From 7464da38458d806aedc46cb8310e3855ab0fdf79 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Tue, 6 Sep 2022 15:30:29 -0500
Subject: add `BindgenOptions::require_syn` method

---
 src/lib.rs | 71 +++++++++++++++++++++++++++++++-------------------------------
 1 file changed, 36 insertions(+), 35 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index b90faba6..fb02fe16 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2029,6 +2029,11 @@ struct BindgenOptions {
 impl ::std::panic::UnwindSafe for BindgenOptions {}
 
 impl BindgenOptions {
+    /// Whether any of the enabled options requires `syn`.
+    fn require_syn(&self) -> bool {
+        self.sort_semantically
+    }
+
     fn build(&mut self) {
         let mut regex_sets = [
             &mut self.allowlisted_vars,
@@ -2455,13 +2460,13 @@ impl Bindings {
 
         let (items, options, warnings) = codegen::codegen(context);
 
-        if options.sort_semantically {
+        let module = if options.require_syn() {
             let module_wrapped_tokens =
                 quote!(mod wrapper_for_sorting_hack { #( #items )* });
 
-            // This semantically sorting business is a hack, for now. This means that we are
-            // re-parsing already generated code using `syn` (as opposed to `quote`) because
-            // `syn` provides us more control over the elements.
+            // This syn business is a hack, for now. This means that we are re-parsing already
+            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+            // control over the elements.
             // One caveat is that some of the items coming from `quote`d output might have
             // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
             // The two `unwrap`s here are deliberate because
@@ -2475,46 +2480,42 @@ impl Bindings {
                     .unwrap()
                     .1;
 
-            syn_parsed_items.sort_by_key(|item| match item {
-                syn::Item::Type(_) => 0,
-                syn::Item::Struct(_) => 1,
-                syn::Item::Const(_) => 2,
-                syn::Item::Fn(_) => 3,
-                syn::Item::Enum(_) => 4,
-                syn::Item::Union(_) => 5,
-                syn::Item::Static(_) => 6,
-                syn::Item::Trait(_) => 7,
-                syn::Item::TraitAlias(_) => 8,
-                syn::Item::Impl(_) => 9,
-                syn::Item::Mod(_) => 10,
-                syn::Item::Use(_) => 11,
-                syn::Item::Verbatim(_) => 12,
-                syn::Item::ExternCrate(_) => 13,
-                syn::Item::ForeignMod(_) => 14,
-                syn::Item::Macro(_) => 15,
-                syn::Item::Macro2(_) => 16,
-                _ => 18,
-            });
+            if options.sort_semantically {
+                syn_parsed_items.sort_by_key(|item| match item {
+                    syn::Item::Type(_) => 0,
+                    syn::Item::Struct(_) => 1,
+                    syn::Item::Const(_) => 2,
+                    syn::Item::Fn(_) => 3,
+                    syn::Item::Enum(_) => 4,
+                    syn::Item::Union(_) => 5,
+                    syn::Item::Static(_) => 6,
+                    syn::Item::Trait(_) => 7,
+                    syn::Item::TraitAlias(_) => 8,
+                    syn::Item::Impl(_) => 9,
+                    syn::Item::Mod(_) => 10,
+                    syn::Item::Use(_) => 11,
+                    syn::Item::Verbatim(_) => 12,
+                    syn::Item::ExternCrate(_) => 13,
+                    syn::Item::ForeignMod(_) => 14,
+                    syn::Item::Macro(_) => 15,
+                    syn::Item::Macro2(_) => 16,
+                    _ => 18,
+                });
+            }
 
             let synful_items = syn_parsed_items
                 .into_iter()
                 .map(|item| item.into_token_stream());
 
-            return Ok(Bindings {
-                options,
-                warnings,
-                module: quote! {
-                    #( #synful_items )*
-                },
-            });
-        }
+            quote! { #( #synful_items )* }
+        } else {
+            quote! { #( #items )* }
+        };
 
         Ok(Bindings {
             options,
             warnings,
-            module: quote! {
-                #( #items )*
-            },
+            module,
         })
     }
 
-- 
cgit v1.2.3


From 8b29355ca0ce54e941d398ef9a605e9b5c0f20ae Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Tue, 6 Sep 2022 16:34:58 -0500
Subject: document usage of `syn` in `CONTRIBUTING.md`

---
 CONTRIBUTING.md | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3fe7539f..2974ba42 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -318,7 +318,19 @@ parameters a given type uses. The analyses are defined in
 
 The final phase is generating Rust source text from the analyzed IR, and it is
 defined in `src/codegen/*`. We use the `quote` crate, which provides the `quote!
-{ ... }` macro for quasi-quoting Rust forms.
+{ ... }` macro for quasi-quoting Rust forms. Some options that affect the
+generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate.
+
+### Implementing new options using `syn`
+
+Here is a list of recommendations to be followed if a new option can be
+implemented using the `syn` crate:
+
+- The `BindgenOptions::require_syn` method must be updated to reflect that this
+  new option requires parsing the generated Rust code with `syn`.
+
+- The implementation of the new option should be added at the end of
+  `Bindings::generate`, inside the `if options.require_syn() { ... }` block.
 
 ## Pull Requests and Code Reviews
 
-- 
cgit v1.2.3


From 61636e94ca315278d9ac5f1210ffca6cca697428 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Tue, 6 Sep 2022 16:59:49 -0500
Subject: add `--newtype-global-enum` option

---
 src/codegen/mod.rs                              | 51 +++++++++++++++++++------
 src/ir/enum_ty.rs                               | 19 ++++++++-
 src/lib.rs                                      | 34 ++++++++++++++---
 src/options.rs                                  | 12 ++++++
 tests/expectations/tests/newtype-global-enum.rs | 12 ++++++
 tests/headers/newtype-global-enum.hpp           |  8 ++++
 6 files changed, 118 insertions(+), 18 deletions(-)
 create mode 100644 tests/expectations/tests/newtype-global-enum.rs
 create mode 100644 tests/headers/newtype-global-enum.hpp

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index ca4cbf23..9a55ea37 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -2577,6 +2577,8 @@ pub enum EnumVariation {
     NewType {
         /// Indicates whether the newtype will have bitwise operators
         is_bitfield: bool,
+        /// Indicates whether the variants will be represented as global constants
+        is_global: bool,
     },
     /// The code for this enum will use consts
     Consts,
@@ -2614,16 +2616,26 @@ impl std::str::FromStr for EnumVariation {
             "rust_non_exhaustive" => Ok(EnumVariation::Rust {
                 non_exhaustive: true,
             }),
-            "bitfield" => Ok(EnumVariation::NewType { is_bitfield: true }),
+            "bitfield" => Ok(EnumVariation::NewType {
+                is_bitfield: true,
+                is_global: false,
+            }),
             "consts" => Ok(EnumVariation::Consts),
             "moduleconsts" => Ok(EnumVariation::ModuleConsts),
-            "newtype" => Ok(EnumVariation::NewType { is_bitfield: false }),
+            "newtype" => Ok(EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: false,
+            }),
+            "newtype_global" => Ok(EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: true,
+            }),
             _ => Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
                 concat!(
                     "Got an invalid EnumVariation. Accepted values ",
                     "are 'rust', 'rust_non_exhaustive', 'bitfield', 'consts',",
-                    "'moduleconsts', and 'newtype'."
+                    "'moduleconsts', 'newtype' and 'newtype_global'."
                 ),
             )),
         }
@@ -2644,6 +2656,7 @@ enum EnumBuilder<'a> {
         canonical_name: &'a str,
         tokens: proc_macro2::TokenStream,
         is_bitfield: bool,
+        is_global: bool,
     },
     Consts {
         variants: Vec<proc_macro2::TokenStream>,
@@ -2684,7 +2697,10 @@ impl<'a> EnumBuilder<'a> {
         let ident = Ident::new(name, Span::call_site());
 
         match enum_variation {
-            EnumVariation::NewType { is_bitfield } => EnumBuilder::NewType {
+            EnumVariation::NewType {
+                is_bitfield,
+                is_global,
+            } => EnumBuilder::NewType {
                 codegen_depth: enum_codegen_depth,
                 canonical_name: name,
                 tokens: quote! {
@@ -2692,6 +2708,7 @@ impl<'a> EnumBuilder<'a> {
                     pub struct #ident (pub #repr);
                 },
                 is_bitfield,
+                is_global,
             },
 
             EnumVariation::Rust { .. } => {
@@ -2792,17 +2809,29 @@ impl<'a> EnumBuilder<'a> {
                 }
             }
 
-            EnumBuilder::NewType { canonical_name, .. } => {
+            EnumBuilder::NewType {
+                canonical_name,
+                is_global,
+                ..
+            } => {
                 if ctx.options().rust_features().associated_const && is_ty_named
                 {
                     let enum_ident = ctx.rust_ident(canonical_name);
                     let variant_ident = ctx.rust_ident(variant_name);
-                    result.push(quote! {
-                        impl #enum_ident {
-                            #doc
-                            pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
-                        }
-                    });
+                    let tokens = quote! {
+                        #doc
+                        pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
+                    };
+
+                    if is_global {
+                        result.push(tokens);
+                    } else {
+                        result.push(quote! {
+                            impl #enum_ident {
+                                #tokens
+                            }
+                        });
+                    }
                 } else {
                     let ident = ctx.rust_ident(match mangling_prefix {
                         Some(prefix) => {
diff --git a/src/ir/enum_ty.rs b/src/ir/enum_ty.rs
index 97455c91..2b039a4f 100644
--- a/src/ir/enum_ty.rs
+++ b/src/ir/enum_ty.rs
@@ -187,10 +187,25 @@ impl Enum {
             &ctx.options().bitfield_enums,
             item,
         ) {
-            EnumVariation::NewType { is_bitfield: true }
+            EnumVariation::NewType {
+                is_bitfield: true,
+                is_global: false,
+            }
         } else if self.is_matching_enum(ctx, &ctx.options().newtype_enums, item)
         {
-            EnumVariation::NewType { is_bitfield: false }
+            EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: false,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().newtype_global_enums,
+            item,
+        ) {
+            EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: true,
+            }
         } else if self.is_matching_enum(
             ctx,
             &ctx.options().rustified_enums,
diff --git a/src/lib.rs b/src/lib.rs
index fb02fe16..112df665 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -279,11 +279,19 @@ impl Builder {
                     codegen::EnumVariation::Rust {
                         non_exhaustive: true,
                     } => "rust_non_exhaustive",
-                    codegen::EnumVariation::NewType { is_bitfield: true } => {
-                        "bitfield"
-                    }
-                    codegen::EnumVariation::NewType { is_bitfield: false } => {
-                        "newtype"
+                    codegen::EnumVariation::NewType {
+                        is_bitfield: true,
+                        ..
+                    } => "bitfield",
+                    codegen::EnumVariation::NewType {
+                        is_bitfield: false,
+                        is_global,
+                    } => {
+                        if is_global {
+                            "newtype_global"
+                        } else {
+                            "newtype"
+                        }
                     }
                     codegen::EnumVariation::Consts => "consts",
                     codegen::EnumVariation::ModuleConsts => "moduleconsts",
@@ -984,6 +992,18 @@ impl Builder {
         self
     }
 
+    /// Mark the given enum (or set of enums, if using a pattern) as a newtype
+    /// whose variants are exposed as global constants.
+    ///
+    /// Regular expressions are supported.
+    ///
+    /// This makes bindgen generate a type that isn't a Rust `enum`. Regular
+    /// expressions are supported.
+    pub fn newtype_global_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.newtype_global_enums.insert(arg);
+        self
+    }
+
     /// Mark the given enum (or set of enums, if using a pattern) as a Rust
     /// enum.
     ///
@@ -1759,6 +1779,9 @@ struct BindgenOptions {
     /// The enum patterns to mark an enum as a newtype.
     newtype_enums: RegexSet,
 
+    /// The enum patterns to mark an enum as a global newtype.
+    newtype_global_enums: RegexSet,
+
     /// The enum patterns to mark an enum as a Rust enum.
     rustified_enums: RegexSet,
 
@@ -2102,6 +2125,7 @@ impl Default for BindgenOptions {
             default_enum_style: Default::default(),
             bitfield_enums: Default::default(),
             newtype_enums: Default::default(),
+            newtype_global_enums: Default::default(),
             rustified_enums: Default::default(),
             rustified_non_exhaustive_enums: Default::default(),
             constified_enums: Default::default(),
diff --git a/src/options.rs b/src/options.rs
index 83da21f4..4db3fd57 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -63,6 +63,12 @@ where
                 .value_name("regex")
                 .multiple_occurrences(true)
                 .number_of_values(1),
+            Arg::new("newtype-global-enum")
+                .long("newtype-global-enum")
+                .help("Mark any enum whose name matches <regex> as a global newtype.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
             Arg::new("rustified-enum")
                 .long("rustified-enum")
                 .help("Mark any enum whose name matches <regex> as a Rust enum.")
@@ -573,6 +579,12 @@ where
         }
     }
 
+    if let Some(newtypes) = matches.values_of("newtype-global-enum") {
+        for regex in newtypes {
+            builder = builder.newtype_global_enum(regex);
+        }
+    }
+
     if let Some(rustifieds) = matches.values_of("rustified-enum") {
         for regex in rustifieds {
             builder = builder.rustified_enum(regex);
diff --git a/tests/expectations/tests/newtype-global-enum.rs b/tests/expectations/tests/newtype-global-enum.rs
new file mode 100644
index 00000000..ff980637
--- /dev/null
+++ b/tests/expectations/tests/newtype-global-enum.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const Foo_Bar: Foo = 2;
+pub const Foo_Baz: Foo = 4;
+pub const Foo_Duplicated: Foo = 4;
+pub const Foo_Negative: Foo = -3;
+pub type Foo = ::std::os::raw::c_int;
diff --git a/tests/headers/newtype-global-enum.hpp b/tests/headers/newtype-global-enum.hpp
new file mode 100644
index 00000000..8021a3cc
--- /dev/null
+++ b/tests/headers/newtype-global-enum.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --newtype-global-enum "Foo" --rust-target 1.28  -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
-- 
cgit v1.2.3


From 0d805d70d5c6e4cc99cbad7a988c38bdfe52321b Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 12 Sep 2022 13:45:54 -0500
Subject: fix `--newtype-global-enum` option

---
 src/codegen/mod.rs                              | 23 +++++++++--------------
 src/lib.rs                                      |  2 ++
 tests/expectations/tests/newtype-global-enum.rs | 12 +++++++-----
 3 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 9a55ea37..f523232e 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -2814,24 +2814,19 @@ impl<'a> EnumBuilder<'a> {
                 is_global,
                 ..
             } => {
-                if ctx.options().rust_features().associated_const && is_ty_named
+                if ctx.options().rust_features().associated_const &&
+                    is_ty_named &&
+                    !is_global
                 {
                     let enum_ident = ctx.rust_ident(canonical_name);
                     let variant_ident = ctx.rust_ident(variant_name);
-                    let tokens = quote! {
-                        #doc
-                        pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
-                    };
 
-                    if is_global {
-                        result.push(tokens);
-                    } else {
-                        result.push(quote! {
-                            impl #enum_ident {
-                                #tokens
-                            }
-                        });
-                    }
+                    result.push(quote! {
+                        impl #enum_ident {
+                            #doc
+                            pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
+                        }
+                    });
                 } else {
                     let ident = ctx.rust_ident(match mangling_prefix {
                         Some(prefix) => {
diff --git a/src/lib.rs b/src/lib.rs
index 112df665..8c41565a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -315,6 +315,7 @@ impl Builder {
         let regex_sets = &[
             (&self.options.bitfield_enums, "--bitfield-enum"),
             (&self.options.newtype_enums, "--newtype-enum"),
+            (&self.options.newtype_global_enums, "--newtype-global-enum"),
             (&self.options.rustified_enums, "--rustified-enum"),
             (
                 &self.options.rustified_non_exhaustive_enums,
@@ -2072,6 +2073,7 @@ impl BindgenOptions {
             &mut self.constified_enums,
             &mut self.constified_enum_modules,
             &mut self.newtype_enums,
+            &mut self.newtype_global_enums,
             &mut self.rustified_enums,
             &mut self.rustified_non_exhaustive_enums,
             &mut self.type_alias,
diff --git a/tests/expectations/tests/newtype-global-enum.rs b/tests/expectations/tests/newtype-global-enum.rs
index ff980637..cf23cca6 100644
--- a/tests/expectations/tests/newtype-global-enum.rs
+++ b/tests/expectations/tests/newtype-global-enum.rs
@@ -5,8 +5,10 @@
     non_upper_case_globals
 )]
 
-pub const Foo_Bar: Foo = 2;
-pub const Foo_Baz: Foo = 4;
-pub const Foo_Duplicated: Foo = 4;
-pub const Foo_Negative: Foo = -3;
-pub type Foo = ::std::os::raw::c_int;
+pub const Foo_Bar: Foo = Foo(2);
+pub const Foo_Baz: Foo = Foo(4);
+pub const Foo_Duplicated: Foo = Foo(4);
+pub const Foo_Negative: Foo = Foo(-3);
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
-- 
cgit v1.2.3


From 6a100c0b32fae6dca5148636bb00c1f8ecd234ca Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 29 Aug 2022 11:37:01 -0500
Subject: add `is_divergent` field

---
 src/ir/function.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/ir/function.rs b/src/ir/function.rs
index 27192bcf..afbb9024 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -228,6 +228,7 @@ pub struct FunctionSig {
 
     /// Whether this function is variadic.
     is_variadic: bool,
+    is_divergent: bool,
 
     /// Whether this function's return value must be used.
     must_use: bool,
@@ -358,6 +359,7 @@ impl FunctionSig {
         return_type: TypeId,
         argument_types: Vec<(Option<String>, TypeId)>,
         is_variadic: bool,
+        is_divergent: bool,
         must_use: bool,
         abi: Abi,
     ) -> Self {
@@ -365,6 +367,7 @@ impl FunctionSig {
             return_type,
             argument_types,
             is_variadic,
+            is_divergent,
             must_use,
             abi,
         }
@@ -528,7 +531,7 @@ impl FunctionSig {
             warn!("Unknown calling convention: {:?}", call_conv);
         }
 
-        Ok(Self::new(ret, args, ty.is_variadic(), must_use, abi))
+        Ok(Self::new(ret, args, ty.is_variadic(), false, must_use, abi))
     }
 
     /// Get this function signature's return type.
-- 
cgit v1.2.3


From 250150d0159ef02b35f65cd83d71d60f0439ee95 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 31 Aug 2022 14:38:26 -0500
Subject: check for noreturn attribute

---
 src/clang.rs       | 18 ++++++++++++++++++
 src/codegen/mod.rs |  4 ++++
 src/ir/function.rs | 14 +++++++++++++-
 3 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/src/clang.rs b/src/clang.rs
index 2aab9618..5579c42b 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -645,6 +645,24 @@ impl Cursor {
         self.has_attr("warn_unused_result", Some(CXCursor_WarnUnusedResultAttr))
     }
 
+    pub fn has_no_return_attr(&self) -> bool {
+        let mut found_attr = false;
+        self.visit(|cur| {
+            found_attr = cur.kind() == CXCursor_UnexposedAttr &&
+                cur.tokens().iter().any(|t| {
+                    t.kind == CXToken_Keyword && t.spelling() == b"_Noreturn"
+                });
+
+            if found_attr {
+                CXChildVisit_Break
+            } else {
+                CXChildVisit_Continue
+            }
+        });
+
+        found_attr
+    }
+
     /// Does this cursor have the given attribute?
     ///
     /// `name` is checked against unexposed attributes.
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index f523232e..f1422d6b 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -4729,6 +4729,10 @@ pub mod utils {
         ctx: &BindgenContext,
         sig: &FunctionSig,
     ) -> proc_macro2::TokenStream {
+        if sig.is_divergent() {
+            return quote! { -> ! };
+        }
+
         let return_item = ctx.resolve_item(sig.return_type());
         if let TypeKind::Void = *return_item.kind().expect_type().kind() {
             quote! {}
diff --git a/src/ir/function.rs b/src/ir/function.rs
index afbb9024..6b59649c 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -381,6 +381,7 @@ impl FunctionSig {
     ) -> Result<Self, ParseError> {
         use clang_sys::*;
         debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
+        let is_divergent = cursor.has_no_return_attr();
 
         // Skip function templates
         let kind = cursor.kind();
@@ -531,7 +532,14 @@ impl FunctionSig {
             warn!("Unknown calling convention: {:?}", call_conv);
         }
 
-        Ok(Self::new(ret, args, ty.is_variadic(), false, must_use, abi))
+        Ok(Self::new(
+            ret,
+            args,
+            ty.is_variadic(),
+            is_divergent,
+            must_use,
+            abi,
+        ))
     }
 
     /// Get this function signature's return type.
@@ -578,6 +586,10 @@ impl FunctionSig {
 
         matches!(self.abi, Abi::C | Abi::Unknown(..))
     }
+
+    pub(crate) fn is_divergent(&self) -> bool {
+        self.is_divergent
+    }
 }
 
 impl ClangSubItemParser for Function {
-- 
cgit v1.2.3


From 1704775d9183ae757cc67c16af267a517dac5a7c Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 31 Aug 2022 14:44:42 -0500
Subject: add tests

---
 tests/expectations/tests/noreturn.rs | 13 +++++++++++++
 tests/headers/noreturn.h             |  3 +++
 2 files changed, 16 insertions(+)
 create mode 100644 tests/expectations/tests/noreturn.rs
 create mode 100644 tests/headers/noreturn.h

diff --git a/tests/expectations/tests/noreturn.rs b/tests/expectations/tests/noreturn.rs
new file mode 100644
index 00000000..fa81ee76
--- /dev/null
+++ b/tests/expectations/tests/noreturn.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn f() -> !;
+}
+extern "C" {
+    pub fn g();
+}
diff --git a/tests/headers/noreturn.h b/tests/headers/noreturn.h
new file mode 100644
index 00000000..9ce68518
--- /dev/null
+++ b/tests/headers/noreturn.h
@@ -0,0 +1,3 @@
+_Noreturn void f(void);
+// TODO (pvdrz): figure out how to handle this case.
+__attribute__((noreturn)) void g(void);
-- 
cgit v1.2.3


From b8f3920ad11b82673d06f2d25bb663e2b7efe491 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 10:54:48 -0500
Subject: add `CxTokenKind` argument to `has_attr`

---
 src/clang.rs | 33 ++++++++++++++-------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/clang.rs b/src/clang.rs
index 5579c42b..4779e0b7 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -642,39 +642,34 @@ impl Cursor {
     pub fn has_warn_unused_result_attr(&self) -> bool {
         // FIXME(emilio): clang-sys doesn't expose this (from clang 9).
         const CXCursor_WarnUnusedResultAttr: CXCursorKind = 440;
-        self.has_attr("warn_unused_result", Some(CXCursor_WarnUnusedResultAttr))
+        self.has_attr(
+            "warn_unused_result",
+            Some(CXCursor_WarnUnusedResultAttr),
+            CXToken_Identifier,
+        )
     }
 
+    /// Check wether this cursor has the `_Noreturn` attribute.
     pub fn has_no_return_attr(&self) -> bool {
-        let mut found_attr = false;
-        self.visit(|cur| {
-            found_attr = cur.kind() == CXCursor_UnexposedAttr &&
-                cur.tokens().iter().any(|t| {
-                    t.kind == CXToken_Keyword && t.spelling() == b"_Noreturn"
-                });
-
-            if found_attr {
-                CXChildVisit_Break
-            } else {
-                CXChildVisit_Continue
-            }
-        });
-
-        found_attr
+        self.has_attr("_Noreturn", None, CXToken_Keyword)
     }
 
     /// Does this cursor have the given attribute?
     ///
     /// `name` is checked against unexposed attributes.
-    fn has_attr(&self, name: &str, clang_kind: Option<CXCursorKind>) -> bool {
+    fn has_attr(
+        &self,
+        name: &str,
+        clang_kind: Option<CXCursorKind>,
+        token_kind: CXTokenKind,
+    ) -> bool {
         let mut found_attr = false;
         self.visit(|cur| {
             let kind = cur.kind();
             found_attr = clang_kind.map_or(false, |k| k == kind) ||
                 (kind == CXCursor_UnexposedAttr &&
                     cur.tokens().iter().any(|t| {
-                        t.kind == CXToken_Identifier &&
-                            t.spelling() == name.as_bytes()
+                        t.kind == token_kind && t.spelling() == name.as_bytes()
                     }));
 
             if found_attr {
-- 
cgit v1.2.3


From 3da6026afd5715715feeb4a8668a91024d71830e Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 10:59:06 -0500
Subject: gate `_Noreturn` detection behind
 `--enable-fucntion-attribute-detection`

---
 src/ir/function.rs       | 4 +++-
 tests/headers/noreturn.h | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/ir/function.rs b/src/ir/function.rs
index 6b59649c..b829e601 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -381,7 +381,9 @@ impl FunctionSig {
     ) -> Result<Self, ParseError> {
         use clang_sys::*;
         debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
-        let is_divergent = cursor.has_no_return_attr();
+
+        let is_divergent = ctx.options().enable_function_attribute_detection &&
+            cursor.has_no_return_attr();
 
         // Skip function templates
         let kind = cursor.kind();
diff --git a/tests/headers/noreturn.h b/tests/headers/noreturn.h
index 9ce68518..0e4819e2 100644
--- a/tests/headers/noreturn.h
+++ b/tests/headers/noreturn.h
@@ -1,3 +1,4 @@
+// bindgen-flags: --enable-function-attribute-detection
 _Noreturn void f(void);
 // TODO (pvdrz): figure out how to handle this case.
 __attribute__((noreturn)) void g(void);
-- 
cgit v1.2.3


From 2251aed4d0a2422d7b94cceeafcfe9ac98a69ad6 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 11:26:47 -0500
Subject: find all attributes in a single pass

---
 src/clang.rs       | 83 +++++++++++++++++++++++++++++++-----------------------
 src/ir/function.rs | 14 +++++----
 2 files changed, 55 insertions(+), 42 deletions(-)

diff --git a/src/clang.rs b/src/clang.rs
index 4779e0b7..05ef5d05 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -12,6 +12,27 @@ use std::hash::Hasher;
 use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
 use std::{mem, ptr, slice};
 
+pub struct Attribute {
+    name: &'static [u8],
+    kind: CXCursorKind,
+    token_kind: CXTokenKind,
+}
+
+impl Attribute {
+    pub const MUST_USE: Self = Self {
+        name: b"warn_unused_result",
+        // FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
+        kind: 440,
+        token_kind: CXToken_Identifier,
+    };
+
+    pub const NO_RETURN: Self = Self {
+        name: b"_Noreturn",
+        kind: CXCursor_UnexposedAttr,
+        token_kind: CXToken_Keyword,
+    };
+}
+
 /// A cursor into the Clang AST, pointing to an AST node.
 ///
 /// We call the AST node pointed to by the cursor the cursor's "referent".
@@ -638,48 +659,38 @@ impl Cursor {
         }
     }
 
-    /// Whether this cursor has the `warn_unused_result` attribute.
-    pub fn has_warn_unused_result_attr(&self) -> bool {
-        // FIXME(emilio): clang-sys doesn't expose this (from clang 9).
-        const CXCursor_WarnUnusedResultAttr: CXCursorKind = 440;
-        self.has_attr(
-            "warn_unused_result",
-            Some(CXCursor_WarnUnusedResultAttr),
-            CXToken_Identifier,
-        )
-    }
-
-    /// Check wether this cursor has the `_Noreturn` attribute.
-    pub fn has_no_return_attr(&self) -> bool {
-        self.has_attr("_Noreturn", None, CXToken_Keyword)
-    }
-
-    /// Does this cursor have the given attribute?
-    ///
-    /// `name` is checked against unexposed attributes.
-    fn has_attr(
+    pub fn has_attrs<const N: usize>(
         &self,
-        name: &str,
-        clang_kind: Option<CXCursorKind>,
-        token_kind: CXTokenKind,
-    ) -> bool {
-        let mut found_attr = false;
+        attrs: &[Attribute; N],
+    ) -> [bool; N] {
+        let mut found_attrs = [false; N];
+        let mut found_count = 0;
+
         self.visit(|cur| {
             let kind = cur.kind();
-            found_attr = clang_kind.map_or(false, |k| k == kind) ||
-                (kind == CXCursor_UnexposedAttr &&
-                    cur.tokens().iter().any(|t| {
-                        t.kind == token_kind && t.spelling() == name.as_bytes()
-                    }));
-
-            if found_attr {
-                CXChildVisit_Break
-            } else {
-                CXChildVisit_Continue
+            for (idx, attr) in attrs.iter().enumerate() {
+                let found_attr = &mut found_attrs[idx];
+                if !*found_attr {
+                    if kind == attr.kind &&
+                        cur.tokens().iter().any(|t| {
+                            t.kind == attr.token_kind &&
+                                t.spelling() == attr.name
+                        })
+                    {
+                        *found_attr = true;
+                        found_count += 1;
+
+                        if found_count == N {
+                            return CXChildVisit_Break;
+                        }
+                    }
+                }
             }
+
+            CXChildVisit_Continue
         });
 
-        found_attr
+        found_attrs
     }
 
     /// Given that this cursor's referent is a `typedef`, get the `Type` that is
diff --git a/src/ir/function.rs b/src/ir/function.rs
index b829e601..6ed3a503 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -6,7 +6,7 @@ use super::dot::DotAttributes;
 use super::item::Item;
 use super::traversal::{EdgeKind, Trace, Tracer};
 use super::ty::TypeKind;
-use crate::clang;
+use crate::clang::{self, Attribute};
 use crate::parse::{
     ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
 };
@@ -382,9 +382,6 @@ impl FunctionSig {
         use clang_sys::*;
         debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
 
-        let is_divergent = ctx.options().enable_function_attribute_detection &&
-            cursor.has_no_return_attr();
-
         // Skip function templates
         let kind = cursor.kind();
         if kind == CXCursor_FunctionTemplate {
@@ -453,8 +450,13 @@ impl FunctionSig {
             }
         };
 
-        let must_use = ctx.options().enable_function_attribute_detection &&
-            cursor.has_warn_unused_result_attr();
+        let [must_use, is_divergent] =
+            if ctx.options().enable_function_attribute_detection {
+                cursor.has_attrs(&[Attribute::MUST_USE, Attribute::NO_RETURN])
+            } else {
+                Default::default()
+            };
+
         let is_method = kind == CXCursor_CXXMethod;
         let is_constructor = kind == CXCursor_Constructor;
         let is_destructor = kind == CXCursor_Destructor;
-- 
cgit v1.2.3


From 15f5094d45a8858ba2d244dc8c6f018a28d48eaa Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 12:16:43 -0500
Subject: document `Attribute`

---
 src/clang.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/clang.rs b/src/clang.rs
index 05ef5d05..d66fe445 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -12,6 +12,10 @@ use std::hash::Hasher;
 use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
 use std::{mem, ptr, slice};
 
+/// Type representing a clang attribute.
+///
+/// Values of this type can be used to check for different attributes using the `has_attrs`
+/// function.
 pub struct Attribute {
     name: &'static [u8],
     kind: CXCursorKind,
@@ -19,6 +23,7 @@ pub struct Attribute {
 }
 
 impl Attribute {
+    /// A `warn_unused_result` attribute.
     pub const MUST_USE: Self = Self {
         name: b"warn_unused_result",
         // FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
@@ -26,6 +31,7 @@ impl Attribute {
         token_kind: CXToken_Identifier,
     };
 
+    /// A `_Noreturn` attribute.
     pub const NO_RETURN: Self = Self {
         name: b"_Noreturn",
         kind: CXCursor_UnexposedAttr,
-- 
cgit v1.2.3


From fb5f9b963cfd6ca878d908be7b237177462f4ddb Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 12:17:36 -0500
Subject: document `has_attrs`

---
 src/clang.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/clang.rs b/src/clang.rs
index d66fe445..0fcccaa4 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -665,6 +665,7 @@ impl Cursor {
         }
     }
 
+    /// Does this cursor have the given attributes?
     pub fn has_attrs<const N: usize>(
         &self,
         attrs: &[Attribute; N],
-- 
cgit v1.2.3


From e503476a96636df41532b988f8f8f0c318fff24a Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 12:36:11 -0500
Subject: bring back optional cursor kind

---
 src/clang.rs | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/clang.rs b/src/clang.rs
index 0fcccaa4..fddb261c 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -18,7 +18,7 @@ use std::{mem, ptr, slice};
 /// function.
 pub struct Attribute {
     name: &'static [u8],
-    kind: CXCursorKind,
+    kind: Option<CXCursorKind>,
     token_kind: CXTokenKind,
 }
 
@@ -27,14 +27,14 @@ impl Attribute {
     pub const MUST_USE: Self = Self {
         name: b"warn_unused_result",
         // FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
-        kind: 440,
+        kind: Some(440),
         token_kind: CXToken_Identifier,
     };
 
     /// A `_Noreturn` attribute.
     pub const NO_RETURN: Self = Self {
         name: b"_Noreturn",
-        kind: CXCursor_UnexposedAttr,
+        kind: None,
         token_kind: CXToken_Keyword,
     };
 }
@@ -678,11 +678,13 @@ impl Cursor {
             for (idx, attr) in attrs.iter().enumerate() {
                 let found_attr = &mut found_attrs[idx];
                 if !*found_attr {
-                    if kind == attr.kind &&
-                        cur.tokens().iter().any(|t| {
-                            t.kind == attr.token_kind &&
-                                t.spelling() == attr.name
-                        })
+                    // `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
+                    if attr.kind.map_or(false, |k| k == kind) ||
+                        (kind == CXCursor_UnexposedAttr &&
+                            cur.tokens().iter().any(|t| {
+                                t.kind == attr.token_kind &&
+                                    t.spelling() == attr.name
+                            }))
                     {
                         *found_attr = true;
                         found_count += 1;
-- 
cgit v1.2.3


From 2ffc8d8946a44f2a695a0c148ad24e7e0e9637d2 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 15:59:37 -0500
Subject: handle c++ `[[noreturn]]` attribute

---
 src/clang.rs                         |  7 +++++++
 src/ir/function.rs                   |  9 +++++++--
 tests/expectations/tests/noreturn.rs | 10 ++++++++--
 tests/headers/noreturn.h             |  4 ----
 tests/headers/noreturn.hpp           |  5 +++++
 5 files changed, 27 insertions(+), 8 deletions(-)
 delete mode 100644 tests/headers/noreturn.h
 create mode 100644 tests/headers/noreturn.hpp

diff --git a/src/clang.rs b/src/clang.rs
index fddb261c..ea505c87 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -37,6 +37,13 @@ impl Attribute {
         kind: None,
         token_kind: CXToken_Keyword,
     };
+
+    /// A `[[noreturn]]` attribute.
+    pub const NO_RETURN_CPP: Self = Self {
+        name: b"noreturn",
+        kind: None,
+        token_kind: CXToken_Identifier,
+    };
 }
 
 /// A cursor into the Clang AST, pointing to an AST node.
diff --git a/src/ir/function.rs b/src/ir/function.rs
index 6ed3a503..a967954e 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -450,9 +450,14 @@ impl FunctionSig {
             }
         };
 
-        let [must_use, is_divergent] =
+        let (must_use, is_divergent) =
             if ctx.options().enable_function_attribute_detection {
-                cursor.has_attrs(&[Attribute::MUST_USE, Attribute::NO_RETURN])
+                let [must_use, no_return, no_return_cpp] = cursor.has_attrs(&[
+                    Attribute::MUST_USE,
+                    Attribute::NO_RETURN,
+                    Attribute::NO_RETURN_CPP,
+                ]);
+                (must_use, no_return || no_return_cpp)
             } else {
                 Default::default()
             };
diff --git a/tests/expectations/tests/noreturn.rs b/tests/expectations/tests/noreturn.rs
index fa81ee76..1ffce9c0 100644
--- a/tests/expectations/tests/noreturn.rs
+++ b/tests/expectations/tests/noreturn.rs
@@ -6,8 +6,14 @@
 )]
 
 extern "C" {
-    pub fn f() -> !;
+    #[link_name = "\u{1}_Z1fv"]
+     pub fn f() -> !;
 }
 extern "C" {
-    pub fn g();
+    #[link_name = "\u{1}_Z1gv"]
+     pub fn g();
+}
+extern "C" {
+    #[link_name = "\u{1}_Z1hv"]
+    pub fn h() -> !;
 }
diff --git a/tests/headers/noreturn.h b/tests/headers/noreturn.h
deleted file mode 100644
index 0e4819e2..00000000
--- a/tests/headers/noreturn.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --enable-function-attribute-detection
-_Noreturn void f(void);
-// TODO (pvdrz): figure out how to handle this case.
-__attribute__((noreturn)) void g(void);
diff --git a/tests/headers/noreturn.hpp b/tests/headers/noreturn.hpp
new file mode 100644
index 00000000..deaa3b1a
--- /dev/null
+++ b/tests/headers/noreturn.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --enable-function-attribute-detection
+_Noreturn void f(void);
+// TODO (pvdrz): figure out how to handle this case.
+__attribute__((noreturn)) void g(void);
+[[noreturn]] void h(void);
-- 
cgit v1.2.3


From 953acc526a808dac53660cee79c68d15ac309a63 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 16:11:05 -0500
Subject: handle `__attribute__((noreturn))` attribute

---
 src/ir/function.rs                   | 7 ++++++-
 tests/expectations/tests/noreturn.rs | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/ir/function.rs b/src/ir/function.rs
index a967954e..928b5aad 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -450,7 +450,7 @@ impl FunctionSig {
             }
         };
 
-        let (must_use, is_divergent) =
+        let (must_use, mut is_divergent) =
             if ctx.options().enable_function_attribute_detection {
                 let [must_use, no_return, no_return_cpp] = cursor.has_attrs(&[
                     Attribute::MUST_USE,
@@ -462,6 +462,11 @@ impl FunctionSig {
                 Default::default()
             };
 
+        // This looks easy to break but the clang parser keeps the type spelling clean even if
+        // other attributes are added.
+        is_divergent =
+            is_divergent || ty.spelling().contains("__attribute__((noreturn))");
+
         let is_method = kind == CXCursor_CXXMethod;
         let is_constructor = kind == CXCursor_Constructor;
         let is_destructor = kind == CXCursor_Destructor;
diff --git a/tests/expectations/tests/noreturn.rs b/tests/expectations/tests/noreturn.rs
index 1ffce9c0..19457495 100644
--- a/tests/expectations/tests/noreturn.rs
+++ b/tests/expectations/tests/noreturn.rs
@@ -11,7 +11,7 @@ extern "C" {
 }
 extern "C" {
     #[link_name = "\u{1}_Z1gv"]
-     pub fn g();
+     pub fn g() -> !;
 }
 extern "C" {
     #[link_name = "\u{1}_Z1hv"]
-- 
cgit v1.2.3


From 86f059f081160ba01de31fc2ec6e20e52b97968d Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 1 Sep 2022 16:24:38 -0500
Subject: add the `-- -std=c++11` flag

---
 tests/headers/noreturn.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/headers/noreturn.hpp b/tests/headers/noreturn.hpp
index deaa3b1a..4ce1e11e 100644
--- a/tests/headers/noreturn.hpp
+++ b/tests/headers/noreturn.hpp
@@ -1,5 +1,4 @@
-// bindgen-flags: --enable-function-attribute-detection
+// bindgen-flags: --enable-function-attribute-detection -- -std=c++11
 _Noreturn void f(void);
-// TODO (pvdrz): figure out how to handle this case.
 __attribute__((noreturn)) void g(void);
 [[noreturn]] void h(void);
-- 
cgit v1.2.3


From 04c0cd0ff45ff3f47d845c2b3b983e2dc06b9ca3 Mon Sep 17 00:00:00 2001
From: Poliorcetics <poliorcetics@users.noreply.github.com>
Date: Fri, 23 Sep 2022 08:30:49 +0200
Subject: Option to wrap union members in ManuallyDrop (#2185)

---
 src/codegen/mod.rs                                 | 153 ++++++++++---
 src/lib.rs                                         |  59 ++++-
 src/options.rs                                     |  61 +++++-
 .../tests/union_with_non_copy_member.rs            | 239 +++++++++++++++++++++
 tests/headers/union_with_non_copy_member.h         |  20 ++
 5 files changed, 499 insertions(+), 33 deletions(-)
 create mode 100644 tests/expectations/tests/union_with_non_copy_member.rs
 create mode 100644 tests/headers/union_with_non_copy_member.h

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index f1422d6b..98ab922a 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1231,7 +1231,7 @@ trait FieldCodegen<'a> {
 }
 
 impl<'a> FieldCodegen<'a> for Field {
-    type Extra = ();
+    type Extra = &'a str;
 
     fn codegen<F, M>(
         &self,
@@ -1244,7 +1244,7 @@ impl<'a> FieldCodegen<'a> for Field {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        _: (),
+        parent_canonical_name: Self::Extra,
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1261,7 +1261,7 @@ impl<'a> FieldCodegen<'a> for Field {
                     struct_layout,
                     fields,
                     methods,
-                    (),
+                    parent_canonical_name,
                 );
             }
             Field::Bitfields(ref unit) => {
@@ -1275,7 +1275,7 @@ impl<'a> FieldCodegen<'a> for Field {
                     struct_layout,
                     fields,
                     methods,
-                    (),
+                    parent_canonical_name,
                 );
             }
         }
@@ -1283,7 +1283,7 @@ impl<'a> FieldCodegen<'a> for Field {
 }
 
 impl<'a> FieldCodegen<'a> for FieldData {
-    type Extra = ();
+    type Extra = &'a str;
 
     fn codegen<F, M>(
         &self,
@@ -1296,7 +1296,7 @@ impl<'a> FieldCodegen<'a> for FieldData {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        _: (),
+        parent_canonical_name: Self::Extra,
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1313,16 +1313,7 @@ impl<'a> FieldCodegen<'a> for FieldData {
 
         // NB: If supported, we use proper `union` types.
         let ty = if parent.is_union() && !struct_layout.is_rust_union() {
-            result.saw_bindgen_union();
-            if ctx.options().enable_cxx_namespaces {
-                quote! {
-                    root::__BindgenUnionField<#ty>
-                }
-            } else {
-                quote! {
-                    __BindgenUnionField<#ty>
-                }
-            }
+            wrap_non_copy_type_for_union(ctx, parent_canonical_name, result, ty)
         } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
             result.saw_incomplete_array();
 
@@ -1433,6 +1424,54 @@ impl<'a> FieldCodegen<'a> for FieldData {
     }
 }
 
+fn wrap_non_copy_type_for_union(
+    ctx: &BindgenContext,
+    parent_canonical_name: &str,
+    result: &mut CodegenResult,
+    field_ty: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+    let union_style = union_style_from_ctx_and_name(ctx, parent_canonical_name);
+
+    match union_style {
+        NonCopyUnionStyle::ManuallyDrop => {
+            if ctx.options().use_core {
+                quote! {
+                    ::core::mem::ManuallyDrop<#field_ty>
+                }
+            } else {
+                quote! {
+                    ::std::mem::ManuallyDrop<#field_ty>
+                }
+            }
+        }
+        NonCopyUnionStyle::BindgenWrapper => {
+            result.saw_bindgen_union();
+            if ctx.options().enable_cxx_namespaces {
+                quote! {
+                    root::__BindgenUnionField<#field_ty>
+                }
+            } else {
+                quote! {
+                    __BindgenUnionField<#field_ty>
+                }
+            }
+        }
+    }
+}
+
+fn union_style_from_ctx_and_name(
+    ctx: &BindgenContext,
+    canonical_name: &str,
+) -> NonCopyUnionStyle {
+    if ctx.options().bindgen_wrapper_union.matches(canonical_name) {
+        NonCopyUnionStyle::BindgenWrapper
+    } else if ctx.options().manually_drop_union.matches(canonical_name) {
+        NonCopyUnionStyle::ManuallyDrop
+    } else {
+        ctx.options().default_non_copy_union_style
+    }
+}
+
 impl BitfieldUnit {
     /// Get the constructor name for this bitfield unit.
     fn ctor_name(&self) -> proc_macro2::TokenStream {
@@ -1499,7 +1538,7 @@ fn access_specifier(
 }
 
 impl<'a> FieldCodegen<'a> for BitfieldUnit {
-    type Extra = ();
+    type Extra = &'a str;
 
     fn codegen<F, M>(
         &self,
@@ -1512,7 +1551,7 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        _: (),
+        parent_canonical_name: Self::Extra,
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1525,16 +1564,12 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
         let unit_field_ty = helpers::bitfield_unit(ctx, layout);
         let field_ty = {
             if parent.is_union() && !struct_layout.is_rust_union() {
-                result.saw_bindgen_union();
-                if ctx.options().enable_cxx_namespaces {
-                    quote! {
-                        root::__BindgenUnionField<#unit_field_ty>
-                    }
-                } else {
-                    quote! {
-                        __BindgenUnionField<#unit_field_ty>
-                    }
-                }
+                wrap_non_copy_type_for_union(
+                    ctx,
+                    parent_canonical_name,
+                    result,
+                    unit_field_ty.clone(),
+                )
             } else {
                 unit_field_ty.clone()
             }
@@ -1859,7 +1894,7 @@ impl CodeGenerator for CompInfo {
                     &mut struct_layout,
                     &mut fields,
                     &mut methods,
-                    (),
+                    &canonical_name,
                 );
             }
             // Check whether an explicit padding field is needed
@@ -1965,7 +2000,10 @@ impl CodeGenerator for CompInfo {
                 explicit_align = Some(layout.align);
             }
 
-            if !struct_layout.is_rust_union() {
+            if !struct_layout.is_rust_union() &&
+                union_style_from_ctx_and_name(ctx, &canonical_name) ==
+                    NonCopyUnionStyle::BindgenWrapper
+            {
                 let ty = helpers::blob(ctx, layout);
                 fields.push(quote! {
                     pub bindgen_union_field: #ty ,
@@ -2092,6 +2130,15 @@ impl CodeGenerator for CompInfo {
                 #( #attributes )*
                 pub union #canonical_ident
             }
+        } else if is_union &&
+            !struct_layout.is_rust_union() &&
+            union_style_from_ctx_and_name(ctx, &canonical_name) ==
+                NonCopyUnionStyle::ManuallyDrop
+        {
+            quote! {
+                #( #attributes )*
+                pub union #canonical_ident
+            }
         } else {
             quote! {
                 #( #attributes )*
@@ -3398,6 +3445,52 @@ impl std::str::FromStr for AliasVariation {
     }
 }
 
+/// Enum for how non-Copy unions should be translated.
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum NonCopyUnionStyle {
+    /// Wrap members in a type generated by bindgen.
+    BindgenWrapper,
+    /// Wrap members in [`::core::mem::ManuallyDrop`].
+    ///
+    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
+    /// MSRV is lower.
+    ManuallyDrop,
+}
+
+impl NonCopyUnionStyle {
+    /// Convert an `NonCopyUnionStyle` to its str representation.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::BindgenWrapper => "bindgen_wrapper",
+            Self::ManuallyDrop => "manually_drop",
+        }
+    }
+}
+
+impl Default for NonCopyUnionStyle {
+    fn default() -> Self {
+        Self::BindgenWrapper
+    }
+}
+
+impl std::str::FromStr for NonCopyUnionStyle {
+    type Err = std::io::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "bindgen_wrapper" => Ok(Self::BindgenWrapper),
+            "manually_drop" => Ok(Self::ManuallyDrop),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid NonCopyUnionStyle. Accepted values ",
+                    "are 'bindgen_wrapper' and 'manually_drop'"
+                ),
+            )),
+        }
+    }
+}
+
 /// Fallible conversion to an opaque blob.
 ///
 /// Implementors of this trait should provide the `try_get_layout` method to
diff --git a/src/lib.rs b/src/lib.rs
index 8c41565a..c7fccb98 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -66,7 +66,9 @@ doc_mod!(ir, ir_docs);
 doc_mod!(parse, parse_docs);
 doc_mod!(regex_set, regex_set_docs);
 
-pub use crate::codegen::{AliasVariation, EnumVariation, MacroTypeVariation};
+pub use crate::codegen::{
+    AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
+};
 use crate::features::RustFeatures;
 pub use crate::features::{
     RustTarget, LATEST_STABLE_RUST, RUST_TARGET_STRINGS,
@@ -312,6 +314,13 @@ impl Builder {
                 .push(self.options.default_alias_style.as_str().into());
         }
 
+        if self.options.default_non_copy_union_style != Default::default() {
+            output_vector.push("--default-non-copy-union-style".into());
+            output_vector.push(
+                self.options.default_non_copy_union_style.as_str().into(),
+            );
+        }
+
         let regex_sets = &[
             (&self.options.bitfield_enums, "--bitfield-enum"),
             (&self.options.newtype_enums, "--newtype-enum"),
@@ -329,6 +338,11 @@ impl Builder {
             (&self.options.type_alias, "--type-alias"),
             (&self.options.new_type_alias, "--new-type-alias"),
             (&self.options.new_type_alias_deref, "--new-type-alias-deref"),
+            (
+                &self.options.bindgen_wrapper_union,
+                "--bindgen-wrapper-union",
+            ),
+            (&self.options.manually_drop_union, "--manually-drop-union"),
             (&self.options.blocklisted_types, "--blocklist-type"),
             (&self.options.blocklisted_functions, "--blocklist-function"),
             (&self.options.blocklisted_items, "--blocklist-item"),
@@ -1101,6 +1115,32 @@ impl Builder {
         self
     }
 
+    /// Set the default style of code to generate for unions with a non-Copy member.
+    pub fn default_non_copy_union_style(
+        mut self,
+        arg: codegen::NonCopyUnionStyle,
+    ) -> Self {
+        self.options.default_non_copy_union_style = arg;
+        self
+    }
+
+    /// Mark the given union (or set of union, if using a pattern) to use
+    /// a bindgen-generated wrapper for its members if at least one is non-Copy.
+    pub fn bindgen_wrapper_union<T: AsRef<str>>(mut self, arg: T) -> Self {
+        self.options.bindgen_wrapper_union.insert(arg);
+        self
+    }
+
+    /// Mark the given union (or set of union, if using a pattern) to use
+    /// [`::core::mem::ManuallyDrop`] for its members if at least one is non-Copy.
+    ///
+    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
+    /// MSRV is lower.
+    pub fn manually_drop_union<T: AsRef<str>>(mut self, arg: T) -> Self {
+        self.options.manually_drop_union.insert(arg);
+        self
+    }
+
     /// Add a string to prepend to the generated bindings. The string is passed
     /// through without any modification.
     pub fn raw_line<T: Into<String>>(mut self, arg: T) -> Self {
@@ -1811,6 +1851,18 @@ struct BindgenOptions {
     /// Deref and Deref to their aliased type.
     new_type_alias_deref: RegexSet,
 
+    /// The default style of code to generate for union containing non-Copy
+    /// members.
+    default_non_copy_union_style: codegen::NonCopyUnionStyle,
+
+    /// The union patterns to mark an non-Copy union as using the bindgen
+    /// generated wrapper.
+    bindgen_wrapper_union: RegexSet,
+
+    /// The union patterns to mark an non-Copy union as using the
+    /// `::core::mem::ManuallyDrop` wrapper.
+    manually_drop_union: RegexSet,
+
     /// Whether we should generate builtins or not.
     builtins: bool,
 
@@ -2079,6 +2131,8 @@ impl BindgenOptions {
             &mut self.type_alias,
             &mut self.new_type_alias,
             &mut self.new_type_alias_deref,
+            &mut self.bindgen_wrapper_union,
+            &mut self.manually_drop_union,
             &mut self.no_partialeq_types,
             &mut self.no_copy_types,
             &mut self.no_debug_types,
@@ -2137,6 +2191,9 @@ impl Default for BindgenOptions {
             type_alias: Default::default(),
             new_type_alias: Default::default(),
             new_type_alias_deref: Default::default(),
+            default_non_copy_union_style: Default::default(),
+            bindgen_wrapper_union: Default::default(),
+            manually_drop_union: Default::default(),
             builtins: false,
             emit_ast: false,
             emit_ir: false,
diff --git a/src/options.rs b/src/options.rs
index 4db3fd57..1e87b6eb 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -1,7 +1,7 @@
 use bindgen::{
     builder, AliasVariation, Builder, CodegenConfig, EnumVariation,
-    MacroTypeVariation, RustTarget, DEFAULT_ANON_FIELDS_PREFIX,
-    RUST_TARGET_STRINGS,
+    MacroTypeVariation, NonCopyUnionStyle, RustTarget,
+    DEFAULT_ANON_FIELDS_PREFIX, RUST_TARGET_STRINGS,
 };
 use clap::{App, Arg};
 use std::fs::File;
@@ -138,6 +138,42 @@ where
                 .value_name("regex")
                 .multiple_occurrences(true)
                 .number_of_values(1),
+            Arg::new("default-non-copy-union-style")
+                .long("default-non-copy-union-style")
+                .help(
+                    "The default style of code used to generate unions with \
+                     non-Copy members. Note that ManuallyDrop was first \
+                     stabilized in Rust 1.20.0.",
+                )
+                .value_name("style")
+                .default_value("bindgen_wrapper")
+                .possible_values(&[
+                    "bindgen_wrapper",
+                    "manually_drop",
+                ])
+                .multiple_occurrences(false),
+            Arg::new("bindgen-wrapper-union")
+                .long("bindgen-wrapper-union")
+                .help(
+                    "Mark any union whose name matches <regex> and who has a \
+                     non-Copy member to use a bindgen-generated wrapper for \
+                     fields.",
+                )
+                .value_name("regex")
+                .takes_value(true)
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("manually-drop-union")
+                .long("manually-drop-union")
+                .help(
+                    "Mark any union whose name matches <regex> and who has a \
+                     non-Copy member to use ManuallyDrop (stabilized in Rust \
+                     1.20.0) for fields.",
+                )
+                .value_name("regex")
+                .takes_value(true)
+                .multiple_occurrences(true)
+                .number_of_values(1),
             Arg::new("blocklist-type")
                 .alias("blacklist-type")
                 .long("blocklist-type")
@@ -631,6 +667,27 @@ where
         }
     }
 
+    if let Some(variant) = matches.value_of("default-non-copy-union-style") {
+        builder = builder.default_non_copy_union_style(
+            NonCopyUnionStyle::from_str(variant)?,
+        );
+    }
+
+    if let Some(bindgen_wrapper_union) =
+        matches.values_of("bindgen-wrapper-union")
+    {
+        for regex in bindgen_wrapper_union {
+            builder = builder.bindgen_wrapper_union(regex);
+        }
+    }
+
+    if let Some(manually_drop_union) = matches.values_of("manually-drop-union")
+    {
+        for regex in manually_drop_union {
+            builder = builder.manually_drop_union(regex);
+        }
+    }
+
     if let Some(hidden_types) = matches.values_of("blocklist-type") {
         for ty in hidden_types {
             builder = builder.blocklist_type(ty);
diff --git a/tests/expectations/tests/union_with_non_copy_member.rs b/tests/expectations/tests/union_with_non_copy_member.rs
new file mode 100644
index 00000000..3c500b21
--- /dev/null
+++ b/tests/expectations/tests/union_with_non_copy_member.rs
@@ -0,0 +1,239 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NonCopyType {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NonCopyType() {
+    const UNINIT: ::std::mem::MaybeUninit<NonCopyType> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NonCopyType>(),
+        4usize,
+        concat!("Size of: ", stringify!(NonCopyType))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NonCopyType>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NonCopyType))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NonCopyType),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
+#[repr(C)]
+pub struct WithBindgenGeneratedWrapper {
+    pub non_copy_type: __BindgenUnionField<NonCopyType>,
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_WithBindgenGeneratedWrapper() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBindgenGeneratedWrapper> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBindgenGeneratedWrapper>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithBindgenGeneratedWrapper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBindgenGeneratedWrapper>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBindgenGeneratedWrapper))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBindgenGeneratedWrapper),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBindgenGeneratedWrapper),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithBindgenGeneratedWrapper {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub union WithManuallyDrop {
+    pub non_copy_type: ::std::mem::ManuallyDrop<NonCopyType>,
+    pub bar: ::std::mem::ManuallyDrop<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_WithManuallyDrop() {
+    const UNINIT: ::std::mem::MaybeUninit<WithManuallyDrop> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithManuallyDrop>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithManuallyDrop))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithManuallyDrop>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithManuallyDrop))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithManuallyDrop),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithManuallyDrop),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithManuallyDrop {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct WithDefaultWrapper {
+    pub non_copy_type: __BindgenUnionField<NonCopyType>,
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_WithDefaultWrapper() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDefaultWrapper> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDefaultWrapper>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDefaultWrapper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDefaultWrapper>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDefaultWrapper))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDefaultWrapper),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDefaultWrapper),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithDefaultWrapper {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/tests/headers/union_with_non_copy_member.h b/tests/headers/union_with_non_copy_member.h
new file mode 100644
index 00000000..764820a4
--- /dev/null
+++ b/tests/headers/union_with_non_copy_member.h
@@ -0,0 +1,20 @@
+// bindgen-flags: --bindgen-wrapper-union 'WithBindgenGeneratedWrapper' --manually-drop-union 'WithManuallyDrop' --no-copy 'NonCopyType'
+
+struct NonCopyType {
+  int foo;
+};
+
+union WithBindgenGeneratedWrapper {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
+
+union WithManuallyDrop {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
+
+union WithDefaultWrapper {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
-- 
cgit v1.2.3


From 4b006da21bd7a6701c8e7f658085569830207c9c Mon Sep 17 00:00:00 2001
From: Christian Poveda <31802960+pvdrz@users.noreply.github.com>
Date: Fri, 23 Sep 2022 02:04:28 -0500
Subject: Add option to deduplicate extern blocks (#2258)

---
 src/lib.rs                                      | 73 ++++++++++++++++++++++++-
 src/options.rs                                  |  7 +++
 tests/expectations/tests/merge-extern-blocks.rs | 37 +++++++++++++
 tests/headers/merge-extern-blocks.h             |  6 ++
 4 files changed, 120 insertions(+), 3 deletions(-)
 create mode 100644 tests/expectations/tests/merge-extern-blocks.rs
 create mode 100644 tests/headers/merge-extern-blocks.h

diff --git a/src/lib.rs b/src/lib.rs
index c7fccb98..3c89368f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -615,6 +615,10 @@ impl Builder {
             output_vector.push("--sort-semantically".into());
         }
 
+        if self.options.merge_extern_blocks {
+            output_vector.push("--merge-extern-blocks".into());
+        }
+
         // Add clang arguments
 
         output_vector.push("--".into());
@@ -1542,7 +1546,7 @@ impl Builder {
         self
     }
 
-    /// If true, enables the sorting of the output in a predefined manner
+    /// If true, enables the sorting of the output in a predefined manner.
     ///
     /// TODO: Perhaps move the sorting order out into a config
     pub fn sort_semantically(mut self, doit: bool) -> Self {
@@ -1550,6 +1554,12 @@ impl Builder {
         self
     }
 
+    /// If true, merges extern blocks.
+    pub fn merge_extern_blocks(mut self, doit: bool) -> Self {
+        self.options.merge_extern_blocks = doit;
+        self
+    }
+
     /// Generate the Rust bindings using the options built up thus far.
     pub fn generate(mut self) -> Result<Bindings, BindgenError> {
         // Add any extra arguments from the environment to the clang command line.
@@ -2095,8 +2105,11 @@ struct BindgenOptions {
     /// Emit vtable functions.
     vtable_generation: bool,
 
-    /// Sort the code generation
+    /// Sort the code generation.
     sort_semantically: bool,
+
+    /// Deduplicate `extern` blocks.
+    merge_extern_blocks: bool,
 }
 
 /// TODO(emilio): This is sort of a lie (see the error message that results from
@@ -2107,7 +2120,7 @@ impl ::std::panic::UnwindSafe for BindgenOptions {}
 impl BindgenOptions {
     /// Whether any of the enabled options requires `syn`.
     fn require_syn(&self) -> bool {
-        self.sort_semantically
+        self.sort_semantically || self.merge_extern_blocks
     }
 
     fn build(&mut self) {
@@ -2258,6 +2271,7 @@ impl Default for BindgenOptions {
             force_explicit_padding: false,
             vtable_generation: false,
             sort_semantically: false,
+            merge_extern_blocks: false,
         }
     }
 }
@@ -2563,6 +2577,59 @@ impl Bindings {
                     .unwrap()
                     .1;
 
+            if options.merge_extern_blocks {
+                // Here we will store all the items after deduplication.
+                let mut items = Vec::new();
+
+                // Keep all the extern blocks in a different `Vec` for faster search.
+                let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+                for item in syn_parsed_items {
+                    match item {
+                        syn::Item::ForeignMod(syn::ItemForeignMod {
+                            attrs,
+                            abi,
+                            brace_token,
+                            items: foreign_items,
+                        }) => {
+                            let mut exists = false;
+                            for foreign_mod in &mut foreign_mods {
+                                // Check if there is a extern block with the same ABI and
+                                // attributes.
+                                if foreign_mod.attrs == attrs &&
+                                    foreign_mod.abi == abi
+                                {
+                                    // Merge the items of the two blocks.
+                                    foreign_mod
+                                        .items
+                                        .extend_from_slice(&foreign_items);
+                                    exists = true;
+                                    break;
+                                }
+                            }
+                            // If no existing extern block had the same ABI and attributes, store
+                            // it.
+                            if !exists {
+                                foreign_mods.push(syn::ItemForeignMod {
+                                    attrs,
+                                    abi,
+                                    brace_token,
+                                    items: foreign_items,
+                                });
+                            }
+                        }
+                        // If the item is not an extern block, we don't have to do anything.
+                        _ => items.push(item),
+                    }
+                }
+
+                // Move all the extern blocks alongiside the rest of the items.
+                for foreign_mod in foreign_mods {
+                    items.push(syn::Item::ForeignMod(foreign_mod));
+                }
+
+                syn_parsed_items = items;
+            }
+
             if options.sort_semantically {
                 syn_parsed_items.sort_by_key(|item| match item {
                     syn::Item::Type(_) => 0,
diff --git a/src/options.rs b/src/options.rs
index 1e87b6eb..f707ab9b 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -560,6 +560,9 @@ where
             Arg::new("sort-semantically")
                 .long("sort-semantically")
                 .help("Enables sorting of code generation in a predefined manner."),
+            Arg::new("merge-extern-blocks")
+                .long("merge-extern-blocks")
+                .help("Deduplicates extern blocks."),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1076,5 +1079,9 @@ where
         builder = builder.sort_semantically(true);
     }
 
+    if matches.is_present("merge-extern-blocks") {
+        builder = builder.merge_extern_blocks(true);
+    }
+
     Ok((builder, output, verbose))
 }
diff --git a/tests/expectations/tests/merge-extern-blocks.rs b/tests/expectations/tests/merge-extern-blocks.rs
new file mode 100644
index 00000000..66ceeff0
--- /dev/null
+++ b/tests/expectations/tests/merge-extern-blocks.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Point {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Point() {
+    const UNINIT: ::std::mem::MaybeUninit<Point> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Point>(),
+        4usize,
+        concat!("Size of: ", stringify!(Point))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Point>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Point))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
+    );
+}
+extern "C" {
+    pub fn foo() -> ::std::os::raw::c_int;
+    pub fn bar() -> ::std::os::raw::c_int;
+}
diff --git a/tests/headers/merge-extern-blocks.h b/tests/headers/merge-extern-blocks.h
new file mode 100644
index 00000000..1d46b7d4
--- /dev/null
+++ b/tests/headers/merge-extern-blocks.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --merge-extern-blocks -- --target=x86_64-unknown-linux
+int foo();
+typedef struct Point {
+    int x;
+} Point;
+int bar();
-- 
cgit v1.2.3


From af12c29026517b4bb9ddef58fec23a7e8142fe0b Mon Sep 17 00:00:00 2001
From: Emilio Cobos Álvarez <emilio@crisal.io>
Date: Thu, 22 Sep 2022 20:53:50 -1000
Subject: codegen: Implement manuallydrop fields better.

This doesn't change behavior but makes the code make more sense.
---
 src/codegen/mod.rs           | 133 ++++++++++++++++---------------------------
 src/codegen/struct_layout.rs |  10 +++-
 src/ir/comp.rs               |  35 +++++++++---
 3 files changed, 84 insertions(+), 94 deletions(-)

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 98ab922a..843d5111 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1231,7 +1231,7 @@ trait FieldCodegen<'a> {
 }
 
 impl<'a> FieldCodegen<'a> for Field {
-    type Extra = &'a str;
+    type Extra = ();
 
     fn codegen<F, M>(
         &self,
@@ -1244,7 +1244,7 @@ impl<'a> FieldCodegen<'a> for Field {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        parent_canonical_name: Self::Extra,
+        _: (),
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1261,7 +1261,7 @@ impl<'a> FieldCodegen<'a> for Field {
                     struct_layout,
                     fields,
                     methods,
-                    parent_canonical_name,
+                    (),
                 );
             }
             Field::Bitfields(ref unit) => {
@@ -1275,15 +1275,44 @@ impl<'a> FieldCodegen<'a> for Field {
                     struct_layout,
                     fields,
                     methods,
-                    parent_canonical_name,
+                    (),
                 );
             }
         }
     }
 }
 
+fn wrap_union_field_if_needed(
+    ctx: &BindgenContext,
+    struct_layout: &StructLayoutTracker,
+    ty: proc_macro2::TokenStream,
+    result: &mut CodegenResult,
+) -> proc_macro2::TokenStream {
+    if struct_layout.is_rust_union() {
+        if struct_layout.can_copy_union_fields() {
+            ty
+        } else {
+            let prefix = ctx.trait_prefix();
+            quote! {
+                ::#prefix::mem::ManuallyDrop<#ty>
+            }
+        }
+    } else {
+        result.saw_bindgen_union();
+        if ctx.options().enable_cxx_namespaces {
+            quote! {
+                root::__BindgenUnionField<#ty>
+            }
+        } else {
+            quote! {
+                __BindgenUnionField<#ty>
+            }
+        }
+    }
+}
+
 impl<'a> FieldCodegen<'a> for FieldData {
-    type Extra = &'a str;
+    type Extra = ();
 
     fn codegen<F, M>(
         &self,
@@ -1296,7 +1325,7 @@ impl<'a> FieldCodegen<'a> for FieldData {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        parent_canonical_name: Self::Extra,
+        _: (),
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1312,8 +1341,8 @@ impl<'a> FieldCodegen<'a> for FieldData {
         ty.append_implicit_template_params(ctx, field_item);
 
         // NB: If supported, we use proper `union` types.
-        let ty = if parent.is_union() && !struct_layout.is_rust_union() {
-            wrap_non_copy_type_for_union(ctx, parent_canonical_name, result, ty)
+        let ty = if parent.is_union() {
+            wrap_union_field_if_needed(ctx, struct_layout, ty, result)
         } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
             result.saw_incomplete_array();
 
@@ -1424,54 +1453,6 @@ impl<'a> FieldCodegen<'a> for FieldData {
     }
 }
 
-fn wrap_non_copy_type_for_union(
-    ctx: &BindgenContext,
-    parent_canonical_name: &str,
-    result: &mut CodegenResult,
-    field_ty: proc_macro2::TokenStream,
-) -> proc_macro2::TokenStream {
-    let union_style = union_style_from_ctx_and_name(ctx, parent_canonical_name);
-
-    match union_style {
-        NonCopyUnionStyle::ManuallyDrop => {
-            if ctx.options().use_core {
-                quote! {
-                    ::core::mem::ManuallyDrop<#field_ty>
-                }
-            } else {
-                quote! {
-                    ::std::mem::ManuallyDrop<#field_ty>
-                }
-            }
-        }
-        NonCopyUnionStyle::BindgenWrapper => {
-            result.saw_bindgen_union();
-            if ctx.options().enable_cxx_namespaces {
-                quote! {
-                    root::__BindgenUnionField<#field_ty>
-                }
-            } else {
-                quote! {
-                    __BindgenUnionField<#field_ty>
-                }
-            }
-        }
-    }
-}
-
-fn union_style_from_ctx_and_name(
-    ctx: &BindgenContext,
-    canonical_name: &str,
-) -> NonCopyUnionStyle {
-    if ctx.options().bindgen_wrapper_union.matches(canonical_name) {
-        NonCopyUnionStyle::BindgenWrapper
-    } else if ctx.options().manually_drop_union.matches(canonical_name) {
-        NonCopyUnionStyle::ManuallyDrop
-    } else {
-        ctx.options().default_non_copy_union_style
-    }
-}
-
 impl BitfieldUnit {
     /// Get the constructor name for this bitfield unit.
     fn ctor_name(&self) -> proc_macro2::TokenStream {
@@ -1538,7 +1519,7 @@ fn access_specifier(
 }
 
 impl<'a> FieldCodegen<'a> for BitfieldUnit {
-    type Extra = &'a str;
+    type Extra = ();
 
     fn codegen<F, M>(
         &self,
@@ -1551,7 +1532,7 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
         struct_layout: &mut StructLayoutTracker,
         fields: &mut F,
         methods: &mut M,
-        parent_canonical_name: Self::Extra,
+        _: (),
     ) where
         F: Extend<proc_macro2::TokenStream>,
         M: Extend<proc_macro2::TokenStream>,
@@ -1562,17 +1543,15 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
 
         let layout = self.layout();
         let unit_field_ty = helpers::bitfield_unit(ctx, layout);
-        let field_ty = {
-            if parent.is_union() && !struct_layout.is_rust_union() {
-                wrap_non_copy_type_for_union(
-                    ctx,
-                    parent_canonical_name,
-                    result,
-                    unit_field_ty.clone(),
-                )
-            } else {
-                unit_field_ty.clone()
-            }
+        let field_ty = if parent.is_union() {
+            wrap_union_field_if_needed(
+                ctx,
+                struct_layout,
+                unit_field_ty.clone(),
+                result,
+            )
+        } else {
+            unit_field_ty.clone()
         };
 
         {
@@ -1894,7 +1873,7 @@ impl CodeGenerator for CompInfo {
                     &mut struct_layout,
                     &mut fields,
                     &mut methods,
-                    &canonical_name,
+                    (),
                 );
             }
             // Check whether an explicit padding field is needed
@@ -2000,10 +1979,7 @@ impl CodeGenerator for CompInfo {
                 explicit_align = Some(layout.align);
             }
 
-            if !struct_layout.is_rust_union() &&
-                union_style_from_ctx_and_name(ctx, &canonical_name) ==
-                    NonCopyUnionStyle::BindgenWrapper
-            {
+            if !struct_layout.is_rust_union() {
                 let ty = helpers::blob(ctx, layout);
                 fields.push(quote! {
                     pub bindgen_union_field: #ty ,
@@ -2130,15 +2106,6 @@ impl CodeGenerator for CompInfo {
                 #( #attributes )*
                 pub union #canonical_ident
             }
-        } else if is_union &&
-            !struct_layout.is_rust_union() &&
-            union_style_from_ctx_and_name(ctx, &canonical_name) ==
-                NonCopyUnionStyle::ManuallyDrop
-        {
-            quote! {
-                #( #attributes )*
-                pub union #canonical_ident
-            }
         } else {
             quote! {
                 #( #attributes )*
diff --git a/src/codegen/struct_layout.rs b/src/codegen/struct_layout.rs
index 657be0b4..ddac1b0a 100644
--- a/src/codegen/struct_layout.rs
+++ b/src/codegen/struct_layout.rs
@@ -20,6 +20,7 @@ pub struct StructLayoutTracker<'a> {
     is_packed: bool,
     known_type_layout: Option<Layout>,
     is_rust_union: bool,
+    can_copy_union_fields: bool,
     latest_offset: usize,
     padding_count: usize,
     latest_field_layout: Option<Layout>,
@@ -90,8 +91,8 @@ impl<'a> StructLayoutTracker<'a> {
     ) -> Self {
         let known_type_layout = ty.layout(ctx);
         let is_packed = comp.is_packed(ctx, known_type_layout.as_ref());
-        let is_rust_union = comp.is_union() &&
-            comp.can_be_rust_union(ctx, known_type_layout.as_ref());
+        let (is_rust_union, can_copy_union_fields) =
+            comp.is_rust_union(ctx, known_type_layout.as_ref(), name);
         StructLayoutTracker {
             name,
             ctx,
@@ -99,6 +100,7 @@ impl<'a> StructLayoutTracker<'a> {
             is_packed,
             known_type_layout,
             is_rust_union,
+            can_copy_union_fields,
             latest_offset: 0,
             padding_count: 0,
             latest_field_layout: None,
@@ -107,6 +109,10 @@ impl<'a> StructLayoutTracker<'a> {
         }
     }
 
+    pub fn can_copy_union_fields(&self) -> bool {
+        self.can_copy_union_fields
+    }
+
     pub fn is_rust_union(&self) -> bool {
         self.is_rust_union
     }
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index fdf6a963..f44c5d67 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -14,6 +14,7 @@ use crate::codegen::struct_layout::{align_to, bytes_from_bits_pow2};
 use crate::ir::derive::CanDeriveCopy;
 use crate::parse::{ClangItemParser, ParseError};
 use crate::HashMap;
+use crate::NonCopyUnionStyle;
 use peeking_take_while::PeekableExt;
 use std::cmp;
 use std::io;
@@ -1680,21 +1681,37 @@ impl CompInfo {
     ///
     /// Requirements:
     ///     1. Current RustTarget allows for `untagged_union`
-    ///     2. Each field can derive `Copy`
+    ///     2. Each field can derive `Copy` or we use ManuallyDrop.
     ///     3. It's not zero-sized.
-    pub fn can_be_rust_union(
+    ///
+    /// Second boolean returns whether all fields can be copied (and thus
+    /// ManuallyDrop is not needed).
+    pub fn is_rust_union(
         &self,
         ctx: &BindgenContext,
         layout: Option<&Layout>,
-    ) -> bool {
+        name: &str,
+    ) -> (bool, bool) {
+        if !self.is_union() {
+            return (false, false);
+        }
+
         if !ctx.options().rust_features().untagged_union {
-            return false;
+            return (false, false);
         }
 
         if self.is_forward_declaration() {
-            return false;
+            return (false, false);
         }
 
+        let union_style = if ctx.options().bindgen_wrapper_union.matches(name) {
+            NonCopyUnionStyle::BindgenWrapper
+        } else if ctx.options().manually_drop_union.matches(name) {
+            NonCopyUnionStyle::ManuallyDrop
+        } else {
+            ctx.options().default_non_copy_union_style
+        };
+
         let all_can_copy = self.fields().iter().all(|f| match *f {
             Field::DataMember(ref field_data) => {
                 field_data.ty().can_derive_copy(ctx)
@@ -1702,15 +1719,15 @@ impl CompInfo {
             Field::Bitfields(_) => true,
         });
 
-        if !all_can_copy {
-            return false;
+        if !all_can_copy && union_style == NonCopyUnionStyle::BindgenWrapper {
+            return (false, false);
         }
 
         if layout.map_or(false, |l| l.size == 0) {
-            return false;
+            return (false, false);
         }
 
-        true
+        (true, all_can_copy)
     }
 }
 
-- 
cgit v1.2.3


From c84897d33846b4cf0d8494e20326cbc6fc3bb0d8 Mon Sep 17 00:00:00 2001
From: Amanjeev Sethi <aj@amanjeev.com>
Date: Mon, 19 Sep 2022 19:26:44 -0400
Subject: test: add test for GH-422

GitHub issue 422 was fixed but needs a test.
https://github.com/rust-lang/rust-bindgen/issues/422

Signed-off-by: Amanjeev Sethi <aj@amanjeev.com>
---
 tests/expectations/tests/inner-typedef-gh422.rs | 37 +++++++++++++++++++++++++
 tests/headers/inner-typedef-gh422.hpp           | 11 ++++++++
 2 files changed, 48 insertions(+)
 create mode 100644 tests/expectations/tests/inner-typedef-gh422.rs
 create mode 100644 tests/headers/inner-typedef-gh422.hpp

diff --git a/tests/expectations/tests/inner-typedef-gh422.rs b/tests/expectations/tests/inner-typedef-gh422.rs
new file mode 100644
index 00000000..1cfa549c
--- /dev/null
+++ b/tests/expectations/tests/inner-typedef-gh422.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo_InnerType<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Foo_InnerType<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type Bar = InnerType;
+extern "C" {
+    #[link_name = "\u{1}_Z4funcv"]
+    pub fn func() -> Bar;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct InnerType {
+    pub _address: u8,
+}
diff --git a/tests/headers/inner-typedef-gh422.hpp b/tests/headers/inner-typedef-gh422.hpp
new file mode 100644
index 00000000..301630a5
--- /dev/null
+++ b/tests/headers/inner-typedef-gh422.hpp
@@ -0,0 +1,11 @@
+template <typename T>
+class Foo {
+public:
+    class InnerType {
+        T t;
+    };
+};
+
+typedef Foo<int>::InnerType Bar;
+
+Bar func();
\ No newline at end of file
-- 
cgit v1.2.3


From 3ec5c8746204ad82bfbf0239d3e9d95d92c2e331 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 7 Sep 2022 15:37:48 -0500
Subject: use `#[feature(core_ffi_c)]` when available

---
 src/codegen/helpers.rs                 | 16 +++++++++++++---
 src/features.rs                        |  2 ++
 tests/expectations/tests/core_ffi_c.rs | 20 ++++++++++++++++++++
 tests/headers/core_ffi_c.h             | 14 ++++++++++++++
 4 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 tests/expectations/tests/core_ffi_c.rs
 create mode 100644 tests/headers/core_ffi_c.h

diff --git a/src/codegen/helpers.rs b/src/codegen/helpers.rs
index 75c169c6..5bf36acb 100644
--- a/src/codegen/helpers.rs
+++ b/src/codegen/helpers.rs
@@ -166,9 +166,19 @@ pub mod ast_ty {
                     #prefix::#ident
                 }
             }
-            None => quote! {
-                ::std::os::raw::#ident
-            },
+            None => {
+                if ctx.options().use_core &&
+                    ctx.options().rust_features().core_ffi_c
+                {
+                    quote! {
+                        ::core::ffi::#ident
+                    }
+                } else {
+                    quote! {
+                        ::std::os::raw::#ident
+                    }
+                }
+            }
         }
     }
 
diff --git a/src/features.rs b/src/features.rs
index 59467703..f18ffa88 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -130,6 +130,7 @@ macro_rules! rust_target_base {
             /// Nightly rust
             ///  * `thiscall` calling convention ([Tracking issue](https://github.com/rust-lang/rust/issues/42202))
             ///  * `vectorcall` calling convention (no tracking issue)
+            ///  * `core_ffi_c` ([Tracking issue](https://github.com/rust-lang/rust/issues/94501))
             => Nightly => nightly;
         );
     }
@@ -236,6 +237,7 @@ rust_feature_def!(
     Nightly {
         => thiscall_abi;
         => vectorcall_abi;
+        => core_ffi_c;
     }
 );
 
diff --git a/tests/expectations/tests/core_ffi_c.rs b/tests/expectations/tests/core_ffi_c.rs
new file mode 100644
index 00000000..7e138a89
--- /dev/null
+++ b/tests/expectations/tests/core_ffi_c.rs
@@ -0,0 +1,20 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type c_char = ::core::ffi::c_char;
+pub type c_double = ::core::ffi::c_double;
+pub type c_float = ::core::ffi::c_float;
+pub type c_int = ::core::ffi::c_int;
+pub type c_long = ::core::ffi::c_long;
+pub type c_longlong = ::core::ffi::c_longlong;
+pub type c_schar = ::core::ffi::c_schar;
+pub type c_short = ::core::ffi::c_short;
+pub type c_uchar = ::core::ffi::c_uchar;
+pub type c_uint = ::core::ffi::c_uint;
+pub type c_ulong = ::core::ffi::c_ulong;
+pub type c_ulonglong = ::core::ffi::c_ulonglong;
+pub type c_ushort = ::core::ffi::c_ushort;
diff --git a/tests/headers/core_ffi_c.h b/tests/headers/core_ffi_c.h
new file mode 100644
index 00000000..3e180fd8
--- /dev/null
+++ b/tests/headers/core_ffi_c.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --rust-target nightly --use-core --no-convert-floats
+typedef char c_char;
+typedef double c_double;
+typedef float c_float;
+typedef int c_int;
+typedef long c_long;
+typedef long long c_longlong;
+typedef signed char c_schar;
+typedef short c_short;
+typedef unsigned char c_uchar;
+typedef unsigned int c_uint;
+typedef unsigned long c_ulong;
+typedef unsigned long long c_ulonglong;
+typedef unsigned short c_ushort;
-- 
cgit v1.2.3


From 995943ce06b0b8d59ceeb056844e474ee0ae644e Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 7 Sep 2022 15:45:11 -0500
Subject: put tests behind the `nightly` feature

---
 tests/expectations/tests/core_ffi_c.rs | 1 +
 tests/headers/core_ffi_c.h             | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/expectations/tests/core_ffi_c.rs b/tests/expectations/tests/core_ffi_c.rs
index 7e138a89..4a74c839 100644
--- a/tests/expectations/tests/core_ffi_c.rs
+++ b/tests/expectations/tests/core_ffi_c.rs
@@ -4,6 +4,7 @@
     non_camel_case_types,
     non_upper_case_globals
 )]
+#![cfg(feature = "nightly")]
 
 pub type c_char = ::core::ffi::c_char;
 pub type c_double = ::core::ffi::c_double;
diff --git a/tests/headers/core_ffi_c.h b/tests/headers/core_ffi_c.h
index 3e180fd8..06623138 100644
--- a/tests/headers/core_ffi_c.h
+++ b/tests/headers/core_ffi_c.h
@@ -1,4 +1,4 @@
-// bindgen-flags: --rust-target nightly --use-core --no-convert-floats
+// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --use-core --no-convert-floats
 typedef char c_char;
 typedef double c_double;
 typedef float c_float;
-- 
cgit v1.2.3


From 0f3b8a840c4456d1db6d005cfdf52c0f6b9dcd81 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 22 Sep 2022 11:13:50 -0500
Subject: update to rust 1.64

---
 src/features.rs                        | 8 ++++++--
 tests/expectations/tests/core_ffi_c.rs | 1 -
 tests/headers/core_ffi_c.h             | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/features.rs b/src/features.rs
index f18ffa88..bb836ce8 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -127,10 +127,12 @@ macro_rules! rust_target_base {
             /// Rust stable 1.47
             /// * `larger_arrays` ([Tracking issue](https://github.com/rust-lang/rust/pull/74060))
             => Stable_1_47 => 1.47;
+            /// Rust stable 1.64
+            ///  * `core_ffi_c` ([Tracking issue](https://github.com/rust-lang/rust/issues/94501))
+            => Stable_1_64 => 1.64;
             /// Nightly rust
             ///  * `thiscall` calling convention ([Tracking issue](https://github.com/rust-lang/rust/issues/42202))
             ///  * `vectorcall` calling convention (no tracking issue)
-            ///  * `core_ffi_c` ([Tracking issue](https://github.com/rust-lang/rust/issues/94501))
             => Nightly => nightly;
         );
     }
@@ -234,10 +236,12 @@ rust_feature_def!(
     Stable_1_47 {
         => larger_arrays;
     }
+    Stable_1_64 {
+        => core_ffi_c;
+    }
     Nightly {
         => thiscall_abi;
         => vectorcall_abi;
-        => core_ffi_c;
     }
 );
 
diff --git a/tests/expectations/tests/core_ffi_c.rs b/tests/expectations/tests/core_ffi_c.rs
index 4a74c839..7e138a89 100644
--- a/tests/expectations/tests/core_ffi_c.rs
+++ b/tests/expectations/tests/core_ffi_c.rs
@@ -4,7 +4,6 @@
     non_camel_case_types,
     non_upper_case_globals
 )]
-#![cfg(feature = "nightly")]
 
 pub type c_char = ::core::ffi::c_char;
 pub type c_double = ::core::ffi::c_double;
diff --git a/tests/headers/core_ffi_c.h b/tests/headers/core_ffi_c.h
index 06623138..6df1e2f8 100644
--- a/tests/headers/core_ffi_c.h
+++ b/tests/headers/core_ffi_c.h
@@ -1,4 +1,4 @@
-// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --use-core --no-convert-floats
+// bindgen-flags: --use-core --rust-target 1.64 --no-convert-floats
 typedef char c_char;
 typedef double c_double;
 typedef float c_float;
-- 
cgit v1.2.3


From 6de2d3d1c17bb4dd432daabf2cd858254663f49e Mon Sep 17 00:00:00 2001
From: Emilio Cobos Álvarez <emilio@crisal.io>
Date: Thu, 22 Sep 2022 21:20:05 -1000
Subject: features: Bump LATEST_STABLE_RUST after #2267.

---
 src/features.rs                      |  2 +-
 tests/expectations/tests/use-core.rs | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/features.rs b/src/features.rs
index bb836ce8..4f05b9eb 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -142,7 +142,7 @@ rust_target_base!(rust_target_def);
 rust_target_base!(rust_target_values_def);
 
 /// Latest stable release of Rust
-pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_47;
+pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_64;
 
 /// Create RustFeatures struct definition, new(), and a getter for each field
 macro_rules! rust_feature_def {
diff --git a/tests/expectations/tests/use-core.rs b/tests/expectations/tests/use-core.rs
index e6124d5a..569e8d24 100644
--- a/tests/expectations/tests/use-core.rs
+++ b/tests/expectations/tests/use-core.rs
@@ -10,8 +10,8 @@ extern crate core;
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct foo {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
+    pub a: ::core::ffi::c_int,
+    pub b: ::core::ffi::c_int,
     pub bar: *mut ::core::ffi::c_void,
 }
 #[test]
@@ -57,8 +57,8 @@ impl Default for foo {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union _bindgen_ty_1 {
-    pub bar: ::std::os::raw::c_int,
-    pub baz: ::std::os::raw::c_long,
+    pub bar: ::core::ffi::c_int,
+    pub baz: ::core::ffi::c_long,
 }
 #[test]
 fn bindgen_test_layout__bindgen_ty_1() {
@@ -109,4 +109,4 @@ extern "C" {
     pub static mut bazz: _bindgen_ty_1;
 }
 pub type fooFunction =
-    ::core::option::Option<unsafe extern "C" fn(bar: ::std::os::raw::c_int)>;
+    ::core::option::Option<unsafe extern "C" fn(bar: ::core::ffi::c_int)>;
-- 
cgit v1.2.3


From e1f314eb44b09268c6d05ff152f3ddd61e635135 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 15:20:56 -0500
Subject: move codegen postprocessing to its own module

---
 src/codegen/mod.rs            |   5 +-
 src/codegen/postprocessing.rs | 148 ++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs                    | 113 +-------------------------------
 3 files changed, 152 insertions(+), 114 deletions(-)
 create mode 100644 src/codegen/postprocessing.rs

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 843d5111..bc2c9fe2 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -3,6 +3,7 @@ mod error;
 mod helpers;
 mod impl_debug;
 mod impl_partialeq;
+mod postprocessing;
 pub mod struct_layout;
 
 #[cfg(test)]
@@ -4414,7 +4415,7 @@ impl CodeGenerator for ObjCInterface {
 
 pub(crate) fn codegen(
     context: BindgenContext,
-) -> (Vec<proc_macro2::TokenStream>, BindgenOptions, Vec<String>) {
+) -> (proc_macro2::TokenStream, BindgenOptions, Vec<String>) {
     context.gen(|context| {
         let _t = context.timer("codegen");
         let counter = Cell::new(0);
@@ -4464,7 +4465,7 @@ pub(crate) fn codegen(
             result.push(dynamic_items_tokens);
         }
 
-        result.items
+        postprocessing::postprocessing(result.items, context.options())
     })
 }
 
diff --git a/src/codegen/postprocessing.rs b/src/codegen/postprocessing.rs
new file mode 100644
index 00000000..72832298
--- /dev/null
+++ b/src/codegen/postprocessing.rs
@@ -0,0 +1,148 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::Item;
+
+use crate::BindgenOptions;
+
+macro_rules! decl_postprocessing {
+    ($($ty:ty),*) => {
+        pub(crate) fn postprocessing(
+            items: Vec<TokenStream>,
+            options: &BindgenOptions,
+        ) -> TokenStream {
+            // Whether any of the enabled options requires `syn`.
+            let require_syn = $(<$ty as PostProcessing>::should_run(options))||*;
+
+            if !require_syn {
+                return items.into_iter().collect();
+            }
+
+            let module_wrapped_tokens =
+                quote!(mod wrapper_for_sorting_hack { #( #items )* });
+
+            // This syn business is a hack, for now. This means that we are re-parsing already
+            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+            // control over the elements.
+            // One caveat is that some of the items coming from `quote`d output might have
+            // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
+            // The two `unwrap`s here are deliberate because
+            //      The first one won't panic because we build the `mod` and know it is there
+            //      The second one won't panic because we know original output has something in
+            //      it already.
+            let mut items =
+                syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+                    .unwrap()
+                    .content
+                    .unwrap()
+                    .1;
+
+            $(if <$ty as PostProcessing>::should_run(options) {
+                <$ty as PostProcessing>::run(&mut items);
+            })*
+
+            let synful_items = items
+                .into_iter()
+                .map(|item| item.into_token_stream());
+
+            quote! { #( #synful_items )* }
+        }
+    };
+}
+
+decl_postprocessing! {
+    MergeExternBlocks,
+    SortSemantically
+}
+
+trait PostProcessing {
+    fn should_run(options: &BindgenOptions) -> bool;
+
+    fn run(items: &mut Vec<Item>);
+}
+
+struct SortSemantically;
+
+impl PostProcessing for SortSemantically {
+    #[inline]
+    fn should_run(options: &BindgenOptions) -> bool {
+        options.sort_semantically
+    }
+
+    fn run(items: &mut Vec<Item>) {
+        items.sort_by_key(|item| match item {
+            Item::Type(_) => 0,
+            Item::Struct(_) => 1,
+            Item::Const(_) => 2,
+            Item::Fn(_) => 3,
+            Item::Enum(_) => 4,
+            Item::Union(_) => 5,
+            Item::Static(_) => 6,
+            Item::Trait(_) => 7,
+            Item::TraitAlias(_) => 8,
+            Item::Impl(_) => 9,
+            Item::Mod(_) => 10,
+            Item::Use(_) => 11,
+            Item::Verbatim(_) => 12,
+            Item::ExternCrate(_) => 13,
+            Item::ForeignMod(_) => 14,
+            Item::Macro(_) => 15,
+            Item::Macro2(_) => 16,
+            _ => 18,
+        });
+    }
+}
+
+struct MergeExternBlocks;
+
+impl PostProcessing for MergeExternBlocks {
+    #[inline]
+    fn should_run(options: &BindgenOptions) -> bool {
+        options.merge_extern_blocks
+    }
+
+    fn run(items: &mut Vec<Item>) {
+        // Keep all the extern blocks in a different `Vec` for faster search.
+        let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+
+        for item in std::mem::take(items) {
+            match item {
+                Item::ForeignMod(syn::ItemForeignMod {
+                    attrs,
+                    abi,
+                    brace_token,
+                    items: foreign_items,
+                }) => {
+                    let mut exists = false;
+                    for foreign_mod in &mut foreign_mods {
+                        // Check if there is a extern block with the same ABI and
+                        // attributes.
+                        if foreign_mod.attrs == attrs && foreign_mod.abi == abi
+                        {
+                            // Merge the items of the two blocks.
+                            foreign_mod.items.extend_from_slice(&foreign_items);
+                            exists = true;
+                            break;
+                        }
+                    }
+                    // If no existing extern block had the same ABI and attributes, store
+                    // it.
+                    if !exists {
+                        foreign_mods.push(syn::ItemForeignMod {
+                            attrs,
+                            abi,
+                            brace_token,
+                            items: foreign_items,
+                        });
+                    }
+                }
+                // If the item is not an extern block, we don't have to do anything.
+                _ => items.push(item),
+            }
+        }
+
+        // Move all the extern blocks alongiside the rest of the items.
+        for foreign_mod in foreign_mods {
+            items.push(Item::ForeignMod(foreign_mod));
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 3c89368f..d0be8604 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,7 +88,6 @@ use std::{env, iter};
 // Some convenient typedefs for a fast hash map and hash set.
 type HashMap<K, V> = ::rustc_hash::FxHashMap<K, V>;
 type HashSet<K> = ::rustc_hash::FxHashSet<K>;
-use quote::ToTokens;
 pub(crate) use std::collections::hash_map::Entry;
 
 /// Default prefix for the anon fields.
@@ -2118,11 +2117,6 @@ struct BindgenOptions {
 impl ::std::panic::UnwindSafe for BindgenOptions {}
 
 impl BindgenOptions {
-    /// Whether any of the enabled options requires `syn`.
-    fn require_syn(&self) -> bool {
-        self.sort_semantically || self.merge_extern_blocks
-    }
-
     fn build(&mut self) {
         let mut regex_sets = [
             &mut self.allowlisted_vars,
@@ -2555,112 +2549,7 @@ impl Bindings {
             parse(&mut context)?;
         }
 
-        let (items, options, warnings) = codegen::codegen(context);
-
-        let module = if options.require_syn() {
-            let module_wrapped_tokens =
-                quote!(mod wrapper_for_sorting_hack { #( #items )* });
-
-            // This syn business is a hack, for now. This means that we are re-parsing already
-            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
-            // control over the elements.
-            // One caveat is that some of the items coming from `quote`d output might have
-            // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-            // The two `unwrap`s here are deliberate because
-            //      The first one won't panic because we build the `mod` and know it is there
-            //      The second one won't panic because we know original output has something in
-            //      it already.
-            let mut syn_parsed_items =
-                syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-                    .unwrap()
-                    .content
-                    .unwrap()
-                    .1;
-
-            if options.merge_extern_blocks {
-                // Here we will store all the items after deduplication.
-                let mut items = Vec::new();
-
-                // Keep all the extern blocks in a different `Vec` for faster search.
-                let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
-                for item in syn_parsed_items {
-                    match item {
-                        syn::Item::ForeignMod(syn::ItemForeignMod {
-                            attrs,
-                            abi,
-                            brace_token,
-                            items: foreign_items,
-                        }) => {
-                            let mut exists = false;
-                            for foreign_mod in &mut foreign_mods {
-                                // Check if there is a extern block with the same ABI and
-                                // attributes.
-                                if foreign_mod.attrs == attrs &&
-                                    foreign_mod.abi == abi
-                                {
-                                    // Merge the items of the two blocks.
-                                    foreign_mod
-                                        .items
-                                        .extend_from_slice(&foreign_items);
-                                    exists = true;
-                                    break;
-                                }
-                            }
-                            // If no existing extern block had the same ABI and attributes, store
-                            // it.
-                            if !exists {
-                                foreign_mods.push(syn::ItemForeignMod {
-                                    attrs,
-                                    abi,
-                                    brace_token,
-                                    items: foreign_items,
-                                });
-                            }
-                        }
-                        // If the item is not an extern block, we don't have to do anything.
-                        _ => items.push(item),
-                    }
-                }
-
-                // Move all the extern blocks alongiside the rest of the items.
-                for foreign_mod in foreign_mods {
-                    items.push(syn::Item::ForeignMod(foreign_mod));
-                }
-
-                syn_parsed_items = items;
-            }
-
-            if options.sort_semantically {
-                syn_parsed_items.sort_by_key(|item| match item {
-                    syn::Item::Type(_) => 0,
-                    syn::Item::Struct(_) => 1,
-                    syn::Item::Const(_) => 2,
-                    syn::Item::Fn(_) => 3,
-                    syn::Item::Enum(_) => 4,
-                    syn::Item::Union(_) => 5,
-                    syn::Item::Static(_) => 6,
-                    syn::Item::Trait(_) => 7,
-                    syn::Item::TraitAlias(_) => 8,
-                    syn::Item::Impl(_) => 9,
-                    syn::Item::Mod(_) => 10,
-                    syn::Item::Use(_) => 11,
-                    syn::Item::Verbatim(_) => 12,
-                    syn::Item::ExternCrate(_) => 13,
-                    syn::Item::ForeignMod(_) => 14,
-                    syn::Item::Macro(_) => 15,
-                    syn::Item::Macro2(_) => 16,
-                    _ => 18,
-                });
-            }
-
-            let synful_items = syn_parsed_items
-                .into_iter()
-                .map(|item| item.into_token_stream());
-
-            quote! { #( #synful_items )* }
-        } else {
-            quote! { #( #items )* }
-        };
+        let (module, options, warnings) = codegen::codegen(context);
 
         Ok(Bindings {
             options,
-- 
cgit v1.2.3


From 0e4c1ae92c8ab89bf2285cf3b4540821fb480850 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 15:24:19 -0500
Subject: update `CONTRIBUTING.md` section about `syn`

---
 CONTRIBUTING.md | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2974ba42..3d757ccd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -323,14 +323,12 @@ generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate
 
 ### Implementing new options using `syn`
 
-Here is a list of recommendations to be followed if a new option can be
-implemented using the `syn` crate:
+If a new option can be implemented using the `syn` crate it should be added to
+the `codegen::postprocessing` module by following these steps:
 
-- The `BindgenOptions::require_syn` method must be updated to reflect that this
-  new option requires parsing the generated Rust code with `syn`.
-
-- The implementation of the new option should be added at the end of
-  `Bindings::generate`, inside the `if options.require_syn() { ... }` block.
+- Introduce a new `struct` with no fields.
+- Implement the `PostProcessing` trait for the `struct`.
+- Add the `struct` to the `decl_postprocessing` macro invocation.
 
 ## Pull Requests and Code Reviews
 
-- 
cgit v1.2.3


From cc78b6fdb6e829e5fb8fa1639f2182cb49333569 Mon Sep 17 00:00:00 2001
From: Geoffrey Thomas <geofft@ldpreload.com>
Date: Thu, 3 Jun 2021 10:47:26 -0400
Subject: Map size_t to usize by default and check compatibility (fixes #1901,
 #1903)

This addresses the underlying issue identified in #1671, that size_t
(integer that can hold any object size) isn't guaranteed to match usize,
which is defined more like uintptr_t (integer that can hold any
pointer). However, on almost all platforms, this is true, and in fact
Rust already uses usize extensively in contexts where size_t would be
more appropriate, such as slice indexing. So, it's better for ergonomics
when interfacing with C code to map the C size_t type to usize. (See
also discussion in rust-lang/rust#65473 about how usize really should be
defined as size_t, not uintptr_t.)

The previous fix for #1671 removed the special case for size_t and
defaulted to binding it as a normal typedef.  This change effectively
reverts that and goes back to mapping size_t to usize (and ssize_t to
isize), but also ensures that if size_t is emitted, the typedef'd type
of size_t in fact is compatible with usize (defined by checking that the
size and alignment match the target pointer width). For (hypothetical)
platforms where this is not true, or for compatibility with the default
behavior of bindgen between 0.53 and this commit, onwards, you can
disable this mapping with --no-size_t-is-usize.
---
 asd.fish                                           | 31 ++++++++++++
 src/codegen/mod.rs                                 | 27 ++++++++++-
 src/lib.rs                                         |  6 +--
 src/options.rs                                     | 11 +++--
 tests/expectations/tests/blocks-signature.rs       | 12 ++---
 tests/expectations/tests/blocks.rs                 |  1 -
 tests/expectations/tests/issue-1498.rs             |  3 +-
 tests/expectations/tests/jsval_layout_opaque.rs    |  3 +-
 .../expectations/tests/jsval_layout_opaque_1_0.rs  |  3 +-
 tests/expectations/tests/layout_array.rs           |  3 +-
 tests/expectations/tests/msvc-no-usr.rs            |  3 +-
 tests/expectations/tests/no_size_t_is_usize.rs     | 56 ++++++++++++++++++++++
 tests/expectations/tests/nsBaseHashtable.rs        |  1 -
 tests/expectations/tests/size_t_is_usize.rs        | 54 ---------------------
 tests/headers/no_size_t_is_usize.h                 | 10 ++++
 tests/headers/size_t_is_usize.h                    | 10 ----
 16 files changed, 142 insertions(+), 92 deletions(-)
 create mode 100644 asd.fish
 create mode 100644 tests/expectations/tests/no_size_t_is_usize.rs
 delete mode 100644 tests/expectations/tests/size_t_is_usize.rs
 create mode 100644 tests/headers/no_size_t_is_usize.h
 delete mode 100644 tests/headers/size_t_is_usize.h

diff --git a/asd.fish b/asd.fish
new file mode 100644
index 00000000..b6c9a270
--- /dev/null
+++ b/asd.fish
@@ -0,0 +1,31 @@
+for name in (rg -lF addr_of! tests/expectations | sd '.*/(.*).rs' '$1')
+    set path (fd --glob "$name.*" tests/headers)
+    if test -n "$path"
+
+        set flags (rg -F "// bindgen-flags" $path)
+        if test -n "$flags"
+            set minor (rg ".*\-\-rust\-target[ =]1.(\d+).*" $path -r '$1')
+            if test -n "$minor"
+                if test $minor -gt 47
+                    echo  $path needs to change the version from 1.$minor to 1.47
+                    sd -s "1.$minor" "1.47" $path
+                else
+                    echo $path uses version 1.$minor and that is fine
+                end
+            else
+                echo $path does not have the `--rust-target` flag
+                sd "// bindgen-flags: (.*)" '// bindgen-flags: --rust-target 1.47 $1' $path
+            end
+        else
+            echo $path does not have the flags at all
+            set contents (echo -e "// bindgen-flags: --rust-target 1.47\n"; cat $path)
+            rm $path
+            touch $path
+            for line in $contents
+                echo $line >> $path
+            end
+        end
+    else
+        echo $name headers not found
+    end
+end
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 843d5111..8eb7b013 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -836,9 +836,34 @@ impl CodeGenerator for Type {
                 }
 
                 // If this is a known named type, disallow generating anything
-                // for it too.
+                // for it too. If size_t -> usize conversions are enabled, we
+                // need to check that these conversions are permissible, but
+                // nothing needs to be generated, still.
                 let spelling = self.name().expect("Unnamed alias?");
                 if utils::type_from_named(ctx, spelling).is_some() {
+                    if let "size_t" | "ssize_t" = spelling {
+                        let layout = inner_item
+                            .kind()
+                            .expect_type()
+                            .layout(ctx)
+                            .expect("No layout?");
+                        assert_eq!(
+                            layout.size,
+                            ctx.target_pointer_size(),
+                            "Target platform requires `--no-size_t-is-usize`. The size of `{}` ({}) does not match the target pointer size ({})",
+                            spelling,
+                            layout.size,
+                            ctx.target_pointer_size(),
+                            );
+                        assert_eq!(
+                            layout.align,
+                            ctx.target_pointer_size(),
+                            "Target platform requires `--no-size_t-is-usize`. The alignment of `{}` ({}) does not match the target pointer size ({})",
+                            spelling,
+                            layout.align,
+                            ctx.target_pointer_size(),
+                        );
+                    }
                     return;
                 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 3c89368f..9a5887df 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -564,8 +564,8 @@ impl Builder {
             output_vector.push("--no-record-matches".into());
         }
 
-        if self.options.size_t_is_usize {
-            output_vector.push("--size_t-is-usize".into());
+        if !self.options.size_t_is_usize {
+            output_vector.push("--no-size_t-is-usize".into());
         }
 
         if !self.options.rustfmt_bindings {
@@ -2253,7 +2253,7 @@ impl Default for BindgenOptions {
             time_phases: false,
             record_matches: true,
             rustfmt_bindings: true,
-            size_t_is_usize: false,
+            size_t_is_usize: true,
             rustfmt_configuration_file: None,
             no_partialeq_types: Default::default(),
             no_copy_types: Default::default(),
diff --git a/src/options.rs b/src/options.rs
index f707ab9b..29edb78b 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -465,7 +465,12 @@ where
                 ),
             Arg::new("size_t-is-usize")
                 .long("size_t-is-usize")
-                .help("Translate size_t to usize."),
+                .help("Ignored - this is enabled by default.")
+                .hidden(true),
+            Arg::with_name("no-size_t-is-usize")
+                .long("no-size_t-is-usize")
+                .help("Do not bind size_t as usize (useful on platforms \
+                       where those types are incompatible)."),
             Arg::new("no-rustfmt-bindings")
                 .long("no-rustfmt-bindings")
                 .help("Do not format the generated bindings with rustfmt."),
@@ -975,8 +980,8 @@ where
         builder = builder.record_matches(false);
     }
 
-    if matches.is_present("size_t-is-usize") {
-        builder = builder.size_t_is_usize(true);
+    if matches.is_present("no-size_t-is-usize") {
+        builder = builder.size_t_is_usize(false);
     }
 
     let no_rustfmt_bindings = matches.is_present("no-rustfmt-bindings");
diff --git a/tests/expectations/tests/blocks-signature.rs b/tests/expectations/tests/blocks-signature.rs
index 779d0ecb..ff7114a7 100644
--- a/tests/expectations/tests/blocks-signature.rs
+++ b/tests/expectations/tests/blocks-signature.rs
@@ -7,7 +7,6 @@
 #![cfg(target_os = "macos")]
 
 extern crate block;
-pub type size_t = ::std::os::raw::c_ulonglong;
 extern "C" {
     #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
     pub fn atexit_b(arg1: _bindgen_ty_id_33);
@@ -82,16 +81,11 @@ impl Default for contains_block_pointers {
 }
 pub type _bindgen_ty_id_33 = *const ::block::Block<(), ()>;
 pub type _bindgen_ty_id_40 = *const ::block::Block<
-    (
-        dispatch_data_t,
-        size_t,
-        *const ::std::os::raw::c_void,
-        size_t,
-    ),
+    (dispatch_data_t, usize, *const ::std::os::raw::c_void, usize),
     bool,
 >;
-pub type _bindgen_ty_id_50 = *const ::block::Block<(size_t,), ()>;
-pub type _bindgen_ty_id_56 = *const ::block::Block<(size_t,), ()>;
+pub type _bindgen_ty_id_50 = *const ::block::Block<(usize,), ()>;
+pub type _bindgen_ty_id_56 = *const ::block::Block<(usize,), ()>;
 pub type contains_block_pointers__bindgen_ty_id_61 =
     *const ::block::Block<(::std::os::raw::c_int,), ()>;
 pub type _bindgen_ty_id_68 =
diff --git a/tests/expectations/tests/blocks.rs b/tests/expectations/tests/blocks.rs
index dbafaf94..6f242989 100644
--- a/tests/expectations/tests/blocks.rs
+++ b/tests/expectations/tests/blocks.rs
@@ -6,7 +6,6 @@
 )]
 #![cfg(target_os = "macos")]
 
-pub type size_t = ::std::os::raw::c_ulonglong;
 extern "C" {
     #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
     pub fn atexit_b(arg1: *mut ::std::os::raw::c_void);
diff --git a/tests/expectations/tests/issue-1498.rs b/tests/expectations/tests/issue-1498.rs
index 08ba9ef4..eb5e2804 100644
--- a/tests/expectations/tests/issue-1498.rs
+++ b/tests/expectations/tests/issue-1498.rs
@@ -5,7 +5,6 @@
     non_upper_case_globals
 )]
 
-pub type size_t = u64;
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub struct rte_memseg {
@@ -13,7 +12,7 @@ pub struct rte_memseg {
     pub phys_addr: u64,
     pub __bindgen_anon_1: rte_memseg__bindgen_ty_1,
     ///< Length of the segment.
-    pub len: size_t,
+    pub len: usize,
     ///< The pagesize of underlying memory
     pub hugepage_sz: u64,
     ///< NUMA socket ID.
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
index 2873f6a2..a812e905 100644
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ b/tests/expectations/tests/jsval_layout_opaque.rs
@@ -94,7 +94,6 @@ where
 pub const JSVAL_TAG_SHIFT: u32 = 47;
 pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
 pub const JSVAL_TAG_MASK: i64 = -140737488355328;
-pub type size_t = ::std::os::raw::c_ulonglong;
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum JSValueType {
@@ -186,7 +185,7 @@ pub union jsval_layout {
     pub s: jsval_layout__bindgen_ty_2,
     pub asDouble: f64,
     pub asPtr: *mut ::std::os::raw::c_void,
-    pub asWord: size_t,
+    pub asWord: usize,
     pub asUIntPtr: usize,
 }
 #[repr(C)]
diff --git a/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/tests/expectations/tests/jsval_layout_opaque_1_0.rs
index 33594c0e..b4394993 100644
--- a/tests/expectations/tests/jsval_layout_opaque_1_0.rs
+++ b/tests/expectations/tests/jsval_layout_opaque_1_0.rs
@@ -137,7 +137,6 @@ impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
 pub const JSVAL_TAG_SHIFT: u32 = 47;
 pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
 pub const JSVAL_TAG_MASK: i64 = -140737488355328;
-pub type size_t = ::std::os::raw::c_ulonglong;
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum JSValueType {
@@ -229,7 +228,7 @@ pub struct jsval_layout {
     pub s: __BindgenUnionField<jsval_layout__bindgen_ty_2>,
     pub asDouble: __BindgenUnionField<f64>,
     pub asPtr: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub asWord: __BindgenUnionField<size_t>,
+    pub asWord: __BindgenUnionField<usize>,
     pub asUIntPtr: __BindgenUnionField<usize>,
     pub bindgen_union_field: u64,
 }
diff --git a/tests/expectations/tests/layout_array.rs b/tests/expectations/tests/layout_array.rs
index f3bbf51e..daf0ad06 100644
--- a/tests/expectations/tests/layout_array.rs
+++ b/tests/expectations/tests/layout_array.rs
@@ -9,7 +9,6 @@ pub const RTE_CACHE_LINE_SIZE: u32 = 64;
 pub const RTE_MEMPOOL_OPS_NAMESIZE: u32 = 32;
 pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16;
 pub const RTE_HEAP_NUM_FREELISTS: u32 = 13;
-pub type size_t = ::std::os::raw::c_longlong;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct rte_mempool {
@@ -279,7 +278,7 @@ pub struct malloc_heap {
     pub lock: rte_spinlock_t,
     pub free_head: [malloc_heap__bindgen_ty_1; 13usize],
     pub alloc_count: ::std::os::raw::c_uint,
-    pub total_size: size_t,
+    pub total_size: usize,
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
diff --git a/tests/expectations/tests/msvc-no-usr.rs b/tests/expectations/tests/msvc-no-usr.rs
index 285670ed..64db43a6 100644
--- a/tests/expectations/tests/msvc-no-usr.rs
+++ b/tests/expectations/tests/msvc-no-usr.rs
@@ -5,11 +5,10 @@
     non_upper_case_globals
 )]
 
-pub type size_t = ::std::os::raw::c_ulonglong;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct A {
-    pub foo: size_t,
+    pub foo: usize,
 }
 #[test]
 fn bindgen_test_layout_A() {
diff --git a/tests/expectations/tests/no_size_t_is_usize.rs b/tests/expectations/tests/no_size_t_is_usize.rs
new file mode 100644
index 00000000..f399a667
--- /dev/null
+++ b/tests/expectations/tests/no_size_t_is_usize.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type size_t = ::std::os::raw::c_ulong;
+pub type ssize_t = ::std::os::raw::c_long;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct A {
+    pub len: size_t,
+    pub offset: ssize_t,
+    pub next: *mut A,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        24usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        8usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(len))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(offset))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
+        16usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(next))
+    );
+}
+impl Default for A {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/tests/expectations/tests/nsBaseHashtable.rs b/tests/expectations/tests/nsBaseHashtable.rs
index d7607b91..26179b76 100644
--- a/tests/expectations/tests/nsBaseHashtable.rs
+++ b/tests/expectations/tests/nsBaseHashtable.rs
@@ -5,7 +5,6 @@
     non_upper_case_globals
 )]
 
-pub type size_t = ::std::os::raw::c_ulonglong;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct nsBaseHashtableET {
diff --git a/tests/expectations/tests/size_t_is_usize.rs b/tests/expectations/tests/size_t_is_usize.rs
deleted file mode 100644
index 2397e0a5..00000000
--- a/tests/expectations/tests/size_t_is_usize.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct A {
-    pub len: usize,
-    pub offset: isize,
-    pub next: *mut A,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        24usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        8usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(len))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(offset))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
-        16usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(next))
-    );
-}
-impl Default for A {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/headers/no_size_t_is_usize.h b/tests/headers/no_size_t_is_usize.h
new file mode 100644
index 00000000..d4370baf
--- /dev/null
+++ b/tests/headers/no_size_t_is_usize.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --no-size_t-is-usize
+
+typedef unsigned long size_t;
+typedef long ssize_t;
+
+struct A {
+  size_t len;
+  ssize_t offset;
+  struct A* next;
+};
diff --git a/tests/headers/size_t_is_usize.h b/tests/headers/size_t_is_usize.h
deleted file mode 100644
index 564b4867..00000000
--- a/tests/headers/size_t_is_usize.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --size_t-is-usize
-
-typedef unsigned long size_t;
-typedef long ssize_t;
-
-struct A {
-  size_t len;
-  ssize_t offset;
-  struct A* next;
-};
-- 
cgit v1.2.3


From 45b9c3430255bae53777a48feb820ea2fdf837b5 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 21:29:17 -0500
Subject: remove file added by mistake

---
 asd.fish | 31 -------------------------------
 1 file changed, 31 deletions(-)
 delete mode 100644 asd.fish

diff --git a/asd.fish b/asd.fish
deleted file mode 100644
index b6c9a270..00000000
--- a/asd.fish
+++ /dev/null
@@ -1,31 +0,0 @@
-for name in (rg -lF addr_of! tests/expectations | sd '.*/(.*).rs' '$1')
-    set path (fd --glob "$name.*" tests/headers)
-    if test -n "$path"
-
-        set flags (rg -F "// bindgen-flags" $path)
-        if test -n "$flags"
-            set minor (rg ".*\-\-rust\-target[ =]1.(\d+).*" $path -r '$1')
-            if test -n "$minor"
-                if test $minor -gt 47
-                    echo  $path needs to change the version from 1.$minor to 1.47
-                    sd -s "1.$minor" "1.47" $path
-                else
-                    echo $path uses version 1.$minor and that is fine
-                end
-            else
-                echo $path does not have the `--rust-target` flag
-                sd "// bindgen-flags: (.*)" '// bindgen-flags: --rust-target 1.47 $1' $path
-            end
-        else
-            echo $path does not have the flags at all
-            set contents (echo -e "// bindgen-flags: --rust-target 1.47\n"; cat $path)
-            rm $path
-            touch $path
-            for line in $contents
-                echo $line >> $path
-            end
-        end
-    else
-        echo $name headers not found
-    end
-end
-- 
cgit v1.2.3


From a372499b938c817719ccc1958bbdcf71f21e8447 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 15:20:56 -0500
Subject: move codegen postprocessing to its own module

---
 src/codegen/mod.rs            |   5 +-
 src/codegen/postprocessing.rs | 148 ++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs                    | 113 +-------------------------------
 3 files changed, 152 insertions(+), 114 deletions(-)
 create mode 100644 src/codegen/postprocessing.rs

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 8eb7b013..5660b126 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -3,6 +3,7 @@ mod error;
 mod helpers;
 mod impl_debug;
 mod impl_partialeq;
+mod postprocessing;
 pub mod struct_layout;
 
 #[cfg(test)]
@@ -4439,7 +4440,7 @@ impl CodeGenerator for ObjCInterface {
 
 pub(crate) fn codegen(
     context: BindgenContext,
-) -> (Vec<proc_macro2::TokenStream>, BindgenOptions, Vec<String>) {
+) -> (proc_macro2::TokenStream, BindgenOptions, Vec<String>) {
     context.gen(|context| {
         let _t = context.timer("codegen");
         let counter = Cell::new(0);
@@ -4489,7 +4490,7 @@ pub(crate) fn codegen(
             result.push(dynamic_items_tokens);
         }
 
-        result.items
+        postprocessing::postprocessing(result.items, context.options())
     })
 }
 
diff --git a/src/codegen/postprocessing.rs b/src/codegen/postprocessing.rs
new file mode 100644
index 00000000..72832298
--- /dev/null
+++ b/src/codegen/postprocessing.rs
@@ -0,0 +1,148 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::Item;
+
+use crate::BindgenOptions;
+
+macro_rules! decl_postprocessing {
+    ($($ty:ty),*) => {
+        pub(crate) fn postprocessing(
+            items: Vec<TokenStream>,
+            options: &BindgenOptions,
+        ) -> TokenStream {
+            // Whether any of the enabled options requires `syn`.
+            let require_syn = $(<$ty as PostProcessing>::should_run(options))||*;
+
+            if !require_syn {
+                return items.into_iter().collect();
+            }
+
+            let module_wrapped_tokens =
+                quote!(mod wrapper_for_sorting_hack { #( #items )* });
+
+            // This syn business is a hack, for now. This means that we are re-parsing already
+            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+            // control over the elements.
+            // One caveat is that some of the items coming from `quote`d output might have
+            // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
+            // The two `unwrap`s here are deliberate because
+            //      The first one won't panic because we build the `mod` and know it is there
+            //      The second one won't panic because we know original output has something in
+            //      it already.
+            let mut items =
+                syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+                    .unwrap()
+                    .content
+                    .unwrap()
+                    .1;
+
+            $(if <$ty as PostProcessing>::should_run(options) {
+                <$ty as PostProcessing>::run(&mut items);
+            })*
+
+            let synful_items = items
+                .into_iter()
+                .map(|item| item.into_token_stream());
+
+            quote! { #( #synful_items )* }
+        }
+    };
+}
+
+decl_postprocessing! {
+    MergeExternBlocks,
+    SortSemantically
+}
+
+trait PostProcessing {
+    fn should_run(options: &BindgenOptions) -> bool;
+
+    fn run(items: &mut Vec<Item>);
+}
+
+struct SortSemantically;
+
+impl PostProcessing for SortSemantically {
+    #[inline]
+    fn should_run(options: &BindgenOptions) -> bool {
+        options.sort_semantically
+    }
+
+    fn run(items: &mut Vec<Item>) {
+        items.sort_by_key(|item| match item {
+            Item::Type(_) => 0,
+            Item::Struct(_) => 1,
+            Item::Const(_) => 2,
+            Item::Fn(_) => 3,
+            Item::Enum(_) => 4,
+            Item::Union(_) => 5,
+            Item::Static(_) => 6,
+            Item::Trait(_) => 7,
+            Item::TraitAlias(_) => 8,
+            Item::Impl(_) => 9,
+            Item::Mod(_) => 10,
+            Item::Use(_) => 11,
+            Item::Verbatim(_) => 12,
+            Item::ExternCrate(_) => 13,
+            Item::ForeignMod(_) => 14,
+            Item::Macro(_) => 15,
+            Item::Macro2(_) => 16,
+            _ => 18,
+        });
+    }
+}
+
+struct MergeExternBlocks;
+
+impl PostProcessing for MergeExternBlocks {
+    #[inline]
+    fn should_run(options: &BindgenOptions) -> bool {
+        options.merge_extern_blocks
+    }
+
+    fn run(items: &mut Vec<Item>) {
+        // Keep all the extern blocks in a different `Vec` for faster search.
+        let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+
+        for item in std::mem::take(items) {
+            match item {
+                Item::ForeignMod(syn::ItemForeignMod {
+                    attrs,
+                    abi,
+                    brace_token,
+                    items: foreign_items,
+                }) => {
+                    let mut exists = false;
+                    for foreign_mod in &mut foreign_mods {
+                        // Check if there is a extern block with the same ABI and
+                        // attributes.
+                        if foreign_mod.attrs == attrs && foreign_mod.abi == abi
+                        {
+                            // Merge the items of the two blocks.
+                            foreign_mod.items.extend_from_slice(&foreign_items);
+                            exists = true;
+                            break;
+                        }
+                    }
+                    // If no existing extern block had the same ABI and attributes, store
+                    // it.
+                    if !exists {
+                        foreign_mods.push(syn::ItemForeignMod {
+                            attrs,
+                            abi,
+                            brace_token,
+                            items: foreign_items,
+                        });
+                    }
+                }
+                // If the item is not an extern block, we don't have to do anything.
+                _ => items.push(item),
+            }
+        }
+
+        // Move all the extern blocks alongiside the rest of the items.
+        for foreign_mod in foreign_mods {
+            items.push(Item::ForeignMod(foreign_mod));
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 9a5887df..3ee46f75 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,7 +88,6 @@ use std::{env, iter};
 // Some convenient typedefs for a fast hash map and hash set.
 type HashMap<K, V> = ::rustc_hash::FxHashMap<K, V>;
 type HashSet<K> = ::rustc_hash::FxHashSet<K>;
-use quote::ToTokens;
 pub(crate) use std::collections::hash_map::Entry;
 
 /// Default prefix for the anon fields.
@@ -2118,11 +2117,6 @@ struct BindgenOptions {
 impl ::std::panic::UnwindSafe for BindgenOptions {}
 
 impl BindgenOptions {
-    /// Whether any of the enabled options requires `syn`.
-    fn require_syn(&self) -> bool {
-        self.sort_semantically || self.merge_extern_blocks
-    }
-
     fn build(&mut self) {
         let mut regex_sets = [
             &mut self.allowlisted_vars,
@@ -2555,112 +2549,7 @@ impl Bindings {
             parse(&mut context)?;
         }
 
-        let (items, options, warnings) = codegen::codegen(context);
-
-        let module = if options.require_syn() {
-            let module_wrapped_tokens =
-                quote!(mod wrapper_for_sorting_hack { #( #items )* });
-
-            // This syn business is a hack, for now. This means that we are re-parsing already
-            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
-            // control over the elements.
-            // One caveat is that some of the items coming from `quote`d output might have
-            // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-            // The two `unwrap`s here are deliberate because
-            //      The first one won't panic because we build the `mod` and know it is there
-            //      The second one won't panic because we know original output has something in
-            //      it already.
-            let mut syn_parsed_items =
-                syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-                    .unwrap()
-                    .content
-                    .unwrap()
-                    .1;
-
-            if options.merge_extern_blocks {
-                // Here we will store all the items after deduplication.
-                let mut items = Vec::new();
-
-                // Keep all the extern blocks in a different `Vec` for faster search.
-                let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
-                for item in syn_parsed_items {
-                    match item {
-                        syn::Item::ForeignMod(syn::ItemForeignMod {
-                            attrs,
-                            abi,
-                            brace_token,
-                            items: foreign_items,
-                        }) => {
-                            let mut exists = false;
-                            for foreign_mod in &mut foreign_mods {
-                                // Check if there is a extern block with the same ABI and
-                                // attributes.
-                                if foreign_mod.attrs == attrs &&
-                                    foreign_mod.abi == abi
-                                {
-                                    // Merge the items of the two blocks.
-                                    foreign_mod
-                                        .items
-                                        .extend_from_slice(&foreign_items);
-                                    exists = true;
-                                    break;
-                                }
-                            }
-                            // If no existing extern block had the same ABI and attributes, store
-                            // it.
-                            if !exists {
-                                foreign_mods.push(syn::ItemForeignMod {
-                                    attrs,
-                                    abi,
-                                    brace_token,
-                                    items: foreign_items,
-                                });
-                            }
-                        }
-                        // If the item is not an extern block, we don't have to do anything.
-                        _ => items.push(item),
-                    }
-                }
-
-                // Move all the extern blocks alongiside the rest of the items.
-                for foreign_mod in foreign_mods {
-                    items.push(syn::Item::ForeignMod(foreign_mod));
-                }
-
-                syn_parsed_items = items;
-            }
-
-            if options.sort_semantically {
-                syn_parsed_items.sort_by_key(|item| match item {
-                    syn::Item::Type(_) => 0,
-                    syn::Item::Struct(_) => 1,
-                    syn::Item::Const(_) => 2,
-                    syn::Item::Fn(_) => 3,
-                    syn::Item::Enum(_) => 4,
-                    syn::Item::Union(_) => 5,
-                    syn::Item::Static(_) => 6,
-                    syn::Item::Trait(_) => 7,
-                    syn::Item::TraitAlias(_) => 8,
-                    syn::Item::Impl(_) => 9,
-                    syn::Item::Mod(_) => 10,
-                    syn::Item::Use(_) => 11,
-                    syn::Item::Verbatim(_) => 12,
-                    syn::Item::ExternCrate(_) => 13,
-                    syn::Item::ForeignMod(_) => 14,
-                    syn::Item::Macro(_) => 15,
-                    syn::Item::Macro2(_) => 16,
-                    _ => 18,
-                });
-            }
-
-            let synful_items = syn_parsed_items
-                .into_iter()
-                .map(|item| item.into_token_stream());
-
-            quote! { #( #synful_items )* }
-        } else {
-            quote! { #( #items )* }
-        };
+        let (module, options, warnings) = codegen::codegen(context);
 
         Ok(Bindings {
             options,
-- 
cgit v1.2.3


From 3dfbc602ae004f142811ad5ef17435dd04bc16ed Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 15:24:19 -0500
Subject: update `CONTRIBUTING.md` section about `syn`

---
 CONTRIBUTING.md | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2974ba42..3d757ccd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -323,14 +323,12 @@ generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate
 
 ### Implementing new options using `syn`
 
-Here is a list of recommendations to be followed if a new option can be
-implemented using the `syn` crate:
+If a new option can be implemented using the `syn` crate it should be added to
+the `codegen::postprocessing` module by following these steps:
 
-- The `BindgenOptions::require_syn` method must be updated to reflect that this
-  new option requires parsing the generated Rust code with `syn`.
-
-- The implementation of the new option should be added at the end of
-  `Bindings::generate`, inside the `if options.require_syn() { ... }` block.
+- Introduce a new `struct` with no fields.
+- Implement the `PostProcessing` trait for the `struct`.
+- Add the `struct` to the `decl_postprocessing` macro invocation.
 
 ## Pull Requests and Code Reviews
 
-- 
cgit v1.2.3


From 0798bdaccfd352c9b2394b1741508000b99ba1bb Mon Sep 17 00:00:00 2001
From: Emilio Cobos Álvarez <emilio@crisal.io>
Date: Fri, 23 Sep 2022 18:10:38 -1000
Subject: Clean-up postprocessing to use less macro magic.

---
 src/codegen/postprocessing.rs | 227 +++++++++++++++++++-----------------------
 1 file changed, 104 insertions(+), 123 deletions(-)

diff --git a/src/codegen/postprocessing.rs b/src/codegen/postprocessing.rs
index 72832298..6d935a61 100644
--- a/src/codegen/postprocessing.rs
+++ b/src/codegen/postprocessing.rs
@@ -4,145 +4,126 @@ use syn::Item;
 
 use crate::BindgenOptions;
 
-macro_rules! decl_postprocessing {
-    ($($ty:ty),*) => {
-        pub(crate) fn postprocessing(
-            items: Vec<TokenStream>,
-            options: &BindgenOptions,
-        ) -> TokenStream {
-            // Whether any of the enabled options requires `syn`.
-            let require_syn = $(<$ty as PostProcessing>::should_run(options))||*;
-
-            if !require_syn {
-                return items.into_iter().collect();
-            }
-
-            let module_wrapped_tokens =
-                quote!(mod wrapper_for_sorting_hack { #( #items )* });
-
-            // This syn business is a hack, for now. This means that we are re-parsing already
-            // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
-            // control over the elements.
-            // One caveat is that some of the items coming from `quote`d output might have
-            // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-            // The two `unwrap`s here are deliberate because
-            //      The first one won't panic because we build the `mod` and know it is there
-            //      The second one won't panic because we know original output has something in
-            //      it already.
-            let mut items =
-                syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-                    .unwrap()
-                    .content
-                    .unwrap()
-                    .1;
-
-            $(if <$ty as PostProcessing>::should_run(options) {
-                <$ty as PostProcessing>::run(&mut items);
-            })*
-
-            let synful_items = items
-                .into_iter()
-                .map(|item| item.into_token_stream());
+struct PostProcessingPass {
+    should_run: fn(&BindgenOptions) -> bool,
+    run: fn(&mut Vec<Item>),
+}
 
-            quote! { #( #synful_items )* }
+// TODO: This can be a const fn when mutable references are allowed in const
+// context.
+macro_rules! pass {
+    ($pass:ident) => {
+        PostProcessingPass {
+            should_run: |options| options.$pass,
+            run: $pass,
         }
     };
 }
 
-decl_postprocessing! {
-    MergeExternBlocks,
-    SortSemantically
-}
-
-trait PostProcessing {
-    fn should_run(options: &BindgenOptions) -> bool;
-
-    fn run(items: &mut Vec<Item>);
-}
-
-struct SortSemantically;
+static PASSES: [PostProcessingPass; 2] =
+    [pass!(merge_extern_blocks), pass!(sort_semantically)];
 
-impl PostProcessing for SortSemantically {
-    #[inline]
-    fn should_run(options: &BindgenOptions) -> bool {
-        options.sort_semantically
+pub(crate) fn postprocessing(
+    items: Vec<TokenStream>,
+    options: &BindgenOptions,
+) -> TokenStream {
+    let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options));
+    if !require_syn {
+        return items.into_iter().collect();
     }
-
-    fn run(items: &mut Vec<Item>) {
-        items.sort_by_key(|item| match item {
-            Item::Type(_) => 0,
-            Item::Struct(_) => 1,
-            Item::Const(_) => 2,
-            Item::Fn(_) => 3,
-            Item::Enum(_) => 4,
-            Item::Union(_) => 5,
-            Item::Static(_) => 6,
-            Item::Trait(_) => 7,
-            Item::TraitAlias(_) => 8,
-            Item::Impl(_) => 9,
-            Item::Mod(_) => 10,
-            Item::Use(_) => 11,
-            Item::Verbatim(_) => 12,
-            Item::ExternCrate(_) => 13,
-            Item::ForeignMod(_) => 14,
-            Item::Macro(_) => 15,
-            Item::Macro2(_) => 16,
-            _ => 18,
-        });
+    let module_wrapped_tokens =
+        quote!(mod wrapper_for_sorting_hack { #( #items )* });
+
+    // This syn business is a hack, for now. This means that we are re-parsing already
+    // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+    // control over the elements.
+    // One caveat is that some of the items coming from `quote`d output might have
+    // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
+    // The two `unwrap`s here are deliberate because
+    //      The first one won't panic because we build the `mod` and know it is there
+    //      The second one won't panic because we know original output has something in
+    //      it already.
+    let mut items = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+        .unwrap()
+        .content
+        .unwrap()
+        .1;
+
+    for pass in PASSES.iter() {
+        if (pass.should_run)(options) {
+            (pass.run)(&mut items);
+        }
     }
-}
 
-struct MergeExternBlocks;
+    let synful_items = items.into_iter().map(|item| item.into_token_stream());
 
-impl PostProcessing for MergeExternBlocks {
-    #[inline]
-    fn should_run(options: &BindgenOptions) -> bool {
-        options.merge_extern_blocks
-    }
+    quote! { #( #synful_items )* }
+}
 
-    fn run(items: &mut Vec<Item>) {
-        // Keep all the extern blocks in a different `Vec` for faster search.
-        let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+fn sort_semantically(items: &mut Vec<Item>) {
+    items.sort_by_key(|item| match item {
+        Item::Type(_) => 0,
+        Item::Struct(_) => 1,
+        Item::Const(_) => 2,
+        Item::Fn(_) => 3,
+        Item::Enum(_) => 4,
+        Item::Union(_) => 5,
+        Item::Static(_) => 6,
+        Item::Trait(_) => 7,
+        Item::TraitAlias(_) => 8,
+        Item::Impl(_) => 9,
+        Item::Mod(_) => 10,
+        Item::Use(_) => 11,
+        Item::Verbatim(_) => 12,
+        Item::ExternCrate(_) => 13,
+        Item::ForeignMod(_) => 14,
+        Item::Macro(_) => 15,
+        Item::Macro2(_) => 16,
+        _ => 18,
+    });
+}
 
-        for item in std::mem::take(items) {
-            match item {
-                Item::ForeignMod(syn::ItemForeignMod {
-                    attrs,
-                    abi,
-                    brace_token,
-                    items: foreign_items,
-                }) => {
-                    let mut exists = false;
-                    for foreign_mod in &mut foreign_mods {
-                        // Check if there is a extern block with the same ABI and
-                        // attributes.
-                        if foreign_mod.attrs == attrs && foreign_mod.abi == abi
-                        {
-                            // Merge the items of the two blocks.
-                            foreign_mod.items.extend_from_slice(&foreign_items);
-                            exists = true;
-                            break;
-                        }
-                    }
-                    // If no existing extern block had the same ABI and attributes, store
-                    // it.
-                    if !exists {
-                        foreign_mods.push(syn::ItemForeignMod {
-                            attrs,
-                            abi,
-                            brace_token,
-                            items: foreign_items,
-                        });
+fn merge_extern_blocks(items: &mut Vec<Item>) {
+    // Keep all the extern blocks in a different `Vec` for faster search.
+    let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+
+    for item in std::mem::take(items) {
+        match item {
+            Item::ForeignMod(syn::ItemForeignMod {
+                attrs,
+                abi,
+                brace_token,
+                items: foreign_items,
+            }) => {
+                let mut exists = false;
+                for foreign_mod in &mut foreign_mods {
+                    // Check if there is a extern block with the same ABI and
+                    // attributes.
+                    if foreign_mod.attrs == attrs && foreign_mod.abi == abi {
+                        // Merge the items of the two blocks.
+                        foreign_mod.items.extend_from_slice(&foreign_items);
+                        exists = true;
+                        break;
                     }
                 }
-                // If the item is not an extern block, we don't have to do anything.
-                _ => items.push(item),
+                // If no existing extern block had the same ABI and attributes, store
+                // it.
+                if !exists {
+                    foreign_mods.push(syn::ItemForeignMod {
+                        attrs,
+                        abi,
+                        brace_token,
+                        items: foreign_items,
+                    });
+                }
             }
+            // If the item is not an extern block, we don't have to do anything.
+            _ => items.push(item),
         }
+    }
 
-        // Move all the extern blocks alongiside the rest of the items.
-        for foreign_mod in foreign_mods {
-            items.push(Item::ForeignMod(foreign_mod));
-        }
+    // Move all the extern blocks alongside the rest of the items.
+    for foreign_mod in foreign_mods {
+        items.push(Item::ForeignMod(foreign_mod));
     }
 }
-- 
cgit v1.2.3


From 4312df317a2fdf26ec889cb2f8d3ffe0b12ea4d3 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 26 Sep 2022 10:55:05 -0500
Subject: update CONTRIBUTING.md

---
 CONTRIBUTING.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3d757ccd..48e4a402 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -326,9 +326,11 @@ generated Rust code are implemented using the [`syn`](https://docs.rs/syn) crate
 If a new option can be implemented using the `syn` crate it should be added to
 the `codegen::postprocessing` module by following these steps:
 
-- Introduce a new `struct` with no fields.
-- Implement the `PostProcessing` trait for the `struct`.
-- Add the `struct` to the `decl_postprocessing` macro invocation.
+- Introduce a new field to `BindgenOptions` for the option.
+- Write a free function inside `codegen::postprocessing` implementing the
+  option. This function with the same name of the `BindgenOptions` field.
+- Add a new value to the `codegen::postprocessing::PASSES` for the option using
+  the `pass!` macro.
 
 ## Pull Requests and Code Reviews
 
-- 
cgit v1.2.3


From 06a6479e9e6fe9b556a54b3d7f28c23b1268b048 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 26 Sep 2022 11:02:42 -0500
Subject: s/static/const

---
 src/codegen/postprocessing.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/codegen/postprocessing.rs b/src/codegen/postprocessing.rs
index 6d935a61..6550ca57 100644
--- a/src/codegen/postprocessing.rs
+++ b/src/codegen/postprocessing.rs
@@ -20,8 +20,8 @@ macro_rules! pass {
     };
 }
 
-static PASSES: [PostProcessingPass; 2] =
-    [pass!(merge_extern_blocks), pass!(sort_semantically)];
+const PASSES: &'static [PostProcessingPass] =
+    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
 
 pub(crate) fn postprocessing(
     items: Vec<TokenStream>,
@@ -43,13 +43,12 @@ pub(crate) fn postprocessing(
     //      The first one won't panic because we build the `mod` and know it is there
     //      The second one won't panic because we know original output has something in
     //      it already.
-    let mut items = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
         .unwrap()
         .content
-        .unwrap()
-        .1;
+        .unwrap();
 
-    for pass in PASSES.iter() {
+    for pass in PASSES {
         if (pass.should_run)(options) {
             (pass.run)(&mut items);
         }
-- 
cgit v1.2.3


From 4cfd06e9e13f0c4177f052677fb7d67dc0367176 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 26 Sep 2022 13:22:15 -0500
Subject: make `BindgenOptions` clonable

---
 src/deps.rs       |  2 +-
 src/ir/context.rs |  7 +++++--
 src/lib.rs        | 30 +++++++++++++-----------------
 src/regex_set.rs  |  2 +-
 4 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/src/deps.rs b/src/deps.rs
index 479c396c..987225b2 100644
--- a/src/deps.rs
+++ b/src/deps.rs
@@ -1,7 +1,7 @@
 /// Generating build depfiles from parsed bindings.
 use std::{collections::BTreeSet, path::PathBuf};
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub(crate) struct DepfileSpec {
     pub output_module: String,
     pub depfile_path: PathBuf,
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 7837e594..ec0fca16 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -505,7 +505,10 @@ impl<'ctx> AllowlistedItemsTraversal<'ctx> {
 
 impl BindgenContext {
     /// Construct the context for the given `options`.
-    pub(crate) fn new(options: BindgenOptions) -> Self {
+    pub(crate) fn new(
+        options: BindgenOptions,
+        input_unsaved_files: &[clang::UnsavedFile],
+    ) -> Self {
         // TODO(emilio): Use the CXTargetInfo here when available.
         //
         // see: https://reviews.llvm.org/D32389
@@ -522,7 +525,7 @@ impl BindgenContext {
                 &index,
                 "",
                 &options.clang_args,
-                &options.input_unsaved_files,
+                &input_unsaved_files,
                 parse_options,
             ).expect("libclang error; possible causes include:
 - Invalid flag syntax
diff --git a/src/lib.rs b/src/lib.rs
index 9a5887df..81a58116 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -83,6 +83,7 @@ use std::fs::{File, OpenOptions};
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
+use std::rc::Rc;
 use std::{env, iter};
 
 // Some convenient typedefs for a fast hash map and hash set.
@@ -1466,7 +1467,7 @@ impl Builder {
         mut self,
         cb: Box<dyn callbacks::ParseCallbacks>,
     ) -> Self {
-        self.options.parse_callbacks = Some(cb);
+        self.options.parse_callbacks = Some(Rc::from(cb));
         self
     }
 
@@ -1575,15 +1576,13 @@ impl Builder {
             }),
         );
 
-        self.options.input_unsaved_files.extend(
-            self.input_header_contents
-                .drain(..)
-                .map(|(name, contents)| {
-                    clang::UnsavedFile::new(&name, &contents)
-                }),
-        );
+        let input_unsaved_files = self
+            .input_header_contents
+            .into_iter()
+            .map(|(name, contents)| clang::UnsavedFile::new(&name, &contents))
+            .collect::<Vec<_>>();
 
-        Bindings::generate(self.options)
+        Bindings::generate(self.options, input_unsaved_files)
     }
 
     /// Preprocess and dump the input header files to disk.
@@ -1775,7 +1774,7 @@ impl Builder {
 }
 
 /// Configuration options for generated bindings.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 struct BindgenOptions {
     /// The set of types that have been blocklisted and should not appear
     /// anywhere in the generated code.
@@ -1978,12 +1977,9 @@ struct BindgenOptions {
     /// Any additional input header files.
     extra_input_headers: Vec<String>,
 
-    /// Unsaved files for input.
-    input_unsaved_files: Vec<clang::UnsavedFile>,
-
     /// A user-provided visitor to allow customizing different kinds of
     /// situations.
-    parse_callbacks: Option<Box<dyn callbacks::ParseCallbacks>>,
+    parse_callbacks: Option<Rc<dyn callbacks::ParseCallbacks>>,
 
     /// Which kind of items should we generate? By default, we'll generate all
     /// of them.
@@ -2236,7 +2232,6 @@ impl Default for BindgenOptions {
             clang_args: vec![],
             input_header: None,
             extra_input_headers: vec![],
-            input_unsaved_files: vec![],
             parse_callbacks: None,
             codegen_config: CodegenConfig::all(),
             conservative_inline_namespaces: false,
@@ -2394,6 +2389,7 @@ impl Bindings {
     /// Generate bindings for the given options.
     pub(crate) fn generate(
         mut options: BindgenOptions,
+        input_unsaved_files: Vec<clang::UnsavedFile>,
     ) -> Result<Bindings, BindgenError> {
         ensure_libclang_is_loaded();
 
@@ -2528,7 +2524,7 @@ impl Bindings {
             }
         }
 
-        for (idx, f) in options.input_unsaved_files.iter().enumerate() {
+        for (idx, f) in input_unsaved_files.iter().enumerate() {
             if idx != 0 || options.input_header.is_some() {
                 options.clang_args.push("-include".to_owned());
             }
@@ -2538,7 +2534,7 @@ impl Bindings {
         debug!("Fixed-up options: {:?}", options);
 
         let time_phases = options.time_phases;
-        let mut context = BindgenContext::new(options);
+        let mut context = BindgenContext::new(options, &input_unsaved_files);
 
         if is_host_build {
             debug_assert_eq!(
diff --git a/src/regex_set.rs b/src/regex_set.rs
index 127c0018..9262c4ee 100644
--- a/src/regex_set.rs
+++ b/src/regex_set.rs
@@ -4,7 +4,7 @@ use regex::RegexSet as RxSet;
 use std::cell::Cell;
 
 /// A dynamic set of regular expressions.
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RegexSet {
     items: Vec<String>,
     /// Whether any of the items in the set was ever matched. The length of this
-- 
cgit v1.2.3


From ddb319ce3579b687cdd06d934ac40c253e96221f Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Tue, 27 Sep 2022 13:43:33 -0500
Subject: split `processing` module

---
 src/codegen/postprocessing.rs                     | 128 ----------------------
 src/codegen/postprocessing/merge_extern_blocks.rs |  46 ++++++++
 src/codegen/postprocessing/mod.rs                 |  66 +++++++++++
 src/codegen/postprocessing/sort_semantically.rs   |  24 ++++
 4 files changed, 136 insertions(+), 128 deletions(-)
 delete mode 100644 src/codegen/postprocessing.rs
 create mode 100644 src/codegen/postprocessing/merge_extern_blocks.rs
 create mode 100644 src/codegen/postprocessing/mod.rs
 create mode 100644 src/codegen/postprocessing/sort_semantically.rs

diff --git a/src/codegen/postprocessing.rs b/src/codegen/postprocessing.rs
deleted file mode 100644
index 6550ca57..00000000
--- a/src/codegen/postprocessing.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-use syn::Item;
-
-use crate::BindgenOptions;
-
-struct PostProcessingPass {
-    should_run: fn(&BindgenOptions) -> bool,
-    run: fn(&mut Vec<Item>),
-}
-
-// TODO: This can be a const fn when mutable references are allowed in const
-// context.
-macro_rules! pass {
-    ($pass:ident) => {
-        PostProcessingPass {
-            should_run: |options| options.$pass,
-            run: $pass,
-        }
-    };
-}
-
-const PASSES: &'static [PostProcessingPass] =
-    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
-
-pub(crate) fn postprocessing(
-    items: Vec<TokenStream>,
-    options: &BindgenOptions,
-) -> TokenStream {
-    let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options));
-    if !require_syn {
-        return items.into_iter().collect();
-    }
-    let module_wrapped_tokens =
-        quote!(mod wrapper_for_sorting_hack { #( #items )* });
-
-    // This syn business is a hack, for now. This means that we are re-parsing already
-    // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
-    // control over the elements.
-    // One caveat is that some of the items coming from `quote`d output might have
-    // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-    // The two `unwrap`s here are deliberate because
-    //      The first one won't panic because we build the `mod` and know it is there
-    //      The second one won't panic because we know original output has something in
-    //      it already.
-    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-        .unwrap()
-        .content
-        .unwrap();
-
-    for pass in PASSES {
-        if (pass.should_run)(options) {
-            (pass.run)(&mut items);
-        }
-    }
-
-    let synful_items = items.into_iter().map(|item| item.into_token_stream());
-
-    quote! { #( #synful_items )* }
-}
-
-fn sort_semantically(items: &mut Vec<Item>) {
-    items.sort_by_key(|item| match item {
-        Item::Type(_) => 0,
-        Item::Struct(_) => 1,
-        Item::Const(_) => 2,
-        Item::Fn(_) => 3,
-        Item::Enum(_) => 4,
-        Item::Union(_) => 5,
-        Item::Static(_) => 6,
-        Item::Trait(_) => 7,
-        Item::TraitAlias(_) => 8,
-        Item::Impl(_) => 9,
-        Item::Mod(_) => 10,
-        Item::Use(_) => 11,
-        Item::Verbatim(_) => 12,
-        Item::ExternCrate(_) => 13,
-        Item::ForeignMod(_) => 14,
-        Item::Macro(_) => 15,
-        Item::Macro2(_) => 16,
-        _ => 18,
-    });
-}
-
-fn merge_extern_blocks(items: &mut Vec<Item>) {
-    // Keep all the extern blocks in a different `Vec` for faster search.
-    let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
-
-    for item in std::mem::take(items) {
-        match item {
-            Item::ForeignMod(syn::ItemForeignMod {
-                attrs,
-                abi,
-                brace_token,
-                items: foreign_items,
-            }) => {
-                let mut exists = false;
-                for foreign_mod in &mut foreign_mods {
-                    // Check if there is a extern block with the same ABI and
-                    // attributes.
-                    if foreign_mod.attrs == attrs && foreign_mod.abi == abi {
-                        // Merge the items of the two blocks.
-                        foreign_mod.items.extend_from_slice(&foreign_items);
-                        exists = true;
-                        break;
-                    }
-                }
-                // If no existing extern block had the same ABI and attributes, store
-                // it.
-                if !exists {
-                    foreign_mods.push(syn::ItemForeignMod {
-                        attrs,
-                        abi,
-                        brace_token,
-                        items: foreign_items,
-                    });
-                }
-            }
-            // If the item is not an extern block, we don't have to do anything.
-            _ => items.push(item),
-        }
-    }
-
-    // Move all the extern blocks alongside the rest of the items.
-    for foreign_mod in foreign_mods {
-        items.push(Item::ForeignMod(foreign_mod));
-    }
-}
diff --git a/src/codegen/postprocessing/merge_extern_blocks.rs b/src/codegen/postprocessing/merge_extern_blocks.rs
new file mode 100644
index 00000000..2b761494
--- /dev/null
+++ b/src/codegen/postprocessing/merge_extern_blocks.rs
@@ -0,0 +1,46 @@
+use syn::{Item, ItemForeignMod};
+
+pub(super) fn merge_extern_blocks(items: &mut Vec<Item>) {
+    // Keep all the extern blocks in a different `Vec` for faster search.
+    let mut foreign_mods = Vec::<ItemForeignMod>::new();
+
+    for item in std::mem::take(items) {
+        match item {
+            Item::ForeignMod(ItemForeignMod {
+                attrs,
+                abi,
+                brace_token,
+                items: foreign_items,
+            }) => {
+                let mut exists = false;
+                for foreign_mod in &mut foreign_mods {
+                    // Check if there is a extern block with the same ABI and
+                    // attributes.
+                    if foreign_mod.attrs == attrs && foreign_mod.abi == abi {
+                        // Merge the items of the two blocks.
+                        foreign_mod.items.extend_from_slice(&foreign_items);
+                        exists = true;
+                        break;
+                    }
+                }
+                // If no existing extern block had the same ABI and attributes, store
+                // it.
+                if !exists {
+                    foreign_mods.push(ItemForeignMod {
+                        attrs,
+                        abi,
+                        brace_token,
+                        items: foreign_items,
+                    });
+                }
+            }
+            // If the item is not an extern block, we don't have to do anything.
+            _ => items.push(item),
+        }
+    }
+
+    // Move all the extern blocks alongside the rest of the items.
+    for foreign_mod in foreign_mods {
+        items.push(Item::ForeignMod(foreign_mod));
+    }
+}
diff --git a/src/codegen/postprocessing/mod.rs b/src/codegen/postprocessing/mod.rs
new file mode 100644
index 00000000..c6612f2b
--- /dev/null
+++ b/src/codegen/postprocessing/mod.rs
@@ -0,0 +1,66 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::Item;
+
+use crate::BindgenOptions;
+
+mod merge_extern_blocks;
+mod sort_semantically;
+
+use merge_extern_blocks::merge_extern_blocks;
+use sort_semantically::sort_semantically;
+
+struct PostProcessingPass {
+    should_run: fn(&BindgenOptions) -> bool,
+    run: fn(&mut Vec<Item>),
+}
+
+// TODO: This can be a const fn when mutable references are allowed in const
+// context.
+macro_rules! pass {
+    ($pass:ident) => {
+        PostProcessingPass {
+            should_run: |options| options.$pass,
+            run: |items| $pass(items),
+        }
+    };
+}
+
+const PASSES: &[PostProcessingPass] =
+    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
+
+pub(crate) fn postprocessing(
+    items: Vec<TokenStream>,
+    options: &BindgenOptions,
+) -> TokenStream {
+    let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options));
+    if !require_syn {
+        return items.into_iter().collect();
+    }
+    let module_wrapped_tokens =
+        quote!(mod wrapper_for_sorting_hack { #( #items )* });
+
+    // This syn business is a hack, for now. This means that we are re-parsing already
+    // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+    // control over the elements.
+    // One caveat is that some of the items coming from `quote`d output might have
+    // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
+    // The two `unwrap`s here are deliberate because
+    //      The first one won't panic because we build the `mod` and know it is there
+    //      The second one won't panic because we know original output has something in
+    //      it already.
+    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+        .unwrap()
+        .content
+        .unwrap();
+
+    for pass in PASSES {
+        if (pass.should_run)(options) {
+            (pass.run)(&mut items);
+        }
+    }
+
+    let synful_items = items.into_iter().map(|item| item.into_token_stream());
+
+    quote! { #( #synful_items )* }
+}
diff --git a/src/codegen/postprocessing/sort_semantically.rs b/src/codegen/postprocessing/sort_semantically.rs
new file mode 100644
index 00000000..96596cb0
--- /dev/null
+++ b/src/codegen/postprocessing/sort_semantically.rs
@@ -0,0 +1,24 @@
+use syn::Item;
+
+pub(super) fn sort_semantically(items: &mut [Item]) {
+    items.sort_by_key(|item| match item {
+        Item::Type(_) => 0,
+        Item::Struct(_) => 1,
+        Item::Const(_) => 2,
+        Item::Fn(_) => 3,
+        Item::Enum(_) => 4,
+        Item::Union(_) => 5,
+        Item::Static(_) => 6,
+        Item::Trait(_) => 7,
+        Item::TraitAlias(_) => 8,
+        Item::Impl(_) => 9,
+        Item::Mod(_) => 10,
+        Item::Use(_) => 11,
+        Item::Verbatim(_) => 12,
+        Item::ExternCrate(_) => 13,
+        Item::ForeignMod(_) => 14,
+        Item::Macro(_) => 15,
+        Item::Macro2(_) => 16,
+        _ => 18,
+    });
+}
-- 
cgit v1.2.3


From 70115a08631f6928efbe5d685043676bf68e3123 Mon Sep 17 00:00:00 2001
From: Geoffry Song <goffrie@gmail.com>
Date: Tue, 27 Sep 2022 21:17:41 +0000
Subject: Don't traverse through special-cased <stdint.h> types.

---
 src/ir/context.rs                          | 34 +++++++++++++++----------
 src/ir/ty.rs                               |  7 +++++
 tests/expectations/tests/stdint_typedef.rs | 41 ++++++++++++++++++++++++++++++
 tests/headers/stdint_typedef.h             | 10 ++++++++
 4 files changed, 78 insertions(+), 14 deletions(-)
 create mode 100644 tests/expectations/tests/stdint_typedef.rs
 create mode 100644 tests/headers/stdint_typedef.h

diff --git a/src/ir/context.rs b/src/ir/context.rs
index 7837e594..d470efa9 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -2250,24 +2250,27 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                         // Sized integer types from <stdint.h> get mapped to Rust primitive
                         // types regardless of whether they are blocklisted, so ensure that
                         // standard traits are considered derivable for them too.
-                        None => match name {
-                            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" |
-                            "int32_t" | "uint32_t" | "int64_t" |
-                            "uint64_t" | "uintptr_t" | "intptr_t" |
-                            "ptrdiff_t" => Some(CanDerive::Yes),
-                            "size_t" if self.options.size_t_is_usize => {
-                                Some(CanDerive::Yes)
-                            }
-                            "ssize_t" if self.options.size_t_is_usize => {
-                                Some(CanDerive::Yes)
-                            }
-                            _ => Some(CanDerive::No),
-                        },
+                        None => Some(if self.is_stdint_type(name) {
+                            CanDerive::Yes
+                        } else {
+                            CanDerive::No
+                        }),
                     })
                     .unwrap_or(CanDerive::No)
             })
     }
 
+    /// Is the given type a type from <stdint.h> that corresponds to a Rust primitive type?
+    pub fn is_stdint_type(&self, name: &str) -> bool {
+        match name {
+            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" | "int32_t" |
+            "uint32_t" | "int64_t" | "uint64_t" | "uintptr_t" |
+            "intptr_t" | "ptrdiff_t" => true,
+            "size_t" | "ssize_t" => self.options.size_t_is_usize,
+            _ => false,
+        }
+    }
+
     /// Get a reference to the set of items we should generate.
     pub fn codegen_items(&self) -> &ItemSet {
         assert!(self.in_codegen_phase());
@@ -2355,7 +2358,10 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                                     TypeKind::Opaque |
                                     TypeKind::TypeParam => return true,
                                     _ => {}
-                                };
+                                }
+                                if self.is_stdint_type(&name) {
+                                    return true;
+                                }
                             }
 
                             // Unnamed top-level enums are special and we
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
index c85bc687..6a3fd0e8 100644
--- a/src/ir/ty.rs
+++ b/src/ir/ty.rs
@@ -1206,6 +1206,13 @@ impl Trace for Type {
     where
         T: Tracer,
     {
+        if self
+            .name()
+            .map_or(false, |name| context.is_stdint_type(name))
+        {
+            // These types are special-cased in codegen and don't need to be traversed.
+            return;
+        }
         match *self.kind() {
             TypeKind::Pointer(inner) |
             TypeKind::Reference(inner) |
diff --git a/tests/expectations/tests/stdint_typedef.rs b/tests/expectations/tests/stdint_typedef.rs
new file mode 100644
index 00000000..a52db496
--- /dev/null
+++ b/tests/expectations/tests/stdint_typedef.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn fun() -> u64;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Struct {
+    pub field: u64,
+}
+#[test]
+fn bindgen_test_layout_Struct() {
+    const UNINIT: ::std::mem::MaybeUninit<Struct> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Struct>(),
+        8usize,
+        concat!("Size of: ", stringify!(Struct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Struct>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Struct))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Struct),
+            "::",
+            stringify!(field)
+        )
+    );
+}
diff --git a/tests/headers/stdint_typedef.h b/tests/headers/stdint_typedef.h
new file mode 100644
index 00000000..f716a7f1
--- /dev/null
+++ b/tests/headers/stdint_typedef.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --allowlist-type="Struct" --allowlist-function="fun"
+
+// no typedef should be emitted for `__uint64_t`
+typedef unsigned long long __uint64_t;
+typedef __uint64_t uint64_t;
+
+uint64_t fun();
+struct Struct {
+	uint64_t field;
+};
-- 
cgit v1.2.3


From 8b69ba05aa685d3bf02f7f21bc5cab63262e1de5 Mon Sep 17 00:00:00 2001
From: Cameron Mulhern <csmulhern@gmail.com>
Date: Mon, 27 Dec 2021 10:49:50 -0500
Subject: Enables blocklisting of Objective-C methods

---
 book/src/objc.md                           |  2 ++
 src/codegen/mod.rs                         | 32 ++++++++++++++++++-----
 tests/expectations/tests/objc_blocklist.rs | 42 ++++++++++++++++++++++++++++++
 tests/headers/objc_blocklist.h             |  9 +++++++
 4 files changed, 78 insertions(+), 7 deletions(-)
 create mode 100644 tests/expectations/tests/objc_blocklist.rs
 create mode 100644 tests/headers/objc_blocklist.h

diff --git a/book/src/objc.md b/book/src/objc.md
index 60e5638d..ce6d7567 100644
--- a/book/src/objc.md
+++ b/book/src/objc.md
@@ -32,6 +32,8 @@ methods found in `NSObject`.
 In order to initialize a class `Foo`, you will have to do something like `let
 foo = Foo(Foo::alloc().initWithStuff())`.
 
+To blocklist an Objective-C method, you should add the bindgen generated method
+path (e.g. `IFoo::method` or `IFoo::class_method`) as a blocklist item.
 
 ## Supported Features
 
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 5660b126..a8a7b076 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -4191,9 +4191,19 @@ impl CodeGenerator for Function {
 fn objc_method_codegen(
     ctx: &BindgenContext,
     method: &ObjCMethod,
+    methods: &mut Vec<proc_macro2::TokenStream>,
     class_name: Option<&str>,
+    rust_class_name: &str,
     prefix: &str,
-) -> proc_macro2::TokenStream {
+) {
+    // This would ideally resolve the method into an Item, and use
+    // Item::process_before_codegen; however, ObjC methods are not currently
+    // made into function items.
+    let name = format!("{}::{}{}", rust_class_name, prefix, method.rust_name());
+    if ctx.options().blocklisted_items.matches(name) {
+        return;
+    }
+
     let signature = method.signature();
     let fn_args = utils::fnsig_arguments(ctx, signature);
     let fn_ret = utils::fnsig_return_ty(ctx, signature);
@@ -4229,11 +4239,11 @@ fn objc_method_codegen(
     let method_name =
         ctx.rust_ident(format!("{}{}", prefix, method.rust_name()));
 
-    quote! {
+    methods.push(quote! {
         unsafe fn #method_name #sig where <Self as std::ops::Deref>::Target: objc::Message + Sized {
             #body
         }
-    }
+    });
 }
 
 impl CodeGenerator for ObjCInterface {
@@ -4249,10 +4259,17 @@ impl CodeGenerator for ObjCInterface {
         debug_assert!(item.is_enabled_for_codegen(ctx));
 
         let mut impl_items = vec![];
+        let rust_class_name = item.path_for_allowlisting(ctx)[1..].join("::");
 
         for method in self.methods() {
-            let impl_item = objc_method_codegen(ctx, method, None, "");
-            impl_items.push(impl_item);
+            objc_method_codegen(
+                ctx,
+                method,
+                &mut impl_items,
+                None,
+                &rust_class_name,
+                "",
+            );
         }
 
         for class_method in self.class_methods() {
@@ -4262,13 +4279,14 @@ impl CodeGenerator for ObjCInterface {
                 .map(|m| m.rust_name())
                 .any(|x| x == class_method.rust_name());
             let prefix = if ambiquity { "class_" } else { "" };
-            let impl_item = objc_method_codegen(
+            objc_method_codegen(
                 ctx,
                 class_method,
+                &mut impl_items,
                 Some(self.name()),
+                &rust_class_name,
                 prefix,
             );
-            impl_items.push(impl_item);
         }
 
         let trait_name = ctx.rust_ident(self.rust_name());
diff --git a/tests/expectations/tests/objc_blocklist.rs b/tests/expectations/tests/objc_blocklist.rs
new file mode 100644
index 00000000..7d5d19b0
--- /dev/null
+++ b/tests/expectations/tests/objc_blocklist.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+#[macro_use]
+extern crate objc;
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct SomeClass(pub id);
+impl std::ops::Deref for SomeClass {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for SomeClass {}
+impl SomeClass {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(SomeClass), alloc) })
+    }
+}
+impl ISomeClass for SomeClass {}
+pub trait ISomeClass: Sized + std::ops::Deref {
+    unsafe fn ambiguouslyBlockedMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, ambiguouslyBlockedMethod)
+    }
+    unsafe fn instanceMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, instanceMethod)
+    }
+}
diff --git a/tests/headers/objc_blocklist.h b/tests/headers/objc_blocklist.h
new file mode 100644
index 00000000..605f2993
--- /dev/null
+++ b/tests/headers/objc_blocklist.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --objc-extern-crate --blocklist-item ISomeClass::class_ambiguouslyBlockedMethod --blocklist-item ISomeClass::blockedInstanceMethod -- -x objective-c
+// bindgen-osx-only
+
+@interface SomeClass
++ (void)ambiguouslyBlockedMethod;
+- (void)ambiguouslyBlockedMethod;
+- (void)instanceMethod;
+- (void)blockedInstanceMethod;
+@end
-- 
cgit v1.2.3


From 17252c73fa2820da7a4c4f0027545b976fd95dc3 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 3 Oct 2022 10:01:46 -0500
Subject: remove reference

---
 src/ir/context.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ir/context.rs b/src/ir/context.rs
index ec0fca16..6f16e192 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -525,7 +525,7 @@ impl BindgenContext {
                 &index,
                 "",
                 &options.clang_args,
-                &input_unsaved_files,
+                input_unsaved_files,
                 parse_options,
             ).expect("libclang error; possible causes include:
 - Invalid flag syntax
-- 
cgit v1.2.3


From cebdedcc40f55d85d1370455c9d596a7c4ac1a19 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Mon, 3 Oct 2022 13:02:03 -0500
Subject: address clippy lints

---
 src/codegen/mod.rs |  2 +-
 src/ir/enum_ty.rs  |  2 +-
 src/ir/var.rs      | 10 +++-------
 src/lib.rs         |  2 +-
 src/options.rs     |  8 ++++----
 tests/tests.rs     |  8 ++++----
 6 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index a8a7b076..7e0d7aa0 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -3439,7 +3439,7 @@ impl std::str::FromStr for AliasVariation {
 }
 
 /// Enum for how non-Copy unions should be translated.
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum NonCopyUnionStyle {
     /// Wrap members in a type generated by bindgen.
     BindgenWrapper,
diff --git a/src/ir/enum_ty.rs b/src/ir/enum_ty.rs
index 2b039a4f..123d1d79 100644
--- a/src/ir/enum_ty.rs
+++ b/src/ir/enum_ty.rs
@@ -165,7 +165,7 @@ impl Enum {
             return false;
         }
 
-        self.variants().iter().any(|v| enums.matches(&v.name()))
+        self.variants().iter().any(|v| enums.matches(v.name()))
     }
 
     /// Returns the final representation of the enum.
diff --git a/src/ir/var.rs b/src/ir/var.rs
index e44d57af..eecca4df 100644
--- a/src/ir/var.rs
+++ b/src/ir/var.rs
@@ -325,8 +325,7 @@ impl ClangSubItemParser for Var {
 
                     let mut val = cursor.evaluate().and_then(|v| v.as_int());
                     if val.is_none() || !kind.signedness_matches(val.unwrap()) {
-                        let tu = ctx.translation_unit();
-                        val = get_integer_literal_from_cursor(&cursor, tu);
+                        val = get_integer_literal_from_cursor(&cursor);
                     }
 
                     val.map(|val| {
@@ -391,10 +390,7 @@ fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option<i64> {
     }
 }
 
-fn get_integer_literal_from_cursor(
-    cursor: &clang::Cursor,
-    unit: &clang::TranslationUnit,
-) -> Option<i64> {
+fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option<i64> {
     use clang_sys::*;
     let mut value = None;
     cursor.visit(|c| {
@@ -403,7 +399,7 @@ fn get_integer_literal_from_cursor(
                 value = parse_int_literal_tokens(&c);
             }
             CXCursor_UnexposedExpr => {
-                value = get_integer_literal_from_cursor(&c, unit);
+                value = get_integer_literal_from_cursor(&c);
             }
             _ => (),
         }
diff --git a/src/lib.rs b/src/lib.rs
index b2467fbc..6e6fa225 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2647,7 +2647,7 @@ impl Bindings {
             .as_ref()
             .and_then(|f| f.to_str())
         {
-            cmd.args(&["--config-path", path]);
+            cmd.args(["--config-path", path]);
         }
 
         let mut child = cmd.spawn()?;
diff --git a/src/options.rs b/src/options.rs
index 29edb78b..1025a36d 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -39,7 +39,7 @@ where
                 .help("The default style of code used to generate enums.")
                 .value_name("variant")
                 .default_value("consts")
-                .possible_values(&[
+                .possible_values([
                     "consts",
                     "moduleconsts",
                     "bitfield",
@@ -98,14 +98,14 @@ where
                 .help("The default signed/unsigned type for C macro constants.")
                 .value_name("variant")
                 .default_value("unsigned")
-                .possible_values(&["signed", "unsigned"])
+                .possible_values(["signed", "unsigned"])
                 .multiple_occurrences(false),
             Arg::new("default-alias-style")
                 .long("default-alias-style")
                 .help("The default style of code used to generate typedefs.")
                 .value_name("variant")
                 .default_value("type_alias")
-                .possible_values(&[
+                .possible_values([
                     "type_alias",
                     "new_type",
                     "new_type_deref",
@@ -147,7 +147,7 @@ where
                 )
                 .value_name("style")
                 .default_value("bindgen_wrapper")
-                .possible_values(&[
+                .possible_values([
                     "bindgen_wrapper",
                     "manually_drop",
                 ])
diff --git a/tests/tests.rs b/tests/tests.rs
index 8dcc5437..ac53d739 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -31,7 +31,7 @@ fn rustfmt(source: String) -> (String, String) {
 
         let mut rustfmt = {
             let mut p = process::Command::new("rustup");
-            p.args(&["run", "nightly", "rustfmt", "--version"]);
+            p.args(["run", "nightly", "rustfmt", "--version"]);
             p
         };
 
@@ -59,13 +59,13 @@ The latest `rustfmt` is required to run the `bindgen` test suite. Install
         Some(r) => process::Command::new(r),
         None => {
             let mut p = process::Command::new("rustup");
-            p.args(&["run", "nightly", "rustfmt"]);
+            p.args(["run", "nightly", "rustfmt"]);
             p
         }
     };
 
     let mut child = child
-        .args(&[
+        .args([
             "--config-path",
             concat!(env!("CARGO_MANIFEST_DIR"), "/tests/rustfmt.toml"),
         ])
@@ -164,7 +164,7 @@ fn error_diff_mismatch(
         let mut actual_result_file = fs::File::create(&actual_result_path)?;
         actual_result_file.write_all(actual.as_bytes())?;
         std::process::Command::new(var)
-            .args(&[filename, &actual_result_path])
+            .args([filename, &actual_result_path])
             .output()?;
     }
 
-- 
cgit v1.2.3


From 0296f9e86c7756e718b6b82836ce1e09b5f8d08a Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 23 Sep 2022 21:36:14 -0500
Subject: split the repo into a workspace

remove `clap` dependency :tada:

update the book installation instructions
---
 .github/workflows/bindgen.yml                      |      4 +-
 .gitignore                                         |      3 +-
 Cargo.lock                                         |    364 +-
 Cargo.toml                                         |     97 +-
 bindgen-cli/Cargo.toml                             |     44 +
 bindgen-cli/main.rs                                |     77 +
 bindgen-cli/options.rs                             |   1092 +
 bindgen-integration/Cargo.toml                     |      2 +-
 bindgen-integration/build.rs                       |     29 +-
 bindgen-tests/Cargo.toml                           |     28 +
 bindgen-tests/build.rs                             |     49 +
 bindgen-tests/src/lib.rs                           |      1 +
 bindgen-tests/tests/.gitattributes                 |      4 +
 bindgen-tests/tests/expectations/Cargo.toml        |     15 +
 bindgen-tests/tests/expectations/build.rs          |     63 +
 bindgen-tests/tests/expectations/lib.rs            |      3 +
 bindgen-tests/tests/expectations/src/lib.rs        |      1 +
 .../struct_with_anon_struct_array_float.rs         |      1 +
 .../tests/expectations/tests/.gitattributes        |      2 +
 .../tests/expectations/tests/16-byte-alignment.rs  |    355 +
 .../expectations/tests/16-byte-alignment_1_0.rs    |    396 +
 .../tests/expectations/tests/381-decltype-alias.rs |     13 +
 .../tests/expectations/tests/accessors.rs          |    434 +
 .../tests/expectations/tests/allowlist-file.rs     |    155 +
 .../tests/allowlist-namespaces-basic.rs            |     38 +
 .../expectations/tests/allowlist-namespaces.rs     |     71 +
 .../tests/expectations/tests/allowlist_basic.rs    |     38 +
 .../tests/expectations/tests/allowlist_fix.rs      |     12 +
 .../tests/expectations/tests/allowlist_vars.rs     |     11 +
 .../tests/expectations/tests/allowlist_warnings.rs |      6 +
 .../tests/allowlisted-item-references-no-hash.rs   |     56 +
 .../allowlisted-item-references-no-partialeq.rs    |     56 +
 .../tests/allowlisted_item_references_no_copy.rs   |     56 +
 .../tests/expectations/tests/annotation_hide.rs    |     58 +
 .../tests/expectations/tests/anon-fields-prefix.rs |    150 +
 .../tests/expectations/tests/anon_enum.rs          |     51 +
 .../expectations/tests/anon_enum_allowlist.rs      |     15 +
 .../tests/expectations/tests/anon_enum_trait.rs    |     56 +
 .../expectations/tests/anon_struct_in_union.rs     |    113 +
 .../expectations/tests/anon_struct_in_union_1_0.rs |    154 +
 .../tests/expectations/tests/anon_union.rs         |    101 +
 .../tests/expectations/tests/anon_union_1_0.rs     |    143 +
 .../expectations/tests/anonymous-template-types.rs |     48 +
 .../tests/expectations/tests/arg_keyword.rs        |     11 +
 .../tests/array-of-zero-sized-types.rs             |     59 +
 .../tests/attribute_warn_unused_result.rs          |     48 +
 ...te_warn_unused_result_no_attribute_detection.rs |     45 +
 .../tests/attribute_warn_unused_result_pre_1_27.rs |     45 +
 .../tests/bad-namespace-parenthood-inheritance.rs  |     26 +
 .../tests/expectations/tests/base-to-derived.rs    |     25 +
 .../tests/bindgen-union-inside-namespace.rs        |    114 +
 .../expectations/tests/bitfield-32bit-overflow.rs  |    715 +
 .../expectations/tests/bitfield-enum-basic.rs      |    169 +
 .../expectations/tests/bitfield-enum-repr-c.rs     |     48 +
 .../tests/bitfield-enum-repr-transparent.rs        |     48 +
 .../tests/expectations/tests/bitfield-large.rs     |    203 +
 .../tests/expectations/tests/bitfield-linux-32.rs  |    166 +
 .../tests/bitfield-method-same-name.rs             |    164 +
 .../tests/expectations/tests/bitfield_align.rs     |    797 +
 .../tests/expectations/tests/bitfield_align_2.rs   |    176 +
 .../expectations/tests/bitfield_large_overflow.rs  |     29 +
 .../expectations/tests/bitfield_method_mangling.rs |    158 +
 .../expectations/tests/bitfield_pragma_packed.rs   |    211 +
 .../tests/expectations/tests/block_return_type.rs  |     16 +
 .../expectations/tests/blocklist-and-impl-debug.rs |     54 +
 .../tests/expectations/tests/blocklist-file.rs     |     91 +
 .../tests/expectations/tests/blocklist-function.rs |     42 +
 .../tests/expectations/tests/blocklist-item.rs     |     24 +
 .../tests/expectations/tests/blocks-signature.rs   |     92 +
 bindgen-tests/tests/expectations/tests/blocks.rs   |     80 +
 .../tests/expectations/tests/bug-1529681.rs        |     25 +
 .../tests/expectations/tests/builtin-template.rs   |      8 +
 .../tests/expectations/tests/c-empty-layout.rs     |     23 +
 bindgen-tests/tests/expectations/tests/c_naming.rs |    102 +
 .../tests/expectations/tests/call-conv-typedef.rs  |     12 +
 .../tests/expectations/tests/canonical-types.rs    |    281 +
 .../tests/canonical_path_without_namespacing.rs    |     29 +
 bindgen-tests/tests/expectations/tests/char.rs     |    107 +
 bindgen-tests/tests/expectations/tests/class.rs    |    507 +
 .../tests/expectations/tests/class_1_0.rs          |    558 +
 .../tests/expectations/tests/class_nested.rs       |    195 +
 .../tests/expectations/tests/class_no_members.rs   |     76 +
 .../tests/expectations/tests/class_static.rs       |     38 +
 .../tests/expectations/tests/class_static_const.rs |     28 +
 .../tests/expectations/tests/class_use_as.rs       |     72 +
 .../tests/expectations/tests/class_with_dtor.rs    |     85 +
 .../expectations/tests/class_with_inner_struct.rs  |    490 +
 .../tests/class_with_inner_struct_1_0.rs           |    546 +
 .../tests/expectations/tests/class_with_typedef.rs |    146 +
 .../tests/expectations/tests/comment-indent.rs     |    139 +
 bindgen-tests/tests/expectations/tests/complex.rs  |    155 +
 .../tests/expectations/tests/complex_global.rs     |     22 +
 .../expectations/tests/const-const-mut-ptr.rs      |     42 +
 .../tests/expectations/tests/const_array.rs        |     13 +
 .../tests/expectations/tests/const_array_fn_arg.rs |     10 +
 .../tests/expectations/tests/const_enum_unnamed.rs |     39 +
 .../tests/const_multidim_array_fn_arg.rs           |     10 +
 .../tests/expectations/tests/const_ptr.rs          |     10 +
 .../tests/expectations/tests/const_resolved_ty.rs  |     10 +
 .../tests/expectations/tests/const_tparam.rs       |     23 +
 .../tests/constant-non-specialized-tp.rs           |     22 +
 .../tests/constified-enum-module-overflow.rs       |     57 +
 .../tests/expectations/tests/constify-all-enums.rs |     54 +
 .../tests/expectations/tests/constify-enum.rs      |     24 +
 .../tests/constify-module-enums-basic.rs           |     72 +
 .../tests/constify-module-enums-namespace.rs       |     73 +
 .../tests/constify-module-enums-shadow-name.rs     |     54 +
 .../tests/constify-module-enums-simple-alias.rs    |    121 +
 .../constify-module-enums-simple-nonamespace.rs    |     53 +
 .../tests/constify-module-enums-types.rs           |    299 +
 .../tests/expectations/tests/constructor-tp.rs     |     42 +
 .../tests/expectations/tests/constructors.rs       |     80 +
 .../tests/expectations/tests/constructors_1_33.rs  |     82 +
 .../tests/contains-vs-inherits-zero-sized.rs       |    103 +
 .../tests/convert-cpp-comment-to-rust.rs           |     28 +
 .../tests/expectations/tests/convert-floats.rs     |     97 +
 .../tests/expectations/tests/core_ffi_c.rs         |     20 +
 .../tests/expectations/tests/cpp-empty-layout.rs   |     25 +
 bindgen-tests/tests/expectations/tests/crtp.rs     |     86 +
 .../tests/expectations/tests/ctypes-prefix-path.rs |     61 +
 .../tests/expectations/tests/dash_language.rs      |     12 +
 .../expectations/tests/decl_extern_int_twice.rs    |     10 +
 .../tests/expectations/tests/decl_ptr_to_array.rs  |     10 +
 .../tests/default-enum-style-constified-module.rs  |     16 +
 .../tests/default-macro-constant-type-signed.rs    |     54 +
 .../tests/default-macro-constant-type-unsigned.rs  |     54 +
 .../tests/default-macro-constant-type.rs           |     54 +
 .../tests/default-template-parameter.rs            |     47 +
 .../tests/expectations/tests/deleted-function.rs   |     91 +
 .../tests/derive-bitfield-method-same-name.rs      |    215 +
 .../tests/expectations/tests/derive-clone.rs       |     48 +
 .../tests/expectations/tests/derive-clone_1_0.rs   |     54 +
 .../tests/expectations/tests/derive-custom.rs      |     26 +
 .../tests/derive-debug-bitfield-core.rs            |    194 +
 .../expectations/tests/derive-debug-bitfield.rs    |    201 +
 .../tests/derive-debug-function-pointer.rs         |     80 +
 .../expectations/tests/derive-debug-generic.rs     |     26 +
 .../expectations/tests/derive-debug-mangle-name.rs |    124 +
 .../derive-debug-opaque-template-instantiation.rs  |     51 +
 .../expectations/tests/derive-debug-opaque.rs      |     83 +
 .../tests/derive-default-and-blocklist.rs          |     50 +
 .../tests/expectations/tests/derive-fn-ptr.rs      |    109 +
 .../tests/derive-hash-and-blocklist.rs             |     49 +
 .../expectations/tests/derive-hash-blocklisting.rs |     95 +
 .../derive-hash-struct-with-anon-struct-float.rs   |     76 +
 .../tests/derive-hash-struct-with-float-array.rs   |     34 +
 .../derive-hash-struct-with-incomplete-array.rs    |    116 +
 .../tests/derive-hash-struct-with-pointer.rs       |    168 +
 .../tests/derive-hash-template-def-float.rs        |     24 +
 .../tests/derive-hash-template-inst-float.rs       |    135 +
 .../tests/derive-partialeq-and-blocklist.rs        |     50 +
 .../tests/derive-partialeq-anonfield.rs            |     63 +
 .../expectations/tests/derive-partialeq-base.rs    |     84 +
 .../tests/derive-partialeq-bitfield.rs             |    189 +
 .../expectations/tests/derive-partialeq-core.rs    |     56 +
 .../expectations/tests/derive-partialeq-pointer.rs |    131 +
 .../expectations/tests/derive-partialeq-union.rs   |     59 +
 .../tests/derive-partialeq-union_1_0.rs            |    113 +
 .../expectations/tests/disable-namespacing.rs      |      8 +
 .../tests/disable-nested-struct-naming.rs          |    269 +
 .../expectations/tests/disable-untagged-union.rs   |     83 +
 .../tests/divide-by-zero-in-struct-layout.rs       |    138 +
 .../tests/expectations/tests/do-not-derive-copy.rs |     41 +
 .../tests/expectations/tests/doggo-or-null.rs      |     85 +
 .../tests/dupe-enum-variant-in-namespace.rs        |     28 +
 .../tests/duplicated-namespaces-definitions.rs     |    108 +
 .../expectations/tests/duplicated-namespaces.rs    |     12 +
 .../tests/duplicated_constants_in_ns.rs            |     22 +
 .../tests/dynamic_loading_attributes.rs            |     56 +
 .../expectations/tests/dynamic_loading_required.rs |     61 +
 .../expectations/tests/dynamic_loading_simple.rs   |     70 +
 .../expectations/tests/dynamic_loading_template.rs |     49 +
 .../tests/dynamic_loading_with_allowlist.rs        |     68 +
 .../tests/dynamic_loading_with_blocklist.rs        |    113 +
 .../tests/dynamic_loading_with_class.rs            |    105 +
 .../tests/expectations/tests/elaborated.rs         |     12 +
 .../tests/expectations/tests/empty-enum.rs         |     34 +
 .../tests/expectations/tests/empty-union.rs        |     21 +
 .../tests/empty_template_param_name.rs             |     13 +
 .../expectations/tests/enum-default-bitfield.rs    |    190 +
 .../expectations/tests/enum-default-consts.rs      |     66 +
 .../expectations/tests/enum-default-module.rs      |     74 +
 .../tests/expectations/tests/enum-default-rust.d   |      1 +
 .../tests/expectations/tests/enum-default-rust.rs  |     80 +
 .../tests/expectations/tests/enum-doc-bitfield.rs  |     64 +
 .../tests/expectations/tests/enum-doc-mod.rs       |     26 +
 .../tests/expectations/tests/enum-doc-rusty.rs     |     27 +
 bindgen-tests/tests/expectations/tests/enum-doc.rs |     24 +
 .../tests/expectations/tests/enum-no-debug-rust.rs |     80 +
 .../expectations/tests/enum-translate-type.rs      |     15 +
 .../tests/expectations/tests/enum-undefault.rs     |     16 +
 .../expectations/tests/enum-variant-replaces.rs    |     17 +
 bindgen-tests/tests/expectations/tests/enum.rs     |     64 +
 .../tests/expectations/tests/enum_alias.rs         |     12 +
 .../expectations/tests/enum_and_vtable_mangling.rs |     59 +
 .../tests/expectations/tests/enum_dupe.rs          |     15 +
 .../tests/expectations/tests/enum_explicit_type.rs |     61 +
 .../tests/enum_explicit_type_constants.rs          |     31 +
 .../tests/expectations/tests/enum_in_template.rs   |     15 +
 .../tests/enum_in_template_with_typedef.rs         |     21 +
 .../tests/expectations/tests/enum_negative.rs      |     13 +
 .../tests/expectations/tests/enum_packed.rs        |     25 +
 .../expectations/tests/eval-value-dependent.rs     |     13 +
 .../tests/eval-variadic-template-parameter.rs      |     12 +
 .../tests/expectations/tests/explicit-padding.rs   |    124 +
 .../expectations/tests/extern-const-struct.rs      |     50 +
 bindgen-tests/tests/expectations/tests/extern.rs   |     10 +
 .../tests/fit-macro-constant-types-signed.rs       |     54 +
 .../expectations/tests/fit-macro-constant-types.rs |     54 +
 bindgen-tests/tests/expectations/tests/float128.rs |      6 +
 .../tests/forward-declaration-autoptr.rs           |     85 +
 .../tests/expectations/tests/forward-enum-decl.rs  |     13 +
 .../tests/forward-inherit-struct-with-fields.rs    |     38 +
 .../expectations/tests/forward-inherit-struct.rs   |     26 +
 .../tests/forward_declared_complex_types.rs        |     87 +
 .../tests/forward_declared_complex_types_1_0.rs    |    112 +
 .../expectations/tests/forward_declared_opaque.rs  |     17 +
 .../expectations/tests/forward_declared_struct.rs  |     59 +
 .../tests/expectations/tests/func_proto.rs         |     10 +
 bindgen-tests/tests/expectations/tests/func_ptr.rs |     15 +
 .../tests/expectations/tests/func_ptr_in_struct.rs |     43 +
 .../expectations/tests/func_ptr_return_type.rs     |     15 +
 .../expectations/tests/func_return_must_use.rs     |     78 +
 .../expectations/tests/func_with_array_arg.rs      |     10 +
 .../expectations/tests/func_with_func_ptr_arg.rs   |     26 +
 .../expectations/tests/function-typedef-stdcall.rs |     17 +
 .../expectations/tests/gen-constructors-neg.rs     |     25 +
 .../tests/expectations/tests/gen-constructors.rs   |     37 +
 .../expectations/tests/gen-destructors-neg.rs      |     33 +
 .../tests/expectations/tests/gen-destructors.rs    |     43 +
 .../tests/expectations/tests/generate-inline.rs    |     39 +
 bindgen-tests/tests/expectations/tests/i128.rs     |     54 +
 .../tests/expectations/tests/in_class_typedef.rs   |     20 +
 .../expectations/tests/incomplete-array-padding.rs |    179 +
 .../tests/expectations/tests/infinite-macro.rs     |      9 +
 ...erit-from-template-instantiation-with-vtable.rs |    238 +
 .../tests/expectations/tests/inherit-namespaced.rs |     26 +
 .../tests/expectations/tests/inherit_named.rs      |     27 +
 .../tests/expectations/tests/inherit_typedef.rs    |     44 +
 .../tests/expectations/tests/inline-function.rs    |      6 +
 .../tests/expectations/tests/inline_namespace.rs   |     48 +
 .../tests/inline_namespace_allowlist.rs            |     17 +
 .../tests/inline_namespace_conservative.rs         |     53 +
 .../tests/inline_namespace_no_ns_enabled.rs        |     53 +
 .../expectations/tests/inner-typedef-gh422.rs      |     37 +
 .../tests/expectations/tests/inner_const.rs        |     41 +
 .../expectations/tests/inner_template_self.rs      |     78 +
 bindgen-tests/tests/expectations/tests/int128_t.rs |      6 +
 .../tests/issue-1025-unknown-enum-repr.rs          |     13 +
 .../tests/expectations/tests/issue-1034.rs         |    120 +
 .../tests/expectations/tests/issue-1040.rs         |      8 +
 .../tests/issue-1076-unnamed-bitfield-alignment.rs |    120 +
 .../tests/issue-1113-template-references.rs        |     47 +
 .../tests/issue-1118-using-forward-decl.rs         |    139 +
 .../tests/issue-1197-pure-virtual-stuff.rs         |     36 +
 .../tests/issue-1198-alias-rust-bitfield-enum.rs   |     83 +
 ...ssue-1198-alias-rust-const-mod-bitfield-enum.rs |     19 +
 .../tests/issue-1198-alias-rust-const-mod-enum.rs  |     19 +
 .../tests/issue-1198-alias-rust-enum.rs            |     25 +
 .../tests/issue-1216-variadic-member.rs            |     43 +
 .../expectations/tests/issue-1238-fwd-no-copy.rs   |     13 +
 .../tests/expectations/tests/issue-1281.rs         |     86 +
 .../tests/expectations/tests/issue-1285.rs         |     93 +
 .../tests/expectations/tests/issue-1291.rs         |    183 +
 .../tests/issue-1350-attribute-overloadable.rs     |     15 +
 .../tests/issue-1382-rust-primitive-types.rs       |    139 +
 .../tests/expectations/tests/issue-1435.rs         |     24 +
 .../tests/expectations/tests/issue-1443.rs         |    176 +
 .../tests/expectations/tests/issue-1454.rs         |     42 +
 .../tests/expectations/tests/issue-1464.rs         |      6 +
 .../expectations/tests/issue-1488-enum-new-type.rs |     49 +
 .../tests/expectations/tests/issue-1488-options.rs |     27 +
 .../tests/issue-1488-template-alias-new-type.rs    |     10 +
 .../tests/expectations/tests/issue-1498.rs         |    170 +
 .../tests/expectations/tests/issue-1514.rs         |     42 +
 .../tests/expectations/tests/issue-1554.rs         |     16 +
 .../tests/issue-1599-opaque-typedef-to-enum.rs     |     11 +
 .../tests/issue-1676-macro-namespace-prefix.rs     |      6 +
 .../tests/expectations/tests/issue-1947.rs         |    349 +
 .../expectations/tests/issue-1977-larger-arrays.rs |     64 +
 .../tests/expectations/tests/issue-1995.rs         |     40 +
 .../tests/expectations/tests/issue-2019.rs         |     79 +
 .../issue-2239-template-dependent-bit-width.rs     |     19 +
 .../tests/expectations/tests/issue-358.rs          |     35 +
 .../tests/expectations/tests/issue-372.rs          |    144 +
 .../tests/expectations/tests/issue-410.rs          |     49 +
 .../tests/expectations/tests/issue-446.rs          |     35 +
 .../tests/expectations/tests/issue-447.rs          |     76 +
 .../tests/expectations/tests/issue-493.rs          |    176 +
 .../tests/expectations/tests/issue-493_1_0.rs      |    144 +
 .../tests/expectations/tests/issue-511.rs          |     19 +
 .../expectations/tests/issue-537-repr-packed-n.rs  |    161 +
 .../tests/expectations/tests/issue-537.rs          |    163 +
 .../tests/issue-544-stylo-creduce-2.rs             |     22 +
 .../expectations/tests/issue-544-stylo-creduce.rs  |     12 +
 ...template-params-causing-layout-test-failures.rs |     73 +
 .../tests/issue-573-layout-test-failures.rs        |     56 +
 .../issue-574-assertion-failure-in-codegen.rs      |     59 +
 .../issue-584-stylo-template-analysis-panic.rs     |    124 +
 .../issue-638-stylo-cannot-find-T-in-this-scope.rs |     38 +
 .../tests/issue-639-typedef-anon-field.rs          |    113 +
 .../expectations/tests/issue-643-inner-struct.rs   |    138 +
 .../issue-645-cannot-find-type-T-in-this-scope.rs  |     25 +
 .../tests/issue-648-derive-debug-with-padding.rs   |    116 +
 .../tests/issue-654-struct-fn-collision.rs         |     15 +
 .../tests/issue-662-cannot-find-T-in-this-scope.rs |     52 +
 .../tests/expectations/tests/issue-662-part-2.rs   |     39 +
 .../tests/expectations/tests/issue-674-1.rs        |     53 +
 .../tests/expectations/tests/issue-674-2.rs        |     98 +
 .../tests/expectations/tests/issue-674-3.rs        |     75 +
 .../tests/issue-677-nested-ns-specifier.rs         |     21 +
 .../tests/issue-691-template-parameter-virtual.rs  |     81 +
 .../expectations/tests/issue-710-must-use-type.rs  |     25 +
 .../tests/issue-739-pointer-wide-bitfield.rs       |    195 +
 .../tests/issue-801-opaque-sloppiness.rs           |     61 +
 ...sue-807-opaque-types-methods-being-generated.rs |    137 +
 .../tests/expectations/tests/issue-816.rs          |    860 +
 .../issue-820-unused-template-param-in-alias.rs    |      8 +
 ...sue-826-generating-methods-when-asked-not-to.rs |     25 +
 .../tests/expectations/tests/issue-833-1.rs        |     15 +
 .../tests/expectations/tests/issue-833-2.rs        |     14 +
 .../tests/expectations/tests/issue-833.rs          |     15 +
 .../tests/expectations/tests/issue-834.rs          |     25 +
 .../tests/issue-848-replacement-system-include.rs  |     31 +
 .../tests/issue-888-enum-var-decl-jump.rs          |     43 +
 .../issue-944-derive-copy-and-blocklisting.rs      |     49 +
 .../tests/expectations/tests/issue-946.rs          |     24 +
 .../tests/expectations/tests/issue_311.rs          |     48 +
 .../tests/expectations/tests/issue_315.rs          |      9 +
 .../expectations/tests/jsval_layout_opaque.rs      |    514 +
 .../expectations/tests/jsval_layout_opaque_1_0.rs  |    548 +
 bindgen-tests/tests/expectations/tests/keywords.rs |    227 +
 bindgen-tests/tests/expectations/tests/layout.rs   |     28 +
 .../tests/expectations/tests/layout_align.rs       |    263 +
 .../tests/expectations/tests/layout_arp.rs         |    216 +
 .../tests/expectations/tests/layout_array.rs       |    408 +
 .../expectations/tests/layout_array_too_long.rs    |    341 +
 .../expectations/tests/layout_cmdline_token.rs     |    285 +
 .../tests/expectations/tests/layout_eth_conf.rs    |   2192 +
 .../expectations/tests/layout_eth_conf_1_0.rs      |   2337 +
 .../tests/expectations/tests/layout_kni_mbuf.rs    |    209 +
 .../expectations/tests/layout_large_align_field.rs |    703 +
 .../tests/expectations/tests/layout_mbuf.rs        |   1204 +
 .../tests/expectations/tests/layout_mbuf_1_0.rs    |   1255 +
 .../tests/libclang-5/abi_variadic_function.rs      |     11 +
 .../tests/expectations/tests/libclang-5/auto.rs    |     35 +
 .../tests/libclang-5/call-conv-field.rs            |     59 +
 .../expectations/tests/libclang-5/const_bool.rs    |     29 +
 .../tests/libclang-5/constant-evaluate.rs          |     25 +
 ...ror-E0600-cannot-apply-unary-negation-to-u32.rs |      9 +
 .../libclang-5/issue-769-bad-instantiation-test.rs |     67 +
 .../tests/libclang-5/mangling-win32.rs             |     52 +
 .../tests/libclang-5/objc_inheritance.rs           |    116 +
 .../expectations/tests/libclang-5/objc_template.rs |     64 +
 .../partial-specialization-and-inheritance.rs      |     39 +
 .../libclang-5/type_alias_template_specialized.rs  |     68 +
 .../tests/libclang-9/abi_variadic_function.rs      |     11 +
 .../tests/expectations/tests/libclang-9/auto.rs    |     35 +
 .../tests/libclang-9/call-conv-field.rs            |     59 +
 .../tests/expectations/tests/libclang-9/class.rs   |    691 +
 .../expectations/tests/libclang-9/class_1_0.rs     |    742 +
 .../expectations/tests/libclang-9/const_bool.rs    |     29 +
 .../tests/libclang-9/constant-evaluate.rs          |     25 +
 .../derive-hash-struct-with-incomplete-array.rs    |    171 +
 ...ror-E0600-cannot-apply-unary-negation-to-u32.rs |      9 +
 .../tests/libclang-9/incomplete-array-padding.rs   |    187 +
 .../tests/libclang-9/issue-643-inner-struct.rs     |    181 +
 .../libclang-9/issue-769-bad-instantiation-test.rs |     67 +
 .../expectations/tests/libclang-9/layout_align.rs  |    318 +
 .../tests/libclang-9/mangling-win32.rs             |     52 +
 .../tests/libclang-9/objc_inheritance.rs           |    116 +
 .../expectations/tests/libclang-9/objc_template.rs |     64 +
 .../partial-specialization-and-inheritance.rs      |     39 +
 .../libclang-9/type_alias_template_specialized.rs  |     68 +
 .../tests/libclang-9/zero-sized-array.rs           |    185 +
 .../libclang_version_specific_generated_tests.rs   |      4 +
 .../tests/expectations/tests/long_double.rs        |     34 +
 .../tests/expectations/tests/macro-expr-basic.rs   |     16 +
 .../tests/macro-expr-uncommon-token.rs             |     11 +
 .../tests/expectations/tests/macro-redef.rs        |     10 +
 .../tests/expectations/tests/macro_const.rs        |     14 +
 .../tests/expectations/tests/macro_const_1_0.rs    |     14 +
 .../expectations/tests/maddness-is-avoidable.rs    |     17 +
 .../tests/expectations/tests/mangling-ios.rs       |     10 +
 .../tests/expectations/tests/mangling-linux32.rs   |     32 +
 .../tests/expectations/tests/mangling-linux64.rs   |     32 +
 .../tests/expectations/tests/mangling-macos.rs     |     32 +
 .../tests/expectations/tests/mangling-win64.rs     |     32 +
 .../expectations/tests/merge-extern-blocks.rs      |     37 +
 .../tests/expectations/tests/method-mangling.rs    |     35 +
 .../tests/expectations/tests/module-allowlisted.rs |     30 +
 .../tests/expectations/tests/msvc-no-usr.rs        |     33 +
 .../tests/multiple-inherit-empty-correct-layout.rs |     61 +
 bindgen-tests/tests/expectations/tests/mutable.rs  |    124 +
 .../tests/expectations/tests/namespace.rs          |    130 +
 .../expectations/tests/nested-template-typedef.rs  |     17 +
 bindgen-tests/tests/expectations/tests/nested.rs   |    111 +
 .../tests/expectations/tests/nested_vtable.rs      |     99 +
 .../expectations/tests/nested_within_namespace.rs  |    115 +
 .../tests/expectations/tests/newtype-enum.rs       |     22 +
 .../expectations/tests/newtype-global-enum.rs      |     14 +
 .../tests/expectations/tests/no-comments.rs        |     33 +
 .../tests/expectations/tests/no-derive-debug.rs    |     56 +
 .../tests/expectations/tests/no-derive-default.rs  |     47 +
 .../expectations/tests/no-hash-allowlisted.rs      |     33 +
 .../tests/expectations/tests/no-hash-opaque.rs     |     26 +
 .../expectations/tests/no-partialeq-allowlisted.rs |     38 +
 .../expectations/tests/no-partialeq-opaque.rs      |     26 +
 .../tests/no-recursive-allowlisting.rs             |     44 +
 bindgen-tests/tests/expectations/tests/no-std.rs   |     59 +
 bindgen-tests/tests/expectations/tests/no_copy.rs  |     13 +
 .../expectations/tests/no_copy_allowlisted.rs      |     33 +
 .../tests/expectations/tests/no_copy_opaque.rs     |     26 +
 bindgen-tests/tests/expectations/tests/no_debug.rs |     13 +
 .../expectations/tests/no_debug_allowlisted.rs     |     38 +
 .../tests/no_debug_bypass_impl_debug.rs            |     40 +
 .../tests/expectations/tests/no_debug_opaque.rs    |     26 +
 .../tests/expectations/tests/no_default.rs         |     27 +
 .../expectations/tests/no_default_allowlisted.rs   |     38 +
 .../tests/no_default_bypass_derive_default.rs      |     26 +
 .../tests/expectations/tests/no_default_opaque.rs  |     26 +
 .../tests/expectations/tests/no_size_t_is_usize.rs |     56 +
 .../tests/expectations/tests/non-type-params.rs    |     68 +
 bindgen-tests/tests/expectations/tests/noreturn.rs |     19 +
 .../tests/expectations/tests/nsBaseHashtable.rs    |     63 +
 .../tests/expectations/tests/nsStyleAutoArray.rs   |     43 +
 .../tests/expectations/tests/objc_allowlist.rs     |     58 +
 .../tests/expectations/tests/objc_blocklist.rs     |     42 +
 .../tests/expectations/tests/objc_category.rs      |     44 +
 .../tests/expectations/tests/objc_class.rs         |     38 +
 .../tests/expectations/tests/objc_class_method.rs  |     68 +
 .../tests/expectations/tests/objc_interface.rs     |     29 +
 .../expectations/tests/objc_interface_type.rs      |     74 +
 .../tests/expectations/tests/objc_method.rs        |     82 +
 .../tests/expectations/tests/objc_method_clash.rs  |     41 +
 .../tests/objc_pointer_return_types.rs             |     58 +
 .../expectations/tests/objc_property_fnptr.rs      |     57 +
 .../tests/expectations/tests/objc_protocol.rs      |     30 +
 .../tests/objc_protocol_inheritance.rs             |     66 +
 .../tests/expectations/tests/objc_sel_and_id.rs    |     20 +
 .../tests/expectations/tests/only_bitfields.rs     |    157 +
 .../tests/opaque-template-inst-member-2.rs         |     99 +
 .../tests/opaque-template-inst-member.rs           |    116 +
 .../opaque-template-instantiation-namespaced.rs    |    198 +
 .../tests/opaque-template-instantiation.rs         |    114 +
 .../tests/expectations/tests/opaque-tracing.rs     |     30 +
 .../tests/expectations/tests/opaque_in_struct.rs   |     60 +
 .../tests/expectations/tests/opaque_pointer.rs     |     97 +
 .../tests/expectations/tests/opaque_typedef.rs     |     15 +
 bindgen-tests/tests/expectations/tests/operator.rs |     16 +
 bindgen-tests/tests/expectations/tests/ord-enum.rs |     23 +
 .../tests/expectations/tests/overflowed_enum.rs    |     20 +
 .../tests/expectations/tests/overloading.rs        |     26 +
 .../tests/expectations/tests/packed-bitfield.rs    |    175 +
 .../expectations/tests/packed-n-with-padding.rs    |     51 +
 .../tests/expectations/tests/packed-vtable.rs      |     40 +
 .../tests/expectations/tests/parm-union.rs         |     40 +
 .../tests/parsecb-anonymous-enum-variant-rename.rs |      9 +
 .../tests/expectations/tests/pointer-attr.rs       |     10 +
 .../tests/prepend-enum-constified-variant.rs       |     15 +
 .../tests/expectations/tests/prepend_enum_name.rs  |     10 +
 bindgen-tests/tests/expectations/tests/private.rs  |    149 +
 .../tests/expectations/tests/private_fields.rs     |    535 +
 .../tests/expectations/tests/public-dtor.rs        |     35 +
 .../tests/qualified-dependent-types.rs             |     17 +
 .../tests/expectations/tests/redeclaration.rs      |     10 +
 .../tests/expectations/tests/ref_argument_array.rs |     49 +
 .../expectations/tests/reparented_replacement.rs   |     51 +
 .../expectations/tests/replace_template_alias.rs   |     26 +
 .../tests/expectations/tests/replace_use.rs        |     55 +
 .../tests/expectations/tests/replaces_double.rs    |     40 +
 .../tests/expectations/tests/repr-align.rs         |     74 +
 .../tests/resolved_type_def_function.rs            |     11 +
 .../same_struct_name_in_different_namespaces.rs    |     54 +
 .../tests/sentry-defined-multiple-times.rs         |    385 +
 .../tests/expectations/tests/short-enums.rs        |     22 +
 .../tests/expectations/tests/size_t_template.rs    |     33 +
 .../tests/expectations/tests/sorted-items.rs       |     82 +
 .../tests/expectations/tests/stdint_typedef.rs     |     41 +
 .../struct_containing_forward_declared_struct.rs   |     68 +
 .../tests/expectations/tests/struct_typedef.rs     |     95 +
 .../tests/expectations/tests/struct_typedef_ns.rs  |    100 +
 .../expectations/tests/struct_with_anon_struct.rs  |     75 +
 .../tests/struct_with_anon_struct_array.rs         |    123 +
 .../tests/struct_with_anon_struct_pointer.rs       |     84 +
 .../expectations/tests/struct_with_anon_union.rs   |     93 +
 .../tests/struct_with_anon_union_1_0.rs            |    129 +
 .../tests/struct_with_anon_unnamed_struct.rs       |     67 +
 .../tests/struct_with_anon_unnamed_union.rs        |     85 +
 .../tests/struct_with_anon_unnamed_union_1_0.rs    |    121 +
 .../expectations/tests/struct_with_bitfields.rs    |    252 +
 .../expectations/tests/struct_with_derive_debug.rs |    149 +
 .../expectations/tests/struct_with_large_array.rs  |     63 +
 .../expectations/tests/struct_with_nesting.rs      |    191 +
 .../expectations/tests/struct_with_nesting_1_0.rs  |    237 +
 .../expectations/tests/struct_with_packing.rs      |     39 +
 .../tests/expectations/tests/struct_with_struct.rs |     75 +
 .../tests/struct_with_typedef_template_arg.rs      |     14 +
 .../tests/expectations/tests/template-fun-ty.rs    |     27 +
 .../expectations/tests/template-param-usage-0.rs   |     22 +
 .../expectations/tests/template-param-usage-1.rs   |     12 +
 .../expectations/tests/template-param-usage-10.rs  |     42 +
 .../expectations/tests/template-param-usage-11.rs  |     12 +
 .../expectations/tests/template-param-usage-12.rs  |     38 +
 .../expectations/tests/template-param-usage-13.rs  |     28 +
 .../expectations/tests/template-param-usage-14.rs  |     27 +
 .../expectations/tests/template-param-usage-15.rs  |     37 +
 .../expectations/tests/template-param-usage-2.rs   |     37 +
 .../expectations/tests/template-param-usage-3.rs   |     41 +
 .../expectations/tests/template-param-usage-4.rs   |     27 +
 .../expectations/tests/template-param-usage-5.rs   |     23 +
 .../expectations/tests/template-param-usage-6.rs   |     13 +
 .../expectations/tests/template-param-usage-7.rs   |     25 +
 .../expectations/tests/template-param-usage-8.rs   |     26 +
 .../expectations/tests/template-param-usage-9.rs   |     31 +
 .../tests/expectations/tests/template-with-var.rs  |     12 +
 bindgen-tests/tests/expectations/tests/template.rs |    995 +
 .../tests/expectations/tests/template_alias.rs     |     23 +
 .../expectations/tests/template_alias_basic.rs     |      8 +
 .../expectations/tests/template_alias_namespace.rs |     37 +
 .../tests/expectations/tests/template_fun.rs       |      6 +
 .../template_instantiation_with_fn_local_type.rs   |     96 +
 .../tests/template_partial_specification.rs        |      6 +
 .../tests/template_typedef_transitive_param.rs     |     28 +
 .../tests/expectations/tests/template_typedefs.rs  |     22 +
 .../tests/expectations/tests/templateref_opaque.rs |     19 +
 .../expectations/tests/templatized-bitfield.rs     |     15 +
 .../tests/test_mixed_header_and_header_contents.rs |    114 +
 .../tests/test_multiple_header_calls_in_builder.rs |    108 +
 bindgen-tests/tests/expectations/tests/timex.rs    |    322 +
 .../tests/expectations/tests/transform-op.rs       |    260 +
 .../type-referenced-by-allowlisted-function.rs     |     41 +
 .../tests/expectations/tests/type_alias_empty.rs   |      8 +
 .../type_alias_partial_template_especialization.rs |     23 +
 .../tests/typedefd-array-as-function-arg.rs        |     11 +
 bindgen-tests/tests/expectations/tests/typeref.rs  |    179 +
 .../tests/expectations/tests/typeref_1_0.rs        |    219 +
 .../tests/expectations/tests/underscore.rs         |     34 +
 .../tests/expectations/tests/union-align.rs        |     79 +
 .../tests/expectations/tests/union-in-ns.rs        |     52 +
 .../tests/expectations/tests/union-in-ns_1_0.rs    |     95 +
 .../tests/expectations/tests/union_bitfield.rs     |    223 +
 .../tests/expectations/tests/union_bitfield_1_0.rs |    298 +
 .../tests/expectations/tests/union_dtor.rs         |     67 +
 .../tests/expectations/tests/union_dtor_1_0.rs     |    103 +
 .../tests/expectations/tests/union_fields.rs       |     71 +
 .../tests/expectations/tests/union_fields_1_0.rs   |    111 +
 .../tests/expectations/tests/union_template.rs     |     64 +
 .../tests/expectations/tests/union_template_1_0.rs |     78 +
 .../expectations/tests/union_with_anon_struct.rs   |     84 +
 .../tests/union_with_anon_struct_1_0.rs            |    129 +
 .../tests/union_with_anon_struct_bitfield.rs       |    194 +
 .../tests/union_with_anon_struct_bitfield_1_0.rs   |    239 +
 .../expectations/tests/union_with_anon_union.rs    |     93 +
 .../tests/union_with_anon_union_1_0.rs             |    130 +
 .../tests/union_with_anon_unnamed_struct.rs        |    112 +
 .../tests/union_with_anon_unnamed_struct_1_0.rs    |    157 +
 .../tests/union_with_anon_unnamed_union.rs         |     94 +
 .../tests/union_with_anon_unnamed_union_1_0.rs     |    131 +
 .../expectations/tests/union_with_big_member.rs    |    160 +
 .../tests/union_with_big_member_1_0.rs             |    212 +
 .../tests/expectations/tests/union_with_nesting.rs |    173 +
 .../expectations/tests/union_with_nesting_1_0.rs   |    203 +
 .../tests/union_with_non_copy_member.rs            |    239 +
 .../tests/expectations/tests/unknown_attr.rs       |     57 +
 .../tests/expectations/tests/unsorted-items.rs     |     82 +
 bindgen-tests/tests/expectations/tests/use-core.rs |    112 +
 .../tests/expectations/tests/use-core_1_0.rs       |    157 +
 bindgen-tests/tests/expectations/tests/using.rs    |     25 +
 .../tests/expectations/tests/var-tracing.rs        |     72 +
 .../tests/expectations/tests/variadic-method.rs    |     33 +
 .../tests/variadic_template_function.rs            |     12 +
 bindgen-tests/tests/expectations/tests/vector.rs   |     45 +
 .../tests/expectations/tests/virtual_dtor.rs       |     40 +
 .../expectations/tests/virtual_inheritance.rs      |    138 +
 .../tests/expectations/tests/virtual_interface.rs  |    128 +
 .../tests/expectations/tests/virtual_overloaded.rs |     55 +
 .../expectations/tests/vtable_recursive_sig.rs     |     69 +
 .../expectations/tests/wasm-constructor-returns.rs |     40 +
 .../tests/expectations/tests/wasm-import-module.rs |     11 +
 .../tests/expectations/tests/weird_bitfields.rs    |    440 +
 .../tests/expectations/tests/what_is_going_on.rs   |     43 +
 .../tests/expectations/tests/win32-thiscall_1_0.rs |     30 +
 .../expectations/tests/win32-thiscall_nightly.rs   |     51 +
 .../expectations/tests/win32-vectorcall-1_0.rs     |      6 +
 .../expectations/tests/win32-vectorcall-nightly.rs |     16 +
 .../tests/with_array_pointers_arguments.rs         |     24 +
 .../tests/without_array_pointers_arguments.rs      |     25 +
 .../expectations/tests/zero-size-array-align.rs    |     90 +
 .../tests/expectations/tests/zero-sized-array.rs   |    159 +
 bindgen-tests/tests/headers/16-byte-alignment.h    |     34 +
 .../tests/headers/16-byte-alignment_1_0.h          |     34 +
 bindgen-tests/tests/headers/381-decltype-alias.hpp |      7 +
 .../tests/headers/abi_variadic_function.hpp        |      4 +
 bindgen-tests/tests/headers/accessors.hpp          |     46 +
 bindgen-tests/tests/headers/allowlist-file.hpp     |     21 +
 .../tests/headers/allowlist-namespaces-basic.hpp   |     10 +
 .../tests/headers/allowlist-namespaces.hpp         |     10 +
 bindgen-tests/tests/headers/allowlist_basic.hpp    |     16 +
 bindgen-tests/tests/headers/allowlist_fix.hpp      |      4 +
 bindgen-tests/tests/headers/allowlist_vars.h       |      4 +
 bindgen-tests/tests/headers/allowlist_warnings.h   |      2 +
 .../allowlisted-item-references-no-hash.hpp        |      7 +
 .../allowlisted-item-references-no-partialeq.hpp   |      7 +
 bindgen-tests/tests/headers/allowlisted/file.hpp   |     22 +
 .../allowlisted_item_references_no_copy.hpp        |      7 +
 bindgen-tests/tests/headers/annotation_hide.hpp    |     16 +
 bindgen-tests/tests/headers/anon-fields-prefix.h   |     15 +
 bindgen-tests/tests/headers/anon_enum.hpp          |     11 +
 bindgen-tests/tests/headers/anon_enum_allowlist.h  |      6 +
 bindgen-tests/tests/headers/anon_enum_trait.hpp    |     23 +
 bindgen-tests/tests/headers/anon_struct_in_union.h |      8 +
 .../tests/headers/anon_struct_in_union_1_0.h       |      9 +
 bindgen-tests/tests/headers/anon_union.hpp         |     21 +
 bindgen-tests/tests/headers/anon_union_1_0.hpp     |     22 +
 .../tests/headers/anonymous-template-types.hpp     |     24 +
 bindgen-tests/tests/headers/arg_keyword.hpp        |      3 +
 .../tests/headers/array-of-zero-sized-types.hpp    |     12 +
 .../tests/headers/attribute_warn_unused_result.hpp |     10 +
 ...e_warn_unused_result_no_attribute_detection.hpp |     10 +
 .../attribute_warn_unused_result_pre_1_27.hpp      |      8 +
 bindgen-tests/tests/headers/auto.hpp               |     19 +
 .../bad-namespace-parenthood-inheritance.hpp       |     15 +
 bindgen-tests/tests/headers/base-to-derived.hpp    |     19 +
 .../headers/bindgen-union-inside-namespace.hpp     |      8 +
 .../tests/headers/bitfield-32bit-overflow.h        |     36 +
 .../tests/headers/bitfield-enum-basic.hpp          |     27 +
 .../tests/headers/bitfield-enum-repr-c.hpp         |      8 +
 .../headers/bitfield-enum-repr-transparent.hpp     |      8 +
 bindgen-tests/tests/headers/bitfield-large.hpp     |      9 +
 bindgen-tests/tests/headers/bitfield-linux-32.hpp  |      9 +
 .../tests/headers/bitfield-method-same-name.hpp    |      6 +
 bindgen-tests/tests/headers/bitfield_align.h       |     49 +
 bindgen-tests/tests/headers/bitfield_align_2.h     |     12 +
 .../tests/headers/bitfield_large_overflow.hpp      |      3 +
 .../tests/headers/bitfield_method_mangling.h       |      5 +
 .../tests/headers/bitfield_pragma_packed.h         |      9 +
 bindgen-tests/tests/headers/block_return_type.h    |      4 +
 .../tests/headers/blocklist-and-impl-debug.hpp     |     10 +
 bindgen-tests/tests/headers/blocklist-file.hpp     |     18 +
 bindgen-tests/tests/headers/blocklist-function.hpp |     16 +
 bindgen-tests/tests/headers/blocklist-item.hpp     |     21 +
 .../tests/headers/blocklisted/fake-stdint.h        |      7 +
 bindgen-tests/tests/headers/blocklisted/file.hpp   |     26 +
 bindgen-tests/tests/headers/blocks-signature.hpp   |      4 +
 bindgen-tests/tests/headers/blocks.hpp             |     25 +
 bindgen-tests/tests/headers/bug-1529681.hpp        |      8 +
 bindgen-tests/tests/headers/builtin-template.hpp   |      6 +
 bindgen-tests/tests/headers/c-empty-layout.h       |      1 +
 bindgen-tests/tests/headers/c_naming.h             |     19 +
 bindgen-tests/tests/headers/call-conv-field.h      |     13 +
 bindgen-tests/tests/headers/call-conv-typedef.h    |      5 +
 bindgen-tests/tests/headers/canonical-types.hpp    |     51 +
 .../headers/canonical_path_without_namespacing.hpp |      7 +
 bindgen-tests/tests/headers/char.h                 |     21 +
 bindgen-tests/tests/headers/class.hpp              |     74 +
 bindgen-tests/tests/headers/class_1_0.hpp          |     76 +
 bindgen-tests/tests/headers/class_nested.hpp       |     37 +
 bindgen-tests/tests/headers/class_no_members.hpp   |     17 +
 bindgen-tests/tests/headers/class_static.hpp       |      8 +
 bindgen-tests/tests/headers/class_static_const.hpp |      9 +
 bindgen-tests/tests/headers/class_use_as.hpp       |     16 +
 bindgen-tests/tests/headers/class_with_dtor.hpp    |     14 +
 .../tests/headers/class_with_inner_struct.hpp      |     44 +
 .../tests/headers/class_with_inner_struct_1_0.hpp  |     44 +
 bindgen-tests/tests/headers/class_with_typedef.hpp |     23 +
 bindgen-tests/tests/headers/comment-indent.hpp     |     47 +
 bindgen-tests/tests/headers/complex.h              |     17 +
 bindgen-tests/tests/headers/complex_global.h       |      4 +
 bindgen-tests/tests/headers/const-const-mut-ptr.h  |      3 +
 bindgen-tests/tests/headers/const_array.h          |      2 +
 bindgen-tests/tests/headers/const_array_fn_arg.h   |      1 +
 bindgen-tests/tests/headers/const_bool.hpp         |      9 +
 bindgen-tests/tests/headers/const_enum_unnamed.hpp |     10 +
 .../tests/headers/const_multidim_array_fn_arg.h    |      1 +
 bindgen-tests/tests/headers/const_ptr.hpp          |      3 +
 bindgen-tests/tests/headers/const_resolved_ty.h    |      3 +
 bindgen-tests/tests/headers/const_tparam.hpp       |      5 +
 bindgen-tests/tests/headers/constant-evaluate.h    |     21 +
 .../tests/headers/constant-non-specialized-tp.hpp  |     15 +
 .../headers/constified-enum-module-overflow.hpp    |      8 +
 bindgen-tests/tests/headers/constify-all-enums.h   |     10 +
 bindgen-tests/tests/headers/constify-enum.h        |     14 +
 .../tests/headers/constify-module-enums-basic.h    |     17 +
 .../headers/constify-module-enums-namespace.hpp    |     17 +
 .../headers/constify-module-enums-shadow-name.h    |     12 +
 .../headers/constify-module-enums-simple-alias.hpp |     21 +
 .../constify-module-enums-simple-nonamespace.hpp   |     12 +
 .../tests/headers/constify-module-enums-types.hpp  |     78 +
 bindgen-tests/tests/headers/constructor-tp.hpp     |     26 +
 bindgen-tests/tests/headers/constructors.hpp       |     13 +
 bindgen-tests/tests/headers/constructors_1_33.hpp  |     16 +
 .../headers/contains-vs-inherits-zero-sized.hpp    |     21 +
 .../tests/headers/convert-cpp-comment-to-rust.hpp  |     14 +
 bindgen-tests/tests/headers/convert-floats.h       |      9 +
 bindgen-tests/tests/headers/core_ffi_c.h           |     14 +
 bindgen-tests/tests/headers/cpp-empty-layout.hpp   |      1 +
 bindgen-tests/tests/headers/crtp.hpp               |     12 +
 bindgen-tests/tests/headers/ctypes-prefix-path.h   |      5 +
 bindgen-tests/tests/headers/dash_language.h        |      6 +
 .../tests/headers/decl_extern_int_twice.h          |      2 +
 bindgen-tests/tests/headers/decl_ptr_to_array.h    |      1 +
 .../headers/default-enum-style-constified-module.h |      4 +
 .../headers/default-macro-constant-type-signed.h   |      3 +
 .../headers/default-macro-constant-type-unsigned.h |      3 +
 .../tests/headers/default-macro-constant-type.h    |     52 +
 .../tests/headers/default-template-parameter.hpp   |      7 +
 bindgen-tests/tests/headers/deleted-function.hpp   |     35 +
 .../headers/derive-bitfield-method-same-name.hpp   |     13 +
 bindgen-tests/tests/headers/derive-clone.h         |      7 +
 bindgen-tests/tests/headers/derive-clone_1_0.h     |      7 +
 bindgen-tests/tests/headers/derive-custom.h        |     28 +
 .../tests/headers/derive-debug-bitfield-core.hpp   |      7 +
 .../tests/headers/derive-debug-bitfield.hpp        |      7 +
 .../headers/derive-debug-function-pointer.hpp      |      7 +
 .../tests/headers/derive-debug-generic.hpp         |      6 +
 .../tests/headers/derive-debug-mangle-name.h       |     14 +
 .../derive-debug-opaque-template-instantiation.hpp |     12 +
 .../tests/headers/derive-debug-opaque.hpp          |     10 +
 .../tests/headers/derive-default-and-blocklist.hpp |     14 +
 bindgen-tests/tests/headers/derive-fn-ptr.h        |     18 +
 .../tests/headers/derive-hash-and-blocklist.hpp    |     10 +
 .../tests/headers/derive-hash-blocklisting.hpp     |     17 +
 .../derive-hash-struct-with-anon-struct-float.h    |      9 +
 .../headers/derive-hash-struct-with-float-array.h  |      6 +
 .../derive-hash-struct-with-incomplete-array.h     |     17 +
 .../headers/derive-hash-struct-with-pointer.h      |     18 +
 .../headers/derive-hash-template-def-float.hpp     |      8 +
 .../headers/derive-hash-template-inst-float.hpp    |     17 +
 .../headers/derive-partialeq-and-blocklist.hpp     |     11 +
 .../tests/headers/derive-partialeq-anonfield.h     |      5 +
 .../tests/headers/derive-partialeq-base.hpp        |      8 +
 .../tests/headers/derive-partialeq-bitfield.hpp    |      7 +
 .../tests/headers/derive-partialeq-core.h          |      5 +
 .../tests/headers/derive-partialeq-pointer.hpp     |     12 +
 .../tests/headers/derive-partialeq-union.hpp       |      7 +
 .../tests/headers/derive-partialeq-union_1_0.hpp   |      7 +
 .../tests/headers/disable-namespacing.hpp          |      9 +
 .../tests/headers/disable-nested-struct-naming.h   |     24 +
 .../tests/headers/disable-untagged-union.hpp       |      6 +
 .../headers/divide-by-zero-in-struct-layout.h      |     22 +
 bindgen-tests/tests/headers/do-not-derive-copy.hpp |      5 +
 bindgen-tests/tests/headers/doggo-or-null.hpp      |     20 +
 .../tests/headers/dupe-enum-variant-in-namespace.h |     10 +
 .../headers/duplicated-namespaces-definitions.hpp  |     18 +
 .../tests/headers/duplicated-namespaces.hpp        |      4 +
 .../tests/headers/duplicated_constants_in_ns.hpp   |      7 +
 .../tests/headers/dynamic_loading_attributes.h     |     11 +
 .../tests/headers/dynamic_loading_required.h       |      5 +
 .../tests/headers/dynamic_loading_simple.h         |      5 +
 .../tests/headers/dynamic_loading_template.hpp     |     10 +
 .../headers/dynamic_loading_with_allowlist.hpp     |     16 +
 .../headers/dynamic_loading_with_blocklist.hpp     |     15 +
 .../tests/headers/dynamic_loading_with_class.hpp   |     15 +
 bindgen-tests/tests/headers/elaborated.hpp         |      5 +
 bindgen-tests/tests/headers/empty-enum.h           |     15 +
 bindgen-tests/tests/headers/empty-union.hpp        |      5 +
 .../tests/headers/empty_template_param_name.hpp    |      7 +
 .../tests/headers/enum-default-bitfield.h          |      3 +
 bindgen-tests/tests/headers/enum-default-consts.h  |      3 +
 bindgen-tests/tests/headers/enum-default-module.h  |      3 +
 bindgen-tests/tests/headers/enum-default-rust.h    |      3 +
 bindgen-tests/tests/headers/enum-doc-bitfield.h    |      3 +
 bindgen-tests/tests/headers/enum-doc-mod.h         |      3 +
 bindgen-tests/tests/headers/enum-doc-rusty.h       |      3 +
 bindgen-tests/tests/headers/enum-doc.h             |     18 +
 bindgen-tests/tests/headers/enum-no-debug-rust.h   |      3 +
 .../tests/headers/enum-translate-type.hpp          |     14 +
 bindgen-tests/tests/headers/enum-undefault.h       |     11 +
 .../tests/headers/enum-variant-replaces.h          |     34 +
 bindgen-tests/tests/headers/enum.h                 |     31 +
 bindgen-tests/tests/headers/enum_alias.hpp         |      7 +
 .../tests/headers/enum_and_vtable_mangling.hpp     |     12 +
 bindgen-tests/tests/headers/enum_dupe.h            |      6 +
 bindgen-tests/tests/headers/enum_explicit_type.hpp |     42 +
 .../tests/headers/enum_explicit_type_constants.hpp |      5 +
 bindgen-tests/tests/headers/enum_in_template.hpp   |     10 +
 .../headers/enum_in_template_with_typedef.hpp      |     16 +
 bindgen-tests/tests/headers/enum_negative.h        |      6 +
 bindgen-tests/tests/headers/enum_packed.h          |     16 +
 ...rror-E0600-cannot-apply-unary-negation-to-u32.h |      5 +
 .../tests/headers/eval-value-dependent.hpp         |      6 +
 .../headers/eval-variadic-template-parameter.hpp   |      8 +
 bindgen-tests/tests/headers/explicit-padding.h     |     17 +
 bindgen-tests/tests/headers/extern-const-struct.h  |      7 +
 bindgen-tests/tests/headers/extern.hpp             |      3 +
 .../headers/fit-macro-constant-types-signed.h      |      2 +
 .../tests/headers/fit-macro-constant-types.h       |      4 +
 bindgen-tests/tests/headers/float128.hpp           |     13 +
 .../tests/headers/forward-declaration-autoptr.hpp  |     10 +
 bindgen-tests/tests/headers/forward-enum-decl.hpp  |      8 +
 .../headers/forward-inherit-struct-with-fields.hpp |      8 +
 .../tests/headers/forward-inherit-struct.hpp       |      5 +
 .../headers/forward_declared_complex_types.hpp     |     16 +
 .../headers/forward_declared_complex_types_1_0.hpp |     18 +
 .../tests/headers/forward_declared_opaque.h        |      4 +
 .../tests/headers/forward_declared_struct.h        |     11 +
 bindgen-tests/tests/headers/func_proto.h           |      1 +
 bindgen-tests/tests/headers/func_ptr.h             |      3 +
 bindgen-tests/tests/headers/func_ptr_in_struct.h   |      7 +
 bindgen-tests/tests/headers/func_ptr_return_type.h |      1 +
 bindgen-tests/tests/headers/func_return_must_use.h |     36 +
 bindgen-tests/tests/headers/func_with_array_arg.h  |      1 +
 .../tests/headers/func_with_func_ptr_arg.h         |      3 +
 .../tests/headers/function-typedef-stdcall.h       |     12 +
 .../tests/headers/gen-constructors-neg.hpp         |      6 +
 bindgen-tests/tests/headers/gen-constructors.hpp   |      6 +
 .../tests/headers/gen-destructors-neg.hpp          |      9 +
 bindgen-tests/tests/headers/gen-destructors.hpp    |      7 +
 bindgen-tests/tests/headers/generate-inline.hpp    |     12 +
 bindgen-tests/tests/headers/i128.h                 |      6 +
 bindgen-tests/tests/headers/in_class_typedef.hpp   |     10 +
 .../tests/headers/incomplete-array-padding.h       |      4 +
 bindgen-tests/tests/headers/infinite-macro.h       |      2 +
 ...rit-from-template-instantiation-with-vtable.hpp |     37 +
 bindgen-tests/tests/headers/inherit-namespaced.hpp |      4 +
 bindgen-tests/tests/headers/inherit_named.hpp      |      5 +
 bindgen-tests/tests/headers/inherit_typedef.hpp    |      5 +
 bindgen-tests/tests/headers/inline-function.h      |      6 +
 bindgen-tests/tests/headers/inline_namespace.hpp   |     11 +
 .../tests/headers/inline_namespace_allowlist.hpp   |      7 +
 .../headers/inline_namespace_conservative.hpp      |     12 +
 .../headers/inline_namespace_no_ns_enabled.hpp     |     18 +
 .../tests/headers/inner-typedef-gh422.hpp          |     11 +
 bindgen-tests/tests/headers/inner_const.hpp        |      6 +
 .../tests/headers/inner_template_self.hpp          |     10 +
 bindgen-tests/tests/headers/int128_t.h             |      7 +
 .../tests/headers/issue-1025-unknown-enum-repr.hpp |      4 +
 bindgen-tests/tests/headers/issue-1034.h           |      4 +
 bindgen-tests/tests/headers/issue-1040.h           |      1 +
 .../issue-1076-unnamed-bitfield-alignment.h        |      4 +
 .../headers/issue-1113-template-references.hpp     |     16 +
 .../headers/issue-1118-using-forward-decl.hpp      |     10 +
 .../headers/issue-1197-pure-virtual-stuff.hpp      |      6 +
 .../headers/issue-1198-alias-rust-bitfield-enum.h  |     13 +
 ...issue-1198-alias-rust-const-mod-bitfield-enum.h |     13 +
 .../headers/issue-1198-alias-rust-const-mod-enum.h |     13 +
 .../tests/headers/issue-1198-alias-rust-enum.h     |     14 +
 .../tests/headers/issue-1216-variadic-member.h     |      4 +
 .../tests/headers/issue-1238-fwd-no-copy.h         |      3 +
 bindgen-tests/tests/headers/issue-1281.h           |     11 +
 bindgen-tests/tests/headers/issue-1285.h           |      8 +
 bindgen-tests/tests/headers/issue-1291.hpp         |     21 +
 .../headers/issue-1350-attribute-overloadable.h    |      2 +
 .../headers/issue-1382-rust-primitive-types.h      |     34 +
 bindgen-tests/tests/headers/issue-1435.hpp         |      7 +
 bindgen-tests/tests/headers/issue-1443.hpp         |     21 +
 bindgen-tests/tests/headers/issue-1454.h           |     10 +
 bindgen-tests/tests/headers/issue-1464.hpp         |      7 +
 .../tests/headers/issue-1488-enum-new-type.h       |     29 +
 bindgen-tests/tests/headers/issue-1488-options.h   |      5 +
 .../headers/issue-1488-template-alias-new-type.hpp |      4 +
 bindgen-tests/tests/headers/issue-1498.h           |     17 +
 bindgen-tests/tests/headers/issue-1514.hpp         |      9 +
 bindgen-tests/tests/headers/issue-1554.h           |      6 +
 .../headers/issue-1599-opaque-typedef-to-enum.h    |      3 +
 .../headers/issue-1676-macro-namespace-prefix.hpp  |      2 +
 bindgen-tests/tests/headers/issue-1947.h           |      9 +
 .../tests/headers/issue-1977-larger-arrays.hpp     |      9 +
 bindgen-tests/tests/headers/issue-1995.h           |     12 +
 bindgen-tests/tests/headers/issue-2019.hpp         |     10 +
 .../issue-2239-template-dependent-bit-width.hpp    |     10 +
 bindgen-tests/tests/headers/issue-358.hpp          |      8 +
 bindgen-tests/tests/headers/issue-372.hpp          |     16 +
 bindgen-tests/tests/headers/issue-410.hpp          |     12 +
 bindgen-tests/tests/headers/issue-446.hpp          |     11 +
 bindgen-tests/tests/headers/issue-447.hpp          |     27 +
 bindgen-tests/tests/headers/issue-493.hpp          |     48 +
 bindgen-tests/tests/headers/issue-493_1_0.hpp      |     49 +
 bindgen-tests/tests/headers/issue-511.h            |      4 +
 .../tests/headers/issue-537-repr-packed-n.h        |     34 +
 bindgen-tests/tests/headers/issue-537.h            |     35 +
 .../tests/headers/issue-544-stylo-creduce-2.hpp    |      8 +
 .../tests/headers/issue-544-stylo-creduce.hpp      |      5 +
 ...emplate-params-causing-layout-test-failures.hpp |     27 +
 .../headers/issue-573-layout-test-failures.hpp     |     12 +
 .../issue-574-assertion-failure-in-codegen.hpp     |      6 +
 .../issue-584-stylo-template-analysis-panic.hpp    |     13 +
 ...issue-638-stylo-cannot-find-T-in-this-scope.hpp |     12 +
 .../tests/headers/issue-639-typedef-anon-field.hpp |     15 +
 .../tests/headers/issue-643-inner-struct.h         |     13 +
 .../issue-645-cannot-find-type-T-in-this-scope.hpp |      9 +
 .../headers/issue-648-derive-debug-with-padding.h  |     21 +
 .../tests/headers/issue-654-struct-fn-collision.h  |      2 +
 .../issue-662-cannot-find-T-in-this-scope.hpp      |      7 +
 bindgen-tests/tests/headers/issue-662-part-2.hpp   |     11 +
 bindgen-tests/tests/headers/issue-674-1.hpp        |      8 +
 bindgen-tests/tests/headers/issue-674-2.hpp        |     15 +
 bindgen-tests/tests/headers/issue-674-3.hpp        |     11 +
 .../headers/issue-677-nested-ns-specifier.hpp      |      5 +
 .../issue-691-template-parameter-virtual.hpp       |     12 +
 .../tests/headers/issue-710-must-use-type.h        |      8 +
 .../headers/issue-739-pointer-wide-bitfield.h      |      9 +
 .../headers/issue-769-bad-instantiation-test.hpp   |     11 +
 .../tests/headers/issue-801-opaque-sloppiness.hpp  |     11 +
 ...ue-807-opaque-types-methods-being-generated.hpp |     36 +
 bindgen-tests/tests/headers/issue-816.h            |     49 +
 .../issue-820-unused-template-param-in-alias.hpp   |      5 +
 ...ue-826-generating-methods-when-asked-not-to.hpp |      5 +
 bindgen-tests/tests/headers/issue-833-1.hpp        |      8 +
 bindgen-tests/tests/headers/issue-833-2.hpp        |      6 +
 bindgen-tests/tests/headers/issue-833.hpp          |      8 +
 bindgen-tests/tests/headers/issue-834.hpp          |      6 +
 .../issue-848-replacement-system-include.hpp       |      7 +
 bindgen-tests/tests/headers/issue-848/an-include.h |     17 +
 .../tests/headers/issue-888-enum-var-decl-jump.hpp |     11 +
 .../issue-944-derive-copy-and-blocklisting.hpp     |     10 +
 bindgen-tests/tests/headers/issue-946.h            |      5 +
 bindgen-tests/tests/headers/issue_311.hpp          |      5 +
 bindgen-tests/tests/headers/issue_315.hpp          |      2 +
 .../tests/headers/jsval_layout_opaque.hpp          |    425 +
 .../tests/headers/jsval_layout_opaque_1_0.hpp      |    425 +
 bindgen-tests/tests/headers/keywords.h             |     56 +
 bindgen-tests/tests/headers/layout.h               |     10 +
 bindgen-tests/tests/headers/layout_align.h         |     20 +
 bindgen-tests/tests/headers/layout_arp.h           |     52 +
 bindgen-tests/tests/headers/layout_array.h         |    110 +
 .../tests/headers/layout_array_too_long.h          |     61 +
 bindgen-tests/tests/headers/layout_cmdline_token.h |     64 +
 bindgen-tests/tests/headers/layout_eth_conf.h      |    428 +
 bindgen-tests/tests/headers/layout_eth_conf_1_0.h  |    429 +
 bindgen-tests/tests/headers/layout_kni_mbuf.h      |     33 +
 .../tests/headers/layout_large_align_field.h       |     99 +
 bindgen-tests/tests/headers/layout_mbuf.h          |    188 +
 bindgen-tests/tests/headers/layout_mbuf_1_0.h      |    189 +
 bindgen-tests/tests/headers/long_double.h          |      5 +
 bindgen-tests/tests/headers/macro-expr-basic.h     |     14 +
 .../tests/headers/macro-expr-uncommon-token.h      |      7 +
 bindgen-tests/tests/headers/macro-redef.h          |      5 +
 bindgen-tests/tests/headers/macro_const.h          |      8 +
 bindgen-tests/tests/headers/macro_const_1_0.h      |     10 +
 .../tests/headers/maddness-is-avoidable.hpp        |      9 +
 bindgen-tests/tests/headers/mangling-ios.h         |      3 +
 bindgen-tests/tests/headers/mangling-linux32.hpp   |      7 +
 bindgen-tests/tests/headers/mangling-linux64.hpp   |      7 +
 bindgen-tests/tests/headers/mangling-macos.hpp     |      7 +
 bindgen-tests/tests/headers/mangling-win32.hpp     |     18 +
 bindgen-tests/tests/headers/mangling-win64.hpp     |      7 +
 bindgen-tests/tests/headers/merge-extern-blocks.h  |      6 +
 bindgen-tests/tests/headers/method-mangling.hpp    |      5 +
 bindgen-tests/tests/headers/module-allowlisted.hpp |      2 +
 bindgen-tests/tests/headers/msvc-no-usr.hpp        |      8 +
 .../multiple-inherit-empty-correct-layout.hpp      |      3 +
 bindgen-tests/tests/headers/mutable.hpp            |     14 +
 bindgen-tests/tests/headers/namespace.hpp          |     51 +
 bindgen-tests/tests/headers/namespace/nsbegin.h    |      1 +
 bindgen-tests/tests/headers/namespace/nsend.h      |      1 +
 .../tests/headers/nested-template-typedef.hpp      |      8 +
 bindgen-tests/tests/headers/nested.hpp             |     15 +
 bindgen-tests/tests/headers/nested_vtable.hpp      |      8 +
 .../tests/headers/nested_within_namespace.hpp      |     15 +
 bindgen-tests/tests/headers/newtype-enum.hpp       |      8 +
 .../tests/headers/newtype-global-enum.hpp          |      8 +
 bindgen-tests/tests/headers/no-comments.h          |      5 +
 bindgen-tests/tests/headers/no-derive-debug.h      |     15 +
 bindgen-tests/tests/headers/no-derive-default.h    |     15 +
 .../tests/headers/no-hash-allowlisted.hpp          |      5 +
 bindgen-tests/tests/headers/no-hash-opaque.hpp     |      5 +
 .../tests/headers/no-partialeq-allowlisted.hpp     |      5 +
 .../tests/headers/no-partialeq-opaque.hpp          |      5 +
 .../tests/headers/no-recursive-allowlisting.h      |      7 +
 bindgen-tests/tests/headers/no-std.h               |      5 +
 bindgen-tests/tests/headers/no_copy.hpp            |      6 +
 .../tests/headers/no_copy_allowlisted.hpp          |      5 +
 bindgen-tests/tests/headers/no_copy_opaque.hpp     |      5 +
 bindgen-tests/tests/headers/no_debug.hpp           |      6 +
 .../tests/headers/no_debug_allowlisted.hpp         |      5 +
 .../tests/headers/no_debug_bypass_impl_debug.hpp   |     11 +
 bindgen-tests/tests/headers/no_debug_opaque.hpp    |      5 +
 bindgen-tests/tests/headers/no_default.hpp         |     11 +
 .../tests/headers/no_default_allowlisted.hpp       |      5 +
 .../headers/no_default_bypass_derive_default.hpp   |     11 +
 bindgen-tests/tests/headers/no_default_opaque.hpp  |      5 +
 bindgen-tests/tests/headers/no_size_t_is_usize.h   |     10 +
 bindgen-tests/tests/headers/non-type-params.hpp    |     17 +
 bindgen-tests/tests/headers/noreturn.hpp           |      4 +
 bindgen-tests/tests/headers/nsBaseHashtable.hpp    |     48 +
 bindgen-tests/tests/headers/nsStyleAutoArray.hpp   |     58 +
 bindgen-tests/tests/headers/objc_allowlist.h       |     24 +
 bindgen-tests/tests/headers/objc_blocklist.h       |      9 +
 bindgen-tests/tests/headers/objc_category.h        |     10 +
 bindgen-tests/tests/headers/objc_class.h           |     10 +
 bindgen-tests/tests/headers/objc_class_method.h    |     11 +
 bindgen-tests/tests/headers/objc_inheritance.h     |     11 +
 bindgen-tests/tests/headers/objc_interface.h       |      8 +
 bindgen-tests/tests/headers/objc_interface_type.h  |     13 +
 bindgen-tests/tests/headers/objc_method.h          |     15 +
 bindgen-tests/tests/headers/objc_method_clash.h    |      7 +
 .../tests/headers/objc_pointer_return_types.h      |     10 +
 bindgen-tests/tests/headers/objc_property_fnptr.h  |      6 +
 bindgen-tests/tests/headers/objc_protocol.h        |      8 +
 .../tests/headers/objc_protocol_inheritance.h      |     11 +
 bindgen-tests/tests/headers/objc_sel_and_id.h      |      7 +
 bindgen-tests/tests/headers/objc_template.h        |     10 +
 bindgen-tests/tests/headers/only_bitfields.hpp     |      4 +
 .../headers/opaque-template-inst-member-2.hpp      |     20 +
 .../tests/headers/opaque-template-inst-member.hpp  |     20 +
 .../opaque-template-instantiation-namespaced.hpp   |     29 +
 .../headers/opaque-template-instantiation.hpp      |     17 +
 bindgen-tests/tests/headers/opaque-tracing.hpp     |     21 +
 bindgen-tests/tests/headers/opaque_in_struct.hpp   |     11 +
 bindgen-tests/tests/headers/opaque_pointer.hpp     |     23 +
 bindgen-tests/tests/headers/opaque_typedef.hpp     |     17 +
 bindgen-tests/tests/headers/operator.hpp           |      5 +
 bindgen-tests/tests/headers/ord-enum.h             |     15 +
 bindgen-tests/tests/headers/overflowed_enum.hpp    |     12 +
 bindgen-tests/tests/headers/overloading.hpp        |      9 +
 bindgen-tests/tests/headers/packed-bitfield.h      |      5 +
 .../tests/headers/packed-n-with-padding.h          |      8 +
 bindgen-tests/tests/headers/packed-vtable.h        |     10 +
 bindgen-tests/tests/headers/parm-union.hpp         |      4 +
 .../parsecb-anonymous-enum-variant-rename.h        |      6 +
 .../partial-specialization-and-inheritance.hpp     |     40 +
 bindgen-tests/tests/headers/pointer-attr.h         |      1 +
 .../headers/prepend-enum-constified-variant.h      |      6 +
 bindgen-tests/tests/headers/prepend_enum_name.hpp  |      6 +
 bindgen-tests/tests/headers/private.hpp            |     21 +
 bindgen-tests/tests/headers/private_fields.hpp     |     44 +
 bindgen-tests/tests/headers/public-dtor.hpp        |     15 +
 .../tests/headers/qualified-dependent-types.hpp    |     16 +
 bindgen-tests/tests/headers/redeclaration.hpp      |      7 +
 bindgen-tests/tests/headers/ref_argument_array.hpp |      6 +
 .../tests/headers/reparented_replacement.hpp       |     16 +
 .../tests/headers/replace_template_alias.hpp       |     23 +
 bindgen-tests/tests/headers/replace_use.hpp        |     15 +
 bindgen-tests/tests/headers/replaces_double.hpp    |     20 +
 bindgen-tests/tests/headers/repr-align.hpp         |     11 +
 .../tests/headers/resolved_type_def_function.h     |      2 +
 .../same_struct_name_in_different_namespaces.hpp   |     12 +
 .../headers/sentry-defined-multiple-times.hpp      |     85 +
 bindgen-tests/tests/headers/short-enums.hpp        |     19 +
 bindgen-tests/tests/headers/size_t_template.hpp    |      8 +
 bindgen-tests/tests/headers/sorted-items.h         |     17 +
 bindgen-tests/tests/headers/stdint_typedef.h       |     10 +
 .../struct_containing_forward_declared_struct.h    |      8 +
 bindgen-tests/tests/headers/struct_typedef.h       |     17 +
 bindgen-tests/tests/headers/struct_typedef_ns.hpp  |     21 +
 .../tests/headers/struct_with_anon_struct.h        |      8 +
 .../tests/headers/struct_with_anon_struct_array.h  |     12 +
 .../headers/struct_with_anon_struct_pointer.h      |      7 +
 .../tests/headers/struct_with_anon_union.h         |      8 +
 .../tests/headers/struct_with_anon_union_1_0.h     |      8 +
 .../headers/struct_with_anon_unnamed_struct.h      |      7 +
 .../tests/headers/struct_with_anon_unnamed_union.h |      7 +
 .../headers/struct_with_anon_unnamed_union_1_0.h   |      8 +
 .../tests/headers/struct_with_bitfields.h          |     14 +
 .../tests/headers/struct_with_derive_debug.h       |     17 +
 .../tests/headers/struct_with_large_array.hpp      |      9 +
 bindgen-tests/tests/headers/struct_with_nesting.h  |     19 +
 .../tests/headers/struct_with_nesting_1_0.h        |     19 +
 bindgen-tests/tests/headers/struct_with_packing.h  |      6 +
 bindgen-tests/tests/headers/struct_with_struct.h   |      8 +
 .../headers/struct_with_typedef_template_arg.hpp   |      5 +
 bindgen-tests/tests/headers/template-fun-ty.hpp    |     17 +
 .../tests/headers/template-param-usage-0.hpp       |      6 +
 .../tests/headers/template-param-usage-1.hpp       |      6 +
 .../tests/headers/template-param-usage-10.hpp      |     14 +
 .../tests/headers/template-param-usage-11.hpp      |      6 +
 .../tests/headers/template-param-usage-12.hpp      |     11 +
 .../tests/headers/template-param-usage-13.hpp      |     11 +
 .../tests/headers/template-param-usage-14.hpp      |     11 +
 .../tests/headers/template-param-usage-15.hpp      |     11 +
 .../tests/headers/template-param-usage-2.hpp       |     10 +
 .../tests/headers/template-param-usage-3.hpp       |     12 +
 .../tests/headers/template-param-usage-4.hpp       |     11 +
 .../tests/headers/template-param-usage-5.hpp       |      8 +
 .../tests/headers/template-param-usage-6.hpp       |      8 +
 .../tests/headers/template-param-usage-7.hpp       |     10 +
 .../tests/headers/template-param-usage-8.hpp       |     10 +
 .../tests/headers/template-param-usage-9.hpp       |     12 +
 bindgen-tests/tests/headers/template-with-var.hpp  |      7 +
 bindgen-tests/tests/headers/template.hpp           |    168 +
 bindgen-tests/tests/headers/template_alias.hpp     |     13 +
 .../tests/headers/template_alias_basic.hpp         |      4 +
 .../tests/headers/template_alias_namespace.hpp     |     13 +
 bindgen-tests/tests/headers/template_fun.hpp       |      3 +
 .../template_instantiation_with_fn_local_type.hpp  |     27 +
 .../headers/template_partial_specification.hpp     |     10 +
 .../headers/template_typedef_transitive_param.hpp  |      8 +
 bindgen-tests/tests/headers/template_typedefs.hpp  |      8 +
 bindgen-tests/tests/headers/templateref_opaque.hpp |     12 +
 .../tests/headers/templatized-bitfield.hpp         |      7 +
 bindgen-tests/tests/headers/timex.h                |     15 +
 bindgen-tests/tests/headers/transform-op.hpp       |     75 +
 .../type-referenced-by-allowlisted-function.h      |      7 +
 bindgen-tests/tests/headers/type_alias_empty.hpp   |     10 +
 ...type_alias_partial_template_especialization.hpp |      7 +
 .../headers/type_alias_template_specialized.hpp    |      9 +
 .../tests/headers/typedefd-array-as-function-arg.h |      3 +
 bindgen-tests/tests/headers/typeref.hpp            |     29 +
 bindgen-tests/tests/headers/typeref_1_0.hpp        |     30 +
 bindgen-tests/tests/headers/underscore.hpp         |      3 +
 bindgen-tests/tests/headers/union-align.h          |     10 +
 bindgen-tests/tests/headers/union-in-ns.hpp        |      5 +
 bindgen-tests/tests/headers/union-in-ns_1_0.hpp    |      5 +
 bindgen-tests/tests/headers/union_bitfield.h       |     10 +
 bindgen-tests/tests/headers/union_bitfield_1_0.h   |     14 +
 bindgen-tests/tests/headers/union_dtor.hpp         |      5 +
 bindgen-tests/tests/headers/union_dtor_1_0.hpp     |      7 +
 bindgen-tests/tests/headers/union_fields.hpp       |      7 +
 bindgen-tests/tests/headers/union_fields_1_0.hpp   |      7 +
 bindgen-tests/tests/headers/union_template.hpp     |     21 +
 bindgen-tests/tests/headers/union_template_1_0.hpp |     21 +
 .../tests/headers/union_with_anon_struct.h         |      8 +
 .../tests/headers/union_with_anon_struct_1_0.h     |      8 +
 .../headers/union_with_anon_struct_bitfield.h      |      9 +
 .../headers/union_with_anon_struct_bitfield_1_0.h  |      9 +
 .../tests/headers/union_with_anon_union.h          |      8 +
 .../tests/headers/union_with_anon_union_1_0.h      |      8 +
 .../tests/headers/union_with_anon_unnamed_struct.h |     11 +
 .../headers/union_with_anon_unnamed_struct_1_0.h   |     11 +
 .../tests/headers/union_with_anon_unnamed_union.h  |      9 +
 .../headers/union_with_anon_unnamed_union_1_0.h    |      9 +
 .../tests/headers/union_with_big_member.h          |     16 +
 .../tests/headers/union_with_big_member_1_0.h      |     16 +
 bindgen-tests/tests/headers/union_with_nesting.h   |     16 +
 .../tests/headers/union_with_nesting_1_0.h         |     16 +
 .../tests/headers/union_with_non_copy_member.h     |     20 +
 bindgen-tests/tests/headers/unknown_attr.h         |      6 +
 bindgen-tests/tests/headers/unsorted-items.h       |     15 +
 bindgen-tests/tests/headers/use-core.h             |     13 +
 bindgen-tests/tests/headers/use-core_1_0.h         |     13 +
 bindgen-tests/tests/headers/using.hpp              |     11 +
 bindgen-tests/tests/headers/var-tracing.hpp        |     10 +
 bindgen-tests/tests/headers/variadic-method.hpp    |      6 +
 .../tests/headers/variadic_template_function.hpp   |      6 +
 bindgen-tests/tests/headers/vector.hpp             |      9 +
 bindgen-tests/tests/headers/virtual_dtor.hpp       |      3 +
 .../tests/headers/virtual_inheritance.hpp          |     16 +
 bindgen-tests/tests/headers/virtual_interface.hpp  |     24 +
 bindgen-tests/tests/headers/virtual_overloaded.hpp |      5 +
 .../tests/headers/vtable_recursive_sig.hpp         |     11 +
 .../tests/headers/wasm-constructor-returns.hpp     |      7 +
 bindgen-tests/tests/headers/wasm-import-module.h   |      3 +
 bindgen-tests/tests/headers/weird_bitfields.hpp    |     36 +
 bindgen-tests/tests/headers/what_is_going_on.hpp   |     19 +
 bindgen-tests/tests/headers/win32-thiscall_1_0.hpp |      7 +
 .../tests/headers/win32-thiscall_nightly.hpp       |      7 +
 bindgen-tests/tests/headers/win32-vectorcall-1_0.h |      3 +
 .../tests/headers/win32-vectorcall-nightly.h       |      3 +
 .../tests/headers/with_array_pointers_arguments.h  |     10 +
 .../headers/without_array_pointers_arguments.h     |      9 +
 .../tests/headers/zero-size-array-align.h          |      5 +
 bindgen-tests/tests/headers/zero-sized-array.hpp   |     45 +
 bindgen-tests/tests/parse_callbacks/mod.rs         |     42 +
 bindgen-tests/tests/quickchecking/.gitignore       |      1 +
 bindgen-tests/tests/quickchecking/Cargo.toml       |     32 +
 bindgen-tests/tests/quickchecking/README.md        |     39 +
 bindgen-tests/tests/quickchecking/src/bin.rs       |    112 +
 bindgen-tests/tests/quickchecking/src/fuzzers.rs   |    635 +
 bindgen-tests/tests/quickchecking/src/lib.rs       |    133 +
 .../tests/quickchecking/tests/fuzzed-c-headers.rs  |     96 +
 bindgen-tests/tests/rustfmt.toml                   |      3 +
 bindgen-tests/tests/stylo.hpp                      | 177914 ++++++++++++++++++
 bindgen-tests/tests/stylo_sanity.rs                |    556 +
 bindgen-tests/tests/test-one.sh                    |     98 +
 bindgen-tests/tests/tests.rs                       |    715 +
 bindgen-tests/tests/uses/.gitignore                |      2 +
 bindgen/Cargo.toml                                 |     69 +
 bindgen/build.rs                                   |     29 +
 bindgen/callbacks.rs                               |    106 +
 bindgen/clang.rs                                   |   2216 +
 bindgen/codegen/bitfield_unit.rs                   |    102 +
 bindgen/codegen/bitfield_unit_tests.rs             |    260 +
 bindgen/codegen/dyngen.rs                          |    181 +
 bindgen/codegen/error.rs                           |     33 +
 bindgen/codegen/helpers.rs                         |    309 +
 bindgen/codegen/impl_debug.rs                      |    245 +
 bindgen/codegen/impl_partialeq.rs                  |    142 +
 bindgen/codegen/mod.rs                             |   5050 +
 .../codegen/postprocessing/merge_extern_blocks.rs  |     46 +
 bindgen/codegen/postprocessing/mod.rs              |     66 +
 .../codegen/postprocessing/sort_semantically.rs    |     24 +
 bindgen/codegen/struct_layout.rs                   |    444 +
 bindgen/csmith-fuzzing/README.md                   |     65 +
 bindgen/csmith-fuzzing/csmith.h                    |     15 +
 bindgen/csmith-fuzzing/driver.py                   |    284 +
 bindgen/csmith-fuzzing/predicate.py                |    273 +
 bindgen/deps.rs                                    |     20 +
 bindgen/extra_assertions.rs                        |     34 +
 bindgen/features.rs                                |    313 +
 bindgen/ir/analysis/derive.rs                      |    732 +
 bindgen/ir/analysis/has_destructor.rs              |    176 +
 bindgen/ir/analysis/has_float.rs                   |    252 +
 bindgen/ir/analysis/has_type_param_in_array.rs     |    252 +
 bindgen/ir/analysis/has_vtable.rs                  |    240 +
 bindgen/ir/analysis/mod.rs                         |    402 +
 bindgen/ir/analysis/sizedness.rs                   |    361 +
 bindgen/ir/analysis/template_params.rs             |    608 +
 bindgen/ir/annotations.rs                          |    211 +
 bindgen/ir/comment.rs                              |    119 +
 bindgen/ir/comp.rs                                 |   1891 +
 bindgen/ir/context.rs                              |   2855 +
 bindgen/ir/derive.rs                               |    135 +
 bindgen/ir/dot.rs                                  |     86 +
 bindgen/ir/enum_ty.rs                              |    320 +
 bindgen/ir/function.rs                             |    690 +
 bindgen/ir/int.rs                                  |    127 +
 bindgen/ir/item.rs                                 |   2018 +
 bindgen/ir/item_kind.rs                            |    147 +
 bindgen/ir/layout.rs                               |    143 +
 bindgen/ir/mod.rs                                  |     24 +
 bindgen/ir/module.rs                               |     95 +
 bindgen/ir/objc.rs                                 |    329 +
 bindgen/ir/template.rs                             |    343 +
 bindgen/ir/traversal.rs                            |    478 +
 bindgen/ir/ty.rs                                   |   1266 +
 bindgen/ir/var.rs                                  |    413 +
 bindgen/lib.rs                                     |   2928 +
 bindgen/log_stubs.rs                               |     32 +
 bindgen/parse.rs                                   |    102 +
 bindgen/regex_set.rs                               |     92 +
 bindgen/time.rs                                    |     52 +
 book/src/command-line-usage.md                     |      2 +-
 build.rs                                           |     90 -
 ci/no-includes.sh                                  |      2 +-
 ci/test.sh                                         |      4 +-
 csmith-fuzzing/README.md                           |     65 -
 csmith-fuzzing/csmith.h                            |     15 -
 csmith-fuzzing/driver.py                           |    284 -
 csmith-fuzzing/predicate.py                        |    273 -
 src/callbacks.rs                                   |    106 -
 src/clang.rs                                       |   2216 -
 src/codegen/bitfield_unit.rs                       |    102 -
 src/codegen/bitfield_unit_tests.rs                 |    260 -
 src/codegen/dyngen.rs                              |    181 -
 src/codegen/error.rs                               |     33 -
 src/codegen/helpers.rs                             |    309 -
 src/codegen/impl_debug.rs                          |    245 -
 src/codegen/impl_partialeq.rs                      |    142 -
 src/codegen/mod.rs                                 |   5050 -
 src/codegen/postprocessing/merge_extern_blocks.rs  |     46 -
 src/codegen/postprocessing/mod.rs                  |     66 -
 src/codegen/postprocessing/sort_semantically.rs    |     24 -
 src/codegen/struct_layout.rs                       |    444 -
 src/deps.rs                                        |     20 -
 src/extra_assertions.rs                            |     34 -
 src/features.rs                                    |    313 -
 src/ir/analysis/derive.rs                          |    732 -
 src/ir/analysis/has_destructor.rs                  |    176 -
 src/ir/analysis/has_float.rs                       |    252 -
 src/ir/analysis/has_type_param_in_array.rs         |    252 -
 src/ir/analysis/has_vtable.rs                      |    240 -
 src/ir/analysis/mod.rs                             |    402 -
 src/ir/analysis/sizedness.rs                       |    361 -
 src/ir/analysis/template_params.rs                 |    608 -
 src/ir/annotations.rs                              |    211 -
 src/ir/comment.rs                                  |    119 -
 src/ir/comp.rs                                     |   1891 -
 src/ir/context.rs                                  |   2855 -
 src/ir/derive.rs                                   |    135 -
 src/ir/dot.rs                                      |     86 -
 src/ir/enum_ty.rs                                  |    320 -
 src/ir/function.rs                                 |    690 -
 src/ir/int.rs                                      |    127 -
 src/ir/item.rs                                     |   2018 -
 src/ir/item_kind.rs                                |    147 -
 src/ir/layout.rs                                   |    143 -
 src/ir/mod.rs                                      |     24 -
 src/ir/module.rs                                   |     95 -
 src/ir/objc.rs                                     |    329 -
 src/ir/template.rs                                 |    343 -
 src/ir/traversal.rs                                |    478 -
 src/ir/ty.rs                                       |   1266 -
 src/ir/var.rs                                      |    413 -
 src/lib.rs                                         |   2928 -
 src/log_stubs.rs                                   |     32 -
 src/main.rs                                        |    109 -
 src/options.rs                                     |   1092 -
 src/parse.rs                                       |    102 -
 src/regex_set.rs                                   |     92 -
 src/time.rs                                        |     52 -
 tests/.gitattributes                               |      4 -
 tests/expectations/Cargo.toml                      |     15 -
 tests/expectations/build.rs                        |     65 -
 tests/expectations/lib.rs                          |      3 -
 tests/expectations/src/lib.rs                      |      1 -
 .../struct_with_anon_struct_array_float.rs         |      1 -
 tests/expectations/tests/.gitattributes            |      2 -
 tests/expectations/tests/16-byte-alignment.rs      |    355 -
 tests/expectations/tests/16-byte-alignment_1_0.rs  |    396 -
 tests/expectations/tests/381-decltype-alias.rs     |     13 -
 tests/expectations/tests/accessors.rs              |    434 -
 tests/expectations/tests/allowlist-file.rs         |    155 -
 .../tests/allowlist-namespaces-basic.rs            |     38 -
 tests/expectations/tests/allowlist-namespaces.rs   |     71 -
 tests/expectations/tests/allowlist_basic.rs        |     38 -
 tests/expectations/tests/allowlist_fix.rs          |     12 -
 tests/expectations/tests/allowlist_vars.rs         |     11 -
 tests/expectations/tests/allowlist_warnings.rs     |      6 -
 .../tests/allowlisted-item-references-no-hash.rs   |     56 -
 .../allowlisted-item-references-no-partialeq.rs    |     56 -
 .../tests/allowlisted_item_references_no_copy.rs   |     56 -
 tests/expectations/tests/annotation_hide.rs        |     58 -
 tests/expectations/tests/anon-fields-prefix.rs     |    150 -
 tests/expectations/tests/anon_enum.rs              |     51 -
 tests/expectations/tests/anon_enum_allowlist.rs    |     15 -
 tests/expectations/tests/anon_enum_trait.rs        |     56 -
 tests/expectations/tests/anon_struct_in_union.rs   |    113 -
 .../expectations/tests/anon_struct_in_union_1_0.rs |    154 -
 tests/expectations/tests/anon_union.rs             |    101 -
 tests/expectations/tests/anon_union_1_0.rs         |    143 -
 .../expectations/tests/anonymous-template-types.rs |     48 -
 tests/expectations/tests/arg_keyword.rs            |     11 -
 .../tests/array-of-zero-sized-types.rs             |     59 -
 .../tests/attribute_warn_unused_result.rs          |     48 -
 ...te_warn_unused_result_no_attribute_detection.rs |     45 -
 .../tests/attribute_warn_unused_result_pre_1_27.rs |     45 -
 .../tests/bad-namespace-parenthood-inheritance.rs  |     26 -
 tests/expectations/tests/base-to-derived.rs        |     25 -
 .../tests/bindgen-union-inside-namespace.rs        |    114 -
 .../expectations/tests/bitfield-32bit-overflow.rs  |    715 -
 tests/expectations/tests/bitfield-enum-basic.rs    |    169 -
 tests/expectations/tests/bitfield-enum-repr-c.rs   |     48 -
 .../tests/bitfield-enum-repr-transparent.rs        |     48 -
 tests/expectations/tests/bitfield-large.rs         |    203 -
 tests/expectations/tests/bitfield-linux-32.rs      |    166 -
 .../tests/bitfield-method-same-name.rs             |    164 -
 tests/expectations/tests/bitfield_align.rs         |    797 -
 tests/expectations/tests/bitfield_align_2.rs       |    176 -
 .../expectations/tests/bitfield_large_overflow.rs  |     29 -
 .../expectations/tests/bitfield_method_mangling.rs |    158 -
 tests/expectations/tests/bitfield_pragma_packed.rs |    211 -
 tests/expectations/tests/block_return_type.rs      |     16 -
 .../expectations/tests/blocklist-and-impl-debug.rs |     54 -
 tests/expectations/tests/blocklist-file.rs         |     91 -
 tests/expectations/tests/blocklist-function.rs     |     42 -
 tests/expectations/tests/blocklist-item.rs         |     24 -
 tests/expectations/tests/blocks-signature.rs       |     92 -
 tests/expectations/tests/blocks.rs                 |     80 -
 tests/expectations/tests/bug-1529681.rs            |     25 -
 tests/expectations/tests/builtin-template.rs       |      8 -
 tests/expectations/tests/c-empty-layout.rs         |     23 -
 tests/expectations/tests/c_naming.rs               |    102 -
 tests/expectations/tests/call-conv-typedef.rs      |     12 -
 tests/expectations/tests/canonical-types.rs        |    281 -
 .../tests/canonical_path_without_namespacing.rs    |     29 -
 tests/expectations/tests/char.rs                   |    107 -
 tests/expectations/tests/class.rs                  |    507 -
 tests/expectations/tests/class_1_0.rs              |    558 -
 tests/expectations/tests/class_nested.rs           |    195 -
 tests/expectations/tests/class_no_members.rs       |     76 -
 tests/expectations/tests/class_static.rs           |     38 -
 tests/expectations/tests/class_static_const.rs     |     28 -
 tests/expectations/tests/class_use_as.rs           |     72 -
 tests/expectations/tests/class_with_dtor.rs        |     85 -
 .../expectations/tests/class_with_inner_struct.rs  |    490 -
 .../tests/class_with_inner_struct_1_0.rs           |    546 -
 tests/expectations/tests/class_with_typedef.rs     |    146 -
 tests/expectations/tests/comment-indent.rs         |    139 -
 tests/expectations/tests/complex.rs                |    155 -
 tests/expectations/tests/complex_global.rs         |     22 -
 tests/expectations/tests/const-const-mut-ptr.rs    |     42 -
 tests/expectations/tests/const_array.rs            |     13 -
 tests/expectations/tests/const_array_fn_arg.rs     |     10 -
 tests/expectations/tests/const_enum_unnamed.rs     |     39 -
 .../tests/const_multidim_array_fn_arg.rs           |     10 -
 tests/expectations/tests/const_ptr.rs              |     10 -
 tests/expectations/tests/const_resolved_ty.rs      |     10 -
 tests/expectations/tests/const_tparam.rs           |     23 -
 .../tests/constant-non-specialized-tp.rs           |     22 -
 .../tests/constified-enum-module-overflow.rs       |     57 -
 tests/expectations/tests/constify-all-enums.rs     |     54 -
 tests/expectations/tests/constify-enum.rs          |     24 -
 .../tests/constify-module-enums-basic.rs           |     72 -
 .../tests/constify-module-enums-namespace.rs       |     73 -
 .../tests/constify-module-enums-shadow-name.rs     |     54 -
 .../tests/constify-module-enums-simple-alias.rs    |    121 -
 .../constify-module-enums-simple-nonamespace.rs    |     53 -
 .../tests/constify-module-enums-types.rs           |    299 -
 tests/expectations/tests/constructor-tp.rs         |     42 -
 tests/expectations/tests/constructors.rs           |     80 -
 tests/expectations/tests/constructors_1_33.rs      |     82 -
 .../tests/contains-vs-inherits-zero-sized.rs       |    103 -
 .../tests/convert-cpp-comment-to-rust.rs           |     28 -
 tests/expectations/tests/convert-floats.rs         |     97 -
 tests/expectations/tests/core_ffi_c.rs             |     20 -
 tests/expectations/tests/cpp-empty-layout.rs       |     25 -
 tests/expectations/tests/crtp.rs                   |     86 -
 tests/expectations/tests/ctypes-prefix-path.rs     |     61 -
 tests/expectations/tests/dash_language.rs          |     12 -
 tests/expectations/tests/decl_extern_int_twice.rs  |     10 -
 tests/expectations/tests/decl_ptr_to_array.rs      |     10 -
 .../tests/default-enum-style-constified-module.rs  |     16 -
 .../tests/default-macro-constant-type-signed.rs    |     54 -
 .../tests/default-macro-constant-type-unsigned.rs  |     54 -
 .../tests/default-macro-constant-type.rs           |     54 -
 .../tests/default-template-parameter.rs            |     47 -
 tests/expectations/tests/deleted-function.rs       |     91 -
 .../tests/derive-bitfield-method-same-name.rs      |    215 -
 tests/expectations/tests/derive-clone.rs           |     48 -
 tests/expectations/tests/derive-clone_1_0.rs       |     54 -
 tests/expectations/tests/derive-custom.rs          |     26 -
 .../tests/derive-debug-bitfield-core.rs            |    194 -
 tests/expectations/tests/derive-debug-bitfield.rs  |    201 -
 .../tests/derive-debug-function-pointer.rs         |     80 -
 tests/expectations/tests/derive-debug-generic.rs   |     26 -
 .../expectations/tests/derive-debug-mangle-name.rs |    124 -
 .../derive-debug-opaque-template-instantiation.rs  |     51 -
 tests/expectations/tests/derive-debug-opaque.rs    |     83 -
 .../tests/derive-default-and-blocklist.rs          |     50 -
 tests/expectations/tests/derive-fn-ptr.rs          |    109 -
 .../tests/derive-hash-and-blocklist.rs             |     49 -
 .../expectations/tests/derive-hash-blocklisting.rs |     95 -
 .../derive-hash-struct-with-anon-struct-float.rs   |     76 -
 .../tests/derive-hash-struct-with-float-array.rs   |     34 -
 .../derive-hash-struct-with-incomplete-array.rs    |    116 -
 .../tests/derive-hash-struct-with-pointer.rs       |    168 -
 .../tests/derive-hash-template-def-float.rs        |     24 -
 .../tests/derive-hash-template-inst-float.rs       |    135 -
 .../tests/derive-partialeq-and-blocklist.rs        |     50 -
 .../tests/derive-partialeq-anonfield.rs            |     63 -
 tests/expectations/tests/derive-partialeq-base.rs  |     84 -
 .../tests/derive-partialeq-bitfield.rs             |    189 -
 tests/expectations/tests/derive-partialeq-core.rs  |     56 -
 .../expectations/tests/derive-partialeq-pointer.rs |    131 -
 tests/expectations/tests/derive-partialeq-union.rs |     59 -
 .../tests/derive-partialeq-union_1_0.rs            |    113 -
 tests/expectations/tests/disable-namespacing.rs    |      8 -
 .../tests/disable-nested-struct-naming.rs          |    269 -
 tests/expectations/tests/disable-untagged-union.rs |     83 -
 .../tests/divide-by-zero-in-struct-layout.rs       |    138 -
 tests/expectations/tests/do-not-derive-copy.rs     |     41 -
 tests/expectations/tests/doggo-or-null.rs          |     85 -
 .../tests/dupe-enum-variant-in-namespace.rs        |     28 -
 .../tests/duplicated-namespaces-definitions.rs     |    108 -
 tests/expectations/tests/duplicated-namespaces.rs  |     12 -
 .../tests/duplicated_constants_in_ns.rs            |     22 -
 .../tests/dynamic_loading_attributes.rs            |     56 -
 .../expectations/tests/dynamic_loading_required.rs |     61 -
 tests/expectations/tests/dynamic_loading_simple.rs |     70 -
 .../expectations/tests/dynamic_loading_template.rs |     49 -
 .../tests/dynamic_loading_with_allowlist.rs        |     68 -
 .../tests/dynamic_loading_with_blocklist.rs        |    113 -
 .../tests/dynamic_loading_with_class.rs            |    105 -
 tests/expectations/tests/elaborated.rs             |     12 -
 tests/expectations/tests/empty-enum.rs             |     34 -
 tests/expectations/tests/empty-union.rs            |     21 -
 .../tests/empty_template_param_name.rs             |     13 -
 tests/expectations/tests/enum-default-bitfield.rs  |    190 -
 tests/expectations/tests/enum-default-consts.rs    |     66 -
 tests/expectations/tests/enum-default-module.rs    |     74 -
 tests/expectations/tests/enum-default-rust.d       |      1 -
 tests/expectations/tests/enum-default-rust.rs      |     80 -
 tests/expectations/tests/enum-doc-bitfield.rs      |     64 -
 tests/expectations/tests/enum-doc-mod.rs           |     26 -
 tests/expectations/tests/enum-doc-rusty.rs         |     27 -
 tests/expectations/tests/enum-doc.rs               |     24 -
 tests/expectations/tests/enum-no-debug-rust.rs     |     80 -
 tests/expectations/tests/enum-translate-type.rs    |     15 -
 tests/expectations/tests/enum-undefault.rs         |     16 -
 tests/expectations/tests/enum-variant-replaces.rs  |     17 -
 tests/expectations/tests/enum.rs                   |     64 -
 tests/expectations/tests/enum_alias.rs             |     12 -
 .../expectations/tests/enum_and_vtable_mangling.rs |     59 -
 tests/expectations/tests/enum_dupe.rs              |     15 -
 tests/expectations/tests/enum_explicit_type.rs     |     61 -
 .../tests/enum_explicit_type_constants.rs          |     31 -
 tests/expectations/tests/enum_in_template.rs       |     15 -
 .../tests/enum_in_template_with_typedef.rs         |     21 -
 tests/expectations/tests/enum_negative.rs          |     13 -
 tests/expectations/tests/enum_packed.rs            |     25 -
 tests/expectations/tests/eval-value-dependent.rs   |     13 -
 .../tests/eval-variadic-template-parameter.rs      |     12 -
 tests/expectations/tests/explicit-padding.rs       |    124 -
 tests/expectations/tests/extern-const-struct.rs    |     50 -
 tests/expectations/tests/extern.rs                 |     10 -
 .../tests/fit-macro-constant-types-signed.rs       |     54 -
 .../expectations/tests/fit-macro-constant-types.rs |     54 -
 tests/expectations/tests/float128.rs               |      6 -
 .../tests/forward-declaration-autoptr.rs           |     85 -
 tests/expectations/tests/forward-enum-decl.rs      |     13 -
 .../tests/forward-inherit-struct-with-fields.rs    |     38 -
 tests/expectations/tests/forward-inherit-struct.rs |     26 -
 .../tests/forward_declared_complex_types.rs        |     87 -
 .../tests/forward_declared_complex_types_1_0.rs    |    112 -
 .../expectations/tests/forward_declared_opaque.rs  |     17 -
 .../expectations/tests/forward_declared_struct.rs  |     59 -
 tests/expectations/tests/func_proto.rs             |     10 -
 tests/expectations/tests/func_ptr.rs               |     15 -
 tests/expectations/tests/func_ptr_in_struct.rs     |     43 -
 tests/expectations/tests/func_ptr_return_type.rs   |     15 -
 tests/expectations/tests/func_return_must_use.rs   |     78 -
 tests/expectations/tests/func_with_array_arg.rs    |     10 -
 tests/expectations/tests/func_with_func_ptr_arg.rs |     26 -
 .../expectations/tests/function-typedef-stdcall.rs |     17 -
 tests/expectations/tests/gen-constructors-neg.rs   |     25 -
 tests/expectations/tests/gen-constructors.rs       |     37 -
 tests/expectations/tests/gen-destructors-neg.rs    |     33 -
 tests/expectations/tests/gen-destructors.rs        |     43 -
 tests/expectations/tests/generate-inline.rs        |     39 -
 tests/expectations/tests/i128.rs                   |     54 -
 tests/expectations/tests/in_class_typedef.rs       |     20 -
 .../expectations/tests/incomplete-array-padding.rs |    179 -
 tests/expectations/tests/infinite-macro.rs         |      9 -
 ...erit-from-template-instantiation-with-vtable.rs |    238 -
 tests/expectations/tests/inherit-namespaced.rs     |     26 -
 tests/expectations/tests/inherit_named.rs          |     27 -
 tests/expectations/tests/inherit_typedef.rs        |     44 -
 tests/expectations/tests/inline-function.rs        |      6 -
 tests/expectations/tests/inline_namespace.rs       |     48 -
 .../tests/inline_namespace_allowlist.rs            |     17 -
 .../tests/inline_namespace_conservative.rs         |     53 -
 .../tests/inline_namespace_no_ns_enabled.rs        |     53 -
 tests/expectations/tests/inner-typedef-gh422.rs    |     37 -
 tests/expectations/tests/inner_const.rs            |     41 -
 tests/expectations/tests/inner_template_self.rs    |     78 -
 tests/expectations/tests/int128_t.rs               |      6 -
 .../tests/issue-1025-unknown-enum-repr.rs          |     13 -
 tests/expectations/tests/issue-1034.rs             |    120 -
 tests/expectations/tests/issue-1040.rs             |      8 -
 .../tests/issue-1076-unnamed-bitfield-alignment.rs |    120 -
 .../tests/issue-1113-template-references.rs        |     47 -
 .../tests/issue-1118-using-forward-decl.rs         |    139 -
 .../tests/issue-1197-pure-virtual-stuff.rs         |     36 -
 .../tests/issue-1198-alias-rust-bitfield-enum.rs   |     83 -
 ...ssue-1198-alias-rust-const-mod-bitfield-enum.rs |     19 -
 .../tests/issue-1198-alias-rust-const-mod-enum.rs  |     19 -
 .../tests/issue-1198-alias-rust-enum.rs            |     25 -
 .../tests/issue-1216-variadic-member.rs            |     43 -
 tests/expectations/tests/issue-1238-fwd-no-copy.rs |     13 -
 tests/expectations/tests/issue-1281.rs             |     86 -
 tests/expectations/tests/issue-1285.rs             |     93 -
 tests/expectations/tests/issue-1291.rs             |    183 -
 .../tests/issue-1350-attribute-overloadable.rs     |     15 -
 .../tests/issue-1382-rust-primitive-types.rs       |    139 -
 tests/expectations/tests/issue-1435.rs             |     24 -
 tests/expectations/tests/issue-1443.rs             |    176 -
 tests/expectations/tests/issue-1454.rs             |     42 -
 tests/expectations/tests/issue-1464.rs             |      6 -
 .../expectations/tests/issue-1488-enum-new-type.rs |     49 -
 tests/expectations/tests/issue-1488-options.rs     |     27 -
 .../tests/issue-1488-template-alias-new-type.rs    |     10 -
 tests/expectations/tests/issue-1498.rs             |    170 -
 tests/expectations/tests/issue-1514.rs             |     42 -
 tests/expectations/tests/issue-1554.rs             |     16 -
 .../tests/issue-1599-opaque-typedef-to-enum.rs     |     11 -
 .../tests/issue-1676-macro-namespace-prefix.rs     |      6 -
 tests/expectations/tests/issue-1947.rs             |    349 -
 .../expectations/tests/issue-1977-larger-arrays.rs |     64 -
 tests/expectations/tests/issue-1995.rs             |     40 -
 tests/expectations/tests/issue-2019.rs             |     79 -
 .../issue-2239-template-dependent-bit-width.rs     |     19 -
 tests/expectations/tests/issue-358.rs              |     35 -
 tests/expectations/tests/issue-372.rs              |    144 -
 tests/expectations/tests/issue-410.rs              |     49 -
 tests/expectations/tests/issue-446.rs              |     35 -
 tests/expectations/tests/issue-447.rs              |     76 -
 tests/expectations/tests/issue-493.rs              |    176 -
 tests/expectations/tests/issue-493_1_0.rs          |    144 -
 tests/expectations/tests/issue-511.rs              |     19 -
 .../expectations/tests/issue-537-repr-packed-n.rs  |    161 -
 tests/expectations/tests/issue-537.rs              |    163 -
 .../tests/issue-544-stylo-creduce-2.rs             |     22 -
 .../expectations/tests/issue-544-stylo-creduce.rs  |     12 -
 ...template-params-causing-layout-test-failures.rs |     73 -
 .../tests/issue-573-layout-test-failures.rs        |     56 -
 .../issue-574-assertion-failure-in-codegen.rs      |     59 -
 .../issue-584-stylo-template-analysis-panic.rs     |    124 -
 .../issue-638-stylo-cannot-find-T-in-this-scope.rs |     38 -
 .../tests/issue-639-typedef-anon-field.rs          |    113 -
 tests/expectations/tests/issue-643-inner-struct.rs |    138 -
 .../issue-645-cannot-find-type-T-in-this-scope.rs  |     25 -
 .../tests/issue-648-derive-debug-with-padding.rs   |    116 -
 .../tests/issue-654-struct-fn-collision.rs         |     15 -
 .../tests/issue-662-cannot-find-T-in-this-scope.rs |     52 -
 tests/expectations/tests/issue-662-part-2.rs       |     39 -
 tests/expectations/tests/issue-674-1.rs            |     53 -
 tests/expectations/tests/issue-674-2.rs            |     98 -
 tests/expectations/tests/issue-674-3.rs            |     75 -
 .../tests/issue-677-nested-ns-specifier.rs         |     21 -
 .../tests/issue-691-template-parameter-virtual.rs  |     81 -
 .../expectations/tests/issue-710-must-use-type.rs  |     25 -
 .../tests/issue-739-pointer-wide-bitfield.rs       |    195 -
 .../tests/issue-801-opaque-sloppiness.rs           |     61 -
 ...sue-807-opaque-types-methods-being-generated.rs |    137 -
 tests/expectations/tests/issue-816.rs              |    860 -
 .../issue-820-unused-template-param-in-alias.rs    |      8 -
 ...sue-826-generating-methods-when-asked-not-to.rs |     25 -
 tests/expectations/tests/issue-833-1.rs            |     15 -
 tests/expectations/tests/issue-833-2.rs            |     14 -
 tests/expectations/tests/issue-833.rs              |     15 -
 tests/expectations/tests/issue-834.rs              |     25 -
 .../tests/issue-848-replacement-system-include.rs  |     31 -
 .../tests/issue-888-enum-var-decl-jump.rs          |     43 -
 .../issue-944-derive-copy-and-blocklisting.rs      |     49 -
 tests/expectations/tests/issue-946.rs              |     24 -
 tests/expectations/tests/issue_311.rs              |     48 -
 tests/expectations/tests/issue_315.rs              |      9 -
 tests/expectations/tests/jsval_layout_opaque.rs    |    514 -
 .../expectations/tests/jsval_layout_opaque_1_0.rs  |    548 -
 tests/expectations/tests/keywords.rs               |    227 -
 tests/expectations/tests/layout.rs                 |     28 -
 tests/expectations/tests/layout_align.rs           |    263 -
 tests/expectations/tests/layout_arp.rs             |    216 -
 tests/expectations/tests/layout_array.rs           |    408 -
 tests/expectations/tests/layout_array_too_long.rs  |    341 -
 tests/expectations/tests/layout_cmdline_token.rs   |    285 -
 tests/expectations/tests/layout_eth_conf.rs        |   2192 -
 tests/expectations/tests/layout_eth_conf_1_0.rs    |   2337 -
 tests/expectations/tests/layout_kni_mbuf.rs        |    209 -
 .../expectations/tests/layout_large_align_field.rs |    703 -
 tests/expectations/tests/layout_mbuf.rs            |   1204 -
 tests/expectations/tests/layout_mbuf_1_0.rs        |   1255 -
 .../tests/libclang-5/abi_variadic_function.rs      |     11 -
 tests/expectations/tests/libclang-5/auto.rs        |     35 -
 .../tests/libclang-5/call-conv-field.rs            |     59 -
 tests/expectations/tests/libclang-5/const_bool.rs  |     29 -
 .../tests/libclang-5/constant-evaluate.rs          |     25 -
 ...ror-E0600-cannot-apply-unary-negation-to-u32.rs |      9 -
 .../libclang-5/issue-769-bad-instantiation-test.rs |     67 -
 .../tests/libclang-5/mangling-win32.rs             |     52 -
 .../tests/libclang-5/objc_inheritance.rs           |    116 -
 .../expectations/tests/libclang-5/objc_template.rs |     64 -
 .../partial-specialization-and-inheritance.rs      |     39 -
 .../libclang-5/type_alias_template_specialized.rs  |     68 -
 .../tests/libclang-9/abi_variadic_function.rs      |     11 -
 tests/expectations/tests/libclang-9/auto.rs        |     35 -
 .../tests/libclang-9/call-conv-field.rs            |     59 -
 tests/expectations/tests/libclang-9/class.rs       |    691 -
 tests/expectations/tests/libclang-9/class_1_0.rs   |    742 -
 tests/expectations/tests/libclang-9/const_bool.rs  |     29 -
 .../tests/libclang-9/constant-evaluate.rs          |     25 -
 .../derive-hash-struct-with-incomplete-array.rs    |    171 -
 ...ror-E0600-cannot-apply-unary-negation-to-u32.rs |      9 -
 .../tests/libclang-9/incomplete-array-padding.rs   |    187 -
 .../tests/libclang-9/issue-643-inner-struct.rs     |    181 -
 .../libclang-9/issue-769-bad-instantiation-test.rs |     67 -
 .../expectations/tests/libclang-9/layout_align.rs  |    318 -
 .../tests/libclang-9/mangling-win32.rs             |     52 -
 .../tests/libclang-9/objc_inheritance.rs           |    116 -
 .../expectations/tests/libclang-9/objc_template.rs |     64 -
 .../partial-specialization-and-inheritance.rs      |     39 -
 .../libclang-9/type_alias_template_specialized.rs  |     68 -
 .../tests/libclang-9/zero-sized-array.rs           |    185 -
 .../libclang_version_specific_generated_tests.rs   |      4 -
 tests/expectations/tests/long_double.rs            |     34 -
 tests/expectations/tests/macro-expr-basic.rs       |     16 -
 .../tests/macro-expr-uncommon-token.rs             |     11 -
 tests/expectations/tests/macro-redef.rs            |     10 -
 tests/expectations/tests/macro_const.rs            |     14 -
 tests/expectations/tests/macro_const_1_0.rs        |     14 -
 tests/expectations/tests/maddness-is-avoidable.rs  |     17 -
 tests/expectations/tests/mangling-ios.rs           |     10 -
 tests/expectations/tests/mangling-linux32.rs       |     32 -
 tests/expectations/tests/mangling-linux64.rs       |     32 -
 tests/expectations/tests/mangling-macos.rs         |     32 -
 tests/expectations/tests/mangling-win64.rs         |     32 -
 tests/expectations/tests/merge-extern-blocks.rs    |     37 -
 tests/expectations/tests/method-mangling.rs        |     35 -
 tests/expectations/tests/module-allowlisted.rs     |     30 -
 tests/expectations/tests/msvc-no-usr.rs            |     33 -
 .../tests/multiple-inherit-empty-correct-layout.rs |     61 -
 tests/expectations/tests/mutable.rs                |    124 -
 tests/expectations/tests/namespace.rs              |    130 -
 .../expectations/tests/nested-template-typedef.rs  |     17 -
 tests/expectations/tests/nested.rs                 |    111 -
 tests/expectations/tests/nested_vtable.rs          |     99 -
 .../expectations/tests/nested_within_namespace.rs  |    115 -
 tests/expectations/tests/newtype-enum.rs           |     22 -
 tests/expectations/tests/newtype-global-enum.rs    |     14 -
 tests/expectations/tests/no-comments.rs            |     33 -
 tests/expectations/tests/no-derive-debug.rs        |     56 -
 tests/expectations/tests/no-derive-default.rs      |     47 -
 tests/expectations/tests/no-hash-allowlisted.rs    |     33 -
 tests/expectations/tests/no-hash-opaque.rs         |     26 -
 .../expectations/tests/no-partialeq-allowlisted.rs |     38 -
 tests/expectations/tests/no-partialeq-opaque.rs    |     26 -
 .../tests/no-recursive-allowlisting.rs             |     44 -
 tests/expectations/tests/no-std.rs                 |     59 -
 tests/expectations/tests/no_copy.rs                |     13 -
 tests/expectations/tests/no_copy_allowlisted.rs    |     33 -
 tests/expectations/tests/no_copy_opaque.rs         |     26 -
 tests/expectations/tests/no_debug.rs               |     13 -
 tests/expectations/tests/no_debug_allowlisted.rs   |     38 -
 .../tests/no_debug_bypass_impl_debug.rs            |     40 -
 tests/expectations/tests/no_debug_opaque.rs        |     26 -
 tests/expectations/tests/no_default.rs             |     27 -
 tests/expectations/tests/no_default_allowlisted.rs |     38 -
 .../tests/no_default_bypass_derive_default.rs      |     26 -
 tests/expectations/tests/no_default_opaque.rs      |     26 -
 tests/expectations/tests/no_size_t_is_usize.rs     |     56 -
 tests/expectations/tests/non-type-params.rs        |     68 -
 tests/expectations/tests/noreturn.rs               |     19 -
 tests/expectations/tests/nsBaseHashtable.rs        |     63 -
 tests/expectations/tests/nsStyleAutoArray.rs       |     43 -
 tests/expectations/tests/objc_allowlist.rs         |     58 -
 tests/expectations/tests/objc_blocklist.rs         |     42 -
 tests/expectations/tests/objc_category.rs          |     44 -
 tests/expectations/tests/objc_class.rs             |     38 -
 tests/expectations/tests/objc_class_method.rs      |     68 -
 tests/expectations/tests/objc_interface.rs         |     29 -
 tests/expectations/tests/objc_interface_type.rs    |     74 -
 tests/expectations/tests/objc_method.rs            |     82 -
 tests/expectations/tests/objc_method_clash.rs      |     41 -
 .../tests/objc_pointer_return_types.rs             |     58 -
 tests/expectations/tests/objc_property_fnptr.rs    |     57 -
 tests/expectations/tests/objc_protocol.rs          |     30 -
 .../tests/objc_protocol_inheritance.rs             |     66 -
 tests/expectations/tests/objc_sel_and_id.rs        |     20 -
 tests/expectations/tests/only_bitfields.rs         |    157 -
 .../tests/opaque-template-inst-member-2.rs         |     99 -
 .../tests/opaque-template-inst-member.rs           |    116 -
 .../opaque-template-instantiation-namespaced.rs    |    198 -
 .../tests/opaque-template-instantiation.rs         |    114 -
 tests/expectations/tests/opaque-tracing.rs         |     30 -
 tests/expectations/tests/opaque_in_struct.rs       |     60 -
 tests/expectations/tests/opaque_pointer.rs         |     97 -
 tests/expectations/tests/opaque_typedef.rs         |     15 -
 tests/expectations/tests/operator.rs               |     16 -
 tests/expectations/tests/ord-enum.rs               |     23 -
 tests/expectations/tests/overflowed_enum.rs        |     20 -
 tests/expectations/tests/overloading.rs            |     26 -
 tests/expectations/tests/packed-bitfield.rs        |    175 -
 tests/expectations/tests/packed-n-with-padding.rs  |     51 -
 tests/expectations/tests/packed-vtable.rs          |     40 -
 tests/expectations/tests/parm-union.rs             |     40 -
 .../tests/parsecb-anonymous-enum-variant-rename.rs |      9 -
 tests/expectations/tests/pointer-attr.rs           |     10 -
 .../tests/prepend-enum-constified-variant.rs       |     15 -
 tests/expectations/tests/prepend_enum_name.rs      |     10 -
 tests/expectations/tests/private.rs                |    149 -
 tests/expectations/tests/private_fields.rs         |    535 -
 tests/expectations/tests/public-dtor.rs            |     35 -
 .../tests/qualified-dependent-types.rs             |     17 -
 tests/expectations/tests/redeclaration.rs          |     10 -
 tests/expectations/tests/ref_argument_array.rs     |     49 -
 tests/expectations/tests/reparented_replacement.rs |     51 -
 tests/expectations/tests/replace_template_alias.rs |     26 -
 tests/expectations/tests/replace_use.rs            |     55 -
 tests/expectations/tests/replaces_double.rs        |     40 -
 tests/expectations/tests/repr-align.rs             |     74 -
 .../tests/resolved_type_def_function.rs            |     11 -
 .../same_struct_name_in_different_namespaces.rs    |     54 -
 .../tests/sentry-defined-multiple-times.rs         |    385 -
 tests/expectations/tests/short-enums.rs            |     22 -
 tests/expectations/tests/size_t_template.rs        |     33 -
 tests/expectations/tests/sorted-items.rs           |     82 -
 tests/expectations/tests/stdint_typedef.rs         |     41 -
 .../struct_containing_forward_declared_struct.rs   |     68 -
 tests/expectations/tests/struct_typedef.rs         |     95 -
 tests/expectations/tests/struct_typedef_ns.rs      |    100 -
 .../expectations/tests/struct_with_anon_struct.rs  |     75 -
 .../tests/struct_with_anon_struct_array.rs         |    123 -
 .../tests/struct_with_anon_struct_pointer.rs       |     84 -
 tests/expectations/tests/struct_with_anon_union.rs |     93 -
 .../tests/struct_with_anon_union_1_0.rs            |    129 -
 .../tests/struct_with_anon_unnamed_struct.rs       |     67 -
 .../tests/struct_with_anon_unnamed_union.rs        |     85 -
 .../tests/struct_with_anon_unnamed_union_1_0.rs    |    121 -
 tests/expectations/tests/struct_with_bitfields.rs  |    252 -
 .../expectations/tests/struct_with_derive_debug.rs |    149 -
 .../expectations/tests/struct_with_large_array.rs  |     63 -
 tests/expectations/tests/struct_with_nesting.rs    |    191 -
 .../expectations/tests/struct_with_nesting_1_0.rs  |    237 -
 tests/expectations/tests/struct_with_packing.rs    |     39 -
 tests/expectations/tests/struct_with_struct.rs     |     75 -
 .../tests/struct_with_typedef_template_arg.rs      |     14 -
 tests/expectations/tests/template-fun-ty.rs        |     27 -
 tests/expectations/tests/template-param-usage-0.rs |     22 -
 tests/expectations/tests/template-param-usage-1.rs |     12 -
 .../expectations/tests/template-param-usage-10.rs  |     42 -
 .../expectations/tests/template-param-usage-11.rs  |     12 -
 .../expectations/tests/template-param-usage-12.rs  |     38 -
 .../expectations/tests/template-param-usage-13.rs  |     28 -
 .../expectations/tests/template-param-usage-14.rs  |     27 -
 .../expectations/tests/template-param-usage-15.rs  |     37 -
 tests/expectations/tests/template-param-usage-2.rs |     37 -
 tests/expectations/tests/template-param-usage-3.rs |     41 -
 tests/expectations/tests/template-param-usage-4.rs |     27 -
 tests/expectations/tests/template-param-usage-5.rs |     23 -
 tests/expectations/tests/template-param-usage-6.rs |     13 -
 tests/expectations/tests/template-param-usage-7.rs |     25 -
 tests/expectations/tests/template-param-usage-8.rs |     26 -
 tests/expectations/tests/template-param-usage-9.rs |     31 -
 tests/expectations/tests/template-with-var.rs      |     12 -
 tests/expectations/tests/template.rs               |    995 -
 tests/expectations/tests/template_alias.rs         |     23 -
 tests/expectations/tests/template_alias_basic.rs   |      8 -
 .../expectations/tests/template_alias_namespace.rs |     37 -
 tests/expectations/tests/template_fun.rs           |      6 -
 .../template_instantiation_with_fn_local_type.rs   |     96 -
 .../tests/template_partial_specification.rs        |      6 -
 .../tests/template_typedef_transitive_param.rs     |     28 -
 tests/expectations/tests/template_typedefs.rs      |     22 -
 tests/expectations/tests/templateref_opaque.rs     |     19 -
 tests/expectations/tests/templatized-bitfield.rs   |     15 -
 .../tests/test_mixed_header_and_header_contents.rs |    114 -
 .../tests/test_multiple_header_calls_in_builder.rs |    108 -
 tests/expectations/tests/timex.rs                  |    322 -
 tests/expectations/tests/transform-op.rs           |    260 -
 .../type-referenced-by-allowlisted-function.rs     |     41 -
 tests/expectations/tests/type_alias_empty.rs       |      8 -
 .../type_alias_partial_template_especialization.rs |     23 -
 .../tests/typedefd-array-as-function-arg.rs        |     11 -
 tests/expectations/tests/typeref.rs                |    179 -
 tests/expectations/tests/typeref_1_0.rs            |    219 -
 tests/expectations/tests/underscore.rs             |     34 -
 tests/expectations/tests/union-align.rs            |     79 -
 tests/expectations/tests/union-in-ns.rs            |     52 -
 tests/expectations/tests/union-in-ns_1_0.rs        |     95 -
 tests/expectations/tests/union_bitfield.rs         |    223 -
 tests/expectations/tests/union_bitfield_1_0.rs     |    298 -
 tests/expectations/tests/union_dtor.rs             |     67 -
 tests/expectations/tests/union_dtor_1_0.rs         |    103 -
 tests/expectations/tests/union_fields.rs           |     71 -
 tests/expectations/tests/union_fields_1_0.rs       |    111 -
 tests/expectations/tests/union_template.rs         |     64 -
 tests/expectations/tests/union_template_1_0.rs     |     78 -
 tests/expectations/tests/union_with_anon_struct.rs |     84 -
 .../tests/union_with_anon_struct_1_0.rs            |    129 -
 .../tests/union_with_anon_struct_bitfield.rs       |    194 -
 .../tests/union_with_anon_struct_bitfield_1_0.rs   |    239 -
 tests/expectations/tests/union_with_anon_union.rs  |     93 -
 .../tests/union_with_anon_union_1_0.rs             |    130 -
 .../tests/union_with_anon_unnamed_struct.rs        |    112 -
 .../tests/union_with_anon_unnamed_struct_1_0.rs    |    157 -
 .../tests/union_with_anon_unnamed_union.rs         |     94 -
 .../tests/union_with_anon_unnamed_union_1_0.rs     |    131 -
 tests/expectations/tests/union_with_big_member.rs  |    160 -
 .../tests/union_with_big_member_1_0.rs             |    212 -
 tests/expectations/tests/union_with_nesting.rs     |    173 -
 tests/expectations/tests/union_with_nesting_1_0.rs |    203 -
 .../tests/union_with_non_copy_member.rs            |    239 -
 tests/expectations/tests/unknown_attr.rs           |     57 -
 tests/expectations/tests/unsorted-items.rs         |     82 -
 tests/expectations/tests/use-core.rs               |    112 -
 tests/expectations/tests/use-core_1_0.rs           |    157 -
 tests/expectations/tests/using.rs                  |     25 -
 tests/expectations/tests/var-tracing.rs            |     72 -
 tests/expectations/tests/variadic-method.rs        |     33 -
 .../tests/variadic_template_function.rs            |     12 -
 tests/expectations/tests/vector.rs                 |     45 -
 tests/expectations/tests/virtual_dtor.rs           |     40 -
 tests/expectations/tests/virtual_inheritance.rs    |    138 -
 tests/expectations/tests/virtual_interface.rs      |    128 -
 tests/expectations/tests/virtual_overloaded.rs     |     55 -
 tests/expectations/tests/vtable_recursive_sig.rs   |     69 -
 .../expectations/tests/wasm-constructor-returns.rs |     40 -
 tests/expectations/tests/wasm-import-module.rs     |     11 -
 tests/expectations/tests/weird_bitfields.rs        |    440 -
 tests/expectations/tests/what_is_going_on.rs       |     43 -
 tests/expectations/tests/win32-thiscall_1_0.rs     |     30 -
 tests/expectations/tests/win32-thiscall_nightly.rs |     51 -
 tests/expectations/tests/win32-vectorcall-1_0.rs   |      6 -
 .../expectations/tests/win32-vectorcall-nightly.rs |     16 -
 .../tests/with_array_pointers_arguments.rs         |     24 -
 .../tests/without_array_pointers_arguments.rs      |     25 -
 tests/expectations/tests/zero-size-array-align.rs  |     90 -
 tests/expectations/tests/zero-sized-array.rs       |    159 -
 tests/headers/16-byte-alignment.h                  |     34 -
 tests/headers/16-byte-alignment_1_0.h              |     34 -
 tests/headers/381-decltype-alias.hpp               |      7 -
 tests/headers/abi_variadic_function.hpp            |      4 -
 tests/headers/accessors.hpp                        |     46 -
 tests/headers/allowlist-file.hpp                   |     21 -
 tests/headers/allowlist-namespaces-basic.hpp       |     10 -
 tests/headers/allowlist-namespaces.hpp             |     10 -
 tests/headers/allowlist_basic.hpp                  |     16 -
 tests/headers/allowlist_fix.hpp                    |      4 -
 tests/headers/allowlist_vars.h                     |      4 -
 tests/headers/allowlist_warnings.h                 |      2 -
 .../allowlisted-item-references-no-hash.hpp        |      7 -
 .../allowlisted-item-references-no-partialeq.hpp   |      7 -
 tests/headers/allowlisted/file.hpp                 |     22 -
 .../allowlisted_item_references_no_copy.hpp        |      7 -
 tests/headers/annotation_hide.hpp                  |     16 -
 tests/headers/anon-fields-prefix.h                 |     15 -
 tests/headers/anon_enum.hpp                        |     11 -
 tests/headers/anon_enum_allowlist.h                |      6 -
 tests/headers/anon_enum_trait.hpp                  |     23 -
 tests/headers/anon_struct_in_union.h               |      8 -
 tests/headers/anon_struct_in_union_1_0.h           |      9 -
 tests/headers/anon_union.hpp                       |     21 -
 tests/headers/anon_union_1_0.hpp                   |     22 -
 tests/headers/anonymous-template-types.hpp         |     24 -
 tests/headers/arg_keyword.hpp                      |      3 -
 tests/headers/array-of-zero-sized-types.hpp        |     12 -
 tests/headers/attribute_warn_unused_result.hpp     |     10 -
 ...e_warn_unused_result_no_attribute_detection.hpp |     10 -
 .../attribute_warn_unused_result_pre_1_27.hpp      |      8 -
 tests/headers/auto.hpp                             |     19 -
 .../bad-namespace-parenthood-inheritance.hpp       |     15 -
 tests/headers/base-to-derived.hpp                  |     19 -
 tests/headers/bindgen-union-inside-namespace.hpp   |      8 -
 tests/headers/bitfield-32bit-overflow.h            |     36 -
 tests/headers/bitfield-enum-basic.hpp              |     27 -
 tests/headers/bitfield-enum-repr-c.hpp             |      8 -
 tests/headers/bitfield-enum-repr-transparent.hpp   |      8 -
 tests/headers/bitfield-large.hpp                   |      9 -
 tests/headers/bitfield-linux-32.hpp                |      9 -
 tests/headers/bitfield-method-same-name.hpp        |      6 -
 tests/headers/bitfield_align.h                     |     49 -
 tests/headers/bitfield_align_2.h                   |     12 -
 tests/headers/bitfield_large_overflow.hpp          |      3 -
 tests/headers/bitfield_method_mangling.h           |      5 -
 tests/headers/bitfield_pragma_packed.h             |      9 -
 tests/headers/block_return_type.h                  |      4 -
 tests/headers/blocklist-and-impl-debug.hpp         |     10 -
 tests/headers/blocklist-file.hpp                   |     18 -
 tests/headers/blocklist-function.hpp               |     16 -
 tests/headers/blocklist-item.hpp                   |     21 -
 tests/headers/blocklisted/fake-stdint.h            |      7 -
 tests/headers/blocklisted/file.hpp                 |     26 -
 tests/headers/blocks-signature.hpp                 |      4 -
 tests/headers/blocks.hpp                           |     25 -
 tests/headers/bug-1529681.hpp                      |      8 -
 tests/headers/builtin-template.hpp                 |      6 -
 tests/headers/c-empty-layout.h                     |      1 -
 tests/headers/c_naming.h                           |     19 -
 tests/headers/call-conv-field.h                    |     13 -
 tests/headers/call-conv-typedef.h                  |      5 -
 tests/headers/canonical-types.hpp                  |     51 -
 .../headers/canonical_path_without_namespacing.hpp |      7 -
 tests/headers/char.h                               |     21 -
 tests/headers/class.hpp                            |     74 -
 tests/headers/class_1_0.hpp                        |     76 -
 tests/headers/class_nested.hpp                     |     37 -
 tests/headers/class_no_members.hpp                 |     17 -
 tests/headers/class_static.hpp                     |      8 -
 tests/headers/class_static_const.hpp               |      9 -
 tests/headers/class_use_as.hpp                     |     16 -
 tests/headers/class_with_dtor.hpp                  |     14 -
 tests/headers/class_with_inner_struct.hpp          |     44 -
 tests/headers/class_with_inner_struct_1_0.hpp      |     44 -
 tests/headers/class_with_typedef.hpp               |     23 -
 tests/headers/comment-indent.hpp                   |     47 -
 tests/headers/complex.h                            |     17 -
 tests/headers/complex_global.h                     |      4 -
 tests/headers/const-const-mut-ptr.h                |      3 -
 tests/headers/const_array.h                        |      2 -
 tests/headers/const_array_fn_arg.h                 |      1 -
 tests/headers/const_bool.hpp                       |      9 -
 tests/headers/const_enum_unnamed.hpp               |     10 -
 tests/headers/const_multidim_array_fn_arg.h        |      1 -
 tests/headers/const_ptr.hpp                        |      3 -
 tests/headers/const_resolved_ty.h                  |      3 -
 tests/headers/const_tparam.hpp                     |      5 -
 tests/headers/constant-evaluate.h                  |     21 -
 tests/headers/constant-non-specialized-tp.hpp      |     15 -
 tests/headers/constified-enum-module-overflow.hpp  |      8 -
 tests/headers/constify-all-enums.h                 |     10 -
 tests/headers/constify-enum.h                      |     14 -
 tests/headers/constify-module-enums-basic.h        |     17 -
 tests/headers/constify-module-enums-namespace.hpp  |     17 -
 tests/headers/constify-module-enums-shadow-name.h  |     12 -
 .../headers/constify-module-enums-simple-alias.hpp |     21 -
 .../constify-module-enums-simple-nonamespace.hpp   |     12 -
 tests/headers/constify-module-enums-types.hpp      |     78 -
 tests/headers/constructor-tp.hpp                   |     26 -
 tests/headers/constructors.hpp                     |     13 -
 tests/headers/constructors_1_33.hpp                |     16 -
 tests/headers/contains-vs-inherits-zero-sized.hpp  |     21 -
 tests/headers/convert-cpp-comment-to-rust.hpp      |     14 -
 tests/headers/convert-floats.h                     |      9 -
 tests/headers/core_ffi_c.h                         |     14 -
 tests/headers/cpp-empty-layout.hpp                 |      1 -
 tests/headers/crtp.hpp                             |     12 -
 tests/headers/ctypes-prefix-path.h                 |      5 -
 tests/headers/dash_language.h                      |      6 -
 tests/headers/decl_extern_int_twice.h              |      2 -
 tests/headers/decl_ptr_to_array.h                  |      1 -
 .../headers/default-enum-style-constified-module.h |      4 -
 tests/headers/default-macro-constant-type-signed.h |      3 -
 .../headers/default-macro-constant-type-unsigned.h |      3 -
 tests/headers/default-macro-constant-type.h        |     52 -
 tests/headers/default-template-parameter.hpp       |      7 -
 tests/headers/deleted-function.hpp                 |     35 -
 tests/headers/derive-bitfield-method-same-name.hpp |     13 -
 tests/headers/derive-clone.h                       |      7 -
 tests/headers/derive-clone_1_0.h                   |      7 -
 tests/headers/derive-custom.h                      |     28 -
 tests/headers/derive-debug-bitfield-core.hpp       |      7 -
 tests/headers/derive-debug-bitfield.hpp            |      7 -
 tests/headers/derive-debug-function-pointer.hpp    |      7 -
 tests/headers/derive-debug-generic.hpp             |      6 -
 tests/headers/derive-debug-mangle-name.h           |     14 -
 .../derive-debug-opaque-template-instantiation.hpp |     12 -
 tests/headers/derive-debug-opaque.hpp              |     10 -
 tests/headers/derive-default-and-blocklist.hpp     |     14 -
 tests/headers/derive-fn-ptr.h                      |     18 -
 tests/headers/derive-hash-and-blocklist.hpp        |     10 -
 tests/headers/derive-hash-blocklisting.hpp         |     17 -
 .../derive-hash-struct-with-anon-struct-float.h    |      9 -
 .../headers/derive-hash-struct-with-float-array.h  |      6 -
 .../derive-hash-struct-with-incomplete-array.h     |     17 -
 tests/headers/derive-hash-struct-with-pointer.h    |     18 -
 tests/headers/derive-hash-template-def-float.hpp   |      8 -
 tests/headers/derive-hash-template-inst-float.hpp  |     17 -
 tests/headers/derive-partialeq-and-blocklist.hpp   |     11 -
 tests/headers/derive-partialeq-anonfield.h         |      5 -
 tests/headers/derive-partialeq-base.hpp            |      8 -
 tests/headers/derive-partialeq-bitfield.hpp        |      7 -
 tests/headers/derive-partialeq-core.h              |      5 -
 tests/headers/derive-partialeq-pointer.hpp         |     12 -
 tests/headers/derive-partialeq-union.hpp           |      7 -
 tests/headers/derive-partialeq-union_1_0.hpp       |      7 -
 tests/headers/disable-namespacing.hpp              |      9 -
 tests/headers/disable-nested-struct-naming.h       |     24 -
 tests/headers/disable-untagged-union.hpp           |      6 -
 tests/headers/divide-by-zero-in-struct-layout.h    |     22 -
 tests/headers/do-not-derive-copy.hpp               |      5 -
 tests/headers/doggo-or-null.hpp                    |     20 -
 tests/headers/dupe-enum-variant-in-namespace.h     |     10 -
 .../headers/duplicated-namespaces-definitions.hpp  |     18 -
 tests/headers/duplicated-namespaces.hpp            |      4 -
 tests/headers/duplicated_constants_in_ns.hpp       |      7 -
 tests/headers/dynamic_loading_attributes.h         |     11 -
 tests/headers/dynamic_loading_required.h           |      5 -
 tests/headers/dynamic_loading_simple.h             |      5 -
 tests/headers/dynamic_loading_template.hpp         |     10 -
 tests/headers/dynamic_loading_with_allowlist.hpp   |     16 -
 tests/headers/dynamic_loading_with_blocklist.hpp   |     15 -
 tests/headers/dynamic_loading_with_class.hpp       |     15 -
 tests/headers/elaborated.hpp                       |      5 -
 tests/headers/empty-enum.h                         |     15 -
 tests/headers/empty-union.hpp                      |      5 -
 tests/headers/empty_template_param_name.hpp        |      7 -
 tests/headers/enum-default-bitfield.h              |      3 -
 tests/headers/enum-default-consts.h                |      3 -
 tests/headers/enum-default-module.h                |      3 -
 tests/headers/enum-default-rust.h                  |      3 -
 tests/headers/enum-doc-bitfield.h                  |      3 -
 tests/headers/enum-doc-mod.h                       |      3 -
 tests/headers/enum-doc-rusty.h                     |      3 -
 tests/headers/enum-doc.h                           |     18 -
 tests/headers/enum-no-debug-rust.h                 |      3 -
 tests/headers/enum-translate-type.hpp              |     14 -
 tests/headers/enum-undefault.h                     |     11 -
 tests/headers/enum-variant-replaces.h              |     34 -
 tests/headers/enum.h                               |     31 -
 tests/headers/enum_alias.hpp                       |      7 -
 tests/headers/enum_and_vtable_mangling.hpp         |     12 -
 tests/headers/enum_dupe.h                          |      6 -
 tests/headers/enum_explicit_type.hpp               |     42 -
 tests/headers/enum_explicit_type_constants.hpp     |      5 -
 tests/headers/enum_in_template.hpp                 |     10 -
 tests/headers/enum_in_template_with_typedef.hpp    |     16 -
 tests/headers/enum_negative.h                      |      6 -
 tests/headers/enum_packed.h                        |     16 -
 ...rror-E0600-cannot-apply-unary-negation-to-u32.h |      5 -
 tests/headers/eval-value-dependent.hpp             |      6 -
 tests/headers/eval-variadic-template-parameter.hpp |      8 -
 tests/headers/explicit-padding.h                   |     17 -
 tests/headers/extern-const-struct.h                |      7 -
 tests/headers/extern.hpp                           |      3 -
 tests/headers/fit-macro-constant-types-signed.h    |      2 -
 tests/headers/fit-macro-constant-types.h           |      4 -
 tests/headers/float128.hpp                         |     13 -
 tests/headers/forward-declaration-autoptr.hpp      |     10 -
 tests/headers/forward-enum-decl.hpp                |      8 -
 .../headers/forward-inherit-struct-with-fields.hpp |      8 -
 tests/headers/forward-inherit-struct.hpp           |      5 -
 tests/headers/forward_declared_complex_types.hpp   |     16 -
 .../headers/forward_declared_complex_types_1_0.hpp |     18 -
 tests/headers/forward_declared_opaque.h            |      4 -
 tests/headers/forward_declared_struct.h            |     11 -
 tests/headers/func_proto.h                         |      1 -
 tests/headers/func_ptr.h                           |      3 -
 tests/headers/func_ptr_in_struct.h                 |      7 -
 tests/headers/func_ptr_return_type.h               |      1 -
 tests/headers/func_return_must_use.h               |     36 -
 tests/headers/func_with_array_arg.h                |      1 -
 tests/headers/func_with_func_ptr_arg.h             |      3 -
 tests/headers/function-typedef-stdcall.h           |     12 -
 tests/headers/gen-constructors-neg.hpp             |      6 -
 tests/headers/gen-constructors.hpp                 |      6 -
 tests/headers/gen-destructors-neg.hpp              |      9 -
 tests/headers/gen-destructors.hpp                  |      7 -
 tests/headers/generate-inline.hpp                  |     12 -
 tests/headers/i128.h                               |      6 -
 tests/headers/in_class_typedef.hpp                 |     10 -
 tests/headers/incomplete-array-padding.h           |      4 -
 tests/headers/infinite-macro.h                     |      2 -
 ...rit-from-template-instantiation-with-vtable.hpp |     37 -
 tests/headers/inherit-namespaced.hpp               |      4 -
 tests/headers/inherit_named.hpp                    |      5 -
 tests/headers/inherit_typedef.hpp                  |      5 -
 tests/headers/inline-function.h                    |      6 -
 tests/headers/inline_namespace.hpp                 |     11 -
 tests/headers/inline_namespace_allowlist.hpp       |      7 -
 tests/headers/inline_namespace_conservative.hpp    |     12 -
 tests/headers/inline_namespace_no_ns_enabled.hpp   |     18 -
 tests/headers/inner-typedef-gh422.hpp              |     11 -
 tests/headers/inner_const.hpp                      |      6 -
 tests/headers/inner_template_self.hpp              |     10 -
 tests/headers/int128_t.h                           |      7 -
 tests/headers/issue-1025-unknown-enum-repr.hpp     |      4 -
 tests/headers/issue-1034.h                         |      4 -
 tests/headers/issue-1040.h                         |      1 -
 .../issue-1076-unnamed-bitfield-alignment.h        |      4 -
 tests/headers/issue-1113-template-references.hpp   |     16 -
 tests/headers/issue-1118-using-forward-decl.hpp    |     10 -
 tests/headers/issue-1197-pure-virtual-stuff.hpp    |      6 -
 .../headers/issue-1198-alias-rust-bitfield-enum.h  |     13 -
 ...issue-1198-alias-rust-const-mod-bitfield-enum.h |     13 -
 .../headers/issue-1198-alias-rust-const-mod-enum.h |     13 -
 tests/headers/issue-1198-alias-rust-enum.h         |     14 -
 tests/headers/issue-1216-variadic-member.h         |      4 -
 tests/headers/issue-1238-fwd-no-copy.h             |      3 -
 tests/headers/issue-1281.h                         |     11 -
 tests/headers/issue-1285.h                         |      8 -
 tests/headers/issue-1291.hpp                       |     21 -
 tests/headers/issue-1350-attribute-overloadable.h  |      2 -
 tests/headers/issue-1382-rust-primitive-types.h    |     34 -
 tests/headers/issue-1435.hpp                       |      7 -
 tests/headers/issue-1443.hpp                       |     21 -
 tests/headers/issue-1454.h                         |     10 -
 tests/headers/issue-1464.hpp                       |      7 -
 tests/headers/issue-1488-enum-new-type.h           |     29 -
 tests/headers/issue-1488-options.h                 |      5 -
 .../headers/issue-1488-template-alias-new-type.hpp |      4 -
 tests/headers/issue-1498.h                         |     17 -
 tests/headers/issue-1514.hpp                       |      9 -
 tests/headers/issue-1554.h                         |      6 -
 tests/headers/issue-1599-opaque-typedef-to-enum.h  |      3 -
 .../headers/issue-1676-macro-namespace-prefix.hpp  |      2 -
 tests/headers/issue-1947.h                         |      9 -
 tests/headers/issue-1977-larger-arrays.hpp         |      9 -
 tests/headers/issue-1995.h                         |     12 -
 tests/headers/issue-2019.hpp                       |     10 -
 .../issue-2239-template-dependent-bit-width.hpp    |     10 -
 tests/headers/issue-358.hpp                        |      8 -
 tests/headers/issue-372.hpp                        |     16 -
 tests/headers/issue-410.hpp                        |     12 -
 tests/headers/issue-446.hpp                        |     11 -
 tests/headers/issue-447.hpp                        |     27 -
 tests/headers/issue-493.hpp                        |     48 -
 tests/headers/issue-493_1_0.hpp                    |     49 -
 tests/headers/issue-511.h                          |      4 -
 tests/headers/issue-537-repr-packed-n.h            |     34 -
 tests/headers/issue-537.h                          |     35 -
 tests/headers/issue-544-stylo-creduce-2.hpp        |      8 -
 tests/headers/issue-544-stylo-creduce.hpp          |      5 -
 ...emplate-params-causing-layout-test-failures.hpp |     27 -
 tests/headers/issue-573-layout-test-failures.hpp   |     12 -
 .../issue-574-assertion-failure-in-codegen.hpp     |      6 -
 .../issue-584-stylo-template-analysis-panic.hpp    |     13 -
 ...issue-638-stylo-cannot-find-T-in-this-scope.hpp |     12 -
 tests/headers/issue-639-typedef-anon-field.hpp     |     15 -
 tests/headers/issue-643-inner-struct.h             |     13 -
 .../issue-645-cannot-find-type-T-in-this-scope.hpp |      9 -
 .../headers/issue-648-derive-debug-with-padding.h  |     21 -
 tests/headers/issue-654-struct-fn-collision.h      |      2 -
 .../issue-662-cannot-find-T-in-this-scope.hpp      |      7 -
 tests/headers/issue-662-part-2.hpp                 |     11 -
 tests/headers/issue-674-1.hpp                      |      8 -
 tests/headers/issue-674-2.hpp                      |     15 -
 tests/headers/issue-674-3.hpp                      |     11 -
 tests/headers/issue-677-nested-ns-specifier.hpp    |      5 -
 .../issue-691-template-parameter-virtual.hpp       |     12 -
 tests/headers/issue-710-must-use-type.h            |      8 -
 tests/headers/issue-739-pointer-wide-bitfield.h    |      9 -
 tests/headers/issue-769-bad-instantiation-test.hpp |     11 -
 tests/headers/issue-801-opaque-sloppiness.hpp      |     11 -
 ...ue-807-opaque-types-methods-being-generated.hpp |     36 -
 tests/headers/issue-816.h                          |     49 -
 .../issue-820-unused-template-param-in-alias.hpp   |      5 -
 ...ue-826-generating-methods-when-asked-not-to.hpp |      5 -
 tests/headers/issue-833-1.hpp                      |      8 -
 tests/headers/issue-833-2.hpp                      |      6 -
 tests/headers/issue-833.hpp                        |      8 -
 tests/headers/issue-834.hpp                        |      6 -
 .../issue-848-replacement-system-include.hpp       |      7 -
 tests/headers/issue-848/an-include.h               |     17 -
 tests/headers/issue-888-enum-var-decl-jump.hpp     |     11 -
 .../issue-944-derive-copy-and-blocklisting.hpp     |     10 -
 tests/headers/issue-946.h                          |      5 -
 tests/headers/issue_311.hpp                        |      5 -
 tests/headers/issue_315.hpp                        |      2 -
 tests/headers/jsval_layout_opaque.hpp              |    425 -
 tests/headers/jsval_layout_opaque_1_0.hpp          |    425 -
 tests/headers/keywords.h                           |     56 -
 tests/headers/layout.h                             |     10 -
 tests/headers/layout_align.h                       |     20 -
 tests/headers/layout_arp.h                         |     52 -
 tests/headers/layout_array.h                       |    110 -
 tests/headers/layout_array_too_long.h              |     61 -
 tests/headers/layout_cmdline_token.h               |     64 -
 tests/headers/layout_eth_conf.h                    |    428 -
 tests/headers/layout_eth_conf_1_0.h                |    429 -
 tests/headers/layout_kni_mbuf.h                    |     33 -
 tests/headers/layout_large_align_field.h           |     99 -
 tests/headers/layout_mbuf.h                        |    188 -
 tests/headers/layout_mbuf_1_0.h                    |    189 -
 tests/headers/long_double.h                        |      5 -
 tests/headers/macro-expr-basic.h                   |     14 -
 tests/headers/macro-expr-uncommon-token.h          |      7 -
 tests/headers/macro-redef.h                        |      5 -
 tests/headers/macro_const.h                        |      8 -
 tests/headers/macro_const_1_0.h                    |     10 -
 tests/headers/maddness-is-avoidable.hpp            |      9 -
 tests/headers/mangling-ios.h                       |      3 -
 tests/headers/mangling-linux32.hpp                 |      7 -
 tests/headers/mangling-linux64.hpp                 |      7 -
 tests/headers/mangling-macos.hpp                   |      7 -
 tests/headers/mangling-win32.hpp                   |     18 -
 tests/headers/mangling-win64.hpp                   |      7 -
 tests/headers/merge-extern-blocks.h                |      6 -
 tests/headers/method-mangling.hpp                  |      5 -
 tests/headers/module-allowlisted.hpp               |      2 -
 tests/headers/msvc-no-usr.hpp                      |      8 -
 .../multiple-inherit-empty-correct-layout.hpp      |      3 -
 tests/headers/mutable.hpp                          |     14 -
 tests/headers/namespace.hpp                        |     51 -
 tests/headers/namespace/nsbegin.h                  |      1 -
 tests/headers/namespace/nsend.h                    |      1 -
 tests/headers/nested-template-typedef.hpp          |      8 -
 tests/headers/nested.hpp                           |     15 -
 tests/headers/nested_vtable.hpp                    |      8 -
 tests/headers/nested_within_namespace.hpp          |     15 -
 tests/headers/newtype-enum.hpp                     |      8 -
 tests/headers/newtype-global-enum.hpp              |      8 -
 tests/headers/no-comments.h                        |      5 -
 tests/headers/no-derive-debug.h                    |     15 -
 tests/headers/no-derive-default.h                  |     15 -
 tests/headers/no-hash-allowlisted.hpp              |      5 -
 tests/headers/no-hash-opaque.hpp                   |      5 -
 tests/headers/no-partialeq-allowlisted.hpp         |      5 -
 tests/headers/no-partialeq-opaque.hpp              |      5 -
 tests/headers/no-recursive-allowlisting.h          |      7 -
 tests/headers/no-std.h                             |      5 -
 tests/headers/no_copy.hpp                          |      6 -
 tests/headers/no_copy_allowlisted.hpp              |      5 -
 tests/headers/no_copy_opaque.hpp                   |      5 -
 tests/headers/no_debug.hpp                         |      6 -
 tests/headers/no_debug_allowlisted.hpp             |      5 -
 tests/headers/no_debug_bypass_impl_debug.hpp       |     11 -
 tests/headers/no_debug_opaque.hpp                  |      5 -
 tests/headers/no_default.hpp                       |     11 -
 tests/headers/no_default_allowlisted.hpp           |      5 -
 tests/headers/no_default_bypass_derive_default.hpp |     11 -
 tests/headers/no_default_opaque.hpp                |      5 -
 tests/headers/no_size_t_is_usize.h                 |     10 -
 tests/headers/non-type-params.hpp                  |     17 -
 tests/headers/noreturn.hpp                         |      4 -
 tests/headers/nsBaseHashtable.hpp                  |     48 -
 tests/headers/nsStyleAutoArray.hpp                 |     58 -
 tests/headers/objc_allowlist.h                     |     24 -
 tests/headers/objc_blocklist.h                     |      9 -
 tests/headers/objc_category.h                      |     10 -
 tests/headers/objc_class.h                         |     10 -
 tests/headers/objc_class_method.h                  |     11 -
 tests/headers/objc_inheritance.h                   |     11 -
 tests/headers/objc_interface.h                     |      8 -
 tests/headers/objc_interface_type.h                |     13 -
 tests/headers/objc_method.h                        |     15 -
 tests/headers/objc_method_clash.h                  |      7 -
 tests/headers/objc_pointer_return_types.h          |     10 -
 tests/headers/objc_property_fnptr.h                |      6 -
 tests/headers/objc_protocol.h                      |      8 -
 tests/headers/objc_protocol_inheritance.h          |     11 -
 tests/headers/objc_sel_and_id.h                    |      7 -
 tests/headers/objc_template.h                      |     10 -
 tests/headers/only_bitfields.hpp                   |      4 -
 tests/headers/opaque-template-inst-member-2.hpp    |     20 -
 tests/headers/opaque-template-inst-member.hpp      |     20 -
 .../opaque-template-instantiation-namespaced.hpp   |     29 -
 tests/headers/opaque-template-instantiation.hpp    |     17 -
 tests/headers/opaque-tracing.hpp                   |     21 -
 tests/headers/opaque_in_struct.hpp                 |     11 -
 tests/headers/opaque_pointer.hpp                   |     23 -
 tests/headers/opaque_typedef.hpp                   |     17 -
 tests/headers/operator.hpp                         |      5 -
 tests/headers/ord-enum.h                           |     15 -
 tests/headers/overflowed_enum.hpp                  |     12 -
 tests/headers/overloading.hpp                      |      9 -
 tests/headers/packed-bitfield.h                    |      5 -
 tests/headers/packed-n-with-padding.h              |      8 -
 tests/headers/packed-vtable.h                      |     10 -
 tests/headers/parm-union.hpp                       |      4 -
 .../parsecb-anonymous-enum-variant-rename.h        |      6 -
 .../partial-specialization-and-inheritance.hpp     |     40 -
 tests/headers/pointer-attr.h                       |      1 -
 tests/headers/prepend-enum-constified-variant.h    |      6 -
 tests/headers/prepend_enum_name.hpp                |      6 -
 tests/headers/private.hpp                          |     21 -
 tests/headers/private_fields.hpp                   |     44 -
 tests/headers/public-dtor.hpp                      |     15 -
 tests/headers/qualified-dependent-types.hpp        |     16 -
 tests/headers/redeclaration.hpp                    |      7 -
 tests/headers/ref_argument_array.hpp               |      6 -
 tests/headers/reparented_replacement.hpp           |     16 -
 tests/headers/replace_template_alias.hpp           |     23 -
 tests/headers/replace_use.hpp                      |     15 -
 tests/headers/replaces_double.hpp                  |     20 -
 tests/headers/repr-align.hpp                       |     11 -
 tests/headers/resolved_type_def_function.h         |      2 -
 .../same_struct_name_in_different_namespaces.hpp   |     12 -
 tests/headers/sentry-defined-multiple-times.hpp    |     85 -
 tests/headers/short-enums.hpp                      |     19 -
 tests/headers/size_t_template.hpp                  |      8 -
 tests/headers/sorted-items.h                       |     17 -
 tests/headers/stdint_typedef.h                     |     10 -
 .../struct_containing_forward_declared_struct.h    |      8 -
 tests/headers/struct_typedef.h                     |     17 -
 tests/headers/struct_typedef_ns.hpp                |     21 -
 tests/headers/struct_with_anon_struct.h            |      8 -
 tests/headers/struct_with_anon_struct_array.h      |     12 -
 tests/headers/struct_with_anon_struct_pointer.h    |      7 -
 tests/headers/struct_with_anon_union.h             |      8 -
 tests/headers/struct_with_anon_union_1_0.h         |      8 -
 tests/headers/struct_with_anon_unnamed_struct.h    |      7 -
 tests/headers/struct_with_anon_unnamed_union.h     |      7 -
 tests/headers/struct_with_anon_unnamed_union_1_0.h |      8 -
 tests/headers/struct_with_bitfields.h              |     14 -
 tests/headers/struct_with_derive_debug.h           |     17 -
 tests/headers/struct_with_large_array.hpp          |      9 -
 tests/headers/struct_with_nesting.h                |     19 -
 tests/headers/struct_with_nesting_1_0.h            |     19 -
 tests/headers/struct_with_packing.h                |      6 -
 tests/headers/struct_with_struct.h                 |      8 -
 tests/headers/struct_with_typedef_template_arg.hpp |      5 -
 tests/headers/template-fun-ty.hpp                  |     17 -
 tests/headers/template-param-usage-0.hpp           |      6 -
 tests/headers/template-param-usage-1.hpp           |      6 -
 tests/headers/template-param-usage-10.hpp          |     14 -
 tests/headers/template-param-usage-11.hpp          |      6 -
 tests/headers/template-param-usage-12.hpp          |     11 -
 tests/headers/template-param-usage-13.hpp          |     11 -
 tests/headers/template-param-usage-14.hpp          |     11 -
 tests/headers/template-param-usage-15.hpp          |     11 -
 tests/headers/template-param-usage-2.hpp           |     10 -
 tests/headers/template-param-usage-3.hpp           |     12 -
 tests/headers/template-param-usage-4.hpp           |     11 -
 tests/headers/template-param-usage-5.hpp           |      8 -
 tests/headers/template-param-usage-6.hpp           |      8 -
 tests/headers/template-param-usage-7.hpp           |     10 -
 tests/headers/template-param-usage-8.hpp           |     10 -
 tests/headers/template-param-usage-9.hpp           |     12 -
 tests/headers/template-with-var.hpp                |      7 -
 tests/headers/template.hpp                         |    168 -
 tests/headers/template_alias.hpp                   |     13 -
 tests/headers/template_alias_basic.hpp             |      4 -
 tests/headers/template_alias_namespace.hpp         |     13 -
 tests/headers/template_fun.hpp                     |      3 -
 .../template_instantiation_with_fn_local_type.hpp  |     27 -
 tests/headers/template_partial_specification.hpp   |     10 -
 .../headers/template_typedef_transitive_param.hpp  |      8 -
 tests/headers/template_typedefs.hpp                |      8 -
 tests/headers/templateref_opaque.hpp               |     12 -
 tests/headers/templatized-bitfield.hpp             |      7 -
 tests/headers/timex.h                              |     15 -
 tests/headers/transform-op.hpp                     |     75 -
 .../type-referenced-by-allowlisted-function.h      |      7 -
 tests/headers/type_alias_empty.hpp                 |     10 -
 ...type_alias_partial_template_especialization.hpp |      7 -
 tests/headers/type_alias_template_specialized.hpp  |      9 -
 tests/headers/typedefd-array-as-function-arg.h     |      3 -
 tests/headers/typeref.hpp                          |     29 -
 tests/headers/typeref_1_0.hpp                      |     30 -
 tests/headers/underscore.hpp                       |      3 -
 tests/headers/union-align.h                        |     10 -
 tests/headers/union-in-ns.hpp                      |      5 -
 tests/headers/union-in-ns_1_0.hpp                  |      5 -
 tests/headers/union_bitfield.h                     |     10 -
 tests/headers/union_bitfield_1_0.h                 |     14 -
 tests/headers/union_dtor.hpp                       |      5 -
 tests/headers/union_dtor_1_0.hpp                   |      7 -
 tests/headers/union_fields.hpp                     |      7 -
 tests/headers/union_fields_1_0.hpp                 |      7 -
 tests/headers/union_template.hpp                   |     21 -
 tests/headers/union_template_1_0.hpp               |     21 -
 tests/headers/union_with_anon_struct.h             |      8 -
 tests/headers/union_with_anon_struct_1_0.h         |      8 -
 tests/headers/union_with_anon_struct_bitfield.h    |      9 -
 .../headers/union_with_anon_struct_bitfield_1_0.h  |      9 -
 tests/headers/union_with_anon_union.h              |      8 -
 tests/headers/union_with_anon_union_1_0.h          |      8 -
 tests/headers/union_with_anon_unnamed_struct.h     |     11 -
 tests/headers/union_with_anon_unnamed_struct_1_0.h |     11 -
 tests/headers/union_with_anon_unnamed_union.h      |      9 -
 tests/headers/union_with_anon_unnamed_union_1_0.h  |      9 -
 tests/headers/union_with_big_member.h              |     16 -
 tests/headers/union_with_big_member_1_0.h          |     16 -
 tests/headers/union_with_nesting.h                 |     16 -
 tests/headers/union_with_nesting_1_0.h             |     16 -
 tests/headers/union_with_non_copy_member.h         |     20 -
 tests/headers/unknown_attr.h                       |      6 -
 tests/headers/unsorted-items.h                     |     15 -
 tests/headers/use-core.h                           |     13 -
 tests/headers/use-core_1_0.h                       |     13 -
 tests/headers/using.hpp                            |     11 -
 tests/headers/var-tracing.hpp                      |     10 -
 tests/headers/variadic-method.hpp                  |      6 -
 tests/headers/variadic_template_function.hpp       |      6 -
 tests/headers/vector.hpp                           |      9 -
 tests/headers/virtual_dtor.hpp                     |      3 -
 tests/headers/virtual_inheritance.hpp              |     16 -
 tests/headers/virtual_interface.hpp                |     24 -
 tests/headers/virtual_overloaded.hpp               |      5 -
 tests/headers/vtable_recursive_sig.hpp             |     11 -
 tests/headers/wasm-constructor-returns.hpp         |      7 -
 tests/headers/wasm-import-module.h                 |      3 -
 tests/headers/weird_bitfields.hpp                  |     36 -
 tests/headers/what_is_going_on.hpp                 |     19 -
 tests/headers/win32-thiscall_1_0.hpp               |      7 -
 tests/headers/win32-thiscall_nightly.hpp           |      7 -
 tests/headers/win32-vectorcall-1_0.h               |      3 -
 tests/headers/win32-vectorcall-nightly.h           |      3 -
 tests/headers/with_array_pointers_arguments.h      |     10 -
 tests/headers/without_array_pointers_arguments.h   |      9 -
 tests/headers/zero-size-array-align.h              |      5 -
 tests/headers/zero-sized-array.hpp                 |     45 -
 tests/parse_callbacks/mod.rs                       |     42 -
 tests/quickchecking/.gitignore                     |      1 -
 tests/quickchecking/Cargo.toml                     |     32 -
 tests/quickchecking/README.md                      |     39 -
 tests/quickchecking/src/bin.rs                     |    110 -
 tests/quickchecking/src/fuzzers.rs                 |    637 -
 tests/quickchecking/src/lib.rs                     |    126 -
 tests/quickchecking/tests/fuzzed-c-headers.rs      |     95 -
 tests/rustfmt.toml                                 |      3 -
 tests/stylo.hpp                                    | 177914 ------------------
 tests/stylo_sanity.rs                              |    556 -
 tests/test-one.sh                                  |     98 -
 tests/tests.rs                                     |    688 -
 tests/uses/.gitignore                              |      2 -
 2418 files changed, 275731 insertions(+), 275355 deletions(-)
 create mode 100644 bindgen-cli/Cargo.toml
 create mode 100644 bindgen-cli/main.rs
 create mode 100644 bindgen-cli/options.rs
 create mode 100644 bindgen-tests/Cargo.toml
 create mode 100644 bindgen-tests/build.rs
 create mode 100644 bindgen-tests/src/lib.rs
 create mode 100644 bindgen-tests/tests/.gitattributes
 create mode 100644 bindgen-tests/tests/expectations/Cargo.toml
 create mode 100644 bindgen-tests/tests/expectations/build.rs
 create mode 100755 bindgen-tests/tests/expectations/lib.rs
 create mode 100644 bindgen-tests/tests/expectations/src/lib.rs
 create mode 100644 bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/.gitattributes
 create mode 100644 bindgen-tests/tests/expectations/tests/16-byte-alignment.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/16-byte-alignment_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/381-decltype-alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/accessors.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist-file.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist_basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist_fix.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist_vars.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlist_warnings.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/annotation_hide.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_enum_trait.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_struct_in_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anon_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/anonymous-template-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/arg_keyword.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/base-to-derived.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-large.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield_align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield_align_2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/block_return_type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocklist-file.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocklist-function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocklist-item.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocks-signature.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/blocks.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/bug-1529681.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/builtin-template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/c-empty-layout.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/c_naming.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/call-conv-typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/canonical-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/char.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_nested.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_no_members.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_static.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_static_const.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_use_as.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_with_dtor.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_with_inner_struct_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/class_with_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/comment-indent.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/complex.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/complex_global.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_ptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_resolved_ty.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/const_tparam.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-all-enums.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constructor-tp.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constructors.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/constructors_1_33.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/convert-floats.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/core_ffi_c.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/crtp.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dash_language.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/default-template-parameter.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/deleted-function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-clone.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-clone_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-custom.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-generic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/derive-partialeq-union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/disable-namespacing.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/disable-untagged-union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/doggo-or-null.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/elaborated.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/empty-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/empty-union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/empty_template_param_name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-default-consts.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-default-module.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-default-rust.d
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-default-rust.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-doc-mod.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-doc.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-translate-type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-undefault.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_dupe.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_explicit_type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_in_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_negative.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/enum_packed.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/eval-value-dependent.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/explicit-padding.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/extern-const-struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/extern.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/float128.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward-enum-decl.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward_declared_complex_types_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/forward_declared_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_proto.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_ptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_return_must_use.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_with_array_arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/gen-constructors.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/gen-destructors.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/generate-inline.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/i128.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/in_class_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/infinite-macro.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inherit-namespaced.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inherit_named.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inherit_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inline-function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inline_namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inner_const.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/inner_template_self.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/int128_t.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1034.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1040.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1281.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1285.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1291.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1435.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1443.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1454.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1464.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1488-options.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1498.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1514.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1554.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1947.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-1995.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-2019.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-358.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-372.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-410.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-446.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-447.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-493.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-493_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-511.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-537.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-662-part-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-674-1.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-674-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-674-3.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-816.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-833-1.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-833-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-833.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-834.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue-946.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue_311.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/issue_315.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/keywords.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_arp.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_array_too_long.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_eth_conf.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_large_align_field.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_mbuf.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/layout_mbuf_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/abi_variadic_function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/auto.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/call-conv-field.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/const_bool.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/constant-evaluate.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/mangling-win32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/objc_inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/objc_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/abi_variadic_function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/auto.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/call-conv-field.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/class.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/class_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/const_bool.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/constant-evaluate.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/layout_align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/mangling-win32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/objc_inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/objc_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/zero-sized-array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/long_double.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/macro-expr-basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/macro-redef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/macro_const.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/macro_const_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mangling-ios.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mangling-linux32.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mangling-linux64.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mangling-macos.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mangling-win64.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/merge-extern-blocks.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/method-mangling.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/module-allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/msvc-no-usr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/mutable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nested-template-typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nested.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nested_vtable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nested_within_namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/newtype-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/newtype-global-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-comments.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-derive-debug.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-derive-default.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-hash-opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no-std.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_copy.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_copy_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_debug.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_debug_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_default.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_default_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/non-type-params.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/noreturn.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_allowlist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_blocklist.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_category.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_class.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_class_method.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_interface.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_interface_type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_method.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_method_clash.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_protocol.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/only_bitfields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque-tracing.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque_in_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque_pointer.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/opaque_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/operator.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/ord-enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/overflowed_enum.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/overloading.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/packed-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/packed-vtable.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/parm-union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/pointer-attr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/prepend_enum_name.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/private.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/private_fields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/public-dtor.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/redeclaration.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/ref_argument_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/reparented_replacement.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/replace_template_alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/replace_use.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/replaces_double.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/repr-align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/short-enums.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/size_t_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/sorted-items.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/stdint_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_typedef.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_large_array.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_nesting.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_nesting_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_packing.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-fun-ty.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-1.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-10.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-11.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-12.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-13.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-14.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-15.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-2.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-3.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-4.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-5.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-6.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-7.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-8.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-param-usage-9.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template-with-var.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_alias.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_alias_basic.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_alias_namespace.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_fun.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_partial_specification.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/template_typedefs.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/templateref_opaque.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/templatized-bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/timex.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/transform-op.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/type_alias_empty.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/typeref.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/typeref_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/underscore.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union-align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union-in-ns.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union-in-ns_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_bitfield_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_dtor.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_dtor_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_fields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_fields_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_template.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_template_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_struct_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_big_member.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_big_member_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_nesting.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_nesting_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/unknown_attr.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/unsorted-items.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/use-core.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/use-core_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/using.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/var-tracing.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/variadic-method.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/variadic_template_function.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/vector.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/virtual_dtor.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/virtual_inheritance.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/virtual_interface.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/virtual_overloaded.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/wasm-import-module.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/weird_bitfields.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/what_is_going_on.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/win32-thiscall_1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/win32-vectorcall-1_0.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/zero-size-array-align.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/zero-sized-array.rs
 create mode 100644 bindgen-tests/tests/headers/16-byte-alignment.h
 create mode 100644 bindgen-tests/tests/headers/16-byte-alignment_1_0.h
 create mode 100644 bindgen-tests/tests/headers/381-decltype-alias.hpp
 create mode 100644 bindgen-tests/tests/headers/abi_variadic_function.hpp
 create mode 100644 bindgen-tests/tests/headers/accessors.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist-file.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist-namespaces.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist_basic.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist_fix.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlist_vars.h
 create mode 100644 bindgen-tests/tests/headers/allowlist_warnings.h
 create mode 100644 bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlisted/file.hpp
 create mode 100644 bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp
 create mode 100644 bindgen-tests/tests/headers/annotation_hide.hpp
 create mode 100644 bindgen-tests/tests/headers/anon-fields-prefix.h
 create mode 100644 bindgen-tests/tests/headers/anon_enum.hpp
 create mode 100644 bindgen-tests/tests/headers/anon_enum_allowlist.h
 create mode 100644 bindgen-tests/tests/headers/anon_enum_trait.hpp
 create mode 100644 bindgen-tests/tests/headers/anon_struct_in_union.h
 create mode 100644 bindgen-tests/tests/headers/anon_struct_in_union_1_0.h
 create mode 100644 bindgen-tests/tests/headers/anon_union.hpp
 create mode 100644 bindgen-tests/tests/headers/anon_union_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/anonymous-template-types.hpp
 create mode 100644 bindgen-tests/tests/headers/arg_keyword.hpp
 create mode 100644 bindgen-tests/tests/headers/array-of-zero-sized-types.hpp
 create mode 100644 bindgen-tests/tests/headers/attribute_warn_unused_result.hpp
 create mode 100644 bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
 create mode 100644 bindgen-tests/tests/headers/attribute_warn_unused_result_pre_1_27.hpp
 create mode 100644 bindgen-tests/tests/headers/auto.hpp
 create mode 100644 bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp
 create mode 100644 bindgen-tests/tests/headers/base-to-derived.hpp
 create mode 100644 bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-32bit-overflow.h
 create mode 100644 bindgen-tests/tests/headers/bitfield-enum-basic.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-large.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-linux-32.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield-method-same-name.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield_align.h
 create mode 100644 bindgen-tests/tests/headers/bitfield_align_2.h
 create mode 100644 bindgen-tests/tests/headers/bitfield_large_overflow.hpp
 create mode 100644 bindgen-tests/tests/headers/bitfield_method_mangling.h
 create mode 100644 bindgen-tests/tests/headers/bitfield_pragma_packed.h
 create mode 100644 bindgen-tests/tests/headers/block_return_type.h
 create mode 100644 bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp
 create mode 100644 bindgen-tests/tests/headers/blocklist-file.hpp
 create mode 100644 bindgen-tests/tests/headers/blocklist-function.hpp
 create mode 100644 bindgen-tests/tests/headers/blocklist-item.hpp
 create mode 100644 bindgen-tests/tests/headers/blocklisted/fake-stdint.h
 create mode 100644 bindgen-tests/tests/headers/blocklisted/file.hpp
 create mode 100644 bindgen-tests/tests/headers/blocks-signature.hpp
 create mode 100644 bindgen-tests/tests/headers/blocks.hpp
 create mode 100644 bindgen-tests/tests/headers/bug-1529681.hpp
 create mode 100644 bindgen-tests/tests/headers/builtin-template.hpp
 create mode 100644 bindgen-tests/tests/headers/c-empty-layout.h
 create mode 100644 bindgen-tests/tests/headers/c_naming.h
 create mode 100644 bindgen-tests/tests/headers/call-conv-field.h
 create mode 100644 bindgen-tests/tests/headers/call-conv-typedef.h
 create mode 100644 bindgen-tests/tests/headers/canonical-types.hpp
 create mode 100644 bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp
 create mode 100644 bindgen-tests/tests/headers/char.h
 create mode 100644 bindgen-tests/tests/headers/class.hpp
 create mode 100644 bindgen-tests/tests/headers/class_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/class_nested.hpp
 create mode 100644 bindgen-tests/tests/headers/class_no_members.hpp
 create mode 100644 bindgen-tests/tests/headers/class_static.hpp
 create mode 100644 bindgen-tests/tests/headers/class_static_const.hpp
 create mode 100644 bindgen-tests/tests/headers/class_use_as.hpp
 create mode 100644 bindgen-tests/tests/headers/class_with_dtor.hpp
 create mode 100644 bindgen-tests/tests/headers/class_with_inner_struct.hpp
 create mode 100644 bindgen-tests/tests/headers/class_with_inner_struct_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/class_with_typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/comment-indent.hpp
 create mode 100644 bindgen-tests/tests/headers/complex.h
 create mode 100644 bindgen-tests/tests/headers/complex_global.h
 create mode 100644 bindgen-tests/tests/headers/const-const-mut-ptr.h
 create mode 100644 bindgen-tests/tests/headers/const_array.h
 create mode 100644 bindgen-tests/tests/headers/const_array_fn_arg.h
 create mode 100644 bindgen-tests/tests/headers/const_bool.hpp
 create mode 100644 bindgen-tests/tests/headers/const_enum_unnamed.hpp
 create mode 100644 bindgen-tests/tests/headers/const_multidim_array_fn_arg.h
 create mode 100644 bindgen-tests/tests/headers/const_ptr.hpp
 create mode 100644 bindgen-tests/tests/headers/const_resolved_ty.h
 create mode 100644 bindgen-tests/tests/headers/const_tparam.hpp
 create mode 100644 bindgen-tests/tests/headers/constant-evaluate.h
 create mode 100644 bindgen-tests/tests/headers/constant-non-specialized-tp.hpp
 create mode 100644 bindgen-tests/tests/headers/constified-enum-module-overflow.hpp
 create mode 100644 bindgen-tests/tests/headers/constify-all-enums.h
 create mode 100644 bindgen-tests/tests/headers/constify-enum.h
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-basic.h
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-shadow-name.h
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp
 create mode 100644 bindgen-tests/tests/headers/constify-module-enums-types.hpp
 create mode 100644 bindgen-tests/tests/headers/constructor-tp.hpp
 create mode 100644 bindgen-tests/tests/headers/constructors.hpp
 create mode 100644 bindgen-tests/tests/headers/constructors_1_33.hpp
 create mode 100644 bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp
 create mode 100644 bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp
 create mode 100644 bindgen-tests/tests/headers/convert-floats.h
 create mode 100644 bindgen-tests/tests/headers/core_ffi_c.h
 create mode 100644 bindgen-tests/tests/headers/cpp-empty-layout.hpp
 create mode 100644 bindgen-tests/tests/headers/crtp.hpp
 create mode 100644 bindgen-tests/tests/headers/ctypes-prefix-path.h
 create mode 100644 bindgen-tests/tests/headers/dash_language.h
 create mode 100644 bindgen-tests/tests/headers/decl_extern_int_twice.h
 create mode 100644 bindgen-tests/tests/headers/decl_ptr_to_array.h
 create mode 100644 bindgen-tests/tests/headers/default-enum-style-constified-module.h
 create mode 100644 bindgen-tests/tests/headers/default-macro-constant-type-signed.h
 create mode 100644 bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h
 create mode 100644 bindgen-tests/tests/headers/default-macro-constant-type.h
 create mode 100644 bindgen-tests/tests/headers/default-template-parameter.hpp
 create mode 100644 bindgen-tests/tests/headers/deleted-function.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-clone.h
 create mode 100644 bindgen-tests/tests/headers/derive-clone_1_0.h
 create mode 100644 bindgen-tests/tests/headers/derive-custom.h
 create mode 100644 bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-debug-bitfield.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-debug-function-pointer.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-debug-generic.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-debug-mangle-name.h
 create mode 100644 bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-debug-opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-default-and-blocklist.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-fn-ptr.h
 create mode 100644 bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-hash-blocklisting.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h
 create mode 100644 bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h
 create mode 100644 bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h
 create mode 100644 bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h
 create mode 100644 bindgen-tests/tests/headers/derive-hash-template-def-float.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-anonfield.h
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-base.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-core.h
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-pointer.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-union.hpp
 create mode 100644 bindgen-tests/tests/headers/derive-partialeq-union_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/disable-namespacing.hpp
 create mode 100644 bindgen-tests/tests/headers/disable-nested-struct-naming.h
 create mode 100644 bindgen-tests/tests/headers/disable-untagged-union.hpp
 create mode 100644 bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h
 create mode 100644 bindgen-tests/tests/headers/do-not-derive-copy.hpp
 create mode 100644 bindgen-tests/tests/headers/doggo-or-null.hpp
 create mode 100644 bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h
 create mode 100644 bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp
 create mode 100644 bindgen-tests/tests/headers/duplicated-namespaces.hpp
 create mode 100644 bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_attributes.h
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_required.h
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_simple.h
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_template.hpp
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp
 create mode 100644 bindgen-tests/tests/headers/dynamic_loading_with_class.hpp
 create mode 100644 bindgen-tests/tests/headers/elaborated.hpp
 create mode 100644 bindgen-tests/tests/headers/empty-enum.h
 create mode 100644 bindgen-tests/tests/headers/empty-union.hpp
 create mode 100644 bindgen-tests/tests/headers/empty_template_param_name.hpp
 create mode 100644 bindgen-tests/tests/headers/enum-default-bitfield.h
 create mode 100644 bindgen-tests/tests/headers/enum-default-consts.h
 create mode 100644 bindgen-tests/tests/headers/enum-default-module.h
 create mode 100644 bindgen-tests/tests/headers/enum-default-rust.h
 create mode 100644 bindgen-tests/tests/headers/enum-doc-bitfield.h
 create mode 100644 bindgen-tests/tests/headers/enum-doc-mod.h
 create mode 100644 bindgen-tests/tests/headers/enum-doc-rusty.h
 create mode 100644 bindgen-tests/tests/headers/enum-doc.h
 create mode 100644 bindgen-tests/tests/headers/enum-no-debug-rust.h
 create mode 100644 bindgen-tests/tests/headers/enum-translate-type.hpp
 create mode 100644 bindgen-tests/tests/headers/enum-undefault.h
 create mode 100644 bindgen-tests/tests/headers/enum-variant-replaces.h
 create mode 100644 bindgen-tests/tests/headers/enum.h
 create mode 100644 bindgen-tests/tests/headers/enum_alias.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_dupe.h
 create mode 100644 bindgen-tests/tests/headers/enum_explicit_type.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_explicit_type_constants.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_in_template.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/enum_negative.h
 create mode 100644 bindgen-tests/tests/headers/enum_packed.h
 create mode 100644 bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
 create mode 100644 bindgen-tests/tests/headers/eval-value-dependent.hpp
 create mode 100644 bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp
 create mode 100644 bindgen-tests/tests/headers/explicit-padding.h
 create mode 100644 bindgen-tests/tests/headers/extern-const-struct.h
 create mode 100644 bindgen-tests/tests/headers/extern.hpp
 create mode 100644 bindgen-tests/tests/headers/fit-macro-constant-types-signed.h
 create mode 100644 bindgen-tests/tests/headers/fit-macro-constant-types.h
 create mode 100644 bindgen-tests/tests/headers/float128.hpp
 create mode 100644 bindgen-tests/tests/headers/forward-declaration-autoptr.hpp
 create mode 100644 bindgen-tests/tests/headers/forward-enum-decl.hpp
 create mode 100644 bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp
 create mode 100644 bindgen-tests/tests/headers/forward-inherit-struct.hpp
 create mode 100644 bindgen-tests/tests/headers/forward_declared_complex_types.hpp
 create mode 100644 bindgen-tests/tests/headers/forward_declared_complex_types_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/forward_declared_opaque.h
 create mode 100644 bindgen-tests/tests/headers/forward_declared_struct.h
 create mode 100644 bindgen-tests/tests/headers/func_proto.h
 create mode 100644 bindgen-tests/tests/headers/func_ptr.h
 create mode 100644 bindgen-tests/tests/headers/func_ptr_in_struct.h
 create mode 100644 bindgen-tests/tests/headers/func_ptr_return_type.h
 create mode 100644 bindgen-tests/tests/headers/func_return_must_use.h
 create mode 100644 bindgen-tests/tests/headers/func_with_array_arg.h
 create mode 100644 bindgen-tests/tests/headers/func_with_func_ptr_arg.h
 create mode 100644 bindgen-tests/tests/headers/function-typedef-stdcall.h
 create mode 100644 bindgen-tests/tests/headers/gen-constructors-neg.hpp
 create mode 100644 bindgen-tests/tests/headers/gen-constructors.hpp
 create mode 100644 bindgen-tests/tests/headers/gen-destructors-neg.hpp
 create mode 100644 bindgen-tests/tests/headers/gen-destructors.hpp
 create mode 100644 bindgen-tests/tests/headers/generate-inline.hpp
 create mode 100644 bindgen-tests/tests/headers/i128.h
 create mode 100644 bindgen-tests/tests/headers/in_class_typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/incomplete-array-padding.h
 create mode 100644 bindgen-tests/tests/headers/infinite-macro.h
 create mode 100644 bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp
 create mode 100644 bindgen-tests/tests/headers/inherit-namespaced.hpp
 create mode 100644 bindgen-tests/tests/headers/inherit_named.hpp
 create mode 100644 bindgen-tests/tests/headers/inherit_typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/inline-function.h
 create mode 100644 bindgen-tests/tests/headers/inline_namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/inline_namespace_allowlist.hpp
 create mode 100644 bindgen-tests/tests/headers/inline_namespace_conservative.hpp
 create mode 100644 bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp
 create mode 100644 bindgen-tests/tests/headers/inner-typedef-gh422.hpp
 create mode 100644 bindgen-tests/tests/headers/inner_const.hpp
 create mode 100644 bindgen-tests/tests/headers/inner_template_self.hpp
 create mode 100644 bindgen-tests/tests/headers/int128_t.h
 create mode 100644 bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1034.h
 create mode 100644 bindgen-tests/tests/headers/issue-1040.h
 create mode 100644 bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h
 create mode 100644 bindgen-tests/tests/headers/issue-1113-template-references.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h
 create mode 100644 bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
 create mode 100644 bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h
 create mode 100644 bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h
 create mode 100644 bindgen-tests/tests/headers/issue-1216-variadic-member.h
 create mode 100644 bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h
 create mode 100644 bindgen-tests/tests/headers/issue-1281.h
 create mode 100644 bindgen-tests/tests/headers/issue-1285.h
 create mode 100644 bindgen-tests/tests/headers/issue-1291.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h
 create mode 100644 bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h
 create mode 100644 bindgen-tests/tests/headers/issue-1435.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1443.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1454.h
 create mode 100644 bindgen-tests/tests/headers/issue-1464.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1488-enum-new-type.h
 create mode 100644 bindgen-tests/tests/headers/issue-1488-options.h
 create mode 100644 bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1498.h
 create mode 100644 bindgen-tests/tests/headers/issue-1514.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1554.h
 create mode 100644 bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h
 create mode 100644 bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1947.h
 create mode 100644 bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-1995.h
 create mode 100644 bindgen-tests/tests/headers/issue-2019.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-358.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-372.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-410.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-446.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-447.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-493.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-493_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-511.h
 create mode 100644 bindgen-tests/tests/headers/issue-537-repr-packed-n.h
 create mode 100644 bindgen-tests/tests/headers/issue-537.h
 create mode 100644 bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-643-inner-struct.h
 create mode 100644 bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h
 create mode 100644 bindgen-tests/tests/headers/issue-654-struct-fn-collision.h
 create mode 100644 bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-662-part-2.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-674-1.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-674-2.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-674-3.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-710-must-use-type.h
 create mode 100644 bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h
 create mode 100644 bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-816.h
 create mode 100644 bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-833-1.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-833-2.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-833.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-834.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-848/an-include.h
 create mode 100644 bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp
 create mode 100644 bindgen-tests/tests/headers/issue-946.h
 create mode 100644 bindgen-tests/tests/headers/issue_311.hpp
 create mode 100644 bindgen-tests/tests/headers/issue_315.hpp
 create mode 100644 bindgen-tests/tests/headers/jsval_layout_opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/jsval_layout_opaque_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/keywords.h
 create mode 100644 bindgen-tests/tests/headers/layout.h
 create mode 100644 bindgen-tests/tests/headers/layout_align.h
 create mode 100644 bindgen-tests/tests/headers/layout_arp.h
 create mode 100644 bindgen-tests/tests/headers/layout_array.h
 create mode 100644 bindgen-tests/tests/headers/layout_array_too_long.h
 create mode 100644 bindgen-tests/tests/headers/layout_cmdline_token.h
 create mode 100644 bindgen-tests/tests/headers/layout_eth_conf.h
 create mode 100644 bindgen-tests/tests/headers/layout_eth_conf_1_0.h
 create mode 100644 bindgen-tests/tests/headers/layout_kni_mbuf.h
 create mode 100644 bindgen-tests/tests/headers/layout_large_align_field.h
 create mode 100644 bindgen-tests/tests/headers/layout_mbuf.h
 create mode 100644 bindgen-tests/tests/headers/layout_mbuf_1_0.h
 create mode 100644 bindgen-tests/tests/headers/long_double.h
 create mode 100644 bindgen-tests/tests/headers/macro-expr-basic.h
 create mode 100644 bindgen-tests/tests/headers/macro-expr-uncommon-token.h
 create mode 100644 bindgen-tests/tests/headers/macro-redef.h
 create mode 100644 bindgen-tests/tests/headers/macro_const.h
 create mode 100644 bindgen-tests/tests/headers/macro_const_1_0.h
 create mode 100644 bindgen-tests/tests/headers/maddness-is-avoidable.hpp
 create mode 100644 bindgen-tests/tests/headers/mangling-ios.h
 create mode 100644 bindgen-tests/tests/headers/mangling-linux32.hpp
 create mode 100644 bindgen-tests/tests/headers/mangling-linux64.hpp
 create mode 100644 bindgen-tests/tests/headers/mangling-macos.hpp
 create mode 100644 bindgen-tests/tests/headers/mangling-win32.hpp
 create mode 100644 bindgen-tests/tests/headers/mangling-win64.hpp
 create mode 100644 bindgen-tests/tests/headers/merge-extern-blocks.h
 create mode 100644 bindgen-tests/tests/headers/method-mangling.hpp
 create mode 100644 bindgen-tests/tests/headers/module-allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/msvc-no-usr.hpp
 create mode 100644 bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp
 create mode 100644 bindgen-tests/tests/headers/mutable.hpp
 create mode 100644 bindgen-tests/tests/headers/namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/namespace/nsbegin.h
 create mode 100644 bindgen-tests/tests/headers/namespace/nsend.h
 create mode 100644 bindgen-tests/tests/headers/nested-template-typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/nested.hpp
 create mode 100644 bindgen-tests/tests/headers/nested_vtable.hpp
 create mode 100644 bindgen-tests/tests/headers/nested_within_namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/newtype-enum.hpp
 create mode 100644 bindgen-tests/tests/headers/newtype-global-enum.hpp
 create mode 100644 bindgen-tests/tests/headers/no-comments.h
 create mode 100644 bindgen-tests/tests/headers/no-derive-debug.h
 create mode 100644 bindgen-tests/tests/headers/no-derive-default.h
 create mode 100644 bindgen-tests/tests/headers/no-hash-allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/no-hash-opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/no-partialeq-opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/no-recursive-allowlisting.h
 create mode 100644 bindgen-tests/tests/headers/no-std.h
 create mode 100644 bindgen-tests/tests/headers/no_copy.hpp
 create mode 100644 bindgen-tests/tests/headers/no_copy_allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/no_copy_opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/no_debug.hpp
 create mode 100644 bindgen-tests/tests/headers/no_debug_allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp
 create mode 100644 bindgen-tests/tests/headers/no_debug_opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/no_default.hpp
 create mode 100644 bindgen-tests/tests/headers/no_default_allowlisted.hpp
 create mode 100644 bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp
 create mode 100644 bindgen-tests/tests/headers/no_default_opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/no_size_t_is_usize.h
 create mode 100644 bindgen-tests/tests/headers/non-type-params.hpp
 create mode 100644 bindgen-tests/tests/headers/noreturn.hpp
 create mode 100644 bindgen-tests/tests/headers/nsBaseHashtable.hpp
 create mode 100644 bindgen-tests/tests/headers/nsStyleAutoArray.hpp
 create mode 100644 bindgen-tests/tests/headers/objc_allowlist.h
 create mode 100644 bindgen-tests/tests/headers/objc_blocklist.h
 create mode 100644 bindgen-tests/tests/headers/objc_category.h
 create mode 100644 bindgen-tests/tests/headers/objc_class.h
 create mode 100644 bindgen-tests/tests/headers/objc_class_method.h
 create mode 100644 bindgen-tests/tests/headers/objc_inheritance.h
 create mode 100644 bindgen-tests/tests/headers/objc_interface.h
 create mode 100644 bindgen-tests/tests/headers/objc_interface_type.h
 create mode 100644 bindgen-tests/tests/headers/objc_method.h
 create mode 100644 bindgen-tests/tests/headers/objc_method_clash.h
 create mode 100644 bindgen-tests/tests/headers/objc_pointer_return_types.h
 create mode 100644 bindgen-tests/tests/headers/objc_property_fnptr.h
 create mode 100644 bindgen-tests/tests/headers/objc_protocol.h
 create mode 100644 bindgen-tests/tests/headers/objc_protocol_inheritance.h
 create mode 100644 bindgen-tests/tests/headers/objc_sel_and_id.h
 create mode 100644 bindgen-tests/tests/headers/objc_template.h
 create mode 100644 bindgen-tests/tests/headers/only_bitfields.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque-template-inst-member.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque-template-instantiation.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque-tracing.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque_in_struct.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque_pointer.hpp
 create mode 100644 bindgen-tests/tests/headers/opaque_typedef.hpp
 create mode 100644 bindgen-tests/tests/headers/operator.hpp
 create mode 100644 bindgen-tests/tests/headers/ord-enum.h
 create mode 100644 bindgen-tests/tests/headers/overflowed_enum.hpp
 create mode 100644 bindgen-tests/tests/headers/overloading.hpp
 create mode 100644 bindgen-tests/tests/headers/packed-bitfield.h
 create mode 100644 bindgen-tests/tests/headers/packed-n-with-padding.h
 create mode 100644 bindgen-tests/tests/headers/packed-vtable.h
 create mode 100644 bindgen-tests/tests/headers/parm-union.hpp
 create mode 100644 bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h
 create mode 100644 bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp
 create mode 100644 bindgen-tests/tests/headers/pointer-attr.h
 create mode 100644 bindgen-tests/tests/headers/prepend-enum-constified-variant.h
 create mode 100644 bindgen-tests/tests/headers/prepend_enum_name.hpp
 create mode 100644 bindgen-tests/tests/headers/private.hpp
 create mode 100644 bindgen-tests/tests/headers/private_fields.hpp
 create mode 100644 bindgen-tests/tests/headers/public-dtor.hpp
 create mode 100644 bindgen-tests/tests/headers/qualified-dependent-types.hpp
 create mode 100644 bindgen-tests/tests/headers/redeclaration.hpp
 create mode 100644 bindgen-tests/tests/headers/ref_argument_array.hpp
 create mode 100644 bindgen-tests/tests/headers/reparented_replacement.hpp
 create mode 100644 bindgen-tests/tests/headers/replace_template_alias.hpp
 create mode 100644 bindgen-tests/tests/headers/replace_use.hpp
 create mode 100644 bindgen-tests/tests/headers/replaces_double.hpp
 create mode 100644 bindgen-tests/tests/headers/repr-align.hpp
 create mode 100644 bindgen-tests/tests/headers/resolved_type_def_function.h
 create mode 100644 bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp
 create mode 100644 bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp
 create mode 100644 bindgen-tests/tests/headers/short-enums.hpp
 create mode 100644 bindgen-tests/tests/headers/size_t_template.hpp
 create mode 100644 bindgen-tests/tests/headers/sorted-items.h
 create mode 100644 bindgen-tests/tests/headers/stdint_typedef.h
 create mode 100644 bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h
 create mode 100644 bindgen-tests/tests/headers/struct_typedef.h
 create mode 100644 bindgen-tests/tests/headers/struct_typedef_ns.hpp
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_struct.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_struct_array.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_union.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_union_1_0.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_anon_unnamed_union_1_0.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_bitfields.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_derive_debug.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_large_array.hpp
 create mode 100644 bindgen-tests/tests/headers/struct_with_nesting.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_nesting_1_0.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_packing.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_struct.h
 create mode 100644 bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp
 create mode 100644 bindgen-tests/tests/headers/template-fun-ty.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-0.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-1.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-10.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-11.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-12.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-13.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-14.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-15.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-2.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-3.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-4.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-5.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-6.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-7.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-8.hpp
 create mode 100644 bindgen-tests/tests/headers/template-param-usage-9.hpp
 create mode 100644 bindgen-tests/tests/headers/template-with-var.hpp
 create mode 100644 bindgen-tests/tests/headers/template.hpp
 create mode 100644 bindgen-tests/tests/headers/template_alias.hpp
 create mode 100644 bindgen-tests/tests/headers/template_alias_basic.hpp
 create mode 100644 bindgen-tests/tests/headers/template_alias_namespace.hpp
 create mode 100644 bindgen-tests/tests/headers/template_fun.hpp
 create mode 100644 bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp
 create mode 100644 bindgen-tests/tests/headers/template_partial_specification.hpp
 create mode 100644 bindgen-tests/tests/headers/template_typedef_transitive_param.hpp
 create mode 100644 bindgen-tests/tests/headers/template_typedefs.hpp
 create mode 100644 bindgen-tests/tests/headers/templateref_opaque.hpp
 create mode 100644 bindgen-tests/tests/headers/templatized-bitfield.hpp
 create mode 100644 bindgen-tests/tests/headers/timex.h
 create mode 100644 bindgen-tests/tests/headers/transform-op.hpp
 create mode 100644 bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h
 create mode 100644 bindgen-tests/tests/headers/type_alias_empty.hpp
 create mode 100644 bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp
 create mode 100644 bindgen-tests/tests/headers/type_alias_template_specialized.hpp
 create mode 100644 bindgen-tests/tests/headers/typedefd-array-as-function-arg.h
 create mode 100644 bindgen-tests/tests/headers/typeref.hpp
 create mode 100644 bindgen-tests/tests/headers/typeref_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/underscore.hpp
 create mode 100644 bindgen-tests/tests/headers/union-align.h
 create mode 100644 bindgen-tests/tests/headers/union-in-ns.hpp
 create mode 100644 bindgen-tests/tests/headers/union-in-ns_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/union_bitfield.h
 create mode 100644 bindgen-tests/tests/headers/union_bitfield_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_dtor.hpp
 create mode 100644 bindgen-tests/tests/headers/union_dtor_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/union_fields.hpp
 create mode 100644 bindgen-tests/tests/headers/union_fields_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/union_template.hpp
 create mode 100644 bindgen-tests/tests/headers/union_template_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_struct.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_struct_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_struct_bitfield_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_union.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_union_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_unnamed_struct_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_unnamed_union.h
 create mode 100644 bindgen-tests/tests/headers/union_with_anon_unnamed_union_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_big_member.h
 create mode 100644 bindgen-tests/tests/headers/union_with_big_member_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_nesting.h
 create mode 100644 bindgen-tests/tests/headers/union_with_nesting_1_0.h
 create mode 100644 bindgen-tests/tests/headers/union_with_non_copy_member.h
 create mode 100644 bindgen-tests/tests/headers/unknown_attr.h
 create mode 100644 bindgen-tests/tests/headers/unsorted-items.h
 create mode 100644 bindgen-tests/tests/headers/use-core.h
 create mode 100644 bindgen-tests/tests/headers/use-core_1_0.h
 create mode 100644 bindgen-tests/tests/headers/using.hpp
 create mode 100644 bindgen-tests/tests/headers/var-tracing.hpp
 create mode 100644 bindgen-tests/tests/headers/variadic-method.hpp
 create mode 100644 bindgen-tests/tests/headers/variadic_template_function.hpp
 create mode 100644 bindgen-tests/tests/headers/vector.hpp
 create mode 100644 bindgen-tests/tests/headers/virtual_dtor.hpp
 create mode 100644 bindgen-tests/tests/headers/virtual_inheritance.hpp
 create mode 100644 bindgen-tests/tests/headers/virtual_interface.hpp
 create mode 100644 bindgen-tests/tests/headers/virtual_overloaded.hpp
 create mode 100644 bindgen-tests/tests/headers/vtable_recursive_sig.hpp
 create mode 100644 bindgen-tests/tests/headers/wasm-constructor-returns.hpp
 create mode 100644 bindgen-tests/tests/headers/wasm-import-module.h
 create mode 100644 bindgen-tests/tests/headers/weird_bitfields.hpp
 create mode 100644 bindgen-tests/tests/headers/what_is_going_on.hpp
 create mode 100644 bindgen-tests/tests/headers/win32-thiscall_1_0.hpp
 create mode 100644 bindgen-tests/tests/headers/win32-thiscall_nightly.hpp
 create mode 100644 bindgen-tests/tests/headers/win32-vectorcall-1_0.h
 create mode 100644 bindgen-tests/tests/headers/win32-vectorcall-nightly.h
 create mode 100644 bindgen-tests/tests/headers/with_array_pointers_arguments.h
 create mode 100644 bindgen-tests/tests/headers/without_array_pointers_arguments.h
 create mode 100644 bindgen-tests/tests/headers/zero-size-array-align.h
 create mode 100644 bindgen-tests/tests/headers/zero-sized-array.hpp
 create mode 100644 bindgen-tests/tests/parse_callbacks/mod.rs
 create mode 100644 bindgen-tests/tests/quickchecking/.gitignore
 create mode 100644 bindgen-tests/tests/quickchecking/Cargo.toml
 create mode 100644 bindgen-tests/tests/quickchecking/README.md
 create mode 100644 bindgen-tests/tests/quickchecking/src/bin.rs
 create mode 100644 bindgen-tests/tests/quickchecking/src/fuzzers.rs
 create mode 100644 bindgen-tests/tests/quickchecking/src/lib.rs
 create mode 100644 bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs
 create mode 100644 bindgen-tests/tests/rustfmt.toml
 create mode 100644 bindgen-tests/tests/stylo.hpp
 create mode 100755 bindgen-tests/tests/stylo_sanity.rs
 create mode 100755 bindgen-tests/tests/test-one.sh
 create mode 100644 bindgen-tests/tests/tests.rs
 create mode 100644 bindgen-tests/tests/uses/.gitignore
 create mode 100644 bindgen/Cargo.toml
 create mode 100644 bindgen/build.rs
 create mode 100644 bindgen/callbacks.rs
 create mode 100644 bindgen/clang.rs
 create mode 100644 bindgen/codegen/bitfield_unit.rs
 create mode 100644 bindgen/codegen/bitfield_unit_tests.rs
 create mode 100644 bindgen/codegen/dyngen.rs
 create mode 100644 bindgen/codegen/error.rs
 create mode 100644 bindgen/codegen/helpers.rs
 create mode 100644 bindgen/codegen/impl_debug.rs
 create mode 100644 bindgen/codegen/impl_partialeq.rs
 create mode 100644 bindgen/codegen/mod.rs
 create mode 100644 bindgen/codegen/postprocessing/merge_extern_blocks.rs
 create mode 100644 bindgen/codegen/postprocessing/mod.rs
 create mode 100644 bindgen/codegen/postprocessing/sort_semantically.rs
 create mode 100644 bindgen/codegen/struct_layout.rs
 create mode 100644 bindgen/csmith-fuzzing/README.md
 create mode 100644 bindgen/csmith-fuzzing/csmith.h
 create mode 100755 bindgen/csmith-fuzzing/driver.py
 create mode 100755 bindgen/csmith-fuzzing/predicate.py
 create mode 100644 bindgen/deps.rs
 create mode 100644 bindgen/extra_assertions.rs
 create mode 100644 bindgen/features.rs
 create mode 100644 bindgen/ir/analysis/derive.rs
 create mode 100644 bindgen/ir/analysis/has_destructor.rs
 create mode 100644 bindgen/ir/analysis/has_float.rs
 create mode 100644 bindgen/ir/analysis/has_type_param_in_array.rs
 create mode 100644 bindgen/ir/analysis/has_vtable.rs
 create mode 100644 bindgen/ir/analysis/mod.rs
 create mode 100644 bindgen/ir/analysis/sizedness.rs
 create mode 100644 bindgen/ir/analysis/template_params.rs
 create mode 100644 bindgen/ir/annotations.rs
 create mode 100644 bindgen/ir/comment.rs
 create mode 100644 bindgen/ir/comp.rs
 create mode 100644 bindgen/ir/context.rs
 create mode 100644 bindgen/ir/derive.rs
 create mode 100644 bindgen/ir/dot.rs
 create mode 100644 bindgen/ir/enum_ty.rs
 create mode 100644 bindgen/ir/function.rs
 create mode 100644 bindgen/ir/int.rs
 create mode 100644 bindgen/ir/item.rs
 create mode 100644 bindgen/ir/item_kind.rs
 create mode 100644 bindgen/ir/layout.rs
 create mode 100644 bindgen/ir/mod.rs
 create mode 100644 bindgen/ir/module.rs
 create mode 100644 bindgen/ir/objc.rs
 create mode 100644 bindgen/ir/template.rs
 create mode 100644 bindgen/ir/traversal.rs
 create mode 100644 bindgen/ir/ty.rs
 create mode 100644 bindgen/ir/var.rs
 create mode 100644 bindgen/lib.rs
 create mode 100644 bindgen/log_stubs.rs
 create mode 100644 bindgen/parse.rs
 create mode 100644 bindgen/regex_set.rs
 create mode 100644 bindgen/time.rs
 delete mode 100644 build.rs
 delete mode 100644 csmith-fuzzing/README.md
 delete mode 100644 csmith-fuzzing/csmith.h
 delete mode 100755 csmith-fuzzing/driver.py
 delete mode 100755 csmith-fuzzing/predicate.py
 delete mode 100644 src/callbacks.rs
 delete mode 100644 src/clang.rs
 delete mode 100644 src/codegen/bitfield_unit.rs
 delete mode 100644 src/codegen/bitfield_unit_tests.rs
 delete mode 100644 src/codegen/dyngen.rs
 delete mode 100644 src/codegen/error.rs
 delete mode 100644 src/codegen/helpers.rs
 delete mode 100644 src/codegen/impl_debug.rs
 delete mode 100644 src/codegen/impl_partialeq.rs
 delete mode 100644 src/codegen/mod.rs
 delete mode 100644 src/codegen/postprocessing/merge_extern_blocks.rs
 delete mode 100644 src/codegen/postprocessing/mod.rs
 delete mode 100644 src/codegen/postprocessing/sort_semantically.rs
 delete mode 100644 src/codegen/struct_layout.rs
 delete mode 100644 src/deps.rs
 delete mode 100644 src/extra_assertions.rs
 delete mode 100644 src/features.rs
 delete mode 100644 src/ir/analysis/derive.rs
 delete mode 100644 src/ir/analysis/has_destructor.rs
 delete mode 100644 src/ir/analysis/has_float.rs
 delete mode 100644 src/ir/analysis/has_type_param_in_array.rs
 delete mode 100644 src/ir/analysis/has_vtable.rs
 delete mode 100644 src/ir/analysis/mod.rs
 delete mode 100644 src/ir/analysis/sizedness.rs
 delete mode 100644 src/ir/analysis/template_params.rs
 delete mode 100644 src/ir/annotations.rs
 delete mode 100644 src/ir/comment.rs
 delete mode 100644 src/ir/comp.rs
 delete mode 100644 src/ir/context.rs
 delete mode 100644 src/ir/derive.rs
 delete mode 100644 src/ir/dot.rs
 delete mode 100644 src/ir/enum_ty.rs
 delete mode 100644 src/ir/function.rs
 delete mode 100644 src/ir/int.rs
 delete mode 100644 src/ir/item.rs
 delete mode 100644 src/ir/item_kind.rs
 delete mode 100644 src/ir/layout.rs
 delete mode 100644 src/ir/mod.rs
 delete mode 100644 src/ir/module.rs
 delete mode 100644 src/ir/objc.rs
 delete mode 100644 src/ir/template.rs
 delete mode 100644 src/ir/traversal.rs
 delete mode 100644 src/ir/ty.rs
 delete mode 100644 src/ir/var.rs
 delete mode 100644 src/lib.rs
 delete mode 100644 src/log_stubs.rs
 delete mode 100644 src/main.rs
 delete mode 100644 src/options.rs
 delete mode 100644 src/parse.rs
 delete mode 100644 src/regex_set.rs
 delete mode 100644 src/time.rs
 delete mode 100644 tests/.gitattributes
 delete mode 100644 tests/expectations/Cargo.toml
 delete mode 100644 tests/expectations/build.rs
 delete mode 100755 tests/expectations/lib.rs
 delete mode 100644 tests/expectations/src/lib.rs
 delete mode 100644 tests/expectations/struct_with_anon_struct_array_float.rs
 delete mode 100644 tests/expectations/tests/.gitattributes
 delete mode 100644 tests/expectations/tests/16-byte-alignment.rs
 delete mode 100644 tests/expectations/tests/16-byte-alignment_1_0.rs
 delete mode 100644 tests/expectations/tests/381-decltype-alias.rs
 delete mode 100644 tests/expectations/tests/accessors.rs
 delete mode 100644 tests/expectations/tests/allowlist-file.rs
 delete mode 100644 tests/expectations/tests/allowlist-namespaces-basic.rs
 delete mode 100644 tests/expectations/tests/allowlist-namespaces.rs
 delete mode 100644 tests/expectations/tests/allowlist_basic.rs
 delete mode 100644 tests/expectations/tests/allowlist_fix.rs
 delete mode 100644 tests/expectations/tests/allowlist_vars.rs
 delete mode 100644 tests/expectations/tests/allowlist_warnings.rs
 delete mode 100644 tests/expectations/tests/allowlisted-item-references-no-hash.rs
 delete mode 100644 tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
 delete mode 100644 tests/expectations/tests/allowlisted_item_references_no_copy.rs
 delete mode 100644 tests/expectations/tests/annotation_hide.rs
 delete mode 100644 tests/expectations/tests/anon-fields-prefix.rs
 delete mode 100644 tests/expectations/tests/anon_enum.rs
 delete mode 100644 tests/expectations/tests/anon_enum_allowlist.rs
 delete mode 100644 tests/expectations/tests/anon_enum_trait.rs
 delete mode 100644 tests/expectations/tests/anon_struct_in_union.rs
 delete mode 100644 tests/expectations/tests/anon_struct_in_union_1_0.rs
 delete mode 100644 tests/expectations/tests/anon_union.rs
 delete mode 100644 tests/expectations/tests/anon_union_1_0.rs
 delete mode 100644 tests/expectations/tests/anonymous-template-types.rs
 delete mode 100644 tests/expectations/tests/arg_keyword.rs
 delete mode 100644 tests/expectations/tests/array-of-zero-sized-types.rs
 delete mode 100644 tests/expectations/tests/attribute_warn_unused_result.rs
 delete mode 100644 tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
 delete mode 100644 tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
 delete mode 100644 tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
 delete mode 100644 tests/expectations/tests/base-to-derived.rs
 delete mode 100644 tests/expectations/tests/bindgen-union-inside-namespace.rs
 delete mode 100644 tests/expectations/tests/bitfield-32bit-overflow.rs
 delete mode 100644 tests/expectations/tests/bitfield-enum-basic.rs
 delete mode 100644 tests/expectations/tests/bitfield-enum-repr-c.rs
 delete mode 100644 tests/expectations/tests/bitfield-enum-repr-transparent.rs
 delete mode 100644 tests/expectations/tests/bitfield-large.rs
 delete mode 100644 tests/expectations/tests/bitfield-linux-32.rs
 delete mode 100644 tests/expectations/tests/bitfield-method-same-name.rs
 delete mode 100644 tests/expectations/tests/bitfield_align.rs
 delete mode 100644 tests/expectations/tests/bitfield_align_2.rs
 delete mode 100644 tests/expectations/tests/bitfield_large_overflow.rs
 delete mode 100644 tests/expectations/tests/bitfield_method_mangling.rs
 delete mode 100644 tests/expectations/tests/bitfield_pragma_packed.rs
 delete mode 100644 tests/expectations/tests/block_return_type.rs
 delete mode 100644 tests/expectations/tests/blocklist-and-impl-debug.rs
 delete mode 100644 tests/expectations/tests/blocklist-file.rs
 delete mode 100644 tests/expectations/tests/blocklist-function.rs
 delete mode 100644 tests/expectations/tests/blocklist-item.rs
 delete mode 100644 tests/expectations/tests/blocks-signature.rs
 delete mode 100644 tests/expectations/tests/blocks.rs
 delete mode 100644 tests/expectations/tests/bug-1529681.rs
 delete mode 100644 tests/expectations/tests/builtin-template.rs
 delete mode 100644 tests/expectations/tests/c-empty-layout.rs
 delete mode 100644 tests/expectations/tests/c_naming.rs
 delete mode 100644 tests/expectations/tests/call-conv-typedef.rs
 delete mode 100644 tests/expectations/tests/canonical-types.rs
 delete mode 100644 tests/expectations/tests/canonical_path_without_namespacing.rs
 delete mode 100644 tests/expectations/tests/char.rs
 delete mode 100644 tests/expectations/tests/class.rs
 delete mode 100644 tests/expectations/tests/class_1_0.rs
 delete mode 100644 tests/expectations/tests/class_nested.rs
 delete mode 100644 tests/expectations/tests/class_no_members.rs
 delete mode 100644 tests/expectations/tests/class_static.rs
 delete mode 100644 tests/expectations/tests/class_static_const.rs
 delete mode 100644 tests/expectations/tests/class_use_as.rs
 delete mode 100644 tests/expectations/tests/class_with_dtor.rs
 delete mode 100644 tests/expectations/tests/class_with_inner_struct.rs
 delete mode 100644 tests/expectations/tests/class_with_inner_struct_1_0.rs
 delete mode 100644 tests/expectations/tests/class_with_typedef.rs
 delete mode 100644 tests/expectations/tests/comment-indent.rs
 delete mode 100644 tests/expectations/tests/complex.rs
 delete mode 100644 tests/expectations/tests/complex_global.rs
 delete mode 100644 tests/expectations/tests/const-const-mut-ptr.rs
 delete mode 100644 tests/expectations/tests/const_array.rs
 delete mode 100644 tests/expectations/tests/const_array_fn_arg.rs
 delete mode 100644 tests/expectations/tests/const_enum_unnamed.rs
 delete mode 100644 tests/expectations/tests/const_multidim_array_fn_arg.rs
 delete mode 100644 tests/expectations/tests/const_ptr.rs
 delete mode 100644 tests/expectations/tests/const_resolved_ty.rs
 delete mode 100644 tests/expectations/tests/const_tparam.rs
 delete mode 100644 tests/expectations/tests/constant-non-specialized-tp.rs
 delete mode 100644 tests/expectations/tests/constified-enum-module-overflow.rs
 delete mode 100644 tests/expectations/tests/constify-all-enums.rs
 delete mode 100644 tests/expectations/tests/constify-enum.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-basic.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-namespace.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-shadow-name.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-simple-alias.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
 delete mode 100644 tests/expectations/tests/constify-module-enums-types.rs
 delete mode 100644 tests/expectations/tests/constructor-tp.rs
 delete mode 100644 tests/expectations/tests/constructors.rs
 delete mode 100644 tests/expectations/tests/constructors_1_33.rs
 delete mode 100644 tests/expectations/tests/contains-vs-inherits-zero-sized.rs
 delete mode 100644 tests/expectations/tests/convert-cpp-comment-to-rust.rs
 delete mode 100644 tests/expectations/tests/convert-floats.rs
 delete mode 100644 tests/expectations/tests/core_ffi_c.rs
 delete mode 100644 tests/expectations/tests/cpp-empty-layout.rs
 delete mode 100644 tests/expectations/tests/crtp.rs
 delete mode 100644 tests/expectations/tests/ctypes-prefix-path.rs
 delete mode 100644 tests/expectations/tests/dash_language.rs
 delete mode 100644 tests/expectations/tests/decl_extern_int_twice.rs
 delete mode 100644 tests/expectations/tests/decl_ptr_to_array.rs
 delete mode 100644 tests/expectations/tests/default-enum-style-constified-module.rs
 delete mode 100644 tests/expectations/tests/default-macro-constant-type-signed.rs
 delete mode 100644 tests/expectations/tests/default-macro-constant-type-unsigned.rs
 delete mode 100644 tests/expectations/tests/default-macro-constant-type.rs
 delete mode 100644 tests/expectations/tests/default-template-parameter.rs
 delete mode 100644 tests/expectations/tests/deleted-function.rs
 delete mode 100644 tests/expectations/tests/derive-bitfield-method-same-name.rs
 delete mode 100644 tests/expectations/tests/derive-clone.rs
 delete mode 100644 tests/expectations/tests/derive-clone_1_0.rs
 delete mode 100644 tests/expectations/tests/derive-custom.rs
 delete mode 100644 tests/expectations/tests/derive-debug-bitfield-core.rs
 delete mode 100644 tests/expectations/tests/derive-debug-bitfield.rs
 delete mode 100644 tests/expectations/tests/derive-debug-function-pointer.rs
 delete mode 100644 tests/expectations/tests/derive-debug-generic.rs
 delete mode 100644 tests/expectations/tests/derive-debug-mangle-name.rs
 delete mode 100644 tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
 delete mode 100644 tests/expectations/tests/derive-debug-opaque.rs
 delete mode 100644 tests/expectations/tests/derive-default-and-blocklist.rs
 delete mode 100644 tests/expectations/tests/derive-fn-ptr.rs
 delete mode 100644 tests/expectations/tests/derive-hash-and-blocklist.rs
 delete mode 100644 tests/expectations/tests/derive-hash-blocklisting.rs
 delete mode 100644 tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
 delete mode 100644 tests/expectations/tests/derive-hash-struct-with-float-array.rs
 delete mode 100644 tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
 delete mode 100644 tests/expectations/tests/derive-hash-struct-with-pointer.rs
 delete mode 100644 tests/expectations/tests/derive-hash-template-def-float.rs
 delete mode 100644 tests/expectations/tests/derive-hash-template-inst-float.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-and-blocklist.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-anonfield.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-base.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-bitfield.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-core.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-pointer.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-union.rs
 delete mode 100644 tests/expectations/tests/derive-partialeq-union_1_0.rs
 delete mode 100644 tests/expectations/tests/disable-namespacing.rs
 delete mode 100644 tests/expectations/tests/disable-nested-struct-naming.rs
 delete mode 100644 tests/expectations/tests/disable-untagged-union.rs
 delete mode 100644 tests/expectations/tests/divide-by-zero-in-struct-layout.rs
 delete mode 100644 tests/expectations/tests/do-not-derive-copy.rs
 delete mode 100644 tests/expectations/tests/doggo-or-null.rs
 delete mode 100644 tests/expectations/tests/dupe-enum-variant-in-namespace.rs
 delete mode 100644 tests/expectations/tests/duplicated-namespaces-definitions.rs
 delete mode 100644 tests/expectations/tests/duplicated-namespaces.rs
 delete mode 100644 tests/expectations/tests/duplicated_constants_in_ns.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_attributes.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_required.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_simple.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_template.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_with_allowlist.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_with_blocklist.rs
 delete mode 100644 tests/expectations/tests/dynamic_loading_with_class.rs
 delete mode 100644 tests/expectations/tests/elaborated.rs
 delete mode 100644 tests/expectations/tests/empty-enum.rs
 delete mode 100644 tests/expectations/tests/empty-union.rs
 delete mode 100644 tests/expectations/tests/empty_template_param_name.rs
 delete mode 100644 tests/expectations/tests/enum-default-bitfield.rs
 delete mode 100644 tests/expectations/tests/enum-default-consts.rs
 delete mode 100644 tests/expectations/tests/enum-default-module.rs
 delete mode 100644 tests/expectations/tests/enum-default-rust.d
 delete mode 100644 tests/expectations/tests/enum-default-rust.rs
 delete mode 100644 tests/expectations/tests/enum-doc-bitfield.rs
 delete mode 100644 tests/expectations/tests/enum-doc-mod.rs
 delete mode 100644 tests/expectations/tests/enum-doc-rusty.rs
 delete mode 100644 tests/expectations/tests/enum-doc.rs
 delete mode 100644 tests/expectations/tests/enum-no-debug-rust.rs
 delete mode 100644 tests/expectations/tests/enum-translate-type.rs
 delete mode 100644 tests/expectations/tests/enum-undefault.rs
 delete mode 100644 tests/expectations/tests/enum-variant-replaces.rs
 delete mode 100644 tests/expectations/tests/enum.rs
 delete mode 100644 tests/expectations/tests/enum_alias.rs
 delete mode 100644 tests/expectations/tests/enum_and_vtable_mangling.rs
 delete mode 100644 tests/expectations/tests/enum_dupe.rs
 delete mode 100644 tests/expectations/tests/enum_explicit_type.rs
 delete mode 100644 tests/expectations/tests/enum_explicit_type_constants.rs
 delete mode 100644 tests/expectations/tests/enum_in_template.rs
 delete mode 100644 tests/expectations/tests/enum_in_template_with_typedef.rs
 delete mode 100644 tests/expectations/tests/enum_negative.rs
 delete mode 100644 tests/expectations/tests/enum_packed.rs
 delete mode 100644 tests/expectations/tests/eval-value-dependent.rs
 delete mode 100644 tests/expectations/tests/eval-variadic-template-parameter.rs
 delete mode 100644 tests/expectations/tests/explicit-padding.rs
 delete mode 100644 tests/expectations/tests/extern-const-struct.rs
 delete mode 100644 tests/expectations/tests/extern.rs
 delete mode 100644 tests/expectations/tests/fit-macro-constant-types-signed.rs
 delete mode 100644 tests/expectations/tests/fit-macro-constant-types.rs
 delete mode 100644 tests/expectations/tests/float128.rs
 delete mode 100644 tests/expectations/tests/forward-declaration-autoptr.rs
 delete mode 100644 tests/expectations/tests/forward-enum-decl.rs
 delete mode 100644 tests/expectations/tests/forward-inherit-struct-with-fields.rs
 delete mode 100644 tests/expectations/tests/forward-inherit-struct.rs
 delete mode 100644 tests/expectations/tests/forward_declared_complex_types.rs
 delete mode 100644 tests/expectations/tests/forward_declared_complex_types_1_0.rs
 delete mode 100644 tests/expectations/tests/forward_declared_opaque.rs
 delete mode 100644 tests/expectations/tests/forward_declared_struct.rs
 delete mode 100644 tests/expectations/tests/func_proto.rs
 delete mode 100644 tests/expectations/tests/func_ptr.rs
 delete mode 100644 tests/expectations/tests/func_ptr_in_struct.rs
 delete mode 100644 tests/expectations/tests/func_ptr_return_type.rs
 delete mode 100644 tests/expectations/tests/func_return_must_use.rs
 delete mode 100644 tests/expectations/tests/func_with_array_arg.rs
 delete mode 100644 tests/expectations/tests/func_with_func_ptr_arg.rs
 delete mode 100644 tests/expectations/tests/function-typedef-stdcall.rs
 delete mode 100644 tests/expectations/tests/gen-constructors-neg.rs
 delete mode 100644 tests/expectations/tests/gen-constructors.rs
 delete mode 100644 tests/expectations/tests/gen-destructors-neg.rs
 delete mode 100644 tests/expectations/tests/gen-destructors.rs
 delete mode 100644 tests/expectations/tests/generate-inline.rs
 delete mode 100644 tests/expectations/tests/i128.rs
 delete mode 100644 tests/expectations/tests/in_class_typedef.rs
 delete mode 100644 tests/expectations/tests/incomplete-array-padding.rs
 delete mode 100644 tests/expectations/tests/infinite-macro.rs
 delete mode 100644 tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
 delete mode 100644 tests/expectations/tests/inherit-namespaced.rs
 delete mode 100644 tests/expectations/tests/inherit_named.rs
 delete mode 100644 tests/expectations/tests/inherit_typedef.rs
 delete mode 100644 tests/expectations/tests/inline-function.rs
 delete mode 100644 tests/expectations/tests/inline_namespace.rs
 delete mode 100644 tests/expectations/tests/inline_namespace_allowlist.rs
 delete mode 100644 tests/expectations/tests/inline_namespace_conservative.rs
 delete mode 100644 tests/expectations/tests/inline_namespace_no_ns_enabled.rs
 delete mode 100644 tests/expectations/tests/inner-typedef-gh422.rs
 delete mode 100644 tests/expectations/tests/inner_const.rs
 delete mode 100644 tests/expectations/tests/inner_template_self.rs
 delete mode 100644 tests/expectations/tests/int128_t.rs
 delete mode 100644 tests/expectations/tests/issue-1025-unknown-enum-repr.rs
 delete mode 100644 tests/expectations/tests/issue-1034.rs
 delete mode 100644 tests/expectations/tests/issue-1040.rs
 delete mode 100644 tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
 delete mode 100644 tests/expectations/tests/issue-1113-template-references.rs
 delete mode 100644 tests/expectations/tests/issue-1118-using-forward-decl.rs
 delete mode 100644 tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
 delete mode 100644 tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
 delete mode 100644 tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
 delete mode 100644 tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
 delete mode 100644 tests/expectations/tests/issue-1198-alias-rust-enum.rs
 delete mode 100644 tests/expectations/tests/issue-1216-variadic-member.rs
 delete mode 100644 tests/expectations/tests/issue-1238-fwd-no-copy.rs
 delete mode 100644 tests/expectations/tests/issue-1281.rs
 delete mode 100644 tests/expectations/tests/issue-1285.rs
 delete mode 100644 tests/expectations/tests/issue-1291.rs
 delete mode 100644 tests/expectations/tests/issue-1350-attribute-overloadable.rs
 delete mode 100644 tests/expectations/tests/issue-1382-rust-primitive-types.rs
 delete mode 100644 tests/expectations/tests/issue-1435.rs
 delete mode 100644 tests/expectations/tests/issue-1443.rs
 delete mode 100644 tests/expectations/tests/issue-1454.rs
 delete mode 100644 tests/expectations/tests/issue-1464.rs
 delete mode 100644 tests/expectations/tests/issue-1488-enum-new-type.rs
 delete mode 100644 tests/expectations/tests/issue-1488-options.rs
 delete mode 100644 tests/expectations/tests/issue-1488-template-alias-new-type.rs
 delete mode 100644 tests/expectations/tests/issue-1498.rs
 delete mode 100644 tests/expectations/tests/issue-1514.rs
 delete mode 100644 tests/expectations/tests/issue-1554.rs
 delete mode 100644 tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
 delete mode 100644 tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
 delete mode 100644 tests/expectations/tests/issue-1947.rs
 delete mode 100644 tests/expectations/tests/issue-1977-larger-arrays.rs
 delete mode 100644 tests/expectations/tests/issue-1995.rs
 delete mode 100644 tests/expectations/tests/issue-2019.rs
 delete mode 100644 tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
 delete mode 100644 tests/expectations/tests/issue-358.rs
 delete mode 100644 tests/expectations/tests/issue-372.rs
 delete mode 100644 tests/expectations/tests/issue-410.rs
 delete mode 100644 tests/expectations/tests/issue-446.rs
 delete mode 100644 tests/expectations/tests/issue-447.rs
 delete mode 100644 tests/expectations/tests/issue-493.rs
 delete mode 100644 tests/expectations/tests/issue-493_1_0.rs
 delete mode 100644 tests/expectations/tests/issue-511.rs
 delete mode 100644 tests/expectations/tests/issue-537-repr-packed-n.rs
 delete mode 100644 tests/expectations/tests/issue-537.rs
 delete mode 100644 tests/expectations/tests/issue-544-stylo-creduce-2.rs
 delete mode 100644 tests/expectations/tests/issue-544-stylo-creduce.rs
 delete mode 100644 tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
 delete mode 100644 tests/expectations/tests/issue-573-layout-test-failures.rs
 delete mode 100644 tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
 delete mode 100644 tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
 delete mode 100644 tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
 delete mode 100644 tests/expectations/tests/issue-639-typedef-anon-field.rs
 delete mode 100644 tests/expectations/tests/issue-643-inner-struct.rs
 delete mode 100644 tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
 delete mode 100644 tests/expectations/tests/issue-648-derive-debug-with-padding.rs
 delete mode 100644 tests/expectations/tests/issue-654-struct-fn-collision.rs
 delete mode 100644 tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
 delete mode 100644 tests/expectations/tests/issue-662-part-2.rs
 delete mode 100644 tests/expectations/tests/issue-674-1.rs
 delete mode 100644 tests/expectations/tests/issue-674-2.rs
 delete mode 100644 tests/expectations/tests/issue-674-3.rs
 delete mode 100644 tests/expectations/tests/issue-677-nested-ns-specifier.rs
 delete mode 100644 tests/expectations/tests/issue-691-template-parameter-virtual.rs
 delete mode 100644 tests/expectations/tests/issue-710-must-use-type.rs
 delete mode 100644 tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
 delete mode 100644 tests/expectations/tests/issue-801-opaque-sloppiness.rs
 delete mode 100644 tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
 delete mode 100644 tests/expectations/tests/issue-816.rs
 delete mode 100644 tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
 delete mode 100644 tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
 delete mode 100644 tests/expectations/tests/issue-833-1.rs
 delete mode 100644 tests/expectations/tests/issue-833-2.rs
 delete mode 100644 tests/expectations/tests/issue-833.rs
 delete mode 100644 tests/expectations/tests/issue-834.rs
 delete mode 100644 tests/expectations/tests/issue-848-replacement-system-include.rs
 delete mode 100644 tests/expectations/tests/issue-888-enum-var-decl-jump.rs
 delete mode 100644 tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
 delete mode 100644 tests/expectations/tests/issue-946.rs
 delete mode 100644 tests/expectations/tests/issue_311.rs
 delete mode 100644 tests/expectations/tests/issue_315.rs
 delete mode 100644 tests/expectations/tests/jsval_layout_opaque.rs
 delete mode 100644 tests/expectations/tests/jsval_layout_opaque_1_0.rs
 delete mode 100644 tests/expectations/tests/keywords.rs
 delete mode 100644 tests/expectations/tests/layout.rs
 delete mode 100644 tests/expectations/tests/layout_align.rs
 delete mode 100644 tests/expectations/tests/layout_arp.rs
 delete mode 100644 tests/expectations/tests/layout_array.rs
 delete mode 100644 tests/expectations/tests/layout_array_too_long.rs
 delete mode 100644 tests/expectations/tests/layout_cmdline_token.rs
 delete mode 100644 tests/expectations/tests/layout_eth_conf.rs
 delete mode 100644 tests/expectations/tests/layout_eth_conf_1_0.rs
 delete mode 100644 tests/expectations/tests/layout_kni_mbuf.rs
 delete mode 100644 tests/expectations/tests/layout_large_align_field.rs
 delete mode 100644 tests/expectations/tests/layout_mbuf.rs
 delete mode 100644 tests/expectations/tests/layout_mbuf_1_0.rs
 delete mode 100644 tests/expectations/tests/libclang-5/abi_variadic_function.rs
 delete mode 100644 tests/expectations/tests/libclang-5/auto.rs
 delete mode 100644 tests/expectations/tests/libclang-5/call-conv-field.rs
 delete mode 100644 tests/expectations/tests/libclang-5/const_bool.rs
 delete mode 100644 tests/expectations/tests/libclang-5/constant-evaluate.rs
 delete mode 100644 tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
 delete mode 100644 tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
 delete mode 100644 tests/expectations/tests/libclang-5/mangling-win32.rs
 delete mode 100644 tests/expectations/tests/libclang-5/objc_inheritance.rs
 delete mode 100644 tests/expectations/tests/libclang-5/objc_template.rs
 delete mode 100644 tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
 delete mode 100644 tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
 delete mode 100644 tests/expectations/tests/libclang-9/abi_variadic_function.rs
 delete mode 100644 tests/expectations/tests/libclang-9/auto.rs
 delete mode 100644 tests/expectations/tests/libclang-9/call-conv-field.rs
 delete mode 100644 tests/expectations/tests/libclang-9/class.rs
 delete mode 100644 tests/expectations/tests/libclang-9/class_1_0.rs
 delete mode 100644 tests/expectations/tests/libclang-9/const_bool.rs
 delete mode 100644 tests/expectations/tests/libclang-9/constant-evaluate.rs
 delete mode 100644 tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
 delete mode 100644 tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
 delete mode 100644 tests/expectations/tests/libclang-9/incomplete-array-padding.rs
 delete mode 100644 tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
 delete mode 100644 tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
 delete mode 100644 tests/expectations/tests/libclang-9/layout_align.rs
 delete mode 100644 tests/expectations/tests/libclang-9/mangling-win32.rs
 delete mode 100644 tests/expectations/tests/libclang-9/objc_inheritance.rs
 delete mode 100644 tests/expectations/tests/libclang-9/objc_template.rs
 delete mode 100644 tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
 delete mode 100644 tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
 delete mode 100644 tests/expectations/tests/libclang-9/zero-sized-array.rs
 delete mode 100644 tests/expectations/tests/libclang_version_specific_generated_tests.rs
 delete mode 100644 tests/expectations/tests/long_double.rs
 delete mode 100644 tests/expectations/tests/macro-expr-basic.rs
 delete mode 100644 tests/expectations/tests/macro-expr-uncommon-token.rs
 delete mode 100644 tests/expectations/tests/macro-redef.rs
 delete mode 100644 tests/expectations/tests/macro_const.rs
 delete mode 100644 tests/expectations/tests/macro_const_1_0.rs
 delete mode 100644 tests/expectations/tests/maddness-is-avoidable.rs
 delete mode 100644 tests/expectations/tests/mangling-ios.rs
 delete mode 100644 tests/expectations/tests/mangling-linux32.rs
 delete mode 100644 tests/expectations/tests/mangling-linux64.rs
 delete mode 100644 tests/expectations/tests/mangling-macos.rs
 delete mode 100644 tests/expectations/tests/mangling-win64.rs
 delete mode 100644 tests/expectations/tests/merge-extern-blocks.rs
 delete mode 100644 tests/expectations/tests/method-mangling.rs
 delete mode 100644 tests/expectations/tests/module-allowlisted.rs
 delete mode 100644 tests/expectations/tests/msvc-no-usr.rs
 delete mode 100644 tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
 delete mode 100644 tests/expectations/tests/mutable.rs
 delete mode 100644 tests/expectations/tests/namespace.rs
 delete mode 100644 tests/expectations/tests/nested-template-typedef.rs
 delete mode 100644 tests/expectations/tests/nested.rs
 delete mode 100644 tests/expectations/tests/nested_vtable.rs
 delete mode 100644 tests/expectations/tests/nested_within_namespace.rs
 delete mode 100644 tests/expectations/tests/newtype-enum.rs
 delete mode 100644 tests/expectations/tests/newtype-global-enum.rs
 delete mode 100644 tests/expectations/tests/no-comments.rs
 delete mode 100644 tests/expectations/tests/no-derive-debug.rs
 delete mode 100644 tests/expectations/tests/no-derive-default.rs
 delete mode 100644 tests/expectations/tests/no-hash-allowlisted.rs
 delete mode 100644 tests/expectations/tests/no-hash-opaque.rs
 delete mode 100644 tests/expectations/tests/no-partialeq-allowlisted.rs
 delete mode 100644 tests/expectations/tests/no-partialeq-opaque.rs
 delete mode 100644 tests/expectations/tests/no-recursive-allowlisting.rs
 delete mode 100644 tests/expectations/tests/no-std.rs
 delete mode 100644 tests/expectations/tests/no_copy.rs
 delete mode 100644 tests/expectations/tests/no_copy_allowlisted.rs
 delete mode 100644 tests/expectations/tests/no_copy_opaque.rs
 delete mode 100644 tests/expectations/tests/no_debug.rs
 delete mode 100644 tests/expectations/tests/no_debug_allowlisted.rs
 delete mode 100644 tests/expectations/tests/no_debug_bypass_impl_debug.rs
 delete mode 100644 tests/expectations/tests/no_debug_opaque.rs
 delete mode 100644 tests/expectations/tests/no_default.rs
 delete mode 100644 tests/expectations/tests/no_default_allowlisted.rs
 delete mode 100644 tests/expectations/tests/no_default_bypass_derive_default.rs
 delete mode 100644 tests/expectations/tests/no_default_opaque.rs
 delete mode 100644 tests/expectations/tests/no_size_t_is_usize.rs
 delete mode 100644 tests/expectations/tests/non-type-params.rs
 delete mode 100644 tests/expectations/tests/noreturn.rs
 delete mode 100644 tests/expectations/tests/nsBaseHashtable.rs
 delete mode 100644 tests/expectations/tests/nsStyleAutoArray.rs
 delete mode 100644 tests/expectations/tests/objc_allowlist.rs
 delete mode 100644 tests/expectations/tests/objc_blocklist.rs
 delete mode 100644 tests/expectations/tests/objc_category.rs
 delete mode 100644 tests/expectations/tests/objc_class.rs
 delete mode 100644 tests/expectations/tests/objc_class_method.rs
 delete mode 100644 tests/expectations/tests/objc_interface.rs
 delete mode 100644 tests/expectations/tests/objc_interface_type.rs
 delete mode 100644 tests/expectations/tests/objc_method.rs
 delete mode 100644 tests/expectations/tests/objc_method_clash.rs
 delete mode 100644 tests/expectations/tests/objc_pointer_return_types.rs
 delete mode 100644 tests/expectations/tests/objc_property_fnptr.rs
 delete mode 100644 tests/expectations/tests/objc_protocol.rs
 delete mode 100644 tests/expectations/tests/objc_protocol_inheritance.rs
 delete mode 100644 tests/expectations/tests/objc_sel_and_id.rs
 delete mode 100644 tests/expectations/tests/only_bitfields.rs
 delete mode 100644 tests/expectations/tests/opaque-template-inst-member-2.rs
 delete mode 100644 tests/expectations/tests/opaque-template-inst-member.rs
 delete mode 100644 tests/expectations/tests/opaque-template-instantiation-namespaced.rs
 delete mode 100644 tests/expectations/tests/opaque-template-instantiation.rs
 delete mode 100644 tests/expectations/tests/opaque-tracing.rs
 delete mode 100644 tests/expectations/tests/opaque_in_struct.rs
 delete mode 100644 tests/expectations/tests/opaque_pointer.rs
 delete mode 100644 tests/expectations/tests/opaque_typedef.rs
 delete mode 100644 tests/expectations/tests/operator.rs
 delete mode 100644 tests/expectations/tests/ord-enum.rs
 delete mode 100644 tests/expectations/tests/overflowed_enum.rs
 delete mode 100644 tests/expectations/tests/overloading.rs
 delete mode 100644 tests/expectations/tests/packed-bitfield.rs
 delete mode 100644 tests/expectations/tests/packed-n-with-padding.rs
 delete mode 100644 tests/expectations/tests/packed-vtable.rs
 delete mode 100644 tests/expectations/tests/parm-union.rs
 delete mode 100644 tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
 delete mode 100644 tests/expectations/tests/pointer-attr.rs
 delete mode 100644 tests/expectations/tests/prepend-enum-constified-variant.rs
 delete mode 100644 tests/expectations/tests/prepend_enum_name.rs
 delete mode 100644 tests/expectations/tests/private.rs
 delete mode 100644 tests/expectations/tests/private_fields.rs
 delete mode 100644 tests/expectations/tests/public-dtor.rs
 delete mode 100644 tests/expectations/tests/qualified-dependent-types.rs
 delete mode 100644 tests/expectations/tests/redeclaration.rs
 delete mode 100644 tests/expectations/tests/ref_argument_array.rs
 delete mode 100644 tests/expectations/tests/reparented_replacement.rs
 delete mode 100644 tests/expectations/tests/replace_template_alias.rs
 delete mode 100644 tests/expectations/tests/replace_use.rs
 delete mode 100644 tests/expectations/tests/replaces_double.rs
 delete mode 100644 tests/expectations/tests/repr-align.rs
 delete mode 100644 tests/expectations/tests/resolved_type_def_function.rs
 delete mode 100644 tests/expectations/tests/same_struct_name_in_different_namespaces.rs
 delete mode 100644 tests/expectations/tests/sentry-defined-multiple-times.rs
 delete mode 100644 tests/expectations/tests/short-enums.rs
 delete mode 100644 tests/expectations/tests/size_t_template.rs
 delete mode 100644 tests/expectations/tests/sorted-items.rs
 delete mode 100644 tests/expectations/tests/stdint_typedef.rs
 delete mode 100644 tests/expectations/tests/struct_containing_forward_declared_struct.rs
 delete mode 100644 tests/expectations/tests/struct_typedef.rs
 delete mode 100644 tests/expectations/tests/struct_typedef_ns.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_struct.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_struct_array.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_struct_pointer.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_union.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_union_1_0.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_unnamed_struct.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_unnamed_union.rs
 delete mode 100644 tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
 delete mode 100644 tests/expectations/tests/struct_with_bitfields.rs
 delete mode 100644 tests/expectations/tests/struct_with_derive_debug.rs
 delete mode 100644 tests/expectations/tests/struct_with_large_array.rs
 delete mode 100644 tests/expectations/tests/struct_with_nesting.rs
 delete mode 100644 tests/expectations/tests/struct_with_nesting_1_0.rs
 delete mode 100644 tests/expectations/tests/struct_with_packing.rs
 delete mode 100644 tests/expectations/tests/struct_with_struct.rs
 delete mode 100644 tests/expectations/tests/struct_with_typedef_template_arg.rs
 delete mode 100644 tests/expectations/tests/template-fun-ty.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-0.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-1.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-10.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-11.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-12.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-13.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-14.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-15.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-2.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-3.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-4.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-5.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-6.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-7.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-8.rs
 delete mode 100644 tests/expectations/tests/template-param-usage-9.rs
 delete mode 100644 tests/expectations/tests/template-with-var.rs
 delete mode 100644 tests/expectations/tests/template.rs
 delete mode 100644 tests/expectations/tests/template_alias.rs
 delete mode 100644 tests/expectations/tests/template_alias_basic.rs
 delete mode 100644 tests/expectations/tests/template_alias_namespace.rs
 delete mode 100644 tests/expectations/tests/template_fun.rs
 delete mode 100644 tests/expectations/tests/template_instantiation_with_fn_local_type.rs
 delete mode 100644 tests/expectations/tests/template_partial_specification.rs
 delete mode 100644 tests/expectations/tests/template_typedef_transitive_param.rs
 delete mode 100644 tests/expectations/tests/template_typedefs.rs
 delete mode 100644 tests/expectations/tests/templateref_opaque.rs
 delete mode 100644 tests/expectations/tests/templatized-bitfield.rs
 delete mode 100644 tests/expectations/tests/test_mixed_header_and_header_contents.rs
 delete mode 100644 tests/expectations/tests/test_multiple_header_calls_in_builder.rs
 delete mode 100644 tests/expectations/tests/timex.rs
 delete mode 100644 tests/expectations/tests/transform-op.rs
 delete mode 100644 tests/expectations/tests/type-referenced-by-allowlisted-function.rs
 delete mode 100644 tests/expectations/tests/type_alias_empty.rs
 delete mode 100644 tests/expectations/tests/type_alias_partial_template_especialization.rs
 delete mode 100644 tests/expectations/tests/typedefd-array-as-function-arg.rs
 delete mode 100644 tests/expectations/tests/typeref.rs
 delete mode 100644 tests/expectations/tests/typeref_1_0.rs
 delete mode 100644 tests/expectations/tests/underscore.rs
 delete mode 100644 tests/expectations/tests/union-align.rs
 delete mode 100644 tests/expectations/tests/union-in-ns.rs
 delete mode 100644 tests/expectations/tests/union-in-ns_1_0.rs
 delete mode 100644 tests/expectations/tests/union_bitfield.rs
 delete mode 100644 tests/expectations/tests/union_bitfield_1_0.rs
 delete mode 100644 tests/expectations/tests/union_dtor.rs
 delete mode 100644 tests/expectations/tests/union_dtor_1_0.rs
 delete mode 100644 tests/expectations/tests/union_fields.rs
 delete mode 100644 tests/expectations/tests/union_fields_1_0.rs
 delete mode 100644 tests/expectations/tests/union_template.rs
 delete mode 100644 tests/expectations/tests/union_template_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_struct.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_struct_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_struct_bitfield.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_union.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_union_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_unnamed_struct.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_unnamed_union.rs
 delete mode 100644 tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_big_member.rs
 delete mode 100644 tests/expectations/tests/union_with_big_member_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_nesting.rs
 delete mode 100644 tests/expectations/tests/union_with_nesting_1_0.rs
 delete mode 100644 tests/expectations/tests/union_with_non_copy_member.rs
 delete mode 100644 tests/expectations/tests/unknown_attr.rs
 delete mode 100644 tests/expectations/tests/unsorted-items.rs
 delete mode 100644 tests/expectations/tests/use-core.rs
 delete mode 100644 tests/expectations/tests/use-core_1_0.rs
 delete mode 100644 tests/expectations/tests/using.rs
 delete mode 100644 tests/expectations/tests/var-tracing.rs
 delete mode 100644 tests/expectations/tests/variadic-method.rs
 delete mode 100644 tests/expectations/tests/variadic_template_function.rs
 delete mode 100644 tests/expectations/tests/vector.rs
 delete mode 100644 tests/expectations/tests/virtual_dtor.rs
 delete mode 100644 tests/expectations/tests/virtual_inheritance.rs
 delete mode 100644 tests/expectations/tests/virtual_interface.rs
 delete mode 100644 tests/expectations/tests/virtual_overloaded.rs
 delete mode 100644 tests/expectations/tests/vtable_recursive_sig.rs
 delete mode 100644 tests/expectations/tests/wasm-constructor-returns.rs
 delete mode 100644 tests/expectations/tests/wasm-import-module.rs
 delete mode 100644 tests/expectations/tests/weird_bitfields.rs
 delete mode 100644 tests/expectations/tests/what_is_going_on.rs
 delete mode 100644 tests/expectations/tests/win32-thiscall_1_0.rs
 delete mode 100644 tests/expectations/tests/win32-thiscall_nightly.rs
 delete mode 100644 tests/expectations/tests/win32-vectorcall-1_0.rs
 delete mode 100644 tests/expectations/tests/win32-vectorcall-nightly.rs
 delete mode 100644 tests/expectations/tests/with_array_pointers_arguments.rs
 delete mode 100644 tests/expectations/tests/without_array_pointers_arguments.rs
 delete mode 100644 tests/expectations/tests/zero-size-array-align.rs
 delete mode 100644 tests/expectations/tests/zero-sized-array.rs
 delete mode 100644 tests/headers/16-byte-alignment.h
 delete mode 100644 tests/headers/16-byte-alignment_1_0.h
 delete mode 100644 tests/headers/381-decltype-alias.hpp
 delete mode 100644 tests/headers/abi_variadic_function.hpp
 delete mode 100644 tests/headers/accessors.hpp
 delete mode 100644 tests/headers/allowlist-file.hpp
 delete mode 100644 tests/headers/allowlist-namespaces-basic.hpp
 delete mode 100644 tests/headers/allowlist-namespaces.hpp
 delete mode 100644 tests/headers/allowlist_basic.hpp
 delete mode 100644 tests/headers/allowlist_fix.hpp
 delete mode 100644 tests/headers/allowlist_vars.h
 delete mode 100644 tests/headers/allowlist_warnings.h
 delete mode 100644 tests/headers/allowlisted-item-references-no-hash.hpp
 delete mode 100644 tests/headers/allowlisted-item-references-no-partialeq.hpp
 delete mode 100644 tests/headers/allowlisted/file.hpp
 delete mode 100644 tests/headers/allowlisted_item_references_no_copy.hpp
 delete mode 100644 tests/headers/annotation_hide.hpp
 delete mode 100644 tests/headers/anon-fields-prefix.h
 delete mode 100644 tests/headers/anon_enum.hpp
 delete mode 100644 tests/headers/anon_enum_allowlist.h
 delete mode 100644 tests/headers/anon_enum_trait.hpp
 delete mode 100644 tests/headers/anon_struct_in_union.h
 delete mode 100644 tests/headers/anon_struct_in_union_1_0.h
 delete mode 100644 tests/headers/anon_union.hpp
 delete mode 100644 tests/headers/anon_union_1_0.hpp
 delete mode 100644 tests/headers/anonymous-template-types.hpp
 delete mode 100644 tests/headers/arg_keyword.hpp
 delete mode 100644 tests/headers/array-of-zero-sized-types.hpp
 delete mode 100644 tests/headers/attribute_warn_unused_result.hpp
 delete mode 100644 tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
 delete mode 100644 tests/headers/attribute_warn_unused_result_pre_1_27.hpp
 delete mode 100644 tests/headers/auto.hpp
 delete mode 100644 tests/headers/bad-namespace-parenthood-inheritance.hpp
 delete mode 100644 tests/headers/base-to-derived.hpp
 delete mode 100644 tests/headers/bindgen-union-inside-namespace.hpp
 delete mode 100644 tests/headers/bitfield-32bit-overflow.h
 delete mode 100644 tests/headers/bitfield-enum-basic.hpp
 delete mode 100644 tests/headers/bitfield-enum-repr-c.hpp
 delete mode 100644 tests/headers/bitfield-enum-repr-transparent.hpp
 delete mode 100644 tests/headers/bitfield-large.hpp
 delete mode 100644 tests/headers/bitfield-linux-32.hpp
 delete mode 100644 tests/headers/bitfield-method-same-name.hpp
 delete mode 100644 tests/headers/bitfield_align.h
 delete mode 100644 tests/headers/bitfield_align_2.h
 delete mode 100644 tests/headers/bitfield_large_overflow.hpp
 delete mode 100644 tests/headers/bitfield_method_mangling.h
 delete mode 100644 tests/headers/bitfield_pragma_packed.h
 delete mode 100644 tests/headers/block_return_type.h
 delete mode 100644 tests/headers/blocklist-and-impl-debug.hpp
 delete mode 100644 tests/headers/blocklist-file.hpp
 delete mode 100644 tests/headers/blocklist-function.hpp
 delete mode 100644 tests/headers/blocklist-item.hpp
 delete mode 100644 tests/headers/blocklisted/fake-stdint.h
 delete mode 100644 tests/headers/blocklisted/file.hpp
 delete mode 100644 tests/headers/blocks-signature.hpp
 delete mode 100644 tests/headers/blocks.hpp
 delete mode 100644 tests/headers/bug-1529681.hpp
 delete mode 100644 tests/headers/builtin-template.hpp
 delete mode 100644 tests/headers/c-empty-layout.h
 delete mode 100644 tests/headers/c_naming.h
 delete mode 100644 tests/headers/call-conv-field.h
 delete mode 100644 tests/headers/call-conv-typedef.h
 delete mode 100644 tests/headers/canonical-types.hpp
 delete mode 100644 tests/headers/canonical_path_without_namespacing.hpp
 delete mode 100644 tests/headers/char.h
 delete mode 100644 tests/headers/class.hpp
 delete mode 100644 tests/headers/class_1_0.hpp
 delete mode 100644 tests/headers/class_nested.hpp
 delete mode 100644 tests/headers/class_no_members.hpp
 delete mode 100644 tests/headers/class_static.hpp
 delete mode 100644 tests/headers/class_static_const.hpp
 delete mode 100644 tests/headers/class_use_as.hpp
 delete mode 100644 tests/headers/class_with_dtor.hpp
 delete mode 100644 tests/headers/class_with_inner_struct.hpp
 delete mode 100644 tests/headers/class_with_inner_struct_1_0.hpp
 delete mode 100644 tests/headers/class_with_typedef.hpp
 delete mode 100644 tests/headers/comment-indent.hpp
 delete mode 100644 tests/headers/complex.h
 delete mode 100644 tests/headers/complex_global.h
 delete mode 100644 tests/headers/const-const-mut-ptr.h
 delete mode 100644 tests/headers/const_array.h
 delete mode 100644 tests/headers/const_array_fn_arg.h
 delete mode 100644 tests/headers/const_bool.hpp
 delete mode 100644 tests/headers/const_enum_unnamed.hpp
 delete mode 100644 tests/headers/const_multidim_array_fn_arg.h
 delete mode 100644 tests/headers/const_ptr.hpp
 delete mode 100644 tests/headers/const_resolved_ty.h
 delete mode 100644 tests/headers/const_tparam.hpp
 delete mode 100644 tests/headers/constant-evaluate.h
 delete mode 100644 tests/headers/constant-non-specialized-tp.hpp
 delete mode 100644 tests/headers/constified-enum-module-overflow.hpp
 delete mode 100644 tests/headers/constify-all-enums.h
 delete mode 100644 tests/headers/constify-enum.h
 delete mode 100644 tests/headers/constify-module-enums-basic.h
 delete mode 100644 tests/headers/constify-module-enums-namespace.hpp
 delete mode 100644 tests/headers/constify-module-enums-shadow-name.h
 delete mode 100644 tests/headers/constify-module-enums-simple-alias.hpp
 delete mode 100644 tests/headers/constify-module-enums-simple-nonamespace.hpp
 delete mode 100644 tests/headers/constify-module-enums-types.hpp
 delete mode 100644 tests/headers/constructor-tp.hpp
 delete mode 100644 tests/headers/constructors.hpp
 delete mode 100644 tests/headers/constructors_1_33.hpp
 delete mode 100644 tests/headers/contains-vs-inherits-zero-sized.hpp
 delete mode 100644 tests/headers/convert-cpp-comment-to-rust.hpp
 delete mode 100644 tests/headers/convert-floats.h
 delete mode 100644 tests/headers/core_ffi_c.h
 delete mode 100644 tests/headers/cpp-empty-layout.hpp
 delete mode 100644 tests/headers/crtp.hpp
 delete mode 100644 tests/headers/ctypes-prefix-path.h
 delete mode 100644 tests/headers/dash_language.h
 delete mode 100644 tests/headers/decl_extern_int_twice.h
 delete mode 100644 tests/headers/decl_ptr_to_array.h
 delete mode 100644 tests/headers/default-enum-style-constified-module.h
 delete mode 100644 tests/headers/default-macro-constant-type-signed.h
 delete mode 100644 tests/headers/default-macro-constant-type-unsigned.h
 delete mode 100644 tests/headers/default-macro-constant-type.h
 delete mode 100644 tests/headers/default-template-parameter.hpp
 delete mode 100644 tests/headers/deleted-function.hpp
 delete mode 100644 tests/headers/derive-bitfield-method-same-name.hpp
 delete mode 100644 tests/headers/derive-clone.h
 delete mode 100644 tests/headers/derive-clone_1_0.h
 delete mode 100644 tests/headers/derive-custom.h
 delete mode 100644 tests/headers/derive-debug-bitfield-core.hpp
 delete mode 100644 tests/headers/derive-debug-bitfield.hpp
 delete mode 100644 tests/headers/derive-debug-function-pointer.hpp
 delete mode 100644 tests/headers/derive-debug-generic.hpp
 delete mode 100644 tests/headers/derive-debug-mangle-name.h
 delete mode 100644 tests/headers/derive-debug-opaque-template-instantiation.hpp
 delete mode 100644 tests/headers/derive-debug-opaque.hpp
 delete mode 100644 tests/headers/derive-default-and-blocklist.hpp
 delete mode 100644 tests/headers/derive-fn-ptr.h
 delete mode 100644 tests/headers/derive-hash-and-blocklist.hpp
 delete mode 100644 tests/headers/derive-hash-blocklisting.hpp
 delete mode 100644 tests/headers/derive-hash-struct-with-anon-struct-float.h
 delete mode 100644 tests/headers/derive-hash-struct-with-float-array.h
 delete mode 100644 tests/headers/derive-hash-struct-with-incomplete-array.h
 delete mode 100644 tests/headers/derive-hash-struct-with-pointer.h
 delete mode 100644 tests/headers/derive-hash-template-def-float.hpp
 delete mode 100644 tests/headers/derive-hash-template-inst-float.hpp
 delete mode 100644 tests/headers/derive-partialeq-and-blocklist.hpp
 delete mode 100644 tests/headers/derive-partialeq-anonfield.h
 delete mode 100644 tests/headers/derive-partialeq-base.hpp
 delete mode 100644 tests/headers/derive-partialeq-bitfield.hpp
 delete mode 100644 tests/headers/derive-partialeq-core.h
 delete mode 100644 tests/headers/derive-partialeq-pointer.hpp
 delete mode 100644 tests/headers/derive-partialeq-union.hpp
 delete mode 100644 tests/headers/derive-partialeq-union_1_0.hpp
 delete mode 100644 tests/headers/disable-namespacing.hpp
 delete mode 100644 tests/headers/disable-nested-struct-naming.h
 delete mode 100644 tests/headers/disable-untagged-union.hpp
 delete mode 100644 tests/headers/divide-by-zero-in-struct-layout.h
 delete mode 100644 tests/headers/do-not-derive-copy.hpp
 delete mode 100644 tests/headers/doggo-or-null.hpp
 delete mode 100644 tests/headers/dupe-enum-variant-in-namespace.h
 delete mode 100644 tests/headers/duplicated-namespaces-definitions.hpp
 delete mode 100644 tests/headers/duplicated-namespaces.hpp
 delete mode 100644 tests/headers/duplicated_constants_in_ns.hpp
 delete mode 100644 tests/headers/dynamic_loading_attributes.h
 delete mode 100644 tests/headers/dynamic_loading_required.h
 delete mode 100644 tests/headers/dynamic_loading_simple.h
 delete mode 100644 tests/headers/dynamic_loading_template.hpp
 delete mode 100644 tests/headers/dynamic_loading_with_allowlist.hpp
 delete mode 100644 tests/headers/dynamic_loading_with_blocklist.hpp
 delete mode 100644 tests/headers/dynamic_loading_with_class.hpp
 delete mode 100644 tests/headers/elaborated.hpp
 delete mode 100644 tests/headers/empty-enum.h
 delete mode 100644 tests/headers/empty-union.hpp
 delete mode 100644 tests/headers/empty_template_param_name.hpp
 delete mode 100644 tests/headers/enum-default-bitfield.h
 delete mode 100644 tests/headers/enum-default-consts.h
 delete mode 100644 tests/headers/enum-default-module.h
 delete mode 100644 tests/headers/enum-default-rust.h
 delete mode 100644 tests/headers/enum-doc-bitfield.h
 delete mode 100644 tests/headers/enum-doc-mod.h
 delete mode 100644 tests/headers/enum-doc-rusty.h
 delete mode 100644 tests/headers/enum-doc.h
 delete mode 100644 tests/headers/enum-no-debug-rust.h
 delete mode 100644 tests/headers/enum-translate-type.hpp
 delete mode 100644 tests/headers/enum-undefault.h
 delete mode 100644 tests/headers/enum-variant-replaces.h
 delete mode 100644 tests/headers/enum.h
 delete mode 100644 tests/headers/enum_alias.hpp
 delete mode 100644 tests/headers/enum_and_vtable_mangling.hpp
 delete mode 100644 tests/headers/enum_dupe.h
 delete mode 100644 tests/headers/enum_explicit_type.hpp
 delete mode 100644 tests/headers/enum_explicit_type_constants.hpp
 delete mode 100644 tests/headers/enum_in_template.hpp
 delete mode 100644 tests/headers/enum_in_template_with_typedef.hpp
 delete mode 100644 tests/headers/enum_negative.h
 delete mode 100644 tests/headers/enum_packed.h
 delete mode 100644 tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
 delete mode 100644 tests/headers/eval-value-dependent.hpp
 delete mode 100644 tests/headers/eval-variadic-template-parameter.hpp
 delete mode 100644 tests/headers/explicit-padding.h
 delete mode 100644 tests/headers/extern-const-struct.h
 delete mode 100644 tests/headers/extern.hpp
 delete mode 100644 tests/headers/fit-macro-constant-types-signed.h
 delete mode 100644 tests/headers/fit-macro-constant-types.h
 delete mode 100644 tests/headers/float128.hpp
 delete mode 100644 tests/headers/forward-declaration-autoptr.hpp
 delete mode 100644 tests/headers/forward-enum-decl.hpp
 delete mode 100644 tests/headers/forward-inherit-struct-with-fields.hpp
 delete mode 100644 tests/headers/forward-inherit-struct.hpp
 delete mode 100644 tests/headers/forward_declared_complex_types.hpp
 delete mode 100644 tests/headers/forward_declared_complex_types_1_0.hpp
 delete mode 100644 tests/headers/forward_declared_opaque.h
 delete mode 100644 tests/headers/forward_declared_struct.h
 delete mode 100644 tests/headers/func_proto.h
 delete mode 100644 tests/headers/func_ptr.h
 delete mode 100644 tests/headers/func_ptr_in_struct.h
 delete mode 100644 tests/headers/func_ptr_return_type.h
 delete mode 100644 tests/headers/func_return_must_use.h
 delete mode 100644 tests/headers/func_with_array_arg.h
 delete mode 100644 tests/headers/func_with_func_ptr_arg.h
 delete mode 100644 tests/headers/function-typedef-stdcall.h
 delete mode 100644 tests/headers/gen-constructors-neg.hpp
 delete mode 100644 tests/headers/gen-constructors.hpp
 delete mode 100644 tests/headers/gen-destructors-neg.hpp
 delete mode 100644 tests/headers/gen-destructors.hpp
 delete mode 100644 tests/headers/generate-inline.hpp
 delete mode 100644 tests/headers/i128.h
 delete mode 100644 tests/headers/in_class_typedef.hpp
 delete mode 100644 tests/headers/incomplete-array-padding.h
 delete mode 100644 tests/headers/infinite-macro.h
 delete mode 100644 tests/headers/inherit-from-template-instantiation-with-vtable.hpp
 delete mode 100644 tests/headers/inherit-namespaced.hpp
 delete mode 100644 tests/headers/inherit_named.hpp
 delete mode 100644 tests/headers/inherit_typedef.hpp
 delete mode 100644 tests/headers/inline-function.h
 delete mode 100644 tests/headers/inline_namespace.hpp
 delete mode 100644 tests/headers/inline_namespace_allowlist.hpp
 delete mode 100644 tests/headers/inline_namespace_conservative.hpp
 delete mode 100644 tests/headers/inline_namespace_no_ns_enabled.hpp
 delete mode 100644 tests/headers/inner-typedef-gh422.hpp
 delete mode 100644 tests/headers/inner_const.hpp
 delete mode 100644 tests/headers/inner_template_self.hpp
 delete mode 100644 tests/headers/int128_t.h
 delete mode 100644 tests/headers/issue-1025-unknown-enum-repr.hpp
 delete mode 100644 tests/headers/issue-1034.h
 delete mode 100644 tests/headers/issue-1040.h
 delete mode 100644 tests/headers/issue-1076-unnamed-bitfield-alignment.h
 delete mode 100644 tests/headers/issue-1113-template-references.hpp
 delete mode 100644 tests/headers/issue-1118-using-forward-decl.hpp
 delete mode 100644 tests/headers/issue-1197-pure-virtual-stuff.hpp
 delete mode 100644 tests/headers/issue-1198-alias-rust-bitfield-enum.h
 delete mode 100644 tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
 delete mode 100644 tests/headers/issue-1198-alias-rust-const-mod-enum.h
 delete mode 100644 tests/headers/issue-1198-alias-rust-enum.h
 delete mode 100644 tests/headers/issue-1216-variadic-member.h
 delete mode 100644 tests/headers/issue-1238-fwd-no-copy.h
 delete mode 100644 tests/headers/issue-1281.h
 delete mode 100644 tests/headers/issue-1285.h
 delete mode 100644 tests/headers/issue-1291.hpp
 delete mode 100644 tests/headers/issue-1350-attribute-overloadable.h
 delete mode 100644 tests/headers/issue-1382-rust-primitive-types.h
 delete mode 100644 tests/headers/issue-1435.hpp
 delete mode 100644 tests/headers/issue-1443.hpp
 delete mode 100644 tests/headers/issue-1454.h
 delete mode 100644 tests/headers/issue-1464.hpp
 delete mode 100644 tests/headers/issue-1488-enum-new-type.h
 delete mode 100644 tests/headers/issue-1488-options.h
 delete mode 100644 tests/headers/issue-1488-template-alias-new-type.hpp
 delete mode 100644 tests/headers/issue-1498.h
 delete mode 100644 tests/headers/issue-1514.hpp
 delete mode 100644 tests/headers/issue-1554.h
 delete mode 100644 tests/headers/issue-1599-opaque-typedef-to-enum.h
 delete mode 100644 tests/headers/issue-1676-macro-namespace-prefix.hpp
 delete mode 100644 tests/headers/issue-1947.h
 delete mode 100644 tests/headers/issue-1977-larger-arrays.hpp
 delete mode 100644 tests/headers/issue-1995.h
 delete mode 100644 tests/headers/issue-2019.hpp
 delete mode 100644 tests/headers/issue-2239-template-dependent-bit-width.hpp
 delete mode 100644 tests/headers/issue-358.hpp
 delete mode 100644 tests/headers/issue-372.hpp
 delete mode 100644 tests/headers/issue-410.hpp
 delete mode 100644 tests/headers/issue-446.hpp
 delete mode 100644 tests/headers/issue-447.hpp
 delete mode 100644 tests/headers/issue-493.hpp
 delete mode 100644 tests/headers/issue-493_1_0.hpp
 delete mode 100644 tests/headers/issue-511.h
 delete mode 100644 tests/headers/issue-537-repr-packed-n.h
 delete mode 100644 tests/headers/issue-537.h
 delete mode 100644 tests/headers/issue-544-stylo-creduce-2.hpp
 delete mode 100644 tests/headers/issue-544-stylo-creduce.hpp
 delete mode 100644 tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
 delete mode 100644 tests/headers/issue-573-layout-test-failures.hpp
 delete mode 100644 tests/headers/issue-574-assertion-failure-in-codegen.hpp
 delete mode 100644 tests/headers/issue-584-stylo-template-analysis-panic.hpp
 delete mode 100644 tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
 delete mode 100644 tests/headers/issue-639-typedef-anon-field.hpp
 delete mode 100644 tests/headers/issue-643-inner-struct.h
 delete mode 100644 tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
 delete mode 100644 tests/headers/issue-648-derive-debug-with-padding.h
 delete mode 100644 tests/headers/issue-654-struct-fn-collision.h
 delete mode 100644 tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
 delete mode 100644 tests/headers/issue-662-part-2.hpp
 delete mode 100644 tests/headers/issue-674-1.hpp
 delete mode 100644 tests/headers/issue-674-2.hpp
 delete mode 100644 tests/headers/issue-674-3.hpp
 delete mode 100644 tests/headers/issue-677-nested-ns-specifier.hpp
 delete mode 100644 tests/headers/issue-691-template-parameter-virtual.hpp
 delete mode 100644 tests/headers/issue-710-must-use-type.h
 delete mode 100644 tests/headers/issue-739-pointer-wide-bitfield.h
 delete mode 100644 tests/headers/issue-769-bad-instantiation-test.hpp
 delete mode 100644 tests/headers/issue-801-opaque-sloppiness.hpp
 delete mode 100644 tests/headers/issue-807-opaque-types-methods-being-generated.hpp
 delete mode 100644 tests/headers/issue-816.h
 delete mode 100644 tests/headers/issue-820-unused-template-param-in-alias.hpp
 delete mode 100644 tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
 delete mode 100644 tests/headers/issue-833-1.hpp
 delete mode 100644 tests/headers/issue-833-2.hpp
 delete mode 100644 tests/headers/issue-833.hpp
 delete mode 100644 tests/headers/issue-834.hpp
 delete mode 100644 tests/headers/issue-848-replacement-system-include.hpp
 delete mode 100644 tests/headers/issue-848/an-include.h
 delete mode 100644 tests/headers/issue-888-enum-var-decl-jump.hpp
 delete mode 100644 tests/headers/issue-944-derive-copy-and-blocklisting.hpp
 delete mode 100644 tests/headers/issue-946.h
 delete mode 100644 tests/headers/issue_311.hpp
 delete mode 100644 tests/headers/issue_315.hpp
 delete mode 100644 tests/headers/jsval_layout_opaque.hpp
 delete mode 100644 tests/headers/jsval_layout_opaque_1_0.hpp
 delete mode 100644 tests/headers/keywords.h
 delete mode 100644 tests/headers/layout.h
 delete mode 100644 tests/headers/layout_align.h
 delete mode 100644 tests/headers/layout_arp.h
 delete mode 100644 tests/headers/layout_array.h
 delete mode 100644 tests/headers/layout_array_too_long.h
 delete mode 100644 tests/headers/layout_cmdline_token.h
 delete mode 100644 tests/headers/layout_eth_conf.h
 delete mode 100644 tests/headers/layout_eth_conf_1_0.h
 delete mode 100644 tests/headers/layout_kni_mbuf.h
 delete mode 100644 tests/headers/layout_large_align_field.h
 delete mode 100644 tests/headers/layout_mbuf.h
 delete mode 100644 tests/headers/layout_mbuf_1_0.h
 delete mode 100644 tests/headers/long_double.h
 delete mode 100644 tests/headers/macro-expr-basic.h
 delete mode 100644 tests/headers/macro-expr-uncommon-token.h
 delete mode 100644 tests/headers/macro-redef.h
 delete mode 100644 tests/headers/macro_const.h
 delete mode 100644 tests/headers/macro_const_1_0.h
 delete mode 100644 tests/headers/maddness-is-avoidable.hpp
 delete mode 100644 tests/headers/mangling-ios.h
 delete mode 100644 tests/headers/mangling-linux32.hpp
 delete mode 100644 tests/headers/mangling-linux64.hpp
 delete mode 100644 tests/headers/mangling-macos.hpp
 delete mode 100644 tests/headers/mangling-win32.hpp
 delete mode 100644 tests/headers/mangling-win64.hpp
 delete mode 100644 tests/headers/merge-extern-blocks.h
 delete mode 100644 tests/headers/method-mangling.hpp
 delete mode 100644 tests/headers/module-allowlisted.hpp
 delete mode 100644 tests/headers/msvc-no-usr.hpp
 delete mode 100644 tests/headers/multiple-inherit-empty-correct-layout.hpp
 delete mode 100644 tests/headers/mutable.hpp
 delete mode 100644 tests/headers/namespace.hpp
 delete mode 100644 tests/headers/namespace/nsbegin.h
 delete mode 100644 tests/headers/namespace/nsend.h
 delete mode 100644 tests/headers/nested-template-typedef.hpp
 delete mode 100644 tests/headers/nested.hpp
 delete mode 100644 tests/headers/nested_vtable.hpp
 delete mode 100644 tests/headers/nested_within_namespace.hpp
 delete mode 100644 tests/headers/newtype-enum.hpp
 delete mode 100644 tests/headers/newtype-global-enum.hpp
 delete mode 100644 tests/headers/no-comments.h
 delete mode 100644 tests/headers/no-derive-debug.h
 delete mode 100644 tests/headers/no-derive-default.h
 delete mode 100644 tests/headers/no-hash-allowlisted.hpp
 delete mode 100644 tests/headers/no-hash-opaque.hpp
 delete mode 100644 tests/headers/no-partialeq-allowlisted.hpp
 delete mode 100644 tests/headers/no-partialeq-opaque.hpp
 delete mode 100644 tests/headers/no-recursive-allowlisting.h
 delete mode 100644 tests/headers/no-std.h
 delete mode 100644 tests/headers/no_copy.hpp
 delete mode 100644 tests/headers/no_copy_allowlisted.hpp
 delete mode 100644 tests/headers/no_copy_opaque.hpp
 delete mode 100644 tests/headers/no_debug.hpp
 delete mode 100644 tests/headers/no_debug_allowlisted.hpp
 delete mode 100644 tests/headers/no_debug_bypass_impl_debug.hpp
 delete mode 100644 tests/headers/no_debug_opaque.hpp
 delete mode 100644 tests/headers/no_default.hpp
 delete mode 100644 tests/headers/no_default_allowlisted.hpp
 delete mode 100644 tests/headers/no_default_bypass_derive_default.hpp
 delete mode 100644 tests/headers/no_default_opaque.hpp
 delete mode 100644 tests/headers/no_size_t_is_usize.h
 delete mode 100644 tests/headers/non-type-params.hpp
 delete mode 100644 tests/headers/noreturn.hpp
 delete mode 100644 tests/headers/nsBaseHashtable.hpp
 delete mode 100644 tests/headers/nsStyleAutoArray.hpp
 delete mode 100644 tests/headers/objc_allowlist.h
 delete mode 100644 tests/headers/objc_blocklist.h
 delete mode 100644 tests/headers/objc_category.h
 delete mode 100644 tests/headers/objc_class.h
 delete mode 100644 tests/headers/objc_class_method.h
 delete mode 100644 tests/headers/objc_inheritance.h
 delete mode 100644 tests/headers/objc_interface.h
 delete mode 100644 tests/headers/objc_interface_type.h
 delete mode 100644 tests/headers/objc_method.h
 delete mode 100644 tests/headers/objc_method_clash.h
 delete mode 100644 tests/headers/objc_pointer_return_types.h
 delete mode 100644 tests/headers/objc_property_fnptr.h
 delete mode 100644 tests/headers/objc_protocol.h
 delete mode 100644 tests/headers/objc_protocol_inheritance.h
 delete mode 100644 tests/headers/objc_sel_and_id.h
 delete mode 100644 tests/headers/objc_template.h
 delete mode 100644 tests/headers/only_bitfields.hpp
 delete mode 100644 tests/headers/opaque-template-inst-member-2.hpp
 delete mode 100644 tests/headers/opaque-template-inst-member.hpp
 delete mode 100644 tests/headers/opaque-template-instantiation-namespaced.hpp
 delete mode 100644 tests/headers/opaque-template-instantiation.hpp
 delete mode 100644 tests/headers/opaque-tracing.hpp
 delete mode 100644 tests/headers/opaque_in_struct.hpp
 delete mode 100644 tests/headers/opaque_pointer.hpp
 delete mode 100644 tests/headers/opaque_typedef.hpp
 delete mode 100644 tests/headers/operator.hpp
 delete mode 100644 tests/headers/ord-enum.h
 delete mode 100644 tests/headers/overflowed_enum.hpp
 delete mode 100644 tests/headers/overloading.hpp
 delete mode 100644 tests/headers/packed-bitfield.h
 delete mode 100644 tests/headers/packed-n-with-padding.h
 delete mode 100644 tests/headers/packed-vtable.h
 delete mode 100644 tests/headers/parm-union.hpp
 delete mode 100644 tests/headers/parsecb-anonymous-enum-variant-rename.h
 delete mode 100644 tests/headers/partial-specialization-and-inheritance.hpp
 delete mode 100644 tests/headers/pointer-attr.h
 delete mode 100644 tests/headers/prepend-enum-constified-variant.h
 delete mode 100644 tests/headers/prepend_enum_name.hpp
 delete mode 100644 tests/headers/private.hpp
 delete mode 100644 tests/headers/private_fields.hpp
 delete mode 100644 tests/headers/public-dtor.hpp
 delete mode 100644 tests/headers/qualified-dependent-types.hpp
 delete mode 100644 tests/headers/redeclaration.hpp
 delete mode 100644 tests/headers/ref_argument_array.hpp
 delete mode 100644 tests/headers/reparented_replacement.hpp
 delete mode 100644 tests/headers/replace_template_alias.hpp
 delete mode 100644 tests/headers/replace_use.hpp
 delete mode 100644 tests/headers/replaces_double.hpp
 delete mode 100644 tests/headers/repr-align.hpp
 delete mode 100644 tests/headers/resolved_type_def_function.h
 delete mode 100644 tests/headers/same_struct_name_in_different_namespaces.hpp
 delete mode 100644 tests/headers/sentry-defined-multiple-times.hpp
 delete mode 100644 tests/headers/short-enums.hpp
 delete mode 100644 tests/headers/size_t_template.hpp
 delete mode 100644 tests/headers/sorted-items.h
 delete mode 100644 tests/headers/stdint_typedef.h
 delete mode 100644 tests/headers/struct_containing_forward_declared_struct.h
 delete mode 100644 tests/headers/struct_typedef.h
 delete mode 100644 tests/headers/struct_typedef_ns.hpp
 delete mode 100644 tests/headers/struct_with_anon_struct.h
 delete mode 100644 tests/headers/struct_with_anon_struct_array.h
 delete mode 100644 tests/headers/struct_with_anon_struct_pointer.h
 delete mode 100644 tests/headers/struct_with_anon_union.h
 delete mode 100644 tests/headers/struct_with_anon_union_1_0.h
 delete mode 100644 tests/headers/struct_with_anon_unnamed_struct.h
 delete mode 100644 tests/headers/struct_with_anon_unnamed_union.h
 delete mode 100644 tests/headers/struct_with_anon_unnamed_union_1_0.h
 delete mode 100644 tests/headers/struct_with_bitfields.h
 delete mode 100644 tests/headers/struct_with_derive_debug.h
 delete mode 100644 tests/headers/struct_with_large_array.hpp
 delete mode 100644 tests/headers/struct_with_nesting.h
 delete mode 100644 tests/headers/struct_with_nesting_1_0.h
 delete mode 100644 tests/headers/struct_with_packing.h
 delete mode 100644 tests/headers/struct_with_struct.h
 delete mode 100644 tests/headers/struct_with_typedef_template_arg.hpp
 delete mode 100644 tests/headers/template-fun-ty.hpp
 delete mode 100644 tests/headers/template-param-usage-0.hpp
 delete mode 100644 tests/headers/template-param-usage-1.hpp
 delete mode 100644 tests/headers/template-param-usage-10.hpp
 delete mode 100644 tests/headers/template-param-usage-11.hpp
 delete mode 100644 tests/headers/template-param-usage-12.hpp
 delete mode 100644 tests/headers/template-param-usage-13.hpp
 delete mode 100644 tests/headers/template-param-usage-14.hpp
 delete mode 100644 tests/headers/template-param-usage-15.hpp
 delete mode 100644 tests/headers/template-param-usage-2.hpp
 delete mode 100644 tests/headers/template-param-usage-3.hpp
 delete mode 100644 tests/headers/template-param-usage-4.hpp
 delete mode 100644 tests/headers/template-param-usage-5.hpp
 delete mode 100644 tests/headers/template-param-usage-6.hpp
 delete mode 100644 tests/headers/template-param-usage-7.hpp
 delete mode 100644 tests/headers/template-param-usage-8.hpp
 delete mode 100644 tests/headers/template-param-usage-9.hpp
 delete mode 100644 tests/headers/template-with-var.hpp
 delete mode 100644 tests/headers/template.hpp
 delete mode 100644 tests/headers/template_alias.hpp
 delete mode 100644 tests/headers/template_alias_basic.hpp
 delete mode 100644 tests/headers/template_alias_namespace.hpp
 delete mode 100644 tests/headers/template_fun.hpp
 delete mode 100644 tests/headers/template_instantiation_with_fn_local_type.hpp
 delete mode 100644 tests/headers/template_partial_specification.hpp
 delete mode 100644 tests/headers/template_typedef_transitive_param.hpp
 delete mode 100644 tests/headers/template_typedefs.hpp
 delete mode 100644 tests/headers/templateref_opaque.hpp
 delete mode 100644 tests/headers/templatized-bitfield.hpp
 delete mode 100644 tests/headers/timex.h
 delete mode 100644 tests/headers/transform-op.hpp
 delete mode 100644 tests/headers/type-referenced-by-allowlisted-function.h
 delete mode 100644 tests/headers/type_alias_empty.hpp
 delete mode 100644 tests/headers/type_alias_partial_template_especialization.hpp
 delete mode 100644 tests/headers/type_alias_template_specialized.hpp
 delete mode 100644 tests/headers/typedefd-array-as-function-arg.h
 delete mode 100644 tests/headers/typeref.hpp
 delete mode 100644 tests/headers/typeref_1_0.hpp
 delete mode 100644 tests/headers/underscore.hpp
 delete mode 100644 tests/headers/union-align.h
 delete mode 100644 tests/headers/union-in-ns.hpp
 delete mode 100644 tests/headers/union-in-ns_1_0.hpp
 delete mode 100644 tests/headers/union_bitfield.h
 delete mode 100644 tests/headers/union_bitfield_1_0.h
 delete mode 100644 tests/headers/union_dtor.hpp
 delete mode 100644 tests/headers/union_dtor_1_0.hpp
 delete mode 100644 tests/headers/union_fields.hpp
 delete mode 100644 tests/headers/union_fields_1_0.hpp
 delete mode 100644 tests/headers/union_template.hpp
 delete mode 100644 tests/headers/union_template_1_0.hpp
 delete mode 100644 tests/headers/union_with_anon_struct.h
 delete mode 100644 tests/headers/union_with_anon_struct_1_0.h
 delete mode 100644 tests/headers/union_with_anon_struct_bitfield.h
 delete mode 100644 tests/headers/union_with_anon_struct_bitfield_1_0.h
 delete mode 100644 tests/headers/union_with_anon_union.h
 delete mode 100644 tests/headers/union_with_anon_union_1_0.h
 delete mode 100644 tests/headers/union_with_anon_unnamed_struct.h
 delete mode 100644 tests/headers/union_with_anon_unnamed_struct_1_0.h
 delete mode 100644 tests/headers/union_with_anon_unnamed_union.h
 delete mode 100644 tests/headers/union_with_anon_unnamed_union_1_0.h
 delete mode 100644 tests/headers/union_with_big_member.h
 delete mode 100644 tests/headers/union_with_big_member_1_0.h
 delete mode 100644 tests/headers/union_with_nesting.h
 delete mode 100644 tests/headers/union_with_nesting_1_0.h
 delete mode 100644 tests/headers/union_with_non_copy_member.h
 delete mode 100644 tests/headers/unknown_attr.h
 delete mode 100644 tests/headers/unsorted-items.h
 delete mode 100644 tests/headers/use-core.h
 delete mode 100644 tests/headers/use-core_1_0.h
 delete mode 100644 tests/headers/using.hpp
 delete mode 100644 tests/headers/var-tracing.hpp
 delete mode 100644 tests/headers/variadic-method.hpp
 delete mode 100644 tests/headers/variadic_template_function.hpp
 delete mode 100644 tests/headers/vector.hpp
 delete mode 100644 tests/headers/virtual_dtor.hpp
 delete mode 100644 tests/headers/virtual_inheritance.hpp
 delete mode 100644 tests/headers/virtual_interface.hpp
 delete mode 100644 tests/headers/virtual_overloaded.hpp
 delete mode 100644 tests/headers/vtable_recursive_sig.hpp
 delete mode 100644 tests/headers/wasm-constructor-returns.hpp
 delete mode 100644 tests/headers/wasm-import-module.h
 delete mode 100644 tests/headers/weird_bitfields.hpp
 delete mode 100644 tests/headers/what_is_going_on.hpp
 delete mode 100644 tests/headers/win32-thiscall_1_0.hpp
 delete mode 100644 tests/headers/win32-thiscall_nightly.hpp
 delete mode 100644 tests/headers/win32-vectorcall-1_0.h
 delete mode 100644 tests/headers/win32-vectorcall-nightly.h
 delete mode 100644 tests/headers/with_array_pointers_arguments.h
 delete mode 100644 tests/headers/without_array_pointers_arguments.h
 delete mode 100644 tests/headers/zero-size-array-align.h
 delete mode 100644 tests/headers/zero-sized-array.hpp
 delete mode 100644 tests/parse_callbacks/mod.rs
 delete mode 100644 tests/quickchecking/.gitignore
 delete mode 100644 tests/quickchecking/Cargo.toml
 delete mode 100644 tests/quickchecking/README.md
 delete mode 100644 tests/quickchecking/src/bin.rs
 delete mode 100644 tests/quickchecking/src/fuzzers.rs
 delete mode 100644 tests/quickchecking/src/lib.rs
 delete mode 100644 tests/quickchecking/tests/fuzzed-c-headers.rs
 delete mode 100644 tests/rustfmt.toml
 delete mode 100644 tests/stylo.hpp
 delete mode 100755 tests/stylo_sanity.rs
 delete mode 100755 tests/test-one.sh
 delete mode 100644 tests/tests.rs
 delete mode 100644 tests/uses/.gitignore

diff --git a/.github/workflows/bindgen.yml b/.github/workflows/bindgen.yml
index 6adbb5da..94a338bf 100644
--- a/.github/workflows/bindgen.yml
+++ b/.github/workflows/bindgen.yml
@@ -68,7 +68,7 @@ jobs:
 
       # TODO: Actually run quickchecks once `bindgen` is reliable enough.
       - name: Build quickcheck tests
-        run: cd tests/quickchecking && cargo test
+        run: cd bindgen-tests/tests/quickchecking && cargo test
 
   test-expectations:
     runs-on: ${{matrix.os}}
@@ -88,7 +88,7 @@ jobs:
           override: true
 
       - name: Test expectations
-        run: cd tests/expectations && cargo test
+        run: cd bindgen-tests/tests/expectations && cargo test
 
   test:
     runs-on: ${{matrix.os}}
diff --git a/.gitignore b/.gitignore
index f5c3381c..a924030c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,8 @@
 target/
 *~
 bindgen-integration/Cargo.lock
-tests/expectations/Cargo.lock
+bindgen-tests/tests/expectations/Cargo.lock
+bindgen-tests/tests/quickchecking/Cargo.lock
 #*#
 
 # Test script output
diff --git a/Cargo.lock b/Cargo.lock
index fa908ea9..b9deb405 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,13 +2,31 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "aho-corasick"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca972c2ea5f742bfce5687b9aef75506a764f61d37f8f649047846a9686ddb66"
+dependencies = [
+ "memchr 0.1.11",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
 dependencies = [
- "memchr",
+ "memchr 2.5.0",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -19,7 +37,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
  "hermit-abi",
  "libc",
- "winapi",
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -35,29 +53,67 @@ dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
- "clap",
- "diff",
- "env_logger",
  "lazy_static",
  "lazycell",
- "log",
+ "log 0.4.14",
  "peeking_take_while",
  "proc-macro2",
  "quote",
- "regex",
+ "regex 1.5.5",
  "rustc-hash",
  "shlex",
  "syn",
- "tempfile",
  "which",
 ]
 
+[[package]]
+name = "bindgen-cli"
+version = "0.60.1"
+dependencies = [
+ "bindgen",
+ "clap 3.2.12",
+ "env_logger 0.9.0",
+ "log 0.4.14",
+ "shlex",
+]
+
+[[package]]
+name = "bindgen-integration"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "cc",
+]
+
+[[package]]
+name = "bindgen-tests"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "clap 3.2.12",
+ "diff",
+ "shlex",
+ "tempfile",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "block"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
+
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -81,7 +137,22 @@ checksum = "5a050e2153c5be08febd6734e29298e844fdb0fa21aeddd63b4eb7baa106c69b"
 dependencies = [
  "glob",
  "libc",
- "libloading",
+ "libloading 0.7.0",
+]
+
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim 0.8.0",
+ "textwrap 0.11.0",
+ "unicode-width",
+ "vec_map",
 ]
 
 [[package]]
@@ -94,9 +165,9 @@ dependencies = [
  "bitflags",
  "clap_lex",
  "indexmap",
- "strsim",
+ "strsim 0.10.0",
  "termcolor",
- "textwrap",
+ "textwrap 0.15.0",
 ]
 
 [[package]]
@@ -120,6 +191,16 @@ version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
 
+[[package]]
+name = "env_logger"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15abd780e45b3ea4f76b4e9a26ff4843258dd8a3eed2775a0e7368c2e7936c2f"
+dependencies = [
+ "log 0.3.9",
+ "regex 0.1.80",
+]
+
 [[package]]
 name = "env_logger"
 version = "0.9.0"
@@ -128,11 +209,17 @@ checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
 dependencies = [
  "atty",
  "humantime",
- "log",
- "regex",
+ "log 0.4.14",
+ "regex 1.5.5",
  "termcolor",
 ]
 
+[[package]]
+name = "fuchsia-cprng"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+
 [[package]]
 name = "getrandom"
 version = "0.2.3"
@@ -181,6 +268,16 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -199,6 +296,16 @@ version = "0.2.126"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
 
+[[package]]
+name = "libloading"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "351a32417a12d5f7e82c368a66781e307834dae04c6ce0cd4456d52989229883"
+dependencies = [
+ "cfg-if",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "libloading"
 version = "0.7.0"
@@ -206,7 +313,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
 dependencies = [
  "cfg-if",
- "winapi",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+dependencies = [
+ "log 0.4.14",
 ]
 
 [[package]]
@@ -218,6 +334,24 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b629fb514376c675b98c1421e80b151d3817ac42d7c667717d282761418d20"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "memchr"
 version = "2.5.0"
@@ -236,11 +370,20 @@ version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ffd9d26838a953b4af82cbeb9f1592c6798916983959be223a7124e992742c1"
 dependencies = [
- "memchr",
+ "memchr 2.5.0",
  "minimal-lexical",
  "version_check",
 ]
 
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+]
+
 [[package]]
 name = "os_str_bytes"
 version = "6.2.0"
@@ -268,6 +411,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quickcheck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02c2411d418cea2364325b18a205664f9ef8252e06b2e911db97c0b0d98b1406"
+dependencies = [
+ "env_logger 0.3.5",
+ "log 0.3.9",
+ "rand 0.3.23",
+]
+
+[[package]]
+name = "quickchecking"
+version = "0.1.0"
+dependencies = [
+ "clap 2.34.0",
+ "lazy_static",
+ "quickcheck",
+ "rand 0.3.23",
+ "tempdir",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.9"
@@ -277,6 +442,29 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ac302d8f83c0c1974bf758f6b041c6c8ada916fbb44a609158ca8b064cc76c"
+dependencies = [
+ "libc",
+ "rand 0.4.6",
+]
+
+[[package]]
+name = "rand"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
+dependencies = [
+ "fuchsia-cprng",
+ "libc",
+ "rand_core 0.3.1",
+ "rdrand",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "rand"
 version = "0.8.4"
@@ -285,7 +473,7 @@ checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
 dependencies = [
  "libc",
  "rand_chacha",
- "rand_core",
+ "rand_core 0.6.3",
  "rand_hc",
 ]
 
@@ -296,9 +484,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+dependencies = [
+ "rand_core 0.4.2",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+
 [[package]]
 name = "rand_core"
 version = "0.6.3"
@@ -314,7 +517,16 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.3",
+]
+
+[[package]]
+name = "rdrand"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+dependencies = [
+ "rand_core 0.3.1",
 ]
 
 [[package]]
@@ -326,17 +538,36 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "regex"
+version = "0.1.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fd4ace6a8cf7860714a2c2280d6c1f7e6a413486c13298bbc86fd3da019402f"
+dependencies = [
+ "aho-corasick 0.5.3",
+ "memchr 0.1.11",
+ "regex-syntax 0.3.9",
+ "thread_local",
+ "utf8-ranges",
+]
+
 [[package]]
 name = "regex"
 version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
 dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
+ "aho-corasick 0.7.18",
+ "memchr 2.5.0",
+ "regex-syntax 0.6.25",
 ]
 
+[[package]]
+name = "regex-syntax"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957"
+
 [[package]]
 name = "regex-syntax"
 version = "0.6.25"
@@ -349,7 +580,7 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
 dependencies = [
- "winapi",
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -364,6 +595,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42a568c8f2cd051a4d283bd6eb0343ac214c1b0f1ac19f93e1175b2dee38c73d"
 
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -381,6 +618,16 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tempdir"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
+dependencies = [
+ "rand 0.4.6",
+ "remove_dir_all",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.2.0"
@@ -389,10 +636,10 @@ checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
 dependencies = [
  "cfg-if",
  "libc",
- "rand",
+ "rand 0.8.4",
  "redox_syscall",
  "remove_dir_all",
- "winapi",
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -404,18 +651,73 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "tests_expectations"
+version = "0.1.0"
+dependencies = [
+ "block",
+ "libloading 0.6.7",
+ "objc",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "textwrap"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
 
+[[package]]
+name = "thread-id"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9539db560102d1cef46b8b78ce737ff0bb64e7e18d35b2a5688f7d097d0ff03"
+dependencies = [
+ "kernel32-sys",
+ "libc",
+]
+
+[[package]]
+name = "thread_local"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8576dbbfcaef9641452d5cf0df9b0e7eeab7694956dd33bb61515fb8f18cfdd5"
+dependencies = [
+ "thread-id",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"
 
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
+[[package]]
+name = "utf8-ranges"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1ca13c08c41c9c3e04224ed9ff80461d97e121589ff27c753a16cb10830ae0f"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
 [[package]]
 name = "version_check"
 version = "0.9.3"
@@ -439,6 +741,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -449,6 +757,12 @@ dependencies = [
  "winapi-x86_64-pc-windows-gnu",
 ]
 
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
@@ -461,7 +775,7 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
- "winapi",
+ "winapi 0.3.9",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 311110b3..a9d9d41e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,88 +1,15 @@
-[package]
-authors = [
-  "Jyun-Yan You <jyyou.tw@gmail.com>",
-  "Emilio Cobos Álvarez <emilio@crisal.io>",
-  "Nick Fitzgerald <fitzgen@gmail.com>",
-  "The Servo project developers",
+[workspace]
+members = [
+    "bindgen",
+    "bindgen-cli",
+    "bindgen-integration",
+    "bindgen-tests",
+    "bindgen-tests/tests/quickchecking",
+    "bindgen-tests/tests/expectations",
 ]
-description = "Automatically generates Rust FFI bindings to C and C++ libraries."
-keywords = ["bindings", "ffi", "code-generation"]
-categories = ["external-ffi-bindings", "development-tools::ffi"]
-license = "BSD-3-Clause"
-name = "bindgen"
-readme = "README.md"
-repository = "https://github.com/rust-lang/rust-bindgen"
-documentation = "https://docs.rs/bindgen"
-homepage = "https://rust-lang.github.io/rust-bindgen/"
-version = "0.60.1"
-edition = "2018"
-build = "build.rs"
-# If you change this, also update README.md and msrv in .github/workflows/bindgen.yml
-rust-version = "1.57.0"
 
-include = [
-  "LICENSE",
-  "README.md",
-  "Cargo.toml",
-  "build.rs",
-  "src/*.rs",
-  "src/**/*.rs",
+default-members = [
+    "bindgen",
+    "bindgen-cli",
+    "bindgen-tests",
 ]
-
-[badges]
-travis-ci = { repository = "rust-lang/rust-bindgen" }
-
-[lib]
-path = "src/lib.rs"
-
-[[bin]]
-name = "bindgen"
-path = "src/main.rs"
-doc = false
-required-features = ["clap"]
-
-[dev-dependencies]
-diff = "0.1"
-clap = "3"
-shlex = "1"
-tempfile = "3"
-
-[dependencies]
-bitflags = "1.0.3"
-cexpr = "0.6"
-# This kinda sucks: https://github.com/rust-lang/cargo/issues/1982
-clap = { version = "3", optional = true }
-clang-sys = { version = "1", features = ["clang_6_0"] }
-lazycell = "1"
-lazy_static = "1"
-peeking_take_while = "0.1.2"
-quote = { version = "1", default-features = false }
-syn = { version = "1.0.99", features = ["full", "extra-traits"]}
-regex = { version = "1.5", default-features = false , features = ["std", "unicode"] }
-which = { version = "4.2.1", optional = true, default-features = false }
-shlex = "1"
-rustc-hash = "1.0.1"
-proc-macro2 = { version = "1", default-features = false }
-
-[dependencies.env_logger]
-optional = true
-version = "0.9.0"
-
-[dependencies.log]
-optional = true
-version = "0.4"
-
-[features]
-default = ["logging", "clap", "runtime", "which-rustfmt"]
-logging = ["env_logger", "log"]
-static = ["clang-sys/static"]
-runtime = ["clang-sys/runtime"]
-# Dynamically discover a `rustfmt` binary using the `which` crate
-which-rustfmt = ["which"]
-
-# These features only exist for CI testing -- don't use them if you're not hacking
-# on bindgen!
-testing_only_docs = []
-testing_only_extra_assertions = []
-testing_only_libclang_9 = []
-testing_only_libclang_5 = []
diff --git a/bindgen-cli/Cargo.toml b/bindgen-cli/Cargo.toml
new file mode 100644
index 00000000..3ebf4a3f
--- /dev/null
+++ b/bindgen-cli/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+authors = [
+  "The rust-bindgen project contributors",
+]
+description = "Automatically generates Rust FFI bindings to C and C++ libraries."
+keywords = ["bindings", "ffi", "code-generation"]
+categories = ["external-ffi-bindings", "development-tools::ffi"]
+license = "BSD-3-Clause"
+name = "bindgen-cli"
+readme = "README.md"
+repository = "https://github.com/rust-lang/rust-bindgen"
+documentation = "https://docs.rs/bindgen"
+homepage = "https://rust-lang.github.io/rust-bindgen/"
+version = "0.60.1"
+edition = "2018"
+# If you change this, also update README.md and msrv in .github/workflows/bindgen.yml
+rust-version = "1.57.0"
+
+include = [
+  "Cargo.toml",
+  "build.rs",
+]
+
+[[bin]]
+path = "main.rs"
+name = "bindgen"
+
+[badges]
+travis-ci = { repository = "rust-lang/rust-bindgen" }
+
+[dependencies]
+bindgen = { path = "../bindgen" }
+shlex = "1"
+clap = "3"
+env_logger = { version = "0.9.0", optional = true }
+log = { version = "0.4", optional = true }
+
+[features]
+default = ["logging", "runtime", "which-rustfmt"]
+logging = ["bindgen/logging", "env_logger", "log"]
+static = ["bindgen/static"]
+runtime = ["bindgen/runtime"]
+# Dynamically discover a `rustfmt` binary using the `which` crate
+which-rustfmt = ["bindgen/which-rustfmt"]
diff --git a/bindgen-cli/main.rs b/bindgen-cli/main.rs
new file mode 100644
index 00000000..a61f67ad
--- /dev/null
+++ b/bindgen-cli/main.rs
@@ -0,0 +1,77 @@
+extern crate bindgen;
+extern crate clap;
+#[cfg(feature = "logging")]
+extern crate env_logger;
+#[cfg(feature = "logging")]
+extern crate log;
+
+use std::env;
+use std::panic;
+
+mod options;
+use crate::options::builder_from_flags;
+
+#[cfg(feature = "logging")]
+fn clang_version_check() {
+    let version = bindgen::clang_version();
+    let expected_version = if cfg!(feature = "testing_only_libclang_9") {
+        Some((9, 0))
+    } else if cfg!(feature = "testing_only_libclang_5") {
+        Some((5, 0))
+    } else {
+        None
+    };
+
+    log::info!(
+        "Clang Version: {}, parsed: {:?}",
+        version.full,
+        version.parsed
+    );
+
+    if expected_version.is_some() {
+        // assert_eq!(version.parsed, version.parsed);
+    }
+}
+
+pub fn main() {
+    #[cfg(feature = "logging")]
+    env_logger::init();
+
+    match builder_from_flags(env::args()) {
+        Ok((builder, output, verbose)) => {
+            #[cfg(feature = "logging")]
+            clang_version_check();
+            let builder_result = panic::catch_unwind(|| {
+                builder.generate().expect("Unable to generate bindings")
+            });
+
+            if builder_result.is_err() {
+                if verbose {
+                    print_verbose_err();
+                }
+                std::process::exit(1);
+            }
+
+            let bindings = builder_result.unwrap();
+            bindings.write(output).expect("Unable to write output");
+        }
+        Err(error) => {
+            println!("{}", error);
+            std::process::exit(1);
+        }
+    };
+}
+
+fn print_verbose_err() {
+    println!("Bindgen unexpectedly panicked");
+    println!(
+        "This may be caused by one of the known-unsupported \
+         things (https://rust-lang.github.io/rust-bindgen/cpp.html), \
+         please modify the bindgen flags to work around it as \
+         described in https://rust-lang.github.io/rust-bindgen/cpp.html"
+    );
+    println!(
+        "Otherwise, please file an issue at \
+         https://github.com/rust-lang/rust-bindgen/issues/new"
+    );
+}
diff --git a/bindgen-cli/options.rs b/bindgen-cli/options.rs
new file mode 100644
index 00000000..5c3960e9
--- /dev/null
+++ b/bindgen-cli/options.rs
@@ -0,0 +1,1092 @@
+use bindgen::{
+    builder, AliasVariation, Builder, CodegenConfig, EnumVariation,
+    MacroTypeVariation, NonCopyUnionStyle, RustTarget,
+    DEFAULT_ANON_FIELDS_PREFIX, RUST_TARGET_STRINGS,
+};
+use clap::{App, Arg};
+use std::fs::File;
+use std::io::{self, stderr, Error, ErrorKind, Write};
+use std::path::PathBuf;
+use std::str::FromStr;
+
+/// Construct a new [`Builder`](./struct.Builder.html) from command line flags.
+pub fn builder_from_flags<I>(
+    args: I,
+) -> Result<(Builder, Box<dyn io::Write>, bool), io::Error>
+where
+    I: Iterator<Item = String>,
+{
+    let rust_target_help = format!(
+        "Version of the Rust compiler to target. Valid options are: {:?}. Defaults to {:?}.",
+        RUST_TARGET_STRINGS,
+        String::from(RustTarget::default())
+    );
+
+    let matches = App::new("bindgen")
+        .about("Generates Rust bindings from C/C++ headers.")
+        .setting(clap::AppSettings::NoAutoVersion)
+        .override_usage("bindgen [FLAGS] [OPTIONS] <header> -- <clang-args>...")
+        .args(&[
+            Arg::new("header")
+                .help("C or C++ header file")
+                .required_unless_present("V"),
+            Arg::new("depfile")
+                .long("depfile")
+                .takes_value(true)
+                .help("Path to write depfile to"),
+            Arg::new("default-enum-style")
+                .long("default-enum-style")
+                .help("The default style of code used to generate enums.")
+                .value_name("variant")
+                .default_value("consts")
+                .possible_values([
+                    "consts",
+                    "moduleconsts",
+                    "bitfield",
+                    "newtype",
+                    "rust",
+                    "rust_non_exhaustive",
+                ])
+                .multiple_occurrences(false),
+            Arg::new("bitfield-enum")
+                .long("bitfield-enum")
+                .help(
+                    "Mark any enum whose name matches <regex> as a set of \
+                     bitfield flags.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("newtype-enum")
+                .long("newtype-enum")
+                .help("Mark any enum whose name matches <regex> as a newtype.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("newtype-global-enum")
+                .long("newtype-global-enum")
+                .help("Mark any enum whose name matches <regex> as a global newtype.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("rustified-enum")
+                .long("rustified-enum")
+                .help("Mark any enum whose name matches <regex> as a Rust enum.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("constified-enum")
+                .long("constified-enum")
+                .help(
+                    "Mark any enum whose name matches <regex> as a series of \
+                     constants.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("constified-enum-module")
+                .long("constified-enum-module")
+                .help(
+                    "Mark any enum whose name matches <regex> as a module of \
+                     constants.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("default-macro-constant-type")
+                .long("default-macro-constant-type")
+                .help("The default signed/unsigned type for C macro constants.")
+                .value_name("variant")
+                .default_value("unsigned")
+                .possible_values(["signed", "unsigned"])
+                .multiple_occurrences(false),
+            Arg::new("default-alias-style")
+                .long("default-alias-style")
+                .help("The default style of code used to generate typedefs.")
+                .value_name("variant")
+                .default_value("type_alias")
+                .possible_values([
+                    "type_alias",
+                    "new_type",
+                    "new_type_deref",
+                ])
+                .multiple_occurrences(false),
+            Arg::new("normal-alias")
+                .long("normal-alias")
+                .help(
+                    "Mark any typedef alias whose name matches <regex> to use \
+                     normal type aliasing.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+             Arg::new("new-type-alias")
+                .long("new-type-alias")
+                .help(
+                    "Mark any typedef alias whose name matches <regex> to have \
+                     a new type generated for it.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+             Arg::new("new-type-alias-deref")
+                .long("new-type-alias-deref")
+                .help(
+                    "Mark any typedef alias whose name matches <regex> to have \
+                     a new type with Deref and DerefMut to the inner type.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("default-non-copy-union-style")
+                .long("default-non-copy-union-style")
+                .help(
+                    "The default style of code used to generate unions with \
+                     non-Copy members. Note that ManuallyDrop was first \
+                     stabilized in Rust 1.20.0.",
+                )
+                .value_name("style")
+                .default_value("bindgen_wrapper")
+                .possible_values([
+                    "bindgen_wrapper",
+                    "manually_drop",
+                ])
+                .multiple_occurrences(false),
+            Arg::new("bindgen-wrapper-union")
+                .long("bindgen-wrapper-union")
+                .help(
+                    "Mark any union whose name matches <regex> and who has a \
+                     non-Copy member to use a bindgen-generated wrapper for \
+                     fields.",
+                )
+                .value_name("regex")
+                .takes_value(true)
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("manually-drop-union")
+                .long("manually-drop-union")
+                .help(
+                    "Mark any union whose name matches <regex> and who has a \
+                     non-Copy member to use ManuallyDrop (stabilized in Rust \
+                     1.20.0) for fields.",
+                )
+                .value_name("regex")
+                .takes_value(true)
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("blocklist-type")
+                .alias("blacklist-type")
+                .long("blocklist-type")
+                .help("Mark <type> as hidden.")
+                .value_name("type")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("blocklist-function")
+                .alias("blacklist-function")
+                .long("blocklist-function")
+                .help("Mark <function> as hidden.")
+                .value_name("function")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("blocklist-item")
+                .alias("blacklist-item")
+                .long("blocklist-item")
+                .help("Mark <item> as hidden.")
+                .value_name("item")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("blocklist-file")
+                .alias("blacklist-file")
+                .long("blocklist-file")
+                .help("Mark all contents of <path> as hidden.")
+                .value_name("path")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("no-layout-tests")
+                .long("no-layout-tests")
+                .help("Avoid generating layout tests for any type."),
+            Arg::new("no-derive-copy")
+                .long("no-derive-copy")
+                .help("Avoid deriving Copy on any type."),
+            Arg::new("no-derive-debug")
+                .long("no-derive-debug")
+                .help("Avoid deriving Debug on any type."),
+            Arg::new("no-derive-default")
+                .long("no-derive-default")
+                .hide(true)
+                .help("Avoid deriving Default on any type."),
+            Arg::new("impl-debug").long("impl-debug").help(
+                "Create Debug implementation, if it can not be derived \
+                 automatically.",
+            ),
+            Arg::new("impl-partialeq")
+                .long("impl-partialeq")
+                .help(
+                    "Create PartialEq implementation, if it can not be derived \
+                     automatically.",
+                ),
+            Arg::new("with-derive-default")
+                .long("with-derive-default")
+                .help("Derive Default on any type."),
+            Arg::new("with-derive-hash")
+                .long("with-derive-hash")
+                .help("Derive hash on any type."),
+            Arg::new("with-derive-partialeq")
+                .long("with-derive-partialeq")
+                .help("Derive partialeq on any type."),
+            Arg::new("with-derive-partialord")
+                .long("with-derive-partialord")
+                .help("Derive partialord on any type."),
+            Arg::new("with-derive-eq")
+                .long("with-derive-eq")
+                .help(
+                    "Derive eq on any type. Enable this option also \
+                     enables --with-derive-partialeq",
+                ),
+            Arg::new("with-derive-ord")
+                .long("with-derive-ord")
+                .help(
+                    "Derive ord on any type. Enable this option also \
+                     enables --with-derive-partialord",
+                ),
+            Arg::new("no-doc-comments")
+                .long("no-doc-comments")
+                .help(
+                    "Avoid including doc comments in the output, see: \
+                     https://github.com/rust-lang/rust-bindgen/issues/426",
+                ),
+            Arg::new("no-recursive-allowlist")
+                .long("no-recursive-allowlist")
+                .alias("no-recursive-whitelist")
+                .help(
+                    "Disable allowlisting types recursively. This will cause \
+                     bindgen to emit Rust code that won't compile! See the \
+                     `bindgen::Builder::allowlist_recursively` method's \
+                     documentation for details.",
+                ),
+            Arg::new("objc-extern-crate")
+                .long("objc-extern-crate")
+                .help("Use extern crate instead of use for objc."),
+            Arg::new("generate-block")
+                .long("generate-block")
+                .help("Generate block signatures instead of void pointers."),
+            Arg::new("block-extern-crate")
+                .long("block-extern-crate")
+                .help("Use extern crate instead of use for block."),
+            Arg::new("distrust-clang-mangling")
+                .long("distrust-clang-mangling")
+                .help("Do not trust the libclang-provided mangling"),
+            Arg::new("builtins").long("builtins").help(
+                "Output bindings for builtin definitions, e.g. \
+                 __builtin_va_list.",
+            ),
+            Arg::new("ctypes-prefix")
+                .long("ctypes-prefix")
+                .help(
+                    "Use the given prefix before raw types instead of \
+                     ::std::os::raw.",
+                )
+                .value_name("prefix"),
+            Arg::new("anon-fields-prefix")
+                .long("anon-fields-prefix")
+                .help("Use the given prefix for the anon fields.")
+                .value_name("prefix")
+                .default_value(DEFAULT_ANON_FIELDS_PREFIX),
+            Arg::new("time-phases")
+                .long("time-phases")
+                .help("Time the different bindgen phases and print to stderr"),
+            // All positional arguments after the end of options marker, `--`
+            Arg::new("clang-args").last(true).multiple_occurrences(true),
+            Arg::new("emit-clang-ast")
+                .long("emit-clang-ast")
+                .help("Output the Clang AST for debugging purposes."),
+            Arg::new("emit-ir")
+                .long("emit-ir")
+                .help("Output our internal IR for debugging purposes."),
+            Arg::new("emit-ir-graphviz")
+                .long("emit-ir-graphviz")
+                .help("Dump graphviz dot file.")
+                .value_name("path"),
+            Arg::new("enable-cxx-namespaces")
+                .long("enable-cxx-namespaces")
+                .help("Enable support for C++ namespaces."),
+            Arg::new("disable-name-namespacing")
+                .long("disable-name-namespacing")
+                .help(
+                    "Disable namespacing via mangling, causing bindgen to \
+                     generate names like \"Baz\" instead of \"foo_bar_Baz\" \
+                     for an input name \"foo::bar::Baz\".",
+                ),
+            Arg::new("disable-nested-struct-naming")
+                .long("disable-nested-struct-naming")
+                .help(
+                    "Disable nested struct naming, causing bindgen to generate \
+                     names like \"bar\" instead of \"foo_bar\" for a nested \
+                     definition \"struct foo { struct bar { } b; };\"."
+                ),
+            Arg::new("disable-untagged-union")
+                .long("disable-untagged-union")
+                .help(
+                    "Disable support for native Rust unions.",
+                ),
+            Arg::new("disable-header-comment")
+                .long("disable-header-comment")
+                .help("Suppress insertion of bindgen's version identifier into generated bindings.")
+                .multiple_occurrences(true),
+            Arg::new("ignore-functions")
+                .long("ignore-functions")
+                .help(
+                    "Do not generate bindings for functions or methods. This \
+                     is useful when you only care about struct layouts.",
+                ),
+            Arg::new("generate")
+                .long("generate")
+                .help(
+                    "Generate only given items, split by commas. \
+                     Valid values are \"functions\",\"types\", \"vars\", \
+                     \"methods\", \"constructors\" and \"destructors\".",
+                )
+                .takes_value(true),
+            Arg::new("ignore-methods")
+                .long("ignore-methods")
+                .help("Do not generate bindings for methods."),
+            Arg::new("no-convert-floats")
+                .long("no-convert-floats")
+                .help("Do not automatically convert floats to f32/f64."),
+            Arg::new("no-prepend-enum-name")
+                .long("no-prepend-enum-name")
+                .help("Do not prepend the enum name to constant or newtype variants."),
+            Arg::new("no-include-path-detection")
+                .long("no-include-path-detection")
+                .help("Do not try to detect default include paths"),
+            Arg::new("fit-macro-constant-types")
+                .long("fit-macro-constant-types")
+                .help("Try to fit macro constants into types smaller than u32/i32"),
+            Arg::new("unstable-rust")
+                .long("unstable-rust")
+                .help("Generate unstable Rust code (deprecated; use --rust-target instead).")
+                .multiple_occurrences(true), // FIXME: Pass legacy test suite
+            Arg::new("opaque-type")
+                .long("opaque-type")
+                .help("Mark <type> as opaque.")
+                .value_name("type")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("output")
+                .short('o')
+                .long("output")
+                .help("Write Rust bindings to <output>.")
+                .takes_value(true),
+            Arg::new("raw-line")
+                .long("raw-line")
+                .help("Add a raw line of Rust code at the beginning of output.")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("module-raw-line")
+                .long("module-raw-line")
+                .help("Add a raw line of Rust code to a given module.")
+                .multiple_occurrences(true)
+                .number_of_values(2)
+                .value_names(&["module-name", "raw-line"]),
+            Arg::new("rust-target")
+                .long("rust-target")
+                .help(rust_target_help.as_ref())
+                .takes_value(true),
+            Arg::new("use-core")
+                .long("use-core")
+                .help("Use types from Rust core instead of std."),
+            Arg::new("conservative-inline-namespaces")
+                .long("conservative-inline-namespaces")
+                .help(
+                    "Conservatively generate inline namespaces to avoid name \
+                     conflicts.",
+                ),
+            Arg::new("use-msvc-mangling")
+                .long("use-msvc-mangling")
+                .help("MSVC C++ ABI mangling. DEPRECATED: Has no effect."),
+            Arg::new("allowlist-function")
+                .long("allowlist-function")
+                .alias("whitelist-function")
+                .help(
+                    "Allowlist all the free-standing functions matching \
+                     <regex>. Other non-allowlisted functions will not be \
+                     generated.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("generate-inline-functions")
+                .long("generate-inline-functions")
+                .help("Generate inline functions."),
+            Arg::new("allowlist-type")
+                .long("allowlist-type")
+                .alias("whitelist-type")
+                .help(
+                    "Only generate types matching <regex>. Other non-allowlisted types will \
+                     not be generated.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("allowlist-var")
+                .long("allowlist-var")
+                .alias("whitelist-var")
+                .help(
+                    "Allowlist all the free-standing variables matching \
+                     <regex>. Other non-allowlisted variables will not be \
+                     generated.",
+                )
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("allowlist-file")
+                .alias("allowlist-file")
+                .long("allowlist-file")
+                .help("Allowlist all contents of <path>.")
+                .value_name("path")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("verbose")
+                .long("verbose")
+                .help("Print verbose error messages."),
+            Arg::new("dump-preprocessed-input")
+                .long("dump-preprocessed-input")
+                .help(
+                    "Preprocess and dump the input header files to disk. \
+                     Useful when debugging bindgen, using C-Reduce, or when \
+                     filing issues. The resulting file will be named \
+                     something like `__bindgen.i` or `__bindgen.ii`.",
+                ),
+            Arg::new("no-record-matches")
+                .long("no-record-matches")
+                .help(
+                    "Do not record matching items in the regex sets. \
+                     This disables reporting of unused items.",
+                ),
+            Arg::new("size_t-is-usize")
+                .long("size_t-is-usize")
+                .help("Ignored - this is enabled by default.")
+                .hidden(true),
+            Arg::with_name("no-size_t-is-usize")
+                .long("no-size_t-is-usize")
+                .help("Do not bind size_t as usize (useful on platforms \
+                       where those types are incompatible)."),
+            Arg::new("no-rustfmt-bindings")
+                .long("no-rustfmt-bindings")
+                .help("Do not format the generated bindings with rustfmt."),
+            Arg::new("rustfmt-bindings")
+                .long("rustfmt-bindings")
+                .help(
+                    "Format the generated bindings with rustfmt. DEPRECATED: \
+                     --rustfmt-bindings is now enabled by default. Disable \
+                     with --no-rustfmt-bindings.",
+                ),
+            Arg::new("rustfmt-configuration-file")
+                .long("rustfmt-configuration-file")
+                .help(
+                    "The absolute path to the rustfmt configuration file. \
+                     The configuration file will be used for formatting the bindings. \
+                     This parameter is incompatible with --no-rustfmt-bindings.",
+                )
+                .value_name("path")
+                .multiple_occurrences(false)
+                .number_of_values(1),
+            Arg::new("no-partialeq")
+                .long("no-partialeq")
+                .help("Avoid deriving PartialEq for types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("no-copy")
+                .long("no-copy")
+                .help("Avoid deriving Copy for types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("no-debug")
+                .long("no-debug")
+                .help("Avoid deriving Debug for types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("no-default")
+                .long("no-default")
+                .help("Avoid deriving/implement Default for types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("no-hash")
+                .long("no-hash")
+                .help("Avoid deriving Hash for types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("must-use-type")
+                .long("must-use-type")
+                .help("Add #[must_use] annotation to types matching <regex>.")
+                .value_name("regex")
+                .multiple_occurrences(true)
+                .number_of_values(1),
+            Arg::new("enable-function-attribute-detection")
+                .long("enable-function-attribute-detection")
+                .help(
+                    "Enables detecting unexposed attributes in functions (slow).
+                       Used to generate #[must_use] annotations.",
+                ),
+            Arg::new("use-array-pointers-in-arguments")
+                .long("use-array-pointers-in-arguments")
+                .help("Use `*const [T; size]` instead of `*const T` for C arrays"),
+            Arg::new("wasm-import-module-name")
+                .long("wasm-import-module-name")
+                .value_name("name")
+                .help("The name to be used in a #[link(wasm_import_module = ...)] statement"),
+            Arg::new("dynamic-loading")
+                .long("dynamic-loading")
+                .takes_value(true)
+                .help("Use dynamic loading mode with the given library name."),
+            Arg::new("dynamic-link-require-all")
+                .long("dynamic-link-require-all")
+                .help("Require successful linkage to all functions in the library."),
+            Arg::new("respect-cxx-access-specs")
+                .long("respect-cxx-access-specs")
+                .help("Makes generated bindings `pub` only for items if the items are publically accessible in C++."),
+            Arg::new("translate-enum-integer-types")
+                .long("translate-enum-integer-types")
+                .help("Always translate enum integer types to native Rust integer types."),
+            Arg::new("c-naming")
+                .long("c-naming")
+                .help("Generate types with C style naming."),
+            Arg::new("explicit-padding")
+                .long("explicit-padding")
+                .help("Always output explicit padding fields."),
+            Arg::new("vtable-generation")
+                .long("vtable-generation")
+                .help("Enables generation of vtable functions."),
+            Arg::new("sort-semantically")
+                .long("sort-semantically")
+                .help("Enables sorting of code generation in a predefined manner."),
+            Arg::new("merge-extern-blocks")
+                .long("merge-extern-blocks")
+                .help("Deduplicates extern blocks."),
+            Arg::new("V")
+                .long("version")
+                .help("Prints the version, and exits"),
+        ]) // .args()
+        .get_matches_from(args);
+
+    let verbose = matches.is_present("verbose");
+    if matches.is_present("V") {
+        println!(
+            "bindgen {}",
+            option_env!("CARGO_PKG_VERSION").unwrap_or("unknown")
+        );
+        if verbose {
+            println!("Clang: {}", bindgen::clang_version().full);
+        }
+        std::process::exit(0);
+    }
+
+    let mut builder = builder();
+
+    if let Some(header) = matches.value_of("header") {
+        builder = builder.header(header);
+    } else {
+        return Err(Error::new(ErrorKind::Other, "Header not found"));
+    }
+
+    if matches.is_present("unstable-rust") {
+        builder = builder.rust_target(RustTarget::Nightly);
+        writeln!(
+            &mut stderr(),
+            "warning: the `--unstable-rust` option is deprecated"
+        )
+        .expect("Unable to write error message");
+    }
+
+    if let Some(rust_target) = matches.value_of("rust-target") {
+        builder = builder.rust_target(RustTarget::from_str(rust_target)?);
+    }
+
+    if let Some(variant) = matches.value_of("default-enum-style") {
+        builder = builder.default_enum_style(EnumVariation::from_str(variant)?)
+    }
+
+    if let Some(bitfields) = matches.values_of("bitfield-enum") {
+        for regex in bitfields {
+            builder = builder.bitfield_enum(regex);
+        }
+    }
+
+    if let Some(newtypes) = matches.values_of("newtype-enum") {
+        for regex in newtypes {
+            builder = builder.newtype_enum(regex);
+        }
+    }
+
+    if let Some(newtypes) = matches.values_of("newtype-global-enum") {
+        for regex in newtypes {
+            builder = builder.newtype_global_enum(regex);
+        }
+    }
+
+    if let Some(rustifieds) = matches.values_of("rustified-enum") {
+        for regex in rustifieds {
+            builder = builder.rustified_enum(regex);
+        }
+    }
+
+    if let Some(const_enums) = matches.values_of("constified-enum") {
+        for regex in const_enums {
+            builder = builder.constified_enum(regex);
+        }
+    }
+
+    if let Some(constified_mods) = matches.values_of("constified-enum-module") {
+        for regex in constified_mods {
+            builder = builder.constified_enum_module(regex);
+        }
+    }
+
+    if let Some(variant) = matches.value_of("default-macro-constant-type") {
+        builder = builder
+            .default_macro_constant_type(MacroTypeVariation::from_str(variant)?)
+    }
+
+    if let Some(variant) = matches.value_of("default-alias-style") {
+        builder =
+            builder.default_alias_style(AliasVariation::from_str(variant)?);
+    }
+
+    if let Some(type_alias) = matches.values_of("normal-alias") {
+        for regex in type_alias {
+            builder = builder.type_alias(regex);
+        }
+    }
+
+    if let Some(new_type) = matches.values_of("new-type-alias") {
+        for regex in new_type {
+            builder = builder.new_type_alias(regex);
+        }
+    }
+
+    if let Some(new_type_deref) = matches.values_of("new-type-alias-deref") {
+        for regex in new_type_deref {
+            builder = builder.new_type_alias_deref(regex);
+        }
+    }
+
+    if let Some(variant) = matches.value_of("default-non-copy-union-style") {
+        builder = builder.default_non_copy_union_style(
+            NonCopyUnionStyle::from_str(variant)?,
+        );
+    }
+
+    if let Some(bindgen_wrapper_union) =
+        matches.values_of("bindgen-wrapper-union")
+    {
+        for regex in bindgen_wrapper_union {
+            builder = builder.bindgen_wrapper_union(regex);
+        }
+    }
+
+    if let Some(manually_drop_union) = matches.values_of("manually-drop-union")
+    {
+        for regex in manually_drop_union {
+            builder = builder.manually_drop_union(regex);
+        }
+    }
+
+    if let Some(hidden_types) = matches.values_of("blocklist-type") {
+        for ty in hidden_types {
+            builder = builder.blocklist_type(ty);
+        }
+    }
+
+    if let Some(hidden_functions) = matches.values_of("blocklist-function") {
+        for fun in hidden_functions {
+            builder = builder.blocklist_function(fun);
+        }
+    }
+
+    if let Some(hidden_identifiers) = matches.values_of("blocklist-item") {
+        for id in hidden_identifiers {
+            builder = builder.blocklist_item(id);
+        }
+    }
+
+    if let Some(hidden_files) = matches.values_of("blocklist-file") {
+        for file in hidden_files {
+            builder = builder.blocklist_file(file);
+        }
+    }
+
+    if matches.is_present("builtins") {
+        builder = builder.emit_builtins();
+    }
+
+    if matches.is_present("no-layout-tests") {
+        builder = builder.layout_tests(false);
+    }
+
+    if matches.is_present("no-derive-copy") {
+        builder = builder.derive_copy(false);
+    }
+
+    if matches.is_present("no-derive-debug") {
+        builder = builder.derive_debug(false);
+    }
+
+    if matches.is_present("impl-debug") {
+        builder = builder.impl_debug(true);
+    }
+
+    if matches.is_present("impl-partialeq") {
+        builder = builder.impl_partialeq(true);
+    }
+
+    if matches.is_present("with-derive-default") {
+        builder = builder.derive_default(true);
+    }
+
+    if matches.is_present("with-derive-hash") {
+        builder = builder.derive_hash(true);
+    }
+
+    if matches.is_present("with-derive-partialeq") {
+        builder = builder.derive_partialeq(true);
+    }
+
+    if matches.is_present("with-derive-partialord") {
+        builder = builder.derive_partialord(true);
+    }
+
+    if matches.is_present("with-derive-eq") {
+        builder = builder.derive_eq(true);
+    }
+
+    if matches.is_present("with-derive-ord") {
+        builder = builder.derive_ord(true);
+    }
+
+    if matches.is_present("no-derive-default") {
+        builder = builder.derive_default(false);
+    }
+
+    if matches.is_present("no-prepend-enum-name") {
+        builder = builder.prepend_enum_name(false);
+    }
+
+    if matches.is_present("no-include-path-detection") {
+        builder = builder.detect_include_paths(false);
+    }
+
+    if matches.is_present("fit-macro-constant-types") {
+        builder = builder.fit_macro_constants(true);
+    }
+
+    if matches.is_present("time-phases") {
+        builder = builder.time_phases(true);
+    }
+
+    if matches.is_present("use-array-pointers-in-arguments") {
+        builder = builder.array_pointers_in_arguments(true);
+    }
+
+    if let Some(wasm_import_name) = matches.value_of("wasm-import-module-name")
+    {
+        builder = builder.wasm_import_module_name(wasm_import_name);
+    }
+
+    if let Some(prefix) = matches.value_of("ctypes-prefix") {
+        builder = builder.ctypes_prefix(prefix);
+    }
+
+    if let Some(prefix) = matches.value_of("anon-fields-prefix") {
+        builder = builder.anon_fields_prefix(prefix);
+    }
+
+    if let Some(what_to_generate) = matches.value_of("generate") {
+        let mut config = CodegenConfig::empty();
+        for what in what_to_generate.split(',') {
+            match what {
+                "functions" => config.insert(CodegenConfig::FUNCTIONS),
+                "types" => config.insert(CodegenConfig::TYPES),
+                "vars" => config.insert(CodegenConfig::VARS),
+                "methods" => config.insert(CodegenConfig::METHODS),
+                "constructors" => config.insert(CodegenConfig::CONSTRUCTORS),
+                "destructors" => config.insert(CodegenConfig::DESTRUCTORS),
+                otherwise => {
+                    return Err(Error::new(
+                        ErrorKind::Other,
+                        format!("Unknown generate item: {}", otherwise),
+                    ));
+                }
+            }
+        }
+        builder = builder.with_codegen_config(config);
+    }
+
+    if matches.is_present("emit-clang-ast") {
+        builder = builder.emit_clang_ast();
+    }
+
+    if matches.is_present("emit-ir") {
+        builder = builder.emit_ir();
+    }
+
+    if let Some(path) = matches.value_of("emit-ir-graphviz") {
+        builder = builder.emit_ir_graphviz(path);
+    }
+
+    if matches.is_present("enable-cxx-namespaces") {
+        builder = builder.enable_cxx_namespaces();
+    }
+
+    if matches.is_present("enable-function-attribute-detection") {
+        builder = builder.enable_function_attribute_detection();
+    }
+
+    if matches.is_present("disable-name-namespacing") {
+        builder = builder.disable_name_namespacing();
+    }
+
+    if matches.is_present("disable-nested-struct-naming") {
+        builder = builder.disable_nested_struct_naming();
+    }
+
+    if matches.is_present("disable-untagged-union") {
+        builder = builder.disable_untagged_union();
+    }
+
+    if matches.is_present("disable-header-comment") {
+        builder = builder.disable_header_comment();
+    }
+
+    if matches.is_present("ignore-functions") {
+        builder = builder.ignore_functions();
+    }
+
+    if matches.is_present("ignore-methods") {
+        builder = builder.ignore_methods();
+    }
+
+    if matches.is_present("no-convert-floats") {
+        builder = builder.no_convert_floats();
+    }
+
+    if matches.is_present("no-doc-comments") {
+        builder = builder.generate_comments(false);
+    }
+
+    if matches.is_present("no-recursive-allowlist") {
+        builder = builder.allowlist_recursively(false);
+    }
+
+    if matches.is_present("objc-extern-crate") {
+        builder = builder.objc_extern_crate(true);
+    }
+
+    if matches.is_present("generate-block") {
+        builder = builder.generate_block(true);
+    }
+
+    if matches.is_present("block-extern-crate") {
+        builder = builder.block_extern_crate(true);
+    }
+
+    if let Some(opaque_types) = matches.values_of("opaque-type") {
+        for ty in opaque_types {
+            builder = builder.opaque_type(ty);
+        }
+    }
+
+    if let Some(lines) = matches.values_of("raw-line") {
+        for line in lines {
+            builder = builder.raw_line(line);
+        }
+    }
+
+    if let Some(mut values) = matches.values_of("module-raw-line") {
+        while let Some(module) = values.next() {
+            let line = values.next().unwrap();
+            builder = builder.module_raw_line(module, line);
+        }
+    }
+
+    if matches.is_present("use-core") {
+        builder = builder.use_core();
+    }
+
+    if matches.is_present("distrust-clang-mangling") {
+        builder = builder.trust_clang_mangling(false);
+    }
+
+    if matches.is_present("conservative-inline-namespaces") {
+        builder = builder.conservative_inline_namespaces();
+    }
+
+    if matches.is_present("generate-inline-functions") {
+        builder = builder.generate_inline_functions(true);
+    }
+
+    if let Some(allowlist) = matches.values_of("allowlist-function") {
+        for regex in allowlist {
+            builder = builder.allowlist_function(regex);
+        }
+    }
+
+    if let Some(allowlist) = matches.values_of("allowlist-type") {
+        for regex in allowlist {
+            builder = builder.allowlist_type(regex);
+        }
+    }
+
+    if let Some(allowlist) = matches.values_of("allowlist-var") {
+        for regex in allowlist {
+            builder = builder.allowlist_var(regex);
+        }
+    }
+
+    if let Some(hidden_files) = matches.values_of("allowlist-file") {
+        for file in hidden_files {
+            builder = builder.allowlist_file(file);
+        }
+    }
+
+    if let Some(args) = matches.values_of("clang-args") {
+        for arg in args {
+            builder = builder.clang_arg(arg);
+        }
+    }
+
+    let output = if let Some(path) = matches.value_of("output") {
+        let file = File::create(path)?;
+        if let Some(depfile) = matches.value_of("depfile") {
+            builder = builder.depfile(path, depfile);
+        }
+        Box::new(io::BufWriter::new(file)) as Box<dyn io::Write>
+    } else {
+        if let Some(depfile) = matches.value_of("depfile") {
+            builder = builder.depfile("-", depfile);
+        }
+        Box::new(io::BufWriter::new(io::stdout())) as Box<dyn io::Write>
+    };
+
+    if matches.is_present("dump-preprocessed-input") {
+        builder.dump_preprocessed_input()?;
+    }
+
+    if matches.is_present("no-record-matches") {
+        builder = builder.record_matches(false);
+    }
+
+    if matches.is_present("no-size_t-is-usize") {
+        builder = builder.size_t_is_usize(false);
+    }
+
+    let no_rustfmt_bindings = matches.is_present("no-rustfmt-bindings");
+    if no_rustfmt_bindings {
+        builder = builder.rustfmt_bindings(false);
+    }
+
+    if let Some(path_str) = matches.value_of("rustfmt-configuration-file") {
+        let path = PathBuf::from(path_str);
+
+        if no_rustfmt_bindings {
+            return Err(Error::new(
+                ErrorKind::Other,
+                "Cannot supply both --rustfmt-configuration-file and --no-rustfmt-bindings",
+            ));
+        }
+
+        if !path.is_absolute() {
+            return Err(Error::new(
+                ErrorKind::Other,
+                "--rustfmt-configuration--file needs to be an absolute path!",
+            ));
+        }
+
+        if path.to_str().is_none() {
+            return Err(Error::new(
+                ErrorKind::Other,
+                "--rustfmt-configuration-file contains non-valid UTF8 characters.",
+            ));
+        }
+
+        builder = builder.rustfmt_configuration_file(Some(path));
+    }
+
+    if let Some(no_partialeq) = matches.values_of("no-partialeq") {
+        for regex in no_partialeq {
+            builder = builder.no_partialeq(regex);
+        }
+    }
+
+    if let Some(no_copy) = matches.values_of("no-copy") {
+        for regex in no_copy {
+            builder = builder.no_copy(regex);
+        }
+    }
+
+    if let Some(no_debug) = matches.values_of("no-debug") {
+        for regex in no_debug {
+            builder = builder.no_debug(regex);
+        }
+    }
+
+    if let Some(no_default) = matches.values_of("no-default") {
+        for regex in no_default {
+            builder = builder.no_default(regex);
+        }
+    }
+
+    if let Some(no_hash) = matches.values_of("no-hash") {
+        for regex in no_hash {
+            builder = builder.no_hash(regex);
+        }
+    }
+
+    if let Some(must_use_type) = matches.values_of("must-use-type") {
+        for regex in must_use_type {
+            builder = builder.must_use_type(regex);
+        }
+    }
+
+    if let Some(dynamic_library_name) = matches.value_of("dynamic-loading") {
+        builder = builder.dynamic_library_name(dynamic_library_name);
+    }
+
+    if matches.is_present("dynamic-link-require-all") {
+        builder = builder.dynamic_link_require_all(true);
+    }
+
+    if matches.is_present("respect-cxx-access-specs") {
+        builder = builder.respect_cxx_access_specs(true);
+    }
+
+    if matches.is_present("translate-enum-integer-types") {
+        builder = builder.translate_enum_integer_types(true);
+    }
+
+    if matches.is_present("c-naming") {
+        builder = builder.c_naming(true);
+    }
+
+    if matches.is_present("explicit-padding") {
+        builder = builder.explicit_padding(true);
+    }
+
+    if matches.is_present("vtable-generation") {
+        builder = builder.vtable_generation(true);
+    }
+
+    if matches.is_present("sort-semantically") {
+        builder = builder.sort_semantically(true);
+    }
+
+    if matches.is_present("merge-extern-blocks") {
+        builder = builder.merge_extern_blocks(true);
+    }
+
+    Ok((builder, output, verbose))
+}
diff --git a/bindgen-integration/Cargo.toml b/bindgen-integration/Cargo.toml
index 733fba58..e2abb6e2 100644
--- a/bindgen-integration/Cargo.toml
+++ b/bindgen-integration/Cargo.toml
@@ -7,7 +7,7 @@ publish = false
 build = "build.rs"
 
 [build-dependencies]
-bindgen = { path = ".." }
+bindgen = { path = "../bindgen" }
 cc = "1.0"
 
 [features]
diff --git a/bindgen-integration/build.rs b/bindgen-integration/build.rs
index d0ec3bc0..980d40b9 100644
--- a/bindgen-integration/build.rs
+++ b/bindgen-integration/build.rs
@@ -123,13 +123,9 @@ impl ParseCallbacks for MacroCallback {
     // Test the "custom derives" capability by adding `PartialEq` to the `Test` struct.
     fn add_derives(&self, name: &str) -> Vec<String> {
         if name == "Test" {
-            vec![
-                "PartialEq".into(),
-            ]
+            vec!["PartialEq".into()]
         } else if name == "MyOrderedEnum" {
-            vec![
-                "std::cmp::PartialOrd".into(),
-            ]
+            vec!["std::cmp::PartialOrd".into()]
         } else {
             vec![]
         }
@@ -162,7 +158,9 @@ fn main() {
 
     let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
     let out_rust_file = out_path.join("test.rs");
-    let out_rust_file_relative = out_rust_file.strip_prefix(std::env::current_dir().unwrap()).unwrap();
+    let out_rust_file_relative = out_rust_file
+        .strip_prefix(std::env::current_dir().unwrap().parent().unwrap())
+        .unwrap();
     let out_dep_file = out_path.join("test.d");
 
     let bindings = Builder::default()
@@ -189,13 +187,18 @@ fn main() {
         .expect("Unable to generate bindings");
 
     assert!(macros.read().unwrap().contains("TESTMACRO"));
-    bindings.write_to_file(&out_rust_file).expect("Couldn't write bindings!");
-
-    let observed_deps = std::fs::read_to_string(out_dep_file).expect("Couldn't read depfile!");
-    let expected_deps = format!("{}: cpp/Test.h include/stub.h", out_rust_file_relative.display());
+    bindings
+        .write_to_file(&out_rust_file)
+        .expect("Couldn't write bindings!");
+
+    let observed_deps =
+        std::fs::read_to_string(out_dep_file).expect("Couldn't read depfile!");
+    let expected_deps = format!(
+        "{}: cpp/Test.h include/stub.h",
+        out_rust_file_relative.display()
+    );
     assert_eq!(
-        observed_deps,
-        expected_deps,
+        observed_deps, expected_deps,
         "including stub via include dir must produce correct dep path",
     );
 }
diff --git a/bindgen-tests/Cargo.toml b/bindgen-tests/Cargo.toml
new file mode 100644
index 00000000..53dfca15
--- /dev/null
+++ b/bindgen-tests/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "bindgen-tests"
+edition = "2018"
+version = "0.1.0"
+publish = false
+
+include = [
+  "Cargo.toml",
+  "build.rs",
+]
+
+[dev-dependencies]
+bindgen = { path = "../bindgen" }
+diff = "0.1"
+shlex = "1"
+clap = "3"
+tempfile = "3"
+
+[features]
+logging = ["bindgen/logging"]
+static = ["bindgen/static"]
+runtime = ["bindgen/runtime"]
+which-rustfmt = ["bindgen/which-rustfmt"]
+
+testing_only_docs = ["bindgen/testing_only_docs"]
+testing_only_extra_assertions = ["bindgen/testing_only_extra_assertions"]
+testing_only_libclang_9 = ["bindgen/testing_only_libclang_9"]
+testing_only_libclang_5 = ["bindgen/testing_only_libclang_5"]
diff --git a/bindgen-tests/build.rs b/bindgen-tests/build.rs
new file mode 100644
index 00000000..6b2f2c72
--- /dev/null
+++ b/bindgen-tests/build.rs
@@ -0,0 +1,49 @@
+use std::char;
+use std::env;
+use std::ffi::OsStr;
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+pub fn main() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let mut dst = File::create(Path::new(&out_dir).join("tests.rs")).unwrap();
+
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let headers_dir = manifest_dir.join("tests").join("headers");
+
+    let headers = match fs::read_dir(headers_dir) {
+        Ok(dir) => dir,
+        // We may not have headers directory after packaging.
+        Err(..) => return,
+    };
+
+    let entries =
+        headers.map(|result| result.expect("Couldn't read header file"));
+
+    println!("cargo:rerun-if-changed=tests/headers");
+
+    for entry in entries {
+        match entry.path().extension().and_then(OsStr::to_str) {
+            Some("h") | Some("hpp") => {
+                let func = entry
+                    .file_name()
+                    .to_str()
+                    .unwrap()
+                    .replace(|c| !char::is_alphanumeric(c), "_")
+                    .replace("__", "_")
+                    .to_lowercase();
+                writeln!(
+                    dst,
+                    "test_header!(header_{}, {:?});",
+                    func,
+                    entry.path(),
+                )
+                .unwrap();
+            }
+            _ => {}
+        }
+    }
+
+    dst.flush().unwrap();
+}
diff --git a/bindgen-tests/src/lib.rs b/bindgen-tests/src/lib.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/bindgen-tests/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/bindgen-tests/tests/.gitattributes b/bindgen-tests/tests/.gitattributes
new file mode 100644
index 00000000..96122eb1
--- /dev/null
+++ b/bindgen-tests/tests/.gitattributes
@@ -0,0 +1,4 @@
+# Tell Github Linguist to avoid counting these C and C++ test inputs toward
+# statistics.
+*.h -linguist-detectable
+*.hpp -linguist-detectable
diff --git a/bindgen-tests/tests/expectations/Cargo.toml b/bindgen-tests/tests/expectations/Cargo.toml
new file mode 100644
index 00000000..f8006afe
--- /dev/null
+++ b/bindgen-tests/tests/expectations/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "tests_expectations"
+description = "bindgen results when ran on ../headers/*"
+version = "0.1.0"
+authors = [
+  "Jyun-Yan You <jyyou.tw@gmail.com>",
+  "Emilio Cobos Álvarez <emilio@crisal.io>",
+  "The Servo project developers",
+]
+edition = "2018"
+
+[dependencies]
+objc = "0.2"
+block = "0.1"
+libloading = "0.6.2"
diff --git a/bindgen-tests/tests/expectations/build.rs b/bindgen-tests/tests/expectations/build.rs
new file mode 100644
index 00000000..edbcafb9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/build.rs
@@ -0,0 +1,63 @@
+//! Generate a module with a custom `#[path=...]` for each of the files in our
+//! libclang version-specific test expectations so that they get their layout
+//! tests run. We need to do this because cargo doesn't automatically detect
+//! tests subdirectories.
+
+use std::env;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
+
+const LIBCLANG_VERSION_DIRS: &'static [&'static str] =
+    &["libclang-5", "libclang-9"];
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let mut test_string = String::new();
+
+    for dir in LIBCLANG_VERSION_DIRS {
+        let dir = Path::new(&env::var_os("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests")
+            .join(dir);
+
+        println!("cargo:rerun-if-changed={}", dir.display());
+
+        for entry in fs::read_dir(dir).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            let path = path.canonicalize().unwrap_or_else(|_| path.into());
+            if path.extension().map(|e| e.to_string_lossy()) !=
+                Some("rs".into())
+            {
+                continue;
+            }
+
+            println!("cargo:rerun-if-changed={}", path.display());
+
+            let module_name: String = path
+                .display()
+                .to_string()
+                .chars()
+                .map(|c| match c {
+                    'a'..='z' | 'A'..='Z' | '0'..='9' => c,
+                    _ => '_',
+                })
+                .collect();
+
+            test_string.push_str(&format!(
+                r###"
+#[path = "{}"]
+mod {};
+"###,
+                path.display().to_string().replace('\\', "\\\\"),
+                module_name,
+            ));
+        }
+    }
+
+    let out_path = Path::new(&env::var_os("OUT_DIR").unwrap())
+        .join("libclang_version_specific_generated_tests.rs");
+    let mut test_file = fs::File::create(out_path).unwrap();
+    test_file.write_all(test_string.as_bytes()).unwrap();
+}
diff --git a/bindgen-tests/tests/expectations/lib.rs b/bindgen-tests/tests/expectations/lib.rs
new file mode 100755
index 00000000..562dc554
--- /dev/null
+++ b/bindgen-tests/tests/expectations/lib.rs
@@ -0,0 +1,3 @@
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+#![allow(non_upper_case_globals)]
diff --git a/bindgen-tests/tests/expectations/src/lib.rs b/bindgen-tests/tests/expectations/src/lib.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/bindgen-tests/tests/expectations/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs b/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/bindgen-tests/tests/expectations/struct_with_anon_struct_array_float.rs
@@ -0,0 +1 @@
+
diff --git a/bindgen-tests/tests/expectations/tests/.gitattributes b/bindgen-tests/tests/expectations/tests/.gitattributes
new file mode 100644
index 00000000..9699dfa0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/.gitattributes
@@ -0,0 +1,2 @@
+# Prevent Github Linguist from counting generated files in statistics.
+*.rs linguist-generated
diff --git a/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs b/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs
new file mode 100644
index 00000000..a60a63aa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/16-byte-alignment.rs
@@ -0,0 +1,355 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_ipv4_tuple {
+    pub src_addr: u32,
+    pub dst_addr: u32,
+    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_ipv4_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+    pub sctp_tag: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
+    pub dport: u16,
+    pub sport: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(dport)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(sport)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1),
+            "::",
+            stringify!(sctp_tag)
+        )
+    );
+}
+impl Default for rte_ipv4_tuple__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_ipv4_tuple))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv4_tuple))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple),
+            "::",
+            stringify!(src_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple),
+            "::",
+            stringify!(dst_addr)
+        )
+    );
+}
+impl Default for rte_ipv4_tuple {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_ipv6_tuple {
+    pub src_addr: [u8; 16usize],
+    pub dst_addr: [u8; 16usize],
+    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_ipv6_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+    pub sctp_tag: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
+    pub dport: u16,
+    pub sport: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(dport)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(sport)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1),
+            "::",
+            stringify!(sctp_tag)
+        )
+    );
+}
+impl Default for rte_ipv6_tuple__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_ipv6_tuple))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv6_tuple))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple),
+            "::",
+            stringify!(src_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple),
+            "::",
+            stringify!(dst_addr)
+        )
+    );
+}
+impl Default for rte_ipv6_tuple {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Copy, Clone)]
+pub union rte_thash_tuple {
+    pub v4: rte_ipv4_tuple,
+    pub v6: rte_ipv6_tuple,
+}
+#[test]
+fn bindgen_test_layout_rte_thash_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_thash_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_thash_tuple>(),
+        48usize,
+        concat!("Size of: ", stringify!(rte_thash_tuple))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_thash_tuple>(),
+        16usize,
+        concat!("Alignment of ", stringify!(rte_thash_tuple))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v4) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_thash_tuple),
+            "::",
+            stringify!(v4)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v6) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_thash_tuple),
+            "::",
+            stringify!(v6)
+        )
+    );
+}
+impl Default for rte_thash_tuple {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/16-byte-alignment_1_0.rs b/bindgen-tests/tests/expectations/tests/16-byte-alignment_1_0.rs
new file mode 100644
index 00000000..369e2c75
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/16-byte-alignment_1_0.rs
@@ -0,0 +1,396 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv4_tuple {
+    pub src_addr: u32,
+    pub dst_addr: u32,
+    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv4_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1:
+        __BindgenUnionField<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>,
+    pub sctp_tag: __BindgenUnionField<u32>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
+    pub dport: u16,
+    pub sport: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(dport)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(sport)
+        )
+    );
+}
+impl Clone for rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple__bindgen_ty_1),
+            "::",
+            stringify!(sctp_tag)
+        )
+    );
+}
+impl Clone for rte_ipv4_tuple__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv4_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv4_tuple>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_ipv4_tuple))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv4_tuple>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv4_tuple))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple),
+            "::",
+            stringify!(src_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv4_tuple),
+            "::",
+            stringify!(dst_addr)
+        )
+    );
+}
+impl Clone for rte_ipv4_tuple {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv6_tuple {
+    pub src_addr: [u8; 16usize],
+    pub dst_addr: [u8; 16usize],
+    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv6_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1:
+        __BindgenUnionField<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>,
+    pub sctp_tag: __BindgenUnionField<u32>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
+    pub dport: u16,
+    pub sport: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(dport)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(sport)
+        )
+    );
+}
+impl Clone for rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple__bindgen_ty_1),
+            "::",
+            stringify!(sctp_tag)
+        )
+    );
+}
+impl Clone for rte_ipv6_tuple__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_ipv6_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ipv6_tuple>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_ipv6_tuple))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ipv6_tuple>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ipv6_tuple))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple),
+            "::",
+            stringify!(src_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ipv6_tuple),
+            "::",
+            stringify!(dst_addr)
+        )
+    );
+}
+impl Clone for rte_ipv6_tuple {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Copy)]
+pub struct rte_thash_tuple {
+    pub v4: __BindgenUnionField<rte_ipv4_tuple>,
+    pub v6: __BindgenUnionField<rte_ipv6_tuple>,
+    pub bindgen_union_field: [u8; 48usize],
+}
+#[test]
+fn bindgen_test_layout_rte_thash_tuple() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_thash_tuple> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_thash_tuple>(),
+        48usize,
+        concat!("Size of: ", stringify!(rte_thash_tuple))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v4) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_thash_tuple),
+            "::",
+            stringify!(v4)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v6) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_thash_tuple),
+            "::",
+            stringify!(v6)
+        )
+    );
+}
+impl Clone for rte_thash_tuple {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_thash_tuple {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs b/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs
new file mode 100644
index 00000000..f4312a11
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/381-decltype-alias.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct std_allocator_traits {
+    pub _address: u8,
+}
+pub type std_allocator_traits___size_type<_Alloc> = _Alloc;
diff --git a/bindgen-tests/tests/expectations/tests/accessors.rs b/bindgen-tests/tests/expectations/tests/accessors.rs
new file mode 100644
index 00000000..05fdaf4c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/accessors.rs
@@ -0,0 +1,434 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct SomeAccessors {
+    pub mNoAccessor: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor></div>
+    pub mBothAccessors: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor="unsafe"></div>
+    pub mUnsafeAccessors: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor="immutable"></div>
+    pub mImmutableAccessor: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_SomeAccessors() {
+    const UNINIT: ::std::mem::MaybeUninit<SomeAccessors> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<SomeAccessors>(),
+        16usize,
+        concat!("Size of: ", stringify!(SomeAccessors))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<SomeAccessors>(),
+        4usize,
+        concat!("Alignment of ", stringify!(SomeAccessors))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mNoAccessor) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SomeAccessors),
+            "::",
+            stringify!(mNoAccessor)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SomeAccessors),
+            "::",
+            stringify!(mBothAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mUnsafeAccessors) as usize -
+                ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SomeAccessors),
+            "::",
+            stringify!(mUnsafeAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mImmutableAccessor) as usize -
+                ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SomeAccessors),
+            "::",
+            stringify!(mImmutableAccessor)
+        )
+    );
+}
+impl SomeAccessors {
+    #[inline]
+    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mBothAccessors
+    }
+    #[inline]
+    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
+        &mut self.mBothAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mUnsafeAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mUnsafeAccessors_mut(
+        &mut self,
+    ) -> &mut ::std::os::raw::c_int {
+        &mut self.mUnsafeAccessors
+    }
+    #[inline]
+    pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int {
+        &self.mImmutableAccessor
+    }
+}
+/// <div rustbindgen accessor></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllAccessors {
+    pub mBothAccessors: ::std::os::raw::c_int,
+    pub mAlsoBothAccessors: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AllAccessors() {
+    const UNINIT: ::std::mem::MaybeUninit<AllAccessors> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllAccessors>(),
+        8usize,
+        concat!("Size of: ", stringify!(AllAccessors))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllAccessors>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllAccessors))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllAccessors),
+            "::",
+            stringify!(mBothAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mAlsoBothAccessors) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllAccessors),
+            "::",
+            stringify!(mAlsoBothAccessors)
+        )
+    );
+}
+impl AllAccessors {
+    #[inline]
+    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mBothAccessors
+    }
+    #[inline]
+    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
+        &mut self.mBothAccessors
+    }
+    #[inline]
+    pub fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mAlsoBothAccessors
+    }
+    #[inline]
+    pub fn get_mAlsoBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
+        &mut self.mAlsoBothAccessors
+    }
+}
+/// <div rustbindgen accessor="unsafe"></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllUnsafeAccessors {
+    pub mBothAccessors: ::std::os::raw::c_int,
+    pub mAlsoBothAccessors: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AllUnsafeAccessors() {
+    const UNINIT: ::std::mem::MaybeUninit<AllUnsafeAccessors> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllUnsafeAccessors>(),
+        8usize,
+        concat!("Size of: ", stringify!(AllUnsafeAccessors))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllUnsafeAccessors>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllUnsafeAccessors))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllUnsafeAccessors),
+            "::",
+            stringify!(mBothAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mAlsoBothAccessors) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllUnsafeAccessors),
+            "::",
+            stringify!(mAlsoBothAccessors)
+        )
+    );
+}
+impl AllUnsafeAccessors {
+    #[inline]
+    pub unsafe fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mBothAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mBothAccessors_mut(
+        &mut self,
+    ) -> &mut ::std::os::raw::c_int {
+        &mut self.mBothAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mAlsoBothAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mAlsoBothAccessors_mut(
+        &mut self,
+    ) -> &mut ::std::os::raw::c_int {
+        &mut self.mAlsoBothAccessors
+    }
+}
+/// <div rustbindgen accessor></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ContradictAccessors {
+    pub mBothAccessors: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor="false"></div>
+    pub mNoAccessors: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor="unsafe"></div>
+    pub mUnsafeAccessors: ::std::os::raw::c_int,
+    /// <div rustbindgen accessor="immutable"></div>
+    pub mImmutableAccessor: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ContradictAccessors() {
+    const UNINIT: ::std::mem::MaybeUninit<ContradictAccessors> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContradictAccessors>(),
+        16usize,
+        concat!("Size of: ", stringify!(ContradictAccessors))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContradictAccessors>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ContradictAccessors))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictAccessors),
+            "::",
+            stringify!(mBothAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mNoAccessors) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictAccessors),
+            "::",
+            stringify!(mNoAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mUnsafeAccessors) as usize -
+                ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictAccessors),
+            "::",
+            stringify!(mUnsafeAccessors)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mImmutableAccessor) as usize -
+                ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictAccessors),
+            "::",
+            stringify!(mImmutableAccessor)
+        )
+    );
+}
+impl ContradictAccessors {
+    #[inline]
+    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mBothAccessors
+    }
+    #[inline]
+    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
+        &mut self.mBothAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int {
+        &self.mUnsafeAccessors
+    }
+    #[inline]
+    pub unsafe fn get_mUnsafeAccessors_mut(
+        &mut self,
+    ) -> &mut ::std::os::raw::c_int {
+        &mut self.mUnsafeAccessors
+    }
+    #[inline]
+    pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int {
+        &self.mImmutableAccessor
+    }
+}
+/// <div rustbindgen accessor replaces="Replaced"></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Replaced {
+    pub mAccessor: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Replaced() {
+    const UNINIT: ::std::mem::MaybeUninit<Replaced> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Replaced>(),
+        4usize,
+        concat!("Size of: ", stringify!(Replaced))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Replaced>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Replaced))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mAccessor) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Replaced),
+            "::",
+            stringify!(mAccessor)
+        )
+    );
+}
+impl Replaced {
+    #[inline]
+    pub fn get_mAccessor(&self) -> &::std::os::raw::c_int {
+        &self.mAccessor
+    }
+    #[inline]
+    pub fn get_mAccessor_mut(&mut self) -> &mut ::std::os::raw::c_int {
+        &mut self.mAccessor
+    }
+}
+/// <div rustbindgen accessor></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Wrapper {
+    pub mReplaced: Replaced,
+}
+#[test]
+fn bindgen_test_layout_Wrapper() {
+    const UNINIT: ::std::mem::MaybeUninit<Wrapper> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Wrapper>(),
+        4usize,
+        concat!("Size of: ", stringify!(Wrapper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Wrapper>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Wrapper))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mReplaced) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Wrapper),
+            "::",
+            stringify!(mReplaced)
+        )
+    );
+}
+impl Wrapper {
+    #[inline]
+    pub fn get_mReplaced(&self) -> &Replaced {
+        &self.mReplaced
+    }
+    #[inline]
+    pub fn get_mReplaced_mut(&mut self) -> &mut Replaced {
+        &mut self.mReplaced
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist-file.rs b/bindgen-tests/tests/expectations/tests/allowlist-file.rs
new file mode 100644
index 00000000..3b72fb75
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist-file.rs
@@ -0,0 +1,155 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const SOME_DEFUN: u32 = 123;
+extern "C" {
+    #[link_name = "\u{1}_Z12SomeFunctionv"]
+    pub fn SomeFunction();
+}
+extern "C" {
+    pub static mut someVar: ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct someClass {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_someClass() {
+    assert_eq!(
+        ::std::mem::size_of::<someClass>(),
+        1usize,
+        concat!("Size of: ", stringify!(someClass))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<someClass>(),
+        1usize,
+        concat!("Alignment of ", stringify!(someClass))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN9someClass16somePublicMethodEi"]
+    pub fn someClass_somePublicMethod(
+        this: *mut someClass,
+        foo: ::std::os::raw::c_int,
+    );
+}
+impl someClass {
+    #[inline]
+    pub unsafe fn somePublicMethod(&mut self, foo: ::std::os::raw::c_int) {
+        someClass_somePublicMethod(self, foo)
+    }
+}
+extern "C" {
+    pub fn ExternFunction();
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3foo18NamespacedFunctionEv"]
+    pub fn foo_NamespacedFunction();
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StructWithAllowlistedDefinition {
+    pub other: *mut StructWithAllowlistedFwdDecl,
+}
+#[test]
+fn bindgen_test_layout_StructWithAllowlistedDefinition() {
+    const UNINIT: ::std::mem::MaybeUninit<StructWithAllowlistedDefinition> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StructWithAllowlistedDefinition>(),
+        8usize,
+        concat!("Size of: ", stringify!(StructWithAllowlistedDefinition))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StructWithAllowlistedDefinition>(),
+        8usize,
+        concat!("Alignment of ", stringify!(StructWithAllowlistedDefinition))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).other) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StructWithAllowlistedDefinition),
+            "::",
+            stringify!(other)
+        )
+    );
+}
+impl Default for StructWithAllowlistedDefinition {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct StructWithAllowlistedFwdDecl {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_StructWithAllowlistedFwdDecl() {
+    const UNINIT: ::std::mem::MaybeUninit<StructWithAllowlistedFwdDecl> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StructWithAllowlistedFwdDecl>(),
+        4usize,
+        concat!("Size of: ", stringify!(StructWithAllowlistedFwdDecl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StructWithAllowlistedFwdDecl>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StructWithAllowlistedFwdDecl))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StructWithAllowlistedFwdDecl),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllowlistMe {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AllowlistMe() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistMe>(),
+        4usize,
+        concat!("Size of: ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistMe>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistMe),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs b/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs
new file mode 100644
index 00000000..36d03fef
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist-namespaces-basic.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod outer {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod inner {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            #[repr(C)]
+            #[derive(Debug, Default, Copy, Clone)]
+            pub struct Helper {
+                pub _address: u8,
+            }
+            #[test]
+            fn bindgen_test_layout_Helper() {
+                assert_eq!(
+                    ::std::mem::size_of::<Helper>(),
+                    1usize,
+                    concat!("Size of: ", stringify!(Helper))
+                );
+                assert_eq!(
+                    ::std::mem::align_of::<Helper>(),
+                    1usize,
+                    concat!("Alignment of ", stringify!(Helper))
+                );
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs b/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs
new file mode 100644
index 00000000..ee9fe428
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist-namespaces.rs
@@ -0,0 +1,71 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod outer {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod inner {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            #[repr(C)]
+            #[derive(Debug, Default, Copy, Clone)]
+            pub struct Helper {
+                pub _address: u8,
+            }
+            #[test]
+            fn bindgen_test_layout_Helper() {
+                assert_eq!(
+                    ::std::mem::size_of::<Helper>(),
+                    1usize,
+                    concat!("Size of: ", stringify!(Helper))
+                );
+                assert_eq!(
+                    ::std::mem::align_of::<Helper>(),
+                    1usize,
+                    concat!("Alignment of ", stringify!(Helper))
+                );
+            }
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Test {
+            pub helper: root::outer::inner::Helper,
+        }
+        #[test]
+        fn bindgen_test_layout_Test() {
+            const UNINIT: ::std::mem::MaybeUninit<Test> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Test>(),
+                1usize,
+                concat!("Size of: ", stringify!(Test))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Test>(),
+                1usize,
+                concat!("Alignment of ", stringify!(Test))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).helper) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Test),
+                    "::",
+                    stringify!(helper)
+                )
+            );
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist_basic.rs b/bindgen-tests/tests/expectations/tests/allowlist_basic.rs
new file mode 100644
index 00000000..5bfe42e8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist_basic.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct AllowlistMe<T> {
+    pub foo: ::std::os::raw::c_int,
+    pub bar: AllowlistMe_Inner<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct AllowlistMe_Inner<T> {
+    pub bar: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for AllowlistMe_Inner<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> Default for AllowlistMe<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist_fix.rs b/bindgen-tests/tests/expectations/tests/allowlist_fix.rs
new file mode 100644
index 00000000..9cff795b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist_fix.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub enum Test {}
+
+extern "C" {
+    pub fn Servo_Test(a: *mut Test);
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlist_vars.rs b/bindgen-tests/tests/expectations/tests/allowlist_vars.rs
new file mode 100644
index 00000000..590cbafc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist_vars.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const NONE: u32 = 0;
+pub const FOO: u32 = 5;
+pub const FOOB: i32 = -2;
+pub const FOOBAR: i32 = -10;
diff --git a/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs b/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlist_warnings.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs
new file mode 100644
index 00000000..56dc5bce
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-hash.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoHash {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_NoHash() {
+    assert_eq!(
+        ::std::mem::size_of::<NoHash>(),
+        1usize,
+        concat!("Size of: ", stringify!(NoHash))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoHash>(),
+        1usize,
+        concat!("Alignment of ", stringify!(NoHash))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllowlistMe {
+    pub a: NoHash,
+}
+#[test]
+fn bindgen_test_layout_AllowlistMe() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistMe>(),
+        1usize,
+        concat!("Size of: ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistMe>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistMe),
+            "::",
+            stringify!(a)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
new file mode 100644
index 00000000..36cdda0e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoPartialEq {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_NoPartialEq() {
+    assert_eq!(
+        ::std::mem::size_of::<NoPartialEq>(),
+        1usize,
+        concat!("Size of: ", stringify!(NoPartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoPartialEq>(),
+        1usize,
+        concat!("Alignment of ", stringify!(NoPartialEq))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AllowlistMe {
+    pub a: NoPartialEq,
+}
+#[test]
+fn bindgen_test_layout_AllowlistMe() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistMe>(),
+        1usize,
+        concat!("Size of: ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistMe>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistMe),
+            "::",
+            stringify!(a)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs b/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs
new file mode 100644
index 00000000..625e0ce6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/allowlisted_item_references_no_copy.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NoCopy {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_NoCopy() {
+    assert_eq!(
+        ::std::mem::size_of::<NoCopy>(),
+        1usize,
+        concat!("Size of: ", stringify!(NoCopy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoCopy>(),
+        1usize,
+        concat!("Alignment of ", stringify!(NoCopy))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct AllowlistMe {
+    pub a: NoCopy,
+}
+#[test]
+fn bindgen_test_layout_AllowlistMe() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistMe>(),
+        1usize,
+        concat!("Size of: ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistMe>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AllowlistMe))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistMe),
+            "::",
+            stringify!(a)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/annotation_hide.rs b/bindgen-tests/tests/expectations/tests/annotation_hide.rs
new file mode 100644
index 00000000..a90c4261
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/annotation_hide.rs
@@ -0,0 +1,58 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen opaque></div>
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct D {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_D() {
+    assert_eq!(
+        ::std::mem::size_of::<D>(),
+        4usize,
+        concat!("Size of: ", stringify!(D))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<D>(),
+        4usize,
+        concat!("Alignment of ", stringify!(D))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NotAnnotated {
+    pub f: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NotAnnotated() {
+    const UNINIT: ::std::mem::MaybeUninit<NotAnnotated> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NotAnnotated>(),
+        4usize,
+        concat!("Size of: ", stringify!(NotAnnotated))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NotAnnotated>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NotAnnotated))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NotAnnotated),
+            "::",
+            stringify!(f)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs b/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs
new file mode 100644
index 00000000..d09cab40
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon-fields-prefix.rs
@@ -0,0 +1,150 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union color {
+    pub u1: color__bindgen_ty_1,
+    pub u2: color__bindgen_ty_2,
+    pub v3: [::std::os::raw::c_uchar; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct color__bindgen_ty_1 {
+    pub r: ::std::os::raw::c_uchar,
+    pub g: ::std::os::raw::c_uchar,
+    pub b: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_color__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<color__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<color__bindgen_ty_1>(),
+        3usize,
+        concat!("Size of: ", stringify!(color__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<color__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(color__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_1),
+            "::",
+            stringify!(r)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_1),
+            "::",
+            stringify!(g)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct color__bindgen_ty_2 {
+    pub y: ::std::os::raw::c_uchar,
+    pub u: ::std::os::raw::c_uchar,
+    pub v: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_color__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<color__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<color__bindgen_ty_2>(),
+        3usize,
+        concat!("Size of: ", stringify!(color__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<color__bindgen_ty_2>(),
+        1usize,
+        concat!("Alignment of ", stringify!(color__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_2),
+            "::",
+            stringify!(y)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_2),
+            "::",
+            stringify!(u)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(color__bindgen_ty_2),
+            "::",
+            stringify!(v)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_color() {
+    const UNINIT: ::std::mem::MaybeUninit<color> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<color>(),
+        3usize,
+        concat!("Size of: ", stringify!(color))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<color>(),
+        1usize,
+        concat!("Alignment of ", stringify!(color))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v3) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(color), "::", stringify!(v3))
+    );
+}
+impl Default for color {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_enum.rs b/bindgen-tests/tests/expectations/tests/anon_enum.rs
new file mode 100644
index 00000000..429f94ce
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_enum.rs
@@ -0,0 +1,51 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialEq)]
+pub struct Test {
+    pub foo: ::std::os::raw::c_int,
+    pub bar: f32,
+}
+pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Test__bindgen_ty_1 {
+    T_NONE = 0,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        8usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(bar))
+    );
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Baz {
+    Foo = 0,
+    Bar = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs
new file mode 100644
index 00000000..f0c06c56
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_enum_allowlist.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const NODE_FLAG_FOO: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_FOO;
+pub const NODE_FLAG_BAR: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_BAR;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    NODE_FLAG_FOO = 0,
+    NODE_FLAG_BAR = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs b/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs
new file mode 100644
index 00000000..9d6b8f57
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_enum_trait.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct DataType {
+    pub _address: u8,
+}
+pub type DataType_value_type<_Tp> = _Tp;
+pub type DataType_work_type<_Tp> = DataType_value_type<_Tp>;
+pub type DataType_channel_type<_Tp> = DataType_value_type<_Tp>;
+pub type DataType_vec_type<_Tp> = DataType_value_type<_Tp>;
+pub const DataType_generic_type: DataType__bindgen_ty_1 =
+    DataType__bindgen_ty_1::generic_type;
+pub const DataType_depth: DataType__bindgen_ty_1 =
+    DataType__bindgen_ty_1::generic_type;
+pub const DataType_channels: DataType__bindgen_ty_1 =
+    DataType__bindgen_ty_1::generic_type;
+pub const DataType_fmt: DataType__bindgen_ty_1 =
+    DataType__bindgen_ty_1::generic_type;
+pub const DataType_type_: DataType__bindgen_ty_1 =
+    DataType__bindgen_ty_1::generic_type;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum DataType__bindgen_ty_1 {
+    generic_type = 0,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
+pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo__bindgen_ty_1 {
+    Bar = 0,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs b/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs
new file mode 100644
index 00000000..f32b057b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_struct_in_union.rs
@@ -0,0 +1,113 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct s {
+    pub u: s__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union s__bindgen_ty_1 {
+    pub field: s__bindgen_ty_1_inner,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct s__bindgen_ty_1_inner {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_s__bindgen_ty_1_inner() {
+    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1_inner> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s__bindgen_ty_1_inner>(),
+        4usize,
+        concat!("Size of: ", stringify!(s__bindgen_ty_1_inner))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s__bindgen_ty_1_inner>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s__bindgen_ty_1_inner))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(s__bindgen_ty_1_inner),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_s__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(s__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(s__bindgen_ty_1),
+            "::",
+            stringify!(field)
+        )
+    );
+}
+impl Default for s__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_s() {
+    const UNINIT: ::std::mem::MaybeUninit<s> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s>(),
+        4usize,
+        concat!("Size of: ", stringify!(s))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(s), "::", stringify!(u))
+    );
+}
+impl Default for s {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_struct_in_union_1_0.rs b/bindgen-tests/tests/expectations/tests/anon_struct_in_union_1_0.rs
new file mode 100644
index 00000000..cbc5ac9b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_struct_in_union_1_0.rs
@@ -0,0 +1,154 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct s {
+    pub u: s__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct s__bindgen_ty_1 {
+    pub field: __BindgenUnionField<s__bindgen_ty_1_inner>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct s__bindgen_ty_1_inner {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_s__bindgen_ty_1_inner() {
+    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1_inner> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s__bindgen_ty_1_inner>(),
+        4usize,
+        concat!("Size of: ", stringify!(s__bindgen_ty_1_inner))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s__bindgen_ty_1_inner>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s__bindgen_ty_1_inner))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(s__bindgen_ty_1_inner),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for s__bindgen_ty_1_inner {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_s__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(s__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(s__bindgen_ty_1),
+            "::",
+            stringify!(field)
+        )
+    );
+}
+impl Clone for s__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_s() {
+    const UNINIT: ::std::mem::MaybeUninit<s> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<s>(),
+        4usize,
+        concat!("Size of: ", stringify!(s))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<s>(),
+        4usize,
+        concat!("Alignment of ", stringify!(s))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(s), "::", stringify!(u))
+    );
+}
+impl Clone for s {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_union.rs b/bindgen-tests/tests/expectations/tests/anon_union.rs
new file mode 100644
index 00000000..8caf7d11
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_union.rs
@@ -0,0 +1,101 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct TErrorResult {
+    pub mResult: ::std::os::raw::c_int,
+    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
+    pub mMightHaveUnreported: bool,
+    pub mUnionState: TErrorResult_UnionState,
+}
+impl TErrorResult_UnionState {
+    pub const HasException: TErrorResult_UnionState =
+        TErrorResult_UnionState::HasMessage;
+}
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum TErrorResult_UnionState {
+    HasMessage = 0,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TErrorResult_Message {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TErrorResult_DOMExceptionInfo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+pub union TErrorResult__bindgen_ty_1 {
+    pub mMessage: *mut TErrorResult_Message,
+    pub mDOMExceptionInfo: *mut TErrorResult_DOMExceptionInfo,
+}
+impl Default for TErrorResult__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for TErrorResult {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct ErrorResult {
+    pub _base: TErrorResult,
+}
+#[test]
+fn bindgen_test_layout_ErrorResult() {
+    assert_eq!(
+        ::std::mem::size_of::<ErrorResult>(),
+        24usize,
+        concat!("Size of: ", stringify!(ErrorResult))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ErrorResult>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ErrorResult))
+    );
+}
+impl Default for ErrorResult {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<TErrorResult>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TErrorResult>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/anon_union_1_0.rs b/bindgen-tests/tests/expectations/tests/anon_union_1_0.rs
new file mode 100644
index 00000000..63273e60
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anon_union_1_0.rs
@@ -0,0 +1,143 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct TErrorResult {
+    pub mResult: ::std::os::raw::c_int,
+    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
+    pub mMightHaveUnreported: bool,
+    pub mUnionState: TErrorResult_UnionState,
+}
+pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
+    TErrorResult_UnionState::HasMessage;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum TErrorResult_UnionState {
+    HasMessage = 0,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TErrorResult_Message {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TErrorResult_DOMExceptionInfo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct TErrorResult__bindgen_ty_1 {
+    pub mMessage: __BindgenUnionField<*mut TErrorResult_Message>,
+    pub mDOMExceptionInfo:
+        __BindgenUnionField<*mut TErrorResult_DOMExceptionInfo>,
+    pub bindgen_union_field: u64,
+}
+impl Default for TErrorResult {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct ErrorResult {
+    pub _base: TErrorResult,
+}
+#[test]
+fn bindgen_test_layout_ErrorResult() {
+    assert_eq!(
+        ::std::mem::size_of::<ErrorResult>(),
+        24usize,
+        concat!("Size of: ", stringify!(ErrorResult))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ErrorResult>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ErrorResult))
+    );
+}
+impl Clone for ErrorResult {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for ErrorResult {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<TErrorResult>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TErrorResult>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs b/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs
new file mode 100644
index 00000000..14afd6b3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/anonymous-template-types.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo<T> {
+    pub t_member: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Foo<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Bar {
+    pub member: ::std::os::raw::c_char,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Quux<V> {
+    pub v_member: V,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
+}
+impl<V> Default for Quux<V> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Lobo {
+    pub also_member: ::std::os::raw::c_char,
+}
+pub type AliasWithAnonType = ::std::os::raw::c_char;
diff --git a/bindgen-tests/tests/expectations/tests/arg_keyword.rs b/bindgen-tests/tests/expectations/tests/arg_keyword.rs
new file mode 100644
index 00000000..43ff5831
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/arg_keyword.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z3fooPKc"]
+    pub fn foo(type_: *const ::std::os::raw::c_char);
+}
diff --git a/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs b/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs
new file mode 100644
index 00000000..ad1f22ed
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/array-of-zero-sized-types.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This should get an `_address` byte.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Empty {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Empty() {
+    assert_eq!(
+        ::std::mem::size_of::<Empty>(),
+        1usize,
+        concat!("Size of: ", stringify!(Empty))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Empty>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Empty))
+    );
+}
+/// This should not get an `_address` byte, since each `Empty` gets one, meaning
+/// that this object is addressable.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct HasArrayOfEmpty {
+    pub empties: [Empty; 10usize],
+}
+#[test]
+fn bindgen_test_layout_HasArrayOfEmpty() {
+    const UNINIT: ::std::mem::MaybeUninit<HasArrayOfEmpty> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<HasArrayOfEmpty>(),
+        10usize,
+        concat!("Size of: ", stringify!(HasArrayOfEmpty))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<HasArrayOfEmpty>(),
+        1usize,
+        concat!("Alignment of ", stringify!(HasArrayOfEmpty))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).empties) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(HasArrayOfEmpty),
+            "::",
+            stringify!(empties)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs
new file mode 100644
index 00000000..12d5eab0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[must_use]
+    #[link_name = "\u{1}_ZN3Foo3fooEi"]
+    pub fn Foo_foo(
+        this: *mut Foo,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    #[must_use]
+    pub unsafe fn foo(
+        &mut self,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        Foo_foo(self, arg1)
+    }
+}
+extern "C" {
+    #[must_use]
+    #[link_name = "\u{1}_Z3fooi"]
+    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
new file mode 100644
index 00000000..d860acd1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
@@ -0,0 +1,45 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo3fooEi"]
+    pub fn Foo_foo(
+        this: *mut Foo,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn foo(
+        &mut self,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        Foo_foo(self, arg1)
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3fooi"]
+    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
new file mode 100644
index 00000000..d860acd1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
@@ -0,0 +1,45 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo3fooEi"]
+    pub fn Foo_foo(
+        this: *mut Foo,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn foo(
+        &mut self,
+        arg1: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        Foo_foo(self, arg1)
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3fooi"]
+    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs b/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
new file mode 100644
index 00000000..4d0d6bcd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct std_char_traits {
+    pub _address: u8,
+}
+impl Default for std_char_traits {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct __gnu_cxx_char_traits {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/base-to-derived.rs b/bindgen-tests/tests/expectations/tests/base-to-derived.rs
new file mode 100644
index 00000000..97830cd4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/base-to-derived.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct false_type {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_false_type() {
+    assert_eq!(
+        ::std::mem::size_of::<false_type>(),
+        1usize,
+        concat!("Size of: ", stringify!(false_type))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<false_type>(),
+        1usize,
+        concat!("Alignment of ", stringify!(false_type))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs b/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs
new file mode 100644
index 00000000..8a091cb5
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bindgen-union-inside-namespace.rs
@@ -0,0 +1,114 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[repr(C)]
+    pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+    impl<T> __BindgenUnionField<T> {
+        #[inline]
+        pub fn new() -> Self {
+            __BindgenUnionField(::std::marker::PhantomData)
+        }
+        #[inline]
+        pub unsafe fn as_ref(&self) -> &T {
+            ::std::mem::transmute(self)
+        }
+        #[inline]
+        pub unsafe fn as_mut(&mut self) -> &mut T {
+            ::std::mem::transmute(self)
+        }
+    }
+    impl<T> ::std::default::Default for __BindgenUnionField<T> {
+        #[inline]
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+    impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+        #[inline]
+        fn clone(&self) -> Self {
+            Self::new()
+        }
+    }
+    impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+    impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+        fn fmt(
+            &self,
+            fmt: &mut ::std::fmt::Formatter<'_>,
+        ) -> ::std::fmt::Result {
+            fmt.write_str("__BindgenUnionField")
+        }
+    }
+    impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+        fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+    }
+    impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+        fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+            true
+        }
+    }
+    impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy)]
+        pub struct Bar {
+            pub foo: root::__BindgenUnionField<::std::os::raw::c_int>,
+            pub bar: root::__BindgenUnionField<::std::os::raw::c_int>,
+            pub bindgen_union_field: u32,
+        }
+        #[test]
+        fn bindgen_test_layout_Bar() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar>(),
+                4usize,
+                concat!("Size of: ", stringify!(Bar))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(bar)
+                )
+            );
+        }
+        impl Clone for Bar {
+            fn clone(&self) -> Self {
+                *self
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs
new file mode 100644
index 00000000..680b25d8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs
@@ -0,0 +1,715 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct MuchBitfield {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize]>,
+}
+#[test]
+fn bindgen_test_layout_MuchBitfield() {
+    assert_eq!(
+        ::std::mem::size_of::<MuchBitfield>(),
+        5usize,
+        concat!("Size of: ", stringify!(MuchBitfield))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MuchBitfield>(),
+        1usize,
+        concat!("Alignment of ", stringify!(MuchBitfield))
+    );
+}
+impl MuchBitfield {
+    #[inline]
+    pub fn m0(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m0(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m1(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m1(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m2(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m2(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m3(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m3(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m4(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m4(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m5(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m5(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m6(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m6(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m7(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m7(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m8(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m8(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m9(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m9(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m10(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m10(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(10usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m11(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m11(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(11usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m12(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m12(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m13(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m13(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(13usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m14(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m14(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(14usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m15(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m15(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(15usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m16(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m16(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m17(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m17(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(17usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m18(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m18(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(18usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m19(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m19(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(19usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m20(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m20(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m21(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m21(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(21usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m22(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m22(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(22usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m23(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m23(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(23usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m24(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m24(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m25(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m25(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(25usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m26(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m26(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(26usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m27(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m27(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(27usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m28(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m28(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(28usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m29(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m29(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(29usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m30(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m30(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(30usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m31(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m31(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m32(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_m32(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(32usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        m0: ::std::os::raw::c_char,
+        m1: ::std::os::raw::c_char,
+        m2: ::std::os::raw::c_char,
+        m3: ::std::os::raw::c_char,
+        m4: ::std::os::raw::c_char,
+        m5: ::std::os::raw::c_char,
+        m6: ::std::os::raw::c_char,
+        m7: ::std::os::raw::c_char,
+        m8: ::std::os::raw::c_char,
+        m9: ::std::os::raw::c_char,
+        m10: ::std::os::raw::c_char,
+        m11: ::std::os::raw::c_char,
+        m12: ::std::os::raw::c_char,
+        m13: ::std::os::raw::c_char,
+        m14: ::std::os::raw::c_char,
+        m15: ::std::os::raw::c_char,
+        m16: ::std::os::raw::c_char,
+        m17: ::std::os::raw::c_char,
+        m18: ::std::os::raw::c_char,
+        m19: ::std::os::raw::c_char,
+        m20: ::std::os::raw::c_char,
+        m21: ::std::os::raw::c_char,
+        m22: ::std::os::raw::c_char,
+        m23: ::std::os::raw::c_char,
+        m24: ::std::os::raw::c_char,
+        m25: ::std::os::raw::c_char,
+        m26: ::std::os::raw::c_char,
+        m27: ::std::os::raw::c_char,
+        m28: ::std::os::raw::c_char,
+        m29: ::std::os::raw::c_char,
+        m30: ::std::os::raw::c_char,
+        m31: ::std::os::raw::c_char,
+        m32: ::std::os::raw::c_char,
+    ) -> __BindgenBitfieldUnit<[u8; 5usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let m0: u8 = unsafe { ::std::mem::transmute(m0) };
+            m0 as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let m1: u8 = unsafe { ::std::mem::transmute(m1) };
+            m1 as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let m2: u8 = unsafe { ::std::mem::transmute(m2) };
+            m2 as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let m3: u8 = unsafe { ::std::mem::transmute(m3) };
+            m3 as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let m4: u8 = unsafe { ::std::mem::transmute(m4) };
+            m4 as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let m5: u8 = unsafe { ::std::mem::transmute(m5) };
+            m5 as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let m6: u8 = unsafe { ::std::mem::transmute(m6) };
+            m6 as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let m7: u8 = unsafe { ::std::mem::transmute(m7) };
+            m7 as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let m8: u8 = unsafe { ::std::mem::transmute(m8) };
+            m8 as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
+            let m9: u8 = unsafe { ::std::mem::transmute(m9) };
+            m9 as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 1u8, {
+            let m10: u8 = unsafe { ::std::mem::transmute(m10) };
+            m10 as u64
+        });
+        __bindgen_bitfield_unit.set(11usize, 1u8, {
+            let m11: u8 = unsafe { ::std::mem::transmute(m11) };
+            m11 as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 1u8, {
+            let m12: u8 = unsafe { ::std::mem::transmute(m12) };
+            m12 as u64
+        });
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
+            let m13: u8 = unsafe { ::std::mem::transmute(m13) };
+            m13 as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
+            let m14: u8 = unsafe { ::std::mem::transmute(m14) };
+            m14 as u64
+        });
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
+            let m15: u8 = unsafe { ::std::mem::transmute(m15) };
+            m15 as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 1u8, {
+            let m16: u8 = unsafe { ::std::mem::transmute(m16) };
+            m16 as u64
+        });
+        __bindgen_bitfield_unit.set(17usize, 1u8, {
+            let m17: u8 = unsafe { ::std::mem::transmute(m17) };
+            m17 as u64
+        });
+        __bindgen_bitfield_unit.set(18usize, 1u8, {
+            let m18: u8 = unsafe { ::std::mem::transmute(m18) };
+            m18 as u64
+        });
+        __bindgen_bitfield_unit.set(19usize, 1u8, {
+            let m19: u8 = unsafe { ::std::mem::transmute(m19) };
+            m19 as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 1u8, {
+            let m20: u8 = unsafe { ::std::mem::transmute(m20) };
+            m20 as u64
+        });
+        __bindgen_bitfield_unit.set(21usize, 1u8, {
+            let m21: u8 = unsafe { ::std::mem::transmute(m21) };
+            m21 as u64
+        });
+        __bindgen_bitfield_unit.set(22usize, 1u8, {
+            let m22: u8 = unsafe { ::std::mem::transmute(m22) };
+            m22 as u64
+        });
+        __bindgen_bitfield_unit.set(23usize, 1u8, {
+            let m23: u8 = unsafe { ::std::mem::transmute(m23) };
+            m23 as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 1u8, {
+            let m24: u8 = unsafe { ::std::mem::transmute(m24) };
+            m24 as u64
+        });
+        __bindgen_bitfield_unit.set(25usize, 1u8, {
+            let m25: u8 = unsafe { ::std::mem::transmute(m25) };
+            m25 as u64
+        });
+        __bindgen_bitfield_unit.set(26usize, 1u8, {
+            let m26: u8 = unsafe { ::std::mem::transmute(m26) };
+            m26 as u64
+        });
+        __bindgen_bitfield_unit.set(27usize, 1u8, {
+            let m27: u8 = unsafe { ::std::mem::transmute(m27) };
+            m27 as u64
+        });
+        __bindgen_bitfield_unit.set(28usize, 1u8, {
+            let m28: u8 = unsafe { ::std::mem::transmute(m28) };
+            m28 as u64
+        });
+        __bindgen_bitfield_unit.set(29usize, 1u8, {
+            let m29: u8 = unsafe { ::std::mem::transmute(m29) };
+            m29 as u64
+        });
+        __bindgen_bitfield_unit.set(30usize, 1u8, {
+            let m30: u8 = unsafe { ::std::mem::transmute(m30) };
+            m30 as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let m31: u8 = unsafe { ::std::mem::transmute(m31) };
+            m31 as u64
+        });
+        __bindgen_bitfield_unit.set(32usize, 1u8, {
+            let m32: u8 = unsafe { ::std::mem::transmute(m32) };
+            m32 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs
new file mode 100644
index 00000000..b6c25870
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-basic.rs
@@ -0,0 +1,169 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl Foo {
+    pub const Bar: Foo = Foo(2);
+}
+impl Foo {
+    pub const Baz: Foo = Foo(4);
+}
+impl Foo {
+    pub const Duplicated: Foo = Foo(4);
+}
+impl Foo {
+    pub const Negative: Foo = Foo(-3);
+}
+impl ::std::ops::BitOr<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Foo(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Foo {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Foo) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Foo(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Foo {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Foo) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
+impl Buz {
+    pub const Bar: Buz = Buz(2);
+}
+impl Buz {
+    pub const Baz: Buz = Buz(4);
+}
+impl Buz {
+    pub const Duplicated: Buz = Buz(4);
+}
+impl Buz {
+    pub const Negative: Buz = Buz(-3);
+}
+impl ::std::ops::BitOr<Buz> for Buz {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Buz(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Buz {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Buz) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Buz> for Buz {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Buz(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Buz {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Buz) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Buz(pub ::std::os::raw::c_schar);
+pub const NS_FOO: _bindgen_ty_1 = _bindgen_ty_1(1);
+pub const NS_BAR: _bindgen_ty_1 = _bindgen_ty_1(2);
+impl ::std::ops::BitOr<_bindgen_ty_1> for _bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        _bindgen_ty_1(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for _bindgen_ty_1 {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: _bindgen_ty_1) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<_bindgen_ty_1> for _bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        _bindgen_ty_1(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for _bindgen_ty_1 {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: _bindgen_ty_1) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint);
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Dummy {
+    pub _address: u8,
+}
+pub const Dummy_DUMMY_FOO: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(1);
+pub const Dummy_DUMMY_BAR: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(2);
+impl ::std::ops::BitOr<Dummy__bindgen_ty_1> for Dummy__bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Dummy__bindgen_ty_1(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Dummy__bindgen_ty_1 {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Dummy__bindgen_ty_1) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Dummy__bindgen_ty_1> for Dummy__bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Dummy__bindgen_ty_1(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Dummy__bindgen_ty_1 {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Dummy__bindgen_ty_1) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Dummy__bindgen_ty_1(pub ::std::os::raw::c_uint);
+#[test]
+fn bindgen_test_layout_Dummy() {
+    assert_eq!(
+        ::std::mem::size_of::<Dummy>(),
+        1usize,
+        concat!("Size of: ", stringify!(Dummy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Dummy>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Dummy))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs
new file mode 100644
index 00000000..1f0228e8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-c.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl Foo {
+    pub const Bar: Foo = Foo(2);
+}
+impl Foo {
+    pub const Baz: Foo = Foo(4);
+}
+impl Foo {
+    pub const Duplicated: Foo = Foo(4);
+}
+impl Foo {
+    pub const Negative: Foo = Foo(-3);
+}
+impl ::std::ops::BitOr<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Foo(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Foo {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Foo) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Foo(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Foo {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Foo) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs
new file mode 100644
index 00000000..53e113ed
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-enum-repr-transparent.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl Foo {
+    pub const Bar: Foo = Foo(2);
+}
+impl Foo {
+    pub const Baz: Foo = Foo(4);
+}
+impl Foo {
+    pub const Duplicated: Foo = Foo(4);
+}
+impl Foo {
+    pub const Negative: Foo = Foo(-3);
+}
+impl ::std::ops::BitOr<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Foo(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Foo {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Foo) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Foo(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Foo {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Foo) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-large.rs b/bindgen-tests/tests/expectations/tests/bitfield-large.rs
new file mode 100644
index 00000000..b2c353a2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-large.rs
@@ -0,0 +1,203 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct HasBigBitfield {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
+}
+#[test]
+fn bindgen_test_layout_HasBigBitfield() {
+    assert_eq!(
+        ::std::mem::size_of::<HasBigBitfield>(),
+        16usize,
+        concat!("Size of: ", stringify!(HasBigBitfield))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<HasBigBitfield>(),
+        16usize,
+        concat!("Alignment of ", stringify!(HasBigBitfield))
+    );
+}
+impl HasBigBitfield {
+    #[inline]
+    pub fn x(&self) -> i128 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 128u8) as u128)
+        }
+    }
+    #[inline]
+    pub fn set_x(&mut self, val: i128) {
+        unsafe {
+            let val: u128 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 128u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(x: i128) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 128u8, {
+            let x: u128 = unsafe { ::std::mem::transmute(x) };
+            x as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct HasTwoBigBitfields {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
+}
+#[test]
+fn bindgen_test_layout_HasTwoBigBitfields() {
+    assert_eq!(
+        ::std::mem::size_of::<HasTwoBigBitfields>(),
+        16usize,
+        concat!("Size of: ", stringify!(HasTwoBigBitfields))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<HasTwoBigBitfields>(),
+        16usize,
+        concat!("Alignment of ", stringify!(HasTwoBigBitfields))
+    );
+}
+impl HasTwoBigBitfields {
+    #[inline]
+    pub fn x(&self) -> i128 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 80u8) as u128)
+        }
+    }
+    #[inline]
+    pub fn set_x(&mut self, val: i128) {
+        unsafe {
+            let val: u128 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 80u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn y(&self) -> i128 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(80usize, 48u8) as u128)
+        }
+    }
+    #[inline]
+    pub fn set_y(&mut self, val: i128) {
+        unsafe {
+            let val: u128 = ::std::mem::transmute(val);
+            self._bitfield_1.set(80usize, 48u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        x: i128,
+        y: i128,
+    ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 80u8, {
+            let x: u128 = unsafe { ::std::mem::transmute(x) };
+            x as u64
+        });
+        __bindgen_bitfield_unit.set(80usize, 48u8, {
+            let y: u128 = unsafe { ::std::mem::transmute(y) };
+            y as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs
new file mode 100644
index 00000000..44c68626
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs
@@ -0,0 +1,166 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test {
+    pub foo: u64,
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        16usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(foo))
+    );
+}
+impl Test {
+    #[inline]
+    pub fn x(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 56u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_x(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 56u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn y(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_y(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(56usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        x: u64,
+        y: u64,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 56u8, {
+            let x: u64 = unsafe { ::std::mem::transmute(x) };
+            x as u64
+        });
+        __bindgen_bitfield_unit.set(56usize, 8u8, {
+            let y: u64 = unsafe { ::std::mem::transmute(y) };
+            y as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs
new file mode 100644
index 00000000..e9c1a76d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs
@@ -0,0 +1,164 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo4typeEv"]
+    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo9set_type_Ec"]
+    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo8set_typeEc"]
+    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
+}
+impl Foo {
+    #[inline]
+    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        type__bindgen_bitfield: ::std::os::raw::c_char,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let type__bindgen_bitfield: u8 =
+                unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
+            type__bindgen_bitfield as u64
+        });
+        __bindgen_bitfield_unit
+    }
+    #[inline]
+    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
+        Foo_type(self)
+    }
+    #[inline]
+    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) {
+        Foo_set_type_(self, c)
+    }
+    #[inline]
+    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) {
+        Foo_set_type(self, c)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align.rs b/bindgen-tests/tests/expectations/tests/bitfield_align.rs
new file mode 100644
index 00000000..4baca112
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield_align.rs
@@ -0,0 +1,797 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub x: ::std::os::raw::c_uchar,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub y: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        4usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(x))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        3usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(y))
+    );
+}
+impl A {
+    #[inline]
+    pub fn b1(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b2(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b3(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b4(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b5(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b6(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b7(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b8(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b9(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b10(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        b1: ::std::os::raw::c_uint,
+        b2: ::std::os::raw::c_uint,
+        b3: ::std::os::raw::c_uint,
+        b4: ::std::os::raw::c_uint,
+        b5: ::std::os::raw::c_uint,
+        b6: ::std::os::raw::c_uint,
+        b7: ::std::os::raw::c_uint,
+        b8: ::std::os::raw::c_uint,
+        b9: ::std::os::raw::c_uint,
+        b10: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let b1: u32 = unsafe { ::std::mem::transmute(b1) };
+            b1 as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let b2: u32 = unsafe { ::std::mem::transmute(b2) };
+            b2 as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let b3: u32 = unsafe { ::std::mem::transmute(b3) };
+            b3 as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let b4: u32 = unsafe { ::std::mem::transmute(b4) };
+            b4 as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let b5: u32 = unsafe { ::std::mem::transmute(b5) };
+            b5 as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let b6: u32 = unsafe { ::std::mem::transmute(b6) };
+            b6 as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let b7: u32 = unsafe { ::std::mem::transmute(b7) };
+            b7 as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let b8: u32 = unsafe { ::std::mem::transmute(b8) };
+            b8 as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let b9: u32 = unsafe { ::std::mem::transmute(b9) };
+            b9 as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
+            let b10: u32 = unsafe { ::std::mem::transmute(b10) };
+            b10 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+impl B {
+    #[inline]
+    pub fn foo(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 31u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bar(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        foo: ::std::os::raw::c_uint,
+        bar: ::std::os::raw::c_uchar,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 31u8, {
+            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
+            foo as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
+            bar as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub x: ::std::os::raw::c_uchar,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub baz: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        8usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(x))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(baz))
+    );
+}
+impl C {
+    #[inline]
+    pub fn b1(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b2(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        b1: ::std::os::raw::c_uint,
+        b2: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let b1: u32 = unsafe { ::std::mem::transmute(b1) };
+            b1 as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let b2: u32 = unsafe { ::std::mem::transmute(b2) };
+            b2 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Date1 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
+    pub __bindgen_padding_0: u8,
+}
+#[test]
+fn bindgen_test_layout_Date1() {
+    assert_eq!(
+        ::std::mem::size_of::<Date1>(),
+        4usize,
+        concat!("Size of: ", stringify!(Date1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Date1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(Date1))
+    );
+}
+impl Date1 {
+    #[inline]
+    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 6u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 5u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        nWeekDay: ::std::os::raw::c_ushort,
+        nMonthDay: ::std::os::raw::c_ushort,
+        nMonth: ::std::os::raw::c_ushort,
+        nYear: ::std::os::raw::c_ushort,
+    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
+            nWeekDay as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 6u8, {
+            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
+            nMonthDay as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 5u8, {
+            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
+            nMonth as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 8u8, {
+            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
+            nYear as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Date2 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_Date2() {
+    assert_eq!(
+        ::std::mem::size_of::<Date2>(),
+        4usize,
+        concat!("Size of: ", stringify!(Date2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Date2>(),
+        2usize,
+        concat!("Alignment of ", stringify!(Date2))
+    );
+}
+impl Date2 {
+    #[inline]
+    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 6u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 5u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn byte(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        nWeekDay: ::std::os::raw::c_ushort,
+        nMonthDay: ::std::os::raw::c_ushort,
+        nMonth: ::std::os::raw::c_ushort,
+        nYear: ::std::os::raw::c_ushort,
+        byte: ::std::os::raw::c_uchar,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
+            nWeekDay as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 6u8, {
+            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
+            nMonthDay as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 5u8, {
+            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
+            nMonth as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 8u8, {
+            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
+            nYear as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 8u8, {
+            let byte: u8 = unsafe { ::std::mem::transmute(byte) };
+            byte as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Date3 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
+    pub byte: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_Date3() {
+    const UNINIT: ::std::mem::MaybeUninit<Date3> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Date3>(),
+        4usize,
+        concat!("Size of: ", stringify!(Date3))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Date3>(),
+        2usize,
+        concat!("Alignment of ", stringify!(Date3))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).byte) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Date3),
+            "::",
+            stringify!(byte)
+        )
+    );
+}
+impl Date3 {
+    #[inline]
+    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 6u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 5u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        nWeekDay: ::std::os::raw::c_ushort,
+        nMonthDay: ::std::os::raw::c_ushort,
+        nMonth: ::std::os::raw::c_ushort,
+        nYear: ::std::os::raw::c_ushort,
+    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
+            nWeekDay as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 6u8, {
+            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
+            nMonthDay as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 5u8, {
+            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
+            nMonth as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 8u8, {
+            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
+            nYear as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs
new file mode 100644
index 00000000..aa11f80c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs
@@ -0,0 +1,176 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(target_os = "windows"))]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MyEnum {
+    ONE = 0,
+    TWO = 1,
+    THREE = 2,
+    FOUR = 3,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct TaggedPtr {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
+}
+#[test]
+fn bindgen_test_layout_TaggedPtr() {
+    assert_eq!(
+        ::std::mem::size_of::<TaggedPtr>(),
+        8usize,
+        concat!("Size of: ", stringify!(TaggedPtr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TaggedPtr>(),
+        8usize,
+        concat!("Alignment of ", stringify!(TaggedPtr))
+    );
+}
+impl Default for TaggedPtr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl TaggedPtr {
+    #[inline]
+    pub fn tag(&self) -> MyEnum {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_tag(&mut self, val: MyEnum) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn ptr(&self) -> ::std::os::raw::c_long {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 62u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        tag: MyEnum,
+        ptr: ::std::os::raw::c_long,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 2u8, {
+            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
+            tag as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 62u8, {
+            let ptr: u64 = unsafe { ::std::mem::transmute(ptr) };
+            ptr as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs
new file mode 100644
index 00000000..4ee1f598
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield_large_overflow.rs
@@ -0,0 +1,29 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct _bindgen_ty_1 {
+    pub _bindgen_opaque_blob: [u64; 10usize],
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<_bindgen_ty_1>(),
+        80usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+}
+extern "C" {
+    pub static mut a: _bindgen_ty_1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs
new file mode 100644
index 00000000..42fa3c4c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs
@@ -0,0 +1,158 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct mach_msg_type_descriptor_t {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_mach_msg_type_descriptor_t() {
+    assert_eq!(
+        ::std::mem::size_of::<mach_msg_type_descriptor_t>(),
+        4usize,
+        concat!("Size of: ", stringify!(mach_msg_type_descriptor_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mach_msg_type_descriptor_t>(),
+        4usize,
+        concat!("Alignment of ", stringify!(mach_msg_type_descriptor_t))
+    );
+}
+impl mach_msg_type_descriptor_t {
+    #[inline]
+    pub fn pad3(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 24u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn type_(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_type(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        pad3: ::std::os::raw::c_uint,
+        type_: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 24u8, {
+            let pad3: u32 = unsafe { ::std::mem::transmute(pad3) };
+            pad3 as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 8u8, {
+            let type_: u32 = unsafe { ::std::mem::transmute(type_) };
+            type_ as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs
new file mode 100644
index 00000000..27cd90f1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs
@@ -0,0 +1,211 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Struct {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_Struct() {
+    assert_eq!(
+        ::std::mem::size_of::<Struct>(),
+        4usize,
+        concat!("Size of: ", stringify!(Struct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Struct>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Struct))
+    );
+}
+impl Struct {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn c(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_c(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 6u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn d(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 16u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 16u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn e(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_e(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: ::std::os::raw::c_uchar,
+        b: ::std::os::raw::c_uchar,
+        c: ::std::os::raw::c_uchar,
+        d: ::std::os::raw::c_ushort,
+        e: ::std::os::raw::c_uchar,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let b: u8 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 6u8, {
+            let c: u8 = unsafe { ::std::mem::transmute(c) };
+            c as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 16u8, {
+            let d: u16 = unsafe { ::std::mem::transmute(d) };
+            d as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 8u8, {
+            let e: u8 = unsafe { ::std::mem::transmute(e) };
+            e as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/block_return_type.rs b/bindgen-tests/tests/expectations/tests/block_return_type.rs
new file mode 100644
index 00000000..bc434733
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/block_return_type.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+extern crate block;
+extern "C" {
+    pub fn func() -> _bindgen_ty_id_4;
+}
+pub type _bindgen_ty_id_4 = *const ::block::Block<
+    (::std::os::raw::c_int, ::std::os::raw::c_int),
+    ::std::os::raw::c_int,
+>;
diff --git a/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs b/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs
new file mode 100644
index 00000000..788cb30c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocklist-and-impl-debug.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub struct BlocklistMe(u8);
+
+/// Because this type contains a blocklisted type, it should not derive Debug.
+#[repr(C)]
+pub struct ShouldManuallyImplDebug {
+    pub a: BlocklistMe,
+}
+#[test]
+fn bindgen_test_layout_ShouldManuallyImplDebug() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldManuallyImplDebug> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldManuallyImplDebug>(),
+        1usize,
+        concat!("Size of: ", stringify!(ShouldManuallyImplDebug))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldManuallyImplDebug>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ShouldManuallyImplDebug))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldManuallyImplDebug),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for ShouldManuallyImplDebug {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for ShouldManuallyImplDebug {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "ShouldManuallyImplDebug {{  }}")
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/blocklist-file.rs b/bindgen-tests/tests/expectations/tests/blocklist-file.rs
new file mode 100644
index 00000000..4d2b6712
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocklist-file.rs
@@ -0,0 +1,91 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct SizedIntegers {
+    pub x: u8,
+    pub y: u16,
+    pub z: u32,
+}
+#[test]
+fn bindgen_test_layout_SizedIntegers() {
+    const UNINIT: ::std::mem::MaybeUninit<SizedIntegers> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<SizedIntegers>(),
+        8usize,
+        concat!("Size of: ", stringify!(SizedIntegers))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<SizedIntegers>(),
+        4usize,
+        concat!("Alignment of ", stringify!(SizedIntegers))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SizedIntegers),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SizedIntegers),
+            "::",
+            stringify!(y)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SizedIntegers),
+            "::",
+            stringify!(z)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct StructWithBlocklistedFwdDecl {
+    pub b: u8,
+}
+#[test]
+fn bindgen_test_layout_StructWithBlocklistedFwdDecl() {
+    const UNINIT: ::std::mem::MaybeUninit<StructWithBlocklistedFwdDecl> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StructWithBlocklistedFwdDecl>(),
+        1usize,
+        concat!("Size of: ", stringify!(StructWithBlocklistedFwdDecl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StructWithBlocklistedFwdDecl>(),
+        1usize,
+        concat!("Alignment of ", stringify!(StructWithBlocklistedFwdDecl))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StructWithBlocklistedFwdDecl),
+            "::",
+            stringify!(b)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/blocklist-function.rs b/bindgen-tests/tests/expectations/tests/blocklist-function.rs
new file mode 100644
index 00000000..5299b151
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocklist-function.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+    }
+    pub mod bar {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        extern "C" {
+            #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"]
+            pub fn NamespacedFunction();
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct C {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_C() {
+        assert_eq!(
+            ::std::mem::size_of::<C>(),
+            1usize,
+            concat!("Size of: ", stringify!(C))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<C>(),
+            1usize,
+            concat!("Alignment of ", stringify!(C))
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/blocklist-item.rs b/bindgen-tests/tests/expectations/tests/blocklist-item.rs
new file mode 100644
index 00000000..0edee9ec
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocklist-item.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+    }
+    pub mod bar {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        extern "C" {
+            #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"]
+            pub fn NamespacedFunction();
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/blocks-signature.rs b/bindgen-tests/tests/expectations/tests/blocks-signature.rs
new file mode 100644
index 00000000..ff7114a7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocks-signature.rs
@@ -0,0 +1,92 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+extern crate block;
+extern "C" {
+    #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
+    pub fn atexit_b(arg1: _bindgen_ty_id_33);
+}
+pub type dispatch_data_t = *mut ::std::os::raw::c_void;
+pub type dispatch_data_applier_t = _bindgen_ty_id_40;
+extern "C" {
+    #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"]
+    pub fn dispatch_data_apply(
+        data: dispatch_data_t,
+        applier: dispatch_data_applier_t,
+    ) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"]
+    pub fn foo(arg1: _bindgen_ty_id_50) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"]
+    pub fn foo_ptr(arg1: *mut _bindgen_ty_id_56) -> bool;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct contains_block_pointers {
+    pub val: contains_block_pointers__bindgen_ty_id_61,
+    pub ptr_val: *mut _bindgen_ty_id_68,
+}
+#[test]
+fn bindgen_test_layout_contains_block_pointers() {
+    const UNINIT: ::std::mem::MaybeUninit<contains_block_pointers> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<contains_block_pointers>(),
+        16usize,
+        concat!("Size of: ", stringify!(contains_block_pointers))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<contains_block_pointers>(),
+        8usize,
+        concat!("Alignment of ", stringify!(contains_block_pointers))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(contains_block_pointers),
+            "::",
+            stringify!(val)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr_val) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(contains_block_pointers),
+            "::",
+            stringify!(ptr_val)
+        )
+    );
+}
+impl Default for contains_block_pointers {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type _bindgen_ty_id_33 = *const ::block::Block<(), ()>;
+pub type _bindgen_ty_id_40 = *const ::block::Block<
+    (dispatch_data_t, usize, *const ::std::os::raw::c_void, usize),
+    bool,
+>;
+pub type _bindgen_ty_id_50 = *const ::block::Block<(usize,), ()>;
+pub type _bindgen_ty_id_56 = *const ::block::Block<(usize,), ()>;
+pub type contains_block_pointers__bindgen_ty_id_61 =
+    *const ::block::Block<(::std::os::raw::c_int,), ()>;
+pub type _bindgen_ty_id_68 =
+    *const ::block::Block<(::std::os::raw::c_int,), ()>;
diff --git a/bindgen-tests/tests/expectations/tests/blocks.rs b/bindgen-tests/tests/expectations/tests/blocks.rs
new file mode 100644
index 00000000..6f242989
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/blocks.rs
@@ -0,0 +1,80 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+extern "C" {
+    #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
+    pub fn atexit_b(arg1: *mut ::std::os::raw::c_void);
+}
+pub type dispatch_data_t = *mut ::std::os::raw::c_void;
+pub type dispatch_data_applier_t = *mut ::std::os::raw::c_void;
+extern "C" {
+    #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"]
+    pub fn dispatch_data_apply(
+        data: dispatch_data_t,
+        applier: dispatch_data_applier_t,
+    ) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"]
+    pub fn foo(arg1: *mut ::std::os::raw::c_void) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"]
+    pub fn foo_ptr(arg1: *mut *mut ::std::os::raw::c_void) -> bool;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct contains_block_pointers {
+    pub val: *mut ::std::os::raw::c_void,
+    pub ptr_val: *mut *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout_contains_block_pointers() {
+    const UNINIT: ::std::mem::MaybeUninit<contains_block_pointers> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<contains_block_pointers>(),
+        16usize,
+        concat!("Size of: ", stringify!(contains_block_pointers))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<contains_block_pointers>(),
+        8usize,
+        concat!("Alignment of ", stringify!(contains_block_pointers))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(contains_block_pointers),
+            "::",
+            stringify!(val)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr_val) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(contains_block_pointers),
+            "::",
+            stringify!(ptr_val)
+        )
+    );
+}
+impl Default for contains_block_pointers {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/bug-1529681.rs b/bindgen-tests/tests/expectations/tests/bug-1529681.rs
new file mode 100644
index 00000000..6a0f5e13
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/bug-1529681.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct BrowsingContext {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_BrowsingContext() {
+    assert_eq!(
+        ::std::mem::size_of::<BrowsingContext>(),
+        1usize,
+        concat!("Size of: ", stringify!(BrowsingContext))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BrowsingContext>(),
+        1usize,
+        concat!("Alignment of ", stringify!(BrowsingContext))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/builtin-template.rs b/bindgen-tests/tests/expectations/tests/builtin-template.rs
new file mode 100644
index 00000000..112b7670
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/builtin-template.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type std_make_integer_sequence = u8;
diff --git a/bindgen-tests/tests/expectations/tests/c-empty-layout.rs b/bindgen-tests/tests/expectations/tests/c-empty-layout.rs
new file mode 100644
index 00000000..ebef2b6d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/c-empty-layout.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        0usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/c_naming.rs b/bindgen-tests/tests/expectations/tests/c_naming.rs
new file mode 100644
index 00000000..3e56b1d6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/c_naming.rs
@@ -0,0 +1,102 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct struct_a {
+    pub a: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_struct_a() {
+    const UNINIT: ::std::mem::MaybeUninit<struct_a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<struct_a>(),
+        4usize,
+        concat!("Size of: ", stringify!(struct_a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<struct_a>(),
+        4usize,
+        concat!("Alignment of ", stringify!(struct_a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(struct_a),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+pub type a = *const struct_a;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union union_b {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_union_b() {
+    const UNINIT: ::std::mem::MaybeUninit<union_b> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<union_b>(),
+        4usize,
+        concat!("Size of: ", stringify!(union_b))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<union_b>(),
+        4usize,
+        concat!("Alignment of ", stringify!(union_b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(union_b),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(union_b),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for union_b {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type b = union_b;
+pub const enum_c_A: enum_c = 0;
+pub type enum_c = ::std::os::raw::c_uint;
+extern "C" {
+    pub fn takes_a(arg: a);
+}
+extern "C" {
+    pub fn takes_b(arg: b);
+}
+extern "C" {
+    pub fn takes_c(arg: enum_c);
+}
diff --git a/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs b/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs
new file mode 100644
index 00000000..6eabb1f6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/call-conv-typedef.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(test))]
+
+pub type void_fn = ::std::option::Option<unsafe extern "stdcall" fn()>;
+pub type fn_ = ::std::option::Option<
+    unsafe extern "stdcall" fn(id: ::std::os::raw::c_int) -> void_fn,
+>;
diff --git a/bindgen-tests/tests/expectations/tests/canonical-types.rs b/bindgen-tests/tests/expectations/tests/canonical-types.rs
new file mode 100644
index 00000000..a68e1424
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/canonical-types.rs
@@ -0,0 +1,281 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ClassA {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassA_ClassAInner<T> {
+    pub x: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ClassA_ClassAInner<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ClassB {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ClassC {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassC_ClassCInnerB {
+    pub cache: *mut ClassC_ClassCInnerA,
+}
+impl Default for ClassC_ClassCInnerB {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassC_ClassCInnerA {
+    pub member: *mut ClassC_ClassCInnerB,
+}
+impl Default for ClassC_ClassCInnerA {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassC_ClassCInnerCRTP {
+    pub _address: u8,
+}
+impl Default for ClassC_ClassCInnerCRTP {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassD {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_ClassD() {
+    assert_eq!(
+        ::std::mem::size_of::<ClassD>(),
+        1usize,
+        concat!("Size of: ", stringify!(ClassD))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassD>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ClassD))
+    );
+}
+impl Default for ClassD {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_ClassB_open0_ClassD_ClassCInnerCRTP_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<ClassB>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(ClassB))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassB>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(ClassB))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassCInnerCRTP {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_ClassCInnerCRTP() {
+    assert_eq!(
+        ::std::mem::size_of::<ClassCInnerCRTP>(),
+        1usize,
+        concat!("Size of: ", stringify!(ClassCInnerCRTP))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassCInnerCRTP>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ClassCInnerCRTP))
+    );
+}
+impl Default for ClassCInnerCRTP {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_ClassB_open0_ClassCInnerCRTP_ClassAInner_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<ClassB>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(ClassB))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassB>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(ClassB))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassAInner {
+    pub x: *mut ClassCInnerA,
+}
+#[test]
+fn bindgen_test_layout_ClassAInner() {
+    const UNINIT: ::std::mem::MaybeUninit<ClassAInner> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ClassAInner>(),
+        8usize,
+        concat!("Size of: ", stringify!(ClassAInner))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassAInner>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ClassAInner))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ClassAInner),
+            "::",
+            stringify!(x)
+        )
+    );
+}
+impl Default for ClassAInner {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassCInnerA {
+    pub member: *mut ClassCInnerB,
+}
+#[test]
+fn bindgen_test_layout_ClassCInnerA() {
+    const UNINIT: ::std::mem::MaybeUninit<ClassCInnerA> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ClassCInnerA>(),
+        8usize,
+        concat!("Size of: ", stringify!(ClassCInnerA))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassCInnerA>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ClassCInnerA))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ClassCInnerA),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for ClassCInnerA {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ClassCInnerB {
+    pub cache: *mut ClassCInnerA,
+}
+#[test]
+fn bindgen_test_layout_ClassCInnerB() {
+    const UNINIT: ::std::mem::MaybeUninit<ClassCInnerB> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ClassCInnerB>(),
+        8usize,
+        concat!("Size of: ", stringify!(ClassCInnerB))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ClassCInnerB>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ClassCInnerB))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cache) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ClassCInnerB),
+            "::",
+            stringify!(cache)
+        )
+    );
+}
+impl Default for ClassCInnerB {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs b/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs
new file mode 100644
index 00000000..12f10a88
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/canonical_path_without_namespacing.rs
@@ -0,0 +1,29 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3bazPN3foo3BarE"]
+    pub fn baz(arg1: *mut Bar);
+}
diff --git a/bindgen-tests/tests/expectations/tests/char.rs b/bindgen-tests/tests/expectations/tests/char.rs
new file mode 100644
index 00000000..960a681f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/char.rs
@@ -0,0 +1,107 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type Char = ::std::os::raw::c_char;
+pub type SChar = ::std::os::raw::c_schar;
+pub type UChar = ::std::os::raw::c_uchar;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Test {
+    pub ch: ::std::os::raw::c_char,
+    pub u: ::std::os::raw::c_uchar,
+    pub d: ::std::os::raw::c_schar,
+    pub cch: ::std::os::raw::c_char,
+    pub cu: ::std::os::raw::c_uchar,
+    pub cd: ::std::os::raw::c_schar,
+    pub Cch: Char,
+    pub Cu: UChar,
+    pub Cd: SChar,
+    pub Ccch: Char,
+    pub Ccu: UChar,
+    pub Ccd: SChar,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        12usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        1usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        2usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
+        3usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
+        5usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
+        6usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
+        7usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Test),
+            "::",
+            stringify!(Ccch)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
+        10usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
+        11usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/class.rs b/bindgen-tests/tests/expectations/tests/class.rs
new file mode 100644
index 00000000..8542135b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class.rs
@@ -0,0 +1,507 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        40usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(big_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct C_with_zero_length_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array))
+    );
+}
+impl Default for C_with_incomplete_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array_2() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
+    );
+}
+#[repr(C)]
+pub struct C_with_zero_length_array_and_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
+        40usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array_and_incomplete_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_and_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct WithDtor {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDtor>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDtor>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDtor),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+pub struct IncompleteArrayNonCopiable {
+    pub whatever: *mut ::std::os::raw::c_void,
+    pub incomplete_array: __IncompleteArrayField<C>,
+}
+#[test]
+fn bindgen_test_layout_IncompleteArrayNonCopiable() {
+    assert_eq!(
+        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
+    );
+}
+impl Default for IncompleteArrayNonCopiable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Union {
+    pub d: f32,
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Union() {
+    const UNINIT: ::std::mem::MaybeUninit<Union> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Union>(),
+        4usize,
+        concat!("Size of: ", stringify!(Union))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Union>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Union))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
+    );
+}
+impl Default for Union {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct WithUnion {
+    pub data: Union,
+}
+#[test]
+fn bindgen_test_layout_WithUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithUnion>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithUnion>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithUnion),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Default for WithUnion {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct RealAbstractionWithTonsOfMethods {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!(
+            "Alignment of ",
+            stringify!(RealAbstractionWithTonsOfMethods)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar(
+        this: *const RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar1(
+        this: *mut RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
+    pub fn RealAbstractionWithTonsOfMethods_bar2(
+        this: *mut RealAbstractionWithTonsOfMethods,
+        foo: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
+    pub fn RealAbstractionWithTonsOfMethods_sta();
+}
+impl RealAbstractionWithTonsOfMethods {
+    #[inline]
+    pub unsafe fn bar(&self) {
+        RealAbstractionWithTonsOfMethods_bar(self)
+    }
+    #[inline]
+    pub unsafe fn bar1(&mut self) {
+        RealAbstractionWithTonsOfMethods_bar1(self)
+    }
+    #[inline]
+    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
+        RealAbstractionWithTonsOfMethods_bar2(self, foo)
+    }
+    #[inline]
+    pub unsafe fn sta() {
+        RealAbstractionWithTonsOfMethods_sta()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_1_0.rs b/bindgen-tests/tests/expectations/tests/class_1_0.rs
new file mode 100644
index 00000000..f6c3021e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_1_0.rs
@@ -0,0 +1,558 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Copy)]
+pub struct C {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        40usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(big_array)
+        )
+    );
+}
+impl Clone for C {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for C {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl ::std::cmp::PartialEq for C {
+    fn eq(&self, other: &C) -> bool {
+        self.a == other.a && &self.big_array[..] == &other.big_array[..]
+    }
+}
+#[repr(C)]
+pub struct C_with_zero_length_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array))
+    );
+}
+impl Default for C_with_incomplete_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array_2() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
+    );
+}
+#[repr(C)]
+pub struct C_with_zero_length_array_and_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
+        40usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array_and_incomplete_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_and_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Hash, PartialEq, Eq)]
+pub struct WithDtor {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDtor>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDtor>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDtor),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+pub struct IncompleteArrayNonCopiable {
+    pub whatever: *mut ::std::os::raw::c_void,
+    pub incomplete_array: __IncompleteArrayField<C>,
+}
+#[test]
+fn bindgen_test_layout_IncompleteArrayNonCopiable() {
+    assert_eq!(
+        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
+    );
+}
+impl Default for IncompleteArrayNonCopiable {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct Union {
+    pub d: __BindgenUnionField<f32>,
+    pub i: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_Union() {
+    const UNINIT: ::std::mem::MaybeUninit<Union> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Union>(),
+        4usize,
+        concat!("Size of: ", stringify!(Union))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Union>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Union))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
+    );
+}
+impl Clone for Union {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct WithUnion {
+    pub data: Union,
+}
+#[test]
+fn bindgen_test_layout_WithUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithUnion>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithUnion>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithUnion),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Clone for WithUnion {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct RealAbstractionWithTonsOfMethods {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!(
+            "Alignment of ",
+            stringify!(RealAbstractionWithTonsOfMethods)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar(
+        this: *const RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar1(
+        this: *mut RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
+    pub fn RealAbstractionWithTonsOfMethods_bar2(
+        this: *mut RealAbstractionWithTonsOfMethods,
+        foo: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
+    pub fn RealAbstractionWithTonsOfMethods_sta();
+}
+impl Clone for RealAbstractionWithTonsOfMethods {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl RealAbstractionWithTonsOfMethods {
+    #[inline]
+    pub unsafe fn bar(&self) {
+        RealAbstractionWithTonsOfMethods_bar(self)
+    }
+    #[inline]
+    pub unsafe fn bar1(&mut self) {
+        RealAbstractionWithTonsOfMethods_bar1(self)
+    }
+    #[inline]
+    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
+        RealAbstractionWithTonsOfMethods_bar2(self, foo)
+    }
+    #[inline]
+    pub unsafe fn sta() {
+        RealAbstractionWithTonsOfMethods_sta()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_nested.rs b/bindgen-tests/tests/expectations/tests/class_nested.rs
new file mode 100644
index 00000000..f2cc8326
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_nested.rs
@@ -0,0 +1,195 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A {
+    pub member_a: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A_B {
+    pub member_b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A_B() {
+    const UNINIT: ::std::mem::MaybeUninit<A_B> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A_B>(),
+        4usize,
+        concat!("Size of: ", stringify!(A_B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A_B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A_B))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).member_b) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A_B),
+            "::",
+            stringify!(member_b)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A_D<T> {
+    pub foo: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for A_D<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        4usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).member_a) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A),
+            "::",
+            stringify!(member_a)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A_C {
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A_C() {
+    const UNINIT: ::std::mem::MaybeUninit<A_C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A_C>(),
+        4usize,
+        concat!("Size of: ", stringify!(A_C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A_C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A_C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A_C), "::", stringify!(baz))
+    );
+}
+extern "C" {
+    pub static mut var: A_B;
+}
+#[test]
+fn __bindgen_test_layout_A_D_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<A_D<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(A_D<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A_D<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(A_D<::std::os::raw::c_int>)
+        )
+    );
+}
+extern "C" {
+    pub static mut baz: A_D<::std::os::raw::c_int>;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct D {
+    pub member: A_B,
+}
+#[test]
+fn bindgen_test_layout_D() {
+    const UNINIT: ::std::mem::MaybeUninit<D> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<D>(),
+        4usize,
+        concat!("Size of: ", stringify!(D))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<D>(),
+        4usize,
+        concat!("Alignment of ", stringify!(D))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(D), "::", stringify!(member))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Templated<T> {
+    pub member: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Templated_Templated_inner<T> {
+    pub member_ptr: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Templated_Templated_inner<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> Default for Templated<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_no_members.rs b/bindgen-tests/tests/expectations/tests/class_no_members.rs
new file mode 100644
index 00000000..676590c8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_no_members.rs
@@ -0,0 +1,76 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct whatever {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_whatever() {
+    assert_eq!(
+        ::std::mem::size_of::<whatever>(),
+        1usize,
+        concat!("Size of: ", stringify!(whatever))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<whatever>(),
+        1usize,
+        concat!("Alignment of ", stringify!(whatever))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct whatever_child {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_whatever_child() {
+    assert_eq!(
+        ::std::mem::size_of::<whatever_child>(),
+        1usize,
+        concat!("Size of: ", stringify!(whatever_child))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<whatever_child>(),
+        1usize,
+        concat!("Alignment of ", stringify!(whatever_child))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct whatever_child_with_member {
+    pub m_member: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_whatever_child_with_member() {
+    const UNINIT: ::std::mem::MaybeUninit<whatever_child_with_member> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<whatever_child_with_member>(),
+        4usize,
+        concat!("Size of: ", stringify!(whatever_child_with_member))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<whatever_child_with_member>(),
+        4usize,
+        concat!("Alignment of ", stringify!(whatever_child_with_member))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(whatever_child_with_member),
+            "::",
+            stringify!(m_member)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_static.rs b/bindgen-tests/tests/expectations/tests/class_static.rs
new file mode 100644
index 00000000..2388f3b3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_static.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct MyClass {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN7MyClass7exampleE"]
+    pub static mut MyClass_example: *const ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN7MyClass26example_check_no_collisionE"]
+    pub static mut MyClass_example_check_no_collision:
+        *const ::std::os::raw::c_int;
+}
+#[test]
+fn bindgen_test_layout_MyClass() {
+    assert_eq!(
+        ::std::mem::size_of::<MyClass>(),
+        1usize,
+        concat!("Size of: ", stringify!(MyClass))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MyClass>(),
+        1usize,
+        concat!("Alignment of ", stringify!(MyClass))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZL26example_check_no_collision"]
+    pub static mut example_check_no_collision: *const ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_static_const.rs b/bindgen-tests/tests/expectations/tests/class_static_const.rs
new file mode 100644
index 00000000..812d78e1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_static_const.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A {
+    pub _address: u8,
+}
+pub const A_a: ::std::os::raw::c_int = 0;
+pub const A_b: i32 = 63;
+pub const A_c: u32 = 255;
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_use_as.rs b/bindgen-tests/tests/expectations/tests/class_use_as.rs
new file mode 100644
index 00000000..ef130c16
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_use_as.rs
@@ -0,0 +1,72 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen="true" replaces="whatever"></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct whatever {
+    pub replacement: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_whatever() {
+    const UNINIT: ::std::mem::MaybeUninit<whatever> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<whatever>(),
+        4usize,
+        concat!("Size of: ", stringify!(whatever))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<whatever>(),
+        4usize,
+        concat!("Alignment of ", stringify!(whatever))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).replacement) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(whatever),
+            "::",
+            stringify!(replacement)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct container {
+    pub c: whatever,
+}
+#[test]
+fn bindgen_test_layout_container() {
+    const UNINIT: ::std::mem::MaybeUninit<container> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<container>(),
+        4usize,
+        concat!("Size of: ", stringify!(container))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<container>(),
+        4usize,
+        concat!("Alignment of ", stringify!(container))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(container),
+            "::",
+            stringify!(c)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_with_dtor.rs b/bindgen-tests/tests/expectations/tests/class_with_dtor.rs
new file mode 100644
index 00000000..86d2a576
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_with_dtor.rs
@@ -0,0 +1,85 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct HandleWithDtor<T> {
+    pub ptr: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for HandleWithDtor<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type HandleValue = HandleWithDtor<::std::os::raw::c_int>;
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct WithoutDtor {
+    pub shouldBeWithDtor: HandleValue,
+}
+#[test]
+fn bindgen_test_layout_WithoutDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<WithoutDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithoutDtor>(),
+        8usize,
+        concat!("Size of: ", stringify!(WithoutDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithoutDtor>(),
+        8usize,
+        concat!("Alignment of ", stringify!(WithoutDtor))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).shouldBeWithDtor) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithoutDtor),
+            "::",
+            stringify!(shouldBeWithDtor)
+        )
+    );
+}
+impl Default for WithoutDtor {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_HandleWithDtor_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(HandleWithDtor<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<HandleWithDtor<::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(HandleWithDtor<::std::os::raw::c_int>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs b/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs
new file mode 100644
index 00000000..eab9d598
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_with_inner_struct.rs
@@ -0,0 +1,490 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct A {
+    pub c: ::std::os::raw::c_uint,
+    pub named_union: A__bindgen_ty_1,
+    pub __bindgen_anon_1: A__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct A_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<A_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(A_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union A__bindgen_ty_1 {
+    pub f: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(A__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A__bindgen_ty_1),
+            "::",
+            stringify!(f)
+        )
+    );
+}
+impl Default for A__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union A__bindgen_ty_2 {
+    pub d: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(A__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A__bindgen_ty_2),
+            "::",
+            stringify!(d)
+        )
+    );
+}
+impl Default for A__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        12usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(c))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).named_union) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A),
+            "::",
+            stringify!(named_union)
+        )
+    );
+}
+impl Default for A {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct B {
+    pub d: ::std::os::raw::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct B_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_B_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<B_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(B_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(B_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(B_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_B() {
+    const UNINIT: ::std::mem::MaybeUninit<B> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(B), "::", stringify!(d))
+    );
+}
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum StepSyntax {
+    Keyword = 0,
+    FunctionalWithoutKeyword = 1,
+    FunctionalWithStartKeyword = 2,
+    FunctionalWithEndKeyword = 3,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub d: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: C__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union C__bindgen_ty_1 {
+    pub mFunc: C__bindgen_ty_1__bindgen_ty_1,
+    pub __bindgen_anon_1: C__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialEq)]
+pub struct C__bindgen_ty_1__bindgen_ty_1 {
+    pub mX1: f32,
+    pub mY1: f32,
+    pub mX2: f32,
+    pub mY2: f32,
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mX1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mX1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mY1) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mY1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mX2) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mX2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mY2) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mY2)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct C__bindgen_ty_1__bindgen_ty_2 {
+    pub mStepSyntax: StepSyntax,
+    pub mSteps: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_2>(),
+        8usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mStepSyntax) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(mStepSyntax)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mSteps) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(mSteps)
+        )
+    );
+}
+impl Default for C__bindgen_ty_1__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFunc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1),
+            "::",
+            stringify!(mFunc)
+        )
+    );
+}
+impl Default for C__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct C_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_C_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<C_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(C_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        20usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_with_inner_struct_1_0.rs b/bindgen-tests/tests/expectations/tests/class_with_inner_struct_1_0.rs
new file mode 100644
index 00000000..42656079
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_with_inner_struct_1_0.rs
@@ -0,0 +1,546 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct A {
+    pub c: ::std::os::raw::c_uint,
+    pub named_union: A__bindgen_ty_1,
+    pub __bindgen_anon_1: A__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct A_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<A_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(A_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+impl Clone for A_Segment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct A__bindgen_ty_1 {
+    pub f: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_A__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(A__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A__bindgen_ty_1),
+            "::",
+            stringify!(f)
+        )
+    );
+}
+impl Clone for A__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct A__bindgen_ty_2 {
+    pub d: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_A__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(A__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A__bindgen_ty_2),
+            "::",
+            stringify!(d)
+        )
+    );
+}
+impl Clone for A__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        12usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(c))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).named_union) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(A),
+            "::",
+            stringify!(named_union)
+        )
+    );
+}
+impl Clone for A {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct B {
+    pub d: ::std::os::raw::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct B_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_B_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<B_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(B_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(B_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(B_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+impl Clone for B_Segment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_B() {
+    const UNINIT: ::std::mem::MaybeUninit<B> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(B), "::", stringify!(d))
+    );
+}
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum StepSyntax {
+    Keyword = 0,
+    FunctionalWithoutKeyword = 1,
+    FunctionalWithStartKeyword = 2,
+    FunctionalWithEndKeyword = 3,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct C {
+    pub d: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: C__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct C__bindgen_ty_1 {
+    pub mFunc: __BindgenUnionField<C__bindgen_ty_1__bindgen_ty_1>,
+    pub __bindgen_anon_1: __BindgenUnionField<C__bindgen_ty_1__bindgen_ty_2>,
+    pub bindgen_union_field: [u32; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, PartialEq)]
+pub struct C__bindgen_ty_1__bindgen_ty_1 {
+    pub mX1: f32,
+    pub mY1: f32,
+    pub mX2: f32,
+    pub mY2: f32,
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mX1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mX1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mY1) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mY1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mX2) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mX2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mY2) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(mY2)
+        )
+    );
+}
+impl Clone for C__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct C__bindgen_ty_1__bindgen_ty_2 {
+    pub mStepSyntax: StepSyntax,
+    pub mSteps: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_2>(),
+        8usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mStepSyntax) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(mStepSyntax)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mSteps) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(mSteps)
+        )
+    );
+}
+impl Clone for C__bindgen_ty_1__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for C__bindgen_ty_1__bindgen_ty_2 {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_C__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(C__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFunc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C__bindgen_ty_1),
+            "::",
+            stringify!(mFunc)
+        )
+    );
+}
+impl Clone for C__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct C_Segment {
+    pub begin: ::std::os::raw::c_int,
+    pub end: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_C_Segment() {
+    const UNINIT: ::std::mem::MaybeUninit<C_Segment> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_Segment>(),
+        8usize,
+        concat!("Size of: ", stringify!(C_Segment))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_Segment>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_Segment))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_Segment),
+            "::",
+            stringify!(begin)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_Segment),
+            "::",
+            stringify!(end)
+        )
+    );
+}
+impl Clone for C_Segment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        20usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
+    );
+}
+impl Clone for C {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/class_with_typedef.rs b/bindgen-tests/tests/expectations/tests/class_with_typedef.rs
new file mode 100644
index 00000000..65e86b27
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/class_with_typedef.rs
@@ -0,0 +1,146 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type AnotherInt = ::std::os::raw::c_int;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct C {
+    pub c: C_MyInt,
+    pub ptr: *mut C_MyInt,
+    pub arr: [C_MyInt; 10usize],
+    pub d: AnotherInt,
+    pub other_ptr: *mut AnotherInt,
+}
+pub type C_MyInt = ::std::os::raw::c_int;
+pub type C_Lookup = *const ::std::os::raw::c_char;
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        72usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        8usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(c))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(ptr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
+        16usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(arr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        56usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).other_ptr) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(other_ptr)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C6methodEi"]
+    pub fn C_method(this: *mut C, c: C_MyInt);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C9methodRefERi"]
+    pub fn C_methodRef(this: *mut C, c: *mut C_MyInt);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C16complexMethodRefERPKc"]
+    pub fn C_complexMethodRef(this: *mut C, c: *mut C_Lookup);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C13anotherMethodEi"]
+    pub fn C_anotherMethod(this: *mut C, c: AnotherInt);
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl C {
+    #[inline]
+    pub unsafe fn method(&mut self, c: C_MyInt) {
+        C_method(self, c)
+    }
+    #[inline]
+    pub unsafe fn methodRef(&mut self, c: *mut C_MyInt) {
+        C_methodRef(self, c)
+    }
+    #[inline]
+    pub unsafe fn complexMethodRef(&mut self, c: *mut C_Lookup) {
+        C_complexMethodRef(self, c)
+    }
+    #[inline]
+    pub unsafe fn anotherMethod(&mut self, c: AnotherInt) {
+        C_anotherMethod(self, c)
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct D {
+    pub _base: C,
+    pub ptr: *mut C_MyInt,
+}
+#[test]
+fn bindgen_test_layout_D() {
+    const UNINIT: ::std::mem::MaybeUninit<D> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<D>(),
+        80usize,
+        concat!("Size of: ", stringify!(D))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<D>(),
+        8usize,
+        concat!("Alignment of ", stringify!(D))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
+        72usize,
+        concat!("Offset of field: ", stringify!(D), "::", stringify!(ptr))
+    );
+}
+impl Default for D {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/comment-indent.rs b/bindgen-tests/tests/expectations/tests/comment-indent.rs
new file mode 100644
index 00000000..3ad221aa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/comment-indent.rs
@@ -0,0 +1,139 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    /// This is a multi-line doc comment.
+    ///
+    /// This class is really really interesting, look!
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Foo {
+        pub _address: u8,
+    }
+    /// This nested class is also a multi-line doc comment.
+    ///
+    /// This class is not so interesting, but worth a bit of docs too!
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Foo_Bar {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_Foo_Bar() {
+        assert_eq!(
+            ::std::mem::size_of::<Foo_Bar>(),
+            1usize,
+            concat!("Size of: ", stringify!(Foo_Bar))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<Foo_Bar>(),
+            1usize,
+            concat!("Alignment of ", stringify!(Foo_Bar))
+        );
+    }
+    #[test]
+    fn bindgen_test_layout_Foo() {
+        assert_eq!(
+            ::std::mem::size_of::<Foo>(),
+            1usize,
+            concat!("Size of: ", stringify!(Foo))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<Foo>(),
+            1usize,
+            concat!("Alignment of ", stringify!(Foo))
+        );
+    }
+    pub mod test {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        /// I'm in a namespace, and thus I may be on a rust module, most of the time.
+        /// My documentation is pretty extensive, I guess.
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Baz {
+            /// This member is plain awesome, just amazing.
+            ///
+            /// It also has super-extensive docs, with even a nice ascii-art diagram.
+            ///
+            /// +------+          +-------+
+            /// | foo  |   ---->  | bar   |
+            /// +------+          +-------+
+            pub member: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_Baz() {
+            const UNINIT: ::std::mem::MaybeUninit<Baz> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Baz>(),
+                4usize,
+                concat!("Size of: ", stringify!(Baz))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Baz>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Baz))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Baz),
+                    "::",
+                    stringify!(member)
+                )
+            );
+        }
+        /// I'm in an inline namespace, and as such I shouldn't get generated inside
+        /// a rust module, except when the relevant option is specified. Also, this
+        /// comment shouldn't be misaligned.
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct InInlineNS {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_InInlineNS() {
+            assert_eq!(
+                ::std::mem::size_of::<InInlineNS>(),
+                1usize,
+                concat!("Size of: ", stringify!(InInlineNS))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<InInlineNS>(),
+                1usize,
+                concat!("Alignment of ", stringify!(InInlineNS))
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Bazz {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_Bazz() {
+            assert_eq!(
+                ::std::mem::size_of::<Bazz>(),
+                1usize,
+                concat!("Size of: ", stringify!(Bazz))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bazz>(),
+                1usize,
+                concat!("Alignment of ", stringify!(Bazz))
+            );
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/complex.rs b/bindgen-tests/tests/expectations/tests/complex.rs
new file mode 100644
index 00000000..e9c4be9d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/complex.rs
@@ -0,0 +1,155 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialEq)]
+pub struct TestDouble {
+    pub mMember: __BindgenComplex<f64>,
+}
+#[test]
+fn bindgen_test_layout_TestDouble() {
+    const UNINIT: ::std::mem::MaybeUninit<TestDouble> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<TestDouble>(),
+        16usize,
+        concat!("Size of: ", stringify!(TestDouble))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestDouble>(),
+        8usize,
+        concat!("Alignment of ", stringify!(TestDouble))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(TestDouble),
+            "::",
+            stringify!(mMember)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct TestDoublePtr {
+    pub mMember: *mut __BindgenComplex<f64>,
+}
+#[test]
+fn bindgen_test_layout_TestDoublePtr() {
+    const UNINIT: ::std::mem::MaybeUninit<TestDoublePtr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<TestDoublePtr>(),
+        8usize,
+        concat!("Size of: ", stringify!(TestDoublePtr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestDoublePtr>(),
+        8usize,
+        concat!("Alignment of ", stringify!(TestDoublePtr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(TestDoublePtr),
+            "::",
+            stringify!(mMember)
+        )
+    );
+}
+impl Default for TestDoublePtr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialEq)]
+pub struct TestFloat {
+    pub mMember: __BindgenComplex<f32>,
+}
+#[test]
+fn bindgen_test_layout_TestFloat() {
+    const UNINIT: ::std::mem::MaybeUninit<TestFloat> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<TestFloat>(),
+        8usize,
+        concat!("Size of: ", stringify!(TestFloat))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestFloat>(),
+        4usize,
+        concat!("Alignment of ", stringify!(TestFloat))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(TestFloat),
+            "::",
+            stringify!(mMember)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct TestFloatPtr {
+    pub mMember: *mut __BindgenComplex<f32>,
+}
+#[test]
+fn bindgen_test_layout_TestFloatPtr() {
+    const UNINIT: ::std::mem::MaybeUninit<TestFloatPtr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<TestFloatPtr>(),
+        8usize,
+        concat!("Size of: ", stringify!(TestFloatPtr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestFloatPtr>(),
+        8usize,
+        concat!("Alignment of ", stringify!(TestFloatPtr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(TestFloatPtr),
+            "::",
+            stringify!(mMember)
+        )
+    );
+}
+impl Default for TestFloatPtr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/complex_global.rs b/bindgen-tests/tests/expectations/tests/complex_global.rs
new file mode 100644
index 00000000..f21735da
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/complex_global.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
+extern "C" {
+    pub static mut globalValueFloat: __BindgenComplex<f32>;
+}
+extern "C" {
+    pub static mut globalValueDouble: __BindgenComplex<f64>;
+}
+extern "C" {
+    pub static mut globalValueLongDouble: __BindgenComplex<f64>;
+}
diff --git a/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs b/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs
new file mode 100644
index 00000000..e8f13dff
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const-const-mut-ptr.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub bar: *const *const *mut *const ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_array.rs b/bindgen-tests/tests/expectations/tests/const_array.rs
new file mode 100644
index 00000000..191bac9c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_array.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub static foo: [::std::os::raw::c_int; 1usize];
+}
+extern "C" {
+    pub static mut bar: [::std::os::raw::c_int; 1usize];
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs b/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs
new file mode 100644
index 00000000..3286dce1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_array_fn_arg.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn f(a: *const ::std::os::raw::c_int);
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs b/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs
new file mode 100644
index 00000000..da0ec2b8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_enum_unnamed.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const FOO_BAR: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAR;
+pub const FOO_BAZ: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAZ;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    FOO_BAR = 0,
+    FOO_BAZ = 1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub const Foo_FOO_BAR: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::FOO_BAR;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo__bindgen_ty_1 {
+    FOO_BAR = 10,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs b/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs
new file mode 100644
index 00000000..11ae184d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_multidim_array_fn_arg.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn f(a: *const [::std::os::raw::c_int; 1usize]);
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_ptr.rs b/bindgen-tests/tests/expectations/tests/const_ptr.rs
new file mode 100644
index 00000000..0087aa99
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_ptr.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo(bar: *const ::std::os::raw::c_void);
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs b/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs
new file mode 100644
index 00000000..66939ef9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_resolved_ty.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo(foo: *const u8);
+}
diff --git a/bindgen-tests/tests/expectations/tests/const_tparam.rs b/bindgen-tests/tests/expectations/tests/const_tparam.rs
new file mode 100644
index 00000000..ec256872
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/const_tparam.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct C<T> {
+    pub foo: *const T,
+    pub bar: *const T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for C<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs b/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs
new file mode 100644
index 00000000..6c1e3d38
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constant-non-specialized-tp.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Outer {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Outer_Inner {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs b/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs
new file mode 100644
index 00000000..d47338f1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constified-enum-module-overflow.rs
@@ -0,0 +1,57 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub _address: u8,
+}
+pub type C_U = B;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub u: u8,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(u))
+    );
+}
+#[test]
+fn __bindgen_test_layout_C_open0_A_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(C))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-all-enums.rs b/bindgen-tests/tests/expectations/tests/constify-all-enums.rs
new file mode 100644
index 00000000..e3c82156
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-all-enums.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const foo_THIS: foo = 0;
+pub const foo_SHOULD_BE: foo = 1;
+pub const foo_A_CONSTANT: foo = 2;
+pub type foo = ::std::os::raw::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct bar {
+    pub this_should_work: foo,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(this_should_work)
+        )
+    );
+}
+impl Default for bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-enum.rs b/bindgen-tests/tests/expectations/tests/constify-enum.rs
new file mode 100644
index 00000000..091743e9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-enum.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const nsCSSPropertyID_eCSSProperty_COUNT_unexistingVariantValue:
+    nsCSSPropertyID =
+    nsCSSPropertyID::eCSSProperty_COUNT_unexistingVariantValue;
+impl nsCSSPropertyID {
+    pub const eCSSProperty_COUNT: nsCSSPropertyID =
+        nsCSSPropertyID::eCSSPropertyAlias_aa;
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum nsCSSPropertyID {
+    eCSSProperty_a = 0,
+    eCSSProperty_b = 1,
+    eCSSPropertyAlias_aa = 2,
+    eCSSPropertyAlias_bb = 3,
+    ///< <div rustbindgen constant></div>
+    eCSSProperty_COUNT_unexistingVariantValue = 4,
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs
new file mode 100644
index 00000000..c5c32983
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-basic.rs
@@ -0,0 +1,72 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const THIS: Type = 0;
+    pub const SHOULD_BE: Type = 1;
+    pub const A_CONSTANT: Type = 2;
+}
+pub use self::foo::Type as foo_alias1;
+pub use self::foo_alias1 as foo_alias2;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct bar {
+    pub this_should_work: foo::Type,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(this_should_work)
+        )
+    );
+}
+impl Default for bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    pub fn func1(
+        arg1: foo::Type,
+        arg2: *mut foo::Type,
+        arg3: *mut *mut foo::Type,
+    ) -> *mut foo::Type;
+}
+extern "C" {
+    pub fn func2(
+        arg1: foo_alias1,
+        arg2: *mut foo_alias1,
+        arg3: *mut *mut foo_alias1,
+    ) -> *mut foo_alias1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs
new file mode 100644
index 00000000..0b8eec1e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-namespace.rs
@@ -0,0 +1,73 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod ns1 {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod ns2 {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            pub mod foo {
+                pub type Type = ::std::os::raw::c_uint;
+                pub const THIS: Type = 0;
+                pub const SHOULD_BE: Type = 1;
+                pub const A_CONSTANT: Type = 2;
+            }
+        }
+        pub mod ns3 {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            #[repr(C)]
+            #[derive(Debug, Copy, Clone)]
+            pub struct bar {
+                pub this_should_work: root::ns1::ns2::foo::Type,
+            }
+            #[test]
+            fn bindgen_test_layout_bar() {
+                const UNINIT: ::std::mem::MaybeUninit<bar> =
+                    ::std::mem::MaybeUninit::uninit();
+                let ptr = UNINIT.as_ptr();
+                assert_eq!(
+                    ::std::mem::size_of::<bar>(),
+                    4usize,
+                    concat!("Size of: ", stringify!(bar))
+                );
+                assert_eq!(
+                    ::std::mem::align_of::<bar>(),
+                    4usize,
+                    concat!("Alignment of ", stringify!(bar))
+                );
+                assert_eq!(
+                    unsafe {
+                        ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
+                            ptr as usize
+                    },
+                    0usize,
+                    concat!(
+                        "Offset of field: ",
+                        stringify!(bar),
+                        "::",
+                        stringify!(this_should_work)
+                    )
+                );
+            }
+            impl Default for bar {
+                fn default() -> Self {
+                    let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                    unsafe {
+                        ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                        s.assume_init()
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs
new file mode 100644
index 00000000..44643d0f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-shadow-name.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const Type: Type = 0;
+    pub const Type_: Type = 1;
+    pub const Type1: Type = 2;
+    pub const Type__: Type = 3;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct bar {
+    pub member: foo::Type,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs
new file mode 100644
index 00000000..0262b128
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-alias.rs
@@ -0,0 +1,121 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod Foo {
+    pub type Type = ::std::os::raw::c_int;
+    pub const Variant1: Type = 0;
+    pub const Variant2: Type = 1;
+    pub const Variant3: Type = 2;
+}
+pub use self::Foo::Type as Foo_alias1;
+pub use self::Foo_alias1 as Foo_alias2;
+pub use self::Foo_alias2 as Foo_alias3;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub baz1: Foo::Type,
+    pub baz2: Foo_alias1,
+    pub baz3: Foo_alias2,
+    pub baz4: Foo_alias3,
+    pub baz_ptr1: *mut Foo::Type,
+    pub baz_ptr2: *mut Foo_alias1,
+    pub baz_ptr3: *mut Foo_alias2,
+    pub baz_ptr4: *mut Foo_alias3,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        48usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz1) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz2) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz3) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz3))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz4) as usize - ptr as usize },
+        12usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz4))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).baz_ptr1) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(baz_ptr1)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).baz_ptr2) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(baz_ptr2)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).baz_ptr3) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(baz_ptr3)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).baz_ptr4) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(baz_ptr4)
+        )
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
new file mode 100644
index 00000000..75ebf48a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
@@ -0,0 +1,53 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod one_Foo {
+    pub type Type = ::std::os::raw::c_int;
+    pub const Variant1: Type = 0;
+    pub const Variant2: Type = 1;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub baz1: one_Foo::Type,
+    pub baz2: *mut one_Foo::Type,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz1) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz2) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz2))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs b/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs
new file mode 100644
index 00000000..c3c6d3ca
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constify-module-enums-types.rs
@@ -0,0 +1,299 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const THIS: Type = 0;
+    pub const SHOULD_BE: Type = 1;
+    pub const A_CONSTANT: Type = 2;
+    pub const ALSO_THIS: Type = 42;
+    pub const AND_ALSO_THIS: Type = 42;
+}
+pub mod anon_enum {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const Variant1: Type = 0;
+    pub const Variant2: Type = 1;
+    pub const Variant3: Type = 2;
+}
+pub mod ns1_foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const THIS: Type = 0;
+    pub const SHOULD_BE: Type = 1;
+    pub const A_CONSTANT: Type = 2;
+    pub const ALSO_THIS: Type = 42;
+}
+pub mod ns2_Foo {
+    pub type Type = ::std::os::raw::c_int;
+    pub const Variant1: Type = 0;
+    pub const Variant2: Type = 1;
+}
+pub use self::anon_enum::Type as anon_enum_alias1;
+pub use self::anon_enum_alias1 as anon_enum_alias2;
+pub use self::anon_enum_alias2 as anon_enum_alias3;
+pub use self::foo::Type as foo_alias1;
+pub use self::foo_alias1 as foo_alias2;
+pub use self::foo_alias2 as foo_alias3;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct bar {
+    pub member1: foo::Type,
+    pub member2: foo_alias1,
+    pub member3: foo_alias2,
+    pub member4: foo_alias3,
+    pub member5: ns1_foo::Type,
+    pub member6: *mut ns2_Foo::Type,
+    pub member7: anon_enum::Type,
+    pub member8: anon_enum_alias1,
+    pub member9: anon_enum_alias2,
+    pub member10: anon_enum_alias3,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        48usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member2) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member3) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member4) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member4)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member5) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member5)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member6) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member6)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member7) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member7)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member8) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member8)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member9) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member9)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).member10) as usize - ptr as usize
+        },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar),
+            "::",
+            stringify!(member10)
+        )
+    );
+}
+impl Default for bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Baz {
+    pub member1: ns2_Foo::Type,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    const UNINIT: ::std::mem::MaybeUninit<Baz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        4usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Baz),
+            "::",
+            stringify!(member1)
+        )
+    );
+}
+impl Default for Baz {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub mod one_Foo {
+    pub type Type = ::std::os::raw::c_int;
+    pub const Variant1: Type = 0;
+    pub const Variant2: Type = 1;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub baz: *mut one_Foo::Type,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5func13fooPS_PS0_"]
+    pub fn func1(
+        arg1: foo::Type,
+        arg2: *mut foo::Type,
+        arg3: *mut *mut foo::Type,
+    ) -> *mut foo::Type;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5func23fooPS_PS0_"]
+    pub fn func2(
+        arg1: foo_alias1,
+        arg2: *mut foo_alias1,
+        arg3: *mut *mut foo_alias1,
+    ) -> *mut foo_alias1;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Thing<T> {
+    pub thing: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Thing<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5func35ThingI3fooE"]
+    pub fn func3(arg1: Thing<foo::Type>) -> foo::Type;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5func45ThingIS_I3fooEE"]
+    pub fn func4(arg1: Thing<Thing<foo::Type>>) -> foo::Type;
+}
diff --git a/bindgen-tests/tests/expectations/tests/constructor-tp.rs b/bindgen-tests/tests/expectations/tests/constructor-tp.rs
new file mode 100644
index 00000000..4b339dc3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constructor-tp.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3BarC1Ev"]
+    pub fn Bar_Bar(this: *mut Bar);
+}
+impl Bar {
+    #[inline]
+    pub unsafe fn new() -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        Bar_Bar(__bindgen_tmp.as_mut_ptr());
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constructors.rs b/bindgen-tests/tests/expectations/tests/constructors.rs
new file mode 100644
index 00000000..2f13effb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constructors.rs
@@ -0,0 +1,80 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TestOverload {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_TestOverload() {
+    assert_eq!(
+        ::std::mem::size_of::<TestOverload>(),
+        1usize,
+        concat!("Size of: ", stringify!(TestOverload))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestOverload>(),
+        1usize,
+        concat!("Alignment of ", stringify!(TestOverload))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN12TestOverloadC1Ei"]
+    pub fn TestOverload_TestOverload(
+        this: *mut TestOverload,
+        arg1: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN12TestOverloadC1Ed"]
+    pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64);
+}
+impl TestOverload {
+    #[inline]
+    pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        TestOverload_TestOverload(__bindgen_tmp.as_mut_ptr(), arg1);
+        __bindgen_tmp.assume_init()
+    }
+    #[inline]
+    pub unsafe fn new1(arg1: f64) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        TestOverload_TestOverload1(__bindgen_tmp.as_mut_ptr(), arg1);
+        __bindgen_tmp.assume_init()
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TestPublicNoArgs {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_TestPublicNoArgs() {
+    assert_eq!(
+        ::std::mem::size_of::<TestPublicNoArgs>(),
+        1usize,
+        concat!("Size of: ", stringify!(TestPublicNoArgs))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestPublicNoArgs>(),
+        1usize,
+        concat!("Alignment of ", stringify!(TestPublicNoArgs))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"]
+    pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs);
+}
+impl TestPublicNoArgs {
+    #[inline]
+    pub unsafe fn new() -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        TestPublicNoArgs_TestPublicNoArgs(__bindgen_tmp.as_mut_ptr());
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/constructors_1_33.rs b/bindgen-tests/tests/expectations/tests/constructors_1_33.rs
new file mode 100644
index 00000000..b5d33332
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/constructors_1_33.rs
@@ -0,0 +1,82 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TestOverload {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_TestOverload() {
+    assert_eq!(
+        ::std::mem::size_of::<TestOverload>(),
+        1usize,
+        concat!("Size of: ", stringify!(TestOverload))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestOverload>(),
+        1usize,
+        concat!("Alignment of ", stringify!(TestOverload))
+    );
+}
+extern "C" {
+    /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
+    #[link_name = "\u{1}_ZN12TestOverloadC1Ei"]
+    pub fn TestOverload_TestOverload(
+        this: *mut TestOverload,
+        arg1: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
+    #[link_name = "\u{1}_ZN12TestOverloadC1Ed"]
+    pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64);
+}
+impl TestOverload {
+    #[inline]
+    pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::uninitialized();
+        TestOverload_TestOverload(&mut __bindgen_tmp, arg1);
+        __bindgen_tmp
+    }
+    #[inline]
+    pub unsafe fn new1(arg1: f64) -> Self {
+        let mut __bindgen_tmp = ::std::mem::uninitialized();
+        TestOverload_TestOverload1(&mut __bindgen_tmp, arg1);
+        __bindgen_tmp
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TestPublicNoArgs {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_TestPublicNoArgs() {
+    assert_eq!(
+        ::std::mem::size_of::<TestPublicNoArgs>(),
+        1usize,
+        concat!("Size of: ", stringify!(TestPublicNoArgs))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TestPublicNoArgs>(),
+        1usize,
+        concat!("Alignment of ", stringify!(TestPublicNoArgs))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"]
+    pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs);
+}
+impl TestPublicNoArgs {
+    #[inline]
+    pub unsafe fn new() -> Self {
+        let mut __bindgen_tmp = ::std::mem::uninitialized();
+        TestPublicNoArgs_TestPublicNoArgs(&mut __bindgen_tmp);
+        __bindgen_tmp
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs b/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs
new file mode 100644
index 00000000..62fc3749
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/contains-vs-inherits-zero-sized.rs
@@ -0,0 +1,103 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This should get an `_address` byte.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Empty {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Empty() {
+    assert_eq!(
+        ::std::mem::size_of::<Empty>(),
+        1usize,
+        concat!("Size of: ", stringify!(Empty))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Empty>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Empty))
+    );
+}
+/// This should not get an `_address` byte, so `sizeof(Inherits)` should be
+/// `1`.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Inherits {
+    pub b: bool,
+}
+#[test]
+fn bindgen_test_layout_Inherits() {
+    const UNINIT: ::std::mem::MaybeUninit<Inherits> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Inherits>(),
+        1usize,
+        concat!("Size of: ", stringify!(Inherits))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Inherits>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Inherits))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Inherits),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+/// This should not get an `_address` byte, but contains `Empty` which *does* get
+/// one, so `sizeof(Contains)` should be `1 + 1`.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Contains {
+    pub empty: Empty,
+    pub b: bool,
+}
+#[test]
+fn bindgen_test_layout_Contains() {
+    const UNINIT: ::std::mem::MaybeUninit<Contains> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Contains>(),
+        2usize,
+        concat!("Size of: ", stringify!(Contains))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Contains>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Contains))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).empty) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Contains),
+            "::",
+            stringify!(empty)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Contains),
+            "::",
+            stringify!(b)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs b/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs
new file mode 100644
index 00000000..09a22c4f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/convert-cpp-comment-to-rust.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type mbedtls_mpi_uint = ::std::os::raw::c_uint;
+/// \brief          MPI structure
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mbedtls_mpi {
+    ///<  integer sign
+    pub s: ::std::os::raw::c_int,
+    ///<  total # of limbs
+    pub n: ::std::os::raw::c_ulong,
+    ///<  pointer to limbs
+    pub p: *mut mbedtls_mpi_uint,
+}
+impl Default for mbedtls_mpi {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/convert-floats.rs b/bindgen-tests/tests/expectations/tests/convert-floats.rs
new file mode 100644
index 00000000..e710a442
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/convert-floats.rs
@@ -0,0 +1,97 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(C)]
+pub struct __BindgenComplex<T> {
+    pub re: T,
+    pub im: T,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub bar: ::std::os::raw::c_float,
+    pub baz: ::std::os::raw::c_float,
+    pub bazz: ::std::os::raw::c_double,
+    pub bazzz: *mut u128,
+    pub complexFloat: __BindgenComplex<::std::os::raw::c_float>,
+    pub complexDouble: __BindgenComplex<::std::os::raw::c_double>,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        48usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bazz) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bazz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bazzz) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(bazzz)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).complexFloat) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(complexFloat)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).complexDouble) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(complexDouble)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/core_ffi_c.rs b/bindgen-tests/tests/expectations/tests/core_ffi_c.rs
new file mode 100644
index 00000000..7e138a89
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/core_ffi_c.rs
@@ -0,0 +1,20 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type c_char = ::core::ffi::c_char;
+pub type c_double = ::core::ffi::c_double;
+pub type c_float = ::core::ffi::c_float;
+pub type c_int = ::core::ffi::c_int;
+pub type c_long = ::core::ffi::c_long;
+pub type c_longlong = ::core::ffi::c_longlong;
+pub type c_schar = ::core::ffi::c_schar;
+pub type c_short = ::core::ffi::c_short;
+pub type c_uchar = ::core::ffi::c_uchar;
+pub type c_uint = ::core::ffi::c_uint;
+pub type c_ulong = ::core::ffi::c_ulong;
+pub type c_ulonglong = ::core::ffi::c_ulonglong;
+pub type c_ushort = ::core::ffi::c_ushort;
diff --git a/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs b/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs
new file mode 100644
index 00000000..f5ba025a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/cpp-empty-layout.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/crtp.rs b/bindgen-tests/tests/expectations/tests/crtp.rs
new file mode 100644
index 00000000..2372e211
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/crtp.rs
@@ -0,0 +1,86 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Base {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Derived {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Derived() {
+    assert_eq!(
+        ::std::mem::size_of::<Derived>(),
+        1usize,
+        concat!("Size of: ", stringify!(Derived))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Derived>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Derived))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct BaseWithDestructor {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct DerivedFromBaseWithDestructor {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_DerivedFromBaseWithDestructor() {
+    assert_eq!(
+        ::std::mem::size_of::<DerivedFromBaseWithDestructor>(),
+        1usize,
+        concat!("Size of: ", stringify!(DerivedFromBaseWithDestructor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DerivedFromBaseWithDestructor>(),
+        1usize,
+        concat!("Alignment of ", stringify!(DerivedFromBaseWithDestructor))
+    );
+}
+#[test]
+fn __bindgen_test_layout_Base_open0_Derived_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Base>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(Base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Base>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(Base))
+    );
+}
+#[test]
+fn __bindgen_test_layout_BaseWithDestructor_open0_DerivedFromBaseWithDestructor_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<BaseWithDestructor>(),
+        1usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(BaseWithDestructor)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BaseWithDestructor>(),
+        1usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(BaseWithDestructor)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs b/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs
new file mode 100644
index 00000000..5b3d186a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/ctypes-prefix-path.rs
@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![no_std]
+mod libc {
+    pub mod foo {
+        pub type c_int = i32;
+        pub enum c_void {}
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub a: libc::foo::c_int,
+    pub b: libc::foo::c_int,
+    pub bar: *mut libc::foo::c_void,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::core::mem::MaybeUninit<foo> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dash_language.rs b/bindgen-tests/tests/expectations/tests/dash_language.rs
new file mode 100644
index 00000000..eb2bbc76
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dash_language.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub bar: ::std::os::raw::c_int,
+}
diff --git a/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs b/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs
new file mode 100644
index 00000000..d812b032
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/decl_extern_int_twice.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub static mut foo: ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs b/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs
new file mode 100644
index 00000000..b520f1e0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/decl_ptr_to_array.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub static mut foo: *mut [::std::os::raw::c_int; 1usize];
+}
diff --git a/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs b/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs
new file mode 100644
index 00000000..5e225e3d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/default-enum-style-constified-module.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod Foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const bar: Type = 0;
+    pub const baz: Type = 1;
+    pub const blap: Type = 2;
+}
+extern "C" {
+    pub fn func(x: Foo::Type);
+}
diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs
new file mode 100644
index 00000000..38ebc531
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-signed.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const N0: i32 = 0;
+pub const N1: i32 = 1;
+pub const N2: i32 = 2;
+pub const N_1: i32 = -1;
+pub const N_2: i32 = -2;
+pub const MAX_U16: i32 = 65535;
+pub const MAX_I16: i32 = 32767;
+pub const MAX_I16_Plus1: i32 = 32768;
+pub const MAX_U16_Plus1: i32 = 65536;
+pub const MAX_I16_Minus1: i32 = 32766;
+pub const MAX_U16_Minus1: i32 = 65534;
+pub const MIN_U16: i32 = 0;
+pub const MIN_I16: i32 = -32768;
+pub const MIN_U16_Plus1: i32 = 1;
+pub const MIN_I16_Plus1: i32 = -32767;
+pub const MIN_U16_Minus1: i32 = -1;
+pub const MIN_I16_Minus1: i32 = -32769;
+pub const MAX_U32: i64 = 4294967295;
+pub const MAX_I32: i32 = 2147483647;
+pub const MAX_I32_Plus1: i64 = 2147483648;
+pub const MAX_U32_Plus1: i64 = 4294967296;
+pub const MAX_I32_Minus1: i32 = 2147483646;
+pub const MAX_U32_Minus1: i64 = 4294967294;
+pub const MIN_U32: i32 = 0;
+pub const MIN_I32: i32 = -2147483648;
+pub const MIN_U32_Plus1: i32 = 1;
+pub const MIN_I32_Plus1: i32 = -2147483647;
+pub const MIN_U32_Minus1: i32 = -1;
+pub const MIN_I32_Minus1: i64 = -2147483649;
+pub const LONG12: i64 = 123456789012;
+pub const LONG_12: i64 = -123456789012;
+extern "C" {
+    pub fn foo(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_uint,
+        arg4: ::std::os::raw::c_char,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: ::std::os::raw::c_schar,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(
+        arg1: ::std::os::raw::c_long,
+        arg2: ::std::os::raw::c_longlong,
+    ) -> ::std::os::raw::c_long;
+}
diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs
new file mode 100644
index 00000000..5571563b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type-unsigned.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const N0: u32 = 0;
+pub const N1: u32 = 1;
+pub const N2: u32 = 2;
+pub const N_1: i32 = -1;
+pub const N_2: i32 = -2;
+pub const MAX_U16: u32 = 65535;
+pub const MAX_I16: u32 = 32767;
+pub const MAX_I16_Plus1: u32 = 32768;
+pub const MAX_U16_Plus1: u32 = 65536;
+pub const MAX_I16_Minus1: u32 = 32766;
+pub const MAX_U16_Minus1: u32 = 65534;
+pub const MIN_U16: u32 = 0;
+pub const MIN_I16: i32 = -32768;
+pub const MIN_U16_Plus1: u32 = 1;
+pub const MIN_I16_Plus1: i32 = -32767;
+pub const MIN_U16_Minus1: i32 = -1;
+pub const MIN_I16_Minus1: i32 = -32769;
+pub const MAX_U32: u32 = 4294967295;
+pub const MAX_I32: u32 = 2147483647;
+pub const MAX_I32_Plus1: u32 = 2147483648;
+pub const MAX_U32_Plus1: u64 = 4294967296;
+pub const MAX_I32_Minus1: u32 = 2147483646;
+pub const MAX_U32_Minus1: u32 = 4294967294;
+pub const MIN_U32: u32 = 0;
+pub const MIN_I32: i32 = -2147483648;
+pub const MIN_U32_Plus1: u32 = 1;
+pub const MIN_I32_Plus1: i32 = -2147483647;
+pub const MIN_U32_Minus1: i32 = -1;
+pub const MIN_I32_Minus1: i64 = -2147483649;
+pub const LONG12: u64 = 123456789012;
+pub const LONG_12: i64 = -123456789012;
+extern "C" {
+    pub fn foo(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_uint,
+        arg4: ::std::os::raw::c_char,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: ::std::os::raw::c_schar,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(
+        arg1: ::std::os::raw::c_long,
+        arg2: ::std::os::raw::c_longlong,
+    ) -> ::std::os::raw::c_long;
+}
diff --git a/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs b/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs
new file mode 100644
index 00000000..5571563b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/default-macro-constant-type.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const N0: u32 = 0;
+pub const N1: u32 = 1;
+pub const N2: u32 = 2;
+pub const N_1: i32 = -1;
+pub const N_2: i32 = -2;
+pub const MAX_U16: u32 = 65535;
+pub const MAX_I16: u32 = 32767;
+pub const MAX_I16_Plus1: u32 = 32768;
+pub const MAX_U16_Plus1: u32 = 65536;
+pub const MAX_I16_Minus1: u32 = 32766;
+pub const MAX_U16_Minus1: u32 = 65534;
+pub const MIN_U16: u32 = 0;
+pub const MIN_I16: i32 = -32768;
+pub const MIN_U16_Plus1: u32 = 1;
+pub const MIN_I16_Plus1: i32 = -32767;
+pub const MIN_U16_Minus1: i32 = -1;
+pub const MIN_I16_Minus1: i32 = -32769;
+pub const MAX_U32: u32 = 4294967295;
+pub const MAX_I32: u32 = 2147483647;
+pub const MAX_I32_Plus1: u32 = 2147483648;
+pub const MAX_U32_Plus1: u64 = 4294967296;
+pub const MAX_I32_Minus1: u32 = 2147483646;
+pub const MAX_U32_Minus1: u32 = 4294967294;
+pub const MIN_U32: u32 = 0;
+pub const MIN_I32: i32 = -2147483648;
+pub const MIN_U32_Plus1: u32 = 1;
+pub const MIN_I32_Plus1: i32 = -2147483647;
+pub const MIN_U32_Minus1: i32 = -1;
+pub const MIN_I32_Minus1: i64 = -2147483649;
+pub const LONG12: u64 = 123456789012;
+pub const LONG_12: i64 = -123456789012;
+extern "C" {
+    pub fn foo(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_uint,
+        arg4: ::std::os::raw::c_char,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: ::std::os::raw::c_schar,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(
+        arg1: ::std::os::raw::c_long,
+        arg2: ::std::os::raw::c_longlong,
+    ) -> ::std::os::raw::c_long;
+}
diff --git a/bindgen-tests/tests/expectations/tests/default-template-parameter.rs b/bindgen-tests/tests/expectations/tests/default-template-parameter.rs
new file mode 100644
index 00000000..2cbe463c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/default-template-parameter.rs
@@ -0,0 +1,47 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo<T, U> {
+    pub t: T,
+    pub u: U,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<T, U> Default for Foo<T, U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_Foo_open0_bool__int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo<bool, ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify ! (Foo < bool , :: std :: os :: raw :: c_int >)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo<bool, ::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify ! (Foo < bool , :: std :: os :: raw :: c_int >)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZL3bar"]
+    pub static mut bar: Foo<bool, ::std::os::raw::c_int>;
+}
diff --git a/bindgen-tests/tests/expectations/tests/deleted-function.rs b/bindgen-tests/tests/expectations/tests/deleted-function.rs
new file mode 100644
index 00000000..96967bb4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/deleted-function.rs
@@ -0,0 +1,91 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A17inline_definitionEv"]
+    pub fn A_inline_definition(this: *mut A);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A22out_of_line_definitionEv"]
+    pub fn A_out_of_line_definition(this: *mut A);
+}
+impl A {
+    #[inline]
+    pub unsafe fn inline_definition(&mut self) {
+        A_inline_definition(self)
+    }
+    #[inline]
+    pub unsafe fn out_of_line_definition(&mut self) {
+        A_out_of_line_definition(self)
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        1usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        1usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        1usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        1usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1CC1ERS_"]
+    pub fn C_C(this: *mut C, arg1: *mut C);
+}
+impl C {
+    #[inline]
+    pub unsafe fn new(arg1: *mut C) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        C_C(__bindgen_tmp.as_mut_ptr(), arg1);
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs
new file mode 100644
index 00000000..ea6621dd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs
@@ -0,0 +1,215 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+/// Because this struct have array larger than 32 items
+/// and --with-derive-partialeq --impl-partialeq --impl-debug is provided,
+/// this struct should manually implement `Debug` and `PartialEq`.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Foo {
+    pub large: [::std::os::raw::c_int; 33usize],
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub __bindgen_padding_0: u16,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        136usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(large)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo4typeEv"]
+    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo9set_type_Ec"]
+    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo8set_typeEc"]
+    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
+}
+impl Default for Foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for Foo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(
+            f,
+            "Foo {{ large: [{}], type_ : {:?},  }}",
+            self.large
+                .iter()
+                .enumerate()
+                .map(|(i, v)| format!(
+                    "{}{:?}",
+                    if i > 0 { ", " } else { "" },
+                    v
+                ))
+                .collect::<String>(),
+            self.type__bindgen_bitfield()
+        )
+    }
+}
+impl ::std::cmp::PartialEq for Foo {
+    fn eq(&self, other: &Foo) -> bool {
+        &self.large[..] == &other.large[..] &&
+            self.type__bindgen_bitfield() == other.type__bindgen_bitfield()
+    }
+}
+impl Foo {
+    #[inline]
+    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        type__bindgen_bitfield: ::std::os::raw::c_char,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let type__bindgen_bitfield: u8 =
+                unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
+            type__bindgen_bitfield as u64
+        });
+        __bindgen_bitfield_unit
+    }
+    #[inline]
+    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
+        Foo_type(self)
+    }
+    #[inline]
+    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) {
+        Foo_set_type_(self, c)
+    }
+    #[inline]
+    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) {
+        Foo_set_type(self, c)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-clone.rs b/bindgen-tests/tests/expectations/tests/derive-clone.rs
new file mode 100644
index 00000000..19c28b69
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-clone.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This struct should derive `Clone`.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ShouldDeriveClone {
+    pub large: [::std::os::raw::c_int; 33usize],
+}
+#[test]
+fn bindgen_test_layout_ShouldDeriveClone() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldDeriveClone> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldDeriveClone>(),
+        132usize,
+        concat!("Size of: ", stringify!(ShouldDeriveClone))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldDeriveClone>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ShouldDeriveClone))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldDeriveClone),
+            "::",
+            stringify!(large)
+        )
+    );
+}
+impl Default for ShouldDeriveClone {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-clone_1_0.rs b/bindgen-tests/tests/expectations/tests/derive-clone_1_0.rs
new file mode 100644
index 00000000..3d72db2f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-clone_1_0.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Since builtin `Clone` impls were introduced in Rust 1.21 this struct
+/// should impl `Clone` "manually".
+#[repr(C)]
+#[derive(Copy)]
+pub struct ShouldImplClone {
+    pub large: [::std::os::raw::c_int; 33usize],
+}
+#[test]
+fn bindgen_test_layout_ShouldImplClone() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldImplClone> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldImplClone>(),
+        132usize,
+        concat!("Size of: ", stringify!(ShouldImplClone))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldImplClone>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ShouldImplClone))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldImplClone),
+            "::",
+            stringify!(large)
+        )
+    );
+}
+impl Clone for ShouldImplClone {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for ShouldImplClone {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-custom.rs b/bindgen-tests/tests/expectations/tests/derive-custom.rs
new file mode 100644
index 00000000..542b6bb2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-custom.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen derive="Debug"></div>
+#[repr(C)]
+#[derive(Default, Debug)]
+pub struct my_type {
+    pub a: ::std::os::raw::c_int,
+}
+/// <div rustbindgen derive="Debug"></div>
+/// <div rustbindgen derive="Clone"></div>
+#[repr(C)]
+#[derive(Default, Debug, Clone)]
+pub struct my_type2 {
+    pub a: ::std::os::raw::c_uint,
+}
+/// <div rustbindgen derive="Debug" derive="Clone"></div>
+#[repr(C)]
+#[derive(Default, Debug, Clone)]
+pub struct my_type3 {
+    pub a: ::std::os::raw::c_ulong,
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs
new file mode 100644
index 00000000..2a78e930
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs
@@ -0,0 +1,194 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate core;
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub large_array: [::std::os::raw::c_int; 50usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::core::mem::MaybeUninit<C> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<C>(),
+        204usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe {
+            ::core::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::core::fmt::Debug for C {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+        write!(
+            f,
+            "C {{ a : {:?}, b : {:?}, large_array: [...] }}",
+            self.a(),
+            self.b()
+        )
+    }
+}
+impl C {
+    #[inline]
+    pub fn a(&self) -> bool {
+        unsafe {
+            ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::core::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> bool {
+        unsafe {
+            ::core::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::core::mem::transmute(val);
+            self._bitfield_1.set(1usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: bool,
+        b: bool,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::core::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 7u8, {
+            let b: u8 = unsafe { ::core::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs
new file mode 100644
index 00000000..0ae8f329
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs
@@ -0,0 +1,201 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub large_array: [::std::os::raw::c_int; 50usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        204usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for C {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(
+            f,
+            "C {{ a : {:?}, b : {:?}, large_array: [{}] }}",
+            self.a(),
+            self.b(),
+            self.large_array
+                .iter()
+                .enumerate()
+                .map(|(i, v)| format!(
+                    "{}{:?}",
+                    if i > 0 { ", " } else { "" },
+                    v
+                ))
+                .collect::<String>()
+        )
+    }
+}
+impl C {
+    #[inline]
+    pub fn a(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: bool,
+        b: bool,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 7u8, {
+            let b: u8 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs
new file mode 100644
index 00000000..16b127bf
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-function-pointer.rs
@@ -0,0 +1,80 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Nice {
+    pub pointer: Nice_Function,
+    pub large_array: [::std::os::raw::c_int; 34usize],
+}
+pub type Nice_Function =
+    ::std::option::Option<unsafe extern "C" fn(data: ::std::os::raw::c_int)>;
+#[test]
+fn bindgen_test_layout_Nice() {
+    const UNINIT: ::std::mem::MaybeUninit<Nice> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Nice>(),
+        144usize,
+        concat!("Size of: ", stringify!(Nice))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Nice>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Nice))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pointer) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Nice),
+            "::",
+            stringify!(pointer)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Nice),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for Nice {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for Nice {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(
+            f,
+            "Nice {{ pointer: {:?}, large_array: [{}] }}",
+            self.pointer,
+            self.large_array
+                .iter()
+                .enumerate()
+                .map(|(i, v)| format!(
+                    "{}{:?}",
+                    if i > 0 { ", " } else { "" },
+                    v
+                ))
+                .collect::<String>()
+        )
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs b/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs
new file mode 100644
index 00000000..49d4e9b8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-generic.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Generic<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Generic<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> ::std::fmt::Debug for Generic<T> {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "Generic {{ t: Array with length 40 }}")
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs b/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs
new file mode 100644
index 00000000..a757d679
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-mangle-name.rs
@@ -0,0 +1,124 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct perf_event_attr {
+    pub type_: ::std::os::raw::c_uint,
+    pub a: f32,
+    pub __bindgen_anon_1: perf_event_attr__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union perf_event_attr__bindgen_ty_1 {
+    pub b: ::std::os::raw::c_int,
+    pub c: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_perf_event_attr__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<perf_event_attr__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<perf_event_attr__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(perf_event_attr__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<perf_event_attr__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(perf_event_attr__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(perf_event_attr__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(perf_event_attr__bindgen_ty_1),
+            "::",
+            stringify!(c)
+        )
+    );
+}
+impl Default for perf_event_attr__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_1 {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "perf_event_attr__bindgen_ty_1 {{ union }}")
+    }
+}
+#[test]
+fn bindgen_test_layout_perf_event_attr() {
+    const UNINIT: ::std::mem::MaybeUninit<perf_event_attr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<perf_event_attr>(),
+        12usize,
+        concat!("Size of: ", stringify!(perf_event_attr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<perf_event_attr>(),
+        4usize,
+        concat!("Alignment of ", stringify!(perf_event_attr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(perf_event_attr),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(perf_event_attr),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for perf_event_attr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for perf_event_attr {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(
+            f,
+            "perf_event_attr {{ type: {:?}, a: {:?}, __bindgen_anon_1: {:?} }}",
+            self.type_, self.a, self.__bindgen_anon_1
+        )
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs b/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
new file mode 100644
index 00000000..a0cc87ff
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
@@ -0,0 +1,51 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Instance {
+    pub val: [u32; 50usize],
+}
+#[test]
+fn bindgen_test_layout_Instance() {
+    const UNINIT: ::std::mem::MaybeUninit<Instance> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Instance>(),
+        200usize,
+        concat!("Size of: ", stringify!(Instance))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Instance>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Instance))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Instance),
+            "::",
+            stringify!(val)
+        )
+    );
+}
+impl Default for Instance {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for Instance {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "Instance {{ val: opaque }}")
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs b/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs
new file mode 100644
index 00000000..5cebc9b8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-debug-opaque.rs
@@ -0,0 +1,83 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+pub struct Opaque {
+    pub _bindgen_opaque_blob: [u32; 41usize],
+}
+#[test]
+fn bindgen_test_layout_Opaque() {
+    assert_eq!(
+        ::std::mem::size_of::<Opaque>(),
+        164usize,
+        concat!("Size of: ", stringify!(Opaque))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Opaque>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Opaque))
+    );
+}
+impl Default for Opaque {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for Opaque {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "Opaque {{ opaque }}")
+    }
+}
+#[repr(C)]
+pub struct OpaqueUser {
+    pub opaque: Opaque,
+}
+#[test]
+fn bindgen_test_layout_OpaqueUser() {
+    const UNINIT: ::std::mem::MaybeUninit<OpaqueUser> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<OpaqueUser>(),
+        164usize,
+        concat!("Size of: ", stringify!(OpaqueUser))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<OpaqueUser>(),
+        4usize,
+        concat!("Alignment of ", stringify!(OpaqueUser))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(OpaqueUser),
+            "::",
+            stringify!(opaque)
+        )
+    );
+}
+impl Default for OpaqueUser {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::fmt::Debug for OpaqueUser {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "OpaqueUser {{ opaque: {:?} }}", self.opaque)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs
new file mode 100644
index 00000000..fe3790c2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-default-and-blocklist.rs
@@ -0,0 +1,50 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub struct BlocklistMe(u8);
+
+/// Because this type contains a blocklisted type, it should not derive
+/// Default. Instead, we should emit a `mem::zeroed` implementation.
+#[repr(C)]
+pub struct ShouldNotDeriveDefault {
+    pub a: BlocklistMe,
+}
+#[test]
+fn bindgen_test_layout_ShouldNotDeriveDefault() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDeriveDefault> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldNotDeriveDefault>(),
+        1usize,
+        concat!("Size of: ", stringify!(ShouldNotDeriveDefault))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldNotDeriveDefault>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ShouldNotDeriveDefault))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotDeriveDefault),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for ShouldNotDeriveDefault {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs b/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs
new file mode 100644
index 00000000..9da0a40a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-fn-ptr.rs
@@ -0,0 +1,109 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type my_fun_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+        arg4: ::std::os::raw::c_int,
+        arg5: ::std::os::raw::c_int,
+        arg6: ::std::os::raw::c_int,
+        arg7: ::std::os::raw::c_int,
+        arg8: ::std::os::raw::c_int,
+        arg9: ::std::os::raw::c_int,
+        arg10: ::std::os::raw::c_int,
+        arg11: ::std::os::raw::c_int,
+        arg12: ::std::os::raw::c_int,
+        arg13: ::std::os::raw::c_int,
+        arg14: ::std::os::raw::c_int,
+        arg15: ::std::os::raw::c_int,
+        arg16: ::std::os::raw::c_int,
+    ),
+>;
+#[repr(C)]
+#[derive(Default, Copy, Clone)]
+pub struct Foo {
+    pub callback: my_fun_t,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(callback)
+        )
+    );
+}
+pub type my_fun2_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+        arg4: ::std::os::raw::c_int,
+        arg5: ::std::os::raw::c_int,
+        arg6: ::std::os::raw::c_int,
+        arg7: ::std::os::raw::c_int,
+        arg8: ::std::os::raw::c_int,
+        arg9: ::std::os::raw::c_int,
+        arg10: ::std::os::raw::c_int,
+        arg11: ::std::os::raw::c_int,
+        arg12: ::std::os::raw::c_int,
+    ),
+>;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Bar {
+    pub callback: my_fun2_t,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(callback)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs
new file mode 100644
index 00000000..c677b15e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-and-blocklist.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub struct BlocklistMe(u8);
+
+/// Because this type contains a blocklisted type, it should not derive Hash.
+#[repr(C)]
+pub struct ShouldNotDeriveHash {
+    pub a: BlocklistMe,
+}
+#[test]
+fn bindgen_test_layout_ShouldNotDeriveHash() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDeriveHash> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldNotDeriveHash>(),
+        1usize,
+        concat!("Size of: ", stringify!(ShouldNotDeriveHash))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldNotDeriveHash>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ShouldNotDeriveHash))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotDeriveHash),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for ShouldNotDeriveHash {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs b/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs
new file mode 100644
index 00000000..868bf9f2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-blocklisting.rs
@@ -0,0 +1,95 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct Blocklisted<T> {
+    t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+
+/// This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type,
+/// causing us to conservatively avoid deriving hash/Eq/PartialEq for it.
+#[repr(C)]
+pub struct AllowlistedOne {
+    pub a: Blocklisted<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_AllowlistedOne() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistedOne> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistedOne>(),
+        4usize,
+        concat!("Size of: ", stringify!(AllowlistedOne))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistedOne>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllowlistedOne))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistedOne),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for AllowlistedOne {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type.
+#[repr(C)]
+pub struct AllowlistedTwo {
+    pub b: Blocklisted<f32>,
+}
+#[test]
+fn bindgen_test_layout_AllowlistedTwo() {
+    const UNINIT: ::std::mem::MaybeUninit<AllowlistedTwo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AllowlistedTwo>(),
+        4usize,
+        concat!("Size of: ", stringify!(AllowlistedTwo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AllowlistedTwo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(AllowlistedTwo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AllowlistedTwo),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for AllowlistedTwo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
new file mode 100644
index 00000000..78c8449b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
@@ -0,0 +1,76 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: f32,
+    pub b: f32,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs
new file mode 100644
index 00000000..a3f6013b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-float-array.rs
@@ -0,0 +1,34 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
+pub struct foo {
+    pub bar: [f32; 3usize],
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        12usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
new file mode 100644
index 00000000..06c8da1b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
@@ -0,0 +1,116 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test() {
+    const UNINIT: ::std::mem::MaybeUninit<test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<test>(),
+        4usize,
+        concat!("Size of: ", stringify!(test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(test), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(test),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test2() {
+    assert_eq!(
+        ::std::mem::size_of::<test2>(),
+        4usize,
+        concat!("Size of: ", stringify!(test2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test2))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test3 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test3() {
+    assert_eq!(
+        ::std::mem::size_of::<test3>(),
+        4usize,
+        concat!("Size of: ", stringify!(test3))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test3>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test3))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs
new file mode 100644
index 00000000..3efd55c9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-struct-with-pointer.rs
@@ -0,0 +1,168 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct ConstPtrMutObj {
+    pub bar: *mut ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ConstPtrMutObj() {
+    const UNINIT: ::std::mem::MaybeUninit<ConstPtrMutObj> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ConstPtrMutObj>(),
+        8usize,
+        concat!("Size of: ", stringify!(ConstPtrMutObj))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ConstPtrMutObj>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ConstPtrMutObj))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ConstPtrMutObj),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for ConstPtrMutObj {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct MutPtrMutObj {
+    pub bar: *mut ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_MutPtrMutObj() {
+    const UNINIT: ::std::mem::MaybeUninit<MutPtrMutObj> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<MutPtrMutObj>(),
+        8usize,
+        concat!("Size of: ", stringify!(MutPtrMutObj))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MutPtrMutObj>(),
+        8usize,
+        concat!("Alignment of ", stringify!(MutPtrMutObj))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(MutPtrMutObj),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for MutPtrMutObj {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct MutPtrConstObj {
+    pub bar: *const ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_MutPtrConstObj() {
+    const UNINIT: ::std::mem::MaybeUninit<MutPtrConstObj> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<MutPtrConstObj>(),
+        8usize,
+        concat!("Size of: ", stringify!(MutPtrConstObj))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MutPtrConstObj>(),
+        8usize,
+        concat!("Alignment of ", stringify!(MutPtrConstObj))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(MutPtrConstObj),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for MutPtrConstObj {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct ConstPtrConstObj {
+    pub bar: *const ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ConstPtrConstObj() {
+    const UNINIT: ::std::mem::MaybeUninit<ConstPtrConstObj> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ConstPtrConstObj>(),
+        8usize,
+        concat!("Size of: ", stringify!(ConstPtrConstObj))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ConstPtrConstObj>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ConstPtrConstObj))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ConstPtrConstObj),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for ConstPtrConstObj {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs
new file mode 100644
index 00000000..5e07a611
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-template-def-float.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
+pub struct foo<T> {
+    pub data: T,
+    pub b: f32,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for foo<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs b/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs
new file mode 100644
index 00000000..b2e2d8d0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-hash-template-inst-float.rs
@@ -0,0 +1,135 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct foo<T> {
+    pub data: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for foo<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct IntStr {
+    pub a: foo<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_IntStr() {
+    const UNINIT: ::std::mem::MaybeUninit<IntStr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<IntStr>(),
+        4usize,
+        concat!("Size of: ", stringify!(IntStr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<IntStr>(),
+        4usize,
+        concat!("Alignment of ", stringify!(IntStr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(IntStr), "::", stringify!(a))
+    );
+}
+impl Default for IntStr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
+pub struct FloatStr {
+    pub a: foo<f32>,
+}
+#[test]
+fn bindgen_test_layout_FloatStr() {
+    const UNINIT: ::std::mem::MaybeUninit<FloatStr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<FloatStr>(),
+        4usize,
+        concat!("Size of: ", stringify!(FloatStr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<FloatStr>(),
+        4usize,
+        concat!("Alignment of ", stringify!(FloatStr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(FloatStr),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for FloatStr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_foo_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<foo<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(foo<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(foo<::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_foo_open0_float_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<foo<f32>>(),
+        4usize,
+        concat!("Size of template specialization: ", stringify!(foo<f32>))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo<f32>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(foo<f32>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs
new file mode 100644
index 00000000..c772c0b9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-and-blocklist.rs
@@ -0,0 +1,50 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub struct BlocklistMe(u8);
+
+/// Because this type contains a blocklisted type, it should not derive
+/// PartialEq.
+#[repr(C)]
+pub struct ShouldNotDerivePartialEq {
+    pub a: BlocklistMe,
+}
+#[test]
+fn bindgen_test_layout_ShouldNotDerivePartialEq() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDerivePartialEq> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldNotDerivePartialEq>(),
+        1usize,
+        concat!("Size of: ", stringify!(ShouldNotDerivePartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldNotDerivePartialEq>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ShouldNotDerivePartialEq))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotDerivePartialEq),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for ShouldNotDerivePartialEq {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs
new file mode 100644
index 00000000..16d4381f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-anonfield.rs
@@ -0,0 +1,63 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct rte_mbuf {
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(1))]
+#[derive(Copy, Clone)]
+pub struct rte_mbuf__bindgen_ty_1 {
+    pub bindgen_union_field: [u8; 0usize],
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
+        0usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf>(),
+        0usize,
+        concat!("Size of: ", stringify!(rte_mbuf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_mbuf))
+    );
+}
+impl Default for rte_mbuf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs
new file mode 100644
index 00000000..840720f2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-base.rs
@@ -0,0 +1,84 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Base {
+    pub large: [::std::os::raw::c_int; 33usize],
+}
+#[test]
+fn bindgen_test_layout_Base() {
+    const UNINIT: ::std::mem::MaybeUninit<Base> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Base>(),
+        132usize,
+        concat!("Size of: ", stringify!(Base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Base>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Base))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Base),
+            "::",
+            stringify!(large)
+        )
+    );
+}
+impl Default for Base {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for Base {
+    fn eq(&self, other: &Base) -> bool {
+        &self.large[..] == &other.large[..]
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ShouldDerivePartialEq {
+    pub _base: Base,
+}
+#[test]
+fn bindgen_test_layout_ShouldDerivePartialEq() {
+    assert_eq!(
+        ::std::mem::size_of::<ShouldDerivePartialEq>(),
+        132usize,
+        concat!("Size of: ", stringify!(ShouldDerivePartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldDerivePartialEq>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ShouldDerivePartialEq))
+    );
+}
+impl Default for ShouldDerivePartialEq {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for ShouldDerivePartialEq {
+    fn eq(&self, other: &ShouldDerivePartialEq) -> bool {
+        self._base == other._base
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs
new file mode 100644
index 00000000..cb9781de
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs
@@ -0,0 +1,189 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub large_array: [::std::os::raw::c_int; 50usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        204usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for C {
+    fn eq(&self, other: &C) -> bool {
+        self.a() == other.a() &&
+            self.b() == other.b() &&
+            &self.large_array[..] == &other.large_array[..]
+    }
+}
+impl C {
+    #[inline]
+    pub fn a(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: bool,
+        b: bool,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 7u8, {
+            let b: u8 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs
new file mode 100644
index 00000000..620b40fa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-core.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate core;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub large_array: [::std::os::raw::c_int; 420usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::core::mem::MaybeUninit<C> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<C>(),
+        1680usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe {
+            ::core::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::core::cmp::PartialEq for C {
+    fn eq(&self, other: &C) -> bool {
+        &self.large_array[..] == &other.large_array[..]
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs
new file mode 100644
index 00000000..e0d3c062
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-pointer.rs
@@ -0,0 +1,131 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Bar {
+    pub b: *mut a,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(b))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct c {
+    pub __bindgen_anon_1: c__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union c__bindgen_ty_1 {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_c__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<c__bindgen_ty_1>(),
+        1usize,
+        concat!("Size of: ", stringify!(c__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<c__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(c__bindgen_ty_1))
+    );
+}
+impl Default for c__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_c() {
+    assert_eq!(
+        ::std::mem::size_of::<c>(),
+        1usize,
+        concat!("Size of: ", stringify!(c))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<c>(),
+        1usize,
+        concat!("Alignment of ", stringify!(c))
+    );
+}
+impl Default for c {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct a {
+    pub d: c,
+}
+#[test]
+fn bindgen_test_layout_a() {
+    const UNINIT: ::std::mem::MaybeUninit<a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        1usize,
+        concat!("Size of: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        1usize,
+        concat!("Alignment of ", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(d))
+    );
+}
+impl Default for a {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs
new file mode 100644
index 00000000..5ffd0bcd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-union.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Deriving PartialEq for rust unions is not supported.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ShouldNotDerivePartialEq {
+    pub a: ::std::os::raw::c_char,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ShouldNotDerivePartialEq() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDerivePartialEq> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldNotDerivePartialEq>(),
+        4usize,
+        concat!("Size of: ", stringify!(ShouldNotDerivePartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldNotDerivePartialEq>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ShouldNotDerivePartialEq))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotDerivePartialEq),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotDerivePartialEq),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for ShouldNotDerivePartialEq {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-union_1_0.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-union_1_0.rs
new file mode 100644
index 00000000..a53b9ba8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-union_1_0.rs
@@ -0,0 +1,113 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+/// This should manually derive PartialEq.
+#[repr(C)]
+#[derive(Copy)]
+pub struct ShouldDerivePartialEq {
+    pub a: __BindgenUnionField<[::std::os::raw::c_char; 150usize]>,
+    pub b: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: [u32; 38usize],
+}
+#[test]
+fn bindgen_test_layout_ShouldDerivePartialEq() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldDerivePartialEq> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldDerivePartialEq>(),
+        152usize,
+        concat!("Size of: ", stringify!(ShouldDerivePartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldDerivePartialEq>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ShouldDerivePartialEq))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldDerivePartialEq),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldDerivePartialEq),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for ShouldDerivePartialEq {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for ShouldDerivePartialEq {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl ::std::cmp::PartialEq for ShouldDerivePartialEq {
+    fn eq(&self, other: &ShouldDerivePartialEq) -> bool {
+        &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/disable-namespacing.rs b/bindgen-tests/tests/expectations/tests/disable-namespacing.rs
new file mode 100644
index 00000000..626bb060
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/disable-namespacing.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type Baz = ::std::os::raw::c_int;
diff --git a/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs b/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs
new file mode 100644
index 00000000..ce8a01ad
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/disable-nested-struct-naming.rs
@@ -0,0 +1,269 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {
+    pub b1: bar1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct bar1 {
+    pub x1: ::std::os::raw::c_int,
+    pub b2: bar1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct bar1__bindgen_ty_1 {
+    pub x2: ::std::os::raw::c_int,
+    pub b3: bar1__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct bar1__bindgen_ty_1__bindgen_ty_1 {
+    pub x3: ::std::os::raw::c_int,
+    pub b4: bar4,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct bar4 {
+    pub x4: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_bar4() {
+    const UNINIT: ::std::mem::MaybeUninit<bar4> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar4>(),
+        4usize,
+        concat!("Size of: ", stringify!(bar4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar4>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar4))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x4) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(bar4), "::", stringify!(x4))
+    );
+}
+#[test]
+fn bindgen_test_layout_bar1__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<bar1__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar1__bindgen_ty_1__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(bar1__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar1__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(bar1__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x3) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar1__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(x3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b4) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar1__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b4)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_bar1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<bar1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar1__bindgen_ty_1>(),
+        12usize,
+        concat!("Size of: ", stringify!(bar1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar1__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar1__bindgen_ty_1),
+            "::",
+            stringify!(x2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b3) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bar1__bindgen_ty_1),
+            "::",
+            stringify!(b3)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_bar1() {
+    const UNINIT: ::std::mem::MaybeUninit<bar1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar1>(),
+        16usize,
+        concat!("Size of: ", stringify!(bar1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x1) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(bar1), "::", stringify!(x1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(bar1), "::", stringify!(b2))
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b1))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct _bindgen_ty_1 {
+    pub anon2: _bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct _bindgen_ty_1__bindgen_ty_1 {
+    pub b: baz,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct baz {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_baz() {
+    const UNINIT: ::std::mem::MaybeUninit<baz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<baz>(),
+        4usize,
+        concat!("Size of: ", stringify!(baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<baz>(),
+        4usize,
+        concat!("Alignment of ", stringify!(baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(baz), "::", stringify!(x))
+    );
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<_bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<_bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).anon2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(anon2)
+        )
+    );
+}
+extern "C" {
+    pub static mut anon1: _bindgen_ty_1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs b/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs
new file mode 100644
index 00000000..515f496b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/disable-untagged-union.rs
@@ -0,0 +1,83 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub baz: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
new file mode 100644
index 00000000..721d71e2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
@@ -0,0 +1,138 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithBitfield {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub a: ::std::os::raw::c_uint,
+}
+impl WithBitfield {
+    #[inline]
+    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithBitfieldAndAttrPacked {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub a: ::std::os::raw::c_uint,
+}
+impl WithBitfieldAndAttrPacked {
+    #[inline]
+    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithBitfieldAndPacked {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub a: ::std::os::raw::c_uint,
+}
+impl WithBitfieldAndPacked {
+    #[inline]
+    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs b/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs
new file mode 100644
index 00000000..4f9081ad
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/do-not-derive-copy.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct WouldBeCopyButWeAreNotDerivingCopy {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WouldBeCopyButWeAreNotDerivingCopy() {
+    const UNINIT: ::std::mem::MaybeUninit<WouldBeCopyButWeAreNotDerivingCopy> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WouldBeCopyButWeAreNotDerivingCopy>(),
+        4usize,
+        concat!("Size of: ", stringify!(WouldBeCopyButWeAreNotDerivingCopy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WouldBeCopyButWeAreNotDerivingCopy>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(WouldBeCopyButWeAreNotDerivingCopy)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WouldBeCopyButWeAreNotDerivingCopy),
+            "::",
+            stringify!(x)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/doggo-or-null.rs b/bindgen-tests/tests/expectations/tests/doggo-or-null.rs
new file mode 100644
index 00000000..90287159
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/doggo-or-null.rs
@@ -0,0 +1,85 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)]
+pub struct Doggo {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Doggo() {
+    const UNINIT: ::std::mem::MaybeUninit<Doggo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Doggo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Doggo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Doggo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Doggo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Doggo), "::", stringify!(x))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)]
+pub struct Null {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Null() {
+    assert_eq!(
+        ::std::mem::size_of::<Null>(),
+        1usize,
+        concat!("Size of: ", stringify!(Null))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Null>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Null))
+    );
+}
+/// This type is an opaque union. Unions can't derive anything interesting like
+/// Debug or Default, even if their layout can, because it would require knowing
+/// which variant is in use. Opaque unions still end up as a `union` in the Rust
+/// bindings, but they just have one variant. Even so, can't derive. We should
+/// probably emit an opaque struct for opaque unions... but until then, we have
+/// this test to make sure that opaque unions don't derive and still compile.
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Copy, Clone)]
+pub union DoggoOrNull {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_DoggoOrNull() {
+    assert_eq!(
+        ::std::mem::size_of::<DoggoOrNull>(),
+        4usize,
+        concat!("Size of: ", stringify!(DoggoOrNull))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DoggoOrNull>(),
+        4usize,
+        concat!("Alignment of ", stringify!(DoggoOrNull))
+    );
+}
+impl Default for DoggoOrNull {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs b/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs
new file mode 100644
index 00000000..85e45392
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dupe-enum-variant-in-namespace.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        impl root::foo::Bar {
+            pub const Foo1: root::foo::Bar = Bar::Foo;
+        }
+        impl root::foo::Bar {
+            pub const Foo3: root::foo::Bar = Bar::Foo2;
+        }
+        #[repr(u32)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub enum Bar {
+            Foo = 0,
+            Foo2 = 1,
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs b/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs
new file mode 100644
index 00000000..8e7c895b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/duplicated-namespaces-definitions.rs
@@ -0,0 +1,108 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Bar {
+            pub foo: ::std::os::raw::c_int,
+            pub baz: bool,
+        }
+        #[test]
+        fn bindgen_test_layout_Bar() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar>(),
+                8usize,
+                concat!("Size of: ", stringify!(Bar))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize
+                },
+                4usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(baz)
+                )
+            );
+        }
+    }
+    pub mod bar {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct Foo {
+            pub ptr: *mut root::foo::Bar,
+        }
+        #[test]
+        fn bindgen_test_layout_Foo() {
+            const UNINIT: ::std::mem::MaybeUninit<Foo> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Foo>(),
+                8usize,
+                concat!("Size of: ", stringify!(Foo))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Foo>(),
+                8usize,
+                concat!("Alignment of ", stringify!(Foo))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Foo),
+                    "::",
+                    stringify!(ptr)
+                )
+            );
+        }
+        impl Default for Foo {
+            fn default() -> Self {
+                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                unsafe {
+                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                    s.assume_init()
+                }
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs b/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs
new file mode 100644
index 00000000..0bbceac8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/duplicated-namespaces.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+}
diff --git a/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs b/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs
new file mode 100644
index 00000000..3b3405db
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/duplicated_constants_in_ns.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub const FOO: ::std::os::raw::c_int = 4;
+    }
+    pub mod bar {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub const FOO: ::std::os::raw::c_int = 5;
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs
new file mode 100644
index 00000000..c834752e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_attributes.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: unsafe extern "C" fn(
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int,
+    pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym)?;
+        let baz = __library.get(b"baz\0").map(|sym| *sym)?;
+        Ok(TestLib {
+            __library,
+            foo,
+            baz,
+        })
+    }
+    #[must_use]
+    /// @brief A function
+    ///
+    /// @param x
+    /// @param y
+    /// @return int
+    pub unsafe fn foo(
+        &self,
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        (self.foo)(x, y)
+    }
+    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
+        (self.baz)()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs
new file mode 100644
index 00000000..e46ffd49
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_required.rs
@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: unsafe extern "C" fn(
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int,
+    pub bar: unsafe extern "C" fn(
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int,
+    pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym)?;
+        let bar = __library.get(b"bar\0").map(|sym| *sym)?;
+        let baz = __library.get(b"baz\0").map(|sym| *sym)?;
+        Ok(TestLib {
+            __library,
+            foo,
+            bar,
+            baz,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        (self.foo)(x, y)
+    }
+    pub unsafe fn bar(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.bar)(x)
+    }
+    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
+        (self.baz)()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs
new file mode 100644
index 00000000..cae5bd69
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_simple.rs
@@ -0,0 +1,70 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: Result<
+        unsafe extern "C" fn(
+            x: ::std::os::raw::c_int,
+            y: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub bar: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub baz: Result<
+        unsafe extern "C" fn() -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym);
+        let bar = __library.get(b"bar\0").map(|sym| *sym);
+        let baz = __library.get(b"baz\0").map(|sym| *sym);
+        Ok(TestLib {
+            __library,
+            foo,
+            bar,
+            baz,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        (self.foo.as_ref().expect("Expected function, got error."))(x, y)
+    }
+    pub unsafe fn bar(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.bar.as_ref().expect("Expected function, got error."))(x)
+    }
+    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
+        (self.baz.as_ref().expect("Expected function, got error."))()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs
new file mode 100644
index 00000000..06e67ed7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_template.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: Result<
+        unsafe extern "C" fn(x: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub foo1: Result<unsafe extern "C" fn(x: f32) -> f32, ::libloading::Error>,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym);
+        let foo1 = __library.get(b"foo1\0").map(|sym| *sym);
+        Ok(TestLib {
+            __library,
+            foo,
+            foo1,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        (self.foo.as_ref().expect("Expected function, got error."))(x)
+    }
+    pub unsafe fn foo1(&self, x: f32) -> f32 {
+        (self.foo1.as_ref().expect("Expected function, got error."))(x)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs
new file mode 100644
index 00000000..97bb67ab
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_allowlist.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub baz: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub bazz: Result<
+        unsafe extern "C" fn(
+            arg1: ::std::os::raw::c_int,
+            ...
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym);
+        let baz = __library.get(b"baz\0").map(|sym| *sym);
+        let bazz = __library.get(b"bazz\0").map(|sym| *sym);
+        Ok(TestLib {
+            __library,
+            foo,
+            baz,
+            bazz,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.foo.as_ref().expect("Expected function, got error."))(x)
+    }
+    pub unsafe fn baz(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.baz.as_ref().expect("Expected function, got error."))(x)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs
new file mode 100644
index 00000000..af482ad9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_blocklist.rs
@@ -0,0 +1,113 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct X {
+    pub _x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_X() {
+    const UNINIT: ::std::mem::MaybeUninit<X> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<X>(),
+        4usize,
+        concat!("Size of: ", stringify!(X))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<X>(),
+        4usize,
+        concat!("Alignment of ", stringify!(X))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr)._x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(X), "::", stringify!(_x))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1X13some_functionEv"]
+    pub fn X_some_function(this: *mut X);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1X19some_other_functionEv"]
+    pub fn X_some_other_function(this: *mut X);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1XC1Ei"]
+    pub fn X_X(this: *mut X, x: ::std::os::raw::c_int);
+}
+impl X {
+    #[inline]
+    pub unsafe fn some_function(&mut self) {
+        X_some_function(self)
+    }
+    #[inline]
+    pub unsafe fn some_other_function(&mut self) {
+        X_some_other_function(self)
+    }
+    #[inline]
+    pub unsafe fn new(x: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        X_X(__bindgen_tmp.as_mut_ptr(), x);
+        __bindgen_tmp.assume_init()
+    }
+}
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub bar: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym);
+        let bar = __library.get(b"bar\0").map(|sym| *sym);
+        Ok(TestLib {
+            __library,
+            foo,
+            bar,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.foo.as_ref().expect("Expected function, got error."))(x)
+    }
+    pub unsafe fn bar(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.bar.as_ref().expect("Expected function, got error."))(x)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs
new file mode 100644
index 00000000..514cff73
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/dynamic_loading_with_class.rs
@@ -0,0 +1,105 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        4usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr)._x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(_x))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A13some_functionEv"]
+    pub fn A_some_function(this: *mut A);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A19some_other_functionEv"]
+    pub fn A_some_other_function(this: *mut A);
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1AC1Ei"]
+    pub fn A_A(this: *mut A, x: ::std::os::raw::c_int);
+}
+impl A {
+    #[inline]
+    pub unsafe fn some_function(&mut self) {
+        A_some_function(self)
+    }
+    #[inline]
+    pub unsafe fn some_other_function(&mut self) {
+        A_some_other_function(self)
+    }
+    #[inline]
+    pub unsafe fn new(x: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        A_A(__bindgen_tmp.as_mut_ptr(), x);
+        __bindgen_tmp.assume_init()
+    }
+}
+extern crate libloading;
+pub struct TestLib {
+    __library: ::libloading::Library,
+    pub foo: Result<
+        unsafe extern "C" fn(
+            x: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+        ::libloading::Error,
+    >,
+    pub bar: Result<unsafe extern "C" fn(), ::libloading::Error>,
+}
+impl TestLib {
+    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    where
+        P: AsRef<::std::ffi::OsStr>,
+    {
+        let library = ::libloading::Library::new(path)?;
+        Self::from_library(library)
+    }
+    pub unsafe fn from_library<L>(
+        library: L,
+    ) -> Result<Self, ::libloading::Error>
+    where
+        L: Into<::libloading::Library>,
+    {
+        let __library = library.into();
+        let foo = __library.get(b"foo\0").map(|sym| *sym);
+        let bar = __library.get(b"bar\0").map(|sym| *sym);
+        Ok(TestLib {
+            __library,
+            foo,
+            bar,
+        })
+    }
+    pub unsafe fn foo(
+        &self,
+        x: *mut ::std::os::raw::c_void,
+    ) -> ::std::os::raw::c_int {
+        (self.foo.as_ref().expect("Expected function, got error."))(x)
+    }
+    pub unsafe fn bar(&self) -> () {
+        (self.bar.as_ref().expect("Expected function, got error."))()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/elaborated.rs b/bindgen-tests/tests/expectations/tests/elaborated.rs
new file mode 100644
index 00000000..47416016
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/elaborated.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type whatever_whatever_t = ::std::os::raw::c_int;
+extern "C" {
+    #[link_name = "\u{1}_Z9somethingPKi"]
+    pub fn something(wat: *const whatever_whatever_t);
+}
diff --git a/bindgen-tests/tests/expectations/tests/empty-enum.rs b/bindgen-tests/tests/expectations/tests/empty-enum.rs
new file mode 100644
index 00000000..fe188b3e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/empty-enum.rs
@@ -0,0 +1,34 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type EmptyConstified = ::std::os::raw::c_uint;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum EmptyRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub mod EmptyModule {
+    pub type Type = ::std::os::raw::c_uint;
+}
+#[repr(i8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum EmptyClassRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub type EmptyClassConstified = ::std::os::raw::c_char;
+pub mod EmptyClassModule {
+    pub type Type = ::std::os::raw::c_char;
+}
+#[repr(i8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum ForwardClassRustified {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+pub type ForwardClassConstified = ::std::os::raw::c_char;
+pub mod ForwardClassModule {
+    pub type Type = ::std::os::raw::c_char;
+}
diff --git a/bindgen-tests/tests/expectations/tests/empty-union.rs b/bindgen-tests/tests/expectations/tests/empty-union.rs
new file mode 100644
index 00000000..c21ae2f0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/empty-union.rs
@@ -0,0 +1,21 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union a__bindgen_ty_1 {
+    pub _address: u8,
+}
+impl Default for a__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs b/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs
new file mode 100644
index 00000000..aa751f77
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/empty_template_param_name.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type __void_t = ::std::os::raw::c_void;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct __iterator_traits {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs b/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs
new file mode 100644
index 00000000..4c075766
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-default-bitfield.rs
@@ -0,0 +1,190 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1,
+}
+pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1(0);
+pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1(1);
+impl ::std::ops::BitOr<foo__bindgen_ty_1> for foo__bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        foo__bindgen_ty_1(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for foo__bindgen_ty_1 {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: foo__bindgen_ty_1) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<foo__bindgen_ty_1> for foo__bindgen_ty_1 {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        foo__bindgen_ty_1(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for foo__bindgen_ty_1 {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: foo__bindgen_ty_1) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1(pub ::std::os::raw::c_uint);
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Foo {
+    pub const Bar: Foo = Foo(0);
+}
+impl Foo {
+    pub const Qux: Foo = Foo(1);
+}
+impl ::std::ops::BitOr<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Foo(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Foo {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Foo) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Foo> for Foo {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Foo(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Foo {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Foo) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_uint);
+pub mod Neg {
+    pub type Type = ::std::os::raw::c_int;
+    pub const MinusOne: Type = -1;
+    pub const One: Type = 1;
+}
+impl NoDebug {
+    pub const NoDebug1: NoDebug = NoDebug(0);
+}
+impl NoDebug {
+    pub const NoDebug2: NoDebug = NoDebug(1);
+}
+impl ::std::ops::BitOr<NoDebug> for NoDebug {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        NoDebug(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for NoDebug {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: NoDebug) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<NoDebug> for NoDebug {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        NoDebug(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for NoDebug {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: NoDebug) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+/// <div rustbindgen nodebug></div>
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NoDebug(pub ::std::os::raw::c_uint);
+impl Debug {
+    pub const Debug1: Debug = Debug(0);
+}
+impl Debug {
+    pub const Debug2: Debug = Debug(1);
+}
+impl ::std::ops::BitOr<Debug> for Debug {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        Debug(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for Debug {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: Debug) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<Debug> for Debug {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        Debug(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for Debug {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: Debug) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+/// <div rustbindgen derive="Debug"></div>
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Debug(pub ::std::os::raw::c_uint);
diff --git a/bindgen-tests/tests/expectations/tests/enum-default-consts.rs b/bindgen-tests/tests/expectations/tests/enum-default-consts.rs
new file mode 100644
index 00000000..ddce26c2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-default-consts.rs
@@ -0,0 +1,66 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1,
+}
+pub const foo_FOO_A: foo__bindgen_ty_1 = 0;
+pub const foo_FOO_B: foo__bindgen_ty_1 = 1;
+pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint;
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub const Foo_Bar: Foo = 0;
+pub const Foo_Qux: Foo = 1;
+pub type Foo = ::std::os::raw::c_uint;
+pub mod Neg {
+    pub type Type = ::std::os::raw::c_int;
+    pub const MinusOne: Type = -1;
+    pub const One: Type = 1;
+}
+pub const NoDebug_NoDebug1: NoDebug = 0;
+pub const NoDebug_NoDebug2: NoDebug = 1;
+/// <div rustbindgen nodebug></div>
+pub type NoDebug = ::std::os::raw::c_uint;
+pub const Debug_Debug1: Debug = 0;
+pub const Debug_Debug2: Debug = 1;
+/// <div rustbindgen derive="Debug"></div>
+pub type Debug = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/enum-default-module.rs b/bindgen-tests/tests/expectations/tests/enum-default-module.rs
new file mode 100644
index 00000000..ae026d8b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-default-module.rs
@@ -0,0 +1,74 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1::Type,
+}
+pub mod foo__bindgen_ty_1 {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const FOO_A: Type = 0;
+    pub const FOO_B: Type = 1;
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub mod Foo {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const Bar: Type = 0;
+    pub const Qux: Type = 1;
+}
+pub mod Neg {
+    pub type Type = ::std::os::raw::c_int;
+    pub const MinusOne: Type = -1;
+    pub const One: Type = 1;
+}
+pub mod NoDebug {
+    /// <div rustbindgen nodebug></div>
+    pub type Type = ::std::os::raw::c_uint;
+    pub const NoDebug1: Type = 0;
+    pub const NoDebug2: Type = 1;
+}
+pub mod Debug {
+    /// <div rustbindgen derive="Debug"></div>
+    pub type Type = ::std::os::raw::c_uint;
+    pub const Debug1: Type = 0;
+    pub const Debug2: Type = 1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-default-rust.d b/bindgen-tests/tests/expectations/tests/enum-default-rust.d
new file mode 100644
index 00000000..a6540005
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-default-rust.d
@@ -0,0 +1 @@
+tests/expectations/tests/enum-default-rust.rs: tests/headers/enum-default-rust.h tests/headers/enum.h
diff --git a/bindgen-tests/tests/expectations/tests/enum-default-rust.rs b/bindgen-tests/tests/expectations/tests/enum-default-rust.rs
new file mode 100644
index 00000000..c3b728f8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-default-rust.rs
@@ -0,0 +1,80 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1,
+}
+pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A;
+pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum foo__bindgen_ty_1 {
+    FOO_A = 0,
+    FOO_B = 1,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 0,
+    Qux = 1,
+}
+pub mod Neg {
+    pub type Type = ::std::os::raw::c_int;
+    pub const MinusOne: Type = -1;
+    pub const One: Type = 1;
+}
+#[repr(u32)]
+/// <div rustbindgen nodebug></div>
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub enum NoDebug {
+    NoDebug1 = 0,
+    NoDebug2 = 1,
+}
+#[repr(u32)]
+/// <div rustbindgen derive="Debug"></div>
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Debug {
+    Debug1 = 0,
+    Debug2 = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs b/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs
new file mode 100644
index 00000000..3be0438e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-doc-bitfield.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl B {
+    /// Document field with three slashes
+    pub const VAR_A: B = B(0);
+}
+impl B {
+    /// Document field with preceeding star
+    pub const VAR_B: B = B(1);
+}
+impl B {
+    /// Document field with preceeding exclamation
+    pub const VAR_C: B = B(2);
+}
+impl B {
+    ///< Document field with following star
+    pub const VAR_D: B = B(3);
+}
+impl B {
+    ///< Document field with following exclamation
+    pub const VAR_E: B = B(4);
+}
+impl B {
+    /// Document field with preceeding star, with a loong long multiline
+    /// comment.
+    ///
+    /// Very interesting documentation, definitely.
+    pub const VAR_F: B = B(5);
+}
+impl ::std::ops::BitOr<B> for B {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        B(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for B {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: B) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<B> for B {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        B(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for B {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: B) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+/// Document enum
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct B(pub ::std::os::raw::c_uint);
diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs b/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs
new file mode 100644
index 00000000..60d6b9f4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-doc-mod.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod B {
+    /// Document enum
+    pub type Type = ::std::os::raw::c_uint;
+    /// Document field with three slashes
+    pub const VAR_A: Type = 0;
+    /// Document field with preceeding star
+    pub const VAR_B: Type = 1;
+    /// Document field with preceeding exclamation
+    pub const VAR_C: Type = 2;
+    ///< Document field with following star
+    pub const VAR_D: Type = 3;
+    ///< Document field with following exclamation
+    pub const VAR_E: Type = 4;
+    /// Document field with preceeding star, with a loong long multiline
+    /// comment.
+    ///
+    /// Very interesting documentation, definitely.
+    pub const VAR_F: Type = 5;
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs b/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs
new file mode 100644
index 00000000..e7208a9d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-doc-rusty.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u32)]
+/// Document enum
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum B {
+    /// Document field with three slashes
+    VAR_A = 0,
+    /// Document field with preceeding star
+    VAR_B = 1,
+    /// Document field with preceeding exclamation
+    VAR_C = 2,
+    ///< Document field with following star
+    VAR_D = 3,
+    ///< Document field with following exclamation
+    VAR_E = 4,
+    /// Document field with preceeding star, with a loong long multiline
+    /// comment.
+    ///
+    /// Very interesting documentation, definitely.
+    VAR_F = 5,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-doc.rs b/bindgen-tests/tests/expectations/tests/enum-doc.rs
new file mode 100644
index 00000000..b5d14b3c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-doc.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Document field with three slashes
+pub const B_VAR_A: B = 0;
+/// Document field with preceeding star
+pub const B_VAR_B: B = 1;
+/// Document field with preceeding exclamation
+pub const B_VAR_C: B = 2;
+///< Document field with following star
+pub const B_VAR_D: B = 3;
+///< Document field with following exclamation
+pub const B_VAR_E: B = 4;
+/// Document field with preceeding star, with a loong long multiline
+/// comment.
+///
+/// Very interesting documentation, definitely.
+pub const B_VAR_F: B = 5;
+/// Document enum
+pub type B = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs b/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs
new file mode 100644
index 00000000..33c7b5c7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-no-debug-rust.rs
@@ -0,0 +1,80 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1,
+}
+pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A;
+pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B;
+#[repr(u32)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub enum foo__bindgen_ty_1 {
+    FOO_A = 0,
+    FOO_B = 1,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(u32)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 0,
+    Qux = 1,
+}
+pub mod Neg {
+    pub type Type = ::std::os::raw::c_int;
+    pub const MinusOne: Type = -1;
+    pub const One: Type = 1;
+}
+#[repr(u32)]
+/// <div rustbindgen nodebug></div>
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub enum NoDebug {
+    NoDebug1 = 0,
+    NoDebug2 = 1,
+}
+#[repr(u32)]
+/// <div rustbindgen derive="Debug"></div>
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)]
+pub enum Debug {
+    Debug1 = 0,
+    Debug2 = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum-translate-type.rs b/bindgen-tests/tests/expectations/tests/enum-translate-type.rs
new file mode 100644
index 00000000..89e6003e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-translate-type.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const my_enum1_A: my_enum1 = 0;
+pub type my_enum1 = u32;
+pub const my_enum2_B: my_enum2 = -1;
+pub type my_enum2 = i32;
+pub const my_enum3_C: my_enum3 = 0;
+pub type my_enum3 = i16;
+pub const my_enum4_D: my_enum4 = 255;
+pub type my_enum4 = u8;
diff --git a/bindgen-tests/tests/expectations/tests/enum-undefault.rs b/bindgen-tests/tests/expectations/tests/enum-undefault.rs
new file mode 100644
index 00000000..e5618b91
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-undefault.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 0,
+    Qux = 1,
+}
+pub const Neg_MinusOne: Neg = -1;
+pub const Neg_One: Neg = 1;
+pub type Neg = ::std::os::raw::c_int;
diff --git a/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs b/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs
new file mode 100644
index 00000000..d9276574
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum-variant-replaces.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen replaces="PASS"></div>
+///
+/// Should see PASS below.
+pub const OGRErr_PASS: OGRErr = 0;
+/// <div rustbindgen replaces="OGRERR_NONE"></div>
+///
+/// Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below.
+pub const OGRErr_OGRERR_NONE: OGRErr = 1;
+/// <div rustbindgen replaces="OGRErr"></div>
+pub type OGRErr = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/enum.rs b/bindgen-tests/tests/expectations/tests/enum.rs
new file mode 100644
index 00000000..65b734a3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub member: foo__bindgen_ty_1,
+}
+pub const foo_FOO_A: foo__bindgen_ty_1 = 0;
+pub const foo_FOO_B: foo__bindgen_ty_1 = 1;
+pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint;
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub const Foo_Bar: Foo = 0;
+pub const Foo_Qux: Foo = 1;
+pub type Foo = ::std::os::raw::c_uint;
+pub const Neg_MinusOne: Neg = -1;
+pub const Neg_One: Neg = 1;
+pub type Neg = ::std::os::raw::c_int;
+pub const NoDebug_NoDebug1: NoDebug = 0;
+pub const NoDebug_NoDebug2: NoDebug = 1;
+/// <div rustbindgen nodebug></div>
+pub type NoDebug = ::std::os::raw::c_uint;
+pub const Debug_Debug1: Debug = 0;
+pub const Debug_Debug2: Debug = 1;
+/// <div rustbindgen derive="Debug"></div>
+pub type Debug = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/enum_alias.rs b/bindgen-tests/tests/expectations/tests/enum_alias.rs
new file mode 100644
index 00000000..ad62d16f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_alias.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Bar {
+    VAL = 0,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs b/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs
new file mode 100644
index 00000000..f414812b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_and_vtable_mangling.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const match_: _bindgen_ty_1 = _bindgen_ty_1::match_;
+pub const whatever_else: _bindgen_ty_1 = _bindgen_ty_1::whatever_else;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    match_ = 0,
+    whatever_else = 1,
+}
+#[repr(C)]
+pub struct C__bindgen_vtable {
+    pub C_match: unsafe extern "C" fn(this: *mut C),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct C {
+    pub vtable_: *const C__bindgen_vtable,
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        16usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        8usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(i))
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C5matchEv"]
+    pub fn C_match(this: *mut ::std::os::raw::c_void);
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_dupe.rs b/bindgen-tests/tests/expectations/tests/enum_dupe.rs
new file mode 100644
index 00000000..869375bb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_dupe.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl Foo {
+    pub const Dupe: Foo = Foo::Bar;
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs b/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs
new file mode 100644
index 00000000..29bc5d8c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_explicit_type.rs
@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 0,
+    Qux = 1,
+}
+#[repr(i8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Neg {
+    MinusOne = -1,
+    One = 1,
+}
+#[repr(u16)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Bigger {
+    Much = 255,
+    Larger = 256,
+}
+#[repr(i64)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MuchLong {
+    MuchLow = -4294967296,
+}
+#[repr(i64)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MuchLongLong {
+    I64_MIN = -9223372036854775808,
+}
+#[repr(u64)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MuchULongLong {
+    MuchHigh = 4294967296,
+}
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum BoolEnumsAreFun {
+    Value = 1,
+}
+pub type MyType = bool;
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum BoolEnumsAreFun2 {
+    Value2 = 1,
+}
+pub const AnonymousVariantOne: _bindgen_ty_1 =
+    _bindgen_ty_1::AnonymousVariantOne;
+pub const AnonymousVariantTwo: _bindgen_ty_1 =
+    _bindgen_ty_1::AnonymousVariantTwo;
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    AnonymousVariantOne = 0,
+    AnonymousVariantTwo = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs b/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs
new file mode 100644
index 00000000..0c833b66
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_explicit_type_constants.rs
@@ -0,0 +1,31 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(target_os = "windows"))]
+
+pub const Foo_Bar: Foo = 0;
+pub const Foo_Qux: Foo = 1;
+pub type Foo = ::std::os::raw::c_uchar;
+pub const Neg_MinusOne: Neg = -1;
+pub const Neg_One: Neg = 1;
+pub type Neg = ::std::os::raw::c_schar;
+pub const Bigger_Much: Bigger = 255;
+pub const Bigger_Larger: Bigger = 256;
+pub type Bigger = ::std::os::raw::c_ushort;
+pub const MuchLong_MuchLow: MuchLong = -4294967296;
+pub type MuchLong = ::std::os::raw::c_long;
+pub const MuchLongLong_I64_MIN: MuchLongLong = -9223372036854775808;
+pub type MuchLongLong = ::std::os::raw::c_longlong;
+pub const MuchULongLong_MuchHigh: MuchULongLong = 4294967296;
+pub type MuchULongLong = ::std::os::raw::c_ulonglong;
+pub const BoolEnumsAreFun_Value: BoolEnumsAreFun = true;
+pub type BoolEnumsAreFun = bool;
+pub type MyType = bool;
+pub const BoolEnumsAreFun2_Value2: BoolEnumsAreFun2 = true;
+pub type BoolEnumsAreFun2 = MyType;
+pub const AnonymousVariantOne: _bindgen_ty_1 = 0;
+pub const AnonymousVariantTwo: _bindgen_ty_1 = 1;
+pub type _bindgen_ty_1 = ::std::os::raw::c_uchar;
diff --git a/bindgen-tests/tests/expectations/tests/enum_in_template.rs b/bindgen-tests/tests/expectations/tests/enum_in_template.rs
new file mode 100644
index 00000000..c4c06a37
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_in_template.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub const Foo_Bar_A: Foo_Bar = 0;
+pub const Foo_Bar_B: Foo_Bar = 0;
+pub type Foo_Bar = i32;
diff --git a/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs b/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs
new file mode 100644
index 00000000..75dce30c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_in_template_with_typedef.rs
@@ -0,0 +1,21 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct std_fbstring_core {
+    pub _address: u8,
+}
+pub type std_fbstring_core_category_type = u8;
+impl std_fbstring_core_Category {
+    pub const Bar: std_fbstring_core_Category = std_fbstring_core_Category::Foo;
+}
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum std_fbstring_core_Category {
+    Foo = 0,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_negative.rs b/bindgen-tests/tests/expectations/tests/enum_negative.rs
new file mode 100644
index 00000000..02b4baed
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_negative.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = -2,
+    Qux = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/enum_packed.rs b/bindgen-tests/tests/expectations/tests/enum_packed.rs
new file mode 100644
index 00000000..89b0da46
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/enum_packed.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    Bar = 0,
+    Qux = 1,
+}
+#[repr(i8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Neg {
+    MinusOne = -1,
+    One = 1,
+}
+#[repr(u16)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Bigger {
+    Much = 255,
+    Larger = 256,
+}
diff --git a/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs b/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs
new file mode 100644
index 00000000..3376bfc6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/eval-value-dependent.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct e {
+    pub _address: u8,
+}
+pub type e_f<d> = d;
diff --git a/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs b/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs
new file mode 100644
index 00000000..576bb721
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/eval-variadic-template-parameter.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/explicit-padding.rs b/bindgen-tests/tests/expectations/tests/explicit-padding.rs
new file mode 100644
index 00000000..a6ea7671
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/explicit-padding.rs
@@ -0,0 +1,124 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct pad_me {
+    pub first: u8,
+    pub __bindgen_padding_0: [u8; 3usize],
+    pub second: u32,
+    pub third: u16,
+    pub __bindgen_padding_1: [u8; 2usize],
+}
+#[test]
+fn bindgen_test_layout_pad_me() {
+    const UNINIT: ::std::mem::MaybeUninit<pad_me> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<pad_me>(),
+        12usize,
+        concat!("Size of: ", stringify!(pad_me))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<pad_me>(),
+        4usize,
+        concat!("Alignment of ", stringify!(pad_me))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pad_me),
+            "::",
+            stringify!(first)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pad_me),
+            "::",
+            stringify!(second)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).third) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pad_me),
+            "::",
+            stringify!(third)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union dont_pad_me {
+    pub first: u8,
+    pub second: u32,
+    pub third: u16,
+}
+#[test]
+fn bindgen_test_layout_dont_pad_me() {
+    const UNINIT: ::std::mem::MaybeUninit<dont_pad_me> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<dont_pad_me>(),
+        4usize,
+        concat!("Size of: ", stringify!(dont_pad_me))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<dont_pad_me>(),
+        4usize,
+        concat!("Alignment of ", stringify!(dont_pad_me))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dont_pad_me),
+            "::",
+            stringify!(first)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dont_pad_me),
+            "::",
+            stringify!(second)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).third) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dont_pad_me),
+            "::",
+            stringify!(third)
+        )
+    );
+}
+impl Default for dont_pad_me {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/extern-const-struct.rs b/bindgen-tests/tests/expectations/tests/extern-const-struct.rs
new file mode 100644
index 00000000..8060316a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/extern-const-struct.rs
@@ -0,0 +1,50 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nsFoo {
+    pub details: [f32; 400usize],
+}
+#[test]
+fn bindgen_test_layout_nsFoo() {
+    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsFoo>(),
+        1600usize,
+        concat!("Size of: ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsFoo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).details) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsFoo),
+            "::",
+            stringify!(details)
+        )
+    );
+}
+impl Default for nsFoo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    pub static gDetails: nsFoo;
+}
diff --git a/bindgen-tests/tests/expectations/tests/extern.rs b/bindgen-tests/tests/expectations/tests/extern.rs
new file mode 100644
index 00000000..7ded13f1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/extern.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type foo = ::std::option::Option<
+    unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
+>;
diff --git a/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs
new file mode 100644
index 00000000..ccb76b85
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types-signed.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const N0: i8 = 0;
+pub const N1: i8 = 1;
+pub const N2: i8 = 2;
+pub const N_1: i8 = -1;
+pub const N_2: i8 = -2;
+pub const MAX_U16: i32 = 65535;
+pub const MAX_I16: i16 = 32767;
+pub const MAX_I16_Plus1: i32 = 32768;
+pub const MAX_U16_Plus1: i32 = 65536;
+pub const MAX_I16_Minus1: i16 = 32766;
+pub const MAX_U16_Minus1: i32 = 65534;
+pub const MIN_U16: i8 = 0;
+pub const MIN_I16: i16 = -32768;
+pub const MIN_U16_Plus1: i8 = 1;
+pub const MIN_I16_Plus1: i16 = -32767;
+pub const MIN_U16_Minus1: i8 = -1;
+pub const MIN_I16_Minus1: i32 = -32769;
+pub const MAX_U32: i64 = 4294967295;
+pub const MAX_I32: i32 = 2147483647;
+pub const MAX_I32_Plus1: i64 = 2147483648;
+pub const MAX_U32_Plus1: i64 = 4294967296;
+pub const MAX_I32_Minus1: i32 = 2147483646;
+pub const MAX_U32_Minus1: i64 = 4294967294;
+pub const MIN_U32: i8 = 0;
+pub const MIN_I32: i32 = -2147483648;
+pub const MIN_U32_Plus1: i8 = 1;
+pub const MIN_I32_Plus1: i32 = -2147483647;
+pub const MIN_U32_Minus1: i8 = -1;
+pub const MIN_I32_Minus1: i64 = -2147483649;
+pub const LONG12: i64 = 123456789012;
+pub const LONG_12: i64 = -123456789012;
+extern "C" {
+    pub fn foo(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_uint,
+        arg4: ::std::os::raw::c_char,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: ::std::os::raw::c_schar,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(
+        arg1: ::std::os::raw::c_long,
+        arg2: ::std::os::raw::c_longlong,
+    ) -> ::std::os::raw::c_long;
+}
diff --git a/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs
new file mode 100644
index 00000000..d8d3f207
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/fit-macro-constant-types.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const N0: u8 = 0;
+pub const N1: u8 = 1;
+pub const N2: u8 = 2;
+pub const N_1: i8 = -1;
+pub const N_2: i8 = -2;
+pub const MAX_U16: u16 = 65535;
+pub const MAX_I16: u16 = 32767;
+pub const MAX_I16_Plus1: u16 = 32768;
+pub const MAX_U16_Plus1: u32 = 65536;
+pub const MAX_I16_Minus1: u16 = 32766;
+pub const MAX_U16_Minus1: u16 = 65534;
+pub const MIN_U16: u8 = 0;
+pub const MIN_I16: i16 = -32768;
+pub const MIN_U16_Plus1: u8 = 1;
+pub const MIN_I16_Plus1: i16 = -32767;
+pub const MIN_U16_Minus1: i8 = -1;
+pub const MIN_I16_Minus1: i32 = -32769;
+pub const MAX_U32: u32 = 4294967295;
+pub const MAX_I32: u32 = 2147483647;
+pub const MAX_I32_Plus1: u32 = 2147483648;
+pub const MAX_U32_Plus1: u64 = 4294967296;
+pub const MAX_I32_Minus1: u32 = 2147483646;
+pub const MAX_U32_Minus1: u32 = 4294967294;
+pub const MIN_U32: u8 = 0;
+pub const MIN_I32: i32 = -2147483648;
+pub const MIN_U32_Plus1: u8 = 1;
+pub const MIN_I32_Plus1: i32 = -2147483647;
+pub const MIN_U32_Minus1: i8 = -1;
+pub const MIN_I32_Minus1: i64 = -2147483649;
+pub const LONG12: u64 = 123456789012;
+pub const LONG_12: i64 = -123456789012;
+extern "C" {
+    pub fn foo(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_uint,
+        arg4: ::std::os::raw::c_char,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: ::std::os::raw::c_schar,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(
+        arg1: ::std::os::raw::c_long,
+        arg2: ::std::os::raw::c_longlong,
+    ) -> ::std::os::raw::c_long;
+}
diff --git a/bindgen-tests/tests/expectations/tests/float128.rs b/bindgen-tests/tests/expectations/tests/float128.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/float128.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs b/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs
new file mode 100644
index 00000000..9f4fdca0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward-declaration-autoptr.rs
@@ -0,0 +1,85 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RefPtr<T> {
+    pub m_inner: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for RefPtr<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub m_member: RefPtr<Foo>,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(m_member)
+        )
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_RefPtr_open0_Foo_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<RefPtr<Foo>>(),
+        8usize,
+        concat!("Size of template specialization: ", stringify!(RefPtr<Foo>))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RefPtr<Foo>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(RefPtr<Foo>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs b/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs
new file mode 100644
index 00000000..0ac550bc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward-enum-decl.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum CSSPseudoClassType {
+    empty = 0,
+    link = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs b/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs
new file mode 100644
index 00000000..330d766b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward-inherit-struct-with-fields.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct js_RootedBase<T> {
+    pub foo: *mut T,
+    pub next: *mut Rooted<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for js_RootedBase<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub _base: js_RootedBase<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs b/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs
new file mode 100644
index 00000000..2c4546eb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward-inherit-struct.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct js_RootedBase {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted {
+    pub _address: u8,
+}
+impl Default for Rooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs
new file mode 100644
index 00000000..c1b1f23d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types.rs
@@ -0,0 +1,87 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo_empty {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo_empty() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo_empty>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo_empty))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo_empty>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo_empty))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub f: *mut Foo,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z10baz_structP3Foo"]
+    pub fn baz_struct(f: *mut Foo);
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Union {
+    _unused: [u8; 0],
+}
+extern "C" {
+    #[link_name = "\u{1}_Z9baz_unionP5Union"]
+    pub fn baz_union(u: *mut Union);
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Quux {
+    _unused: [u8; 0],
+}
+extern "C" {
+    #[link_name = "\u{1}_Z9baz_classP4Quux"]
+    pub fn baz_class(q: *mut Quux);
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_complex_types_1_0.rs b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types_1_0.rs
new file mode 100644
index 00000000..ecdbe49d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward_declared_complex_types_1_0.rs
@@ -0,0 +1,112 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Foo_empty {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo_empty() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo_empty>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo_empty))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo_empty>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo_empty))
+    );
+}
+impl Clone for Foo_empty {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
+impl Clone for Foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Bar {
+    pub f: *mut Foo,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
+    );
+}
+impl Clone for Bar {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for Bar {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z10baz_structP3Foo"]
+    pub fn baz_struct(f: *mut Foo);
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Union {
+    _unused: [u8; 0],
+}
+impl Clone for Union {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z9baz_unionP5Union"]
+    pub fn baz_union(u: *mut Union);
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Quux {
+    _unused: [u8; 0],
+}
+impl Clone for Quux {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z9baz_classP4Quux"]
+    pub fn baz_class(q: *mut Quux);
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs b/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs
new file mode 100644
index 00000000..58c02b44
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward_declared_opaque.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct a {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct b {
+    _unused: [u8; 0],
+}
diff --git a/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs b/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs
new file mode 100644
index 00000000..f877666a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/forward_declared_struct.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct a {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_a() {
+    const UNINIT: ::std::mem::MaybeUninit<a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        4usize,
+        concat!("Size of: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        4usize,
+        concat!("Alignment of ", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct c {
+    pub d: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_c() {
+    const UNINIT: ::std::mem::MaybeUninit<c> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<c>(),
+        4usize,
+        concat!("Size of: ", stringify!(c))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<c>(),
+        4usize,
+        concat!("Alignment of ", stringify!(c))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(c), "::", stringify!(d))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_proto.rs b/bindgen-tests/tests/expectations/tests/func_proto.rs
new file mode 100644
index 00000000..7ded13f1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_proto.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type foo = ::std::option::Option<
+    unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
+>;
diff --git a/bindgen-tests/tests/expectations/tests/func_ptr.rs b/bindgen-tests/tests/expectations/tests/func_ptr.rs
new file mode 100644
index 00000000..9c718f03
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_ptr.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub static mut foo: ::std::option::Option<
+        unsafe extern "C" fn(
+            x: ::std::os::raw::c_int,
+            y: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+    >;
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs b/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs
new file mode 100644
index 00000000..745720d9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_ptr_in_struct.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum baz {
+    __bindgen_cannot_repr_c_on_empty_enum = 0,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo {
+    pub bar: ::std::option::Option<
+        unsafe extern "C" fn(
+            x: ::std::os::raw::c_int,
+            y: ::std::os::raw::c_int,
+        ) -> baz,
+    >,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs b/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs
new file mode 100644
index 00000000..8f2da8ef
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_ptr_return_type.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn func() -> ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: ::std::os::raw::c_int,
+            arg2: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+    >;
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_return_must_use.rs b/bindgen-tests/tests/expectations/tests/func_return_must_use.rs
new file mode 100644
index 00000000..6ea6c704
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_return_must_use.rs
@@ -0,0 +1,78 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type MustUseInt = ::std::os::raw::c_int;
+extern "C" {
+    #[must_use]
+    pub fn return_int() -> MustUseInt;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+#[must_use]
+pub struct MustUseStruct {
+    _unused: [u8; 0],
+}
+extern "C" {
+    #[must_use]
+    pub fn return_struct() -> MustUseStruct;
+}
+/// <div rustbindgen mustusetype></div>
+pub type AnnotatedInt = ::std::os::raw::c_int;
+extern "C" {
+    #[must_use]
+    pub fn return_annotated_int() -> AnnotatedInt;
+}
+extern "C" {
+    pub fn return_plain_int() -> ::std::os::raw::c_int;
+}
+/// <div rustbindgen mustusetype></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+#[must_use]
+pub struct AnnotatedStruct {}
+#[test]
+fn bindgen_test_layout_AnnotatedStruct() {
+    assert_eq!(
+        ::std::mem::size_of::<AnnotatedStruct>(),
+        0usize,
+        concat!("Size of: ", stringify!(AnnotatedStruct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AnnotatedStruct>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AnnotatedStruct))
+    );
+}
+extern "C" {
+    #[must_use]
+    pub fn return_annotated_struct() -> AnnotatedStruct;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PlainStruct {}
+#[test]
+fn bindgen_test_layout_PlainStruct() {
+    assert_eq!(
+        ::std::mem::size_of::<PlainStruct>(),
+        0usize,
+        concat!("Size of: ", stringify!(PlainStruct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PlainStruct>(),
+        1usize,
+        concat!("Alignment of ", stringify!(PlainStruct))
+    );
+}
+/// <div rustbindgen mustusetype></div>
+pub type TypedefPlainStruct = PlainStruct;
+extern "C" {
+    pub fn return_plain_struct() -> PlainStruct;
+}
+extern "C" {
+    #[must_use]
+    pub fn return_typedef_struct() -> TypedefPlainStruct;
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs b/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs
new file mode 100644
index 00000000..f98192f8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_with_array_arg.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn f(x: *mut ::std::os::raw::c_int);
+}
diff --git a/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs b/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs
new file mode 100644
index 00000000..fb06b88e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/func_with_func_ptr_arg.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo(bar: ::std::option::Option<unsafe extern "C" fn()>);
+}
+extern "C" {
+    pub fn bar(
+        one: ::std::option::Option<
+            unsafe extern "C" fn(
+                a: ::std::os::raw::c_int,
+                b: ::std::os::raw::c_int,
+            ),
+        >,
+        two: ::std::option::Option<
+            unsafe extern "C" fn(
+                c: ::std::os::raw::c_int,
+                d: ::std::os::raw::c_int,
+            ),
+        >,
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs b/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs
new file mode 100644
index 00000000..11c9ef20
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/function-typedef-stdcall.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type PFN_VIGEM_X360_NOTIFICATION = ::std::option::Option<
+    unsafe extern "C" fn(
+        arg1: *mut ::std::os::raw::c_void,
+        arg2: *mut ::std::os::raw::c_void,
+        arg3: ::std::os::raw::c_uchar,
+        arg4: ::std::os::raw::c_uchar,
+        arg5: ::std::os::raw::c_uchar,
+        arg6: *mut ::std::os::raw::c_void,
+    ),
+>;
diff --git a/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs b/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs
new file mode 100644
index 00000000..f5ba025a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/gen-constructors-neg.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/gen-constructors.rs b/bindgen-tests/tests/expectations/tests/gen-constructors.rs
new file mode 100644
index 00000000..89b86379
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/gen-constructors.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3FooC1Ei"]
+    pub fn Foo_Foo(this: *mut Foo, a: ::std::os::raw::c_int);
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn new(a: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        Foo_Foo(__bindgen_tmp.as_mut_ptr(), a);
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs b/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs
new file mode 100644
index 00000000..b87eb1d4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/gen-destructors-neg.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct Foo {
+    pub bar: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/gen-destructors.rs b/bindgen-tests/tests/expectations/tests/gen-destructors.rs
new file mode 100644
index 00000000..1711f76d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/gen-destructors.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct Foo {
+    pub bar: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3FooD1Ev"]
+    pub fn Foo_Foo_destructor(this: *mut Foo);
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn destruct(&mut self) {
+        Foo_Foo_destructor(self)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/generate-inline.rs b/bindgen-tests/tests/expectations/tests/generate-inline.rs
new file mode 100644
index 00000000..3cb865a4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/generate-inline.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo3barEv"]
+    pub fn Foo_bar() -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn bar() -> ::std::os::raw::c_int {
+        Foo_bar()
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3foov"]
+    pub fn foo() -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/i128.rs b/bindgen-tests/tests/expectations/tests/i128.rs
new file mode 100644
index 00000000..dee57a6d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/i128.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {
+    pub my_signed: i128,
+    pub my_unsigned: u128,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        32usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        16usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).my_signed) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(my_signed)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).my_unsigned) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(my_unsigned)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/in_class_typedef.rs b/bindgen-tests/tests/expectations/tests/in_class_typedef.rs
new file mode 100644
index 00000000..7bb7d391
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/in_class_typedef.rs
@@ -0,0 +1,20 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub type Foo_elem_type<T> = T;
+pub type Foo_ptr_type<T> = *mut T;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo_Bar {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
diff --git a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs
new file mode 100644
index 00000000..18061ea1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs
@@ -0,0 +1,179 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct foo {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl foo {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: ::std::os::raw::c_char,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/infinite-macro.rs b/bindgen-tests/tests/expectations/tests/infinite-macro.rs
new file mode 100644
index 00000000..081a0c29
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/infinite-macro.rs
@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const INFINITY: f64 = ::std::f64::INFINITY;
+pub const NAN: f64 = ::std::f64::NAN;
diff --git a/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs b/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
new file mode 100644
index 00000000..0876878e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
@@ -0,0 +1,238 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct BaseWithVtable__bindgen_vtable {}
+/// This should have an explicit vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct BaseWithVtable<T> {
+    pub vtable_: *const BaseWithVtable__bindgen_vtable,
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for BaseWithVtable<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// This should not have an explicit vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DerivedWithNoVirtualMethods {
+    pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DerivedWithNoVirtualMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<DerivedWithNoVirtualMethods>(),
+        16usize,
+        concat!("Size of: ", stringify!(DerivedWithNoVirtualMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DerivedWithNoVirtualMethods>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DerivedWithNoVirtualMethods))
+    );
+}
+impl Default for DerivedWithNoVirtualMethods {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// This should not have an explicit vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DerivedWithVirtualMethods {
+    pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DerivedWithVirtualMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<DerivedWithVirtualMethods>(),
+        16usize,
+        concat!("Size of: ", stringify!(DerivedWithVirtualMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DerivedWithVirtualMethods>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DerivedWithVirtualMethods))
+    );
+}
+impl Default for DerivedWithVirtualMethods {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// This should not have any vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct BaseWithoutVtable<U> {
+    pub u: U,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<U> Default for BaseWithoutVtable<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct DerivedWithVtable__bindgen_vtable(::std::os::raw::c_void);
+/// This should have an explicit vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DerivedWithVtable {
+    pub vtable_: *const DerivedWithVtable__bindgen_vtable,
+    pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DerivedWithVtable() {
+    assert_eq!(
+        ::std::mem::size_of::<DerivedWithVtable>(),
+        16usize,
+        concat!("Size of: ", stringify!(DerivedWithVtable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DerivedWithVtable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DerivedWithVtable))
+    );
+}
+impl Default for DerivedWithVtable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// This should not have any vtable.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DerivedWithoutVtable {
+    pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DerivedWithoutVtable() {
+    assert_eq!(
+        ::std::mem::size_of::<DerivedWithoutVtable>(),
+        8usize,
+        concat!("Size of: ", stringify!(DerivedWithoutVtable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DerivedWithoutVtable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DerivedWithoutVtable))
+    );
+}
+impl Default for DerivedWithoutVtable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_BaseWithVtable_open0_ptr_char_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
+        16usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_BaseWithVtable_open0_ptr_char_close0_instantiation_1()
+{
+    assert_eq!(
+        ::std::mem::size_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
+        16usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_BaseWithoutVtable_open0_ptr_char_close0_instantiation()
+{
+    assert_eq!(
+        ::std::mem::size_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(
+        ),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_BaseWithoutVtable_open0_ptr_char_close0_instantiation_1(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(
+        ),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs b/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs
new file mode 100644
index 00000000..2c4546eb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inherit-namespaced.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct js_RootedBase {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted {
+    pub _address: u8,
+}
+impl Default for Rooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inherit_named.rs b/bindgen-tests/tests/expectations/tests/inherit_named.rs
new file mode 100644
index 00000000..a8eee207
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inherit_named.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Wohoo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Weeee<T> {
+    pub _base: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Weeee<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inherit_typedef.rs b/bindgen-tests/tests/expectations/tests/inherit_typedef.rs
new file mode 100644
index 00000000..285dd44f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inherit_typedef.rs
@@ -0,0 +1,44 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+pub type TypedefedFoo = Foo;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/inline-function.rs b/bindgen-tests/tests/expectations/tests/inline-function.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline-function.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace.rs b/bindgen-tests/tests/expectations/tests/inline_namespace.rs
new file mode 100644
index 00000000..c569bba6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline_namespace.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub type Ty = ::std::os::raw::c_int;
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Bar {
+        pub baz: root::foo::Ty,
+    }
+    #[test]
+    fn bindgen_test_layout_Bar() {
+        const UNINIT: ::std::mem::MaybeUninit<Bar> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<Bar>(),
+            4usize,
+            concat!("Size of: ", stringify!(Bar))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<Bar>(),
+            4usize,
+            concat!("Alignment of ", stringify!(Bar))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(Bar),
+                "::",
+                stringify!(baz)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs
new file mode 100644
index 00000000..1f4bc686
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline_namespace_allowlist.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod std {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub type string = *const ::std::os::raw::c_char;
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs
new file mode 100644
index 00000000..4ffafd46
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline_namespace_conservative.rs
@@ -0,0 +1,53 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod bar {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            pub type Ty = ::std::os::raw::c_int;
+        }
+        pub type Ty = ::std::os::raw::c_longlong;
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Bar {
+        pub baz: root::foo::bar::Ty,
+    }
+    #[test]
+    fn bindgen_test_layout_Bar() {
+        const UNINIT: ::std::mem::MaybeUninit<Bar> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<Bar>(),
+            4usize,
+            concat!("Size of: ", stringify!(Bar))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<Bar>(),
+            4usize,
+            concat!("Alignment of ", stringify!(Bar))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(Bar),
+                "::",
+                stringify!(baz)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs
new file mode 100644
index 00000000..7a0c9935
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline_namespace_no_ns_enabled.rs
@@ -0,0 +1,53 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct std_basic_string<CharT> {
+    pub hider: std_basic_string_Alloc_hider,
+    pub length: ::std::os::raw::c_ulong,
+    pub __bindgen_anon_1: std_basic_string__bindgen_ty_1<CharT>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<CharT>>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct std_basic_string_Alloc_hider {
+    pub storage: *mut ::std::os::raw::c_void,
+}
+impl Default for std_basic_string_Alloc_hider {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct std_basic_string__bindgen_ty_1<CharT> {
+    pub inline_storage: [CharT; 4usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<CharT>>,
+}
+impl<CharT> Default for std_basic_string__bindgen_ty_1<CharT> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<CharT> Default for std_basic_string<CharT> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs b/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs
new file mode 100644
index 00000000..1cfa549c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inner-typedef-gh422.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo_InnerType<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Foo_InnerType<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type Bar = InnerType;
+extern "C" {
+    #[link_name = "\u{1}_Z4funcv"]
+    pub fn func() -> Bar;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct InnerType {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/inner_const.rs b/bindgen-tests/tests/expectations/tests/inner_const.rs
new file mode 100644
index 00000000..69a7c39a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inner_const.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub bar: ::std::os::raw::c_int,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo3BOOE"]
+    pub static mut Foo_BOO: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo8whateverE"]
+    pub static mut Foo_whatever: Foo;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/inner_template_self.rs b/bindgen-tests/tests/expectations/tests/inner_template_self.rs
new file mode 100644
index 00000000..13d9ac14
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inner_template_self.rs
@@ -0,0 +1,78 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct LinkedList {
+    pub next: *mut LinkedList,
+    pub prev: *mut LinkedList,
+}
+impl Default for LinkedList {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct InstantiateIt {
+    pub m_list: LinkedList,
+}
+#[test]
+fn bindgen_test_layout_InstantiateIt() {
+    const UNINIT: ::std::mem::MaybeUninit<InstantiateIt> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<InstantiateIt>(),
+        16usize,
+        concat!("Size of: ", stringify!(InstantiateIt))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InstantiateIt>(),
+        8usize,
+        concat!("Alignment of ", stringify!(InstantiateIt))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m_list) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(InstantiateIt),
+            "::",
+            stringify!(m_list)
+        )
+    );
+}
+impl Default for InstantiateIt {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_LinkedList_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<LinkedList>(),
+        16usize,
+        concat!("Size of template specialization: ", stringify!(LinkedList))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<LinkedList>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(LinkedList)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/int128_t.rs b/bindgen-tests/tests/expectations/tests/int128_t.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/int128_t.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs b/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs
new file mode 100644
index 00000000..c42e167f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1025-unknown-enum-repr.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct a {
+    pub _address: u8,
+}
+pub type a__bindgen_ty_1 = i32;
diff --git a/bindgen-tests/tests/expectations/tests/issue-1034.rs b/bindgen-tests/tests/expectations/tests/issue-1034.rs
new file mode 100644
index 00000000..32f4310e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1034.rs
@@ -0,0 +1,120 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct S2 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+}
+#[test]
+fn bindgen_test_layout_S2() {
+    assert_eq!(
+        ::std::mem::size_of::<S2>(),
+        2usize,
+        concat!("Size of: ", stringify!(S2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<S2>(),
+        1usize,
+        concat!("Alignment of ", stringify!(S2))
+    );
+}
+impl S2 {
+    #[inline]
+    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1040.rs b/bindgen-tests/tests/expectations/tests/issue-1040.rs
new file mode 100644
index 00000000..8503e8d2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1040.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const g_107: ::std::os::raw::c_ulonglong = 18446744073709551615;
diff --git a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
new file mode 100644
index 00000000..d91dd8fa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
@@ -0,0 +1,120 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct S1 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
+}
+#[test]
+fn bindgen_test_layout_S1() {
+    assert_eq!(
+        ::std::mem::size_of::<S1>(),
+        3usize,
+        concat!("Size of: ", stringify!(S1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<S1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(S1))
+    );
+}
+impl S1 {
+    #[inline]
+    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 3usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+            Default::default();
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs b/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs
new file mode 100644
index 00000000..c1465835
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1113-template-references.rs
@@ -0,0 +1,47 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Entry<K, V> {
+    pub _base: K,
+    pub mData: V,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
+}
+impl<K, V> Default for Entry<K, V> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct nsBaseHashtable {
+    pub _address: u8,
+}
+pub type nsBaseHashtable_EntryType<K, V> = Entry<K, V>;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsBaseHashtable_EntryPtr<K, V> {
+    pub mEntry: *mut nsBaseHashtable_EntryType<K, V>,
+    pub mExistingEntry: bool,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
+}
+impl<K, V> Default for nsBaseHashtable_EntryPtr<K, V> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs b/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs
new file mode 100644
index 00000000..e881c8c4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1118-using-forward-decl.rs
@@ -0,0 +1,139 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type c = nsTArray;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsTArray_base {
+    pub d: *mut ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_nsTArray_base() {
+    const UNINIT: ::std::mem::MaybeUninit<nsTArray_base> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsTArray_base>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsTArray_base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsTArray_base>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsTArray_base))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsTArray_base),
+            "::",
+            stringify!(d)
+        )
+    );
+}
+impl Default for nsTArray_base {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsTArray {
+    pub _base: nsTArray_base,
+}
+impl Default for nsTArray {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsIContent {
+    pub foo: nsTArray,
+}
+#[test]
+fn bindgen_test_layout_nsIContent() {
+    const UNINIT: ::std::mem::MaybeUninit<nsIContent> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsIContent>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsIContent))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsIContent>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsIContent))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsIContent),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
+impl Default for nsIContent {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z35Gecko_GetAnonymousContentForElementv"]
+    pub fn Gecko_GetAnonymousContentForElement() -> *mut nsTArray;
+}
+#[test]
+fn __bindgen_test_layout_nsTArray_open0_ptr_nsIContent_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<nsTArray>(),
+        8usize,
+        concat!("Size of template specialization: ", stringify!(nsTArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsTArray>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(nsTArray)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_nsTArray_open0_ptr_nsIContent_close0_instantiation_1()
+{
+    assert_eq!(
+        ::std::mem::size_of::<nsTArray>(),
+        8usize,
+        concat!("Size of template specialization: ", stringify!(nsTArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsTArray>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(nsTArray)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs b/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
new file mode 100644
index 00000000..fd023363
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
@@ -0,0 +1,36 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Foo__bindgen_vtable(::std::os::raw::c_void);
+#[repr(C)]
+#[derive(Debug)]
+pub struct Foo {
+    pub vtable_: *const Foo__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+impl Default for Foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
new file mode 100644
index 00000000..ed9f7c9b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
@@ -0,0 +1,83 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl MyDupeEnum {
+    pub const A: MyDupeEnum = MyDupeEnum(0);
+}
+impl MyDupeEnum {
+    pub const A_alias: MyDupeEnum = MyDupeEnum(0);
+}
+impl MyDupeEnum {
+    pub const B: MyDupeEnum = MyDupeEnum(1);
+}
+impl ::std::ops::BitOr<MyDupeEnum> for MyDupeEnum {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        MyDupeEnum(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for MyDupeEnum {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: MyDupeEnum) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<MyDupeEnum> for MyDupeEnum {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        MyDupeEnum(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for MyDupeEnum {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: MyDupeEnum) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct MyDupeEnum(pub ::std::os::raw::c_uint);
+impl MyOtherDupeEnum {
+    pub const C: MyOtherDupeEnum = MyOtherDupeEnum(0);
+}
+impl MyOtherDupeEnum {
+    pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum(0);
+}
+impl MyOtherDupeEnum {
+    pub const D: MyOtherDupeEnum = MyOtherDupeEnum(1);
+}
+impl ::std::ops::BitOr<MyOtherDupeEnum> for MyOtherDupeEnum {
+    type Output = Self;
+    #[inline]
+    fn bitor(self, other: Self) -> Self {
+        MyOtherDupeEnum(self.0 | other.0)
+    }
+}
+impl ::std::ops::BitOrAssign for MyOtherDupeEnum {
+    #[inline]
+    fn bitor_assign(&mut self, rhs: MyOtherDupeEnum) {
+        self.0 |= rhs.0;
+    }
+}
+impl ::std::ops::BitAnd<MyOtherDupeEnum> for MyOtherDupeEnum {
+    type Output = Self;
+    #[inline]
+    fn bitand(self, other: Self) -> Self {
+        MyOtherDupeEnum(self.0 & other.0)
+    }
+}
+impl ::std::ops::BitAndAssign for MyOtherDupeEnum {
+    #[inline]
+    fn bitand_assign(&mut self, rhs: MyOtherDupeEnum) {
+        self.0 &= rhs.0;
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct MyOtherDupeEnum(pub ::std::os::raw::c_uint);
diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
new file mode 100644
index 00000000..81c74abb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod MyDupeEnum {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const A: Type = 0;
+    pub const A_alias: Type = 0;
+    pub const B: Type = 1;
+}
+pub mod MyOtherDupeEnum {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const C: Type = 0;
+    pub const C_alias: Type = 0;
+    pub const D: Type = 1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
new file mode 100644
index 00000000..81c74abb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub mod MyDupeEnum {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const A: Type = 0;
+    pub const A_alias: Type = 0;
+    pub const B: Type = 1;
+}
+pub mod MyOtherDupeEnum {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const C: Type = 0;
+    pub const C_alias: Type = 0;
+    pub const D: Type = 1;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs
new file mode 100644
index 00000000..fda73a02
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1198-alias-rust-enum.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl MyDupeEnum {
+    pub const A_alias: MyDupeEnum = MyDupeEnum::A;
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MyDupeEnum {
+    A = 0,
+    B = 1,
+}
+impl MyOtherDupeEnum {
+    pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum::C;
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MyOtherDupeEnum {
+    C = 0,
+    D = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs b/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs
new file mode 100644
index 00000000..bb57c856
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1216-variadic-member.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn f(a: ::std::os::raw::c_int, ...);
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub f: ::std::option::Option<
+        unsafe extern "C" fn(
+            p: *mut ::std::os::raw::c_void,
+            obj: *mut ::std::os::raw::c_void,
+            a: ::std::os::raw::c_int,
+            ...
+        ),
+    >,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs b/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs
new file mode 100644
index 00000000..006900cb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1238-fwd-no-copy.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct MyType {
+    _unused: [u8; 0],
+}
+pub type MyTypeT = MyType;
diff --git a/bindgen-tests/tests/expectations/tests/issue-1281.rs b/bindgen-tests/tests/expectations/tests/issue-1281.rs
new file mode 100644
index 00000000..db99cbce
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1281.rs
@@ -0,0 +1,86 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct bar {
+    pub u: foo,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(foo))
+    );
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(bar), "::", stringify!(u))
+    );
+}
+pub type bar_t = bar;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct baz {
+    pub f: foo,
+}
+#[test]
+fn bindgen_test_layout_baz() {
+    const UNINIT: ::std::mem::MaybeUninit<baz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<baz>(),
+        4usize,
+        concat!("Size of: ", stringify!(baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<baz>(),
+        4usize,
+        concat!("Alignment of ", stringify!(baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(baz), "::", stringify!(f))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1285.rs b/bindgen-tests/tests/expectations/tests/issue-1285.rs
new file mode 100644
index 00000000..08aab0a9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1285.rs
@@ -0,0 +1,93 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1291.rs b/bindgen-tests/tests/expectations/tests/issue-1291.rs
new file mode 100644
index 00000000..25f4f105
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1291.rs
@@ -0,0 +1,183 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct RTCRay {
+    pub org: [f32; 3usize],
+    pub align0: f32,
+    pub dir: [f32; 3usize],
+    pub align1: f32,
+    pub tnear: f32,
+    pub tfar: f32,
+    pub time: f32,
+    pub mask: ::std::os::raw::c_uint,
+    pub Ng: [f32; 3usize],
+    pub align2: f32,
+    pub u: f32,
+    pub v: f32,
+    pub geomID: ::std::os::raw::c_uint,
+    pub primID: ::std::os::raw::c_uint,
+    pub instID: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_RTCRay() {
+    const UNINIT: ::std::mem::MaybeUninit<RTCRay> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<RTCRay>(),
+        96usize,
+        concat!("Size of: ", stringify!(RTCRay))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RTCRay>(),
+        16usize,
+        concat!("Alignment of ", stringify!(RTCRay))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).org) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(org)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).align0) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(align0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dir) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(dir)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).align1) as usize - ptr as usize },
+        28usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(align1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(tnear)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(tfar)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(time)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(mask)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ng) as usize - ptr as usize },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(Ng)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).align2) as usize - ptr as usize },
+        60usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(align2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        64usize,
+        concat!("Offset of field: ", stringify!(RTCRay), "::", stringify!(u))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
+        68usize,
+        concat!("Offset of field: ", stringify!(RTCRay), "::", stringify!(v))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(geomID)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
+        76usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(primID)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RTCRay),
+            "::",
+            stringify!(instID)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs b/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs
new file mode 100644
index 00000000..4deed060
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1350-attribute-overloadable.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z11my_functioni"]
+    pub fn my_function(a: ::std::os::raw::c_int);
+}
+extern "C" {
+    #[link_name = "\u{1}_Z11my_functionPKc"]
+    pub fn my_function1(a: *const ::std::os::raw::c_char);
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs b/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs
new file mode 100644
index 00000000..b767d5e4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1382-rust-primitive-types.rs
@@ -0,0 +1,139 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type i8_ = i8;
+pub type u8_ = u8;
+pub type i16_ = i16;
+pub type u16_ = u16;
+pub type i32_ = i32;
+pub type u32_ = u32;
+pub type i64_ = i64;
+pub type u64_ = u64;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub i8_: ::std::os::raw::c_int,
+    pub u8_: ::std::os::raw::c_int,
+    pub i16_: ::std::os::raw::c_int,
+    pub u16_: ::std::os::raw::c_int,
+    pub i32_: ::std::os::raw::c_int,
+    pub u32_: ::std::os::raw::c_int,
+    pub i64_: ::std::os::raw::c_int,
+    pub u64_: ::std::os::raw::c_int,
+    pub i128_: ::std::os::raw::c_int,
+    pub u128_: ::std::os::raw::c_int,
+    pub isize_: ::std::os::raw::c_int,
+    pub usize_: ::std::os::raw::c_int,
+    pub f32_: ::std::os::raw::c_int,
+    pub f64_: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        56usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i8_) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i8_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u8_) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u8_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i16_) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i16_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u16_) as usize - ptr as usize },
+        12usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u16_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
+        16usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i32_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
+        20usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u32_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize },
+        24usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i64_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u64_) as usize - ptr as usize },
+        28usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u64_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i128_) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(i128_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u128_) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(u128_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).isize_) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(isize_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).usize_) as usize - ptr as usize },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo),
+            "::",
+            stringify!(usize_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f32_) as usize - ptr as usize },
+        48usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f32_))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize },
+        52usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f64_))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1435.rs b/bindgen-tests/tests/expectations/tests/issue-1435.rs
new file mode 100644
index 00000000..79ed7b29
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1435.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod ns {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub const AB_A: root::ns::AB = 0;
+        pub const AB_B: root::ns::AB = 1;
+        pub type AB = ::std::os::raw::c_int;
+    }
+    pub use self::super::root::ns::AB;
+    extern "C" {
+        #[link_name = "\u{1}_ZL2kA"]
+        pub static kA: root::AB;
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1443.rs b/bindgen-tests/tests/expectations/tests/issue-1443.rs
new file mode 100644
index 00000000..48cae79f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1443.rs
@@ -0,0 +1,176 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub f: *const Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(m))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Baz {
+    pub f: *mut Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    const UNINIT: ::std::mem::MaybeUninit<Baz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        16usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(m))
+    );
+}
+impl Default for Baz {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Tar {
+    pub f: *const Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Tar() {
+    const UNINIT: ::std::mem::MaybeUninit<Tar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Tar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Tar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Tar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Tar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(m))
+    );
+}
+impl Default for Tar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Taz {
+    pub f: *mut Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Taz() {
+    const UNINIT: ::std::mem::MaybeUninit<Taz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Taz>(),
+        16usize,
+        concat!("Size of: ", stringify!(Taz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Taz>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Taz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(m))
+    );
+}
+impl Default for Taz {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1454.rs b/bindgen-tests/tests/expectations/tests/issue-1454.rs
new file mode 100644
index 00000000..8da43cb0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1454.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct extern_type;
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct local_type {
+    pub inner: extern_type,
+}
+#[test]
+fn bindgen_test_layout_local_type() {
+    const UNINIT: ::std::mem::MaybeUninit<local_type> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<local_type>(),
+        0usize,
+        concat!("Size of: ", stringify!(local_type))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<local_type>(),
+        1usize,
+        concat!("Alignment of ", stringify!(local_type))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).inner) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(local_type),
+            "::",
+            stringify!(inner)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1464.rs b/bindgen-tests/tests/expectations/tests/issue-1464.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1464.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs b/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs
new file mode 100644
index 00000000..b762659a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1488-enum-new-type.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const Foo_A: Foo = 0;
+pub const Foo_B: Foo = 1;
+pub type Foo = ::std::os::raw::c_uint;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct FooAlias(pub Foo);
+pub mod Bar {
+    pub type Type = ::std::os::raw::c_uint;
+    pub const C: Type = 0;
+    pub const D: Type = 1;
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct BarAlias(pub Bar::Type);
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Qux {
+    E = 0,
+    F = 1,
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct QuxAlias(pub Qux);
+pub const Baz_G: Baz = 0;
+pub const Baz_H: Baz = 1;
+pub type Baz = ::std::os::raw::c_uint;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct BazAlias(pub Baz);
+impl ::std::ops::Deref for BazAlias {
+    type Target = Baz;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl ::std::ops::DerefMut for BazAlias {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-options.rs b/bindgen-tests/tests/expectations/tests/issue-1488-options.rs
new file mode 100644
index 00000000..cf13b562
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1488-options.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type OSStatus = ::std::os::raw::c_int;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct SomePtr(pub *mut ::std::os::raw::c_void);
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct AnotherPtr(pub *mut ::std::os::raw::c_void);
+impl ::std::ops::Deref for AnotherPtr {
+    type Target = *mut ::std::os::raw::c_void;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl ::std::ops::DerefMut for AnotherPtr {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs b/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs
new file mode 100644
index 00000000..1af0c575
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1488-template-alias-new-type.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Wrapped<T>(pub T);
diff --git a/bindgen-tests/tests/expectations/tests/issue-1498.rs b/bindgen-tests/tests/expectations/tests/issue-1498.rs
new file mode 100644
index 00000000..eb5e2804
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1498.rs
@@ -0,0 +1,170 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct rte_memseg {
+    ///< Start physical address.
+    pub phys_addr: u64,
+    pub __bindgen_anon_1: rte_memseg__bindgen_ty_1,
+    ///< Length of the segment.
+    pub len: usize,
+    ///< The pagesize of underlying memory
+    pub hugepage_sz: u64,
+    ///< NUMA socket ID.
+    pub socket_id: i32,
+    ///< Number of channels.
+    pub nchannel: u32,
+    ///< Number of ranks.
+    pub nrank: u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_memseg__bindgen_ty_1 {
+    ///< Start virtual address.
+    pub addr: *mut ::std::os::raw::c_void,
+    ///< Makes sure addr is always 64 bits
+    pub addr_64: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_memseg__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_memseg__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_memseg__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_memseg__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_memseg__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_memseg__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg__bindgen_ty_1),
+            "::",
+            stringify!(addr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).addr_64) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg__bindgen_ty_1),
+            "::",
+            stringify!(addr_64)
+        )
+    );
+}
+impl Default for rte_memseg__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_memseg() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_memseg> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_memseg>(),
+        44usize,
+        concat!("Size of: ", stringify!(rte_memseg))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_memseg>(),
+        1usize,
+        concat!("Alignment of ", stringify!(rte_memseg))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).phys_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(phys_addr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).hugepage_sz) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(hugepage_sz)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).socket_id) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(socket_id)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nchannel) as usize - ptr as usize
+        },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(nchannel)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nrank) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_memseg),
+            "::",
+            stringify!(nrank)
+        )
+    );
+}
+impl Default for rte_memseg {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1514.rs b/bindgen-tests/tests/expectations/tests/issue-1514.rs
new file mode 100644
index 00000000..31939ca5
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1514.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Thing {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Thing_Inner<T> {
+    pub ptr: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Thing_Inner<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Thing_AnotherInner<T> {
+    pub _base: Thing_Inner<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Thing_AnotherInner<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1554.rs b/bindgen-tests/tests/expectations/tests/issue-1554.rs
new file mode 100644
index 00000000..7e7cddd6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1554.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+#![feature(non_exhaustive)]
+
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Planet {
+    earth = 0,
+    mars = 1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs b/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
new file mode 100644
index 00000000..eacb3411
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const a_b: a = 0;
+pub const a_c: a = 1;
+pub type a = ::std::os::raw::c_uint;
+pub type d = u32;
diff --git a/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs b/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/issue-1947.rs b/bindgen-tests/tests/expectations/tests/issue-1947.rs
new file mode 100644
index 00000000..e133ed85
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1947.rs
@@ -0,0 +1,349 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+pub type U8 = ::std::os::raw::c_uchar;
+pub type U16 = ::std::os::raw::c_ushort;
+#[repr(C)]
+#[repr(align(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct V56AMDY {
+    pub _bitfield_align_1: [u16; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub MADK: U8,
+    pub MABR: U8,
+    pub _bitfield_align_2: [u16; 0],
+    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 3usize]>,
+    pub _rB_: U8,
+}
+#[test]
+fn bindgen_test_layout_V56AMDY() {
+    const UNINIT: ::std::mem::MaybeUninit<V56AMDY> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<V56AMDY>(),
+        8usize,
+        concat!("Size of: ", stringify!(V56AMDY))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<V56AMDY>(),
+        2usize,
+        concat!("Alignment of ", stringify!(V56AMDY))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).MADK) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(V56AMDY),
+            "::",
+            stringify!(MADK)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).MABR) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(V56AMDY),
+            "::",
+            stringify!(MABR)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr)._rB_) as usize - ptr as usize },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(V56AMDY),
+            "::",
+            stringify!(_rB_)
+        )
+    );
+}
+impl V56AMDY {
+    #[inline]
+    pub fn MADZ(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MADZ(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 10u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MAI0(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MAI0(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(10usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MAI1(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MAI1(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MAI2(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MAI2(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(14usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        MADZ: U16,
+        MAI0: U16,
+        MAI1: U16,
+        MAI2: U16,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 10u8, {
+            let MADZ: u16 = unsafe { ::std::mem::transmute(MADZ) };
+            MADZ as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 2u8, {
+            let MAI0: u16 = unsafe { ::std::mem::transmute(MAI0) };
+            MAI0 as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 2u8, {
+            let MAI1: u16 = unsafe { ::std::mem::transmute(MAI1) };
+            MAI1 as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 2u8, {
+            let MAI2: u16 = unsafe { ::std::mem::transmute(MAI2) };
+            MAI2 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+    #[inline]
+    pub fn MATH(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(0usize, 10u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MATH(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_2.set(0usize, 10u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MATE(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(10usize, 4u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MATE(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_2.set(10usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MATW(&self) -> U16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(14usize, 2u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_MATW(&mut self, val: U16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_2.set(14usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MASW(&self) -> U8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(16usize, 4u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_MASW(&mut self, val: U8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(16usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MABW(&self) -> U8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(20usize, 3u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_MABW(&mut self, val: U8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(20usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn MAXN(&self) -> U8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(23usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_MAXN(&mut self, val: U8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(23usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_2(
+        MATH: U16,
+        MATE: U16,
+        MATW: U16,
+        MASW: U8,
+        MABW: U8,
+        MAXN: U8,
+    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 10u8, {
+            let MATH: u16 = unsafe { ::std::mem::transmute(MATH) };
+            MATH as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 4u8, {
+            let MATE: u16 = unsafe { ::std::mem::transmute(MATE) };
+            MATE as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 2u8, {
+            let MATW: u16 = unsafe { ::std::mem::transmute(MATW) };
+            MATW as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 4u8, {
+            let MASW: u8 = unsafe { ::std::mem::transmute(MASW) };
+            MASW as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 3u8, {
+            let MABW: u8 = unsafe { ::std::mem::transmute(MABW) };
+            MABW as u64
+        });
+        __bindgen_bitfield_unit.set(23usize, 1u8, {
+            let MAXN: u8 = unsafe { ::std::mem::transmute(MAXN) };
+            MAXN as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs b/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs
new file mode 100644
index 00000000..6375ea7e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1977-larger-arrays.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct S {
+    pub large_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_S() {
+    const UNINIT: ::std::mem::MaybeUninit<S> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<S>(),
+        33usize,
+        concat!("Size of: ", stringify!(S))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<S>(),
+        1usize,
+        concat!("Alignment of ", stringify!(S))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(S),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for S {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ST<T> {
+    pub large_array: [T; 33usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ST<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-1995.rs b/bindgen-tests/tests/expectations/tests/issue-1995.rs
new file mode 100644
index 00000000..890479b5
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-1995.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This is a constant that has a docstring
+///
+/// And expected to be found in generated bindings code too.
+pub const FOO: ::std::os::raw::c_int = 1;
+/// This is a constant that has a docstring
+///
+/// And expected to be found in generated bindings code too.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-2019.rs b/bindgen-tests/tests/expectations/tests/issue-2019.rs
new file mode 100644
index 00000000..294e9f0e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-2019.rs
@@ -0,0 +1,79 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub a: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        4usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(a))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1A4makeEv"]
+    pub fn make() -> A;
+}
+impl A {
+    #[inline]
+    pub unsafe fn make() -> A {
+        make()
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct B {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    const UNINIT: ::std::mem::MaybeUninit<B> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(B), "::", stringify!(b))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1B4makeEv"]
+    pub fn make1() -> B;
+}
+impl B {
+    #[inline]
+    pub unsafe fn make() -> B {
+        make1()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs b/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
new file mode 100644
index 00000000..75ec9e43
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct b {
+    pub _address: u8,
+}
+pub type b_td<a> = a;
+pub type b_ta<a> = a;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct b_foo {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-358.rs b/bindgen-tests/tests/expectations/tests/issue-358.rs
new file mode 100644
index 00000000..e9ee0f50
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-358.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct JS_PersistentRooted {
+    pub _base: a,
+}
+impl Default for JS_PersistentRooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct a {
+    pub b: *mut a,
+}
+impl Default for a {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-372.rs b/bindgen-tests/tests/expectations/tests/issue-372.rs
new file mode 100644
index 00000000..e87fb4d1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-372.rs
@@ -0,0 +1,144 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct i {
+        pub j: *mut root::i,
+        pub k: *mut root::i,
+        pub l: bool,
+    }
+    #[test]
+    fn bindgen_test_layout_i() {
+        const UNINIT: ::std::mem::MaybeUninit<i> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<i>(),
+            24usize,
+            concat!("Size of: ", stringify!(i))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<i>(),
+            8usize,
+            concat!("Alignment of ", stringify!(i))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).j) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(i), "::", stringify!(j))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize },
+            8usize,
+            concat!("Offset of field: ", stringify!(i), "::", stringify!(k))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).l) as usize - ptr as usize },
+            16usize,
+            concat!("Offset of field: ", stringify!(i), "::", stringify!(l))
+        );
+    }
+    impl Default for i {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct d {
+        pub m: root::i,
+    }
+    #[test]
+    fn bindgen_test_layout_d() {
+        const UNINIT: ::std::mem::MaybeUninit<d> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<d>(),
+            24usize,
+            concat!("Size of: ", stringify!(d))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<d>(),
+            8usize,
+            concat!("Alignment of ", stringify!(d))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(d), "::", stringify!(m))
+        );
+    }
+    impl Default for d {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+    pub enum n {
+        o = 0,
+        p = 1,
+        q = 2,
+        r = 3,
+        s = 4,
+        t = 5,
+        b = 6,
+        ae = 7,
+        e = 8,
+        ag = 9,
+        ah = 10,
+        ai = 11,
+    }
+    #[repr(C)]
+    pub struct F {
+        pub w: [u64; 33usize],
+    }
+    #[test]
+    fn bindgen_test_layout_F() {
+        const UNINIT: ::std::mem::MaybeUninit<F> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<F>(),
+            264usize,
+            concat!("Size of: ", stringify!(F))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<F>(),
+            8usize,
+            concat!("Alignment of ", stringify!(F))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(F), "::", stringify!(w))
+        );
+    }
+    impl Default for F {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-410.rs b/bindgen-tests/tests/expectations/tests/issue-410.rs
new file mode 100644
index 00000000..ad7463c2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-410.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod JS {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Value {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_Value() {
+            assert_eq!(
+                ::std::mem::size_of::<Value>(),
+                1usize,
+                concat!("Size of: ", stringify!(Value))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Value>(),
+                1usize,
+                concat!("Alignment of ", stringify!(Value))
+            );
+        }
+        extern "C" {
+            #[link_name = "\u{1}_ZN2JS5Value1aE10JSWhyMagic"]
+            pub fn Value_a(this: *mut root::JS::Value, arg1: root::JSWhyMagic);
+        }
+        impl Value {
+            #[inline]
+            pub unsafe fn a(&mut self, arg1: root::JSWhyMagic) {
+                Value_a(self, arg1)
+            }
+        }
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+    pub enum JSWhyMagic {
+        __bindgen_cannot_repr_c_on_empty_enum = 0,
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-446.rs b/bindgen-tests/tests/expectations/tests/issue-446.rs
new file mode 100644
index 00000000..db69f159
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-446.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct List {
+    pub next: *mut List,
+}
+impl Default for List {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct PersistentRooted {
+    pub root_list: List,
+}
+impl Default for PersistentRooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-447.rs b/bindgen-tests/tests/expectations/tests/issue-447.rs
new file mode 100644
index 00000000..949db73b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-447.rs
@@ -0,0 +1,76 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod mozilla {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod detail {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            #[repr(C)]
+            #[derive(Debug, Default, Copy, Clone)]
+            pub struct GuardObjectNotifier {
+                pub _address: u8,
+            }
+            #[test]
+            fn bindgen_test_layout_GuardObjectNotifier() {
+                assert_eq!(
+                    ::std::mem::size_of::<GuardObjectNotifier>(),
+                    1usize,
+                    concat!("Size of: ", stringify!(GuardObjectNotifier))
+                );
+                assert_eq!(
+                    ::std::mem::align_of::<GuardObjectNotifier>(),
+                    1usize,
+                    concat!("Alignment of ", stringify!(GuardObjectNotifier))
+                );
+            }
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct JSAutoCompartment {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_JSAutoCompartment() {
+        assert_eq!(
+            ::std::mem::size_of::<JSAutoCompartment>(),
+            1usize,
+            concat!("Size of: ", stringify!(JSAutoCompartment))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<JSAutoCompartment>(),
+            1usize,
+            concat!("Alignment of ", stringify!(JSAutoCompartment))
+        );
+    }
+    extern "C" {
+        #[link_name = "\u{1}_ZN17JSAutoCompartmentC1EN7mozilla6detail19GuardObjectNotifierE"]
+        pub fn JSAutoCompartment_JSAutoCompartment(
+            this: *mut root::JSAutoCompartment,
+            arg1: root::mozilla::detail::GuardObjectNotifier,
+        );
+    }
+    impl JSAutoCompartment {
+        #[inline]
+        pub unsafe fn new(
+            arg1: root::mozilla::detail::GuardObjectNotifier,
+        ) -> Self {
+            let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+            JSAutoCompartment_JSAutoCompartment(
+                __bindgen_tmp.as_mut_ptr(),
+                arg1,
+            );
+            __bindgen_tmp.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-493.rs b/bindgen-tests/tests/expectations/tests/issue-493.rs
new file mode 100644
index 00000000..61c7f792
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-493.rs
@@ -0,0 +1,176 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string {
+    pub _address: u8,
+}
+pub type basic_string_size_type = ::std::os::raw::c_ulonglong;
+pub type basic_string_value_type = ::std::os::raw::c_char;
+pub type basic_string_pointer = *mut basic_string_value_type;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___long {
+    pub __cap_: basic_string_size_type,
+    pub __size_: basic_string_size_type,
+    pub __data_: basic_string_pointer,
+}
+impl Default for basic_string___long {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub const basic_string___min_cap: basic_string__bindgen_ty_1 =
+    basic_string__bindgen_ty_1::__min_cap;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum basic_string__bindgen_ty_1 {
+    __min_cap = 0,
+}
+#[repr(C)]
+pub struct basic_string___short {
+    pub __bindgen_anon_1: basic_string___short__bindgen_ty_1,
+    pub __data_: *mut basic_string_value_type,
+}
+#[repr(C)]
+pub union basic_string___short__bindgen_ty_1 {
+    pub __size_: ::std::os::raw::c_uchar,
+    pub __lx: basic_string_value_type,
+}
+impl Default for basic_string___short__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for basic_string___short {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(1))]
+pub struct basic_string___ulx {
+    pub __lx: __BindgenUnionField<basic_string___long>,
+    pub __lxx: __BindgenUnionField<basic_string___short>,
+    pub bindgen_union_field: [u8; 0usize],
+}
+impl Default for basic_string___ulx {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub const basic_string___n_words: basic_string__bindgen_ty_2 =
+    basic_string__bindgen_ty_2::__n_words;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum basic_string__bindgen_ty_2 {
+    __n_words = 0,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___raw {
+    pub __words: *mut basic_string_size_type,
+}
+impl Default for basic_string___raw {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct basic_string___rep {
+    pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(1))]
+pub struct basic_string___rep__bindgen_ty_1 {
+    pub __l: __BindgenUnionField<basic_string___long>,
+    pub __s: __BindgenUnionField<basic_string___short>,
+    pub __r: __BindgenUnionField<basic_string___raw>,
+    pub bindgen_union_field: [u8; 0usize],
+}
+impl Default for basic_string___rep__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for basic_string___rep {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-493_1_0.rs b/bindgen-tests/tests/expectations/tests/issue-493_1_0.rs
new file mode 100644
index 00000000..1a0131c3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-493_1_0.rs
@@ -0,0 +1,144 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string {
+    pub _address: u8,
+}
+pub type basic_string_size_type = ::std::os::raw::c_ulonglong;
+pub type basic_string_value_type = ::std::os::raw::c_char;
+pub type basic_string_pointer = *mut basic_string_value_type;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___long {
+    pub __cap_: basic_string_size_type,
+    pub __size_: basic_string_size_type,
+    pub __data_: basic_string_pointer,
+}
+impl Default for basic_string___long {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+pub const basic_string___min_cap: basic_string__bindgen_ty_1 =
+    basic_string__bindgen_ty_1::__min_cap;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum basic_string__bindgen_ty_1 {
+    __min_cap = 0,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___short {
+    pub __bindgen_anon_1: basic_string___short__bindgen_ty_1,
+    pub __data_: *mut basic_string_value_type,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___short__bindgen_ty_1 {
+    pub __size_: __BindgenUnionField<::std::os::raw::c_uchar>,
+    pub __lx: __BindgenUnionField<basic_string_value_type>,
+    pub bindgen_union_field: u8,
+}
+impl Default for basic_string___short {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___ulx {
+    pub __lx: __BindgenUnionField<basic_string___long>,
+    pub __lxx: __BindgenUnionField<basic_string___short>,
+    pub bindgen_union_field: [u8; 0usize],
+}
+pub const basic_string___n_words: basic_string__bindgen_ty_2 =
+    basic_string__bindgen_ty_2::__n_words;
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum basic_string__bindgen_ty_2 {
+    __n_words = 0,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___raw {
+    pub __words: *mut basic_string_size_type,
+}
+impl Default for basic_string___raw {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___rep {
+    pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct basic_string___rep__bindgen_ty_1 {
+    pub __l: __BindgenUnionField<basic_string___long>,
+    pub __s: __BindgenUnionField<basic_string___short>,
+    pub __r: __BindgenUnionField<basic_string___raw>,
+    pub bindgen_union_field: [u8; 0usize],
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-511.rs b/bindgen-tests/tests/expectations/tests/issue-511.rs
new file mode 100644
index 00000000..b7705ef2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-511.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub static mut a: *mut ::std::os::raw::c_char;
+}
+extern "C" {
+    pub static mut b: *const ::std::os::raw::c_char;
+}
+extern "C" {
+    pub static c: *mut ::std::os::raw::c_char;
+}
+extern "C" {
+    pub static d: *const ::std::os::raw::c_char;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs b/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs
new file mode 100644
index 00000000..b1e42ca7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-537-repr-packed-n.rs
@@ -0,0 +1,161 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+
+/// This should not be opaque; we can see the attributes and can pack the
+/// struct.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AlignedToOne {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AlignedToOne() {
+    const UNINIT: ::std::mem::MaybeUninit<AlignedToOne> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AlignedToOne>(),
+        4usize,
+        concat!("Size of: ", stringify!(AlignedToOne))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AlignedToOne>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AlignedToOne))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AlignedToOne),
+            "::",
+            stringify!(i)
+        )
+    );
+}
+/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
+#[repr(C, packed(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AlignedToTwo {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AlignedToTwo() {
+    const UNINIT: ::std::mem::MaybeUninit<AlignedToTwo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AlignedToTwo>(),
+        4usize,
+        concat!("Size of: ", stringify!(AlignedToTwo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AlignedToTwo>(),
+        2usize,
+        concat!("Alignment of ", stringify!(AlignedToTwo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AlignedToTwo),
+            "::",
+            stringify!(i)
+        )
+    );
+}
+/// This should not be opaque because although `libclang` doesn't give us the
+/// `#pragma pack(1)`, we can detect that alignment is 1 and add
+/// `#[repr(packed)]` to the struct ourselves.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PackedToOne {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_PackedToOne() {
+    const UNINIT: ::std::mem::MaybeUninit<PackedToOne> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PackedToOne>(),
+        8usize,
+        concat!("Size of: ", stringify!(PackedToOne))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PackedToOne>(),
+        1usize,
+        concat!("Alignment of ", stringify!(PackedToOne))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToOne),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToOne),
+            "::",
+            stringify!(y)
+        )
+    );
+}
+/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
+#[repr(C, packed(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PackedToTwo {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_PackedToTwo() {
+    const UNINIT: ::std::mem::MaybeUninit<PackedToTwo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PackedToTwo>(),
+        8usize,
+        concat!("Size of: ", stringify!(PackedToTwo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PackedToTwo>(),
+        2usize,
+        concat!("Alignment of ", stringify!(PackedToTwo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToTwo),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToTwo),
+            "::",
+            stringify!(y)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-537.rs b/bindgen-tests/tests/expectations/tests/issue-537.rs
new file mode 100644
index 00000000..e2be9d63
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-537.rs
@@ -0,0 +1,163 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This should not be opaque; we can see the attributes and can pack the
+/// struct.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AlignedToOne {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AlignedToOne() {
+    const UNINIT: ::std::mem::MaybeUninit<AlignedToOne> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AlignedToOne>(),
+        4usize,
+        concat!("Size of: ", stringify!(AlignedToOne))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AlignedToOne>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AlignedToOne))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AlignedToOne),
+            "::",
+            stringify!(i)
+        )
+    );
+}
+/// This should be opaque because although we can see the attributes, Rust before
+/// 1.33 doesn't have `#[repr(packed(N))]`.
+#[repr(C, packed(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AlignedToTwo {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_AlignedToTwo() {
+    const UNINIT: ::std::mem::MaybeUninit<AlignedToTwo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AlignedToTwo>(),
+        4usize,
+        concat!("Size of: ", stringify!(AlignedToTwo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AlignedToTwo>(),
+        2usize,
+        concat!("Alignment of ", stringify!(AlignedToTwo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AlignedToTwo),
+            "::",
+            stringify!(i)
+        )
+    );
+}
+/// This should not be opaque because although `libclang` doesn't give us the
+/// `#pragma pack(1)`, we can detect that alignment is 1 and add
+/// `#[repr(packed)]` to the struct ourselves.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PackedToOne {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_PackedToOne() {
+    const UNINIT: ::std::mem::MaybeUninit<PackedToOne> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PackedToOne>(),
+        8usize,
+        concat!("Size of: ", stringify!(PackedToOne))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PackedToOne>(),
+        1usize,
+        concat!("Alignment of ", stringify!(PackedToOne))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToOne),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToOne),
+            "::",
+            stringify!(y)
+        )
+    );
+}
+/// In this case, even if we can detect the weird alignment triggered by
+/// `#pragma pack(2)`, we can't do anything about it because Rust before 1.33
+/// doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque.
+#[repr(C, packed(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PackedToTwo {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_PackedToTwo() {
+    const UNINIT: ::std::mem::MaybeUninit<PackedToTwo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PackedToTwo>(),
+        8usize,
+        concat!("Size of: ", stringify!(PackedToTwo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PackedToTwo>(),
+        2usize,
+        concat!("Alignment of ", stringify!(PackedToTwo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToTwo),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PackedToTwo),
+            "::",
+            stringify!(y)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs
new file mode 100644
index 00000000..6165419d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce-2.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Foo {
+    pub member: Foo_SecondAlias,
+}
+pub type Foo_FirstAlias = [u8; 0usize];
+pub type Foo_SecondAlias = [u8; 0usize];
+impl Default for Foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs
new file mode 100644
index 00000000..1516c0a9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-544-stylo-creduce.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct a {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs b/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
new file mode 100644
index 00000000..997a7311
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
@@ -0,0 +1,73 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const ENUM_VARIANT_1: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_1;
+pub const ENUM_VARIANT_2: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_2;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    ENUM_VARIANT_1 = 0,
+    ENUM_VARIANT_2 = 1,
+}
+pub type JS_Alias = u8;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct JS_Base {
+    pub f: JS_Alias,
+}
+impl Default for JS_Base {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct JS_AutoIdVector {
+    pub _base: JS_Base,
+}
+#[test]
+fn bindgen_test_layout_JS_AutoIdVector() {
+    assert_eq!(
+        ::std::mem::size_of::<JS_AutoIdVector>(),
+        1usize,
+        concat!("Size of: ", stringify!(JS_AutoIdVector))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<JS_AutoIdVector>(),
+        1usize,
+        concat!("Alignment of ", stringify!(JS_AutoIdVector))
+    );
+}
+impl Default for JS_AutoIdVector {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_JS_Base_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<JS_Base>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(JS_Base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<JS_Base>(),
+        1usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(JS_Base)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs b/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs
new file mode 100644
index 00000000..fbff1362
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-573-layout-test-failures.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Outer {
+    pub i: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AutoIdVector {
+    pub ar: Outer,
+}
+#[test]
+fn bindgen_test_layout_AutoIdVector() {
+    const UNINIT: ::std::mem::MaybeUninit<AutoIdVector> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<AutoIdVector>(),
+        1usize,
+        concat!("Size of: ", stringify!(AutoIdVector))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AutoIdVector>(),
+        1usize,
+        concat!("Alignment of ", stringify!(AutoIdVector))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(AutoIdVector),
+            "::",
+            stringify!(ar)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_Outer_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Outer>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(Outer))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Outer>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(Outer))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs b/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
new file mode 100644
index 00000000..22aa9d16
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct a {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct _bindgen_ty_1 {
+    pub ar: a,
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<_bindgen_ty_1>(),
+        1usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(ar)
+        )
+    );
+}
+extern "C" {
+    pub static mut AutoIdVector: _bindgen_ty_1;
+}
+#[test]
+fn __bindgen_test_layout_a_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(a))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs b/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
new file mode 100644
index 00000000..3765315c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
@@ -0,0 +1,124 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type RefPtr<T> = T;
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _address: u8,
+}
+pub type A_a = b;
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
+#[repr(C)]
+pub struct e<c> {
+    pub d: RefPtr<c>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<c>>,
+}
+impl<c> Default for e<c> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct f {
+    pub _address: u8,
+}
+#[repr(C)]
+pub struct g {
+    pub h: f,
+}
+#[test]
+fn bindgen_test_layout_g() {
+    const UNINIT: ::std::mem::MaybeUninit<g> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<g>(),
+        1usize,
+        concat!("Size of: ", stringify!(g))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<g>(),
+        1usize,
+        concat!("Alignment of ", stringify!(g))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(g), "::", stringify!(h))
+    );
+}
+impl Default for g {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct b {
+    pub _base: g,
+}
+#[test]
+fn bindgen_test_layout_b() {
+    assert_eq!(
+        ::std::mem::size_of::<b>(),
+        1usize,
+        concat!("Size of: ", stringify!(b))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<b>(),
+        1usize,
+        concat!("Alignment of ", stringify!(b))
+    );
+}
+impl Default for b {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z25Servo_Element_GetSnapshotv"]
+    pub fn Servo_Element_GetSnapshot() -> A;
+}
+#[test]
+fn __bindgen_test_layout_f_open0_e_open1_int_close1_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<f>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(f))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<f>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(f))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
new file mode 100644
index 00000000..ba886f36
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RefPtr<T> {
+    pub use_of_t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for RefPtr<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesRefPtrWithAliasedTypeParam<U> {
+    pub member: RefPtr<UsesRefPtrWithAliasedTypeParam_V<U>>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+pub type UsesRefPtrWithAliasedTypeParam_V<U> = U;
+impl<U> Default for UsesRefPtrWithAliasedTypeParam<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs b/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs
new file mode 100644
index 00000000..bac8a04c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-639-typedef-anon-field.rs
@@ -0,0 +1,113 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub bar: Foo_Bar,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo_Bar {
+    pub abc: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Foo_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo_Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo_Bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo_Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo_Bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo_Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).abc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Foo_Bar),
+            "::",
+            stringify!(abc)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Baz {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Baz_Bar {
+    pub abc: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Baz_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Baz_Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Baz_Bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(Baz_Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz_Bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Baz_Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).abc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Baz_Bar),
+            "::",
+            stringify!(abc)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        1usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs b/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs
new file mode 100644
index 00000000..b69aa16e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-643-inner-struct.rs
@@ -0,0 +1,138 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct rte_ring {
+    pub memzone: *mut rte_memzone,
+    pub prod: rte_ring_prod,
+    pub cons: rte_ring_cons,
+    pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_ring_prod {
+    pub watermark: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_prod() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ring_prod> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring_prod>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ring_prod))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring_prod>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ring_prod))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).watermark) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring_prod),
+            "::",
+            stringify!(watermark)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_ring_cons {
+    pub sc_dequeue: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_cons() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ring_cons> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring_cons>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ring_cons))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring_cons>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ring_cons))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sc_dequeue) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring_cons),
+            "::",
+            stringify!(sc_dequeue)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_ring() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_ring))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_ring))
+    );
+}
+impl Default for rte_ring {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_memzone {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
new file mode 100644
index 00000000..75d6581e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[derive(Clone, Copy, Debug)]
+pub struct RefPtr<T>(T);
+
+#[repr(C)]
+pub struct HasRefPtr<T> {
+    pub refptr_member: RefPtr<HasRefPtr_TypedefOfT<T>>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+pub type HasRefPtr_TypedefOfT<T> = T;
+impl<T> Default for HasRefPtr<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs b/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs
new file mode 100644
index 00000000..13cdf0c9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-648-derive-debug-with-padding.rs
@@ -0,0 +1,116 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// We emit a `[u8; 63usize]` padding field for this struct, which cannot derive
+/// Debug/Hash because 63 is over the hard coded limit.
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct NoDebug {
+    pub c: ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_NoDebug() {
+    const UNINIT: ::std::mem::MaybeUninit<NoDebug> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoDebug>(),
+        64usize,
+        concat!("Size of: ", stringify!(NoDebug))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoDebug>(),
+        64usize,
+        concat!("Alignment of ", stringify!(NoDebug))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NoDebug),
+            "::",
+            stringify!(c)
+        )
+    );
+}
+impl Default for NoDebug {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for NoDebug {
+    fn eq(&self, other: &NoDebug) -> bool {
+        self.c == other.c
+    }
+}
+/// This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive
+/// Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because
+/// we determine Debug derive-ability before we compute padding, which happens at
+/// codegen.
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct ShouldDeriveDebugButDoesNot {
+    pub c: [::std::os::raw::c_char; 32usize],
+    pub d: ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_ShouldDeriveDebugButDoesNot() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldDeriveDebugButDoesNot> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldDeriveDebugButDoesNot>(),
+        64usize,
+        concat!("Size of: ", stringify!(ShouldDeriveDebugButDoesNot))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldDeriveDebugButDoesNot>(),
+        64usize,
+        concat!("Alignment of ", stringify!(ShouldDeriveDebugButDoesNot))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldDeriveDebugButDoesNot),
+            "::",
+            stringify!(c)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldDeriveDebugButDoesNot),
+            "::",
+            stringify!(d)
+        )
+    );
+}
+impl Default for ShouldDeriveDebugButDoesNot {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for ShouldDeriveDebugButDoesNot {
+    fn eq(&self, other: &ShouldDeriveDebugButDoesNot) -> bool {
+        self.c == other.c && self.d == other.d
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs b/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs
new file mode 100644
index 00000000..65d3a516
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-654-struct-fn-collision.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    _unused: [u8; 0],
+}
+extern "C" {
+    pub fn foo() -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs b/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
new file mode 100644
index 00000000..5636a977
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
@@ -0,0 +1,52 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RefPtr<T> {
+    pub a: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for RefPtr<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsMainThreadPtrHolder<T> {
+    pub a: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for nsMainThreadPtrHolder<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsMainThreadPtrHandle<T> {
+    pub mPtr: RefPtr<nsMainThreadPtrHolder<T>>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for nsMainThreadPtrHandle<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs b/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs
new file mode 100644
index 00000000..e8d14bfe
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-662-part-2.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[derive(Clone, Copy, Debug)]
+pub struct RefPtr<T>(T);
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsMainThreadPtrHolder<T> {
+    pub a: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for nsMainThreadPtrHolder<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct nsMainThreadPtrHandle<U> {
+    pub mPtr: RefPtr<nsMainThreadPtrHolder<U>>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<U> Default for nsMainThreadPtrHandle<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-674-1.rs b/bindgen-tests/tests/expectations/tests/issue-674-1.rs
new file mode 100644
index 00000000..b37d7a27
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-674-1.rs
@@ -0,0 +1,53 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod mozilla {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Maybe {
+            pub _address: u8,
+        }
+        pub type Maybe_ValueType<T> = T;
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct CapturingContentInfo {
+        pub a: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_CapturingContentInfo() {
+        const UNINIT: ::std::mem::MaybeUninit<CapturingContentInfo> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<CapturingContentInfo>(),
+            1usize,
+            concat!("Size of: ", stringify!(CapturingContentInfo))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<CapturingContentInfo>(),
+            1usize,
+            concat!("Alignment of ", stringify!(CapturingContentInfo))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(CapturingContentInfo),
+                "::",
+                stringify!(a)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-674-2.rs b/bindgen-tests/tests/expectations/tests/issue-674-2.rs
new file mode 100644
index 00000000..12b2aa20
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-674-2.rs
@@ -0,0 +1,98 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod JS {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Rooted {
+            pub _address: u8,
+        }
+        pub type Rooted_ElementType<T> = T;
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct c {
+        pub b: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_c() {
+        const UNINIT: ::std::mem::MaybeUninit<c> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<c>(),
+            1usize,
+            concat!("Size of: ", stringify!(c))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<c>(),
+            1usize,
+            concat!("Alignment of ", stringify!(c))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(c), "::", stringify!(b))
+        );
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct B {
+        pub a: root::c,
+    }
+    #[test]
+    fn bindgen_test_layout_B() {
+        const UNINIT: ::std::mem::MaybeUninit<B> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<B>(),
+            1usize,
+            concat!("Size of: ", stringify!(B))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<B>(),
+            1usize,
+            concat!("Alignment of ", stringify!(B))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(B), "::", stringify!(a))
+        );
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct StaticRefPtr {
+        pub _address: u8,
+    }
+    #[test]
+    fn __bindgen_test_layout_StaticRefPtr_open0_B_close0_instantiation() {
+        assert_eq!(
+            ::std::mem::size_of::<root::StaticRefPtr>(),
+            1usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::StaticRefPtr)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::StaticRefPtr>(),
+            1usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::StaticRefPtr)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-674-3.rs b/bindgen-tests/tests/expectations/tests/issue-674-3.rs
new file mode 100644
index 00000000..e7af6b8d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-674-3.rs
@@ -0,0 +1,75 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct nsRefPtrHashtable {
+        pub _address: u8,
+    }
+    pub type nsRefPtrHashtable_UserDataType<PtrType> = *mut PtrType;
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct a {
+        pub b: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_a() {
+        const UNINIT: ::std::mem::MaybeUninit<a> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<a>(),
+            1usize,
+            concat!("Size of: ", stringify!(a))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<a>(),
+            1usize,
+            concat!("Alignment of ", stringify!(a))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+            0usize,
+            concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
+        );
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct nsCSSValue {
+        pub c: root::a,
+    }
+    #[test]
+    fn bindgen_test_layout_nsCSSValue() {
+        const UNINIT: ::std::mem::MaybeUninit<nsCSSValue> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<nsCSSValue>(),
+            1usize,
+            concat!("Size of: ", stringify!(nsCSSValue))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<nsCSSValue>(),
+            1usize,
+            concat!("Alignment of ", stringify!(nsCSSValue))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(nsCSSValue),
+                "::",
+                stringify!(c)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs b/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs
new file mode 100644
index 00000000..800f0dc8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-677-nested-ns-specifier.rs
@@ -0,0 +1,21 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod bar {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            pub type bar = ::std::os::raw::c_int;
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs b/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs
new file mode 100644
index 00000000..e71b2aae
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-691-template-parameter-virtual.rs
@@ -0,0 +1,81 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct VirtualMethods__bindgen_vtable {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct VirtualMethods {
+    pub vtable_: *const VirtualMethods__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_VirtualMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<VirtualMethods>(),
+        8usize,
+        concat!("Size of: ", stringify!(VirtualMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<VirtualMethods>(),
+        8usize,
+        concat!("Alignment of ", stringify!(VirtualMethods))
+    );
+}
+impl Default for VirtualMethods {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Set {
+    pub bar: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ServoElementSnapshotTable {
+    pub _base: Set,
+}
+#[test]
+fn bindgen_test_layout_ServoElementSnapshotTable() {
+    assert_eq!(
+        ::std::mem::size_of::<ServoElementSnapshotTable>(),
+        4usize,
+        concat!("Size of: ", stringify!(ServoElementSnapshotTable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ServoElementSnapshotTable>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ServoElementSnapshotTable))
+    );
+}
+impl Default for ServoElementSnapshotTable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_Set_open0_VirtualMethods_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Set>(),
+        4usize,
+        concat!("Size of template specialization: ", stringify!(Set))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Set>(),
+        4usize,
+        concat!("Alignment of template specialization: ", stringify!(Set))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs b/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs
new file mode 100644
index 00000000..1d598241
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-710-must-use-type.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+#[must_use]
+pub struct A {
+    _unused: [u8; 0],
+}
+/// <div rustbindgen mustusetype></div>
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+#[must_use]
+pub struct B {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct C {
+    _unused: [u8; 0],
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
new file mode 100644
index 00000000..1a633844
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
@@ -0,0 +1,195 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(target_os = "windows"))]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 32usize]>,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        32usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+impl Foo {
+    #[inline]
+    pub fn m_bitfield(&self) -> ::std::os::raw::c_ulong {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 64u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_m_bitfield(&mut self, val: ::std::os::raw::c_ulong) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 64u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn m_bar(&self) -> ::std::os::raw::c_ulong {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(64usize, 64u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_m_bar(&mut self, val: ::std::os::raw::c_ulong) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(64usize, 64u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn foo(&self) -> ::std::os::raw::c_ulong {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(128usize, 1u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_foo(&mut self, val: ::std::os::raw::c_ulong) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(128usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bar(&self) -> ::std::os::raw::c_ulong {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(192usize, 64u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_bar(&mut self, val: ::std::os::raw::c_ulong) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(192usize, 64u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        m_bitfield: ::std::os::raw::c_ulong,
+        m_bar: ::std::os::raw::c_ulong,
+        foo: ::std::os::raw::c_ulong,
+        bar: ::std::os::raw::c_ulong,
+    ) -> __BindgenBitfieldUnit<[u8; 32usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 32usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 64u8, {
+            let m_bitfield: u64 = unsafe { ::std::mem::transmute(m_bitfield) };
+            m_bitfield as u64
+        });
+        __bindgen_bitfield_unit.set(64usize, 64u8, {
+            let m_bar: u64 = unsafe { ::std::mem::transmute(m_bar) };
+            m_bar as u64
+        });
+        __bindgen_bitfield_unit.set(128usize, 1u8, {
+            let foo: u64 = unsafe { ::std::mem::transmute(foo) };
+            foo as u64
+        });
+        __bindgen_bitfield_unit.set(192usize, 64u8, {
+            let bar: u64 = unsafe { ::std::mem::transmute(bar) };
+            bar as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs b/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs
new file mode 100644
index 00000000..b3192b72
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-801-opaque-sloppiness.rs
@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct A {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[repr(align(1))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct B {
+    pub _bindgen_opaque_blob: u8,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        1usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        1usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1B1aE"]
+    pub static mut B_a: A;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct C {
+    pub b: B,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        1usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        1usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(b))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs b/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
new file mode 100644
index 00000000..f8869528
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
@@ -0,0 +1,137 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Pupper {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Pupper() {
+    assert_eq!(
+        ::std::mem::size_of::<Pupper>(),
+        1usize,
+        concat!("Size of: ", stringify!(Pupper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Pupper>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Pupper))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Doggo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Doggo() {
+    assert_eq!(
+        ::std::mem::size_of::<Doggo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Doggo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Doggo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Doggo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct SuchWow {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_SuchWow() {
+    assert_eq!(
+        ::std::mem::size_of::<SuchWow>(),
+        1usize,
+        concat!("Size of: ", stringify!(SuchWow))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<SuchWow>(),
+        1usize,
+        concat!("Alignment of ", stringify!(SuchWow))
+    );
+}
+#[repr(C)]
+#[repr(align(1))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Opaque {
+    pub _bindgen_opaque_blob: u8,
+}
+#[test]
+fn bindgen_test_layout_Opaque() {
+    assert_eq!(
+        ::std::mem::size_of::<Opaque>(),
+        1usize,
+        concat!("Size of: ", stringify!(Opaque))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Opaque>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Opaque))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN6Opaque17eleven_out_of_tenEv"]
+    pub fn Opaque_eleven_out_of_ten(this: *mut Opaque) -> SuchWow;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN6OpaqueC1E6Pupper"]
+    pub fn Opaque_Opaque(this: *mut Opaque, pup: Pupper);
+}
+impl Opaque {
+    #[inline]
+    pub unsafe fn eleven_out_of_ten(&mut self) -> SuchWow {
+        Opaque_eleven_out_of_ten(self)
+    }
+    #[inline]
+    pub unsafe fn new(pup: Pupper) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        Opaque_Opaque(__bindgen_tmp.as_mut_ptr(), pup);
+        __bindgen_tmp.assume_init()
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN6Opaque11MAJESTIC_AFE"]
+    pub static mut Opaque_MAJESTIC_AF: Doggo;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Allowlisted {
+    pub some_member: Opaque,
+}
+#[test]
+fn bindgen_test_layout_Allowlisted() {
+    const UNINIT: ::std::mem::MaybeUninit<Allowlisted> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Allowlisted>(),
+        1usize,
+        concat!("Size of: ", stringify!(Allowlisted))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Allowlisted>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Allowlisted))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).some_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Allowlisted),
+            "::",
+            stringify!(some_member)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-816.rs b/bindgen-tests/tests/expectations/tests/issue-816.rs
new file mode 100644
index 00000000..c7f94106
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-816.rs
@@ -0,0 +1,860 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct capabilities {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
+}
+#[test]
+fn bindgen_test_layout_capabilities() {
+    assert_eq!(
+        ::std::mem::size_of::<capabilities>(),
+        16usize,
+        concat!("Size of: ", stringify!(capabilities))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<capabilities>(),
+        4usize,
+        concat!("Alignment of ", stringify!(capabilities))
+    );
+}
+impl capabilities {
+    #[inline]
+    pub fn bit_1(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_1(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_2(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_2(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_3(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_3(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_4(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_4(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_5(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_5(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_6(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_6(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_7(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_7(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_8(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_8(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_9(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_9(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_10(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_10(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_11(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_11(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(10usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_12(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_12(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(11usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_13(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_13(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_14(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_14(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(13usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_15(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_15(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(14usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_16(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_16(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(15usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_17(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_17(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_18(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_18(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(17usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_19(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_19(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(18usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_20(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_20(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(19usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_21(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_21(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_22(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_22(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(21usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_23(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_23(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(22usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_24(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_24(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(23usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_25(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_25(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_26(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_26(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(25usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_27(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_27(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(26usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_28(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_28(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(27usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_29(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_29(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(28usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_30(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_30(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(29usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_31(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_31(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(30usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_32(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_32(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_33(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_33(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(32usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_34(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_34(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(33usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_35(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_35(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(34usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_36(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_36(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(35usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_37(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_37(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(36usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_38(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_38(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(37usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_39(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_39(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(38usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_40(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_40(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(39usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bit_41(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bit_41(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(40usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        bit_1: ::std::os::raw::c_uint,
+        bit_2: ::std::os::raw::c_uint,
+        bit_3: ::std::os::raw::c_uint,
+        bit_4: ::std::os::raw::c_uint,
+        bit_5: ::std::os::raw::c_uint,
+        bit_6: ::std::os::raw::c_uint,
+        bit_7: ::std::os::raw::c_uint,
+        bit_8: ::std::os::raw::c_uint,
+        bit_9: ::std::os::raw::c_uint,
+        bit_10: ::std::os::raw::c_uint,
+        bit_11: ::std::os::raw::c_uint,
+        bit_12: ::std::os::raw::c_uint,
+        bit_13: ::std::os::raw::c_uint,
+        bit_14: ::std::os::raw::c_uint,
+        bit_15: ::std::os::raw::c_uint,
+        bit_16: ::std::os::raw::c_uint,
+        bit_17: ::std::os::raw::c_uint,
+        bit_18: ::std::os::raw::c_uint,
+        bit_19: ::std::os::raw::c_uint,
+        bit_20: ::std::os::raw::c_uint,
+        bit_21: ::std::os::raw::c_uint,
+        bit_22: ::std::os::raw::c_uint,
+        bit_23: ::std::os::raw::c_uint,
+        bit_24: ::std::os::raw::c_uint,
+        bit_25: ::std::os::raw::c_uint,
+        bit_26: ::std::os::raw::c_uint,
+        bit_27: ::std::os::raw::c_uint,
+        bit_28: ::std::os::raw::c_uint,
+        bit_29: ::std::os::raw::c_uint,
+        bit_30: ::std::os::raw::c_uint,
+        bit_31: ::std::os::raw::c_uint,
+        bit_32: ::std::os::raw::c_uint,
+        bit_33: ::std::os::raw::c_uint,
+        bit_34: ::std::os::raw::c_uint,
+        bit_35: ::std::os::raw::c_uint,
+        bit_36: ::std::os::raw::c_uint,
+        bit_37: ::std::os::raw::c_uint,
+        bit_38: ::std::os::raw::c_uint,
+        bit_39: ::std::os::raw::c_uint,
+        bit_40: ::std::os::raw::c_uint,
+        bit_41: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let bit_1: u32 = unsafe { ::std::mem::transmute(bit_1) };
+            bit_1 as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let bit_2: u32 = unsafe { ::std::mem::transmute(bit_2) };
+            bit_2 as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let bit_3: u32 = unsafe { ::std::mem::transmute(bit_3) };
+            bit_3 as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let bit_4: u32 = unsafe { ::std::mem::transmute(bit_4) };
+            bit_4 as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let bit_5: u32 = unsafe { ::std::mem::transmute(bit_5) };
+            bit_5 as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let bit_6: u32 = unsafe { ::std::mem::transmute(bit_6) };
+            bit_6 as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let bit_7: u32 = unsafe { ::std::mem::transmute(bit_7) };
+            bit_7 as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let bit_8: u32 = unsafe { ::std::mem::transmute(bit_8) };
+            bit_8 as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let bit_9: u32 = unsafe { ::std::mem::transmute(bit_9) };
+            bit_9 as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
+            let bit_10: u32 = unsafe { ::std::mem::transmute(bit_10) };
+            bit_10 as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 1u8, {
+            let bit_11: u32 = unsafe { ::std::mem::transmute(bit_11) };
+            bit_11 as u64
+        });
+        __bindgen_bitfield_unit.set(11usize, 1u8, {
+            let bit_12: u32 = unsafe { ::std::mem::transmute(bit_12) };
+            bit_12 as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 1u8, {
+            let bit_13: u32 = unsafe { ::std::mem::transmute(bit_13) };
+            bit_13 as u64
+        });
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
+            let bit_14: u32 = unsafe { ::std::mem::transmute(bit_14) };
+            bit_14 as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
+            let bit_15: u32 = unsafe { ::std::mem::transmute(bit_15) };
+            bit_15 as u64
+        });
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
+            let bit_16: u32 = unsafe { ::std::mem::transmute(bit_16) };
+            bit_16 as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 1u8, {
+            let bit_17: u32 = unsafe { ::std::mem::transmute(bit_17) };
+            bit_17 as u64
+        });
+        __bindgen_bitfield_unit.set(17usize, 1u8, {
+            let bit_18: u32 = unsafe { ::std::mem::transmute(bit_18) };
+            bit_18 as u64
+        });
+        __bindgen_bitfield_unit.set(18usize, 1u8, {
+            let bit_19: u32 = unsafe { ::std::mem::transmute(bit_19) };
+            bit_19 as u64
+        });
+        __bindgen_bitfield_unit.set(19usize, 1u8, {
+            let bit_20: u32 = unsafe { ::std::mem::transmute(bit_20) };
+            bit_20 as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 1u8, {
+            let bit_21: u32 = unsafe { ::std::mem::transmute(bit_21) };
+            bit_21 as u64
+        });
+        __bindgen_bitfield_unit.set(21usize, 1u8, {
+            let bit_22: u32 = unsafe { ::std::mem::transmute(bit_22) };
+            bit_22 as u64
+        });
+        __bindgen_bitfield_unit.set(22usize, 1u8, {
+            let bit_23: u32 = unsafe { ::std::mem::transmute(bit_23) };
+            bit_23 as u64
+        });
+        __bindgen_bitfield_unit.set(23usize, 1u8, {
+            let bit_24: u32 = unsafe { ::std::mem::transmute(bit_24) };
+            bit_24 as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 1u8, {
+            let bit_25: u32 = unsafe { ::std::mem::transmute(bit_25) };
+            bit_25 as u64
+        });
+        __bindgen_bitfield_unit.set(25usize, 1u8, {
+            let bit_26: u32 = unsafe { ::std::mem::transmute(bit_26) };
+            bit_26 as u64
+        });
+        __bindgen_bitfield_unit.set(26usize, 1u8, {
+            let bit_27: u32 = unsafe { ::std::mem::transmute(bit_27) };
+            bit_27 as u64
+        });
+        __bindgen_bitfield_unit.set(27usize, 1u8, {
+            let bit_28: u32 = unsafe { ::std::mem::transmute(bit_28) };
+            bit_28 as u64
+        });
+        __bindgen_bitfield_unit.set(28usize, 1u8, {
+            let bit_29: u32 = unsafe { ::std::mem::transmute(bit_29) };
+            bit_29 as u64
+        });
+        __bindgen_bitfield_unit.set(29usize, 1u8, {
+            let bit_30: u32 = unsafe { ::std::mem::transmute(bit_30) };
+            bit_30 as u64
+        });
+        __bindgen_bitfield_unit.set(30usize, 1u8, {
+            let bit_31: u32 = unsafe { ::std::mem::transmute(bit_31) };
+            bit_31 as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let bit_32: u32 = unsafe { ::std::mem::transmute(bit_32) };
+            bit_32 as u64
+        });
+        __bindgen_bitfield_unit.set(32usize, 1u8, {
+            let bit_33: u32 = unsafe { ::std::mem::transmute(bit_33) };
+            bit_33 as u64
+        });
+        __bindgen_bitfield_unit.set(33usize, 1u8, {
+            let bit_34: u32 = unsafe { ::std::mem::transmute(bit_34) };
+            bit_34 as u64
+        });
+        __bindgen_bitfield_unit.set(34usize, 1u8, {
+            let bit_35: u32 = unsafe { ::std::mem::transmute(bit_35) };
+            bit_35 as u64
+        });
+        __bindgen_bitfield_unit.set(35usize, 1u8, {
+            let bit_36: u32 = unsafe { ::std::mem::transmute(bit_36) };
+            bit_36 as u64
+        });
+        __bindgen_bitfield_unit.set(36usize, 1u8, {
+            let bit_37: u32 = unsafe { ::std::mem::transmute(bit_37) };
+            bit_37 as u64
+        });
+        __bindgen_bitfield_unit.set(37usize, 1u8, {
+            let bit_38: u32 = unsafe { ::std::mem::transmute(bit_38) };
+            bit_38 as u64
+        });
+        __bindgen_bitfield_unit.set(38usize, 1u8, {
+            let bit_39: u32 = unsafe { ::std::mem::transmute(bit_39) };
+            bit_39 as u64
+        });
+        __bindgen_bitfield_unit.set(39usize, 1u8, {
+            let bit_40: u32 = unsafe { ::std::mem::transmute(bit_40) };
+            bit_40 as u64
+        });
+        __bindgen_bitfield_unit.set(40usize, 1u8, {
+            let bit_41: u32 = unsafe { ::std::mem::transmute(bit_41) };
+            bit_41 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs b/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
new file mode 100644
index 00000000..cfe00784
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type Foo_self_type = u8;
diff --git a/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs b/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
new file mode 100644
index 00000000..f5ba025a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-833-1.rs b/bindgen-tests/tests/expectations/tests/issue-833-1.rs
new file mode 100644
index 00000000..f91266f6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-833-1.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct nsTArray {
+    pub hdr: *const (),
+}
+
+extern "C" {
+    pub fn func() -> *mut nsTArray;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-833-2.rs b/bindgen-tests/tests/expectations/tests/issue-833-2.rs
new file mode 100644
index 00000000..1dfe1abd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-833-2.rs
@@ -0,0 +1,14 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+// If the output of this changes, please ensure issue-833-1.hpp changes too
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct nsTArray {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-833.rs b/bindgen-tests/tests/expectations/tests/issue-833.rs
new file mode 100644
index 00000000..a092fb71
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-833.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct nsTArray<T> {
+    pub hdr: *const T,
+}
+
+extern "C" {
+    pub fn func() -> *mut nsTArray<::std::os::raw::c_int>;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-834.rs b/bindgen-tests/tests/expectations/tests/issue-834.rs
new file mode 100644
index 00000000..465341fb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-834.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct U {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_U() {
+    assert_eq!(
+        ::std::mem::size_of::<U>(),
+        1usize,
+        concat!("Size of: ", stringify!(U))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<U>(),
+        1usize,
+        concat!("Alignment of ", stringify!(U))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs b/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs
new file mode 100644
index 00000000..294df575
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-848-replacement-system-include.rs
@@ -0,0 +1,31 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This is intended to replace another type, but won't if we treat this include
+/// as a system include, because clang doesn't parse comments there.
+///
+/// See #848.
+///
+/// <div rustbindgen replaces="nsTArray"></div>
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsTArray<T> {
+    pub m: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for nsTArray<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    pub fn func() -> *mut nsTArray<::std::os::raw::c_int>;
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs b/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs
new file mode 100644
index 00000000..6ac308a7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-888-enum-var-decl-jump.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod Halide {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Type {
+            pub _address: u8,
+        }
+        extern "C" {
+            #[link_name = "\u{1}_ZN6Halide4Type1bE"]
+            pub static mut Type_b: root::a;
+        }
+        #[test]
+        fn bindgen_test_layout_Type() {
+            assert_eq!(
+                ::std::mem::size_of::<Type>(),
+                1usize,
+                concat!("Size of: ", stringify!(Type))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Type>(),
+                1usize,
+                concat!("Alignment of ", stringify!(Type))
+            );
+        }
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+    pub enum a {
+        __bindgen_cannot_repr_c_on_empty_enum = 0,
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs b/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
new file mode 100644
index 00000000..d9c365d8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub struct BlocklistMe(u8);
+
+/// Because this type contains a blocklisted type, it should not derive Copy.
+#[repr(C)]
+pub struct ShouldNotBeCopy {
+    pub a: BlocklistMe,
+}
+#[test]
+fn bindgen_test_layout_ShouldNotBeCopy() {
+    const UNINIT: ::std::mem::MaybeUninit<ShouldNotBeCopy> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ShouldNotBeCopy>(),
+        1usize,
+        concat!("Size of: ", stringify!(ShouldNotBeCopy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ShouldNotBeCopy>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ShouldNotBeCopy))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ShouldNotBeCopy),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for ShouldNotBeCopy {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue-946.rs b/bindgen-tests/tests/expectations/tests/issue-946.rs
new file mode 100644
index 00000000..897700b3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue-946.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        0usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+}
+pub type bar = foo;
diff --git a/bindgen-tests/tests/expectations/tests/issue_311.rs b/bindgen-tests/tests/expectations/tests/issue_311.rs
new file mode 100644
index 00000000..49e30d84
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue_311.rs
@@ -0,0 +1,48 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct jsval_layout {
+        pub __bindgen_anon_1: root::jsval_layout__bindgen_ty_1,
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct jsval_layout__bindgen_ty_1 {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
+        assert_eq!(
+            ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
+            1usize,
+            concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
+            1usize,
+            concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
+        );
+    }
+    #[test]
+    fn bindgen_test_layout_jsval_layout() {
+        assert_eq!(
+            ::std::mem::size_of::<jsval_layout>(),
+            1usize,
+            concat!("Size of: ", stringify!(jsval_layout))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<jsval_layout>(),
+            1usize,
+            concat!("Alignment of ", stringify!(jsval_layout))
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/issue_315.rs b/bindgen-tests/tests/expectations/tests/issue_315.rs
new file mode 100644
index 00000000..71ae1f27
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/issue_315.rs
@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen replaces="c"></div>
+pub type c<a> = a;
diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs
new file mode 100644
index 00000000..a812e905
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs
@@ -0,0 +1,514 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+pub const JSVAL_TAG_SHIFT: u32 = 47;
+pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
+pub const JSVAL_TAG_MASK: i64 = -140737488355328;
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueType {
+    JSVAL_TYPE_DOUBLE = 0,
+    JSVAL_TYPE_INT32 = 1,
+    JSVAL_TYPE_UNDEFINED = 2,
+    JSVAL_TYPE_BOOLEAN = 3,
+    JSVAL_TYPE_MAGIC = 4,
+    JSVAL_TYPE_STRING = 5,
+    JSVAL_TYPE_SYMBOL = 6,
+    JSVAL_TYPE_NULL = 7,
+    JSVAL_TYPE_OBJECT = 8,
+    JSVAL_TYPE_UNKNOWN = 32,
+    JSVAL_TYPE_MISSING = 33,
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueTag {
+    JSVAL_TAG_MAX_DOUBLE = 131056,
+    JSVAL_TAG_INT32 = 131057,
+    JSVAL_TAG_UNDEFINED = 131058,
+    JSVAL_TAG_STRING = 131061,
+    JSVAL_TAG_SYMBOL = 131062,
+    JSVAL_TAG_BOOLEAN = 131059,
+    JSVAL_TAG_MAGIC = 131060,
+    JSVAL_TAG_NULL = 131063,
+    JSVAL_TAG_OBJECT = 131064,
+}
+#[repr(u64)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueShiftedTag {
+    JSVAL_SHIFTED_TAG_MAX_DOUBLE = 18444492278190833663,
+    JSVAL_SHIFTED_TAG_INT32 = 18444633011384221696,
+    JSVAL_SHIFTED_TAG_UNDEFINED = 18444773748872577024,
+    JSVAL_SHIFTED_TAG_STRING = 18445195961337643008,
+    JSVAL_SHIFTED_TAG_SYMBOL = 18445336698825998336,
+    JSVAL_SHIFTED_TAG_BOOLEAN = 18444914486360932352,
+    JSVAL_SHIFTED_TAG_MAGIC = 18445055223849287680,
+    JSVAL_SHIFTED_TAG_NULL = 18445477436314353664,
+    JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992,
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSWhyMagic {
+    /// a hole in a native object's elements
+    JS_ELEMENTS_HOLE = 0,
+    /// there is not a pending iterator value
+    JS_NO_ITER_VALUE = 1,
+    /// exception value thrown when closing a generator
+    JS_GENERATOR_CLOSING = 2,
+    /// compiler sentinel value
+    JS_NO_CONSTANT = 3,
+    /// used in debug builds to catch tracing errors
+    JS_THIS_POISON = 4,
+    /// used in debug builds to catch tracing errors
+    JS_ARG_POISON = 5,
+    /// an empty subnode in the AST serializer
+    JS_SERIALIZE_NO_NODE = 6,
+    /// lazy arguments value on the stack
+    JS_LAZY_ARGUMENTS = 7,
+    /// optimized-away 'arguments' value
+    JS_OPTIMIZED_ARGUMENTS = 8,
+    /// magic value passed to natives to indicate construction
+    JS_IS_CONSTRUCTING = 9,
+    /// arguments.callee has been overwritten
+    JS_OVERWRITTEN_CALLEE = 10,
+    /// value of static block object slot
+    JS_BLOCK_NEEDS_CLONE = 11,
+    /// see class js::HashableValue
+    JS_HASH_KEY_EMPTY = 12,
+    /// error while running Ion code
+    JS_ION_ERROR = 13,
+    /// missing recover instruction result
+    JS_ION_BAILOUT = 14,
+    /// optimized out slot
+    JS_OPTIMIZED_OUT = 15,
+    /// uninitialized lexical bindings that produce ReferenceError on touch.
+    JS_UNINITIALIZED_LEXICAL = 16,
+    /// for local use
+    JS_GENERIC_MAGIC = 17,
+    /// for local use
+    JS_WHY_MAGIC_COUNT = 18,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union jsval_layout {
+    pub asBits: u64,
+    pub debugView: jsval_layout__bindgen_ty_1,
+    pub s: jsval_layout__bindgen_ty_2,
+    pub asDouble: f64,
+    pub asPtr: *mut ::std::os::raw::c_void,
+    pub asWord: usize,
+    pub asUIntPtr: usize,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct jsval_layout__bindgen_ty_1 {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
+    );
+}
+impl Default for jsval_layout__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl jsval_layout__bindgen_ty_1 {
+    #[inline]
+    pub fn payload47(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 47u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_payload47(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 47u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tag(&self) -> JSValueTag {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(47usize, 17u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_tag(&mut self, val: JSValueTag) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(47usize, 17u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        payload47: u64,
+        tag: JSValueTag,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 47u8, {
+            let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
+            payload47 as u64
+        });
+        __bindgen_bitfield_unit.set(47usize, 17u8, {
+            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
+            tag as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct jsval_layout__bindgen_ty_2 {
+    pub payload: jsval_layout__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union jsval_layout__bindgen_ty_2__bindgen_ty_1 {
+    pub i32_: i32,
+    pub u32_: u32,
+    pub why: JSWhyMagic,
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_2__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        jsval_layout__bindgen_ty_2__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(i32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(u32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).why) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(why)
+        )
+    );
+}
+impl Default for jsval_layout__bindgen_ty_2__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<jsval_layout__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2),
+            "::",
+            stringify!(payload)
+        )
+    );
+}
+impl Default for jsval_layout__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_jsval_layout() {
+    const UNINIT: ::std::mem::MaybeUninit<jsval_layout> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout>(),
+        8usize,
+        concat!("Size of: ", stringify!(jsval_layout))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout>(),
+        8usize,
+        concat!("Alignment of ", stringify!(jsval_layout))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asBits) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asBits)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).debugView) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(debugView)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(s)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asDouble)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asPtr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asPtr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asWord) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asWord)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).asUIntPtr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asUIntPtr)
+        )
+    );
+}
+impl Default for jsval_layout {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Value {
+    pub data: jsval_layout,
+}
+#[test]
+fn bindgen_test_layout_Value() {
+    const UNINIT: ::std::mem::MaybeUninit<Value> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Value>(),
+        8usize,
+        concat!("Size of: ", stringify!(Value))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Value>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Value))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Value),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Default for Value {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs
new file mode 100644
index 00000000..b4394993
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs
@@ -0,0 +1,548 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+pub const JSVAL_TAG_SHIFT: u32 = 47;
+pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
+pub const JSVAL_TAG_MASK: i64 = -140737488355328;
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueType {
+    JSVAL_TYPE_DOUBLE = 0,
+    JSVAL_TYPE_INT32 = 1,
+    JSVAL_TYPE_UNDEFINED = 2,
+    JSVAL_TYPE_BOOLEAN = 3,
+    JSVAL_TYPE_MAGIC = 4,
+    JSVAL_TYPE_STRING = 5,
+    JSVAL_TYPE_SYMBOL = 6,
+    JSVAL_TYPE_NULL = 7,
+    JSVAL_TYPE_OBJECT = 8,
+    JSVAL_TYPE_UNKNOWN = 32,
+    JSVAL_TYPE_MISSING = 33,
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueTag {
+    JSVAL_TAG_MAX_DOUBLE = 131056,
+    JSVAL_TAG_INT32 = 131057,
+    JSVAL_TAG_UNDEFINED = 131058,
+    JSVAL_TAG_STRING = 131061,
+    JSVAL_TAG_SYMBOL = 131062,
+    JSVAL_TAG_BOOLEAN = 131059,
+    JSVAL_TAG_MAGIC = 131060,
+    JSVAL_TAG_NULL = 131063,
+    JSVAL_TAG_OBJECT = 131064,
+}
+#[repr(u64)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSValueShiftedTag {
+    JSVAL_SHIFTED_TAG_MAX_DOUBLE = 18444492278190833663,
+    JSVAL_SHIFTED_TAG_INT32 = 18444633011384221696,
+    JSVAL_SHIFTED_TAG_UNDEFINED = 18444773748872577024,
+    JSVAL_SHIFTED_TAG_STRING = 18445195961337643008,
+    JSVAL_SHIFTED_TAG_SYMBOL = 18445336698825998336,
+    JSVAL_SHIFTED_TAG_BOOLEAN = 18444914486360932352,
+    JSVAL_SHIFTED_TAG_MAGIC = 18445055223849287680,
+    JSVAL_SHIFTED_TAG_NULL = 18445477436314353664,
+    JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992,
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JSWhyMagic {
+    /// a hole in a native object's elements
+    JS_ELEMENTS_HOLE = 0,
+    /// there is not a pending iterator value
+    JS_NO_ITER_VALUE = 1,
+    /// exception value thrown when closing a generator
+    JS_GENERATOR_CLOSING = 2,
+    /// compiler sentinel value
+    JS_NO_CONSTANT = 3,
+    /// used in debug builds to catch tracing errors
+    JS_THIS_POISON = 4,
+    /// used in debug builds to catch tracing errors
+    JS_ARG_POISON = 5,
+    /// an empty subnode in the AST serializer
+    JS_SERIALIZE_NO_NODE = 6,
+    /// lazy arguments value on the stack
+    JS_LAZY_ARGUMENTS = 7,
+    /// optimized-away 'arguments' value
+    JS_OPTIMIZED_ARGUMENTS = 8,
+    /// magic value passed to natives to indicate construction
+    JS_IS_CONSTRUCTING = 9,
+    /// arguments.callee has been overwritten
+    JS_OVERWRITTEN_CALLEE = 10,
+    /// value of static block object slot
+    JS_BLOCK_NEEDS_CLONE = 11,
+    /// see class js::HashableValue
+    JS_HASH_KEY_EMPTY = 12,
+    /// error while running Ion code
+    JS_ION_ERROR = 13,
+    /// missing recover instruction result
+    JS_ION_BAILOUT = 14,
+    /// optimized out slot
+    JS_OPTIMIZED_OUT = 15,
+    /// uninitialized lexical bindings that produce ReferenceError on touch.
+    JS_UNINITIALIZED_LEXICAL = 16,
+    /// for local use
+    JS_GENERIC_MAGIC = 17,
+    /// for local use
+    JS_WHY_MAGIC_COUNT = 18,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct jsval_layout {
+    pub asBits: __BindgenUnionField<u64>,
+    pub debugView: __BindgenUnionField<jsval_layout__bindgen_ty_1>,
+    pub s: __BindgenUnionField<jsval_layout__bindgen_ty_2>,
+    pub asDouble: __BindgenUnionField<f64>,
+    pub asPtr: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    pub asWord: __BindgenUnionField<usize>,
+    pub asUIntPtr: __BindgenUnionField<usize>,
+    pub bindgen_union_field: u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct jsval_layout__bindgen_ty_1 {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
+    pub __bindgen_align: [u64; 0usize],
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
+    );
+}
+impl Clone for jsval_layout__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for jsval_layout__bindgen_ty_1 {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl jsval_layout__bindgen_ty_1 {
+    #[inline]
+    pub fn payload47(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 47u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_payload47(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 47u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tag(&self) -> JSValueTag {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(47usize, 17u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_tag(&mut self, val: JSValueTag) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(47usize, 17u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        payload47: u64,
+        tag: JSValueTag,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 47u8, {
+            let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
+            payload47 as u64
+        });
+        __bindgen_bitfield_unit.set(47usize, 17u8, {
+            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
+            tag as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct jsval_layout__bindgen_ty_2 {
+    pub payload: jsval_layout__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct jsval_layout__bindgen_ty_2__bindgen_ty_1 {
+    pub i32_: __BindgenUnionField<i32>,
+    pub u32_: __BindgenUnionField<u32>,
+    pub why: __BindgenUnionField<JSWhyMagic>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_2__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        jsval_layout__bindgen_ty_2__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(i32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(u32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).why) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
+            "::",
+            stringify!(why)
+        )
+    );
+}
+impl Clone for jsval_layout__bindgen_ty_2__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_jsval_layout__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<jsval_layout__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout__bindgen_ty_2),
+            "::",
+            stringify!(payload)
+        )
+    );
+}
+impl Clone for jsval_layout__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_jsval_layout() {
+    const UNINIT: ::std::mem::MaybeUninit<jsval_layout> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<jsval_layout>(),
+        8usize,
+        concat!("Size of: ", stringify!(jsval_layout))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jsval_layout>(),
+        8usize,
+        concat!("Alignment of ", stringify!(jsval_layout))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asBits) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asBits)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).debugView) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(debugView)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(s)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asDouble)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asPtr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asPtr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).asWord) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asWord)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).asUIntPtr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(jsval_layout),
+            "::",
+            stringify!(asUIntPtr)
+        )
+    );
+}
+impl Clone for jsval_layout {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct Value {
+    pub data: jsval_layout,
+}
+#[test]
+fn bindgen_test_layout_Value() {
+    const UNINIT: ::std::mem::MaybeUninit<Value> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Value>(),
+        8usize,
+        concat!("Size of: ", stringify!(Value))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Value>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Value))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Value),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Clone for Value {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/keywords.rs b/bindgen-tests/tests/expectations/tests/keywords.rs
new file mode 100644
index 00000000..a1e7f877
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/keywords.rs
@@ -0,0 +1,227 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}u8"]
+    pub static mut u8_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}u16"]
+    pub static mut u16_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}u32"]
+    pub static mut u32_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}u64"]
+    pub static mut u64_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}i8"]
+    pub static mut i8_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}i16"]
+    pub static mut i16_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}i32"]
+    pub static mut i32_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}i64"]
+    pub static mut i64_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}f32"]
+    pub static mut f32_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}f64"]
+    pub static mut f64_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}usize"]
+    pub static mut usize_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}isize"]
+    pub static mut isize_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}bool"]
+    pub static mut bool_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}str"]
+    pub static mut str_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}dyn"]
+    pub static mut dyn_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}as"]
+    pub static mut as_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}async"]
+    pub static mut async_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}await"]
+    pub static mut await_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}box"]
+    pub static mut box_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}crate"]
+    pub static mut crate_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}false"]
+    pub static mut false_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}fn"]
+    pub static mut fn_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}impl"]
+    pub static mut impl_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}in"]
+    pub static mut in_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}let"]
+    pub static mut let_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}loop"]
+    pub static mut loop_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}match"]
+    pub static mut match_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}mod"]
+    pub static mut mod_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}move"]
+    pub static mut move_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}mut"]
+    pub static mut mut_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}pub"]
+    pub static mut pub_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}ref"]
+    pub static mut ref_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}self"]
+    pub static mut self_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}Self"]
+    pub static mut Self_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}super"]
+    pub static mut super_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}trait"]
+    pub static mut trait_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}true"]
+    pub static mut true_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}try"]
+    pub static mut try_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}type"]
+    pub static mut type_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}unsafe"]
+    pub static mut unsafe_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}use"]
+    pub static mut use_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}where"]
+    pub static mut where_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}abstract"]
+    pub static mut abstract_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}alignof"]
+    pub static mut alignof_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}become"]
+    pub static mut become_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}final"]
+    pub static mut final_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}macro"]
+    pub static mut macro_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}offsetof"]
+    pub static mut offsetof_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}override"]
+    pub static mut override_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}priv"]
+    pub static mut priv_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}proc"]
+    pub static mut proc_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}pure"]
+    pub static mut pure_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}unsized"]
+    pub static mut unsized_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}virtual"]
+    pub static mut virtual_: ::std::os::raw::c_int;
+}
+extern "C" {
+    #[link_name = "\u{1}yield"]
+    pub static mut yield_: ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout.rs b/bindgen-tests/tests/expectations/tests/layout.rs
new file mode 100644
index 00000000..ae417259
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct header {
+    pub _bindgen_opaque_blob: [u8; 16usize],
+}
+#[test]
+fn bindgen_test_layout_header() {
+    assert_eq!(
+        ::std::mem::size_of::<header>(),
+        16usize,
+        concat!("Size of: ", stringify!(header))
+    );
+}
+impl Default for header {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_align.rs b/bindgen-tests/tests/expectations/tests/layout_align.rs
new file mode 100644
index 00000000..466e7686
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_align.rs
@@ -0,0 +1,263 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct rte_kni_fifo {
+    ///< Next position to be written
+    pub write: ::std::os::raw::c_uint,
+    ///< Next position to be read
+    pub read: ::std::os::raw::c_uint,
+    ///< Circular buffer length
+    pub len: ::std::os::raw::c_uint,
+    ///< Pointer size - for 32/64 bit OS
+    pub elem_size: ::std::os::raw::c_uint,
+    ///< The buffer contains mbuf pointers
+    pub buffer: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[test]
+fn bindgen_test_layout_rte_kni_fifo() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_kni_fifo>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_kni_fifo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_kni_fifo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_kni_fifo))
+    );
+}
+impl Default for rte_kni_fifo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_eth_link {
+    ///< ETH_SPEED_NUM_
+    pub link_speed: u32,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_link() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_link> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_link>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_eth_link))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_link>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_link))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).link_speed) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_link),
+            "::",
+            stringify!(link_speed)
+        )
+    );
+}
+impl rte_eth_link {
+    #[inline]
+    pub fn link_duplex(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_duplex(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn link_autoneg(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_autoneg(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn link_status(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_status(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        link_duplex: u16,
+        link_autoneg: u16,
+        link_status: u16,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let link_duplex: u16 =
+                unsafe { ::std::mem::transmute(link_duplex) };
+            link_duplex as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let link_autoneg: u16 =
+                unsafe { ::std::mem::transmute(link_autoneg) };
+            link_autoneg as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let link_status: u16 =
+                unsafe { ::std::mem::transmute(link_status) };
+            link_status as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_arp.rs b/bindgen-tests/tests/expectations/tests/layout_arp.rs
new file mode 100644
index 00000000..6852c236
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_arp.rs
@@ -0,0 +1,216 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const ETHER_ADDR_LEN: u32 = 6;
+pub const ARP_HRD_ETHER: u32 = 1;
+pub const ARP_OP_REQUEST: u32 = 1;
+pub const ARP_OP_REPLY: u32 = 2;
+pub const ARP_OP_REVREQUEST: u32 = 3;
+pub const ARP_OP_REVREPLY: u32 = 4;
+pub const ARP_OP_INVREQUEST: u32 = 8;
+pub const ARP_OP_INVREPLY: u32 = 9;
+/// Ethernet address:
+/// A universally administered address is uniquely assigned to a device by its
+/// manufacturer. The first three octets (in transmission order) contain the
+/// Organizationally Unique Identifier (OUI). The following three (MAC-48 and
+/// EUI-48) octets are assigned by that organization with the only constraint
+/// of uniqueness.
+/// A locally administered address is assigned to a device by a network
+/// administrator and does not contain OUIs.
+/// See http://standards.ieee.org/regauth/groupmac/tutorial.html
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ether_addr {
+    ///< Addr bytes in tx order
+    pub addr_bytes: [u8; 6usize],
+}
+#[test]
+fn bindgen_test_layout_ether_addr() {
+    const UNINIT: ::std::mem::MaybeUninit<ether_addr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ether_addr>(),
+        6usize,
+        concat!("Size of: ", stringify!(ether_addr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ether_addr>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ether_addr))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).addr_bytes) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ether_addr),
+            "::",
+            stringify!(addr_bytes)
+        )
+    );
+}
+/// ARP header IPv4 payload.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct arp_ipv4 {
+    ///< sender hardware address
+    pub arp_sha: ether_addr,
+    ///< sender IP address
+    pub arp_sip: u32,
+    ///< target hardware address
+    pub arp_tha: ether_addr,
+    ///< target IP address
+    pub arp_tip: u32,
+}
+#[test]
+fn bindgen_test_layout_arp_ipv4() {
+    const UNINIT: ::std::mem::MaybeUninit<arp_ipv4> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<arp_ipv4>(),
+        20usize,
+        concat!("Size of: ", stringify!(arp_ipv4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<arp_ipv4>(),
+        1usize,
+        concat!("Alignment of ", stringify!(arp_ipv4))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_sha) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_ipv4),
+            "::",
+            stringify!(arp_sha)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_sip) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_ipv4),
+            "::",
+            stringify!(arp_sip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_tha) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_ipv4),
+            "::",
+            stringify!(arp_tha)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_tip) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_ipv4),
+            "::",
+            stringify!(arp_tip)
+        )
+    );
+}
+/// ARP header.
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct arp_hdr {
+    pub arp_hrd: u16,
+    pub arp_pro: u16,
+    pub arp_hln: u8,
+    pub arp_pln: u8,
+    pub arp_op: u16,
+    pub arp_data: arp_ipv4,
+}
+#[test]
+fn bindgen_test_layout_arp_hdr() {
+    const UNINIT: ::std::mem::MaybeUninit<arp_hdr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<arp_hdr>(),
+        28usize,
+        concat!("Size of: ", stringify!(arp_hdr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<arp_hdr>(),
+        1usize,
+        concat!("Alignment of ", stringify!(arp_hdr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_hrd) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_hrd)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_pro) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_pro)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_hln) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_hln)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_pln) as usize - ptr as usize },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_pln)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arp_op) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_op)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).arp_data) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(arp_hdr),
+            "::",
+            stringify!(arp_data)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_array.rs b/bindgen-tests/tests/expectations/tests/layout_array.rs
new file mode 100644
index 00000000..daf0ad06
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_array.rs
@@ -0,0 +1,408 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+pub const RTE_MEMPOOL_OPS_NAMESIZE: u32 = 32;
+pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16;
+pub const RTE_HEAP_NUM_FREELISTS: u32 = 13;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct rte_mempool {
+    _unused: [u8; 0],
+}
+/// Prototype for implementation specific data provisioning function.
+///
+/// The function should provide the implementation specific memory for
+/// for use by the other mempool ops functions in a given mempool ops struct.
+/// E.g. the default ops provides an instance of the rte_ring for this purpose.
+/// it will most likely point to a different type of data structure, and
+/// will be transparent to the application programmer.
+/// This function should set mp->pool_data.
+pub type rte_mempool_alloc_t = ::std::option::Option<
+    unsafe extern "C" fn(mp: *mut rte_mempool) -> ::std::os::raw::c_int,
+>;
+/// Free the opaque private data pointed to by mp->pool_data pointer.
+pub type rte_mempool_free_t =
+    ::std::option::Option<unsafe extern "C" fn(mp: *mut rte_mempool)>;
+/// Enqueue an object into the external pool.
+pub type rte_mempool_enqueue_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        mp: *mut rte_mempool,
+        obj_table: *const *mut ::std::os::raw::c_void,
+        n: ::std::os::raw::c_uint,
+    ) -> ::std::os::raw::c_int,
+>;
+/// Dequeue an object from the external pool.
+pub type rte_mempool_dequeue_t = ::std::option::Option<
+    unsafe extern "C" fn(
+        mp: *mut rte_mempool,
+        obj_table: *mut *mut ::std::os::raw::c_void,
+        n: ::std::os::raw::c_uint,
+    ) -> ::std::os::raw::c_int,
+>;
+/// Return the number of available objects in the external pool.
+pub type rte_mempool_get_count = ::std::option::Option<
+    unsafe extern "C" fn(mp: *const rte_mempool) -> ::std::os::raw::c_uint,
+>;
+/// Structure defining mempool operations structure
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct rte_mempool_ops {
+    ///< Name of mempool ops struct.
+    pub name: [::std::os::raw::c_char; 32usize],
+    ///< Allocate private data.
+    pub alloc: rte_mempool_alloc_t,
+    ///< Free the external pool.
+    pub free: rte_mempool_free_t,
+    ///< Enqueue an object.
+    pub enqueue: rte_mempool_enqueue_t,
+    ///< Dequeue an object.
+    pub dequeue: rte_mempool_dequeue_t,
+    ///< Get qty of available objs.
+    pub get_count: rte_mempool_get_count,
+}
+#[test]
+fn bindgen_test_layout_rte_mempool_ops() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mempool_ops> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mempool_ops>(),
+        128usize,
+        concat!("Size of: ", stringify!(rte_mempool_ops))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mempool_ops>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_mempool_ops))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(name)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(alloc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(free)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).enqueue) as usize - ptr as usize },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(enqueue)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dequeue) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(dequeue)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).get_count) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops),
+            "::",
+            stringify!(get_count)
+        )
+    );
+}
+impl Default for rte_mempool_ops {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for rte_mempool_ops {
+    fn eq(&self, other: &rte_mempool_ops) -> bool {
+        self.name == other.name &&
+            self.alloc == other.alloc &&
+            self.free == other.free &&
+            self.enqueue == other.enqueue &&
+            self.dequeue == other.dequeue &&
+            self.get_count == other.get_count
+    }
+}
+/// The rte_spinlock_t type.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_spinlock_t {
+    ///< lock status 0 = unlocked, 1 = locked
+    pub locked: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_rte_spinlock_t() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_spinlock_t> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_spinlock_t>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_spinlock_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_spinlock_t>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_spinlock_t))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).locked) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_spinlock_t),
+            "::",
+            stringify!(locked)
+        )
+    );
+}
+/// Structure storing the table of registered ops structs, each of which contain
+/// the function pointers for the mempool ops functions.
+/// Each process has its own storage for this ops struct array so that
+/// the mempools can be shared across primary and secondary processes.
+/// The indices used to access the array are valid across processes, whereas
+/// any function pointers stored directly in the mempool struct would not be.
+/// This results in us simply having "ops_index" in the mempool struct.
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct rte_mempool_ops_table {
+    ///< Spinlock for add/delete.
+    pub sl: rte_spinlock_t,
+    ///< Number of used ops structs in the table.
+    pub num_ops: u32,
+    pub __bindgen_padding_0: [u64; 7usize],
+    /// Storage for all possible ops structs.
+    pub ops: [rte_mempool_ops; 16usize],
+}
+#[test]
+fn bindgen_test_layout_rte_mempool_ops_table() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mempool_ops_table> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mempool_ops_table>(),
+        2112usize,
+        concat!("Size of: ", stringify!(rte_mempool_ops_table))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mempool_ops_table>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_mempool_ops_table))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sl) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops_table),
+            "::",
+            stringify!(sl)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_ops) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops_table),
+            "::",
+            stringify!(num_ops)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mempool_ops_table),
+            "::",
+            stringify!(ops)
+        )
+    );
+}
+impl Default for rte_mempool_ops_table {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// Structure to hold malloc heap
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct malloc_heap {
+    pub lock: rte_spinlock_t,
+    pub free_head: [malloc_heap__bindgen_ty_1; 13usize],
+    pub alloc_count: ::std::os::raw::c_uint,
+    pub total_size: usize,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct malloc_heap__bindgen_ty_1 {
+    pub lh_first: *mut malloc_elem,
+}
+#[test]
+fn bindgen_test_layout_malloc_heap__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<malloc_heap__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<malloc_heap__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(malloc_heap__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<malloc_heap__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(malloc_heap__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).lh_first) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(malloc_heap__bindgen_ty_1),
+            "::",
+            stringify!(lh_first)
+        )
+    );
+}
+impl Default for malloc_heap__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_malloc_heap() {
+    const UNINIT: ::std::mem::MaybeUninit<malloc_heap> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<malloc_heap>(),
+        128usize,
+        concat!("Size of: ", stringify!(malloc_heap))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<malloc_heap>(),
+        64usize,
+        concat!("Alignment of ", stringify!(malloc_heap))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lock) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(malloc_heap),
+            "::",
+            stringify!(lock)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).free_head) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(malloc_heap),
+            "::",
+            stringify!(free_head)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).alloc_count) as usize - ptr as usize
+        },
+        112usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(malloc_heap),
+            "::",
+            stringify!(alloc_count)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
+        },
+        120usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(malloc_heap),
+            "::",
+            stringify!(total_size)
+        )
+    );
+}
+impl Default for malloc_heap {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for malloc_heap {
+    fn eq(&self, other: &malloc_heap) -> bool {
+        self.lock == other.lock &&
+            self.free_head == other.free_head &&
+            self.alloc_count == other.alloc_count &&
+            self.total_size == other.total_size
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct malloc_elem {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs b/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs
new file mode 100644
index 00000000..56b3c021
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_array_too_long.rs
@@ -0,0 +1,341 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4;
+pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX;
+pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX;
+pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM;
+pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    ///< index of last fragment
+    IP_LAST_FRAG_IDX = 0,
+    ///< index of first fragment
+    IP_FIRST_FRAG_IDX = 1,
+    ///< minimum number of fragments
+    IP_MIN_FRAG_NUM = 2,
+    IP_MAX_FRAG_NUM = 4,
+}
+/// @internal fragmented mbuf
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ip_frag {
+    ///< offset into the packet
+    pub ofs: u16,
+    ///< length of fragment
+    pub len: u16,
+    ///< fragment mbuf
+    pub mb: *mut rte_mbuf,
+}
+#[test]
+fn bindgen_test_layout_ip_frag() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag>(),
+        16usize,
+        concat!("Size of: ", stringify!(ip_frag))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ofs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(ofs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(len)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mb) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(mb)
+        )
+    );
+}
+impl Default for ip_frag {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ip_frag_key {
+    ///< src address, first 8 bytes used for IPv4
+    pub src_dst: [u64; 4usize],
+    ///< dst address
+    pub id: u32,
+    ///< src/dst key length
+    pub key_len: u32,
+}
+#[test]
+fn bindgen_test_layout_ip_frag_key() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_key> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_key>(),
+        40usize,
+        concat!("Size of: ", stringify!(ip_frag_key))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_key>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag_key))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_dst) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(src_dst)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).key_len) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(key_len)
+        )
+    );
+}
+/// @internal Fragmented packet to reassemble.
+/// First two entries in the frags[] array are for the last and first fragments.
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct ip_frag_pkt {
+    ///< LRU list
+    pub lru: ip_frag_pkt__bindgen_ty_1,
+    ///< fragmentation key
+    pub key: ip_frag_key,
+    ///< creation timestamp
+    pub start: u64,
+    ///< expected reassembled size
+    pub total_size: u32,
+    ///< size of fragments received
+    pub frag_size: u32,
+    ///< index of next entry to fill
+    pub last_idx: u32,
+    ///< fragments
+    pub frags: [ip_frag; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ip_frag_pkt__bindgen_ty_1 {
+    pub tqe_next: *mut ip_frag_pkt,
+    pub tqe_prev: *mut *mut ip_frag_pkt,
+}
+#[test]
+fn bindgen_test_layout_ip_frag_pkt__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(ip_frag_pkt__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag_pkt__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqe_next) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt__bindgen_ty_1),
+            "::",
+            stringify!(tqe_next)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqe_prev) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt__bindgen_ty_1),
+            "::",
+            stringify!(tqe_prev)
+        )
+    );
+}
+impl Default for ip_frag_pkt__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_ip_frag_pkt() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_pkt>(),
+        192usize,
+        concat!("Size of: ", stringify!(ip_frag_pkt))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_pkt>(),
+        64usize,
+        concat!("Alignment of ", stringify!(ip_frag_pkt))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(lru)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(key)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(start)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(total_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).frag_size) as usize - ptr as usize
+        },
+        68usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(frag_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).last_idx) as usize - ptr as usize
+        },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(last_idx)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).frags) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(frags)
+        )
+    );
+}
+impl Default for ip_frag_pkt {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for ip_frag_pkt {
+    fn eq(&self, other: &ip_frag_pkt) -> bool {
+        self.lru == other.lru &&
+            self.key == other.key &&
+            self.start == other.start &&
+            self.total_size == other.total_size &&
+            self.frag_size == other.frag_size &&
+            self.last_idx == other.last_idx &&
+            self.frags == other.frags
+    }
+}
+///< fragment mbuf
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mbuf {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs b/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs
new file mode 100644
index 00000000..899703bd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_cmdline_token.rs
@@ -0,0 +1,285 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// Stores a pointer to the ops struct, and the offset: the place to
+/// write the parsed result in the destination structure.
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cmdline_token_hdr {
+    pub ops: *mut cmdline_token_ops,
+    pub offset: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_cmdline_token_hdr() {
+    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_hdr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<cmdline_token_hdr>(),
+        16usize,
+        concat!("Size of: ", stringify!(cmdline_token_hdr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<cmdline_token_hdr>(),
+        8usize,
+        concat!("Alignment of ", stringify!(cmdline_token_hdr))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_hdr),
+            "::",
+            stringify!(ops)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_hdr),
+            "::",
+            stringify!(offset)
+        )
+    );
+}
+impl Default for cmdline_token_hdr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// Stores a pointer to the ops struct, and the offset: the place to
+/// write the parsed result in the destination structure.
+pub type cmdline_parse_token_hdr_t = cmdline_token_hdr;
+/// A token is defined by this structure.
+///
+/// parse() takes the token as first argument, then the source buffer
+/// starting at the token we want to parse. The 3rd arg is a pointer
+/// where we store the parsed data (as binary). It returns the number of
+/// parsed chars on success and a negative value on error.
+///
+/// complete_get_nb() returns the number of possible values for this
+/// token if completion is possible. If it is NULL or if it returns 0,
+/// no completion is possible.
+///
+/// complete_get_elt() copy in dstbuf (the size is specified in the
+/// parameter) the i-th possible completion for this token.  returns 0
+/// on success or and a negative value on error.
+///
+/// get_help() fills the dstbuf with the help for the token. It returns
+/// -1 on error and 0 on success.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct cmdline_token_ops {
+    /// parse(token ptr, buf, res pts, buf len)
+    pub parse: ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: *mut cmdline_parse_token_hdr_t,
+            arg2: *const ::std::os::raw::c_char,
+            arg3: *mut ::std::os::raw::c_void,
+            arg4: ::std::os::raw::c_uint,
+        ) -> ::std::os::raw::c_int,
+    >,
+    /// return the num of possible choices for this token
+    pub complete_get_nb: ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: *mut cmdline_parse_token_hdr_t,
+        ) -> ::std::os::raw::c_int,
+    >,
+    /// return the elt x for this token (token, idx, dstbuf, size)
+    pub complete_get_elt: ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: *mut cmdline_parse_token_hdr_t,
+            arg2: ::std::os::raw::c_int,
+            arg3: *mut ::std::os::raw::c_char,
+            arg4: ::std::os::raw::c_uint,
+        ) -> ::std::os::raw::c_int,
+    >,
+    /// get help for this token (token, dstbuf, size)
+    pub get_help: ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: *mut cmdline_parse_token_hdr_t,
+            arg2: *mut ::std::os::raw::c_char,
+            arg3: ::std::os::raw::c_uint,
+        ) -> ::std::os::raw::c_int,
+    >,
+}
+#[test]
+fn bindgen_test_layout_cmdline_token_ops() {
+    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_ops> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<cmdline_token_ops>(),
+        32usize,
+        concat!("Size of: ", stringify!(cmdline_token_ops))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<cmdline_token_ops>(),
+        8usize,
+        concat!("Alignment of ", stringify!(cmdline_token_ops))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).parse) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_ops),
+            "::",
+            stringify!(parse)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).complete_get_nb) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_ops),
+            "::",
+            stringify!(complete_get_nb)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).complete_get_elt) as usize -
+                ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_ops),
+            "::",
+            stringify!(complete_get_elt)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).get_help) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_ops),
+            "::",
+            stringify!(get_help)
+        )
+    );
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum cmdline_numtype {
+    UINT8 = 0,
+    UINT16 = 1,
+    UINT32 = 2,
+    UINT64 = 3,
+    INT8 = 4,
+    INT16 = 5,
+    INT32 = 6,
+    INT64 = 7,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cmdline_token_num_data {
+    pub type_: cmdline_numtype,
+}
+#[test]
+fn bindgen_test_layout_cmdline_token_num_data() {
+    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_num_data> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<cmdline_token_num_data>(),
+        4usize,
+        concat!("Size of: ", stringify!(cmdline_token_num_data))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<cmdline_token_num_data>(),
+        4usize,
+        concat!("Alignment of ", stringify!(cmdline_token_num_data))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_num_data),
+            "::",
+            stringify!(type_)
+        )
+    );
+}
+impl Default for cmdline_token_num_data {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cmdline_token_num {
+    pub hdr: cmdline_token_hdr,
+    pub num_data: cmdline_token_num_data,
+}
+#[test]
+fn bindgen_test_layout_cmdline_token_num() {
+    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_num> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<cmdline_token_num>(),
+        24usize,
+        concat!("Size of: ", stringify!(cmdline_token_num))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<cmdline_token_num>(),
+        8usize,
+        concat!("Alignment of ", stringify!(cmdline_token_num))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_num),
+            "::",
+            stringify!(hdr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).num_data) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(cmdline_token_num),
+            "::",
+            stringify!(num_data)
+        )
+    );
+}
+impl Default for cmdline_token_num {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type cmdline_parse_token_num_t = cmdline_token_num;
diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs
new file mode 100644
index 00000000..62b99e90
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs
@@ -0,0 +1,2192 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+pub const ETH_MQ_RX_RSS_FLAG: u32 = 1;
+pub const ETH_MQ_RX_DCB_FLAG: u32 = 2;
+pub const ETH_MQ_RX_VMDQ_FLAG: u32 = 4;
+pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64;
+pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8;
+pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128;
+pub const ETH_DCB_NUM_QUEUES: u32 = 128;
+pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16;
+pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128;
+pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0;
+pub const RTE_ETH_FLOW_RAW: u32 = 1;
+pub const RTE_ETH_FLOW_IPV4: u32 = 2;
+pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7;
+pub const RTE_ETH_FLOW_IPV6: u32 = 8;
+pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13;
+pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14;
+pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15;
+pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16;
+pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17;
+pub const RTE_ETH_FLOW_PORT: u32 = 18;
+pub const RTE_ETH_FLOW_VXLAN: u32 = 19;
+pub const RTE_ETH_FLOW_GENEVE: u32 = 20;
+pub const RTE_ETH_FLOW_NVGRE: u32 = 21;
+pub const RTE_ETH_FLOW_MAX: u32 = 22;
+#[repr(u32)]
+///  A set of values to identify what method is to be used to route
+///  packets to multiple queues.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_rx_mq_mode {
+    /// None of DCB,RSS or VMDQ mode
+    ETH_MQ_RX_NONE = 0,
+    /// For RX side, only RSS is on
+    ETH_MQ_RX_RSS = 1,
+    /// For RX side,only DCB is on.
+    ETH_MQ_RX_DCB = 2,
+    /// Both DCB and RSS enable
+    ETH_MQ_RX_DCB_RSS = 3,
+    /// Only VMDQ, no RSS nor DCB
+    ETH_MQ_RX_VMDQ_ONLY = 4,
+    /// RSS mode with VMDQ
+    ETH_MQ_RX_VMDQ_RSS = 5,
+    /// Use VMDQ+DCB to route traffic to queues
+    ETH_MQ_RX_VMDQ_DCB = 6,
+    /// Enable both VMDQ and DCB in VMDq
+    ETH_MQ_RX_VMDQ_DCB_RSS = 7,
+}
+/// A structure used to configure the RX features of an Ethernet port.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_rxmode {
+    /// The multi-queue packet distribution mode to be used, e.g. RSS.
+    pub mq_mode: rte_eth_rx_mq_mode,
+    ///< Only used if jumbo_frame enabled.
+    pub max_rx_pkt_len: u32,
+    ///< hdr buf size (header_split enabled).
+    pub split_hdr_size: u16,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_rxmode() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rxmode> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_rxmode>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_rxmode))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_rxmode>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_rxmode))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(mq_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).max_rx_pkt_len) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(max_rx_pkt_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).split_hdr_size) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(split_hdr_size)
+        )
+    );
+}
+impl Default for rte_eth_rxmode {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl rte_eth_rxmode {
+    #[inline]
+    pub fn header_split(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_header_split(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_ip_checksum(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_ip_checksum(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_filter(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_filter(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_strip(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_strip(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_extend(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_extend(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn jumbo_frame(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_jumbo_frame(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_strip_crc(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_strip_crc(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn enable_scatter(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_enable_scatter(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn enable_lro(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_enable_lro(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        header_split: u16,
+        hw_ip_checksum: u16,
+        hw_vlan_filter: u16,
+        hw_vlan_strip: u16,
+        hw_vlan_extend: u16,
+        jumbo_frame: u16,
+        hw_strip_crc: u16,
+        enable_scatter: u16,
+        enable_lro: u16,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let header_split: u16 =
+                unsafe { ::std::mem::transmute(header_split) };
+            header_split as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let hw_ip_checksum: u16 =
+                unsafe { ::std::mem::transmute(hw_ip_checksum) };
+            hw_ip_checksum as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let hw_vlan_filter: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_filter) };
+            hw_vlan_filter as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let hw_vlan_strip: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_strip) };
+            hw_vlan_strip as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let hw_vlan_extend: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_extend) };
+            hw_vlan_extend as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let jumbo_frame: u16 =
+                unsafe { ::std::mem::transmute(jumbo_frame) };
+            jumbo_frame as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let hw_strip_crc: u16 =
+                unsafe { ::std::mem::transmute(hw_strip_crc) };
+            hw_strip_crc as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let enable_scatter: u16 =
+                unsafe { ::std::mem::transmute(enable_scatter) };
+            enable_scatter as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let enable_lro: u16 = unsafe { ::std::mem::transmute(enable_lro) };
+            enable_lro as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(u32)]
+/// A set of values to identify what method is to be used to transmit
+/// packets using multi-TCs.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_tx_mq_mode {
+    ///< It is in neither DCB nor VT mode.
+    ETH_MQ_TX_NONE = 0,
+    ///< For TX side,only DCB is on.
+    ETH_MQ_TX_DCB = 1,
+    ///< For TX side,both DCB and VT is on.
+    ETH_MQ_TX_VMDQ_DCB = 2,
+    ///< Only VT on, no DCB
+    ETH_MQ_TX_VMDQ_ONLY = 3,
+}
+/// A structure used to configure the TX features of an Ethernet port.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_txmode {
+    ///< TX multi-queues mode.
+    pub mq_mode: rte_eth_tx_mq_mode,
+    pub pvid: u16,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_txmode() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_txmode> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_txmode>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_eth_txmode))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_txmode>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_txmode))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_txmode),
+            "::",
+            stringify!(mq_mode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pvid) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_txmode),
+            "::",
+            stringify!(pvid)
+        )
+    );
+}
+impl Default for rte_eth_txmode {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl rte_eth_txmode {
+    #[inline]
+    pub fn hw_vlan_reject_tagged(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_reject_untagged(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_insert_pvid(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        hw_vlan_reject_tagged: u8,
+        hw_vlan_reject_untagged: u8,
+        hw_vlan_insert_pvid: u8,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let hw_vlan_reject_tagged: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
+            hw_vlan_reject_tagged as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let hw_vlan_reject_untagged: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_reject_untagged) };
+            hw_vlan_reject_untagged as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let hw_vlan_insert_pvid: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_insert_pvid) };
+            hw_vlan_insert_pvid as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+/// A structure used to configure the Receive Side Scaling (RSS) feature
+/// of an Ethernet port.
+/// If not NULL, the *rss_key* pointer of the *rss_conf* structure points
+/// to an array holding the RSS key to use for hashing specific header
+/// fields of received packets. The length of this array should be indicated
+/// by *rss_key_len* below. Otherwise, a default random hash key is used by
+/// the device driver.
+///
+/// The *rss_key_len* field of the *rss_conf* structure indicates the length
+/// in bytes of the array pointed by *rss_key*. To be compatible, this length
+/// will be checked in i40e only. Others assume 40 bytes to be used as before.
+///
+/// The *rss_hf* field of the *rss_conf* structure indicates the different
+/// types of IPv4/IPv6 packets to which the RSS hashing must be applied.
+/// Supplying an *rss_hf* equal to zero disables the RSS feature.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_rss_conf {
+    ///< If not NULL, 40-byte hash key.
+    pub rss_key: *mut u8,
+    ///< hash key length in bytes.
+    pub rss_key_len: u8,
+    ///< Hash functions to apply - see below.
+    pub rss_hf: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_rss_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rss_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_rss_conf>(),
+        24usize,
+        concat!("Size of: ", stringify!(rte_eth_rss_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_rss_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_rss_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss_key) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_key)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rss_key_len) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_key_len)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss_hf) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_hf)
+        )
+    );
+}
+impl Default for rte_eth_rss_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(u32)]
+/// This enum indicates the possible number of traffic classes
+/// in DCB configratioins
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_nb_tcs {
+    ///< 4 TCs with DCB.
+    ETH_4_TCS = 4,
+    ///< 8 TCs with DCB.
+    ETH_8_TCS = 8,
+}
+#[repr(u32)]
+/// This enum indicates the possible number of queue pools
+/// in VMDQ configurations.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_nb_pools {
+    ///< 8 VMDq pools.
+    ETH_8_POOLS = 8,
+    ///< 16 VMDq pools.
+    ETH_16_POOLS = 16,
+    ///< 32 VMDq pools.
+    ETH_32_POOLS = 32,
+    ///< 64 VMDq pools.
+    ETH_64_POOLS = 64,
+}
+/// A structure used to configure the VMDQ+DCB feature
+/// of an Ethernet port.
+///
+/// Using this feature, packets are routed to a pool of queues, based
+/// on the vlan id in the vlan tag, and then to a specific queue within
+/// that pool, using the user priority vlan tag field.
+///
+/// A default pool may be used, if desired, to route all traffic which
+/// does not match the vlan filter rules.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_eth_vmdq_dcb_conf {
+    ///< With DCB, 16 or 32 pools
+    pub nb_queue_pools: rte_eth_nb_pools,
+    ///< If non-zero, use a default pool
+    pub enable_default_pool: u8,
+    ///< The default pool, if applicable
+    pub default_pool: u8,
+    ///< We can have up to 64 filters/mappings
+    pub nb_pool_maps: u8,
+    ///< VMDq vlan pool maps.
+    pub pool_map: [rte_eth_vmdq_dcb_conf__bindgen_ty_1; 64usize],
+    pub dcb_tc: [u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
+    ///< The vlan id of the received frame
+    pub vlan_id: u16,
+    ///< Bitmask of pools for packet rx
+    pub pools: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
+            "::",
+            stringify!(vlan_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
+            "::",
+            stringify!(pools)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf>(),
+        1040usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(enable_default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
+        },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
+        },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(nb_pool_maps)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(pool_map)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        1032usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Default for rte_eth_vmdq_dcb_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_dcb_rx_conf {
+    ///< Possible DCB TCs, 4 or 8 TCs
+    pub nb_tcs: rte_eth_nb_tcs,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_dcb_rx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_rx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_dcb_rx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_dcb_rx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_dcb_rx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_dcb_rx_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_rx_conf),
+            "::",
+            stringify!(nb_tcs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_rx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Default for rte_eth_dcb_rx_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_dcb_tx_conf {
+    ///< With DCB, 16 or 32 pools.
+    pub nb_queue_pools: rte_eth_nb_pools,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_tx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_tx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_tx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_tx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Default for rte_eth_vmdq_dcb_tx_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_dcb_tx_conf {
+    ///< Possible DCB TCs, 4 or 8 TCs.
+    pub nb_tcs: rte_eth_nb_tcs,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_dcb_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_dcb_tx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_dcb_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_dcb_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_dcb_tx_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_tx_conf),
+            "::",
+            stringify!(nb_tcs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_tx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Default for rte_eth_dcb_tx_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_tx_conf {
+    ///< VMDq mode, 64 pools.
+    pub nb_queue_pools: rte_eth_nb_pools,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_tx_conf>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_tx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_tx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+}
+impl Default for rte_eth_vmdq_tx_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_eth_vmdq_rx_conf {
+    ///< VMDq only mode, 8 or 64 pools
+    pub nb_queue_pools: rte_eth_nb_pools,
+    ///< If non-zero, use a default pool
+    pub enable_default_pool: u8,
+    ///< The default pool, if applicable
+    pub default_pool: u8,
+    ///< Enable VT loop back
+    pub enable_loop_back: u8,
+    ///< We can have up to 64 filters/mappings
+    pub nb_pool_maps: u8,
+    ///< Flags from ETH_VMDQ_ACCEPT_*
+    pub rx_mode: u32,
+    ///< VMDq vlan pool maps.
+    pub pool_map: [rte_eth_vmdq_rx_conf__bindgen_ty_1; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_rx_conf__bindgen_ty_1 {
+    ///< The vlan id of the received frame
+    pub vlan_id: u16,
+    ///< Bitmask of pools for packet rx
+    pub pools: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_rx_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
+            "::",
+            stringify!(vlan_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
+            "::",
+            stringify!(pools)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_rx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_rx_conf>(),
+        1040usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_rx_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_rx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(enable_default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
+        },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_loop_back) as usize -
+                ptr as usize
+        },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(enable_loop_back)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
+        },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(nb_pool_maps)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rx_mode) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(rx_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(pool_map)
+        )
+    );
+}
+impl Default for rte_eth_vmdq_rx_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(u32)]
+///  Flow Director setting modes: none, signature or perfect.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_mode {
+    ///< Disable FDIR support.
+    RTE_FDIR_MODE_NONE = 0,
+    ///< Enable FDIR signature filter mode.
+    RTE_FDIR_MODE_SIGNATURE = 1,
+    ///< Enable FDIR perfect filter mode.
+    RTE_FDIR_MODE_PERFECT = 2,
+    ///< Enable FDIR filter mode - MAC VLAN.
+    RTE_FDIR_MODE_PERFECT_MAC_VLAN = 3,
+    ///< Enable FDIR filter mode - tunnel.
+    RTE_FDIR_MODE_PERFECT_TUNNEL = 4,
+}
+#[repr(u32)]
+///  Memory space that can be configured to store Flow Director filters
+///  in the board memory.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_pballoc_type {
+    ///< 64k.
+    RTE_FDIR_PBALLOC_64K = 0,
+    ///< 128k.
+    RTE_FDIR_PBALLOC_128K = 1,
+    ///< 256k.
+    RTE_FDIR_PBALLOC_256K = 2,
+}
+#[repr(u32)]
+///  Select report mode of FDIR hash information in RX descriptors.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_status_mode {
+    ///< Never report FDIR hash.
+    RTE_FDIR_NO_REPORT_STATUS = 0,
+    ///< Only report FDIR hash for matching pkts.
+    RTE_FDIR_REPORT_STATUS = 1,
+    ///< Always report FDIR hash.
+    RTE_FDIR_REPORT_STATUS_ALWAYS = 2,
+}
+/// A structure used to define the input for IPV4 flow
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_ipv4_flow {
+    ///< IPv4 source address in big endian.
+    pub src_ip: u32,
+    ///< IPv4 destination address in big endian.
+    pub dst_ip: u32,
+    ///< Type of service to match.
+    pub tos: u8,
+    ///< Time to live to match.
+    pub ttl: u8,
+    ///< Protocol, next header in big endian.
+    pub proto: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_ipv4_flow() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv4_flow> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_ipv4_flow>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_ipv4_flow))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_ipv4_flow>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_ipv4_flow))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(src_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(dst_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tos) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(tos)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ttl) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(ttl)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(proto)
+        )
+    );
+}
+/// A structure used to define the input for IPV6 flow
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_ipv6_flow {
+    ///< IPv6 source address in big endian.
+    pub src_ip: [u32; 4usize],
+    ///< IPv6 destination address in big endian.
+    pub dst_ip: [u32; 4usize],
+    ///< Traffic class to match.
+    pub tc: u8,
+    ///< Protocol, next header to match.
+    pub proto: u8,
+    ///< Hop limits to match.
+    pub hop_limits: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_ipv6_flow() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv6_flow> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_ipv6_flow>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_eth_ipv6_flow))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_ipv6_flow>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_ipv6_flow))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(src_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(dst_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tc) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(tc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
+        33usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(proto)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).hop_limits) as usize - ptr as usize
+        },
+        34usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(hop_limits)
+        )
+    );
+}
+///  A structure used to configure FDIR masks that are used by the device
+///  to match the various fields of RX packet headers.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_masks {
+    ///< Bit mask for vlan_tci in big endian
+    pub vlan_tci_mask: u16,
+    /// Bit mask for ipv4 flow in big endian.
+    pub ipv4_mask: rte_eth_ipv4_flow,
+    /// Bit maks for ipv6 flow in big endian.
+    pub ipv6_mask: rte_eth_ipv6_flow,
+    /// Bit mask for L4 source port in big endian.
+    pub src_port_mask: u16,
+    /// Bit mask for L4 destination port in big endian.
+    pub dst_port_mask: u16,
+    /// 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
+    ///first byte on the wire
+    pub mac_addr_byte_mask: u8,
+    /// Bit mask for tunnel ID in big endian.
+    pub tunnel_id_mask: u32,
+    ///< 1 - Match tunnel type,
+    ///0 - Ignore tunnel type.
+    pub tunnel_type_mask: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_masks() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_masks> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_masks>(),
+        68usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_masks))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_masks>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_masks))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci_mask) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(vlan_tci_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ipv4_mask) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(ipv4_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ipv6_mask) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(ipv6_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_port_mask) as usize - ptr as usize
+        },
+        52usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(src_port_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_port_mask) as usize - ptr as usize
+        },
+        54usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(dst_port_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mac_addr_byte_mask) as usize -
+                ptr as usize
+        },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(mac_addr_byte_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tunnel_id_mask) as usize - ptr as usize
+        },
+        60usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(tunnel_id_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tunnel_type_mask) as usize -
+                ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(tunnel_type_mask)
+        )
+    );
+}
+#[repr(u32)]
+/// Payload type
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_payload_type {
+    RTE_ETH_PAYLOAD_UNKNOWN = 0,
+    RTE_ETH_RAW_PAYLOAD = 1,
+    RTE_ETH_L2_PAYLOAD = 2,
+    RTE_ETH_L3_PAYLOAD = 3,
+    RTE_ETH_L4_PAYLOAD = 4,
+    RTE_ETH_PAYLOAD_MAX = 8,
+}
+/// A structure used to select bytes extracted from the protocol layers to
+/// flexible payload for filter
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_flex_payload_cfg {
+    ///< Payload type
+    pub type_: rte_eth_payload_type,
+    pub src_offset: [u16; 16usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_flex_payload_cfg() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_flex_payload_cfg> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_flex_payload_cfg>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_eth_flex_payload_cfg))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_flex_payload_cfg>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_flex_payload_cfg))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_flex_payload_cfg),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_offset) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_flex_payload_cfg),
+            "::",
+            stringify!(src_offset)
+        )
+    );
+}
+impl Default for rte_eth_flex_payload_cfg {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// A structure used to define FDIR masks for flexible payload
+/// for each flow type
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_flex_mask {
+    pub flow_type: u16,
+    pub mask: [u8; 16usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_flex_mask() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_mask> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_flex_mask>(),
+        18usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_flex_mask))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_flex_mask>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_mask))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flow_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_mask),
+            "::",
+            stringify!(flow_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_mask),
+            "::",
+            stringify!(mask)
+        )
+    );
+}
+/// A structure used to define all flexible payload related setting
+/// include flex payload and flex mask
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_flex_conf {
+    ///< The number of following payload cfg
+    pub nb_payloads: u16,
+    ///< The number of following mask
+    pub nb_flexmasks: u16,
+    pub flex_set: [rte_eth_flex_payload_cfg; 8usize],
+    pub flex_mask: [rte_eth_fdir_flex_mask; 22usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_flex_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_flex_conf>(),
+        688usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_flex_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_flex_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_payloads) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(nb_payloads)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_flexmasks) as usize - ptr as usize
+        },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(nb_flexmasks)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_set) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(flex_set)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_mask) as usize - ptr as usize
+        },
+        292usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(flex_mask)
+        )
+    );
+}
+impl Default for rte_eth_fdir_flex_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// A structure used to configure the Flow Director (FDIR) feature
+/// of an Ethernet port.
+///
+/// If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_fdir_conf {
+    ///< Flow Director mode.
+    pub mode: rte_fdir_mode,
+    ///< Space for FDIR filters.
+    pub pballoc: rte_fdir_pballoc_type,
+    ///< How to report FDIR hash.
+    pub status: rte_fdir_status_mode,
+    /// RX queue of packets matching a "drop" filter in perfect mode.
+    pub drop_queue: u8,
+    pub mask: rte_eth_fdir_masks,
+    pub flex_conf: rte_eth_fdir_flex_conf,
+}
+#[test]
+fn bindgen_test_layout_rte_fdir_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_fdir_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_fdir_conf>(),
+        772usize,
+        concat!("Size of: ", stringify!(rte_fdir_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_fdir_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_fdir_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(mode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pballoc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(pballoc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(status)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).drop_queue) as usize - ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(drop_queue)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_conf) as usize - ptr as usize
+        },
+        84usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(flex_conf)
+        )
+    );
+}
+impl Default for rte_fdir_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// A structure used to enable/disable specific device interrupts.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_intr_conf {
+    /// enable/disable lsc interrupt. 0 (default) - disable, 1 enable
+    pub lsc: u16,
+    /// enable/disable rxq interrupt. 0 (default) - disable, 1 enable
+    pub rxq: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_intr_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_intr_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_intr_conf>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_intr_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_intr_conf>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_intr_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lsc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_intr_conf),
+            "::",
+            stringify!(lsc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rxq) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_intr_conf),
+            "::",
+            stringify!(rxq)
+        )
+    );
+}
+/// A structure used to configure an Ethernet port.
+/// Depending upon the RX multi-queue mode, extra advanced
+/// configuration settings may be needed.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_eth_conf {
+    ///< bitmap of ETH_LINK_SPEED_XXX of speeds to be
+    ///used. ETH_LINK_SPEED_FIXED disables link
+    ///autonegotiation, and a unique speed shall be
+    ///set. Otherwise, the bitmap defines the set of
+    ///speeds to be advertised. If the special value
+    ///ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
+    ///supported are advertised.
+    pub link_speeds: u32,
+    ///< Port RX configuration.
+    pub rxmode: rte_eth_rxmode,
+    ///< Port TX configuration.
+    pub txmode: rte_eth_txmode,
+    ///< Loopback operation mode. By default the value
+    ///is 0, meaning the loopback mode is disabled.
+    ///Read the datasheet of given ethernet controller
+    ///for details. The possible values of this field
+    ///are defined in implementation of each driver.
+    pub lpbk_mode: u32,
+    ///< Port RX filtering configuration (union).
+    pub rx_adv_conf: rte_eth_conf__bindgen_ty_1,
+    ///< Port TX DCB configuration (union).
+    pub tx_adv_conf: rte_eth_conf__bindgen_ty_2,
+    /// Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
+    ///is needed,and the variable must be set ETH_DCB_PFC_SUPPORT.
+    pub dcb_capability_en: u32,
+    ///< FDIR configuration.
+    pub fdir_conf: rte_fdir_conf,
+    ///< Interrupt mode configuration.
+    pub intr_conf: rte_intr_conf,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_eth_conf__bindgen_ty_1 {
+    ///< Port RSS configuration
+    pub rss_conf: rte_eth_rss_conf,
+    pub vmdq_dcb_conf: rte_eth_vmdq_dcb_conf,
+    pub dcb_rx_conf: rte_eth_dcb_rx_conf,
+    pub vmdq_rx_conf: rte_eth_vmdq_rx_conf,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_1>(),
+        2120usize,
+        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rss_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(rss_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_dcb_conf) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(vmdq_dcb_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_rx_conf) as usize - ptr as usize
+        },
+        1064usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(dcb_rx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_rx_conf) as usize - ptr as usize
+        },
+        1080usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(vmdq_rx_conf)
+        )
+    );
+}
+impl Default for rte_eth_conf__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_eth_conf__bindgen_ty_2 {
+    pub vmdq_dcb_tx_conf: rte_eth_vmdq_dcb_tx_conf,
+    pub dcb_tx_conf: rte_eth_dcb_tx_conf,
+    pub vmdq_tx_conf: rte_eth_vmdq_tx_conf,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_2>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_dcb_tx_conf) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(vmdq_dcb_tx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_tx_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(dcb_tx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_tx_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(vmdq_tx_conf)
+        )
+    );
+}
+impl Default for rte_eth_conf__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf>(),
+        2944usize,
+        concat!("Size of: ", stringify!(rte_eth_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).link_speeds) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(link_speeds)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rxmode) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(rxmode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).txmode) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(txmode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).lpbk_mode) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(lpbk_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rx_adv_conf) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(rx_adv_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tx_adv_conf) as usize - ptr as usize
+        },
+        2152usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(tx_adv_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_capability_en) as usize -
+                ptr as usize
+        },
+        2164usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(dcb_capability_en)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).fdir_conf) as usize - ptr as usize
+        },
+        2168usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(fdir_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).intr_conf) as usize - ptr as usize
+        },
+        2940usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(intr_conf)
+        )
+    );
+}
+impl Default for rte_eth_conf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs
new file mode 100644
index 00000000..d7fa0a63
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs
@@ -0,0 +1,2337 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+pub const ETH_MQ_RX_RSS_FLAG: u32 = 1;
+pub const ETH_MQ_RX_DCB_FLAG: u32 = 2;
+pub const ETH_MQ_RX_VMDQ_FLAG: u32 = 4;
+pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64;
+pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8;
+pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128;
+pub const ETH_DCB_NUM_QUEUES: u32 = 128;
+pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16;
+pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128;
+pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0;
+pub const RTE_ETH_FLOW_RAW: u32 = 1;
+pub const RTE_ETH_FLOW_IPV4: u32 = 2;
+pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6;
+pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7;
+pub const RTE_ETH_FLOW_IPV6: u32 = 8;
+pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12;
+pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13;
+pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14;
+pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15;
+pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16;
+pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17;
+pub const RTE_ETH_FLOW_PORT: u32 = 18;
+pub const RTE_ETH_FLOW_VXLAN: u32 = 19;
+pub const RTE_ETH_FLOW_GENEVE: u32 = 20;
+pub const RTE_ETH_FLOW_NVGRE: u32 = 21;
+pub const RTE_ETH_FLOW_MAX: u32 = 22;
+#[repr(u32)]
+///  A set of values to identify what method is to be used to route
+///  packets to multiple queues.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_rx_mq_mode {
+    /// None of DCB,RSS or VMDQ mode
+    ETH_MQ_RX_NONE = 0,
+    /// For RX side, only RSS is on
+    ETH_MQ_RX_RSS = 1,
+    /// For RX side,only DCB is on.
+    ETH_MQ_RX_DCB = 2,
+    /// Both DCB and RSS enable
+    ETH_MQ_RX_DCB_RSS = 3,
+    /// Only VMDQ, no RSS nor DCB
+    ETH_MQ_RX_VMDQ_ONLY = 4,
+    /// RSS mode with VMDQ
+    ETH_MQ_RX_VMDQ_RSS = 5,
+    /// Use VMDQ+DCB to route traffic to queues
+    ETH_MQ_RX_VMDQ_DCB = 6,
+    /// Enable both VMDQ and DCB in VMDq
+    ETH_MQ_RX_VMDQ_DCB_RSS = 7,
+}
+/// A structure used to configure the RX features of an Ethernet port.
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_rxmode {
+    /// The multi-queue packet distribution mode to be used, e.g. RSS.
+    pub mq_mode: rte_eth_rx_mq_mode,
+    ///< Only used if jumbo_frame enabled.
+    pub max_rx_pkt_len: u32,
+    ///< hdr buf size (header_split enabled).
+    pub split_hdr_size: u16,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_rxmode() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rxmode> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_rxmode>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_rxmode))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_rxmode>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_rxmode))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(mq_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).max_rx_pkt_len) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(max_rx_pkt_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).split_hdr_size) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rxmode),
+            "::",
+            stringify!(split_hdr_size)
+        )
+    );
+}
+impl Clone for rte_eth_rxmode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_rxmode {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl rte_eth_rxmode {
+    #[inline]
+    pub fn header_split(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_header_split(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_ip_checksum(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_ip_checksum(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_filter(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_filter(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_strip(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_strip(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_extend(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_extend(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn jumbo_frame(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_jumbo_frame(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_strip_crc(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_hw_strip_crc(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn enable_scatter(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_enable_scatter(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn enable_lro(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_enable_lro(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        header_split: u16,
+        hw_ip_checksum: u16,
+        hw_vlan_filter: u16,
+        hw_vlan_strip: u16,
+        hw_vlan_extend: u16,
+        jumbo_frame: u16,
+        hw_strip_crc: u16,
+        enable_scatter: u16,
+        enable_lro: u16,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let header_split: u16 =
+                unsafe { ::std::mem::transmute(header_split) };
+            header_split as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let hw_ip_checksum: u16 =
+                unsafe { ::std::mem::transmute(hw_ip_checksum) };
+            hw_ip_checksum as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let hw_vlan_filter: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_filter) };
+            hw_vlan_filter as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let hw_vlan_strip: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_strip) };
+            hw_vlan_strip as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let hw_vlan_extend: u16 =
+                unsafe { ::std::mem::transmute(hw_vlan_extend) };
+            hw_vlan_extend as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let jumbo_frame: u16 =
+                unsafe { ::std::mem::transmute(jumbo_frame) };
+            jumbo_frame as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let hw_strip_crc: u16 =
+                unsafe { ::std::mem::transmute(hw_strip_crc) };
+            hw_strip_crc as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let enable_scatter: u16 =
+                unsafe { ::std::mem::transmute(enable_scatter) };
+            enable_scatter as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let enable_lro: u16 = unsafe { ::std::mem::transmute(enable_lro) };
+            enable_lro as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(u32)]
+/// A set of values to identify what method is to be used to transmit
+/// packets using multi-TCs.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_tx_mq_mode {
+    ///< It is in neither DCB nor VT mode.
+    ETH_MQ_TX_NONE = 0,
+    ///< For TX side,only DCB is on.
+    ETH_MQ_TX_DCB = 1,
+    ///< For TX side,both DCB and VT is on.
+    ETH_MQ_TX_VMDQ_DCB = 2,
+    ///< Only VT on, no DCB
+    ETH_MQ_TX_VMDQ_ONLY = 3,
+}
+/// A structure used to configure the TX features of an Ethernet port.
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_txmode {
+    ///< TX multi-queues mode.
+    pub mq_mode: rte_eth_tx_mq_mode,
+    pub pvid: u16,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_txmode() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_txmode> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_txmode>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_eth_txmode))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_txmode>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_txmode))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_txmode),
+            "::",
+            stringify!(mq_mode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pvid) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_txmode),
+            "::",
+            stringify!(pvid)
+        )
+    );
+}
+impl Clone for rte_eth_txmode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_txmode {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl rte_eth_txmode {
+    #[inline]
+    pub fn hw_vlan_reject_tagged(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_reject_untagged(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn hw_vlan_insert_pvid(&self) -> u8 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        hw_vlan_reject_tagged: u8,
+        hw_vlan_reject_untagged: u8,
+        hw_vlan_insert_pvid: u8,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let hw_vlan_reject_tagged: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
+            hw_vlan_reject_tagged as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let hw_vlan_reject_untagged: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_reject_untagged) };
+            hw_vlan_reject_untagged as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let hw_vlan_insert_pvid: u8 =
+                unsafe { ::std::mem::transmute(hw_vlan_insert_pvid) };
+            hw_vlan_insert_pvid as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+/// A structure used to configure the Receive Side Scaling (RSS) feature
+/// of an Ethernet port.
+/// If not NULL, the *rss_key* pointer of the *rss_conf* structure points
+/// to an array holding the RSS key to use for hashing specific header
+/// fields of received packets. The length of this array should be indicated
+/// by *rss_key_len* below. Otherwise, a default random hash key is used by
+/// the device driver.
+///
+/// The *rss_key_len* field of the *rss_conf* structure indicates the length
+/// in bytes of the array pointed by *rss_key*. To be compatible, this length
+/// will be checked in i40e only. Others assume 40 bytes to be used as before.
+///
+/// The *rss_hf* field of the *rss_conf* structure indicates the different
+/// types of IPv4/IPv6 packets to which the RSS hashing must be applied.
+/// Supplying an *rss_hf* equal to zero disables the RSS feature.
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_rss_conf {
+    ///< If not NULL, 40-byte hash key.
+    pub rss_key: *mut u8,
+    ///< hash key length in bytes.
+    pub rss_key_len: u8,
+    ///< Hash functions to apply - see below.
+    pub rss_hf: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_rss_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rss_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_rss_conf>(),
+        24usize,
+        concat!("Size of: ", stringify!(rte_eth_rss_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_rss_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_rss_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss_key) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_key)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rss_key_len) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_key_len)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss_hf) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_rss_conf),
+            "::",
+            stringify!(rss_hf)
+        )
+    );
+}
+impl Clone for rte_eth_rss_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_rss_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(u32)]
+/// This enum indicates the possible number of traffic classes
+/// in DCB configratioins
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_nb_tcs {
+    ///< 4 TCs with DCB.
+    ETH_4_TCS = 4,
+    ///< 8 TCs with DCB.
+    ETH_8_TCS = 8,
+}
+#[repr(u32)]
+/// This enum indicates the possible number of queue pools
+/// in VMDQ configurations.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_nb_pools {
+    ///< 8 VMDq pools.
+    ETH_8_POOLS = 8,
+    ///< 16 VMDq pools.
+    ETH_16_POOLS = 16,
+    ///< 32 VMDq pools.
+    ETH_32_POOLS = 32,
+    ///< 64 VMDq pools.
+    ETH_64_POOLS = 64,
+}
+/// A structure used to configure the VMDQ+DCB feature
+/// of an Ethernet port.
+///
+/// Using this feature, packets are routed to a pool of queues, based
+/// on the vlan id in the vlan tag, and then to a specific queue within
+/// that pool, using the user priority vlan tag field.
+///
+/// A default pool may be used, if desired, to route all traffic which
+/// does not match the vlan filter rules.
+#[repr(C)]
+#[derive(Copy)]
+pub struct rte_eth_vmdq_dcb_conf {
+    ///< With DCB, 16 or 32 pools
+    pub nb_queue_pools: rte_eth_nb_pools,
+    ///< If non-zero, use a default pool
+    pub enable_default_pool: u8,
+    ///< The default pool, if applicable
+    pub default_pool: u8,
+    ///< We can have up to 64 filters/mappings
+    pub nb_pool_maps: u8,
+    ///< VMDq vlan pool maps.
+    pub pool_map: [rte_eth_vmdq_dcb_conf__bindgen_ty_1; 64usize],
+    pub dcb_tc: [u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
+    ///< The vlan id of the received frame
+    pub vlan_id: u16,
+    ///< Bitmask of pools for packet rx
+    pub pools: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
+            "::",
+            stringify!(vlan_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
+            "::",
+            stringify!(pools)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf>(),
+        1040usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(enable_default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
+        },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
+        },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(nb_pool_maps)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(pool_map)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        1032usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_dcb_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_vmdq_dcb_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_dcb_rx_conf {
+    ///< Possible DCB TCs, 4 or 8 TCs
+    pub nb_tcs: rte_eth_nb_tcs,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_dcb_rx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_rx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_dcb_rx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_dcb_rx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_dcb_rx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_dcb_rx_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_rx_conf),
+            "::",
+            stringify!(nb_tcs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_rx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Clone for rte_eth_dcb_rx_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_dcb_rx_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_dcb_tx_conf {
+    ///< With DCB, 16 or 32 pools.
+    pub nb_queue_pools: rte_eth_nb_pools,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_dcb_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_dcb_tx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_dcb_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_tx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_tx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_dcb_tx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_dcb_tx_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_vmdq_dcb_tx_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_dcb_tx_conf {
+    ///< Possible DCB TCs, 4 or 8 TCs.
+    pub nb_tcs: rte_eth_nb_tcs,
+    /// Traffic class each UP mapped to.
+    pub dcb_tc: [u8; 8usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_dcb_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_dcb_tx_conf>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_dcb_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_dcb_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_dcb_tx_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_tx_conf),
+            "::",
+            stringify!(nb_tcs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_dcb_tx_conf),
+            "::",
+            stringify!(dcb_tc)
+        )
+    );
+}
+impl Clone for rte_eth_dcb_tx_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_dcb_tx_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_tx_conf {
+    ///< VMDq mode, 64 pools.
+    pub nb_queue_pools: rte_eth_nb_pools,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_tx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_tx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_tx_conf>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_tx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_tx_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_tx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_tx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_tx_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_vmdq_tx_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy)]
+pub struct rte_eth_vmdq_rx_conf {
+    ///< VMDq only mode, 8 or 64 pools
+    pub nb_queue_pools: rte_eth_nb_pools,
+    ///< If non-zero, use a default pool
+    pub enable_default_pool: u8,
+    ///< The default pool, if applicable
+    pub default_pool: u8,
+    ///< Enable VT loop back
+    pub enable_loop_back: u8,
+    ///< We can have up to 64 filters/mappings
+    pub nb_pool_maps: u8,
+    ///< Flags from ETH_VMDQ_ACCEPT_*
+    pub rx_mode: u32,
+    ///< VMDq vlan pool maps.
+    pub pool_map: [rte_eth_vmdq_rx_conf__bindgen_ty_1; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_vmdq_rx_conf__bindgen_ty_1 {
+    ///< The vlan id of the received frame
+    pub vlan_id: u16,
+    ///< Bitmask of pools for packet rx
+    pub pools: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_rx_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
+            "::",
+            stringify!(vlan_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
+            "::",
+            stringify!(pools)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_rx_conf__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_eth_vmdq_rx_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_vmdq_rx_conf>(),
+        1040usize,
+        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_vmdq_rx_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_vmdq_rx_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(nb_queue_pools)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(enable_default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
+        },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(default_pool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).enable_loop_back) as usize -
+                ptr as usize
+        },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(enable_loop_back)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
+        },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(nb_pool_maps)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rx_mode) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(rx_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_vmdq_rx_conf),
+            "::",
+            stringify!(pool_map)
+        )
+    );
+}
+impl Clone for rte_eth_vmdq_rx_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_vmdq_rx_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(u32)]
+///  Flow Director setting modes: none, signature or perfect.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_mode {
+    ///< Disable FDIR support.
+    RTE_FDIR_MODE_NONE = 0,
+    ///< Enable FDIR signature filter mode.
+    RTE_FDIR_MODE_SIGNATURE = 1,
+    ///< Enable FDIR perfect filter mode.
+    RTE_FDIR_MODE_PERFECT = 2,
+    ///< Enable FDIR filter mode - MAC VLAN.
+    RTE_FDIR_MODE_PERFECT_MAC_VLAN = 3,
+    ///< Enable FDIR filter mode - tunnel.
+    RTE_FDIR_MODE_PERFECT_TUNNEL = 4,
+}
+#[repr(u32)]
+///  Memory space that can be configured to store Flow Director filters
+///  in the board memory.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_pballoc_type {
+    ///< 64k.
+    RTE_FDIR_PBALLOC_64K = 0,
+    ///< 128k.
+    RTE_FDIR_PBALLOC_128K = 1,
+    ///< 256k.
+    RTE_FDIR_PBALLOC_256K = 2,
+}
+#[repr(u32)]
+///  Select report mode of FDIR hash information in RX descriptors.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_fdir_status_mode {
+    ///< Never report FDIR hash.
+    RTE_FDIR_NO_REPORT_STATUS = 0,
+    ///< Only report FDIR hash for matching pkts.
+    RTE_FDIR_REPORT_STATUS = 1,
+    ///< Always report FDIR hash.
+    RTE_FDIR_REPORT_STATUS_ALWAYS = 2,
+}
+/// A structure used to define the input for IPV4 flow
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_ipv4_flow {
+    ///< IPv4 source address in big endian.
+    pub src_ip: u32,
+    ///< IPv4 destination address in big endian.
+    pub dst_ip: u32,
+    ///< Type of service to match.
+    pub tos: u8,
+    ///< Time to live to match.
+    pub ttl: u8,
+    ///< Protocol, next header in big endian.
+    pub proto: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_ipv4_flow() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv4_flow> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_ipv4_flow>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_ipv4_flow))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_ipv4_flow>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_ipv4_flow))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(src_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(dst_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tos) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(tos)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ttl) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(ttl)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv4_flow),
+            "::",
+            stringify!(proto)
+        )
+    );
+}
+impl Clone for rte_eth_ipv4_flow {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+/// A structure used to define the input for IPV6 flow
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_ipv6_flow {
+    ///< IPv6 source address in big endian.
+    pub src_ip: [u32; 4usize],
+    ///< IPv6 destination address in big endian.
+    pub dst_ip: [u32; 4usize],
+    ///< Traffic class to match.
+    pub tc: u8,
+    ///< Protocol, next header to match.
+    pub proto: u8,
+    ///< Hop limits to match.
+    pub hop_limits: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_ipv6_flow() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv6_flow> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_ipv6_flow>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_eth_ipv6_flow))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_ipv6_flow>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_ipv6_flow))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(src_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(dst_ip)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tc) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(tc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
+        33usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(proto)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).hop_limits) as usize - ptr as usize
+        },
+        34usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_ipv6_flow),
+            "::",
+            stringify!(hop_limits)
+        )
+    );
+}
+impl Clone for rte_eth_ipv6_flow {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+///  A structure used to configure FDIR masks that are used by the device
+///  to match the various fields of RX packet headers.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_masks {
+    ///< Bit mask for vlan_tci in big endian
+    pub vlan_tci_mask: u16,
+    /// Bit mask for ipv4 flow in big endian.
+    pub ipv4_mask: rte_eth_ipv4_flow,
+    /// Bit maks for ipv6 flow in big endian.
+    pub ipv6_mask: rte_eth_ipv6_flow,
+    /// Bit mask for L4 source port in big endian.
+    pub src_port_mask: u16,
+    /// Bit mask for L4 destination port in big endian.
+    pub dst_port_mask: u16,
+    /// 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
+    ///first byte on the wire
+    pub mac_addr_byte_mask: u8,
+    /// Bit mask for tunnel ID in big endian.
+    pub tunnel_id_mask: u32,
+    ///< 1 - Match tunnel type,
+    ///0 - Ignore tunnel type.
+    pub tunnel_type_mask: u8,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_masks() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_masks> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_masks>(),
+        68usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_masks))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_masks>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_masks))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci_mask) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(vlan_tci_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ipv4_mask) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(ipv4_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ipv6_mask) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(ipv6_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_port_mask) as usize - ptr as usize
+        },
+        52usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(src_port_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dst_port_mask) as usize - ptr as usize
+        },
+        54usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(dst_port_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mac_addr_byte_mask) as usize -
+                ptr as usize
+        },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(mac_addr_byte_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tunnel_id_mask) as usize - ptr as usize
+        },
+        60usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(tunnel_id_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tunnel_type_mask) as usize -
+                ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_masks),
+            "::",
+            stringify!(tunnel_type_mask)
+        )
+    );
+}
+impl Clone for rte_eth_fdir_masks {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(u32)]
+/// Payload type
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum rte_eth_payload_type {
+    RTE_ETH_PAYLOAD_UNKNOWN = 0,
+    RTE_ETH_RAW_PAYLOAD = 1,
+    RTE_ETH_L2_PAYLOAD = 2,
+    RTE_ETH_L3_PAYLOAD = 3,
+    RTE_ETH_L4_PAYLOAD = 4,
+    RTE_ETH_PAYLOAD_MAX = 8,
+}
+/// A structure used to select bytes extracted from the protocol layers to
+/// flexible payload for filter
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_flex_payload_cfg {
+    ///< Payload type
+    pub type_: rte_eth_payload_type,
+    pub src_offset: [u16; 16usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_flex_payload_cfg() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_flex_payload_cfg> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_flex_payload_cfg>(),
+        36usize,
+        concat!("Size of: ", stringify!(rte_eth_flex_payload_cfg))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_flex_payload_cfg>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_flex_payload_cfg))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_flex_payload_cfg),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).src_offset) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_flex_payload_cfg),
+            "::",
+            stringify!(src_offset)
+        )
+    );
+}
+impl Clone for rte_eth_flex_payload_cfg {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_flex_payload_cfg {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+/// A structure used to define FDIR masks for flexible payload
+/// for each flow type
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_flex_mask {
+    pub flow_type: u16,
+    pub mask: [u8; 16usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_flex_mask() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_mask> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_flex_mask>(),
+        18usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_flex_mask))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_flex_mask>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_mask))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flow_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_mask),
+            "::",
+            stringify!(flow_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_mask),
+            "::",
+            stringify!(mask)
+        )
+    );
+}
+impl Clone for rte_eth_fdir_flex_mask {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+/// A structure used to define all flexible payload related setting
+/// include flex payload and flex mask
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_fdir_flex_conf {
+    ///< The number of following payload cfg
+    pub nb_payloads: u16,
+    ///< The number of following mask
+    pub nb_flexmasks: u16,
+    pub flex_set: [rte_eth_flex_payload_cfg; 8usize],
+    pub flex_mask: [rte_eth_fdir_flex_mask; 22usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_fdir_flex_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_fdir_flex_conf>(),
+        688usize,
+        concat!("Size of: ", stringify!(rte_eth_fdir_flex_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_fdir_flex_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_payloads) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(nb_payloads)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_flexmasks) as usize - ptr as usize
+        },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(nb_flexmasks)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_set) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(flex_set)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_mask) as usize - ptr as usize
+        },
+        292usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_fdir_flex_conf),
+            "::",
+            stringify!(flex_mask)
+        )
+    );
+}
+impl Clone for rte_eth_fdir_flex_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_fdir_flex_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+/// A structure used to configure the Flow Director (FDIR) feature
+/// of an Ethernet port.
+///
+/// If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct rte_fdir_conf {
+    ///< Flow Director mode.
+    pub mode: rte_fdir_mode,
+    ///< Space for FDIR filters.
+    pub pballoc: rte_fdir_pballoc_type,
+    ///< How to report FDIR hash.
+    pub status: rte_fdir_status_mode,
+    /// RX queue of packets matching a "drop" filter in perfect mode.
+    pub drop_queue: u8,
+    pub mask: rte_eth_fdir_masks,
+    pub flex_conf: rte_eth_fdir_flex_conf,
+}
+#[test]
+fn bindgen_test_layout_rte_fdir_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_fdir_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_fdir_conf>(),
+        772usize,
+        concat!("Size of: ", stringify!(rte_fdir_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_fdir_conf>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_fdir_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(mode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pballoc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(pballoc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(status)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).drop_queue) as usize - ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(drop_queue)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).flex_conf) as usize - ptr as usize
+        },
+        84usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_fdir_conf),
+            "::",
+            stringify!(flex_conf)
+        )
+    );
+}
+impl Clone for rte_fdir_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_fdir_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+/// A structure used to enable/disable specific device interrupts.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_intr_conf {
+    /// enable/disable lsc interrupt. 0 (default) - disable, 1 enable
+    pub lsc: u16,
+    /// enable/disable rxq interrupt. 0 (default) - disable, 1 enable
+    pub rxq: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_intr_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_intr_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_intr_conf>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_intr_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_intr_conf>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_intr_conf))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lsc) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_intr_conf),
+            "::",
+            stringify!(lsc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rxq) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_intr_conf),
+            "::",
+            stringify!(rxq)
+        )
+    );
+}
+impl Clone for rte_intr_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+/// A structure used to configure an Ethernet port.
+/// Depending upon the RX multi-queue mode, extra advanced
+/// configuration settings may be needed.
+#[repr(C)]
+#[derive(Copy)]
+pub struct rte_eth_conf {
+    ///< bitmap of ETH_LINK_SPEED_XXX of speeds to be
+    ///used. ETH_LINK_SPEED_FIXED disables link
+    ///autonegotiation, and a unique speed shall be
+    ///set. Otherwise, the bitmap defines the set of
+    ///speeds to be advertised. If the special value
+    ///ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
+    ///supported are advertised.
+    pub link_speeds: u32,
+    ///< Port RX configuration.
+    pub rxmode: rte_eth_rxmode,
+    ///< Port TX configuration.
+    pub txmode: rte_eth_txmode,
+    ///< Loopback operation mode. By default the value
+    ///is 0, meaning the loopback mode is disabled.
+    ///Read the datasheet of given ethernet controller
+    ///for details. The possible values of this field
+    ///are defined in implementation of each driver.
+    pub lpbk_mode: u32,
+    ///< Port RX filtering configuration (union).
+    pub rx_adv_conf: rte_eth_conf__bindgen_ty_1,
+    ///< Port TX DCB configuration (union).
+    pub tx_adv_conf: rte_eth_conf__bindgen_ty_2,
+    /// Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
+    ///is needed,and the variable must be set ETH_DCB_PFC_SUPPORT.
+    pub dcb_capability_en: u32,
+    ///< FDIR configuration.
+    pub fdir_conf: rte_fdir_conf,
+    ///< Interrupt mode configuration.
+    pub intr_conf: rte_intr_conf,
+}
+#[repr(C)]
+#[derive(Copy)]
+pub struct rte_eth_conf__bindgen_ty_1 {
+    ///< Port RSS configuration
+    pub rss_conf: rte_eth_rss_conf,
+    pub vmdq_dcb_conf: rte_eth_vmdq_dcb_conf,
+    pub dcb_rx_conf: rte_eth_dcb_rx_conf,
+    pub vmdq_rx_conf: rte_eth_vmdq_rx_conf,
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_1>(),
+        2120usize,
+        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rss_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(rss_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_dcb_conf) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(vmdq_dcb_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_rx_conf) as usize - ptr as usize
+        },
+        1064usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(dcb_rx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_rx_conf) as usize - ptr as usize
+        },
+        1080usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_1),
+            "::",
+            stringify!(vmdq_rx_conf)
+        )
+    );
+}
+impl Clone for rte_eth_conf__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_conf__bindgen_ty_1 {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_eth_conf__bindgen_ty_2 {
+    pub vmdq_dcb_tx_conf: __BindgenUnionField<rte_eth_vmdq_dcb_tx_conf>,
+    pub dcb_tx_conf: __BindgenUnionField<rte_eth_dcb_tx_conf>,
+    pub vmdq_tx_conf: __BindgenUnionField<rte_eth_vmdq_tx_conf>,
+    pub bindgen_union_field: [u32; 3usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_2>(),
+        12usize,
+        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_dcb_tx_conf) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(vmdq_dcb_tx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_tx_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(dcb_tx_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vmdq_tx_conf) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf__bindgen_ty_2),
+            "::",
+            stringify!(vmdq_tx_conf)
+        )
+    );
+}
+impl Clone for rte_eth_conf__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_eth_conf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_conf>(),
+        2944usize,
+        concat!("Size of: ", stringify!(rte_eth_conf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_conf>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_conf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).link_speeds) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(link_speeds)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rxmode) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(rxmode)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).txmode) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(txmode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).lpbk_mode) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(lpbk_mode)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rx_adv_conf) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(rx_adv_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tx_adv_conf) as usize - ptr as usize
+        },
+        2152usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(tx_adv_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).dcb_capability_en) as usize -
+                ptr as usize
+        },
+        2164usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(dcb_capability_en)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).fdir_conf) as usize - ptr as usize
+        },
+        2168usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(fdir_conf)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).intr_conf) as usize - ptr as usize
+        },
+        2940usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_conf),
+            "::",
+            stringify!(intr_conf)
+        )
+    );
+}
+impl Clone for rte_eth_conf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for rte_eth_conf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs
new file mode 100644
index 00000000..be88d20f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_kni_mbuf.rs
@@ -0,0 +1,209 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct rte_kni_mbuf {
+    pub buf_addr: *mut ::std::os::raw::c_void,
+    pub buf_physaddr: u64,
+    pub pad0: [::std::os::raw::c_char; 2usize],
+    ///< Start address of data in segment buffer.
+    pub data_off: u16,
+    pub pad1: [::std::os::raw::c_char; 2usize],
+    ///< Number of segments.
+    pub nb_segs: u8,
+    pub pad4: [::std::os::raw::c_char; 1usize],
+    ///< Offload features.
+    pub ol_flags: u64,
+    pub pad2: [::std::os::raw::c_char; 4usize],
+    ///< Total pkt len: sum of all segment data_len.
+    pub pkt_len: u32,
+    ///< Amount of data in segment buffer.
+    pub data_len: u16,
+    pub __bindgen_padding_0: [u8; 22usize],
+    pub pad3: [::std::os::raw::c_char; 8usize],
+    pub pool: *mut ::std::os::raw::c_void,
+    pub next: *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout_rte_kni_mbuf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_kni_mbuf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_kni_mbuf>(),
+        128usize,
+        concat!("Size of: ", stringify!(rte_kni_mbuf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_kni_mbuf>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_kni_mbuf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(buf_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(buf_physaddr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pad0) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pad0)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(data_off)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pad1) as usize - ptr as usize },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pad1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(nb_segs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pad4) as usize - ptr as usize },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pad4)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(ol_flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pad2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pkt_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(data_len)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pad3) as usize - ptr as usize },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pad3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(pool)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_mbuf),
+            "::",
+            stringify!(next)
+        )
+    );
+}
+impl Default for rte_kni_mbuf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs b/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs
new file mode 100644
index 00000000..075ef46a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_large_align_field.rs
@@ -0,0 +1,703 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4;
+pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX;
+pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX;
+pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM;
+pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    ///< index of last fragment
+    IP_LAST_FRAG_IDX = 0,
+    ///< index of first fragment
+    IP_FIRST_FRAG_IDX = 1,
+    ///< minimum number of fragments
+    IP_MIN_FRAG_NUM = 2,
+    IP_MAX_FRAG_NUM = 4,
+}
+/// @internal fragmented mbuf
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ip_frag {
+    ///< offset into the packet
+    pub ofs: u16,
+    ///< length of fragment
+    pub len: u16,
+    ///< fragment mbuf
+    pub mb: *mut rte_mbuf,
+}
+#[test]
+fn bindgen_test_layout_ip_frag() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag>(),
+        16usize,
+        concat!("Size of: ", stringify!(ip_frag))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ofs) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(ofs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(len)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mb) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag),
+            "::",
+            stringify!(mb)
+        )
+    );
+}
+impl Default for ip_frag {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ip_frag_key {
+    ///< src address, first 8 bytes used for IPv4
+    pub src_dst: [u64; 4usize],
+    ///< dst address
+    pub id: u32,
+    ///< src/dst key length
+    pub key_len: u32,
+}
+#[test]
+fn bindgen_test_layout_ip_frag_key() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_key> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_key>(),
+        40usize,
+        concat!("Size of: ", stringify!(ip_frag_key))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_key>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag_key))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).src_dst) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(src_dst)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).key_len) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_key),
+            "::",
+            stringify!(key_len)
+        )
+    );
+}
+/// @internal Fragmented packet to reassemble.
+/// First two entries in the frags[] array are for the last and first fragments.
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct ip_frag_pkt {
+    ///< LRU list
+    pub lru: ip_frag_pkt__bindgen_ty_1,
+    ///< fragmentation key
+    pub key: ip_frag_key,
+    ///< creation timestamp
+    pub start: u64,
+    ///< expected reassembled size
+    pub total_size: u32,
+    ///< size of fragments received
+    pub frag_size: u32,
+    ///< index of next entry to fill
+    pub last_idx: u32,
+    ///< fragments
+    pub frags: [ip_frag; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ip_frag_pkt__bindgen_ty_1 {
+    pub tqe_next: *mut ip_frag_pkt,
+    pub tqe_prev: *mut *mut ip_frag_pkt,
+}
+#[test]
+fn bindgen_test_layout_ip_frag_pkt__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>(),
+        16usize,
+        concat!("Size of: ", stringify!(ip_frag_pkt__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_frag_pkt__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqe_next) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt__bindgen_ty_1),
+            "::",
+            stringify!(tqe_next)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqe_prev) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt__bindgen_ty_1),
+            "::",
+            stringify!(tqe_prev)
+        )
+    );
+}
+impl Default for ip_frag_pkt__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_ip_frag_pkt() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_pkt>(),
+        192usize,
+        concat!("Size of: ", stringify!(ip_frag_pkt))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_pkt>(),
+        64usize,
+        concat!("Alignment of ", stringify!(ip_frag_pkt))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(lru)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(key)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(start)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(total_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).frag_size) as usize - ptr as usize
+        },
+        68usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(frag_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).last_idx) as usize - ptr as usize
+        },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(last_idx)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).frags) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_pkt),
+            "::",
+            stringify!(frags)
+        )
+    );
+}
+impl Default for ip_frag_pkt {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ip_pkt_list {
+    pub tqh_first: *mut ip_frag_pkt,
+    pub tqh_last: *mut *mut ip_frag_pkt,
+}
+#[test]
+fn bindgen_test_layout_ip_pkt_list() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_pkt_list> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_pkt_list>(),
+        16usize,
+        concat!("Size of: ", stringify!(ip_pkt_list))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_pkt_list>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ip_pkt_list))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqh_first) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_pkt_list),
+            "::",
+            stringify!(tqh_first)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tqh_last) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_pkt_list),
+            "::",
+            stringify!(tqh_last)
+        )
+    );
+}
+impl Default for ip_pkt_list {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// fragmentation table statistics
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct ip_frag_tbl_stat {
+    ///< total # of find/insert attempts.
+    pub find_num: u64,
+    ///< # of add ops.
+    pub add_num: u64,
+    ///< # of del ops.
+    pub del_num: u64,
+    ///< # of reuse (del/add) ops.
+    pub reuse_num: u64,
+    ///< total # of add failures.
+    pub fail_total: u64,
+    ///< # of 'no space' add failures.
+    pub fail_nospace: u64,
+}
+#[test]
+fn bindgen_test_layout_ip_frag_tbl_stat() {
+    const UNINIT: ::std::mem::MaybeUninit<ip_frag_tbl_stat> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ip_frag_tbl_stat>(),
+        64usize,
+        concat!("Size of: ", stringify!(ip_frag_tbl_stat))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ip_frag_tbl_stat>(),
+        64usize,
+        concat!("Alignment of ", stringify!(ip_frag_tbl_stat))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).find_num) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(find_num)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).add_num) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(add_num)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).del_num) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(del_num)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).reuse_num) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(reuse_num)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).fail_total) as usize - ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(fail_total)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).fail_nospace) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ip_frag_tbl_stat),
+            "::",
+            stringify!(fail_nospace)
+        )
+    );
+}
+impl Default for ip_frag_tbl_stat {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// fragmentation table
+#[repr(C)]
+#[repr(align(64))]
+pub struct rte_ip_frag_tbl {
+    ///< ttl for table entries.
+    pub max_cycles: u64,
+    ///< hash value mask.
+    pub entry_mask: u32,
+    ///< max entries allowed.
+    pub max_entries: u32,
+    ///< entries in use.
+    pub use_entries: u32,
+    ///< hash assocaitivity.
+    pub bucket_entries: u32,
+    ///< total size of the table.
+    pub nb_entries: u32,
+    ///< num of associativity lines.
+    pub nb_buckets: u32,
+    ///< last used entry.
+    pub last: *mut ip_frag_pkt,
+    ///< LRU list for table entries.
+    pub lru: ip_pkt_list,
+    pub __bindgen_padding_0: u64,
+    ///< statistics counters.
+    pub stat: ip_frag_tbl_stat,
+    ///< hash table.
+    pub pkt: __IncompleteArrayField<ip_frag_pkt>,
+}
+#[test]
+fn bindgen_test_layout_rte_ip_frag_tbl() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ip_frag_tbl> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ip_frag_tbl>(),
+        128usize,
+        concat!("Size of: ", stringify!(rte_ip_frag_tbl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ip_frag_tbl>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_ip_frag_tbl))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).max_cycles) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(max_cycles)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).entry_mask) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(entry_mask)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).max_entries) as usize - ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(max_entries)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).use_entries) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(use_entries)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).bucket_entries) as usize - ptr as usize
+        },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(bucket_entries)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_entries) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(nb_entries)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).nb_buckets) as usize - ptr as usize
+        },
+        28usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(nb_buckets)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(last)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(lru)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).stat) as usize - ptr as usize },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(stat)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pkt) as usize - ptr as usize },
+        128usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ip_frag_tbl),
+            "::",
+            stringify!(pkt)
+        )
+    );
+}
+impl Default for rte_ip_frag_tbl {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+///< fragment mbuf
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_mbuf {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs
new file mode 100644
index 00000000..800a303b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs
@@ -0,0 +1,1204 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+pub type phys_addr_t = u64;
+pub type MARKER = [*mut ::std::os::raw::c_void; 0usize];
+pub type MARKER8 = [u8; 0usize];
+pub type MARKER64 = [u64; 0usize];
+/// The atomic counter structure.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_atomic16_t {
+    ///< An internal counter value.
+    pub cnt: i16,
+}
+#[test]
+fn bindgen_test_layout_rte_atomic16_t() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_atomic16_t> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_atomic16_t>(),
+        2usize,
+        concat!("Size of: ", stringify!(rte_atomic16_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_atomic16_t>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_atomic16_t))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cnt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_atomic16_t),
+            "::",
+            stringify!(cnt)
+        )
+    );
+}
+/// The generic rte_mbuf, containing a packet mbuf.
+#[repr(C)]
+#[repr(align(64))]
+pub struct rte_mbuf {
+    pub cacheline0: MARKER,
+    ///< Virtual address of segment buffer.
+    pub buf_addr: *mut ::std::os::raw::c_void,
+    ///< Physical address of segment buffer.
+    pub buf_physaddr: phys_addr_t,
+    ///< Length of segment buffer.
+    pub buf_len: u16,
+    pub rearm_data: MARKER8,
+    pub data_off: u16,
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
+    ///< Number of segments.
+    pub nb_segs: u8,
+    ///< Input port.
+    pub port: u8,
+    ///< Offload features.
+    pub ol_flags: u64,
+    pub rx_descriptor_fields1: MARKER,
+    pub __bindgen_anon_2: rte_mbuf__bindgen_ty_2,
+    ///< Total pkt len: sum of all segments.
+    pub pkt_len: u32,
+    ///< Amount of data in segment buffer.
+    pub data_len: u16,
+    /// VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set.
+    pub vlan_tci: u16,
+    ///< hash information
+    pub hash: rte_mbuf__bindgen_ty_3,
+    ///< Sequence number. See also rte_reorder_insert()
+    pub seqn: u32,
+    /// Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set.
+    pub vlan_tci_outer: u16,
+    pub cacheline1: MARKER,
+    pub __bindgen_anon_3: rte_mbuf__bindgen_ty_4,
+    ///< Pool from which mbuf was allocated.
+    pub pool: *mut rte_mempool,
+    ///< Next segment of scattered packet.
+    pub next: *mut rte_mbuf,
+    pub __bindgen_anon_4: rte_mbuf__bindgen_ty_5,
+    /// Size of the application private data. In case of an indirect
+    /// mbuf, it stores the direct mbuf private data size.
+    pub priv_size: u16,
+    /// Timesync flags for use with IEEE1588.
+    pub timesync: u16,
+}
+/// 16-bit Reference counter.
+/// It should only be accessed using the following functions:
+/// rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
+/// rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
+/// or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
+/// config option.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_1 {
+    ///< Atomically accessed refcnt
+    pub refcnt_atomic: rte_atomic16_t,
+    ///< Non-atomically accessed refcnt
+    pub refcnt: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).refcnt_atomic) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_1),
+            "::",
+            stringify!(refcnt_atomic)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).refcnt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_1),
+            "::",
+            stringify!(refcnt)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_2 {
+    ///< L2/L3/L4 and tunnel information.
+    pub packet_type: u32,
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+}
+impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
+    #[inline]
+    pub fn l2_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l2_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l3_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l3_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l4_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l4_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tun_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_tun_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l2_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l2_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l3_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l3_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l4_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l4_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        l2_type: u32,
+        l3_type: u32,
+        l4_type: u32,
+        tun_type: u32,
+        inner_l2_type: u32,
+        inner_l3_type: u32,
+        inner_l4_type: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 4u8, {
+            let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
+            l2_type as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 4u8, {
+            let l3_type: u32 = unsafe { ::std::mem::transmute(l3_type) };
+            l3_type as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 4u8, {
+            let l4_type: u32 = unsafe { ::std::mem::transmute(l4_type) };
+            l4_type as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 4u8, {
+            let tun_type: u32 = unsafe { ::std::mem::transmute(tun_type) };
+            tun_type as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 4u8, {
+            let inner_l2_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l2_type) };
+            inner_l2_type as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 4u8, {
+            let inner_l3_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l3_type) };
+            inner_l3_type as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 4u8, {
+            let inner_l4_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l4_type) };
+            inner_l4_type as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).packet_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_2),
+            "::",
+            stringify!(packet_type)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_3 {
+    ///< RSS hash result if RSS enabled
+    pub rss: u32,
+    ///< Filter identifier if FDIR enabled
+    pub fdir: rte_mbuf__bindgen_ty_3__bindgen_ty_1,
+    ///< Hierarchical scheduler
+    pub sched: rte_mbuf__bindgen_ty_3__bindgen_ty_2,
+    ///< User defined tags. See rte_distributor_process()
+    pub usr: u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+    pub hi: u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
+    pub __bindgen_anon_1:
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
+    pub lo: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
+    pub hash: u16,
+    pub id: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
+) {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq ! (:: std :: mem :: size_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 4usize , concat ! ("Size of: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
+    assert_eq ! (:: std :: mem :: align_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 2usize , concat ! ("Alignment of " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
+    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hash) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (hash)));
+    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . id) as usize - ptr as usize } , 2usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (id)));
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<
+            rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+        >(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(lo)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1),
+            "::",
+            stringify!(hi)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
+    pub lo: u32,
+    pub hi: u32,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_2,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
+            "::",
+            stringify!(lo)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
+            "::",
+            stringify!(hi)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_3> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_3))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_3))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(rss)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).fdir) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(fdir)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sched) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(sched)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).usr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(usr)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_3 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_4 {
+    ///< Can be used for external metadata
+    pub userdata: *mut ::std::os::raw::c_void,
+    ///< Allow 8-byte userdata on 32-bit
+    pub udata64: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_4() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_4> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_4>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_4>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_4))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_4),
+            "::",
+            stringify!(userdata)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).udata64) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_4),
+            "::",
+            stringify!(udata64)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_4 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union rte_mbuf__bindgen_ty_5 {
+    ///< combined for easy fetch
+    pub tx_offload: u64,
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_5__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
+    pub _bitfield_align_1: [u16; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
+        )
+    );
+}
+impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
+    #[inline]
+    pub fn l2_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l2_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l3_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l3_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 9u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l4_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l4_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tso_segsz(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 16u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_tso_segsz(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 16u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn outer_l3_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(40usize, 9u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_outer_l3_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(40usize, 9u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn outer_l2_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(49usize, 7u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_outer_l2_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(49usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        l2_len: u64,
+        l3_len: u64,
+        l4_len: u64,
+        tso_segsz: u64,
+        outer_l3_len: u64,
+        outer_l2_len: u64,
+    ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 7u8, {
+            let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
+            l2_len as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 9u8, {
+            let l3_len: u64 = unsafe { ::std::mem::transmute(l3_len) };
+            l3_len as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 8u8, {
+            let l4_len: u64 = unsafe { ::std::mem::transmute(l4_len) };
+            l4_len as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 16u8, {
+            let tso_segsz: u64 = unsafe { ::std::mem::transmute(tso_segsz) };
+            tso_segsz as u64
+        });
+        __bindgen_bitfield_unit.set(40usize, 9u8, {
+            let outer_l3_len: u64 =
+                unsafe { ::std::mem::transmute(outer_l3_len) };
+            outer_l3_len as u64
+        });
+        __bindgen_bitfield_unit.set(49usize, 7u8, {
+            let outer_l2_len: u64 =
+                unsafe { ::std::mem::transmute(outer_l2_len) };
+            outer_l2_len as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_5() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_5> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_5))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_5))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tx_offload) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_5),
+            "::",
+            stringify!(tx_offload)
+        )
+    );
+}
+impl Default for rte_mbuf__bindgen_ty_5 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf>(),
+        128usize,
+        concat!("Size of: ", stringify!(rte_mbuf))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf>(),
+        64usize,
+        concat!("Alignment of ", stringify!(rte_mbuf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).cacheline0) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(cacheline0)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_physaddr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).buf_len) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rearm_data) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(rearm_data)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(data_off)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(nb_segs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(port)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(ol_flags)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rx_descriptor_fields1) as usize -
+                ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(rx_descriptor_fields1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(pkt_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(data_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci) as usize - ptr as usize
+        },
+        42usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(vlan_tci)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(hash)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).seqn) as usize - ptr as usize },
+        52usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(seqn)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci_outer) as usize - ptr as usize
+        },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(vlan_tci_outer)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).cacheline1) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(cacheline1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(pool)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(next)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).priv_size) as usize - ptr as usize
+        },
+        96usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(priv_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).timesync) as usize - ptr as usize
+        },
+        98usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(timesync)
+        )
+    );
+}
+impl Default for rte_mbuf {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+///< Pool from which mbuf was allocated.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct rte_mempool {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/layout_mbuf_1_0.rs b/bindgen-tests/tests/expectations/tests/layout_mbuf_1_0.rs
new file mode 100644
index 00000000..90f7ed09
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/layout_mbuf_1_0.rs
@@ -0,0 +1,1255 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
+pub const RTE_CACHE_LINE_SIZE: u32 = 64;
+pub type phys_addr_t = u64;
+pub type MARKER = [*mut ::std::os::raw::c_void; 0usize];
+pub type MARKER8 = [u8; 0usize];
+pub type MARKER64 = [u64; 0usize];
+/// The atomic counter structure.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_atomic16_t {
+    ///< An internal counter value.
+    pub cnt: i16,
+}
+#[test]
+fn bindgen_test_layout_rte_atomic16_t() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_atomic16_t> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_atomic16_t>(),
+        2usize,
+        concat!("Size of: ", stringify!(rte_atomic16_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_atomic16_t>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_atomic16_t))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cnt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_atomic16_t),
+            "::",
+            stringify!(cnt)
+        )
+    );
+}
+impl Clone for rte_atomic16_t {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+/// The generic rte_mbuf, containing a packet mbuf.
+#[repr(C)]
+pub struct rte_mbuf {
+    pub cacheline0: MARKER,
+    ///< Virtual address of segment buffer.
+    pub buf_addr: *mut ::std::os::raw::c_void,
+    ///< Physical address of segment buffer.
+    pub buf_physaddr: phys_addr_t,
+    ///< Length of segment buffer.
+    pub buf_len: u16,
+    pub rearm_data: MARKER8,
+    pub data_off: u16,
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
+    ///< Number of segments.
+    pub nb_segs: u8,
+    ///< Input port.
+    pub port: u8,
+    ///< Offload features.
+    pub ol_flags: u64,
+    pub rx_descriptor_fields1: MARKER,
+    pub __bindgen_anon_2: rte_mbuf__bindgen_ty_2,
+    ///< Total pkt len: sum of all segments.
+    pub pkt_len: u32,
+    ///< Amount of data in segment buffer.
+    pub data_len: u16,
+    /// VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set.
+    pub vlan_tci: u16,
+    ///< hash information
+    pub hash: rte_mbuf__bindgen_ty_3,
+    ///< Sequence number. See also rte_reorder_insert()
+    pub seqn: u32,
+    /// Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set.
+    pub vlan_tci_outer: u16,
+    pub cacheline1: MARKER,
+    pub __bindgen_anon_3: rte_mbuf__bindgen_ty_4,
+    ///< Pool from which mbuf was allocated.
+    pub pool: *mut rte_mempool,
+    ///< Next segment of scattered packet.
+    pub next: *mut rte_mbuf,
+    pub __bindgen_anon_4: rte_mbuf__bindgen_ty_5,
+    /// Size of the application private data. In case of an indirect
+    /// mbuf, it stores the direct mbuf private data size.
+    pub priv_size: u16,
+    /// Timesync flags for use with IEEE1588.
+    pub timesync: u16,
+    pub __bindgen_padding_0: [u32; 7usize],
+}
+/// 16-bit Reference counter.
+/// It should only be accessed using the following functions:
+/// rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
+/// rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
+/// or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
+/// config option.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_1 {
+    ///< Atomically accessed refcnt
+    pub refcnt_atomic: __BindgenUnionField<rte_atomic16_t>,
+    ///< Non-atomically accessed refcnt
+    pub refcnt: __BindgenUnionField<u16>,
+    pub bindgen_union_field: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).refcnt_atomic) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_1),
+            "::",
+            stringify!(refcnt_atomic)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).refcnt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_1),
+            "::",
+            stringify!(refcnt)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_2 {
+    ///< L2/L3/L4 and tunnel information.
+    pub packet_type: __BindgenUnionField<u32>,
+    pub __bindgen_anon_1:
+        __BindgenUnionField<rte_mbuf__bindgen_ty_2__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+    pub __bindgen_align: [u32; 0usize],
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
+    #[inline]
+    pub fn l2_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l2_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l3_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l3_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l4_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_l4_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tun_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_tun_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l2_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l2_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l3_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l3_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn inner_l4_type(&self) -> u32 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_inner_l4_type(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        l2_type: u32,
+        l3_type: u32,
+        l4_type: u32,
+        tun_type: u32,
+        inner_l2_type: u32,
+        inner_l3_type: u32,
+        inner_l4_type: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 4u8, {
+            let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
+            l2_type as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 4u8, {
+            let l3_type: u32 = unsafe { ::std::mem::transmute(l3_type) };
+            l3_type as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 4u8, {
+            let l4_type: u32 = unsafe { ::std::mem::transmute(l4_type) };
+            l4_type as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 4u8, {
+            let tun_type: u32 = unsafe { ::std::mem::transmute(tun_type) };
+            tun_type as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 4u8, {
+            let inner_l2_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l2_type) };
+            inner_l2_type as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 4u8, {
+            let inner_l3_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l3_type) };
+            inner_l3_type as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 4u8, {
+            let inner_l4_type: u32 =
+                unsafe { ::std::mem::transmute(inner_l4_type) };
+            inner_l4_type as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).packet_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_2),
+            "::",
+            stringify!(packet_type)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3 {
+    ///< RSS hash result if RSS enabled
+    pub rss: __BindgenUnionField<u32>,
+    ///< Filter identifier if FDIR enabled
+    pub fdir: __BindgenUnionField<rte_mbuf__bindgen_ty_3__bindgen_ty_1>,
+    ///< Hierarchical scheduler
+    pub sched: __BindgenUnionField<rte_mbuf__bindgen_ty_3__bindgen_ty_2>,
+    ///< User defined tags. See rte_distributor_process()
+    pub usr: __BindgenUnionField<u32>,
+    pub bindgen_union_field: [u32; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
+    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+    pub hi: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
+    pub __bindgen_anon_1: __BindgenUnionField<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
+    >,
+    pub lo: __BindgenUnionField<u32>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
+    pub hash: u16,
+    pub id: u16,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
+) {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq ! (:: std :: mem :: size_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 4usize , concat ! ("Size of: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
+    assert_eq ! (:: std :: mem :: align_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 2usize , concat ! ("Alignment of " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
+    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hash) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (hash)));
+    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . id) as usize - ptr as usize } , 2usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (id)));
+}
+impl Clone
+    for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
+{
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<
+            rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
+        >(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(lo)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_1,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1),
+            "::",
+            stringify!(hi)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
+    pub lo: u32,
+    pub hi: u32,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        rte_mbuf__bindgen_ty_3__bindgen_ty_2,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
+            "::",
+            stringify!(lo)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
+            "::",
+            stringify!(hi)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_3() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_3> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_3))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_3))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rss) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(rss)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).fdir) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(fdir)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sched) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(sched)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).usr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_3),
+            "::",
+            stringify!(usr)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_3 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_4 {
+    ///< Can be used for external metadata
+    pub userdata: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    ///< Allow 8-byte userdata on 32-bit
+    pub udata64: __BindgenUnionField<u64>,
+    pub bindgen_union_field: u64,
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_4() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_4> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_4>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_4>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_4))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_4),
+            "::",
+            stringify!(userdata)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).udata64) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_4),
+            "::",
+            stringify!(udata64)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_4 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_5 {
+    ///< combined for easy fetch
+    pub tx_offload: __BindgenUnionField<u64>,
+    pub __bindgen_anon_1:
+        __BindgenUnionField<rte_mbuf__bindgen_ty_5__bindgen_ty_1>,
+    pub bindgen_union_field: u64,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
+    pub _bitfield_align_1: [u16; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
+    pub __bindgen_align: [u64; 0usize],
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Size of: ",
+            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
+    #[inline]
+    pub fn l2_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l2_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l3_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l3_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 9u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn l4_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_l4_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn tso_segsz(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(24usize, 16u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_tso_segsz(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 16u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn outer_l3_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(40usize, 9u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_outer_l3_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(40usize, 9u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn outer_l2_len(&self) -> u64 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(49usize, 7u8) as u64)
+        }
+    }
+    #[inline]
+    pub fn set_outer_l2_len(&mut self, val: u64) {
+        unsafe {
+            let val: u64 = ::std::mem::transmute(val);
+            self._bitfield_1.set(49usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        l2_len: u64,
+        l3_len: u64,
+        l4_len: u64,
+        tso_segsz: u64,
+        outer_l3_len: u64,
+        outer_l2_len: u64,
+    ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 7u8, {
+            let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
+            l2_len as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 9u8, {
+            let l3_len: u64 = unsafe { ::std::mem::transmute(l3_len) };
+            l3_len as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 8u8, {
+            let l4_len: u64 = unsafe { ::std::mem::transmute(l4_len) };
+            l4_len as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 16u8, {
+            let tso_segsz: u64 = unsafe { ::std::mem::transmute(tso_segsz) };
+            tso_segsz as u64
+        });
+        __bindgen_bitfield_unit.set(40usize, 9u8, {
+            let outer_l3_len: u64 =
+                unsafe { ::std::mem::transmute(outer_l3_len) };
+            outer_l3_len as u64
+        });
+        __bindgen_bitfield_unit.set(49usize, 7u8, {
+            let outer_l2_len: u64 =
+                unsafe { ::std::mem::transmute(outer_l2_len) };
+            outer_l2_len as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf__bindgen_ty_5() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_5> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_5))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_5))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).tx_offload) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf__bindgen_ty_5),
+            "::",
+            stringify!(tx_offload)
+        )
+    );
+}
+impl Clone for rte_mbuf__bindgen_ty_5 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_rte_mbuf() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_mbuf>(),
+        128usize,
+        concat!("Size of: ", stringify!(rte_mbuf))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).cacheline0) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(cacheline0)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_addr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_physaddr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).buf_len) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(buf_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rearm_data) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(rearm_data)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(data_off)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(nb_segs)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(port)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(ol_flags)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).rx_descriptor_fields1) as usize -
+                ptr as usize
+        },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(rx_descriptor_fields1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(pkt_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(data_len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci) as usize - ptr as usize
+        },
+        42usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(vlan_tci)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(hash)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).seqn) as usize - ptr as usize },
+        52usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(seqn)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).vlan_tci_outer) as usize - ptr as usize
+        },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(vlan_tci_outer)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).cacheline1) as usize - ptr as usize
+        },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(cacheline1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(pool)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(next)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).priv_size) as usize - ptr as usize
+        },
+        96usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(priv_size)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).timesync) as usize - ptr as usize
+        },
+        98usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_mbuf),
+            "::",
+            stringify!(timesync)
+        )
+    );
+}
+impl Default for rte_mbuf {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+///< Pool from which mbuf was allocated.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct rte_mempool {
+    pub _address: u8,
+}
+impl Clone for rte_mempool {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/abi_variadic_function.rs b/bindgen-tests/tests/expectations/tests/libclang-5/abi_variadic_function.rs
new file mode 100644
index 00000000..6aeb16f2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/abi_variadic_function.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z1bcz"]
+    pub fn b(arg1: ::std::os::raw::c_char, ...) -> ::std::os::raw::c_char;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/auto.rs b/bindgen-tests/tests/expectations/tests/libclang-5/auto.rs
new file mode 100644
index 00000000..0b20b39e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/auto.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub const Foo_kFoo: bool = true;
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5Test2v"]
+    pub fn Test2() -> ::std::os::raw::c_uint;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/call-conv-field.rs b/bindgen-tests/tests/expectations/tests/libclang-5/call-conv-field.rs
new file mode 100644
index 00000000..62b5ace2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/call-conv-field.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(test))]
+
+#[repr(C)]
+#[derive(Default, Copy, Clone)]
+pub struct JNINativeInterface_ {
+    pub GetVersion: ::std::option::Option<
+        unsafe extern "stdcall" fn(
+            env: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+    >,
+    pub __hack: ::std::os::raw::c_ulonglong,
+}
+#[test]
+fn bindgen_test_layout_JNINativeInterface_() {
+    const UNINIT: ::std::mem::MaybeUninit<JNINativeInterface_> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<JNINativeInterface_>(),
+        16usize,
+        concat!("Size of: ", stringify!(JNINativeInterface_))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<JNINativeInterface_>(),
+        8usize,
+        concat!("Alignment of ", stringify!(JNINativeInterface_))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).GetVersion) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JNINativeInterface_),
+            "::",
+            stringify!(GetVersion)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).__hack) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JNINativeInterface_),
+            "::",
+            stringify!(__hack)
+        )
+    );
+}
+extern "stdcall" {
+    pub fn bar();
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/const_bool.rs b/bindgen-tests/tests/expectations/tests/libclang-5/const_bool.rs
new file mode 100644
index 00000000..97e1d8dd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/const_bool.rs
@@ -0,0 +1,29 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const k: bool = true;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _address: u8,
+}
+pub const A_k: bool = false;
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
+pub type foo = bool;
+pub const k2: foo = true;
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/constant-evaluate.rs b/bindgen-tests/tests/expectations/tests/libclang-5/constant-evaluate.rs
new file mode 100644
index 00000000..9debe39d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/constant-evaluate.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo;
+pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    foo = 4,
+    bar = 8,
+}
+pub type EasyToOverflow = ::std::os::raw::c_ulonglong;
+pub const k: EasyToOverflow = 2147483648;
+pub const k_expr: EasyToOverflow = 1152921504606846976;
+pub const wow: EasyToOverflow = 2147483648;
+pub const BAZ: ::std::os::raw::c_longlong = 24;
+pub const fuzz: f64 = 51.0;
+pub const BAZZ: ::std::os::raw::c_char = 53;
+pub const WAT: ::std::os::raw::c_char = 0;
+pub const bytestring: &[u8; 4usize] = b"Foo\0";
+pub const NOT_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs b/bindgen-tests/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
new file mode 100644
index 00000000..57878592
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![allow(overflowing_literals)]
+
+pub const a: u32 = 4294967291;
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs b/bindgen-tests/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
new file mode 100644
index 00000000..60857966
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
@@ -0,0 +1,67 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct Rooted<T> {
+        pub member: T,
+        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    }
+    impl<T> Default for Rooted<T> {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+    pub type AutoValueVector_Alias = ::std::os::raw::c_int;
+    #[test]
+    fn __bindgen_test_layout_Rooted_open0_int_close0_instantiation() {
+        assert_eq!(
+            ::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>(),
+            4usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::Rooted<::std::os::raw::c_int>)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>(),
+            4usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::Rooted<::std::os::raw::c_int>)
+            )
+        );
+    }
+    #[test]
+    fn __bindgen_test_layout_Rooted_open0_AutoValueVector_Alias_close0_instantiation(
+    ) {
+        assert_eq!(
+            ::std::mem::size_of::<root::Rooted<root::AutoValueVector_Alias>>(),
+            4usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::Rooted<root::AutoValueVector_Alias>)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::Rooted<root::AutoValueVector_Alias>>(),
+            4usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::Rooted<root::AutoValueVector_Alias>)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/mangling-win32.rs b/bindgen-tests/tests/expectations/tests/libclang-5/mangling-win32.rs
new file mode 100644
index 00000000..0aee3274
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/mangling-win32.rs
@@ -0,0 +1,52 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "fastcall" {
+    pub fn fast_call_func_no_args() -> ::std::os::raw::c_int;
+}
+extern "fastcall" {
+    pub fn fast_call_func_many_args(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+extern "stdcall" {
+    pub fn std_call_func_no_args() -> ::std::os::raw::c_int;
+}
+extern "stdcall" {
+    pub fn std_call_func_many_args(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/objc_inheritance.rs b/bindgen-tests/tests/expectations/tests/libclang-5/objc_inheritance.rs
new file mode 100644
index 00000000..f1c2a88c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/objc_inheritance.rs
@@ -0,0 +1,116 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar(pub id);
+impl std::ops::Deref for Bar {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Bar {}
+impl Bar {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Bar), alloc) })
+    }
+}
+impl IFoo for Bar {}
+impl From<Bar> for Foo {
+    fn from(child: Bar) -> Foo {
+        Foo(child.0)
+    }
+}
+impl std::convert::TryFrom<Foo> for Bar {
+    type Error = &'static str;
+    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
+        if is_kind_of {
+            Ok(Bar(parent.0))
+        } else {
+            Err("This Foo cannot be downcasted to Bar")
+        }
+    }
+}
+impl IBar for Bar {}
+pub trait IBar: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Baz(pub id);
+impl std::ops::Deref for Baz {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Baz {}
+impl Baz {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Baz), alloc) })
+    }
+}
+impl IBar for Baz {}
+impl From<Baz> for Bar {
+    fn from(child: Baz) -> Bar {
+        Bar(child.0)
+    }
+}
+impl std::convert::TryFrom<Bar> for Baz {
+    type Error = &'static str;
+    fn try_from(parent: Bar) -> Result<Baz, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
+        if is_kind_of {
+            Ok(Baz(parent.0))
+        } else {
+            Err("This Bar cannot be downcasted to Baz")
+        }
+    }
+}
+impl IFoo for Baz {}
+impl From<Baz> for Foo {
+    fn from(child: Baz) -> Foo {
+        Foo(child.0)
+    }
+}
+impl std::convert::TryFrom<Foo> for Baz {
+    type Error = &'static str;
+    fn try_from(parent: Foo) -> Result<Baz, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
+        if is_kind_of {
+            Ok(Baz(parent.0))
+        } else {
+            Err("This Foo cannot be downcasted to Baz")
+        }
+    }
+}
+impl IBaz for Baz {}
+pub trait IBaz: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/objc_template.rs b/bindgen-tests/tests/expectations/tests/libclang-5/objc_template.rs
new file mode 100644
index 00000000..53caa661
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/objc_template.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
+pub trait IFoo<ObjectType: 'static>: Sized + std::ops::Deref {
+    unsafe fn get(&self) -> *mut ObjectType
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, get)
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct FooMultiGeneric(pub id);
+impl std::ops::Deref for FooMultiGeneric {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for FooMultiGeneric {}
+impl FooMultiGeneric {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(FooMultiGeneric), alloc) })
+    }
+}
+impl<KeyType: 'static, ObjectType: 'static>
+    IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric
+{
+}
+pub trait IFooMultiGeneric<KeyType: 'static, ObjectType: 'static>:
+    Sized + std::ops::Deref
+{
+    unsafe fn objectForKey_(&self, key: *mut KeyType) -> *mut ObjectType
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, objectForKey: key)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs b/bindgen-tests/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
new file mode 100644
index 00000000..e62ea681
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Base {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Derived {
+    pub b: bool,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Usage {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN5Usage13static_memberE"]
+    pub static mut Usage_static_member: [u32; 2usize];
+}
+#[test]
+fn bindgen_test_layout_Usage() {
+    assert_eq!(
+        ::std::mem::size_of::<Usage>(),
+        1usize,
+        concat!("Size of: ", stringify!(Usage))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Usage>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Usage))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs b/bindgen-tests/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
new file mode 100644
index 00000000..19f8881d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted {
+    pub ptr: MaybeWrapped<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_Rooted() {
+    const UNINIT: ::std::mem::MaybeUninit<Rooted> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Rooted>(),
+        4usize,
+        concat!("Size of: ", stringify!(Rooted))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Rooted>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Rooted))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Rooted),
+            "::",
+            stringify!(ptr)
+        )
+    );
+}
+impl Default for Rooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// <div rustbindgen replaces="MaybeWrapped"></div>
+pub type MaybeWrapped<a> = a;
+#[test]
+fn __bindgen_test_layout_MaybeWrapped_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<MaybeWrapped<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(MaybeWrapped<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MaybeWrapped<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(MaybeWrapped<::std::os::raw::c_int>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/abi_variadic_function.rs b/bindgen-tests/tests/expectations/tests/libclang-9/abi_variadic_function.rs
new file mode 100644
index 00000000..6aeb16f2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/abi_variadic_function.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z1bcz"]
+    pub fn b(arg1: ::std::os::raw::c_char, ...) -> ::std::os::raw::c_char;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/auto.rs b/bindgen-tests/tests/expectations/tests/libclang-9/auto.rs
new file mode 100644
index 00000000..0b20b39e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/auto.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub const Foo_kFoo: bool = true;
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_Z5Test2v"]
+    pub fn Test2() -> ::std::os::raw::c_uint;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/call-conv-field.rs b/bindgen-tests/tests/expectations/tests/libclang-9/call-conv-field.rs
new file mode 100644
index 00000000..62b5ace2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/call-conv-field.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(test))]
+
+#[repr(C)]
+#[derive(Default, Copy, Clone)]
+pub struct JNINativeInterface_ {
+    pub GetVersion: ::std::option::Option<
+        unsafe extern "stdcall" fn(
+            env: *mut ::std::os::raw::c_void,
+        ) -> ::std::os::raw::c_int,
+    >,
+    pub __hack: ::std::os::raw::c_ulonglong,
+}
+#[test]
+fn bindgen_test_layout_JNINativeInterface_() {
+    const UNINIT: ::std::mem::MaybeUninit<JNINativeInterface_> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<JNINativeInterface_>(),
+        16usize,
+        concat!("Size of: ", stringify!(JNINativeInterface_))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<JNINativeInterface_>(),
+        8usize,
+        concat!("Alignment of ", stringify!(JNINativeInterface_))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).GetVersion) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JNINativeInterface_),
+            "::",
+            stringify!(GetVersion)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).__hack) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JNINativeInterface_),
+            "::",
+            stringify!(__hack)
+        )
+    );
+}
+extern "stdcall" {
+    pub fn bar();
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/class.rs b/bindgen-tests/tests/expectations/tests/libclang-9/class.rs
new file mode 100644
index 00000000..0d64a9ff
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/class.rs
@@ -0,0 +1,691 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct C {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        40usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(big_array)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct C_with_zero_length_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for C_with_incomplete_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array_2),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_zero_length_array_and_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        C_with_zero_length_array_and_incomplete_array,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
+        40usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array_and_incomplete_array {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_and_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        C_with_zero_length_array_and_incomplete_array_2,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct WithDtor {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDtor>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDtor>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDtor),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+pub struct IncompleteArrayNonCopiable {
+    pub whatever: *mut ::std::os::raw::c_void,
+    pub incomplete_array: __IncompleteArrayField<C>,
+}
+#[test]
+fn bindgen_test_layout_IncompleteArrayNonCopiable() {
+    const UNINIT: ::std::mem::MaybeUninit<IncompleteArrayNonCopiable> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(IncompleteArrayNonCopiable),
+            "::",
+            stringify!(whatever)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(IncompleteArrayNonCopiable),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for IncompleteArrayNonCopiable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Union {
+    pub d: f32,
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Union() {
+    const UNINIT: ::std::mem::MaybeUninit<Union> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Union>(),
+        4usize,
+        concat!("Size of: ", stringify!(Union))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Union>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Union))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
+    );
+}
+impl Default for Union {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct WithUnion {
+    pub data: Union,
+}
+#[test]
+fn bindgen_test_layout_WithUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithUnion>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithUnion>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithUnion),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Default for WithUnion {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct RealAbstractionWithTonsOfMethods {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!(
+            "Alignment of ",
+            stringify!(RealAbstractionWithTonsOfMethods)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar(
+        this: *const RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar1(
+        this: *mut RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
+    pub fn RealAbstractionWithTonsOfMethods_bar2(
+        this: *mut RealAbstractionWithTonsOfMethods,
+        foo: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
+    pub fn RealAbstractionWithTonsOfMethods_sta();
+}
+impl RealAbstractionWithTonsOfMethods {
+    #[inline]
+    pub unsafe fn bar(&self) {
+        RealAbstractionWithTonsOfMethods_bar(self)
+    }
+    #[inline]
+    pub unsafe fn bar1(&mut self) {
+        RealAbstractionWithTonsOfMethods_bar1(self)
+    }
+    #[inline]
+    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
+        RealAbstractionWithTonsOfMethods_bar2(self, foo)
+    }
+    #[inline]
+    pub unsafe fn sta() {
+        RealAbstractionWithTonsOfMethods_sta()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/class_1_0.rs b/bindgen-tests/tests/expectations/tests/libclang-9/class_1_0.rs
new file mode 100644
index 00000000..e8c2e077
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/class_1_0.rs
@@ -0,0 +1,742 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Copy)]
+pub struct C {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        40usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(big_array)
+        )
+    );
+}
+impl Clone for C {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for C {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl ::std::cmp::PartialEq for C {
+    fn eq(&self, other: &C) -> bool {
+        self.a == other.a && &self.big_array[..] == &other.big_array[..]
+    }
+}
+#[repr(C)]
+pub struct C_with_zero_length_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array>(),
+        40usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for C_with_incomplete_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_incomplete_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_incomplete_array_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_incomplete_array_2),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+#[repr(C)]
+pub struct C_with_zero_length_array_and_incomplete_array {
+    pub a: ::std::os::raw::c_int,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        C_with_zero_length_array_and_incomplete_array,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
+        40usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(big_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        37usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for C_with_zero_length_array_and_incomplete_array {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct C_with_zero_length_array_and_incomplete_array_2 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        C_with_zero_length_array_and_incomplete_array_2,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
+        ),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C_with_zero_length_array_and_incomplete_array_2),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Hash, PartialEq, Eq)]
+pub struct WithDtor {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDtor>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDtor>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDtor),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+pub struct IncompleteArrayNonCopiable {
+    pub whatever: *mut ::std::os::raw::c_void,
+    pub incomplete_array: __IncompleteArrayField<C>,
+}
+#[test]
+fn bindgen_test_layout_IncompleteArrayNonCopiable() {
+    const UNINIT: ::std::mem::MaybeUninit<IncompleteArrayNonCopiable> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(IncompleteArrayNonCopiable),
+            "::",
+            stringify!(whatever)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(IncompleteArrayNonCopiable),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+impl Default for IncompleteArrayNonCopiable {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct Union {
+    pub d: __BindgenUnionField<f32>,
+    pub i: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_Union() {
+    const UNINIT: ::std::mem::MaybeUninit<Union> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Union>(),
+        4usize,
+        concat!("Size of: ", stringify!(Union))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Union>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Union))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
+    );
+}
+impl Clone for Union {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct WithUnion {
+    pub data: Union,
+}
+#[test]
+fn bindgen_test_layout_WithUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithUnion>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithUnion>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithUnion),
+            "::",
+            stringify!(data)
+        )
+    );
+}
+impl Clone for WithUnion {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct RealAbstractionWithTonsOfMethods {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
+    assert_eq!(
+        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
+        1usize,
+        concat!(
+            "Alignment of ",
+            stringify!(RealAbstractionWithTonsOfMethods)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar(
+        this: *const RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
+    pub fn RealAbstractionWithTonsOfMethods_bar1(
+        this: *mut RealAbstractionWithTonsOfMethods,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
+    pub fn RealAbstractionWithTonsOfMethods_bar2(
+        this: *mut RealAbstractionWithTonsOfMethods,
+        foo: ::std::os::raw::c_int,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
+    pub fn RealAbstractionWithTonsOfMethods_sta();
+}
+impl Clone for RealAbstractionWithTonsOfMethods {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl RealAbstractionWithTonsOfMethods {
+    #[inline]
+    pub unsafe fn bar(&self) {
+        RealAbstractionWithTonsOfMethods_bar(self)
+    }
+    #[inline]
+    pub unsafe fn bar1(&mut self) {
+        RealAbstractionWithTonsOfMethods_bar1(self)
+    }
+    #[inline]
+    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
+        RealAbstractionWithTonsOfMethods_bar2(self, foo)
+    }
+    #[inline]
+    pub unsafe fn sta() {
+        RealAbstractionWithTonsOfMethods_sta()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/const_bool.rs b/bindgen-tests/tests/expectations/tests/libclang-9/const_bool.rs
new file mode 100644
index 00000000..97e1d8dd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/const_bool.rs
@@ -0,0 +1,29 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const k: bool = true;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub _address: u8,
+}
+pub const A_k: bool = false;
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        1usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        1usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+}
+pub type foo = bool;
+pub const k2: foo = true;
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/constant-evaluate.rs b/bindgen-tests/tests/expectations/tests/libclang-9/constant-evaluate.rs
new file mode 100644
index 00000000..9debe39d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/constant-evaluate.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo;
+pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+    foo = 4,
+    bar = 8,
+}
+pub type EasyToOverflow = ::std::os::raw::c_ulonglong;
+pub const k: EasyToOverflow = 2147483648;
+pub const k_expr: EasyToOverflow = 1152921504606846976;
+pub const wow: EasyToOverflow = 2147483648;
+pub const BAZ: ::std::os::raw::c_longlong = 24;
+pub const fuzz: f64 = 51.0;
+pub const BAZZ: ::std::os::raw::c_char = 53;
+pub const WAT: ::std::os::raw::c_char = 0;
+pub const bytestring: &[u8; 4usize] = b"Foo\0";
+pub const NOT_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs b/bindgen-tests/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
new file mode 100644
index 00000000..2af22cc4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
@@ -0,0 +1,171 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test() {
+    const UNINIT: ::std::mem::MaybeUninit<test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<test>(),
+        4usize,
+        concat!("Size of: ", stringify!(test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(test), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(test),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test2 {
+    pub a: ::std::os::raw::c_int,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test2() {
+    const UNINIT: ::std::mem::MaybeUninit<test2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<test2>(),
+        4usize,
+        concat!("Size of: ", stringify!(test2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(test2), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(test2),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct test3 {
+    pub a: ::std::os::raw::c_int,
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_test3() {
+    const UNINIT: ::std::mem::MaybeUninit<test3> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<test3>(),
+        4usize,
+        concat!("Size of: ", stringify!(test3))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<test3>(),
+        4usize,
+        concat!("Alignment of ", stringify!(test3))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(test3), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(test3),
+            "::",
+            stringify!(zero_length_array)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
+                ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(test3),
+            "::",
+            stringify!(incomplete_array)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs b/bindgen-tests/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
new file mode 100644
index 00000000..57878592
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![allow(overflowing_literals)]
+
+pub const a: u32 = 4294967291;
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/incomplete-array-padding.rs b/bindgen-tests/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
new file mode 100644
index 00000000..1de963bf
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
@@ -0,0 +1,187 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct foo {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl foo {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_char {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_char) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: ::std::os::raw::c_char,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs b/bindgen-tests/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
new file mode 100644
index 00000000..ab402cfb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
@@ -0,0 +1,181 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct rte_ring {
+    pub memzone: *mut rte_memzone,
+    pub prod: rte_ring_prod,
+    pub cons: rte_ring_cons,
+    pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_ring_prod {
+    pub watermark: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_prod() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ring_prod> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring_prod>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ring_prod))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring_prod>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ring_prod))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).watermark) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring_prod),
+            "::",
+            stringify!(watermark)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_ring_cons {
+    pub sc_dequeue: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_cons() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ring_cons> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring_cons>(),
+        4usize,
+        concat!("Size of: ", stringify!(rte_ring_cons))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring_cons>(),
+        4usize,
+        concat!("Alignment of ", stringify!(rte_ring_cons))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).sc_dequeue) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring_cons),
+            "::",
+            stringify!(sc_dequeue)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_rte_ring() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_ring> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_ring>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_ring))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_ring>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_ring))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).memzone) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring),
+            "::",
+            stringify!(memzone)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).prod) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring),
+            "::",
+            stringify!(prod)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cons) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring),
+            "::",
+            stringify!(cons)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ring) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_ring),
+            "::",
+            stringify!(ring)
+        )
+    );
+}
+impl Default for rte_ring {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_memzone {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs b/bindgen-tests/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
new file mode 100644
index 00000000..60857966
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
@@ -0,0 +1,67 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct Rooted<T> {
+        pub member: T,
+        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    }
+    impl<T> Default for Rooted<T> {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+    pub type AutoValueVector_Alias = ::std::os::raw::c_int;
+    #[test]
+    fn __bindgen_test_layout_Rooted_open0_int_close0_instantiation() {
+        assert_eq!(
+            ::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>(),
+            4usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::Rooted<::std::os::raw::c_int>)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>(),
+            4usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::Rooted<::std::os::raw::c_int>)
+            )
+        );
+    }
+    #[test]
+    fn __bindgen_test_layout_Rooted_open0_AutoValueVector_Alias_close0_instantiation(
+    ) {
+        assert_eq!(
+            ::std::mem::size_of::<root::Rooted<root::AutoValueVector_Alias>>(),
+            4usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::Rooted<root::AutoValueVector_Alias>)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::Rooted<root::AutoValueVector_Alias>>(),
+            4usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::Rooted<root::AutoValueVector_Alias>)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/layout_align.rs b/bindgen-tests/tests/expectations/tests/libclang-9/layout_align.rs
new file mode 100644
index 00000000..f6a32704
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/layout_align.rs
@@ -0,0 +1,318 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct rte_kni_fifo {
+    ///< Next position to be written
+    pub write: ::std::os::raw::c_uint,
+    ///< Next position to be read
+    pub read: ::std::os::raw::c_uint,
+    ///< Circular buffer length
+    pub len: ::std::os::raw::c_uint,
+    ///< Pointer size - for 32/64 bit OS
+    pub elem_size: ::std::os::raw::c_uint,
+    ///< The buffer contains mbuf pointers
+    pub buffer: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+#[test]
+fn bindgen_test_layout_rte_kni_fifo() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_kni_fifo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_kni_fifo>(),
+        16usize,
+        concat!("Size of: ", stringify!(rte_kni_fifo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_kni_fifo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_kni_fifo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_fifo),
+            "::",
+            stringify!(write)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_fifo),
+            "::",
+            stringify!(read)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_fifo),
+            "::",
+            stringify!(len)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).elem_size) as usize - ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_fifo),
+            "::",
+            stringify!(elem_size)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_kni_fifo),
+            "::",
+            stringify!(buffer)
+        )
+    );
+}
+impl Default for rte_kni_fifo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct rte_eth_link {
+    ///< ETH_SPEED_NUM_
+    pub link_speed: u32,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_rte_eth_link() {
+    const UNINIT: ::std::mem::MaybeUninit<rte_eth_link> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<rte_eth_link>(),
+        8usize,
+        concat!("Size of: ", stringify!(rte_eth_link))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<rte_eth_link>(),
+        8usize,
+        concat!("Alignment of ", stringify!(rte_eth_link))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).link_speed) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(rte_eth_link),
+            "::",
+            stringify!(link_speed)
+        )
+    );
+}
+impl rte_eth_link {
+    #[inline]
+    pub fn link_duplex(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_duplex(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn link_autoneg(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_autoneg(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn link_status(&self) -> u16 {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_link_status(&mut self, val: u16) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        link_duplex: u16,
+        link_autoneg: u16,
+        link_status: u16,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let link_duplex: u16 =
+                unsafe { ::std::mem::transmute(link_duplex) };
+            link_duplex as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let link_autoneg: u16 =
+                unsafe { ::std::mem::transmute(link_autoneg) };
+            link_autoneg as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let link_status: u16 =
+                unsafe { ::std::mem::transmute(link_status) };
+            link_status as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/mangling-win32.rs b/bindgen-tests/tests/expectations/tests/libclang-9/mangling-win32.rs
new file mode 100644
index 00000000..0aee3274
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/mangling-win32.rs
@@ -0,0 +1,52 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "fastcall" {
+    pub fn fast_call_func_no_args() -> ::std::os::raw::c_int;
+}
+extern "fastcall" {
+    pub fn fast_call_func_many_args(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+extern "stdcall" {
+    pub fn std_call_func_no_args() -> ::std::os::raw::c_int;
+}
+extern "stdcall" {
+    pub fn std_call_func_many_args(
+        arg1: ::std::os::raw::c_int,
+        arg2: ::std::os::raw::c_int,
+        arg3: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/objc_inheritance.rs b/bindgen-tests/tests/expectations/tests/libclang-9/objc_inheritance.rs
new file mode 100644
index 00000000..f1c2a88c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/objc_inheritance.rs
@@ -0,0 +1,116 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar(pub id);
+impl std::ops::Deref for Bar {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Bar {}
+impl Bar {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Bar), alloc) })
+    }
+}
+impl IFoo for Bar {}
+impl From<Bar> for Foo {
+    fn from(child: Bar) -> Foo {
+        Foo(child.0)
+    }
+}
+impl std::convert::TryFrom<Foo> for Bar {
+    type Error = &'static str;
+    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
+        if is_kind_of {
+            Ok(Bar(parent.0))
+        } else {
+            Err("This Foo cannot be downcasted to Bar")
+        }
+    }
+}
+impl IBar for Bar {}
+pub trait IBar: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Baz(pub id);
+impl std::ops::Deref for Baz {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Baz {}
+impl Baz {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Baz), alloc) })
+    }
+}
+impl IBar for Baz {}
+impl From<Baz> for Bar {
+    fn from(child: Baz) -> Bar {
+        Bar(child.0)
+    }
+}
+impl std::convert::TryFrom<Bar> for Baz {
+    type Error = &'static str;
+    fn try_from(parent: Bar) -> Result<Baz, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
+        if is_kind_of {
+            Ok(Baz(parent.0))
+        } else {
+            Err("This Bar cannot be downcasted to Baz")
+        }
+    }
+}
+impl IFoo for Baz {}
+impl From<Baz> for Foo {
+    fn from(child: Baz) -> Foo {
+        Foo(child.0)
+    }
+}
+impl std::convert::TryFrom<Foo> for Baz {
+    type Error = &'static str;
+    fn try_from(parent: Foo) -> Result<Baz, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
+        if is_kind_of {
+            Ok(Baz(parent.0))
+        } else {
+            Err("This Foo cannot be downcasted to Baz")
+        }
+    }
+}
+impl IBaz for Baz {}
+pub trait IBaz: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/objc_template.rs b/bindgen-tests/tests/expectations/tests/libclang-9/objc_template.rs
new file mode 100644
index 00000000..3c615035
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/objc_template.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
+pub trait IFoo<ObjectType: 'static>: Sized + std::ops::Deref {
+    unsafe fn get(&self) -> u64
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, get)
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct FooMultiGeneric(pub id);
+impl std::ops::Deref for FooMultiGeneric {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for FooMultiGeneric {}
+impl FooMultiGeneric {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(FooMultiGeneric), alloc) })
+    }
+}
+impl<KeyType: 'static, ObjectType: 'static>
+    IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric
+{
+}
+pub trait IFooMultiGeneric<KeyType: 'static, ObjectType: 'static>:
+    Sized + std::ops::Deref
+{
+    unsafe fn objectForKey_(&self, key: u64) -> u64
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, objectForKey: key)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs b/bindgen-tests/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
new file mode 100644
index 00000000..e62ea681
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Base {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Derived {
+    pub b: bool,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Usage {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN5Usage13static_memberE"]
+    pub static mut Usage_static_member: [u32; 2usize];
+}
+#[test]
+fn bindgen_test_layout_Usage() {
+    assert_eq!(
+        ::std::mem::size_of::<Usage>(),
+        1usize,
+        concat!("Size of: ", stringify!(Usage))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Usage>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Usage))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs b/bindgen-tests/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
new file mode 100644
index 00000000..19f8881d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted {
+    pub ptr: MaybeWrapped<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_Rooted() {
+    const UNINIT: ::std::mem::MaybeUninit<Rooted> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Rooted>(),
+        4usize,
+        concat!("Size of: ", stringify!(Rooted))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Rooted>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Rooted))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Rooted),
+            "::",
+            stringify!(ptr)
+        )
+    );
+}
+impl Default for Rooted {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// <div rustbindgen replaces="MaybeWrapped"></div>
+pub type MaybeWrapped<a> = a;
+#[test]
+fn __bindgen_test_layout_MaybeWrapped_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<MaybeWrapped<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(MaybeWrapped<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MaybeWrapped<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(MaybeWrapped<::std::os::raw::c_int>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/zero-sized-array.rs b/bindgen-tests/tests/expectations/tests/libclang-9/zero-sized-array.rs
new file mode 100644
index 00000000..3066fac4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-9/zero-sized-array.rs
@@ -0,0 +1,185 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+/// Bizarrely enough, this should *not* get an `_address` field.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ZeroSizedArray {
+    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_ZeroSizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<ZeroSizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ZeroSizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ZeroSizedArray),
+            "::",
+            stringify!(arr)
+        )
+    );
+}
+/// And nor should this get an `_address` field.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ContainsZeroSizedArray {
+    pub zsa: ZeroSizedArray,
+}
+#[test]
+fn bindgen_test_layout_ContainsZeroSizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsZeroSizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ContainsZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ContainsZeroSizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).zsa) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsZeroSizedArray),
+            "::",
+            stringify!(zsa)
+        )
+    );
+}
+/// Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
+/// either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct InheritsZeroSizedArray {
+    pub _base: ZeroSizedArray,
+}
+#[test]
+fn bindgen_test_layout_InheritsZeroSizedArray() {
+    assert_eq!(
+        ::std::mem::size_of::<InheritsZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(InheritsZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(InheritsZeroSizedArray))
+    );
+}
+/// And this should not get an `_address` field either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct DynamicallySizedArray {
+    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DynamicallySizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<DynamicallySizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<DynamicallySizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(DynamicallySizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DynamicallySizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(DynamicallySizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(DynamicallySizedArray),
+            "::",
+            stringify!(arr)
+        )
+    );
+}
+/// No `_address` field here either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ContainsDynamicallySizedArray {
+    pub dsa: DynamicallySizedArray,
+}
+#[test]
+fn bindgen_test_layout_ContainsDynamicallySizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsDynamicallySizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsDynamicallySizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ContainsDynamicallySizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsDynamicallySizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ContainsDynamicallySizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).dsa) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsDynamicallySizedArray),
+            "::",
+            stringify!(dsa)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs b/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs
new file mode 100644
index 00000000..2643709c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang_version_specific_generated_tests.rs
@@ -0,0 +1,4 @@
+include!(concat!(
+    env!("OUT_DIR"),
+    "/libclang_version_specific_generated_tests.rs"
+));
diff --git a/bindgen-tests/tests/expectations/tests/long_double.rs b/bindgen-tests/tests/expectations/tests/long_double.rs
new file mode 100644
index 00000000..2c3b6c93
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/long_double.rs
@@ -0,0 +1,34 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {
+    pub bar: u128,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        16usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs
new file mode 100644
index 00000000..4eeb310c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const FOO: u32 = 1;
+pub const BAR: u32 = 4;
+pub const BAZ: u32 = 5;
+pub const MIN: i64 = -9223372036854775808;
+pub const BARR: u32 = 1;
+pub const BAZZ: u32 = 7;
+pub const I_RAN_OUT_OF_DUMB_NAMES: u32 = 7;
+pub const HAZ_A_COMMENT: u32 = 1;
+pub const HAZ_A_COMMENT_INSIDE: u32 = 2;
diff --git a/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs b/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs
new file mode 100644
index 00000000..b2f2ebd2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/macro-expr-uncommon-token.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const MODBUS_WOOT: u32 = 3;
+extern "C" {
+    pub fn foo();
+}
diff --git a/bindgen-tests/tests/expectations/tests/macro-redef.rs b/bindgen-tests/tests/expectations/tests/macro-redef.rs
new file mode 100644
index 00000000..ff5654f4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/macro-redef.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const FOO: u32 = 4;
+pub const BAR: u32 = 5;
+pub const BAZ: u32 = 6;
diff --git a/bindgen-tests/tests/expectations/tests/macro_const.rs b/bindgen-tests/tests/expectations/tests/macro_const.rs
new file mode 100644
index 00000000..de423a2a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/macro_const.rs
@@ -0,0 +1,14 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const foo: &[u8; 4usize] = b"bar\0";
+pub const CHAR: u8 = 98u8;
+pub const CHARR: u8 = 0u8;
+pub const FLOAT: f64 = 5.09;
+pub const FLOAT_EXPR: f64 = 0.005;
+pub const LONG: u32 = 3;
+pub const INVALID_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs
new file mode 100644
index 00000000..e1356611
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs
@@ -0,0 +1,14 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const foo: &'static [u8; 4usize] = b"bar\0";
+pub const CHAR: u8 = 98u8;
+pub const CHARR: u8 = 0u8;
+pub const FLOAT: f64 = 5.09;
+pub const FLOAT_EXPR: f64 = 0.005;
+pub const LONG: u32 = 3;
+pub const INVALID_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs b/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs
new file mode 100644
index 00000000..12157f4b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/maddness-is-avoidable.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct RefPtr {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct RefPtr_Proxy {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/mangling-ios.rs b/bindgen-tests/tests/expectations/tests/mangling-ios.rs
new file mode 100644
index 00000000..8a4ff657
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mangling-ios.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
diff --git a/bindgen-tests/tests/expectations/tests/mangling-linux32.rs b/bindgen-tests/tests/expectations/tests/mangling-linux32.rs
new file mode 100644
index 00000000..bddd7617
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mangling-linux32.rs
@@ -0,0 +1,32 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo4sBarE"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/mangling-linux64.rs b/bindgen-tests/tests/expectations/tests/mangling-linux64.rs
new file mode 100644
index 00000000..bddd7617
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mangling-linux64.rs
@@ -0,0 +1,32 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo4sBarE"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/mangling-macos.rs b/bindgen-tests/tests/expectations/tests/mangling-macos.rs
new file mode 100644
index 00000000..9af36259
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mangling-macos.rs
@@ -0,0 +1,32 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}__ZN3Foo4sBarE"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/mangling-win64.rs b/bindgen-tests/tests/expectations/tests/mangling-win64.rs
new file mode 100644
index 00000000..cb5f7103
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mangling-win64.rs
@@ -0,0 +1,32 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
+    pub static mut Foo_sBar: bool;
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/merge-extern-blocks.rs b/bindgen-tests/tests/expectations/tests/merge-extern-blocks.rs
new file mode 100644
index 00000000..66ceeff0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/merge-extern-blocks.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Point {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Point() {
+    const UNINIT: ::std::mem::MaybeUninit<Point> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Point>(),
+        4usize,
+        concat!("Size of: ", stringify!(Point))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Point>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Point))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
+    );
+}
+extern "C" {
+    pub fn foo() -> ::std::os::raw::c_int;
+    pub fn bar() -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/method-mangling.rs b/bindgen-tests/tests/expectations/tests/method-mangling.rs
new file mode 100644
index 00000000..e4627ac8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/method-mangling.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Foo4typeEv"]
+    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_int {
+        Foo_type(self)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/module-allowlisted.rs b/bindgen-tests/tests/expectations/tests/module-allowlisted.rs
new file mode 100644
index 00000000..30cdb358
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/module-allowlisted.rs
@@ -0,0 +1,30 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Test {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_Test() {
+        assert_eq!(
+            ::std::mem::size_of::<Test>(),
+            1usize,
+            concat!("Size of: ", stringify!(Test))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<Test>(),
+            1usize,
+            concat!("Alignment of ", stringify!(Test))
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs b/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs
new file mode 100644
index 00000000..64db43a6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/msvc-no-usr.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub foo: usize,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        8usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        8usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs b/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
new file mode 100644
index 00000000..55b3d1e3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Baz {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        1usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/mutable.rs b/bindgen-tests/tests/expectations/tests/mutable.rs
new file mode 100644
index 00000000..94c70326
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/mutable.rs
@@ -0,0 +1,124 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub m_member: ::std::os::raw::c_int,
+    pub m_other: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        8usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(m_member)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m_other) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(m_other)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NonCopiable {
+    pub m_member: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NonCopiable() {
+    const UNINIT: ::std::mem::MaybeUninit<NonCopiable> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NonCopiable>(),
+        4usize,
+        concat!("Size of: ", stringify!(NonCopiable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NonCopiable>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NonCopiable))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NonCopiable),
+            "::",
+            stringify!(m_member)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NonCopiableWithNonCopiableMutableMember {
+    pub m_member: NonCopiable,
+}
+#[test]
+fn bindgen_test_layout_NonCopiableWithNonCopiableMutableMember() {
+    const UNINIT: ::std::mem::MaybeUninit<
+        NonCopiableWithNonCopiableMutableMember,
+    > = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NonCopiableWithNonCopiableMutableMember>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(NonCopiableWithNonCopiableMutableMember)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NonCopiableWithNonCopiableMutableMember>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(NonCopiableWithNonCopiableMutableMember)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NonCopiableWithNonCopiableMutableMember),
+            "::",
+            stringify!(m_member)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/namespace.rs b/bindgen-tests/tests/expectations/tests/namespace.rs
new file mode 100644
index 00000000..49c8a7ef
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/namespace.rs
@@ -0,0 +1,130 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    extern "C" {
+        #[link_name = "\u{1}_Z9top_levelv"]
+        pub fn top_level();
+    }
+    pub mod whatever {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub type whatever_other_thing_t = whatever_int_t;
+        pub type whatever_int_t = ::std::os::raw::c_int;
+        extern "C" {
+            #[link_name = "\u{1}_ZN8whatever11in_whateverEv"]
+            pub fn in_whatever();
+        }
+    }
+    pub mod _bindgen_mod_id_17 {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct A {
+            pub b: root::whatever::whatever_int_t,
+        }
+        #[test]
+        fn bindgen_test_layout_A() {
+            const UNINIT: ::std::mem::MaybeUninit<A> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<A>(),
+                4usize,
+                concat!("Size of: ", stringify!(A))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<A>(),
+                4usize,
+                concat!("Alignment of ", stringify!(A))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(A),
+                    "::",
+                    stringify!(b)
+                )
+            );
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct C<T> {
+        pub _base: root::_bindgen_mod_id_17::A,
+        pub m_c: T,
+        pub m_c_ptr: *mut T,
+        pub m_c_arr: [T; 10usize],
+        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    }
+    impl<T> Default for C<T> {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+    pub mod w {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub type whatever_int_t = ::std::os::raw::c_uint;
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct D<T> {
+            pub m_c: root::C<T>,
+            pub _phantom_0:
+                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+        }
+        impl<T> Default for D<T> {
+            fn default() -> Self {
+                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                unsafe {
+                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                    s.assume_init()
+                }
+            }
+        }
+        extern "C" {
+            #[link_name = "\u{1}_ZN1w3hehEv"]
+            pub fn heh() -> root::w::whatever_int_t;
+        }
+        extern "C" {
+            #[link_name = "\u{1}_ZN1w3fooEv"]
+            pub fn foo() -> root::C<::std::os::raw::c_int>;
+        }
+        extern "C" {
+            #[link_name = "\u{1}_ZN1w4barrEv"]
+            pub fn barr() -> root::C<f32>;
+        }
+    }
+    pub mod foobar {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        extern "C" {
+            #[link_name = "\u{1}_ZN6foobar3fooEv"]
+            pub fn foo();
+        }
+    }
+    pub mod faraway {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        extern "C" {
+            #[link_name = "\u{1}_ZN7faraway3barEv"]
+            pub fn bar();
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs b/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs
new file mode 100644
index 00000000..ab761d28
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nested-template-typedef.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo_Bar {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/nested.rs b/bindgen-tests/tests/expectations/tests/nested.rs
new file mode 100644
index 00000000..415a7405
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nested.rs
@@ -0,0 +1,111 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Calc {
+    pub w: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Calc() {
+    const UNINIT: ::std::mem::MaybeUninit<Calc> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Calc>(),
+        4usize,
+        concat!("Size of: ", stringify!(Calc))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Calc>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Calc))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Calc), "::", stringify!(w))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test_Size {
+    pub mWidth: Test_Size_Dimension,
+    pub mHeight: Test_Size_Dimension,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test_Size_Dimension {
+    pub _base: Calc,
+}
+#[test]
+fn bindgen_test_layout_Test_Size_Dimension() {
+    assert_eq!(
+        ::std::mem::size_of::<Test_Size_Dimension>(),
+        4usize,
+        concat!("Size of: ", stringify!(Test_Size_Dimension))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test_Size_Dimension>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Test_Size_Dimension))
+    );
+}
+#[test]
+fn bindgen_test_layout_Test_Size() {
+    const UNINIT: ::std::mem::MaybeUninit<Test_Size> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test_Size>(),
+        8usize,
+        concat!("Size of: ", stringify!(Test_Size))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test_Size>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Test_Size))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mWidth) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Test_Size),
+            "::",
+            stringify!(mWidth)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mHeight) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Test_Size),
+            "::",
+            stringify!(mHeight)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        1usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/nested_vtable.rs b/bindgen-tests/tests/expectations/tests/nested_vtable.rs
new file mode 100644
index 00000000..7ee48304
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nested_vtable.rs
@@ -0,0 +1,99 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct nsISupports__bindgen_vtable {
+    pub nsISupports_QueryInterface:
+        unsafe extern "C" fn(this: *mut nsISupports) -> *mut nsISupports,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsISupports {
+    pub vtable_: *const nsISupports__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_nsISupports() {
+    assert_eq!(
+        ::std::mem::size_of::<nsISupports>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsISupports))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsISupports>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsISupports))
+    );
+}
+impl Default for nsISupports {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN11nsISupports14QueryInterfaceEv"]
+    pub fn nsISupports_QueryInterface(
+        this: *mut ::std::os::raw::c_void,
+    ) -> *mut nsISupports;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsIRunnable {
+    pub _base: nsISupports,
+}
+#[test]
+fn bindgen_test_layout_nsIRunnable() {
+    assert_eq!(
+        ::std::mem::size_of::<nsIRunnable>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsIRunnable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsIRunnable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsIRunnable))
+    );
+}
+impl Default for nsIRunnable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Runnable {
+    pub _base: nsIRunnable,
+}
+#[test]
+fn bindgen_test_layout_Runnable() {
+    assert_eq!(
+        ::std::mem::size_of::<Runnable>(),
+        8usize,
+        concat!("Size of: ", stringify!(Runnable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Runnable>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Runnable))
+    );
+}
+impl Default for Runnable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs b/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs
new file mode 100644
index 00000000..629c449a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nested_within_namespace.rs
@@ -0,0 +1,115 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Bar {
+            pub foo: ::std::os::raw::c_int,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Bar_Baz {
+            pub foo: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_Bar_Baz() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar_Baz> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar_Baz>(),
+                4usize,
+                concat!("Size of: ", stringify!(Bar_Baz))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar_Baz>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar_Baz))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar_Baz),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+        }
+        #[test]
+        fn bindgen_test_layout_Bar() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar>(),
+                4usize,
+                concat!("Size of: ", stringify!(Bar))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Baz {
+            pub baz: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_Baz() {
+            const UNINIT: ::std::mem::MaybeUninit<Baz> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Baz>(),
+                4usize,
+                concat!("Size of: ", stringify!(Baz))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Baz>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Baz))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Baz),
+                    "::",
+                    stringify!(baz)
+                )
+            );
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/newtype-enum.rs b/bindgen-tests/tests/expectations/tests/newtype-enum.rs
new file mode 100644
index 00000000..26a4eb1f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/newtype-enum.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl Foo {
+    pub const Bar: Foo = Foo(2);
+}
+impl Foo {
+    pub const Baz: Foo = Foo(4);
+}
+impl Foo {
+    pub const Duplicated: Foo = Foo(4);
+}
+impl Foo {
+    pub const Negative: Foo = Foo(-3);
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs b/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs
new file mode 100644
index 00000000..cf23cca6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/newtype-global-enum.rs
@@ -0,0 +1,14 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const Foo_Bar: Foo = Foo(2);
+pub const Foo_Baz: Foo = Foo(4);
+pub const Foo_Duplicated: Foo = Foo(4);
+pub const Foo_Negative: Foo = Foo(-3);
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/bindgen-tests/tests/expectations/tests/no-comments.rs b/bindgen-tests/tests/expectations/tests/no-comments.rs
new file mode 100644
index 00000000..a375d8ea
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-comments.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub s: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(s))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-derive-debug.rs b/bindgen-tests/tests/expectations/tests/no-derive-debug.rs
new file mode 100644
index 00000000..c7a6d184
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-derive-debug.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct foo {
+    bar: ::std::os::raw::c_int,
+}
+
+/// bar should compile. It will normally derive debug, but our blocklist of foo
+/// and replacement for another type that doesn't implement it would prevent it
+/// from building if --no-derive-debug didn't work.
+#[repr(C)]
+pub struct bar {
+    pub foo: foo,
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(bar), "::", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(bar), "::", stringify!(baz))
+    );
+}
+impl Default for bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-derive-default.rs b/bindgen-tests/tests/expectations/tests/no-derive-default.rs
new file mode 100644
index 00000000..46b2cb4e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-derive-default.rs
@@ -0,0 +1,47 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct foo {
+    bar: ::std::os::raw::c_int,
+}
+
+/// bar should compile. It will normally derive default, but our blocklist of foo
+/// and replacement for another type that doesn't implement it would prevent it
+/// from building if --no-derive-default didn't work.
+#[repr(C)]
+pub struct bar {
+    pub foo: foo,
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_bar() {
+    const UNINIT: ::std::mem::MaybeUninit<bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(bar), "::", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(bar), "::", stringify!(baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs b/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs
new file mode 100644
index 00000000..549b72b5
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-hash-allowlisted.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoHash {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NoHash() {
+    const UNINIT: ::std::mem::MaybeUninit<NoHash> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoHash>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoHash))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoHash>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoHash))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(NoHash), "::", stringify!(i))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs b/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs
new file mode 100644
index 00000000..49ff4daa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-hash-opaque.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoHash {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_NoHash() {
+    assert_eq!(
+        ::std::mem::size_of::<NoHash>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoHash))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoHash>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoHash))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs b/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs
new file mode 100644
index 00000000..c7895fe6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-partialeq-allowlisted.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoPartialEq {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NoPartialEq() {
+    const UNINIT: ::std::mem::MaybeUninit<NoPartialEq> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoPartialEq>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoPartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoPartialEq>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoPartialEq))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NoPartialEq),
+            "::",
+            stringify!(i)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs b/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs
new file mode 100644
index 00000000..423799a6
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-partialeq-opaque.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoPartialEq {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_NoPartialEq() {
+    assert_eq!(
+        ::std::mem::size_of::<NoPartialEq>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoPartialEq))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoPartialEq>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoPartialEq))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs b/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs
new file mode 100644
index 00000000..6f1e19ba
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-recursive-allowlisting.rs
@@ -0,0 +1,44 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub enum Bar {}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    pub baz: *mut Bar,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    const UNINIT: ::std::mem::MaybeUninit<Foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(baz))
+    );
+}
+impl Default for Foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/no-std.rs b/bindgen-tests/tests/expectations/tests/no-std.rs
new file mode 100644
index 00000000..457242c2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no-std.rs
@@ -0,0 +1,59 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![no_std]
+mod libc {
+    pub type c_int = i32;
+    pub enum c_void {}
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct foo {
+    pub a: libc::c_int,
+    pub b: libc::c_int,
+    pub bar: *mut libc::c_void,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::core::mem::MaybeUninit<foo> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_copy.rs b/bindgen-tests/tests/expectations/tests/no_copy.rs
new file mode 100644
index 00000000..daccf757
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_copy.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen nocopy></div>
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct CopiableButWait {
+    pub whatever: ::std::os::raw::c_int,
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs
new file mode 100644
index 00000000..1c46de75
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_copy_allowlisted.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NoCopy {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NoCopy() {
+    const UNINIT: ::std::mem::MaybeUninit<NoCopy> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoCopy>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoCopy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoCopy>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoCopy))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(NoCopy), "::", stringify!(i))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs b/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs
new file mode 100644
index 00000000..7fc3529f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_copy_opaque.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default)]
+pub struct NoCopy {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_NoCopy() {
+    assert_eq!(
+        ::std::mem::size_of::<NoCopy>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoCopy))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoCopy>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoCopy))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_debug.rs b/bindgen-tests/tests/expectations/tests/no_debug.rs
new file mode 100644
index 00000000..21850ecb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_debug.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen nodebug></div>
+#[repr(C)]
+#[derive(Default, Copy, Clone)]
+pub struct DebugButWait {
+    pub whatever: ::std::os::raw::c_int,
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs
new file mode 100644
index 00000000..859dad8c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_debug_allowlisted.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default, Copy, Clone)]
+pub struct NoDebug {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NoDebug() {
+    const UNINIT: ::std::mem::MaybeUninit<NoDebug> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoDebug>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoDebug))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoDebug>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoDebug))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NoDebug),
+            "::",
+            stringify!(i)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs b/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs
new file mode 100644
index 00000000..334f39dd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_debug_bypass_impl_debug.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Generic<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Generic<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> ::std::fmt::Debug for Generic<T> {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(f, "Generic {{ t: Array with length 40 }}")
+    }
+}
+#[repr(C)]
+pub struct NoDebug<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for NoDebug<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs b/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs
new file mode 100644
index 00000000..4b657481
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_debug_opaque.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Default, Copy, Clone)]
+pub struct NoDebug {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_NoDebug() {
+    assert_eq!(
+        ::std::mem::size_of::<NoDebug>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoDebug))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoDebug>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoDebug))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_default.rs b/bindgen-tests/tests/expectations/tests/no_default.rs
new file mode 100644
index 00000000..22fdbf36
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_default.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen nodefault></div>
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DefaultButWait {
+    pub whatever: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DefaultButWaitDerived {
+    pub whatever: DefaultButWait,
+}
+impl Default for DefaultButWaitDerived {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs b/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs
new file mode 100644
index 00000000..c4deceb4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_default_allowlisted.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct NoDefault {
+    pub i: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NoDefault() {
+    const UNINIT: ::std::mem::MaybeUninit<NoDefault> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NoDefault>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoDefault))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoDefault>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoDefault))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NoDefault),
+            "::",
+            stringify!(i)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs b/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs
new file mode 100644
index 00000000..6c44a9dd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_default_bypass_derive_default.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Generic<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Generic<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct NoDefault<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_default_opaque.rs b/bindgen-tests/tests/expectations/tests/no_default_opaque.rs
new file mode 100644
index 00000000..3c928551
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_default_opaque.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct NoDefault {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_NoDefault() {
+    assert_eq!(
+        ::std::mem::size_of::<NoDefault>(),
+        4usize,
+        concat!("Size of: ", stringify!(NoDefault))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NoDefault>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NoDefault))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs b/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs
new file mode 100644
index 00000000..f399a667
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/no_size_t_is_usize.rs
@@ -0,0 +1,56 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type size_t = ::std::os::raw::c_ulong;
+pub type ssize_t = ::std::os::raw::c_long;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct A {
+    pub len: size_t,
+    pub offset: ssize_t,
+    pub next: *mut A,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        24usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        8usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(len))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(offset))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
+        16usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(next))
+    );
+}
+impl Default for A {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/non-type-params.rs b/bindgen-tests/tests/expectations/tests/non-type-params.rs
new file mode 100644
index 00000000..2b38e216
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/non-type-params.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type Array16 = u8;
+pub type ArrayInt4 = [u32; 4usize];
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct UsesArray {
+    pub array_char_16: [u8; 16usize],
+    pub array_bool_8: [u8; 8usize],
+    pub array_int_4: ArrayInt4,
+}
+#[test]
+fn bindgen_test_layout_UsesArray() {
+    const UNINIT: ::std::mem::MaybeUninit<UsesArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<UsesArray>(),
+        40usize,
+        concat!("Size of: ", stringify!(UsesArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<UsesArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(UsesArray))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).array_char_16) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UsesArray),
+            "::",
+            stringify!(array_char_16)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).array_bool_8) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UsesArray),
+            "::",
+            stringify!(array_bool_8)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).array_int_4) as usize - ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UsesArray),
+            "::",
+            stringify!(array_int_4)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/noreturn.rs b/bindgen-tests/tests/expectations/tests/noreturn.rs
new file mode 100644
index 00000000..a3905782
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/noreturn.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z1fv"]
+    pub fn f() -> !;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z1gv"]
+    pub fn g() -> !;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z1hv"]
+    pub fn h() -> !;
+}
diff --git a/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs b/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs
new file mode 100644
index 00000000..26179b76
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nsBaseHashtable.rs
@@ -0,0 +1,63 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct nsBaseHashtableET {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct nsTHashtable {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsBaseHashtable {
+    pub _address: u8,
+}
+pub type nsBaseHashtable_KeyType = [u8; 0usize];
+pub type nsBaseHashtable_EntryType = nsBaseHashtableET;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsBaseHashtable_LookupResult {
+    pub mEntry: *mut nsBaseHashtable_EntryType,
+    pub mTable: *mut nsBaseHashtable,
+}
+impl Default for nsBaseHashtable_LookupResult {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct nsBaseHashtable_EntryPtr {
+    pub mEntry: *mut nsBaseHashtable_EntryType,
+    pub mExistingEntry: bool,
+}
+impl Default for nsBaseHashtable_EntryPtr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for nsBaseHashtable {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs b/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs
new file mode 100644
index 00000000..fab18c1c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/nsStyleAutoArray.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsTArray<T> {
+    pub mBuff: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for nsTArray<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsStyleAutoArray<T> {
+    pub mFirstElement: T,
+    pub mOtherElements: nsTArray<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum nsStyleAutoArray_WithSingleInitialElement {
+    WITH_SINGLE_INITIAL_ELEMENT = 0,
+}
+impl<T> Default for nsStyleAutoArray<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_allowlist.rs b/bindgen-tests/tests/expectations/tests/objc_allowlist.rs
new file mode 100644
index 00000000..370cab93
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_allowlist.rs
@@ -0,0 +1,58 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+pub trait PSomeProtocol: Sized + std::ops::Deref {
+    unsafe fn protocolMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, protocolMethod)
+    }
+    unsafe fn protocolClassMethod()
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(SomeProtocol), protocolClassMethod)
+    }
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct AllowlistMe(pub id);
+impl std::ops::Deref for AllowlistMe {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for AllowlistMe {}
+impl AllowlistMe {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(AllowlistMe), alloc) })
+    }
+}
+impl PSomeProtocol for AllowlistMe {}
+impl IAllowlistMe for AllowlistMe {}
+pub trait IAllowlistMe: Sized + std::ops::Deref {
+    unsafe fn method(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, method)
+    }
+    unsafe fn classMethod()
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(AllowlistMe), classMethod)
+    }
+}
+impl AllowlistMe_InterestingCategory for AllowlistMe {}
+pub trait AllowlistMe_InterestingCategory: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/objc_blocklist.rs b/bindgen-tests/tests/expectations/tests/objc_blocklist.rs
new file mode 100644
index 00000000..7d5d19b0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_blocklist.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+#[macro_use]
+extern crate objc;
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct SomeClass(pub id);
+impl std::ops::Deref for SomeClass {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for SomeClass {}
+impl SomeClass {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(SomeClass), alloc) })
+    }
+}
+impl ISomeClass for SomeClass {}
+pub trait ISomeClass: Sized + std::ops::Deref {
+    unsafe fn ambiguouslyBlockedMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, ambiguouslyBlockedMethod)
+    }
+    unsafe fn instanceMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, instanceMethod)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_category.rs b/bindgen-tests/tests/expectations/tests/objc_category.rs
new file mode 100644
index 00000000..9d60233b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_category.rs
@@ -0,0 +1,44 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn method(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, method)
+    }
+}
+impl Foo_BarCategory for Foo {}
+pub trait Foo_BarCategory: Sized + std::ops::Deref {
+    unsafe fn categoryMethod(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, categoryMethod)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_class.rs b/bindgen-tests/tests/expectations/tests/objc_class.rs
new file mode 100644
index 00000000..b322bddc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_class.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+extern "C" {
+    pub static mut fooVar: Foo;
+}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn method(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, method)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_class_method.rs b/bindgen-tests/tests/expectations/tests/objc_class_method.rs
new file mode 100644
index 00000000..29e70256
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_class_method.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn method()
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), method)
+    }
+    unsafe fn methodWithInt_(foo: ::std::os::raw::c_int)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), methodWithInt: foo)
+    }
+    unsafe fn methodWithFoo_(foo: Foo)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), methodWithFoo: foo)
+    }
+    unsafe fn methodReturningInt() -> ::std::os::raw::c_int
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), methodReturningInt)
+    }
+    unsafe fn methodReturningFoo() -> Foo
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), methodReturningFoo)
+    }
+    unsafe fn methodWithArg1_andArg2_andArg3_(
+        intvalue: ::std::os::raw::c_int,
+        ptr: *mut ::std::os::raw::c_char,
+        floatvalue: f32,
+    ) where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send ! (class ! (Foo) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_interface.rs b/bindgen-tests/tests/expectations/tests/objc_interface.rs
new file mode 100644
index 00000000..89e64d86
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_interface.rs
@@ -0,0 +1,29 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+pub trait Pbar: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/objc_interface_type.rs b/bindgen-tests/tests/expectations/tests/objc_interface_type.rs
new file mode 100644
index 00000000..423ba910
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_interface_type.rs
@@ -0,0 +1,74 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct FooStruct {
+    pub foo: Foo,
+}
+#[test]
+fn bindgen_test_layout_FooStruct() {
+    const UNINIT: ::std::mem::MaybeUninit<FooStruct> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<FooStruct>(),
+        8usize,
+        concat!("Size of: ", stringify!(FooStruct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<FooStruct>(),
+        8usize,
+        concat!("Alignment of ", stringify!(FooStruct))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(FooStruct),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
+impl Default for FooStruct {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    pub fn fooFunc(foo: Foo);
+}
+extern "C" {
+    pub static mut kFoo: Foo;
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_method.rs b/bindgen-tests/tests/expectations/tests/objc_method.rs
new file mode 100644
index 00000000..593fd277
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_method.rs
@@ -0,0 +1,82 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn method(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, method)
+    }
+    unsafe fn methodWithInt_(&self, foo: ::std::os::raw::c_int)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, methodWithInt: foo)
+    }
+    unsafe fn methodWithFoo_(&self, foo: Foo)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, methodWithFoo: foo)
+    }
+    unsafe fn methodReturningInt(&self) -> ::std::os::raw::c_int
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, methodReturningInt)
+    }
+    unsafe fn methodReturningFoo(&self) -> Foo
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, methodReturningFoo)
+    }
+    unsafe fn methodWithArg1_andArg2_andArg3_(
+        &self,
+        intvalue: ::std::os::raw::c_int,
+        ptr: *mut ::std::os::raw::c_char,
+        floatvalue: f32,
+    ) where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send ! (* self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue)
+    }
+    unsafe fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(
+        &self,
+        arg1: ::std::os::raw::c_int,
+        arg2: f32,
+        arg3: f32,
+        arg4: ::std::os::raw::c_int,
+    ) -> instancetype
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send ! (* self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4)
+    }
+}
+pub type instancetype = id;
diff --git a/bindgen-tests/tests/expectations/tests/objc_method_clash.rs b/bindgen-tests/tests/expectations/tests/objc_method_clash.rs
new file mode 100644
index 00000000..ac77cc19
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_method_clash.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn foo(&self)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, foo)
+    }
+    unsafe fn class_foo()
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), foo)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs b/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs
new file mode 100644
index 00000000..1ec8494d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_pointer_return_types.rs
@@ -0,0 +1,58 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar(pub id);
+impl std::ops::Deref for Bar {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Bar {}
+impl Bar {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Bar), alloc) })
+    }
+}
+impl IBar for Bar {}
+pub trait IBar: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn methodUsingBar_(&self, my_bar: Bar)
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, methodUsingBar: my_bar)
+    }
+    unsafe fn methodReturningBar() -> Bar
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(class!(Foo), methodReturningBar)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs b/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs
new file mode 100644
index 00000000..9f3fabd2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_property_fnptr.rs
@@ -0,0 +1,57 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {
+    unsafe fn func(
+        &self,
+    ) -> ::std::option::Option<
+        unsafe extern "C" fn(
+            arg1: ::std::os::raw::c_char,
+            arg2: ::std::os::raw::c_short,
+            arg3: f32,
+        ) -> ::std::os::raw::c_int,
+    >
+    where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, func)
+    }
+    unsafe fn setFunc_(
+        &self,
+        func: ::std::option::Option<
+            unsafe extern "C" fn(
+                arg1: ::std::os::raw::c_char,
+                arg2: ::std::os::raw::c_short,
+                arg3: f32,
+            ) -> ::std::os::raw::c_int,
+        >,
+    ) where
+        <Self as std::ops::Deref>::Target: objc::Message + Sized,
+    {
+        msg_send!(*self, setFunc: func)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/objc_protocol.rs b/bindgen-tests/tests/expectations/tests/objc_protocol.rs
new file mode 100644
index 00000000..5bd7d433
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_protocol.rs
@@ -0,0 +1,30 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+pub trait PFoo: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl PFoo for Foo {}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs b/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs
new file mode 100644
index 00000000..f5f80e2e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_protocol_inheritance.rs
@@ -0,0 +1,66 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+pub trait PFoo: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo(pub id);
+impl std::ops::Deref for Foo {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Foo {}
+impl Foo {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Foo), alloc) })
+    }
+}
+impl PFoo for Foo {}
+impl IFoo for Foo {}
+pub trait IFoo: Sized + std::ops::Deref {}
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar(pub id);
+impl std::ops::Deref for Bar {
+    type Target = objc::runtime::Object;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.0 }
+    }
+}
+unsafe impl objc::Message for Bar {}
+impl Bar {
+    pub fn alloc() -> Self {
+        Self(unsafe { msg_send!(class!(Bar), alloc) })
+    }
+}
+impl IFoo for Bar {}
+impl PFoo for Bar {}
+impl From<Bar> for Foo {
+    fn from(child: Bar) -> Foo {
+        Foo(child.0)
+    }
+}
+impl std::convert::TryFrom<Foo> for Bar {
+    type Error = &'static str;
+    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
+        let is_kind_of: bool =
+            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
+        if is_kind_of {
+            Ok(Bar(parent.0))
+        } else {
+            Err("This Foo cannot be downcasted to Bar")
+        }
+    }
+}
+impl IBar for Bar {}
+pub trait IBar: Sized + std::ops::Deref {}
diff --git a/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs b/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs
new file mode 100644
index 00000000..0017eab0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/objc_sel_and_id.rs
@@ -0,0 +1,20 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(target_os = "macos")]
+
+use objc::{self, class, msg_send, sel, sel_impl};
+#[allow(non_camel_case_types)]
+pub type id = *mut objc::runtime::Object;
+extern "C" {
+    pub static mut object: id;
+}
+extern "C" {
+    pub static mut selector: objc::runtime::Sel;
+}
+extern "C" {
+    pub fn f(object: id, selector: objc::runtime::Sel);
+}
diff --git a/bindgen-tests/tests/expectations/tests/only_bitfields.rs b/bindgen-tests/tests/expectations/tests/only_bitfields.rs
new file mode 100644
index 00000000..2f063b5b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/only_bitfields.rs
@@ -0,0 +1,157 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        1usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        1usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+}
+impl C {
+    #[inline]
+    pub fn a(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: bool,
+        b: bool,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u8 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 7u8, {
+            let b: u8 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs
new file mode 100644
index 00000000..c28d9356
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member-2.rs
@@ -0,0 +1,99 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// This is like `opaque-template-inst-member.hpp` except exercising the cases
+/// where we are OK to derive Debug/Hash/PartialEq.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct OpaqueTemplate {
+    pub _address: u8,
+}
+/// Should derive Debug/Hash/PartialEq.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ContainsOpaqueTemplate {
+    pub mBlah: u32,
+    pub mBaz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ContainsOpaqueTemplate() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueTemplate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsOpaqueTemplate>(),
+        8usize,
+        concat!("Size of: ", stringify!(ContainsOpaqueTemplate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsOpaqueTemplate>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ContainsOpaqueTemplate))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBlah) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsOpaqueTemplate),
+            "::",
+            stringify!(mBlah)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBaz) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsOpaqueTemplate),
+            "::",
+            stringify!(mBaz)
+        )
+    );
+}
+/// Should also derive Debug/Hash/PartialEq.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct InheritsOpaqueTemplate {
+    pub _base: u8,
+    pub wow: *mut ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_InheritsOpaqueTemplate() {
+    const UNINIT: ::std::mem::MaybeUninit<InheritsOpaqueTemplate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<InheritsOpaqueTemplate>(),
+        16usize,
+        concat!("Size of: ", stringify!(InheritsOpaqueTemplate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsOpaqueTemplate>(),
+        8usize,
+        concat!("Alignment of ", stringify!(InheritsOpaqueTemplate))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).wow) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(InheritsOpaqueTemplate),
+            "::",
+            stringify!(wow)
+        )
+    );
+}
+impl Default for InheritsOpaqueTemplate {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs
new file mode 100644
index 00000000..4ba85f66
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque-template-inst-member.rs
@@ -0,0 +1,116 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct OpaqueTemplate {
+    pub _address: u8,
+}
+/// This should not end up deriving Debug/Hash because its `mBlah` field cannot derive
+/// Debug/Hash because the instantiation's definition cannot derive Debug/Hash.
+#[repr(C)]
+pub struct ContainsOpaqueTemplate {
+    pub mBlah: [u32; 101usize],
+    pub mBaz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ContainsOpaqueTemplate() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueTemplate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsOpaqueTemplate>(),
+        408usize,
+        concat!("Size of: ", stringify!(ContainsOpaqueTemplate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsOpaqueTemplate>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ContainsOpaqueTemplate))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBlah) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsOpaqueTemplate),
+            "::",
+            stringify!(mBlah)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBaz) as usize - ptr as usize },
+        404usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsOpaqueTemplate),
+            "::",
+            stringify!(mBaz)
+        )
+    );
+}
+impl Default for ContainsOpaqueTemplate {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for ContainsOpaqueTemplate {
+    fn eq(&self, other: &ContainsOpaqueTemplate) -> bool {
+        &self.mBlah[..] == &other.mBlah[..] && self.mBaz == other.mBaz
+    }
+}
+/// This should not end up deriving Debug/Hash either, for similar reasons, although
+/// we're exercising base member edges now.
+#[repr(C)]
+pub struct InheritsOpaqueTemplate {
+    pub _base: [u8; 401usize],
+    pub wow: *mut ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_InheritsOpaqueTemplate() {
+    const UNINIT: ::std::mem::MaybeUninit<InheritsOpaqueTemplate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<InheritsOpaqueTemplate>(),
+        416usize,
+        concat!("Size of: ", stringify!(InheritsOpaqueTemplate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsOpaqueTemplate>(),
+        8usize,
+        concat!("Alignment of ", stringify!(InheritsOpaqueTemplate))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).wow) as usize - ptr as usize },
+        408usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(InheritsOpaqueTemplate),
+            "::",
+            stringify!(wow)
+        )
+    );
+}
+impl Default for InheritsOpaqueTemplate {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl ::std::cmp::PartialEq for InheritsOpaqueTemplate {
+    fn eq(&self, other: &InheritsOpaqueTemplate) -> bool {
+        &self._base[..] == &other._base[..] && self.wow == other.wow
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs
new file mode 100644
index 00000000..3575216c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs
@@ -0,0 +1,198 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod zoidberg {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct Template<T> {
+            pub member: T,
+            pub _phantom_0:
+                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+        }
+        impl<T> Default for Template<T> {
+            fn default() -> Self {
+                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                unsafe {
+                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                    s.assume_init()
+                }
+            }
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct Foo {
+            pub c: ::std::os::raw::c_char,
+        }
+        #[test]
+        fn bindgen_test_layout_Foo() {
+            const UNINIT: ::std::mem::MaybeUninit<Foo> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Foo>(),
+                1usize,
+                concat!("Size of: ", stringify!(Foo))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Foo>(),
+                1usize,
+                concat!("Alignment of ", stringify!(Foo))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Foo),
+                    "::",
+                    stringify!(c)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct Bar {
+            pub i: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_Bar() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar>(),
+                4usize,
+                concat!("Size of: ", stringify!(Bar))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(i)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct ContainsInstantiation {
+            pub not_opaque: root::zoidberg::Template<root::zoidberg::Foo>,
+        }
+        #[test]
+        fn bindgen_test_layout_ContainsInstantiation() {
+            const UNINIT: ::std::mem::MaybeUninit<ContainsInstantiation> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<ContainsInstantiation>(),
+                1usize,
+                concat!("Size of: ", stringify!(ContainsInstantiation))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<ContainsInstantiation>(),
+                1usize,
+                concat!("Alignment of ", stringify!(ContainsInstantiation))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).not_opaque) as usize -
+                        ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(ContainsInstantiation),
+                    "::",
+                    stringify!(not_opaque)
+                )
+            );
+        }
+        impl Default for ContainsInstantiation {
+            fn default() -> Self {
+                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                unsafe {
+                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                    s.assume_init()
+                }
+            }
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct ContainsOpaqueInstantiation {
+            pub opaque: u32,
+        }
+        #[test]
+        fn bindgen_test_layout_ContainsOpaqueInstantiation() {
+            const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueInstantiation> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<ContainsOpaqueInstantiation>(),
+                4usize,
+                concat!("Size of: ", stringify!(ContainsOpaqueInstantiation))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<ContainsOpaqueInstantiation>(),
+                4usize,
+                concat!(
+                    "Alignment of ",
+                    stringify!(ContainsOpaqueInstantiation)
+                )
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(ContainsOpaqueInstantiation),
+                    "::",
+                    stringify!(opaque)
+                )
+            );
+        }
+    }
+    #[test]
+    fn __bindgen_test_layout_Template_open0_Foo_close0_instantiation() {
+        assert_eq!(
+            ::std::mem::size_of::<root::zoidberg::Template<root::zoidberg::Foo>>(
+            ),
+            1usize,
+            concat!(
+                "Size of template specialization: ",
+                stringify!(root::zoidberg::Template<root::zoidberg::Foo>)
+            )
+        );
+        assert_eq!(
+            ::std::mem::align_of::<root::zoidberg::Template<root::zoidberg::Foo>>(
+            ),
+            1usize,
+            concat!(
+                "Alignment of template specialization: ",
+                stringify!(root::zoidberg::Template<root::zoidberg::Foo>)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs
new file mode 100644
index 00000000..910c616f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque-template-instantiation.rs
@@ -0,0 +1,114 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Template<T> {
+    pub member: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Template<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ContainsInstantiation {
+    pub not_opaque: Template<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_ContainsInstantiation() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsInstantiation> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsInstantiation>(),
+        1usize,
+        concat!("Size of: ", stringify!(ContainsInstantiation))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsInstantiation>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ContainsInstantiation))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).not_opaque) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsInstantiation),
+            "::",
+            stringify!(not_opaque)
+        )
+    );
+}
+impl Default for ContainsInstantiation {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct ContainsOpaqueInstantiation {
+    pub opaque: u32,
+}
+#[test]
+fn bindgen_test_layout_ContainsOpaqueInstantiation() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueInstantiation> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsOpaqueInstantiation>(),
+        4usize,
+        concat!("Size of: ", stringify!(ContainsOpaqueInstantiation))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsOpaqueInstantiation>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ContainsOpaqueInstantiation))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsOpaqueInstantiation),
+            "::",
+            stringify!(opaque)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_Template_open0_char_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Template<::std::os::raw::c_char>>(),
+        1usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(Template<::std::os::raw::c_char>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Template<::std::os::raw::c_char>>(),
+        1usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(Template<::std::os::raw::c_char>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque-tracing.rs b/bindgen-tests/tests/expectations/tests/opaque-tracing.rs
new file mode 100644
index 00000000..98c54171
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque-tracing.rs
@@ -0,0 +1,30 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z3fooP9Container"]
+    pub fn foo(c: *mut Container);
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Container {
+    pub _bindgen_opaque_blob: [u32; 2usize],
+}
+#[test]
+fn bindgen_test_layout_Container() {
+    assert_eq!(
+        ::std::mem::size_of::<Container>(),
+        8usize,
+        concat!("Size of: ", stringify!(Container))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Container>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Container))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs b/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs
new file mode 100644
index 00000000..0d13b121
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque_in_struct.rs
@@ -0,0 +1,60 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen opaque>
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct opaque {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_opaque() {
+    assert_eq!(
+        ::std::mem::size_of::<opaque>(),
+        4usize,
+        concat!("Size of: ", stringify!(opaque))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<opaque>(),
+        4usize,
+        concat!("Alignment of ", stringify!(opaque))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct container {
+    pub contained: opaque,
+}
+#[test]
+fn bindgen_test_layout_container() {
+    const UNINIT: ::std::mem::MaybeUninit<container> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<container>(),
+        4usize,
+        concat!("Size of: ", stringify!(container))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<container>(),
+        4usize,
+        concat!("Alignment of ", stringify!(container))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).contained) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(container),
+            "::",
+            stringify!(contained)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque_pointer.rs b/bindgen-tests/tests/expectations/tests/opaque_pointer.rs
new file mode 100644
index 00000000..13b8cc36
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque_pointer.rs
@@ -0,0 +1,97 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen opaque></div>
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct OtherOpaque {
+    pub _bindgen_opaque_blob: u32,
+}
+#[test]
+fn bindgen_test_layout_OtherOpaque() {
+    assert_eq!(
+        ::std::mem::size_of::<OtherOpaque>(),
+        4usize,
+        concat!("Size of: ", stringify!(OtherOpaque))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<OtherOpaque>(),
+        4usize,
+        concat!("Alignment of ", stringify!(OtherOpaque))
+    );
+}
+/// <div rustbindgen opaque></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Opaque {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq)]
+pub struct WithOpaquePtr {
+    pub whatever: *mut u8,
+    pub other: u32,
+    pub t: OtherOpaque,
+}
+#[test]
+fn bindgen_test_layout_WithOpaquePtr() {
+    const UNINIT: ::std::mem::MaybeUninit<WithOpaquePtr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithOpaquePtr>(),
+        16usize,
+        concat!("Size of: ", stringify!(WithOpaquePtr))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithOpaquePtr>(),
+        8usize,
+        concat!("Alignment of ", stringify!(WithOpaquePtr))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithOpaquePtr),
+            "::",
+            stringify!(whatever)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).other) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithOpaquePtr),
+            "::",
+            stringify!(other)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithOpaquePtr),
+            "::",
+            stringify!(t)
+        )
+    );
+}
+impl Default for WithOpaquePtr {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/opaque_typedef.rs b/bindgen-tests/tests/expectations/tests/opaque_typedef.rs
new file mode 100644
index 00000000..c61a294c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/opaque_typedef.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct RandomTemplate {
+    pub _address: u8,
+}
+/// <div rustbindgen opaque></div>
+pub type ShouldBeOpaque = u8;
+pub type ShouldNotBeOpaque = RandomTemplate;
diff --git a/bindgen-tests/tests/expectations/tests/operator.rs b/bindgen-tests/tests/expectations/tests/operator.rs
new file mode 100644
index 00000000..5128226d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/operator.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z20operator_informationv"]
+    pub fn operator_information() -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
diff --git a/bindgen-tests/tests/expectations/tests/ord-enum.rs b/bindgen-tests/tests/expectations/tests/ord-enum.rs
new file mode 100644
index 00000000..a72fef8d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/ord-enum.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub enum A {
+    A0 = 0,
+    A1 = 1,
+    A2 = 2,
+    A3 = -1,
+}
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub enum B {
+    B0 = 1,
+    B1 = 4,
+    B2 = 3,
+    B3 = -1,
+}
diff --git a/bindgen-tests/tests/expectations/tests/overflowed_enum.rs b/bindgen-tests/tests/expectations/tests/overflowed_enum.rs
new file mode 100644
index 00000000..94e166ad
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/overflowed_enum.rs
@@ -0,0 +1,20 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Foo {
+    BAP_ARM = 9698489,
+    BAP_X86 = 11960045,
+    BAP_X86_64 = 3128633167,
+}
+#[repr(u16)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum Bar {
+    One = 1,
+    Big = 2,
+}
diff --git a/bindgen-tests/tests/expectations/tests/overloading.rs b/bindgen-tests/tests/expectations/tests/overloading.rs
new file mode 100644
index 00000000..b43432eb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/overloading.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z8Evaluatec"]
+    pub fn Evaluate(r: ::std::os::raw::c_char) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_Z8Evaluateii"]
+    pub fn Evaluate1(
+        x: ::std::os::raw::c_int,
+        y: ::std::os::raw::c_int,
+    ) -> bool;
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3foo10MyFunctionEv"]
+    pub fn foo_MyFunction();
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3bar10MyFunctionEv"]
+    pub fn bar_MyFunction();
+}
diff --git a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs
new file mode 100644
index 00000000..f90edb93
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs
@@ -0,0 +1,175 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Date {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
+}
+#[test]
+fn bindgen_test_layout_Date() {
+    assert_eq!(
+        ::std::mem::size_of::<Date>(),
+        3usize,
+        concat!("Size of: ", stringify!(Date))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Date>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Date))
+    );
+}
+impl Date {
+    #[inline]
+    pub fn day(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_day(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 5u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn month(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_month(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn year(&self) -> ::std::os::raw::c_short {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(9usize, 15u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_year(&mut self, val: ::std::os::raw::c_short) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 15u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        day: ::std::os::raw::c_uchar,
+        month: ::std::os::raw::c_uchar,
+        year: ::std::os::raw::c_short,
+    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 5u8, {
+            let day: u8 = unsafe { ::std::mem::transmute(day) };
+            day as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 4u8, {
+            let month: u8 = unsafe { ::std::mem::transmute(month) };
+            month as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 15u8, {
+            let year: u16 = unsafe { ::std::mem::transmute(year) };
+            year as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs b/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs
new file mode 100644
index 00000000..b171b1da
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/packed-n-with-padding.rs
@@ -0,0 +1,51 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C, packed(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Packed {
+    pub a: ::std::os::raw::c_char,
+    pub b: ::std::os::raw::c_short,
+    pub c: ::std::os::raw::c_char,
+    pub d: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Packed() {
+    const UNINIT: ::std::mem::MaybeUninit<Packed> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Packed>(),
+        10usize,
+        concat!("Size of: ", stringify!(Packed))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Packed>(),
+        2usize,
+        concat!("Alignment of ", stringify!(Packed))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        2usize,
+        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(c))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        6usize,
+        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(d))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/packed-vtable.rs b/bindgen-tests/tests/expectations/tests/packed-vtable.rs
new file mode 100644
index 00000000..71688151
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/packed-vtable.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+
+#[repr(C)]
+pub struct PackedVtable__bindgen_vtable(::std::os::raw::c_void);
+#[repr(C, packed)]
+pub struct PackedVtable {
+    pub vtable_: *const PackedVtable__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_PackedVtable() {
+    assert_eq!(
+        ::std::mem::size_of::<PackedVtable>(),
+        8usize,
+        concat!("Size of: ", stringify!(PackedVtable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PackedVtable>(),
+        1usize,
+        concat!("Alignment of ", stringify!(PackedVtable))
+    );
+}
+impl Default for PackedVtable {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN12PackedVtableD1Ev"]
+    pub fn PackedVtable_PackedVtable_destructor(this: *mut PackedVtable);
+}
diff --git a/bindgen-tests/tests/expectations/tests/parm-union.rs b/bindgen-tests/tests/expectations/tests/parm-union.rs
new file mode 100644
index 00000000..9f7dd20a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/parm-union.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Struct {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Struct() {
+    assert_eq!(
+        ::std::mem::size_of::<Struct>(),
+        1usize,
+        concat!("Size of: ", stringify!(Struct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Struct>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Struct))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN6Struct8FunctionER5Union"]
+    pub fn Struct_Function(this: *mut Struct, arg1: *mut Union);
+}
+impl Struct {
+    #[inline]
+    pub unsafe fn Function(&mut self, arg1: *mut Union) {
+        Struct_Function(self, arg1)
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Union {
+    _unused: [u8; 0],
+}
diff --git a/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs b/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
new file mode 100644
index 00000000..8ead5b8a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const RENAMED_MyVal: _bindgen_ty_1 = 0;
+pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/pointer-attr.rs b/bindgen-tests/tests/expectations/tests/pointer-attr.rs
new file mode 100644
index 00000000..95fe9c5f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/pointer-attr.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn a(arg1: *const ::std::os::raw::c_char);
+}
diff --git a/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs b/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs
new file mode 100644
index 00000000..b2b09444
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/prepend-enum-constified-variant.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+impl AVCodecID {
+    pub const AV_CODEC_ID_TTF: AVCodecID = AVCodecID::AV_CODEC_ID_FIRST_UNKNOWN;
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum AVCodecID {
+    AV_CODEC_ID_FIRST_UNKNOWN = 98304,
+}
diff --git a/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs b/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs
new file mode 100644
index 00000000..31db4144
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/prepend_enum_name.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const FOO_BAR: foo = 0;
+pub const FOO_BAZ: foo = 1;
+pub type foo = ::std::os::raw::c_uint;
diff --git a/bindgen-tests/tests/expectations/tests/private.rs b/bindgen-tests/tests/expectations/tests/private.rs
new file mode 100644
index 00000000..ab57d37f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/private.rs
@@ -0,0 +1,149 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct HasPrivate {
+    pub mNotPrivate: ::std::os::raw::c_int,
+    /// <div rustbindgen private></div>
+    mIsPrivate: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_HasPrivate() {
+    const UNINIT: ::std::mem::MaybeUninit<HasPrivate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<HasPrivate>(),
+        8usize,
+        concat!("Size of: ", stringify!(HasPrivate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<HasPrivate>(),
+        4usize,
+        concat!("Alignment of ", stringify!(HasPrivate))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mNotPrivate) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(HasPrivate),
+            "::",
+            stringify!(mNotPrivate)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(HasPrivate),
+            "::",
+            stringify!(mIsPrivate)
+        )
+    );
+}
+/// <div rustbindgen private></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct VeryPrivate {
+    mIsPrivate: ::std::os::raw::c_int,
+    mIsAlsoPrivate: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_VeryPrivate() {
+    const UNINIT: ::std::mem::MaybeUninit<VeryPrivate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<VeryPrivate>(),
+        8usize,
+        concat!("Size of: ", stringify!(VeryPrivate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<VeryPrivate>(),
+        4usize,
+        concat!("Alignment of ", stringify!(VeryPrivate))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(VeryPrivate),
+            "::",
+            stringify!(mIsPrivate)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsAlsoPrivate) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(VeryPrivate),
+            "::",
+            stringify!(mIsAlsoPrivate)
+        )
+    );
+}
+/// <div rustbindgen private></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ContradictPrivate {
+    /// <div rustbindgen private="false"></div>
+    pub mNotPrivate: ::std::os::raw::c_int,
+    mIsPrivate: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_ContradictPrivate() {
+    const UNINIT: ::std::mem::MaybeUninit<ContradictPrivate> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContradictPrivate>(),
+        8usize,
+        concat!("Size of: ", stringify!(ContradictPrivate))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContradictPrivate>(),
+        4usize,
+        concat!("Alignment of ", stringify!(ContradictPrivate))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mNotPrivate) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictPrivate),
+            "::",
+            stringify!(mNotPrivate)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
+        },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContradictPrivate),
+            "::",
+            stringify!(mIsPrivate)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/private_fields.rs b/bindgen-tests/tests/expectations/tests/private_fields.rs
new file mode 100644
index 00000000..8db332a5
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/private_fields.rs
@@ -0,0 +1,535 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PubPriv {
+    pub x: ::std::os::raw::c_int,
+    y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_PubPriv() {
+    const UNINIT: ::std::mem::MaybeUninit<PubPriv> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PubPriv>(),
+        8usize,
+        concat!("Size of: ", stringify!(PubPriv))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PubPriv>(),
+        4usize,
+        concat!("Alignment of ", stringify!(PubPriv))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PubPriv),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PubPriv),
+            "::",
+            stringify!(y)
+        )
+    );
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PrivateBitFields {
+    pub _bitfield_align_1: [u8; 0],
+    _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_PrivateBitFields() {
+    assert_eq!(
+        ::std::mem::size_of::<PrivateBitFields>(),
+        4usize,
+        concat!("Size of: ", stringify!(PrivateBitFields))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PrivateBitFields>(),
+        4usize,
+        concat!("Alignment of ", stringify!(PrivateBitFields))
+    );
+}
+impl PrivateBitFields {
+    #[inline]
+    fn a(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    fn set_a(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    fn b(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    fn set_b(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    fn new_bitfield_1(
+        a: ::std::os::raw::c_uint,
+        b: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 4u8, {
+            let a: u32 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 4u8, {
+            let b: u32 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct PublicBitFields {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_PublicBitFields() {
+    assert_eq!(
+        ::std::mem::size_of::<PublicBitFields>(),
+        4usize,
+        concat!("Size of: ", stringify!(PublicBitFields))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PublicBitFields>(),
+        4usize,
+        concat!("Alignment of ", stringify!(PublicBitFields))
+    );
+}
+impl PublicBitFields {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: ::std::os::raw::c_uint,
+        b: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 4u8, {
+            let a: u32 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 4u8, {
+            let b: u32 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct MixedBitFields {
+    pub _bitfield_align_1: [u8; 0],
+    _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_MixedBitFields() {
+    assert_eq!(
+        ::std::mem::size_of::<MixedBitFields>(),
+        4usize,
+        concat!("Size of: ", stringify!(MixedBitFields))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<MixedBitFields>(),
+        4usize,
+        concat!("Alignment of ", stringify!(MixedBitFields))
+    );
+}
+impl MixedBitFields {
+    #[inline]
+    fn a(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    fn set_a(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn d(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_d(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 4u8, val as u64)
+        }
+    }
+    #[inline]
+    fn new_bitfield_1(
+        a: ::std::os::raw::c_uint,
+        d: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 4u8, {
+            let a: u32 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 4u8, {
+            let d: u32 = unsafe { ::std::mem::transmute(d) };
+            d as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Base {
+    pub member: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Base() {
+    const UNINIT: ::std::mem::MaybeUninit<Base> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Base>(),
+        4usize,
+        concat!("Size of: ", stringify!(Base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Base>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Base))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Base),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct InheritsPrivately {
+    _base: Base,
+}
+#[test]
+fn bindgen_test_layout_InheritsPrivately() {
+    assert_eq!(
+        ::std::mem::size_of::<InheritsPrivately>(),
+        4usize,
+        concat!("Size of: ", stringify!(InheritsPrivately))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsPrivately>(),
+        4usize,
+        concat!("Alignment of ", stringify!(InheritsPrivately))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct InheritsPublically {
+    pub _base: Base,
+}
+#[test]
+fn bindgen_test_layout_InheritsPublically() {
+    assert_eq!(
+        ::std::mem::size_of::<InheritsPublically>(),
+        4usize,
+        concat!("Size of: ", stringify!(InheritsPublically))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsPublically>(),
+        4usize,
+        concat!("Alignment of ", stringify!(InheritsPublically))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithAnonStruct {
+    __bindgen_anon_1: WithAnonStruct__bindgen_ty_1,
+    pub __bindgen_anon_2: WithAnonStruct__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithAnonStruct__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithAnonStruct__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<WithAnonStruct__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithAnonStruct__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithAnonStruct__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithAnonStruct__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithAnonStruct__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithAnonStruct__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct WithAnonStruct__bindgen_ty_2 {
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_WithAnonStruct__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<WithAnonStruct__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithAnonStruct__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithAnonStruct__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithAnonStruct__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithAnonStruct__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithAnonStruct__bindgen_ty_2),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_WithAnonStruct() {
+    assert_eq!(
+        ::std::mem::size_of::<WithAnonStruct>(),
+        8usize,
+        concat!("Size of: ", stringify!(WithAnonStruct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithAnonStruct>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithAnonStruct))
+    );
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct WithAnonUnion {
+    __bindgen_anon_1: WithAnonUnion__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union WithAnonUnion__bindgen_ty_1 {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_WithAnonUnion__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<WithAnonUnion__bindgen_ty_1>(),
+        1usize,
+        concat!("Size of: ", stringify!(WithAnonUnion__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithAnonUnion__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(WithAnonUnion__bindgen_ty_1))
+    );
+}
+impl Default for WithAnonUnion__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_WithAnonUnion() {
+    assert_eq!(
+        ::std::mem::size_of::<WithAnonUnion>(),
+        1usize,
+        concat!("Size of: ", stringify!(WithAnonUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithAnonUnion>(),
+        1usize,
+        concat!("Alignment of ", stringify!(WithAnonUnion))
+    );
+}
+impl Default for WithAnonUnion {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/public-dtor.rs b/bindgen-tests/tests/expectations/tests/public-dtor.rs
new file mode 100644
index 00000000..64a50389
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/public-dtor.rs
@@ -0,0 +1,35 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct cv_String {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_cv_String() {
+    assert_eq!(
+        ::std::mem::size_of::<cv_String>(),
+        1usize,
+        concat!("Size of: ", stringify!(cv_String))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<cv_String>(),
+        1usize,
+        concat!("Alignment of ", stringify!(cv_String))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN2cv6StringD1Ev"]
+    pub fn cv_String_String_destructor(this: *mut cv_String);
+}
+impl cv_String {
+    #[inline]
+    pub unsafe fn destruct(&mut self) {
+        cv_String_String_destructor(self)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs b/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs
new file mode 100644
index 00000000..f1b2c845
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/qualified-dependent-types.rs
@@ -0,0 +1,17 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/redeclaration.rs b/bindgen-tests/tests/expectations/tests/redeclaration.rs
new file mode 100644
index 00000000..8a4ff657
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/redeclaration.rs
@@ -0,0 +1,10 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo();
+}
diff --git a/bindgen-tests/tests/expectations/tests/ref_argument_array.rs b/bindgen-tests/tests/expectations/tests/ref_argument_array.rs
new file mode 100644
index 00000000..00a8e0ee
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/ref_argument_array.rs
@@ -0,0 +1,49 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const NSID_LENGTH: u32 = 10;
+#[repr(C)]
+pub struct nsID__bindgen_vtable {
+    pub nsID_ToProvidedString: unsafe extern "C" fn(
+        this: *mut nsID,
+        aDest: *mut [::std::os::raw::c_char; 10usize],
+    ),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct nsID {
+    pub vtable_: *const nsID__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_nsID() {
+    assert_eq!(
+        ::std::mem::size_of::<nsID>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsID))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsID>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsID))
+    );
+}
+impl Default for nsID {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN4nsID16ToProvidedStringERA10_c"]
+    pub fn nsID_ToProvidedString(
+        this: *mut ::std::os::raw::c_void,
+        aDest: *mut [::std::os::raw::c_char; 10usize],
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/reparented_replacement.rs b/bindgen-tests/tests/expectations/tests/reparented_replacement.rs
new file mode 100644
index 00000000..d9d13c1a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/reparented_replacement.rs
@@ -0,0 +1,51 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod foo {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        /// <div rustbindgen replaces="foo::Bar"></div>
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Bar {
+            pub bazz: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_Bar() {
+            const UNINIT: ::std::mem::MaybeUninit<Bar> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<Bar>(),
+                4usize,
+                concat!("Size of: ", stringify!(Bar))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<Bar>(),
+                4usize,
+                concat!("Alignment of ", stringify!(Bar))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).bazz) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(Bar),
+                    "::",
+                    stringify!(bazz)
+                )
+            );
+        }
+    }
+    pub type ReferencesBar = root::foo::Bar;
+}
diff --git a/bindgen-tests/tests/expectations/tests/replace_template_alias.rs b/bindgen-tests/tests/expectations/tests/replace_template_alias.rs
new file mode 100644
index 00000000..4f464129
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/replace_template_alias.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// But the replacement type does use T!
+///
+/// <div rustbindgen replaces="JS::detail::MaybeWrapped" />
+pub type JS_detail_MaybeWrapped<T> = T;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct JS_Rooted<T> {
+    pub ptr: JS_detail_MaybeWrapped<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for JS_Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/replace_use.rs b/bindgen-tests/tests/expectations/tests/replace_use.rs
new file mode 100644
index 00000000..d4228e12
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/replace_use.rs
@@ -0,0 +1,55 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// <div rustbindgen replaces="nsTArray"></div>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct nsTArray {
+    pub y: ::std::os::raw::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Test {
+    pub a: nsTArray,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        4usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(a))
+    );
+}
+#[test]
+fn __bindgen_test_layout_nsTArray_open0_long_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<nsTArray>(),
+        4usize,
+        concat!("Size of template specialization: ", stringify!(nsTArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsTArray>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(nsTArray)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/replaces_double.rs b/bindgen-tests/tests/expectations/tests/replaces_double.rs
new file mode 100644
index 00000000..99de1320
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/replaces_double.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Wrapper_Wrapped<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Wrapper_Wrapped<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type Wrapper_Type<T> = Wrapper_Wrapped<T>;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub ptr: Rooted_MaybeWrapped<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+/// <div rustbindgen replaces="Rooted_MaybeWrapped"></div>
+pub type Rooted_MaybeWrapped<T> = T;
+impl<T> Default for Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/repr-align.rs b/bindgen-tests/tests/expectations/tests/repr-align.rs
new file mode 100644
index 00000000..c6fee20d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/repr-align.rs
@@ -0,0 +1,74 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct a {
+    pub b: ::std::os::raw::c_int,
+    pub c: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_a() {
+    const UNINIT: ::std::mem::MaybeUninit<a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        8usize,
+        concat!("Size of: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        8usize,
+        concat!("Alignment of ", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(c))
+    );
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct b {
+    pub b: ::std::os::raw::c_int,
+    pub c: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_b() {
+    const UNINIT: ::std::mem::MaybeUninit<b> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<b>(),
+        8usize,
+        concat!("Size of: ", stringify!(b))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<b>(),
+        8usize,
+        concat!("Alignment of ", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(b), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(b), "::", stringify!(c))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs b/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs
new file mode 100644
index 00000000..79797679
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/resolved_type_def_function.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type FuncType = ::std::option::Option<unsafe extern "C" fn()>;
+extern "C" {
+    pub fn Func();
+}
diff --git a/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs b/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs
new file mode 100644
index 00000000..80024761
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/same_struct_name_in_different_namespaces.rs
@@ -0,0 +1,54 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct JS_Zone {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct JS_shadow_Zone {
+    pub x: ::std::os::raw::c_int,
+    pub y: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_JS_shadow_Zone() {
+    const UNINIT: ::std::mem::MaybeUninit<JS_shadow_Zone> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<JS_shadow_Zone>(),
+        8usize,
+        concat!("Size of: ", stringify!(JS_shadow_Zone))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<JS_shadow_Zone>(),
+        4usize,
+        concat!("Alignment of ", stringify!(JS_shadow_Zone))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JS_shadow_Zone),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(JS_shadow_Zone),
+            "::",
+            stringify!(y)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs b/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs
new file mode 100644
index 00000000..48f8ca81
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/sentry-defined-multiple-times.rs
@@ -0,0 +1,385 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod whatever {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Wrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct Wrapper_sentry {
+            pub i_am_wrapper_sentry: ::std::os::raw::c_int,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct sentry {
+            pub i_am_plain_sentry: bool,
+        }
+        #[test]
+        fn bindgen_test_layout_sentry() {
+            const UNINIT: ::std::mem::MaybeUninit<sentry> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<sentry>(),
+                1usize,
+                concat!("Size of: ", stringify!(sentry))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<sentry>(),
+                1usize,
+                concat!("Alignment of ", stringify!(sentry))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).i_am_plain_sentry) as usize -
+                        ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(sentry),
+                    "::",
+                    stringify!(i_am_plain_sentry)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct NotTemplateWrapper {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_NotTemplateWrapper() {
+            assert_eq!(
+                ::std::mem::size_of::<NotTemplateWrapper>(),
+                1usize,
+                concat!("Size of: ", stringify!(NotTemplateWrapper))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<NotTemplateWrapper>(),
+                1usize,
+                concat!("Alignment of ", stringify!(NotTemplateWrapper))
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct NotTemplateWrapper_sentry {
+            pub i_am_not_template_wrapper_sentry: ::std::os::raw::c_char,
+        }
+        #[test]
+        fn bindgen_test_layout_NotTemplateWrapper_sentry() {
+            const UNINIT: ::std::mem::MaybeUninit<NotTemplateWrapper_sentry> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<NotTemplateWrapper_sentry>(),
+                1usize,
+                concat!("Size of: ", stringify!(NotTemplateWrapper_sentry))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<NotTemplateWrapper_sentry>(),
+                1usize,
+                concat!("Alignment of ", stringify!(NotTemplateWrapper_sentry))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!(
+                        (*ptr).i_am_not_template_wrapper_sentry
+                    ) as usize -
+                        ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(NotTemplateWrapper_sentry),
+                    "::",
+                    stringify!(i_am_not_template_wrapper_sentry)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct InlineNotTemplateWrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct InlineNotTemplateWrapper_sentry {
+            pub i_am_inline_not_template_wrapper_sentry: bool,
+        }
+        #[test]
+        fn bindgen_test_layout_InlineNotTemplateWrapper_sentry() {
+            const UNINIT: ::std::mem::MaybeUninit<
+                InlineNotTemplateWrapper_sentry,
+            > = ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<InlineNotTemplateWrapper_sentry>(),
+                1usize,
+                concat!(
+                    "Size of: ",
+                    stringify!(InlineNotTemplateWrapper_sentry)
+                )
+            );
+            assert_eq!(
+                ::std::mem::align_of::<InlineNotTemplateWrapper_sentry>(),
+                1usize,
+                concat!(
+                    "Alignment of ",
+                    stringify!(InlineNotTemplateWrapper_sentry)
+                )
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!(
+                        (*ptr).i_am_inline_not_template_wrapper_sentry
+                    ) as usize -
+                        ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(InlineNotTemplateWrapper_sentry),
+                    "::",
+                    stringify!(i_am_inline_not_template_wrapper_sentry)
+                )
+            );
+        }
+        #[test]
+        fn bindgen_test_layout_InlineNotTemplateWrapper() {
+            assert_eq!(
+                ::std::mem::size_of::<InlineNotTemplateWrapper>(),
+                1usize,
+                concat!("Size of: ", stringify!(InlineNotTemplateWrapper))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<InlineNotTemplateWrapper>(),
+                1usize,
+                concat!("Alignment of ", stringify!(InlineNotTemplateWrapper))
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct InlineTemplateWrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct InlineTemplateWrapper_sentry {
+            pub i_am_inline_template_wrapper_sentry: ::std::os::raw::c_int,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleWrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleWrapper_InnerDoubleWrapper {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper() {
+            assert_eq!(
+                ::std::mem::size_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
+                1usize,
+                concat!(
+                    "Size of: ",
+                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper)
+                )
+            );
+            assert_eq!(
+                ::std::mem::align_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
+                1usize,
+                concat!(
+                    "Alignment of ",
+                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper)
+                )
+            );
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleWrapper() {
+            assert_eq!(
+                ::std::mem::size_of::<OuterDoubleWrapper>(),
+                1usize,
+                concat!("Size of: ", stringify!(OuterDoubleWrapper))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<OuterDoubleWrapper>(),
+                1usize,
+                concat!("Alignment of ", stringify!(OuterDoubleWrapper))
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleWrapper_InnerDoubleWrapper_sentry {
+            pub i_am_double_wrapper_sentry: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper_sentry() {
+            const UNINIT: ::std::mem::MaybeUninit<
+                OuterDoubleWrapper_InnerDoubleWrapper_sentry,
+            > = ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<
+                    OuterDoubleWrapper_InnerDoubleWrapper_sentry,
+                >(),
+                4usize,
+                concat!(
+                    "Size of: ",
+                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry)
+                )
+            );
+            assert_eq!(
+                ::std::mem::align_of::<
+                    OuterDoubleWrapper_InnerDoubleWrapper_sentry,
+                >(),
+                4usize,
+                concat!(
+                    "Alignment of ",
+                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry)
+                )
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).i_am_double_wrapper_sentry)
+                        as usize -
+                        ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry),
+                    "::",
+                    stringify!(i_am_double_wrapper_sentry)
+                )
+            );
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleInlineWrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone)]
+        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry {
+            pub i_am_double_wrapper_inline_sentry: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry(
+        ) {
+            const UNINIT: ::std::mem::MaybeUninit<
+                OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry,
+            > = ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq ! (:: std :: mem :: size_of :: < OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry > () , 4usize , concat ! ("Size of: " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry)));
+            assert_eq ! (:: std :: mem :: align_of :: < OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry > () , 4usize , concat ! ("Alignment of " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry)));
+            assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . i_am_double_wrapper_inline_sentry) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry) , "::" , stringify ! (i_am_double_wrapper_inline_sentry)));
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper(
+        ) {
+            assert_eq!(
+                ::std::mem::size_of::<
+                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
+                >(),
+                1usize,
+                concat!(
+                    "Size of: ",
+                    stringify!(
+                        OuterDoubleInlineWrapper_InnerDoubleInlineWrapper
+                    )
+                )
+            );
+            assert_eq!(
+                ::std::mem::align_of::<
+                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
+                >(),
+                1usize,
+                concat!(
+                    "Alignment of ",
+                    stringify!(
+                        OuterDoubleInlineWrapper_InnerDoubleInlineWrapper
+                    )
+                )
+            );
+        }
+        #[test]
+        fn bindgen_test_layout_OuterDoubleInlineWrapper() {
+            assert_eq!(
+                ::std::mem::size_of::<OuterDoubleInlineWrapper>(),
+                1usize,
+                concat!("Size of: ", stringify!(OuterDoubleInlineWrapper))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<OuterDoubleInlineWrapper>(),
+                1usize,
+                concat!("Alignment of ", stringify!(OuterDoubleInlineWrapper))
+            );
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct OutsideNamespaceWrapper {
+        pub _address: u8,
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct OutsideNamespaceWrapper_sentry {
+        pub i_am_outside_namespace_wrapper_sentry: ::std::os::raw::c_int,
+    }
+    #[repr(C)]
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct sentry {
+        pub i_am_outside_namespace_sentry: ::std::os::raw::c_int,
+    }
+    #[test]
+    fn bindgen_test_layout_sentry() {
+        const UNINIT: ::std::mem::MaybeUninit<sentry> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<sentry>(),
+            4usize,
+            concat!("Size of: ", stringify!(sentry))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<sentry>(),
+            4usize,
+            concat!("Alignment of ", stringify!(sentry))
+        );
+        assert_eq!(
+            unsafe {
+                ::std::ptr::addr_of!((*ptr).i_am_outside_namespace_sentry)
+                    as usize -
+                    ptr as usize
+            },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(sentry),
+                "::",
+                stringify!(i_am_outside_namespace_sentry)
+            )
+        );
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/short-enums.rs b/bindgen-tests/tests/expectations/tests/short-enums.rs
new file mode 100644
index 00000000..a8a494ea
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/short-enums.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum one_byte_t {
+    SOME_VALUE = 1,
+}
+#[repr(u16)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum two_byte_t {
+    SOME_OTHER_VALUE = 256,
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum four_byte_t {
+    SOME_BIGGER_VALUE = 16777216,
+}
diff --git a/bindgen-tests/tests/expectations/tests/size_t_template.rs b/bindgen-tests/tests/expectations/tests/size_t_template.rs
new file mode 100644
index 00000000..1aa8b9ac
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/size_t_template.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct C {
+    pub arr: [u32; 3usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        12usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        4usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(arr))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/sorted-items.rs b/bindgen-tests/tests/expectations/tests/sorted-items.rs
new file mode 100644
index 00000000..7df7c3d7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/sorted-items.rs
@@ -0,0 +1,82 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type number = ::std::os::raw::c_int;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Point {
+    pub x: number,
+    pub y: number,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Angle {
+    pub a: number,
+    pub b: number,
+}
+pub const NUMBER: number = 42;
+#[test]
+fn bindgen_test_layout_Point() {
+    const UNINIT: ::std::mem::MaybeUninit<Point> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Point>(),
+        8usize,
+        concat!("Size of: ", stringify!(Point))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Point>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Point))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(y))
+    );
+}
+#[test]
+fn bindgen_test_layout_Angle() {
+    const UNINIT: ::std::mem::MaybeUninit<Angle> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Angle>(),
+        8usize,
+        concat!("Size of: ", stringify!(Angle))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Angle>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Angle))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(b))
+    );
+}
+extern "C" {
+    pub fn foo() -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar(x: number) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn baz(point: Point) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/stdint_typedef.rs b/bindgen-tests/tests/expectations/tests/stdint_typedef.rs
new file mode 100644
index 00000000..a52db496
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/stdint_typedef.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn fun() -> u64;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Struct {
+    pub field: u64,
+}
+#[test]
+fn bindgen_test_layout_Struct() {
+    const UNINIT: ::std::mem::MaybeUninit<Struct> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Struct>(),
+        8usize,
+        concat!("Size of: ", stringify!(Struct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Struct>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Struct))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Struct),
+            "::",
+            stringify!(field)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs b/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs
new file mode 100644
index 00000000..8279fe1f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_containing_forward_declared_struct.rs
@@ -0,0 +1,68 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct a {
+    pub val_a: *mut b,
+}
+#[test]
+fn bindgen_test_layout_a() {
+    const UNINIT: ::std::mem::MaybeUninit<a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        8usize,
+        concat!("Size of: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        8usize,
+        concat!("Alignment of ", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).val_a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(val_a))
+    );
+}
+impl Default for a {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct b {
+    pub val_b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_b() {
+    const UNINIT: ::std::mem::MaybeUninit<b> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<b>(),
+        4usize,
+        concat!("Size of: ", stringify!(b))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<b>(),
+        4usize,
+        concat!("Alignment of ", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).val_b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(b), "::", stringify!(val_b))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_typedef.rs b/bindgen-tests/tests/expectations/tests/struct_typedef.rs
new file mode 100644
index 00000000..f9d7fedb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_typedef.rs
@@ -0,0 +1,95 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct typedef_named_struct {
+    pub has_name: bool,
+}
+#[test]
+fn bindgen_test_layout_typedef_named_struct() {
+    const UNINIT: ::std::mem::MaybeUninit<typedef_named_struct> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<typedef_named_struct>(),
+        1usize,
+        concat!("Size of: ", stringify!(typedef_named_struct))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<typedef_named_struct>(),
+        1usize,
+        concat!("Alignment of ", stringify!(typedef_named_struct))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).has_name) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(typedef_named_struct),
+            "::",
+            stringify!(has_name)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct _bindgen_ty_1 {
+    pub no_name: *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).no_name) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(no_name)
+        )
+    );
+}
+impl Default for _bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type struct_ptr_t = *mut _bindgen_ty_1;
+pub type struct_ptr_ptr_t = *mut *mut _bindgen_ty_1;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum typedef_named_enum {
+    ENUM_HAS_NAME = 1,
+}
+pub const ENUM_IS_ANON: _bindgen_ty_2 = _bindgen_ty_2::ENUM_IS_ANON;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_2 {
+    ENUM_IS_ANON = 0,
+}
+pub type enum_ptr_t = *mut _bindgen_ty_2;
+pub type enum_ptr_ptr_t = *mut *mut _bindgen_ty_2;
diff --git a/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs b/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs
new file mode 100644
index 00000000..2bad358a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_typedef_ns.rs
@@ -0,0 +1,100 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod whatever {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct typedef_struct {
+            pub foo: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout_typedef_struct() {
+            const UNINIT: ::std::mem::MaybeUninit<typedef_struct> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<typedef_struct>(),
+                4usize,
+                concat!("Size of: ", stringify!(typedef_struct))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<typedef_struct>(),
+                4usize,
+                concat!("Alignment of ", stringify!(typedef_struct))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(typedef_struct),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+        }
+        #[repr(u32)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub enum typedef_enum {
+            BAR = 1,
+        }
+    }
+    pub mod _bindgen_mod_id_12 {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        #[repr(C)]
+        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct _bindgen_ty_1 {
+            pub foo: ::std::os::raw::c_int,
+        }
+        #[test]
+        fn bindgen_test_layout__bindgen_ty_1() {
+            const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
+                ::std::mem::MaybeUninit::uninit();
+            let ptr = UNINIT.as_ptr();
+            assert_eq!(
+                ::std::mem::size_of::<_bindgen_ty_1>(),
+                4usize,
+                concat!("Size of: ", stringify!(_bindgen_ty_1))
+            );
+            assert_eq!(
+                ::std::mem::align_of::<_bindgen_ty_1>(),
+                4usize,
+                concat!("Alignment of ", stringify!(_bindgen_ty_1))
+            );
+            assert_eq!(
+                unsafe {
+                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
+                },
+                0usize,
+                concat!(
+                    "Offset of field: ",
+                    stringify!(_bindgen_ty_1),
+                    "::",
+                    stringify!(foo)
+                )
+            );
+        }
+        pub type typedef_struct = root::_bindgen_mod_id_12::_bindgen_ty_1;
+        pub const _bindgen_mod_id_12_BAR:
+            root::_bindgen_mod_id_12::_bindgen_ty_2 = _bindgen_ty_2::BAR;
+        #[repr(u32)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub enum _bindgen_ty_2 {
+            BAR = 1,
+        }
+        pub use self::super::super::root::_bindgen_mod_id_12::_bindgen_ty_2 as typedef_enum;
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs
new file mode 100644
index 00000000..238400a1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct.rs
@@ -0,0 +1,75 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs
new file mode 100644
index 00000000..f3af6b60
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_array.rs
@@ -0,0 +1,123 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: [foo__bindgen_ty_1; 2usize],
+    pub baz: [[[foo__bindgen_ty_2; 4usize]; 3usize]; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_2 {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_2>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_2),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        208usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        16usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs
new file mode 100644
index 00000000..5bb10079
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_struct_pointer.rs
@@ -0,0 +1,84 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: *mut foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs
new file mode 100644
index 00000000..08aab0a9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_union.rs
@@ -0,0 +1,93 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_union_1_0.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_union_1_0.rs
new file mode 100644
index 00000000..8db33d11
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_union_1_0.rs
@@ -0,0 +1,129 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs
new file mode 100644
index 00000000..56981065
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_struct.rs
@@ -0,0 +1,67 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs
new file mode 100644
index 00000000..499fc7a1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union.rs
@@ -0,0 +1,85 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo {
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
new file mode 100644
index 00000000..55432d47
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
@@ -0,0 +1,121 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs
new file mode 100644
index 00000000..a9be3006
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs
@@ -0,0 +1,252 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct bitfield {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub e: ::std::os::raw::c_int,
+    pub _bitfield_align_2: [u32; 0],
+    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 8usize]>,
+}
+#[test]
+fn bindgen_test_layout_bitfield() {
+    const UNINIT: ::std::mem::MaybeUninit<bitfield> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<bitfield>(),
+        16usize,
+        concat!("Size of: ", stringify!(bitfield))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<bitfield>(),
+        4usize,
+        concat!("Alignment of ", stringify!(bitfield))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).e) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(bitfield),
+            "::",
+            stringify!(e)
+        )
+    );
+}
+impl bitfield {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn c(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn d(&self) -> ::std::os::raw::c_ushort {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u16)
+        }
+    }
+    #[inline]
+    pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
+        unsafe {
+            let val: u16 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        a: ::std::os::raw::c_ushort,
+        b: ::std::os::raw::c_ushort,
+        c: ::std::os::raw::c_ushort,
+        d: ::std::os::raw::c_ushort,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let a: u16 = unsafe { ::std::mem::transmute(a) };
+            a as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let b: u16 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let c: u16 = unsafe { ::std::mem::transmute(c) };
+            c as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 2u8, {
+            let d: u16 = unsafe { ::std::mem::transmute(d) };
+            d as u64
+        });
+        __bindgen_bitfield_unit
+    }
+    #[inline]
+    pub fn f(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(0usize, 2u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_f(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_2.set(0usize, 2u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn g(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(32usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_g(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_2.set(32usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_2(
+        f: ::std::os::raw::c_uint,
+        g: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 2u8, {
+            let f: u32 = unsafe { ::std::mem::transmute(f) };
+            f as u64
+        });
+        __bindgen_bitfield_unit.set(32usize, 32u8, {
+            let g: u32 = unsafe { ::std::mem::transmute(g) };
+            g as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs b/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs
new file mode 100644
index 00000000..1bb7c77d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_derive_debug.rs
@@ -0,0 +1,149 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct LittleArray {
+    pub a: [::std::os::raw::c_int; 32usize],
+}
+#[test]
+fn bindgen_test_layout_LittleArray() {
+    const UNINIT: ::std::mem::MaybeUninit<LittleArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<LittleArray>(),
+        128usize,
+        concat!("Size of: ", stringify!(LittleArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<LittleArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(LittleArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(LittleArray),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct BigArray {
+    pub a: [::std::os::raw::c_int; 33usize],
+}
+#[test]
+fn bindgen_test_layout_BigArray() {
+    const UNINIT: ::std::mem::MaybeUninit<BigArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<BigArray>(),
+        132usize,
+        concat!("Size of: ", stringify!(BigArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<BigArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(BigArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(BigArray),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for BigArray {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct WithLittleArray {
+    pub a: LittleArray,
+}
+#[test]
+fn bindgen_test_layout_WithLittleArray() {
+    const UNINIT: ::std::mem::MaybeUninit<WithLittleArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithLittleArray>(),
+        128usize,
+        concat!("Size of: ", stringify!(WithLittleArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithLittleArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithLittleArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithLittleArray),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct WithBigArray {
+    pub a: BigArray,
+}
+#[test]
+fn bindgen_test_layout_WithBigArray() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigArray>(),
+        132usize,
+        concat!("Size of: ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Default for WithBigArray {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs b/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs
new file mode 100644
index 00000000..9f2c0ecc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_large_array.rs
@@ -0,0 +1,63 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct S {
+    pub large_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_S() {
+    const UNINIT: ::std::mem::MaybeUninit<S> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<S>(),
+        33usize,
+        concat!("Size of: ", stringify!(S))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<S>(),
+        1usize,
+        concat!("Alignment of ", stringify!(S))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(S),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for S {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct ST<T> {
+    pub large_array: [T; 33usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ST<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs b/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs
new file mode 100644
index 00000000..ff177ff1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_nesting.rs
@@ -0,0 +1,191 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo {
+    pub a: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub b: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
+    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_1 {
+    pub c1: ::std::os::raw::c_ushort,
+    pub c2: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(c1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(c2)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_2 {
+    pub d1: ::std::os::raw::c_uchar,
+    pub d2: ::std::os::raw::c_uchar,
+    pub d3: ::std::os::raw::c_uchar,
+    pub d4: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        1usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d2) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d3) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d4) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d4)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_nesting_1_0.rs b/bindgen-tests/tests/expectations/tests/struct_with_nesting_1_0.rs
new file mode 100644
index 00000000..af795b64
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_nesting_1_0.rs
@@ -0,0 +1,237 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub b: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1__bindgen_ty_1>,
+    pub __bindgen_anon_2: __BindgenUnionField<foo__bindgen_ty_1__bindgen_ty_2>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_1 {
+    pub c1: ::std::os::raw::c_ushort,
+    pub c2: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(c1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(c2)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_2 {
+    pub d1: ::std::os::raw::c_uchar,
+    pub d2: ::std::os::raw::c_uchar,
+    pub d3: ::std::os::raw::c_uchar,
+    pub d4: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        1usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d2) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d3) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d4) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(d4)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_packing.rs b/bindgen-tests/tests/expectations/tests/struct_with_packing.rs
new file mode 100644
index 00000000..b8ea17cd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_packing.rs
@@ -0,0 +1,39 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C, packed)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct a {
+    pub b: ::std::os::raw::c_char,
+    pub c: ::std::os::raw::c_short,
+}
+#[test]
+fn bindgen_test_layout_a() {
+    const UNINIT: ::std::mem::MaybeUninit<a> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<a>(),
+        3usize,
+        concat!("Size of: ", stringify!(a))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<a>(),
+        1usize,
+        concat!("Alignment of ", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        1usize,
+        concat!("Offset of field: ", stringify!(a), "::", stringify!(c))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_struct.rs b/bindgen-tests/tests/expectations/tests/struct_with_struct.rs
new file mode 100644
index 00000000..b1ee5db4
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_struct.rs
@@ -0,0 +1,75 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub x: ::std::os::raw::c_uint,
+    pub y: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(x)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(y)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs b/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs
new file mode 100644
index 00000000..49afe559
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/struct_with_typedef_template_arg.rs
@@ -0,0 +1,14 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Proxy {
+    pub _address: u8,
+}
+pub type Proxy_foo<T> =
+    ::std::option::Option<unsafe extern "C" fn(bar: *mut T)>;
diff --git a/bindgen-tests/tests/expectations/tests/template-fun-ty.rs b/bindgen-tests/tests/expectations/tests/template-fun-ty.rs
new file mode 100644
index 00000000..a7132cf0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-fun-ty.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub type Foo_FunctionPtr<T> =
+    ::std::option::Option<unsafe extern "C" fn() -> T>;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct RefPtr {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct RefPtr_Proxy {
+    pub _address: u8,
+}
+pub type RefPtr_Proxy_member_function<R, Args> =
+    ::std::option::Option<unsafe extern "C" fn(arg1: Args) -> R>;
+pub type Returner<T> = ::std::option::Option<unsafe extern "C" fn() -> T>;
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs
new file mode 100644
index 00000000..2acfb069
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-0.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for UsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs
new file mode 100644
index 00000000..4fc227c9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-1.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DoesNotUseTemplateParameter {
+    pub x: ::std::os::raw::c_int,
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs
new file mode 100644
index 00000000..c6034fb8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-10.rs
@@ -0,0 +1,42 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoublyIndirectUsage<T, U> {
+    pub doubly_indirect: DoublyIndirectUsage_IndirectUsage<T, U>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+pub type DoublyIndirectUsage_Aliased<T> = T;
+pub type DoublyIndirectUsage_Typedefed<U> = U;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoublyIndirectUsage_IndirectUsage<T, U> {
+    pub member: DoublyIndirectUsage_Aliased<T>,
+    pub another: DoublyIndirectUsage_Typedefed<U>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<T, U> Default for DoublyIndirectUsage_IndirectUsage<T, U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T, U> Default for DoublyIndirectUsage<T, U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs
new file mode 100644
index 00000000..63a31e23
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-11.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DoesNotUseT {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs
new file mode 100644
index 00000000..626e451a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-12.rs
@@ -0,0 +1,38 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct BaseUsesT<T> {
+    pub t: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for BaseUsesT<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct CrtpUsesU<U> {
+    pub _base: BaseUsesT<CrtpUsesU<U>>,
+    pub usage: U,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<U> Default for CrtpUsesU<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs
new file mode 100644
index 00000000..70c1778b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-13.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct BaseIgnoresT {
+    pub x: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct CrtpUsesU<U> {
+    pub _base: BaseIgnoresT,
+    pub usage: U,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<U> Default for CrtpUsesU<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs
new file mode 100644
index 00000000..0e0fd0c9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-14.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct BaseIgnoresT {
+    pub x: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct CrtpIgnoresU {
+    pub _base: BaseIgnoresT,
+    pub y: ::std::os::raw::c_int,
+}
+impl Default for CrtpIgnoresU {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs
new file mode 100644
index 00000000..941c6073
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-15.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct BaseUsesT<T> {
+    pub usage: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for BaseUsesT<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct CrtpIgnoresU {
+    pub _base: BaseUsesT<CrtpIgnoresU>,
+    pub y: ::std::os::raw::c_int,
+}
+impl Default for CrtpIgnoresU {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs
new file mode 100644
index 00000000..0ad5d7bb
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-2.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter_AlsoUsesTemplateParameter<T> {
+    pub also: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for UsesTemplateParameter_AlsoUsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> Default for UsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs
new file mode 100644
index 00000000..414818d9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-3.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter_AlsoUsesTemplateParameterAndMore<T, U> {
+    pub also: T,
+    pub more: U,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<T, U> Default
+    for UsesTemplateParameter_AlsoUsesTemplateParameterAndMore<T, U>
+{
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl<T> Default for UsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs
new file mode 100644
index 00000000..afcba978
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-4.rs
@@ -0,0 +1,27 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct UsesTemplateParameter<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct UsesTemplateParameter_DoesNotUseTemplateParameters {
+    pub x: ::std::os::raw::c_int,
+}
+impl<T> Default for UsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs
new file mode 100644
index 00000000..2cc8db6f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-5.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IndirectlyUsesTemplateParameter<T> {
+    pub aliased: IndirectlyUsesTemplateParameter_Aliased<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+pub type IndirectlyUsesTemplateParameter_Aliased<T> = T;
+impl<T> Default for IndirectlyUsesTemplateParameter<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs
new file mode 100644
index 00000000..3c0e5152
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-6.rs
@@ -0,0 +1,13 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DoesNotUseTemplateParameter {
+    pub x: ::std::os::raw::c_int,
+}
+pub type DoesNotUseTemplateParameter_ButAliasDoesUseIt<T> = T;
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs
new file mode 100644
index 00000000..3ed7a45d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-7.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoesNotUseU<T, V> {
+    pub t: T,
+    pub v: V,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
+}
+impl<T, V> Default for DoesNotUseU<T, V> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type Alias = DoesNotUseU<::std::os::raw::c_int, ::std::os::raw::c_char>;
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs
new file mode 100644
index 00000000..f8ac6714
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-8.rs
@@ -0,0 +1,26 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct IndirectUsage<T, U> {
+    pub member1: IndirectUsage_Typedefed<T>,
+    pub member2: IndirectUsage_Aliased<U>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+pub type IndirectUsage_Typedefed<T> = T;
+pub type IndirectUsage_Aliased<U> = U;
+impl<T, U> Default for IndirectUsage<T, U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs b/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs
new file mode 100644
index 00000000..a50079a2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-param-usage-9.rs
@@ -0,0 +1,31 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DoesNotUse {
+    pub _address: u8,
+}
+pub type DoesNotUse_Aliased<T> = T;
+pub type DoesNotUse_Typedefed<U> = U;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoesNotUse_IndirectUsage<T, U> {
+    pub member: DoesNotUse_Aliased<T>,
+    pub another: DoesNotUse_Typedefed<U>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<T, U> Default for DoesNotUse_IndirectUsage<T, U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template-with-var.rs b/bindgen-tests/tests/expectations/tests/template-with-var.rs
new file mode 100644
index 00000000..0476a256
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template-with-var.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TemplateWithVar {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/template.rs b/bindgen-tests/tests/expectations/tests/template.rs
new file mode 100644
index 00000000..7637295a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template.rs
@@ -0,0 +1,995 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct Foo<T> {
+    pub m_member: T,
+    pub m_member_ptr: *mut T,
+    pub m_member_arr: [T; 1usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Foo<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct B<T> {
+    pub m_member: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for B<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_Z3bar3FooIiiE"]
+    pub fn bar(foo: Foo<::std::os::raw::c_int>);
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mozilla_Foo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct C {
+    pub mB: B<::std::os::raw::c_uint>,
+    pub mBConstPtr: B<*const ::std::os::raw::c_int>,
+    pub mBConstStructPtr: B<*const mozilla_Foo>,
+    pub mBConstStructPtrArray: B<[*const mozilla_Foo; 1usize]>,
+    pub mBConst: B<::std::os::raw::c_int>,
+    pub mBVolatile: B<::std::os::raw::c_int>,
+    pub mBConstBool: B<bool>,
+    pub mBConstChar: B<u16>,
+    pub mBArray: B<[::std::os::raw::c_int; 1usize]>,
+    pub mBPtrArray: B<[*mut ::std::os::raw::c_int; 1usize]>,
+    pub mBArrayPtr: B<*mut [::std::os::raw::c_int; 1usize]>,
+    pub mBRef: B<*mut ::std::os::raw::c_int>,
+    pub mBConstRef: B<*const ::std::os::raw::c_int>,
+    pub mPtrRef: B<*mut *mut ::std::os::raw::c_int>,
+    pub mArrayRef: B<*mut [::std::os::raw::c_int; 1usize]>,
+    pub mBConstArray: B<[::std::os::raw::c_int; 1usize]>,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        104usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        8usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mB) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(mB))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstPtr) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstPtr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstStructPtr) as usize -
+                ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstStructPtr)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstStructPtrArray) as usize -
+                ptr as usize
+        },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstStructPtrArray)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBConst) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConst)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBVolatile) as usize - ptr as usize
+        },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBVolatile)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstBool) as usize - ptr as usize
+        },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstBool)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstChar) as usize - ptr as usize
+        },
+        42usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstChar)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBArray) as usize - ptr as usize },
+        44usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBArray)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBPtrArray) as usize - ptr as usize
+        },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBPtrArray)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBArrayPtr) as usize - ptr as usize
+        },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBArrayPtr)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBRef) as usize - ptr as usize },
+        64usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(mBRef))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstRef) as usize - ptr as usize
+        },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstRef)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mPtrRef) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mPtrRef)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mArrayRef) as usize - ptr as usize
+        },
+        88usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mArrayRef)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mBConstArray) as usize - ptr as usize
+        },
+        96usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(C),
+            "::",
+            stringify!(mBConstArray)
+        )
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct D {
+    pub m_foo: D_MyFoo,
+}
+pub type D_MyFoo = Foo<::std::os::raw::c_int>;
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct D_U<Z> {
+    pub m_nested_foo: D_MyFoo,
+    pub m_baz: Z,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<Z>>,
+}
+impl<Z> Default for D_U<Z> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for D {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Rooted<T> {
+    pub prev: *mut T,
+    pub next: *mut Rooted<*mut ::std::os::raw::c_void>,
+    pub ptr: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct RootedContainer {
+    pub root: Rooted<*mut ::std::os::raw::c_void>,
+}
+#[test]
+fn bindgen_test_layout_RootedContainer() {
+    const UNINIT: ::std::mem::MaybeUninit<RootedContainer> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<RootedContainer>(),
+        24usize,
+        concat!("Size of: ", stringify!(RootedContainer))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<RootedContainer>(),
+        8usize,
+        concat!("Alignment of ", stringify!(RootedContainer))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(RootedContainer),
+            "::",
+            stringify!(root)
+        )
+    );
+}
+impl Default for RootedContainer {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type WithDtorIntFwd = WithDtor<::std::os::raw::c_int>;
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct WithDtor<T> {
+    pub member: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for WithDtor<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct PODButContainsDtor {
+    pub member: WithDtorIntFwd,
+}
+#[test]
+fn bindgen_test_layout_PODButContainsDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<PODButContainsDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<PODButContainsDtor>(),
+        4usize,
+        concat!("Size of: ", stringify!(PODButContainsDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PODButContainsDtor>(),
+        4usize,
+        concat!("Alignment of ", stringify!(PODButContainsDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(PODButContainsDtor),
+            "::",
+            stringify!(member)
+        )
+    );
+}
+impl Default for PODButContainsDtor {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// <div rustbindgen opaque>
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Opaque {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct POD {
+    pub opaque_member: u32,
+}
+#[test]
+fn bindgen_test_layout_POD() {
+    const UNINIT: ::std::mem::MaybeUninit<POD> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<POD>(),
+        4usize,
+        concat!("Size of: ", stringify!(POD))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<POD>(),
+        4usize,
+        concat!("Alignment of ", stringify!(POD))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).opaque_member) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(POD),
+            "::",
+            stringify!(opaque_member)
+        )
+    );
+}
+/// <div rustbindgen replaces="NestedReplaced"></div>
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NestedReplaced<T> {
+    pub buff: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for NestedReplaced<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NestedBase<T> {
+    pub buff: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for NestedBase<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NestedContainer<T> {
+    pub c: T,
+    pub nested: NestedReplaced<T>,
+    pub inc: Incomplete<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for NestedContainer<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Incomplete<T> {
+    pub d: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Incomplete<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Untemplated {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Untemplated() {
+    assert_eq!(
+        ::std::mem::size_of::<Untemplated>(),
+        1usize,
+        concat!("Size of: ", stringify!(Untemplated))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Untemplated>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Untemplated))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Templated {
+    pub m_untemplated: Untemplated,
+}
+/// If the replacement doesn't happen at the parse level the container would be
+/// copy and the replacement wouldn't, so this wouldn't compile.
+///
+/// <div rustbindgen replaces="ReplacedWithoutDestructor"></div>
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ReplacedWithoutDestructor<T> {
+    pub buff: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ReplacedWithoutDestructor<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ShouldNotBeCopiable<T> {
+    pub m_member: ReplacedWithoutDestructor<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ShouldNotBeCopiable<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ShouldNotBeCopiableAsWell<U> {
+    pub m_member: ReplacedWithoutDestructorFwd<U>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
+}
+impl<U> Default for ShouldNotBeCopiableAsWell<U> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+/// If the replacement doesn't happen at the parse level the container would be
+/// copy and the replacement wouldn't, so this wouldn't compile.
+///
+/// <div rustbindgen replaces="ReplacedWithoutDestructorFwd"></div>
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ReplacedWithoutDestructorFwd<T> {
+    pub buff: *mut T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ReplacedWithoutDestructorFwd<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_Foo_open0_int_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo<::std::os::raw::c_int>>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(Foo<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo<::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(Foo<::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_unsigned_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<::std::os::raw::c_uint>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<::std::os::raw::c_uint>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<::std::os::raw::c_uint>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<::std::os::raw::c_uint>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ptr_const_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*const ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*const ::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*const ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*const ::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ptr_const_mozilla__Foo_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*const mozilla_Foo>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*const mozilla_Foo>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*const mozilla_Foo>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*const mozilla_Foo>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_array1_ptr_const_mozilla__Foo_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<B<[*const mozilla_Foo; 1usize]>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<[*const mozilla_Foo; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<[*const mozilla_Foo; 1usize]>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<[*const mozilla_Foo; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_const_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_volatile_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_const_bool_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<bool>>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(B<bool>))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<bool>>(),
+        1usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<bool>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_const_char16_t_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<u16>>(),
+        2usize,
+        concat!("Size of template specialization: ", stringify!(B<u16>))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<u16>>(),
+        2usize,
+        concat!("Alignment of template specialization: ", stringify!(B<u16>))
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_array1_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<[::std::os::raw::c_int; 1usize]>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<[::std::os::raw::c_int; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<[::std::os::raw::c_int; 1usize]>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<[::std::os::raw::c_int; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_array1_ptr_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<[*mut ::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<[*mut ::std::os::raw::c_int; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<[*mut ::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<[*mut ::std::os::raw::c_int; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ptr_array1_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ref_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*mut ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*mut ::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*mut ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*mut ::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ref_const_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*const ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*const ::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*const ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*const ::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ref_ptr_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*mut *mut ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*mut *mut ::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*mut *mut ::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*mut *mut ::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_ref_array1_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_B_open0_array1_const_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<B<[::std::os::raw::c_int; 1usize]>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(B<[::std::os::raw::c_int; 1usize]>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B<[::std::os::raw::c_int; 1usize]>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(B<[::std::os::raw::c_int; 1usize]>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_Foo_open0_int_int_close0_instantiation_1() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo<::std::os::raw::c_int>>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(Foo<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo<::std::os::raw::c_int>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(Foo<::std::os::raw::c_int>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_Rooted_open0_ptr_void_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(Rooted<*mut ::std::os::raw::c_void>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(Rooted<*mut ::std::os::raw::c_void>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_Rooted_open0_ptr_void_close0_instantiation_1() {
+    assert_eq!(
+        ::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(Rooted<*mut ::std::os::raw::c_void>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(Rooted<*mut ::std::os::raw::c_void>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_WithDtor_open0_int_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<WithDtor<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(WithDtor<::std::os::raw::c_int>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDtor<::std::os::raw::c_int>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(WithDtor<::std::os::raw::c_int>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/template_alias.rs b/bindgen-tests/tests/expectations/tests/template_alias.rs
new file mode 100644
index 00000000..7e0af20d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_alias.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type JS_detail_Wrapped<T> = T;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct JS_Rooted<T> {
+    pub ptr: JS_detail_Wrapped<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for JS_Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template_alias_basic.rs b/bindgen-tests/tests/expectations/tests/template_alias_basic.rs
new file mode 100644
index 00000000..e06ffada
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_alias_basic.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type Wrapped<T> = T;
diff --git a/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs b/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs
new file mode 100644
index 00000000..7196b532
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_alias_namespace.rs
@@ -0,0 +1,37 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod JS {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod detail {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            pub type Wrapped<T> = T;
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct Rooted<T> {
+            pub ptr: root::JS::detail::Wrapped<T>,
+            pub _phantom_0:
+                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+        }
+        impl<T> Default for Rooted<T> {
+            fn default() -> Self {
+                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+                unsafe {
+                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                    s.assume_init()
+                }
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/template_fun.rs b/bindgen-tests/tests/expectations/tests/template_fun.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_fun.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs
new file mode 100644
index 00000000..d968e71b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs
@@ -0,0 +1,96 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_Z1fv"]
+    pub fn f();
+}
+#[test]
+fn __bindgen_test_layout_Foo_open0_Bar_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(Foo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Baz {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        1usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+}
+#[test]
+fn __bindgen_test_layout_Foo_open0_Boo_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of template specialization: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of template specialization: ", stringify!(Foo))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Boo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Boo() {
+    assert_eq!(
+        ::std::mem::size_of::<Boo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Boo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Boo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Boo))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/template_partial_specification.rs b/bindgen-tests/tests/expectations/tests/template_partial_specification.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_partial_specification.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs b/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs
new file mode 100644
index 00000000..68ca126a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_typedef_transitive_param.rs
@@ -0,0 +1,28 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Wrapper {
+    pub _address: u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Wrapper_Wrapped<T> {
+    pub t: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Wrapper_Wrapped<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type Wrapper_Type<T> = Wrapper_Wrapped<T>;
diff --git a/bindgen-tests/tests/expectations/tests/template_typedefs.rs b/bindgen-tests/tests/expectations/tests/template_typedefs.rs
new file mode 100644
index 00000000..3883879d
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/template_typedefs.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type foo =
+    ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+pub type Foo_Char<T> = T;
+pub type Foo_FooPtrTypedef<T> = *mut Foo_Char<T>;
+pub type Foo_nsCOMArrayEnumFunc<T> = ::std::option::Option<
+    unsafe extern "C" fn(
+        aElement: *mut T,
+        aData: *mut ::std::os::raw::c_void,
+    ) -> bool,
+>;
diff --git a/bindgen-tests/tests/expectations/tests/templateref_opaque.rs b/bindgen-tests/tests/expectations/tests/templateref_opaque.rs
new file mode 100644
index 00000000..70cef867
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/templateref_opaque.rs
@@ -0,0 +1,19 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct detail_PointerType {
+    pub _address: u8,
+}
+pub type detail_PointerType_Type<T> = *mut T;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct UniquePtr {
+    pub _address: u8,
+}
+pub type UniquePtr_Pointer = detail_PointerType;
diff --git a/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs b/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs
new file mode 100644
index 00000000..5657a655
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/templatized-bitfield.rs
@@ -0,0 +1,15 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+/// We don't get a layout for this bitfield, since we don't know what `T` will
+/// be, so we cannot allocate bitfield units. The best thing we can do is make
+/// the struct opaque.
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TemplatizedBitfield {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs b/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs
new file mode 100644
index 00000000..5f8da2af
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/test_mixed_header_and_header_contents.rs
@@ -0,0 +1,114 @@
+extern "C" {
+    pub static mut foo: ::std::option::Option<
+        unsafe extern "C" fn(
+            x: ::std::os::raw::c_int,
+            y: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+    >;
+}
+extern "C" {
+    pub fn bar(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn bar2(b: *const ::std::os::raw::c_char) -> f32;
+}
+pub type Char = ::std::os::raw::c_char;
+pub type SChar = ::std::os::raw::c_schar;
+pub type UChar = ::std::os::raw::c_uchar;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Test {
+    pub ch: ::std::os::raw::c_char,
+    pub u: ::std::os::raw::c_uchar,
+    pub d: ::std::os::raw::c_schar,
+    pub cch: ::std::os::raw::c_char,
+    pub cu: ::std::os::raw::c_uchar,
+    pub cd: ::std::os::raw::c_schar,
+    pub Cch: Char,
+    pub Cu: UChar,
+    pub Cd: SChar,
+    pub Ccch: Char,
+    pub Ccu: UChar,
+    pub Ccd: SChar,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        12usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        1usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        2usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
+        3usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
+        5usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
+        6usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
+        7usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Test),
+            "::",
+            stringify!(Ccch)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
+        10usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
+        11usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs b/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs
new file mode 100644
index 00000000..b594d70c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/test_multiple_header_calls_in_builder.rs
@@ -0,0 +1,108 @@
+extern "C" {
+    pub static mut foo: ::std::option::Option<
+        unsafe extern "C" fn(
+            x: ::std::os::raw::c_int,
+            y: ::std::os::raw::c_int,
+        ) -> ::std::os::raw::c_int,
+    >;
+}
+pub type Char = ::std::os::raw::c_char;
+pub type SChar = ::std::os::raw::c_schar;
+pub type UChar = ::std::os::raw::c_uchar;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Test {
+    pub ch: ::std::os::raw::c_char,
+    pub u: ::std::os::raw::c_uchar,
+    pub d: ::std::os::raw::c_schar,
+    pub cch: ::std::os::raw::c_char,
+    pub cu: ::std::os::raw::c_uchar,
+    pub cd: ::std::os::raw::c_schar,
+    pub Cch: Char,
+    pub Cu: UChar,
+    pub Cd: SChar,
+    pub Ccch: Char,
+    pub Ccu: UChar,
+    pub Ccd: SChar,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    const UNINIT: ::std::mem::MaybeUninit<Test> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Test>(),
+        12usize,
+        concat!("Size of: ", stringify!(Test))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Test>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Test))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
+        1usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
+        2usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
+        3usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
+        5usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
+        6usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
+        7usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Test),
+            "::",
+            stringify!(Ccch)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
+        10usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
+        11usize,
+        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/timex.rs b/bindgen-tests/tests/expectations/tests/timex.rs
new file mode 100644
index 00000000..dfcebdd2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/timex.rs
@@ -0,0 +1,322 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct timex {
+    pub tai: ::std::os::raw::c_int,
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
+}
+#[test]
+fn bindgen_test_layout_timex() {
+    const UNINIT: ::std::mem::MaybeUninit<timex> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<timex>(),
+        48usize,
+        concat!("Size of: ", stringify!(timex))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<timex>(),
+        4usize,
+        concat!("Alignment of ", stringify!(timex))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tai) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(timex),
+            "::",
+            stringify!(tai)
+        )
+    );
+}
+impl Default for timex {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct timex_named {
+    pub tai: ::std::os::raw::c_int,
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
+}
+#[test]
+fn bindgen_test_layout_timex_named() {
+    const UNINIT: ::std::mem::MaybeUninit<timex_named> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<timex_named>(),
+        48usize,
+        concat!("Size of: ", stringify!(timex_named))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<timex_named>(),
+        4usize,
+        concat!("Alignment of ", stringify!(timex_named))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tai) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(timex_named),
+            "::",
+            stringify!(tai)
+        )
+    );
+}
+impl Default for timex_named {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl timex_named {
+    #[inline]
+    pub fn a(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(32usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn c(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(64usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(64usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn d(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(96usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_d(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(96usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn e(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(128usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_e(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(128usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn f(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(160usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_f(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(160usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn g(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(192usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_g(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(192usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn h(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(224usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_h(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(224usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn i(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(256usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_i(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(256usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn j(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(288usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_j(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(288usize, 32u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn k(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(320usize, 32u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_k(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(320usize, 32u8, val as u64)
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/transform-op.rs b/bindgen-tests/tests/expectations/tests/transform-op.rs
new file mode 100644
index 00000000..84a94603
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/transform-op.rs
@@ -0,0 +1,260 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StylePoint<T> {
+    pub x: T,
+    pub y: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StylePoint<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct StyleFoo<T> {
+    pub __bindgen_anon_1: __BindgenUnionField<StyleFoo__bindgen_ty_1>,
+    pub foo: __BindgenUnionField<StyleFoo_Foo_Body<T>>,
+    pub bar: __BindgenUnionField<StyleFoo_Bar_Body<T>>,
+    pub baz: __BindgenUnionField<StyleFoo_Baz_Body<T>>,
+    pub bindgen_union_field: [u8; 0usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+pub const StyleFoo_Tag_Foo: StyleFoo_Tag = 0;
+pub const StyleFoo_Tag_Bar: StyleFoo_Tag = 0;
+pub const StyleFoo_Tag_Baz: StyleFoo_Tag = 0;
+pub const StyleFoo_Tag_Bazz: StyleFoo_Tag = 0;
+pub type StyleFoo_Tag = u8;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleFoo_Foo_Body<T> {
+    pub tag: StyleFoo_Tag,
+    pub x: i32,
+    pub y: StylePoint<T>,
+    pub z: StylePoint<f32>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleFoo_Foo_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleFoo_Bar_Body<T> {
+    pub tag: StyleFoo_Tag,
+    pub _0: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleFoo_Bar_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleFoo_Baz_Body<T> {
+    pub tag: StyleFoo_Tag,
+    pub _0: StylePoint<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleFoo_Baz_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleFoo__bindgen_ty_1 {
+    pub tag: StyleFoo_Tag,
+}
+impl Default for StyleFoo__bindgen_ty_1 {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleBar<T> {
+    pub tag: StyleBar_Tag,
+    pub __bindgen_anon_1: StyleBar__bindgen_ty_1<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+pub const StyleBar_Tag_Bar1: StyleBar_Tag = 0;
+pub const StyleBar_Tag_Bar2: StyleBar_Tag = 0;
+pub const StyleBar_Tag_Bar3: StyleBar_Tag = 0;
+pub const StyleBar_Tag_Bar4: StyleBar_Tag = 0;
+pub type StyleBar_Tag = ::std::os::raw::c_int;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleBar_StyleBar1_Body<T> {
+    pub x: i32,
+    pub y: StylePoint<T>,
+    pub z: StylePoint<f32>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleBar_StyleBar1_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleBar_StyleBar2_Body<T> {
+    pub _0: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleBar_StyleBar2_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StyleBar_StyleBar3_Body<T> {
+    pub _0: StylePoint<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleBar_StyleBar3_Body<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct StyleBar__bindgen_ty_1<T> {
+    pub bar1: __BindgenUnionField<StyleBar_StyleBar1_Body<T>>,
+    pub bar2: __BindgenUnionField<StyleBar_StyleBar2_Body<T>>,
+    pub bar3: __BindgenUnionField<StyleBar_StyleBar3_Body<T>>,
+    pub bindgen_union_field: [u8; 0usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for StyleBar<T> {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_StylePoint_open0_float_close0_instantiation() {
+    assert_eq!(
+        ::std::mem::size_of::<StylePoint<f32>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(StylePoint<f32>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StylePoint<f32>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(StylePoint<f32>)
+        )
+    );
+}
+#[test]
+fn __bindgen_test_layout_StylePoint_open0_float_close0_instantiation_1() {
+    assert_eq!(
+        ::std::mem::size_of::<StylePoint<f32>>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(StylePoint<f32>)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StylePoint<f32>>(),
+        4usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(StylePoint<f32>)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs b/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs
new file mode 100644
index 00000000..7ae042bc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/type-referenced-by-allowlisted-function.rs
@@ -0,0 +1,41 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct dl_phdr_info {
+    pub x: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_dl_phdr_info() {
+    const UNINIT: ::std::mem::MaybeUninit<dl_phdr_info> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<dl_phdr_info>(),
+        4usize,
+        concat!("Size of: ", stringify!(dl_phdr_info))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<dl_phdr_info>(),
+        4usize,
+        concat!("Alignment of ", stringify!(dl_phdr_info))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dl_phdr_info),
+            "::",
+            stringify!(x)
+        )
+    );
+}
+extern "C" {
+    pub fn dl_iterate_phdr(arg1: *mut dl_phdr_info) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/type_alias_empty.rs b/bindgen-tests/tests/expectations/tests/type_alias_empty.rs
new file mode 100644
index 00000000..cb871a33
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/type_alias_empty.rs
@@ -0,0 +1,8 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type bool_constant = u8;
diff --git a/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs b/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs
new file mode 100644
index 00000000..44449f20
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/type_alias_partial_template_especialization.rs
@@ -0,0 +1,23 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type MaybeWrapped<A> = A;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub ptr: MaybeWrapped<T>,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Rooted<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs b/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs
new file mode 100644
index 00000000..330499b8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/typedefd-array-as-function-arg.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub type myVector3 = [f32; 3usize];
+extern "C" {
+    pub fn modifyVectorFunc(v: *mut f32);
+}
diff --git a/bindgen-tests/tests/expectations/tests/typeref.rs b/bindgen-tests/tests/expectations/tests/typeref.rs
new file mode 100644
index 00000000..a3a31daf
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/typeref.rs
@@ -0,0 +1,179 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct mozilla_FragmentOrURL {
+    pub mIsLocalRef: bool,
+}
+#[test]
+fn bindgen_test_layout_mozilla_FragmentOrURL() {
+    const UNINIT: ::std::mem::MaybeUninit<mozilla_FragmentOrURL> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_FragmentOrURL>(),
+        1usize,
+        concat!("Size of: ", stringify!(mozilla_FragmentOrURL))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_FragmentOrURL>(),
+        1usize,
+        concat!("Alignment of ", stringify!(mozilla_FragmentOrURL))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsLocalRef) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(mozilla_FragmentOrURL),
+            "::",
+            stringify!(mIsLocalRef)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct mozilla_Position {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_mozilla_Position() {
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_Position>(),
+        1usize,
+        concat!("Size of: ", stringify!(mozilla_Position))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_Position>(),
+        1usize,
+        concat!("Alignment of ", stringify!(mozilla_Position))
+    );
+}
+#[repr(C)]
+pub struct mozilla_StyleShapeSource {
+    pub __bindgen_anon_1: mozilla_StyleShapeSource__bindgen_ty_1,
+}
+#[repr(C)]
+pub union mozilla_StyleShapeSource__bindgen_ty_1 {
+    pub mPosition: *mut mozilla_Position,
+    pub mFragmentOrURL: *mut mozilla_FragmentOrURL,
+}
+impl Default for mozilla_StyleShapeSource__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for mozilla_StyleShapeSource {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Bar {
+    pub mFoo: *mut nsFoo,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(mFoo))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct nsFoo {
+    pub mBar: mozilla_StyleShapeSource,
+}
+#[test]
+fn bindgen_test_layout_nsFoo() {
+    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsFoo>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsFoo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsFoo),
+            "::",
+            stringify!(mBar)
+        )
+    );
+}
+impl Default for nsFoo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn __bindgen_test_layout_mozilla_StyleShapeSource_open0_int_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_StyleShapeSource>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(mozilla_StyleShapeSource)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_StyleShapeSource>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(mozilla_StyleShapeSource)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/typeref_1_0.rs b/bindgen-tests/tests/expectations/tests/typeref_1_0.rs
new file mode 100644
index 00000000..8e4143c0
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/typeref_1_0.rs
@@ -0,0 +1,219 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct mozilla_FragmentOrURL {
+    pub mIsLocalRef: bool,
+}
+#[test]
+fn bindgen_test_layout_mozilla_FragmentOrURL() {
+    const UNINIT: ::std::mem::MaybeUninit<mozilla_FragmentOrURL> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_FragmentOrURL>(),
+        1usize,
+        concat!("Size of: ", stringify!(mozilla_FragmentOrURL))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_FragmentOrURL>(),
+        1usize,
+        concat!("Alignment of ", stringify!(mozilla_FragmentOrURL))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mIsLocalRef) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(mozilla_FragmentOrURL),
+            "::",
+            stringify!(mIsLocalRef)
+        )
+    );
+}
+impl Clone for mozilla_FragmentOrURL {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct mozilla_Position {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_mozilla_Position() {
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_Position>(),
+        1usize,
+        concat!("Size of: ", stringify!(mozilla_Position))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_Position>(),
+        1usize,
+        concat!("Alignment of ", stringify!(mozilla_Position))
+    );
+}
+impl Clone for mozilla_Position {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct mozilla_StyleShapeSource {
+    pub __bindgen_anon_1: mozilla_StyleShapeSource__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct mozilla_StyleShapeSource__bindgen_ty_1 {
+    pub mPosition: __BindgenUnionField<*mut mozilla_Position>,
+    pub mFragmentOrURL: __BindgenUnionField<*mut mozilla_FragmentOrURL>,
+    pub bindgen_union_field: u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct Bar {
+    pub mFoo: *mut nsFoo,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        8usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(mFoo))
+    );
+}
+impl Clone for Bar {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for Bar {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct nsFoo {
+    pub mBar: mozilla_StyleShapeSource,
+}
+#[test]
+fn bindgen_test_layout_nsFoo() {
+    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsFoo>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsFoo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsFoo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsFoo),
+            "::",
+            stringify!(mBar)
+        )
+    );
+}
+impl Clone for nsFoo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn __bindgen_test_layout_mozilla_StyleShapeSource_open0_int_close0_instantiation(
+) {
+    assert_eq!(
+        ::std::mem::size_of::<mozilla_StyleShapeSource>(),
+        8usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(mozilla_StyleShapeSource)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<mozilla_StyleShapeSource>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(mozilla_StyleShapeSource)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/underscore.rs b/bindgen-tests/tests/expectations/tests/underscore.rs
new file mode 100644
index 00000000..bfc05ac1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/underscore.rs
@@ -0,0 +1,34 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const __: ::std::os::raw::c_int = 10;
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct ptr_t {
+    pub __: [::std::os::raw::c_uchar; 8usize],
+}
+#[test]
+fn bindgen_test_layout_ptr_t() {
+    const UNINIT: ::std::mem::MaybeUninit<ptr_t> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ptr_t>(),
+        8usize,
+        concat!("Size of: ", stringify!(ptr_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ptr_t>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ptr_t))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).__) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(ptr_t), "::", stringify!(__))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/union-align.rs b/bindgen-tests/tests/expectations/tests/union-align.rs
new file mode 100644
index 00000000..062ea97a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union-align.rs
@@ -0,0 +1,79 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Copy, Clone)]
+pub union Bar {
+    pub foo: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        16usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(foo))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Copy, Clone)]
+pub union Baz {
+    pub bar: Bar,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    const UNINIT: ::std::mem::MaybeUninit<Baz> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        16usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        16usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(bar))
+    );
+}
+impl Default for Baz {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union-in-ns.rs b/bindgen-tests/tests/expectations/tests/union-in-ns.rs
new file mode 100644
index 00000000..65f3f8f2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union-in-ns.rs
@@ -0,0 +1,52 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub union bar {
+        pub baz: ::std::os::raw::c_int,
+    }
+    #[test]
+    fn bindgen_test_layout_bar() {
+        const UNINIT: ::std::mem::MaybeUninit<bar> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<bar>(),
+            4usize,
+            concat!("Size of: ", stringify!(bar))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<bar>(),
+            4usize,
+            concat!("Alignment of ", stringify!(bar))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(bar),
+                "::",
+                stringify!(baz)
+            )
+        );
+    }
+    impl Default for bar {
+        fn default() -> Self {
+            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+            unsafe {
+                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                s.assume_init()
+            }
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union-in-ns_1_0.rs b/bindgen-tests/tests/expectations/tests/union-in-ns_1_0.rs
new file mode 100644
index 00000000..a057cc34
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union-in-ns_1_0.rs
@@ -0,0 +1,95 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[repr(C)]
+    pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+    impl<T> __BindgenUnionField<T> {
+        #[inline]
+        pub fn new() -> Self {
+            __BindgenUnionField(::std::marker::PhantomData)
+        }
+        #[inline]
+        pub unsafe fn as_ref(&self) -> &T {
+            ::std::mem::transmute(self)
+        }
+        #[inline]
+        pub unsafe fn as_mut(&mut self) -> &mut T {
+            ::std::mem::transmute(self)
+        }
+    }
+    impl<T> ::std::default::Default for __BindgenUnionField<T> {
+        #[inline]
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+    impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+        #[inline]
+        fn clone(&self) -> Self {
+            Self::new()
+        }
+    }
+    impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+    impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+        fn fmt(
+            &self,
+            fmt: &mut ::std::fmt::Formatter<'_>,
+        ) -> ::std::fmt::Result {
+            fmt.write_str("__BindgenUnionField")
+        }
+    }
+    impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+        fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+    }
+    impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+        fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+            true
+        }
+    }
+    impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+    #[allow(unused_imports)]
+    use self::super::root;
+    #[repr(C)]
+    #[derive(Debug, Default, Copy)]
+    pub struct bar {
+        pub baz: root::__BindgenUnionField<::std::os::raw::c_int>,
+        pub bindgen_union_field: u32,
+    }
+    #[test]
+    fn bindgen_test_layout_bar() {
+        const UNINIT: ::std::mem::MaybeUninit<bar> =
+            ::std::mem::MaybeUninit::uninit();
+        let ptr = UNINIT.as_ptr();
+        assert_eq!(
+            ::std::mem::size_of::<bar>(),
+            4usize,
+            concat!("Size of: ", stringify!(bar))
+        );
+        assert_eq!(
+            ::std::mem::align_of::<bar>(),
+            4usize,
+            concat!("Alignment of ", stringify!(bar))
+        );
+        assert_eq!(
+            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+            0usize,
+            concat!(
+                "Offset of field: ",
+                stringify!(bar),
+                "::",
+                stringify!(baz)
+            )
+        );
+    }
+    impl Clone for bar {
+        fn clone(&self) -> Self {
+            *self
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_bitfield.rs
new file mode 100644
index 00000000..9e07a1df
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_bitfield.rs
@@ -0,0 +1,223 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Copy, Clone)]
+pub union U4 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+}
+#[test]
+fn bindgen_test_layout_U4() {
+    assert_eq!(
+        ::std::mem::size_of::<U4>(),
+        4usize,
+        concat!("Size of: ", stringify!(U4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<U4>(),
+        4usize,
+        concat!("Alignment of ", stringify!(U4))
+    );
+}
+impl Default for U4 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl U4 {
+    #[inline]
+    pub fn derp(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_derp(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        derp: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let derp: u32 = unsafe { ::std::mem::transmute(derp) };
+            derp as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Copy, Clone)]
+pub union B {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+impl Default for B {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl B {
+    #[inline]
+    pub fn foo(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 31u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bar(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        foo: ::std::os::raw::c_uint,
+        bar: ::std::os::raw::c_uchar,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 31u8, {
+            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
+            foo as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
+            bar as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_bitfield_1_0.rs b/bindgen-tests/tests/expectations/tests/union_bitfield_1_0.rs
new file mode 100644
index 00000000..22277468
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_bitfield_1_0.rs
@@ -0,0 +1,298 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct U4 {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 1usize]>>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_U4() {
+    assert_eq!(
+        ::std::mem::size_of::<U4>(),
+        4usize,
+        concat!("Size of: ", stringify!(U4))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<U4>(),
+        4usize,
+        concat!("Alignment of ", stringify!(U4))
+    );
+}
+impl Clone for U4 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl U4 {
+    #[inline]
+    pub fn derp(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(
+                self._bitfield_1.as_ref().get(0usize, 1u8) as u32
+            )
+        }
+    }
+    #[inline]
+    pub fn set_derp(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.as_mut().set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        derp: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let derp: u32 = unsafe { ::std::mem::transmute(derp) };
+            derp as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct B {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 4usize]>>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        4usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        4usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+}
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl B {
+    #[inline]
+    pub fn foo(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(
+                self._bitfield_1.as_ref().get(0usize, 31u8) as u32
+            )
+        }
+    }
+    #[inline]
+    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.as_mut().set(0usize, 31u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bar(&self) -> ::std::os::raw::c_uchar {
+        unsafe {
+            ::std::mem::transmute(
+                self._bitfield_1.as_ref().get(31usize, 1u8) as u8
+            )
+        }
+    }
+    #[inline]
+    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_1.as_mut().set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        foo: ::std::os::raw::c_uint,
+        bar: ::std::os::raw::c_uchar,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 31u8, {
+            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
+            foo as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
+            bar as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Copy)]
+pub struct HasBigBitfield {
+    pub _bitfield_align_1: [u64; 0],
+    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 16usize]>>,
+    pub bindgen_union_field: [u8; 16usize],
+}
+#[test]
+fn bindgen_test_layout_HasBigBitfield() {
+    assert_eq!(
+        ::std::mem::size_of::<HasBigBitfield>(),
+        16usize,
+        concat!("Size of: ", stringify!(HasBigBitfield))
+    );
+}
+impl Clone for HasBigBitfield {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for HasBigBitfield {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+impl ::std::cmp::PartialEq for HasBigBitfield {
+    fn eq(&self, other: &HasBigBitfield) -> bool {
+        &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_dtor.rs b/bindgen-tests/tests/expectations/tests/union_dtor.rs
new file mode 100644
index 00000000..085e5ca3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_dtor.rs
@@ -0,0 +1,67 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub union UnionWithDtor {
+    pub mFoo: ::std::os::raw::c_int,
+    pub mBar: *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout_UnionWithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<UnionWithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<UnionWithDtor>(),
+        8usize,
+        concat!("Size of: ", stringify!(UnionWithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<UnionWithDtor>(),
+        8usize,
+        concat!("Alignment of ", stringify!(UnionWithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UnionWithDtor),
+            "::",
+            stringify!(mFoo)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UnionWithDtor),
+            "::",
+            stringify!(mBar)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN13UnionWithDtorD1Ev"]
+    pub fn UnionWithDtor_UnionWithDtor_destructor(this: *mut UnionWithDtor);
+}
+impl Default for UnionWithDtor {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl UnionWithDtor {
+    #[inline]
+    pub unsafe fn destruct(&mut self) {
+        UnionWithDtor_UnionWithDtor_destructor(self)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_dtor_1_0.rs b/bindgen-tests/tests/expectations/tests/union_dtor_1_0.rs
new file mode 100644
index 00000000..67455aa8
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_dtor_1_0.rs
@@ -0,0 +1,103 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct UnionWithDtor {
+    pub mFoo: __BindgenUnionField<::std::os::raw::c_int>,
+    pub mBar: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    pub bindgen_union_field: u64,
+}
+#[test]
+fn bindgen_test_layout_UnionWithDtor() {
+    const UNINIT: ::std::mem::MaybeUninit<UnionWithDtor> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<UnionWithDtor>(),
+        8usize,
+        concat!("Size of: ", stringify!(UnionWithDtor))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<UnionWithDtor>(),
+        8usize,
+        concat!("Alignment of ", stringify!(UnionWithDtor))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UnionWithDtor),
+            "::",
+            stringify!(mFoo)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(UnionWithDtor),
+            "::",
+            stringify!(mBar)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN13UnionWithDtorD1Ev"]
+    pub fn UnionWithDtor_UnionWithDtor_destructor(this: *mut UnionWithDtor);
+}
+impl UnionWithDtor {
+    #[inline]
+    pub unsafe fn destruct(&mut self) {
+        UnionWithDtor_UnionWithDtor_destructor(self)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_fields.rs b/bindgen-tests/tests/expectations/tests/union_fields.rs
new file mode 100644
index 00000000..9135ca3c
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_fields.rs
@@ -0,0 +1,71 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union nsStyleUnion {
+    pub mInt: ::std::os::raw::c_int,
+    pub mFloat: f32,
+    pub mPointer: *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout_nsStyleUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<nsStyleUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsStyleUnion>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsStyleUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsStyleUnion>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsStyleUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mInt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mInt)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFloat) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mFloat)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mPointer) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mPointer)
+        )
+    );
+}
+impl Default for nsStyleUnion {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_fields_1_0.rs b/bindgen-tests/tests/expectations/tests/union_fields_1_0.rs
new file mode 100644
index 00000000..b5f94bcd
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_fields_1_0.rs
@@ -0,0 +1,111 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq)]
+pub struct nsStyleUnion {
+    pub mInt: __BindgenUnionField<::std::os::raw::c_int>,
+    pub mFloat: __BindgenUnionField<f32>,
+    pub mPointer: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    pub bindgen_union_field: u64,
+}
+#[test]
+fn bindgen_test_layout_nsStyleUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<nsStyleUnion> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<nsStyleUnion>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsStyleUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsStyleUnion>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsStyleUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mInt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mInt)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mFloat) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mFloat)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mPointer) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(nsStyleUnion),
+            "::",
+            stringify!(mPointer)
+        )
+    );
+}
+impl Clone for nsStyleUnion {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_template.rs b/bindgen-tests/tests/expectations/tests/union_template.rs
new file mode 100644
index 00000000..9c3d7a07
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_template.rs
@@ -0,0 +1,64 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct NastyStruct {
+    pub mIsSome: bool,
+    pub mStorage: NastyStruct__bindgen_ty_1,
+    pub __bindgen_anon_1: NastyStruct__bindgen_ty_2,
+}
+#[repr(C)]
+pub union NastyStruct__bindgen_ty_1 {
+    pub mFoo: *mut ::std::os::raw::c_void,
+    pub mDummy: ::std::os::raw::c_ulong,
+}
+impl Default for NastyStruct__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub union NastyStruct__bindgen_ty_2 {
+    pub wat: ::std::os::raw::c_short,
+    pub wut: *mut ::std::os::raw::c_int,
+}
+impl Default for NastyStruct__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Default for NastyStruct {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub union Whatever {
+    pub mTPtr: *mut ::std::os::raw::c_void,
+    pub mInt: ::std::os::raw::c_int,
+}
+impl Default for Whatever {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_template_1_0.rs b/bindgen-tests/tests/expectations/tests/union_template_1_0.rs
new file mode 100644
index 00000000..487579f7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_template_1_0.rs
@@ -0,0 +1,78 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NastyStruct {
+    pub mIsSome: bool,
+    pub mStorage: NastyStruct__bindgen_ty_1,
+    pub __bindgen_anon_1: NastyStruct__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NastyStruct__bindgen_ty_1 {
+    pub mFoo: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    pub mDummy: __BindgenUnionField<::std::os::raw::c_ulong>,
+    pub bindgen_union_field: u64,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct NastyStruct__bindgen_ty_2 {
+    pub wat: __BindgenUnionField<::std::os::raw::c_short>,
+    pub wut: __BindgenUnionField<*mut ::std::os::raw::c_int>,
+    pub bindgen_union_field: u64,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Whatever {
+    pub mTPtr: __BindgenUnionField<*mut ::std::os::raw::c_void>,
+    pub mInt: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u64,
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs
new file mode 100644
index 00000000..35b5829b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct.rs
@@ -0,0 +1,84 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_1_0.rs
new file mode 100644
index 00000000..8b11e757
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_1_0.rs
@@ -0,0 +1,129 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: __BindgenUnionField<foo__bindgen_ty_1>,
+    pub bindgen_union_field: [u32; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs
new file mode 100644
index 00000000..e81b3bef
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs
@@ -0,0 +1,194 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo {
+    pub a: ::std::os::raw::c_int,
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+}
+impl foo__bindgen_ty_1 {
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn c(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 25u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        b: ::std::os::raw::c_int,
+        c: ::std::os::raw::c_int,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 7u8, {
+            let b: u32 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 25u8, {
+            let c: u32 = unsafe { ::std::mem::transmute(c) };
+            c as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
new file mode 100644
index 00000000..6ce6ed22
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
@@ -0,0 +1,239 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: __BindgenUnionField<::std::os::raw::c_int>,
+    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub _bitfield_align_1: [u32; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+    pub __bindgen_align: [u32; 0usize],
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl foo__bindgen_ty_1 {
+    #[inline]
+    pub fn b(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 7u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn c(&self) -> ::std::os::raw::c_int {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 25u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        b: ::std::os::raw::c_int,
+        c: ::std::os::raw::c_int,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 7u8, {
+            let b: u32 = unsafe { ::std::mem::transmute(b) };
+            b as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 25u8, {
+            let c: u32 = unsafe { ::std::mem::transmute(c) };
+            c as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs
new file mode 100644
index 00000000..487650bf
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_union.rs
@@ -0,0 +1,93 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo {
+    pub bar: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub a: ::std::os::raw::c_uint,
+    pub b: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_union_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_union_1_0.rs
new file mode 100644
index 00000000..f3e4b840
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_union_1_0.rs
@@ -0,0 +1,130 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub bar: __BindgenUnionField<foo__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs
new file mode 100644
index 00000000..cff5df04
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct.rs
@@ -0,0 +1,112 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union pixel {
+    pub rgba: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: pixel__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct pixel__bindgen_ty_1 {
+    pub r: ::std::os::raw::c_uchar,
+    pub g: ::std::os::raw::c_uchar,
+    pub b: ::std::os::raw::c_uchar,
+    pub a: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_pixel__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<pixel__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<pixel__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(pixel__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<pixel__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(pixel__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(r)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(g)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+#[test]
+fn bindgen_test_layout_pixel() {
+    const UNINIT: ::std::mem::MaybeUninit<pixel> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<pixel>(),
+        4usize,
+        concat!("Size of: ", stringify!(pixel))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<pixel>(),
+        4usize,
+        concat!("Alignment of ", stringify!(pixel))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rgba) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel),
+            "::",
+            stringify!(rgba)
+        )
+    );
+}
+impl Default for pixel {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
new file mode 100644
index 00000000..1562a8c9
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
@@ -0,0 +1,157 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct pixel {
+    pub rgba: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub __bindgen_anon_1: __BindgenUnionField<pixel__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct pixel__bindgen_ty_1 {
+    pub r: ::std::os::raw::c_uchar,
+    pub g: ::std::os::raw::c_uchar,
+    pub b: ::std::os::raw::c_uchar,
+    pub a: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_pixel__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<pixel__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<pixel__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(pixel__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<pixel__bindgen_ty_1>(),
+        1usize,
+        concat!("Alignment of ", stringify!(pixel__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(r)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(g)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel__bindgen_ty_1),
+            "::",
+            stringify!(a)
+        )
+    );
+}
+impl Clone for pixel__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_pixel() {
+    const UNINIT: ::std::mem::MaybeUninit<pixel> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<pixel>(),
+        4usize,
+        concat!("Size of: ", stringify!(pixel))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<pixel>(),
+        4usize,
+        concat!("Alignment of ", stringify!(pixel))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).rgba) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(pixel),
+            "::",
+            stringify!(rgba)
+        )
+    );
+}
+impl Clone for pixel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs
new file mode 100644
index 00000000..f1abfc5a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union.rs
@@ -0,0 +1,94 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo {
+    pub a: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1 {
+    pub b: ::std::os::raw::c_ushort,
+    pub c: ::std::os::raw::c_uchar,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(c)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
new file mode 100644
index 00000000..197a6bbf
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
@@ -0,0 +1,131 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub c: __BindgenUnionField<::std::os::raw::c_uchar>,
+    pub bindgen_union_field: u16,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(b)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1),
+            "::",
+            stringify!(c)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_big_member.rs b/bindgen-tests/tests/expectations/tests/union_with_big_member.rs
new file mode 100644
index 00000000..7110257b
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_big_member.rs
@@ -0,0 +1,160 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union WithBigArray {
+    pub a: ::std::os::raw::c_int,
+    pub b: [::std::os::raw::c_int; 33usize],
+}
+#[test]
+fn bindgen_test_layout_WithBigArray() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigArray>(),
+        132usize,
+        concat!("Size of: ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for WithBigArray {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union WithBigArray2 {
+    pub a: ::std::os::raw::c_int,
+    pub b: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_WithBigArray2() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigArray2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigArray2>(),
+        36usize,
+        concat!("Size of: ", stringify!(WithBigArray2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigArray2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigArray2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray2),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for WithBigArray2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union WithBigMember {
+    pub a: ::std::os::raw::c_int,
+    pub b: WithBigArray,
+}
+#[test]
+fn bindgen_test_layout_WithBigMember() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigMember> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigMember>(),
+        132usize,
+        concat!("Size of: ", stringify!(WithBigMember))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigMember>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigMember))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigMember),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigMember),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Default for WithBigMember {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_big_member_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_big_member_1_0.rs
new file mode 100644
index 00000000..63b43baa
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_big_member_1_0.rs
@@ -0,0 +1,212 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Copy)]
+pub struct WithBigArray {
+    pub a: __BindgenUnionField<::std::os::raw::c_int>,
+    pub b: __BindgenUnionField<[::std::os::raw::c_int; 33usize]>,
+    pub bindgen_union_field: [u32; 33usize],
+}
+#[test]
+fn bindgen_test_layout_WithBigArray() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigArray>(),
+        132usize,
+        concat!("Size of: ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigArray>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for WithBigArray {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for WithBigArray {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct WithBigArray2 {
+    pub a: __BindgenUnionField<::std::os::raw::c_int>,
+    pub b: __BindgenUnionField<[::std::os::raw::c_char; 33usize]>,
+    pub bindgen_union_field: [u32; 9usize],
+}
+#[test]
+fn bindgen_test_layout_WithBigArray2() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigArray2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigArray2>(),
+        36usize,
+        concat!("Size of: ", stringify!(WithBigArray2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigArray2>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigArray2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray2),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigArray2),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for WithBigArray2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Copy)]
+pub struct WithBigMember {
+    pub a: __BindgenUnionField<::std::os::raw::c_int>,
+    pub b: __BindgenUnionField<WithBigArray>,
+    pub bindgen_union_field: [u32; 33usize],
+}
+#[test]
+fn bindgen_test_layout_WithBigMember() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBigMember> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBigMember>(),
+        132usize,
+        concat!("Size of: ", stringify!(WithBigMember))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBigMember>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBigMember))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigMember),
+            "::",
+            stringify!(a)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBigMember),
+            "::",
+            stringify!(b)
+        )
+    );
+}
+impl Clone for WithBigMember {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for WithBigMember {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::std::mem::uninitialized();
+            ::std::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_nesting.rs b/bindgen-tests/tests/expectations/tests/union_with_nesting.rs
new file mode 100644
index 00000000..ec9c1480
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_nesting.rs
@@ -0,0 +1,173 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo {
+    pub a: ::std::os::raw::c_uint,
+    pub __bindgen_anon_1: foo__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct foo__bindgen_ty_1 {
+    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
+    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1__bindgen_ty_1 {
+    pub b1: ::std::os::raw::c_ushort,
+    pub b2: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b2)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union foo__bindgen_ty_1__bindgen_ty_2 {
+    pub c1: ::std::os::raw::c_ushort,
+    pub c2: ::std::os::raw::c_ushort,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(c1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(c2)
+        )
+    );
+}
+impl Default for foo__bindgen_ty_1__bindgen_ty_2 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+}
+impl Default for foo__bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_nesting_1_0.rs b/bindgen-tests/tests/expectations/tests/union_with_nesting_1_0.rs
new file mode 100644
index 00000000..a1e452fe
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_nesting_1_0.rs
@@ -0,0 +1,203 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
+    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
+    pub bindgen_union_field: u32,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1 {
+    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
+    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_1 {
+    pub b1: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub b2: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub bindgen_union_field: u16,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
+            "::",
+            stringify!(b2)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct foo__bindgen_ty_1__bindgen_ty_2 {
+    pub c1: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub c2: __BindgenUnionField<::std::os::raw::c_ushort>,
+    pub bindgen_union_field: u16,
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        2usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(c1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(c2)
+        )
+    );
+}
+impl Clone for foo__bindgen_ty_1__bindgen_ty_2 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<foo__bindgen_ty_1>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo__bindgen_ty_1>(),
+        2usize,
+        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
+    );
+}
+impl Clone for foo__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        4usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs b/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs
new file mode 100644
index 00000000..3c500b21
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/union_with_non_copy_member.rs
@@ -0,0 +1,239 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __BindgenUnionField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::std::mem::transmute(self)
+    }
+}
+impl<T> ::std::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct NonCopyType {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_NonCopyType() {
+    const UNINIT: ::std::mem::MaybeUninit<NonCopyType> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<NonCopyType>(),
+        4usize,
+        concat!("Size of: ", stringify!(NonCopyType))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<NonCopyType>(),
+        4usize,
+        concat!("Alignment of ", stringify!(NonCopyType))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(NonCopyType),
+            "::",
+            stringify!(foo)
+        )
+    );
+}
+#[repr(C)]
+pub struct WithBindgenGeneratedWrapper {
+    pub non_copy_type: __BindgenUnionField<NonCopyType>,
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_WithBindgenGeneratedWrapper() {
+    const UNINIT: ::std::mem::MaybeUninit<WithBindgenGeneratedWrapper> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithBindgenGeneratedWrapper>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithBindgenGeneratedWrapper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithBindgenGeneratedWrapper>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithBindgenGeneratedWrapper))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBindgenGeneratedWrapper),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithBindgenGeneratedWrapper),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithBindgenGeneratedWrapper {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub union WithManuallyDrop {
+    pub non_copy_type: ::std::mem::ManuallyDrop<NonCopyType>,
+    pub bar: ::std::mem::ManuallyDrop<::std::os::raw::c_int>,
+}
+#[test]
+fn bindgen_test_layout_WithManuallyDrop() {
+    const UNINIT: ::std::mem::MaybeUninit<WithManuallyDrop> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithManuallyDrop>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithManuallyDrop))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithManuallyDrop>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithManuallyDrop))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithManuallyDrop),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithManuallyDrop),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithManuallyDrop {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct WithDefaultWrapper {
+    pub non_copy_type: __BindgenUnionField<NonCopyType>,
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub bindgen_union_field: u32,
+}
+#[test]
+fn bindgen_test_layout_WithDefaultWrapper() {
+    const UNINIT: ::std::mem::MaybeUninit<WithDefaultWrapper> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<WithDefaultWrapper>(),
+        4usize,
+        concat!("Size of: ", stringify!(WithDefaultWrapper))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<WithDefaultWrapper>(),
+        4usize,
+        concat!("Alignment of ", stringify!(WithDefaultWrapper))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDefaultWrapper),
+            "::",
+            stringify!(non_copy_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(WithDefaultWrapper),
+            "::",
+            stringify!(bar)
+        )
+    );
+}
+impl Default for WithDefaultWrapper {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/unknown_attr.rs b/bindgen-tests/tests/expectations/tests/unknown_attr.rs
new file mode 100644
index 00000000..c790f009
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/unknown_attr.rs
@@ -0,0 +1,57 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct max_align_t {
+    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
+    pub __bindgen_padding_0: u64,
+    pub __clang_max_align_nonce2: ::std::os::raw::c_longlong,
+}
+#[test]
+fn bindgen_test_layout_max_align_t() {
+    const UNINIT: ::std::mem::MaybeUninit<max_align_t> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<max_align_t>(),
+        32usize,
+        concat!("Size of: ", stringify!(max_align_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<max_align_t>(),
+        16usize,
+        concat!("Alignment of ", stringify!(max_align_t))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(max_align_t),
+            "::",
+            stringify!(__clang_max_align_nonce1)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize -
+                ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(max_align_t),
+            "::",
+            stringify!(__clang_max_align_nonce2)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/unsorted-items.rs b/bindgen-tests/tests/expectations/tests/unsorted-items.rs
new file mode 100644
index 00000000..ce0c5f3f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/unsorted-items.rs
@@ -0,0 +1,82 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn foo() -> ::std::os::raw::c_int;
+}
+pub type number = ::std::os::raw::c_int;
+extern "C" {
+    pub fn bar(x: number) -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Point {
+    pub x: number,
+    pub y: number,
+}
+#[test]
+fn bindgen_test_layout_Point() {
+    const UNINIT: ::std::mem::MaybeUninit<Point> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Point>(),
+        8usize,
+        concat!("Size of: ", stringify!(Point))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Point>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Point))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Point), "::", stringify!(y))
+    );
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Angle {
+    pub a: number,
+    pub b: number,
+}
+#[test]
+fn bindgen_test_layout_Angle() {
+    const UNINIT: ::std::mem::MaybeUninit<Angle> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Angle>(),
+        8usize,
+        concat!("Size of: ", stringify!(Angle))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Angle>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Angle))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(b))
+    );
+}
+extern "C" {
+    pub fn baz(point: Point) -> ::std::os::raw::c_int;
+}
+pub const NUMBER: number = 42;
diff --git a/bindgen-tests/tests/expectations/tests/use-core.rs b/bindgen-tests/tests/expectations/tests/use-core.rs
new file mode 100644
index 00000000..569e8d24
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/use-core.rs
@@ -0,0 +1,112 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(not(target_os = "windows"))]
+extern crate core;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: ::core::ffi::c_int,
+    pub b: ::core::ffi::c_int,
+    pub bar: *mut ::core::ffi::c_void,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::core::mem::MaybeUninit<foo> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Default for foo {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union _bindgen_ty_1 {
+    pub bar: ::core::ffi::c_int,
+    pub baz: ::core::ffi::c_long,
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(bar)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(baz)
+        )
+    );
+}
+impl Default for _bindgen_ty_1 {
+    fn default() -> Self {
+        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    pub static mut bazz: _bindgen_ty_1;
+}
+pub type fooFunction =
+    ::core::option::Option<unsafe extern "C" fn(bar: ::core::ffi::c_int)>;
diff --git a/bindgen-tests/tests/expectations/tests/use-core_1_0.rs b/bindgen-tests/tests/expectations/tests/use-core_1_0.rs
new file mode 100644
index 00000000..8c6d0fd2
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/use-core_1_0.rs
@@ -0,0 +1,157 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern crate core;
+
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
+impl<T> __BindgenUnionField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __BindgenUnionField(::core::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ref(&self) -> &T {
+        ::core::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_mut(&mut self) -> &mut T {
+        ::core::mem::transmute(self)
+    }
+}
+impl<T> ::core::default::Default for __BindgenUnionField<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<T> ::core::clone::Clone for __BindgenUnionField<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+impl<T> ::core::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::core::fmt::Debug for __BindgenUnionField<T> {
+    fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+        fmt.write_str("__BindgenUnionField")
+    }
+}
+impl<T> ::core::hash::Hash for __BindgenUnionField<T> {
+    fn hash<H: ::core::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::core::cmp::PartialEq for __BindgenUnionField<T> {
+    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+        true
+    }
+}
+impl<T> ::core::cmp::Eq for __BindgenUnionField<T> {}
+#[repr(C)]
+#[derive(Debug, Copy, Hash, PartialEq, Eq)]
+pub struct foo {
+    pub a: ::std::os::raw::c_int,
+    pub b: ::std::os::raw::c_int,
+    pub bar: *mut ::std::os::raw::c_void,
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::core::mem::MaybeUninit<foo> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<foo>(),
+        16usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
+        4usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
+    );
+}
+impl Clone for foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Default for foo {
+    fn default() -> Self {
+        unsafe {
+            let mut s: Self = ::core::mem::uninitialized();
+            ::core::ptr::write_bytes(&mut s, 0, 1);
+            s
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
+pub struct _bindgen_ty_1 {
+    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
+    pub baz: __BindgenUnionField<::std::os::raw::c_long>,
+    pub bindgen_union_field: u64,
+}
+#[test]
+fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<_bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(_bindgen_ty_1))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(bar)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(_bindgen_ty_1),
+            "::",
+            stringify!(baz)
+        )
+    );
+}
+impl Clone for _bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+extern "C" {
+    pub static mut bazz: _bindgen_ty_1;
+}
+pub type fooFunction =
+    ::core::option::Option<unsafe extern "C" fn(bar: ::std::os::raw::c_int)>;
diff --git a/bindgen-tests/tests/expectations/tests/using.rs b/bindgen-tests/tests/expectations/tests/using.rs
new file mode 100644
index 00000000..4749ed55
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/using.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Point<T> {
+    pub x: T,
+    pub y: T,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for Point<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type IntPoint2D = Point<::std::os::raw::c_int>;
+pub type IntVec2D = Point<::std::os::raw::c_int>;
diff --git a/bindgen-tests/tests/expectations/tests/var-tracing.rs b/bindgen-tests/tests/expectations/tests/var-tracing.rs
new file mode 100644
index 00000000..4280802e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/var-tracing.rs
@@ -0,0 +1,72 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub m_baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    const UNINIT: ::std::mem::MaybeUninit<Bar> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        4usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).m_baz) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Bar),
+            "::",
+            stringify!(m_baz)
+        )
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3BarC1Ei"]
+    pub fn Bar_Bar(this: *mut Bar, baz: ::std::os::raw::c_int);
+}
+impl Bar {
+    #[inline]
+    pub unsafe fn new(baz: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        Bar_Bar(__bindgen_tmp.as_mut_ptr(), baz);
+        __bindgen_tmp.assume_init()
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Baz {
+    pub _address: u8,
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Baz3FOOE"]
+    pub static mut Baz_FOO: [Bar; 0usize];
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        1usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/variadic-method.rs b/bindgen-tests/tests/expectations/tests/variadic-method.rs
new file mode 100644
index 00000000..be93dda7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/variadic-method.rs
@@ -0,0 +1,33 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    #[link_name = "\u{1}_Z3fooPKcz"]
+    pub fn foo(fmt: *const ::std::os::raw::c_char, ...);
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        1usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3Bar3fooEPKcz"]
+    pub fn Bar_foo(this: *mut Bar, fmt: *const ::std::os::raw::c_char, ...);
+}
diff --git a/bindgen-tests/tests/expectations/tests/variadic_template_function.rs b/bindgen-tests/tests/expectations/tests/variadic_template_function.rs
new file mode 100644
index 00000000..8f67136a
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/variadic_template_function.rs
@@ -0,0 +1,12 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct VariadicFunctionObject {
+    pub _address: u8,
+}
diff --git a/bindgen-tests/tests/expectations/tests/vector.rs b/bindgen-tests/tests/expectations/tests/vector.rs
new file mode 100644
index 00000000..12d2e1b1
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/vector.rs
@@ -0,0 +1,45 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct foo {
+    pub mMember: [::std::os::raw::c_longlong; 1usize],
+}
+#[test]
+fn bindgen_test_layout_foo() {
+    const UNINIT: ::std::mem::MaybeUninit<foo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<foo>(),
+        8usize,
+        concat!("Size of: ", stringify!(foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<foo>(),
+        8usize,
+        concat!("Alignment of ", stringify!(foo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(foo),
+            "::",
+            stringify!(mMember)
+        )
+    );
+}
+pub type __m128 = [f32; 4usize];
+pub type __m128d = [f64; 2usize];
+pub type __m128i = [::std::os::raw::c_longlong; 2usize];
+extern "C" {
+    #[link_name = "\u{1}_Z3fooDv2_xDv2_d"]
+    pub fn foo(arg1: __m128i, arg2: __m128d) -> __m128;
+}
diff --git a/bindgen-tests/tests/expectations/tests/virtual_dtor.rs b/bindgen-tests/tests/expectations/tests/virtual_dtor.rs
new file mode 100644
index 00000000..c3c66e91
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/virtual_dtor.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct nsSlots__bindgen_vtable(::std::os::raw::c_void);
+#[repr(C)]
+#[derive(Debug)]
+pub struct nsSlots {
+    pub vtable_: *const nsSlots__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_nsSlots() {
+    assert_eq!(
+        ::std::mem::size_of::<nsSlots>(),
+        8usize,
+        concat!("Size of: ", stringify!(nsSlots))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<nsSlots>(),
+        8usize,
+        concat!("Alignment of ", stringify!(nsSlots))
+    );
+}
+impl Default for nsSlots {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN7nsSlotsD1Ev"]
+    pub fn nsSlots_nsSlots_destructor(this: *mut nsSlots);
+}
diff --git a/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs b/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs
new file mode 100644
index 00000000..2c15b428
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/virtual_inheritance.rs
@@ -0,0 +1,138 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct A {
+    pub foo: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A() {
+    const UNINIT: ::std::mem::MaybeUninit<A> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<A>(),
+        4usize,
+        concat!("Size of: ", stringify!(A))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<A>(),
+        4usize,
+        concat!("Alignment of ", stringify!(A))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(A), "::", stringify!(foo))
+    );
+}
+#[repr(C)]
+pub struct B__bindgen_vtable(::std::os::raw::c_void);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct B {
+    pub vtable_: *const B__bindgen_vtable,
+    pub bar: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_B() {
+    const UNINIT: ::std::mem::MaybeUninit<B> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<B>(),
+        16usize,
+        concat!("Size of: ", stringify!(B))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<B>(),
+        8usize,
+        concat!("Alignment of ", stringify!(B))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(B), "::", stringify!(bar))
+    );
+}
+impl Default for B {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct C__bindgen_vtable(::std::os::raw::c_void);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct C {
+    pub vtable_: *const C__bindgen_vtable,
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    const UNINIT: ::std::mem::MaybeUninit<C> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        16usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        8usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(C), "::", stringify!(baz))
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct D {
+    pub _base: C,
+    pub _base_1: B,
+    pub bazz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_D() {
+    assert_eq!(
+        ::std::mem::size_of::<D>(),
+        40usize,
+        concat!("Size of: ", stringify!(D))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<D>(),
+        8usize,
+        concat!("Alignment of ", stringify!(D))
+    );
+}
+impl Default for D {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/virtual_interface.rs b/bindgen-tests/tests/expectations/tests/virtual_interface.rs
new file mode 100644
index 00000000..be94f232
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/virtual_interface.rs
@@ -0,0 +1,128 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct PureVirtualIFace__bindgen_vtable {
+    pub PureVirtualIFace_Foo: unsafe extern "C" fn(this: *mut PureVirtualIFace),
+    pub PureVirtualIFace_Bar: unsafe extern "C" fn(
+        this: *mut PureVirtualIFace,
+        arg1: ::std::os::raw::c_uint,
+    ),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct PureVirtualIFace {
+    pub vtable_: *const PureVirtualIFace__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_PureVirtualIFace() {
+    assert_eq!(
+        ::std::mem::size_of::<PureVirtualIFace>(),
+        8usize,
+        concat!("Size of: ", stringify!(PureVirtualIFace))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<PureVirtualIFace>(),
+        8usize,
+        concat!("Alignment of ", stringify!(PureVirtualIFace))
+    );
+}
+impl Default for PureVirtualIFace {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+pub struct AnotherInterface__bindgen_vtable {
+    pub AnotherInterface_Baz: unsafe extern "C" fn(this: *mut AnotherInterface),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct AnotherInterface {
+    pub vtable_: *const AnotherInterface__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_AnotherInterface() {
+    assert_eq!(
+        ::std::mem::size_of::<AnotherInterface>(),
+        8usize,
+        concat!("Size of: ", stringify!(AnotherInterface))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<AnotherInterface>(),
+        8usize,
+        concat!("Alignment of ", stringify!(AnotherInterface))
+    );
+}
+impl Default for AnotherInterface {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Implementation {
+    pub _base: PureVirtualIFace,
+}
+#[test]
+fn bindgen_test_layout_Implementation() {
+    assert_eq!(
+        ::std::mem::size_of::<Implementation>(),
+        8usize,
+        concat!("Size of: ", stringify!(Implementation))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Implementation>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Implementation))
+    );
+}
+impl Default for Implementation {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct DoubleImpl {
+    pub _base: PureVirtualIFace,
+    pub _base_1: AnotherInterface,
+}
+#[test]
+fn bindgen_test_layout_DoubleImpl() {
+    assert_eq!(
+        ::std::mem::size_of::<DoubleImpl>(),
+        16usize,
+        concat!("Size of: ", stringify!(DoubleImpl))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DoubleImpl>(),
+        8usize,
+        concat!("Alignment of ", stringify!(DoubleImpl))
+    );
+}
+impl Default for DoubleImpl {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs b/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs
new file mode 100644
index 00000000..c117d9ef
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/virtual_overloaded.rs
@@ -0,0 +1,55 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct C__bindgen_vtable {
+    pub C_do_thing:
+        unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_char),
+    pub C_do_thing1:
+        unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_int),
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct C {
+    pub vtable_: *const C__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(
+        ::std::mem::size_of::<C>(),
+        8usize,
+        concat!("Size of: ", stringify!(C))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<C>(),
+        8usize,
+        concat!("Alignment of ", stringify!(C))
+    );
+}
+impl Default for C {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C8do_thingEc"]
+    pub fn C_do_thing(
+        this: *mut ::std::os::raw::c_void,
+        arg1: ::std::os::raw::c_char,
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN1C8do_thingEi"]
+    pub fn C_do_thing1(
+        this: *mut ::std::os::raw::c_void,
+        arg1: ::std::os::raw::c_int,
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs b/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs
new file mode 100644
index 00000000..74e1dc79
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/vtable_recursive_sig.rs
@@ -0,0 +1,69 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+pub struct Base__bindgen_vtable {
+    pub Base_AsDerived: unsafe extern "C" fn(this: *mut Base) -> *mut Derived,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Base {
+    pub vtable_: *const Base__bindgen_vtable,
+}
+#[test]
+fn bindgen_test_layout_Base() {
+    assert_eq!(
+        ::std::mem::size_of::<Base>(),
+        8usize,
+        concat!("Size of: ", stringify!(Base))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Base>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Base))
+    );
+}
+impl Default for Base {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN4Base9AsDerivedEv"]
+    pub fn Base_AsDerived(this: *mut ::std::os::raw::c_void) -> *mut Derived;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Derived {
+    pub _base: Base,
+}
+#[test]
+fn bindgen_test_layout_Derived() {
+    assert_eq!(
+        ::std::mem::size_of::<Derived>(),
+        8usize,
+        concat!("Size of: ", stringify!(Derived))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Derived>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Derived))
+    );
+}
+impl Default for Derived {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs b/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs
new file mode 100644
index 00000000..6d15c51f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/wasm-constructor-returns.rs
@@ -0,0 +1,40 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "C" {
+    #[link_name = "\u{1}_ZN3FooC1Ei"]
+    pub fn Foo_Foo(
+        this: *mut Foo,
+        var: ::std::os::raw::c_int,
+    ) -> *mut ::std::os::raw::c_void;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn new(var: ::std::os::raw::c_int) -> Self {
+        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
+        Foo_Foo(__bindgen_tmp.as_mut_ptr(), var);
+        __bindgen_tmp.assume_init()
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/wasm-import-module.rs b/bindgen-tests/tests/expectations/tests/wasm-import-module.rs
new file mode 100644
index 00000000..e334a7b7
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/wasm-import-module.rs
@@ -0,0 +1,11 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[link(wasm_import_module = "test-module")]
+extern "C" {
+    pub fn test_function();
+}
diff --git a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs
new file mode 100644
index 00000000..9383bada
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs
@@ -0,0 +1,440 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum nsStyleSVGOpacitySource {
+    eStyleSVGOpacitySource_Normal = 0,
+    eStyleSVGOpacitySource_ContextFillOpacity = 1,
+    eStyleSVGOpacitySource_ContextStrokeOpacity = 2,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Weird {
+    pub mStrokeDasharrayLength: ::std::os::raw::c_uint,
+    pub _bitfield_align_1: [u16; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
+    pub mClipRule: ::std::os::raw::c_uchar,
+    pub mColorInterpolation: ::std::os::raw::c_uchar,
+    pub mColorInterpolationFilters: ::std::os::raw::c_uchar,
+    pub mFillRule: ::std::os::raw::c_uchar,
+    pub mImageRendering: ::std::os::raw::c_uchar,
+    pub mPaintOrder: ::std::os::raw::c_uchar,
+    pub mShapeRendering: ::std::os::raw::c_uchar,
+    pub mStrokeLinecap: ::std::os::raw::c_uchar,
+    pub mStrokeLinejoin: ::std::os::raw::c_uchar,
+    pub mTextAnchor: ::std::os::raw::c_uchar,
+    pub mTextRendering: ::std::os::raw::c_uchar,
+    pub _bitfield_align_2: [u8; 0],
+    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_Weird() {
+    const UNINIT: ::std::mem::MaybeUninit<Weird> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<Weird>(),
+        24usize,
+        concat!("Size of: ", stringify!(Weird))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Weird>(),
+        4usize,
+        concat!("Alignment of ", stringify!(Weird))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mStrokeDasharrayLength) as usize -
+                ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mStrokeDasharrayLength)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mClipRule) as usize - ptr as usize
+        },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mClipRule)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mColorInterpolation) as usize -
+                ptr as usize
+        },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mColorInterpolation)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mColorInterpolationFilters) as usize -
+                ptr as usize
+        },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mColorInterpolationFilters)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mFillRule) as usize - ptr as usize
+        },
+        11usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mFillRule)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mImageRendering) as usize - ptr as usize
+        },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mImageRendering)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mPaintOrder) as usize - ptr as usize
+        },
+        13usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mPaintOrder)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mShapeRendering) as usize - ptr as usize
+        },
+        14usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mShapeRendering)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mStrokeLinecap) as usize - ptr as usize
+        },
+        15usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mStrokeLinecap)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mStrokeLinejoin) as usize - ptr as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mStrokeLinejoin)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mTextAnchor) as usize - ptr as usize
+        },
+        17usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mTextAnchor)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).mTextRendering) as usize - ptr as usize
+        },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(Weird),
+            "::",
+            stringify!(mTextRendering)
+        )
+    );
+}
+impl Default for Weird {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+impl Weird {
+    #[inline]
+    pub fn bitTest(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 16u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn bitTest2(&self) -> ::std::os::raw::c_uint {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_1.get(16usize, 15u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 15u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        bitTest: ::std::os::raw::c_uint,
+        bitTest2: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 16u8, {
+            let bitTest: u32 = unsafe { ::std::mem::transmute(bitTest) };
+            bitTest as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 15u8, {
+            let bitTest2: u32 = unsafe { ::std::mem::transmute(bitTest2) };
+            bitTest2 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+    #[inline]
+    pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(0usize, 3u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_2.set(0usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(3usize, 3u8) as u32)
+        }
+    }
+    #[inline]
+    pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_2.set(3usize, 3u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn mStrokeDasharrayFromObject(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn mStrokeDashoffsetFromObject(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn mStrokeWidthFromObject(&self) -> bool {
+        unsafe {
+            ::std::mem::transmute(self._bitfield_2.get(8usize, 1u8) as u8)
+        }
+    }
+    #[inline]
+    pub fn set_mStrokeWidthFromObject(&mut self, val: bool) {
+        unsafe {
+            let val: u8 = ::std::mem::transmute(val);
+            self._bitfield_2.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_2(
+        mFillOpacitySource: nsStyleSVGOpacitySource,
+        mStrokeOpacitySource: nsStyleSVGOpacitySource,
+        mStrokeDasharrayFromObject: bool,
+        mStrokeDashoffsetFromObject: bool,
+        mStrokeWidthFromObject: bool,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 3u8, {
+            let mFillOpacitySource: u32 =
+                unsafe { ::std::mem::transmute(mFillOpacitySource) };
+            mFillOpacitySource as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 3u8, {
+            let mStrokeOpacitySource: u32 =
+                unsafe { ::std::mem::transmute(mStrokeOpacitySource) };
+            mStrokeOpacitySource as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let mStrokeDasharrayFromObject: u8 =
+                unsafe { ::std::mem::transmute(mStrokeDasharrayFromObject) };
+            mStrokeDasharrayFromObject as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let mStrokeDashoffsetFromObject: u8 =
+                unsafe { ::std::mem::transmute(mStrokeDashoffsetFromObject) };
+            mStrokeDashoffsetFromObject as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let mStrokeWidthFromObject: u8 =
+                unsafe { ::std::mem::transmute(mStrokeWidthFromObject) };
+            mStrokeWidthFromObject as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/what_is_going_on.rs b/bindgen-tests/tests/expectations/tests/what_is_going_on.rs
new file mode 100644
index 00000000..b4f42791
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/what_is_going_on.rs
@@ -0,0 +1,43 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct UnknownUnits {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_UnknownUnits() {
+    assert_eq!(
+        ::std::mem::size_of::<UnknownUnits>(),
+        1usize,
+        concat!("Size of: ", stringify!(UnknownUnits))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<UnknownUnits>(),
+        1usize,
+        concat!("Alignment of ", stringify!(UnknownUnits))
+    );
+}
+pub type Float = f32;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct PointTyped<F> {
+    pub x: F,
+    pub y: F,
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<F>>,
+}
+impl<F> Default for PointTyped<F> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+pub type IntPoint = PointTyped<f32>;
diff --git a/bindgen-tests/tests/expectations/tests/win32-thiscall_1_0.rs b/bindgen-tests/tests/expectations/tests/win32-thiscall_1_0.rs
new file mode 100644
index 00000000..502e12fe
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/win32-thiscall_1_0.rs
@@ -0,0 +1,30 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+impl Clone for Foo {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs b/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs
new file mode 100644
index 00000000..92bb13cc
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/win32-thiscall_nightly.rs
@@ -0,0 +1,51 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+#![feature(abi_thiscall)]
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
+}
+extern "thiscall" {
+    #[link_name = "\u{1}?test@Foo@@QAEXXZ"]
+    pub fn Foo_test(this: *mut Foo);
+}
+extern "thiscall" {
+    #[link_name = "\u{1}?test2@Foo@@QAEHH@Z"]
+    pub fn Foo_test2(
+        this: *mut Foo,
+        var: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+impl Foo {
+    #[inline]
+    pub unsafe fn test(&mut self) {
+        Foo_test(self)
+    }
+    #[inline]
+    pub unsafe fn test2(
+        &mut self,
+        var: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int {
+        Foo_test2(self, var)
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/win32-vectorcall-1_0.rs b/bindgen-tests/tests/expectations/tests/win32-vectorcall-1_0.rs
new file mode 100644
index 00000000..131dbdf3
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/win32-vectorcall-1_0.rs
@@ -0,0 +1,6 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
diff --git a/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs b/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs
new file mode 100644
index 00000000..163741df
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/win32-vectorcall-nightly.rs
@@ -0,0 +1,16 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+#![cfg(feature = "nightly")]
+#![feature(abi_vectorcall)]
+
+extern "vectorcall" {
+    #[link_name = "\u{1}test_vectorcall@@16"]
+    pub fn test_vectorcall(
+        a: ::std::os::raw::c_int,
+        b: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
diff --git a/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs b/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs
new file mode 100644
index 00000000..2a7d1802
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/with_array_pointers_arguments.rs
@@ -0,0 +1,24 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn test_fn(
+        a: f32,
+        arr: *mut [::std::os::raw::c_int; 20usize],
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn test_fn2(
+        arr: *const [f32; 20usize],
+        b: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+pub type defArr = [::std::os::raw::c_char; 20usize];
+pub type foo = ::std::option::Option<unsafe extern "C" fn(a: *mut defArr)>;
+extern "C" {
+    pub fn bar(a: *mut defArr);
+}
diff --git a/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs b/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs
new file mode 100644
index 00000000..c4acdb3e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/without_array_pointers_arguments.rs
@@ -0,0 +1,25 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+extern "C" {
+    pub fn test_fn(
+        a: f32,
+        arr: *mut ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+    pub fn test_fn2(
+        arr: *const f32,
+        b: ::std::os::raw::c_int,
+    ) -> ::std::os::raw::c_int;
+}
+pub type defArr = [::std::os::raw::c_char; 20usize];
+pub type foo =
+    ::std::option::Option<unsafe extern "C" fn(a: *mut ::std::os::raw::c_char)>;
+extern "C" {
+    pub fn bar(a: *mut ::std::os::raw::c_char);
+}
diff --git a/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs b/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs
new file mode 100644
index 00000000..d7d0f661
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/zero-size-array-align.rs
@@ -0,0 +1,90 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct dm_deps {
+    pub count: ::std::os::raw::c_uint,
+    pub filler: ::std::os::raw::c_uint,
+    pub device: __IncompleteArrayField<::std::os::raw::c_ulonglong>,
+}
+#[test]
+fn bindgen_test_layout_dm_deps() {
+    const UNINIT: ::std::mem::MaybeUninit<dm_deps> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<dm_deps>(),
+        8usize,
+        concat!("Size of: ", stringify!(dm_deps))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<dm_deps>(),
+        8usize,
+        concat!("Alignment of ", stringify!(dm_deps))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dm_deps),
+            "::",
+            stringify!(count)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).filler) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dm_deps),
+            "::",
+            stringify!(filler)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(dm_deps),
+            "::",
+            stringify!(device)
+        )
+    );
+}
diff --git a/bindgen-tests/tests/expectations/tests/zero-sized-array.rs b/bindgen-tests/tests/expectations/tests/zero-sized-array.rs
new file mode 100644
index 00000000..4ba52498
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/zero-sized-array.rs
@@ -0,0 +1,159 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
+impl<T> __IncompleteArrayField<T> {
+    #[inline]
+    pub const fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData, [])
+    }
+    #[inline]
+    pub fn as_ptr(&self) -> *const T {
+        self as *const _ as *const T
+    }
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self as *mut _ as *mut T
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+/// Bizarrely enough, this should *not* get an `_address` field.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ZeroSizedArray {
+    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_ZeroSizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<ZeroSizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ZeroSizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ZeroSizedArray),
+            "::",
+            stringify!(arr)
+        )
+    );
+}
+/// And nor should this get an `_address` field.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ContainsZeroSizedArray {
+    pub zsa: ZeroSizedArray,
+}
+#[test]
+fn bindgen_test_layout_ContainsZeroSizedArray() {
+    const UNINIT: ::std::mem::MaybeUninit<ContainsZeroSizedArray> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ContainsZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ContainsZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ContainsZeroSizedArray))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).zsa) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ContainsZeroSizedArray),
+            "::",
+            stringify!(zsa)
+        )
+    );
+}
+/// Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
+/// either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct InheritsZeroSizedArray {
+    pub _base: ZeroSizedArray,
+}
+#[test]
+fn bindgen_test_layout_InheritsZeroSizedArray() {
+    assert_eq!(
+        ::std::mem::size_of::<InheritsZeroSizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(InheritsZeroSizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<InheritsZeroSizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(InheritsZeroSizedArray))
+    );
+}
+/// And this should not get an `_address` field either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct DynamicallySizedArray {
+    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
+}
+#[test]
+fn bindgen_test_layout_DynamicallySizedArray() {
+    assert_eq!(
+        ::std::mem::size_of::<DynamicallySizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(DynamicallySizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<DynamicallySizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(DynamicallySizedArray))
+    );
+}
+/// No `_address` field here either.
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct ContainsDynamicallySizedArray {
+    pub dsa: DynamicallySizedArray,
+}
+#[test]
+fn bindgen_test_layout_ContainsDynamicallySizedArray() {
+    assert_eq!(
+        ::std::mem::size_of::<ContainsDynamicallySizedArray>(),
+        0usize,
+        concat!("Size of: ", stringify!(ContainsDynamicallySizedArray))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ContainsDynamicallySizedArray>(),
+        1usize,
+        concat!("Alignment of ", stringify!(ContainsDynamicallySizedArray))
+    );
+}
diff --git a/bindgen-tests/tests/headers/16-byte-alignment.h b/bindgen-tests/tests/headers/16-byte-alignment.h
new file mode 100644
index 00000000..235a994a
--- /dev/null
+++ b/bindgen-tests/tests/headers/16-byte-alignment.h
@@ -0,0 +1,34 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+struct rte_ipv4_tuple {
+        uint32_t        src_addr;
+        uint32_t        dst_addr;
+        union {
+                struct {
+                        uint16_t dport;
+                        uint16_t sport;
+                };
+                uint32_t        sctp_tag;
+        };
+};
+
+struct rte_ipv6_tuple {
+        uint8_t         src_addr[16];
+        uint8_t         dst_addr[16];
+        union {
+                struct {
+                        uint16_t dport;
+                        uint16_t sport;
+                };
+                uint32_t        sctp_tag;
+        };
+};
+
+union rte_thash_tuple {
+        struct rte_ipv4_tuple   v4;
+        struct rte_ipv6_tuple   v6;
+} __attribute__((aligned(16)));
diff --git a/bindgen-tests/tests/headers/16-byte-alignment_1_0.h b/bindgen-tests/tests/headers/16-byte-alignment_1_0.h
new file mode 100644
index 00000000..8a9fd491
--- /dev/null
+++ b/bindgen-tests/tests/headers/16-byte-alignment_1_0.h
@@ -0,0 +1,34 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+struct rte_ipv4_tuple {
+        uint32_t        src_addr;
+        uint32_t        dst_addr;
+        union {
+                struct {
+                        uint16_t dport;
+                        uint16_t sport;
+                };
+                uint32_t        sctp_tag;
+        };
+};
+
+struct rte_ipv6_tuple {
+        uint8_t         src_addr[16];
+        uint8_t         dst_addr[16];
+        union {
+                struct {
+                        uint16_t dport;
+                        uint16_t sport;
+                };
+                uint32_t        sctp_tag;
+        };
+};
+
+union rte_thash_tuple {
+        struct rte_ipv4_tuple   v4;
+        struct rte_ipv6_tuple   v6;
+} __attribute__((aligned(16)));
diff --git a/bindgen-tests/tests/headers/381-decltype-alias.hpp b/bindgen-tests/tests/headers/381-decltype-alias.hpp
new file mode 100644
index 00000000..0bec2fc7
--- /dev/null
+++ b/bindgen-tests/tests/headers/381-decltype-alias.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -std=c++11
+
+namespace std {
+  template<typename _Alloc> struct allocator_traits {
+    typedef decltype ( _S_size_type_helper ( ( _Alloc * ) 0 ) ) __size_type;
+  };
+}
diff --git a/bindgen-tests/tests/headers/abi_variadic_function.hpp b/bindgen-tests/tests/headers/abi_variadic_function.hpp
new file mode 100644
index 00000000..2141535c
--- /dev/null
+++ b/bindgen-tests/tests/headers/abi_variadic_function.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: -- -std=c++11
+
+char __attribute__((ms_abi)) a(char, ...);
+char b(char, ...);
diff --git a/bindgen-tests/tests/headers/accessors.hpp b/bindgen-tests/tests/headers/accessors.hpp
new file mode 100644
index 00000000..4c23e35d
--- /dev/null
+++ b/bindgen-tests/tests/headers/accessors.hpp
@@ -0,0 +1,46 @@
+struct SomeAccessors {
+    int mNoAccessor;
+    /** <div rustbindgen accessor></div> */
+    int mBothAccessors;
+    /** <div rustbindgen accessor="unsafe"></div> */
+    int mUnsafeAccessors;
+    /** <div rustbindgen accessor="immutable"></div> */
+    int mImmutableAccessor;
+};
+
+/** <div rustbindgen accessor></div> */
+struct AllAccessors {
+    int mBothAccessors;
+    int mAlsoBothAccessors;
+};
+
+/** <div rustbindgen accessor="unsafe"></div> */
+struct AllUnsafeAccessors {
+    int mBothAccessors;
+    int mAlsoBothAccessors;
+};
+
+/** <div rustbindgen accessor></div> */
+struct ContradictAccessors {
+    int mBothAccessors;
+    /** <div rustbindgen accessor="false"></div> */
+    int mNoAccessors;
+    /** <div rustbindgen accessor="unsafe"></div> */
+    int mUnsafeAccessors;
+    /** <div rustbindgen accessor="immutable"></div> */
+    int mImmutableAccessor;
+};
+
+/** <div rustbindgen accessor replaces="Replaced"></div> */
+struct Replacing {
+    int mAccessor;
+};
+
+struct Replaced {
+    int noOp;
+};
+
+/** <div rustbindgen accessor></div> */
+struct Wrapper {
+    Replaced mReplaced;
+};
diff --git a/bindgen-tests/tests/headers/allowlist-file.hpp b/bindgen-tests/tests/headers/allowlist-file.hpp
new file mode 100644
index 00000000..b0354a04
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist-file.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --allowlist-file ".*/allowlisted/file.*" --allowlist-type AllowlistMe -- -Itests/headers
+
+
+// Forward declaration of struct that's defined in an allowlisted file.
+struct StructWithAllowlistedDefinition;
+
+#include "allowlisted/file.hpp"
+
+// Actual definition of struct that has a forward declaration in an allowlisted file.
+struct StructWithAllowlistedFwdDecl {
+    int b;
+};
+
+class Ignored {
+    char c;
+};
+
+// Also have an explicitly allowlisted type
+class AllowlistMe {
+    int foo;
+};
diff --git a/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp b/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp
new file mode 100644
index 00000000..fb4dd1be
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist-namespaces-basic.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type outer::inner::Helper
+
+namespace outer {
+  namespace inner {
+    struct Helper {};
+  }
+  struct Test {
+    inner::Helper helper;
+  };
+}
diff --git a/bindgen-tests/tests/headers/allowlist-namespaces.hpp b/bindgen-tests/tests/headers/allowlist-namespaces.hpp
new file mode 100644
index 00000000..2cffe9d3
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist-namespaces.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type '.*'
+
+namespace outer {
+  namespace inner {
+    struct Helper {};
+  }
+  struct Test {
+    inner::Helper helper;
+  };
+}
diff --git a/bindgen-tests/tests/headers/allowlist_basic.hpp b/bindgen-tests/tests/headers/allowlist_basic.hpp
new file mode 100644
index 00000000..ef858c95
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist_basic.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --allowlist-type AllowlistMe
+
+template<typename T>
+class AllowlistMe {
+  class Inner {
+    T bar;
+  };
+
+  int foo;
+  Inner bar;
+};
+
+struct DontAllowlistMe {
+  void* foo;
+  double _Complex noComplexGenerated;
+};
diff --git a/bindgen-tests/tests/headers/allowlist_fix.hpp b/bindgen-tests/tests/headers/allowlist_fix.hpp
new file mode 100644
index 00000000..ff810fc6
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist_fix.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: --allowlist-function 'Servo_.*' --blocklist-type Test --raw-line "pub enum Test {}"
+
+struct Test {};
+extern "C" void Servo_Test(Test* a);
diff --git a/bindgen-tests/tests/headers/allowlist_vars.h b/bindgen-tests/tests/headers/allowlist_vars.h
new file mode 100644
index 00000000..07fa2815
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist_vars.h
@@ -0,0 +1,4 @@
+#define NONE      0
+#define FOO       5
+#define FOOB     -2
+#define FOOBAR  (-10)
diff --git a/bindgen-tests/tests/headers/allowlist_warnings.h b/bindgen-tests/tests/headers/allowlist_warnings.h
new file mode 100644
index 00000000..83c9e259
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlist_warnings.h
@@ -0,0 +1,2 @@
+// bindgen-flags: --allowlist-function "doesnt_match_anything"
+int non_matched_function(int arg);
diff --git a/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp b/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp
new file mode 100644
index 00000000..56c2a39f
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlisted-item-references-no-hash.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --allowlist-type "AllowlistMe" --no-hash "NoHash"
+
+struct NoHash {};
+
+class AllowlistMe {
+  NoHash a;
+};
diff --git a/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp b/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp
new file mode 100644
index 00000000..d85fb6b7
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlisted-item-references-no-partialeq.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-partialeq --allowlist-type "AllowlistMe" --no-partialeq "NoPartialEq"
+
+struct NoPartialEq {};
+
+class AllowlistMe {
+  NoPartialEq a;
+};
diff --git a/bindgen-tests/tests/headers/allowlisted/file.hpp b/bindgen-tests/tests/headers/allowlisted/file.hpp
new file mode 100644
index 00000000..5f360e5e
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlisted/file.hpp
@@ -0,0 +1,22 @@
+void SomeFunction();
+extern int someVar;
+#define SOME_DEFUN 123
+
+class someClass {
+  void somePrivateMethod();
+public:
+  void somePublicMethod(int foo);
+};
+
+extern "C" void ExternFunction();
+
+namespace foo {
+  void NamespacedFunction();
+}
+
+
+struct StructWithAllowlistedFwdDecl;
+
+struct StructWithAllowlistedDefinition {
+    StructWithAllowlistedFwdDecl* other;
+};
diff --git a/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp b/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp
new file mode 100644
index 00000000..9feb3054
--- /dev/null
+++ b/bindgen-tests/tests/headers/allowlisted_item_references_no_copy.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --allowlist-type "AllowlistMe" --no-copy "NoCopy"
+
+struct NoCopy {};
+
+class AllowlistMe {
+  NoCopy a;
+};
diff --git a/bindgen-tests/tests/headers/annotation_hide.hpp b/bindgen-tests/tests/headers/annotation_hide.hpp
new file mode 100644
index 00000000..3c82c9a2
--- /dev/null
+++ b/bindgen-tests/tests/headers/annotation_hide.hpp
@@ -0,0 +1,16 @@
+
+/**
+ * <div rustbindgen="true" hide="true"></div>
+ */
+struct C;
+
+/**
+ * <div rustbindgen opaque></div>
+ */
+struct D {
+    int a;
+};
+
+struct NotAnnotated {
+    int f;
+};
diff --git a/bindgen-tests/tests/headers/anon-fields-prefix.h b/bindgen-tests/tests/headers/anon-fields-prefix.h
new file mode 100644
index 00000000..8dcae0c6
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon-fields-prefix.h
@@ -0,0 +1,15 @@
+// bindgen-flags: --anon-fields-prefix "u"
+
+union color {
+  struct {
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+  };
+  struct {
+    unsigned char y;
+    unsigned char u;
+    unsigned char v;
+  };
+  unsigned char v3[3];
+};
diff --git a/bindgen-tests/tests/headers/anon_enum.hpp b/bindgen-tests/tests/headers/anon_enum.hpp
new file mode 100644
index 00000000..bbd52240
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_enum.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+struct Test {
+  int foo;
+  float bar;
+  enum { T_NONE };
+};
+
+typedef enum {
+  Foo,
+  Bar,
+} Baz;
diff --git a/bindgen-tests/tests/headers/anon_enum_allowlist.h b/bindgen-tests/tests/headers/anon_enum_allowlist.h
new file mode 100644
index 00000000..94119a87
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_enum_allowlist.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --allowlist-var "NODE_.*" --rustified-enum ".*"
+
+enum {
+  NODE_FLAG_FOO,
+  NODE_FLAG_BAR,
+};
diff --git a/bindgen-tests/tests/headers/anon_enum_trait.hpp b/bindgen-tests/tests/headers/anon_enum_trait.hpp
new file mode 100644
index 00000000..cc0cd389
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_enum_trait.hpp
@@ -0,0 +1,23 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+
+template<typename _Tp>
+class DataType {
+public:
+    typedef _Tp         value_type;
+    typedef value_type  work_type;
+    typedef value_type  channel_type;
+    typedef value_type  vec_type;
+    enum { generic_type = 1,
+           depth        = -1,
+           channels     = 1,
+           fmt          = 0,
+           type = -1,
+         };
+};
+
+struct Foo {
+  enum {
+    Bar = 0,
+    Baz = 0,
+  };
+};
diff --git a/bindgen-tests/tests/headers/anon_struct_in_union.h b/bindgen-tests/tests/headers/anon_struct_in_union.h
new file mode 100644
index 00000000..2587ede5
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_struct_in_union.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct s {
+  union {
+    struct inner {
+      int b;
+    } field;
+  } u;
+};
diff --git a/bindgen-tests/tests/headers/anon_struct_in_union_1_0.h b/bindgen-tests/tests/headers/anon_struct_in_union_1_0.h
new file mode 100644
index 00000000..6b59723a
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_struct_in_union_1_0.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct s {
+  union {
+    struct inner {
+      int b;
+    } field;
+  } u;
+};
diff --git a/bindgen-tests/tests/headers/anon_union.hpp b/bindgen-tests/tests/headers/anon_union.hpp
new file mode 100644
index 00000000..e4be25bc
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_union.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+template<typename T>
+struct TErrorResult {
+  enum UnionState {
+    HasMessage,
+    HasException,
+  };
+  int mResult;
+  struct Message;
+  struct DOMExceptionInfo;
+  union {
+    Message* mMessage;
+    DOMExceptionInfo* mDOMExceptionInfo;
+  };
+
+  bool mMightHaveUnreported;
+  UnionState mUnionState;
+};
+
+struct ErrorResult : public TErrorResult<int> {
+};
diff --git a/bindgen-tests/tests/headers/anon_union_1_0.hpp b/bindgen-tests/tests/headers/anon_union_1_0.hpp
new file mode 100644
index 00000000..3d9ae3dd
--- /dev/null
+++ b/bindgen-tests/tests/headers/anon_union_1_0.hpp
@@ -0,0 +1,22 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+
+template<typename T>
+struct TErrorResult {
+  enum UnionState {
+    HasMessage,
+    HasException,
+  };
+  int mResult;
+  struct Message;
+  struct DOMExceptionInfo;
+  union {
+    Message* mMessage;
+    DOMExceptionInfo* mDOMExceptionInfo;
+  };
+
+  bool mMightHaveUnreported;
+  UnionState mUnionState;
+};
+
+struct ErrorResult : public TErrorResult<int> {
+};
diff --git a/bindgen-tests/tests/headers/anonymous-template-types.hpp b/bindgen-tests/tests/headers/anonymous-template-types.hpp
new file mode 100644
index 00000000..d4ad534b
--- /dev/null
+++ b/bindgen-tests/tests/headers/anonymous-template-types.hpp
@@ -0,0 +1,24 @@
+// bindgen-flags:  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
+
+template <typename T, typename>
+struct Foo {
+    T t_member;
+};
+
+template <typename U, typename>
+struct Bar {
+    char member;
+};
+
+template <typename, typename V>
+struct Quux {
+    V v_member;
+};
+
+template <typename, typename W>
+struct Lobo {
+    char also_member;
+};
+
+template <typename>
+using AliasWithAnonType = char;
diff --git a/bindgen-tests/tests/headers/arg_keyword.hpp b/bindgen-tests/tests/headers/arg_keyword.hpp
new file mode 100644
index 00000000..283fcf23
--- /dev/null
+++ b/bindgen-tests/tests/headers/arg_keyword.hpp
@@ -0,0 +1,3 @@
+// This comment exists to ensure that `--dump-preprocessed-input` doesn't strip
+// comments.
+void foo(const char* type);
diff --git a/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp b/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp
new file mode 100644
index 00000000..87b36d41
--- /dev/null
+++ b/bindgen-tests/tests/headers/array-of-zero-sized-types.hpp
@@ -0,0 +1,12 @@
+/**
+ * This should get an `_address` byte.
+ */
+struct Empty {};
+
+/**
+ * This should not get an `_address` byte, since each `Empty` gets one, meaning
+ * that this object is addressable.
+ */
+struct HasArrayOfEmpty {
+    Empty empties[10];
+};
diff --git a/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp b/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp
new file mode 100644
index 00000000..26fda091
--- /dev/null
+++ b/bindgen-tests/tests/headers/attribute_warn_unused_result.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --rust-target 1.27 --enable-function-attribute-detection
+
+class Foo {
+public:
+    __attribute__((warn_unused_result))
+    int foo(int);
+};
+
+__attribute__((warn_unused_result))
+int foo(int);
diff --git a/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp b/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
new file mode 100644
index 00000000..21550307
--- /dev/null
+++ b/bindgen-tests/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --rust-target 1.27
+
+class Foo {
+public:
+    __attribute__((warn_unused_result))
+    int foo(int);
+};
+
+__attribute__((warn_unused_result))
+int foo(int);
diff --git a/bindgen-tests/tests/headers/attribute_warn_unused_result_pre_1_27.hpp b/bindgen-tests/tests/headers/attribute_warn_unused_result_pre_1_27.hpp
new file mode 100644
index 00000000..25127d9c
--- /dev/null
+++ b/bindgen-tests/tests/headers/attribute_warn_unused_result_pre_1_27.hpp
@@ -0,0 +1,8 @@
+class Foo {
+public:
+    __attribute__((warn_unused_result))
+    int foo(int);
+};
+
+__attribute__((warn_unused_result))
+int foo(int);
diff --git a/bindgen-tests/tests/headers/auto.hpp b/bindgen-tests/tests/headers/auto.hpp
new file mode 100644
index 00000000..b5f6d5f3
--- /dev/null
+++ b/bindgen-tests/tests/headers/auto.hpp
@@ -0,0 +1,19 @@
+// bindgen-flags: -- -std=c++14
+// bindgen-unstable
+
+class Foo {
+  static constexpr auto kFoo = 2 == 2;
+};
+
+template<typename T>
+class Bar {
+  static const constexpr auto kBar = T(1);
+};
+
+template<typename T> auto Test1() {
+  return T(1);
+}
+
+auto Test2() {
+  return Test1<unsigned int>();
+}
diff --git a/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp b/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp
new file mode 100644
index 00000000..ce21a401
--- /dev/null
+++ b/bindgen-tests/tests/headers/bad-namespace-parenthood-inheritance.hpp
@@ -0,0 +1,15 @@
+namespace std
+{
+  template < typename > struct char_traits;
+}
+namespace __gnu_cxx
+{
+  template < typename > struct char_traits;
+}
+namespace std
+{
+  template < class _CharT > struct char_traits:__gnu_cxx::char_traits <
+    _CharT >
+  {
+  };
+}
diff --git a/bindgen-tests/tests/headers/base-to-derived.hpp b/bindgen-tests/tests/headers/base-to-derived.hpp
new file mode 100644
index 00000000..ea31e0f2
--- /dev/null
+++ b/bindgen-tests/tests/headers/base-to-derived.hpp
@@ -0,0 +1,19 @@
+// bindgen-flags: -- -std=c++11
+
+struct false_type {};
+
+template<typename _From, typename _To, bool>
+struct __is_base_to_derived_ref;
+
+template<typename _From, typename _To>
+struct __is_base_to_derived_ref<_From, _To, true>
+{
+  typedef _To type;
+
+  static constexpr bool value = type::value;
+};
+
+template<typename _From, typename _To>
+struct __is_base_to_derived_ref<_From, _To, false>
+: public false_type
+{ };
diff --git a/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp b/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp
new file mode 100644
index 00000000..6a7d3a30
--- /dev/null
+++ b/bindgen-tests/tests/headers/bindgen-union-inside-namespace.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --rust-target 1.0 --enable-cxx-namespaces
+
+namespace foo {
+  union Bar {
+    int foo;
+    int bar;
+  };
+}
diff --git a/bindgen-tests/tests/headers/bitfield-32bit-overflow.h b/bindgen-tests/tests/headers/bitfield-32bit-overflow.h
new file mode 100644
index 00000000..90796996
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-32bit-overflow.h
@@ -0,0 +1,36 @@
+
+struct MuchBitfield {
+  char m0 : 1;
+  char m1 : 1;
+  char m2 : 1;
+  char m3 : 1;
+  char m4 : 1;
+  char m5 : 1;
+  char m6 : 1;
+  char m7 : 1;
+  char m8 : 1;
+  char m9 : 1;
+  char m10 : 1;
+  char m11 : 1;
+  char m12 : 1;
+  char m13 : 1;
+  char m14 : 1;
+  char m15 : 1;
+  char m16 : 1;
+  char m17 : 1;
+  char m18 : 1;
+  char m19 : 1;
+  char m20 : 1;
+  char m21 : 1;
+  char m22 : 1;
+  char m23 : 1;
+  char m24 : 1;
+  char m25 : 1;
+  char m26 : 1;
+  char m27 : 1;
+  char m28 : 1;
+  char m29 : 1;
+  char m30 : 1;
+  char m31 : 1;
+  char m32 : 1;
+};
diff --git a/bindgen-tests/tests/headers/bitfield-enum-basic.hpp b/bindgen-tests/tests/headers/bitfield-enum-basic.hpp
new file mode 100644
index 00000000..339fb4d5
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-enum-basic.hpp
@@ -0,0 +1,27 @@
+// bindgen-flags: --bitfield-enum "Foo|Buz|NS_.*|DUMMY_.*" --rustified-enum ".*" -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
+
+enum class Buz : signed char {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
+
+enum {
+  NS_FOO = 1 << 0,
+  NS_BAR = 1 << 1,
+};
+
+class Dummy {
+  enum {
+    DUMMY_FOO = 1 << 0,
+    DUMMY_BAR = 1 << 1,
+  };
+};
diff --git a/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp b/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp
new file mode 100644
index 00000000..20a3f9db
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-enum-repr-c.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --bitfield-enum "Foo" --rust-target 1.27  -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
diff --git a/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp b/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp
new file mode 100644
index 00000000..e53bb075
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-enum-repr-transparent.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --bitfield-enum "Foo" --rust-target 1.28  -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
diff --git a/bindgen-tests/tests/headers/bitfield-large.hpp b/bindgen-tests/tests/headers/bitfield-large.hpp
new file mode 100644
index 00000000..2e349279
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-large.hpp
@@ -0,0 +1,9 @@
+struct HasBigBitfield {
+  __int128 x : 128;
+};
+
+
+struct HasTwoBigBitfields {
+  __int128 x : 80;
+  __int128 y : 48;
+};
diff --git a/bindgen-tests/tests/headers/bitfield-linux-32.hpp b/bindgen-tests/tests/headers/bitfield-linux-32.hpp
new file mode 100644
index 00000000..b9a480df
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-linux-32.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: -- --target=i586-unknown-linux
+
+typedef unsigned long long uint64_t;
+
+struct Test {
+  uint64_t foo;
+  uint64_t x : 56;
+  uint64_t y : 8;
+};
diff --git a/bindgen-tests/tests/headers/bitfield-method-same-name.hpp b/bindgen-tests/tests/headers/bitfield-method-same-name.hpp
new file mode 100644
index 00000000..d66f16c0
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield-method-same-name.hpp
@@ -0,0 +1,6 @@
+struct Foo {
+    char type_ : 3;
+    char type();
+    void set_type_(char c);
+    void set_type(char c);
+};
diff --git a/bindgen-tests/tests/headers/bitfield_align.h b/bindgen-tests/tests/headers/bitfield_align.h
new file mode 100644
index 00000000..7b9527a2
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield_align.h
@@ -0,0 +1,49 @@
+struct A {
+  unsigned char x;
+  unsigned b1 : 1;
+  unsigned b2 : 1;
+  unsigned b3 : 1;
+  unsigned b4 : 1;
+  unsigned b5 : 1;
+  unsigned b6 : 1;
+  unsigned b7 : 1;
+  unsigned b8 : 1;
+  unsigned b9 : 1;
+  unsigned b10 : 1;
+  unsigned char y;
+};
+
+struct B {
+  unsigned foo : 31;
+  unsigned char bar : 1;
+};
+
+struct C {
+  unsigned char x;
+  unsigned b1 : 1;
+  unsigned b2 : 1;
+  unsigned baz;
+};
+
+struct Date1 {
+   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+   unsigned short nMonth    : 5;    // 0..12  (5 bits)
+   unsigned short nYear     : 8;    // 0..100 (8 bits)
+};
+
+struct Date2 {
+   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+   unsigned short nMonth    : 5;    // 0..12  (5 bits)
+   unsigned short nYear     : 8;    // 0..100 (8 bits)
+   unsigned char byte : 8;
+};
+
+struct Date3 {
+   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+   unsigned short nMonth    : 5;    // 0..12  (5 bits)
+   unsigned short nYear     : 8;    // 0..100 (8 bits)
+   unsigned char byte;
+};
diff --git a/bindgen-tests/tests/headers/bitfield_align_2.h b/bindgen-tests/tests/headers/bitfield_align_2.h
new file mode 100644
index 00000000..cb0f2e20
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield_align_2.h
@@ -0,0 +1,12 @@
+// bindgen-flags: --rustified-enum ".*" --raw-line '#![cfg(not(target_os="windows"))]'
+enum MyEnum {
+    ONE,
+    TWO,
+    THREE,
+    FOUR
+};
+
+struct TaggedPtr {
+    enum MyEnum tag : 2;
+    long   ptr : 62;
+};
diff --git a/bindgen-tests/tests/headers/bitfield_large_overflow.hpp b/bindgen-tests/tests/headers/bitfield_large_overflow.hpp
new file mode 100644
index 00000000..9e040ae3
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield_large_overflow.hpp
@@ -0,0 +1,3 @@
+struct {
+  unsigned : 632;
+} a;
diff --git a/bindgen-tests/tests/headers/bitfield_method_mangling.h b/bindgen-tests/tests/headers/bitfield_method_mangling.h
new file mode 100644
index 00000000..257648ee
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield_method_mangling.h
@@ -0,0 +1,5 @@
+typedef struct
+{
+  unsigned int pad3: 24;
+  unsigned int type: 8;
+} mach_msg_type_descriptor_t;
diff --git a/bindgen-tests/tests/headers/bitfield_pragma_packed.h b/bindgen-tests/tests/headers/bitfield_pragma_packed.h
new file mode 100644
index 00000000..b4011ca8
--- /dev/null
+++ b/bindgen-tests/tests/headers/bitfield_pragma_packed.h
@@ -0,0 +1,9 @@
+#pragma pack(push, 1)
+struct Struct {
+    unsigned char a : 1;
+    unsigned char b : 1;
+    unsigned char c : 6;
+    unsigned short int d : 16;
+    unsigned char e : 8;
+};
+#pragma pack(pop)
diff --git a/bindgen-tests/tests/headers/block_return_type.h b/bindgen-tests/tests/headers/block_return_type.h
new file mode 100644
index 00000000..be76cb59
--- /dev/null
+++ b/bindgen-tests/tests/headers/block_return_type.h
@@ -0,0 +1,4 @@
+// bindgen-flags: --generate-block --block-extern-crate -- -fblocks
+// bindgen-osx-only
+
+int (^func(void))(int, int);
diff --git a/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp b/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp
new file mode 100644
index 00000000..14e17537
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklist-and-impl-debug.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --impl-debug --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
+
+struct BlocklistMe {};
+
+/**
+ * Because this type contains a blocklisted type, it should not derive Debug.
+ */
+struct ShouldManuallyImplDebug {
+    BlocklistMe a;
+};
diff --git a/bindgen-tests/tests/headers/blocklist-file.hpp b/bindgen-tests/tests/headers/blocklist-file.hpp
new file mode 100644
index 00000000..ad8bcd66
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklist-file.hpp
@@ -0,0 +1,18 @@
+// bindgen-flags: --blocklist-file ".*/blocklisted/file.*" -- -Itests/headers
+
+// Forward declaration of struct that's defined in a blocklisted file.
+struct StructWithBlocklistedDefinition;
+
+#include "blocklisted/file.hpp"
+#include "blocklisted/fake-stdint.h"
+
+struct SizedIntegers {
+    uint8_t x;
+    uint16_t y;
+    uint32_t z;
+};
+
+// Actual definition of struct that has a forward declaration in a blocklisted file.
+struct StructWithBlocklistedFwdDecl {
+    uint8_t b;
+};
diff --git a/bindgen-tests/tests/headers/blocklist-function.hpp b/bindgen-tests/tests/headers/blocklist-function.hpp
new file mode 100644
index 00000000..d7c8bb35
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklist-function.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --blocklist-function "ExternFunction" --blocklist-function "foo::NamespacedFunction" --blocklist-function "C_ClassMethod" --enable-cxx-namespaces
+
+extern "C" void ExternFunction();
+
+namespace foo {
+  void NamespacedFunction();
+}
+
+namespace bar {
+  void NamespacedFunction();
+}
+
+class C {
+public:
+  void ClassMethod();
+};
diff --git a/bindgen-tests/tests/headers/blocklist-item.hpp b/bindgen-tests/tests/headers/blocklist-item.hpp
new file mode 100644
index 00000000..2d795d5a
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklist-item.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --blocklist-item "SomeFunction" --blocklist-item "SOME_DEFUN" --blocklist-item "someVar" --blocklist-item "ExternFunction" --blocklist-item "foo::NamespacedFunction" --blocklist-item "someClass.*" --enable-cxx-namespaces
+
+void SomeFunction();
+extern int someVar;
+#define SOME_DEFUN 123
+
+class someClass {
+  void somePrivateMethod();
+public:
+  void somePublicMethod(int foo);
+};
+
+extern "C" void ExternFunction();
+
+namespace foo {
+  void NamespacedFunction();
+}
+
+namespace bar {
+  void NamespacedFunction();
+}
diff --git a/bindgen-tests/tests/headers/blocklisted/fake-stdint.h b/bindgen-tests/tests/headers/blocklisted/fake-stdint.h
new file mode 100644
index 00000000..a8cfe010
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklisted/fake-stdint.h
@@ -0,0 +1,7 @@
+// <stdint.h>-like types get special treatment even when blocklisted.
+typedef signed char      int8_t;
+typedef unsigned char    uint8_t;
+typedef signed short     int16_t;
+typedef unsigned short   uint16_t;
+typedef signed int       int32_t;
+typedef unsigned int     uint32_t;
diff --git a/bindgen-tests/tests/headers/blocklisted/file.hpp b/bindgen-tests/tests/headers/blocklisted/file.hpp
new file mode 100644
index 00000000..4bcb589e
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocklisted/file.hpp
@@ -0,0 +1,26 @@
+void SomeFunction();
+extern int someVar;
+#define SOME_DEFUN 123
+
+class someClass {
+  void somePrivateMethod();
+public:
+  void somePublicMethod(int foo);
+};
+
+extern "C" void ExternFunction();
+
+namespace foo {
+  void NamespacedFunction();
+}
+
+namespace bar {
+  void NamespacedFunction();
+}
+
+
+struct StructWithBlocklistedFwdDecl;
+
+struct StructWithBlocklistedDefinition {
+    StructWithBlocklistedFwdDecl* other;
+};
diff --git a/bindgen-tests/tests/headers/blocks-signature.hpp b/bindgen-tests/tests/headers/blocks-signature.hpp
new file mode 100644
index 00000000..eaa72526
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocks-signature.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: --generate-block --block-extern-crate -- -fblocks
+// bindgen-osx-only
+
+#include "blocks.hpp"
diff --git a/bindgen-tests/tests/headers/blocks.hpp b/bindgen-tests/tests/headers/blocks.hpp
new file mode 100644
index 00000000..a68de7e2
--- /dev/null
+++ b/bindgen-tests/tests/headers/blocks.hpp
@@ -0,0 +1,25 @@
+// bindgen-flags: --block-extern-crate -- -fblocks
+// bindgen-osx-only
+
+typedef unsigned long long size_t;
+
+void atexit_b(void (^)(void));
+
+typedef void *dispatch_data_t;
+
+typedef bool (^dispatch_data_applier_t)(dispatch_data_t region,
+                                        size_t offset,
+                                        const void *buffer,
+                                        size_t size);
+
+bool dispatch_data_apply(dispatch_data_t data,
+                         dispatch_data_applier_t applier);
+
+bool foo(void (^)(size_t bar));
+
+bool foo_ptr(void (^*)(size_t bar));
+
+struct contains_block_pointers {
+    void (^val)(int);
+    void (^*ptr_val)(int);
+};
diff --git a/bindgen-tests/tests/headers/bug-1529681.hpp b/bindgen-tests/tests/headers/bug-1529681.hpp
new file mode 100644
index 00000000..17fa849a
--- /dev/null
+++ b/bindgen-tests/tests/headers/bug-1529681.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++14
+//
+// https://bugzilla.mozilla.org/show_bug.cgi?id=1529681
+// https://bugs.llvm.org/show_bug.cgi?id=40813
+
+class BrowsingContext {
+  auto Tie(void* aUnused) const;
+};
diff --git a/bindgen-tests/tests/headers/builtin-template.hpp b/bindgen-tests/tests/headers/builtin-template.hpp
new file mode 100644
index 00000000..4e64ebc7
--- /dev/null
+++ b/bindgen-tests/tests/headers/builtin-template.hpp
@@ -0,0 +1,6 @@
+namespace std {
+template<class T, T... Ints>
+class integer_sequence;
+template<class T, T N>
+using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
+}
diff --git a/bindgen-tests/tests/headers/c-empty-layout.h b/bindgen-tests/tests/headers/c-empty-layout.h
new file mode 100644
index 00000000..1fe02e89
--- /dev/null
+++ b/bindgen-tests/tests/headers/c-empty-layout.h
@@ -0,0 +1 @@
+struct Foo {};
diff --git a/bindgen-tests/tests/headers/c_naming.h b/bindgen-tests/tests/headers/c_naming.h
new file mode 100644
index 00000000..fd84c271
--- /dev/null
+++ b/bindgen-tests/tests/headers/c_naming.h
@@ -0,0 +1,19 @@
+// bindgen-flags: --c-naming
+
+typedef const struct a {
+    int a;
+} *a;
+
+union b {
+    int a;
+    int b;
+};
+typedef union b b;
+
+enum c {
+    A,
+};
+
+void takes_a(a arg) {}
+void takes_b(b arg) {}
+void takes_c(enum c arg) {}
diff --git a/bindgen-tests/tests/headers/call-conv-field.h b/bindgen-tests/tests/headers/call-conv-field.h
new file mode 100644
index 00000000..da45ba1d
--- /dev/null
+++ b/bindgen-tests/tests/headers/call-conv-field.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32
+// bindgen-unstable
+//
+// We can only check that this builds, but not that it actually passes, because
+// we have no CI on the target platform.
+
+struct JNINativeInterface_ {
+  int (__stdcall *GetVersion)(void *env);
+  unsigned long long __hack; // A hack so the field alignment is the same than
+                             // for 64-bit, where we run CI.
+};
+
+__stdcall void bar();
diff --git a/bindgen-tests/tests/headers/call-conv-typedef.h b/bindgen-tests/tests/headers/call-conv-typedef.h
new file mode 100644
index 00000000..3b911dda
--- /dev/null
+++ b/bindgen-tests/tests/headers/call-conv-typedef.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32
+
+
+typedef void (__stdcall *void_fn)();
+typedef void_fn (__stdcall *fn)(int id);
diff --git a/bindgen-tests/tests/headers/canonical-types.hpp b/bindgen-tests/tests/headers/canonical-types.hpp
new file mode 100644
index 00000000..c8eadd7e
--- /dev/null
+++ b/bindgen-tests/tests/headers/canonical-types.hpp
@@ -0,0 +1,51 @@
+// bindgen-flags: -- -std=c++14
+
+// Issue #2078. To pick up the definition of `ClassCInnerA`,
+// `ty.canonical_type().declaration().definition()` is needed.
+
+template<class T>
+class ClassA {
+public:
+    class ClassAInner {
+    public:
+        T *x;
+    };
+};
+
+template<class D, class I>
+class ClassB {
+public:
+    void foo() {
+        ((D *)0)->quux();
+    }
+};
+
+template<typename T>
+class ClassC {
+    struct ClassCInnerA;
+
+    struct ClassCInnerB {
+        ClassCInnerA *cache;
+    };
+    static_assert(sizeof(ClassCInnerB) > 0, "");
+
+    struct ClassCInnerA {
+        ClassCInnerB *member;
+    };
+
+public:
+    class ClassCInnerCRTP : public ClassB<ClassCInnerCRTP, typename ClassA<ClassCInnerA>::ClassAInner> {
+    public:
+        void quux() {
+            ((typename ClassA<ClassCInnerA>::ClassAInner *)0)->x->member;
+        }
+    };
+};
+
+class ClassD : public ClassB<ClassD, ClassC<int>::ClassCInnerCRTP> {
+public:
+    void bar() {
+        ((ClassC<int>::ClassCInnerCRTP *)0)->foo();
+    }
+};
+
diff --git a/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp b/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp
new file mode 100644
index 00000000..92e85842
--- /dev/null
+++ b/bindgen-tests/tests/headers/canonical_path_without_namespacing.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --disable-name-namespacing
+
+namespace foo {
+  struct Bar {};
+}
+
+void baz(foo::Bar*);
diff --git a/bindgen-tests/tests/headers/char.h b/bindgen-tests/tests/headers/char.h
new file mode 100644
index 00000000..7cffd865
--- /dev/null
+++ b/bindgen-tests/tests/headers/char.h
@@ -0,0 +1,21 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+typedef char Char;
+typedef signed char SChar;
+typedef unsigned char UChar;
+
+struct Test {
+  char ch;
+  unsigned char u;
+  signed char d;
+  const char cch;
+  const unsigned char cu;
+  const signed char cd;
+
+  Char Cch;
+  UChar Cu;
+  SChar Cd;
+  const Char Ccch;
+  const UChar Ccu;
+  const SChar Ccd;
+};
diff --git a/bindgen-tests/tests/headers/class.hpp b/bindgen-tests/tests/headers/class.hpp
new file mode 100644
index 00000000..a90e373f
--- /dev/null
+++ b/bindgen-tests/tests/headers/class.hpp
@@ -0,0 +1,74 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord --rust-target 1.40
+//
+class C {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+};
+
+class C_with_zero_length_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char zero_length_array[0];
+};
+
+class C_with_zero_length_array_2 {
+    int a;
+    char zero_length_array[0];
+};
+
+class C_with_incomplete_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char incomplete_array[];
+};
+
+class C_with_incomplete_array_2 {
+    int a;
+    char incomplete_array[];
+};
+
+class C_with_zero_length_array_and_incomplete_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char zero_length_array[0];
+    char incomplete_array[];
+};
+
+class C_with_zero_length_array_and_incomplete_array_2 {
+    int a;
+    char zero_length_array[0];
+    char incomplete_array[];
+};
+
+class WithDtor {
+    int b;
+
+    ~WithDtor() {}
+};
+
+class IncompleteArrayNonCopiable {
+  void* whatever;
+  C incomplete_array[];
+};
+
+union Union {
+    float d;
+    int i;
+};
+
+class WithUnion {
+    Union data;
+};
+
+class RealAbstractionWithTonsOfMethods {
+  void foo();
+public:
+  void bar() const;
+  void bar();
+  void bar(int foo);
+  static void sta();
+};
diff --git a/bindgen-tests/tests/headers/class_1_0.hpp b/bindgen-tests/tests/headers/class_1_0.hpp
new file mode 100644
index 00000000..e3735eb6
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_1_0.hpp
@@ -0,0 +1,76 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --impl-partialeq --with-derive-eq
+
+class C {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+};
+
+class C_with_zero_length_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char zero_length_array[0];
+};
+
+class C_with_zero_length_array_2 {
+    int a;
+    char zero_length_array[0];
+};
+
+class C_with_incomplete_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char incomplete_array[];
+};
+
+class C_with_incomplete_array_2 {
+    int a;
+    char incomplete_array[];
+};
+
+
+class C_with_zero_length_array_and_incomplete_array {
+    int a;
+    // More than rust limits (32)
+    char big_array[33];
+    char zero_length_array[0];
+    char incomplete_array[];
+};
+
+class C_with_zero_length_array_and_incomplete_array_2 {
+    int a;
+    char zero_length_array[0];
+    char incomplete_array[];
+};
+
+
+class WithDtor {
+    int b;
+
+    ~WithDtor() {}
+};
+
+class IncompleteArrayNonCopiable {
+  void* whatever;
+  C incomplete_array[];
+};
+
+union Union {
+    float d;
+    int i;
+};
+
+class WithUnion {
+    Union data;
+};
+
+class RealAbstractionWithTonsOfMethods {
+  void foo();
+public:
+  void bar() const;
+  void bar();
+  void bar(int foo);
+  static void sta();
+};
diff --git a/bindgen-tests/tests/headers/class_nested.hpp b/bindgen-tests/tests/headers/class_nested.hpp
new file mode 100644
index 00000000..d6ca02c2
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_nested.hpp
@@ -0,0 +1,37 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+class A {
+public:
+    int member_a;
+    class B {
+        int member_b;
+    };
+
+    class C;
+
+    template<typename T>
+    class D {
+      T foo;
+    };
+};
+
+class A::C {
+  int baz;
+};
+
+A::B var;
+A::D<int> baz;
+
+class D {
+    A::B member;
+};
+
+template<typename T>
+class Templated {
+    T member;
+
+    class Templated_inner {
+    public:
+        T* member_ptr;
+        void get();
+    };
+};
diff --git a/bindgen-tests/tests/headers/class_no_members.hpp b/bindgen-tests/tests/headers/class_no_members.hpp
new file mode 100644
index 00000000..6963e372
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_no_members.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+// bindgen-flags: -- -std=c++11
+
+class whatever {
+};
+
+class whatever_child: public whatever {
+};
+
+class whatever_child_with_member: public whatever {
+public:
+    int m_member;
+};
+
+static_assert(sizeof(whatever) == 1, "Testing!");
+static_assert(sizeof(whatever_child) == 1, "Testing!");
+static_assert(sizeof(whatever_child_with_member) == 4, "Testing!");
diff --git a/bindgen-tests/tests/headers/class_static.hpp b/bindgen-tests/tests/headers/class_static.hpp
new file mode 100644
index 00000000..d8f9be6d
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_static.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+class MyClass {
+public:
+    static const int* example;
+    static const int* example_check_no_collision;
+};
+
+static const int* example_check_no_collision;
diff --git a/bindgen-tests/tests/headers/class_static_const.hpp b/bindgen-tests/tests/headers/class_static_const.hpp
new file mode 100644
index 00000000..3e320edc
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_static_const.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+using int32_t = int;
+typedef unsigned int uint32_t;
+
+class A {
+    static const int a = 0;
+    static const int32_t b = 077;
+    static const uint32_t c = 0xff;
+};
diff --git a/bindgen-tests/tests/headers/class_use_as.hpp b/bindgen-tests/tests/headers/class_use_as.hpp
new file mode 100644
index 00000000..b7eaf29b
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_use_as.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+/**
+ * <div rustbindgen="true" replaces="whatever"></div>
+ */
+struct whatever_replacement {
+    int replacement;
+};
+
+struct whatever {
+    int b;
+};
+
+struct container {
+    whatever c;
+};
diff --git a/bindgen-tests/tests/headers/class_with_dtor.hpp b/bindgen-tests/tests/headers/class_with_dtor.hpp
new file mode 100644
index 00000000..f52858a7
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_with_dtor.hpp
@@ -0,0 +1,14 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+
+template <typename T>
+class HandleWithDtor {
+    T* ptr;
+    ~HandleWithDtor() {}
+};
+
+typedef HandleWithDtor<int> HandleValue;
+
+class WithoutDtor {
+    HandleValue shouldBeWithDtor;
+};
diff --git a/bindgen-tests/tests/headers/class_with_inner_struct.hpp b/bindgen-tests/tests/headers/class_with_inner_struct.hpp
new file mode 100644
index 00000000..fd195fb7
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_with_inner_struct.hpp
@@ -0,0 +1,44 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+// bindgen-flags: -- -std=c++11
+
+class A {
+    unsigned c;
+    struct Segment { int begin, end; };
+    union {
+        int f;
+    } named_union;
+    union {
+        int d;
+    };
+};
+
+class B {
+    unsigned d;
+    struct Segment { int begin, end; };
+};
+
+
+enum class StepSyntax {
+    Keyword,                     // step-start and step-end
+    FunctionalWithoutKeyword,    // steps(...)
+    FunctionalWithStartKeyword,  // steps(..., start)
+    FunctionalWithEndKeyword,    // steps(..., end)
+};
+
+class C {
+    unsigned d;
+    union {
+        struct {
+            float mX1;
+            float mY1;
+            float mX2;
+            float mY2;
+        } mFunc;
+        struct {
+            StepSyntax mStepSyntax;
+            unsigned int mSteps;
+        };
+    };
+    // To ensure it doesn't collide
+    struct Segment { int begin, end; };
+};
diff --git a/bindgen-tests/tests/headers/class_with_inner_struct_1_0.hpp b/bindgen-tests/tests/headers/class_with_inner_struct_1_0.hpp
new file mode 100644
index 00000000..34ed96e7
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_with_inner_struct_1_0.hpp
@@ -0,0 +1,44 @@
+// bindgen-flags: --rust-target 1.0  --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+// bindgen-flags: -- -std=c++11
+
+class A {
+    unsigned c;
+    struct Segment { int begin, end; };
+    union {
+        int f;
+    } named_union;
+    union {
+        int d;
+    };
+};
+
+class B {
+    unsigned d;
+    struct Segment { int begin, end; };
+};
+
+
+enum class StepSyntax {
+    Keyword,                     // step-start and step-end
+    FunctionalWithoutKeyword,    // steps(...)
+    FunctionalWithStartKeyword,  // steps(..., start)
+    FunctionalWithEndKeyword,    // steps(..., end)
+};
+
+class C {
+    unsigned d;
+    union {
+        struct {
+            float mX1;
+            float mY1;
+            float mX2;
+            float mY2;
+        } mFunc;
+        struct {
+            StepSyntax mStepSyntax;
+            unsigned int mSteps;
+        };
+    };
+    // To ensure it doesn't collide
+    struct Segment { int begin, end; };
+};
diff --git a/bindgen-tests/tests/headers/class_with_typedef.hpp b/bindgen-tests/tests/headers/class_with_typedef.hpp
new file mode 100644
index 00000000..7c3d3c97
--- /dev/null
+++ b/bindgen-tests/tests/headers/class_with_typedef.hpp
@@ -0,0 +1,23 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+typedef int AnotherInt;
+
+class C {
+public:
+    typedef int MyInt;
+    typedef const char* Lookup;
+    MyInt c;
+    MyInt* ptr;
+    MyInt arr[10];
+    AnotherInt d;
+    AnotherInt* other_ptr;
+
+    void method(MyInt c);
+    void methodRef(MyInt& c);
+    void complexMethodRef(Lookup& c);
+    void anotherMethod(AnotherInt c);
+};
+
+class D: public C {
+public:
+    MyInt* ptr;
+};
diff --git a/bindgen-tests/tests/headers/comment-indent.hpp b/bindgen-tests/tests/headers/comment-indent.hpp
new file mode 100644
index 00000000..96c13fcc
--- /dev/null
+++ b/bindgen-tests/tests/headers/comment-indent.hpp
@@ -0,0 +1,47 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+/**
+ * This is a multi-line doc comment.
+ *
+ * This class is really really interesting, look!
+ */
+class Foo {
+  /**
+   * This nested class is also a multi-line doc comment.
+   *
+   * This class is not so interesting, but worth a bit of docs too!
+   */
+  class Bar { };
+};
+
+namespace test {
+  /**
+   * I'm in a namespace, and thus I may be on a rust module, most of the time.
+   * My documentation is pretty extensive, I guess.
+   */
+  class Baz {
+    /**
+     * This member is plain awesome, just amazing.
+     *
+     * It also has super-extensive docs, with even a nice ascii-art diagram.
+     *
+     * +------+          +-------+
+     * | foo  |   ---->  | bar   |
+     * +------+          +-------+
+     */
+    int member;
+  };
+
+  inline namespace foobiedoobie {
+    /**
+     * I'm in an inline namespace, and as such I shouldn't get generated inside
+     * a rust module, except when the relevant option is specified. Also, this
+     * comment shouldn't be misaligned.
+     */
+    class InInlineNS {
+    };
+  }
+
+  /**/
+  class Bazz {};
+}
diff --git a/bindgen-tests/tests/headers/complex.h b/bindgen-tests/tests/headers/complex.h
new file mode 100644
index 00000000..2996be1f
--- /dev/null
+++ b/bindgen-tests/tests/headers/complex.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+#define COMPLEX_TEST(ty_, name_)  \
+  struct Test##name_ {            \
+    ty_ _Complex mMember;         \
+                                  \
+  };                              \
+  struct Test##name_##Ptr {       \
+    ty_ _Complex* mMember;        \
+  };
+
+COMPLEX_TEST(double, Double)
+COMPLEX_TEST(float, Float)
+
+// FIXME: 128-byte-aligned in some machines
+// which we can't support right now in Rust.
+// COMPLEX_TEST(long double, LongDouble)
diff --git a/bindgen-tests/tests/headers/complex_global.h b/bindgen-tests/tests/headers/complex_global.h
new file mode 100644
index 00000000..6b9ffa53
--- /dev/null
+++ b/bindgen-tests/tests/headers/complex_global.h
@@ -0,0 +1,4 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+float _Complex globalValueFloat;
+double _Complex globalValueDouble;
+long double _Complex globalValueLongDouble;
diff --git a/bindgen-tests/tests/headers/const-const-mut-ptr.h b/bindgen-tests/tests/headers/const-const-mut-ptr.h
new file mode 100644
index 00000000..cc7daf7c
--- /dev/null
+++ b/bindgen-tests/tests/headers/const-const-mut-ptr.h
@@ -0,0 +1,3 @@
+struct foo {
+  const int** const* const* bar;
+};
diff --git a/bindgen-tests/tests/headers/const_array.h b/bindgen-tests/tests/headers/const_array.h
new file mode 100644
index 00000000..a337881f
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_array.h
@@ -0,0 +1,2 @@
+extern const int foo[1];
+extern int bar[1];
diff --git a/bindgen-tests/tests/headers/const_array_fn_arg.h b/bindgen-tests/tests/headers/const_array_fn_arg.h
new file mode 100644
index 00000000..ebe22861
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_array_fn_arg.h
@@ -0,0 +1 @@
+void f(const int a[]);
diff --git a/bindgen-tests/tests/headers/const_bool.hpp b/bindgen-tests/tests/headers/const_bool.hpp
new file mode 100644
index 00000000..633a7c90
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_bool.hpp
@@ -0,0 +1,9 @@
+// bindgen-unstable
+
+const bool k = true;
+struct A {
+  static const bool k = false;
+};
+
+typedef bool foo;
+const foo k2 = true;
diff --git a/bindgen-tests/tests/headers/const_enum_unnamed.hpp b/bindgen-tests/tests/headers/const_enum_unnamed.hpp
new file mode 100644
index 00000000..cee87e64
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_enum_unnamed.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum {
+  FOO_BAR,
+  FOO_BAZ,
+};
+
+class Foo {
+  enum { FOO_BAR = 10 };
+};
diff --git a/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h b/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h
new file mode 100644
index 00000000..784a51fe
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_multidim_array_fn_arg.h
@@ -0,0 +1 @@
+void f(const int a[1][1]);
diff --git a/bindgen-tests/tests/headers/const_ptr.hpp b/bindgen-tests/tests/headers/const_ptr.hpp
new file mode 100644
index 00000000..66744f8b
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_ptr.hpp
@@ -0,0 +1,3 @@
+extern "C" {
+  void foo(const void* bar);
+}
diff --git a/bindgen-tests/tests/headers/const_resolved_ty.h b/bindgen-tests/tests/headers/const_resolved_ty.h
new file mode 100644
index 00000000..2521e61c
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_resolved_ty.h
@@ -0,0 +1,3 @@
+typedef unsigned char uint8_t;
+
+void foo(const uint8_t* foo);
diff --git a/bindgen-tests/tests/headers/const_tparam.hpp b/bindgen-tests/tests/headers/const_tparam.hpp
new file mode 100644
index 00000000..05f26e4a
--- /dev/null
+++ b/bindgen-tests/tests/headers/const_tparam.hpp
@@ -0,0 +1,5 @@
+template<typename T>
+class C {
+  const T* const foo;
+  const T* bar;
+};
diff --git a/bindgen-tests/tests/headers/constant-evaluate.h b/bindgen-tests/tests/headers/constant-evaluate.h
new file mode 100644
index 00000000..812553ed
--- /dev/null
+++ b/bindgen-tests/tests/headers/constant-evaluate.h
@@ -0,0 +1,21 @@
+// bindgen-unstable
+// bindgen-flags: --rustified-enum ".*"
+
+enum {
+  foo = 4,
+  bar = 8,
+};
+
+typedef unsigned long long EasyToOverflow;
+const EasyToOverflow k = 0x80000000;
+
+const EasyToOverflow k_expr = 1ULL << 60;
+const EasyToOverflow wow = 1ULL << 31;
+
+const long long BAZ = (1 << foo) | bar;
+const double fuzz = (1 + 50.0f);
+const char BAZZ = '5';
+const char WAT = '\0';
+
+const char* bytestring = "Foo";
+const char* NOT_UTF8 = "\xf0\x28\x8c\x28";
diff --git a/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp b/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp
new file mode 100644
index 00000000..539c2887
--- /dev/null
+++ b/bindgen-tests/tests/headers/constant-non-specialized-tp.hpp
@@ -0,0 +1,15 @@
+// bindgen-flags: -- -std=c++11
+
+// This test ensure we protect ourselves from an LLVM crash.
+
+template <class... Args>
+struct Test {
+  static constexpr bool x[] = {Args::x...};
+};
+
+template<typename... T>
+struct Outer {
+  struct Inner {
+    static constexpr int value[] = { T::value... };
+  };
+};
diff --git a/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp b/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp
new file mode 100644
index 00000000..d48f2be1
--- /dev/null
+++ b/bindgen-tests/tests/headers/constified-enum-module-overflow.hpp
@@ -0,0 +1,8 @@
+template <typename> class B{};
+template <typename c> class C {
+public:
+  using U = B<c>;
+};
+class A : C<A> {
+  U u;
+};
diff --git a/bindgen-tests/tests/headers/constify-all-enums.h b/bindgen-tests/tests/headers/constify-all-enums.h
new file mode 100644
index 00000000..6f4364e3
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-all-enums.h
@@ -0,0 +1,10 @@
+
+enum foo {
+  THIS,
+  SHOULD_BE,
+  A_CONSTANT,
+};
+
+struct bar {
+  enum foo this_should_work;
+};
diff --git a/bindgen-tests/tests/headers/constify-enum.h b/bindgen-tests/tests/headers/constify-enum.h
new file mode 100644
index 00000000..b8e0be3e
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-enum.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum nsCSSPropertyID {
+  eCSSProperty_a,
+  eCSSProperty_b,
+
+  eCSSProperty_COUNT, /**< <div rustbindgen constant></div> */
+  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1, /**< <div rustbindgen hide></div> */
+
+  eCSSPropertyAlias_aa,
+  eCSSPropertyAlias_bb,
+
+  eCSSProperty_COUNT_unexistingVariantValue, /**< <div rustbindgen constant></div> */
+};
diff --git a/bindgen-tests/tests/headers/constify-module-enums-basic.h b/bindgen-tests/tests/headers/constify-module-enums-basic.h
new file mode 100644
index 00000000..631e8847
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-basic.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --constified-enum-module foo
+
+enum foo {
+  THIS,
+  SHOULD_BE,
+  A_CONSTANT,
+};
+
+typedef enum foo foo_alias1;
+typedef foo_alias1 foo_alias2;
+
+struct bar {
+  enum foo this_should_work;
+};
+
+enum foo *func1(enum foo arg1, enum foo *arg2, enum foo **arg3);
+foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3);
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp b/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp
new file mode 100644
index 00000000..5d8ea23a
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-namespace.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --enable-cxx-namespaces --constified-enum-module ns1::ns2::foo
+
+namespace ns1 {
+  namespace ns2 {
+    enum foo {
+      THIS,
+      SHOULD_BE,
+      A_CONSTANT,
+    };
+  }
+
+  namespace ns3 {
+    struct bar {
+      enum ns2::foo this_should_work;
+    };
+  }
+}
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h b/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h
new file mode 100644
index 00000000..38b26106
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-shadow-name.h
@@ -0,0 +1,12 @@
+// bindgen-flags: --constified-enum-module foo
+
+enum foo {
+  Type,
+  Type_,
+  Type1,
+  Type__,
+};
+
+struct bar {
+  enum foo member;
+};
diff --git a/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp b/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp
new file mode 100644
index 00000000..35ac4be3
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-simple-alias.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --constified-enum-module Foo
+
+enum class Foo {
+  Variant1, Variant2, Variant3,
+};
+
+typedef Foo Foo_alias1;
+typedef Foo_alias1 Foo_alias2;
+typedef Foo_alias2 Foo_alias3;
+
+class Bar {
+  Foo baz1;
+  Foo_alias1 baz2;
+  Foo_alias2 baz3;
+  Foo_alias3 baz4;
+
+  Foo *baz_ptr1;
+  Foo_alias1 *baz_ptr2;
+  Foo_alias2 *baz_ptr3;
+  Foo_alias3 *baz_ptr4;
+};
diff --git a/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp b/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp
new file mode 100644
index 00000000..5b15f5c8
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-simple-nonamespace.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --constified-enum-module one::Foo
+
+namespace one {
+  enum class Foo {
+    Variant1, Variant2,
+  };
+}
+
+class Bar {
+  one::Foo baz1;
+  one::Foo* baz2;
+};
diff --git a/bindgen-tests/tests/headers/constify-module-enums-types.hpp b/bindgen-tests/tests/headers/constify-module-enums-types.hpp
new file mode 100644
index 00000000..decf935a
--- /dev/null
+++ b/bindgen-tests/tests/headers/constify-module-enums-types.hpp
@@ -0,0 +1,78 @@
+// bindgen-flags: --constified-enum-module ".*"
+
+typedef enum foo {
+  THIS,
+  SHOULD_BE,
+  A_CONSTANT,
+  ALSO_THIS = 42,
+  AND_ALSO_THIS = 42,
+} foo;
+
+
+typedef enum {
+  Variant1, Variant2, Variant3,
+} anon_enum;
+
+
+namespace ns1 {
+  typedef enum {
+    THIS,
+    SHOULD_BE,
+    A_CONSTANT,
+    ALSO_THIS = 42,
+  } foo;
+}
+
+namespace ns2 {
+  enum class Foo {
+    Variant1,
+    Variant2,
+  };
+}
+
+typedef foo foo_alias1;
+typedef foo_alias1 foo_alias2;
+typedef foo_alias2 foo_alias3;
+
+typedef anon_enum anon_enum_alias1;
+typedef anon_enum_alias1 anon_enum_alias2;
+typedef anon_enum_alias2 anon_enum_alias3;
+
+typedef struct bar {
+  foo member1;
+  foo_alias1 member2;
+  foo_alias2 member3;
+  foo_alias3 member4;
+  ns1::foo member5;
+  ns2::Foo *member6;
+  anon_enum member7;
+  anon_enum_alias1 member8;
+  anon_enum_alias2 member9;
+  anon_enum_alias3 member10;
+} bar;
+
+class Baz {
+  ns2::Foo member1;
+};
+
+namespace one {
+  enum class Foo {
+    Variant1, Variant2,
+  };
+}
+
+class Bar {
+  one::Foo* baz;
+};
+
+foo *func1(foo arg1, foo *arg2, foo **arg3);
+foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3);
+
+template <class T>
+class Thing {
+  T thing;
+  T& get_thing();
+};
+
+foo func3(Thing<foo> arg1);
+foo func4(Thing< Thing<foo> > arg1);
diff --git a/bindgen-tests/tests/headers/constructor-tp.hpp b/bindgen-tests/tests/headers/constructor-tp.hpp
new file mode 100644
index 00000000..6e55ea78
--- /dev/null
+++ b/bindgen-tests/tests/headers/constructor-tp.hpp
@@ -0,0 +1,26 @@
+
+template<typename T>
+class Foo {
+public:
+  Foo();
+
+  void doBaz();
+};
+
+template<typename T>
+inline void
+Foo<T>::doBaz() {
+}
+
+class Bar {
+public:
+  Bar();
+};
+
+template<typename T>
+Foo<T>::Foo() {
+}
+
+inline
+Bar::Bar() {
+}
diff --git a/bindgen-tests/tests/headers/constructors.hpp b/bindgen-tests/tests/headers/constructors.hpp
new file mode 100644
index 00000000..d4174889
--- /dev/null
+++ b/bindgen-tests/tests/headers/constructors.hpp
@@ -0,0 +1,13 @@
+
+class TestOverload {
+  // This one shouldnt' be generated.
+  TestOverload();
+public:
+  TestOverload(int);
+  TestOverload(double);
+};
+
+class TestPublicNoArgs {
+public:
+  TestPublicNoArgs();
+};
diff --git a/bindgen-tests/tests/headers/constructors_1_33.hpp b/bindgen-tests/tests/headers/constructors_1_33.hpp
new file mode 100644
index 00000000..7c6262d4
--- /dev/null
+++ b/bindgen-tests/tests/headers/constructors_1_33.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --rust-target 1.33
+
+class TestOverload {
+  // This one shouldnt' be generated.
+  TestOverload();
+public:
+  /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
+  TestOverload(int);
+  /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
+  TestOverload(double);
+};
+
+class TestPublicNoArgs {
+public:
+  TestPublicNoArgs();
+};
diff --git a/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp b/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp
new file mode 100644
index 00000000..d354b0a2
--- /dev/null
+++ b/bindgen-tests/tests/headers/contains-vs-inherits-zero-sized.hpp
@@ -0,0 +1,21 @@
+/**
+ * This should get an `_address` byte.
+ */
+struct Empty {};
+
+/**
+ * This should not get an `_address` byte, so `sizeof(Inherits)` should be
+ * `1`.
+ */
+struct Inherits : public Empty {
+    bool b;
+};
+
+/**
+ * This should not get an `_address` byte, but contains `Empty` which *does* get
+ * one, so `sizeof(Contains)` should be `1 + 1`.
+ */
+struct Contains {
+    Empty empty;
+    bool b;
+};
diff --git a/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp b/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp
new file mode 100644
index 00000000..f5bbbf58
--- /dev/null
+++ b/bindgen-tests/tests/headers/convert-cpp-comment-to-rust.hpp
@@ -0,0 +1,14 @@
+// bindgen-flags: --no-layout-tests
+typedef unsigned mbedtls_mpi_uint;
+
+/**
+ * \brief          MPI structure
+ */
+typedef struct
+{
+    int s;                /*!<  integer sign      */
+    unsigned long n;      /*!<  total # of limbs  */
+    mbedtls_mpi_uint *p;  /*!<  pointer to limbs  */
+}
+mbedtls_mpi;
+
diff --git a/bindgen-tests/tests/headers/convert-floats.h b/bindgen-tests/tests/headers/convert-floats.h
new file mode 100644
index 00000000..08d9fe0b
--- /dev/null
+++ b/bindgen-tests/tests/headers/convert-floats.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --no-convert-floats
+
+struct foo {
+  float bar, baz;
+  double bazz;
+  long double* bazzz;
+  float _Complex complexFloat;
+  double _Complex complexDouble;
+};
diff --git a/bindgen-tests/tests/headers/core_ffi_c.h b/bindgen-tests/tests/headers/core_ffi_c.h
new file mode 100644
index 00000000..6df1e2f8
--- /dev/null
+++ b/bindgen-tests/tests/headers/core_ffi_c.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --use-core --rust-target 1.64 --no-convert-floats
+typedef char c_char;
+typedef double c_double;
+typedef float c_float;
+typedef int c_int;
+typedef long c_long;
+typedef long long c_longlong;
+typedef signed char c_schar;
+typedef short c_short;
+typedef unsigned char c_uchar;
+typedef unsigned int c_uint;
+typedef unsigned long c_ulong;
+typedef unsigned long long c_ulonglong;
+typedef unsigned short c_ushort;
diff --git a/bindgen-tests/tests/headers/cpp-empty-layout.hpp b/bindgen-tests/tests/headers/cpp-empty-layout.hpp
new file mode 100644
index 00000000..1fe02e89
--- /dev/null
+++ b/bindgen-tests/tests/headers/cpp-empty-layout.hpp
@@ -0,0 +1 @@
+struct Foo {};
diff --git a/bindgen-tests/tests/headers/crtp.hpp b/bindgen-tests/tests/headers/crtp.hpp
new file mode 100644
index 00000000..a5477c54
--- /dev/null
+++ b/bindgen-tests/tests/headers/crtp.hpp
@@ -0,0 +1,12 @@
+template<class T>
+class Base {};
+
+class Derived : public Base<Derived> {};
+
+template<class T>
+class BaseWithDestructor {
+  ~BaseWithDestructor();
+};
+
+class DerivedFromBaseWithDestructor :
+  public BaseWithDestructor<DerivedFromBaseWithDestructor> {};
diff --git a/bindgen-tests/tests/headers/ctypes-prefix-path.h b/bindgen-tests/tests/headers/ctypes-prefix-path.h
new file mode 100644
index 00000000..10e06f89
--- /dev/null
+++ b/bindgen-tests/tests/headers/ctypes-prefix-path.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --ctypes-prefix "libc::foo" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub mod foo { pub type c_int = i32; pub enum c_void {} } }" --rustified-enum ".*"
+struct foo {
+  int a, b;
+  void* bar;
+};
diff --git a/bindgen-tests/tests/headers/dash_language.h b/bindgen-tests/tests/headers/dash_language.h
new file mode 100644
index 00000000..4c8bb58d
--- /dev/null
+++ b/bindgen-tests/tests/headers/dash_language.h
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -x c++ --std=c++11
+
+template<typename T>
+struct Foo {
+  int bar;
+};
diff --git a/bindgen-tests/tests/headers/decl_extern_int_twice.h b/bindgen-tests/tests/headers/decl_extern_int_twice.h
new file mode 100644
index 00000000..06f80e87
--- /dev/null
+++ b/bindgen-tests/tests/headers/decl_extern_int_twice.h
@@ -0,0 +1,2 @@
+extern int foo;
+extern int foo;
diff --git a/bindgen-tests/tests/headers/decl_ptr_to_array.h b/bindgen-tests/tests/headers/decl_ptr_to_array.h
new file mode 100644
index 00000000..3222cbd4
--- /dev/null
+++ b/bindgen-tests/tests/headers/decl_ptr_to_array.h
@@ -0,0 +1 @@
+int (*foo)[1];
diff --git a/bindgen-tests/tests/headers/default-enum-style-constified-module.h b/bindgen-tests/tests/headers/default-enum-style-constified-module.h
new file mode 100644
index 00000000..a5ba6531
--- /dev/null
+++ b/bindgen-tests/tests/headers/default-enum-style-constified-module.h
@@ -0,0 +1,4 @@
+// bindgen-flags: --default-enum-style moduleconsts
+
+typedef enum { bar, baz, blap } Foo;
+void func(Foo x);
diff --git a/bindgen-tests/tests/headers/default-macro-constant-type-signed.h b/bindgen-tests/tests/headers/default-macro-constant-type-signed.h
new file mode 100644
index 00000000..da3f1344
--- /dev/null
+++ b/bindgen-tests/tests/headers/default-macro-constant-type-signed.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-macro-constant-type signed
+// All values are i32 if they fit; otherwise i64.
+#include "default-macro-constant-type.h"
diff --git a/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h b/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h
new file mode 100644
index 00000000..1078e852
--- /dev/null
+++ b/bindgen-tests/tests/headers/default-macro-constant-type-unsigned.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-macro-constant-type unsigned
+// Negative values are i32 or i64; others are u32 or u64.
+#include "default-macro-constant-type.h"
diff --git a/bindgen-tests/tests/headers/default-macro-constant-type.h b/bindgen-tests/tests/headers/default-macro-constant-type.h
new file mode 100644
index 00000000..a863362c
--- /dev/null
+++ b/bindgen-tests/tests/headers/default-macro-constant-type.h
@@ -0,0 +1,52 @@
+// Test default of --default-macro-constant-type
+// Negative values are i32 or i64; others are u32 or u64.
+
+#define N0 0
+#define N1 1ULL
+#define N2 2ULL
+
+#define N_1 (-1LL)
+#define N_2 (-2LL)
+
+#define MAX_U16  0xFFFFULL
+#define MAX_I16 (0x8000ULL - 1)
+
+#define MAX_I16_Plus1 (MAX_I16 + 1)
+#define MAX_U16_Plus1 (MAX_U16 + 1)
+
+#define MAX_I16_Minus1 (MAX_I16 - 1)
+#define MAX_U16_Minus1 (MAX_U16 - 1)
+
+#define MIN_U16 0
+#define MIN_I16 (- (1ULL<<15))
+
+#define MIN_U16_Plus1 (MIN_U16 + 1)
+#define MIN_I16_Plus1 (MIN_I16 + 1)
+
+#define MIN_U16_Minus1 (MIN_U16 - 1)
+#define MIN_I16_Minus1 (MIN_I16 - 1)
+
+#define MAX_U32  0xFFFFFFFFULL
+#define MAX_I32 (0x80000000ULL - 1)
+
+#define MAX_I32_Plus1 (MAX_I32 + 1)
+#define MAX_U32_Plus1 (MAX_U32 + 1)
+
+#define MAX_I32_Minus1 (MAX_I32 - 1)
+#define MAX_U32_Minus1 (MAX_U32 - 1)
+
+#define MIN_U32 0
+#define MIN_I32 (- (1ULL<<31))
+
+#define MIN_U32_Plus1 (MIN_U32 + 1)
+#define MIN_I32_Plus1 (MIN_I32 + 1)
+
+#define MIN_U32_Minus1 (MIN_U32 - 1)
+#define MIN_I32_Minus1 (MIN_I32 - 1)
+
+#define LONG12    123456789012ULL
+#define LONG_12 (- 123456789012ULL)
+
+// Function parameter and return types are not affected.
+int foo(int, signed, unsigned, char, unsigned char, signed char);
+long bar(long, long long);
diff --git a/bindgen-tests/tests/headers/default-template-parameter.hpp b/bindgen-tests/tests/headers/default-template-parameter.hpp
new file mode 100644
index 00000000..4deed834
--- /dev/null
+++ b/bindgen-tests/tests/headers/default-template-parameter.hpp
@@ -0,0 +1,7 @@
+template <typename T, typename U = int>
+struct Foo {
+    T t;
+    U u;
+};
+
+static Foo<bool> bar;
diff --git a/bindgen-tests/tests/headers/deleted-function.hpp b/bindgen-tests/tests/headers/deleted-function.hpp
new file mode 100644
index 00000000..61848a0a
--- /dev/null
+++ b/bindgen-tests/tests/headers/deleted-function.hpp
@@ -0,0 +1,35 @@
+// bindgen-flags: --generate-inline-functions -- -std=c++11
+
+class A {
+public:
+      // Deleted function should not get a binding.
+      void deleted() = delete;
+
+      // Inline functions should get bindings, whether they are defined inline
+      // (in the class) or out of line.
+      inline void inline_definition() {}
+      inline void out_of_line_definition();
+
+      // TODO: This is an edge case that we get wrong: An inline function
+      // without a definition in the same translation unit should still get a
+      // binding. We currently can't distinguish this case from a deleted member
+      // function because libclang doesn't provide a direct way to query for
+      // deleted member functions. This seems acceptable, however, as an inline
+      // function without a definition in the same translation unit is unlikely
+      // to be useful in practice.
+      inline void inline_without_definition();
+};
+
+void A::out_of_line_definition() {}
+
+class B {
+public:
+     // Deleted copy constructor should not get a binding.
+     B(B&) = delete;
+};
+
+class C {
+public:
+     // Defaulted copy constructor should get a binding.
+     C(C&) = default;
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp b/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp
new file mode 100644
index 00000000..ea9d801f
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-bitfield-method-same-name.hpp
@@ -0,0 +1,13 @@
+// bindgen-flags: --with-derive-partialeq --impl-partialeq --impl-debug --rust-target 1.40
+
+/// Because this struct have array larger than 32 items 
+/// and --with-derive-partialeq --impl-partialeq --impl-debug is provided, 
+/// this struct should manually implement `Debug` and `PartialEq`.
+struct Foo {
+    int large[33];
+    char type_ : 3;
+    unsigned : 8;
+    char type();
+    void set_type_(char c);
+    void set_type(char c);
+};
diff --git a/bindgen-tests/tests/headers/derive-clone.h b/bindgen-tests/tests/headers/derive-clone.h
new file mode 100644
index 00000000..aacbcaf8
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-clone.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.40
+//
+
+/// This struct should derive `Clone`.
+struct ShouldDeriveClone {
+    int large[33];
+};
diff --git a/bindgen-tests/tests/headers/derive-clone_1_0.h b/bindgen-tests/tests/headers/derive-clone_1_0.h
new file mode 100644
index 00000000..34ef40ae
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-clone_1_0.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.0
+
+/// Since builtin `Clone` impls were introduced in Rust 1.21 this struct 
+/// should impl `Clone` "manually".
+struct ShouldImplClone {
+    int large[33];
+};
diff --git a/bindgen-tests/tests/headers/derive-custom.h b/bindgen-tests/tests/headers/derive-custom.h
new file mode 100644
index 00000000..8c57278c
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-custom.h
@@ -0,0 +1,28 @@
+// bindgen-flags: --no-derive-debug --no-derive-copy --default-enum-style rust --no-layout-tests
+
+/** <div rustbindgen derive="Debug"></div> */
+struct my_type;
+
+/** <div rustbindgen derive="Clone"></div> */
+struct my_type;
+
+struct my_type {
+    int a;
+};
+
+/**
+ * <div rustbindgen derive="Debug"></div>
+ * <div rustbindgen derive="Clone"></div>
+ */
+struct my_type2;
+
+struct my_type2 {
+    unsigned a;
+};
+
+/**
+ * <div rustbindgen derive="Debug" derive="Clone"></div>
+ */
+struct my_type3 {
+    unsigned long a;
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp b/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp
new file mode 100644
index 00000000..2073cc2a
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-bitfield-core.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --impl-debug --use-core --raw-line "extern crate core;" --rust-target 1.40
+
+class C {
+  bool a: 1;
+  bool b: 7;
+  int large_array[50];
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-bitfield.hpp b/bindgen-tests/tests/headers/derive-debug-bitfield.hpp
new file mode 100644
index 00000000..b6891905
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-bitfield.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --impl-debug --rust-target 1.40
+
+class C {
+  bool a: 1;
+  bool b: 7;
+  int large_array[50];
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp b/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp
new file mode 100644
index 00000000..147097fb
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-function-pointer.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --impl-debug --rust-target 1.40
+
+class Nice {
+  typedef void (*Function) (int data);
+  Function pointer;
+  int large_array[34];
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-generic.hpp b/bindgen-tests/tests/headers/derive-debug-generic.hpp
new file mode 100644
index 00000000..50122faf
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-generic.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --impl-debug --rust-target 1.40
+
+template<typename T>
+class Generic {
+  T t[40];
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-mangle-name.h b/bindgen-tests/tests/headers/derive-debug-mangle-name.h
new file mode 100644
index 00000000..1cd7db63
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-mangle-name.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --impl-debug
+struct perf_event_attr {
+
+    /*
+     * Major type: hardware/software/tracepoint/etc.
+     */
+    unsigned int			type;
+
+    float a;
+    union {
+        int b;
+        int c;
+    };
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp b/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp
new file mode 100644
index 00000000..0c70fcc5
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-opaque-template-instantiation.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --impl-debug --rust-target 1.40
+
+// This type is opaque because the second template parameter
+// is a non-type template parameter
+template<typename T, int N>
+class Opaque {
+  T array[N];
+};
+
+class Instance {
+  Opaque<int, 50> val;
+};
diff --git a/bindgen-tests/tests/headers/derive-debug-opaque.hpp b/bindgen-tests/tests/headers/derive-debug-opaque.hpp
new file mode 100644
index 00000000..715d3c89
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-debug-opaque.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --opaque-type "Opaque" --impl-debug --rust-target 1.40
+
+class Opaque {
+  int i;
+  int not_debug[40];
+};
+
+class OpaqueUser {
+  Opaque opaque;
+};
diff --git a/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp
new file mode 100644
index 00000000..20d938cc
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-default-and-blocklist.hpp
@@ -0,0 +1,14 @@
+// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
+
+// Note that we do not explicitly provide the `--with-derive-default` flag
+// above, since it is added by the test runner implicitly.
+
+struct BlocklistMe {};
+
+/**
+ * Because this type contains a blocklisted type, it should not derive
+ * Default. Instead, we should emit a `mem::zeroed` implementation.
+ */
+struct ShouldNotDeriveDefault {
+    BlocklistMe a;
+};
diff --git a/bindgen-tests/tests/headers/derive-fn-ptr.h b/bindgen-tests/tests/headers/derive-fn-ptr.h
new file mode 100644
index 00000000..93b980e6
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-fn-ptr.h
@@ -0,0 +1,18 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+typedef void (*my_fun_t)(int, int, int, int,
+                         int, int, int, int,
+                         int, int, int, int,
+                         int, int, int, int);
+
+struct Foo {
+  my_fun_t callback;
+};
+
+typedef void (*my_fun2_t)(int, int, int, int,
+                         int, int, int, int,
+                         int, int, int, int);
+
+struct Bar {
+  my_fun2_t callback;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp
new file mode 100644
index 00000000..51a3372f
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-and-blocklist.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --with-derive-hash --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
+
+struct BlocklistMe {};
+
+/**
+ * Because this type contains a blocklisted type, it should not derive Hash.
+ */
+struct ShouldNotDeriveHash {
+    BlocklistMe a;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp b/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp
new file mode 100644
index 00000000..4e20e392
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-blocklisting.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq --allowlist-type 'Allowlisted.*' --blocklist-type Blocklisted --raw-line "#[repr(C)] #[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)] pub struct Blocklisted<T> {t: T, pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>> }"
+//
+template <class T>
+struct Blocklisted {
+    T t;
+};
+
+/// This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type,
+/// causing us to conservatively avoid deriving hash/Eq/PartialEq for it.
+struct AllowlistedOne {
+    Blocklisted<int> a;
+};
+
+/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type.
+struct AllowlistedTwo {
+    Blocklisted<float> b;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h b/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h
new file mode 100644
index 00000000..dc6e7329
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-struct-with-anon-struct-float.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
+//
+/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
+struct foo {
+    struct {
+        float a;
+        float b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h b/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h
new file mode 100644
index 00000000..2294b1de
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-struct-with-float-array.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
+//
+/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
+struct foo {
+    float bar[3];
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h b/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h
new file mode 100644
index 00000000..65c009db
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-struct-with-incomplete-array.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord
+// 
+struct test {
+    int a;
+    char zero_length_array[0];
+};
+
+struct test2 {
+    int a;
+    char incomplete_array[];
+};
+
+struct test3 {
+    int a;
+    char zero_length_array[0];
+    char incomplete_array[];
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h b/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h
new file mode 100644
index 00000000..a3ce9cc5
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-struct-with-pointer.h
@@ -0,0 +1,18 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
+//
+/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq
+struct ConstPtrMutObj {
+    int* const bar;
+};
+
+struct MutPtrMutObj {
+    int* bar;
+};
+
+struct MutPtrConstObj {
+    const int* bar;
+};
+
+struct ConstPtrConstObj {
+    const int* const bar;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp b/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp
new file mode 100644
index 00000000..253fb9ce
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-template-def-float.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
+//
+/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd.
+template <typename T>
+struct foo {
+    T data;
+    float b;
+};
diff --git a/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp b/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp
new file mode 100644
index 00000000..0a4fc0c1
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-hash-template-inst-float.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
+//
+/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq
+template <typename T>
+struct foo {
+    T data;
+};
+
+/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int
+struct IntStr {
+    foo<int> a;
+};
+
+/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd
+struct FloatStr {
+    foo<float> a;
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp b/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp
new file mode 100644
index 00000000..953d0677
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-and-blocklist.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --with-derive-partialeq --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
+
+struct BlocklistMe {};
+
+/**
+ * Because this type contains a blocklisted type, it should not derive
+ * PartialEq.
+ */
+struct ShouldNotDerivePartialEq {
+    BlocklistMe a;
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-anonfield.h b/bindgen-tests/tests/headers/derive-partialeq-anonfield.h
new file mode 100644
index 00000000..3bbe2bc3
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-anonfield.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
+
+struct rte_mbuf {
+    union {};
+} __attribute__((__aligned__(64)));
diff --git a/bindgen-tests/tests/headers/derive-partialeq-base.hpp b/bindgen-tests/tests/headers/derive-partialeq-base.hpp
new file mode 100644
index 00000000..2a57dca4
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-base.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-partialeq --impl-partialeq --rust-target 1.40
+
+class Base {
+    int large[33];
+};
+
+class ShouldDerivePartialEq: Base {
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp b/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp
new file mode 100644
index 00000000..f6dd82e5
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-bitfield.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-partialeq --impl-partialeq --rust-target 1.40
+
+class C {
+    bool a: 1;
+    bool b: 7;
+    int large_array[50];
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-core.h b/bindgen-tests/tests/headers/derive-partialeq-core.h
new file mode 100644
index 00000000..18eed8b3
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-core.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-partialeq --impl-partialeq --use-core --raw-line "extern crate core;" --rust-target 1.40
+
+struct C {
+    int large_array[420];
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp b/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp
new file mode 100644
index 00000000..ce971e07
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-pointer.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct a;
+class Bar {
+  a *b;
+};
+struct c {
+  union {};
+};
+struct a {
+  c d;
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-union.hpp b/bindgen-tests/tests/headers/derive-partialeq-union.hpp
new file mode 100644
index 00000000..e2081a01
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-union.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-partialeq --impl-partialeq
+
+/// Deriving PartialEq for rust unions is not supported.
+union ShouldNotDerivePartialEq {
+    char a;
+    int b;
+};
diff --git a/bindgen-tests/tests/headers/derive-partialeq-union_1_0.hpp b/bindgen-tests/tests/headers/derive-partialeq-union_1_0.hpp
new file mode 100644
index 00000000..d546d77b
--- /dev/null
+++ b/bindgen-tests/tests/headers/derive-partialeq-union_1_0.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-partialeq --impl-partialeq
+
+/// This should manually derive PartialEq.
+union ShouldDerivePartialEq {
+    char a[150];
+    int b;
+};
diff --git a/bindgen-tests/tests/headers/disable-namespacing.hpp b/bindgen-tests/tests/headers/disable-namespacing.hpp
new file mode 100644
index 00000000..11191361
--- /dev/null
+++ b/bindgen-tests/tests/headers/disable-namespacing.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --disable-name-namespacing
+
+namespace foo {
+namespace bar {
+
+typedef int Baz;
+
+}
+}
diff --git a/bindgen-tests/tests/headers/disable-nested-struct-naming.h b/bindgen-tests/tests/headers/disable-nested-struct-naming.h
new file mode 100644
index 00000000..0e4fccb6
--- /dev/null
+++ b/bindgen-tests/tests/headers/disable-nested-struct-naming.h
@@ -0,0 +1,24 @@
+// bindgen-flags: --disable-nested-struct-naming
+
+struct foo {
+    struct bar1 {
+        int x1;
+        struct {
+            int x2;
+            struct {
+                int x3;
+                struct bar4 {
+                    int x4;
+                } b4;
+            } b3;
+        } b2;
+    } b1;
+};
+
+struct {
+    struct {
+        struct baz {
+            int x;
+        } b;
+    } anon2;
+} anon1;
diff --git a/bindgen-tests/tests/headers/disable-untagged-union.hpp b/bindgen-tests/tests/headers/disable-untagged-union.hpp
new file mode 100644
index 00000000..44623181
--- /dev/null
+++ b/bindgen-tests/tests/headers/disable-untagged-union.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --disable-untagged-union
+
+union Foo {
+  int bar;
+  unsigned int baz;
+};
diff --git a/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h b/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h
new file mode 100644
index 00000000..7c500cb0
--- /dev/null
+++ b/bindgen-tests/tests/headers/divide-by-zero-in-struct-layout.h
@@ -0,0 +1,22 @@
+// bindgen-flags: --no-layout-tests
+//
+// Unfortunately, we aren't translating the third struct correctly yet. But we
+// definitely shouldn't divide-by-zero when we see it...
+//
+// Once we fix #981 we should remove the `--no-layout-tests`.
+
+struct WithBitfield {
+    unsigned : 7;
+    unsigned a;
+};
+
+struct WithBitfieldAndAttrPacked {
+    unsigned : 7;
+    unsigned a;
+} __attribute__((packed));
+
+#pragma pack(1)
+struct WithBitfieldAndPacked {
+    unsigned : 7;
+    unsigned a;
+};
diff --git a/bindgen-tests/tests/headers/do-not-derive-copy.hpp b/bindgen-tests/tests/headers/do-not-derive-copy.hpp
new file mode 100644
index 00000000..18c26135
--- /dev/null
+++ b/bindgen-tests/tests/headers/do-not-derive-copy.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --no-derive-copy
+
+class WouldBeCopyButWeAreNotDerivingCopy {
+    int x;
+};
diff --git a/bindgen-tests/tests/headers/doggo-or-null.hpp b/bindgen-tests/tests/headers/doggo-or-null.hpp
new file mode 100644
index 00000000..9146e189
--- /dev/null
+++ b/bindgen-tests/tests/headers/doggo-or-null.hpp
@@ -0,0 +1,20 @@
+// bindgen-flags: --opaque-type DoggoOrNull --with-derive-partialeq --with-derive-hash -- -std=c++14
+
+class Doggo {
+    int x;
+};
+
+class Null {};
+
+/**
+ * This type is an opaque union. Unions can't derive anything interesting like
+ * Debug or Default, even if their layout can, because it would require knowing
+ * which variant is in use. Opaque unions still end up as a `union` in the Rust
+ * bindings, but they just have one variant. Even so, can't derive. We should
+ * probably emit an opaque struct for opaque unions... but until then, we have
+ * this test to make sure that opaque unions don't derive and still compile.
+ */
+union DoggoOrNull {
+    Doggo doggo;
+    Null none;
+};
diff --git a/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h b/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h
new file mode 100644
index 00000000..2b6fb93a
--- /dev/null
+++ b/bindgen-tests/tests/headers/dupe-enum-variant-in-namespace.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --rustified-enum ".*" --enable-cxx-namespaces -- -x c++ -std=c++11
+
+namespace foo {
+  enum class Bar : unsigned {
+    Foo = 0,
+    Foo1 = 0,
+    Foo2,
+    Foo3 = Foo2,
+  };
+}
diff --git a/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp b/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp
new file mode 100644
index 00000000..7c8888de
--- /dev/null
+++ b/bindgen-tests/tests/headers/duplicated-namespaces-definitions.hpp
@@ -0,0 +1,18 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+namespace foo {
+  class Bar;
+}
+
+namespace bar {
+  struct Foo {
+    foo::Bar* ptr;
+  };
+};
+
+namespace foo {
+  class Bar {
+    int foo;
+    bool baz;
+  };
+}
diff --git a/bindgen-tests/tests/headers/duplicated-namespaces.hpp b/bindgen-tests/tests/headers/duplicated-namespaces.hpp
new file mode 100644
index 00000000..10e1933f
--- /dev/null
+++ b/bindgen-tests/tests/headers/duplicated-namespaces.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+namespace std {}
+namespace std {}
diff --git a/bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp b/bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp
new file mode 100644
index 00000000..bb343641
--- /dev/null
+++ b/bindgen-tests/tests/headers/duplicated_constants_in_ns.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --enable-cxx-namespaces
+namespace foo {
+    const int FOO = 4;
+}
+namespace bar {
+    const int FOO = 5;
+}
diff --git a/bindgen-tests/tests/headers/dynamic_loading_attributes.h b/bindgen-tests/tests/headers/dynamic_loading_attributes.h
new file mode 100644
index 00000000..e2ca62b1
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_attributes.h
@@ -0,0 +1,11 @@
+// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all --enable-function-attribute-detection
+/**
+ * @brief A function
+ * 
+ * @param x 
+ * @param y 
+ * @return int 
+ */
+__attribute__((warn_unused_result))
+int foo(int x, int y);
+int baz() ;
diff --git a/bindgen-tests/tests/headers/dynamic_loading_required.h b/bindgen-tests/tests/headers/dynamic_loading_required.h
new file mode 100644
index 00000000..f9861e84
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_required.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all
+
+int foo(int x, int y);
+int bar(void *x);
+int baz();
diff --git a/bindgen-tests/tests/headers/dynamic_loading_simple.h b/bindgen-tests/tests/headers/dynamic_loading_simple.h
new file mode 100644
index 00000000..f418851b
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_simple.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --dynamic-loading TestLib
+
+int foo(int x, int y);
+int bar(void *x);
+int baz();
diff --git a/bindgen-tests/tests/headers/dynamic_loading_template.hpp b/bindgen-tests/tests/headers/dynamic_loading_template.hpp
new file mode 100644
index 00000000..27f04c8e
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_template.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --dynamic-loading TestLib
+
+template<typename T>
+T foo(T x);
+
+template<>
+int foo(int x);
+
+template<>
+float foo(float x);
diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp
new file mode 100644
index 00000000..995fbdd5
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_with_allowlist.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --dynamic-loading TestLib --allowlist-function baz --allowlist-function foo --allowlist-function bazz
+
+class X {
+  int _x;
+
+ public:
+  X(int x);
+
+  void some_function();
+  void some_other_function();
+};
+
+int foo(void *x);
+int bar(void *x);
+int baz(void *x);
+int bazz(int, ...);
diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp
new file mode 100644
index 00000000..81266d1f
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_with_blocklist.hpp
@@ -0,0 +1,15 @@
+// bindgen-flags: --dynamic-loading TestLib --blocklist-function baz
+
+class X {
+  int _x;
+
+ public:
+  X(int x);
+
+  void some_function();
+  void some_other_function();
+};
+
+int foo(void *x);
+int bar(void *x);
+int baz(void *x);
diff --git a/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp b/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp
new file mode 100644
index 00000000..632db4d0
--- /dev/null
+++ b/bindgen-tests/tests/headers/dynamic_loading_with_class.hpp
@@ -0,0 +1,15 @@
+// bindgen-flags: --dynamic-loading TestLib
+
+int foo(void *x);
+
+class A {
+  int _x;
+
+ public:
+  A(int x);
+
+  void some_function();
+  void some_other_function();
+};
+
+void bar();
diff --git a/bindgen-tests/tests/headers/elaborated.hpp b/bindgen-tests/tests/headers/elaborated.hpp
new file mode 100644
index 00000000..4bfbff23
--- /dev/null
+++ b/bindgen-tests/tests/headers/elaborated.hpp
@@ -0,0 +1,5 @@
+namespace whatever {
+  typedef int whatever_t;
+}
+
+void something(const whatever::whatever_t *wat);
diff --git a/bindgen-tests/tests/headers/empty-enum.h b/bindgen-tests/tests/headers/empty-enum.h
new file mode 100644
index 00000000..8b7502e6
--- /dev/null
+++ b/bindgen-tests/tests/headers/empty-enum.h
@@ -0,0 +1,15 @@
+// bindgen-flags: --rustified-enum '.*Rustified.*' --constified-enum-module '.*Module.*' -- -x c++ --std=c++14
+
+// Constified is default, so no flag for that.
+
+enum EmptyConstified {};
+enum EmptyRustified {};
+enum EmptyModule {};
+
+enum class EmptyClassRustified : char {};
+enum class EmptyClassConstified : char {};
+enum class EmptyClassModule : char {};
+
+enum class ForwardClassRustified : char;
+enum class ForwardClassConstified : char;
+enum class ForwardClassModule : char;
diff --git a/bindgen-tests/tests/headers/empty-union.hpp b/bindgen-tests/tests/headers/empty-union.hpp
new file mode 100644
index 00000000..3b067e39
--- /dev/null
+++ b/bindgen-tests/tests/headers/empty-union.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --opaque-type "*"
+
+template <int> class a {
+  union {};
+};
diff --git a/bindgen-tests/tests/headers/empty_template_param_name.hpp b/bindgen-tests/tests/headers/empty_template_param_name.hpp
new file mode 100644
index 00000000..ab2aab92
--- /dev/null
+++ b/bindgen-tests/tests/headers/empty_template_param_name.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+// bindgen-flags: -- -std=c++11
+
+template<typename...> using __void_t = void;
+
+template<typename _Iterator, typename = __void_t<>>
+  struct __iterator_traits { };
diff --git a/bindgen-tests/tests/headers/enum-default-bitfield.h b/bindgen-tests/tests/headers/enum-default-bitfield.h
new file mode 100644
index 00000000..5f3cb954
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-default-bitfield.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-enum-style=bitfield --constified-enum-module=Neg
+
+#include "enum.h"
diff --git a/bindgen-tests/tests/headers/enum-default-consts.h b/bindgen-tests/tests/headers/enum-default-consts.h
new file mode 100644
index 00000000..233d2718
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-default-consts.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-enum-style=consts --constified-enum-module=Neg
+
+#include "enum.h"
diff --git a/bindgen-tests/tests/headers/enum-default-module.h b/bindgen-tests/tests/headers/enum-default-module.h
new file mode 100644
index 00000000..8c2ec1bc
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-default-module.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-enum-style=moduleconsts --constified-enum-module=Neg
+
+#include "enum.h"
diff --git a/bindgen-tests/tests/headers/enum-default-rust.h b/bindgen-tests/tests/headers/enum-default-rust.h
new file mode 100644
index 00000000..7fd2999f
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-default-rust.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --default-enum-style=rust --constified-enum-module=Neg
+
+#include "enum.h"
diff --git a/bindgen-tests/tests/headers/enum-doc-bitfield.h b/bindgen-tests/tests/headers/enum-doc-bitfield.h
new file mode 100644
index 00000000..5bbd7287
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-doc-bitfield.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --bitfield-enum B
+
+#include "enum-doc.h"
diff --git a/bindgen-tests/tests/headers/enum-doc-mod.h b/bindgen-tests/tests/headers/enum-doc-mod.h
new file mode 100644
index 00000000..e5217451
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-doc-mod.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --constified-enum-module B
+
+#include "enum-doc.h"
diff --git a/bindgen-tests/tests/headers/enum-doc-rusty.h b/bindgen-tests/tests/headers/enum-doc-rusty.h
new file mode 100644
index 00000000..35622d2b
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-doc-rusty.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --rustified-enum B
+
+#include "enum-doc.h"
diff --git a/bindgen-tests/tests/headers/enum-doc.h b/bindgen-tests/tests/headers/enum-doc.h
new file mode 100644
index 00000000..58e2c69e
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-doc.h
@@ -0,0 +1,18 @@
+/** Document enum */
+enum B {
+    /// Document field with three slashes
+    VAR_A = 0,
+    /** Document field with preceeding star */
+    VAR_B = 1,
+    /*! Document field with preceeding exclamation */
+    VAR_C = 2,
+    VAR_D = 3, /**< Document field with following star */
+    VAR_E = 4, /*!< Document field with following exclamation */
+    /**
+     * Document field with preceeding star, with a loong long multiline
+     * comment.
+     *
+     * Very interesting documentation, definitely.
+     */
+    VAR_F,
+};
diff --git a/bindgen-tests/tests/headers/enum-no-debug-rust.h b/bindgen-tests/tests/headers/enum-no-debug-rust.h
new file mode 100644
index 00000000..7cb73980
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-no-debug-rust.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --no-derive-debug --default-enum-style=rust --constified-enum-module=Neg
+
+#include "enum.h"
diff --git a/bindgen-tests/tests/headers/enum-translate-type.hpp b/bindgen-tests/tests/headers/enum-translate-type.hpp
new file mode 100644
index 00000000..8d856261
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-translate-type.hpp
@@ -0,0 +1,14 @@
+// bindgen-flags: --translate-enum-integer-types -- -std=c++11 -Wno-narrowing
+
+enum my_enum1 {
+    A = 0,
+};
+enum my_enum2 {
+    B = -1,
+};
+enum my_enum3: short {
+    C = 0,
+};
+enum my_enum4: unsigned char {
+    D = -1,
+};
diff --git a/bindgen-tests/tests/headers/enum-undefault.h b/bindgen-tests/tests/headers/enum-undefault.h
new file mode 100644
index 00000000..7150be0d
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-undefault.h
@@ -0,0 +1,11 @@
+// bindgen-flags: --default-enum-style=rust --constified-enum=Neg
+
+enum Foo {
+    Bar = 0,
+    Qux
+};
+
+enum Neg {
+    MinusOne = -1,
+    One = 1,
+};
diff --git a/bindgen-tests/tests/headers/enum-variant-replaces.h b/bindgen-tests/tests/headers/enum-variant-replaces.h
new file mode 100644
index 00000000..45eb4d7a
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum-variant-replaces.h
@@ -0,0 +1,34 @@
+
+/** Type for a OGR error */
+typedef enum
+{
+    OGRERR_NONE,                       /**< Success */
+    OGRERR_NOT_ENOUGH_DATA,            /**< Not enough data to deserialize */
+    OGRERR_NOT_ENOUGH_MEMORY,          /**< Not enough memory */
+    OGRERR_UNSUPPORTED_GEOMETRY_TYPE,  /**< Unsupported geometry type */
+    OGRERR_UNSUPPORTED_OPERATION,      /**< Unsupported operation */
+    OGRERR_CORRUPT_DATA,               /**< Corrupt data */
+    OGRERR_FAILURE,                    /**< Failure */
+    OGRERR_UNSUPPORTED_SRS,            /**< Unsupported SRS */
+    OGRERR_INVALID_HANDLE,             /**< Invalid handle */
+    OGRERR_NON_EXISTING_FEATURE        /**< Non existing feature. Added in GDAL 2.0 */
+} OGRErr;
+
+/**
+ * <div rustbindgen replaces="OGRErr"></div>
+ */
+typedef enum
+{
+    /**
+     * <div rustbindgen replaces="PASS"></div>
+     *
+     * Should see PASS below.
+     */
+    FAIL,
+    /**
+     * <div rustbindgen replaces="OGRERR_NONE"></div>
+     *
+     * Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below.
+     */
+    CUSTOM_OGRERR_NONE
+} StrictOGRErr;
diff --git a/bindgen-tests/tests/headers/enum.h b/bindgen-tests/tests/headers/enum.h
new file mode 100644
index 00000000..0147433e
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum.h
@@ -0,0 +1,31 @@
+// A few tests for enum-related issues that should be tested with all the enum
+// representations.
+
+struct foo {
+  enum {
+    FOO_A,
+    FOO_B,
+  } member;
+};
+
+enum Foo {
+    Bar = 0,
+    Qux
+};
+
+enum Neg {
+    MinusOne = -1,
+    One = 1,
+};
+
+/** <div rustbindgen nodebug></div> */
+enum NoDebug {
+    NoDebug1,
+    NoDebug2,
+};
+
+/** <div rustbindgen derive="Debug"></div> */
+enum Debug {
+    Debug1,
+    Debug2,
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/enum_alias.hpp b/bindgen-tests/tests/headers/enum_alias.hpp
new file mode 100644
index 00000000..8ddb25c3
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_alias.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11
+
+typedef unsigned char uint8_t;
+
+enum Bar : uint8_t {
+  VAL
+};
diff --git a/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp b/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp
new file mode 100644
index 00000000..659a8bd1
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_and_vtable_mangling.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum {
+    match,
+    whatever_else,
+};
+
+class C {
+    int i;
+public:
+    virtual void match();
+};
diff --git a/bindgen-tests/tests/headers/enum_dupe.h b/bindgen-tests/tests/headers/enum_dupe.h
new file mode 100644
index 00000000..b8d9689a
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_dupe.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum Foo {
+    Bar = 1,
+    Dupe = 1
+};
diff --git a/bindgen-tests/tests/headers/enum_explicit_type.hpp b/bindgen-tests/tests/headers/enum_explicit_type.hpp
new file mode 100644
index 00000000..38e636e6
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_explicit_type.hpp
@@ -0,0 +1,42 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11
+
+enum Foo: unsigned char {
+    Bar = 0,
+    Qux
+};
+
+enum Neg: signed char {
+    MinusOne = -1,
+    One = 1,
+};
+
+enum Bigger: unsigned short {
+    Much = 255,
+    Larger
+};
+
+enum MuchLong: long {
+    MuchLow = -4294967296,
+};
+
+enum MuchLongLong: long long {
+    I64_MIN = 1ll << 63,
+};
+
+enum MuchULongLong: unsigned long long {
+    MuchHigh = 4294967296,
+};
+
+enum BoolEnumsAreFun: bool {
+    Value = true,
+};
+
+using MyType = bool;
+enum BoolEnumsAreFun2: MyType {
+    Value2 = true,
+};
+
+enum : unsigned char {
+    AnonymousVariantOne,
+    AnonymousVariantTwo,
+};
diff --git a/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp b/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp
new file mode 100644
index 00000000..e1ecf6fa
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_explicit_type_constants.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]' -- -std=c++11 
+//
+// This test is much like enum_explicit_type, but without --rustified-enum.
+
+#include "enum_explicit_type.hpp"
diff --git a/bindgen-tests/tests/headers/enum_in_template.hpp b/bindgen-tests/tests/headers/enum_in_template.hpp
new file mode 100644
index 00000000..41c017c4
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_in_template.hpp
@@ -0,0 +1,10 @@
+
+template <class T>
+class Foo
+{
+    enum Bar
+    {
+        A,
+        B
+    };
+};
diff --git a/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp b/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp
new file mode 100644
index 00000000..87290ece
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_in_template_with_typedef.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11
+
+namespace std {
+  template <typename Char> class fbstring_core;
+}
+
+typedef unsigned char uint8_t;
+namespace std {
+  template <typename Char> class fbstring_core {
+    typedef uint8_t category_type;
+    enum Category : category_type {
+      Foo = 1,
+      Bar = 4,
+    };
+  };
+}
diff --git a/bindgen-tests/tests/headers/enum_negative.h b/bindgen-tests/tests/headers/enum_negative.h
new file mode 100644
index 00000000..0fa0df97
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_negative.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum Foo {
+    Bar = -2,
+    Qux = 1,
+};
diff --git a/bindgen-tests/tests/headers/enum_packed.h b/bindgen-tests/tests/headers/enum_packed.h
new file mode 100644
index 00000000..cc70c816
--- /dev/null
+++ b/bindgen-tests/tests/headers/enum_packed.h
@@ -0,0 +1,16 @@
+// bindgen-flags: --rustified-enum ".*"
+
+enum __attribute__((packed)) Foo {
+    Bar = 0,
+    Qux
+};
+
+enum __attribute__((packed)) Neg {
+    MinusOne = -1,
+    One = 1,
+};
+
+enum __attribute__((packed)) Bigger {
+    Much = 255,
+    Larger
+};
diff --git a/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h b/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
new file mode 100644
index 00000000..4c342c0e
--- /dev/null
+++ b/bindgen-tests/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --raw-line "#![allow(overflowing_literals)]"
+
+typedef unsigned int uint32_t;
+
+uint32_t a = 18446744073709551611;
diff --git a/bindgen-tests/tests/headers/eval-value-dependent.hpp b/bindgen-tests/tests/headers/eval-value-dependent.hpp
new file mode 100644
index 00000000..0f4dc6ab
--- /dev/null
+++ b/bindgen-tests/tests/headers/eval-value-dependent.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -std=c++11
+
+template <typename d> class e {
+  using f = d;
+  static const auto g = alignof(f);
+};
diff --git a/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp b/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp
new file mode 100644
index 00000000..0a9e51c1
--- /dev/null
+++ b/bindgen-tests/tests/headers/eval-variadic-template-parameter.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++11
+
+template <typename... T>
+struct B {
+    // Can't generate anything meaningful in Rust for this, but we shouldn't
+    // trigger an assertion inside Clang.
+    static const long c = sizeof...(T);
+};
diff --git a/bindgen-tests/tests/headers/explicit-padding.h b/bindgen-tests/tests/headers/explicit-padding.h
new file mode 100644
index 00000000..4abaafba
--- /dev/null
+++ b/bindgen-tests/tests/headers/explicit-padding.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --explicit-padding
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+struct pad_me {
+        uint8_t first;
+        uint32_t second;
+        uint16_t third;
+};
+
+union dont_pad_me {
+        uint8_t first;
+        uint32_t second;
+        uint16_t third;
+};
diff --git a/bindgen-tests/tests/headers/extern-const-struct.h b/bindgen-tests/tests/headers/extern-const-struct.h
new file mode 100644
index 00000000..10271274
--- /dev/null
+++ b/bindgen-tests/tests/headers/extern-const-struct.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.40
+
+struct nsFoo {
+  float details[400];
+};
+
+extern const struct nsFoo gDetails;
diff --git a/bindgen-tests/tests/headers/extern.hpp b/bindgen-tests/tests/headers/extern.hpp
new file mode 100644
index 00000000..0779e038
--- /dev/null
+++ b/bindgen-tests/tests/headers/extern.hpp
@@ -0,0 +1,3 @@
+extern "C" {
+#include "func_proto.h"
+}
diff --git a/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h b/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h
new file mode 100644
index 00000000..dba20937
--- /dev/null
+++ b/bindgen-tests/tests/headers/fit-macro-constant-types-signed.h
@@ -0,0 +1,2 @@
+// bindgen-flags: --default-macro-constant-type=signed --fit-macro-constant-types
+#include "default-macro-constant-type.h"
diff --git a/bindgen-tests/tests/headers/fit-macro-constant-types.h b/bindgen-tests/tests/headers/fit-macro-constant-types.h
new file mode 100644
index 00000000..b995bfc0
--- /dev/null
+++ b/bindgen-tests/tests/headers/fit-macro-constant-types.h
@@ -0,0 +1,4 @@
+// bindgen-flags: --fit-macro-constant-types
+// Test fitting macro constants into smaller integer types
+// Negative values are i8, i16, i32 or i64; others are u8, u16, u32 or u64.
+#include "default-macro-constant-type.h"
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/float128.hpp b/bindgen-tests/tests/headers/float128.hpp
new file mode 100644
index 00000000..f554e88e
--- /dev/null
+++ b/bindgen-tests/tests/headers/float128.hpp
@@ -0,0 +1,13 @@
+// FIXME: libclang < 3.9 does not expose `__float128` in its interface, so this
+// test will fail. Once we remove support for `--features llvm_stable` and
+// require libclang >= 3.9, we can reenable this test.
+//
+// static __float128 global = 1.0;
+
+// FIXME: We have no way to get 128 bit aligned structs in Rust at the moment,
+// and therefore the generated layout tests for this struct will fail. When we
+// can enforce 128 bit alignment, we can re-enable this test.
+//
+// struct A {
+//     __float128 f;
+// };
diff --git a/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp b/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp
new file mode 100644
index 00000000..a26c1cd2
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward-declaration-autoptr.hpp
@@ -0,0 +1,10 @@
+class Foo;
+
+template <typename T>
+struct RefPtr {
+  T* m_inner;
+};
+
+struct Bar {
+  RefPtr<Foo> m_member;
+};
diff --git a/bindgen-tests/tests/headers/forward-enum-decl.hpp b/bindgen-tests/tests/headers/forward-enum-decl.hpp
new file mode 100644
index 00000000..81a0eee7
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward-enum-decl.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11
+
+enum class CSSPseudoClassType : int;
+
+enum class CSSPseudoClassType : int {
+  empty,
+  link,
+};
diff --git a/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp b/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp
new file mode 100644
index 00000000..437fff5d
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward-inherit-struct-with-fields.hpp
@@ -0,0 +1,8 @@
+template <typename> class Rooted;
+namespace js {
+    template <typename T> class RootedBase {
+      T* foo;
+      Rooted<T>* next;
+    };
+}
+template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/bindgen-tests/tests/headers/forward-inherit-struct.hpp b/bindgen-tests/tests/headers/forward-inherit-struct.hpp
new file mode 100644
index 00000000..ac7aef5e
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward-inherit-struct.hpp
@@ -0,0 +1,5 @@
+template <typename> class Rooted;
+namespace js {
+    template <typename T> class RootedBase {};
+}
+template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/bindgen-tests/tests/headers/forward_declared_complex_types.hpp b/bindgen-tests/tests/headers/forward_declared_complex_types.hpp
new file mode 100644
index 00000000..ffc779ad
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward_declared_complex_types.hpp
@@ -0,0 +1,16 @@
+struct Foo_empty {};
+struct Foo;
+
+struct Bar {
+    Foo *f;
+};
+
+void baz_struct(Foo* f);
+
+union Union;
+
+void baz_union(Union* u);
+
+class Quux;
+
+void baz_class(Quux* q);
diff --git a/bindgen-tests/tests/headers/forward_declared_complex_types_1_0.hpp b/bindgen-tests/tests/headers/forward_declared_complex_types_1_0.hpp
new file mode 100644
index 00000000..ff6076fc
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward_declared_complex_types_1_0.hpp
@@ -0,0 +1,18 @@
+// bindgen-flags: --rust-target 1.0
+
+struct Foo_empty {};
+struct Foo;
+
+struct Bar {
+    Foo *f;
+};
+
+void baz_struct(Foo* f);
+
+union Union;
+
+void baz_union(Union* u);
+
+class Quux;
+
+void baz_class(Quux* q);
diff --git a/bindgen-tests/tests/headers/forward_declared_opaque.h b/bindgen-tests/tests/headers/forward_declared_opaque.h
new file mode 100644
index 00000000..1b58edb9
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward_declared_opaque.h
@@ -0,0 +1,4 @@
+// bindgen-flags: --opaque-type "*"
+
+union a;
+struct b;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/forward_declared_struct.h b/bindgen-tests/tests/headers/forward_declared_struct.h
new file mode 100644
index 00000000..2a69450c
--- /dev/null
+++ b/bindgen-tests/tests/headers/forward_declared_struct.h
@@ -0,0 +1,11 @@
+struct a;
+
+struct a {
+    int b;
+};
+
+struct c {
+    int d;
+};
+
+struct c;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/func_proto.h b/bindgen-tests/tests/headers/func_proto.h
new file mode 100644
index 00000000..51139ca9
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_proto.h
@@ -0,0 +1 @@
+typedef int foo(int bar);
diff --git a/bindgen-tests/tests/headers/func_ptr.h b/bindgen-tests/tests/headers/func_ptr.h
new file mode 100644
index 00000000..34dc48d1
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_ptr.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+int (*foo) (int x, int y);
diff --git a/bindgen-tests/tests/headers/func_ptr_in_struct.h b/bindgen-tests/tests/headers/func_ptr_in_struct.h
new file mode 100644
index 00000000..ef075df7
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_ptr_in_struct.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+//
+enum baz;
+
+struct Foo {
+    enum baz (*bar) (int x, int y);
+};
diff --git a/bindgen-tests/tests/headers/func_ptr_return_type.h b/bindgen-tests/tests/headers/func_ptr_return_type.h
new file mode 100644
index 00000000..d529edc7
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_ptr_return_type.h
@@ -0,0 +1 @@
+int (*func(void))(int, int);
diff --git a/bindgen-tests/tests/headers/func_return_must_use.h b/bindgen-tests/tests/headers/func_return_must_use.h
new file mode 100644
index 00000000..f05bd2de
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_return_must_use.h
@@ -0,0 +1,36 @@
+// bindgen-flags: --must-use-type 'MustUse.*'
+
+typedef int MustUseInt;
+
+MustUseInt return_int();
+
+struct MustUseStruct;
+
+struct MustUseStruct return_struct();
+
+/**
+ * <div rustbindgen mustusetype></div>
+ */
+typedef int AnnotatedInt;
+
+AnnotatedInt return_annotated_int();
+
+int return_plain_int();
+
+/**
+ * <div rustbindgen mustusetype></div>
+ */
+struct AnnotatedStruct {};
+
+struct AnnotatedStruct return_annotated_struct();
+
+struct PlainStruct {};
+
+/**
+ * <div rustbindgen mustusetype></div>
+ */
+typedef struct PlainStruct TypedefPlainStruct;
+
+struct PlainStruct return_plain_struct();
+
+TypedefPlainStruct return_typedef_struct();
diff --git a/bindgen-tests/tests/headers/func_with_array_arg.h b/bindgen-tests/tests/headers/func_with_array_arg.h
new file mode 100644
index 00000000..1b81702b
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_with_array_arg.h
@@ -0,0 +1 @@
+void f(int x[2]);
diff --git a/bindgen-tests/tests/headers/func_with_func_ptr_arg.h b/bindgen-tests/tests/headers/func_with_func_ptr_arg.h
new file mode 100644
index 00000000..e9abcae6
--- /dev/null
+++ b/bindgen-tests/tests/headers/func_with_func_ptr_arg.h
@@ -0,0 +1,3 @@
+void foo(void (*bar)());
+
+void bar(void (*one)(int a, int b), void (*two)(int c, int d));
diff --git a/bindgen-tests/tests/headers/function-typedef-stdcall.h b/bindgen-tests/tests/headers/function-typedef-stdcall.h
new file mode 100644
index 00000000..05d1e78a
--- /dev/null
+++ b/bindgen-tests/tests/headers/function-typedef-stdcall.h
@@ -0,0 +1,12 @@
+typedef
+    void __stdcall
+    EVT_VIGEM_X360_NOTIFICATION(
+        void* Client,
+        void* Target,
+        unsigned char LargeMotor,
+        unsigned char SmallMotor,
+        unsigned char LedNumber,
+        void* UserData
+    );
+
+typedef EVT_VIGEM_X360_NOTIFICATION *PFN_VIGEM_X360_NOTIFICATION;
diff --git a/bindgen-tests/tests/headers/gen-constructors-neg.hpp b/bindgen-tests/tests/headers/gen-constructors-neg.hpp
new file mode 100644
index 00000000..2dd491c4
--- /dev/null
+++ b/bindgen-tests/tests/headers/gen-constructors-neg.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --generate types,functions
+
+class Foo {
+ public:
+  Foo(int a);
+};
diff --git a/bindgen-tests/tests/headers/gen-constructors.hpp b/bindgen-tests/tests/headers/gen-constructors.hpp
new file mode 100644
index 00000000..809d6ef9
--- /dev/null
+++ b/bindgen-tests/tests/headers/gen-constructors.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --generate types,constructors,functions
+
+class Foo {
+ public:
+  Foo(int a);
+};
diff --git a/bindgen-tests/tests/headers/gen-destructors-neg.hpp b/bindgen-tests/tests/headers/gen-destructors-neg.hpp
new file mode 100644
index 00000000..5ede3ba3
--- /dev/null
+++ b/bindgen-tests/tests/headers/gen-destructors-neg.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --generate types,functions
+//
+// NB: This is intended to _not_ generate destructors.
+
+class Foo {
+  int bar;
+ public:
+  ~Foo();
+};
diff --git a/bindgen-tests/tests/headers/gen-destructors.hpp b/bindgen-tests/tests/headers/gen-destructors.hpp
new file mode 100644
index 00000000..719eb248
--- /dev/null
+++ b/bindgen-tests/tests/headers/gen-destructors.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --generate types,destructors,functions
+
+class Foo {
+  int bar;
+ public:
+  ~Foo();
+};
diff --git a/bindgen-tests/tests/headers/generate-inline.hpp b/bindgen-tests/tests/headers/generate-inline.hpp
new file mode 100644
index 00000000..922ee1ca
--- /dev/null
+++ b/bindgen-tests/tests/headers/generate-inline.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --generate-inline-functions
+
+class Foo {
+ public:
+  static inline int bar() {
+    return 42;
+  }
+};
+
+inline int foo() {
+  return 42;
+}
diff --git a/bindgen-tests/tests/headers/i128.h b/bindgen-tests/tests/headers/i128.h
new file mode 100644
index 00000000..6ec399c7
--- /dev/null
+++ b/bindgen-tests/tests/headers/i128.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --rust-target 1.26
+
+struct foo {
+  __int128 my_signed;
+  unsigned __int128 my_unsigned;
+};
diff --git a/bindgen-tests/tests/headers/in_class_typedef.hpp b/bindgen-tests/tests/headers/in_class_typedef.hpp
new file mode 100644
index 00000000..dda7472d
--- /dev/null
+++ b/bindgen-tests/tests/headers/in_class_typedef.hpp
@@ -0,0 +1,10 @@
+
+template<typename T>
+class Foo {
+  typedef T elem_type;
+  typedef T* ptr_type;
+
+  typedef struct Bar {
+    int x, y;
+  } Bar;
+};
diff --git a/bindgen-tests/tests/headers/incomplete-array-padding.h b/bindgen-tests/tests/headers/incomplete-array-padding.h
new file mode 100644
index 00000000..3fcc4c1a
--- /dev/null
+++ b/bindgen-tests/tests/headers/incomplete-array-padding.h
@@ -0,0 +1,4 @@
+struct foo {
+  char a : 1;
+  void *b[];
+};
diff --git a/bindgen-tests/tests/headers/infinite-macro.h b/bindgen-tests/tests/headers/infinite-macro.h
new file mode 100644
index 00000000..ab352c57
--- /dev/null
+++ b/bindgen-tests/tests/headers/infinite-macro.h
@@ -0,0 +1,2 @@
+#define INFINITY (1.0f/0.0f)
+#define NAN (0.0f/0.0f)
diff --git a/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp b/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp
new file mode 100644
index 00000000..562ca0e1
--- /dev/null
+++ b/bindgen-tests/tests/headers/inherit-from-template-instantiation-with-vtable.hpp
@@ -0,0 +1,37 @@
+// bindgen-flags: -- -std=c++14
+
+// Small test that we handle virtual tables correctly when deriving from a
+// template instantiation. This wasn't previously handled at all. Note that when
+// inheriting from a template parameter, the type that is instantiated might or
+// might not have a virtual table, and we have no way of knowing. We don't
+// handle that yet, so no test for it here.
+
+/// This should have an explicit vtable.
+template<class T>
+class BaseWithVtable {
+    T t;
+
+    virtual void hello();
+};
+
+/// This should not have an explicit vtable.
+class DerivedWithNoVirtualMethods : public BaseWithVtable<char*> {};
+
+/// This should not have an explicit vtable.
+class DerivedWithVirtualMethods : public BaseWithVtable<char*> {
+    virtual void zoidberg();
+};
+
+/// This should not have any vtable.
+template<class U>
+class BaseWithoutVtable {
+    U u;
+};
+
+/// This should have an explicit vtable.
+class DerivedWithVtable : public BaseWithoutVtable<char*> {
+    virtual void leela();
+};
+
+/// This should not have any vtable.
+class DerivedWithoutVtable : public BaseWithoutVtable<char*> {};
diff --git a/bindgen-tests/tests/headers/inherit-namespaced.hpp b/bindgen-tests/tests/headers/inherit-namespaced.hpp
new file mode 100644
index 00000000..61eafd5a
--- /dev/null
+++ b/bindgen-tests/tests/headers/inherit-namespaced.hpp
@@ -0,0 +1,4 @@
+namespace js {
+    template <typename T> class RootedBase {};
+}
+template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/bindgen-tests/tests/headers/inherit_named.hpp b/bindgen-tests/tests/headers/inherit_named.hpp
new file mode 100644
index 00000000..9881d1b6
--- /dev/null
+++ b/bindgen-tests/tests/headers/inherit_named.hpp
@@ -0,0 +1,5 @@
+template<typename T>
+class Wohoo {};
+
+template<typename T>
+class Weeee : public T {};
diff --git a/bindgen-tests/tests/headers/inherit_typedef.hpp b/bindgen-tests/tests/headers/inherit_typedef.hpp
new file mode 100644
index 00000000..8d699e82
--- /dev/null
+++ b/bindgen-tests/tests/headers/inherit_typedef.hpp
@@ -0,0 +1,5 @@
+struct Foo {};
+
+typedef Foo TypedefedFoo;
+
+struct Bar: public TypedefedFoo {};
diff --git a/bindgen-tests/tests/headers/inline-function.h b/bindgen-tests/tests/headers/inline-function.h
new file mode 100644
index 00000000..02cb7c08
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline-function.h
@@ -0,0 +1,6 @@
+// bindgen-unstable
+
+/** The point of this test is to _not_ generate these functions. */
+
+inline static int myadd(const int x, const int y) { return x + y; }
+static int mysub(const int x, const int y) { return x - y; }
diff --git a/bindgen-tests/tests/headers/inline_namespace.hpp b/bindgen-tests/tests/headers/inline_namespace.hpp
new file mode 100644
index 00000000..2ccf8ab0
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline_namespace.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --enable-cxx-namespaces -- -std=c++11
+
+namespace foo {
+  inline namespace bar {
+    using Ty = int;
+  };
+};
+
+class Bar {
+  foo::Ty baz;
+};
diff --git a/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp b/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp
new file mode 100644
index 00000000..90e46dfb
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline_namespace_allowlist.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type=std::string -- -std=c++11
+
+namespace std {
+  inline namespace bar {
+    using string = const char*;
+  };
+};
diff --git a/bindgen-tests/tests/headers/inline_namespace_conservative.hpp b/bindgen-tests/tests/headers/inline_namespace_conservative.hpp
new file mode 100644
index 00000000..50068a2e
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline_namespace_conservative.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --enable-cxx-namespaces --conservative-inline-namespaces -- -std=c++11
+
+namespace foo {
+  inline namespace bar {
+    using Ty = int;
+  };
+  using Ty = long long;
+};
+
+class Bar {
+  foo::bar::Ty baz;
+};
diff --git a/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp b/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp
new file mode 100644
index 00000000..30cd4e9b
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline_namespace_no_ns_enabled.hpp
@@ -0,0 +1,18 @@
+// bindgen-flags: -- -std=c++11
+
+namespace std {
+inline namespace __cxx11 {
+
+template<typename CharT>
+class basic_string {
+  struct Alloc_hider {
+    void* storage;
+  } hider;
+  unsigned long length;
+  struct {
+    CharT inline_storage[4];
+  };
+};
+
+}
+}
diff --git a/bindgen-tests/tests/headers/inner-typedef-gh422.hpp b/bindgen-tests/tests/headers/inner-typedef-gh422.hpp
new file mode 100644
index 00000000..301630a5
--- /dev/null
+++ b/bindgen-tests/tests/headers/inner-typedef-gh422.hpp
@@ -0,0 +1,11 @@
+template <typename T>
+class Foo {
+public:
+    class InnerType {
+        T t;
+    };
+};
+
+typedef Foo<int>::InnerType Bar;
+
+Bar func();
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/inner_const.hpp b/bindgen-tests/tests/headers/inner_const.hpp
new file mode 100644
index 00000000..25c2e603
--- /dev/null
+++ b/bindgen-tests/tests/headers/inner_const.hpp
@@ -0,0 +1,6 @@
+
+class Foo {
+  static int BOO;
+  static Foo whatever;
+  int bar;
+};
diff --git a/bindgen-tests/tests/headers/inner_template_self.hpp b/bindgen-tests/tests/headers/inner_template_self.hpp
new file mode 100644
index 00000000..1ae5af06
--- /dev/null
+++ b/bindgen-tests/tests/headers/inner_template_self.hpp
@@ -0,0 +1,10 @@
+
+template <typename T>
+class LinkedList {
+    LinkedList<T>* next;
+    LinkedList* prev;
+};
+
+class InstantiateIt {
+    LinkedList<int> m_list;
+};
diff --git a/bindgen-tests/tests/headers/int128_t.h b/bindgen-tests/tests/headers/int128_t.h
new file mode 100644
index 00000000..eece252c
--- /dev/null
+++ b/bindgen-tests/tests/headers/int128_t.h
@@ -0,0 +1,7 @@
+/**
+ * FIXME: Uncomment this once we can generate the proper alignment for the type,
+ * i.e., when we use u128/i128.
+struct Foo {
+  __int128 foo;
+};
+ */
diff --git a/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp b/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp
new file mode 100644
index 00000000..589b3c25
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1025-unknown-enum-repr.hpp
@@ -0,0 +1,4 @@
+
+template <typename> class a {
+  enum {};
+};
diff --git a/bindgen-tests/tests/headers/issue-1034.h b/bindgen-tests/tests/headers/issue-1034.h
new file mode 100644
index 00000000..8042fec6
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1034.h
@@ -0,0 +1,4 @@
+
+struct S2 {
+    unsigned : 11
+};
diff --git a/bindgen-tests/tests/headers/issue-1040.h b/bindgen-tests/tests/headers/issue-1040.h
new file mode 100644
index 00000000..1d61d40d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1040.h
@@ -0,0 +1 @@
+unsigned long long g_107 = 18446744073709551615UL;
diff --git a/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h b/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h
new file mode 100644
index 00000000..876ec174
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1076-unnamed-bitfield-alignment.h
@@ -0,0 +1,4 @@
+struct S1 {
+    signed : 15;
+    unsigned : 6
+};
diff --git a/bindgen-tests/tests/headers/issue-1113-template-references.hpp b/bindgen-tests/tests/headers/issue-1113-template-references.hpp
new file mode 100644
index 00000000..46339c5d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1113-template-references.hpp
@@ -0,0 +1,16 @@
+template<class K, class V>
+class Entry : public K
+{
+  V mData;
+};
+
+template<typename K, typename V>
+class nsBaseHashtable {
+  typedef Entry<K, V> EntryType;
+
+  struct EntryPtr {
+  private:
+    EntryType& mEntry;
+    bool mExistingEntry;
+  };
+};
diff --git a/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp b/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp
new file mode 100644
index 00000000..b6ea63f6
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1118-using-forward-decl.hpp
@@ -0,0 +1,10 @@
+template <class> class nsTArray;
+template <class b> using c = nsTArray<b>;
+class nsTArray_base {
+  int *d;
+};
+template <class> class nsTArray : nsTArray_base {};
+class nsIContent {
+  nsTArray<nsIContent *> foo;
+};
+nsTArray<nsIContent*> *Gecko_GetAnonymousContentForElement();
diff --git a/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp b/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp
new file mode 100644
index 00000000..a0da90c9
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1197-pure-virtual-stuff.hpp
@@ -0,0 +1,6 @@
+class Foo
+{
+public:
+  virtual void Bar() = 0;
+  virtual ~Foo() = 0;
+};
diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h
new file mode 100644
index 00000000..5bccb0d4
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-bitfield-enum.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --rustified-enum '.*' --bitfield-enum '.*'
+
+typedef enum MyDupeEnum {
+	A = 0,
+	A_alias = 0,
+	B,
+} MyDupeEnum;
+
+enum MyOtherDupeEnum {
+	C = 0,
+	C_alias = 0,
+	D,
+};
diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
new file mode 100644
index 00000000..ecdf8c3f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*' --bitfield-enum '.*'
+
+typedef enum MyDupeEnum {
+	A = 0,
+	A_alias = 0,
+	B,
+} MyDupeEnum;
+
+enum MyOtherDupeEnum {
+	C = 0,
+	C_alias = 0,
+	D,
+};
diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h
new file mode 100644
index 00000000..944fac31
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-const-mod-enum.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*'
+
+typedef enum MyDupeEnum {
+	A = 0,
+	A_alias = 0,
+	B,
+} MyDupeEnum;
+
+enum MyOtherDupeEnum {
+	C = 0,
+	C_alias = 0,
+	D,
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h b/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h
new file mode 100644
index 00000000..ede44f0a
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1198-alias-rust-enum.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --rustified-enum '.*'
+
+
+typedef enum MyDupeEnum {
+	A = 0,
+	A_alias = 0,
+	B,
+} MyDupeEnum;
+
+enum MyOtherDupeEnum {
+	C = 0,
+	C_alias = 0,
+	D,
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-1216-variadic-member.h b/bindgen-tests/tests/headers/issue-1216-variadic-member.h
new file mode 100644
index 00000000..b8bc0b81
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1216-variadic-member.h
@@ -0,0 +1,4 @@
+void f(int a, ...);
+struct Foo {
+  void (*f)(void *p, void *obj, int a, ...);
+};
diff --git a/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h b/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h
new file mode 100644
index 00000000..150bbbeb
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1238-fwd-no-copy.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --no-copy MyType
+
+typedef struct MyType MyTypeT;
diff --git a/bindgen-tests/tests/headers/issue-1281.h b/bindgen-tests/tests/headers/issue-1281.h
new file mode 100644
index 00000000..4a3aaab0
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1281.h
@@ -0,0 +1,11 @@
+struct foo;
+
+typedef struct bar {
+  struct foo {
+    int foo;
+  } u;
+} bar_t;
+
+struct baz {
+  struct foo f;
+};
diff --git a/bindgen-tests/tests/headers/issue-1285.h b/bindgen-tests/tests/headers/issue-1285.h
new file mode 100644
index 00000000..a2817d84
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1285.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --no-recursive-allowlist --allowlist-type "foo"
+
+struct foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    } bar;
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-1291.hpp b/bindgen-tests/tests/headers/issue-1291.hpp
new file mode 100644
index 00000000..4ec524f1
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1291.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --rust-target 1.25
+// bindgen-unstable
+
+struct __attribute__((aligned(16))) RTCRay
+    {
+  float org[3];
+  float align0;
+  float dir[3];
+  float align1;
+  float tnear;
+  float tfar;
+  float time;
+  unsigned mask;
+  float Ng[3];
+  float align2;
+  float u;
+  float v;
+  unsigned geomID;
+  unsigned primID;
+  unsigned instID;
+};
diff --git a/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h b/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h
new file mode 100644
index 00000000..4b0ec2a6
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1350-attribute-overloadable.h
@@ -0,0 +1,2 @@
+void my_function(int a) __attribute__((overloadable));
+void my_function(const char *a) __attribute__((overloadable));
diff --git a/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h b/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h
new file mode 100644
index 00000000..4cf346e6
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1382-rust-primitive-types.h
@@ -0,0 +1,34 @@
+typedef int int8_t;
+typedef int uint8_t;
+typedef int int16_t;
+typedef int uint16_t;
+typedef int int32_t;
+typedef int uint32_t;
+typedef int int64_t;
+typedef int uint64_t;
+
+typedef int8_t i8;
+typedef uint8_t u8;
+typedef int16_t i16;
+typedef uint16_t u16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+
+struct Foo {
+    int i8;
+    int u8;
+    int i16;
+    int u16;
+    int i32;
+    int u32;
+    int i64;
+    int u64;
+    int i128;
+    int u128;
+    int isize;
+    int usize;
+    int f32;
+    int f64;
+};
diff --git a/bindgen-tests/tests/headers/issue-1435.hpp b/bindgen-tests/tests/headers/issue-1435.hpp
new file mode 100644
index 00000000..fbf3c507
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1435.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+namespace ns {
+enum class AB { A, B };
+}
+using AB = ns::AB;
+static const AB kA = AB::A;
diff --git a/bindgen-tests/tests/headers/issue-1443.hpp b/bindgen-tests/tests/headers/issue-1443.hpp
new file mode 100644
index 00000000..9b637ba7
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1443.hpp
@@ -0,0 +1,21 @@
+struct Foo;
+
+struct Bar {
+  const Foo& f;
+  unsigned m;
+};
+
+struct Baz {
+  Foo& f;
+  unsigned m;
+};
+
+struct Tar {
+  const Foo&& f;
+  unsigned m;
+};
+
+struct Taz {
+  Foo&& f;
+  unsigned m;
+};
diff --git a/bindgen-tests/tests/headers/issue-1454.h b/bindgen-tests/tests/headers/issue-1454.h
new file mode 100644
index 00000000..96645dac
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1454.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --no-recursive-allowlist --allowlist-type "local_type" --with-derive-hash --no-derive-copy --no-derive-default --raw-line "#[repr(C)] #[derive(Debug)] pub struct extern_type;"
+// bindgen-parse-callbacks: blocklisted-type-implements-trait
+
+struct extern_type {};
+
+typedef struct
+{
+    struct extern_type inner;
+}
+local_type;
diff --git a/bindgen-tests/tests/headers/issue-1464.hpp b/bindgen-tests/tests/headers/issue-1464.hpp
new file mode 100644
index 00000000..d34d0fe3
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1464.hpp
@@ -0,0 +1,7 @@
+
+// Should not crash.
+template <int Foo> class Bar {
+public:
+  Bar();
+  ~Bar();
+};
diff --git a/bindgen-tests/tests/headers/issue-1488-enum-new-type.h b/bindgen-tests/tests/headers/issue-1488-enum-new-type.h
new file mode 100644
index 00000000..6855283f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1488-enum-new-type.h
@@ -0,0 +1,29 @@
+// bindgen-flags: --default-alias-style=new_type --constified-enum "Foo" --constified-enum-module "Bar" --rustified-enum "Qux" --new-type-alias-deref "BazAlias"
+
+enum Foo {
+    A,
+    B
+};
+
+typedef enum Foo FooAlias;
+
+enum Bar {
+    C,
+    D
+};
+
+typedef enum Bar BarAlias;
+
+enum Qux {
+    E,
+    F
+};
+
+typedef enum Qux QuxAlias;
+
+enum Baz {
+    G,
+    H
+};
+
+typedef enum Baz BazAlias;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-1488-options.h b/bindgen-tests/tests/headers/issue-1488-options.h
new file mode 100644
index 00000000..fba1c93b
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1488-options.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --new-type-alias "SomePtr" --new-type-alias-deref "AnotherPtr"
+
+typedef int OSStatus;
+typedef void* SomePtr;
+typedef void* AnotherPtr;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp b/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp
new file mode 100644
index 00000000..4374da3d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1488-template-alias-new-type.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --default-alias-style=new_type -- -std=c++14
+
+template<typename T>
+using Wrapped = T;
diff --git a/bindgen-tests/tests/headers/issue-1498.h b/bindgen-tests/tests/headers/issue-1498.h
new file mode 100644
index 00000000..aceabbd2
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1498.h
@@ -0,0 +1,17 @@
+typedef unsigned long uint64_t;
+typedef uint64_t size_t;
+typedef unsigned uint32_t;
+typedef int int32_t;
+
+struct rte_memseg {
+    uint64_t phys_addr;      /**< Start physical address. */
+    union {
+        void *addr;         /**< Start virtual address. */
+        uint64_t addr_64;   /**< Makes sure addr is always 64 bits */
+    };
+    size_t len;               /**< Length of the segment. */
+    uint64_t hugepage_sz;       /**< The pagesize of underlying memory */
+    int32_t socket_id;          /**< NUMA socket ID. */
+    uint32_t nchannel;          /**< Number of channels. */
+    uint32_t nrank;             /**< Number of ranks. */
+} __attribute__((__packed__));
diff --git a/bindgen-tests/tests/headers/issue-1514.hpp b/bindgen-tests/tests/headers/issue-1514.hpp
new file mode 100644
index 00000000..2a398898
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1514.hpp
@@ -0,0 +1,9 @@
+template<typename T>
+struct Thing {
+    struct Inner {
+        T *ptr;
+    };
+
+    struct AnotherInner : Inner {
+    };
+};
diff --git a/bindgen-tests/tests/headers/issue-1554.h b/bindgen-tests/tests/headers/issue-1554.h
new file mode 100644
index 00000000..13452923
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1554.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --default-enum-style rust_non_exhaustive --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(non_exhaustive)]'
+
+enum Planet {
+    earth,
+    mars
+};
diff --git a/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h b/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h
new file mode 100644
index 00000000..85e845b8
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1599-opaque-typedef-to-enum.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --opaque-type d
+
+typedef enum a { b, c } d;
diff --git a/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp b/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp
new file mode 100644
index 00000000..297927b6
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1676-macro-namespace-prefix.hpp
@@ -0,0 +1,2 @@
+#define nssv_inline_ns inline
+nssv_inline_ns namespace literals {}
diff --git a/bindgen-tests/tests/headers/issue-1947.h b/bindgen-tests/tests/headers/issue-1947.h
new file mode 100644
index 00000000..e2e9b3e1
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1947.h
@@ -0,0 +1,9 @@
+typedef unsigned char U8;
+typedef unsigned short U16;
+
+typedef struct {
+    U16 MADZ : 10, MAI0 : 2, MAI1 : 2, MAI2 : 2;
+    U8 MADK, MABR;
+    U16 MATH : 10, MATE : 4, MATW : 2;
+    U8 MASW : 4, MABW : 3, MAXN : 1, _rB_;
+} V56AMDY;
diff --git a/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp b/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp
new file mode 100644
index 00000000..58e8e4d1
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1977-larger-arrays.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct S {
+    char large_array[33];
+};
+
+template<typename T> struct ST {
+    T large_array[33];
+};
diff --git a/bindgen-tests/tests/headers/issue-1995.h b/bindgen-tests/tests/headers/issue-1995.h
new file mode 100644
index 00000000..619f6735
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-1995.h
@@ -0,0 +1,12 @@
+/// This is a constant that has a docstring
+///
+/// And expected to be found in generated bindings code too.
+const int FOO = 1;
+
+/// This is a constant that has a docstring
+///
+/// And expected to be found in generated bindings code too.
+struct Bar
+{
+    int baz;
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-2019.hpp b/bindgen-tests/tests/headers/issue-2019.hpp
new file mode 100644
index 00000000..2e9a3ffd
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-2019.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --disable-nested-struct-naming
+
+struct A {
+    static A make();
+    int a;
+};
+struct B {
+    static B make();
+    int b;
+};
diff --git a/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp b/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp
new file mode 100644
index 00000000..4e6feb3f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-2239-template-dependent-bit-width.hpp
@@ -0,0 +1,10 @@
+template <class a> class b {
+    typedef a td;
+    using ta = a;
+    struct foo {
+        a foo : sizeof(a);
+        a : sizeof(a);
+        td : sizeof(td);
+        ta : sizeof(ta);
+    };
+};
diff --git a/bindgen-tests/tests/headers/issue-358.hpp b/bindgen-tests/tests/headers/issue-358.hpp
new file mode 100644
index 00000000..b14521b7
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-358.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++11
+namespace JS {
+template <typename> class PersistentRooted;
+}
+template <typename> class a { a *b; };
+namespace JS {
+template <typename c> class PersistentRooted : a<PersistentRooted<c>> {};
+}
diff --git a/bindgen-tests/tests/headers/issue-372.hpp b/bindgen-tests/tests/headers/issue-372.hpp
new file mode 100644
index 00000000..a2a5d451
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-372.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*" --rust-target 1.40
+template <typename a, int b> class c { a e[b]; };
+class d;
+template <typename g, g f> class C { c<d, f> h; };
+class i {
+  i *j;
+  i *k;
+  bool l;
+};
+class d {
+  i m;
+};
+enum n { o, p, q, r, s, t, b, ae, e, ag, ah, ai };
+class F {
+  C<n, ai> w;
+};
diff --git a/bindgen-tests/tests/headers/issue-410.hpp b/bindgen-tests/tests/headers/issue-410.hpp
new file mode 100644
index 00000000..d4f3de3d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-410.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type JS::Value --rustified-enum ".*"
+
+namespace JS {
+class Value;
+}
+typedef enum {} JSWhyMagic;
+namespace JS {
+class Value {
+public:
+  void a(JSWhyMagic);
+};
+}
diff --git a/bindgen-tests/tests/headers/issue-446.hpp b/bindgen-tests/tests/headers/issue-446.hpp
new file mode 100644
index 00000000..2e09c274
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-446.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename Elem>
+class List {
+    List<Elem> *next;
+};
+
+template <typename GcThing>
+class PersistentRooted {
+    List<PersistentRooted<GcThing>> root_list;
+};
diff --git a/bindgen-tests/tests/headers/issue-447.hpp b/bindgen-tests/tests/headers/issue-447.hpp
new file mode 100644
index 00000000..43765fa9
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-447.hpp
@@ -0,0 +1,27 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type JSAutoCompartment -- -std=c++11
+
+namespace mozilla {
+    template <typename> class a {};
+    namespace detail {
+        class GuardObjectNotifier {};
+        struct b;
+    }
+    class c {
+        typedef detail::b d;
+    };
+}
+namespace js {
+    class D {
+        mozilla::a<mozilla::c> e;
+    };
+}
+struct f {
+    js::D g;
+};
+namespace js {
+    struct ContextFriendFields : f {};
+}
+class JSAutoCompartment {
+public:
+    JSAutoCompartment(mozilla::detail::GuardObjectNotifier);
+};
diff --git a/bindgen-tests/tests/headers/issue-493.hpp b/bindgen-tests/tests/headers/issue-493.hpp
new file mode 100644
index 00000000..8b122ceb
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-493.hpp
@@ -0,0 +1,48 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+template<class _CharT, class _Traits, class _Allocator>
+class basic_string
+{
+public:
+    typedef unsigned long long size_type;
+    typedef char value_type;
+    typedef value_type * pointer;
+
+    struct __long
+    {
+        size_type __cap_;
+        size_type __size_;
+        pointer   __data_;
+    };
+
+    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
+                        (sizeof(__long) - 1)/sizeof(value_type) : 2};
+
+    struct __short
+    {
+        union
+        {
+            unsigned char __size_;
+            value_type __lx;
+        };
+        value_type __data_[__min_cap];
+    };
+
+    union __ulx{__long __lx; __short __lxx;};
+
+    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
+
+    struct __raw
+    {
+        size_type __words[__n_words];
+    };
+
+    struct __rep
+    {
+        union
+        {
+            __long  __l;
+            __short __s;
+            __raw   __r;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/issue-493_1_0.hpp b/bindgen-tests/tests/headers/issue-493_1_0.hpp
new file mode 100644
index 00000000..af6fd47c
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-493_1_0.hpp
@@ -0,0 +1,49 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+
+template<class _CharT, class _Traits, class _Allocator>
+class basic_string
+{
+public:
+    typedef unsigned long long size_type;
+    typedef char value_type;
+    typedef value_type * pointer;
+
+    struct __long
+    {
+        size_type __cap_;
+        size_type __size_;
+        pointer   __data_;
+    };
+
+    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
+                        (sizeof(__long) - 1)/sizeof(value_type) : 2};
+
+    struct __short
+    {
+        union
+        {
+            unsigned char __size_;
+            value_type __lx;
+        };
+        value_type __data_[__min_cap];
+    };
+
+    union __ulx{__long __lx; __short __lxx;};
+
+    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
+
+    struct __raw
+    {
+        size_type __words[__n_words];
+    };
+
+    struct __rep
+    {
+        union
+        {
+            __long  __l;
+            __short __s;
+            __raw   __r;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/issue-511.h b/bindgen-tests/tests/headers/issue-511.h
new file mode 100644
index 00000000..da364312
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-511.h
@@ -0,0 +1,4 @@
+char * a;
+const char * b;
+char * const c;
+const char * const d;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/issue-537-repr-packed-n.h b/bindgen-tests/tests/headers/issue-537-repr-packed-n.h
new file mode 100644
index 00000000..f4c0070a
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-537-repr-packed-n.h
@@ -0,0 +1,34 @@
+// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.33
+
+/// This should not be opaque; we can see the attributes and can pack the
+/// struct.
+struct AlignedToOne {
+    int i;
+} __attribute__ ((packed,aligned(1)));
+
+/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
+struct AlignedToTwo {
+    int i;
+} __attribute__ ((packed,aligned(2)));
+
+#pragma pack(1)
+
+/// This should not be opaque because although `libclang` doesn't give us the
+/// `#pragma pack(1)`, we can detect that alignment is 1 and add
+/// `#[repr(packed)]` to the struct ourselves.
+struct PackedToOne {
+    int x;
+    int y;
+};
+
+#pragma pack()
+
+#pragma pack(2)
+
+/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
+struct PackedToTwo {
+    int x;
+    int y;
+};
+
+#pragma pack()
diff --git a/bindgen-tests/tests/headers/issue-537.h b/bindgen-tests/tests/headers/issue-537.h
new file mode 100644
index 00000000..a773199f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-537.h
@@ -0,0 +1,35 @@
+/// This should not be opaque; we can see the attributes and can pack the
+/// struct.
+struct AlignedToOne {
+    int i;
+} __attribute__ ((packed,aligned(1)));
+
+/// This should be opaque because although we can see the attributes, Rust before
+/// 1.33 doesn't have `#[repr(packed(N))]`.
+struct AlignedToTwo {
+    int i;
+} __attribute__ ((packed,aligned(2)));
+
+#pragma pack(1)
+
+/// This should not be opaque because although `libclang` doesn't give us the
+/// `#pragma pack(1)`, we can detect that alignment is 1 and add
+/// `#[repr(packed)]` to the struct ourselves.
+struct PackedToOne {
+    int x;
+    int y;
+};
+
+#pragma pack()
+
+#pragma pack(2)
+
+/// In this case, even if we can detect the weird alignment triggered by
+/// `#pragma pack(2)`, we can't do anything about it because Rust before 1.33
+/// doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque.
+struct PackedToTwo {
+    int x;
+    int y;
+};
+
+#pragma pack()
diff --git a/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp b/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp
new file mode 100644
index 00000000..f3467f45
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-544-stylo-creduce-2.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+struct Foo {
+    template <typename> using FirstAlias = typename T::Associated;
+    template <typename U> using SecondAlias = Foo<FirstAlias<U>>;
+    SecondAlias<int> member;
+};
diff --git a/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp b/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp
new file mode 100644
index 00000000..ba9f8257
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-544-stylo-creduce.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename> class a;
+template <typename b, typename... c> class a<b(c...)> { a(const a &); };
+template <typename b, typename... c> a<b(c...)>::a(const a &) {}
diff --git a/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp b/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
new file mode 100644
index 00000000..297d1112
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
@@ -0,0 +1,27 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++14
+
+// Generated by C-Reduce, cleaned up and given names for readability.
+
+template <int, typename>
+struct HasNonTypeTemplateParam {
+    // But doesn't use the non-type template param nor its type param...
+};
+
+enum {
+    ENUM_VARIANT_1,
+    ENUM_VARIANT_2
+};
+
+namespace JS {
+
+template <typename T>
+using Alias = HasNonTypeTemplateParam<ENUM_VARIANT_1, T>;
+
+template <typename U>
+class Base {
+    Alias<U> f;
+};
+
+class AutoIdVector : Base<int> {};
+
+}
diff --git a/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp b/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp
new file mode 100644
index 00000000..ac8cbd48
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-573-layout-test-failures.hpp
@@ -0,0 +1,12 @@
+template <int>
+struct UnusedIntTemplateParam {};
+
+template <class>
+class Outer {
+    static const long SIZE = 1;
+    UnusedIntTemplateParam<SIZE> i;
+};
+
+class AutoIdVector {
+  Outer<int> ar;
+};
diff --git a/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp b/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp
new file mode 100644
index 00000000..b563b4ef
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-574-assertion-failure-in-codegen.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -std=c++14
+
+template <class> class a {};
+class {
+  a<int> ar;
+} AutoIdVector;
diff --git a/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp b/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp
new file mode 100644
index 00000000..5f11ea3c
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-584-stylo-template-analysis-panic.hpp
@@ -0,0 +1,13 @@
+// bindgen-flags: --blocklist-type RefPtr --allowlist-function 'Servo_.*' --raw-line 'pub type RefPtr<T> = T;' -- -std=c++14
+template <class> class RefPtr;
+class b;
+class A {
+  typedef b a;
+};
+template <class c> class e { RefPtr<c> d; };
+template <class> class f {};
+class g {
+  f<e<int>> h;
+};
+class b : g {};
+A Servo_Element_GetSnapshot();
diff --git a/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
new file mode 100644
index 00000000..13b656e1
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: -- -std=c++14
+
+template <class T>
+class RefPtr {
+    T use_of_t;
+};
+
+template <typename U>
+class UsesRefPtrWithAliasedTypeParam {
+    using V = U;
+    RefPtr<V> member;
+};
diff --git a/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp b/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp
new file mode 100644
index 00000000..efd6c4f4
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-639-typedef-anon-field.hpp
@@ -0,0 +1,15 @@
+class Foo {
+ public:
+  typedef struct {
+      int abc;
+  } Bar;
+
+  Bar bar;
+};
+
+class Baz {
+ public:
+  typedef struct {
+      int abc;
+  } Bar;
+};
diff --git a/bindgen-tests/tests/headers/issue-643-inner-struct.h b/bindgen-tests/tests/headers/issue-643-inner-struct.h
new file mode 100644
index 00000000..25c525b3
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-643-inner-struct.h
@@ -0,0 +1,13 @@
+struct rte_ring {
+  struct rte_memzone *memzone;
+
+  struct prod {
+    unsigned watermark;
+  } prod;
+
+  struct cons {
+    unsigned sc_dequeue;
+  } cons;
+
+  void *ring[];
+};
diff --git a/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
new file mode 100644
index 00000000..8e07a8a0
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --blocklist-type RefPtr --raw-line "#[derive(Clone, Copy, Debug)] pub struct RefPtr<T>(T);" --allowlist-type "HasRefPtr" -- -std=c++14
+
+template <class> class RefPtr {};
+
+template <typename T>
+class HasRefPtr {
+  typedef T TypedefOfT;
+  RefPtr<TypedefOfT> refptr_member;
+};
diff --git a/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h b/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h
new file mode 100644
index 00000000..0860ce95
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-648-derive-debug-with-padding.h
@@ -0,0 +1,21 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rust-target 1.40
+/**
+ * We emit a `[u8; 63usize]` padding field for this struct, which cannot derive
+ * Debug/Hash because 63 is over the hard coded limit.
+ */
+struct NoDebug {
+    char c;
+    // padding of 63 bytes
+} __attribute__((__aligned__(64)));
+
+/**
+ * This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive
+ * Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because
+ * we determine Debug derive-ability before we compute padding, which happens at
+ * codegen.
+ */
+struct ShouldDeriveDebugButDoesNot {
+    char c[32];
+    char d;
+    // padding of 31 bytes
+} __attribute__((__aligned__(64)));
diff --git a/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h b/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h
new file mode 100644
index 00000000..f52a1b20
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-654-struct-fn-collision.h
@@ -0,0 +1,2 @@
+struct foo;
+int foo(void);
diff --git a/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp b/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
new file mode 100644
index 00000000..6b3f928b
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- --std=c++14
+
+template <class T> class RefPtr { T a; };
+template <class T> class nsMainThreadPtrHolder { T a; };
+template <class T> class nsMainThreadPtrHandle {
+    RefPtr<nsMainThreadPtrHolder<T>> mPtr;
+};
diff --git a/bindgen-tests/tests/headers/issue-662-part-2.hpp b/bindgen-tests/tests/headers/issue-662-part-2.hpp
new file mode 100644
index 00000000..1330c342
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-662-part-2.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --blocklist-type RefPtr --raw-line '#[derive(Clone, Copy, Debug)] pub struct RefPtr<T>(T);' -- --std=c++14
+
+// This is pretty much the same as the other issue 662 test case, but this time
+// we blocklist RefPtr to exercise the instantiation-of-a-blocklisted-template
+// path in the template analysis.
+
+template <class> class RefPtr {};
+template <class T> class nsMainThreadPtrHolder { T a; };
+template <class U> class nsMainThreadPtrHandle {
+    RefPtr<nsMainThreadPtrHolder<U>> mPtr;
+};
diff --git a/bindgen-tests/tests/headers/issue-674-1.hpp b/bindgen-tests/tests/headers/issue-674-1.hpp
new file mode 100644
index 00000000..7fc781c1
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-674-1.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type CapturingContentInfo --opaque-type 'mozilla::Maybe' -- -std=c++14
+
+namespace mozilla {
+template <class T> class Maybe { using ValueType = T; };
+}
+struct CapturingContentInfo {
+  mozilla::Maybe<float> a;
+};
diff --git a/bindgen-tests/tests/headers/issue-674-2.hpp b/bindgen-tests/tests/headers/issue-674-2.hpp
new file mode 100644
index 00000000..86d2b648
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-674-2.hpp
@@ -0,0 +1,15 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type StaticRefPtr --opaque-type 'JS::Rooted' -- -std=c++14
+
+namespace JS {
+template <typename T> class Rooted { using ElementType = T; };
+}
+class c {
+  JS::Rooted<int> b;
+};
+class B {
+  c a;
+};
+template <class> class StaticRefPtr {};
+struct {
+  StaticRefPtr<B> d;
+} e;
diff --git a/bindgen-tests/tests/headers/issue-674-3.hpp b/bindgen-tests/tests/headers/issue-674-3.hpp
new file mode 100644
index 00000000..20aa463c
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-674-3.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type nsCSSValue --opaque-type 'nsRefPtrHashtable' -- -std=c++14
+
+template <class PtrType> class nsRefPtrHashtable {
+  typedef PtrType *UserDataType;
+};
+struct a {
+  nsRefPtrHashtable<int> b;
+};
+class nsCSSValue {
+  a c;
+};
diff --git a/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp b/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp
new file mode 100644
index 00000000..ef2cea82
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-677-nested-ns-specifier.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --enable-cxx-namespaces -- -std=c++14
+
+namespace foo::bar {
+  typedef int bar;
+}
diff --git a/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp b/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp
new file mode 100644
index 00000000..f80e058d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-691-template-parameter-virtual.hpp
@@ -0,0 +1,12 @@
+class VirtualMethods {
+  virtual void foo();
+};
+
+template<typename K>
+class Set {
+  int bar;
+};
+
+class ServoElementSnapshotTable
+  : public Set<VirtualMethods>
+{};
diff --git a/bindgen-tests/tests/headers/issue-710-must-use-type.h b/bindgen-tests/tests/headers/issue-710-must-use-type.h
new file mode 100644
index 00000000..276f636d
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-710-must-use-type.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --must-use-type A
+
+struct A;
+
+/** <div rustbindgen mustusetype></div> */
+struct B;
+
+struct C;
diff --git a/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h b/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h
new file mode 100644
index 00000000..eeb7ae9c
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-739-pointer-wide-bitfield.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]'
+#define POINTER_WIDTH (sizeof(void*) * 8)
+
+struct Foo {
+  unsigned long m_bitfield: POINTER_WIDTH;
+  unsigned long m_bar: POINTER_WIDTH;
+  unsigned long foo: 1;
+  unsigned long bar: POINTER_WIDTH;
+};
diff --git a/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp b/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp
new file mode 100644
index 00000000..13c6dd1c
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-769-bad-instantiation-test.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --enable-cxx-namespaces --allowlist-type Rooted
+
+template <typename T>
+class Rooted {
+    T member;
+};
+
+class AutoValueVector : Rooted<int> {
+    using Alias = int;
+    using RootedAlias = Rooted<Alias>;
+};
diff --git a/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp b/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp
new file mode 100644
index 00000000..6b707f4e
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-801-opaque-sloppiness.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --opaque-type "B" --allowlist-type "C" --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+class A;
+
+class B {
+  static A a;
+};
+
+class C {
+  B b;
+};
diff --git a/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp b/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp
new file mode 100644
index 00000000..de98b32a
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-807-opaque-types-methods-being-generated.hpp
@@ -0,0 +1,36 @@
+// bindgen-flags: --allowlist-type Allowlisted --opaque-type Opaque --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
+
+// These types are not explicitly allowlisted, but are reachable through the
+// opaque type.
+class Pupper {};
+class Doggo {};
+class SuchWow {};
+
+// These types are not allowlisted, and would be reachable through `Opaque` if
+// it were not marked opaque, but since it is, there should be no bindings
+// generated for them.
+class NoBindingsShouldBeGeneratedForMe1 {};
+class NoBindingsShouldBeGeneratedForMe2 {};
+
+// Exercise the different kinds of outgoing edges from an opaque type.
+class Opaque
+  // Base member edge.
+  : public NoBindingsShouldBeGeneratedForMe1 {
+
+protected:
+    // Field edge.
+    NoBindingsShouldBeGeneratedForMe2 field;
+
+    // Constructor edge.
+    Opaque(Pupper pup);
+
+    // Inner static variable edge.
+    static Doggo MAJESTIC_AF;
+
+    // Method edge.
+    SuchWow eleven_out_of_ten();
+};
+
+class Allowlisted {
+    Opaque some_member;
+};
diff --git a/bindgen-tests/tests/headers/issue-816.h b/bindgen-tests/tests/headers/issue-816.h
new file mode 100644
index 00000000..5f16a178
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-816.h
@@ -0,0 +1,49 @@
+typedef struct {
+    unsigned int bit_1 : 1;
+    unsigned int bit_2 : 1;
+    unsigned int bit_3 : 1;
+    unsigned int bit_4 : 1;
+    unsigned int bit_5 : 1;
+    unsigned int bit_6 : 1;
+    unsigned int bit_7 : 1;
+    unsigned int bit_8 : 1;
+    unsigned int bit_9 : 1;
+    unsigned int bit_10 : 1;
+    unsigned int bit_11 : 1;
+    unsigned int bit_12 : 1;
+    unsigned int bit_13 : 1;
+    unsigned int bit_14 : 1;
+    unsigned int bit_15 : 1;
+    unsigned int bit_16 : 1;
+    unsigned int bit_17 : 1;
+    unsigned int bit_18 : 1;
+    unsigned int bit_19 : 1;
+    unsigned int bit_20 : 1;
+    unsigned int bit_21 : 1;
+    unsigned int bit_22 : 1;
+    unsigned int bit_23 : 1;
+    unsigned int bit_24 : 1;
+    unsigned int bit_25 : 1;
+    unsigned int bit_26 : 1;
+    unsigned int bit_27 : 1;
+    unsigned int bit_28 : 1;
+    unsigned int bit_29 : 1;
+    unsigned int bit_30 : 1;
+    unsigned int bit_31 : 1;
+    unsigned int bit_32 : 1;
+    unsigned int bit_33 : 1;
+    unsigned int bit_34 : 1;
+    unsigned int bit_35 : 1;
+    unsigned int bit_36 : 1;
+    unsigned int bit_37 : 1;
+    unsigned int bit_38 : 1;
+    unsigned int bit_39 : 1;
+    unsigned int bit_40 : 1;
+    unsigned int bit_41 : 1;
+    unsigned int : 7;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+} capabilities;
diff --git a/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp b/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp
new file mode 100644
index 00000000..ca5d8b96
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-820-unused-template-param-in-alias.hpp
@@ -0,0 +1,5 @@
+template<typename E, int N>
+class Foo {
+    typedef Foo<E, N> self_type;
+    E mBar;
+};
diff --git a/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp b/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
new file mode 100644
index 00000000..f6b2ed30
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --ignore-methods -- --target=i686-pc-win32
+
+struct Foo {
+    void test();
+};
diff --git a/bindgen-tests/tests/headers/issue-833-1.hpp b/bindgen-tests/tests/headers/issue-833-1.hpp
new file mode 100644
index 00000000..d66ee01f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-833-1.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray { pub hdr: *const () }"
+
+template<typename T>
+class nsTArray {
+  static T* sFoo;
+};
+
+extern "C" nsTArray<int>* func();
diff --git a/bindgen-tests/tests/headers/issue-833-2.hpp b/bindgen-tests/tests/headers/issue-833-2.hpp
new file mode 100644
index 00000000..487c5607
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-833-2.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --raw-line "// If the output of this changes, please ensure issue-833-1.hpp changes too"
+
+template<typename T>
+class nsTArray {
+  static T* sFoo;
+};
diff --git a/bindgen-tests/tests/headers/issue-833.hpp b/bindgen-tests/tests/headers/issue-833.hpp
new file mode 100644
index 00000000..f8b708bf
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-833.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray<T> { pub hdr: *const T }"
+
+template<typename T>
+class nsTArray {
+  T* mHeader;
+};
+
+extern "C" nsTArray<int>* func();
diff --git a/bindgen-tests/tests/headers/issue-834.hpp b/bindgen-tests/tests/headers/issue-834.hpp
new file mode 100644
index 00000000..64797012
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-834.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --allowlist-type U --generate types
+
+struct T {};
+struct U {
+  void test(T a);
+};
diff --git a/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp b/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp
new file mode 100644
index 00000000..e95c823f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-848-replacement-system-include.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -Itests/headers/issue-848
+
+#include "an-include.h"
+
+extern "C" {
+  nsTArray<int>* func();
+}
diff --git a/bindgen-tests/tests/headers/issue-848/an-include.h b/bindgen-tests/tests/headers/issue-848/an-include.h
new file mode 100644
index 00000000..0421d19f
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-848/an-include.h
@@ -0,0 +1,17 @@
+template<typename T>
+class nsTArray {
+  void* mBuffer;
+};
+
+/**
+ * This is intended to replace another type, but won't if we treat this include
+ * as a system include, because clang doesn't parse comments there.
+ *
+ * See #848.
+ *
+ * <div rustbindgen replaces="nsTArray"></div>
+ */
+template<typename T>
+class nsTArray_Simple {
+  T* m;
+};
diff --git a/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp b/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp
new file mode 100644
index 00000000..fa4ba56b
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-888-enum-var-decl-jump.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*"
+
+namespace Halide {
+struct Type;
+}
+typedef enum {} a;
+namespace Halide {
+struct Type {
+  static a b;
+};
+}
diff --git a/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp b/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp
new file mode 100644
index 00000000..5e94dfab
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-944-derive-copy-and-blocklisting.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
+
+struct BlocklistMe {};
+
+/**
+ * Because this type contains a blocklisted type, it should not derive Copy.
+ */
+struct ShouldNotBeCopy {
+    BlocklistMe a;
+};
diff --git a/bindgen-tests/tests/headers/issue-946.h b/bindgen-tests/tests/headers/issue-946.h
new file mode 100644
index 00000000..5d145e09
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue-946.h
@@ -0,0 +1,5 @@
+struct foo { };
+
+typedef struct foo bar;
+
+typedef bar foo;
diff --git a/bindgen-tests/tests/headers/issue_311.hpp b/bindgen-tests/tests/headers/issue_311.hpp
new file mode 100644
index 00000000..a8d7fd99
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue_311.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+struct jsval_layout {
+  struct {};
+};
diff --git a/bindgen-tests/tests/headers/issue_315.hpp b/bindgen-tests/tests/headers/issue_315.hpp
new file mode 100644
index 00000000..e58cb5e3
--- /dev/null
+++ b/bindgen-tests/tests/headers/issue_315.hpp
@@ -0,0 +1,2 @@
+/// <div rustbindgen replaces="c"></div>
+template <typename a> using b = a;
diff --git a/bindgen-tests/tests/headers/jsval_layout_opaque.hpp b/bindgen-tests/tests/headers/jsval_layout_opaque.hpp
new file mode 100644
index 00000000..ef13b85b
--- /dev/null
+++ b/bindgen-tests/tests/headers/jsval_layout_opaque.hpp
@@ -0,0 +1,425 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+// bindgen-flags: -- -std=c++11
+
+/**
+ * These typedefs are hacky, but keep our tests consistent across 64-bit
+ * platforms, otherwise the id's change and our CI is unhappy.
+ */
+typedef unsigned char uint8_t;
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long long size_t;
+typedef unsigned long long uintptr_t;
+
+
+#define JS_PUNBOX64
+#define IS_LITTLE_ENDIAN
+
+/*
+ * Try to get jsvals 64-bit aligned. We could almost assert that all values are
+ * aligned, but MSVC and GCC occasionally break alignment.
+ */
+#if defined(__GNUC__) || defined(__xlc__) || defined(__xlC__)
+# define JSVAL_ALIGNMENT        __attribute__((aligned (8)))
+#elif defined(_MSC_VER)
+  /*
+   * Structs can be aligned with MSVC, but not if they are used as parameters,
+   * so we just don't try to align.
+   */
+# define JSVAL_ALIGNMENT
+#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# define JSVAL_ALIGNMENT
+#elif defined(__HP_cc) || defined(__HP_aCC)
+# define JSVAL_ALIGNMENT
+#endif
+
+#if defined(JS_PUNBOX64)
+# define JSVAL_TAG_SHIFT 47
+#endif
+
+/*
+ * We try to use enums so that printing a jsval_layout in the debugger shows
+ * nice symbolic type tags, however we can only do this when we can force the
+ * underlying type of the enum to be the desired size.
+ */
+#if !defined(__SUNPRO_CC) && !defined(__xlC__)
+
+#if defined(_MSC_VER)
+# define JS_ENUM_HEADER(id, type)              enum id : type
+# define JS_ENUM_FOOTER(id)
+#else
+# define JS_ENUM_HEADER(id, type)              enum id
+# define JS_ENUM_FOOTER(id)                    __attribute__((packed))
+#endif
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueType, uint8_t)
+{
+    JSVAL_TYPE_DOUBLE              = 0x00,
+    JSVAL_TYPE_INT32               = 0x01,
+    JSVAL_TYPE_UNDEFINED           = 0x02,
+    JSVAL_TYPE_BOOLEAN             = 0x03,
+    JSVAL_TYPE_MAGIC               = 0x04,
+    JSVAL_TYPE_STRING              = 0x05,
+    JSVAL_TYPE_SYMBOL              = 0x06,
+    JSVAL_TYPE_NULL                = 0x07,
+    JSVAL_TYPE_OBJECT              = 0x08,
+
+    /* These never appear in a jsval; they are only provided as an out-of-band value. */
+    JSVAL_TYPE_UNKNOWN             = 0x20,
+    JSVAL_TYPE_MISSING             = 0x21
+} JS_ENUM_FOOTER(JSValueType);
+
+static_assert(sizeof(JSValueType) == 1,
+              "compiler typed enum support is apparently buggy");
+
+#if defined(JS_NUNBOX32)
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueTag, uint32_t)
+{
+    JSVAL_TAG_CLEAR                = 0xFFFFFF80,
+    JSVAL_TAG_INT32                = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
+    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
+    JSVAL_TAG_STRING               = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
+    JSVAL_TAG_SYMBOL               = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
+    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
+    JSVAL_TAG_MAGIC                = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
+    JSVAL_TAG_NULL                 = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
+    JSVAL_TAG_OBJECT               = JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT
+} JS_ENUM_FOOTER(JSValueTag);
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+#elif defined(JS_PUNBOX64)
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueTag, uint32_t)
+{
+    JSVAL_TAG_MAX_DOUBLE           = 0x1FFF0,
+    JSVAL_TAG_INT32                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
+    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
+    JSVAL_TAG_STRING               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
+    JSVAL_TAG_SYMBOL               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
+    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
+    JSVAL_TAG_MAGIC                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
+    JSVAL_TAG_NULL                 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
+    JSVAL_TAG_OBJECT               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
+} JS_ENUM_FOOTER(JSValueTag);
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+JS_ENUM_HEADER(JSValueShiftedTag, uint64_t)
+{
+    JSVAL_SHIFTED_TAG_MAX_DOUBLE   = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
+    JSVAL_SHIFTED_TAG_INT32        = (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_UNDEFINED    = (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_STRING       = (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_SYMBOL       = (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_BOOLEAN      = (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_MAGIC        = (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_NULL         = (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_OBJECT       = (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
+} JS_ENUM_FOOTER(JSValueShiftedTag);
+
+static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
+              "compiler typed enum support is apparently buggy");
+
+#endif
+
+/*
+ * All our supported compilers implement C++11 |enum Foo : T| syntax, so don't
+ * expose these macros. (This macro exists *only* because gcc bug 51242
+ * <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51242> makes bit-fields of
+ * typed enums trigger a warning that can't be turned off. Don't expose it
+ * beyond this file!)
+ */
+#undef JS_ENUM_HEADER
+#undef JS_ENUM_FOOTER
+
+#else  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
+
+typedef uint8_t JSValueType;
+#define JSVAL_TYPE_DOUBLE            ((uint8_t)0x00)
+#define JSVAL_TYPE_INT32             ((uint8_t)0x01)
+#define JSVAL_TYPE_UNDEFINED         ((uint8_t)0x02)
+#define JSVAL_TYPE_BOOLEAN           ((uint8_t)0x03)
+#define JSVAL_TYPE_MAGIC             ((uint8_t)0x04)
+#define JSVAL_TYPE_STRING            ((uint8_t)0x05)
+#define JSVAL_TYPE_SYMBOL            ((uint8_t)0x06)
+#define JSVAL_TYPE_NULL              ((uint8_t)0x07)
+#define JSVAL_TYPE_OBJECT            ((uint8_t)0x08)
+#define JSVAL_TYPE_UNKNOWN           ((uint8_t)0x20)
+
+#if defined(JS_NUNBOX32)
+
+typedef uint32_t JSValueTag;
+#define JSVAL_TAG_CLEAR              ((uint32_t)(0xFFFFFF80))
+#define JSVAL_TAG_INT32              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32))
+#define JSVAL_TAG_UNDEFINED          ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED))
+#define JSVAL_TAG_STRING             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING))
+#define JSVAL_TAG_SYMBOL             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL))
+#define JSVAL_TAG_BOOLEAN            ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN))
+#define JSVAL_TAG_MAGIC              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC))
+#define JSVAL_TAG_NULL               ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL))
+#define JSVAL_TAG_OBJECT             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT))
+
+#elif defined(JS_PUNBOX64)
+
+typedef uint32_t JSValueTag;
+#define JSVAL_TAG_MAX_DOUBLE         ((uint32_t)(0x1FFF0))
+#define JSVAL_TAG_INT32              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32)
+#define JSVAL_TAG_UNDEFINED          (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED)
+#define JSVAL_TAG_STRING             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING)
+#define JSVAL_TAG_SYMBOL             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL)
+#define JSVAL_TAG_BOOLEAN            (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN)
+#define JSVAL_TAG_MAGIC              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC)
+#define JSVAL_TAG_NULL               (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL)
+#define JSVAL_TAG_OBJECT             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT)
+
+typedef uint64_t JSValueShiftedTag;
+#define JSVAL_SHIFTED_TAG_MAX_DOUBLE ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF)
+#define JSVAL_SHIFTED_TAG_INT32      (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_UNDEFINED  (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_STRING     (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_SYMBOL     (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_BOOLEAN    (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_MAGIC      (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_NULL       (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_OBJECT     (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
+
+#endif  /* JS_PUNBOX64 */
+#endif  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
+
+#if defined(JS_NUNBOX32)
+
+#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_CLEAR | (type)))
+
+#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
+#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
+#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
+#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
+
+#elif defined(JS_PUNBOX64)
+
+#define JSVAL_PAYLOAD_MASK           0x00007FFFFFFFFFFFLL
+#define JSVAL_TAG_MASK               0xFFFF800000000000LL
+#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_MAX_DOUBLE | (type)))
+#define JSVAL_TYPE_TO_SHIFTED_TAG(type) (((uint64_t)JSVAL_TYPE_TO_TAG(type)) << JSVAL_TAG_SHIFT)
+
+#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
+#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
+#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
+#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
+
+#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET  JSVAL_SHIFTED_TAG_NULL
+#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET    JSVAL_SHIFTED_TAG_OBJECT
+#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET       JSVAL_SHIFTED_TAG_UNDEFINED
+#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET      JSVAL_SHIFTED_TAG_STRING
+
+#endif /* JS_PUNBOX64 */
+
+typedef enum JSWhyMagic
+{
+    /** a hole in a native object's elements */
+    JS_ELEMENTS_HOLE,
+
+    /** there is not a pending iterator value */
+    JS_NO_ITER_VALUE,
+
+    /** exception value thrown when closing a generator */
+    JS_GENERATOR_CLOSING,
+
+    /** compiler sentinel value */
+    JS_NO_CONSTANT,
+
+    /** used in debug builds to catch tracing errors */
+    JS_THIS_POISON,
+
+    /** used in debug builds to catch tracing errors */
+    JS_ARG_POISON,
+
+    /** an empty subnode in the AST serializer */
+    JS_SERIALIZE_NO_NODE,
+
+    /** lazy arguments value on the stack */
+    JS_LAZY_ARGUMENTS,
+
+    /** optimized-away 'arguments' value */
+    JS_OPTIMIZED_ARGUMENTS,
+
+    /** magic value passed to natives to indicate construction */
+    JS_IS_CONSTRUCTING,
+
+    /** arguments.callee has been overwritten */
+    JS_OVERWRITTEN_CALLEE,
+
+    /** value of static block object slot */
+    JS_BLOCK_NEEDS_CLONE,
+
+    /** see class js::HashableValue */
+    JS_HASH_KEY_EMPTY,
+
+    /** error while running Ion code */
+    JS_ION_ERROR,
+
+    /** missing recover instruction result */
+    JS_ION_BAILOUT,
+
+    /** optimized out slot */
+    JS_OPTIMIZED_OUT,
+
+    /** uninitialized lexical bindings that produce ReferenceError on touch. */
+    JS_UNINITIALIZED_LEXICAL,
+
+    /** for local use */
+    JS_GENERIC_MAGIC,
+
+    JS_WHY_MAGIC_COUNT
+} JSWhyMagic;
+
+#if defined(IS_LITTLE_ENDIAN)
+# if defined(JS_NUNBOX32)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
+            JSString*      str;
+            JS::Symbol*    sym;
+            JSObject*      obj;
+            js::gc::Cell*  cell;
+            void*          ptr;
+            JSWhyMagic     why;
+            size_t         word;
+            uintptr_t      uintptr;
+        } payload;
+        JSValueTag tag;
+    } s;
+    double asDouble;
+    void* asPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# elif defined(JS_PUNBOX64)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+#if !defined(_WIN64)
+    /* MSVC does not pack these correctly :-( */
+    struct {
+        uint64_t           payload47 : 47;
+        JSValueTag         tag : 17;
+    } debugView;
+#endif
+    struct {
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            JSWhyMagic     why;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+    size_t asWord;
+    uintptr_t asUIntPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# endif  /* JS_PUNBOX64 */
+#else   /* defined(IS_LITTLE_ENDIAN) */
+# if defined(JS_NUNBOX32)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        JSValueTag tag;
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
+            JSString*      str;
+            JS::Symbol*    sym;
+            JSObject*      obj;
+            js::gc::Cell*  cell;
+            void*          ptr;
+            JSWhyMagic     why;
+            size_t         word;
+            uintptr_t      uintptr;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# elif defined(JS_PUNBOX64)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        JSValueTag         tag : 17;
+        uint64_t           payload47 : 47;
+    } debugView;
+    struct {
+        uint32_t           padding;
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            JSWhyMagic     why;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+    size_t asWord;
+    uintptr_t asUIntPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# endif /* JS_PUNBOX64 */
+#endif  /* defined(IS_LITTLE_ENDIAN) */
+
+/*
+ * For codesize purposes on some platforms, it's important that the
+ * compiler know that JS::Values constructed from constant values can be
+ * folded to constant bit patterns at compile time, rather than
+ * constructed at runtime.  Doing this requires a fair amount of C++11
+ * features, which are not supported on all of our compilers.  Set up
+ * some defines and helper macros in an attempt to confine the ugliness
+ * here, rather than scattering it all about the file.  The important
+ * features are:
+ *
+ * - constexpr;
+ * - defaulted functions;
+ * - C99-style designated initializers.
+ */
+#if defined(__clang__)
+#  if __has_feature(cxx_constexpr) && __has_feature(cxx_defaulted_functions)
+#    define JS_VALUE_IS_CONSTEXPR
+#  endif
+#elif defined(__GNUC__)
+/*
+ * We need 4.5 for defaulted functions, 4.6 for constexpr, 4.7 because 4.6
+ * doesn't understand |(X) { .field = ... }| syntax, and 4.7.3 because
+ * versions prior to that have bugs in the C++ front-end that cause crashes.
+ */
+#  if MOZ_GCC_VERSION_AT_LEAST(4, 7, 3)
+#    define JS_VALUE_IS_CONSTEXPR
+#  endif
+#endif
+
+#if defined(JS_VALUE_IS_CONSTEXPR)
+#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
+    return (jsval_layout) { .asBits = (BITS) }
+#  define JS_VALUE_CONSTEXPR MOZ_CONSTEXPR
+#  define JS_VALUE_CONSTEXPR_VAR MOZ_CONSTEXPR_VAR
+#else
+#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
+    jsval_layout l;                        \
+    l.asBits = (BITS);                     \
+    return l;
+#  define JS_VALUE_CONSTEXPR
+#  define JS_VALUE_CONSTEXPR_VAR const
+#endif
+
+struct Value {
+    jsval_layout data;
+};
diff --git a/bindgen-tests/tests/headers/jsval_layout_opaque_1_0.hpp b/bindgen-tests/tests/headers/jsval_layout_opaque_1_0.hpp
new file mode 100644
index 00000000..c8e66551
--- /dev/null
+++ b/bindgen-tests/tests/headers/jsval_layout_opaque_1_0.hpp
@@ -0,0 +1,425 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+// bindgen-flags: -- -std=c++11
+
+/**
+ * These typedefs are hacky, but keep our tests consistent across 64-bit
+ * platforms, otherwise the id's change and our CI is unhappy.
+ */
+typedef unsigned char uint8_t;
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long long size_t;
+typedef unsigned long long uintptr_t;
+
+
+#define JS_PUNBOX64
+#define IS_LITTLE_ENDIAN
+
+/*
+ * Try to get jsvals 64-bit aligned. We could almost assert that all values are
+ * aligned, but MSVC and GCC occasionally break alignment.
+ */
+#if defined(__GNUC__) || defined(__xlc__) || defined(__xlC__)
+# define JSVAL_ALIGNMENT        __attribute__((aligned (8)))
+#elif defined(_MSC_VER)
+  /*
+   * Structs can be aligned with MSVC, but not if they are used as parameters,
+   * so we just don't try to align.
+   */
+# define JSVAL_ALIGNMENT
+#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# define JSVAL_ALIGNMENT
+#elif defined(__HP_cc) || defined(__HP_aCC)
+# define JSVAL_ALIGNMENT
+#endif
+
+#if defined(JS_PUNBOX64)
+# define JSVAL_TAG_SHIFT 47
+#endif
+
+/*
+ * We try to use enums so that printing a jsval_layout in the debugger shows
+ * nice symbolic type tags, however we can only do this when we can force the
+ * underlying type of the enum to be the desired size.
+ */
+#if !defined(__SUNPRO_CC) && !defined(__xlC__)
+
+#if defined(_MSC_VER)
+# define JS_ENUM_HEADER(id, type)              enum id : type
+# define JS_ENUM_FOOTER(id)
+#else
+# define JS_ENUM_HEADER(id, type)              enum id
+# define JS_ENUM_FOOTER(id)                    __attribute__((packed))
+#endif
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueType, uint8_t)
+{
+    JSVAL_TYPE_DOUBLE              = 0x00,
+    JSVAL_TYPE_INT32               = 0x01,
+    JSVAL_TYPE_UNDEFINED           = 0x02,
+    JSVAL_TYPE_BOOLEAN             = 0x03,
+    JSVAL_TYPE_MAGIC               = 0x04,
+    JSVAL_TYPE_STRING              = 0x05,
+    JSVAL_TYPE_SYMBOL              = 0x06,
+    JSVAL_TYPE_NULL                = 0x07,
+    JSVAL_TYPE_OBJECT              = 0x08,
+
+    /* These never appear in a jsval; they are only provided as an out-of-band value. */
+    JSVAL_TYPE_UNKNOWN             = 0x20,
+    JSVAL_TYPE_MISSING             = 0x21
+} JS_ENUM_FOOTER(JSValueType);
+
+static_assert(sizeof(JSValueType) == 1,
+              "compiler typed enum support is apparently buggy");
+
+#if defined(JS_NUNBOX32)
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueTag, uint32_t)
+{
+    JSVAL_TAG_CLEAR                = 0xFFFFFF80,
+    JSVAL_TAG_INT32                = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
+    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
+    JSVAL_TAG_STRING               = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
+    JSVAL_TAG_SYMBOL               = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
+    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
+    JSVAL_TAG_MAGIC                = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
+    JSVAL_TAG_NULL                 = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
+    JSVAL_TAG_OBJECT               = JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT
+} JS_ENUM_FOOTER(JSValueTag);
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+#elif defined(JS_PUNBOX64)
+
+/* Remember to propagate changes to the C defines below. */
+JS_ENUM_HEADER(JSValueTag, uint32_t)
+{
+    JSVAL_TAG_MAX_DOUBLE           = 0x1FFF0,
+    JSVAL_TAG_INT32                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
+    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
+    JSVAL_TAG_STRING               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
+    JSVAL_TAG_SYMBOL               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
+    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
+    JSVAL_TAG_MAGIC                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
+    JSVAL_TAG_NULL                 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
+    JSVAL_TAG_OBJECT               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
+} JS_ENUM_FOOTER(JSValueTag);
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+JS_ENUM_HEADER(JSValueShiftedTag, uint64_t)
+{
+    JSVAL_SHIFTED_TAG_MAX_DOUBLE   = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
+    JSVAL_SHIFTED_TAG_INT32        = (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_UNDEFINED    = (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_STRING       = (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_SYMBOL       = (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_BOOLEAN      = (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_MAGIC        = (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_NULL         = (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT),
+    JSVAL_SHIFTED_TAG_OBJECT       = (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
+} JS_ENUM_FOOTER(JSValueShiftedTag);
+
+static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
+              "compiler typed enum support is apparently buggy");
+
+#endif
+
+/*
+ * All our supported compilers implement C++11 |enum Foo : T| syntax, so don't
+ * expose these macros. (This macro exists *only* because gcc bug 51242
+ * <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51242> makes bit-fields of
+ * typed enums trigger a warning that can't be turned off. Don't expose it
+ * beyond this file!)
+ */
+#undef JS_ENUM_HEADER
+#undef JS_ENUM_FOOTER
+
+#else  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
+
+typedef uint8_t JSValueType;
+#define JSVAL_TYPE_DOUBLE            ((uint8_t)0x00)
+#define JSVAL_TYPE_INT32             ((uint8_t)0x01)
+#define JSVAL_TYPE_UNDEFINED         ((uint8_t)0x02)
+#define JSVAL_TYPE_BOOLEAN           ((uint8_t)0x03)
+#define JSVAL_TYPE_MAGIC             ((uint8_t)0x04)
+#define JSVAL_TYPE_STRING            ((uint8_t)0x05)
+#define JSVAL_TYPE_SYMBOL            ((uint8_t)0x06)
+#define JSVAL_TYPE_NULL              ((uint8_t)0x07)
+#define JSVAL_TYPE_OBJECT            ((uint8_t)0x08)
+#define JSVAL_TYPE_UNKNOWN           ((uint8_t)0x20)
+
+#if defined(JS_NUNBOX32)
+
+typedef uint32_t JSValueTag;
+#define JSVAL_TAG_CLEAR              ((uint32_t)(0xFFFFFF80))
+#define JSVAL_TAG_INT32              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32))
+#define JSVAL_TAG_UNDEFINED          ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED))
+#define JSVAL_TAG_STRING             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING))
+#define JSVAL_TAG_SYMBOL             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL))
+#define JSVAL_TAG_BOOLEAN            ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN))
+#define JSVAL_TAG_MAGIC              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC))
+#define JSVAL_TAG_NULL               ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL))
+#define JSVAL_TAG_OBJECT             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT))
+
+#elif defined(JS_PUNBOX64)
+
+typedef uint32_t JSValueTag;
+#define JSVAL_TAG_MAX_DOUBLE         ((uint32_t)(0x1FFF0))
+#define JSVAL_TAG_INT32              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32)
+#define JSVAL_TAG_UNDEFINED          (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED)
+#define JSVAL_TAG_STRING             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING)
+#define JSVAL_TAG_SYMBOL             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL)
+#define JSVAL_TAG_BOOLEAN            (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN)
+#define JSVAL_TAG_MAGIC              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC)
+#define JSVAL_TAG_NULL               (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL)
+#define JSVAL_TAG_OBJECT             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT)
+
+typedef uint64_t JSValueShiftedTag;
+#define JSVAL_SHIFTED_TAG_MAX_DOUBLE ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF)
+#define JSVAL_SHIFTED_TAG_INT32      (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_UNDEFINED  (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_STRING     (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_SYMBOL     (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_BOOLEAN    (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_MAGIC      (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_NULL       (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT)
+#define JSVAL_SHIFTED_TAG_OBJECT     (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
+
+#endif  /* JS_PUNBOX64 */
+#endif  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
+
+#if defined(JS_NUNBOX32)
+
+#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_CLEAR | (type)))
+
+#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
+#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
+#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
+#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
+
+#elif defined(JS_PUNBOX64)
+
+#define JSVAL_PAYLOAD_MASK           0x00007FFFFFFFFFFFLL
+#define JSVAL_TAG_MASK               0xFFFF800000000000LL
+#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_MAX_DOUBLE | (type)))
+#define JSVAL_TYPE_TO_SHIFTED_TAG(type) (((uint64_t)JSVAL_TYPE_TO_TAG(type)) << JSVAL_TAG_SHIFT)
+
+#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
+#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
+#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
+#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
+
+#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET  JSVAL_SHIFTED_TAG_NULL
+#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET    JSVAL_SHIFTED_TAG_OBJECT
+#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET       JSVAL_SHIFTED_TAG_UNDEFINED
+#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET      JSVAL_SHIFTED_TAG_STRING
+
+#endif /* JS_PUNBOX64 */
+
+typedef enum JSWhyMagic
+{
+    /** a hole in a native object's elements */
+    JS_ELEMENTS_HOLE,
+
+    /** there is not a pending iterator value */
+    JS_NO_ITER_VALUE,
+
+    /** exception value thrown when closing a generator */
+    JS_GENERATOR_CLOSING,
+
+    /** compiler sentinel value */
+    JS_NO_CONSTANT,
+
+    /** used in debug builds to catch tracing errors */
+    JS_THIS_POISON,
+
+    /** used in debug builds to catch tracing errors */
+    JS_ARG_POISON,
+
+    /** an empty subnode in the AST serializer */
+    JS_SERIALIZE_NO_NODE,
+
+    /** lazy arguments value on the stack */
+    JS_LAZY_ARGUMENTS,
+
+    /** optimized-away 'arguments' value */
+    JS_OPTIMIZED_ARGUMENTS,
+
+    /** magic value passed to natives to indicate construction */
+    JS_IS_CONSTRUCTING,
+
+    /** arguments.callee has been overwritten */
+    JS_OVERWRITTEN_CALLEE,
+
+    /** value of static block object slot */
+    JS_BLOCK_NEEDS_CLONE,
+
+    /** see class js::HashableValue */
+    JS_HASH_KEY_EMPTY,
+
+    /** error while running Ion code */
+    JS_ION_ERROR,
+
+    /** missing recover instruction result */
+    JS_ION_BAILOUT,
+
+    /** optimized out slot */
+    JS_OPTIMIZED_OUT,
+
+    /** uninitialized lexical bindings that produce ReferenceError on touch. */
+    JS_UNINITIALIZED_LEXICAL,
+
+    /** for local use */
+    JS_GENERIC_MAGIC,
+
+    JS_WHY_MAGIC_COUNT
+} JSWhyMagic;
+
+#if defined(IS_LITTLE_ENDIAN)
+# if defined(JS_NUNBOX32)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
+            JSString*      str;
+            JS::Symbol*    sym;
+            JSObject*      obj;
+            js::gc::Cell*  cell;
+            void*          ptr;
+            JSWhyMagic     why;
+            size_t         word;
+            uintptr_t      uintptr;
+        } payload;
+        JSValueTag tag;
+    } s;
+    double asDouble;
+    void* asPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# elif defined(JS_PUNBOX64)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+#if !defined(_WIN64)
+    /* MSVC does not pack these correctly :-( */
+    struct {
+        uint64_t           payload47 : 47;
+        JSValueTag         tag : 17;
+    } debugView;
+#endif
+    struct {
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            JSWhyMagic     why;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+    size_t asWord;
+    uintptr_t asUIntPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# endif  /* JS_PUNBOX64 */
+#else   /* defined(IS_LITTLE_ENDIAN) */
+# if defined(JS_NUNBOX32)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        JSValueTag tag;
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
+            JSString*      str;
+            JS::Symbol*    sym;
+            JSObject*      obj;
+            js::gc::Cell*  cell;
+            void*          ptr;
+            JSWhyMagic     why;
+            size_t         word;
+            uintptr_t      uintptr;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# elif defined(JS_PUNBOX64)
+typedef union jsval_layout
+{
+    uint64_t asBits;
+    struct {
+        JSValueTag         tag : 17;
+        uint64_t           payload47 : 47;
+    } debugView;
+    struct {
+        uint32_t           padding;
+        union {
+            int32_t        i32;
+            uint32_t       u32;
+            JSWhyMagic     why;
+        } payload;
+    } s;
+    double asDouble;
+    void* asPtr;
+    size_t asWord;
+    uintptr_t asUIntPtr;
+} JSVAL_ALIGNMENT jsval_layout;
+# endif /* JS_PUNBOX64 */
+#endif  /* defined(IS_LITTLE_ENDIAN) */
+
+/*
+ * For codesize purposes on some platforms, it's important that the
+ * compiler know that JS::Values constructed from constant values can be
+ * folded to constant bit patterns at compile time, rather than
+ * constructed at runtime.  Doing this requires a fair amount of C++11
+ * features, which are not supported on all of our compilers.  Set up
+ * some defines and helper macros in an attempt to confine the ugliness
+ * here, rather than scattering it all about the file.  The important
+ * features are:
+ *
+ * - constexpr;
+ * - defaulted functions;
+ * - C99-style designated initializers.
+ */
+#if defined(__clang__)
+#  if __has_feature(cxx_constexpr) && __has_feature(cxx_defaulted_functions)
+#    define JS_VALUE_IS_CONSTEXPR
+#  endif
+#elif defined(__GNUC__)
+/*
+ * We need 4.5 for defaulted functions, 4.6 for constexpr, 4.7 because 4.6
+ * doesn't understand |(X) { .field = ... }| syntax, and 4.7.3 because
+ * versions prior to that have bugs in the C++ front-end that cause crashes.
+ */
+#  if MOZ_GCC_VERSION_AT_LEAST(4, 7, 3)
+#    define JS_VALUE_IS_CONSTEXPR
+#  endif
+#endif
+
+#if defined(JS_VALUE_IS_CONSTEXPR)
+#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
+    return (jsval_layout) { .asBits = (BITS) }
+#  define JS_VALUE_CONSTEXPR MOZ_CONSTEXPR
+#  define JS_VALUE_CONSTEXPR_VAR MOZ_CONSTEXPR_VAR
+#else
+#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
+    jsval_layout l;                        \
+    l.asBits = (BITS);                     \
+    return l;
+#  define JS_VALUE_CONSTEXPR
+#  define JS_VALUE_CONSTEXPR_VAR const
+#endif
+
+struct Value {
+    jsval_layout data;
+};
diff --git a/bindgen-tests/tests/headers/keywords.h b/bindgen-tests/tests/headers/keywords.h
new file mode 100644
index 00000000..3b3fc497
--- /dev/null
+++ b/bindgen-tests/tests/headers/keywords.h
@@ -0,0 +1,56 @@
+int u8;
+int u16;
+int u32;
+int u64;
+int i8;
+int i16;
+int i32;
+int i64;
+int f32;
+int f64;
+int usize;
+int isize;
+int bool;
+int str;
+int dyn;
+
+int as;
+int async;
+int await;
+int box;
+int crate;
+int false;
+int fn;
+int impl;
+int in;
+int let;
+int loop;
+int match;
+int mod;
+int move;
+int mut;
+int pub;
+int ref;
+int self;
+int Self;
+int super;
+int trait;
+int true;
+int try;
+int type;
+int unsafe;
+int use;
+int where;
+int abstract;
+int alignof;
+int become;
+int final;
+int macro;
+int offsetof;
+int override;
+int priv;
+int proc;
+int pure;
+int unsized;
+int virtual;
+int yield;
diff --git a/bindgen-tests/tests/headers/layout.h b/bindgen-tests/tests/headers/layout.h
new file mode 100644
index 00000000..b290ee85
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --rust-target 1.21
+//
+// FIXME: https://github.com/rust-lang/rust-bindgen/issues/1498
+
+struct header
+{
+    char proto;
+    unsigned int size __attribute__ ((packed));
+    unsigned char data[] __attribute__ ((aligned(8)));
+} __attribute__ ((aligned, packed));
diff --git a/bindgen-tests/tests/headers/layout_align.h b/bindgen-tests/tests/headers/layout_align.h
new file mode 100644
index 00000000..0201877e
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_align.h
@@ -0,0 +1,20 @@
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+struct rte_kni_fifo {
+	volatile unsigned write;     /**< Next position to be written*/
+	volatile unsigned read;      /**< Next position to be read */
+	unsigned len;                /**< Circular buffer length */
+	unsigned elem_size;          /**< Pointer size - for 32/64 bit OS */
+	void *volatile buffer[];     /**< The buffer contains mbuf pointers */
+};
+
+__extension__
+struct rte_eth_link {
+	uint32_t link_speed;        /**< ETH_SPEED_NUM_ */
+	uint16_t link_duplex  : 1;  /**< ETH_LINK_[HALF/FULL]_DUPLEX */
+	uint16_t link_autoneg : 1;  /**< ETH_LINK_SPEED_[AUTONEG/FIXED] */
+	uint16_t link_status  : 1;  /**< ETH_LINK_[DOWN/UP] */
+} __attribute__((aligned(8)));      /**< aligned for atomic64 read/write */
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/layout_arp.h b/bindgen-tests/tests/headers/layout_arp.h
new file mode 100644
index 00000000..8682cbe0
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_arp.h
@@ -0,0 +1,52 @@
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+#define ETHER_ADDR_LEN  6 /**< Length of Ethernet address. */
+
+/**
+ * Ethernet address:
+ * A universally administered address is uniquely assigned to a device by its
+ * manufacturer. The first three octets (in transmission order) contain the
+ * Organizationally Unique Identifier (OUI). The following three (MAC-48 and
+ * EUI-48) octets are assigned by that organization with the only constraint
+ * of uniqueness.
+ * A locally administered address is assigned to a device by a network
+ * administrator and does not contain OUIs.
+ * See http://standards.ieee.org/regauth/groupmac/tutorial.html
+ */
+struct ether_addr {
+	uint8_t addr_bytes[ETHER_ADDR_LEN]; /**< Addr bytes in tx order */
+} __attribute__((__packed__));
+
+/**
+ * ARP header IPv4 payload.
+ */
+struct arp_ipv4 {
+	struct ether_addr arp_sha;  /**< sender hardware address */
+	uint32_t          arp_sip;  /**< sender IP address */
+	struct ether_addr arp_tha;  /**< target hardware address */
+	uint32_t          arp_tip;  /**< target IP address */
+} __attribute__((__packed__));
+
+/**
+ * ARP header.
+ */
+struct arp_hdr {
+	uint16_t arp_hrd;    /* format of hardware address */
+#define ARP_HRD_ETHER     1  /* ARP Ethernet address format */
+
+	uint16_t arp_pro;    /* format of protocol address */
+	uint8_t  arp_hln;    /* length of hardware address */
+	uint8_t  arp_pln;    /* length of protocol address */
+	uint16_t arp_op;     /* ARP opcode (command) */
+#define	ARP_OP_REQUEST    1 /* request to resolve address */
+#define	ARP_OP_REPLY      2 /* response to previous request */
+#define	ARP_OP_REVREQUEST 3 /* request proto addr given hardware */
+#define	ARP_OP_REVREPLY   4 /* response giving protocol address */
+#define	ARP_OP_INVREQUEST 8 /* request to identify peer */
+#define	ARP_OP_INVREPLY   9 /* response identifying peer */
+
+	struct arp_ipv4 arp_data;
+} __attribute__((__packed__));
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/layout_array.h b/bindgen-tests/tests/headers/layout_array.h
new file mode 100644
index 00000000..e6a57f7c
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_array.h
@@ -0,0 +1,110 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rust-target 1.40
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+typedef long long size_t;
+
+#define RTE_CACHE_LINE_SIZE 64
+
+/**
+ * Force alignment
+ */
+#define __rte_aligned(a) __attribute__((__aligned__(a)))
+
+/**
+ * Force alignment to cache line.
+ */
+#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
+
+#define RTE_MEMPOOL_OPS_NAMESIZE 32 /**< Max length of ops struct name. */
+
+/**
+ * Prototype for implementation specific data provisioning function.
+ *
+ * The function should provide the implementation specific memory for
+ * for use by the other mempool ops functions in a given mempool ops struct.
+ * E.g. the default ops provides an instance of the rte_ring for this purpose.
+ * it will most likely point to a different type of data structure, and
+ * will be transparent to the application programmer.
+ * This function should set mp->pool_data.
+ */
+typedef int (*rte_mempool_alloc_t)(struct rte_mempool *mp);
+
+/**
+ * Free the opaque private data pointed to by mp->pool_data pointer.
+ */
+typedef void (*rte_mempool_free_t)(struct rte_mempool *mp);
+
+/**
+ * Enqueue an object into the external pool.
+ */
+typedef int (*rte_mempool_enqueue_t)(struct rte_mempool *mp,
+		void * const *obj_table, unsigned int n);
+
+/**
+ * Dequeue an object from the external pool.
+ */
+typedef int (*rte_mempool_dequeue_t)(struct rte_mempool *mp,
+		void **obj_table, unsigned int n);
+
+/**
+ * Return the number of available objects in the external pool.
+ */
+typedef unsigned (*rte_mempool_get_count)(const struct rte_mempool *mp);
+/** Structure defining mempool operations structure */
+struct rte_mempool_ops {
+	char name[RTE_MEMPOOL_OPS_NAMESIZE]; /**< Name of mempool ops struct. */
+	rte_mempool_alloc_t alloc;       /**< Allocate private data. */
+	rte_mempool_free_t free;         /**< Free the external pool. */
+	rte_mempool_enqueue_t enqueue;   /**< Enqueue an object. */
+	rte_mempool_dequeue_t dequeue;   /**< Dequeue an object. */
+	rte_mempool_get_count get_count; /**< Get qty of available objs. */
+} __rte_cache_aligned;
+
+#define RTE_MEMPOOL_MAX_OPS_IDX 16  /**< Max registered ops structs */
+
+/**
+ * The rte_spinlock_t type.
+ */
+typedef struct {
+	volatile int locked; /**< lock status 0 = unlocked, 1 = locked */
+} rte_spinlock_t;
+
+/**
+ * Structure storing the table of registered ops structs, each of which contain
+ * the function pointers for the mempool ops functions.
+ * Each process has its own storage for this ops struct array so that
+ * the mempools can be shared across primary and secondary processes.
+ * The indices used to access the array are valid across processes, whereas
+ * any function pointers stored directly in the mempool struct would not be.
+ * This results in us simply having "ops_index" in the mempool struct.
+ */
+struct rte_mempool_ops_table {
+	rte_spinlock_t sl;     /**< Spinlock for add/delete. */
+	uint32_t num_ops;      /**< Number of used ops structs in the table. */
+	/**
+	 * Storage for all possible ops structs.
+	 */
+	struct rte_mempool_ops ops[RTE_MEMPOOL_MAX_OPS_IDX];
+} __rte_cache_aligned;
+
+
+/* Number of free lists per heap, grouped by size. */
+#define RTE_HEAP_NUM_FREELISTS  13
+
+#define LIST_HEAD(name, type)                                           \
+struct name {                                                           \
+		struct type *lh_first;  /* first element */                     \
+}
+
+/**
+ * Structure to hold malloc heap
+ */
+struct malloc_heap {
+	rte_spinlock_t lock;
+	LIST_HEAD(, malloc_elem) free_head[RTE_HEAP_NUM_FREELISTS];
+	unsigned alloc_count;
+	size_t total_size;
+} __rte_cache_aligned;
diff --git a/bindgen-tests/tests/headers/layout_array_too_long.h b/bindgen-tests/tests/headers/layout_array_too_long.h
new file mode 100644
index 00000000..53e4d8be
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_array_too_long.h
@@ -0,0 +1,61 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rustified-enum ".*" --rust-target 1.40
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+#define RTE_CACHE_LINE_SIZE 64
+
+/**
+ * Force alignment
+ */
+#define __rte_aligned(a) __attribute__((__aligned__(a)))
+
+/**
+ * Force alignment to cache line.
+ */
+#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
+
+#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4
+
+enum {
+	IP_LAST_FRAG_IDX,    /**< index of last fragment */
+	IP_FIRST_FRAG_IDX,   /**< index of first fragment */
+	IP_MIN_FRAG_NUM,     /**< minimum number of fragments */
+	IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG,
+	/**< maximum number of fragments per packet */
+};
+
+/** @internal fragmented mbuf */
+struct ip_frag {
+	uint16_t ofs;          /**< offset into the packet */
+	uint16_t len;          /**< length of fragment */
+	struct rte_mbuf *mb;   /**< fragment mbuf */
+};
+
+/** @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. */
+struct ip_frag_key {
+	uint64_t src_dst[4];      /**< src address, first 8 bytes used for IPv4 */
+	uint32_t id;           /**< dst address */
+	uint32_t key_len;      /**< src/dst key length */
+};
+
+#define	TAILQ_ENTRY(type)						                    \
+struct {								                            \
+	struct type *tqe_next;	/* next element */			            \
+	struct type **tqe_prev;	/* address of previous next element */	\
+}
+
+/**
+ * @internal Fragmented packet to reassemble.
+ * First two entries in the frags[] array are for the last and first fragments.
+ */
+struct ip_frag_pkt {
+	TAILQ_ENTRY(ip_frag_pkt) lru;   /**< LRU list */
+	struct ip_frag_key key;           /**< fragmentation key */
+	uint64_t             start;       /**< creation timestamp */
+	uint32_t             total_size;  /**< expected reassembled size */
+	uint32_t             frag_size;   /**< size of fragments received */
+	uint32_t             last_idx;    /**< index of next entry to fill */
+	struct ip_frag       frags[IP_MAX_FRAG_NUM]; /**< fragments */
+} __rte_cache_aligned;
diff --git a/bindgen-tests/tests/headers/layout_cmdline_token.h b/bindgen-tests/tests/headers/layout_cmdline_token.h
new file mode 100644
index 00000000..da1bfc2e
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_cmdline_token.h
@@ -0,0 +1,64 @@
+// bindgen-flags: --rustified-enum ".*"
+
+/**
+ * Stores a pointer to the ops struct, and the offset: the place to
+ * write the parsed result in the destination structure.
+ */
+struct cmdline_token_hdr {
+	struct cmdline_token_ops *ops;
+	unsigned int offset;
+};
+typedef struct cmdline_token_hdr cmdline_parse_token_hdr_t;
+
+/**
+ * A token is defined by this structure.
+ *
+ * parse() takes the token as first argument, then the source buffer
+ * starting at the token we want to parse. The 3rd arg is a pointer
+ * where we store the parsed data (as binary). It returns the number of
+ * parsed chars on success and a negative value on error.
+ *
+ * complete_get_nb() returns the number of possible values for this
+ * token if completion is possible. If it is NULL or if it returns 0,
+ * no completion is possible.
+ *
+ * complete_get_elt() copy in dstbuf (the size is specified in the
+ * parameter) the i-th possible completion for this token.  returns 0
+ * on success or and a negative value on error.
+ *
+ * get_help() fills the dstbuf with the help for the token. It returns
+ * -1 on error and 0 on success.
+ */
+struct cmdline_token_ops {
+	/** parse(token ptr, buf, res pts, buf len) */
+	int (*parse)(cmdline_parse_token_hdr_t *, const char *, void *,
+		unsigned int);
+	/** return the num of possible choices for this token */
+	int (*complete_get_nb)(cmdline_parse_token_hdr_t *);
+	/** return the elt x for this token (token, idx, dstbuf, size) */
+	int (*complete_get_elt)(cmdline_parse_token_hdr_t *, int, char *,
+		unsigned int);
+	/** get help for this token (token, dstbuf, size) */
+	int (*get_help)(cmdline_parse_token_hdr_t *, char *, unsigned int);
+};
+
+enum cmdline_numtype {
+	UINT8 = 0,
+	UINT16,
+	UINT32,
+	UINT64,
+	INT8,
+	INT16,
+	INT32,
+	INT64
+};
+
+struct cmdline_token_num_data {
+	enum cmdline_numtype type;
+};
+
+struct cmdline_token_num {
+	struct cmdline_token_hdr hdr;
+	struct cmdline_token_num_data num_data;
+};
+typedef struct cmdline_token_num cmdline_parse_token_num_t;
diff --git a/bindgen-tests/tests/headers/layout_eth_conf.h b/bindgen-tests/tests/headers/layout_eth_conf.h
new file mode 100644
index 00000000..9446bffb
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_eth_conf.h
@@ -0,0 +1,428 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" --rust-target 1.40
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+/**
+ *  Simple flags are used for rte_eth_conf.rxmode.mq_mode.
+ */
+#define ETH_MQ_RX_RSS_FLAG  0x1
+#define ETH_MQ_RX_DCB_FLAG  0x2
+#define ETH_MQ_RX_VMDQ_FLAG 0x4
+
+/* Definitions used for VMDQ and DCB functionality */
+#define ETH_VMDQ_MAX_VLAN_FILTERS   64 /**< Maximum nb. of VMDQ vlan filters. */
+#define ETH_DCB_NUM_USER_PRIORITIES 8  /**< Maximum nb. of DCB priorities. */
+#define ETH_VMDQ_DCB_NUM_QUEUES     128 /**< Maximum nb. of VMDQ DCB queues. */
+#define ETH_DCB_NUM_QUEUES          128 /**< Maximum nb. of DCB queues. */
+
+/**
+ *  A set of values to identify what method is to be used to route
+ *  packets to multiple queues.
+ */
+enum rte_eth_rx_mq_mode {
+	/** None of DCB,RSS or VMDQ mode */
+	ETH_MQ_RX_NONE = 0,
+
+	/** For RX side, only RSS is on */
+	ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG,
+	/** For RX side,only DCB is on. */
+	ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG,
+	/** Both DCB and RSS enable */
+	ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG,
+
+	/** Only VMDQ, no RSS nor DCB */
+	ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG,
+	/** RSS mode with VMDQ */
+	ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG,
+	/** Use VMDQ+DCB to route traffic to queues */
+	ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG,
+	/** Enable both VMDQ and DCB in VMDq */
+	ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG |
+				 ETH_MQ_RX_VMDQ_FLAG,
+};
+
+/**
+ * A structure used to configure the RX features of an Ethernet port.
+ */
+struct rte_eth_rxmode {
+	/** The multi-queue packet distribution mode to be used, e.g. RSS. */
+	enum rte_eth_rx_mq_mode mq_mode;
+	uint32_t max_rx_pkt_len;  /**< Only used if jumbo_frame enabled. */
+	uint16_t split_hdr_size;  /**< hdr buf size (header_split enabled).*/
+	__extension__
+	uint16_t header_split : 1, /**< Header Split enable. */
+		hw_ip_checksum   : 1, /**< IP/UDP/TCP checksum offload enable. */
+		hw_vlan_filter   : 1, /**< VLAN filter enable. */
+		hw_vlan_strip    : 1, /**< VLAN strip enable. */
+		hw_vlan_extend   : 1, /**< Extended VLAN enable. */
+		jumbo_frame      : 1, /**< Jumbo Frame Receipt enable. */
+		hw_strip_crc     : 1, /**< Enable CRC stripping by hardware. */
+		enable_scatter   : 1, /**< Enable scatter packets rx handler */
+		enable_lro       : 1; /**< Enable LRO */
+};
+
+/**
+ * A set of values to identify what method is to be used to transmit
+ * packets using multi-TCs.
+ */
+enum rte_eth_tx_mq_mode {
+	ETH_MQ_TX_NONE    = 0,  /**< It is in neither DCB nor VT mode. */
+	ETH_MQ_TX_DCB,          /**< For TX side,only DCB is on. */
+	ETH_MQ_TX_VMDQ_DCB,	/**< For TX side,both DCB and VT is on. */
+	ETH_MQ_TX_VMDQ_ONLY,    /**< Only VT on, no DCB */
+};
+
+/**
+ * A structure used to configure the TX features of an Ethernet port.
+ */
+struct rte_eth_txmode {
+	enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */
+
+	/* For i40e specifically */
+	uint16_t pvid;
+	__extension__
+	uint8_t hw_vlan_reject_tagged : 1,
+		/**< If set, reject sending out tagged pkts */
+		hw_vlan_reject_untagged : 1,
+		/**< If set, reject sending out untagged pkts */
+		hw_vlan_insert_pvid : 1;
+		/**< If set, enable port based VLAN insertion */
+};
+
+/**
+ * A structure used to configure the Receive Side Scaling (RSS) feature
+ * of an Ethernet port.
+ * If not NULL, the *rss_key* pointer of the *rss_conf* structure points
+ * to an array holding the RSS key to use for hashing specific header
+ * fields of received packets. The length of this array should be indicated
+ * by *rss_key_len* below. Otherwise, a default random hash key is used by
+ * the device driver.
+ *
+ * The *rss_key_len* field of the *rss_conf* structure indicates the length
+ * in bytes of the array pointed by *rss_key*. To be compatible, this length
+ * will be checked in i40e only. Others assume 40 bytes to be used as before.
+ *
+ * The *rss_hf* field of the *rss_conf* structure indicates the different
+ * types of IPv4/IPv6 packets to which the RSS hashing must be applied.
+ * Supplying an *rss_hf* equal to zero disables the RSS feature.
+ */
+struct rte_eth_rss_conf {
+	uint8_t *rss_key;    /**< If not NULL, 40-byte hash key. */
+	uint8_t rss_key_len; /**< hash key length in bytes. */
+	uint64_t rss_hf;     /**< Hash functions to apply - see below. */
+};
+
+/**
+ * This enum indicates the possible number of traffic classes
+ * in DCB configratioins
+ */
+enum rte_eth_nb_tcs {
+	ETH_4_TCS = 4, /**< 4 TCs with DCB. */
+	ETH_8_TCS = 8  /**< 8 TCs with DCB. */
+};
+
+/**
+ * This enum indicates the possible number of queue pools
+ * in VMDQ configurations.
+ */
+enum rte_eth_nb_pools {
+	ETH_8_POOLS = 8,    /**< 8 VMDq pools. */
+	ETH_16_POOLS = 16,  /**< 16 VMDq pools. */
+	ETH_32_POOLS = 32,  /**< 32 VMDq pools. */
+	ETH_64_POOLS = 64   /**< 64 VMDq pools. */
+};
+
+/**
+ * A structure used to configure the VMDQ+DCB feature
+ * of an Ethernet port.
+ *
+ * Using this feature, packets are routed to a pool of queues, based
+ * on the vlan id in the vlan tag, and then to a specific queue within
+ * that pool, using the user priority vlan tag field.
+ *
+ * A default pool may be used, if desired, to route all traffic which
+ * does not match the vlan filter rules.
+ */
+struct rte_eth_vmdq_dcb_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */
+	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
+	uint8_t default_pool; /**< The default pool, if applicable */
+	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
+	struct {
+		uint16_t vlan_id; /**< The vlan id of the received frame */
+		uint64_t pools;   /**< Bitmask of pools for packet rx */
+	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+	/**< Selects a queue in a pool */
+};
+
+/* This structure may be extended in future. */
+struct rte_eth_dcb_rx_conf {
+	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_vmdq_dcb_tx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_dcb_tx_conf {
+	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs. */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_vmdq_tx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq mode, 64 pools. */
+};
+
+struct rte_eth_vmdq_rx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq only mode, 8 or 64 pools */
+	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
+	uint8_t default_pool; /**< The default pool, if applicable */
+	uint8_t enable_loop_back; /**< Enable VT loop back */
+	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
+	uint32_t rx_mode; /**< Flags from ETH_VMDQ_ACCEPT_* */
+	struct {
+		uint16_t vlan_id; /**< The vlan id of the received frame */
+		uint64_t pools;   /**< Bitmask of pools for packet rx */
+	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
+};
+
+/**
+ *  Flow Director setting modes: none, signature or perfect.
+ */
+enum rte_fdir_mode {
+	RTE_FDIR_MODE_NONE      = 0, /**< Disable FDIR support. */
+	RTE_FDIR_MODE_SIGNATURE,     /**< Enable FDIR signature filter mode. */
+	RTE_FDIR_MODE_PERFECT,       /**< Enable FDIR perfect filter mode. */
+	RTE_FDIR_MODE_PERFECT_MAC_VLAN, /**< Enable FDIR filter mode - MAC VLAN. */
+	RTE_FDIR_MODE_PERFECT_TUNNEL,   /**< Enable FDIR filter mode - tunnel. */
+};
+
+/**
+ *  Memory space that can be configured to store Flow Director filters
+ *  in the board memory.
+ */
+enum rte_fdir_pballoc_type {
+	RTE_FDIR_PBALLOC_64K = 0,  /**< 64k. */
+	RTE_FDIR_PBALLOC_128K,     /**< 128k. */
+	RTE_FDIR_PBALLOC_256K,     /**< 256k. */
+};
+
+/**
+ *  Select report mode of FDIR hash information in RX descriptors.
+ */
+enum rte_fdir_status_mode {
+	RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */
+	RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */
+	RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */
+};
+
+/**
+ * A structure used to define the input for IPV4 flow
+ */
+struct rte_eth_ipv4_flow {
+	uint32_t src_ip;      /**< IPv4 source address in big endian. */
+	uint32_t dst_ip;      /**< IPv4 destination address in big endian. */
+	uint8_t  tos;         /**< Type of service to match. */
+	uint8_t  ttl;         /**< Time to live to match. */
+	uint8_t  proto;       /**< Protocol, next header in big endian. */
+};
+
+/**
+ * A structure used to define the input for IPV6 flow
+ */
+struct rte_eth_ipv6_flow {
+	uint32_t src_ip[4];      /**< IPv6 source address in big endian. */
+	uint32_t dst_ip[4];      /**< IPv6 destination address in big endian. */
+	uint8_t  tc;             /**< Traffic class to match. */
+	uint8_t  proto;          /**< Protocol, next header to match. */
+	uint8_t  hop_limits;     /**< Hop limits to match. */
+};
+
+/**
+ *  A structure used to configure FDIR masks that are used by the device
+ *  to match the various fields of RX packet headers.
+ */
+struct rte_eth_fdir_masks {
+	uint16_t vlan_tci_mask;   /**< Bit mask for vlan_tci in big endian */
+	/** Bit mask for ipv4 flow in big endian. */
+	struct rte_eth_ipv4_flow   ipv4_mask;
+	/** Bit maks for ipv6 flow in big endian. */
+	struct rte_eth_ipv6_flow   ipv6_mask;
+	/** Bit mask for L4 source port in big endian. */
+	uint16_t src_port_mask;
+	/** Bit mask for L4 destination port in big endian. */
+	uint16_t dst_port_mask;
+	/** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
+	    first byte on the wire */
+	uint8_t mac_addr_byte_mask;
+	/** Bit mask for tunnel ID in big endian. */
+	uint32_t tunnel_id_mask;
+	uint8_t tunnel_type_mask; /**< 1 - Match tunnel type,
+				       0 - Ignore tunnel type. */
+};
+
+/**
+ * Payload type
+ */
+enum rte_eth_payload_type {
+	RTE_ETH_PAYLOAD_UNKNOWN = 0,
+	RTE_ETH_RAW_PAYLOAD,
+	RTE_ETH_L2_PAYLOAD,
+	RTE_ETH_L3_PAYLOAD,
+	RTE_ETH_L4_PAYLOAD,
+	RTE_ETH_PAYLOAD_MAX = 8,
+};
+
+#define RTE_ETH_FDIR_MAX_FLEXLEN 16  /**< Max length of flexbytes. */
+#define RTE_ETH_INSET_SIZE_MAX   128 /**< Max length of input set. */
+
+/**
+ * A structure used to select bytes extracted from the protocol layers to
+ * flexible payload for filter
+ */
+struct rte_eth_flex_payload_cfg {
+	enum rte_eth_payload_type type;  /**< Payload type */
+	uint16_t src_offset[RTE_ETH_FDIR_MAX_FLEXLEN];
+	/**< Offset in bytes from the beginning of packet's payload
+	     src_offset[i] indicates the flexbyte i's offset in original
+	     packet payload. This value should be less than
+	     flex_payload_limit in struct rte_eth_fdir_info.*/
+};
+
+/**
+ * A structure used to define FDIR masks for flexible payload
+ * for each flow type
+ */
+struct rte_eth_fdir_flex_mask {
+	uint16_t flow_type;
+	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
+	/**< Mask for the whole flexible payload */
+};
+
+
+/*
+ * A packet can be identified by hardware as different flow types. Different
+ * NIC hardwares may support different flow types.
+ * Basically, the NIC hardware identifies the flow type as deep protocol as
+ * possible, and exclusively. For example, if a packet is identified as
+ * 'RTE_ETH_FLOW_NONFRAG_IPV4_TCP', it will not be any of other flow types,
+ * though it is an actual IPV4 packet.
+ * Note that the flow types are used to define RSS offload types in
+ * rte_ethdev.h.
+ */
+#define RTE_ETH_FLOW_UNKNOWN             0
+#define RTE_ETH_FLOW_RAW                 1
+#define RTE_ETH_FLOW_IPV4                2
+#define RTE_ETH_FLOW_FRAG_IPV4           3
+#define RTE_ETH_FLOW_NONFRAG_IPV4_TCP    4
+#define RTE_ETH_FLOW_NONFRAG_IPV4_UDP    5
+#define RTE_ETH_FLOW_NONFRAG_IPV4_SCTP   6
+#define RTE_ETH_FLOW_NONFRAG_IPV4_OTHER  7
+#define RTE_ETH_FLOW_IPV6                8
+#define RTE_ETH_FLOW_FRAG_IPV6           9
+#define RTE_ETH_FLOW_NONFRAG_IPV6_TCP   10
+#define RTE_ETH_FLOW_NONFRAG_IPV6_UDP   11
+#define RTE_ETH_FLOW_NONFRAG_IPV6_SCTP  12
+#define RTE_ETH_FLOW_NONFRAG_IPV6_OTHER 13
+#define RTE_ETH_FLOW_L2_PAYLOAD         14
+#define RTE_ETH_FLOW_IPV6_EX            15
+#define RTE_ETH_FLOW_IPV6_TCP_EX        16
+#define RTE_ETH_FLOW_IPV6_UDP_EX        17
+#define RTE_ETH_FLOW_PORT               18
+	/**< Consider device port number as a flow differentiator */
+#define RTE_ETH_FLOW_VXLAN              19 /**< VXLAN protocol based flow */
+#define RTE_ETH_FLOW_GENEVE             20 /**< GENEVE protocol based flow */
+#define RTE_ETH_FLOW_NVGRE              21 /**< NVGRE protocol based flow */
+#define RTE_ETH_FLOW_MAX                22
+
+/**
+ * A structure used to define all flexible payload related setting
+ * include flex payload and flex mask
+ */
+struct rte_eth_fdir_flex_conf {
+	uint16_t nb_payloads;  /**< The number of following payload cfg */
+	uint16_t nb_flexmasks; /**< The number of following mask */
+	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
+	/**< Flex payload configuration for each payload type */
+	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_MAX];
+	/**< Flex mask configuration for each flow type */
+};
+
+/**
+ * A structure used to configure the Flow Director (FDIR) feature
+ * of an Ethernet port.
+ *
+ * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
+ */
+struct rte_fdir_conf {
+	enum rte_fdir_mode mode; /**< Flow Director mode. */
+	enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */
+	enum rte_fdir_status_mode status;  /**< How to report FDIR hash. */
+	/** RX queue of packets matching a "drop" filter in perfect mode. */
+	uint8_t drop_queue;
+	struct rte_eth_fdir_masks mask;
+	struct rte_eth_fdir_flex_conf flex_conf;
+	/**< Flex payload configuration. */
+};
+
+/**
+ * A structure used to enable/disable specific device interrupts.
+ */
+struct rte_intr_conf {
+	/** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */
+	uint16_t lsc;
+	/** enable/disable rxq interrupt. 0 (default) - disable, 1 enable */
+	uint16_t rxq;
+};
+
+/**
+ * A structure used to configure an Ethernet port.
+ * Depending upon the RX multi-queue mode, extra advanced
+ * configuration settings may be needed.
+ */
+struct rte_eth_conf {
+	uint32_t link_speeds; /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be
+				used. ETH_LINK_SPEED_FIXED disables link
+				autonegotiation, and a unique speed shall be
+				set. Otherwise, the bitmap defines the set of
+				speeds to be advertised. If the special value
+				ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
+				supported are advertised. */
+	struct rte_eth_rxmode rxmode; /**< Port RX configuration. */
+	struct rte_eth_txmode txmode; /**< Port TX configuration. */
+	uint32_t lpbk_mode; /**< Loopback operation mode. By default the value
+			         is 0, meaning the loopback mode is disabled.
+				 Read the datasheet of given ethernet controller
+				 for details. The possible values of this field
+				 are defined in implementation of each driver. */
+	struct {
+		struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */
+		struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
+		/**< Port vmdq+dcb configuration. */
+		struct rte_eth_dcb_rx_conf dcb_rx_conf;
+		/**< Port dcb RX configuration. */
+		struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
+		/**< Port vmdq RX configuration. */
+	} rx_adv_conf; /**< Port RX filtering configuration (union). */
+	union {
+		struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
+		/**< Port vmdq+dcb TX configuration. */
+		struct rte_eth_dcb_tx_conf dcb_tx_conf;
+		/**< Port dcb TX configuration. */
+		struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
+		/**< Port vmdq TX configuration. */
+	} tx_adv_conf; /**< Port TX DCB configuration (union). */
+	/** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
+	    is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */
+	uint32_t dcb_capability_en;
+	struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */
+	struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */
+};
diff --git a/bindgen-tests/tests/headers/layout_eth_conf_1_0.h b/bindgen-tests/tests/headers/layout_eth_conf_1_0.h
new file mode 100644
index 00000000..48ba39ff
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_eth_conf_1_0.h
@@ -0,0 +1,429 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+/**
+ *  Simple flags are used for rte_eth_conf.rxmode.mq_mode.
+ */
+#define ETH_MQ_RX_RSS_FLAG  0x1
+#define ETH_MQ_RX_DCB_FLAG  0x2
+#define ETH_MQ_RX_VMDQ_FLAG 0x4
+
+/* Definitions used for VMDQ and DCB functionality */
+#define ETH_VMDQ_MAX_VLAN_FILTERS   64 /**< Maximum nb. of VMDQ vlan filters. */
+#define ETH_DCB_NUM_USER_PRIORITIES 8  /**< Maximum nb. of DCB priorities. */
+#define ETH_VMDQ_DCB_NUM_QUEUES     128 /**< Maximum nb. of VMDQ DCB queues. */
+#define ETH_DCB_NUM_QUEUES          128 /**< Maximum nb. of DCB queues. */
+
+/**
+ *  A set of values to identify what method is to be used to route
+ *  packets to multiple queues.
+ */
+enum rte_eth_rx_mq_mode {
+	/** None of DCB,RSS or VMDQ mode */
+	ETH_MQ_RX_NONE = 0,
+
+	/** For RX side, only RSS is on */
+	ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG,
+	/** For RX side,only DCB is on. */
+	ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG,
+	/** Both DCB and RSS enable */
+	ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG,
+
+	/** Only VMDQ, no RSS nor DCB */
+	ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG,
+	/** RSS mode with VMDQ */
+	ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG,
+	/** Use VMDQ+DCB to route traffic to queues */
+	ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG,
+	/** Enable both VMDQ and DCB in VMDq */
+	ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG |
+				 ETH_MQ_RX_VMDQ_FLAG,
+};
+
+/**
+ * A structure used to configure the RX features of an Ethernet port.
+ */
+struct rte_eth_rxmode {
+	/** The multi-queue packet distribution mode to be used, e.g. RSS. */
+	enum rte_eth_rx_mq_mode mq_mode;
+	uint32_t max_rx_pkt_len;  /**< Only used if jumbo_frame enabled. */
+	uint16_t split_hdr_size;  /**< hdr buf size (header_split enabled).*/
+	__extension__
+	uint16_t header_split : 1, /**< Header Split enable. */
+		hw_ip_checksum   : 1, /**< IP/UDP/TCP checksum offload enable. */
+		hw_vlan_filter   : 1, /**< VLAN filter enable. */
+		hw_vlan_strip    : 1, /**< VLAN strip enable. */
+		hw_vlan_extend   : 1, /**< Extended VLAN enable. */
+		jumbo_frame      : 1, /**< Jumbo Frame Receipt enable. */
+		hw_strip_crc     : 1, /**< Enable CRC stripping by hardware. */
+		enable_scatter   : 1, /**< Enable scatter packets rx handler */
+		enable_lro       : 1; /**< Enable LRO */
+};
+
+/**
+ * A set of values to identify what method is to be used to transmit
+ * packets using multi-TCs.
+ */
+enum rte_eth_tx_mq_mode {
+	ETH_MQ_TX_NONE    = 0,  /**< It is in neither DCB nor VT mode. */
+	ETH_MQ_TX_DCB,          /**< For TX side,only DCB is on. */
+	ETH_MQ_TX_VMDQ_DCB,	/**< For TX side,both DCB and VT is on. */
+	ETH_MQ_TX_VMDQ_ONLY,    /**< Only VT on, no DCB */
+};
+
+/**
+ * A structure used to configure the TX features of an Ethernet port.
+ */
+struct rte_eth_txmode {
+	enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */
+
+	/* For i40e specifically */
+	uint16_t pvid;
+	__extension__
+	uint8_t hw_vlan_reject_tagged : 1,
+		/**< If set, reject sending out tagged pkts */
+		hw_vlan_reject_untagged : 1,
+		/**< If set, reject sending out untagged pkts */
+		hw_vlan_insert_pvid : 1;
+		/**< If set, enable port based VLAN insertion */
+};
+
+/**
+ * A structure used to configure the Receive Side Scaling (RSS) feature
+ * of an Ethernet port.
+ * If not NULL, the *rss_key* pointer of the *rss_conf* structure points
+ * to an array holding the RSS key to use for hashing specific header
+ * fields of received packets. The length of this array should be indicated
+ * by *rss_key_len* below. Otherwise, a default random hash key is used by
+ * the device driver.
+ *
+ * The *rss_key_len* field of the *rss_conf* structure indicates the length
+ * in bytes of the array pointed by *rss_key*. To be compatible, this length
+ * will be checked in i40e only. Others assume 40 bytes to be used as before.
+ *
+ * The *rss_hf* field of the *rss_conf* structure indicates the different
+ * types of IPv4/IPv6 packets to which the RSS hashing must be applied.
+ * Supplying an *rss_hf* equal to zero disables the RSS feature.
+ */
+struct rte_eth_rss_conf {
+	uint8_t *rss_key;    /**< If not NULL, 40-byte hash key. */
+	uint8_t rss_key_len; /**< hash key length in bytes. */
+	uint64_t rss_hf;     /**< Hash functions to apply - see below. */
+};
+
+/**
+ * This enum indicates the possible number of traffic classes
+ * in DCB configratioins
+ */
+enum rte_eth_nb_tcs {
+	ETH_4_TCS = 4, /**< 4 TCs with DCB. */
+	ETH_8_TCS = 8  /**< 8 TCs with DCB. */
+};
+
+/**
+ * This enum indicates the possible number of queue pools
+ * in VMDQ configurations.
+ */
+enum rte_eth_nb_pools {
+	ETH_8_POOLS = 8,    /**< 8 VMDq pools. */
+	ETH_16_POOLS = 16,  /**< 16 VMDq pools. */
+	ETH_32_POOLS = 32,  /**< 32 VMDq pools. */
+	ETH_64_POOLS = 64   /**< 64 VMDq pools. */
+};
+
+/**
+ * A structure used to configure the VMDQ+DCB feature
+ * of an Ethernet port.
+ *
+ * Using this feature, packets are routed to a pool of queues, based
+ * on the vlan id in the vlan tag, and then to a specific queue within
+ * that pool, using the user priority vlan tag field.
+ *
+ * A default pool may be used, if desired, to route all traffic which
+ * does not match the vlan filter rules.
+ */
+struct rte_eth_vmdq_dcb_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */
+	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
+	uint8_t default_pool; /**< The default pool, if applicable */
+	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
+	struct {
+		uint16_t vlan_id; /**< The vlan id of the received frame */
+		uint64_t pools;   /**< Bitmask of pools for packet rx */
+	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+	/**< Selects a queue in a pool */
+};
+
+/* This structure may be extended in future. */
+struct rte_eth_dcb_rx_conf {
+	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_vmdq_dcb_tx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_dcb_tx_conf {
+	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs. */
+	/** Traffic class each UP mapped to. */
+	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
+};
+
+struct rte_eth_vmdq_tx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq mode, 64 pools. */
+};
+
+struct rte_eth_vmdq_rx_conf {
+	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq only mode, 8 or 64 pools */
+	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
+	uint8_t default_pool; /**< The default pool, if applicable */
+	uint8_t enable_loop_back; /**< Enable VT loop back */
+	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
+	uint32_t rx_mode; /**< Flags from ETH_VMDQ_ACCEPT_* */
+	struct {
+		uint16_t vlan_id; /**< The vlan id of the received frame */
+		uint64_t pools;   /**< Bitmask of pools for packet rx */
+	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
+};
+
+/**
+ *  Flow Director setting modes: none, signature or perfect.
+ */
+enum rte_fdir_mode {
+	RTE_FDIR_MODE_NONE      = 0, /**< Disable FDIR support. */
+	RTE_FDIR_MODE_SIGNATURE,     /**< Enable FDIR signature filter mode. */
+	RTE_FDIR_MODE_PERFECT,       /**< Enable FDIR perfect filter mode. */
+	RTE_FDIR_MODE_PERFECT_MAC_VLAN, /**< Enable FDIR filter mode - MAC VLAN. */
+	RTE_FDIR_MODE_PERFECT_TUNNEL,   /**< Enable FDIR filter mode - tunnel. */
+};
+
+/**
+ *  Memory space that can be configured to store Flow Director filters
+ *  in the board memory.
+ */
+enum rte_fdir_pballoc_type {
+	RTE_FDIR_PBALLOC_64K = 0,  /**< 64k. */
+	RTE_FDIR_PBALLOC_128K,     /**< 128k. */
+	RTE_FDIR_PBALLOC_256K,     /**< 256k. */
+};
+
+/**
+ *  Select report mode of FDIR hash information in RX descriptors.
+ */
+enum rte_fdir_status_mode {
+	RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */
+	RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */
+	RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */
+};
+
+/**
+ * A structure used to define the input for IPV4 flow
+ */
+struct rte_eth_ipv4_flow {
+	uint32_t src_ip;      /**< IPv4 source address in big endian. */
+	uint32_t dst_ip;      /**< IPv4 destination address in big endian. */
+	uint8_t  tos;         /**< Type of service to match. */
+	uint8_t  ttl;         /**< Time to live to match. */
+	uint8_t  proto;       /**< Protocol, next header in big endian. */
+};
+
+/**
+ * A structure used to define the input for IPV6 flow
+ */
+struct rte_eth_ipv6_flow {
+	uint32_t src_ip[4];      /**< IPv6 source address in big endian. */
+	uint32_t dst_ip[4];      /**< IPv6 destination address in big endian. */
+	uint8_t  tc;             /**< Traffic class to match. */
+	uint8_t  proto;          /**< Protocol, next header to match. */
+	uint8_t  hop_limits;     /**< Hop limits to match. */
+};
+
+/**
+ *  A structure used to configure FDIR masks that are used by the device
+ *  to match the various fields of RX packet headers.
+ */
+struct rte_eth_fdir_masks {
+	uint16_t vlan_tci_mask;   /**< Bit mask for vlan_tci in big endian */
+	/** Bit mask for ipv4 flow in big endian. */
+	struct rte_eth_ipv4_flow   ipv4_mask;
+	/** Bit maks for ipv6 flow in big endian. */
+	struct rte_eth_ipv6_flow   ipv6_mask;
+	/** Bit mask for L4 source port in big endian. */
+	uint16_t src_port_mask;
+	/** Bit mask for L4 destination port in big endian. */
+	uint16_t dst_port_mask;
+	/** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
+	    first byte on the wire */
+	uint8_t mac_addr_byte_mask;
+	/** Bit mask for tunnel ID in big endian. */
+	uint32_t tunnel_id_mask;
+	uint8_t tunnel_type_mask; /**< 1 - Match tunnel type,
+				       0 - Ignore tunnel type. */
+};
+
+/**
+ * Payload type
+ */
+enum rte_eth_payload_type {
+	RTE_ETH_PAYLOAD_UNKNOWN = 0,
+	RTE_ETH_RAW_PAYLOAD,
+	RTE_ETH_L2_PAYLOAD,
+	RTE_ETH_L3_PAYLOAD,
+	RTE_ETH_L4_PAYLOAD,
+	RTE_ETH_PAYLOAD_MAX = 8,
+};
+
+#define RTE_ETH_FDIR_MAX_FLEXLEN 16  /**< Max length of flexbytes. */
+#define RTE_ETH_INSET_SIZE_MAX   128 /**< Max length of input set. */
+
+/**
+ * A structure used to select bytes extracted from the protocol layers to
+ * flexible payload for filter
+ */
+struct rte_eth_flex_payload_cfg {
+	enum rte_eth_payload_type type;  /**< Payload type */
+	uint16_t src_offset[RTE_ETH_FDIR_MAX_FLEXLEN];
+	/**< Offset in bytes from the beginning of packet's payload
+	     src_offset[i] indicates the flexbyte i's offset in original
+	     packet payload. This value should be less than
+	     flex_payload_limit in struct rte_eth_fdir_info.*/
+};
+
+/**
+ * A structure used to define FDIR masks for flexible payload
+ * for each flow type
+ */
+struct rte_eth_fdir_flex_mask {
+	uint16_t flow_type;
+	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
+	/**< Mask for the whole flexible payload */
+};
+
+
+/*
+ * A packet can be identified by hardware as different flow types. Different
+ * NIC hardwares may support different flow types.
+ * Basically, the NIC hardware identifies the flow type as deep protocol as
+ * possible, and exclusively. For example, if a packet is identified as
+ * 'RTE_ETH_FLOW_NONFRAG_IPV4_TCP', it will not be any of other flow types,
+ * though it is an actual IPV4 packet.
+ * Note that the flow types are used to define RSS offload types in
+ * rte_ethdev.h.
+ */
+#define RTE_ETH_FLOW_UNKNOWN             0
+#define RTE_ETH_FLOW_RAW                 1
+#define RTE_ETH_FLOW_IPV4                2
+#define RTE_ETH_FLOW_FRAG_IPV4           3
+#define RTE_ETH_FLOW_NONFRAG_IPV4_TCP    4
+#define RTE_ETH_FLOW_NONFRAG_IPV4_UDP    5
+#define RTE_ETH_FLOW_NONFRAG_IPV4_SCTP   6
+#define RTE_ETH_FLOW_NONFRAG_IPV4_OTHER  7
+#define RTE_ETH_FLOW_IPV6                8
+#define RTE_ETH_FLOW_FRAG_IPV6           9
+#define RTE_ETH_FLOW_NONFRAG_IPV6_TCP   10
+#define RTE_ETH_FLOW_NONFRAG_IPV6_UDP   11
+#define RTE_ETH_FLOW_NONFRAG_IPV6_SCTP  12
+#define RTE_ETH_FLOW_NONFRAG_IPV6_OTHER 13
+#define RTE_ETH_FLOW_L2_PAYLOAD         14
+#define RTE_ETH_FLOW_IPV6_EX            15
+#define RTE_ETH_FLOW_IPV6_TCP_EX        16
+#define RTE_ETH_FLOW_IPV6_UDP_EX        17
+#define RTE_ETH_FLOW_PORT               18
+	/**< Consider device port number as a flow differentiator */
+#define RTE_ETH_FLOW_VXLAN              19 /**< VXLAN protocol based flow */
+#define RTE_ETH_FLOW_GENEVE             20 /**< GENEVE protocol based flow */
+#define RTE_ETH_FLOW_NVGRE              21 /**< NVGRE protocol based flow */
+#define RTE_ETH_FLOW_MAX                22
+
+/**
+ * A structure used to define all flexible payload related setting
+ * include flex payload and flex mask
+ */
+struct rte_eth_fdir_flex_conf {
+	uint16_t nb_payloads;  /**< The number of following payload cfg */
+	uint16_t nb_flexmasks; /**< The number of following mask */
+	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
+	/**< Flex payload configuration for each payload type */
+	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_MAX];
+	/**< Flex mask configuration for each flow type */
+};
+
+/**
+ * A structure used to configure the Flow Director (FDIR) feature
+ * of an Ethernet port.
+ *
+ * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
+ */
+struct rte_fdir_conf {
+	enum rte_fdir_mode mode; /**< Flow Director mode. */
+	enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */
+	enum rte_fdir_status_mode status;  /**< How to report FDIR hash. */
+	/** RX queue of packets matching a "drop" filter in perfect mode. */
+	uint8_t drop_queue;
+	struct rte_eth_fdir_masks mask;
+	struct rte_eth_fdir_flex_conf flex_conf;
+	/**< Flex payload configuration. */
+};
+
+/**
+ * A structure used to enable/disable specific device interrupts.
+ */
+struct rte_intr_conf {
+	/** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */
+	uint16_t lsc;
+	/** enable/disable rxq interrupt. 0 (default) - disable, 1 enable */
+	uint16_t rxq;
+};
+
+/**
+ * A structure used to configure an Ethernet port.
+ * Depending upon the RX multi-queue mode, extra advanced
+ * configuration settings may be needed.
+ */
+struct rte_eth_conf {
+	uint32_t link_speeds; /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be
+				used. ETH_LINK_SPEED_FIXED disables link
+				autonegotiation, and a unique speed shall be
+				set. Otherwise, the bitmap defines the set of
+				speeds to be advertised. If the special value
+				ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
+				supported are advertised. */
+	struct rte_eth_rxmode rxmode; /**< Port RX configuration. */
+	struct rte_eth_txmode txmode; /**< Port TX configuration. */
+	uint32_t lpbk_mode; /**< Loopback operation mode. By default the value
+			         is 0, meaning the loopback mode is disabled.
+				 Read the datasheet of given ethernet controller
+				 for details. The possible values of this field
+				 are defined in implementation of each driver. */
+	struct {
+		struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */
+		struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
+		/**< Port vmdq+dcb configuration. */
+		struct rte_eth_dcb_rx_conf dcb_rx_conf;
+		/**< Port dcb RX configuration. */
+		struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
+		/**< Port vmdq RX configuration. */
+	} rx_adv_conf; /**< Port RX filtering configuration (union). */
+	union {
+		struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
+		/**< Port vmdq+dcb TX configuration. */
+		struct rte_eth_dcb_tx_conf dcb_tx_conf;
+		/**< Port dcb TX configuration. */
+		struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
+		/**< Port vmdq TX configuration. */
+	} tx_adv_conf; /**< Port TX DCB configuration (union). */
+	/** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
+	    is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */
+	uint32_t dcb_capability_en;
+	struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */
+	struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */
+};
diff --git a/bindgen-tests/tests/headers/layout_kni_mbuf.h b/bindgen-tests/tests/headers/layout_kni_mbuf.h
new file mode 100644
index 00000000..4d604aa6
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_kni_mbuf.h
@@ -0,0 +1,33 @@
+// bindgen-flags: --rust-target 1.40
+
+#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
+
+#define RTE_CACHE_LINE_SIZE 64
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+/*
+ * The kernel image of the rte_mbuf struct, with only the relevant fields.
+ * Padding is necessary to assure the offsets of these fields
+ */
+struct rte_kni_mbuf {
+	void *buf_addr __attribute__((__aligned__(RTE_CACHE_LINE_SIZE)));
+	uint64_t buf_physaddr;
+	char pad0[2];
+	uint16_t data_off;      /**< Start address of data in segment buffer. */
+	char pad1[2];
+	uint8_t nb_segs;        /**< Number of segments. */
+	char pad4[1];
+	uint64_t ol_flags;      /**< Offload features. */
+	char pad2[4];
+	uint32_t pkt_len;       /**< Total pkt len: sum of all segment data_len. */
+	uint16_t data_len;      /**< Amount of data in segment buffer. */
+
+	/* fields on second cache line */
+	char pad3[8] __attribute__((__aligned__(RTE_CACHE_LINE_MIN_SIZE)));
+	void *pool;
+	void *next;
+};
diff --git a/bindgen-tests/tests/headers/layout_large_align_field.h b/bindgen-tests/tests/headers/layout_large_align_field.h
new file mode 100644
index 00000000..63aea90b
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_large_align_field.h
@@ -0,0 +1,99 @@
+// bindgen-flags: --rustified-enum ".*" --rust-target 1.40
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+#define RTE_CACHE_LINE_SIZE 64
+
+/**
+ * Force alignment
+ */
+#define __rte_aligned(a) __attribute__((__aligned__(a)))
+
+/**
+ * Force alignment to cache line.
+ */
+#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
+
+#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4
+
+enum {
+	IP_LAST_FRAG_IDX,    /**< index of last fragment */
+	IP_FIRST_FRAG_IDX,   /**< index of first fragment */
+	IP_MIN_FRAG_NUM,     /**< minimum number of fragments */
+	IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG,
+	/**< maximum number of fragments per packet */
+};
+
+/** @internal fragmented mbuf */
+struct ip_frag {
+	uint16_t ofs;          /**< offset into the packet */
+	uint16_t len;          /**< length of fragment */
+	struct rte_mbuf *mb;   /**< fragment mbuf */
+};
+
+/** @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. */
+struct ip_frag_key {
+	uint64_t src_dst[4];      /**< src address, first 8 bytes used for IPv4 */
+	uint32_t id;           /**< dst address */
+	uint32_t key_len;      /**< src/dst key length */
+};
+
+/*
+ * Tail queue declarations.
+ */
+#define	TAILQ_HEAD(name, type)						            \
+struct name {								                    \
+	struct type *tqh_first;	/* first element */			        \
+	struct type **tqh_last;	/* addr of last next element */		\
+}
+
+
+#define	TAILQ_ENTRY(type)						                    \
+struct {								                            \
+	struct type *tqe_next;	/* next element */			            \
+	struct type **tqe_prev;	/* address of previous next element */	\
+}
+
+/**
+ * @internal Fragmented packet to reassemble.
+ * First two entries in the frags[] array are for the last and first fragments.
+ */
+struct ip_frag_pkt {
+	TAILQ_ENTRY(ip_frag_pkt) lru;   /**< LRU list */
+	struct ip_frag_key key;           /**< fragmentation key */
+	uint64_t             start;       /**< creation timestamp */
+	uint32_t             total_size;  /**< expected reassembled size */
+	uint32_t             frag_size;   /**< size of fragments received */
+	uint32_t             last_idx;    /**< index of next entry to fill */
+	struct ip_frag       frags[IP_MAX_FRAG_NUM]; /**< fragments */
+} __rte_cache_aligned;
+
+TAILQ_HEAD(ip_pkt_list, ip_frag_pkt); /**< @internal fragments tailq */
+
+/** fragmentation table statistics */
+struct ip_frag_tbl_stat {
+	uint64_t find_num;      /**< total # of find/insert attempts. */
+	uint64_t add_num;       /**< # of add ops. */
+	uint64_t del_num;       /**< # of del ops. */
+	uint64_t reuse_num;     /**< # of reuse (del/add) ops. */
+	uint64_t fail_total;    /**< total # of add failures. */
+	uint64_t fail_nospace;  /**< # of 'no space' add failures. */
+} __rte_cache_aligned;
+
+/** fragmentation table */
+struct rte_ip_frag_tbl {
+	uint64_t             max_cycles;      /**< ttl for table entries. */
+	uint32_t             entry_mask;      /**< hash value mask. */
+	uint32_t             max_entries;     /**< max entries allowed. */
+	uint32_t             use_entries;     /**< entries in use. */
+	uint32_t             bucket_entries;  /**< hash assocaitivity. */
+	uint32_t             nb_entries;      /**< total size of the table. */
+	uint32_t             nb_buckets;      /**< num of associativity lines. */
+	struct ip_frag_pkt *last;         /**< last used entry. */
+	struct ip_pkt_list lru;           /**< LRU list for table entries. */
+	struct ip_frag_tbl_stat stat;     /**< statistics counters. */
+	__extension__ struct ip_frag_pkt pkt[0]; /**< hash table. */
+};
diff --git a/bindgen-tests/tests/headers/layout_mbuf.h b/bindgen-tests/tests/headers/layout_mbuf.h
new file mode 100644
index 00000000..0e342f45
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_mbuf.h
@@ -0,0 +1,188 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
+
+#define RTE_CACHE_LINE_SIZE 64
+
+typedef char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+typedef long long int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+typedef uint64_t phys_addr_t;
+
+/**
+ * Force alignment
+ */
+#define __rte_aligned(a) __attribute__((__aligned__(a)))
+
+/**
+ * Force alignment to cache line.
+ */
+#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
+
+/**
+ * Force minimum cache line alignment.
+ */
+#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE)
+
+/* define a set of marker types that can be used to refer to set points in the
+ * mbuf */
+__extension__
+typedef void    *MARKER[0];   /**< generic marker for a point in a structure */
+__extension__
+typedef uint8_t  MARKER8[0];  /**< generic marker with 1B alignment */
+__extension__
+typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes
+                               * with a single assignment */
+
+/** C extension macro for environments lacking C11 features. */
+#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
+#define RTE_STD_C11 __extension__
+#else
+#define RTE_STD_C11
+#endif
+
+/**
+ * The atomic counter structure.
+ */
+typedef struct {
+	volatile int16_t cnt; /**< An internal counter value. */
+} rte_atomic16_t;
+
+/**
+ * The generic rte_mbuf, containing a packet mbuf.
+ */
+struct rte_mbuf {
+	MARKER cacheline0;
+
+	void *buf_addr;           /**< Virtual address of segment buffer. */
+	phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */
+
+	uint16_t buf_len;         /**< Length of segment buffer. */
+
+	/* next 6 bytes are initialised on RX descriptor rearm */
+	MARKER8 rearm_data;
+	uint16_t data_off;
+
+	/**
+	 * 16-bit Reference counter.
+	 * It should only be accessed using the following functions:
+	 * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
+	 * rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
+	 * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
+	 * config option.
+	 */
+	RTE_STD_C11
+	union {
+		rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */
+		uint16_t refcnt;              /**< Non-atomically accessed refcnt */
+	};
+	uint8_t nb_segs;          /**< Number of segments. */
+	uint8_t port;             /**< Input port. */
+
+	uint64_t ol_flags;        /**< Offload features. */
+
+	/* remaining bytes are set on RX when pulling packet from descriptor */
+	MARKER rx_descriptor_fields1;
+
+	/*
+	 * The packet type, which is the combination of outer/inner L2, L3, L4
+	 * and tunnel types. The packet_type is about data really present in the
+	 * mbuf. Example: if vlan stripping is enabled, a received vlan packet
+	 * would have RTE_PTYPE_L2_ETHER and not RTE_PTYPE_L2_VLAN because the
+	 * vlan is stripped from the data.
+	 */
+	RTE_STD_C11
+	union {
+		uint32_t packet_type; /**< L2/L3/L4 and tunnel information. */
+		struct {
+			uint32_t l2_type:4; /**< (Outer) L2 type. */
+			uint32_t l3_type:4; /**< (Outer) L3 type. */
+			uint32_t l4_type:4; /**< (Outer) L4 type. */
+			uint32_t tun_type:4; /**< Tunnel type. */
+			uint32_t inner_l2_type:4; /**< Inner L2 type. */
+			uint32_t inner_l3_type:4; /**< Inner L3 type. */
+			uint32_t inner_l4_type:4; /**< Inner L4 type. */
+		};
+	};
+
+	uint32_t pkt_len;         /**< Total pkt len: sum of all segments. */
+	uint16_t data_len;        /**< Amount of data in segment buffer. */
+	/** VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. */
+	uint16_t vlan_tci;
+
+	union {
+		uint32_t rss;     /**< RSS hash result if RSS enabled */
+		struct {
+			RTE_STD_C11
+			union {
+				struct {
+					uint16_t hash;
+					uint16_t id;
+				};
+				uint32_t lo;
+				/**< Second 4 flexible bytes */
+			};
+			uint32_t hi;
+			/**< First 4 flexible bytes or FD ID, dependent on
+			     PKT_RX_FDIR_* flag in ol_flags. */
+		} fdir;           /**< Filter identifier if FDIR enabled */
+		struct {
+			uint32_t lo;
+			uint32_t hi;
+		} sched;          /**< Hierarchical scheduler */
+		uint32_t usr;	  /**< User defined tags. See rte_distributor_process() */
+	} hash;                   /**< hash information */
+
+	uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */
+
+	/** Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. */
+	uint16_t vlan_tci_outer;
+
+	/* second cache line - fields only used in slow path or on TX */
+	MARKER cacheline1 __rte_cache_min_aligned;
+
+	RTE_STD_C11
+	union {
+		void *userdata;   /**< Can be used for external metadata */
+		uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */
+	};
+
+	struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */
+	struct rte_mbuf *next;    /**< Next segment of scattered packet. */
+
+	/* fields to support TX offloads */
+	RTE_STD_C11
+	union {
+		uint64_t tx_offload;       /**< combined for easy fetch */
+		__extension__
+		struct {
+			uint64_t l2_len:7;
+			/**< L2 (MAC) Header Length for non-tunneling pkt.
+			 * Outer_L4_len + ... + Inner_L2_len for tunneling pkt.
+			 */
+			uint64_t l3_len:9; /**< L3 (IP) Header Length. */
+			uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
+			uint64_t tso_segsz:16; /**< TCP TSO segment size */
+
+			/* fields for TX offloading of tunnels */
+			uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */
+			uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */
+
+			/* uint64_t unused:8; */
+		};
+	};
+
+	/** Size of the application private data. In case of an indirect
+	 * mbuf, it stores the direct mbuf private data size. */
+	uint16_t priv_size;
+
+	/** Timesync flags for use with IEEE1588. */
+	uint16_t timesync;
+} __rte_cache_aligned;
diff --git a/bindgen-tests/tests/headers/layout_mbuf_1_0.h b/bindgen-tests/tests/headers/layout_mbuf_1_0.h
new file mode 100644
index 00000000..2854de50
--- /dev/null
+++ b/bindgen-tests/tests/headers/layout_mbuf_1_0.h
@@ -0,0 +1,189 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+
+#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
+
+#define RTE_CACHE_LINE_SIZE 64
+
+typedef char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+typedef long long int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+typedef uint64_t phys_addr_t;
+
+/**
+ * Force alignment
+ */
+#define __rte_aligned(a) __attribute__((__aligned__(a)))
+
+/**
+ * Force alignment to cache line.
+ */
+#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
+
+/**
+ * Force minimum cache line alignment.
+ */
+#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE)
+
+/* define a set of marker types that can be used to refer to set points in the
+ * mbuf */
+__extension__
+typedef void    *MARKER[0];   /**< generic marker for a point in a structure */
+__extension__
+typedef uint8_t  MARKER8[0];  /**< generic marker with 1B alignment */
+__extension__
+typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes
+                               * with a single assignment */
+
+/** C extension macro for environments lacking C11 features. */
+#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
+#define RTE_STD_C11 __extension__
+#else
+#define RTE_STD_C11
+#endif
+
+/**
+ * The atomic counter structure.
+ */
+typedef struct {
+	volatile int16_t cnt; /**< An internal counter value. */
+} rte_atomic16_t;
+
+/**
+ * The generic rte_mbuf, containing a packet mbuf.
+ */
+struct rte_mbuf {
+	MARKER cacheline0;
+
+	void *buf_addr;           /**< Virtual address of segment buffer. */
+	phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */
+
+	uint16_t buf_len;         /**< Length of segment buffer. */
+
+	/* next 6 bytes are initialised on RX descriptor rearm */
+	MARKER8 rearm_data;
+	uint16_t data_off;
+
+	/**
+	 * 16-bit Reference counter.
+	 * It should only be accessed using the following functions:
+	 * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
+	 * rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
+	 * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
+	 * config option.
+	 */
+	RTE_STD_C11
+	union {
+		rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */
+		uint16_t refcnt;              /**< Non-atomically accessed refcnt */
+	};
+	uint8_t nb_segs;          /**< Number of segments. */
+	uint8_t port;             /**< Input port. */
+
+	uint64_t ol_flags;        /**< Offload features. */
+
+	/* remaining bytes are set on RX when pulling packet from descriptor */
+	MARKER rx_descriptor_fields1;
+
+	/*
+	 * The packet type, which is the combination of outer/inner L2, L3, L4
+	 * and tunnel types. The packet_type is about data really present in the
+	 * mbuf. Example: if vlan stripping is enabled, a received vlan packet
+	 * would have RTE_PTYPE_L2_ETHER and not RTE_PTYPE_L2_VLAN because the
+	 * vlan is stripped from the data.
+	 */
+	RTE_STD_C11
+	union {
+		uint32_t packet_type; /**< L2/L3/L4 and tunnel information. */
+		struct {
+			uint32_t l2_type:4; /**< (Outer) L2 type. */
+			uint32_t l3_type:4; /**< (Outer) L3 type. */
+			uint32_t l4_type:4; /**< (Outer) L4 type. */
+			uint32_t tun_type:4; /**< Tunnel type. */
+			uint32_t inner_l2_type:4; /**< Inner L2 type. */
+			uint32_t inner_l3_type:4; /**< Inner L3 type. */
+			uint32_t inner_l4_type:4; /**< Inner L4 type. */
+		};
+	};
+
+	uint32_t pkt_len;         /**< Total pkt len: sum of all segments. */
+	uint16_t data_len;        /**< Amount of data in segment buffer. */
+	/** VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. */
+	uint16_t vlan_tci;
+
+	union {
+		uint32_t rss;     /**< RSS hash result if RSS enabled */
+		struct {
+			RTE_STD_C11
+			union {
+				struct {
+					uint16_t hash;
+					uint16_t id;
+				};
+				uint32_t lo;
+				/**< Second 4 flexible bytes */
+			};
+			uint32_t hi;
+			/**< First 4 flexible bytes or FD ID, dependent on
+			     PKT_RX_FDIR_* flag in ol_flags. */
+		} fdir;           /**< Filter identifier if FDIR enabled */
+		struct {
+			uint32_t lo;
+			uint32_t hi;
+		} sched;          /**< Hierarchical scheduler */
+		uint32_t usr;	  /**< User defined tags. See rte_distributor_process() */
+	} hash;                   /**< hash information */
+
+	uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */
+
+	/** Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. */
+	uint16_t vlan_tci_outer;
+
+	/* second cache line - fields only used in slow path or on TX */
+	MARKER cacheline1 __rte_cache_min_aligned;
+
+	RTE_STD_C11
+	union {
+		void *userdata;   /**< Can be used for external metadata */
+		uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */
+	};
+
+	struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */
+	struct rte_mbuf *next;    /**< Next segment of scattered packet. */
+
+	/* fields to support TX offloads */
+	RTE_STD_C11
+	union {
+		uint64_t tx_offload;       /**< combined for easy fetch */
+		__extension__
+		struct {
+			uint64_t l2_len:7;
+			/**< L2 (MAC) Header Length for non-tunneling pkt.
+			 * Outer_L4_len + ... + Inner_L2_len for tunneling pkt.
+			 */
+			uint64_t l3_len:9; /**< L3 (IP) Header Length. */
+			uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
+			uint64_t tso_segsz:16; /**< TCP TSO segment size */
+
+			/* fields for TX offloading of tunnels */
+			uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */
+			uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */
+
+			/* uint64_t unused:8; */
+		};
+	};
+
+	/** Size of the application private data. In case of an indirect
+	 * mbuf, it stores the direct mbuf private data size. */
+	uint16_t priv_size;
+
+	/** Timesync flags for use with IEEE1588. */
+	uint16_t timesync;
+} __rte_cache_aligned;
diff --git a/bindgen-tests/tests/headers/long_double.h b/bindgen-tests/tests/headers/long_double.h
new file mode 100644
index 00000000..91c4ed6c
--- /dev/null
+++ b/bindgen-tests/tests/headers/long_double.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --rust-target 1.26
+
+struct foo {
+  long double bar;
+};
diff --git a/bindgen-tests/tests/headers/macro-expr-basic.h b/bindgen-tests/tests/headers/macro-expr-basic.h
new file mode 100644
index 00000000..d2de7fdf
--- /dev/null
+++ b/bindgen-tests/tests/headers/macro-expr-basic.h
@@ -0,0 +1,14 @@
+#define FOO 1
+#define BAR 4
+#define BAZ (FOO + BAR)
+
+#define MIN (1 << 63)
+
+#define BARR (1 << 0)
+#define BAZZ ((1 << 1) + BAZ)
+#define I_RAN_OUT_OF_DUMB_NAMES (BARR | BAZZ)
+
+/* I haz a comment */
+#define HAZ_A_COMMENT BARR
+
+#define HAZ_A_COMMENT_INSIDE (/* comment for real */ BARR + FOO)
diff --git a/bindgen-tests/tests/headers/macro-expr-uncommon-token.h b/bindgen-tests/tests/headers/macro-expr-uncommon-token.h
new file mode 100644
index 00000000..dd1b4343
--- /dev/null
+++ b/bindgen-tests/tests/headers/macro-expr-uncommon-token.h
@@ -0,0 +1,7 @@
+
+// Commenting this out & removing the usage before `foo` results in the correct
+// bindings
+#define MODBUS_API
+#define MODBUS_WOOT 3
+
+MODBUS_API void foo();
diff --git a/bindgen-tests/tests/headers/macro-redef.h b/bindgen-tests/tests/headers/macro-redef.h
new file mode 100644
index 00000000..0180d2ab
--- /dev/null
+++ b/bindgen-tests/tests/headers/macro-redef.h
@@ -0,0 +1,5 @@
+#define FOO 4
+#define BAR (1 + FOO)
+#undef FOO
+#define FOO 5
+#define BAZ (1 + FOO)
diff --git a/bindgen-tests/tests/headers/macro_const.h b/bindgen-tests/tests/headers/macro_const.h
new file mode 100644
index 00000000..7c5aa438
--- /dev/null
+++ b/bindgen-tests/tests/headers/macro_const.h
@@ -0,0 +1,8 @@
+#define foo "bar"
+#define CHAR 'b'
+#define CHARR '\0'
+#define FLOAT 5.09f
+#define FLOAT_EXPR (5 / 1000.0f)
+#define LONG 3L
+
+#define INVALID_UTF8 "\xf0\x28\x8c\x28"
diff --git a/bindgen-tests/tests/headers/macro_const_1_0.h b/bindgen-tests/tests/headers/macro_const_1_0.h
new file mode 100644
index 00000000..3be86b4f
--- /dev/null
+++ b/bindgen-tests/tests/headers/macro_const_1_0.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --rust-target 1.0
+
+#define foo "bar"
+#define CHAR 'b'
+#define CHARR '\0'
+#define FLOAT 5.09f
+#define FLOAT_EXPR (5 / 1000.0f)
+#define LONG 3L
+
+#define INVALID_UTF8 "\xf0\x28\x8c\x28"
diff --git a/bindgen-tests/tests/headers/maddness-is-avoidable.hpp b/bindgen-tests/tests/headers/maddness-is-avoidable.hpp
new file mode 100644
index 00000000..47a7ffbf
--- /dev/null
+++ b/bindgen-tests/tests/headers/maddness-is-avoidable.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --blocklist-type RefPtr_Proxy_member_function
+
+template<typename T>
+class RefPtr {
+  template<typename R, typename... Args>
+  class Proxy {
+    typedef R (T::*member_function)(Args...);
+  };
+};
diff --git a/bindgen-tests/tests/headers/mangling-ios.h b/bindgen-tests/tests/headers/mangling-ios.h
new file mode 100644
index 00000000..d3a0cd78
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-ios.h
@@ -0,0 +1,3 @@
+// bindgen-flags: -- --target=x86_64-apple-ios
+
+void foo();
diff --git a/bindgen-tests/tests/headers/mangling-linux32.hpp b/bindgen-tests/tests/headers/mangling-linux32.hpp
new file mode 100644
index 00000000..450c91d7
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-linux32.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- --target=i586-unknown-linux
+
+extern "C" void foo();
+
+struct Foo {
+  static bool sBar;
+};
diff --git a/bindgen-tests/tests/headers/mangling-linux64.hpp b/bindgen-tests/tests/headers/mangling-linux64.hpp
new file mode 100644
index 00000000..36dda913
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-linux64.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- --target=x86_64-unknown-linux
+
+extern "C" void foo();
+
+struct Foo {
+  static bool sBar;
+};
diff --git a/bindgen-tests/tests/headers/mangling-macos.hpp b/bindgen-tests/tests/headers/mangling-macos.hpp
new file mode 100644
index 00000000..94b16202
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-macos.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- --target=x86_64-apple-darwin
+
+extern "C" void foo();
+
+struct Foo {
+  static bool sBar;
+};
diff --git a/bindgen-tests/tests/headers/mangling-win32.hpp b/bindgen-tests/tests/headers/mangling-win32.hpp
new file mode 100644
index 00000000..386df4ab
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-win32.hpp
@@ -0,0 +1,18 @@
+// bindgen-flags: -- --target=i686-pc-win32
+
+extern "C" void foo();
+
+struct Foo {
+  static bool sBar;
+};
+
+// Also test some x86 Windows specific calling conventions that have their own
+// special mangling
+extern "C" {
+    int _fastcall fast_call_func_no_args();
+    // This will result in a suffix with more than one character (i.e. `@12`)
+    int _fastcall fast_call_func_many_args(int,int,int);
+    int _stdcall std_call_func_no_args();
+    // This will result in a suffix with more than one character (i.e. `@12`)
+    int _stdcall std_call_func_many_args(int,int,int);
+}
diff --git a/bindgen-tests/tests/headers/mangling-win64.hpp b/bindgen-tests/tests/headers/mangling-win64.hpp
new file mode 100644
index 00000000..8882d7dd
--- /dev/null
+++ b/bindgen-tests/tests/headers/mangling-win64.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- --target=x86_64-pc-win32
+
+extern "C" void foo();
+
+struct Foo {
+  static bool sBar;
+};
diff --git a/bindgen-tests/tests/headers/merge-extern-blocks.h b/bindgen-tests/tests/headers/merge-extern-blocks.h
new file mode 100644
index 00000000..1d46b7d4
--- /dev/null
+++ b/bindgen-tests/tests/headers/merge-extern-blocks.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --merge-extern-blocks -- --target=x86_64-unknown-linux
+int foo();
+typedef struct Point {
+    int x;
+} Point;
+int bar();
diff --git a/bindgen-tests/tests/headers/method-mangling.hpp b/bindgen-tests/tests/headers/method-mangling.hpp
new file mode 100644
index 00000000..0dac4975
--- /dev/null
+++ b/bindgen-tests/tests/headers/method-mangling.hpp
@@ -0,0 +1,5 @@
+
+class Foo {
+public:
+  int type();
+};
diff --git a/bindgen-tests/tests/headers/module-allowlisted.hpp b/bindgen-tests/tests/headers/module-allowlisted.hpp
new file mode 100644
index 00000000..f41e874e
--- /dev/null
+++ b/bindgen-tests/tests/headers/module-allowlisted.hpp
@@ -0,0 +1,2 @@
+// bindgen-flags: --enable-cxx-namespaces
+struct Test {};
diff --git a/bindgen-tests/tests/headers/msvc-no-usr.hpp b/bindgen-tests/tests/headers/msvc-no-usr.hpp
new file mode 100644
index 00000000..b15e49f5
--- /dev/null
+++ b/bindgen-tests/tests/headers/msvc-no-usr.hpp
@@ -0,0 +1,8 @@
+
+typedef unsigned long long size_t;
+
+class A {
+  const size_t foo;
+
+  A() : foo(5) {}
+};
diff --git a/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp b/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp
new file mode 100644
index 00000000..1e2b133a
--- /dev/null
+++ b/bindgen-tests/tests/headers/multiple-inherit-empty-correct-layout.hpp
@@ -0,0 +1,3 @@
+struct Foo {};
+struct Bar {};
+struct Baz : public Foo, public Bar {};
diff --git a/bindgen-tests/tests/headers/mutable.hpp b/bindgen-tests/tests/headers/mutable.hpp
new file mode 100644
index 00000000..b61a1031
--- /dev/null
+++ b/bindgen-tests/tests/headers/mutable.hpp
@@ -0,0 +1,14 @@
+class C {
+    mutable int m_member;
+    int m_other;
+};
+
+class NonCopiable {
+    mutable int m_member;
+
+    ~NonCopiable() {};
+};
+
+class NonCopiableWithNonCopiableMutableMember {
+    mutable NonCopiable m_member;
+};
diff --git a/bindgen-tests/tests/headers/namespace.hpp b/bindgen-tests/tests/headers/namespace.hpp
new file mode 100644
index 00000000..7e4197da
--- /dev/null
+++ b/bindgen-tests/tests/headers/namespace.hpp
@@ -0,0 +1,51 @@
+// bindgen-flags: --enable-cxx-namespaces --module-raw-line root::whatever 'pub type whatever_other_thing_t = whatever_int_t;'
+
+void top_level();
+
+namespace whatever {
+    typedef int whatever_int_t;
+
+    void in_whatever();
+}
+
+namespace {
+    namespace empty {}
+
+    struct A {
+        whatever::whatever_int_t b;
+    };
+}
+
+template<typename T>
+class C: public A {
+    T m_c;
+    T* m_c_ptr;
+    T m_c_arr[10];
+};
+
+template<>
+class C<int>;
+
+namespace w {
+    typedef unsigned int whatever_int_t;
+
+    template<typename T>
+    class D {
+        C<T> m_c;
+    };
+
+    whatever_int_t heh(); // this should return w::whatever_int_t, and not whatever::whatever_int_t
+
+    C<int> foo();
+
+    C<float> barr(); // <- This is the problematic one
+}
+
+#define NAMESPACE foobar
+namespace NAMESPACE {
+    void foo();
+}
+
+#include "namespace/nsbegin.h"
+void bar();
+#include "namespace/nsend.h"
diff --git a/bindgen-tests/tests/headers/namespace/nsbegin.h b/bindgen-tests/tests/headers/namespace/nsbegin.h
new file mode 100644
index 00000000..47a51c93
--- /dev/null
+++ b/bindgen-tests/tests/headers/namespace/nsbegin.h
@@ -0,0 +1 @@
+namespace faraway {
diff --git a/bindgen-tests/tests/headers/namespace/nsend.h b/bindgen-tests/tests/headers/namespace/nsend.h
new file mode 100644
index 00000000..5c34318c
--- /dev/null
+++ b/bindgen-tests/tests/headers/namespace/nsend.h
@@ -0,0 +1 @@
+}
diff --git a/bindgen-tests/tests/headers/nested-template-typedef.hpp b/bindgen-tests/tests/headers/nested-template-typedef.hpp
new file mode 100644
index 00000000..8c83de5b
--- /dev/null
+++ b/bindgen-tests/tests/headers/nested-template-typedef.hpp
@@ -0,0 +1,8 @@
+template<typename T>
+class Foo {
+public:
+    template<typename U>
+    struct Bar {
+        typedef Foo<U> FooU;
+    };
+};
diff --git a/bindgen-tests/tests/headers/nested.hpp b/bindgen-tests/tests/headers/nested.hpp
new file mode 100644
index 00000000..299e1768
--- /dev/null
+++ b/bindgen-tests/tests/headers/nested.hpp
@@ -0,0 +1,15 @@
+
+class Calc {
+    int w;
+};
+
+class Test {
+public:
+    struct Size;
+    friend struct Size;
+    struct Size {
+        struct Dimension : public Calc {
+        };
+        Dimension mWidth, mHeight;
+    };
+};
diff --git a/bindgen-tests/tests/headers/nested_vtable.hpp b/bindgen-tests/tests/headers/nested_vtable.hpp
new file mode 100644
index 00000000..87d6ce1f
--- /dev/null
+++ b/bindgen-tests/tests/headers/nested_vtable.hpp
@@ -0,0 +1,8 @@
+class nsISupports {
+public:
+  virtual nsISupports* QueryInterface();
+};
+
+class nsIRunnable : public nsISupports {};
+
+class Runnable : public nsIRunnable {};
diff --git a/bindgen-tests/tests/headers/nested_within_namespace.hpp b/bindgen-tests/tests/headers/nested_within_namespace.hpp
new file mode 100644
index 00000000..a9b7c1ec
--- /dev/null
+++ b/bindgen-tests/tests/headers/nested_within_namespace.hpp
@@ -0,0 +1,15 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+namespace foo {
+  class Bar {
+    int foo;
+
+    class Baz {
+      int foo;
+    };
+  };
+
+  class Baz {
+    int baz;
+  };
+}
diff --git a/bindgen-tests/tests/headers/newtype-enum.hpp b/bindgen-tests/tests/headers/newtype-enum.hpp
new file mode 100644
index 00000000..890683ae
--- /dev/null
+++ b/bindgen-tests/tests/headers/newtype-enum.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --newtype-enum "Foo" --rust-target 1.28  -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
diff --git a/bindgen-tests/tests/headers/newtype-global-enum.hpp b/bindgen-tests/tests/headers/newtype-global-enum.hpp
new file mode 100644
index 00000000..8021a3cc
--- /dev/null
+++ b/bindgen-tests/tests/headers/newtype-global-enum.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --newtype-global-enum "Foo" --rust-target 1.28  -- -std=c++11
+
+enum Foo {
+  Bar = 1 << 1,
+  Baz = 1 << 2,
+  Duplicated = 1 << 2,
+  Negative = -3,
+};
diff --git a/bindgen-tests/tests/headers/no-comments.h b/bindgen-tests/tests/headers/no-comments.h
new file mode 100644
index 00000000..1ddb1a3b
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-comments.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --no-doc-comments
+
+struct Foo {
+    int s; /*!< Including this will prevent rustc for compiling it */
+};
diff --git a/bindgen-tests/tests/headers/no-derive-debug.h b/bindgen-tests/tests/headers/no-derive-debug.h
new file mode 100644
index 00000000..d11ca0ad
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-derive-debug.h
@@ -0,0 +1,15 @@
+// bindgen-flags: --no-derive-debug --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Default)] pub struct foo { bar: ::std::os::raw::c_int, }"
+
+struct foo {
+  int bar;
+};
+
+/**
+ * bar should compile. It will normally derive debug, but our blocklist of foo
+ * and replacement for another type that doesn't implement it would prevent it
+ * from building if --no-derive-debug didn't work.
+ */
+struct bar {
+  struct foo foo;
+  int baz;
+};
diff --git a/bindgen-tests/tests/headers/no-derive-default.h b/bindgen-tests/tests/headers/no-derive-default.h
new file mode 100644
index 00000000..d184ee3a
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-derive-default.h
@@ -0,0 +1,15 @@
+// bindgen-flags: --no-derive-default --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct foo { bar: ::std::os::raw::c_int, }"
+
+struct foo {
+  int bar;
+};
+
+/**
+ * bar should compile. It will normally derive default, but our blocklist of foo
+ * and replacement for another type that doesn't implement it would prevent it
+ * from building if --no-derive-default didn't work.
+ */
+struct bar {
+  struct foo foo;
+  int baz;
+};
diff --git a/bindgen-tests/tests/headers/no-hash-allowlisted.hpp b/bindgen-tests/tests/headers/no-hash-allowlisted.hpp
new file mode 100644
index 00000000..0f60817d
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-hash-allowlisted.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-hash --allowlist-type "NoHash" --no-hash "NoHash"
+
+class NoHash {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no-hash-opaque.hpp b/bindgen-tests/tests/headers/no-hash-opaque.hpp
new file mode 100644
index 00000000..c1db2cd1
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-hash-opaque.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-hash --opaque-type "NoHash" --no-hash "NoHash"
+
+class NoHash {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp b/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp
new file mode 100644
index 00000000..ced1b42a
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-partialeq-allowlisted.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-partialeq --allowlist-type "NoPartialEq" --no-partialeq "NoPartialEq"
+
+class NoPartialEq {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no-partialeq-opaque.hpp b/bindgen-tests/tests/headers/no-partialeq-opaque.hpp
new file mode 100644
index 00000000..a5a03cd2
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-partialeq-opaque.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-partialeq --opaque-type "NoPartialEq" --no-partialeq "NoPartialEq"
+
+class NoPartialEq {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no-recursive-allowlisting.h b/bindgen-tests/tests/headers/no-recursive-allowlisting.h
new file mode 100644
index 00000000..1c661711
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-recursive-allowlisting.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --no-recursive-allowlist --allowlist-type "Foo" --raw-line "pub enum Bar {}" --rustified-enum ".*"
+
+struct Bar;
+
+struct Foo {
+  struct Bar* baz;
+};
diff --git a/bindgen-tests/tests/headers/no-std.h b/bindgen-tests/tests/headers/no-std.h
new file mode 100644
index 00000000..d98abced
--- /dev/null
+++ b/bindgen-tests/tests/headers/no-std.h
@@ -0,0 +1,5 @@
+// bindgen-flags: --ctypes-prefix "libc" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub type c_int = i32; pub enum c_void {} }" --rustified-enum ".*"
+struct foo {
+  int a, b;
+  void* bar;
+};
diff --git a/bindgen-tests/tests/headers/no_copy.hpp b/bindgen-tests/tests/headers/no_copy.hpp
new file mode 100644
index 00000000..349e428e
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_copy.hpp
@@ -0,0 +1,6 @@
+
+/** <div rustbindgen nocopy></div> */
+template<typename T>
+class CopiableButWait {
+    int whatever;
+};
diff --git a/bindgen-tests/tests/headers/no_copy_allowlisted.hpp b/bindgen-tests/tests/headers/no_copy_allowlisted.hpp
new file mode 100644
index 00000000..f3b922ca
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_copy_allowlisted.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --allowlist-type "NoCopy" --no-copy "NoCopy"
+
+class NoCopy {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_copy_opaque.hpp b/bindgen-tests/tests/headers/no_copy_opaque.hpp
new file mode 100644
index 00000000..c21f213a
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_copy_opaque.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --opaque-type "NoCopy" --no-copy "NoCopy"
+
+class NoCopy {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_debug.hpp b/bindgen-tests/tests/headers/no_debug.hpp
new file mode 100644
index 00000000..2017f75d
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_debug.hpp
@@ -0,0 +1,6 @@
+
+/** <div rustbindgen nodebug></div> */
+template<typename T>
+class DebugButWait {
+    int whatever;
+};
diff --git a/bindgen-tests/tests/headers/no_debug_allowlisted.hpp b/bindgen-tests/tests/headers/no_debug_allowlisted.hpp
new file mode 100644
index 00000000..3e3633e4
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_debug_allowlisted.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --allowlist-type "NoDebug" --no-debug "NoDebug"
+
+class NoDebug {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp b/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp
new file mode 100644
index 00000000..d934d2c7
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_debug_bypass_impl_debug.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --no-debug "NoDebug" --impl-debug --rust-target 1.40
+
+template<typename T>
+class Generic {
+  T t[40];
+};
+
+template<typename T>
+class NoDebug {
+  T t[40];
+};
diff --git a/bindgen-tests/tests/headers/no_debug_opaque.hpp b/bindgen-tests/tests/headers/no_debug_opaque.hpp
new file mode 100644
index 00000000..d5dc18f7
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_debug_opaque.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --opaque-type "NoDebug" --no-debug "NoDebug"
+
+class NoDebug {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_default.hpp b/bindgen-tests/tests/headers/no_default.hpp
new file mode 100644
index 00000000..79d25fbd
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_default.hpp
@@ -0,0 +1,11 @@
+
+/** <div rustbindgen nodefault></div> */
+template<typename T>
+class DefaultButWait {
+    int whatever;
+};
+
+template<typename T>
+class DefaultButWaitDerived {
+    DefaultButWait<T> whatever;
+};
diff --git a/bindgen-tests/tests/headers/no_default_allowlisted.hpp b/bindgen-tests/tests/headers/no_default_allowlisted.hpp
new file mode 100644
index 00000000..8a604081
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_default_allowlisted.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --allowlist-type "NoDefault" --no-default "NoDefault"
+
+class NoDefault {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp b/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp
new file mode 100644
index 00000000..ab0fdfae
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_default_bypass_derive_default.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --no-default "NoDefault" --rust-target 1.40
+
+template<typename T>
+class Generic {
+  T t[40];
+};
+
+template<typename T>
+class NoDefault {
+  T t[40];
+};
diff --git a/bindgen-tests/tests/headers/no_default_opaque.hpp b/bindgen-tests/tests/headers/no_default_opaque.hpp
new file mode 100644
index 00000000..3245d8f9
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_default_opaque.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --opaque-type "NoDefault" --no-default "NoDefault"
+
+class NoDefault {
+  int i;
+};
diff --git a/bindgen-tests/tests/headers/no_size_t_is_usize.h b/bindgen-tests/tests/headers/no_size_t_is_usize.h
new file mode 100644
index 00000000..d4370baf
--- /dev/null
+++ b/bindgen-tests/tests/headers/no_size_t_is_usize.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --no-size_t-is-usize
+
+typedef unsigned long size_t;
+typedef long ssize_t;
+
+struct A {
+  size_t len;
+  ssize_t offset;
+  struct A* next;
+};
diff --git a/bindgen-tests/tests/headers/non-type-params.hpp b/bindgen-tests/tests/headers/non-type-params.hpp
new file mode 100644
index 00000000..3e2ccf8e
--- /dev/null
+++ b/bindgen-tests/tests/headers/non-type-params.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T, unsigned int Capacity>
+struct Array {
+    T elements[Capacity];
+};
+
+template <typename T>
+using Array16 = Array<T, 16>;
+
+using ArrayInt4 = Array<int, 4>;
+
+struct UsesArray {
+    Array16<char>  array_char_16;
+    Array<bool, 8> array_bool_8;
+    ArrayInt4      array_int_4;
+};
diff --git a/bindgen-tests/tests/headers/noreturn.hpp b/bindgen-tests/tests/headers/noreturn.hpp
new file mode 100644
index 00000000..4ce1e11e
--- /dev/null
+++ b/bindgen-tests/tests/headers/noreturn.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: --enable-function-attribute-detection -- -std=c++11
+_Noreturn void f(void);
+__attribute__((noreturn)) void g(void);
+[[noreturn]] void h(void);
diff --git a/bindgen-tests/tests/headers/nsBaseHashtable.hpp b/bindgen-tests/tests/headers/nsBaseHashtable.hpp
new file mode 100644
index 00000000..36a480f2
--- /dev/null
+++ b/bindgen-tests/tests/headers/nsBaseHashtable.hpp
@@ -0,0 +1,48 @@
+// bindgen-flags: -- -std=c++14
+
+using uint32_t = unsigned long;
+using size_t = unsigned long long;
+
+template<class KeyClass, class DataType>
+class nsBaseHashtableET {
+};
+
+template<class Entry>
+class nsTHashtable {
+};
+
+template<class KeyClass, class DataType, class UserDataType>
+class nsBaseHashtable
+  : protected nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>
+{
+
+public:
+  typedef typename KeyClass::KeyType KeyType;
+  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
+
+  using nsTHashtable<EntryType>::Contains;
+  using nsTHashtable<EntryType>::GetGeneration;
+
+  nsBaseHashtable() {}
+  explicit nsBaseHashtable(uint32_t);
+
+  struct LookupResult {
+  private:
+    EntryType* mEntry;
+    nsBaseHashtable& mTable;
+
+  public:
+    LookupResult(EntryType*, nsBaseHashtable&);
+  };
+
+  struct EntryPtr {
+  private:
+    EntryType& mEntry;
+    bool mExistingEntry;
+
+  public:
+    EntryPtr(nsBaseHashtable&, EntryType*, bool);
+    ~EntryPtr();
+  };
+
+};
diff --git a/bindgen-tests/tests/headers/nsStyleAutoArray.hpp b/bindgen-tests/tests/headers/nsStyleAutoArray.hpp
new file mode 100644
index 00000000..3049ea21
--- /dev/null
+++ b/bindgen-tests/tests/headers/nsStyleAutoArray.hpp
@@ -0,0 +1,58 @@
+// bindgen-flags: --rustified-enum ".*"
+
+template<typename T>
+class nsTArray {
+    T* mBuff;
+};
+
+template<typename T>
+class nsStyleAutoArray
+{
+public:
+  // This constructor places a single element in mFirstElement.
+  enum WithSingleInitialElement { WITH_SINGLE_INITIAL_ELEMENT };
+  explicit nsStyleAutoArray(WithSingleInitialElement) {}
+  nsStyleAutoArray(const nsStyleAutoArray& aOther) { *this = aOther; }
+  nsStyleAutoArray& operator=(const nsStyleAutoArray& aOther) {
+    mFirstElement = aOther.mFirstElement;
+    mOtherElements = aOther.mOtherElements;
+    return *this;
+  }
+
+  bool operator==(const nsStyleAutoArray& aOther) const {
+    return Length() == aOther.Length() &&
+           mFirstElement == aOther.mFirstElement &&
+           mOtherElements == aOther.mOtherElements;
+  }
+  bool operator!=(const nsStyleAutoArray& aOther) const {
+    return !(*this == aOther);
+  }
+
+  unsigned long Length() const {
+    return mOtherElements.Length() + 1;
+  }
+  const T& operator[](unsigned long aIndex) const {
+    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
+  }
+  T& operator[](unsigned long aIndex) {
+    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
+  }
+
+  void EnsureLengthAtLeast(unsigned long aMinLen) {
+    if (aMinLen > 0) {
+      mOtherElements.EnsureLengthAtLeast(aMinLen - 1);
+    }
+  }
+
+  void SetLengthNonZero(unsigned long aNewLen) {
+    mOtherElements.SetLength(aNewLen - 1);
+  }
+
+  void TruncateLengthNonZero(unsigned long aNewLen) {
+    mOtherElements.TruncateLength(aNewLen - 1);
+  }
+
+private:
+  T mFirstElement;
+  nsTArray<T> mOtherElements;
+};
diff --git a/bindgen-tests/tests/headers/objc_allowlist.h b/bindgen-tests/tests/headers/objc_allowlist.h
new file mode 100644
index 00000000..b5406d0a
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_allowlist.h
@@ -0,0 +1,24 @@
+// bindgen-flags: --allowlist-type IAllowlistMe --allowlist-type AllowlistMe_InterestingCategory -- -x objective-c
+// bindgen-osx-only
+
+
+// Protocol should be included, since it is used by the AllowlistMe
+@protocol SomeProtocol
+-(void)protocolMethod;
++(void)protocolClassMethod;
+@end
+
+// The allowlisted item
+@interface AllowlistMe <SomeProtocol>
+-(void)method;
++(void)classMethod;
+@end
+
+// This was also explicitly allowlisted
+@interface AllowlistMe (InterestingCategory)
+@end
+
+// This was not automatically allowlisted
+@interface AllowlistMe (IgnoredCategory)
+@end
+
diff --git a/bindgen-tests/tests/headers/objc_blocklist.h b/bindgen-tests/tests/headers/objc_blocklist.h
new file mode 100644
index 00000000..605f2993
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_blocklist.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --objc-extern-crate --blocklist-item ISomeClass::class_ambiguouslyBlockedMethod --blocklist-item ISomeClass::blockedInstanceMethod -- -x objective-c
+// bindgen-osx-only
+
+@interface SomeClass
++ (void)ambiguouslyBlockedMethod;
+- (void)ambiguouslyBlockedMethod;
+- (void)instanceMethod;
+- (void)blockedInstanceMethod;
+@end
diff --git a/bindgen-tests/tests/headers/objc_category.h b/bindgen-tests/tests/headers/objc_category.h
new file mode 100644
index 00000000..b8e60d5f
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_category.h
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+-(void)method;
+@end
+
+@interface Foo (BarCategory)
+-(void)categoryMethod;
+@end
diff --git a/bindgen-tests/tests/headers/objc_class.h b/bindgen-tests/tests/headers/objc_class.h
new file mode 100644
index 00000000..f5ec9507
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_class.h
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@class Foo;
+
+Foo* fooVar;
+
+@interface Foo
+-(void)method;
+@end
diff --git a/bindgen-tests/tests/headers/objc_class_method.h b/bindgen-tests/tests/headers/objc_class_method.h
new file mode 100644
index 00000000..1a68ed3e
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_class_method.h
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
++ (void)method;
++ (void)methodWithInt:(int)foo;
++ (void)methodWithFoo:(Foo*)foo;
++ (int)methodReturningInt;
++ (Foo*)methodReturningFoo;
++ (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue;
+@end
diff --git a/bindgen-tests/tests/headers/objc_inheritance.h b/bindgen-tests/tests/headers/objc_inheritance.h
new file mode 100644
index 00000000..985f1597
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_inheritance.h
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+@end
+
+@interface Bar: Foo
+@end
+
+@interface Baz: Bar
+@end
diff --git a/bindgen-tests/tests/headers/objc_interface.h b/bindgen-tests/tests/headers/objc_interface.h
new file mode 100644
index 00000000..df16e921
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_interface.h
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+@end
+
+@protocol bar
+@end
diff --git a/bindgen-tests/tests/headers/objc_interface_type.h b/bindgen-tests/tests/headers/objc_interface_type.h
new file mode 100644
index 00000000..4667ce2a
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_interface_type.h
@@ -0,0 +1,13 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+@end
+
+struct FooStruct {
+  Foo *foo;
+};
+
+void fooFunc(Foo *foo);
+
+static const Foo *kFoo;
diff --git a/bindgen-tests/tests/headers/objc_method.h b/bindgen-tests/tests/headers/objc_method.h
new file mode 100644
index 00000000..b89d1621
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_method.h
@@ -0,0 +1,15 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+- (void)method;
+- (void)methodWithInt:(int)foo;
+- (void)methodWithFoo:(Foo*)foo;
+- (int)methodReturningInt;
+- (Foo*)methodReturningFoo;
+- (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue;
+- (instancetype)methodWithAndWithoutKeywords:(int)arg1
+                                    arg2Name:(float)arg2
+                                            :(float)arg3
+                                    arg4Name:(int)arg4;
+@end
diff --git a/bindgen-tests/tests/headers/objc_method_clash.h b/bindgen-tests/tests/headers/objc_method_clash.h
new file mode 100644
index 00000000..d99d3691
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_method_clash.h
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
++ (void)foo;
+- (void)foo;
+@end
diff --git a/bindgen-tests/tests/headers/objc_pointer_return_types.h b/bindgen-tests/tests/headers/objc_pointer_return_types.h
new file mode 100644
index 00000000..4d1a6dea
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_pointer_return_types.h
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Bar
+@end
+
+@interface Foo
++ (Bar*)methodReturningBar;
+- (void)methodUsingBar:(Bar *)my_bar;
+@end
diff --git a/bindgen-tests/tests/headers/objc_property_fnptr.h b/bindgen-tests/tests/headers/objc_property_fnptr.h
new file mode 100644
index 00000000..fe3e7fcc
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_property_fnptr.h
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo
+@property int (*func)(char, short, float);
+@end
diff --git a/bindgen-tests/tests/headers/objc_protocol.h b/bindgen-tests/tests/headers/objc_protocol.h
new file mode 100644
index 00000000..46978a3b
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_protocol.h
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@protocol Foo
+@end
+
+@interface Foo <Foo>
+@end
diff --git a/bindgen-tests/tests/headers/objc_protocol_inheritance.h b/bindgen-tests/tests/headers/objc_protocol_inheritance.h
new file mode 100644
index 00000000..13135fdd
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_protocol_inheritance.h
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@protocol Foo
+@end
+
+@interface Foo <Foo>
+@end
+
+@interface Bar : Foo
+@end
diff --git a/bindgen-tests/tests/headers/objc_sel_and_id.h b/bindgen-tests/tests/headers/objc_sel_and_id.h
new file mode 100644
index 00000000..6491a541
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_sel_and_id.h
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+id object;
+SEL selector;
+
+void f(id object, SEL selector);
diff --git a/bindgen-tests/tests/headers/objc_template.h b/bindgen-tests/tests/headers/objc_template.h
new file mode 100644
index 00000000..b616da01
--- /dev/null
+++ b/bindgen-tests/tests/headers/objc_template.h
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -x objective-c
+// bindgen-osx-only
+
+@interface Foo<__covariant ObjectType>
+- (ObjectType)get;
+@end
+
+@interface FooMultiGeneric<__covariant KeyType, __covariant ObjectType>
+- (nullable ObjectType)objectForKey:(KeyType)key;
+@end
diff --git a/bindgen-tests/tests/headers/only_bitfields.hpp b/bindgen-tests/tests/headers/only_bitfields.hpp
new file mode 100644
index 00000000..793bc66b
--- /dev/null
+++ b/bindgen-tests/tests/headers/only_bitfields.hpp
@@ -0,0 +1,4 @@
+class C {
+    bool a: 1;
+    bool b: 7;
+};
diff --git a/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp b/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp
new file mode 100644
index 00000000..85b648ff
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque-template-inst-member-2.hpp
@@ -0,0 +1,20 @@
+// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+/// This is like `opaque-template-inst-member.hpp` except exercising the cases
+/// where we are OK to derive Debug/Hash/PartialEq.
+
+template<typename T>
+class OpaqueTemplate {
+    T mData;
+};
+
+/// Should derive Debug/Hash/PartialEq.
+class ContainsOpaqueTemplate {
+    OpaqueTemplate<int> mBlah;
+    int mBaz;
+};
+
+/// Should also derive Debug/Hash/PartialEq.
+class InheritsOpaqueTemplate : public OpaqueTemplate<bool> {
+    char* wow;
+};
diff --git a/bindgen-tests/tests/headers/opaque-template-inst-member.hpp b/bindgen-tests/tests/headers/opaque-template-inst-member.hpp
new file mode 100644
index 00000000..9b327919
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque-template-inst-member.hpp
@@ -0,0 +1,20 @@
+// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --impl-partialeq --with-derive-eq --rust-target 1.40
+
+template<typename T>
+class OpaqueTemplate {
+    T mData;
+    bool mCannotDebug[400];
+};
+
+/// This should not end up deriving Debug/Hash because its `mBlah` field cannot derive
+/// Debug/Hash because the instantiation's definition cannot derive Debug/Hash.
+class ContainsOpaqueTemplate {
+    OpaqueTemplate<int> mBlah;
+    int mBaz;
+};
+
+/// This should not end up deriving Debug/Hash either, for similar reasons, although
+/// we're exercising base member edges now.
+class InheritsOpaqueTemplate : public OpaqueTemplate<bool> {
+    char* wow;
+};
diff --git a/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp b/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp
new file mode 100644
index 00000000..e1cadcc2
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque-template-instantiation-namespaced.hpp
@@ -0,0 +1,29 @@
+// bindgen-flags: --enable-cxx-namespaces --opaque-type 'zoidberg::Template<zoidberg::Bar>'  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
+
+namespace zoidberg {
+
+template <typename T>
+class Template {
+    T member;
+};
+
+struct Foo {
+    char c;
+};
+
+struct Bar {
+    int i;
+};
+
+class ContainsInstantiation {
+    Template<Foo> not_opaque;
+};
+
+class ContainsOpaqueInstantiation {
+    // We should not generate a layout test for this instantiation, and it
+    // should appear as an opaque blob of bytes in
+    // `ContainsOpaqueInstantiation`'s type definition.
+    Template<Bar> opaque;
+};
+
+}
diff --git a/bindgen-tests/tests/headers/opaque-template-instantiation.hpp b/bindgen-tests/tests/headers/opaque-template-instantiation.hpp
new file mode 100644
index 00000000..fff49af2
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque-template-instantiation.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --opaque-type 'Template<int>'  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
+
+template <typename T>
+class Template {
+    T member;
+};
+
+class ContainsInstantiation {
+    Template<char> not_opaque;
+};
+
+class ContainsOpaqueInstantiation {
+    // We should not generate a layout test for this instantiation, and it
+    // should appear as an opaque blob of bytes in
+    // `ContainsOpaqueInstantiation`'s type definition.
+    Template<int> opaque;
+};
diff --git a/bindgen-tests/tests/headers/opaque-tracing.hpp b/bindgen-tests/tests/headers/opaque-tracing.hpp
new file mode 100644
index 00000000..cf65276a
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque-tracing.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --opaque-type ".*" --allowlist-function=foo  --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+class Container;
+
+// The allowlist tracing should reach the Container type, even though it's
+// marked as opaque.
+void foo(Container* c);
+
+template<typename T>
+class Wat {
+  T foo;
+};
+
+class OtherOpaque {
+  int bar;
+};
+
+class Container {
+  Wat<int> bar;
+  OtherOpaque baz;
+};
diff --git a/bindgen-tests/tests/headers/opaque_in_struct.hpp b/bindgen-tests/tests/headers/opaque_in_struct.hpp
new file mode 100644
index 00000000..12910e1f
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque_in_struct.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+
+/** <div rustbindgen opaque> */
+typedef struct opaque {
+    int waht;
+} opaque;
+
+struct container {
+    opaque contained;
+};
diff --git a/bindgen-tests/tests/headers/opaque_pointer.hpp b/bindgen-tests/tests/headers/opaque_pointer.hpp
new file mode 100644
index 00000000..00868985
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque_pointer.hpp
@@ -0,0 +1,23 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+/**
+ * <div rustbindgen opaque></div>
+ */
+struct OtherOpaque {
+    int c;
+};
+
+/**
+ * <div rustbindgen opaque></div>
+ */
+template <typename T>
+struct Opaque {
+    T whatever;
+};
+
+struct WithOpaquePtr {
+    Opaque<int>* whatever;
+    Opaque<float> other;
+    OtherOpaque t;
+};
+
diff --git a/bindgen-tests/tests/headers/opaque_typedef.hpp b/bindgen-tests/tests/headers/opaque_typedef.hpp
new file mode 100644
index 00000000..878d5bcb
--- /dev/null
+++ b/bindgen-tests/tests/headers/opaque_typedef.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags:  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
+template<typename T>
+class RandomTemplate;
+
+template<int i>
+class Wat;
+
+template<int i>
+class Wat3;
+
+template<>
+class Wat3<3>;
+
+/** <div rustbindgen opaque></div> */
+typedef RandomTemplate<int> ShouldBeOpaque;
+
+typedef RandomTemplate<float> ShouldNotBeOpaque;
diff --git a/bindgen-tests/tests/headers/operator.hpp b/bindgen-tests/tests/headers/operator.hpp
new file mode 100644
index 00000000..186f1fe6
--- /dev/null
+++ b/bindgen-tests/tests/headers/operator.hpp
@@ -0,0 +1,5 @@
+int operator_information(void);
+
+class Foo;
+int operator<<(const Foo&, int);
+
diff --git a/bindgen-tests/tests/headers/ord-enum.h b/bindgen-tests/tests/headers/ord-enum.h
new file mode 100644
index 00000000..364f711e
--- /dev/null
+++ b/bindgen-tests/tests/headers/ord-enum.h
@@ -0,0 +1,15 @@
+// bindgen-flags: --rustified-enum * --with-derive-ord
+
+enum A {
+	A0 = 0,
+	A1 = 1,
+	A2 = 2,
+	A3 = A0 - 1,
+};
+
+enum B {
+	B0 = 1,
+	B1 = B0 + 3,
+	B2 = B0 + 2,
+	B3 = B0 - 2,
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/overflowed_enum.hpp b/bindgen-tests/tests/headers/overflowed_enum.hpp
new file mode 100644
index 00000000..18d3fe41
--- /dev/null
+++ b/bindgen-tests/tests/headers/overflowed_enum.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -Wno-narrowing
+
+enum Foo {
+    BAP_ARM = 0x93fcb9,
+    BAP_X86 = 0xb67eed,
+    BAP_X86_64 = 0xba7b274f,
+};
+
+enum Bar: unsigned short {
+    One = 1,
+    Big = 65538,
+};
diff --git a/bindgen-tests/tests/headers/overloading.hpp b/bindgen-tests/tests/headers/overloading.hpp
new file mode 100644
index 00000000..3c2b0487
--- /dev/null
+++ b/bindgen-tests/tests/headers/overloading.hpp
@@ -0,0 +1,9 @@
+extern bool Evaluate(char r);
+extern bool Evaluate(int x, int y);
+
+namespace foo {
+    extern void MyFunction();
+}
+namespace bar {
+    extern void MyFunction();
+}
diff --git a/bindgen-tests/tests/headers/packed-bitfield.h b/bindgen-tests/tests/headers/packed-bitfield.h
new file mode 100644
index 00000000..ef23bc6a
--- /dev/null
+++ b/bindgen-tests/tests/headers/packed-bitfield.h
@@ -0,0 +1,5 @@
+struct Date {
+    unsigned char day: 5;
+    unsigned char month: 4;
+    signed short year: 15;
+} __attribute__((packed));
diff --git a/bindgen-tests/tests/headers/packed-n-with-padding.h b/bindgen-tests/tests/headers/packed-n-with-padding.h
new file mode 100644
index 00000000..8a6233b5
--- /dev/null
+++ b/bindgen-tests/tests/headers/packed-n-with-padding.h
@@ -0,0 +1,8 @@
+#pragma pack(push, 2)
+struct Packed {
+    char a;
+    short b;
+    char c;
+    int d;
+};
+#pragma pack(pop)
diff --git a/bindgen-tests/tests/headers/packed-vtable.h b/bindgen-tests/tests/headers/packed-vtable.h
new file mode 100644
index 00000000..d2413d45
--- /dev/null
+++ b/bindgen-tests/tests/headers/packed-vtable.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.33 -- -x c++ -std=c++11
+
+#pragma pack(1)
+
+// This should be packed.
+struct PackedVtable {
+  virtual ~PackedVtable();
+};
+
+#pragma pack()
diff --git a/bindgen-tests/tests/headers/parm-union.hpp b/bindgen-tests/tests/headers/parm-union.hpp
new file mode 100644
index 00000000..e36df691
--- /dev/null
+++ b/bindgen-tests/tests/headers/parm-union.hpp
@@ -0,0 +1,4 @@
+struct Struct
+{
+    void Function(union Union&);
+};
diff --git a/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h b/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h
new file mode 100644
index 00000000..9336cf89
--- /dev/null
+++ b/bindgen-tests/tests/headers/parsecb-anonymous-enum-variant-rename.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --allowlist-var ^MyVal$
+// bindgen-parse-callbacks: enum-variant-rename
+
+enum {
+    MyVal = 0,
+};
diff --git a/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp b/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp
new file mode 100644
index 00000000..4eb8f545
--- /dev/null
+++ b/bindgen-tests/tests/headers/partial-specialization-and-inheritance.hpp
@@ -0,0 +1,40 @@
+// bindgen-unstable
+
+// This was originally a test case generated by creducing errors in SpiderMonkey
+// bindings generation. I've tried to make it understandable by giving more
+// meaningful names to everything, and a couple comments.
+//
+// We don't support partial template specialization, but we *should*
+// successfully parse this header, and generate bindings for it, but the usage
+// of the partial template specialization should result in opaque blobs.
+
+// A base class providing a method.
+template <typename T>
+class Base {
+public:
+  void some_method(T, T);
+};
+
+// A template with a default representation.
+template <typename U>
+class Derived {
+    bool b;
+};
+
+// A partial specialization for pointers. Note that this should have a different
+// and larger layout than the template it is specializing.
+template <typename U>
+class Derived<U*> : public Base<U*> {
+    int x;
+    int y;
+};
+
+// A struct that uses the partial specialization and method from the partial
+// specialization's base class.
+struct Usage {
+  Usage() {
+      static_member.some_method(this, this);
+  }
+
+  static Derived<Usage*> static_member;
+};
diff --git a/bindgen-tests/tests/headers/pointer-attr.h b/bindgen-tests/tests/headers/pointer-attr.h
new file mode 100644
index 00000000..fe0004b8
--- /dev/null
+++ b/bindgen-tests/tests/headers/pointer-attr.h
@@ -0,0 +1 @@
+void a(const char __attribute__((btf_type_tag("a"))) *);
diff --git a/bindgen-tests/tests/headers/prepend-enum-constified-variant.h b/bindgen-tests/tests/headers/prepend-enum-constified-variant.h
new file mode 100644
index 00000000..e9ba0e73
--- /dev/null
+++ b/bindgen-tests/tests/headers/prepend-enum-constified-variant.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --no-prepend-enum-name --rustified-enum ".*"
+
+enum AVCodecID {
+  AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,
+  AV_CODEC_ID_TTF = 0x18000,
+};
diff --git a/bindgen-tests/tests/headers/prepend_enum_name.hpp b/bindgen-tests/tests/headers/prepend_enum_name.hpp
new file mode 100644
index 00000000..e7660369
--- /dev/null
+++ b/bindgen-tests/tests/headers/prepend_enum_name.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --no-prepend-enum-name
+
+enum foo {
+	FOO_BAR,
+	FOO_BAZ,
+};
diff --git a/bindgen-tests/tests/headers/private.hpp b/bindgen-tests/tests/headers/private.hpp
new file mode 100644
index 00000000..c0f3ce7f
--- /dev/null
+++ b/bindgen-tests/tests/headers/private.hpp
@@ -0,0 +1,21 @@
+
+struct HasPrivate {
+    int mNotPrivate;
+    /** <div rustbindgen private></div> */
+    int mIsPrivate;
+};
+
+
+/** <div rustbindgen private></div> */
+struct VeryPrivate {
+    int mIsPrivate;
+    int mIsAlsoPrivate;
+};
+
+
+/** <div rustbindgen private></div> */
+struct ContradictPrivate {
+    /** <div rustbindgen private="false"></div> */
+    int mNotPrivate;
+    int mIsPrivate;
+};
diff --git a/bindgen-tests/tests/headers/private_fields.hpp b/bindgen-tests/tests/headers/private_fields.hpp
new file mode 100644
index 00000000..9d55ebca
--- /dev/null
+++ b/bindgen-tests/tests/headers/private_fields.hpp
@@ -0,0 +1,44 @@
+// bindgen-flags: --respect-cxx-access-specs
+class PubPriv {
+  public:
+    int x;
+  private:
+    int y;
+};
+
+class PrivateBitFields {
+  unsigned int a : 4;
+  unsigned int b : 4;
+};
+class PublicBitFields {
+ public:
+  unsigned int a : 4;
+  unsigned int b : 4;
+};
+class MixedBitFields {
+  unsigned int a : 4;
+ public:
+  unsigned int d : 4;
+};
+
+class Base {
+ public:
+  int member;
+};
+
+class InheritsPrivately : Base {};
+class InheritsPublically : public Base {};
+
+class WithAnonStruct {
+  struct {
+     int a;
+  };
+ public:
+  struct {
+    int b;
+  };
+};
+
+class WithAnonUnion {
+  union {};
+};
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/public-dtor.hpp b/bindgen-tests/tests/headers/public-dtor.hpp
new file mode 100644
index 00000000..5d4fb592
--- /dev/null
+++ b/bindgen-tests/tests/headers/public-dtor.hpp
@@ -0,0 +1,15 @@
+
+
+namespace cv {
+class String {
+public:
+  ~String();
+};
+
+
+inline
+String::~String()
+{
+}
+
+}
diff --git a/bindgen-tests/tests/headers/qualified-dependent-types.hpp b/bindgen-tests/tests/headers/qualified-dependent-types.hpp
new file mode 100644
index 00000000..fcdfc87c
--- /dev/null
+++ b/bindgen-tests/tests/headers/qualified-dependent-types.hpp
@@ -0,0 +1,16 @@
+// Issue #2085.
+
+template<typename T>
+struct Foo;
+
+template<typename T, typename U>
+struct Bar {};
+
+template<typename T>
+struct Bar<T, void> {
+    using BarDependent = typename Foo<T>::Dependent;
+    void method(const BarDependent &);
+};
+
+template<typename T>
+void Bar<T, void>::method(const BarDependent &) {}
diff --git a/bindgen-tests/tests/headers/redeclaration.hpp b/bindgen-tests/tests/headers/redeclaration.hpp
new file mode 100644
index 00000000..d536b158
--- /dev/null
+++ b/bindgen-tests/tests/headers/redeclaration.hpp
@@ -0,0 +1,7 @@
+extern "C" {
+  void foo();
+}
+
+extern "C" {
+  void foo();
+}
diff --git a/bindgen-tests/tests/headers/ref_argument_array.hpp b/bindgen-tests/tests/headers/ref_argument_array.hpp
new file mode 100644
index 00000000..53f66950
--- /dev/null
+++ b/bindgen-tests/tests/headers/ref_argument_array.hpp
@@ -0,0 +1,6 @@
+
+#define NSID_LENGTH 10
+class nsID {
+public:
+  virtual void ToProvidedString(char (&aDest)[NSID_LENGTH]);
+};
diff --git a/bindgen-tests/tests/headers/reparented_replacement.hpp b/bindgen-tests/tests/headers/reparented_replacement.hpp
new file mode 100644
index 00000000..4ac2bf03
--- /dev/null
+++ b/bindgen-tests/tests/headers/reparented_replacement.hpp
@@ -0,0 +1,16 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+namespace foo {
+  struct Bar {
+    int baz;
+  };
+}
+
+namespace bar {
+  /// <div rustbindgen replaces="foo::Bar"></div>
+  struct Bar_Replacement {
+    int bazz;
+  };
+};
+
+typedef foo::Bar ReferencesBar;
diff --git a/bindgen-tests/tests/headers/replace_template_alias.hpp b/bindgen-tests/tests/headers/replace_template_alias.hpp
new file mode 100644
index 00000000..c325b5a3
--- /dev/null
+++ b/bindgen-tests/tests/headers/replace_template_alias.hpp
@@ -0,0 +1,23 @@
+// bindgen-flags: -- --std=c++14
+
+namespace JS {
+namespace detail {
+
+/// Notice how this doesn't use T.
+template <typename T>
+using MaybeWrapped = int;
+
+}
+
+template <typename T>
+class Rooted {
+    detail::MaybeWrapped<T> ptr;
+};
+
+}
+
+/// But the replacement type does use T!
+///
+/// <div rustbindgen replaces="JS::detail::MaybeWrapped" />
+template <typename T>
+using replaces_MaybeWrapped = T;
diff --git a/bindgen-tests/tests/headers/replace_use.hpp b/bindgen-tests/tests/headers/replace_use.hpp
new file mode 100644
index 00000000..de44eb19
--- /dev/null
+++ b/bindgen-tests/tests/headers/replace_use.hpp
@@ -0,0 +1,15 @@
+template<typename T>
+struct nsTArray {
+  int x;
+};
+/**
+ * <div rustbindgen replaces="nsTArray"></div>
+ */
+template<typename T>
+struct nsTArray_Simple {
+  unsigned int y;
+};
+
+struct Test {
+  nsTArray<long> a;
+};
diff --git a/bindgen-tests/tests/headers/replaces_double.hpp b/bindgen-tests/tests/headers/replaces_double.hpp
new file mode 100644
index 00000000..ce6a8dbb
--- /dev/null
+++ b/bindgen-tests/tests/headers/replaces_double.hpp
@@ -0,0 +1,20 @@
+// bindgen-flags: --blocklist-type Wrapper -- --std=c++11
+
+template<typename T>
+struct Wrapper {
+    struct Wrapped {
+        T t;
+    };
+    using Type = Wrapped;
+};
+
+template<typename T>
+class Rooted {
+    using MaybeWrapped = typename Wrapper<T>::Type;
+    MaybeWrapped ptr;
+
+    /**
+     * <div rustbindgen replaces="Rooted_MaybeWrapped"></div>
+     */
+    using MaybeWrapped_simple = T;
+};
diff --git a/bindgen-tests/tests/headers/repr-align.hpp b/bindgen-tests/tests/headers/repr-align.hpp
new file mode 100644
index 00000000..3347594b
--- /dev/null
+++ b/bindgen-tests/tests/headers/repr-align.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.25 -- -std=c++11
+
+struct alignas(8) a {
+  int b;
+  int c;
+};
+
+struct alignas(double) b {
+  int b;
+  int c;
+};
diff --git a/bindgen-tests/tests/headers/resolved_type_def_function.h b/bindgen-tests/tests/headers/resolved_type_def_function.h
new file mode 100644
index 00000000..139b8c3e
--- /dev/null
+++ b/bindgen-tests/tests/headers/resolved_type_def_function.h
@@ -0,0 +1,2 @@
+typedef void (FuncType) ();
+extern FuncType Func;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp b/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp
new file mode 100644
index 00000000..fe685845
--- /dev/null
+++ b/bindgen-tests/tests/headers/same_struct_name_in_different_namespaces.hpp
@@ -0,0 +1,12 @@
+namespace JS {
+
+    struct Zone;
+
+    namespace shadow {
+
+        struct Zone {
+            int x;
+            int y;
+        };
+    }
+}
diff --git a/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp b/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp
new file mode 100644
index 00000000..d44837d0
--- /dev/null
+++ b/bindgen-tests/tests/headers/sentry-defined-multiple-times.hpp
@@ -0,0 +1,85 @@
+// bindgen-flags: --enable-cxx-namespaces -- -std=c++11
+
+// `Wrapper::sentry` and `sentry` should be emitted as `Wrapper_sentry` and
+// `sentry` respectively, but instead `Wrapper::sentry` is named just `sentry`
+// which leads to compilation errors.
+//
+// Note: if there is no namespace, then we don't run into problems. Similarly,
+// making the `Wrapper::sentry` definition inline in `Wrapper`, rather than
+// declared inline with an out of line definition, makes the problem go away as
+// well.
+
+namespace whatever {
+    template <typename, typename>
+    class Wrapper {
+        // Declaration of Wrapper::sentry
+        class sentry;
+    };
+
+    // Definition of Wrapper::sentry
+    template <typename f, typename h>
+    class Wrapper<f, h>::sentry {
+        int i_am_wrapper_sentry;
+    };
+
+    class sentry {
+        bool i_am_plain_sentry;
+    };
+
+    // Ok, that was the original bug report. While we're here, let's just try
+    // lots of different things that could go wrong and make sure we handle them
+    // right.
+
+    class NotTemplateWrapper {
+        class sentry;
+    };
+
+    class NotTemplateWrapper::sentry {
+        char i_am_not_template_wrapper_sentry;
+    };
+
+    class InlineNotTemplateWrapper {
+        class sentry {
+            bool i_am_inline_not_template_wrapper_sentry;
+        };
+    };
+
+    template <typename, typename>
+    class InlineTemplateWrapper {
+        class sentry {
+            int i_am_inline_template_wrapper_sentry;
+        };
+    };
+
+    class OuterDoubleWrapper {
+        class InnerDoubleWrapper {
+            class sentry;
+        };
+    };
+
+    class OuterDoubleWrapper::InnerDoubleWrapper::sentry {
+        int i_am_double_wrapper_sentry;
+    };
+
+    class OuterDoubleInlineWrapper {
+        class InnerDoubleInlineWrapper {
+            class sentry {
+                int i_am_double_wrapper_inline_sentry;
+            };
+        };
+    };
+}
+
+template <typename, typename>
+class OutsideNamespaceWrapper {
+    class sentry;
+};
+
+template <typename f, typename h>
+class OutsideNamespaceWrapper<f, h>::sentry {
+    int i_am_outside_namespace_wrapper_sentry;
+};
+
+class sentry {
+    int i_am_outside_namespace_sentry;
+};
diff --git a/bindgen-tests/tests/headers/short-enums.hpp b/bindgen-tests/tests/headers/short-enums.hpp
new file mode 100644
index 00000000..14f833de
--- /dev/null
+++ b/bindgen-tests/tests/headers/short-enums.hpp
@@ -0,0 +1,19 @@
+// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -fshort-enums
+
+typedef enum {
+    SOME_VALUE = 0x1,
+} one_byte_t;
+
+static_assert(sizeof(one_byte_t) == 1, "Short enums should work");
+
+typedef enum {
+    SOME_OTHER_VALUE = 0x100,
+} two_byte_t;
+
+static_assert(sizeof(two_byte_t) == 2, "");
+
+typedef enum {
+    SOME_BIGGER_VALUE = 0x1000000,
+} four_byte_t;
+
+static_assert(sizeof(four_byte_t) == 4, "");
diff --git a/bindgen-tests/tests/headers/size_t_template.hpp b/bindgen-tests/tests/headers/size_t_template.hpp
new file mode 100644
index 00000000..6045c698
--- /dev/null
+++ b/bindgen-tests/tests/headers/size_t_template.hpp
@@ -0,0 +1,8 @@
+template<typename T, unsigned long N>
+class Array {
+    T inner[N];
+};
+
+class C {
+    Array<int, 3> arr;
+};
diff --git a/bindgen-tests/tests/headers/sorted-items.h b/bindgen-tests/tests/headers/sorted-items.h
new file mode 100644
index 00000000..11fc2ef4
--- /dev/null
+++ b/bindgen-tests/tests/headers/sorted-items.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --sort-semantically -- --target=x86_64-unknown-linux
+
+int foo();
+typedef int number;
+int bar(number x);
+struct Point
+{
+    number x;
+    number y;
+};
+struct Angle
+{
+    number a;
+    number b;
+};
+int baz(struct Point point);
+const number NUMBER = 42;
diff --git a/bindgen-tests/tests/headers/stdint_typedef.h b/bindgen-tests/tests/headers/stdint_typedef.h
new file mode 100644
index 00000000..f716a7f1
--- /dev/null
+++ b/bindgen-tests/tests/headers/stdint_typedef.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --allowlist-type="Struct" --allowlist-function="fun"
+
+// no typedef should be emitted for `__uint64_t`
+typedef unsigned long long __uint64_t;
+typedef __uint64_t uint64_t;
+
+uint64_t fun();
+struct Struct {
+	uint64_t field;
+};
diff --git a/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h b/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h
new file mode 100644
index 00000000..cf7cb5c4
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_containing_forward_declared_struct.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct a {
+    struct b* val_a;
+};
+
+struct b {
+    int val_b;
+};
diff --git a/bindgen-tests/tests/headers/struct_typedef.h b/bindgen-tests/tests/headers/struct_typedef.h
new file mode 100644
index 00000000..2ed7aabd
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_typedef.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
+//
+typedef struct {
+    _Bool has_name;
+} typedef_named_struct;
+
+typedef struct {
+    void *no_name;
+} *struct_ptr_t, **struct_ptr_ptr_t;
+
+typedef enum {
+    ENUM_HAS_NAME=1
+} typedef_named_enum;
+
+typedef enum {
+    ENUM_IS_ANON
+} *enum_ptr_t, **enum_ptr_ptr_t;
diff --git a/bindgen-tests/tests/headers/struct_typedef_ns.hpp b/bindgen-tests/tests/headers/struct_typedef_ns.hpp
new file mode 100644
index 00000000..40a7c680
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_typedef_ns.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces --rustified-enum ".*"
+
+namespace whatever {
+    typedef struct {
+        int foo;
+    } typedef_struct;
+
+    typedef enum {
+        BAR=1
+    } typedef_enum;
+}
+
+namespace {
+    typedef struct {
+        int foo;
+    } typedef_struct;
+
+    typedef enum {
+        BAR=1
+    } typedef_enum;
+}
diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct.h b/bindgen-tests/tests/headers/struct_with_anon_struct.h
new file mode 100644
index 00000000..a5e8476d
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_struct.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct foo {
+    struct {
+        int a;
+        int b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct_array.h b/bindgen-tests/tests/headers/struct_with_anon_struct_array.h
new file mode 100644
index 00000000..94a8ea0a
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_struct_array.h
@@ -0,0 +1,12 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct foo {
+    struct {
+        int a;
+        int b;
+    } bar[2];
+    struct {
+        int a;
+        int b;
+    } baz[2][3][4];
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h b/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h
new file mode 100644
index 00000000..d92c8011
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_struct_pointer.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct foo {
+    struct {
+        int a;
+        int b;
+    } *bar;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_union.h b/bindgen-tests/tests/headers/struct_with_anon_union.h
new file mode 100644
index 00000000..bd75563d
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_union.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_union_1_0.h b/bindgen-tests/tests/headers/struct_with_anon_union_1_0.h
new file mode 100644
index 00000000..847c354b
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_union_1_0.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h b/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h
new file mode 100644
index 00000000..92705238
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_unnamed_struct.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct foo {
+    struct {
+        unsigned int a;
+        unsigned int b;
+    };
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h
new file mode 100644
index 00000000..00fa4900
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    };
+};
diff --git a/bindgen-tests/tests/headers/struct_with_anon_unnamed_union_1_0.h b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union_1_0.h
new file mode 100644
index 00000000..791a1593
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_anon_unnamed_union_1_0.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    };
+};
diff --git a/bindgen-tests/tests/headers/struct_with_bitfields.h b/bindgen-tests/tests/headers/struct_with_bitfields.h
new file mode 100644
index 00000000..ba1af26d
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_bitfields.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct bitfield {
+    unsigned short
+    a   :1,
+    b   :1,
+    c   :1,
+        :1,
+        :2,
+    d   :2;
+    int e;
+    unsigned int f : 2;
+    unsigned int g : 32;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_derive_debug.h b/bindgen-tests/tests/headers/struct_with_derive_debug.h
new file mode 100644
index 00000000..4dc816b7
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_derive_debug.h
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rust-target 1.40
+//
+struct LittleArray {
+    int a[32];
+};
+
+struct BigArray{
+    int a[33];
+};
+
+struct WithLittleArray {
+    struct LittleArray a;
+};
+
+struct WithBigArray {
+    struct BigArray a;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_large_array.hpp b/bindgen-tests/tests/headers/struct_with_large_array.hpp
new file mode 100644
index 00000000..974ca526
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_large_array.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rust-target 1.40
+//
+struct S {
+    char large_array[33];
+};
+
+template<typename T> struct ST {
+    T large_array[33];
+};
diff --git a/bindgen-tests/tests/headers/struct_with_nesting.h b/bindgen-tests/tests/headers/struct_with_nesting.h
new file mode 100644
index 00000000..ac902b44
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_nesting.h
@@ -0,0 +1,19 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct foo {
+    unsigned int a;
+    union {
+        unsigned int b;
+        struct {
+            unsigned short c1;
+            unsigned short c2;
+        };
+
+        struct {
+            unsigned char d1;
+            unsigned char d2;
+            unsigned char d3;
+            unsigned char d4;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/struct_with_nesting_1_0.h b/bindgen-tests/tests/headers/struct_with_nesting_1_0.h
new file mode 100644
index 00000000..a24ae1db
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_nesting_1_0.h
@@ -0,0 +1,19 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct foo {
+    unsigned int a;
+    union {
+        unsigned int b;
+        struct {
+            unsigned short c1;
+            unsigned short c2;
+        };
+
+        struct {
+            unsigned char d1;
+            unsigned char d2;
+            unsigned char d3;
+            unsigned char d4;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/struct_with_packing.h b/bindgen-tests/tests/headers/struct_with_packing.h
new file mode 100644
index 00000000..9ed50317
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_packing.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct a {
+    char b;
+    short c;
+} __attribute__((packed));
diff --git a/bindgen-tests/tests/headers/struct_with_struct.h b/bindgen-tests/tests/headers/struct_with_struct.h
new file mode 100644
index 00000000..1a178074
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_struct.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+struct foo {
+    struct {
+        unsigned int x;
+        unsigned int y;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp b/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp
new file mode 100644
index 00000000..ec1b55aa
--- /dev/null
+++ b/bindgen-tests/tests/headers/struct_with_typedef_template_arg.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+template<typename T, typename ...Args>
+struct Proxy {
+  typedef void (*foo)(T* bar);
+};
diff --git a/bindgen-tests/tests/headers/template-fun-ty.hpp b/bindgen-tests/tests/headers/template-fun-ty.hpp
new file mode 100644
index 00000000..bb9d23cf
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-fun-ty.hpp
@@ -0,0 +1,17 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+template <typename T>
+class Foo
+{
+  typedef T (FunctionPtr)();
+};
+
+template<typename T>
+class RefPtr {
+  template<typename R, typename... Args>
+  class Proxy {
+    typedef R (T::*member_function)(Args...);
+  };
+};
+
+template<typename T>
+using Returner = T(*)();
diff --git a/bindgen-tests/tests/headers/template-param-usage-0.hpp b/bindgen-tests/tests/headers/template-param-usage-0.hpp
new file mode 100644
index 00000000..57c11a10
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-0.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class UsesTemplateParameter {
+    T t;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-1.hpp b/bindgen-tests/tests/headers/template-param-usage-1.hpp
new file mode 100644
index 00000000..dba41489
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-1.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class DoesNotUseTemplateParameter {
+    int x;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-10.hpp b/bindgen-tests/tests/headers/template-param-usage-10.hpp
new file mode 100644
index 00000000..a6f3ccd8
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-10.hpp
@@ -0,0 +1,14 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T, typename U, typename NeverUsed>
+class DoublyIndirectUsage {
+    using Aliased = T;
+    typedef U Typedefed;
+
+    class IndirectUsage {
+        Aliased member;
+        Typedefed another;
+    };
+
+    IndirectUsage doubly_indirect;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-11.hpp b/bindgen-tests/tests/headers/template-param-usage-11.hpp
new file mode 100644
index 00000000..8780f5d3
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-11.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class DoesNotUseT {
+    static T but_static_member_does;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-12.hpp b/bindgen-tests/tests/headers/template-param-usage-12.hpp
new file mode 100644
index 00000000..9b4cea19
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-12.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class BaseUsesT {
+    T* t;
+};
+
+template <typename U>
+class CrtpUsesU : public BaseUsesT<CrtpUsesU<U>> {
+    U usage;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-13.hpp b/bindgen-tests/tests/headers/template-param-usage-13.hpp
new file mode 100644
index 00000000..87db1a10
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-13.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class BaseIgnoresT {
+    int x;
+};
+
+template <typename U>
+class CrtpUsesU : public BaseIgnoresT<CrtpUsesU<U>> {
+    U usage;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-14.hpp b/bindgen-tests/tests/headers/template-param-usage-14.hpp
new file mode 100644
index 00000000..19016296
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-14.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class BaseIgnoresT {
+    int x;
+};
+
+template <typename U>
+class CrtpIgnoresU : public BaseIgnoresT<CrtpIgnoresU<U>> {
+    int y;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-15.hpp b/bindgen-tests/tests/headers/template-param-usage-15.hpp
new file mode 100644
index 00000000..bac7ada7
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-15.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class BaseUsesT {
+    T* usage;
+};
+
+template <typename U>
+class CrtpIgnoresU : public BaseUsesT<CrtpIgnoresU<U>> {
+    int y;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-2.hpp b/bindgen-tests/tests/headers/template-param-usage-2.hpp
new file mode 100644
index 00000000..302140ab
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-2.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class UsesTemplateParameter {
+    T t;
+
+    class AlsoUsesTemplateParameter {
+        T also;
+    };
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-3.hpp b/bindgen-tests/tests/headers/template-param-usage-3.hpp
new file mode 100644
index 00000000..57396a8a
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-3.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class UsesTemplateParameter {
+    T t;
+
+    template <typename U>
+    class AlsoUsesTemplateParameterAndMore {
+        T also;
+        U more;
+    };
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-4.hpp b/bindgen-tests/tests/headers/template-param-usage-4.hpp
new file mode 100644
index 00000000..0415d692
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-4.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class UsesTemplateParameter {
+    T t;
+
+    template <typename U>
+    class DoesNotUseTemplateParameters {
+        int x;
+    };
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-5.hpp b/bindgen-tests/tests/headers/template-param-usage-5.hpp
new file mode 100644
index 00000000..04b9bf80
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-5.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class IndirectlyUsesTemplateParameter {
+    using Aliased = T;
+
+    Aliased aliased;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-6.hpp b/bindgen-tests/tests/headers/template-param-usage-6.hpp
new file mode 100644
index 00000000..ee0519c5
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-6.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T>
+class DoesNotUseTemplateParameter {
+    using ButAliasDoesUseIt = T;
+
+    int x;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-7.hpp b/bindgen-tests/tests/headers/template-param-usage-7.hpp
new file mode 100644
index 00000000..99d4cc71
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-7.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T, typename U, typename V>
+class DoesNotUseU {
+    T t;
+    V v;
+};
+
+// The bool should go away becuase U is not used.
+using Alias = DoesNotUseU<int, bool, char>;
diff --git a/bindgen-tests/tests/headers/template-param-usage-8.hpp b/bindgen-tests/tests/headers/template-param-usage-8.hpp
new file mode 100644
index 00000000..96eabc06
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-8.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T, typename U>
+class IndirectUsage {
+    typedef T Typedefed;
+    using Aliased = U;
+
+    Typedefed member1;
+    Aliased member2;
+};
diff --git a/bindgen-tests/tests/headers/template-param-usage-9.hpp b/bindgen-tests/tests/headers/template-param-usage-9.hpp
new file mode 100644
index 00000000..b9bd202c
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-param-usage-9.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: -- -std=c++14
+
+template <typename T, typename U>
+class DoesNotUse {
+    using Aliased = T;
+    typedef U Typedefed;
+
+    class IndirectUsage {
+        Aliased member;
+        Typedefed another;
+    };
+};
diff --git a/bindgen-tests/tests/headers/template-with-var.hpp b/bindgen-tests/tests/headers/template-with-var.hpp
new file mode 100644
index 00000000..88f60d21
--- /dev/null
+++ b/bindgen-tests/tests/headers/template-with-var.hpp
@@ -0,0 +1,7 @@
+template<typename T>
+class TemplateWithVar {
+    // We shouldn't generate bindings for this because there are potentially
+    // many instantiations of this variable, but we can't know which ones exist
+    // or don't.
+    static T var = 0;
+};
diff --git a/bindgen-tests/tests/headers/template.hpp b/bindgen-tests/tests/headers/template.hpp
new file mode 100644
index 00000000..bc32a357
--- /dev/null
+++ b/bindgen-tests/tests/headers/template.hpp
@@ -0,0 +1,168 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
+//
+template<typename T, typename U> class Foo {
+    T m_member;
+    T* m_member_ptr;
+    T m_member_arr[1];
+};
+
+template<typename T> class B {
+    T m_member { 0 };
+};
+
+void bar(Foo<int, int> foo);
+
+namespace mozilla {
+class Foo;
+};
+
+struct C {
+    B<unsigned int> mB;
+    B<const int*> mBConstPtr;
+    B<const mozilla::Foo*> mBConstStructPtr;
+    B<const mozilla::Foo*[1]> mBConstStructPtrArray;
+    B<const int> mBConst;
+    B<volatile int> mBVolatile;
+    B<const bool> mBConstBool;
+    B<const char16_t> mBConstChar;
+    B<int[1]> mBArray;
+    B<int*[1]> mBPtrArray;
+    B<int(*)[1]> mBArrayPtr;
+    B<int&> mBRef;
+    B<const int&> mBConstRef;
+    B<int*&> mPtrRef;
+    B<int(&)[1]> mArrayRef;
+    B<const int[1]> mBConstArray;
+};
+
+template<typename T>
+class D {
+    typedef Foo<int, int> MyFoo;
+
+    MyFoo m_foo;
+
+    template<typename Z>
+    class U {
+        MyFoo m_nested_foo;
+        Z m_baz;
+    };
+};
+
+template<typename T>
+class Rooted {
+    T* prev;
+    Rooted<void*>* next;
+    T ptr;
+};
+
+class RootedContainer {
+    Rooted<void*> root;
+};
+
+template<typename T>
+class WithDtor;
+
+typedef WithDtor<int> WithDtorIntFwd;
+
+template<typename T>
+class WithDtor {
+    T member;
+    ~WithDtor() {}
+};
+
+class PODButContainsDtor {
+    WithDtorIntFwd member;
+};
+
+
+/** <div rustbindgen opaque> */
+template<typename T>
+class Opaque {
+    T member;
+};
+
+class POD {
+    Opaque<int> opaque_member;
+};
+
+/**
+ * <div rustbindgen replaces="NestedReplaced"></div>
+ */
+template<typename T>
+class Nested {
+    T* buff;
+};
+
+template<typename T, typename U>
+class NestedBase {
+    T* buff;
+};
+
+template<typename T>
+class NestedReplaced: public NestedBase<T, int> {
+};
+
+template<typename T>
+class Incomplete;
+
+template<typename T>
+class NestedContainer {
+    T c;
+private:
+    NestedReplaced<T> nested;
+    Incomplete<T> inc;
+};
+
+template<typename T>
+class Incomplete {
+    T d;
+};
+
+class Untemplated {};
+
+template<typename T>
+class Templated {
+    Untemplated m_untemplated;
+};
+
+/**
+ * If the replacement doesn't happen at the parse level the container would be
+ * copy and the replacement wouldn't, so this wouldn't compile.
+ *
+ * <div rustbindgen replaces="ReplacedWithoutDestructor"></div>
+ */
+template<typename T>
+class ReplacedWithDestructor {
+    T* buff;
+    ~ReplacedWithDestructor() {};
+};
+
+template<typename T>
+class ReplacedWithoutDestructor {
+    T* buff;
+};
+
+template<typename T>
+class ReplacedWithoutDestructorFwd;
+
+template<typename T>
+class ShouldNotBeCopiable {
+    ReplacedWithoutDestructor<T> m_member;
+};
+
+template<typename U>
+class ShouldNotBeCopiableAsWell {
+    ReplacedWithoutDestructorFwd<U> m_member;
+};
+
+/**
+ * If the replacement doesn't happen at the parse level the container would be
+ * copy and the replacement wouldn't, so this wouldn't compile.
+ *
+ * <div rustbindgen replaces="ReplacedWithoutDestructorFwd"></div>
+ */
+template<typename T>
+class ReplacedWithDestructorDeclaredAfter {
+    T* buff;
+    ~ReplacedWithDestructorDeclaredAfter() {};
+};
diff --git a/bindgen-tests/tests/headers/template_alias.hpp b/bindgen-tests/tests/headers/template_alias.hpp
new file mode 100644
index 00000000..8b3ea692
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_alias.hpp
@@ -0,0 +1,13 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
+
+namespace JS {
+namespace detail {
+    template <typename T>
+    using Wrapped = T;
+}
+
+template <typename T>
+struct Rooted {
+    detail::Wrapped<T> ptr;
+};
+}
diff --git a/bindgen-tests/tests/headers/template_alias_basic.hpp b/bindgen-tests/tests/headers/template_alias_basic.hpp
new file mode 100644
index 00000000..964f6e27
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_alias_basic.hpp
@@ -0,0 +1,4 @@
+// bindgen-flags: -- -std=c++11
+
+template<typename T>
+using Wrapped = T;
diff --git a/bindgen-tests/tests/headers/template_alias_namespace.hpp b/bindgen-tests/tests/headers/template_alias_namespace.hpp
new file mode 100644
index 00000000..c20bf206
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_alias_namespace.hpp
@@ -0,0 +1,13 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces -- -std=c++14
+
+namespace JS {
+namespace detail {
+    template <typename T>
+    using Wrapped = T;
+}
+
+template <typename T>
+struct Rooted {
+    detail::Wrapped<T> ptr;
+};
+}
diff --git a/bindgen-tests/tests/headers/template_fun.hpp b/bindgen-tests/tests/headers/template_fun.hpp
new file mode 100644
index 00000000..17b1383b
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_fun.hpp
@@ -0,0 +1,3 @@
+// this will be ignored
+template <class T>
+void foo() {}
diff --git a/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp b/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp
new file mode 100644
index 00000000..b7ff28b0
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_instantiation_with_fn_local_type.hpp
@@ -0,0 +1,27 @@
+// bindgen-flags: -- -std=c++14
+//
+// https://github.com/rust-lang/rust-bindgen/issues/2036
+
+template<typename T>
+struct Foo {};
+template<typename T>
+Foo<T> foo{};
+
+// Struct inside function
+void f() {
+  struct Bar {
+    Bar() {}
+  };
+  foo<Bar>;
+}
+
+// Struct inside method
+class Baz {
+  void f() {
+    struct Boo {
+      Boo() {}
+    };
+    foo<Boo>;
+  }
+};
+
diff --git a/bindgen-tests/tests/headers/template_partial_specification.hpp b/bindgen-tests/tests/headers/template_partial_specification.hpp
new file mode 100644
index 00000000..fe1be658
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_partial_specification.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: -- --target=x86_64-pc-win32
+
+template<typename Method, bool Cancelable>
+struct nsRunnableMethodTraits;
+
+template<class C, typename R, bool Cancelable, typename... As>
+struct nsRunnableMethodTraits<R(C::*)(As...), Cancelable>
+{
+  static const bool can_cancel = Cancelable;
+};
diff --git a/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp b/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp
new file mode 100644
index 00000000..34a5b92c
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_typedef_transitive_param.hpp
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+template<typename T>
+struct Wrapper {
+    struct Wrapped {
+        T t;
+    };
+    using Type = Wrapped;
+};
diff --git a/bindgen-tests/tests/headers/template_typedefs.hpp b/bindgen-tests/tests/headers/template_typedefs.hpp
new file mode 100644
index 00000000..5e13dcd8
--- /dev/null
+++ b/bindgen-tests/tests/headers/template_typedefs.hpp
@@ -0,0 +1,8 @@
+typedef void (*foo)(int);
+
+template<typename T, typename U>
+class Foo {
+  typedef T Char;
+  typedef Char* FooPtrTypedef;
+  typedef bool (*nsCOMArrayEnumFunc)(T* aElement, void* aData);
+};
diff --git a/bindgen-tests/tests/headers/templateref_opaque.hpp b/bindgen-tests/tests/headers/templateref_opaque.hpp
new file mode 100644
index 00000000..2f6a0027
--- /dev/null
+++ b/bindgen-tests/tests/headers/templateref_opaque.hpp
@@ -0,0 +1,12 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+namespace detail {
+template<typename T>
+struct PointerType {
+  typedef T* Type;
+};
+}
+template<typename T>
+class UniquePtr {
+  typedef typename detail::PointerType<T> Pointer;
+};
diff --git a/bindgen-tests/tests/headers/templatized-bitfield.hpp b/bindgen-tests/tests/headers/templatized-bitfield.hpp
new file mode 100644
index 00000000..ed4a1540
--- /dev/null
+++ b/bindgen-tests/tests/headers/templatized-bitfield.hpp
@@ -0,0 +1,7 @@
+/// We don't get a layout for this bitfield, since we don't know what `T` will
+/// be, so we cannot allocate bitfield units. The best thing we can do is make
+/// the struct opaque.
+template <class T>
+class TemplatizedBitfield {
+    T t : 6;
+};
diff --git a/bindgen-tests/tests/headers/timex.h b/bindgen-tests/tests/headers/timex.h
new file mode 100644
index 00000000..1add26ca
--- /dev/null
+++ b/bindgen-tests/tests/headers/timex.h
@@ -0,0 +1,15 @@
+struct timex {
+	int tai;
+
+	int  :32; int  :32; int  :32; int  :32;
+	int  :32; int  :32; int  :32; int  :32;
+	int  :32; int  :32; int  :32;
+};
+
+struct timex_named {
+  int tai;
+
+  int a:32; int b:32; int c:32; int d:32;
+  int e:32; int f:32; int g:32; int h:32;
+  int i:32; int j:32; int k:32;
+};
diff --git a/bindgen-tests/tests/headers/transform-op.hpp b/bindgen-tests/tests/headers/transform-op.hpp
new file mode 100644
index 00000000..aa6118eb
--- /dev/null
+++ b/bindgen-tests/tests/headers/transform-op.hpp
@@ -0,0 +1,75 @@
+// bindgen-flags: --rust-target 1.0 -- -std=c++11
+
+typedef unsigned char uint8_t;
+typedef int int32_t;
+
+template<typename T>
+struct StylePoint {
+  T x;
+  T y;
+};
+
+template<typename T>
+union StyleFoo {
+  enum class Tag : uint8_t {
+    Foo,
+    Bar,
+    Baz,
+    Bazz,
+  };
+
+  struct Foo_Body {
+    Tag tag;
+    int32_t x;
+    StylePoint<T> y;
+    StylePoint<float> z;
+  };
+
+  struct Bar_Body {
+    Tag tag;
+    T _0;
+  };
+
+  struct Baz_Body {
+    Tag tag;
+    StylePoint<T> _0;
+  };
+
+  struct {
+    Tag tag;
+  };
+  Foo_Body foo;
+  Bar_Body bar;
+  Baz_Body baz;
+};
+
+template<typename T>
+struct StyleBar {
+  enum class Tag {
+    Bar1,
+    Bar2,
+    Bar3,
+    Bar4,
+  };
+
+  struct StyleBar1_Body {
+    int32_t x;
+    StylePoint<T> y;
+    StylePoint<float> z;
+  };
+
+  struct StyleBar2_Body {
+    T _0;
+  };
+
+  struct StyleBar3_Body {
+    StylePoint<T> _0;
+  };
+
+  Tag tag;
+  union {
+    StyleBar1_Body bar1;
+    StyleBar2_Body bar2;
+    StyleBar3_Body bar3;
+  };
+};
diff --git a/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h b/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h
new file mode 100644
index 00000000..bf675bc9
--- /dev/null
+++ b/bindgen-tests/tests/headers/type-referenced-by-allowlisted-function.h
@@ -0,0 +1,7 @@
+// bindgen-flags: --allowlist-function dl_iterate_phdr
+
+struct dl_phdr_info {
+    int x;
+};
+
+int dl_iterate_phdr(struct dl_phdr_info *);
diff --git a/bindgen-tests/tests/headers/type_alias_empty.hpp b/bindgen-tests/tests/headers/type_alias_empty.hpp
new file mode 100644
index 00000000..bcccc3c8
--- /dev/null
+++ b/bindgen-tests/tests/headers/type_alias_empty.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --allowlist-type bool_constant -- -std=c++11
+
+// NB: The --allowlist-type is done to trigger the traversal of the types on
+// codegen in order to trigger #67.
+
+template<typename T, T Val>
+struct integral_constant {};
+
+template<bool B>
+using bool_constant = integral_constant<bool, B>;
diff --git a/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp b/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp
new file mode 100644
index 00000000..dfc36786
--- /dev/null
+++ b/bindgen-tests/tests/headers/type_alias_partial_template_especialization.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -std=c++14
+template <typename A> using MaybeWrapped = A;
+
+template<class T>
+class Rooted {
+  MaybeWrapped<T> ptr;
+};
diff --git a/bindgen-tests/tests/headers/type_alias_template_specialized.hpp b/bindgen-tests/tests/headers/type_alias_template_specialized.hpp
new file mode 100644
index 00000000..f7403a36
--- /dev/null
+++ b/bindgen-tests/tests/headers/type_alias_template_specialized.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --allowlist-type Rooted -- -std=c++14
+
+template <typename a> using MaybeWrapped = a;
+class Rooted {
+  MaybeWrapped<int> ptr;
+};
+
+/// <div rustbindgen replaces="MaybeWrapped"></div>
+template <typename a> using replaces_MaybeWrapped = a;
diff --git a/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h b/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h
new file mode 100644
index 00000000..93790591
--- /dev/null
+++ b/bindgen-tests/tests/headers/typedefd-array-as-function-arg.h
@@ -0,0 +1,3 @@
+// foo.h
+typedef float myVector3[3];
+void modifyVectorFunc(myVector3 v);
diff --git a/bindgen-tests/tests/headers/typeref.hpp b/bindgen-tests/tests/headers/typeref.hpp
new file mode 100644
index 00000000..bdc1b302
--- /dev/null
+++ b/bindgen-tests/tests/headers/typeref.hpp
@@ -0,0 +1,29 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+struct nsFoo;
+
+namespace mozilla {
+
+struct FragmentOrURL { bool mIsLocalRef; };
+struct Position { };
+
+} // namespace mozilla
+
+class Bar {
+  nsFoo* mFoo;
+};
+
+namespace mozilla {
+
+template<typename ReferenceBox>
+struct StyleShapeSource {
+  union {
+    Position* mPosition;
+    FragmentOrURL* mFragmentOrURL;
+  };
+};
+
+} // namespace mozilla
+
+struct nsFoo {
+  mozilla::StyleShapeSource<int> mBar;
+};
diff --git a/bindgen-tests/tests/headers/typeref_1_0.hpp b/bindgen-tests/tests/headers/typeref_1_0.hpp
new file mode 100644
index 00000000..70dfc11f
--- /dev/null
+++ b/bindgen-tests/tests/headers/typeref_1_0.hpp
@@ -0,0 +1,30 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct nsFoo;
+
+namespace mozilla {
+
+struct FragmentOrURL { bool mIsLocalRef; };
+struct Position { };
+
+} // namespace mozilla
+
+class Bar {
+  nsFoo* mFoo;
+};
+
+namespace mozilla {
+
+template<typename ReferenceBox>
+struct StyleShapeSource {
+  union {
+    Position* mPosition;
+    FragmentOrURL* mFragmentOrURL;
+  };
+};
+
+} // namespace mozilla
+
+struct nsFoo {
+  mozilla::StyleShapeSource<int> mBar;
+};
diff --git a/bindgen-tests/tests/headers/underscore.hpp b/bindgen-tests/tests/headers/underscore.hpp
new file mode 100644
index 00000000..1c9371f1
--- /dev/null
+++ b/bindgen-tests/tests/headers/underscore.hpp
@@ -0,0 +1,3 @@
+const int _ = 10;
+
+typedef struct { unsigned char _[8]; } ptr_t;
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/union-align.h b/bindgen-tests/tests/headers/union-align.h
new file mode 100644
index 00000000..9557b279
--- /dev/null
+++ b/bindgen-tests/tests/headers/union-align.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --rust-target 1.26
+
+union Bar {
+  unsigned char foo;
+} __attribute__ ((__aligned__ (16)));
+
+
+union Baz {
+  union Bar bar;
+};
diff --git a/bindgen-tests/tests/headers/union-in-ns.hpp b/bindgen-tests/tests/headers/union-in-ns.hpp
new file mode 100644
index 00000000..68b8f72d
--- /dev/null
+++ b/bindgen-tests/tests/headers/union-in-ns.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --enable-cxx-namespaces
+
+union bar {
+  int baz;
+};
diff --git a/bindgen-tests/tests/headers/union-in-ns_1_0.hpp b/bindgen-tests/tests/headers/union-in-ns_1_0.hpp
new file mode 100644
index 00000000..f3ae2210
--- /dev/null
+++ b/bindgen-tests/tests/headers/union-in-ns_1_0.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --rust-target 1.0 --enable-cxx-namespaces
+
+union bar {
+  int baz;
+};
diff --git a/bindgen-tests/tests/headers/union_bitfield.h b/bindgen-tests/tests/headers/union_bitfield.h
new file mode 100644
index 00000000..99072957
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_bitfield.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
+
+union U4 {
+    unsigned derp : 1;
+};
+
+union B {
+    unsigned foo : 31;
+    unsigned char bar : 1;
+};
diff --git a/bindgen-tests/tests/headers/union_bitfield_1_0.h b/bindgen-tests/tests/headers/union_bitfield_1_0.h
new file mode 100644
index 00000000..06b61ad7
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_bitfield_1_0.h
@@ -0,0 +1,14 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
+
+union U4 {
+    unsigned derp : 1;
+};
+
+union B {
+    unsigned foo : 31;
+    unsigned char bar : 1;
+};
+
+union HasBigBitfield {
+    __int128 x : 128;
+};
diff --git a/bindgen-tests/tests/headers/union_dtor.hpp b/bindgen-tests/tests/headers/union_dtor.hpp
new file mode 100644
index 00000000..399dc89d
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_dtor.hpp
@@ -0,0 +1,5 @@
+union UnionWithDtor {
+  ~UnionWithDtor();
+  int mFoo;
+  void* mBar;
+};
diff --git a/bindgen-tests/tests/headers/union_dtor_1_0.hpp b/bindgen-tests/tests/headers/union_dtor_1_0.hpp
new file mode 100644
index 00000000..01f76366
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_dtor_1_0.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.0
+
+union UnionWithDtor {
+  ~UnionWithDtor();
+  int mFoo;
+  void* mBar;
+};
diff --git a/bindgen-tests/tests/headers/union_fields.hpp b/bindgen-tests/tests/headers/union_fields.hpp
new file mode 100644
index 00000000..7bb2a3ce
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_fields.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+typedef union {
+  int mInt;
+  float mFloat;
+  void* mPointer;
+} nsStyleUnion;
diff --git a/bindgen-tests/tests/headers/union_fields_1_0.hpp b/bindgen-tests/tests/headers/union_fields_1_0.hpp
new file mode 100644
index 00000000..bbb67fbc
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_fields_1_0.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+typedef union {
+  int mInt;
+  float mFloat;
+  void* mPointer;
+} nsStyleUnion;
diff --git a/bindgen-tests/tests/headers/union_template.hpp b/bindgen-tests/tests/headers/union_template.hpp
new file mode 100644
index 00000000..8b57f5a0
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_template.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+template<typename T>
+struct NastyStruct {
+  bool mIsSome;
+  union {
+    void* mFoo;
+    unsigned long mDummy;
+  } mStorage;
+
+  union {
+    short wat;
+    int* wut;
+  };
+};
+
+template<typename T>
+union Whatever {
+  void* mTPtr;
+  int mInt;
+};
diff --git a/bindgen-tests/tests/headers/union_template_1_0.hpp b/bindgen-tests/tests/headers/union_template_1_0.hpp
new file mode 100644
index 00000000..18e3d74a
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_template_1_0.hpp
@@ -0,0 +1,21 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+template<typename T>
+struct NastyStruct {
+  bool mIsSome;
+  union {
+    void* mFoo;
+    unsigned long mDummy;
+  } mStorage;
+
+  union {
+    short wat;
+    int* wut;
+  };
+};
+
+template<typename T>
+union Whatever {
+  void* mTPtr;
+  int mInt;
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_struct.h b/bindgen-tests/tests/headers/union_with_anon_struct.h
new file mode 100644
index 00000000..b239b2d8
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_struct.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union foo {
+    struct {
+        unsigned int a;
+        unsigned int b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_struct_1_0.h b/bindgen-tests/tests/headers/union_with_anon_struct_1_0.h
new file mode 100644
index 00000000..9313299e
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_struct_1_0.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union foo {
+    struct {
+        unsigned int a;
+        unsigned int b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h
new file mode 100644
index 00000000..bbb1ef41
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union foo {
+    int a;
+    struct {
+        int b : 7;
+        int c : 25;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_struct_bitfield_1_0.h b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield_1_0.h
new file mode 100644
index 00000000..0b0e3d73
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_struct_bitfield_1_0.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union foo {
+    int a;
+    struct {
+        int b : 7;
+        int c : 25;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_union.h b/bindgen-tests/tests/headers/union_with_anon_union.h
new file mode 100644
index 00000000..02b09e2e
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_union.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_union_1_0.h b/bindgen-tests/tests/headers/union_with_anon_union_1_0.h
new file mode 100644
index 00000000..28a7231d
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_union_1_0.h
@@ -0,0 +1,8 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union foo {
+    union {
+        unsigned int a;
+        unsigned short b;
+    } bar;
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h
new file mode 100644
index 00000000..04903318
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct.h
@@ -0,0 +1,11 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union pixel {
+    unsigned int rgba;
+    struct {
+        unsigned char r;
+        unsigned char g;
+        unsigned char b;
+        unsigned char a;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_struct_1_0.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct_1_0.h
new file mode 100644
index 00000000..506a41f6
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_struct_1_0.h
@@ -0,0 +1,11 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union pixel {
+    unsigned int rgba;
+    struct {
+        unsigned char r;
+        unsigned char g;
+        unsigned char b;
+        unsigned char a;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h
new file mode 100644
index 00000000..dbccd5b5
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_union.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union foo {
+    unsigned int a;
+    union {
+        unsigned short b;
+        unsigned char c;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_anon_unnamed_union_1_0.h b/bindgen-tests/tests/headers/union_with_anon_unnamed_union_1_0.h
new file mode 100644
index 00000000..c556a613
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_anon_unnamed_union_1_0.h
@@ -0,0 +1,9 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union foo {
+    unsigned int a;
+    union {
+        unsigned short b;
+        unsigned char c;
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_big_member.h b/bindgen-tests/tests/headers/union_with_big_member.h
new file mode 100644
index 00000000..e8a3fe0a
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_big_member.h
@@ -0,0 +1,16 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union WithBigArray {
+  int a;
+  int b[33];
+};
+
+union WithBigArray2 {
+  int a;
+  char b[33];
+};
+
+union WithBigMember {
+  int a;
+  union WithBigArray b;
+};
diff --git a/bindgen-tests/tests/headers/union_with_big_member_1_0.h b/bindgen-tests/tests/headers/union_with_big_member_1_0.h
new file mode 100644
index 00000000..04294354
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_big_member_1_0.h
@@ -0,0 +1,16 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union WithBigArray {
+  int a;
+  int b[33];
+};
+
+union WithBigArray2 {
+  int a;
+  char b[33];
+};
+
+union WithBigMember {
+  int a;
+  union WithBigArray b;
+};
diff --git a/bindgen-tests/tests/headers/union_with_nesting.h b/bindgen-tests/tests/headers/union_with_nesting.h
new file mode 100644
index 00000000..ae25244a
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_nesting.h
@@ -0,0 +1,16 @@
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
+//
+union foo {
+    unsigned int a;
+    struct {
+        union {
+            unsigned short b1;
+            unsigned short b2;
+        };
+
+        union {
+            unsigned short c1;
+            unsigned short c2;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_nesting_1_0.h b/bindgen-tests/tests/headers/union_with_nesting_1_0.h
new file mode 100644
index 00000000..3cdb7238
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_nesting_1_0.h
@@ -0,0 +1,16 @@
+// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+union foo {
+    unsigned int a;
+    struct {
+        union {
+            unsigned short b1;
+            unsigned short b2;
+        };
+
+        union {
+            unsigned short c1;
+            unsigned short c2;
+        };
+    };
+};
diff --git a/bindgen-tests/tests/headers/union_with_non_copy_member.h b/bindgen-tests/tests/headers/union_with_non_copy_member.h
new file mode 100644
index 00000000..764820a4
--- /dev/null
+++ b/bindgen-tests/tests/headers/union_with_non_copy_member.h
@@ -0,0 +1,20 @@
+// bindgen-flags: --bindgen-wrapper-union 'WithBindgenGeneratedWrapper' --manually-drop-union 'WithManuallyDrop' --no-copy 'NonCopyType'
+
+struct NonCopyType {
+  int foo;
+};
+
+union WithBindgenGeneratedWrapper {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
+
+union WithManuallyDrop {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
+
+union WithDefaultWrapper {
+  struct NonCopyType non_copy_type;
+  int bar;
+};
diff --git a/bindgen-tests/tests/headers/unknown_attr.h b/bindgen-tests/tests/headers/unknown_attr.h
new file mode 100644
index 00000000..1e89fb14
--- /dev/null
+++ b/bindgen-tests/tests/headers/unknown_attr.h
@@ -0,0 +1,6 @@
+typedef struct {
+  long long __clang_max_align_nonce1
+      __attribute__((__aligned__(__alignof__(long long))));
+  long long __clang_max_align_nonce2
+      __attribute__((__aligned__(__alignof__(long double))));
+} max_align_t;
diff --git a/bindgen-tests/tests/headers/unsorted-items.h b/bindgen-tests/tests/headers/unsorted-items.h
new file mode 100644
index 00000000..23962d18
--- /dev/null
+++ b/bindgen-tests/tests/headers/unsorted-items.h
@@ -0,0 +1,15 @@
+int foo();
+typedef int number;
+int bar(number x);
+struct Point
+{
+    number x;
+    number y;
+};
+struct Angle
+{
+    number a;
+    number b;
+};
+int baz(struct Point point);
+const number NUMBER = 42;
diff --git a/bindgen-tests/tests/headers/use-core.h b/bindgen-tests/tests/headers/use-core.h
new file mode 100644
index 00000000..5ee0ac6f
--- /dev/null
+++ b/bindgen-tests/tests/headers/use-core.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --use-core --raw-line '#![cfg(not(target_os="windows"))] extern crate core;' --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct foo {
+  int a, b;
+  void* bar;
+};
+
+union {
+  int bar;
+  long baz;
+} bazz;
+
+typedef void (*fooFunction)(int bar);
diff --git a/bindgen-tests/tests/headers/use-core_1_0.h b/bindgen-tests/tests/headers/use-core_1_0.h
new file mode 100644
index 00000000..40de9d15
--- /dev/null
+++ b/bindgen-tests/tests/headers/use-core_1_0.h
@@ -0,0 +1,13 @@
+// bindgen-flags: --rust-target 1.0 --use-core --raw-line "extern crate core;" --with-derive-hash --with-derive-partialeq --with-derive-eq
+
+struct foo {
+  int a, b;
+  void* bar;
+};
+
+union {
+  int bar;
+  long baz;
+} bazz;
+
+typedef void (*fooFunction)(int bar);
diff --git a/bindgen-tests/tests/headers/using.hpp b/bindgen-tests/tests/headers/using.hpp
new file mode 100644
index 00000000..ba07b9c8
--- /dev/null
+++ b/bindgen-tests/tests/headers/using.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++11
+
+template<typename T>
+class Point {
+    T x;
+    T y;
+};
+
+typedef Point<int> IntPoint2D;
+
+using IntVec2D = Point<int>;
diff --git a/bindgen-tests/tests/headers/var-tracing.hpp b/bindgen-tests/tests/headers/var-tracing.hpp
new file mode 100644
index 00000000..ef002a00
--- /dev/null
+++ b/bindgen-tests/tests/headers/var-tracing.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --allowlist-type Baz
+
+struct Bar {
+  const int m_baz;
+  Bar(int baz);
+};
+
+class Baz {
+  static const Bar FOO[];
+};
diff --git a/bindgen-tests/tests/headers/variadic-method.hpp b/bindgen-tests/tests/headers/variadic-method.hpp
new file mode 100644
index 00000000..78a8eb45
--- /dev/null
+++ b/bindgen-tests/tests/headers/variadic-method.hpp
@@ -0,0 +1,6 @@
+
+void foo(const char* fmt, ...);
+
+struct Bar {
+  void foo(const char* fmt, ...);
+};
diff --git a/bindgen-tests/tests/headers/variadic_template_function.hpp b/bindgen-tests/tests/headers/variadic_template_function.hpp
new file mode 100644
index 00000000..4942d8f0
--- /dev/null
+++ b/bindgen-tests/tests/headers/variadic_template_function.hpp
@@ -0,0 +1,6 @@
+
+template <typename T>
+class VariadicFunctionObject {
+public:
+	int add_em_up(T count,...);
+};
diff --git a/bindgen-tests/tests/headers/vector.hpp b/bindgen-tests/tests/headers/vector.hpp
new file mode 100644
index 00000000..173aa022
--- /dev/null
+++ b/bindgen-tests/tests/headers/vector.hpp
@@ -0,0 +1,9 @@
+struct foo {
+  __attribute__((__vector_size__(1 * sizeof(long long)))) long long mMember;
+};
+
+typedef float __m128 __attribute__ ((__vector_size__ (16)));
+typedef double __m128d __attribute__((__vector_size__(16)));
+typedef long long __m128i __attribute__((__vector_size__(16)));
+
+__m128 foo(__m128i, __m128d);
diff --git a/bindgen-tests/tests/headers/virtual_dtor.hpp b/bindgen-tests/tests/headers/virtual_dtor.hpp
new file mode 100644
index 00000000..c35dcab1
--- /dev/null
+++ b/bindgen-tests/tests/headers/virtual_dtor.hpp
@@ -0,0 +1,3 @@
+struct nsSlots {
+    virtual ~nsSlots();
+};
diff --git a/bindgen-tests/tests/headers/virtual_inheritance.hpp b/bindgen-tests/tests/headers/virtual_inheritance.hpp
new file mode 100644
index 00000000..5198c51e
--- /dev/null
+++ b/bindgen-tests/tests/headers/virtual_inheritance.hpp
@@ -0,0 +1,16 @@
+
+class A {
+  int foo;
+};
+
+class B: public virtual A {
+  int bar;
+};
+
+class C: public virtual A {
+  int baz;
+};
+
+class D: public C, public B {
+  int bazz;
+};
diff --git a/bindgen-tests/tests/headers/virtual_interface.hpp b/bindgen-tests/tests/headers/virtual_interface.hpp
new file mode 100644
index 00000000..00ab0737
--- /dev/null
+++ b/bindgen-tests/tests/headers/virtual_interface.hpp
@@ -0,0 +1,24 @@
+class PureVirtualIFace {
+public:
+    virtual void Foo() = 0;
+    virtual void Bar(unsigned int) = 0;
+};
+
+class AnotherInterface {
+public:
+    virtual void Baz() = 0;
+};
+
+class Implementation : public PureVirtualIFace {
+public:
+    void Foo() override {}
+    void Bar(unsigned int) override {}
+};
+
+class DoubleImpl : public PureVirtualIFace, public AnotherInterface {
+public:
+    void Foo() override {}
+    void Bar(unsigned int) override {}
+
+    void Baz() override {}
+};
diff --git a/bindgen-tests/tests/headers/virtual_overloaded.hpp b/bindgen-tests/tests/headers/virtual_overloaded.hpp
new file mode 100644
index 00000000..f5ba5ff2
--- /dev/null
+++ b/bindgen-tests/tests/headers/virtual_overloaded.hpp
@@ -0,0 +1,5 @@
+class C {
+public:
+    virtual void do_thing(char);
+    virtual void do_thing(int);
+};
diff --git a/bindgen-tests/tests/headers/vtable_recursive_sig.hpp b/bindgen-tests/tests/headers/vtable_recursive_sig.hpp
new file mode 100644
index 00000000..8a073864
--- /dev/null
+++ b/bindgen-tests/tests/headers/vtable_recursive_sig.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: -- -std=c++11
+
+class Derived;
+class Base {
+public:
+  virtual Derived* AsDerived();
+};
+
+class Derived final : public Base {
+  virtual Derived* AsDerived() override;
+};
diff --git a/bindgen-tests/tests/headers/wasm-constructor-returns.hpp b/bindgen-tests/tests/headers/wasm-constructor-returns.hpp
new file mode 100644
index 00000000..9e470327
--- /dev/null
+++ b/bindgen-tests/tests/headers/wasm-constructor-returns.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --generate constructors,types -- -fvisibility=default --target=wasm32-unknown-emscripten
+
+class Foo {
+public:
+    Foo(int var);
+};
+
diff --git a/bindgen-tests/tests/headers/wasm-import-module.h b/bindgen-tests/tests/headers/wasm-import-module.h
new file mode 100644
index 00000000..db4fe85c
--- /dev/null
+++ b/bindgen-tests/tests/headers/wasm-import-module.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --wasm-import-module-name test-module
+
+void test_function();
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/weird_bitfields.hpp b/bindgen-tests/tests/headers/weird_bitfields.hpp
new file mode 100644
index 00000000..b2761a80
--- /dev/null
+++ b/bindgen-tests/tests/headers/weird_bitfields.hpp
@@ -0,0 +1,36 @@
+// bindgen-flags: --rustified-enum ".*"
+
+// You can guess where this is taken from...
+enum nsStyleSVGOpacitySource {
+  eStyleSVGOpacitySource_Normal,
+  eStyleSVGOpacitySource_ContextFillOpacity,
+  eStyleSVGOpacitySource_ContextStrokeOpacity
+};
+
+class Weird {
+  unsigned int         mStrokeDasharrayLength;
+  unsigned int         bitTest: 16;
+  unsigned int         bitTest2: 15;
+  unsigned char          mClipRule;         // [inherited]
+  unsigned char          mColorInterpolation; // [inherited] see nsStyleConsts.h
+  unsigned char          mColorInterpolationFilters; // [inherited] see nsStyleConsts.h
+  unsigned char          mFillRule;         // [inherited] see nsStyleConsts.h
+  unsigned char          mImageRendering;   // [inherited] see nsStyleConsts.h
+  unsigned char          mPaintOrder;       // [inherited] see nsStyleConsts.h
+  unsigned char          mShapeRendering;   // [inherited] see nsStyleConsts.h
+  unsigned char          mStrokeLinecap;    // [inherited] see nsStyleConsts.h
+  unsigned char          mStrokeLinejoin;   // [inherited] see nsStyleConsts.h
+  unsigned char          mTextAnchor;       // [inherited] see nsStyleConsts.h
+  unsigned char          mTextRendering;    // [inherited] see nsStyleConsts.h
+
+  // In SVG glyphs, whether we inherit fill or stroke opacity from the outer
+  // text object.
+  // Use 3 bits to avoid signedness problems in MSVC.
+  nsStyleSVGOpacitySource mFillOpacitySource    : 3;
+  nsStyleSVGOpacitySource mStrokeOpacitySource  : 3;
+
+  // SVG glyph outer object inheritance for other properties
+  bool mStrokeDasharrayFromObject   : 1;
+  bool mStrokeDashoffsetFromObject  : 1;
+  bool mStrokeWidthFromObject       : 1;
+};
diff --git a/bindgen-tests/tests/headers/what_is_going_on.hpp b/bindgen-tests/tests/headers/what_is_going_on.hpp
new file mode 100644
index 00000000..078c1ad5
--- /dev/null
+++ b/bindgen-tests/tests/headers/what_is_going_on.hpp
@@ -0,0 +1,19 @@
+
+struct UnknownUnits {};
+typedef float Float;
+
+template<class units, class F = Float>
+struct PointTyped {
+  F x;
+  F y;
+
+  static PointTyped<units, F> FromUnknownPoint(const PointTyped<UnknownUnits, F>& aPoint) {
+    return PointTyped<units, F>(aPoint.x, aPoint.y);
+  }
+
+  PointTyped<UnknownUnits, F> ToUnknownPoint() const {
+    return PointTyped<UnknownUnits, F>(this->x, this->y);
+  }
+};
+
+typedef PointTyped<UnknownUnits> IntPoint;
diff --git a/bindgen-tests/tests/headers/win32-thiscall_1_0.hpp b/bindgen-tests/tests/headers/win32-thiscall_1_0.hpp
new file mode 100644
index 00000000..5907c76e
--- /dev/null
+++ b/bindgen-tests/tests/headers/win32-thiscall_1_0.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target 1.0 -- --target=i686-pc-windows-msvc
+
+class Foo {
+  public:
+    void test();
+    int test2(int var);
+};
diff --git a/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp b/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp
new file mode 100644
index 00000000..2c9f2f17
--- /dev/null
+++ b/bindgen-tests/tests/headers/win32-thiscall_nightly.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_thiscall)]' -- --target=i686-pc-windows-msvc
+
+class Foo {
+  public:
+    void test();
+    int test2(int var);
+};
diff --git a/bindgen-tests/tests/headers/win32-vectorcall-1_0.h b/bindgen-tests/tests/headers/win32-vectorcall-1_0.h
new file mode 100644
index 00000000..a1f852b5
--- /dev/null
+++ b/bindgen-tests/tests/headers/win32-vectorcall-1_0.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --rust-target 1.0 -- --target=x86_64-pc-windows-msvc
+
+int __vectorcall test_vectorcall(int a, int b);
diff --git a/bindgen-tests/tests/headers/win32-vectorcall-nightly.h b/bindgen-tests/tests/headers/win32-vectorcall-nightly.h
new file mode 100644
index 00000000..c099bb59
--- /dev/null
+++ b/bindgen-tests/tests/headers/win32-vectorcall-nightly.h
@@ -0,0 +1,3 @@
+// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_vectorcall)]' -- --target=x86_64-pc-windows-msvc
+
+int __vectorcall test_vectorcall(int a, int b);
diff --git a/bindgen-tests/tests/headers/with_array_pointers_arguments.h b/bindgen-tests/tests/headers/with_array_pointers_arguments.h
new file mode 100644
index 00000000..565b3cf6
--- /dev/null
+++ b/bindgen-tests/tests/headers/with_array_pointers_arguments.h
@@ -0,0 +1,10 @@
+// bindgen-flags: --use-array-pointers-in-arguments
+
+int test_fn(float a, int arr[20]);
+
+int test_fn2(const float arr[20], int b);
+
+typedef char defArr[20];
+typedef void foo(defArr a);
+
+void bar(defArr a);
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/without_array_pointers_arguments.h b/bindgen-tests/tests/headers/without_array_pointers_arguments.h
new file mode 100644
index 00000000..2f066874
--- /dev/null
+++ b/bindgen-tests/tests/headers/without_array_pointers_arguments.h
@@ -0,0 +1,9 @@
+
+int test_fn(float a, int arr[20]);
+
+int test_fn2(const float arr[20], int b);
+
+typedef char defArr[20];
+typedef void foo(defArr a);
+
+void bar(defArr a);
\ No newline at end of file
diff --git a/bindgen-tests/tests/headers/zero-size-array-align.h b/bindgen-tests/tests/headers/zero-size-array-align.h
new file mode 100644
index 00000000..05b11bce
--- /dev/null
+++ b/bindgen-tests/tests/headers/zero-size-array-align.h
@@ -0,0 +1,5 @@
+struct dm_deps {
+  unsigned count;
+  unsigned filler;
+  unsigned long long device[0];
+};
diff --git a/bindgen-tests/tests/headers/zero-sized-array.hpp b/bindgen-tests/tests/headers/zero-sized-array.hpp
new file mode 100644
index 00000000..ae6d0554
--- /dev/null
+++ b/bindgen-tests/tests/headers/zero-sized-array.hpp
@@ -0,0 +1,45 @@
+// These classes are technically zero-sized, but despite that they still don't
+// get an `_address` field inserted.
+
+/**
+ * Bizarrely enough, this should *not* get an `_address` field.
+ */
+class ZeroSizedArray {
+    char arr[0];
+};
+
+/**
+ * And nor should this get an `_address` field.
+ */
+class ContainsZeroSizedArray {
+    ZeroSizedArray zsa;
+};
+
+/**
+ * Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
+ * either.
+ */
+class InheritsZeroSizedArray : ZeroSizedArray {};
+
+// These are dynamically sized, which means that `sizeof` yields `0` but it
+// isn't really true. We shouldn't add an `_address` field to them.
+
+/**
+ * And this should not get an `_address` field either.
+ */
+class DynamicallySizedArray {
+    char arr[];
+};
+
+/**
+ * No `_address` field here either.
+ */
+class ContainsDynamicallySizedArray {
+    DynamicallySizedArray dsa;
+};
+
+// Note: this is disallowed:
+//
+//     error: base class 'DynamicallySizedArray' has a flexible array member
+//
+// class InheritsDynamicallySizedArray : DynamicallySizedArray {};
diff --git a/bindgen-tests/tests/parse_callbacks/mod.rs b/bindgen-tests/tests/parse_callbacks/mod.rs
new file mode 100644
index 00000000..b94b54de
--- /dev/null
+++ b/bindgen-tests/tests/parse_callbacks/mod.rs
@@ -0,0 +1,42 @@
+use bindgen::callbacks::*;
+
+#[derive(Debug)]
+struct EnumVariantRename;
+
+impl ParseCallbacks for EnumVariantRename {
+    fn enum_variant_name(
+        &self,
+        _enum_name: Option<&str>,
+        original_variant_name: &str,
+        _variant_value: EnumVariantValue,
+    ) -> Option<String> {
+        Some(format!("RENAMED_{}", original_variant_name))
+    }
+}
+
+#[derive(Debug)]
+struct BlocklistedTypeImplementsTrait;
+
+impl ParseCallbacks for BlocklistedTypeImplementsTrait {
+    fn blocklisted_type_implements_trait(
+        &self,
+        _name: &str,
+        derive_trait: DeriveTrait,
+    ) -> Option<ImplementsTrait> {
+        if derive_trait == DeriveTrait::Hash {
+            Some(ImplementsTrait::No)
+        } else {
+            Some(ImplementsTrait::Yes)
+        }
+    }
+}
+
+pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
+    match cb {
+        "enum-variant-rename" => Box::new(EnumVariantRename),
+        "blocklisted-type-implements-trait" => {
+            Box::new(BlocklistedTypeImplementsTrait)
+        }
+        _ => panic!("Couldn't find name ParseCallbacks: {}", cb),
+    }
+}
diff --git a/bindgen-tests/tests/quickchecking/.gitignore b/bindgen-tests/tests/quickchecking/.gitignore
new file mode 100644
index 00000000..03314f77
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/.gitignore
@@ -0,0 +1 @@
+Cargo.lock
diff --git a/bindgen-tests/tests/quickchecking/Cargo.toml b/bindgen-tests/tests/quickchecking/Cargo.toml
new file mode 100644
index 00000000..455a8240
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "quickchecking"
+description = "Bindgen property tests with quickcheck. Generate random valid C code and pass it to the csmith/predicate.py script"
+version = "0.1.0"
+authors = ["Shea Newton <sheanewt@gmail.com>"]
+
+[lib]
+name = "quickchecking"
+path = "src/lib.rs"
+
+[[bin]]
+name = "quickchecking"
+path = "src/bin.rs"
+
+[dependencies]
+clap = "2.28"
+lazy_static = "1.0"
+quickcheck = "0.4"
+rand = "0.3"
+tempdir = "0.3"
+
+[features]
+# No features by default.
+default = []
+
+# Enable the generation of code that allows for zero sized arrays as struct
+# fields. Until issues #684 and #1153 are resolved this can result in failing tests.
+zero-sized-arrays = []
+
+# Enable the generation of code that allows for long double types as struct
+# fields. Until issue #550 is resolved this can result in failing tests.
+long-doubles = []
diff --git a/bindgen-tests/tests/quickchecking/README.md b/bindgen-tests/tests/quickchecking/README.md
new file mode 100644
index 00000000..d3cfe170
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/README.md
@@ -0,0 +1,39 @@
+# Property tests for `bindgen` with `quickchecking`
+
+`quickchecking` generates random C headers to test `bindgen` 
+using the [`quickcheck`][quickcheck] property testing crate. When testing 
+`bindgen` with `quickchecking`, the generated header files are passed to 
+`bindgen`'s `csmith-fuzzing/predicate.py` script. If that script fails, 
+`quickchecking` panics, and you can report an issue containing the test case!
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Prerequisites](#prerequisites)
+- [Running](#running)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Prerequisites
+
+Requires `python3` to be in `$PATH`.
+
+Many systems have `python3` by default but if your OS doesn't, its package 
+manager may make it available:
+
+```
+$ sudo apt install python3
+$ brew install python3
+$ # Etc...
+```
+
+## Running
+
+Run `quickchecking` binary to generate and test fuzzed C headers with 
+`cargo run`. Additional configuration is exposed through the binary's CLI.
+
+```
+$ cargo run --bin=quickchecking -- -h
+```
+[quickcheck]: https://github.com/BurntSushi/quickcheck
diff --git a/bindgen-tests/tests/quickchecking/src/bin.rs b/bindgen-tests/tests/quickchecking/src/bin.rs
new file mode 100644
index 00000000..f2b52e82
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/src/bin.rs
@@ -0,0 +1,112 @@
+//! An application to run property tests for `bindgen` with _fuzzed_ C headers
+//! using `quickcheck`
+//!
+//! ## Usage
+//!
+//! Print help
+//! ```bash
+//! $ cargo run --bin=quickchecking -- -h
+//! ```
+//!
+//! Run with default values
+//! ```bash
+//! $ cargo run --bin=quickchecking
+//! ```
+//!
+#![deny(missing_docs)]
+extern crate clap;
+extern crate quickchecking;
+
+use clap::{App, Arg};
+use std::path::Path;
+
+// Validate CLI argument input for generation range.
+fn validate_generate_range(v: String) -> Result<(), String> {
+    match v.parse::<usize>() {
+        Ok(_) => Ok(()),
+        Err(_) => Err(String::from(
+            "Generate range could not be converted to a usize.",
+        )),
+    }
+}
+
+// Validate CLI argument input for tests count.
+fn validate_tests_count(v: String) -> Result<(), String> {
+    match v.parse::<usize>() {
+        Ok(_) => Ok(()),
+        Err(_) => Err(String::from(
+            "Tests count could not be converted to a usize.",
+        )),
+    }
+}
+
+// Validate CLI argument input for fuzzed headers output path.
+fn validate_path(v: String) -> Result<(), String> {
+    match Path::new(&v).is_dir() {
+        true => Ok(()),
+        false => Err(String::from("Provided directory path does not exist.")),
+    }
+}
+
+fn main() {
+    let matches = App::new("quickchecking")
+        .version("0.2.0")
+        .about(
+            "Bindgen property tests with quickcheck. \
+             Generate random valid C code and pass it to the \
+             csmith/predicate.py script",
+        )
+        .arg(
+            Arg::with_name("path")
+                .short("p")
+                .long("path")
+                .value_name("PATH")
+                .help(
+                    "Optional. Preserve generated headers for inspection, \
+                     provide directory path for header output. [default: None] ",
+                )
+                .takes_value(true)
+                .validator(validate_path),
+        )
+        .arg(
+            Arg::with_name("range")
+                .short("r")
+                .long("range")
+                .value_name("RANGE")
+                .help(
+                    "Sets the range quickcheck uses during generation. \
+                     Corresponds to things like arbitrary usize and \
+                     arbitrary vector length. This number doesn't have \
+                     to grow much for execution time to increase \
+                     significantly.",
+                )
+                .takes_value(true)
+                .default_value("32")
+                .validator(validate_generate_range),
+        )
+        .arg(
+            Arg::with_name("count")
+                .short("c")
+                .long("count")
+                .value_name("COUNT")
+                .help(
+                    "Count / number of tests to run. Running a fuzzed \
+                     header through the predicate.py script can take a \
+                     long time, especially if the generation range is \
+                     large. Increase this number if you're willing to \
+                     wait a while.",
+                )
+                .takes_value(true)
+                .default_value("2")
+                .validator(validate_tests_count),
+        )
+        .get_matches();
+
+    let output_path: Option<&str> = matches.value_of("path");
+    let generate_range: usize =
+        matches.value_of("range").unwrap().parse::<usize>().unwrap();
+    let tests: usize =
+        matches.value_of("count").unwrap().parse::<usize>().unwrap();
+
+    quickchecking::test_bindgen(generate_range, tests, output_path)
+}
diff --git a/bindgen-tests/tests/quickchecking/src/fuzzers.rs b/bindgen-tests/tests/quickchecking/src/fuzzers.rs
new file mode 100644
index 00000000..b609dd5a
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/src/fuzzers.rs
@@ -0,0 +1,635 @@
+use quickcheck::{Arbitrary, Gen, StdGen};
+use rand::thread_rng;
+use std::fmt;
+
+/// BaseTypeC is used in generation of C headers to represent the C language's
+/// primitive types as well as `void*`.
+#[derive(Debug, Clone)]
+pub struct BaseTypeC {
+    /// String representation of C type.
+    pub def: String,
+}
+
+/// TypeQualifierC is used in generation of C headers to represent qualifiers
+/// such as `const`.
+#[derive(Debug, Clone)]
+pub struct TypeQualifierC {
+    /// String representation of C type qualifier.
+    pub def: String,
+}
+
+/// PointerLevelC is used in generation of C headers to represent number of
+/// `*` for pointer types.
+#[derive(Debug, Clone)]
+pub struct PointerLevelC {
+    /// String representation of C declaration's pointer level.
+    pub def: String,
+}
+
+/// ArrayDimensionC is used in generation of C headers to represent number of
+/// `[]` used to define array types.
+#[derive(Debug, Clone)]
+pub struct ArrayDimensionC {
+    /// String representation of C declaration's array dimension.
+    pub def: String,
+}
+
+/// BasicTypeDeclarationC is used in generation of C headers to represent
+/// declarations outside of function pointers that take the form
+/// `BaseTypeC` + `TypeQualifierC` + `PointerLevelC` + `ident_id`.
+#[derive(Debug, Clone)]
+pub struct BasicTypeDeclarationC {
+    /// The declaration's base type, i.e. `int`.
+    pub type_name: BaseTypeC,
+    /// The declaration's type qualifier, i.e. `const`.
+    pub type_qualifier: TypeQualifierC,
+    /// The declaration's pointer level, i.e. `***`.
+    pub pointer_level: PointerLevelC,
+    /// The declaration's array dimension, i.e. [][][].
+    pub array_dimension: ArrayDimensionC,
+    /// The declaration's identifier, i.e. ident_N.
+    pub ident_id: String,
+}
+
+/// StructDeclarationC is used in generation of C headers to represent the
+/// definition of a struct type.
+#[derive(Debug, Clone)]
+pub struct StructDeclarationC {
+    /// The declaration's fields.
+    pub fields: DeclarationListC,
+    /// The declaration's array dimension, i.e. [][][].
+    pub array_dimension: ArrayDimensionC,
+    /// The declaration's identifier, i.e. struct_N.
+    pub ident_id: String,
+}
+
+/// UnionDeclarationC is used in generation of C headers to represent the
+/// definition of a union type.
+#[derive(Debug, Clone)]
+pub struct UnionDeclarationC {
+    /// The declaration's fields.
+    pub fields: DeclarationListC,
+    /// The declaration's array dimension, i.e. [][][].
+    pub array_dimension: ArrayDimensionC,
+    /// The declaration's identifier, i.e. union_N.
+    pub ident_id: String,
+}
+
+/// FunctionPointerDeclarationC is used in generation of C headers to represent
+/// the definition of a function pointer type.
+#[derive(Debug, Clone)]
+pub struct FunctionPointerDeclarationC {
+    /// The function's type qualifier, i.e. `const`.
+    pub type_qualifier: TypeQualifierC,
+    /// The function's return type, i.e. `int`.
+    pub type_name: BaseTypeC,
+    /// The function's pointer level, i.e. `***`.
+    pub pointer_level: PointerLevelC,
+    /// The function's parameters.
+    pub params: ParameterListC,
+    /// The declaration's identifier, i.e. func_ptr_N.
+    pub ident_id: String,
+}
+
+/// FunctionPrototypeC is used in generation of C headers to represent the
+/// definition of a function prototype.
+#[derive(Debug, Clone)]
+pub struct FunctionPrototypeC {
+    /// The function's type qualifier, i.e. `const`.
+    pub type_qualifier: TypeQualifierC,
+    /// The function's return type, i.e. `int`.
+    pub type_name: BaseTypeC,
+    /// The function's pointer level, i.e. `***`.
+    pub pointer_level: PointerLevelC,
+    /// The function's parameters.
+    pub params: ParameterListC,
+    /// The prototype's identifier, i.e. `func_N`.
+    pub ident_id: String,
+}
+
+/// ParameterC is used in generation of C headers to represent the
+/// definition function parameters.
+#[derive(Debug, Clone)]
+pub struct ParameterC {
+    /// The parameter's type qualifier, i.e. `const`.
+    pub type_qualifier: TypeQualifierC,
+    /// The parameter's base type, i.e. `int`.
+    pub type_name: BaseTypeC,
+    /// The parameter's pointer level, i.e. `***`.
+    pub pointer_level: PointerLevelC,
+}
+
+/// ParameterListC is used in generation of C headers to represent a list of
+/// definitions of function parameters.
+#[derive(Debug, Clone)]
+pub struct ParameterListC {
+    /// Parameters that define a C function signature.
+    pub params: Vec<ParameterC>,
+}
+
+/// DeclarationC is used in generation of C headers to represent all supported
+/// C type declarations allowed in the generated header.
+#[derive(Debug, Clone)]
+pub enum DeclarationC {
+    /// Function prototype declaration kind.
+    FunctionDecl(FunctionPrototypeC),
+    /// Function pointer declaration kind.
+    FunctionPtrDecl(FunctionPointerDeclarationC),
+    /// Struct declaration kind.
+    StructDecl(StructDeclarationC),
+    /// Union declaration kind.
+    UnionDecl(UnionDeclarationC),
+    /// Basic type declaration kind.
+    VariableDecl(BasicTypeDeclarationC),
+}
+
+/// DeclarationListC is used in generation of C headers to represent a list of
+/// declarations.
+#[derive(Debug, Clone)]
+pub struct DeclarationListC {
+    /// Grouping of C declarations.
+    pub decls: Vec<DeclarationC>,
+}
+
+/// HeaderC is used in generation of C headers to represent a collection of
+/// declarations.
+#[derive(Clone)]
+pub struct HeaderC {
+    /// The header's declarations.
+    pub def: DeclarationListC,
+}
+
+/// MakeUnique is used in generation of C headers to make declaration
+/// identifiers unique by incorporating the `stamp` parameter into it's name.
+trait MakeUnique {
+    fn make_unique(&mut self, stamp: usize);
+}
+
+/// MakeUnique is used in generation of C headers to make DeclarationC
+/// identifiers unique.
+impl MakeUnique for DeclarationC {
+    fn make_unique(&mut self, stamp: usize) {
+        match *self {
+            DeclarationC::FunctionDecl(ref mut d) => d.make_unique(stamp),
+            DeclarationC::FunctionPtrDecl(ref mut d) => d.make_unique(stamp),
+            DeclarationC::StructDecl(ref mut d) => d.make_unique(stamp),
+            DeclarationC::UnionDecl(ref mut d) => d.make_unique(stamp),
+            DeclarationC::VariableDecl(ref mut d) => d.make_unique(stamp),
+        }
+    }
+}
+
+/// A qucickcheck trait for describing how DeclarationC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for DeclarationC {
+    fn arbitrary<G: Gen>(g: &mut G) -> DeclarationC {
+        match g.gen_range(0, 5) {
+            0 => DeclarationC::FunctionDecl(FunctionPrototypeC::arbitrary(g)),
+            1 => DeclarationC::FunctionPtrDecl(
+                FunctionPointerDeclarationC::arbitrary(g),
+            ),
+            2 => DeclarationC::StructDecl(StructDeclarationC::arbitrary(g)),
+            3 => DeclarationC::UnionDecl(UnionDeclarationC::arbitrary(g)),
+            4 => {
+                DeclarationC::VariableDecl(BasicTypeDeclarationC::arbitrary(g))
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+/// Enables to string and format for DeclarationC types.
+impl fmt::Display for DeclarationC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            DeclarationC::FunctionPtrDecl(ref d) => write!(f, "{}", d),
+            DeclarationC::StructDecl(ref d) => write!(f, "{}", d),
+            DeclarationC::UnionDecl(ref d) => write!(f, "{}", d),
+            DeclarationC::VariableDecl(ref d) => write!(f, "{}", d),
+            DeclarationC::FunctionDecl(ref d) => write!(f, "{}", d),
+        }
+    }
+}
+
+/// A qucickcheck trait for describing how DeclarationListC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for DeclarationListC {
+    fn arbitrary<G: Gen>(g: &mut G) -> DeclarationListC {
+        DeclarationListC {
+            decls: Arbitrary::arbitrary(g),
+        }
+    }
+}
+
+/// Enables to string and format for DeclarationListC types.
+impl fmt::Display for DeclarationListC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut display = String::new();
+        for decl in &self.decls {
+            display += &format!("{}", decl);
+        }
+        write!(f, "{}", display)
+    }
+}
+
+/// A qucickcheck trait for describing how BaseTypeC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for BaseTypeC {
+    fn arbitrary<G: Gen>(g: &mut G) -> BaseTypeC {
+        // Special case `long double` until issue #550 is resolved.
+        let base_type = vec![
+            "char",
+            "signed char",
+            "unsigned char",
+            "short",
+            "short int",
+            "signed short",
+            "signed short int",
+            "unsigned short",
+            "unsigned short int",
+            "int",
+            "signed",
+            "signed int",
+            "unsigned",
+            "unsigned int",
+            "long",
+            "long int",
+            "signed long",
+            "signed long int",
+            "unsigned long",
+            "unsigned long int",
+            "long long",
+            "long long int",
+            "signed long long",
+            "signed long long int",
+            "unsigned long long",
+            "unsigned long long int",
+            "float",
+            "double",
+            #[cfg(feature = "long-doubles")]
+            "long double",
+            "void*",
+        ];
+        BaseTypeC {
+            def: String::from(*g.choose(&base_type).unwrap()),
+        }
+    }
+}
+
+/// Enables to string and format for BaseTypeC types,
+impl fmt::Display for BaseTypeC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.def)
+    }
+}
+
+/// A qucickcheck trait for describing how TypeQualifierC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for TypeQualifierC {
+    fn arbitrary<G: Gen>(g: &mut G) -> TypeQualifierC {
+        let qualifier = vec!["const", ""];
+        TypeQualifierC {
+            def: String::from(*g.choose(&qualifier).unwrap()),
+        }
+    }
+}
+
+/// Enables to string and format for TypeQualifierC types.
+impl fmt::Display for TypeQualifierC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.def)
+    }
+}
+
+/// A qucickcheck trait for describing how PointerLevelC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for PointerLevelC {
+    fn arbitrary<G: Gen>(g: &mut G) -> PointerLevelC {
+        PointerLevelC {
+            // 16 is an arbitrary "not too big" number for capping pointer level.
+            def: (0..g.gen_range(0, 16)).map(|_| "*").collect::<String>(),
+        }
+    }
+}
+
+/// Enables to string and format for PointerLevelC types.
+impl fmt::Display for PointerLevelC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.def)
+    }
+}
+
+/// A qucickcheck trait for describing how ArrayDimensionC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for ArrayDimensionC {
+    fn arbitrary<G: Gen>(g: &mut G) -> ArrayDimensionC {
+        // Keep these small, clang complains when they get too big.
+        let dimensions = g.gen_range(0, 5);
+        let mut def = String::new();
+
+        let lower_bound;
+        if cfg!(feature = "zero-sized-arrays") {
+            lower_bound = 0;
+        } else {
+            lower_bound = 1;
+        }
+
+        for _ in 1..dimensions {
+            // 16 is an arbitrary "not too big" number for capping array size.
+            def += &format!("[{}]", g.gen_range(lower_bound, 16));
+        }
+        ArrayDimensionC { def }
+    }
+}
+
+/// Enables to string and format for ArrayDimensionC types.
+impl fmt::Display for ArrayDimensionC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.def)
+    }
+}
+
+/// MakeUnique is used in generation of C headers to make BasicTypeDeclarationC
+/// identifiers unique.
+impl MakeUnique for BasicTypeDeclarationC {
+    fn make_unique(&mut self, stamp: usize) {
+        self.ident_id += &format!("_{}", stamp);
+    }
+}
+
+/// A qucickcheck trait for describing how BasicTypeDeclarationC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for BasicTypeDeclarationC {
+    fn arbitrary<G: Gen>(g: &mut G) -> BasicTypeDeclarationC {
+        BasicTypeDeclarationC {
+            type_qualifier: Arbitrary::arbitrary(g),
+            type_name: Arbitrary::arbitrary(g),
+            pointer_level: Arbitrary::arbitrary(g),
+            array_dimension: Arbitrary::arbitrary(g),
+            ident_id: format!("{}", usize::arbitrary(g)),
+        }
+    }
+}
+
+/// Enables to string and format for BasicTypeDeclarationC types.
+impl fmt::Display for BasicTypeDeclarationC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {} ident_{}{};",
+            self.type_qualifier,
+            self.type_name,
+            self.pointer_level,
+            self.ident_id,
+            self.array_dimension
+        )
+    }
+}
+
+/// MakeUnique is used in generation of C headers to make StructDeclarationC
+/// identifiers unique.
+impl MakeUnique for StructDeclarationC {
+    fn make_unique(&mut self, stamp: usize) {
+        self.ident_id += &format!("_{}", stamp);
+    }
+}
+
+/// A qucickcheck trait for describing how StructDeclarationC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for StructDeclarationC {
+    fn arbitrary<G: Gen>(g: &mut G) -> StructDeclarationC {
+        // Reduce generator size as a method of putting a bound on recursion.
+        // When size < 1 the empty list is generated.
+        let reduced_size: usize = (g.size() / 2) as usize + 1;
+        let mut decl_list: DeclarationListC =
+            Arbitrary::arbitrary(&mut StdGen::new(thread_rng(), reduced_size));
+        let mut fields: DeclarationListC = DeclarationListC { decls: vec![] };
+
+        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
+            match *decl {
+                DeclarationC::FunctionDecl(_) => {}
+                ref mut decl => {
+                    decl.make_unique(i);
+                    fields.decls.push(decl.clone());
+                }
+            }
+        }
+
+        StructDeclarationC {
+            fields,
+            ident_id: format!("{}", usize::arbitrary(g)),
+            array_dimension: Arbitrary::arbitrary(g),
+        }
+    }
+}
+
+/// Enables to string and format for StructDeclarationC types.
+impl fmt::Display for StructDeclarationC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "struct {{ {} }} struct_{}{};",
+            self.fields, self.ident_id, self.array_dimension
+        )
+    }
+}
+
+/// MakeUnique is used in generation of C headers to make UnionDeclarationC
+/// identifiers unique.
+impl MakeUnique for UnionDeclarationC {
+    fn make_unique(&mut self, stamp: usize) {
+        self.ident_id += &format!("_{}", stamp);
+    }
+}
+
+/// A qucickcheck trait for describing how UnionDeclarationC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for UnionDeclarationC {
+    fn arbitrary<G: Gen>(g: &mut G) -> UnionDeclarationC {
+        // Reduce generator size as a method of putting a bound on recursion.
+        // When size < 1 the empty list is generated.
+        let reduced_size: usize = (g.size() / 2) as usize + 1;
+        let mut decl_list: DeclarationListC =
+            Arbitrary::arbitrary(&mut StdGen::new(thread_rng(), reduced_size));
+        let mut fields: DeclarationListC = DeclarationListC { decls: vec![] };
+
+        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
+            match *decl {
+                DeclarationC::FunctionDecl(_) => {}
+                ref mut decl => {
+                    decl.make_unique(i);
+                    fields.decls.push(decl.clone());
+                }
+            }
+        }
+
+        UnionDeclarationC {
+            fields,
+            ident_id: format!("{}", usize::arbitrary(g)),
+            array_dimension: Arbitrary::arbitrary(g),
+        }
+    }
+}
+
+/// Enables to string and format for UnionDeclarationC types.
+impl fmt::Display for UnionDeclarationC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "union {{ {} }} union_{}{};",
+            self.fields, self.ident_id, self.array_dimension
+        )
+    }
+}
+
+/// MakeUnique is used in generation of C headers to make
+/// FunctionPointerDeclarationC identifiers unique.
+impl MakeUnique for FunctionPointerDeclarationC {
+    fn make_unique(&mut self, stamp: usize) {
+        self.ident_id += &format!("_{}", stamp);
+    }
+}
+
+/// A qucickcheck trait for describing how FunctionPointerDeclarationC types can
+/// be randomly generated and shrunk.
+impl Arbitrary for FunctionPointerDeclarationC {
+    fn arbitrary<G: Gen>(g: &mut G) -> FunctionPointerDeclarationC {
+        FunctionPointerDeclarationC {
+            type_qualifier: Arbitrary::arbitrary(g),
+            type_name: Arbitrary::arbitrary(g),
+            pointer_level: Arbitrary::arbitrary(g),
+            params: Arbitrary::arbitrary(g),
+            ident_id: format!("{}", usize::arbitrary(g)),
+        }
+    }
+}
+
+/// Enables to string and format for FunctionPointerDeclarationC types.
+impl fmt::Display for FunctionPointerDeclarationC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {} (*func_ptr_{})({});",
+            self.type_qualifier,
+            self.type_name,
+            self.pointer_level,
+            self.ident_id,
+            self.params
+        )
+    }
+}
+
+/// MakeUnique is used in generation of C headers to make FunctionPrototypeC
+/// identifiers unique.
+impl MakeUnique for FunctionPrototypeC {
+    fn make_unique(&mut self, stamp: usize) {
+        self.ident_id += &format!("_{}", stamp);
+    }
+}
+
+/// A qucickcheck trait for describing how FunctionPrototypeC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for FunctionPrototypeC {
+    fn arbitrary<G: Gen>(g: &mut G) -> FunctionPrototypeC {
+        FunctionPrototypeC {
+            type_qualifier: Arbitrary::arbitrary(g),
+            type_name: Arbitrary::arbitrary(g),
+            pointer_level: Arbitrary::arbitrary(g),
+            params: Arbitrary::arbitrary(g),
+            ident_id: format!("{}", usize::arbitrary(g)),
+        }
+    }
+}
+
+/// Enables to string and format for FunctionPrototypeC types.
+impl fmt::Display for FunctionPrototypeC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {} func_{}({});",
+            self.type_qualifier,
+            self.type_name,
+            self.pointer_level,
+            self.ident_id,
+            self.params
+        )
+    }
+}
+
+/// A qucickcheck trait for describing how ParameterC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for ParameterC {
+    fn arbitrary<G: Gen>(g: &mut G) -> ParameterC {
+        ParameterC {
+            type_qualifier: Arbitrary::arbitrary(g),
+            type_name: Arbitrary::arbitrary(g),
+            pointer_level: Arbitrary::arbitrary(g),
+        }
+    }
+}
+
+/// Enables to string and format for ParameterC types.
+impl fmt::Display for ParameterC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {}",
+            self.type_qualifier, self.type_name, self.pointer_level
+        )
+    }
+}
+
+/// A qucickcheck trait for describing how ParameterListC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for ParameterListC {
+    fn arbitrary<G: Gen>(g: &mut G) -> ParameterListC {
+        ParameterListC {
+            params: Arbitrary::arbitrary(g),
+        }
+    }
+}
+
+/// Enables to string and format for ParameterListC types.
+impl fmt::Display for ParameterListC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut display = String::new();
+        for (i, p) in self.params.iter().enumerate() {
+            match i {
+                0 => display += &format!("{}", p),
+                _ => display += &format!(",{}", p),
+            }
+        }
+        write!(f, "{}", display)
+    }
+}
+
+/// A qucickcheck trait for describing how HeaderC types can be
+/// randomly generated and shrunk.
+impl Arbitrary for HeaderC {
+    fn arbitrary<G: Gen>(g: &mut G) -> HeaderC {
+        let mut decl_list: DeclarationListC = Arbitrary::arbitrary(g);
+        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
+            decl.make_unique(i);
+        }
+        HeaderC { def: decl_list }
+    }
+}
+
+/// Enables to string and format for HeaderC types.
+impl fmt::Display for HeaderC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut display = String::new();
+        for decl in &self.def.decls {
+            display += &format!("{}", decl);
+        }
+        write!(f, "{}", display)
+    }
+}
+
+/// Use Display trait for Debug so that any failing property tests report
+/// generated C code rather than the data structures that contain it.
+impl fmt::Debug for HeaderC {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
diff --git a/bindgen-tests/tests/quickchecking/src/lib.rs b/bindgen-tests/tests/quickchecking/src/lib.rs
new file mode 100644
index 00000000..b09d1c49
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/src/lib.rs
@@ -0,0 +1,133 @@
+//! A library to generate __fuzzed__ C headers for use with `quickcheck`
+//!
+//! ## Example
+//!
+//! ```rust
+//! extern crate quickcheck;
+//! extern crate quickchecking;
+//! extern crate rand;
+//! use quickcheck::{Arbitrary, Gen, StdGen};
+//! use quickchecking::fuzzers;
+//! use rand::thread_rng;
+//!
+//! fn main() {
+//!     let generate_range: usize = 10; // Determines things like the length of
+//!                                     // arbitrary vectors generated.
+//!     let header = fuzzers::HeaderC::arbitrary(
+//!        &mut StdGen::new(thread_rng(), generate_range));
+//!     println!("{}", header);
+//! }
+//! ```
+//!
+#![deny(missing_docs)]
+#[macro_use]
+extern crate lazy_static;
+extern crate quickcheck;
+extern crate rand;
+extern crate tempdir;
+
+use quickcheck::{QuickCheck, StdGen, TestResult};
+use rand::thread_rng;
+use std::error::Error;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+use std::process::{Command, Output};
+use std::sync::Mutex;
+use tempdir::TempDir;
+
+/// Contains definitions of and impls for types used to fuzz C declarations.
+pub mod fuzzers;
+
+// Global singleton, manages context across tests. For now that context is
+// only the output_path for inspecting fuzzed headers (if specified).
+struct Context {
+    output_path: Option<String>,
+}
+
+// Initialize global context.
+lazy_static! {
+    static ref CONTEXT: Mutex<Context> =
+        Mutex::new(Context { output_path: None });
+}
+
+// Passes fuzzed header to the `csmith-fuzzing/predicate.py` script, returns
+// output of the associated command.
+fn run_predicate_script(
+    header: fuzzers::HeaderC,
+) -> Result<Output, Box<dyn Error>> {
+    let dir = TempDir::new("bindgen_prop")?;
+    let header_path = dir.path().join("prop_test.h");
+
+    let mut header_file = File::create(&header_path)?;
+    header_file.write_all(header.to_string().as_bytes())?;
+    header_file.sync_all()?;
+
+    let header_path_string;
+    match header_path.into_os_string().into_string() {
+        Ok(s) => header_path_string = s,
+        Err(_) => return Err(From::from("error converting path into String")),
+    }
+
+    let mut predicate_script_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    predicate_script_path.push("../../csmith-fuzzing/predicate.py");
+
+    let predicate_script_path_string;
+    match predicate_script_path.into_os_string().into_string() {
+        Ok(s) => predicate_script_path_string = s,
+        Err(_) => return Err(From::from("error converting path into String")),
+    }
+
+    // Copy generated temp files to output_path directory for inspection.
+    // If `None`, output path not specified, don't copy.
+    match CONTEXT.lock().unwrap().output_path {
+        Some(ref path) => {
+            Command::new("cp")
+                .arg("-a")
+                .arg(&dir.path().to_str().unwrap())
+                .arg(&path)
+                .output()?;
+        }
+        None => {}
+    }
+
+    Ok(Command::new(&predicate_script_path_string)
+        .arg(&header_path_string)
+        .output()?)
+}
+
+// Generatable property. Pass generated headers off to run through the
+// `csmith-fuzzing/predicate.py` script. Success is measured by the success
+// status of that command.
+fn bindgen_prop(header: fuzzers::HeaderC) -> TestResult {
+    match run_predicate_script(header) {
+        Ok(o) => return TestResult::from_bool(o.status.success()),
+        Err(e) => {
+            println!("{:?}", e);
+            return TestResult::from_bool(false);
+        }
+    }
+}
+
+/// Instantiate a Quickcheck object and use it to run property tests using
+/// fuzzed C headers generated with types defined in the `fuzzers` module.
+/// Success/Failure is dictated by the result of passing the fuzzed headers
+/// to the `csmith-fuzzing/predicate.py` script.
+pub fn test_bindgen(
+    generate_range: usize,
+    tests: usize,
+    output_path: Option<&str>,
+) {
+    match output_path {
+        Some(path) => {
+            CONTEXT.lock().unwrap().output_path =
+                Some(String::from(PathBuf::from(path).to_str().unwrap()));
+        }
+        None => {} // Path not specified, don't provide output.
+    }
+
+    QuickCheck::new()
+        .tests(tests)
+        .gen(StdGen::new(thread_rng(), generate_range))
+        .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult)
+}
diff --git a/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs b/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs
new file mode 100644
index 00000000..800c70b4
--- /dev/null
+++ b/bindgen-tests/tests/quickchecking/tests/fuzzed-c-headers.rs
@@ -0,0 +1,96 @@
+extern crate quickcheck;
+extern crate quickchecking;
+extern crate rand;
+
+use quickcheck::{Arbitrary, StdGen};
+use quickchecking::fuzzers::{
+    ArrayDimensionC, BaseTypeC, BasicTypeDeclarationC, DeclarationC,
+    DeclarationListC, FunctionPointerDeclarationC, FunctionPrototypeC, HeaderC,
+    ParameterC, ParameterListC, PointerLevelC, StructDeclarationC,
+    TypeQualifierC, UnionDeclarationC,
+};
+use rand::thread_rng;
+
+#[test]
+fn test_declaraion_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: DeclarationC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_declaraion_list_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: DeclarationListC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_base_type_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: BaseTypeC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_type_qualifier_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: TypeQualifierC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_pointer_level_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: PointerLevelC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_array_dimension_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: ArrayDimensionC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_basic_type_declaration_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: BasicTypeDeclarationC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_struct_declaration_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: StructDeclarationC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_union_declaration_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: UnionDeclarationC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_function_pointer_declaration_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: FunctionPointerDeclarationC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_function_prototype_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: FunctionPrototypeC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_parameter_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: ParameterC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_parameter_list_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: ParameterListC = Arbitrary::arbitrary(gen);
+}
+
+#[test]
+fn test_header_c_does_not_panic() {
+    let ref mut gen = StdGen::new(thread_rng(), 50);
+    let _: HeaderC = Arbitrary::arbitrary(gen);
+}
diff --git a/bindgen-tests/tests/rustfmt.toml b/bindgen-tests/tests/rustfmt.toml
new file mode 100644
index 00000000..2564ccb5
--- /dev/null
+++ b/bindgen-tests/tests/rustfmt.toml
@@ -0,0 +1,3 @@
+normalize_doc_attributes = true
+max_width = 80
+binop_separator = "back"
diff --git a/bindgen-tests/tests/stylo.hpp b/bindgen-tests/tests/stylo.hpp
new file mode 100644
index 00000000..88102903
--- /dev/null
+++ b/bindgen-tests/tests/stylo.hpp
@@ -0,0 +1,177914 @@
+# 1 "stylo.cpp"
+# 1 "<built-in>" 1
+# 1 "<built-in>" 3
+# 352 "<built-in>" 3
+# 1 "<command line>" 1
+# 1 "<built-in>" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
+#pragma clang diagnostic push
+
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
+#pragma clang diagnostic pop
+# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h" 1
+# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h"
+typedef const char16_t* char16ptr_t;
+
+
+
+static_assert(sizeof(char16_t) == 2, "Is char16_t type 16 bits?");
+static_assert(char16_t(-1) > char16_t(0), "Is char16_t type unsigned?");
+static_assert(sizeof(u'A') == 2, "Is unicode char literal 16 bits?");
+static_assert(sizeof(u""[0]) == 2, "Is unicode string char 16 bits?");
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 2
+# 2 "<built-in>" 2
+# 1 "stylo.cpp" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 1 3
+# 63 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 3
+# 1 "/usr/include/stdint.h" 1 3 4
+# 25 "/usr/include/stdint.h" 3 4
+# 1 "/usr/include/features.h" 1 3 4
+# 346 "/usr/include/features.h" 3 4
+# 1 "/usr/include/stdc-predef.h" 1 3 4
+# 347 "/usr/include/features.h" 2 3 4
+# 368 "/usr/include/features.h" 3 4
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+# 415 "/usr/include/sys/cdefs.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 416 "/usr/include/sys/cdefs.h" 2 3 4
+# 369 "/usr/include/features.h" 2 3 4
+# 392 "/usr/include/features.h" 3 4
+# 1 "/usr/include/gnu/stubs.h" 1 3 4
+# 10 "/usr/include/gnu/stubs.h" 3 4
+# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
+# 11 "/usr/include/gnu/stubs.h" 2 3 4
+# 393 "/usr/include/features.h" 2 3 4
+# 26 "/usr/include/stdint.h" 2 3 4
+# 1 "/usr/include/bits/wchar.h" 1 3 4
+# 27 "/usr/include/stdint.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 28 "/usr/include/stdint.h" 2 3 4
+
+
+
+
+
+
+
+
+typedef signed char int8_t;
+typedef short int int16_t;
+typedef int int32_t;
+
+typedef long int int64_t;
+
+
+
+
+
+
+
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+
+typedef unsigned int uint32_t;
+
+
+
+typedef unsigned long int uint64_t;
+# 65 "/usr/include/stdint.h" 3 4
+typedef signed char int_least8_t;
+typedef short int int_least16_t;
+typedef int int_least32_t;
+
+typedef long int int_least64_t;
+
+
+
+
+
+
+typedef unsigned char uint_least8_t;
+typedef unsigned short int uint_least16_t;
+typedef unsigned int uint_least32_t;
+
+typedef unsigned long int uint_least64_t;
+# 90 "/usr/include/stdint.h" 3 4
+typedef signed char int_fast8_t;
+
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+# 103 "/usr/include/stdint.h" 3 4
+typedef unsigned char uint_fast8_t;
+
+typedef unsigned long int uint_fast16_t;
+typedef unsigned long int uint_fast32_t;
+typedef unsigned long int uint_fast64_t;
+# 119 "/usr/include/stdint.h" 3 4
+typedef long int intptr_t;
+
+
+typedef unsigned long int uintptr_t;
+# 134 "/usr/include/stdint.h" 3 4
+typedef long int intmax_t;
+typedef unsigned long int uintmax_t;
+# 64 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 2 3
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 1
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 1 3
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 3
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 1 3
+
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 4 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
+# 2106 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
+namespace std
+{
+  typedef long unsigned int size_t;
+  typedef long int ptrdiff_t;
+
+
+  typedef decltype(nullptr) nullptr_t;
+
+}
+# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
+namespace std
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+# 2414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/os_defines.h" 1 3
+# 2415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
+# 2418 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
+# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 51 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
+typedef long int ptrdiff_t;
+# 62 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
+typedef long unsigned int size_t;
+# 118 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 1 3
+# 35 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 3
+typedef struct {
+  long long __clang_max_align_nonce1
+      __attribute__((__aligned__(__alignof__(long long))));
+  long double __clang_max_align_nonce2
+      __attribute__((__aligned__(__alignof__(long double))));
+} max_align_t;
+# 119 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 2 3
+# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3
+
+
+namespace std
+{
+
+  using ::max_align_t;
+}
+# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 2
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 2
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 2
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 36 "/usr/include/wchar.h" 3 4
+# 1 "/usr/include/stdio.h" 1 3 4
+# 44 "/usr/include/stdio.h" 3 4
+struct _IO_FILE;
+
+
+
+typedef struct _IO_FILE FILE;
+# 64 "/usr/include/stdio.h" 3 4
+typedef struct _IO_FILE __FILE;
+# 37 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 1 3 4
+# 30 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4
+typedef __builtin_va_list va_list;
+# 50 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 40 "/usr/include/wchar.h" 2 3 4
+# 51 "/usr/include/wchar.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 132 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 4
+typedef unsigned int wint_t;
+# 52 "/usr/include/wchar.h" 2 3 4
+# 82 "/usr/include/wchar.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+
+    unsigned int __wch;
+
+
+
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 106 "/usr/include/wchar.h" 3 4
+typedef __mbstate_t mbstate_t;
+# 132 "/usr/include/wchar.h" 3 4
+extern "C" {
+
+
+
+
+struct tm;
+# 147 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
+   size_t __n) throw ();
+
+
+
+
+# 1 "/usr/include/xlocale.h" 1 3 4
+# 27 "/usr/include/xlocale.h" 3 4
+typedef struct __locale_struct
+{
+
+  struct __locale_data *__locales[13];
+
+
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+
+
+  const char *__names[13];
+} *__locale_t;
+
+
+typedef __locale_t locale_t;
+# 184 "/usr/include/wchar.h" 2 3 4
+
+extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+    __locale_t __loc) throw ();
+
+extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+     size_t __n, __locale_t __loc) throw ();
+
+
+
+
+
+extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         const wchar_t *__restrict __s2, size_t __n) throw ();
+# 209 "/usr/include/wchar.h" 3 4
+extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
+        __locale_t __loc) throw ();
+
+
+
+
+extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
+    size_t __n, __locale_t __loc) throw ();
+
+
+extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
+# 230 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+# 240 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+
+extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+
+
+extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+# 269 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+# 280 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
+     throw () __attribute__ ((__pure__));
+
+
+
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+
+
+extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
+# 302 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+# 323 "/usr/include/wchar.h" 3 4
+extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+
+extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw ();
+
+
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+
+
+
+
+
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+
+
+
+
+
+
+extern wint_t btowc (int __c) throw ();
+
+
+
+extern int wctob (wint_t __c) throw ();
+
+
+
+extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+
+
+
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         const char *__restrict __s, size_t __n,
+         mbstate_t *__restrict __p) throw ();
+
+
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+
+
+extern size_t __mbrlen (const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+# 411 "/usr/include/wchar.h" 3 4
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsrtombs (char *__restrict __dst,
+    const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsnrtombs (char *__restrict __dst,
+     const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+extern int wcwidth (wchar_t __c) throw ();
+
+
+
+extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
+
+
+
+
+
+
+extern double wcstod (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) throw ();
+
+
+
+
+
+extern float wcstof (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long double wcstold (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+
+
+
+
+
+
+
+extern long int wcstol (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) throw ();
+
+
+
+extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+
+
+
+__extension__
+extern long long int wcstoll (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) throw ();
+
+
+
+
+
+
+__extension__
+extern long long int wcstoq (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) throw ();
+# 533 "/usr/include/wchar.h" 3 4
+extern long int wcstol_l (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     __locale_t __loc) throw ();
+
+extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, __locale_t __loc) throw ();
+
+__extension__
+extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, __locale_t __loc) throw ();
+
+__extension__
+extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw ();
+
+extern double wcstod_l (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern float wcstof_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern long double wcstold_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         __locale_t __loc) throw ();
+
+
+
+
+
+
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src) throw ();
+
+
+
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw ();
+
+
+
+
+
+
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+
+
+
+
+
+
+extern int fwide (__FILE *__fp, int __mode) throw ();
+
+
+
+
+
+
+extern int fwprintf (__FILE *__restrict __stream,
+       const wchar_t *__restrict __format, ...)
+                                                           ;
+
+
+
+
+extern int wprintf (const wchar_t *__restrict __format, ...)
+                                                           ;
+
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       const wchar_t *__restrict __format, ...)
+     throw () ;
+
+
+
+
+
+extern int vfwprintf (__FILE *__restrict __s,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+
+
+
+
+extern int vwprintf (const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+
+
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+
+
+
+
+
+
+extern int fwscanf (__FILE *__restrict __stream,
+      const wchar_t *__restrict __format, ...)
+                                                          ;
+
+
+
+
+extern int wscanf (const wchar_t *__restrict __format, ...)
+                                                          ;
+
+extern int swscanf (const wchar_t *__restrict __s,
+      const wchar_t *__restrict __format, ...)
+     throw () ;
+# 692 "/usr/include/wchar.h" 3 4
+extern int vfwscanf (__FILE *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+
+
+
+
+extern int vwscanf (const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+
+extern int vswscanf (const wchar_t *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+# 748 "/usr/include/wchar.h" 3 4
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+
+
+
+
+
+extern wint_t getwchar (void);
+
+
+
+
+
+
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+
+
+
+
+
+extern wint_t putwchar (wchar_t __wc);
+
+
+
+
+
+
+
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+
+
+
+
+
+extern int fputws (const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+# 804 "/usr/include/wchar.h" 3 4
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+
+
+
+
+
+
+
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+
+
+
+
+
+
+
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+# 830 "/usr/include/wchar.h" 3 4
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+# 840 "/usr/include/wchar.h" 3 4
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fputws_unlocked (const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   const wchar_t *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+
+
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     const wchar_t *__restrict __format,
+     const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+# 894 "/usr/include/wchar.h" 3 4
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2
+
+namespace mozilla {
+
+
+
+template<typename> struct RemoveCV;
+template<typename> struct AddRvalueReference;
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+typename AddRvalueReference<T>::Type DeclVal();
+
+
+
+
+
+
+
+template<typename T, T Value>
+struct IntegralConstant
+{
+  static constexpr T value = Value;
+  typedef T ValueType;
+  typedef IntegralConstant<T, Value> Type;
+};
+
+
+typedef IntegralConstant<bool, true> TrueType;
+typedef IntegralConstant<bool, false> FalseType;
+
+
+
+
+
+namespace detail {
+
+template<typename T>
+struct IsVoidHelper : FalseType {};
+
+template<>
+struct IsVoidHelper<void> : TrueType {};
+
+}
+# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsVoid : detail::IsVoidHelper<typename RemoveCV<T>::Type> {};
+
+namespace detail {
+
+template <typename T>
+struct IsIntegralHelper : FalseType {};
+
+template<> struct IsIntegralHelper<char> : TrueType {};
+template<> struct IsIntegralHelper<signed char> : TrueType {};
+template<> struct IsIntegralHelper<unsigned char> : TrueType {};
+template<> struct IsIntegralHelper<short> : TrueType {};
+template<> struct IsIntegralHelper<unsigned short> : TrueType {};
+template<> struct IsIntegralHelper<int> : TrueType {};
+template<> struct IsIntegralHelper<unsigned int> : TrueType {};
+template<> struct IsIntegralHelper<long> : TrueType {};
+template<> struct IsIntegralHelper<unsigned long> : TrueType {};
+template<> struct IsIntegralHelper<long long> : TrueType {};
+template<> struct IsIntegralHelper<unsigned long long> : TrueType {};
+template<> struct IsIntegralHelper<bool> : TrueType {};
+template<> struct IsIntegralHelper<wchar_t> : TrueType {};
+template<> struct IsIntegralHelper<char16_t> : TrueType {};
+
+}
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsIntegral : detail::IsIntegralHelper<typename RemoveCV<T>::Type>
+{};
+
+template<typename T, typename U>
+struct IsSame;
+
+namespace detail {
+
+template<typename T>
+struct IsFloatingPointHelper
+  : IntegralConstant<bool,
+                     IsSame<T, float>::value ||
+                     IsSame<T, double>::value ||
+                     IsSame<T, long double>::value>
+{};
+
+}
+# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsFloatingPoint
+  : detail::IsFloatingPointHelper<typename RemoveCV<T>::Type>
+{};
+
+namespace detail {
+
+template<typename T>
+struct IsArrayHelper : FalseType {};
+
+template<typename T, decltype(sizeof(1)) N>
+struct IsArrayHelper<T[N]> : TrueType {};
+
+template<typename T>
+struct IsArrayHelper<T[]> : TrueType {};
+
+}
+# 168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsArray : detail::IsArrayHelper<typename RemoveCV<T>::Type>
+{};
+
+namespace detail {
+
+template<typename T>
+struct IsFunPtr;
+
+template<typename>
+struct IsFunPtr
+  : public FalseType
+{};
+
+template<typename Result, typename... ArgTypes>
+struct IsFunPtr<Result(*)(ArgTypes...)>
+  : public TrueType
+{};
+
+};
+# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsFunction
+  : public detail::IsFunPtr<typename RemoveCV<T>::Type *>
+{};
+
+namespace detail {
+
+template<typename T>
+struct IsPointerHelper : FalseType {};
+
+template<typename T>
+struct IsPointerHelper<T*> : TrueType {};
+
+}
+# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsPointer : detail::IsPointerHelper<typename RemoveCV<T>::Type>
+{};
+# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsLvalueReference : FalseType {};
+
+template<typename T>
+struct IsLvalueReference<T&> : TrueType {};
+# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsRvalueReference : FalseType {};
+
+template<typename T>
+struct IsRvalueReference<T&&> : TrueType {};
+
+namespace detail {
+
+
+template<typename T>
+struct IsEnumHelper
+  : IntegralConstant<bool, __is_enum(T)>
+{};
+
+}
+# 286 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsEnum
+  : detail::IsEnumHelper<typename RemoveCV<T>::Type>
+{};
+
+namespace detail {
+
+
+
+
+
+template<typename T>
+struct IsClassHelper
+  : IntegralConstant<bool, __is_class(T)>
+{};
+
+}
+# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsClass
+  : detail::IsClassHelper<typename RemoveCV<T>::Type>
+{};
+# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsReference
+  : IntegralConstant<bool,
+                     IsLvalueReference<T>::value || IsRvalueReference<T>::value>
+{};
+# 348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsArithmetic
+  : IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>
+{};
+
+namespace detail {
+
+template<typename T>
+struct IsMemberPointerHelper : FalseType {};
+
+template<typename T, typename U>
+struct IsMemberPointerHelper<T U::*> : TrueType {};
+
+}
+# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsMemberPointer
+  : detail::IsMemberPointerHelper<typename RemoveCV<T>::Type>
+{};
+# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsScalar
+  : IntegralConstant<bool, IsArithmetic<T>::value || IsEnum<T>::value ||
+                     IsPointer<T>::value || IsMemberPointer<T>::value>
+{};
+# 397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsConst : FalseType {};
+
+template<typename T>
+struct IsConst<const T> : TrueType {};
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsVolatile : FalseType {};
+
+template<typename T>
+struct IsVolatile<volatile T> : TrueType {};
+# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsPod : public FalseType {};
+
+template<> struct IsPod<char> : TrueType {};
+template<> struct IsPod<signed char> : TrueType {};
+template<> struct IsPod<unsigned char> : TrueType {};
+template<> struct IsPod<short> : TrueType {};
+template<> struct IsPod<unsigned short> : TrueType {};
+template<> struct IsPod<int> : TrueType {};
+template<> struct IsPod<unsigned int> : TrueType {};
+template<> struct IsPod<long> : TrueType {};
+template<> struct IsPod<unsigned long> : TrueType {};
+template<> struct IsPod<long long> : TrueType {};
+template<> struct IsPod<unsigned long long> : TrueType {};
+template<> struct IsPod<bool> : TrueType {};
+template<> struct IsPod<float> : TrueType {};
+template<> struct IsPod<double> : TrueType {};
+template<> struct IsPod<wchar_t> : TrueType {};
+template<> struct IsPod<char16_t> : TrueType {};
+template<typename T> struct IsPod<T*> : TrueType {};
+
+namespace detail {
+
+
+
+
+
+template<typename T>
+struct IsEmptyHelper
+  : IntegralConstant<bool, IsClass<T>::value && __is_empty(T)>
+{};
+
+}
+# 498 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsEmpty : detail::IsEmptyHelper<typename RemoveCV<T>::Type>
+{};
+
+
+namespace detail {
+
+template<typename T,
+         bool = IsFloatingPoint<T>::value,
+         bool = IsIntegral<T>::value,
+         typename NoCV = typename RemoveCV<T>::Type>
+struct IsSignedHelper;
+
+
+template<typename T, typename NoCV>
+struct IsSignedHelper<T, true, false, NoCV> : TrueType {};
+
+
+template<typename T, typename NoCV>
+struct IsSignedHelper<T, false, true, NoCV>
+  : IntegralConstant<bool, bool(NoCV(-1) < NoCV(1))>
+{};
+
+
+template<typename T, typename NoCV>
+struct IsSignedHelper<T, false, false, NoCV> : FalseType {};
+
+}
+# 536 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsSigned : detail::IsSignedHelper<T> {};
+
+namespace detail {
+
+template<typename T,
+         bool = IsFloatingPoint<T>::value,
+         bool = IsIntegral<T>::value,
+         typename NoCV = typename RemoveCV<T>::Type>
+struct IsUnsignedHelper;
+
+
+template<typename T, typename NoCV>
+struct IsUnsignedHelper<T, true, false, NoCV> : FalseType {};
+
+
+template<typename T, typename NoCV>
+struct IsUnsignedHelper<T, false, true, NoCV>
+  : IntegralConstant<bool,
+                     (IsSame<NoCV, bool>::value || bool(NoCV(1) < NoCV(-1)))>
+{};
+
+
+template<typename T, typename NoCV>
+struct IsUnsignedHelper<T, false, false, NoCV> : FalseType {};
+
+}
+# 572 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsUnsigned : detail::IsUnsignedHelper<T> {};
+
+namespace detail {
+
+struct DoIsDefaultConstructibleImpl
+{
+  template<typename T, typename = decltype(T())>
+  static TrueType test(int);
+  template<typename T>
+  static FalseType test(...);
+};
+
+template<typename T>
+struct IsDefaultConstructibleImpl : public DoIsDefaultConstructibleImpl
+{
+  typedef decltype(test<T>(0)) Type;
+};
+
+}
+# 611 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsDefaultConstructible
+  : public detail::IsDefaultConstructibleImpl<T>::Type
+{};
+
+namespace detail {
+
+struct DoIsDestructibleImpl
+{
+  template<typename T, typename = decltype(DeclVal<T&>().~T())>
+  static TrueType test(int);
+  template<typename T>
+  static FalseType test(...);
+};
+
+template<typename T>
+struct IsDestructibleImpl : public DoIsDestructibleImpl
+{
+  typedef decltype(test<T>(0)) Type;
+};
+
+}
+# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct IsDestructible : public detail::IsDestructibleImpl<T>::Type {};
+# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T, typename U>
+struct IsSame : FalseType {};
+
+template<typename T>
+struct IsSame<T, T> : TrueType {};
+
+namespace detail {
+
+
+
+template<class Base, class Derived>
+struct BaseOfTester : IntegralConstant<bool, __is_base_of(Base, Derived)> {};
+# 727 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+}
+# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<class Base, class Derived>
+struct IsBaseOf
+  : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
+{};
+
+namespace detail {
+
+template<typename From, typename To>
+struct ConvertibleTester
+{
+private:
+  template<typename To1>
+  static char test_helper(To1);
+
+  template<typename From1, typename To1>
+  static decltype(test_helper<To1>(DeclVal<From1>())) test(int);
+
+  template<typename From1, typename To1>
+  static int test(...);
+
+public:
+  static const bool value =
+    sizeof(test<From, To>(0)) == sizeof(char);
+};
+
+}
+# 793 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename From, typename To>
+struct IsConvertible
+  : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
+{};
+
+template<typename B>
+struct IsConvertible<void, B>
+  : IntegralConstant<bool, IsVoid<B>::value>
+{};
+
+template<typename A>
+struct IsConvertible<A, void>
+  : IntegralConstant<bool, IsVoid<A>::value>
+{};
+
+template<>
+struct IsConvertible<void, void>
+  : TrueType
+{};
+# 825 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemoveConst
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct RemoveConst<const T>
+{
+  typedef T Type;
+};
+# 845 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemoveVolatile
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct RemoveVolatile<volatile T>
+{
+  typedef T Type;
+};
+# 865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemoveCV
+{
+  typedef typename RemoveConst<typename RemoveVolatile<T>::Type>::Type Type;
+};
+# 881 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemoveReference
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct RemoveReference<T&>
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct RemoveReference<T&&>
+{
+  typedef T Type;
+};
+
+template<bool Condition, typename A, typename B>
+struct Conditional;
+
+namespace detail {
+
+enum Voidness { TIsVoid, TIsNotVoid };
+
+template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
+struct AddLvalueReferenceHelper;
+
+template<typename T>
+struct AddLvalueReferenceHelper<T, TIsVoid>
+{
+  typedef void Type;
+};
+
+template<typename T>
+struct AddLvalueReferenceHelper<T, TIsNotVoid>
+{
+  typedef T& Type;
+};
+
+}
+# 937 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct AddLvalueReference
+  : detail::AddLvalueReferenceHelper<T>
+{};
+
+namespace detail {
+
+template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
+struct AddRvalueReferenceHelper;
+
+template<typename T>
+struct AddRvalueReferenceHelper<T, TIsVoid>
+{
+  typedef void Type;
+};
+
+template<typename T>
+struct AddRvalueReferenceHelper<T, TIsNotVoid>
+{
+  typedef T&& Type;
+};
+
+}
+# 976 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct AddRvalueReference
+  : detail::AddRvalueReferenceHelper<T>
+{};
+
+
+
+template<bool B, typename T = void>
+struct EnableIf;
+
+namespace detail {
+
+template<bool MakeConst, typename T>
+struct WithC : Conditional<MakeConst, const T, T>
+{};
+
+template<bool MakeVolatile, typename T>
+struct WithV : Conditional<MakeVolatile, volatile T, T>
+{};
+
+
+template<bool MakeConst, bool MakeVolatile, typename T>
+struct WithCV : WithC<MakeConst, typename WithV<MakeVolatile, T>::Type>
+{};
+
+template<typename T>
+struct CorrespondingSigned;
+
+template<>
+struct CorrespondingSigned<char> { typedef signed char Type; };
+template<>
+struct CorrespondingSigned<unsigned char> { typedef signed char Type; };
+template<>
+struct CorrespondingSigned<unsigned short> { typedef short Type; };
+template<>
+struct CorrespondingSigned<unsigned int> { typedef int Type; };
+template<>
+struct CorrespondingSigned<unsigned long> { typedef long Type; };
+template<>
+struct CorrespondingSigned<unsigned long long> { typedef long long Type; };
+
+template<typename T,
+         typename CVRemoved = typename RemoveCV<T>::Type,
+         bool IsSignedIntegerType = IsSigned<CVRemoved>::value &&
+                                    !IsSame<char, CVRemoved>::value>
+struct MakeSigned;
+
+template<typename T, typename CVRemoved>
+struct MakeSigned<T, CVRemoved, true>
+{
+  typedef T Type;
+};
+
+template<typename T, typename CVRemoved>
+struct MakeSigned<T, CVRemoved, false>
+  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
+           typename CorrespondingSigned<CVRemoved>::Type>
+{};
+
+}
+# 1059 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct MakeSigned
+  : EnableIf<IsIntegral<T>::value &&
+             !IsSame<bool, typename RemoveCV<T>::Type>::value,
+             typename detail::MakeSigned<T>
+            >::Type
+{};
+
+namespace detail {
+
+template<typename T>
+struct CorrespondingUnsigned;
+
+template<>
+struct CorrespondingUnsigned<char> { typedef unsigned char Type; };
+template<>
+struct CorrespondingUnsigned<signed char> { typedef unsigned char Type; };
+template<>
+struct CorrespondingUnsigned<short> { typedef unsigned short Type; };
+template<>
+struct CorrespondingUnsigned<int> { typedef unsigned int Type; };
+template<>
+struct CorrespondingUnsigned<long> { typedef unsigned long Type; };
+template<>
+struct CorrespondingUnsigned<long long> { typedef unsigned long long Type; };
+
+
+template<typename T,
+         typename CVRemoved = typename RemoveCV<T>::Type,
+         bool IsUnsignedIntegerType = IsUnsigned<CVRemoved>::value &&
+                                      !IsSame<char, CVRemoved>::value>
+struct MakeUnsigned;
+
+template<typename T, typename CVRemoved>
+struct MakeUnsigned<T, CVRemoved, true>
+{
+  typedef T Type;
+};
+
+template<typename T, typename CVRemoved>
+struct MakeUnsigned<T, CVRemoved, false>
+  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
+           typename CorrespondingUnsigned<CVRemoved>::Type>
+{};
+
+}
+# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct MakeUnsigned
+  : EnableIf<IsIntegral<T>::value &&
+             !IsSame<bool, typename RemoveCV<T>::Type>::value,
+             typename detail::MakeUnsigned<T>
+            >::Type
+{};
+# 1147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemoveExtent
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct RemoveExtent<T[]>
+{
+  typedef T Type;
+};
+
+template<typename T, decltype(sizeof(1)) N>
+struct RemoveExtent<T[N]>
+{
+  typedef T Type;
+};
+
+
+
+namespace detail {
+
+template<typename T, typename CVRemoved>
+struct RemovePointerHelper
+{
+  typedef T Type;
+};
+
+template<typename T, typename Pointee>
+struct RemovePointerHelper<T, Pointee*>
+{
+  typedef Pointee Type;
+};
+
+}
+# 1198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct RemovePointer
+  : detail::RemovePointerHelper<T, typename RemoveCV<T>::Type>
+{};
+# 1213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+struct AddPointer
+{
+  typedef typename RemoveReference<T>::Type* Type;
+};
+# 1239 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<bool B, typename T>
+struct EnableIf
+{};
+
+template<typename T>
+struct EnableIf<true, T>
+{
+  typedef T Type;
+};
+
+
+
+
+
+
+
+template<bool Condition, typename A, typename B>
+struct Conditional
+{
+  typedef A Type;
+};
+
+template<class A, class B>
+struct Conditional<false, A, B>
+{
+  typedef B Type;
+};
+
+namespace detail {
+
+template<typename U,
+         bool IsArray = IsArray<U>::value,
+         bool IsFunction = IsFunction<U>::value>
+struct DecaySelector;
+
+template<typename U>
+struct DecaySelector<U, false, false>
+{
+  typedef typename RemoveCV<U>::Type Type;
+};
+
+template<typename U>
+struct DecaySelector<U, true, false>
+{
+  typedef typename RemoveExtent<U>::Type* Type;
+};
+
+template<typename U>
+struct DecaySelector<U, false, true>
+{
+  typedef typename AddPointer<U>::Type Type;
+};
+
+};
+# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
+template<typename T>
+class Decay
+  : public detail::DecaySelector<typename RemoveReference<T>::Type>
+{
+};
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 2
+
+
+namespace mozilla {
+
+namespace detail {
+
+
+
+
+
+
+template<size_t Size, bool Signedness>
+struct StdintTypeForSizeAndSignedness;
+
+template<>
+struct StdintTypeForSizeAndSignedness<1, true>
+{
+  typedef int8_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<1, false>
+{
+  typedef uint8_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<2, true>
+{
+  typedef int16_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<2, false>
+{
+  typedef uint16_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<4, true>
+{
+  typedef int32_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<4, false>
+{
+  typedef uint32_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<8, true>
+{
+  typedef int64_t Type;
+};
+
+template<>
+struct StdintTypeForSizeAndSignedness<8, false>
+{
+  typedef uint64_t Type;
+};
+
+}
+
+template<size_t Size>
+struct UnsignedStdintTypeForSize
+  : detail::StdintTypeForSizeAndSignedness<Size, false>
+{};
+
+template<size_t Size>
+struct SignedStdintTypeForSize
+  : detail::StdintTypeForSizeAndSignedness<Size, true>
+{};
+
+template<typename IntegerType>
+struct PositionOfSignBit
+{
+  static_assert(IsIntegral<IntegerType>::value,
+                "PositionOfSignBit is only for integral types");
+
+  static const size_t value = 8 * sizeof(IntegerType) - 1;
+};
+
+
+
+
+
+
+template<typename IntegerType>
+struct MinValue
+{
+private:
+  static_assert(IsIntegral<IntegerType>::value,
+                "MinValue is only for integral types");
+
+  typedef typename MakeUnsigned<IntegerType>::Type UnsignedIntegerType;
+  static const size_t PosOfSignBit = PositionOfSignBit<IntegerType>::value;
+
+public:
+
+
+
+
+
+
+  static const IntegerType value =
+      IsSigned<IntegerType>::value
+      ? IntegerType(UnsignedIntegerType(1) << PosOfSignBit)
+      : IntegerType(0);
+};
+
+
+
+
+
+
+template<typename IntegerType>
+struct MaxValue
+{
+  static_assert(IsIntegral<IntegerType>::value,
+                "MaxValue is only for integral types");
+
+
+
+
+  static const IntegerType value = ~MinValue<IntegerType>::value;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2
+
+namespace mozilla {
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
+template<typename E>
+class CastableTypedEnumResult
+{
+private:
+  const E mValue;
+
+public:
+  explicit constexpr CastableTypedEnumResult(E aValue)
+    : mValue(aValue)
+  {}
+
+  constexpr operator E() const { return mValue; }
+
+  template<typename DestinationType>
+  explicit constexpr
+  operator DestinationType() const { return DestinationType(mValue); }
+
+  constexpr bool operator !() const { return !bool(mValue); }
+};
+# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
+template<typename E> constexpr CastableTypedEnumResult<E> operator |(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE | E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator |(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) | aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator |(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) | E(aR2)); }
+template<typename E> constexpr CastableTypedEnumResult<E> operator &(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE & E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator &(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) & aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator &(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) & E(aR2)); }
+template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE ^ E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) ^ aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) ^ E(aR2)); }
+template<typename E> constexpr bool operator ==(const E& aE, const CastableTypedEnumResult<E>& aR) { return bool(aE == E(aR)); } template<typename E> constexpr bool operator ==(const CastableTypedEnumResult<E>& aR, const E& aE) { return bool(E(aR) == aE); } template<typename E> constexpr bool operator ==(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return bool(E(aR1) == E(aR2)); }
+template<typename E> constexpr bool operator !=(const E& aE, const CastableTypedEnumResult<E>& aR) { return bool(aE != E(aR)); } template<typename E> constexpr bool operator !=(const CastableTypedEnumResult<E>& aR, const E& aE) { return bool(E(aR) != aE); } template<typename E> constexpr bool operator !=(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return bool(E(aR1) != E(aR2)); }
+
+template <typename E>
+constexpr CastableTypedEnumResult<E>
+operator ~(const CastableTypedEnumResult<E>& aR)
+{
+  return CastableTypedEnumResult<E>(~(E(aR)));
+}
+# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
+template<typename E> E& operator &=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 &= E(aR2); }
+template<typename E> E& operator |=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 |= E(aR2); }
+template<typename E> E& operator ^=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 ^= E(aR2); }
+
+
+
+
+
+namespace detail {
+template<typename E>
+struct UnsignedIntegerTypeForEnum
+  : UnsignedStdintTypeForSize<sizeof(E)>
+{};
+}
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 2
+
+
+
+
+
+
+struct ServoNodeData;
+namespace mozilla {
+
+
+
+
+
+template<typename T>
+struct ServoUnsafeCell {
+  T value;
+
+
+  ServoUnsafeCell() : value() {};
+};
+
+template<typename T>
+struct ServoCell {
+  ServoUnsafeCell<T> value;
+  T Get() const { return value.value; }
+  void Set(T arg) { value.value = arg; }
+  ServoCell() : value() {};
+};
+
+
+
+
+enum class LazyComputeBehavior {
+  Allow,
+  Assert,
+};
+
+
+
+
+enum class TraversalRootBehavior {
+  Normal,
+  UnstyledChildrenOnly,
+};
+
+
+enum class UpdateAnimationsTasks : uint8_t {
+  CSSAnimations = 1 << 0,
+  CSSTransitions = 1 << 1,
+  EffectProperties = 1 << 2,
+  CascadeResults = 1 << 3,
+};
+
+inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator |(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) | U(b))); } inline UpdateAnimationsTasks& operator |=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator &(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) & U(b))); } inline UpdateAnimationsTasks& operator &=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator ^(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) ^ U(b))); } inline UpdateAnimationsTasks& operator ^=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator~(UpdateAnimationsTasks a) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(~(U(a)))); }
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Likely.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroArgs.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticAnalysisFunctions.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 1
+
+
+
+
+
+
+
+
+# 1 "/usr/include/stdio.h" 1 3 4
+# 29 "/usr/include/stdio.h" 3 4
+extern "C" {
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 34 "/usr/include/stdio.h" 2 3 4
+
+# 1 "/usr/include/bits/types.h" 1 3 4
+# 27 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 28 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+
+
+
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+# 121 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/typesizes.h" 1 3 4
+# 122 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+
+typedef int __daddr_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef long int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+
+typedef long int __fsword_t;
+
+typedef long int __ssize_t;
+
+
+typedef long int __syscall_slong_t;
+
+typedef unsigned long int __syscall_ulong_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef __quad_t *__qaddr_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+# 36 "/usr/include/stdio.h" 2 3 4
+# 74 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/libio.h" 1 3 4
+# 31 "/usr/include/libio.h" 3 4
+# 1 "/usr/include/_G_config.h" 1 3 4
+# 15 "/usr/include/_G_config.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 16 "/usr/include/_G_config.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 21 "/usr/include/_G_config.h" 2 3 4
+typedef struct
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} _G_fpos_t;
+typedef struct
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} _G_fpos64_t;
+# 32 "/usr/include/libio.h" 2 3 4
+# 144 "/usr/include/libio.h" 3 4
+struct _IO_jump_t; struct _IO_FILE;
+
+
+
+
+
+typedef void _IO_lock_t;
+
+
+
+
+
+struct _IO_marker {
+  struct _IO_marker *_next;
+  struct _IO_FILE *_sbuf;
+
+
+
+  int _pos;
+# 173 "/usr/include/libio.h" 3 4
+};
+
+
+enum __codecvt_result
+{
+  __codecvt_ok,
+  __codecvt_partial,
+  __codecvt_error,
+  __codecvt_noconv
+};
+# 241 "/usr/include/libio.h" 3 4
+struct _IO_FILE {
+  int _flags;
+
+
+
+
+  char* _IO_read_ptr;
+  char* _IO_read_end;
+  char* _IO_read_base;
+  char* _IO_write_base;
+  char* _IO_write_ptr;
+  char* _IO_write_end;
+  char* _IO_buf_base;
+  char* _IO_buf_end;
+
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+
+  struct _IO_marker *_markers;
+
+  struct _IO_FILE *_chain;
+
+  int _fileno;
+
+
+
+  int _flags2;
+
+  __off_t _old_offset;
+
+
+
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+
+
+
+  _IO_lock_t *_lock;
+# 289 "/usr/include/libio.h" 3 4
+  __off64_t _offset;
+
+
+
+
+
+
+
+  void *__pad1;
+  void *__pad2;
+  void *__pad3;
+  void *__pad4;
+
+  size_t __pad5;
+  int _mode;
+
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+
+};
+
+
+
+
+
+struct _IO_FILE_plus;
+
+extern struct _IO_FILE_plus _IO_2_1_stdin_;
+extern struct _IO_FILE_plus _IO_2_1_stdout_;
+extern struct _IO_FILE_plus _IO_2_1_stderr_;
+# 333 "/usr/include/libio.h" 3 4
+typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
+
+
+
+
+
+
+
+typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
+     size_t __n);
+
+
+
+
+
+
+
+typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
+
+
+typedef int __io_close_fn (void *__cookie);
+
+
+
+
+typedef __io_read_fn cookie_read_function_t;
+typedef __io_write_fn cookie_write_function_t;
+typedef __io_seek_fn cookie_seek_function_t;
+typedef __io_close_fn cookie_close_function_t;
+
+
+typedef struct
+{
+  __io_read_fn *read;
+  __io_write_fn *write;
+  __io_seek_fn *seek;
+  __io_close_fn *close;
+} _IO_cookie_io_functions_t;
+typedef _IO_cookie_io_functions_t cookie_io_functions_t;
+
+struct _IO_cookie_file;
+
+
+extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
+        void *__cookie, _IO_cookie_io_functions_t __fns);
+
+
+
+
+extern "C" {
+
+
+extern int __underflow (_IO_FILE *);
+extern int __uflow (_IO_FILE *);
+extern int __overflow (_IO_FILE *, int);
+# 429 "/usr/include/libio.h" 3 4
+extern int _IO_getc (_IO_FILE *__fp);
+extern int _IO_putc (int __c, _IO_FILE *__fp);
+extern int _IO_feof (_IO_FILE *__fp) throw ();
+extern int _IO_ferror (_IO_FILE *__fp) throw ();
+
+extern int _IO_peekc_locked (_IO_FILE *__fp);
+
+
+
+
+
+extern void _IO_flockfile (_IO_FILE *) throw ();
+extern void _IO_funlockfile (_IO_FILE *) throw ();
+extern int _IO_ftrylockfile (_IO_FILE *) throw ();
+# 459 "/usr/include/libio.h" 3 4
+extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
+   __gnuc_va_list, int *__restrict);
+extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
+    __gnuc_va_list);
+extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
+extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
+
+extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
+extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
+
+extern void _IO_free_backup_area (_IO_FILE *) throw ();
+# 521 "/usr/include/libio.h" 3 4
+}
+# 75 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+typedef __gnuc_va_list va_list;
+# 90 "/usr/include/stdio.h" 3 4
+typedef __off_t off_t;
+
+
+
+
+
+
+typedef __off64_t off64_t;
+
+
+
+
+
+
+typedef __ssize_t ssize_t;
+
+
+
+
+
+
+
+typedef _G_fpos_t fpos_t;
+
+
+
+
+
+typedef _G_fpos64_t fpos64_t;
+# 166 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 167 "/usr/include/stdio.h" 2 3 4
+
+
+
+extern struct _IO_FILE *stdin;
+extern struct _IO_FILE *stdout;
+extern struct _IO_FILE *stderr;
+
+
+
+
+
+
+
+extern int remove (const char *__filename) throw ();
+
+extern int rename (const char *__old, const char *__new) throw ();
+
+
+
+
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) throw ();
+# 197 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile (void) ;
+# 207 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile64 (void) ;
+
+
+
+extern char *tmpnam (char *__s) throw () ;
+
+
+
+
+
+extern char *tmpnam_r (char *__s) throw () ;
+# 229 "/usr/include/stdio.h" 3 4
+extern char *tempnam (const char *__dir, const char *__pfx)
+     throw () __attribute__ ((__malloc__)) ;
+# 239 "/usr/include/stdio.h" 3 4
+extern int fclose (FILE *__stream);
+
+
+
+
+extern int fflush (FILE *__stream);
+# 254 "/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 264 "/usr/include/stdio.h" 3 4
+extern int fcloseall (void);
+# 274 "/usr/include/stdio.h" 3 4
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes) ;
+
+
+
+
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+# 299 "/usr/include/stdio.h" 3 4
+extern FILE *fopen64 (const char *__restrict __filename,
+        const char *__restrict __modes) ;
+extern FILE *freopen64 (const char *__restrict __filename,
+   const char *__restrict __modes,
+   FILE *__restrict __stream) ;
+
+
+
+
+extern FILE *fdopen (int __fd, const char *__modes) throw () ;
+
+
+
+
+
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     const char *__restrict __modes,
+     _IO_cookie_io_functions_t __io_funcs) throw () ;
+
+
+
+
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  throw () ;
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
+
+
+
+
+
+
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+
+
+extern void setlinebuf (FILE *__stream) throw ();
+# 358 "/usr/include/stdio.h" 3 4
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+
+
+
+
+extern int printf (const char *__restrict __format, ...);
+
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) throw ();
+
+
+
+
+
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+
+
+
+
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+
+
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+
+
+
+
+extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
+extern int __asprintf (char **__restrict __ptr,
+         const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int asprintf (char **__restrict __ptr,
+       const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+
+
+
+
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+# 427 "/usr/include/stdio.h" 3 4
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+
+
+
+
+extern int scanf (const char *__restrict __format, ...) ;
+
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) throw ();
+# 473 "/usr/include/stdio.h" 3 4
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+
+
+
+
+
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+
+
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 533 "/usr/include/stdio.h" 3 4
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+# 552 "/usr/include/stdio.h" 3 4
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 563 "/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+# 575 "/usr/include/stdio.h" 3 4
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+# 596 "/usr/include/stdio.h" 3 4
+extern int fputc_unlocked (int __c, FILE *__stream);
+
+
+
+
+
+
+
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+
+
+
+
+
+
+extern int getw (FILE *__stream);
+
+
+extern int putw (int __w, FILE *__stream);
+# 624 "/usr/include/stdio.h" 3 4
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+          ;
+# 651 "/usr/include/stdio.h" 3 4
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream) ;
+# 667 "/usr/include/stdio.h" 3 4
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+          size_t *__restrict __n, int __delimiter,
+          FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+        size_t *__restrict __n, int __delimiter,
+        FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern __ssize_t getline (char **__restrict __lineptr,
+       size_t *__restrict __n,
+       FILE *__restrict __stream) ;
+# 691 "/usr/include/stdio.h" 3 4
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+
+
+
+
+
+extern int puts (const char *__s);
+
+
+
+
+
+
+extern int ungetc (int __c, FILE *__stream);
+
+
+
+
+
+
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+
+
+
+
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+# 728 "/usr/include/stdio.h" 3 4
+extern int fputs_unlocked (const char *__restrict __s,
+      FILE *__restrict __stream);
+# 739 "/usr/include/stdio.h" 3 4
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+# 751 "/usr/include/stdio.h" 3 4
+extern int fseek (FILE *__stream, long int __off, int __whence);
+
+
+
+
+extern long int ftell (FILE *__stream) ;
+
+
+
+
+extern void rewind (FILE *__stream);
+# 775 "/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) ;
+# 800 "/usr/include/stdio.h" 3 4
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+
+
+
+
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+# 820 "/usr/include/stdio.h" 3 4
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+extern __off64_t ftello64 (FILE *__stream) ;
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
+extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
+
+
+
+
+extern void clearerr (FILE *__stream) throw ();
+
+extern int feof (FILE *__stream) throw () ;
+
+extern int ferror (FILE *__stream) throw () ;
+
+
+
+
+extern void clearerr_unlocked (FILE *__stream) throw ();
+extern int feof_unlocked (FILE *__stream) throw () ;
+extern int ferror_unlocked (FILE *__stream) throw () ;
+# 848 "/usr/include/stdio.h" 3 4
+extern void perror (const char *__s);
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
+# 26 "/usr/include/bits/sys_errlist.h" 3 4
+extern int sys_nerr;
+extern const char *const sys_errlist[];
+
+
+extern int _sys_nerr;
+extern const char *const _sys_errlist[];
+# 856 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+extern int fileno (FILE *__stream) throw () ;
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) throw () ;
+# 874 "/usr/include/stdio.h" 3 4
+extern FILE *popen (const char *__command, const char *__modes) ;
+
+
+
+
+
+extern int pclose (FILE *__stream);
+
+
+
+
+
+extern char *ctermid (char *__s) throw ();
+
+
+
+
+
+extern char *cuserid (char *__s);
+
+
+
+
+struct obstack;
+
+
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       const char *__restrict __format,
+       __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
+
+
+
+
+
+
+
+extern void flockfile (FILE *__stream) throw ();
+
+
+
+extern int ftrylockfile (FILE *__stream) throw () ;
+
+
+extern void funlockfile (FILE *__stream) throw ();
+# 944 "/usr/include/stdio.h" 3 4
+}
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcom-config.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
+
+#pragma GCC visibility push(default)
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 3
+# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
+
+extern "C++" {
+
+namespace std
+{
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
+  class exception
+  {
+  public:
+    exception() noexcept { }
+    virtual ~exception() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+
+
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() noexcept { }
+
+
+
+    virtual ~bad_exception() noexcept;
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+
+  typedef void (*terminate_handler) ();
+
+
+  typedef void (*unexpected_handler) ();
+
+
+  terminate_handler set_terminate(terminate_handler) noexcept;
+
+
+
+  terminate_handler get_terminate() noexcept;
+
+
+
+
+  void terminate() noexcept __attribute__ ((__noreturn__));
+
+
+  unexpected_handler set_unexpected(unexpected_handler) noexcept;
+
+
+
+  unexpected_handler get_unexpected() noexcept;
+
+
+
+
+  void unexpected() __attribute__ ((__noreturn__));
+# 129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
+  bool uncaught_exception() noexcept __attribute__ ((__pure__));
+# 138 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
+}
+
+namespace __gnu_cxx
+{
+# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
+  void __verbose_terminate_handler();
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
+#pragma GCC visibility push(default)
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_defines.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 2 3
+
+
+
+
+
+extern "C++" {
+
+namespace std
+{
+  class type_info;
+
+
+
+
+
+  namespace __exception_ptr
+  {
+    class exception_ptr;
+  }
+
+  using __exception_ptr::exception_ptr;
+
+
+
+
+
+  exception_ptr current_exception() noexcept;
+
+
+  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
+
+  namespace __exception_ptr
+  {
+    using std::rethrow_exception;
+
+
+
+
+
+    class exception_ptr
+    {
+      void* _M_exception_object;
+
+      explicit exception_ptr(void* __e) noexcept;
+
+      void _M_addref() noexcept;
+      void _M_release() noexcept;
+
+      void *_M_get() const noexcept __attribute__ ((__pure__));
+
+      friend exception_ptr std::current_exception() noexcept;
+      friend void std::rethrow_exception(exception_ptr);
+
+    public:
+      exception_ptr() noexcept;
+
+      exception_ptr(const exception_ptr&) noexcept;
+
+
+      exception_ptr(nullptr_t) noexcept
+      : _M_exception_object(0)
+      { }
+
+      exception_ptr(exception_ptr&& __o) noexcept
+      : _M_exception_object(__o._M_exception_object)
+      { __o._M_exception_object = 0; }
+# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
+      exception_ptr&
+      operator=(const exception_ptr&) noexcept;
+
+
+      exception_ptr&
+      operator=(exception_ptr&& __o) noexcept
+      {
+        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
+        return *this;
+      }
+
+
+      ~exception_ptr() noexcept;
+
+      void
+      swap(exception_ptr&) noexcept;
+# 140 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
+      explicit operator bool() const
+      { return _M_exception_object; }
+
+
+      friend bool
+      operator==(const exception_ptr&, const exception_ptr&)
+ noexcept __attribute__ ((__pure__));
+
+      const class std::type_info*
+      __cxa_exception_type() const noexcept
+ __attribute__ ((__pure__));
+    };
+
+    bool
+    operator==(const exception_ptr&, const exception_ptr&)
+      noexcept __attribute__ ((__pure__));
+
+    bool
+    operator!=(const exception_ptr&, const exception_ptr&)
+      noexcept __attribute__ ((__pure__));
+
+    inline void
+    swap(exception_ptr& __lhs, exception_ptr& __rhs)
+    { __lhs.swap(__rhs); }
+
+  }
+
+
+
+  template<typename _Ex>
+    exception_ptr
+    make_exception_ptr(_Ex __ex) noexcept
+    {
+
+      try
+ {
+   throw __ex;
+ }
+      catch(...)
+ {
+   return current_exception();
+ }
+
+
+
+    }
+
+
+
+
+
+  template<typename _Ex>
+    exception_ptr
+    copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));
+
+  template<typename _Ex>
+    exception_ptr
+    copy_exception(_Ex __ex) noexcept
+    { return std::make_exception_ptr<_Ex>(__ex); }
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 3
+#pragma GCC visibility push(default)
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline _Tp*
+    __addressof(_Tp& __r) noexcept
+    {
+      return reinterpret_cast<_Tp*>
+ (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
+    }
+
+
+}
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+namespace std
+{
+  typedef unsigned short uint_least16_t;
+  typedef unsigned int uint_least32_t;
+}
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static constexpr _Tp value = __v;
+      typedef _Tp value_type;
+      typedef integral_constant<_Tp, __v> type;
+      constexpr operator value_type() const { return value; }
+
+
+
+
+      constexpr value_type operator()() const { return value; }
+
+    };
+
+  template<typename _Tp, _Tp __v>
+    constexpr _Tp integral_constant<_Tp, __v>::value;
+
+
+  typedef integral_constant<bool, true> true_type;
+
+
+  typedef integral_constant<bool, false> false_type;
+
+  template<bool __v>
+    using __bool_constant = integral_constant<bool, __v>;
+# 103 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<bool, typename, typename>
+    struct conditional;
+
+  template<typename...>
+    struct __or_;
+
+  template<>
+    struct __or_<>
+    : public false_type
+    { };
+
+  template<typename _B1>
+    struct __or_<_B1>
+    : public _B1
+    { };
+
+  template<typename _B1, typename _B2>
+    struct __or_<_B1, _B2>
+    : public conditional<_B1::value, _B1, _B2>::type
+    { };
+
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __or_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
+    { };
+
+  template<typename...>
+    struct __and_;
+
+  template<>
+    struct __and_<>
+    : public true_type
+    { };
+
+  template<typename _B1>
+    struct __and_<_B1>
+    : public _B1
+    { };
+
+  template<typename _B1, typename _B2>
+    struct __and_<_B1, _B2>
+    : public conditional<_B1::value, _B2, _B1>::type
+    { };
+
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __and_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
+    { };
+
+  template<typename _Pp>
+    struct __not_
+    : public integral_constant<bool, !_Pp::value>
+    { };
+
+  struct __nonesuch {
+    __nonesuch() = delete;
+    ~__nonesuch() = delete;
+    __nonesuch(__nonesuch const&) = delete;
+    void operator=(__nonesuch const&) = delete;
+  };
+# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+
+  struct __failure_type
+  { };
+
+
+
+  template<typename>
+    struct remove_cv;
+
+  template<typename>
+    struct __is_void_helper
+    : public false_type { };
+
+  template<>
+    struct __is_void_helper<void>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_void
+    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_integral_helper
+    : public false_type { };
+
+  template<>
+    struct __is_integral_helper<bool>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<signed char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned char>
+    : public true_type { };
+
+
+  template<>
+    struct __is_integral_helper<wchar_t>
+    : public true_type { };
+
+
+  template<>
+    struct __is_integral_helper<char16_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<char32_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long long>
+    : public true_type { };
+# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_floating_point_helper
+    : public false_type { };
+
+  template<>
+    struct __is_floating_point_helper<float>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<double>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<long double>
+    : public true_type { };
+# 349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  template<typename>
+    struct is_array
+    : public false_type { };
+
+  template<typename _Tp, std::size_t _Size>
+    struct is_array<_Tp[_Size]>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_array<_Tp[]>
+    : public true_type { };
+
+  template<typename>
+    struct __is_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_pointer_helper<_Tp*>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_pointer
+    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  template<typename>
+    struct is_lvalue_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_lvalue_reference<_Tp&>
+    : public true_type { };
+
+
+  template<typename>
+    struct is_rvalue_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_rvalue_reference<_Tp&&>
+    : public true_type { };
+
+  template<typename>
+    struct is_function;
+
+  template<typename>
+    struct __is_member_object_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, !is_function<_Tp>::value> { };
+
+
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public __is_member_object_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+
+  template<typename>
+    struct __is_member_function_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_function_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, is_function<_Tp>::value> { };
+
+
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public __is_member_function_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_enum
+    : public integral_constant<bool, __is_enum(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_union
+    : public integral_constant<bool, __is_union(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_class
+    : public integral_constant<bool, __is_class(_Tp)>
+    { };
+
+
+  template<typename>
+    struct is_function
+    : public false_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...)>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......)>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes...) const volatile &&>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile &>
+    : public true_type { };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct is_function<_Res(_ArgTypes......) const volatile &&>
+    : public true_type { };
+
+
+
+  template<typename>
+    struct __is_null_pointer_helper
+    : public false_type { };
+
+  template<>
+    struct __is_null_pointer_helper<std::nullptr_t>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_null_pointer
+    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct is_reference
+    : public __or_<is_lvalue_reference<_Tp>,
+                   is_rvalue_reference<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_arithmetic
+    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_fundamental
+    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
+     is_null_pointer<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_object
+    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
+                          is_void<_Tp>>>::type
+    { };
+
+  template<typename>
+    struct is_member_pointer;
+
+
+  template<typename _Tp>
+    struct is_scalar
+    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
+                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_compound
+    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct __is_member_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_pointer_helper<_Tp _Cp::*>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_member_pointer
+    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+
+  template<typename _Tp>
+    struct __is_referenceable
+    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args...)>
+    : public true_type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args......)>
+    : public true_type
+    { };
+
+
+
+
+  template<typename>
+    struct is_const
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_const<_Tp const>
+    : public true_type { };
+
+
+  template<typename>
+    struct is_volatile
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_volatile<_Tp volatile>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_trivial
+    : public integral_constant<bool, __is_trivial(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copyable
+    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    { };
+
+
+
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_empty
+    : public integral_constant<bool, __is_empty(_Tp)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_polymorphic
+    : public integral_constant<bool, __is_polymorphic(_Tp)>
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct is_final
+    : public integral_constant<bool, __is_final(_Tp)>
+    { };
+
+
+
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+
+  template<typename _Tp,
+    bool = is_arithmetic<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, true>
+    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_signed
+    : public __is_signed_helper<_Tp>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_unsigned
+    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
+    { };
+
+
+
+
+  template<typename>
+    struct add_rvalue_reference;
+
+
+
+
+
+  template<typename _Tp>
+    typename add_rvalue_reference<_Tp>::type declval() noexcept;
+
+  template<typename, unsigned = 0>
+    struct extent;
+
+  template<typename>
+    struct remove_all_extents;
+
+  template<typename _Tp>
+    struct __is_array_known_bounds
+    : public integral_constant<bool, (extent<_Tp>::value > 0)>
+    { };
+
+  template<typename _Tp>
+    struct __is_array_unknown_bounds
+    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
+    { };
+
+
+
+
+
+
+  struct __do_is_destructible_impl
+  {
+    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
+      static true_type __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_destructible_impl
+    : public __do_is_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, false>
+    : public __is_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, true, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, true>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_destructible
+    : public __is_destructible_safe<_Tp>::type
+    { };
+
+
+
+
+
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
+        __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_impl
+    : public __do_is_nt_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_nt_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, false>
+    : public __is_nt_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, true, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, true>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_destructible
+    : public __is_nt_destructible_safe<_Tp>::type
+    { };
+
+  struct __do_is_default_constructible_impl
+  {
+    template<typename _Tp, typename = decltype(_Tp())>
+      static true_type __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_default_constructible_impl
+    : public __do_is_default_constructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_default_constructible_atom
+    : public __and_<__not_<is_void<_Tp>>,
+                    __is_default_constructible_impl<_Tp>>
+    { };
+
+  template<typename _Tp, bool = is_array<_Tp>::value>
+    struct __is_default_constructible_safe;
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __is_default_constructible_safe<_Tp, true>
+    : public __and_<__is_array_known_bounds<_Tp>,
+      __is_default_constructible_atom<typename
+                      remove_all_extents<_Tp>::type>>
+    { };
+
+  template<typename _Tp>
+    struct __is_default_constructible_safe<_Tp, false>
+    : public __is_default_constructible_atom<_Tp>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_default_constructible
+    : public __is_default_constructible_safe<_Tp>::type
+    { };
+# 933 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  struct __do_is_static_castable_impl
+  {
+    template<typename _From, typename _To, typename
+             = decltype(static_cast<_To>(declval<_From>()))>
+      static true_type __test(int);
+
+    template<typename, typename>
+      static false_type __test(...);
+  };
+
+  template<typename _From, typename _To>
+    struct __is_static_castable_impl
+    : public __do_is_static_castable_impl
+    {
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_static_castable_safe
+    : public __is_static_castable_impl<_From, _To>::type
+    { };
+
+
+  template<typename _From, typename _To>
+    struct __is_static_castable
+    : public integral_constant<bool, (__is_static_castable_safe<
+          _From, _To>::value)>
+    { };
+
+
+
+
+
+
+  struct __do_is_direct_constructible_impl
+  {
+    template<typename _Tp, typename _Arg, typename
+      = decltype(::new _Tp(declval<_Arg>()))>
+      static true_type __test(int);
+
+    template<typename, typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_impl
+    : public __do_is_direct_constructible_impl
+    {
+      typedef decltype(__test<_Tp, _Arg>(0)) type;
+    };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new_safe
+    : public __and_<is_destructible<_Tp>,
+                    __is_direct_constructible_impl<_Tp, _Arg>>
+    { };
+
+  template<typename, typename>
+    struct is_same;
+
+  template<typename, typename>
+    struct is_base_of;
+
+  template<typename>
+    struct remove_reference;
+
+  template<typename _From, typename _To, bool
+           = __not_<__or_<is_void<_From>,
+                          is_function<_From>>>::value>
+    struct __is_base_to_derived_ref;
+
+  template<typename _Tp, typename... _Args>
+    struct is_constructible;
+
+
+
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<_From
+        >::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<_To
+        >::type>::type __dst_t;
+      typedef __and_<__not_<is_same<__src_t, __dst_t>>,
+       is_base_of<__src_t, __dst_t>,
+       __not_<is_constructible<__dst_t, _From>>> type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, false>
+    : public false_type
+    { };
+
+  template<typename _From, typename _To, bool
+           = __and_<is_lvalue_reference<_From>,
+                    is_rvalue_reference<_To>>::value>
+    struct __is_lvalue_to_rvalue_ref;
+
+
+
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _From>::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<
+        _To>::type>::type __dst_t;
+      typedef __and_<__not_<is_function<__src_t>>,
+        __or_<is_same<__src_t, __dst_t>,
+      is_base_of<__dst_t, __src_t>>> type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
+    : public false_type
+    { };
+
+
+
+
+
+
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_ref_cast
+    : public __and_<__is_static_castable<_Arg, _Tp>,
+                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
+                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
+                   >>>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new
+    : public conditional<is_reference<_Tp>::value,
+    __is_direct_constructible_ref_cast<_Tp, _Arg>,
+    __is_direct_constructible_new_safe<_Tp, _Arg>
+    >::type
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible
+    : public __is_direct_constructible_new<_Tp, _Arg>::type
+    { };
+
+
+
+
+
+
+  struct __do_is_nary_constructible_impl
+  {
+    template<typename _Tp, typename... _Args, typename
+             = decltype(_Tp(declval<_Args>()...))>
+      static true_type __test(int);
+
+    template<typename, typename...>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nary_constructible_impl
+    : public __do_is_nary_constructible_impl
+    {
+      typedef decltype(__test<_Tp, _Args...>(0)) type;
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nary_constructible
+    : public __is_nary_constructible_impl<_Tp, _Args...>::type
+    {
+      static_assert(sizeof...(_Args) > 1,
+                    "Only useful for > 1 arguments");
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_constructible_impl
+    : public __is_nary_constructible<_Tp, _Args...>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_constructible_impl<_Tp, _Arg>
+    : public __is_direct_constructible<_Tp, _Arg>
+    { };
+
+  template<typename _Tp>
+    struct __is_constructible_impl<_Tp>
+    : public is_default_constructible<_Tp>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+    : public __is_constructible_impl<_Tp, _Args...>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_constructible
+    : public __is_move_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_atom
+    : public integral_constant<bool, noexcept(_Tp())>
+    { };
+
+  template<typename _Tp, bool = is_array<_Tp>::value>
+    struct __is_nt_default_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_impl<_Tp, true>
+    : public __and_<__is_array_known_bounds<_Tp>,
+      __is_nt_default_constructible_atom<typename
+                      remove_all_extents<_Tp>::type>>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_default_constructible_impl<_Tp, false>
+    : public __is_nt_default_constructible_atom<_Tp>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_default_constructible
+    : public __and_<is_default_constructible<_Tp>,
+                    __is_nt_default_constructible_impl<_Tp>>
+    { };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl
+    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_nt_constructible_impl<_Tp, _Arg>
+    : public integral_constant<bool,
+                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_constructible_impl<_Tp>
+    : public is_nothrow_default_constructible<_Tp>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_nothrow_constructible
+    : public __and_<is_constructible<_Tp, _Args...>,
+      __is_nt_constructible_impl<_Tp, _Args...>>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_constructible
+    : public __is_nothrow_copy_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_constructible
+    : public __is_nothrow_move_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, typename _Up>
+    class __is_assignable_helper
+    {
+      template<typename _Tp1, typename _Up1,
+        typename = decltype(declval<_Tp1>() = declval<_Up1>())>
+ static true_type
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+      : public __is_assignable_helper<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_assignable
+    : public __is_move_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, typename _Up>
+    struct __is_nt_assignable_impl
+    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_assignable
+    : public __and_<is_assignable<_Tp, _Up>,
+      __is_nt_assignable_impl<_Tp, _Up>>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_assignable
+    : public __is_nt_copy_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_trivially_constructible
+    : public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Args...)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_default_constructible
+    : public is_trivially_constructible<_Tp>::type
+    { };
+
+  struct __do_is_implicitly_default_constructible_impl
+  {
+    template <typename _Tp>
+    static void __helper(const _Tp&);
+
+    template <typename _Tp>
+    static true_type __test(const _Tp&,
+                            decltype(__helper<const _Tp&>({}))* = 0);
+
+    static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_impl
+      : public __do_is_implicitly_default_constructible_impl
+  {
+    typedef decltype(__test(declval<_Tp>())) type;
+  };
+
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_safe
+      : public __is_implicitly_default_constructible_impl<_Tp>::type
+  { };
+
+  template <typename _Tp>
+    struct __is_implicitly_default_constructible
+      : public __and_<is_default_constructible<_Tp>,
+                      __is_implicitly_default_constructible_safe<_Tp>>
+  { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_constructible
+    : public __and_<is_copy_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, const _Tp&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_constructible
+    : public __and_<is_move_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Tp&&)>>
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_trivially_assignable
+    : public __and_<is_assignable<_Tp, _Up>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp, _Up)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_assignable
+    : public __and_<is_copy_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, const _Tp&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_assignable
+    : public __and_<is_move_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, _Tp&&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<is_destructible<_Tp>, integral_constant<bool,
+         __has_trivial_destructor(_Tp)>>
+    { };
+
+
+  template<typename _Tp>
+    struct has_trivial_default_constructor
+    : public integral_constant<bool, __has_trivial_constructor(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  template<typename _Tp>
+    struct has_trivial_copy_constructor
+    : public integral_constant<bool, __has_trivial_copy(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  template<typename _Tp>
+    struct has_trivial_copy_assign
+    : public integral_constant<bool, __has_trivial_assign(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+
+
+
+
+
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+
+
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+
+  template<typename, unsigned _Uint>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+          _Uint == 0 ? _Size : extent<_Tp,
+          _Uint - 1>::value>
+    { };
+
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+          _Uint == 0 ? 0 : extent<_Tp,
+             _Uint - 1>::value>
+    { };
+
+
+
+
+
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
+
+
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
+    { };
+
+  template<typename _From, typename _To,
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
+    struct __is_convertible_helper
+    { typedef typename is_void<_To>::type type; };
+
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+       template<typename _To1>
+ static void __test_aux(_To1);
+
+      template<typename _From1, typename _To1,
+        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
+ static true_type
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+
+
+
+
+
+  template<typename _Tp>
+    struct remove_const
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp type; };
+
+
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp type; };
+
+
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type type;
+    };
+
+
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const type; };
+
+
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile type; };
+
+
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type type;
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    using remove_const_t = typename remove_const<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_cv_t = typename remove_cv<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_const_t = typename add_const<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_volatile_t = typename add_volatile<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_cv_t = typename add_cv<_Tp>::type;
+
+
+
+
+
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp type; };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_lvalue_reference_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct __add_lvalue_reference_helper<_Tp, true>
+    { typedef _Tp& type; };
+
+
+  template<typename _Tp>
+    struct add_lvalue_reference
+    : public __add_lvalue_reference_helper<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_rvalue_reference_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct __add_rvalue_reference_helper<_Tp, true>
+    { typedef _Tp&& type; };
+
+
+  template<typename _Tp>
+    struct add_rvalue_reference
+    : public __add_rvalue_reference_helper<_Tp>
+    { };
+
+
+
+  template<typename _Tp>
+    using remove_reference_t = typename remove_reference<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
+
+
+
+
+
+  template<typename _Unqualified, bool _IsConst, bool _IsVol>
+    struct __cv_selector;
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, false>
+    { typedef _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, true>
+    { typedef volatile _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, false>
+    { typedef const _Unqualified __type; };
+
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, true>
+    { typedef const volatile _Unqualified __type; };
+
+  template<typename _Qualified, typename _Unqualified,
+    bool _IsConst = is_const<_Qualified>::value,
+    bool _IsVol = is_volatile<_Qualified>::value>
+    class __match_cv_qualifiers
+    {
+      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
+
+    public:
+      typedef typename __match::__type __type;
+    };
+
+
+  template<typename _Tp>
+    struct __make_unsigned
+    { typedef _Tp __type; };
+
+  template<>
+    struct __make_unsigned<char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __make_unsigned<signed char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __make_unsigned<short>
+    { typedef unsigned short __type; };
+
+  template<>
+    struct __make_unsigned<int>
+    { typedef unsigned int __type; };
+
+  template<>
+    struct __make_unsigned<long>
+    { typedef unsigned long __type; };
+
+  template<>
+    struct __make_unsigned<long long>
+    { typedef unsigned long long __type; };
+
+
+  template<>
+    struct __make_unsigned<wchar_t> : __make_unsigned<int>
+    { };
+# 1785 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_unsigned_selector;
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, true, false>
+    {
+      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
+      typedef typename __unsignedt::__type __unsigned_type;
+      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
+
+    public:
+      typedef typename __cv_unsigned::__type __type;
+    };
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, false, true>
+    {
+
+      typedef unsigned char __smallest;
+      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
+      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
+      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
+      static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
+      typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
+      typedef typename __cond3::type __cond3_type;
+      typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
+      typedef typename __cond2::type __cond2_type;
+      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
+      typedef typename __cond1::type __cond1_type;
+
+      typedef typename conditional<__b0, __smallest, __cond1_type>::type
+ __unsigned_type;
+      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
+
+    public:
+      typedef typename __cv_unsigned::__type __type;
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct make_unsigned
+    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
+
+
+  template<>
+    struct make_unsigned<bool>;
+
+
+
+  template<typename _Tp>
+    struct __make_signed
+    { typedef _Tp __type; };
+
+  template<>
+    struct __make_signed<char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __make_signed<unsigned char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __make_signed<unsigned short>
+    { typedef signed short __type; };
+
+  template<>
+    struct __make_signed<unsigned int>
+    { typedef signed int __type; };
+
+  template<>
+    struct __make_signed<unsigned long>
+    { typedef signed long __type; };
+
+  template<>
+    struct __make_signed<unsigned long long>
+    { typedef signed long long __type; };
+# 1874 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<>
+    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
+    { };
+  template<>
+    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
+    { };
+# 1904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_signed_selector;
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, true, false>
+    {
+      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
+      typedef typename __signedt::__type __signed_type;
+      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
+
+    public:
+      typedef typename __cv_signed::__type __type;
+    };
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, false, true>
+    {
+      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
+
+    public:
+      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct make_signed
+    { typedef typename __make_signed_selector<_Tp>::__type type; };
+
+
+  template<>
+    struct make_signed<bool>;
+
+
+
+  template<typename _Tp>
+    using make_signed_t = typename make_signed<_Tp>::type;
+
+
+  template<typename _Tp>
+    using make_unsigned_t = typename make_unsigned<_Tp>::type;
+
+
+
+
+
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp type; };
+
+
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type type; };
+
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type type; };
+
+
+
+  template<typename _Tp>
+    using remove_extent_t = typename remove_extent<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
+
+
+
+
+  template<typename _Tp, typename>
+    struct __remove_pointer_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp, typename _Up>
+    struct __remove_pointer_helper<_Tp, _Up*>
+    { typedef _Up type; };
+
+
+  template<typename _Tp>
+    struct remove_pointer
+    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    { };
+
+
+  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
+          is_void<_Tp>>::value>
+    struct __add_pointer_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct __add_pointer_helper<_Tp, true>
+    { typedef typename remove_reference<_Tp>::type* type; };
+
+  template<typename _Tp>
+    struct add_pointer
+    : public __add_pointer_helper<_Tp>
+    { };
+
+
+
+  template<typename _Tp>
+    using remove_pointer_t = typename remove_pointer<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_pointer_t = typename add_pointer<_Tp>::type;
+
+
+  template<std::size_t _Len>
+    struct __aligned_storage_msa
+    {
+      union __type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__)) { } __align;
+      };
+    };
+# 2050 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<std::size_t _Len, std::size_t _Align =
+    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    struct aligned_storage
+    {
+      union type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__((_Align)))) { } __align;
+      };
+    };
+
+  template <typename... _Types>
+    struct __strictest_alignment
+    {
+      static const size_t _S_alignment = 0;
+      static const size_t _S_size = 0;
+    };
+
+  template <typename _Tp, typename... _Types>
+    struct __strictest_alignment<_Tp, _Types...>
+    {
+      static const size_t _S_alignment =
+        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
+ ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
+      static const size_t _S_size =
+        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
+ ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
+    };
+# 2089 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template <size_t _Len, typename... _Types>
+    struct aligned_union
+    {
+    private:
+      static_assert(sizeof...(_Types) != 0, "At least one type is required");
+
+      using __strictest = __strictest_alignment<_Types...>;
+      static const size_t _S_len = _Len > __strictest::_S_size
+ ? _Len : __strictest::_S_size;
+    public:
+
+      static const size_t alignment_value = __strictest::_S_alignment;
+
+      typedef typename aligned_storage<_S_len, alignment_value>::type type;
+    };
+
+  template <size_t _Len, typename... _Types>
+    const size_t aligned_union<_Len, _Types...>::alignment_value;
+
+
+
+  template<typename _Up,
+    bool _IsArray = is_array<_Up>::value,
+    bool _IsFunction = is_function<_Up>::value>
+    struct __decay_selector;
+
+
+  template<typename _Up>
+    struct __decay_selector<_Up, false, false>
+    { typedef typename remove_cv<_Up>::type __type; };
+
+  template<typename _Up>
+    struct __decay_selector<_Up, true, false>
+    { typedef typename remove_extent<_Up>::type* __type; };
+
+  template<typename _Up>
+    struct __decay_selector<_Up, false, true>
+    { typedef typename add_pointer<_Up>::type __type; };
+
+
+  template<typename _Tp>
+    class decay
+    {
+      typedef typename remove_reference<_Tp>::type __remove_type;
+
+    public:
+      typedef typename __decay_selector<__remove_type>::__type type;
+    };
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __decay_and_strip
+    {
+      typedef typename __strip_reference_wrapper<
+ typename decay<_Tp>::type>::__type __type;
+    };
+
+
+
+
+  template<bool, typename _Tp = void>
+    struct enable_if
+    { };
+
+
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+
+  template<typename... _Cond>
+    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
+
+
+
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct conditional
+    { typedef _Iftrue type; };
+
+
+  template<typename _Iftrue, typename _Iffalse>
+    struct conditional<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse type; };
+
+
+  template<typename... _Tp>
+    struct common_type;
+
+
+
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      static __success_type<typename decay<decltype
+       (true ? std::declval<_Tp>()
+        : std::declval<_Up>())>::type> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp, typename _Up>
+    struct __common_type_impl
+    : private __do_common_type_impl
+    {
+      typedef decltype(_S_test<_Tp, _Up>(0)) type;
+    };
+
+  struct __do_member_type_wrapper
+  {
+    template<typename _Tp>
+      static __success_type<typename _Tp::type> _S_test(int);
+
+    template<typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp>
+    struct __member_type_wrapper
+    : private __do_member_type_wrapper
+    {
+      typedef decltype(_S_test<_Tp>(0)) type;
+    };
+
+  template<typename _CTp, typename... _Args>
+    struct __expanded_common_type_wrapper
+    {
+      typedef common_type<typename _CTp::type, _Args...> type;
+    };
+
+  template<typename... _Args>
+    struct __expanded_common_type_wrapper<__failure_type, _Args...>
+    { typedef __failure_type type; };
+
+  template<typename _Tp>
+    struct common_type<_Tp>
+    { typedef typename decay<_Tp>::type type; };
+
+  template<typename _Tp, typename _Up>
+    struct common_type<_Tp, _Up>
+    : public __common_type_impl<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, typename _Up, typename... _Vp>
+    struct common_type<_Tp, _Up, _Vp...>
+    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
+               common_type<_Tp, _Up>>::type, _Vp...>::type
+    { };
+
+
+  template<typename _Tp>
+    struct underlying_type
+    {
+      typedef __underlying_type(_Tp) type;
+    };
+
+  template<typename _Tp>
+    struct __declval_protector
+    {
+      static const bool __stop = false;
+      static typename add_rvalue_reference<_Tp>::type __delegate();
+    };
+
+  template<typename _Tp>
+    inline typename add_rvalue_reference<_Tp>::type
+    declval() noexcept
+    {
+      static_assert(__declval_protector<_Tp>::__stop,
+      "declval() must not be used!");
+      return __declval_protector<_Tp>::__delegate();
+    }
+
+
+  template<typename _Signature>
+    class result_of;
+
+
+
+
+
+  struct __invoke_memfun_ref { };
+  struct __invoke_memfun_deref { };
+  struct __invoke_memobj_ref { };
+  struct __invoke_memobj_deref { };
+  struct __invoke_other { };
+
+
+  template<typename _Tp, typename _Tag>
+    struct __result_of_success : __success_type<_Tp>
+    { using __invoke_type = _Tag; };
+
+
+  struct __result_of_memfun_ref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __result_of_success<decltype(
+      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_ref> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_ref
+    : private __result_of_memfun_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+
+  struct __result_of_memfun_deref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __result_of_success<decltype(
+      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_deref> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_deref
+    : private __result_of_memfun_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+
+  struct __result_of_memobj_ref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __result_of_success<decltype(
+      std::declval<_Tp1>().*std::declval<_Fp>()
+      ), __invoke_memobj_ref> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_ref
+    : private __result_of_memobj_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+
+  struct __result_of_memobj_deref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __result_of_success<decltype(
+      (*std::declval<_Tp1>()).*std::declval<_Fp>()
+      ), __invoke_memobj_deref> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_deref
+    : private __result_of_memobj_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj;
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, _Arg>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memobj_ref<_MemPtr, _Arg>,
+        __result_of_memobj_deref<_MemPtr, _Arg>
+      >::type::type type;
+    };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun;
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+      >::type::type type;
+    };
+
+
+
+
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
+    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&>
+    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&>
+    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&>
+    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&&>
+    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
+    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&,
+         _Args...>
+    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&,
+         _Args...>
+    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&&,
+         _Args...>
+    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&&,
+         _Args...>
+    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
+    { };
+
+  template<bool, bool, typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl
+    {
+      typedef __failure_type type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_impl<true, false, _MemPtr, _Arg>
+    : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
+    { };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+    : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
+    { };
+
+
+  struct __result_of_other_impl
+  {
+    template<typename _Fn, typename... _Args>
+      static __result_of_success<decltype(
+      std::declval<_Fn>()(std::declval<_Args>()...)
+      ), __invoke_other> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
+    : private __result_of_other_impl
+    {
+      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    : public __result_of_impl<
+        is_member_object_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+        is_member_function_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+     _Functor, _ArgTypes...
+      >::type
+    { };
+
+
+
+  template<size_t _Len, size_t _Align =
+     __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+
+  template <size_t _Len, typename... _Types>
+    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+
+
+  template<typename _Tp>
+    using decay_t = typename decay<_Tp>::type;
+
+
+  template<bool _Cond, typename _Tp = void>
+    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
+
+
+  template<typename... _Tp>
+    using common_type_t = typename common_type<_Tp...>::type;
+
+
+  template<typename _Tp>
+    using underlying_type_t = typename underlying_type<_Tp>::type;
+
+
+  template<typename _Tp>
+    using result_of_t = typename result_of<_Tp>::type;
+
+
+  template<typename...> using __void_t = void;
+# 2551 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template<typename _Default, typename _AlwaysVoid,
+    template<typename...> class _Op, typename... _Args>
+    struct __detector
+    {
+      using value_t = false_type;
+      using type = _Default;
+    };
+
+
+  template<typename _Default, template<typename...> class _Op,
+     typename... _Args>
+    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
+    {
+      using value_t = true_type;
+      using type = _Op<_Args...>;
+    };
+
+
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or = __detector<_Default, void, _Op, _Args...>;
+
+
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or_t
+      = typename __detected_or<_Default, _Op, _Args...>::type;
+
+
+  template<template<typename...> class _Default,
+    template<typename...> class _Op, typename... _Args>
+    using __detected_or_t_ =
+      __detected_or_t<_Default<_Args...>, _Op, _Args...>;
+# 2601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
+  template <typename _Tp>
+    struct __is_swappable;
+
+  template <typename _Tp>
+    struct __is_nothrow_swappable;
+
+  template<typename _Tp>
+    inline
+    typename enable_if<__and_<is_move_constructible<_Tp>,
+         is_move_assignable<_Tp>>::value>::type
+    swap(_Tp&, _Tp&)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value);
+
+  template<typename _Tp, size_t _Nm>
+    inline
+    typename enable_if<__is_swappable<_Tp>::value>::type
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value);
+
+  namespace __swappable_details {
+    using std::swap;
+
+    struct __do_is_swappable_impl
+    {
+      template<typename _Tp, typename
+               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
+        static true_type __test(int);
+
+      template<typename>
+        static false_type __test(...);
+    };
+
+    struct __do_is_nothrow_swappable_impl
+    {
+      template<typename _Tp>
+        static __bool_constant<
+          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
+        > __test(int);
+
+      template<typename>
+        static false_type __test(...);
+    };
+
+  }
+
+  template<typename _Tp>
+    struct __is_swappable_impl
+    : public __swappable_details::__do_is_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_nothrow_swappable_impl
+    : public __swappable_details::__do_is_nothrow_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    { };
+
+
+}
+# 58 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Tp&&>(__t); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
+    {
+      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
+      " substituting _Tp is an lvalue reference type");
+      return static_cast<_Tp&&>(__t);
+    }
+
+
+
+
+
+
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+
+
+  template<typename _Tp>
+    struct __move_if_noexcept_cond
+    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
+                    is_copy_constructible<_Tp>>::type { };
+# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+  template<typename _Tp>
+    constexpr typename
+    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
+    move_if_noexcept(_Tp& __x) noexcept
+    { return std::move(__x); }
+# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+  template<typename _Tp>
+    inline _Tp*
+    addressof(_Tp& __r) noexcept
+    { return std::__addressof(__r); }
+
+
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    __exchange(_Tp& __obj, _Up&& __new_val)
+    {
+      _Tp __old_val = std::move(__obj);
+      __obj = std::forward<_Up>(__new_val);
+      return __old_val;
+    }
+
+
+
+}
+# 159 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 174 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
+  template<typename _Tp>
+    inline
+
+    typename enable_if<__and_<is_move_constructible<_Tp>,
+         is_move_assignable<_Tp>>::value>::type
+    swap(_Tp& __a, _Tp& __b)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value)
+
+
+
+
+    {
+
+
+
+      _Tp __tmp = std::move(__a);
+      __a = std::move(__b);
+      __b = std::move(__tmp);
+    }
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline
+
+    typename enable_if<__is_swappable<_Tp>::value>::type
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value)
+
+
+
+
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+    }
+
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 2 3
+
+
+
+
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class nested_exception
+  {
+    exception_ptr _M_ptr;
+
+  public:
+    nested_exception() noexcept : _M_ptr(current_exception()) { }
+
+    nested_exception(const nested_exception&) noexcept = default;
+
+    nested_exception& operator=(const nested_exception&) noexcept = default;
+
+    virtual ~nested_exception() noexcept;
+
+    [[noreturn]]
+    void
+    rethrow_nested() const
+    {
+      if (_M_ptr)
+ rethrow_exception(_M_ptr);
+      std::terminate();
+    }
+
+    exception_ptr
+    nested_ptr() const noexcept
+    { return _M_ptr; }
+  };
+
+  template<typename _Except>
+    struct _Nested_exception : public _Except, public nested_exception
+    {
+      explicit _Nested_exception(const _Except& __ex)
+      : _Except(__ex)
+      { }
+
+      explicit _Nested_exception(_Except&& __ex)
+      : _Except(static_cast<_Except&&>(__ex))
+      { }
+    };
+
+
+
+
+  template<typename _Tp>
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, true_type)
+    {
+      using _Up = typename remove_reference<_Tp>::type;
+      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
+    }
+
+  template<typename _Tp>
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, false_type)
+    { throw std::forward<_Tp>(__t); }
+
+
+
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    throw_with_nested(_Tp&& __t)
+    {
+      using _Up = typename remove_reference<_Tp>::type;
+      using _CopyConstructible
+ = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
+      static_assert(_CopyConstructible::value,
+   "throw_with_nested argument must be CopyConstructible");
+      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
+       __not_<is_base_of<nested_exception, _Up>>>;
+      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
+    }
+
+
+  template<typename _Tp>
+    using __rethrow_if_nested_cond = typename enable_if<
+      __and_<is_polymorphic<_Tp>,
+      __or_<__not_<is_base_of<nested_exception, _Tp>>,
+     is_convertible<_Tp*, nested_exception*>>>::value
+    >::type;
+
+
+  template<typename _Ex>
+    inline __rethrow_if_nested_cond<_Ex>
+    __rethrow_if_nested_impl(const _Ex* __ptr)
+    {
+      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
+ __ne_ptr->rethrow_nested();
+    }
+
+
+  inline void
+  __rethrow_if_nested_impl(const void*)
+  { }
+
+
+  template<typename _Ex>
+    inline void
+    rethrow_if_nested(const _Ex& __ex)
+    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
+
+
+}
+
+}
+
+
+
+#pragma GCC visibility pop
+# 172 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 2 3
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+
+
+
+    virtual ~bad_alloc() throw();
+
+
+    virtual const char* what() const throw();
+  };
+
+
+  class bad_array_new_length : public bad_alloc
+  {
+  public:
+    bad_array_new_length() throw() { };
+
+
+
+    virtual ~bad_array_new_length() throw();
+
+
+    virtual const char* what() const throw();
+  };
+
+
+  struct nothrow_t
+  {
+
+    explicit nothrow_t() = default;
+
+  };
+
+  extern const nothrow_t nothrow;
+
+
+
+  typedef void (*new_handler)();
+
+
+
+  new_handler set_new_handler(new_handler) throw();
+
+
+
+  new_handler get_new_handler() noexcept;
+
+}
+# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
+void* operator new(std::size_t)
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t)
+  __attribute__((__externally_visible__));
+void operator delete(void*) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*) noexcept
+  __attribute__((__externally_visible__));
+
+
+
+
+
+
+void* operator new(std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete(void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
+inline void* operator new(std::size_t, void* __p) noexcept
+{ return __p; }
+inline void* operator new[](std::size_t, void* __p) noexcept
+{ return __p; }
+
+
+inline void operator delete (void*, void*) noexcept { }
+inline void operator delete[](void*, void*) noexcept { }
+
+}
+
+#pragma GCC visibility pop
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+# 75 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+# 1 "/usr/include/stdlib.h" 1 3 4
+# 32 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 33 "/usr/include/stdlib.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/waitflags.h" 1 3 4
+# 42 "/usr/include/stdlib.h" 2 3 4
+# 1 "/usr/include/bits/waitstatus.h" 1 3 4
+# 43 "/usr/include/stdlib.h" 2 3 4
+# 58 "/usr/include/stdlib.h" 3 4
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+
+
+
+
+
+
+
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+# 100 "/usr/include/stdlib.h" 3 4
+extern size_t __ctype_get_mb_cur_max (void) throw () ;
+
+
+
+
+extern double atof (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern int atoi (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern long int atol (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+__extension__ extern long long int atoll (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
+
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 200 "/usr/include/stdlib.h" 3 4
+extern long int strtol_l (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
+
+extern unsigned long int strtoul_l (const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern long long int strtoll_l (const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern unsigned long long int strtoull_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+extern double strtod_l (const char *__restrict __nptr,
+   char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+extern float strtof_l (const char *__restrict __nptr,
+         char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+extern long double strtold_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+# 266 "/usr/include/stdlib.h" 3 4
+extern char *l64a (long int __n) throw () ;
+
+
+extern long int a64l (const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+# 1 "/usr/include/sys/types.h" 1 3 4
+# 27 "/usr/include/sys/types.h" 3 4
+extern "C" {
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+
+
+
+
+typedef __loff_t loff_t;
+
+
+
+typedef __ino_t ino_t;
+
+
+
+
+
+
+typedef __ino64_t ino64_t;
+
+
+
+
+typedef __dev_t dev_t;
+
+
+
+
+typedef __gid_t gid_t;
+
+
+
+
+typedef __mode_t mode_t;
+
+
+
+
+typedef __nlink_t nlink_t;
+
+
+
+
+typedef __uid_t uid_t;
+# 98 "/usr/include/sys/types.h" 3 4
+typedef __pid_t pid_t;
+
+
+
+
+
+typedef __id_t id_t;
+# 115 "/usr/include/sys/types.h" 3 4
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+
+
+
+
+
+typedef __key_t key_t;
+# 132 "/usr/include/sys/types.h" 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 59 "/usr/include/time.h" 3 4
+typedef __clock_t clock_t;
+# 75 "/usr/include/time.h" 3 4
+typedef __time_t time_t;
+# 91 "/usr/include/time.h" 3 4
+typedef __clockid_t clockid_t;
+# 103 "/usr/include/time.h" 3 4
+typedef __timer_t timer_t;
+# 133 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef __useconds_t useconds_t;
+
+
+
+typedef __suseconds_t suseconds_t;
+
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 147 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+# 200 "/usr/include/sys/types.h" 3 4
+typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
+typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+# 216 "/usr/include/sys/types.h" 3 4
+# 1 "/usr/include/endian.h" 1 3 4
+# 36 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/bits/endian.h" 1 3 4
+# 37 "/usr/include/endian.h" 2 3 4
+# 60 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/bits/byteswap.h" 1 3 4
+# 28 "/usr/include/bits/byteswap.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/bits/byteswap.h" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/bits/byteswap-16.h" 1 3 4
+# 36 "/usr/include/bits/byteswap.h" 2 3 4
+# 61 "/usr/include/endian.h" 2 3 4
+# 217 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/sys/select.h" 1 3 4
+# 30 "/usr/include/sys/select.h" 3 4
+# 1 "/usr/include/bits/select.h" 1 3 4
+# 22 "/usr/include/bits/select.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 23 "/usr/include/bits/select.h" 2 3 4
+# 31 "/usr/include/sys/select.h" 2 3 4
+
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 22 "/usr/include/bits/sigset.h" 3 4
+typedef int __sig_atomic_t;
+
+
+
+
+typedef struct
+  {
+    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+  } __sigset_t;
+# 34 "/usr/include/sys/select.h" 2 3 4
+
+
+
+typedef __sigset_t sigset_t;
+
+
+
+
+
+
+
+
+# 1 "/usr/include/time.h" 1 3 4
+# 120 "/usr/include/time.h" 3 4
+struct timespec
+  {
+    __time_t tv_sec;
+    __syscall_slong_t tv_nsec;
+  };
+# 46 "/usr/include/sys/select.h" 2 3 4
+
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 30 "/usr/include/bits/time.h" 3 4
+struct timeval
+  {
+    __time_t tv_sec;
+    __suseconds_t tv_usec;
+  };
+# 48 "/usr/include/sys/select.h" 2 3 4
+
+
+
+
+
+
+
+
+typedef long int __fd_mask;
+# 66 "/usr/include/sys/select.h" 3 4
+typedef struct
+  {
+
+
+
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+
+
+
+
+
+  } fd_set;
+
+
+
+
+
+
+typedef __fd_mask fd_mask;
+# 98 "/usr/include/sys/select.h" 3 4
+extern "C" {
+# 108 "/usr/include/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 120 "/usr/include/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+# 133 "/usr/include/sys/select.h" 3 4
+}
+# 220 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/sys/sysmacros.h" 1 3 4
+# 24 "/usr/include/sys/sysmacros.h" 3 4
+extern "C" {
+
+__extension__
+extern unsigned int gnu_dev_major (unsigned long long int __dev)
+     throw () __attribute__ ((__const__));
+__extension__
+extern unsigned int gnu_dev_minor (unsigned long long int __dev)
+     throw () __attribute__ ((__const__));
+__extension__
+extern unsigned long long int gnu_dev_makedev (unsigned int __major,
+            unsigned int __minor)
+     throw () __attribute__ ((__const__));
+# 58 "/usr/include/sys/sysmacros.h" 3 4
+}
+# 223 "/usr/include/sys/types.h" 2 3 4
+
+
+
+
+
+typedef __blksize_t blksize_t;
+
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+# 262 "/usr/include/sys/types.h" 3 4
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+
+
+
+
+
+
+# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
+# 21 "/usr/include/bits/pthreadtypes.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
+# 60 "/usr/include/bits/pthreadtypes.h" 3 4
+typedef unsigned long int pthread_t;
+
+
+union pthread_attr_t
+{
+  char __size[56];
+  long int __align;
+};
+
+typedef union pthread_attr_t pthread_attr_t;
+
+
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+# 90 "/usr/include/bits/pthreadtypes.h" 3 4
+typedef union
+{
+  struct __pthread_mutex_s
+  {
+    int __lock;
+    unsigned int __count;
+    int __owner;
+
+    unsigned int __nusers;
+
+
+
+    int __kind;
+
+    short __spins;
+    short __elision;
+    __pthread_list_t __list;
+# 125 "/usr/include/bits/pthreadtypes.h" 3 4
+  } __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+
+
+
+
+typedef union
+{
+  struct
+  {
+    int __lock;
+    unsigned int __futex;
+    __extension__ unsigned long long int __total_seq;
+    __extension__ unsigned long long int __wakeup_seq;
+    __extension__ unsigned long long int __woken_seq;
+    void *__mutex;
+    unsigned int __nwaiters;
+    unsigned int __broadcast_seq;
+  } __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+
+
+
+typedef unsigned int pthread_key_t;
+
+
+
+typedef int pthread_once_t;
+
+
+
+
+
+typedef union
+{
+
+  struct
+  {
+    int __lock;
+    unsigned int __nr_readers;
+    unsigned int __readers_wakeup;
+    unsigned int __writer_wakeup;
+    unsigned int __nr_readers_queued;
+    unsigned int __nr_writers_queued;
+    int __writer;
+    int __shared;
+    signed char __rwelision;
+
+
+
+
+    unsigned char __pad1[7];
+
+
+    unsigned long int __pad2;
+
+
+    unsigned int __flags;
+
+  } __data;
+# 220 "/usr/include/bits/pthreadtypes.h" 3 4
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+
+
+
+
+
+typedef volatile int pthread_spinlock_t;
+
+
+
+
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+# 271 "/usr/include/sys/types.h" 2 3 4
+
+
+}
+# 276 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) throw ();
+
+
+extern void srandom (unsigned int __seed) throw ();
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int rand (void) throw ();
+
+extern void srand (unsigned int __seed) throw ();
+
+
+
+
+extern int rand_r (unsigned int *__seed) throw ();
+
+
+
+
+
+
+
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    __extension__ unsigned long long int __a;
+
+  };
+
+
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+# 427 "/usr/include/stdlib.h" 3 4
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) ;
+# 441 "/usr/include/stdlib.h" 3 4
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+
+extern void free (void *__ptr) throw ();
+
+
+
+
+extern void cfree (void *__ptr) throw ();
+
+
+
+
+# 1 "/usr/include/alloca.h" 1 3 4
+# 24 "/usr/include/alloca.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 25 "/usr/include/alloca.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+extern void *alloca (size_t __size) throw ();
+
+
+
+
+
+}
+# 454 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+# 496 "/usr/include/stdlib.h" 3 4
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+extern char *secure_getenv (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (const char *__name, const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int clearenv (void) throw ();
+# 567 "/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
+# 580 "/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 590 "/usr/include/stdlib.h" 3 4
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 602 "/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+# 612 "/usr/include/stdlib.h" 3 4
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) ;
+# 623 "/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
+# 634 "/usr/include/stdlib.h" 3 4
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 644 "/usr/include/stdlib.h" 3 4
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 654 "/usr/include/stdlib.h" 3 4
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 666 "/usr/include/stdlib.h" 3 4
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 677 "/usr/include/stdlib.h" 3 4
+extern int system (const char *__command) ;
+
+
+
+
+
+
+extern char *canonicalize_file_name (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+# 694 "/usr/include/stdlib.h" 3 4
+extern char *realpath (const char *__restrict __name,
+         char *__restrict __resolved) throw () ;
+
+
+
+
+
+
+typedef int (*__compar_fn_t) (const void *, const void *);
+
+
+typedef __compar_fn_t comparison_fn_t;
+
+
+
+typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
+
+
+
+
+
+extern void *bsearch (const void *__key, const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) ;
+
+
+
+
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+
+
+
+
+extern int abs (int __x) throw () __attribute__ ((__const__)) ;
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
+
+
+
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) ;
+
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) ;
+
+
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) ;
+# 772 "/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+
+extern int mblen (const char *__s, size_t __n) throw ();
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) throw ();
+
+
+extern int wctomb (char *__s, wchar_t __wchar) throw ();
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) throw ();
+
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     throw ();
+# 848 "/usr/include/stdlib.h" 3 4
+extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
+# 859 "/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
+
+
+
+
+
+extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int posix_openpt (int __oflag) ;
+
+
+
+
+
+
+
+extern int grantpt (int __fd) throw ();
+
+
+
+extern int unlockpt (int __fd) throw ();
+
+
+
+
+extern char *ptsname (int __fd) throw () ;
+
+
+
+
+
+
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int getpt (void);
+
+
+
+
+
+
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 921 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
+# 922 "/usr/include/stdlib.h" 2 3 4
+# 934 "/usr/include/stdlib.h" 3 4
+}
+# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 2 3
+# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+
+
+  using ::at_quick_exit;
+
+
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+
+  using ::qsort;
+
+
+  using ::quick_exit;
+
+
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+
+  using ::wcstombs;
+  using ::wctomb;
+
+
+
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+
+
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+}
+# 215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  using ::lldiv_t;
+
+
+
+
+
+  using ::_Exit;
+
+
+
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+# 247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+
+  using ::strtof;
+  using ::strtold;
+
+
+}
+
+namespace std
+{
+
+  using ::__gnu_cxx::lldiv_t;
+
+  using ::__gnu_cxx::_Exit;
+
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+}
+
+
+
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
+
+
+# 1 "/usr/include/string.h" 1 3 4
+# 27 "/usr/include/string.h" 3 4
+extern "C" {
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 33 "/usr/include/string.h" 2 3 4
+# 42 "/usr/include/string.h" 3 4
+extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
+       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void *memmove (void *__dest, const void *__src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
+        int __c, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int memcmp (const void *__s1, const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 92 "/usr/include/string.h" 3 4
+extern void *memchr (const void *__s, int __c, size_t __n)
+      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 106 "/usr/include/string.h" 3 4
+extern void *rawmemchr (const void *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 117 "/usr/include/string.h" 3 4
+extern void *memrchr (const void *__s, int __c, size_t __n)
+      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strcat (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncat (char *__restrict __dest, const char *__restrict __src,
+        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int strncmp (const char *__s1, const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcoll (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern size_t strxfrm (char *__restrict __dest,
+         const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (2)));
+# 162 "/usr/include/string.h" 3 4
+extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
+    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
+
+
+
+
+extern char *strdup (const char *__s)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strndup (const char *__string, size_t __n)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+# 231 "/usr/include/string.h" 3 4
+extern char *strchr (const char *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 258 "/usr/include/string.h" 3 4
+extern char *strrchr (const char *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 272 "/usr/include/string.h" 3 4
+extern char *strchrnul (const char *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern size_t strcspn (const char *__s, const char *__reject)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern size_t strspn (const char *__s, const char *__accept)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 310 "/usr/include/string.h" 3 4
+extern char *strpbrk (const char *__s, const char *__accept)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 337 "/usr/include/string.h" 3 4
+extern char *strstr (const char *__haystack, const char *__needle)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strtok (char *__restrict __s, const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern char *__strtok_r (char *__restrict __s,
+    const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+# 368 "/usr/include/string.h" 3 4
+extern char *strcasestr (const char *__haystack, const char *__needle)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+extern void *memmem (const void *__haystack, size_t __haystacklen,
+       const void *__needle, size_t __needlelen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern void *__mempcpy (void *__restrict __dest,
+   const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *mempcpy (void *__restrict __dest,
+        const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern size_t strlen (const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern size_t strnlen (const char *__string, size_t __maxlen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern char *strerror (int __errnum) throw ();
+# 433 "/usr/include/string.h" 3 4
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) ;
+
+
+
+
+
+extern char *strerror_l (int __errnum, __locale_t __l) throw ();
+
+
+
+
+
+extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern void bcopy (const void *__src, void *__dest, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int bcmp (const void *__s1, const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 484 "/usr/include/string.h" 3 4
+extern char *index (const char *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 512 "/usr/include/string.h" 3 4
+extern char *rindex (const char *__s, int __c)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int ffs (int __i) throw () __attribute__ ((__const__));
+
+
+
+
+extern int ffsl (long int __l) throw () __attribute__ ((__const__));
+__extension__ extern int ffsll (long long int __ll)
+     throw () __attribute__ ((__const__));
+
+
+
+extern int strcasecmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int strcasecmp_l (const char *__s1, const char *__s2,
+    __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+extern int strncasecmp_l (const char *__s1, const char *__s2,
+     size_t __n, __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+
+
+
+extern char *strsep (char **__restrict __stringp,
+       const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strsignal (int __sig) throw ();
+
+
+extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern char *__stpncpy (char *__restrict __dest,
+   const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int strverscmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+# 599 "/usr/include/string.h" 3 4
+extern char *basename (const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
+# 656 "/usr/include/string.h" 3 4
+}
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 2 3
+# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+
+
+  inline void*
+  memchr(void* __s, int __c, size_t __n)
+  { return __builtin_memchr(__s, __c, __n); }
+
+  inline char*
+  strchr(char* __s, int __n)
+  { return __builtin_strchr(__s, __n); }
+
+  inline char*
+  strpbrk(char* __s1, const char* __s2)
+  { return __builtin_strpbrk(__s1, __s2); }
+
+  inline char*
+  strrchr(char* __s, int __n)
+  { return __builtin_strrchr(__s, __n); }
+
+  inline char*
+  strstr(char* __s1, const char* __s2)
+  { return __builtin_strstr(__s1, __s2); }
+
+
+
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h" 1
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h"
+namespace mozilla {
+
+struct fallible_t { };
+# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h"
+extern const fallible_t fallible;
+
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h"
+__attribute__((weak)) __attribute__((visibility("default")))
+
+  __attribute__((noreturn))
+
+  void mozalloc_abort(const char* const msg);
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 1 3
+# 37 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 3
+# 1 "/usr/include/limits.h" 1 3 4
+# 143 "/usr/include/limits.h" 3 4
+# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
+# 160 "/usr/include/bits/posix1_lim.h" 3 4
+# 1 "/usr/include/bits/local_lim.h" 1 3 4
+# 38 "/usr/include/bits/local_lim.h" 3 4
+# 1 "/usr/include/linux/limits.h" 1 3 4
+# 39 "/usr/include/bits/local_lim.h" 2 3 4
+# 161 "/usr/include/bits/posix1_lim.h" 2 3 4
+# 144 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
+# 148 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
+# 33 "/usr/include/bits/xopen_lim.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 34 "/usr/include/bits/xopen_lim.h" 2 3 4
+# 152 "/usr/include/limits.h" 2 3 4
+# 38 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 2 3
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2
+
+
+
+namespace mozilla {
+
+namespace tl {
+
+
+template<size_t Size, size_t... Rest>
+struct Min
+{
+  static constexpr size_t value =
+    Size < Min<Rest...>::value
+    ? Size
+    : Min<Rest...>::value;
+};
+
+template<size_t Size>
+struct Min<Size>
+{
+  static constexpr size_t value = Size;
+};
+
+template<size_t Size, size_t... Rest>
+struct Max
+{
+  static constexpr size_t value =
+    Size > Max<Rest...>::value
+    ? Size
+    : Max<Rest...>::value;
+};
+
+template<size_t Size>
+struct Max<Size>
+{
+  static constexpr size_t value = Size;
+};
+
+
+template<size_t I>
+struct FloorLog2
+{
+  static const size_t value = 1 + FloorLog2<I / 2>::value;
+};
+template<> struct FloorLog2<0> { };
+template<> struct FloorLog2<1> { static const size_t value = 0; };
+
+
+template<size_t I>
+struct CeilingLog2
+{
+  static const size_t value = FloorLog2<2 * I - 1>::value;
+};
+
+
+template<size_t I>
+struct RoundUpPow2
+{
+  static const size_t value = size_t(1) << CeilingLog2<I>::value;
+};
+template<>
+struct RoundUpPow2<0>
+{
+  static const size_t value = 1;
+};
+
+
+template<typename T>
+struct BitSize
+{
+  static const size_t value = sizeof(T) * 8;
+};
+
+
+
+
+
+template<size_t N>
+struct NBitMask
+{
+
+
+
+
+  static const size_t checkPrecondition =
+    0 / size_t(N < BitSize<size_t>::value);
+  static const size_t value = (size_t(1) << N) - 1 + checkPrecondition;
+};
+template<>
+struct NBitMask<BitSize<size_t>::value>
+{
+  static const size_t value = size_t(-1);
+};
+
+
+
+
+
+template<size_t N>
+struct MulOverflowMask
+{
+  static const size_t value =
+    ~NBitMask<BitSize<size_t>::value - CeilingLog2<N>::value>::value;
+};
+template<> struct MulOverflowMask<0> { };
+template<> struct MulOverflowMask<1> { static const size_t value = 0; };
+# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h"
+template<bool...>
+struct And;
+
+template<>
+struct And<> : public TrueType { };
+
+template<bool C1, bool... Cn>
+struct And<C1, Cn...>
+  : public Conditional<C1, And<Cn...>, FalseType>::Type { };
+
+}
+
+}
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
+# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
+extern "C" {
+# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
+__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmalloc(size_t size)
+    __attribute__ ((malloc, warn_unused_result));
+
+__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xcalloc(size_t nmemb, size_t size)
+    __attribute__ ((malloc, warn_unused_result));
+
+__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xrealloc(void* ptr, size_t size)
+    __attribute__ ((malloc, warn_unused_result));
+
+__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrdup(const char* str)
+    __attribute__ ((malloc, warn_unused_result));
+
+__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_usable_size(void *ptr);
+
+__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_size_of(const void *ptr);
+
+
+__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrndup(const char* str, size_t strsize)
+    __attribute__ ((malloc, warn_unused_result));
+
+
+
+
+__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result))
+int moz_xposix_memalign(void **ptr, size_t alignment, size_t size);
+
+__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result))
+int moz_posix_memalign(void **ptr, size_t alignment, size_t size);
+
+
+
+
+__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmemalign(size_t boundary, size_t size)
+    __attribute__ ((malloc, warn_unused_result));
+
+
+
+
+__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xvalloc(size_t size)
+    __attribute__ ((malloc, warn_unused_result));
+
+
+
+
+}
+# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
+__attribute__((always_inline)) inline
+
+void* operator new(size_t size) throw(std::bad_alloc)
+{
+    return moz_xmalloc(size);
+}
+
+                    __attribute__((always_inline)) inline
+void* operator new(size_t size, const std::nothrow_t&) throw()
+{
+    return malloc(size);
+}
+
+                    __attribute__((always_inline)) inline
+void* operator new[](size_t size) throw(std::bad_alloc)
+{
+    return moz_xmalloc(size);
+}
+
+                    __attribute__((always_inline)) inline
+void* operator new[](size_t size, const std::nothrow_t&) throw()
+{
+    return malloc(size);
+}
+
+                    __attribute__((always_inline)) inline
+void operator delete(void* ptr) throw()
+{
+    return free(ptr);
+}
+
+                    __attribute__((always_inline)) inline
+void operator delete(void* ptr, const std::nothrow_t&) throw()
+{
+    return free(ptr);
+}
+
+                    __attribute__((always_inline)) inline
+void operator delete[](void* ptr) throw()
+{
+    return free(ptr);
+}
+
+                    __attribute__((always_inline)) inline
+void operator delete[](void* ptr, const std::nothrow_t&) throw()
+{
+    return free(ptr);
+}
+# 259 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
+__attribute__((always_inline)) inline
+void* operator new(size_t size, const mozilla::fallible_t&) throw()
+{
+    return malloc(size);
+}
+
+__attribute__((always_inline)) inline
+void* operator new[](size_t size, const mozilla::fallible_t&) throw()
+{
+    return malloc(size);
+}
+
+__attribute__((always_inline)) inline
+void operator delete(void* ptr, const mozilla::fallible_t&) throw()
+{
+    free(ptr);
+}
+
+__attribute__((always_inline)) inline
+void operator delete[](void* ptr, const mozilla::fallible_t&) throw()
+{
+    free(ptr);
+}
+
+
+
+
+
+
+
+class InfallibleAllocPolicy
+{
+public:
+    template <typename T>
+    T* maybe_pod_malloc(size_t aNumElems)
+    {
+        return pod_malloc<T>(aNumElems);
+    }
+
+    template <typename T>
+    T* maybe_pod_calloc(size_t aNumElems)
+    {
+        return pod_calloc<T>(aNumElems);
+    }
+
+    template <typename T>
+    T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
+    {
+        return pod_realloc<T>(aPtr, aOldSize, aNewSize);
+    }
+
+    template <typename T>
+    T* pod_malloc(size_t aNumElems)
+    {
+        if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+            reportAllocOverflow();
+        }
+        return static_cast<T*>(moz_xmalloc(aNumElems * sizeof(T)));
+    }
+
+    template <typename T>
+    T* pod_calloc(size_t aNumElems)
+    {
+        return static_cast<T*>(moz_xcalloc(aNumElems, sizeof(T)));
+    }
+
+    template <typename T>
+    T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
+    {
+        if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+            reportAllocOverflow();
+        }
+        return static_cast<T*>(moz_xrealloc(aPtr, aNewSize * sizeof(T)));
+    }
+
+    void free_(void* aPtr)
+    {
+        free(aPtr);
+    }
+
+    void reportAllocOverflow() const
+    {
+        mozalloc_abort("alloc overflow");
+    }
+
+    bool checkSimulatedOOM() const
+    {
+        return true;
+    }
+};
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h"
+typedef uintptr_t MozRefCountType;
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h"
+typedef uint32_t MozExternalRefCountType;
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
+# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 1
+# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
+enum class nsresult : uint32_t
+{
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1
+
+
+
+  NS_OK = 0,
+
+
+
+
+  NS_ERROR_BASE = 0xC1F30000,
+
+  NS_ERROR_NOT_INITIALIZED = NS_ERROR_BASE + 1,
+
+  NS_ERROR_ALREADY_INITIALIZED = NS_ERROR_BASE + 2,
+
+  NS_ERROR_NOT_IMPLEMENTED = 0x80004001,
+
+  NS_NOINTERFACE = 0x80004002,
+  NS_ERROR_NO_INTERFACE = NS_NOINTERFACE,
+
+  NS_ERROR_ABORT = 0x80004004,
+
+  NS_ERROR_FAILURE = 0x80004005,
+
+  NS_ERROR_UNEXPECTED = 0x8000ffff,
+
+  NS_ERROR_OUT_OF_MEMORY = 0x8007000e,
+
+  NS_ERROR_ILLEGAL_VALUE = 0x80070057,
+  NS_ERROR_INVALID_ARG = NS_ERROR_ILLEGAL_VALUE,
+  NS_ERROR_INVALID_POINTER = NS_ERROR_INVALID_ARG,
+  NS_ERROR_NULL_POINTER = NS_ERROR_INVALID_ARG,
+
+  NS_ERROR_NO_AGGREGATION = 0x80040110,
+
+  NS_ERROR_NOT_AVAILABLE = 0x80040111,
+
+  NS_ERROR_FACTORY_NOT_REGISTERED = 0x80040154,
+
+  NS_ERROR_FACTORY_REGISTER_AGAIN = 0x80040155,
+
+  NS_ERROR_FACTORY_NOT_LOADED = 0x800401f8,
+
+  NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = NS_ERROR_BASE + 0x101,
+
+  NS_ERROR_FACTORY_EXISTS = NS_ERROR_BASE + 0x100,
+
+
+
+
+
+
+
+  NS_ERROR_CANNOT_CONVERT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_OBJECT_IS_IMMUTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_ERROR_NOT_SAME_THREAD = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(4),
+
+
+  NS_ERROR_ILLEGAL_DURING_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(30),
+  NS_ERROR_SERVICE_NOT_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22),
+
+  NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_SUCCESS_INTERRUPTED_TRAVERSE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2),
+
+  NS_ERROR_SERVICE_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22),
+
+  NS_ERROR_SERVICE_IN_USE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(23),
+# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_BASE_STREAM_CLOSED = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(2),
+
+  NS_BASE_STREAM_OSERROR = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_BASE_STREAM_ILLEGAL_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(4),
+
+  NS_BASE_STREAM_NO_CONVERTER = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(5),
+
+  NS_BASE_STREAM_BAD_CONVERSION = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(6),
+  NS_BASE_STREAM_WOULD_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(7),
+# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(2),
+
+  NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_ERROR_GFX_PRINTER_STARTDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(4),
+
+  NS_ERROR_GFX_PRINTER_ENDDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(5),
+
+  NS_ERROR_GFX_PRINTER_STARTPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(6),
+
+  NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(7),
+
+
+  NS_ERROR_GFX_CMAP_MALFORMED = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(51),
+# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_SUCCESS_EVENT_CONSUMED = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+
+  NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(2),
+# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_BINDING_SUCCEEDED = NS_OK,
+
+
+  NS_BINDING_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_BINDING_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(2),
+
+
+
+
+
+  NS_BINDING_REDIRECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3),
+
+
+
+
+
+  NS_BINDING_RETARGETED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4),
+
+
+
+
+
+  NS_ERROR_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10),
+
+
+
+  NS_ERROR_IN_PROGRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(15),
+
+
+
+
+  NS_ERROR_NO_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(17),
+
+  NS_ERROR_UNKNOWN_PROTOCOL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(18),
+
+
+  NS_ERROR_INVALID_CONTENT_ENCODING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27),
+
+
+
+  NS_ERROR_CORRUPTED_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(29),
+
+
+
+  NS_ERROR_INVALID_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(58),
+
+
+
+  NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(34),
+
+
+  NS_ERROR_ALREADY_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(73),
+
+
+
+
+  NS_ERROR_ALREADY_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11),
+
+  NS_ERROR_NOT_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12),
+
+
+  NS_ERROR_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13),
+
+  NS_ERROR_NET_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(14),
+
+
+  NS_ERROR_OFFLINE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(16),
+
+
+
+  NS_ERROR_PORT_ACCESS_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(19),
+
+  NS_ERROR_NET_RESET = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(20),
+
+  NS_ERROR_NET_INTERRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(71),
+
+  NS_ERROR_PROXY_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(72),
+
+  NS_ERROR_NET_PARTIAL_TRANSFER = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(76),
+
+  NS_ERROR_NET_INADEQUATE_SECURITY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(82),
+
+
+
+
+
+  NS_ERROR_NOT_RESUMABLE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(25),
+
+  NS_ERROR_REDIRECT_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(31),
+
+
+  NS_ERROR_ENTITY_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(32),
+
+
+
+  NS_ERROR_UNSAFE_CONTENT_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(74),
+
+
+  NS_ERROR_REMOTE_XUL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(75),
+
+  NS_ERROR_LOAD_SHOWED_ERRORPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(77),
+
+
+  NS_ERROR_DOCSHELL_DYING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(78),
+
+
+
+
+  NS_ERROR_FTP_LOGIN = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(21),
+  NS_ERROR_FTP_CWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(22),
+  NS_ERROR_FTP_PASV = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(23),
+  NS_ERROR_FTP_PWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(24),
+  NS_ERROR_FTP_LIST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28),
+
+
+
+
+
+  NS_ERROR_UNKNOWN_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(30),
+
+
+  NS_ERROR_DNS_LOOKUP_QUEUE_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(33),
+
+
+
+  NS_ERROR_UNKNOWN_PROXY_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(42),
+
+
+
+
+
+  NS_ERROR_UNKNOWN_SOCKET_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(51),
+
+  NS_ERROR_SOCKET_CREATE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(52),
+
+  NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(53),
+
+  NS_ERROR_SOCKET_ADDRESS_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(54),
+
+
+  NS_ERROR_CACHE_KEY_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(61),
+  NS_ERROR_CACHE_DATA_IS_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(62),
+  NS_ERROR_CACHE_DATA_IS_NOT_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(63),
+  NS_ERROR_CACHE_WAIT_FOR_VALIDATION = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(64),
+  NS_ERROR_CACHE_ENTRY_DOOMED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(65),
+  NS_ERROR_CACHE_READ_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(66),
+  NS_ERROR_CACHE_WRITE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(67),
+  NS_ERROR_CACHE_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(68),
+
+
+  NS_ERROR_DOCUMENT_NOT_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(70),
+
+
+
+
+
+  NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(80),
+
+  NS_ERROR_HOST_IS_IP_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(81),
+
+
+
+
+
+
+
+  NS_SUCCESS_ADOPTED_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(90),
+
+
+  NS_NET_STATUS_BEGIN_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27),
+  NS_NET_STATUS_END_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28),
+
+
+
+
+  NS_SUCCESS_AUTH_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(40),
+
+
+
+
+  NS_NET_STATUS_READING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(8),
+  NS_NET_STATUS_WRITING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(9),
+
+
+  NS_NET_STATUS_RESOLVING_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3),
+  NS_NET_STATUS_RESOLVED_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11),
+  NS_NET_STATUS_CONNECTING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(7),
+  NS_NET_STATUS_CONNECTED_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4),
+  NS_NET_STATUS_TLS_HANDSHAKE_STARTING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12),
+  NS_NET_STATUS_TLS_HANDSHAKE_ENDED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13),
+  NS_NET_STATUS_SENDING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(5),
+  NS_NET_STATUS_WAITING_FOR = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10),
+  NS_NET_STATUS_RECEIVING_FROM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(6),
+
+
+
+  NS_ERROR_INTERCEPTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(100),
+
+
+
+  NS_ERROR_HSTS_PRIMING_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(110),
+
+
+
+
+
+
+
+  NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1000),
+  NS_ERROR_PLUGIN_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1001),
+  NS_ERROR_PLUGIN_BLOCKLISTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1002),
+  NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1003),
+  NS_ERROR_PLUGIN_CLICKTOPLAY = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1004),
+  NS_PLUGIN_INIT_PENDING = ((uint32_t)(0) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1005),
+# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_TABLELAYOUT_CELL_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(0),
+
+  NS_POSITION_BEFORE_TABLE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(3),
+
+
+  NS_STATE_PROPERTY_EXISTS = NS_OK,
+
+  NS_STATE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(5),
+
+
+
+
+
+
+
+  NS_ERROR_HTMLPARSER_CONTINUE = NS_OK,
+
+  NS_ERROR_HTMLPARSER_EOF = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1000),
+  NS_ERROR_HTMLPARSER_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1001),
+  NS_ERROR_HTMLPARSER_CANTPROPAGATE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1002),
+  NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1003),
+  NS_ERROR_HTMLPARSER_BADFILENAME = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1004),
+  NS_ERROR_HTMLPARSER_BADURL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1005),
+  NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1006),
+  NS_ERROR_HTMLPARSER_INTERRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1007),
+  NS_ERROR_HTMLPARSER_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1008),
+  NS_ERROR_HTMLPARSER_BADTOKENIZER = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1009),
+  NS_ERROR_HTMLPARSER_BADATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1010),
+  NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1011),
+  NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1012),
+  NS_ERROR_HTMLPARSER_BADDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1013),
+  NS_ERROR_HTMLPARSER_BADCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1014),
+  NS_ERROR_HTMLPARSER_STOPPARSING = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1015),
+  NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1016),
+  NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1017),
+  NS_ERROR_HTMLPARSER_FAKE_ENDTAG = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1018),
+  NS_ERROR_HTMLPARSER_INVALID_COMMENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1019),
+
+  NS_HTMLTOKENS_NOT_AN_ENTITY = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(2000),
+  NS_HTMLPARSER_VALID_META_CHARSET = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(3000),
+# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_RDF_ASSERTION_ACCEPTED = NS_OK,
+
+
+  NS_RDF_CURSOR_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(1),
+
+
+  NS_RDF_NO_VALUE = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(2),
+
+
+
+  NS_RDF_ASSERTION_REJECTED = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_RDF_STOP_VISIT = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(4),
+
+
+
+
+
+
+
+  NS_ERROR_UCONV_NOCONV = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_UDEC_ILLEGALINPUT = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14),
+
+  NS_SUCCESS_USING_FALLBACK_LOCALE = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(2),
+  NS_OK_UDEC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(11),
+  NS_OK_UDEC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(12),
+  NS_OK_UDEC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(13),
+  NS_OK_UDEC_NOBOMFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14),
+  NS_OK_UENC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(33),
+  NS_OK_UENC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(34),
+  NS_ERROR_UENC_NOMAPPING = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(35),
+  NS_OK_UENC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(36),
+
+
+  NS_EXACT_LENGTH = NS_OK_UDEC_EXACTLENGTH,
+  NS_PARTIAL_MORE_INPUT = NS_OK_UDEC_MOREINPUT,
+  NS_PARTIAL_MORE_OUTPUT = NS_OK_UDEC_MOREOUTPUT,
+  NS_ERROR_ILLEGAL_INPUT = NS_ERROR_UDEC_ILLEGALINPUT,
+# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_FILE_UNRECOGNIZED_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_FILE_EXECUTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_FILE_UNKNOWN_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_FILE_DESTINATION_NOT_DIR = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_FILE_COPY_OR_MOVE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_FILE_ALREADY_EXISTS = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_FILE_INVALID_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_FILE_DISK_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_FILE_CORRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_FILE_NOT_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_FILE_IS_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(13),
+  NS_ERROR_FILE_IS_LOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(14),
+  NS_ERROR_FILE_TOO_BIG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(15),
+  NS_ERROR_FILE_NO_DEVICE_SPACE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(16),
+  NS_ERROR_FILE_NAME_TOO_LONG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(17),
+  NS_ERROR_FILE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(18),
+  NS_ERROR_FILE_READ_ONLY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(19),
+  NS_ERROR_FILE_DIR_NOT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(20),
+  NS_ERROR_FILE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(21),
+
+  NS_SUCCESS_FILE_DIRECTORY_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_SUCCESS_AGGREGATE_RESULT = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2),
+# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INDEX_SIZE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_DOM_WRONG_DOCUMENT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_INVALID_CHARACTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_DOM_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_DOM_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_DOM_INVALID_STATE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_DOM_SYNTAX_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_DOM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(13),
+  NS_ERROR_DOM_NAMESPACE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(14),
+  NS_ERROR_DOM_INVALID_ACCESS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(15),
+  NS_ERROR_DOM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(17),
+  NS_ERROR_DOM_SECURITY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(18),
+  NS_ERROR_DOM_NETWORK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(19),
+  NS_ERROR_DOM_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(20),
+  NS_ERROR_DOM_URL_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(21),
+  NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(22),
+  NS_ERROR_DOM_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(23),
+  NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(24),
+  NS_ERROR_DOM_DATA_CLONE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(25),
+
+  NS_ERROR_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(26),
+  NS_ERROR_RANGE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(27),
+
+  NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(28),
+  NS_ERROR_DOM_INVALID_POINTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(29),
+
+  NS_ERROR_DOM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(30),
+  NS_ERROR_DOM_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(31),
+  NS_ERROR_DOM_OPERATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(32),
+
+  NS_ERROR_DOM_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(33),
+
+  NS_ERROR_DOM_SECMAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1001),
+  NS_ERROR_DOM_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1002),
+  NS_ERROR_DOM_NOT_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1003),
+  NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1004),
+  NS_ERROR_DOM_NOT_NUMBER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1005),
+  NS_ERROR_DOM_NOT_BOOLEAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1006),
+  NS_ERROR_DOM_NOT_FUNCTION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1007),
+  NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1008),
+  NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1009),
+  NS_ERROR_DOM_PROP_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1010),
+  NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1011),
+  NS_ERROR_DOM_BAD_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1012),
+  NS_ERROR_DOM_RETVAL_UNDEFINED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1013),
+  NS_ERROR_DOM_QUOTA_REACHED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1014),
+
+
+  NS_ERROR_UNCATCHABLE_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1015),
+
+  NS_ERROR_DOM_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1016),
+  NS_ERROR_DOM_INVALID_HEADER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1017),
+
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1018),
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1019),
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1020),
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1021),
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1022),
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1023),
+  NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1024),
+  NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1025),
+
+
+
+
+
+  NS_SUCCESS_DOM_NO_OPERATION = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+
+
+
+  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(2),
+
+
+
+
+
+
+  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3),
+
+
+
+
+
+
+
+  NS_IMAGELIB_SUCCESS_LOAD_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(0),
+  NS_IMAGELIB_CHANGING_OWNER = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_IMAGELIB_ERROR_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(5),
+  NS_IMAGELIB_ERROR_NO_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(6),
+  NS_IMAGELIB_ERROR_NOT_FINISHED = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(7),
+  NS_IMAGELIB_ERROR_NO_ENCODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(9),
+
+
+
+
+
+
+
+  NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(1),
+  NS_SUCCESS_EDITOR_FOUND_TARGET = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(2),
+
+
+
+
+
+
+
+  NS_ERROR_XPC_NOT_ENOUGH_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_XPC_NEED_OUT_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_XPC_CANT_SET_OUT_VAL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_XPC_CANT_GET_METHOD_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_XPC_UNEXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_XPC_BAD_CONVERT_JS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_XPC_BAD_CONVERT_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(13),
+  NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(14),
+  NS_ERROR_XPC_CANT_WATCH_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(15),
+  NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(16),
+  NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(17),
+  NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(18),
+  NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(19),
+  NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(20),
+  NS_ERROR_XPC_CI_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(21),
+  NS_ERROR_XPC_GS_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(22),
+  NS_ERROR_XPC_BAD_CID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(23),
+  NS_ERROR_XPC_BAD_IID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(24),
+  NS_ERROR_XPC_CANT_CREATE_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(25),
+  NS_ERROR_XPC_JS_THREW_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(26),
+  NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(27),
+  NS_ERROR_XPC_JS_THREW_JS_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(28),
+  NS_ERROR_XPC_JS_THREW_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(29),
+  NS_ERROR_XPC_JS_THREW_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(30),
+  NS_ERROR_XPC_JS_THREW_NUMBER = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(31),
+  NS_ERROR_XPC_JAVASCRIPT_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(32),
+  NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(33),
+  NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(34),
+  NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(35),
+  NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(36),
+  NS_ERROR_XPC_CANT_GET_ARRAY_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(37),
+  NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(38),
+  NS_ERROR_XPC_SECURITY_MANAGER_VETO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(39),
+  NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(40),
+  NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(41),
+  NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(42),
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(43),
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(44),
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(45),
+  NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(46),
+  NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(47),
+  NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(48),
+  NS_ERROR_XPC_BAD_ID_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(49),
+  NS_ERROR_XPC_BAD_INITIALIZER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(50),
+  NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(51),
+  NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(52),
+  NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(53),
+  NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(54),
+# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_LAUNCHED_CHILD_PROCESS = ((uint32_t)(1) << 31) | ((uint32_t)(19 + 0x45) << 16) | (uint32_t)(200),
+# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_CSP_FORM_ACTION_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(98),
+  NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(99),
+
+
+  NS_ERROR_SRI_CORRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(200),
+  NS_ERROR_SRI_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(201),
+  NS_ERROR_SRI_NOT_ELIGIBLE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(202),
+  NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(203),
+  NS_ERROR_SRI_IMPORT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(204),
+
+
+
+  NS_ERROR_CMS_VERIFY_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1024),
+  NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1025),
+  NS_ERROR_CMS_VERIFY_BAD_DIGEST = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1026),
+  NS_ERROR_CMS_VERIFY_NOCERT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1028),
+  NS_ERROR_CMS_VERIFY_UNTRUSTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1029),
+  NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1031),
+  NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1032),
+  NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1033),
+  NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1034),
+  NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1035),
+  NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1036),
+  NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1037),
+  NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1038),
+  NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1039),
+  NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1040),
+  NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1056),
+  NS_ERROR_CMS_ENCRYPT_INCOMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1057),
+# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INVALID_EXPRESSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(51),
+  NS_ERROR_DOM_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(52),
+
+
+
+
+
+
+
+  NS_ERROR_WONT_HANDLE_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(1),
+
+
+  NS_ERROR_MALWARE_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(30),
+  NS_ERROR_PHISHING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(31),
+  NS_ERROR_TRACKING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(34),
+  NS_ERROR_UNWANTED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(35),
+  NS_ERROR_BLOCKED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(37),
+
+
+  NS_ERROR_SAVE_LINK_AS_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(32),
+
+
+  NS_ERROR_PARSED_DATA_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(33),
+
+
+
+  NS_REFRESHURI_HEADER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(2),
+# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_IMAGE_SRC_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_IMAGE_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(5),
+
+  NS_ERROR_CONTENT_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(7),
+
+  NS_PROPTABLE_PROP_NOT_THERE = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(10),
+
+  NS_ERROR_XBL_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(15),
+
+  NS_ERROR_CONTENT_CRASHED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(16),
+
+
+  NS_HTML_STYLE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(2),
+  NS_CONTENT_BLOCKED = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(8),
+  NS_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(9),
+  NS_PROPTABLE_PROP_OVERWRITTEN = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(11),
+
+  NS_FINDBROADCASTER_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(12),
+  NS_FINDBROADCASTER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(13),
+  NS_FINDBROADCASTER_AWAIT_OVERLAYS = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(14),
+
+
+
+
+
+
+
+  NS_ERROR_XPATH_INVALID_ARG = NS_ERROR_INVALID_ARG,
+
+  NS_ERROR_XSLT_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_XPATH_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_XSLT_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_XSLT_EXECUTION_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_XPATH_UNKNOWN_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_XSLT_BAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_XSLT_BAD_VALUE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_XSLT_NODESET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_XSLT_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_XSLT_NETWORK_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_XSLT_WRONG_MIME_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_XSLT_LOAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(13),
+  NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(14),
+  NS_ERROR_XPATH_PAREN_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(15),
+  NS_ERROR_XPATH_INVALID_AXIS = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(16),
+  NS_ERROR_XPATH_NO_NODE_TYPE_TEST = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(17),
+  NS_ERROR_XPATH_BRACKET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(18),
+  NS_ERROR_XPATH_INVALID_VAR_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(19),
+  NS_ERROR_XPATH_UNEXPECTED_END = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(20),
+  NS_ERROR_XPATH_OPERATOR_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(21),
+  NS_ERROR_XPATH_UNCLOSED_LITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(22),
+  NS_ERROR_XPATH_BAD_COLON = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(23),
+  NS_ERROR_XPATH_BAD_BANG = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(24),
+  NS_ERROR_XPATH_ILLEGAL_CHAR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(25),
+  NS_ERROR_XPATH_BINARY_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(26),
+  NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(27),
+  NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(28),
+  NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(29),
+  NS_ERROR_XSLT_BAD_NODE_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(30),
+  NS_ERROR_XSLT_VAR_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(31),
+  NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(32),
+
+  NS_XSLT_GET_NEW_HANDLER = ((uint32_t)(0) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1),
+# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_TRANSPORT_INIT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_ERROR_DUPLICATE_HANDLE = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(2),
+
+  NS_ERROR_BRIDGE_OPEN_PARENT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_ERROR_BRIDGE_OPEN_CHILD = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(4),
+
+
+
+
+
+
+
+  NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(0),
+
+  NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(2),
+# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_STORAGE_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_STORAGE_IOERR = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_STORAGE_CONSTRAINT = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(3),
+
+
+
+
+
+
+
+  NS_ERROR_DOM_FILE_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(0),
+  NS_ERROR_DOM_FILE_NOT_READABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_FILE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(2),
+# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_INDEXEDDB_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1001),
+
+
+
+
+
+
+
+  NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(6),
+
+
+
+
+
+
+  NS_ERROR_SIGNED_JAR_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_SIGNED_JAR_ENTRY_MISSING = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_SIGNED_JAR_ENTRY_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(8),
+
+
+
+
+
+
+  NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(6),
+
+
+
+
+
+
+  NS_ERROR_SIGNED_APP_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(38 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+
+
+
+  NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(39 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+
+
+
+  NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_PUSH_DENIED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_DOM_PUSH_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(6),
+
+
+
+
+
+
+
+  NS_ERROR_DOM_MEDIA_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(3),
+
+
+  NS_ERROR_DOM_MEDIA_DECODE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_DOM_MEDIA_FATAL_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_DOM_MEDIA_METADATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_DOM_MEDIA_END_OF_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_DOM_MEDIA_CANCELED = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(11),
+  NS_ERROR_DOM_MEDIA_DEMUXER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(12),
+  NS_ERROR_DOM_MEDIA_CDM_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(13),
+  NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(14),
+  NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(15),
+
+
+  NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(101),
+
+
+
+
+
+
+  NS_ERROR_UC_UPDATE_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(1),
+  NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_UC_UPDATE_INFINITE_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(3),
+  NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(4),
+  NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(5),
+  NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(6),
+  NS_ERROR_UC_UPDATE_SHUTDOWNING = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(7),
+  NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(8),
+  NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(9),
+  NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(10),
+  NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(11),
+
+
+
+
+
+
+
+  NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(1),
+
+  NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(2),
+
+  NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(3),
+
+  NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(4),
+
+  NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(5),
+# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOWNLOAD_COMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+  NS_ERROR_DOWNLOAD_NOT_PARTIAL = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2),
+  NS_ERROR_UNORM_MOREOUTPUT = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(33),
+
+  NS_ERROR_DOCSHELL_REQUEST_REJECTED = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1001),
+
+
+
+
+  NS_ERROR_DOCUMENT_IS_PRINTMODE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2001),
+
+  NS_SUCCESS_DONT_FIXUP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
+
+
+
+  NS_SUCCESS_RESTART_APP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
+  NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(3),
+  NS_SUCCESS_UNORM_NOTFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(17),
+
+
+
+
+  NS_ERROR_NOT_IN_TREE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(38),
+
+
+  NS_OK_NO_NAME_CLAUSE_HANDLED = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(34)
+# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2
+
+};
+
+
+
+
+
+const nsresult
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1
+
+
+
+  NS_OK = nsresult::NS_OK,
+
+
+
+
+  NS_ERROR_BASE = nsresult::NS_ERROR_BASE,
+
+  NS_ERROR_NOT_INITIALIZED = nsresult::NS_ERROR_NOT_INITIALIZED,
+
+  NS_ERROR_ALREADY_INITIALIZED = nsresult::NS_ERROR_ALREADY_INITIALIZED,
+
+  NS_ERROR_NOT_IMPLEMENTED = nsresult::NS_ERROR_NOT_IMPLEMENTED,
+
+  NS_NOINTERFACE = nsresult::NS_NOINTERFACE,
+  NS_ERROR_NO_INTERFACE = nsresult::NS_ERROR_NO_INTERFACE,
+
+  NS_ERROR_ABORT = nsresult::NS_ERROR_ABORT,
+
+  NS_ERROR_FAILURE = nsresult::NS_ERROR_FAILURE,
+
+  NS_ERROR_UNEXPECTED = nsresult::NS_ERROR_UNEXPECTED,
+
+  NS_ERROR_OUT_OF_MEMORY = nsresult::NS_ERROR_OUT_OF_MEMORY,
+
+  NS_ERROR_ILLEGAL_VALUE = nsresult::NS_ERROR_ILLEGAL_VALUE,
+  NS_ERROR_INVALID_ARG = nsresult::NS_ERROR_INVALID_ARG,
+  NS_ERROR_INVALID_POINTER = nsresult::NS_ERROR_INVALID_POINTER,
+  NS_ERROR_NULL_POINTER = nsresult::NS_ERROR_NULL_POINTER,
+
+  NS_ERROR_NO_AGGREGATION = nsresult::NS_ERROR_NO_AGGREGATION,
+
+  NS_ERROR_NOT_AVAILABLE = nsresult::NS_ERROR_NOT_AVAILABLE,
+
+  NS_ERROR_FACTORY_NOT_REGISTERED = nsresult::NS_ERROR_FACTORY_NOT_REGISTERED,
+
+  NS_ERROR_FACTORY_REGISTER_AGAIN = nsresult::NS_ERROR_FACTORY_REGISTER_AGAIN,
+
+  NS_ERROR_FACTORY_NOT_LOADED = nsresult::NS_ERROR_FACTORY_NOT_LOADED,
+
+  NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = nsresult::NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT,
+
+  NS_ERROR_FACTORY_EXISTS = nsresult::NS_ERROR_FACTORY_EXISTS,
+
+
+
+
+
+
+
+  NS_ERROR_CANNOT_CONVERT_DATA = nsresult::NS_ERROR_CANNOT_CONVERT_DATA,
+  NS_ERROR_OBJECT_IS_IMMUTABLE = nsresult::NS_ERROR_OBJECT_IS_IMMUTABLE,
+  NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = nsresult::NS_ERROR_LOSS_OF_SIGNIFICANT_DATA,
+
+  NS_ERROR_NOT_SAME_THREAD = nsresult::NS_ERROR_NOT_SAME_THREAD,
+
+
+  NS_ERROR_ILLEGAL_DURING_SHUTDOWN = nsresult::NS_ERROR_ILLEGAL_DURING_SHUTDOWN,
+  NS_ERROR_SERVICE_NOT_AVAILABLE = nsresult::NS_ERROR_SERVICE_NOT_AVAILABLE,
+
+  NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = nsresult::NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA,
+
+  NS_SUCCESS_INTERRUPTED_TRAVERSE = nsresult::NS_SUCCESS_INTERRUPTED_TRAVERSE,
+
+  NS_ERROR_SERVICE_NOT_FOUND = nsresult::NS_ERROR_SERVICE_NOT_FOUND,
+
+  NS_ERROR_SERVICE_IN_USE = nsresult::NS_ERROR_SERVICE_IN_USE,
+# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_BASE_STREAM_CLOSED = nsresult::NS_BASE_STREAM_CLOSED,
+
+  NS_BASE_STREAM_OSERROR = nsresult::NS_BASE_STREAM_OSERROR,
+
+  NS_BASE_STREAM_ILLEGAL_ARGS = nsresult::NS_BASE_STREAM_ILLEGAL_ARGS,
+
+  NS_BASE_STREAM_NO_CONVERTER = nsresult::NS_BASE_STREAM_NO_CONVERTER,
+
+  NS_BASE_STREAM_BAD_CONVERSION = nsresult::NS_BASE_STREAM_BAD_CONVERSION,
+  NS_BASE_STREAM_WOULD_BLOCK = nsresult::NS_BASE_STREAM_WOULD_BLOCK,
+# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = nsresult::NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE,
+
+  NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = nsresult::NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND,
+
+  NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = nsresult::NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE,
+
+  NS_ERROR_GFX_PRINTER_STARTDOC = nsresult::NS_ERROR_GFX_PRINTER_STARTDOC,
+
+  NS_ERROR_GFX_PRINTER_ENDDOC = nsresult::NS_ERROR_GFX_PRINTER_ENDDOC,
+
+  NS_ERROR_GFX_PRINTER_STARTPAGE = nsresult::NS_ERROR_GFX_PRINTER_STARTPAGE,
+
+  NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = nsresult::NS_ERROR_GFX_PRINTER_DOC_IS_BUSY,
+
+
+  NS_ERROR_GFX_CMAP_MALFORMED = nsresult::NS_ERROR_GFX_CMAP_MALFORMED,
+# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_SUCCESS_EVENT_CONSUMED = nsresult::NS_SUCCESS_EVENT_CONSUMED,
+
+
+
+
+  NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = nsresult::NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY,
+# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_BINDING_SUCCEEDED = nsresult::NS_BINDING_SUCCEEDED,
+
+
+  NS_BINDING_FAILED = nsresult::NS_BINDING_FAILED,
+
+  NS_BINDING_ABORTED = nsresult::NS_BINDING_ABORTED,
+
+
+
+
+
+  NS_BINDING_REDIRECTED = nsresult::NS_BINDING_REDIRECTED,
+
+
+
+
+
+  NS_BINDING_RETARGETED = nsresult::NS_BINDING_RETARGETED,
+
+
+
+
+
+  NS_ERROR_MALFORMED_URI = nsresult::NS_ERROR_MALFORMED_URI,
+
+
+
+  NS_ERROR_IN_PROGRESS = nsresult::NS_ERROR_IN_PROGRESS,
+
+
+
+
+  NS_ERROR_NO_CONTENT = nsresult::NS_ERROR_NO_CONTENT,
+
+  NS_ERROR_UNKNOWN_PROTOCOL = nsresult::NS_ERROR_UNKNOWN_PROTOCOL,
+
+
+  NS_ERROR_INVALID_CONTENT_ENCODING = nsresult::NS_ERROR_INVALID_CONTENT_ENCODING,
+
+
+
+  NS_ERROR_CORRUPTED_CONTENT = nsresult::NS_ERROR_CORRUPTED_CONTENT,
+
+
+
+  NS_ERROR_INVALID_SIGNATURE = nsresult::NS_ERROR_INVALID_SIGNATURE,
+
+
+
+  NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = nsresult::NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY,
+
+
+  NS_ERROR_ALREADY_OPENED = nsresult::NS_ERROR_ALREADY_OPENED,
+
+
+
+
+  NS_ERROR_ALREADY_CONNECTED = nsresult::NS_ERROR_ALREADY_CONNECTED,
+
+  NS_ERROR_NOT_CONNECTED = nsresult::NS_ERROR_NOT_CONNECTED,
+
+
+  NS_ERROR_CONNECTION_REFUSED = nsresult::NS_ERROR_CONNECTION_REFUSED,
+
+  NS_ERROR_NET_TIMEOUT = nsresult::NS_ERROR_NET_TIMEOUT,
+
+
+  NS_ERROR_OFFLINE = nsresult::NS_ERROR_OFFLINE,
+
+
+
+  NS_ERROR_PORT_ACCESS_NOT_ALLOWED = nsresult::NS_ERROR_PORT_ACCESS_NOT_ALLOWED,
+
+  NS_ERROR_NET_RESET = nsresult::NS_ERROR_NET_RESET,
+
+  NS_ERROR_NET_INTERRUPT = nsresult::NS_ERROR_NET_INTERRUPT,
+
+  NS_ERROR_PROXY_CONNECTION_REFUSED = nsresult::NS_ERROR_PROXY_CONNECTION_REFUSED,
+
+  NS_ERROR_NET_PARTIAL_TRANSFER = nsresult::NS_ERROR_NET_PARTIAL_TRANSFER,
+
+  NS_ERROR_NET_INADEQUATE_SECURITY = nsresult::NS_ERROR_NET_INADEQUATE_SECURITY,
+
+
+
+
+
+  NS_ERROR_NOT_RESUMABLE = nsresult::NS_ERROR_NOT_RESUMABLE,
+
+  NS_ERROR_REDIRECT_LOOP = nsresult::NS_ERROR_REDIRECT_LOOP,
+
+
+  NS_ERROR_ENTITY_CHANGED = nsresult::NS_ERROR_ENTITY_CHANGED,
+
+
+
+  NS_ERROR_UNSAFE_CONTENT_TYPE = nsresult::NS_ERROR_UNSAFE_CONTENT_TYPE,
+
+
+  NS_ERROR_REMOTE_XUL = nsresult::NS_ERROR_REMOTE_XUL,
+
+  NS_ERROR_LOAD_SHOWED_ERRORPAGE = nsresult::NS_ERROR_LOAD_SHOWED_ERRORPAGE,
+
+
+  NS_ERROR_DOCSHELL_DYING = nsresult::NS_ERROR_DOCSHELL_DYING,
+
+
+
+
+  NS_ERROR_FTP_LOGIN = nsresult::NS_ERROR_FTP_LOGIN,
+  NS_ERROR_FTP_CWD = nsresult::NS_ERROR_FTP_CWD,
+  NS_ERROR_FTP_PASV = nsresult::NS_ERROR_FTP_PASV,
+  NS_ERROR_FTP_PWD = nsresult::NS_ERROR_FTP_PWD,
+  NS_ERROR_FTP_LIST = nsresult::NS_ERROR_FTP_LIST,
+
+
+
+
+
+  NS_ERROR_UNKNOWN_HOST = nsresult::NS_ERROR_UNKNOWN_HOST,
+
+
+  NS_ERROR_DNS_LOOKUP_QUEUE_FULL = nsresult::NS_ERROR_DNS_LOOKUP_QUEUE_FULL,
+
+
+
+  NS_ERROR_UNKNOWN_PROXY_HOST = nsresult::NS_ERROR_UNKNOWN_PROXY_HOST,
+
+
+
+
+
+  NS_ERROR_UNKNOWN_SOCKET_TYPE = nsresult::NS_ERROR_UNKNOWN_SOCKET_TYPE,
+
+  NS_ERROR_SOCKET_CREATE_FAILED = nsresult::NS_ERROR_SOCKET_CREATE_FAILED,
+
+  NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = nsresult::NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED,
+
+  NS_ERROR_SOCKET_ADDRESS_IN_USE = nsresult::NS_ERROR_SOCKET_ADDRESS_IN_USE,
+
+
+  NS_ERROR_CACHE_KEY_NOT_FOUND = nsresult::NS_ERROR_CACHE_KEY_NOT_FOUND,
+  NS_ERROR_CACHE_DATA_IS_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_STREAM,
+  NS_ERROR_CACHE_DATA_IS_NOT_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_NOT_STREAM,
+  NS_ERROR_CACHE_WAIT_FOR_VALIDATION = nsresult::NS_ERROR_CACHE_WAIT_FOR_VALIDATION,
+  NS_ERROR_CACHE_ENTRY_DOOMED = nsresult::NS_ERROR_CACHE_ENTRY_DOOMED,
+  NS_ERROR_CACHE_READ_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_READ_ACCESS_DENIED,
+  NS_ERROR_CACHE_WRITE_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_WRITE_ACCESS_DENIED,
+  NS_ERROR_CACHE_IN_USE = nsresult::NS_ERROR_CACHE_IN_USE,
+
+
+  NS_ERROR_DOCUMENT_NOT_CACHED = nsresult::NS_ERROR_DOCUMENT_NOT_CACHED,
+
+
+
+
+
+  NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = nsresult::NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS,
+
+  NS_ERROR_HOST_IS_IP_ADDRESS = nsresult::NS_ERROR_HOST_IS_IP_ADDRESS,
+
+
+
+
+
+
+
+  NS_SUCCESS_ADOPTED_DATA = nsresult::NS_SUCCESS_ADOPTED_DATA,
+
+
+  NS_NET_STATUS_BEGIN_FTP_TRANSACTION = nsresult::NS_NET_STATUS_BEGIN_FTP_TRANSACTION,
+  NS_NET_STATUS_END_FTP_TRANSACTION = nsresult::NS_NET_STATUS_END_FTP_TRANSACTION,
+
+
+
+
+  NS_SUCCESS_AUTH_FINISHED = nsresult::NS_SUCCESS_AUTH_FINISHED,
+
+
+
+
+  NS_NET_STATUS_READING = nsresult::NS_NET_STATUS_READING,
+  NS_NET_STATUS_WRITING = nsresult::NS_NET_STATUS_WRITING,
+
+
+  NS_NET_STATUS_RESOLVING_HOST = nsresult::NS_NET_STATUS_RESOLVING_HOST,
+  NS_NET_STATUS_RESOLVED_HOST = nsresult::NS_NET_STATUS_RESOLVED_HOST,
+  NS_NET_STATUS_CONNECTING_TO = nsresult::NS_NET_STATUS_CONNECTING_TO,
+  NS_NET_STATUS_CONNECTED_TO = nsresult::NS_NET_STATUS_CONNECTED_TO,
+  NS_NET_STATUS_TLS_HANDSHAKE_STARTING = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_STARTING,
+  NS_NET_STATUS_TLS_HANDSHAKE_ENDED = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_ENDED,
+  NS_NET_STATUS_SENDING_TO = nsresult::NS_NET_STATUS_SENDING_TO,
+  NS_NET_STATUS_WAITING_FOR = nsresult::NS_NET_STATUS_WAITING_FOR,
+  NS_NET_STATUS_RECEIVING_FROM = nsresult::NS_NET_STATUS_RECEIVING_FROM,
+
+
+
+  NS_ERROR_INTERCEPTION_FAILED = nsresult::NS_ERROR_INTERCEPTION_FAILED,
+
+
+
+  NS_ERROR_HSTS_PRIMING_TIMEOUT = nsresult::NS_ERROR_HSTS_PRIMING_TIMEOUT,
+
+
+
+
+
+
+
+  NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = nsresult::NS_ERROR_PLUGINS_PLUGINSNOTCHANGED,
+  NS_ERROR_PLUGIN_DISABLED = nsresult::NS_ERROR_PLUGIN_DISABLED,
+  NS_ERROR_PLUGIN_BLOCKLISTED = nsresult::NS_ERROR_PLUGIN_BLOCKLISTED,
+  NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = nsresult::NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED,
+  NS_ERROR_PLUGIN_CLICKTOPLAY = nsresult::NS_ERROR_PLUGIN_CLICKTOPLAY,
+  NS_PLUGIN_INIT_PENDING = nsresult::NS_PLUGIN_INIT_PENDING,
+# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_TABLELAYOUT_CELL_NOT_FOUND = nsresult::NS_TABLELAYOUT_CELL_NOT_FOUND,
+
+  NS_POSITION_BEFORE_TABLE = nsresult::NS_POSITION_BEFORE_TABLE,
+
+
+  NS_STATE_PROPERTY_EXISTS = nsresult::NS_STATE_PROPERTY_EXISTS,
+
+  NS_STATE_PROPERTY_NOT_THERE = nsresult::NS_STATE_PROPERTY_NOT_THERE,
+
+
+
+
+
+
+
+  NS_ERROR_HTMLPARSER_CONTINUE = nsresult::NS_ERROR_HTMLPARSER_CONTINUE,
+
+  NS_ERROR_HTMLPARSER_EOF = nsresult::NS_ERROR_HTMLPARSER_EOF,
+  NS_ERROR_HTMLPARSER_UNKNOWN = nsresult::NS_ERROR_HTMLPARSER_UNKNOWN,
+  NS_ERROR_HTMLPARSER_CANTPROPAGATE = nsresult::NS_ERROR_HTMLPARSER_CANTPROPAGATE,
+  NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = nsresult::NS_ERROR_HTMLPARSER_CONTEXTMISMATCH,
+  NS_ERROR_HTMLPARSER_BADFILENAME = nsresult::NS_ERROR_HTMLPARSER_BADFILENAME,
+  NS_ERROR_HTMLPARSER_BADURL = nsresult::NS_ERROR_HTMLPARSER_BADURL,
+  NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = nsresult::NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT,
+  NS_ERROR_HTMLPARSER_INTERRUPTED = nsresult::NS_ERROR_HTMLPARSER_INTERRUPTED,
+  NS_ERROR_HTMLPARSER_BLOCK = nsresult::NS_ERROR_HTMLPARSER_BLOCK,
+  NS_ERROR_HTMLPARSER_BADTOKENIZER = nsresult::NS_ERROR_HTMLPARSER_BADTOKENIZER,
+  NS_ERROR_HTMLPARSER_BADATTRIBUTE = nsresult::NS_ERROR_HTMLPARSER_BADATTRIBUTE,
+  NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = nsresult::NS_ERROR_HTMLPARSER_UNRESOLVEDDTD,
+  NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = nsresult::NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT,
+  NS_ERROR_HTMLPARSER_BADDTD = nsresult::NS_ERROR_HTMLPARSER_BADDTD,
+  NS_ERROR_HTMLPARSER_BADCONTEXT = nsresult::NS_ERROR_HTMLPARSER_BADCONTEXT,
+  NS_ERROR_HTMLPARSER_STOPPARSING = nsresult::NS_ERROR_HTMLPARSER_STOPPARSING,
+  NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = nsresult::NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL,
+  NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = nsresult::NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP,
+  NS_ERROR_HTMLPARSER_FAKE_ENDTAG = nsresult::NS_ERROR_HTMLPARSER_FAKE_ENDTAG,
+  NS_ERROR_HTMLPARSER_INVALID_COMMENT = nsresult::NS_ERROR_HTMLPARSER_INVALID_COMMENT,
+
+  NS_HTMLTOKENS_NOT_AN_ENTITY = nsresult::NS_HTMLTOKENS_NOT_AN_ENTITY,
+  NS_HTMLPARSER_VALID_META_CHARSET = nsresult::NS_HTMLPARSER_VALID_META_CHARSET,
+# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_RDF_ASSERTION_ACCEPTED = nsresult::NS_RDF_ASSERTION_ACCEPTED,
+
+
+  NS_RDF_CURSOR_EMPTY = nsresult::NS_RDF_CURSOR_EMPTY,
+
+
+  NS_RDF_NO_VALUE = nsresult::NS_RDF_NO_VALUE,
+
+
+
+  NS_RDF_ASSERTION_REJECTED = nsresult::NS_RDF_ASSERTION_REJECTED,
+
+  NS_RDF_STOP_VISIT = nsresult::NS_RDF_STOP_VISIT,
+
+
+
+
+
+
+
+  NS_ERROR_UCONV_NOCONV = nsresult::NS_ERROR_UCONV_NOCONV,
+  NS_ERROR_UDEC_ILLEGALINPUT = nsresult::NS_ERROR_UDEC_ILLEGALINPUT,
+
+  NS_SUCCESS_USING_FALLBACK_LOCALE = nsresult::NS_SUCCESS_USING_FALLBACK_LOCALE,
+  NS_OK_UDEC_EXACTLENGTH = nsresult::NS_OK_UDEC_EXACTLENGTH,
+  NS_OK_UDEC_MOREINPUT = nsresult::NS_OK_UDEC_MOREINPUT,
+  NS_OK_UDEC_MOREOUTPUT = nsresult::NS_OK_UDEC_MOREOUTPUT,
+  NS_OK_UDEC_NOBOMFOUND = nsresult::NS_OK_UDEC_NOBOMFOUND,
+  NS_OK_UENC_EXACTLENGTH = nsresult::NS_OK_UENC_EXACTLENGTH,
+  NS_OK_UENC_MOREOUTPUT = nsresult::NS_OK_UENC_MOREOUTPUT,
+  NS_ERROR_UENC_NOMAPPING = nsresult::NS_ERROR_UENC_NOMAPPING,
+  NS_OK_UENC_MOREINPUT = nsresult::NS_OK_UENC_MOREINPUT,
+
+
+  NS_EXACT_LENGTH = nsresult::NS_EXACT_LENGTH,
+  NS_PARTIAL_MORE_INPUT = nsresult::NS_PARTIAL_MORE_INPUT,
+  NS_PARTIAL_MORE_OUTPUT = nsresult::NS_PARTIAL_MORE_OUTPUT,
+  NS_ERROR_ILLEGAL_INPUT = nsresult::NS_ERROR_ILLEGAL_INPUT,
+# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_FILE_UNRECOGNIZED_PATH = nsresult::NS_ERROR_FILE_UNRECOGNIZED_PATH,
+  NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = nsresult::NS_ERROR_FILE_UNRESOLVABLE_SYMLINK,
+  NS_ERROR_FILE_EXECUTION_FAILED = nsresult::NS_ERROR_FILE_EXECUTION_FAILED,
+  NS_ERROR_FILE_UNKNOWN_TYPE = nsresult::NS_ERROR_FILE_UNKNOWN_TYPE,
+  NS_ERROR_FILE_DESTINATION_NOT_DIR = nsresult::NS_ERROR_FILE_DESTINATION_NOT_DIR,
+  NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = nsresult::NS_ERROR_FILE_TARGET_DOES_NOT_EXIST,
+  NS_ERROR_FILE_COPY_OR_MOVE_FAILED = nsresult::NS_ERROR_FILE_COPY_OR_MOVE_FAILED,
+  NS_ERROR_FILE_ALREADY_EXISTS = nsresult::NS_ERROR_FILE_ALREADY_EXISTS,
+  NS_ERROR_FILE_INVALID_PATH = nsresult::NS_ERROR_FILE_INVALID_PATH,
+  NS_ERROR_FILE_DISK_FULL = nsresult::NS_ERROR_FILE_DISK_FULL,
+  NS_ERROR_FILE_CORRUPTED = nsresult::NS_ERROR_FILE_CORRUPTED,
+  NS_ERROR_FILE_NOT_DIRECTORY = nsresult::NS_ERROR_FILE_NOT_DIRECTORY,
+  NS_ERROR_FILE_IS_DIRECTORY = nsresult::NS_ERROR_FILE_IS_DIRECTORY,
+  NS_ERROR_FILE_IS_LOCKED = nsresult::NS_ERROR_FILE_IS_LOCKED,
+  NS_ERROR_FILE_TOO_BIG = nsresult::NS_ERROR_FILE_TOO_BIG,
+  NS_ERROR_FILE_NO_DEVICE_SPACE = nsresult::NS_ERROR_FILE_NO_DEVICE_SPACE,
+  NS_ERROR_FILE_NAME_TOO_LONG = nsresult::NS_ERROR_FILE_NAME_TOO_LONG,
+  NS_ERROR_FILE_NOT_FOUND = nsresult::NS_ERROR_FILE_NOT_FOUND,
+  NS_ERROR_FILE_READ_ONLY = nsresult::NS_ERROR_FILE_READ_ONLY,
+  NS_ERROR_FILE_DIR_NOT_EMPTY = nsresult::NS_ERROR_FILE_DIR_NOT_EMPTY,
+  NS_ERROR_FILE_ACCESS_DENIED = nsresult::NS_ERROR_FILE_ACCESS_DENIED,
+
+  NS_SUCCESS_FILE_DIRECTORY_EMPTY = nsresult::NS_SUCCESS_FILE_DIRECTORY_EMPTY,
+
+  NS_SUCCESS_AGGREGATE_RESULT = nsresult::NS_SUCCESS_AGGREGATE_RESULT,
+# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INDEX_SIZE_ERR = nsresult::NS_ERROR_DOM_INDEX_SIZE_ERR,
+  NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = nsresult::NS_ERROR_DOM_HIERARCHY_REQUEST_ERR,
+  NS_ERROR_DOM_WRONG_DOCUMENT_ERR = nsresult::NS_ERROR_DOM_WRONG_DOCUMENT_ERR,
+  NS_ERROR_DOM_INVALID_CHARACTER_ERR = nsresult::NS_ERROR_DOM_INVALID_CHARACTER_ERR,
+  NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR,
+  NS_ERROR_DOM_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_NOT_FOUND_ERR,
+  NS_ERROR_DOM_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_NOT_SUPPORTED_ERR,
+  NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = nsresult::NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR,
+  NS_ERROR_DOM_INVALID_STATE_ERR = nsresult::NS_ERROR_DOM_INVALID_STATE_ERR,
+  NS_ERROR_DOM_SYNTAX_ERR = nsresult::NS_ERROR_DOM_SYNTAX_ERR,
+  NS_ERROR_DOM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_INVALID_MODIFICATION_ERR,
+  NS_ERROR_DOM_NAMESPACE_ERR = nsresult::NS_ERROR_DOM_NAMESPACE_ERR,
+  NS_ERROR_DOM_INVALID_ACCESS_ERR = nsresult::NS_ERROR_DOM_INVALID_ACCESS_ERR,
+  NS_ERROR_DOM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_TYPE_MISMATCH_ERR,
+  NS_ERROR_DOM_SECURITY_ERR = nsresult::NS_ERROR_DOM_SECURITY_ERR,
+  NS_ERROR_DOM_NETWORK_ERR = nsresult::NS_ERROR_DOM_NETWORK_ERR,
+  NS_ERROR_DOM_ABORT_ERR = nsresult::NS_ERROR_DOM_ABORT_ERR,
+  NS_ERROR_DOM_URL_MISMATCH_ERR = nsresult::NS_ERROR_DOM_URL_MISMATCH_ERR,
+  NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = nsresult::NS_ERROR_DOM_QUOTA_EXCEEDED_ERR,
+  NS_ERROR_DOM_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_TIMEOUT_ERR,
+  NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = nsresult::NS_ERROR_DOM_INVALID_NODE_TYPE_ERR,
+  NS_ERROR_DOM_DATA_CLONE_ERR = nsresult::NS_ERROR_DOM_DATA_CLONE_ERR,
+
+  NS_ERROR_TYPE_ERR = nsresult::NS_ERROR_TYPE_ERR,
+  NS_ERROR_RANGE_ERR = nsresult::NS_ERROR_RANGE_ERR,
+
+  NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR,
+  NS_ERROR_DOM_INVALID_POINTER_ERR = nsresult::NS_ERROR_DOM_INVALID_POINTER_ERR,
+
+  NS_ERROR_DOM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_UNKNOWN_ERR,
+  NS_ERROR_DOM_DATA_ERR = nsresult::NS_ERROR_DOM_DATA_ERR,
+  NS_ERROR_DOM_OPERATION_ERR = nsresult::NS_ERROR_DOM_OPERATION_ERR,
+
+  NS_ERROR_DOM_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NOT_ALLOWED_ERR,
+
+  NS_ERROR_DOM_SECMAN_ERR = nsresult::NS_ERROR_DOM_SECMAN_ERR,
+  NS_ERROR_DOM_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_WRONG_TYPE_ERR,
+  NS_ERROR_DOM_NOT_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_OBJECT_ERR,
+  NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_XPC_OBJECT_ERR,
+  NS_ERROR_DOM_NOT_NUMBER_ERR = nsresult::NS_ERROR_DOM_NOT_NUMBER_ERR,
+  NS_ERROR_DOM_NOT_BOOLEAN_ERR = nsresult::NS_ERROR_DOM_NOT_BOOLEAN_ERR,
+  NS_ERROR_DOM_NOT_FUNCTION_ERR = nsresult::NS_ERROR_DOM_NOT_FUNCTION_ERR,
+  NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = nsresult::NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR,
+  NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = nsresult::NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN,
+  NS_ERROR_DOM_PROP_ACCESS_DENIED = nsresult::NS_ERROR_DOM_PROP_ACCESS_DENIED,
+  NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = nsresult::NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED,
+  NS_ERROR_DOM_BAD_URI = nsresult::NS_ERROR_DOM_BAD_URI,
+  NS_ERROR_DOM_RETVAL_UNDEFINED = nsresult::NS_ERROR_DOM_RETVAL_UNDEFINED,
+  NS_ERROR_DOM_QUOTA_REACHED = nsresult::NS_ERROR_DOM_QUOTA_REACHED,
+
+
+  NS_ERROR_UNCATCHABLE_EXCEPTION = nsresult::NS_ERROR_UNCATCHABLE_EXCEPTION,
+
+  NS_ERROR_DOM_MALFORMED_URI = nsresult::NS_ERROR_DOM_MALFORMED_URI,
+  NS_ERROR_DOM_INVALID_HEADER_NAME = nsresult::NS_ERROR_DOM_INVALID_HEADER_NAME,
+
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT,
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED,
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING,
+  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE,
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML,
+  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT,
+  NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC,
+  NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC,
+
+
+
+
+
+  NS_SUCCESS_DOM_NO_OPERATION = nsresult::NS_SUCCESS_DOM_NO_OPERATION,
+
+
+
+
+
+
+  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW,
+
+
+
+
+
+
+  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE,
+
+
+
+
+
+
+
+  NS_IMAGELIB_SUCCESS_LOAD_FINISHED = nsresult::NS_IMAGELIB_SUCCESS_LOAD_FINISHED,
+  NS_IMAGELIB_CHANGING_OWNER = nsresult::NS_IMAGELIB_CHANGING_OWNER,
+
+  NS_IMAGELIB_ERROR_FAILURE = nsresult::NS_IMAGELIB_ERROR_FAILURE,
+  NS_IMAGELIB_ERROR_NO_DECODER = nsresult::NS_IMAGELIB_ERROR_NO_DECODER,
+  NS_IMAGELIB_ERROR_NOT_FINISHED = nsresult::NS_IMAGELIB_ERROR_NOT_FINISHED,
+  NS_IMAGELIB_ERROR_NO_ENCODER = nsresult::NS_IMAGELIB_ERROR_NO_ENCODER,
+
+
+
+
+
+
+
+  NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = nsresult::NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND,
+  NS_SUCCESS_EDITOR_FOUND_TARGET = nsresult::NS_SUCCESS_EDITOR_FOUND_TARGET,
+
+
+
+
+
+
+
+  NS_ERROR_XPC_NOT_ENOUGH_ARGS = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ARGS,
+  NS_ERROR_XPC_NEED_OUT_OBJECT = nsresult::NS_ERROR_XPC_NEED_OUT_OBJECT,
+  NS_ERROR_XPC_CANT_SET_OUT_VAL = nsresult::NS_ERROR_XPC_CANT_SET_OUT_VAL,
+  NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_NATIVE_RETURNED_FAILURE,
+  NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_INTERFACE_INFO,
+  NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO,
+  NS_ERROR_XPC_CANT_GET_METHOD_INFO = nsresult::NS_ERROR_XPC_CANT_GET_METHOD_INFO,
+  NS_ERROR_XPC_UNEXPECTED = nsresult::NS_ERROR_XPC_UNEXPECTED,
+  NS_ERROR_XPC_BAD_CONVERT_JS = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS,
+  NS_ERROR_XPC_BAD_CONVERT_NATIVE = nsresult::NS_ERROR_XPC_BAD_CONVERT_NATIVE,
+  NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF,
+  NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = nsresult::NS_ERROR_XPC_BAD_OP_ON_WN_PROTO,
+  NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = nsresult::NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN,
+  NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN,
+  NS_ERROR_XPC_CANT_WATCH_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_WATCH_WN_STATIC,
+  NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_EXPORT_WN_STATIC,
+  NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED,
+  NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED,
+  NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE,
+  NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE,
+  NS_ERROR_XPC_CI_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_CI_RETURNED_FAILURE,
+  NS_ERROR_XPC_GS_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_GS_RETURNED_FAILURE,
+  NS_ERROR_XPC_BAD_CID = nsresult::NS_ERROR_XPC_BAD_CID,
+  NS_ERROR_XPC_BAD_IID = nsresult::NS_ERROR_XPC_BAD_IID,
+  NS_ERROR_XPC_CANT_CREATE_WN = nsresult::NS_ERROR_XPC_CANT_CREATE_WN,
+  NS_ERROR_XPC_JS_THREW_EXCEPTION = nsresult::NS_ERROR_XPC_JS_THREW_EXCEPTION,
+  NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT,
+  NS_ERROR_XPC_JS_THREW_JS_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_JS_OBJECT,
+  NS_ERROR_XPC_JS_THREW_NULL = nsresult::NS_ERROR_XPC_JS_THREW_NULL,
+  NS_ERROR_XPC_JS_THREW_STRING = nsresult::NS_ERROR_XPC_JS_THREW_STRING,
+  NS_ERROR_XPC_JS_THREW_NUMBER = nsresult::NS_ERROR_XPC_JS_THREW_NUMBER,
+  NS_ERROR_XPC_JAVASCRIPT_ERROR = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR,
+  NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS,
+  NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY,
+  NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY,
+  NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY,
+  NS_ERROR_XPC_CANT_GET_ARRAY_INFO = nsresult::NS_ERROR_XPC_CANT_GET_ARRAY_INFO,
+  NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = nsresult::NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING,
+  NS_ERROR_XPC_SECURITY_MANAGER_VETO = nsresult::NS_ERROR_XPC_SECURITY_MANAGER_VETO,
+  NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = nsresult::NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE,
+  NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = nsresult::NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS,
+  NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = nsresult::NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT,
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT,
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE,
+  NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD,
+  NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = nsresult::NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE,
+  NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = nsresult::NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED,
+  NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = nsresult::NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED,
+  NS_ERROR_XPC_BAD_ID_STRING = nsresult::NS_ERROR_XPC_BAD_ID_STRING,
+  NS_ERROR_XPC_BAD_INITIALIZER_NAME = nsresult::NS_ERROR_XPC_BAD_INITIALIZER_NAME,
+  NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = nsresult::NS_ERROR_XPC_HAS_BEEN_SHUTDOWN,
+  NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN,
+  NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL,
+  NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = nsresult::NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE,
+# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_LAUNCHED_CHILD_PROCESS = nsresult::NS_ERROR_LAUNCHED_CHILD_PROCESS,
+# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_CSP_FORM_ACTION_VIOLATION = nsresult::NS_ERROR_CSP_FORM_ACTION_VIOLATION,
+  NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = nsresult::NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION,
+
+
+  NS_ERROR_SRI_CORRUPT = nsresult::NS_ERROR_SRI_CORRUPT,
+  NS_ERROR_SRI_DISABLED = nsresult::NS_ERROR_SRI_DISABLED,
+  NS_ERROR_SRI_NOT_ELIGIBLE = nsresult::NS_ERROR_SRI_NOT_ELIGIBLE,
+  NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = nsresult::NS_ERROR_SRI_UNEXPECTED_HASH_TYPE,
+  NS_ERROR_SRI_IMPORT = nsresult::NS_ERROR_SRI_IMPORT,
+
+
+
+  NS_ERROR_CMS_VERIFY_NOT_SIGNED = nsresult::NS_ERROR_CMS_VERIFY_NOT_SIGNED,
+  NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = nsresult::NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO,
+  NS_ERROR_CMS_VERIFY_BAD_DIGEST = nsresult::NS_ERROR_CMS_VERIFY_BAD_DIGEST,
+  NS_ERROR_CMS_VERIFY_NOCERT = nsresult::NS_ERROR_CMS_VERIFY_NOCERT,
+  NS_ERROR_CMS_VERIFY_UNTRUSTED = nsresult::NS_ERROR_CMS_VERIFY_UNTRUSTED,
+  NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = nsresult::NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED,
+  NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = nsresult::NS_ERROR_CMS_VERIFY_ERROR_PROCESSING,
+  NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_BAD_SIGNATURE,
+  NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH,
+  NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO,
+  NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO,
+  NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE,
+  NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_HEADER_MISMATCH,
+  NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = nsresult::NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED,
+  NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = nsresult::NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS,
+  NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = nsresult::NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG,
+  NS_ERROR_CMS_ENCRYPT_INCOMPLETE = nsresult::NS_ERROR_CMS_ENCRYPT_INCOMPLETE,
+# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INVALID_EXPRESSION_ERR = nsresult::NS_ERROR_DOM_INVALID_EXPRESSION_ERR,
+  NS_ERROR_DOM_TYPE_ERR = nsresult::NS_ERROR_DOM_TYPE_ERR,
+
+
+
+
+
+
+
+  NS_ERROR_WONT_HANDLE_CONTENT = nsresult::NS_ERROR_WONT_HANDLE_CONTENT,
+
+
+  NS_ERROR_MALWARE_URI = nsresult::NS_ERROR_MALWARE_URI,
+  NS_ERROR_PHISHING_URI = nsresult::NS_ERROR_PHISHING_URI,
+  NS_ERROR_TRACKING_URI = nsresult::NS_ERROR_TRACKING_URI,
+  NS_ERROR_UNWANTED_URI = nsresult::NS_ERROR_UNWANTED_URI,
+  NS_ERROR_BLOCKED_URI = nsresult::NS_ERROR_BLOCKED_URI,
+
+
+  NS_ERROR_SAVE_LINK_AS_TIMEOUT = nsresult::NS_ERROR_SAVE_LINK_AS_TIMEOUT,
+
+
+  NS_ERROR_PARSED_DATA_CACHED = nsresult::NS_ERROR_PARSED_DATA_CACHED,
+
+
+
+  NS_REFRESHURI_HEADER_FOUND = nsresult::NS_REFRESHURI_HEADER_FOUND,
+# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_IMAGE_SRC_CHANGED = nsresult::NS_ERROR_IMAGE_SRC_CHANGED,
+  NS_ERROR_IMAGE_BLOCKED = nsresult::NS_ERROR_IMAGE_BLOCKED,
+
+  NS_ERROR_CONTENT_BLOCKED = nsresult::NS_ERROR_CONTENT_BLOCKED,
+  NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_ERROR_CONTENT_BLOCKED_SHOW_ALT,
+
+  NS_PROPTABLE_PROP_NOT_THERE = nsresult::NS_PROPTABLE_PROP_NOT_THERE,
+
+  NS_ERROR_XBL_BLOCKED = nsresult::NS_ERROR_XBL_BLOCKED,
+
+  NS_ERROR_CONTENT_CRASHED = nsresult::NS_ERROR_CONTENT_CRASHED,
+
+
+  NS_HTML_STYLE_PROPERTY_NOT_THERE = nsresult::NS_HTML_STYLE_PROPERTY_NOT_THERE,
+  NS_CONTENT_BLOCKED = nsresult::NS_CONTENT_BLOCKED,
+  NS_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_CONTENT_BLOCKED_SHOW_ALT,
+  NS_PROPTABLE_PROP_OVERWRITTEN = nsresult::NS_PROPTABLE_PROP_OVERWRITTEN,
+
+  NS_FINDBROADCASTER_NOT_FOUND = nsresult::NS_FINDBROADCASTER_NOT_FOUND,
+  NS_FINDBROADCASTER_FOUND = nsresult::NS_FINDBROADCASTER_FOUND,
+  NS_FINDBROADCASTER_AWAIT_OVERLAYS = nsresult::NS_FINDBROADCASTER_AWAIT_OVERLAYS,
+
+
+
+
+
+
+
+  NS_ERROR_XPATH_INVALID_ARG = nsresult::NS_ERROR_XPATH_INVALID_ARG,
+
+  NS_ERROR_XSLT_PARSE_FAILURE = nsresult::NS_ERROR_XSLT_PARSE_FAILURE,
+  NS_ERROR_XPATH_PARSE_FAILURE = nsresult::NS_ERROR_XPATH_PARSE_FAILURE,
+  NS_ERROR_XSLT_ALREADY_SET = nsresult::NS_ERROR_XSLT_ALREADY_SET,
+  NS_ERROR_XSLT_EXECUTION_FAILURE = nsresult::NS_ERROR_XSLT_EXECUTION_FAILURE,
+  NS_ERROR_XPATH_UNKNOWN_FUNCTION = nsresult::NS_ERROR_XPATH_UNKNOWN_FUNCTION,
+  NS_ERROR_XSLT_BAD_RECURSION = nsresult::NS_ERROR_XSLT_BAD_RECURSION,
+  NS_ERROR_XSLT_BAD_VALUE = nsresult::NS_ERROR_XSLT_BAD_VALUE,
+  NS_ERROR_XSLT_NODESET_EXPECTED = nsresult::NS_ERROR_XSLT_NODESET_EXPECTED,
+  NS_ERROR_XSLT_ABORTED = nsresult::NS_ERROR_XSLT_ABORTED,
+  NS_ERROR_XSLT_NETWORK_ERROR = nsresult::NS_ERROR_XSLT_NETWORK_ERROR,
+  NS_ERROR_XSLT_WRONG_MIME_TYPE = nsresult::NS_ERROR_XSLT_WRONG_MIME_TYPE,
+  NS_ERROR_XSLT_LOAD_RECURSION = nsresult::NS_ERROR_XSLT_LOAD_RECURSION,
+  NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = nsresult::NS_ERROR_XPATH_BAD_ARGUMENT_COUNT,
+  NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = nsresult::NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION,
+  NS_ERROR_XPATH_PAREN_EXPECTED = nsresult::NS_ERROR_XPATH_PAREN_EXPECTED,
+  NS_ERROR_XPATH_INVALID_AXIS = nsresult::NS_ERROR_XPATH_INVALID_AXIS,
+  NS_ERROR_XPATH_NO_NODE_TYPE_TEST = nsresult::NS_ERROR_XPATH_NO_NODE_TYPE_TEST,
+  NS_ERROR_XPATH_BRACKET_EXPECTED = nsresult::NS_ERROR_XPATH_BRACKET_EXPECTED,
+  NS_ERROR_XPATH_INVALID_VAR_NAME = nsresult::NS_ERROR_XPATH_INVALID_VAR_NAME,
+  NS_ERROR_XPATH_UNEXPECTED_END = nsresult::NS_ERROR_XPATH_UNEXPECTED_END,
+  NS_ERROR_XPATH_OPERATOR_EXPECTED = nsresult::NS_ERROR_XPATH_OPERATOR_EXPECTED,
+  NS_ERROR_XPATH_UNCLOSED_LITERAL = nsresult::NS_ERROR_XPATH_UNCLOSED_LITERAL,
+  NS_ERROR_XPATH_BAD_COLON = nsresult::NS_ERROR_XPATH_BAD_COLON,
+  NS_ERROR_XPATH_BAD_BANG = nsresult::NS_ERROR_XPATH_BAD_BANG,
+  NS_ERROR_XPATH_ILLEGAL_CHAR = nsresult::NS_ERROR_XPATH_ILLEGAL_CHAR,
+  NS_ERROR_XPATH_BINARY_EXPECTED = nsresult::NS_ERROR_XPATH_BINARY_EXPECTED,
+  NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = nsresult::NS_ERROR_XSLT_LOAD_BLOCKED_ERROR,
+  NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = nsresult::NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED,
+  NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = nsresult::NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE,
+  NS_ERROR_XSLT_BAD_NODE_NAME = nsresult::NS_ERROR_XSLT_BAD_NODE_NAME,
+  NS_ERROR_XSLT_VAR_ALREADY_SET = nsresult::NS_ERROR_XSLT_VAR_ALREADY_SET,
+  NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = nsresult::NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED,
+
+  NS_XSLT_GET_NEW_HANDLER = nsresult::NS_XSLT_GET_NEW_HANDLER,
+# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_TRANSPORT_INIT = nsresult::NS_ERROR_TRANSPORT_INIT,
+
+  NS_ERROR_DUPLICATE_HANDLE = nsresult::NS_ERROR_DUPLICATE_HANDLE,
+
+  NS_ERROR_BRIDGE_OPEN_PARENT = nsresult::NS_ERROR_BRIDGE_OPEN_PARENT,
+
+  NS_ERROR_BRIDGE_OPEN_CHILD = nsresult::NS_ERROR_BRIDGE_OPEN_CHILD,
+
+
+
+
+
+
+
+  NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_SVG_WRONG_TYPE_ERR,
+
+  NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = nsresult::NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE,
+# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_STORAGE_BUSY = nsresult::NS_ERROR_STORAGE_BUSY,
+  NS_ERROR_STORAGE_IOERR = nsresult::NS_ERROR_STORAGE_IOERR,
+  NS_ERROR_STORAGE_CONSTRAINT = nsresult::NS_ERROR_STORAGE_CONSTRAINT,
+
+
+
+
+
+
+
+  NS_ERROR_DOM_FILE_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_FOUND_ERR,
+  NS_ERROR_DOM_FILE_NOT_READABLE_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_READABLE_ERR,
+  NS_ERROR_DOM_FILE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILE_ABORT_ERR,
+# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,
+  NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR,
+  NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR,
+  NS_ERROR_DOM_INDEXEDDB_DATA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_DATA_ERR,
+  NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR,
+  NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR,
+  NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_ABORT_ERR,
+  NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR,
+  NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR,
+  NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR,
+  NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_VERSION_ERR,
+  NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR,
+
+
+
+
+
+
+
+  NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR,
+  NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR,
+  NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR,
+  NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_ABORT_ERR,
+  NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR,
+  NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR,
+
+
+
+
+
+
+  NS_ERROR_SIGNED_JAR_NOT_SIGNED = nsresult::NS_ERROR_SIGNED_JAR_NOT_SIGNED,
+  NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY,
+  NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY,
+  NS_ERROR_SIGNED_JAR_ENTRY_MISSING = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_MISSING,
+  NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = nsresult::NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE,
+  NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE,
+  NS_ERROR_SIGNED_JAR_ENTRY_INVALID = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_INVALID,
+  NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_JAR_MANIFEST_INVALID,
+
+
+
+
+
+
+  NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR,
+  NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR,
+  NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR,
+  NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR,
+  NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR,
+  NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR,
+
+
+
+
+
+
+  NS_ERROR_SIGNED_APP_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_APP_MANIFEST_INVALID,
+
+
+
+
+
+
+  NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = nsresult::NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR,
+
+
+
+
+
+
+  NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR,
+  NS_ERROR_DOM_PUSH_DENIED_ERR = nsresult::NS_ERROR_DOM_PUSH_DENIED_ERR,
+  NS_ERROR_DOM_PUSH_ABORT_ERR = nsresult::NS_ERROR_DOM_PUSH_ABORT_ERR,
+  NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = nsresult::NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE,
+  NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_KEY_ERR,
+  NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR,
+
+
+
+
+
+
+
+  NS_ERROR_DOM_MEDIA_ABORT_ERR = nsresult::NS_ERROR_DOM_MEDIA_ABORT_ERR,
+  NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR,
+  NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR,
+
+
+  NS_ERROR_DOM_MEDIA_DECODE_ERR = nsresult::NS_ERROR_DOM_MEDIA_DECODE_ERR,
+  NS_ERROR_DOM_MEDIA_FATAL_ERR = nsresult::NS_ERROR_DOM_MEDIA_FATAL_ERR,
+  NS_ERROR_DOM_MEDIA_METADATA_ERR = nsresult::NS_ERROR_DOM_MEDIA_METADATA_ERR,
+  NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = nsresult::NS_ERROR_DOM_MEDIA_OVERFLOW_ERR,
+  NS_ERROR_DOM_MEDIA_END_OF_STREAM = nsresult::NS_ERROR_DOM_MEDIA_END_OF_STREAM,
+  NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = nsresult::NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA,
+  NS_ERROR_DOM_MEDIA_CANCELED = nsresult::NS_ERROR_DOM_MEDIA_CANCELED,
+  NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = nsresult::NS_ERROR_DOM_MEDIA_MEDIASINK_ERR,
+  NS_ERROR_DOM_MEDIA_DEMUXER_ERR = nsresult::NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
+  NS_ERROR_DOM_MEDIA_CDM_ERR = nsresult::NS_ERROR_DOM_MEDIA_CDM_ERR,
+  NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = nsresult::NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER,
+  NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = nsresult::NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER,
+
+
+  NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = nsresult::NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR,
+
+
+
+
+
+
+  NS_ERROR_UC_UPDATE_UNKNOWN = nsresult::NS_ERROR_UC_UPDATE_UNKNOWN,
+  NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = nsresult::NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX,
+  NS_ERROR_UC_UPDATE_INFINITE_LOOP = nsresult::NS_ERROR_UC_UPDATE_INFINITE_LOOP,
+  NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = nsresult::NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES,
+  NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = nsresult::NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH,
+  NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = nsresult::NS_ERROR_UC_UPDATE_MISSING_CHECKSUM,
+  NS_ERROR_UC_UPDATE_SHUTDOWNING = nsresult::NS_ERROR_UC_UPDATE_SHUTDOWNING,
+  NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = nsresult::NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND,
+  NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = nsresult::NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE,
+  NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = nsresult::NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK,
+  NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = nsresult::NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR,
+
+
+
+
+
+
+
+  NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION,
+
+  NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION,
+
+  NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT,
+
+  NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR,
+
+  NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR,
+# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
+  NS_ERROR_DOWNLOAD_COMPLETE = nsresult::NS_ERROR_DOWNLOAD_COMPLETE,
+
+
+
+  NS_ERROR_DOWNLOAD_NOT_PARTIAL = nsresult::NS_ERROR_DOWNLOAD_NOT_PARTIAL,
+  NS_ERROR_UNORM_MOREOUTPUT = nsresult::NS_ERROR_UNORM_MOREOUTPUT,
+
+  NS_ERROR_DOCSHELL_REQUEST_REJECTED = nsresult::NS_ERROR_DOCSHELL_REQUEST_REJECTED,
+
+
+
+
+  NS_ERROR_DOCUMENT_IS_PRINTMODE = nsresult::NS_ERROR_DOCUMENT_IS_PRINTMODE,
+
+  NS_SUCCESS_DONT_FIXUP = nsresult::NS_SUCCESS_DONT_FIXUP,
+
+
+
+  NS_SUCCESS_RESTART_APP = nsresult::NS_SUCCESS_RESTART_APP,
+  NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = nsresult::NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE,
+  NS_SUCCESS_UNORM_NOTFOUND = nsresult::NS_SUCCESS_UNORM_NOTFOUND,
+
+
+
+
+  NS_ERROR_NOT_IN_TREE = nsresult::NS_ERROR_NOT_IN_TREE,
+
+
+  NS_OK_NO_NAME_CLAUSE_HANDLED = nsresult::NS_OK_NO_NAME_CLAUSE_HANDLED
+# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2
+
+;
+# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
+inline uint32_t
+NS_FAILED_impl(nsresult aErr)
+{
+  return static_cast<uint32_t>(aErr) & 0x80000000;
+}
+
+
+
+
+static_assert(((nsresult)0) < ((nsresult)-1),
+              "nsresult must be an unsigned type");
+static_assert(sizeof(nsresult) == sizeof(uint32_t),
+              "nsresult must be 32 bits");
+# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
+extern nsresult
+NS_ErrorAccordingToNSPR();
+
+
+
+
+
+
+inline constexpr uint16_t
+NS_ERROR_GET_CODE(nsresult aErr)
+{
+  return uint32_t(aErr) & 0xffff;
+}
+inline constexpr uint16_t
+NS_ERROR_GET_MODULE(nsresult aErr)
+{
+  return ((uint32_t(aErr) >> 16) - 0x45) & 0x1fff;
+}
+inline bool
+NS_ERROR_GET_SEVERITY(nsresult aErr)
+{
+  return uint32_t(aErr) >> 31;
+}
+# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
+
+typedef MozRefCountType nsrefcnt;
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2
+
+class nsTraceRefcnt
+{
+public:
+  static void Shutdown();
+
+  static nsresult DumpStatistics();
+
+  static void ResetStatistics();
+
+  static void WalkTheStack(FILE* aStream);
+
+
+
+
+
+
+  static void SetActivityIsLegal(bool aLegal);
+};
+
+
+
+
+extern "C" void
+NS_MeanAndStdDev(double aNumberOfValues,
+                 double aSumOfValues, double aSumOfSquaredValues,
+                 double* aMeanResult, double* aStdDevResult);
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+
+
+
+
+
+
+
+
+extern "C" {
+extern __attribute__((weak)) __attribute__((visibility("default"))) const char* gMozCrashReason;
+}
+
+
+static inline void
+AnnotateMozCrashReason(const char* reason)
+{
+  gMozCrashReason = reason;
+}
+
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 2 3
+
+using std::abort;
+using std::atexit;
+using std::exit;
+
+
+  using std::at_quick_exit;
+
+
+  using std::quick_exit;
+
+
+
+
+using std::div_t;
+using std::ldiv_t;
+
+using std::abs;
+using std::atof;
+using std::atoi;
+using std::atol;
+using std::bsearch;
+using std::calloc;
+using std::div;
+using std::free;
+using std::getenv;
+using std::labs;
+using std::ldiv;
+using std::malloc;
+
+using std::mblen;
+using std::mbstowcs;
+using std::mbtowc;
+
+using std::qsort;
+using std::rand;
+using std::realloc;
+using std::srand;
+using std::strtod;
+using std::strtol;
+using std::strtoul;
+using std::system;
+
+using std::wcstombs;
+using std::wctomb;
+# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+# 1 "/usr/include/signal.h" 1 3 4
+# 30 "/usr/include/signal.h" 3 4
+extern "C" {
+
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 102 "/usr/include/bits/sigset.h" 3 4
+extern int __sigismember (const __sigset_t *, int);
+extern int __sigaddset (__sigset_t *, int);
+extern int __sigdelset (__sigset_t *, int);
+# 33 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+
+typedef __sig_atomic_t sig_atomic_t;
+# 57 "/usr/include/signal.h" 3 4
+# 1 "/usr/include/bits/signum.h" 1 3 4
+# 58 "/usr/include/signal.h" 2 3 4
+# 75 "/usr/include/signal.h" 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 76 "/usr/include/signal.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/bits/siginfo.h" 1 3 4
+# 24 "/usr/include/bits/siginfo.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 25 "/usr/include/bits/siginfo.h" 2 3 4
+
+
+
+
+
+
+
+typedef union sigval
+  {
+    int sival_int;
+    void *sival_ptr;
+  } sigval_t;
+# 58 "/usr/include/bits/siginfo.h" 3 4
+typedef __clock_t __sigchld_clock_t;
+
+
+
+typedef struct
+  {
+    int si_signo;
+    int si_errno;
+
+    int si_code;
+
+    union
+      {
+ int _pad[((128 / sizeof (int)) - 4)];
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+   } _kill;
+
+
+ struct
+   {
+     int si_tid;
+     int si_overrun;
+     sigval_t si_sigval;
+   } _timer;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     sigval_t si_sigval;
+   } _rt;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     int si_status;
+     __sigchld_clock_t si_utime;
+     __sigchld_clock_t si_stime;
+   } _sigchld;
+
+
+ struct
+   {
+     void *si_addr;
+     short int si_addr_lsb;
+     struct
+       {
+  void *_lower;
+  void *_upper;
+       } si_addr_bnd;
+   } _sigfault;
+
+
+ struct
+   {
+     long int si_band;
+     int si_fd;
+   } _sigpoll;
+
+
+ struct
+   {
+     void *_call_addr;
+     int _syscall;
+     unsigned int _arch;
+   } _sigsys;
+      } _sifields;
+  } siginfo_t ;
+# 160 "/usr/include/bits/siginfo.h" 3 4
+enum
+{
+  SI_ASYNCNL = -60,
+
+  SI_TKILL = -6,
+
+  SI_SIGIO,
+
+  SI_ASYNCIO,
+
+  SI_MESGQ,
+
+  SI_TIMER,
+
+  SI_QUEUE,
+
+  SI_USER,
+
+  SI_KERNEL = 0x80
+
+};
+
+
+
+
+enum
+{
+  ILL_ILLOPC = 1,
+
+  ILL_ILLOPN,
+
+  ILL_ILLADR,
+
+  ILL_ILLTRP,
+
+  ILL_PRVOPC,
+
+  ILL_PRVREG,
+
+  ILL_COPROC,
+
+  ILL_BADSTK
+
+};
+
+
+enum
+{
+  FPE_INTDIV = 1,
+
+  FPE_INTOVF,
+
+  FPE_FLTDIV,
+
+  FPE_FLTOVF,
+
+  FPE_FLTUND,
+
+  FPE_FLTRES,
+
+  FPE_FLTINV,
+
+  FPE_FLTSUB
+
+};
+
+
+enum
+{
+  SEGV_MAPERR = 1,
+
+  SEGV_ACCERR
+
+};
+
+
+enum
+{
+  BUS_ADRALN = 1,
+
+  BUS_ADRERR,
+
+  BUS_OBJERR,
+
+  BUS_MCEERR_AR,
+
+  BUS_MCEERR_AO
+
+};
+
+
+
+
+enum
+{
+  TRAP_BRKPT = 1,
+
+  TRAP_TRACE
+
+};
+
+
+
+
+enum
+{
+  CLD_EXITED = 1,
+
+  CLD_KILLED,
+
+  CLD_DUMPED,
+
+  CLD_TRAPPED,
+
+  CLD_STOPPED,
+
+  CLD_CONTINUED
+
+};
+
+
+enum
+{
+  POLL_IN = 1,
+
+  POLL_OUT,
+
+  POLL_MSG,
+
+  POLL_ERR,
+
+  POLL_PRI,
+
+  POLL_HUP
+
+};
+# 320 "/usr/include/bits/siginfo.h" 3 4
+typedef struct sigevent
+  {
+    sigval_t sigev_value;
+    int sigev_signo;
+    int sigev_notify;
+
+    union
+      {
+ int _pad[((64 / sizeof (int)) - 4)];
+
+
+
+ __pid_t _tid;
+
+ struct
+   {
+     void (*_function) (sigval_t);
+     pthread_attr_t *_attribute;
+   } _sigev_thread;
+      } _sigev_un;
+  } sigevent_t;
+
+
+
+
+
+
+enum
+{
+  SIGEV_SIGNAL = 0,
+
+  SIGEV_NONE,
+
+  SIGEV_THREAD,
+
+
+  SIGEV_THREAD_ID = 4
+
+};
+# 81 "/usr/include/signal.h" 2 3 4
+
+
+
+
+typedef void (*__sighandler_t) (int);
+
+
+
+
+extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+
+
+
+
+
+
+extern __sighandler_t signal (int __sig, __sighandler_t __handler)
+     throw ();
+# 119 "/usr/include/signal.h" 3 4
+extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+
+
+
+
+
+extern int kill (__pid_t __pid, int __sig) throw ();
+
+
+
+
+
+
+extern int killpg (__pid_t __pgrp, int __sig) throw ();
+
+
+
+
+extern int raise (int __sig) throw ();
+
+
+
+
+extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
+     throw ();
+extern int gsignal (int __sig) throw ();
+
+
+
+
+extern void psignal (int __sig, const char *__s);
+
+
+extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
+# 168 "/usr/include/signal.h" 3 4
+extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
+# 187 "/usr/include/signal.h" 3 4
+extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
+# 202 "/usr/include/signal.h" 3 4
+typedef __sighandler_t sighandler_t;
+
+
+
+
+typedef __sighandler_t sig_t;
+
+
+
+
+
+extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigismember (const sigset_t *__set, int __signo)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigandset (sigset_t *__set, const sigset_t *__left,
+        const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern int sigorset (sigset_t *__set, const sigset_t *__left,
+       const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+
+# 1 "/usr/include/bits/sigaction.h" 1 3 4
+# 24 "/usr/include/bits/sigaction.h" 3 4
+struct sigaction
+  {
+
+
+    union
+      {
+
+ __sighandler_t sa_handler;
+
+ void (*sa_sigaction) (int, siginfo_t *, void *);
+      }
+    __sigaction_handler;
+
+
+
+
+
+
+
+    __sigset_t sa_mask;
+
+
+    int sa_flags;
+
+
+    void (*sa_restorer) (void);
+  };
+# 244 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigprocmask (int __how, const sigset_t *__restrict __set,
+   sigset_t *__restrict __oset) throw ();
+
+
+
+
+
+
+extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaction (int __sig, const struct sigaction *__restrict __act,
+        struct sigaction *__restrict __oact) throw ();
+
+
+extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
+     __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int sigwaitinfo (const sigset_t *__restrict __set,
+   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sigtimedwait (const sigset_t *__restrict __set,
+    siginfo_t *__restrict __info,
+    const struct timespec *__restrict __timeout)
+     __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
+     throw ();
+# 301 "/usr/include/signal.h" 3 4
+extern const char *const _sys_siglist[65];
+extern const char *const sys_siglist[65];
+
+
+
+
+# 1 "/usr/include/bits/sigcontext.h" 1 3 4
+# 29 "/usr/include/bits/sigcontext.h" 3 4
+struct _fpx_sw_bytes
+{
+  __uint32_t magic1;
+  __uint32_t extended_size;
+  __uint64_t xstate_bv;
+  __uint32_t xstate_size;
+  __uint32_t padding[7];
+};
+
+struct _fpreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+};
+
+struct _fpxreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+  unsigned short padding[3];
+};
+
+struct _xmmreg
+{
+  __uint32_t element[4];
+};
+# 121 "/usr/include/bits/sigcontext.h" 3 4
+struct _fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _fpxreg _st[8];
+  struct _xmmreg _xmm[16];
+  __uint32_t padding[24];
+};
+
+struct sigcontext
+{
+  __uint64_t r8;
+  __uint64_t r9;
+  __uint64_t r10;
+  __uint64_t r11;
+  __uint64_t r12;
+  __uint64_t r13;
+  __uint64_t r14;
+  __uint64_t r15;
+  __uint64_t rdi;
+  __uint64_t rsi;
+  __uint64_t rbp;
+  __uint64_t rbx;
+  __uint64_t rdx;
+  __uint64_t rax;
+  __uint64_t rcx;
+  __uint64_t rsp;
+  __uint64_t rip;
+  __uint64_t eflags;
+  unsigned short cs;
+  unsigned short gs;
+  unsigned short fs;
+  unsigned short __pad0;
+  __uint64_t err;
+  __uint64_t trapno;
+  __uint64_t oldmask;
+  __uint64_t cr2;
+  __extension__ union
+    {
+      struct _fpstate * fpstate;
+      __uint64_t __fpstate_word;
+    };
+  __uint64_t __reserved1 [8];
+};
+
+
+
+struct _xsave_hdr
+{
+  __uint64_t xstate_bv;
+  __uint64_t reserved1[2];
+  __uint64_t reserved2[5];
+};
+
+struct _ymmh_state
+{
+  __uint32_t ymmh_space[64];
+};
+
+struct _xstate
+{
+  struct _fpstate fpstate;
+  struct _xsave_hdr xstate_hdr;
+  struct _ymmh_state ymmh;
+};
+# 307 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigreturn (struct sigcontext *__scp) throw ();
+
+
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 317 "/usr/include/signal.h" 2 3 4
+
+
+
+
+extern int siginterrupt (int __sig, int __interrupt) throw ();
+
+
+# 1 "/usr/include/bits/sigstack.h" 1 3 4
+# 25 "/usr/include/bits/sigstack.h" 3 4
+struct sigstack
+  {
+    void *ss_sp;
+    int ss_onstack;
+  };
+
+
+
+enum
+{
+  SS_ONSTACK = 1,
+
+  SS_DISABLE
+
+};
+# 49 "/usr/include/bits/sigstack.h" 3 4
+typedef struct sigaltstack
+  {
+    void *ss_sp;
+    int ss_flags;
+    size_t ss_size;
+  } stack_t;
+# 324 "/usr/include/signal.h" 2 3 4
+
+
+# 1 "/usr/include/sys/ucontext.h" 1 3 4
+# 22 "/usr/include/sys/ucontext.h" 3 4
+# 1 "/usr/include/signal.h" 1 3 4
+# 23 "/usr/include/sys/ucontext.h" 2 3 4
+
+
+
+
+
+
+
+
+__extension__ typedef long long int greg_t;
+
+
+
+
+
+typedef greg_t gregset_t[23];
+
+
+
+enum
+{
+  REG_R8 = 0,
+
+  REG_R9,
+
+  REG_R10,
+
+  REG_R11,
+
+  REG_R12,
+
+  REG_R13,
+
+  REG_R14,
+
+  REG_R15,
+
+  REG_RDI,
+
+  REG_RSI,
+
+  REG_RBP,
+
+  REG_RBX,
+
+  REG_RDX,
+
+  REG_RAX,
+
+  REG_RCX,
+
+  REG_RSP,
+
+  REG_RIP,
+
+  REG_EFL,
+
+  REG_CSGSFS,
+
+  REG_ERR,
+
+  REG_TRAPNO,
+
+  REG_OLDMASK,
+
+  REG_CR2
+
+};
+
+
+struct _libc_fpxreg
+{
+  unsigned short int significand[4];
+  unsigned short int exponent;
+  unsigned short int padding[3];
+};
+
+struct _libc_xmmreg
+{
+  __uint32_t element[4];
+};
+
+struct _libc_fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _libc_fpxreg _st[8];
+  struct _libc_xmmreg _xmm[16];
+  __uint32_t padding[24];
+};
+
+
+typedef struct _libc_fpstate *fpregset_t;
+
+
+typedef struct
+  {
+    gregset_t gregs;
+
+    fpregset_t fpregs;
+    __extension__ unsigned long long __reserved1 [8];
+} mcontext_t;
+
+
+typedef struct ucontext
+  {
+    unsigned long int uc_flags;
+    struct ucontext *uc_link;
+    stack_t uc_stack;
+    mcontext_t uc_mcontext;
+    __sigset_t uc_sigmask;
+    struct _libc_fpstate __fpregs_mem;
+  } ucontext_t;
+# 327 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
+     throw () __attribute__ ((__deprecated__));
+
+
+
+extern int sigaltstack (const struct sigaltstack *__restrict __ss,
+   struct sigaltstack *__restrict __oss) throw ();
+
+
+
+
+
+
+
+extern int sighold (int __sig) throw ();
+
+
+extern int sigrelse (int __sig) throw ();
+
+
+extern int sigignore (int __sig) throw ();
+
+
+extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/sigthread.h" 1 3 4
+# 30 "/usr/include/bits/sigthread.h" 3 4
+extern int pthread_sigmask (int __how,
+       const __sigset_t *__restrict __newmask,
+       __sigset_t *__restrict __oldmask)throw ();
+
+
+extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
+
+
+
+extern int pthread_sigqueue (pthread_t __threadid, int __signo,
+        const union sigval __value) throw ();
+# 363 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+extern int __libc_current_sigrtmin (void) throw ();
+
+extern int __libc_current_sigrtmax (void) throw ();
+
+
+
+}
+# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
+# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+extern "C" {
+# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void
+MOZ_ReportAssertionFailure(const char* aStr, const char* aFilename, int aLine)
+
+{
+
+
+
+
+
+  fprintf(stderr, "Assertion failure: %s, at %s:%d\n", aStr, aFilename, aLine);
+
+  nsTraceRefcnt::WalkTheStack(stderr);
+
+  fflush(stderr);
+
+}
+
+__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void
+MOZ_ReportCrash(const char* aStr, const char* aFilename, int aLine)
+
+{
+
+
+
+
+  fprintf(stderr, "Hit MOZ_CRASH(%s) at %s:%d\n", aStr, aFilename, aLine);
+
+  nsTraceRefcnt::WalkTheStack(stderr);
+
+  fflush(stderr);
+
+}
+# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) void
+MOZ_CrashOOL(int aLine, const char* aReason);
+
+
+
+
+
+
+
+static const size_t sPrintfMaxArgs = 4;
+static const size_t sPrintfCrashReasonSize = 1024;
+
+
+__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) __attribute__ ((format (printf, 2, 3))) void
+MOZ_CrashPrintf(int aLine, const char* aFormat, ...);
+# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+}
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
+namespace mozilla {
+namespace detail {
+
+template<typename T>
+struct AssertionConditionType
+{
+  typedef typename RemoveReference<T>::Type ValueT;
+  static_assert(!IsArray<ValueT>::value,
+                "Expected boolean assertion condition, got an array or a "
+                "string!");
+  static_assert(!IsFunction<ValueT>::value,
+                "Expected boolean assertion condition, got a function! Did "
+                "you intend to call that function?");
+  static_assert(!IsFloatingPoint<ValueT>::value,
+                "It's often a bad idea to assert that a floating-point number "
+                "is nonzero, because such assertions tend to intermittently "
+                "fail. Shouldn't your code gracefully handle this case instead "
+                "of asserting? Anyway, if you really want to do that, write an "
+                "explicit boolean condition, like !!x or x!=0.");
+
+  static const bool isValid = true;
+};
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h"
+namespace mozilla {
+# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h"
+template<typename T>
+inline typename RemoveReference<T>::Type&&
+Move(T&& aX)
+{
+  return static_cast<typename RemoveReference<T>::Type&&>(aX);
+}
+
+
+
+
+
+template<typename T>
+inline T&&
+Forward(typename RemoveReference<T>::Type& aX)
+{
+  return static_cast<T&&>(aX);
+}
+
+template<typename T>
+inline T&&
+Forward(typename RemoveReference<T>::Type&& aX)
+{
+  static_assert(!IsLvalueReference<T>::value,
+                "misuse of Forward detected!  try the other overload");
+  return static_cast<T&&>(aX);
+}
+
+
+template<typename T>
+inline void
+Swap(T& aX, T& aY)
+{
+  T tmp(Move(aX));
+  aX = Move(aY);
+  aY = Move(tmp);
+}
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2
+
+namespace mozilla {
+
+struct unused_t;
+
+}
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
+template<class T>
+struct already_AddRefed
+{
+# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
+  already_AddRefed() : mRawPtr(nullptr) {}
+
+
+
+  typedef void (already_AddRefed::* MatchNullptr)(double, float);
+               already_AddRefed(MatchNullptr aRawPtr) : mRawPtr(nullptr) {}
+
+  explicit already_AddRefed(T* aRawPtr) : mRawPtr(aRawPtr) {}
+
+
+  already_AddRefed(const already_AddRefed<T>& aOther) = delete;
+  already_AddRefed<T>& operator=(const already_AddRefed<T>& aOther) = delete;
+
+  already_AddRefed(already_AddRefed<T>&& aOther) : mRawPtr(aOther.take()) {}
+
+  already_AddRefed<T>& operator=(already_AddRefed<T>&& aOther)
+  {
+    mRawPtr = aOther.take();
+    return *this;
+  }
+# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
+  template <typename U>
+               already_AddRefed(already_AddRefed<U>&& aOther) : mRawPtr(aOther.take()) {}
+
+  ~already_AddRefed() { do { } while (0); }
+
+
+
+
+
+  friend void operator<<(const mozilla::unused_t& aUnused,
+                         const already_AddRefed<T>& aRhs)
+  {
+    auto mutableAlreadyAddRefed = const_cast<already_AddRefed<T>*>(&aRhs);
+    aUnused << mutableAlreadyAddRefed->take();
+  }
+
+  __attribute__ ((warn_unused_result)) T* take()
+  {
+    T* rawPtr = mRawPtr;
+    mRawPtr = nullptr;
+    return rawPtr;
+  }
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
+  template<class U>
+  already_AddRefed<U> downcast()
+  {
+    U* tmp = static_cast<U*>(mRawPtr);
+    mRawPtr = nullptr;
+    return already_AddRefed<U>(tmp);
+  }
+
+private:
+  T* mRawPtr;
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 2
+
+
+
+
+
+
+
+class nsCOMPtr_helper;
+
+namespace mozilla {
+template<class T> class OwningNonNull;
+template<class T> class StaticRefPtr;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+template<class U>
+struct RefPtrTraits
+{
+  static void AddRef(U* aPtr) {
+    aPtr->AddRef();
+  }
+  static void Release(U* aPtr) {
+    aPtr->Release();
+  }
+};
+
+}
+
+template <class T>
+class RefPtr
+{
+private:
+  void
+  assign_with_AddRef(T* aRawPtr)
+  {
+    if (aRawPtr) {
+      ConstRemovingRefPtrTraits<T>::AddRef(aRawPtr);
+    }
+    assign_assuming_AddRef(aRawPtr);
+  }
+
+  void
+  assign_assuming_AddRef(T* aNewPtr)
+  {
+    T* oldPtr = mRawPtr;
+    mRawPtr = aNewPtr;
+    if (oldPtr) {
+      ConstRemovingRefPtrTraits<T>::Release(oldPtr);
+    }
+  }
+
+private:
+  T* mRawPtr;
+
+public:
+  typedef T element_type;
+
+  ~RefPtr()
+  {
+    if (mRawPtr) {
+      ConstRemovingRefPtrTraits<T>::Release(mRawPtr);
+    }
+  }
+
+
+
+  RefPtr()
+    : mRawPtr(nullptr)
+
+  {
+  }
+
+  RefPtr(const RefPtr<T>& aSmartPtr)
+    : mRawPtr(aSmartPtr.mRawPtr)
+
+  {
+    if (mRawPtr) {
+      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
+    }
+  }
+
+  RefPtr(RefPtr<T>&& aRefPtr)
+    : mRawPtr(aRefPtr.mRawPtr)
+  {
+    aRefPtr.mRawPtr = nullptr;
+  }
+
+
+
+               RefPtr(T* aRawPtr)
+    : mRawPtr(aRawPtr)
+  {
+    if (mRawPtr) {
+      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
+    }
+  }
+
+               RefPtr(decltype(nullptr))
+    : mRawPtr(nullptr)
+  {
+  }
+
+  template <typename I>
+               RefPtr(already_AddRefed<I>& aSmartPtr)
+    : mRawPtr(aSmartPtr.take())
+
+  {
+  }
+
+  template <typename I>
+               RefPtr(already_AddRefed<I>&& aSmartPtr)
+    : mRawPtr(aSmartPtr.take())
+
+  {
+  }
+
+  template <typename I>
+               RefPtr(const RefPtr<I>& aSmartPtr)
+    : mRawPtr(aSmartPtr.get())
+
+  {
+    if (mRawPtr) {
+      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
+    }
+  }
+
+  template <typename I>
+               RefPtr(RefPtr<I>&& aSmartPtr)
+    : mRawPtr(aSmartPtr.forget().take())
+
+  {
+  }
+
+               RefPtr(const nsCOMPtr_helper& aHelper);
+
+
+  template<class U>
+               RefPtr(const mozilla::OwningNonNull<U>& aOther);
+
+
+  template<class U>
+               RefPtr(const mozilla::StaticRefPtr<U>& aOther);
+
+
+
+  RefPtr<T>&
+  operator=(decltype(nullptr))
+  {
+    assign_assuming_AddRef(nullptr);
+    return *this;
+  }
+
+  RefPtr<T>&
+  operator=(const RefPtr<T>& aRhs)
+
+  {
+    assign_with_AddRef(aRhs.mRawPtr);
+    return *this;
+  }
+
+  template <typename I>
+  RefPtr<T>&
+  operator=(const RefPtr<I>& aRhs)
+
+  {
+    assign_with_AddRef(aRhs.get());
+    return *this;
+  }
+
+  RefPtr<T>&
+  operator=(T* aRhs)
+
+  {
+    assign_with_AddRef(aRhs);
+    return *this;
+  }
+
+  template <typename I>
+  RefPtr<T>&
+  operator=(already_AddRefed<I>& aRhs)
+
+  {
+    assign_assuming_AddRef(aRhs.take());
+    return *this;
+  }
+
+  template <typename I>
+  RefPtr<T>&
+  operator=(already_AddRefed<I> && aRhs)
+
+  {
+    assign_assuming_AddRef(aRhs.take());
+    return *this;
+  }
+
+  RefPtr<T>& operator=(const nsCOMPtr_helper& aHelper);
+
+  RefPtr<T>&
+  operator=(RefPtr<T> && aRefPtr)
+  {
+    assign_assuming_AddRef(aRefPtr.mRawPtr);
+    aRefPtr.mRawPtr = nullptr;
+    return *this;
+  }
+
+
+  template<class U>
+  RefPtr<T>&
+  operator=(const mozilla::OwningNonNull<U>& aOther);
+
+
+  template<class U>
+  RefPtr<T>&
+  operator=(const mozilla::StaticRefPtr<U>& aOther);
+
+
+
+  void
+  swap(RefPtr<T>& aRhs)
+
+  {
+    T* temp = aRhs.mRawPtr;
+    aRhs.mRawPtr = mRawPtr;
+    mRawPtr = temp;
+  }
+
+  void
+  swap(T*& aRhs)
+
+  {
+    T* temp = aRhs;
+    aRhs = mRawPtr;
+    mRawPtr = temp;
+  }
+
+  already_AddRefed<T>
+
+  forget()
+
+
+  {
+    T* temp = nullptr;
+    swap(temp);
+    return already_AddRefed<T>(temp);
+  }
+
+  template <typename I>
+  void
+  forget(I** aRhs)
+
+
+
+
+  {
+    do { } while (0);
+    *aRhs = mRawPtr;
+    mRawPtr = nullptr;
+  }
+
+  T*
+  get() const
+
+
+
+
+  {
+    return const_cast<T*>(mRawPtr);
+  }
+
+  operator T*() const &
+# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+  {
+    return get();
+  }
+
+
+
+
+  operator T*() const && = delete;
+
+
+
+
+  explicit operator bool() const { return !!mRawPtr; }
+  bool operator!() const { return !mRawPtr; }
+
+  T*
+  operator->() const
+  {
+    do { } while (0);
+
+    return get();
+  }
+
+  template <typename R, typename... Args>
+  class Proxy
+  {
+    typedef R (T::*member_function)(Args...);
+    T* mRawPtr;
+    member_function mFunction;
+  public:
+    Proxy(T* aRawPtr, member_function aFunction)
+      : mRawPtr(aRawPtr),
+        mFunction(aFunction)
+    {
+    }
+    template<typename... ActualArgs>
+    R operator()(ActualArgs&&... aArgs)
+    {
+      return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
+    }
+  };
+
+  template <typename R, typename... Args>
+  Proxy<R, Args...> operator->*(R (T::*aFptr)(Args...)) const
+  {
+    do { } while (0);
+
+    return Proxy<R, Args...>(get(), aFptr);
+  }
+
+  RefPtr<T>*
+  get_address()
+
+
+  {
+    return this;
+  }
+
+  const RefPtr<T>*
+  get_address() const
+
+
+  {
+    return this;
+  }
+
+public:
+  T&
+  operator*() const
+  {
+    do { } while (0);
+
+    return *get();
+  }
+
+  T**
+  StartAssignment()
+  {
+    assign_assuming_AddRef(nullptr);
+    return reinterpret_cast<T**>(&mRawPtr);
+  }
+private:
+# 388 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+  template<class U>
+  struct ConstRemovingRefPtrTraits
+  {
+    static void AddRef(U* aPtr) {
+      mozilla::RefPtrTraits<U>::AddRef(aPtr);
+    }
+    static void Release(U* aPtr) {
+      mozilla::RefPtrTraits<U>::Release(aPtr);
+    }
+  };
+  template<class U>
+  struct ConstRemovingRefPtrTraits<const U>
+  {
+    static void AddRef(const U* aPtr) {
+      mozilla::RefPtrTraits<U>::AddRef(const_cast<U*>(aPtr));
+    }
+    static void Release(const U* aPtr) {
+      mozilla::RefPtrTraits<U>::Release(const_cast<U*>(aPtr));
+    }
+  };
+};
+
+class nsCycleCollectionTraversalCallback;
+template <typename T>
+void
+CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
+                         T* aChild, const char* aName, uint32_t aFlags);
+
+template <typename T>
+inline void
+ImplCycleCollectionUnlink(RefPtr<T>& aField)
+{
+  aField = nullptr;
+}
+
+template <typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            RefPtr<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+
+template <class T>
+inline RefPtr<T>*
+address_of(RefPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+
+template <class T>
+inline const RefPtr<T>*
+address_of(const RefPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+
+template <class T>
+class RefPtrGetterAddRefs
+# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+{
+public:
+  explicit
+  RefPtrGetterAddRefs(RefPtr<T>& aSmartPtr)
+    : mTargetSmartPtr(aSmartPtr)
+  {
+
+  }
+
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
+
+  operator T**()
+  {
+    return mTargetSmartPtr.StartAssignment();
+  }
+
+  T*&
+  operator*()
+  {
+    return *(mTargetSmartPtr.StartAssignment());
+  }
+
+private:
+  RefPtr<T>& mTargetSmartPtr;
+};
+
+template <class T>
+inline RefPtrGetterAddRefs<T>
+getter_AddRefs(RefPtr<T>& aSmartPtr)
+
+
+
+
+{
+  return RefPtrGetterAddRefs<T>(aSmartPtr);
+}
+
+
+
+
+template <class T, class U>
+inline bool
+operator==(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
+}
+
+
+template <class T, class U>
+inline bool
+operator!=(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
+}
+
+
+
+
+template <class T, class U>
+inline bool
+operator==(const RefPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator==(const U* aLhs, const RefPtr<T>& aRhs)
+{
+  return static_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator!=(const RefPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator!=(const U* aLhs, const RefPtr<T>& aRhs)
+{
+  return static_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator==(const RefPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator==(U* aLhs, const RefPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator!=(const RefPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator!=(U* aLhs, const RefPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
+}
+
+
+
+template <class T>
+inline bool
+operator==(const RefPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() == nullptr;
+}
+
+template <class T>
+inline bool
+operator==(decltype(nullptr), const RefPtr<T>& aRhs)
+{
+  return nullptr == aRhs.get();
+}
+
+template <class T>
+inline bool
+operator!=(const RefPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() != nullptr;
+}
+
+template <class T>
+inline bool
+operator!=(decltype(nullptr), const RefPtr<T>& aRhs)
+{
+  return nullptr != aRhs.get();
+}
+
+
+
+template <class T>
+inline already_AddRefed<T>
+do_AddRef(T* aObj)
+{
+  RefPtr<T> ref(aObj);
+  return ref.forget();
+}
+
+template <class T>
+inline already_AddRefed<T>
+do_AddRef(const RefPtr<T>& aObj)
+{
+  RefPtr<T> ref(aObj);
+  return ref.forget();
+}
+
+namespace mozilla {
+# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
+template<typename T, typename... Args>
+already_AddRefed<T>
+MakeAndAddRef(Args&&... aArgs)
+{
+  RefPtr<T> p(new T(Forward<Args>(aArgs)...));
+  return p.forget();
+}
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
+namespace mozilla {
+
+namespace detail {
+
+enum StorageType { AsBase, AsMember };
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
+template<typename A, typename B,
+         detail::StorageType =
+           IsEmpty<A>::value ? detail::AsBase : detail::AsMember,
+         detail::StorageType =
+           IsEmpty<B>::value && !IsBaseOf<A, B>::value && !IsBaseOf<B, A>::value
+           ? detail::AsBase
+           : detail::AsMember>
+struct PairHelper;
+
+template<typename A, typename B>
+struct PairHelper<A, B, AsMember, AsMember>
+{
+protected:
+  template<typename AArg, typename BArg>
+  PairHelper(AArg&& aA, BArg&& aB)
+    : mFirstA(Forward<AArg>(aA)),
+      mSecondB(Forward<BArg>(aB))
+  {}
+
+  A& first() { return mFirstA; }
+  const A& first() const { return mFirstA; }
+  B& second() { return mSecondB; }
+  const B& second() const { return mSecondB; }
+
+  void swap(PairHelper& aOther)
+  {
+    Swap(mFirstA, aOther.mFirstA);
+    Swap(mSecondB, aOther.mSecondB);
+  }
+
+private:
+  A mFirstA;
+  B mSecondB;
+};
+
+template<typename A, typename B>
+struct PairHelper<A, B, AsMember, AsBase> : private B
+{
+protected:
+  template<typename AArg, typename BArg>
+  PairHelper(AArg&& aA, BArg&& aB)
+    : B(Forward<BArg>(aB)),
+      mFirstA(Forward<AArg>(aA))
+  {}
+
+  A& first() { return mFirstA; }
+  const A& first() const { return mFirstA; }
+  B& second() { return *this; }
+  const B& second() const { return *this; }
+
+  void swap(PairHelper& aOther)
+  {
+    Swap(mFirstA, aOther.mFirstA);
+    Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
+  }
+
+private:
+  A mFirstA;
+};
+
+template<typename A, typename B>
+struct PairHelper<A, B, AsBase, AsMember> : private A
+{
+protected:
+  template<typename AArg, typename BArg>
+  PairHelper(AArg&& aA, BArg&& aB)
+    : A(Forward<AArg>(aA)),
+      mSecondB(Forward<BArg>(aB))
+  {}
+
+  A& first() { return *this; }
+  const A& first() const { return *this; }
+  B& second() { return mSecondB; }
+  const B& second() const { return mSecondB; }
+
+  void swap(PairHelper& aOther)
+  {
+    Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
+    Swap(mSecondB, aOther.mSecondB);
+  }
+
+private:
+  B mSecondB;
+};
+
+template<typename A, typename B>
+struct PairHelper<A, B, AsBase, AsBase> : private A, private B
+{
+protected:
+  template<typename AArg, typename BArg>
+  PairHelper(AArg&& aA, BArg&& aB)
+    : A(Forward<AArg>(aA)),
+      B(Forward<BArg>(aB))
+  {}
+
+  A& first() { return static_cast<A&>(*this); }
+  const A& first() const { return static_cast<A&>(*this); }
+  B& second() { return static_cast<B&>(*this); }
+  const B& second() const { return static_cast<B&>(*this); }
+
+  void swap(PairHelper& aOther)
+  {
+    Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
+    Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
+  }
+};
+
+}
+# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
+template<typename A, typename B>
+struct Pair
+  : private detail::PairHelper<A, B>
+{
+  typedef typename detail::PairHelper<A, B> Base;
+
+public:
+  template<typename AArg, typename BArg>
+  Pair(AArg&& aA, BArg&& aB)
+    : Base(Forward<AArg>(aA), Forward<BArg>(aB))
+  {}
+
+  Pair(Pair&& aOther)
+    : Base(Move(aOther.first()), Move(aOther.second()))
+  { }
+
+  Pair(const Pair& aOther) = default;
+
+  Pair& operator=(Pair&& aOther)
+  {
+    do { } while (0);
+
+    first() = Move(aOther.first());
+    second() = Move(aOther.second());
+
+    return *this;
+  }
+
+  Pair& operator=(const Pair& aOther) = default;
+
+
+  using Base::first;
+
+  using Base::second;
+
+
+  void swap(Pair& aOther) { Base::swap(aOther); }
+};
+
+template<typename A, class B>
+void
+Swap(Pair<A, B>& aX, Pair<A, B>& aY)
+{
+  aX.swap(aY);
+}
+# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
+template<typename A, typename B>
+Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
+     typename RemoveCV<typename RemoveReference<B>::Type>::Type>
+MakePair(A&& aA, B&& aB)
+{
+  return
+    Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
+         typename RemoveCV<typename RemoveReference<B>::Type>::Type>(
+             Forward<A>(aA),
+             Forward<B>(aB));
+}
+
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 2
+
+
+namespace mozilla {
+
+template<typename T> class DefaultDelete;
+template<typename T, class D = DefaultDelete<T>> class UniquePtr;
+
+}
+
+namespace mozilla {
+
+namespace detail {
+
+struct HasPointerTypeHelper
+{
+  template <class U> static double Test(...);
+  template <class U> static char Test(typename U::pointer* = 0);
+};
+
+template <class T>
+class HasPointerType : public IntegralConstant<bool, sizeof(HasPointerTypeHelper::Test<T>(0)) == 1>
+{
+};
+
+template <class T, class D, bool = HasPointerType<D>::value>
+struct PointerTypeImpl
+{
+  typedef typename D::pointer Type;
+};
+
+template <class T, class D>
+struct PointerTypeImpl<T, D, false>
+{
+  typedef T* Type;
+};
+
+template <class T, class D>
+struct PointerType
+{
+  typedef typename PointerTypeImpl<T, typename RemoveReference<D>::Type>::Type Type;
+};
+
+}
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
+template<typename T, class D>
+class UniquePtr
+{
+public:
+  typedef T ElementType;
+  typedef D DeleterType;
+  typedef typename detail::PointerType<T, DeleterType>::Type Pointer;
+
+private:
+  Pair<Pointer, DeleterType> mTuple;
+
+  Pointer& ptr() { return mTuple.first(); }
+  const Pointer& ptr() const { return mTuple.first(); }
+
+  DeleterType& del() { return mTuple.second(); }
+  const DeleterType& del() const { return mTuple.second(); }
+
+public:
+
+
+
+  constexpr UniquePtr()
+    : mTuple(static_cast<Pointer>(nullptr), DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+
+
+
+  explicit UniquePtr(Pointer aPtr)
+    : mTuple(aPtr, DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+  UniquePtr(Pointer aPtr,
+            typename Conditional<IsReference<D>::value,
+                                 D,
+                                 const D&>::Type aD1)
+    : mTuple(aPtr, aD1)
+  {}
+# 254 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
+  UniquePtr(Pointer aPtr,
+            typename RemoveReference<D>::Type&& aD2)
+    : mTuple(aPtr, Move(aD2))
+  {
+    static_assert(!IsReference<D>::value,
+                  "rvalue deleter can't be stored by reference");
+  }
+
+  UniquePtr(UniquePtr&& aOther)
+    : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
+  {}
+
+
+  UniquePtr(decltype(nullptr))
+    : mTuple(nullptr, DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+  template<typename U, class E>
+
+  UniquePtr(UniquePtr<U, E>&& aOther,
+            typename EnableIf<IsConvertible<typename UniquePtr<U, E>::Pointer,
+                                            Pointer>::value &&
+                              !IsArray<U>::value &&
+                              (IsReference<D>::value
+                               ? IsSame<D, E>::value
+                               : IsConvertible<E, D>::value),
+                              int>::Type aDummy = 0)
+    : mTuple(aOther.release(), Forward<E>(aOther.get_deleter()))
+  {
+  }
+
+  ~UniquePtr() { reset(nullptr); }
+
+  UniquePtr& operator=(UniquePtr&& aOther)
+  {
+    reset(aOther.release());
+    get_deleter() = Forward<DeleterType>(aOther.get_deleter());
+    return *this;
+  }
+
+  template<typename U, typename E>
+  UniquePtr& operator=(UniquePtr<U, E>&& aOther)
+  {
+    static_assert(IsConvertible<typename UniquePtr<U, E>::Pointer,
+                                Pointer>::value,
+                  "incompatible UniquePtr pointees");
+    static_assert(!IsArray<U>::value,
+                  "can't assign from UniquePtr holding an array");
+
+    reset(aOther.release());
+    get_deleter() = Forward<E>(aOther.get_deleter());
+    return *this;
+  }
+
+  UniquePtr& operator=(decltype(nullptr))
+  {
+    reset(nullptr);
+    return *this;
+  }
+
+  T& operator*() const { return *get(); }
+  Pointer operator->() const
+  {
+    do { } while (0);
+    return get();
+  }
+
+  explicit operator bool() const { return get() != nullptr; }
+
+  Pointer get() const { return ptr(); }
+
+  DeleterType& get_deleter() { return del(); }
+  const DeleterType& get_deleter() const { return del(); }
+
+  __attribute__ ((warn_unused_result)) Pointer release()
+  {
+    Pointer p = ptr();
+    ptr() = nullptr;
+    return p;
+  }
+
+  void reset(Pointer aPtr = Pointer())
+  {
+    Pointer old = ptr();
+    ptr() = aPtr;
+    if (old != nullptr) {
+      get_deleter()(old);
+    }
+  }
+
+  void swap(UniquePtr& aOther)
+  {
+    mTuple.swap(aOther.mTuple);
+  }
+
+  UniquePtr(const UniquePtr& aOther) = delete;
+  void operator=(const UniquePtr& aOther) = delete;
+};
+
+
+
+
+
+template<typename T, class D>
+class UniquePtr<T[], D>
+{
+public:
+  typedef T* Pointer;
+  typedef T ElementType;
+  typedef D DeleterType;
+
+private:
+  Pair<Pointer, DeleterType> mTuple;
+
+public:
+
+
+
+  constexpr UniquePtr()
+    : mTuple(static_cast<Pointer>(nullptr), DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+
+
+
+  explicit UniquePtr(Pointer aPtr)
+    : mTuple(aPtr, DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+
+
+
+
+
+  template<typename U>
+  UniquePtr(U&& aU,
+            typename EnableIf<IsPointer<U>::value &&
+                              IsConvertible<U, Pointer>::value,
+                              int>::Type aDummy = 0)
+  = delete;
+
+  UniquePtr(Pointer aPtr,
+            typename Conditional<IsReference<D>::value,
+                                 D,
+                                 const D&>::Type aD1)
+    : mTuple(aPtr, aD1)
+  {}
+
+
+
+
+
+  UniquePtr(Pointer aPtr,
+            typename RemoveReference<D>::Type&& aD2)
+    : mTuple(aPtr, Move(aD2))
+  {
+    static_assert(!IsReference<D>::value,
+                  "rvalue deleter can't be stored by reference");
+  }
+
+
+  template<typename U, typename V>
+  UniquePtr(U&& aU, V&& aV,
+            typename EnableIf<IsPointer<U>::value &&
+                              IsConvertible<U, Pointer>::value,
+                              int>::Type aDummy = 0)
+  = delete;
+
+  UniquePtr(UniquePtr&& aOther)
+    : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
+  {}
+
+
+  UniquePtr(decltype(nullptr))
+    : mTuple(nullptr, DeleterType())
+  {
+    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+    static_assert(!IsReference<D>::value, "must provide a deleter instance");
+  }
+
+  ~UniquePtr() { reset(nullptr); }
+
+  UniquePtr& operator=(UniquePtr&& aOther)
+  {
+    reset(aOther.release());
+    get_deleter() = Forward<DeleterType>(aOther.get_deleter());
+    return *this;
+  }
+
+  UniquePtr& operator=(decltype(nullptr))
+  {
+    reset();
+    return *this;
+  }
+
+  explicit operator bool() const { return get() != nullptr; }
+
+  T& operator[](decltype(sizeof(int)) aIndex) const { return get()[aIndex]; }
+  Pointer get() const { return mTuple.first(); }
+
+  DeleterType& get_deleter() { return mTuple.second(); }
+  const DeleterType& get_deleter() const { return mTuple.second(); }
+
+  __attribute__ ((warn_unused_result)) Pointer release()
+  {
+    Pointer p = mTuple.first();
+    mTuple.first() = nullptr;
+    return p;
+  }
+
+  void reset(Pointer aPtr = Pointer())
+  {
+    Pointer old = mTuple.first();
+    mTuple.first() = aPtr;
+    if (old != nullptr) {
+      mTuple.second()(old);
+    }
+  }
+
+  void reset(decltype(nullptr))
+  {
+    Pointer old = mTuple.first();
+    mTuple.first() = nullptr;
+    if (old != nullptr) {
+      mTuple.second()(old);
+    }
+  }
+
+  template<typename U>
+  void reset(U) = delete;
+
+  void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
+
+  UniquePtr(const UniquePtr& aOther) = delete;
+  void operator=(const UniquePtr& aOther) = delete;
+};
+# 513 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
+template<typename T>
+class DefaultDelete
+{
+public:
+  constexpr DefaultDelete() {}
+
+  template<typename U>
+               DefaultDelete(const DefaultDelete<U>& aOther,
+                             typename EnableIf<mozilla::IsConvertible<U*, T*>::value,
+                                               int>::Type aDummy = 0)
+  {}
+
+  void operator()(T* aPtr) const
+  {
+    static_assert(sizeof(T) > 0, "T must be complete");
+    delete aPtr;
+  }
+};
+
+
+template<typename T>
+class DefaultDelete<T[]>
+{
+public:
+  constexpr DefaultDelete() {}
+
+  void operator()(T* aPtr) const
+  {
+    static_assert(sizeof(T) > 0, "T must be complete");
+    delete[] aPtr;
+  }
+
+  template<typename U>
+  void operator()(U* aPtr) const = delete;
+};
+
+template<typename T, class D>
+void
+Swap(UniquePtr<T, D>& aX, UniquePtr<T, D>& aY)
+{
+  aX.swap(aY);
+}
+
+template<typename T, class D, typename U, class E>
+bool
+operator==(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY)
+{
+  return aX.get() == aY.get();
+}
+
+template<typename T, class D, typename U, class E>
+bool
+operator!=(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY)
+{
+  return aX.get() != aY.get();
+}
+
+template<typename T, class D>
+bool
+operator==(const UniquePtr<T, D>& aX, decltype(nullptr))
+{
+  return !aX;
+}
+
+template<typename T, class D>
+bool
+operator==(decltype(nullptr), const UniquePtr<T, D>& aX)
+{
+  return !aX;
+}
+
+template<typename T, class D>
+bool
+operator!=(const UniquePtr<T, D>& aX, decltype(nullptr))
+{
+  return bool(aX);
+}
+
+template<typename T, class D>
+bool
+operator!=(decltype(nullptr), const UniquePtr<T, D>& aX)
+{
+  return bool(aX);
+}
+
+
+
+namespace detail {
+
+template<typename T>
+struct UniqueSelector
+{
+  typedef UniquePtr<T> SingleObject;
+};
+
+template<typename T>
+struct UniqueSelector<T[]>
+{
+  typedef UniquePtr<T[]> UnknownBound;
+};
+
+template<typename T, decltype(sizeof(int)) N>
+struct UniqueSelector<T[N]>
+{
+  typedef UniquePtr<T[N]> KnownBound;
+};
+
+}
+# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
+template<typename T, typename... Args>
+typename detail::UniqueSelector<T>::SingleObject
+MakeUnique(Args&&... aArgs)
+{
+  return UniquePtr<T>(new T(Forward<Args>(aArgs)...));
+}
+
+template<typename T>
+typename detail::UniqueSelector<T>::UnknownBound
+MakeUnique(decltype(sizeof(int)) aN)
+{
+  typedef typename RemoveExtent<T>::Type ArrayType;
+  return UniquePtr<T>(new ArrayType[aN]());
+}
+
+template<typename T, typename... Args>
+typename detail::UniqueSelector<T>::KnownBound
+MakeUnique(Args&&... aArgs) = delete;
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 2
+
+template<class E>
+class nsTArray;
+
+template<class E>
+class FallibleTArray;
+
+template<class E, size_t N>
+class AutoTArray;
+
+template<class E>
+using InfallibleTArray = nsTArray<E>;
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 2
+
+
+namespace mozilla {
+
+
+
+
+
+template<typename T>
+class AlignmentFinder
+{
+  struct Aligner
+  {
+    char mChar;
+    T mT;
+  };
+
+public:
+  static const size_t alignment = sizeof(Aligner) - sizeof(T);
+};
+# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h"
+template<size_t Align>
+struct AlignedElem;
+
+
+
+
+
+
+template<>
+struct AlignedElem<1>
+{
+  uint8_t elem __attribute__((aligned(1)));
+};
+
+template<>
+struct AlignedElem<2>
+{
+  uint8_t elem __attribute__((aligned(2)));
+};
+
+template<>
+struct AlignedElem<4>
+{
+  uint8_t elem __attribute__((aligned(4)));
+};
+
+template<>
+struct AlignedElem<8>
+{
+  uint8_t elem __attribute__((aligned(8)));
+};
+
+template<>
+struct AlignedElem<16>
+{
+  uint8_t elem __attribute__((aligned(16)));
+};
+
+template<typename T>
+struct AlignedStorage2
+{
+  union U
+  {
+    char mBytes[sizeof(T)];
+    uint64_t mDummy;
+  } u;
+
+  const T* addr() const { return reinterpret_cast<const T*>(u.mBytes); }
+  T* addr() { return static_cast<T*>(static_cast<void*>(u.mBytes)); }
+
+  AlignedStorage2() = default;
+
+
+
+  AlignedStorage2(const AlignedStorage2&) = delete;
+  void operator=(const AlignedStorage2&) = delete;
+};
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+  struct input_iterator_tag { };
+
+
+  struct output_iterator_tag { };
+
+
+  struct forward_iterator_tag : public input_iterator_tag { };
+
+
+
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+
+
+
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+
+      typedef _Category iterator_category;
+
+      typedef _Tp value_type;
+
+      typedef _Distance difference_type;
+
+      typedef _Pointer pointer;
+
+      typedef _Reference reference;
+    };
+# 143 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+  template<typename _Iterator, typename = __void_t<>>
+    struct __iterator_traits { };
+
+  template<typename _Iterator>
+    struct __iterator_traits<_Iterator,
+        __void_t<typename _Iterator::iterator_category,
+          typename _Iterator::value_type,
+          typename _Iterator::difference_type,
+          typename _Iterator::pointer,
+          typename _Iterator::reference>>
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type value_type;
+      typedef typename _Iterator::difference_type difference_type;
+      typedef typename _Iterator::pointer pointer;
+      typedef typename _Iterator::reference reference;
+    };
+
+  template<typename _Iterator>
+    struct iterator_traits
+    : public __iterator_traits<_Iterator> { };
+# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+    };
+
+
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+    };
+
+
+
+
+
+  template<typename _Iter>
+    inline typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+# 230 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
+  template<typename _InIter>
+    using _RequireInputIter = typename
+      enable_if<is_convertible<typename
+  iterator_traits<_InIter>::iterator_category,
+          input_iterator_tag>::value>::type;
+
+
+
+}
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/assertions.h" 1 3
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template <typename> struct _List_iterator;
+  template <typename> struct _List_const_iterator;
+
+
+
+
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    __distance(_InputIterator __first, _InputIterator __last,
+               input_iterator_tag)
+    {
+
+
+
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+
+  template<typename _RandomAccessIterator>
+    inline typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+
+
+
+      return __last - __first;
+    }
+
+
+
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_iterator<_Tp>,
+        std::_List_iterator<_Tp>,
+        input_iterator_tag);
+
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_const_iterator<_Tp>,
+        std::_List_const_iterator<_Tp>,
+        input_iterator_tag);
+# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+
+      return std::__distance(__first, __last,
+        std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+
+
+                                ;
+      while (__n--)
+ ++__i;
+    }
+
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline void
+    __advance(_BidirectionalIterator& __i, _Distance __n,
+       bidirectional_iterator_tag)
+    {
+
+
+
+      if (__n > 0)
+        while (__n--)
+   ++__i;
+      else
+        while (__n++)
+   --__i;
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+
+
+
+      __i += __n;
+    }
+# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+
+
+
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    next(_ForwardIterator __x, typename
+  iterator_traits<_ForwardIterator>::difference_type __n = 1)
+    {
+
+
+
+      std::advance(__x, __n);
+      return __x;
+    }
+
+  template<typename _BidirectionalIterator>
+    inline _BidirectionalIterator
+    prev(_BidirectionalIterator __x, typename
+  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
+    {
+
+
+
+      std::advance(__x, -__n);
+      return __x;
+    }
+
+
+
+
+}
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
+extern "C++" {
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  struct __true_type { };
+  struct __false_type { };
+
+  template<bool>
+    struct __truth_type
+    { typedef __false_type __type; };
+
+  template<>
+    struct __truth_type<true>
+    { typedef __true_type __type; };
+
+
+
+  template<class _Sp, class _Tp>
+    struct __traitor
+    {
+      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+      typedef typename __truth_type<__value>::__type __type;
+    };
+
+
+  template<typename, typename>
+    struct __are_same
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __are_same<_Tp, _Tp>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_void
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_void<void>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+
+
+
+  template<>
+    struct __is_integer<bool>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<>
+    struct __is_integer<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+  template<>
+    struct __is_integer<char16_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<char32_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<>
+    struct __is_integer<short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+# 278 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
+  template<typename _Tp>
+    struct __is_floating
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+  template<>
+    struct __is_floating<float>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<long double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_pointer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __is_pointer<_Tp*>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_arithmetic
+    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_scalar
+    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_char
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_char<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<>
+    struct __is_char<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_byte
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_byte<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+
+  template<typename _Iterator>
+    inline _Iterator
+    __miter_base(_Iterator __it)
+    { return __it; }
+
+
+}
+}
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 3
+
+
+
+
+extern "C++" {
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<bool, typename>
+    struct __enable_if
+    { };
+
+  template<typename _Tp>
+    struct __enable_if<true, _Tp>
+    { typedef _Tp __type; };
+
+
+
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct __conditional_type
+    { typedef _Iftrue __type; };
+
+  template<typename _Iftrue, typename _Iffalse>
+    struct __conditional_type<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse __type; };
+
+
+
+  template<typename _Tp>
+    struct __add_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+    public:
+      typedef typename __if_type::__type __type;
+    };
+
+  template<>
+    struct __add_unsigned<char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<signed char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<short>
+    { typedef unsigned short __type; };
+
+  template<>
+    struct __add_unsigned<int>
+    { typedef unsigned int __type; };
+
+  template<>
+    struct __add_unsigned<long>
+    { typedef unsigned long __type; };
+
+  template<>
+    struct __add_unsigned<long long>
+    { typedef unsigned long long __type; };
+
+
+  template<>
+    struct __add_unsigned<bool>;
+
+  template<>
+    struct __add_unsigned<wchar_t>;
+
+
+
+  template<typename _Tp>
+    struct __remove_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+    public:
+      typedef typename __if_type::__type __type;
+    };
+
+  template<>
+    struct __remove_unsigned<char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned short>
+    { typedef short __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned int>
+    { typedef int __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long>
+    { typedef long __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long long>
+    { typedef long long __type; };
+
+
+  template<>
+    struct __remove_unsigned<bool>;
+
+  template<>
+    struct __remove_unsigned<wchar_t>;
+
+
+
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type* __ptr)
+    { return __ptr == 0; }
+
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type)
+    { return false; }
+
+
+  inline bool
+  __is_null_pointer(std::nullptr_t)
+  { return true; }
+
+
+
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+
+
+
+
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { };
+
+  template<>
+    struct __promote<long double>
+    { typedef long double __type; };
+
+  template<>
+    struct __promote<double>
+    { typedef double __type; };
+
+  template<>
+    struct __promote<float>
+    { typedef float __type; };
+
+  template<typename _Tp, typename _Up,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type>
+    struct __promote_2
+    {
+      typedef __typeof__(_Tp2() + _Up2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type>
+    struct __promote_3
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type,
+           typename _Wp2 = typename __promote<_Wp>::__type>
+    struct __promote_4
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
+    };
+
+
+}
+}
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  class __undefined;
+
+
+  template<typename _Tp>
+    struct __get_first_arg
+    { using type = __undefined; };
+
+  template<template<typename, typename...> class _Template, typename _Tp,
+           typename... _Types>
+    struct __get_first_arg<_Template<_Tp, _Types...>>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
+
+
+  template<typename _Tp, typename _Up>
+    struct __replace_first_arg
+    { using type = __undefined; };
+
+  template<template<typename, typename...> class _Template, typename _Up,
+           typename _Tp, typename... _Types>
+    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
+    { using type = _Template<_Up, _Types...>; };
+
+  template<typename _Tp, typename _Up>
+    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
+
+  template<typename _Tp>
+    using __make_not_void
+      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
+
+
+
+
+
+  template<typename _Ptr>
+    struct pointer_traits
+    {
+    private:
+      template<typename _Tp>
+ using __element_type = typename _Tp::element_type;
+
+      template<typename _Tp>
+ using __difference_type = typename _Tp::difference_type;
+
+      template<typename _Tp, typename _Up>
+ using __rebind = typename _Tp::template rebind<_Up>;
+
+    public:
+
+      using pointer = _Ptr;
+
+
+      using element_type
+ = __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>;
+
+
+      using difference_type
+ = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
+
+
+      template<typename _Up>
+        using rebind
+   = __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>;
+
+      static _Ptr
+      pointer_to(__make_not_void<element_type>& __e)
+      { return _Ptr::pointer_to(__e); }
+
+      static_assert(!is_same<element_type, __undefined>::value,
+   "pointer type defines element_type or is like SomePointer<T, Args>");
+      static_assert(!is_same<rebind<element_type>, __undefined>::value,
+   "pointer type defines rebind<U> or is like SomePointer<T, Args>");
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct pointer_traits<_Tp*>
+    {
+
+      typedef _Tp* pointer;
+
+      typedef _Tp element_type;
+
+      typedef ptrdiff_t difference_type;
+
+      template<typename _Up>
+        using rebind = _Up*;
+
+
+
+
+
+
+      static pointer
+      pointer_to(__make_not_void<element_type>& __r) noexcept
+      { return std::addressof(__r); }
+    };
+
+
+  template<typename _Ptr, typename _Tp>
+    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
+
+
+}
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+        typename iterator_traits<_Iterator>::value_type,
+        typename iterator_traits<_Iterator>::difference_type,
+        typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::pointer pointer;
+      typedef typename __traits_type::reference reference;
+
+
+
+
+
+
+
+      reverse_iterator() : current() { }
+
+
+
+
+      explicit
+      reverse_iterator(iterator_type __x) : current(__x) { }
+
+
+
+
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+
+
+
+
+
+      template<typename _Iter>
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+
+
+
+
+      iterator_type
+      base() const
+      { return current; }
+# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+      reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+
+
+
+
+
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+
+
+
+
+
+      reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+
+
+
+
+
+
+
+      reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+
+
+
+
+
+
+
+      reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+# 290 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Iterator>
+
+
+
+
+
+    inline auto
+    operator-(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    -> decltype(__x.base() - __y.base())
+
+    { return __y.base() - __x.base(); }
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+       const reverse_iterator<_Iterator>& __x)
+    { return reverse_iterator<_Iterator>(__x.base() - __n); }
+
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+
+
+    inline auto
+    operator-(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    -> decltype(__y.base() - __x.base())
+
+
+
+
+
+    { return __y.base() - __x.base(); }
+
+
+
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    __make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+
+
+
+
+
+
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+
+
+
+
+  template<typename _Iterator>
+    auto
+    __niter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
+    { return __make_reverse_iterator(__niter_base(__it.base())); }
+
+  template<typename _Iterator>
+    struct __is_move_iterator<reverse_iterator<_Iterator> >
+      : __is_move_iterator<_Iterator>
+    { };
+
+  template<typename _Iterator>
+    auto
+    __miter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
+    { return __make_reverse_iterator(__miter_base(__it.base())); }
+# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+      explicit
+      back_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+# 483 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+      back_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_back(__value);
+ return *this;
+      }
+
+      back_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_back(std::move(__value));
+ return *this;
+      }
+
+
+
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 525 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+# 540 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+      explicit front_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+# 574 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+      front_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_front(__value);
+ return *this;
+      }
+
+      front_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_front(std::move(__value));
+ return *this;
+      }
+
+
+
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 616 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+# 635 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+
+      typedef _Container container_type;
+
+
+
+
+
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(std::__addressof(__x)), iter(__i) {}
+# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+      insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+      }
+
+      insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ iter = container->insert(iter, std::move(__value));
+ ++iter;
+ return *this;
+      }
+
+
+
+      insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+
+
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+# 754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  using std::iterator_traits;
+  using std::iterator;
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::reference reference;
+      typedef typename __traits_type::pointer pointer;
+
+      constexpr __normal_iterator() noexcept
+      : _M_current(_Iterator()) { }
+
+      explicit
+      __normal_iterator(const _Iterator& __i) noexcept
+      : _M_current(__i) { }
+
+
+      template<typename _Iter>
+        __normal_iterator(const __normal_iterator<_Iter,
+     typename __enable_if<
+              (std::__are_same<_Iter, typename _Container::pointer>::__value),
+        _Container>::__type>& __i) noexcept
+        : _M_current(__i.base()) { }
+
+
+      reference
+      operator*() const noexcept
+      { return *_M_current; }
+
+      pointer
+      operator->() const noexcept
+      { return _M_current; }
+
+      __normal_iterator&
+      operator++() noexcept
+      {
+ ++_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator++(int) noexcept
+      { return __normal_iterator(_M_current++); }
+
+
+      __normal_iterator&
+      operator--() noexcept
+      {
+ --_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator--(int) noexcept
+      { return __normal_iterator(_M_current--); }
+
+
+      reference
+      operator[](difference_type __n) const noexcept
+      { return _M_current[__n]; }
+
+      __normal_iterator&
+      operator+=(difference_type __n) noexcept
+      { _M_current += __n; return *this; }
+
+      __normal_iterator
+      operator+(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current + __n); }
+
+      __normal_iterator&
+      operator-=(difference_type __n) noexcept
+      { _M_current -= __n; return *this; }
+
+      __normal_iterator
+      operator-(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current - __n); }
+
+      const _Iterator&
+      base() const noexcept
+      { return _M_current; }
+    };
+# 854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() != __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() != __rhs.base(); }
+
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() >= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() >= __rhs.base(); }
+
+
+
+
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+
+
+    inline auto
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
+    -> decltype(__lhs.base() - __rhs.base())
+
+
+
+
+
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline __normal_iterator<_Iterator, _Container>
+    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
+       __n, const __normal_iterator<_Iterator, _Container>& __i)
+    noexcept
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Iterator, typename _Container>
+    _Iterator
+    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
+    { return __it.base(); }
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 1006 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class move_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+      typedef typename __traits_type::reference __base_ref;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+
+      typedef _Iterator pointer;
+
+
+      typedef typename conditional<is_reference<__base_ref>::value,
+    typename remove_reference<__base_ref>::type&&,
+    __base_ref>::type reference;
+
+      move_iterator()
+      : _M_current() { }
+
+      explicit
+      move_iterator(iterator_type __i)
+      : _M_current(__i) { }
+
+      template<typename _Iter>
+ move_iterator(const move_iterator<_Iter>& __i)
+ : _M_current(__i.base()) { }
+
+      iterator_type
+      base() const
+      { return _M_current; }
+
+      reference
+      operator*() const
+      { return static_cast<reference>(*_M_current); }
+
+      pointer
+      operator->() const
+      { return _M_current; }
+
+      move_iterator&
+      operator++()
+      {
+ ++_M_current;
+ return *this;
+      }
+
+      move_iterator
+      operator++(int)
+      {
+ move_iterator __tmp = *this;
+ ++_M_current;
+ return __tmp;
+      }
+
+      move_iterator&
+      operator--()
+      {
+ --_M_current;
+ return *this;
+      }
+
+      move_iterator
+      operator--(int)
+      {
+ move_iterator __tmp = *this;
+ --_M_current;
+ return __tmp;
+      }
+
+      move_iterator
+      operator+(difference_type __n) const
+      { return move_iterator(_M_current + __n); }
+
+      move_iterator&
+      operator+=(difference_type __n)
+      {
+ _M_current += __n;
+ return *this;
+      }
+
+      move_iterator
+      operator-(difference_type __n) const
+      { return move_iterator(_M_current - __n); }
+
+      move_iterator&
+      operator-=(difference_type __n)
+      {
+ _M_current -= __n;
+ return *this;
+      }
+
+      reference
+      operator[](difference_type __n) const
+      { return std::move(_M_current[__n]); }
+    };
+
+
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator==(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline auto
+    operator-(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    -> decltype(__x.base() - __y.base())
+    { return __x.base() - __y.base(); }
+
+  template<typename _Iterator>
+    inline auto
+    operator-(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    -> decltype(__x.base() - __y.base())
+    { return __x.base() - __y.base(); }
+
+  template<typename _Iterator>
+    inline move_iterator<_Iterator>
+    operator+(typename move_iterator<_Iterator>::difference_type __n,
+       const move_iterator<_Iterator>& __x)
+    { return __x + __n; }
+
+  template<typename _Iterator>
+    inline move_iterator<_Iterator>
+    make_move_iterator(_Iterator __i)
+    { return move_iterator<_Iterator>(__i); }
+
+  template<typename _Iterator, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond
+      <typename iterator_traits<_Iterator>::value_type>::value,
+                _Iterator, move_iterator<_Iterator>>::type>
+    inline _ReturnType
+    __make_move_if_noexcept_iterator(_Iterator __i)
+    { return _ReturnType(__i); }
+
+
+
+  template<typename _Tp, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
+      const _Tp*, move_iterator<_Tp*>>::type>
+    inline _ReturnType
+    __make_move_if_noexcept_iterator(_Tp* __i)
+    { return _ReturnType(__i); }
+
+
+
+  template<typename _Iterator>
+    auto
+    __niter_base(move_iterator<_Iterator> __it)
+    -> decltype(make_move_iterator(__niter_base(__it.base())))
+    { return make_move_iterator(__niter_base(__it.base())); }
+
+  template<typename _Iterator>
+    struct __is_move_iterator<move_iterator<_Iterator> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<typename _Iterator>
+    auto
+    __miter_base(move_iterator<_Iterator> __it)
+    -> decltype(__miter_base(__it.base()))
+    { return __miter_base(__it.base()); }
+
+
+}
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 1 3
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3
+  template<typename>
+    class allocator;
+
+  template<>
+    class allocator<void>;
+
+
+  template<typename, typename>
+    struct uses_allocator;
+
+
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3
+  template<class _CharT>
+    struct char_traits;
+
+  template<> struct char_traits<char>;
+
+
+  template<> struct char_traits<wchar_t>;
+
+
+
+
+  template<> struct char_traits<char16_t>;
+  template<> struct char_traits<char32_t>;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+
+
+  typedef basic_string<char> string;
+
+
+
+  typedef basic_string<wchar_t> wstring;
+
+
+
+
+
+  typedef basic_string<char16_t> u16string;
+
+
+  typedef basic_string<char32_t> u32string;
+
+
+}
+
+
+
+
+}
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+namespace std
+{
+  using ::mbstate_t;
+}
+# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+
+  using ::swprintf;
+
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+
+  using ::vfwscanf;
+
+
+  using ::vswprintf;
+
+
+  using ::vswscanf;
+
+  using ::vwprintf;
+
+  using ::vwscanf;
+
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+
+  using ::wcstof;
+
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+
+
+  inline wchar_t*
+  wcschr(wchar_t* __p, wchar_t __c)
+  { return wcschr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
+  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wcsrchr(wchar_t* __p, wchar_t __c)
+  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
+
+  inline wchar_t*
+  wcsstr(wchar_t* __s1, const wchar_t* __s2)
+  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
+
+  inline wchar_t*
+  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
+  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
+
+
+
+}
+
+
+
+
+
+
+
+namespace __gnu_cxx
+{
+
+
+
+
+
+  using ::wcstold;
+# 257 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+  using ::wcstoll;
+  using ::wcstoull;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+# 277 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+namespace std
+{
+
+  using std::wcstof;
+
+
+  using std::vfwscanf;
+
+
+  using std::vswscanf;
+
+
+  using std::vwscanf;
+
+
+
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 2 3
+# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+  typedef long streamoff;
+# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+  typedef ptrdiff_t streamsize;
+# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+
+    public:
+
+
+
+
+      fpos()
+      : _M_off(0), _M_state() { }
+# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+
+
+      operator streamoff() const { return _M_off; }
+
+
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+
+
+      _StateT
+      state() const
+      { return _M_state; }
+
+
+
+
+
+      fpos&
+      operator+=(streamoff __off)
+      {
+ _M_off += __off;
+ return *this;
+      }
+
+
+
+
+
+      fpos&
+      operator-=(streamoff __off)
+      {
+ _M_off -= __off;
+ return *this;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator+(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos += __off;
+ return __pos;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator-(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos -= __off;
+ return __pos;
+      }
+
+
+
+
+
+
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+
+
+
+
+
+
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+
+
+
+
+
+  typedef fpos<mbstate_t> streampos;
+
+  typedef fpos<mbstate_t> wstreampos;
+
+
+
+  typedef fpos<mbstate_t> u16streampos;
+
+  typedef fpos<mbstate_t> u32streampos;
+
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+
+}
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+
+
+
+  typedef basic_ios<char> ios;
+
+
+  typedef basic_streambuf<char> streambuf;
+
+
+  typedef basic_istream<char> istream;
+
+
+  typedef basic_ostream<char> ostream;
+
+
+  typedef basic_iostream<char> iostream;
+
+
+  typedef basic_stringbuf<char> stringbuf;
+
+
+  typedef basic_istringstream<char> istringstream;
+
+
+  typedef basic_ostringstream<char> ostringstream;
+
+
+  typedef basic_stringstream<char> stringstream;
+
+
+  typedef basic_filebuf<char> filebuf;
+
+
+  typedef basic_ifstream<char> ifstream;
+
+
+  typedef basic_ofstream<char> ofstream;
+
+
+  typedef basic_fstream<char> fstream;
+
+
+
+  typedef basic_ios<wchar_t> wios;
+
+
+  typedef basic_streambuf<wchar_t> wstreambuf;
+
+
+  typedef basic_istream<wchar_t> wistream;
+
+
+  typedef basic_ostream<wchar_t> wostream;
+
+
+  typedef basic_iostream<wchar_t> wiostream;
+
+
+  typedef basic_stringbuf<wchar_t> wstringbuf;
+
+
+  typedef basic_istringstream<wchar_t> wistringstream;
+
+
+  typedef basic_ostringstream<wchar_t> wostringstream;
+
+
+  typedef basic_stringstream<wchar_t> wstringstream;
+
+
+  typedef basic_filebuf<wchar_t> wfilebuf;
+
+
+  typedef basic_ifstream<wchar_t> wifstream;
+
+
+  typedef basic_ofstream<wchar_t> wofstream;
+
+
+  typedef basic_fstream<wchar_t> wfstream;
+
+
+
+
+}
+# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 1 3
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
+    __attribute__((__format__(__gnu_printf__, 1, 2)));
+
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+
+
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+
+}
+# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+
+      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
+      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
+
+
+
+      static const bool __is_signed = ((_Value)(-1) < 0);
+      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
+    };
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+# 99 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+
+      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
+
+
+      static const bool __is_signed = true;
+      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
+      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
+    };
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+    __numeric_traits_integer<_Value>,
+    __numeric_traits_floating<_Value> >::__type
+    { };
+
+
+}
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 1 3
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
+
+
+  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
+
+
+  template<typename...>
+    class tuple;
+
+  template<std::size_t...>
+    struct _Index_tuple;
+
+
+
+
+
+
+  template <bool, typename _T1, typename _T2>
+    struct _PCC
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, const _U2&>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return __and_<is_convertible<const _U1&, _T1>,
+        is_convertible<const _U2&, _T2>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, _U2&&>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return __and_<is_convertible<_U1&&, _T1>,
+        is_convertible<_U2&&, _T2>>::value;
+      }
+
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _CopyMovePair()
+      {
+ using __do_converts = __and_<is_convertible<const _U1&, _T1>,
+      is_convertible<_U2&&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, _U2&&>,
+        __converts
+        >::value;
+      }
+
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _MoveCopyPair()
+      {
+ using __do_converts = __and_<is_convertible<_U1&&, _T1>,
+      is_convertible<const _U2&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, const _U2&&>,
+        __converts
+        >::value;
+      }
+  };
+
+  template <typename _T1, typename _T2>
+    struct _PCC<false, _T1, _T2>
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return false;
+      }
+  };
+# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    struct pair
+    {
+      typedef _T1 first_type;
+      typedef _T2 second_type;
+
+      _T1 first;
+      _T2 second;
+
+
+
+
+
+
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                                     __is_implicitly_default_constructible<_U1>,
+                                     __is_implicitly_default_constructible<_U2>>
+                                   ::value, bool>::type = true>
+
+      constexpr pair()
+      : first(), second() { }
+
+
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                       is_default_constructible<_U1>,
+                       is_default_constructible<_U2>,
+                       __not_<
+                         __and_<__is_implicitly_default_constructible<_U1>,
+                                __is_implicitly_default_constructible<_U2>>>>
+                                   ::value, bool>::type = false>
+      explicit constexpr pair()
+      : first(), second() { }
+# 233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+      using _PCCP = _PCC<true, _T1, _T2>;
+
+      template<typename _U1 = _T1, typename _U2=_T2, typename
+        enable_if<_PCCP::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCP::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+      constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+
+       template<typename _U1 = _T1, typename _U2=_T2, typename
+  enable_if<_PCCP::template
+       _ConstructiblePair<_U1, _U2>()
+                   && !_PCCP::template
+       _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+      explicit constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+# 261 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+      template <typename _U1, typename _U2>
+        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
+       || !is_same<_T2, _U2>::value,
+       _T1, _T2>;
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+     bool>::type=true>
+        constexpr pair(const pair<_U1, _U2>& __p)
+        : first(__p.first), second(__p.second) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+    && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(const pair<_U1, _U2>& __p)
+ : first(__p.first), second(__p.second) { }
+
+      constexpr pair(const pair&) = default;
+      constexpr pair(pair&&) = default;
+
+
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<true, _U1, _T2>(),
+                         bool>::type=true>
+       constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<false, _U1, _T2>(),
+                         bool>::type=false>
+       explicit constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<true, _T1, _U2>(),
+                         bool>::type=true>
+       constexpr pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<false, _T1, _U2>(),
+                         bool>::type=false>
+       explicit pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(pair<_U1, _U2>&& __p)
+ : first(std::forward<_U1>(__p.first)),
+   second(std::forward<_U2>(__p.second)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(pair<_U1, _U2>&& __p)
+ : first(std::forward<_U1>(__p.first)),
+   second(std::forward<_U2>(__p.second)) { }
+
+      template<typename... _Args1, typename... _Args2>
+        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
+
+      pair&
+      operator=(typename conditional<
+  __and_<is_copy_assignable<_T1>,
+         is_copy_assignable<_T2>>::value,
+  const pair&, const __nonesuch&>::type __p)
+      {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+      }
+
+      pair&
+      operator=(typename conditional<
+  __not_<__and_<is_copy_assignable<_T1>,
+                is_copy_assignable<_T2>>>::value,
+  const pair&, const __nonesuch&>::type __p) = delete;
+
+      pair&
+      operator=(typename conditional<
+  __and_<is_move_assignable<_T1>,
+         is_move_assignable<_T2>>::value,
+  pair&&, __nonesuch&&>::type __p)
+      noexcept(__and_<is_nothrow_move_assignable<_T1>,
+               is_nothrow_move_assignable<_T2>>::value)
+      {
+ first = std::forward<first_type>(__p.first);
+ second = std::forward<second_type>(__p.second);
+ return *this;
+      }
+
+      template<typename _U1, typename _U2>
+      typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
+    is_assignable<_T2&, const _U2&>>::value,
+    pair&>::type
+ operator=(const pair<_U1, _U2>& __p)
+ {
+   first = __p.first;
+   second = __p.second;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+      typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
+    is_assignable<_T2&, _U2&&>>::value,
+    pair&>::type
+ operator=(pair<_U1, _U2>&& __p)
+ {
+   first = std::forward<_U1>(__p.first);
+   second = std::forward<_U2>(__p.second);
+   return *this;
+ }
+
+      void
+      swap(pair& __p)
+      noexcept(__is_nothrow_swappable<_T1>::value
+               && __is_nothrow_swappable<_T2>::value)
+      {
+ using std::swap;
+ swap(first, __p.first);
+ swap(second, __p.second);
+      }
+
+    private:
+      template<typename... _Args1, std::size_t... _Indexes1,
+               typename... _Args2, std::size_t... _Indexes2>
+        pair(tuple<_Args1...>&, tuple<_Args2...>&,
+             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
+
+    };
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first < __y.first
+      || (!(__y.first < __x.first) && __x.second < __y.second); }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+
+
+
+
+
+  template<typename _T1, typename _T2>
+    inline void
+    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+# 490 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    constexpr pair<typename __decay_and_strip<_T1>::__type,
+                   typename __decay_and_strip<_T2>::__type>
+    make_pair(_T1&& __x, _T2&& __y)
+    {
+      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
+      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
+      typedef pair<__ds_type1, __ds_type2> __pair_type;
+      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
+    }
+# 510 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
+}
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 1 3
+# 48 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 3
+namespace std
+{
+  namespace __debug { }
+}
+
+
+
+
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 3
+namespace __gnu_cxx
+{
+namespace __ops
+{
+  struct _Iter_less_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      constexpr
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 < *__it2; }
+  };
+  constexpr
+  inline _Iter_less_iter
+  __iter_less_iter()
+  { return _Iter_less_iter(); }
+
+  struct _Iter_less_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it < __val; }
+    };
+
+  inline _Iter_less_val
+  __iter_less_val()
+  { return _Iter_less_val(); }
+
+  inline _Iter_less_val
+  __iter_comp_val(_Iter_less_iter)
+  { return _Iter_less_val(); }
+
+  struct _Val_less_iter
+  {
+    template<typename _Value, typename _Iterator>
+      bool
+      operator()(_Value& __val, _Iterator __it) const
+      { return __val < *__it; }
+    };
+
+  inline _Val_less_iter
+  __val_less_iter()
+  { return _Val_less_iter(); }
+
+  inline _Val_less_iter
+  __val_comp_iter(_Iter_less_iter)
+  { return _Val_less_iter(); }
+
+  struct _Iter_equal_to_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 == *__it2; }
+    };
+
+  inline _Iter_equal_to_iter
+  __iter_equal_to_iter()
+  { return _Iter_equal_to_iter(); }
+
+  struct _Iter_equal_to_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it == __val; }
+    };
+
+  inline _Iter_equal_to_val
+  __iter_equal_to_val()
+  { return _Iter_equal_to_val(); }
+
+  inline _Iter_equal_to_val
+  __iter_comp_val(_Iter_equal_to_iter)
+  { return _Iter_equal_to_val(); }
+
+  template<typename _Compare>
+    struct _Iter_comp_iter
+    {
+      _Compare _M_comp;
+      constexpr
+      _Iter_comp_iter(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Iterator1, typename _Iterator2>
+        constexpr
+        bool
+        operator()(_Iterator1 __it1, _Iterator2 __it2)
+        { return bool(_M_comp(*__it1, *__it2)); }
+    };
+
+  template<typename _Compare>
+    constexpr
+    inline _Iter_comp_iter<_Compare>
+    __iter_comp_iter(_Compare __comp)
+    { return _Iter_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    struct _Iter_comp_val
+    {
+      _Compare _M_comp;
+
+      _Iter_comp_val(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Iterator, typename _Value>
+ bool
+ operator()(_Iterator __it, _Value& __val)
+ { return bool(_M_comp(*__it, __val)); }
+    };
+
+  template<typename _Compare>
+   inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Compare __comp)
+    { return _Iter_comp_val<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
+    { return _Iter_comp_val<_Compare>(__comp._M_comp); }
+
+  template<typename _Compare>
+    struct _Val_comp_iter
+    {
+      _Compare _M_comp;
+
+      _Val_comp_iter(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Value, typename _Iterator>
+ bool
+ operator()(_Value& __val, _Iterator __it)
+ { return bool(_M_comp(__val, *__it)); }
+    };
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Compare __comp)
+    { return _Val_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
+    { return _Val_comp_iter<_Compare>(__comp._M_comp); }
+
+  template<typename _Value>
+    struct _Iter_equals_val
+    {
+      _Value& _M_value;
+
+      _Iter_equals_val(_Value& __value)
+ : _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return *__it == _M_value; }
+    };
+
+  template<typename _Value>
+    inline _Iter_equals_val<_Value>
+    __iter_equals_val(_Value& __val)
+    { return _Iter_equals_val<_Value>(__val); }
+
+  template<typename _Iterator1>
+    struct _Iter_equals_iter
+    {
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_equals_iter(_Iterator1 __it1)
+ : _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return *__it2 == _M_ref; }
+    };
+
+  template<typename _Iterator>
+    inline _Iter_equals_iter<_Iterator>
+    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
+    { return _Iter_equals_iter<_Iterator>(__it); }
+
+  template<typename _Predicate>
+    struct _Iter_pred
+    {
+      _Predicate _M_pred;
+
+      _Iter_pred(_Predicate __pred)
+ : _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_pred<_Predicate>
+    __pred_iter(_Predicate __pred)
+    { return _Iter_pred<_Predicate>(__pred); }
+
+  template<typename _Compare, typename _Value>
+    struct _Iter_comp_to_val
+    {
+      _Compare _M_comp;
+      _Value& _M_value;
+
+      _Iter_comp_to_val(_Compare __comp, _Value& __value)
+ : _M_comp(__comp), _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_comp(*__it, _M_value)); }
+    };
+
+  template<typename _Compare, typename _Value>
+    _Iter_comp_to_val<_Compare, _Value>
+    __iter_comp_val(_Compare __comp, _Value &__val)
+    { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
+
+  template<typename _Compare, typename _Iterator1>
+    struct _Iter_comp_to_iter
+    {
+      _Compare _M_comp;
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
+ : _M_comp(__comp), _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return bool(_M_comp(*__it2, _M_ref)); }
+    };
+
+  template<typename _Compare, typename _Iterator>
+    inline _Iter_comp_to_iter<_Compare, _Iterator>
+    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
+    { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
+
+  template<typename _Predicate>
+    struct _Iter_negate
+    {
+      _Predicate _M_pred;
+
+      _Iter_negate(_Predicate __pred)
+ : _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return !bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_negate<_Predicate>
+    __negate(_Iter_pred<_Predicate> __pred)
+    { return _Iter_negate<_Predicate>(__pred._M_pred); }
+
+}
+}
+# 72 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+      swap(*__a, *__b);
+
+    }
+# 164 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+
+
+
+
+
+                                                       ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+
+
+
+      if (__b < __a)
+ return __b;
+      return __a;
+    }
+# 216 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+
+
+
+      if (__a < __b)
+ return __b;
+      return __a;
+    }
+# 240 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+
+      if (__comp(__b, __a))
+ return __b;
+      return __a;
+    }
+# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+
+      if (__comp(__a, __b))
+ return __b;
+      return __a;
+    }
+
+
+
+  template<typename _Iterator>
+    inline _Iterator
+    __niter_base(_Iterator __it)
+    { return __it; }
+
+
+
+
+
+
+
+  template<bool, bool, typename>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   for (; __first != __last; ++__result, (void)++__first)
+     *__result = *__first;
+   return __result;
+ }
+    };
+
+
+  template<typename _Category>
+    struct __copy_move<true, false, _Category>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   for (; __first != __last; ++__result, (void)++__first)
+     *__result = std::move(*__first);
+   return __result;
+ }
+    };
+
+
+  template<>
+    struct __copy_move<false, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = *__first;
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+
+
+  template<>
+    struct __copy_move<true, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = std::move(*__first);
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+
+
+  template<bool _IsMove>
+    struct __copy_move<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+
+   static_assert( __assignable::type::value, "type is not assignable" );
+
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+   return __result + _Num;
+ }
+    };
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
+      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueTypeI)
+                      && __is_pointer<_II>::__value
+                      && __is_pointer<_OI>::__value
+        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
+
+      return std::__copy_move<_IsMove, __simple,
+                       _Category>::__copy_m(__first, __last, __result);
+    }
+
+
+
+  template<typename _CharT>
+    struct char_traits;
+
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator;
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(_CharT*, _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(const _CharT*, const _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
+     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a2(_II __first, _II __last, _OI __result)
+    {
+      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+
+
+
+
+                                                     ;
+
+      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+# 477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+    inline _OI
+    move(_II __first, _II __last, _OI __result)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__copy_move_a2<true>(std::__miter_base(__first),
+           std::__miter_base(__last), __result);
+    }
+
+
+
+
+
+
+  template<bool, bool, typename>
+    struct __copy_move_backward
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   while (__first != __last)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+
+
+  template<typename _Category>
+    struct __copy_move_backward<true, false, _Category>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   while (__first != __last)
+     *--__result = std::move(*--__last);
+   return __result;
+ }
+    };
+
+
+  template<>
+    struct __copy_move_backward<false, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+
+
+  template<>
+    struct __copy_move_backward<true, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = std::move(*--__last);
+   return __result;
+ }
+    };
+
+
+  template<bool _IsMove>
+    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+
+   static_assert( __assignable::type::value, "type is not assignable" );
+
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+   return __result - _Num;
+ }
+    };
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
+      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueType1)
+                      && __is_pointer<_BI1>::__value
+                      && __is_pointer<_BI2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__copy_move_backward<_IsMove, __simple,
+                                _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      return _BI2(std::__copy_move_backward_a<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+# 620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+# 656 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
+      std::__miter_base(__last),
+      __result);
+    }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+       const _Tp& __value)
+    {
+      for (; __first != __last; ++__first)
+ *__first = __value;
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __first != __last; ++__first)
+ *__first = __tmp;
+    }
+
+
+  template<typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
+    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+      if (const size_t __len = __last - __first)
+ __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
+    }
+# 722 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+
+
+
+                                                     ;
+
+      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
+      __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __value;
+      return __first;
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+
+  template<typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
+    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
+    {
+      std::__fill_a(__first, __first + __n, __c);
+      return __first + __n;
+    }
+# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _OI, typename _Size, typename _Tp>
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+
+
+
+      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
+    }
+
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+        static bool
+        equal(_II1 __first1, _II1 __last1, _II2 __first2)
+        {
+   for (; __first1 != __last1; ++__first1, (void)++__first2)
+     if (!(*__first1 == *__first2))
+       return false;
+   return true;
+ }
+    };
+
+  template<>
+    struct __equal<true>
+    {
+      template<typename _Tp>
+        static bool
+        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
+        {
+   if (const size_t __len = (__last1 - __first1))
+     return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
+   return true;
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+         || __is_pointer<_ValueType1>::__value)
+                      && __is_pointer<_II1>::__value
+                      && __is_pointer<_II2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+        static _II1
+        __newlast1(_II1, _II1 __last1, _II2, _II2)
+        { return __last1; }
+
+      template<typename _II>
+        static bool
+        __cnd2(_II __first, _II __last)
+        { return __first != __last; }
+    };
+
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+        static _RAI1
+        __newlast1(_RAI1 __first1, _RAI1 __last1,
+     _RAI2 __first2, _RAI2 __last2)
+        {
+   const typename iterator_traits<_RAI1>::difference_type
+     __diff1 = __last1 - __first1;
+   const typename iterator_traits<_RAI2>::difference_type
+     __diff2 = __last2 - __first2;
+   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+ }
+
+      template<typename _RAI>
+        static bool
+        __cnd2(_RAI, _RAI)
+        { return true; }
+    };
+
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+    ++__first1, (void)++__first2)
+ {
+   if (__comp(__first1, __first2))
+     return true;
+   if (__comp(__first2, __first1))
+     return false;
+ }
+      return __first1 == __last1 && __first2 != __last2;
+    }
+
+  template<bool _BoolType>
+    struct __lexicographical_compare
+    {
+      template<typename _II1, typename _II2>
+        static bool __lc(_II1, _II1, _II2, _II2);
+    };
+
+  template<bool _BoolType>
+    template<typename _II1, typename _II2>
+      bool
+      __lexicographical_compare<_BoolType>::
+      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+      {
+ return std::__lexicographical_compare_impl(__first1, __last1,
+         __first2, __last2,
+     __gnu_cxx::__ops::__iter_less_iter());
+      }
+
+  template<>
+    struct __lexicographical_compare<true>
+    {
+      template<typename _Tp, typename _Up>
+        static bool
+        __lc(const _Tp* __first1, const _Tp* __last1,
+      const _Up* __first2, const _Up* __last2)
+ {
+   const size_t __len1 = __last1 - __first1;
+   const size_t __len2 = __last2 - __first2;
+   if (const size_t __len = std::min(__len1, __len2))
+     if (int __result = __builtin_memcmp(__first1, __first2, __len))
+       return __result < 0;
+   return __len1 < __len2;
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+      _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+ (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+  && __is_pointer<_II1>::__value
+  && __is_pointer<_II2>::__value);
+
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+           __first2, __last2);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+# 982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+
+
+
+                                                                  ;
+
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val());
+    }
+
+
+
+  inline constexpr int
+  __lg(int __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr unsigned
+  __lg(unsigned __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr long
+  __lg(long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr unsigned long
+  __lg(unsigned long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr long long
+  __lg(long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+  inline constexpr unsigned long long
+  __lg(unsigned long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+# 1039 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+
+
+
+
+
+
+                                                       ;
+
+      return std::__equal_aux(std::__niter_base(__first1),
+         std::__niter_base(__last1),
+         std::__niter_base(__first2));
+    }
+# 1071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+
+
+                                                       ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return true;
+    }
+# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2);
+ }
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!(*__first1 == *__first2))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+# 1153 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
+    {
+
+
+
+                                                       ;
+                                                       ;
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2,
+           __binary_pred);
+ }
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+# 1201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2)
+    {
+# 1215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+                                                       ;
+                                                       ;
+
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+      std::__niter_base(__last1),
+      std::__niter_base(__first2),
+      std::__niter_base(__last2));
+    }
+# 1237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2, typename _Compare>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__lexicographical_compare_impl
+ (__first1, __last1, __first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __binary_pred(__first1, __first2))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1280 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2)
+    {
+
+
+
+
+
+
+                                                       ;
+
+      return std::__mismatch(__first1, __last1, __first2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1313 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+
+
+                                                       ;
+
+      return std::__mismatch(__first1, __last1, __first2,
+ __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __first2 != __last2
+      && __binary_pred(__first1, __first2))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1395 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _BinaryPredicate __binary_pred)
+    {
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+}
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+# 82 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static std::size_t
+      length(const char_type* __s);
+
+      static const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+
+      static constexpr char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof()
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+
+  template<typename _CharT>
+    int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+ if (lt(__s1[__i], __s2[__i]))
+   return -1;
+ else if (lt(__s2[__i], __s1[__i]))
+   return 1;
+      return 0;
+    }
+
+  template<typename _CharT>
+    std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+
+  template<typename _CharT>
+    const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+          __n * sizeof(char_type)));
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 226 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+
+
+
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      {
+
+ return (static_cast<unsigned char>(__c1)
+  < static_cast<unsigned char>(__c2));
+      }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return 0;
+ return __builtin_memcmp(__s1, __s2, __n);
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { return __builtin_strlen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return static_cast<char_type>(__c); }
+
+
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return (__c == eof()) ? 0 : __c; }
+  };
+
+
+
+
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t char_type;
+      typedef wint_t int_type;
+      typedef streamoff off_type;
+      typedef wstreampos pos_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return 0;
+ return wmemcmp(__s1, __s2, __n);
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { return wcslen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+ return wmemchr(__s, __a, __n);
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemmove(__s1, __s2, __n);
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemcpy(__s1, __s2, __n);
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return wmemset(__s, __a, __n);
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>((0xffffffffu)); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+
+
+
+}
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3
+# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3
+namespace std
+{
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+}
+# 421 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<>
+    struct char_traits<char16_t>
+    {
+      typedef char16_t char_type;
+      typedef uint_least16_t int_type;
+      typedef streamoff off_type;
+      typedef u16streampos pos_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+
+      static size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+  template<>
+    struct char_traits<char32_t>
+    {
+      typedef char32_t char_type;
+      typedef uint_least32_t int_type;
+      typedef streamoff off_type;
+      typedef u32streampos pos_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+
+      static size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 3
+
+
+# 1 "/usr/include/locale.h" 1 3 4
+# 28 "/usr/include/locale.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 29 "/usr/include/locale.h" 2 3 4
+# 1 "/usr/include/bits/locale.h" 1 3 4
+# 30 "/usr/include/locale.h" 2 3 4
+
+extern "C" {
+# 53 "/usr/include/locale.h" 3 4
+struct lconv
+{
+
+
+  char *decimal_point;
+  char *thousands_sep;
+
+
+
+
+
+  char *grouping;
+
+
+
+
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+
+  char p_cs_precedes;
+
+  char p_sep_by_space;
+
+  char n_cs_precedes;
+
+  char n_sep_by_space;
+
+
+
+
+
+
+  char p_sign_posn;
+  char n_sign_posn;
+
+
+  char int_p_cs_precedes;
+
+  char int_p_sep_by_space;
+
+  char int_n_cs_precedes;
+
+  char int_n_sep_by_space;
+
+
+
+
+
+
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+# 120 "/usr/include/locale.h" 3 4
+};
+
+
+
+extern char *setlocale (int __category, const char *__locale) throw ();
+
+
+extern struct lconv *localeconv (void) throw ();
+# 151 "/usr/include/locale.h" 3 4
+extern __locale_t newlocale (int __category_mask, const char *__locale,
+        __locale_t __base) throw ();
+# 186 "/usr/include/locale.h" 3 4
+extern __locale_t duplocale (__locale_t __dataset) throw ();
+
+
+
+extern void freelocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+extern __locale_t uselocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+
+}
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 2 3
+
+
+
+
+
+
+
+
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+
+}
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __locale_t __c_locale;
+
+
+
+
+
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+
+
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+
+
+
+
+    __builtin_va_end(__args);
+
+
+    __gnu_cxx::__uselocale(__old);
+
+
+
+
+
+
+
+    return __ret;
+  }
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
+
+
+# 1 "/usr/include/ctype.h" 1 3 4
+# 28 "/usr/include/ctype.h" 3 4
+extern "C" {
+# 46 "/usr/include/ctype.h" 3 4
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+# 79 "/usr/include/ctype.h" 3 4
+extern const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const__));
+# 110 "/usr/include/ctype.h" 3 4
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+
+
+
+extern int tolower (int __c) throw ();
+
+
+extern int toupper (int __c) throw ();
+# 136 "/usr/include/ctype.h" 3 4
+extern int isblank (int) throw ();
+
+
+
+
+
+
+extern int isctype (int __c, int __mask) throw ();
+
+
+
+
+
+
+extern int isascii (int __c) throw ();
+
+
+
+extern int toascii (int __c) throw ();
+
+
+
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+# 271 "/usr/include/ctype.h" 3 4
+extern int isalnum_l (int, __locale_t) throw ();
+extern int isalpha_l (int, __locale_t) throw ();
+extern int iscntrl_l (int, __locale_t) throw ();
+extern int isdigit_l (int, __locale_t) throw ();
+extern int islower_l (int, __locale_t) throw ();
+extern int isgraph_l (int, __locale_t) throw ();
+extern int isprint_l (int, __locale_t) throw ();
+extern int ispunct_l (int, __locale_t) throw ();
+extern int isspace_l (int, __locale_t) throw ();
+extern int isupper_l (int, __locale_t) throw ();
+extern int isxdigit_l (int, __locale_t) throw ();
+
+extern int isblank_l (int, __locale_t) throw ();
+
+
+
+extern int __tolower_l (int __c, __locale_t __l) throw ();
+extern int tolower_l (int __c, __locale_t __l) throw ();
+
+
+extern int __toupper_l (int __c, __locale_t __l) throw ();
+extern int toupper_l (int __c, __locale_t __l) throw ();
+# 347 "/usr/include/ctype.h" 3 4
+}
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 2 3
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+}
+
+
+
+
+
+
+
+namespace std
+{
+  using ::isblank;
+}
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3
+  class locale;
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isblank(_CharT, const locale&);
+
+
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+
+
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+
+  template<> class ctype<wchar_t>;
+
+  template<typename _CharT>
+    class ctype_byname;
+
+
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+
+
+
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+
+namespace __cxx11 {
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+}
+
+namespace __cxx11 {
+
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT>
+    class collate_byname;
+}
+
+
+  class time_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+}
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+
+
+  class money_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+}
+namespace __cxx11 {
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+}
+
+
+  class messages_base;
+namespace __cxx11 {
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+}
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 1 3
+# 30 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3
+#pragma GCC visibility push(default)
+# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+# 1 "/usr/include/pthread.h" 1 3 4
+# 23 "/usr/include/pthread.h" 3 4
+# 1 "/usr/include/sched.h" 1 3 4
+# 28 "/usr/include/sched.h" 3 4
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 29 "/usr/include/sched.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/time.h" 1 3 4
+# 35 "/usr/include/sched.h" 2 3 4
+
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/sched.h" 1 3 4
+# 73 "/usr/include/bits/sched.h" 3 4
+struct sched_param
+  {
+    int __sched_priority;
+  };
+
+extern "C" {
+
+
+
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+
+
+extern int unshare (int __flags) throw ();
+
+
+extern int sched_getcpu (void) throw ();
+
+
+extern int setns (int __fd, int __nstype) throw ();
+
+
+
+}
+
+
+
+
+
+
+
+struct __sched_param
+  {
+    int __sched_priority;
+  };
+# 119 "/usr/include/bits/sched.h" 3 4
+typedef unsigned long int __cpu_mask;
+
+
+
+
+
+
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+# 202 "/usr/include/bits/sched.h" 3 4
+extern "C" {
+
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+  throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+
+}
+# 44 "/usr/include/sched.h" 2 3 4
+
+
+
+
+extern "C" {
+
+
+extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
+     throw ();
+
+
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
+
+
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          const struct sched_param *__param) throw ();
+
+
+extern int sched_getscheduler (__pid_t __pid) throw ();
+
+
+extern int sched_yield (void) throw ();
+
+
+extern int sched_get_priority_max (int __algorithm) throw ();
+
+
+extern int sched_get_priority_min (int __algorithm) throw ();
+
+
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
+# 118 "/usr/include/sched.h" 3 4
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         const cpu_set_t *__cpuset) throw ();
+
+
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+
+
+}
+# 24 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 29 "/usr/include/time.h" 3 4
+extern "C" {
+
+
+
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
+# 38 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 88 "/usr/include/bits/time.h" 3 4
+# 1 "/usr/include/bits/timex.h" 1 3 4
+# 25 "/usr/include/bits/timex.h" 3 4
+struct timex
+{
+  unsigned int modes;
+  __syscall_slong_t offset;
+  __syscall_slong_t freq;
+  __syscall_slong_t maxerror;
+  __syscall_slong_t esterror;
+  int status;
+  __syscall_slong_t constant;
+  __syscall_slong_t precision;
+  __syscall_slong_t tolerance;
+  struct timeval time;
+  __syscall_slong_t tick;
+  __syscall_slong_t ppsfreq;
+  __syscall_slong_t jitter;
+  int shift;
+  __syscall_slong_t stabil;
+  __syscall_slong_t jitcnt;
+  __syscall_slong_t calcnt;
+  __syscall_slong_t errcnt;
+  __syscall_slong_t stbcnt;
+
+  int tai;
+
+
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32;
+};
+# 89 "/usr/include/bits/time.h" 2 3 4
+
+extern "C" {
+
+
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
+
+}
+# 42 "/usr/include/time.h" 2 3 4
+# 133 "/usr/include/time.h" 3 4
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  const char *tm_zone;
+
+
+
+
+};
+# 161 "/usr/include/time.h" 3 4
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+
+struct sigevent;
+# 189 "/usr/include/time.h" 3 4
+extern clock_t clock (void) throw ();
+
+
+extern time_t time (time_t *__timer) throw ();
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) throw ();
+
+
+
+
+
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *strptime (const char *__restrict __s,
+         const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+
+
+
+
+
+
+
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+
+
+
+extern char *strptime_l (const char *__restrict __s,
+    const char *__restrict __fmt, struct tm *__tp,
+    __locale_t __loc) throw ();
+
+
+
+
+
+
+extern struct tm *gmtime (const time_t *__timer) throw ();
+
+
+
+extern struct tm *localtime (const time_t *__timer) throw ();
+
+
+
+
+
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *asctime (const struct tm *__tp) throw ();
+
+
+extern char *ctime (const time_t *__timer) throw ();
+
+
+
+
+
+
+
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+
+
+
+
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) throw ();
+
+
+
+extern int daylight;
+extern long int timezone;
+
+
+
+
+
+extern int stime (const time_t *__when) throw ();
+# 319 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) throw ();
+
+
+extern time_t timelocal (struct tm *__tp) throw ();
+
+
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+# 334 "/usr/include/time.h" 3 4
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     throw ();
+
+
+
+
+
+
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+
+
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+
+
+extern int timer_delete (timer_t __timerid) throw ();
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+
+
+extern int timer_getoverrun (timer_t __timerid) throw ();
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 403 "/usr/include/time.h" 3 4
+extern int getdate_err;
+# 412 "/usr/include/time.h" 3 4
+extern struct tm *getdate (const char *__string);
+# 426 "/usr/include/time.h" 3 4
+extern int getdate_r (const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+
+
+}
+# 25 "/usr/include/pthread.h" 2 3 4
+
+
+# 1 "/usr/include/bits/setjmp.h" 1 3 4
+# 26 "/usr/include/bits/setjmp.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 27 "/usr/include/bits/setjmp.h" 2 3 4
+
+
+
+
+typedef long int __jmp_buf[8];
+# 28 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/pthread.h" 2 3 4
+
+
+
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+
+  PTHREAD_CREATE_DETACHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+
+
+
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+
+};
+
+
+
+
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+
+
+
+
+
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+# 114 "/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+# 155 "/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+
+  PTHREAD_EXPLICIT_SCHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+
+  PTHREAD_SCOPE_PROCESS
+
+};
+
+
+
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+
+  PTHREAD_PROCESS_SHARED
+
+};
+# 190 "/usr/include/pthread.h" 3 4
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+
+
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+
+  PTHREAD_CANCEL_DISABLE
+
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+
+  PTHREAD_CANCEL_ASYNCHRONOUS
+
+};
+# 228 "/usr/include/pthread.h" 3 4
+extern "C" {
+
+
+
+
+extern int pthread_create (pthread_t *__restrict __newthread,
+      const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern int pthread_join (pthread_t __th, void **__thread_return);
+
+
+
+
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+
+
+
+
+
+
+
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     const struct timespec *__abstime);
+
+
+
+
+
+
+extern int pthread_detach (pthread_t __th) throw ();
+
+
+
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+
+
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
+  throw () __attribute__ ((__const__));
+
+
+
+
+
+
+
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+
+
+
+
+
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+
+
+extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+extern int pthread_getattr_default_np (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+
+
+
+
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int pthread_getconcurrency (void) throw ();
+
+
+extern int pthread_setconcurrency (int __level) throw ();
+
+
+
+
+
+
+
+extern int pthread_yield (void) throw ();
+
+
+
+
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 494 "/usr/include/pthread.h" 3 4
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+# 506 "/usr/include/pthread.h" 3 4
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+
+
+
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+
+
+extern int pthread_cancel (pthread_t __th);
+
+
+
+
+extern void pthread_testcancel (void);
+
+
+
+
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+# 540 "/usr/include/pthread.h" 3 4
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+
+
+
+
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+# 742 "/usr/include/pthread.h" 3 4
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+
+
+
+
+
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 806 "/usr/include/pthread.h" 3 4
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 888 "/usr/include/pthread.h" 3 4
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         const pthread_condattr_t *__restrict __cond_attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+# 1000 "/usr/include/pthread.h" 3 4
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_getpshared (const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_condattr_getclock (const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1044 "/usr/include/pthread.h" 3 4
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1111 "/usr/include/pthread.h" 3 4
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+
+
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+
+
+extern int pthread_setspecific (pthread_key_t __key,
+    const void *__pointer) throw () ;
+
+
+
+
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+# 1145 "/usr/include/pthread.h" 3 4
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) throw ();
+# 1159 "/usr/include/pthread.h" 3 4
+}
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 2 3
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+# 101 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
+
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
+
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
+
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
+
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
+
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
+
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
+
+static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
+
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
+# 236 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
+# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw___pthread_key_create;
+  return __gthread_active_ptr != 0;
+}
+# 658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+
+static inline void
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    __gthrw_pthread_mutex_init (__mutex, __null);
+}
+
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+# 807 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+
+
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_destroy (__mutex);
+}
+# 849 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 2 3
+
+
+#pragma GCC visibility pop
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 1 3
+# 32 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 3
+typedef int _Atomic_word;
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  static inline _Atomic_word
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, 4); }
+
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, 4); }
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+
+
+
+  }
+
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+
+
+
+  }
+
+
+}
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 1 3
+# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using std::size_t;
+  using std::ptrdiff_t;
+# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef new_allocator<_Tp1> other; };
+
+
+
+
+      typedef std::true_type propagate_on_container_move_assignment;
+
+
+      new_allocator() noexcept { }
+
+      new_allocator(const new_allocator&) noexcept { }
+
+      template<typename _Tp1>
+        new_allocator(const new_allocator<_Tp1>&) noexcept { }
+
+      ~new_allocator() noexcept { }
+
+      pointer
+      address(reference __x) const noexcept
+      { return std::__addressof(__x); }
+
+      const_pointer
+      address(const_reference __x) const noexcept
+      { return std::__addressof(__x); }
+
+
+
+      pointer
+      allocate(size_type __n, const void* = 0)
+      {
+ if (__n > this->max_size())
+   std::__throw_bad_alloc();
+
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+
+
+      void
+      deallocate(pointer __p, size_type)
+      { ::operator delete(__p); }
+
+      size_type
+      max_size() const noexcept
+      { return size_t(-1) / sizeof(_Tp); }
+
+
+      template<typename _Up, typename... _Args>
+        void
+        construct(_Up* __p, _Args&&... __args)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+        void
+        destroy(_Up* __p) { __p->~_Up(); }
+# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
+    };
+
+  template<typename _Tp>
+    inline bool
+    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return false; }
+
+
+}
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 2 3
+
+
+namespace std
+{
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3
+  template<typename _Tp>
+    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
+}
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 2 3
+# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef void* pointer;
+      typedef const void* const_pointer;
+      typedef void value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+      typedef true_type is_always_equal;
+
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+ void
+ destroy(_Up* __p) { __p->~_Up(); }
+
+    };
+# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator: public __allocator_base<_Tp>
+    {
+   public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+      typedef true_type is_always_equal;
+
+
+      allocator() throw() { }
+
+      allocator(const allocator& __a) throw()
+      : __allocator_base<_Tp>(__a) { }
+
+      template<typename _Tp1>
+        allocator(const allocator<_Tp1>&) throw() { }
+
+      ~allocator() throw() { }
+
+
+    };
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return true; }
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return false; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return false; }
+
+
+
+
+
+
+  extern template class allocator<char>;
+  extern template class allocator<wchar_t>;
+
+
+
+
+
+
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_swap
+    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
+
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
+      {
+
+ if (__one != __two)
+   swap(__one, __two);
+      }
+    };
+
+
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_neq
+    {
+      static bool
+      _S_do_it(const _Alloc&, const _Alloc&)
+      { return false; }
+    };
+
+  template<typename _Alloc>
+    struct __alloc_neq<_Alloc, false>
+    {
+      static bool
+      _S_do_it(const _Alloc& __one, const _Alloc& __two)
+      { return __one != __two; }
+    };
+
+
+  template<typename _Tp, bool
+    = __or_<is_copy_constructible<typename _Tp::value_type>,
+            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
+    struct __shrink_to_fit_aux
+    { static bool _S_do_it(_Tp&) noexcept { return false; } };
+
+  template<typename _Tp>
+    struct __shrink_to_fit_aux<_Tp, true>
+    {
+      static bool
+      _S_do_it(_Tp& __c) noexcept
+      {
+
+ try
+   {
+     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
+  __make_move_if_noexcept_iterator(__c.end()),
+  __c.get_allocator()).swap(__c);
+     return true;
+   }
+ catch(...)
+   { return false; }
+
+
+
+      }
+    };
+
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 3
+
+#pragma GCC visibility push(default)
+
+
+namespace __cxxabiv1
+{
+
+
+
+
+
+
+
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+
+
+    virtual void __pure_dummy() = 0;
+  };
+}
+
+
+#pragma GCC visibility pop
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+
+
+
+}
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+
+      typedef _Arg argument_type;
+
+
+      typedef _Result result_type;
+    };
+
+
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+
+      typedef _Arg1 first_argument_type;
+
+
+      typedef _Arg2 second_argument_type;
+
+
+      typedef _Result result_type;
+    };
+# 144 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  struct __is_transparent;
+
+  template<typename _Tp = void>
+    struct plus;
+
+  template<typename _Tp = void>
+    struct minus;
+
+  template<typename _Tp = void>
+    struct multiplies;
+
+  template<typename _Tp = void>
+    struct divides;
+
+  template<typename _Tp = void>
+    struct modulus;
+
+  template<typename _Tp = void>
+    struct negate;
+
+
+
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+
+
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+
+
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+
+
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+
+
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+
+
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+
+
+
+
+
+  template<>
+    struct plus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct minus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct multiplies<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct divides<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct modulus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct negate<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(-std::forward<_Tp>(__t)))
+ -> decltype(-std::forward<_Tp>(__t))
+ { return -std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Tp = void>
+    struct equal_to;
+
+  template<typename _Tp = void>
+    struct not_equal_to;
+
+  template<typename _Tp = void>
+    struct greater;
+
+  template<typename _Tp = void>
+    struct less;
+
+  template<typename _Tp = void>
+    struct greater_equal;
+
+  template<typename _Tp = void>
+    struct less_equal;
+
+
+
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+    };
+
+
+  template<typename _Tp>
+    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+
+
+
+  template<>
+    struct equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct not_equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct greater<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct less<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct greater_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct less_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Tp = void>
+    struct logical_and;
+
+  template<typename _Tp = void>
+    struct logical_or;
+
+  template<typename _Tp = void>
+    struct logical_not;
+
+
+
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+
+
+
+  template<>
+    struct logical_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct logical_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct logical_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(!std::forward<_Tp>(__t)))
+ -> decltype(!std::forward<_Tp>(__t))
+ { return !std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+
+
+  template<typename _Tp = void>
+    struct bit_and;
+
+  template<typename _Tp = void>
+    struct bit_or;
+
+  template<typename _Tp = void>
+    struct bit_xor;
+
+  template<typename _Tp = void>
+    struct bit_not;
+
+
+
+
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_not : public unary_function<_Tp, _Tp>
+    {
+    constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return ~__x; }
+    };
+
+
+  template <>
+    struct bit_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_xor<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(~std::forward<_Tp>(__t)))
+ -> decltype(~std::forward<_Tp>(__t))
+ { return ~std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 740 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      constexpr
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      constexpr
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+
+
+  template<typename _Predicate>
+    constexpr
+    inline unary_negate<_Predicate>
+    not1(const _Predicate& __pred)
+    { return unary_negate<_Predicate>(__pred); }
+
+
+  template<typename _Predicate>
+    class binary_negate
+    : public binary_function<typename _Predicate::first_argument_type,
+        typename _Predicate::second_argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      constexpr
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      constexpr
+      bool
+      operator()(const typename _Predicate::first_argument_type& __x,
+   const typename _Predicate::second_argument_type& __y) const
+      { return !_M_pred(__x, __y); }
+    };
+
+
+  template<typename _Predicate>
+    constexpr
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+# 817 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg);
+
+    public:
+      pointer_to_unary_function() { }
+
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+
+
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+
+    public:
+      pointer_to_binary_function() { }
+
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+
+
+  template<typename _Tp>
+    struct _Identity
+    : public unary_function<_Tp,_Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+
+  template<typename _Pair>
+    struct _Select1st
+    : public unary_function<_Pair, typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+
+
+      template<typename _Pair2>
+        typename _Pair2::first_type&
+        operator()(_Pair2& __x) const
+        { return __x.first; }
+
+      template<typename _Pair2>
+        const typename _Pair2::first_type&
+        operator()(const _Pair2& __x) const
+        { return __x.first; }
+
+    };
+
+  template<typename _Pair>
+    struct _Select2nd
+    : public unary_function<_Pair, typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+# 937 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+
+
+
+}
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+
+    public:
+      binder1st(const _Operation& __x,
+  const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } __attribute__ ((__deprecated__));
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+
+
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+
+    public:
+      binder2nd(const _Operation& __x,
+  const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } __attribute__ ((__deprecated__));
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    }
+
+
+
+}
+
+#pragma GCC diagnostic pop
+# 1128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 2 3
+# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 3
+
+
+
+
+
+#pragma GCC visibility push(default)
+
+
+
+namespace std
+{
+
+  template<class _E>
+    class initializer_list
+    {
+    public:
+      typedef _E value_type;
+      typedef const _E& reference;
+      typedef const _E& const_reference;
+      typedef size_t size_type;
+      typedef const _E* iterator;
+      typedef const _E* const_iterator;
+
+    private:
+      iterator _M_array;
+      size_type _M_len;
+
+
+      constexpr initializer_list(const_iterator __a, size_type __l)
+      : _M_array(__a), _M_len(__l) { }
+
+    public:
+      constexpr initializer_list() noexcept
+      : _M_array(0), _M_len(0) { }
+
+
+      constexpr size_type
+      size() const noexcept { return _M_len; }
+
+
+      constexpr const_iterator
+      begin() const noexcept { return _M_array; }
+
+
+      constexpr const_iterator
+      end() const noexcept { return begin() + size(); }
+    };
+
+
+
+
+
+
+  template<class _Tp>
+    constexpr const _Tp*
+    begin(initializer_list<_Tp> __ils) noexcept
+    { return __ils.begin(); }
+
+
+
+
+
+
+  template<class _Tp>
+    constexpr const _Tp*
+    end(initializer_list<_Tp> __ils) noexcept
+    { return __ils.end(); }
+}
+
+#pragma GCC visibility pop
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 2 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    begin(_Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    begin(const _Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    end(_Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    end(const _Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    begin(_Tp (&__arr)[_Nm])
+    { return __arr; }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    end(_Tp (&__arr)[_Nm])
+    { return __arr + _Nm; }
+
+
+
+  template<typename _Tp> class valarray;
+
+  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
+  template<typename _Tp> _Tp* end(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
+      -> decltype(std::begin(__cont))
+    { return std::begin(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
+      -> decltype(std::end(__cont))
+    { return std::end(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rend(_Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rend(const _Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rbegin(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr + _Nm); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rend(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline reverse_iterator<const _Tp*>
+    rbegin(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.end()); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline reverse_iterator<const _Tp*>
+    rend(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.begin()); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
+    { return std::rbegin(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    crend(const _Container& __cont) -> decltype(std::rend(__cont))
+    { return std::rend(__cont); }
+# 320 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3
+}
+# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 1 3
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  struct __allocator_traits_base
+  {
+    template<typename _Alloc, typename _Up>
+      using __rebind = typename _Alloc::template rebind<_Up>::other;
+
+  protected:
+    template<typename _Tp>
+      using __pointer = typename _Tp::pointer;
+    template<typename _Tp>
+      using __c_pointer = typename _Tp::const_pointer;
+    template<typename _Tp>
+      using __v_pointer = typename _Tp::void_pointer;
+    template<typename _Tp>
+      using __cv_pointer = typename _Tp::const_void_pointer;
+    template<typename _Tp>
+      using __diff_type = typename _Tp::difference_type;
+    template<typename _Tp>
+      using __size_type = typename _Tp::size_type;
+    template<typename _Tp>
+      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
+    template<typename _Tp>
+      using __pocma = typename _Tp::propagate_on_container_move_assignment;
+    template<typename _Tp>
+      using __pocs = typename _Tp::propagate_on_container_swap;
+    template<typename _Tp>
+      using __equal = typename _Tp::is_always_equal;
+  };
+
+  template<typename _Alloc, typename _Up>
+    using __alloc_rebind = __detected_or_t_<__replace_first_arg_t,
+         __allocator_traits_base::__rebind,
+         _Alloc, _Up>;
+
+
+
+
+
+  template<typename _Alloc>
+    struct allocator_traits : __allocator_traits_base
+    {
+
+      typedef _Alloc allocator_type;
+
+      typedef typename _Alloc::value_type value_type;
+
+
+
+
+
+
+      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
+
+
+
+
+
+
+
+      using const_pointer
+ = __detected_or_t<__ptr_rebind<pointer, const value_type>,
+     __c_pointer, _Alloc>;
+
+
+
+
+
+
+
+      using void_pointer
+ = __detected_or_t<__ptr_rebind<pointer, void>, __v_pointer, _Alloc>;
+
+
+
+
+
+
+
+      using const_void_pointer
+ = __detected_or_t<__ptr_rebind<pointer, const void>, __cv_pointer,
+     _Alloc>;
+
+
+
+
+
+
+
+      using difference_type
+ = __detected_or_t<typename pointer_traits<pointer>::difference_type,
+     __diff_type, _Alloc>;
+
+
+
+
+
+
+
+      using size_type
+ = __detected_or_t<typename make_unsigned<difference_type>::type,
+     __size_type, _Alloc>;
+
+
+
+
+
+
+
+      using propagate_on_container_copy_assignment
+ = __detected_or_t<false_type, __pocca, _Alloc>;
+
+
+
+
+
+
+
+      using propagate_on_container_move_assignment
+ = __detected_or_t<false_type, __pocma, _Alloc>;
+
+
+
+
+
+
+
+      using propagate_on_container_swap
+ = __detected_or_t<false_type, __pocs, _Alloc>;
+
+
+
+
+
+
+
+      using is_always_equal
+ = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
+
+      template<typename _Tp>
+ using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
+      template<typename _Tp>
+ using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
+
+      static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value,
+   "allocator defines rebind or is like Alloc<T, Args>");
+
+    private:
+      template<typename _Alloc2>
+ static auto
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
+ -> decltype(__a.allocate(__n, __hint))
+ { return __a.allocate(__n, __hint); }
+
+      template<typename _Alloc2>
+ static pointer
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
+ { return __a.allocate(__n); }
+
+      template<typename _Tp, typename... _Args>
+ struct __construct_helper
+ {
+   template<typename _Alloc2,
+     typename = decltype(std::declval<_Alloc2*>()->construct(
+    std::declval<_Tp*>(), std::declval<_Args>()...))>
+     static true_type __test(int);
+
+   template<typename>
+     static false_type __test(...);
+
+   using type = decltype(__test<_Alloc>(0));
+ };
+
+      template<typename _Tp, typename... _Args>
+ using __has_construct
+   = typename __construct_helper<_Tp, _Args...>::type;
+
+      template<typename _Tp, typename... _Args>
+ static _Require<__has_construct<_Tp, _Args...>>
+ _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+
+      template<typename _Tp, typename... _Args>
+ static
+ _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+          is_constructible<_Tp, _Args...>>>
+ _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
+ { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
+
+      template<typename _Alloc2, typename _Tp>
+ static auto
+ _S_destroy(_Alloc2& __a, _Tp* __p, int)
+ -> decltype(__a.destroy(__p))
+ { __a.destroy(__p); }
+
+      template<typename _Alloc2, typename _Tp>
+ static void
+ _S_destroy(_Alloc2&, _Tp* __p, ...)
+ { __p->~_Tp(); }
+
+      template<typename _Alloc2>
+ static auto
+ _S_max_size(_Alloc2& __a, int)
+ -> decltype(__a.max_size())
+ { return __a.max_size(); }
+
+      template<typename _Alloc2>
+ static size_type
+ _S_max_size(_Alloc2&, ...)
+ {
+
+
+   return __gnu_cxx::__numeric_traits<size_type>::__max
+     / sizeof(value_type);
+ }
+
+      template<typename _Alloc2>
+ static auto
+ _S_select(_Alloc2& __a, int)
+ -> decltype(__a.select_on_container_copy_construction())
+ { return __a.select_on_container_copy_construction(); }
+
+      template<typename _Alloc2>
+ static _Alloc2
+ _S_select(_Alloc2& __a, ...)
+ { return __a; }
+
+    public:
+# 279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint, 0); }
+# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static void
+      deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      template<typename _Tp, typename... _Args>
+ static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+ { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      template<typename _Tp>
+ static void destroy(_Alloc& __a, _Tp* __p)
+ { _S_destroy(__a, __p, 0); }
+# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static size_type max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static _Alloc
+      select_on_container_copy_construction(const _Alloc& __rhs)
+      { return _S_select(__rhs, 0); }
+    };
+
+
+  template<typename _Tp>
+    struct allocator_traits<allocator<_Tp>>
+    {
+
+      using allocator_type = allocator<_Tp>;
+
+      using value_type = _Tp;
+
+
+      using pointer = _Tp*;
+
+
+      using const_pointer = const _Tp*;
+
+
+      using void_pointer = void*;
+
+
+      using const_void_pointer = const void*;
+
+
+      using difference_type = std::ptrdiff_t;
+
+
+      using size_type = std::size_t;
+
+
+      using propagate_on_container_copy_assignment = false_type;
+
+
+      using propagate_on_container_move_assignment = true_type;
+
+
+      using propagate_on_container_swap = false_type;
+
+
+      using is_always_equal = true_type;
+
+      template<typename _Up>
+ using rebind_alloc = allocator<_Up>;
+
+      template<typename _Up>
+ using rebind_traits = allocator_traits<allocator<_Up>>;
+# 414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(allocator_type& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 428 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
+      { return __a.allocate(__n, __hint); }
+# 440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      static void
+      deallocate(allocator_type& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      template<typename _Up, typename... _Args>
+ static void
+ construct(allocator_type& __a, _Up* __p, _Args&&... __args)
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+# 464 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
+      template<typename _Up>
+ static void
+ destroy(allocator_type& __a, _Up* __p)
+ { __a.destroy(__p); }
+
+
+
+
+
+
+      static size_type
+      max_size(const allocator_type& __a) noexcept
+      { return __a.max_size(); }
+
+
+
+
+
+
+      static allocator_type
+      select_on_container_copy_construction(const allocator_type& __rhs)
+      { return __rhs; }
+    };
+
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
+    { __one = __two; }
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
+      __do_alloc_on_copy(__one, __two, __pocca());
+    }
+
+  template<typename _Alloc>
+    inline _Alloc __alloc_on_copy(const _Alloc& __a)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      return __traits::select_on_container_copy_construction(__a);
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
+    { __one = std::move(__two); }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_move_assignment __pocma;
+      __do_alloc_on_move(__one, __two, __pocma());
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
+    {
+      using std::swap;
+      swap(__one, __two);
+    }
+
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
+    { }
+
+  template<typename _Alloc>
+    inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_swap __pocs;
+      __do_alloc_on_swap(__one, __two, __pocs());
+    }
+
+  template<typename _Alloc>
+    class __is_copy_insertable_impl
+    {
+      typedef allocator_traits<_Alloc> _Traits;
+
+      template<typename _Up, typename
+        = decltype(_Traits::construct(std::declval<_Alloc&>(),
+          std::declval<_Up*>(),
+          std::declval<const _Up&>()))>
+ static true_type
+ _M_select(int);
+
+      template<typename _Up>
+ static false_type
+ _M_select(...);
+
+    public:
+      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
+    };
+
+
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_copy_insertable_impl<_Alloc>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+
+
+}
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 2 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+template<typename _Alloc>
+  struct __alloc_traits
+
+  : std::allocator_traits<_Alloc>
+
+  {
+    typedef _Alloc allocator_type;
+
+    typedef std::allocator_traits<_Alloc> _Base_type;
+    typedef typename _Base_type::value_type value_type;
+    typedef typename _Base_type::pointer pointer;
+    typedef typename _Base_type::const_pointer const_pointer;
+    typedef typename _Base_type::size_type size_type;
+    typedef typename _Base_type::difference_type difference_type;
+
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    using _Base_type::allocate;
+    using _Base_type::deallocate;
+    using _Base_type::construct;
+    using _Base_type::destroy;
+    using _Base_type::max_size;
+
+  private:
+    template<typename _Ptr>
+      using __is_custom_pointer
+ = std::__and_<std::is_same<pointer, _Ptr>,
+        std::__not_<std::is_pointer<_Ptr>>>;
+
+  public:
+
+    template<typename _Ptr, typename... _Args>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+      {
+ _Base_type::construct(__a, std::addressof(*__p),
+         std::forward<_Args>(__args)...);
+      }
+
+
+    template<typename _Ptr>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      destroy(_Alloc& __a, _Ptr __p)
+      { _Base_type::destroy(__a, std::addressof(*__p)); }
+
+    static _Alloc _S_select_on_copy(const _Alloc& __a)
+    { return _Base_type::select_on_container_copy_construction(__a); }
+
+    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
+    { std::__alloc_on_swap(__a, __b); }
+
+    static constexpr bool _S_propagate_on_copy_assign()
+    { return _Base_type::propagate_on_container_copy_assignment::value; }
+
+    static constexpr bool _S_propagate_on_move_assign()
+    { return _Base_type::propagate_on_container_move_assignment::value; }
+
+    static constexpr bool _S_propagate_on_swap()
+    { return _Base_type::propagate_on_container_swap::value; }
+
+    static constexpr bool _S_always_equal()
+    { return _Base_type::is_always_equal::value; }
+
+    static constexpr bool _S_nothrow_move()
+    { return _S_propagate_on_move_assign() || _S_always_equal(); }
+
+    template<typename _Tp>
+      struct rebind
+      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
+# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3
+  };
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+namespace __cxx11 {
+# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+
+
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Char_alloc_type allocator_type;
+      typedef typename _Alloc_traits::size_type size_type;
+      typedef typename _Alloc_traits::difference_type difference_type;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+       const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+
+
+      static const size_type npos = static_cast<size_type>(-1);
+
+    private:
+
+
+
+
+      typedef const_iterator __const_iterator;
+
+
+
+      struct _Alloc_hider : allocator_type
+      {
+ _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
+ : allocator_type(__a), _M_p(__dat) { }
+
+ pointer _M_p;
+      };
+
+      _Alloc_hider _M_dataplus;
+      size_type _M_string_length;
+
+      enum { _S_local_capacity = 15 / sizeof(_CharT) };
+
+      union
+      {
+ _CharT _M_local_buf[_S_local_capacity + 1];
+ size_type _M_allocated_capacity;
+      };
+
+      void
+      _M_data(pointer __p)
+      { _M_dataplus._M_p = __p; }
+
+      void
+      _M_length(size_type __length)
+      { _M_string_length = __length; }
+
+      pointer
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      pointer
+      _M_local_data()
+      {
+
+ return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      const_pointer
+      _M_local_data() const
+      {
+
+ return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      void
+      _M_capacity(size_type __capacity)
+      { _M_allocated_capacity = __capacity; }
+
+      void
+      _M_set_length(size_type __n)
+      {
+ _M_length(__n);
+ traits_type::assign(_M_data()[__n], _CharT());
+      }
+
+      bool
+      _M_is_local() const
+      { return _M_data() == _M_local_data(); }
+
+
+      pointer
+      _M_create(size_type&, size_type);
+
+      void
+      _M_dispose()
+      {
+ if (!_M_is_local())
+   _M_destroy(_M_allocated_capacity);
+      }
+
+      void
+      _M_destroy(size_type __size) throw()
+      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
+
+
+
+      template<typename _InIterator>
+        void
+        _M_construct_aux(_InIterator __beg, _InIterator __end,
+    std::__false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          _M_construct(__beg, __end, _Tag());
+ }
+
+
+
+      template<typename _Integer>
+        void
+        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
+ { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
+
+      void
+      _M_construct_aux_2(size_type __req, _CharT __c)
+      { _M_construct(__req, __c); }
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   _M_construct_aux(__beg, __end, _Integral());
+        }
+
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end,
+       std::input_iterator_tag);
+
+
+
+      template<typename _FwdIterator>
+        void
+        _M_construct(_FwdIterator __beg, _FwdIterator __end,
+       std::forward_iterator_tag);
+
+      void
+      _M_construct(size_type __req, _CharT __c);
+
+      allocator_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+
+    private:
+# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),
+
+       __s, __pos, this->size());
+ return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+
+
+
+      size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+
+
+      bool
+      _M_disjunct(const _CharT* __s) const noexcept
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+
+
+
+      static void
+      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+
+      static void
+      _S_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+
+
+
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, (void)++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ const difference_type __d = difference_type(__n1 - __n2);
+
+ if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+   return __gnu_cxx::__numeric_traits<int>::__max;
+ else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+   return __gnu_cxx::__numeric_traits<int>::__min;
+ else
+   return int(__d);
+      }
+
+      void
+      _M_assign(const basic_string& __rcs);
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+  size_type __len2);
+
+      void
+      _M_erase(size_type __pos, size_type __n);
+
+    public:
+
+
+
+
+
+
+
+      basic_string()
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+      : _M_dataplus(_M_local_data())
+      { _M_set_length(0); }
+
+
+
+
+      explicit
+      basic_string(const _Alloc& __a) noexcept
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_set_length(0); }
+
+
+
+
+
+      basic_string(const basic_string& __str)
+      : _M_dataplus(_M_local_data(),
+      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
+      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+# 410 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n = npos)
+      : _M_dataplus(_M_local_data())
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start
+   = __str._M_data() + __str._M_check(__pos, "string::string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s + __n); }
+
+
+
+
+
+
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
+
+
+
+
+
+
+
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__n, __c); }
+# 476 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string(basic_string&& __str) noexcept
+      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+   }
+ else
+   {
+     _M_data(__str._M_data());
+     _M_capacity(__str._M_allocated_capacity);
+   }
+
+
+
+
+ _M_length(__str.length());
+ __str._M_data(__str._M_local_data());
+ __str._M_set_length(0);
+      }
+
+
+
+
+
+
+      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__l.begin(), __l.end()); }
+
+      basic_string(const basic_string& __str, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__str.begin(), __str.end()); }
+
+      basic_string(basic_string&& __str, const _Alloc& __a)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+     _M_length(__str.length());
+     __str._M_set_length(0);
+   }
+ else if (_Alloc_traits::_S_always_equal()
+     || __str.get_allocator() == __a)
+   {
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     __str._M_data(__str._M_local_buf);
+     __str._M_set_length(0);
+   }
+ else
+   _M_construct(__str.begin(), __str.end());
+      }
+# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc())
+ : _M_dataplus(_M_local_data(), __a)
+ { _M_construct(__beg, __end); }
+
+
+
+
+      ~basic_string()
+      { _M_dispose(); }
+
+
+
+
+
+      basic_string&
+      operator=(const basic_string& __str)
+      {
+
+ if (_Alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
+  && _M_get_allocator() != __str._M_get_allocator())
+       {
+
+  _M_destroy(_M_allocated_capacity);
+  _M_data(_M_local_data());
+  _M_set_length(0);
+       }
+     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
+   }
+
+ return this->assign(__str);
+      }
+
+
+
+
+
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+# 599 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+# 617 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      operator=(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
+     && !_Alloc_traits::_S_always_equal()
+     && _M_get_allocator() != __str._M_get_allocator())
+   {
+
+     _M_destroy(_M_allocated_capacity);
+     _M_data(_M_local_data());
+     _M_set_length(0);
+   }
+
+ std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
+
+ if (!__str._M_is_local()
+     && (_Alloc_traits::_S_propagate_on_move_assign()
+       || _Alloc_traits::_S_always_equal()))
+   {
+     pointer __data = nullptr;
+     size_type __capacity;
+     if (!_M_is_local())
+       {
+  if (_Alloc_traits::_S_always_equal())
+    {
+      __data = _M_data();
+      __capacity = _M_allocated_capacity;
+    }
+  else
+    _M_destroy(_M_allocated_capacity);
+       }
+
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     if (__data)
+       {
+  __str._M_data(__data);
+  __str._M_capacity(__capacity);
+       }
+     else
+       __str._M_data(__str._M_local_buf);
+   }
+ else
+     assign(__str);
+ __str.clear();
+ return *this;
+      }
+
+
+
+
+
+      basic_string&
+      operator=(initializer_list<_CharT> __l)
+      {
+ this->assign(__l.begin(), __l.size());
+ return *this;
+      }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return iterator(_M_data()); }
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_data()); }
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return iterator(_M_data() + this->size()); }
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_M_data() + this->size()); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(this->end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(this->begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_data()); }
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_data() + this->size()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+
+    public:
+
+
+
+      size_type
+      size() const noexcept
+      { return _M_string_length; }
+
+
+
+      size_type
+      length() const noexcept
+      { return _M_string_length; }
+
+
+      size_type
+      max_size() const noexcept
+      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
+# 813 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      void
+      resize(size_type __n, _CharT __c);
+# 826 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+
+
+
+      void
+      shrink_to_fit() noexcept
+      {
+
+ if (capacity() > size())
+   {
+     try
+       { reserve(0); }
+     catch(...)
+       { }
+   }
+
+      }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      {
+ return _M_is_local() ? size_type(_S_local_capacity)
+                      : _M_allocated_capacity;
+      }
+# 875 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      void
+      reserve(size_type __res_arg = 0);
+
+
+
+
+      void
+      clear() noexcept
+      { _M_set_length(0); }
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return this->size() == 0; }
+# 904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      const_reference
+      operator[] (size_type __pos) const noexcept
+      {
+                                  ;
+ return _M_data()[__pos];
+      }
+# 921 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      reference
+      operator[](size_type __pos)
+      {
+
+
+                                  ;
+
+                                                                   ;
+ return _M_data()[__pos];
+      }
+# 942 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+
+
+       __n, this->size());
+ return _M_data()[__n];
+      }
+# 963 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+
+
+       __n, this->size());
+ return _M_data()[__n];
+      }
+
+
+
+
+
+
+      reference
+      front() noexcept
+      {
+                           ;
+ return operator[](0);
+      }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      {
+                           ;
+ return operator[](0);
+      }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+                           ;
+ return operator[](this->size() - 1);
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+                           ;
+ return operator[](this->size() - 1);
+      }
+# 1026 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+
+
+
+
+
+
+
+      basic_string&
+      operator+=(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+
+
+
+
+
+
+
+      basic_string&
+      append(const basic_string& __str)
+      { return _M_append(__str._M_data(), __str.size()); }
+# 1084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n)
+      { return _M_append(__str._M_data()
+    + __str._M_check(__pos, "basic_string::append"),
+    __str._M_limit(__pos, __n)); }
+
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s, size_type __n)
+      {
+                                        ;
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s)
+      {
+                               ;
+ const size_type __n = traits_type::length(__s);
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+# 1126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      append(size_type __n, _CharT __c)
+      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+
+
+
+
+
+
+
+      basic_string&
+      append(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+# 1150 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(end(), end(), __first, __last); }
+
+
+
+
+
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __size = this->size();
+ if (__size + 1 > this->capacity())
+   this->_M_mutate(__size, size_type(0), 0, size_type(1));
+ traits_type::assign(this->_M_data()[__size], __c);
+ this->_M_set_length(__size + 1);
+      }
+
+
+
+
+
+
+      basic_string&
+      assign(const basic_string& __str)
+      {
+ this->_M_assign(__str);
+ return *this;
+      }
+# 1194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+
+
+ return *this = std::move(__str);
+      }
+# 1217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+     + __str._M_check(__pos, "basic_string::assign"),
+     __str._M_limit(__pos, __n)); }
+# 1233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+                                        ;
+ return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s)
+      {
+                               ;
+ return _M_replace(size_type(0), this->size(), __s,
+     traits_type::length(__s));
+      }
+# 1266 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+# 1279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(begin(), end(), __first, __last); }
+
+
+
+
+
+
+
+      basic_string&
+      assign(initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.size()); }
+# 1315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      iterator
+      insert(const_iterator __p, size_type __n, _CharT __c)
+      {
+                                                         ;
+ const size_type __pos = __p - begin();
+ this->replace(__p, __p, __n, __c);
+ return iterator(this->_M_data() + __pos);
+      }
+# 1357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
+        {
+                                                           ;
+   const size_type __pos = __p - begin();
+   this->replace(__p, __p, __beg, __end);
+   return iterator(this->_M_data() + __pos);
+ }
+# 1393 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      void
+      insert(iterator __p, initializer_list<_CharT> __l)
+      {
+                                                         ;
+ this->insert(__p - begin(), __l.begin(), __l.size());
+      }
+# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->replace(__pos1, size_type(0),
+        __str._M_data(), __str.size()); }
+# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+        + __str._M_check(__pos2, "basic_string::insert"),
+        __str._M_limit(__pos2, __n)); }
+# 1459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n)
+      { return this->replace(__pos, size_type(0), __s, __n); }
+# 1478 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+                               ;
+ return this->replace(__pos, size_type(0), __s,
+        traits_type::length(__s));
+      }
+# 1502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+# 1520 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      iterator
+      insert(__const_iterator __p, _CharT __c)
+      {
+                                                         ;
+ const size_type __pos = __p - begin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ return iterator(_M_data() + __pos);
+      }
+# 1544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ this->_M_erase(_M_check(__pos, "basic_string::erase"),
+         _M_limit(__pos, __n));
+ return *this;
+      }
+# 1560 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __position)
+      {
+
+                           ;
+ const size_type __pos = __position - begin();
+ this->_M_erase(__pos, size_type(1));
+ return iterator(_M_data() + __pos);
+      }
+# 1579 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __first, __const_iterator __last)
+      {
+
+                        ;
+        const size_type __pos = __first - begin();
+ this->_M_erase(__pos, __last - __first);
+ return iterator(this->_M_data() + __pos);
+      }
+
+
+
+
+
+
+
+      void
+      pop_back() noexcept
+      {
+                           ;
+ _M_erase(size() - 1, 1);
+      }
+# 1620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+# 1642 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+# 1667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2)
+      {
+                                         ;
+ return _M_replace(_M_check(__pos, "basic_string::replace"),
+     _M_limit(__pos, __n1), __s, __n2);
+      }
+# 1692 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+                               ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+# 1716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+# 1734 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+# 1754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __s, size_type __n)
+      {
+
+                      ;
+ return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
+      }
+# 1776 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
+      {
+                               ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+# 1797 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
+       _CharT __c)
+      {
+
+                      ;
+ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
+      }
+# 1822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        replace(const_iterator __i1, const_iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+
+                        ;
+                                             ;
+   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
+        std::__false_type());
+ }
+# 1854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       _CharT* __k1, _CharT* __k2)
+      {
+
+                      ;
+                                           ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+
+                      ;
+                                           ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       iterator __k1, iterator __k2)
+      {
+
+                      ;
+                                           ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+
+                      ;
+                                           ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+# 1913 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string& replace(const_iterator __i1, const_iterator __i2,
+       initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
+
+
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _Integer __n, _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _InputIterator __k1, _InputIterator __k2,
+       __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+
+      basic_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+   const size_type __len2);
+
+      basic_string&
+      _M_append(const _CharT* __s, size_type __n);
+
+    public:
+# 1956 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+# 1966 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      void
+      swap(basic_string& __s) noexcept;
+# 1976 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      const _CharT*
+      c_str() const noexcept
+      { return _M_data(); }
+
+
+
+
+
+
+
+      const _CharT*
+      data() const noexcept
+      { return _M_data(); }
+
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_get_allocator(); }
+# 2009 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+ noexcept
+      { return this->find(__str.data(), __pos, __str.size()); }
+# 2037 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+                               ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+# 2054 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+# 2067 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+ noexcept
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+# 2084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2097 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+                               ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+# 2114 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+ noexcept
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+# 2145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+                               ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+# 2177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+# 2192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+ noexcept
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2222 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+                               ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+# 2241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
+      { return this->rfind(__c, __pos); }
+# 2255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+ noexcept
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+# 2272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const;
+# 2286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+                               ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2303 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+ noexcept;
+# 2318 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+ noexcept
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+# 2335 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const;
+# 2349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+                               ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2366 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+ noexcept;
+# 2382 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+# 2401 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+# 2433 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+# 2459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2) const;
+# 2477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(const _CharT* __s) const;
+# 2501 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+# 2528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+  };
+}
+# 4927 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    {
+      const auto __size = __lhs.size() + __rhs.size();
+      const bool __cond = (__size > __lhs.capacity()
+      && __size <= __rhs.capacity());
+      return __cond ? std::move(__rhs.insert(0, __lhs))
+             : std::move(__lhs.append(__rhs));
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, 1, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const _CharT* __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       _CharT __rhs)
+    { return std::move(__lhs.append(1, __rhs)); }
+# 5048 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) == 0; }
+
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+        const basic_string<_CharT>& __rhs) noexcept
+    { return (__lhs.size() == __rhs.size()
+       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+          __lhs.size())); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+# 5095 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+# 5133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+# 5171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+# 5209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+# 5247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+# 5285 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+# 5305 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+# 5323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+
+
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+# 5346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+# 5363 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str, __is.widen('\n')); }
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    { return std::getline(__is, __str, __delim); }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str); }
+
+
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+     char __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+     wchar_t __delim);
+
+
+
+}
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 3
+
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
+# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+
+
+
+
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+
+  using ::tmpnam;
+
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+}
+# 157 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
+namespace __gnu_cxx
+{
+# 175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+}
+# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3
+
+
+# 1 "/usr/include/errno.h" 1 3 4
+# 31 "/usr/include/errno.h" 3 4
+extern "C" {
+
+
+
+
+# 1 "/usr/include/bits/errno.h" 1 3 4
+# 24 "/usr/include/bits/errno.h" 3 4
+# 1 "/usr/include/linux/errno.h" 1 3 4
+# 1 "/usr/include/asm/errno.h" 1 3 4
+# 1 "/usr/include/asm-generic/errno.h" 1 3 4
+
+
+
+# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
+# 5 "/usr/include/asm-generic/errno.h" 2 3 4
+# 2 "/usr/include/asm/errno.h" 2 3 4
+# 2 "/usr/include/linux/errno.h" 2 3 4
+# 25 "/usr/include/bits/errno.h" 2 3 4
+# 50 "/usr/include/bits/errno.h" 3 4
+extern int *__errno_location (void) throw () __attribute__ ((__const__));
+# 36 "/usr/include/errno.h" 2 3 4
+# 54 "/usr/include/errno.h" 3 4
+extern char *program_invocation_name, *program_invocation_short_name;
+
+
+
+}
+# 68 "/usr/include/errno.h" 3 4
+typedef int error_t;
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
+    typename... _Base>
+    _Ret
+    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
+    const char* __name, const _CharT* __str, std::size_t* __idx,
+    _Base... __base)
+    {
+      _Ret __ret;
+
+      _CharT* __endptr;
+
+      struct _Save_errno {
+ _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
+ ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
+ int _M_errno;
+      } const __save_errno;
+
+      const _TRet __tmp = __convf(__str, &__endptr, __base...);
+
+      if (__endptr == __str)
+ std::__throw_invalid_argument(__name);
+      else if ((*__errno_location ()) == 34
+        || (std::__are_same<_Ret, int>::__value
+     && (__tmp < __numeric_traits<int>::__min
+         || __tmp > __numeric_traits<int>::__max)))
+ std::__throw_out_of_range(__name);
+      else
+ __ret = __tmp;
+
+      if (__idx)
+ *__idx = __endptr - __str;
+
+      return __ret;
+    }
+
+
+  template<typename _String, typename _CharT = typename _String::value_type>
+    _String
+    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
+     __builtin_va_list), std::size_t __n,
+   const _CharT* __fmt, ...)
+    {
+
+
+      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+         * __n));
+
+      __builtin_va_list __args;
+      __builtin_va_start(__args, __fmt);
+
+      const int __len = __convf(__s, __n, __fmt, __args);
+
+      __builtin_va_end(__args);
+
+      return _String(__s, __s + __len);
+    }
+
+
+}
+# 5403 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+
+
+
+  inline int
+  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
+     __idx, __base); }
+
+  inline long
+  stol(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long
+  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
+        __idx, __base); }
+
+  inline long long
+  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long long
+  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
+        __idx, __base); }
+
+
+  inline float
+  stof(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
+
+
+
+
+
+
+  inline string
+  to_string(int __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
+        "%d", __val); }
+
+  inline string
+  to_string(unsigned __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned),
+        "%u", __val); }
+
+  inline string
+  to_string(long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
+        "%ld", __val); }
+
+  inline string
+  to_string(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned long),
+        "%lu", __val); }
+
+  inline string
+  to_string(long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(long long),
+        "%lld", __val); }
+
+  inline string
+  to_string(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned long long),
+        "%llu", __val); }
+
+  inline string
+  to_string(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+
+  inline string
+  to_string(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+
+  inline string
+  to_string(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%Lf", __val);
+  }
+
+
+
+  inline int
+  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
+     __idx, __base); }
+
+  inline long
+  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long
+  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
+        __idx, __base); }
+
+  inline long long
+  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long long
+  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
+        __idx, __base); }
+
+
+  inline float
+  stof(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
+
+
+
+  inline wstring
+  to_wstring(int __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
+         L"%d", __val); }
+
+  inline wstring
+  to_wstring(unsigned __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned),
+         L"%u", __val); }
+
+  inline wstring
+  to_wstring(long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
+         L"%ld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long),
+         L"%lu", __val); }
+
+  inline wstring
+  to_wstring(long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(long long),
+         L"%lld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long long),
+         L"%llu", __val); }
+
+  inline wstring
+  to_wstring(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%Lf", __val);
+  }
+
+
+
+}
+
+}
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 3
+
+
+
+namespace std
+{
+
+
+
+
+
+
+
+  size_t
+  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+
+
+
+
+
+  size_t
+  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+
+
+}
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
+  template<typename _Result, typename _Arg>
+    struct __hash_base
+    {
+      typedef _Result result_type;
+      typedef _Arg argument_type;
+    };
+
+
+  template<typename _Tp>
+    struct hash;
+
+
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __hash_enum
+    {
+    private:
+
+      __hash_enum(__hash_enum&&);
+      ~__hash_enum();
+    };
+
+
+  template<typename _Tp>
+    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
+    {
+      size_t
+      operator()(_Tp __val) const noexcept
+      {
+       using __type = typename underlying_type<_Tp>::type;
+       return hash<__type>{}(static_cast<__type>(__val));
+      }
+    };
+
+
+
+  template<typename _Tp>
+    struct hash : __hash_enum<_Tp>
+    { };
+
+
+  template<typename _Tp>
+    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
+    {
+      size_t
+      operator()(_Tp* __p) const noexcept
+      { return reinterpret_cast<size_t>(__p); }
+    };
+# 108 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
+  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
+# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
+  struct _Hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(0xc70f6907UL))
+    { return _Hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+  struct _Fnv_hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(2166136261UL))
+    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+
+  template<>
+    struct hash<float> : public __hash_base<size_t, float>
+    {
+      size_t
+      operator()(float __val) const noexcept
+      {
+
+ return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+
+  template<>
+    struct hash<double> : public __hash_base<size_t, double>
+    {
+      size_t
+      operator()(double __val) const noexcept
+      {
+
+ return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+
+  template<>
+    struct hash<long double>
+    : public __hash_base<size_t, long double>
+    {
+      __attribute__ ((__pure__)) size_t
+      operator()(long double __val) const noexcept;
+    };
+
+
+
+
+
+
+
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+
+}
+# 5629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template<>
+    struct hash<string>
+    : public __hash_base<size_t, string>
+    {
+      size_t
+      operator()(const string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<string>> : std::false_type
+    { };
+
+
+
+  template<>
+    struct hash<wstring>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const wstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<wstring>> : std::false_type
+    { };
+
+
+
+
+
+  template<>
+    struct hash<u16string>
+    : public __hash_base<size_t, u16string>
+    {
+      size_t
+      operator()(const u16string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u16string>> : std::false_type
+    { };
+
+
+  template<>
+    struct hash<u32string>
+    : public __hash_base<size_t, u32string>
+    {
+      size_t
+      operator()(const u32string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u32string>> : std::false_type
+    { };
+# 5707 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
+  inline namespace literals
+  {
+  inline namespace string_literals
+  {
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char>
+    operator""s(const char* __str, size_t __len)
+    { return basic_string<char>{__str, __len}; }
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<wchar_t>
+    operator""s(const wchar_t* __str, size_t __len)
+    { return basic_string<wchar_t>{__str, __len}; }
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char16_t>
+    operator""s(const char16_t* __str, size_t __len)
+    { return basic_string<char16_t>{__str, __len}; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char32_t>
+    operator""s(const char32_t* __str, size_t __len)
+    { return basic_string<char32_t>{__str, __len}; }
+
+
+
+  }
+  }
+
+
+
+}
+# 53 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 1 3
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s) noexcept
+    {
+      if (this == &__s)
+ return;
+
+      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
+
+      if (_M_is_local())
+ if (__s._M_is_local())
+   {
+     if (length() && __s.length())
+       {
+  _CharT __tmp_data[_S_local_capacity + 1];
+  traits_type::copy(__tmp_data, __s._M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(_M_local_buf, __tmp_data,
+      _S_local_capacity + 1);
+       }
+     else if (__s.length())
+       {
+  traits_type::copy(_M_local_buf, __s._M_local_buf,
+      _S_local_capacity + 1);
+  _M_length(__s.length());
+  __s._M_set_length(0);
+  return;
+       }
+     else if (length())
+       {
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  __s._M_length(length());
+  _M_set_length(0);
+  return;
+       }
+   }
+ else
+   {
+     const size_type __tmp_capacity = __s._M_allocated_capacity;
+     traits_type::copy(__s._M_local_buf, _M_local_buf,
+         _S_local_capacity + 1);
+     _M_data(__s._M_data());
+     __s._M_data(__s._M_local_buf);
+     _M_capacity(__tmp_capacity);
+   }
+      else
+ {
+   const size_type __tmp_capacity = _M_allocated_capacity;
+   if (__s._M_is_local())
+     {
+       traits_type::copy(_M_local_buf, __s._M_local_buf,
+    _S_local_capacity + 1);
+       __s._M_data(_M_data());
+       _M_data(_M_local_buf);
+     }
+   else
+     {
+       pointer __tmp_ptr = _M_data();
+       _M_data(__s._M_data());
+       __s._M_data(__tmp_ptr);
+       _M_capacity(__s._M_allocated_capacity);
+     }
+   __s._M_capacity(__tmp_capacity);
+ }
+
+      const size_type __tmp_length = length();
+      _M_length(__s.length());
+      __s._M_length(__tmp_length);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::pointer
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_create(size_type& __capacity, size_type __old_capacity)
+    {
+
+
+      if (__capacity > max_size())
+ std::__throw_length_error(("basic_string::_M_create"));
+
+
+
+
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ {
+   __capacity = 2 * __old_capacity;
+
+   if (__capacity > max_size())
+     __capacity = max_size();
+ }
+
+
+
+      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
+    }
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::input_iterator_tag)
+      {
+ size_type __len = 0;
+ size_type __capacity = size_type(_S_local_capacity);
+
+ while (__beg != __end && __len < __capacity)
+   {
+     _M_data()[__len++] = *__beg;
+     ++__beg;
+   }
+
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __capacity)
+    {
+
+      __capacity = __len + 1;
+      pointer __another = _M_create(__capacity, __len);
+      this->_S_copy(__another, _M_data(), __len);
+      _M_dispose();
+      _M_data(__another);
+      _M_capacity(__capacity);
+    }
+  _M_data()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__len);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::forward_iterator_tag)
+      {
+
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   std::__throw_logic_error(("basic_string::" "_M_construct null not valid"));
+
+
+ size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
+
+ if (__dnew > size_type(_S_local_capacity))
+   {
+     _M_data(_M_create(__dnew, size_type(0)));
+     _M_capacity(__dnew);
+   }
+
+
+ try
+   { this->_S_copy_chars(_M_data(), __beg, __end); }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__dnew);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_construct(size_type __n, _CharT __c)
+    {
+      if (__n > size_type(_S_local_capacity))
+ {
+   _M_data(_M_create(__n, size_type(0)));
+   _M_capacity(__n);
+ }
+
+      if (__n)
+ this->_S_assign(_M_data(), __n, __c);
+
+      _M_set_length(__n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_assign(const basic_string& __str)
+    {
+      if (this != &__str)
+ {
+   const size_type __rsize = __str.length();
+   const size_type __capacity = capacity();
+
+   if (__rsize > __capacity)
+     {
+       size_type __new_capacity = __rsize;
+       pointer __tmp = _M_create(__new_capacity, __capacity);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__new_capacity);
+     }
+
+   if (__rsize)
+     this->_S_copy(_M_data(), __str._M_data(), __rsize);
+
+   _M_set_length(__rsize);
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+
+      if (__res < length())
+ __res = length();
+
+      const size_type __capacity = capacity();
+      if (__res != __capacity)
+ {
+   if (__res > __capacity
+       || __res > size_type(_S_local_capacity))
+     {
+       pointer __tmp = _M_create(__res, __capacity);
+       this->_S_copy(__tmp, _M_data(), length() + 1);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__res);
+     }
+   else if (!_M_is_local())
+     {
+       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
+       _M_destroy(__capacity);
+       _M_data(_M_local_data());
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+       size_type __len2)
+    {
+      const size_type __how_much = length() - __pos - __len1;
+
+      size_type __new_capacity = length() + __len2 - __len1;
+      pointer __r = _M_create(__new_capacity, capacity());
+
+      if (__pos)
+ this->_S_copy(__r, _M_data(), __pos);
+      if (__s && __len2)
+ this->_S_copy(__r + __pos, __s, __len2);
+      if (__how_much)
+ this->_S_copy(__r + __pos + __len2,
+        _M_data() + __pos + __len1, __how_much);
+
+      _M_dispose();
+      _M_data(__r);
+      _M_capacity(__new_capacity);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __how_much = length() - __pos - __n;
+
+      if (__how_much && __n)
+ this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
+
+      _M_set_length(length() - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->_M_erase(__n, __size - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_append(const _CharT* __s, size_type __n)
+    {
+      const size_type __len = __n + this->size();
+
+      if (__len <= this->capacity())
+ {
+   if (__n)
+     this->_S_copy(this->_M_data() + this->size(), __s, __n);
+ }
+      else
+ this->_M_mutate(this->size(), size_type(0), __s, __n);
+
+      this->_M_set_length(__len);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+     _InputIterator __k1, _InputIterator __k2,
+     std::__false_type)
+      {
+ const basic_string __s(__k1, __k2);
+ const size_type __n1 = __i2 - __i1;
+ return _M_replace(__i1 - begin(), __n1, __s._M_data(),
+     __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __n2 - __n1;
+
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos1;
+
+   const size_type __how_much = __old_size - __pos1 - __n1;
+   if (__how_much && __n1 != __n2)
+     this->_S_move(__p + __n2, __p + __n1, __how_much);
+ }
+      else
+ this->_M_mutate(__pos1, __n1, 0, __n2);
+
+      if (__n2)
+ this->_S_assign(this->_M_data() + __pos1, __n2, __c);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+        const size_type __len2)
+    {
+      _M_check_length(__len1, __len2, "basic_string::_M_replace");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos;
+
+   const size_type __how_much = __old_size - __pos - __len1;
+   if (_M_disjunct(__s))
+     {
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2)
+  this->_S_copy(__p, __s, __len2);
+     }
+   else
+     {
+
+       if (__len2 && __len2 <= __len1)
+  this->_S_move(__p, __s, __len2);
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2 > __len1)
+  {
+    if (__s + __len2 <= __p + __len1)
+      this->_S_move(__p, __s, __len2);
+    else if (__s >= __p + __len1)
+      this->_S_copy(__p, __s + __len2 - __len1, __len2);
+    else
+      {
+        const size_type __nleft = (__p + __len1) - __s;
+        this->_S_move(__p, __s, __nleft);
+        this->_S_copy(__p + __nleft, __p + __len2,
+        __len2 - __nleft);
+      }
+  }
+     }
+ }
+      else
+ this->_M_mutate(__pos, __len1, __s, __len2);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+                                             ;
+      if (__n)
+ _S_copy(__s, _M_data() + __pos, __n);
+
+      return __n;
+    }
+# 1145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+                                      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      const size_type __size = this->size();
+      const _CharT* __data = _M_data();
+
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+
+      if (__n <= __size)
+ {
+   for (; __pos <= __size - __n; ++__pos)
+     if (traits_type::eq(__data[__pos], __s[0])
+  && traits_type::compare(__data + __pos + 1,
+     __s + 1, __n - 1) == 0)
+       return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+ {
+   const _CharT* __data = _M_data();
+   const size_type __n = __size - __pos;
+   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+   if (__p)
+     __ret = __p - __data;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      const size_type __size = this->size();
+      if (__n <= __size)
+ {
+   __pos = std::min(size_type(__size - __n), __pos);
+   const _CharT* __data = _M_data();
+   do
+     {
+       if (traits_type::compare(__data + __pos, __s, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(_M_data()[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      for (; __n && __pos < this->size(); ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::find(__s, __n, _M_data()[__pos]))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::eq(_M_data()[__pos], __c))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+                                             ;
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(_M_data()[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+ __r = _S_compare(__n, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+     size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+         __str.data() + __pos2, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const
+    {
+                                    ;
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+ __r = _S_compare(__size, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+                                    ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+     size_type __n2) const
+    {
+                                              ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+        basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef typename __ctype_type::ctype_base __ctype_base;
+
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       __str.erase();
+       _CharT __buf[128];
+       __size_type __len = 0;
+       const streamsize __w = __in.width();
+       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+                                : __str.max_size();
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(__ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    if (__len == sizeof(__buf) / sizeof(_CharT))
+      {
+        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+        __len = 0;
+      }
+    __buf[__len++] = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       __str.append(__buf, __len);
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       const __int_type __idelim = _Traits::to_int_type(__delim);
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !_Traits::eq_int_type(__c, __idelim))
+  {
+    __str += _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       else if (_Traits::eq_int_type(__c, __idelim))
+  {
+    ++__extracted;
+    __in.rdbuf()->sbumpc();
+  }
+       else
+  __err |= __ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+
+
+  extern template class basic_string<char>;
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+
+
+  extern template class basic_string<wchar_t>;
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+
+
+
+
+}
+# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+  class locale
+  {
+  public:
+
+
+    typedef int category;
+
+
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    locale() throw();
+# 126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    locale(const locale& __other) throw();
+# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    explicit
+    locale(const char* __s);
+# 151 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const char* __s, category __cat);
+# 162 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    explicit
+    locale(const std::string& __s) : locale(__s.c_str()) { }
+# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const std::string& __s, category __cat)
+    : locale(__base, __s.c_str(), __cat) { }
+# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const locale& __add, category __cat);
+# 205 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+
+    ~locale() throw();
+# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    const locale&
+    operator=(const locale& __other) throw();
+# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+
+
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    name() const;
+# 254 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    bool
+    operator==(const locale& __other) const throw();
+
+
+
+
+
+
+
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+# 282 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+# 298 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    static locale
+    global(const locale& __loc);
+
+
+
+
+    static const locale&
+    classic();
+
+  private:
+
+    _Impl* _M_impl;
+
+
+    static _Impl* _S_classic;
+
+
+    static _Impl* _S_global;
+
+
+
+
+
+    static const char* const* const _S_categories;
+# 333 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    enum { _S_categories_size = 6 + 6 };
+
+
+    static __gthread_once_t _S_once;
+
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+
+
+    static const id* const _S_twinned_facets[];
+
+  };
+# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word _M_refcount;
+
+
+    static __c_locale _S_c_locale;
+
+
+    static const char _S_c_name[2];
+
+
+    static __gthread_once_t _S_once;
+
+
+    static void
+    _S_initialize_once();
+
+  protected:
+# 402 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+
+
+    static __c_locale
+    _S_get_c_locale();
+
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+# 438 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+    facet(const facet&) = delete;
+
+    facet&
+    operator=(const facet&) = delete;
+
+
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() const throw()
+    {
+
+                                                           ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+                                                              ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    class __shim;
+
+    const facet* _M_sso_shim(const id*) const;
+    const facet* _M_cow_shim(const id*) const;
+  };
+# 482 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+
+
+
+    mutable size_t _M_index;
+
+
+    static _Atomic_word _S_refcount;
+
+    void
+    operator=(const id&);
+
+    id(const id&);
+
+  public:
+
+
+
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+
+  class locale::_Impl
+  {
+  public:
+
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+
+                                                           ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+                                                              ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);
+
+    void
+    operator=(const _Impl&);
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    template<typename _Facet>
+      void
+      _M_init_facet_unchecked(_Facet* __facet)
+      {
+ __facet->_M_add_reference();
+ _M_facets[_Facet::id._M_id()] = __facet;
+      }
+
+    void
+    _M_install_cache(const facet*, size_t);
+
+    void _M_init_extra(facet**);
+    void _M_init_extra(void*, void*, const char*, const char*);
+  };
+# 640 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+  template<typename _CharT>
+    class __cxx11:: collate : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_collate;
+
+    public:
+
+      static locale::id id;
+# 667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+# 681 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+# 698 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  protected:
+
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+# 760 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+# 774 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+# 787 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+
+
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+
+
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+
+
+
+  template<typename _CharT>
+    class __cxx11:: collate_byname : public collate<_CharT>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+
+
+      explicit
+      collate_byname(const string& __s, size_t __refs = 0)
+      : collate_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+
+
+
+    }
+# 130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+
+
+
+    }
+
+
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+
+
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+
+
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+
+
+
+
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+
+   __p++;
+   __q++;
+ }
+    }
+
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+
+
+      const string_type __str(__lo, __hi);
+
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+
+      size_t __len = (__hi - __lo) * 2;
+
+      _CharT* __c = new _CharT[__len];
+
+      try
+ {
+
+
+
+   for (;;)
+     {
+
+       size_t __res = _M_transform(__c, __p, __len);
+
+
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+
+      delete [] __c;
+
+      return __ret;
+    }
+
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+
+
+
+
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+
+
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+
+
+
+
+}
+# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3
+
+
+# 1 "/usr/include/errno.h" 1 3 4
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  enum class errc
+    {
+      address_family_not_supported = 97,
+      address_in_use = 98,
+      address_not_available = 99,
+      already_connected = 106,
+      argument_list_too_long = 7,
+      argument_out_of_domain = 33,
+      bad_address = 14,
+      bad_file_descriptor = 9,
+
+
+      bad_message = 74,
+
+
+      broken_pipe = 32,
+      connection_aborted = 103,
+      connection_already_in_progress = 114,
+      connection_refused = 111,
+      connection_reset = 104,
+      cross_device_link = 18,
+      destination_address_required = 89,
+      device_or_resource_busy = 16,
+      directory_not_empty = 39,
+      executable_format_error = 8,
+      file_exists = 17,
+      file_too_large = 27,
+      filename_too_long = 36,
+      function_not_supported = 38,
+      host_unreachable = 113,
+
+
+      identifier_removed = 43,
+
+
+      illegal_byte_sequence = 84,
+      inappropriate_io_control_operation = 25,
+      interrupted = 4,
+      invalid_argument = 22,
+      invalid_seek = 29,
+      io_error = 5,
+      is_a_directory = 21,
+      message_size = 90,
+      network_down = 100,
+      network_reset = 102,
+      network_unreachable = 101,
+      no_buffer_space = 105,
+      no_child_process = 10,
+
+
+      no_link = 67,
+
+
+      no_lock_available = 37,
+
+
+      no_message_available = 61,
+
+
+      no_message = 42,
+      no_protocol_option = 92,
+      no_space_on_device = 28,
+
+
+      no_stream_resources = 63,
+
+
+      no_such_device_or_address = 6,
+      no_such_device = 19,
+      no_such_file_or_directory = 2,
+      no_such_process = 3,
+      not_a_directory = 20,
+      not_a_socket = 88,
+
+
+      not_a_stream = 60,
+
+
+      not_connected = 107,
+      not_enough_memory = 12,
+
+
+      not_supported = 95,
+
+
+
+      operation_canceled = 125,
+
+
+      operation_in_progress = 115,
+      operation_not_permitted = 1,
+      operation_not_supported = 95,
+      operation_would_block = 11,
+
+
+      owner_dead = 130,
+
+
+      permission_denied = 13,
+
+
+      protocol_error = 71,
+
+
+      protocol_not_supported = 93,
+      read_only_file_system = 30,
+      resource_deadlock_would_occur = 35,
+      resource_unavailable_try_again = 11,
+      result_out_of_range = 34,
+
+
+      state_not_recoverable = 131,
+
+
+
+      stream_timeout = 62,
+
+
+
+      text_file_busy = 26,
+
+
+      timed_out = 110,
+      too_many_files_open_in_system = 23,
+      too_many_files_open = 24,
+      too_many_links = 31,
+      too_many_symbolic_link_levels = 40,
+
+
+      value_too_large = 75,
+
+
+      wrong_protocol_type = 91
+    };
+
+
+}
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct __cow_string
+  {
+    union {
+      const char* _M_p;
+      char _M_bytes[sizeof(const char*)];
+    };
+
+    __cow_string();
+    __cow_string(const std::string&);
+    __cow_string(const char*, size_t);
+    __cow_string(const __cow_string&) noexcept;
+    __cow_string& operator=(const __cow_string&) noexcept;
+    ~__cow_string();
+
+    __cow_string(__cow_string&&) noexcept;
+    __cow_string& operator=(__cow_string&&) noexcept;
+
+  };
+
+  typedef basic_string<char> __sso_string;
+# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3
+  class logic_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    logic_error(const string& __arg) ;
+
+
+    explicit
+    logic_error(const char*) ;
+
+
+
+    logic_error(const logic_error&) noexcept;
+    logic_error& operator=(const logic_error&) noexcept;
+
+
+    virtual ~logic_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+
+
+
+
+
+  };
+
+
+
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg) ;
+
+    explicit domain_error(const char*) ;
+
+    virtual ~domain_error() noexcept;
+  };
+
+
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg) ;
+
+    explicit invalid_argument(const char*) ;
+
+    virtual ~invalid_argument() noexcept;
+  };
+
+
+
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg) ;
+
+    explicit length_error(const char*) ;
+
+    virtual ~length_error() noexcept;
+  };
+
+
+
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg) ;
+
+    explicit out_of_range(const char*) ;
+
+    virtual ~out_of_range() noexcept;
+  };
+
+
+
+
+
+
+  class runtime_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    runtime_error(const string& __arg) ;
+
+
+    explicit
+    runtime_error(const char*) ;
+
+
+
+    runtime_error(const runtime_error&) noexcept;
+    runtime_error& operator=(const runtime_error&) noexcept;
+
+
+    virtual ~runtime_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+
+
+
+
+
+  };
+
+
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg) ;
+
+    explicit range_error(const char*) ;
+
+    virtual ~range_error() noexcept;
+  };
+
+
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg) ;
+
+    explicit overflow_error(const char*) ;
+
+    virtual ~overflow_error() noexcept;
+  };
+
+
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg) ;
+
+    explicit underflow_error(const char*) ;
+
+    virtual ~underflow_error() noexcept;
+  };
+
+
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  class error_code;
+  class error_condition;
+  class system_error;
+
+
+  template<typename _Tp>
+    struct is_error_code_enum : public false_type { };
+
+
+  template<typename _Tp>
+    struct is_error_condition_enum : public false_type { };
+
+  template<>
+    struct is_error_condition_enum<errc>
+    : public true_type { };
+
+  inline namespace _V2 {
+
+
+  class error_category
+  {
+  public:
+    constexpr error_category() noexcept = default;
+
+    virtual ~error_category();
+
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    virtual const char*
+    name() const noexcept = 0;
+
+
+
+
+
+
+  private:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual __cow_string
+    _M_message(int) const;
+
+  public:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual string
+    message(int) const = 0;
+# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3
+  public:
+    virtual error_condition
+    default_error_condition(int __i) const noexcept;
+
+    virtual bool
+    equivalent(int __i, const error_condition& __cond) const noexcept;
+
+    virtual bool
+    equivalent(const error_code& __code, int __i) const noexcept;
+
+    bool
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+
+    bool
+    operator==(const error_category& __other) const noexcept
+    { return this == &__other; }
+
+    bool
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+  };
+
+
+  __attribute__ ((__const__)) const error_category& system_category() noexcept;
+  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
+
+  }
+
+  error_code make_error_code(errc) noexcept;
+
+  template<typename _Tp>
+    struct hash;
+
+
+
+  struct error_code
+  {
+    error_code() noexcept
+    : _M_value(0), _M_cat(&system_category()) { }
+
+    error_code(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorCodeEnum, typename = typename
+      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
+      error_code(_ErrorCodeEnum __e) noexcept
+      { *this = make_error_code(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+    void
+    clear() noexcept
+    { assign(0, system_category()); }
+
+
+    template<typename _ErrorCodeEnum>
+      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+    error_code&>::type
+      operator=(_ErrorCodeEnum __e) noexcept
+      { return *this = make_error_code(__e); }
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    error_condition
+    default_error_condition() const noexcept;
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+
+
+  private:
+    friend class hash<error_code>;
+
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+  inline error_code
+  make_error_code(errc __e) noexcept
+  { return error_code(static_cast<int>(__e), generic_category()); }
+
+  inline bool
+  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
+    { return (__os << __e.category().name() << ':' << __e.value()); }
+
+  error_condition make_error_condition(errc) noexcept;
+
+
+
+  struct error_condition
+  {
+    error_condition() noexcept
+    : _M_value(0), _M_cat(&generic_category()) { }
+
+    error_condition(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorConditionEnum, typename = typename
+  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
+      error_condition(_ErrorConditionEnum __e) noexcept
+      { *this = make_error_condition(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+
+    template<typename _ErrorConditionEnum>
+      typename enable_if<is_error_condition_enum
+    <_ErrorConditionEnum>::value, error_condition&>::type
+      operator=(_ErrorConditionEnum __e) noexcept
+      { return *this = make_error_condition(__e); }
+
+    void
+    clear() noexcept
+    { assign(0, generic_category()); }
+
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+
+
+  private:
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+  inline error_condition
+  make_error_condition(errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), generic_category()); }
+
+  inline bool
+  operator<(const error_condition& __lhs,
+     const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+
+  inline bool
+  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value()); }
+
+  inline bool
+  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category().equivalent(__lhs.value(), __rhs)
+     || __rhs.category().equivalent(__lhs, __rhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__rhs.category().equivalent(__rhs.value(), __lhs)
+     || __lhs.category().equivalent(__rhs, __lhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value());
+  }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  class system_error : public std::runtime_error
+  {
+  private:
+    error_code _M_code;
+
+  public:
+    system_error(error_code __ec = error_code())
+    : runtime_error(__ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const string& __what)
+    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const char* __what)
+    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
+
+    system_error(int __v, const error_category& __ecat, const char* __what)
+    : system_error(error_code(__v, __ecat), __what) { }
+
+    system_error(int __v, const error_category& __ecat)
+    : runtime_error(error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    system_error(int __v, const error_category& __ecat, const string& __what)
+    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    virtual ~system_error() noexcept;
+
+    const error_code&
+    code() const noexcept { return _M_code; }
+  };
+
+
+}
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<>
+    struct hash<error_code>
+    : public __hash_base<size_t, error_code>
+    {
+      size_t
+      operator()(const error_code& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
+ return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
+      }
+    };
+
+
+}
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16,
+      _S_ios_fmtflags_max = 2147483647,
+      _S_ios_fmtflags_min = ~2147483647
+    };
+
+  inline constexpr _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+
+  inline const _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Openmode
+    {
+      _S_app = 1L << 0,
+      _S_ate = 1L << 1,
+      _S_bin = 1L << 2,
+      _S_in = 1L << 3,
+      _S_out = 1L << 4,
+      _S_trunc = 1L << 5,
+      _S_ios_openmode_end = 1L << 16,
+      _S_ios_openmode_max = 2147483647,
+      _S_ios_openmode_min = ~2147483647
+    };
+
+  inline constexpr _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+
+  inline const _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Iostate
+    {
+      _S_goodbit = 0,
+      _S_badbit = 1L << 0,
+      _S_eofbit = 1L << 1,
+      _S_failbit = 1L << 2,
+      _S_ios_iostate_end = 1L << 16,
+      _S_ios_iostate_max = 2147483647,
+      _S_ios_iostate_min = ~2147483647
+    };
+
+  inline constexpr _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+
+  inline const _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Seekdir
+    {
+      _S_beg = 0,
+      _S_cur = 1,
+      _S_end = 2,
+      _S_ios_seekdir_end = 1L << 16
+    };
+
+
+
+  enum class io_errc { stream = 1 };
+
+  template <> struct is_error_code_enum<io_errc> : public true_type { };
+
+  const error_category& iostream_category() noexcept;
+
+  inline error_code
+  make_error_code(io_errc e) noexcept
+  { return error_code(static_cast<int>(e), iostream_category()); }
+
+  inline error_condition
+  make_error_condition(io_errc e) noexcept
+  { return error_condition(static_cast<int>(e), iostream_category()); }
+# 228 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+  class ios_base
+  {
+# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+  public:
+# 255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
+    {
+    public:
+      explicit
+      failure(const string& __str);
+
+
+      explicit
+      failure(const string&, const error_code&);
+
+      explicit
+      failure(const char*, const error_code& = io_errc::stream);
+
+
+      virtual
+      ~failure() throw();
+
+      virtual const char*
+      what() const throw();
+    };
+# 323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    typedef _Ios_Fmtflags fmtflags;
+
+
+    static const fmtflags boolalpha = _S_boolalpha;
+
+
+    static const fmtflags dec = _S_dec;
+
+
+    static const fmtflags fixed = _S_fixed;
+
+
+    static const fmtflags hex = _S_hex;
+
+
+
+
+    static const fmtflags internal = _S_internal;
+
+
+
+    static const fmtflags left = _S_left;
+
+
+    static const fmtflags oct = _S_oct;
+
+
+
+    static const fmtflags right = _S_right;
+
+
+    static const fmtflags scientific = _S_scientific;
+
+
+
+    static const fmtflags showbase = _S_showbase;
+
+
+
+    static const fmtflags showpoint = _S_showpoint;
+
+
+    static const fmtflags showpos = _S_showpos;
+
+
+    static const fmtflags skipws = _S_skipws;
+
+
+    static const fmtflags unitbuf = _S_unitbuf;
+
+
+
+    static const fmtflags uppercase = _S_uppercase;
+
+
+    static const fmtflags adjustfield = _S_adjustfield;
+
+
+    static const fmtflags basefield = _S_basefield;
+
+
+    static const fmtflags floatfield = _S_floatfield;
+# 398 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    typedef _Ios_Iostate iostate;
+
+
+
+    static const iostate badbit = _S_badbit;
+
+
+    static const iostate eofbit = _S_eofbit;
+
+
+
+
+    static const iostate failbit = _S_failbit;
+
+
+    static const iostate goodbit = _S_goodbit;
+# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    typedef _Ios_Openmode openmode;
+
+
+    static const openmode app = _S_app;
+
+
+    static const openmode ate = _S_ate;
+
+
+
+
+    static const openmode binary = _S_bin;
+
+
+    static const openmode in = _S_in;
+
+
+    static const openmode out = _S_out;
+
+
+    static const openmode trunc = _S_trunc;
+# 461 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    typedef _Ios_Seekdir seekdir;
+
+
+    static const seekdir beg = _S_beg;
+
+
+    static const seekdir cur = _S_cur;
+
+
+    static const seekdir end = _S_end;
+
+
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+# 487 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+# 516 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    void
+    register_callback(event_callback __fn, int __index);
+
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+
+
+
+    struct _Callback_list
+    {
+
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+
+      int
+      _M_remove_reference()
+      {
+
+                                                             ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+                                                                ;
+          }
+        return __res;
+      }
+    };
+
+     _Callback_list* _M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+
+    _Words _M_word_zero;
+
+
+
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+
+
+    int _M_word_size;
+    _Words* _M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+
+    locale _M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+
+
+
+
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+
+
+
+
+
+
+    fmtflags
+    flags() const
+    { return _M_flags; }
+# 629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+# 662 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+
+
+
+
+
+
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+# 688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+
+
+
+
+
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+
+
+
+
+
+
+    streamsize
+    width() const
+    { return _M_width; }
+
+
+
+
+
+
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+# 739 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    static bool
+    sync_with_stdio(bool __sync = true);
+# 751 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    locale
+    imbue(const locale& __loc) throw();
+# 762 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+# 773 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    static int
+    xalloc() throw();
+# 808 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+# 829 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+# 846 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+    virtual ~ios_base();
+
+  protected:
+    ios_base() throw ();
+# 860 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
+  public:
+    ios_base(const ios_base&) = delete;
+
+    ios_base&
+    operator=(const ios_base&) = delete;
+
+  protected:
+    void
+    _M_move(ios_base&) noexcept;
+
+    void
+    _M_swap(ios_base& __rhs) noexcept;
+
+  };
+
+
+
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+
+
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+
+
+
+
+
+  inline ios_base&
+  hexfloat(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  defaultfloat(ios_base& __base)
+  {
+    __base.unsetf(ios_base::floatfield);
+    return __base;
+  }
+
+
+
+}
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+
+
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
+
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+
+    protected:
+
+
+
+
+
+
+
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+
+
+      locale _M_buf_locale;
+
+  public:
+
+      virtual
+      ~basic_streambuf()
+      { }
+# 208 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      locale
+      pubimbue(const locale& __loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+# 225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+# 238 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+# 250 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+
+
+
+      int
+      pubsync() { return this->sync(); }
+# 283 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+# 297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+# 337 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+# 356 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+# 449 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    protected:
+# 463 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+# 481 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      char_type*
+      eback() const { return _M_in_beg; }
+
+      char_type*
+      gptr() const { return _M_in_cur; }
+
+      char_type*
+      egptr() const { return _M_in_end; }
+# 497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+# 508 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+# 528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      char_type*
+      pbase() const { return _M_out_beg; }
+
+      char_type*
+      pptr() const { return _M_out_cur; }
+
+      char_type*
+      epptr() const { return _M_out_end; }
+# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+# 554 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+# 575 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual void
+      imbue(const locale& __loc)
+      { }
+# 590 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 613 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual int
+      sync() { return 0; }
+# 648 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual streamsize
+      showmanyc() { return 0; }
+# 664 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+# 699 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+# 723 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof())
+      { return traits_type::eof(); }
+# 741 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+# 767 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      virtual int_type
+      overflow(int_type __c = traits_type::eof())
+      { return traits_type::eof(); }
+
+
+
+    public:
+# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
+      void
+      stossc()
+      {
+ if (this->gptr() < this->egptr())
+   this->gbump(1);
+ else
+   this->uflow();
+      }
+
+
+
+      void
+      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
+
+      void
+      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
+
+
+
+
+    protected:
+
+      basic_streambuf(const basic_streambuf&);
+
+      basic_streambuf&
+      operator=(const basic_streambuf&);
+
+
+      void
+      swap(basic_streambuf& __sb)
+      {
+ std::swap(_M_in_beg, __sb._M_in_beg);
+ std::swap(_M_in_cur, __sb._M_in_cur);
+ std::swap(_M_in_end, __sb._M_in_end);
+ std::swap(_M_out_beg, __sb._M_out_beg);
+ std::swap(_M_out_cur, __sb._M_out_cur);
+ std::swap(_M_out_end, __sb._M_out_end);
+ std::swap(_M_buf_locale, __sb._M_buf_locale);
+      }
+
+    };
+
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>::
+    basic_streambuf(const basic_streambuf&) = default;
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>&
+    std::basic_streambuf<_CharT, _Traits>::
+    operator=(const basic_streambuf&) = default;
+
+
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+     basic_streambuf<char>* __sbout, bool& __ineof);
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_gbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_pbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+
+
+
+
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+
+
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+
+
+
+
+}
+# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 2 3
+# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
+# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
+# 1 "/usr/include/wctype.h" 1 3 4
+# 33 "/usr/include/wctype.h" 3 4
+# 1 "/usr/include/wchar.h" 1 3 4
+# 34 "/usr/include/wctype.h" 2 3 4
+# 52 "/usr/include/wctype.h" 3 4
+typedef unsigned long int wctype_t;
+# 71 "/usr/include/wctype.h" 3 4
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+
+  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
+  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
+  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
+  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
+  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
+  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
+  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
+  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
+  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
+  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
+  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
+  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
+};
+
+
+
+extern "C" {
+# 111 "/usr/include/wctype.h" 3 4
+extern int iswalnum (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswalpha (wint_t __wc) throw ();
+
+
+extern int iswcntrl (wint_t __wc) throw ();
+
+
+
+extern int iswdigit (wint_t __wc) throw ();
+
+
+
+extern int iswgraph (wint_t __wc) throw ();
+
+
+
+
+extern int iswlower (wint_t __wc) throw ();
+
+
+extern int iswprint (wint_t __wc) throw ();
+
+
+
+
+extern int iswpunct (wint_t __wc) throw ();
+
+
+
+
+extern int iswspace (wint_t __wc) throw ();
+
+
+
+
+extern int iswupper (wint_t __wc) throw ();
+
+
+
+
+extern int iswxdigit (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswblank (wint_t __wc) throw ();
+# 171 "/usr/include/wctype.h" 3 4
+extern wctype_t wctype (const char *__property) throw ();
+
+
+
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+# 186 "/usr/include/wctype.h" 3 4
+typedef const __int32_t *wctrans_t;
+
+
+
+
+
+
+
+extern wint_t towlower (wint_t __wc) throw ();
+
+
+extern wint_t towupper (wint_t __wc) throw ();
+
+
+}
+# 213 "/usr/include/wctype.h" 3 4
+extern "C" {
+
+
+
+
+extern wctrans_t wctrans (const char *__property) throw ();
+
+
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+# 230 "/usr/include/wctype.h" 3 4
+extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+
+extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctype_t wctype_l (const char *__property, __locale_t __locale)
+     throw ();
+
+
+
+extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
+     throw ();
+
+
+
+
+
+
+
+extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
+     throw ();
+
+
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      __locale_t __locale) throw ();
+
+
+
+}
+# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 2 3
+# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+
+  using ::iswblank;
+
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct ctype_base
+  {
+
+    typedef const int* __to_type;
+
+
+
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+
+    static const mask blank = _ISblank;
+
+  };
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+                      _CharT*,
+
+
+        _CharT>
+
+
+
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename _Traits::int_type int_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+      template<bool _IsMove, typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+ __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+               istreambuf_iterator<_CharT2> >::__type
+ find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+    private:
+
+
+
+
+
+
+
+      mutable streambuf_type* _M_sbuf;
+      mutable int_type _M_c;
+
+    public:
+
+      constexpr istreambuf_iterator() noexcept
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
+
+      ~istreambuf_iterator() = default;
+
+
+
+      istreambuf_iterator(istream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+
+
+
+
+      char_type
+      operator*() const
+      {
+
+
+
+
+
+
+
+ return traits_type::to_char_type(_M_get());
+      }
+
+
+      istreambuf_iterator&
+      operator++()
+      {
+
+
+                        ;
+ if (_M_sbuf)
+   {
+     _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return *this;
+      }
+
+
+      istreambuf_iterator
+      operator++(int)
+      {
+
+
+                        ;
+
+ istreambuf_iterator __old = *this;
+ if (_M_sbuf)
+   {
+     __old._M_c = _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return __old;
+      }
+
+
+
+
+
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+
+    private:
+      int_type
+      _M_get() const
+      {
+ const int_type __eof = traits_type::eof();
+ int_type __ret = __eof;
+ if (_M_sbuf)
+   {
+     if (!traits_type::eq_int_type(_M_c, __eof))
+       __ret = _M_c;
+     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
+            __eof))
+       _M_c = __ret;
+     else
+       _M_sbuf = 0;
+   }
+ return __ret;
+      }
+
+      bool
+      _M_at_eof() const
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(_M_get(), __eof);
+      }
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+    private:
+      streambuf_type* _M_sbuf;
+      bool _M_failed;
+
+    public:
+
+      ostreambuf_iterator(ostream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+ if (!_M_failed &&
+     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+   _M_failed = true;
+ return *this;
+      }
+
+
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+
+
+      bool
+      failed() const noexcept
+      { return _M_failed; }
+
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+ if (__builtin_expect(!_M_failed, true)
+     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+    false))
+   _M_failed = true;
+ return *this;
+      }
+    };
+
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+                           ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last,
+  ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+ {
+   bool __ineof;
+   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+   if (!__ineof)
+     __result._M_failed = true;
+ }
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+     istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof()))
+     {
+       const streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    traits_type::copy(__result, __sb->gptr(), __n);
+    __sb->__safe_gbump(__n);
+    __result += __n;
+    __c = __sb->underflow();
+  }
+       else
+  {
+    *__result++ = traits_type::to_char_type(__c);
+    __c = __sb->snextc();
+  }
+     }
+ }
+      return __result;
+    }
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+          istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   const int_type __ival = traits_type::to_int_type(__val);
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof())
+   && !traits_type::eq_int_type(__c, __ival))
+     {
+       streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    const _CharT* __p = traits_type::find(__sb->gptr(),
+       __n, __val);
+    if (__p)
+      __n = __p - __sb->gptr();
+    __sb->__safe_gbump(__n);
+    __c = __sb->sgetc();
+  }
+       else
+  __c = __sb->snextc();
+     }
+
+   if (!traits_type::eq_int_type(__c, traits_type::eof()))
+     __first._M_c = __c;
+   else
+     __first._M_sbuf = 0;
+ }
+      return __first;
+    }
+
+
+
+
+}
+# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+
+
+
+
+
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+
+
+
+
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+
+
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef _CharT char_type;
+# 168 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+# 185 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+# 201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+# 217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+# 231 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 260 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 292 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+# 311 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+# 352 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+# 434 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+# 469 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+# 502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const = 0;
+# 542 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+# 563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const = 0;
+    };
+# 611 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+
+
+      static locale::id id;
+
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+
+   protected:
+      virtual
+      ~ctype();
+
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_widen(char __c) const;
+
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+    };
+
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+# 680 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef char char_type;
+
+    protected:
+
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+
+
+    public:
+
+      static locale::id id;
+
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+# 743 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      inline bool
+      is(mask __m, char __c) const;
+# 758 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+# 772 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+# 786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+# 801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 834 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 871 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+# 898 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+# 929 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+# 962 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char* __to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+
+
+
+
+
+      const mask*
+      table() const throw()
+      { return _M_table; }
+
+
+      static const mask*
+      classic_table() throw();
+    protected:
+
+
+
+
+
+
+
+      virtual
+      ~ctype();
+# 1011 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1028 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+# 1130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const
+      { return __c; }
+# 1156 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const
+      {
+ __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+# 1181 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+
+
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+
+    protected:
+      __c_locale _M_c_locale_ctype;
+
+
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+
+
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+
+    public:
+
+
+      static locale::id id;
+# 1214 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(size_t __refs = 0);
+# 1225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+
+      virtual
+      ~ctype();
+# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+# 1268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+# 1286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+# 1304 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+# 1321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1338 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1354 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1391 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const;
+# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+# 1462 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+
+
+      void
+      _M_initialize_ctype() throw();
+    };
+
+
+
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0)
+      : ctype_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~ctype_byname() { };
+    };
+
+
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+
+
+}
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  bool
+  ctype<char>::
+  is(mask __m, char __c) const
+  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
+
+  const char*
+  ctype<char>::
+  is(const char* __low, const char* __high, mask* __vec) const
+  {
+    while (__low < __high)
+      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
+    return __high;
+  }
+
+  const char*
+  ctype<char>::
+  scan_is(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
+      ++__low;
+    return __low;
+  }
+
+  const char*
+  ctype<char>::
+  scan_not(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
+      ++__low;
+    return __low;
+  }
+
+
+}
+# 1535 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  class __num_base
+  {
+  public:
+
+
+    enum
+      {
+ _S_ominus,
+ _S_oplus,
+ _S_ox,
+ _S_oX,
+ _S_odigits,
+ _S_odigits_end = _S_odigits + 16,
+ _S_oudigits = _S_odigits_end,
+ _S_oudigits_end = _S_oudigits + 16,
+ _S_oe = _S_odigits + 14,
+ _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+
+
+
+
+
+
+    static const char* _S_atoms_out;
+
+
+
+    static const char* _S_atoms_in;
+
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+
+
+
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+
+
+
+
+
+      _CharT _M_atoms_out[__num_base::_S_oend];
+
+
+
+
+
+      _CharT _M_atoms_in[__num_base::_S_iend];
+
+      bool _M_allocated;
+
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+ _M_use_grouping(false),
+ _M_truename(0), _M_truename_size(0), _M_falsename(0),
+ _M_falsename_size(0), _M_decimal_point(_CharT()),
+ _M_thousands_sep(_CharT()), _M_allocated(false)
+ { }
+
+      ~__numpunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+
+namespace __cxx11 {
+# 1665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __numpunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+
+    public:
+
+      static locale::id id;
+
+
+
+
+
+
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+# 1703 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+# 1717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+# 1731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1744 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1775 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1788 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      string_type
+      truename() const
+      { return this->do_truename(); }
+# 1801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    protected:
+
+      virtual
+      ~numpunct();
+# 1818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1830 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1843 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1856 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+# 1869 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+
+
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+
+  template<>
+    numpunct<char>::~numpunct();
+
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+  template<>
+    numpunct<wchar_t>::~numpunct();
+
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+
+      explicit
+      numpunct_byname(const string& __s, size_t __refs = 0)
+      : numpunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+}
+# 1947 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 1968 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+# 1994 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2031 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2091 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2134 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    protected:
+
+      virtual ~num_get() { }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+
+      template<typename _ValueT>
+ __attribute ((__abi_tag__ ("cxx11")))
+ iter_type
+ _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+ _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+ _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+# 2207 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      double&) const;
+
+
+
+
+
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      long double&) const;
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+# 2270 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+# 2288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 2309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+# 2327 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2432 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2457 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+    protected:
+      template<typename _ValueT>
+ iter_type
+ _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+ iter_type
+ _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+
+
+      virtual
+      ~num_put() { };
+# 2505 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, double) const;
+
+
+
+
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, const void*) const;
+
+
+
+
+
+
+
+    };
+
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+# 2563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+
+
+
+  template<typename _CharT>
+    inline bool
+    isblank(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
+
+
+
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+
+
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+
+
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = 0;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   const string& __g = __np.grouping();
+   _M_grouping_size = __g.size();
+   __grouping = new char[_M_grouping_size];
+   __g.copy(__grouping, _M_grouping_size);
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(__grouping[0]) > 0
+        && (__grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   const basic_string<_CharT>& __tn = __np.truename();
+   _M_truename_size = __tn.size();
+   __truename = new _CharT[_M_truename_size];
+   __tn.copy(__truename, _M_truename_size);
+
+   const basic_string<_CharT>& __fn = __np.falsename();
+   _M_falsename_size = __fn.size();
+   __falsename = new _CharT[_M_falsename_size];
+   __fn.copy(__falsename, _M_falsename_size);
+
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+
+   _M_grouping = __grouping;
+   _M_truename = __truename;
+   _M_falsename = __falsename;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+# 139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+
+
+  template<typename _CharT, typename _InIter>
+    __attribute ((__abi_tag__ ("cxx11")))
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+
+
+      bool __testeof = __beg == __end;
+
+
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+
+
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+
+
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+      if (!__lc->_M_allocated)
+
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+
+  __xtrc += 'e';
+  __found_sci = true;
+
+
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+
+
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<char>(__sep_pos);
+   __sep_pos = 0;
+        }
+      else
+        {
+
+
+   __xtrc.clear();
+   break;
+        }
+    }
+  else
+    break;
+       }
+     else if (__c == __lc->_M_decimal_point)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+
+      if (__found_grouping.size())
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += '.';
+      __found_dec = true;
+    }
+  else
+    break;
+       }
+     else
+       {
+  const char_type* __q =
+    __traits_type::find(__lit_zero, 10, __c);
+  if (__q)
+    {
+      __xtrc += '0' + (__q - __lit_zero);
+      __found_mantissa = true;
+      ++__sep_pos;
+    }
+  else if ((__c == __lit[__num_base::_S_ie]
+     || __c == __lit[__num_base::_S_iE])
+    && !__found_sci && __found_mantissa)
+    {
+
+      if (__found_grouping.size() && !__found_dec)
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += 'e';
+      __found_sci = true;
+
+
+      if (++__beg != __end)
+        {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping
+     && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+        __xtrc += __plus ? '+' : '-';
+   else
+     continue;
+        }
+      else
+        {
+   __testeof = true;
+   break;
+        }
+    }
+  else
+    break;
+       }
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+
+
+
+      if (__found_grouping.size())
+        {
+
+   if (!__found_dec && !__found_sci)
+     __found_grouping += static_cast<char>(__sep_pos);
+
+          if (!std::__verify_grouping(__lc->_M_grouping,
+          __lc->_M_grouping_size,
+          __found_grouping))
+     __err = ios_base::failbit;
+        }
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      __attribute ((__abi_tag__ ("cxx11")))
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+
+
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+
+
+ bool __testeof = __beg == __end;
+
+
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+
+
+
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+
+
+
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+
+
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
+   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+ if (!__lc->_M_allocated)
+
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+
+
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+
+
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+
+
+
+ if (__found_grouping.size())
+   {
+
+     __found_grouping += static_cast<char>(__sep_pos);
+
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+
+
+
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative
+  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
+     else
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+
+
+
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+
+
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+
+       const char_type __c = *__beg;
+
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+
+       if (!__testf && __donet)
+  break;
+
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+
+       if (!__testt && __donef)
+  break;
+
+       if (!__testt && !__testf)
+  break;
+
+       ++__n;
+       ++__beg;
+
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+
+
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+# 735 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+
+
+      __io.flags(__fmt);
+
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+
+
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+
+
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+
+
+
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+
+
+ if (__lc->_M_use_grouping)
+   {
+
+
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+
+
+ if (__builtin_expect(__dec, true))
+   {
+
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __cs, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+
+
+
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+
+
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+# 971 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+
+
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+
+
+ int __len;
+
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+
+
+
+ const bool __use_prec =
+   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
+
+
+
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ if (__use_prec)
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __prec, __v);
+ else
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __v);
+
+
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     if (__use_prec)
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __prec, __v);
+     else
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __v);
+   }
+# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+
+
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+
+
+
+
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+
+
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+
+     __ws = __ws2;
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __ws, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+# 1169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+# 1206 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+
+
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+
+
+
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+
+      while (__first != __last)
+ *__s++ = *__first++;
+
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      return __s;
+    }
+
+
+
+
+  extern template class __cxx11:: numpunct<char>;
+  extern template class __cxx11:: numpunct_byname<char>;
+  extern template class num_get<char>;
+  extern template class num_put<char>;
+  extern template class ctype_byname<char>;
+
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+
+
+  extern template class __cxx11:: numpunct<wchar_t>;
+  extern template class __cxx11:: numpunct_byname<wchar_t>;
+  extern template class num_get<wchar_t>;
+  extern template class num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+
+
+
+
+}
+# 2652 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+
+
+
+
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+
+
+
+    protected:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+
+
+      const __ctype_type* _M_ctype;
+
+      const __num_put_type* _M_num_put;
+
+      const __num_get_type* _M_num_get;
+
+    public:
+# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      explicit operator bool() const
+      { return !this->fail(); }
+
+
+
+
+
+      bool
+      operator!() const
+      { return this->fail(); }
+# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+# 147 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      void
+      clear(iostate __state = goodbit);
+
+
+
+
+
+
+
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+
+
+
+      void
+      _M_setstate(iostate __state)
+      {
+
+
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+
+
+
+
+
+
+
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+
+
+
+
+
+
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+# 200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+
+
+
+
+
+
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+# 221 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      iostate
+      exceptions() const
+      { return _M_exception; }
+# 256 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+
+
+
+
+
+
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+
+
+
+
+
+
+      virtual
+      ~basic_ios() { }
+# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+
+
+
+
+
+
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+# 360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+
+
+
+
+
+
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+# 389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+# 409 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      locale
+      imbue(const locale& __loc);
+# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+
+    protected:
+
+
+
+
+
+
+
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+
+
+
+
+
+
+
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+
+
+      basic_ios(const basic_ios&) = delete;
+      basic_ios& operator=(const basic_ios&) = delete;
+
+      void
+      move(basic_ios& __rhs)
+      {
+ ios_base::_M_move(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ this->tie(__rhs.tie(nullptr));
+ _M_fill = __rhs._M_fill;
+ _M_fill_init = __rhs._M_fill_init;
+ _M_streambuf = nullptr;
+      }
+
+      void
+      move(basic_ios&& __rhs)
+      { this->move(__rhs); }
+
+      void
+      swap(basic_ios& __rhs) noexcept
+      {
+ ios_base::_M_swap(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ __rhs._M_cache_locale(__rhs._M_ios_locale);
+ std::swap(_M_tie, __rhs._M_tie);
+ std::swap(_M_fill, __rhs._M_fill);
+ std::swap(_M_fill_init, __rhs._M_fill_init);
+      }
+
+      void
+      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+      { _M_streambuf = __sb; }
+
+
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+
+
+      if (this != &__rhs)
+ {
+
+
+
+
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+
+
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+
+
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+
+   _M_call_callbacks(copyfmt_event);
+
+
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+
+      ios_base::_M_init();
+
+
+      _M_cache_locale(_M_ios_locale);
+# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3
+      _M_fill = _CharT();
+      _M_fill_init = false;
+
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = &use_facet<__ctype_type>(__loc);
+      else
+ _M_ctype = 0;
+
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = &use_facet<__num_put_type>(__loc);
+      else
+ _M_num_put = 0;
+
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = &use_facet<__num_get_type>(__loc);
+      else
+ _M_num_get = 0;
+    }
+
+
+
+
+  extern template class basic_ios<char>;
+
+
+  extern template class basic_ios<wchar_t>;
+
+
+
+
+}
+# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3
+# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
+# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_ostream() { }
+
+
+      class sentry;
+      friend class sentry;
+# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+
+
+
+ return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+# 165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(short __n);
+
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+      __ostream_type&
+      operator<<(int __n);
+
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(float __f)
+      {
+
+
+ return _M_insert(static_cast<double>(__f));
+      }
+
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+# 244 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+# 269 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+# 302 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      put(char_type __c);
+
+
+
+
+
+
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      flush();
+# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      pos_type
+      tellp();
+# 368 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      __ostream_type&
+      seekp(pos_type);
+# 380 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+
+    protected:
+      basic_ostream()
+      { this->init(0); }
+
+
+
+      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
+
+      basic_ostream(const basic_ostream&) = delete;
+
+      basic_ostream(basic_ostream&& __rhs)
+      : __ios_type()
+      { __ios_type::move(__rhs); }
+
+
+
+      basic_ostream& operator=(const basic_ostream&) = delete;
+
+      basic_ostream&
+      operator=(basic_ostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_ostream& __rhs)
+      { __ios_type::swap(__rhs); }
+
+
+      template<typename _ValueT>
+ __ostream_type&
+ _M_insert(_ValueT __v);
+    };
+# 425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+
+    public:
+# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+# 454 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      ~sentry()
+      {
+
+ if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+   {
+
+     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+       _M_os.setstate(ios_base::badbit);
+   }
+      }
+# 473 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 495 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+
+
+  template <class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+# 600 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
+    {
+      __os << __x;
+      return __os;
+    }
+
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+
+
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+
+
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+
+
+
+
+}
+# 639 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+
+    protected:
+
+
+
+
+
+      streamsize _M_gcount;
+
+    public:
+
+
+
+
+
+
+
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+
+      class sentry;
+      friend class sentry;
+# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+# 167 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+# 213 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+# 268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+# 301 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      int_type
+      get();
+# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      get(char_type& __c);
+# 342 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+# 353 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+# 376 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+# 386 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+# 450 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore();
+# 467 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      int_type
+      peek();
+# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      putback(char_type __c);
+# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      unget();
+# 555 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      int
+      sync();
+# 570 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      pos_type
+      tellg();
+# 585 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      seekg(pos_type);
+# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+
+
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+
+
+      basic_istream(const basic_istream&) = delete;
+
+      basic_istream(basic_istream&& __rhs)
+      : __ios_type(), _M_gcount(__rhs._M_gcount)
+      {
+ __ios_type::move(__rhs);
+ __rhs._M_gcount = 0;
+      }
+
+
+
+      basic_istream& operator=(const basic_istream&) = delete;
+
+      basic_istream&
+      operator=(basic_istream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_istream& __rhs)
+      {
+ __ios_type::swap(__rhs);
+ std::swap(_M_gcount, __rhs._M_gcount);
+      }
+
+
+      template<typename _ValueT>
+ __istream_type&
+ _M_extract(_ValueT& __v);
+    };
+
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+# 685 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+
+    public:
+
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+# 721 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+# 732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 750 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+# 823 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+
+
+
+
+
+
+
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+
+
+
+
+      virtual
+      ~basic_iostream() { }
+
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+
+
+      basic_iostream(const basic_iostream&) = delete;
+
+      basic_iostream(basic_iostream&& __rhs)
+      : __istream_type(std::move(__rhs)), __ostream_type(*this)
+      { }
+
+
+
+      basic_iostream& operator=(const basic_iostream&) = delete;
+
+      basic_iostream&
+      operator=(basic_iostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_iostream& __rhs)
+      { __istream_type::swap(__rhs); }
+
+    };
+# 906 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+# 922 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
+    {
+      __is >> __x;
+      return __is;
+    }
+
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ {
+   if (__in.tie())
+     __in.tie()->flush();
+   if (!__noskip && bool(__in.flags() & ios_base::skipws))
+     {
+       const __int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       __int_type __c = __sb->sgetc();
+
+       const __ctype_type& __ct = __check_facet(__in._M_ctype);
+       while (!traits_type::eq_int_type(__c, __eof)
+       && __ct.is(ctype_base::space,
+    traits_type::to_char_type(__c)))
+  __c = __sb->snextc();
+
+
+
+
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+ }
+
+      if (__in.good() && __err == ios_base::goodbit)
+ _M_ok = true;
+      else
+ {
+   __err |= ios_base::failbit;
+   __in.setstate(__err);
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+ sentry __cerb(*this, false);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_get_type& __ng = __check_facet(this->_M_num_get);
+  __ng.get(*this, 0, *this, __err, __v);
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__max;
+  }
+       else
+  __n = short(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__max;
+  }
+       else
+  __n = int(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+ {
+   try
+     {
+       bool __ineof;
+       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+  __err |= ios_base::failbit;
+       if (__ineof)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::failbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbout)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       __c = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__c, __eof))
+  _M_gcount = 1;
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __cb = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+  {
+    _M_gcount = 1;
+    __c = traits_type::to_char_type(__cb);
+  }
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (_M_gcount + 1 < __n
+       && !traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim))
+  {
+    *__s++ = traits_type::to_char_type(__c);
+    ++_M_gcount;
+    __c = __sb->snextc();
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __this_sb = this->rdbuf();
+       int_type __c = __this_sb->sgetc();
+       char_type __c2 = traits_type::to_char_type(__c);
+
+       while (!traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim)
+       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+  {
+    ++_M_gcount;
+    __c = __this_sb->snextc();
+    __c2 = traits_type::to_char_type(__c);
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+
+       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+  __err |= ios_base::eofbit;
+       else
+  _M_gcount = 1;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+# 513 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+
+
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+
+
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       if (!this->fail())
+  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+        ios_base::in);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+
+
+
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+
+
+
+
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+
+  extern template class basic_iostream<char>;
+
+
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+
+  extern template class basic_iostream<wchar_t>;
+
+
+
+
+}
+# 935 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 2 3
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type* _M_stream;
+      _Tp _M_value;
+      bool _M_ok;
+
+    public:
+
+      constexpr istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+
+
+      istream_iterator(istream_type& __s)
+      : _M_stream(&__s)
+      { _M_read(); }
+
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+
+      const _Tp&
+      operator*() const
+      {
+
+
+                        ;
+ return _M_value;
+      }
+
+      const _Tp*
+      operator->() const { return &(operator*()); }
+
+      istream_iterator&
+      operator++()
+      {
+
+
+                        ;
+ _M_read();
+ return *this;
+      }
+
+      istream_iterator
+      operator++(int)
+      {
+
+
+                        ;
+ istream_iterator __tmp = *this;
+ _M_read();
+ return __tmp;
+      }
+
+      bool
+      _M_equal(const istream_iterator& __x) const
+      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
+
+    private:
+      void
+      _M_read()
+      {
+ _M_ok = (_M_stream && *_M_stream) ? true : false;
+ if (_M_ok)
+   {
+     *_M_stream >> _M_value;
+     _M_ok = *_M_stream ? true : false;
+   }
+      }
+    };
+
+
+  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
+    inline bool
+    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return __x._M_equal(__y); }
+
+
+  template <class _Tp, class _CharT, class _Traits, class _Dist>
+    inline bool
+    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return !__x._M_equal(__y); }
+# 152 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+    private:
+      ostream_type* _M_stream;
+      const _CharT* _M_string;
+
+    public:
+
+      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(&__s), _M_string(__c) { }
+
+
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
+
+
+
+      ostream_iterator&
+      operator=(const _Tp& __value)
+      {
+
+
+                        ;
+ *_M_stream << __value;
+ if (_M_string) *_M_stream << _M_string;
+ return *this;
+      }
+
+      ostream_iterator&
+      operator*()
+      { return *this; }
+
+      ostream_iterator&
+      operator++()
+      { return *this; }
+
+      ostream_iterator&
+      operator++(int)
+      { return *this; }
+    };
+
+
+
+
+}
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 2
+
+
+
+namespace mozilla {
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h"
+template<class Element, class ArrayType>
+class ArrayIterator
+{
+public:
+  typedef ArrayType array_type;
+  typedef ArrayIterator<Element, ArrayType> iterator_type;
+  typedef typename array_type::index_type index_type;
+  typedef typename RemoveReference<Element>::Type value_type;
+  typedef ptrdiff_t difference_type;
+  typedef value_type* pointer;
+  typedef value_type& reference;
+  typedef std::random_access_iterator_tag iterator_category;
+
+private:
+  const array_type* mArray;
+  index_type mIndex;
+
+public:
+  ArrayIterator() : mArray(nullptr), mIndex(0) {}
+  ArrayIterator(const iterator_type& aOther)
+    : mArray(aOther.mArray), mIndex(aOther.mIndex) {}
+  ArrayIterator(const array_type& aArray, index_type aIndex)
+    : mArray(&aArray), mIndex(aIndex) {}
+
+  iterator_type& operator=(const iterator_type& aOther) {
+    mArray = aOther.mArray;
+    mIndex = aOther.mIndex;
+    return *this;
+  }
+
+  bool operator==(const iterator_type& aRhs) const {
+    return mIndex == aRhs.mIndex;
+  }
+  bool operator!=(const iterator_type& aRhs) const {
+    return !(*this == aRhs);
+  }
+  bool operator<(const iterator_type& aRhs) const {
+    return mIndex < aRhs.mIndex;
+  }
+  bool operator>(const iterator_type& aRhs) const {
+    return mIndex > aRhs.mIndex;
+  }
+  bool operator<=(const iterator_type& aRhs) const {
+    return mIndex <= aRhs.mIndex;
+  }
+  bool operator>=(const iterator_type& aRhs) const {
+    return mIndex >= aRhs.mIndex;
+  }
+
+
+
+  value_type* operator->() const {
+    return const_cast<value_type*>(&mArray->ElementAt(mIndex));
+  }
+  Element operator*() const {
+    return const_cast<Element>(mArray->ElementAt(mIndex));
+  }
+
+  iterator_type& operator++() {
+    ++mIndex;
+    return *this;
+  }
+  iterator_type operator++(int) {
+    iterator_type it = *this;
+    ++*this;
+    return it;
+  }
+  iterator_type& operator--() {
+    --mIndex;
+    return *this;
+  }
+  iterator_type operator--(int) {
+    iterator_type it = *this;
+    --*this;
+    return it;
+  }
+
+  iterator_type& operator+=(difference_type aDiff) {
+    mIndex += aDiff;
+    return *this;
+  }
+  iterator_type& operator-=(difference_type aDiff) {
+    mIndex -= aDiff;
+    return *this;
+  }
+
+  iterator_type operator+(difference_type aDiff) const {
+    iterator_type it = *this;
+    it += aDiff;
+    return it;
+  }
+  iterator_type operator-(difference_type aDiff) const {
+    iterator_type it = *this;
+    it -= aDiff;
+    return it;
+  }
+
+  difference_type operator-(const iterator_type& aOther) const {
+    return static_cast<difference_type>(mIndex) -
+      static_cast<difference_type>(aOther.mIndex);
+  }
+
+  Element operator[](difference_type aIndex) const {
+    return *this->operator+(aIndex);
+  }
+};
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 2
+
+namespace mozilla {
+# 66 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h"
+template<typename Container, typename Comparator>
+bool
+BinarySearchIf(const Container& aContainer, size_t aBegin, size_t aEnd,
+               const Comparator& aCompare, size_t* aMatchOrInsertionPoint)
+{
+  do { } while (0);
+
+  size_t low = aBegin;
+  size_t high = aEnd;
+  while (high != low) {
+    size_t middle = low + (high - low) / 2;
+
+
+
+    const int result = aCompare(aContainer[middle]);
+
+    if (result == 0) {
+      *aMatchOrInsertionPoint = middle;
+      return true;
+    }
+
+    if (result < 0) {
+      high = middle;
+    } else {
+      low = middle + 1;
+    }
+  }
+
+  *aMatchOrInsertionPoint = low;
+  return false;
+}
+
+namespace detail {
+
+template<class T>
+class BinarySearchDefaultComparator
+{
+public:
+  explicit BinarySearchDefaultComparator(const T& aTarget)
+    : mTarget(aTarget)
+  {}
+
+  template <class U>
+  int operator()(const U& aVal) const {
+    if (mTarget == aVal) {
+      return 0;
+    }
+
+    if (mTarget < aVal) {
+      return -1;
+    }
+
+    return 1;
+  }
+
+private:
+  const T& mTarget;
+};
+
+}
+
+template <typename Container, typename T>
+bool
+BinarySearch(const Container& aContainer, size_t aBegin, size_t aEnd,
+             T aTarget, size_t* aMatchOrInsertionPoint)
+{
+  return BinarySearchIf(aContainer, aBegin, aEnd,
+                        detail::BinarySearchDefaultComparator<T>(aTarget),
+                        aMatchOrInsertionPoint);
+}
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+
+
+
+
+
+# 1 "/usr/include/math.h" 1 3 4
+# 28 "/usr/include/math.h" 3 4
+extern "C" {
+
+
+
+# 1 "/usr/include/bits/math-vector.h" 1 3 4
+# 25 "/usr/include/bits/math-vector.h" 3 4
+# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
+# 26 "/usr/include/bits/math-vector.h" 2 3 4
+# 32 "/usr/include/math.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/huge_val.h" 1 3 4
+# 36 "/usr/include/math.h" 2 3 4
+
+# 1 "/usr/include/bits/huge_valf.h" 1 3 4
+# 38 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/huge_vall.h" 1 3 4
+# 39 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/inf.h" 1 3 4
+# 42 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/nan.h" 1 3 4
+# 45 "/usr/include/math.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/mathdef.h" 1 3 4
+# 28 "/usr/include/bits/mathdef.h" 3 4
+typedef float float_t;
+typedef double double_t;
+# 49 "/usr/include/math.h" 2 3 4
+# 83 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 54 "/usr/include/bits/mathcalls.h" 3 4
+extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
+
+extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
+
+extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
+
+extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
+
+
+ extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
+
+ extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
+
+extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
+
+
+
+
+extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
+
+extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
+
+extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
+
+
+
+
+ extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
+
+
+
+
+
+
+extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
+
+extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
+
+extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
+
+
+
+
+
+
+
+ extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
+
+
+extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
+
+
+extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
+
+
+ extern double log (double __x) throw (); extern double __log (double __x) throw ();
+
+
+extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
+
+
+extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
+
+extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
+
+
+
+
+
+extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
+
+
+extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
+
+
+extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
+
+
+
+
+
+
+extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
+
+
+extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
+# 153 "/usr/include/bits/mathcalls.h" 3 4
+ extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
+
+
+extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
+
+
+
+
+
+extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
+
+
+
+
+
+
+extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
+# 178 "/usr/include/bits/mathcalls.h" 3 4
+extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
+
+
+extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
+
+
+
+
+extern int __isinf (double __value) throw () __attribute__ ((__const__));
+
+
+extern int __finite (double __value) throw () __attribute__ ((__const__));
+# 208 "/usr/include/bits/mathcalls.h" 3 4
+extern int finite (double __value) throw () __attribute__ ((__const__));
+
+
+extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
+
+
+
+extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
+
+
+
+
+
+extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnan (double __value) throw () __attribute__ ((__const__));
+# 247 "/usr/include/bits/mathcalls.h" 3 4
+extern double j0 (double) throw (); extern double __j0 (double) throw ();
+extern double j1 (double) throw (); extern double __j1 (double) throw ();
+extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
+extern double y0 (double) throw (); extern double __y0 (double) throw ();
+extern double y1 (double) throw (); extern double __y1 (double) throw ();
+extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
+
+
+
+
+
+
+extern double erf (double) throw (); extern double __erf (double) throw ();
+extern double erfc (double) throw (); extern double __erfc (double) throw ();
+extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
+
+
+
+
+
+
+extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
+
+
+
+
+
+extern double gamma (double) throw (); extern double __gamma (double) throw ();
+
+
+
+
+
+
+extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
+
+
+extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
+
+extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
+
+extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
+
+
+
+extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
+
+
+
+extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
+
+
+
+extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
+
+
+
+
+extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
+
+
+
+extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
+
+
+
+extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
+
+
+
+extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
+__extension__
+extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
+
+
+
+extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
+__extension__
+extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
+
+
+
+extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
+
+
+extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+
+extern int __fpclassify (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbit (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
+# 382 "/usr/include/bits/mathcalls.h" 3 4
+extern int __issignaling (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+# 84 "/usr/include/math.h" 2 3 4
+# 104 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 54 "/usr/include/bits/mathcalls.h" 3 4
+extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
+
+extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
+
+extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
+
+extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
+
+
+ extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
+
+ extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
+
+extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
+
+
+
+
+extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
+
+extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
+
+extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
+
+
+
+
+ extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
+
+
+
+
+
+
+extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
+
+extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
+
+extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
+
+
+
+
+
+
+
+ extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
+
+
+extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
+
+
+extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
+
+
+ extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
+
+
+extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
+
+
+extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
+
+extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
+
+
+
+
+
+extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
+
+
+extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
+
+
+extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
+
+
+
+
+
+
+extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
+
+
+extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
+# 153 "/usr/include/bits/mathcalls.h" 3 4
+ extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
+
+
+extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
+
+
+
+
+
+extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
+
+
+
+
+
+
+extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
+# 178 "/usr/include/bits/mathcalls.h" 3 4
+extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
+
+
+
+
+extern int __isinff (float __value) throw () __attribute__ ((__const__));
+
+
+extern int __finitef (float __value) throw () __attribute__ ((__const__));
+# 204 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinff (float __value) throw () __attribute__ ((__const__));
+
+
+
+extern int finitef (float __value) throw () __attribute__ ((__const__));
+
+
+extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
+
+
+
+extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
+
+
+
+
+
+extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnanf (float __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern int isnanf (float __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern float j0f (float) throw (); extern float __j0f (float) throw ();
+extern float j1f (float) throw (); extern float __j1f (float) throw ();
+extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
+extern float y0f (float) throw (); extern float __y0f (float) throw ();
+extern float y1f (float) throw (); extern float __y1f (float) throw ();
+extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
+
+
+
+
+
+
+extern float erff (float) throw (); extern float __erff (float) throw ();
+extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
+extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
+
+
+
+
+
+
+extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
+
+
+
+
+
+extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
+
+
+
+
+
+
+extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
+
+
+extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
+
+extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
+
+extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
+
+
+
+extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
+
+
+
+extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
+
+
+
+extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
+
+
+
+
+extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
+
+
+
+extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
+
+
+
+extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
+
+
+
+extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
+__extension__
+extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
+
+
+
+extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
+__extension__
+extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
+
+
+
+extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
+
+
+extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+
+extern int __fpclassifyf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
+# 382 "/usr/include/bits/mathcalls.h" 3 4
+extern int __issignalingf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+# 105 "/usr/include/math.h" 2 3 4
+# 151 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 54 "/usr/include/bits/mathcalls.h" 3 4
+extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
+
+extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
+
+extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
+
+extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
+
+
+ extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
+
+ extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
+
+extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
+
+
+
+
+extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
+
+extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
+
+extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
+
+
+
+
+ extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
+
+
+
+
+
+
+extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
+
+extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
+
+extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
+
+
+
+
+
+
+
+ extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
+
+
+extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
+
+
+extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
+
+
+ extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
+
+
+extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
+
+
+extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
+
+extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
+
+
+
+
+
+extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
+
+
+extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
+
+
+extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
+
+
+
+
+
+
+extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
+
+
+extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
+# 153 "/usr/include/bits/mathcalls.h" 3 4
+ extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
+
+
+extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
+
+
+
+
+
+extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
+
+
+
+
+
+
+extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
+# 178 "/usr/include/bits/mathcalls.h" 3 4
+extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
+
+
+
+
+extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
+
+
+extern int __finitel (long double __value) throw () __attribute__ ((__const__));
+# 204 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinfl (long double __value) throw () __attribute__ ((__const__));
+
+
+
+extern int finitel (long double __value) throw () __attribute__ ((__const__));
+
+
+extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
+
+
+
+extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
+
+
+
+
+
+extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern int isnanl (long double __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
+extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
+extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
+extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
+extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
+extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
+
+
+
+
+
+
+extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
+extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
+extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
+
+
+
+
+
+
+extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
+
+
+
+
+
+extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
+
+
+
+
+
+
+extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
+
+
+extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
+
+extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
+
+
+
+extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
+
+
+
+extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
+
+
+
+extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
+
+
+
+
+extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
+
+
+
+extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
+
+
+
+extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
+__extension__
+extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
+
+
+
+extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
+__extension__
+extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
+
+
+
+extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
+
+
+extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+extern int __fpclassifyl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
+# 382 "/usr/include/bits/mathcalls.h" 3 4
+extern int __issignalingl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+# 152 "/usr/include/math.h" 2 3 4
+# 168 "/usr/include/math.h" 3 4
+extern int signgam;
+# 209 "/usr/include/math.h" 3 4
+enum
+  {
+    FP_NAN =
+
+      0,
+    FP_INFINITE =
+
+      1,
+    FP_ZERO =
+
+      2,
+    FP_SUBNORMAL =
+
+      3,
+    FP_NORMAL =
+
+      4
+  };
+# 347 "/usr/include/math.h" 3 4
+typedef enum
+{
+  _IEEE_ = -1,
+  _SVID_,
+  _XOPEN_,
+  _POSIX_,
+  _ISOC_
+} _LIB_VERSION_TYPE;
+
+
+
+
+extern _LIB_VERSION_TYPE _LIB_VERSION;
+# 370 "/usr/include/math.h" 3 4
+struct __exception
+
+
+
+  {
+    int type;
+    char *name;
+    double arg1;
+    double arg2;
+    double retval;
+  };
+
+
+extern int matherr (struct __exception *__exc) throw ();
+# 534 "/usr/include/math.h" 3 4
+}
+# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 2 3
+# 77 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  inline constexpr double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+
+
+
+  inline constexpr float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline constexpr long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    abs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::acos;
+
+
+  inline constexpr float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+
+  inline constexpr long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+
+  using ::asin;
+
+
+  inline constexpr float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+
+  inline constexpr long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+
+  using ::atan;
+
+
+  inline constexpr float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+
+  inline constexpr long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+
+  using ::atan2;
+
+
+  inline constexpr float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+
+  inline constexpr long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+
+
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+
+  using ::ceil;
+
+
+  inline constexpr float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+
+  inline constexpr long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+
+  using ::cos;
+
+
+  inline constexpr float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+
+  inline constexpr long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+
+  using ::cosh;
+
+
+  inline constexpr float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+
+  inline constexpr long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+
+  using ::exp;
+
+
+  inline constexpr float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+
+  inline constexpr long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+
+  using ::fabs;
+
+
+  inline constexpr float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline constexpr long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::floor;
+
+
+  inline constexpr float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+
+  inline constexpr long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+
+  using ::fmod;
+
+
+  inline constexpr float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+
+  inline constexpr long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+
+
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmod(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmod(__type(__x), __type(__y));
+    }
+
+  using ::frexp;
+
+
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+
+  using ::ldexp;
+
+
+  inline constexpr float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+
+  inline constexpr long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ldexp(_Tp __x, int __exp)
+    { return __builtin_ldexp(__x, __exp); }
+
+  using ::log;
+
+
+  inline constexpr float
+  log(float __x)
+  { return __builtin_logf(__x); }
+
+  inline constexpr long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+
+  using ::log10;
+
+
+  inline constexpr float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+
+  inline constexpr long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+
+  using ::modf;
+
+
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+
+
+  using ::pow;
+
+
+  inline constexpr float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+
+  inline constexpr long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+# 435 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
+  using ::sin;
+
+
+  inline constexpr float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline constexpr long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+
+  inline constexpr float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline constexpr long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+
+  inline constexpr float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline constexpr long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+
+  inline constexpr float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline constexpr long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+
+  inline constexpr float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline constexpr long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+
+
+}
+# 559 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  constexpr int
+  fpclassify(float __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(long double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              int>::__type
+    fpclassify(_Tp __x)
+    { return __x != 0 ? 4 : 2; }
+
+
+
+  constexpr bool
+  isfinite(float __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(double __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(long double __x)
+  { return __builtin_isfinite(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isfinite(_Tp __x)
+    { return true; }
+
+
+
+  constexpr bool
+  isinf(float __x)
+  { return __builtin_isinf(__x); }
+
+
+
+
+
+  constexpr bool
+  isinf(double __x)
+  { return __builtin_isinf(__x); }
+
+
+  constexpr bool
+  isinf(long double __x)
+  { return __builtin_isinf(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isinf(_Tp __x)
+    { return false; }
+
+
+
+  constexpr bool
+  isnan(float __x)
+  { return __builtin_isnan(__x); }
+
+
+
+
+
+  constexpr bool
+  isnan(double __x)
+  { return __builtin_isnan(__x); }
+
+
+  constexpr bool
+  isnan(long double __x)
+  { return __builtin_isnan(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnan(_Tp __x)
+    { return false; }
+
+
+
+  constexpr bool
+  isnormal(float __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(double __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(long double __x)
+  { return __builtin_isnormal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnormal(_Tp __x)
+    { return __x != 0 ? true : false; }
+
+
+
+
+  constexpr bool
+  signbit(float __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbit(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    signbit(_Tp __x)
+    { return __x < 0 ? true : false; }
+
+
+
+  constexpr bool
+  isgreater(float __x, float __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(double __x, double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(long double __x, long double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isgreaterequal(float __x, float __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(double __x, double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(long double __x, long double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreaterequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreaterequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isless(float __x, float __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(double __x, double __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(long double __x, long double __y)
+  { return __builtin_isless(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isless(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isless(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessequal(float __x, float __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(double __x, double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(long double __x, long double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessgreater(float __x, float __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(double __x, double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(long double __x, long double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isunordered(float __x, float __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(double __x, double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(long double __x, long double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isunordered(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isunordered(__type(__x), __type(__y));
+    }
+# 981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+}
+# 1096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  using ::double_t;
+  using ::float_t;
+
+
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+
+  using ::remquo;
+  using ::remquof;
+  using ::remquol;
+
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+
+
+
+  constexpr float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+
+  constexpr long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    acosh(_Tp __x)
+    { return __builtin_acosh(__x); }
+
+
+
+  constexpr float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+
+  constexpr long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    asinh(_Tp __x)
+    { return __builtin_asinh(__x); }
+
+
+
+  constexpr float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+
+  constexpr long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    atanh(_Tp __x)
+    { return __builtin_atanh(__x); }
+
+
+
+  constexpr float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+
+  constexpr long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    cbrt(_Tp __x)
+    { return __builtin_cbrt(__x); }
+
+
+
+  constexpr float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+
+  constexpr long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+
+  constexpr long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erf(_Tp __x)
+    { return __builtin_erf(__x); }
+
+
+
+  constexpr float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+
+  constexpr long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erfc(_Tp __x)
+    { return __builtin_erfc(__x); }
+
+
+
+  constexpr float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+
+  constexpr long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    exp2(_Tp __x)
+    { return __builtin_exp2(__x); }
+
+
+
+  constexpr float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+
+  constexpr long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    expm1(_Tp __x)
+    { return __builtin_expm1(__x); }
+
+
+
+  constexpr float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+
+  constexpr long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+
+  constexpr long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+
+
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+
+
+
+  constexpr float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+
+  constexpr long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+
+  constexpr long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+
+  constexpr long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+
+  constexpr int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    int>::__type
+    ilogb(_Tp __x)
+    { return __builtin_ilogb(__x); }
+
+
+
+  constexpr float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+
+  constexpr long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    lgamma(_Tp __x)
+    { return __builtin_lgamma(__x); }
+
+
+
+  constexpr long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+
+  constexpr long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llrint(_Tp __x)
+    { return __builtin_llrint(__x); }
+
+
+
+  constexpr long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+
+  constexpr long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llround(_Tp __x)
+    { return __builtin_llround(__x); }
+
+
+
+  constexpr float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+
+  constexpr long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log1p(_Tp __x)
+    { return __builtin_log1p(__x); }
+
+
+
+
+  constexpr float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+
+  constexpr long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log2(_Tp __x)
+    { return __builtin_log2(__x); }
+
+
+
+  constexpr float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+
+  constexpr long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    logb(_Tp __x)
+    { return __builtin_logb(__x); }
+
+
+
+  constexpr long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+
+  constexpr long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lrint(_Tp __x)
+    { return __builtin_lrint(__x); }
+
+
+
+  constexpr long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+
+  constexpr long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lround(_Tp __x)
+    { return __builtin_lround(__x); }
+
+
+
+  constexpr float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+
+  constexpr long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nearbyint(_Tp __x)
+    { return __builtin_nearbyint(__x); }
+
+
+
+  constexpr float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+
+  constexpr long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+
+  constexpr long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nexttoward(_Tp __x, long double __y)
+    { return __builtin_nexttoward(__x, __y); }
+
+
+
+  constexpr float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+
+  constexpr long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+
+
+
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+
+
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+
+
+
+  constexpr float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+
+  constexpr long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    rint(_Tp __x)
+    { return __builtin_rint(__x); }
+
+
+
+  constexpr float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+
+  constexpr long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    round(_Tp __x)
+    { return __builtin_round(__x); }
+
+
+
+  constexpr float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+
+  constexpr long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbln(_Tp __x, long __ex)
+    { return __builtin_scalbln(__x, __ex); }
+
+
+
+  constexpr float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+
+  constexpr long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbn(_Tp __x, int __ex)
+    { return __builtin_scalbn(__x, __ex); }
+
+
+
+  constexpr float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+
+  constexpr long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    tgamma(_Tp __x)
+    { return __builtin_tgamma(__x); }
+
+
+
+  constexpr float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+
+  constexpr long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    trunc(_Tp __x)
+    { return __builtin_trunc(__x); }
+
+
+
+}
+# 1889 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 2
+
+
+
+namespace mozilla {
+
+
+template<typename IntegerType>
+__attribute__((always_inline)) inline IntegerType
+EuclidGCD(IntegerType aA, IntegerType aB)
+{
+
+
+  do { } while (0);
+  do { } while (0);
+
+  while (aA != aB) {
+    if (aA > aB) {
+      aA = aA - aB;
+    } else {
+      aB = aB - aA;
+    }
+  }
+
+  return aA;
+}
+
+
+template<typename IntegerType>
+__attribute__((always_inline)) inline IntegerType
+EuclidLCM(IntegerType aA, IntegerType aB)
+{
+
+  return (aA / EuclidGCD(aA, aB)) * aB;
+}
+
+namespace detail {
+
+template<typename T>
+struct AllowDeprecatedAbsFixed : FalseType {};
+
+template<> struct AllowDeprecatedAbsFixed<int32_t> : TrueType {};
+template<> struct AllowDeprecatedAbsFixed<int64_t> : TrueType {};
+
+template<typename T>
+struct AllowDeprecatedAbs : AllowDeprecatedAbsFixed<T> {};
+
+template<> struct AllowDeprecatedAbs<int> : TrueType {};
+template<> struct AllowDeprecatedAbs<long> : TrueType {};
+
+}
+
+
+
+template<typename T>
+inline typename mozilla::EnableIf<detail::AllowDeprecatedAbs<T>::value, T>::Type
+DeprecatedAbs(const T aValue)
+{
+# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+  do { } while (0);
+
+
+  return aValue >= 0 ? aValue : -aValue;
+}
+
+namespace detail {
+
+
+
+
+
+template<typename T>
+struct AbsReturnTypeFixed;
+
+template<> struct AbsReturnTypeFixed<int8_t> { typedef uint8_t Type; };
+template<> struct AbsReturnTypeFixed<int16_t> { typedef uint16_t Type; };
+template<> struct AbsReturnTypeFixed<int32_t> { typedef uint32_t Type; };
+template<> struct AbsReturnTypeFixed<int64_t> { typedef uint64_t Type; };
+
+template<typename T>
+struct AbsReturnType : AbsReturnTypeFixed<T> {};
+
+template<> struct AbsReturnType<char> :
+  EnableIf<char(-1) < char(0), unsigned char> {};
+template<> struct AbsReturnType<signed char> { typedef unsigned char Type; };
+template<> struct AbsReturnType<short> { typedef unsigned short Type; };
+template<> struct AbsReturnType<int> { typedef unsigned int Type; };
+template<> struct AbsReturnType<long> { typedef unsigned long Type; };
+template<> struct AbsReturnType<long long> { typedef unsigned long long Type; };
+template<> struct AbsReturnType<float> { typedef float Type; };
+template<> struct AbsReturnType<double> { typedef double Type; };
+template<> struct AbsReturnType<long double> { typedef long double Type; };
+
+}
+
+template<typename T>
+inline typename detail::AbsReturnType<T>::Type
+Abs(const T aValue)
+{
+  typedef typename detail::AbsReturnType<T>::Type ReturnType;
+  return aValue >= 0 ? ReturnType(aValue) : ~ReturnType(aValue) + 1;
+}
+
+template<>
+inline float
+Abs<float>(const float aFloat)
+{
+  return std::fabs(aFloat);
+}
+
+template<>
+inline double
+Abs<double>(const double aDouble)
+{
+  return std::fabs(aDouble);
+}
+
+template<>
+inline long double
+Abs<long double>(const long double aLongDouble)
+{
+  return std::fabs(aLongDouble);
+}
+
+}
+# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+namespace mozilla {
+
+namespace detail {
+# 250 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+inline uint_fast8_t
+CountLeadingZeroes32(uint32_t aValue)
+{
+  return __builtin_clz(aValue);
+}
+
+inline uint_fast8_t
+CountTrailingZeroes32(uint32_t aValue)
+{
+  return __builtin_ctz(aValue);
+}
+
+inline uint_fast8_t
+CountPopulation32(uint32_t aValue)
+{
+  return __builtin_popcount(aValue);
+}
+
+inline uint_fast8_t
+CountPopulation64(uint64_t aValue)
+{
+  return __builtin_popcountll(aValue);
+}
+
+inline uint_fast8_t
+CountLeadingZeroes64(uint64_t aValue)
+{
+  return __builtin_clzll(aValue);
+}
+
+inline uint_fast8_t
+CountTrailingZeroes64(uint64_t aValue)
+{
+  return __builtin_ctzll(aValue);
+}
+# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+}
+# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+inline uint_fast8_t
+CountLeadingZeroes32(uint32_t aValue)
+{
+  do { } while (0);
+  return detail::CountLeadingZeroes32(aValue);
+}
+# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+inline uint_fast8_t
+CountTrailingZeroes32(uint32_t aValue)
+{
+  do { } while (0);
+  return detail::CountTrailingZeroes32(aValue);
+}
+
+
+
+
+inline uint_fast8_t
+CountPopulation32(uint32_t aValue)
+{
+  return detail::CountPopulation32(aValue);
+}
+
+
+inline uint_fast8_t
+CountPopulation64(uint64_t aValue)
+{
+  return detail::CountPopulation64(aValue);
+}
+
+
+inline uint_fast8_t
+CountLeadingZeroes64(uint64_t aValue)
+{
+  do { } while (0);
+  return detail::CountLeadingZeroes64(aValue);
+}
+
+
+inline uint_fast8_t
+CountTrailingZeroes64(uint64_t aValue)
+{
+  do { } while (0);
+  return detail::CountTrailingZeroes64(aValue);
+}
+
+namespace detail {
+
+template<typename T, size_t Size = sizeof(T)>
+class CeilingLog2;
+
+template<typename T>
+class CeilingLog2<T, 4>
+{
+public:
+  static uint_fast8_t compute(const T aValue)
+  {
+
+    return aValue <= 1 ? 0u : 32u - CountLeadingZeroes32(aValue - 1);
+  }
+};
+
+template<typename T>
+class CeilingLog2<T, 8>
+{
+public:
+  static uint_fast8_t compute(const T aValue)
+  {
+
+    return aValue <= 1 ? 0u : 64u - CountLeadingZeroes64(aValue - 1);
+  }
+};
+
+}
+# 404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+template<typename T>
+inline uint_fast8_t
+CeilingLog2(const T aValue)
+{
+  return detail::CeilingLog2<T>::compute(aValue);
+}
+
+
+inline uint_fast8_t
+CeilingLog2Size(size_t aValue)
+{
+  return CeilingLog2(aValue);
+}
+
+namespace detail {
+
+template<typename T, size_t Size = sizeof(T)>
+class FloorLog2;
+
+template<typename T>
+class FloorLog2<T, 4>
+{
+public:
+  static uint_fast8_t compute(const T aValue)
+  {
+    return 31u - CountLeadingZeroes32(aValue | 1);
+  }
+};
+
+template<typename T>
+class FloorLog2<T, 8>
+{
+public:
+  static uint_fast8_t compute(const T aValue)
+  {
+    return 63u - CountLeadingZeroes64(aValue | 1);
+  }
+};
+
+}
+# 453 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
+template<typename T>
+inline uint_fast8_t
+FloorLog2(const T aValue)
+{
+  return detail::FloorLog2<T>::compute(aValue);
+}
+
+
+inline uint_fast8_t
+FloorLog2Size(size_t aValue)
+{
+  return FloorLog2(aValue);
+}
+
+
+
+
+
+inline size_t
+RoundUpPow2(size_t aValue)
+{
+  do { } while (0);
+
+  return size_t(1) << CeilingLog2(aValue);
+}
+
+
+
+
+template<typename T>
+inline T
+RotateLeft(const T aValue, uint_fast8_t aShift)
+{
+  do { } while (0);
+  do { } while (0);
+
+
+
+
+  static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
+  return (aValue << aShift) | (aValue >> (sizeof(T) * 8 - aShift));
+}
+
+
+
+
+template<typename T>
+inline T
+RotateRight(const T aValue, uint_fast8_t aShift)
+{
+  do { } while (0);
+  do { } while (0);
+
+
+
+
+  static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
+  return (aValue >> aShift) | (aValue << (sizeof(T) * 8 - aShift));
+}
+
+
+
+
+
+template<typename T>
+constexpr bool
+IsPowerOfTwo(T x)
+{
+    static_assert(IsUnsigned<T>::value,
+                  "IsPowerOfTwo requires unsigned values");
+    return x && (x & (x - 1)) == 0;
+}
+
+template<typename T>
+inline T
+Clamp(const T aValue, const T aMin, const T aMax)
+{
+    static_assert(IsIntegral<T>::value,
+                  "Clamp accepts only integral types, so that it doesn't have"
+                  " to distinguish differently-signed zeroes (which users may"
+                  " or may not care to distinguish, likely at a perf cost) or"
+                  " to decide how to clamp NaN or a range with a NaN"
+                  " endpoint.");
+    do { } while (0);
+
+    if (aValue <= aMin)
+        return aMin;
+    if (aValue >= aMax)
+        return aMax;
+    return aValue;
+}
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 2
+
+
+
+namespace mozilla {
+
+
+
+
+
+typedef size_t (*MallocSizeOf)(const void* p);
+
+}
+
+
+
+typedef size_t (*MozMallocSizeOf)(const void* p);
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h"
+namespace mozilla {
+
+template<typename IteratorT>
+class ReverseIterator
+{
+public:
+  template<typename Iterator>
+  explicit ReverseIterator(Iterator aIter)
+    : mCurrent(aIter) { }
+
+  template<typename Iterator>
+               ReverseIterator(const ReverseIterator<Iterator>& aOther)
+    : mCurrent(aOther.mCurrent) { }
+
+  decltype(*DeclVal<IteratorT>()) operator*() const
+  {
+    IteratorT tmp = mCurrent;
+    return *--tmp;
+  }
+
+
+
+  ReverseIterator& operator++() { --mCurrent; return *this; }
+  ReverseIterator& operator--() { ++mCurrent; return *this; }
+  ReverseIterator operator++(int) { auto ret = *this; mCurrent--; return ret; }
+  ReverseIterator operator--(int) { auto ret = *this; mCurrent++; return ret; }
+
+
+
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator==(const ReverseIterator<Iterator1>& aIter1,
+                         const ReverseIterator<Iterator2>& aIter2);
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator!=(const ReverseIterator<Iterator1>& aIter1,
+                         const ReverseIterator<Iterator2>& aIter2);
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator<(const ReverseIterator<Iterator1>& aIter1,
+                        const ReverseIterator<Iterator2>& aIter2);
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator<=(const ReverseIterator<Iterator1>& aIter1,
+                         const ReverseIterator<Iterator2>& aIter2);
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator>(const ReverseIterator<Iterator1>& aIter1,
+                        const ReverseIterator<Iterator2>& aIter2);
+  template<typename Iterator1, typename Iterator2>
+  friend bool operator>=(const ReverseIterator<Iterator1>& aIter1,
+                         const ReverseIterator<Iterator2>& aIter2);
+
+private:
+  IteratorT mCurrent;
+};
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator==(const ReverseIterator<Iterator1>& aIter1,
+           const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent == aIter2.mCurrent;
+}
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator!=(const ReverseIterator<Iterator1>& aIter1,
+           const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent != aIter2.mCurrent;
+}
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator<(const ReverseIterator<Iterator1>& aIter1,
+          const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent > aIter2.mCurrent;
+}
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator<=(const ReverseIterator<Iterator1>& aIter1,
+           const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent >= aIter2.mCurrent;
+}
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator>(const ReverseIterator<Iterator1>& aIter1,
+          const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent < aIter2.mCurrent;
+}
+
+template<typename Iterator1, typename Iterator2>
+bool
+operator>=(const ReverseIterator<Iterator1>& aIter1,
+           const ReverseIterator<Iterator2>& aIter2)
+{
+  return aIter1.mCurrent <= aIter2.mCurrent;
+}
+
+namespace detail {
+
+template<typename IteratorT>
+class IteratorRange
+{
+public:
+  typedef IteratorT iterator;
+  typedef IteratorT const_iterator;
+  typedef ReverseIterator<IteratorT> reverse_iterator;
+  typedef ReverseIterator<IteratorT> const_reverse_iterator;
+
+  template<typename Iterator1, typename Iterator2>
+               IteratorRange(Iterator1 aIterBegin, Iterator2 aIterEnd)
+    : mIterBegin(aIterBegin), mIterEnd(aIterEnd) { }
+
+  template<typename Iterator>
+               IteratorRange(const IteratorRange<Iterator>& aOther)
+    : mIterBegin(aOther.mIterBegin), mIterEnd(aOther.mIterEnd) { }
+
+  iterator begin() const { return mIterBegin; }
+  const_iterator cbegin() const { return begin(); }
+  iterator end() const { return mIterEnd; }
+  const_iterator cend() const { return end(); }
+  reverse_iterator rbegin() const { return reverse_iterator(mIterEnd); }
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  reverse_iterator rend() const { return reverse_iterator(mIterBegin); }
+  const_reverse_iterator crend() const { return rend(); }
+
+private:
+  IteratorT mIterBegin;
+  IteratorT mIterEnd;
+};
+
+}
+
+template<typename Range>
+detail::IteratorRange<typename Range::reverse_iterator>
+Reversed(Range& aRange)
+{
+  return {aRange.rbegin(), aRange.rend()};
+}
+
+template<typename Range>
+detail::IteratorRange<typename Range::const_reverse_iterator>
+Reversed(const Range& aRange)
+{
+  return {aRange.rbegin(), aRange.rend()};
+}
+
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 2
+
+namespace mozilla {
+
+template<typename T, size_t Length>
+class Array
+{
+  T mArr[Length];
+
+public:
+  Array() {}
+
+  template <typename... Args>
+               Array(Args&&... aArgs)
+    : mArr{mozilla::Forward<Args>(aArgs)...}
+  {
+    static_assert(sizeof...(aArgs) == Length,
+                  "The number of arguments should be equal to the template parameter Length");
+  }
+
+  T& operator[](size_t aIndex)
+  {
+    do { } while (0);
+    return mArr[aIndex];
+  }
+
+  const T& operator[](size_t aIndex) const
+  {
+    do { } while (0);
+    return mArr[aIndex];
+  }
+
+  bool operator==(const Array<T, Length>& aOther) const
+  {
+    for (size_t i = 0; i < Length; i++) {
+      if (mArr[i] != aOther[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  typedef T* iterator;
+  typedef const T* const_iterator;
+  typedef ReverseIterator<T*> reverse_iterator;
+  typedef ReverseIterator<const T*> const_reverse_iterator;
+
+
+  iterator begin() { return mArr; }
+  const_iterator begin() const { return mArr; }
+  const_iterator cbegin() const { return begin(); }
+  iterator end() { return mArr + Length; }
+  const_iterator end() const { return mArr + Length; }
+  const_iterator cend() const { return end(); }
+
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  const_reverse_iterator crend() const { return rend(); }
+};
+
+template<typename T>
+class Array<T, 0>
+{
+public:
+  T& operator[](size_t aIndex)
+  {
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 87; ::abort(); } while (0); } while (0);
+  }
+
+  const T& operator[](size_t aIndex) const
+  {
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 92; ::abort(); } while (0); } while (0);
+  }
+};
+
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h"
+namespace mozilla {
+# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h"
+template<typename To, typename From>
+inline void
+BitwiseCast(const From aFrom, To* aResult)
+{
+  static_assert(sizeof(From) == sizeof(To),
+                "To and From must have the same size");
+  union
+  {
+    From mFrom;
+    To mTo;
+  } u;
+  u.mFrom = aFrom;
+  *aResult = u.mTo;
+}
+
+template<typename To, typename From>
+inline To
+BitwiseCast(const From aFrom)
+{
+  To temp;
+  BitwiseCast<To, From>(aFrom, &temp);
+  return temp;
+}
+
+namespace detail {
+
+enum ToSignedness { ToIsSigned, ToIsUnsigned };
+enum FromSignedness { FromIsSigned, FromIsUnsigned };
+
+template<typename From,
+         typename To,
+         FromSignedness = IsSigned<From>::value ? FromIsSigned : FromIsUnsigned,
+         ToSignedness = IsSigned<To>::value ? ToIsSigned : ToIsUnsigned>
+struct BoundsCheckImpl;
+
+
+
+
+
+
+enum UUComparison { FromIsBigger, FromIsNotBigger };
+
+
+
+template<typename From, typename To,
+         UUComparison = (sizeof(From) > sizeof(To))
+                        ? FromIsBigger
+                        : FromIsNotBigger>
+struct UnsignedUnsignedCheck;
+
+template<typename From, typename To>
+struct UnsignedUnsignedCheck<From, To, FromIsBigger>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return aFrom <= From(To(-1));
+  }
+};
+
+template<typename From, typename To>
+struct UnsignedUnsignedCheck<From, To, FromIsNotBigger>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return true;
+  }
+};
+
+template<typename From, typename To>
+struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsUnsigned>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return UnsignedUnsignedCheck<From, To>::checkBounds(aFrom);
+  }
+};
+
+
+
+template<typename From, typename To>
+struct BoundsCheckImpl<From, To, FromIsSigned, ToIsUnsigned>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    if (aFrom < 0) {
+      return false;
+    }
+    if (sizeof(To) >= sizeof(From)) {
+      return true;
+    }
+    return aFrom <= From(To(-1));
+  }
+};
+
+
+
+enum USComparison { FromIsSmaller, FromIsNotSmaller };
+
+template<typename From, typename To,
+         USComparison = (sizeof(From) < sizeof(To))
+                        ? FromIsSmaller
+                        : FromIsNotSmaller>
+struct UnsignedSignedCheck;
+
+template<typename From, typename To>
+struct UnsignedSignedCheck<From, To, FromIsSmaller>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return true;
+  }
+};
+
+template<typename From, typename To>
+struct UnsignedSignedCheck<From, To, FromIsNotSmaller>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1);
+    return aFrom <= From(MaxValue);
+  }
+};
+
+template<typename From, typename To>
+struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsSigned>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return UnsignedSignedCheck<From, To>::checkBounds(aFrom);
+  }
+};
+
+
+
+template<typename From, typename To>
+struct BoundsCheckImpl<From, To, FromIsSigned, ToIsSigned>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    if (sizeof(From) <= sizeof(To)) {
+      return true;
+    }
+    const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1);
+    const To MinValue = -MaxValue - To(1);
+    return From(MinValue) <= aFrom &&
+           From(aFrom) <= From(MaxValue);
+  }
+};
+
+template<typename From, typename To,
+         bool TypesAreIntegral = IsIntegral<From>::value &&
+                                 IsIntegral<To>::value>
+class BoundsChecker;
+
+template<typename From>
+class BoundsChecker<From, From, true>
+{
+public:
+  static bool checkBounds(const From aFrom) { return true; }
+};
+
+template<typename From, typename To>
+class BoundsChecker<From, To, true>
+{
+public:
+  static bool checkBounds(const From aFrom)
+  {
+    return BoundsCheckImpl<From, To>::checkBounds(aFrom);
+  }
+};
+
+template<typename From, typename To>
+inline bool
+IsInBounds(const From aFrom)
+{
+  return BoundsChecker<From, To>::checkBounds(aFrom);
+}
+
+}
+
+
+
+
+
+
+template<typename To, typename From>
+inline To
+AssertedCast(const From aFrom)
+{
+  do { } while (0);
+  return static_cast<To>(aFrom);
+}
+
+
+
+
+
+
+template<typename To, typename From>
+inline To
+ReleaseAssertedCast(const From aFrom)
+{
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype((detail::IsInBounds<From, To>(aFrom)))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((detail::IsInBounds<From, To>(aFrom))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(detail::IsInBounds<From, To>(aFrom))" ")"); do { *((volatile int*) __null) = 250; ::abort(); } while (0); } } while (0);
+  return static_cast<To>(aFrom);
+}
+
+}
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3
+# 69 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 1 3
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  namespace rel_ops
+  {
+# 85 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+# 124 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+
+
+  }
+
+}
+# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 2 3
+
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp>
+    struct tuple_size;
+
+
+
+  template<typename _Tp>
+    struct tuple_size<const _Tp>
+    : integral_constant<size_t, tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<volatile _Tp>
+    : integral_constant<size_t, tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<const volatile _Tp>
+    : integral_constant<size_t, tuple_size<_Tp>::value> { };
+
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element;
+
+
+  template<std::size_t __i, typename _Tp>
+    using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const _Tp>
+    {
+      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, volatile _Tp>
+    {
+      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const volatile _Tp>
+    {
+      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+
+
+
+  template<std::size_t __i, typename _Tp>
+    using tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+
+  template<typename>
+    struct __is_tuple_like_impl : false_type
+    { };
+
+
+
+
+  template<typename _T1, typename _T2>
+    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
+    { };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2>>
+    : public integral_constant<std::size_t, 2> { };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp1 type; };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp2 type; };
+
+  template<std::size_t _Int>
+    struct __pair_get;
+
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp1>(__pair.first); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+    };
+
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp2>(__pair.second); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+    };
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__get(__in); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__move_get(std::move(__in)); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__const_get(__in); }
+
+
+
+
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+
+
+
+
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    exchange(_Tp& __obj, _Up&& __new_val)
+    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+
+
+
+
+  template<size_t... _Indexes> struct _Index_tuple { };
+
+
+  template<typename _Itup1, typename _Itup2> struct _Itup_cat;
+
+  template<size_t... _Ind1, size_t... _Ind2>
+    struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
+    {
+      using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>;
+    };
+
+
+  template<size_t _Num>
+    struct _Build_index_tuple
+    : _Itup_cat<typename _Build_index_tuple<_Num / 2>::__type,
+  typename _Build_index_tuple<_Num - _Num / 2>::__type>
+    { };
+
+  template<>
+    struct _Build_index_tuple<1>
+    {
+      typedef _Index_tuple<0> __type;
+    };
+
+  template<>
+    struct _Build_index_tuple<0>
+    {
+      typedef _Index_tuple<> __type;
+    };
+
+
+
+
+
+
+  template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() { return sizeof...(_Idx); }
+    };
+
+  template<typename _Tp, _Tp _Num,
+    typename _ISeq = typename _Build_index_tuple<_Num>::__type>
+    struct _Make_integer_sequence;
+
+  template<typename _Tp, _Tp _Num, size_t... _Idx>
+    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
+    {
+      static_assert( _Num >= 0,
+       "Cannot make integer sequence of negative length" );
+
+      typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
+    };
+
+
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+      = typename _Make_integer_sequence<_Tp, _Num>::__type;
+
+
+  template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+
+
+  template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+
+  template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+
+
+}
+# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
+
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
+  template<typename _IIter, typename _Predicate>
+    bool
+    all_of(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    any_of(_IIter, _IIter, _Predicate);
+
+
+  template<typename _FIter, typename _Tp>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    copy(_IIter, _IIter, _OIter);
+
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+  template<typename _IIter, typename _Size, typename _OIter>
+    _OIter
+    copy_n(_IIter, _Size, _OIter);
+
+
+
+
+
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    void
+    fill(_FIter, _FIter, const _Tp&);
+
+  template<typename _OIter, typename _Size, typename _Tp>
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+
+
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+
+
+
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if_not(_IIter, _IIter, _Predicate);
+
+
+
+
+
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _BIter>
+    void
+    inplace_merge(_BIter, _BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    void
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+
+
+  template<typename _RAIter>
+    bool
+    is_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    bool
+    is_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    _RAIter
+    is_heap_until(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    is_heap_until(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    is_partitioned(_IIter, _IIter, _Predicate);
+
+  template<typename _FIter1, typename _FIter2>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2);
+
+  template<typename _FIter1, typename _FIter2,
+    typename _BinaryPredicate>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter>
+    bool
+    is_sorted(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    bool
+    is_sorted(_FIter, _FIter, _Compare);
+
+  template<typename _FIter>
+    _FIter
+    is_sorted_until(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    is_sorted_until(_FIter, _FIter, _Compare);
+
+
+  template<typename _FIter1, typename _FIter2>
+    void
+    iter_swap(_FIter1, _FIter2);
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _RAIter>
+    void
+    make_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    make_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>, _Compare);
+
+
+
+
+  template<typename _BIter>
+    bool
+    next_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool
+    next_permutation(_BIter, _BIter, _Compare);
+
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    none_of(_IIter, _IIter, _Predicate);
+
+
+
+
+
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+
+
+
+
+  template<typename _IIter, typename _OIter1,
+    typename _OIter2, typename _Predicate>
+    pair<_OIter1, _OIter2>
+    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    partition_point(_FIter, _FIter, _Predicate);
+
+
+  template<typename _RAIter>
+    void
+    pop_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    pop_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter>
+    bool
+    prev_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool
+    prev_permutation(_BIter, _BIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    push_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    push_heap(_RAIter, _RAIter, _Compare);
+
+
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    remove(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    remove_if(_FIter, _FIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+
+
+  template<typename _BIter>
+    void
+    reverse(_BIter, _BIter);
+
+  template<typename _BIter, typename _OIter>
+    _OIter
+    reverse_copy(_BIter, _BIter, _OIter);
+
+  inline namespace _V2
+  {
+    template<typename _FIter>
+      _FIter
+      rotate(_FIter, _FIter, _FIter);
+  }
+
+  template<typename _FIter, typename _OIter>
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+# 552 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
+  template<typename _RAIter, typename _UGenerator>
+    void
+    shuffle(_RAIter, _RAIter, _UGenerator&&);
+
+
+  template<typename _RAIter>
+    void
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+# 581 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
+  template<typename _FIter1, typename _FIter2>
+    _FIter2
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+
+
+
+  template<typename _FIter>
+    _FIter
+    unique(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    unique(_FIter, _FIter, _BinaryPredicate);
+
+
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+
+
+
+
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Funct>
+    _Funct
+    for_each(_IIter, _IIter, _Funct);
+
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    partition(_BIter, _BIter, _Predicate);
+
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Generator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+
+     _Generator&&);
+
+
+
+
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+
+  template<typename _FIter, typename _Size, typename _Tp,
+    typename _BinaryPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+        _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _BinaryOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+
+}
+# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 1 3
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+      _Compare __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__comp(__first + __parent, __first + __child))
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    {
+      return std::__is_heap_until(__first, __n,
+   __gnu_cxx::__ops::__iter_less_iter()) == __n;
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    {
+      return std::__is_heap_until(__first, __n,
+ __gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n;
+    }
+
+  template<typename _RandomAccessIterator>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+    typename _Compare>
+    void
+    __push_heap(_RandomAccessIterator __first,
+  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
+  _Compare __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
+ {
+   *(__first + __holeIndex) = std::move(*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = std::move(__value);
+    }
+# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+
+
+
+                                                     ;
+                                                     ;
+                                                  ;
+
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value),
+         __gnu_cxx::__ops::__iter_less_val());
+    }
+# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+
+
+                                                     ;
+                                                                  ;
+                                                               ;
+
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value),
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Tp, typename _Compare>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (__comp(__first + __secondChild,
+       __first + (__secondChild - 1)))
+     __secondChild--;
+   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));
+
+   __holeIndex = __secondChild - 1;
+ }
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         std::move(__value),
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      _ValueType __value = std::move(*__result);
+      *__result = std::move(*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    std::move(__value), __comp);
+    }
+# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                         ;
+                                                     ;
+                                                     ;
+                                              ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+ }
+    }
+# 296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+
+
+
+                                                     ;
+                                                                  ;
+                                                         ;
+                                                           ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+      if (__last - __first < 2)
+ return;
+
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = std::move(*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, std::move(__value),
+        __comp);
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+# 351 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      std::__make_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+
+
+                                                     ;
+                                                                  ;
+
+      std::__make_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+# 412 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+                                              ;
+
+      std::__sort_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 439 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+
+
+                                                     ;
+                                                                  ;
+                                                           ;
+
+      std::__sort_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return __first +
+ std::__is_heap_until(__first, std::distance(__first, __last),
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 494 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+
+
+
+                                                     ;
+                                                                  ;
+
+      return __first
+ + std::__is_heap_until(__first, std::distance(__first, __last),
+          __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+# 530 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _Compare __comp)
+    { return std::is_heap_until(__first, __last, __comp) == __last; }
+
+
+
+}
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _T1, typename... _Args>
+    inline void
+    _Construct(_T1* __p, _Args&&... __args)
+    { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
+# 90 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3
+  template<typename _Tp>
+    inline void
+    _Destroy(_Tp* __pointer)
+    { __pointer->~_Tp(); }
+
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator __first, _ForwardIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     std::_Destroy(std::__addressof(*__first));
+ }
+    };
+
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+
+
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+      for (; __first != __last; ++__first)
+ __traits::destroy(__alloc, std::__addressof(*__first));
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+
+
+}
+# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len) noexcept
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+# 110 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p, std::nothrow); }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+
+
+
+    public:
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef pointer iterator;
+      typedef ptrdiff_t size_type;
+
+    protected:
+      size_type _M_original_len;
+      size_type _M_len;
+      pointer _M_buffer;
+
+    public:
+
+      size_type
+      size() const
+      { return _M_len; }
+
+
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+
+
+      iterator
+      begin()
+      { return _M_buffer; }
+
+
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+
+
+
+
+
+      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
+
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::return_temporary_buffer(_M_buffer);
+      }
+
+    private:
+
+      _Temporary_buffer(const _Temporary_buffer&);
+
+      void
+      operator=(const _Temporary_buffer&);
+    };
+
+
+  template<bool>
+    struct __uninitialized_construct_buf_dispatch
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer __first, _Pointer __last,
+       _ForwardIterator __seed)
+        {
+   if(__first == __last)
+     return;
+
+   _Pointer __cur = __first;
+   try
+     {
+       std::_Construct(std::__addressof(*__first),
+         std::move(*__seed));
+       _Pointer __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(std::__addressof(*__cur),
+    std::move(*__prev));
+       *__seed = std::move(*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
+    };
+# 229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
+  template<typename _Pointer, typename _ForwardIterator>
+    inline void
+    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
+      _ForwardIterator __seed)
+    {
+      typedef typename std::iterator_traits<_Pointer>::value_type
+ _ValueType;
+
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __seed);
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _M_original_len(std::distance(__first, __last)),
+      _M_len(0), _M_buffer(0)
+    {
+      try
+ {
+   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
+         value_type>(_M_original_len));
+   _M_buffer = __p.first;
+   _M_len = __p.second;
+   if (_M_buffer)
+     std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
+            __first);
+ }
+      catch(...)
+ {
+   std::return_temporary_buffer(_M_buffer);
+   _M_buffer = 0;
+   _M_len = 0;
+   throw;
+ }
+    }
+
+
+}
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 1 3
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+
+
+
+
+
+
+
+  enum float_denorm_style
+  {
+
+    denorm_indeterminate = -1,
+
+    denorm_absent = 0,
+
+    denorm_present = 1
+  };
+# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+  struct __numeric_limits_base
+  {
+
+
+    static constexpr bool is_specialized = false;
+
+
+
+
+    static constexpr int digits = 0;
+
+
+    static constexpr int digits10 = 0;
+
+
+
+
+    static constexpr int max_digits10 = 0;
+
+
+
+    static constexpr bool is_signed = false;
+
+
+    static constexpr bool is_integer = false;
+
+
+
+
+    static constexpr bool is_exact = false;
+
+
+
+    static constexpr int radix = 0;
+
+
+
+    static constexpr int min_exponent = 0;
+
+
+
+    static constexpr int min_exponent10 = 0;
+
+
+
+
+    static constexpr int max_exponent = 0;
+
+
+
+    static constexpr int max_exponent10 = 0;
+
+
+    static constexpr bool has_infinity = false;
+
+
+
+    static constexpr bool has_quiet_NaN = false;
+
+
+
+    static constexpr bool has_signaling_NaN = false;
+
+
+    static constexpr float_denorm_style has_denorm = denorm_absent;
+
+
+
+    static constexpr bool has_denorm_loss = false;
+
+
+
+    static constexpr bool is_iec559 = false;
+
+
+
+
+    static constexpr bool is_bounded = false;
+# 288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+    static constexpr bool is_modulo = false;
+
+
+    static constexpr bool traps = false;
+
+
+    static constexpr bool tinyness_before = false;
+
+
+
+
+    static constexpr float_round_style round_style =
+          round_toward_zero;
+  };
+# 314 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+
+
+      static constexpr _Tp
+      min() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      max() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      lowest() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      epsilon() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      round_error() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      infinity() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      quiet_NaN() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      signaling_NaN() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      denorm_min() noexcept { return _Tp(); }
+    };
+
+
+  template<typename _Tp>
+    struct numeric_limits<const _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<volatile _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<const volatile _Tp>
+    : public numeric_limits<_Tp> { };
+
+
+
+
+
+
+  template<>
+    struct numeric_limits<bool>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr bool
+      min() noexcept { return false; }
+
+      static constexpr bool
+      max() noexcept { return true; }
+
+
+      static constexpr bool
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = 1;
+      static constexpr int digits10 = 0;
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr bool
+      epsilon() noexcept { return false; }
+
+      static constexpr bool
+      round_error() noexcept { return false; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr bool
+      infinity() noexcept { return false; }
+
+      static constexpr bool
+      quiet_NaN() noexcept { return false; }
+
+      static constexpr bool
+      signaling_NaN() noexcept { return false; }
+
+      static constexpr bool
+      denorm_min() noexcept { return false; }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+
+
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char
+      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
+
+      static constexpr char
+      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
+
+
+      static constexpr char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = ((char)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char
+      epsilon() noexcept { return 0; }
+
+      static constexpr char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr
+      char infinity() noexcept { return char(); }
+
+      static constexpr char
+      quiet_NaN() noexcept { return char(); }
+
+      static constexpr char
+      signaling_NaN() noexcept { return char(); }
+
+      static constexpr char
+      denorm_min() noexcept { return static_cast<char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr signed char
+      min() noexcept { return -127 - 1; }
+
+      static constexpr signed char
+      max() noexcept { return 127; }
+
+
+      static constexpr signed char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr signed char
+      epsilon() noexcept { return 0; }
+
+      static constexpr signed char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr signed char
+      infinity() noexcept { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      quiet_NaN() noexcept { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      signaling_NaN() noexcept
+      { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      denorm_min() noexcept
+      { return static_cast<signed char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned char
+      min() noexcept { return 0; }
+
+      static constexpr unsigned char
+      max() noexcept { return 127 * 2U + 1; }
+
+
+      static constexpr unsigned char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned char
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned char
+      infinity() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      quiet_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      signaling_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      denorm_min() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr wchar_t
+      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
+
+      static constexpr wchar_t
+      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
+
+
+      static constexpr wchar_t
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr wchar_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr wchar_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr wchar_t
+      infinity() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      quiet_NaN() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      signaling_NaN() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      denorm_min() noexcept { return wchar_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+
+  template<>
+    struct numeric_limits<char16_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char16_t
+      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
+
+      static constexpr char16_t
+      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
+
+      static constexpr char16_t
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char16_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char16_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr char16_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char16_t
+      infinity() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      quiet_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      signaling_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      denorm_min() noexcept { return char16_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<char32_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char32_t
+      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
+
+      static constexpr char32_t
+      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
+
+      static constexpr char32_t
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char32_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char32_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr char32_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char32_t
+      infinity() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      quiet_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      signaling_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      denorm_min() noexcept { return char32_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+
+
+
+  template<>
+    struct numeric_limits<short>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr short
+      min() noexcept { return -32767 - 1; }
+
+      static constexpr short
+      max() noexcept { return 32767; }
+
+
+      static constexpr short
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr short
+      epsilon() noexcept { return 0; }
+
+      static constexpr short
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr short
+      infinity() noexcept { return short(); }
+
+      static constexpr short
+      quiet_NaN() noexcept { return short(); }
+
+      static constexpr short
+      signaling_NaN() noexcept { return short(); }
+
+      static constexpr short
+      denorm_min() noexcept { return short(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned short
+      min() noexcept { return 0; }
+
+      static constexpr unsigned short
+      max() noexcept { return 32767 * 2U + 1; }
+
+
+      static constexpr unsigned short
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned short
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned short
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned short
+      infinity() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      quiet_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      signaling_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      denorm_min() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<int>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr int
+      min() noexcept { return -2147483647 - 1; }
+
+      static constexpr int
+      max() noexcept { return 2147483647; }
+
+
+      static constexpr int
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr int
+      epsilon() noexcept { return 0; }
+
+      static constexpr int
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr int
+      infinity() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      quiet_NaN() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      signaling_NaN() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      denorm_min() noexcept { return static_cast<int>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned int
+      min() noexcept { return 0; }
+
+      static constexpr unsigned int
+      max() noexcept { return 2147483647 * 2U + 1; }
+
+
+      static constexpr unsigned int
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned int
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned int
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned int
+      infinity() noexcept { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      quiet_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      signaling_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      denorm_min() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long
+      min() noexcept { return -9223372036854775807L - 1; }
+
+      static constexpr long
+      max() noexcept { return 9223372036854775807L; }
+
+
+      static constexpr long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr long
+      epsilon() noexcept { return 0; }
+
+      static constexpr long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr long
+      infinity() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      quiet_NaN() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      signaling_NaN() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      denorm_min() noexcept { return static_cast<long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned long
+      min() noexcept { return 0; }
+
+      static constexpr unsigned long
+      max() noexcept { return 9223372036854775807L * 2UL + 1; }
+
+
+      static constexpr unsigned long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned long
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned long
+      infinity() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      denorm_min() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long long
+      min() noexcept { return -9223372036854775807LL - 1; }
+
+      static constexpr long long
+      max() noexcept { return 9223372036854775807LL; }
+
+
+      static constexpr long long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr long long
+      epsilon() noexcept { return 0; }
+
+      static constexpr long long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr long long
+      infinity() noexcept { return static_cast<long long>(0); }
+
+      static constexpr long long
+      quiet_NaN() noexcept { return static_cast<long long>(0); }
+
+      static constexpr long long
+      signaling_NaN() noexcept
+      { return static_cast<long long>(0); }
+
+      static constexpr long long
+      denorm_min() noexcept { return static_cast<long long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned long long
+      min() noexcept { return 0; }
+
+      static constexpr unsigned long long
+      max() noexcept { return 9223372036854775807LL * 2ULL + 1; }
+
+
+      static constexpr unsigned long long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned long long
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned long long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned long long
+      infinity() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      denorm_min() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+# 1592 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
+  template<>
+    struct numeric_limits<float>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr float
+      min() noexcept { return 1.17549435e-38F; }
+
+      static constexpr float
+      max() noexcept { return 3.40282347e+38F; }
+
+
+      static constexpr float
+      lowest() noexcept { return -3.40282347e+38F; }
+
+
+      static constexpr int digits = 24;
+      static constexpr int digits10 = 6;
+
+      static constexpr int max_digits10
+  = (2 + (24) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr float
+      epsilon() noexcept { return 1.19209290e-7F; }
+
+      static constexpr float
+      round_error() noexcept { return 0.5F; }
+
+      static constexpr int min_exponent = (-125);
+      static constexpr int min_exponent10 = (-37);
+      static constexpr int max_exponent = 128;
+      static constexpr int max_exponent10 = 38;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+       = false;
+
+      static constexpr float
+      infinity() noexcept { return __builtin_huge_valf(); }
+
+      static constexpr float
+      quiet_NaN() noexcept { return __builtin_nanf(""); }
+
+      static constexpr float
+      signaling_NaN() noexcept { return __builtin_nansf(""); }
+
+      static constexpr float
+      denorm_min() noexcept { return 1.40129846e-45F; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+
+
+
+
+
+
+  template<>
+    struct numeric_limits<double>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr double
+      min() noexcept { return 2.2250738585072014e-308; }
+
+      static constexpr double
+      max() noexcept { return 1.7976931348623157e+308; }
+
+
+      static constexpr double
+      lowest() noexcept { return -1.7976931348623157e+308; }
+
+
+      static constexpr int digits = 53;
+      static constexpr int digits10 = 15;
+
+      static constexpr int max_digits10
+  = (2 + (53) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr double
+      epsilon() noexcept { return 2.2204460492503131e-16; }
+
+      static constexpr double
+      round_error() noexcept { return 0.5; }
+
+      static constexpr int min_exponent = (-1021);
+      static constexpr int min_exponent10 = (-307);
+      static constexpr int max_exponent = 1024;
+      static constexpr int max_exponent10 = 308;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+        = false;
+
+      static constexpr double
+      infinity() noexcept { return __builtin_huge_val(); }
+
+      static constexpr double
+      quiet_NaN() noexcept { return __builtin_nan(""); }
+
+      static constexpr double
+      signaling_NaN() noexcept { return __builtin_nans(""); }
+
+      static constexpr double
+      denorm_min() noexcept { return 4.9406564584124654e-324; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+
+
+
+
+
+
+  template<>
+    struct numeric_limits<long double>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long double
+      min() noexcept { return 3.36210314311209350626e-4932L; }
+
+      static constexpr long double
+      max() noexcept { return 1.18973149535723176502e+4932L; }
+
+
+      static constexpr long double
+      lowest() noexcept { return -1.18973149535723176502e+4932L; }
+
+
+      static constexpr int digits = 64;
+      static constexpr int digits10 = 18;
+
+      static constexpr int max_digits10
+  = (2 + (64) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr long double
+      epsilon() noexcept { return 1.08420217248550443401e-19L; }
+
+      static constexpr long double
+      round_error() noexcept { return 0.5L; }
+
+      static constexpr int min_exponent = (-16381);
+      static constexpr int min_exponent10 = (-4931);
+      static constexpr int max_exponent = 16384;
+      static constexpr int max_exponent10 = 4932;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+ = false;
+
+      static constexpr long double
+      infinity() noexcept { return __builtin_huge_vall(); }
+
+      static constexpr long double
+      quiet_NaN() noexcept { return __builtin_nanl(""); }
+
+      static constexpr long double
+      signaling_NaN() noexcept { return __builtin_nansl(""); }
+
+      static constexpr long double
+      denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before =
+      false;
+      static constexpr float_round_style round_style =
+            round_to_nearest;
+    };
+
+
+
+
+
+
+}
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+
+
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+ return ((__x - 1) & __x) == 0;
+      };
+
+  }
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
+  template<typename _IntType = int>
+    class uniform_int_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "template argument not an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+      struct param_type
+      {
+ typedef uniform_int_distribution<_IntType> distribution_type;
+
+ explicit
+ param_type(_IntType __a = 0,
+     _IntType __b = std::numeric_limits<_IntType>::max())
+ : _M_a(__a), _M_b(__b)
+ {
+                                 ;
+ }
+
+ result_type
+ a() const
+ { return _M_a; }
+
+ result_type
+ b() const
+ { return _M_b; }
+
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+      private:
+ _IntType _M_a;
+ _IntType _M_b;
+      };
+
+    public:
+
+
+
+      explicit
+      uniform_int_distribution(_IntType __a = 0,
+      _IntType __b = std::numeric_limits<_IntType>::max())
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      uniform_int_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+
+
+
+
+
+      void
+      reset() { }
+
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+
+
+
+      param_type
+      param() const
+      { return _M_param; }
+
+
+
+
+
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+
+
+
+      result_type
+      min() const
+      { return this->a(); }
+
+
+
+
+      result_type
+      max() const
+      { return this->b(); }
+
+
+
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+   const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename uniform_int_distribution<_IntType>::result_type
+      uniform_int_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+
+ __uctype __ret;
+
+ if (__urngrange > __urange)
+   {
+
+     const __uctype __uerange = __urange + 1;
+     const __uctype __scaling = __urngrange / __uerange;
+     const __uctype __past = __uerange * __scaling;
+     do
+       __ret = __uctype(__urng()) - __urngmin;
+     while (__ret >= __past);
+     __ret /= __scaling;
+   }
+ else if (__urngrange < __urange)
+   {
+# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
+     __uctype __tmp;
+     do
+       {
+  const __uctype __uerngrange = __urngrange + 1;
+  __tmp = (__uerngrange * operator()
+    (__urng, param_type(0, __urange / __uerngrange)));
+  __ret = __tmp + (__uctype(__urng()) - __urngmin);
+       }
+     while (__ret > __urange || __ret < __tmp);
+   }
+ else
+   __ret = __uctype(__urng()) - __urngmin;
+
+ return __ret + __param.a();
+      }
+
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      uniform_int_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+
+ __uctype __ret;
+
+ if (__urngrange > __urange)
+   {
+     if (__detail::_Power_of_2(__urngrange + 1)
+  && __detail::_Power_of_2(__urange + 1))
+       {
+  while (__f != __t)
+    {
+      __ret = __uctype(__urng()) - __urngmin;
+      *__f++ = (__ret & __urange) + __param.a();
+    }
+       }
+     else
+       {
+
+  const __uctype __uerange = __urange + 1;
+  const __uctype __scaling = __urngrange / __uerange;
+  const __uctype __past = __uerange * __scaling;
+  while (__f != __t)
+    {
+      do
+        __ret = __uctype(__urng()) - __urngmin;
+      while (__ret >= __past);
+      *__f++ = __ret / __scaling + __param.a();
+    }
+       }
+   }
+ else if (__urngrange < __urange)
+   {
+# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
+     __uctype __tmp;
+     while (__f != __t)
+       {
+  do
+    {
+      const __uctype __uerngrange = __urngrange + 1;
+      __tmp = (__uerngrange * operator()
+        (__urng, param_type(0, __urange / __uerngrange)));
+      __ret = __tmp + (__uctype(__urng()) - __urngmin);
+    }
+  while (__ret > __urange || __ret < __tmp);
+  *__f++ = __ret;
+       }
+   }
+ else
+   while (__f != __t)
+     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
+      }
+
+
+}
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
+      _Iterator __c, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ {
+   if (__comp(__b, __c))
+     std::iter_swap(__result, __b);
+   else if (__comp(__a, __c))
+     std::iter_swap(__result, __c);
+   else
+     std::iter_swap(__result, __a);
+ }
+      else if (__comp(__a, __c))
+ std::iter_swap(__result, __a);
+      else if (__comp(__b, __c))
+ std::iter_swap(__result, __c);
+      else
+ std::iter_swap(__result, __b);
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !__pred(__first))
+ ++__first;
+      return __first;
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ }
+
+      switch (__last - __first)
+ {
+ case 3:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 2:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 1:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+
+  template<typename _Iterator, typename _Predicate>
+    inline _Iterator
+    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
+    {
+      return __find_if(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if_not(_InputIterator __first, _InputIterator __last,
+    _Predicate __pred)
+    {
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__negate(__pred),
+       std::__iterator_category(__first));
+    }
+
+
+
+
+  template<typename _InputIterator, typename _Predicate, typename _Distance>
+    _InputIterator
+    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
+    {
+      for (; __len; --__len, ++__first)
+ if (!__pred(__first))
+   break;
+      return __first;
+    }
+# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __predicate)
+    {
+
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   __first1 =
+     std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+   if (__first1 == __last1)
+     return __last1;
+
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+
+   while (__predicate(__current, __p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::forward_iterator_tag)
+    {
+      __first = std::__find_if(__first, __last, __unary_pred);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && __unary_pred(__i))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::__find_if(++__i, __last, __unary_pred);
+ }
+      return __last;
+    }
+
+
+
+
+
+  template<typename _RandomAccessIter, typename _Integer,
+    typename _UnaryPredicate>
+    _RandomAccessIter
+    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      _DistanceType __remainder = __count;
+
+      while (__remainder <= __tailSize)
+ {
+   __first += __remainder;
+   __tailSize -= __remainder;
+
+
+   _RandomAccessIter __backTrack = __first;
+   while (__unary_pred(--__backTrack))
+     {
+       if (--__remainder == 0)
+  return (__first - __count);
+     }
+   __remainder = __count + 1 - (__first - __backTrack);
+ }
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count,
+        _UnaryPredicate __unary_pred)
+    {
+      if (__count <= 0)
+ return __first;
+
+      if (__count == 1)
+ return std::__find_if(__first, __last, __unary_pred);
+
+      return std::__search_n_aux(__first, __last, __count, __unary_pred,
+     std::__iterator_category(__first));
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+ return __last1;
+
+      _ForwardIterator1 __result = __last1;
+      while (1)
+ {
+   _ForwardIterator1 __new_result
+     = std::__search(__first1, __last1, __first2, __last2, __comp);
+   if (__new_result == __last1)
+     return __result;
+   else
+     {
+       __result = __new_result;
+       __first1 = __new_result;
+       ++__first1;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BinaryPredicate>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+
+
+
+
+
+
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
+           _RevIterator2(__last2), __rlast2,
+           __comp);
+
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 471 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 506 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if_not(__first, __last, __pred); }
+# 523 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if(__first, __last, __pred); }
+# 541 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return !std::none_of(__first, __last, __pred); }
+# 556 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if_not(_InputIterator __first, _InputIterator __last,
+  _Predicate __pred)
+    {
+
+
+
+
+                                                     ;
+      return std::__find_if_not(__first, __last,
+    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 580 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    is_partitioned(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+      __first = std::find_if_not(__first, __last, __pred);
+      return std::none_of(__first, __last, __pred);
+    }
+# 598 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    partition_point(_ForwardIterator __first, _ForwardIterator __last,
+      _Predicate __pred)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__pred(*__middle))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    __remove_copy_if(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _Predicate __pred)
+    {
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+# 665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+ __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 697 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    inline _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    _OutputIterator
+    __copy_n(_InputIterator __first, _Size __n,
+      _OutputIterator __result, input_iterator_tag)
+    {
+      if (__n > 0)
+ {
+   while (true)
+     {
+       *__result = *__first;
+       ++__result;
+       if (--__n > 0)
+  ++__first;
+       else
+  break;
+     }
+ }
+      return __result;
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _OutputIterator>
+    inline _OutputIterator
+    __copy_n(_RandomAccessIterator __first, _Size __n,
+      _OutputIterator __result, random_access_iterator_tag)
+    { return std::copy(__first, __first + __n, __result); }
+# 794 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    inline _OutputIterator
+    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+
+
+
+
+
+      return std::__copy_n(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+# 822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator1,
+    typename _OutputIterator2, typename _Predicate>
+    pair<_OutputIterator1, _OutputIterator2>
+    partition_copy(_InputIterator __first, _InputIterator __last,
+     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
+     _Predicate __pred)
+    {
+# 837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                     ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__out_true = *__first;
+     ++__out_true;
+   }
+ else
+   {
+     *__out_false = *__first;
+     ++__out_false;
+   }
+
+      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+    }
+
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred)
+    {
+      __first = std::__find_if(__first, __last, __pred);
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = std::move(*__first);
+     ++__result;
+   }
+      return __result;
+    }
+# 891 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__remove_if(__first, __last,
+  __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 924 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__remove_if(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+ {
+   if (__binary_pred(__first, __next))
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __unique(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+
+      __first = std::__adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+ return __last;
+
+
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!__binary_pred(__dest, __first))
+   *++__dest = std::move(*__first);
+      return ++__dest;
+    }
+# 990 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1020 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    forward_iterator_tag, output_iterator_tag)
+    {
+
+
+
+
+
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!__binary_pred(__first, __next))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, output_iterator_tag)
+    {
+
+
+
+
+
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
+ __rebound_pred
+ = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
+      *__result = __value;
+      while (++__first != __last)
+ if (!__rebound_pred(__first, __value))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, forward_iterator_tag)
+    {
+
+
+
+
+      *__result = *__first;
+      while (++__first != __last)
+ if (!__binary_pred(__result, __first))
+   *++__result = *__first;
+      return ++__result;
+    }
+
+
+
+
+
+
+  template<typename _BidirectionalIterator>
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      while (true)
+ if (__first == __last || __first == --__last)
+   return;
+ else
+   {
+     std::iter_swap(__first, __last);
+     ++__first;
+   }
+    }
+
+
+
+
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       random_access_iterator_tag)
+    {
+      if (__first == __last)
+ return;
+      --__last;
+      while (__first < __last)
+ {
+   std::iter_swap(__first, __last);
+   ++__first;
+   --__last;
+ }
+    }
+# 1175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+
+
+
+                                                     ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+# 1202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+
+
+
+
+
+                                                     ;
+
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+
+
+
+
+
+  template<typename _EuclideanRingElement>
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+
+  inline namespace _V2
+  {
+
+
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+
+      _ForwardIterator __ret = __first;
+
+      __first2 = __middle;
+
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+      return __ret;
+    }
+
+
+  template<typename _BidirectionalIterator>
+    _BidirectionalIterator
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+
+
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+
+      if (__first == __middle)
+ {
+   std::__reverse(__middle, __last, bidirectional_iterator_tag());
+   return __last;
+ }
+      else
+ {
+   std::__reverse(__first, __middle, bidirectional_iterator_tag());
+   return __first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+    _RandomAccessIterator
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+
+
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return __middle;
+ }
+
+      _RandomAccessIterator __p = __first;
+      _RandomAccessIterator __ret = __first + (__last - __middle);
+
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*__p);
+    std::move(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*(__p + __n - 1));
+    std::move_backward(__p, __p + __n - 1, __p + __n);
+    *__p = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+     }
+ }
+    }
+# 1429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+
+
+
+                                                       ;
+                                                      ;
+
+      return std::__rotate(__first, __middle, __last,
+      std::__iterator_category(__first));
+    }
+
+  }
+# 1466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _OutputIterator>
+    inline _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+  _ForwardIterator __last, _OutputIterator __result)
+    {
+
+
+
+
+                                                       ;
+                                                      ;
+
+      return std::copy(__first, __middle,
+         std::copy(__middle, __last, __result));
+    }
+
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+ return __first;
+
+      while (__pred(*__first))
+ if (++__first == __last)
+   return __first;
+
+      _ForwardIterator __next = __first;
+
+      while (++__next != __last)
+ if (__pred(*__next))
+   {
+     std::iter_swap(__first, __next);
+     ++__first;
+   }
+
+      return __first;
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+  _Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+ {
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (__pred(*__first))
+       ++__first;
+     else
+       break;
+   --__last;
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (!bool(__pred(*__last)))
+       --__last;
+     else
+       break;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+# 1543 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+    typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred, _Distance __len,
+    _Pointer __buffer,
+    _Distance __buffer_size)
+    {
+      if (__len == 1)
+ return __first;
+
+      if (__len <= __buffer_size)
+ {
+   _ForwardIterator __result1 = __first;
+   _Pointer __result2 = __buffer;
+
+
+
+
+   *__result2 = std::move(*__first);
+   ++__result2;
+   ++__first;
+   for (; __first != __last; ++__first)
+     if (__pred(__first))
+       {
+  *__result1 = std::move(*__first);
+  ++__result1;
+       }
+     else
+       {
+  *__result2 = std::move(*__first);
+  ++__result2;
+       }
+
+   std::move(__buffer, __result2, __result1);
+   return __result1;
+ }
+
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __left_split =
+ std::__stable_partition_adaptive(__first, __middle, __pred,
+      __len / 2, __buffer,
+      __buffer_size);
+
+
+
+      _Distance __right_len = __len - __len / 2;
+      _ForwardIterator __right_split =
+ std::__find_if_not_n(__middle, __right_len, __pred);
+
+      if (__right_len)
+ __right_split =
+   std::__stable_partition_adaptive(__right_split, __last, __pred,
+        __right_len,
+        __buffer, __buffer_size);
+
+      std::rotate(__left_split, __middle, __right_split);
+      std::advance(__left_split, std::distance(__middle, __right_split));
+      return __left_split;
+    }
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+         _Predicate __pred)
+    {
+      __first = std::__find_if_not(__first, __last, __pred);
+
+      if (__first == __last)
+ return __first;
+
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
+      return
+ std::__stable_partition_adaptive(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()),
+      __buf.begin(),
+      _DistanceType(__buf.size()));
+    }
+# 1646 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__stable_partition(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::__make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (__comp(__i, __first))
+   std::__pop_heap(__first, __middle, __i, __comp);
+    }
+
+
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+    _RandomAccessIterator
+    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
+   _RandomAccessIterator __result_first,
+   _RandomAccessIterator __result_last,
+   _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
+      typedef typename _RItTraits::difference_type _DistanceType;
+
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while (__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+
+      std::__make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(__first, __result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first), __comp);
+   ++__first;
+ }
+      std::__sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+# 1732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+# 1752 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                     ;
+                                                     ;
+                                                                   ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+          __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 1781 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+# 1806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                     ;
+                                                                  ;
+                                                                   ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+         _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = std::move(*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, __next))
+ {
+   *__last = std::move(*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = std::move(__val);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (__comp(__i, __first))
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = std::move(*__i);
+       std::move_backward(__first, __i, __i + 1);
+       *__first = std::move(__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+
+
+
+
+  enum { _S_threshold = 16 };
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+       __comp);
+ }
+      else
+ std::__insertion_sort(__first, __last, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     _RandomAccessIterator __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, __last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
+      __comp);
+      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __partial_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __middle,
+     _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::__sort_heap(__first, __middle, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::__partial_sort(__first, __last, __last, __comp);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+   __last = __cut;
+ }
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2,
+    __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+# 2018 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+
+
+
+
+                    ;
+
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__val, __middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+# 2072 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+
+
+
+                                                                  ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+
+
+
+
+                    ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp,
+    typename _CompareItTp, typename _CompareTpIt>
+    pair<_ForwardIterator, _ForwardIterator>
+    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val,
+    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp_it_val(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp_val_it(__val, __middle))
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left
+  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
+       std::advance(__first, __len);
+       _ForwardIterator __right
+  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+# 2173 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+
+
+
+
+
+                                                                  ;
+                                                                  ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val(),
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+
+
+
+
+
+
+                    ;
+
+                    ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp),
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+# 2242 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val)
+    {
+
+
+
+
+                                                                  ;
+                                                                  ;
+
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+# 2275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+
+
+
+
+
+                    ;
+
+                    ;
+
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_comp_val(__comp));
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      if (__first1 != __last1)
+ std::move(__first1, __last1, __result);
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3, typename _Compare>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result,
+       _Compare __comp)
+    {
+      if (__first1 == __last1)
+ {
+   std::move_backward(__first2, __last2, __result);
+   return;
+ }
+      else if (__first2 == __last2)
+ return;
+
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (__comp(__last2, __last1))
+     {
+       *--__result = std::move(*__last1);
+       if (__first1 == __last1)
+  {
+    std::move_backward(__first2, ++__last2, __result);
+    return;
+  }
+       --__last1;
+     }
+   else
+     {
+       *--__result = std::move(*__last2);
+       if (__first2 == __last2)
+  return;
+       --__last2;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+        _BidirectionalIterator1 __middle,
+        _BidirectionalIterator1 __last,
+        _Distance __len1, _Distance __len2,
+        _BidirectionalIterator2 __buffer,
+        _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+ {
+   if (__len2)
+     {
+       __buffer_end = std::move(__middle, __last, __buffer);
+       std::move_backward(__first, __middle, __last);
+       return std::move(__buffer, __buffer_end, __first);
+     }
+   else
+     return __first;
+ }
+      else if (__len1 <= __buffer_size)
+ {
+   if (__len1)
+     {
+       __buffer_end = std::move(__first, __middle, __buffer);
+       std::move(__middle, __last, __first);
+       return std::move_backward(__buffer, __buffer_end, __last);
+     }
+   else
+     return __last;
+ }
+      else
+ {
+   std::rotate(__first, __middle, __last);
+   std::advance(__first, std::distance(__middle, __last));
+   return __first;
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+       _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size,
+       _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
+   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+         __first, __comp);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
+   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+           __buffer_end, __last, __comp);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut
+  = std::__lower_bound(__middle, __last, *__first_cut,
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut
+  = std::__upper_bound(__first, __middle, *__second_cut,
+         __gnu_cxx::__ops::__val_comp_iter(__comp));
+       __len11 = std::distance(__first, __first_cut);
+     }
+
+   _BidirectionalIterator __new_middle
+     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+         __len1 - __len11, __len22, __buffer,
+         __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2,
+      _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+
+      if (__len1 + __len2 == 2)
+ {
+   if (__comp(__middle, __first))
+     std::iter_swap(__first, __middle);
+   return;
+ }
+
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut
+     = std::__lower_bound(__middle, __last, *__first_cut,
+     __gnu_cxx::__ops::__iter_comp_val(__comp));
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut
+     = std::__upper_bound(__first, __middle, *__second_cut,
+     __gnu_cxx::__ops::__val_comp_iter(__comp));
+   __len11 = std::distance(__first, __first_cut);
+ }
+
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    __inplace_merge(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+   _DistanceType;
+
+      if (__first == __middle || __middle == __last)
+ return;
+
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+
+      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer
+   (__first, __middle, __last, __len1, __len2, __comp);
+      else
+ std::__merge_adaptive
+   (__first, __middle, __last, __len1, __len2, __buf.begin(),
+    _DistanceType(__buf.size()), __comp);
+    }
+# 2569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+
+
+
+
+
+                                                  ;
+                                                 ;
+                                                     ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2610 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+
+
+
+
+
+
+                                                               ;
+                                                              ;
+                                                                  ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator __first1, _InputIterator __last1,
+   _InputIterator __first2, _InputIterator __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::move(__first2, __last2, std::move(__first1, __last1, __result));
+
+
+    }
+
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result, _Distance __step_size,
+        _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+
+      while (__last - __first >= __two_step)
+ {
+   __result = std::__move_merge(__first, __first + __step_size,
+           __first + __step_size,
+           __first + __two_step,
+           __result, __comp);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+
+      std::__move_merge(__first, __first + __step_size,
+   __first + __step_size, __last, __result, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size, __comp);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+
+  enum { _S_chunk_size = 7 };
+
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+        _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer,
+     __step_size, __comp);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first,
+     __step_size, __comp);
+   __step_size *= 2;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Pointer __buffer, _Distance __buffer_size,
+      _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle, __buffer,
+          __buffer_size, __comp);
+   std::__stable_sort_adaptive(__middle, __last, __buffer,
+          __buffer_size, __comp);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size,
+       __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last, __comp);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle,
+      __comp);
+    }
+# 2782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first2, __first1))
+   return false;
+ else if (__comp(__first1, __first2))
+   ++__first1;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+
+      return __first2 == __last2;
+    }
+# 2821 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+# 2835 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2865 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+# 2881 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 2900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __next_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__i, __ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(__i, --__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 2949 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __prev_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__ii, __i))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(--__j, __i))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 3049 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__prev_permutation(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__prev_permutation(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    _OutputIterator
+    __replace_copy_if(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+      for (; __first != __last; ++__first, (void)++__result)
+ if (__pred(__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+# 3131 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_equals_val(__old_value),
+           __new_value);
+    }
+# 3165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    inline _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+    __gnu_cxx::__ops::__pred_iter(__pred),
+           __new_value);
+    }
+
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (__pred(__first))
+   ++__n;
+      return __n;
+    }
+# 3204 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+# 3218 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    { return std::is_sorted_until(__first, __last, __comp) == __last; }
+
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+        _Compare __comp)
+    {
+      if (__first == __last)
+ return __last;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, (void)++__next)
+ if (__comp(__next, __first))
+   return __next;
+      return __next;
+    }
+# 3247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3271 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+      _Compare __comp)
+    {
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 3296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _Tp>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b)
+    {
+
+
+
+      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+# 3317 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    pair<_ForwardIterator, _ForwardIterator>
+    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    {
+      _ForwardIterator __next = __first;
+      if (__first == __last
+   || ++__next == __last)
+ return std::make_pair(__first, __first);
+
+      _ForwardIterator __min{}, __max{};
+      if (__comp(__next, __first))
+ {
+   __min = __next;
+   __max = __first;
+ }
+      else
+ {
+   __min = __first;
+   __max = __next;
+ }
+
+      __first = __next;
+      ++__first;
+
+      while (__first != __last)
+ {
+   __next = __first;
+   if (++__next == __last)
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       else if (!__comp(__first, __max))
+  __max = __first;
+       break;
+     }
+
+   if (__comp(__next, __first))
+     {
+       if (__comp(__next, __min))
+  __min = __next;
+       if (!__comp(__first, __max))
+  __max = __first;
+     }
+   else
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       if (!__comp(__next, __max))
+  __max = __next;
+     }
+
+   __first = __next;
+   ++__first;
+ }
+
+      return std::make_pair(__min, __max);
+    }
+# 3397 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+     _Compare __comp)
+    {
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l)
+    { return *std::min_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::min_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l)
+    { return *std::max_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::max_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end());
+      return std::make_pair(*__p.first, *__p.second);
+    }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l, _Compare __comp)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end(), __comp);
+      return std::make_pair(*__p.first, *__p.second);
+    }
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+
+      if (__first1 == __last1)
+ return true;
+
+
+
+      _ForwardIterator2 __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches
+     = std::__count_if(__first2, __last2,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches ||
+       std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 3537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2)
+    {
+
+
+
+
+
+
+                                                       ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3568 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+
+
+
+
+
+                                                       ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+       _BinaryPredicate __pred)
+    {
+      using _Cat1
+ = typename iterator_traits<_ForwardIterator1>::iterator_category;
+      using _Cat2
+ = typename iterator_traits<_ForwardIterator2>::iterator_category;
+      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
+      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
+      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
+      if (__ra_iters)
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+ }
+
+
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+
+      if (__ra_iters)
+ {
+   if (__first1 == __last1)
+     return true;
+ }
+      else
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 == 0 && __d2 == 0)
+     return true;
+   if (__d1 != __d2)
+     return false;
+ }
+
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches = std::__count_if(__first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches
+       || std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 3661 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+                                                       ;
+                                                       ;
+
+      return
+ std::__is_permutation(__first1, __last1, __first2, __last2,
+         __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+     _BinaryPredicate __pred)
+    {
+                                                       ;
+                                                       ;
+
+      return std::__is_permutation(__first1, __last1, __first2, __last2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+# 3716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator,
+    typename _UniformRandomNumberGenerator>
+    void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _UniformRandomNumberGenerator&& __g)
+    {
+
+
+
+                                                     ;
+
+      if (__first == __last)
+ return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
+      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
+      typedef typename __distr_type::param_type __p_type;
+      __distr_type __d;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
+    }
+# 3761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Function>
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+
+
+                                                     ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return std::move(__f);
+    }
+# 3782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+
+
+
+
+                                                     ;
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 3806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 3837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+# 3877 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+# 3909 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__adjacent_find(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__adjacent_find(__first, __last,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+# 3959 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 3982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 4022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 4061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                       ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
+    }
+# 4096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__search_n(__first, __last, __count,
+        __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 4129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+    typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+
+
+
+
+                                                     ;
+
+      return std::__search_n(__first, __last, __count,
+  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
+    }
+# 4163 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+
+
+
+
+
+                                                     ;
+
+      for (; __first != __last; ++__first, (void)++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+# 4200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+
+
+
+
+
+
+                                                       ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+# 4233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+
+
+
+
+
+
+                                                     ;
+
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+# 4265 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+
+
+
+
+
+
+
+                                                     ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+# 4297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+
+
+
+
+                                                     ;
+
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+# 4328 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+
+
+
+
+
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __gen();
+      return __first;
+    }
+# 4364 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+
+
+
+
+
+
+                                                     ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    __gnu_cxx::__ops::__iter_equal_to_iter(),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4404 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+
+
+
+
+                                                     ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+                                                     ;
+
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   {
+
+     _RandomAccessIterator __j = __first
+     + std::rand() % ((__i - __first) + 1);
+     if (__i != __j)
+       std::iter_swap(__i, __j);
+   }
+    }
+# 4472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+
+     _RandomNumberGenerator&& __rand)
+
+
+
+    {
+
+
+
+                                                     ;
+
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+   if (__i != __j)
+     std::iter_swap(__i, __j);
+ }
+    }
+# 4512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+
+
+
+
+                                                     ;
+
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+# 4545 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                       ;
+                                                      ;
+                                                     ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4583 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+
+
+
+
+
+
+                                                       ;
+                                                      ;
+                                                                  ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4619 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                    ;
+                                                   ;
+                                                     ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+
+
+
+
+
+
+                                                    ;
+                                                   ;
+                                                                  ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4695 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4725 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 4786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+# 4803 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__merge(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4836 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+# 4853 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__merge(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+# 4900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+
+
+
+
+                                                     ;
+                                                     ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+  _InputIterator2 __first2, _InputIterator2 __last2,
+  _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first1, __first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5002 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+# 5022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5051 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+# 5071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+         _InputIterator2 __first2, _InputIterator2 __last2,
+         _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   ++__first1;
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+# 5121 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+# 5139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__set_intersection(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+# 5187 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__set_intersection(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+# 5241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+# 5259 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5291 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+# 5309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_symmetric_difference(_InputIterator1 __first1,
+          _InputIterator1 __last1,
+          _InputIterator2 __first2,
+          _InputIterator2 __last2,
+          _OutputIterator __result,
+          _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+# 5389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                ;
+                                                                ;
+                                                        ;
+                                                        ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+     __first2, __last2, __result,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5419 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+# 5440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+                                                                             ;
+                                                                             ;
+                                                                     ;
+                                                                     ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __min_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__first, __result))
+   __result = __first;
+      return __result;
+    }
+# 5472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    _ForwardIterator
+    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __max_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__result, __first))
+   __result = __first;
+      return __result;
+    }
+# 5536 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+
+
+
+                                                     ;
+                                                     ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5561 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+
+
+
+
+                                                     ;
+                                                                  ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+}
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+
+      static constexpr _Tp&
+      _S_ref(const _Type& __t, std::size_t __n) noexcept
+      { return const_cast<_Tp&>(__t[__n]); }
+
+      static constexpr _Tp*
+      _S_ptr(const _Type& __t) noexcept
+      { return const_cast<_Tp*>(__t); }
+    };
+
+ template<typename _Tp>
+   struct __array_traits<_Tp, 0>
+   {
+     struct _Type { };
+
+     static constexpr _Tp&
+     _S_ref(const _Type&, std::size_t) noexcept
+     { return *static_cast<_Tp*>(nullptr); }
+
+     static constexpr _Tp*
+     _S_ptr(const _Type&) noexcept
+     { return nullptr; }
+   };
+# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef value_type* iterator;
+      typedef const value_type* const_iterator;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+
+      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type _M_elems;
+
+
+
+
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(__is_nothrow_swappable<_Tp>::value)
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+
+      iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+      constexpr size_type
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type
+      max_size() const noexcept { return _Nm; }
+
+      constexpr bool
+      empty() const noexcept { return size() == 0; }
+
+
+      reference
+      operator[](size_type __n) noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      reference
+      at(size_type __n)
+      {
+ if (__n >= _Nm)
+   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
+
+     __n, _Nm);
+ return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+
+
+ return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
+
+        __n, _Nm),
+      _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference
+      front() noexcept
+      { return *begin(); }
+
+      constexpr const_reference
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+
+      reference
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      constexpr const_reference
+      back() const noexcept
+      {
+ return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+             : _AT_Type::_S_ref(_M_elems, 0);
+      }
+
+      pointer
+      data() noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+
+      const_pointer
+      data() const noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+    };
+
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    {
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+       __b.begin(), __b.end());
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  template<typename _Tp>
+    class tuple_size;
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<std::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+
+  template<std::size_t _Int, typename _Tp>
+    class tuple_element;
+
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, std::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
+    { };
+
+
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
+# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
+namespace mozilla {
+
+
+
+
+template<class T, class U>
+inline constexpr T
+narrow_cast(U&& u)
+{
+  return static_cast<T>(mozilla::Forward<U>(u));
+}
+# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
+constexpr const size_t dynamic_extent = mozilla::MaxValue<size_t>::value;
+
+template<class ElementType, size_t Extent = dynamic_extent>
+class Span;
+
+
+namespace span_details {
+
+inline size_t strlen16(const char16_t* aZeroTerminated) {
+  size_t len = 0;
+  while (*(aZeroTerminated++)) {
+    len++;
+  }
+  return len;
+}
+
+
+template<class T>
+using remove_cv_t = typename mozilla::RemoveCV<T>::Type;
+template<class T>
+using remove_const_t = typename mozilla::RemoveConst<T>::Type;
+template<bool B, class T, class F>
+using conditional_t = typename mozilla::Conditional<B, T, F>::Type;
+template<class T>
+using add_pointer_t = typename mozilla::AddPointer<T>::Type;
+template<bool B, class T = void>
+using enable_if_t = typename mozilla::EnableIf<B, T>::Type;
+
+template<class T>
+struct is_span_oracle : mozilla::FalseType
+{
+};
+
+template<class ElementType, size_t Extent>
+struct is_span_oracle<mozilla::Span<ElementType, Extent>> : mozilla::TrueType
+{
+};
+
+template<class T>
+struct is_span : public is_span_oracle<remove_cv_t<T>>
+{
+};
+
+template<class T>
+struct is_std_array_oracle : mozilla::FalseType
+{
+};
+
+template<class ElementType, size_t Extent>
+struct is_std_array_oracle<std::array<ElementType, Extent>> : mozilla::TrueType
+{
+};
+
+template<class T>
+struct is_std_array : public is_std_array_oracle<remove_cv_t<T>>
+{
+};
+
+template<size_t From, size_t To>
+struct is_allowed_extent_conversion
+  : public mozilla::IntegralConstant<bool,
+                                  From == To ||
+                                    From == mozilla::dynamic_extent ||
+                                    To == mozilla::dynamic_extent>
+{
+};
+
+template<class From, class To>
+struct is_allowed_element_type_conversion
+  : public mozilla::IntegralConstant<bool, mozilla::IsConvertible<From (*)[], To (*)[]>::value>
+{
+};
+
+template<class Span, bool IsConst>
+class span_iterator
+{
+  using element_type_ = typename Span::element_type;
+
+public:
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = remove_const_t<element_type_>;
+  using difference_type = typename Span::index_type;
+
+  using reference = conditional_t<IsConst, const element_type_, element_type_>&;
+  using pointer = add_pointer_t<reference>;
+
+  constexpr span_iterator() : span_iterator(nullptr, 0) {}
+
+                               span_iterator(const Span* span,
+                                             typename Span::index_type index)
+    : span_(span)
+    , index_(index)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span == nullptr || (index_ >= 0 && index <= span_->Length()))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span == nullptr || (index_ >= 0 && index <= span_->Length())))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span == nullptr || (index_ >= 0 && index <= span_->Length())" ")"); do { *((volatile int*) __null) = 176; ::abort(); } while (0); } } while (0);
+
+  }
+
+  friend class span_iterator<Span, true>;
+  constexpr span_iterator(const span_iterator<Span, false>& other)
+    : span_iterator(other.span_, other.index_)
+  {
+  }
+
+                                          span_iterator<Span, IsConst>&
+  operator=(const span_iterator<Span, IsConst>&) = default;
+
+                         reference operator*() const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 190; ::abort(); } while (0); } } while (0);
+    return (*span_)[index_];
+  }
+
+                         pointer operator->() const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 196; ::abort(); } while (0); } } while (0);
+    return &((*span_)[index_]);
+  }
+
+                               span_iterator& operator++()
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && index_ >= 0 && index_ < span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ >= 0 && index_ < span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ >= 0 && index_ < span_->Length()" ")"); do { *((volatile int*) __null) = 202; ::abort(); } while (0); } } while (0);
+    ++index_;
+    return *this;
+  }
+
+                               span_iterator operator++(int)
+  {
+    auto ret = *this;
+    ++(*this);
+    return ret;
+  }
+
+                               span_iterator& operator--()
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && index_ > 0 && index_ <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ > 0 && index_ <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ > 0 && index_ <= span_->Length()" ")"); do { *((volatile int*) __null) = 216; ::abort(); } while (0); } } while (0);
+    --index_;
+    return *this;
+  }
+
+                               span_iterator operator--(int)
+  {
+    auto ret = *this;
+    --(*this);
+    return ret;
+  }
+
+                                     span_iterator
+  operator+(difference_type n) const
+  {
+    auto ret = *this;
+    return ret += n;
+  }
+
+                         span_iterator& operator+=(difference_type n)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()" ")"); do { *((volatile int*) __null) = 238; ::abort(); } while (0); } } while (0);
+
+    index_ += n;
+    return *this;
+  }
+
+                                     span_iterator
+  operator-(difference_type n) const
+  {
+    auto ret = *this;
+    return ret -= n;
+  }
+
+                               span_iterator& operator-=(difference_type n)
+
+  {
+    return *this += -n;
+  }
+
+                         difference_type
+  operator-(const span_iterator& rhs) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ == rhs.span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 259; ::abort(); } while (0); } } while (0);
+    return index_ - rhs.index_;
+  }
+
+  constexpr reference operator[](difference_type n) const
+  {
+    return *(*this + n);
+  }
+
+  constexpr friend bool operator==(const span_iterator& lhs,
+                                   const span_iterator& rhs)
+  {
+    return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
+  }
+
+  constexpr friend bool operator!=(const span_iterator& lhs,
+                                   const span_iterator& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+                         friend bool operator<(const span_iterator& lhs,
+                                               const span_iterator& rhs)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(lhs.span_ == rhs.span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(lhs.span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "lhs.span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 283; ::abort(); } while (0); } } while (0);
+    return lhs.index_ < rhs.index_;
+  }
+
+  constexpr friend bool operator<=(const span_iterator& lhs,
+                                   const span_iterator& rhs)
+  {
+    return !(rhs < lhs);
+  }
+
+  constexpr friend bool operator>(const span_iterator& lhs,
+                                  const span_iterator& rhs)
+  {
+    return rhs < lhs;
+  }
+
+  constexpr friend bool operator>=(const span_iterator& lhs,
+                                   const span_iterator& rhs)
+  {
+    return !(rhs > lhs);
+  }
+
+  void swap(span_iterator& rhs)
+  {
+    std::swap(index_, rhs.index_);
+    std::swap(span_, rhs.span_);
+  }
+
+protected:
+  const Span* span_;
+  size_t index_;
+};
+
+template<class Span, bool IsConst>
+inline constexpr span_iterator<Span, IsConst>
+operator+(typename span_iterator<Span, IsConst>::difference_type n,
+          const span_iterator<Span, IsConst>& rhs)
+{
+  return rhs + n;
+}
+
+template<size_t Ext>
+class extent_type
+{
+public:
+  using index_type = size_t;
+
+  static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size.");
+
+  constexpr extent_type() {}
+
+  template<index_type Other>
+                                            extent_type(extent_type<Other> ext)
+  {
+    static_assert(
+      Other == Ext || Other == dynamic_extent,
+      "Mismatch between fixed-size extent and size of initializing data.");
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(ext.size() == Ext)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ext.size() == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "ext.size() == Ext" ")"); do { *((volatile int*) __null) = 340; ::abort(); } while (0); } } while (0);
+  }
+
+                                            extent_type(index_type length)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(length == Ext)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(length == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "length == Ext" ")"); do { *((volatile int*) __null) = 345; ::abort(); } while (0); } } while (0);
+  }
+
+  constexpr index_type size() const { return Ext; }
+};
+
+template<>
+class extent_type<dynamic_extent>
+{
+public:
+  using index_type = size_t;
+
+  template<index_type Other>
+  explicit constexpr extent_type(extent_type<Other> ext)
+    : size_(ext.size())
+  {
+  }
+
+  explicit constexpr extent_type(index_type length)
+    : size_(length)
+  {
+  }
+
+  constexpr index_type size() const { return size_; }
+
+private:
+  index_type size_;
+};
+}
+# 436 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
+template<class ElementType, size_t Extent>
+class Span
+{
+public:
+
+  using element_type = ElementType;
+  using index_type = size_t;
+  using pointer = element_type*;
+  using reference = element_type&;
+
+  using iterator =
+    span_details::span_iterator<Span<ElementType, Extent>, false>;
+  using const_iterator =
+    span_details::span_iterator<Span<ElementType, Extent>, true>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  constexpr static const index_type extent = Extent;
+
+
+
+
+
+
+
+  template<
+    bool Dependent = false,
+    class = span_details::enable_if_t<
+      (Dependent || Extent == 0 || Extent == mozilla::MaxValue<size_t>::value)>>
+  constexpr Span()
+    : storage_(nullptr, span_details::extent_type<0>())
+  {
+  }
+
+
+
+
+  constexpr Span(std::nullptr_t) : Span() {}
+
+
+
+
+  constexpr Span(pointer aPtr, index_type aLength)
+    : storage_(aPtr, aLength)
+  {
+  }
+
+
+
+
+  constexpr Span(pointer aStartPtr, pointer aEndPtr)
+    : storage_(aStartPtr, std::distance(aStartPtr, aEndPtr))
+  {
+  }
+
+
+
+
+  template<size_t N>
+  constexpr Span(element_type (&aArr)[N])
+    : storage_(&aArr[0], span_details::extent_type<N>())
+  {
+  }
+
+
+
+
+  template<size_t N,
+           class ArrayElementType = span_details::remove_const_t<element_type>>
+  constexpr Span(std::array<ArrayElementType, N>& aArr)
+    : storage_(&aArr[0], span_details::extent_type<N>())
+  {
+  }
+
+
+
+
+  template<size_t N>
+  constexpr Span(
+    const std::array<span_details::remove_const_t<element_type>, N>& aArr)
+    : storage_(&aArr[0], span_details::extent_type<N>())
+  {
+  }
+
+
+
+
+  template<size_t N,
+           class ArrayElementType = span_details::remove_const_t<element_type>>
+  constexpr Span(mozilla::Array<ArrayElementType, N>& aArr)
+    : storage_(&aArr[0], span_details::extent_type<N>())
+  {
+  }
+
+
+
+
+  template<size_t N>
+  constexpr Span(
+    const mozilla::Array<span_details::remove_const_t<element_type>, N>& aArr)
+    : storage_(&aArr[0], span_details::extent_type<N>())
+  {
+  }
+
+
+
+
+  template<class ArrayElementType = std::add_pointer<element_type>>
+  constexpr Span(const mozilla::UniquePtr<ArrayElementType>& aPtr,
+                 index_type aLength)
+    : storage_(aPtr.get(), aLength)
+  {
+  }
+
+
+
+
+
+
+  template<
+    class Container,
+    class = span_details::enable_if_t<
+      !span_details::is_span<Container>::value &&
+      !span_details::is_std_array<Container>::value &&
+      mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
+      mozilla::IsConvertible<typename Container::pointer,
+                          decltype(mozilla::DeclVal<Container>().data())>::value>>
+  constexpr Span(Container& cont)
+    : Span(cont.data(), ReleaseAssertedCast<index_type>(cont.size()))
+  {
+  }
+
+
+
+
+  template<
+    class Container,
+    class = span_details::enable_if_t<
+      mozilla::IsConst<element_type>::value &&
+      !span_details::is_span<Container>::value &&
+      mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
+      mozilla::IsConvertible<typename Container::pointer,
+                          decltype(mozilla::DeclVal<Container>().data())>::value>>
+  constexpr Span(const Container& cont)
+    : Span(cont.data(), ReleaseAssertedCast<index_type>(cont.size()))
+  {
+  }
+
+
+
+
+  constexpr Span(const Span& other) = default;
+
+
+
+
+  constexpr Span(Span&& other) = default;
+
+
+
+
+  template<
+    class OtherElementType,
+    size_t OtherExtent,
+    class = span_details::enable_if_t<
+      span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
+      span_details::is_allowed_element_type_conversion<OtherElementType,
+                                                       element_type>::value>>
+  constexpr Span(const Span<OtherElementType, OtherExtent>& other)
+    : storage_(other.data(),
+               span_details::extent_type<OtherExtent>(other.size()))
+  {
+  }
+
+
+
+
+  template<
+    class OtherElementType,
+    size_t OtherExtent,
+    class = span_details::enable_if_t<
+      span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
+      span_details::is_allowed_element_type_conversion<OtherElementType,
+                                                       element_type>::value>>
+  constexpr Span(Span<OtherElementType, OtherExtent>&& other)
+    : storage_(other.data(),
+               span_details::extent_type<OtherExtent>(other.size()))
+  {
+  }
+
+  ~Span() = default;
+                                          Span& operator=(const Span& other)
+    = default;
+
+                                          Span& operator=(Span&& other)
+    = default;
+
+
+
+
+
+  template<size_t Count>
+                         Span<element_type, Count> First() const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Count <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 640; ::abort(); } while (0); } } while (0);
+    return { data(), Count };
+  }
+
+
+
+
+  template<size_t Count>
+                         Span<element_type, Count> Last() const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Count <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 650; ::abort(); } while (0); } } while (0);
+    return { data() + (size() - Count), Count };
+  }
+
+
+
+
+  template<size_t Offset, size_t Count = dynamic_extent>
+                         Span<element_type, Count> Subspan() const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size())))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))" ")"); do { *((volatile int*) __null) = 661; ::abort(); } while (0); } } while (0);
+
+    return { data() + Offset,
+             Count == dynamic_extent ? size() - Offset : Count };
+  }
+
+
+
+
+                         Span<element_type, dynamic_extent> First(
+    index_type aCount) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 672; ::abort(); } while (0); } } while (0);
+    return { data(), aCount };
+  }
+
+
+
+
+                         Span<element_type, dynamic_extent> Last(
+    index_type aCount) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 682; ::abort(); } while (0); } } while (0);
+    return { data() + (size() - aCount), aCount };
+  }
+
+
+
+
+                         Span<element_type, dynamic_extent> Subspan(
+    index_type aStart,
+    index_type aLength = dynamic_extent) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size())))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))" ")"); do { *((volatile int*) __null) = 695; ::abort(); } while (0); } } while (0);
+
+
+    return { data() + aStart,
+             aLength == dynamic_extent ? size() - aStart : aLength };
+  }
+
+
+
+
+                         Span<element_type, dynamic_extent> From(
+    index_type aStart) const
+  {
+    return Subspan(aStart);
+  }
+
+
+
+
+                         Span<element_type, dynamic_extent> To(
+    index_type aEnd) const
+  {
+    return Subspan(0, aEnd);
+  }
+
+
+
+
+
+                         Span<element_type, dynamic_extent> FromTo(
+    index_type aStart,
+    index_type aEnd) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aStart <= aEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= aEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= aEnd" ")"); do { *((volatile int*) __null) = 726; ::abort(); } while (0); } } while (0);
+    return Subspan(aStart, aEnd - aStart);
+  }
+
+
+
+
+
+  constexpr index_type Length() const { return size(); }
+
+
+
+
+  constexpr index_type size() const { return storage_.size(); }
+
+
+
+
+  constexpr index_type LengthBytes() const { return size_bytes(); }
+
+
+
+
+  constexpr index_type size_bytes() const
+  {
+    return size() * narrow_cast<index_type>(sizeof(element_type));
+  }
+
+
+
+
+  constexpr bool IsEmpty() const { return empty(); }
+
+
+
+
+
+  constexpr bool empty() const { return size() == 0; }
+
+
+                         reference operator[](index_type idx) const
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(idx < storage_.size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(idx < storage_.size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "idx < storage_.size()" ")"); do { *((volatile int*) __null) = 768; ::abort(); } while (0); } } while (0);
+    return data()[idx];
+  }
+
+
+
+
+  constexpr reference at(index_type idx) const { return this->operator[](idx); }
+
+  constexpr reference operator()(index_type idx) const
+  {
+    return this->operator[](idx);
+  }
+
+
+
+
+  constexpr pointer Elements() const { return data(); }
+
+
+
+
+  constexpr pointer data() const { return storage_.data(); }
+
+
+  iterator begin() const { return { this, 0 }; }
+  iterator end() const { return { this, Length() }; }
+
+  const_iterator cbegin() const { return { this, 0 }; }
+  const_iterator cend() const { return { this, Length() }; }
+
+  reverse_iterator rbegin() const
+  {
+    return reverse_iterator{ end() };
+  }
+  reverse_iterator rend() const
+  {
+    return reverse_iterator{ begin() };
+  }
+
+  const_reverse_iterator crbegin() const
+  {
+    return const_reverse_iterator{ cend() };
+  }
+  const_reverse_iterator crend() const
+  {
+    return const_reverse_iterator{ cbegin() };
+  }
+
+private:
+
+
+
+  template<class ExtentType>
+  class storage_type : public ExtentType
+  {
+  public:
+    template<class OtherExtentType>
+                                 storage_type(pointer elements,
+                                              OtherExtentType ext)
+      : ExtentType(ext)
+      , data_(elements)
+    {
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)" ")"); do { *((volatile int*) __null) = 833; ::abort(); } while (0); } } while (0);
+
+
+    }
+
+    constexpr pointer data() const { return data_; }
+
+  private:
+    pointer data_;
+  };
+
+  storage_type<span_details::extent_type<Extent>> storage_;
+};
+
+
+template<class ElementType, size_t FirstExtent, size_t SecondExtent>
+inline constexpr bool
+operator==(const Span<ElementType, FirstExtent>& l,
+           const Span<ElementType, SecondExtent>& r)
+{
+  return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin());
+}
+
+template<class ElementType, size_t Extent>
+inline constexpr bool
+operator!=(const Span<ElementType, Extent>& l,
+           const Span<ElementType, Extent>& r)
+{
+  return !(l == r);
+}
+
+template<class ElementType, size_t Extent>
+inline constexpr bool
+operator<(const Span<ElementType, Extent>& l,
+          const Span<ElementType, Extent>& r)
+{
+  return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template<class ElementType, size_t Extent>
+inline constexpr bool
+operator<=(const Span<ElementType, Extent>& l,
+           const Span<ElementType, Extent>& r)
+{
+  return !(l > r);
+}
+
+template<class ElementType, size_t Extent>
+inline constexpr bool
+operator>(const Span<ElementType, Extent>& l,
+          const Span<ElementType, Extent>& r)
+{
+  return r < l;
+}
+
+template<class ElementType, size_t Extent>
+inline constexpr bool
+operator>=(const Span<ElementType, Extent>& l,
+           const Span<ElementType, Extent>& r)
+{
+  return !(l < r);
+}
+
+namespace span_details {
+
+
+
+
+
+
+template<class ElementType, size_t Extent>
+struct calculate_byte_size
+  : mozilla::IntegralConstant<size_t,
+                           static_cast<size_t>(sizeof(ElementType) *
+                                               static_cast<size_t>(Extent))>
+{
+};
+
+template<class ElementType>
+struct calculate_byte_size<ElementType, dynamic_extent>
+  : mozilla::IntegralConstant<size_t, dynamic_extent>
+{
+};
+}
+
+
+
+
+
+template<class ElementType, size_t Extent>
+Span<const uint8_t,
+     span_details::calculate_byte_size<ElementType, Extent>::value>
+AsBytes(Span<ElementType, Extent> s)
+{
+  return { reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes() };
+}
+
+
+
+
+template<class ElementType,
+         size_t Extent,
+         class = span_details::enable_if_t<!mozilla::IsConst<ElementType>::value>>
+Span<uint8_t, span_details::calculate_byte_size<ElementType, Extent>::value>
+AsWritableBytes(Span<ElementType, Extent> s)
+{
+  return { reinterpret_cast<uint8_t*>(s.data()), s.size_bytes() };
+}
+
+
+
+
+
+
+
+template<class ElementType>
+Span<ElementType>
+MakeSpan(ElementType* aPtr, typename Span<ElementType>::index_type aLength)
+{
+  return Span<ElementType>(aPtr, aLength);
+}
+
+
+
+
+template<class ElementType>
+Span<ElementType>
+MakeSpan(ElementType* aStartPtr, ElementType* aEndPtr)
+{
+  return Span<ElementType>(aStartPtr, aEndPtr);
+}
+
+
+
+
+template<class ElementType, size_t N>
+Span<ElementType> MakeSpan(ElementType (&aArr)[N])
+{
+  return Span<ElementType>(aArr);
+}
+
+
+
+
+template<class ElementType, size_t N>
+Span<ElementType>
+MakeSpan(mozilla::Array<ElementType, N>& aArr)
+{
+  return aArr;
+}
+
+
+
+
+template<class ElementType, size_t N>
+Span<const ElementType>
+MakeSpan(const mozilla::Array<ElementType, N>& arr)
+{
+  return arr;
+}
+
+
+
+
+template<class Container>
+Span<typename Container::value_type>
+MakeSpan(Container& cont)
+{
+  return Span<typename Container::value_type>(cont);
+}
+
+
+
+
+template<class Container>
+Span<const typename Container::value_type>
+MakeSpan(const Container& cont)
+{
+  return Span<const typename Container::value_type>(cont);
+}
+
+
+
+
+template<class Ptr>
+Span<typename Ptr::element_type>
+MakeSpan(Ptr& aPtr, size_t aLength)
+{
+  return Span<typename Ptr::element_type>(aPtr, aLength);
+}
+
+
+
+
+inline Span<const char>
+MakeStringSpan(const char* aZeroTerminated)
+{
+  return Span<const char>(aZeroTerminated, std::strlen(aZeroTerminated));
+}
+
+
+
+
+inline Span<const char16_t>
+MakeStringSpan(const char16_t* aZeroTerminated)
+{
+  return Span<const char16_t>(aZeroTerminated, span_details::strlen16(aZeroTerminated));
+}
+
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h"
+namespace mozilla {
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h"
+template<typename IndexType,
+         IndexType SizeAsEnumValue,
+         typename ValueType>
+class EnumeratedArray
+{
+public:
+  static const size_t kSize = size_t(SizeAsEnumValue);
+
+private:
+  typedef Array<ValueType, kSize> ArrayType;
+
+  ArrayType mArray;
+
+public:
+  EnumeratedArray() {}
+
+  template <typename... Args>
+               EnumeratedArray(Args&&... aArgs)
+    : mArray{mozilla::Forward<Args>(aArgs)...}
+  {}
+
+  explicit EnumeratedArray(const EnumeratedArray& aOther)
+  {
+    for (size_t i = 0; i < kSize; i++) {
+      mArray[i] = aOther.mArray[i];
+    }
+  }
+
+  EnumeratedArray(EnumeratedArray&& aOther)
+  {
+    for (size_t i = 0; i < kSize; i++) {
+      mArray[i] = Move(aOther.mArray[i]);
+    }
+  }
+
+  ValueType& operator[](IndexType aIndex)
+  {
+    return mArray[size_t(aIndex)];
+  }
+
+  const ValueType& operator[](IndexType aIndex) const
+  {
+    return mArray[size_t(aIndex)];
+  }
+
+  typedef typename ArrayType::iterator iterator;
+  typedef typename ArrayType::const_iterator const_iterator;
+  typedef typename ArrayType::reverse_iterator reverse_iterator;
+  typedef typename ArrayType::const_reverse_iterator const_reverse_iterator;
+
+
+  iterator begin() { return mArray.begin(); }
+  const_iterator begin() const { return mArray.begin(); }
+  const_iterator cbegin() const { return mArray.cbegin(); }
+  iterator end() { return mArray.end(); }
+  const_iterator end() const { return mArray.end(); }
+  const_iterator cend() const { return mArray.cend(); }
+
+
+  reverse_iterator rbegin() { return mArray.rbegin(); }
+  const_reverse_iterator rbegin() const { return mArray.rbegin(); }
+  const_reverse_iterator crbegin() const { return mArray.crbegin(); }
+  reverse_iterator rend() { return mArray.rend(); }
+  const_reverse_iterator rend() const { return mArray.rend(); }
+  const_reverse_iterator crend() const { return mArray.crend(); }
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" 1
+# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
+namespace mozilla {
+
+template<typename T>
+class LinkedListElement;
+
+namespace detail {
+
+
+
+
+
+
+template<typename T>
+struct LinkedListElementTraits
+{
+  typedef T* RawType;
+  typedef const T* ConstRawType;
+  typedef T* ClientType;
+  typedef const T* ConstClientType;
+
+
+
+
+
+
+  static void enterList(LinkedListElement<T>* elt) {}
+  static void exitList(LinkedListElement<T>* elt) {}
+};
+
+template<typename T>
+struct LinkedListElementTraits<RefPtr<T>>
+{
+  typedef T* RawType;
+  typedef const T* ConstRawType;
+  typedef RefPtr<T> ClientType;
+  typedef RefPtr<const T> ConstClientType;
+
+  static void enterList(LinkedListElement<RefPtr<T>>* elt) { elt->asT()->AddRef(); }
+  static void exitList(LinkedListElement<RefPtr<T>>* elt) { elt->asT()->Release(); }
+};
+
+}
+
+template<typename T>
+class LinkedList;
+
+template<typename T>
+class LinkedListElement
+{
+  typedef typename detail::LinkedListElementTraits<T> Traits;
+  typedef typename Traits::RawType RawType;
+  typedef typename Traits::ConstRawType ConstRawType;
+  typedef typename Traits::ClientType ClientType;
+  typedef typename Traits::ConstClientType ConstClientType;
+# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
+private:
+  LinkedListElement* mNext;
+  LinkedListElement* mPrev;
+  const bool mIsSentinel;
+
+public:
+  LinkedListElement()
+    : mNext(this),
+      mPrev(this),
+      mIsSentinel(false)
+  { }
+
+
+
+
+
+  LinkedListElement(LinkedListElement<T>&& aOther)
+    : mIsSentinel(aOther.mIsSentinel)
+  {
+    adjustLinkForMove(Move(aOther));
+  }
+
+  LinkedListElement& operator=(LinkedListElement<T>&& aOther)
+  {
+    do { } while (0);
+    do { } while (0);
+
+    adjustLinkForMove(Move(aOther));
+    return *this;
+  }
+
+  ~LinkedListElement()
+  {
+    if (!mIsSentinel && isInList()) {
+      remove();
+    }
+  }
+
+
+
+
+
+  RawType getNext() { return mNext->asT(); }
+  ConstRawType getNext() const { return mNext->asT(); }
+
+
+
+
+
+  RawType getPrevious() { return mPrev->asT(); }
+  ConstRawType getPrevious() const { return mPrev->asT(); }
+
+
+
+
+
+  void setNext(RawType aElem)
+  {
+    do { } while (0);
+    setNextUnsafe(aElem);
+  }
+
+
+
+
+
+
+  void setPrevious(RawType aElem)
+  {
+    do { } while (0);
+    setPreviousUnsafe(aElem);
+  }
+
+
+
+
+
+  void remove()
+  {
+    do { } while (0);
+
+    mPrev->mNext = mNext;
+    mNext->mPrev = mPrev;
+    mNext = this;
+    mPrev = this;
+
+    Traits::exitList(this);
+  }
+
+
+
+
+
+
+  ClientType removeAndGetNext()
+  {
+    ClientType r = getNext();
+    remove();
+    return r;
+  }
+
+
+
+
+
+
+  ClientType removeAndGetPrevious()
+  {
+    ClientType r = getPrevious();
+    remove();
+    return r;
+  }
+
+
+
+
+
+  void removeFrom(const LinkedList<T>& aList)
+  {
+    aList.assertContains(asT());
+    remove();
+  }
+
+
+
+
+  bool isInList() const
+  {
+    do { } while (0);
+    return mNext != this;
+  }
+
+private:
+  friend class LinkedList<T>;
+  friend struct detail::LinkedListElementTraits<T>;
+
+  enum class NodeKind {
+    Normal,
+    Sentinel
+  };
+
+  explicit LinkedListElement(NodeKind nodeKind)
+    : mNext(this),
+      mPrev(this),
+      mIsSentinel(nodeKind == NodeKind::Sentinel)
+  { }
+
+
+
+
+
+  RawType asT()
+  {
+    return mIsSentinel ? nullptr : static_cast<RawType>(this);
+  }
+  ConstRawType asT() const
+  {
+    return mIsSentinel ? nullptr : static_cast<ConstRawType>(this);
+  }
+
+
+
+
+
+  void setNextUnsafe(RawType aElem)
+  {
+    LinkedListElement *listElem = static_cast<LinkedListElement*>(aElem);
+    do { } while (0);
+
+    listElem->mNext = this->mNext;
+    listElem->mPrev = this;
+    this->mNext->mPrev = listElem;
+    this->mNext = listElem;
+
+    Traits::enterList(aElem);
+  }
+
+
+
+
+
+  void setPreviousUnsafe(RawType aElem)
+  {
+    LinkedListElement<T>* listElem = static_cast<LinkedListElement<T>*>(aElem);
+    do { } while (0);
+
+    listElem->mNext = this;
+    listElem->mPrev = this->mPrev;
+    this->mPrev->mNext = listElem;
+    this->mPrev = listElem;
+
+    Traits::enterList(aElem);
+  }
+
+
+
+
+
+  void adjustLinkForMove(LinkedListElement<T>&& aOther)
+  {
+    if (!aOther.isInList()) {
+      mNext = this;
+      mPrev = this;
+      return;
+    }
+
+    if (!mIsSentinel) {
+      Traits::enterList(this);
+    }
+
+    do { } while (0);
+    do { } while (0);
+
+
+
+
+
+    mNext = aOther.mNext;
+    mPrev = aOther.mPrev;
+
+    mNext->mPrev = this;
+    mPrev->mNext = this;
+
+
+
+
+
+    aOther.mNext = &aOther;
+    aOther.mPrev = &aOther;
+
+    if (!mIsSentinel) {
+      Traits::exitList(&aOther);
+    }
+  }
+
+  LinkedListElement& operator=(const LinkedListElement<T>& aOther) = delete;
+  LinkedListElement(const LinkedListElement<T>& aOther) = delete;
+};
+
+template<typename T>
+class LinkedList
+{
+private:
+  typedef typename detail::LinkedListElementTraits<T> Traits;
+  typedef typename Traits::RawType RawType;
+  typedef typename Traits::ConstRawType ConstRawType;
+  typedef typename Traits::ClientType ClientType;
+  typedef typename Traits::ConstClientType ConstClientType;
+
+  LinkedListElement<T> sentinel;
+
+public:
+  class Iterator {
+    RawType mCurrent;
+
+  public:
+    explicit Iterator(RawType aCurrent) : mCurrent(aCurrent) {}
+
+    RawType operator *() const {
+      return mCurrent;
+    }
+
+    const Iterator& operator++() {
+      mCurrent = mCurrent->getNext();
+      return *this;
+    }
+
+    bool operator!=(Iterator& aOther) const {
+      return mCurrent != aOther.mCurrent;
+    }
+  };
+
+  LinkedList() : sentinel(LinkedListElement<T>::NodeKind::Sentinel) { }
+
+  LinkedList(LinkedList<T>&& aOther)
+    : sentinel(mozilla::Move(aOther.sentinel))
+  { }
+
+  LinkedList& operator=(LinkedList<T>&& aOther)
+  {
+    do { } while (0);
+    sentinel = mozilla::Move(aOther.sentinel);
+    return *this;
+  }
+
+  ~LinkedList() {
+    do { } while (0);
+
+
+
+  }
+
+
+
+
+  void insertFront(RawType aElem)
+  {
+
+    sentinel.setNextUnsafe(aElem);
+  }
+
+
+
+
+  void insertBack(RawType aElem)
+  {
+    sentinel.setPreviousUnsafe(aElem);
+  }
+
+
+
+
+  RawType getFirst() { return sentinel.getNext(); }
+  ConstRawType getFirst() const { return sentinel.getNext(); }
+
+
+
+
+  RawType getLast() { return sentinel.getPrevious(); }
+  ConstRawType getLast() const { return sentinel.getPrevious(); }
+
+
+
+
+
+  ClientType popFirst()
+  {
+    ClientType ret = sentinel.getNext();
+    if (ret) {
+      static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
+    }
+    return ret;
+  }
+
+
+
+
+
+  ClientType popLast()
+  {
+    ClientType ret = sentinel.getPrevious();
+    if (ret) {
+      static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
+    }
+    return ret;
+  }
+
+
+
+
+  bool isEmpty() const
+  {
+    return !sentinel.isInList();
+  }
+
+
+
+
+
+
+
+  void clear()
+  {
+    while (popFirst()) {
+      continue;
+    }
+  }
+
+
+
+
+
+
+  Iterator begin() {
+    return Iterator(getFirst());
+  }
+  Iterator end() {
+    return Iterator(nullptr);
+  }
+
+
+
+
+
+
+
+  size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+  {
+    size_t n = 0;
+    for (const T* t = getFirst(); t; t = t->getNext()) {
+      n += aMallocSizeOf(t);
+    }
+    return n;
+  }
+
+
+
+
+  size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+
+  void debugAssertIsSane() const
+  {
+# 622 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
+  }
+
+private:
+  friend class LinkedListElement<T>;
+
+  void assertContains(const RawType aValue) const
+  {
+# 637 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
+  }
+
+  LinkedList& operator=(const LinkedList<T>& aOther) = delete;
+  LinkedList(const LinkedList<T>& aOther) = delete;
+};
+
+template <typename T>
+class AutoCleanLinkedList : public LinkedList<T>
+{
+public:
+  ~AutoCleanLinkedList()
+  {
+    while (T* element = this->popFirst()) {
+      delete element;
+    }
+  }
+};
+
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 2
+
+
+
+
+
+
+
+
+namespace mozilla {
+# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
+template<class T>
+__attribute__((always_inline)) inline size_t
+PointerRangeSize(T* aBegin, T* aEnd)
+{
+  do { } while (0);
+  return (size_t(aEnd) - size_t(aBegin)) / sizeof(T);
+}
+
+
+
+
+
+
+
+template<typename T, size_t N>
+constexpr size_t
+ArrayLength(T (&aArr)[N])
+{
+  return N;
+}
+
+template<typename T, size_t N>
+constexpr size_t
+ArrayLength(const Array<T, N>& aArr)
+{
+  return N;
+}
+
+template<typename E, E N, typename T>
+constexpr size_t
+ArrayLength(const EnumeratedArray<E, N, T>& aArr)
+{
+  return size_t(N);
+}
+
+
+
+
+
+
+template<typename T, size_t N>
+constexpr T*
+ArrayEnd(T (&aArr)[N])
+{
+  return aArr + ArrayLength(aArr);
+}
+
+template<typename T, size_t N>
+constexpr T*
+ArrayEnd(Array<T, N>& aArr)
+{
+  return &aArr[0] + ArrayLength(aArr);
+}
+
+template<typename T, size_t N>
+constexpr const T*
+ArrayEnd(const Array<T, N>& aArr)
+{
+  return &aArr[0] + ArrayLength(aArr);
+}
+
+namespace detail {
+
+template<typename AlignType, typename Pointee,
+         typename = EnableIf<!IsVoid<AlignType>::value>>
+struct AlignedChecker
+{
+  static void
+  test(const Pointee* aPtr)
+  {
+    do { } while (0);
+
+  }
+};
+
+template<typename AlignType, typename Pointee>
+struct AlignedChecker<AlignType, Pointee>
+{
+  static void
+  test(const Pointee* aPtr)
+  {
+  }
+};
+
+}
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
+template<typename T, typename U>
+inline typename EnableIf<IsSame<T, U>::value ||
+                         IsBaseOf<T, U>::value ||
+                         IsVoid<T>::value,
+                         bool>::Type
+IsInRange(const T* aPtr, const U* aBegin, const U* aEnd)
+{
+  do { } while (0);
+  detail::AlignedChecker<U, T>::test(aPtr);
+  detail::AlignedChecker<U, U>::test(aBegin);
+  detail::AlignedChecker<U, U>::test(aEnd);
+  return aBegin <= reinterpret_cast<const U*>(aPtr) &&
+         reinterpret_cast<const U*>(aPtr) < aEnd;
+}
+
+
+
+
+
+
+template<typename T>
+inline bool
+IsInRange(const T* aPtr, uintptr_t aBegin, uintptr_t aEnd)
+{
+  return IsInRange(aPtr,
+                   reinterpret_cast<const T*>(aBegin),
+                   reinterpret_cast<const T*>(aEnd));
+}
+
+namespace detail {
+
+
+
+
+
+template <typename T, size_t N>
+char (&ArrayLengthHelper(T (&array)[N]))[N];
+
+}
+
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 2
+
+
+
+
+
+namespace mozilla {
+
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodZero(T* aT)
+{
+  memset(aT, 0, sizeof(T));
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodZero(T* aT, size_t aNElem)
+{
+
+
+
+
+
+  for (T* end = aT + aNElem; aT < end; aT++) {
+    memset(aT, 0, sizeof(T));
+  }
+}
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
+template<typename T, size_t N>
+static void PodZero(T (&aT)[N]) = delete;
+template<typename T, size_t N>
+static void PodZero(T (&aT)[N], size_t aNElem) = delete;
+
+
+template <class T, size_t N>
+static __attribute__((always_inline)) inline void
+PodArrayZero(T (&aT)[N])
+{
+  memset(aT, 0, N * sizeof(T));
+}
+
+template <typename T, size_t N>
+static __attribute__((always_inline)) inline void
+PodArrayZero(Array<T, N>& aArr)
+{
+  memset(&aArr[0], 0, N * sizeof(T));
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodAssign(T* aDst, const T* aSrc)
+{
+  do { } while (0);
+
+  memcpy(reinterpret_cast<char*>(aDst), reinterpret_cast<const char*>(aSrc),
+         sizeof(T));
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodCopy(T* aDst, const T* aSrc, size_t aNElem)
+{
+  do { } while (0);
+
+  if (aNElem < 128) {
+
+
+
+
+    for (const T* srcend = aSrc + aNElem; aSrc < srcend; aSrc++, aDst++) {
+      PodAssign(aDst, aSrc);
+    }
+  } else {
+    memcpy(aDst, aSrc, aNElem * sizeof(T));
+  }
+}
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodCopy(volatile T* aDst, const volatile T* aSrc, size_t aNElem)
+{
+  do { } while (0);
+# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
+  for (const volatile T* srcend = aSrc + aNElem;
+       aSrc < srcend;
+       aSrc++, aDst++) {
+    *aDst = *aSrc;
+  }
+}
+
+
+
+
+
+template <class T, size_t N>
+static __attribute__((always_inline)) inline void
+PodArrayCopy(T (&aDst)[N], const T (&aSrc)[N])
+{
+  PodCopy(aDst, aSrc, N);
+}
+
+
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline void
+PodMove(T* aDst, const T* aSrc, size_t aNElem)
+{
+  do { } while (0);
+
+  memmove(aDst, aSrc, aNElem * sizeof(T));
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+PodEqual(const T* one, const T* two, size_t len)
+{
+  if (len < 128) {
+    const T* p1end = one + len;
+    const T* p1 = one;
+    const T* p2 = two;
+    for (; p1 < p1end; p1++, p2++) {
+      if (*p1 != *p2) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return !memcmp(one, two, len * sizeof(T));
+}
+
+
+
+
+
+template <class T, size_t N>
+static __attribute__((always_inline)) inline bool
+PodEqual(const T (&one)[N], const T (&two)[N])
+{
+  return PodEqual(one, two, N);
+}
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsprototypes.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 1
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js-config.h" 1
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsversion.h" 1
+# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 1
+# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
+namespace mozilla {
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
+template<typename T>
+class DebugOnly
+{
+public:
+# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
+  DebugOnly() { }
+               DebugOnly(const T&) { }
+  DebugOnly(const DebugOnly&) { }
+  DebugOnly& operator=(const T&) { return *this; }
+  void operator++(int) { }
+  void operator--(int) { }
+  DebugOnly& operator+=(const T&) { return *this; }
+  DebugOnly& operator-=(const T&) { return *this; }
+  DebugOnly& operator&=(const T&) { return *this; }
+  DebugOnly& operator|=(const T&) { return *this; }
+  DebugOnly& operator^=(const T&) { return *this; }
+
+
+
+
+
+
+
+  ~DebugOnly() {}
+};
+
+}
+# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 2
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
+namespace mozilla {
+
+namespace detail {
+
+
+
+
+
+
+template<typename T, size_t Size = sizeof(T)>
+struct Swapper;
+
+template<typename T>
+struct Swapper<T, 2>
+{
+  static T swap(T aValue)
+  {
+
+    return __builtin_bswap16(aValue);
+
+
+
+  }
+};
+
+template<typename T>
+struct Swapper<T, 4>
+{
+  static T swap(T aValue)
+  {
+
+    return T(__builtin_bswap32(aValue));
+# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
+  }
+};
+
+template<typename T>
+struct Swapper<T, 8>
+{
+  static inline T swap(T aValue)
+  {
+
+    return T(__builtin_bswap64(aValue));
+# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
+  }
+};
+
+enum Endianness { Little, Big };
+
+
+
+
+
+
+
+class EndianUtils
+{
+
+
+
+
+  static void assertNoOverlap(const void* aDest, const void* aSrc,
+                              size_t aCount)
+  {
+    DebugOnly<const uint8_t*> byteDestPtr = static_cast<const uint8_t*>(aDest);
+    DebugOnly<const uint8_t*> byteSrcPtr = static_cast<const uint8_t*>(aSrc);
+    do { } while (0);
+
+
+
+  }
+
+  template<typename T>
+  static void assertAligned(T* aPtr)
+  {
+    do { } while (0);
+  }
+
+protected:
+
+
+
+
+  template<Endianness SourceEndian, Endianness DestEndian, typename T>
+  static inline T maybeSwap(T aValue)
+  {
+    if (SourceEndian == DestEndian) {
+      return aValue;
+    }
+    return Swapper<T>::swap(aValue);
+  }
+
+
+
+
+
+  template<Endianness SourceEndian, Endianness DestEndian, typename T>
+  static inline void maybeSwapInPlace(T* aPtr, size_t aCount)
+  {
+    assertAligned(aPtr);
+
+    if (SourceEndian == DestEndian) {
+      return;
+    }
+    for (size_t i = 0; i < aCount; i++) {
+      aPtr[i] = Swapper<T>::swap(aPtr[i]);
+    }
+  }
+
+
+
+
+
+  template<Endianness SourceEndian, Endianness DestEndian, typename T>
+  static void copyAndSwapTo(void* aDest, const T* aSrc, size_t aCount)
+  {
+    assertNoOverlap(aDest, aSrc, aCount * sizeof(T));
+    assertAligned(aSrc);
+
+    if (SourceEndian == DestEndian) {
+      memcpy(aDest, aSrc, aCount * sizeof(T));
+      return;
+    }
+
+    uint8_t* byteDestPtr = static_cast<uint8_t*>(aDest);
+    for (size_t i = 0; i < aCount; ++i) {
+      union
+      {
+        T mVal;
+        uint8_t mBuffer[sizeof(T)];
+      } u;
+      u.mVal = maybeSwap<SourceEndian, DestEndian>(aSrc[i]);
+      memcpy(byteDestPtr, u.mBuffer, sizeof(T));
+      byteDestPtr += sizeof(T);
+    }
+  }
+
+
+
+
+
+  template<Endianness SourceEndian, Endianness DestEndian, typename T>
+  static void copyAndSwapFrom(T* aDest, const void* aSrc, size_t aCount)
+  {
+    assertNoOverlap(aDest, aSrc, aCount * sizeof(T));
+    assertAligned(aDest);
+
+    if (SourceEndian == DestEndian) {
+      memcpy(aDest, aSrc, aCount * sizeof(T));
+      return;
+    }
+
+    const uint8_t* byteSrcPtr = static_cast<const uint8_t*>(aSrc);
+    for (size_t i = 0; i < aCount; ++i) {
+      union
+      {
+        T mVal;
+        uint8_t mBuffer[sizeof(T)];
+      } u;
+      memcpy(u.mBuffer, byteSrcPtr, sizeof(T));
+      aDest[i] = maybeSwap<SourceEndian, DestEndian>(u.mVal);
+      byteSrcPtr += sizeof(T);
+    }
+  }
+};
+
+template<Endianness ThisEndian>
+class Endian : private EndianUtils
+{
+protected:
+
+  static __attribute__ ((warn_unused_result)) uint16_t readUint16(const void* aPtr)
+  {
+    return read<uint16_t>(aPtr);
+  }
+
+
+  static __attribute__ ((warn_unused_result)) uint32_t readUint32(const void* aPtr)
+  {
+    return read<uint32_t>(aPtr);
+  }
+
+
+  static __attribute__ ((warn_unused_result)) uint64_t readUint64(const void* aPtr)
+  {
+    return read<uint64_t>(aPtr);
+  }
+
+
+  static __attribute__ ((warn_unused_result)) int16_t readInt16(const void* aPtr)
+  {
+    return read<int16_t>(aPtr);
+  }
+
+
+  static __attribute__ ((warn_unused_result)) int32_t readInt32(const void* aPtr)
+  {
+    return read<uint32_t>(aPtr);
+  }
+
+
+  static __attribute__ ((warn_unused_result)) int64_t readInt64(const void* aPtr)
+  {
+    return read<int64_t>(aPtr);
+  }
+
+
+  static void writeUint16(void* aPtr, uint16_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+
+
+  static void writeUint32(void* aPtr, uint32_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+
+
+  static void writeUint64(void* aPtr, uint64_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+
+
+  static void writeInt16(void* aPtr, int16_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+
+
+  static void writeInt32(void* aPtr, int32_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+
+
+  static void writeInt64(void* aPtr, int64_t aValue)
+  {
+    write(aPtr, aValue);
+  }
+# 425 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapToLittleEndian(T aValue)
+  {
+    return maybeSwap<ThisEndian, Little>(aValue);
+  }
+
+
+
+
+
+
+  template<typename T>
+  static void copyAndSwapToLittleEndian(void* aDest, const T* aSrc,
+                                        size_t aCount)
+  {
+    copyAndSwapTo<ThisEndian, Little>(aDest, aSrc, aCount);
+  }
+
+
+
+
+  template<typename T>
+  static void swapToLittleEndianInPlace(T* aPtr, size_t aCount)
+  {
+    maybeSwapInPlace<ThisEndian, Little>(aPtr, aCount);
+  }
+
+
+
+
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapToBigEndian(T aValue)
+  {
+    return maybeSwap<ThisEndian, Big>(aValue);
+  }
+
+
+
+
+
+
+  template<typename T>
+  static void copyAndSwapToBigEndian(void* aDest, const T* aSrc,
+                                     size_t aCount)
+  {
+    copyAndSwapTo<ThisEndian, Big>(aDest, aSrc, aCount);
+  }
+
+
+
+
+  template<typename T>
+  static void swapToBigEndianInPlace(T* aPtr, size_t aCount)
+  {
+    maybeSwapInPlace<ThisEndian, Big>(aPtr, aCount);
+  }
+
+
+
+
+
+
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapToNetworkOrder(T aValue)
+  {
+    return swapToBigEndian(aValue);
+  }
+
+  template<typename T>
+  static void
+  copyAndSwapToNetworkOrder(void* aDest, const T* aSrc, size_t aCount)
+  {
+    copyAndSwapToBigEndian(aDest, aSrc, aCount);
+  }
+
+  template<typename T>
+  static void
+  swapToNetworkOrderInPlace(T* aPtr, size_t aCount)
+  {
+    swapToBigEndianInPlace(aPtr, aCount);
+  }
+
+
+
+
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapFromLittleEndian(T aValue)
+  {
+    return maybeSwap<Little, ThisEndian>(aValue);
+  }
+
+
+
+
+
+
+  template<typename T>
+  static void copyAndSwapFromLittleEndian(T* aDest, const void* aSrc,
+                                          size_t aCount)
+  {
+    copyAndSwapFrom<Little, ThisEndian>(aDest, aSrc, aCount);
+  }
+
+
+
+
+  template<typename T>
+  static void swapFromLittleEndianInPlace(T* aPtr, size_t aCount)
+  {
+    maybeSwapInPlace<Little, ThisEndian>(aPtr, aCount);
+  }
+
+
+
+
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapFromBigEndian(T aValue)
+  {
+    return maybeSwap<Big, ThisEndian>(aValue);
+  }
+
+
+
+
+
+
+  template<typename T>
+  static void copyAndSwapFromBigEndian(T* aDest, const void* aSrc,
+                                       size_t aCount)
+  {
+    copyAndSwapFrom<Big, ThisEndian>(aDest, aSrc, aCount);
+  }
+
+
+
+
+  template<typename T>
+  static void swapFromBigEndianInPlace(T* aPtr, size_t aCount)
+  {
+    maybeSwapInPlace<Big, ThisEndian>(aPtr, aCount);
+  }
+
+
+
+
+
+  template<typename T>
+  __attribute__ ((warn_unused_result)) static T swapFromNetworkOrder(T aValue)
+  {
+    return swapFromBigEndian(aValue);
+  }
+
+  template<typename T>
+  static void copyAndSwapFromNetworkOrder(T* aDest, const void* aSrc,
+                                          size_t aCount)
+  {
+    copyAndSwapFromBigEndian(aDest, aSrc, aCount);
+  }
+
+  template<typename T>
+  static void swapFromNetworkOrderInPlace(T* aPtr, size_t aCount)
+  {
+    swapFromBigEndianInPlace(aPtr, aCount);
+  }
+
+private:
+
+
+
+
+  template<typename T>
+  static T read(const void* aPtr)
+  {
+    union
+    {
+      T mVal;
+      uint8_t mBuffer[sizeof(T)];
+    } u;
+    memcpy(u.mBuffer, aPtr, sizeof(T));
+    return maybeSwap<ThisEndian, detail::Little>(u.mVal);
+  }
+
+
+
+
+
+  template<typename T>
+  static void write(void* aPtr, T aValue)
+  {
+    T tmp = maybeSwap<detail::Little, ThisEndian>(aValue);
+    memcpy(aPtr, &tmp, sizeof(T));
+  }
+
+  Endian() = delete;
+  Endian(const Endian& aTther) = delete;
+  void operator=(const Endian& aOther) = delete;
+};
+
+template<Endianness ThisEndian>
+class EndianReadWrite : public Endian<ThisEndian>
+{
+private:
+  typedef Endian<ThisEndian> super;
+
+public:
+  using super::readUint16;
+  using super::readUint32;
+  using super::readUint64;
+  using super::readInt16;
+  using super::readInt32;
+  using super::readInt64;
+  using super::writeUint16;
+  using super::writeUint32;
+  using super::writeUint64;
+  using super::writeInt16;
+  using super::writeInt32;
+  using super::writeInt64;
+};
+
+}
+
+class LittleEndian final : public detail::EndianReadWrite<detail::Little>
+{};
+
+class BigEndian final : public detail::EndianReadWrite<detail::Big>
+{};
+
+typedef BigEndian NetworkEndian;
+
+class NativeEndian final : public detail::Endian<detail::Little>
+{
+private:
+  typedef detail::Endian<detail::Little> super;
+
+public:
+
+
+
+
+
+  using super::swapToLittleEndian;
+  using super::copyAndSwapToLittleEndian;
+  using super::swapToLittleEndianInPlace;
+  using super::swapToBigEndian;
+  using super::copyAndSwapToBigEndian;
+  using super::swapToBigEndianInPlace;
+  using super::swapToNetworkOrder;
+  using super::copyAndSwapToNetworkOrder;
+  using super::swapToNetworkOrderInPlace;
+
+
+
+
+
+
+  using super::swapFromLittleEndian;
+  using super::copyAndSwapFromLittleEndian;
+  using super::swapFromLittleEndianInPlace;
+  using super::swapFromBigEndian;
+  using super::copyAndSwapFromBigEndian;
+  using super::swapFromBigEndianInPlace;
+  using super::swapFromNetworkOrder;
+  using super::copyAndSwapFromNetworkOrder;
+  using super::swapFromNetworkOrderInPlace;
+};
+
+
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 2
+# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 1
+# 119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h"
+namespace mozilla {
+enum NotNullTag {
+  KnownNotNull,
+};
+}
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h"
+inline void*
+operator new(size_t, mozilla::NotNullTag, void* p)
+{
+  do { } while (0);
+  return p;
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 2
+
+
+
+
+
+
+namespace mozilla {
+
+template<typename... Ts>
+class Variant;
+
+namespace detail {
+
+template <typename...>
+struct FirstTypeIsInRest;
+
+template <typename First>
+struct FirstTypeIsInRest<First> : FalseType {};
+
+template <typename First, typename Second, typename... Rest>
+struct FirstTypeIsInRest<First, Second, Rest...>
+{
+  static constexpr bool value =
+    IsSame<First, Second>::value ||
+    FirstTypeIsInRest<First, Rest...>::value;
+};
+
+template <typename...>
+struct TypesAreDistinct;
+
+template <>
+struct TypesAreDistinct<> : TrueType { };
+
+template<typename First, typename... Rest>
+struct TypesAreDistinct<First, Rest...>
+{
+  static constexpr bool value =
+    !FirstTypeIsInRest<First, Rest...>::value &&
+    TypesAreDistinct<Rest...>::value;
+};
+
+
+
+
+
+
+template<typename Needle, typename... Haystack>
+struct IsVariant;
+
+template<typename Needle>
+struct IsVariant<Needle> : FalseType {};
+
+template<typename Needle, typename... Haystack>
+struct IsVariant<Needle, Needle, Haystack...> : TrueType {};
+
+template<typename Needle, typename T, typename... Haystack>
+struct IsVariant<Needle, T, Haystack...> : public IsVariant<Needle, Haystack...> { };
+
+
+template<typename T, typename... Variants>
+struct SelectVariantTypeHelper;
+
+template<typename T>
+struct SelectVariantTypeHelper<T>
+{ };
+
+template<typename T, typename... Variants>
+struct SelectVariantTypeHelper<T, T, Variants...>
+{
+  typedef T Type;
+};
+
+template<typename T, typename... Variants>
+struct SelectVariantTypeHelper<T, const T, Variants...>
+{
+  typedef const T Type;
+};
+
+template<typename T, typename... Variants>
+struct SelectVariantTypeHelper<T, const T&, Variants...>
+{
+  typedef const T& Type;
+};
+
+template<typename T, typename... Variants>
+struct SelectVariantTypeHelper<T, T&&, Variants...>
+{
+  typedef T&& Type;
+};
+
+template<typename T, typename Head, typename... Variants>
+struct SelectVariantTypeHelper<T, Head, Variants...>
+  : public SelectVariantTypeHelper<T, Variants...>
+{ };
+
+
+
+
+
+
+template <typename T, typename... Variants>
+struct SelectVariantType
+  : public SelectVariantTypeHelper<typename RemoveConst<typename RemoveReference<T>::Type>::Type,
+                                   Variants...>
+{ };
+
+
+
+template<typename... Ts>
+struct VariantTag
+{
+private:
+  static const size_t TypeCount = sizeof...(Ts);
+
+public:
+  using Type =
+    typename Conditional<TypeCount < 3,
+                         bool,
+                         typename Conditional<TypeCount < (1 << 8),
+                                              uint_fast8_t,
+                                              size_t
+                                              >::Type
+                         >::Type;
+};
+
+
+
+
+
+template<typename Tag, size_t N, typename T, typename U, typename Next, bool isMatch>
+struct TagHelper;
+
+
+template<typename Tag, size_t N, typename T, typename U, typename Next>
+struct TagHelper<Tag, N, T, U, Next, false>
+{
+  static Tag tag() { return Next::template tag<U>(); }
+};
+
+
+template<typename Tag, size_t N, typename T, typename U, typename Next>
+struct TagHelper<Tag, N, T, U, Next, true>
+{
+  static Tag tag() { return Tag(N); }
+};
+
+
+
+
+
+
+
+template<typename Tag, size_t N, typename... Ts>
+struct VariantImplementation;
+
+
+template<typename Tag, size_t N, typename T>
+struct VariantImplementation<Tag, N, T>
+{
+  template<typename U>
+  static Tag tag() {
+    static_assert(mozilla::IsSame<T, U>::value,
+                  "mozilla::Variant: tag: bad type!");
+    return Tag(N);
+  }
+
+  template<typename Variant>
+  static void copyConstruct(void* aLhs, const Variant& aRhs) {
+    ::new (KnownNotNull, aLhs) T(aRhs.template as<T>());
+  }
+
+  template<typename Variant>
+  static void moveConstruct(void* aLhs, Variant&& aRhs) {
+    ::new (KnownNotNull, aLhs) T(aRhs.template extract<T>());
+  }
+
+  template<typename Variant>
+  static void destroy(Variant& aV) {
+    aV.template as<T>().~T();
+  }
+
+  template<typename Variant>
+  static bool
+  equal(const Variant& aLhs, const Variant& aRhs) {
+      return aLhs.template as<T>() == aRhs.template as<T>();
+  }
+
+  template<typename Matcher, typename ConcreteVariant>
+  static auto
+  match(Matcher&& aMatcher, ConcreteVariant& aV)
+    -> decltype(aMatcher.match(aV.template as<T>()))
+  {
+    return aMatcher.match(aV.template as<T>());
+  }
+};
+
+
+template<typename Tag, size_t N, typename T, typename... Ts>
+struct VariantImplementation<Tag, N, T, Ts...>
+{
+
+  using Next = VariantImplementation<Tag, N + 1, Ts...>;
+
+  template<typename U>
+  static Tag tag() {
+    return TagHelper<Tag, N, T, U, Next, IsSame<T, U>::value>::tag();
+  }
+
+  template<typename Variant>
+  static void copyConstruct(void* aLhs, const Variant& aRhs) {
+    if (aRhs.template is<T>()) {
+      ::new (KnownNotNull, aLhs) T(aRhs.template as<T>());
+    } else {
+      Next::copyConstruct(aLhs, aRhs);
+    }
+  }
+
+  template<typename Variant>
+  static void moveConstruct(void* aLhs, Variant&& aRhs) {
+    if (aRhs.template is<T>()) {
+      ::new (KnownNotNull, aLhs) T(aRhs.template extract<T>());
+    } else {
+      Next::moveConstruct(aLhs, aRhs);
+    }
+  }
+
+  template<typename Variant>
+  static void destroy(Variant& aV) {
+    if (aV.template is<T>()) {
+      aV.template as<T>().~T();
+    } else {
+      Next::destroy(aV);
+    }
+  }
+
+  template<typename Variant>
+  static bool equal(const Variant& aLhs, const Variant& aRhs) {
+    if (aLhs.template is<T>()) {
+      do { } while (0);
+      return aLhs.template as<T>() == aRhs.template as<T>();
+    } else {
+      return Next::equal(aLhs, aRhs);
+    }
+  }
+
+  template<typename Matcher, typename ConcreteVariant>
+  static auto
+  match(Matcher&& aMatcher, ConcreteVariant& aV)
+    -> decltype(aMatcher.match(aV.template as<T>()))
+  {
+    if (aV.template is<T>()) {
+      return aMatcher.match(aV.template as<T>());
+    } else {
+# 278 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
+      return Next::match(aMatcher, aV);
+    }
+  }
+};
+
+
+
+
+
+
+
+template <typename T>
+struct AsVariantTemporary
+{
+  explicit AsVariantTemporary(const T& aValue)
+    : mValue(aValue)
+  {}
+
+  template<typename U>
+  explicit AsVariantTemporary(U&& aValue)
+    : mValue(Forward<U>(aValue))
+  {}
+
+  AsVariantTemporary(const AsVariantTemporary& aOther)
+    : mValue(aOther.mValue)
+  {}
+
+  AsVariantTemporary(AsVariantTemporary&& aOther)
+    : mValue(Move(aOther.mValue))
+  {}
+
+  AsVariantTemporary() = delete;
+  void operator=(const AsVariantTemporary&) = delete;
+  void operator=(AsVariantTemporary&&) = delete;
+
+  typename RemoveConst<typename RemoveReference<T>::Type>::Type mValue;
+};
+
+}
+# 447 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
+template<typename... Ts>
+class Variant
+{
+  static_assert(detail::TypesAreDistinct<Ts...>::value,
+                "Variant with duplicate types is not supported");
+
+  using Tag = typename detail::VariantTag<Ts...>::Type;
+  using Impl = detail::VariantImplementation<Tag, 0, Ts...>;
+
+  static constexpr size_t RawDataAlignment = tl::Max<alignof(Ts)...>::value;
+  static constexpr size_t RawDataSize = tl::Max<sizeof(Ts)...>::value;
+
+
+  alignas(RawDataAlignment) unsigned char rawData[RawDataSize];
+
+
+
+  Tag tag;
+
+
+
+
+
+  void* ptr() {
+    return rawData;
+  }
+
+  const void* ptr() const {
+    return rawData;
+  }
+
+public:
+
+  template<typename RefT,
+
+
+
+
+           typename T = typename detail::SelectVariantType<RefT, Ts...>::Type>
+  explicit Variant(RefT&& aT)
+    : tag(Impl::template tag<T>())
+  {
+    ::new (KnownNotNull, ptr()) T(Forward<RefT>(aT));
+  }
+
+
+
+
+
+
+  template<typename RefT,
+           typename T = typename detail::SelectVariantType<RefT, Ts...>::Type>
+               Variant(detail::AsVariantTemporary<RefT>&& aValue)
+    : tag(Impl::template tag<T>())
+  {
+    ::new (KnownNotNull, ptr()) T(Move(aValue.mValue));
+  }
+
+
+  Variant(const Variant& aRhs)
+    : tag(aRhs.tag)
+  {
+    Impl::copyConstruct(ptr(), aRhs);
+  }
+
+
+  Variant(Variant&& aRhs)
+    : tag(aRhs.tag)
+  {
+    Impl::moveConstruct(ptr(), Move(aRhs));
+  }
+
+
+  Variant& operator=(const Variant& aRhs) {
+    do { } while (0);
+    this->~Variant();
+    ::new (KnownNotNull, this) Variant(aRhs);
+    return *this;
+  }
+
+
+  Variant& operator=(Variant&& aRhs) {
+    do { } while (0);
+    this->~Variant();
+    ::new (KnownNotNull, this) Variant(Move(aRhs));
+    return *this;
+  }
+
+
+  template <typename T>
+  Variant& operator=(detail::AsVariantTemporary<T>&& aValue)
+  {
+    this->~Variant();
+    ::new (KnownNotNull, this) Variant(Move(aValue));
+    return *this;
+  }
+
+  ~Variant()
+  {
+    Impl::destroy(*this);
+  }
+
+
+  template<typename T>
+  bool is() const {
+    static_assert(detail::IsVariant<T, Ts...>::value,
+                  "provided a type not found in this Variant's type list");
+    return Impl::template tag<T>() == tag;
+  }
+
+
+
+
+
+  bool operator==(const Variant& aRhs) const {
+    return tag == aRhs.tag && Impl::equal(*this, aRhs);
+  }
+
+
+
+
+
+
+  bool operator!=(const Variant& aRhs) const {
+    return !(*this == aRhs);
+  }
+
+
+
+
+  template<typename T>
+  T& as() {
+    static_assert(detail::IsVariant<T, Ts...>::value,
+                  "provided a type not found in this Variant's type list");
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(is<T>())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is<T>()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is<T>()" ")"); do { *((volatile int*) __null) = 581; ::abort(); } while (0); } } while (0);
+    return *static_cast<T*>(ptr());
+  }
+
+
+  template<typename T>
+  const T& as() const {
+    static_assert(detail::IsVariant<T, Ts...>::value,
+                  "provided a type not found in this Variant's type list");
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(is<T>())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is<T>()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is<T>()" ")"); do { *((volatile int*) __null) = 590; ::abort(); } while (0); } } while (0);
+    return *static_cast<const T*>(ptr());
+  }
+
+
+
+
+
+
+
+  template<typename T>
+  T extract() {
+    static_assert(detail::IsVariant<T, Ts...>::value,
+                  "provided a type not found in this Variant's type list");
+    do { } while (0);
+    return T(Move(as<T>()));
+  }
+
+
+
+
+  template<typename Matcher>
+  auto
+  match(Matcher&& aMatcher) const
+    -> decltype(Impl::match(aMatcher, *this))
+  {
+    return Impl::match(aMatcher, *this);
+  }
+
+
+  template<typename Matcher>
+  auto
+  match(Matcher&& aMatcher)
+    -> decltype(Impl::match(aMatcher, *this))
+  {
+    return Impl::match(aMatcher, *this);
+  }
+};
+# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
+template<typename T>
+detail::AsVariantTemporary<T>
+AsVariant(T&& aValue)
+{
+  return detail::AsVariantTemporary<T>(Forward<T>(aValue));
+}
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 2
+
+namespace mozilla {
+
+
+
+
+
+
+struct Ok {};
+
+template <typename E> class GenericErrorResult;
+template <typename V, typename E> class Result;
+
+namespace detail {
+
+enum class PackingStrategy {
+  Variant,
+  NullIsOk,
+  LowBitTagIsError,
+  PackedVariant,
+};
+
+template <typename V, typename E, PackingStrategy Strategy>
+class ResultImplementation;
+
+template <typename V, typename E>
+class ResultImplementation<V, E, PackingStrategy::Variant>
+{
+  mozilla::Variant<V, E> mStorage;
+
+public:
+  explicit ResultImplementation(V aValue) : mStorage(aValue) {}
+  explicit ResultImplementation(E aErrorValue) : mStorage(aErrorValue) {}
+
+  bool isOk() const { return mStorage.template is<V>(); }
+
+
+
+
+  V unwrap() const { return mStorage.template as<V>(); }
+  E unwrapErr() const { return mStorage.template as<E>(); }
+};
+
+
+
+
+
+template <typename V, typename E>
+class ResultImplementation<V, E&, PackingStrategy::Variant>
+{
+  mozilla::Variant<V, E*> mStorage;
+
+public:
+  explicit ResultImplementation(V aValue) : mStorage(aValue) {}
+  explicit ResultImplementation(E& aErrorValue) : mStorage(&aErrorValue) {}
+
+  bool isOk() const { return mStorage.template is<V>(); }
+  V unwrap() const { return mStorage.template as<V>(); }
+  E& unwrapErr() const { return *mStorage.template as<E*>(); }
+};
+
+
+
+
+
+template <typename V, typename E>
+class ResultImplementation<V, E&, PackingStrategy::NullIsOk>
+{
+  E* mErrorValue;
+
+public:
+  explicit ResultImplementation(V) : mErrorValue(nullptr) {}
+  explicit ResultImplementation(E& aErrorValue) : mErrorValue(&aErrorValue) {}
+
+  bool isOk() const { return mErrorValue == nullptr; }
+
+  V unwrap() const { return V(); }
+  E& unwrapErr() const { return *mErrorValue; }
+};
+
+
+
+
+
+template <typename V, typename E>
+class ResultImplementation<V*, E&, PackingStrategy::LowBitTagIsError>
+{
+  uintptr_t mBits;
+
+public:
+  explicit ResultImplementation(V* aValue)
+    : mBits(reinterpret_cast<uintptr_t>(aValue))
+  {
+    do { } while (0);
+
+  }
+  explicit ResultImplementation(E& aErrorValue)
+    : mBits(reinterpret_cast<uintptr_t>(&aErrorValue) | 1)
+  {
+    do { } while (0);
+
+  }
+
+  bool isOk() const { return (mBits & 1) == 0; }
+
+  V* unwrap() const { return reinterpret_cast<V*>(mBits); }
+  E& unwrapErr() const { return *reinterpret_cast<E*>(mBits ^ 1); }
+};
+
+
+template<typename V, typename E>
+struct IsPackableVariant
+{
+  struct VEbool {
+      V v;
+      E e;
+      bool ok;
+  };
+  struct EVbool {
+      E e;
+      V v;
+      bool ok;
+  };
+
+  using Impl = typename Conditional<sizeof(VEbool) <= sizeof(EVbool),
+                                    VEbool, EVbool>::Type;
+
+  static const bool value = sizeof(Impl) <= sizeof(uintptr_t);
+};
+
+
+
+
+
+template <typename V, typename E>
+class ResultImplementation<V, E, PackingStrategy::PackedVariant>
+{
+  using Impl = typename IsPackableVariant<V, E>::Impl;
+  Impl data;
+
+public:
+  explicit ResultImplementation(V aValue)
+  {
+    data.v = aValue;
+    data.ok = true;
+  }
+  explicit ResultImplementation(E aErrorValue)
+  {
+    data.e = aErrorValue;
+    data.ok = false;
+  }
+
+  bool isOk() const { return data.ok; }
+
+  V unwrap() const { return data.v; }
+  E unwrapErr() const { return data.e; }
+};
+
+
+
+
+
+template<typename T>
+struct UnusedZero
+{
+  static const bool value = false;
+};
+
+
+template<typename T>
+struct UnusedZero<T&>
+{
+  static const bool value = true;
+};
+
+
+
+
+template <typename T> struct HasFreeLSB { static const bool value = false; };
+
+
+
+
+template <typename T> struct HasFreeLSB<T*> {
+  static const bool value = (mozilla::AlignmentFinder<T>::alignment & 1) == 0;
+};
+
+
+
+template <typename T> struct HasFreeLSB<T&> {
+  static const bool value = HasFreeLSB<T*>::value;
+};
+
+
+
+template <typename V, typename E>
+struct SelectResultImpl
+{
+  static const PackingStrategy value =
+      (IsEmpty<V>::value && UnusedZero<E>::value)
+    ? PackingStrategy::NullIsOk
+    : (detail::HasFreeLSB<V>::value && detail::HasFreeLSB<E>::value)
+    ? PackingStrategy::LowBitTagIsError
+    : (IsDefaultConstructible<V>::value && IsDefaultConstructible<E>::value &&
+       IsPackableVariant<V, E>::value)
+    ? PackingStrategy::PackedVariant
+    : PackingStrategy::Variant;
+
+  using Type = detail::ResultImplementation<V, E, value>;
+};
+
+template <typename T>
+struct IsResult : FalseType { };
+
+template <typename V, typename E>
+struct IsResult<Result<V, E>> : TrueType { };
+
+}
+# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
+template <typename V, typename E>
+class Result final
+{
+  using Impl = typename detail::SelectResultImpl<V, E>::Type;
+
+  Impl mImpl;
+
+public:
+
+
+
+               Result(V aValue) : mImpl(aValue) { do { } while (0); }
+
+
+
+
+  explicit Result(E aErrorValue) : mImpl(aErrorValue) { do { } while (0); }
+
+
+
+
+
+  template <typename E2>
+               Result(const GenericErrorResult<E2>& aErrorResult)
+    : mImpl(aErrorResult.mErrorValue)
+  {
+    static_assert(mozilla::IsConvertible<E2, E>::value,
+                  "E2 must be convertible to E");
+    do { } while (0);
+  }
+
+  Result(const Result&) = default;
+  Result& operator=(const Result&) = default;
+
+
+  bool isOk() const { return mImpl.isOk(); }
+
+
+  bool isErr() const { return !mImpl.isOk(); }
+
+
+  V unwrap() const {
+    do { } while (0);
+    return mImpl.unwrap();
+  }
+
+
+  E unwrapErr() const {
+    do { } while (0);
+    return mImpl.unwrapErr();
+  }
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
+  template<typename F>
+  auto map(F f) const -> Result<decltype(f(*((V*) nullptr))), E> {
+      using RetResult = Result<decltype(f(*((V*) nullptr))), E>;
+      return isOk() ? RetResult(f(unwrap())) : RetResult(unwrapErr());
+  }
+# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
+  template<
+      typename F,
+      typename = typename EnableIf<
+          detail::IsResult<decltype((*((F*) nullptr))(*((V*) nullptr)))>::value
+      >::Type
+  >
+  auto andThen(F f) const -> decltype(f(*((V*) nullptr))) {
+      return isOk() ? f(unwrap()) : GenericErrorResult<E>(unwrapErr());
+  }
+};
+
+
+
+
+
+
+
+template <typename E>
+class GenericErrorResult
+{
+  E mErrorValue;
+
+  template<typename V, typename E2> friend class Result;
+
+public:
+  explicit GenericErrorResult(E aErrorValue) : mErrorValue(aErrorValue) {}
+};
+
+template <typename E>
+inline GenericErrorResult<E>
+Err(E&& aErrorValue)
+{
+  return GenericErrorResult<E>(aErrorValue);
+}
+
+}
+# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 2
+
+struct JSContext;
+# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
+namespace JS {
+
+using mozilla::Ok;
+
+
+
+
+
+struct Error
+{
+
+
+    int dummy;
+};
+
+struct OOM : public Error
+{
+};
+# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
+template <typename V = Ok, typename E = Error&>
+using Result = mozilla::Result<V, E>;
+
+static_assert(sizeof(Result<>) == sizeof(uintptr_t),
+              "Result<> should be pointer-sized");
+
+static_assert(sizeof(Result<int*, Error&>) == sizeof(uintptr_t),
+              "Result<V*, Error&> should be pointer-sized");
+
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 2
+
+
+
+
+struct JSContext;
+class JSFunction;
+class JSObject;
+class JSScript;
+class JSString;
+class JSAddonId;
+
+struct jsid;
+
+namespace JS {
+
+typedef unsigned char Latin1Char;
+
+class Symbol;
+class Value;
+template <typename T> class Handle;
+template <typename T> class MutableHandle;
+template <typename T> class Rooted;
+template <typename T> class PersistentRooted;
+
+typedef Handle<JSFunction*> HandleFunction;
+typedef Handle<jsid> HandleId;
+typedef Handle<JSObject*> HandleObject;
+typedef Handle<JSScript*> HandleScript;
+typedef Handle<JSString*> HandleString;
+typedef Handle<JS::Symbol*> HandleSymbol;
+typedef Handle<Value> HandleValue;
+
+typedef MutableHandle<JSFunction*> MutableHandleFunction;
+typedef MutableHandle<jsid> MutableHandleId;
+typedef MutableHandle<JSObject*> MutableHandleObject;
+typedef MutableHandle<JSScript*> MutableHandleScript;
+typedef MutableHandle<JSString*> MutableHandleString;
+typedef MutableHandle<JS::Symbol*> MutableHandleSymbol;
+typedef MutableHandle<Value> MutableHandleValue;
+
+typedef Rooted<JSObject*> RootedObject;
+typedef Rooted<JSFunction*> RootedFunction;
+typedef Rooted<JSScript*> RootedScript;
+typedef Rooted<JSString*> RootedString;
+typedef Rooted<JS::Symbol*> RootedSymbol;
+typedef Rooted<jsid> RootedId;
+typedef Rooted<JS::Value> RootedValue;
+
+typedef PersistentRooted<JSFunction*> PersistentRootedFunction;
+typedef PersistentRooted<jsid> PersistentRootedId;
+typedef PersistentRooted<JSObject*> PersistentRootedObject;
+typedef PersistentRooted<JSScript*> PersistentRootedScript;
+typedef PersistentRooted<JSString*> PersistentRootedString;
+typedef PersistentRooted<JS::Symbol*> PersistentRootedSymbol;
+typedef PersistentRooted<Value> PersistentRootedValue;
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 2
+
+
+namespace js {
+class BaseShape;
+class LazyScript;
+class ObjectGroup;
+class RegExpShared;
+class Shape;
+class Scope;
+namespace jit {
+class JitCode;
+}
+}
+
+namespace JS {
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
+enum class TraceKind
+{
+
+
+
+    Object = 0x00,
+    String = 0x02,
+    Symbol = 0x03,
+
+
+    Script = 0x01,
+
+
+    Shape = 0x04,
+
+
+    ObjectGroup = 0x05,
+
+
+    Null = 0x06,
+
+
+    BaseShape = 0x0F,
+    JitCode = 0x1F,
+    LazyScript = 0x2F,
+    Scope = 0x3F,
+    RegExpShared = 0x4F
+};
+const static uintptr_t OutOfLineTraceKindMask = 0x07;
+static_assert(uintptr_t(JS::TraceKind::BaseShape) & OutOfLineTraceKindMask, "mask bits are set");
+static_assert(uintptr_t(JS::TraceKind::JitCode) & OutOfLineTraceKindMask, "mask bits are set");
+static_assert(uintptr_t(JS::TraceKind::LazyScript) & OutOfLineTraceKindMask, "mask bits are set");
+static_assert(uintptr_t(JS::TraceKind::Scope) & OutOfLineTraceKindMask, "mask bits are set");
+static_assert(uintptr_t(JS::TraceKind::RegExpShared) & OutOfLineTraceKindMask, "mask bits are set");
+
+
+
+
+template <typename T>
+struct MapTypeToTraceKind {
+    static const JS::TraceKind kind = T::TraceKind;
+};
+# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
+template <> struct MapTypeToTraceKind<js::BaseShape> { static const JS::TraceKind kind = JS::TraceKind::BaseShape; }; template <> struct MapTypeToTraceKind<js::jit::JitCode> { static const JS::TraceKind kind = JS::TraceKind::JitCode; }; template <> struct MapTypeToTraceKind<js::LazyScript> { static const JS::TraceKind kind = JS::TraceKind::LazyScript; }; template <> struct MapTypeToTraceKind<js::Scope> { static const JS::TraceKind kind = JS::TraceKind::Scope; }; template <> struct MapTypeToTraceKind<JSObject> { static const JS::TraceKind kind = JS::TraceKind::Object; }; template <> struct MapTypeToTraceKind<js::ObjectGroup> { static const JS::TraceKind kind = JS::TraceKind::ObjectGroup; }; template <> struct MapTypeToTraceKind<JSScript> { static const JS::TraceKind kind = JS::TraceKind::Script; }; template <> struct MapTypeToTraceKind<js::Shape> { static const JS::TraceKind kind = JS::TraceKind::Shape; }; template <> struct MapTypeToTraceKind<JSString> { static const JS::TraceKind kind = JS::TraceKind::String; }; template <> struct MapTypeToTraceKind<JS::Symbol> { static const JS::TraceKind kind = JS::TraceKind::Symbol; }; template <> struct MapTypeToTraceKind<js::RegExpShared> { static const JS::TraceKind kind = JS::TraceKind::RegExpShared; };;
+
+
+
+
+
+enum class RootKind : int8_t
+{
+
+
+
+BaseShape, JitCode, LazyScript, Scope, Object, ObjectGroup, Script, Shape, String, Symbol, RegExpShared,
+
+
+
+    Id,
+    Value,
+
+
+    Traceable,
+
+    Limit
+};
+
+
+template <TraceKind traceKind> struct MapTraceKindToRootKind {};
+
+
+
+
+template <> struct MapTraceKindToRootKind<JS::TraceKind::BaseShape> { static const JS::RootKind kind = JS::RootKind::BaseShape; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::JitCode> { static const JS::RootKind kind = JS::RootKind::JitCode; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::LazyScript> { static const JS::RootKind kind = JS::RootKind::LazyScript; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Scope> { static const JS::RootKind kind = JS::RootKind::Scope; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Object> { static const JS::RootKind kind = JS::RootKind::Object; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::ObjectGroup> { static const JS::RootKind kind = JS::RootKind::ObjectGroup; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Script> { static const JS::RootKind kind = JS::RootKind::Script; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Shape> { static const JS::RootKind kind = JS::RootKind::Shape; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::String> { static const JS::RootKind kind = JS::RootKind::String; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Symbol> { static const JS::RootKind kind = JS::RootKind::Symbol; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::RegExpShared> { static const JS::RootKind kind = JS::RootKind::RegExpShared; };
+
+
+
+
+
+template <typename T>
+struct MapTypeToRootKind {
+    static const JS::RootKind kind = JS::RootKind::Traceable;
+};
+template <typename T>
+struct MapTypeToRootKind<T*> {
+    static const JS::RootKind kind =
+        JS::MapTraceKindToRootKind<JS::MapTypeToTraceKind<T>::kind>::kind;
+};
+template <typename T>
+struct MapTypeToRootKind<mozilla::UniquePtr<T>> {
+    static const JS::RootKind kind = JS::MapTypeToRootKind<T>::kind;
+};
+template <> struct MapTypeToRootKind<JS::Value> {
+    static const JS::RootKind kind = JS::RootKind::Value;
+};
+template <> struct MapTypeToRootKind<jsid> {
+    static const JS::RootKind kind = JS::RootKind::Id;
+};
+template <> struct MapTypeToRootKind<JSFunction*> : public MapTypeToRootKind<JSObject*> {};
+# 183 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
+template <typename F, typename... Args>
+auto
+DispatchTraceKindTyped(F f, JS::TraceKind traceKind, Args&&... args)
+  -> decltype(f. template operator()<JSObject>(mozilla::Forward<Args>(args)...))
+{
+    switch (traceKind) {
+
+
+
+      case JS::TraceKind::BaseShape: return f. template operator()<js::BaseShape>(mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f. template operator()<js::jit::JitCode>(mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f. template operator()<js::LazyScript>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f. template operator()<js::Scope>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f. template operator()<JSObject>(mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f. template operator()<js::ObjectGroup>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f. template operator()<JSScript>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f. template operator()<js::Shape>(mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f. template operator()<JSString>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f. template operator()<JS::Symbol>(mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f. template operator()<js::RegExpShared>(mozilla::Forward<Args>(args)...);;
+
+      default:
+          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 195; ::abort(); } while (0); } while (0);
+    }
+}
+
+
+template <typename F, typename... Args>
+auto
+DispatchTraceKindTyped(F f, void* thing, JS::TraceKind traceKind, Args&&... args)
+  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+{
+    switch (traceKind) {
+
+
+
+      case JS::TraceKind::BaseShape: return f(static_cast<js::BaseShape*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f(static_cast<js::jit::JitCode*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f(static_cast<js::LazyScript*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f(static_cast<js::Scope*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f(static_cast<JSObject*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f(static_cast<js::ObjectGroup*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f(static_cast<JSScript*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f(static_cast<js::Shape*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f(static_cast<JSString*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f(static_cast<JS::Symbol*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f(static_cast<js::RegExpShared*>(thing), mozilla::Forward<Args>(args)...);;
+
+      default:
+          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 212; ::abort(); } while (0); } while (0);
+    }
+}
+
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
+
+
+
+
+
+
+namespace JS {
+
+class AutoIdVector;
+class CallArgs;
+
+template <typename T>
+class Rooted;
+
+class CompileOptions;
+class ReadOnlyCompileOptions;
+class OwningCompileOptions;
+class TransitiveCompileOptions;
+class CompartmentOptions;
+
+class Value;
+struct Zone;
+
+}
+
+
+
+
+
+
+enum JSVersion {
+    JSVERSION_ECMA_3 = 148,
+    JSVERSION_1_6 = 160,
+    JSVERSION_1_7 = 170,
+    JSVERSION_1_8 = 180,
+    JSVERSION_ECMA_5 = 185,
+    JSVERSION_DEFAULT = 0,
+    JSVERSION_UNKNOWN = -1,
+    JSVERSION_LATEST = JSVERSION_ECMA_5
+};
+
+
+enum JSType {
+    JSTYPE_UNDEFINED,
+    JSTYPE_OBJECT,
+    JSTYPE_FUNCTION,
+    JSTYPE_STRING,
+    JSTYPE_NUMBER,
+    JSTYPE_BOOLEAN,
+    JSTYPE_NULL,
+    JSTYPE_SYMBOL,
+    JSTYPE_LIMIT
+};
+
+
+enum JSProtoKey {
+
+    JSProto_Null = 0, JSProto_Object = 1, JSProto_Function = 2, JSProto_Array = 3, JSProto_Boolean = 4, JSProto_JSON = 5, JSProto_Date = 6, JSProto_Math = 7, JSProto_Number = 8, JSProto_String = 9, JSProto_RegExp = 10, JSProto_Error = 11, JSProto_InternalError = 12, JSProto_EvalError = 13, JSProto_RangeError = 14, JSProto_ReferenceError = 15, JSProto_SyntaxError = 16, JSProto_TypeError = 17, JSProto_URIError = 18, JSProto_DebuggeeWouldRun = 19, JSProto_CompileError = 20, JSProto_LinkError = 21, JSProto_RuntimeError = 22, JSProto_Iterator = 23, JSProto_StopIteration = 24, JSProto_ArrayBuffer = 25, JSProto_Int8Array = 26, JSProto_Uint8Array = 27, JSProto_Int16Array = 28, JSProto_Uint16Array = 29, JSProto_Int32Array = 30, JSProto_Uint32Array = 31, JSProto_Float32Array = 32, JSProto_Float64Array = 33, JSProto_Uint8ClampedArray = 34, JSProto_Proxy = 35, JSProto_WeakMap = 36, JSProto_Map = 37, JSProto_Set = 38, JSProto_DataView = 39, JSProto_Symbol = 40, JSProto_SharedArrayBuffer = 41, JSProto_Intl = 42, JSProto_TypedObject = 43, JSProto_Reflect = 44, JSProto_SIMD = 45, JSProto_WeakSet = 46, JSProto_TypedArray = 47, JSProto_Atomics = 48, JSProto_SavedFrame = 49, JSProto_WebAssembly = 50, JSProto_WasmModule = 51, JSProto_WasmInstance = 52, JSProto_WasmMemory = 53, JSProto_WasmTable = 54, JSProto_Promise = 55,
+
+    JSProto_LIMIT
+};
+
+
+struct JSClass;
+struct JSCompartment;
+struct JSCrossCompartmentCall;
+class JSErrorReport;
+struct JSExceptionState;
+struct JSFunctionSpec;
+struct JSLocaleCallbacks;
+struct JSObjectMap;
+struct JSPrincipals;
+struct JSPropertyName;
+struct JSPropertySpec;
+struct JSRuntime;
+struct JSSecurityCallbacks;
+struct JSStructuredCloneCallbacks;
+struct JSStructuredCloneReader;
+struct JSStructuredCloneWriter;
+class JSTracer;
+
+class JSFlatString;
+
+typedef bool (*JSInitCallback)(void);
+
+template<typename T> struct JSConstScalarSpec;
+typedef JSConstScalarSpec<double> JSConstDoubleSpec;
+typedef JSConstScalarSpec<int32_t> JSConstIntegerSpec;
+
+
+
+
+
+typedef void
+(* JSTraceDataOp)(JSTracer* trc, void* data);
+
+namespace js {
+namespace gc {
+class AutoTraceSession;
+class StoreBuffer;
+}
+
+class CooperatingContext;
+
+inline JSCompartment* GetContextCompartment(const JSContext* cx);
+inline JS::Zone* GetContextZone(const JSContext* cx);
+
+
+
+bool
+CurrentThreadCanAccessRuntime(const JSRuntime* rt);
+
+
+
+
+
+
+}
+
+namespace JS {
+
+class AutoEnterCycleCollection;
+class AutoAssertOnBarrier;
+struct PropertyDescriptor;
+
+typedef void (*OffThreadCompileCallback)(void* token, void* callbackData);
+
+enum class HeapState {
+    Idle,
+    Tracing,
+    MajorCollecting,
+    MinorCollecting,
+    CycleCollecting
+};
+
+HeapState
+CurrentThreadHeapState();
+
+static inline bool
+CurrentThreadIsHeapBusy()
+{
+    return CurrentThreadHeapState() != HeapState::Idle;
+}
+
+static inline bool
+CurrentThreadIsHeapTracing()
+{
+    return CurrentThreadHeapState() == HeapState::Tracing;
+}
+
+static inline bool
+CurrentThreadIsHeapMajorCollecting()
+{
+    return CurrentThreadHeapState() == HeapState::MajorCollecting;
+}
+
+static inline bool
+CurrentThreadIsHeapMinorCollecting()
+{
+    return CurrentThreadHeapState() == HeapState::MinorCollecting;
+}
+
+static inline bool
+CurrentThreadIsHeapCollecting()
+{
+    HeapState state = CurrentThreadHeapState();
+    return state == HeapState::MajorCollecting || state == HeapState::MinorCollecting;
+}
+
+static inline bool
+CurrentThreadIsHeapCycleCollecting()
+{
+    return CurrentThreadHeapState() == HeapState::CycleCollecting;
+}
+
+
+
+class AutoEnterCycleCollection
+{
+
+
+
+
+
+
+
+  public:
+    explicit AutoEnterCycleCollection(JSContext* cx) {}
+    ~AutoEnterCycleCollection() {}
+
+};
+
+class RootingContext;
+
+class AutoGCRooter
+{
+  public:
+    AutoGCRooter(JSContext* cx, ptrdiff_t tag);
+    AutoGCRooter(RootingContext* cx, ptrdiff_t tag);
+
+    ~AutoGCRooter() {
+        do { } while (0);
+        *stackTop = down;
+    }
+
+
+    inline void trace(JSTracer* trc);
+    static void traceAll(const js::CooperatingContext& target, JSTracer* trc);
+    static void traceAllWrappers(const js::CooperatingContext& target, JSTracer* trc);
+
+  protected:
+    AutoGCRooter * const down;
+# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
+    ptrdiff_t tag_;
+
+    enum {
+        VALARRAY = -2,
+        PARSER = -3,
+        VALVECTOR = -10,
+        IDVECTOR = -11,
+        OBJVECTOR = -14,
+        IONMASM = -19,
+        WRAPVECTOR = -20,
+        WRAPPER = -21,
+        CUSTOM = -26
+    };
+
+    static ptrdiff_t GetTag(const Value& value) { return VALVECTOR; }
+    static ptrdiff_t GetTag(const jsid& id) { return IDVECTOR; }
+    static ptrdiff_t GetTag(JSObject* obj) { return OBJVECTOR; }
+
+  private:
+    AutoGCRooter ** const stackTop;
+
+
+    AutoGCRooter(AutoGCRooter& ida) = delete;
+    void operator=(AutoGCRooter& ida) = delete;
+};
+
+
+
+template <>
+struct MapTypeToRootKind<void*> {
+    static const RootKind kind = RootKind::Traceable;
+};
+
+using RootedListHeads = mozilla::EnumeratedArray<RootKind, RootKind::Limit,
+                                                 Rooted<void*>*>;
+
+
+
+
+
+
+enum StackKind
+{
+    StackForSystemCode,
+    StackForTrustedScript,
+    StackForUntrustedScript,
+    StackKindCount
+};
+
+
+
+class RootingContext
+{
+
+    RootedListHeads stackRoots_;
+    template <typename T> friend class JS::Rooted;
+
+
+    JS::AutoGCRooter* autoGCRooters_;
+    friend class JS::AutoGCRooter;
+
+  public:
+    RootingContext();
+
+    void traceStackRoots(JSTracer* trc);
+    void checkNoGCRooters();
+
+  protected:
+
+
+
+
+
+    JSCompartment* compartment_;
+
+
+    JS::Zone* zone_;
+
+  public:
+
+    uintptr_t nativeStackLimit[StackKindCount];
+
+    static const RootingContext* get(const JSContext* cx) {
+        return reinterpret_cast<const RootingContext*>(cx);
+    }
+
+    static RootingContext* get(JSContext* cx) {
+        return reinterpret_cast<RootingContext*>(cx);
+    }
+
+    friend JSCompartment* js::GetContextCompartment(const JSContext* cx);
+    friend JS::Zone* js::GetContextZone(const JSContext* cx);
+};
+
+}
+
+namespace js {
+# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
+inline JSCompartment*
+GetContextCompartment(const JSContext* cx)
+{
+    return JS::RootingContext::get(cx)->compartment_;
+}
+
+inline JS::Zone*
+GetContextZone(const JSContext* cx)
+{
+    return JS::RootingContext::get(cx)->zone_;
+}
+
+}
+
+extern "C" {
+
+
+typedef struct PRFileDesc PRFileDesc;
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 1
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+namespace mozilla {
+# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+enum MemoryOrdering {
+# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+  Relaxed,
+# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+  ReleaseAcquire,
+# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+  SequentiallyConsistent,
+};
+
+}
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 1 3
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 3
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
+# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
+  typedef enum memory_order
+    {
+      memory_order_relaxed,
+      memory_order_consume,
+      memory_order_acquire,
+      memory_order_release,
+      memory_order_acq_rel,
+      memory_order_seq_cst
+    } memory_order;
+
+  enum __memory_order_modifier
+    {
+      __memory_order_mask = 0x0ffff,
+      __memory_order_modifier_mask = 0xffff0000,
+      __memory_order_hle_acquire = 0x10000,
+      __memory_order_hle_release = 0x20000
+    };
+
+  constexpr memory_order
+  operator|(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m | int(__mod));
+  }
+
+  constexpr memory_order
+  operator&(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m & int(__mod));
+  }
+
+
+  constexpr memory_order
+  __cmpexch_failure_order2(memory_order __m) noexcept
+  {
+    return __m == memory_order_acq_rel ? memory_order_acquire
+      : __m == memory_order_release ? memory_order_relaxed : __m;
+  }
+
+  constexpr memory_order
+  __cmpexch_failure_order(memory_order __m) noexcept
+  {
+    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
+      | (__m & __memory_order_modifier_mask));
+  }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_thread_fence(memory_order __m) noexcept
+  { __atomic_thread_fence(__m); }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_signal_fence(memory_order __m) noexcept
+  { __atomic_signal_fence(__m); }
+
+
+  template<typename _Tp>
+    inline _Tp
+    kill_dependency(_Tp __y) noexcept
+    {
+      _Tp __ret(__y);
+      return __ret;
+    }
+
+
+
+  template<typename _IntTp>
+    struct __atomic_base;
+
+
+
+
+  template<typename _Tp>
+    struct atomic;
+
+  template<typename _Tp>
+    struct atomic<_Tp*>;
+
+
+
+    typedef bool __atomic_flag_data_type;
+# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
+  extern "C" {
+
+  struct __atomic_flag_base
+  {
+    __atomic_flag_data_type _M_i;
+  };
+
+  }
+
+
+
+
+  struct atomic_flag : public __atomic_flag_base
+  {
+    atomic_flag() noexcept = default;
+    ~atomic_flag() noexcept = default;
+    atomic_flag(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+
+
+    constexpr atomic_flag(bool __i) noexcept
+      : __atomic_flag_base{ _S_init(__i) }
+    { }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+                                                   ;
+                                                   ;
+                                                   ;
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+                                                   ;
+                                                   ;
+                                                   ;
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+  private:
+    static constexpr __atomic_flag_data_type
+    _S_init(bool __i)
+    { return __i ? 1 : 0; }
+  };
+# 237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
+  template<typename _ITp>
+    struct __atomic_base
+    {
+    private:
+      typedef _ITp __int_type;
+
+      static constexpr int _S_alignment =
+ sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
+
+      alignas(_S_alignment) __int_type _M_i;
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
+
+      operator __int_type() const noexcept
+      { return load(); }
+
+      operator __int_type() const volatile noexcept
+      { return load(); }
+
+      __int_type
+      operator=(__int_type __i) noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator=(__int_type __i) volatile noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) volatile noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) volatile noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) volatile noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) volatile noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+                                              ;
+
+ __atomic_store_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+                                              ;
+
+ __atomic_store_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+       memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+
+ return __atomic_load_n(&_M_i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+
+ return __atomic_load_n(&_M_i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1, memory_order __m2) noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1, memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+   memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+    };
+
+
+
+  template<typename _PTp>
+    struct __atomic_base<_PTp*>
+    {
+    private:
+      typedef _PTp* __pointer_type;
+
+      __pointer_type _M_p;
+
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
+
+      operator __pointer_type() const noexcept
+      { return load(); }
+
+      operator __pointer_type() const volatile noexcept
+      { return load(); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+
+                                              ;
+                                              ;
+                                              ;
+
+ __atomic_store_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+                                              ;
+
+ __atomic_store_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+
+ return __atomic_load_n(&_M_p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+                                              ;
+                                              ;
+
+ return __atomic_load_n(&_M_p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+                                               ;
+                                               ;
+                               ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+    };
+
+
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct atomic;
+
+
+
+  template<>
+  struct atomic<bool>
+  {
+  private:
+    __atomic_base<bool> _M_base;
+
+  public:
+    atomic() noexcept = default;
+    ~atomic() noexcept = default;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+
+    constexpr atomic(bool __i) noexcept : _M_base(__i) { }
+
+    bool
+    operator=(bool __i) noexcept
+    { return _M_base.operator=(__i); }
+
+    bool
+    operator=(bool __i) volatile noexcept
+    { return _M_base.operator=(__i); }
+
+    operator bool() const noexcept
+    { return _M_base.load(); }
+
+    operator bool() const volatile noexcept
+    { return _M_base.load(); }
+
+    bool
+    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
+
+    bool
+    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { _M_base.store(__i, __m); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+    { _M_base.store(__i, __m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    exchange(bool __i,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+     memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+  };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct atomic
+    {
+    private:
+
+      static constexpr int _S_min_alignment
+ = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
+ ? 0 : sizeof(_Tp);
+
+      static constexpr int _S_alignment
+        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
+
+      alignas(_S_alignment) _Tp _M_i;
+
+      static_assert(__is_trivially_copyable(_Tp),
+      "std::atomic requires a trivially copyable type");
+
+      static_assert(sizeof(_Tp) > 0,
+      "Incomplete or zero-sized types are not supported");
+
+    public:
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
+
+      operator _Tp() const noexcept
+      { return load(); }
+
+      operator _Tp() const volatile noexcept
+      { return load(); }
+
+      _Tp
+      operator=(_Tp __i) noexcept
+      { store(__i); return __i; }
+
+      _Tp
+      operator=(_Tp __i) volatile noexcept
+      { store(__i); return __i; }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      { __atomic_store(&_M_i, &__i, __m); }
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+      { __atomic_store(&_M_i, &__i, __m); }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+        _Tp tmp;
+ __atomic_load(&_M_i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        _Tp tmp;
+ __atomic_load(&_M_i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        _Tp tmp;
+ __atomic_exchange(&_M_i, &__i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        _Tp tmp;
+ __atomic_exchange(&_M_i, &__i, &tmp, __m);
+ return tmp;
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+          memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+    };
+
+
+
+  template<typename _Tp>
+    struct atomic<_Tp*>
+    {
+      typedef _Tp* __pointer_type;
+      typedef __atomic_base<_Tp*> __base_type;
+      __base_type _M_b;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
+
+      operator __pointer_type() const noexcept
+      { return __pointer_type(_M_b); }
+
+      operator __pointer_type() const volatile noexcept
+      { return __pointer_type(_M_b); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator++() noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator--() noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return _M_b.operator-=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator-=(__d); }
+
+      bool
+      is_lock_free() const noexcept
+      { return _M_b.is_lock_free(); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return _M_b.is_lock_free(); }
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.store(__p, __m); }
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.store(__p, __m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+    };
+
+
+
+  template<>
+    struct atomic<char> : __atomic_base<char>
+    {
+      typedef char __integral_type;
+      typedef __atomic_base<char> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<signed char> : __atomic_base<signed char>
+    {
+      typedef signed char __integral_type;
+      typedef __atomic_base<signed char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned char> : __atomic_base<unsigned char>
+    {
+      typedef unsigned char __integral_type;
+      typedef __atomic_base<unsigned char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<short> : __atomic_base<short>
+    {
+      typedef short __integral_type;
+      typedef __atomic_base<short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned short> : __atomic_base<unsigned short>
+    {
+      typedef unsigned short __integral_type;
+      typedef __atomic_base<unsigned short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<int> : __atomic_base<int>
+    {
+      typedef int __integral_type;
+      typedef __atomic_base<int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned int> : __atomic_base<unsigned int>
+    {
+      typedef unsigned int __integral_type;
+      typedef __atomic_base<unsigned int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<long> : __atomic_base<long>
+    {
+      typedef long __integral_type;
+      typedef __atomic_base<long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned long> : __atomic_base<unsigned long>
+    {
+      typedef unsigned long __integral_type;
+      typedef __atomic_base<unsigned long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<long long> : __atomic_base<long long>
+    {
+      typedef long long __integral_type;
+      typedef __atomic_base<long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
+    {
+      typedef unsigned long long __integral_type;
+      typedef __atomic_base<unsigned long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<wchar_t> : __atomic_base<wchar_t>
+    {
+      typedef wchar_t __integral_type;
+      typedef __atomic_base<wchar_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<char16_t> : __atomic_base<char16_t>
+    {
+      typedef char16_t __integral_type;
+      typedef __atomic_base<char16_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<char32_t> : __atomic_base<char32_t>
+    {
+      typedef char32_t __integral_type;
+      typedef __atomic_base<char32_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+
+  typedef atomic<bool> atomic_bool;
+
+
+  typedef atomic<char> atomic_char;
+
+
+  typedef atomic<signed char> atomic_schar;
+
+
+  typedef atomic<unsigned char> atomic_uchar;
+
+
+  typedef atomic<short> atomic_short;
+
+
+  typedef atomic<unsigned short> atomic_ushort;
+
+
+  typedef atomic<int> atomic_int;
+
+
+  typedef atomic<unsigned int> atomic_uint;
+
+
+  typedef atomic<long> atomic_long;
+
+
+  typedef atomic<unsigned long> atomic_ulong;
+
+
+  typedef atomic<long long> atomic_llong;
+
+
+  typedef atomic<unsigned long long> atomic_ullong;
+
+
+  typedef atomic<wchar_t> atomic_wchar_t;
+
+
+  typedef atomic<char16_t> atomic_char16_t;
+
+
+  typedef atomic<char32_t> atomic_char32_t;
+
+
+
+  typedef atomic<int_least8_t> atomic_int_least8_t;
+
+
+  typedef atomic<uint_least8_t> atomic_uint_least8_t;
+
+
+  typedef atomic<int_least16_t> atomic_int_least16_t;
+
+
+  typedef atomic<uint_least16_t> atomic_uint_least16_t;
+
+
+  typedef atomic<int_least32_t> atomic_int_least32_t;
+
+
+  typedef atomic<uint_least32_t> atomic_uint_least32_t;
+
+
+  typedef atomic<int_least64_t> atomic_int_least64_t;
+
+
+  typedef atomic<uint_least64_t> atomic_uint_least64_t;
+
+
+
+  typedef atomic<int_fast8_t> atomic_int_fast8_t;
+
+
+  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
+
+
+  typedef atomic<int_fast16_t> atomic_int_fast16_t;
+
+
+  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
+
+
+  typedef atomic<int_fast32_t> atomic_int_fast32_t;
+
+
+  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
+
+
+  typedef atomic<int_fast64_t> atomic_int_fast64_t;
+
+
+  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
+
+
+
+  typedef atomic<intptr_t> atomic_intptr_t;
+
+
+  typedef atomic<uintptr_t> atomic_uintptr_t;
+
+
+  typedef atomic<size_t> atomic_size_t;
+
+
+  typedef atomic<intmax_t> atomic_intmax_t;
+
+
+  typedef atomic<uintmax_t> atomic_uintmax_t;
+
+
+  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
+
+
+
+  inline bool
+  atomic_flag_test_and_set_explicit(atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline bool
+  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline bool
+  atomic_flag_test_and_set(atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline bool
+  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(volatile atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const volatile atomic<_ITp>* __a,
+    memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
+         _ITp* __i1, _ITp __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
+         _ITp* __i1, _ITp __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+
+  template<typename _ITp>
+    inline void
+    atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const volatile atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(atomic<_ITp>* __a,
+     _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
+     _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+
+
+
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
+         ptrdiff_t __d, memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+
+
+
+}
+# 171 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 2
+
+namespace mozilla {
+namespace detail {
+
+
+
+
+
+template<MemoryOrdering Order> struct AtomicOrderConstraints;
+
+template<>
+struct AtomicOrderConstraints<Relaxed>
+{
+  static const std::memory_order AtomicRMWOrder = std::memory_order_relaxed;
+  static const std::memory_order LoadOrder = std::memory_order_relaxed;
+  static const std::memory_order StoreOrder = std::memory_order_relaxed;
+  static const std::memory_order CompareExchangeFailureOrder =
+    std::memory_order_relaxed;
+};
+
+template<>
+struct AtomicOrderConstraints<ReleaseAcquire>
+{
+  static const std::memory_order AtomicRMWOrder = std::memory_order_acq_rel;
+  static const std::memory_order LoadOrder = std::memory_order_acquire;
+  static const std::memory_order StoreOrder = std::memory_order_release;
+  static const std::memory_order CompareExchangeFailureOrder =
+    std::memory_order_acquire;
+};
+
+template<>
+struct AtomicOrderConstraints<SequentiallyConsistent>
+{
+  static const std::memory_order AtomicRMWOrder = std::memory_order_seq_cst;
+  static const std::memory_order LoadOrder = std::memory_order_seq_cst;
+  static const std::memory_order StoreOrder = std::memory_order_seq_cst;
+  static const std::memory_order CompareExchangeFailureOrder =
+    std::memory_order_seq_cst;
+};
+
+template<typename T, MemoryOrdering Order>
+struct IntrinsicBase
+{
+  typedef std::atomic<T> ValueType;
+  typedef AtomicOrderConstraints<Order> OrderedOp;
+};
+
+template<typename T, MemoryOrdering Order>
+struct IntrinsicMemoryOps : public IntrinsicBase<T, Order>
+{
+  typedef IntrinsicBase<T, Order> Base;
+
+  static T load(const typename Base::ValueType& aPtr)
+  {
+    return aPtr.load(Base::OrderedOp::LoadOrder);
+  }
+
+  static void store(typename Base::ValueType& aPtr, T aVal)
+  {
+    aPtr.store(aVal, Base::OrderedOp::StoreOrder);
+  }
+
+  static T exchange(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.exchange(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+
+  static bool compareExchange(typename Base::ValueType& aPtr,
+                              T aOldVal, T aNewVal)
+  {
+    return aPtr.compare_exchange_strong(aOldVal, aNewVal,
+                                        Base::OrderedOp::AtomicRMWOrder,
+                                        Base::OrderedOp::CompareExchangeFailureOrder);
+  }
+};
+
+template<typename T, MemoryOrdering Order>
+struct IntrinsicAddSub : public IntrinsicBase<T, Order>
+{
+  typedef IntrinsicBase<T, Order> Base;
+
+  static T add(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+
+  static T sub(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+};
+
+template<typename T, MemoryOrdering Order>
+struct IntrinsicAddSub<T*, Order> : public IntrinsicBase<T*, Order>
+{
+  typedef IntrinsicBase<T*, Order> Base;
+
+  static T* add(typename Base::ValueType& aPtr, ptrdiff_t aVal)
+  {
+    return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+
+  static T* sub(typename Base::ValueType& aPtr, ptrdiff_t aVal)
+  {
+    return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+};
+
+template<typename T, MemoryOrdering Order>
+struct IntrinsicIncDec : public IntrinsicAddSub<T, Order>
+{
+  typedef IntrinsicBase<T, Order> Base;
+
+  static T inc(typename Base::ValueType& aPtr)
+  {
+    return IntrinsicAddSub<T, Order>::add(aPtr, 1);
+  }
+
+  static T dec(typename Base::ValueType& aPtr)
+  {
+    return IntrinsicAddSub<T, Order>::sub(aPtr, 1);
+  }
+};
+
+template<typename T, MemoryOrdering Order>
+struct AtomicIntrinsics : public IntrinsicMemoryOps<T, Order>,
+                          public IntrinsicIncDec<T, Order>
+{
+  typedef IntrinsicBase<T, Order> Base;
+
+  static T or_(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.fetch_or(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+
+  static T xor_(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.fetch_xor(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+
+  static T and_(typename Base::ValueType& aPtr, T aVal)
+  {
+    return aPtr.fetch_and(aVal, Base::OrderedOp::AtomicRMWOrder);
+  }
+};
+
+template<typename T, MemoryOrdering Order>
+struct AtomicIntrinsics<T*, Order>
+  : public IntrinsicMemoryOps<T*, Order>, public IntrinsicIncDec<T*, Order>
+{
+};
+
+template<typename T>
+struct ToStorageTypeArgument
+{
+  static constexpr T convert (T aT) { return aT; }
+};
+
+}
+}
+# 533 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+namespace mozilla {
+
+namespace detail {
+
+template<typename T, MemoryOrdering Order>
+class AtomicBase
+{
+  static_assert(sizeof(T) == 4 || sizeof(T) == 8,
+                "mozilla/Atomics.h only supports 32-bit and 64-bit types");
+
+protected:
+  typedef typename detail::AtomicIntrinsics<T, Order> Intrinsics;
+  typedef typename Intrinsics::ValueType ValueType;
+  ValueType mValue;
+
+public:
+  constexpr AtomicBase() : mValue() {}
+  explicit constexpr AtomicBase(T aInit)
+    : mValue(ToStorageTypeArgument<T>::convert(aInit))
+  {}
+
+
+
+
+
+
+  T operator=(T aVal)
+  {
+    Intrinsics::store(mValue, aVal);
+    return aVal;
+  }
+
+
+
+
+
+  T exchange(T aVal)
+  {
+    return Intrinsics::exchange(mValue, aVal);
+  }
+# 585 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+  bool compareExchange(T aOldValue, T aNewValue)
+  {
+    return Intrinsics::compareExchange(mValue, aOldValue, aNewValue);
+  }
+
+private:
+  template<MemoryOrdering AnyOrder>
+  AtomicBase(const AtomicBase<T, AnyOrder>& aCopy) = delete;
+};
+
+template<typename T, MemoryOrdering Order>
+class AtomicBaseIncDec : public AtomicBase<T, Order>
+{
+  typedef typename detail::AtomicBase<T, Order> Base;
+
+public:
+  constexpr AtomicBaseIncDec() : Base() {}
+  explicit constexpr AtomicBaseIncDec(T aInit) : Base(aInit) {}
+
+  using Base::operator=;
+
+  operator T() const { return Base::Intrinsics::load(Base::mValue); }
+  T operator++(int) { return Base::Intrinsics::inc(Base::mValue); }
+  T operator--(int) { return Base::Intrinsics::dec(Base::mValue); }
+  T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; }
+  T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; }
+
+private:
+  template<MemoryOrdering AnyOrder>
+  AtomicBaseIncDec(const AtomicBaseIncDec<T, AnyOrder>& aCopy) = delete;
+};
+
+}
+# 636 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+template<typename T,
+         MemoryOrdering Order = SequentiallyConsistent,
+         typename Enable = void>
+class Atomic;
+# 649 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+template<typename T, MemoryOrdering Order>
+class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value &&
+                       !IsSame<T, bool>::value>::Type>
+  : public detail::AtomicBaseIncDec<T, Order>
+{
+  typedef typename detail::AtomicBaseIncDec<T, Order> Base;
+
+public:
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T aInit) : Base(aInit) {}
+
+  using Base::operator=;
+
+  T operator+=(T aDelta)
+  {
+    return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
+  }
+
+  T operator-=(T aDelta)
+  {
+    return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta;
+  }
+
+  T operator|=(T aVal)
+  {
+    return Base::Intrinsics::or_(Base::mValue, aVal) | aVal;
+  }
+
+  T operator^=(T aVal)
+  {
+    return Base::Intrinsics::xor_(Base::mValue, aVal) ^ aVal;
+  }
+
+  T operator&=(T aVal)
+  {
+    return Base::Intrinsics::and_(Base::mValue, aVal) & aVal;
+  }
+
+private:
+  Atomic(Atomic<T, Order>& aOther) = delete;
+};
+# 699 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+template<typename T, MemoryOrdering Order>
+class Atomic<T*, Order> : public detail::AtomicBaseIncDec<T*, Order>
+{
+  typedef typename detail::AtomicBaseIncDec<T*, Order> Base;
+
+public:
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T* aInit) : Base(aInit) {}
+
+  using Base::operator=;
+
+  T* operator+=(ptrdiff_t aDelta)
+  {
+    return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
+  }
+
+  T* operator-=(ptrdiff_t aDelta)
+  {
+    return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta;
+  }
+
+private:
+  Atomic(Atomic<T*, Order>& aOther) = delete;
+};
+
+
+
+
+
+
+template<typename T, MemoryOrdering Order>
+class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type>
+  : public detail::AtomicBase<T, Order>
+{
+  typedef typename detail::AtomicBase<T, Order> Base;
+
+public:
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T aInit) : Base(aInit) {}
+
+  operator T() const { return T(Base::Intrinsics::load(Base::mValue)); }
+
+  using Base::operator=;
+
+private:
+  Atomic(Atomic<T, Order>& aOther) = delete;
+};
+# 763 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
+template<MemoryOrdering Order>
+class Atomic<bool, Order>
+  : protected detail::AtomicBase<uint32_t, Order>
+{
+  typedef typename detail::AtomicBase<uint32_t, Order> Base;
+
+public:
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(bool aInit) : Base(aInit) {}
+
+
+               operator bool() const
+  {
+    return Base::Intrinsics::load(Base::mValue);
+  }
+
+  bool operator=(bool aVal)
+  {
+    return Base::operator=(aVal);
+  }
+
+  bool exchange(bool aVal)
+  {
+    return Base::exchange(aVal);
+  }
+
+  bool compareExchange(bool aOldValue, bool aNewValue)
+  {
+    return Base::compareExchange(aOldValue, aNewValue);
+  }
+
+private:
+  Atomic(Atomic<bool, Order>& aOther) = delete;
+};
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 1
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/GuardObjects.h" 1
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 2
+
+
+namespace mozilla {
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
+template<typename Traits>
+class Scoped
+{
+public:
+  typedef typename Traits::type Resource;
+
+  explicit Scoped()
+    : mValue(Traits::empty())
+  {
+    do { } while (0);
+  }
+
+  explicit Scoped(const Resource& aValue
+                                                 )
+    : mValue(aValue)
+  {
+    do { } while (0);
+  }
+
+
+  Scoped(Scoped&& aOther
+                                        )
+    : mValue(Move(aOther.mValue))
+  {
+    do { } while (0);
+    aOther.mValue = Traits::empty();
+  }
+
+  ~Scoped() { Traits::release(mValue); }
+
+
+  operator const Resource&() const { return mValue; }
+  const Resource& operator->() const { return mValue; }
+  const Resource& get() const { return mValue; }
+
+  Resource& rwget() { return mValue; }
+# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
+  Resource forget()
+  {
+    Resource tmp = mValue;
+    mValue = Traits::empty();
+    return tmp;
+  }
+
+
+
+
+
+
+  void dispose()
+  {
+    Traits::release(mValue);
+    mValue = Traits::empty();
+  }
+
+  bool operator==(const Resource& aOther) const { return mValue == aOther; }
+# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
+  Scoped& operator=(const Resource& aOther) { return reset(aOther); }
+
+  Scoped& reset(const Resource& aOther)
+  {
+    Traits::release(mValue);
+    mValue = aOther;
+    return *this;
+  }
+
+
+  Scoped& operator=(Scoped&& aRhs)
+  {
+    do { } while (0);
+    this->~Scoped();
+    new(this) Scoped(Move(aRhs));
+    return *this;
+  }
+
+private:
+  explicit Scoped(const Scoped& aValue) = delete;
+  Scoped& operator=(const Scoped& aValue) = delete;
+
+private:
+  Resource mValue;
+
+};
+# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
+template <typename T> void TypeSpecificDelete(T* aValue);
+
+template <typename T>
+struct TypeSpecificScopedPointerTraits
+{
+  typedef T* type;
+  static type empty() { return nullptr; }
+  static void release(type aValue)
+  {
+    if (aValue) {
+      TypeSpecificDelete(aValue);
+    }
+  }
+};
+
+template<typename Type> struct TypeSpecificScopedPointer : public mozilla::Scoped<TypeSpecificScopedPointerTraits<Type> > { typedef mozilla::Scoped<TypeSpecificScopedPointerTraits<Type> > Super; typedef typename Super::Resource Resource; TypeSpecificScopedPointer& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit TypeSpecificScopedPointer() : Super() {} explicit TypeSpecificScopedPointer(Resource aRhs ) : Super(aRhs ) {} TypeSpecificScopedPointer(TypeSpecificScopedPointer&& aRhs ) : Super(Move(aRhs) ) {} private: explicit TypeSpecificScopedPointer(TypeSpecificScopedPointer&) = delete; TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&) = delete; };
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+namespace JS {}
+
+
+namespace mozilla {}
+
+
+namespace js {}
+
+
+
+
+extern __attribute__((noreturn)) __attribute__ ((cold)) void
+JS_Assert(const char* s, const char* file, int ln);
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+namespace js {
+namespace oom {
+
+
+
+
+
+
+
+enum ThreadType {
+    THREAD_TYPE_NONE = 0,
+    THREAD_TYPE_COOPERATING,
+    THREAD_TYPE_WASM,
+    THREAD_TYPE_ION,
+    THREAD_TYPE_PARSE,
+    THREAD_TYPE_COMPRESS,
+    THREAD_TYPE_GCHELPER,
+    THREAD_TYPE_GCPARALLEL,
+    THREAD_TYPE_PROMISE_TASK,
+    THREAD_TYPE_MAX
+};
+# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+inline bool InitThreadType(void) { return true; }
+inline void SetThreadType(ThreadType t) {};
+inline uint32_t GetThreadType(void) { return 0; }
+
+
+}
+}
+# 169 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+namespace js {
+namespace oom {
+static inline bool IsSimulatedOOMAllocation() { return false; }
+static inline bool ShouldFailWithOOM() { return false; }
+}
+}
+
+
+
+namespace js {
+
+
+struct AutoEnterOOMUnsafeRegion
+{
+    __attribute__((noreturn)) __attribute__ ((cold)) void crash(const char* reason);
+    __attribute__((noreturn)) __attribute__ ((cold)) void crash(size_t size, const char* reason);
+
+    using AnnotateOOMAllocationSizeCallback = void(*)(size_t);
+    static AnnotateOOMAllocationSizeCallback annotateOOMSizeCallback;
+    static void setAnnotateOOMAllocationSizeCallback(AnnotateOOMAllocationSizeCallback callback) {
+        annotateOOMSizeCallback = callback;
+    }
+# 222 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+};
+
+}
+
+static inline void* js_malloc(size_t bytes)
+{
+    do {} while(0);
+    return malloc(bytes);
+}
+
+static inline void* js_calloc(size_t bytes)
+{
+    do {} while(0);
+    return calloc(bytes, 1);
+}
+
+static inline void* js_calloc(size_t nmemb, size_t size)
+{
+    do {} while(0);
+    return calloc(nmemb, size);
+}
+
+static inline void* js_realloc(void* p, size_t bytes)
+{
+
+
+
+    do { } while (0);
+
+    do {} while(0);
+    return realloc(p, bytes);
+}
+
+static inline void js_free(void* p)
+{
+    free(p);
+}
+
+static inline char* js_strdup(const char* s)
+{
+    do {} while(0);
+    return strdup(s);
+}
+# 346 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+template <class T, typename... Args> static __attribute__((always_inline)) inline T * js_new(Args&&... args) { void* memory = js_malloc(sizeof(T)); return (__builtin_expect(!!(memory), 1)) ? new(memory) T(mozilla::Forward<Args>(args)...) : nullptr; }
+
+namespace js {
+
+
+
+
+
+template <typename T>
+__attribute__ ((warn_unused_result)) inline bool
+CalculateAllocSize(size_t numElems, size_t* bytesOut)
+{
+    *bytesOut = numElems * sizeof(T);
+    return (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) == 0;
+}
+
+
+
+
+
+
+template <typename T, typename Extra>
+__attribute__ ((warn_unused_result)) inline bool
+CalculateAllocSizeWithExtra(size_t numExtra, size_t* bytesOut)
+{
+    *bytesOut = sizeof(T) + numExtra * sizeof(Extra);
+    return (numExtra & mozilla::tl::MulOverflowMask<sizeof(Extra)>::value) == 0 &&
+           *bytesOut >= sizeof(T);
+}
+
+}
+
+template <class T>
+static __attribute__((always_inline)) inline void
+js_delete(const T* p)
+{
+    if (p) {
+        p->~T();
+        js_free(const_cast<T*>(p));
+    }
+}
+
+template<class T>
+static __attribute__((always_inline)) inline void
+js_delete_poison(const T* p)
+{
+    if (p) {
+        p->~T();
+        memset(const_cast<T*>(p), 0x3B, sizeof(T));
+        js_free(const_cast<T*>(p));
+    }
+}
+
+template <class T>
+static __attribute__((always_inline)) inline T*
+js_pod_malloc()
+{
+    return static_cast<T*>(js_malloc(sizeof(T)));
+}
+
+template <class T>
+static __attribute__((always_inline)) inline T*
+js_pod_calloc()
+{
+    return static_cast<T*>(js_calloc(sizeof(T)));
+}
+
+template <class T>
+static __attribute__((always_inline)) inline T*
+js_pod_malloc(size_t numElems)
+{
+    size_t bytes;
+    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems, &bytes)), 0)))
+        return nullptr;
+    return static_cast<T*>(js_malloc(bytes));
+}
+
+template <class T>
+static __attribute__((always_inline)) inline T*
+js_pod_calloc(size_t numElems)
+{
+    size_t bytes;
+    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems, &bytes)), 0)))
+        return nullptr;
+    return static_cast<T*>(js_calloc(bytes));
+}
+
+template <class T>
+static __attribute__((always_inline)) inline T*
+js_pod_realloc(T* prior, size_t oldSize, size_t newSize)
+{
+    do { } while (0);
+    size_t bytes;
+    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(newSize, &bytes)), 0)))
+        return nullptr;
+    return static_cast<T*>(js_realloc(prior, bytes));
+}
+
+namespace js {
+
+template<typename T>
+struct ScopedFreePtrTraits
+{
+    typedef T* type;
+    static T* empty() { return nullptr; }
+    static void release(T* ptr) { js_free(ptr); }
+};
+template<typename Type> struct ScopedJSFreePtr : public mozilla::Scoped<ScopedFreePtrTraits<Type> > { typedef mozilla::Scoped<ScopedFreePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedJSFreePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSFreePtr& operator=(ScopedJSFreePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSFreePtr() : Super() {} explicit ScopedJSFreePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSFreePtr(ScopedJSFreePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSFreePtr(ScopedJSFreePtr&) = delete; ScopedJSFreePtr& operator=(ScopedJSFreePtr&) = delete; };
+
+template <typename T>
+struct ScopedDeletePtrTraits : public ScopedFreePtrTraits<T>
+{
+    static void release(T* ptr) { js_delete(ptr); }
+};
+template<typename Type> struct ScopedJSDeletePtr : public mozilla::Scoped<ScopedDeletePtrTraits<Type> > { typedef mozilla::Scoped<ScopedDeletePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedJSDeletePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSDeletePtr() : Super() {} explicit ScopedJSDeletePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSDeletePtr(ScopedJSDeletePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSDeletePtr(ScopedJSDeletePtr&) = delete; ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&) = delete; };
+
+template <typename T>
+struct ScopedReleasePtrTraits : public ScopedFreePtrTraits<T>
+{
+    static void release(T* ptr) { if (ptr) ptr->release(); }
+};
+template<typename Type> struct ScopedReleasePtr : public mozilla::Scoped<ScopedReleasePtrTraits<Type> > { typedef mozilla::Scoped<ScopedReleasePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedReleasePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedReleasePtr& operator=(ScopedReleasePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedReleasePtr() : Super() {} explicit ScopedReleasePtr(Resource aRhs ) : Super(aRhs ) {} ScopedReleasePtr(ScopedReleasePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedReleasePtr(ScopedReleasePtr&) = delete; ScopedReleasePtr& operator=(ScopedReleasePtr&) = delete; };
+
+}
+
+namespace JS {
+
+template<typename T>
+struct DeletePolicy
+{
+    constexpr DeletePolicy() {}
+
+    template<typename U>
+                 DeletePolicy(DeletePolicy<U> other,
+                              typename mozilla::EnableIf<mozilla::IsConvertible<U*, T*>::value,
+                                                         int>::Type dummy = 0)
+    {}
+
+    void operator()(const T* ptr) {
+        js_delete(const_cast<T*>(ptr));
+    }
+};
+
+struct FreePolicy
+{
+    void operator()(const void* ptr) {
+        js_free(const_cast<void*>(ptr));
+    }
+};
+
+typedef mozilla::UniquePtr<char[], JS::FreePolicy> UniqueChars;
+typedef mozilla::UniquePtr<char16_t[], JS::FreePolicy> UniqueTwoByteChars;
+
+}
+
+namespace js {
+
+
+typedef uint32_t HashNumber;
+const unsigned HashNumberSizeBits = 32;
+
+namespace detail {
+# 524 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+inline HashNumber
+ScrambleHashCode(HashNumber h)
+{
+# 542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
+    static const HashNumber goldenRatio = 0x9E3779B9U;
+    return h * goldenRatio;
+}
+
+}
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 2
+
+
+namespace js {
+
+bool
+CurrentThreadCanAccessZone(JS::Zone* zone);
+
+namespace gc {
+
+struct Cell;
+
+const size_t ArenaShift = 12;
+const size_t ArenaSize = size_t(1) << ArenaShift;
+const size_t ArenaMask = ArenaSize - 1;
+
+
+
+
+const size_t ChunkShift = 20;
+
+const size_t ChunkSize = size_t(1) << ChunkShift;
+const size_t ChunkMask = ChunkSize - 1;
+
+const size_t CellShift = 3;
+const size_t CellSize = size_t(1) << CellShift;
+const size_t CellMask = CellSize - 1;
+
+
+
+
+
+
+const size_t ChunkMarkBitmapOffset = 1032352;
+const size_t ChunkMarkBitmapBits = 129024;
+
+const size_t ChunkRuntimeOffset = ChunkSize - sizeof(void*);
+const size_t ChunkTrailerSize = 2 * sizeof(uintptr_t) + sizeof(uint64_t);
+const size_t ChunkLocationOffset = ChunkSize - ChunkTrailerSize;
+const size_t ArenaZoneOffset = sizeof(size_t);
+const size_t ArenaHeaderSize = sizeof(size_t) + 2 * sizeof(uintptr_t) +
+                               sizeof(size_t) + sizeof(uintptr_t);
+
+
+
+
+
+
+static const uint32_t BLACK = 0;
+static const uint32_t GRAY = 1;
+
+
+
+
+
+enum class ChunkLocation : uint32_t
+{
+    Invalid = 0,
+    Nursery = 1,
+    TenuredHeap = 2
+};
+
+
+
+extern void
+AssertGCThingHasType(js::gc::Cell* cell, JS::TraceKind kind);
+
+
+
+
+
+__attribute__((always_inline)) inline bool IsInsideNursery(const js::gc::Cell* cell);
+
+}
+}
+
+namespace JS {
+struct Zone;
+
+
+const uint32_t DefaultNurseryBytes = 16 * js::gc::ChunkSize;
+
+
+const uint32_t DefaultHeapMaxBytes = 32 * 1024 * 1024;
+
+namespace shadow {
+
+struct Zone
+{
+  protected:
+    JSRuntime* const runtime_;
+    JSTracer* const barrierTracer_;
+
+  public:
+    bool needsIncrementalBarrier_;
+
+    Zone(JSRuntime* runtime, JSTracer* barrierTracerArg)
+      : runtime_(runtime),
+        barrierTracer_(barrierTracerArg),
+        needsIncrementalBarrier_(false)
+    {}
+
+    bool needsIncrementalBarrier() const {
+        return needsIncrementalBarrier_;
+    }
+
+    JSTracer* barrierTracer() {
+        do { } while (0);
+        do { } while (0);
+        return barrierTracer_;
+    }
+
+    JSRuntime* runtimeFromActiveCooperatingThread() const {
+        do { } while (0);
+        return runtime_;
+    }
+
+
+
+    JSRuntime* runtimeFromAnyThread() const {
+        return runtime_;
+    }
+
+    static __attribute__((always_inline)) inline JS::shadow::Zone* asShadowZone(JS::Zone* zone) {
+        return reinterpret_cast<JS::shadow::Zone*>(zone);
+    }
+};
+
+}
+# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h"
+class GCCellPtr
+{
+  public:
+
+    GCCellPtr(void* gcthing, JS::TraceKind traceKind) : ptr(checkedCast(gcthing, traceKind)) {}
+
+
+                 GCCellPtr(decltype(nullptr)) : ptr(checkedCast(nullptr, JS::TraceKind::Null)) {}
+
+
+    template <typename T>
+    explicit GCCellPtr(T* p) : ptr(checkedCast(p, JS::MapTypeToTraceKind<T>::kind)) { }
+    explicit GCCellPtr(JSFunction* p) : ptr(checkedCast(p, JS::TraceKind::Object)) { }
+    explicit GCCellPtr(JSFlatString* str) : ptr(checkedCast(str, JS::TraceKind::String)) { }
+    explicit GCCellPtr(const Value& v);
+
+    JS::TraceKind kind() const {
+        JS::TraceKind traceKind = JS::TraceKind(ptr & OutOfLineTraceKindMask);
+        if (uintptr_t(traceKind) != OutOfLineTraceKindMask)
+            return traceKind;
+        return outOfLineKind();
+    }
+
+
+    explicit operator bool() const {
+        do { } while (0);
+        return asCell();
+    }
+
+
+    template <typename T>
+    bool is() const { return kind() == JS::MapTypeToTraceKind<T>::kind; }
+
+
+
+    template <typename T>
+    T& as() const {
+        do { } while (0);
+
+
+        return *reinterpret_cast<T*>(asCell());
+    }
+
+
+
+
+    js::gc::Cell* asCell() const {
+        return reinterpret_cast<js::gc::Cell*>(ptr & ~OutOfLineTraceKindMask);
+    }
+
+
+    uint64_t unsafeAsInteger() const {
+        return static_cast<uint64_t>(unsafeAsUIntPtr());
+    }
+
+    uintptr_t unsafeAsUIntPtr() const {
+        do { } while (0);
+        do { } while (0);
+        return reinterpret_cast<uintptr_t>(asCell());
+    }
+
+    bool mayBeOwnedByOtherRuntime() const;
+
+  private:
+    static uintptr_t checkedCast(void* p, JS::TraceKind traceKind) {
+        js::gc::Cell* cell = static_cast<js::gc::Cell*>(p);
+        do { } while (0);
+        AssertGCThingHasType(cell, traceKind);
+
+
+        do { } while (0);
+
+        return uintptr_t(p) | (uintptr_t(traceKind) & OutOfLineTraceKindMask);
+    }
+
+    JS::TraceKind outOfLineKind() const;
+
+    uintptr_t ptr;
+};
+
+inline bool
+operator==(const GCCellPtr& ptr1, const GCCellPtr& ptr2)
+{
+    return ptr1.asCell() == ptr2.asCell();
+}
+
+inline bool
+operator!=(const GCCellPtr& ptr1, const GCCellPtr& ptr2)
+{
+    return !(ptr1 == ptr2);
+}
+
+
+
+template <typename F, typename... Args>
+auto
+DispatchTyped(F f, GCCellPtr thing, Args&&... args)
+  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+{
+    switch (thing.kind()) {
+
+
+
+      case JS::TraceKind::BaseShape: return f(&thing.as<js::BaseShape>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f(&thing.as<js::jit::JitCode>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f(&thing.as<js::LazyScript>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f(&thing.as<js::Scope>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f(&thing.as<JSObject>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f(&thing.as<js::ObjectGroup>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f(&thing.as<JSScript>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f(&thing.as<js::Shape>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f(&thing.as<JSString>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f(&thing.as<JS::Symbol>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f(&thing.as<js::RegExpShared>(), mozilla::Forward<Args>(args)...);;
+
+      default:
+          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTyped for GCCellPtr." ")"); do { *((volatile int*) __null) = 258; ::abort(); } while (0); } while (0);
+    }
+}
+
+}
+
+namespace js {
+namespace gc {
+namespace detail {
+
+static __attribute__((always_inline)) inline uintptr_t*
+GetGCThingMarkBitmap(const uintptr_t addr)
+{
+    do { } while (0);
+    const uintptr_t bmap_addr = (addr & ~ChunkMask) | ChunkMarkBitmapOffset;
+    return reinterpret_cast<uintptr_t*>(bmap_addr);
+}
+
+static __attribute__((always_inline)) inline void
+GetGCThingMarkWordAndMask(const uintptr_t addr, uint32_t color,
+                          uintptr_t** wordp, uintptr_t* maskp)
+{
+    do { } while (0);
+    const size_t bit = (addr & js::gc::ChunkMask) / js::gc::CellSize + color;
+    do { } while (0);
+    uintptr_t* bitmap = GetGCThingMarkBitmap(addr);
+    const uintptr_t nbits = sizeof(*bitmap) * 8;
+    *maskp = uintptr_t(1) << (bit % nbits);
+    *wordp = &bitmap[bit / nbits];
+}
+
+static __attribute__((always_inline)) inline JS::Zone*
+GetGCThingZone(const uintptr_t addr)
+{
+    do { } while (0);
+    const uintptr_t zone_addr = (addr & ~ArenaMask) | ArenaZoneOffset;
+    return *reinterpret_cast<JS::Zone**>(zone_addr);
+
+}
+
+static __attribute__((always_inline)) inline bool
+CellIsMarkedGray(const Cell* cell)
+{
+    do { } while (0);
+    if (js::gc::IsInsideNursery(cell))
+        return false;
+
+    uintptr_t* word, mask;
+    js::gc::detail::GetGCThingMarkWordAndMask(uintptr_t(cell), js::gc::GRAY, &word, &mask);
+    return *word & mask;
+}
+
+extern bool
+CellIsMarkedGrayIfKnown(const Cell* cell);
+
+
+
+
+
+
+}
+
+__attribute__((always_inline)) inline bool
+IsInsideNursery(const js::gc::Cell* cell)
+{
+    if (!cell)
+        return false;
+    uintptr_t addr = uintptr_t(cell);
+    addr &= ~js::gc::ChunkMask;
+    addr |= js::gc::ChunkLocationOffset;
+    auto location = *reinterpret_cast<ChunkLocation*>(addr);
+    do { } while (0);
+    return location == ChunkLocation::Nursery;
+}
+
+}
+}
+
+namespace JS {
+
+static __attribute__((always_inline)) inline Zone*
+GetTenuredGCThingZone(GCCellPtr thing)
+{
+    do { } while (0);
+    return js::gc::detail::GetGCThingZone(thing.unsafeAsUIntPtr());
+}
+
+static __attribute__((always_inline)) inline Zone*
+GetStringZone(JSString* str)
+{
+    return js::gc::detail::GetGCThingZone(uintptr_t(str));
+}
+
+extern Zone*
+GetObjectZone(JSObject* obj);
+
+static __attribute__((always_inline)) inline bool
+GCThingIsMarkedGray(GCCellPtr thing)
+{
+    if (thing.mayBeOwnedByOtherRuntime())
+        return false;
+    return js::gc::detail::CellIsMarkedGrayIfKnown(thing.asCell());
+}
+
+extern JS::TraceKind
+GCThingTraceKind(void* thing);
+
+}
+
+namespace js {
+namespace gc {
+
+static __attribute__((always_inline)) inline bool
+IsIncrementalBarrierNeededOnTenuredGCThing(const JS::GCCellPtr thing)
+{
+    do { } while (0);
+    do { } while (0);
+
+
+
+
+    do { } while (0);
+
+    JS::Zone* zone = JS::GetTenuredGCThingZone(thing);
+    return JS::shadow::Zone::asShadowZone(zone)->needsIncrementalBarrier();
+}
+
+
+
+
+
+
+extern JSObject*
+NewMemoryInfoObject(JSContext* cx);
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h"
+typedef int64_t PRTime;
+
+
+
+class nsAString;
+class nsACString;
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
+# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
+struct nsID
+{
+
+
+
+
+
+  uint32_t m0;
+  uint16_t m1;
+  uint16_t m2;
+  uint8_t m3[8];
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
+  void Clear();
+
+
+
+
+
+
+  inline bool Equals(const nsID& aOther) const
+  {
+
+    return
+      (((uint32_t*)&m0)[0] == ((uint32_t*)&aOther.m0)[0]) &&
+      (((uint32_t*)&m0)[1] == ((uint32_t*)&aOther.m0)[1]) &&
+      (((uint32_t*)&m0)[2] == ((uint32_t*)&aOther.m0)[2]) &&
+      (((uint32_t*)&m0)[3] == ((uint32_t*)&aOther.m0)[3]);
+  }
+
+  inline bool operator==(const nsID& aOther) const
+  {
+    return Equals(aOther);
+  }
+
+
+
+
+
+  bool Parse(const char* aIDStr);
+
+
+
+
+
+
+
+  char* ToString() const;
+
+
+
+
+
+
+  void ToProvidedString(char (&aDest)[39]) const;
+
+
+
+
+};
+# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
+class nsIDToCString
+{
+public:
+  explicit nsIDToCString(const nsID& aID)
+  {
+    aID.ToProvidedString(mStringBytes);
+  }
+
+  const char *get() const
+  {
+    return mStringBytes;
+  }
+
+protected:
+  char mStringBytes[39];
+};
+
+
+
+
+
+
+typedef nsID nsCID;
+# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
+typedef nsID nsIID;
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 2
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
+class nsISupports
+{
+public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
+  virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
+
+
+
+
+
+
+
+  virtual MozExternalRefCountType AddRef(void) = 0;
+# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
+  virtual MozExternalRefCountType Release(void) = 0;
+
+
+};
+
+template<typename T> struct nsISupports::COMTypeInfo<nsISupports, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupports::COMTypeInfo<nsISupports, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x00000000, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} };
+# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOMCID.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+class nsAString;
+class nsACString;
+
+class nsISupports;
+class nsIModule;
+class nsIComponentManager;
+class nsIComponentRegistrar;
+class nsIServiceManager;
+class nsIFile;
+class nsILocalFile;
+class nsIDirectoryServiceProvider;
+class nsIMemory;
+class nsIDebug2;
+
+
+namespace mozilla {
+struct Module;
+}
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult
+NS_InitXPCOM2(nsIServiceManager** aResult,
+              nsIFile* aBinDirectory,
+              nsIDirectoryServiceProvider* aAppFileLocationProvider);
+
+
+
+
+
+extern "C" nsresult
+NS_InitMinimalXPCOM();
+# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_ShutdownXPCOM(nsIServiceManager* aServMgr);
+# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_GetServiceManager(nsIServiceManager** aResult);
+# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_GetComponentManager(nsIComponentManager** aResult);
+# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_GetComponentRegistrar(nsIComponentRegistrar** aResult);
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_GetMemoryManager(nsIMemory** aResult);
+# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_NewLocalFile(const nsAString& aPath,
+                                    bool aFollowLinks,
+                                    nsIFile** aResult);
+
+extern "C" nsresult NS_NewNativeLocalFile(const nsACString& aPath,
+                                          bool aFollowLinks,
+                                          nsIFile** aResult);
+
+
+
+
+class NS_ConvertUTF16toUTF8;
+nsresult NS_NewNativeLocalFile(const NS_ConvertUTF16toUTF8& aPath,
+                               bool aFollowLinks,
+                               nsIFile** aResult) = delete;
+# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+enum
+{
+  NS_DEBUG_WARNING = 0,
+  NS_DEBUG_ASSERTION = 1,
+  NS_DEBUG_BREAK = 2,
+  NS_DEBUG_ABORT = 3
+};
+# 255 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" void NS_DebugBreak(uint32_t aSeverity,
+                              const char* aStr, const char* aExpr,
+                              const char* aFile, int32_t aLine);
+# 275 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" void NS_LogInit();
+
+extern "C" void NS_LogTerm();
+
+
+
+
+
+
+
+class ScopedLogging
+{
+public:
+    ScopedLogging()
+    {
+        NS_LogInit();
+    }
+
+    ~ScopedLogging()
+    {
+        NS_LogTerm();
+    }
+};
+# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" void NS_LogCtor(void* aPtr, const char* aTypeName,
+                           uint32_t aInstanceSize);
+
+extern "C" void NS_LogDtor(void* aPtr, const char* aTypeName,
+                           uint32_t aInstanceSize);
+# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" void NS_LogAddRef(void* aPtr, nsrefcnt aNewRefCnt,
+                             const char* aTypeName, uint32_t aInstanceSize);
+
+extern "C" void NS_LogRelease(void* aPtr, nsrefcnt aNewRefCnt,
+                              const char* aTypeName);
+# 342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" void NS_LogCOMPtrAddRef(void* aCOMPtr, nsISupports* aObject);
+
+extern "C" void NS_LogCOMPtrRelease(void* aCOMPtr, nsISupports* aObject);
+# 354 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+class nsCycleCollectionParticipant;
+class nsCycleCollectingAutoRefCnt;
+
+extern "C" void NS_CycleCollectorSuspect3(void* aPtr,
+                                          nsCycleCollectionParticipant* aCp,
+                                          nsCycleCollectingAutoRefCnt* aRefCnt,
+                                          bool* aShouldDelete);
+# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
+extern "C" nsresult NS_GetDebug(nsIDebug2** aResult);
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 2
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
+void NS_ABORT_OOM(size_t aSize);
+# 390 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
+extern "C" {
+# 402 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
+void printf_stderr(const char* aFmt, ...) __attribute__ ((format (printf, 1, 2)));
+
+
+
+
+void vprintf_stderr(const char* aFmt, va_list aArgs);
+# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
+void fprintf_stderr(FILE* aFile, const char* aFmt, ...) __attribute__ ((format (printf, 2, 3)));
+
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 1
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/md/_linux.cfg" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 2
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+extern "C" {
+# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef unsigned char PRUint8;
+# 260 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef signed char PRInt8;
+# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef unsigned short PRUint16;
+typedef short PRInt16;
+# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef unsigned int PRUint32;
+typedef int PRInt32;
+# 365 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef long PRInt64;
+typedef unsigned long PRUint64;
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef int PRIntn;
+typedef unsigned int PRUintn;
+# 421 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef double PRFloat64;
+
+
+
+
+
+
+typedef size_t PRSize;
+
+
+
+
+
+
+
+typedef PRInt32 PROffset32;
+typedef PRInt64 PROffset64;
+
+
+
+
+
+
+
+typedef ptrdiff_t PRPtrdiff;
+# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef unsigned long PRUptrdiff;
+# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef PRIntn PRBool;
+# 477 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef PRUint8 PRPackedBool;
+
+
+
+
+
+typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
+
+
+
+
+
+
+typedef PRUint16 PRUnichar;
+# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+typedef long PRWord;
+typedef unsigned long PRUword;
+# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
+}
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
+extern "C" {
+
+
+
+
+
+typedef PRUint32 PRIntervalTime;
+# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
+extern __attribute__((visibility("default"))) PRIntervalTime PR_IntervalNow(void);
+# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
+extern __attribute__((visibility("default"))) PRUint32 PR_TicksPerSecond(void);
+# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
+extern __attribute__((visibility("default"))) PRIntervalTime PR_SecondsToInterval(PRUint32 seconds);
+extern __attribute__((visibility("default"))) PRIntervalTime PR_MillisecondsToInterval(PRUint32 milli);
+extern __attribute__((visibility("default"))) PRIntervalTime PR_MicrosecondsToInterval(PRUint32 micro);
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
+extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToSeconds(PRIntervalTime ticks);
+extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMilliseconds(PRIntervalTime ticks);
+extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMicroseconds(PRIntervalTime ticks);
+
+}
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2
+
+extern "C" {
+
+typedef struct PRThread PRThread;
+typedef struct PRThreadStack PRThreadStack;
+
+typedef enum PRThreadType {
+    PR_USER_THREAD,
+    PR_SYSTEM_THREAD
+} PRThreadType;
+
+typedef enum PRThreadScope {
+    PR_LOCAL_THREAD,
+    PR_GLOBAL_THREAD,
+    PR_GLOBAL_BOUND_THREAD
+} PRThreadScope;
+
+typedef enum PRThreadState {
+    PR_JOINABLE_THREAD,
+    PR_UNJOINABLE_THREAD
+} PRThreadState;
+
+typedef enum PRThreadPriority
+{
+    PR_PRIORITY_FIRST = 0,
+    PR_PRIORITY_LOW = 0,
+    PR_PRIORITY_NORMAL = 1,
+    PR_PRIORITY_HIGH = 2,
+    PR_PRIORITY_URGENT = 3,
+    PR_PRIORITY_LAST = 3
+} PRThreadPriority;
+# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) PRThread* PR_CreateThread(PRThreadType type,
+                     void ( *start)(void *arg),
+                     void *arg,
+                     PRThreadPriority priority,
+                     PRThreadScope scope,
+                     PRThreadState state,
+                     PRUint32 stackSize);
+# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) PRStatus PR_JoinThread(PRThread *thread);
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRThread* PR_GetCurrentThread(void);
+
+
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRThreadPriority PR_GetThreadPriority(const PRThread *thread);
+# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) void PR_SetThreadPriority(PRThread *thread, PRThreadPriority priority);
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRStatus PR_SetCurrentThreadName(const char *name);
+
+
+
+
+extern __attribute__((visibility("default"))) const char * PR_GetThreadName(const PRThread *thread);
+# 189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+typedef void ( *PRThreadPrivateDTOR)(void *priv);
+
+extern __attribute__((visibility("default"))) PRStatus PR_NewThreadPrivateIndex(
+    PRUintn *newIndex, PRThreadPrivateDTOR destructor);
+# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) PRStatus PR_SetThreadPrivate(PRUintn tpdIndex, void *priv);
+# 216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) void* PR_GetThreadPrivate(PRUintn tpdIndex);
+# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) PRStatus PR_Interrupt(PRThread *thread);
+
+
+
+
+
+extern __attribute__((visibility("default"))) void PR_ClearInterrupt(void);
+
+
+
+
+extern __attribute__((visibility("default"))) void PR_BlockInterrupt(void);
+
+
+
+
+extern __attribute__((visibility("default"))) void PR_UnblockInterrupt(void);
+# 253 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
+extern __attribute__((visibility("default"))) PRStatus PR_Sleep(PRIntervalTime ticks);
+
+
+
+
+extern __attribute__((visibility("default"))) PRThreadScope PR_GetThreadScope(const PRThread *thread);
+
+
+
+
+extern __attribute__((visibility("default"))) PRThreadType PR_GetThreadType(const PRThread *thread);
+
+
+
+
+extern __attribute__((visibility("default"))) PRThreadState PR_GetThreadState(const PRThread *thread);
+
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroForEach.h" 1
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
+
+
+
+
+
+
+
+inline nsISupports*
+ToSupports(nsISupports* aSupports)
+{
+  return aSupports;
+}
+
+inline nsISupports*
+ToCanonicalSupports(nsISupports* aSupports)
+{
+  return nullptr;
+}
+# 174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
+class nsCycleCollectingAutoRefCnt
+{
+public:
+  nsCycleCollectingAutoRefCnt() : mRefCntAndFlags(0) {}
+
+  explicit nsCycleCollectingAutoRefCnt(uintptr_t aValue)
+    : mRefCntAndFlags(aValue << 2)
+  {
+  }
+
+  nsCycleCollectingAutoRefCnt(const nsCycleCollectingAutoRefCnt&) = delete;
+  void operator=(const nsCycleCollectingAutoRefCnt&) = delete;
+
+  __attribute__((always_inline)) inline uintptr_t incr(nsISupports* aOwner)
+  {
+    return incr(aOwner, nullptr);
+  }
+
+  __attribute__((always_inline)) inline uintptr_t incr(void* aOwner,
+                                   nsCycleCollectionParticipant* aCp)
+  {
+    mRefCntAndFlags += (1 << 2);
+    mRefCntAndFlags &= ~(1 << 1);
+
+
+    if (!IsInPurpleBuffer()) {
+      mRefCntAndFlags |= (1 << 0);
+
+      do { } while (0);
+      NS_CycleCollectorSuspect3(aOwner, aCp, this, nullptr);
+    }
+    return (mRefCntAndFlags >> 2);
+  }
+
+  __attribute__((always_inline)) inline void stabilizeForDeletion()
+  {
+
+
+    mRefCntAndFlags = (1 << 2) | (1 << 0);
+  }
+
+  __attribute__((always_inline)) inline uintptr_t decr(nsISupports* aOwner,
+                                   bool* aShouldDelete = nullptr)
+  {
+    return decr(aOwner, nullptr, aShouldDelete);
+  }
+
+  __attribute__((always_inline)) inline uintptr_t decr(void* aOwner,
+                                   nsCycleCollectionParticipant* aCp,
+                                   bool* aShouldDelete = nullptr)
+  {
+    do { } while (0);
+    if (!IsInPurpleBuffer()) {
+      mRefCntAndFlags -= (1 << 2);
+      mRefCntAndFlags |= ((1 << 0) | (1 << 1));
+      uintptr_t retval = (mRefCntAndFlags >> 2);
+
+      NS_CycleCollectorSuspect3(aOwner, aCp, this, aShouldDelete);
+      return retval;
+    }
+    mRefCntAndFlags -= (1 << 2);
+    mRefCntAndFlags |= ((1 << 0) | (1 << 1));
+    return (mRefCntAndFlags >> 2);
+  }
+
+  __attribute__((always_inline)) inline void RemovePurple()
+  {
+    do { } while (0);
+    mRefCntAndFlags &= ~(1 << 1);
+  }
+
+  __attribute__((always_inline)) inline void RemoveFromPurpleBuffer()
+  {
+    do { } while (0);
+    mRefCntAndFlags &= ~((1 << 1) | (1 << 0));
+  }
+
+  __attribute__((always_inline)) inline bool IsPurple() const
+  {
+    return !!(mRefCntAndFlags & (1 << 1));
+  }
+
+  __attribute__((always_inline)) inline bool IsInPurpleBuffer() const
+  {
+    return !!(mRefCntAndFlags & (1 << 0));
+  }
+
+  __attribute__((always_inline)) inline nsrefcnt get() const
+  {
+    return (mRefCntAndFlags >> 2);
+  }
+
+  __attribute__((always_inline)) inline operator nsrefcnt() const
+  {
+    return get();
+  }
+
+private:
+  uintptr_t mRefCntAndFlags;
+};
+
+class nsAutoRefCnt
+{
+public:
+  nsAutoRefCnt() : mValue(0) {}
+  explicit nsAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {}
+
+  nsAutoRefCnt(const nsAutoRefCnt&) = delete;
+  void operator=(const nsAutoRefCnt&) = delete;
+
+
+  nsrefcnt operator++() { return ++mValue; }
+  nsrefcnt operator--() { return --mValue; }
+
+  nsrefcnt operator=(nsrefcnt aValue) { return (mValue = aValue); }
+  operator nsrefcnt() const { return mValue; }
+  nsrefcnt get() const { return mValue; }
+
+  static const bool isThreadSafe = false;
+private:
+  nsrefcnt operator++(int) = delete;
+  nsrefcnt operator--(int) = delete;
+  nsrefcnt mValue;
+};
+
+namespace mozilla {
+class ThreadSafeAutoRefCnt
+{
+public:
+  ThreadSafeAutoRefCnt() : mValue(0) {}
+  explicit ThreadSafeAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {}
+
+  ThreadSafeAutoRefCnt(const ThreadSafeAutoRefCnt&) = delete;
+  void operator=(const ThreadSafeAutoRefCnt&) = delete;
+
+
+  __attribute__((always_inline)) inline nsrefcnt operator++()
+  {
+# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
+    return mValue.fetch_add(1, std::memory_order_relaxed) + 1;
+  }
+  __attribute__((always_inline)) inline nsrefcnt operator--()
+  {
+
+
+
+
+    nsrefcnt result = mValue.fetch_sub(1, std::memory_order_release) - 1;
+    if (result == 0) {
+
+
+
+
+      result = mValue.load(std::memory_order_acquire);
+    }
+    return result;
+  }
+
+  __attribute__((always_inline)) inline nsrefcnt operator=(nsrefcnt aValue)
+  {
+
+
+    mValue.store(aValue, std::memory_order_release);
+    return aValue;
+  }
+  __attribute__((always_inline)) inline operator nsrefcnt() const { return get(); }
+  __attribute__((always_inline)) inline nsrefcnt get() const
+  {
+
+
+    return mValue.load(std::memory_order_acquire);
+  }
+
+  static const bool isThreadSafe = true;
+private:
+  nsrefcnt operator++(int) = delete;
+  nsrefcnt operator--(int) = delete;
+  std::atomic<nsrefcnt> mValue;
+};
+}
+# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
+struct QITableEntry
+{
+  const nsIID* iid;
+  int32_t offset;
+};
+
+nsresult
+NS_TableDrivenQI(void* aThis, const nsIID& aIID,
+                 void** aInstancePtr, const QITableEntry* aEntries);
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
+template<class T>
+inline void
+ns_if_addref(T aExpr)
+{
+  if (aExpr) {
+    aExpr->AddRef();
+  }
+}
+# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
+template<class T, class DestinationType>
+inline nsresult
+CallQueryInterface(T* aSource, DestinationType** aDestination)
+{
+
+
+  static_assert(!mozilla::IsSame<T, DestinationType>::value ||
+                mozilla::IsSame<DestinationType, nsISupports>::value,
+                "don't use CallQueryInterface for compile-time-determinable casts");
+
+  do { } while(0);
+  do { } while(0);
+
+  return aSource->QueryInterface((DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                                 reinterpret_cast<void**>(aDestination));
+}
+
+template <class SourceType, class DestinationType>
+inline nsresult
+CallQueryInterface(RefPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr)
+{
+  return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+}
+# 131 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
+
+class nsCycleCollectionParticipant;
+
+class nsCycleCollectionTraversalCallback
+{
+public:
+
+
+
+
+  virtual void DescribeRefCountedNode(nsrefcnt aRefcount,
+                                           const char* aObjName) = 0;
+
+  virtual void DescribeGCedNode(bool aIsMarked,
+                                     const char* aObjName,
+                                     uint64_t aCompartmentAddress = 0) = 0;
+
+  virtual void NoteXPCOMChild(nsISupports* aChild) = 0;
+  virtual void NoteJSChild(const JS::GCCellPtr& aThing) = 0;
+  virtual void NoteNativeChild(void* aChild,
+                                    nsCycleCollectionParticipant* aHelper) = 0;
+
+
+
+
+
+  virtual void NoteNextEdgeName(const char* aName) = 0;
+
+  enum
+  {
+
+
+
+
+    WANT_DEBUG_INFO = (1 << 0),
+
+
+
+    WANT_ALL_TRACES = (1 << 1)
+  };
+  uint32_t Flags() const { return mFlags; }
+  bool WantDebugInfo() const { return (mFlags & WANT_DEBUG_INFO) != 0; }
+  bool WantAllTraces() const { return (mFlags & WANT_ALL_TRACES) != 0; }
+protected:
+  nsCycleCollectionTraversalCallback() : mFlags(0) {}
+
+  uint32_t mFlags;
+};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 2
+
+
+
+enum
+{
+  CycleCollectionEdgeNameArrayFlag = 1
+};
+
+
+void
+CycleCollectionNoteEdgeNameImpl(nsCycleCollectionTraversalCallback& aCallback,
+                                const char* aName,
+                                uint32_t aFlags = 0);
+
+
+__attribute__((always_inline)) inline void
+CycleCollectionNoteEdgeName(nsCycleCollectionTraversalCallback& aCallback,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  if ((__builtin_expect(!!(aCallback.WantDebugInfo()), 0))) {
+    CycleCollectionNoteEdgeNameImpl(aCallback, aName, aFlags);
+  }
+}
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h"
+template<typename T>
+nsISupports*
+ToSupports(T* aPtr, typename T::cycleCollection* aDummy = 0)
+{
+  return T::cycleCollection::Upcast(aPtr);
+}
+
+
+
+template<typename T,
+         bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
+struct CycleCollectionNoteChildImpl
+{
+};
+
+template<typename T>
+struct CycleCollectionNoteChildImpl<T, true>
+{
+  static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild)
+  {
+    aCallback.NoteXPCOMChild(ToSupports(aChild));
+  }
+};
+
+template<typename T>
+struct CycleCollectionNoteChildImpl<T, false>
+{
+  static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild)
+  {
+    aCallback.NoteNativeChild(aChild, T::cycleCollection::GetParticipant());
+  }
+};
+
+
+
+
+template<typename T>
+inline void
+CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
+                         T* aChild, const char* aName, uint32_t aFlags)
+{
+  CycleCollectionNoteEdgeName(aCallback, aName, aFlags);
+  CycleCollectionNoteChildImpl<T>::Run(aCallback, aChild);
+}
+
+template<typename T>
+inline void
+CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
+                         T* aChild, const char* aName)
+{
+  CycleCollectionNoteChild(aCallback, aChild, aName, 0);
+}
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h" 1
+# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h"
+template <class CharT>
+struct nsCharTraits
+{
+};
+
+template <>
+struct nsCharTraits<char16_t>
+{
+  typedef char16_t char_type;
+  typedef uint16_t unsigned_char_type;
+  typedef char incompatible_char_type;
+
+  static char_type* const sEmptyBuffer;
+
+  static void
+  assign(char_type& aLhs, char_type aRhs)
+  {
+    aLhs = aRhs;
+  }
+
+
+
+  typedef int int_type;
+
+  static char_type
+  to_char_type(int_type aChar)
+  {
+    return char_type(aChar);
+  }
+
+  static int_type
+  to_int_type(char_type aChar)
+  {
+    return int_type(static_cast<unsigned_char_type>(aChar));
+  }
+
+  static bool
+  eq_int_type(int_type aLhs, int_type aRhs)
+  {
+    return aLhs == aRhs;
+  }
+
+
+
+
+  static bool
+  eq(char_type aLhs, char_type aRhs)
+  {
+    return aLhs == aRhs;
+  }
+
+  static bool
+  lt(char_type aLhs, char_type aRhs)
+  {
+    return aLhs < aRhs;
+  }
+
+
+
+
+  static char_type*
+  move(char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    return static_cast<char_type*>(memmove(aStr1, aStr2,
+                                           aN * sizeof(char_type)));
+  }
+
+  static char_type*
+  copy(char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    return static_cast<char_type*>(memcpy(aStr1, aStr2,
+                                          aN * sizeof(char_type)));
+  }
+
+  static char_type*
+  copyASCII(char_type* aStr1, const char* aStr2, size_t aN)
+  {
+    for (char_type* s = aStr1; aN--; ++s, ++aStr2) {
+      do { } while(0);
+      *s = static_cast<char_type>(*aStr2);
+    }
+    return aStr1;
+  }
+
+  static char_type*
+  assign(char_type* aStr, size_t aN, char_type aChar)
+  {
+    char_type* result = aStr;
+    while (aN--) {
+      assign(*aStr++, aChar);
+    }
+    return result;
+  }
+
+  static int
+  compare(const char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      if (!eq(*aStr1, *aStr2)) {
+        return to_int_type(*aStr1) - to_int_type(*aStr2);
+      }
+    }
+
+    return 0;
+  }
+
+  static int
+  compareASCII(const char_type* aStr1, const char* aStr2, size_t aN)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      do { } while(0);
+      if (!eq_int_type(to_int_type(*aStr1),
+                       to_int_type(static_cast<char_type>(*aStr2)))) {
+        return to_int_type(*aStr1) -
+               to_int_type(static_cast<char_type>(*aStr2));
+      }
+    }
+
+    return 0;
+  }
+
+
+
+
+  static int
+  compareASCIINullTerminated(const char_type* aStr1, size_t aN,
+                             const char* aStr2)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      if (!*aStr2) {
+        return 1;
+      }
+      do { } while(0);
+      if (!eq_int_type(to_int_type(*aStr1),
+                       to_int_type(static_cast<char_type>(*aStr2)))) {
+        return to_int_type(*aStr1) -
+               to_int_type(static_cast<char_type>(*aStr2));
+      }
+    }
+
+    if (*aStr2) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+
+
+
+
+  static char_type
+  ASCIIToLower(char_type aChar)
+  {
+    if (aChar >= 'A' && aChar <= 'Z') {
+      return char_type(aChar + ('a' - 'A'));
+    }
+
+    return aChar;
+  }
+
+  static int
+  compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      do { } while(0);
+      do { } while(0);
+
+      char_type lower_s1 = ASCIIToLower(*aStr1);
+      if (lower_s1 != static_cast<char_type>(*aStr2)) {
+        return to_int_type(lower_s1) -
+               to_int_type(static_cast<char_type>(*aStr2));
+      }
+    }
+
+    return 0;
+  }
+
+
+
+
+  static int
+  compareLowerCaseToASCIINullTerminated(const char_type* aStr1,
+                                        size_t aN, const char* aStr2)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      if (!*aStr2) {
+        return 1;
+      }
+      do { } while(0);
+      do { } while(0);
+
+      char_type lower_s1 = ASCIIToLower(*aStr1);
+      if (lower_s1 != static_cast<char_type>(*aStr2)) {
+        return to_int_type(lower_s1) -
+               to_int_type(static_cast<char_type>(*aStr2));
+      }
+    }
+
+    if (*aStr2) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+  static size_t
+  length(const char_type* aStr)
+  {
+    size_t result = 0;
+    while (!eq(*aStr++, char_type(0))) {
+      ++result;
+    }
+    return result;
+  }
+
+  static const char_type*
+  find(const char_type* aStr, size_t aN, char_type aChar)
+  {
+    while (aN--) {
+      if (eq(*aStr, aChar)) {
+        return aStr;
+      }
+      ++aStr;
+    }
+
+    return 0;
+  }
+};
+
+template <>
+struct nsCharTraits<char>
+{
+  typedef char char_type;
+  typedef unsigned char unsigned_char_type;
+  typedef char16_t incompatible_char_type;
+
+  static char_type* const sEmptyBuffer;
+
+  static void
+  assign(char_type& aLhs, char_type aRhs)
+  {
+    aLhs = aRhs;
+  }
+
+
+
+
+  typedef int int_type;
+
+  static char_type
+  to_char_type(int_type aChar)
+  {
+    return char_type(aChar);
+  }
+
+  static int_type
+  to_int_type(char_type aChar)
+  {
+    return int_type(static_cast<unsigned_char_type>(aChar));
+  }
+
+  static bool
+  eq_int_type(int_type aLhs, int_type aRhs)
+  {
+    return aLhs == aRhs;
+  }
+
+
+
+
+  static bool eq(char_type aLhs, char_type aRhs)
+  {
+    return aLhs == aRhs;
+  }
+
+  static bool
+  lt(char_type aLhs, char_type aRhs)
+  {
+    return aLhs < aRhs;
+  }
+
+
+
+
+  static char_type*
+  move(char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    return static_cast<char_type*>(memmove(aStr1, aStr2,
+                                           aN * sizeof(char_type)));
+  }
+
+  static char_type*
+  copy(char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    return static_cast<char_type*>(memcpy(aStr1, aStr2,
+                                          aN * sizeof(char_type)));
+  }
+
+  static char_type*
+  copyASCII(char_type* aStr1, const char* aStr2, size_t aN)
+  {
+    return copy(aStr1, aStr2, aN);
+  }
+
+  static char_type*
+  assign(char_type* aStr, size_t aN, char_type aChar)
+  {
+    return static_cast<char_type*>(memset(aStr, to_int_type(aChar), aN));
+  }
+
+  static int
+  compare(const char_type* aStr1, const char_type* aStr2, size_t aN)
+  {
+    return memcmp(aStr1, aStr2, aN);
+  }
+
+  static int
+  compareASCII(const char_type* aStr1, const char* aStr2, size_t aN)
+  {
+
+
+
+
+
+    return compare(aStr1, aStr2, aN);
+  }
+
+
+
+
+  static int
+  compareASCIINullTerminated(const char_type* aStr1, size_t aN,
+                             const char* aStr2)
+  {
+
+
+    for (; aN--; ++aStr1, ++aStr2) {
+      if (!*aStr2) {
+        return 1;
+      }
+      do { } while(0);
+      if (*aStr1 != *aStr2) {
+        return to_int_type(*aStr1) - to_int_type(*aStr2);
+      }
+    }
+
+    if (*aStr2) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+
+
+
+  static char_type
+  ASCIIToLower(char_type aChar)
+  {
+    if (aChar >= 'A' && aChar <= 'Z') {
+      return char_type(aChar + ('a' - 'A'));
+    }
+
+    return aChar;
+  }
+
+  static int
+  compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      do { } while(0);
+      do { } while(0);
+
+      char_type lower_s1 = ASCIIToLower(*aStr1);
+      if (lower_s1 != *aStr2) {
+        return to_int_type(lower_s1) - to_int_type(*aStr2);
+      }
+    }
+    return 0;
+  }
+
+
+
+
+  static int
+  compareLowerCaseToASCIINullTerminated(const char_type* aStr1, size_t aN,
+                                        const char* aStr2)
+  {
+    for (; aN--; ++aStr1, ++aStr2) {
+      if (!*aStr2) {
+        return 1;
+      }
+      do { } while(0);
+      do { } while(0);
+
+      char_type lower_s1 = ASCIIToLower(*aStr1);
+      if (lower_s1 != *aStr2) {
+        return to_int_type(lower_s1) - to_int_type(*aStr2);
+      }
+    }
+
+    if (*aStr2) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+  static size_t
+  length(const char_type* aStr)
+  {
+    return strlen(aStr);
+  }
+
+  static const char_type*
+  find(const char_type* aStr, size_t aN, char_type aChar)
+  {
+    return reinterpret_cast<const char_type*>(memchr(aStr, to_int_type(aChar),
+                                                     aN));
+  }
+};
+
+template <class InputIterator>
+struct nsCharSourceTraits
+{
+  typedef typename InputIterator::difference_type difference_type;
+
+  static uint32_t
+  readable_distance(const InputIterator& aFirst, const InputIterator& aLast)
+  {
+
+    return uint32_t(aLast.get() - aFirst.get());
+  }
+
+  static const typename InputIterator::value_type*
+  read(const InputIterator& aIter)
+  {
+    return aIter.get();
+  }
+
+  static void
+  advance(InputIterator& aStr, difference_type aN)
+  {
+    aStr.advance(aN);
+  }
+};
+
+template <class CharT>
+struct nsCharSourceTraits<CharT*>
+{
+  typedef ptrdiff_t difference_type;
+
+  static uint32_t
+  readable_distance(CharT* aStr)
+  {
+    return uint32_t(nsCharTraits<CharT>::length(aStr));
+
+  }
+
+  static uint32_t
+  readable_distance(CharT* aFirst, CharT* aLast)
+  {
+    return uint32_t(aLast - aFirst);
+  }
+
+  static const CharT*
+  read(CharT* aStr)
+  {
+    return aStr;
+  }
+
+  static void
+  advance(CharT*& aStr, difference_type aN)
+  {
+    aStr += aN;
+  }
+};
+
+template <class OutputIterator>
+struct nsCharSinkTraits
+{
+  static void
+  write(OutputIterator& aIter, const typename OutputIterator::value_type* aStr,
+        uint32_t aN)
+  {
+    aIter.write(aStr, aN);
+  }
+};
+
+template <class CharT>
+struct nsCharSinkTraits<CharT*>
+{
+  static void
+  write(CharT*& aIter, const CharT* aStr, uint32_t aN)
+  {
+    nsCharTraits<CharT>::move(aIter, aStr, aN);
+    aIter += aN;
+  }
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 2
+
+template <class T>
+inline T
+NS_ROUNDUP(const T& aA, const T& aB)
+{
+  return ((aA + (aB - 1)) / aB) * aB;
+}
+
+
+
+
+template <class T>
+inline const T&
+XPCOM_MIN(const T& aA, const T& aB)
+{
+  return aB < aA ? aB : aA;
+}
+
+
+template <class T>
+inline const T&
+XPCOM_MAX(const T& aA, const T& aB)
+{
+  return aA > aB ? aA : aB;
+}
+
+namespace mozilla {
+
+template <class T>
+inline const T&
+clamped(const T& aA, const T& aMin, const T& aMax)
+{
+  do { } while (0);
+
+  return XPCOM_MIN(XPCOM_MAX(aA, aMin), aMax);
+}
+
+}
+
+template <class InputIterator, class T>
+inline uint32_t
+NS_COUNT(InputIterator& aFirst, const InputIterator& aLast, const T& aValue)
+{
+  uint32_t result = 0;
+  for (; aFirst != aLast; ++aFirst)
+    if (*aFirst == aValue) {
+      ++result;
+    }
+  return result;
+}
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator&
+copy_string(const InputIterator& aFirst, const InputIterator& aLast,
+            OutputIterator& aResult)
+{
+  typedef nsCharSourceTraits<InputIterator> source_traits;
+  typedef nsCharSinkTraits<OutputIterator> sink_traits;
+
+  sink_traits::write(aResult, source_traits::read(aFirst),
+                     source_traits::readable_distance(aFirst, aLast));
+  return aResult;
+}
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h"
+extern "C" {
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h"
+void NS_QuickSort(void*, unsigned int, unsigned int,
+                  int (*)(const void*, const void*, void*),
+                  void*);
+
+
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h"
+namespace mozilla {
+namespace gfx {
+
+struct UnknownUnits;
+
+template <class units>
+class IntRegionTyped;
+
+typedef IntRegionTyped<UnknownUnits> IntRegion;
+
+}
+}
+
+typedef mozilla::gfx::IntRegion nsIntRegion;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 1 3
+# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
+
+
+
+
+
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
+namespace std
+{
+
+
+
+
+
+
+  class type_info
+  {
+  public:
+
+
+
+
+    virtual ~type_info();
+
+
+
+    const char* name() const noexcept
+    { return __name[0] == '*' ? __name + 1 : __name; }
+# 115 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
+    bool before(const type_info& __arg) const noexcept
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+ ? __name < __arg.__name
+ : __builtin_strcmp (__name, __arg.__name) < 0; }
+
+    bool operator==(const type_info& __arg) const noexcept
+    {
+      return ((__name == __arg.__name)
+       || (__name[0] != '*' &&
+    __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
+    bool operator!=(const type_info& __arg) const noexcept
+    { return !operator==(__arg); }
+
+
+    size_t hash_code() const noexcept
+    {
+
+      return _Hash_bytes(name(), __builtin_strlen(name()),
+    static_cast<size_t>(0xc70f6907UL));
+
+
+
+    }
+
+
+
+    virtual bool __is_pointer_p() const;
+
+
+    virtual bool __is_function_p() const;
+
+
+
+
+
+
+
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+       unsigned __outer) const;
+
+
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+        void **__obj_ptr) const;
+
+  protected:
+    const char *__name;
+
+    explicit type_info(const char *__n): __name(__n) { }
+
+  private:
+
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+
+
+
+
+
+
+
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() noexcept { }
+
+
+
+    virtual ~bad_cast() noexcept;
+
+
+    virtual const char* what() const noexcept;
+  };
+
+
+
+
+
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () noexcept { }
+
+
+
+    virtual ~bad_typeid() noexcept;
+
+
+    virtual const char* what() const noexcept;
+  };
+}
+
+}
+
+#pragma GCC visibility pop
+# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 1 3
+# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  struct __erased_type { };
+
+  template<typename _Alloc, typename _Tp>
+    using __is_erased_or_convertible
+      = __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
+
+
+  struct allocator_arg_t { explicit allocator_arg_t() = default; };
+
+  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+
+  template<typename _Tp, typename _Alloc, typename = __void_t<>>
+    struct __uses_allocator_helper
+    : false_type { };
+
+  template<typename _Tp, typename _Alloc>
+    struct __uses_allocator_helper<_Tp, _Alloc,
+       __void_t<typename _Tp::allocator_type>>
+    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
+    { };
+
+
+  template<typename _Tp, typename _Alloc>
+    struct uses_allocator
+    : __uses_allocator_helper<_Tp, _Alloc>::type
+    { };
+
+  struct __uses_alloc_base { };
+
+  struct __uses_alloc0 : __uses_alloc_base
+  {
+    struct _Sink { void operator=(const void*) { } } _M_a;
+  };
+
+  template<typename _Alloc>
+    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
+
+  template<typename _Alloc>
+    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
+
+  template<bool, typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
+    : conditional<
+        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
+        __uses_alloc1<_Alloc>,
+        __uses_alloc2<_Alloc>>::type
+    {
+      static_assert(__or_<
+   is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>,
+   is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with"
+   " an allocator must be possible if uses_allocator is true");
+    };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
+    : __uses_alloc0 { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    using __uses_alloc_t =
+      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
+    __use_alloc(const _Alloc& __a)
+    {
+      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
+      __ret._M_a = std::__addressof(__a);
+      return __ret;
+    }
+
+
+}
+# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
+    struct _Head_base;
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, true>
+    : public _Head
+    {
+      constexpr _Head_base()
+      : _Head() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _Head(__h) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _Head(std::forward<_UHead>(__h)) { }
+
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _Head() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _Head(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _Head(*__a._M_a) { }
+
+      template<typename _UHead>
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b; }
+    };
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, false>
+    {
+      constexpr _Head_base()
+      : _M_head_impl() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _M_head_impl(__h) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _M_head_impl(std::forward<_UHead>(__h)) { }
+
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _M_head_impl() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _M_head_impl(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _M_head_impl(*__a._M_a) { }
+
+      template<typename _UHead>
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
+ { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      _Head _M_head_impl;
+    };
+# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl;
+
+  template<typename _Tp>
+    struct __is_empty_non_tuple : is_empty<_Tp> { };
+
+
+  template<typename _El0, typename... _El>
+    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
+
+
+  template<typename _Tp>
+    using __empty_not_final
+    = typename conditional<__is_final(_Tp), false_type,
+      __is_empty_non_tuple<_Tp>>::type;
+
+
+
+
+
+
+  template<std::size_t _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>,
+      private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
+
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr _Inherited&
+      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
+
+      static constexpr const _Inherited&
+      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
+
+      constexpr _Tuple_impl()
+      : _Inherited(), _Base() { }
+
+      explicit
+      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
+      : _Inherited(__tail...), _Base(__head) { }
+
+      template<typename _UHead, typename... _UTail, typename = typename
+               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
+ : _Inherited(std::forward<_UTail>(__tail)...),
+   _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_constructible<_Head>,
+               is_nothrow_move_constructible<_Inherited>>::value)
+      : _Inherited(std::move(_M_tail(__in))),
+ _Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename... _UElements>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _UHead, typename... _UTails>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a),
+          _Base(__tag, __use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head, const _Tail&... __tail)
+ : _Inherited(__tag, __a, __tail...),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTail,
+               typename = typename enable_if<sizeof...(_Tail)
+          == sizeof...(_UTail)>::type>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head, _UTail&&... __tail)
+ : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
+          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Inherited(__tag, __a, _M_tail(__in)),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Inherited(__tag, __a, std::move(_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename... _UElements>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(__tag, __a,
+       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+  _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTails>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(__tag, __a, std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+ _M_head(*this) = _M_head(__in);
+ _M_tail(*this) = _M_tail(__in);
+ return *this;
+      }
+
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_assignable<_Head>,
+               is_nothrow_move_assignable<_Inherited>>::value)
+      {
+ _M_head(*this) = std::forward<_Head>(_M_head(__in));
+ _M_tail(*this) = std::move(_M_tail(__in));
+ return *this;
+      }
+
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+   _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
+   return *this;
+ }
+
+      template<typename _UHead, typename... _UTails>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        {
+   _M_head(*this) = std::forward<_UHead>
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+   _M_tail(*this) = std::move
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
+   return *this;
+ }
+
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(__is_nothrow_swappable<_Head>::value
+               && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+ _Inherited::_M_swap(_M_tail(__in));
+      }
+    };
+
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Tuple_impl<_Idx, _Head>
+    : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
+
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      constexpr _Tuple_impl()
+      : _Base() { }
+
+      explicit
+      constexpr _Tuple_impl(const _Head& __head)
+      : _Base(__head) { }
+
+      template<typename _UHead>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head)
+ : _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_constructible<_Head>::value)
+      : _Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Base(__tag, __use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+ _M_head(*this) = _M_head(__in);
+ return *this;
+      }
+
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_assignable<_Head>::value)
+      {
+ _M_head(*this) = std::forward<_Head>(_M_head(__in));
+ return *this;
+      }
+
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UHead>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+   return *this;
+ }
+
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead>&& __in)
+        {
+   _M_head(*this)
+     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+   return *this;
+ }
+
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(__is_nothrow_swappable<_Head>::value)
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+      }
+    };
+
+  template<typename... _Elements>
+    class tuple;
+
+
+
+  template<bool, typename... _Elements>
+  struct _TC
+  {
+    template<typename... _UElements>
+    static constexpr bool _ConstructibleTuple()
+    {
+      return __and_<is_constructible<_Elements, const _UElements&>...>::value;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyConvertibleTuple()
+    {
+      return __and_<is_convertible<const _UElements&, _Elements>...>::value;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _MoveConstructibleTuple()
+    {
+      return __and_<is_constructible<_Elements, _UElements&&>...>::value;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyMoveConvertibleTuple()
+    {
+      return __and_<is_convertible<_UElements&&, _Elements>...>::value;
+    }
+
+    template<typename _SrcTuple>
+    static constexpr bool _NonNestedTuple()
+    {
+      return __and_<__not_<is_same<tuple<_Elements...>,
+                                   typename remove_cv<
+                                     typename remove_reference<_SrcTuple>::type
+                                   >::type>>,
+                     __not_<is_convertible<_SrcTuple, _Elements...>>,
+                     __not_<is_constructible<_Elements..., _SrcTuple>>
+              >::value;
+    }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return __not_<is_same<tuple<_Elements...>,
+        typename remove_const<
+          typename remove_reference<_UElements...>::type
+          >::type>>::value;
+    }
+  };
+
+  template<typename... _Elements>
+  struct _TC<false, _Elements...>
+  {
+    template<typename... _UElements>
+    static constexpr bool _ConstructibleTuple()
+    {
+      return false;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyConvertibleTuple()
+    {
+      return false;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _MoveConstructibleTuple()
+    {
+      return false;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyMoveConvertibleTuple()
+    {
+      return false;
+    }
+
+    template<typename... _UElements>
+    static constexpr bool _NonNestedTuple()
+    {
+      return true;
+    }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return true;
+    }
+  };
+
+
+  template<typename... _Elements>
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+
+
+      template<typename _Dummy>
+      struct _TC2
+      {
+        static constexpr bool _DefaultConstructibleTuple()
+        {
+          return __and_<is_default_constructible<_Elements>...>::value;
+        }
+        static constexpr bool _ImplicitlyDefaultConstructibleTuple()
+        {
+          return __and_<__is_implicitly_default_constructible<_Elements>...>
+            ::value;
+        }
+      };
+
+    public:
+      template<typename _Dummy = void,
+               typename enable_if<_TC2<_Dummy>::
+                                    _ImplicitlyDefaultConstructibleTuple(),
+                                  bool>::type = true>
+      constexpr tuple()
+      : _Inherited() { }
+
+      template<typename _Dummy = void,
+               typename enable_if<_TC2<_Dummy>::
+                                    _DefaultConstructibleTuple()
+                                  &&
+                                  !_TC2<_Dummy>::
+                                    _ImplicitlyDefaultConstructibleTuple(),
+                                  bool>::type = false>
+      explicit constexpr tuple()
+      : _Inherited() { }
+
+
+
+      template<typename _Dummy> using _TCC =
+        _TC<is_same<_Dummy, void>::value,
+            _Elements...>;
+
+      template<typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>()
+                 && (sizeof...(_Elements) >= 1),
+               bool>::type=true>
+        constexpr tuple(const _Elements&... __elements)
+      : _Inherited(__elements...) { }
+
+      template<typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>()
+                 && (sizeof...(_Elements) >= 1),
+               bool>::type=false>
+      explicit constexpr tuple(const _Elements&... __elements)
+      : _Inherited(__elements...) { }
+
+
+
+      template<typename... _UElements> using _TMC =
+                  _TC<(sizeof...(_Elements) == sizeof...(_UElements)),
+                      _Elements...>;
+
+      template<typename... _UElements, typename
+        enable_if<
+    _TC<sizeof...(_UElements) == 1, _Elements...>::template
+      _NotSameTuple<_UElements...>()
+    && _TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && (sizeof...(_Elements) >= 1),
+        bool>::type=true>
+        constexpr tuple(_UElements&&... __elements)
+        : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      template<typename... _UElements, typename
+        enable_if<
+    _TC<sizeof...(_UElements) == 1, _Elements...>::template
+      _NotSameTuple<_UElements...>()
+    && _TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && (sizeof...(_Elements) >= 1),
+        bool>::type=false>
+        explicit constexpr tuple(_UElements&&... __elements)
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+
+
+      template<typename _Dummy> using _TNTC =
+        _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
+            _Elements...>;
+
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMC<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<const tuple<_UElements...>&>(),
+        bool>::type=true>
+        constexpr tuple(const tuple<_UElements...>& __in)
+        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+        { }
+
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMC<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<const tuple<_UElements...>&>(),
+        bool>::type=false>
+        explicit constexpr tuple(const tuple<_UElements...>& __in)
+        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+        { }
+
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=true>
+        constexpr tuple(tuple<_UElements...>&& __in)
+        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=false>
+        explicit constexpr tuple(tuple<_UElements...>&& __in)
+        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>(),
+               bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>(),
+               bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+        { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+        { }
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+      }
+
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+ static_cast<_Inherited&>(*this) = std::move(__in);
+ return *this;
+      }
+
+      template<typename... _UElements, typename = typename
+        enable_if<sizeof...(_UElements)
+    == sizeof...(_Elements)>::type>
+        tuple&
+        operator=(const tuple<_UElements...>& __in)
+        {
+   static_cast<_Inherited&>(*this) = __in;
+   return *this;
+ }
+
+      template<typename... _UElements, typename = typename
+        enable_if<sizeof...(_UElements)
+    == sizeof...(_Elements)>::type>
+        tuple&
+        operator=(tuple<_UElements...>&& __in)
+        {
+   static_cast<_Inherited&>(*this) = std::move(__in);
+   return *this;
+ }
+
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+  template<>
+    class tuple<>
+    {
+    public:
+      void swap(tuple&) noexcept { }
+    };
+
+
+
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+    public:
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                                     __is_implicitly_default_constructible<_U1>,
+                                     __is_implicitly_default_constructible<_U2>>
+                                   ::value, bool>::type = true>
+
+      constexpr tuple()
+      : _Inherited() { }
+
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<
+                  __and_<
+                    is_default_constructible<_U1>,
+                    is_default_constructible<_U2>,
+                    __not_<
+                      __and_<__is_implicitly_default_constructible<_U1>,
+                             __is_implicitly_default_constructible<_U2>>>>
+                  ::value, bool>::type = false>
+
+      explicit constexpr tuple()
+      : _Inherited() { }
+
+
+
+      template<typename _Dummy> using _TCC =
+        _TC<is_same<_Dummy, void>::value, _T1, _T2>;
+
+      template<typename _Dummy = void, typename
+               enable_if<_TCC<_Dummy>::template
+                           _ConstructibleTuple<_T1, _T2>()
+                         && _TCC<_Dummy>::template
+                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
+ bool>::type = true>
+        constexpr tuple(const _T1& __a1, const _T2& __a2)
+        : _Inherited(__a1, __a2) { }
+
+      template<typename _Dummy = void, typename
+               enable_if<_TCC<_Dummy>::template
+                           _ConstructibleTuple<_T1, _T2>()
+                         && !_TCC<_Dummy>::template
+                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
+        : _Inherited(__a1, __a2) { }
+
+
+
+      using _TMC = _TC<true, _T1, _T2>;
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(_U1&& __a1, _U2&& __a2)
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(const tuple<_U1, _U2>& __in)
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const tuple<_U1, _U2>& __in)
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(tuple<_U1, _U2>&& __in)
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(tuple<_U1, _U2>&& __in)
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(const pair<_U1, _U2>& __in)
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const pair<_U1, _U2>& __in)
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(pair<_U1, _U2>&& __in)
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(pair<_U1, _U2>&& __in)
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_T1, _T2>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
+               bool>::type=true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_T1, _T2>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
+               bool>::type=false>
+
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+      }
+
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+ static_cast<_Inherited&>(*this) = std::move(__in);
+ return *this;
+      }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+   static_cast<_Inherited&>(*this) = __in;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(tuple<_U1, _U2>&& __in)
+        {
+   static_cast<_Inherited&>(*this) = std::move(__in);
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+   this->_M_head(*this) = __in.first;
+   this->_M_tail(*this)._M_head(*this) = __in.second;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(pair<_U1, _U2>&& __in)
+        {
+   this->_M_head(*this) = std::forward<_U1>(__in.first);
+   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+   return *this;
+ }
+
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+
+
+
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+
+
+
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...>>
+    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr _Head&
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr const _Head&
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
+    get(tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
+    get(const tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<__element_type&&>(std::get<__i>(__t));
+    }
+
+
+
+
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr _Head&
+    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr const _Head&
+    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&
+    get(tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&&
+    get(tuple<_Types...>&& __t) noexcept
+    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&
+    get(const tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+
+  template<typename _Tp, typename _Up, size_t __i, size_t __size>
+    struct __tuple_compare
+    {
+      static constexpr bool
+      __eq(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) == std::get<__i>(__u))
+   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
+      }
+
+      static constexpr bool
+      __less(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) < std::get<__i>(__u))
+   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
+       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
+      }
+    };
+
+  template<typename _Tp, typename _Up, size_t __size>
+    struct __tuple_compare<_Tp, _Up, __size, __size>
+    {
+      static constexpr bool
+      __eq(const _Tp&, const _Up&) { return true; }
+
+      static constexpr bool
+      __less(const _Tp&, const _Up&) { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator==(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__eq(__t, __u);
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__less(__t, __u);
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator!=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+
+  template<typename... _Elements>
+    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
+    make_tuple(_Elements&&... __args)
+    {
+      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
+ __result_type;
+      return __result_type(std::forward<_Elements>(__args)...);
+    }
+
+
+
+  template<typename... _Elements>
+    constexpr tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+
+  template<typename... _Tps>
+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_tuple_like
+    : public __is_tuple_like_impl<typename std::remove_cv
+            <typename std::remove_reference<_Tp>::type>::type>::type
+    { };
+
+  template<size_t, typename, typename, size_t>
+    struct __make_tuple_impl;
+
+  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
+    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
+    : __make_tuple_impl<_Idx + 1,
+   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
+   _Tuple, _Nm>
+    { };
+
+  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
+    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
+    {
+      typedef tuple<_Tp...> __type;
+    };
+
+  template<typename _Tuple>
+    struct __do_make_tuple
+    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
+    { };
+
+
+  template<typename _Tuple>
+    struct __make_tuple
+    : public __do_make_tuple<typename std::remove_cv
+            <typename std::remove_reference<_Tuple>::type>::type>
+    { };
+
+
+  template<typename...>
+    struct __combine_tuples;
+
+  template<>
+    struct __combine_tuples<>
+    {
+      typedef tuple<> __type;
+    };
+
+  template<typename... _Ts>
+    struct __combine_tuples<tuple<_Ts...>>
+    {
+      typedef tuple<_Ts...> __type;
+    };
+
+  template<typename... _T1s, typename... _T2s, typename... _Rem>
+    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
+    {
+      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
+     _Rem...>::__type __type;
+    };
+
+
+  template<typename... _Tpls>
+    struct __tuple_cat_result
+    {
+      typedef typename __combine_tuples
+        <typename __make_tuple<_Tpls>::__type...>::__type __type;
+    };
+
+
+
+  template<typename...>
+    struct __make_1st_indices;
+
+  template<>
+    struct __make_1st_indices<>
+    {
+      typedef std::_Index_tuple<> __type;
+    };
+
+  template<typename _Tp, typename... _Tpls>
+    struct __make_1st_indices<_Tp, _Tpls...>
+    {
+      typedef typename std::_Build_index_tuple<std::tuple_size<
+ typename std::remove_reference<_Tp>::type>::value>::__type __type;
+    };
+
+
+
+
+  template<typename _Ret, typename _Indices, typename... _Tpls>
+    struct __tuple_concater;
+
+  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
+    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
+    {
+      template<typename... _Us>
+        static constexpr _Ret
+        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
+        {
+   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
+   return __next::_S_do(std::forward<_Tpls>(__tps)...,
+          std::forward<_Us>(__us)...,
+          std::get<_Is>(std::forward<_Tp>(__tp))...);
+ }
+    };
+
+  template<typename _Ret>
+    struct __tuple_concater<_Ret, std::_Index_tuple<>>
+    {
+      template<typename... _Us>
+ static constexpr _Ret
+ _S_do(_Us&&... __us)
+        {
+   return _Ret(std::forward<_Us>(__us)...);
+ }
+    };
+
+
+  template<typename... _Tpls, typename = typename
+           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
+    constexpr auto
+    tuple_cat(_Tpls&&... __tpls)
+    -> typename __tuple_cat_result<_Tpls...>::__type
+    {
+      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
+      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
+      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
+    }
+
+
+
+
+  template<typename... _Elements>
+    constexpr tuple<_Elements&...>
+    tie(_Elements&... __args) noexcept
+    { return tuple<_Elements&...>(__args...); }
+
+
+  template<typename... _Elements>
+    inline void
+    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      const _Swallow_assign&
+      operator=(const _Tp&) const
+      { return *this; }
+  };
+
+  const _Swallow_assign ignore{};
+
+
+  template<typename... _Types, typename _Alloc>
+    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
+
+
+  template<class _T1, class _T2>
+    template<typename... _Args1, typename... _Args2>
+      inline
+      pair<_T1, _T2>::
+      pair(piecewise_construct_t,
+    tuple<_Args1...> __first, tuple<_Args2...> __second)
+      : pair(__first, __second,
+      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
+      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
+      { }
+
+  template<class _T1, class _T2>
+    template<typename... _Args1, std::size_t... _Indexes1,
+             typename... _Args2, std::size_t... _Indexes2>
+      inline
+      pair<_T1, _T2>::
+      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
+    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
+      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
+        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
+      { }
+
+
+
+
+}
+# 56 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _MemberPointer>
+    class _Mem_fn;
+  template<typename _Tp, typename _Class>
+    _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::*) noexcept;
+
+
+  template<typename _Functor, typename = __void_t<>>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<_Functor,
+      __void_t<typename _Functor::result_type>>
+    { typedef typename _Functor::result_type result_type; };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Functor>
+    { };
+
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
+      const volatile>
+    { typedef _Res result_type; };
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
+      const volatile>
+    { typedef _Res result_type; };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+    { };
+
+  template<typename _Tp, typename _Up = typename decay<_Tp>::type>
+    struct __inv_unwrap
+    {
+      using type = _Tp;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
+    {
+      using type = _Up&;
+    };
+
+
+
+  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
+    inline _Up&&
+    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Up&&>(__t); }
+
+  template<typename _Res, typename _Fn, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...)))
+    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    noexcept(noexcept(
+   (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...)))
+    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    noexcept(noexcept(
+   ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...)))
+    {
+      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    inline _Res
+    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
+    noexcept(noexcept(__invfwd<_Tp>(__t).*__f))
+    { return __invfwd<_Tp>(__t).*__f; }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    inline _Res
+    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
+    noexcept(noexcept((*std::forward<_Tp>(__t)).*__f))
+    { return (*std::forward<_Tp>(__t)).*__f; }
+
+
+  template<typename _Callable, typename... _Args>
+    inline typename result_of<_Callable&&(_Args&&...)>::type
+    __invoke(_Callable&& __fn, _Args&&... __args)
+    {
+      using __result_of = result_of<_Callable&&(_Args&&...)>;
+      using __type = typename __result_of::type;
+      using __tag = typename __result_of::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+# 272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<bool _Unary, bool _Binary, typename _Tp>
+    struct _Reference_wrapper_base_impl;
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, false, _Tp>
+    : _Weak_result_type<_Tp>
+    { };
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, false, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::argument_type argument_type;
+    };
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base_impl<false, true, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+
+   template<typename _Tp>
+    struct _Reference_wrapper_base_impl<true, true, _Tp>
+    : _Weak_result_type<_Tp>
+    {
+      typedef typename _Tp::argument_type argument_type;
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+  template<typename _Tp, typename = __void_t<>> struct __has_argument_type : false_type { }; template<typename _Tp> struct __has_argument_type<_Tp, __void_t<typename _Tp::argument_type>> : true_type { };
+  template<typename _Tp, typename = __void_t<>> struct __has_first_argument_type : false_type { }; template<typename _Tp> struct __has_first_argument_type<_Tp, __void_t<typename _Tp::first_argument_type>> : true_type { };
+  template<typename _Tp, typename = __void_t<>> struct __has_second_argument_type : false_type { }; template<typename _Tp> struct __has_second_argument_type<_Tp, __void_t<typename _Tp::second_argument_type>> : true_type { };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Reference_wrapper_base_impl<
+      __has_argument_type<_Tp>::value,
+      __has_first_argument_type<_Tp>::value
+      && __has_second_argument_type<_Tp>::value,
+      _Tp>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(*)(_T1)>
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)()>
+    : unary_function<_T1*, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+    : binary_function<_T1*, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const>
+    : unary_function<const _T1*, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+    : binary_function<const _T1*, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+    : unary_function<volatile _T1*, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+    : binary_function<volatile _T1*, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+    : unary_function<const volatile _T1*, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+    : binary_function<const volatile _T1*, _T2, _Res>
+    { };
+
+
+
+
+
+
+  template<typename _Tp>
+    class reference_wrapper
+    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+    {
+      _Tp* _M_data;
+
+    public:
+      typedef _Tp type;
+
+      reference_wrapper(_Tp& __indata) noexcept
+      : _M_data(std::__addressof(__indata))
+      { }
+
+      reference_wrapper(_Tp&&) = delete;
+
+      reference_wrapper(const reference_wrapper&) = default;
+
+      reference_wrapper&
+      operator=(const reference_wrapper&) = default;
+
+      operator _Tp&() const noexcept
+      { return this->get(); }
+
+      _Tp&
+      get() const noexcept
+      { return *_M_data; }
+
+      template<typename... _Args>
+ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+   return std::__invoke(get(), std::forward<_Args>(__args)...);
+ }
+    };
+
+
+
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t) noexcept
+    { return reference_wrapper<_Tp>(__t); }
+
+
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t) noexcept
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    void ref(const _Tp&&) = delete;
+
+  template<typename _Tp>
+    void cref(const _Tp&&) = delete;
+
+
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t) noexcept
+    { return ref(__t.get()); }
+
+
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t) noexcept
+    { return cref(__t.get()); }
+
+
+
+  template<typename... _Types>
+    struct _Pack : integral_constant<size_t, sizeof...(_Types)>
+    { };
+
+  template<typename _From, typename _To, bool = _From::value == _To::value>
+    struct _AllConvertible : false_type
+    { };
+
+  template<typename... _From, typename... _To>
+    struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
+    : __and_<is_convertible<_From, _To>...>
+    { };
+
+  template<typename _Tp1, typename _Tp2>
+    using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
+        typename std::decay<_Tp2>::type>>;
+
+
+
+
+
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Maybe_unary_or_binary_function { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  template<typename _Signature>
+    struct _Mem_fn_traits;
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Mem_fn_traits_base
+    {
+      using __result_type = _Res;
+      using __maybe_type
+ = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
+      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
+    };
+# 569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+
+
+
+
+  template<typename _MemFunPtr,
+    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
+    class _Mem_fn_base
+    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using _Traits = _Mem_fn_traits<_MemFunPtr>;
+
+      using _Arity = typename _Traits::__arity;
+      using _Varargs = typename _Traits::__vararg;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemFunPtr _M_pmf;
+
+    public:
+
+      using result_type = typename _Traits::__result_type;
+
+      explicit constexpr
+      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
+
+      template<typename... _Args>
+ auto
+ operator()(_Args&&... __args) const
+ noexcept(noexcept(
+       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
+ -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
+ { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
+    };
+
+
+  template<typename _MemObjPtr>
+    class _Mem_fn_base<_MemObjPtr, false>
+    {
+      using _Arity = integral_constant<size_t, 0>;
+      using _Varargs = false_type;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemObjPtr _M_pm;
+
+    public:
+      explicit constexpr
+      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
+
+      template<typename _Tp>
+ auto
+ operator()(_Tp&& __obj) const
+ noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
+ -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
+ { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
+    };
+
+  template<typename _Res, typename _Class>
+    struct _Mem_fn<_Res _Class::*>
+    : _Mem_fn_base<_Res _Class::*>
+    {
+      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
+    };
+# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Tp, typename _Class>
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm) noexcept
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+# 660 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Tp>
+    struct is_bind_expression
+    : public false_type { };
+# 671 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Tp>
+    struct is_placeholder
+    : public integral_constant<int, 0>
+    { };
+
+
+
+
+  template<int _Num> struct _Placeholder { };
+
+
+
+
+
+
+
+  namespace placeholders
+  {
+
+
+
+
+
+    extern const _Placeholder<1> _1;
+    extern const _Placeholder<2> _2;
+    extern const _Placeholder<3> _3;
+    extern const _Placeholder<4> _4;
+    extern const _Placeholder<5> _5;
+    extern const _Placeholder<6> _6;
+    extern const _Placeholder<7> _7;
+    extern const _Placeholder<8> _8;
+    extern const _Placeholder<9> _9;
+    extern const _Placeholder<10> _10;
+    extern const _Placeholder<11> _11;
+    extern const _Placeholder<12> _12;
+    extern const _Placeholder<13> _13;
+    extern const _Placeholder<14> _14;
+    extern const _Placeholder<15> _15;
+    extern const _Placeholder<16> _16;
+    extern const _Placeholder<17> _17;
+    extern const _Placeholder<18> _18;
+    extern const _Placeholder<19> _19;
+    extern const _Placeholder<20> _20;
+    extern const _Placeholder<21> _21;
+    extern const _Placeholder<22> _22;
+    extern const _Placeholder<23> _23;
+    extern const _Placeholder<24> _24;
+    extern const _Placeholder<25> _25;
+    extern const _Placeholder<26> _26;
+    extern const _Placeholder<27> _27;
+    extern const _Placeholder<28> _28;
+    extern const _Placeholder<29> _29;
+
+  }
+# 733 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const _Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+
+
+ template<std::size_t __i, typename _Tuple>
+   using _Safe_tuple_element_t
+     = typename enable_if<(__i < tuple_size<_Tuple>::value),
+     tuple_element<__i, _Tuple>>::type::type;
+# 761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Arg,
+    bool _IsBindExp = is_bind_expression<_Arg>::value,
+    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+
+
+
+
+
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+
+
+
+
+      template<typename _CVRef, typename _Tuple>
+ _Tp&
+ operator()(_CVRef& __arg, _Tuple&) const volatile
+ { return __arg.get(); }
+    };
+
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _CVArg, typename... _Args>
+ auto
+ operator()(_CVArg& __arg,
+     tuple<_Args...>& __tuple) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+
+   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+     _Indexes;
+   return this->__call(__arg, __tuple, _Indexes());
+ }
+
+    private:
+
+
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
+ auto
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
+        const _Index_tuple<_Indexes...>&) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+   return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Tuple>
+ _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+ {
+   using __type
+     = __tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>;
+   return std::forward<__type>(
+       ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _CVArg, typename _Tuple>
+ _CVArg&&
+ operator()(_CVArg&& __arg, _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _Maybe_wrap_member_pointer
+    {
+      typedef _Tp type;
+
+      static constexpr const _Tp&
+      __do_wrap(const _Tp& __x)
+      { return __x; }
+
+      static constexpr _Tp&&
+      __do_wrap(_Tp&& __x)
+      { return static_cast<_Tp&&>(__x); }
+    };
+
+
+
+
+
+
+  template<typename _Tp, typename _Class>
+    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
+    {
+      typedef _Mem_fn<_Tp _Class::*> type;
+
+      static constexpr type
+      __do_wrap(_Tp _Class::* __pm)
+      { return type(__pm); }
+    };
+
+
+
+
+
+  template<>
+    struct _Maybe_wrap_member_pointer<void>
+    {
+      typedef void type;
+    };
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
+    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(const volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
+    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
+
+
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef _Bind __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_v(tuple<_Args...>&& __args,
+   _Index_tuple<_Indexes...>) volatile
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c_v(tuple<_Args...>&& __args,
+     _Index_tuple<_Indexes...>) const volatile
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+     public:
+      template<typename... _Args>
+ explicit _Bind(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit _Bind(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind(const _Bind&) = default;
+
+      _Bind(_Bind&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+
+
+      template<typename... _Args, typename _Result
+ = decltype( std::declval<_Functor&>()(
+       _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
+      std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args, typename _Result
+ = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+         typename add_const<_Functor>::type&>::type>()(
+       _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
+      std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args) const
+ {
+   return this->__call_c<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args, typename _Result
+ = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+                       typename add_volatile<_Functor>::type&>::type>()(
+       _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
+      std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args, typename _Result
+ = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
+                       typename add_cv<_Functor>::type&>::type>()(
+       _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
+      std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call_c_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+
+
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef _Bind_result __self_type;
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Res>
+ struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
+      template<typename _Res>
+ struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __disable_if_void<_Res>::type = 0)
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __enable_if_void<_Res>::type = 0)
+ {
+   _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __disable_if_void<_Res>::type = 0) const
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __enable_if_void<_Res>::type = 0) const
+ {
+   _M_f(_Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __disable_if_void<_Res>::type = 0) volatile
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __enable_if_void<_Res>::type = 0) volatile
+ {
+   _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+     typename __disable_if_void<_Res>::type = 0) const volatile
+ {
+   return _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ void
+ __call(tuple<_Args...>&& __args,
+        _Index_tuple<_Indexes...>,
+     typename __enable_if_void<_Res>::type = 0) const volatile
+ {
+   _M_f(_Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+    public:
+      typedef _Result result_type;
+
+      template<typename... _Args>
+ explicit _Bind_result(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit _Bind_result(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind_result(const _Bind_result&) = default;
+
+      _Bind_result(_Bind_result&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+
+
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args) const
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_check_arity { };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Tp, typename _Class, typename... _BoundArgs>
+    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
+    {
+      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
+      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
+      static_assert(_Varargs::value
+      ? sizeof...(_BoundArgs) >= _Arity::value + 1
+      : sizeof...(_BoundArgs) == _Arity::value + 1,
+      "Wrong number of arguments for pointer-to-member");
+    };
+
+
+
+
+  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
+    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
+
+  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
+    struct _Bind_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+ __maybe_type;
+      typedef typename __maybe_type::type __func_type;
+      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
+    };
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_helper<true, _Func, _BoundArgs...>
+    { };
+
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    inline typename
+    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::type __result_type;
+      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
+      std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    struct _Bindres_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+ __maybe_type;
+      typedef typename __maybe_type::type __functor_type;
+      typedef _Bind_result<_Result,
+      __functor_type(typename decay<_BoundArgs>::type...)>
+ type;
+    };
+
+
+
+
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    inline
+    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::type __result_type;
+      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
+      std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Signature>
+    struct _Bind_simple;
+
+  template<typename _Callable, typename... _Args>
+    struct _Bind_simple<_Callable(_Args...)>
+    {
+      typedef typename result_of<_Callable(_Args...)>::type result_type;
+
+      template<typename _Tp, typename... _Up>
+        explicit
+        _Bind_simple(_Tp&& __f, _Up&&... __args)
+        : _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
+        { }
+
+      _Bind_simple(const _Bind_simple&) = default;
+      _Bind_simple(_Bind_simple&&) = default;
+
+      result_type
+      operator()()
+      {
+        typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
+        return _M_invoke(_Indices());
+      }
+
+    private:
+      template<std::size_t... _Indices>
+        typename result_of<_Callable(_Args...)>::type
+        _M_invoke(_Index_tuple<_Indices...>)
+        {
+
+
+          return std::forward<_Callable>(std::get<0>(_M_bound))(
+              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
+        }
+
+      std::tuple<_Callable, _Args...> _M_bound;
+    };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_simple_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+        __maybe_type;
+      typedef typename __maybe_type::type __func_type;
+      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
+        __type;
+    };
+
+
+
+  template<typename _Callable, typename... _Args>
+    typename _Bind_simple_helper<_Callable, _Args...>::__type
+    __bind_simple(_Callable&& __callable, _Args&&... __args)
+    {
+      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::__type __result_type;
+      return __result_type(
+          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
+          std::forward<_Args>(__args)...);
+    }
+
+
+
+
+
+
+  class bad_function_call : public std::exception
+  {
+  public:
+    virtual ~bad_function_call() noexcept;
+
+    const char* what() const noexcept;
+  };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __is_location_invariant
+    : is_trivially_copyable<_Tp>::type
+    { };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void* _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union [[gnu::may_alias]] _Any_data
+  {
+    void* _M_access() { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+
+
+  template<typename _Tp>
+    struct _Simple_type_wrapper
+    {
+      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+      _Tp __value;
+    };
+
+  template<typename _Tp>
+    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+    : __is_location_invariant<_Tp>
+    { };
+
+
+
+  template<typename _Functor>
+    inline _Functor&
+    __callable_functor(_Functor& __f)
+    { return __f; }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* volatile &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Member, typename _Class>
+    inline _Mem_fn<_Member _Class::*>
+    __callable_functor(_Member _Class::* const volatile &__p)
+    { return std::mem_fn(__p); }
+
+  template<typename _Signature>
+    class function;
+
+
+  class _Function_base
+  {
+  public:
+    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+  && sizeof(_Functor) <= _M_max_size
+  && __alignof__(_Functor) <= _M_max_align
+  && (_M_max_align % __alignof__(_Functor) == 0));
+
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+   const _Functor* __ptr =
+     __stored_locally? std::__addressof(__source._M_access<_Functor>())
+                                 : __source._M_access<_Functor*>();
+   return const_cast<_Functor*>(__ptr);
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+   __dest._M_access<_Functor*>() =
+     new _Functor(*__source._M_access<_Functor*>());
+ }
+
+
+
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+   __victim._M_access<_Functor>().~_Functor();
+ }
+
+
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+   delete __victim._M_access<_Functor*>();
+ }
+
+      public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+     _Manager_operation __op)
+ {
+   switch (__op)
+     {
+
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+       break;
+
+     case __clone_functor:
+       _M_clone(__dest, __source, _Local_storage());
+       break;
+
+     case __destroy_functor:
+       _M_destroy(__dest, _Local_storage());
+       break;
+     }
+   return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f)
+ { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+
+ template<typename _Signature>
+   static bool
+   _M_not_empty_function(const function<_Signature>& __f)
+   { return static_cast<bool>(__f); }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp* __fp)
+   { return __fp != nullptr; }
+
+ template<typename _Class, typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp _Class::* __mp)
+   { return __mp != nullptr; }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(const _Tp&)
+   { return true; }
+
+      private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+ { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+      };
+
+    template<typename _Functor>
+      class _Ref_manager : public _Base_manager<_Functor*>
+      {
+ typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+      public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+     _Manager_operation __op)
+ {
+   switch (__op)
+     {
+
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+       return is_const<_Functor>::value;
+       break;
+
+     default:
+       _Base::_M_manager(__dest, __source, __op);
+     }
+   return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+ {
+   _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
+ }
+      };
+
+    _Function_base() : _M_manager(nullptr) { }
+
+    ~_Function_base()
+    {
+      if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+      _Manager_operation);
+
+    _Any_data _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return (*_Base::_M_get_pointer(__functor))(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ (*_Base::_M_get_pointer(__functor))(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return std::__callable_functor(**_Base::_M_get_pointer(__functor))(
+       std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+    : public _Function_base::_Ref_manager<_Functor>
+    {
+      typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ std::__callable_functor(**_Base::_M_get_pointer(__functor))(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename _Res,
+    typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    {
+      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ _Base;
+
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _Class, typename _Member, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    : public _Function_base::_Base_manager<
+   _Simple_type_wrapper< _Member _Class::* > >
+    {
+      typedef _Member _Class::* _Functor;
+      typedef _Simple_type_wrapper<_Functor> _Wrapper;
+      typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+    public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+   _Manager_operation __op)
+      {
+ switch (__op)
+   {
+
+   case __get_type_info:
+     __dest._M_access<const type_info*>() = &typeid(_Functor);
+     break;
+
+   case __get_functor_ptr:
+     __dest._M_access<_Functor*>() =
+       &_Base::_M_get_pointer(__source)->__value;
+     break;
+
+   default:
+     _Base::_M_manager(__dest, __source, __op);
+   }
+ return false;
+      }
+
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+  template<typename _From, typename _To>
+    using __check_func_return_type
+      = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
+
+
+
+
+
+
+
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      typedef _Res _Signature_type(_ArgTypes...);
+
+      template<typename _Func,
+        typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
+ struct _Callable : __check_func_return_type<_Res2, _Res> { };
+
+
+
+      template<typename _Tp>
+ struct _Callable<function, _Tp> : false_type { };
+
+      template<typename _Cond, typename _Tp>
+ using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+
+    public:
+      typedef _Res result_type;
+
+
+
+
+
+
+
+      function() noexcept
+      : _Function_base() { }
+
+
+
+
+
+      function(nullptr_t) noexcept
+      : _Function_base() { }
+# 1879 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      function(const function& __x);
+# 1888 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      function(function&& __x) : _Function_base()
+      {
+ __x.swap(*this);
+      }
+# 1911 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      template<typename _Functor,
+        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
+        typename = _Requires<_Callable<_Functor>, void>>
+ function(_Functor);
+# 1928 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      function&
+      operator=(const function& __x)
+      {
+ function(__x).swap(*this);
+ return *this;
+      }
+# 1946 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      function&
+      operator=(function&& __x)
+      {
+ function(std::move(__x)).swap(*this);
+ return *this;
+      }
+# 1960 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      function&
+      operator=(nullptr_t) noexcept
+      {
+ if (_M_manager)
+   {
+     _M_manager(_M_functor, _M_functor, __destroy_functor);
+     _M_manager = nullptr;
+     _M_invoker = nullptr;
+   }
+ return *this;
+      }
+# 1988 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      template<typename _Functor>
+ _Requires<_Callable<typename decay<_Functor>::type>, function&>
+ operator=(_Functor&& __f)
+ {
+   function(std::forward<_Functor>(__f)).swap(*this);
+   return *this;
+ }
+
+
+      template<typename _Functor>
+ function&
+ operator=(reference_wrapper<_Functor> __f) noexcept
+ {
+   function(__f).swap(*this);
+   return *this;
+ }
+# 2014 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      void swap(function& __x) noexcept
+      {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+ std::swap(_M_invoker, __x._M_invoker);
+      }
+# 2042 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      explicit operator bool() const noexcept
+      { return !_M_empty(); }
+# 2055 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      _Res operator()(_ArgTypes... __args) const;
+# 2068 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      const type_info& target_type() const noexcept;
+# 2079 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+      template<typename _Functor> _Functor* target() noexcept;
+
+
+      template<typename _Functor> const _Functor* target() const noexcept;
+
+
+    private:
+      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
+      _Invoker_type _M_invoker;
+  };
+
+
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+ {
+   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+   _M_invoker = __x._M_invoker;
+   _M_manager = __x._M_manager;
+ }
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor, typename, typename>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f)
+      : _Function_base()
+      {
+ typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+ if (_My_handler::_M_not_empty_function(__f))
+   {
+     _My_handler::_M_init_functor(_M_functor, std::move(__f));
+     _M_invoker = &_My_handler::_M_invoke;
+     _M_manager = &_My_handler::_M_manager;
+   }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+ __throw_bad_function_call();
+      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+    }
+
+
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const noexcept
+    {
+      if (_M_manager)
+ {
+   _Any_data __typeinfo_result;
+   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+   return *__typeinfo_result._M_access<const type_info*>();
+ }
+      else
+ return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() noexcept
+      {
+ if (typeid(_Functor) == target_type() && _M_manager)
+   {
+     _Any_data __ptr;
+     if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+  && !is_const<_Functor>::value)
+       return 0;
+     else
+       return __ptr._M_access<_Functor*>();
+   }
+ else
+   return 0;
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const noexcept
+      {
+ if (typeid(_Functor) == target_type() && _M_manager)
+   {
+     _Any_data __ptr;
+     _M_manager(__ptr, _M_functor, __get_functor_ptr);
+     return __ptr._M_access<const _Functor*>();
+   }
+ else
+   return 0;
+      }
+# 2191 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return !static_cast<bool>(__f); }
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return !static_cast<bool>(__f); }
+# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return static_cast<bool>(__f); }
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return static_cast<bool>(__f); }
+# 2229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
+  template<typename _Res, typename... _Args>
+    inline void
+    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+    { __x.swap(__y); }
+
+
+}
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+
+
+
+namespace JS {
+template<class T>
+class Heap;
+}
+
+class nsRegion;
+namespace mozilla {
+namespace layers {
+struct TileClient;
+}
+}
+
+namespace mozilla {
+struct SerializedStructuredCloneBuffer;
+class SourceBufferTask;
+}
+
+namespace mozilla {
+namespace dom {
+namespace ipc {
+class StructuredCloneData;
+}
+}
+}
+
+namespace mozilla {
+namespace dom {
+class ClonedMessageData;
+class MessagePortMessage;
+namespace indexedDB {
+struct StructuredCloneReadInfo;
+class SerializedStructuredCloneReadInfo;
+class ObjectStoreCursorResponse;
+}
+}
+}
+
+class JSStructuredCloneData;
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+struct nsTArrayFallibleResult
+{
+
+               nsTArrayFallibleResult(bool aResult) : mResult(aResult) {}
+
+               operator bool() { return mResult; }
+
+private:
+  bool mResult;
+};
+
+struct nsTArrayInfallibleResult
+{
+};
+
+
+
+
+
+
+struct nsTArrayFallibleAllocatorBase
+{
+  typedef bool ResultType;
+  typedef nsTArrayFallibleResult ResultTypeProxy;
+
+  static ResultType Result(ResultTypeProxy aResult) { return aResult; }
+  static bool Successful(ResultTypeProxy aResult) { return aResult; }
+  static ResultTypeProxy SuccessResult() { return true; }
+  static ResultTypeProxy FailureResult() { return false; }
+  static ResultType ConvertBoolToResultType(bool aValue) { return aValue; }
+};
+
+struct nsTArrayInfallibleAllocatorBase
+{
+  typedef void ResultType;
+  typedef nsTArrayInfallibleResult ResultTypeProxy;
+
+  static ResultType Result(ResultTypeProxy aResult) {}
+  static bool Successful(ResultTypeProxy) { return true; }
+  static ResultTypeProxy SuccessResult() { return ResultTypeProxy(); }
+
+  static ResultTypeProxy FailureResult()
+  {
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "Infallible nsTArray should never fail" ")"); do { *((volatile int*) __null) = 180; ::abort(); } while (0); } while (0);
+    return ResultTypeProxy();
+  }
+
+  static ResultType ConvertBoolToResultType(bool aValue)
+  {
+    if (!aValue) {
+      do { AnnotateMozCrashReason("MOZ_CRASH(" "infallible nsTArray should never convert false to ResultType" ")"); do { *((volatile int*) __null) = 187; ::abort(); } while (0); } while (0);
+    }
+  }
+};
+
+struct nsTArrayFallibleAllocator : nsTArrayFallibleAllocatorBase
+{
+  static void* Malloc(size_t aSize) { return malloc(aSize); }
+  static void* Realloc(void* aPtr, size_t aSize)
+  {
+    return realloc(aPtr, aSize);
+  }
+
+  static void Free(void* aPtr) { free(aPtr); }
+  static void SizeTooBig(size_t) {}
+};
+
+
+
+
+struct nsTArrayInfallibleAllocator : nsTArrayInfallibleAllocatorBase
+{
+  static void* Malloc(size_t aSize) { return moz_xmalloc(aSize); }
+  static void* Realloc(void* aPtr, size_t aSize)
+  {
+    return moz_xrealloc(aPtr, aSize);
+  }
+
+  static void Free(void* aPtr) { free(aPtr); }
+  static void SizeTooBig(size_t aSize) { NS_ABORT_OOM(aSize); }
+};
+# 251 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+struct nsTArrayHeader
+{
+  static nsTArrayHeader sEmptyHdr;
+
+  uint32_t mLength;
+  uint32_t mCapacity : 31;
+  uint32_t mIsAutoArray : 1;
+};
+
+
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtHelper
+{
+  typedef E* elem_type;
+  typedef size_t index_type;
+
+
+
+
+  elem_type& SafeElementAt(index_type aIndex);
+  const elem_type& SafeElementAt(index_type aIndex) const;
+};
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtHelper<E*, Derived>
+{
+  typedef E* elem_type;
+
+  typedef size_t index_type;
+
+  elem_type SafeElementAt(index_type aIndex)
+  {
+    return static_cast<Derived*>(this)->SafeElementAt(aIndex, nullptr);
+  }
+
+
+
+
+
+  elem_type SafeElementAt(index_type aIndex) const
+  {
+    return static_cast<const Derived*>(this)->SafeElementAt(aIndex, nullptr);
+  }
+};
+
+
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtSmartPtrHelper
+{
+  typedef E* elem_type;
+  typedef const E* const_elem_type;
+  typedef size_t index_type;
+
+  elem_type SafeElementAt(index_type aIndex)
+  {
+    return static_cast<Derived*>(this)->SafeElementAt(aIndex, nullptr);
+  }
+
+
+  elem_type SafeElementAt(index_type aIndex) const
+  {
+    return static_cast<const Derived*>(this)->SafeElementAt(aIndex, nullptr);
+  }
+};
+
+template<class T> class nsCOMPtr;
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtHelper<nsCOMPtr<E>, Derived>
+  : public nsTArray_SafeElementAtSmartPtrHelper<E, Derived>
+{
+};
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtHelper<RefPtr<E>, Derived>
+  : public nsTArray_SafeElementAtSmartPtrHelper<E, Derived>
+{
+};
+
+namespace mozilla {
+template<class T> class OwningNonNull;
+}
+
+template<class E, class Derived>
+struct nsTArray_SafeElementAtHelper<mozilla::OwningNonNull<E>, Derived>
+{
+  typedef E* elem_type;
+  typedef const E* const_elem_type;
+  typedef size_t index_type;
+
+  elem_type SafeElementAt(index_type aIndex)
+  {
+    if (aIndex < static_cast<Derived*>(this)->Length()) {
+      return static_cast<Derived*>(this)->ElementAt(aIndex);
+    }
+    return nullptr;
+  }
+
+
+  elem_type SafeElementAt(index_type aIndex) const
+  {
+    if (aIndex < static_cast<const Derived*>(this)->Length()) {
+      return static_cast<const Derived*>(this)->ElementAt(aIndex);
+    }
+    return nullptr;
+  }
+};
+
+
+extern "C" void Gecko_EnsureTArrayCapacity(void* aArray,
+                                           size_t aCapacity,
+                                           size_t aElementSize);
+extern "C" void Gecko_ClearPODTArray(void* aArray,
+                                     size_t aElementSize,
+                                     size_t aElementAlign);
+
+__attribute__((noreturn)) __attribute__ ((cold)) void
+InvalidArrayIndex_CRASH(size_t aIndex, size_t aLength);
+
+
+
+
+
+
+template<class Alloc, class Copy>
+class nsTArray_base
+{
+
+
+
+  template<class Allocator, class Copier>
+  friend class nsTArray_base;
+  friend void Gecko_EnsureTArrayCapacity(void* aArray, size_t aCapacity,
+                                         size_t aElemSize);
+  friend void Gecko_ClearPODTArray(void* aTArray, size_t aElementSize,
+                                   size_t aElementAlign);
+
+protected:
+  typedef nsTArrayHeader Header;
+
+public:
+  typedef size_t size_type;
+  typedef size_t index_type;
+
+
+  size_type Length() const { return mHdr->mLength; }
+
+
+  bool IsEmpty() const { return Length() == 0; }
+
+
+
+
+  size_type Capacity() const { return mHdr->mCapacity; }
+
+
+
+
+
+protected:
+  nsTArray_base();
+
+  ~nsTArray_base();
+
+
+
+
+
+  template<typename ActualAlloc>
+  typename ActualAlloc::ResultTypeProxy EnsureCapacity(size_type aCapacity,
+                                                       size_type aElemSize);
+
+
+
+
+
+  void ShrinkCapacity(size_type aElemSize, size_t aElemAlign);
+# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<typename ActualAlloc>
+  void ShiftData(index_type aStart, size_type aOldLen, size_type aNewLen,
+                 size_type aElemSize, size_t aElemAlign);
+
+
+
+
+
+  void IncrementLength(size_t aNum)
+  {
+    if (mHdr == EmptyHdr()) {
+      if ((__builtin_expect(!!(aNum != 0), 0))) {
+
+        do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 452; ::abort(); } while (0); } while (0);
+      }
+    } else {
+      mHdr->mLength += aNum;
+    }
+  }
+
+
+
+
+
+
+
+  template<typename ActualAlloc>
+  bool InsertSlotsAt(index_type aIndex, size_type aCount,
+                     size_type aElementSize, size_t aElemAlign);
+
+  template<typename ActualAlloc, class Allocator>
+  typename ActualAlloc::ResultTypeProxy
+  SwapArrayElements(nsTArray_base<Allocator, Copy>& aOther,
+                    size_type aElemSize,
+                    size_t aElemAlign);
+
+
+  class IsAutoArrayRestorer
+  {
+  public:
+    IsAutoArrayRestorer(nsTArray_base<Alloc, Copy>& aArray, size_t aElemAlign);
+    ~IsAutoArrayRestorer();
+
+  private:
+    nsTArray_base<Alloc, Copy>& mArray;
+    size_t mElemAlign;
+    bool mIsAuto;
+  };
+
+
+
+  template<typename ActualAlloc>
+  bool EnsureNotUsingAutoArrayBuffer(size_type aElemSize);
+
+
+  bool IsAutoArray() const { return mHdr->mIsAutoArray; }
+
+
+  Header* GetAutoArrayBuffer(size_t aElemAlign)
+  {
+    do { } while (0);
+    return GetAutoArrayBufferUnsafe(aElemAlign);
+  }
+  const Header* GetAutoArrayBuffer(size_t aElemAlign) const
+  {
+    do { } while (0);
+    return GetAutoArrayBufferUnsafe(aElemAlign);
+  }
+
+
+
+  Header* GetAutoArrayBufferUnsafe(size_t aElemAlign)
+  {
+    return const_cast<Header*>(static_cast<const nsTArray_base<Alloc, Copy>*>(
+      this)->GetAutoArrayBufferUnsafe(aElemAlign));
+  }
+  const Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) const;
+
+
+
+  bool UsesAutoArrayBuffer() const;
+
+
+
+  Header* mHdr;
+
+  Header* Hdr() const { return mHdr; }
+  Header** PtrToHdr() { return &mHdr; }
+  static Header* EmptyHdr() { return &Header::sEmptyHdr; }
+};
+
+
+
+
+
+template<class E>
+class nsTArrayElementTraits
+{
+public:
+
+  static inline void Construct(E* aE)
+  {
+
+
+
+
+
+    new (static_cast<void*>(aE)) E;
+  }
+
+  template<class A>
+  static inline void Construct(E* aE, A&& aArg)
+  {
+    typedef typename mozilla::RemoveCV<E>::Type E_NoCV;
+    typedef typename mozilla::RemoveCV<A>::Type A_NoCV;
+    static_assert(!mozilla::IsSame<E_NoCV*, A_NoCV>::value,
+                  "For safety, we disallow constructing nsTArray<E> elements "
+                  "from E* pointers. See bug 960591.");
+    new (static_cast<void*>(aE)) E(mozilla::Forward<A>(aArg));
+  }
+
+  static inline void Destruct(E* aE) { aE->~E(); }
+};
+
+
+template<class A, class B>
+class nsDefaultComparator
+{
+public:
+  bool Equals(const A& aA, const B& aB) const { return aA == aB; }
+  bool LessThan(const A& aA, const B& aB) const { return aA < aB; }
+};
+
+template<bool IsPod, bool IsSameType>
+struct AssignRangeAlgorithm
+{
+  template<class Item, class ElemType, class IndexType, class SizeType>
+  static void implementation(ElemType* aElements, IndexType aStart,
+                             SizeType aCount, const Item* aValues)
+  {
+    ElemType* iter = aElements + aStart;
+    ElemType* end = iter + aCount;
+    for (; iter != end; ++iter, ++aValues) {
+      nsTArrayElementTraits<ElemType>::Construct(iter, *aValues);
+    }
+  }
+};
+
+template<>
+struct AssignRangeAlgorithm<true, true>
+{
+  template<class Item, class ElemType, class IndexType, class SizeType>
+  static void implementation(ElemType* aElements, IndexType aStart,
+                             SizeType aCount, const Item* aValues)
+  {
+    memcpy(aElements + aStart, aValues, aCount * sizeof(ElemType));
+  }
+};
+# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+struct nsTArray_CopyWithMemutils
+{
+  const static bool allowRealloc = true;
+
+  static void MoveNonOverlappingRegionWithHeader(void* aDest, const void* aSrc,
+                                                 size_t aCount, size_t aElemSize)
+  {
+    memcpy(aDest, aSrc, sizeof(nsTArrayHeader) + aCount * aElemSize);
+  }
+
+  static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+                                    size_t aElemSize)
+  {
+    memmove(aDest, aSrc, aCount * aElemSize);
+  }
+
+  static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+                                       size_t aElemSize)
+  {
+    memcpy(aDest, aSrc, aCount * aElemSize);
+  }
+};
+
+
+
+
+
+template<class ElemType>
+struct nsTArray_CopyWithConstructors
+{
+  typedef nsTArrayElementTraits<ElemType> traits;
+
+  const static bool allowRealloc = false;
+
+  static void MoveNonOverlappingRegionWithHeader(void* aDest, void* aSrc, size_t aCount,
+                                                 size_t aElemSize)
+  {
+    nsTArrayHeader* destHeader = static_cast<nsTArrayHeader*>(aDest);
+    nsTArrayHeader* srcHeader = static_cast<nsTArrayHeader*>(aSrc);
+    *destHeader = *srcHeader;
+    MoveNonOverlappingRegion(static_cast<uint8_t*>(aDest) + sizeof(nsTArrayHeader),
+                             static_cast<uint8_t*>(aSrc) + sizeof(nsTArrayHeader),
+                             aCount, aElemSize);
+  }
+# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+                                    size_t aElemSize)
+  {
+    ElemType* destElem = static_cast<ElemType*>(aDest);
+    ElemType* srcElem = static_cast<ElemType*>(aSrc);
+    ElemType* destElemEnd = destElem + aCount;
+    ElemType* srcElemEnd = srcElem + aCount;
+    if (destElem == srcElem) {
+      return;
+    }
+
+
+    if (srcElemEnd > destElem && srcElemEnd < destElemEnd) {
+      while (destElemEnd != destElem) {
+        --destElemEnd;
+        --srcElemEnd;
+        traits::Construct(destElemEnd, mozilla::Move(*srcElemEnd));
+        traits::Destruct(srcElemEnd);
+      }
+    } else {
+      MoveNonOverlappingRegion(aDest, aSrc, aCount, aElemSize);
+    }
+  }
+
+  static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+                                       size_t aElemSize)
+  {
+    ElemType* destElem = static_cast<ElemType*>(aDest);
+    ElemType* srcElem = static_cast<ElemType*>(aSrc);
+    ElemType* destElemEnd = destElem + aCount;
+
+
+
+
+    while (destElem != destElemEnd) {
+      traits::Construct(destElem, mozilla::Move(*srcElem));
+      traits::Destruct(srcElem);
+      ++destElem;
+      ++srcElem;
+    }
+  }
+};
+
+
+
+
+template<class E>
+struct nsTArray_CopyChooser
+{
+  typedef nsTArray_CopyWithMemutils Type;
+};
+# 725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+template<class E>
+struct nsTArray_CopyChooser<JS::Heap<E>>
+{
+  typedef nsTArray_CopyWithConstructors<JS::Heap<E>> Type;
+};
+
+template<> struct nsTArray_CopyChooser<nsRegion> { typedef nsTArray_CopyWithConstructors<nsRegion> Type; };
+template<> struct nsTArray_CopyChooser<nsIntRegion> { typedef nsTArray_CopyWithConstructors<nsIntRegion> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::layers::TileClient> { typedef nsTArray_CopyWithConstructors<mozilla::layers::TileClient> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::SerializedStructuredCloneBuffer> { typedef nsTArray_CopyWithConstructors<mozilla::SerializedStructuredCloneBuffer> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::dom::ipc::StructuredCloneData> { typedef nsTArray_CopyWithConstructors<mozilla::dom::ipc::StructuredCloneData> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::dom::ClonedMessageData> { typedef nsTArray_CopyWithConstructors<mozilla::dom::ClonedMessageData> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::StructuredCloneReadInfo> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::StructuredCloneReadInfo> Type; };;
+template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::ObjectStoreCursorResponse> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::ObjectStoreCursorResponse> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo> Type; };;
+template<> struct nsTArray_CopyChooser<JSStructuredCloneData> { typedef nsTArray_CopyWithConstructors<JSStructuredCloneData> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::dom::MessagePortMessage> { typedef nsTArray_CopyWithConstructors<mozilla::dom::MessagePortMessage> Type; };
+template<> struct nsTArray_CopyChooser<mozilla::SourceBufferTask> { typedef nsTArray_CopyWithConstructors<mozilla::SourceBufferTask> Type; };
+
+template<typename T>
+struct nsTArray_CopyChooser<std::function<T>>
+{
+  typedef nsTArray_CopyWithConstructors<std::function<T>> Type;
+};
+
+
+
+
+
+
+
+template<class E, class Derived>
+struct nsTArray_TypedBase : public nsTArray_SafeElementAtHelper<E, Derived>
+{
+};
+# 772 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+template<class E, class Derived>
+struct nsTArray_TypedBase<JS::Heap<E>, Derived>
+  : public nsTArray_SafeElementAtHelper<JS::Heap<E>, Derived>
+{
+  operator const nsTArray<E>&()
+  {
+    static_assert(sizeof(E) == sizeof(JS::Heap<E>),
+                  "JS::Heap<E> must be binary compatible with E.");
+    Derived* self = static_cast<Derived*>(this);
+    return *reinterpret_cast<nsTArray<E> *>(self);
+  }
+
+  operator const FallibleTArray<E>&()
+  {
+    Derived* self = static_cast<Derived*>(this);
+    return *reinterpret_cast<FallibleTArray<E> *>(self);
+  }
+};
+
+namespace detail {
+
+template<class Item, class Comparator>
+struct ItemComparatorEq
+{
+  const Item& mItem;
+  const Comparator& mComp;
+  ItemComparatorEq(const Item& aItem, const Comparator& aComp)
+    : mItem(aItem)
+    , mComp(aComp)
+  {}
+  template<class T>
+  int operator()(const T& aElement) const {
+    if (mComp.Equals(aElement, mItem)) {
+      return 0;
+    }
+
+    return mComp.LessThan(aElement, mItem) ? 1 : -1;
+  }
+};
+
+template<class Item, class Comparator>
+struct ItemComparatorFirstElementGT
+{
+  const Item& mItem;
+  const Comparator& mComp;
+  ItemComparatorFirstElementGT(const Item& aItem, const Comparator& aComp)
+    : mItem(aItem)
+    , mComp(aComp)
+  {}
+  template<class T>
+  int operator()(const T& aElement) const {
+    if (mComp.LessThan(aElement, mItem) ||
+        mComp.Equals(aElement, mItem)) {
+      return 1;
+    } else {
+      return -1;
+    }
+  }
+};
+
+}
+# 846 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+template<class E, class Alloc>
+class nsTArray_Impl
+  : public nsTArray_base<Alloc, typename nsTArray_CopyChooser<E>::Type>
+  , public nsTArray_TypedBase<E, nsTArray_Impl<E, Alloc>>
+{
+private:
+  typedef nsTArrayFallibleAllocator FallibleAlloc;
+  typedef nsTArrayInfallibleAllocator InfallibleAlloc;
+
+public:
+  typedef typename nsTArray_CopyChooser<E>::Type copy_type;
+  typedef nsTArray_base<Alloc, copy_type> base_type;
+  typedef typename base_type::size_type size_type;
+  typedef typename base_type::index_type index_type;
+  typedef E elem_type;
+  typedef nsTArray_Impl<E, Alloc> self_type;
+  typedef nsTArrayElementTraits<E> elem_traits;
+  typedef nsTArray_SafeElementAtHelper<E, self_type> safeelementat_helper_type;
+  typedef mozilla::ArrayIterator<elem_type&, nsTArray<E>> iterator;
+  typedef mozilla::ArrayIterator<const elem_type&, nsTArray<E>> const_iterator;
+  typedef mozilla::ReverseIterator<iterator> reverse_iterator;
+  typedef mozilla::ReverseIterator<const_iterator> const_reverse_iterator;
+
+  using safeelementat_helper_type::SafeElementAt;
+  using base_type::EmptyHdr;
+
+
+
+  static const index_type NoIndex = index_type(-1);
+
+  using base_type::Length;
+
+
+
+
+
+  ~nsTArray_Impl() { Clear(); }
+
+
+
+
+
+  nsTArray_Impl() {}
+
+
+  explicit nsTArray_Impl(size_type aCapacity) { SetCapacity(aCapacity); }
+
+
+
+  template<typename Allocator>
+  explicit nsTArray_Impl(nsTArray_Impl<E, Allocator>&& aOther)
+  {
+    SwapElements(aOther);
+  }
+# 916 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  explicit nsTArray_Impl(const self_type& aOther) { AppendElements(aOther); }
+
+  explicit nsTArray_Impl(std::initializer_list<E> aIL) { AppendElements(aIL.begin(), aIL.size()); }
+
+
+  template<typename Allocator>
+  operator const nsTArray_Impl<E, Allocator>&() const
+  {
+    return *reinterpret_cast<const nsTArray_Impl<E, Allocator>*>(this);
+  }
+
+  operator const nsTArray<E>&() const
+  {
+    return *reinterpret_cast<const InfallibleTArray<E>*>(this);
+  }
+  operator const FallibleTArray<E>&() const
+  {
+    return *reinterpret_cast<const FallibleTArray<E>*>(this);
+  }
+
+
+
+
+  self_type& operator=(const self_type& aOther)
+  {
+    if (this != &aOther) {
+      ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length());
+    }
+    return *this;
+  }
+
+
+
+
+  self_type& operator=(self_type&& aOther)
+  {
+    if (this != &aOther) {
+      Clear();
+      SwapElements(aOther);
+    }
+    return *this;
+  }
+
+
+
+  template<typename Allocator>
+  bool operator==(const nsTArray_Impl<E, Allocator>& aOther) const
+  {
+    size_type len = Length();
+    if (len != aOther.Length()) {
+      return false;
+    }
+
+
+    for (index_type i = 0; i < len; ++i) {
+      if (!(operator[](i) == aOther[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+
+
+  bool operator!=(const self_type& aOther) const { return !operator==(aOther); }
+
+  template<typename Allocator>
+  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
+  {
+    ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length());
+    return *this;
+  }
+
+  template<typename Allocator>
+  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
+  {
+    Clear();
+    SwapElements(aOther);
+    return *this;
+  }
+
+
+
+
+
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    if (this->UsesAutoArrayBuffer() || Hdr() == EmptyHdr()) {
+      return 0;
+    }
+    return aMallocSizeOf(this->Hdr());
+  }
+
+
+
+
+
+  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+# 1026 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  elem_type* Elements() { return reinterpret_cast<elem_type*>(Hdr() + 1); }
+
+
+
+
+  const elem_type* Elements() const
+  {
+    return reinterpret_cast<const elem_type*>(Hdr() + 1);
+  }
+
+
+
+
+
+  elem_type& ElementAt(index_type aIndex)
+  {
+    if ((__builtin_expect(!!(aIndex >= Length()), 0))) {
+      InvalidArrayIndex_CRASH(aIndex, Length());
+    }
+    return Elements()[aIndex];
+  }
+
+
+
+
+
+  const elem_type& ElementAt(index_type aIndex) const
+  {
+    if ((__builtin_expect(!!(aIndex >= Length()), 0))) {
+      InvalidArrayIndex_CRASH(aIndex, Length());
+    }
+    return Elements()[aIndex];
+  }
+
+
+
+
+
+
+  elem_type& SafeElementAt(index_type aIndex, elem_type& aDef)
+  {
+    return aIndex < Length() ? Elements()[aIndex] : aDef;
+  }
+
+
+
+
+
+
+  const elem_type& SafeElementAt(index_type aIndex, const elem_type& aDef) const
+  {
+    return aIndex < Length() ? Elements()[aIndex] : aDef;
+  }
+
+
+  elem_type& operator[](index_type aIndex) { return ElementAt(aIndex); }
+
+
+  const elem_type& operator[](index_type aIndex) const { return ElementAt(aIndex); }
+
+
+  elem_type& LastElement() { return ElementAt(Length() - 1); }
+
+
+  const elem_type& LastElement() const { return ElementAt(Length() - 1); }
+
+
+  elem_type& SafeLastElement(elem_type& aDef)
+  {
+    return SafeElementAt(Length() - 1, aDef);
+  }
+
+
+  const elem_type& SafeLastElement(const elem_type& aDef) const
+  {
+    return SafeElementAt(Length() - 1, aDef);
+  }
+
+
+  iterator begin() { return iterator(*this, 0); }
+  const_iterator begin() const { return const_iterator(*this, 0); }
+  const_iterator cbegin() const { return begin(); }
+  iterator end() { return iterator(*this, Length()); }
+  const_iterator end() const { return const_iterator(*this, Length()); }
+  const_iterator cend() const { return end(); }
+
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  const_reverse_iterator crend() const { return rend(); }
+
+
+
+  operator mozilla::Span<elem_type>()
+  {
+    return mozilla::Span<elem_type>(Elements(), Length());
+  }
+
+  operator mozilla::Span<const elem_type>() const
+  {
+    return mozilla::Span<const elem_type>(Elements(), Length());
+  }
+# 1141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Item, class Comparator>
+  bool Contains(const Item& aItem, const Comparator& aComp) const
+  {
+    return IndexOf(aItem, 0, aComp) != NoIndex;
+  }
+
+
+
+
+
+
+  template<class Item>
+  bool Contains(const Item& aItem) const
+  {
+    return IndexOf(aItem) != NoIndex;
+  }
+
+
+
+
+
+
+
+  template<class Item, class Comparator>
+  index_type IndexOf(const Item& aItem, index_type aStart,
+                     const Comparator& aComp) const
+  {
+    const elem_type* iter = Elements() + aStart;
+    const elem_type* iend = Elements() + Length();
+    for (; iter != iend; ++iter) {
+      if (aComp.Equals(*iter, aItem)) {
+        return index_type(iter - Elements());
+      }
+    }
+    return NoIndex;
+  }
+
+
+
+
+
+
+
+  template<class Item>
+  index_type IndexOf(const Item& aItem, index_type aStart = 0) const
+  {
+    return IndexOf(aItem, aStart, nsDefaultComparator<elem_type, Item>());
+  }
+# 1197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Item, class Comparator>
+  index_type LastIndexOf(const Item& aItem, index_type aStart,
+                         const Comparator& aComp) const
+  {
+    size_type endOffset = aStart >= Length() ? Length() : aStart + 1;
+    const elem_type* iend = Elements() - 1;
+    const elem_type* iter = iend + endOffset;
+    for (; iter != iend; --iter) {
+      if (aComp.Equals(*iter, aItem)) {
+        return index_type(iter - Elements());
+      }
+    }
+    return NoIndex;
+  }
+# 1219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Item>
+  index_type LastIndexOf(const Item& aItem,
+                         index_type aStart = NoIndex) const
+  {
+    return LastIndexOf(aItem, aStart, nsDefaultComparator<elem_type, Item>());
+  }
+# 1233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Item, class Comparator>
+  index_type BinaryIndexOf(const Item& aItem, const Comparator& aComp) const
+  {
+    using mozilla::BinarySearchIf;
+    typedef ::detail::ItemComparatorEq<Item, Comparator> Cmp;
+
+    size_t index;
+    bool found = BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index);
+    return found ? index : NoIndex;
+  }
+
+
+
+
+
+
+  template<class Item>
+  index_type BinaryIndexOf(const Item& aItem) const
+  {
+    return BinaryIndexOf(aItem, nsDefaultComparator<elem_type, Item>());
+  }
+
+
+
+
+
+  template<class Allocator, typename ActualAlloc = Alloc>
+  typename ActualAlloc::ResultType Assign(
+      const nsTArray_Impl<E, Allocator>& aOther)
+  {
+    return ActualAlloc::ConvertBoolToResultType(
+      !!ReplaceElementsAt<E, ActualAlloc>(0, Length(),
+                                          aOther.Elements(), aOther.Length()));
+  }
+
+  template<class Allocator>
+  __attribute__ ((warn_unused_result))
+  bool Assign(const nsTArray_Impl<E, Allocator>& aOther,
+              const mozilla::fallible_t&)
+  {
+    return Assign<Allocator, FallibleAlloc>(aOther);
+  }
+
+  template<class Allocator>
+  void Assign(nsTArray_Impl<E, Allocator>&& aOther)
+  {
+    Clear();
+    SwapElements(aOther);
+  }
+
+
+
+
+
+
+  void ClearAndRetainStorage()
+  {
+    if (base_type::mHdr == EmptyHdr()) {
+      return;
+    }
+
+    DestructRange(0, Length());
+    base_type::mHdr->mLength = 0;
+  }
+# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  void SetLengthAndRetainStorage(size_type aNewLen)
+  {
+    do { } while (0);
+    size_type oldLen = Length();
+    if (aNewLen > oldLen) {
+      InsertElementsAt(oldLen, aNewLen - oldLen);
+      return;
+    }
+    if (aNewLen < oldLen) {
+      DestructRange(aNewLen, oldLen - aNewLen);
+      base_type::mHdr->mLength = aNewLen;
+    }
+  }
+# 1330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const Item* aArray, size_type aArrayLen);
+
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const Item* aArray, size_type aArrayLen,
+                               const mozilla::fallible_t&)
+  {
+    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount,
+                                                  aArray, aArrayLen);
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const nsTArray<Item>& aArray)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(
+      aStart, aCount, aArray.Elements(), aArray.Length());
+  }
+
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* ReplaceElementsAt(index_type aStart,
+                               size_type aCount,
+                               mozilla::Span<const Item> aSpan)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(
+      aStart, aCount, aSpan.Elements(), aSpan.Length());
+  }
+
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const nsTArray<Item>& aArray,
+                               const mozilla::fallible_t&)
+  {
+    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aArray);
+  }
+
+  template<class Item>
+  __attribute__ ((warn_unused_result)) elem_type* ReplaceElementsAt(index_type aStart,
+                                            size_type aCount,
+                                            mozilla::Span<const Item> aSpan,
+                                            const mozilla::fallible_t&)
+  {
+    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aSpan);
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const Item& aItem)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(aStart, aCount, &aItem, 1);
+  }
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
+                               const Item& aItem, const mozilla::fallible_t&)
+  {
+    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aItem);
+  }
+
+
+  template<class Item>
+  elem_type* ReplaceElementAt(index_type aIndex, const Item& aItem)
+  {
+    return ReplaceElementsAt(aIndex, 1, &aItem, 1);
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* InsertElementsAt(index_type aIndex, const Item* aArray,
+                              size_type aArrayLen)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(aIndex, 0, aArray, aArrayLen);
+  }
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementsAt(index_type aIndex, const Item* aArray,
+                              size_type aArrayLen, const mozilla::fallible_t&)
+  {
+    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aArray, aArrayLen);
+  }
+
+
+protected:
+  template<class Item, class Allocator, typename ActualAlloc = Alloc>
+  elem_type* InsertElementsAt(index_type aIndex,
+                              const nsTArray_Impl<Item, Allocator>& aArray)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(
+      aIndex, 0, aArray.Elements(), aArray.Length());
+  }
+
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* InsertElementsAt(index_type aIndex,
+                              mozilla::Span<const Item> aSpan)
+  {
+    return ReplaceElementsAt<Item, ActualAlloc>(
+      aIndex, 0, aSpan.Elements(), aSpan.Length());
+  }
+
+public:
+
+  template<class Item, class Allocator>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementsAt(index_type aIndex,
+                              const nsTArray_Impl<Item, Allocator>& aArray,
+                              const mozilla::fallible_t&)
+  {
+    return InsertElementsAt<Item, Allocator, FallibleAlloc>(aIndex, aArray);
+  }
+
+  template<class Item>
+  __attribute__ ((warn_unused_result)) elem_type* InsertElementsAt(index_type aIndex,
+                                           mozilla::Span<const Item> aSpan,
+                                           const mozilla::fallible_t&)
+  {
+    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aSpan);
+  }
+
+
+
+
+protected:
+  template<typename ActualAlloc = Alloc>
+  elem_type* InsertElementAt(index_type aIndex);
+
+public:
+
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementAt(index_type aIndex, const mozilla::fallible_t&)
+  {
+    return InsertElementAt<FallibleAlloc>(aIndex);
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* InsertElementAt(index_type aIndex, Item&& aItem);
+
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementAt(index_type aIndex, Item&& aItem,
+                             const mozilla::fallible_t&)
+  {
+    return InsertElementAt<Item, FallibleAlloc>(aIndex,
+                                                mozilla::Forward<Item>(aItem));
+  }
+# 1507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  elem_type* ReconstructElementAt(index_type aIndex)
+  {
+    elem_type* elem = &ElementAt(aIndex);
+    elem_traits::Destruct(elem);
+    elem_traits::Construct(elem);
+    return elem;
+  }
+# 1530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Item, class Comparator>
+  index_type IndexOfFirstElementGt(const Item& aItem,
+                                   const Comparator& aComp) const
+  {
+    using mozilla::BinarySearchIf;
+    typedef ::detail::ItemComparatorFirstElementGT<Item, Comparator> Cmp;
+
+    size_t index;
+    BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index);
+    return index;
+  }
+
+
+  template<class Item>
+  index_type
+  IndexOfFirstElementGt(const Item& aItem) const
+  {
+    return IndexOfFirstElementGt(aItem, nsDefaultComparator<elem_type, Item>());
+  }
+
+
+
+
+protected:
+  template<class Item, class Comparator, typename ActualAlloc = Alloc>
+  elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp)
+  {
+    index_type index = IndexOfFirstElementGt<Item, Comparator>(aItem, aComp);
+    return InsertElementAt<Item, ActualAlloc>(
+      index, mozilla::Forward<Item>(aItem));
+  }
+public:
+
+  template<class Item, class Comparator>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp,
+                                 const mozilla::fallible_t&)
+  {
+    return InsertElementSorted<Item, Comparator, FallibleAlloc>(
+      mozilla::Forward<Item>(aItem), aComp);
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* InsertElementSorted(Item&& aItem)
+  {
+    nsDefaultComparator<elem_type, Item> comp;
+    return InsertElementSorted<Item, decltype(comp), ActualAlloc>(
+      mozilla::Forward<Item>(aItem), comp);
+  }
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementSorted(Item&& aItem, const mozilla::fallible_t&)
+  {
+    return InsertElementSorted<Item, FallibleAlloc>(
+      mozilla::Forward<Item>(aItem));
+  }
+
+
+
+
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* AppendElements(const Item* aArray, size_type aArrayLen);
+
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* AppendElements(mozilla::Span<const Item> aSpan)
+  {
+    return AppendElements<Item, FallibleAlloc>(aSpan.Elements(),
+                                               aSpan.Length());
+  }
+
+  template<class Item, size_t Length, typename ActualAlloc = Alloc>
+  elem_type* AppendElements(const mozilla::Array<Item, Length>& aArray)
+  {
+    return AppendElements<Item, ActualAlloc>(&aArray[0], Length);
+  }
+
+public:
+
+  template<class Item>
+
+  elem_type* AppendElements(const Item* aArray, size_type aArrayLen,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, FallibleAlloc>(aArray, aArrayLen);
+  }
+
+  template<class Item>
+
+  elem_type* AppendElements(mozilla::Span<const Item> aSpan,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, FallibleAlloc>(aSpan.Elements(),
+                                               aSpan.Length());
+  }
+
+
+protected:
+  template<class Item, class Allocator, typename ActualAlloc = Alloc>
+  elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray)
+  {
+    return AppendElements<Item, ActualAlloc>(aArray.Elements(), aArray.Length());
+  }
+public:
+
+  template<class Item, class Allocator>
+
+  elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, Allocator, FallibleAlloc>(aArray);
+  }
+
+
+
+protected:
+  template<class Item, class Allocator, typename ActualAlloc = Alloc>
+  elem_type* AppendElements(nsTArray_Impl<Item, Allocator>&& aArray);
+
+public:
+
+  template<class Item, class Allocator, typename ActualAlloc = Alloc>
+
+  elem_type* AppendElements(nsTArray_Impl<Item, Allocator>&& aArray,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, Allocator>(mozilla::Move(aArray));
+  }
+
+
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* AppendElement(Item&& aItem);
+
+public:
+
+  template<class Item>
+
+  elem_type* AppendElement(Item&& aItem,
+                           const mozilla::fallible_t&)
+  {
+    return AppendElement<Item, FallibleAlloc>(mozilla::Forward<Item>(aItem));
+  }
+
+
+
+
+protected:
+  template<typename ActualAlloc = Alloc>
+  elem_type* AppendElements(size_type aCount) {
+    if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+          Length() + aCount, sizeof(elem_type)))) {
+      return nullptr;
+    }
+    elem_type* elems = Elements() + Length();
+    size_type i;
+    for (i = 0; i < aCount; ++i) {
+      elem_traits::Construct(elems + i);
+    }
+    this->IncrementLength(aCount);
+    return elems;
+  }
+public:
+
+
+  elem_type* AppendElements(size_type aCount,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<FallibleAlloc>(aCount);
+  }
+
+
+
+
+protected:
+  template<typename ActualAlloc = Alloc>
+  elem_type* AppendElement()
+  {
+    return AppendElements<ActualAlloc>(1);
+  }
+public:
+
+
+  elem_type* AppendElement(const mozilla::fallible_t&)
+  {
+    return AppendElement<FallibleAlloc>();
+  }
+
+
+
+
+  void RemoveElementsAt(index_type aStart, size_type aCount);
+
+
+  void RemoveElementAt(index_type aIndex) { RemoveElementsAt(aIndex, 1); }
+
+
+  void Clear() { RemoveElementsAt(0, Length()); }
+
+
+
+
+
+
+  template<typename Predicate>
+  void RemoveElementsBy(Predicate aPredicate);
+
+
+
+
+
+
+  template<class Item, class Comparator>
+  bool RemoveElement(const Item& aItem, const Comparator& aComp)
+  {
+    index_type i = IndexOf(aItem, 0, aComp);
+    if (i == NoIndex) {
+      return false;
+    }
+
+    RemoveElementAt(i);
+    return true;
+  }
+
+
+
+  template<class Item>
+  bool RemoveElement(const Item& aItem)
+  {
+    return RemoveElement(aItem, nsDefaultComparator<elem_type, Item>());
+  }
+
+
+
+
+
+
+
+  template<class Item, class Comparator>
+  bool RemoveElementSorted(const Item& aItem, const Comparator& aComp)
+  {
+    index_type index = IndexOfFirstElementGt(aItem, aComp);
+    if (index > 0 && aComp.Equals(ElementAt(index - 1), aItem)) {
+      RemoveElementAt(index - 1);
+      return true;
+    }
+    return false;
+  }
+
+
+  template<class Item>
+  bool RemoveElementSorted(const Item& aItem)
+  {
+    return RemoveElementSorted(aItem, nsDefaultComparator<elem_type, Item>());
+  }
+
+
+
+  template<class Allocator>
+  typename Alloc::ResultType SwapElements(nsTArray_Impl<E, Allocator>& aOther)
+  {
+    return Alloc::Result(this->template SwapArrayElements<Alloc>(
+      aOther, sizeof(elem_type), mozilla::AlignmentFinder<elem_type>::alignment));
+  }
+# 1811 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+protected:
+  template<typename ActualAlloc = Alloc>
+  typename ActualAlloc::ResultType SetCapacity(size_type aCapacity)
+  {
+    return ActualAlloc::Result(this->template EnsureCapacity<ActualAlloc>(
+      aCapacity, sizeof(elem_type)));
+  }
+public:
+
+  __attribute__ ((warn_unused_result))
+  bool SetCapacity(size_type aCapacity, const mozilla::fallible_t&)
+  {
+    return SetCapacity<FallibleAlloc>(aCapacity);
+  }
+# 1834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+protected:
+  template<typename ActualAlloc = Alloc>
+  typename ActualAlloc::ResultType SetLength(size_type aNewLen)
+  {
+    size_type oldLen = Length();
+    if (aNewLen > oldLen) {
+      return ActualAlloc::ConvertBoolToResultType(
+        InsertElementsAt<ActualAlloc>(oldLen, aNewLen - oldLen) != nullptr);
+    }
+
+    TruncateLength(aNewLen);
+    return ActualAlloc::ConvertBoolToResultType(true);
+  }
+public:
+
+  __attribute__ ((warn_unused_result))
+  bool SetLength(size_type aNewLen, const mozilla::fallible_t&)
+  {
+    return SetLength<FallibleAlloc>(aNewLen);
+  }
+
+
+
+
+
+
+
+  void TruncateLength(size_type aNewLen)
+  {
+    size_type oldLen = Length();
+    do { } while (0);
+
+    RemoveElementsAt(aNewLen, oldLen - aNewLen);
+  }
+
+
+
+
+
+
+
+protected:
+  template<typename ActualAlloc = Alloc>
+  typename ActualAlloc::ResultType EnsureLengthAtLeast(size_type aMinLen)
+  {
+    size_type oldLen = Length();
+    if (aMinLen > oldLen) {
+      return ActualAlloc::ConvertBoolToResultType(
+        !!InsertElementsAt<ActualAlloc>(oldLen, aMinLen - oldLen));
+    }
+    return ActualAlloc::ConvertBoolToResultType(true);
+  }
+public:
+
+  __attribute__ ((warn_unused_result))
+  bool EnsureLengthAtLeast(size_type aMinLen, const mozilla::fallible_t&)
+  {
+    return EnsureLengthAtLeast<FallibleAlloc>(aMinLen);
+  }
+
+
+
+
+
+
+protected:
+  template<typename ActualAlloc = Alloc>
+  elem_type* InsertElementsAt(index_type aIndex, size_type aCount)
+  {
+    if (!base_type::template InsertSlotsAt<ActualAlloc>(aIndex, aCount,
+                                                        sizeof(elem_type),
+                                                        mozilla::AlignmentFinder<elem_type>::alignment)) {
+      return nullptr;
+    }
+
+
+    elem_type* iter = Elements() + aIndex;
+    elem_type* iend = iter + aCount;
+    for (; iter != iend; ++iter) {
+      elem_traits::Construct(iter);
+    }
+
+    return Elements() + aIndex;
+  }
+public:
+
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
+                              const mozilla::fallible_t&)
+  {
+    return InsertElementsAt<FallibleAlloc>(aIndex, aCount);
+  }
+# 1934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+protected:
+  template<class Item, typename ActualAlloc = Alloc>
+  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
+                              const Item& aItem);
+
+public:
+
+  template<class Item>
+  __attribute__ ((warn_unused_result))
+  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
+                              const Item& aItem, const mozilla::fallible_t&)
+  {
+    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aCount, aItem);
+  }
+
+
+  void Compact()
+  {
+    ShrinkCapacity(sizeof(elem_type), mozilla::AlignmentFinder<elem_type>::alignment);
+  }
+# 1962 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+  template<class Comparator>
+  static int Compare(const void* aE1, const void* aE2, void* aData)
+  {
+    const Comparator* c = reinterpret_cast<const Comparator*>(aData);
+    const elem_type* a = static_cast<const elem_type*>(aE1);
+    const elem_type* b = static_cast<const elem_type*>(aE2);
+    return c->LessThan(*a, *b) ? -1 : (c->Equals(*a, *b) ? 0 : 1);
+  }
+
+
+
+
+  template<class Comparator>
+  void Sort(const Comparator& aComp)
+  {
+    NS_QuickSort(Elements(), Length(), sizeof(elem_type),
+                 Compare<Comparator>, const_cast<Comparator*>(&aComp));
+  }
+
+
+
+  void Sort() { Sort(nsDefaultComparator<elem_type, elem_type>()); }
+
+
+  void Reverse()
+  {
+    elem_type* elements = Elements();
+    const size_type len = Length();
+    for (index_type i = 0, iend = len / 2; i < iend; ++i) {
+      mozilla::Swap(elements[i], elements[len - i - 1]);
+    }
+  }
+
+protected:
+  using base_type::Hdr;
+  using base_type::ShrinkCapacity;
+
+
+
+
+  void DestructRange(index_type aStart, size_type aCount)
+  {
+    elem_type* iter = Elements() + aStart;
+    elem_type *iend = iter + aCount;
+    for (; iter != iend; ++iter) {
+      elem_traits::Destruct(iter);
+    }
+  }
+
+
+
+
+
+  template<class Item>
+  void AssignRange(index_type aStart, size_type aCount, const Item* aValues)
+  {
+    AssignRangeAlgorithm<mozilla::IsPod<Item>::value,
+                         mozilla::IsSame<Item, elem_type>::value>
+                         ::implementation(Elements(), aStart, aCount, aValues);
+  }
+};
+
+template<typename E, class Alloc>
+template<class Item, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::ReplaceElementsAt(index_type aStart, size_type aCount,
+                                           const Item* aArray, size_type aArrayLen) -> elem_type*
+{
+  if ((__builtin_expect(!!(aStart > Length()), 0))) {
+    InvalidArrayIndex_CRASH(aStart, Length());
+  }
+
+
+  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+        Length() + aArrayLen - aCount, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  DestructRange(aStart, aCount);
+  this->template ShiftData<ActualAlloc>(aStart, aCount, aArrayLen,
+                                        sizeof(elem_type),
+                                        mozilla::AlignmentFinder<elem_type>::alignment);
+  AssignRange(aStart, aArrayLen, aArray);
+  return Elements() + aStart;
+}
+
+template<typename E, class Alloc>
+void
+nsTArray_Impl<E, Alloc>::RemoveElementsAt(index_type aStart, size_type aCount)
+{
+  do { } while (0);
+  do { } while (0);
+
+  do { } while (0);
+  DestructRange(aStart, aCount);
+  this->template ShiftData<InfallibleAlloc>(aStart, aCount, 0,
+                                            sizeof(elem_type),
+                                            mozilla::AlignmentFinder<elem_type>::alignment);
+}
+
+template<typename E, class Alloc>
+template<typename Predicate>
+void
+nsTArray_Impl<E, Alloc>::RemoveElementsBy(Predicate aPredicate)
+{
+  if (base_type::mHdr == EmptyHdr()) {
+    return;
+  }
+
+  index_type j = 0;
+  index_type len = Length();
+  for (index_type i = 0; i < len; ++i) {
+    if (aPredicate(Elements()[i])) {
+      elem_traits::Destruct(Elements() + i);
+    } else {
+      if (j < i) {
+        copy_type::MoveNonOverlappingRegion(Elements() + j, Elements() + i,
+                                            1, sizeof(elem_type));
+      }
+      ++j;
+    }
+  }
+  base_type::mHdr->mLength = j;
+}
+
+template<typename E, class Alloc>
+template<class Item, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::InsertElementsAt(index_type aIndex, size_type aCount,
+                                          const Item& aItem) -> elem_type*
+{
+  if (!base_type::template InsertSlotsAt<ActualAlloc>(aIndex, aCount,
+                                                      sizeof(elem_type),
+                                                      mozilla::AlignmentFinder<elem_type>::alignment)) {
+    return nullptr;
+  }
+
+
+  elem_type* iter = Elements() + aIndex;
+  elem_type* iend = iter + aCount;
+  for (; iter != iend; ++iter) {
+    elem_traits::Construct(iter, aItem);
+  }
+
+  return Elements() + aIndex;
+}
+
+template<typename E, class Alloc>
+template<typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::InsertElementAt(index_type aIndex) -> elem_type*
+{
+  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
+    InvalidArrayIndex_CRASH(aIndex, Length());
+  }
+
+  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+        Length() + 1, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(elem_type),
+                                        mozilla::AlignmentFinder<elem_type>::alignment);
+  elem_type* elem = Elements() + aIndex;
+  elem_traits::Construct(elem);
+  return elem;
+}
+
+template<typename E, class Alloc>
+template<class Item, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::InsertElementAt(index_type aIndex, Item&& aItem) -> elem_type*
+{
+  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
+    InvalidArrayIndex_CRASH(aIndex, Length());
+  }
+
+  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+         Length() + 1, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(elem_type),
+                                        mozilla::AlignmentFinder<elem_type>::alignment);
+  elem_type* elem = Elements() + aIndex;
+  elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
+  return elem;
+}
+
+template<typename E, class Alloc>
+template<class Item, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::AppendElements(const Item* aArray, size_type aArrayLen) -> elem_type*
+{
+  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+        Length() + aArrayLen, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  index_type len = Length();
+  AssignRange(len, aArrayLen, aArray);
+  this->IncrementLength(aArrayLen);
+  return Elements() + len;
+}
+
+template<typename E, class Alloc>
+template<class Item, class Allocator, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::AppendElements(nsTArray_Impl<Item, Allocator>&& aArray) -> elem_type*
+{
+  do { } while (0);
+  if (Length() == 0) {
+    SwapElements<ActualAlloc>(aArray);
+    return Elements();
+  }
+
+  index_type len = Length();
+  index_type otherLen = aArray.Length();
+  if (!Alloc::Successful(this->template EnsureCapacity<Alloc>(
+        len + otherLen, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  copy_type::MoveNonOverlappingRegion(Elements() + len, aArray.Elements(), otherLen,
+                                      sizeof(elem_type));
+  this->IncrementLength(otherLen);
+  aArray.template ShiftData<Alloc>(0, otherLen, 0, sizeof(elem_type),
+                                   mozilla::AlignmentFinder<elem_type>::alignment);
+  return Elements() + len;
+}
+
+template<typename E, class Alloc>
+template<class Item, typename ActualAlloc>
+auto
+nsTArray_Impl<E, Alloc>::AppendElement(Item&& aItem) -> elem_type*
+{
+  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+         Length() + 1, sizeof(elem_type)))) {
+    return nullptr;
+  }
+  elem_type* elem = Elements() + Length();
+  elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
+  this->IncrementLength(1);
+  return elem;
+}
+
+template<typename E, typename Alloc>
+inline void
+ImplCycleCollectionUnlink(nsTArray_Impl<E, Alloc>& aField)
+{
+  aField.Clear();
+}
+
+template<typename E, typename Alloc>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsTArray_Impl<E, Alloc>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  aFlags |= CycleCollectionEdgeNameArrayFlag;
+  size_t length = aField.Length();
+  for (size_t i = 0; i < length; ++i) {
+    ImplCycleCollectionTraverse(aCallback, aField[i], aName, aFlags);
+  }
+}
+
+
+
+
+
+template<class E>
+class nsTArray : public nsTArray_Impl<E, nsTArrayInfallibleAllocator>
+{
+public:
+  typedef nsTArray_Impl<E, nsTArrayInfallibleAllocator> base_type;
+  typedef nsTArray<E> self_type;
+  typedef typename base_type::size_type size_type;
+
+  nsTArray() {}
+  explicit nsTArray(size_type aCapacity) : base_type(aCapacity) {}
+  explicit nsTArray(const nsTArray& aOther) : base_type(aOther) {}
+               nsTArray(nsTArray&& aOther) : base_type(mozilla::Move(aOther)) {}
+               nsTArray(std::initializer_list<E> aIL) : base_type(aIL) {}
+
+  template<class Allocator>
+  explicit nsTArray(const nsTArray_Impl<E, Allocator>& aOther)
+    : base_type(aOther)
+  {
+  }
+  template<class Allocator>
+               nsTArray(nsTArray_Impl<E, Allocator>&& aOther)
+    : base_type(mozilla::Move(aOther))
+  {
+  }
+
+  self_type& operator=(const self_type& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+  template<class Allocator>
+  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+  self_type& operator=(self_type&& aOther)
+  {
+    base_type::operator=(mozilla::Move(aOther));
+    return *this;
+  }
+  template<class Allocator>
+  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
+  {
+    base_type::operator=(mozilla::Move(aOther));
+    return *this;
+  }
+
+  using base_type::AppendElement;
+  using base_type::AppendElements;
+  using base_type::EnsureLengthAtLeast;
+  using base_type::InsertElementAt;
+  using base_type::InsertElementsAt;
+  using base_type::InsertElementSorted;
+  using base_type::ReplaceElementsAt;
+  using base_type::SetCapacity;
+  using base_type::SetLength;
+};
+
+
+
+
+template<class E>
+class FallibleTArray : public nsTArray_Impl<E, nsTArrayFallibleAllocator>
+{
+public:
+  typedef nsTArray_Impl<E, nsTArrayFallibleAllocator> base_type;
+  typedef FallibleTArray<E> self_type;
+  typedef typename base_type::size_type size_type;
+
+  FallibleTArray() {}
+  explicit FallibleTArray(size_type aCapacity) : base_type(aCapacity) {}
+  explicit FallibleTArray(const FallibleTArray<E>& aOther) : base_type(aOther) {}
+  FallibleTArray(FallibleTArray<E>&& aOther)
+    : base_type(mozilla::Move(aOther))
+  {
+  }
+
+  template<class Allocator>
+  explicit FallibleTArray(const nsTArray_Impl<E, Allocator>& aOther)
+    : base_type(aOther)
+  {
+  }
+  template<class Allocator>
+  explicit FallibleTArray(nsTArray_Impl<E, Allocator>&& aOther)
+    : base_type(mozilla::Move(aOther))
+  {
+  }
+
+  self_type& operator=(const self_type& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+  template<class Allocator>
+  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+  self_type& operator=(self_type&& aOther)
+  {
+    base_type::operator=(mozilla::Move(aOther));
+    return *this;
+  }
+  template<class Allocator>
+  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
+  {
+    base_type::operator=(mozilla::Move(aOther));
+    return *this;
+  }
+};
+
+
+
+
+
+template<class E, size_t N>
+class AutoTArray : public nsTArray<E>
+{
+  static_assert(N != 0, "AutoTArray<E, 0> should be specialized");
+public:
+  typedef AutoTArray<E, N> self_type;
+  typedef nsTArray<E> base_type;
+  typedef typename base_type::Header Header;
+  typedef typename base_type::elem_type elem_type;
+
+  AutoTArray()
+  {
+    Init();
+  }
+
+  AutoTArray(const self_type& aOther)
+  {
+    Init();
+    this->AppendElements(aOther);
+  }
+
+  explicit AutoTArray(const base_type& aOther)
+  {
+    Init();
+    this->AppendElements(aOther);
+  }
+
+  explicit AutoTArray(base_type&& aOther)
+  {
+    Init();
+    this->SwapElements(aOther);
+  }
+
+  template<typename Allocator>
+  explicit AutoTArray(nsTArray_Impl<elem_type, Allocator>&& aOther)
+  {
+    Init();
+    this->SwapElements(aOther);
+  }
+
+               AutoTArray(std::initializer_list<E> aIL)
+  {
+    Init();
+    this->AppendElements(aIL.begin(), aIL.size());
+  }
+
+  self_type& operator=(const self_type& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+
+  template<typename Allocator>
+  self_type& operator=(const nsTArray_Impl<elem_type, Allocator>& aOther)
+  {
+    base_type::operator=(aOther);
+    return *this;
+  }
+
+private:
+
+
+  template<class Allocator, class Copier>
+  friend class nsTArray_base;
+
+  void Init()
+  {
+    static_assert(mozilla::AlignmentFinder<elem_type>::alignment <= 8,
+                  "can't handle alignments greater than 8, "
+                  "see nsTArray_base::UsesAutoArrayBuffer()");
+
+    Header** phdr = base_type::PtrToHdr();
+    *phdr = reinterpret_cast<Header*>(&mAutoBuf);
+    (*phdr)->mLength = 0;
+    (*phdr)->mCapacity = N;
+    (*phdr)->mIsAutoArray = 1;
+
+    do { } while (0);
+
+
+  }
+
+
+
+
+
+  union
+  {
+    char mAutoBuf[sizeof(nsTArrayHeader) + N * sizeof(elem_type)];
+
+    mozilla::AlignedElem<(mozilla::AlignmentFinder<Header>::alignment > mozilla::AlignmentFinder<elem_type>::alignment) ?
+                         mozilla::AlignmentFinder<Header>::alignment : mozilla::AlignmentFinder<elem_type>::alignment> mAlign;
+  };
+};
+# 2454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+template<class E>
+class AutoTArray<E, 0> : public nsTArray<E>
+{
+};
+
+template<class E, size_t N>
+struct nsTArray_CopyChooser<AutoTArray<E, N>>
+{
+  typedef nsTArray_CopyWithConstructors<AutoTArray<E, N>> Type;
+};
+
+
+namespace mozilla {
+
+template<class ElementType, class TArrayAlloc>
+Span<ElementType>
+MakeSpan(nsTArray_Impl<ElementType, TArrayAlloc>& aTArray)
+{
+  return aTArray;
+}
+
+template<class ElementType, class TArrayAlloc>
+Span<const ElementType>
+MakeSpan(const nsTArray_Impl<ElementType, TArrayAlloc>& aTArray)
+{
+  return aTArray;
+}
+
+}
+# 2497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
+static_assert(sizeof(AutoTArray<uint32_t, 2>) ==
+              sizeof(void*) + sizeof(nsTArrayHeader) + sizeof(uint32_t) * 2,
+              "AutoTArray shouldn't contain any extra padding, "
+              "see the comment");
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
+template<class Alloc, class Copy>
+nsTArray_base<Alloc, Copy>::nsTArray_base()
+  : mHdr(EmptyHdr())
+{
+                               ;
+}
+
+template<class Alloc, class Copy>
+nsTArray_base<Alloc, Copy>::~nsTArray_base()
+{
+  if (mHdr != EmptyHdr() && !UsesAutoArrayBuffer()) {
+    Alloc::Free(mHdr);
+  }
+                               ;
+}
+
+template<class Alloc, class Copy>
+const nsTArrayHeader*
+nsTArray_base<Alloc, Copy>::GetAutoArrayBufferUnsafe(size_t aElemAlign) const
+{
+
+
+
+  const void* autoBuf =
+    &reinterpret_cast<const AutoTArray<nsTArray<uint32_t>, 1>*>(this)->mAutoBuf;
+
+
+
+
+  static_assert(sizeof(void*) != 4 ||
+                (mozilla::AlignmentFinder<mozilla::AlignedElem<8> >::alignment == 8 &&
+                 sizeof(AutoTArray<mozilla::AlignedElem<8>, 1>) ==
+                   sizeof(void*) + sizeof(nsTArrayHeader) +
+                   4 + sizeof(mozilla::AlignedElem<8>)),
+                "auto array padding wasn't what we expected");
+
+
+  do { } while (0);
+
+  if (sizeof(void*) == 4 && aElemAlign == 8) {
+    autoBuf = reinterpret_cast<const char*>(autoBuf) + 4;
+  }
+
+  return reinterpret_cast<const Header*>(autoBuf);
+}
+
+template<class Alloc, class Copy>
+bool
+nsTArray_base<Alloc, Copy>::UsesAutoArrayBuffer() const
+{
+  if (!mHdr->mIsAutoArray) {
+    return false;
+  }
+# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
+  static_assert(sizeof(nsTArrayHeader) > 4,
+                "see comment above");
+# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
+  return mHdr == GetAutoArrayBuffer(4) || mHdr == GetAutoArrayBuffer(8);
+}
+
+
+bool IsTwiceTheRequiredBytesRepresentableAsUint32(size_t aCapacity,
+                                                  size_t aElemSize);
+
+template<class Alloc, class Copy>
+template<typename ActualAlloc>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, Copy>::EnsureCapacity(size_type aCapacity,
+                                           size_type aElemSize)
+{
+
+  if (aCapacity <= mHdr->mCapacity) {
+    return ActualAlloc::SuccessResult();
+  }
+
+
+
+
+
+
+  if (!IsTwiceTheRequiredBytesRepresentableAsUint32(aCapacity, aElemSize)) {
+    ActualAlloc::SizeTooBig((size_t)aCapacity * aElemSize);
+    return ActualAlloc::FailureResult();
+  }
+
+  size_t reqSize = sizeof(Header) + aCapacity * aElemSize;
+
+  if (mHdr == EmptyHdr()) {
+
+    Header* header = static_cast<Header*>(ActualAlloc::Malloc(reqSize));
+    if (!header) {
+      return ActualAlloc::FailureResult();
+    }
+    header->mLength = 0;
+    header->mCapacity = aCapacity;
+    header->mIsAutoArray = 0;
+    mHdr = header;
+
+    return ActualAlloc::SuccessResult();
+  }
+
+
+
+
+
+  const size_t slowGrowthThreshold = 8 * 1024 * 1024;
+
+  size_t bytesToAlloc;
+  if (reqSize >= slowGrowthThreshold) {
+    size_t currSize = sizeof(Header) + Capacity() * aElemSize;
+    size_t minNewSize = currSize + (currSize >> 3);
+    bytesToAlloc = reqSize > minNewSize ? reqSize : minNewSize;
+
+
+    const size_t MiB = 1 << 20;
+    bytesToAlloc = MiB * ((bytesToAlloc + MiB - 1) / MiB);
+  } else {
+
+    bytesToAlloc = mozilla::RoundUpPow2(reqSize);
+  }
+
+  Header* header;
+  if (UsesAutoArrayBuffer() || !Copy::allowRealloc) {
+
+    header = static_cast<Header*>(ActualAlloc::Malloc(bytesToAlloc));
+    if (!header) {
+      return ActualAlloc::FailureResult();
+    }
+
+    Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize);
+
+    if (!UsesAutoArrayBuffer()) {
+      ActualAlloc::Free(mHdr);
+    }
+  } else {
+
+    header = static_cast<Header*>(ActualAlloc::Realloc(mHdr, bytesToAlloc));
+    if (!header) {
+      return ActualAlloc::FailureResult();
+    }
+  }
+
+
+  size_t newCapacity = (bytesToAlloc - sizeof(Header)) / aElemSize;
+  do { } while (0);
+  header->mCapacity = newCapacity;
+
+  mHdr = header;
+
+  return ActualAlloc::SuccessResult();
+}
+
+
+
+template<class Alloc, class Copy>
+void
+nsTArray_base<Alloc, Copy>::ShrinkCapacity(size_type aElemSize,
+                                           size_t aElemAlign)
+{
+  if (mHdr == EmptyHdr() || UsesAutoArrayBuffer()) {
+    return;
+  }
+
+  if (mHdr->mLength >= mHdr->mCapacity) {
+    return;
+  }
+
+  size_type length = Length();
+
+  if (IsAutoArray() && GetAutoArrayBuffer(aElemAlign)->mCapacity >= length) {
+    Header* header = GetAutoArrayBuffer(aElemAlign);
+
+
+    header->mLength = length;
+    Copy::MoveNonOverlappingRegion(header + 1, mHdr + 1, length, aElemSize);
+
+    nsTArrayFallibleAllocator::Free(mHdr);
+    mHdr = header;
+    return;
+  }
+
+  if (length == 0) {
+    do { } while (0);
+    nsTArrayFallibleAllocator::Free(mHdr);
+    mHdr = EmptyHdr();
+    return;
+  }
+
+  size_type size = sizeof(Header) + length * aElemSize;
+  void* ptr = nsTArrayFallibleAllocator::Realloc(mHdr, size);
+  if (!ptr) {
+    return;
+  }
+  mHdr = static_cast<Header*>(ptr);
+  mHdr->mCapacity = length;
+}
+
+template<class Alloc, class Copy>
+template<typename ActualAlloc>
+void
+nsTArray_base<Alloc, Copy>::ShiftData(index_type aStart,
+                                      size_type aOldLen, size_type aNewLen,
+                                      size_type aElemSize, size_t aElemAlign)
+{
+  if (aOldLen == aNewLen) {
+    return;
+  }
+
+
+  size_type num = mHdr->mLength - (aStart + aOldLen);
+
+
+  mHdr->mLength += aNewLen - aOldLen;
+  if (mHdr->mLength == 0) {
+    ShrinkCapacity(aElemSize, aElemAlign);
+  } else {
+
+    if (num == 0) {
+      return;
+    }
+
+    aStart *= aElemSize;
+    aNewLen *= aElemSize;
+    aOldLen *= aElemSize;
+    char* baseAddr = reinterpret_cast<char*>(mHdr + 1) + aStart;
+    Copy::MoveOverlappingRegion(baseAddr + aNewLen, baseAddr + aOldLen, num, aElemSize);
+  }
+}
+
+template<class Alloc, class Copy>
+template<typename ActualAlloc>
+bool
+nsTArray_base<Alloc, Copy>::InsertSlotsAt(index_type aIndex, size_type aCount,
+                                          size_type aElemSize,
+                                          size_t aElemAlign)
+{
+  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
+    InvalidArrayIndex_CRASH(aIndex, Length());
+  }
+
+  size_type newLen = Length() + aCount;
+
+  EnsureCapacity<ActualAlloc>(newLen, aElemSize);
+
+
+  if (Capacity() < newLen) {
+    return false;
+  }
+
+
+
+  ShiftData<ActualAlloc>(aIndex, 0, aCount, aElemSize, aElemAlign);
+
+  return true;
+}
+# 311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
+template<class Alloc, class Copy>
+nsTArray_base<Alloc, Copy>::IsAutoArrayRestorer::IsAutoArrayRestorer(
+      nsTArray_base<Alloc, Copy>& aArray,
+      size_t aElemAlign)
+  : mArray(aArray)
+  , mElemAlign(aElemAlign)
+  , mIsAuto(aArray.IsAutoArray())
+{
+}
+
+template<class Alloc, class Copy>
+nsTArray_base<Alloc, Copy>::IsAutoArrayRestorer::~IsAutoArrayRestorer()
+{
+
+  if (mIsAuto && mArray.mHdr == mArray.EmptyHdr()) {
+
+
+    mArray.mHdr = mArray.GetAutoArrayBufferUnsafe(mElemAlign);
+    mArray.mHdr->mLength = 0;
+  } else if (mArray.mHdr != mArray.EmptyHdr()) {
+    mArray.mHdr->mIsAutoArray = mIsAuto;
+  }
+}
+
+template<class Alloc, class Copy>
+template<typename ActualAlloc, class Allocator>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, Copy>::SwapArrayElements(nsTArray_base<Allocator,
+                                                            Copy>& aOther,
+                                              size_type aElemSize,
+                                              size_t aElemAlign)
+{
+
+
+
+
+
+
+  IsAutoArrayRestorer ourAutoRestorer(*this, aElemAlign);
+  typename nsTArray_base<Allocator, Copy>::IsAutoArrayRestorer
+    otherAutoRestorer(aOther, aElemAlign);
+
+
+
+
+  if ((!UsesAutoArrayBuffer() || Capacity() < aOther.Length()) &&
+      (!aOther.UsesAutoArrayBuffer() || aOther.Capacity() < Length())) {
+
+    if (!EnsureNotUsingAutoArrayBuffer<ActualAlloc>(aElemSize) ||
+        !aOther.template EnsureNotUsingAutoArrayBuffer<ActualAlloc>(aElemSize)) {
+      return ActualAlloc::FailureResult();
+    }
+
+    Header* temp = mHdr;
+    mHdr = aOther.mHdr;
+    aOther.mHdr = temp;
+
+    return ActualAlloc::SuccessResult();
+  }
+# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
+  if (!ActualAlloc::Successful(EnsureCapacity<ActualAlloc>(aOther.Length(), aElemSize)) ||
+      !Allocator::Successful(aOther.template EnsureCapacity<Allocator>(Length(), aElemSize))) {
+    return ActualAlloc::FailureResult();
+  }
+
+
+
+  do { } while (0);
+
+
+  size_type smallerLength = XPCOM_MIN(Length(), aOther.Length());
+  size_type largerLength = XPCOM_MAX(Length(), aOther.Length());
+  void* smallerElements;
+  void* largerElements;
+  if (Length() <= aOther.Length()) {
+    smallerElements = Hdr() + 1;
+    largerElements = aOther.Hdr() + 1;
+  } else {
+    smallerElements = aOther.Hdr() + 1;
+    largerElements = Hdr() + 1;
+  }
+
+
+
+
+
+
+  AutoTArray<nsTArray_Impl<uint8_t, ActualAlloc>, 64> temp;
+  if (!ActualAlloc::Successful(temp.template EnsureCapacity<ActualAlloc>(smallerLength,
+                                                                         aElemSize))) {
+    return ActualAlloc::FailureResult();
+  }
+
+  Copy::MoveNonOverlappingRegion(temp.Elements(), smallerElements, smallerLength, aElemSize);
+  Copy::MoveNonOverlappingRegion(smallerElements, largerElements, largerLength, aElemSize);
+  Copy::MoveNonOverlappingRegion(largerElements, temp.Elements(), smallerLength, aElemSize);
+
+
+  do { } while (0);
+
+
+  size_type tempLength = Length();
+
+
+
+  if (mHdr != EmptyHdr()) {
+    mHdr->mLength = aOther.Length();
+  }
+  if (aOther.mHdr != EmptyHdr()) {
+    aOther.mHdr->mLength = tempLength;
+  }
+
+  return ActualAlloc::SuccessResult();
+}
+
+template<class Alloc, class Copy>
+template<typename ActualAlloc>
+bool
+nsTArray_base<Alloc, Copy>::EnsureNotUsingAutoArrayBuffer(size_type aElemSize)
+{
+  if (UsesAutoArrayBuffer()) {
+
+
+
+
+
+    if (Length() == 0) {
+      mHdr = EmptyHdr();
+      return true;
+    }
+
+    size_type size = sizeof(Header) + Length() * aElemSize;
+
+    Header* header = static_cast<Header*>(ActualAlloc::Malloc(size));
+    if (!header) {
+      return false;
+    }
+
+    Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize);
+    header->mCapacity = Length();
+    mHdr = header;
+  }
+
+  return true;
+}
+# 2504 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 2
+
+
+
+
+
+
+template<typename T>
+class nsStyleAutoArray
+{
+public:
+
+  enum WithSingleInitialElement { WITH_SINGLE_INITIAL_ELEMENT };
+  explicit nsStyleAutoArray(WithSingleInitialElement) {}
+  nsStyleAutoArray(const nsStyleAutoArray& aOther) { *this = aOther; }
+  nsStyleAutoArray& operator=(const nsStyleAutoArray& aOther) {
+    mFirstElement = aOther.mFirstElement;
+    mOtherElements = aOther.mOtherElements;
+    return *this;
+  }
+
+  bool operator==(const nsStyleAutoArray& aOther) const {
+    return Length() == aOther.Length() &&
+           mFirstElement == aOther.mFirstElement &&
+           mOtherElements == aOther.mOtherElements;
+  }
+  bool operator!=(const nsStyleAutoArray& aOther) const {
+    return !(*this == aOther);
+  }
+
+  nsStyleAutoArray& operator=(nsStyleAutoArray&& aOther) {
+    mFirstElement = aOther.mFirstElement;
+    mOtherElements.SwapElements(aOther.mOtherElements);
+
+    return *this;
+  }
+
+  size_t Length() const {
+    return mOtherElements.Length() + 1;
+  }
+  const T& operator[](size_t aIndex) const {
+    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
+  }
+  T& operator[](size_t aIndex) {
+    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
+  }
+
+  void EnsureLengthAtLeast(size_t aMinLen) {
+    if (aMinLen > 0) {
+      mOtherElements.EnsureLengthAtLeast(aMinLen - 1);
+    }
+  }
+
+  void SetLengthNonZero(size_t aNewLen) {
+    do { } while (0);
+    mOtherElements.SetLength(aNewLen - 1);
+  }
+
+  void TruncateLengthNonZero(size_t aNewLen) {
+    do { } while (0);
+    do { } while (0);
+    mOtherElements.TruncateLength(aNewLen - 1);
+  }
+
+private:
+  T mFirstElement;
+  nsTArray<T> mOtherElements;
+};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+
+
+struct RawServoStyleSet;
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
+
+
+
+
+
+
+
+
+struct ServoCssRules;
+struct RawServoStyleSheet;
+struct ServoComputedValues;
+struct RawServoDeclarationBlock;
+struct RawServoStyleRule;
+struct RawServoImportRule;
+struct RawServoAnimationValue;
+struct RawServoAnimationValueMap;
+struct RawServoMediaList;
+struct RawServoMediaRule;
+struct RawServoNamespaceRule;
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+
+
+namespace mozilla {
+  class ServoElementSnapshot;
+  struct StyleAnimation;
+namespace css {
+struct URLExtraData;
+}
+namespace dom {
+class Element;
+class StyleChildrenIterator;
+}
+struct AnimationPropertySegment;
+struct ComputedTiming;
+struct Keyframe;
+struct PropertyStyleAnimationValuePair;
+using ComputedKeyframeValues = nsTArray<PropertyStyleAnimationValuePair>;
+}
+
+class nsCSSValue;
+struct nsFontFaceRuleContainer;
+class nsIDocument;
+class nsINode;
+class nsPresContext;
+struct nsTimingFunction;
+
+using mozilla::dom::StyleChildrenIterator;
+using mozilla::ServoElementSnapshot;
+
+typedef nsINode RawGeckoNode;
+typedef mozilla::dom::Element RawGeckoElement;
+typedef nsIDocument RawGeckoDocument;
+typedef nsPresContext RawGeckoPresContext;
+typedef mozilla::css::URLExtraData RawGeckoURLExtraData;
+typedef nsTArray<mozilla::Keyframe> RawGeckoKeyframeList;
+typedef nsTArray<mozilla::ComputedKeyframeValues> RawGeckoComputedKeyframeValuesList;
+typedef nsTArray<mozilla::PropertyStyleAnimationValuePair> RawGeckoAnimationValueList;
+typedef nsStyleAutoArray<mozilla::StyleAnimation> RawGeckoStyleAnimationList;
+typedef nsTArray<nsFontFaceRuleContainer> RawGeckoFontFaceRuleList;
+typedef mozilla::AnimationPropertySegment RawGeckoAnimationPropertySegment;
+typedef mozilla::ComputedTiming RawGeckoComputedTiming;
+# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
+
+
+
+
+
+
+
+
+typedef ServoCssRules const* ServoCssRulesBorrowedOrNull; typedef ServoCssRules const* ServoCssRulesBorrowed; typedef ServoCssRules* ServoCssRulesBorrowedMut; struct ServoCssRulesStrong { ServoCssRules* mPtr; already_AddRefed<ServoCssRules> Consume(); };
+typedef RawServoStyleSheet const* RawServoStyleSheetBorrowedOrNull; typedef RawServoStyleSheet const* RawServoStyleSheetBorrowed; typedef RawServoStyleSheet* RawServoStyleSheetBorrowedMut; struct RawServoStyleSheetStrong { RawServoStyleSheet* mPtr; already_AddRefed<RawServoStyleSheet> Consume(); };
+typedef ServoComputedValues const* ServoComputedValuesBorrowedOrNull; typedef ServoComputedValues const* ServoComputedValuesBorrowed; typedef ServoComputedValues* ServoComputedValuesBorrowedMut; struct ServoComputedValuesStrong { ServoComputedValues* mPtr; already_AddRefed<ServoComputedValues> Consume(); };
+typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowedOrNull; typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowed; typedef RawServoDeclarationBlock* RawServoDeclarationBlockBorrowedMut; struct RawServoDeclarationBlockStrong { RawServoDeclarationBlock* mPtr; already_AddRefed<RawServoDeclarationBlock> Consume(); };
+typedef RawServoStyleRule const* RawServoStyleRuleBorrowedOrNull; typedef RawServoStyleRule const* RawServoStyleRuleBorrowed; typedef RawServoStyleRule* RawServoStyleRuleBorrowedMut; struct RawServoStyleRuleStrong { RawServoStyleRule* mPtr; already_AddRefed<RawServoStyleRule> Consume(); };
+typedef RawServoImportRule const* RawServoImportRuleBorrowedOrNull; typedef RawServoImportRule const* RawServoImportRuleBorrowed; typedef RawServoImportRule* RawServoImportRuleBorrowedMut; struct RawServoImportRuleStrong { RawServoImportRule* mPtr; already_AddRefed<RawServoImportRule> Consume(); };
+typedef RawServoAnimationValue const* RawServoAnimationValueBorrowedOrNull; typedef RawServoAnimationValue const* RawServoAnimationValueBorrowed; typedef RawServoAnimationValue* RawServoAnimationValueBorrowedMut; struct RawServoAnimationValueStrong { RawServoAnimationValue* mPtr; already_AddRefed<RawServoAnimationValue> Consume(); };
+typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowedOrNull; typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowed; typedef RawServoAnimationValueMap* RawServoAnimationValueMapBorrowedMut; struct RawServoAnimationValueMapStrong { RawServoAnimationValueMap* mPtr; already_AddRefed<RawServoAnimationValueMap> Consume(); };
+typedef RawServoMediaList const* RawServoMediaListBorrowedOrNull; typedef RawServoMediaList const* RawServoMediaListBorrowed; typedef RawServoMediaList* RawServoMediaListBorrowedMut; struct RawServoMediaListStrong { RawServoMediaList* mPtr; already_AddRefed<RawServoMediaList> Consume(); };
+typedef RawServoMediaRule const* RawServoMediaRuleBorrowedOrNull; typedef RawServoMediaRule const* RawServoMediaRuleBorrowed; typedef RawServoMediaRule* RawServoMediaRuleBorrowedMut; struct RawServoMediaRuleStrong { RawServoMediaRule* mPtr; already_AddRefed<RawServoMediaRule> Consume(); };
+typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowedOrNull; typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowed; typedef RawServoNamespaceRule* RawServoNamespaceRuleBorrowedMut; struct RawServoNamespaceRuleStrong { RawServoNamespaceRule* mPtr; already_AddRefed<RawServoNamespaceRule> Consume(); };
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
+typedef RawServoDeclarationBlockStrong const* RawServoDeclarationBlockStrongBorrowedOrNull;
+
+typedef RawServoStyleSet* RawServoStyleSetOwned; typedef RawServoStyleSet const* RawServoStyleSetBorrowed; typedef RawServoStyleSet* RawServoStyleSetBorrowedMut;
+typedef StyleChildrenIterator* StyleChildrenIteratorOwnedOrNull; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowedOrNull; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMutOrNull;
+typedef StyleChildrenIterator* StyleChildrenIteratorOwned; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowed; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut;
+typedef ServoElementSnapshot* ServoElementSnapshotOwned; typedef ServoElementSnapshot const* ServoElementSnapshotBorrowed; typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut;
+
+
+
+
+
+
+typedef RawGeckoNode const* RawGeckoNodeBorrowed;
+typedef RawGeckoNode const* RawGeckoNodeBorrowedOrNull;
+typedef RawGeckoElement const* RawGeckoElementBorrowed;
+typedef RawGeckoElement const* RawGeckoElementBorrowedOrNull;
+typedef RawGeckoDocument const* RawGeckoDocumentBorrowed;
+typedef RawGeckoDocument const* RawGeckoDocumentBorrowedOrNull;
+typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut;
+typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut;
+typedef nsCSSValue const* nsCSSValueBorrowed;
+typedef nsCSSValue* nsCSSValueBorrowedMut;
+typedef RawGeckoPresContext* RawGeckoPresContextOwned; typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed; typedef RawGeckoPresContext* RawGeckoPresContextBorrowedMut;
+typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed;
+typedef RawGeckoAnimationValueList* RawGeckoAnimationValueListBorrowedMut;
+typedef RawGeckoKeyframeList* RawGeckoKeyframeListBorrowedMut;
+typedef RawGeckoKeyframeList const* RawGeckoKeyframeListBorrowed;
+typedef RawGeckoComputedKeyframeValuesList* RawGeckoComputedKeyframeValuesListBorrowedMut;
+typedef RawGeckoStyleAnimationList const* RawGeckoStyleAnimationListBorrowed;
+typedef nsTimingFunction* nsTimingFunctionBorrowedMut;
+typedef nsTimingFunction const* nsTimingFunctionBorrowed;
+typedef RawGeckoFontFaceRuleList* RawGeckoFontFaceRuleListBorrowedMut;
+typedef RawGeckoAnimationPropertySegment const* RawGeckoAnimationPropertySegmentBorrowed;
+typedef RawGeckoComputedTiming const* RawGeckoComputedTimingBorrowed;
+# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
+
+
+
+
+
+
+
+
+extern "C" { void Servo_CssRules_AddRef( ServoCssRulesBorrowed ptr); void Servo_CssRules_Release( ServoCssRulesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<ServoCssRules> { static void AddRef(ServoCssRules* aPtr) { Servo_CssRules_AddRef(aPtr); } static void Release(ServoCssRules* aPtr) { Servo_CssRules_Release(aPtr); } }; }
+extern "C" { void Servo_StyleSheet_AddRef( RawServoStyleSheetBorrowed ptr); void Servo_StyleSheet_Release( RawServoStyleSheetBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoStyleSheet> { static void AddRef(RawServoStyleSheet* aPtr) { Servo_StyleSheet_AddRef(aPtr); } static void Release(RawServoStyleSheet* aPtr) { Servo_StyleSheet_Release(aPtr); } }; }
+extern "C" { void Servo_ComputedValues_AddRef( ServoComputedValuesBorrowed ptr); void Servo_ComputedValues_Release( ServoComputedValuesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<ServoComputedValues> { static void AddRef(ServoComputedValues* aPtr) { Servo_ComputedValues_AddRef(aPtr); } static void Release(ServoComputedValues* aPtr) { Servo_ComputedValues_Release(aPtr); } }; }
+extern "C" { void Servo_DeclarationBlock_AddRef( RawServoDeclarationBlockBorrowed ptr); void Servo_DeclarationBlock_Release( RawServoDeclarationBlockBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoDeclarationBlock> { static void AddRef(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_AddRef(aPtr); } static void Release(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_Release(aPtr); } }; }
+extern "C" { void Servo_StyleRule_AddRef( RawServoStyleRuleBorrowed ptr); void Servo_StyleRule_Release( RawServoStyleRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoStyleRule> { static void AddRef(RawServoStyleRule* aPtr) { Servo_StyleRule_AddRef(aPtr); } static void Release(RawServoStyleRule* aPtr) { Servo_StyleRule_Release(aPtr); } }; }
+extern "C" { void Servo_ImportRule_AddRef( RawServoImportRuleBorrowed ptr); void Servo_ImportRule_Release( RawServoImportRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoImportRule> { static void AddRef(RawServoImportRule* aPtr) { Servo_ImportRule_AddRef(aPtr); } static void Release(RawServoImportRule* aPtr) { Servo_ImportRule_Release(aPtr); } }; }
+extern "C" { void Servo_AnimationValue_AddRef( RawServoAnimationValueBorrowed ptr); void Servo_AnimationValue_Release( RawServoAnimationValueBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoAnimationValue> { static void AddRef(RawServoAnimationValue* aPtr) { Servo_AnimationValue_AddRef(aPtr); } static void Release(RawServoAnimationValue* aPtr) { Servo_AnimationValue_Release(aPtr); } }; }
+extern "C" { void Servo_AnimationValueMap_AddRef( RawServoAnimationValueMapBorrowed ptr); void Servo_AnimationValueMap_Release( RawServoAnimationValueMapBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoAnimationValueMap> { static void AddRef(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_AddRef(aPtr); } static void Release(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_Release(aPtr); } }; }
+extern "C" { void Servo_MediaList_AddRef( RawServoMediaListBorrowed ptr); void Servo_MediaList_Release( RawServoMediaListBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoMediaList> { static void AddRef(RawServoMediaList* aPtr) { Servo_MediaList_AddRef(aPtr); } static void Release(RawServoMediaList* aPtr) { Servo_MediaList_Release(aPtr); } }; }
+extern "C" { void Servo_MediaRule_AddRef( RawServoMediaRuleBorrowed ptr); void Servo_MediaRule_Release( RawServoMediaRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoMediaRule> { static void AddRef(RawServoMediaRule* aPtr) { Servo_MediaRule_AddRef(aPtr); } static void Release(RawServoMediaRule* aPtr) { Servo_MediaRule_Release(aPtr); } }; }
+extern "C" { void Servo_NamespaceRule_AddRef( RawServoNamespaceRuleBorrowed ptr); void Servo_NamespaceRule_Release( RawServoNamespaceRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoNamespaceRule> { static void AddRef(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_AddRef(aPtr); } static void Release(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_Release(aPtr); } }; }
+# 165 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
+# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
+extern "C" void Servo_StyleSet_Drop( RawServoStyleSetOwned ptr); namespace mozilla { template<> class DefaultDelete<RawServoStyleSet> { public: void operator()(RawServoStyleSet* aPtr) const { Servo_StyleSet_Drop(aPtr); } }; };
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+namespace mozilla {
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+class EventStates
+{
+public:
+  typedef uint64_t InternalType;
+  typedef uint64_t ServoType;
+
+  constexpr EventStates()
+    : mStates(0)
+  {
+  }
+
+
+
+
+
+
+  explicit constexpr EventStates(InternalType aStates)
+    : mStates(aStates)
+  {
+  }
+
+  EventStates constexpr operator|(const EventStates& aEventStates) const
+  {
+    return EventStates(mStates | aEventStates.mStates);
+  }
+
+  EventStates& operator|=(const EventStates& aEventStates)
+  {
+    mStates |= aEventStates.mStates;
+    return *this;
+  }
+
+
+
+
+  EventStates constexpr operator&(const EventStates& aEventStates) const
+  {
+    return EventStates(mStates & aEventStates.mStates);
+  }
+
+  EventStates& operator&=(const EventStates& aEventStates)
+  {
+    mStates &= aEventStates.mStates;
+    return *this;
+  }
+
+  bool operator==(const EventStates& aEventStates) const
+  {
+    return mStates == aEventStates.mStates;
+  }
+
+  bool operator!=(const EventStates& aEventStates) const
+  {
+    return mStates != aEventStates.mStates;
+  }
+
+  EventStates operator~() const
+  {
+    return EventStates(~mStates);
+  }
+
+  EventStates operator^(const EventStates& aEventStates) const
+  {
+    return EventStates(mStates ^ aEventStates.mStates);
+  }
+
+  EventStates& operator^=(const EventStates& aEventStates)
+  {
+    mStates ^= aEventStates.mStates;
+    return *this;
+  }
+
+
+
+
+
+
+
+  bool IsEmpty() const
+  {
+    return mStates == 0;
+  }
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+  bool HasState(EventStates aEventStates) const
+  {
+# 124 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+    return mStates & aEventStates.mStates;
+  }
+# 135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+  bool HasAtLeastOneOfStates(EventStates aEventStates) const
+  {
+    return mStates & aEventStates.mStates;
+  }
+# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
+  bool HasAllStates(EventStates aEventStates) const
+  {
+    return (mStates & aEventStates.mStates) == aEventStates.mStates;
+  }
+
+
+
+  InternalType GetInternalValue() const {
+    return mStates;
+  }
+
+
+
+
+  ServoType ServoValue() const
+  {
+    return mStates;
+  }
+
+private:
+  InternalType mStates;
+};
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h"
+class nsAttrName;
+class nsAttrValue;
+
+namespace mozilla {
+namespace dom {
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h"
+struct BorrowedAttrInfo
+{
+  BorrowedAttrInfo()
+    : mName(nullptr)
+    , mValue(nullptr)
+  {
+  }
+
+  BorrowedAttrInfo(const nsAttrName* aName, const nsAttrValue* aValue);
+
+  BorrowedAttrInfo(const BorrowedAttrInfo& aOther);
+
+  const nsAttrName* mName;
+  const nsAttrValue* mValue;
+
+  explicit operator bool() const { return mName != nullptr; }
+};
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAnnotations.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+namespace mozilla {
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+struct FloatTypeTraits
+{
+  typedef uint32_t Bits;
+
+  static const unsigned kExponentBias = 127;
+  static const unsigned kExponentShift = 23;
+
+  static const Bits kSignBit = 0x80000000UL;
+  static const Bits kExponentBits = 0x7F800000UL;
+  static const Bits kSignificandBits = 0x007FFFFFUL;
+};
+
+struct DoubleTypeTraits
+{
+  typedef uint64_t Bits;
+
+  static const unsigned kExponentBias = 1023;
+  static const unsigned kExponentShift = 52;
+
+  static const Bits kSignBit = 0x8000000000000000ULL;
+  static const Bits kExponentBits = 0x7ff0000000000000ULL;
+  static const Bits kSignificandBits = 0x000fffffffffffffULL;
+};
+
+template<typename T> struct SelectTrait;
+template<> struct SelectTrait<float> : public FloatTypeTraits {};
+template<> struct SelectTrait<double> : public DoubleTypeTraits {};
+# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+struct FloatingPoint : public SelectTrait<T>
+{
+  typedef SelectTrait<T> Base;
+  typedef typename Base::Bits Bits;
+
+  static_assert((Base::kSignBit & Base::kExponentBits) == 0,
+                "sign bit shouldn't overlap exponent bits");
+  static_assert((Base::kSignBit & Base::kSignificandBits) == 0,
+                "sign bit shouldn't overlap significand bits");
+  static_assert((Base::kExponentBits & Base::kSignificandBits) == 0,
+                "exponent bits shouldn't overlap significand bits");
+
+  static_assert((Base::kSignBit | Base::kExponentBits | Base::kSignificandBits) ==
+                ~Bits(0),
+                "all bits accounted for");
+# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+  static_assert(sizeof(T) == sizeof(Bits), "Bits must be same size as T");
+};
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsNaN(T aValue)
+{
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  return (BitwiseCast<Bits>(aValue) & Traits::kExponentBits) == Traits::kExponentBits &&
+         (BitwiseCast<Bits>(aValue) & Traits::kSignificandBits) != 0;
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsInfinite(T aValue)
+{
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return (bits & ~Traits::kSignBit) == Traits::kExponentBits;
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsFinite(T aValue)
+{
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return (bits & Traits::kExponentBits) != Traits::kExponentBits;
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsNegative(T aValue)
+{
+  do { } while (0);
+
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return (bits & Traits::kSignBit) != 0;
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsNegativeZero(T aValue)
+{
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return bits == Traits::kSignBit;
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline bool
+IsPositiveZero(T aValue)
+{
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return bits == 0;
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+ToZeroIfNonfinite(T aValue)
+{
+  return IsFinite(aValue) ? aValue : 0;
+}
+
+
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline int_fast16_t
+ExponentComponent(T aValue)
+{
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  Bits bits = BitwiseCast<Bits>(aValue);
+  return int_fast16_t((bits & Traits::kExponentBits) >> Traits::kExponentShift) -
+         int_fast16_t(Traits::kExponentBias);
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+PositiveInfinity()
+{
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  return BitwiseCast<T>(Traits::kExponentBits);
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+NegativeInfinity()
+{
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  return BitwiseCast<T>(Traits::kSignBit | Traits::kExponentBits);
+}
+
+
+
+
+
+template<typename T,
+         int SignBit,
+         typename FloatingPoint<T>::Bits Significand>
+struct SpecificNaNBits
+{
+  using Traits = FloatingPoint<T>;
+
+  static_assert(SignBit == 0 || SignBit == 1, "bad sign bit");
+  static_assert((Significand & ~Traits::kSignificandBits) == 0,
+                "significand must only have significand bits set");
+  static_assert(Significand & Traits::kSignificandBits,
+                "significand must be nonzero");
+
+  static constexpr typename Traits::Bits value =
+    (SignBit * Traits::kSignBit) | Traits::kExponentBits | Significand;
+};
+# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+static __attribute__((always_inline)) inline void
+SpecificNaN(int signbit, typename FloatingPoint<T>::Bits significand, T* result)
+{
+  typedef FloatingPoint<T> Traits;
+  do { } while (0);
+  do { } while (0);
+  do { } while (0);
+
+  BitwiseCast<T>((signbit ? Traits::kSignBit : 0) |
+                  Traits::kExponentBits |
+                  significand,
+                  result);
+  do { } while (0);
+}
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+SpecificNaN(int signbit, typename FloatingPoint<T>::Bits significand)
+{
+  T t;
+  SpecificNaN(signbit, significand, &t);
+  return t;
+}
+
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+MinNumberValue()
+{
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  return BitwiseCast<T>(Bits(1));
+}
+# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+static __attribute__((always_inline)) inline bool
+NumberEqualsInt32(T aValue, int32_t* aInt32)
+{
+
+
+
+
+
+
+  return aValue == (*aInt32 = int32_t(aValue));
+}
+# 358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+static __attribute__((always_inline)) inline bool
+NumberIsInt32(T aValue, int32_t* aInt32)
+{
+  return !IsNegativeZero(aValue) && NumberEqualsInt32(aValue, aInt32);
+}
+
+
+
+
+
+template<typename T>
+static __attribute__((always_inline)) inline T
+UnspecifiedNaN()
+{
+
+
+
+
+
+
+  typedef FloatingPoint<T> Traits;
+  return SpecificNaN<T>(1, Traits::kSignificandBits);
+}
+
+
+
+
+
+
+template<typename T>
+static inline bool
+NumbersAreIdentical(T aValue1, T aValue2)
+{
+  typedef FloatingPoint<T> Traits;
+  typedef typename Traits::Bits Bits;
+  if (IsNaN(aValue1)) {
+    return IsNaN(aValue2);
+  }
+  return BitwiseCast<Bits>(aValue1) == BitwiseCast<Bits>(aValue2);
+}
+
+namespace detail {
+
+template<typename T>
+struct FuzzyEqualsEpsilon;
+
+template<>
+struct FuzzyEqualsEpsilon<float>
+{
+
+  static float value() { return 1.0f / (1 << 17); }
+};
+
+template<>
+struct FuzzyEqualsEpsilon<double>
+{
+
+  static double value() { return 1.0 / (1LL << 40); }
+};
+
+}
+# 433 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+static __attribute__((always_inline)) inline bool
+FuzzyEqualsAdditive(T aValue1, T aValue2,
+                    T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
+{
+  static_assert(IsFloatingPoint<T>::value, "floating point type required");
+  return Abs(aValue1 - aValue2) <= aEpsilon;
+}
+# 454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+template<typename T>
+static __attribute__((always_inline)) inline bool
+FuzzyEqualsMultiplicative(T aValue1, T aValue2,
+                          T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
+{
+  static_assert(IsFloatingPoint<T>::value, "floating point type required");
+
+  T smaller = Abs(aValue1) < Abs(aValue2) ? Abs(aValue1) : Abs(aValue2);
+  return Abs(aValue1 - aValue2) <= aEpsilon * smaller;
+}
+# 473 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
+__attribute__ ((warn_unused_result))
+extern __attribute__((weak)) __attribute__((visibility("default"))) bool
+IsFloat32Representable(double aFloat32);
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 2
+
+
+
+namespace IPC {
+template<typename T> struct ParamTraits;
+}
+
+
+
+
+
+
+
+namespace mozilla {
+
+
+typedef uint64_t TimeStampValue;
+
+
+class TimeStamp;
+
+
+
+
+class BaseTimeDurationPlatformUtils
+{
+public:
+  static __attribute__((weak)) __attribute__((visibility("default"))) double ToSeconds(int64_t aTicks);
+  static __attribute__((weak)) __attribute__((visibility("default"))) double ToSecondsSigDigits(int64_t aTicks);
+  static __attribute__((weak)) __attribute__((visibility("default"))) int64_t TicksFromMilliseconds(double aMilliseconds);
+  static __attribute__((weak)) __attribute__((visibility("default"))) int64_t ResolutionInTicks();
+};
+# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+template <typename ValueCalculator>
+class BaseTimeDuration
+{
+public:
+
+  constexpr BaseTimeDuration() : mValue(0) {}
+
+
+  struct _SomethingVeryRandomHere;
+               BaseTimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0)
+  {
+    do { } while (0);
+  }
+
+
+
+  template <typename E>
+  explicit BaseTimeDuration(const BaseTimeDuration<E>& aOther)
+    : mValue(aOther.mValue)
+  { }
+
+  template <typename E>
+  BaseTimeDuration& operator=(const BaseTimeDuration<E>& aOther)
+  {
+    mValue = aOther.mValue;
+    return *this;
+  }
+
+  double ToSeconds() const
+  {
+    if (mValue == (9223372036854775807L)) {
+      return PositiveInfinity<double>();
+    }
+    if (mValue == (-9223372036854775807L -1)) {
+      return NegativeInfinity<double>();
+    }
+    return BaseTimeDurationPlatformUtils::ToSeconds(mValue);
+  }
+
+
+
+  double ToSecondsSigDigits() const
+  {
+    if (mValue == (9223372036854775807L)) {
+      return PositiveInfinity<double>();
+    }
+    if (mValue == (-9223372036854775807L -1)) {
+      return NegativeInfinity<double>();
+    }
+    return BaseTimeDurationPlatformUtils::ToSecondsSigDigits(mValue);
+  }
+  double ToMilliseconds() const { return ToSeconds() * 1000.0; }
+  double ToMicroseconds() const { return ToMilliseconds() * 1000.0; }
+
+
+
+
+
+
+  static inline BaseTimeDuration FromSeconds(double aSeconds)
+  {
+    return FromMilliseconds(aSeconds * 1000.0);
+  }
+  static BaseTimeDuration FromMilliseconds(double aMilliseconds)
+  {
+    if (aMilliseconds == PositiveInfinity<double>()) {
+      return Forever();
+    }
+    if (aMilliseconds == NegativeInfinity<double>()) {
+      return FromTicks((-9223372036854775807L -1));
+    }
+    return FromTicks(
+      BaseTimeDurationPlatformUtils::TicksFromMilliseconds(aMilliseconds));
+  }
+  static inline BaseTimeDuration FromMicroseconds(double aMicroseconds)
+  {
+    return FromMilliseconds(aMicroseconds / 1000.0);
+  }
+
+  static BaseTimeDuration Forever()
+  {
+    return FromTicks((9223372036854775807L));
+  }
+
+  BaseTimeDuration operator+(const BaseTimeDuration& aOther) const
+  {
+    return FromTicks(ValueCalculator::Add(mValue, aOther.mValue));
+  }
+  BaseTimeDuration operator-(const BaseTimeDuration& aOther) const
+  {
+    return FromTicks(ValueCalculator::Subtract(mValue, aOther.mValue));
+  }
+  BaseTimeDuration& operator+=(const BaseTimeDuration& aOther)
+  {
+    mValue = ValueCalculator::Add(mValue, aOther.mValue);
+    return *this;
+  }
+  BaseTimeDuration& operator-=(const BaseTimeDuration& aOther)
+  {
+    mValue = ValueCalculator::Subtract(mValue, aOther.mValue);
+    return *this;
+  }
+  BaseTimeDuration operator-() const
+  {
+
+
+    int64_t ticks;
+    if (mValue == (9223372036854775807L)) {
+      ticks = (-9223372036854775807L -1);
+    } else if (mValue == (-9223372036854775807L -1)) {
+      ticks = (9223372036854775807L);
+    } else {
+      ticks = -mValue;
+    }
+
+    return FromTicks(ticks);
+  }
+
+  static BaseTimeDuration Max(const BaseTimeDuration& aA,
+                              const BaseTimeDuration& aB)
+  {
+    return FromTicks(std::max(aA.mValue, aB.mValue));
+  }
+  static BaseTimeDuration Min(const BaseTimeDuration& aA,
+                              const BaseTimeDuration& aB)
+  {
+    return FromTicks(std::min(aA.mValue, aB.mValue));
+  }
+
+private:
+
+
+  BaseTimeDuration operator*(const double aMultiplier) const = delete;
+
+
+
+
+  BaseTimeDuration operator/(const double aDivisor) const = delete;
+
+public:
+  BaseTimeDuration MultDouble(double aMultiplier) const
+  {
+    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+  }
+  BaseTimeDuration operator*(const int32_t aMultiplier) const
+  {
+    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+  }
+  BaseTimeDuration operator*(const uint32_t aMultiplier) const
+  {
+    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+  }
+  BaseTimeDuration operator*(const int64_t aMultiplier) const
+  {
+    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+  }
+  BaseTimeDuration operator*(const uint64_t aMultiplier) const
+  {
+    if (aMultiplier > (9223372036854775807L)) {
+      return Forever();
+    }
+    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
+  }
+  BaseTimeDuration operator/(const int64_t aDivisor) const
+  {
+    do { } while (0);
+    return FromTicks(ValueCalculator::Divide(mValue, aDivisor));
+  }
+  double operator/(const BaseTimeDuration& aOther) const
+  {
+
+
+    do { } while (0);
+
+    return ValueCalculator::DivideDouble(mValue, aOther.mValue);
+  }
+  BaseTimeDuration operator%(const BaseTimeDuration& aOther) const
+  {
+    do { } while (0);
+    return FromTicks(ValueCalculator::Modulo(mValue, aOther.mValue));
+  }
+
+  template<typename E>
+  bool operator<(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue < aOther.mValue;
+  }
+  template<typename E>
+  bool operator<=(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue <= aOther.mValue;
+  }
+  template<typename E>
+  bool operator>=(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue >= aOther.mValue;
+  }
+  template<typename E>
+  bool operator>(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue > aOther.mValue;
+  }
+  template<typename E>
+  bool operator==(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue == aOther.mValue;
+  }
+  template<typename E>
+  bool operator!=(const BaseTimeDuration<E>& aOther) const
+  {
+    return mValue != aOther.mValue;
+  }
+  bool IsZero() const
+  {
+    return mValue == 0;
+  }
+  explicit operator bool() const
+  {
+    return mValue != 0;
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const BaseTimeDuration& aDuration) {
+    return aStream << aDuration.ToMilliseconds() << " ms";
+  }
+
+
+
+
+
+  static BaseTimeDuration Resolution() {
+    return FromTicks(BaseTimeDurationPlatformUtils::ResolutionInTicks());
+  }
+# 303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+private:
+  friend class TimeStamp;
+  friend struct IPC::ParamTraits<mozilla::BaseTimeDuration<ValueCalculator>>;
+  template <typename>
+  friend class BaseTimeDuration;
+
+  static BaseTimeDuration FromTicks(int64_t aTicks)
+  {
+    BaseTimeDuration t;
+    t.mValue = aTicks;
+    return t;
+  }
+
+  static BaseTimeDuration FromTicks(double aTicks)
+  {
+
+
+    if (aTicks >= double((9223372036854775807L))) {
+      return FromTicks((9223372036854775807L));
+    }
+
+
+    if (aTicks <= double((-9223372036854775807L -1))) {
+      return FromTicks((-9223372036854775807L -1));
+    }
+
+    return FromTicks(int64_t(aTicks));
+  }
+
+
+  int64_t mValue;
+};
+
+
+
+
+
+class TimeDurationValueCalculator
+{
+public:
+  static int64_t Add(int64_t aA, int64_t aB) { return aA + aB; }
+  static int64_t Subtract(int64_t aA, int64_t aB) { return aA - aB; }
+
+  template <typename T>
+  static int64_t Multiply(int64_t aA, T aB)
+  {
+    static_assert(IsIntegral<T>::value,
+                  "Using integer multiplication routine with non-integer type."
+                  " Further specialization required");
+    return aA * static_cast<int64_t>(aB);
+  }
+
+  static int64_t Divide(int64_t aA, int64_t aB) { return aA / aB; }
+  static double DivideDouble(int64_t aA, int64_t aB)
+  {
+    return static_cast<double>(aA) / aB;
+  }
+  static int64_t Modulo(int64_t aA, int64_t aB) { return aA % aB; }
+};
+
+template <>
+inline int64_t
+TimeDurationValueCalculator::Multiply<double>(int64_t aA, double aB)
+{
+  return static_cast<int64_t>(aA * aB);
+}
+# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+typedef BaseTimeDuration<TimeDurationValueCalculator> TimeDuration;
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+class TimeStamp
+{
+public:
+
+
+
+  constexpr TimeStamp() : mValue(0) {}
+# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+  bool IsNull() const { return mValue == 0; }
+
+
+
+
+
+  explicit operator bool() const
+  {
+    return mValue != 0;
+  }
+# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+  static TimeStamp Now() { return Now(true); }
+  static TimeStamp NowLoRes() { return Now(false); }
+# 482 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+  static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp ProcessCreation(bool& aIsInconsistent);
+
+
+
+
+
+
+  static __attribute__((weak)) __attribute__((visibility("default"))) void RecordProcessRestart();
+
+
+
+
+  TimeDuration operator-(const TimeStamp& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+    static_assert(-(9223372036854775807L) > (-9223372036854775807L -1), "int64_t sanity check");
+    int64_t ticks = int64_t(mValue - aOther.mValue);
+
+    if (mValue > aOther.mValue) {
+      if (ticks < 0) {
+        ticks = (9223372036854775807L);
+      }
+    } else {
+      if (ticks > 0) {
+        ticks = (-9223372036854775807L -1);
+      }
+    }
+    return TimeDuration::FromTicks(ticks);
+  }
+
+  TimeStamp operator+(const TimeDuration& aOther) const
+  {
+    TimeStamp result = *this;
+    result += aOther;
+    return result;
+  }
+  TimeStamp operator-(const TimeDuration& aOther) const
+  {
+    TimeStamp result = *this;
+    result -= aOther;
+    return result;
+  }
+  TimeStamp& operator+=(const TimeDuration& aOther)
+  {
+    do { } while (0);
+    TimeStampValue value = mValue + aOther.mValue;
+
+
+
+    if (aOther.mValue < 0 && value > mValue) {
+      value = 0;
+    }
+    mValue = value;
+    return *this;
+  }
+  TimeStamp& operator-=(const TimeDuration& aOther)
+  {
+    do { } while (0);
+    TimeStampValue value = mValue - aOther.mValue;
+
+
+
+    if (aOther.mValue > 0 && value > mValue) {
+      value = 0;
+    }
+    mValue = value;
+    return *this;
+  }
+
+  bool operator<(const TimeStamp& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mValue < aOther.mValue;
+  }
+  bool operator<=(const TimeStamp& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mValue <= aOther.mValue;
+  }
+  bool operator>=(const TimeStamp& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mValue >= aOther.mValue;
+  }
+  bool operator>(const TimeStamp& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mValue > aOther.mValue;
+  }
+  bool operator==(const TimeStamp& aOther) const
+  {
+    return IsNull()
+           ? aOther.IsNull()
+           : !aOther.IsNull() && mValue == aOther.mValue;
+  }
+  bool operator!=(const TimeStamp& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+
+
+
+
+  static __attribute__((weak)) __attribute__((visibility("default"))) void Startup();
+  static __attribute__((weak)) __attribute__((visibility("default"))) void Shutdown();
+
+private:
+  friend struct IPC::ParamTraits<mozilla::TimeStamp>;
+  friend void StartupTimelineRecordExternal(int, uint64_t);
+
+               TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
+
+  static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp Now(bool aHighResolution);
+# 610 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+  static __attribute__((weak)) __attribute__((visibility("default"))) uint64_t ComputeProcessUptime();
+# 625 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
+  TimeStampValue mValue;
+};
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2
+
+namespace mozilla {
+# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h"
+class MallocAllocPolicy
+{
+public:
+  template <typename T>
+  T* maybe_pod_malloc(size_t aNumElems)
+  {
+    if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+      return nullptr;
+    }
+    return static_cast<T*>(malloc(aNumElems * sizeof(T)));
+  }
+
+  template <typename T>
+  T* maybe_pod_calloc(size_t aNumElems)
+  {
+    return static_cast<T*>(calloc(aNumElems, sizeof(T)));
+  }
+
+  template <typename T>
+  T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
+  {
+    if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
+      return nullptr;
+    }
+    return static_cast<T*>(realloc(aPtr, aNewSize * sizeof(T)));
+  }
+
+  template <typename T>
+  T* pod_malloc(size_t aNumElems)
+  {
+    return maybe_pod_malloc<T>(aNumElems);
+  }
+
+  template <typename T>
+  T* pod_calloc(size_t aNumElems)
+  {
+    return maybe_pod_calloc<T>(aNumElems);
+  }
+
+  template <typename T>
+  T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
+  {
+    return maybe_pod_realloc<T>(aPtr, aOldSize, aNewSize);
+  }
+
+  void free_(void* aPtr)
+  {
+    free(aPtr);
+  }
+
+  void reportAllocOverflow() const
+  {
+  }
+
+  __attribute__ ((warn_unused_result)) bool checkSimulatedOOM() const
+  {
+    return true;
+  }
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h"
+namespace mozilla {
+
+
+class ReentrancyGuard
+{
+
+
+
+
+
+public:
+  template<class T>
+
+
+
+
+
+  explicit ReentrancyGuard(T&
+                                                          )
+
+  {
+    do { } while (0);
+
+
+
+
+  }
+  ~ReentrancyGuard()
+  {
+
+
+
+  }
+
+private:
+  ReentrancyGuard(const ReentrancyGuard&) = delete;
+  void operator=(const ReentrancyGuard&) = delete;
+};
+
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+namespace mozilla {
+
+template<typename T, size_t N, class AllocPolicy>
+class Vector;
+
+namespace detail {
+
+
+
+
+
+
+template<typename T>
+static bool CapacityHasExcessSpace(size_t aCapacity)
+{
+  size_t size = aCapacity * sizeof(T);
+  return RoundUpPow2(size) - size >= sizeof(T);
+}
+
+
+
+
+
+template<typename T, size_t N, class AP, bool IsPod>
+struct VectorImpl
+{
+
+
+
+  template<typename... Args>
+  __attribute__ ((nonnull(1)))
+  static inline void new_(T* aDst, Args&&... aArgs)
+  {
+    new(KnownNotNull, aDst) T(Forward<Args>(aArgs)...);
+  }
+
+
+  static inline void destroy(T* aBegin, T* aEnd)
+  {
+    do { } while (0);
+    for (T* p = aBegin; p < aEnd; ++p) {
+      p->~T();
+    }
+  }
+
+
+  static inline void initialize(T* aBegin, T* aEnd)
+  {
+    do { } while (0);
+    for (T* p = aBegin; p < aEnd; ++p) {
+      new_(p);
+    }
+  }
+
+
+
+
+
+  template<typename U>
+  static inline void copyConstruct(T* aDst,
+                                   const U* aSrcStart, const U* aSrcEnd)
+  {
+    do { } while (0);
+    for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
+      new_(aDst, *p);
+    }
+  }
+
+
+
+
+
+  template<typename U>
+  static inline void moveConstruct(T* aDst, U* aSrcStart, U* aSrcEnd)
+  {
+    do { } while (0);
+    for (U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
+      new_(aDst, Move(*p));
+    }
+  }
+
+
+
+
+
+  template<typename U>
+  static inline void copyConstructN(T* aDst, size_t aN, const U& aU)
+  {
+    for (T* end = aDst + aN; aDst < end; ++aDst) {
+      new_(aDst, aU);
+    }
+  }
+
+
+
+
+
+
+
+  static inline __attribute__ ((warn_unused_result)) bool
+  growTo(Vector<T, N, AP>& aV, size_t aNewCap)
+  {
+    do { } while (0);
+    do { } while (0);
+    T* newbuf = aV.template pod_malloc<T>(aNewCap);
+    if ((__builtin_expect(!!(!newbuf), 0))) {
+      return false;
+    }
+    T* dst = newbuf;
+    T* src = aV.beginNoCheck();
+    for (; src < aV.endNoCheck(); ++dst, ++src) {
+      new_(dst, Move(*src));
+    }
+    VectorImpl::destroy(aV.beginNoCheck(), aV.endNoCheck());
+    aV.free_(aV.mBegin);
+    aV.mBegin = newbuf;
+
+    aV.mTail.mCapacity = aNewCap;
+    return true;
+  }
+};
+
+
+
+
+
+
+template<typename T, size_t N, class AP>
+struct VectorImpl<T, N, AP, true>
+{
+  template<typename... Args>
+  __attribute__ ((nonnull(1)))
+  static inline void new_(T* aDst, Args&&... aArgs)
+  {
+
+
+
+
+    T temp(Forward<Args>(aArgs)...);
+    *aDst = temp;
+  }
+
+  static inline void destroy(T*, T*) {}
+
+  static inline void initialize(T* aBegin, T* aEnd)
+  {
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+    do { } while (0);
+    for (T* p = aBegin; p < aEnd; ++p) {
+      new_(p);
+    }
+  }
+
+  template<typename U>
+  static inline void copyConstruct(T* aDst,
+                                   const U* aSrcStart, const U* aSrcEnd)
+  {
+
+
+
+
+
+
+
+    do { } while (0);
+    for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
+      new_(aDst, *p);
+    }
+  }
+
+  template<typename U>
+  static inline void moveConstruct(T* aDst,
+                                   const U* aSrcStart, const U* aSrcEnd)
+  {
+    copyConstruct(aDst, aSrcStart, aSrcEnd);
+  }
+
+  static inline void copyConstructN(T* aDst, size_t aN, const T& aT)
+  {
+    for (T* end = aDst + aN; aDst < end; ++aDst) {
+      new_(aDst, aT);
+    }
+  }
+
+  static inline __attribute__ ((warn_unused_result)) bool
+  growTo(Vector<T, N, AP>& aV, size_t aNewCap)
+  {
+    do { } while (0);
+    do { } while (0);
+    T* newbuf =
+      aV.template pod_realloc<T>(aV.mBegin, aV.mTail.mCapacity, aNewCap);
+    if ((__builtin_expect(!!(!newbuf), 0))) {
+      return false;
+    }
+    aV.mBegin = newbuf;
+
+    aV.mTail.mCapacity = aNewCap;
+    return true;
+  }
+
+  static inline void
+  podResizeToFit(Vector<T, N, AP>& aV)
+  {
+    if (aV.usingInlineStorage() || aV.mLength == aV.mTail.mCapacity) {
+      return;
+    }
+    T* newbuf =
+      aV.template pod_realloc<T>(aV.mBegin, aV.mTail.mCapacity, aV.mLength);
+    if ((__builtin_expect(!!(!newbuf), 0))) {
+      return;
+    }
+    aV.mBegin = newbuf;
+    aV.mTail.mCapacity = aV.mLength;
+  }
+};
+
+
+
+struct VectorTesting;
+
+}
+# 280 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+template<typename T,
+         size_t MinInlineCapacity = 0,
+         class AllocPolicy = MallocAllocPolicy>
+class Vector final : private AllocPolicy
+{
+
+
+  static const bool kElemIsPod = IsPod<T>::value;
+  typedef detail::VectorImpl<T, MinInlineCapacity, AllocPolicy, kElemIsPod> Impl;
+  friend struct detail::VectorImpl<T, MinInlineCapacity, AllocPolicy, kElemIsPod>;
+
+  friend struct detail::VectorTesting;
+
+  __attribute__ ((warn_unused_result)) bool growStorageBy(size_t aIncr);
+  __attribute__ ((warn_unused_result)) bool convertToHeapStorage(size_t aNewCap);
+  __attribute__ ((warn_unused_result)) bool maybeCheckSimulatedOOM(size_t aRequestedSize);
+# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  static constexpr size_t kMaxInlineBytes =
+    1024 - (sizeof(AllocPolicy) + sizeof(T*) + sizeof(size_t) + sizeof(size_t));
+# 317 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  template<size_t MinimumInlineCapacity, size_t Dummy>
+  struct ComputeCapacity
+  {
+    static constexpr size_t value =
+      tl::Min<MinimumInlineCapacity, kMaxInlineBytes / sizeof(T)>::value;
+  };
+
+  template<size_t Dummy>
+  struct ComputeCapacity<0, Dummy>
+  {
+    static constexpr size_t value = 0;
+  };
+
+
+  static constexpr size_t kInlineCapacity =
+    ComputeCapacity<MinInlineCapacity, 0>::value;
+# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  T* mBegin;
+
+
+  size_t mLength;
+# 367 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  struct CapacityAndReserved
+  {
+    explicit CapacityAndReserved(size_t aCapacity, size_t aReserved)
+      : mCapacity(aCapacity)
+
+
+
+    {}
+    CapacityAndReserved() = default;
+
+
+    size_t mCapacity;
+
+
+
+
+
+  };
+# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  template<size_t Capacity, size_t Dummy>
+  struct CRAndStorage : CapacityAndReserved
+  {
+    explicit CRAndStorage(size_t aCapacity, size_t aReserved)
+      : CapacityAndReserved(aCapacity, aReserved)
+    {}
+    CRAndStorage() = default;
+
+    alignas(T) unsigned char mBytes[Capacity * sizeof(T)];
+
+
+
+    void* data() { return mBytes; }
+
+    T* storage() { return static_cast<T*>(data()); }
+  };
+
+  template<size_t Dummy>
+  struct CRAndStorage<0, Dummy> : CapacityAndReserved
+  {
+    explicit CRAndStorage(size_t aCapacity, size_t aReserved)
+      : CapacityAndReserved(aCapacity, aReserved)
+    {}
+    CRAndStorage() = default;
+
+    T* storage() { return nullptr; }
+  };
+
+  CRAndStorage<kInlineCapacity, 0> mTail;
+# 434 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  bool usingInlineStorage() const
+  {
+    return mBegin == const_cast<Vector*>(this)->inlineStorage();
+  }
+
+  T* inlineStorage()
+  {
+    return mTail.storage();
+  }
+
+  T* beginNoCheck() const
+  {
+    return mBegin;
+  }
+
+  T* endNoCheck()
+  {
+    return mBegin + mLength;
+  }
+
+  const T* endNoCheck() const
+  {
+    return mBegin + mLength;
+  }
+# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  template<typename U> void internalAppend(U&& aU);
+  template<typename U, size_t O, class BP>
+  void internalAppendAll(const Vector<U, O, BP>& aU);
+  void internalAppendN(const T& aT, size_t aN);
+  template<typename U> void internalAppend(const U* aBegin, size_t aLength);
+
+public:
+  static const size_t sMaxInlineStorage = MinInlineCapacity;
+
+  typedef T ElementType;
+
+  explicit Vector(AllocPolicy = AllocPolicy());
+  Vector(Vector&&);
+  Vector& operator=(Vector&&);
+  ~Vector();
+
+
+
+  const AllocPolicy& allocPolicy() const { return *this; }
+
+  AllocPolicy& allocPolicy() { return *this; }
+
+  enum { InlineLength = MinInlineCapacity };
+
+  size_t length() const { return mLength; }
+
+  bool empty() const { return mLength == 0; }
+
+  size_t capacity() const { return mTail.mCapacity; }
+
+  T* begin()
+  {
+    do { } while (0);
+    return mBegin;
+  }
+
+  const T* begin() const
+  {
+    do { } while (0);
+    return mBegin;
+  }
+
+  T* end()
+  {
+    do { } while (0);
+    return mBegin + mLength;
+  }
+
+  const T* end() const
+  {
+    do { } while (0);
+    return mBegin + mLength;
+  }
+
+  T& operator[](size_t aIndex)
+  {
+    do { } while (0);
+    do { } while (0);
+    return begin()[aIndex];
+  }
+
+  const T& operator[](size_t aIndex) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return begin()[aIndex];
+  }
+
+  T& back()
+  {
+    do { } while (0);
+    do { } while (0);
+    return *(end() - 1);
+  }
+
+  const T& back() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return *(end() - 1);
+  }
+
+  class Range
+  {
+    friend class Vector;
+    T* mCur;
+    T* mEnd;
+    Range(T* aCur, T* aEnd)
+      : mCur(aCur)
+      , mEnd(aEnd)
+    {
+      do { } while (0);
+    }
+
+  public:
+    bool empty() const { return mCur == mEnd; }
+    size_t remain() const { return PointerRangeSize(mCur, mEnd); }
+    T& front() const { do { } while (0); return *mCur; }
+    void popFront() { do { } while (0); ++mCur; }
+    T popCopyFront() { do { } while (0); return *mCur++; }
+  };
+
+  class ConstRange
+  {
+    friend class Vector;
+    const T* mCur;
+    const T* mEnd;
+    ConstRange(const T* aCur, const T* aEnd)
+      : mCur(aCur)
+      , mEnd(aEnd)
+    {
+      do { } while (0);
+    }
+
+  public:
+    bool empty() const { return mCur == mEnd; }
+    size_t remain() const { return PointerRangeSize(mCur, mEnd); }
+    const T& front() const { do { } while (0); return *mCur; }
+    void popFront() { do { } while (0); ++mCur; }
+    T popCopyFront() { do { } while (0); return *mCur++; }
+  };
+
+  Range all() { return Range(begin(), end()); }
+  ConstRange all() const { return ConstRange(begin(), end()); }
+
+
+
+
+
+
+  void reverse();
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool initCapacity(size_t aRequest);
+# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  __attribute__ ((warn_unused_result)) bool initLengthUninitialized(size_t aRequest);
+# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  __attribute__ ((warn_unused_result)) bool reserve(size_t aRequest);
+
+
+
+
+
+  void shrinkBy(size_t aIncr);
+
+
+
+
+
+  void shrinkTo(size_t aNewLength);
+
+
+  __attribute__ ((warn_unused_result)) bool growBy(size_t aIncr);
+
+
+  __attribute__ ((warn_unused_result)) bool resize(size_t aNewLength);
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool growByUninitialized(size_t aIncr);
+  void infallibleGrowByUninitialized(size_t aIncr);
+  __attribute__ ((warn_unused_result)) bool resizeUninitialized(size_t aNewLength);
+
+
+  void clear();
+
+
+  void clearAndFree();
+
+
+
+
+
+
+  void podResizeToFit();
+
+
+
+
+
+
+
+  bool canAppendWithoutRealloc(size_t aNeeded) const;
+# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  template<typename U> __attribute__ ((warn_unused_result)) bool append(U&& aU);
+
+
+
+
+  template<typename... Args>
+  __attribute__ ((warn_unused_result)) bool emplaceBack(Args&&... aArgs)
+  {
+    if (!growByUninitialized(1))
+      return false;
+    Impl::new_(&back(), Forward<Args>(aArgs)...);
+    return true;
+  }
+
+  template<typename U, size_t O, class BP>
+  __attribute__ ((warn_unused_result)) bool appendAll(const Vector<U, O, BP>& aU);
+  __attribute__ ((warn_unused_result)) bool appendN(const T& aT, size_t aN);
+  template<typename U> __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd);
+  template<typename U> __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength);
+
+
+
+
+
+
+  template<typename U> void infallibleAppend(U&& aU)
+  {
+    internalAppend(Forward<U>(aU));
+  }
+  void infallibleAppendN(const T& aT, size_t aN)
+  {
+    internalAppendN(aT, aN);
+  }
+  template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd)
+  {
+    internalAppend(aBegin, PointerRangeSize(aBegin, aEnd));
+  }
+  template<typename U> void infallibleAppend(const U* aBegin, size_t aLength)
+  {
+    internalAppend(aBegin, aLength);
+  }
+  template<typename... Args>
+  void infallibleEmplaceBack(Args&&... aArgs)
+  {
+    infallibleGrowByUninitialized(1);
+    Impl::new_(&back(), Forward<Args>(aArgs)...);
+  }
+
+  void popBack();
+
+  T popCopy();
+# 749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  __attribute__ ((warn_unused_result)) T* extractRawBuffer();
+# 767 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  __attribute__ ((warn_unused_result)) T* extractOrCopyRawBuffer();
+# 777 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  void replaceRawBuffer(T* aP, size_t aLength);
+# 794 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  template<typename U>
+  __attribute__ ((warn_unused_result)) T* insert(T* aP, U&& aVal);
+
+
+
+
+
+  void erase(T* aT);
+
+
+
+
+
+
+  void erase(T* aBegin, T* aEnd);
+
+
+
+
+  size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
+
+
+
+
+
+  size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+
+  void swap(Vector& aOther);
+
+private:
+  Vector(const Vector&) = delete;
+  void operator=(const Vector&) = delete;
+};
+# 838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline
+Vector<T, N, AP>::Vector(AP aAP)
+  : AP(aAP)
+  , mLength(0)
+  , mTail(kInlineCapacity, 0)
+
+
+
+{
+  mBegin = inlineStorage();
+}
+
+
+template<typename T, size_t N, class AllocPolicy>
+__attribute__((always_inline)) inline
+Vector<T, N, AllocPolicy>::Vector(Vector&& aRhs)
+  : AllocPolicy(Move(aRhs))
+
+
+
+{
+  mLength = aRhs.mLength;
+  mTail.mCapacity = aRhs.mTail.mCapacity;
+
+
+
+
+  if (aRhs.usingInlineStorage()) {
+
+    mBegin = inlineStorage();
+    Impl::moveConstruct(mBegin, aRhs.beginNoCheck(), aRhs.endNoCheck());
+
+
+
+
+  } else {
+
+
+
+
+    mBegin = aRhs.mBegin;
+    aRhs.mBegin = aRhs.inlineStorage();
+    aRhs.mTail.mCapacity = kInlineCapacity;
+    aRhs.mLength = 0;
+
+
+
+  }
+}
+
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline Vector<T, N, AP>&
+Vector<T, N, AP>::operator=(Vector&& aRhs)
+{
+  do { } while (0);
+  this->~Vector();
+  new(KnownNotNull, this) Vector(Move(aRhs));
+  return *this;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline
+Vector<T, N, AP>::~Vector()
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  Impl::destroy(beginNoCheck(), endNoCheck());
+  if (!usingInlineStorage()) {
+    this->free_(beginNoCheck());
+  }
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::reverse() {
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  T* elems = mBegin;
+  size_t len = mLength;
+  size_t mid = len / 2;
+  for (size_t i = 0; i < mid; i++) {
+    Swap(elems[i], elems[len - i - 1]);
+  }
+}
+
+
+
+
+
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::convertToHeapStorage(size_t aNewCap)
+{
+  do { } while (0);
+
+
+  do { } while (0);
+  T* newBuf = this->template pod_malloc<T>(aNewCap);
+  if ((__builtin_expect(!!(!newBuf), 0))) {
+    return false;
+  }
+
+
+  Impl::moveConstruct(newBuf, beginNoCheck(), endNoCheck());
+  Impl::destroy(beginNoCheck(), endNoCheck());
+
+
+  mBegin = newBuf;
+
+  mTail.mCapacity = aNewCap;
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((noinline)) bool
+Vector<T, N, AP>::growStorageBy(size_t aIncr)
+{
+  do { } while (0);
+# 966 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+  size_t newCap;
+
+  if (aIncr == 1) {
+    if (usingInlineStorage()) {
+
+      size_t newSize =
+        tl::RoundUpPow2<(kInlineCapacity + 1) * sizeof(T)>::value;
+      newCap = newSize / sizeof(T);
+      goto convert;
+    }
+
+    if (mLength == 0) {
+
+      newCap = 1;
+      goto grow;
+    }
+# 994 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
+    if ((__builtin_expect(!!(mLength & tl::MulOverflowMask<4 * sizeof(T)>::value), 0))) {
+      this->reportAllocOverflow();
+      return false;
+    }
+
+
+
+
+
+
+    newCap = mLength * 2;
+    if (detail::CapacityHasExcessSpace<T>(newCap)) {
+      newCap += 1;
+    }
+  } else {
+
+    size_t newMinCap = mLength + aIncr;
+
+
+    if ((__builtin_expect(!!(newMinCap < mLength || newMinCap & tl::MulOverflowMask<2 * sizeof(T)>::value), 0)))
+
+    {
+      this->reportAllocOverflow();
+      return false;
+    }
+
+    size_t newMinSize = newMinCap * sizeof(T);
+    size_t newSize = RoundUpPow2(newMinSize);
+    newCap = newSize / sizeof(T);
+  }
+
+  if (usingInlineStorage()) {
+convert:
+    return convertToHeapStorage(newCap);
+  }
+
+grow:
+  return Impl::growTo(*this, newCap);
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::initCapacity(size_t aRequest)
+{
+  do { } while (0);
+  do { } while (0);
+  if (aRequest == 0) {
+    return true;
+  }
+  T* newbuf = this->template pod_malloc<T>(aRequest);
+  if ((__builtin_expect(!!(!newbuf), 0))) {
+    return false;
+  }
+  mBegin = newbuf;
+  mTail.mCapacity = aRequest;
+
+
+
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::initLengthUninitialized(size_t aRequest)
+{
+  if (!initCapacity(aRequest)) {
+    return false;
+  }
+  infallibleGrowByUninitialized(aRequest);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::maybeCheckSimulatedOOM(size_t aRequestedSize)
+{
+  if (aRequestedSize <= N) {
+    return true;
+  }
+
+
+
+
+
+
+
+  return allocPolicy().checkSimulatedOOM();
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::reserve(size_t aRequest)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  if (aRequest > mTail.mCapacity) {
+    if ((__builtin_expect(!!(!growStorageBy(aRequest - mLength)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(aRequest)) {
+    return false;
+  }
+
+
+
+
+
+
+
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::shrinkBy(size_t aIncr)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  do { } while (0);
+  Impl::destroy(endNoCheck() - aIncr, endNoCheck());
+  mLength -= aIncr;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::shrinkTo(size_t aNewLength)
+{
+  do { } while (0);
+  shrinkBy(mLength - aNewLength);
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::growBy(size_t aIncr)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  if (aIncr > mTail.mCapacity - mLength) {
+    if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) {
+    return false;
+  }
+  do { } while (0);
+  T* newend = endNoCheck() + aIncr;
+  Impl::initialize(endNoCheck(), newend);
+  mLength += aIncr;
+
+
+
+
+
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::growByUninitialized(size_t aIncr)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  if (aIncr > mTail.mCapacity - mLength) {
+    if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) {
+    return false;
+  }
+
+
+
+
+
+  infallibleGrowByUninitialized(aIncr);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::infallibleGrowByUninitialized(size_t aIncr)
+{
+  do { } while (0);
+  mLength += aIncr;
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::resize(size_t aNewLength)
+{
+  size_t curLength = mLength;
+  if (aNewLength > curLength) {
+    return growBy(aNewLength - curLength);
+  }
+  shrinkBy(curLength - aNewLength);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::resizeUninitialized(size_t aNewLength)
+{
+  size_t curLength = mLength;
+  if (aNewLength > curLength) {
+    return growByUninitialized(aNewLength - curLength);
+  }
+  shrinkBy(curLength - aNewLength);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::clear()
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  Impl::destroy(beginNoCheck(), endNoCheck());
+  mLength = 0;
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::clearAndFree()
+{
+  clear();
+
+  if (usingInlineStorage()) {
+    return;
+  }
+  this->free_(beginNoCheck());
+  mBegin = inlineStorage();
+  mTail.mCapacity = kInlineCapacity;
+
+
+
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::podResizeToFit()
+{
+
+
+  Impl::podResizeToFit(*this);
+}
+
+template<typename T, size_t N, class AP>
+inline bool
+Vector<T, N, AP>::canAppendWithoutRealloc(size_t aNeeded) const
+{
+  return mLength + aNeeded <= mTail.mCapacity;
+}
+
+template<typename T, size_t N, class AP>
+template<typename U, size_t O, class BP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::internalAppendAll(const Vector<U, O, BP>& aOther)
+{
+  internalAppend(aOther.begin(), aOther.length());
+}
+
+template<typename T, size_t N, class AP>
+template<typename U>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::internalAppend(U&& aU)
+{
+  do { } while (0);
+  do { } while (0);
+  Impl::new_(endNoCheck(), Forward<U>(aU));
+  ++mLength;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::appendN(const T& aT, size_t aNeeded)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  if (mLength + aNeeded > mTail.mCapacity) {
+    if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) {
+    return false;
+  }
+
+
+
+
+
+  internalAppendN(aT, aNeeded);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::internalAppendN(const T& aT, size_t aNeeded)
+{
+  do { } while (0);
+  do { } while (0);
+  Impl::copyConstructN(endNoCheck(), aNeeded, aT);
+  mLength += aNeeded;
+}
+
+template<typename T, size_t N, class AP>
+template<typename U>
+inline T*
+Vector<T, N, AP>::insert(T* aP, U&& aVal)
+{
+  do { } while (0);
+  do { } while (0);
+  size_t pos = aP - begin();
+  do { } while (0);
+  size_t oldLength = mLength;
+  if (pos == oldLength) {
+    if (!append(Forward<U>(aVal))) {
+      return nullptr;
+    }
+  } else {
+    T oldBack = Move(back());
+    if (!append(Move(oldBack))) {
+      return nullptr;
+    }
+    for (size_t i = oldLength - 1; i > pos; --i) {
+      (*this)[i] = Move((*this)[i - 1]);
+    }
+    (*this)[pos] = Forward<U>(aVal);
+  }
+  return begin() + pos;
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::erase(T* aIt)
+{
+  do { } while (0);
+  do { } while (0);
+  while (aIt + 1 < end()) {
+    *aIt = Move(*(aIt + 1));
+    ++aIt;
+  }
+  popBack();
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::erase(T* aBegin, T* aEnd)
+{
+  do { } while (0);
+  do { } while (0);
+  do { } while (0);
+  while (aEnd < end()) {
+    *aBegin++ = Move(*aEnd++);
+  }
+  shrinkBy(aEnd - aBegin);
+}
+
+template<typename T, size_t N, class AP>
+template<typename U>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::append(const U* aInsBegin, const U* aInsEnd)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  size_t aNeeded = PointerRangeSize(aInsBegin, aInsEnd);
+  if (mLength + aNeeded > mTail.mCapacity) {
+    if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) {
+      return false;
+  }
+
+
+
+
+
+  internalAppend(aInsBegin, aNeeded);
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+template<typename U>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::internalAppend(const U* aInsBegin, size_t aInsLength)
+{
+  do { } while (0);
+  do { } while (0);
+  Impl::copyConstruct(endNoCheck(), aInsBegin, aInsBegin + aInsLength);
+  mLength += aInsLength;
+}
+
+template<typename T, size_t N, class AP>
+template<typename U>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::append(U&& aU)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  if (mLength == mTail.mCapacity) {
+    if ((__builtin_expect(!!(!growStorageBy(1)), 0))) {
+      return false;
+    }
+  } else if (!maybeCheckSimulatedOOM(mLength + 1)) {
+      return false;
+  }
+
+
+
+
+
+  internalAppend(Forward<U>(aU));
+  return true;
+}
+
+template<typename T, size_t N, class AP>
+template<typename U, size_t O, class BP>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::appendAll(const Vector<U, O, BP>& aOther)
+{
+  return append(aOther.begin(), aOther.length());
+}
+
+template<typename T, size_t N, class AP>
+template<class U>
+__attribute__((always_inline)) inline bool
+Vector<T, N, AP>::append(const U* aInsBegin, size_t aInsLength)
+{
+  return append(aInsBegin, aInsBegin + aInsLength);
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline void
+Vector<T, N, AP>::popBack()
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+  do { } while (0);
+  --mLength;
+  endNoCheck()->~T();
+}
+
+template<typename T, size_t N, class AP>
+__attribute__((always_inline)) inline T
+Vector<T, N, AP>::popCopy()
+{
+  T ret = back();
+  popBack();
+  return ret;
+}
+
+template<typename T, size_t N, class AP>
+inline T*
+Vector<T, N, AP>::extractRawBuffer()
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+
+  if (usingInlineStorage()) {
+    return nullptr;
+  }
+
+  T* ret = mBegin;
+  mBegin = inlineStorage();
+  mLength = 0;
+  mTail.mCapacity = kInlineCapacity;
+
+
+
+  return ret;
+}
+
+template<typename T, size_t N, class AP>
+inline T*
+Vector<T, N, AP>::extractOrCopyRawBuffer()
+{
+  if (T* ret = extractRawBuffer()) {
+    return ret;
+  }
+
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+
+  T* copy = this->template pod_malloc<T>(mLength);
+  if (!copy) {
+    return nullptr;
+  }
+
+  Impl::moveConstruct(copy, beginNoCheck(), endNoCheck());
+  Impl::destroy(beginNoCheck(), endNoCheck());
+  mBegin = inlineStorage();
+  mLength = 0;
+  mTail.mCapacity = kInlineCapacity;
+
+
+
+  return copy;
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::replaceRawBuffer(T* aP, size_t aLength)
+{
+  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
+
+
+  Impl::destroy(beginNoCheck(), endNoCheck());
+  if (!usingInlineStorage()) {
+    this->free_(beginNoCheck());
+  }
+
+
+  if (aLength <= kInlineCapacity) {
+
+
+
+
+
+    mBegin = inlineStorage();
+    mLength = aLength;
+    mTail.mCapacity = kInlineCapacity;
+    Impl::moveConstruct(mBegin, aP, aP + aLength);
+    Impl::destroy(aP, aP + aLength);
+    this->free_(aP);
+  } else {
+    mBegin = aP;
+    mLength = aLength;
+    mTail.mCapacity = aLength;
+  }
+
+
+
+}
+
+template<typename T, size_t N, class AP>
+inline size_t
+Vector<T, N, AP>::sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+{
+  return usingInlineStorage() ? 0 : aMallocSizeOf(beginNoCheck());
+}
+
+template<typename T, size_t N, class AP>
+inline size_t
+Vector<T, N, AP>::sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+  return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf);
+}
+
+template<typename T, size_t N, class AP>
+inline void
+Vector<T, N, AP>::swap(Vector& aOther)
+{
+  static_assert(N == 0,
+                "still need to implement this for N != 0");
+
+
+  if (!usingInlineStorage() && aOther.usingInlineStorage()) {
+    aOther.mBegin = mBegin;
+    mBegin = inlineStorage();
+  } else if (usingInlineStorage() && !aOther.usingInlineStorage()) {
+    mBegin = aOther.mBegin;
+    aOther.mBegin = aOther.inlineStorage();
+  } else if (!usingInlineStorage() && !aOther.usingInlineStorage()) {
+    Swap(mBegin, aOther.mBegin);
+  } else {
+
+  }
+
+  Swap(mLength, aOther.mLength);
+  Swap(mTail.mCapacity, aOther.mTail.mCapacity);
+
+
+
+}
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h"
+namespace js {
+
+
+template <typename T, typename D = JS::DeletePolicy<T>>
+using UniquePtr = mozilla::UniquePtr<T, D>;
+
+namespace detail {
+
+template<typename T>
+struct UniqueSelector
+{
+  typedef UniquePtr<T> SingleObject;
+};
+
+template<typename T>
+struct UniqueSelector<T[]>
+{
+  typedef UniquePtr<T[]> UnknownBound;
+};
+
+template<typename T, decltype(sizeof(int)) N>
+struct UniqueSelector<T[N]>
+{
+  typedef UniquePtr<T[N]> KnownBound;
+};
+
+}
+
+
+
+template<typename T, typename... Args>
+typename detail::UniqueSelector<T>::SingleObject
+MakeUnique(Args&&... aArgs)
+{
+  return UniquePtr<T>(js_new<T>(mozilla::Forward<Args>(aArgs)...));
+}
+
+template<typename T>
+typename detail::UniqueSelector<T>::UnknownBound
+MakeUnique(decltype(sizeof(int)) aN) = delete;
+
+template<typename T, typename... Args>
+typename detail::UniqueSelector<T>::KnownBound
+MakeUnique(Args&&... aArgs) = delete;
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
+
+namespace js {
+namespace gc {
+class GCRuntime;
+}
+namespace gcstats {
+struct Statistics;
+}
+}
+
+typedef enum JSGCMode {
+
+    JSGC_MODE_GLOBAL = 0,
+
+
+    JSGC_MODE_ZONE = 1,
+
+
+
+
+
+    JSGC_MODE_INCREMENTAL = 2
+} JSGCMode;
+
+
+
+
+typedef enum JSGCInvocationKind {
+
+    GC_NORMAL = 0,
+
+
+    GC_SHRINK = 1
+} JSGCInvocationKind;
+
+namespace JS {
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+namespace gcreason {
+
+
+enum Reason {
+
+    API, EAGER_ALLOC_TRIGGER, DESTROY_RUNTIME, UNUSED0, LAST_DITCH, TOO_MUCH_MALLOC, ALLOC_TRIGGER, DEBUG_GC, COMPARTMENT_REVIVED, RESET, OUT_OF_NURSERY, EVICT_NURSERY, FULL_STORE_BUFFER, SHARED_MEMORY_LIMIT, UNUSED1, INCREMENTAL_TOO_SLOW, ABORT_GC, RESERVED0, RESERVED1, RESERVED2, RESERVED3, RESERVED4, RESERVED5, RESERVED6, RESERVED7, RESERVED8, RESERVED9, RESERVED10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15, DOM_WINDOW_UTILS, COMPONENT_UTILS, MEM_PRESSURE, CC_WAITING, CC_FORCED, LOAD_END, POST_COMPARTMENT, PAGE_HIDE, NSJSCONTEXT_DESTROY, SET_NEW_DOCUMENT, SET_DOC_SHELL, DOM_UTILS, DOM_IPC, DOM_WORKER, INTER_SLICE_GC, REFRESH_FRAME, FULL_GC_TIMER, SHUTDOWN_CC, FINISH_LARGE_EVALUATE, USER_INACTIVE, XPCONNECT_SHUTDOWN,
+
+    NO_REASON,
+    NUM_REASONS,
+
+
+
+
+
+
+
+    NUM_TELEMETRY_REASONS = 100
+};
+
+
+
+
+extern const char*
+ExplainReason(JS::gcreason::Reason reason);
+
+}
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+extern void
+PrepareZoneForGC(Zone* zone);
+
+
+
+
+extern void
+PrepareForFullGC(JSContext* cx);
+
+
+
+
+
+
+extern void
+PrepareForIncrementalGC(JSContext* cx);
+
+
+
+
+
+extern bool
+IsGCScheduled(JSContext* cx);
+
+
+
+
+
+extern void
+SkipZoneForGC(Zone* zone);
+# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+extern void
+GCForReason(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason);
+# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+extern void
+StartIncrementalGC(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason,
+                   int64_t millis = 0);
+# 248 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+extern void
+IncrementalGCSlice(JSContext* cx, gcreason::Reason reason, int64_t millis = 0);
+
+
+
+
+
+
+
+extern void
+FinishIncrementalGC(JSContext* cx, gcreason::Reason reason);
+
+
+
+
+
+
+
+extern void
+AbortIncrementalGC(JSContext* cx);
+
+namespace dbg {
+
+
+
+
+class GarbageCollectionEvent
+{
+
+    uint64_t majorGCNumber_;
+
+
+
+    const char* reason;
+
+
+
+
+    const char* nonincrementalReason;
+
+
+
+    struct Collection {
+        mozilla::TimeStamp startTimestamp;
+        mozilla::TimeStamp endTimestamp;
+    };
+
+
+    mozilla::Vector<Collection> collections;
+
+    GarbageCollectionEvent(const GarbageCollectionEvent& rhs) = delete;
+    GarbageCollectionEvent& operator=(const GarbageCollectionEvent& rhs) = delete;
+
+  public:
+    explicit GarbageCollectionEvent(uint64_t majorGCNum)
+        : majorGCNumber_(majorGCNum)
+        , reason(nullptr)
+        , nonincrementalReason(nullptr)
+        , collections()
+    { }
+
+    using Ptr = js::UniquePtr<GarbageCollectionEvent>;
+    static Ptr Create(JSRuntime* rt, ::js::gcstats::Statistics& stats, uint64_t majorGCNumber);
+
+    JSObject* toJSObject(JSContext* cx) const;
+
+    uint64_t majorGCNumber() const { return majorGCNumber_; }
+};
+
+}
+
+enum GCProgress {
+# 330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+    GC_CYCLE_BEGIN,
+    GC_SLICE_BEGIN,
+    GC_SLICE_END,
+    GC_CYCLE_END
+};
+
+struct GCDescription {
+    bool isZone_;
+    JSGCInvocationKind invocationKind_;
+    gcreason::Reason reason_;
+
+    GCDescription(bool isZone, JSGCInvocationKind kind, gcreason::Reason reason)
+      : isZone_(isZone), invocationKind_(kind), reason_(reason) {}
+
+    char16_t* formatSliceMessage(JSContext* cx) const;
+    char16_t* formatSummaryMessage(JSContext* cx) const;
+    char16_t* formatJSON(JSContext* cx, uint64_t timestamp) const;
+
+    JS::dbg::GarbageCollectionEvent::Ptr toGCEvent(JSContext* cx) const;
+};
+
+typedef void
+(* GCSliceCallback)(JSContext* cx, GCProgress progress, const GCDescription& desc);
+
+
+
+
+
+
+extern GCSliceCallback
+SetGCSliceCallback(JSContext* cx, GCSliceCallback callback);
+
+
+
+
+enum class GCNurseryProgress {
+
+
+
+    GC_NURSERY_COLLECTION_START,
+
+
+
+    GC_NURSERY_COLLECTION_END
+};
+
+
+
+
+
+using GCNurseryCollectionCallback = void(*)(JSContext* cx, GCNurseryProgress progress,
+                                            gcreason::Reason reason);
+
+
+
+
+
+extern GCNurseryCollectionCallback
+SetGCNurseryCollectionCallback(JSContext* cx, GCNurseryCollectionCallback callback);
+
+typedef void
+(* DoCycleCollectionCallback)(JSContext* cx);
+
+
+
+
+
+extern DoCycleCollectionCallback
+SetDoCycleCollectionCallback(JSContext* cx, DoCycleCollectionCallback callback);
+
+
+
+
+
+
+
+extern void
+DisableIncrementalGC(JSContext* cx);
+# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+extern bool
+IsIncrementalGCEnabled(JSContext* cx);
+
+
+
+
+
+extern bool
+IsIncrementalGCInProgress(JSContext* cx);
+
+
+
+
+
+
+
+extern bool
+IsIncrementalBarrierNeeded(JSContext* cx);
+
+
+
+
+
+extern void
+IncrementalPreWriteBarrier(JSObject* obj);
+
+
+
+
+
+extern void
+IncrementalReadBarrier(GCCellPtr thing);
+
+
+
+
+extern bool
+WasIncrementalGC(JSContext* cx);
+# 465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+class AutoDisableGenerationalGC
+{
+    JSContext* cx;
+
+  public:
+    explicit AutoDisableGenerationalGC(JSContext* cx);
+    ~AutoDisableGenerationalGC();
+};
+
+
+
+
+
+extern bool
+IsGenerationalGCEnabled(JSRuntime* rt);
+
+
+
+
+
+
+extern size_t
+GetGCNumber();
+
+
+
+
+
+
+class AutoRequireNoGC
+{
+  protected:
+    AutoRequireNoGC() {}
+    ~AutoRequireNoGC() {}
+};
+# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+class AutoAssertNoGC : public AutoRequireNoGC
+{
+    JSContext* cx_;
+
+  public:
+    explicit AutoAssertNoGC(JSContext* cx = nullptr);
+    ~AutoAssertNoGC();
+};
+
+
+
+
+
+class AutoAssertNoAlloc
+{
+
+    js::gc::GCRuntime* gc;
+
+  public:
+    AutoAssertNoAlloc() : gc(nullptr) {}
+    explicit AutoAssertNoAlloc(JSContext* cx);
+    void disallowAlloc(JSRuntime* rt);
+    ~AutoAssertNoAlloc();
+
+
+
+
+
+
+};
+
+
+
+
+
+class AutoAssertOnBarrier
+{
+    JSContext* context;
+    bool prev;
+
+  public:
+    explicit AutoAssertOnBarrier(JSContext* cx);
+    ~AutoAssertOnBarrier();
+};
+# 568 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+class AutoSuppressGCAnalysis : public AutoAssertNoAlloc
+{
+  public:
+    AutoSuppressGCAnalysis() : AutoAssertNoAlloc() {}
+    explicit AutoSuppressGCAnalysis(JSContext* cx) : AutoAssertNoAlloc(cx) {}
+} ;
+# 583 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+class AutoAssertGCCallback : public AutoSuppressGCAnalysis
+{
+  public:
+    explicit AutoAssertGCCallback(JSObject* obj);
+};
+# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
+class AutoCheckCannotGC : public AutoRequireNoGC
+{
+  public:
+    explicit AutoCheckCannotGC(JSContext* cx = nullptr) {}
+} ;
+
+
+
+
+
+
+
+extern bool
+UnmarkGrayGCThingRecursively(GCCellPtr thing);
+
+}
+
+namespace js {
+namespace gc {
+
+extern bool
+BarriersAreAllowedOnCurrentThread();
+
+static __attribute__((always_inline)) inline void
+ExposeGCThingToActiveJS(JS::GCCellPtr thing)
+{
+
+
+
+    if (IsInsideNursery(thing.asCell()))
+        return;
+
+
+
+    if (thing.mayBeOwnedByOtherRuntime())
+        return;
+
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(BarriersAreAllowedOnCurrentThread())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 645; ::abort(); } while (0); } } while (0);
+
+    if (IsIncrementalBarrierNeededOnTenuredGCThing(thing))
+        JS::IncrementalReadBarrier(thing);
+    else if (js::gc::detail::CellIsMarkedGray(thing.asCell()))
+        JS::UnmarkGrayGCThingRecursively(thing);
+
+    do { } while (0);
+}
+
+static __attribute__((always_inline)) inline void
+GCThingReadBarrier(JS::GCCellPtr thing)
+{
+
+
+    if (IsInsideNursery(thing.asCell()))
+        return;
+
+
+
+    if (thing.mayBeOwnedByOtherRuntime())
+        return;
+
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(BarriersAreAllowedOnCurrentThread())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 668; ::abort(); } while (0); } } while (0);
+
+    if (IsIncrementalBarrierNeededOnTenuredGCThing(thing))
+        JS::IncrementalReadBarrier(thing);
+}
+
+}
+}
+
+namespace JS {
+
+
+
+
+
+
+
+static __attribute__((always_inline)) inline void
+ExposeObjectToActiveJS(JSObject* obj)
+{
+    do { } while (0);
+    js::gc::ExposeGCThingToActiveJS(GCCellPtr(obj));
+}
+
+static __attribute__((always_inline)) inline void
+ExposeScriptToActiveJS(JSScript* script)
+{
+    js::gc::ExposeGCThingToActiveJS(GCCellPtr(script));
+}
+
+
+
+
+static __attribute__((always_inline)) inline void
+StringReadBarrier(JSString* string)
+{
+    do { } while (0);
+    js::gc::GCThingReadBarrier(GCCellPtr(string));
+}
+
+
+
+
+
+
+extern void
+PokeGC(JSContext* cx);
+
+
+
+
+extern void
+NotifyDidPaint(JSContext* cx);
+
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 1
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h"
+namespace js {
+
+enum class AllocFunction {
+    Malloc,
+    Calloc,
+    Realloc
+};
+
+
+class SystemAllocPolicy
+{
+  public:
+    template <typename T> T* maybe_pod_malloc(size_t numElems) { return js_pod_malloc<T>(numElems); }
+    template <typename T> T* maybe_pod_calloc(size_t numElems) { return js_pod_calloc<T>(numElems); }
+    template <typename T> T* maybe_pod_realloc(T* p, size_t oldSize, size_t newSize) {
+        return js_pod_realloc<T>(p, oldSize, newSize);
+    }
+    template <typename T> T* pod_malloc(size_t numElems) { return maybe_pod_malloc<T>(numElems); }
+    template <typename T> T* pod_calloc(size_t numElems) { return maybe_pod_calloc<T>(numElems); }
+    template <typename T> T* pod_realloc(T* p, size_t oldSize, size_t newSize) {
+        return maybe_pod_realloc<T>(p, oldSize, newSize);
+    }
+    void free_(void* p) { js_free(p); }
+    void reportAllocOverflow() const {}
+    bool checkSimulatedOOM() const {
+        return !js::oom::ShouldFailWithOOM();
+    }
+};
+
+void ReportOutOfMemory(JSContext* cx);
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h"
+class TempAllocPolicy
+{
+    JSContext* const cx_;
+
+
+
+
+
+    void* onOutOfMemory(AllocFunction allocFunc, size_t nbytes,
+                                       void* reallocPtr = nullptr);
+
+    template <typename T>
+    T* onOutOfMemoryTyped(AllocFunction allocFunc, size_t numElems, void* reallocPtr = nullptr) {
+        size_t bytes;
+        if ((__builtin_expect(!!(!CalculateAllocSize<T>(numElems, &bytes)), 0)))
+            return nullptr;
+        return static_cast<T*>(onOutOfMemory(allocFunc, bytes, reallocPtr));
+    }
+
+  public:
+                 TempAllocPolicy(JSContext* cx) : cx_(cx) {}
+
+    template <typename T>
+    T* maybe_pod_malloc(size_t numElems) {
+        return js_pod_malloc<T>(numElems);
+    }
+
+    template <typename T>
+    T* maybe_pod_calloc(size_t numElems) {
+        return js_pod_calloc<T>(numElems);
+    }
+
+    template <typename T>
+    T* maybe_pod_realloc(T* prior, size_t oldSize, size_t newSize) {
+        return js_pod_realloc<T>(prior, oldSize, newSize);
+    }
+
+    template <typename T>
+    T* pod_malloc(size_t numElems) {
+        T* p = maybe_pod_malloc<T>(numElems);
+        if ((__builtin_expect(!!(!p), 0)))
+            p = onOutOfMemoryTyped<T>(AllocFunction::Malloc, numElems);
+        return p;
+    }
+
+    template <typename T>
+    T* pod_calloc(size_t numElems) {
+        T* p = maybe_pod_calloc<T>(numElems);
+        if ((__builtin_expect(!!(!p), 0)))
+            p = onOutOfMemoryTyped<T>(AllocFunction::Calloc, numElems);
+        return p;
+    }
+
+    template <typename T>
+    T* pod_realloc(T* prior, size_t oldSize, size_t newSize) {
+        T* p2 = maybe_pod_realloc<T>(prior, oldSize, newSize);
+        if ((__builtin_expect(!!(!p2), 0)))
+            p2 = onOutOfMemoryTyped<T>(AllocFunction::Realloc, newSize, prior);
+        return p2;
+    }
+
+    void free_(void* p) {
+        js_free(p);
+    }
+
+    void reportAllocOverflow() const;
+
+    bool checkSimulatedOOM() const {
+        if (js::oom::ShouldFailWithOOM()) {
+            ReportOutOfMemory(cx_);
+            return false;
+        }
+
+        return true;
+    }
+};
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" 1
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+namespace mozilla {
+
+
+
+
+static const uint32_t kGoldenRatioU32 = 0x9E3779B9U;
+
+inline uint32_t
+RotateBitsLeft32(uint32_t aValue, uint8_t aBits)
+{
+  do { } while (0);
+  return (aValue << aBits) | (aValue >> (32 - aBits));
+}
+
+namespace detail {
+
+inline uint32_t
+AddU32ToHash(uint32_t aHash, uint32_t aValue)
+{
+# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+  return kGoldenRatioU32 * (RotateBitsLeft32(aHash, 5) ^ aValue);
+}
+
+
+
+
+template<size_t PtrSize>
+inline uint32_t
+AddUintptrToHash(uint32_t aHash, uintptr_t aValue);
+
+template<>
+inline uint32_t
+AddUintptrToHash<4>(uint32_t aHash, uintptr_t aValue)
+{
+  return AddU32ToHash(aHash, static_cast<uint32_t>(aValue));
+}
+
+template<>
+inline uint32_t
+AddUintptrToHash<8>(uint32_t aHash, uintptr_t aValue)
+{
+
+
+
+
+
+
+
+  uint32_t v1 = static_cast<uint32_t>(aValue);
+  uint32_t v2 = static_cast<uint32_t>(static_cast<uint64_t>(aValue) >> 32);
+  return AddU32ToHash(AddU32ToHash(aHash, v1), v2);
+}
+
+}
+# 159 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+template<typename A>
+__attribute__ ((warn_unused_result)) inline uint32_t
+AddToHash(uint32_t aHash, A aA)
+{
+
+
+
+
+  return detail::AddU32ToHash(aHash, aA);
+}
+
+template<typename A>
+__attribute__ ((warn_unused_result)) inline uint32_t
+AddToHash(uint32_t aHash, A* aA)
+{
+
+
+
+
+
+  static_assert(sizeof(aA) == sizeof(uintptr_t), "Strange pointer!");
+
+  return detail::AddUintptrToHash<sizeof(uintptr_t)>(aHash, uintptr_t(aA));
+}
+
+template<>
+__attribute__ ((warn_unused_result)) inline uint32_t
+AddToHash(uint32_t aHash, uintptr_t aA)
+{
+  return detail::AddUintptrToHash<sizeof(uintptr_t)>(aHash, aA);
+}
+
+template<typename A, typename... Args>
+__attribute__ ((warn_unused_result)) uint32_t
+AddToHash(uint32_t aHash, A aArg, Args... aArgs)
+{
+  return AddToHash(AddToHash(aHash, aArg), aArgs...);
+}
+# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+template<typename... Args>
+__attribute__ ((warn_unused_result)) inline uint32_t
+HashGeneric(Args... aArgs)
+{
+  return AddToHash(0, aArgs...);
+}
+
+namespace detail {
+
+template<typename T>
+uint32_t
+HashUntilZero(const T* aStr)
+{
+  uint32_t hash = 0;
+  for (T c; (c = *aStr); aStr++) {
+    hash = AddToHash(hash, c);
+  }
+  return hash;
+}
+
+template<typename T>
+uint32_t
+HashKnownLength(const T* aStr, size_t aLength)
+{
+  uint32_t hash = 0;
+  for (size_t i = 0; i < aLength; i++) {
+    hash = AddToHash(hash, aStr[i]);
+  }
+  return hash;
+}
+
+}
+
+
+
+
+
+
+
+__attribute__ ((warn_unused_result)) inline uint32_t
+HashString(const char* aStr)
+{
+  return detail::HashUntilZero(reinterpret_cast<const unsigned char*>(aStr));
+}
+
+__attribute__ ((warn_unused_result)) inline uint32_t
+HashString(const char* aStr, size_t aLength)
+{
+  return detail::HashKnownLength(reinterpret_cast<const unsigned char*>(aStr), aLength);
+}
+
+__attribute__ ((warn_unused_result))
+inline uint32_t
+HashString(const unsigned char* aStr, size_t aLength)
+{
+  return detail::HashKnownLength(aStr, aLength);
+}
+
+__attribute__ ((warn_unused_result)) inline uint32_t
+HashString(const char16_t* aStr)
+{
+  return detail::HashUntilZero(aStr);
+}
+
+__attribute__ ((warn_unused_result)) inline uint32_t
+HashString(const char16_t* aStr, size_t aLength)
+{
+  return detail::HashKnownLength(aStr, aLength);
+}
+# 299 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+__attribute__ ((warn_unused_result)) extern __attribute__((weak)) __attribute__((visibility("default"))) uint32_t
+HashBytes(const void* bytes, size_t aLength);
+# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
+class HashCodeScrambler
+{
+  struct SipHasher;
+
+  uint64_t mK0, mK1;
+
+public:
+
+  constexpr HashCodeScrambler(uint64_t aK0, uint64_t aK1) : mK0(aK0), mK1(aK1) {}
+
+
+
+
+
+  uint32_t scramble(uint32_t aHashCode) const
+  {
+    SipHasher hasher(mK0, mK1);
+    return uint32_t(hasher.sipHash(aHashCode));
+  }
+
+private:
+  struct SipHasher
+  {
+    SipHasher(uint64_t aK0, uint64_t aK1)
+    {
+
+      mV0 = aK0 ^ 0x736f6d6570736575UL;
+      mV1 = aK1 ^ 0x646f72616e646f6dUL;
+      mV2 = aK0 ^ 0x6c7967656e657261UL;
+      mV3 = aK1 ^ 0x7465646279746573UL;
+    }
+
+    uint64_t sipHash(uint64_t aM)
+    {
+
+      mV3 ^= aM;
+      sipRound();
+      mV0 ^= aM;
+
+
+      mV2 ^= 0xff;
+      for (int i = 0; i < 3; i++)
+        sipRound();
+      return mV0 ^ mV1 ^ mV2 ^ mV3;
+    }
+
+    void sipRound()
+    {
+      mV0 += mV1;
+      mV1 = RotateLeft(mV1, 13);
+      mV1 ^= mV0;
+      mV0 = RotateLeft(mV0, 32);
+      mV2 += mV3;
+      mV3 = RotateLeft(mV3, 16);
+      mV3 ^= mV2;
+      mV0 += mV3;
+      mV3 = RotateLeft(mV3, 21);
+      mV3 ^= mV0;
+      mV2 += mV1;
+      mV1 = RotateLeft(mV1, 17);
+      mV1 ^= mV2;
+      mV2 = RotateLeft(mV2, 32);
+    }
+
+    uint64_t mV0, mV1, mV2, mV3;
+  };
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h"
+namespace mozilla {
+
+
+
+
+
+
+template<typename T>
+class Opaque final
+{
+  static_assert(mozilla::IsIntegral<T>::value,
+                "mozilla::Opaque only supports integral types");
+
+  T mValue;
+
+public:
+  Opaque() {}
+  explicit Opaque(T aValue) : mValue(aValue) {}
+
+  bool operator==(const Opaque& aOther) const {
+    return mValue == aOther.mValue;
+  }
+
+  bool operator!=(const Opaque& aOther) const {
+    return !(*this == aOther);
+  }
+};
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2
+
+
+
+
+
+
+
+
+namespace js {
+
+class TempAllocPolicy;
+template <class> struct DefaultHasher;
+template <class, class> class HashMapEntry;
+namespace detail {
+    template <class T> class HashTableEntry;
+    template <class T, class HashPolicy, class AllocPolicy> class HashTable;
+}
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+using Generation = mozilla::Opaque<uint64_t>;
+# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+template <class Key,
+          class Value,
+          class HashPolicy = DefaultHasher<Key>,
+          class AllocPolicy = TempAllocPolicy>
+class HashMap
+{
+    typedef HashMapEntry<Key, Value> TableEntry;
+
+    struct MapHashPolicy : HashPolicy
+    {
+        using Base = HashPolicy;
+        typedef Key KeyType;
+        static const Key& getKey(TableEntry& e) { return e.key(); }
+        static void setKey(TableEntry& e, Key& k) { HashPolicy::rekey(e.mutableKey(), k); }
+    };
+
+    typedef detail::HashTable<TableEntry, MapHashPolicy, AllocPolicy> Impl;
+    Impl impl;
+
+  public:
+    typedef typename HashPolicy::Lookup Lookup;
+    typedef TableEntry Entry;
+
+
+
+    explicit HashMap(AllocPolicy a = AllocPolicy()) : impl(a) {}
+    __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); }
+    bool initialized() const { return impl.initialized(); }
+# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Ptr Ptr;
+    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); }
+
+
+
+    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const {
+        return impl.readonlyThreadsafeLookup(l);
+    }
+
+
+    void remove(Ptr p) { impl.remove(p); }
+# 150 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::AddPtr AddPtr;
+    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const {
+        return impl.lookupForAdd(l);
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) {
+        return impl.add(p,
+                        mozilla::Forward<KeyInput>(k),
+                        mozilla::Forward<ValueInput>(v));
+    }
+
+    template<typename KeyInput>
+    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k) {
+        return impl.add(p, mozilla::Forward<KeyInput>(k), Value());
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) {
+        return impl.relookupOrAdd(p, k,
+                                  mozilla::Forward<KeyInput>(k),
+                                  mozilla::Forward<ValueInput>(v));
+    }
+# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Range Range;
+    Range all() const { return impl.all(); }
+# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Enum Enum;
+
+
+
+    void clear() { impl.clear(); }
+
+
+
+    void clearAndShrink() { impl.clearAndShrink(); }
+
+
+
+    void finish() { impl.finish(); }
+
+
+    bool empty() const { return impl.empty(); }
+
+
+    uint32_t count() const { return impl.count(); }
+
+
+
+    size_t capacity() const { return impl.capacity(); }
+
+
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return impl.sizeOfExcludingThis(mallocSizeOf);
+    }
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf);
+    }
+
+    Generation generation() const {
+        return impl.generation();
+    }
+
+
+
+    bool has(const Lookup& l) const {
+        return impl.lookup(l).found();
+    }
+
+
+    template<typename KeyInput, typename ValueInput>
+    __attribute__ ((warn_unused_result)) bool put(KeyInput&& k, ValueInput&& v) {
+        AddPtr p = lookupForAdd(k);
+        if (p) {
+            p->value() = mozilla::Forward<ValueInput>(v);
+            return true;
+        }
+        return add(p, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+    }
+
+
+    template<typename KeyInput, typename ValueInput>
+    __attribute__ ((warn_unused_result)) bool putNew(KeyInput&& k, ValueInput&& v) {
+        return impl.putNew(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+    }
+
+
+    template<typename KeyInput, typename ValueInput>
+    void putNewInfallible(KeyInput&& k, ValueInput&& v) {
+        impl.putNewInfallible(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+    }
+
+
+    Ptr lookupWithDefault(const Key& k, const Value& defaultValue) {
+        AddPtr p = lookupForAdd(k);
+        if (p)
+            return p;
+        bool ok = add(p, k, defaultValue);
+        do { } while (0);
+        (void)ok;
+        return p;
+    }
+
+
+    void remove(const Lookup& l) {
+        if (Ptr p = lookup(l))
+            remove(p);
+    }
+
+
+
+    void rekeyIfMoved(const Key& old_key, const Key& new_key) {
+        if (old_key != new_key)
+            rekeyAs(old_key, new_key, new_key);
+    }
+
+
+    bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const Key& new_key) {
+        if (Ptr p = lookup(old_lookup)) {
+            impl.rekeyAndMaybeRehash(p, new_lookup, new_key);
+            return true;
+        }
+        return false;
+    }
+
+
+    HashMap(HashMap&& rhs) : impl(mozilla::Move(rhs.impl)) {}
+    void operator=(HashMap&& rhs) {
+        do { } while (0);
+        impl = mozilla::Move(rhs.impl);
+    }
+
+  private:
+
+    HashMap(const HashMap& hm) = delete;
+    HashMap& operator=(const HashMap& hm) = delete;
+
+    friend class Impl::Enum;
+};
+# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+template <class T,
+          class HashPolicy = DefaultHasher<T>,
+          class AllocPolicy = TempAllocPolicy>
+class HashSet
+{
+    struct SetOps : HashPolicy
+    {
+        using Base = HashPolicy;
+        typedef T KeyType;
+        static const KeyType& getKey(const T& t) { return t; }
+        static void setKey(T& t, KeyType& k) { HashPolicy::rekey(t, k); }
+    };
+
+    typedef detail::HashTable<const T, SetOps, AllocPolicy> Impl;
+    Impl impl;
+
+  public:
+    typedef typename HashPolicy::Lookup Lookup;
+    typedef T Entry;
+
+
+
+    explicit HashSet(AllocPolicy a = AllocPolicy()) : impl(a) {}
+    __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); }
+    bool initialized() const { return impl.initialized(); }
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Ptr Ptr;
+    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); }
+
+
+
+    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const {
+        return impl.readonlyThreadsafeLookup(l);
+    }
+
+
+    void remove(Ptr p) { impl.remove(p); }
+# 406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::AddPtr AddPtr;
+    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const {
+        return impl.lookupForAdd(l);
+    }
+
+    template <typename U>
+    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, U&& u) {
+        return impl.add(p, mozilla::Forward<U>(u));
+    }
+
+    template <typename U>
+    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, U&& u) {
+        return impl.relookupOrAdd(p, l, mozilla::Forward<U>(u));
+    }
+# 429 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Range Range;
+    Range all() const { return impl.all(); }
+# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+    typedef typename Impl::Enum Enum;
+
+
+
+    void clear() { impl.clear(); }
+
+
+
+    void clearAndShrink() { impl.clearAndShrink(); }
+
+
+
+    void finish() { impl.finish(); }
+
+
+    bool empty() const { return impl.empty(); }
+
+
+    uint32_t count() const { return impl.count(); }
+
+
+
+    size_t capacity() const { return impl.capacity(); }
+
+
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return impl.sizeOfExcludingThis(mallocSizeOf);
+    }
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf);
+    }
+
+    Generation generation() const {
+        return impl.generation();
+    }
+
+
+
+    bool has(const Lookup& l) const {
+        return impl.lookup(l).found();
+    }
+
+
+    template <typename U>
+    __attribute__ ((warn_unused_result)) bool put(U&& u) {
+        AddPtr p = lookupForAdd(u);
+        return p ? true : add(p, mozilla::Forward<U>(u));
+    }
+
+
+    template <typename U>
+    __attribute__ ((warn_unused_result)) bool putNew(U&& u) {
+        return impl.putNew(u, mozilla::Forward<U>(u));
+    }
+
+    template <typename U>
+    __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, U&& u) {
+        return impl.putNew(l, mozilla::Forward<U>(u));
+    }
+
+
+    template <typename U>
+    void putNewInfallible(const Lookup& l, U&& u) {
+        impl.putNewInfallible(l, mozilla::Forward<U>(u));
+    }
+
+    void remove(const Lookup& l) {
+        if (Ptr p = lookup(l))
+            remove(p);
+    }
+
+
+
+    void rekeyIfMoved(const Lookup& old_value, const T& new_value) {
+        if (old_value != new_value)
+            rekeyAs(old_value, new_value, new_value);
+    }
+
+
+    bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const T& new_value) {
+        if (Ptr p = lookup(old_lookup)) {
+            impl.rekeyAndMaybeRehash(p, new_lookup, new_value);
+            return true;
+        }
+        return false;
+    }
+
+
+
+
+
+    void replaceKey(Ptr p, const T& new_value) {
+        do { } while (0);
+        do { } while (0);
+        do { } while (0);
+        do { } while (0);
+        const_cast<T&>(*p) = new_value;
+    }
+
+
+    HashSet(HashSet&& rhs) : impl(mozilla::Move(rhs.impl)) {}
+    void operator=(HashSet&& rhs) {
+        do { } while (0);
+        impl = mozilla::Move(rhs.impl);
+    }
+
+  private:
+
+    HashSet(const HashSet& hs) = delete;
+    HashSet& operator=(const HashSet& hs) = delete;
+
+    friend class Impl::Enum;
+};
+# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+template <typename Key, size_t zeroBits>
+struct PointerHasher
+{
+    typedef Key Lookup;
+    static HashNumber hash(const Lookup& l) {
+        size_t word = reinterpret_cast<size_t>(l) >> zeroBits;
+        static_assert(sizeof(HashNumber) == 4,
+                      "subsequent code assumes a four-byte hash");
+
+
+
+        static_assert(sizeof(word) == 8,
+                      "unexpected word size, new hashing strategy required to "
+                      "properly incorporate all bits");
+        return HashNumber((word >> 32) ^ word);
+
+    }
+    static bool match(const Key& k, const Lookup& l) {
+        return k == l;
+    }
+    static void rekey(Key& k, const Key& newKey) {
+        k = newKey;
+    }
+};
+
+
+
+
+
+template <class Key>
+struct DefaultHasher
+{
+    typedef Key Lookup;
+    static HashNumber hash(const Lookup& l) {
+
+        return l;
+    }
+    static bool match(const Key& k, const Lookup& l) {
+
+        return k == l;
+    }
+    static void rekey(Key& k, const Key& newKey) {
+        k = newKey;
+    }
+};
+
+
+
+template <class T>
+struct DefaultHasher<T*> : PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>
+{};
+
+
+
+template <class T, class D>
+struct DefaultHasher<mozilla::UniquePtr<T, D>>
+{
+    using Lookup = mozilla::UniquePtr<T, D>;
+    using PtrHasher = PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>;
+
+    static HashNumber hash(const Lookup& l) {
+        return PtrHasher::hash(l.get());
+    }
+    static bool match(const mozilla::UniquePtr<T, D>& k, const Lookup& l) {
+        return PtrHasher::match(k.get(), l.get());
+    }
+    static void rekey(mozilla::UniquePtr<T, D>& k, mozilla::UniquePtr<T, D>&& newKey) {
+        k = mozilla::Move(newKey);
+    }
+};
+
+
+template <>
+struct DefaultHasher<double>
+{
+    typedef double Lookup;
+    static HashNumber hash(double d) {
+        static_assert(sizeof(HashNumber) == 4,
+                      "subsequent code assumes a four-byte hash");
+        uint64_t u = mozilla::BitwiseCast<uint64_t>(d);
+        return HashNumber(u ^ (u >> 32));
+    }
+    static bool match(double lhs, double rhs) {
+        return mozilla::BitwiseCast<uint64_t>(lhs) == mozilla::BitwiseCast<uint64_t>(rhs);
+    }
+};
+
+template <>
+struct DefaultHasher<float>
+{
+    typedef float Lookup;
+    static HashNumber hash(float f) {
+        static_assert(sizeof(HashNumber) == 4,
+                      "subsequent code assumes a four-byte hash");
+        return HashNumber(mozilla::BitwiseCast<uint32_t>(f));
+    }
+    static bool match(float lhs, float rhs) {
+        return mozilla::BitwiseCast<uint32_t>(lhs) == mozilla::BitwiseCast<uint32_t>(rhs);
+    }
+};
+
+
+struct CStringHasher
+{
+    typedef const char* Lookup;
+    static js::HashNumber hash(Lookup l) {
+        return mozilla::HashString(l);
+    }
+    static bool match(const char* key, Lookup lookup) {
+        return strcmp(key, lookup) == 0;
+    }
+};
+# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+template <typename HashPolicy>
+struct FallibleHashMethods
+{
+
+
+    template <typename Lookup> static bool hasHash(Lookup&& l) { return true; }
+
+
+
+    template <typename Lookup> static bool ensureHash(Lookup&& l) { return true; }
+};
+
+template <typename HashPolicy, typename Lookup>
+static bool
+HasHash(Lookup&& l) {
+    return FallibleHashMethods<typename HashPolicy::Base>::hasHash(mozilla::Forward<Lookup>(l));
+}
+
+template <typename HashPolicy, typename Lookup>
+static bool
+EnsureHash(Lookup&& l) {
+    return FallibleHashMethods<typename HashPolicy::Base>::ensureHash(mozilla::Forward<Lookup>(l));
+}
+# 739 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+template <class Key, class Value>
+class HashMapEntry
+{
+    Key key_;
+    Value value_;
+
+    template <class, class, class> friend class detail::HashTable;
+    template <class> friend class detail::HashTableEntry;
+    template <class, class, class, class> friend class HashMap;
+
+  public:
+    template<typename KeyInput, typename ValueInput>
+    HashMapEntry(KeyInput&& k, ValueInput&& v)
+      : key_(mozilla::Forward<KeyInput>(k)),
+        value_(mozilla::Forward<ValueInput>(v))
+    {}
+
+    HashMapEntry(HashMapEntry&& rhs)
+      : key_(mozilla::Move(rhs.key_)),
+        value_(mozilla::Move(rhs.value_))
+    {}
+
+    void operator=(HashMapEntry&& rhs) {
+        key_ = mozilla::Move(rhs.key_);
+        value_ = mozilla::Move(rhs.value_);
+    }
+
+    typedef Key KeyType;
+    typedef Value ValueType;
+
+    const Key& key() const { return key_; }
+    Key& mutableKey() { return key_; }
+    const Value& value() const { return value_; }
+    Value& value() { return value_; }
+
+  private:
+    HashMapEntry(const HashMapEntry&) = delete;
+    void operator=(const HashMapEntry&) = delete;
+};
+
+}
+
+namespace mozilla {
+
+template <typename T>
+struct IsPod<js::detail::HashTableEntry<T> > : IsPod<T> {};
+
+template <typename K, typename V>
+struct IsPod<js::HashMapEntry<K, V> >
+  : IntegralConstant<bool, IsPod<K>::value && IsPod<V>::value>
+{};
+
+}
+
+namespace js {
+
+namespace detail {
+
+template <class T, class HashPolicy, class AllocPolicy>
+class HashTable;
+
+template <class T>
+class HashTableEntry
+{
+    template <class, class, class> friend class HashTable;
+    typedef typename mozilla::RemoveConst<T>::Type NonConstT;
+
+    HashNumber keyHash;
+    mozilla::AlignedStorage2<NonConstT> mem;
+
+    static const HashNumber sFreeKey = 0;
+    static const HashNumber sRemovedKey = 1;
+    static const HashNumber sCollisionBit = 1;
+
+    static bool isLiveHash(HashNumber hash)
+    {
+        return hash > sRemovedKey;
+    }
+
+    HashTableEntry(const HashTableEntry&) = delete;
+    void operator=(const HashTableEntry&) = delete;
+    ~HashTableEntry() = delete;
+
+  public:
+
+
+    void destroyIfLive() {
+        if (isLive())
+            mem.addr()->~T();
+    }
+
+    void destroy() {
+        do { } while (0);
+        mem.addr()->~T();
+    }
+
+    void swap(HashTableEntry* other) {
+        if (this == other)
+            return;
+        do { } while (0);
+        if (other->isLive()) {
+            mozilla::Swap(*mem.addr(), *other->mem.addr());
+        } else {
+            *other->mem.addr() = mozilla::Move(*mem.addr());
+            destroy();
+        }
+        mozilla::Swap(keyHash, other->keyHash);
+    }
+
+    T& get() { do { } while (0); return *mem.addr(); }
+    NonConstT& getMutable() { do { } while (0); return *mem.addr(); }
+
+    bool isFree() const { return keyHash == sFreeKey; }
+    void clearLive() { do { } while (0); keyHash = sFreeKey; mem.addr()->~T(); }
+    void clear() { if (isLive()) mem.addr()->~T(); keyHash = sFreeKey; }
+    bool isRemoved() const { return keyHash == sRemovedKey; }
+    void removeLive() { do { } while (0); keyHash = sRemovedKey; mem.addr()->~T(); }
+    bool isLive() const { return isLiveHash(keyHash); }
+    void setCollision() { do { } while (0); keyHash |= sCollisionBit; }
+    void unsetCollision() { keyHash &= ~sCollisionBit; }
+    bool hasCollision() const { return keyHash & sCollisionBit; }
+    bool matchHash(HashNumber hn) { return (keyHash & ~sCollisionBit) == hn; }
+    HashNumber getKeyHash() const { return keyHash & ~sCollisionBit; }
+
+    template <typename... Args>
+    void setLive(HashNumber hn, Args&&... args)
+    {
+        do { } while (0);
+        keyHash = hn;
+        new(mem.addr()) T(mozilla::Forward<Args>(args)...);
+        do { } while (0);
+    }
+};
+
+template <class T, class HashPolicy, class AllocPolicy>
+class HashTable : private AllocPolicy
+{
+    friend class mozilla::ReentrancyGuard;
+
+    typedef typename mozilla::RemoveConst<T>::Type NonConstT;
+    typedef typename HashPolicy::KeyType Key;
+    typedef typename HashPolicy::Lookup Lookup;
+
+  public:
+    typedef HashTableEntry<T> Entry;
+
+
+
+
+
+    class Ptr
+    {
+        friend class HashTable;
+
+        Entry* entry_;
+
+        const HashTable* table_;
+        Generation generation;
+
+
+      protected:
+        Ptr(Entry& entry, const HashTable& tableArg)
+          : entry_(&entry)
+
+          , table_(&tableArg)
+          , generation(tableArg.generation())
+
+        {}
+
+      public:
+        Ptr()
+          : entry_(nullptr)
+
+          , table_(nullptr)
+          , generation(0)
+
+        {}
+
+        bool isValid() const {
+            return !entry_;
+        }
+
+        bool found() const {
+            if (isValid())
+                return false;
+
+            do { } while (0);
+
+            return entry_->isLive();
+        }
+
+        explicit operator bool() const {
+            return found();
+        }
+
+        bool operator==(const Ptr& rhs) const {
+            do { } while (0);
+            return entry_ == rhs.entry_;
+        }
+
+        bool operator!=(const Ptr& rhs) const {
+
+            do { } while (0);
+
+            return !(*this == rhs);
+        }
+
+        T& operator*() const {
+
+            do { } while (0);
+            do { } while (0);
+
+            return entry_->get();
+        }
+
+        T* operator->() const {
+
+            do { } while (0);
+            do { } while (0);
+
+            return &entry_->get();
+        }
+    };
+
+
+    class AddPtr : public Ptr
+    {
+        friend class HashTable;
+        HashNumber keyHash;
+
+        uint64_t mutationCount;
+
+
+        AddPtr(Entry& entry, const HashTable& tableArg, HashNumber hn)
+          : Ptr(entry, tableArg)
+          , keyHash(hn)
+
+          , mutationCount(tableArg.mutationCount)
+
+        {}
+
+      public:
+        AddPtr() : keyHash(0) {}
+    };
+
+
+
+
+
+    class Range
+    {
+      protected:
+        friend class HashTable;
+
+        Range(const HashTable& tableArg, Entry* c, Entry* e)
+          : cur(c)
+          , end(e)
+
+          , table_(&tableArg)
+          , mutationCount(tableArg.mutationCount)
+          , generation(tableArg.generation())
+          , validEntry(true)
+
+        {
+            while (cur < end && !cur->isLive())
+                ++cur;
+        }
+
+        Entry* cur;
+        Entry* end;
+
+        const HashTable* table_;
+        uint64_t mutationCount;
+        Generation generation;
+        bool validEntry;
+
+
+      public:
+        Range()
+          : cur(nullptr)
+          , end(nullptr)
+
+          , table_(nullptr)
+          , mutationCount(0)
+          , generation(0)
+          , validEntry(false)
+
+        {}
+
+        bool empty() const {
+
+            do { } while (0);
+            do { } while (0);
+
+            return cur == end;
+        }
+
+        T& front() const {
+            do { } while (0);
+
+            do { } while (0);
+            do { } while (0);
+            do { } while (0);
+
+            return cur->get();
+        }
+
+        void popFront() {
+            do { } while (0);
+
+            do { } while (0);
+            do { } while (0);
+
+            while (++cur < end && !cur->isLive())
+                continue;
+
+            validEntry = true;
+
+        }
+    };
+
+
+
+
+
+
+    class Enum : public Range
+    {
+        friend class HashTable;
+
+        HashTable& table_;
+        bool rekeyed;
+        bool removed;
+
+
+        Enum(const Enum&) = delete;
+        void operator=(const Enum&) = delete;
+
+      public:
+        template<class Map> explicit
+        Enum(Map& map) : Range(map.all()), table_(map.impl), rekeyed(false), removed(false) {}
+# 1088 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
+        void removeFront() {
+            table_.remove(*this->cur);
+            removed = true;
+
+            this->validEntry = false;
+            this->mutationCount = table_.mutationCount;
+
+        }
+
+        NonConstT& mutableFront() {
+            do { } while (0);
+
+            do { } while (0);
+            do { } while (0);
+            do { } while (0);
+
+            return this->cur->getMutable();
+        }
+
+
+
+
+        void rekeyFront(const Lookup& l, const Key& k) {
+            do { } while (0);
+            Ptr p(*this->cur, table_);
+            table_.rekeyWithoutRehash(p, l, k);
+            rekeyed = true;
+
+            this->validEntry = false;
+            this->mutationCount = table_.mutationCount;
+
+        }
+
+        void rekeyFront(const Key& k) {
+            rekeyFront(k, k);
+        }
+
+
+        ~Enum() {
+            if (rekeyed) {
+                table_.gen++;
+                table_.checkOverRemoved();
+            }
+
+            if (removed)
+                table_.compactIfUnderloaded();
+        }
+    };
+
+
+    HashTable(HashTable&& rhs)
+      : AllocPolicy(rhs)
+    {
+        mozilla::PodAssign(this, &rhs);
+        rhs.table = nullptr;
+    }
+    void operator=(HashTable&& rhs) {
+        do { } while (0);
+        if (table)
+            destroyTable(*this, table, capacity());
+        mozilla::PodAssign(this, &rhs);
+        rhs.table = nullptr;
+    }
+
+  private:
+
+    HashTable(const HashTable&) = delete;
+    void operator=(const HashTable&) = delete;
+
+  private:
+    static const size_t CAP_BITS = 30;
+
+  public:
+    uint64_t gen:56;
+    uint64_t hashShift:8;
+    Entry* table;
+    uint32_t entryCount;
+    uint32_t removedCount;
+
+
+    uint64_t mutationCount;
+    mutable bool mEntered;
+
+
+    mutable struct Stats
+    {
+        uint32_t searches;
+        uint32_t steps;
+        uint32_t hits;
+        uint32_t misses;
+        uint32_t addOverRemoved;
+        uint32_t removes;
+        uint32_t removeFrees;
+        uint32_t grows;
+        uint32_t shrinks;
+        uint32_t compresses;
+        uint32_t rehashes;
+    } stats;
+
+
+
+
+
+
+
+    static const unsigned sMinCapacityLog2 = 2;
+    static const unsigned sMinCapacity = 1 << sMinCapacityLog2;
+    static const unsigned sMaxInit = ((uint32_t)1 << (CAP_BITS - 1));
+    static const unsigned sMaxCapacity = ((uint32_t)1 << (CAP_BITS));
+    static const unsigned sHashBits = mozilla::tl::BitSize<HashNumber>::value;
+
+
+
+    static const uint8_t sAlphaDenominator = 4;
+    static const uint8_t sMinAlphaNumerator = 1;
+    static const uint8_t sMaxAlphaNumerator = 3;
+
+    static const HashNumber sFreeKey = Entry::sFreeKey;
+    static const HashNumber sRemovedKey = Entry::sRemovedKey;
+    static const HashNumber sCollisionBit = Entry::sCollisionBit;
+
+    void setTableSizeLog2(unsigned sizeLog2)
+    {
+        hashShift = sHashBits - sizeLog2;
+    }
+
+    static bool isLiveHash(HashNumber hash)
+    {
+        return Entry::isLiveHash(hash);
+    }
+
+    static HashNumber prepareHash(const Lookup& l)
+    {
+        HashNumber keyHash = ScrambleHashCode(HashPolicy::hash(l));
+
+
+        if (!isLiveHash(keyHash))
+            keyHash -= (sRemovedKey + 1);
+        return keyHash & ~sCollisionBit;
+    }
+
+    enum FailureBehavior { DontReportFailure = false, ReportFailure = true };
+
+    static Entry* createTable(AllocPolicy& alloc, uint32_t capacity,
+                              FailureBehavior reportFailure = ReportFailure)
+    {
+        static_assert(sFreeKey == 0,
+                      "newly-calloc'd tables have to be considered empty");
+        if (reportFailure)
+            return alloc.template pod_calloc<Entry>(capacity);
+
+        return alloc.template maybe_pod_calloc<Entry>(capacity);
+    }
+
+    static Entry* maybeCreateTable(AllocPolicy& alloc, uint32_t capacity)
+    {
+        static_assert(sFreeKey == 0,
+                      "newly-calloc'd tables have to be considered empty");
+        return alloc.template maybe_pod_calloc<Entry>(capacity);
+    }
+
+    static void destroyTable(AllocPolicy& alloc, Entry* oldTable, uint32_t capacity)
+    {
+        Entry* end = oldTable + capacity;
+        for (Entry* e = oldTable; e < end; ++e)
+            e->destroyIfLive();
+        alloc.free_(oldTable);
+    }
+
+  public:
+    explicit HashTable(AllocPolicy ap)
+      : AllocPolicy(ap)
+      , gen(0)
+      , hashShift(sHashBits)
+      , table(nullptr)
+      , entryCount(0)
+      , removedCount(0)
+
+      , mutationCount(0)
+      , mEntered(false)
+
+    {}
+
+    __attribute__ ((warn_unused_result)) bool init(uint32_t length)
+    {
+        do { } while (0);
+
+
+
+
+        if ((__builtin_expect(!!(length > sMaxInit), 0))) {
+            this->reportAllocOverflow();
+            return false;
+        }
+
+        static_assert((sMaxInit * sAlphaDenominator) / sAlphaDenominator == sMaxInit,
+                      "multiplication in numerator below could overflow");
+        static_assert(sMaxInit * sAlphaDenominator <= (4294967295U) - sMaxAlphaNumerator,
+                      "numerator calculation below could potentially overflow");
+
+
+
+
+        uint32_t newCapacity =
+            (length * sAlphaDenominator + sMaxAlphaNumerator - 1) / sMaxAlphaNumerator;
+        if (newCapacity < sMinCapacity)
+            newCapacity = sMinCapacity;
+
+
+        uint32_t roundUp = sMinCapacity, roundUpLog2 = sMinCapacityLog2;
+        while (roundUp < newCapacity) {
+            roundUp <<= 1;
+            ++roundUpLog2;
+        }
+
+        newCapacity = roundUp;
+        do { } while (0);
+        do { } while (0);
+
+        table = createTable(*this, newCapacity);
+        if (!table)
+            return false;
+
+        setTableSizeLog2(roundUpLog2);
+        memset(&stats, 0, sizeof(stats));
+        return true;
+    }
+
+    bool initialized() const
+    {
+        return !!table;
+    }
+
+    ~HashTable()
+    {
+        if (table)
+            destroyTable(*this, table, capacity());
+    }
+
+  private:
+    HashNumber hash1(HashNumber hash0) const
+    {
+        return hash0 >> hashShift;
+    }
+
+    struct DoubleHash
+    {
+        HashNumber h2;
+        HashNumber sizeMask;
+    };
+
+    DoubleHash hash2(HashNumber curKeyHash) const
+    {
+        unsigned sizeLog2 = sHashBits - hashShift;
+        DoubleHash dh = {
+            ((curKeyHash << sizeLog2) >> hashShift) | 1,
+            (HashNumber(1) << sizeLog2) - 1
+        };
+        return dh;
+    }
+
+    static HashNumber applyDoubleHash(HashNumber h1, const DoubleHash& dh)
+    {
+        return (h1 - dh.h2) & dh.sizeMask;
+    }
+
+    bool overloaded()
+    {
+        static_assert(sMaxCapacity <= (4294967295U) / sMaxAlphaNumerator,
+                      "multiplication below could overflow");
+        return entryCount + removedCount >=
+               capacity() * sMaxAlphaNumerator / sAlphaDenominator;
+    }
+
+
+    static bool wouldBeUnderloaded(uint32_t capacity, uint32_t entryCount)
+    {
+        static_assert(sMaxCapacity <= (4294967295U) / sMinAlphaNumerator,
+                      "multiplication below could overflow");
+        return capacity > sMinCapacity &&
+               entryCount <= capacity * sMinAlphaNumerator / sAlphaDenominator;
+    }
+
+    bool underloaded()
+    {
+        return wouldBeUnderloaded(capacity(), entryCount);
+    }
+
+    static __attribute__((always_inline)) inline bool match(Entry& e, const Lookup& l)
+    {
+        return HashPolicy::match(HashPolicy::getKey(e.get()), l);
+    }
+
+
+
+
+
+
+    __attribute__((always_inline)) inline Entry&
+    lookup(const Lookup& l, HashNumber keyHash, unsigned collisionBit) const
+    {
+        do { } while (0);
+        do { } while (0);
+        do { } while (0);
+        do { } while (0);
+        stats.searches++;
+
+
+        HashNumber h1 = hash1(keyHash);
+        Entry* entry = &table[h1];
+
+
+        if (entry->isFree()) {
+            stats.misses++;
+            return *entry;
+        }
+
+
+        if (entry->matchHash(keyHash) && match(*entry, l)) {
+            stats.hits++;
+            return *entry;
+        }
+
+
+        DoubleHash dh = hash2(keyHash);
+
+
+        Entry* firstRemoved = nullptr;
+
+        while (true) {
+            if ((__builtin_expect(!!(entry->isRemoved()), 0))) {
+                if (!firstRemoved)
+                    firstRemoved = entry;
+            } else {
+                if (collisionBit == sCollisionBit)
+                    entry->setCollision();
+            }
+
+            stats.steps++;
+            h1 = applyDoubleHash(h1, dh);
+
+            entry = &table[h1];
+            if (entry->isFree()) {
+                stats.misses++;
+                return firstRemoved ? *firstRemoved : *entry;
+            }
+
+            if (entry->matchHash(keyHash) && match(*entry, l)) {
+                stats.hits++;
+                return *entry;
+            }
+        }
+    }
+
+
+
+
+
+
+
+    Entry& findFreeEntry(HashNumber keyHash)
+    {
+        do { } while (0);
+        do { } while (0);
+        stats.searches++;
+
+
+
+
+        HashNumber h1 = hash1(keyHash);
+        Entry* entry = &table[h1];
+
+
+        if (!entry->isLive()) {
+            stats.misses++;
+            return *entry;
+        }
+
+
+        DoubleHash dh = hash2(keyHash);
+
+        while (true) {
+            do { } while (0);
+            entry->setCollision();
+
+            stats.steps++;
+            h1 = applyDoubleHash(h1, dh);
+
+            entry = &table[h1];
+            if (!entry->isLive()) {
+                stats.misses++;
+                return *entry;
+            }
+        }
+    }
+
+    enum RebuildStatus { NotOverloaded, Rehashed, RehashFailed };
+
+    RebuildStatus changeTableSize(int deltaLog2, FailureBehavior reportFailure = ReportFailure)
+    {
+
+        Entry* oldTable = table;
+        uint32_t oldCap = capacity();
+        uint32_t newLog2 = sHashBits - hashShift + deltaLog2;
+        uint32_t newCapacity = ((uint32_t)1 << (newLog2));
+        if ((__builtin_expect(!!(newCapacity > sMaxCapacity), 0))) {
+            if (reportFailure)
+                this->reportAllocOverflow();
+            return RehashFailed;
+        }
+
+        Entry* newTable = createTable(*this, newCapacity, reportFailure);
+        if (!newTable)
+            return RehashFailed;
+
+
+        setTableSizeLog2(newLog2);
+        removedCount = 0;
+        gen++;
+        table = newTable;
+
+
+        Entry* end = oldTable + oldCap;
+        for (Entry* src = oldTable; src < end; ++src) {
+            if (src->isLive()) {
+                HashNumber hn = src->getKeyHash();
+                findFreeEntry(hn).setLive(
+                    hn, mozilla::Move(const_cast<typename Entry::NonConstT&>(src->get())));
+                src->destroy();
+            }
+        }
+
+
+        this->free_(oldTable);
+        return Rehashed;
+    }
+
+    bool shouldCompressTable()
+    {
+
+        return removedCount >= (capacity() >> 2);
+    }
+
+    RebuildStatus checkOverloaded(FailureBehavior reportFailure = ReportFailure)
+    {
+        if (!overloaded())
+            return NotOverloaded;
+
+        int deltaLog2;
+        if (shouldCompressTable()) {
+            stats.compresses++;
+            deltaLog2 = 0;
+        } else {
+            stats.grows++;
+            deltaLog2 = 1;
+        }
+
+        return changeTableSize(deltaLog2, reportFailure);
+    }
+
+
+    void checkOverRemoved()
+    {
+        if (overloaded()) {
+            if (checkOverloaded(DontReportFailure) == RehashFailed)
+                rehashTableInPlace();
+        }
+    }
+
+    void remove(Entry& e)
+    {
+        do { } while (0);
+        stats.removes++;
+
+        if (e.hasCollision()) {
+            e.removeLive();
+            removedCount++;
+        } else {
+            stats.removeFrees++;
+            e.clearLive();
+        }
+        entryCount--;
+
+        mutationCount++;
+
+    }
+
+    void checkUnderloaded()
+    {
+        if (underloaded()) {
+            stats.shrinks++;
+            (void) changeTableSize(-1, DontReportFailure);
+        }
+    }
+
+
+
+
+    void compactIfUnderloaded()
+    {
+        int32_t resizeLog2 = 0;
+        uint32_t newCapacity = capacity();
+        while (wouldBeUnderloaded(newCapacity, entryCount)) {
+            newCapacity = newCapacity >> 1;
+            resizeLog2--;
+        }
+
+        if (resizeLog2 != 0)
+            (void) changeTableSize(resizeLog2, DontReportFailure);
+    }
+
+
+
+
+
+
+    void rehashTableInPlace()
+    {
+        stats.rehashes++;
+        removedCount = 0;
+        for (size_t i = 0; i < capacity(); ++i)
+            table[i].unsetCollision();
+
+        for (size_t i = 0; i < capacity();) {
+            Entry* src = &table[i];
+
+            if (!src->isLive() || src->hasCollision()) {
+                ++i;
+                continue;
+            }
+
+            HashNumber keyHash = src->getKeyHash();
+            HashNumber h1 = hash1(keyHash);
+            DoubleHash dh = hash2(keyHash);
+            Entry* tgt = &table[h1];
+            while (true) {
+                if (!tgt->hasCollision()) {
+                    src->swap(tgt);
+                    tgt->setCollision();
+                    break;
+                }
+
+                h1 = applyDoubleHash(h1, dh);
+                tgt = &table[h1];
+            }
+        }
+
+
+
+
+
+
+    }
+
+
+
+
+
+
+    template <typename... Args>
+    void putNewInfallibleInternal(const Lookup& l, Args&&... args)
+    {
+        do { } while (0);
+
+        HashNumber keyHash = prepareHash(l);
+        Entry* entry = &findFreeEntry(keyHash);
+        do { } while (0);
+
+        if (entry->isRemoved()) {
+            stats.addOverRemoved++;
+            removedCount--;
+            keyHash |= sCollisionBit;
+        }
+
+        entry->setLive(keyHash, mozilla::Forward<Args>(args)...);
+        entryCount++;
+
+        mutationCount++;
+
+    }
+
+  public:
+    void clear()
+    {
+        if (mozilla::IsPod<Entry>::value) {
+            memset(table, 0, sizeof(*table) * capacity());
+        } else {
+            uint32_t tableCapacity = capacity();
+            Entry* end = table + tableCapacity;
+            for (Entry* e = table; e < end; ++e)
+                e->clear();
+        }
+        removedCount = 0;
+        entryCount = 0;
+
+        mutationCount++;
+
+    }
+
+    void clearAndShrink()
+    {
+        clear();
+        compactIfUnderloaded();
+    }
+
+    void finish()
+    {
+
+        do { } while (0);
+
+        if (!table)
+            return;
+
+        destroyTable(*this, table, capacity());
+        table = nullptr;
+        gen++;
+        entryCount = 0;
+        removedCount = 0;
+
+        mutationCount++;
+
+    }
+
+    Range all() const
+    {
+        do { } while (0);
+        return Range(*this, table, table + capacity());
+    }
+
+    bool empty() const
+    {
+        do { } while (0);
+        return !entryCount;
+    }
+
+    uint32_t count() const
+    {
+        do { } while (0);
+        return entryCount;
+    }
+
+    uint32_t capacity() const
+    {
+        do { } while (0);
+        return ((uint32_t)1 << (sHashBits - hashShift));
+    }
+
+    Generation generation() const
+    {
+        do { } while (0);
+        return Generation(gen);
+    }
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+    {
+        return mallocSizeOf(table);
+    }
+
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+    {
+        return mallocSizeOf(this) + sizeOfExcludingThis(mallocSizeOf);
+    }
+
+    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const
+    {
+        mozilla::ReentrancyGuard g(*this);
+        if (!HasHash<HashPolicy>(l))
+            return Ptr();
+        HashNumber keyHash = prepareHash(l);
+        return Ptr(lookup(l, keyHash, 0), *this);
+    }
+
+    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const
+    {
+        if (!HasHash<HashPolicy>(l))
+            return Ptr();
+        HashNumber keyHash = prepareHash(l);
+        return Ptr(lookup(l, keyHash, 0), *this);
+    }
+
+    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const
+    {
+        mozilla::ReentrancyGuard g(*this);
+        if (!EnsureHash<HashPolicy>(l))
+            return AddPtr();
+        HashNumber keyHash = prepareHash(l);
+        Entry& entry = lookup(l, keyHash, sCollisionBit);
+        AddPtr p(entry, *this, keyHash);
+        return p;
+    }
+
+    template <typename... Args>
+    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, Args&&... args)
+    {
+        mozilla::ReentrancyGuard g(*this);
+        do { } while (0);
+        do { } while (0);
+        do { } while (0);
+
+
+        if (p.isValid())
+            return false;
+
+
+
+        if (p.entry_->isRemoved()) {
+            if (!this->checkSimulatedOOM())
+                return false;
+            stats.addOverRemoved++;
+            removedCount--;
+            p.keyHash |= sCollisionBit;
+        } else {
+
+            RebuildStatus status = checkOverloaded();
+            if (status == RehashFailed)
+                return false;
+            if (status == NotOverloaded && !this->checkSimulatedOOM())
+                return false;
+            if (status == Rehashed)
+                p.entry_ = &findFreeEntry(p.keyHash);
+        }
+
+        p.entry_->setLive(p.keyHash, mozilla::Forward<Args>(args)...);
+        entryCount++;
+
+        mutationCount++;
+        p.generation = generation();
+        p.mutationCount = mutationCount;
+
+        return true;
+    }
+
+
+
+    template <typename... Args>
+    void putNewInfallible(const Lookup& l, Args&&... args)
+    {
+        do { } while (0);
+        mozilla::ReentrancyGuard g(*this);
+        putNewInfallibleInternal(l, mozilla::Forward<Args>(args)...);
+    }
+
+
+
+    template <typename... Args>
+    __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, Args&&... args)
+    {
+        if (!this->checkSimulatedOOM())
+            return false;
+
+        if (!EnsureHash<HashPolicy>(l))
+            return false;
+
+        if (checkOverloaded() == RehashFailed)
+            return false;
+
+        putNewInfallible(l, mozilla::Forward<Args>(args)...);
+        return true;
+    }
+
+
+
+    template <typename... Args>
+    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, Args&&... args)
+    {
+
+        if (p.isValid())
+            return false;
+
+
+        p.generation = generation();
+        p.mutationCount = mutationCount;
+
+        {
+            mozilla::ReentrancyGuard g(*this);
+            do { } while (0);
+            p.entry_ = &lookup(l, p.keyHash, sCollisionBit);
+        }
+        return p.found() || add(p, mozilla::Forward<Args>(args)...);
+    }
+
+    void remove(Ptr p)
+    {
+        do { } while (0);
+        mozilla::ReentrancyGuard g(*this);
+        do { } while (0);
+        remove(*p.entry_);
+        checkUnderloaded();
+    }
+
+    void rekeyWithoutRehash(Ptr p, const Lookup& l, const Key& k)
+    {
+        do { } while (0);
+        mozilla::ReentrancyGuard g(*this);
+        do { } while (0);
+        typename HashTableEntry<T>::NonConstT t(mozilla::Move(*p));
+        HashPolicy::setKey(t, const_cast<Key&>(k));
+        remove(*p.entry_);
+        putNewInfallibleInternal(l, mozilla::Move(t));
+    }
+
+    void rekeyAndMaybeRehash(Ptr p, const Lookup& l, const Key& k)
+    {
+        rekeyWithoutRehash(p, l, k);
+        checkOverRemoved();
+    }
+
+
+};
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2
+
+
+
+class JSTracer;
+
+namespace JS {
+class CallbackTracer;
+template <typename T> class Heap;
+template <typename T> class TenuredHeap;
+
+
+const char*
+GCTraceKindToAscii(JS::TraceKind kind);
+
+}
+
+enum WeakMapTraceKind {
+
+
+
+
+    DoNotTraceWeakMaps,
+
+
+
+
+
+    ExpandWeakMaps,
+
+
+
+
+
+    TraceWeakMapValues,
+
+
+
+
+
+    TraceWeakMapKeysValues
+};
+
+class JSTracer
+{
+  public:
+
+    JSRuntime* runtime() const { return runtime_; }
+
+
+    WeakMapTraceKind weakMapAction() const { return weakMapAction_; }
+
+    enum class TracerKindTag {
+
+
+
+        Marking,
+
+
+
+
+
+        WeakMarking,
+
+
+
+        Tenuring,
+
+
+
+        Callback
+    };
+    bool isMarkingTracer() const { return tag_ == TracerKindTag::Marking || tag_ == TracerKindTag::WeakMarking; }
+    bool isWeakMarkingTracer() const { return tag_ == TracerKindTag::WeakMarking; }
+    bool isTenuringTracer() const { return tag_ == TracerKindTag::Tenuring; }
+    bool isCallbackTracer() const { return tag_ == TracerKindTag::Callback; }
+    inline JS::CallbackTracer* asCallbackTracer();
+    bool traceWeakEdges() const { return traceWeakEdges_; }
+
+
+
+
+  protected:
+    JSTracer(JSRuntime* rt, TracerKindTag tag,
+             WeakMapTraceKind weakTraceKind = TraceWeakMapValues)
+      : runtime_(rt)
+      , weakMapAction_(weakTraceKind)
+
+
+
+      , tag_(tag)
+      , traceWeakEdges_(true)
+    {}
+# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
+  private:
+    JSRuntime* runtime_;
+    WeakMapTraceKind weakMapAction_;
+
+
+
+
+  protected:
+    TracerKindTag tag_;
+    bool traceWeakEdges_;
+};
+
+namespace JS {
+
+class AutoTracingName;
+class AutoTracingIndex;
+class AutoTracingCallback;
+
+class CallbackTracer : public JSTracer
+{
+  public:
+    CallbackTracer(JSRuntime* rt, WeakMapTraceKind weakTraceKind = TraceWeakMapValues)
+      : JSTracer(rt, JSTracer::TracerKindTag::Callback, weakTraceKind),
+        contextName_(nullptr), contextIndex_(InvalidIndex), contextFunctor_(nullptr)
+    {}
+    CallbackTracer(JSContext* cx, WeakMapTraceKind weakTraceKind = TraceWeakMapValues);
+
+
+
+
+
+
+    virtual void onObjectEdge(JSObject** objp) { onChild(JS::GCCellPtr(*objp)); }
+    virtual void onStringEdge(JSString** strp) { onChild(JS::GCCellPtr(*strp)); }
+    virtual void onSymbolEdge(JS::Symbol** symp) { onChild(JS::GCCellPtr(*symp)); }
+    virtual void onScriptEdge(JSScript** scriptp) { onChild(JS::GCCellPtr(*scriptp)); }
+    virtual void onShapeEdge(js::Shape** shapep) {
+        onChild(JS::GCCellPtr(*shapep, JS::TraceKind::Shape));
+    }
+    virtual void onObjectGroupEdge(js::ObjectGroup** groupp) {
+        onChild(JS::GCCellPtr(*groupp, JS::TraceKind::ObjectGroup));
+    }
+    virtual void onBaseShapeEdge(js::BaseShape** basep) {
+        onChild(JS::GCCellPtr(*basep, JS::TraceKind::BaseShape));
+    }
+    virtual void onJitCodeEdge(js::jit::JitCode** codep) {
+        onChild(JS::GCCellPtr(*codep, JS::TraceKind::JitCode));
+    }
+    virtual void onLazyScriptEdge(js::LazyScript** lazyp) {
+        onChild(JS::GCCellPtr(*lazyp, JS::TraceKind::LazyScript));
+    }
+    virtual void onScopeEdge(js::Scope** scopep) {
+        onChild(JS::GCCellPtr(*scopep, JS::TraceKind::Scope));
+    }
+    virtual void onRegExpSharedEdge(js::RegExpShared** sharedp) {
+        onChild(JS::GCCellPtr(*sharedp, JS::TraceKind::RegExpShared));
+    }
+
+
+
+    virtual void onChild(const JS::GCCellPtr& thing) = 0;
+# 195 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
+    const char* contextName() const { do { } while (0); return contextName_; }
+
+
+
+
+    const static size_t InvalidIndex = size_t(-1);
+    size_t contextIndex() const { return contextIndex_; }
+
+
+
+
+
+
+    void getTracingEdgeName(char* buffer, size_t bufferSize);
+
+
+
+
+
+
+    class ContextFunctor {
+      public:
+        virtual void operator()(CallbackTracer* trc, char* buf, size_t bufsize) = 0;
+    };
+# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
+    void dispatchToOnEdge(JSObject** objp) { onObjectEdge(objp); }
+    void dispatchToOnEdge(JSString** strp) { onStringEdge(strp); }
+    void dispatchToOnEdge(JS::Symbol** symp) { onSymbolEdge(symp); }
+    void dispatchToOnEdge(JSScript** scriptp) { onScriptEdge(scriptp); }
+    void dispatchToOnEdge(js::Shape** shapep) { onShapeEdge(shapep); }
+    void dispatchToOnEdge(js::ObjectGroup** groupp) { onObjectGroupEdge(groupp); }
+    void dispatchToOnEdge(js::BaseShape** basep) { onBaseShapeEdge(basep); }
+    void dispatchToOnEdge(js::jit::JitCode** codep) { onJitCodeEdge(codep); }
+    void dispatchToOnEdge(js::LazyScript** lazyp) { onLazyScriptEdge(lazyp); }
+    void dispatchToOnEdge(js::Scope** scopep) { onScopeEdge(scopep); }
+    void dispatchToOnEdge(js::RegExpShared** sharedp) { onRegExpSharedEdge(sharedp); }
+
+  protected:
+    void setTraceWeakEdges(bool value) {
+        traceWeakEdges_ = value;
+    }
+
+  private:
+    friend class AutoTracingName;
+    const char* contextName_;
+
+    friend class AutoTracingIndex;
+    size_t contextIndex_;
+
+    friend class AutoTracingDetails;
+    ContextFunctor* contextFunctor_;
+};
+
+
+class AutoTracingName
+{
+    CallbackTracer* trc_;
+    const char* prior_;
+
+  public:
+    AutoTracingName(CallbackTracer* trc, const char* name) : trc_(trc), prior_(trc->contextName_) {
+        do { } while (0);
+        trc->contextName_ = name;
+    }
+    ~AutoTracingName() {
+        do { } while (0);
+        trc_->contextName_ = prior_;
+    }
+};
+
+
+class AutoTracingIndex
+{
+    CallbackTracer* trc_;
+
+  public:
+    explicit AutoTracingIndex(JSTracer* trc, size_t initial = 0) : trc_(nullptr) {
+        if (trc->isCallbackTracer()) {
+            trc_ = trc->asCallbackTracer();
+            do { } while (0);
+            trc_->contextIndex_ = initial;
+        }
+    }
+    ~AutoTracingIndex() {
+        if (trc_) {
+            do { } while (0);
+            trc_->contextIndex_ = CallbackTracer::InvalidIndex;
+        }
+    }
+
+    void operator++() {
+        if (trc_) {
+            do { } while (0);
+            ++trc_->contextIndex_;
+        }
+    }
+};
+
+
+
+class AutoTracingDetails
+{
+    CallbackTracer* trc_;
+
+  public:
+    AutoTracingDetails(JSTracer* trc, CallbackTracer::ContextFunctor& func) : trc_(nullptr) {
+        if (trc->isCallbackTracer()) {
+            trc_ = trc->asCallbackTracer();
+            do { } while (0);
+            trc_->contextFunctor_ = &func;
+        }
+    }
+    ~AutoTracingDetails() {
+        if (trc_) {
+            do { } while (0);
+            trc_->contextFunctor_ = nullptr;
+        }
+    }
+};
+
+}
+
+JS::CallbackTracer*
+JSTracer::asCallbackTracer()
+{
+    do { } while (0);
+    return static_cast<JS::CallbackTracer*>(this);
+}
+
+namespace JS {
+# 350 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
+template <typename T>
+extern void
+TraceEdge(JSTracer* trc, JS::Heap<T>* edgep, const char* name);
+
+extern void
+TraceEdge(JSTracer* trc, JS::TenuredHeap<JSObject*>* edgep, const char* name);
+
+
+
+
+
+
+
+template <typename T>
+extern void
+UnsafeTraceRoot(JSTracer* trc, T* edgep, const char* name);
+
+extern void
+TraceChildren(JSTracer* trc, GCCellPtr thing);
+
+using ZoneSet = js::HashSet<Zone*, js::DefaultHasher<Zone*>, js::SystemAllocPolicy>;
+using CompartmentSet = js::HashSet<JSCompartment*, js::DefaultHasher<JSCompartment*>,
+                                   js::SystemAllocPolicy>;
+
+
+
+
+
+
+extern void
+TraceIncomingCCWs(JSTracer* trc, const JS::CompartmentSet& compartments);
+
+}
+
+extern void
+JS_GetTraceThingInfo(char* buf, size_t bufsize, JSTracer* trc,
+                     void* thing, JS::TraceKind kind, bool includeDetails);
+
+namespace js {
+
+
+
+
+
+
+template <typename T>
+extern void
+UnsafeTraceManuallyBarrieredEdge(JSTracer* trc, T* edgep, const char* name);
+
+namespace gc {
+
+
+template <typename T>
+extern bool
+EdgeNeedsSweep(JS::Heap<T>* edgep);
+
+
+
+template <typename T>
+bool
+IsAboutToBeFinalizedUnbarriered(T* thingp);
+
+}
+}
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 2
+# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h"
+class JSAtom;
+class JSFunction;
+class JSObject;
+class JSScript;
+class JSString;
+namespace JS {
+class Symbol;
+}
+
+namespace JS {
+
+
+
+template <typename T>
+struct StructGCPolicy
+{
+    static T initial() {
+        return T();
+    }
+
+    static void trace(JSTracer* trc, T* tp, const char* name) {
+        tp->trace(trc);
+    }
+
+    static void sweep(T* tp) {
+        return tp->sweep();
+    }
+
+    static bool needsSweep(T* tp) {
+        return tp->needsSweep();
+    }
+};
+
+
+
+
+
+template <typename T> struct GCPolicy : public StructGCPolicy<T> {};
+
+
+template <typename T>
+struct IgnoreGCPolicy {
+    static T initial() { return T(); }
+    static void trace(JSTracer* trc, T* t, const char* name) {}
+    static bool needsSweep(T* v) { return false; }
+};
+template <> struct GCPolicy<uint32_t> : public IgnoreGCPolicy<uint32_t> {};
+template <> struct GCPolicy<uint64_t> : public IgnoreGCPolicy<uint64_t> {};
+
+template <typename T>
+struct GCPointerPolicy
+{
+    static T initial() { return nullptr; }
+    static void trace(JSTracer* trc, T* vp, const char* name) {
+        if (*vp)
+            js::UnsafeTraceManuallyBarrieredEdge(trc, vp, name);
+    }
+    static bool needsSweep(T* vp) {
+        if (*vp)
+            return js::gc::IsAboutToBeFinalizedUnbarriered(vp);
+        return false;
+    }
+};
+template <> struct GCPolicy<JS::Symbol*> : public GCPointerPolicy<JS::Symbol*> {};
+template <> struct GCPolicy<JSAtom*> : public GCPointerPolicy<JSAtom*> {};
+template <> struct GCPolicy<JSFunction*> : public GCPointerPolicy<JSFunction*> {};
+template <> struct GCPolicy<JSObject*> : public GCPointerPolicy<JSObject*> {};
+template <> struct GCPolicy<JSScript*> : public GCPointerPolicy<JSScript*> {};
+template <> struct GCPolicy<JSString*> : public GCPointerPolicy<JSString*> {};
+
+template <typename T>
+struct GCPolicy<JS::Heap<T>>
+{
+    static void trace(JSTracer* trc, JS::Heap<T>* thingp, const char* name) {
+        TraceEdge(trc, thingp, name);
+    }
+    static bool needsSweep(JS::Heap<T>* thingp) {
+        return js::gc::EdgeNeedsSweep(thingp);
+    }
+};
+
+
+template <typename T, typename D>
+struct GCPolicy<mozilla::UniquePtr<T, D>>
+{
+    static mozilla::UniquePtr<T,D> initial() { return mozilla::UniquePtr<T,D>(); }
+    static void trace(JSTracer* trc, mozilla::UniquePtr<T,D>* tp, const char* name) {
+        if (tp->get())
+            GCPolicy<T>::trace(trc, tp->get(), name);
+    }
+    static bool needsSweep(mozilla::UniquePtr<T,D>* tp) {
+        if (tp->get())
+            return GCPolicy<T>::needsSweep(tp->get());
+        return false;
+    }
+};
+
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
+# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+namespace js {
+
+template <typename T>
+struct BarrierMethods {
+};
+
+template <typename Element, typename Wrapper>
+class WrappedPtrOperations {};
+
+template <typename Element, typename Wrapper>
+class MutableWrappedPtrOperations : public WrappedPtrOperations<Element, Wrapper> {};
+
+template <typename T, typename Wrapper>
+class RootedBase : public MutableWrappedPtrOperations<T, Wrapper> {};
+
+template <typename T, typename Wrapper>
+class HandleBase : public WrappedPtrOperations<T, Wrapper> {};
+
+template <typename T, typename Wrapper>
+class MutableHandleBase : public MutableWrappedPtrOperations<T, Wrapper> {};
+
+template <typename T, typename Wrapper>
+class HeapBase : public MutableWrappedPtrOperations<T, Wrapper> {};
+
+
+template <typename T> struct IsHeapConstructibleType { static constexpr bool value = false; };
+
+
+template <> struct IsHeapConstructibleType<JS::Symbol*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSAtom*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSFunction*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSObject*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSScript*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSString*> { static constexpr bool value = true; };
+template <> struct IsHeapConstructibleType<JS::Value> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<jsid> { static constexpr bool value = true; };
+
+
+template <typename T, typename Wrapper>
+class PersistentRootedBase : public MutableWrappedPtrOperations<T, Wrapper> {};
+
+namespace gc {
+struct Cell;
+template<typename T>
+struct PersistentRootedMarker;
+}
+# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+}
+
+namespace JS {
+
+template <typename T> class Rooted;
+template <typename T> class PersistentRooted;
+
+
+bool isGCEnabled();
+
+void HeapObjectPostBarrier(JSObject** objp, JSObject* prev, JSObject* next);
+
+
+
+
+
+
+extern void
+AssertGCThingMustBeTenured(JSObject* obj);
+extern void
+AssertGCThingIsNotAnObjectSubclass(js::gc::Cell* cell);
+# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class Heap : public js::HeapBase<T, Heap<T>>
+{
+
+    static_assert(js::IsHeapConstructibleType<T>::value,
+                  "Type T must be a public GC pointer type");
+  public:
+    using ElementType = T;
+
+    Heap() {
+        static_assert(sizeof(T) == sizeof(Heap<T>),
+                      "Heap<T> must be binary compatible with T.");
+        init(GCPolicy<T>::initial());
+    }
+    explicit Heap(const T& p) { init(p); }
+
+
+
+
+
+
+
+    explicit Heap(const Heap<T>& p) { init(p.ptr); }
+
+    ~Heap() {
+        post(ptr, GCPolicy<T>::initial());
+    }
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    Heap<T>& operator=(const T& p) { set(p); return *this; } Heap<T>& operator=(const Heap<T>& other) { set(other.get()); return *this; };
+
+    const T* address() const { return &ptr; }
+
+    void exposeToActiveJS() const {
+        js::BarrierMethods<T>::exposeToJS(ptr);
+    }
+    const T& get() const {
+        exposeToActiveJS();
+        return ptr;
+    }
+    const T& unbarrieredGet() const {
+        return ptr;
+    }
+
+    T* unsafeGet() { return &ptr; }
+
+    explicit operator bool() const {
+        return bool(js::BarrierMethods<T>::asGCThingOrNull(ptr));
+    }
+    explicit operator bool() {
+        return bool(js::BarrierMethods<T>::asGCThingOrNull(ptr));
+    }
+
+  private:
+    void init(const T& newPtr) {
+        ptr = newPtr;
+        post(GCPolicy<T>::initial(), ptr);
+    }
+
+    void set(const T& newPtr) {
+        T tmp = ptr;
+        ptr = newPtr;
+        post(tmp, ptr);
+    }
+
+    void post(const T& prev, const T& next) {
+        js::BarrierMethods<T>::postBarrier(&ptr, prev, next);
+    }
+
+    T ptr;
+};
+
+static __attribute__((always_inline)) inline bool
+ObjectIsTenured(JSObject* obj)
+{
+    return !js::gc::IsInsideNursery(reinterpret_cast<js::gc::Cell*>(obj));
+}
+
+static __attribute__((always_inline)) inline bool
+ObjectIsTenured(const Heap<JSObject*>& obj)
+{
+    return ObjectIsTenured(obj.unbarrieredGet());
+}
+
+static __attribute__((always_inline)) inline bool
+ObjectIsMarkedGray(JSObject* obj)
+{
+    auto cell = reinterpret_cast<js::gc::Cell*>(obj);
+    return js::gc::detail::CellIsMarkedGrayIfKnown(cell);
+}
+
+static __attribute__((always_inline)) inline bool
+ObjectIsMarkedGray(const JS::Heap<JSObject*>& obj)
+{
+    return ObjectIsMarkedGray(obj.unbarrieredGet());
+}
+# 380 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class TenuredHeap : public js::HeapBase<T, TenuredHeap<T>>
+{
+  public:
+    using ElementType = T;
+
+    TenuredHeap() : bits(0) {
+        static_assert(sizeof(T) == sizeof(TenuredHeap<T>),
+                      "TenuredHeap<T> must be binary compatible with T.");
+    }
+    explicit TenuredHeap(T p) : bits(0) { setPtr(p); }
+    explicit TenuredHeap(const TenuredHeap<T>& p) : bits(0) { setPtr(p.getPtr()); }
+
+    void setPtr(T newPtr) {
+        do { } while (0);
+        if (newPtr)
+            AssertGCThingMustBeTenured(newPtr);
+        bits = (bits & flagsMask) | reinterpret_cast<uintptr_t>(newPtr);
+    }
+
+    void setFlags(uintptr_t flagsToSet) {
+        do { } while (0);
+        bits |= flagsToSet;
+    }
+
+    void unsetFlags(uintptr_t flagsToUnset) {
+        do { } while (0);
+        bits &= ~flagsToUnset;
+    }
+
+    bool hasFlag(uintptr_t flag) const {
+        do { } while (0);
+        return (bits & flag) != 0;
+    }
+
+    T unbarrieredGetPtr() const { return reinterpret_cast<T>(bits & ~flagsMask); }
+    uintptr_t getFlags() const { return bits & flagsMask; }
+
+    void exposeToActiveJS() const {
+        js::BarrierMethods<T>::exposeToJS(unbarrieredGetPtr());
+    }
+    T getPtr() const {
+        exposeToActiveJS();
+        return unbarrieredGetPtr();
+    }
+
+    operator T() const { return getPtr(); }
+    T operator->() const { return getPtr(); }
+
+    explicit operator bool() const {
+        return bool(js::BarrierMethods<T>::asGCThingOrNull(unbarrieredGetPtr()));
+    }
+    explicit operator bool() {
+        return bool(js::BarrierMethods<T>::asGCThingOrNull(unbarrieredGetPtr()));
+    }
+
+    TenuredHeap<T>& operator=(T p) {
+        setPtr(p);
+        return *this;
+    }
+
+    TenuredHeap<T>& operator=(const TenuredHeap<T>& other) {
+        bits = other.bits;
+        return *this;
+    }
+
+  private:
+    enum {
+        maskBits = 3,
+        flagsMask = (1 << maskBits) - 1,
+    };
+
+    uintptr_t bits;
+};
+# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class Handle : public js::HandleBase<T, Handle<T>>
+{
+    friend class JS::MutableHandle<T>;
+
+  public:
+    using ElementType = T;
+
+
+    template <typename S>
+                 Handle(Handle<S> handle,
+                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0)
+    {
+        static_assert(sizeof(Handle<T>) == sizeof(T*),
+                      "Handle must be binary compatible with T*.");
+        ptr = reinterpret_cast<const T*>(handle.address());
+    }
+
+                 Handle(decltype(nullptr)) {
+        static_assert(mozilla::IsPointer<T>::value,
+                      "nullptr_t overload not valid for non-pointer types");
+        static void* const ConstNullValue = nullptr;
+        ptr = reinterpret_cast<const T*>(&ConstNullValue);
+    }
+
+                 Handle(MutableHandle<T> handle) {
+        ptr = handle.address();
+    }
+# 507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+    static constexpr Handle fromMarkedLocation(const T* p) {
+        return Handle(p, DeliberatelyChoosingThisOverload,
+                      ImUsingThisOnlyInFromFromMarkedLocation);
+    }
+
+
+
+
+
+    template <typename S>
+    inline
+                 Handle(const Rooted<S>& root,
+                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
+
+    template <typename S>
+    inline
+                 Handle(const PersistentRooted<S>& root,
+                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
+
+
+    template <typename S>
+    inline
+                 Handle(MutableHandle<S>& root,
+                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
+
+  private:
+    Handle() {}
+    template <typename S> Handle<T>& operator=(S) = delete; Handle<T>& operator=(const Handle<T>&) = delete;;
+
+    enum Disambiguator { DeliberatelyChoosingThisOverload = 42 };
+    enum CallerIdentity { ImUsingThisOnlyInFromFromMarkedLocation = 17 };
+    constexpr Handle(const T* p, Disambiguator, CallerIdentity) : ptr(p) {}
+
+    const T* ptr;
+};
+# 554 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class MutableHandle : public js::MutableHandleBase<T, MutableHandle<T>>
+{
+  public:
+    using ElementType = T;
+
+    inline MutableHandle(Rooted<T>* root);
+    inline MutableHandle(PersistentRooted<T>* root);
+
+  private:
+
+    MutableHandle(decltype(nullptr)) = delete;
+
+  public:
+    void set(const T& v) {
+        *ptr = v;
+    }
+# 579 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+    static MutableHandle fromMarkedLocation(T* p) {
+        MutableHandle h;
+        h.ptr = p;
+        return h;
+    }
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
+    T* address() { return &(*ptr); } T& get() { return (*ptr); };
+
+  private:
+    MutableHandle() {}
+    template <typename S> MutableHandle<T>& operator=(S) = delete; MutableHandle<T>& operator=(const MutableHandle<T>&) = delete;;
+
+    T* ptr;
+};
+
+}
+
+namespace js {
+
+template <typename T>
+struct BarrierMethods<T*>
+{
+    static T* initial() { return nullptr; }
+    static gc::Cell* asGCThingOrNull(T* v) {
+        if (!v)
+            return nullptr;
+        do { } while (0);
+        return reinterpret_cast<gc::Cell*>(v);
+    }
+    static void postBarrier(T** vp, T* prev, T* next) {
+        if (next)
+            JS::AssertGCThingIsNotAnObjectSubclass(reinterpret_cast<js::gc::Cell*>(next));
+    }
+    static void exposeToJS(T* t) {
+        if (t)
+            js::gc::ExposeGCThingToActiveJS(JS::GCCellPtr(t));
+    }
+};
+
+template <>
+struct BarrierMethods<JSObject*>
+{
+    static JSObject* initial() { return nullptr; }
+    static gc::Cell* asGCThingOrNull(JSObject* v) {
+        if (!v)
+            return nullptr;
+        do { } while (0);
+        return reinterpret_cast<gc::Cell*>(v);
+    }
+    static void postBarrier(JSObject** vp, JSObject* prev, JSObject* next) {
+        JS::HeapObjectPostBarrier(vp, prev, next);
+    }
+    static void exposeToJS(JSObject* obj) {
+        if (obj)
+            JS::ExposeObjectToActiveJS(obj);
+    }
+};
+
+template <>
+struct BarrierMethods<JSFunction*>
+{
+    static JSFunction* initial() { return nullptr; }
+    static gc::Cell* asGCThingOrNull(JSFunction* v) {
+        if (!v)
+            return nullptr;
+        do { } while (0);
+        return reinterpret_cast<gc::Cell*>(v);
+    }
+    static void postBarrier(JSFunction** vp, JSFunction* prev, JSFunction* next) {
+        JS::HeapObjectPostBarrier(reinterpret_cast<JSObject**>(vp),
+                                  reinterpret_cast<JSObject*>(prev),
+                                  reinterpret_cast<JSObject*>(next));
+    }
+    static void exposeToJS(JSFunction* fun) {
+        if (fun)
+            JS::ExposeObjectToActiveJS(reinterpret_cast<JSObject*>(fun));
+    }
+};
+# 671 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+struct MovableCellHasher
+{
+    using Key = T;
+    using Lookup = T;
+
+    static bool hasHash(const Lookup& l);
+    static bool ensureHash(const Lookup& l);
+    static HashNumber hash(const Lookup& l);
+    static bool match(const Key& k, const Lookup& l);
+    static void rekey(Key& k, const Key& newKey) { k = newKey; }
+};
+
+template <typename T>
+struct MovableCellHasher<JS::Heap<T>>
+{
+    using Key = JS::Heap<T>;
+    using Lookup = T;
+
+    static bool hasHash(const Lookup& l) { return MovableCellHasher<T>::hasHash(l); }
+    static bool ensureHash(const Lookup& l) { return MovableCellHasher<T>::ensureHash(l); }
+    static HashNumber hash(const Lookup& l) { return MovableCellHasher<T>::hash(l); }
+    static bool match(const Key& k, const Lookup& l) {
+        return MovableCellHasher<T>::match(k.unbarrieredGet(), l);
+    }
+    static void rekey(Key& k, const Key& newKey) { k.unsafeSet(newKey); }
+};
+
+template <typename T>
+struct FallibleHashMethods<MovableCellHasher<T>>
+{
+    template <typename Lookup> static bool hasHash(Lookup&& l) {
+        return MovableCellHasher<T>::hasHash(mozilla::Forward<Lookup>(l));
+    }
+    template <typename Lookup> static bool ensureHash(Lookup&& l) {
+        return MovableCellHasher<T>::ensureHash(mozilla::Forward<Lookup>(l));
+    }
+};
+
+}
+
+namespace js {
+# 722 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class alignas(8) DispatchWrapper
+{
+    static_assert(JS::MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
+                  "DispatchWrapper is intended only for usage with a Traceable");
+
+    using TraceFn = void (*)(JSTracer*, T*, const char*);
+    TraceFn tracer;
+    alignas(gc::CellSize) T storage;
+
+  public:
+    template <typename U>
+                 DispatchWrapper(U&& initial)
+      : tracer(&JS::GCPolicy<T>::trace),
+        storage(mozilla::Forward<U>(initial))
+    { }
+
+
+    T* operator &() { return &storage; }
+    const T* operator &() const { return &storage; }
+    operator T&() { return storage; }
+    operator const T&() const { return storage; }
+
+
+
+    static void TraceWrapped(JSTracer* trc, T* thingp, const char* name) {
+        auto wrapper = reinterpret_cast<DispatchWrapper*>(
+                           uintptr_t(thingp) - __builtin_offsetof(DispatchWrapper, storage));
+        wrapper->tracer(trc, &wrapper->storage, name);
+    }
+};
+
+}
+
+namespace JS {
+# 766 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+class Rooted : public js::RootedBase<T, Rooted<T>>
+{
+    inline void registerWithRootLists(RootedListHeads& roots) {
+        this->stack = &roots[JS::MapTypeToRootKind<T>::kind];
+        this->prev = *stack;
+        *stack = reinterpret_cast<Rooted<void*>*>(this);
+    }
+
+    inline RootedListHeads& rootLists(RootingContext* cx) {
+        return cx->stackRoots_;
+    }
+    inline RootedListHeads& rootLists(JSContext* cx) {
+        return rootLists(RootingContext::get(cx));
+    }
+
+  public:
+    using ElementType = T;
+
+    template <typename RootingContext>
+    explicit Rooted(const RootingContext& cx)
+      : ptr(GCPolicy<T>::initial())
+    {
+        registerWithRootLists(rootLists(cx));
+    }
+
+    template <typename RootingContext, typename S>
+    Rooted(const RootingContext& cx, S&& initial)
+      : ptr(mozilla::Forward<S>(initial))
+    {
+        registerWithRootLists(rootLists(cx));
+    }
+
+    ~Rooted() {
+        do { } while (0);
+        *stack = prev;
+    }
+
+    Rooted<T>* previous() { return reinterpret_cast<Rooted<T>*>(prev); }
+
+
+
+
+
+    void set(const T& value) {
+        ptr = value;
+    }
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    Rooted<T>& operator=(const T& p) { set(p); return *this; } Rooted<T>& operator=(const Rooted<T>& other) { set(other.get()); return *this; };
+    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
+    T* address() { return &(ptr); } T& get() { return (ptr); };
+
+  private:
+
+
+
+
+
+    Rooted<void*>** stack;
+    Rooted<void*>* prev;
+# 836 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+    using MaybeWrapped = typename mozilla::Conditional<
+        MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
+        js::DispatchWrapper<T>,
+        T>::Type;
+    MaybeWrapped ptr;
+
+    Rooted(const Rooted&) = delete;
+} ;
+
+}
+
+namespace js {
+# 859 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename Container>
+class RootedBase<JSObject*, Container> : public MutableWrappedPtrOperations<JSObject*, Container>
+{
+  public:
+    template <class U>
+    JS::Handle<U*> as() const;
+};
+# 877 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename Container>
+class HandleBase<JSObject*, Container> : public WrappedPtrOperations<JSObject*, Container>
+{
+  public:
+    template <class U>
+    JS::Handle<U*> as() const;
+};
+
+
+template <typename T>
+class FakeRooted : public RootedBase<T, FakeRooted<T>>
+{
+  public:
+    using ElementType = T;
+
+    template <typename CX>
+    explicit FakeRooted(CX* cx) : ptr(JS::GCPolicy<T>::initial()) {}
+
+    template <typename CX>
+    FakeRooted(CX* cx, T initial) : ptr(initial) {}
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    FakeRooted<T>& operator=(const T& p) { set(p); return *this; } FakeRooted<T>& operator=(const FakeRooted<T>& other) { set(other.get()); return *this; };
+    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
+    T* address() { return &(ptr); } T& get() { return (ptr); };
+
+  private:
+    T ptr;
+
+    void set(const T& value) {
+        ptr = value;
+    }
+
+    FakeRooted(const FakeRooted&) = delete;
+};
+
+
+template <typename T>
+class FakeMutableHandle : public js::MutableHandleBase<T, FakeMutableHandle<T>>
+{
+  public:
+    using ElementType = T;
+
+                 FakeMutableHandle(T* t) {
+        ptr = t;
+    }
+
+                 FakeMutableHandle(FakeRooted<T>* root) {
+        ptr = root->address();
+    }
+
+    void set(const T& v) {
+        *ptr = v;
+    }
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
+    T* address() { return &(*ptr); } T& get() { return (*ptr); };
+
+  private:
+    FakeMutableHandle() {}
+    template <typename S> FakeMutableHandle<T>& operator=(S) = delete; FakeMutableHandle<T>& operator=(const FakeMutableHandle<T>&) = delete;;
+
+    T* ptr;
+};
+# 952 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+enum AllowGC {
+    NoGC = 0,
+    CanGC = 1
+};
+template <typename T, AllowGC allowGC>
+class MaybeRooted
+{
+};
+
+template <typename T> class MaybeRooted<T, CanGC>
+{
+  public:
+    typedef JS::Handle<T> HandleType;
+    typedef JS::Rooted<T> RootType;
+    typedef JS::MutableHandle<T> MutableHandleType;
+
+    static inline JS::Handle<T> toHandle(HandleType v) {
+        return v;
+    }
+
+    static inline JS::MutableHandle<T> toMutableHandle(MutableHandleType v) {
+        return v;
+    }
+
+    template <typename T2>
+    static inline JS::Handle<T2*> downcastHandle(HandleType v) {
+        return v.template as<T2>();
+    }
+};
+
+template <typename T> class MaybeRooted<T, NoGC>
+{
+  public:
+    typedef const T& HandleType;
+    typedef FakeRooted<T> RootType;
+    typedef FakeMutableHandle<T> MutableHandleType;
+
+    static JS::Handle<T> toHandle(HandleType v) {
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 990; ::abort(); } while (0); } while (0);
+    }
+
+    static JS::MutableHandle<T> toMutableHandle(MutableHandleType v) {
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 994; ::abort(); } while (0); } while (0);
+    }
+
+    template <typename T2>
+    static inline T2* downcastHandle(HandleType v) {
+        return &v->template as<T2>();
+    }
+};
+
+}
+
+namespace JS {
+
+template <typename T> template <typename S>
+inline
+Handle<T>::Handle(const Rooted<S>& root,
+                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
+{
+    ptr = reinterpret_cast<const T*>(root.address());
+}
+
+template <typename T> template <typename S>
+inline
+Handle<T>::Handle(const PersistentRooted<S>& root,
+                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
+{
+    ptr = reinterpret_cast<const T*>(root.address());
+}
+
+template <typename T> template <typename S>
+inline
+Handle<T>::Handle(MutableHandle<S>& root,
+                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
+{
+    ptr = reinterpret_cast<const T*>(root.address());
+}
+
+template <typename T>
+inline
+MutableHandle<T>::MutableHandle(Rooted<T>* root)
+{
+    static_assert(sizeof(MutableHandle<T>) == sizeof(T*),
+                  "MutableHandle must be binary compatible with T*.");
+    ptr = root->address();
+}
+
+template <typename T>
+inline
+MutableHandle<T>::MutableHandle(PersistentRooted<T>* root)
+{
+    static_assert(sizeof(MutableHandle<T>) == sizeof(T*),
+                  "MutableHandle must be binary compatible with T*.");
+    ptr = root->address();
+}
+
+void
+AddPersistentRoot(RootingContext* cx, RootKind kind, PersistentRooted<void*>* root);
+# 1086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template<typename T>
+class PersistentRooted : public js::RootedBase<T, PersistentRooted<T>>,
+                         private mozilla::LinkedListElement<PersistentRooted<T>>
+{
+    using ListBase = mozilla::LinkedListElement<PersistentRooted<T>>;
+
+    friend class mozilla::LinkedList<PersistentRooted>;
+    friend class mozilla::LinkedListElement<PersistentRooted>;
+
+    void registerWithRootLists(RootingContext* cx) {
+        do { } while (0);
+        JS::RootKind kind = JS::MapTypeToRootKind<T>::kind;
+        AddPersistentRoot(cx, kind, reinterpret_cast<JS::PersistentRooted<void*>*>(this));
+    }
+
+  public:
+    using ElementType = T;
+
+    PersistentRooted() : ptr(GCPolicy<T>::initial()) {}
+
+    explicit PersistentRooted(RootingContext* cx)
+      : ptr(GCPolicy<T>::initial())
+    {
+        registerWithRootLists(cx);
+    }
+
+    explicit PersistentRooted(JSContext* cx)
+      : ptr(GCPolicy<T>::initial())
+    {
+        registerWithRootLists(RootingContext::get(cx));
+    }
+
+    template <typename U>
+    PersistentRooted(RootingContext* cx, U&& initial)
+      : ptr(mozilla::Forward<U>(initial))
+    {
+        registerWithRootLists(cx);
+    }
+
+    template <typename U>
+    PersistentRooted(JSContext* cx, U&& initial)
+      : ptr(mozilla::Forward<U>(initial))
+    {
+        registerWithRootLists(RootingContext::get(cx));
+    }
+
+    PersistentRooted(const PersistentRooted& rhs)
+      : mozilla::LinkedListElement<PersistentRooted<T>>(),
+        ptr(rhs.ptr)
+    {
+# 1144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+        const_cast<PersistentRooted&>(rhs).setNext(this);
+    }
+
+    bool initialized() {
+        return ListBase::isInList();
+    }
+
+    void init(JSContext* cx) {
+        init(cx, GCPolicy<T>::initial());
+    }
+
+    template <typename U>
+    void init(JSContext* cx, U&& initial) {
+        ptr = mozilla::Forward<U>(initial);
+        registerWithRootLists(RootingContext::get(cx));
+    }
+
+    void reset() {
+        if (initialized()) {
+            set(GCPolicy<T>::initial());
+            ListBase::remove();
+        }
+    }
+
+    operator const T&() const { return get(); } const T& operator->() const { return get(); };
+    PersistentRooted<T>& operator=(const T& p) { set(p); return *this; } PersistentRooted<T>& operator=(const PersistentRooted<T>& other) { set(other.get()); return *this; };
+    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
+
+
+
+
+    T* address() {
+        do { } while (0);
+        return &ptr;
+    }
+    T& get() {
+        do { } while (0);
+        return ptr;
+    }
+
+  private:
+    template <typename U>
+    void set(U&& value) {
+        do { } while (0);
+        ptr = mozilla::Forward<U>(value);
+    }
+
+
+    using MaybeWrapped = typename mozilla::Conditional<
+        MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
+        js::DispatchWrapper<T>,
+        T>::Type;
+    MaybeWrapped ptr;
+} ;
+
+class ObjectPtr
+{
+    Heap<JSObject*> value;
+
+  public:
+    using ElementType = JSObject*;
+
+    ObjectPtr() : value(nullptr) {}
+
+    explicit ObjectPtr(JSObject* obj) : value(obj) {}
+
+
+    ~ObjectPtr() { do { } while (0); }
+
+    void finalize(JSRuntime* rt);
+    void finalize(JSContext* cx);
+
+    void init(JSObject* obj) { value = obj; }
+
+    JSObject* get() const { return value; }
+    JSObject* unbarrieredGet() const { return value.unbarrieredGet(); }
+
+    void writeBarrierPre(JSContext* cx) {
+        IncrementalPreWriteBarrier(value);
+    }
+
+    void updateWeakPointerAfterGC();
+
+    ObjectPtr& operator=(JSObject* obj) {
+        IncrementalPreWriteBarrier(value);
+        value = obj;
+        return *this;
+    }
+
+    void trace(JSTracer* trc, const char* name);
+
+    JSObject& operator*() const { return *value; }
+    JSObject* operator->() const { return value; }
+    operator JSObject*() const { return value; }
+
+    explicit operator bool() const { return value.unbarrieredGet(); }
+    explicit operator bool() { return value.unbarrieredGet(); }
+};
+
+}
+
+namespace js {
+
+template <typename T, typename D, typename Container>
+class WrappedPtrOperations<UniquePtr<T, D>, Container>
+{
+    const UniquePtr<T, D>& uniquePtr() const { return static_cast<const Container*>(this)->get(); }
+
+  public:
+    explicit operator bool() const { return !!uniquePtr(); }
+};
+
+template <typename T, typename D, typename Container>
+class MutableWrappedPtrOperations<UniquePtr<T, D>, Container>
+  : public WrappedPtrOperations<UniquePtr<T, D>, Container>
+{
+    UniquePtr<T, D>& uniquePtr() { return static_cast<Container*>(this)->get(); }
+
+  public:
+    __attribute__ ((warn_unused_result)) typename UniquePtr<T, D>::Pointer release() { return uniquePtr().release(); }
+};
+
+namespace gc {
+
+template <typename T, typename TraceCallbacks>
+void
+CallTraceCallbackOnNonHeap(T* v, const TraceCallbacks& aCallbacks, const char* aName, void* aClosure)
+{
+    static_assert(sizeof(T) == sizeof(JS::Heap<T>), "T and Heap<T> must be compatible.");
+    do { } while (0);
+    mozilla::DebugOnly<Cell*> cell = BarrierMethods<T>::asGCThingOrNull(*v);
+    do { } while (0);
+    do { } while (0);
+    JS::Heap<T>* asHeapT = reinterpret_cast<JS::Heap<T>*>(v);
+    aCallbacks.Trace(asHeapT, aName, aClosure);
+}
+
+}
+}
+
+
+
+namespace mozilla {
+
+template <typename T>
+inline void
+Swap(JS::Heap<T>& aX, JS::Heap<T>& aY)
+{
+    T tmp = aX;
+    aX = aY;
+    aY = tmp;
+}
+
+template <typename T>
+inline void
+Swap(JS::TenuredHeap<T>& aX, JS::TenuredHeap<T>& aY)
+{
+    T tmp = aX;
+    aX = aY;
+    aY = tmp;
+}
+
+}
+
+namespace js {
+namespace detail {
+# 1320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T>
+struct DefineComparisonOps : mozilla::FalseType {};
+
+template <typename T>
+struct DefineComparisonOps<JS::Heap<T>> : mozilla::TrueType {
+    static const T& get(const JS::Heap<T>& v) { return v.unbarrieredGet(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<JS::TenuredHeap<T>> : mozilla::TrueType {
+    static const T get(const JS::TenuredHeap<T>& v) { return v.unbarrieredGetPtr(); }
+};
+
+template <>
+struct DefineComparisonOps<JS::ObjectPtr> : mozilla::TrueType {
+    static const JSObject* get(const JS::ObjectPtr& v) { return v.unbarrieredGet(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<JS::Rooted<T>> : mozilla::TrueType {
+    static const T& get(const JS::Rooted<T>& v) { return v.get(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<JS::Handle<T>> : mozilla::TrueType {
+    static const T& get(const JS::Handle<T>& v) { return v.get(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<JS::MutableHandle<T>> : mozilla::TrueType {
+    static const T& get(const JS::MutableHandle<T>& v) { return v.get(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<JS::PersistentRooted<T>> : mozilla::TrueType {
+    static const T& get(const JS::PersistentRooted<T>& v) { return v.get(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<js::FakeRooted<T>> : mozilla::TrueType {
+    static const T& get(const js::FakeRooted<T>& v) { return v.get(); }
+};
+
+template <typename T>
+struct DefineComparisonOps<js::FakeMutableHandle<T>> : mozilla::TrueType {
+    static const T& get(const js::FakeMutableHandle<T>& v) { return v.get(); }
+};
+
+}
+}
+# 1378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
+template <typename T, typename U>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           js::detail::DefineComparisonOps<U>::value, bool>::Type
+operator==(const T& a, const U& b) {
+    return js::detail::DefineComparisonOps<T>::get(a) == js::detail::DefineComparisonOps<U>::get(b);
+}
+
+template <typename T, typename U>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           js::detail::DefineComparisonOps<U>::value, bool>::Type
+operator!=(const T& a, const U& b) {
+    return !(a == b);
+}
+
+
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
+operator==(const T& a, const typename T::ElementType& b) {
+    return js::detail::DefineComparisonOps<T>::get(a) == b;
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
+operator!=(const T& a, const typename T::ElementType& b) {
+    return !(a == b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
+operator==(const typename T::ElementType& a, const T& b) {
+    return a == js::detail::DefineComparisonOps<T>::get(b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
+operator!=(const typename T::ElementType& a, const T& b) {
+    return !(a == b);
+}
+
+
+
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator==(const typename mozilla::RemovePointer<typename T::ElementType>::Type* a, const T& b) {
+    return a == js::detail::DefineComparisonOps<T>::get(b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator!=(const typename mozilla::RemovePointer<typename T::ElementType>::Type* a, const T& b) {
+    return !(a == b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator==(const T& a, const typename mozilla::RemovePointer<typename T::ElementType>::Type* b) {
+    return js::detail::DefineComparisonOps<T>::get(a) == b;
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator!=(const T& a, const typename mozilla::RemovePointer<typename T::ElementType>::Type* b) {
+    return !(a == b);
+}
+
+
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator==(std::nullptr_t a, const T& b) {
+    return a == js::detail::DefineComparisonOps<T>::get(b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator!=(std::nullptr_t a, const T& b) {
+    return !(a == b);
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator==(const T& a, std::nullptr_t b) {
+    return js::detail::DefineComparisonOps<T>::get(a) == b;
+}
+
+template <typename T>
+typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
+                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
+operator!=(const T& a, std::nullptr_t b) {
+    return !(a == b);
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 2
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+class nsCycleCollectionISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+};
+
+template<typename T> struct nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc61eac14, 0x5f7a, 0x4481, { 0x96, 0x5e, 0x7e, 0xaa, 0x6e, 0xff, 0xa8, 0x5f } };
+
+
+namespace JS {
+template<class T> class Heap;
+}
+
+
+
+
+
+
+struct TraceCallbacks
+{
+  virtual void Trace(JS::Heap<JS::Value>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::Heap<jsid>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::Heap<JSObject*>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JSObject** aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::TenuredHeap<JSObject*>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::Heap<JSString*>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::Heap<JSScript*>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+  virtual void Trace(JS::Heap<JSFunction*>* aPtr, const char* aName,
+                     void* aClosure) const = 0;
+};
+
+
+
+
+
+struct TraceCallbackFunc : public TraceCallbacks
+{
+  typedef void (*Func)(JS::GCCellPtr aPtr, const char* aName, void* aClosure);
+
+  explicit TraceCallbackFunc(Func aCb) : mCallback(aCb) {}
+
+  virtual void Trace(JS::Heap<JS::Value>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::Heap<jsid>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::Heap<JSObject*>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JSObject** aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::TenuredHeap<JSObject*>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::Heap<JSString*>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::Heap<JSScript*>* aPtr, const char* aName,
+                     void* aClosure) const override;
+  virtual void Trace(JS::Heap<JSFunction*>* aPtr, const char* aName,
+                     void* aClosure) const override;
+
+private:
+  Func mCallback;
+};
+
+
+
+
+class nsCycleCollectionParticipant
+{
+public:
+  constexpr explicit nsCycleCollectionParticipant(bool aSkip,
+                                                  bool aTraverseShouldTrace = false)
+    : mMightSkip(aSkip)
+    , mTraverseShouldTrace(aTraverseShouldTrace)
+  {
+  }
+
+  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb) = 0;
+
+  nsresult TraverseNativeAndJS(void* aPtr,
+                               nsCycleCollectionTraversalCallback& aCb)
+  {
+    nsresult rv = TraverseNative(aPtr, aCb);
+    if (mTraverseShouldTrace) {
+
+
+      TraceCallbackFunc noteJsChild(&nsCycleCollectionParticipant::NoteJSChild);
+      Trace(aPtr, noteJsChild, &aCb);
+    }
+    return rv;
+  }
+
+
+  static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName,
+                          void* aClosure);
+
+  virtual void Root(void* aPtr) = 0;
+  virtual void Unlink(void* aPtr) = 0;
+  virtual void Unroot(void* aPtr) = 0;
+  virtual const char* ClassName() = 0;
+
+  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
+                          void* aClosure) {}
+# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+  bool CanSkip(void* aPtr, bool aRemovingAllowed)
+  {
+    return mMightSkip ? CanSkipReal(aPtr, aRemovingAllowed) : false;
+  }
+# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+  bool CanSkipInCC(void* aPtr)
+  {
+    return mMightSkip ? CanSkipInCCReal(aPtr) : false;
+  }
+# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+  bool CanSkipThis(void* aPtr)
+  {
+    return mMightSkip ? CanSkipThisReal(aPtr) : false;
+  }
+
+  virtual void DeleteCycleCollectable(void* aPtr) = 0;
+
+protected:
+  virtual bool CanSkipReal(void* aPtr, bool aRemovingAllowed)
+  {
+    do { } while(0);
+    return false;
+  }
+  virtual bool CanSkipInCCReal(void* aPtr)
+  {
+    do { } while(0);
+    return false;
+  }
+  virtual bool CanSkipThisReal(void* aPtr)
+  {
+    do { } while(0);
+    return false;
+  }
+
+private:
+  const bool mMightSkip;
+  const bool mTraverseShouldTrace;
+};
+
+class nsScriptObjectTracer : public nsCycleCollectionParticipant
+{
+public:
+  constexpr explicit nsScriptObjectTracer(bool aSkip)
+    : nsCycleCollectionParticipant(aSkip, true)
+  {
+  }
+
+  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
+                          void* aClosure) override = 0;
+
+};
+
+class nsXPCOMCycleCollectionParticipant : public nsScriptObjectTracer
+{
+public:
+  constexpr explicit nsXPCOMCycleCollectionParticipant(bool aSkip)
+    : nsScriptObjectTracer(aSkip)
+  {
+  }
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  virtual void Root(void* aPtr) override;
+  virtual void Unroot(void* aPtr) override;
+
+  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
+                          void* aClosure) override;
+
+  static bool CheckForRightISupports(nsISupports* aSupports);
+};
+
+template<typename T> struct nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x9674489b, 0x1f6f, 0x4550, { 0xa7, 0x30, 0xcc, 0xae, 0xdd, 0x10, 0x4c, 0xf9 } };
+# 341 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
+template<typename T,
+         bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
+struct DowncastCCParticipantImpl
+{
+};
+
+
+template<typename T>
+struct DowncastCCParticipantImpl<T, true>
+{
+  static T* Run(void* aPtr)
+  {
+    nsISupports* s = static_cast<nsISupports*>(aPtr);
+    do { } while (0);
+
+    T* rval = T::cycleCollection::Downcast(s);
+                                        ;
+    return rval;
+  }
+};
+
+
+template<typename T>
+struct DowncastCCParticipantImpl<T, false>
+{
+  static T* Run(void* aPtr) { return static_cast<T*>(aPtr); }
+};
+
+template<typename T>
+T*
+DowncastCCParticipant(void* aPtr)
+{
+  return DowncastCCParticipantImpl<T>::Run(aPtr);
+}
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h"
+static const int32_t kNameSpaceID_None = 0;
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h"
+namespace mozilla {
+namespace detail {
+
+class nsStringRepr;
+class nsCStringRepr;
+
+}
+}
+
+
+
+
+
+class nsAString;
+class nsSubstringTuple;
+class nsString;
+class nsAutoString;
+class nsDependentString;
+class nsDependentSubstring;
+class nsPromiseFlatString;
+class nsStringComparator;
+class nsDefaultStringComparator;
+class nsXPIDLString;
+
+
+
+
+
+
+class nsACString;
+class nsCSubstringTuple;
+class nsCString;
+class nsAutoCString;
+class nsDependentCString;
+class nsDependentCSubstring;
+class nsPromiseFlatCString;
+class nsCStringComparator;
+class nsDefaultCStringComparator;
+class nsXPIDLCString;
+
+
+
+
+
+
+typedef nsAString nsSubstring;
+typedef nsACString nsCSubstring;
+
+typedef nsString nsAFlatString;
+typedef nsSubstring nsASingleFragmentString;
+
+typedef nsCString nsAFlatCString;
+typedef nsCSubstring nsASingleFragmentCString;
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h"
+template <class CharT>
+class nsReadingIterator
+{
+public:
+  typedef nsReadingIterator<CharT> self_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef CharT value_type;
+  typedef const CharT* pointer;
+  typedef const CharT& reference;
+
+private:
+  friend class mozilla::detail::nsStringRepr;
+  friend class mozilla::detail::nsCStringRepr;
+
+
+
+
+
+
+  const CharT* mStart;
+  const CharT* mEnd;
+  const CharT* mPosition;
+
+public:
+  nsReadingIterator()
+  {
+  }
+
+
+
+  pointer get() const
+  {
+    return mPosition;
+  }
+
+  CharT operator*() const
+  {
+    return *get();
+  }
+
+  self_type& operator++()
+  {
+    ++mPosition;
+    return *this;
+  }
+
+  self_type operator++(int)
+  {
+    self_type result(*this);
+    ++mPosition;
+    return result;
+  }
+
+  self_type& operator--()
+  {
+    --mPosition;
+    return *this;
+  }
+
+  self_type operator--(int)
+  {
+    self_type result(*this);
+    --mPosition;
+    return result;
+  }
+
+  self_type& advance(difference_type aN)
+  {
+    if (aN > 0) {
+      difference_type step = XPCOM_MIN(aN, mEnd - mPosition);
+
+      do { } while(0);
+
+
+      mPosition += step;
+    } else if (aN < 0) {
+      difference_type step = XPCOM_MAX(aN, -(mPosition - mStart));
+
+      do { } while(0);
+
+
+      mPosition += step;
+    }
+    return *this;
+  }
+
+
+
+
+
+
+  size_type operator-(const self_type& aOther) const
+  {
+    do { } while (0);
+    return mPosition - aOther.mPosition;
+  }
+};
+
+
+
+
+
+template <class CharT>
+class nsWritingIterator
+{
+public:
+  typedef nsWritingIterator<CharT> self_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef CharT value_type;
+  typedef CharT* pointer;
+  typedef CharT& reference;
+
+private:
+  friend class nsAString;
+  friend class nsACString;
+
+
+
+
+
+
+  CharT* mStart;
+  CharT* mEnd;
+  CharT* mPosition;
+
+public:
+  nsWritingIterator()
+  {
+  }
+
+
+
+  pointer get() const
+  {
+    return mPosition;
+  }
+
+  reference operator*() const
+  {
+    return *get();
+  }
+
+  self_type& operator++()
+  {
+    ++mPosition;
+    return *this;
+  }
+
+  self_type operator++(int)
+  {
+    self_type result(*this);
+    ++mPosition;
+    return result;
+  }
+
+  self_type& operator--()
+  {
+    --mPosition;
+    return *this;
+  }
+
+  self_type operator--(int)
+  {
+    self_type result(*this);
+    --mPosition;
+    return result;
+  }
+
+  self_type& advance(difference_type aN)
+  {
+    if (aN > 0) {
+      difference_type step = XPCOM_MIN(aN, mEnd - mPosition);
+
+      do { } while(0);
+
+
+      mPosition += step;
+    } else if (aN < 0) {
+      difference_type step = XPCOM_MAX(aN, -(mPosition - mStart));
+
+      do { } while(0);
+
+
+      mPosition += step;
+    }
+    return *this;
+  }
+
+
+
+
+
+
+  size_type operator-(const self_type& aOther) const
+  {
+    do { } while (0);
+    return mPosition - aOther.mPosition;
+  }
+};
+
+template <class CharT>
+struct nsCharSinkTraits<nsWritingIterator<CharT>>
+{
+  static void
+  write(nsWritingIterator<CharT>& aIter, const CharT* aStr, uint32_t aN)
+  {
+    nsCharTraits<CharT>::move(aIter.get(), aStr, aN);
+    aIter.advance(aN);
+  }
+};
+
+template <class CharT>
+inline bool
+operator==(const nsReadingIterator<CharT>& aLhs,
+           const nsReadingIterator<CharT>& aRhs)
+{
+  return aLhs.get() == aRhs.get();
+}
+
+template <class CharT>
+inline bool
+operator!=(const nsReadingIterator<CharT>& aLhs,
+           const nsReadingIterator<CharT>& aRhs)
+{
+  return aLhs.get() != aRhs.get();
+}
+
+
+
+
+
+
+template <class CharT>
+inline bool
+operator==(const nsWritingIterator<CharT>& aLhs,
+           const nsWritingIterator<CharT>& aRhs)
+{
+  return aLhs.get() == aRhs.get();
+}
+
+template <class CharT>
+inline bool
+operator!=(const nsWritingIterator<CharT>& aLhs,
+           const nsWritingIterator<CharT>& aRhs)
+{
+  return aLhs.get() != aRhs.get();
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 1
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 1 3
+# 30 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 3
+# 1 "/usr/include/inttypes.h" 1 3 4
+# 266 "/usr/include/inttypes.h" 3 4
+extern "C" {
+
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } imaxdiv_t;
+# 290 "/usr/include/inttypes.h" 3 4
+extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));
+
+
+extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
+      throw () __attribute__ ((__const__));
+
+
+extern intmax_t strtoimax (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base) throw ();
+
+
+extern uintmax_t strtoumax (const char *__restrict __nptr,
+       char ** __restrict __endptr, int __base) throw ();
+
+
+extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
+       wchar_t ** __restrict __endptr, int __base)
+     throw ();
+# 432 "/usr/include/inttypes.h" 3 4
+}
+# 31 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 2 3
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 2
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 2
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsStringComparator
+{
+public:
+  typedef char16_t char_type;
+
+  nsStringComparator()
+  {
+  }
+
+  virtual int operator()(const char_type*, const char_type*,
+                         uint32_t, uint32_t) const = 0;
+};
+
+
+
+
+
+class nsDefaultStringComparator
+  : public nsStringComparator
+{
+public:
+  typedef char16_t char_type;
+
+  nsDefaultStringComparator()
+  {
+  }
+
+  virtual int operator()(const char_type*, const char_type*,
+                         uint32_t, uint32_t) const override;
+};
+
+class nsSubstringSplitter;
+
+namespace mozilla {
+namespace detail {
+# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsStringRepr
+{
+public:
+  typedef mozilla::fallible_t fallible_t;
+
+  typedef char16_t char_type;
+
+  typedef nsCharTraits<char_type> char_traits;
+  typedef char_traits::incompatible_char_type incompatible_char_type;
+
+  typedef nsStringRepr self_type;
+  typedef self_type base_string_type;
+
+  typedef nsAString substring_type;
+  typedef nsSubstringTuple substring_tuple_type;
+  typedef nsString string_type;
+
+  typedef nsReadingIterator<char_type> const_iterator;
+  typedef nsWritingIterator<char_type> iterator;
+
+  typedef nsStringComparator comparator_type;
+
+  typedef char_type* char_iterator;
+  typedef const char_type* const_char_iterator;
+
+  typedef uint32_t index_type;
+  typedef uint32_t size_type;
+
+
+
+
+
+  const_char_iterator BeginReading() const
+  {
+    return mData;
+  }
+  const_char_iterator EndReading() const
+  {
+    return mData + mLength;
+  }
+
+
+
+
+
+  const_iterator& BeginReading(const_iterator& aIter) const
+  {
+    aIter.mStart = mData;
+    aIter.mEnd = mData + mLength;
+    aIter.mPosition = aIter.mStart;
+    return aIter;
+  }
+
+  const_iterator& EndReading(const_iterator& aIter) const
+  {
+    aIter.mStart = mData;
+    aIter.mEnd = mData + mLength;
+    aIter.mPosition = aIter.mEnd;
+    return aIter;
+  }
+
+  const_char_iterator& BeginReading(const_char_iterator& aIter) const
+  {
+    return aIter = mData;
+  }
+
+  const_char_iterator& EndReading(const_char_iterator& aIter) const
+  {
+    return aIter = mData + mLength;
+  }
+# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  const char_type* Data() const
+
+  {
+    return mData;
+  }
+
+  size_type Length() const
+  {
+    return mLength;
+  }
+
+  uint32_t Flags() const
+  {
+    return mFlags;
+  }
+
+  bool IsEmpty() const
+  {
+    return mLength == 0;
+  }
+
+  bool IsLiteral() const
+  {
+    return (mFlags & F_LITERAL) != 0;
+  }
+
+  bool IsVoid() const
+  {
+    return (mFlags & F_VOIDED) != 0;
+  }
+
+  bool IsTerminated() const
+  {
+    return (mFlags & F_TERMINATED) != 0;
+  }
+
+  char_type CharAt(index_type aIndex) const
+  {
+    do { } while(0);
+    return mData[aIndex];
+  }
+
+  char_type operator[](index_type aIndex) const
+  {
+    return CharAt(aIndex);
+  }
+
+  char_type First() const;
+
+  char_type Last() const;
+
+  size_type CountChar(char_type) const;
+  int32_t FindChar(char_type, index_type aOffset = 0) const;
+
+  inline bool Contains(char_type aChar) const
+  {
+    return FindChar(aChar) != -1;
+  }
+
+
+
+
+
+  bool Equals(const self_type&) const;
+  bool Equals(const self_type&, const comparator_type&) const;
+
+  bool Equals(const substring_tuple_type& aTuple) const;
+  bool Equals(const substring_tuple_type& aTuple,
+                          const comparator_type& aComp) const;
+
+  bool Equals(const char_type* aData) const;
+  bool Equals(const char_type* aData,
+                          const comparator_type& aComp) const;
+# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  bool EqualsASCII(const char* aData, size_type aLen) const;
+
+
+
+
+
+  bool EqualsASCII(const char* aData) const;
+
+
+
+
+
+
+
+  template<int N>
+  inline bool EqualsLiteral(const char (&aStr)[N]) const
+  {
+    return EqualsASCII(aStr, N - 1);
+  }
+
+
+
+
+
+
+
+  bool LowerCaseEqualsASCII(const char* aData,
+                                        size_type aLen) const;
+  bool LowerCaseEqualsASCII(const char* aData) const;
+
+
+
+
+
+
+  template<int N>
+  inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const
+  {
+    return LowerCaseEqualsASCII(aStr, N - 1);
+  }
+
+
+
+
+  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const
+  {
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+    return (aStart < (mData + mLength) && aEnd > mData);
+  }
+
+protected:
+  nsStringRepr() = delete;
+
+  constexpr
+  nsStringRepr(char_type* aData, size_type aLength, uint32_t aFlags)
+    : mData(aData)
+    , mLength(aLength)
+    , mFlags(aFlags)
+  {
+  }
+
+  char_type* mData;
+  size_type mLength;
+  uint32_t mFlags;
+
+public:
+
+
+
+
+
+
+  enum
+  {
+    F_NONE = 0,
+
+
+    F_TERMINATED = 1 << 0,
+    F_VOIDED = 1 << 1,
+    F_SHARED = 1 << 2,
+    F_OWNED = 1 << 3,
+    F_FIXED = 1 << 4,
+    F_LITERAL = 1 << 5,
+
+
+    F_CLASS_FIXED = 1 << 16
+  };
+# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+};
+
+}
+}
+# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsAString : public mozilla::detail::nsStringRepr
+{
+public:
+  typedef nsAString self_type;
+
+
+  ~nsAString()
+  {
+    Finalize();
+  }
+
+
+
+
+
+  char_iterator BeginWriting()
+  {
+    if (!EnsureMutable()) {
+      AllocFailed(mLength);
+    }
+
+    return mData;
+  }
+
+  char_iterator BeginWriting(const fallible_t&)
+  {
+    return EnsureMutable() ? mData : char_iterator(0);
+  }
+
+  char_iterator EndWriting()
+  {
+    if (!EnsureMutable()) {
+      AllocFailed(mLength);
+    }
+
+    return mData + mLength;
+  }
+
+  char_iterator EndWriting(const fallible_t&)
+  {
+    return EnsureMutable() ? (mData + mLength) : char_iterator(0);
+  }
+
+  char_iterator& BeginWriting(char_iterator& aIter)
+  {
+    return aIter = BeginWriting();
+  }
+
+  char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible)
+  {
+    return aIter = BeginWriting(aFallible);
+  }
+
+  char_iterator& EndWriting(char_iterator& aIter)
+  {
+    return aIter = EndWriting();
+  }
+
+  char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible)
+  {
+    return aIter = EndWriting(aFallible);
+  }
+
+
+
+
+
+  iterator& BeginWriting(iterator& aIter)
+  {
+    char_type* data = BeginWriting();
+    aIter.mStart = data;
+    aIter.mEnd = data + mLength;
+    aIter.mPosition = aIter.mStart;
+    return aIter;
+  }
+
+  iterator& EndWriting(iterator& aIter)
+  {
+    char_type* data = BeginWriting();
+    aIter.mStart = data;
+    aIter.mEnd = data + mLength;
+    aIter.mPosition = aIter.mEnd;
+    return aIter;
+  }
+
+
+
+
+
+  void Assign(char_type aChar);
+  __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&);
+
+  void Assign(const char_type* aData);
+  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
+                                       const fallible_t&);
+
+  void Assign(const char_type* aData, size_type aLength);
+  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
+                                       size_type aLength, const fallible_t&);
+
+  void Assign(const self_type&);
+  __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&);
+
+  void Assign(const substring_tuple_type&);
+  __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&,
+                                       const fallible_t&);
+# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void AssignASCII(const char* aData, size_type aLength);
+  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
+                                            size_type aLength,
+                                            const fallible_t&);
+
+  void AssignASCII(const char* aData)
+  {
+    AssignASCII(aData, mozilla::AssertedCast<size_type, size_t>(strlen(aData)));
+  }
+  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
+                                            const fallible_t& aFallible)
+  {
+    return AssignASCII(aData,
+                       mozilla::AssertedCast<size_type, size_t>(strlen(aData)),
+                       aFallible);
+  }
+
+
+
+
+
+
+
+  template<int N>
+  void AssignLiteral(const char_type (&aStr)[N])
+  {
+    AssignLiteral(aStr, N - 1);
+  }
+
+  template<int N>
+  void AssignLiteral(const char (&aStr)[N])
+  {
+    AssignASCII(aStr, N - 1);
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+  void Adopt(char_type* aData, size_type aLength = size_type(-1));
+
+
+
+
+
+
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           char_type aChar);
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                                        size_type aCutLength,
+                                        char_type aChar,
+                                        const fallible_t&);
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           const char_type* aData,
+                           size_type aLength = size_type(-1));
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                                        size_type aCutLength,
+                                        const char_type* aData,
+                                        size_type aLength,
+                                        const fallible_t&);
+  void Replace(index_type aCutStart, size_type aCutLength,
+               const self_type& aStr)
+  {
+    Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length());
+  }
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                            size_type aCutLength,
+                            const self_type& aStr,
+                            const fallible_t& aFallible)
+  {
+    return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(),
+                   aFallible);
+  }
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           const substring_tuple_type& aTuple);
+
+  void ReplaceASCII(index_type aCutStart, size_type aCutLength,
+                                const char* aData,
+                                size_type aLength = size_type(-1));
+
+  __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength,
+                                             const char* aData,
+                                             size_type aLength,
+                                             const fallible_t&);
+
+
+
+
+  template<int N>
+  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
+                      const char_type (&aStr)[N])
+  {
+    ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1);
+  }
+
+  void Append(char_type aChar)
+  {
+    Replace(mLength, 0, aChar);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aChar, aFallible);
+  }
+  void Append(const char_type* aData, size_type aLength = size_type(-1))
+  {
+    Replace(mLength, 0, aData, aLength);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength,
+                           const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aData, aLength, aFallible);
+  }
+# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void Append(const self_type& aStr)
+  {
+    Replace(mLength, 0, aStr);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aStr, aFallible);
+  }
+  void Append(const substring_tuple_type& aTuple)
+  {
+    Replace(mLength, 0, aTuple);
+  }
+
+  void AppendASCII(const char* aData, size_type aLength = size_type(-1))
+  {
+    ReplaceASCII(mLength, 0, aData, aLength);
+  }
+
+  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible)
+  {
+    return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible);
+  }
+
+  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible)
+  {
+    return ReplaceASCII(mLength, 0, aData, aLength, aFallible);
+  }
+
+
+
+
+
+
+
+  void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3)));
+  void AppendPrintf(const char* aFormat, va_list aAp);
+  void AppendInt(int32_t aInteger)
+  {
+    AppendPrintf("%" "d", aInteger);
+  }
+  void AppendInt(int32_t aInteger, int aRadix)
+  {
+    if (aRadix == 10) {
+      AppendPrintf("%" "d", aInteger);
+    } else {
+      AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x",
+                   static_cast<uint32_t>(aInteger));
+    }
+  }
+  void AppendInt(uint32_t aInteger)
+  {
+    AppendPrintf("%" "u", aInteger);
+  }
+  void AppendInt(uint32_t aInteger, int aRadix)
+  {
+    AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x",
+                 aInteger);
+  }
+  void AppendInt(int64_t aInteger)
+  {
+    AppendPrintf("%" "l" "d", aInteger);
+  }
+  void AppendInt(int64_t aInteger, int aRadix)
+  {
+    if (aRadix == 10) {
+      AppendPrintf("%" "l" "d", aInteger);
+    } else {
+      AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
+                   static_cast<uint64_t>(aInteger));
+    }
+  }
+  void AppendInt(uint64_t aInteger)
+  {
+    AppendPrintf("%" "l" "u", aInteger);
+  }
+  void AppendInt(uint64_t aInteger, int aRadix)
+  {
+    AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
+                 aInteger);
+  }
+
+
+
+
+  void AppendFloat(float aFloat);
+  void AppendFloat(double aFloat);
+public:
+
+
+
+
+  template<int N>
+  void AppendLiteral(const char_type (&aStr)[N])
+  {
+    ReplaceLiteral(mLength, 0, aStr, N - 1);
+  }
+
+  template<int N>
+  void AppendLiteral(const char (&aStr)[N])
+  {
+    AppendASCII(aStr, N - 1);
+  }
+
+  template<int N>
+  __attribute__ ((warn_unused_result)) bool AppendLiteral(const char (&aStr)[N], const fallible_t& aFallible)
+  {
+    return AppendASCII(aStr, N - 1, aFallible);
+  }
+
+
+  self_type& operator+=(char_type aChar)
+  {
+    Append(aChar);
+    return *this;
+  }
+  self_type& operator+=(const char_type* aData)
+  {
+    Append(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator+=(const self_type& aStr)
+  {
+    Append(aStr);
+    return *this;
+  }
+  self_type& operator+=(const substring_tuple_type& aTuple)
+  {
+    Append(aTuple);
+    return *this;
+  }
+
+  void Insert(char_type aChar, index_type aPos)
+  {
+    Replace(aPos, 0, aChar);
+  }
+  void Insert(const char_type* aData, index_type aPos,
+              size_type aLength = size_type(-1))
+  {
+    Replace(aPos, 0, aData, aLength);
+  }
+
+
+
+
+
+
+
+  void Insert(const self_type& aStr, index_type aPos)
+  {
+    Replace(aPos, 0, aStr);
+  }
+  void Insert(const substring_tuple_type& aTuple, index_type aPos)
+  {
+    Replace(aPos, 0, aTuple);
+  }
+
+
+
+
+  template<int N>
+  void InsertLiteral(const char_type (&aStr)[N], index_type aPos)
+  {
+    ReplaceLiteral(aPos, 0, aStr, N - 1);
+  }
+
+  void Cut(index_type aCutStart, size_type aCutLength)
+  {
+    Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0);
+  }
+
+  nsSubstringSplitter Split(const char_type aChar) const;
+# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void SetCapacity(size_type aNewCapacity);
+  __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity,
+                                            const fallible_t&);
+
+  void SetLength(size_type aNewLength);
+  __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength,
+                                          const fallible_t&);
+
+  void Truncate(size_type aNewLength = 0)
+  {
+    do { } while(0);
+    SetLength(aNewLength);
+  }
+# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  inline size_type GetData(const char_type** aData) const
+  {
+    *aData = mData;
+    return mLength;
+  }
+# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1))
+  {
+    if (!EnsureMutable(aNewLen)) {
+      AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen);
+    }
+
+    *aData = mData;
+    return mLength;
+  }
+
+  size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&)
+  {
+    if (!EnsureMutable(aNewLen)) {
+      *aData = nullptr;
+      return 0;
+    }
+
+    *aData = mData;
+    return mLength;
+  }
+# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  operator mozilla::Span<char_type>()
+  {
+    return mozilla::MakeSpan(BeginWriting(), Length());
+  }
+
+  operator mozilla::Span<const char_type>() const
+  {
+    return mozilla::MakeSpan(BeginReading(), Length());
+  }
+
+  void Append(mozilla::Span<const char_type> aSpan)
+  {
+    auto len = aSpan.Length();
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
+    Append(aSpan.Elements(), len);
+  }
+
+  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const char_type> aSpan,
+                           const fallible_t& aFallible)
+  {
+    auto len = aSpan.Length();
+    if (len > mozilla::MaxValue<size_type>::value) {
+      return false;
+    }
+    return Append(aSpan.Elements(), len, aFallible);
+  }
+# 995 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void SetIsVoid(bool);
+# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void StripChar(char_type aChar, int32_t aOffset = 0);
+# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void StripChars(const char_type* aChars, uint32_t aOffset = 0);
+
+
+
+
+
+  void ForgetSharedBuffer()
+  {
+    if (mFlags & nsSubstring::F_SHARED) {
+      mData = char_traits::sEmptyBuffer;
+      mLength = 0;
+      mFlags = F_TERMINATED;
+    }
+  }
+
+public:
+
+
+
+
+
+               nsAString(const substring_tuple_type& aTuple)
+    : nsStringRepr(nullptr, 0, F_NONE)
+  {
+    Assign(aTuple);
+  }
+
+  size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+
+
+
+
+
+
+
+  size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+
+  template<class T>
+  void NS_ABORT_OOM(T)
+  {
+    struct never {};
+    static_assert(mozilla::IsSame<T, never>::value,
+      "In string classes, use AllocFailed to account for sizeof(char_type). "
+      "Use the global ::NS_ABORT_OOM if you really have a count of bytes.");
+  }
+
+  __attribute__((always_inline)) inline void AllocFailed(size_t aLength)
+  {
+    ::NS_ABORT_OOM(aLength * sizeof(char_type));
+  }
+
+protected:
+
+
+  nsAString()
+    : nsStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED)
+  {
+  }
+
+
+
+  nsAString(const self_type& aStr)
+    : nsStringRepr(aStr.mData, aStr.mLength,
+                          aStr.mFlags & (F_TERMINATED | F_VOIDED))
+  {
+  }
+# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  nsAString(char_type* aData, size_type aLength, uint32_t aFlags)
+    : nsStringRepr(aData, aLength, aFlags)
+  {
+  }
+
+
+
+
+
+
+
+  void Finalize();
+# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  bool MutatePrep(size_type aCapacity,
+                              char_type** aOldData, uint32_t* aOldFlags);
+# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart,
+                                size_type aCutLength,
+                                size_type aNewLength);
+
+  __attribute__ ((warn_unused_result)) bool ReplacePrepInternal(
+    index_type aCutStart,
+    size_type aCutLength,
+    size_type aNewFragLength,
+    size_type aNewTotalLength);
+# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  size_type Capacity() const;
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool EnsureMutable(
+    size_type aNewLen = size_type(-1));
+
+
+
+
+  static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) {
+    if (aCapacity > kMaxCapacity) {
+
+
+      do { } while(0);
+      return false;
+    }
+
+    return true;
+  }
+
+
+
+
+  void SetDataFlags(uint32_t aDataFlags)
+  {
+    do { } while(0);
+    mFlags = aDataFlags | (mFlags & 0xFFFF0000);
+  }
+
+  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
+                                  const char_type* aData, size_type aLength);
+
+  static const size_type kMaxCapacity;
+public:
+
+
+
+  void AssignLiteral(const char_type* aData, size_type aLength);
+};
+
+static_assert(sizeof(nsAString) ==
+              sizeof(mozilla::detail::nsStringRepr),
+              "Don't add new data fields to nsTSubstring_CharT. "
+              "Add to nsTStringRepr_CharT instead.");
+
+int
+Compare(const nsAString::base_string_type& aLhs,
+        const nsAString::base_string_type& aRhs,
+        const nsStringComparator& = nsDefaultStringComparator());
+
+
+inline bool
+operator!=(const nsAString::base_string_type& aLhs,
+           const nsAString::base_string_type& aRhs)
+{
+  return !aLhs.Equals(aRhs);
+}
+
+inline bool
+operator!=(const nsAString::base_string_type& aLhs,
+           const nsAString::char_type* aRhs)
+{
+  return !aLhs.Equals(aRhs);
+}
+
+inline bool
+operator<(const nsAString::base_string_type& aLhs,
+          const nsAString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) < 0;
+}
+
+inline bool
+operator<=(const nsAString::base_string_type& aLhs,
+           const nsAString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) <= 0;
+}
+
+inline bool
+operator==(const nsAString::base_string_type& aLhs,
+           const nsAString::base_string_type& aRhs)
+{
+  return aLhs.Equals(aRhs);
+}
+
+inline bool
+operator==(const nsAString::base_string_type& aLhs,
+           const nsAString::char_type* aRhs)
+{
+  return aLhs.Equals(aRhs);
+}
+
+
+inline bool
+operator>=(const nsAString::base_string_type& aLhs,
+           const nsAString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) >= 0;
+}
+
+inline bool
+operator>(const nsAString::base_string_type& aLhs,
+          const nsAString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) > 0;
+}
+
+
+
+class nsSubstringSplitter
+{
+  typedef nsAString::size_type size_type;
+  typedef nsAString::char_type char_type;
+
+  class nsTSubstringSplit_Iter
+  {
+  public:
+    nsTSubstringSplit_Iter(const nsSubstringSplitter& aObj,
+                           size_type aPos)
+      : mObj(aObj)
+      , mPos(aPos)
+    {
+    }
+
+    bool operator!=(const nsTSubstringSplit_Iter& other) const
+    {
+      return mPos != other.mPos;
+    }
+
+    const nsDependentSubstring& operator*() const;
+
+    const nsTSubstringSplit_Iter& operator++()
+    {
+      ++mPos;
+      return *this;
+    }
+
+  private:
+    const nsSubstringSplitter& mObj;
+    size_type mPos;
+  };
+
+private:
+  const nsAString* const mStr;
+  mozilla::UniquePtr<nsDependentSubstring[]> mArray;
+  size_type mArraySize;
+  const char_type mDelim;
+
+public:
+  nsSubstringSplitter(const nsAString* aStr, char_type aDelim);
+
+  nsTSubstringSplit_Iter begin() const
+  {
+    return nsTSubstringSplit_Iter(*this, 0);
+  }
+
+  nsTSubstringSplit_Iter end() const
+  {
+    return nsTSubstringSplit_Iter(*this, mArraySize);
+  }
+
+  const nsDependentSubstring& Get(const size_type index) const
+  {
+    do { } while (0);
+    return mArray[index];
+  }
+};
+
+
+
+
+namespace mozilla {
+
+inline Span<char16_t>
+MakeSpan(nsAString& aString)
+{
+  return aString;
+}
+
+inline Span<const char16_t>
+MakeSpan(const nsAString& aString)
+{
+  return aString;
+}
+
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsCStringComparator
+{
+public:
+  typedef char char_type;
+
+  nsCStringComparator()
+  {
+  }
+
+  virtual int operator()(const char_type*, const char_type*,
+                         uint32_t, uint32_t) const = 0;
+};
+
+
+
+
+
+class nsDefaultCStringComparator
+  : public nsCStringComparator
+{
+public:
+  typedef char char_type;
+
+  nsDefaultCStringComparator()
+  {
+  }
+
+  virtual int operator()(const char_type*, const char_type*,
+                         uint32_t, uint32_t) const override;
+};
+
+class nsCSubstringSplitter;
+
+namespace mozilla {
+namespace detail {
+# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsCStringRepr
+{
+public:
+  typedef mozilla::fallible_t fallible_t;
+
+  typedef char char_type;
+
+  typedef nsCharTraits<char_type> char_traits;
+  typedef char_traits::incompatible_char_type incompatible_char_type;
+
+  typedef nsCStringRepr self_type;
+  typedef self_type base_string_type;
+
+  typedef nsACString substring_type;
+  typedef nsCSubstringTuple substring_tuple_type;
+  typedef nsCString string_type;
+
+  typedef nsReadingIterator<char_type> const_iterator;
+  typedef nsWritingIterator<char_type> iterator;
+
+  typedef nsCStringComparator comparator_type;
+
+  typedef char_type* char_iterator;
+  typedef const char_type* const_char_iterator;
+
+  typedef uint32_t index_type;
+  typedef uint32_t size_type;
+
+
+
+
+
+  const_char_iterator BeginReading() const
+  {
+    return mData;
+  }
+  const_char_iterator EndReading() const
+  {
+    return mData + mLength;
+  }
+
+
+
+
+
+  const_iterator& BeginReading(const_iterator& aIter) const
+  {
+    aIter.mStart = mData;
+    aIter.mEnd = mData + mLength;
+    aIter.mPosition = aIter.mStart;
+    return aIter;
+  }
+
+  const_iterator& EndReading(const_iterator& aIter) const
+  {
+    aIter.mStart = mData;
+    aIter.mEnd = mData + mLength;
+    aIter.mPosition = aIter.mEnd;
+    return aIter;
+  }
+
+  const_char_iterator& BeginReading(const_char_iterator& aIter) const
+  {
+    return aIter = mData;
+  }
+
+  const_char_iterator& EndReading(const_char_iterator& aIter) const
+  {
+    return aIter = mData + mLength;
+  }
+# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  const char_type* Data() const
+
+  {
+    return mData;
+  }
+
+  size_type Length() const
+  {
+    return mLength;
+  }
+
+  uint32_t Flags() const
+  {
+    return mFlags;
+  }
+
+  bool IsEmpty() const
+  {
+    return mLength == 0;
+  }
+
+  bool IsLiteral() const
+  {
+    return (mFlags & F_LITERAL) != 0;
+  }
+
+  bool IsVoid() const
+  {
+    return (mFlags & F_VOIDED) != 0;
+  }
+
+  bool IsTerminated() const
+  {
+    return (mFlags & F_TERMINATED) != 0;
+  }
+
+  char_type CharAt(index_type aIndex) const
+  {
+    do { } while(0);
+    return mData[aIndex];
+  }
+
+  char_type operator[](index_type aIndex) const
+  {
+    return CharAt(aIndex);
+  }
+
+  char_type First() const;
+
+  char_type Last() const;
+
+  size_type CountChar(char_type) const;
+  int32_t FindChar(char_type, index_type aOffset = 0) const;
+
+  inline bool Contains(char_type aChar) const
+  {
+    return FindChar(aChar) != -1;
+  }
+
+
+
+
+
+  bool Equals(const self_type&) const;
+  bool Equals(const self_type&, const comparator_type&) const;
+
+  bool Equals(const substring_tuple_type& aTuple) const;
+  bool Equals(const substring_tuple_type& aTuple,
+                          const comparator_type& aComp) const;
+
+  bool Equals(const char_type* aData) const;
+  bool Equals(const char_type* aData,
+                          const comparator_type& aComp) const;
+# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  bool EqualsASCII(const char* aData, size_type aLen) const;
+
+
+
+
+
+  bool EqualsASCII(const char* aData) const;
+
+
+
+
+
+
+
+  template<int N>
+  inline bool EqualsLiteral(const char (&aStr)[N]) const
+  {
+    return EqualsASCII(aStr, N - 1);
+  }
+
+
+
+
+
+
+
+  bool LowerCaseEqualsASCII(const char* aData,
+                                        size_type aLen) const;
+  bool LowerCaseEqualsASCII(const char* aData) const;
+
+
+
+
+
+
+  template<int N>
+  inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const
+  {
+    return LowerCaseEqualsASCII(aStr, N - 1);
+  }
+
+
+
+
+  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const
+  {
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+    return (aStart < (mData + mLength) && aEnd > mData);
+  }
+
+protected:
+  nsCStringRepr() = delete;
+
+  constexpr
+  nsCStringRepr(char_type* aData, size_type aLength, uint32_t aFlags)
+    : mData(aData)
+    , mLength(aLength)
+    , mFlags(aFlags)
+  {
+  }
+
+  char_type* mData;
+  size_type mLength;
+  uint32_t mFlags;
+
+public:
+
+
+
+
+
+
+  enum
+  {
+    F_NONE = 0,
+
+
+    F_TERMINATED = 1 << 0,
+    F_VOIDED = 1 << 1,
+    F_SHARED = 1 << 2,
+    F_OWNED = 1 << 3,
+    F_FIXED = 1 << 4,
+    F_LITERAL = 1 << 5,
+
+
+    F_CLASS_FIXED = 1 << 16
+  };
+# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+};
+
+}
+}
+# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+class nsACString : public mozilla::detail::nsCStringRepr
+{
+public:
+  typedef nsACString self_type;
+
+
+  ~nsACString()
+  {
+    Finalize();
+  }
+
+
+
+
+
+  char_iterator BeginWriting()
+  {
+    if (!EnsureMutable()) {
+      AllocFailed(mLength);
+    }
+
+    return mData;
+  }
+
+  char_iterator BeginWriting(const fallible_t&)
+  {
+    return EnsureMutable() ? mData : char_iterator(0);
+  }
+
+  char_iterator EndWriting()
+  {
+    if (!EnsureMutable()) {
+      AllocFailed(mLength);
+    }
+
+    return mData + mLength;
+  }
+
+  char_iterator EndWriting(const fallible_t&)
+  {
+    return EnsureMutable() ? (mData + mLength) : char_iterator(0);
+  }
+
+  char_iterator& BeginWriting(char_iterator& aIter)
+  {
+    return aIter = BeginWriting();
+  }
+
+  char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible)
+  {
+    return aIter = BeginWriting(aFallible);
+  }
+
+  char_iterator& EndWriting(char_iterator& aIter)
+  {
+    return aIter = EndWriting();
+  }
+
+  char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible)
+  {
+    return aIter = EndWriting(aFallible);
+  }
+
+
+
+
+
+  iterator& BeginWriting(iterator& aIter)
+  {
+    char_type* data = BeginWriting();
+    aIter.mStart = data;
+    aIter.mEnd = data + mLength;
+    aIter.mPosition = aIter.mStart;
+    return aIter;
+  }
+
+  iterator& EndWriting(iterator& aIter)
+  {
+    char_type* data = BeginWriting();
+    aIter.mStart = data;
+    aIter.mEnd = data + mLength;
+    aIter.mPosition = aIter.mEnd;
+    return aIter;
+  }
+
+
+
+
+
+  void Assign(char_type aChar);
+  __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&);
+
+  void Assign(const char_type* aData);
+  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
+                                       const fallible_t&);
+
+  void Assign(const char_type* aData, size_type aLength);
+  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
+                                       size_type aLength, const fallible_t&);
+
+  void Assign(const self_type&);
+  __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&);
+
+  void Assign(const substring_tuple_type&);
+  __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&,
+                                       const fallible_t&);
+# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void AssignASCII(const char* aData, size_type aLength);
+  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
+                                            size_type aLength,
+                                            const fallible_t&);
+
+  void AssignASCII(const char* aData)
+  {
+    AssignASCII(aData, mozilla::AssertedCast<size_type, size_t>(strlen(aData)));
+  }
+  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
+                                            const fallible_t& aFallible)
+  {
+    return AssignASCII(aData,
+                       mozilla::AssertedCast<size_type, size_t>(strlen(aData)),
+                       aFallible);
+  }
+
+
+
+
+
+
+
+  template<int N>
+  void AssignLiteral(const char_type (&aStr)[N])
+  {
+    AssignLiteral(aStr, N - 1);
+  }
+# 551 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+  void Adopt(char_type* aData, size_type aLength = size_type(-1));
+
+
+
+
+
+
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           char_type aChar);
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                                        size_type aCutLength,
+                                        char_type aChar,
+                                        const fallible_t&);
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           const char_type* aData,
+                           size_type aLength = size_type(-1));
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                                        size_type aCutLength,
+                                        const char_type* aData,
+                                        size_type aLength,
+                                        const fallible_t&);
+  void Replace(index_type aCutStart, size_type aCutLength,
+               const self_type& aStr)
+  {
+    Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length());
+  }
+  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
+                            size_type aCutLength,
+                            const self_type& aStr,
+                            const fallible_t& aFallible)
+  {
+    return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(),
+                   aFallible);
+  }
+  void Replace(index_type aCutStart, size_type aCutLength,
+                           const substring_tuple_type& aTuple);
+
+  void ReplaceASCII(index_type aCutStart, size_type aCutLength,
+                                const char* aData,
+                                size_type aLength = size_type(-1));
+
+  __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength,
+                                             const char* aData,
+                                             size_type aLength,
+                                             const fallible_t&);
+
+
+
+
+  template<int N>
+  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
+                      const char_type (&aStr)[N])
+  {
+    ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1);
+  }
+
+  void Append(char_type aChar)
+  {
+    Replace(mLength, 0, aChar);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aChar, aFallible);
+  }
+  void Append(const char_type* aData, size_type aLength = size_type(-1))
+  {
+    Replace(mLength, 0, aData, aLength);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength,
+                           const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aData, aLength, aFallible);
+  }
+# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void Append(const self_type& aStr)
+  {
+    Replace(mLength, 0, aStr);
+  }
+  __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible)
+  {
+    return Replace(mLength, 0, aStr, aFallible);
+  }
+  void Append(const substring_tuple_type& aTuple)
+  {
+    Replace(mLength, 0, aTuple);
+  }
+
+  void AppendASCII(const char* aData, size_type aLength = size_type(-1))
+  {
+    ReplaceASCII(mLength, 0, aData, aLength);
+  }
+
+  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible)
+  {
+    return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible);
+  }
+
+  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible)
+  {
+    return ReplaceASCII(mLength, 0, aData, aLength, aFallible);
+  }
+
+
+
+
+
+
+
+  void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3)));
+  void AppendPrintf(const char* aFormat, va_list aAp);
+  void AppendInt(int32_t aInteger)
+  {
+    AppendPrintf("%" "d", aInteger);
+  }
+  void AppendInt(int32_t aInteger, int aRadix)
+  {
+    if (aRadix == 10) {
+      AppendPrintf("%" "d", aInteger);
+    } else {
+      AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x",
+                   static_cast<uint32_t>(aInteger));
+    }
+  }
+  void AppendInt(uint32_t aInteger)
+  {
+    AppendPrintf("%" "u", aInteger);
+  }
+  void AppendInt(uint32_t aInteger, int aRadix)
+  {
+    AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x",
+                 aInteger);
+  }
+  void AppendInt(int64_t aInteger)
+  {
+    AppendPrintf("%" "l" "d", aInteger);
+  }
+  void AppendInt(int64_t aInteger, int aRadix)
+  {
+    if (aRadix == 10) {
+      AppendPrintf("%" "l" "d", aInteger);
+    } else {
+      AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
+                   static_cast<uint64_t>(aInteger));
+    }
+  }
+  void AppendInt(uint64_t aInteger)
+  {
+    AppendPrintf("%" "l" "u", aInteger);
+  }
+  void AppendInt(uint64_t aInteger, int aRadix)
+  {
+    AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
+                 aInteger);
+  }
+
+
+
+
+  void AppendFloat(float aFloat);
+  void AppendFloat(double aFloat);
+public:
+
+
+
+
+  template<int N>
+  void AppendLiteral(const char_type (&aStr)[N])
+  {
+    ReplaceLiteral(mLength, 0, aStr, N - 1);
+  }
+# 770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  self_type& operator+=(char_type aChar)
+  {
+    Append(aChar);
+    return *this;
+  }
+  self_type& operator+=(const char_type* aData)
+  {
+    Append(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator+=(const self_type& aStr)
+  {
+    Append(aStr);
+    return *this;
+  }
+  self_type& operator+=(const substring_tuple_type& aTuple)
+  {
+    Append(aTuple);
+    return *this;
+  }
+
+  void Insert(char_type aChar, index_type aPos)
+  {
+    Replace(aPos, 0, aChar);
+  }
+  void Insert(const char_type* aData, index_type aPos,
+              size_type aLength = size_type(-1))
+  {
+    Replace(aPos, 0, aData, aLength);
+  }
+
+
+
+
+
+
+
+  void Insert(const self_type& aStr, index_type aPos)
+  {
+    Replace(aPos, 0, aStr);
+  }
+  void Insert(const substring_tuple_type& aTuple, index_type aPos)
+  {
+    Replace(aPos, 0, aTuple);
+  }
+
+
+
+
+  template<int N>
+  void InsertLiteral(const char_type (&aStr)[N], index_type aPos)
+  {
+    ReplaceLiteral(aPos, 0, aStr, N - 1);
+  }
+
+  void Cut(index_type aCutStart, size_type aCutLength)
+  {
+    Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0);
+  }
+
+  nsCSubstringSplitter Split(const char_type aChar) const;
+# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void SetCapacity(size_type aNewCapacity);
+  __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity,
+                                            const fallible_t&);
+
+  void SetLength(size_type aNewLength);
+  __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength,
+                                          const fallible_t&);
+
+  void Truncate(size_type aNewLength = 0)
+  {
+    do { } while(0);
+    SetLength(aNewLength);
+  }
+# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  inline size_type GetData(const char_type** aData) const
+  {
+    *aData = mData;
+    return mLength;
+  }
+# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1))
+  {
+    if (!EnsureMutable(aNewLen)) {
+      AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen);
+    }
+
+    *aData = mData;
+    return mLength;
+  }
+
+  size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&)
+  {
+    if (!EnsureMutable(aNewLen)) {
+      *aData = nullptr;
+      return 0;
+    }
+
+    *aData = mData;
+    return mLength;
+  }
+# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  operator mozilla::Span<char_type>()
+  {
+    return mozilla::MakeSpan(BeginWriting(), Length());
+  }
+
+  operator mozilla::Span<const char_type>() const
+  {
+    return mozilla::MakeSpan(BeginReading(), Length());
+  }
+
+  void Append(mozilla::Span<const char_type> aSpan)
+  {
+    auto len = aSpan.Length();
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
+    Append(aSpan.Elements(), len);
+  }
+
+  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const char_type> aSpan,
+                           const fallible_t& aFallible)
+  {
+    auto len = aSpan.Length();
+    if (len > mozilla::MaxValue<size_type>::value) {
+      return false;
+    }
+    return Append(aSpan.Elements(), len, aFallible);
+  }
+
+
+  operator mozilla::Span<uint8_t>()
+  {
+    return mozilla::MakeSpan(reinterpret_cast<uint8_t*>(BeginWriting()),
+                             Length());
+  }
+
+  operator mozilla::Span<const uint8_t>() const
+  {
+    return mozilla::MakeSpan(reinterpret_cast<const uint8_t*>(BeginReading()),
+                             Length());
+  }
+
+  void Append(mozilla::Span<const uint8_t> aSpan)
+  {
+    auto len = aSpan.Length();
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 974; ::abort(); } while (0); } } while (0);
+    Append(reinterpret_cast<const char*>(aSpan.Elements()), len);
+  }
+
+  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const uint8_t> aSpan,
+                           const fallible_t& aFallible)
+  {
+    auto len = aSpan.Length();
+    if (len > mozilla::MaxValue<size_type>::value) {
+      return false;
+    }
+    return Append(
+      reinterpret_cast<const char*>(aSpan.Elements()), len, aFallible);
+  }
+
+
+
+
+
+
+
+  void SetIsVoid(bool);
+# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void StripChar(char_type aChar, int32_t aOffset = 0);
+# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  void StripChars(const char_type* aChars, uint32_t aOffset = 0);
+
+
+
+
+
+  void ForgetSharedBuffer()
+  {
+    if (mFlags & nsSubstring::F_SHARED) {
+      mData = char_traits::sEmptyBuffer;
+      mLength = 0;
+      mFlags = F_TERMINATED;
+    }
+  }
+
+public:
+
+
+
+
+
+               nsACString(const substring_tuple_type& aTuple)
+    : nsCStringRepr(nullptr, 0, F_NONE)
+  {
+    Assign(aTuple);
+  }
+
+  size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+
+
+
+
+
+
+
+  size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
+  const;
+
+  template<class T>
+  void NS_ABORT_OOM(T)
+  {
+    struct never {};
+    static_assert(mozilla::IsSame<T, never>::value,
+      "In string classes, use AllocFailed to account for sizeof(char_type). "
+      "Use the global ::NS_ABORT_OOM if you really have a count of bytes.");
+  }
+
+  __attribute__((always_inline)) inline void AllocFailed(size_t aLength)
+  {
+    ::NS_ABORT_OOM(aLength * sizeof(char_type));
+  }
+
+protected:
+
+
+  nsACString()
+    : nsCStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED)
+  {
+  }
+
+
+
+  nsACString(const self_type& aStr)
+    : nsCStringRepr(aStr.mData, aStr.mLength,
+                          aStr.mFlags & (F_TERMINATED | F_VOIDED))
+  {
+  }
+# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  nsACString(char_type* aData, size_type aLength, uint32_t aFlags)
+    : nsCStringRepr(aData, aLength, aFlags)
+  {
+  }
+
+
+
+
+
+
+
+  void Finalize();
+# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  bool MutatePrep(size_type aCapacity,
+                              char_type** aOldData, uint32_t* aOldFlags);
+# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart,
+                                size_type aCutLength,
+                                size_type aNewLength);
+
+  __attribute__ ((warn_unused_result)) bool ReplacePrepInternal(
+    index_type aCutStart,
+    size_type aCutLength,
+    size_type aNewFragLength,
+    size_type aNewTotalLength);
+# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
+  size_type Capacity() const;
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool EnsureMutable(
+    size_type aNewLen = size_type(-1));
+
+
+
+
+  static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) {
+    if (aCapacity > kMaxCapacity) {
+
+
+      do { } while(0);
+      return false;
+    }
+
+    return true;
+  }
+
+
+
+
+  void SetDataFlags(uint32_t aDataFlags)
+  {
+    do { } while(0);
+    mFlags = aDataFlags | (mFlags & 0xFFFF0000);
+  }
+
+  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
+                                  const char_type* aData, size_type aLength);
+
+  static const size_type kMaxCapacity;
+public:
+
+
+
+  void AssignLiteral(const char_type* aData, size_type aLength);
+};
+
+static_assert(sizeof(nsACString) ==
+              sizeof(mozilla::detail::nsCStringRepr),
+              "Don't add new data fields to nsTSubstring_CharT. "
+              "Add to nsTStringRepr_CharT instead.");
+
+int
+Compare(const nsACString::base_string_type& aLhs,
+        const nsACString::base_string_type& aRhs,
+        const nsCStringComparator& = nsDefaultCStringComparator());
+
+
+inline bool
+operator!=(const nsACString::base_string_type& aLhs,
+           const nsACString::base_string_type& aRhs)
+{
+  return !aLhs.Equals(aRhs);
+}
+
+inline bool
+operator!=(const nsACString::base_string_type& aLhs,
+           const nsACString::char_type* aRhs)
+{
+  return !aLhs.Equals(aRhs);
+}
+
+inline bool
+operator<(const nsACString::base_string_type& aLhs,
+          const nsACString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) < 0;
+}
+
+inline bool
+operator<=(const nsACString::base_string_type& aLhs,
+           const nsACString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) <= 0;
+}
+
+inline bool
+operator==(const nsACString::base_string_type& aLhs,
+           const nsACString::base_string_type& aRhs)
+{
+  return aLhs.Equals(aRhs);
+}
+
+inline bool
+operator==(const nsACString::base_string_type& aLhs,
+           const nsACString::char_type* aRhs)
+{
+  return aLhs.Equals(aRhs);
+}
+
+
+inline bool
+operator>=(const nsACString::base_string_type& aLhs,
+           const nsACString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) >= 0;
+}
+
+inline bool
+operator>(const nsACString::base_string_type& aLhs,
+          const nsACString::base_string_type& aRhs)
+{
+  return Compare(aLhs, aRhs) > 0;
+}
+
+
+
+class nsCSubstringSplitter
+{
+  typedef nsACString::size_type size_type;
+  typedef nsACString::char_type char_type;
+
+  class nsTSubstringSplit_Iter
+  {
+  public:
+    nsTSubstringSplit_Iter(const nsCSubstringSplitter& aObj,
+                           size_type aPos)
+      : mObj(aObj)
+      , mPos(aPos)
+    {
+    }
+
+    bool operator!=(const nsTSubstringSplit_Iter& other) const
+    {
+      return mPos != other.mPos;
+    }
+
+    const nsDependentCSubstring& operator*() const;
+
+    const nsTSubstringSplit_Iter& operator++()
+    {
+      ++mPos;
+      return *this;
+    }
+
+  private:
+    const nsCSubstringSplitter& mObj;
+    size_type mPos;
+  };
+
+private:
+  const nsACString* const mStr;
+  mozilla::UniquePtr<nsDependentCSubstring[]> mArray;
+  size_type mArraySize;
+  const char_type mDelim;
+
+public:
+  nsCSubstringSplitter(const nsACString* aStr, char_type aDelim);
+
+  nsTSubstringSplit_Iter begin() const
+  {
+    return nsTSubstringSplit_Iter(*this, 0);
+  }
+
+  nsTSubstringSplit_Iter end() const
+  {
+    return nsTSubstringSplit_Iter(*this, mArraySize);
+  }
+
+  const nsDependentCSubstring& Get(const size_type index) const
+  {
+    do { } while (0);
+    return mArray[index];
+  }
+};
+
+
+
+
+namespace mozilla {
+
+inline Span<char>
+MakeSpan(nsACString& aString)
+{
+  return aString;
+}
+
+inline Span<const char>
+MakeSpan(const nsACString& aString)
+{
+  return aString;
+}
+
+}
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+
+
+
+
+
+
+class nsCaseInsensitiveCStringComparator
+  : public nsCStringComparator
+{
+public:
+  nsCaseInsensitiveCStringComparator()
+  {
+  }
+  typedef char char_type;
+
+  virtual int operator()(const char_type*, const char_type*,
+                         uint32_t, uint32_t) const override;
+};
+
+class nsCaseInsensitiveCStringArrayComparator
+{
+public:
+  template<class A, class B>
+  bool Equals(const A& aStrA, const B& aStrB) const
+  {
+    return aStrA.Equals(aStrB, nsCaseInsensitiveCStringComparator());
+  }
+};
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h"
+class nsSubstringTuple
+{
+public:
+
+  typedef char16_t char_type;
+  typedef nsCharTraits<char_type> char_traits;
+
+  typedef nsSubstringTuple self_type;
+  typedef mozilla::detail::nsStringRepr base_string_type;
+  typedef uint32_t size_type;
+
+public:
+
+  nsSubstringTuple(const base_string_type* aStrA,
+                          const base_string_type* aStrB)
+    : mHead(nullptr)
+    , mFragA(aStrA)
+    , mFragB(aStrB)
+  {
+  }
+
+  nsSubstringTuple(const self_type& aHead,
+                          const base_string_type* aStrB)
+    : mHead(&aHead)
+    , mFragA(nullptr)
+    , mFragB(aStrB)
+  {
+  }
+
+
+
+
+  size_type Length() const;
+
+
+
+
+
+
+  void WriteTo(char_type* aBuf, uint32_t aBufLen) const;
+
+
+
+
+
+  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const;
+
+private:
+
+  const self_type* const mHead;
+  const base_string_type* const mFragA;
+  const base_string_type* const mFragB;
+};
+
+inline const nsSubstringTuple
+operator+(const nsSubstringTuple::base_string_type& aStrA,
+          const nsSubstringTuple::base_string_type& aStrB)
+{
+  return nsSubstringTuple(&aStrA, &aStrB);
+}
+
+inline const nsSubstringTuple
+operator+(const nsSubstringTuple& aHead,
+          const nsSubstringTuple::base_string_type& aStrB)
+{
+  return nsSubstringTuple(aHead, &aStrB);
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h"
+class nsCSubstringTuple
+{
+public:
+
+  typedef char char_type;
+  typedef nsCharTraits<char_type> char_traits;
+
+  typedef nsCSubstringTuple self_type;
+  typedef mozilla::detail::nsCStringRepr base_string_type;
+  typedef uint32_t size_type;
+
+public:
+
+  nsCSubstringTuple(const base_string_type* aStrA,
+                          const base_string_type* aStrB)
+    : mHead(nullptr)
+    , mFragA(aStrA)
+    , mFragB(aStrB)
+  {
+  }
+
+  nsCSubstringTuple(const self_type& aHead,
+                          const base_string_type* aStrB)
+    : mHead(&aHead)
+    , mFragA(nullptr)
+    , mFragB(aStrB)
+  {
+  }
+
+
+
+
+  size_type Length() const;
+
+
+
+
+
+
+  void WriteTo(char_type* aBuf, uint32_t aBufLen) const;
+
+
+
+
+
+  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const;
+
+private:
+
+  const self_type* const mHead;
+  const base_string_type* const mFragA;
+  const base_string_type* const mFragB;
+};
+
+inline const nsCSubstringTuple
+operator+(const nsCSubstringTuple::base_string_type& aStrA,
+          const nsCSubstringTuple::base_string_type& aStrB)
+{
+  return nsCSubstringTuple(&aStrA, &aStrB);
+}
+
+inline const nsCSubstringTuple
+operator+(const nsCSubstringTuple& aHead,
+          const nsCSubstringTuple::base_string_type& aStrB)
+{
+  return nsCSubstringTuple(aHead, &aStrB);
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 2
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
+class nsDependentSubstring : public nsAString
+{
+public:
+
+  typedef nsDependentSubstring self_type;
+
+public:
+
+  void Rebind(const substring_type&, uint32_t aStartPos,
+              uint32_t aLength = size_type(-1));
+
+  void Rebind(const char_type* aData, size_type aLength);
+
+  void Rebind(const char_type* aStart, const char_type* aEnd);
+
+  nsDependentSubstring(const substring_type& aStr, uint32_t aStartPos,
+                              uint32_t aLength = size_type(-1))
+    : substring_type()
+  {
+    Rebind(aStr, aStartPos, aLength);
+  }
+
+  nsDependentSubstring(const char_type* aData, size_type aLength)
+    : substring_type(const_cast<char_type*>(aData), aLength, F_NONE)
+  {
+  }
+
+  nsDependentSubstring(const char_type* aStart, const char_type* aEnd);
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
+  nsDependentSubstring(const const_iterator& aStart,
+                              const const_iterator& aEnd);
+
+
+  nsDependentSubstring()
+    : substring_type()
+  {
+  }
+
+
+
+private:
+
+  void operator=(const self_type&);
+};
+
+inline const nsDependentSubstring
+Substring(const nsAString& aStr, uint32_t aStartPos,
+          uint32_t aLength = uint32_t(-1))
+{
+  return nsDependentSubstring(aStr, aStartPos, aLength);
+}
+
+inline const nsDependentSubstring
+Substring(const nsReadingIterator<char16_t>& aStart,
+          const nsReadingIterator<char16_t>& aEnd)
+{
+  return nsDependentSubstring(aStart.get(), aEnd.get());
+}
+
+inline const nsDependentSubstring
+Substring(const char16_t* aData, uint32_t aLength)
+{
+  return nsDependentSubstring(aData, aLength);
+}
+
+const nsDependentSubstring
+Substring(const char16_t* aStart, const char16_t* aEnd);
+
+inline const nsDependentSubstring
+StringHead(const nsAString& aStr, uint32_t aCount)
+{
+  return nsDependentSubstring(aStr, 0, aCount);
+}
+
+inline const nsDependentSubstring
+StringTail(const nsAString& aStr, uint32_t aCount)
+{
+  return nsDependentSubstring(aStr, aStr.Length() - aCount, aCount);
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
+class nsDependentCSubstring : public nsACString
+{
+public:
+
+  typedef nsDependentCSubstring self_type;
+
+public:
+
+  void Rebind(const substring_type&, uint32_t aStartPos,
+              uint32_t aLength = size_type(-1));
+
+  void Rebind(const char_type* aData, size_type aLength);
+
+  void Rebind(const char_type* aStart, const char_type* aEnd);
+
+  nsDependentCSubstring(const substring_type& aStr, uint32_t aStartPos,
+                              uint32_t aLength = size_type(-1))
+    : substring_type()
+  {
+    Rebind(aStr, aStartPos, aLength);
+  }
+
+  nsDependentCSubstring(const char_type* aData, size_type aLength)
+    : substring_type(const_cast<char_type*>(aData), aLength, F_NONE)
+  {
+  }
+
+  nsDependentCSubstring(const char_type* aStart, const char_type* aEnd);
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
+  nsDependentCSubstring(const const_iterator& aStart,
+                              const const_iterator& aEnd);
+
+
+  nsDependentCSubstring()
+    : substring_type()
+  {
+  }
+
+
+
+private:
+
+  void operator=(const self_type&);
+};
+
+inline const nsDependentCSubstring
+Substring(const nsACString& aStr, uint32_t aStartPos,
+          uint32_t aLength = uint32_t(-1))
+{
+  return nsDependentCSubstring(aStr, aStartPos, aLength);
+}
+
+inline const nsDependentCSubstring
+Substring(const nsReadingIterator<char>& aStart,
+          const nsReadingIterator<char>& aEnd)
+{
+  return nsDependentCSubstring(aStart.get(), aEnd.get());
+}
+
+inline const nsDependentCSubstring
+Substring(const char* aData, uint32_t aLength)
+{
+  return nsDependentCSubstring(aData, aLength);
+}
+
+const nsDependentCSubstring
+Substring(const char* aStart, const char* aEnd);
+
+inline const nsDependentCSubstring
+StringHead(const nsACString& aStr, uint32_t aCount)
+{
+  return nsDependentCSubstring(aStr, 0, aCount);
+}
+
+inline const nsDependentCSubstring
+StringTail(const nsACString& aStr, uint32_t aCount)
+{
+  return nsDependentCSubstring(aStr, aStr.Length() - aCount, aCount);
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+inline size_t
+Distance(const nsReadingIterator<char16_t>& aStart,
+         const nsReadingIterator<char16_t>& aEnd)
+{
+  do { } while (0);
+  return static_cast<size_t>(aEnd.get() - aStart.get());
+}
+inline size_t
+Distance(const nsReadingIterator<char>& aStart,
+         const nsReadingIterator<char>& aEnd)
+{
+  do { } while (0);
+  return static_cast<size_t>(aEnd.get() - aStart.get());
+}
+
+void LossyCopyUTF16toASCII(const nsAString& aSource, nsACString& aDest);
+void CopyASCIItoUTF16(const nsACString& aSource, nsAString& aDest);
+
+void LossyCopyUTF16toASCII(const char16ptr_t aSource, nsACString& aDest);
+void CopyASCIItoUTF16(const char* aSource, nsAString& aDest);
+
+void CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest);
+__attribute__ ((warn_unused_result)) bool CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest,
+                                  const mozilla::fallible_t&);
+void CopyUTF8toUTF16(const nsACString& aSource, nsAString& aDest);
+
+void CopyUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest);
+void CopyUTF8toUTF16(const char* aSource, nsAString& aDest);
+
+void LossyAppendUTF16toASCII(const nsAString& aSource, nsACString& aDest);
+void AppendASCIItoUTF16(const nsACString& aSource, nsAString& aDest);
+__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const nsACString& aSource,
+                                     nsAString& aDest,
+                                     const mozilla::fallible_t&);
+
+void LossyAppendUTF16toASCII(const char16ptr_t aSource, nsACString& aDest);
+__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const char* aSource,
+                                     nsAString& aDest,
+                                     const mozilla::fallible_t&);
+void AppendASCIItoUTF16(const char* aSource, nsAString& aDest);
+
+void AppendUTF16toUTF8(const nsAString& aSource, nsACString& aDest);
+__attribute__ ((warn_unused_result)) bool AppendUTF16toUTF8(const nsAString& aSource,
+                                    nsACString& aDest,
+                                    const mozilla::fallible_t&);
+void AppendUTF8toUTF16(const nsACString& aSource, nsAString& aDest);
+__attribute__ ((warn_unused_result)) bool AppendUTF8toUTF16(const nsACString& aSource,
+                                    nsAString& aDest,
+                                    const mozilla::fallible_t&);
+
+void AppendUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest);
+void AppendUTF8toUTF16(const char* aSource, nsAString& aDest);
+# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char* ToNewCString(const nsAString& aSource);
+# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char* ToNewCString(const nsACString& aSource);
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char* ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count = nullptr);
+# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char16_t* ToNewUnicode(const nsAString& aSource);
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char16_t* ToNewUnicode(const nsACString& aSource);
+# 153 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+uint32_t CalcUTF8ToUnicodeLength(const nsACString& aSource);
+# 173 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char16_t* UTF8ToUnicodeBuffer(const nsACString& aSource,
+                              char16_t* aBuffer,
+                              uint32_t* aUTF16Count = nullptr);
+# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char16_t* UTF8ToNewUnicode(const nsACString& aSource,
+                           uint32_t* aUTF16Count = nullptr);
+# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+char16_t* CopyUnicodeTo(const nsAString& aSource,
+                        uint32_t aSrcOffset,
+                        char16_t* aDest,
+                        uint32_t aLength);
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+void CopyUnicodeTo(const nsAString::const_iterator& aSrcStart,
+                   const nsAString::const_iterator& aSrcEnd,
+                   nsAString& aDest);
+# 238 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+void AppendUnicodeTo(const nsAString::const_iterator& aSrcStart,
+                     const nsAString::const_iterator& aSrcEnd,
+                     nsAString& aDest);
+
+
+
+
+
+
+bool IsASCII(const nsAString& aString);
+
+
+
+
+
+
+bool IsASCII(const nsACString& aString);
+# 287 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+bool IsUTF8(const nsACString& aString, bool aRejectNonChar = true);
+
+bool ParseString(const nsACString& aAstring, char aDelimiter,
+                 nsTArray<nsCString>& aArray);
+
+
+
+
+void ToUpperCase(nsACString&);
+
+void ToLowerCase(nsACString&);
+
+void ToUpperCase(nsCSubstring&);
+
+void ToLowerCase(nsCSubstring&);
+
+
+
+
+void ToUpperCase(const nsACString& aSource, nsACString& aDest);
+
+void ToLowerCase(const nsACString& aSource, nsACString& aDest);
+# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+bool FindInReadable(const nsAString& aPattern, nsAString::const_iterator&,
+                    nsAString::const_iterator&,
+                    const nsStringComparator& = nsDefaultStringComparator());
+bool FindInReadable(const nsACString& aPattern, nsACString::const_iterator&,
+                    nsACString::const_iterator&,
+                    const nsCStringComparator& = nsDefaultCStringComparator());
+
+
+
+inline bool
+FindInReadable(const nsAString& aPattern, const nsAString& aSource,
+               const nsStringComparator& aCompare = nsDefaultStringComparator())
+{
+  nsAString::const_iterator start, end;
+  aSource.BeginReading(start);
+  aSource.EndReading(end);
+  return FindInReadable(aPattern, start, end, aCompare);
+}
+
+inline bool
+FindInReadable(const nsACString& aPattern, const nsACString& aSource,
+               const nsCStringComparator& aCompare = nsDefaultCStringComparator())
+{
+  nsACString::const_iterator start, end;
+  aSource.BeginReading(start);
+  aSource.EndReading(end);
+  return FindInReadable(aPattern, start, end, aCompare);
+}
+
+
+bool CaseInsensitiveFindInReadable(const nsACString& aPattern,
+                                   nsACString::const_iterator&,
+                                   nsACString::const_iterator&);
+
+
+
+
+
+
+
+bool RFindInReadable(const nsAString& aPattern, nsAString::const_iterator&,
+                     nsAString::const_iterator&,
+                     const nsStringComparator& = nsDefaultStringComparator());
+bool RFindInReadable(const nsACString& aPattern, nsACString::const_iterator&,
+                     nsACString::const_iterator&,
+                     const nsCStringComparator& = nsDefaultCStringComparator());
+# 375 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+bool FindCharInReadable(char16_t aChar, nsAString::const_iterator& aSearchStart,
+                        const nsAString::const_iterator& aSearchEnd);
+bool FindCharInReadable(char aChar, nsACString::const_iterator& aSearchStart,
+                        const nsACString::const_iterator& aSearchEnd);
+
+
+
+
+uint32_t CountCharInReadable(const nsAString& aStr,
+                             char16_t aChar);
+uint32_t CountCharInReadable(const nsACString& aStr,
+                             char aChar);
+
+bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring);
+bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring,
+                      const nsStringComparator& aComparator);
+bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring);
+bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring,
+                      const nsCStringComparator& aComparator);
+bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring);
+bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring,
+                    const nsStringComparator& aComparator);
+bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring);
+bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring,
+                    const nsCStringComparator& aComparator);
+
+const nsAFlatString& EmptyString();
+const nsAFlatCString& EmptyCString();
+
+const nsAFlatString& NullString();
+const nsAFlatCString& NullCString();
+# 415 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
+int32_t CompareUTF8toUTF16(const nsASingleFragmentCString& aUTF8String,
+                           const nsASingleFragmentString& aUTF16String);
+
+void AppendUCS4ToUTF16(const uint32_t aSource, nsAString& aDest);
+
+template<class T>
+inline bool
+EnsureStringLength(T& aStr, uint32_t aLen)
+{
+  aStr.SetLength(aLen);
+  return (aStr.Length() == aLen);
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsString : public nsAString
+{
+public:
+
+  typedef nsString self_type;
+
+public:
+
+
+
+
+
+  nsString()
+    : substring_type()
+  {
+  }
+
+  explicit
+  nsString(const char_type* aData, size_type aLength = size_type(-1))
+    : substring_type()
+  {
+    Assign(aData, aLength);
+  }
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsString(const self_type& aStr)
+    : substring_type()
+  {
+    Assign(aStr);
+  }
+
+               nsString(const substring_tuple_type& aTuple)
+    : substring_type()
+  {
+    Assign(aTuple);
+  }
+
+  explicit
+  nsString(const substring_type& aReadable)
+    : substring_type()
+  {
+    Assign(aReadable);
+  }
+
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  const char_type* get() const
+
+  {
+    return mData;
+  }
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  char_type CharAt(index_type aIndex) const
+  {
+    do { } while(0);
+    return mData[aIndex];
+  }
+
+  char_type operator[](index_type aIndex) const
+  {
+    return CharAt(aIndex);
+  }
+# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t Find(const nsCString& aString, bool aIgnoreCase = false,
+               int32_t aOffset = 0, int32_t aCount = -1) const;
+  int32_t Find(const char* aString, bool aIgnoreCase = false,
+               int32_t aOffset = 0, int32_t aCount = -1) const;
+
+
+  int32_t Find(const nsAFlatString& aString, int32_t aOffset = 0,
+               int32_t aCount = -1) const;
+  int32_t Find(const char16_t* aString, int32_t aOffset = 0,
+               int32_t aCount = -1) const;
+# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFind(const nsCString& aString, bool aIgnoreCase = false,
+                int32_t aOffset = -1, int32_t aCount = -1) const;
+  int32_t RFind(const char* aCString, bool aIgnoreCase = false,
+                int32_t aOffset = -1, int32_t aCount = -1) const;
+
+
+  int32_t RFind(const nsAFlatString& aString, int32_t aOffset = -1,
+                int32_t aCount = -1) const;
+  int32_t RFind(const char16_t* aString, int32_t aOffset = -1,
+                int32_t aCount = -1) const;
+# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFindChar(char16_t aChar, int32_t aOffset = -1,
+                    int32_t aCount = -1) const;
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const;
+  int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const
+  {
+    return FindCharInSet(aString.get(), aOffset);
+  }
+
+
+  int32_t FindCharInSet(const char16_t* aString, int32_t aOffset = 0) const;
+# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const;
+  int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const
+  {
+    return RFindCharInSet(aString.get(), aOffset);
+  }
+# 281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const;
+# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  double ToDouble(nsresult* aErrorCode) const;
+
+
+
+
+
+
+
+  float ToFloat(nsresult* aErrorCode) const
+  {
+    return (float)ToDouble(aErrorCode);
+  }
+# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
+
+
+
+
+
+
+
+  int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const;
+
+  size_type Left(self_type& aResult, size_type aCount) const
+  {
+    return Mid(aResult, 0, aCount);
+  }
+
+  size_type Right(self_type& aResult, size_type aCount) const
+  {
+    aCount = XPCOM_MIN(mLength, aCount);
+    return Mid(aResult, mLength - aCount, aCount);
+  }
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  bool SetCharAt(char16_t aChar, uint32_t aIndex);
+# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  using nsAString::StripChars;
+
+  void StripChars(const char* aSet);
+  bool StripChars(const char* aSet, const fallible_t&);
+
+
+
+
+
+  void StripWhitespace();
+  bool StripWhitespace(const fallible_t&);
+
+
+
+
+
+
+  void ReplaceChar(char_type aOldChar, char_type aNewChar);
+  void ReplaceChar(const char* aSet, char_type aNewChar);
+
+  void ReplaceChar(const char16_t* aSet, char16_t aNewChar);
+
+
+
+
+
+
+  void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue);
+  void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue);
+  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget,
+                                     const self_type& aNewValue,
+                                     const fallible_t&);
+  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget,
+                                     const char_type* aNewValue,
+                                     const fallible_t&);
+# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void Trim(const char* aSet, bool aEliminateLeading = true,
+            bool aEliminateTrailing = true, bool aIgnoreQuotes = false);
+# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void CompressWhitespace(bool aEliminateLeading = true,
+                          bool aEliminateTrailing = true);
+
+
+
+
+
+
+  void AssignWithConversion(const nsACString& aString);
+  void AssignWithConversion(const incompatible_char_type* aData,
+                            int32_t aLength = -1);
+# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void Rebind(const char_type* aData, size_type aLength);
+
+
+
+
+  void AssertValidDependentString()
+  {
+    do { } while(0);
+    do { } while(0);
+    do { } while(0);
+
+
+  }
+
+
+protected:
+
+
+  nsString(char_type* aData, size_type aLength, uint32_t aFlags)
+    : substring_type(aData, aLength, aFlags)
+  {
+  }
+
+  struct Segment {
+    uint32_t mBegin, mLength;
+    Segment(uint32_t aBegin, uint32_t aLength)
+      : mBegin(aBegin)
+      , mLength(aLength)
+    {}
+  };
+};
+
+
+class nsFixedString : public nsString
+{
+public:
+
+  typedef nsFixedString self_type;
+  typedef nsFixedString fixed_string_type;
+
+public:
+# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsFixedString(char_type* aData, size_type aStorageSize)
+    : string_type(aData, uint32_t(char_traits::length(aData)),
+                  F_TERMINATED | F_FIXED | F_CLASS_FIXED)
+    , mFixedCapacity(aStorageSize - 1)
+    , mFixedBuf(aData)
+  {
+  }
+
+  nsFixedString(char_type* aData, size_type aStorageSize,
+                       size_type aLength)
+    : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED)
+    , mFixedCapacity(aStorageSize - 1)
+    , mFixedBuf(aData)
+  {
+
+    mFixedBuf[aLength] = char_type(0);
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+protected:
+
+  friend class nsAString;
+
+  size_type mFixedCapacity;
+  char_type* mFixedBuf;
+};
+# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsAutoString : public nsFixedString
+{
+public:
+
+  typedef nsAutoString self_type;
+
+public:
+
+
+
+
+
+  nsAutoString()
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+  }
+
+  explicit
+  nsAutoString(char_type aChar)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aChar);
+  }
+
+  explicit
+  nsAutoString(const char_type* aData, size_type aLength = size_type(-1))
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aData, aLength);
+  }
+# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsAutoString(const self_type& aStr)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aStr);
+  }
+
+  explicit
+  nsAutoString(const substring_type& aStr)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aStr);
+  }
+
+               nsAutoString(const substring_tuple_type& aTuple)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aTuple);
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+  enum
+  {
+    kDefaultStorageSize = 64
+  };
+
+private:
+
+  char_type mStorage[kDefaultStorageSize];
+};
+
+
+
+
+
+
+
+template<class E> class nsTArrayElementTraits;
+template<>
+class nsTArrayElementTraits<nsAutoString>
+{
+public:
+  template<class A> struct Dont_Instantiate_nsTArray_of;
+  template<class A> struct Instead_Use_nsTArray_of;
+
+  static Dont_Instantiate_nsTArray_of<nsAutoString>*
+  Construct(Instead_Use_nsTArray_of<nsString>* aE)
+  {
+    return 0;
+  }
+  template<class A>
+  static Dont_Instantiate_nsTArray_of<nsAutoString>*
+  Construct(Instead_Use_nsTArray_of<nsString>* aE, const A& aArg)
+  {
+    return 0;
+  }
+  static Dont_Instantiate_nsTArray_of<nsAutoString>*
+  Destruct(Instead_Use_nsTArray_of<nsString>* aE)
+  {
+    return 0;
+  }
+};
+# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsXPIDLString : public nsString
+{
+public:
+
+  typedef nsXPIDLString self_type;
+
+public:
+
+  nsXPIDLString()
+    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
+  {
+  }
+
+
+  nsXPIDLString(const self_type& aStr)
+    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
+  {
+    Assign(aStr);
+  }
+
+
+
+
+
+  const char_type* get() const
+
+  {
+    return (mFlags & F_VOIDED) ? nullptr : mData;
+  }
+
+
+
+  operator const char_type*() const
+  {
+    return get();
+  }
+
+
+  char_type operator[](int32_t aIndex) const
+  {
+    return CharAt(index_type(aIndex));
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+};
+# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsGetterCopies
+{
+public:
+  typedef char16_t char_type;
+
+  explicit nsGetterCopies(nsAString& aStr)
+    : mString(aStr)
+    , mData(nullptr)
+  {
+  }
+
+  ~nsGetterCopies()
+  {
+    mString.Adopt(mData);
+  }
+
+  operator char_type**()
+  {
+    return &mData;
+  }
+
+private:
+  nsAString& mString;
+  char_type* mData;
+};
+
+inline nsGetterCopies
+getter_Copies(nsAString& aString)
+{
+  return nsGetterCopies(aString);
+}
+# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsAdoptingString : public nsXPIDLString
+{
+public:
+
+  typedef nsAdoptingString self_type;
+
+public:
+
+  explicit nsAdoptingString()
+  {
+  }
+  explicit nsAdoptingString(char_type* aStr,
+                                   size_type aLength = size_type(-1))
+  {
+    Adopt(aStr, aLength);
+  }
+
+
+
+
+
+  nsAdoptingString(const self_type& aStr)
+    : nsXPIDLString()
+  {
+    *this = aStr;
+  }
+
+
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+
+
+
+  self_type& operator=(const self_type& aStr);
+
+private:
+  self_type& operator=(const char_type* aData) = delete;
+  self_type& operator=(char_type* aData) = delete;
+};
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsCString : public nsACString
+{
+public:
+
+  typedef nsCString self_type;
+
+public:
+
+
+
+
+
+  nsCString()
+    : substring_type()
+  {
+  }
+
+  explicit
+  nsCString(const char_type* aData, size_type aLength = size_type(-1))
+    : substring_type()
+  {
+    Assign(aData, aLength);
+  }
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsCString(const self_type& aStr)
+    : substring_type()
+  {
+    Assign(aStr);
+  }
+
+               nsCString(const substring_tuple_type& aTuple)
+    : substring_type()
+  {
+    Assign(aTuple);
+  }
+
+  explicit
+  nsCString(const substring_type& aReadable)
+    : substring_type()
+  {
+    Assign(aReadable);
+  }
+
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  const char_type* get() const
+
+  {
+    return mData;
+  }
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  char_type CharAt(index_type aIndex) const
+  {
+    do { } while(0);
+    return mData[aIndex];
+  }
+
+  char_type operator[](index_type aIndex) const
+  {
+    return CharAt(aIndex);
+  }
+# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t Find(const nsCString& aString, bool aIgnoreCase = false,
+               int32_t aOffset = 0, int32_t aCount = -1) const;
+  int32_t Find(const char* aString, bool aIgnoreCase = false,
+               int32_t aOffset = 0, int32_t aCount = -1) const;
+# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFind(const nsCString& aString, bool aIgnoreCase = false,
+                int32_t aOffset = -1, int32_t aCount = -1) const;
+  int32_t RFind(const char* aCString, bool aIgnoreCase = false,
+                int32_t aOffset = -1, int32_t aCount = -1) const;
+# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFindChar(char16_t aChar, int32_t aOffset = -1,
+                    int32_t aCount = -1) const;
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const;
+  int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const
+  {
+    return FindCharInSet(aString.get(), aOffset);
+  }
+# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const;
+  int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const
+  {
+    return RFindCharInSet(aString.get(), aOffset);
+  }
+# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t Compare(const char* aString, bool aIgnoreCase = false,
+                  int32_t aCount = -1) const;
+# 276 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const
+  {
+    return Compare(aString, true, aCount) == 0;
+  }
+# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  double ToDouble(nsresult* aErrorCode) const;
+
+
+
+
+
+
+
+  float ToFloat(nsresult* aErrorCode) const
+  {
+    return (float)ToDouble(aErrorCode);
+  }
+# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
+
+
+
+
+
+
+
+  int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const;
+
+  size_type Left(self_type& aResult, size_type aCount) const
+  {
+    return Mid(aResult, 0, aCount);
+  }
+
+  size_type Right(self_type& aResult, size_type aCount) const
+  {
+    aCount = XPCOM_MIN(mLength, aCount);
+    return Mid(aResult, mLength - aCount, aCount);
+  }
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  bool SetCharAt(char16_t aChar, uint32_t aIndex);
+# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void StripChars(const char* aSet);
+  bool StripChars(const char* aSet, const fallible_t&);
+
+
+
+
+
+  void StripWhitespace();
+  bool StripWhitespace(const fallible_t&);
+
+
+
+
+
+
+  void ReplaceChar(char_type aOldChar, char_type aNewChar);
+  void ReplaceChar(const char* aSet, char_type aNewChar);
+# 399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue);
+  void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue);
+  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget,
+                                     const self_type& aNewValue,
+                                     const fallible_t&);
+  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget,
+                                     const char_type* aNewValue,
+                                     const fallible_t&);
+# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void Trim(const char* aSet, bool aEliminateLeading = true,
+            bool aEliminateTrailing = true, bool aIgnoreQuotes = false);
+# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void CompressWhitespace(bool aEliminateLeading = true,
+                          bool aEliminateTrailing = true);
+
+
+
+
+
+
+  void AssignWithConversion(const nsAString& aString);
+  void AssignWithConversion(const incompatible_char_type* aData,
+                            int32_t aLength = -1);
+# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  void Rebind(const char_type* aData, size_type aLength);
+
+
+
+
+  void AssertValidDependentString()
+  {
+    do { } while(0);
+    do { } while(0);
+    do { } while(0);
+
+
+  }
+
+
+protected:
+
+
+  nsCString(char_type* aData, size_type aLength, uint32_t aFlags)
+    : substring_type(aData, aLength, aFlags)
+  {
+  }
+
+  struct Segment {
+    uint32_t mBegin, mLength;
+    Segment(uint32_t aBegin, uint32_t aLength)
+      : mBegin(aBegin)
+      , mLength(aLength)
+    {}
+  };
+};
+
+
+class nsFixedCString : public nsCString
+{
+public:
+
+  typedef nsFixedCString self_type;
+  typedef nsFixedCString fixed_string_type;
+
+public:
+# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsFixedCString(char_type* aData, size_type aStorageSize)
+    : string_type(aData, uint32_t(char_traits::length(aData)),
+                  F_TERMINATED | F_FIXED | F_CLASS_FIXED)
+    , mFixedCapacity(aStorageSize - 1)
+    , mFixedBuf(aData)
+  {
+  }
+
+  nsFixedCString(char_type* aData, size_type aStorageSize,
+                       size_type aLength)
+    : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED)
+    , mFixedCapacity(aStorageSize - 1)
+    , mFixedBuf(aData)
+  {
+
+    mFixedBuf[aLength] = char_type(0);
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+protected:
+
+  friend class nsACString;
+
+  size_type mFixedCapacity;
+  char_type* mFixedBuf;
+};
+# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsAutoCString : public nsFixedCString
+{
+public:
+
+  typedef nsAutoCString self_type;
+
+public:
+
+
+
+
+
+  nsAutoCString()
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+  }
+
+  explicit
+  nsAutoCString(char_type aChar)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aChar);
+  }
+
+  explicit
+  nsAutoCString(const char_type* aData, size_type aLength = size_type(-1))
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aData, aLength);
+  }
+# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+  nsAutoCString(const self_type& aStr)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aStr);
+  }
+
+  explicit
+  nsAutoCString(const substring_type& aStr)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aStr);
+  }
+
+               nsAutoCString(const substring_tuple_type& aTuple)
+    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
+  {
+    Assign(aTuple);
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aData)
+  {
+    Assign(aData);
+    return *this;
+  }
+
+
+
+
+
+
+
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+  enum
+  {
+    kDefaultStorageSize = 64
+  };
+
+private:
+
+  char_type mStorage[kDefaultStorageSize];
+};
+
+
+
+
+
+
+
+template<class E> class nsTArrayElementTraits;
+template<>
+class nsTArrayElementTraits<nsAutoCString>
+{
+public:
+  template<class A> struct Dont_Instantiate_nsTArray_of;
+  template<class A> struct Instead_Use_nsTArray_of;
+
+  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
+  Construct(Instead_Use_nsTArray_of<nsCString>* aE)
+  {
+    return 0;
+  }
+  template<class A>
+  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
+  Construct(Instead_Use_nsTArray_of<nsCString>* aE, const A& aArg)
+  {
+    return 0;
+  }
+  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
+  Destruct(Instead_Use_nsTArray_of<nsCString>* aE)
+  {
+    return 0;
+  }
+};
+# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsXPIDLCString : public nsCString
+{
+public:
+
+  typedef nsXPIDLCString self_type;
+
+public:
+
+  nsXPIDLCString()
+    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
+  {
+  }
+
+
+  nsXPIDLCString(const self_type& aStr)
+    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
+  {
+    Assign(aStr);
+  }
+
+
+
+
+
+  const char_type* get() const
+
+  {
+    return (mFlags & F_VOIDED) ? nullptr : mData;
+  }
+
+
+
+  operator const char_type*() const
+  {
+    return get();
+  }
+
+
+  char_type operator[](int32_t aIndex) const
+  {
+    return CharAt(index_type(aIndex));
+  }
+
+
+  self_type& operator=(char_type aChar)
+  {
+    Assign(aChar);
+    return *this;
+  }
+  self_type& operator=(const char_type* aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const self_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+};
+# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsCGetterCopies
+{
+public:
+  typedef char char_type;
+
+  explicit nsCGetterCopies(nsACString& aStr)
+    : mString(aStr)
+    , mData(nullptr)
+  {
+  }
+
+  ~nsCGetterCopies()
+  {
+    mString.Adopt(mData);
+  }
+
+  operator char_type**()
+  {
+    return &mData;
+  }
+
+private:
+  nsACString& mString;
+  char_type* mData;
+};
+
+inline nsCGetterCopies
+getter_Copies(nsACString& aString)
+{
+  return nsCGetterCopies(aString);
+}
+# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
+class nsAdoptingCString : public nsXPIDLCString
+{
+public:
+
+  typedef nsAdoptingCString self_type;
+
+public:
+
+  explicit nsAdoptingCString()
+  {
+  }
+  explicit nsAdoptingCString(char_type* aStr,
+                                   size_type aLength = size_type(-1))
+  {
+    Adopt(aStr, aLength);
+  }
+
+
+
+
+
+  nsAdoptingCString(const self_type& aStr)
+    : nsXPIDLCString()
+  {
+    *this = aStr;
+  }
+
+
+  self_type& operator=(const substring_type& aStr)
+  {
+    Assign(aStr);
+    return *this;
+  }
+  self_type& operator=(const substring_tuple_type& aTuple)
+  {
+    Assign(aTuple);
+    return *this;
+  }
+
+
+
+
+  self_type& operator=(const self_type& aStr);
+
+private:
+  self_type& operator=(const char_type* aData) = delete;
+  self_type& operator=(char_type* aData) = delete;
+};
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+
+static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2");
+static_assert(sizeof(nsString::char_type) == 2,
+              "size of nsString::char_type must be 2");
+static_assert(nsString::char_type(-1) > nsString::char_type(0),
+              "nsString::char_type must be unsigned");
+static_assert(sizeof(nsCString::char_type) == 1,
+              "size of nsCString::char_type must be 1");
+
+
+
+
+
+class NS_LossyConvertUTF16toASCII : public nsAutoCString
+{
+public:
+  explicit NS_LossyConvertUTF16toASCII(const char16ptr_t aString)
+  {
+    LossyAppendUTF16toASCII(aString, *this);
+  }
+
+  NS_LossyConvertUTF16toASCII(const char16ptr_t aString, uint32_t aLength)
+  {
+    LossyAppendUTF16toASCII(Substring(aString, aLength), *this);
+  }
+
+  explicit NS_LossyConvertUTF16toASCII(const nsAString& aString)
+  {
+    LossyAppendUTF16toASCII(aString, *this);
+  }
+
+private:
+
+  NS_LossyConvertUTF16toASCII(char) = delete;
+};
+
+
+class NS_ConvertASCIItoUTF16 : public nsAutoString
+{
+public:
+  explicit NS_ConvertASCIItoUTF16(const char* aCString)
+  {
+    AppendASCIItoUTF16(aCString, *this);
+  }
+
+  NS_ConvertASCIItoUTF16(const char* aCString, uint32_t aLength)
+  {
+    AppendASCIItoUTF16(Substring(aCString, aLength), *this);
+  }
+
+  explicit NS_ConvertASCIItoUTF16(const nsACString& aCString)
+  {
+    AppendASCIItoUTF16(aCString, *this);
+  }
+
+private:
+
+  NS_ConvertASCIItoUTF16(char16_t) = delete;
+};
+
+
+
+
+
+class NS_ConvertUTF16toUTF8 : public nsAutoCString
+{
+public:
+  explicit NS_ConvertUTF16toUTF8(const char16ptr_t aString)
+  {
+    AppendUTF16toUTF8(aString, *this);
+  }
+
+  NS_ConvertUTF16toUTF8(const char16ptr_t aString, uint32_t aLength)
+  {
+    AppendUTF16toUTF8(Substring(aString, aLength), *this);
+  }
+
+  explicit NS_ConvertUTF16toUTF8(const nsAString& aString)
+  {
+    AppendUTF16toUTF8(aString, *this);
+  }
+
+private:
+
+  NS_ConvertUTF16toUTF8(char) = delete;
+};
+
+
+class NS_ConvertUTF8toUTF16 : public nsAutoString
+{
+public:
+  explicit NS_ConvertUTF8toUTF16(const char* aCString)
+  {
+    AppendUTF8toUTF16(aCString, *this);
+  }
+
+  NS_ConvertUTF8toUTF16(const char* aCString, uint32_t aLength)
+  {
+    AppendUTF8toUTF16(Substring(aCString, aLength), *this);
+  }
+
+  explicit NS_ConvertUTF8toUTF16(const nsACString& aCString)
+  {
+    AppendUTF8toUTF16(aCString, *this);
+  }
+
+private:
+
+  NS_ConvertUTF8toUTF16(char16_t) = delete;
+};
+# 180 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
+inline char16_t*
+wwc(char16_t* aStr)
+{
+  return aStr;
+}
+
+inline const char16_t*
+wwc(const char16_t* aStr)
+{
+  return aStr;
+}
+
+
+
+
+typedef nsAutoString nsVoidableString;
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+class nsDependentString : public nsString
+{
+public:
+
+  typedef nsDependentString self_type;
+
+public:
+
+
+
+
+
+  nsDependentString(const char_type* aStart, const char_type* aEnd);
+
+  nsDependentString(const char_type* aData, uint32_t aLength)
+    : string_type(const_cast<char_type*>(aData), aLength, F_TERMINATED)
+  {
+    AssertValidDependentString();
+  }
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  explicit
+  nsDependentString(const char_type* aData)
+    : string_type(const_cast<char_type*>(aData),
+                  uint32_t(char_traits::length(aData)), F_TERMINATED)
+  {
+    AssertValidDependentString();
+  }
+# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  nsDependentString(const string_type& aStr, uint32_t aStartPos)
+    : string_type()
+  {
+    Rebind(aStr, aStartPos);
+  }
+
+
+  nsDependentString()
+    : string_type()
+  {
+  }
+# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  using nsString::Rebind;
+  void Rebind(const char_type* aData)
+  {
+    Rebind(aData, uint32_t(char_traits::length(aData)));
+  }
+
+  void Rebind(const char_type* aStart, const char_type* aEnd);
+  void Rebind(const string_type&, uint32_t aStartPos);
+
+private:
+
+
+  nsDependentString(const substring_tuple_type&) = delete;
+};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+class nsDependentCString : public nsCString
+{
+public:
+
+  typedef nsDependentCString self_type;
+
+public:
+
+
+
+
+
+  nsDependentCString(const char_type* aStart, const char_type* aEnd);
+
+  nsDependentCString(const char_type* aData, uint32_t aLength)
+    : string_type(const_cast<char_type*>(aData), aLength, F_TERMINATED)
+  {
+    AssertValidDependentString();
+  }
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  explicit
+  nsDependentCString(const char_type* aData)
+    : string_type(const_cast<char_type*>(aData),
+                  uint32_t(char_traits::length(aData)), F_TERMINATED)
+  {
+    AssertValidDependentString();
+  }
+# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  nsDependentCString(const string_type& aStr, uint32_t aStartPos)
+    : string_type()
+  {
+    Rebind(aStr, aStartPos);
+  }
+
+
+  nsDependentCString()
+    : string_type()
+  {
+  }
+# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
+  using nsCString::Rebind;
+  void Rebind(const char_type* aData)
+  {
+    Rebind(aData, uint32_t(char_traits::length(aData)));
+  }
+
+  void Rebind(const char_type* aStart, const char_type* aEnd);
+  void Rebind(const string_type&, uint32_t aStartPos);
+
+private:
+
+
+  nsDependentCString(const substring_tuple_type&) = delete;
+};
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
+# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
+class nsLiteralString : public mozilla::detail::nsStringRepr
+{
+public:
+
+  typedef nsLiteralString self_type;
+
+public:
+
+
+
+
+
+  template<size_type N>
+  explicit nsLiteralString(const char_type (&aStr)[N])
+    : base_string_type(const_cast<char_type*>(aStr), N - 1, F_TERMINATED | F_LITERAL)
+  {
+  }
+
+
+
+
+
+
+  const nsString& AsString() const
+  {
+    return *reinterpret_cast<const nsString*>(this);
+  }
+
+  operator const nsString&() const
+  {
+    return AsString();
+  }
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
+  const char_type* get() const && = delete;
+  const char_type* get() const &
+
+  {
+    return mData;
+  }
+
+private:
+
+
+  template<size_type N>
+  nsLiteralString(char_type (&aStr)[N]) = delete;
+
+  self_type& operator=(const self_type&) = delete;
+};
+
+static_assert(sizeof(nsLiteralString) == sizeof(nsString),
+              "nsTLiteralString_CharT can masquerade as nsTString_CharT, "
+              "so they must have identical layout");
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
+class nsLiteralCString : public mozilla::detail::nsCStringRepr
+{
+public:
+
+  typedef nsLiteralCString self_type;
+
+public:
+
+
+
+
+
+  template<size_type N>
+  explicit nsLiteralCString(const char_type (&aStr)[N])
+    : base_string_type(const_cast<char_type*>(aStr), N - 1, F_TERMINATED | F_LITERAL)
+  {
+  }
+
+
+
+
+
+
+  const nsCString& AsString() const
+  {
+    return *reinterpret_cast<const nsCString*>(this);
+  }
+
+  operator const nsCString&() const
+  {
+    return AsString();
+  }
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
+  const char_type* get() const && = delete;
+  const char_type* get() const &
+
+  {
+    return mData;
+  }
+
+private:
+
+
+  template<size_type N>
+  nsLiteralCString(char_type (&aStr)[N]) = delete;
+
+  self_type& operator=(const self_type&) = delete;
+};
+
+static_assert(sizeof(nsLiteralCString) == sizeof(nsCString),
+              "nsTLiteralString_CharT can masquerade as nsTString_CharT, "
+              "so they must have identical layout");
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
+# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h"
+class nsPromiseFlatString : public nsString
+{
+public:
+
+  typedef nsPromiseFlatString self_type;
+
+private:
+
+  void Init(const substring_type&);
+
+
+  void operator=(const self_type&) = delete;
+
+
+  nsPromiseFlatString() = delete;
+
+
+  nsPromiseFlatString(const string_type& aStr) = delete;
+
+public:
+
+  explicit
+  nsPromiseFlatString(const substring_type& aStr)
+    : string_type()
+  {
+    Init(aStr);
+  }
+
+  explicit
+  nsPromiseFlatString(const substring_tuple_type& aTuple)
+    : string_type()
+  {
+
+
+    Assign(aTuple);
+  }
+};
+
+
+
+template<class T>
+const nsPromiseFlatString
+PromiseFlatString(const T& aString)
+{
+  return nsPromiseFlatString(aString);
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h"
+class nsPromiseFlatCString : public nsCString
+{
+public:
+
+  typedef nsPromiseFlatCString self_type;
+
+private:
+
+  void Init(const substring_type&);
+
+
+  void operator=(const self_type&) = delete;
+
+
+  nsPromiseFlatCString() = delete;
+
+
+  nsPromiseFlatCString(const string_type& aStr) = delete;
+
+public:
+
+  explicit
+  nsPromiseFlatCString(const substring_type& aStr)
+    : string_type()
+  {
+    Init(aStr);
+  }
+
+  explicit
+  nsPromiseFlatCString(const substring_tuple_type& aTuple)
+    : string_type()
+  {
+
+
+    Assign(aTuple);
+  }
+};
+
+
+
+template<class T>
+const nsPromiseFlatCString
+PromiseFlatCString(const T& aString)
+{
+  return nsPromiseFlatCString(aString);
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
+# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
+class nsIMemory;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
+class nsMemory
+{
+public:
+  static nsresult HeapMinimize(bool aImmediate);
+  static void* Clone(const void* aPtr, size_t aSize);
+  static nsIMemory* GetGlobalMemoryService();
+};
+# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
+namespace mozilla {
+template<class T>
+struct AlignmentTestStruct
+{
+  char c;
+  T t;
+};
+}
+
+
+
+
+
+
+
+enum nsAssignmentType
+{
+  NS_ASSIGNMENT_COPY,
+  NS_ASSIGNMENT_DEPEND,
+  NS_ASSIGNMENT_ADOPT
+};
+# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h"
+extern "C" {
+
+typedef struct PLHashEntry PLHashEntry;
+typedef struct PLHashTable PLHashTable;
+typedef PRUint32 PLHashNumber;
+
+typedef PLHashNumber ( *PLHashFunction)(const void *key);
+typedef PRIntn ( *PLHashComparator)(const void *v1, const void *v2);
+
+typedef PRIntn ( *PLHashEnumerator)(PLHashEntry *he, PRIntn i, void *arg);
+
+
+
+
+
+
+
+typedef struct PLHashAllocOps {
+    void * ( *allocTable)(void *pool, PRSize size);
+    void ( *freeTable)(void *pool, void *item);
+    PLHashEntry * ( *allocEntry)(void *pool, const void *key);
+    void ( *freeEntry)(void *pool, PLHashEntry *he, PRUintn flag);
+} PLHashAllocOps;
+
+
+
+
+struct PLHashEntry {
+    PLHashEntry *next;
+    PLHashNumber keyHash;
+    const void *key;
+    void *value;
+};
+
+struct PLHashTable {
+    PLHashEntry **buckets;
+    PRUint32 nentries;
+    PRUint32 shift;
+    PLHashFunction keyHash;
+    PLHashComparator keyCompare;
+    PLHashComparator valueCompare;
+    const PLHashAllocOps *allocOps;
+    void *allocPriv;
+
+
+
+
+
+
+};
+
+
+
+
+
+extern __attribute__((visibility("default"))) PLHashTable *
+PL_NewHashTable(PRUint32 numBuckets, PLHashFunction keyHash,
+                PLHashComparator keyCompare, PLHashComparator valueCompare,
+                const PLHashAllocOps *allocOps, void *allocPriv);
+
+extern __attribute__((visibility("default"))) void
+PL_HashTableDestroy(PLHashTable *ht);
+
+
+extern __attribute__((visibility("default"))) PLHashEntry *
+PL_HashTableAdd(PLHashTable *ht, const void *key, void *value);
+
+extern __attribute__((visibility("default"))) PRBool
+PL_HashTableRemove(PLHashTable *ht, const void *key);
+
+extern __attribute__((visibility("default"))) void *
+PL_HashTableLookup(PLHashTable *ht, const void *key);
+
+extern __attribute__((visibility("default"))) void *
+PL_HashTableLookupConst(PLHashTable *ht, const void *key);
+
+extern __attribute__((visibility("default"))) PRIntn
+PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg);
+
+
+extern __attribute__((visibility("default"))) PLHashNumber
+PL_HashString(const void *key);
+
+
+extern __attribute__((visibility("default"))) PRIntn
+PL_CompareStrings(const void *v1, const void *v2);
+
+
+extern __attribute__((visibility("default"))) PRIntn
+PL_CompareValues(const void *v1, const void *v2);
+
+
+extern __attribute__((visibility("default"))) PLHashEntry **
+PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key);
+
+extern __attribute__((visibility("default"))) PLHashEntry **
+PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash,
+                           const void *key);
+
+extern __attribute__((visibility("default"))) PLHashEntry *
+PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep, PLHashNumber keyHash,
+                   const void *key, void *value);
+
+extern __attribute__((visibility("default"))) void
+PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he);
+
+
+extern __attribute__((visibility("default"))) PRIntn
+PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp);
+
+}
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 2
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" 1
+# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+namespace mozilla {
+template<class T> class OwningNonNull;
+}
+
+template<class T>
+inline already_AddRefed<T>
+dont_AddRef(T* aRawPtr)
+{
+  return already_AddRefed<T>(aRawPtr);
+}
+
+template<class T>
+inline already_AddRefed<T>&&
+dont_AddRef(already_AddRefed<T>&& aAlreadyAddRefedPtr)
+{
+  return mozilla::Move(aAlreadyAddRefedPtr);
+}
+# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+class nsCOMPtr_helper
+{
+public:
+  virtual nsresult operator()(const nsIID&, void**) const = 0;
+};
+
+
+
+
+
+
+
+class nsQueryInterface final
+{
+public:
+  explicit
+  nsQueryInterface(nsISupports* aRawPtr) : mRawPtr(aRawPtr) {}
+
+  nsresult operator()(const nsIID& aIID, void**) const;
+
+private:
+  nsISupports* mRawPtr;
+};
+
+class nsQueryInterfaceWithError final
+{
+public:
+  nsQueryInterfaceWithError(nsISupports* aRawPtr, nsresult* aError)
+    : mRawPtr(aRawPtr)
+    , mErrorPtr(aError)
+  {
+  }
+
+  nsresult operator()(const nsIID& aIID, void**) const;
+
+private:
+  nsISupports* mRawPtr;
+  nsresult* mErrorPtr;
+};
+
+inline nsQueryInterface
+do_QueryInterface(nsISupports* aRawPtr)
+{
+  return nsQueryInterface(aRawPtr);
+}
+
+inline nsQueryInterfaceWithError
+do_QueryInterface(nsISupports* aRawPtr, nsresult* aError)
+{
+  return nsQueryInterfaceWithError(aRawPtr, aError);
+}
+
+template<class T>
+inline void
+do_QueryInterface(already_AddRefed<T>&)
+{
+
+
+
+}
+
+template<class T>
+inline void
+do_QueryInterface(already_AddRefed<T>&, nsresult*)
+{
+
+
+
+}
+
+
+
+
+class nsGetServiceByCID final
+{
+public:
+  explicit nsGetServiceByCID(const nsCID& aCID) : mCID(aCID) {}
+
+  nsresult operator()(const nsIID&, void**) const;
+
+private:
+  const nsCID& mCID;
+};
+
+class nsGetServiceByCIDWithError final
+{
+public:
+  nsGetServiceByCIDWithError(const nsCID& aCID, nsresult* aErrorPtr)
+    : mCID(aCID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  nsresult operator()(const nsIID&, void**) const;
+
+private:
+  const nsCID& mCID;
+  nsresult* mErrorPtr;
+};
+
+class nsGetServiceByContractID final
+{
+public:
+  explicit nsGetServiceByContractID(const char* aContractID)
+    : mContractID(aContractID)
+  {
+  }
+
+  nsresult operator()(const nsIID&, void**) const;
+
+private:
+  const char* mContractID;
+};
+
+class nsGetServiceByContractIDWithError final
+{
+public:
+  nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr)
+    : mContractID(aContractID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  nsresult operator()(const nsIID&, void**) const;
+
+private:
+  const char* mContractID;
+  nsresult* mErrorPtr;
+};
+# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+class nsCOMPtr_base
+{
+public:
+  explicit nsCOMPtr_base(nsISupports* aRawPtr = nullptr) : mRawPtr(aRawPtr) {}
+
+                          ~nsCOMPtr_base()
+  {
+                                    ;
+    if (mRawPtr) {
+      (mRawPtr)->Release();
+    }
+  }
+
+  void
+  assign_with_AddRef(nsISupports*);
+  void
+  assign_from_qi(const nsQueryInterface, const nsIID&);
+  void
+  assign_from_qi_with_error(const nsQueryInterfaceWithError&, const nsIID&);
+  void
+  assign_from_gs_cid(const nsGetServiceByCID, const nsIID&);
+  void
+  assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError&, const nsIID&);
+  void
+  assign_from_gs_contractid(const nsGetServiceByContractID, const nsIID&);
+  void
+  assign_from_gs_contractid_with_error(const nsGetServiceByContractIDWithError&,
+                                       const nsIID&);
+  void
+  assign_from_helper(const nsCOMPtr_helper&, const nsIID&);
+  void**
+  begin_assignment();
+
+protected:
+  nsISupports* __attribute__((__may_alias__)) mRawPtr;
+
+  void assign_assuming_AddRef(nsISupports* aNewPtr)
+  {
+
+
+
+
+
+
+    nsISupports* oldPtr = mRawPtr;
+    mRawPtr = aNewPtr;
+                                       ;
+                                   ;
+    if (oldPtr) {
+      (oldPtr)->Release();
+    }
+  }
+};
+
+
+
+
+template<class T>
+char (&TestForIID(decltype(&(T::template COMTypeInfo<T, void>::kIID))))[2];
+template<class T>
+char TestForIID(...);
+
+template<class T>
+class nsCOMPtr final
+
+  : private nsCOMPtr_base
+
+{
+# 387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+  void assert_validity()
+  {
+    static_assert(1 < sizeof(TestForIID<T>(nullptr)), "nsCOMPtr only works "
+                  "for types with IIDs.  Either use RefPtr; add an IID to "
+                  "your type with NS_DECLARE_STATIC_IID_ACCESSOR/"
+                  "NS_DEFINE_STATIC_IID_ACCESSOR; or make the nsCOMPtr point "
+                  "to a base class with an IID.");
+  }
+
+public:
+  typedef T element_type;
+# 426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+  nsCOMPtr()
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+  }
+
+               nsCOMPtr(decltype(nullptr))
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+  }
+
+  nsCOMPtr(const nsCOMPtr<T>& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.mRawPtr)
+  {
+    assert_validity();
+    if (mRawPtr) {
+      (mRawPtr)->AddRef();
+    }
+                                                 ;
+  }
+
+  nsCOMPtr(nsCOMPtr<T>&& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.mRawPtr)
+  {
+    assert_validity();
+    aSmartPtr.mRawPtr = nullptr;
+                                       ;
+                                  ;
+  }
+
+               nsCOMPtr(T* aRawPtr)
+    : nsCOMPtr_base(aRawPtr)
+  {
+    assert_validity();
+    if (mRawPtr) {
+      (mRawPtr)->AddRef();
+    }
+                                       ;
+                                  ;
+  }
+
+               nsCOMPtr(already_AddRefed<T>& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.take())
+  {
+    assert_validity();
+                                       ;
+                                  ;
+  }
+
+
+               nsCOMPtr(already_AddRefed<T>&& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.take())
+  {
+    assert_validity();
+                                       ;
+                                  ;
+  }
+
+
+  template<typename U>
+               nsCOMPtr(already_AddRefed<U>& aSmartPtr)
+    : nsCOMPtr_base(static_cast<T*>(aSmartPtr.take()))
+  {
+    assert_validity();
+
+    static_assert(mozilla::IsBaseOf<T, U>::value,
+                  "U is not a subclass of T");
+                                                        ;
+                                  ;
+  }
+
+
+  template<typename U>
+               nsCOMPtr(already_AddRefed<U>&& aSmartPtr)
+    : nsCOMPtr_base(static_cast<T*>(aSmartPtr.take()))
+  {
+    assert_validity();
+
+    static_assert(mozilla::IsBaseOf<T, U>::value,
+                  "U is not a subclass of T");
+                                                        ;
+                                  ;
+  }
+
+
+               nsCOMPtr(const nsQueryInterface aQI)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_qi(aQI, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsQueryInterfaceWithError& aQI)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_qi_with_error(aQI, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByCID aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_gs_cid(aGS, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_gs_cid_with_error(aGS, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByContractID aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_gs_contractid(aGS, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_gs_contractid_with_error(aGS, (T::template COMTypeInfo<T, void>::kIID));
+  }
+
+
+
+               nsCOMPtr(const nsCOMPtr_helper& aHelper)
+    : nsCOMPtr_base(nullptr)
+  {
+    assert_validity();
+                                       ;
+    assign_from_helper(aHelper, (T::template COMTypeInfo<T, void>::kIID));
+                                  ;
+  }
+
+
+  template<class U>
+               nsCOMPtr(const mozilla::OwningNonNull<U>& aOther);
+
+
+
+
+  nsCOMPtr<T>& operator=(const nsCOMPtr<T>& aRhs)
+  {
+    assign_with_AddRef(aRhs.mRawPtr);
+    return *this;
+  }
+
+  nsCOMPtr<T>& operator=(T* aRhs)
+  {
+    assign_with_AddRef(aRhs);
+                                  ;
+    return *this;
+  }
+
+  nsCOMPtr<T>& operator=(decltype(nullptr))
+  {
+    assign_assuming_AddRef(nullptr);
+    return *this;
+  }
+
+
+  template<typename U>
+  nsCOMPtr<T>& operator=(already_AddRefed<U>& aRhs)
+  {
+
+    static_assert(mozilla::IsBaseOf<T, U>::value,
+                  "U is not a subclass of T");
+    assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
+                                  ;
+    return *this;
+  }
+
+
+  template<typename U>
+  nsCOMPtr<T>& operator=(already_AddRefed<U>&& aRhs)
+  {
+
+    static_assert(mozilla::IsBaseOf<T, U>::value,
+                  "U is not a subclass of T");
+    assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
+                                  ;
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsQueryInterface aRhs)
+  {
+    assign_from_qi(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsQueryInterfaceWithError& aRhs)
+  {
+    assign_from_qi_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsGetServiceByCID aRhs)
+  {
+    assign_from_gs_cid(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsGetServiceByCIDWithError& aRhs)
+  {
+    assign_from_gs_cid_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsGetServiceByContractID aRhs)
+  {
+    assign_from_gs_contractid(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<T>& operator=(const nsGetServiceByContractIDWithError& aRhs)
+  {
+    assign_from_gs_contractid_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+    return *this;
+  }
+
+
+
+  nsCOMPtr<T>& operator=(const nsCOMPtr_helper& aRhs)
+  {
+    assign_from_helper(aRhs, (T::template COMTypeInfo<T, void>::kIID));
+                                  ;
+    return *this;
+  }
+
+
+  template<class U>
+  nsCOMPtr<T>& operator=(const mozilla::OwningNonNull<U>& aOther);
+
+
+  void swap(nsCOMPtr<T>& aRhs)
+  {
+
+    nsISupports* temp = aRhs.mRawPtr;
+
+
+
+                                        ;
+                                    ;
+                                    ;
+                                  ;
+    aRhs.mRawPtr = mRawPtr;
+    mRawPtr = temp;
+
+  }
+
+
+  void swap(T*& aRhs)
+  {
+
+    nsISupports* temp = aRhs;
+
+
+
+                                    ;
+                                    ;
+    aRhs = reinterpret_cast<T*>(mRawPtr);
+    mRawPtr = temp;
+                                  ;
+  }
+
+
+
+
+
+
+  already_AddRefed<T> forget()
+  {
+    T* temp = nullptr;
+    swap(temp);
+    return already_AddRefed<T>(temp);
+  }
+
+
+
+
+  template<typename I>
+  void forget(I** aRhs)
+  {
+    do { } while(0);
+                                    ;
+    *aRhs = get();
+    mRawPtr = nullptr;
+  }
+
+
+
+
+  T* get() const { return reinterpret_cast<T*>(mRawPtr); }
+
+
+
+
+
+
+
+  operator T*() const & { return get(); }
+
+
+
+
+  operator T*() const && = delete;
+
+
+  explicit operator bool() const { return !!mRawPtr; }
+
+  T* operator->() const
+  {
+    do { } while (0);
+
+    return get();
+  }
+
+
+  nsCOMPtr<T>* get_address() { return this; }
+  const nsCOMPtr<T>* get_address() const { return this; }
+
+public:
+  T& operator*() const
+  {
+    do { } while (0);
+
+    return *get();
+  }
+
+  T** StartAssignment()
+  {
+
+    return reinterpret_cast<T**>(begin_assignment());
+
+
+
+
+  }
+};
+# 800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+template<>
+class nsCOMPtr<nsISupports>
+  : private nsCOMPtr_base
+{
+public:
+  typedef nsISupports element_type;
+
+
+
+  nsCOMPtr()
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+  }
+
+               nsCOMPtr(decltype(nullptr))
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+  }
+
+  nsCOMPtr(const nsCOMPtr<nsISupports>& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.mRawPtr)
+  {
+    if (mRawPtr) {
+      (mRawPtr)->AddRef();
+    }
+                                                 ;
+  }
+
+               nsCOMPtr(nsISupports* aRawPtr)
+    : nsCOMPtr_base(aRawPtr)
+  {
+    if (mRawPtr) {
+      (mRawPtr)->AddRef();
+    }
+                                       ;
+  }
+
+
+               nsCOMPtr(already_AddRefed<nsISupports>& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.take())
+  {
+                                       ;
+  }
+
+
+               nsCOMPtr(already_AddRefed<nsISupports>&& aSmartPtr)
+    : nsCOMPtr_base(aSmartPtr.take())
+  {
+                                       ;
+  }
+
+
+               nsCOMPtr(const nsQueryInterface aQI)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_qi(aQI, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsQueryInterfaceWithError& aQI)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_qi_with_error(aQI, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByCID aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_gs_cid(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_gs_cid_with_error(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByContractID aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_gs_contractid(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+               nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_gs_contractid_with_error(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+
+               nsCOMPtr(const nsCOMPtr_helper& aHelper)
+    : nsCOMPtr_base(nullptr)
+  {
+                                       ;
+    assign_from_helper(aHelper, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+  }
+
+
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsCOMPtr<nsISupports>& aRhs)
+  {
+    assign_with_AddRef(aRhs.mRawPtr);
+    return *this;
+  }
+
+  nsCOMPtr<nsISupports>& operator=(nsISupports* aRhs)
+  {
+    assign_with_AddRef(aRhs);
+    return *this;
+  }
+
+  nsCOMPtr<nsISupports>& operator=(decltype(nullptr))
+  {
+    assign_assuming_AddRef(nullptr);
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>& aRhs)
+  {
+    assign_assuming_AddRef(aRhs.take());
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>&& aRhs)
+  {
+    assign_assuming_AddRef(aRhs.take());
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsQueryInterface aRhs)
+  {
+    assign_from_qi(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsQueryInterfaceWithError& aRhs)
+  {
+    assign_from_qi_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCID aRhs)
+  {
+    assign_from_gs_cid(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCIDWithError& aRhs)
+  {
+    assign_from_gs_cid_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractID aRhs)
+  {
+    assign_from_gs_contractid(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractIDWithError& aRhs)
+  {
+    assign_from_gs_contractid_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+
+  nsCOMPtr<nsISupports>& operator=(const nsCOMPtr_helper& aRhs)
+  {
+    assign_from_helper(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
+    return *this;
+  }
+
+
+  void swap(nsCOMPtr<nsISupports>& aRhs)
+  {
+    nsISupports* temp = aRhs.mRawPtr;
+                                        ;
+                                    ;
+                                    ;
+                                  ;
+    aRhs.mRawPtr = mRawPtr;
+    mRawPtr = temp;
+  }
+
+
+  void swap(nsISupports*& aRhs)
+  {
+    nsISupports* temp = aRhs;
+                                    ;
+                                    ;
+    aRhs = mRawPtr;
+    mRawPtr = temp;
+  }
+
+
+
+  already_AddRefed<nsISupports> forget()
+  {
+    nsISupports* temp = nullptr;
+    swap(temp);
+    return already_AddRefed<nsISupports>(temp);
+  }
+
+
+
+
+  void forget(nsISupports** aRhs)
+  {
+    do { } while(0);
+    *aRhs = nullptr;
+    swap(*aRhs);
+  }
+
+
+
+
+
+
+  nsISupports* get() const { return reinterpret_cast<nsISupports*>(mRawPtr); }
+
+
+
+
+
+
+
+  operator nsISupports* () const { return get(); }
+
+  nsISupports* operator->() const
+  {
+    do { } while (0);
+
+    return get();
+  }
+
+
+  nsCOMPtr<nsISupports>* get_address() { return this; }
+  const nsCOMPtr<nsISupports>* get_address() const { return this; }
+
+public:
+
+  nsISupports& operator*() const
+  {
+    do { } while (0);
+
+    return *get();
+  }
+
+  nsISupports** StartAssignment()
+  {
+
+    return reinterpret_cast<nsISupports**>(begin_assignment());
+
+
+
+
+  }
+};
+
+template<typename T>
+inline void
+ImplCycleCollectionUnlink(nsCOMPtr<T>& aField)
+{
+  aField = nullptr;
+}
+
+template<typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsCOMPtr<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+# 1206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+template<class T>
+inline nsCOMPtr<T>*
+address_of(nsCOMPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+
+template<class T>
+inline const nsCOMPtr<T>*
+address_of(const nsCOMPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+# 1235 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+template<class T>
+class nsGetterAddRefs
+{
+public:
+  explicit nsGetterAddRefs(nsCOMPtr<T>& aSmartPtr)
+    : mTargetSmartPtr(aSmartPtr)
+  {
+  }
+# 1258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
+
+  operator T**() { return mTargetSmartPtr.StartAssignment(); }
+  T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
+
+private:
+  nsCOMPtr<T>& mTargetSmartPtr;
+};
+
+
+template<>
+class nsGetterAddRefs<nsISupports>
+{
+public:
+  explicit nsGetterAddRefs(nsCOMPtr<nsISupports>& aSmartPtr)
+    : mTargetSmartPtr(aSmartPtr)
+  {
+  }
+# 1288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
+
+  operator nsISupports**() { return mTargetSmartPtr.StartAssignment(); }
+  nsISupports*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
+
+private:
+  nsCOMPtr<nsISupports>& mTargetSmartPtr;
+};
+
+template<class T>
+inline nsGetterAddRefs<T>
+getter_AddRefs(nsCOMPtr<T>& aSmartPtr)
+{
+  return nsGetterAddRefs<T>(aSmartPtr);
+}
+
+template<class T, class DestinationType>
+inline nsresult
+CallQueryInterface(T* aSource, nsGetterAddRefs<DestinationType> aDestination)
+{
+  return CallQueryInterface(aSource,
+                            static_cast<DestinationType**>(aDestination));
+}
+
+
+
+
+template<class T, class U>
+inline bool
+operator==(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
+}
+
+
+template<class T, class U>
+inline bool
+operator!=(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
+}
+
+
+
+
+template<class T, class U>
+inline bool
+operator==(const nsCOMPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == aRhs;
+}
+
+template<class T, class U>
+inline bool
+operator==(const U* aLhs, const nsCOMPtr<T>& aRhs)
+{
+  return aLhs == static_cast<const T*>(aRhs.get());
+}
+
+template<class T, class U>
+inline bool
+operator!=(const nsCOMPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != aRhs;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const U* aLhs, const nsCOMPtr<T>& aRhs)
+{
+  return aLhs != static_cast<const T*>(aRhs.get());
+}
+
+template<class T, class U>
+inline bool
+operator==(const nsCOMPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
+}
+
+template<class T, class U>
+inline bool
+operator==(U* aLhs, const nsCOMPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
+}
+
+template<class T, class U>
+inline bool
+operator!=(const nsCOMPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
+}
+
+template<class T, class U>
+inline bool
+operator!=(U* aLhs, const nsCOMPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
+}
+
+
+
+
+
+template<class T>
+inline bool
+operator==(const nsCOMPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() == nullptr;
+}
+
+template<class T>
+inline bool
+operator==(decltype(nullptr), const nsCOMPtr<T>& aRhs)
+{
+  return nullptr == aRhs.get();
+}
+
+template<class T>
+inline bool
+operator!=(const nsCOMPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() != nullptr;
+}
+
+template<class T>
+inline bool
+operator!=(decltype(nullptr), const nsCOMPtr<T>& aRhs)
+{
+  return nullptr != aRhs.get();
+}
+
+
+
+
+inline bool
+SameCOMIdentity(nsISupports* aLhs, nsISupports* aRhs)
+{
+  return nsCOMPtr<nsISupports>(do_QueryInterface(aLhs)) ==
+    nsCOMPtr<nsISupports>(do_QueryInterface(aRhs));
+}
+
+
+
+template<class SourceType, class DestinationType>
+inline nsresult
+CallQueryInterface(nsCOMPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr)
+{
+  return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+}
+
+template <class T>
+RefPtr<T>::RefPtr(const nsCOMPtr_helper& aHelper)
+{
+  void* newRawPtr;
+  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo<T, void>::kIID), &newRawPtr))), 0)))) {
+    newRawPtr = nullptr;
+  }
+  mRawPtr = static_cast<T*>(newRawPtr);
+}
+
+template <class T>
+RefPtr<T>&
+RefPtr<T>::operator=(const nsCOMPtr_helper& aHelper)
+{
+  void* newRawPtr;
+  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo<T, void>::kIID), &newRawPtr))), 0)))) {
+    newRawPtr = nullptr;
+  }
+  assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  return *this;
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+template<class T> struct already_AddRefed;
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+class nsStringBuffer
+{
+private:
+  friend class CheckStaticAtomSizes;
+
+  std::atomic<uint32_t> mRefCount;
+  uint32_t mStorageSize;
+
+public:
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  static already_AddRefed<nsStringBuffer> Alloc(size_t aStorageSize);
+# 61 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  static nsStringBuffer* Realloc(nsStringBuffer* aBuf, size_t aStorageSize);
+
+
+
+
+  void AddRef();
+
+
+
+
+
+  void Release();
+
+
+
+
+
+
+  static nsStringBuffer* FromData(void* aData)
+  {
+    return reinterpret_cast<nsStringBuffer*>(aData) - 1;
+  }
+
+
+
+
+  void* Data() const
+  {
+    return const_cast<char*>(reinterpret_cast<const char*>(this + 1));
+  }
+
+
+
+
+
+
+  uint32_t StorageSize() const
+  {
+    return mStorageSize;
+  }
+# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  bool IsReadonly() const
+  {
+# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+    return mRefCount.load(std::memory_order_relaxed) > 1;
+  }
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  static nsStringBuffer* FromString(const nsAString& aStr);
+  static nsStringBuffer* FromString(const nsACString& aStr);
+# 160 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  void ToString(uint32_t aLen, nsAString& aStr, bool aMoveOwnership = false);
+  void ToString(uint32_t aLen, nsACString& aStr, bool aMoveOwnership = false);
+
+
+
+
+  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) const;
+# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
+  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) const;
+};
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2
+
+
+
+
+
+
+
+
+class nsIAtom : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult ScriptableToString(nsAString & _retval) = 0;
+
+
+  virtual nsresult ToUTF8String(nsACString & _retval) = 0;
+
+
+  virtual nsresult ScriptableEquals(const nsAString & aString, bool *_retval) = 0;
+
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) = 0;
+
+
+  inline bool Equals(char16ptr_t aString, uint32_t aLength) const
+  {
+    return mLength == aLength &&
+           memcmp(mString, aString, mLength * sizeof(char16_t)) == 0;
+  }
+  inline bool Equals(const nsAString& aString) const {
+    return Equals(aString.BeginReading(), aString.Length());
+  }
+  inline bool IsStaticAtom() const {
+    return mIsStatic;
+  }
+  inline char16ptr_t GetUTF16String() const {
+    return mString;
+  }
+  inline uint32_t GetLength() const {
+    return mLength;
+  }
+  inline void ToString(nsAString& aBuf) const {
+
+    nsStringBuffer::FromData(mString)->ToString(mLength, aBuf);
+  }
+  inline nsStringBuffer* GetStringBuffer() const {
+
+    return nsStringBuffer::FromData(mString);
+  }
+
+
+
+
+
+  inline uint32_t hash() const {
+    return mHash;
+  }
+protected:
+  uint32_t mLength:31;
+  uint32_t mIsStatic:1;
+  uint32_t mHash;
+
+
+
+
+
+  char16_t* mString;
+};
+
+  template<typename T> struct nsIAtom::COMTypeInfo<nsIAtom, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAtom::COMTypeInfo<nsIAtom, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8b8c11d4, 0x3ed5, 0x4079, { 0x89, 0x74, 0x73, 0xc7, 0x57, 0x6c, 0xdb, 0x34 }};
+# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h"
+extern already_AddRefed<nsIAtom> NS_Atomize(const char* aUTF8String);
+
+
+
+extern already_AddRefed<nsIAtom> NS_Atomize(const nsACString& aUTF8String);
+
+
+
+
+extern already_AddRefed<nsIAtom> NS_Atomize(const char16_t* aUTF16String);
+
+
+
+extern already_AddRefed<nsIAtom> NS_Atomize(const nsAString& aUTF16String);
+
+
+
+extern already_AddRefed<nsIAtom> NS_AtomizeMainThread(const nsAString& aUTF16String);
+
+
+
+
+extern nsrefcnt NS_GetNumberOfAtoms(void);
+
+
+
+
+extern nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
+
+
+
+extern void NS_SealStaticAtomTable();
+class nsAtomString : public nsString
+{
+public:
+  explicit nsAtomString(const nsIAtom* aAtom)
+  {
+    aAtom->ToString(*this);
+  }
+};
+class nsAtomCString : public nsCString
+{
+public:
+  explicit nsAtomCString(nsIAtom* aAtom)
+  {
+    aAtom->ToUTF8String(*this);
+  }
+};
+class nsDependentAtomString : public nsDependentString
+{
+public:
+  explicit nsDependentAtomString(const nsIAtom* aAtom)
+    : nsDependentString(aAtom->GetUTF16String(), aAtom->GetLength())
+  {
+  }
+};
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
+
+class nsIDocument;
+class nsNodeInfoManager;
+
+namespace mozilla {
+namespace dom {
+
+class NodeInfo final
+{
+public:
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<NodeInfo>::value, "Reference-counted class " "NodeInfo" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsCycleCollectionParticipant { public: constexpr cycleCollection () : nsCycleCollectionParticipant(true) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "NodeInfo"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<NodeInfo>(n)->DeleteCycleCollectable(); } static NodeInfo* Downcast(void* s) { return DowncastCCParticipant<NodeInfo>(s); } static void* Upcast(NodeInfo *p) { return static_cast<void*>(p); } virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static nsCycleCollectionParticipant* GetParticipant() { return &NodeInfo::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+
+
+
+
+
+  void GetName(nsAString& aName) const;
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
+  nsIAtom* NameAtom() const
+  {
+    return mInner.mName;
+  }
+# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
+  const nsString& QualifiedName() const {
+    return mQualifiedName;
+  }
+
+
+
+
+  const nsString& NodeName() const {
+    return mNodeName;
+  }
+
+
+
+
+  const nsString& LocalName() const {
+    return mLocalName;
+  }
+
+
+
+
+
+
+
+  void GetPrefix(nsAString& aPrefix) const;
+
+
+
+
+
+
+
+  nsIAtom* GetPrefixAtom() const
+  {
+    return mInner.mPrefix;
+  }
+
+
+
+
+  void GetNamespaceURI(nsAString& aNameSpaceURI) const;
+
+
+
+
+
+  int32_t NamespaceID() const
+  {
+    return mInner.mNamespaceID;
+  }
+
+
+
+
+
+  uint16_t NodeType() const
+  {
+    return mInner.mNodeType;
+  }
+
+
+
+
+  nsIAtom* GetExtraName() const
+  {
+    return mInner.mExtraName;
+  }
+
+
+
+
+
+  nsNodeInfoManager* NodeInfoManager() const
+  {
+    return mOwnerManager;
+  }
+
+
+
+
+
+
+  inline bool Equals(NodeInfo* aNodeInfo) const;
+
+  bool NameAndNamespaceEquals(NodeInfo* aNodeInfo) const;
+
+  bool Equals(nsIAtom* aNameAtom) const
+  {
+    return mInner.mName == aNameAtom;
+  }
+
+  bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom) const
+  {
+    return (mInner.mName == aNameAtom) && (mInner.mPrefix == aPrefixAtom);
+  }
+
+  bool Equals(nsIAtom* aNameAtom, int32_t aNamespaceID) const
+  {
+    return ((mInner.mName == aNameAtom) &&
+            (mInner.mNamespaceID == aNamespaceID));
+  }
+
+  bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom, int32_t aNamespaceID) const
+  {
+    return ((mInner.mName == aNameAtom) &&
+            (mInner.mPrefix == aPrefixAtom) &&
+            (mInner.mNamespaceID == aNamespaceID));
+  }
+
+  bool NamespaceEquals(int32_t aNamespaceID) const
+  {
+    return mInner.mNamespaceID == aNamespaceID;
+  }
+
+  inline bool Equals(const nsAString& aName) const;
+
+  inline bool Equals(const nsAString& aName, const nsAString& aPrefix) const;
+
+  inline bool Equals(const nsAString& aName, int32_t aNamespaceID) const;
+
+  inline bool Equals(const nsAString& aName, const nsAString& aPrefix, int32_t aNamespaceID) const;
+
+  bool NamespaceEquals(const nsAString& aNamespaceURI) const;
+
+  inline bool QualifiedNameEquals(nsIAtom* aNameAtom) const;
+
+  bool QualifiedNameEquals(const nsAString& aQualifiedName) const
+  {
+    return mQualifiedName == aQualifiedName;
+  }
+
+
+
+
+  nsIDocument* GetDocument() const
+  {
+    return mDocument;
+  }
+
+private:
+  NodeInfo() = delete;
+  NodeInfo(const NodeInfo& aOther) = delete;
+
+
+
+  NodeInfo(nsIAtom* aName, nsIAtom* aPrefix, int32_t aNamespaceID,
+           uint16_t aNodeType, nsIAtom* aExtraName,
+           nsNodeInfoManager* aOwnerManager);
+
+  ~NodeInfo();
+
+public:
+  bool CanSkip();
+
+
+
+
+
+  void DeleteCycleCollectable();
+
+protected:
+# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
+  class NodeInfoInner
+  {
+  public:
+    NodeInfoInner()
+      : mName(nullptr), mPrefix(nullptr), mNamespaceID(-1),
+        mNodeType(0), mNameString(nullptr), mExtraName(nullptr)
+    {
+    }
+    NodeInfoInner(nsIAtom *aName, nsIAtom *aPrefix, int32_t aNamespaceID,
+                    uint16_t aNodeType, nsIAtom* aExtraName)
+      : mName(aName), mPrefix(aPrefix), mNamespaceID(aNamespaceID),
+        mNodeType(aNodeType), mNameString(nullptr), mExtraName(aExtraName)
+    {
+    }
+    NodeInfoInner(const nsAString& aTmpName, nsIAtom *aPrefix,
+                    int32_t aNamespaceID, uint16_t aNodeType)
+      : mName(nullptr), mPrefix(aPrefix), mNamespaceID(aNamespaceID),
+        mNodeType(aNodeType), mNameString(&aTmpName), mExtraName(nullptr)
+    {
+    }
+
+    nsCOMPtr<nsIAtom> mName;
+    nsCOMPtr<nsIAtom> mPrefix;
+    int32_t mNamespaceID;
+    uint16_t mNodeType;
+    const nsAString* mNameString;
+    nsCOMPtr<nsIAtom> mExtraName;
+  };
+
+
+  friend class ::nsNodeInfoManager;
+
+
+
+  nsIDocument* mDocument;
+
+  NodeInfoInner mInner;
+
+  RefPtr<nsNodeInfoManager> mOwnerManager;
+
+
+
+
+
+
+
+  nsString mQualifiedName;
+
+
+  nsString mNodeName;
+
+
+
+  nsString mLocalName;
+};
+
+}
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h"
+inline bool DOMStringIsNull(const nsAString& aString)
+{
+  return aString.IsVoid();
+}
+
+inline void SetDOMStringToNull(nsAString& aString)
+{
+  aString.SetIsVoid(true);
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2
+
+
+class nsAttrName
+{
+public:
+  nsAttrName(const nsAttrName& aOther)
+    : mBits(aOther.mBits)
+  {
+    AddRefInternalName();
+  }
+
+  explicit nsAttrName(nsIAtom* aAtom)
+    : mBits(reinterpret_cast<uintptr_t>(aAtom))
+  {
+    do { } while(0);
+    (aAtom)->AddRef();
+  }
+
+  explicit nsAttrName(mozilla::dom::NodeInfo* aNodeInfo)
+  {
+    do { } while(0);
+    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
+      (aNodeInfo->NameAtom())->AddRef();
+    }
+    else {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
+              1;
+      (aNodeInfo)->AddRef();
+    }
+  }
+
+  ~nsAttrName()
+  {
+    ReleaseInternalName();
+  }
+
+  void SetTo(mozilla::dom::NodeInfo* aNodeInfo)
+  {
+    do { } while(0);
+
+    ReleaseInternalName();
+    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
+      (aNodeInfo->NameAtom())->AddRef();
+    }
+    else {
+      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
+              1;
+      (aNodeInfo)->AddRef();
+    }
+  }
+
+  void SetTo(nsIAtom* aAtom)
+  {
+    do { } while(0);
+
+    ReleaseInternalName();
+    mBits = reinterpret_cast<uintptr_t>(aAtom);
+    (aAtom)->AddRef();
+  }
+
+  bool IsAtom() const
+  {
+    return !(mBits & 1);
+  }
+
+  mozilla::dom::NodeInfo* NodeInfo() const
+  {
+    do { } while(0);
+    return reinterpret_cast<mozilla::dom::NodeInfo*>(mBits & ~1);
+  }
+
+  nsIAtom* Atom() const
+  {
+    do { } while(0);
+    return reinterpret_cast<nsIAtom*>(mBits);
+  }
+
+  bool Equals(const nsAttrName& aOther) const
+  {
+    return mBits == aOther.mBits;
+  }
+
+
+  bool Equals(nsIAtom* aAtom) const
+  {
+    return reinterpret_cast<uintptr_t>(aAtom) == mBits;
+  }
+
+
+  bool Equals(const nsAString& aLocalName) const
+  {
+    return IsAtom() && Atom()->Equals(aLocalName);
+  }
+
+  bool Equals(nsIAtom* aLocalName, int32_t aNamespaceID) const
+  {
+    if (aNamespaceID == kNameSpaceID_None) {
+      return Equals(aLocalName);
+    }
+    return !IsAtom() && NodeInfo()->Equals(aLocalName, aNamespaceID);
+  }
+
+  bool Equals(mozilla::dom::NodeInfo* aNodeInfo) const
+  {
+    return Equals(aNodeInfo->NameAtom(), aNodeInfo->NamespaceID());
+  }
+
+  int32_t NamespaceID() const
+  {
+    return IsAtom() ? kNameSpaceID_None : NodeInfo()->NamespaceID();
+  }
+
+  int32_t NamespaceEquals(int32_t aNamespaceID) const
+  {
+    return aNamespaceID == kNameSpaceID_None ?
+           IsAtom() :
+           (!IsAtom() && NodeInfo()->NamespaceEquals(aNamespaceID));
+  }
+
+  nsIAtom* LocalName() const
+  {
+    return IsAtom() ? Atom() : NodeInfo()->NameAtom();
+  }
+
+  nsIAtom* GetPrefix() const
+  {
+    return IsAtom() ? nullptr : NodeInfo()->GetPrefixAtom();
+  }
+
+  bool QualifiedNameEquals(const nsAString& aName) const
+  {
+    return IsAtom() ? Atom()->Equals(aName) :
+                      NodeInfo()->QualifiedNameEquals(aName);
+  }
+
+  void GetQualifiedName(nsAString& aStr) const
+  {
+    if (IsAtom()) {
+      Atom()->ToString(aStr);
+    }
+    else {
+      aStr = NodeInfo()->QualifiedName();
+    }
+  }
+
+
+  void GetPrefix(nsAString& aStr) const
+  {
+    if (IsAtom()) {
+      SetDOMStringToNull(aStr);
+    }
+    else {
+      NodeInfo()->GetPrefix(aStr);
+    }
+  }
+
+
+  uint32_t HashValue() const
+  {
+
+
+
+    return mBits - 0;
+  }
+
+  bool IsSmaller(nsIAtom* aOther) const
+  {
+    return mBits < reinterpret_cast<uintptr_t>(aOther);
+  }
+
+private:
+
+  void AddRefInternalName()
+  {
+    if (IsAtom()) {
+      (Atom())->AddRef();
+    } else {
+      (NodeInfo())->AddRef();
+    }
+  }
+
+  void ReleaseInternalName()
+  {
+    if (IsAtom()) {
+      Atom()->Release();
+    } else {
+      NodeInfo()->Release();
+    }
+  }
+
+  uintptr_t mBits;
+};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 1
+
+
+
+
+
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/float.h" 1 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2
+
+
+
+
+
+
+
+
+inline double
+NS_round(double aNum)
+{
+  return aNum >= 0.0 ? floor(aNum + 0.5) : ceil(aNum - 0.5);
+}
+inline float
+NS_roundf(float aNum)
+{
+  return aNum >= 0.0f ? floorf(aNum + 0.5f) : ceilf(aNum - 0.5f);
+}
+inline int32_t
+NS_lround(double aNum)
+{
+  return aNum >= 0.0 ? int32_t(aNum + 0.5) : int32_t(aNum - 0.5);
+}
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
+inline int32_t
+NS_lroundf(float aNum)
+{
+  return aNum >= 0.0f ? int32_t(aNum + 0.5f) : int32_t(aNum - 0.5f);
+}
+
+
+
+
+
+
+inline double
+NS_hypot(double aNum1, double aNum2)
+{
+
+  return __builtin_hypot(aNum1, aNum2);
+
+
+
+
+
+}
+
+
+
+
+
+inline bool
+NS_finite(double aNum)
+{
+# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
+  return finite(aNum);
+
+}
+
+
+
+
+
+
+
+inline double
+NS_floorModulo(double aNum1, double aNum2)
+{
+  return (aNum1 - aNum2 * floor(aNum1 / aNum2));
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 2 3
+
+using std::abs;
+using std::acos;
+using std::asin;
+using std::atan;
+using std::atan2;
+using std::cos;
+using std::sin;
+using std::tan;
+using std::cosh;
+using std::sinh;
+using std::tanh;
+using std::exp;
+using std::frexp;
+using std::ldexp;
+using std::log;
+using std::log10;
+using std::modf;
+using std::pow;
+using std::sqrt;
+using std::ceil;
+using std::fabs;
+using std::floor;
+using std::fmod;
+
+
+using std::fpclassify;
+using std::isfinite;
+using std::isinf;
+using std::isnan;
+using std::isnormal;
+using std::signbit;
+using std::isgreater;
+using std::isgreaterequal;
+using std::isless;
+using std::islessequal;
+using std::islessgreater;
+using std::isunordered;
+
+
+
+using std::acosh;
+using std::asinh;
+using std::atanh;
+using std::cbrt;
+using std::copysign;
+using std::erf;
+using std::erfc;
+using std::exp2;
+using std::expm1;
+using std::fdim;
+using std::fma;
+using std::fmax;
+using std::fmin;
+using std::hypot;
+using std::ilogb;
+using std::lgamma;
+using std::llrint;
+using std::llround;
+using std::log1p;
+using std::log2;
+using std::logb;
+using std::lrint;
+using std::lround;
+using std::nearbyint;
+using std::nextafter;
+using std::nexttoward;
+using std::remainder;
+using std::remquo;
+using std::rint;
+using std::round;
+using std::scalbln;
+using std::scalbn;
+using std::tgamma;
+using std::trunc;
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
+inline float NS_IEEEPositiveInfinity() {
+  union { uint32_t mPRUint32; float mFloat; } pun;
+  pun.mPRUint32 = 0x7F800000;
+  return pun.mFloat;
+}
+inline bool NS_IEEEIsNan(float aF) {
+  union { uint32_t mBits; float mFloat; } pun;
+  pun.mFloat = aF;
+  return (pun.mBits & 0x7F800000) == 0x7F800000 &&
+    (pun.mBits & 0x007FFFFF) != 0;
+}
+
+
+
+
+
+typedef int32_t nscoord;
+
+
+
+
+
+inline void VERIFY_COORD(nscoord aCoord) {
+
+
+
+
+}
+
+
+
+
+
+inline nscoord NSCoordDivRem(nscoord aSpace, size_t aN, nscoord* aQuotient)
+{
+
+
+
+
+  div_t result = div(aSpace, aN);
+  *aQuotient = nscoord(result.quot);
+  return nscoord(result.rem);
+
+}
+
+inline nscoord NSCoordMulDiv(nscoord aMult1, nscoord aMult2, nscoord aDiv) {
+
+
+
+  return (int64_t(aMult1) * int64_t(aMult2) / int64_t(aDiv));
+
+}
+
+inline nscoord NSToCoordRound(float aValue)
+{
+
+
+
+  return nscoord(floorf(aValue + 0.5f));
+
+}
+
+inline nscoord NSToCoordRound(double aValue)
+{
+
+
+
+  return nscoord(floor(aValue + 0.5f));
+
+}
+
+inline nscoord NSToCoordRoundWithClamp(float aValue)
+{
+
+
+  if (aValue >= nscoord(1 << 30)) {
+    return nscoord(1 << 30);
+  }
+  if (aValue <= (-nscoord(1 << 30))) {
+    return (-nscoord(1 << 30));
+  }
+
+  return NSToCoordRound(aValue);
+}
+
+
+
+
+
+
+
+inline nscoord _nscoordSaturatingMultiply(nscoord aCoord, float aScale,
+                                          bool requireNotNegative) {
+  VERIFY_COORD(aCoord);
+  if (requireNotNegative) {
+    do { } while (0);
+
+  }
+
+
+
+  float product = aCoord * aScale;
+  if (requireNotNegative ? aCoord > 0 : (aCoord > 0) == (aScale > 0))
+    return NSToCoordRoundWithClamp(std::min<float>(nscoord(1 << 30), product));
+  return NSToCoordRoundWithClamp(std::max<float>((-nscoord(1 << 30)), product));
+
+}
+
+
+
+
+
+
+
+inline nscoord NSCoordSaturatingNonnegativeMultiply(nscoord aCoord, float aScale) {
+  return _nscoordSaturatingMultiply(aCoord, aScale, true);
+}
+
+
+
+
+
+inline nscoord NSCoordSaturatingMultiply(nscoord aCoord, float aScale) {
+  return _nscoordSaturatingMultiply(aCoord, aScale, false);
+}
+# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
+inline nscoord
+NSCoordSaturatingAdd(nscoord a, nscoord b)
+{
+  VERIFY_COORD(a);
+  VERIFY_COORD(b);
+
+
+
+
+
+  if (a == nscoord(1 << 30) || b == nscoord(1 << 30)) {
+
+    return nscoord(1 << 30);
+  } else {
+
+
+    return std::min(nscoord(1 << 30), a + b);
+  }
+
+}
+# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
+inline nscoord
+NSCoordSaturatingSubtract(nscoord a, nscoord b,
+                          nscoord infMinusInfResult)
+{
+  VERIFY_COORD(a);
+  VERIFY_COORD(b);
+
+  if (b == nscoord(1 << 30)) {
+    if (a == nscoord(1 << 30)) {
+
+      return infMinusInfResult;
+    } else {
+
+      do { } while(0);
+      return 0;
+    }
+  } else {
+
+
+
+
+    if (a == nscoord(1 << 30)) {
+
+      return nscoord(1 << 30);
+    } else {
+
+
+      return std::min(nscoord(1 << 30), a - b);
+    }
+
+  }
+}
+
+inline float NSCoordToFloat(nscoord aCoord) {
+  VERIFY_COORD(aCoord);
+
+
+
+  return (float)aCoord;
+}
+
+
+
+
+inline nscoord NSToCoordFloor(float aValue)
+{
+  return nscoord(floorf(aValue));
+}
+
+inline nscoord NSToCoordFloor(double aValue)
+{
+  return nscoord(floor(aValue));
+}
+
+inline nscoord NSToCoordFloorClamped(float aValue)
+{
+
+
+  if (aValue >= nscoord(1 << 30)) {
+    return nscoord(1 << 30);
+  }
+  if (aValue <= (-nscoord(1 << 30))) {
+    return (-nscoord(1 << 30));
+  }
+
+  return NSToCoordFloor(aValue);
+}
+
+inline nscoord NSToCoordCeil(float aValue)
+{
+  return nscoord(ceilf(aValue));
+}
+
+inline nscoord NSToCoordCeil(double aValue)
+{
+  return nscoord(ceil(aValue));
+}
+
+inline nscoord NSToCoordCeilClamped(double aValue)
+{
+
+
+  if (aValue >= nscoord(1 << 30)) {
+    return nscoord(1 << 30);
+  }
+  if (aValue <= (-nscoord(1 << 30))) {
+    return (-nscoord(1 << 30));
+  }
+
+  return NSToCoordCeil(aValue);
+}
+
+
+
+
+
+inline nscoord NSToCoordTrunc(float aValue)
+{
+
+
+  return nscoord(aValue);
+}
+
+inline nscoord NSToCoordTrunc(double aValue)
+{
+
+
+  return nscoord(aValue);
+}
+
+inline nscoord NSToCoordTruncClamped(float aValue)
+{
+
+
+  if (aValue >= nscoord(1 << 30)) {
+    return nscoord(1 << 30);
+  }
+  if (aValue <= (-nscoord(1 << 30))) {
+    return (-nscoord(1 << 30));
+  }
+
+  return NSToCoordTrunc(aValue);
+}
+
+inline nscoord NSToCoordTruncClamped(double aValue)
+{
+
+
+  if (aValue >= nscoord(1 << 30)) {
+    return nscoord(1 << 30);
+  }
+  if (aValue <= (-nscoord(1 << 30))) {
+    return (-nscoord(1 << 30));
+  }
+
+  return NSToCoordTrunc(aValue);
+}
+
+
+
+
+inline int32_t NSToIntFloor(float aValue)
+{
+  return int32_t(floorf(aValue));
+}
+
+inline int32_t NSToIntCeil(float aValue)
+{
+  return int32_t(ceilf(aValue));
+}
+
+inline int32_t NSToIntRound(float aValue)
+{
+  return NS_lroundf(aValue);
+}
+
+inline int32_t NSToIntRound(double aValue)
+{
+  return NS_lround(aValue);
+}
+
+inline int32_t NSToIntRoundUp(double aValue)
+{
+  return int32_t(floor(aValue + 0.5));
+}
+
+
+
+
+inline nscoord NSFloatPixelsToAppUnits(float aPixels, float aAppUnitsPerPixel)
+{
+  return NSToCoordRoundWithClamp(aPixels * aAppUnitsPerPixel);
+}
+
+inline nscoord NSIntPixelsToAppUnits(int32_t aPixels, int32_t aAppUnitsPerPixel)
+{
+
+
+  nscoord r = aPixels * (nscoord)aAppUnitsPerPixel;
+  VERIFY_COORD(r);
+  return r;
+}
+
+inline float NSAppUnitsToFloatPixels(nscoord aAppUnits, float aAppUnitsPerPixel)
+{
+  return (float(aAppUnits) / aAppUnitsPerPixel);
+}
+
+inline double NSAppUnitsToDoublePixels(nscoord aAppUnits, double aAppUnitsPerPixel)
+{
+  return (double(aAppUnits) / aAppUnitsPerPixel);
+}
+
+inline int32_t NSAppUnitsToIntPixels(nscoord aAppUnits, float aAppUnitsPerPixel)
+{
+  return NSToIntRound(float(aAppUnits) / aAppUnitsPerPixel);
+}
+
+inline float NSCoordScale(nscoord aCoord, int32_t aFromAPP, int32_t aToAPP)
+{
+  return (NSCoordToFloat(aCoord) * aToAPP) / aFromAPP;
+}
+# 418 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
+inline float NSUnitsToTwips(float aValue, float aPointsPerUnit)
+{
+  return aValue * aPointsPerUnit * 20.0f;
+}
+
+inline float NSTwipsToUnits(float aTwips, float aUnitsPerPoint)
+{
+  return (aTwips * (aUnitsPerPoint / 20.0f));
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2
+
+class nsAString;
+class nsString;
+
+
+
+typedef uint32_t nscolor;
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h"
+namespace mozilla {
+
+template<typename T>
+inline uint8_t ClampColor(T aColor)
+{
+  if (aColor >= 255) {
+    return 255;
+  }
+  if (aColor <= 0) {
+    return 0;
+  }
+  return NSToIntRound(aColor);
+}
+
+}
+# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h"
+enum class nsHexColorType : uint8_t {
+  NoAlpha,
+  AllowAlpha,
+};
+
+
+
+
+bool
+NS_HexToRGBA(const nsAString& aBuf, nsHexColorType aType, nscolor* aResult);
+
+
+
+nscolor NS_ComposeColors(nscolor aBG, nscolor aFG);
+
+namespace mozilla {
+
+inline uint32_t RoundingDivideBy255(uint32_t n)
+{
+
+
+
+  return (n + 127) / 255;
+}
+
+
+
+nscolor LinearBlendColors(nscolor aBg, nscolor aFg, uint_fast8_t aFgRatio);
+
+}
+
+
+
+
+bool NS_LooseHexToRGB(const nsString& aBuf, nscolor* aResult);
+
+
+
+
+
+
+bool NS_ColorNameToRGB(const nsAString& aBuf, nscolor* aResult);
+
+
+
+const char * const * NS_AllColorNames(size_t *aSizeArray);
+
+
+
+nscolor NS_HSL2RGB(float h, float s, float l);
+
+
+
+
+
+
+const char* NS_RGBToColorName(nscolor aColor);
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h"
+enum nsCaseTreatment {
+  eCaseMatters,
+  eIgnoreCase
+};
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+
+template <class T, class Sub>
+struct BaseSize {
+  union {
+    struct {
+      T width, height;
+    };
+    T components[2];
+  };
+
+
+  constexpr BaseSize() : width(0), height(0) {}
+  constexpr BaseSize(T aWidth, T aHeight) : width(aWidth), height(aHeight) {}
+
+  void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; }
+
+  bool IsEmpty() const {
+    return width <= 0 || height <= 0;
+  }
+
+  bool IsSquare() const {
+    return width == height;
+  }
+
+
+
+
+  bool operator==(const Sub& aSize) const {
+    return width == aSize.width && height == aSize.height;
+  }
+  bool operator!=(const Sub& aSize) const {
+    return width != aSize.width || height != aSize.height;
+  }
+  bool operator<=(const Sub& aSize) const {
+    return width <= aSize.width && height <= aSize.height;
+  }
+  bool operator<(const Sub& aSize) const {
+    return *this <= aSize && *this != aSize;
+  }
+
+  Sub operator+(const Sub& aSize) const {
+    return Sub(width + aSize.width, height + aSize.height);
+  }
+  Sub operator-(const Sub& aSize) const {
+    return Sub(width - aSize.width, height - aSize.height);
+  }
+  Sub& operator+=(const Sub& aSize) {
+    width += aSize.width;
+    height += aSize.height;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const Sub& aSize) {
+    width -= aSize.width;
+    height -= aSize.height;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub operator*(T aScale) const {
+    return Sub(width * aScale, height * aScale);
+  }
+  Sub operator/(T aScale) const {
+    return Sub(width / aScale, height / aScale);
+  }
+  friend Sub operator*(T aScale, const Sub& aSize) {
+    return Sub(aScale * aSize.width, aScale * aSize.height);
+  }
+  void Scale(T aXScale, T aYScale) {
+    width *= aXScale;
+    height *= aYScale;
+  }
+
+  Sub operator*(const Sub& aSize) const {
+    return Sub(width * aSize.width, height * aSize.height);
+  }
+  Sub operator/(const Sub& aSize) const {
+    return Sub(width / aSize.width, height / aSize.height);
+  }
+
+  friend Sub Min(const Sub& aA, const Sub& aB) {
+    return Sub(std::min(aA.width, aB.width),
+               std::min(aA.height, aB.height));
+  }
+
+  friend Sub Max(const Sub& aA, const Sub& aB) {
+    return Sub(std::max(aA.width, aB.width),
+               std::max(aA.height, aB.height));
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+      const BaseSize<T, Sub>& aSize) {
+    return aStream << aSize.width << " x " << aSize.height;
+  }
+};
+
+}
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 1
+
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 2
+
+
+
+
+
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+
+template <class T, class Sub, class Coord = T>
+struct BasePoint {
+  union {
+    struct {
+      T x, y;
+    };
+    T components[2];
+  };
+
+
+  constexpr BasePoint() : x(0), y(0) {}
+  constexpr BasePoint(Coord aX, Coord aY) : x(aX), y(aY) {}
+
+  void MoveTo(T aX, T aY) { x = aX; y = aY; }
+  void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; }
+
+
+
+
+  bool operator==(const Sub& aPoint) const {
+    return x == aPoint.x && y == aPoint.y;
+  }
+  bool operator!=(const Sub& aPoint) const {
+    return x != aPoint.x || y != aPoint.y;
+  }
+
+  Sub operator+(const Sub& aPoint) const {
+    return Sub(x + aPoint.x, y + aPoint.y);
+  }
+  Sub operator-(const Sub& aPoint) const {
+    return Sub(x - aPoint.x, y - aPoint.y);
+  }
+  Sub& operator+=(const Sub& aPoint) {
+    x += aPoint.x;
+    y += aPoint.y;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const Sub& aPoint) {
+    x -= aPoint.x;
+    y -= aPoint.y;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub operator*(T aScale) const {
+    return Sub(x * aScale, y * aScale);
+  }
+  Sub operator/(T aScale) const {
+    return Sub(x / aScale, y / aScale);
+  }
+
+  Sub operator-() const {
+    return Sub(-x, -y);
+  }
+
+  T DotProduct(const Sub& aPoint) const {
+      return x * aPoint.x + y * aPoint.y;
+  }
+
+  Coord Length() const {
+    return hypot(x, y);
+  }
+
+  T LengthSquare() const {
+    return x * x + y * y;
+  }
+
+
+
+
+  Sub& Round() {
+    x = Coord(floor(T(x) + T(0.5)));
+    y = Coord(floor(T(y) + T(0.5)));
+    return *static_cast<Sub*>(this);
+  }
+
+
+  bool IsFinite() const
+  {
+    typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
+    return (mozilla::IsFinite(FloatType(x)) && mozilla::IsFinite(FloatType(y)));
+    return true;
+  }
+
+  void Clamp(T aMaxAbsValue)
+  {
+    x = std::max(std::min(x, aMaxAbsValue), -aMaxAbsValue);
+    y = std::max(std::min(y, aMaxAbsValue), -aMaxAbsValue);
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const BasePoint<T, Sub, Coord>& aPoint) {
+    return stream << '(' << aPoint.x << ',' << aPoint.y << ')';
+  }
+
+};
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 2
+
+
+namespace mozilla {
+namespace gfx {
+
+typedef float Float;
+
+enum class SurfaceType : int8_t {
+  DATA,
+  D2D1_BITMAP,
+  D2D1_DRAWTARGET,
+  CAIRO,
+  CAIRO_IMAGE,
+  COREGRAPHICS_IMAGE,
+  COREGRAPHICS_CGCONTEXT,
+  SKIA,
+  DUAL_DT,
+  D2D1_1_IMAGE,
+  RECORDING,
+  TILED,
+  DATA_SHARED,
+};
+
+enum class SurfaceFormat : int8_t {
+
+
+
+
+  B8G8R8A8,
+  B8G8R8X8,
+  R8G8B8A8,
+  R8G8B8X8,
+  A8R8G8B8,
+  X8R8G8B8,
+
+  R8G8B8,
+  B8G8R8,
+
+
+
+
+  R5G6B5_UINT16,
+
+
+  A8,
+
+
+  YUV,
+  NV12,
+  YUV422,
+  HSV,
+  Lab,
+  Depth,
+
+
+  UNKNOWN,
+
+
+
+
+
+  A8R8G8B8_UINT32 = B8G8R8A8,
+  X8R8G8B8_UINT32 = B8G8R8X8
+
+
+
+
+
+
+};
+
+inline bool IsOpaque(SurfaceFormat aFormat)
+{
+  switch (aFormat) {
+  case SurfaceFormat::B8G8R8X8:
+  case SurfaceFormat::R8G8B8X8:
+  case SurfaceFormat::R5G6B5_UINT16:
+  case SurfaceFormat::YUV:
+  case SurfaceFormat::NV12:
+  case SurfaceFormat::YUV422:
+    return true;
+  default:
+    return false;
+  }
+}
+
+enum class FilterType : int8_t {
+  BLEND = 0,
+  TRANSFORM,
+  MORPHOLOGY,
+  COLOR_MATRIX,
+  FLOOD,
+  TILE,
+  TABLE_TRANSFER,
+  DISCRETE_TRANSFER,
+  LINEAR_TRANSFER,
+  GAMMA_TRANSFER,
+  CONVOLVE_MATRIX,
+  DISPLACEMENT_MAP,
+  TURBULENCE,
+  ARITHMETIC_COMBINE,
+  COMPOSITE,
+  DIRECTIONAL_BLUR,
+  GAUSSIAN_BLUR,
+  POINT_DIFFUSE,
+  POINT_SPECULAR,
+  SPOT_DIFFUSE,
+  SPOT_SPECULAR,
+  DISTANT_DIFFUSE,
+  DISTANT_SPECULAR,
+  CROP,
+  PREMULTIPLY,
+  UNPREMULTIPLY
+};
+
+enum class DrawTargetType : int8_t {
+  SOFTWARE_RASTER = 0,
+  HARDWARE_RASTER,
+  VECTOR
+};
+
+enum class BackendType : int8_t {
+  NONE = 0,
+  DIRECT2D,
+  CAIRO,
+  SKIA,
+  RECORDING,
+  DIRECT2D1_1,
+
+
+  BACKEND_LAST
+};
+
+enum class FontType : int8_t {
+  DWRITE,
+  GDI,
+  MAC,
+  SKIA,
+  CAIRO,
+  COREGRAPHICS,
+  FONTCONFIG
+};
+
+enum class NativeSurfaceType : int8_t {
+  D3D10_TEXTURE,
+  CAIRO_CONTEXT,
+  CGCONTEXT,
+  CGCONTEXT_ACCELERATED,
+  OPENGL_TEXTURE
+};
+
+enum class NativeFontType : int8_t {
+  DWRITE_FONT_FACE,
+  GDI_FONT_FACE,
+  MAC_FONT_FACE,
+  SKIA_FONT_FACE,
+  CAIRO_FONT_FACE
+};
+
+enum class FontStyle : int8_t {
+  NORMAL,
+  ITALIC,
+  BOLD,
+  BOLD_ITALIC
+};
+
+enum class FontHinting : int8_t {
+  NONE,
+  LIGHT,
+  NORMAL,
+  FULL
+};
+
+enum class CompositionOp : int8_t {
+  OP_OVER,
+  OP_ADD,
+  OP_ATOP,
+  OP_OUT,
+  OP_IN,
+  OP_SOURCE,
+  OP_DEST_IN,
+  OP_DEST_OUT,
+  OP_DEST_OVER,
+  OP_DEST_ATOP,
+  OP_XOR,
+  OP_MULTIPLY,
+  OP_SCREEN,
+  OP_OVERLAY,
+  OP_DARKEN,
+  OP_LIGHTEN,
+  OP_COLOR_DODGE,
+  OP_COLOR_BURN,
+  OP_HARD_LIGHT,
+  OP_SOFT_LIGHT,
+  OP_DIFFERENCE,
+  OP_EXCLUSION,
+  OP_HUE,
+  OP_SATURATION,
+  OP_COLOR,
+  OP_LUMINOSITY,
+  OP_COUNT
+};
+
+enum class Axis : int8_t {
+  X_AXIS,
+  Y_AXIS,
+  BOTH
+};
+
+enum class ExtendMode : int8_t {
+  CLAMP,
+  REPEAT,
+  REPEAT_X,
+  REPEAT_Y,
+  REFLECT
+};
+
+enum class FillRule : int8_t {
+  FILL_WINDING,
+  FILL_EVEN_ODD
+};
+
+enum class AntialiasMode : int8_t {
+  NONE,
+  GRAY,
+  SUBPIXEL,
+  DEFAULT
+};
+
+
+enum class SamplingFilter : int8_t {
+  GOOD,
+  LINEAR,
+  POINT,
+  SENTINEL
+};
+
+enum class PatternType : int8_t {
+  COLOR,
+  SURFACE,
+  LINEAR_GRADIENT,
+  RADIAL_GRADIENT
+};
+
+enum class JoinStyle : int8_t {
+  BEVEL,
+  ROUND,
+  MITER,
+
+
+  MITER_OR_BEVEL
+};
+
+enum class CapStyle : int8_t {
+  BUTT,
+  ROUND,
+  SQUARE
+};
+
+enum class SamplingBounds : int8_t {
+  UNBOUNDED,
+  BOUNDED
+};
+
+
+struct Color
+{
+public:
+  Color()
+    : r(0.0f), g(0.0f), b(0.0f), a(0.0f)
+  {}
+  Color(Float aR, Float aG, Float aB, Float aA)
+    : r(aR), g(aG), b(aB), a(aA)
+  {}
+  Color(Float aR, Float aG, Float aB)
+    : r(aR), g(aG), b(aB), a(1.0f)
+  {}
+
+  static Color FromABGR(uint32_t aColor)
+  {
+    Color newColor(((aColor >> 0) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 8) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 16) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 24) & 0xff) * (1.0f / 255.0f));
+
+    return newColor;
+  }
+
+
+
+  static Color UnusualFromARGB(uint32_t aColor)
+  {
+    Color newColor(((aColor >> 16) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 8) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 0) & 0xff) * (1.0f / 255.0f),
+                   ((aColor >> 24) & 0xff) * (1.0f / 255.0f));
+
+    return newColor;
+  }
+
+  uint32_t ToABGR() const
+  {
+    return uint32_t(r * 255.0f) | uint32_t(g * 255.0f) << 8 |
+           uint32_t(b * 255.0f) << 16 | uint32_t(a * 255.0f) << 24;
+  }
+
+
+
+  uint32_t UnusualToARGB() const
+  {
+    return uint32_t(b * 255.0f) | uint32_t(g * 255.0f) << 8 |
+           uint32_t(r * 255.0f) << 16 | uint32_t(a * 255.0f) << 24;
+  }
+
+  bool operator==(const Color& aColor) const {
+    return r == aColor.r && g == aColor.g && b == aColor.b && a == aColor.a;
+  }
+
+  bool operator!=(const Color& aColor) const {
+    return !(*this == aColor);
+  }
+
+  Float r, g, b, a;
+};
+
+struct GradientStop
+{
+  bool operator<(const GradientStop& aOther) const {
+    return offset < aOther.offset;
+  }
+
+  Float offset;
+  Color color;
+};
+
+enum class JobStatus {
+    Complete,
+    Wait,
+    Yield,
+    Error
+};
+
+}
+}
+
+
+typedef mozilla::gfx::SurfaceFormat gfxImageFormat;
+# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+namespace mozilla {
+
+
+enum Side { eSideTop, eSideRight, eSideBottom, eSideLeft };
+
+enum SideBits {
+  eSideBitsNone = 0,
+  eSideBitsTop = 1 << eSideTop,
+  eSideBitsRight = 1 << eSideRight,
+  eSideBitsBottom = 1 << eSideBottom,
+  eSideBitsLeft = 1 << eSideLeft,
+  eSideBitsTopBottom = eSideBitsTop | eSideBitsBottom,
+  eSideBitsLeftRight = eSideBitsLeft | eSideBitsRight,
+  eSideBitsAll = eSideBitsTopBottom | eSideBitsLeftRight
+};
+# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+static inline Side& operator++(Side& side) {
+  do { } while (0);
+
+  side = Side(side + 1);
+  return side;
+}
+
+enum Corner {
+
+  eCornerTopLeft = 0,
+  eCornerTopRight = 1,
+  eCornerBottomRight = 2,
+  eCornerBottomLeft = 3
+};
+
+
+
+
+constexpr int eCornerCount = 4;
+# 427 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+static inline Corner operator++(Corner& aCorner) {
+  do { } while (0);
+
+  aCorner = Corner(aCorner + 1);
+  return aCorner;
+}
+
+
+enum HalfCorner {
+
+  eCornerTopLeftX = 0,
+  eCornerTopLeftY = 1,
+  eCornerTopRightX = 2,
+  eCornerTopRightY = 3,
+  eCornerBottomRightX = 4,
+  eCornerBottomRightY = 5,
+  eCornerBottomLeftX = 6,
+  eCornerBottomLeftY = 7
+};
+# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+static inline HalfCorner operator++(HalfCorner& aHalfCorner) {
+  do { } while (0);
+
+  aHalfCorner = HalfCorner(aHalfCorner + 1);
+  return aHalfCorner;
+}
+
+
+
+
+constexpr bool HalfCornerIsX(HalfCorner aHalfCorner)
+{
+  return !(aHalfCorner % 2);
+}
+
+constexpr Corner HalfToFullCorner(HalfCorner aHalfCorner)
+{
+  return Corner(aHalfCorner / 2);
+}
+
+constexpr HalfCorner FullToHalfCorner(Corner aCorner, bool aIsVertical)
+{
+  return HalfCorner(aCorner * 2 + aIsVertical);
+}
+
+constexpr bool SideIsVertical(Side aSide)
+{
+  return aSide % 2;
+}
+
+
+
+
+
+constexpr Corner SideToFullCorner(Side aSide, bool aIsSecond)
+{
+  return Corner((aSide + aIsSecond) % 4);
+}
+# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
+constexpr HalfCorner SideToHalfCorner(Side aSide, bool aIsSecond,
+                                      bool aIsParallel)
+{
+  return HalfCorner(((aSide + aIsSecond) * 2 + (aSide + !aIsParallel) % 2) % 8);
+}
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+
+template <class T, class Sub>
+struct BaseCoord {
+  T value;
+
+
+  constexpr BaseCoord() : value(0) {}
+  explicit constexpr BaseCoord(T aValue) : value(aValue) {}
+
+
+
+
+  operator T() const { return value; }
+
+  friend bool operator==(Sub aA, Sub aB) {
+    return aA.value == aB.value;
+  }
+  friend bool operator!=(Sub aA, Sub aB) {
+    return aA.value != aB.value;
+  }
+
+  friend Sub operator+(Sub aA, Sub aB) {
+    return Sub(aA.value + aB.value);
+  }
+  friend Sub operator-(Sub aA, Sub aB) {
+    return Sub(aA.value - aB.value);
+  }
+  friend Sub operator*(Sub aCoord, T aScale) {
+    return Sub(aCoord.value * aScale);
+  }
+  friend Sub operator*(T aScale, Sub aCoord) {
+    return Sub(aScale * aCoord.value);
+  }
+  friend Sub operator/(Sub aCoord, T aScale) {
+    return Sub(aCoord.value / aScale);
+  }
+
+
+  Sub& operator+=(Sub aCoord) {
+    value += aCoord.value;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(Sub aCoord) {
+    value -= aCoord.value;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator*=(T aScale) {
+    value *= aScale;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator/=(T aScale) {
+    value /= aScale;
+    return *static_cast<Sub*>(this);
+  }
+
+
+
+
+
+  friend bool operator==(Sub aA, T aB) {
+    return aA.value == aB;
+  }
+  friend bool operator==(T aA, Sub aB) {
+    return aA == aB.value;
+  }
+  friend bool operator!=(Sub aA, T aB) {
+    return aA.value != aB;
+  }
+  friend bool operator!=(T aA, Sub aB) {
+    return aA != aB.value;
+  }
+  friend T operator+(Sub aA, T aB) {
+    return aA.value + aB;
+  }
+  friend T operator+(T aA, Sub aB) {
+    return aA + aB.value;
+  }
+  friend T operator-(Sub aA, T aB) {
+    return aA.value - aB;
+  }
+  friend T operator-(T aA, Sub aB) {
+    return aA - aB.value;
+  }
+
+  Sub operator-() const {
+    return Sub(-value);
+  }
+};
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2
+
+namespace mozilla {
+
+template <typename> struct IsPixel;
+
+namespace gfx {
+
+template <class units> struct IntCoordTyped;
+template <class units, class F = Float> struct CoordTyped;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
+template <class coord, class primitive>
+struct CommonType;
+
+template <class units, class primitive>
+struct CommonType<IntCoordTyped<units>, primitive> {
+    typedef decltype(int32_t() + primitive()) type;
+};
+
+template <class units, class F, class primitive>
+struct CommonType<CoordTyped<units, F>, primitive> {
+    typedef decltype(F() + primitive()) type;
+};
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
+template <bool B, class coord, class primitive>
+struct CoordOperatorsHelper {
+
+
+};
+
+template <class coord, class primitive>
+struct CoordOperatorsHelper<true, coord, primitive> {
+  friend bool operator==(coord aA, primitive aB) {
+    return aA.value == aB;
+  }
+  friend bool operator==(primitive aA, coord aB) {
+    return aA == aB.value;
+  }
+  friend bool operator!=(coord aA, primitive aB) {
+    return aA.value != aB;
+  }
+  friend bool operator!=(primitive aA, coord aB) {
+    return aA != aB.value;
+  }
+
+  typedef typename CommonType<coord, primitive>::type result_type;
+
+  friend result_type operator+(coord aA, primitive aB) {
+    return aA.value + aB;
+  }
+  friend result_type operator+(primitive aA, coord aB) {
+    return aA + aB.value;
+  }
+  friend result_type operator-(coord aA, primitive aB) {
+    return aA.value - aB;
+  }
+  friend result_type operator-(primitive aA, coord aB) {
+    return aA - aB.value;
+  }
+  friend result_type operator*(coord aCoord, primitive aScale) {
+    return aCoord.value * aScale;
+  }
+  friend result_type operator*(primitive aScale, coord aCoord) {
+    return aScale * aCoord.value;
+  }
+  friend result_type operator/(coord aCoord, primitive aScale) {
+    return aCoord.value / aScale;
+  }
+
+};
+
+
+
+
+template<class units>
+struct IntCoordTyped :
+  public BaseCoord< int32_t, IntCoordTyped<units> >,
+  public CoordOperatorsHelper< true, IntCoordTyped<units>, float >,
+  public CoordOperatorsHelper< true, IntCoordTyped<units>, double > {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef BaseCoord< int32_t, IntCoordTyped<units> > Super;
+
+  constexpr IntCoordTyped() : Super() {}
+  constexpr IntCoordTyped(int32_t aValue) : Super(aValue) {}
+};
+
+template<class units, class F>
+struct CoordTyped :
+  public BaseCoord< F, CoordTyped<units, F> >,
+  public CoordOperatorsHelper< !IsSame<F, int32_t>::value, CoordTyped<units, F>, int32_t >,
+  public CoordOperatorsHelper< !IsSame<F, uint32_t>::value, CoordTyped<units, F>, uint32_t >,
+  public CoordOperatorsHelper< !IsSame<F, double>::value, CoordTyped<units, F>, double >,
+  public CoordOperatorsHelper< !IsSame<F, float>::value, CoordTyped<units, F>, float > {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef BaseCoord< F, CoordTyped<units, F> > Super;
+
+  constexpr CoordTyped() : Super() {}
+  constexpr CoordTyped(F aValue) : Super(aValue) {}
+  explicit constexpr CoordTyped(const IntCoordTyped<units>& aCoord) : Super(F(aCoord.value)) {}
+
+  void Round() {
+    this->value = floor(this->value + 0.5);
+  }
+  void Truncate() {
+    this->value = int32_t(this->value);
+  }
+
+  IntCoordTyped<units> Rounded() const {
+    return IntCoordTyped<units>(int32_t(floor(this->value + 0.5)));
+  }
+  IntCoordTyped<units> Truncated() const {
+    return IntCoordTyped<units>(int32_t(this->value));
+  }
+};
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+
+template <class T, class Sub>
+struct BasePoint3D {
+  union {
+    struct {
+      T x, y, z;
+    };
+    T components[3];
+  };
+
+
+  BasePoint3D() : x(0), y(0), z(0) {}
+  BasePoint3D(T aX, T aY, T aZ) : x(aX), y(aY), z(aZ) {}
+
+  void MoveTo(T aX, T aY, T aZ) { x = aX; y = aY; z = aZ; }
+  void MoveBy(T aDx, T aDy, T aDz) { x += aDx; y += aDy; z += aDz; }
+
+
+
+
+  T& operator[](int aIndex) {
+    do { } while (0);
+    return *((&x)+aIndex);
+  }
+
+  const T& operator[](int aIndex) const {
+    do { } while (0);
+    return *((&x)+aIndex);
+  }
+
+  bool operator==(const Sub& aPoint) const {
+    return x == aPoint.x && y == aPoint.y && z == aPoint.z;
+  }
+  bool operator!=(const Sub& aPoint) const {
+    return x != aPoint.x || y != aPoint.y || z != aPoint.z;
+  }
+
+  Sub operator+(const Sub& aPoint) const {
+    return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z);
+  }
+  Sub operator-(const Sub& aPoint) const {
+    return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z);
+  }
+  Sub& operator+=(const Sub& aPoint) {
+    x += aPoint.x;
+    y += aPoint.y;
+    z += aPoint.z;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const Sub& aPoint) {
+    x -= aPoint.x;
+    y -= aPoint.y;
+    z -= aPoint.z;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub operator*(T aScale) const {
+    return Sub(x * aScale, y * aScale, z * aScale);
+  }
+  Sub operator/(T aScale) const {
+    return Sub(x / aScale, y / aScale, z / aScale);
+  }
+
+  Sub& operator*=(T aScale) {
+    x *= aScale;
+    y *= aScale;
+    z *= aScale;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub& operator/=(T aScale) {
+      x /= aScale;
+      y /= aScale;
+      z /= aScale;
+      return *static_cast<Sub*>(this);
+  }
+
+  Sub operator-() const {
+    return Sub(-x, -y, -z);
+  }
+
+  Sub CrossProduct(const Sub& aPoint) const {
+      return Sub(y * aPoint.z - aPoint.y * z,
+                 z * aPoint.x - aPoint.z * x,
+                 x * aPoint.y - aPoint.x * y);
+  }
+
+  T DotProduct(const Sub& aPoint) const {
+      return x * aPoint.x + y * aPoint.y + z * aPoint.z;
+  }
+
+  T Length() const {
+      return sqrt(x*x + y*y + z*z);
+  }
+
+
+  void Normalize() {
+      *this /= Length();
+  }
+};
+
+}
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+
+template <class T, class Sub>
+struct BasePoint4D {
+  union {
+    struct {
+      T x, y, z, w;
+    };
+    T components[4];
+  };
+
+
+  BasePoint4D() : x(0), y(0), z(0), w(0) {}
+  BasePoint4D(T aX, T aY, T aZ, T aW) : x(aX), y(aY), z(aZ), w(aW) {}
+
+  void MoveTo(T aX, T aY, T aZ, T aW) { x = aX; y = aY; z = aZ; w = aW; }
+  void MoveBy(T aDx, T aDy, T aDz, T aDw) { x += aDx; y += aDy; z += aDz; w += aDw; }
+
+
+
+
+  bool operator==(const Sub& aPoint) const {
+    return x == aPoint.x && y == aPoint.y &&
+           z == aPoint.z && w == aPoint.w;
+  }
+  bool operator!=(const Sub& aPoint) const {
+    return x != aPoint.x || y != aPoint.y ||
+           z != aPoint.z || w != aPoint.w;
+  }
+
+  Sub operator+(const Sub& aPoint) const {
+    return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z, w + aPoint.w);
+  }
+  Sub operator-(const Sub& aPoint) const {
+    return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z, w - aPoint.w);
+  }
+  Sub& operator+=(const Sub& aPoint) {
+    x += aPoint.x;
+    y += aPoint.y;
+    z += aPoint.z;
+    w += aPoint.w;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const Sub& aPoint) {
+    x -= aPoint.x;
+    y -= aPoint.y;
+    z -= aPoint.z;
+    w -= aPoint.w;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub operator*(T aScale) const {
+    return Sub(x * aScale, y * aScale, z * aScale, w * aScale);
+  }
+  Sub operator/(T aScale) const {
+    return Sub(x / aScale, y / aScale, z / aScale, w / aScale);
+  }
+
+  Sub& operator*=(T aScale) {
+    x *= aScale;
+    y *= aScale;
+    z *= aScale;
+    w *= aScale;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub& operator/=(T aScale) {
+    x /= aScale;
+    y /= aScale;
+    z /= aScale;
+    w /= aScale;
+    return *static_cast<Sub*>(this);
+  }
+
+  Sub operator-() const {
+    return Sub(-x, -y, -z, -w);
+  }
+
+  T& operator[](int aIndex) {
+    do { } while (0);
+    return *((&x)+aIndex);
+  }
+
+  const T& operator[](int aIndex) const {
+    do { } while (0);
+    return *((&x)+aIndex);
+  }
+
+  T DotProduct(const Sub& aPoint) const {
+    return x * aPoint.x + y * aPoint.y + z * aPoint.z + w * aPoint.w;
+  }
+
+
+  Sub CrossProduct(const Sub& aPoint) const {
+      return Sub(y * aPoint.z - aPoint.y * z,
+          z * aPoint.x - aPoint.z * x,
+          x * aPoint.y - aPoint.x * y,
+          0);
+  }
+
+  T Length() const {
+    return sqrt(x*x + y*y + z*z + w*w);
+  }
+
+  void Normalize() {
+    *this /= Length();
+  }
+
+  bool HasPositiveWCoord() { return w > 0; }
+};
+
+}
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
+
+namespace mozilla {
+
+template <typename> struct IsPixel;
+
+namespace gfx {
+
+
+struct UnknownUnits {};
+
+}
+
+template<> struct IsPixel<gfx::UnknownUnits> : TrueType {};
+
+namespace gfx {
+
+
+
+
+
+
+template<typename T>
+struct IntParam {
+  constexpr IntParam(char val) : value(val) {}
+  constexpr IntParam(unsigned char val) : value(val) {}
+  constexpr IntParam(short val) : value(val) {}
+  constexpr IntParam(unsigned short val) : value(val) {}
+  constexpr IntParam(int val) : value(val) {}
+  constexpr IntParam(unsigned int val) : value(val) {}
+  constexpr IntParam(long val) : value(val) {}
+  constexpr IntParam(unsigned long val) : value(val) {}
+  constexpr IntParam(long long val) : value(val) {}
+  constexpr IntParam(unsigned long long val) : value(val) {}
+  template<typename Unit>
+  constexpr IntParam(IntCoordTyped<Unit> val) : value(val) {}
+
+
+               IntParam(float val) = delete;
+               IntParam(double val) = delete;
+
+  T value;
+};
+
+template<class units, class> struct PointTyped;
+template<class units, class> struct SizeTyped;
+
+template<class units>
+struct IntPointTyped :
+  public BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> >,
+  public units {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef IntParam<int32_t> ToInt;
+  typedef IntCoordTyped<units> Coord;
+  typedef BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> > Super;
+
+  constexpr IntPointTyped() : Super() {}
+  constexpr IntPointTyped(ToInt aX, ToInt aY) : Super(Coord(aX.value), Coord(aY.value)) {}
+
+  static IntPointTyped<units> Round(float aX, float aY) {
+    return IntPointTyped(int32_t(floorf(aX + 0.5)), int32_t(floorf(aY + 0.5)));
+  }
+
+  static IntPointTyped<units> Ceil(float aX, float aY) {
+    return IntPointTyped(int32_t(ceil(aX)), int32_t(ceil(aY)));
+  }
+
+  static IntPointTyped<units> Floor(float aX, float aY) {
+    return IntPointTyped(int32_t(floorf(aX)), int32_t(floorf(aY)));
+  }
+
+  static IntPointTyped<units> Truncate(float aX, float aY) {
+    return IntPointTyped(int32_t(aX), int32_t(aY));
+  }
+
+  static IntPointTyped<units> Round(const PointTyped<units, float>& aPoint);
+  static IntPointTyped<units> Ceil(const PointTyped<units, float>& aPoint);
+  static IntPointTyped<units> Floor(const PointTyped<units, float>& aPoint);
+  static IntPointTyped<units> Truncate(const PointTyped<units, float>& aPoint);
+
+
+
+
+  static IntPointTyped<units> FromUnknownPoint(const IntPointTyped<UnknownUnits>& aPoint) {
+    return IntPointTyped<units>(aPoint.x, aPoint.y);
+  }
+
+  IntPointTyped<UnknownUnits> ToUnknownPoint() const {
+    return IntPointTyped<UnknownUnits>(this->x, this->y);
+  }
+};
+typedef IntPointTyped<UnknownUnits> IntPoint;
+
+template<class units, class F = Float>
+struct PointTyped :
+  public BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> >,
+  public units {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef CoordTyped<units, F> Coord;
+  typedef BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> > Super;
+
+  constexpr PointTyped() : Super() {}
+  constexpr PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {}
+
+
+  constexpr PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {}
+  constexpr PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {}
+  constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
+  constexpr PointTyped(const IntPointTyped<units>& point) : Super(F(point.x), F(point.y)) {}
+
+
+
+
+  static PointTyped<units, F> FromUnknownPoint(const PointTyped<UnknownUnits, F>& aPoint) {
+    return PointTyped<units, F>(aPoint.x, aPoint.y);
+  }
+
+  PointTyped<UnknownUnits, F> ToUnknownPoint() const {
+    return PointTyped<UnknownUnits, F>(this->x, this->y);
+  }
+};
+typedef PointTyped<UnknownUnits> Point;
+typedef PointTyped<UnknownUnits, double> PointDouble;
+
+template<class units>
+IntPointTyped<units> RoundedToInt(const PointTyped<units>& aPoint) {
+  return IntPointTyped<units>::Round(aPoint.x, aPoint.y);
+}
+
+template<class units>
+IntPointTyped<units> TruncatedToInt(const PointTyped<units>& aPoint) {
+  return IntPointTyped<units>::Truncate(aPoint.x, aPoint.y);
+}
+
+template<class units, class F = Float>
+struct Point3DTyped :
+  public BasePoint3D< F, Point3DTyped<units, F> > {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef BasePoint3D< F, Point3DTyped<units, F> > Super;
+
+  Point3DTyped() : Super() {}
+  Point3DTyped(F aX, F aY, F aZ) : Super(aX, aY, aZ) {}
+
+
+
+
+  static Point3DTyped<units, F> FromUnknownPoint(const Point3DTyped<UnknownUnits, F>& aPoint) {
+    return Point3DTyped<units, F>(aPoint.x, aPoint.y, aPoint.z);
+  }
+
+  Point3DTyped<UnknownUnits, F> ToUnknownPoint() const {
+    return Point3DTyped<UnknownUnits, F>(this->x, this->y, this->z);
+  }
+};
+typedef Point3DTyped<UnknownUnits> Point3D;
+typedef Point3DTyped<UnknownUnits, double> PointDouble3D;
+
+template<typename units>
+IntPointTyped<units>
+IntPointTyped<units>::Round(const PointTyped<units, float>& aPoint)
+{
+  return IntPointTyped::Round(aPoint.x, aPoint.y);
+}
+
+template<typename units>
+IntPointTyped<units>
+IntPointTyped<units>::Ceil(const PointTyped<units, float>& aPoint)
+{
+  return IntPointTyped::Ceil(aPoint.x, aPoint.y);
+}
+
+template<typename units>
+IntPointTyped<units>
+IntPointTyped<units>::Floor(const PointTyped<units, float>& aPoint)
+{
+  return IntPointTyped::Floor(aPoint.x, aPoint.y);
+}
+
+template<typename units>
+IntPointTyped<units>
+IntPointTyped<units>::Truncate(const PointTyped<units, float>& aPoint)
+{
+  return IntPointTyped::Truncate(aPoint.x, aPoint.y);
+}
+
+template<class units, class F = Float>
+struct Point4DTyped :
+  public BasePoint4D< F, Point4DTyped<units, F> > {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef BasePoint4D< F, Point4DTyped<units, F> > Super;
+
+  Point4DTyped() : Super() {}
+  Point4DTyped(F aX, F aY, F aZ, F aW) : Super(aX, aY, aZ, aW) {}
+
+  explicit Point4DTyped(const Point3DTyped<units, F>& aPoint)
+    : Super(aPoint.x, aPoint.y, aPoint.z, 1) {}
+
+
+
+
+  static Point4DTyped<units, F> FromUnknownPoint(const Point4DTyped<UnknownUnits, F>& aPoint) {
+    return Point4DTyped<units, F>(aPoint.x, aPoint.y, aPoint.z, aPoint.w);
+  }
+
+  Point4DTyped<UnknownUnits, F> ToUnknownPoint() const {
+    return Point4DTyped<UnknownUnits, F>(this->x, this->y, this->z, this->w);
+  }
+
+  PointTyped<units, F> As2DPoint() const {
+    return PointTyped<units, F>(this->x / this->w,
+                                this->y / this->w);
+  }
+
+  Point3DTyped<units, F> As3DPoint() const {
+    return Point3DTyped<units, F>(this->x / this->w,
+                                  this->y / this->w,
+                                  this->z / this->w);
+  }
+};
+typedef Point4DTyped<UnknownUnits> Point4D;
+typedef Point4DTyped<UnknownUnits, double> PointDouble4D;
+
+template<class units>
+struct IntSizeTyped :
+  public BaseSize< int32_t, IntSizeTyped<units> >,
+  public units {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef IntParam<int32_t> ToInt;
+  typedef BaseSize< int32_t, IntSizeTyped<units> > Super;
+
+  constexpr IntSizeTyped() : Super() {}
+  constexpr IntSizeTyped(ToInt aWidth, ToInt aHeight) : Super(aWidth.value, aHeight.value) {}
+
+  static IntSizeTyped<units> Round(float aWidth, float aHeight) {
+    return IntSizeTyped(int32_t(floorf(aWidth + 0.5)), int32_t(floorf(aHeight + 0.5)));
+  }
+
+  static IntSizeTyped<units> Truncate(float aWidth, float aHeight) {
+    return IntSizeTyped(int32_t(aWidth), int32_t(aHeight));
+  }
+
+  static IntSizeTyped<units> Ceil(float aWidth, float aHeight) {
+    return IntSizeTyped(int32_t(ceil(aWidth)), int32_t(ceil(aHeight)));
+  }
+
+  static IntSizeTyped<units> Floor(float aWidth, float aHeight) {
+    return IntSizeTyped(int32_t(floorf(aWidth)), int32_t(floorf(aHeight)));
+  }
+
+  static IntSizeTyped<units> Round(const SizeTyped<units, float>& aSize);
+  static IntSizeTyped<units> Ceil(const SizeTyped<units, float>& aSize);
+  static IntSizeTyped<units> Floor(const SizeTyped<units, float>& aSize);
+  static IntSizeTyped<units> Truncate(const SizeTyped<units, float>& aSize);
+
+
+
+
+  static IntSizeTyped<units> FromUnknownSize(const IntSizeTyped<UnknownUnits>& aSize) {
+    return IntSizeTyped<units>(aSize.width, aSize.height);
+  }
+
+  IntSizeTyped<UnknownUnits> ToUnknownSize() const {
+    return IntSizeTyped<UnknownUnits>(this->width, this->height);
+  }
+};
+typedef IntSizeTyped<UnknownUnits> IntSize;
+
+template<class units, class F = Float>
+struct SizeTyped :
+  public BaseSize< F, SizeTyped<units, F> >,
+  public units {
+  static_assert(IsPixel<units>::value,
+                "'units' must be a coordinate system tag");
+
+  typedef BaseSize< F, SizeTyped<units, F> > Super;
+
+  constexpr SizeTyped() : Super() {}
+  constexpr SizeTyped(F aWidth, F aHeight) : Super(aWidth, aHeight) {}
+  explicit SizeTyped(const IntSizeTyped<units>& size) :
+    Super(F(size.width), F(size.height)) {}
+
+
+
+
+  static SizeTyped<units, F> FromUnknownSize(const SizeTyped<UnknownUnits, F>& aSize) {
+    return SizeTyped<units, F>(aSize.width, aSize.height);
+  }
+
+  SizeTyped<UnknownUnits, F> ToUnknownSize() const {
+    return SizeTyped<UnknownUnits, F>(this->width, this->height);
+  }
+};
+typedef SizeTyped<UnknownUnits> Size;
+typedef SizeTyped<UnknownUnits, double> SizeDouble;
+
+template<class units>
+IntSizeTyped<units> RoundedToInt(const SizeTyped<units>& aSize) {
+  return IntSizeTyped<units>(int32_t(floorf(aSize.width + 0.5f)),
+                             int32_t(floorf(aSize.height + 0.5f)));
+}
+
+template<typename units> IntSizeTyped<units>
+IntSizeTyped<units>::Round(const SizeTyped<units, float>& aSize) {
+  return IntSizeTyped::Round(aSize.width, aSize.height);
+}
+
+template<typename units> IntSizeTyped<units>
+IntSizeTyped<units>::Ceil(const SizeTyped<units, float>& aSize) {
+  return IntSizeTyped::Ceil(aSize.width, aSize.height);
+}
+
+template<typename units> IntSizeTyped<units>
+IntSizeTyped<units>::Floor(const SizeTyped<units, float>& aSize) {
+  return IntSizeTyped::Floor(aSize.width, aSize.height);
+}
+
+template<typename units> IntSizeTyped<units>
+IntSizeTyped<units>::Truncate(const SizeTyped<units, float>& aSize) {
+  return IntSizeTyped::Truncate(aSize.width, aSize.height);
+}
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 2
+
+
+
+
+typedef mozilla::gfx::IntSize nsIntSize;
+
+struct nsSize : public mozilla::gfx::BaseSize<nscoord, nsSize> {
+  typedef mozilla::gfx::BaseSize<nscoord, nsSize> Super;
+
+  nsSize() : Super() {}
+  nsSize(nscoord aWidth, nscoord aHeight) : Super(aWidth, aHeight) {}
+
+  inline mozilla::gfx::IntSize ScaleToNearestPixels(float aXScale, float aYScale,
+                                        nscoord aAppUnitsPerPixel) const;
+  inline mozilla::gfx::IntSize ToNearestPixels(nscoord aAppUnitsPerPixel) const;
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) inline nsSize
+    ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const;
+};
+
+inline mozilla::gfx::IntSize
+nsSize::ScaleToNearestPixels(float aXScale, float aYScale,
+                             nscoord aAppUnitsPerPixel) const
+{
+  return mozilla::gfx::IntSize(
+      NSToIntRoundUp(NSAppUnitsToDoublePixels(width, aAppUnitsPerPixel) * aXScale),
+      NSToIntRoundUp(NSAppUnitsToDoublePixels(height, aAppUnitsPerPixel) * aYScale));
+}
+
+inline mozilla::gfx::IntSize
+nsSize::ToNearestPixels(nscoord aAppUnitsPerPixel) const
+{
+  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
+}
+
+inline nsSize
+nsSize::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const {
+  if (aFromAPP != aToAPP) {
+    nsSize size;
+    size.width = NSToCoordRound(NSCoordScale(width, aFromAPP, aToAPP));
+    size.height = NSToCoordRound(NSCoordScale(height, aFromAPP, aToAPP));
+    return size;
+  }
+  return *this;
+}
+
+inline nsSize
+IntSizeToAppUnits(mozilla::gfx::IntSize aSize, nscoord aAppUnitsPerPixel)
+{
+  return nsSize(NSIntPixelsToAppUnits(aSize.width, aAppUnitsPerPixel),
+                NSIntPixelsToAppUnits(aSize.height, aAppUnitsPerPixel));
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
+
+
+
+
+
+typedef mozilla::gfx::IntPoint nsIntPoint;
+
+
+
+struct nsPoint : public mozilla::gfx::BasePoint<nscoord, nsPoint> {
+  typedef mozilla::gfx::BasePoint<nscoord, nsPoint> Super;
+
+  nsPoint() : Super() {}
+  nsPoint(const nsPoint& aPoint) : Super(aPoint) {}
+  nsPoint(nscoord aX, nscoord aY) : Super(aX, aY) {}
+
+  inline nsIntPoint ScaleToNearestPixels(float aXScale, float aYScale,
+                                         nscoord aAppUnitsPerPixel) const;
+  inline nsIntPoint ToNearestPixels(nscoord aAppUnitsPerPixel) const;
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) inline nsPoint
+    ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const;
+
+  __attribute__ ((warn_unused_result)) inline nsPoint
+    RemoveResolution(const float resolution) const;
+  __attribute__ ((warn_unused_result)) inline nsPoint
+    ApplyResolution(const float resolution) const;
+};
+
+inline nsPoint ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel);
+
+inline nsIntPoint
+nsPoint::ScaleToNearestPixels(float aXScale, float aYScale,
+                              nscoord aAppUnitsPerPixel) const
+{
+  return nsIntPoint(
+      NSToIntRoundUp(NSAppUnitsToDoublePixels(x, aAppUnitsPerPixel) * aXScale),
+      NSToIntRoundUp(NSAppUnitsToDoublePixels(y, aAppUnitsPerPixel) * aYScale));
+}
+
+inline nsIntPoint
+nsPoint::ToNearestPixels(nscoord aAppUnitsPerPixel) const
+{
+  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
+}
+
+inline nsPoint
+nsPoint::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const
+{
+  if (aFromAPP != aToAPP) {
+    nsPoint point;
+    point.x = NSToCoordRound(NSCoordScale(x, aFromAPP, aToAPP));
+    point.y = NSToCoordRound(NSCoordScale(y, aFromAPP, aToAPP));
+    return point;
+  }
+  return *this;
+}
+
+inline nsPoint
+nsPoint::RemoveResolution(const float resolution) const {
+  if (resolution != 1.0f) {
+    nsPoint point;
+    point.x = NSToCoordRound(NSCoordToFloat(x) / resolution);
+    point.y = NSToCoordRound(NSCoordToFloat(y) / resolution);
+    return point;
+  }
+  return *this;
+}
+
+inline nsPoint
+nsPoint::ApplyResolution(const float resolution) const {
+  if (resolution != 1.0f) {
+    nsPoint point;
+    point.x = NSToCoordRound(NSCoordToFloat(x) * resolution);
+    point.y = NSToCoordRound(NSCoordToFloat(y) * resolution);
+    return point;
+  }
+  return *this;
+}
+
+
+inline nsPoint
+ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel)
+{
+  return nsPoint(NSIntPixelsToAppUnits(aPoint.x, aAppUnitsPerPixel),
+                 NSIntPixelsToAppUnits(aPoint.y, aAppUnitsPerPixel));
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h"
+namespace mozilla {
+
+
+
+
+struct Sides final {
+  Sides() : mBits(0) {}
+  explicit Sides(SideBits aSideBits)
+  {
+    do { } while (0);
+    mBits = aSideBits;
+  }
+  bool IsEmpty() const { return mBits == 0; }
+  bool Top() const { return (mBits & eSideBitsTop) != 0; }
+  bool Right() const { return (mBits & eSideBitsRight) != 0; }
+  bool Bottom() const { return (mBits & eSideBitsBottom) != 0; }
+  bool Left() const { return (mBits & eSideBitsLeft) != 0; }
+  bool Contains(SideBits aSideBits) const
+  {
+    do { } while (0);
+    return (mBits & aSideBits) == aSideBits;
+  }
+  Sides operator|(Sides aOther) const
+  {
+    return Sides(SideBits(mBits | aOther.mBits));
+  }
+  Sides operator|(SideBits aSideBits) const
+  {
+    return *this | Sides(aSideBits);
+  }
+  Sides& operator|=(Sides aOther)
+  {
+    mBits |= aOther.mBits;
+    return *this;
+  }
+  Sides& operator|=(SideBits aSideBits)
+  {
+    return *this |= Sides(aSideBits);
+  }
+  bool operator==(Sides aOther) const
+  {
+    return mBits == aOther.mBits;
+  }
+  bool operator!=(Sides aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+private:
+  uint8_t mBits;
+};
+
+namespace gfx {
+
+
+
+
+
+template <class T, class Sub>
+struct BaseMargin {
+  typedef mozilla::Side SideT;
+
+
+
+  T top, right, bottom, left;
+
+
+  BaseMargin() : top(0), right(0), bottom(0), left(0) {}
+  BaseMargin(T aTop, T aRight, T aBottom, T aLeft) :
+      top(aTop), right(aRight), bottom(aBottom), left(aLeft) {}
+
+  void SizeTo(T aTop, T aRight, T aBottom, T aLeft)
+  {
+    top = aTop; right = aRight; bottom = aBottom; left = aLeft;
+  }
+
+  T LeftRight() const { return left + right; }
+  T TopBottom() const { return top + bottom; }
+
+  T& Side(SideT aSide) {
+
+    return *(&top + int(aSide));
+  }
+  T Side(SideT aSide) const {
+
+    return *(&top + int(aSide));
+  }
+
+  void ApplySkipSides(Sides aSkipSides)
+  {
+    if (aSkipSides.Top()) {
+      top = 0;
+    }
+    if (aSkipSides.Right()) {
+      right = 0;
+    }
+    if (aSkipSides.Bottom()) {
+      bottom = 0;
+    }
+    if (aSkipSides.Left()) {
+      left = 0;
+    }
+  }
+
+
+
+  bool operator==(const Sub& aMargin) const {
+    return top == aMargin.top && right == aMargin.right &&
+           bottom == aMargin.bottom && left == aMargin.left;
+  }
+  bool operator!=(const Sub& aMargin) const {
+    return !(*this == aMargin);
+  }
+  Sub operator+(const Sub& aMargin) const {
+    return Sub(top + aMargin.top, right + aMargin.right,
+               bottom + aMargin.bottom, left + aMargin.left);
+  }
+  Sub operator-(const Sub& aMargin) const {
+    return Sub(top - aMargin.top, right - aMargin.right,
+               bottom - aMargin.bottom, left - aMargin.left);
+  }
+  Sub& operator+=(const Sub& aMargin) {
+    top += aMargin.top;
+    right += aMargin.right;
+    bottom += aMargin.bottom;
+    left += aMargin.left;
+    return *static_cast<Sub*>(this);
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+      const BaseMargin& aMargin) {
+    return aStream << '(' << aMargin.top << ',' << aMargin.right << ','
+                  << aMargin.bottom << ',' << aMargin.left << ')';
+  }
+};
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 2
+
+
+
+
+
+
+
+namespace mozilla {
+namespace gfx {
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
+template <class T, class Sub, class Point, class SizeT, class MarginT>
+struct BaseRect {
+  T x, y, width, height;
+
+
+  BaseRect() : x(0), y(0), width(0), height(0) {}
+  BaseRect(const Point& aOrigin, const SizeT &aSize) :
+      x(aOrigin.x), y(aOrigin.y), width(aSize.width), height(aSize.height)
+  {
+  }
+  BaseRect(T aX, T aY, T aWidth, T aHeight) :
+      x(aX), y(aY), width(aWidth), height(aHeight)
+  {
+  }
+
+
+
+  bool IsEmpty() const { return height <= 0 || width <= 0; }
+  void SetEmpty() { width = height = 0; }
+
+
+  bool IsFinite() const
+  {
+    typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
+    return (mozilla::IsFinite(FloatType(x)) &&
+            mozilla::IsFinite(FloatType(y)) &&
+            mozilla::IsFinite(FloatType(width)) &&
+            mozilla::IsFinite(FloatType(height)));
+  }
+
+
+
+
+  bool Contains(const Sub& aRect) const
+  {
+    return aRect.IsEmpty() ||
+           (x <= aRect.x && aRect.XMost() <= XMost() &&
+            y <= aRect.y && aRect.YMost() <= YMost());
+  }
+
+
+
+  bool Contains(T aX, T aY) const
+  {
+    return x <= aX && aX < XMost() &&
+           y <= aY && aY < YMost();
+  }
+
+
+
+  bool Contains(const Point& aPoint) const { return Contains(aPoint.x, aPoint.y); }
+
+
+
+
+  bool Intersects(const Sub& aRect) const
+  {
+    return !IsEmpty() && !aRect.IsEmpty() &&
+           x < aRect.XMost() && aRect.x < XMost() &&
+           y < aRect.YMost() && aRect.y < YMost();
+  }
+
+
+
+
+  __attribute__ ((warn_unused_result)) Sub Intersect(const Sub& aRect) const
+  {
+    Sub result;
+    result.x = std::max<T>(x, aRect.x);
+    result.y = std::max<T>(y, aRect.y);
+    result.width = std::min<T>(x - result.x + width, aRect.x - result.x + aRect.width);
+    result.height = std::min<T>(y - result.y + height, aRect.y - result.y + aRect.height);
+    if (result.width < 0 || result.height < 0) {
+      result.SizeTo(0, 0);
+    }
+    return result;
+  }
+
+
+
+
+
+
+  bool IntersectRect(const Sub& aRect1, const Sub& aRect2)
+  {
+    *static_cast<Sub*>(this) = aRect1.Intersect(aRect2);
+    return !IsEmpty();
+  }
+
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) Sub Union(const Sub& aRect) const
+  {
+    if (IsEmpty()) {
+      return aRect;
+    } else if (aRect.IsEmpty()) {
+      return *static_cast<const Sub*>(this);
+    } else {
+      return UnionEdges(aRect);
+    }
+  }
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) Sub UnionEdges(const Sub& aRect) const
+  {
+    Sub result;
+    result.x = std::min(x, aRect.x);
+    result.y = std::min(y, aRect.y);
+    result.width = std::max(XMost(), aRect.XMost()) - result.x;
+    result.height = std::max(YMost(), aRect.YMost()) - result.y;
+    return result;
+  }
+
+
+
+
+
+
+  void UnionRect(const Sub& aRect1, const Sub& aRect2)
+  {
+    *static_cast<Sub*>(this) = aRect1.Union(aRect2);
+  }
+
+
+
+
+
+
+  void UnionRectEdges(const Sub& aRect1, const Sub& aRect2)
+  {
+    *static_cast<Sub*>(this) = aRect1.UnionEdges(aRect2);
+  }
+
+
+  void ExpandToEnclose(const Point& aPoint)
+  {
+    if (aPoint.x < x) {
+      width = XMost() - aPoint.x;
+      x = aPoint.x;
+    } else if (aPoint.x > XMost()) {
+      width = aPoint.x - x;
+    }
+    if (aPoint.y < y) {
+      height = YMost() - aPoint.y;
+      y = aPoint.y;
+    } else if (aPoint.y > YMost()) {
+      height = aPoint.y - y;
+    }
+  }
+
+  void SetRect(T aX, T aY, T aWidth, T aHeight)
+  {
+    x = aX; y = aY; width = aWidth; height = aHeight;
+  }
+  void SetRect(const Point& aPt, const SizeT& aSize)
+  {
+    SetRect(aPt.x, aPt.y, aSize.width, aSize.height);
+  }
+  void MoveTo(T aX, T aY) { x = aX; y = aY; }
+  void MoveTo(const Point& aPoint) { x = aPoint.x; y = aPoint.y; }
+  void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; }
+  void MoveBy(const Point& aPoint) { x += aPoint.x; y += aPoint.y; }
+  void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; }
+  void SizeTo(const SizeT& aSize) { width = aSize.width; height = aSize.height; }
+
+  void Inflate(T aD) { Inflate(aD, aD); }
+  void Inflate(T aDx, T aDy)
+  {
+    x -= aDx;
+    y -= aDy;
+    width += 2 * aDx;
+    height += 2 * aDy;
+  }
+  void Inflate(const MarginT& aMargin)
+  {
+    x -= aMargin.left;
+    y -= aMargin.top;
+    width += aMargin.LeftRight();
+    height += aMargin.TopBottom();
+  }
+  void Inflate(const SizeT& aSize) { Inflate(aSize.width, aSize.height); }
+
+  void Deflate(T aD) { Deflate(aD, aD); }
+  void Deflate(T aDx, T aDy)
+  {
+    x += aDx;
+    y += aDy;
+    width = std::max(T(0), width - 2 * aDx);
+    height = std::max(T(0), height - 2 * aDy);
+  }
+  void Deflate(const MarginT& aMargin)
+  {
+    x += aMargin.left;
+    y += aMargin.top;
+    width = std::max(T(0), width - aMargin.LeftRight());
+    height = std::max(T(0), height - aMargin.TopBottom());
+  }
+  void Deflate(const SizeT& aSize) { Deflate(aSize.width, aSize.height); }
+
+
+
+
+
+  bool IsEqualEdges(const Sub& aRect) const
+  {
+    return x == aRect.x && y == aRect.y &&
+           width == aRect.width && height == aRect.height;
+  }
+
+
+  bool IsEqualInterior(const Sub& aRect) const
+  {
+    return IsEqualEdges(aRect) || (IsEmpty() && aRect.IsEmpty());
+  }
+
+  friend Sub operator+(Sub aSub, const Point& aPoint)
+  {
+    aSub += aPoint;
+    return aSub;
+  }
+  friend Sub operator-(Sub aSub, const Point& aPoint)
+  {
+    aSub -= aPoint;
+    return aSub;
+  }
+  friend Sub operator+(Sub aSub, const SizeT& aSize)
+  {
+    aSub += aSize;
+    return aSub;
+  }
+  friend Sub operator-(Sub aSub, const SizeT& aSize)
+  {
+    aSub -= aSize;
+    return aSub;
+  }
+  Sub& operator+=(const Point& aPoint)
+  {
+    MoveBy(aPoint);
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const Point& aPoint)
+  {
+    MoveBy(-aPoint);
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator+=(const SizeT& aSize)
+  {
+    width += aSize.width;
+    height += aSize.height;
+    return *static_cast<Sub*>(this);
+  }
+  Sub& operator-=(const SizeT& aSize)
+  {
+    width -= aSize.width;
+    height -= aSize.height;
+    return *static_cast<Sub*>(this);
+  }
+
+  MarginT operator-(const Sub& aRect) const
+  {
+    return MarginT(aRect.y - y,
+                   XMost() - aRect.XMost(),
+                   YMost() - aRect.YMost(),
+                   aRect.x - x);
+  }
+
+
+  Point TopLeft() const { return Point(x, y); }
+  Point TopRight() const { return Point(XMost(), y); }
+  Point BottomLeft() const { return Point(x, YMost()); }
+  Point BottomRight() const { return Point(XMost(), YMost()); }
+  Point AtCorner(Corner aCorner) const {
+    switch (aCorner) {
+      case eCornerTopLeft: return TopLeft();
+      case eCornerTopRight: return TopRight();
+      case eCornerBottomRight: return BottomRight();
+      case eCornerBottomLeft: return BottomLeft();
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 329; ::abort(); } while (0); } while (0);
+  }
+  Point CCWCorner(mozilla::Side side) const {
+    switch (side) {
+      case eSideTop: return TopLeft();
+      case eSideRight: return TopRight();
+      case eSideBottom: return BottomRight();
+      case eSideLeft: return BottomLeft();
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 338; ::abort(); } while (0); } while (0);
+  }
+  Point CWCorner(mozilla::Side side) const {
+    switch (side) {
+      case eSideTop: return TopRight();
+      case eSideRight: return BottomRight();
+      case eSideBottom: return BottomLeft();
+      case eSideLeft: return TopLeft();
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 347; ::abort(); } while (0); } while (0);
+  }
+  Point Center() const { return Point(x, y) + Point(width, height)/2; }
+  SizeT Size() const { return SizeT(width, height); }
+
+  T Area() const { return width * height; }
+
+
+  T X() const { return x; }
+  T Y() const { return y; }
+  T Width() const { return width; }
+  T Height() const { return height; }
+  T XMost() const { return x + width; }
+  T YMost() const { return y + height; }
+
+
+  T Edge(mozilla::Side aSide) const
+  {
+    switch (aSide) {
+      case eSideTop: return Y();
+      case eSideRight: return XMost();
+      case eSideBottom: return YMost();
+      case eSideLeft: return X();
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 371; ::abort(); } while (0); } while (0);
+  }
+
+
+  void SetLeftEdge(T aX) {
+    do { } while (0);
+    width = XMost() - aX;
+    x = aX;
+  }
+  void SetRightEdge(T aXMost) {
+    do { } while (0);
+    width = aXMost - x;
+  }
+  void SetTopEdge(T aY) {
+    do { } while (0);
+    height = YMost() - aY;
+    y = aY;
+  }
+  void SetBottomEdge(T aYMost) {
+    do { } while (0);
+    height = aYMost - y;
+  }
+# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
+  void Round()
+  {
+    T x0 = static_cast<T>(floor(T(X()) + 0.5));
+    T y0 = static_cast<T>(floor(T(Y()) + 0.5));
+    T x1 = static_cast<T>(floor(T(XMost()) + 0.5));
+    T y1 = static_cast<T>(floor(T(YMost()) + 0.5));
+
+    x = x0;
+    y = y0;
+
+    width = x1 - x0;
+    height = y1 - y0;
+  }
+
+
+
+  void RoundIn()
+  {
+    T x0 = static_cast<T>(ceil(T(X())));
+    T y0 = static_cast<T>(ceil(T(Y())));
+    T x1 = static_cast<T>(floor(T(XMost())));
+    T y1 = static_cast<T>(floor(T(YMost())));
+
+    x = x0;
+    y = y0;
+
+    width = x1 - x0;
+    height = y1 - y0;
+  }
+
+
+
+  void RoundOut()
+  {
+    T x0 = static_cast<T>(floor(T(X())));
+    T y0 = static_cast<T>(floor(T(Y())));
+    T x1 = static_cast<T>(ceil(T(XMost())));
+    T y1 = static_cast<T>(ceil(T(YMost())));
+
+    x = x0;
+    y = y0;
+
+    width = x1 - x0;
+    height = y1 - y0;
+  }
+
+
+  void Scale(T aScale) { Scale(aScale, aScale); }
+
+  void Scale(T aXScale, T aYScale)
+  {
+    T right = XMost() * aXScale;
+    T bottom = YMost() * aYScale;
+    x = x * aXScale;
+    y = y * aYScale;
+    width = right - x;
+    height = bottom - y;
+  }
+
+
+
+  void ScaleRoundOut(double aScale) { ScaleRoundOut(aScale, aScale); }
+
+
+
+
+  void ScaleRoundOut(double aXScale, double aYScale)
+  {
+    T right = static_cast<T>(ceil(double(XMost()) * aXScale));
+    T bottom = static_cast<T>(ceil(double(YMost()) * aYScale));
+    x = static_cast<T>(floor(double(x) * aXScale));
+    y = static_cast<T>(floor(double(y) * aYScale));
+    width = right - x;
+    height = bottom - y;
+  }
+
+
+  void ScaleRoundIn(double aScale) { ScaleRoundIn(aScale, aScale); }
+
+
+
+  void ScaleRoundIn(double aXScale, double aYScale)
+  {
+    T right = static_cast<T>(floor(double(XMost()) * aXScale));
+    T bottom = static_cast<T>(floor(double(YMost()) * aYScale));
+    x = static_cast<T>(ceil(double(x) * aXScale));
+    y = static_cast<T>(ceil(double(y) * aYScale));
+    width = std::max<T>(0, right - x);
+    height = std::max<T>(0, bottom - y);
+  }
+
+
+
+  void ScaleInverseRoundOut(double aScale) { ScaleInverseRoundOut(aScale, aScale); }
+
+
+
+
+  void ScaleInverseRoundOut(double aXScale, double aYScale)
+  {
+    T right = static_cast<T>(ceil(double(XMost()) / aXScale));
+    T bottom = static_cast<T>(ceil(double(YMost()) / aYScale));
+    x = static_cast<T>(floor(double(x) / aXScale));
+    y = static_cast<T>(floor(double(y) / aYScale));
+    width = right - x;
+    height = bottom - y;
+  }
+
+
+  void ScaleInverseRoundIn(double aScale) { ScaleInverseRoundIn(aScale, aScale); }
+
+
+
+  void ScaleInverseRoundIn(double aXScale, double aYScale)
+  {
+    T right = static_cast<T>(floor(double(XMost()) / aXScale));
+    T bottom = static_cast<T>(floor(double(YMost()) / aYScale));
+    x = static_cast<T>(ceil(double(x) / aXScale));
+    y = static_cast<T>(ceil(double(y) / aYScale));
+    width = std::max<T>(0, right - x);
+    height = std::max<T>(0, bottom - y);
+  }
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) Point ClampPoint(const Point& aPoint) const
+  {
+    return Point(std::max(x, std::min(XMost(), aPoint.x)),
+                 std::max(y, std::min(YMost(), aPoint.y)));
+  }
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) Sub MoveInsideAndClamp(const Sub& aRect) const
+  {
+    Sub rect(std::max(aRect.x, x),
+             std::max(aRect.y, y),
+             std::min(aRect.width, width),
+             std::min(aRect.height, height));
+    rect.x = std::min(rect.XMost(), aRect.XMost()) - rect.width;
+    rect.y = std::min(rect.YMost(), aRect.YMost()) - rect.height;
+    return rect;
+  }
+
+
+
+
+
+
+
+  static Sub MaxIntRect()
+  {
+    return Sub(
+      static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
+      static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
+      static_cast<T>(std::numeric_limits<int32_t>::max()),
+      static_cast<T>(std::numeric_limits<int32_t>::max())
+    );
+  };
+
+  friend std::ostream& operator<<(std::ostream& stream,
+      const BaseRect<T, Sub, Point, SizeT, MarginT>& aRect) {
+    return stream << '(' << aRect.x << ',' << aRect.y << ','
+                  << aRect.width << ',' << aRect.height << ')';
+  }
+
+private:
+
+
+  bool operator==(const Sub& aRect) const { return false; }
+  bool operator!=(const Sub& aRect) const { return false; }
+};
+
+}
+}
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/NumericTools.h" 1
+
+
+
+
+
+
+
+
+namespace mozilla {
+
+
+
+
+
+
+inline int32_t
+RoundDownToMultiple(int32_t x, int32_t aMultiplier)
+{
+
+
+  int mod = x % aMultiplier;
+  if (x > 0) {
+    return x - mod;
+  }
+  return mod ? x - aMultiplier - mod : x;
+}
+
+
+
+
+inline int32_t
+RoundUpToMultiple(int32_t x, int32_t aMultiplier)
+{
+  int mod = x % aMultiplier;
+  if (x > 0) {
+    return mod ? x + aMultiplier - mod : x;
+  }
+  return x - mod;
+}
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+namespace mozilla {
+
+template<typename T> class CheckedInt;
+
+namespace detail {
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+struct UnsupportedType {};
+
+template<typename IntegerType>
+struct IsSupportedPass2
+{
+  static const bool value = false;
+};
+
+template<typename IntegerType>
+struct IsSupported
+{
+  static const bool value = IsSupportedPass2<IntegerType>::value;
+};
+
+template<>
+struct IsSupported<int8_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<uint8_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<int16_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<uint16_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<int32_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<uint32_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<int64_t>
+{ static const bool value = true; };
+
+template<>
+struct IsSupported<uint64_t>
+{ static const bool value = true; };
+
+
+template<>
+struct IsSupportedPass2<char>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<signed char>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<unsigned char>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<short>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<unsigned short>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<int>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<unsigned int>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<long>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<unsigned long>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<long long>
+{ static const bool value = true; };
+
+template<>
+struct IsSupportedPass2<unsigned long long>
+{ static const bool value = true; };
+
+
+
+
+
+
+
+template<typename IntegerType, size_t Size = sizeof(IntegerType)>
+struct TwiceBiggerType
+{
+  typedef typename detail::StdintTypeForSizeAndSignedness<
+                     sizeof(IntegerType) * 2,
+                     IsSigned<IntegerType>::value
+                   >::Type Type;
+};
+
+template<typename IntegerType>
+struct TwiceBiggerType<IntegerType, 8>
+{
+  typedef UnsupportedType Type;
+};
+
+template<typename T>
+inline bool
+HasSignBit(T aX)
+{
+
+
+
+
+  return bool(typename MakeUnsigned<T>::Type(aX) >>
+              PositionOfSignBit<T>::value);
+}
+
+
+
+template<typename T>
+inline T
+BinaryComplement(T aX)
+{
+  return ~aX;
+}
+
+template<typename T,
+         typename U,
+         bool IsTSigned = IsSigned<T>::value,
+         bool IsUSigned = IsSigned<U>::value>
+struct DoesRangeContainRange
+{
+};
+
+template<typename T, typename U, bool Signedness>
+struct DoesRangeContainRange<T, U, Signedness, Signedness>
+{
+  static const bool value = sizeof(T) >= sizeof(U);
+};
+
+template<typename T, typename U>
+struct DoesRangeContainRange<T, U, true, false>
+{
+  static const bool value = sizeof(T) > sizeof(U);
+};
+
+template<typename T, typename U>
+struct DoesRangeContainRange<T, U, false, true>
+{
+  static const bool value = false;
+};
+
+template<typename T,
+         typename U,
+         bool IsTSigned = IsSigned<T>::value,
+         bool IsUSigned = IsSigned<U>::value,
+         bool DoesTRangeContainURange = DoesRangeContainRange<T, U>::value>
+struct IsInRangeImpl {};
+
+template<typename T, typename U, bool IsTSigned, bool IsUSigned>
+struct IsInRangeImpl<T, U, IsTSigned, IsUSigned, true>
+{
+  static bool constexpr run(U)
+  {
+    return true;
+  }
+};
+
+template<typename T, typename U>
+struct IsInRangeImpl<T, U, true, true, false>
+{
+  static bool constexpr run(U aX)
+  {
+    return aX <= MaxValue<T>::value && aX >= MinValue<T>::value;
+  }
+};
+
+template<typename T, typename U>
+struct IsInRangeImpl<T, U, false, false, false>
+{
+  static bool constexpr run(U aX)
+  {
+    return aX <= MaxValue<T>::value;
+  }
+};
+
+template<typename T, typename U>
+struct IsInRangeImpl<T, U, true, false, false>
+{
+  static bool constexpr run(U aX)
+  {
+    return sizeof(T) > sizeof(U) || aX <= U(MaxValue<T>::value);
+  }
+};
+
+template<typename T, typename U>
+struct IsInRangeImpl<T, U, false, true, false>
+{
+  static bool constexpr run(U aX)
+  {
+    return sizeof(T) >= sizeof(U)
+           ? aX >= 0
+           : aX >= 0 && aX <= U(MaxValue<T>::value);
+  }
+};
+
+template<typename T, typename U>
+inline constexpr bool
+IsInRange(U aX)
+{
+  return IsInRangeImpl<T, U>::run(aX);
+}
+
+template<typename T>
+inline bool
+IsAddValid(T aX, T aY)
+{
+
+
+
+
+
+
+  typename MakeUnsigned<T>::Type ux = aX;
+  typename MakeUnsigned<T>::Type uy = aY;
+  typename MakeUnsigned<T>::Type result = ux + uy;
+  return IsSigned<T>::value
+         ? HasSignBit(BinaryComplement(T((result ^ aX) & (result ^ aY))))
+         : BinaryComplement(aX) >= aY;
+}
+
+template<typename T>
+inline bool
+IsSubValid(T aX, T aY)
+{
+
+
+
+  typename MakeUnsigned<T>::Type ux = aX;
+  typename MakeUnsigned<T>::Type uy = aY;
+  typename MakeUnsigned<T>::Type result = ux - uy;
+
+  return IsSigned<T>::value
+         ? HasSignBit(BinaryComplement(T((result ^ aX) & (aX ^ aY))))
+         : aX >= aY;
+}
+
+template<typename T,
+         bool IsTSigned = IsSigned<T>::value,
+         bool TwiceBiggerTypeIsSupported =
+           IsSupported<typename TwiceBiggerType<T>::Type>::value>
+struct IsMulValidImpl {};
+
+template<typename T, bool IsTSigned>
+struct IsMulValidImpl<T, IsTSigned, true>
+{
+  static bool run(T aX, T aY)
+  {
+    typedef typename TwiceBiggerType<T>::Type TwiceBiggerType;
+    TwiceBiggerType product = TwiceBiggerType(aX) * TwiceBiggerType(aY);
+    return IsInRange<T>(product);
+  }
+};
+
+template<typename T>
+struct IsMulValidImpl<T, true, false>
+{
+  static bool run(T aX, T aY)
+  {
+    const T max = MaxValue<T>::value;
+    const T min = MinValue<T>::value;
+
+    if (aX == 0 || aY == 0) {
+      return true;
+    }
+    if (aX > 0) {
+      return aY > 0
+             ? aX <= max / aY
+             : aY >= min / aX;
+    }
+
+
+    return aY > 0
+           ? aX >= min / aY
+           : aY >= max / aX;
+  }
+};
+
+template<typename T>
+struct IsMulValidImpl<T, false, false>
+{
+  static bool run(T aX, T aY)
+  {
+    return aY == 0 || aX <= MaxValue<T>::value / aY;
+  }
+};
+
+template<typename T>
+inline bool
+IsMulValid(T aX, T aY)
+{
+  return IsMulValidImpl<T>::run(aX, aY);
+}
+
+template<typename T>
+inline bool
+IsDivValid(T aX, T aY)
+{
+
+
+  return aY != 0 &&
+         !(IsSigned<T>::value && aX == MinValue<T>::value && aY == T(-1));
+}
+
+template<typename T, bool IsTSigned = IsSigned<T>::value>
+struct IsModValidImpl;
+
+template<typename T>
+inline bool
+IsModValid(T aX, T aY)
+{
+  return IsModValidImpl<T>::run(aX, aY);
+}
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+template<typename T>
+struct IsModValidImpl<T, false>
+{
+  static inline bool run(T aX, T aY)
+  {
+    return aY >= 1;
+  }
+};
+
+template<typename T>
+struct IsModValidImpl<T, true>
+{
+  static inline bool run(T aX, T aY)
+  {
+    if (aX < 0) {
+      return false;
+    }
+    return aY >= 1;
+  }
+};
+
+template<typename T, bool IsSigned = IsSigned<T>::value>
+struct NegateImpl;
+
+template<typename T>
+struct NegateImpl<T, false>
+{
+  static CheckedInt<T> negate(const CheckedInt<T>& aVal)
+  {
+
+
+    return CheckedInt<T>(0, aVal.isValid() && aVal.mValue == 0);
+  }
+};
+
+template<typename T>
+struct NegateImpl<T, true>
+{
+  static CheckedInt<T> negate(const CheckedInt<T>& aVal)
+  {
+
+
+    if (!aVal.isValid() || aVal.mValue == MinValue<T>::value) {
+      return CheckedInt<T>(aVal.mValue, false);
+    }
+    return CheckedInt<T>(-aVal.mValue, true);
+  }
+};
+
+}
+# 499 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+template<typename T>
+class CheckedInt
+{
+protected:
+  T mValue;
+  bool mIsValid;
+
+  template<typename U>
+  CheckedInt(U aValue, bool aIsValid) : mValue(aValue), mIsValid(aIsValid)
+  {
+    static_assert(detail::IsSupported<T>::value &&
+                  detail::IsSupported<U>::value,
+                  "This type is not supported by CheckedInt");
+  }
+
+  friend struct detail::NegateImpl<T>;
+
+public:
+# 528 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+  template<typename U>
+               constexpr CheckedInt(U aValue)
+    : mValue(T(aValue)),
+      mIsValid(detail::IsInRange<T>(aValue))
+  {
+    static_assert(detail::IsSupported<T>::value &&
+                  detail::IsSupported<U>::value,
+                  "This type is not supported by CheckedInt");
+  }
+
+  template<typename U>
+  friend class CheckedInt;
+
+  template<typename U>
+  CheckedInt<U> toChecked() const
+  {
+    CheckedInt<U> ret(mValue);
+    ret.mIsValid = ret.mIsValid && mIsValid;
+    return ret;
+  }
+
+
+  constexpr CheckedInt() : mValue(0), mIsValid(true)
+  {
+    static_assert(detail::IsSupported<T>::value,
+                  "This type is not supported by CheckedInt");
+  }
+
+
+  T value() const
+  {
+    do { } while (0);
+    return mValue;
+  }
+
+
+
+
+
+
+  bool isValid() const
+  {
+    return mIsValid;
+  }
+
+  template<typename U>
+  friend CheckedInt<U> operator +(const CheckedInt<U>& aLhs,
+                                  const CheckedInt<U>& aRhs);
+  template<typename U>
+  CheckedInt& operator +=(U aRhs);
+  CheckedInt& operator +=(const CheckedInt<T>& aRhs);
+
+  template<typename U>
+  friend CheckedInt<U> operator -(const CheckedInt<U>& aLhs,
+                                  const CheckedInt<U>& aRhs);
+  template<typename U>
+  CheckedInt& operator -=(U aRhs);
+  CheckedInt& operator -=(const CheckedInt<T>& aRhs);
+
+  template<typename U>
+  friend CheckedInt<U> operator *(const CheckedInt<U>& aLhs,
+                                  const CheckedInt<U>& aRhs);
+  template<typename U>
+  CheckedInt& operator *=(U aRhs);
+  CheckedInt& operator *=(const CheckedInt<T>& aRhs);
+
+  template<typename U>
+  friend CheckedInt<U> operator /(const CheckedInt<U>& aLhs,
+                                  const CheckedInt<U>& aRhs);
+  template<typename U>
+  CheckedInt& operator /=(U aRhs);
+  CheckedInt& operator /=(const CheckedInt<T>& aRhs);
+
+  template<typename U>
+  friend CheckedInt<U> operator %(const CheckedInt<U>& aLhs,
+                                  const CheckedInt<U>& aRhs);
+  template<typename U>
+  CheckedInt& operator %=(U aRhs);
+  CheckedInt& operator %=(const CheckedInt<T>& aRhs);
+
+  CheckedInt operator -() const
+  {
+    return detail::NegateImpl<T>::negate(*this);
+  }
+# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+  bool operator ==(const CheckedInt& aOther) const
+  {
+    return mIsValid && aOther.mIsValid && mValue == aOther.mValue;
+  }
+
+
+  CheckedInt& operator++()
+  {
+    *this += 1;
+    return *this;
+  }
+
+
+  CheckedInt operator++(int)
+  {
+    CheckedInt tmp = *this;
+    *this += 1;
+    return tmp;
+  }
+
+
+  CheckedInt& operator--()
+  {
+    *this -= 1;
+    return *this;
+  }
+
+
+  CheckedInt operator--(int)
+  {
+    CheckedInt tmp = *this;
+    *this -= 1;
+    return tmp;
+  }
+
+private:
+
+
+
+
+  template<typename U> bool operator !=(U aOther) const = delete;
+  template<typename U> bool operator < (U aOther) const = delete;
+  template<typename U> bool operator <=(U aOther) const = delete;
+  template<typename U> bool operator > (U aOther) const = delete;
+  template<typename U> bool operator >=(U aOther) const = delete;
+};
+# 690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+template<typename T> inline CheckedInt<T> operator +(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsAddValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue + aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
+template<typename T> inline CheckedInt<T> operator -(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsSubValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue - aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
+template<typename T> inline CheckedInt<T> operator *(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsMulValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue * aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
+template<typename T> inline CheckedInt<T> operator /(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsDivValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue / aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
+template<typename T> inline CheckedInt<T> operator %(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsModValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue % aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
+# 704 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+namespace detail {
+
+template<typename T, typename U>
+struct CastToCheckedIntImpl
+{
+  typedef CheckedInt<T> ReturnType;
+  static CheckedInt<T> run(U aU) { return aU; }
+};
+
+template<typename T>
+struct CastToCheckedIntImpl<T, CheckedInt<T> >
+{
+  typedef const CheckedInt<T>& ReturnType;
+  static const CheckedInt<T>& run(const CheckedInt<T>& aU) { return aU; }
+};
+
+}
+
+template<typename T, typename U>
+inline typename detail::CastToCheckedIntImpl<T, U>::ReturnType
+castToCheckedInt(U aU)
+{
+  static_assert(detail::IsSupported<T>::value &&
+                detail::IsSupported<U>::value,
+                "This type is not supported by CheckedInt");
+  return detail::CastToCheckedIntImpl<T, U>::run(aU);
+}
+# 757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
+template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator +=(U aRhs) { *this = *this + castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator +=(const CheckedInt<T>& aRhs) { *this = *this + aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator +(const CheckedInt<T>& aLhs, U aRhs) { return aLhs + castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator +(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) + aRhs; }
+template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator *=(U aRhs) { *this = *this * castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator *=(const CheckedInt<T>& aRhs) { *this = *this * aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator *(const CheckedInt<T>& aLhs, U aRhs) { return aLhs * castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator *(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) * aRhs; }
+template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator -=(U aRhs) { *this = *this - castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator -=(const CheckedInt<T>& aRhs) { *this = *this - aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator -(const CheckedInt<T>& aLhs, U aRhs) { return aLhs - castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator -(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) - aRhs; }
+template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator /=(U aRhs) { *this = *this / castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator /=(const CheckedInt<T>& aRhs) { *this = *this / aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator /(const CheckedInt<T>& aLhs, U aRhs) { return aLhs / castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator /(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) / aRhs; }
+template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator %=(U aRhs) { *this = *this % castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator %=(const CheckedInt<T>& aRhs) { *this = *this % aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator %(const CheckedInt<T>& aLhs, U aRhs) { return aLhs % castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator %(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) % aRhs; }
+
+
+
+template<typename T, typename U>
+inline bool
+operator ==(const CheckedInt<T>& aLhs, U aRhs)
+{
+  return aLhs == castToCheckedInt<T>(aRhs);
+}
+
+template<typename T, typename U>
+inline bool
+operator ==(U aLhs, const CheckedInt<T>& aRhs)
+{
+  return castToCheckedInt<T>(aLhs) == aRhs;
+}
+
+
+typedef CheckedInt<int8_t> CheckedInt8;
+typedef CheckedInt<uint8_t> CheckedUint8;
+typedef CheckedInt<int16_t> CheckedInt16;
+typedef CheckedInt<uint16_t> CheckedUint16;
+typedef CheckedInt<int32_t> CheckedInt32;
+typedef CheckedInt<uint32_t> CheckedUint32;
+typedef CheckedInt<int64_t> CheckedInt64;
+typedef CheckedInt<uint64_t> CheckedUint64;
+
+}
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2
+
+namespace mozilla {
+namespace gfx {
+
+static inline bool
+IsOperatorBoundByMask(CompositionOp aOp) {
+  switch (aOp) {
+  case CompositionOp::OP_IN:
+  case CompositionOp::OP_OUT:
+  case CompositionOp::OP_DEST_IN:
+  case CompositionOp::OP_DEST_ATOP:
+  case CompositionOp::OP_SOURCE:
+    return false;
+  default:
+    return true;
+  }
+}
+
+template <class T>
+struct ClassStorage
+{
+  char bytes[sizeof(T)];
+
+  const T *addr() const { return (const T *)bytes; }
+  T *addr() { return (T *)(void *)bytes; }
+};
+
+static inline bool
+FuzzyEqual(Float aA, Float aB, Float aErr)
+{
+  if ((aA + aErr >= aB) && (aA - aErr <= aB)) {
+    return true;
+  }
+  return false;
+}
+
+static inline void
+NudgeToInteger(float *aVal)
+{
+  float r = floorf(*aVal + 0.5f);
+
+
+
+
+
+  if (FuzzyEqual(r, *aVal, r == 0.0f ? 1e-6f : fabs(r*1e-6f))) {
+    *aVal = r;
+  }
+}
+
+static inline void
+NudgeToInteger(float *aVal, float aErr)
+{
+  float r = floorf(*aVal + 0.5f);
+  if (FuzzyEqual(r, *aVal, aErr)) {
+    *aVal = r;
+  }
+}
+
+static inline Float
+Distance(Point aA, Point aB)
+{
+  return hypotf(aB.x - aA.x, aB.y - aA.y);
+}
+
+static inline int
+BytesPerPixel(SurfaceFormat aFormat)
+{
+  switch (aFormat) {
+  case SurfaceFormat::A8:
+    return 1;
+  case SurfaceFormat::R5G6B5_UINT16:
+    return 2;
+  case SurfaceFormat::R8G8B8:
+  case SurfaceFormat::B8G8R8:
+    return 3;
+  case SurfaceFormat::HSV:
+  case SurfaceFormat::Lab:
+    return 3 * sizeof(float);
+  case SurfaceFormat::Depth:
+    return sizeof(uint16_t);
+  default:
+    return 4;
+  }
+}
+
+static inline bool
+IsOpaqueFormat(SurfaceFormat aFormat) {
+  switch (aFormat) {
+    case SurfaceFormat::B8G8R8X8:
+    case SurfaceFormat::R8G8B8X8:
+    case SurfaceFormat::X8R8G8B8:
+    case SurfaceFormat::YUV:
+    case SurfaceFormat::NV12:
+    case SurfaceFormat::YUV422:
+    case SurfaceFormat::R5G6B5_UINT16:
+      return true;
+    default:
+      return false;
+  }
+}
+
+template<typename T, int alignment = 16>
+struct AlignedArray
+{
+  typedef T value_type;
+
+  AlignedArray()
+    : mPtr(nullptr)
+    , mStorage(nullptr)
+  {
+  }
+
+  explicit __attribute__((always_inline)) inline AlignedArray(size_t aCount, bool aZero = false)
+    : mStorage(nullptr)
+    , mCount(0)
+  {
+    Realloc(aCount, aZero);
+  }
+
+  __attribute__((always_inline)) inline ~AlignedArray()
+  {
+    Dealloc();
+  }
+
+  void Dealloc()
+  {
+
+
+
+
+    static_assert(mozilla::IsPod<T>::value,
+                  "Destructors must be invoked for this type");
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h"
+    free(mStorage);
+    mStorage = nullptr;
+    mPtr = nullptr;
+  }
+
+  __attribute__((always_inline)) inline void Realloc(size_t aCount, bool aZero = false)
+  {
+    free(mStorage);
+    CheckedInt32 storageByteCount =
+      CheckedInt32(sizeof(T)) * aCount + (alignment - 1);
+    if (!storageByteCount.isValid()) {
+      mStorage = nullptr;
+      mPtr = nullptr;
+      mCount = 0;
+      return;
+    }
+
+
+    if (aZero) {
+
+
+      mStorage = static_cast<uint8_t *>(calloc(1, storageByteCount.value()));
+    } else {
+      mStorage = static_cast<uint8_t *>(malloc(storageByteCount.value()));
+    }
+    if (!mStorage) {
+      mStorage = nullptr;
+      mPtr = nullptr;
+      mCount = 0;
+      return;
+    }
+    if (uintptr_t(mStorage) % alignment) {
+
+      mPtr = (T*)(uintptr_t(mStorage) + alignment - (uintptr_t(mStorage) % alignment));
+    } else {
+      mPtr = (T*)(mStorage);
+    }
+
+
+
+
+    mPtr = new (mPtr) T[aCount];
+    mCount = aCount;
+  }
+
+  void Swap(AlignedArray<T, alignment>& aOther)
+  {
+    mozilla::Swap(mPtr, aOther.mPtr);
+    mozilla::Swap(mStorage, aOther.mStorage);
+    mozilla::Swap(mCount, aOther.mCount);
+  }
+
+  __attribute__((always_inline)) inline operator T*()
+  {
+    return mPtr;
+  }
+
+  T *mPtr;
+
+private:
+  uint8_t *mStorage;
+  size_t mCount;
+};
+# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h"
+template<int alignment>
+int32_t GetAlignedStride(int32_t aWidth, int32_t aBytesPerPixel)
+{
+  static_assert(alignment > 0 && (alignment & (alignment-1)) == 0,
+                "This implementation currently require power-of-two alignment");
+  const int32_t mask = alignment - 1;
+  CheckedInt32 stride = CheckedInt32(aWidth) * CheckedInt32(aBytesPerPixel) + CheckedInt32(mask);
+  if (stride.isValid()) {
+    return stride.value() & ~mask;
+  }
+  return 0;
+}
+
+}
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
+namespace mozilla {
+
+struct Nothing { };
+# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
+template<class T>
+class Maybe
+{
+  alignas(T) unsigned char mStorage[sizeof(T)];
+  char mIsSome;
+
+
+
+  void* data() { return mStorage; }
+  const void* data() const { return mStorage; }
+
+public:
+  using ValueType = T;
+
+  Maybe() : mIsSome(false) { }
+  ~Maybe() { reset(); }
+
+               Maybe(Nothing) : mIsSome(false) { }
+
+  Maybe(const Maybe& aOther)
+    : mIsSome(false)
+  {
+    if (aOther.mIsSome) {
+      emplace(*aOther);
+    }
+  }
+
+
+
+
+  template<typename U,
+           typename =
+             typename std::enable_if<std::is_convertible<U, T>::value>::type>
+
+  Maybe(const Maybe<U>& aOther)
+    : mIsSome(false)
+  {
+    if (aOther.isSome()) {
+      emplace(*aOther);
+    }
+  }
+
+  Maybe(Maybe&& aOther)
+    : mIsSome(false)
+  {
+    if (aOther.mIsSome) {
+      emplace(Move(*aOther));
+      aOther.reset();
+    }
+  }
+
+
+
+
+  template<typename U,
+           typename =
+             typename std::enable_if<std::is_convertible<U, T>::value>::type>
+
+  Maybe(Maybe<U>&& aOther)
+    : mIsSome(false)
+  {
+    if (aOther.isSome()) {
+      emplace(Move(*aOther));
+      aOther.reset();
+    }
+  }
+
+  Maybe& operator=(const Maybe& aOther)
+  {
+    if (&aOther != this) {
+      if (aOther.mIsSome) {
+        if (mIsSome) {
+          ref() = aOther.ref();
+        } else {
+          emplace(*aOther);
+        }
+      } else {
+        reset();
+      }
+    }
+    return *this;
+  }
+
+  template<typename U,
+           typename =
+             typename std::enable_if<std::is_convertible<U, T>::value>::type>
+  Maybe& operator=(const Maybe<U>& aOther)
+  {
+    if (aOther.isSome()) {
+      if (mIsSome) {
+        ref() = aOther.ref();
+      } else {
+        emplace(*aOther);
+      }
+    } else {
+      reset();
+    }
+    return *this;
+  }
+
+  Maybe& operator=(Maybe&& aOther)
+  {
+    do { } while (0);
+
+    if (aOther.mIsSome) {
+      if (mIsSome) {
+        ref() = Move(aOther.ref());
+      } else {
+        emplace(Move(*aOther));
+      }
+      aOther.reset();
+    } else {
+      reset();
+    }
+
+    return *this;
+  }
+
+  template<typename U,
+           typename =
+             typename std::enable_if<std::is_convertible<U, T>::value>::type>
+  Maybe& operator=(Maybe<U>&& aOther)
+  {
+    if (aOther.isSome()) {
+      if (mIsSome) {
+        ref() = Move(aOther.ref());
+      } else {
+        emplace(Move(*aOther));
+      }
+      aOther.reset();
+    } else {
+      reset();
+    }
+
+    return *this;
+  }
+
+
+  explicit operator bool() const { return isSome(); }
+  bool isSome() const { return mIsSome; }
+  bool isNothing() const { return !mIsSome; }
+
+
+  T value() const
+  {
+    do { } while (0);
+    return ref();
+  }
+
+
+
+
+
+  template<typename V>
+  T valueOr(V&& aDefault) const
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return Forward<V>(aDefault);
+  }
+
+
+
+
+
+  template<typename F>
+  T valueOrFrom(F&& aFunc) const
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return aFunc();
+  }
+
+
+  T* ptr()
+  {
+    do { } while (0);
+    return &ref();
+  }
+
+  const T* ptr() const
+  {
+    do { } while (0);
+    return &ref();
+  }
+
+
+
+
+
+  T* ptrOr(T* aDefault)
+  {
+    if (isSome()) {
+      return ptr();
+    }
+    return aDefault;
+  }
+
+  const T* ptrOr(const T* aDefault) const
+  {
+    if (isSome()) {
+      return ptr();
+    }
+    return aDefault;
+  }
+
+
+
+
+
+  template<typename F>
+  T* ptrOrFrom(F&& aFunc)
+  {
+    if (isSome()) {
+      return ptr();
+    }
+    return aFunc();
+  }
+
+  template<typename F>
+  const T* ptrOrFrom(F&& aFunc) const
+  {
+    if (isSome()) {
+      return ptr();
+    }
+    return aFunc();
+  }
+
+  T* operator->()
+  {
+    do { } while (0);
+    return ptr();
+  }
+
+  const T* operator->() const
+  {
+    do { } while (0);
+    return ptr();
+  }
+
+
+  T& ref()
+  {
+    do { } while (0);
+    return *static_cast<T*>(data());
+  }
+
+  const T& ref() const
+  {
+    do { } while (0);
+    return *static_cast<const T*>(data());
+  }
+
+
+
+
+
+  T& refOr(T& aDefault)
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return aDefault;
+  }
+
+  const T& refOr(const T& aDefault) const
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return aDefault;
+  }
+
+
+
+
+
+  template<typename F>
+  T& refOrFrom(F&& aFunc)
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return aFunc();
+  }
+
+  template<typename F>
+  const T& refOrFrom(F&& aFunc) const
+  {
+    if (isSome()) {
+      return ref();
+    }
+    return aFunc();
+  }
+
+  T& operator*()
+  {
+    do { } while (0);
+    return ref();
+  }
+
+  const T& operator*() const
+  {
+    do { } while (0);
+    return ref();
+  }
+
+
+
+  template<typename Func>
+  Maybe& apply(Func aFunc)
+  {
+    if (isSome()) {
+      aFunc(ref());
+    }
+    return *this;
+  }
+
+  template<typename Func>
+  const Maybe& apply(Func aFunc) const
+  {
+    if (isSome()) {
+      aFunc(ref());
+    }
+    return *this;
+  }
+
+
+
+
+
+  template<typename Func>
+  auto map(Func aFunc) -> Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>
+  {
+    using ReturnType = decltype(aFunc(ref()));
+    if (isSome()) {
+      Maybe<ReturnType> val;
+      val.emplace(aFunc(ref()));
+      return val;
+    }
+    return Maybe<ReturnType>();
+  }
+
+  template<typename Func>
+  auto map(Func aFunc) const -> Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>
+  {
+    using ReturnType = decltype(aFunc(ref()));
+    if (isSome()) {
+      Maybe<ReturnType> val;
+      val.emplace(aFunc(ref()));
+      return val;
+    }
+    return Maybe<ReturnType>();
+  }
+
+
+  void reset()
+  {
+    if (isSome()) {
+      ref().T::~T();
+      mIsSome = false;
+    }
+  }
+
+
+
+
+
+  template<typename... Args>
+  void emplace(Args&&... aArgs)
+  {
+    do { } while (0);
+    ::new (KnownNotNull, data()) T(Forward<Args>(aArgs)...);
+    mIsSome = true;
+  }
+
+  friend std::ostream&
+  operator<<(std::ostream& aStream, const Maybe<T>& aMaybe)
+  {
+    if (aMaybe) {
+      aStream << aMaybe.ref();
+    } else {
+      aStream << "<Nothing>";
+    }
+    return aStream;
+  }
+};
+# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
+template<typename T,
+         typename U = typename std::remove_cv<
+           typename std::remove_reference<T>::type>::type>
+Maybe<U>
+Some(T&& aValue)
+{
+  Maybe<U> value;
+  value.emplace(Forward<T>(aValue));
+  return value;
+}
+
+template<typename T>
+Maybe<typename RemoveCV<typename RemoveReference<T>::Type>::Type>
+ToMaybe(T* aPtr)
+{
+  if (aPtr) {
+    return Some(*aPtr);
+  }
+  return Nothing();
+}
+
+
+
+
+
+
+template<typename T> bool
+operator==(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  if (aLHS.isNothing() != aRHS.isNothing()) {
+    return false;
+  }
+  return aLHS.isNothing() || *aLHS == *aRHS;
+}
+
+template<typename T> bool
+operator!=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  return !(aLHS == aRHS);
+}
+
+
+
+
+
+template<typename T> bool
+operator==(const Maybe<T>& aLHS, const Nothing& aRHS)
+{
+  return aLHS.isNothing();
+}
+
+template<typename T> bool
+operator!=(const Maybe<T>& aLHS, const Nothing& aRHS)
+{
+  return !(aLHS == aRHS);
+}
+
+template<typename T> bool
+operator==(const Nothing& aLHS, const Maybe<T>& aRHS)
+{
+  return aRHS.isNothing();
+}
+
+template<typename T> bool
+operator!=(const Nothing& aLHS, const Maybe<T>& aRHS)
+{
+  return !(aLHS == aRHS);
+}
+
+
+
+
+
+template<typename T> bool
+operator<(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  if (aLHS.isNothing()) {
+    return aRHS.isSome();
+  }
+  if (aRHS.isNothing()) {
+    return false;
+  }
+  return *aLHS < *aRHS;
+}
+
+template<typename T> bool
+operator>(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  return !(aLHS < aRHS || aLHS == aRHS);
+}
+
+template<typename T> bool
+operator<=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  return aLHS < aRHS || aLHS == aRHS;
+}
+
+template<typename T> bool
+operator>=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
+{
+  return !(aLHS < aRHS);
+}
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
+# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
+
+namespace mozilla {
+
+template <typename> struct IsPixel;
+
+namespace gfx {
+
+template<class units, class F> struct RectTyped;
+
+template<class units>
+struct IntMarginTyped:
+    public BaseMargin<int32_t, IntMarginTyped<units> >,
+    public units {
+    static_assert(IsPixel<units>::value,
+                  "'units' must be a coordinate system tag");
+
+    typedef BaseMargin<int32_t, IntMarginTyped<units> > Super;
+
+    IntMarginTyped() : Super() {}
+    IntMarginTyped(int32_t aTop, int32_t aRight, int32_t aBottom, int32_t aLeft) :
+        Super(aTop, aRight, aBottom, aLeft) {}
+
+
+
+
+    static IntMarginTyped<units> FromUnknownMargin(const IntMarginTyped<UnknownUnits>& aMargin) {
+        return IntMarginTyped<units>(aMargin.top, aMargin.right,
+                                     aMargin.bottom, aMargin.left);
+    }
+
+    IntMarginTyped<UnknownUnits> ToUnknownMargin() const {
+        return IntMarginTyped<UnknownUnits>(this->top, this->right,
+                                            this->bottom, this->left);
+    }
+};
+typedef IntMarginTyped<UnknownUnits> IntMargin;
+
+template<class units, class F = Float>
+struct MarginTyped:
+    public BaseMargin<F, MarginTyped<units> >,
+    public units {
+    static_assert(IsPixel<units>::value,
+                  "'units' must be a coordinate system tag");
+
+    typedef BaseMargin<F, MarginTyped<units, F> > Super;
+
+    MarginTyped() : Super() {}
+    MarginTyped(F aTop, F aRight, F aBottom, F aLeft) :
+        Super(aTop, aRight, aBottom, aLeft) {}
+    explicit MarginTyped(const IntMarginTyped<units>& aMargin) :
+        Super(F(aMargin.top), F(aMargin.right),
+              F(aMargin.bottom), F(aMargin.left)) {}
+};
+typedef MarginTyped<UnknownUnits> Margin;
+typedef MarginTyped<UnknownUnits, double> MarginDouble;
+
+template<class units>
+IntMarginTyped<units> RoundedToInt(const MarginTyped<units>& aMargin)
+{
+  return IntMarginTyped<units>(int32_t(floorf(aMargin.top + 0.5f)),
+                               int32_t(floorf(aMargin.right + 0.5f)),
+                               int32_t(floorf(aMargin.bottom + 0.5f)),
+                               int32_t(floorf(aMargin.left + 0.5f)));
+}
+
+template<class units>
+struct IntRectTyped :
+    public BaseRect<int32_t, IntRectTyped<units>, IntPointTyped<units>, IntSizeTyped<units>, IntMarginTyped<units> >,
+    public units {
+    static_assert(IsPixel<units>::value,
+                  "'units' must be a coordinate system tag");
+
+    typedef BaseRect<int32_t, IntRectTyped<units>, IntPointTyped<units>, IntSizeTyped<units>, IntMarginTyped<units> > Super;
+    typedef IntRectTyped<units> Self;
+    typedef IntParam<int32_t> ToInt;
+
+    IntRectTyped() : Super() {}
+    IntRectTyped(const IntPointTyped<units>& aPos, const IntSizeTyped<units>& aSize) :
+        Super(aPos, aSize) {}
+
+    IntRectTyped(ToInt aX, ToInt aY, ToInt aWidth, ToInt aHeight) :
+        Super(aX.value, aY.value, aWidth.value, aHeight.value) {}
+
+    static IntRectTyped<units> RoundIn(float aX, float aY, float aW, float aH) {
+      return IntRectTyped<units>::RoundIn(RectTyped<units, float>(aX, aY, aW, aH));
+    }
+
+    static IntRectTyped<units> RoundOut(float aX, float aY, float aW, float aH) {
+      return IntRectTyped<units>::RoundOut(RectTyped<units, float>(aX, aY, aW, aH));
+    }
+
+    static IntRectTyped<units> Round(float aX, float aY, float aW, float aH) {
+      return IntRectTyped<units>::Round(RectTyped<units, float>(aX, aY, aW, aH));
+    }
+
+    static IntRectTyped<units> Truncate(float aX, float aY, float aW, float aH) {
+      return IntRectTyped<units>(IntPointTyped<units>::Truncate(aX, aY),
+                                 IntSizeTyped<units>::Truncate(aW, aH));
+    }
+
+    static IntRectTyped<units> RoundIn(const RectTyped<units, float>& aRect) {
+      auto tmp(aRect);
+      tmp.RoundIn();
+      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
+                          int32_t(tmp.width), int32_t(tmp.height));
+    }
+
+    static IntRectTyped<units> RoundOut(const RectTyped<units, float>& aRect) {
+      auto tmp(aRect);
+      tmp.RoundOut();
+      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
+                          int32_t(tmp.width), int32_t(tmp.height));
+    }
+
+    static IntRectTyped<units> Round(const RectTyped<units, float>& aRect) {
+      auto tmp(aRect);
+      tmp.Round();
+      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
+                          int32_t(tmp.width), int32_t(tmp.height));
+    }
+
+    static IntRectTyped<units> Truncate(const RectTyped<units, float>& aRect) {
+      return IntRectTyped::Truncate(aRect.x, aRect.y, aRect.width, aRect.height);
+    }
+
+
+    void Round() {}
+    void RoundIn() {}
+    void RoundOut() {}
+
+
+
+
+    static IntRectTyped<units> FromUnknownRect(const IntRectTyped<UnknownUnits>& rect) {
+        return IntRectTyped<units>(rect.x, rect.y, rect.width, rect.height);
+    }
+
+    IntRectTyped<UnknownUnits> ToUnknownRect() const {
+        return IntRectTyped<UnknownUnits>(this->x, this->y, this->width, this->height);
+    }
+
+    bool Overflows() const {
+      CheckedInt<int32_t> xMost = this->x;
+      xMost += this->width;
+      CheckedInt<int32_t> yMost = this->y;
+      yMost += this->height;
+      return !xMost.isValid() || !yMost.isValid();
+    }
+
+
+
+
+    __attribute__ ((warn_unused_result)) Maybe<Self> SafeUnion(const Self& aRect) const
+    {
+      if (this->IsEmpty()) {
+        return aRect.Overflows() ? Nothing() : Some(aRect);
+      } else if (aRect.IsEmpty()) {
+        return Some(*static_cast<const Self*>(this));
+      } else {
+        return this->SafeUnionEdges(aRect);
+      }
+    }
+
+
+
+    __attribute__ ((warn_unused_result)) Maybe<Self> SafeUnionEdges(const Self& aRect) const
+    {
+      if (this->Overflows() || aRect.Overflows()) {
+        return Nothing();
+      }
+
+
+      CheckedInt<int32_t> newX = std::min(this->x, aRect.x);
+      CheckedInt<int32_t> newY = std::min(this->y, aRect.y);
+      CheckedInt<int32_t> newXMost = std::max(this->XMost(), aRect.XMost());
+      CheckedInt<int32_t> newYMost = std::max(this->YMost(), aRect.YMost());
+      CheckedInt<int32_t> newW = newXMost - newX;
+      CheckedInt<int32_t> newH = newYMost - newY;
+      if (!newW.isValid() || !newH.isValid()) {
+        return Nothing();
+      }
+      return Some(Self(newX.value(), newY.value(), newW.value(), newH.value()));
+    }
+
+
+    bool operator==(const IntRectTyped<units>& aRect) const
+    {
+      return IntRectTyped<units>::IsEqualEdges(aRect);
+    }
+
+    void InflateToMultiple(const IntSizeTyped<units>& aTileSize)
+    {
+      if (this->IsEmpty()) {
+        return;
+      }
+
+      int32_t yMost = this->YMost();
+      int32_t xMost = this->XMost();
+
+      this->x = mozilla::RoundDownToMultiple(this->x, aTileSize.width);
+      this->y = mozilla::RoundDownToMultiple(this->y, aTileSize.height);
+      xMost = mozilla::RoundUpToMultiple(xMost, aTileSize.width);
+      yMost = mozilla::RoundUpToMultiple(yMost, aTileSize.height);
+
+      this->width = xMost - this->x;
+      this->height = yMost - this->y;
+    }
+
+};
+typedef IntRectTyped<UnknownUnits> IntRect;
+
+template<class units, class F = Float>
+struct RectTyped :
+    public BaseRect<F, RectTyped<units, F>, PointTyped<units, F>, SizeTyped<units, F>, MarginTyped<units, F> >,
+    public units {
+    static_assert(IsPixel<units>::value,
+                  "'units' must be a coordinate system tag");
+
+    typedef BaseRect<F, RectTyped<units, F>, PointTyped<units, F>, SizeTyped<units, F>, MarginTyped<units, F> > Super;
+
+    RectTyped() : Super() {}
+    RectTyped(const PointTyped<units, F>& aPos, const SizeTyped<units, F>& aSize) :
+        Super(aPos, aSize) {}
+    RectTyped(F _x, F _y, F _width, F _height) :
+        Super(_x, _y, _width, _height) {}
+    explicit RectTyped(const IntRectTyped<units>& rect) :
+        Super(F(rect.x), F(rect.y),
+              F(rect.width), F(rect.height)) {}
+
+    void NudgeToIntegers()
+    {
+      NudgeToInteger(&(this->x));
+      NudgeToInteger(&(this->y));
+      NudgeToInteger(&(this->width));
+      NudgeToInteger(&(this->height));
+    }
+
+    bool ToIntRect(IntRectTyped<units> *aOut) const
+    {
+      *aOut = IntRectTyped<units>(int32_t(this->X()), int32_t(this->Y()),
+                                  int32_t(this->Width()), int32_t(this->Height()));
+      return RectTyped<units, F>(F(aOut->x), F(aOut->y),
+                                 F(aOut->width), F(aOut->height))
+             .IsEqualEdges(*this);
+    }
+
+
+
+
+    static RectTyped<units, F> FromUnknownRect(const RectTyped<UnknownUnits, F>& rect) {
+        return RectTyped<units, F>(rect.x, rect.y, rect.width, rect.height);
+    }
+
+    RectTyped<UnknownUnits, F> ToUnknownRect() const {
+        return RectTyped<UnknownUnits, F>(this->x, this->y, this->width, this->height);
+    }
+
+
+    bool operator==(const RectTyped<units, F>& aRect) const
+    {
+      return RectTyped<units, F>::IsEqualEdges(aRect);
+    }
+};
+typedef RectTyped<UnknownUnits> Rect;
+typedef RectTyped<UnknownUnits, double> RectDouble;
+
+template<class units>
+IntRectTyped<units> RoundedToInt(const RectTyped<units>& aRect)
+{
+  RectTyped<units> copy(aRect);
+  copy.Round();
+  return IntRectTyped<units>(int32_t(copy.x),
+                             int32_t(copy.y),
+                             int32_t(copy.width),
+                             int32_t(copy.height));
+}
+
+template<class units>
+IntRectTyped<units> RoundedIn(const RectTyped<units>& aRect)
+{
+  return IntRectTyped<units>::RoundIn(aRect);
+}
+
+template<class units>
+IntRectTyped<units> RoundedOut(const RectTyped<units>& aRect)
+{
+  return IntRectTyped<units>::RoundOut(aRect);
+}
+
+template<class units>
+IntRectTyped<units> TruncatedToInt(const RectTyped<units>& aRect) {
+  return IntRectTyped<units>::Truncate(aRect);
+}
+
+template<class units>
+RectTyped<units> IntRectToRect(const IntRectTyped<units>& aRect)
+{
+  return RectTyped<units>(aRect.x, aRect.y, aRect.width, aRect.height);
+}
+
+
+template <typename T>
+Maybe<T>
+IntersectMaybeRects(const Maybe<T>& a, const Maybe<T>& b)
+{
+  if (!a) {
+    return b;
+  } else if (!b) {
+    return a;
+  } else {
+    return Some(a->Intersect(*b));
+  }
+}
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
+
+struct nsMargin : public mozilla::gfx::BaseMargin<nscoord, nsMargin> {
+  typedef mozilla::gfx::BaseMargin<nscoord, nsMargin> Super;
+
+
+  nsMargin() : Super() {}
+  nsMargin(const nsMargin& aMargin) : Super(aMargin) {}
+  nsMargin(nscoord aTop, nscoord aRight, nscoord aBottom, nscoord aLeft)
+    : Super(aTop, aRight, aBottom, aLeft) {}
+};
+
+typedef mozilla::gfx::IntMargin nsIntMargin;
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h"
+class nsSVGAngle;
+class nsSVGIntegerPair;
+class nsSVGLength2;
+class nsSVGNumberPair;
+class nsSVGViewBox;
+
+namespace mozilla {
+class SVGLengthList;
+class SVGNumberList;
+class SVGPathData;
+class SVGPointList;
+class SVGAnimatedPreserveAspectRatio;
+class SVGStringList;
+class SVGTransformList;
+}
+
+namespace mozilla {
+
+class SVGAttrValueWrapper
+{
+public:
+  static void ToString(const nsSVGAngle* aAngle, nsAString& aResult);
+  static void ToString(const nsSVGIntegerPair* aIntegerPair,
+                       nsAString& aResult);
+  static void ToString(const nsSVGLength2* aLength, nsAString& aResult);
+  static void ToString(const mozilla::SVGLengthList* aLengthList,
+                       nsAString& aResult);
+  static void ToString(const mozilla::SVGNumberList* aNumberList,
+                       nsAString& aResult);
+  static void ToString(const nsSVGNumberPair* aNumberPair, nsAString& aResult);
+  static void ToString(const mozilla::SVGPathData* aPathData,
+                       nsAString& aResult);
+  static void ToString(const mozilla::SVGPointList* aPointList,
+                       nsAString& aResult);
+  static void ToString(
+    const mozilla::SVGAnimatedPreserveAspectRatio* aPreserveAspectRatio,
+    nsAString& aResult);
+  static void ToString(const mozilla::SVGStringList* aStringList,
+                       nsAString& aResult);
+  static void ToString(const mozilla::SVGTransformList* aTransformList,
+                       nsAString& aResult);
+  static void ToString(const nsSVGViewBox* aViewBox, nsAString& aResult);
+};
+
+}
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+namespace JS { class Value; }
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+enum JSValueType
+{
+    JSVAL_TYPE_DOUBLE = 0x00,
+    JSVAL_TYPE_INT32 = 0x01,
+    JSVAL_TYPE_UNDEFINED = 0x02,
+    JSVAL_TYPE_NULL = 0x03,
+    JSVAL_TYPE_BOOLEAN = 0x04,
+    JSVAL_TYPE_MAGIC = 0x05,
+    JSVAL_TYPE_STRING = 0x06,
+    JSVAL_TYPE_SYMBOL = 0x07,
+    JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
+    JSVAL_TYPE_OBJECT = 0x0c,
+
+
+    JSVAL_TYPE_UNKNOWN = 0x20,
+    JSVAL_TYPE_MISSING = 0x21
+} __attribute__((packed));
+
+static_assert(sizeof(JSValueType) == 1,
+              "compiler typed enum support is apparently buggy");
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+enum JSValueTag
+{
+    JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
+    JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
+    JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
+    JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
+    JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
+    JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
+    JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
+    JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
+    JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
+    JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
+} __attribute__((packed));
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+enum JSValueShiftedTag
+{
+    JSVAL_SHIFTED_TAG_MAX_DOUBLE = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << 47) | 0xFFFFFFFF),
+    JSVAL_SHIFTED_TAG_INT32 = (((uint64_t)JSVAL_TAG_INT32) << 47),
+    JSVAL_SHIFTED_TAG_UNDEFINED = (((uint64_t)JSVAL_TAG_UNDEFINED) << 47),
+    JSVAL_SHIFTED_TAG_NULL = (((uint64_t)JSVAL_TAG_NULL) << 47),
+    JSVAL_SHIFTED_TAG_BOOLEAN = (((uint64_t)JSVAL_TAG_BOOLEAN) << 47),
+    JSVAL_SHIFTED_TAG_MAGIC = (((uint64_t)JSVAL_TAG_MAGIC) << 47),
+    JSVAL_SHIFTED_TAG_STRING = (((uint64_t)JSVAL_TAG_STRING) << 47),
+    JSVAL_SHIFTED_TAG_SYMBOL = (((uint64_t)JSVAL_TAG_SYMBOL) << 47),
+    JSVAL_SHIFTED_TAG_PRIVATE_GCTHING = (((uint64_t)JSVAL_TAG_PRIVATE_GCTHING) << 47),
+    JSVAL_SHIFTED_TAG_OBJECT = (((uint64_t)JSVAL_TAG_OBJECT) << 47)
+} __attribute__((packed));
+
+static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
+              "compiler typed enum support is apparently buggy");
+# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+typedef enum JSWhyMagic
+{
+
+    JS_ELEMENTS_HOLE,
+
+
+    JS_NO_ITER_VALUE,
+
+
+    JS_GENERATOR_CLOSING,
+
+
+    JS_NO_CONSTANT,
+
+
+    JS_THIS_POISON,
+
+
+    JS_ARG_POISON,
+
+
+    JS_SERIALIZE_NO_NODE,
+
+
+    JS_LAZY_ARGUMENTS,
+
+
+    JS_OPTIMIZED_ARGUMENTS,
+
+
+    JS_IS_CONSTRUCTING,
+
+
+    JS_BLOCK_NEEDS_CLONE,
+
+
+    JS_HASH_KEY_EMPTY,
+
+
+    JS_ION_ERROR,
+
+
+    JS_ION_BAILOUT,
+
+
+    JS_OPTIMIZED_OUT,
+
+
+    JS_UNINITIALIZED_LEXICAL,
+
+
+    JS_GENERIC_MAGIC,
+
+    JS_WHY_MAGIC_COUNT
+} JSWhyMagic;
+
+namespace JS {
+
+static inline constexpr JS::Value UndefinedValue();
+static inline JS::Value PoisonedObjectValue(JSObject* obj);
+
+namespace detail {
+
+constexpr int CanonicalizedNaNSignBit = 0;
+constexpr uint64_t CanonicalizedNaNSignificand = 0x8000000000000ULL;
+
+constexpr uint64_t CanonicalizedNaNBits =
+    mozilla::SpecificNaNBits<double,
+                             detail::CanonicalizedNaNSignBit,
+                             detail::CanonicalizedNaNSignificand>::value;
+
+}
+
+
+
+
+
+
+
+static __attribute__((always_inline)) inline double
+GenericNaN()
+{
+  return mozilla::SpecificNaN<double>(detail::CanonicalizedNaNSignBit,
+                                      detail::CanonicalizedNaNSignificand);
+}
+
+
+
+
+
+static inline double
+CanonicalizeNaN(double d)
+{
+    if ((__builtin_expect(!!(mozilla::IsNaN(d)), 0)))
+        return GenericNaN();
+    return d;
+}
+# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+class alignas(8) Value
+{
+  public:
+
+
+
+    using PayloadType = uint64_t;
+
+
+
+
+
+
+    Value() = default;
+    Value(const Value& v) = default;
+
+
+
+
+
+    template <typename T>
+    static bool isNumberRepresentable(const T t) {
+        return T(double(t)) == t;
+    }
+
+
+
+    void setNull() {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_NULL, 0);
+    }
+
+    void setUndefined() {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_UNDEFINED, 0);
+    }
+
+    void setInt32(int32_t i) {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
+    }
+
+    int32_t& getInt32Ref() {
+        do { } while (0);
+        return data.s.payload.i32;
+    }
+
+    void setDouble(double d) {
+
+
+        data = layout(d);
+        do { } while (0);
+    }
+
+    void setNaN() {
+        setDouble(GenericNaN());
+    }
+
+    double& getDoubleRef() {
+        do { } while (0);
+        return data.asDouble;
+    }
+
+    void setString(JSString* str) {
+        do { } while (0);
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_STRING, PayloadType(str));
+    }
+
+    void setSymbol(JS::Symbol* sym) {
+        do { } while (0);
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_SYMBOL, PayloadType(sym));
+    }
+
+    void setObject(JSObject& obj) {
+        do { } while (0);
+
+
+
+
+
+        do { } while (0);
+
+        setObjectNoCheck(&obj);
+    }
+
+  private:
+    void setObjectNoCheck(JSObject* obj) {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_OBJECT, PayloadType(obj));
+    }
+
+    friend inline Value PoisonedObjectValue(JSObject* obj);
+
+  public:
+    void setBoolean(bool b) {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(b));
+    }
+
+    void setMagic(JSWhyMagic why) {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, uint32_t(why));
+    }
+
+    void setMagicUint32(uint32_t payload) {
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, payload);
+    }
+
+    bool setNumber(uint32_t ui) {
+        if (ui > ((int32_t)0x7fffffff)) {
+            setDouble((double)ui);
+            return false;
+        } else {
+            setInt32((int32_t)ui);
+            return true;
+        }
+    }
+
+    bool setNumber(double d) {
+        int32_t i;
+        if (mozilla::NumberIsInt32(d, &i)) {
+            setInt32(i);
+            return true;
+        }
+
+        setDouble(d);
+        return false;
+    }
+
+    void setObjectOrNull(JSObject* arg) {
+        if (arg)
+            setObject(*arg);
+        else
+            setNull();
+    }
+
+    void swap(Value& rhs) {
+        uint64_t tmp = rhs.data.asBits;
+        rhs.data.asBits = data.asBits;
+        data.asBits = tmp;
+    }
+
+  private:
+    JSValueTag toTag() const {
+
+
+
+        return JSValueTag(data.asBits >> 47);
+
+    }
+
+  public:
+# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+    const void* bitsAsPunboxPointer() const {
+        return reinterpret_cast<void*>(data.asBits);
+    }
+# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+    bool isUndefined() const {
+
+
+
+        return data.asBits == JSVAL_SHIFTED_TAG_UNDEFINED;
+
+    }
+
+    bool isNull() const {
+
+
+
+        return data.asBits == JSVAL_SHIFTED_TAG_NULL;
+
+    }
+
+    bool isNullOrUndefined() const {
+        return isNull() || isUndefined();
+    }
+
+    bool isInt32() const {
+        return toTag() == JSVAL_TAG_INT32;
+    }
+
+    bool isInt32(int32_t i32) const {
+        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i32));
+    }
+
+    bool isDouble() const {
+
+
+
+        return (data.asBits | mozilla::DoubleTypeTraits::kSignBit) <= JSVAL_SHIFTED_TAG_MAX_DOUBLE;
+
+    }
+
+    bool isNumber() const {
+
+
+
+
+        return data.asBits < JSVAL_SHIFTED_TAG_UNDEFINED;
+
+    }
+
+    bool isString() const {
+        return toTag() == JSVAL_TAG_STRING;
+    }
+
+    bool isSymbol() const {
+        return toTag() == JSVAL_TAG_SYMBOL;
+    }
+
+    bool isObject() const {
+
+
+
+        do { } while (0);
+        return data.asBits >= JSVAL_SHIFTED_TAG_OBJECT;
+
+    }
+
+    bool isPrimitive() const {
+
+
+
+        return data.asBits < JSVAL_SHIFTED_TAG_OBJECT;
+
+    }
+
+    bool isObjectOrNull() const {
+        return isObject() || isNull();
+    }
+
+    bool isGCThing() const {
+
+
+
+
+        return data.asBits >= JSVAL_SHIFTED_TAG_STRING;
+
+    }
+
+    bool isBoolean() const {
+        return toTag() == JSVAL_TAG_BOOLEAN;
+    }
+
+    bool isTrue() const {
+        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(true));
+    }
+
+    bool isFalse() const {
+        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(false));
+    }
+
+    bool isMagic() const {
+        return toTag() == JSVAL_TAG_MAGIC;
+    }
+
+    bool isMagic(JSWhyMagic why) const {
+        do { } while (0);
+        return isMagic();
+    }
+
+    JS::TraceKind traceKind() const {
+        do { } while (0);
+        static_assert((JSVAL_TAG_STRING & 0x03) == size_t(JS::TraceKind::String),
+                      "Value type tags must correspond with JS::TraceKinds.");
+        static_assert((JSVAL_TAG_SYMBOL & 0x03) == size_t(JS::TraceKind::Symbol),
+                      "Value type tags must correspond with JS::TraceKinds.");
+        static_assert((JSVAL_TAG_OBJECT & 0x03) == size_t(JS::TraceKind::Object),
+                      "Value type tags must correspond with JS::TraceKinds.");
+        if ((__builtin_expect(!!(isPrivateGCThing()), 0)))
+            return JS::GCThingTraceKind(toGCThing());
+        return JS::TraceKind(toTag() & 0x03);
+    }
+
+    JSWhyMagic whyMagic() const {
+        do { } while (0);
+        return data.s.payload.why;
+    }
+
+    uint32_t magicUint32() const {
+        do { } while (0);
+        return data.s.payload.u32;
+    }
+
+
+
+    bool operator==(const Value& rhs) const {
+        return data.asBits == rhs.data.asBits;
+    }
+
+    bool operator!=(const Value& rhs) const {
+        return data.asBits != rhs.data.asBits;
+    }
+
+    friend inline bool SameType(const Value& lhs, const Value& rhs);
+
+
+
+    int32_t toInt32() const {
+        do { } while (0);
+
+
+
+        return int32_t(data.asBits);
+
+    }
+
+    double toDouble() const {
+        do { } while (0);
+        return data.asDouble;
+    }
+
+    double toNumber() const {
+        do { } while (0);
+        return isDouble() ? toDouble() : double(toInt32());
+    }
+
+    JSString* toString() const {
+        do { } while (0);
+
+
+
+        return reinterpret_cast<JSString*>(data.asBits & 0x00007FFFFFFFFFFFLL);
+
+    }
+
+    JS::Symbol* toSymbol() const {
+        do { } while (0);
+
+
+
+        return reinterpret_cast<JS::Symbol*>(data.asBits & 0x00007FFFFFFFFFFFLL);
+
+    }
+
+    JSObject& toObject() const {
+        do { } while (0);
+
+
+
+        return *toObjectOrNull();
+
+    }
+
+    JSObject* toObjectOrNull() const {
+        do { } while (0);
+
+
+
+        uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL;
+        do { } while (0);
+        return reinterpret_cast<JSObject*>(ptrBits);
+
+    }
+
+    js::gc::Cell* toGCThing() const {
+        do { } while (0);
+
+
+
+        uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL;
+        do { } while (0);
+        return reinterpret_cast<js::gc::Cell*>(ptrBits);
+
+    }
+
+    GCCellPtr toGCCellPtr() const {
+        return GCCellPtr(toGCThing(), traceKind());
+    }
+
+    bool toBoolean() const {
+        do { } while (0);
+
+
+
+        return bool(data.asBits & 0x00007FFFFFFFFFFFLL);
+
+    }
+
+    uint32_t payloadAsRawUint32() const {
+        do { } while (0);
+        return data.s.payload.u32;
+    }
+
+    uint64_t asRawBits() const {
+        return data.asBits;
+    }
+
+    JSValueType extractNonDoubleType() const {
+        uint32_t type = toTag() & 0xF;
+        do { } while (0);
+        return JSValueType(type);
+    }
+# 709 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+    void setPrivate(void* ptr) {
+        do { } while (0);
+
+
+
+
+        data.asBits = uintptr_t(ptr) >> 1;
+
+        do { } while (0);
+    }
+
+    void* toPrivate() const {
+        do { } while (0);
+
+
+
+        do { } while (0);
+        return reinterpret_cast<void*>(data.asBits << 1);
+
+    }
+
+    void setPrivateUint32(uint32_t ui) {
+        do { } while (0);
+        setInt32(int32_t(ui));
+    }
+
+    uint32_t toPrivateUint32() const {
+        return uint32_t(toInt32());
+    }
+# 748 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+    void setPrivateGCThing(js::gc::Cell* cell) {
+        do { } while (0);
+
+        do { } while (0);
+
+        do { } while (0);
+
+
+        do { } while (0);
+
+
+
+
+
+        do { } while (0);
+
+        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_PRIVATE_GCTHING, PayloadType(cell));
+    }
+
+    bool isPrivateGCThing() const {
+        return toTag() == JSVAL_TAG_PRIVATE_GCTHING;
+    }
+
+    const size_t* payloadWord() const {
+
+
+
+        return &data.asWord;
+
+    }
+
+    const uintptr_t* payloadUIntPtr() const {
+
+
+
+        return &data.asUIntPtr;
+
+    }
+
+
+
+
+
+  private:
+# 822 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+    union layout {
+        uint64_t asBits;
+
+
+        struct {
+            uint64_t payload47 : 47;
+            JSValueTag tag : 17;
+        } debugView;
+
+        struct {
+            union {
+                int32_t i32;
+                uint32_t u32;
+                JSWhyMagic why;
+            } payload;
+        } s;
+        double asDouble;
+        void* asPtr;
+        size_t asWord;
+        uintptr_t asUIntPtr;
+
+        layout() = default;
+        explicit constexpr layout(uint64_t bits) : asBits(bits) {}
+        explicit constexpr layout(double d) : asDouble(d) {}
+    } data;
+# 902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+  private:
+    explicit constexpr Value(uint64_t asBits) : data(asBits) {}
+    explicit constexpr Value(double d) : data(d) {}
+
+    void staticAssertions() {
+        static_assert(sizeof(JSValueType) == 1, "JS_STATIC_ASSERT");
+        static_assert(sizeof(JSValueTag) == 4, "JS_STATIC_ASSERT");
+        static_assert(sizeof(JSWhyMagic) <= 4, "JS_STATIC_ASSERT");
+        static_assert(sizeof(Value) == 8, "JS_STATIC_ASSERT");
+    }
+
+    friend constexpr Value JS::UndefinedValue();
+
+  public:
+    static constexpr uint64_t
+    bitsFromTagAndPayload(JSValueTag tag, PayloadType payload)
+    {
+
+
+
+        return (uint64_t(uint32_t(tag)) << 47) | payload;
+
+    }
+
+    static constexpr Value
+    fromTagAndPayload(JSValueTag tag, PayloadType payload)
+    {
+        return fromRawBits(bitsFromTagAndPayload(tag, payload));
+    }
+
+    static constexpr Value
+    fromRawBits(uint64_t asBits) {
+        return Value(asBits);
+    }
+
+    static constexpr Value
+    fromInt32(int32_t i) {
+        return fromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
+    }
+
+    static constexpr Value
+    fromDouble(double d) {
+        return Value(d);
+    }
+} ;
+
+static_assert(sizeof(Value) == 8, "Value size must leave three tag bits, be a binary power, and is ubiquitously depended upon everywhere");
+
+inline bool
+IsOptimizedPlaceholderMagicValue(const Value& v)
+{
+    if (v.isMagic()) {
+        do { } while (0);
+        return true;
+    }
+    return false;
+}
+
+static __attribute__((always_inline)) inline void
+ExposeValueToActiveJS(const Value& v)
+{
+    if (v.isGCThing())
+        js::gc::ExposeGCThingToActiveJS(GCCellPtr(v));
+}
+
+
+
+static inline Value
+NullValue()
+{
+    Value v;
+    v.setNull();
+    return v;
+}
+
+static inline constexpr Value
+UndefinedValue()
+{
+    return Value::fromTagAndPayload(JSVAL_TAG_UNDEFINED, 0);
+}
+
+static inline constexpr Value
+Int32Value(int32_t i32)
+{
+    return Value::fromInt32(i32);
+}
+
+static inline Value
+DoubleValue(double dbl)
+{
+    Value v;
+    v.setDouble(dbl);
+    return v;
+}
+
+static inline Value
+CanonicalizedDoubleValue(double d)
+{
+    return (__builtin_expect(!!(mozilla::IsNaN(d)), 0))
+           ? Value::fromRawBits(detail::CanonicalizedNaNBits)
+           : Value::fromDouble(d);
+}
+
+static inline bool
+IsCanonicalized(double d)
+{
+  if (mozilla::IsInfinite(d) || mozilla::IsFinite(d))
+      return true;
+
+  uint64_t bits;
+  mozilla::BitwiseCast<uint64_t>(d, &bits);
+  return (bits & ~mozilla::DoubleTypeTraits::kSignBit) == detail::CanonicalizedNaNBits;
+}
+
+static inline Value
+DoubleNaNValue()
+{
+    Value v;
+    v.setNaN();
+    return v;
+}
+
+static inline Value
+Float32Value(float f)
+{
+    Value v;
+    v.setDouble(f);
+    return v;
+}
+
+static inline Value
+StringValue(JSString* str)
+{
+    Value v;
+    v.setString(str);
+    return v;
+}
+
+static inline Value
+SymbolValue(JS::Symbol* sym)
+{
+    Value v;
+    v.setSymbol(sym);
+    return v;
+}
+
+static inline Value
+BooleanValue(bool boo)
+{
+    Value v;
+    v.setBoolean(boo);
+    return v;
+}
+
+static inline Value
+TrueValue()
+{
+    Value v;
+    v.setBoolean(true);
+    return v;
+}
+
+static inline Value
+FalseValue()
+{
+    Value v;
+    v.setBoolean(false);
+    return v;
+}
+
+static inline Value
+ObjectValue(JSObject& obj)
+{
+    Value v;
+    v.setObject(obj);
+    return v;
+}
+
+static inline Value
+ObjectValueCrashOnTouch()
+{
+    Value v;
+    v.setObject(*reinterpret_cast<JSObject*>(0x48));
+    return v;
+}
+
+static inline Value
+MagicValue(JSWhyMagic why)
+{
+    Value v;
+    v.setMagic(why);
+    return v;
+}
+
+static inline Value
+MagicValueUint32(uint32_t payload)
+{
+    Value v;
+    v.setMagicUint32(payload);
+    return v;
+}
+
+static inline Value
+NumberValue(float f)
+{
+    Value v;
+    v.setNumber(f);
+    return v;
+}
+
+static inline Value
+NumberValue(double dbl)
+{
+    Value v;
+    v.setNumber(dbl);
+    return v;
+}
+
+static inline Value
+NumberValue(int8_t i)
+{
+    return Int32Value(i);
+}
+
+static inline Value
+NumberValue(uint8_t i)
+{
+    return Int32Value(i);
+}
+
+static inline Value
+NumberValue(int16_t i)
+{
+    return Int32Value(i);
+}
+
+static inline Value
+NumberValue(uint16_t i)
+{
+    return Int32Value(i);
+}
+
+static inline Value
+NumberValue(int32_t i)
+{
+    return Int32Value(i);
+}
+
+static inline constexpr Value
+NumberValue(uint32_t i)
+{
+    return i <= ((int32_t)0x7fffffff)
+           ? Int32Value(int32_t(i))
+           : Value::fromDouble(double(i));
+}
+
+namespace detail {
+
+template <bool Signed>
+class MakeNumberValue
+{
+  public:
+    template<typename T>
+    static inline Value create(const T t)
+    {
+        Value v;
+        if (((int32_t)0x80000000) <= t && t <= ((int32_t)0x7fffffff))
+            v.setInt32(int32_t(t));
+        else
+            v.setDouble(double(t));
+        return v;
+    }
+};
+
+template <>
+class MakeNumberValue<false>
+{
+  public:
+    template<typename T>
+    static inline Value create(const T t)
+    {
+        Value v;
+        if (t <= ((int32_t)0x7fffffff))
+            v.setInt32(int32_t(t));
+        else
+            v.setDouble(double(t));
+        return v;
+    }
+};
+
+}
+
+template <typename T>
+static inline Value
+NumberValue(const T t)
+{
+    do { } while (0);
+    return detail::MakeNumberValue<std::numeric_limits<T>::is_signed>::create(t);
+}
+
+static inline Value
+ObjectOrNullValue(JSObject* obj)
+{
+    Value v;
+    v.setObjectOrNull(obj);
+    return v;
+}
+
+static inline Value
+PrivateValue(void* ptr)
+{
+    Value v;
+    v.setPrivate(ptr);
+    return v;
+}
+
+static inline Value
+PrivateUint32Value(uint32_t ui)
+{
+    Value v;
+    v.setPrivateUint32(ui);
+    return v;
+}
+
+static inline Value
+PrivateGCThingValue(js::gc::Cell* cell)
+{
+    Value v;
+    v.setPrivateGCThing(cell);
+    return v;
+}
+
+static inline Value
+PoisonedObjectValue(JSObject* obj)
+{
+    Value v;
+    v.setObjectNoCheck(obj);
+    return v;
+}
+
+inline bool
+SameType(const Value& lhs, const Value& rhs)
+{
+
+
+
+
+    return (lhs.isDouble() && rhs.isDouble()) ||
+           (((lhs.data.asBits ^ rhs.data.asBits) & 0xFFFF800000000000ULL) == 0);
+
+}
+
+}
+
+
+
+namespace JS {
+void HeapValuePostBarrier(Value* valuep, const Value& prev, const Value& next);
+
+template <>
+struct GCPolicy<JS::Value>
+{
+    static Value initial() { return UndefinedValue(); }
+    static void trace(JSTracer* trc, Value* v, const char* name) {
+        js::UnsafeTraceManuallyBarrieredEdge(trc, v, name);
+    }
+    static bool isTenured(const Value& thing) {
+        return !thing.isGCThing() || !IsInsideNursery(thing.toGCThing());
+    }
+};
+
+}
+
+namespace js {
+
+template <>
+struct BarrierMethods<JS::Value>
+{
+    static gc::Cell* asGCThingOrNull(const JS::Value& v) {
+        return v.isGCThing() ? v.toGCThing() : nullptr;
+    }
+    static void postBarrier(JS::Value* v, const JS::Value& prev, const JS::Value& next) {
+        JS::HeapValuePostBarrier(v, prev, next);
+    }
+    static void exposeToJS(const JS::Value& v) {
+        JS::ExposeValueToActiveJS(v);
+    }
+};
+
+template <class Wrapper> class MutableValueOperations;
+
+
+
+
+
+
+
+template <class Wrapper>
+class WrappedPtrOperations<JS::Value, Wrapper>
+{
+    const JS::Value& value() const { return static_cast<const Wrapper*>(this)->get(); }
+
+  public:
+    bool isUndefined() const { return value().isUndefined(); }
+    bool isNull() const { return value().isNull(); }
+    bool isBoolean() const { return value().isBoolean(); }
+    bool isTrue() const { return value().isTrue(); }
+    bool isFalse() const { return value().isFalse(); }
+    bool isNumber() const { return value().isNumber(); }
+    bool isInt32() const { return value().isInt32(); }
+    bool isInt32(int32_t i32) const { return value().isInt32(i32); }
+    bool isDouble() const { return value().isDouble(); }
+    bool isString() const { return value().isString(); }
+    bool isSymbol() const { return value().isSymbol(); }
+    bool isObject() const { return value().isObject(); }
+    bool isMagic() const { return value().isMagic(); }
+    bool isMagic(JSWhyMagic why) const { return value().isMagic(why); }
+    bool isGCThing() const { return value().isGCThing(); }
+    bool isPrimitive() const { return value().isPrimitive(); }
+
+    bool isNullOrUndefined() const { return value().isNullOrUndefined(); }
+    bool isObjectOrNull() const { return value().isObjectOrNull(); }
+
+    bool toBoolean() const { return value().toBoolean(); }
+    double toNumber() const { return value().toNumber(); }
+    int32_t toInt32() const { return value().toInt32(); }
+    double toDouble() const { return value().toDouble(); }
+    JSString* toString() const { return value().toString(); }
+    JS::Symbol* toSymbol() const { return value().toSymbol(); }
+    JSObject& toObject() const { return value().toObject(); }
+    JSObject* toObjectOrNull() const { return value().toObjectOrNull(); }
+    gc::Cell* toGCThing() const { return value().toGCThing(); }
+    JS::TraceKind traceKind() const { return value().traceKind(); }
+    void* toPrivate() const { return value().toPrivate(); }
+    uint32_t toPrivateUint32() const { return value().toPrivateUint32(); }
+
+    uint64_t asRawBits() const { return value().asRawBits(); }
+    JSValueType extractNonDoubleType() const { return value().extractNonDoubleType(); }
+
+    JSWhyMagic whyMagic() const { return value().whyMagic(); }
+    uint32_t magicUint32() const { return value().magicUint32(); }
+};
+
+
+
+
+
+
+
+template <class Wrapper>
+class MutableWrappedPtrOperations<JS::Value, Wrapper> : public WrappedPtrOperations<JS::Value, Wrapper>
+{
+    JS::Value& value() { return static_cast<Wrapper*>(this)->get(); }
+
+  public:
+    void setNull() { value().setNull(); }
+    void setUndefined() { value().setUndefined(); }
+    void setInt32(int32_t i) { value().setInt32(i); }
+    void setDouble(double d) { value().setDouble(d); }
+    void setNaN() { setDouble(JS::GenericNaN()); }
+    void setBoolean(bool b) { value().setBoolean(b); }
+    void setMagic(JSWhyMagic why) { value().setMagic(why); }
+    bool setNumber(uint32_t ui) { return value().setNumber(ui); }
+    bool setNumber(double d) { return value().setNumber(d); }
+    void setString(JSString* str) { this->value().setString(str); }
+    void setSymbol(JS::Symbol* sym) { this->value().setSymbol(sym); }
+    void setObject(JSObject& obj) { this->value().setObject(obj); }
+    void setObjectOrNull(JSObject* arg) { this->value().setObjectOrNull(arg); }
+    void setPrivate(void* ptr) { this->value().setPrivate(ptr); }
+    void setPrivateUint32(uint32_t ui) { this->value().setPrivateUint32(ui); }
+    void setPrivateGCThing(js::gc::Cell* cell) { this->value().setPrivateGCThing(cell); }
+};
+
+
+
+
+
+template <typename Wrapper>
+class HeapBase<JS::Value, Wrapper> : public WrappedPtrOperations<JS::Value, Wrapper>
+{
+    void setBarriered(const JS::Value& v) {
+        *static_cast<JS::Heap<JS::Value>*>(this) = v;
+    }
+
+  public:
+    void setNull() { setBarriered(JS::NullValue()); }
+    void setUndefined() { setBarriered(JS::UndefinedValue()); }
+    void setInt32(int32_t i) { setBarriered(JS::Int32Value(i)); }
+    void setDouble(double d) { setBarriered(JS::DoubleValue(d)); }
+    void setNaN() { setDouble(JS::GenericNaN()); }
+    void setBoolean(bool b) { setBarriered(JS::BooleanValue(b)); }
+    void setMagic(JSWhyMagic why) { setBarriered(JS::MagicValue(why)); }
+    void setString(JSString* str) { setBarriered(JS::StringValue(str)); }
+    void setSymbol(JS::Symbol* sym) { setBarriered(JS::SymbolValue(sym)); }
+    void setObject(JSObject& obj) { setBarriered(JS::ObjectValue(obj)); }
+    void setPrivateGCThing(js::gc::Cell* cell) { setBarriered(JS::PrivateGCThingValue(cell)); }
+
+    bool setNumber(uint32_t ui) {
+        if (ui > ((int32_t)0x7fffffff)) {
+            setDouble((double)ui);
+            return false;
+        } else {
+            setInt32((int32_t)ui);
+            return true;
+        }
+    }
+
+    bool setNumber(double d) {
+        int32_t i;
+        if (mozilla::NumberIsInt32(d, &i)) {
+            setInt32(i);
+            return true;
+        }
+
+        setDouble(d);
+        return false;
+    }
+
+    void setObjectOrNull(JSObject* arg) {
+        if (arg)
+            setObject(*arg);
+        else
+            setNull();
+    }
+};
+
+
+
+
+
+template <typename F, typename... Args>
+auto
+DispatchTyped(F f, const JS::Value& val, Args&&... args)
+  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+{
+    if (val.isString())
+        return f(val.toString(), mozilla::Forward<Args>(args)...);
+    if (val.isObject())
+        return f(&val.toObject(), mozilla::Forward<Args>(args)...);
+    if (val.isSymbol())
+        return f(val.toSymbol(), mozilla::Forward<Args>(args)...);
+    if ((__builtin_expect(!!(val.isPrivateGCThing()), 0)))
+        return DispatchTyped(f, val.toGCCellPtr(), mozilla::Forward<Args>(args)...);
+    do { } while (0);
+    return F::defaultValue(val);
+}
+
+template <class S> struct VoidDefaultAdaptor { static void defaultValue(const S&) {} };
+template <class S> struct IdentityDefaultAdaptor { static S defaultValue(const S& v) {return v;} };
+template <class S, bool v> struct BoolDefaultAdaptor { static bool defaultValue(const S&) { return v; } };
+
+}
+# 1478 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
+namespace JS {
+
+extern const HandleValue NullHandleValue;
+extern const HandleValue UndefinedHandleValue;
+extern const HandleValue TrueHandleValue;
+extern const HandleValue FalseHandleValue;
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
+template <class T>
+class nsAutoPtr
+{
+private:
+  static_assert(!mozilla::IsScalar<T>::value, "If you are using "
+                "nsAutoPtr to hold an array, use UniquePtr<T[]> instead");
+
+  void**
+  begin_assignment()
+  {
+    assign(0);
+    return reinterpret_cast<void**>(&mRawPtr);
+  }
+
+  void
+  assign(T* aNewPtr)
+  {
+    T* oldPtr = mRawPtr;
+
+    if (aNewPtr && aNewPtr == oldPtr) {
+      do { AnnotateMozCrashReason("MOZ_CRASH(" "Logic flaw in the caller" ")"); do { *((volatile int*) __null) = 41; ::abort(); } while (0); } while (0);
+    }
+
+    mRawPtr = aNewPtr;
+    delete oldPtr;
+  }
+
+
+
+
+
+
+  class Ptr
+  {
+  public:
+                 Ptr(T* aPtr)
+      : mPtr(aPtr)
+    {
+    }
+
+    operator T*() const
+    {
+      return mPtr;
+    }
+
+  private:
+    T* mPtr;
+  };
+
+private:
+  T* mRawPtr;
+
+public:
+  typedef T element_type;
+
+  ~nsAutoPtr()
+  {
+    delete mRawPtr;
+  }
+
+
+
+  nsAutoPtr()
+    : mRawPtr(0)
+
+  {
+  }
+
+               nsAutoPtr(Ptr aRawPtr)
+    : mRawPtr(aRawPtr)
+
+  {
+  }
+
+
+
+  nsAutoPtr(nsAutoPtr<T>& aSmartPtr)
+    : mRawPtr(aSmartPtr.forget())
+
+  {
+  }
+
+  template <typename I>
+               nsAutoPtr(nsAutoPtr<I>& aSmartPtr)
+    : mRawPtr(aSmartPtr.forget())
+
+  {
+  }
+
+  nsAutoPtr(nsAutoPtr<T>&& aSmartPtr)
+    : mRawPtr(aSmartPtr.forget())
+
+  {
+  }
+
+  template <typename I>
+               nsAutoPtr(nsAutoPtr<I>&& aSmartPtr)
+    : mRawPtr(aSmartPtr.forget())
+
+  {
+  }
+
+
+
+  nsAutoPtr<T>&
+  operator=(T* aRhs)
+
+  {
+    assign(aRhs);
+    return *this;
+  }
+
+  nsAutoPtr<T>& operator=(nsAutoPtr<T>& aRhs)
+
+  {
+    assign(aRhs.forget());
+    return *this;
+  }
+
+  template <typename I>
+  nsAutoPtr<T>& operator=(nsAutoPtr<I>& aRhs)
+
+  {
+    assign(aRhs.forget());
+    return *this;
+  }
+
+  nsAutoPtr<T>& operator=(nsAutoPtr<T>&& aRhs)
+  {
+    assign(aRhs.forget());
+    return *this;
+  }
+
+  template <typename I>
+  nsAutoPtr<T>& operator=(nsAutoPtr<I>&& aRhs)
+  {
+    assign(aRhs.forget());
+    return *this;
+  }
+
+
+
+  T*
+  get() const
+
+
+
+
+
+  {
+    return mRawPtr;
+  }
+
+  operator T*() const
+# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
+  {
+    return get();
+  }
+
+  T*
+  forget()
+  {
+    T* temp = mRawPtr;
+    mRawPtr = 0;
+    return temp;
+  }
+
+  T*
+  operator->() const
+  {
+    do { } while(0);
+
+    return get();
+  }
+
+  template <typename R, typename... Args>
+  class Proxy
+  {
+    typedef R (T::*member_function)(Args...);
+    T* mRawPtr;
+    member_function mFunction;
+  public:
+    Proxy(T* aRawPtr, member_function aFunction)
+      : mRawPtr(aRawPtr),
+        mFunction(aFunction)
+    {
+    }
+    template<typename... ActualArgs>
+    R operator()(ActualArgs&&... aArgs)
+    {
+      return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
+    }
+  };
+
+  template <typename R, typename C, typename... Args>
+  Proxy<R, Args...> operator->*(R (C::*aFptr)(Args...)) const
+  {
+    do { } while(0);
+
+    return Proxy<R, Args...>(get(), aFptr);
+  }
+
+  nsAutoPtr<T>*
+  get_address()
+
+
+  {
+    return this;
+  }
+
+  const nsAutoPtr<T>*
+  get_address() const
+
+
+  {
+    return this;
+  }
+
+public:
+  T&
+  operator*() const
+  {
+    do { } while(0);
+
+    return *get();
+  }
+
+  T**
+  StartAssignment()
+  {
+
+    return reinterpret_cast<T**>(begin_assignment());
+
+
+
+
+  }
+};
+
+template <class T>
+inline nsAutoPtr<T>*
+address_of(nsAutoPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+
+template <class T>
+inline const nsAutoPtr<T>*
+address_of(const nsAutoPtr<T>& aPtr)
+{
+  return aPtr.get_address();
+}
+
+template <class T>
+class nsAutoPtrGetterTransfers
+# 301 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
+{
+public:
+  explicit
+  nsAutoPtrGetterTransfers(nsAutoPtr<T>& aSmartPtr)
+    : mTargetSmartPtr(aSmartPtr)
+  {
+
+  }
+
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
+
+  operator T**()
+  {
+    return mTargetSmartPtr.StartAssignment();
+  }
+
+  T*&
+  operator*()
+  {
+    return *(mTargetSmartPtr.StartAssignment());
+  }
+
+private:
+  nsAutoPtr<T>& mTargetSmartPtr;
+};
+
+template <class T>
+inline nsAutoPtrGetterTransfers<T>
+getter_Transfers(nsAutoPtr<T>& aSmartPtr)
+
+
+
+
+{
+  return nsAutoPtrGetterTransfers<T>(aSmartPtr);
+}
+
+
+
+
+
+template <class T, class U>
+inline bool
+operator==(const nsAutoPtr<T>& aLhs, const nsAutoPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
+}
+
+
+template <class T, class U>
+inline bool
+operator!=(const nsAutoPtr<T>& aLhs, const nsAutoPtr<U>& aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
+}
+
+
+
+
+template <class T, class U>
+inline bool
+operator==(const nsAutoPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator==(const U* aLhs, const nsAutoPtr<T>& aRhs)
+{
+  return static_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator!=(const nsAutoPtr<T>& aLhs, const U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator!=(const U* aLhs, const nsAutoPtr<T>& aRhs)
+{
+  return static_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator==(const nsAutoPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator==(U* aLhs, const nsAutoPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
+}
+
+template <class T, class U>
+inline bool
+operator!=(const nsAutoPtr<T>& aLhs, U* aRhs)
+{
+  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
+}
+
+template <class T, class U>
+inline bool
+operator!=(U* aLhs, const nsAutoPtr<T>& aRhs)
+{
+  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
+}
+
+
+
+
+
+template <class T>
+inline bool
+operator==(const nsAutoPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() == nullptr;
+}
+
+template <class T>
+inline bool
+operator==(decltype(nullptr), const nsAutoPtr<T>& aRhs)
+{
+  return nullptr == aRhs.get();
+}
+
+template <class T>
+inline bool
+operator!=(const nsAutoPtr<T>& aLhs, decltype(nullptr))
+{
+  return aLhs.get() != nullptr;
+}
+
+template <class T>
+inline bool
+operator!=(decltype(nullptr), const nsAutoPtr<T>& aRhs)
+{
+  return nullptr != aRhs.get();
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 2
+
+
+namespace mozilla {
+
+template<class T>
+class OwningNonNull
+{
+public:
+  OwningNonNull() {}
+
+               OwningNonNull(T& aValue)
+  {
+    init(&aValue);
+  }
+
+  template<class U>
+               OwningNonNull(already_AddRefed<U>&& aValue)
+  {
+    init(aValue);
+  }
+
+  template<class U>
+               OwningNonNull(const OwningNonNull<U>& aValue)
+  {
+    init(aValue);
+  }
+
+
+  operator T&() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return *mPtr;
+  }
+
+  operator T*() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mPtr;
+  }
+
+
+  explicit operator bool() const = delete;
+
+  T*
+  operator->() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mPtr;
+  }
+
+  OwningNonNull<T>&
+  operator=(T* aValue)
+  {
+    init(aValue);
+    return *this;
+  }
+
+  OwningNonNull<T>&
+  operator=(T& aValue)
+  {
+    init(&aValue);
+    return *this;
+  }
+
+  template<class U>
+  OwningNonNull<T>&
+  operator=(already_AddRefed<U>&& aValue)
+  {
+    init(aValue);
+    return *this;
+  }
+
+  template<class U>
+  OwningNonNull<T>&
+  operator=(const OwningNonNull<U>& aValue)
+  {
+    init(aValue);
+    return *this;
+  }
+
+
+  void operator=(decltype(nullptr)) = delete;
+
+  already_AddRefed<T> forget()
+  {
+
+
+
+    return mPtr.forget();
+  }
+
+  template<class U>
+  void
+  forget(U** aOther)
+  {
+
+
+
+    mPtr.forget(aOther);
+  }
+
+
+  T* get() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mPtr;
+  }
+
+  template<typename U>
+  void swap(U& aOther)
+  {
+    mPtr.swap(aOther);
+
+
+
+  }
+
+
+
+
+  bool isInitialized() const
+  {
+    do { } while (0);
+    return mPtr;
+  }
+
+protected:
+  template<typename U>
+  void init(U&& aValue)
+  {
+    mPtr = aValue;
+    do { } while (0);
+
+
+
+  }
+
+  RefPtr<T> mPtr;
+
+
+
+};
+
+template <typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            OwningNonNull<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+
+}
+
+
+template<class T> template<class U>
+nsCOMPtr<T>::nsCOMPtr(const mozilla::OwningNonNull<U>& aOther)
+  : nsCOMPtr(aOther.get())
+{}
+
+template<class T> template<class U>
+nsCOMPtr<T>&
+nsCOMPtr<T>::operator=(const mozilla::OwningNonNull<U>& aOther)
+{
+  return operator=(aOther.get());
+}
+
+
+template<class T> template<class U>
+RefPtr<T>::RefPtr(const mozilla::OwningNonNull<U>& aOther)
+  : RefPtr(aOther.get())
+{}
+
+template<class T> template<class U>
+RefPtr<T>&
+RefPtr<T>::operator=(const mozilla::OwningNonNull<U>& aOther)
+{
+  return operator=(aOther.get());
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 2
+
+
+
+namespace JS {
+template<typename T>
+struct GCPolicy<mozilla::OwningNonNull<T>>
+{
+  typedef mozilla::OwningNonNull<T> SmartPtrType;
+
+  static SmartPtrType initial()
+  {
+    return SmartPtrType();
+  }
+
+  static void trace(JSTracer* trc, SmartPtrType* tp,
+                    const char* name)
+  {
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h"
+    if ((*tp).isInitialized()) {
+      (*tp)->Trace(trc);
+    }
+  }
+};
+}
+
+namespace js {
+template<typename T, typename Wrapper>
+struct WrappedPtrOperations<mozilla::OwningNonNull<T>, Wrapper>
+{
+  operator T& () const
+  {
+    return static_cast<const Wrapper*>(this)->get();
+  }
+};
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h"
+namespace JS {
+template<typename T>
+struct GCPolicy<RefPtr<T>>
+{
+  static RefPtr<T> initial() {
+    return RefPtr<T>();
+  }
+
+  static void trace(JSTracer* trc, RefPtr<T>* tp, const char* name)
+  {
+    if (*tp) {
+      (*tp)->Trace(trc);
+    }
+  }
+};
+}
+
+namespace js {
+template<typename T, typename Wrapper>
+struct WrappedPtrOperations<RefPtr<T>, Wrapper>
+{
+  operator T*() const
+  {
+    return static_cast<const Wrapper*>(this)->get();
+  }
+};
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h"
+namespace mozilla {
+namespace dom {
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h"
+class DOMString {
+public:
+  DOMString()
+    : mStringBuffer(nullptr)
+    , mLength(0)
+    , mIsNull(false)
+    , mStringBufferOwned(false)
+  {}
+  ~DOMString()
+  {
+    do { } while (0);
+
+    if (mStringBufferOwned) {
+      do { } while (0);
+      mStringBuffer->Release();
+    }
+  }
+
+  operator nsString&()
+  {
+    return AsAString();
+  }
+
+
+
+  operator const nsString&() = delete;
+  operator const nsAString&() = delete;
+
+  nsString& AsAString()
+  {
+    do { } while (0);
+    do { } while (0);
+    if (!mString) {
+      mString.emplace();
+    }
+    return *mString;
+  }
+
+  bool HasStringBuffer() const
+  {
+    do { } while (0);
+
+    do { } while (0);
+    return !mString;
+  }
+
+
+
+
+
+
+  nsStringBuffer* StringBuffer() const
+  {
+    do { } while (0);
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+
+    return mStringBuffer;
+  }
+
+
+
+  uint32_t StringBufferLength() const
+  {
+    do { } while (0);
+    return mLength;
+  }
+
+
+
+  void RelinquishBufferOwnership()
+  {
+    do { } while (0);
+    if (mStringBufferOwned) {
+
+      mStringBufferOwned = false;
+    } else {
+
+      mStringBuffer->AddRef();
+    }
+  }
+
+
+
+
+  void SetStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength)
+  {
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    mStringBuffer = aStringBuffer;
+    mLength = aLength;
+  }
+
+
+  void SetEphemeralStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength)
+  {
+
+    SetStringBuffer(aStringBuffer, aLength);
+    aStringBuffer->AddRef();
+    mStringBufferOwned = true;
+  }
+
+  void SetOwnedString(const nsAString& aString)
+  {
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    nsStringBuffer* buf = nsStringBuffer::FromString(aString);
+    if (buf) {
+      SetStringBuffer(buf, aString.Length());
+    } else if (aString.IsVoid()) {
+      SetNull();
+    } else if (!aString.IsEmpty()) {
+      AsAString() = aString;
+    }
+  }
+
+  enum NullHandling
+  {
+    eTreatNullAsNull,
+    eTreatNullAsEmpty,
+    eNullNotExpected
+  };
+
+  void SetOwnedAtom(nsIAtom* aAtom, NullHandling aNullHandling)
+  {
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    if (aNullHandling == eNullNotExpected || aAtom) {
+      SetStringBuffer(aAtom->GetStringBuffer(), aAtom->GetLength());
+    } else if (aNullHandling == eTreatNullAsNull) {
+      SetNull();
+    }
+  }
+
+  void SetNull()
+  {
+    do { } while (0);
+    do { } while (0);
+    mIsNull = true;
+  }
+
+  bool IsNull() const
+  {
+    do { } while (0);
+
+    return mIsNull || (mString && mString->IsVoid());
+  }
+
+  void ToString(nsAString& aString)
+  {
+    if (IsNull()) {
+      SetDOMStringToNull(aString);
+    } else if (HasStringBuffer()) {
+      if (StringBufferLength() == 0) {
+        aString.Truncate();
+      } else {
+
+
+        nsStringBuffer* buf = StringBuffer();
+        uint32_t len = StringBufferLength();
+        auto chars = static_cast<char16_t*>(buf->Data());
+        if (chars[len] == '\0') {
+
+          buf->ToString(len, aString);
+        } else {
+
+          aString.Assign(chars, len);
+        }
+      }
+    } else {
+      aString = AsAString();
+    }
+  }
+
+private:
+
+  Maybe<nsAutoString> mString;
+
+
+
+  nsStringBuffer* mStringBuffer;
+
+
+  uint32_t mLength;
+  bool mIsNull;
+  bool mStringBufferOwned;
+};
+
+}
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
+
+
+
+
+
+class nsIPrincipal;
+class nsWrapperCache;
+
+namespace mozilla {
+namespace dom {
+
+
+
+struct DictionaryBase
+{
+protected:
+  bool ParseJSON(JSContext* aCx, const nsAString& aJSON,
+                 JS::MutableHandle<JS::Value> aVal);
+
+  bool StringifyToJSON(JSContext* aCx,
+                       JS::Handle<JSObject*> aObj,
+                       nsAString& aJSON) const;
+
+
+
+
+
+  struct FastDictionaryInitializer {
+  };
+
+  bool mIsAnyMemberPresent = false;
+
+private:
+
+
+  static bool AppendJSONToString(const char16_t* aJSONData,
+                                 uint32_t aDataLength, void* aString);
+
+public:
+  bool IsAnyMemberPresent() const
+  {
+    return mIsAnyMemberPresent;
+  }
+};
+
+
+
+
+struct AllTypedArraysBase {
+};
+
+
+
+
+struct AllOwningUnionBase {
+};
+
+
+struct EnumEntry {
+  const char* value;
+  size_t length;
+};
+
+enum class CallerType : uint32_t;
+
+class GlobalObject
+{
+public:
+  GlobalObject(JSContext* aCx, JSObject* aObject);
+
+  JSObject* Get() const
+  {
+    return mGlobalJSObject;
+  }
+
+  nsISupports* GetAsSupports() const;
+
+
+
+
+  JSContext* Context() const
+  {
+    return mCx;
+  }
+
+  bool Failed() const
+  {
+    return !Get();
+  }
+
+
+
+  nsIPrincipal* GetSubjectPrincipal() const;
+
+
+
+  dom::CallerType CallerType() const;
+
+protected:
+  JS::Rooted<JSObject*> mGlobalJSObject;
+  JSContext* mCx;
+  mutable nsISupports* mGlobalObject;
+
+
+
+};
+
+
+template<typename T, typename InternalType>
+class Optional_base
+{
+public:
+  Optional_base()
+  {}
+
+  explicit Optional_base(const T& aValue)
+  {
+    mImpl.emplace(aValue);
+  }
+
+  bool operator==(const Optional_base<T, InternalType>& aOther) const
+  {
+    return mImpl == aOther.mImpl;
+  }
+
+  template<typename T1, typename T2>
+  explicit Optional_base(const T1& aValue1, const T2& aValue2)
+  {
+    mImpl.emplace(aValue1, aValue2);
+  }
+
+  bool WasPassed() const
+  {
+    return mImpl.isSome();
+  }
+
+
+  template<typename... Args>
+  InternalType& Construct(Args&&... aArgs)
+  {
+    mImpl.emplace(Forward<Args>(aArgs)...);
+    return *mImpl;
+  }
+
+  void Reset()
+  {
+    mImpl.reset();
+  }
+
+  const T& Value() const
+  {
+    return *mImpl;
+  }
+
+
+  InternalType& Value()
+  {
+    return *mImpl;
+  }
+
+
+  const InternalType& InternalValue() const
+  {
+    return *mImpl;
+  }
+
+
+
+
+
+private:
+
+  Optional_base(const Optional_base& other) = delete;
+  const Optional_base &operator=(const Optional_base &other) = delete;
+
+protected:
+  Maybe<InternalType> mImpl;
+};
+
+template<typename T>
+class Optional : public Optional_base<T, T>
+{
+public:
+  Optional() :
+    Optional_base<T, T>()
+  {}
+
+  explicit Optional(const T& aValue) :
+    Optional_base<T, T>(aValue)
+  {}
+};
+
+template<typename T>
+class Optional<JS::Handle<T> > :
+  public Optional_base<JS::Handle<T>, JS::Rooted<T> >
+{
+public:
+  Optional() :
+    Optional_base<JS::Handle<T>, JS::Rooted<T> >()
+  {}
+
+  explicit Optional(JSContext* cx) :
+    Optional_base<JS::Handle<T>, JS::Rooted<T> >()
+  {
+    this->Construct(cx);
+  }
+
+  Optional(JSContext* cx, const T& aValue) :
+    Optional_base<JS::Handle<T>, JS::Rooted<T> >(cx, aValue)
+  {}
+
+
+
+  JS::Handle<T> Value() const
+  {
+    return *this->mImpl;
+  }
+
+
+
+  JS::Rooted<T>& Value()
+  {
+    return *this->mImpl;
+  }
+};
+
+
+
+
+template<>
+class Optional<JSObject*> : public Optional_base<JSObject*, JSObject*>
+{
+public:
+  Optional() :
+    Optional_base<JSObject*, JSObject*>()
+  {}
+
+  explicit Optional(JSObject* aValue) :
+    Optional_base<JSObject*, JSObject*>(aValue)
+  {}
+
+
+  JSObject*& Construct()
+  {
+
+
+    return Optional_base<JSObject*, JSObject*>::Construct(
+      static_cast<JSObject*>(nullptr));
+  }
+
+  template <class T1>
+  JSObject*& Construct(const T1& t1)
+  {
+    return Optional_base<JSObject*, JSObject*>::Construct(t1);
+  }
+};
+
+
+template<>
+class Optional<JS::Value>
+{
+private:
+  Optional() = delete;
+
+  explicit Optional(const JS::Value& aValue) = delete;
+};
+
+
+template<typename U> class NonNull;
+template<typename T>
+class Optional<NonNull<T> > : public Optional_base<T, NonNull<T> >
+{
+public:
+
+
+
+  T& Value() const
+  {
+    return *this->mImpl->get();
+  }
+
+
+
+  NonNull<T>& Value()
+  {
+    return *this->mImpl;
+  }
+};
+
+
+
+template<typename T>
+class Optional<OwningNonNull<T> > : public Optional_base<T, OwningNonNull<T> >
+{
+public:
+
+
+
+  T& Value() const
+  {
+    return *this->mImpl->get();
+  }
+
+
+
+  OwningNonNull<T>& Value()
+  {
+    return *this->mImpl;
+  }
+};
+
+
+
+
+
+
+namespace binding_detail {
+struct FakeString;
+}
+
+template<>
+class Optional<nsAString>
+{
+public:
+  Optional() : mPassed(false) {}
+
+  bool WasPassed() const
+  {
+    return mPassed;
+  }
+
+  void operator=(const nsAString* str)
+  {
+    do { } while (0);
+    mStr = str;
+    mPassed = true;
+  }
+
+
+
+  void operator=(const binding_detail::FakeString* str)
+  {
+    do { } while (0);
+    mStr = reinterpret_cast<const nsString*>(str);
+    mPassed = true;
+  }
+
+  const nsAString& Value() const
+  {
+    do { } while (0);
+    return *mStr;
+  }
+
+private:
+
+  Optional(const Optional& other) = delete;
+  const Optional &operator=(const Optional &other) = delete;
+
+  bool mPassed;
+  const nsAString* mStr;
+};
+
+template<class T>
+class NonNull
+{
+public:
+  NonNull()
+
+
+
+  {}
+
+
+  operator T&() const {
+    do { } while (0);
+    do { } while (0);
+    return *ptr;
+  }
+
+  operator T*() const {
+    do { } while (0);
+    do { } while (0);
+    return ptr;
+  }
+
+  void operator=(T* t) {
+    ptr = t;
+    do { } while (0);
+
+
+
+  }
+
+  template<typename U>
+  void operator=(U* t) {
+    ptr = t->ToAStringPtr();
+    do { } while (0);
+
+
+
+  }
+
+  T** Slot() {
+
+
+
+    return &ptr;
+  }
+
+  T* Ptr() {
+    do { } while (0);
+    do { } while (0);
+    return ptr;
+  }
+
+
+  T* get() const {
+    do { } while (0);
+    do { } while (0);
+    return ptr;
+  }
+
+protected:
+  T* ptr;
+
+
+
+};
+
+
+
+
+
+template<typename T>
+class Sequence : public FallibleTArray<T>
+{
+public:
+  Sequence() : FallibleTArray<T>()
+  {}
+};
+
+inline nsWrapperCache*
+GetWrapperCache(nsWrapperCache* cache)
+{
+  return cache;
+}
+
+inline nsWrapperCache*
+GetWrapperCache(void* p)
+{
+  return nullptr;
+}
+
+
+
+template <template <typename> class SmartPtr, typename T>
+inline nsWrapperCache*
+GetWrapperCache(const SmartPtr<T>& aObject)
+{
+  return GetWrapperCache(aObject.get());
+}
+
+struct ParentObject {
+  template<class T>
+               ParentObject(T* aObject) :
+    mObject(aObject),
+    mWrapperCache(GetWrapperCache(aObject)),
+    mUseXBLScope(false)
+  {}
+
+  template<class T, template<typename> class SmartPtr>
+               ParentObject(const SmartPtr<T>& aObject) :
+    mObject(aObject.get()),
+    mWrapperCache(GetWrapperCache(aObject.get())),
+    mUseXBLScope(false)
+  {}
+
+  ParentObject(nsISupports* aObject, nsWrapperCache* aCache) :
+    mObject(aObject),
+    mWrapperCache(aCache),
+    mUseXBLScope(false)
+  {}
+
+
+
+  nsISupports* const mObject;
+  nsWrapperCache* const mWrapperCache;
+  bool mUseXBLScope;
+};
+
+namespace binding_detail {
+
+
+template<typename T>
+class AutoSequence : public AutoTArray<T, 16>
+{
+public:
+  AutoSequence() : AutoTArray<T, 16>()
+  {}
+
+
+  operator const Sequence<T>&() const {
+    return *reinterpret_cast<const Sequence<T>*>(this);
+  }
+};
+
+}
+
+
+enum class CallerType : uint32_t {
+  System,
+  NonSystem
+};
+
+
+
+
+class SystemCallerGuarantee {
+public:
+  operator CallerType() const { return CallerType::System; }
+};
+
+}
+}
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h"
+namespace mozilla {
+
+namespace detail {
+
+template<size_t EnumSize, bool EnumSigned, size_t StorageSize, bool StorageSigned>
+struct EnumFitsWithinHelper;
+
+
+template<size_t EnumSize, size_t StorageSize>
+struct EnumFitsWithinHelper<EnumSize, true, StorageSize, true>
+  : public std::integral_constant<bool, (EnumSize <= StorageSize)>
+{};
+
+
+template<size_t EnumSize, size_t StorageSize>
+struct EnumFitsWithinHelper<EnumSize, true, StorageSize, false>
+  : public std::integral_constant<bool, false>
+{};
+
+
+template<size_t EnumSize, size_t StorageSize>
+struct EnumFitsWithinHelper<EnumSize, false, StorageSize, true>
+  : public std::integral_constant<bool, (EnumSize * 2 <= StorageSize)>
+{};
+
+
+template<size_t EnumSize, size_t StorageSize>
+struct EnumFitsWithinHelper<EnumSize, false, StorageSize, false>
+  : public std::integral_constant<bool, (EnumSize <= StorageSize)>
+{};
+
+}
+# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h"
+template<typename T, typename Storage>
+struct EnumTypeFitsWithin
+  : public detail::EnumFitsWithinHelper<
+      sizeof(T),
+      std::is_signed<typename std::underlying_type<T>::type>::value,
+      sizeof(Storage),
+      std::is_signed<Storage>::value
+    >
+{
+  static_assert(std::is_enum<T>::value, "must provide an enum type");
+  static_assert(std::is_integral<Storage>::value, "must provide an integral type");
+};
+
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
+
+
+
+
+class nsAString;
+class nsIDocument;
+class nsStyledElement;
+struct MiscContainer;
+
+namespace mozilla {
+class DeclarationBlock;
+namespace css {
+struct URLValue;
+struct ImageValue;
+}
+}
+# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+class nsCheapString : public nsString {
+public:
+  explicit nsCheapString(nsStringBuffer* aBuf)
+  {
+    if (aBuf)
+      aBuf->ToString(aBuf->StorageSize()/sizeof(char16_t) - 1, *this);
+  }
+};
+
+class nsAttrValue {
+  friend struct MiscContainer;
+public:
+  typedef nsTArray< nsCOMPtr<nsIAtom> > AtomArray;
+
+
+  enum ValueType {
+    eString = 0x00,
+
+    eAtom = 0x02,
+    eInteger = 0x03,
+    eColor = 0x07,
+    eEnum = 0x0B,
+    ePercent = 0x0F,
+
+
+    eCSSDeclaration = 0x10,
+    eURL,
+    eImage,
+    eAtomArray,
+    eDoubleValue,
+    eIntMarginValue,
+    eSVGAngle,
+    eSVGTypesBegin = eSVGAngle,
+    eSVGIntegerPair,
+    eSVGLength,
+    eSVGLengthList,
+    eSVGNumberList,
+    eSVGNumberPair,
+    eSVGPathData,
+    eSVGPointList,
+    eSVGPreserveAspectRatio,
+    eSVGStringList,
+    eSVGTransformList,
+    eSVGViewBox,
+    eSVGTypesEnd = eSVGViewBox,
+  };
+
+  nsAttrValue();
+  nsAttrValue(const nsAttrValue& aOther);
+  explicit nsAttrValue(const nsAString& aValue);
+  explicit nsAttrValue(nsIAtom* aValue);
+  nsAttrValue(already_AddRefed<mozilla::DeclarationBlock> aValue,
+              const nsAString* aSerialized);
+  explicit nsAttrValue(const nsIntMargin& aValue);
+  ~nsAttrValue();
+
+  inline const nsAttrValue& operator=(const nsAttrValue& aOther);
+
+  static nsresult Init();
+  static void Shutdown();
+
+  ValueType Type() const;
+
+
+
+
+
+  inline bool StoresOwnData() const;
+
+  void Reset();
+
+  void SetTo(const nsAttrValue& aOther);
+  void SetTo(const nsAString& aValue);
+  void SetTo(nsIAtom* aValue);
+  void SetTo(int16_t aInt);
+  void SetTo(int32_t aInt, const nsAString* aSerialized);
+  void SetTo(double aValue, const nsAString* aSerialized);
+  void SetTo(already_AddRefed<mozilla::DeclarationBlock> aValue,
+             const nsAString* aSerialized);
+  void SetTo(mozilla::css::URLValue* aValue, const nsAString* aSerialized);
+  void SetTo(const nsIntMargin& aValue);
+  void SetTo(const nsSVGAngle& aValue, const nsAString* aSerialized);
+  void SetTo(const nsSVGIntegerPair& aValue, const nsAString* aSerialized);
+  void SetTo(const nsSVGLength2& aValue, const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGLengthList& aValue,
+             const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGNumberList& aValue,
+             const nsAString* aSerialized);
+  void SetTo(const nsSVGNumberPair& aValue, const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGPathData& aValue, const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGPointList& aValue, const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGAnimatedPreserveAspectRatio& aValue,
+             const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGStringList& aValue,
+             const nsAString* aSerialized);
+  void SetTo(const mozilla::SVGTransformList& aValue,
+             const nsAString* aSerialized);
+  void SetTo(const nsSVGViewBox& aValue, const nsAString* aSerialized);
+# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  void SetToSerialized(const nsAttrValue& aValue);
+
+  void SwapValueWith(nsAttrValue& aOther);
+
+  void ToString(nsAString& aResult) const;
+  inline void ToString(mozilla::dom::DOMString& aResult) const;
+
+
+
+
+
+  already_AddRefed<nsIAtom> GetAsAtom() const;
+
+
+
+  inline bool IsEmptyString() const;
+  const nsCheapString GetStringValue() const;
+  inline nsIAtom* GetAtomValue() const;
+  inline int32_t GetIntegerValue() const;
+  bool GetColorValue(nscolor& aColor) const;
+  inline int16_t GetEnumValue() const;
+  inline float GetPercentValue() const;
+  inline AtomArray* GetAtomArrayValue() const;
+  inline mozilla::DeclarationBlock* GetCSSDeclarationValue() const;
+  inline mozilla::css::URLValue* GetURLValue() const;
+  inline mozilla::css::ImageValue* GetImageValue() const;
+  inline double GetDoubleValue() const;
+  bool GetIntMarginValue(nsIntMargin& aMargin) const;
+
+
+
+
+
+
+
+  void GetEnumString(nsAString& aResult, bool aRealTag) const;
+
+
+
+
+  uint32_t GetAtomCount() const;
+
+
+  nsIAtom* AtomAt(int32_t aIndex) const;
+
+  uint32_t HashValue() const;
+  bool Equals(const nsAttrValue& aOther) const;
+
+  bool Equals(const nsAString& aValue, nsCaseTreatment aCaseSensitive) const;
+  bool Equals(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const;
+# 239 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool EqualsAsStrings(const nsAttrValue& aOther) const;
+
+
+
+
+
+  bool Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const;
+
+
+
+
+
+  bool Contains(const nsAString& aValue) const;
+
+  void ParseAtom(const nsAString& aValue);
+  void ParseAtomArray(const nsAString& aValue);
+  void ParseStringOrAtom(const nsAString& aValue);
+# 267 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  struct EnumTable {
+
+
+
+    constexpr EnumTable(const char* aTag, int16_t aValue)
+      : tag(aTag)
+      , value(aValue)
+    {
+    }
+
+    template<typename T,
+             typename = typename std::enable_if<std::is_enum<T>::value>::type>
+    constexpr EnumTable(const char* aTag, T aValue)
+      : tag(aTag)
+      , value(static_cast<int16_t>(aValue))
+    {
+      static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+                    "aValue must be an enum that fits within int16_t");
+    }
+
+
+    const char* tag;
+
+    int16_t value;
+  };
+# 304 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseEnumValue(const nsAString& aValue,
+                        const EnumTable* aTable,
+                        bool aCaseSensitive,
+                        const EnumTable* aDefaultValue = nullptr);
+# 319 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseSpecialIntValue(const nsAString& aString);
+# 328 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseIntValue(const nsAString& aString) {
+    return ParseIntWithBounds(aString, (-2147483647-1), (2147483647));
+  }
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseIntWithBounds(const nsAString& aString, int32_t aMin,
+                            int32_t aMax = (2147483647));
+# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  void ParseIntWithFallback(const nsAString& aString, int32_t aDefault,
+                            int32_t aMax = (2147483647));
+# 363 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseNonNegativeIntValue(const nsAString& aString);
+# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParsePositiveIntValue(const nsAString& aString);
+# 387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseColor(const nsAString& aString);
+
+
+
+
+
+
+
+  bool ParseDoubleValue(const nsAString& aString);
+
+
+
+
+
+  bool ParseLazyURIValue(const nsAString& aString);
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  bool ParseIntMarginValue(const nsAString& aString);
+
+
+
+
+
+
+  void LoadImage(nsIDocument* aDocument);
+
+
+
+
+
+
+
+  bool ParseStyleAttribute(const nsAString& aString,
+                           nsStyledElement* aElement);
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  enum ValueBaseType {
+    eStringBase = eString,
+    eOtherBase = 0x01,
+    eAtomBase = eAtom,
+    eIntegerBase = 0x03
+  };
+
+  inline ValueBaseType BaseType() const;
+  inline bool IsSVGType(ValueType aType) const;
+# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
+  int16_t GetEnumTableIndex(const EnumTable* aTable);
+
+  inline void SetPtrValueAndType(void* aValue, ValueBaseType aType);
+  void SetIntValueAndType(int32_t aValue, ValueType aType,
+                          const nsAString* aStringValue);
+  void SetColorValue(nscolor aColor, const nsAString& aString);
+  void SetMiscAtomOrString(const nsAString* aValue);
+  void ResetMiscAtomOrString();
+  void SetSVGType(ValueType aType, const void* aValue,
+                  const nsAString* aSerialized);
+  inline void ResetIfSet();
+
+  inline void* GetPtr() const;
+  inline MiscContainer* GetMiscContainer() const;
+  inline int32_t GetIntInternal() const;
+
+
+
+  MiscContainer* ClearMiscContainer();
+
+
+  MiscContainer* EnsureEmptyMiscContainer();
+  bool EnsureEmptyAtomArray();
+  already_AddRefed<nsStringBuffer>
+    GetStringBuffer(const nsAString& aValue) const;
+
+
+  int32_t EnumTableEntryToValue(const EnumTable* aEnumTable,
+                                const EnumTable* aTableEntry);
+
+  static nsTArray<const EnumTable*>* sEnumTableArray;
+
+  uintptr_t mBits;
+};
+
+inline const nsAttrValue&
+nsAttrValue::operator=(const nsAttrValue& aOther)
+{
+  SetTo(aOther);
+  return *this;
+}
+
+inline nsIAtom*
+nsAttrValue::GetAtomValue() const
+{
+  do { } while(0);
+  return reinterpret_cast<nsIAtom*>(GetPtr());
+}
+
+inline nsAttrValue::ValueBaseType
+nsAttrValue::BaseType() const
+{
+  return static_cast<ValueBaseType>(mBits & (uintptr_t(3)));
+}
+
+inline void*
+nsAttrValue::GetPtr() const
+{
+  do { } while(0);
+
+  return reinterpret_cast<void*>(mBits & (~(uintptr_t(3))));
+}
+
+inline bool
+nsAttrValue::IsEmptyString() const
+{
+  return !mBits;
+}
+
+inline void
+nsAttrValue::ToString(mozilla::dom::DOMString& aResult) const
+{
+  switch (Type()) {
+    case eString:
+    {
+      nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
+      if (str) {
+        aResult.SetStringBuffer(str, str->StorageSize()/sizeof(char16_t) - 1);
+      }
+
+      return;
+    }
+    case eAtom:
+    {
+      nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
+      aResult.SetStringBuffer(atom->GetStringBuffer(), atom->GetLength());
+      break;
+    }
+    default:
+    {
+      ToString(aResult.AsAString());
+    }
+  }
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+struct nsCSSSelector;
+
+
+
+enum nsChangeHint {
+  nsChangeHint_Empty = 0,
+
+
+
+
+  nsChangeHint_RepaintFrame = 1 << 0,
+
+
+
+  nsChangeHint_NeedReflow = 1 << 1,
+
+
+
+  nsChangeHint_ClearAncestorIntrinsics = 1 << 2,
+
+
+
+
+  nsChangeHint_ClearDescendantIntrinsics = 1 << 3,
+
+
+
+
+  nsChangeHint_NeedDirtyReflow = 1 << 4,
+
+
+
+  nsChangeHint_SyncFrameView = 1 << 5,
+
+
+  nsChangeHint_UpdateCursor = 1 << 6,
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_UpdateEffects = 1 << 7,
+
+
+
+
+
+
+  nsChangeHint_UpdateOpacityLayer = 1 << 8,
+
+
+
+
+  nsChangeHint_UpdateTransformLayer = 1 << 9,
+# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_ReconstructFrame = 1 << 10,
+
+
+
+
+
+  nsChangeHint_UpdateOverflow = 1 << 11,
+
+
+
+
+
+  nsChangeHint_UpdateSubtreeOverflow = 1 << 12,
+# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_UpdatePostTransformOverflow = 1 << 13,
+
+
+
+
+
+
+
+  nsChangeHint_UpdateParentOverflow = 1 << 14,
+
+
+
+
+
+  nsChangeHint_ChildrenOnlyTransform = 1 << 15,
+# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_RecomputePosition = 1 << 16,
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_UpdateContainingBlock = 1 << 17,
+
+
+
+
+
+
+
+  nsChangeHint_BorderStyleNoneChange = 1 << 18,
+
+
+
+
+
+  nsChangeHint_UpdateTextPath = 1 << 19,
+
+
+
+
+
+  nsChangeHint_SchedulePaint = 1 << 20,
+# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_NeutralChange = 1 << 21,
+
+
+
+
+  nsChangeHint_InvalidateRenderingObservers = 1 << 22,
+
+
+
+
+
+
+
+  nsChangeHint_ReflowChangesSizeOrPosition = 1 << 23,
+
+
+
+
+
+  nsChangeHint_UpdateComputedBSize = 1 << 24,
+# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_UpdateUsesOpacity = 1 << 25,
+# 217 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_UpdateBackgroundPosition = 1 << 26,
+
+
+
+
+
+  nsChangeHint_AddOrRemoveTransform = 1 << 27,
+# 240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  nsChangeHint_AllHints = (1 << 28) - 1,
+};
+
+
+
+
+inline void operator<(nsChangeHint s1, nsChangeHint s2) {}
+inline void operator>(nsChangeHint s1, nsChangeHint s2) {}
+inline void operator!=(nsChangeHint s1, nsChangeHint s2) {}
+inline void operator==(nsChangeHint s1, nsChangeHint s2) {}
+inline void operator<=(nsChangeHint s1, nsChangeHint s2) {}
+inline void operator>=(nsChangeHint s1, nsChangeHint s2) {}
+
+
+
+
+inline bool NS_IsHintSubset(nsChangeHint aSubset, nsChangeHint aSuperSet) {
+  return (aSubset & aSuperSet) == aSubset;
+}
+
+
+
+typedef decltype(nsChangeHint(0) + nsChangeHint(0)) nsChangeHint_size_t;
+
+inline nsChangeHint constexpr
+operator|(nsChangeHint aLeft, nsChangeHint aRight)
+{
+  return nsChangeHint(nsChangeHint_size_t(aLeft) | nsChangeHint_size_t(aRight));
+}
+
+inline nsChangeHint constexpr
+operator&(nsChangeHint aLeft, nsChangeHint aRight)
+{
+  return nsChangeHint(nsChangeHint_size_t(aLeft) & nsChangeHint_size_t(aRight));
+}
+
+inline nsChangeHint& operator|=(nsChangeHint& aLeft, nsChangeHint aRight)
+{
+  return aLeft = aLeft | aRight;
+}
+
+inline nsChangeHint& operator&=(nsChangeHint& aLeft, nsChangeHint aRight)
+{
+  return aLeft = aLeft & aRight;
+}
+
+inline nsChangeHint constexpr
+operator~(nsChangeHint aArg)
+{
+  return nsChangeHint(~nsChangeHint_size_t(aArg));
+}
+
+inline nsChangeHint constexpr
+operator^(nsChangeHint aLeft, nsChangeHint aRight)
+{
+  return nsChangeHint(nsChangeHint_size_t(aLeft) ^ nsChangeHint_size_t(aRight));
+}
+
+inline nsChangeHint operator^=(nsChangeHint& aLeft, nsChangeHint aRight)
+{
+  return aLeft = aLeft ^ aRight;
+}
+# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+static_assert(!(( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) &
+                ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform )) &&
+              !(( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) &
+                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )) &&
+              !(( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform ) &
+                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )) &&
+              !(nsChangeHint_AllHints ^
+                ( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) ^
+                ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform ) ^
+                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )),
+              "change hints must be present in exactly one of "
+              "nsChangeHint_Hints_{Always,Never,Sometimes}"
+              "HandledForDescendants");
+# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+inline nsChangeHint NS_HintsNotHandledForDescendantsIn(nsChangeHint aChangeHint) {
+  nsChangeHint result =
+    aChangeHint & ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform );
+
+  if (!NS_IsHintSubset(nsChangeHint_NeedDirtyReflow, aChangeHint)) {
+    if (NS_IsHintSubset(nsChangeHint_NeedReflow, aChangeHint)) {
+
+
+      result |= nsChangeHint_NeedReflow;
+    }
+
+    if (NS_IsHintSubset(nsChangeHint_ReflowChangesSizeOrPosition,
+                        aChangeHint)) {
+
+
+      result |= nsChangeHint_ReflowChangesSizeOrPosition;
+    }
+  }
+
+  if (!NS_IsHintSubset(nsChangeHint_ClearDescendantIntrinsics, aChangeHint) &&
+      NS_IsHintSubset(nsChangeHint_ClearAncestorIntrinsics, aChangeHint)) {
+
+
+    result |= nsChangeHint_ClearAncestorIntrinsics;
+  }
+
+  do { } while (0);
+
+
+
+  return result;
+}
+
+inline nsChangeHint
+NS_HintsHandledForDescendantsIn(nsChangeHint aChangeHint)
+{
+  return aChangeHint & ~NS_HintsNotHandledForDescendantsIn(aChangeHint);
+}
+
+
+
+inline nsChangeHint
+NS_RemoveSubsumedHints(nsChangeHint aOurChange, nsChangeHint aHintsHandled)
+{
+  nsChangeHint result =
+    aOurChange & ~NS_HintsHandledForDescendantsIn(aHintsHandled);
+
+  if (result & (nsChangeHint_ClearAncestorIntrinsics |
+                nsChangeHint_ClearDescendantIntrinsics |
+                nsChangeHint_NeedDirtyReflow |
+                nsChangeHint_ReflowChangesSizeOrPosition |
+                nsChangeHint_UpdateComputedBSize)) {
+    result |= nsChangeHint_NeedReflow;
+  }
+
+  if (result & (nsChangeHint_ClearDescendantIntrinsics)) {
+    do { } while (0);
+    result |=
+              nsChangeHint_NeedDirtyReflow;
+  }
+
+  return result;
+}
+# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+enum nsRestyleHint {
+
+
+
+
+  eRestyle_Self = 1 << 0,
+
+
+
+  eRestyle_SomeDescendants = 1 << 1,
+
+
+
+
+
+  eRestyle_Subtree = 1 << 2,
+
+
+
+  eRestyle_LaterSiblings = 1 << 3,
+
+
+
+
+
+
+  eRestyle_CSSTransitions = 1 << 4,
+
+
+
+
+
+
+  eRestyle_CSSAnimations = 1 << 5,
+# 519 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
+  eRestyle_StyleAttribute = 1 << 6,
+
+
+
+  eRestyle_StyleAttribute_Animations = 1 << 7,
+
+
+
+  eRestyle_Force = 1 << 8,
+
+
+
+
+
+
+  eRestyle_ForceDescendants = 1 << 9,
+
+
+  eRestyle_AllHintsWithAnimations = eRestyle_CSSTransitions |
+                                    eRestyle_CSSAnimations |
+                                    eRestyle_StyleAttribute_Animations,
+};
+
+
+
+typedef decltype(nsRestyleHint(0) + nsRestyleHint(0)) nsRestyleHint_size_t;
+
+inline constexpr nsRestyleHint operator|(nsRestyleHint aLeft,
+                                             nsRestyleHint aRight)
+{
+  return nsRestyleHint(nsRestyleHint_size_t(aLeft) |
+                       nsRestyleHint_size_t(aRight));
+}
+
+inline constexpr nsRestyleHint operator&(nsRestyleHint aLeft,
+                                             nsRestyleHint aRight)
+{
+  return nsRestyleHint(nsRestyleHint_size_t(aLeft) &
+                       nsRestyleHint_size_t(aRight));
+}
+
+inline nsRestyleHint& operator|=(nsRestyleHint& aLeft, nsRestyleHint aRight)
+{
+  return aLeft = aLeft | aRight;
+}
+
+inline nsRestyleHint& operator&=(nsRestyleHint& aLeft, nsRestyleHint aRight)
+{
+  return aLeft = aLeft & aRight;
+}
+
+inline constexpr nsRestyleHint operator~(nsRestyleHint aArg)
+{
+  return nsRestyleHint(~nsRestyleHint_size_t(aArg));
+}
+
+inline constexpr nsRestyleHint operator^(nsRestyleHint aLeft,
+                                             nsRestyleHint aRight)
+{
+  return nsRestyleHint(nsRestyleHint_size_t(aLeft) ^
+                       nsRestyleHint_size_t(aRight));
+}
+
+inline nsRestyleHint operator^=(nsRestyleHint& aLeft, nsRestyleHint aRight)
+{
+  return aLeft = aLeft ^ aRight;
+}
+
+namespace mozilla {
+
+
+
+
+
+struct RestyleHintData
+{
+
+
+  nsTArray<nsCSSSelector*> mSelectorsForDescendants;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
+
+
+namespace mozilla {
+
+namespace dom {
+class Element;
+}
+
+
+
+
+
+
+struct ServoAttrSnapshot
+{
+  nsAttrName mName;
+  nsAttrValue mValue;
+
+  ServoAttrSnapshot(const nsAttrName& aName, const nsAttrValue& aValue)
+    : mName(aName)
+    , mValue(aValue)
+  {
+  }
+};
+
+
+
+
+
+enum class ServoElementSnapshotFlags : uint8_t
+{
+  State = 1 << 0,
+  Attributes = 1 << 1,
+  All = State | Attributes
+};
+
+inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator |(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) | U(b))); } inline ServoElementSnapshotFlags& operator |=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator &(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) & U(b))); } inline ServoElementSnapshotFlags& operator &=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator ^(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) ^ U(b))); } inline ServoElementSnapshotFlags& operator ^=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator~(ServoElementSnapshotFlags a) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(~(U(a)))); }
+# 61 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h"
+class ServoElementSnapshot
+{
+  typedef dom::BorrowedAttrInfo BorrowedAttrInfo;
+  typedef dom::Element Element;
+  typedef EventStates::ServoType ServoStateType;
+
+public:
+  typedef ServoElementSnapshotFlags Flags;
+
+  explicit ServoElementSnapshot(const Element* aElement);
+  ~ServoElementSnapshot();
+
+  bool HasAttrs() { return HasAny(Flags::Attributes); }
+
+  bool HasState() { return HasAny(Flags::State); }
+
+
+
+
+  void AddState(EventStates aState)
+  {
+    if (!HasAny(Flags::State)) {
+      mState = aState.ServoValue();
+      mContains |= Flags::State;
+    }
+  }
+
+
+
+
+  void AddAttrs(Element* aElement);
+
+
+
+
+  BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const
+  {
+    if (aIndex >= mAttrs.Length()) {
+      return BorrowedAttrInfo(nullptr, nullptr);
+    }
+    return BorrowedAttrInfo(&mAttrs[aIndex].mName, &mAttrs[aIndex].mValue);
+  }
+
+  const nsAttrValue* GetParsedAttr(nsIAtom* aLocalName) const
+  {
+    return GetParsedAttr(aLocalName, kNameSpaceID_None);
+  }
+
+  const nsAttrValue* GetParsedAttr(nsIAtom* aLocalName,
+                                   int32_t aNamespaceID) const
+  {
+    uint32_t i, len = mAttrs.Length();
+    if (aNamespaceID == kNameSpaceID_None) {
+
+      for (i = 0; i < len; ++i) {
+        if (mAttrs[i].mName.Equals(aLocalName)) {
+          return &mAttrs[i].mValue;
+        }
+      }
+
+      return nullptr;
+    }
+
+    for (i = 0; i < len; ++i) {
+      if (mAttrs[i].mName.Equals(aLocalName, aNamespaceID)) {
+        return &mAttrs[i].mValue;
+      }
+    }
+
+    return nullptr;
+  }
+
+  bool IsInChromeDocument() const
+  {
+    return mIsInChromeDocument;
+  }
+
+  bool HasAny(Flags aFlags) { return bool(mContains & aFlags); }
+
+private:
+
+
+
+
+  Flags mContains;
+  nsTArray<ServoAttrSnapshot> mAttrs;
+  ServoStateType mState;
+  bool mIsHTMLElementInHTMLDocument;
+  bool mIsInChromeDocument;
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h"
+namespace mozilla {
+namespace css {
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h"
+enum SheetParsingMode {
+  eAuthorSheetFeatures = 0,
+  eUserSheetFeatures,
+  eAgentSheetFeatures
+};
+
+}
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h"
+class nsINode;
+class nsIContent;
+class nsMappedAttributes;
+class nsHTMLStyleSheet;
+class nsRuleWalker;
+class nsMappedAttributeElement;
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h"
+class nsAttrAndChildArray
+{
+  typedef mozilla::dom::BorrowedAttrInfo BorrowedAttrInfo;
+public:
+  nsAttrAndChildArray();
+  ~nsAttrAndChildArray();
+
+  uint32_t ChildCount() const
+  {
+    return mImpl ? (mImpl->mAttrAndChildCount >> 10) : 0;
+  }
+  nsIContent* ChildAt(uint32_t aPos) const
+  {
+    do { } while(0);
+    return reinterpret_cast<nsIContent*>(mImpl->mBuffer[AttrSlotsSize() + aPos]);
+  }
+  nsIContent* GetSafeChildAt(uint32_t aPos) const;
+  nsIContent * const * GetChildArray(uint32_t* aChildCount) const;
+  nsresult AppendChild(nsIContent* aChild)
+  {
+    return InsertChildAt(aChild, ChildCount());
+  }
+  nsresult InsertChildAt(nsIContent* aChild, uint32_t aPos);
+  void RemoveChildAt(uint32_t aPos);
+
+
+  already_AddRefed<nsIContent> TakeChildAt(uint32_t aPos);
+  int32_t IndexOfChild(const nsINode* aPossibleChild) const;
+
+  bool HasAttrs() const
+  {
+    return MappedAttrCount() || (AttrSlotCount() && AttrSlotIsTaken(0));
+  }
+
+  uint32_t AttrCount() const;
+  const nsAttrValue* GetAttr(nsIAtom* aLocalName,
+                             int32_t aNamespaceID = kNameSpaceID_None) const;
+
+
+  const nsAttrValue* GetAttr(const nsAString& aName) const;
+
+
+  const nsAttrValue* GetAttr(const nsAString& aName,
+                             nsCaseTreatment aCaseSensitive) const;
+  const nsAttrValue* AttrAt(uint32_t aPos) const;
+
+  nsresult SetAndSwapAttr(nsIAtom* aLocalName, nsAttrValue& aValue);
+  nsresult SetAndSwapAttr(mozilla::dom::NodeInfo* aName, nsAttrValue& aValue);
+
+
+
+  nsresult RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue);
+
+
+  const nsAttrName* AttrNameAt(uint32_t aPos) const;
+
+
+  BorrowedAttrInfo AttrInfoAt(uint32_t aPos) const;
+
+
+  const nsAttrName* GetSafeAttrNameAt(uint32_t aPos) const;
+
+  const nsAttrName* GetExistingAttrNameFromQName(const nsAString& aName) const;
+  int32_t IndexOfAttr(nsIAtom* aLocalName, int32_t aNamespaceID = kNameSpaceID_None) const;
+
+  nsresult SetAndTakeMappedAttr(nsIAtom* aLocalName, nsAttrValue& aValue,
+                                nsMappedAttributeElement* aContent,
+                                nsHTMLStyleSheet* aSheet);
+  nsresult SetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet) {
+    if (!mImpl || !mImpl->mMappedAttrs) {
+      return NS_OK;
+    }
+    return DoSetMappedAttrStyleSheet(aSheet);
+  }
+  void WalkMappedAttributeStyleRules(nsRuleWalker* aRuleWalker);
+
+  void Compact();
+
+  bool CanFitMoreAttrs() const
+  {
+    return AttrSlotCount() < ((1 << 10) - 1) ||
+           !AttrSlotIsTaken(((1 << 10) - 1) - 1);
+  }
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+  bool HasMappedAttrs() const
+  {
+    return MappedAttrCount();
+  }
+  const nsMappedAttributes* GetMapped() const;
+
+
+  nsresult ForceMapped(nsMappedAttributeElement* aContent, nsIDocument* aDocument);
+
+
+
+  void ClearMappedServoStyle();
+
+private:
+  nsAttrAndChildArray(const nsAttrAndChildArray& aOther) = delete;
+  nsAttrAndChildArray& operator=(const nsAttrAndChildArray& aOther) = delete;
+
+  void Clear();
+
+  uint32_t NonMappedAttrCount() const;
+  uint32_t MappedAttrCount() const;
+
+
+  nsMappedAttributes*
+  GetModifiableMapped(nsMappedAttributeElement* aContent,
+                      nsHTMLStyleSheet* aSheet,
+                      bool aWillAddAttr,
+                      int32_t aAttrCount = 1);
+  nsresult MakeMappedUnique(nsMappedAttributes* aAttributes);
+
+  uint32_t AttrSlotsSize() const
+  {
+    return AttrSlotCount() * (sizeof(InternalAttr) / sizeof(void*));
+  }
+
+  uint32_t AttrSlotCount() const
+  {
+    return mImpl ? mImpl->mAttrAndChildCount & ((1 << 10) - 1) : 0;
+  }
+
+  bool AttrSlotIsTaken(uint32_t aSlot) const
+  {
+    do { } while(0);
+    return mImpl->mBuffer[aSlot * (sizeof(InternalAttr) / sizeof(void*))];
+  }
+
+  void SetChildCount(uint32_t aCount)
+  {
+    mImpl->mAttrAndChildCount =
+        (mImpl->mAttrAndChildCount & ((1 << 10) - 1)) |
+        (aCount << 10);
+  }
+
+  void SetAttrSlotCount(uint32_t aCount)
+  {
+    mImpl->mAttrAndChildCount =
+        (mImpl->mAttrAndChildCount & ~((1 << 10) - 1)) |
+        aCount;
+  }
+
+  void SetAttrSlotAndChildCount(uint32_t aSlotCount, uint32_t aChildCount)
+  {
+    mImpl->mAttrAndChildCount = aSlotCount |
+      (aChildCount << 10);
+  }
+
+  bool GrowBy(uint32_t aGrowSize);
+  bool AddAttrSlot();
+
+
+
+
+
+
+  inline void SetChildAtPos(void** aPos, nsIContent* aChild, uint32_t aIndex,
+                            uint32_t aChildCount);
+
+
+
+
+  nsresult DoSetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet);
+
+  struct InternalAttr
+  {
+    nsAttrName mName;
+    nsAttrValue mValue;
+  };
+
+  struct Impl {
+    uint32_t mAttrAndChildCount;
+    uint32_t mBufferSize;
+    nsMappedAttributes* mMappedAttrs;
+    void* mBuffer[1];
+  };
+
+  Impl* mImpl;
+};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h"
+class nsIAtom;
+
+class nsGkAtoms {
+public:
+
+  static void AddRefAtoms();
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtomList.h" 1
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtomList.h"
+static nsIAtom* _empty;
+static nsIAtom* moz;
+static nsIAtom* mozframetype;
+static nsIAtom* _moz_abspos;
+static nsIAtom* _moz_activated;
+static nsIAtom* _moz_anonclass;
+static nsIAtom* _moz_resizing;
+static nsIAtom* mozallowfullscreen;
+static nsIAtom* moztype;
+static nsIAtom* mozdirty;
+static nsIAtom* mozdisallowselectionprint;
+static nsIAtom* mozdonotsend;
+static nsIAtom* mozeditorbogusnode;
+static nsIAtom* mozgeneratedcontentbefore;
+static nsIAtom* mozgeneratedcontentafter;
+static nsIAtom* mozgeneratedcontentimage;
+static nsIAtom* mozquote;
+static nsIAtom* mozsignature;
+static nsIAtom* _moz_is_glyph;
+static nsIAtom* _moz_original_size;
+static nsIAtom* _moz_target;
+static nsIAtom* menuactive;
+static nsIAtom* _poundDefault;
+static nsIAtom* _asterisk;
+static nsIAtom* a;
+static nsIAtom* abbr;
+static nsIAtom* abort;
+static nsIAtom* above;
+static nsIAtom* acceltext;
+static nsIAtom* accept;
+static nsIAtom* acceptcharset;
+static nsIAtom* accesskey;
+static nsIAtom* acronym;
+static nsIAtom* action;
+static nsIAtom* active;
+static nsIAtom* activetitlebarcolor;
+static nsIAtom* activateontab;
+static nsIAtom* actuate;
+static nsIAtom* address;
+static nsIAtom* after;
+static nsIAtom* after_end;
+static nsIAtom* after_start;
+static nsIAtom* align;
+static nsIAtom* alink;
+static nsIAtom* all;
+static nsIAtom* allowdirs;
+static nsIAtom* allowevents;
+static nsIAtom* allownegativeassertions;
+static nsIAtom* allowforms;
+static nsIAtom* allowfullscreen;
+static nsIAtom* allowmodals;
+static nsIAtom* alloworientationlock;
+static nsIAtom* allowpointerlock;
+static nsIAtom* allowpopupstoescapesandbox;
+static nsIAtom* allowpopups;
+static nsIAtom* allowpresentation;
+static nsIAtom* allowsameorigin;
+static nsIAtom* allowscripts;
+static nsIAtom* allowtopnavigation;
+static nsIAtom* allowuntrusted;
+static nsIAtom* alt;
+static nsIAtom* alternate;
+static nsIAtom* always;
+static nsIAtom* ancestor;
+static nsIAtom* ancestorOrSelf;
+static nsIAtom* anchor;
+static nsIAtom* _and;
+static nsIAtom* animations;
+static nsIAtom* anonid;
+static nsIAtom* anonlocation;
+static nsIAtom* any;
+static nsIAtom* applet;
+static nsIAtom* applyImports;
+static nsIAtom* applyTemplates;
+static nsIAtom* mozapptype;
+static nsIAtom* archive;
+static nsIAtom* area;
+static nsIAtom* arrow;
+static nsIAtom* article;
+static nsIAtom* ascending;
+static nsIAtom* aside;
+static nsIAtom* aspectRatio;
+static nsIAtom* assign;
+static nsIAtom* async;
+static nsIAtom* attribute;
+static nsIAtom* attributes;
+static nsIAtom* attributeSet;
+static nsIAtom* aural;
+static nsIAtom* _auto;
+static nsIAtom* autocheck;
+static nsIAtom* autocomplete;
+static nsIAtom* autofocus;
+static nsIAtom* autoplay;
+static nsIAtom* autorepeatbutton;
+static nsIAtom* axis;
+static nsIAtom* b;
+static nsIAtom* backdropFrame;
+static nsIAtom* background;
+static nsIAtom* base;
+static nsIAtom* basefont;
+static nsIAtom* baseline;
+static nsIAtom* bdi;
+static nsIAtom* bdo;
+static nsIAtom* before;
+static nsIAtom* before_end;
+static nsIAtom* before_start;
+static nsIAtom* below;
+static nsIAtom* bgcolor;
+static nsIAtom* bgsound;
+static nsIAtom* big;
+static nsIAtom* binding;
+static nsIAtom* bindings;
+static nsIAtom* bindToUntrustedContent;
+static nsIAtom* blankrow;
+static nsIAtom* block;
+static nsIAtom* blockquote;
+static nsIAtom* blur;
+static nsIAtom* body;
+static nsIAtom* boolean;
+static nsIAtom* border;
+static nsIAtom* bordercolor;
+static nsIAtom* both;
+static nsIAtom* bottom;
+static nsIAtom* bottomend;
+static nsIAtom* bottomstart;
+static nsIAtom* bottomleft;
+static nsIAtom* bottommargin;
+static nsIAtom* bottompadding;
+static nsIAtom* bottomright;
+static nsIAtom* box;
+static nsIAtom* br;
+static nsIAtom* braille;
+static nsIAtom* broadcast;
+static nsIAtom* broadcaster;
+static nsIAtom* broadcasterset;
+static nsIAtom* browser;
+static nsIAtom* mozbrowser;
+static nsIAtom* bulletinboard;
+static nsIAtom* button;
+static nsIAtom* brighttitlebarforeground;
+static nsIAtom* callTemplate;
+static nsIAtom* cancel;
+static nsIAtom* canvas;
+static nsIAtom* caption;
+static nsIAtom* capture;
+static nsIAtom* caseOrder;
+static nsIAtom* cdataSectionElements;
+static nsIAtom* ceiling;
+static nsIAtom* cell;
+static nsIAtom* cellpadding;
+static nsIAtom* cellspacing;
+static nsIAtom* center;
+static nsIAtom* ch;
+static nsIAtom* change;
+static nsIAtom* _char;
+static nsIAtom* characterData;
+static nsIAtom* charcode;
+static nsIAtom* charoff;
+static nsIAtom* charset;
+static nsIAtom* checkbox;
+static nsIAtom* checked;
+static nsIAtom* child;
+static nsIAtom* children;
+static nsIAtom* childList;
+static nsIAtom* choose;
+static nsIAtom* chromemargin;
+static nsIAtom* chromeOnlyContent;
+static nsIAtom* exposeToUntrustedContent;
+static nsIAtom* circ;
+static nsIAtom* circle;
+static nsIAtom* cite;
+static nsIAtom* _class;
+static nsIAtom* classid;
+static nsIAtom* clear;
+static nsIAtom* click;
+static nsIAtom* clickcount;
+static nsIAtom* clickthrough;
+static nsIAtom* movetoclick;
+static nsIAtom* clip;
+static nsIAtom* close;
+static nsIAtom* closed;
+static nsIAtom* closemenu;
+static nsIAtom* coalesceduplicatearcs;
+static nsIAtom* code;
+static nsIAtom* codebase;
+static nsIAtom* codetype;
+static nsIAtom* col;
+static nsIAtom* colgroup;
+static nsIAtom* collapse;
+static nsIAtom* collapsed;
+static nsIAtom* color;
+static nsIAtom* colorIndex;
+static nsIAtom* cols;
+static nsIAtom* colspan;
+static nsIAtom* column;
+static nsIAtom* columns;
+static nsIAtom* combobox;
+static nsIAtom* command;
+static nsIAtom* commands;
+static nsIAtom* commandset;
+static nsIAtom* commandupdate;
+static nsIAtom* commandupdater;
+static nsIAtom* comment;
+static nsIAtom* compact;
+static nsIAtom* concat;
+static nsIAtom* conditions;
+static nsIAtom* constructor;
+static nsIAtom* consumeoutsideclicks;
+static nsIAtom* container;
+static nsIAtom* containment;
+static nsIAtom* contains;
+static nsIAtom* content;
+static nsIAtom* contenteditable;
+static nsIAtom* headerContentDisposition;
+static nsIAtom* headerContentLanguage;
+static nsIAtom* contentLocation;
+static nsIAtom* headerContentScriptType;
+static nsIAtom* headerContentStyleType;
+static nsIAtom* headerContentType;
+static nsIAtom* consumeanchor;
+static nsIAtom* context;
+static nsIAtom* contextmenu;
+static nsIAtom* control;
+static nsIAtom* controls;
+static nsIAtom* coords;
+static nsIAtom* copy;
+static nsIAtom* copyOf;
+static nsIAtom* count;
+static nsIAtom* crop;
+static nsIAtom* crossorigin;
+static nsIAtom* curpos;
+static nsIAtom* current;
+static nsIAtom* cutoutregion;
+static nsIAtom* cycler;
+static nsIAtom* data;
+static nsIAtom* datalist;
+static nsIAtom* dataType;
+static nsIAtom* dateTime;
+static nsIAtom* datasources;
+static nsIAtom* datetime;
+static nsIAtom* datetimebox;
+static nsIAtom* dblclick;
+static nsIAtom* dd;
+static nsIAtom* debug;
+static nsIAtom* decimalFormat;
+static nsIAtom* decimalSeparator;
+static nsIAtom* deck;
+static nsIAtom* declare;
+static nsIAtom* decoderDoctor;
+static nsIAtom* decrement;
+static nsIAtom* _default;
+static nsIAtom* headerDefaultStyle;
+static nsIAtom* defaultAction;
+static nsIAtom* defaultchecked;
+static nsIAtom* defaultLabel;
+static nsIAtom* defaultselected;
+static nsIAtom* defaultvalue;
+static nsIAtom* defaultplaybackrate;
+static nsIAtom* defer;
+static nsIAtom* del;
+static nsIAtom* descendant;
+static nsIAtom* descendantOrSelf;
+static nsIAtom* descending;
+static nsIAtom* description;
+static nsIAtom* destructor;
+static nsIAtom* details;
+static nsIAtom* deviceAspectRatio;
+static nsIAtom* deviceHeight;
+static nsIAtom* devicePixelRatio;
+static nsIAtom* deviceWidth;
+static nsIAtom* dfn;
+static nsIAtom* dialog;
+static nsIAtom* difference;
+static nsIAtom* digit;
+static nsIAtom* dir;
+static nsIAtom* dirAutoSetBy;
+static nsIAtom* directionality;
+static nsIAtom* directory;
+static nsIAtom* disableOutputEscaping;
+static nsIAtom* disabled;
+static nsIAtom* disableglobalhistory;
+static nsIAtom* disablehistory;
+static nsIAtom* disablefullscreen;
+static nsIAtom* display;
+static nsIAtom* displayMode;
+static nsIAtom* distinct;
+static nsIAtom* div;
+static nsIAtom* dl;
+static nsIAtom* doctypePublic;
+static nsIAtom* doctypeSystem;
+static nsIAtom* document;
+static nsIAtom* download;
+static nsIAtom* DOMAttrModified;
+static nsIAtom* DOMCharacterDataModified;
+static nsIAtom* DOMNodeInserted;
+static nsIAtom* DOMNodeInsertedIntoDocument;
+static nsIAtom* DOMNodeRemoved;
+static nsIAtom* DOMNodeRemovedFromDocument;
+static nsIAtom* DOMSubtreeModified;
+static nsIAtom* double_;
+static nsIAtom* drag;
+static nsIAtom* dragend;
+static nsIAtom* dragenter;
+static nsIAtom* dragevent;
+static nsIAtom* dragexit;
+static nsIAtom* draggable;
+static nsIAtom* dragging;
+static nsIAtom* dragleave;
+static nsIAtom* dragover;
+static nsIAtom* dragSession;
+static nsIAtom* dragstart;
+static nsIAtom* drawintitlebar;
+static nsIAtom* drawtitle;
+static nsIAtom* drop;
+static nsIAtom* dropAfter;
+static nsIAtom* dropBefore;
+static nsIAtom* dropOn;
+static nsIAtom* dropMarker;
+static nsIAtom* dt;
+static nsIAtom* editable;
+static nsIAtom* editing;
+static nsIAtom* editor;
+static nsIAtom* editorDisplayList;
+static nsIAtom* element;
+static nsIAtom* elementAvailable;
+static nsIAtom* elements;
+static nsIAtom* em;
+static nsIAtom* embed;
+static nsIAtom* embossed;
+static nsIAtom* empty;
+static nsIAtom* encoding;
+static nsIAtom* enctype;
+static nsIAtom* end;
+static nsIAtom* endEvent;
+static nsIAtom* end_after;
+static nsIAtom* end_before;
+static nsIAtom* equalsize;
+static nsIAtom* error;
+static nsIAtom* even;
+static nsIAtom* event;
+static nsIAtom* events;
+static nsIAtom* excludeResultPrefixes;
+static nsIAtom* excludes;
+static nsIAtom* expr;
+static nsIAtom* extends;
+static nsIAtom* extensionElementPrefixes;
+static nsIAtom* face;
+static nsIAtom* fallback;
+static nsIAtom* _false;
+static nsIAtom* farthest;
+static nsIAtom* field;
+static nsIAtom* fieldset;
+static nsIAtom* figcaption;
+static nsIAtom* figure;
+static nsIAtom* fixed;
+static nsIAtom* flags;
+static nsIAtom* flex;
+static nsIAtom* flexgroup;
+static nsIAtom* flip;
+static nsIAtom* floating;
+static nsIAtom* floor;
+static nsIAtom* flowlength;
+static nsIAtom* focus;
+static nsIAtom* focused;
+static nsIAtom* followanchor;
+static nsIAtom* following;
+static nsIAtom* followingSibling;
+static nsIAtom* font;
+static nsIAtom* fontWeight;
+static nsIAtom* fontpicker;
+static nsIAtom* footer;
+static nsIAtom* _for;
+static nsIAtom* forEach;
+static nsIAtom* forceOwnRefreshDriver;
+static nsIAtom* form;
+static nsIAtom* formaction;
+static nsIAtom* format;
+static nsIAtom* formatNumber;
+static nsIAtom* formenctype;
+static nsIAtom* formmethod;
+static nsIAtom* formnovalidate;
+static nsIAtom* formtarget;
+static nsIAtom* frame;
+static nsIAtom* frameborder;
+static nsIAtom* frameset;
+static nsIAtom* from;
+static nsIAtom* fullscreenchange;
+static nsIAtom* fullscreenerror;
+static nsIAtom* functionAvailable;
+static nsIAtom* freshProcess;
+static nsIAtom* generateId;
+static nsIAtom* getter;
+static nsIAtom* glyphchar;
+static nsIAtom* glyphid;
+static nsIAtom* grid;
+static nsIAtom* grippy;
+static nsIAtom* group;
+static nsIAtom* groupingSeparator;
+static nsIAtom* groupingSize;
+static nsIAtom* grow;
+static nsIAtom* gutter;
+static nsIAtom* h1;
+static nsIAtom* h2;
+static nsIAtom* h3;
+static nsIAtom* h4;
+static nsIAtom* h5;
+static nsIAtom* h6;
+static nsIAtom* handheld;
+static nsIAtom* handheldFriendly;
+static nsIAtom* handler;
+static nsIAtom* handlers;
+static nsIAtom* HARD;
+static nsIAtom* hasSameNode;
+static nsIAtom* hbox;
+static nsIAtom* head;
+static nsIAtom* header;
+static nsIAtom* headers;
+static nsIAtom* height;
+static nsIAtom* hgroup;
+static nsIAtom* hidden;
+static nsIAtom* hidechrome;
+static nsIAtom* hidecolumnpicker;
+static nsIAtom* high;
+static nsIAtom* highest;
+static nsIAtom* horizontal;
+static nsIAtom* hover;
+static nsIAtom* hr;
+static nsIAtom* href;
+static nsIAtom* hreflang;
+static nsIAtom* hspace;
+static nsIAtom* html;
+static nsIAtom* httpEquiv;
+static nsIAtom* i;
+static nsIAtom* icon;
+static nsIAtom* id;
+static nsIAtom* _if;
+static nsIAtom* iframe;
+static nsIAtom* ignorecase;
+static nsIAtom* ignorekeys;
+static nsIAtom* ignoreuserfocus;
+static nsIAtom* ilayer;
+static nsIAtom* image;
+static nsIAtom* imageClickedPoint;
+static nsIAtom* img;
+static nsIAtom* implementation;
+static nsIAtom* implements;
+static nsIAtom* import;
+static nsIAtom* inactivetitlebarcolor;
+static nsIAtom* include;
+static nsIAtom* includes;
+static nsIAtom* increment;
+static nsIAtom* indent;
+static nsIAtom* indeterminate;
+static nsIAtom* index;
+static nsIAtom* infer;
+static nsIAtom* infinity;
+static nsIAtom* inherit;
+static nsIAtom* inherits;
+static nsIAtom* inheritstyle;
+static nsIAtom* initial_scale;
+static nsIAtom* input;
+static nsIAtom* inputmode;
+static nsIAtom* ins;
+static nsIAtom* insertafter;
+static nsIAtom* insertbefore;
+static nsIAtom* install;
+static nsIAtom* instanceOf;
+static nsIAtom* int32;
+static nsIAtom* int64;
+static nsIAtom* integer;
+static nsIAtom* integrity;
+static nsIAtom* intersection;
+static nsIAtom* is;
+static nsIAtom* iscontainer;
+static nsIAtom* isempty;
+static nsIAtom* ismap;
+static nsIAtom* itemid;
+static nsIAtom* itemprop;
+static nsIAtom* itemref;
+static nsIAtom* itemscope;
+static nsIAtom* itemtype;
+static nsIAtom* kbd;
+static nsIAtom* keepcurrentinview;
+static nsIAtom* keepobjectsalive;
+static nsIAtom* key;
+static nsIAtom* keycode;
+static nsIAtom* keystatuseschange;
+static nsIAtom* keydown;
+static nsIAtom* keygen;
+static nsIAtom* keypress;
+static nsIAtom* keyset;
+static nsIAtom* keysystem;
+static nsIAtom* keytext;
+static nsIAtom* keyup;
+static nsIAtom* kind;
+static nsIAtom* label;
+static nsIAtom* lang;
+static nsIAtom* language;
+static nsIAtom* last;
+static nsIAtom* layer;
+static nsIAtom* LayerActivity;
+static nsIAtom* layout;
+static nsIAtom* leading;
+static nsIAtom* leaf;
+static nsIAtom* left;
+static nsIAtom* leftmargin;
+static nsIAtom* leftpadding;
+static nsIAtom* legend;
+static nsIAtom* length;
+static nsIAtom* letterValue;
+static nsIAtom* level;
+static nsIAtom* li;
+static nsIAtom* line;
+static nsIAtom* link;
+static nsIAtom* list;
+static nsIAtom* listbox;
+static nsIAtom* listboxbody;
+static nsIAtom* listcell;
+static nsIAtom* listcol;
+static nsIAtom* listcols;
+static nsIAtom* listener;
+static nsIAtom* listhead;
+static nsIAtom* listheader;
+static nsIAtom* listing;
+static nsIAtom* listitem;
+static nsIAtom* listrows;
+static nsIAtom* load;
+static nsIAtom* loadingprincipal;
+static nsIAtom* localedir;
+static nsIAtom* localName;
+static nsIAtom* longdesc;
+static nsIAtom* loop;
+static nsIAtom* low;
+static nsIAtom* lowerFirst;
+static nsIAtom* lowest;
+static nsIAtom* lowsrc;
+static nsIAtom* ltr;
+static nsIAtom* lwtheme;
+static nsIAtom* lwthemetextcolor;
+static nsIAtom* main;
+static nsIAtom* map;
+static nsIAtom* manifest;
+static nsIAtom* marginBottom;
+static nsIAtom* marginLeft;
+static nsIAtom* marginRight;
+static nsIAtom* marginTop;
+static nsIAtom* marginheight;
+static nsIAtom* marginwidth;
+static nsIAtom* mark;
+static nsIAtom* marquee;
+static nsIAtom* match;
+static nsIAtom* max;
+static nsIAtom* maxheight;
+static nsIAtom* maximum_scale;
+static nsIAtom* maxlength;
+static nsIAtom* maxpos;
+static nsIAtom* maxwidth;
+static nsIAtom* mayscript;
+static nsIAtom* media;
+static nsIAtom* mediaType;
+static nsIAtom* member;
+static nsIAtom* menu;
+static nsIAtom* menubar;
+static nsIAtom* menubutton;
+static nsIAtom* menuButton;
+static nsIAtom* menugroup;
+static nsIAtom* menuitem;
+static nsIAtom* menulist;
+static nsIAtom* menupopup;
+static nsIAtom* menuseparator;
+static nsIAtom* message;
+static nsIAtom* meta;
+static nsIAtom* referrer;
+static nsIAtom* referrerpolicy;
+static nsIAtom* headerReferrerPolicy;
+static nsIAtom* meter;
+static nsIAtom* method;
+static nsIAtom* middle;
+static nsIAtom* min;
+static nsIAtom* minheight;
+static nsIAtom* minimum_scale;
+static nsIAtom* minlength;
+static nsIAtom* minpos;
+static nsIAtom* minusSign;
+static nsIAtom* minwidth;
+static nsIAtom* _mixed;
+static nsIAtom* messagemanagergroup;
+static nsIAtom* mod;
+static nsIAtom* mode;
+static nsIAtom* modifiers;
+static nsIAtom* monochrome;
+static nsIAtom* mousedown;
+static nsIAtom* mousemove;
+static nsIAtom* mouseout;
+static nsIAtom* mouseover;
+static nsIAtom* mousethrough;
+static nsIAtom* mouseup;
+static nsIAtom* mozaudiochannel;
+static nsIAtom* mozfullscreenchange;
+static nsIAtom* mozfullscreenerror;
+static nsIAtom* mozpointerlockchange;
+static nsIAtom* mozpointerlockerror;
+static nsIAtom* mozprivatebrowsing;
+static nsIAtom* moz_opaque;
+static nsIAtom* moz_action_hint;
+static nsIAtom* x_moz_errormessage;
+static nsIAtom* msthemecompatible;
+static nsIAtom* multicol;
+static nsIAtom* multiple;
+static nsIAtom* muted;
+static nsIAtom* name;
+static nsIAtom* _namespace;
+static nsIAtom* namespaceAlias;
+static nsIAtom* namespaceUri;
+static nsIAtom* NaN;
+static nsIAtom* nativeAnonymousChildList;
+static nsIAtom* nav;
+static nsIAtom* negate;
+static nsIAtom* never;
+static nsIAtom* _new;
+static nsIAtom* newline;
+static nsIAtom* nextBidi;
+static nsIAtom* no;
+static nsIAtom* noautofocus;
+static nsIAtom* noautohide;
+static nsIAtom* norolluponanchor;
+static nsIAtom* nobr;
+static nsIAtom* node;
+static nsIAtom* nodefaultsrc;
+static nsIAtom* nodeSet;
+static nsIAtom* noembed;
+static nsIAtom* noframes;
+static nsIAtom* nohref;
+static nsIAtom* noisolation;
+static nsIAtom* nonce;
+static nsIAtom* none;
+static nsIAtom* noresize;
+static nsIAtom* normal;
+static nsIAtom* normalizeSpace;
+static nsIAtom* noscript;
+static nsIAtom* noshade;
+static nsIAtom* novalidate;
+static nsIAtom* _not;
+static nsIAtom* nowrap;
+static nsIAtom* number;
+static nsIAtom* null;
+static nsIAtom* object;
+static nsIAtom* objectType;
+static nsIAtom* observer;
+static nsIAtom* observes;
+static nsIAtom* odd;
+static nsIAtom* OFF;
+static nsIAtom* ol;
+static nsIAtom* omitXmlDeclaration;
+static nsIAtom* ona2dpstatuschanged;
+static nsIAtom* onabort;
+static nsIAtom* onmozaccesskeynotfound;
+static nsIAtom* onactivate;
+static nsIAtom* onadapteradded;
+static nsIAtom* onadapterremoved;
+static nsIAtom* onafterprint;
+static nsIAtom* onafterscriptexecute;
+static nsIAtom* onalerting;
+static nsIAtom* onanimationcancel;
+static nsIAtom* onanimationend;
+static nsIAtom* onanimationiteration;
+static nsIAtom* onanimationstart;
+static nsIAtom* onantennaavailablechange;
+static nsIAtom* onAppCommand;
+static nsIAtom* onappinstalled;
+static nsIAtom* onattributechanged;
+static nsIAtom* onattributereadreq;
+static nsIAtom* onattributewritereq;
+static nsIAtom* onaudioprocess;
+static nsIAtom* onauxclick;
+static nsIAtom* onbeforecopy;
+static nsIAtom* onbeforecut;
+static nsIAtom* onbeforepaste;
+static nsIAtom* onbeforeevicted;
+static nsIAtom* onbeforeprint;
+static nsIAtom* onbeforescriptexecute;
+static nsIAtom* onbeforeunload;
+static nsIAtom* onblocked;
+static nsIAtom* onblur;
+static nsIAtom* onbroadcast;
+static nsIAtom* onbusy;
+static nsIAtom* onbufferedamountlow;
+static nsIAtom* oncached;
+static nsIAtom* oncallschanged;
+static nsIAtom* oncancel;
+static nsIAtom* oncardstatechange;
+static nsIAtom* oncfstatechange;
+static nsIAtom* onchange;
+static nsIAtom* oncharacteristicchanged;
+static nsIAtom* onchargingchange;
+static nsIAtom* onchargingtimechange;
+static nsIAtom* onchecking;
+static nsIAtom* onclick;
+static nsIAtom* onclirmodechange;
+static nsIAtom* onclose;
+static nsIAtom* oncommand;
+static nsIAtom* oncommandupdate;
+static nsIAtom* oncomplete;
+static nsIAtom* oncompositionend;
+static nsIAtom* oncompositionstart;
+static nsIAtom* oncompositionupdate;
+static nsIAtom* onconnect;
+static nsIAtom* onconnected;
+static nsIAtom* onconnecting;
+static nsIAtom* onconnectionavailable;
+static nsIAtom* onconnectionstatechanged;
+static nsIAtom* oncontextmenu;
+static nsIAtom* oncopy;
+static nsIAtom* oncurrentchannelchanged;
+static nsIAtom* oncurrentsourcechanged;
+static nsIAtom* oncut;
+static nsIAtom* ondatachange;
+static nsIAtom* ondataerror;
+static nsIAtom* ondblclick;
+static nsIAtom* ondeleted;
+static nsIAtom* ondeliverysuccess;
+static nsIAtom* ondeliveryerror;
+static nsIAtom* ondevicefound;
+static nsIAtom* ondevicepaired;
+static nsIAtom* ondeviceunpaired;
+static nsIAtom* ondialing;
+static nsIAtom* ondisabled;
+static nsIAtom* ondischargingtimechange;
+static nsIAtom* ondisconnect;
+static nsIAtom* ondisconnected;
+static nsIAtom* ondisconnecting;
+static nsIAtom* ondisplaypasskeyreq;
+static nsIAtom* ondownloading;
+static nsIAtom* onDOMActivate;
+static nsIAtom* onDOMAttrModified;
+static nsIAtom* onDOMCharacterDataModified;
+static nsIAtom* onDOMFocusIn;
+static nsIAtom* onDOMFocusOut;
+static nsIAtom* onDOMMouseScroll;
+static nsIAtom* onDOMNodeInserted;
+static nsIAtom* onDOMNodeInsertedIntoDocument;
+static nsIAtom* onDOMNodeRemoved;
+static nsIAtom* onDOMNodeRemovedFromDocument;
+static nsIAtom* onDOMSubtreeModified;
+static nsIAtom* ondata;
+static nsIAtom* ondrag;
+static nsIAtom* ondragdrop;
+static nsIAtom* ondragend;
+static nsIAtom* ondragenter;
+static nsIAtom* ondragexit;
+static nsIAtom* ondraggesture;
+static nsIAtom* ondragleave;
+static nsIAtom* ondragover;
+static nsIAtom* ondragstart;
+static nsIAtom* ondrain;
+static nsIAtom* ondrop;
+static nsIAtom* oneitbroadcasted;
+static nsIAtom* onenabled;
+static nsIAtom* onenterpincodereq;
+static nsIAtom* onemergencycbmodechange;
+static nsIAtom* onerror;
+static nsIAtom* onevicted;
+static nsIAtom* onfailed;
+static nsIAtom* onfetch;
+static nsIAtom* onfinish;
+static nsIAtom* onfocus;
+static nsIAtom* onfocusin;
+static nsIAtom* onfocusout;
+static nsIAtom* onfrequencychange;
+static nsIAtom* onfullscreenchange;
+static nsIAtom* onfullscreenerror;
+static nsIAtom* onspeakerforcedchange;
+static nsIAtom* onget;
+static nsIAtom* ongroupchange;
+static nsIAtom* onhashchange;
+static nsIAtom* onheadphoneschange;
+static nsIAtom* onheld;
+static nsIAtom* onhfpstatuschanged;
+static nsIAtom* onhidstatuschanged;
+static nsIAtom* onholding;
+static nsIAtom* oniccchange;
+static nsIAtom* oniccdetected;
+static nsIAtom* oniccinfochange;
+static nsIAtom* oniccundetected;
+static nsIAtom* onincoming;
+static nsIAtom* oninput;
+static nsIAtom* oninstall;
+static nsIAtom* oninvalid;
+static nsIAtom* onkeydown;
+static nsIAtom* onkeypress;
+static nsIAtom* onkeyup;
+static nsIAtom* onlanguagechange;
+static nsIAtom* onlevelchange;
+static nsIAtom* onLoad;
+static nsIAtom* onload;
+static nsIAtom* onloading;
+static nsIAtom* onloadingdone;
+static nsIAtom* onloadingerror;
+static nsIAtom* onpopstate;
+static nsIAtom* only;
+static nsIAtom* onmessage;
+static nsIAtom* onmousedown;
+static nsIAtom* onmouseenter;
+static nsIAtom* onmouseleave;
+static nsIAtom* onmouselongtap;
+static nsIAtom* onmousemove;
+static nsIAtom* onmouseout;
+static nsIAtom* onmouseover;
+static nsIAtom* onMozMouseHittest;
+static nsIAtom* onmouseup;
+static nsIAtom* onMozAfterPaint;
+static nsIAtom* onmozfullscreenchange;
+static nsIAtom* onmozfullscreenerror;
+static nsIAtom* onmozkeydownonplugin;
+static nsIAtom* onmozkeyuponplugin;
+static nsIAtom* onmozpointerlockchange;
+static nsIAtom* onmozpointerlockerror;
+static nsIAtom* onmoztimechange;
+static nsIAtom* onMozMousePixelScroll;
+static nsIAtom* onMozScrolledAreaChanged;
+static nsIAtom* onmoznetworkupload;
+static nsIAtom* onmoznetworkdownload;
+static nsIAtom* onmapfolderlistingreq;
+static nsIAtom* onmapmessageslistingreq;
+static nsIAtom* onmapgetmessagereq;
+static nsIAtom* onmapsetmessagestatusreq;
+static nsIAtom* onmapsendmessagereq;
+static nsIAtom* onmapmessageupdatereq;
+static nsIAtom* onnewrdsgroup;
+static nsIAtom* onnotificationclick;
+static nsIAtom* onnotificationclose;
+static nsIAtom* onnoupdate;
+static nsIAtom* onobexpasswordreq;
+static nsIAtom* onobsolete;
+static nsIAtom* ononline;
+static nsIAtom* onoffline;
+static nsIAtom* onopen;
+static nsIAtom* onorientationchange;
+static nsIAtom* onotastatuschange;
+static nsIAtom* onoverflow;
+static nsIAtom* onoverflowchanged;
+static nsIAtom* onpagehide;
+static nsIAtom* onpageshow;
+static nsIAtom* onpaint;
+static nsIAtom* onpairingaborted;
+static nsIAtom* onpairingconfirmationreq;
+static nsIAtom* onpairingconsentreq;
+static nsIAtom* onpaste;
+static nsIAtom* onpendingchange;
+static nsIAtom* onpichange;
+static nsIAtom* onpointerlockchange;
+static nsIAtom* onpointerlockerror;
+static nsIAtom* onpopuphidden;
+static nsIAtom* onpopuphiding;
+static nsIAtom* onpopuppositioned;
+static nsIAtom* onpopupshowing;
+static nsIAtom* onpopupshown;
+static nsIAtom* onpullphonebookreq;
+static nsIAtom* onpullvcardentryreq;
+static nsIAtom* onpullvcardlistingreq;
+static nsIAtom* onpush;
+static nsIAtom* onpushsubscriptionchange;
+static nsIAtom* onpschange;
+static nsIAtom* onptychange;
+static nsIAtom* onradiostatechange;
+static nsIAtom* onrdsdisabled;
+static nsIAtom* onrdsenabled;
+static nsIAtom* onreaderror;
+static nsIAtom* onreadsuccess;
+static nsIAtom* onready;
+static nsIAtom* onreadystatechange;
+static nsIAtom* onreceived;
+static nsIAtom* onremoteheld;
+static nsIAtom* onremoteresumed;
+static nsIAtom* onrequestprogress;
+static nsIAtom* onresourcetimingbufferfull;
+static nsIAtom* onresponseprogress;
+static nsIAtom* onretrieving;
+static nsIAtom* onRequest;
+static nsIAtom* onrequestmediaplaystatus;
+static nsIAtom* onreset;
+static nsIAtom* onresuming;
+static nsIAtom* onresize;
+static nsIAtom* onrtchange;
+static nsIAtom* onscanningstatechanged;
+static nsIAtom* onscostatuschanged;
+static nsIAtom* onscroll;
+static nsIAtom* onselect;
+static nsIAtom* onselectionchange;
+static nsIAtom* onselectstart;
+static nsIAtom* onsending;
+static nsIAtom* onsent;
+static nsIAtom* onset;
+static nsIAtom* onshow;
+static nsIAtom* onstatechange;
+static nsIAtom* onstatuschanged;
+static nsIAtom* onstkcommand;
+static nsIAtom* onstksessionend;
+static nsIAtom* onstorage;
+static nsIAtom* onstorageareachanged;
+static nsIAtom* onsubmit;
+static nsIAtom* onsuccess;
+static nsIAtom* ontypechange;
+static nsIAtom* onterminate;
+static nsIAtom* ontext;
+static nsIAtom* ontoggle;
+static nsIAtom* ontouchstart;
+static nsIAtom* ontouchend;
+static nsIAtom* ontouchmove;
+static nsIAtom* ontouchcancel;
+static nsIAtom* ontransitioncancel;
+static nsIAtom* ontransitionend;
+static nsIAtom* ontransitionrun;
+static nsIAtom* ontransitionstart;
+static nsIAtom* onunderflow;
+static nsIAtom* onunload;
+static nsIAtom* onupdatefound;
+static nsIAtom* onupdateready;
+static nsIAtom* onupgradeneeded;
+static nsIAtom* onussdreceived;
+static nsIAtom* onversionchange;
+static nsIAtom* onvoicechange;
+static nsIAtom* onvoiceschanged;
+static nsIAtom* onvrdisplayactivate;
+static nsIAtom* onvrdisplayconnect;
+static nsIAtom* onvrdisplaydeactivate;
+static nsIAtom* onvrdisplaydisconnect;
+static nsIAtom* onvrdisplaypresentchange;
+static nsIAtom* onwebkitAnimationEnd;
+static nsIAtom* onwebkitAnimationIteration;
+static nsIAtom* onwebkitAnimationStart;
+static nsIAtom* onwebkitTransitionEnd;
+static nsIAtom* onwebkitanimationend;
+static nsIAtom* onwebkitanimationiteration;
+static nsIAtom* onwebkitanimationstart;
+static nsIAtom* onwebkittransitionend;
+static nsIAtom* onwebsocket;
+static nsIAtom* onwheel;
+static nsIAtom* open;
+static nsIAtom* optgroup;
+static nsIAtom* optimum;
+static nsIAtom* option;
+static nsIAtom* _or;
+static nsIAtom* order;
+static nsIAtom* ordinal;
+static nsIAtom* orient;
+static nsIAtom* orientation;
+static nsIAtom* otherwise;
+static nsIAtom* output;
+static nsIAtom* overflow;
+static nsIAtom* overflowchanged;
+static nsIAtom* overlay;
+static nsIAtom* overlap;
+static nsIAtom* p;
+static nsIAtom* pack;
+static nsIAtom* page;
+static nsIAtom* pageincrement;
+static nsIAtom* pagex;
+static nsIAtom* pagey;
+static nsIAtom* paint_order;
+static nsIAtom* palettename;
+static nsIAtom* panel;
+static nsIAtom* param;
+static nsIAtom* parameter;
+static nsIAtom* parent;
+static nsIAtom* parentfocused;
+static nsIAtom* parsetype;
+static nsIAtom* password;
+static nsIAtom* pattern;
+static nsIAtom* patternSeparator;
+static nsIAtom* perMille;
+static nsIAtom* percent;
+static nsIAtom* persist;
+static nsIAtom* phase;
+static nsIAtom* picture;
+static nsIAtom* ping;
+static nsIAtom* pinned;
+static nsIAtom* placeholder;
+static nsIAtom* plaintext;
+static nsIAtom* playbackrate;
+static nsIAtom* pointSize;
+static nsIAtom* pointerlockchange;
+static nsIAtom* pointerlockerror;
+static nsIAtom* poly;
+static nsIAtom* polygon;
+static nsIAtom* popup;
+static nsIAtom* popupalign;
+static nsIAtom* popupanchor;
+static nsIAtom* popupgroup;
+static nsIAtom* popuphidden;
+static nsIAtom* popuphiding;
+static nsIAtom* popupset;
+static nsIAtom* popupshowing;
+static nsIAtom* popupshown;
+static nsIAtom* popupsinherittooltip;
+static nsIAtom* position;
+static nsIAtom* poster;
+static nsIAtom* pre;
+static nsIAtom* preceding;
+static nsIAtom* precedingSibling;
+static nsIAtom* predicate;
+static nsIAtom* prefix;
+static nsIAtom* preload;
+static nsIAtom* prerendered;
+static nsIAtom* mozpresentation;
+static nsIAtom* preserve;
+static nsIAtom* preserveSpace;
+static nsIAtom* preventdefault;
+static nsIAtom* primary;
+static nsIAtom* print;
+static nsIAtom* priority;
+static nsIAtom* processingInstruction;
+static nsIAtom* profile;
+static nsIAtom* progress;
+static nsIAtom* progressmeter;
+static nsIAtom* progressNormal;
+static nsIAtom* progressUndetermined;
+static nsIAtom* projection;
+static nsIAtom* prompt;
+static nsIAtom* propagate;
+static nsIAtom* properties;
+static nsIAtom* property;
+static nsIAtom* pubdate;
+static nsIAtom* q;
+static nsIAtom* query;
+static nsIAtom* queryset;
+static nsIAtom* querytype;
+static nsIAtom* radio;
+static nsIAtom* radiogroup;
+static nsIAtom* range;
+static nsIAtom* readonly;
+static nsIAtom* rect;
+static nsIAtom* rectangle;
+static nsIAtom* ref;
+static nsIAtom* refresh;
+static nsIAtom* rel;
+static nsIAtom* onreloadpage;
+static nsIAtom* rem;
+static nsIAtom* removeelement;
+static nsIAtom* renderingobserverlist;
+static nsIAtom* repeat;
+static nsIAtom* replace;
+static nsIAtom* required;
+static nsIAtom* reserved;
+static nsIAtom* reset;
+static nsIAtom* resizeafter;
+static nsIAtom* resizebefore;
+static nsIAtom* resizer;
+static nsIAtom* resolution;
+static nsIAtom* resource;
+static nsIAtom* resources;
+static nsIAtom* result;
+static nsIAtom* resultPrefix;
+static nsIAtom* retargetdocumentfocus;
+static nsIAtom* rev;
+static nsIAtom* reverse;
+static nsIAtom* reversed;
+static nsIAtom* richlistbox;
+static nsIAtom* richlistitem;
+static nsIAtom* right;
+static nsIAtom* rightmargin;
+static nsIAtom* rightpadding;
+static nsIAtom* role;
+static nsIAtom* rolluponmousewheel;
+static nsIAtom* round;
+static nsIAtom* row;
+static nsIAtom* rows;
+static nsIAtom* rowspan;
+static nsIAtom* rb;
+static nsIAtom* rp;
+static nsIAtom* rt;
+static nsIAtom* rtc;
+static nsIAtom* rtl;
+static nsIAtom* ruby;
+static nsIAtom* rubyBase;
+static nsIAtom* rubyBaseContainer;
+static nsIAtom* rubyText;
+static nsIAtom* rubyTextContainer;
+static nsIAtom* rule;
+static nsIAtom* rules;
+static nsIAtom* s;
+static nsIAtom* samp;
+static nsIAtom* sandbox;
+static nsIAtom* sbattr;
+static nsIAtom* scale;
+static nsIAtom* scan;
+static nsIAtom* scheme;
+static nsIAtom* scope;
+static nsIAtom* scoped;
+static nsIAtom* screen;
+static nsIAtom* screenX;
+static nsIAtom* screenY;
+static nsIAtom* script;
+static nsIAtom* scriptEnabledBeforePrintOrPreview;
+static nsIAtom* scrollbar;
+static nsIAtom* scrollbarbutton;
+static nsIAtom* scrollbarDownBottom;
+static nsIAtom* scrollbarDownTop;
+static nsIAtom* scrollbarUpBottom;
+static nsIAtom* scrollbarUpTop;
+static nsIAtom* scrollbox;
+static nsIAtom* scrollcorner;
+static nsIAtom* scrolling;
+static nsIAtom* scrollPosition;
+static nsIAtom* section;
+static nsIAtom* select;
+static nsIAtom* selectable;
+static nsIAtom* selected;
+static nsIAtom* selectedIndex;
+static nsIAtom* selectedindex;
+static nsIAtom* self;
+static nsIAtom* seltype;
+static nsIAtom* setcookie;
+static nsIAtom* setter;
+static nsIAtom* shape;
+static nsIAtom* show;
+static nsIAtom* showcaret;
+static nsIAtom* showresizer;
+static nsIAtom* simple;
+static nsIAtom* single;
+static nsIAtom* size;
+static nsIAtom* sizes;
+static nsIAtom* sizemode;
+static nsIAtom* sizetopopup;
+static nsIAtom* slider;
+static nsIAtom* small;
+static nsIAtom* smooth;
+static nsIAtom* snap;
+static nsIAtom* sort;
+static nsIAtom* sortActive;
+static nsIAtom* sortDirection;
+static nsIAtom* sorted;
+static nsIAtom* sorthints;
+static nsIAtom* sortLocked;
+static nsIAtom* sortResource;
+static nsIAtom* sortResource2;
+static nsIAtom* sortSeparators;
+static nsIAtom* sortStaticsLast;
+static nsIAtom* source;
+static nsIAtom* space;
+static nsIAtom* spacer;
+static nsIAtom* span;
+static nsIAtom* spellcheck;
+static nsIAtom* spinner;
+static nsIAtom* split;
+static nsIAtom* splitter;
+static nsIAtom* spring;
+static nsIAtom* src;
+static nsIAtom* srcdoc;
+static nsIAtom* srclang;
+static nsIAtom* srcset;
+static nsIAtom* stack;
+static nsIAtom* standalone;
+static nsIAtom* standby;
+static nsIAtom* start;
+static nsIAtom* start_after;
+static nsIAtom* start_before;
+static nsIAtom* startsWith;
+static nsIAtom* state;
+static nsIAtom* statedatasource;
+static nsIAtom* staticHint;
+static nsIAtom* statusbar;
+static nsIAtom* statustext;
+static nsIAtom* step;
+static nsIAtom* stop;
+static nsIAtom* stretch;
+static nsIAtom* strike;
+static nsIAtom* string;
+static nsIAtom* stringLength;
+static nsIAtom* stripSpace;
+static nsIAtom* strong;
+static nsIAtom* style;
+static nsIAtom* stylesheet;
+static nsIAtom* stylesheetPrefix;
+static nsIAtom* subject;
+static nsIAtom* submit;
+static nsIAtom* substate;
+static nsIAtom* substring;
+static nsIAtom* substringAfter;
+static nsIAtom* substringBefore;
+static nsIAtom* sub;
+static nsIAtom* sum;
+static nsIAtom* sup;
+static nsIAtom* summary;
+static nsIAtom* systemProperty;
+static nsIAtom* tab;
+static nsIAtom* tabbox;
+static nsIAtom* tabindex;
+static nsIAtom* table;
+static nsIAtom* tabpanel;
+static nsIAtom* tabpanels;
+static nsIAtom* tag;
+static nsIAtom* target;
+static nsIAtom* targets;
+static nsIAtom* tbody;
+static nsIAtom* td;
+static nsIAtom* _template;
+static nsIAtom* text_decoration;
+static nsIAtom* terminate;
+static nsIAtom* test;
+static nsIAtom* text;
+static nsIAtom* textAlign;
+static nsIAtom* textarea;
+static nsIAtom* textbox;
+static nsIAtom* textnode;
+static nsIAtom* textNodeDirectionalityMap;
+static nsIAtom* tfoot;
+static nsIAtom* th;
+static nsIAtom* thead;
+static nsIAtom* thumb;
+static nsIAtom* time;
+static nsIAtom* title;
+static nsIAtom* titlebar;
+static nsIAtom* titletip;
+static nsIAtom* toggled;
+static nsIAtom* token;
+static nsIAtom* tokenize;
+static nsIAtom* toolbar;
+static nsIAtom* toolbarbutton;
+static nsIAtom* toolbaritem;
+static nsIAtom* toolbox;
+static nsIAtom* tooltip;
+static nsIAtom* tooltiptext;
+static nsIAtom* top;
+static nsIAtom* topleft;
+static nsIAtom* topmargin;
+static nsIAtom* toppadding;
+static nsIAtom* topright;
+static nsIAtom* tr;
+static nsIAtom* track;
+static nsIAtom* trailing;
+static nsIAtom* transform;
+static nsIAtom* transform_3d;
+static nsIAtom* transformiix;
+static nsIAtom* translate;
+static nsIAtom* transparent;
+static nsIAtom* tree;
+static nsIAtom* treecell;
+static nsIAtom* treechildren;
+static nsIAtom* treecol;
+static nsIAtom* treecolpicker;
+static nsIAtom* treecols;
+static nsIAtom* treeitem;
+static nsIAtom* treerow;
+static nsIAtom* treeseparator;
+static nsIAtom* triple;
+static nsIAtom* _true;
+static nsIAtom* tt;
+static nsIAtom* tty;
+static nsIAtom* tv;
+static nsIAtom* type;
+static nsIAtom* typemustmatch;
+static nsIAtom* u;
+static nsIAtom* ul;
+static nsIAtom* underflow;
+static nsIAtom* undetermined;
+static nsIAtom* unload;
+static nsIAtom* unparsedEntityUri;
+static nsIAtom* upperFirst;
+static nsIAtom* uri;
+static nsIAtom* use;
+static nsIAtom* useAttributeSets;
+static nsIAtom* usemap;
+static nsIAtom* user_scalable;
+static nsIAtom* userInput;
+static nsIAtom* validate;
+static nsIAtom* valign;
+static nsIAtom* value;
+static nsIAtom* values;
+static nsIAtom* valueOf;
+static nsIAtom* valuetype;
+static nsIAtom* var;
+static nsIAtom* variable;
+static nsIAtom* vbox;
+static nsIAtom* vcard_name;
+static nsIAtom* vendor;
+static nsIAtom* vendorUrl;
+static nsIAtom* version;
+static nsIAtom* vert;
+static nsIAtom* vertical;
+static nsIAtom* audio;
+static nsIAtom* video;
+static nsIAtom* videocontrols;
+static nsIAtom* viewport;
+static nsIAtom* viewport_height;
+static nsIAtom* viewport_initial_scale;
+static nsIAtom* viewport_maximum_scale;
+static nsIAtom* viewport_minimum_scale;
+static nsIAtom* viewport_user_scalable;
+static nsIAtom* viewport_width;
+static nsIAtom* visibility;
+static nsIAtom* visuallyselected;
+static nsIAtom* vlink;
+static nsIAtom* vspace;
+static nsIAtom* wbr;
+static nsIAtom* webkitdirectory;
+static nsIAtom* when;
+static nsIAtom* where;
+static nsIAtom* widget;
+static nsIAtom* width;
+static nsIAtom* willChange;
+static nsIAtom* window;
+static nsIAtom* headerWindowTarget;
+static nsIAtom* windowtype;
+static nsIAtom* withParam;
+static nsIAtom* wizard;
+static nsIAtom* wrap;
+static nsIAtom* headerDNSPrefetchControl;
+static nsIAtom* headerCSP;
+static nsIAtom* headerCSPReportOnly;
+static nsIAtom* headerXFO;
+static nsIAtom* x_western;
+static nsIAtom* xml;
+static nsIAtom* xml_stylesheet;
+static nsIAtom* xmlns;
+static nsIAtom* xmp;
+static nsIAtom* xulcontentsgenerated;
+static nsIAtom* yes;
+static nsIAtom* z_index;
+static nsIAtom* zeroDigit;
+
+
+static nsIAtom* percentage;
+static nsIAtom* A;
+static nsIAtom* alignment_baseline;
+static nsIAtom* amplitude;
+static nsIAtom* animate;
+static nsIAtom* animateColor;
+static nsIAtom* animateMotion;
+static nsIAtom* animateTransform;
+static nsIAtom* arithmetic;
+static nsIAtom* atop;
+static nsIAtom* azimuth;
+static nsIAtom* B;
+static nsIAtom* backgroundColor;
+static nsIAtom* background_image;
+static nsIAtom* baseFrequency;
+static nsIAtom* baseline_shift;
+static nsIAtom* bias;
+static nsIAtom* caption_side;
+static nsIAtom* clip_path;
+static nsIAtom* clip_rule;
+static nsIAtom* clipPath;
+static nsIAtom* clipPathUnits;
+static nsIAtom* cm;
+static nsIAtom* colorBurn;
+static nsIAtom* colorDodge;
+static nsIAtom* colorInterpolation;
+static nsIAtom* colorInterpolationFilters;
+static nsIAtom* colorProfile;
+static nsIAtom* cursor;
+static nsIAtom* cx;
+static nsIAtom* cy;
+static nsIAtom* d;
+static nsIAtom* darken;
+static nsIAtom* defs;
+static nsIAtom* deg;
+static nsIAtom* desc;
+static nsIAtom* diffuseConstant;
+static nsIAtom* dilate;
+static nsIAtom* direction;
+static nsIAtom* disable;
+static nsIAtom* discrete;
+static nsIAtom* divisor;
+static nsIAtom* dominant_baseline;
+static nsIAtom* duplicate;
+static nsIAtom* dx;
+static nsIAtom* dy;
+static nsIAtom* edgeMode;
+static nsIAtom* ellipse;
+static nsIAtom* elevation;
+static nsIAtom* erode;
+static nsIAtom* ex;
+static nsIAtom* exact;
+static nsIAtom* exclusion;
+static nsIAtom* exponent;
+static nsIAtom* feBlend;
+static nsIAtom* feColorMatrix;
+static nsIAtom* feComponentTransfer;
+static nsIAtom* feComposite;
+static nsIAtom* feConvolveMatrix;
+static nsIAtom* feDiffuseLighting;
+static nsIAtom* feDisplacementMap;
+static nsIAtom* feDistantLight;
+static nsIAtom* feDropShadow;
+static nsIAtom* feFlood;
+static nsIAtom* feFuncA;
+static nsIAtom* feFuncB;
+static nsIAtom* feFuncG;
+static nsIAtom* feFuncR;
+static nsIAtom* feGaussianBlur;
+static nsIAtom* feImage;
+static nsIAtom* feMerge;
+static nsIAtom* feMergeNode;
+static nsIAtom* feMorphology;
+static nsIAtom* feOffset;
+static nsIAtom* fePointLight;
+static nsIAtom* feSpecularLighting;
+static nsIAtom* feSpotLight;
+static nsIAtom* feTile;
+static nsIAtom* feTurbulence;
+static nsIAtom* fill;
+static nsIAtom* fill_opacity;
+static nsIAtom* fill_rule;
+static nsIAtom* filter;
+static nsIAtom* filterUnits;
+static nsIAtom* _float;
+static nsIAtom* flood_color;
+static nsIAtom* flood_opacity;
+static nsIAtom* font_face;
+static nsIAtom* font_face_format;
+static nsIAtom* font_face_name;
+static nsIAtom* font_face_src;
+static nsIAtom* font_face_uri;
+static nsIAtom* font_family;
+static nsIAtom* font_size;
+static nsIAtom* font_size_adjust;
+static nsIAtom* font_stretch;
+static nsIAtom* font_style;
+static nsIAtom* font_variant;
+static nsIAtom* foreignObject;
+static nsIAtom* fractalNoise;
+static nsIAtom* fx;
+static nsIAtom* fy;
+static nsIAtom* G;
+static nsIAtom* g;
+static nsIAtom* gamma;
+
+static nsIAtom* generic_;
+static nsIAtom* glyphRef;
+static nsIAtom* grad;
+static nsIAtom* gradientTransform;
+static nsIAtom* gradientUnits;
+static nsIAtom* hardLight;
+static nsIAtom* hue;
+static nsIAtom* hueRotate;
+static nsIAtom* identity;
+static nsIAtom* image_rendering;
+static nsIAtom* in;
+static nsIAtom* in2;
+static nsIAtom* intercept;
+static nsIAtom* k1;
+static nsIAtom* k2;
+static nsIAtom* k3;
+static nsIAtom* k4;
+static nsIAtom* kernelMatrix;
+static nsIAtom* kernelUnitLength;
+static nsIAtom* lengthAdjust;
+static nsIAtom* letter_spacing;
+static nsIAtom* lighten;
+static nsIAtom* lighting_color;
+static nsIAtom* limitingConeAngle;
+static nsIAtom* linear;
+static nsIAtom* linearGradient;
+static nsIAtom* linearRGB;
+static nsIAtom* list_style_type;
+static nsIAtom* luminanceToAlpha;
+static nsIAtom* luminosity;
+static nsIAtom* magnify;
+static nsIAtom* marker;
+static nsIAtom* marker_end;
+static nsIAtom* marker_mid;
+static nsIAtom* marker_start;
+static nsIAtom* markerHeight;
+static nsIAtom* markerUnits;
+static nsIAtom* markerWidth;
+static nsIAtom* mask;
+static nsIAtom* maskContentUnits;
+static nsIAtom* mask_type;
+static nsIAtom* maskUnits;
+static nsIAtom* matrix;
+static nsIAtom* metadata;
+static nsIAtom* missingGlyph;
+static nsIAtom* mm;
+static nsIAtom* mpath;
+static nsIAtom* noStitch;
+static nsIAtom* numOctaves;
+static nsIAtom* multiply;
+static nsIAtom* objectBoundingBox;
+static nsIAtom* offset;
+static nsIAtom* onSVGLoad;
+static nsIAtom* onSVGResize;
+static nsIAtom* onSVGScroll;
+static nsIAtom* onSVGUnload;
+static nsIAtom* onSVGZoom;
+static nsIAtom* onzoom;
+static nsIAtom* opacity;
+static nsIAtom* _operator;
+static nsIAtom* out;
+static nsIAtom* over;
+static nsIAtom* overridePreserveAspectRatio;
+static nsIAtom* pad;
+static nsIAtom* path;
+static nsIAtom* pathLength;
+static nsIAtom* patternContentUnits;
+static nsIAtom* patternTransform;
+static nsIAtom* patternUnits;
+static nsIAtom* pc;
+static nsIAtom* pointer_events;
+static nsIAtom* points;
+static nsIAtom* pointsAtX;
+static nsIAtom* pointsAtY;
+static nsIAtom* pointsAtZ;
+static nsIAtom* polyline;
+static nsIAtom* preserveAlpha;
+static nsIAtom* preserveAspectRatio;
+static nsIAtom* primitiveUnits;
+static nsIAtom* pt;
+static nsIAtom* px;
+static nsIAtom* R;
+static nsIAtom* r;
+static nsIAtom* rad;
+static nsIAtom* radialGradient;
+static nsIAtom* radius;
+static nsIAtom* reflect;
+static nsIAtom* refX;
+static nsIAtom* refY;
+static nsIAtom* requiredExtensions;
+static nsIAtom* requiredFeatures;
+static nsIAtom* rotate;
+static nsIAtom* rx;
+static nsIAtom* ry;
+static nsIAtom* saturate;
+static nsIAtom* saturation;
+static nsIAtom* set;
+static nsIAtom* seed;
+static nsIAtom* shadow;
+static nsIAtom* shape_rendering;
+static nsIAtom* skewX;
+static nsIAtom* skewY;
+static nsIAtom* slope;
+static nsIAtom* softLight;
+static nsIAtom* spacing;
+static nsIAtom* spacingAndGlyphs;
+static nsIAtom* specularConstant;
+static nsIAtom* specularExponent;
+static nsIAtom* spreadMethod;
+static nsIAtom* sRGB;
+static nsIAtom* startOffset;
+static nsIAtom* stdDeviation;
+static nsIAtom* stitch;
+static nsIAtom* stitchTiles;
+static nsIAtom* stop_color;
+static nsIAtom* stop_opacity;
+static nsIAtom* stroke;
+static nsIAtom* stroke_dasharray;
+static nsIAtom* stroke_dashoffset;
+static nsIAtom* stroke_linecap;
+static nsIAtom* stroke_linejoin;
+static nsIAtom* stroke_miterlimit;
+static nsIAtom* stroke_opacity;
+static nsIAtom* stroke_width;
+static nsIAtom* strokeWidth;
+static nsIAtom* surfaceScale;
+static nsIAtom* svg;
+static nsIAtom* svgContextPaint;
+static nsIAtom* svgSwitch;
+static nsIAtom* symbol;
+static nsIAtom* systemLanguage;
+static nsIAtom* tableValues;
+static nsIAtom* targetX;
+static nsIAtom* targetY;
+static nsIAtom* text_anchor;
+static nsIAtom* text_rendering;
+static nsIAtom* textLength;
+static nsIAtom* textPath;
+static nsIAtom* tref;
+static nsIAtom* tspan;
+static nsIAtom* turbulence;
+static nsIAtom* unicode_bidi;
+static nsIAtom* userSpaceOnUse;
+static nsIAtom* view;
+static nsIAtom* viewBox;
+static nsIAtom* viewTarget;
+static nsIAtom* white_space;
+static nsIAtom* word_spacing;
+static nsIAtom* writing_mode;
+static nsIAtom* x;
+static nsIAtom* x1;
+static nsIAtom* x2;
+static nsIAtom* xChannelSelector;
+static nsIAtom* xor_;
+static nsIAtom* y;
+static nsIAtom* y1;
+static nsIAtom* y2;
+static nsIAtom* yChannelSelector;
+static nsIAtom* z;
+static nsIAtom* zoomAndPan;
+static nsIAtom* vector_effect;
+static nsIAtom* vertical_align;
+
+static nsIAtom* accumulate;
+static nsIAtom* additive;
+static nsIAtom* attributeName;
+static nsIAtom* attributeType;
+static nsIAtom* auto_reverse;
+static nsIAtom* begin;
+static nsIAtom* beginEvent;
+static nsIAtom* by;
+static nsIAtom* calcMode;
+static nsIAtom* css;
+static nsIAtom* dur;
+static nsIAtom* keyPoints;
+static nsIAtom* keySplines;
+static nsIAtom* keyTimes;
+static nsIAtom* mozAnimateMotionDummyAttr;
+static nsIAtom* onbegin;
+static nsIAtom* onbeginEvent;
+static nsIAtom* onend;
+static nsIAtom* onendEvent;
+static nsIAtom* onrepeat;
+static nsIAtom* onrepeatEvent;
+static nsIAtom* repeatCount;
+static nsIAtom* repeatDur;
+static nsIAtom* repeatEvent;
+static nsIAtom* restart;
+static nsIAtom* to;
+static nsIAtom* XML;
+
+static nsIAtom* abs_;
+static nsIAtom* accent_;
+static nsIAtom* accentunder_;
+static nsIAtom* actiontype_;
+static nsIAtom* alignmentscope_;
+static nsIAtom* altimg_;
+static nsIAtom* altimg_height_;
+static nsIAtom* altimg_valign_;
+static nsIAtom* altimg_width_;
+static nsIAtom* annotation_;
+static nsIAtom* annotation_xml_;
+static nsIAtom* apply_;
+static nsIAtom* approx_;
+static nsIAtom* arccos_;
+static nsIAtom* arccosh_;
+static nsIAtom* arccot_;
+static nsIAtom* arccoth_;
+static nsIAtom* arccsc_;
+static nsIAtom* arccsch_;
+static nsIAtom* arcsec_;
+static nsIAtom* arcsech_;
+static nsIAtom* arcsin_;
+static nsIAtom* arcsinh_;
+static nsIAtom* arctan_;
+static nsIAtom* arctanh_;
+static nsIAtom* arg_;
+static nsIAtom* bevelled_;
+static nsIAtom* bind_;
+static nsIAtom* bvar_;
+static nsIAtom* card_;
+static nsIAtom* cartesianproduct_;
+static nsIAtom* cbytes_;
+static nsIAtom* cd_;
+static nsIAtom* cdgroup_;
+static nsIAtom* cerror_;
+static nsIAtom* charalign_;
+static nsIAtom* ci_;
+static nsIAtom* closure_;
+static nsIAtom* cn_;
+static nsIAtom* codomain_;
+static nsIAtom* columnalign_;
+static nsIAtom* columnalignment_;
+static nsIAtom* columnlines_;
+static nsIAtom* columnspacing_;
+static nsIAtom* columnspan_;
+static nsIAtom* columnwidth_;
+static nsIAtom* complexes_;
+static nsIAtom* compose_;
+static nsIAtom* condition_;
+static nsIAtom* conjugate_;
+static nsIAtom* cos_;
+static nsIAtom* cosh_;
+static nsIAtom* cot_;
+static nsIAtom* coth_;
+static nsIAtom* crossout_;
+static nsIAtom* csc_;
+static nsIAtom* csch_;
+static nsIAtom* cs_;
+static nsIAtom* csymbol_;
+static nsIAtom* curl_;
+static nsIAtom* decimalpoint_;
+static nsIAtom* definitionURL_;
+static nsIAtom* degree_;
+static nsIAtom* denomalign_;
+static nsIAtom* depth_;
+static nsIAtom* determinant_;
+static nsIAtom* diff_;
+static nsIAtom* displaystyle_;
+static nsIAtom* divergence_;
+static nsIAtom* divide_;
+static nsIAtom* domain_;
+static nsIAtom* domainofapplication_;
+static nsIAtom* edge_;
+static nsIAtom* el_;
+static nsIAtom* emptyset_;
+static nsIAtom* eq_;
+static nsIAtom* equalcolumns_;
+static nsIAtom* equalrows_;
+static nsIAtom* equivalent_;
+static nsIAtom* eulergamma_;
+static nsIAtom* exists_;
+static nsIAtom* exp_;
+static nsIAtom* exponentiale_;
+static nsIAtom* factorial_;
+static nsIAtom* factorof_;
+static nsIAtom* fence_;
+static nsIAtom* fn_;
+static nsIAtom* fontfamily_;
+static nsIAtom* fontsize_;
+static nsIAtom* fontstyle_;
+static nsIAtom* fontweight_;
+static nsIAtom* forall_;
+static nsIAtom* framespacing_;
+static nsIAtom* gcd_;
+static nsIAtom* geq_;
+static nsIAtom* groupalign_;
+static nsIAtom* gt_;
+static nsIAtom* ident_;
+static nsIAtom* imaginaryi_;
+static nsIAtom* imaginary_;
+static nsIAtom* implies_;
+static nsIAtom* indentalignfirst_;
+static nsIAtom* indentalign_;
+static nsIAtom* indentalignlast_;
+static nsIAtom* indentshiftfirst_;
+static nsIAtom* indentshift_;
+static nsIAtom* indenttarget_;
+static nsIAtom* integers_;
+static nsIAtom* intersect_;
+static nsIAtom* interval_;
+static nsIAtom* int_;
+static nsIAtom* inverse_;
+static nsIAtom* lambda_;
+static nsIAtom* laplacian_;
+static nsIAtom* largeop_;
+static nsIAtom* lcm_;
+static nsIAtom* leq_;
+static nsIAtom* limit_;
+static nsIAtom* linebreak_;
+static nsIAtom* linebreakmultchar_;
+static nsIAtom* linebreakstyle_;
+static nsIAtom* linethickness_;
+static nsIAtom* list_;
+static nsIAtom* ln_;
+static nsIAtom* location_;
+static nsIAtom* logbase_;
+static nsIAtom* log_;
+static nsIAtom* longdivstyle_;
+static nsIAtom* lowlimit_;
+static nsIAtom* lquote_;
+static nsIAtom* lspace_;
+static nsIAtom* lt_;
+static nsIAtom* maction_;
+static nsIAtom* maligngroup_;
+static nsIAtom* malignmark_;
+static nsIAtom* mathbackground_;
+static nsIAtom* mathcolor_;
+static nsIAtom* mathsize_;
+static nsIAtom* mathvariant_;
+static nsIAtom* matrixrow_;
+static nsIAtom* maxsize_;
+static nsIAtom* mean_;
+static nsIAtom* median_;
+static nsIAtom* menclose_;
+static nsIAtom* merror_;
+static nsIAtom* mfenced_;
+static nsIAtom* mfrac_;
+static nsIAtom* mglyph_;
+static nsIAtom* mi_;
+static nsIAtom* minlabelspacing_;
+static nsIAtom* minsize_;
+static nsIAtom* minus_;
+static nsIAtom* mlabeledtr_;
+static nsIAtom* mlongdiv_;
+static nsIAtom* mmultiscripts_;
+static nsIAtom* mn_;
+static nsIAtom* momentabout_;
+static nsIAtom* moment_;
+static nsIAtom* mo_;
+static nsIAtom* movablelimits_;
+static nsIAtom* mover_;
+static nsIAtom* mpadded_;
+static nsIAtom* mphantom_;
+static nsIAtom* mprescripts_;
+static nsIAtom* mroot_;
+static nsIAtom* mrow_;
+static nsIAtom* mscarries_;
+static nsIAtom* mscarry_;
+static nsIAtom* msgroup_;
+static nsIAtom* msline_;
+static nsIAtom* ms_;
+static nsIAtom* mspace_;
+static nsIAtom* msqrt_;
+static nsIAtom* msrow_;
+static nsIAtom* mstack_;
+static nsIAtom* mstyle_;
+static nsIAtom* msub_;
+static nsIAtom* msubsup_;
+static nsIAtom* msup_;
+static nsIAtom* mtable_;
+static nsIAtom* mtd_;
+static nsIAtom* mtext_;
+static nsIAtom* mtr_;
+static nsIAtom* munder_;
+static nsIAtom* munderover_;
+static nsIAtom* naturalnumbers_;
+static nsIAtom* neq_;
+static nsIAtom* notanumber_;
+static nsIAtom* notation_;
+static nsIAtom* note_;
+static nsIAtom* notin_;
+static nsIAtom* notprsubset_;
+static nsIAtom* notsubset_;
+static nsIAtom* numalign_;
+static nsIAtom* other_;
+static nsIAtom* outerproduct_;
+static nsIAtom* partialdiff_;
+static nsIAtom* piece_;
+static nsIAtom* piecewise_;
+static nsIAtom* pi_;
+static nsIAtom* plus_;
+static nsIAtom* power_;
+static nsIAtom* primes_;
+static nsIAtom* product_;
+static nsIAtom* prsubset_;
+static nsIAtom* quotient_;
+static nsIAtom* rationals_;
+static nsIAtom* real_;
+static nsIAtom* reals_;
+static nsIAtom* reln_;
+static nsIAtom* root_;
+static nsIAtom* rowalign_;
+static nsIAtom* rowlines_;
+static nsIAtom* rowspacing_;
+static nsIAtom* rquote_;
+static nsIAtom* rspace_;
+static nsIAtom* scalarproduct_;
+static nsIAtom* schemaLocation_;
+static nsIAtom* scriptlevel_;
+static nsIAtom* scriptminsize_;
+static nsIAtom* scriptsizemultiplier_;
+static nsIAtom* scriptsize_;
+static nsIAtom* sdev_;
+static nsIAtom* sech_;
+static nsIAtom* sec_;
+static nsIAtom* selection_;
+static nsIAtom* selector_;
+static nsIAtom* semantics_;
+static nsIAtom* separator_;
+static nsIAtom* separators_;
+static nsIAtom* sep_;
+static nsIAtom* setdiff_;
+static nsIAtom* set_;
+static nsIAtom* share_;
+static nsIAtom* shift_;
+static nsIAtom* side_;
+static nsIAtom* sinh_;
+static nsIAtom* sin_;
+static nsIAtom* stackalign_;
+static nsIAtom* stretchy_;
+static nsIAtom* subscriptshift_;
+static nsIAtom* subset_;
+static nsIAtom* superscriptshift_;
+static nsIAtom* symmetric_;
+static nsIAtom* tanh_;
+static nsIAtom* tan_;
+static nsIAtom* tendsto_;
+static nsIAtom* times_;
+static nsIAtom* transpose_;
+static nsIAtom* union_;
+static nsIAtom* uplimit_;
+static nsIAtom* variance_;
+static nsIAtom* vectorproduct_;
+static nsIAtom* vector_;
+static nsIAtom* voffset_;
+static nsIAtom* xref_;
+static nsIAtom* math;
+static nsIAtom* avg;
+static nsIAtom* booleanFromString;
+static nsIAtom* countNonEmpty;
+static nsIAtom* daysFromDate;
+static nsIAtom* init;
+static nsIAtom* instance;
+static nsIAtom* months;
+static nsIAtom* now;
+static nsIAtom* seconds;
+static nsIAtom* secondsFromDateTime;
+
+
+static nsIAtom* onMozSwipeGestureMayStart;
+static nsIAtom* onMozSwipeGestureStart;
+static nsIAtom* onMozSwipeGestureUpdate;
+static nsIAtom* onMozSwipeGestureEnd;
+static nsIAtom* onMozSwipeGesture;
+static nsIAtom* onMozMagnifyGestureStart;
+static nsIAtom* onMozMagnifyGestureUpdate;
+static nsIAtom* onMozMagnifyGesture;
+static nsIAtom* onMozRotateGestureStart;
+static nsIAtom* onMozRotateGestureUpdate;
+static nsIAtom* onMozRotateGesture;
+static nsIAtom* onMozTapGesture;
+static nsIAtom* onMozPressTapGesture;
+static nsIAtom* onMozEdgeUIStarted;
+static nsIAtom* onMozEdgeUICanceled;
+static nsIAtom* onMozEdgeUICompleted;
+
+
+static nsIAtom* onpointerdown;
+static nsIAtom* onpointermove;
+static nsIAtom* onpointerup;
+static nsIAtom* onpointercancel;
+static nsIAtom* onpointerover;
+static nsIAtom* onpointerout;
+static nsIAtom* onpointerenter;
+static nsIAtom* onpointerleave;
+static nsIAtom* ongotpointercapture;
+static nsIAtom* onlostpointercapture;
+
+
+static nsIAtom* ondevicemotion;
+static nsIAtom* ondeviceorientation;
+static nsIAtom* onabsolutedeviceorientation;
+static nsIAtom* ondeviceproximity;
+static nsIAtom* onmozorientationchange;
+static nsIAtom* onuserproximity;
+
+
+static nsIAtom* ondevicelight;
+
+
+static nsIAtom* onmozinterruptbegin;
+static nsIAtom* onmozinterruptend;
+
+
+static nsIAtom* ondevicechange;
+
+
+static nsIAtom* mozinputrangeignorepreventdefault;
+
+
+
+
+
+
+static nsIAtom* cdataTagName;
+static nsIAtom* commentTagName;
+static nsIAtom* documentNodeName;
+static nsIAtom* documentFragmentNodeName;
+static nsIAtom* documentTypeNodeName;
+static nsIAtom* processingInstructionTagName;
+static nsIAtom* textTagName;
+
+
+static nsIAtom* bcTableCellFrame;
+static nsIAtom* blockFrame;
+static nsIAtom* boxFrame;
+static nsIAtom* brFrame;
+static nsIAtom* bulletFrame;
+static nsIAtom* colorControlFrame;
+static nsIAtom* columnSetFrame;
+static nsIAtom* comboboxControlFrame;
+static nsIAtom* comboboxDisplayFrame;
+static nsIAtom* dateTimeControlFrame;
+static nsIAtom* deckFrame;
+static nsIAtom* detailsFrame;
+static nsIAtom* fieldSetFrame;
+static nsIAtom* flexContainerFrame;
+static nsIAtom* formControlFrame;
+static nsIAtom* frameSetFrame;
+static nsIAtom* gfxButtonControlFrame;
+static nsIAtom* gridContainerFrame;
+static nsIAtom* HTMLButtonControlFrame;
+static nsIAtom* HTMLCanvasFrame;
+static nsIAtom* subDocumentFrame;
+static nsIAtom* imageBoxFrame;
+static nsIAtom* imageFrame;
+static nsIAtom* imageControlFrame;
+static nsIAtom* inlineFrame;
+static nsIAtom* leafBoxFrame;
+static nsIAtom* legendFrame;
+static nsIAtom* letterFrame;
+static nsIAtom* lineFrame;
+static nsIAtom* listControlFrame;
+static nsIAtom* menuFrame;
+static nsIAtom* meterFrame;
+static nsIAtom* menuPopupFrame;
+static nsIAtom* numberControlFrame;
+static nsIAtom* objectFrame;
+static nsIAtom* pageFrame;
+static nsIAtom* pageBreakFrame;
+static nsIAtom* pageContentFrame;
+static nsIAtom* placeholderFrame;
+static nsIAtom* popupSetFrame;
+static nsIAtom* progressFrame;
+static nsIAtom* canvasFrame;
+static nsIAtom* rangeFrame;
+static nsIAtom* rootFrame;
+static nsIAtom* rubyBaseContainerFrame;
+static nsIAtom* rubyBaseFrame;
+static nsIAtom* rubyFrame;
+static nsIAtom* rubyTextContainerFrame;
+static nsIAtom* rubyTextFrame;
+static nsIAtom* scrollFrame;
+static nsIAtom* scrollbarFrame;
+static nsIAtom* sequenceFrame;
+static nsIAtom* sliderFrame;
+static nsIAtom* tableCellFrame;
+static nsIAtom* tableColFrame;
+static nsIAtom* tableColGroupFrame;
+static nsIAtom* tableFrame;
+static nsIAtom* tableWrapperFrame;
+static nsIAtom* tableRowGroupFrame;
+static nsIAtom* tableRowFrame;
+static nsIAtom* textInputFrame;
+static nsIAtom* textFrame;
+static nsIAtom* viewportFrame;
+
+static nsIAtom* XULLabelFrame;
+
+static nsIAtom* svgAFrame;
+static nsIAtom* svgClipPathFrame;
+static nsIAtom* svgDefsFrame;
+static nsIAtom* svgFEContainerFrame;
+static nsIAtom* svgFEImageFrame;
+static nsIAtom* svgFELeafFrame;
+static nsIAtom* svgFEUnstyledLeafFrame;
+static nsIAtom* svgFilterFrame;
+static nsIAtom* svgForeignObjectFrame;
+static nsIAtom* svgGenericContainerFrame;
+static nsIAtom* svgGeometryFrame;
+static nsIAtom* svgGFrame;
+static nsIAtom* svgGradientFrame;
+static nsIAtom* svgImageFrame;
+static nsIAtom* svgInnerSVGFrame;
+static nsIAtom* svgLinearGradientFrame;
+static nsIAtom* svgMarkerFrame;
+static nsIAtom* svgMarkerAnonChildFrame;
+static nsIAtom* svgMaskFrame;
+static nsIAtom* svgOuterSVGFrame;
+static nsIAtom* svgOuterSVGAnonChildFrame;
+static nsIAtom* svgPatternFrame;
+static nsIAtom* svgRadialGradientFrame;
+static nsIAtom* svgStopFrame;
+static nsIAtom* svgSwitchFrame;
+static nsIAtom* svgTextFrame;
+static nsIAtom* svgUseFrame;
+static nsIAtom* svgViewFrame;
+static nsIAtom* HTMLVideoFrame;
+static nsIAtom* onloadend;
+static nsIAtom* onloadstart;
+static nsIAtom* onprogress;
+static nsIAtom* onsuspend;
+static nsIAtom* onemptied;
+static nsIAtom* onstalled;
+static nsIAtom* onplay;
+static nsIAtom* onpause;
+static nsIAtom* onloadedmetadata;
+static nsIAtom* onloadeddata;
+static nsIAtom* onwaiting;
+static nsIAtom* onplaying;
+static nsIAtom* oncanplay;
+static nsIAtom* oncanplaythrough;
+static nsIAtom* onseeking;
+static nsIAtom* onseeked;
+static nsIAtom* ontimeout;
+static nsIAtom* ontimeupdate;
+static nsIAtom* onended;
+static nsIAtom* onratechange;
+static nsIAtom* ondurationchange;
+static nsIAtom* onvolumechange;
+static nsIAtom* onaddtrack;
+static nsIAtom* oncontrollerchange;
+static nsIAtom* oncuechange;
+static nsIAtom* onenter;
+static nsIAtom* onexit;
+static nsIAtom* onencrypted;
+static nsIAtom* encrypted;
+static nsIAtom* onwaitingforkey;
+static nsIAtom* onkeystatuseschange;
+static nsIAtom* onremovetrack;
+static nsIAtom* loadstart;
+static nsIAtom* suspend;
+static nsIAtom* emptied;
+static nsIAtom* stalled;
+static nsIAtom* play;
+static nsIAtom* pause;
+static nsIAtom* loadedmetadata;
+static nsIAtom* loadeddata;
+static nsIAtom* waiting;
+static nsIAtom* playing;
+static nsIAtom* seeking;
+static nsIAtom* seeked;
+static nsIAtom* timeupdate;
+static nsIAtom* ended;
+static nsIAtom* canplay;
+static nsIAtom* canplaythrough;
+static nsIAtom* ratechange;
+static nsIAtom* durationchange;
+static nsIAtom* volumechange;
+static nsIAtom* ondataavailable;
+static nsIAtom* onwarning;
+static nsIAtom* onstart;
+static nsIAtom* onstop;
+static nsIAtom* onphoto;
+static nsIAtom* onactivestatechanged;
+static nsIAtom* ongamepadbuttondown;
+static nsIAtom* ongamepadbuttonup;
+static nsIAtom* ongamepadaxismove;
+static nsIAtom* ongamepadconnected;
+static nsIAtom* ongamepaddisconnected;
+
+
+static nsIAtom* animationsProperty;
+static nsIAtom* animationsOfBeforeProperty;
+static nsIAtom* animationsOfAfterProperty;
+static nsIAtom* animationEffectsProperty;
+static nsIAtom* animationEffectsForBeforeProperty;
+static nsIAtom* animationEffectsForAfterProperty;
+static nsIAtom* cssPseudoElementBeforeProperty;
+static nsIAtom* cssPseudoElementAfterProperty;
+static nsIAtom* transitionsProperty;
+static nsIAtom* transitionsOfBeforeProperty;
+static nsIAtom* transitionsOfAfterProperty;
+static nsIAtom* genConInitializerProperty;
+static nsIAtom* labelMouseDownPtProperty;
+static nsIAtom* lockedStyleStates;
+static nsIAtom* apzCallbackTransform;
+static nsIAtom* restylableAnonymousNode;
+static nsIAtom* paintRequestTime;
+static nsIAtom* pseudoProperty;
+
+
+static nsIAtom* Japanese;
+static nsIAtom* Chinese;
+static nsIAtom* Taiwanese;
+static nsIAtom* HongKongChinese;
+static nsIAtom* Unicode;
+
+
+static nsIAtom* ko;
+static nsIAtom* zh_cn;
+static nsIAtom* zh_hk;
+static nsIAtom* zh_tw;
+
+
+static nsIAtom* x_cyrillic;
+static nsIAtom* he;
+static nsIAtom* ar;
+static nsIAtom* x_devanagari;
+static nsIAtom* x_tamil;
+static nsIAtom* x_armn;
+static nsIAtom* x_beng;
+static nsIAtom* x_cans;
+static nsIAtom* x_ethi;
+static nsIAtom* x_geor;
+static nsIAtom* x_gujr;
+static nsIAtom* x_guru;
+static nsIAtom* x_khmr;
+static nsIAtom* x_knda;
+static nsIAtom* x_mlym;
+static nsIAtom* x_orya;
+static nsIAtom* x_sinh;
+static nsIAtom* x_telu;
+static nsIAtom* x_tibt;
+
+
+static nsIAtom* az;
+static nsIAtom* ba;
+static nsIAtom* crh;
+static nsIAtom* el;
+static nsIAtom* ga;
+static nsIAtom* nl;
+
+
+static nsIAtom* x_math;
+
+
+static nsIAtom* TypingTxnName;
+static nsIAtom* IMETxnName;
+static nsIAtom* DeleteTxnName;
+
+
+static nsIAtom* serif;
+static nsIAtom* sans_serif;
+static nsIAtom* cursive;
+static nsIAtom* fantasy;
+static nsIAtom* monospace;
+static nsIAtom* mozfixed;
+
+
+static nsIAtom* Remote;
+static nsIAtom* RemoteId;
+static nsIAtom* RemoteType;
+static nsIAtom* DisplayPort;
+static nsIAtom* DisplayPortMargins;
+static nsIAtom* DisplayPortBase;
+static nsIAtom* AsyncScrollLayerCreationFailed;
+static nsIAtom* forcemessagemanager;
+
+
+static nsIAtom* color_picker_available;
+static nsIAtom* scrollbar_start_backward;
+static nsIAtom* scrollbar_start_forward;
+static nsIAtom* scrollbar_end_backward;
+static nsIAtom* scrollbar_end_forward;
+static nsIAtom* scrollbar_thumb_proportional;
+static nsIAtom* overlay_scrollbars;
+static nsIAtom* windows_default_theme;
+static nsIAtom* mac_graphite_theme;
+static nsIAtom* mac_yosemite_theme;
+static nsIAtom* windows_compositor;
+static nsIAtom* windows_glass;
+static nsIAtom* touch_enabled;
+static nsIAtom* menubar_drag;
+static nsIAtom* swipe_animation_enabled;
+static nsIAtom* physical_home_button;
+
+
+static nsIAtom* windows_classic;
+static nsIAtom* windows_theme_aero;
+static nsIAtom* windows_theme_aero_lite;
+static nsIAtom* windows_theme_luna_blue;
+static nsIAtom* windows_theme_luna_olive;
+static nsIAtom* windows_theme_luna_silver;
+static nsIAtom* windows_theme_royale;
+static nsIAtom* windows_theme_zune;
+static nsIAtom* windows_theme_generic;
+
+
+static nsIAtom* _moz_color_picker_available;
+static nsIAtom* _moz_scrollbar_start_backward;
+static nsIAtom* _moz_scrollbar_start_forward;
+static nsIAtom* _moz_scrollbar_end_backward;
+static nsIAtom* _moz_scrollbar_end_forward;
+static nsIAtom* _moz_scrollbar_thumb_proportional;
+static nsIAtom* _moz_overlay_scrollbars;
+static nsIAtom* _moz_windows_default_theme;
+static nsIAtom* _moz_mac_graphite_theme;
+static nsIAtom* _moz_mac_yosemite_theme;
+static nsIAtom* _moz_windows_compositor;
+static nsIAtom* _moz_windows_classic;
+static nsIAtom* _moz_windows_glass;
+static nsIAtom* _moz_windows_theme;
+static nsIAtom* _moz_os_version;
+static nsIAtom* _moz_touch_enabled;
+static nsIAtom* _moz_menubar_drag;
+static nsIAtom* _moz_device_pixel_ratio;
+static nsIAtom* _moz_device_orientation;
+static nsIAtom* _moz_is_resource_document;
+static nsIAtom* _moz_swipe_animation_enabled;
+static nsIAtom* _moz_physical_home_button;
+
+
+static nsIAtom* Back;
+static nsIAtom* Forward;
+static nsIAtom* Reload;
+static nsIAtom* Stop;
+static nsIAtom* Search;
+static nsIAtom* Bookmarks;
+static nsIAtom* Home;
+static nsIAtom* Clear;
+static nsIAtom* VolumeUp;
+static nsIAtom* VolumeDown;
+static nsIAtom* NextTrack;
+static nsIAtom* PreviousTrack;
+static nsIAtom* MediaStop;
+static nsIAtom* PlayPause;
+static nsIAtom* Menu;
+static nsIAtom* New;
+static nsIAtom* Open;
+static nsIAtom* Close;
+static nsIAtom* Save;
+static nsIAtom* Find;
+static nsIAtom* Help;
+static nsIAtom* Print;
+static nsIAtom* SendMail;
+static nsIAtom* ForwardMail;
+static nsIAtom* ReplyToMail;
+
+
+
+
+
+
+static nsIAtom* mouseWheel;
+static nsIAtom* pixels;
+static nsIAtom* lines;
+static nsIAtom* pages;
+static nsIAtom* scrollbars;
+static nsIAtom* other;
+
+static nsIAtom* apz;
+static nsIAtom* restore;
+
+
+static nsIAtom* alert;
+static nsIAtom* alertdialog;
+static nsIAtom* application;
+static nsIAtom* aria_activedescendant;
+static nsIAtom* aria_atomic;
+static nsIAtom* aria_autocomplete;
+static nsIAtom* aria_busy;
+static nsIAtom* aria_checked;
+static nsIAtom* aria_colcount;
+static nsIAtom* aria_colindex;
+static nsIAtom* aria_controls;
+static nsIAtom* aria_describedby;
+static nsIAtom* aria_details;
+static nsIAtom* aria_disabled;
+static nsIAtom* aria_dropeffect;
+static nsIAtom* aria_errormessage;
+static nsIAtom* aria_expanded;
+static nsIAtom* aria_flowto;
+static nsIAtom* aria_grabbed;
+static nsIAtom* aria_haspopup;
+static nsIAtom* aria_hidden;
+static nsIAtom* aria_invalid;
+static nsIAtom* aria_label;
+static nsIAtom* aria_labelledby;
+static nsIAtom* aria_level;
+static nsIAtom* aria_live;
+static nsIAtom* aria_modal;
+static nsIAtom* aria_multiline;
+static nsIAtom* aria_multiselectable;
+static nsIAtom* aria_orientation;
+static nsIAtom* aria_owns;
+static nsIAtom* aria_posinset;
+static nsIAtom* aria_pressed;
+static nsIAtom* aria_readonly;
+static nsIAtom* aria_relevant;
+static nsIAtom* aria_required;
+static nsIAtom* aria_rowcount;
+static nsIAtom* aria_rowindex;
+static nsIAtom* aria_selected;
+static nsIAtom* aria_setsize;
+static nsIAtom* aria_sort;
+static nsIAtom* aria_valuenow;
+static nsIAtom* aria_valuemin;
+static nsIAtom* aria_valuemax;
+static nsIAtom* aria_valuetext;
+static nsIAtom* AreaFrame;
+static nsIAtom* auto_generated;
+static nsIAtom* banner;
+static nsIAtom* checkable;
+static nsIAtom* choices;
+static nsIAtom* columnheader;
+static nsIAtom* complementary;
+static nsIAtom* containerAtomic;
+static nsIAtom* containerBusy;
+static nsIAtom* containerLive;
+static nsIAtom* containerLiveRole;
+static nsIAtom* containerRelevant;
+static nsIAtom* contentinfo;
+static nsIAtom* cycles;
+static nsIAtom* datatable;
+static nsIAtom* eventFromInput;
+static nsIAtom* feed;
+static nsIAtom* grammar;
+static nsIAtom* gridcell;
+static nsIAtom* heading;
+static nsIAtom* hitregion;
+static nsIAtom* InlineBlockFrame;
+static nsIAtom* inlinevalue;
+static nsIAtom* invalid;
+static nsIAtom* item;
+static nsIAtom* itemset;
+static nsIAtom* lineNumber;
+static nsIAtom* linkedPanel;
+static nsIAtom* live;
+static nsIAtom* menuitemcheckbox;
+static nsIAtom* menuitemradio;
+static nsIAtom* mixed;
+static nsIAtom* multiline;
+static nsIAtom* navigation;
+static nsIAtom* polite;
+static nsIAtom* posinset;
+static nsIAtom* presentation;
+static nsIAtom* progressbar;
+static nsIAtom* region;
+static nsIAtom* rowgroup;
+static nsIAtom* rowheader;
+static nsIAtom* search;
+static nsIAtom* searchbox;
+static nsIAtom* select1;
+static nsIAtom* setsize;
+static nsIAtom* spelling;
+static nsIAtom* spinbutton;
+static nsIAtom* status;
+static nsIAtom* _switch;
+static nsIAtom* tableCellIndex;
+static nsIAtom* tablist;
+static nsIAtom* textIndent;
+static nsIAtom* textInputType;
+static nsIAtom* textLineThroughColor;
+static nsIAtom* textLineThroughStyle;
+static nsIAtom* textPosition;
+static nsIAtom* textUnderlineColor;
+static nsIAtom* textUnderlineStyle;
+static nsIAtom* timer;
+static nsIAtom* toolbarname;
+static nsIAtom* toolbarseparator;
+static nsIAtom* toolbarspacer;
+static nsIAtom* toolbarspring;
+static nsIAtom* treegrid;
+static nsIAtom* _undefined;
+static nsIAtom* xmlroles;
+
+
+static nsIAtom* close_fence;
+static nsIAtom* denominator;
+static nsIAtom* numerator;
+static nsIAtom* open_fence;
+static nsIAtom* overscript;
+static nsIAtom* presubscript;
+static nsIAtom* presuperscript;
+static nsIAtom* root_index;
+static nsIAtom* subscript;
+static nsIAtom* superscript;
+static nsIAtom* underscript;
+
+
+
+static nsIAtom* onaudiostart;
+static nsIAtom* onaudioend;
+static nsIAtom* onsoundstart;
+static nsIAtom* onsoundend;
+static nsIAtom* onspeechstart;
+static nsIAtom* onspeechend;
+static nsIAtom* onresult;
+static nsIAtom* onnomatch;
+static nsIAtom* onresume;
+static nsIAtom* onmark;
+static nsIAtom* onboundary;
+
+
+
+static nsIAtom* usercontextid;
+
+
+static nsIAtom* nsuri_xmlns;
+static nsIAtom* nsuri_xml;
+static nsIAtom* nsuri_xhtml;
+static nsIAtom* nsuri_xlink;
+static nsIAtom* nsuri_xslt;
+static nsIAtom* nsuri_xbl;
+static nsIAtom* nsuri_mathml;
+static nsIAtom* nsuri_rdf;
+static nsIAtom* nsuri_xul;
+static nsIAtom* nsuri_svg;
+
+
+static nsIAtom* onsourceopen;
+static nsIAtom* onsourceended;
+static nsIAtom* onsourceclosed;
+static nsIAtom* onupdatestart;
+static nsIAtom* onupdate;
+static nsIAtom* onupdateend;
+static nsIAtom* onaddsourcebuffer;
+static nsIAtom* onremovesourcebuffer;
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h" 2
+
+};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/domstubs.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/domstubs.h"
+class nsWrapperCache;
+typedef uint64_t DOMTimeStamp;
+
+typedef double DOMHighResTimeStamp;
+
+class nsIDOMAttr;
+
+class nsIDOMCDATASection;
+
+class nsIDOMCharacterData;
+
+class nsIDOMComment;
+
+class nsIDOMDOMImplementation;
+
+class nsIDOMDocument;
+
+class nsIDOMDocumentFragment;
+
+class nsIDOMDocumentType;
+
+class nsIDOMElement;
+
+class nsIDOMNode;
+
+class nsIDOMNodeList;
+
+class nsIDOMProcessingInstruction;
+
+class nsIDOMText;
+
+class nsIDOMClientRect;
+
+class nsIDOMClientRectList;
+
+class DOMException;
+
+class nsIDOMStyleSheetList;
+
+class nsIDOMStyleSheet;
+
+class nsIDOMMediaList;
+
+class nsIDOMWindow;
+
+class nsIDOMWindowCollection;
+
+class nsIDOMNavigator;
+
+class nsIDOMScreen;
+
+class nsIDOMEvent;
+
+class nsIDOMEventTarget;
+
+class nsIDOMEventListener;
+
+class nsIDOMHTMLElement;
+
+class nsIDOMHTMLFormElement;
+
+class nsIDOMHTMLCollection;
+
+class nsIDOMHTMLHeadElement;
+
+class nsIDOMCSSValue;
+
+class nsIDOMCSSPrimitiveValue;
+
+class nsIDOMCSSRule;
+
+class nsIDOMCSSRuleList;
+
+class nsIDOMCSSKeyframeRule;
+
+class nsIDOMCSSFontFeatureValuesRule;
+
+class nsIDOMCSSStyleSheet;
+
+class nsIDOMCSSStyleDeclaration;
+
+class nsIDOMCounter;
+
+class nsIDOMRect;
+
+class nsIDOMCSSStyleRule;
+
+class nsIDOMCSSStyleRuleCollection;
+
+class nsIDOMRange;
+
+class nsIDOMCrypto;
+
+class nsIDOMFontFace;
+
+class nsIDOMFontFaceList;
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h" 2
+
+
+
+
+
+
+class nsIVariant;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h"
+class nsIDOMNode : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    ELEMENT_NODE = 1U,
+    ATTRIBUTE_NODE = 2U,
+    TEXT_NODE = 3U,
+    CDATA_SECTION_NODE = 4U,
+    ENTITY_REFERENCE_NODE = 5U,
+    ENTITY_NODE = 6U,
+    PROCESSING_INSTRUCTION_NODE = 7U,
+    COMMENT_NODE = 8U,
+    DOCUMENT_NODE = 9U,
+    DOCUMENT_TYPE_NODE = 10U,
+    DOCUMENT_FRAGMENT_NODE = 11U,
+    NOTATION_NODE = 12U
+  };
+
+
+  virtual nsresult GetNodeName(nsAString & aNodeName) = 0;
+
+
+  virtual nsresult GetNodeValue(nsAString & aNodeValue) = 0;
+  virtual nsresult SetNodeValue(const nsAString & aNodeValue) = 0;
+
+
+  virtual nsresult GetNodeType(uint16_t *aNodeType) = 0;
+
+
+  virtual nsresult GetParentNode(nsIDOMNode * *aParentNode) = 0;
+
+
+  virtual nsresult GetChildNodes(nsIDOMNodeList * *aChildNodes) = 0;
+
+
+  virtual nsresult GetFirstChild(nsIDOMNode * *aFirstChild) = 0;
+
+
+  virtual nsresult GetLastChild(nsIDOMNode * *aLastChild) = 0;
+
+
+  virtual nsresult GetPreviousSibling(nsIDOMNode * *aPreviousSibling) = 0;
+
+
+  virtual nsresult GetNextSibling(nsIDOMNode * *aNextSibling) = 0;
+
+
+  virtual nsresult GetOwnerDocument(nsIDOMDocument * *aOwnerDocument) = 0;
+
+
+  virtual nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode * *_retval) = 0;
+
+
+  virtual nsresult HasChildNodes(bool *_retval) = 0;
+
+
+  virtual nsresult CloneNode(bool deep, uint8_t _argc, nsIDOMNode * *_retval) = 0;
+
+
+  virtual nsresult GetNamespaceURI(nsAString & aNamespaceURI) = 0;
+
+
+  virtual nsresult GetPrefix(nsAString & aPrefix) = 0;
+
+
+  virtual nsresult GetLocalName(nsAString & aLocalName) = 0;
+
+  enum {
+    DOCUMENT_POSITION_DISCONNECTED = 1U,
+    DOCUMENT_POSITION_PRECEDING = 2U,
+    DOCUMENT_POSITION_FOLLOWING = 4U,
+    DOCUMENT_POSITION_CONTAINS = 8U,
+    DOCUMENT_POSITION_CONTAINED_BY = 16U,
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32U
+  };
+
+
+  virtual nsresult GetTextContent(nsAString & aTextContent) = 0;
+  virtual nsresult SetTextContent(const nsAString & aTextContent) = 0;
+
+};
+
+  template<typename T> struct nsIDOMNode::COMTypeInfo<nsIDOMNode, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMNode::COMTypeInfo<nsIDOMNode, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcc35b412, 0x009b, 0x46a3, { 0x9b, 0xe0, 0x76, 0x44, 0x8f, 0x12, 0x54, 0x8d }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h" 1
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
+class nsIDataType : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    VTYPE_INT8 = 0U,
+    VTYPE_INT16 = 1U,
+    VTYPE_INT32 = 2U,
+    VTYPE_INT64 = 3U,
+    VTYPE_UINT8 = 4U,
+    VTYPE_UINT16 = 5U,
+    VTYPE_UINT32 = 6U,
+    VTYPE_UINT64 = 7U,
+    VTYPE_FLOAT = 8U,
+    VTYPE_DOUBLE = 9U,
+    VTYPE_BOOL = 10U,
+    VTYPE_CHAR = 11U,
+    VTYPE_WCHAR = 12U,
+    VTYPE_VOID = 13U,
+    VTYPE_ID = 14U,
+    VTYPE_DOMSTRING = 15U,
+    VTYPE_CHAR_STR = 16U,
+    VTYPE_WCHAR_STR = 17U,
+    VTYPE_INTERFACE = 18U,
+    VTYPE_INTERFACE_IS = 19U,
+    VTYPE_ARRAY = 20U,
+    VTYPE_STRING_SIZE_IS = 21U,
+    VTYPE_WSTRING_SIZE_IS = 22U,
+    VTYPE_UTF8STRING = 23U,
+    VTYPE_CSTRING = 24U,
+    VTYPE_ASTRING = 25U,
+    VTYPE_EMPTY_ARRAY = 254U,
+    VTYPE_EMPTY = 255U
+  };
+
+};
+
+  template<typename T> struct nsIDataType::COMTypeInfo<nsIDataType, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDataType::COMTypeInfo<nsIDataType, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4d12e540, 0x83d7, 0x11d5, { 0x90, 0xed, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
+# 123 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
+class nsIVariant : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetDataType(uint16_t *aDataType) = 0;
+
+
+  virtual nsresult GetAsInt8(uint8_t *_retval) = 0;
+
+
+  virtual nsresult GetAsInt16(int16_t *_retval) = 0;
+
+
+  virtual nsresult GetAsInt32(int32_t *_retval) = 0;
+
+
+  virtual nsresult GetAsInt64(int64_t *_retval) = 0;
+
+
+  virtual nsresult GetAsUint8(uint8_t *_retval) = 0;
+
+
+  virtual nsresult GetAsUint16(uint16_t *_retval) = 0;
+
+
+  virtual nsresult GetAsUint32(uint32_t *_retval) = 0;
+
+
+  virtual nsresult GetAsUint64(uint64_t *_retval) = 0;
+
+
+  virtual nsresult GetAsFloat(float *_retval) = 0;
+
+
+  virtual nsresult GetAsDouble(double *_retval) = 0;
+
+
+  virtual nsresult GetAsBool(bool *_retval) = 0;
+
+
+  virtual nsresult GetAsChar(char *_retval) = 0;
+
+
+  virtual nsresult GetAsWChar(char16_t *_retval) = 0;
+
+
+  virtual nsresult GetAsID(nsID *retval) = 0;
+
+
+  virtual nsresult GetAsAString(nsAString & _retval) = 0;
+
+
+  virtual nsresult GetAsDOMString(nsAString & _retval) = 0;
+
+
+  virtual nsresult GetAsACString(nsACString & _retval) = 0;
+
+
+  virtual nsresult GetAsAUTF8String(nsACString & _retval) = 0;
+
+
+  virtual nsresult GetAsString(char * *_retval) = 0;
+
+
+  virtual nsresult GetAsWString(char16_t * *_retval) = 0;
+
+
+  virtual nsresult GetAsISupports(nsISupports * *_retval) = 0;
+
+
+  virtual nsresult GetAsJSVal(JS::MutableHandleValue _retval) = 0;
+
+
+  virtual nsresult GetAsInterface(nsIID **iid, void **iface) = 0;
+
+
+  virtual nsresult GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) = 0;
+
+
+  virtual nsresult GetAsStringWithSize(uint32_t *size, char * *str) = 0;
+
+
+  virtual nsresult GetAsWStringWithSize(uint32_t *size, char16_t * *str) = 0;
+
+};
+
+  template<typename T> struct nsIVariant::COMTypeInfo<nsIVariant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIVariant::COMTypeInfo<nsIVariant, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x81e4c2de, 0xacac, 0x4ad6, { 0x90, 0x1a, 0xb5, 0xfb, 0x1b, 0x85, 0x1a, 0x0d }};
+# 539 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
+class nsIWritableVariant : public nsIVariant {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetWritable(bool *aWritable) = 0;
+  virtual nsresult SetWritable(bool aWritable) = 0;
+
+
+  virtual nsresult SetAsInt8(uint8_t aValue) = 0;
+
+
+  virtual nsresult SetAsInt16(int16_t aValue) = 0;
+
+
+  virtual nsresult SetAsInt32(int32_t aValue) = 0;
+
+
+  virtual nsresult SetAsInt64(int64_t aValue) = 0;
+
+
+  virtual nsresult SetAsUint8(uint8_t aValue) = 0;
+
+
+  virtual nsresult SetAsUint16(uint16_t aValue) = 0;
+
+
+  virtual nsresult SetAsUint32(uint32_t aValue) = 0;
+
+
+  virtual nsresult SetAsUint64(uint64_t aValue) = 0;
+
+
+  virtual nsresult SetAsFloat(float aValue) = 0;
+
+
+  virtual nsresult SetAsDouble(double aValue) = 0;
+
+
+  virtual nsresult SetAsBool(bool aValue) = 0;
+
+
+  virtual nsresult SetAsChar(char aValue) = 0;
+
+
+  virtual nsresult SetAsWChar(char16_t aValue) = 0;
+
+
+  virtual nsresult SetAsID(const nsID & aValue) = 0;
+
+
+  virtual nsresult SetAsAString(const nsAString & aValue) = 0;
+
+
+  virtual nsresult SetAsDOMString(const nsAString & aValue) = 0;
+
+
+  virtual nsresult SetAsACString(const nsACString & aValue) = 0;
+
+
+  virtual nsresult SetAsAUTF8String(const nsACString & aValue) = 0;
+
+
+  virtual nsresult SetAsString(const char * aValue) = 0;
+
+
+  virtual nsresult SetAsWString(const char16_t * aValue) = 0;
+
+
+  virtual nsresult SetAsISupports(nsISupports *aValue) = 0;
+
+
+  virtual nsresult SetAsInterface(const nsIID & iid, void *iface) = 0;
+
+
+  virtual nsresult SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) = 0;
+
+
+  virtual nsresult SetAsStringWithSize(uint32_t size, const char * str) = 0;
+
+
+  virtual nsresult SetAsWStringWithSize(uint32_t size, const char16_t * str) = 0;
+
+
+  virtual nsresult SetAsVoid(void) = 0;
+
+
+  virtual nsresult SetAsEmpty(void) = 0;
+
+
+  virtual nsresult SetAsEmptyArray(void) = 0;
+
+
+  virtual nsresult SetFromVariant(nsIVariant *aValue) = 0;
+
+};
+
+  template<typename T> struct nsIWritableVariant::COMTypeInfo<nsIWritableVariant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIWritableVariant::COMTypeInfo<nsIWritableVariant, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5586a590, 0x8c82, 0x11d5, { 0x90, 0xf3, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeInfoManager.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeInfoManager.h"
+class nsAString;
+class nsBindingManager;
+class nsIAtom;
+class nsIDocument;
+class nsIDOMDocumentType;
+class nsIPrincipal;
+struct PLHashEntry;
+struct PLHashTable;
+template<class T> struct already_AddRefed;
+
+namespace mozilla {
+namespace dom {
+class NodeInfo;
+}
+}
+
+
+
+class nsNodeInfoManager final
+{
+private:
+  ~nsNodeInfoManager();
+
+public:
+  nsNodeInfoManager();
+
+  void DeleteCycleCollectable(void) { delete this; } class cycleCollection : public nsCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsCycleCollectionParticipant(true) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsNodeInfoManager"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<nsNodeInfoManager>(n)->DeleteCycleCollectable(); } static nsNodeInfoManager* Downcast(void* s) { return DowncastCCParticipant<nsNodeInfoManager>(s); } static void* Upcast(nsNodeInfoManager *p) { return static_cast<void*>(p); } virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static nsCycleCollectionParticipant* GetParticipant() { return &nsNodeInfoManager::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsNodeInfoManager>::value, "Reference-counted class " "nsNodeInfoManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+
+
+
+
+  nsresult Init(nsIDocument *aDocument);
+
+
+
+
+
+  void DropDocumentReference();
+
+
+
+
+  already_AddRefed<mozilla::dom::NodeInfo>
+  GetNodeInfo(nsIAtom *aName, nsIAtom *aPrefix, int32_t aNamespaceID,
+              uint16_t aNodeType, nsIAtom* aExtraName = nullptr);
+  nsresult GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
+                       int32_t aNamespaceID, uint16_t aNodeType,
+                       mozilla::dom::NodeInfo** aNodeInfo);
+  nsresult GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
+                       const nsAString& aNamespaceURI, uint16_t aNodeType,
+                       mozilla::dom::NodeInfo** aNodeInfo);
+
+
+
+
+  already_AddRefed<mozilla::dom::NodeInfo> GetTextNodeInfo();
+
+
+
+
+  already_AddRefed<mozilla::dom::NodeInfo> GetCommentNodeInfo();
+
+
+
+
+  already_AddRefed<mozilla::dom::NodeInfo> GetDocumentNodeInfo();
+
+
+
+
+
+  nsIDocument* GetDocument() const
+  {
+    return mDocument;
+  }
+
+
+
+
+  nsIPrincipal *DocumentPrincipal() const {
+    do { } while(0);
+    return mPrincipal;
+  }
+
+  void RemoveNodeInfo(mozilla::dom::NodeInfo *aNodeInfo);
+
+  nsBindingManager* GetBindingManager() const
+  {
+    return mBindingManager;
+  }
+
+protected:
+  friend class nsDocument;
+  friend class nsXULPrototypeDocument;
+  friend nsresult NS_NewDOMDocumentType(nsIDOMDocumentType** ,
+                                        nsNodeInfoManager *,
+                                        nsIAtom *,
+                                        const nsAString& ,
+                                        const nsAString& ,
+                                        const nsAString& );
+
+
+
+
+  void SetDocumentPrincipal(nsIPrincipal *aPrincipal);
+
+private:
+  static int NodeInfoInnerKeyCompare(const void *key1, const void *key2);
+  static PLHashNumber GetNodeInfoInnerHashValue(const void *key);
+  static int DropNodeInfoDocument(PLHashEntry *he, int hashIndex,
+                                     void *arg);
+
+  PLHashTable *mNodeInfoHash;
+  nsIDocument * mDocument;
+  uint32_t mNonDocumentNodeInfos;
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCOMPtr<nsIPrincipal> mDefaultPrincipal;
+  mozilla::dom::NodeInfo * mTextNodeInfo;
+  mozilla::dom::NodeInfo * mCommentNodeInfo;
+  mozilla::dom::NodeInfo * mDocumentNodeInfo;
+  RefPtr<nsBindingManager> mBindingManager;
+  mozilla::dom::NodeInfo* mRecentlyUsedNodeInfos[31];
+};
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h" 1
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
+class nsIAtom;
+
+typedef void
+(*NSPropertyFunc)(void *aObject,
+                  nsIAtom *aPropertyName,
+                  void *aPropertyValue,
+                  void *aData);
+
+
+
+
+
+
+
+typedef NSPropertyFunc NSPropertyDtorFunc;
+class nsINode;
+class nsIFrame;
+
+class nsPropertyOwner
+{
+public:
+  nsPropertyOwner(const nsPropertyOwner& aOther) : mObject(aOther.mObject) {}
+
+
+
+
+               nsPropertyOwner(const nsINode* aObject) : mObject(aObject) {}
+               nsPropertyOwner(const nsIFrame* aObject) : mObject(aObject) {}
+
+  operator const void*() { return mObject; }
+  const void* get() { return mObject; }
+
+private:
+  const void* mObject;
+};
+
+class nsPropertyTable
+{
+ public:
+
+
+
+
+  void* GetProperty(const nsPropertyOwner& aObject,
+                    nsIAtom *aPropertyName,
+                    nsresult *aResult = nullptr)
+  {
+    return GetPropertyInternal(aObject, aPropertyName, false, aResult);
+  }
+# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
+  nsresult SetProperty(const nsPropertyOwner& aObject,
+                                   nsIAtom *aPropertyName,
+                                   void *aPropertyValue,
+                                   NSPropertyDtorFunc aDtor,
+                                   void *aDtorData,
+                                   bool aTransfer = false,
+                                   void **aOldValue = nullptr)
+  {
+    return SetPropertyInternal(aObject, aPropertyName, aPropertyValue,
+                               aDtor, aDtorData, aTransfer, aOldValue);
+  }
+
+
+
+
+
+  nsresult DeleteProperty(nsPropertyOwner aObject,
+                                      nsIAtom *aPropertyName);
+
+
+
+
+
+
+  void* UnsetProperty(const nsPropertyOwner& aObject,
+                      nsIAtom *aPropertyName,
+                      nsresult *aStatus = nullptr)
+  {
+    return GetPropertyInternal(aObject, aPropertyName, true, aStatus);
+  }
+
+
+
+
+
+  void DeleteAllPropertiesFor(nsPropertyOwner aObject);
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
+  nsresult
+    TransferOrDeleteAllPropertiesFor(nsPropertyOwner aObject,
+                                     nsPropertyTable *aOtherTable);
+
+
+
+
+
+
+  void Enumerate(nsPropertyOwner aObject,
+                             NSPropertyFunc aCallback, void *aData);
+
+
+
+
+
+
+  void EnumerateAll(NSPropertyFunc aCallback, void *aData);
+
+
+
+
+
+  void DeleteAllProperties();
+
+  nsPropertyTable() : mPropertyList(nullptr) {}
+  ~nsPropertyTable() {
+    DeleteAllProperties();
+  }
+
+
+
+
+
+
+  static void SupportsDtorFunc(void *aObject, nsIAtom *aPropertyName,
+                               void *aPropertyValue, void *aData);
+
+  class PropertyList;
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ private:
+  void DestroyPropertyList();
+  PropertyList* GetPropertyListFor(nsIAtom *aPropertyName) const;
+  void* GetPropertyInternal(nsPropertyOwner aObject,
+                                        nsIAtom *aPropertyName,
+                                        bool aRemove,
+                                        nsresult *aStatus);
+  nsresult SetPropertyInternal(nsPropertyOwner aObject,
+                                           nsIAtom *aPropertyName,
+                                           void *aPropertyValue,
+                                           NSPropertyDtorFunc aDtor,
+                                           void *aDtorData,
+                                           bool aTransfer,
+                                           void **aOldValue);
+
+  PropertyList *mPropertyList;
+};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+class nsTObserverArray_base
+{
+public:
+  typedef size_t index_type;
+  typedef size_t size_type;
+  typedef ptrdiff_t diff_type;
+
+protected:
+  class Iterator_base
+  {
+  protected:
+    friend class nsTObserverArray_base;
+
+    Iterator_base(index_type aPosition, Iterator_base* aNext)
+      : mPosition(aPosition)
+      , mNext(aNext)
+    {
+    }
+
+
+
+    index_type mPosition;
+
+
+    Iterator_base* mNext;
+  };
+
+  nsTObserverArray_base() : mIterators(nullptr) {}
+
+  ~nsTObserverArray_base()
+  {
+    do { } while(0);
+  }
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+  void AdjustIterators(index_type aModPos, diff_type aAdjustment);
+
+
+
+
+  void ClearIterators();
+
+  mutable Iterator_base* mIterators;
+};
+
+template<class T, size_t N>
+class nsAutoTObserverArray : protected nsTObserverArray_base
+{
+public:
+  typedef T elem_type;
+  typedef nsTArray<T> array_type;
+
+  nsAutoTObserverArray() {}
+
+
+
+
+
+
+  size_type Length() const { return mArray.Length(); }
+
+
+  bool IsEmpty() const { return mArray.IsEmpty(); }
+
+
+
+
+
+
+  elem_type& ElementAt(index_type aIndex)
+  {
+    return mArray.ElementAt(aIndex);
+  }
+
+
+  const elem_type& ElementAt(index_type aIndex) const
+  {
+    return mArray.ElementAt(aIndex);
+  }
+
+
+
+
+
+
+  elem_type& SafeElementAt(index_type aIndex, elem_type& aDef)
+  {
+    return mArray.SafeElementAt(aIndex, aDef);
+  }
+
+
+  const elem_type& SafeElementAt(index_type aIndex, const elem_type& aDef) const
+  {
+    return mArray.SafeElementAt(aIndex, aDef);
+  }
+# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+  template<class Item>
+  bool Contains(const Item& aItem) const
+  {
+    return IndexOf(aItem) != array_type::NoIndex;
+  }
+
+
+
+
+
+
+
+  template<class Item>
+  index_type IndexOf(const Item& aItem, index_type aStart = 0) const
+  {
+    return mArray.IndexOf(aItem, aStart);
+  }
+# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+  template<class Item>
+  elem_type* InsertElementAt(index_type aIndex, const Item& aItem)
+  {
+    elem_type* item = mArray.InsertElementAt(aIndex, aItem);
+    AdjustIterators(aIndex, 1);
+    return item;
+  }
+
+
+
+  elem_type* InsertElementAt(index_type aIndex)
+  {
+    elem_type* item = mArray.InsertElementAt(aIndex);
+    AdjustIterators(aIndex, 1);
+    return item;
+  }
+
+
+
+
+
+  template<class Item>
+  bool PrependElementUnlessExists(const Item& aItem)
+  {
+    if (Contains(aItem)) {
+      return true;
+    }
+
+    bool inserted = mArray.InsertElementAt(0, aItem) != nullptr;
+    AdjustIterators(0, 1);
+    return inserted;
+  }
+
+
+
+
+  template<class Item>
+  elem_type* AppendElement(const Item& aItem)
+  {
+    return mArray.AppendElement(aItem);
+  }
+
+
+
+  elem_type* AppendElement()
+  {
+    return mArray.AppendElement();
+  }
+
+
+
+
+
+  template<class Item>
+  bool AppendElementUnlessExists(const Item& aItem)
+  {
+    return Contains(aItem) || AppendElement(aItem) != nullptr;
+  }
+
+
+
+  void RemoveElementAt(index_type aIndex)
+  {
+    do { } while(0);
+    mArray.RemoveElementAt(aIndex);
+    AdjustIterators(aIndex, -1);
+  }
+
+
+
+
+
+
+  template<class Item>
+  bool RemoveElement(const Item& aItem)
+  {
+    index_type index = mArray.IndexOf(aItem, 0);
+    if (index == array_type::NoIndex) {
+      return false;
+    }
+
+    mArray.RemoveElementAt(index);
+    AdjustIterators(index, -1);
+    return true;
+  }
+
+
+  void RemoveElementsBy(std::function<bool(const elem_type&)> aPredicate)
+  {
+    index_type i = 0;
+    mArray.RemoveElementsBy([&](const elem_type& aItem) {
+      if (aPredicate(aItem)) {
+
+        AdjustIterators(i, -1);
+        return true;
+      }
+      ++i;
+      return false;
+    });
+  }
+
+
+
+
+  void Clear()
+  {
+    mArray.Clear();
+    ClearIterators();
+  }
+
+
+  void Compact() { mArray.Compact(); }
+
+
+
+
+
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+
+
+  class Iterator : public Iterator_base
+  {
+  protected:
+    friend class nsAutoTObserverArray;
+    typedef nsAutoTObserverArray<T, N> array_type;
+
+    Iterator(index_type aPosition, const array_type& aArray)
+      : Iterator_base(aPosition, aArray.mIterators)
+      , mArray(const_cast<array_type&>(aArray))
+    {
+      aArray.mIterators = this;
+    }
+
+    ~Iterator()
+    {
+      do { } while(0);
+
+
+
+      mArray.mIterators = mNext;
+    }
+
+
+    array_type& mArray;
+  };
+# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+  class ForwardIterator : protected Iterator
+  {
+  public:
+    typedef nsAutoTObserverArray<T, N> array_type;
+    typedef Iterator base_type;
+
+    explicit ForwardIterator(const array_type& aArray)
+      : Iterator(0, aArray)
+    {
+    }
+
+    ForwardIterator(const array_type& aArray, index_type aPos)
+      : Iterator(aPos, aArray)
+    {
+    }
+
+    bool operator<(const ForwardIterator& aOther) const
+    {
+      do { } while(0);
+
+      return base_type::mPosition < aOther.mPosition;
+    }
+
+
+
+
+    bool HasMore() const
+    {
+      return base_type::mPosition < base_type::mArray.Length();
+    }
+
+
+
+
+    elem_type& GetNext()
+    {
+      do { } while(0);
+      return base_type::mArray.ElementAt(base_type::mPosition++);
+    }
+  };
+
+
+
+  class EndLimitedIterator : protected ForwardIterator
+  {
+  public:
+    typedef nsAutoTObserverArray<T, N> array_type;
+    typedef Iterator base_type;
+
+    explicit EndLimitedIterator(const array_type& aArray)
+      : ForwardIterator(aArray)
+      , mEnd(aArray, aArray.Length())
+    {
+    }
+
+
+
+
+    bool HasMore() const { return *this < mEnd; }
+
+
+
+
+    elem_type& GetNext()
+    {
+      do { } while(0);
+      return base_type::mArray.ElementAt(base_type::mPosition++);
+    }
+
+  private:
+    ForwardIterator mEnd;
+  };
+# 407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
+  class BackwardIterator : protected Iterator
+  {
+  public:
+    typedef nsAutoTObserverArray<T, N> array_type;
+    typedef Iterator base_type;
+
+    explicit BackwardIterator(const array_type& aArray)
+      : Iterator(aArray.Length(), aArray)
+    {
+    }
+
+
+
+
+    bool HasMore() const { return base_type::mPosition > 0; }
+
+
+
+
+    elem_type& GetNext()
+    {
+      do { } while(0);
+      return base_type::mArray.ElementAt(--base_type::mPosition);
+    }
+
+
+
+
+    void Remove()
+    {
+      return base_type::mArray.RemoveElementAt(base_type::mPosition);
+    }
+  };
+
+protected:
+  AutoTArray<T, N> mArray;
+};
+
+template<class T>
+class nsTObserverArray : public nsAutoTObserverArray<T, 0>
+{
+public:
+  typedef nsAutoTObserverArray<T, 0> base_type;
+  typedef nsTObserverArray_base::size_type size_type;
+
+
+
+
+
+  nsTObserverArray() {}
+
+
+  explicit nsTObserverArray(size_type aCapacity)
+  {
+    base_type::mArray.SetCapacity(aCapacity);
+  }
+};
+
+template<typename T, size_t N>
+inline void
+ImplCycleCollectionUnlink(nsAutoTObserverArray<T, N>& aField)
+{
+  aField.Clear();
+}
+
+template<typename T, size_t N>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsAutoTObserverArray<T, N>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  aFlags |= CycleCollectionEdgeNameArrayFlag;
+  size_t length = aField.Length();
+  for (size_t i = 0; i < length; ++i) {
+    ImplCycleCollectionTraverse(aCallback, aField.ElementAt(i), aName, aFlags);
+  }
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h" 1
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+namespace IPC {
+class Message;
+template <typename> struct ParamTraits;
+}
+class PickleIterator;
+
+namespace mozilla {
+
+namespace dom {
+
+enum ErrNum {
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Errors.msg" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Errors.msg"
+MSG_INVALID_ENUM_VALUE,
+MSG_MISSING_ARGUMENTS,
+MSG_NOT_OBJECT,
+MSG_NOT_CALLABLE,
+MSG_NOT_CONSTRUCTOR,
+MSG_DOES_NOT_IMPLEMENT_INTERFACE,
+MSG_METHOD_THIS_DOES_NOT_IMPLEMENT_INTERFACE,
+MSG_METHOD_THIS_UNWRAPPING_DENIED,
+MSG_THIS_DOES_NOT_IMPLEMENT_INTERFACE,
+MSG_NOT_IN_UNION,
+MSG_ILLEGAL_CONSTRUCTOR,
+MSG_CONSTRUCTOR_WITHOUT_NEW,
+MSG_ENFORCE_RANGE_NON_FINITE,
+MSG_ENFORCE_RANGE_OUT_OF_RANGE,
+MSG_NOT_SEQUENCE,
+MSG_NOT_DICTIONARY,
+MSG_OVERLOAD_RESOLUTION_FAILED,
+MSG_GLOBAL_NOT_NATIVE,
+MSG_ENCODING_NOT_SUPPORTED,
+MSG_DOM_ENCODING_NOT_UTF,
+MSG_DOM_DECODING_FAILED,
+MSG_NOT_FINITE,
+MSG_INVALID_VERSION,
+MSG_INVALID_BYTESTRING,
+
+MSG_NOT_DATE,
+MSG_INVALID_ADVANCE_COUNT,
+MSG_DEFINEPROPERTY_ON_GSP,
+MSG_INVALID_URL,
+MSG_URL_HAS_CREDENTIALS,
+MSG_METADATA_NOT_CONFIGURED,
+MSG_INVALID_READ_SIZE,
+MSG_HEADERS_IMMUTABLE,
+MSG_INVALID_HEADER_NAME,
+MSG_INVALID_HEADER_VALUE,
+MSG_INVALID_HEADER_SEQUENCE,
+MSG_PERMISSION_DENIED_TO_PASS_ARG,
+MSG_MISSING_REQUIRED_DICTIONARY_MEMBER,
+MSG_REQUEST_INTEGRITY_METADATA_NOT_EMPTY,
+MSG_INVALID_REQUEST_METHOD,
+MSG_INVALID_REQUEST_MODE,
+MSG_INVALID_REFERRER_URL,
+MSG_CROSS_ORIGIN_REFERRER_URL,
+MSG_FETCH_BODY_CONSUMED_ERROR,
+MSG_RESPONSE_INVALID_STATUSTEXT_ERROR,
+MSG_FETCH_FAILED,
+MSG_NO_BODY_ALLOWED_FOR_GET_AND_HEAD,
+MSG_RESPONSE_NULL_STATUS_WITH_BODY,
+MSG_DEFINE_NON_CONFIGURABLE_PROP_ON_WINDOW,
+MSG_INVALID_ZOOMANDPAN_VALUE_ERROR,
+MSG_INVALID_TRANSFORM_ANGLE_ERROR,
+MSG_INVALID_RESPONSE_STATUSCODE_ERROR,
+MSG_INVALID_REDIRECT_STATUSCODE_ERROR,
+MSG_INVALID_URL_SCHEME,
+MSG_RESPONSE_URL_IS_NULL,
+MSG_RESPONSE_HAS_VARY_STAR,
+MSG_BAD_FORMDATA,
+MSG_NO_ACTIVE_WORKER,
+MSG_NOTIFICATION_PERMISSION_DENIED,
+MSG_NOTIFICATION_NO_CONSTRUCTOR_IN_SERVICEWORKER,
+MSG_INVALID_SCOPE,
+MSG_INVALID_KEYFRAME_OFFSETS,
+MSG_IS_NOT_PROMISE,
+MSG_SW_INSTALL_ERROR,
+MSG_SW_SCRIPT_THREW,
+MSG_TYPEDARRAY_IS_SHARED,
+MSG_TYPEDARRAY_IS_DETACHED,
+MSG_CACHE_ADD_FAILED_RESPONSE,
+MSG_SW_UPDATE_BAD_REGISTRATION,
+MSG_INVALID_DURATION_ERROR,
+MSG_INVALID_EASING_ERROR,
+MSG_INVALID_SPACING_MODE_ERROR,
+MSG_USELESS_SETTIMEOUT,
+MSG_TOKENLIST_NO_SUPPORTED_TOKENS,
+MSG_CACHE_STREAM_CLOSED,
+MSG_TIME_VALUE_OUT_OF_RANGE,
+MSG_ONLY_IF_CACHED_WITHOUT_SAME_ORIGIN,
+MSG_THRESHOLD_RANGE_ERROR,
+MSG_WORKER_THREAD_SHUTTING_DOWN,
+MSG_CACHE_OPEN_FAILED,
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h" 2
+
+  Err_Limit
+};
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+uint16_t
+GetErrorArgCount(const ErrNum aErrorNumber);
+
+namespace binding_detail {
+void ThrowErrorMessage(JSContext* aCx, const unsigned aErrorNumber, ...);
+}
+
+template<typename... Ts>
+inline bool
+ThrowErrorMessage(JSContext* aCx, const ErrNum aErrorNumber, Ts&&... aArgs)
+{
+  binding_detail::ThrowErrorMessage(aCx, static_cast<const unsigned>(aErrorNumber),
+                                    mozilla::Forward<Ts>(aArgs)...);
+  return false;
+}
+
+struct StringArrayAppender
+{
+  static void Append(nsTArray<nsString>& aArgs, uint16_t aCount)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount == 0))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount == 0" ") (" "Must give at least as many string arguments as are required by the ErrNum." ")"); do { *((volatile int*) __null) = 87; ::abort(); } while (0); } } while (0);
+  }
+
+  template<typename... Ts>
+  static void Append(nsTArray<nsString>& aArgs, uint16_t aCount, const nsAString& aFirst, Ts&&... aOtherArgs)
+  {
+    if (aCount == 0) {
+      do { } while (0);
+      return;
+    }
+    aArgs.AppendElement(aFirst);
+    Append(aArgs, aCount - 1, Forward<Ts>(aOtherArgs)...);
+  }
+};
+
+}
+
+class ErrorResult;
+class OOMReporter;
+
+namespace binding_danger {
+# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+template<typename CleanupPolicy>
+class TErrorResult {
+public:
+  TErrorResult()
+    : mResult(NS_OK)
+
+
+
+
+  {
+  }
+
+  ~TErrorResult() {
+    AssertInOwningThread();
+
+    if (CleanupPolicy::assertHandled) {
+
+
+      AssertReportedOrSuppressed();
+    }
+
+    if (CleanupPolicy::suppress) {
+      SuppressException();
+    }
+
+
+    AssertReportedOrSuppressed();
+  }
+
+  TErrorResult(TErrorResult&& aRHS)
+
+
+
+    : TErrorResult()
+  {
+    *this = Move(aRHS);
+  }
+  TErrorResult& operator=(TErrorResult&& aRHS);
+
+  explicit TErrorResult(nsresult aRv)
+    : TErrorResult()
+  {
+    AssignErrorCode(aRv);
+  }
+
+  operator ErrorResult&();
+  operator OOMReporter&();
+
+  void Throw(nsresult rv) {
+    do { } while (0);
+    AssignErrorCode(rv);
+  }
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  void ThrowWithCustomCleanup(nsresult rv) {
+    Throw(rv);
+  }
+
+
+
+
+  void CloneTo(TErrorResult& aRv) const;
+
+
+
+
+  void SuppressException();
+
+
+
+
+  nsresult StealNSResult() {
+    nsresult rv = ErrorCode();
+    SuppressException();
+
+    if (rv == NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR ||
+        rv == NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR ||
+        rv == NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION ||
+        rv == NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION) {
+
+      return NS_ERROR_DOM_INVALID_STATE_ERR;
+    }
+
+    return rv;
+  }
+# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  bool MaybeSetPendingException(JSContext* cx)
+  {
+    WouldReportJSException();
+    if (!Failed()) {
+      return false;
+    }
+
+    SetPendingException(cx);
+    return true;
+  }
+# 286 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  void StealExceptionFromJSContext(JSContext* cx);
+
+  template<dom::ErrNum errorNumber, typename... Ts>
+  void ThrowTypeError(Ts&&... messageArgs)
+  {
+    ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR,
+                                       Forward<Ts>(messageArgs)...);
+  }
+
+  template<dom::ErrNum errorNumber, typename... Ts>
+  void ThrowRangeError(Ts&&... messageArgs)
+  {
+    ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR,
+                                       Forward<Ts>(messageArgs)...);
+  }
+
+  bool IsErrorWithMessage() const
+  {
+    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR ||
+           ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR;
+  }
+# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  void ThrowJSException(JSContext* cx, JS::Handle<JS::Value> exn);
+  bool IsJSException() const
+  {
+    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION;
+  }
+
+
+
+
+
+
+  void ThrowDOMException(nsresult rv, const nsACString& message = EmptyCString());
+  bool IsDOMException() const
+  {
+    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION;
+  }
+
+
+
+
+  void NoteJSContextException(JSContext* aCx);
+
+
+
+  bool IsJSContextException() {
+    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT;
+  }
+
+
+  void ThrowUncatchableException() {
+    Throw(NS_ERROR_UNCATCHABLE_EXCEPTION);
+  }
+  bool IsUncatchableException() const {
+    return ErrorCode() == NS_ERROR_UNCATCHABLE_EXCEPTION;
+  }
+
+  void __attribute__((always_inline)) inline MightThrowJSException()
+  {
+
+
+
+  }
+  void __attribute__((always_inline)) inline WouldReportJSException()
+  {
+
+
+
+  }
+# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  void operator=(nsresult rv) {
+    AssignErrorCode(rv);
+  }
+
+  bool Failed() const {
+    return ((bool)(__builtin_expect(!!(NS_FAILED_impl(mResult)), 0)));
+  }
+
+  bool ErrorCodeIs(nsresult rv) const {
+    return mResult == rv;
+  }
+
+
+  uint32_t ErrorCodeAsInt() const {
+    return static_cast<uint32_t>(ErrorCode());
+  }
+
+protected:
+  nsresult ErrorCode() const {
+    return mResult;
+  }
+
+private:
+# 406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  friend struct IPC::ParamTraits<TErrorResult>;
+  friend struct IPC::ParamTraits<ErrorResult>;
+  void SerializeMessage(IPC::Message* aMsg) const;
+  bool DeserializeMessage(const IPC::Message* aMsg, PickleIterator* aIter);
+
+  void SerializeDOMExceptionInfo(IPC::Message* aMsg) const;
+  bool DeserializeDOMExceptionInfo(const IPC::Message* aMsg, PickleIterator* aIter);
+
+
+
+  nsTArray<nsString>& CreateErrorMessageHelper(const dom::ErrNum errorNumber, nsresult errorType);
+
+  template<dom::ErrNum errorNumber, typename... Ts>
+  void ThrowErrorWithMessage(nsresult errorType, Ts&&... messageArgs)
+  {
+
+
+
+
+
+    ClearUnionData();
+
+    nsTArray<nsString>& messageArgsArray = CreateErrorMessageHelper(errorNumber, errorType);
+    uint16_t argCount = dom::GetErrorArgCount(errorNumber);
+    dom::StringArrayAppender::Append(messageArgsArray, argCount,
+                                     Forward<Ts>(messageArgs)...);
+
+
+
+  }
+
+  __attribute__((always_inline)) inline void AssertInOwningThread() const {
+
+
+
+  }
+
+  void AssignErrorCode(nsresult aRv) {
+    do { } while (0);
+
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+
+    mResult = aRv;
+  }
+
+  void ClearMessage();
+  void ClearDOMExceptionInfo();
+
+
+
+
+
+
+
+  void ClearUnionData();
+
+
+
+  void SetPendingException(JSContext* cx);
+
+
+  void SetPendingExceptionWithMessage(JSContext* cx);
+  void SetPendingJSException(JSContext* cx);
+  void SetPendingDOMException(JSContext* cx);
+  void SetPendingGenericErrorException(JSContext* cx);
+
+  __attribute__((always_inline)) inline void AssertReportedOrSuppressed()
+  {
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+  }
+# 497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  nsresult mResult;
+
+  struct Message;
+  struct DOMExceptionInfo;
+
+
+
+
+
+
+  union {
+    Message* mMessage;
+    JS::Value mJSException;
+    DOMExceptionInfo* mDOMExceptionInfo;
+  };
+# 530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+  TErrorResult(const TErrorResult&) = delete;
+  void operator=(const TErrorResult&) = delete;
+};
+
+struct JustAssertCleanupPolicy {
+  static const bool assertHandled = true;
+  static const bool suppress = false;
+};
+
+struct AssertAndSuppressCleanupPolicy {
+  static const bool assertHandled = true;
+  static const bool suppress = true;
+};
+
+struct JustSuppressCleanupPolicy {
+  static const bool assertHandled = false;
+  static const bool suppress = true;
+};
+
+}
+
+
+
+class ErrorResult :
+    public binding_danger::TErrorResult<binding_danger::AssertAndSuppressCleanupPolicy>
+{
+  typedef binding_danger::TErrorResult<binding_danger::AssertAndSuppressCleanupPolicy> BaseErrorResult;
+
+public:
+  ErrorResult()
+    : BaseErrorResult()
+  {}
+
+  ErrorResult(ErrorResult&& aRHS)
+    : BaseErrorResult(Move(aRHS))
+  {}
+
+  explicit ErrorResult(nsresult aRv)
+    : BaseErrorResult(aRv)
+  {}
+
+  void operator=(nsresult rv)
+  {
+    BaseErrorResult::operator=(rv);
+  }
+
+  ErrorResult& operator=(ErrorResult&& aRHS)
+  {
+    BaseErrorResult::operator=(Move(aRHS));
+    return *this;
+  }
+
+private:
+
+
+  ErrorResult(const ErrorResult&) = delete;
+  void operator=(const ErrorResult&) = delete;
+};
+
+template<typename CleanupPolicy>
+binding_danger::TErrorResult<CleanupPolicy>::operator ErrorResult&()
+{
+  return *static_cast<ErrorResult*>(
+     reinterpret_cast<TErrorResult<AssertAndSuppressCleanupPolicy>*>(this));
+}
+
+
+
+
+class IgnoredErrorResult :
+    public binding_danger::TErrorResult<binding_danger::JustSuppressCleanupPolicy>
+{
+};
+
+namespace dom {
+namespace binding_detail {
+class FastErrorResult :
+    public mozilla::binding_danger::TErrorResult<
+      mozilla::binding_danger::JustAssertCleanupPolicy>
+{
+};
+}
+}
+# 627 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+namespace binding_danger {
+class OOMReporterInstantiator;
+}
+
+class OOMReporter : private dom::binding_detail::FastErrorResult
+{
+public:
+  void ReportOOM()
+  {
+    Throw(NS_ERROR_OUT_OF_MEMORY);
+  }
+
+private:
+
+
+  friend class binding_danger::OOMReporterInstantiator;
+
+
+  template<typename CleanupPolicy>
+  friend class binding_danger::TErrorResult;
+
+  OOMReporter()
+    : dom::binding_detail::FastErrorResult()
+  {
+  }
+};
+
+namespace binding_danger {
+class OOMReporterInstantiator : public OOMReporter
+{
+public:
+  OOMReporterInstantiator()
+    : OOMReporter()
+  {
+  }
+
+
+
+
+  bool MaybeSetPendingException(JSContext* cx)
+  {
+    return OOMReporter::MaybeSetPendingException(cx);
+  }
+};
+}
+
+template<typename CleanupPolicy>
+binding_danger::TErrorResult<CleanupPolicy>::operator OOMReporter&()
+{
+  return *static_cast<OOMReporter*>(
+     reinterpret_cast<TErrorResult<JustAssertCleanupPolicy>*>(this));
+}
+# 706 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h"
+class nsCString;
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h"
+enum nsEventStatus
+{
+
+  nsEventStatus_eIgnore,
+
+  nsEventStatus_eConsumeNoDefault,
+
+  nsEventStatus_eConsumeDoDefault,
+
+  nsEventStatus_eSentinel
+};
+
+namespace mozilla {
+
+
+
+
+
+typedef uint16_t EventMessageType;
+
+enum EventMessage : EventMessageType
+{
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventMessageList.h" 1
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventMessageList.h"
+eVoidEvent,
+
+
+
+eAllEvents,
+
+
+eWindowClose,
+
+eKeyPress,
+eKeyUp,
+eKeyDown,
+
+
+
+
+
+eKeyDownOnPlugin,
+eKeyUpOnPlugin,
+
+
+
+
+
+eAccessKeyNotFound,
+
+eResize,
+eScroll,
+
+
+eInstall,
+eAppInstalled,
+
+
+
+
+
+ePluginActivate,
+ePluginFocus,
+
+eOffline,
+eOnline,
+
+eLanguageChange,
+
+eMouseMove,
+eMouseUp,
+eMouseDown,
+eMouseEnterIntoWidget,
+eMouseExitFromWidget,
+eMouseDoubleClick,
+eMouseClick,
+eMouseAuxClick,
+
+eMouseActivate,
+eMouseOver,
+eMouseOut,
+eMouseHitTest,
+eMouseEnter,
+eMouseLeave,
+eMouseTouchDrag,
+eMouseLongTap,
+eMouseEventFirst = eMouseMove, eMouseEventLast = eMouseLongTap,
+
+
+ePointerMove,
+ePointerUp,
+ePointerDown,
+ePointerOver,
+ePointerOut,
+ePointerEnter,
+ePointerLeave,
+ePointerCancel,
+ePointerGotCapture,
+ePointerLostCapture,
+ePointerEventFirst = ePointerMove, ePointerEventLast = ePointerLostCapture,
+
+eContextMenu,
+
+eLoad,
+eUnload,
+eHashChange,
+eImageAbort,
+eLoadError,
+eLoadEnd,
+ePopState,
+eStorage,
+eBeforeUnload,
+eReadyStateChange,
+
+eFormSubmit,
+eFormReset,
+eFormChange,
+eFormSelect,
+eFormInvalid,
+
+
+eFocus,
+eBlur,
+eFocusIn,
+eFocusOut,
+
+eDragEnter,
+eDragOver,
+eDragExit,
+eDrag,
+eDragEnd,
+eDragStart,
+eDrop,
+eDragLeave,
+eDragDropEventFirst = eDragEnter, eDragDropEventLast = eDragLeave,
+
+
+eXULPopupShowing,
+eXULPopupShown,
+eXULPopupPositioned,
+eXULPopupHiding,
+eXULPopupHidden,
+eXULBroadcast,
+eXULCommandUpdate,
+
+
+eLegacyMouseLineOrPageScroll,
+eLegacyMousePixelScroll,
+
+eScrollPortUnderflow,
+eScrollPortOverflow,
+
+eLegacySubtreeModified,
+eLegacyNodeInserted,
+eLegacyNodeRemoved,
+eLegacyNodeRemovedFromDocument,
+eLegacyNodeInsertedIntoDocument,
+eLegacyAttrModified,
+eLegacyCharacterDataModified,
+eLegacyMutationEventFirst = eLegacySubtreeModified, eLegacyMutationEventLast = eLegacyCharacterDataModified,
+
+
+eUnidentifiedEvent,
+
+
+eCompositionStart,
+
+
+
+eCompositionEnd,
+
+
+
+
+eCompositionUpdate,
+
+
+
+
+eCompositionChange,
+
+
+
+
+
+
+eCompositionCommitAsIs,
+
+
+
+
+
+eCompositionCommit,
+
+
+
+
+eLegacyDOMActivate,
+
+eLegacyDOMFocusIn,
+
+eLegacyDOMFocusOut,
+
+
+ePageShow,
+ePageHide,
+
+
+eSVGLoad,
+eSVGUnload,
+eSVGResize,
+eSVGScroll,
+
+
+eSVGZoom,
+
+
+eXULCommand,
+
+
+eCopy,
+eCut,
+ePaste,
+ePasteNoFormatting,
+
+
+
+eQuerySelectedText,
+
+
+
+eQueryTextContent,
+
+
+eQueryCaretRect,
+
+
+
+eQueryTextRect,
+
+
+eQueryTextRectArray,
+
+
+eQueryEditorRect,
+
+
+eQueryContentState,
+
+eQuerySelectionAsTransferable,
+
+
+
+eQueryCharacterAtPoint,
+
+
+eQueryDOMWidgetHittest,
+
+
+eLoadStart,
+eProgress,
+eSuspend,
+eEmptied,
+eStalled,
+ePlay,
+ePause,
+eLoadedMetaData,
+eLoadedData,
+eWaiting,
+ePlaying,
+eCanPlay,
+eCanPlayThrough,
+eSeeking,
+eSeeked,
+eTimeUpdate,
+eEnded,
+eRateChange,
+eDurationChange,
+eVolumeChange,
+
+
+eAfterPaint,
+
+
+eSwipeGestureMayStart,
+eSwipeGestureStart,
+eSwipeGestureUpdate,
+eSwipeGestureEnd,
+eSwipeGesture,
+eMagnifyGestureStart,
+eMagnifyGestureUpdate,
+eMagnifyGesture,
+eRotateGestureStart,
+eRotateGestureUpdate,
+eRotateGesture,
+eTapGesture,
+ePressTapGesture,
+eEdgeUIStarted,
+eEdgeUICanceled,
+eEdgeUICompleted,
+
+
+ePluginInputEvent,
+
+
+
+eSetSelection,
+
+
+eContentCommandCut,
+eContentCommandCopy,
+eContentCommandPaste,
+eContentCommandDelete,
+eContentCommandUndo,
+eContentCommandRedo,
+eContentCommandPasteTransferable,
+eContentCommandLookUpDictionary,
+
+
+
+
+
+
+eContentCommandScroll,
+
+
+eGestureNotify,
+
+eScrolledAreaChanged,
+
+
+eTransitionStart,
+eTransitionRun,
+eTransitionEnd,
+eTransitionCancel,
+eAnimationStart,
+eAnimationEnd,
+eAnimationIteration,
+eAnimationCancel,
+
+
+eWebkitTransitionEnd,
+eWebkitAnimationStart,
+eWebkitAnimationEnd,
+eWebkitAnimationIteration,
+
+eSMILBeginEvent,
+eSMILEndEvent,
+eSMILRepeatEvent,
+
+eAudioProcess,
+eAudioComplete,
+
+
+eBeforeScriptExecute,
+eAfterScriptExecute,
+
+eBeforePrint,
+eAfterPrint,
+
+eMessage,
+
+
+eOpen,
+
+
+eDeviceOrientation,
+eAbsoluteDeviceOrientation,
+eDeviceMotion,
+eDeviceProximity,
+eUserProximity,
+eDeviceLight,
+
+
+
+
+
+eVRDisplayActivate,
+eVRDisplayDeactivate,
+eVRDisplayConnect,
+eVRDisplayDisconnect,
+eVRDisplayPresentChange,
+
+eShow,
+
+
+eFullscreenChange,
+eFullscreenError,
+eMozFullscreenChange,
+eMozFullscreenError,
+
+eTouchStart,
+eTouchMove,
+eTouchEnd,
+eTouchCancel,
+eTouchPointerCancel,
+
+
+ePointerLockChange,
+ePointerLockError,
+eMozPointerLockChange,
+eMozPointerLockError,
+
+
+eWheel,
+
+
+
+eWheelOperationStart,
+
+
+
+eWheelOperationEnd,
+
+
+eTimeChange,
+
+
+eNetworkUpload,
+eNetworkDownload,
+
+
+eMediaRecorderDataAvailable,
+eMediaRecorderWarning,
+eMediaRecorderStop,
+
+
+eGamepadButtonDown,
+eGamepadButtonUp,
+eGamepadAxisMove,
+eGamepadConnected,
+eGamepadDisconnected,
+eGamepadEventFirst = eGamepadButtonDown, eGamepadEventLast = eGamepadDisconnected,
+
+
+
+eEditorInput,
+
+
+eSelectStart,
+eSelectionChange,
+
+
+eToggle,
+
+
+eClose,
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+
+
+
+
+
+  eEventMessage_MaxValue
+};
+
+const char* ToChar(EventMessage aEventMessage);
+
+
+
+
+
+typedef uint8_t EventClassIDType;
+
+enum EventClassID : EventClassIDType
+{
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h"
+eBasicEventClass
+, eGUIEventClass
+, eInputEventClass
+, eUIEventClass
+
+
+, eKeyboardEventClass
+, eCompositionEventClass
+, eQueryContentEventClass
+, eSelectionEventClass
+, eEditorInputEventClass
+
+
+, eMouseEventBaseClass
+, eMouseEventClass
+, eDragEventClass
+, eMouseScrollEventClass
+, eWheelEventClass
+, ePointerEventClass
+
+
+, eGestureNotifyEventClass
+, eSimpleGestureEventClass
+, eTouchEventClass
+
+
+, eScrollPortEventClass
+, eScrollAreaEventClass
+, eFormEventClass
+, eClipboardEventClass
+, eFocusEventClass
+, eTransitionEventClass
+, eAnimationEventClass
+, eSMILTimeEventClass
+
+
+, eCommandEventClass
+, eContentCommandEventClass
+, ePluginEventClass
+
+
+, eMutationEventClass
+# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+
+
+
+};
+
+const char* ToChar(EventClassID aEventClassID);
+
+typedef uint16_t Modifiers;
+
+
+
+
+typedef uint16_t KeyNameIndexType;
+enum KeyNameIndex : KeyNameIndexType
+{
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h"
+KEY_NAME_INDEX_Unidentified,
+
+
+
+
+KEY_NAME_INDEX_PrintableKey,
+KEY_NAME_INDEX_SoftLeft,
+KEY_NAME_INDEX_SoftRight,
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h"
+KEY_NAME_INDEX_Alt,
+KEY_NAME_INDEX_AltGraph,
+KEY_NAME_INDEX_CapsLock,
+KEY_NAME_INDEX_Control,
+KEY_NAME_INDEX_Fn,
+KEY_NAME_INDEX_FnLock,
+KEY_NAME_INDEX_Hyper,
+KEY_NAME_INDEX_Meta,
+KEY_NAME_INDEX_NumLock,
+KEY_NAME_INDEX_OS,
+KEY_NAME_INDEX_ScrollLock,
+KEY_NAME_INDEX_Shift,
+KEY_NAME_INDEX_Super,
+KEY_NAME_INDEX_Symbol,
+KEY_NAME_INDEX_SymbolLock,
+
+
+
+
+KEY_NAME_INDEX_Enter,
+KEY_NAME_INDEX_Tab,
+
+
+
+
+KEY_NAME_INDEX_ArrowDown,
+KEY_NAME_INDEX_ArrowLeft,
+KEY_NAME_INDEX_ArrowRight,
+KEY_NAME_INDEX_ArrowUp,
+KEY_NAME_INDEX_End,
+KEY_NAME_INDEX_Home,
+KEY_NAME_INDEX_PageDown,
+KEY_NAME_INDEX_PageUp,
+
+
+
+
+KEY_NAME_INDEX_Backspace,
+KEY_NAME_INDEX_Clear,
+KEY_NAME_INDEX_Copy,
+KEY_NAME_INDEX_CrSel,
+KEY_NAME_INDEX_Cut,
+KEY_NAME_INDEX_Delete,
+KEY_NAME_INDEX_EraseEof,
+KEY_NAME_INDEX_ExSel,
+KEY_NAME_INDEX_Insert,
+KEY_NAME_INDEX_Paste,
+KEY_NAME_INDEX_Redo,
+KEY_NAME_INDEX_Undo,
+
+
+
+
+KEY_NAME_INDEX_Accept,
+KEY_NAME_INDEX_Again,
+KEY_NAME_INDEX_Attn,
+KEY_NAME_INDEX_Cancel,
+KEY_NAME_INDEX_ContextMenu,
+KEY_NAME_INDEX_Escape,
+KEY_NAME_INDEX_Execute,
+KEY_NAME_INDEX_Find,
+KEY_NAME_INDEX_Help,
+KEY_NAME_INDEX_Pause,
+KEY_NAME_INDEX_Play,
+KEY_NAME_INDEX_Props,
+KEY_NAME_INDEX_Select,
+KEY_NAME_INDEX_ZoomIn,
+KEY_NAME_INDEX_ZoomOut,
+
+
+
+
+KEY_NAME_INDEX_BrightnessDown,
+KEY_NAME_INDEX_BrightnessUp,
+KEY_NAME_INDEX_Eject,
+KEY_NAME_INDEX_LogOff,
+KEY_NAME_INDEX_Power,
+KEY_NAME_INDEX_PowerOff,
+KEY_NAME_INDEX_PrintScreen,
+KEY_NAME_INDEX_Hibernate,
+KEY_NAME_INDEX_Standby,
+KEY_NAME_INDEX_WakeUp,
+
+
+
+
+KEY_NAME_INDEX_AllCandidates,
+KEY_NAME_INDEX_Alphanumeric,
+KEY_NAME_INDEX_CodeInput,
+KEY_NAME_INDEX_Compose,
+KEY_NAME_INDEX_Convert,
+KEY_NAME_INDEX_Dead,
+KEY_NAME_INDEX_FinalMode,
+KEY_NAME_INDEX_GroupFirst,
+KEY_NAME_INDEX_GroupLast,
+KEY_NAME_INDEX_GroupNext,
+KEY_NAME_INDEX_GroupPrevious,
+KEY_NAME_INDEX_ModeChange,
+KEY_NAME_INDEX_NextCandidate,
+KEY_NAME_INDEX_NonConvert,
+KEY_NAME_INDEX_PreviousCandidate,
+KEY_NAME_INDEX_Process,
+KEY_NAME_INDEX_SingleCandidate,
+
+
+
+
+KEY_NAME_INDEX_HangulMode,
+KEY_NAME_INDEX_HanjaMode,
+KEY_NAME_INDEX_JunjaMode,
+
+
+
+
+KEY_NAME_INDEX_Eisu,
+KEY_NAME_INDEX_Hankaku,
+KEY_NAME_INDEX_Hiragana,
+KEY_NAME_INDEX_HiraganaKatakana,
+KEY_NAME_INDEX_KanaMode,
+KEY_NAME_INDEX_KanjiMode,
+KEY_NAME_INDEX_Katakana,
+KEY_NAME_INDEX_Romaji,
+KEY_NAME_INDEX_Zenkaku,
+KEY_NAME_INDEX_ZenkakuHankaku,
+
+
+
+
+KEY_NAME_INDEX_F1,
+KEY_NAME_INDEX_F2,
+KEY_NAME_INDEX_F3,
+KEY_NAME_INDEX_F4,
+KEY_NAME_INDEX_F5,
+KEY_NAME_INDEX_F6,
+KEY_NAME_INDEX_F7,
+KEY_NAME_INDEX_F8,
+KEY_NAME_INDEX_F9,
+KEY_NAME_INDEX_F10,
+KEY_NAME_INDEX_F11,
+KEY_NAME_INDEX_F12,
+KEY_NAME_INDEX_F13,
+KEY_NAME_INDEX_F14,
+KEY_NAME_INDEX_F15,
+KEY_NAME_INDEX_F16,
+KEY_NAME_INDEX_F17,
+KEY_NAME_INDEX_F18,
+KEY_NAME_INDEX_F19,
+KEY_NAME_INDEX_F20,
+KEY_NAME_INDEX_F21,
+KEY_NAME_INDEX_F22,
+KEY_NAME_INDEX_F23,
+KEY_NAME_INDEX_F24,
+KEY_NAME_INDEX_F25,
+KEY_NAME_INDEX_F26,
+KEY_NAME_INDEX_F27,
+KEY_NAME_INDEX_F28,
+KEY_NAME_INDEX_F29,
+KEY_NAME_INDEX_F30,
+KEY_NAME_INDEX_F31,
+KEY_NAME_INDEX_F32,
+KEY_NAME_INDEX_F33,
+KEY_NAME_INDEX_F34,
+KEY_NAME_INDEX_F35,
+KEY_NAME_INDEX_Soft1,
+KEY_NAME_INDEX_Soft2,
+KEY_NAME_INDEX_Soft3,
+KEY_NAME_INDEX_Soft4,
+
+
+
+
+KEY_NAME_INDEX_ChannelDown,
+KEY_NAME_INDEX_ChannelUp,
+KEY_NAME_INDEX_Close,
+KEY_NAME_INDEX_MailForward,
+KEY_NAME_INDEX_MailReply,
+KEY_NAME_INDEX_MailSend,
+KEY_NAME_INDEX_MediaFastForward,
+KEY_NAME_INDEX_MediaPause,
+KEY_NAME_INDEX_MediaPlay,
+KEY_NAME_INDEX_MediaPlayPause,
+KEY_NAME_INDEX_MediaRecord,
+KEY_NAME_INDEX_MediaRewind,
+KEY_NAME_INDEX_MediaStop,
+KEY_NAME_INDEX_MediaTrackNext,
+KEY_NAME_INDEX_MediaTrackPrevious,
+KEY_NAME_INDEX_New,
+KEY_NAME_INDEX_Open,
+KEY_NAME_INDEX_Print,
+KEY_NAME_INDEX_Save,
+KEY_NAME_INDEX_SpellCheck,
+
+
+
+
+KEY_NAME_INDEX_Key11,
+KEY_NAME_INDEX_Key12,
+
+
+
+
+KEY_NAME_INDEX_AudioBalanceLeft,
+KEY_NAME_INDEX_AudioBalanceRight,
+KEY_NAME_INDEX_AudioBassBoostDown,
+KEY_NAME_INDEX_AudioBassBoostToggle,
+KEY_NAME_INDEX_AudioBassBoostUp,
+KEY_NAME_INDEX_AudioFaderFront,
+KEY_NAME_INDEX_AudioFaderRear,
+KEY_NAME_INDEX_AudioSurroundModeNext,
+KEY_NAME_INDEX_AudioTrebleDown,
+KEY_NAME_INDEX_AudioTrebleUp,
+KEY_NAME_INDEX_AudioVolumeDown,
+KEY_NAME_INDEX_AudioVolumeUp,
+KEY_NAME_INDEX_AudioVolumeMute,
+
+KEY_NAME_INDEX_MicrophoneToggle,
+KEY_NAME_INDEX_MicrophoneVolumeDown,
+KEY_NAME_INDEX_MicrophoneVolumeUp,
+KEY_NAME_INDEX_MicrophoneVolumeMute,
+
+
+
+
+KEY_NAME_INDEX_SpeechCorrectionList,
+KEY_NAME_INDEX_SpeechInputToggle,
+
+
+
+
+KEY_NAME_INDEX_LaunchCalculator,
+KEY_NAME_INDEX_LaunchCalendar,
+KEY_NAME_INDEX_LaunchContacts,
+KEY_NAME_INDEX_LaunchMail,
+KEY_NAME_INDEX_LaunchMediaPlayer,
+KEY_NAME_INDEX_LaunchMusicPlayer,
+KEY_NAME_INDEX_LaunchMyComputer,
+KEY_NAME_INDEX_LaunchPhone,
+KEY_NAME_INDEX_LaunchScreenSaver,
+KEY_NAME_INDEX_LaunchSpreadsheet,
+KEY_NAME_INDEX_LaunchWebBrowser,
+KEY_NAME_INDEX_LaunchWebCam,
+KEY_NAME_INDEX_LaunchWordProcessor,
+
+KEY_NAME_INDEX_LaunchApplication1,
+KEY_NAME_INDEX_LaunchApplication2,
+KEY_NAME_INDEX_LaunchApplication3,
+KEY_NAME_INDEX_LaunchApplication4,
+KEY_NAME_INDEX_LaunchApplication5,
+KEY_NAME_INDEX_LaunchApplication6,
+KEY_NAME_INDEX_LaunchApplication7,
+KEY_NAME_INDEX_LaunchApplication8,
+KEY_NAME_INDEX_LaunchApplication9,
+KEY_NAME_INDEX_LaunchApplication10,
+KEY_NAME_INDEX_LaunchApplication11,
+KEY_NAME_INDEX_LaunchApplication12,
+KEY_NAME_INDEX_LaunchApplication13,
+KEY_NAME_INDEX_LaunchApplication14,
+KEY_NAME_INDEX_LaunchApplication15,
+KEY_NAME_INDEX_LaunchApplication16,
+KEY_NAME_INDEX_LaunchApplication17,
+KEY_NAME_INDEX_LaunchApplication18,
+
+
+
+
+KEY_NAME_INDEX_BrowserBack,
+KEY_NAME_INDEX_BrowserFavorites,
+KEY_NAME_INDEX_BrowserForward,
+KEY_NAME_INDEX_BrowserHome,
+KEY_NAME_INDEX_BrowserRefresh,
+KEY_NAME_INDEX_BrowserSearch,
+KEY_NAME_INDEX_BrowserStop,
+
+
+
+
+KEY_NAME_INDEX_AppSwitch,
+KEY_NAME_INDEX_Call,
+KEY_NAME_INDEX_Camera,
+KEY_NAME_INDEX_CameraFocus,
+KEY_NAME_INDEX_EndCall,
+KEY_NAME_INDEX_GoBack,
+KEY_NAME_INDEX_GoHome,
+KEY_NAME_INDEX_HeadsetHook,
+KEY_NAME_INDEX_LastNumberRedial,
+KEY_NAME_INDEX_Notification,
+KEY_NAME_INDEX_MannerMode,
+KEY_NAME_INDEX_VoiceDial,
+
+
+
+
+KEY_NAME_INDEX_TV,
+KEY_NAME_INDEX_TV3DMode,
+KEY_NAME_INDEX_TVAntennaCable,
+KEY_NAME_INDEX_TVAudioDescription,
+KEY_NAME_INDEX_TVAudioDescriptionMixDown,
+KEY_NAME_INDEX_TVAudioDescriptionMixUp,
+KEY_NAME_INDEX_TVContentsMenu,
+KEY_NAME_INDEX_TVDataService,
+KEY_NAME_INDEX_TVInput,
+KEY_NAME_INDEX_TVInputComponent1,
+KEY_NAME_INDEX_TVInputComponent2,
+KEY_NAME_INDEX_TVInputComposite1,
+KEY_NAME_INDEX_TVInputComposite2,
+KEY_NAME_INDEX_TVInputHDMI1,
+KEY_NAME_INDEX_TVInputHDMI2,
+KEY_NAME_INDEX_TVInputHDMI3,
+KEY_NAME_INDEX_TVInputHDMI4,
+KEY_NAME_INDEX_TVInputVGA1,
+KEY_NAME_INDEX_TVMediaContext,
+KEY_NAME_INDEX_TVNetwork,
+KEY_NAME_INDEX_TVNumberEntry,
+KEY_NAME_INDEX_TVPower,
+KEY_NAME_INDEX_TVRadioService,
+KEY_NAME_INDEX_TVSatellite,
+KEY_NAME_INDEX_TVSatelliteBS,
+KEY_NAME_INDEX_TVSatelliteCS,
+KEY_NAME_INDEX_TVSatelliteToggle,
+KEY_NAME_INDEX_TVTerrestrialAnalog,
+KEY_NAME_INDEX_TVTerrestrialDigital,
+KEY_NAME_INDEX_TVTimer,
+
+
+
+
+KEY_NAME_INDEX_AVRInput,
+KEY_NAME_INDEX_AVRPower,
+KEY_NAME_INDEX_ColorF0Red,
+KEY_NAME_INDEX_ColorF1Green,
+KEY_NAME_INDEX_ColorF2Yellow,
+KEY_NAME_INDEX_ColorF3Blue,
+KEY_NAME_INDEX_ColorF4Grey,
+KEY_NAME_INDEX_ColorF5Brown,
+KEY_NAME_INDEX_ClosedCaptionToggle,
+KEY_NAME_INDEX_Dimmer,
+KEY_NAME_INDEX_DisplaySwap,
+KEY_NAME_INDEX_DVR,
+KEY_NAME_INDEX_Exit,
+KEY_NAME_INDEX_FavoriteClear0,
+KEY_NAME_INDEX_FavoriteClear1,
+KEY_NAME_INDEX_FavoriteClear2,
+KEY_NAME_INDEX_FavoriteClear3,
+KEY_NAME_INDEX_FavoriteRecall0,
+KEY_NAME_INDEX_FavoriteRecall1,
+KEY_NAME_INDEX_FavoriteRecall2,
+KEY_NAME_INDEX_FavoriteRecall3,
+KEY_NAME_INDEX_FavoriteStore0,
+KEY_NAME_INDEX_FavoriteStore1,
+KEY_NAME_INDEX_FavoriteStore2,
+KEY_NAME_INDEX_FavoriteStore3,
+KEY_NAME_INDEX_Guide,
+KEY_NAME_INDEX_GuideNextDay,
+KEY_NAME_INDEX_GuidePreviousDay,
+KEY_NAME_INDEX_Info,
+KEY_NAME_INDEX_InstantReplay,
+KEY_NAME_INDEX_Link,
+KEY_NAME_INDEX_ListProgram,
+KEY_NAME_INDEX_LiveContent,
+KEY_NAME_INDEX_Lock,
+KEY_NAME_INDEX_MediaApps,
+KEY_NAME_INDEX_MediaAudioTrack,
+KEY_NAME_INDEX_MediaLast,
+KEY_NAME_INDEX_MediaSkipBackward,
+KEY_NAME_INDEX_MediaSkipForward,
+KEY_NAME_INDEX_MediaStepBackward,
+KEY_NAME_INDEX_MediaStepForward,
+KEY_NAME_INDEX_MediaTopMenu,
+KEY_NAME_INDEX_NavigateIn,
+KEY_NAME_INDEX_NavigateNext,
+KEY_NAME_INDEX_NavigateOut,
+KEY_NAME_INDEX_NavigatePrevious,
+KEY_NAME_INDEX_NextFavoriteChannel,
+KEY_NAME_INDEX_NextUserProfile,
+KEY_NAME_INDEX_OnDemand,
+KEY_NAME_INDEX_Pairing,
+KEY_NAME_INDEX_PinPDown,
+KEY_NAME_INDEX_PinPMove,
+KEY_NAME_INDEX_PinPToggle,
+KEY_NAME_INDEX_PinPUp,
+KEY_NAME_INDEX_PlaySpeedDown,
+KEY_NAME_INDEX_PlaySpeedReset,
+KEY_NAME_INDEX_PlaySpeedUp,
+KEY_NAME_INDEX_RandomToggle,
+KEY_NAME_INDEX_RcLowBattery,
+KEY_NAME_INDEX_RecordSpeedNext,
+KEY_NAME_INDEX_RfBypass,
+KEY_NAME_INDEX_ScanChannelsToggle,
+KEY_NAME_INDEX_ScreenModeNext,
+KEY_NAME_INDEX_Settings,
+KEY_NAME_INDEX_SplitScreenToggle,
+KEY_NAME_INDEX_STBInput,
+KEY_NAME_INDEX_STBPower,
+KEY_NAME_INDEX_Subtitle,
+KEY_NAME_INDEX_Teletext,
+KEY_NAME_INDEX_VideoModeNext,
+KEY_NAME_INDEX_Wink,
+KEY_NAME_INDEX_ZoomToggle,
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+
+
+  KEY_NAME_INDEX_USE_STRING
+};
+
+
+
+const nsCString ToString(KeyNameIndex aKeyNameIndex);
+
+
+
+
+typedef uint8_t CodeNameIndexType;
+enum CodeNameIndex : CodeNameIndexType
+{
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h"
+CODE_NAME_INDEX_UNKNOWN,
+
+
+CODE_NAME_INDEX_Backquote,
+CODE_NAME_INDEX_Backslash,
+CODE_NAME_INDEX_Backspace,
+CODE_NAME_INDEX_BracketLeft,
+CODE_NAME_INDEX_BracketRight,
+CODE_NAME_INDEX_Comma,
+CODE_NAME_INDEX_Digit0,
+CODE_NAME_INDEX_Digit1,
+CODE_NAME_INDEX_Digit2,
+CODE_NAME_INDEX_Digit3,
+CODE_NAME_INDEX_Digit4,
+CODE_NAME_INDEX_Digit5,
+CODE_NAME_INDEX_Digit6,
+CODE_NAME_INDEX_Digit7,
+CODE_NAME_INDEX_Digit8,
+CODE_NAME_INDEX_Digit9,
+CODE_NAME_INDEX_Equal,
+CODE_NAME_INDEX_IntlBackslash,
+CODE_NAME_INDEX_IntlHash,
+CODE_NAME_INDEX_IntlRo,
+CODE_NAME_INDEX_IntlYen,
+CODE_NAME_INDEX_KeyA,
+CODE_NAME_INDEX_KeyB,
+CODE_NAME_INDEX_KeyC,
+CODE_NAME_INDEX_KeyD,
+CODE_NAME_INDEX_KeyE,
+CODE_NAME_INDEX_KeyF,
+CODE_NAME_INDEX_KeyG,
+CODE_NAME_INDEX_KeyH,
+CODE_NAME_INDEX_KeyI,
+CODE_NAME_INDEX_KeyJ,
+CODE_NAME_INDEX_KeyK,
+CODE_NAME_INDEX_KeyL,
+CODE_NAME_INDEX_KeyM,
+CODE_NAME_INDEX_KeyN,
+CODE_NAME_INDEX_KeyO,
+CODE_NAME_INDEX_KeyP,
+CODE_NAME_INDEX_KeyQ,
+CODE_NAME_INDEX_KeyR,
+CODE_NAME_INDEX_KeyS,
+CODE_NAME_INDEX_KeyT,
+CODE_NAME_INDEX_KeyU,
+CODE_NAME_INDEX_KeyV,
+CODE_NAME_INDEX_KeyW,
+CODE_NAME_INDEX_KeyX,
+CODE_NAME_INDEX_KeyY,
+CODE_NAME_INDEX_KeyZ,
+CODE_NAME_INDEX_Minus,
+CODE_NAME_INDEX_Period,
+CODE_NAME_INDEX_Quote,
+CODE_NAME_INDEX_Semicolon,
+CODE_NAME_INDEX_Slash,
+
+
+CODE_NAME_INDEX_AltLeft,
+CODE_NAME_INDEX_AltRight,
+CODE_NAME_INDEX_CapsLock,
+CODE_NAME_INDEX_ContextMenu,
+CODE_NAME_INDEX_ControlLeft,
+CODE_NAME_INDEX_ControlRight,
+CODE_NAME_INDEX_Enter,
+CODE_NAME_INDEX_OSLeft,
+CODE_NAME_INDEX_OSRight,
+CODE_NAME_INDEX_ShiftLeft,
+CODE_NAME_INDEX_ShiftRight,
+CODE_NAME_INDEX_Space,
+CODE_NAME_INDEX_Tab,
+
+
+CODE_NAME_INDEX_Convert,
+CODE_NAME_INDEX_KanaMode,
+CODE_NAME_INDEX_Lang1,
+CODE_NAME_INDEX_Lang2,
+CODE_NAME_INDEX_Lang3,
+CODE_NAME_INDEX_Lang4,
+CODE_NAME_INDEX_Lang5,
+CODE_NAME_INDEX_NonConvert,
+
+
+CODE_NAME_INDEX_Delete,
+CODE_NAME_INDEX_End,
+CODE_NAME_INDEX_Help,
+CODE_NAME_INDEX_Home,
+CODE_NAME_INDEX_Insert,
+CODE_NAME_INDEX_PageDown,
+CODE_NAME_INDEX_PageUp,
+
+
+CODE_NAME_INDEX_ArrowDown,
+CODE_NAME_INDEX_ArrowLeft,
+CODE_NAME_INDEX_ArrowRight,
+CODE_NAME_INDEX_ArrowUp,
+
+
+CODE_NAME_INDEX_NumLock,
+CODE_NAME_INDEX_Numpad0,
+CODE_NAME_INDEX_Numpad1,
+CODE_NAME_INDEX_Numpad2,
+CODE_NAME_INDEX_Numpad3,
+CODE_NAME_INDEX_Numpad4,
+CODE_NAME_INDEX_Numpad5,
+CODE_NAME_INDEX_Numpad6,
+CODE_NAME_INDEX_Numpad7,
+CODE_NAME_INDEX_Numpad8,
+CODE_NAME_INDEX_Numpad9,
+CODE_NAME_INDEX_NumpadAdd,
+CODE_NAME_INDEX_NumpadBackspace,
+CODE_NAME_INDEX_NumpadClear,
+CODE_NAME_INDEX_NumpadClearEntry,
+CODE_NAME_INDEX_NumpadComma,
+CODE_NAME_INDEX_NumpadDecimal,
+CODE_NAME_INDEX_NumpadDivide,
+CODE_NAME_INDEX_NumpadEnter,
+CODE_NAME_INDEX_NumpadEqual,
+CODE_NAME_INDEX_NumpadMemoryAdd,
+CODE_NAME_INDEX_NumpadMemoryClear,
+CODE_NAME_INDEX_NumpadMemoryRecall,
+CODE_NAME_INDEX_NumpadMemoryStore,
+CODE_NAME_INDEX_NumpadMemorySubtract,
+CODE_NAME_INDEX_NumpadMultiply,
+CODE_NAME_INDEX_NumpadParenLeft,
+CODE_NAME_INDEX_NumpadParenRight,
+CODE_NAME_INDEX_NumpadSubtract,
+
+
+CODE_NAME_INDEX_Escape,
+CODE_NAME_INDEX_F1,
+CODE_NAME_INDEX_F2,
+CODE_NAME_INDEX_F3,
+CODE_NAME_INDEX_F4,
+CODE_NAME_INDEX_F5,
+CODE_NAME_INDEX_F6,
+CODE_NAME_INDEX_F7,
+CODE_NAME_INDEX_F8,
+CODE_NAME_INDEX_F9,
+CODE_NAME_INDEX_F10,
+CODE_NAME_INDEX_F11,
+CODE_NAME_INDEX_F12,
+CODE_NAME_INDEX_F13,
+CODE_NAME_INDEX_F14,
+CODE_NAME_INDEX_F15,
+CODE_NAME_INDEX_F16,
+CODE_NAME_INDEX_F17,
+CODE_NAME_INDEX_F18,
+CODE_NAME_INDEX_F19,
+CODE_NAME_INDEX_F20,
+CODE_NAME_INDEX_F21,
+CODE_NAME_INDEX_F22,
+CODE_NAME_INDEX_F23,
+CODE_NAME_INDEX_F24,
+CODE_NAME_INDEX_Fn,
+CODE_NAME_INDEX_FnLock,
+CODE_NAME_INDEX_PrintScreen,
+CODE_NAME_INDEX_ScrollLock,
+CODE_NAME_INDEX_Pause,
+
+
+CODE_NAME_INDEX_BrowserBack,
+CODE_NAME_INDEX_BrowserFavorites,
+CODE_NAME_INDEX_BrowserForward,
+CODE_NAME_INDEX_BrowserHome,
+CODE_NAME_INDEX_BrowserRefresh,
+CODE_NAME_INDEX_BrowserSearch,
+CODE_NAME_INDEX_BrowserStop,
+CODE_NAME_INDEX_Eject,
+CODE_NAME_INDEX_LaunchApp1,
+CODE_NAME_INDEX_LaunchApp2,
+CODE_NAME_INDEX_LaunchMail,
+CODE_NAME_INDEX_MediaPlayPause,
+CODE_NAME_INDEX_MediaSelect,
+CODE_NAME_INDEX_MediaStop,
+CODE_NAME_INDEX_MediaTrackNext,
+CODE_NAME_INDEX_MediaTrackPrevious,
+CODE_NAME_INDEX_Power,
+CODE_NAME_INDEX_Sleep,
+CODE_NAME_INDEX_VolumeDown,
+CODE_NAME_INDEX_VolumeMute,
+CODE_NAME_INDEX_VolumeUp,
+CODE_NAME_INDEX_WakeUp,
+# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h"
+CODE_NAME_INDEX_Again,
+CODE_NAME_INDEX_Copy,
+CODE_NAME_INDEX_Cut,
+CODE_NAME_INDEX_Find,
+CODE_NAME_INDEX_Open,
+CODE_NAME_INDEX_Paste,
+CODE_NAME_INDEX_Props,
+CODE_NAME_INDEX_Select,
+CODE_NAME_INDEX_Undo,
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+
+
+  CODE_NAME_INDEX_USE_STRING
+};
+
+
+
+const nsCString ToString(CodeNameIndex aCodeNameIndex);
+
+
+
+typedef int8_t CommandInt;
+enum Command : CommandInt
+{
+  CommandDoNothing
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CommandList.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CommandList.h"
+, CommandBeginLine
+, CommandCharNext
+, CommandCharPrevious
+, CommandCopy
+, CommandCut
+, CommandDelete
+, CommandDeleteCharBackward
+, CommandDeleteCharForward
+, CommandDeleteToBeginningOfLine
+, CommandDeleteToEndOfLine
+, CommandDeleteWordBackward
+, CommandDeleteWordForward
+, CommandEndLine
+, CommandLineNext
+, CommandLinePrevious
+, CommandMoveBottom
+, CommandMovePageDown
+, CommandMovePageUp
+, CommandMoveTop
+, CommandPaste
+, CommandScrollBottom
+, CommandScrollLineDown
+, CommandScrollLineUp
+, CommandScrollPageDown
+, CommandScrollPageUp
+, CommandScrollTop
+, CommandSelectAll
+, CommandSelectBeginLine
+, CommandSelectBottom
+, CommandSelectCharNext
+, CommandSelectCharPrevious
+, CommandSelectEndLine
+, CommandSelectLineNext
+, CommandSelectLinePrevious
+, CommandSelectPageDown
+, CommandSelectPageUp
+, CommandSelectTop
+, CommandSelectWordNext
+, CommandSelectWordPrevious
+, CommandWordNext
+, CommandWordPrevious
+# 125 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+};
+
+
+}
+
+
+
+
+
+namespace mozilla {
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h"
+class WidgetEvent;
+class WidgetGUIEvent;
+class WidgetInputEvent;
+class InternalUIEvent;
+
+
+class WidgetKeyboardEvent;
+class WidgetCompositionEvent;
+class WidgetQueryContentEvent;
+class WidgetSelectionEvent;
+class InternalEditorInputEvent;
+
+
+class WidgetMouseEventBase;
+class WidgetMouseEvent;
+class WidgetDragEvent;
+class WidgetMouseScrollEvent;
+class WidgetWheelEvent;
+class WidgetPointerEvent;
+
+
+class WidgetGestureNotifyEvent;
+class WidgetSimpleGestureEvent;
+class WidgetTouchEvent;
+
+
+class InternalScrollPortEvent;
+class InternalScrollAreaEvent;
+class InternalFormEvent;
+class InternalClipboardEvent;
+class InternalFocusEvent;
+class InternalTransitionEvent;
+class InternalAnimationEvent;
+class InternalSMILTimeEvent;
+
+
+class WidgetCommandEvent;
+class WidgetContentCommandEvent;
+class WidgetPluginEvent;
+
+
+class InternalMutationEvent;
+# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
+
+
+
+
+
+struct BaseEventFlags;
+struct EventFlags;
+
+class WidgetEventTime;
+
+class NativeEventData;
+
+
+struct AlternativeCharCode;
+struct ShortcutKeyCandidate;
+
+typedef nsTArray<ShortcutKeyCandidate> ShortcutKeyCandidateArray;
+typedef AutoTArray<ShortcutKeyCandidate, 10> AutoShortcutKeyCandidateArray;
+
+
+typedef uint8_t RawTextRangeType;
+enum class TextRangeType : RawTextRangeType;
+
+struct TextRangeStyle;
+struct TextRange;
+
+class TextRangeArray;
+
+
+struct FontRange;
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Nullable.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Nullable.h"
+class nsCycleCollectionTraversalCallback;
+
+namespace mozilla {
+namespace dom {
+
+
+template <typename T>
+struct Nullable
+{
+private:
+  Maybe<T> mValue;
+
+public:
+  Nullable()
+    : mValue()
+  {}
+
+               Nullable(const decltype(nullptr)&)
+    : mValue()
+  {}
+
+  explicit Nullable(const T& aValue)
+    : mValue()
+  {
+    mValue.emplace(aValue);
+  }
+
+               Nullable(T&& aValue)
+    : mValue()
+  {
+    mValue.emplace(mozilla::Move(aValue));
+  }
+
+  Nullable(Nullable<T>&& aOther)
+    : mValue(mozilla::Move(aOther.mValue))
+  {}
+
+  Nullable(const Nullable<T>& aOther)
+    : mValue(aOther.mValue)
+  {}
+
+  void operator=(const Nullable<T>& aOther)
+  {
+    mValue = aOther.mValue;
+  }
+
+  void SetValue(const T& aArgs)
+  {
+    mValue.reset();
+    mValue.emplace(aArgs);
+  }
+
+  void SetValue(T&& aArgs)
+  {
+    mValue.reset();
+    mValue.emplace(mozilla::Move(aArgs));
+  }
+
+
+
+
+  T& SetValue() {
+    if (mValue.isNothing()) {
+      mValue.emplace();
+    }
+    return mValue.ref();
+  }
+
+  void SetNull() {
+    mValue.reset();
+  }
+
+  const T& Value() const {
+    return mValue.ref();
+  }
+
+  T& Value() {
+    return mValue.ref();
+  }
+
+  bool IsNull() const {
+    return mValue.isNothing();
+  }
+
+  bool Equals(const Nullable<T>& aOtherNullable) const
+  {
+    return mValue == aOtherNullable.mValue;
+  }
+
+  bool operator==(const Nullable<T>& aOtherNullable) const
+  {
+    return Equals(aOtherNullable);
+  }
+
+  bool operator!=(const Nullable<T>& aOtherNullable) const
+  {
+    return !Equals(aOtherNullable);
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const Nullable& aNullable) {
+    return aStream << aNullable.mValue;
+  }
+};
+
+
+template<typename T>
+void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            Nullable<T>& aNullable,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  if (!aNullable.IsNull()) {
+    ImplCycleCollectionTraverse(aCallback, aNullable.Value(), aName, aFlags);
+  }
+}
+
+template<typename T>
+void
+ImplCycleCollectionUnlink(Nullable<T>& aNullable)
+{
+  if (!aNullable.IsNull()) {
+    ImplCycleCollectionUnlink(aNullable.Value());
+  }
+}
+
+}
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 2
+
+using mozilla::dom::Nullable;
+namespace mozilla {
+class EventChainVisitor;
+class EventChainPostVisitor;
+class EventChainPreVisitor;
+class EventListenerManager;
+namespace dom {
+class EventTarget;
+}
+}
+class nsPresContext;
+class nsIScriptContext;
+
+class nsIDOMEventListener;
+
+class nsIDOMEvent;
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h"
+class nsIDOMEventTarget : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult AddEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc) = 0;
+
+
+  virtual nsresult AddSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc) = 0;
+
+
+  nsresult AddEventListener(const nsAString& aType,
+                            nsIDOMEventListener* aListener,
+                            bool aUseCapture)
+  {
+    return AddEventListener(aType, aListener, aUseCapture, false, 1);
+  }
+
+  nsresult AddEventListener(const nsAString& aType,
+                            nsIDOMEventListener* aListener,
+                            bool aUseCapture,
+                            bool aWantsUntrusted)
+  {
+    return AddEventListener(aType, aListener, aUseCapture, aWantsUntrusted, 2);
+  }
+
+  nsresult AddSystemEventListener(const nsAString& aType,
+                                  nsIDOMEventListener* aListener,
+                                  bool aUseCapture)
+  {
+    return AddSystemEventListener(aType, aListener, aUseCapture, false, 1);
+  }
+
+  nsresult AddSystemEventListener(const nsAString& aType,
+                                  nsIDOMEventListener* aListener,
+                                  bool aUseCapture,
+                                  bool aWantsUntrusted)
+  {
+    return AddSystemEventListener(aType, aListener, aUseCapture,
+                                  aWantsUntrusted, 2);
+  }
+
+  virtual nsresult RemoveEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture) = 0;
+
+
+  virtual nsresult RemoveSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture) = 0;
+
+
+  virtual nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval) = 0;
+
+
+  virtual mozilla::dom::EventTarget * GetTargetForDOMEvent(void) = 0;
+
+
+  virtual mozilla::dom::EventTarget * GetTargetForEventTargetChain(void) = 0;
+
+
+  virtual nsresult GetEventTargetParent(mozilla::EventChainPreVisitor & aVisitor) = 0;
+
+   virtual nsresult PreHandleEvent(mozilla::EventChainVisitor& aVisitor)
+  {
+    return NS_OK;
+  }
+
+  virtual nsresult WillHandleEvent(mozilla::EventChainPostVisitor & aVisitor) = 0;
+
+
+  virtual nsresult PostHandleEvent(mozilla::EventChainPostVisitor & aVisitor) = 0;
+
+
+  virtual nsresult DispatchDOMEvent(mozilla::WidgetEvent *aEvent, nsIDOMEvent *aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) = 0;
+
+
+  virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv) = 0;
+
+};
+
+  template<typename T> struct nsIDOMEventTarget::COMTypeInfo<nsIDOMEventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMEventTarget::COMTypeInfo<nsIDOMEventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9a78ac3c, 0x9507, 0x4d00, { 0xb2, 0xd6, 0x10, 0xb5, 0x08, 0xd2, 0xec, 0x31 }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h" 1
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
+struct jsid
+{
+    size_t asBits;
+    bool operator==(const jsid& rhs) const { return asBits == rhs.asBits; }
+    bool operator!=(const jsid& rhs) const { return asBits != rhs.asBits; }
+} ;
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
+static __attribute__((always_inline)) inline bool
+JSID_IS_STRING(jsid iden)
+{
+    return ((iden.asBits) & 0x7) == 0;
+}
+
+static __attribute__((always_inline)) inline JSString*
+JSID_TO_STRING(jsid iden)
+{
+    do { } while (0);
+    return (JSString*)(iden.asBits);
+}
+# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
+jsid
+INTERNED_STRING_TO_JSID(JSContext* cx, JSString* str);
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_INT(jsid iden)
+{
+    return !!((iden.asBits) & 0x1);
+}
+
+static __attribute__((always_inline)) inline int32_t
+JSID_TO_INT(jsid iden)
+{
+    do { } while (0);
+    uint32_t bits = static_cast<uint32_t>((iden.asBits)) >> 1;
+    return static_cast<int32_t>(bits);
+}
+
+
+
+
+static __attribute__((always_inline)) inline bool
+INT_FITS_IN_JSID(int32_t i)
+{
+    return i >= 0;
+}
+
+static __attribute__((always_inline)) inline jsid
+INT_TO_JSID(int32_t i)
+{
+    jsid iden;
+    do { } while (0);
+    uint32_t bits = (static_cast<uint32_t>(i) << 1) | 0x1;
+    (iden.asBits) = static_cast<size_t>(bits);
+    return iden;
+}
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_SYMBOL(jsid iden)
+{
+    return ((iden.asBits) & 0x7) == 0x4 &&
+           (iden.asBits) != 0x4;
+}
+
+static __attribute__((always_inline)) inline JS::Symbol*
+JSID_TO_SYMBOL(jsid iden)
+{
+    do { } while (0);
+    return (JS::Symbol*)((iden.asBits) & ~(size_t)0x7);
+}
+
+static __attribute__((always_inline)) inline jsid
+SYMBOL_TO_JSID(JS::Symbol* sym)
+{
+    jsid iden;
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    (iden.asBits) = (size_t(sym) | 0x4);
+    return iden;
+}
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_GCTHING(jsid iden)
+{
+    return JSID_IS_STRING(iden) || JSID_IS_SYMBOL(iden);
+}
+
+static __attribute__((always_inline)) inline JS::GCCellPtr
+JSID_TO_GCTHING(jsid iden)
+{
+    void* thing = (void*)((iden.asBits) & ~(size_t)0x7);
+    if (JSID_IS_STRING(iden))
+        return JS::GCCellPtr(thing, JS::TraceKind::String);
+    do { } while (0);
+    return JS::GCCellPtr(thing, JS::TraceKind::Symbol);
+}
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_VOID(const jsid iden)
+{
+    do { } while (0);
+
+    return (size_t)(iden.asBits) == 0x2;
+}
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_EMPTY(const jsid iden)
+{
+    return (size_t)(iden.asBits) == 0x4;
+}
+
+extern const jsid JSID_VOID;
+extern const jsid JSID_EMPTY;
+
+extern const JS::HandleId JSID_VOIDHANDLE;
+extern const JS::HandleId JSID_EMPTYHANDLE;
+
+namespace JS {
+
+template <>
+struct GCPolicy<jsid>
+{
+    static jsid initial() { return JSID_VOID; }
+    static void trace(JSTracer* trc, jsid* idp, const char* name) {
+        js::UnsafeTraceManuallyBarrieredEdge(trc, idp, name);
+    }
+};
+
+}
+
+namespace js {
+
+template <>
+struct BarrierMethods<jsid>
+{
+    static void postBarrier(jsid* idp, jsid prev, jsid next) {}
+    static void exposeToJS(jsid iden) {
+        if (JSID_IS_GCTHING(iden))
+            js::gc::ExposeGCThingToActiveJS(JSID_TO_GCTHING(iden));
+    }
+};
+
+
+
+template <typename F, typename... Args>
+auto
+DispatchTyped(F f, const jsid& iden, Args&&... args)
+  -> decltype(f(static_cast<JSString*>(nullptr), mozilla::Forward<Args>(args)...))
+{
+    if (JSID_IS_STRING(iden))
+        return f(JSID_TO_STRING(iden), mozilla::Forward<Args>(args)...);
+    if (JSID_IS_SYMBOL(iden))
+        return f(JSID_TO_SYMBOL(iden), mozilla::Forward<Args>(args)...);
+    do { } while (0);
+    return F::defaultValue(iden);
+}
+
+
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h" 2
+
+
+
+
+namespace mozilla {
+namespace dom {
+class TabChildGlobal;
+class ProcessGlobal;
+}
+}
+class SandboxPrivate;
+class nsInProcessTabChildGlobal;
+class nsWindowRoot;
+# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
+class nsWrapperCache
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  nsWrapperCache() : mWrapper(nullptr), mFlags(0)
+  {
+  }
+  ~nsWrapperCache()
+  {
+    do { } while (0);
+
+  }
+
+
+
+
+
+
+
+  JSObject* GetWrapper() const;
+# 101 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
+  JSObject* GetWrapperPreserveColor() const
+  {
+    return GetWrapperJSObject();
+  }
+# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
+  void SetWrapper(JSObject* aWrapper)
+  {
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+
+
+    SetWrapperJSObject(aWrapper);
+  }
+
+
+
+
+
+  void ClearWrapper()
+  {
+    do { } while (0);
+
+    SetWrapperJSObject(nullptr);
+  }
+
+
+
+
+
+
+
+  void UpdateWrapper(JSObject* aNewObject, const JSObject* aOldObject)
+  {
+    if (mWrapper) {
+      do { } while (0);
+      mWrapper = aNewObject;
+    }
+  }
+
+  bool PreservingWrapper() const
+  {
+    return HasWrapperFlag(WRAPPER_BIT_PRESERVED);
+  }
+
+  bool IsDOMBinding() const
+  {
+    return !HasWrapperFlag(WRAPPER_IS_NOT_DOM_BINDING);
+  }
+
+
+
+
+
+  virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) = 0;
+
+
+
+
+
+  bool HasKnownLiveWrapper() const;
+
+
+
+
+
+
+  bool HasKnownLiveWrapperAndDoesNotNeedTracing(nsISupports* aThis);
+
+  bool HasNothingToTrace(nsISupports* aThis);
+
+
+
+
+  void MarkWrapperLive();
+
+
+  void SetPreservingWrapper(bool aPreserve)
+  {
+    if(aPreserve) {
+      SetWrapperFlags(WRAPPER_BIT_PRESERVED);
+    }
+    else {
+      UnsetWrapperFlags(WRAPPER_BIT_PRESERVED);
+    }
+  }
+
+  void TraceWrapper(const TraceCallbacks& aCallbacks, void* aClosure)
+  {
+    if (PreservingWrapper() && mWrapper) {
+      aCallbacks.Trace(&mWrapper, "Preserved wrapper", aClosure);
+    }
+  }
+
+
+
+
+
+
+  typedef uint32_t FlagsType;
+
+  FlagsType GetFlags() const
+  {
+    return mFlags & ~kWrapperFlagsMask;
+  }
+
+  bool HasFlag(FlagsType aFlag) const
+  {
+    do { } while (0);
+    return !!(mFlags & aFlag);
+  }
+
+  void SetFlags(FlagsType aFlagsToSet)
+  {
+    do { } while (0);
+    mFlags |= aFlagsToSet;
+  }
+
+  void UnsetFlags(FlagsType aFlagsToUnset)
+  {
+    do { } while (0);
+    mFlags &= ~aFlagsToUnset;
+  }
+
+  void PreserveWrapper(nsISupports* aScriptObjectHolder)
+  {
+    if (PreservingWrapper()) {
+      return;
+    }
+
+    nsISupports* ccISupports;
+    aScriptObjectHolder->QueryInterface((nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, void>::kIID),
+                                        reinterpret_cast<void**>(&ccISupports));
+    do { } while (0);
+
+    nsXPCOMCycleCollectionParticipant* participant;
+    CallQueryInterface(ccISupports, &participant);
+    PreserveWrapper(ccISupports, participant);
+  }
+
+  void PreserveWrapper(void* aScriptObjectHolder, nsScriptObjectTracer* aTracer)
+  {
+    if (PreservingWrapper()) {
+      return;
+    }
+
+    HoldJSObjects(aScriptObjectHolder, aTracer);
+    SetPreservingWrapper(true);
+
+
+
+
+  }
+
+  void ReleaseWrapper(void* aScriptObjectHolder);
+
+protected:
+  void TraceWrapper(JSTracer* aTrc, const char* name)
+  {
+    if (mWrapper) {
+      js::UnsafeTraceManuallyBarrieredEdge(aTrc, &mWrapper, name);
+    }
+  }
+
+  void PoisonWrapper()
+  {
+    if (mWrapper) {
+
+
+      mWrapper = reinterpret_cast<JSObject*>(1);
+    }
+  }
+
+private:
+
+
+
+  friend class mozilla::dom::TabChildGlobal;
+  friend class mozilla::dom::ProcessGlobal;
+  friend class SandboxPrivate;
+  friend class nsInProcessTabChildGlobal;
+  friend class nsWindowRoot;
+  void SetIsNotDOMBinding()
+  {
+    do { } while (0);
+
+    SetWrapperFlags(WRAPPER_IS_NOT_DOM_BINDING);
+  }
+
+  JSObject *GetWrapperJSObject() const
+  {
+    return mWrapper;
+  }
+
+  void SetWrapperJSObject(JSObject* aWrapper);
+
+  FlagsType GetWrapperFlags() const
+  {
+    return mFlags & kWrapperFlagsMask;
+  }
+
+  bool HasWrapperFlag(FlagsType aFlag) const
+  {
+    do { } while (0);
+    return !!(mFlags & aFlag);
+  }
+
+  void SetWrapperFlags(FlagsType aFlagsToSet)
+  {
+    do { } while (0);
+    mFlags |= aFlagsToSet;
+  }
+
+  void UnsetWrapperFlags(FlagsType aFlagsToUnset)
+  {
+    do { } while (0);
+    mFlags &= ~aFlagsToUnset;
+  }
+
+  void HoldJSObjects(void* aScriptObjectHolder,
+                     nsScriptObjectTracer* aTracer);
+# 347 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
+  enum { WRAPPER_BIT_PRESERVED = 1 << 0 };
+
+
+
+
+
+  enum { WRAPPER_IS_NOT_DOM_BINDING = 1 << 1 };
+
+  enum { kWrapperFlagsMask = (WRAPPER_BIT_PRESERVED | WRAPPER_IS_NOT_DOM_BINDING) };
+
+  JSObject* mWrapper;
+  FlagsType mFlags;
+};
+
+enum { WRAPPER_CACHE_FLAGS_BITS_USED = 2 };
+
+template<typename T> struct nsWrapperCache::COMTypeInfo<nsWrapperCache, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsWrapperCache::COMTypeInfo<nsWrapperCache, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x6f3179a1, 0x36f7, 0x4a5c, { 0x8c, 0xf1, 0xad, 0xc8, 0x7c, 0xde, 0x3e, 0x87 } };
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 2
+
+
+class nsPIDOMWindowOuter;
+class nsIGlobalObject;
+
+namespace mozilla {
+
+class AsyncEventDispatcher;
+class ErrorResult;
+class EventListenerManager;
+
+namespace dom {
+
+class AddEventListenerOptionsOrBoolean;
+class Event;
+class EventListener;
+class EventListenerOptionsOrBoolean;
+class EventHandlerNonNull;
+
+template <class T> struct Nullable;
+
+
+
+
+
+
+class EventTarget : public nsIDOMEventTarget,
+                    public nsWrapperCache
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  using nsIDOMEventTarget::AddEventListener;
+  using nsIDOMEventTarget::RemoveEventListener;
+  using nsIDOMEventTarget::DispatchEvent;
+  virtual void AddEventListener(const nsAString& aType,
+                                EventListener* aCallback,
+                                const AddEventListenerOptionsOrBoolean& aOptions,
+                                const Nullable<bool>& aWantsUntrusted,
+                                ErrorResult& aRv) = 0;
+  virtual void RemoveEventListener(const nsAString& aType,
+                                   EventListener* aCallback,
+                                   const EventListenerOptionsOrBoolean& aOptions,
+                                   ErrorResult& aRv);
+  bool DispatchEvent(Event& aEvent, CallerType aCallerType, ErrorResult& aRv);
+
+
+  EventHandlerNonNull* GetEventHandler(const nsAString& aType)
+  {
+    nsCOMPtr<nsIAtom> type = NS_Atomize(aType);
+    return GetEventHandler(type, EmptyString());
+  }
+
+
+  void SetEventHandler(const nsAString& aType, EventHandlerNonNull* aHandler,
+                       ErrorResult& rv);
+
+
+  virtual void EventListenerAdded(nsIAtom* aType) {}
+  virtual void EventListenerRemoved(nsIAtom* aType) {}
+
+
+
+
+  virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() = 0;
+
+
+
+
+  virtual nsIGlobalObject* GetOwnerGlobal() const = 0;
+
+
+
+
+  virtual EventListenerManager* GetOrCreateListenerManager() = 0;
+
+
+
+
+
+  virtual EventListenerManager* GetExistingListenerManager() const = 0;
+
+
+  virtual void AsyncEventRunning(AsyncEventDispatcher* aEvent) {}
+
+  virtual bool IsApzAware() const;
+
+protected:
+  EventHandlerNonNull* GetEventHandler(nsIAtom* aType,
+                                       const nsAString& aTypeString);
+  void SetEventHandler(nsIAtom* aType, const nsAString& aTypeString,
+                       EventHandlerNonNull* aHandler);
+};
+
+template<typename T> struct EventTarget::COMTypeInfo<EventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID EventTarget::COMTypeInfo<EventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xde651c36, 0x0053, 0x4c67, { 0xb1, 0x3d, 0x67, 0xb9, 0x40, 0xfc, 0x82, 0xe4 } };
+
+}
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+class nsAttrAndChildArray;
+class nsChildContentList;
+struct nsCSSSelectorList;
+class nsDOMAttributeMap;
+class nsIAnimationObserver;
+class nsIContent;
+class nsIDocument;
+class nsIDOMElement;
+class nsIDOMNodeList;
+class nsIEditor;
+class nsIFrame;
+class nsIMutationObserver;
+class nsINode;
+class nsINodeList;
+class nsIPresShell;
+class nsIPrincipal;
+class nsIURI;
+class nsNodeSupportsWeakRefTearoff;
+class nsNodeWeakReference;
+class nsDOMMutationObserver;
+
+namespace mozilla {
+class EventListenerManager;
+namespace dom {
+
+
+
+
+inline bool IsSpaceCharacter(char16_t aChar) {
+  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
+         aChar == '\f';
+}
+inline bool IsSpaceCharacter(char aChar) {
+  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
+         aChar == '\f';
+}
+class AccessibleNode;
+struct BoxQuadOptions;
+struct ConvertCoordinateOptions;
+class DOMPoint;
+class DOMQuad;
+class DOMRectReadOnly;
+class Element;
+class EventHandlerNonNull;
+template<typename T> class Optional;
+class OwningNodeOrString;
+template<typename> class Sequence;
+class Text;
+class TextOrElementOrDocument;
+struct DOMPointInit;
+struct GetRootNodeOptions;
+enum class CallerType : uint32_t;
+}
+}
+
+
+
+
+enum {
+
+  NODE_HAS_LISTENERMANAGER = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (0))),
+
+
+  NODE_HAS_PROPERTIES = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (1))),
+
+
+
+
+
+
+  NODE_IS_ANONYMOUS_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (2))),
+
+
+
+
+
+
+
+  NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (3))),
+
+
+
+
+
+  NODE_IS_NATIVE_ANONYMOUS_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (4))),
+
+
+
+  NODE_FORCE_XBL_BINDINGS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (5))),
+
+
+  NODE_MAY_BE_IN_BINDING_MNGR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (6))),
+
+  NODE_IS_EDITABLE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (7))),
+# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  NODE_IS_NATIVE_ANONYMOUS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (8))),
+
+
+  NODE_IS_IN_SHADOW_TREE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (9))),
+
+
+  NODE_HAS_EMPTY_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (10))),
+
+
+
+  NODE_HAS_SLOW_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (11))),
+
+
+
+  NODE_HAS_EDGE_CHILD_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (12))),
+# 174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (13))),
+
+  NODE_ALL_SELECTOR_FLAGS = NODE_HAS_EMPTY_SELECTOR |
+                                          NODE_HAS_SLOW_SELECTOR |
+                                          NODE_HAS_EDGE_CHILD_SELECTOR |
+                                          NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS,
+
+
+
+  NODE_NEEDS_FRAME = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (14))),
+
+
+
+
+  NODE_DESCENDANTS_NEED_FRAMES = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (15))),
+
+
+  NODE_HAS_ACCESSKEY = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (16))),
+
+
+  NODE_HAS_DIRECTION_RTL = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (17))),
+
+
+  NODE_HAS_DIRECTION_LTR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (18))),
+
+  NODE_ALL_DIRECTION_FLAGS = NODE_HAS_DIRECTION_LTR |
+                                          NODE_HAS_DIRECTION_RTL,
+
+  NODE_CHROME_ONLY_ACCESS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (19))),
+
+  NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (20))),
+
+
+
+
+
+
+  NODE_SHARED_RESTYLE_BIT_1 = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (21))),
+  NODE_SHARED_RESTYLE_BIT_2 = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (22))),
+
+
+  NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO = NODE_SHARED_RESTYLE_BIT_1,
+
+
+
+  NODE_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO =
+    NODE_SHARED_RESTYLE_BIT_2,
+
+
+  NODE_TYPE_SPECIFIC_BITS_OFFSET = 23
+};
+
+
+
+
+
+
+static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET) <= sizeof(nsWrapperCache::FlagsType) * 8, "Not enough space for our bits");
+
+
+
+
+
+
+
+class nsMutationGuard {
+public:
+  nsMutationGuard()
+  {
+    mStartingGeneration = sGeneration;
+  }
+# 258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  bool Mutated(uint8_t aIgnoreCount)
+  {
+    return (sGeneration - mStartingGeneration) > aIgnoreCount;
+  }
+
+
+
+
+  static void DidMutate()
+  {
+    sGeneration++;
+  }
+
+private:
+
+  uint64_t mStartingGeneration;
+
+
+  static uint64_t sGeneration;
+};
+# 301 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+class nsINode : public mozilla::dom::EventTarget
+{
+public:
+  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;
+  typedef mozilla::dom::ConvertCoordinateOptions ConvertCoordinateOptions;
+  typedef mozilla::dom::DOMPoint DOMPoint;
+  typedef mozilla::dom::DOMPointInit DOMPointInit;
+  typedef mozilla::dom::DOMQuad DOMQuad;
+  typedef mozilla::dom::DOMRectReadOnly DOMRectReadOnly;
+  typedef mozilla::dom::OwningNodeOrString OwningNodeOrString;
+  typedef mozilla::dom::TextOrElementOrDocument TextOrElementOrDocument;
+  typedef mozilla::dom::CallerType CallerType;
+  typedef mozilla::ErrorResult ErrorResult;
+
+  template<class T>
+  using Sequence = mozilla::dom::Sequence<T>;
+
+  template<typename T, typename U> struct COMTypeInfo;
+# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+
+
+
+
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  friend class nsNodeUtils;
+  friend class nsNodeWeakReference;
+  friend class nsNodeSupportsWeakRefTearoff;
+  friend class nsAttrAndChildArray;
+
+
+  explicit nsINode(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
+  : mNodeInfo(aNodeInfo)
+  , mParent(nullptr)
+  , mBoolFlags(0)
+  , mNextSibling(nullptr)
+  , mPreviousSibling(nullptr)
+  , mFirstChild(nullptr)
+  , mSubtreeRoot(this)
+  , mSlots(nullptr)
+  {
+  }
+
+
+  virtual ~nsINode();
+
+
+
+
+  enum {
+
+    eCONTENT = 1 << 0,
+
+    eDOCUMENT = 1 << 1,
+
+    eATTRIBUTE = 1 << 2,
+
+    eTEXT = 1 << 3,
+
+    ePROCESSING_INSTRUCTION = 1 << 4,
+
+    eCOMMENT = 1 << 5,
+
+    eHTML_FORM_CONTROL = 1 << 6,
+
+    eDOCUMENT_FRAGMENT = 1 << 7,
+
+
+    eDATA_NODE = 1 << 8,
+
+    eMEDIA = 1 << 9,
+
+    eANIMATION = 1 << 10,
+
+    eFILTER = 1 << 11
+  };
+# 414 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual bool IsNodeOfType(uint32_t aFlags) const = 0;
+
+  virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+
+
+
+
+  static bool HasBoxQuadsSupport(JSContext* aCx, JSObject* );
+
+protected:
+# 434 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual JSObject* WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) = 0;
+
+public:
+  mozilla::dom::ParentObject GetParentObject() const;
+
+
+
+
+
+
+  virtual nsINode* GetScopeChainParent() const;
+
+
+
+
+  bool IsElement() const {
+    return GetBoolFlag(NodeIsElement);
+  }
+
+
+
+
+
+  mozilla::dom::Element* AsElement();
+  const mozilla::dom::Element* AsElement() const;
+
+
+
+
+
+  nsIContent* AsContent();
+  const nsIContent* AsContent() const
+  {
+    return const_cast<nsINode*>(this)->AsContent();
+  }
+
+
+
+
+
+  mozilla::dom::Text* GetAsText();
+  const mozilla::dom::Text* GetAsText() const;
+
+  virtual nsIDOMNode* AsDOMNode() = 0;
+
+
+
+
+  bool HasChildren() const { return !!mFirstChild; }
+
+
+
+
+
+  virtual uint32_t GetChildCount() const = 0;
+
+
+
+
+
+
+  virtual nsIContent* GetChildAt(uint32_t aIndex) const = 0;
+# 506 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const = 0;
+# 516 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual int32_t IndexOf(const nsINode* aPossibleChild) const = 0;
+# 532 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIDocument *OwnerDoc() const
+  {
+    return mNodeInfo->GetDocument();
+  }
+
+
+
+
+
+  nsINode *OwnerDocAsNode() const;
+
+
+
+
+
+
+  bool IsInUncomposedDoc() const
+  {
+    return GetBoolFlag(IsInDocument);
+  }
+# 560 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIDocument* GetUncomposedDoc() const
+  {
+    return IsInUncomposedDoc() ? OwnerDoc() : nullptr;
+  }
+
+
+
+
+
+
+  nsIDocument* GetComposedDoc() const
+  {
+    return IsInShadowTree() ?
+      GetComposedDocInternal() : GetUncomposedDoc();
+  }
+
+
+
+
+  bool IsInComposedDoc() const
+  {
+    return IsInUncomposedDoc() || (IsInShadowTree() && GetComposedDocInternal());
+  }
+
+
+
+
+
+  uint16_t NodeType() const
+  {
+    return mNodeInfo->NodeType();
+  }
+  const nsString& NodeName() const
+  {
+    return mNodeInfo->NodeName();
+  }
+  const nsString& LocalName() const
+  {
+    return mNodeInfo->LocalName();
+  }
+
+
+
+
+
+  inline mozilla::dom::NodeInfo* NodeInfo() const
+  {
+    return mNodeInfo;
+  }
+
+  inline bool IsInNamespace(int32_t aNamespace) const
+  {
+    return mNodeInfo->NamespaceID() == aNamespace;
+  }
+
+
+
+
+
+  friend std::ostream& operator<<(std::ostream& aStream, const nsINode& aNode);
+
+protected:
+
+
+  inline bool IsNodeInternal() const
+  {
+    return false;
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsNodeInternal(First aFirst, Args... aArgs) const
+  {
+    return mNodeInfo->Equals(aFirst) || IsNodeInternal(aArgs...);
+  }
+
+public:
+  inline bool IsHTMLElement() const
+  {
+    return IsElement() && IsInNamespace(3);
+  }
+
+  inline bool IsHTMLElement(nsIAtom* aTag) const
+  {
+    return IsElement() && mNodeInfo->Equals(aTag, 3);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const
+  {
+    return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsSVGElement() const
+  {
+    return IsElement() && IsInNamespace(10);
+  }
+
+  inline bool IsSVGElement(nsIAtom* aTag) const
+  {
+    return IsElement() && mNodeInfo->Equals(aTag, 10);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const
+  {
+    return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsXULElement() const
+  {
+    return IsElement() && IsInNamespace(9);
+  }
+
+  inline bool IsXULElement(nsIAtom* aTag) const
+  {
+    return IsElement() && mNodeInfo->Equals(aTag, 9);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const
+  {
+    return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsMathMLElement() const
+  {
+    return IsElement() && IsInNamespace(7);
+  }
+
+  inline bool IsMathMLElement(nsIAtom* aTag) const
+  {
+    return IsElement() && mNodeInfo->Equals(aTag, 7);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const
+  {
+    return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+# 720 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
+                                 bool aNotify) = 0;
+# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult AppendChildTo(nsIContent* aKid, bool aNotify)
+  {
+    return InsertChildAt(aKid, GetChildCount(), aNotify);
+  }
+# 757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) = 0;
+# 770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void* GetProperty(nsIAtom *aPropertyName,
+                    nsresult *aStatus = nullptr) const
+  {
+    return GetProperty(0, aPropertyName, aStatus);
+  }
+# 788 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void* GetProperty(uint16_t aCategory, nsIAtom *aPropertyName,
+                    nsresult *aStatus = nullptr) const;
+# 808 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult SetProperty(nsIAtom *aPropertyName, void *aValue,
+                       NSPropertyDtorFunc aDtor = nullptr,
+                       bool aTransfer = false)
+  {
+    return SetProperty(0, aPropertyName, aValue, aDtor, aTransfer);
+  }
+# 834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult SetProperty(uint16_t aCategory,
+                       nsIAtom *aPropertyName, void *aValue,
+                       NSPropertyDtorFunc aDtor = nullptr,
+                       bool aTransfer = false,
+                       void **aOldValue = nullptr);
+
+
+
+
+  template<class T>
+  static void DeleteProperty(void *, nsIAtom *, void *aPropertyValue, void *)
+  {
+    delete static_cast<T *>(aPropertyValue);
+  }
+
+
+
+
+
+
+
+  void DeleteProperty(nsIAtom *aPropertyName)
+  {
+    DeleteProperty(0, aPropertyName);
+  }
+# 867 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void DeleteProperty(uint16_t aCategory, nsIAtom *aPropertyName);
+# 882 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void* UnsetProperty(nsIAtom *aPropertyName,
+                      nsresult *aStatus = nullptr)
+  {
+    return UnsetProperty(0, aPropertyName, aStatus);
+  }
+# 902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void* UnsetProperty(uint16_t aCategory, nsIAtom *aPropertyName,
+                      nsresult *aStatus = nullptr);
+
+  bool HasProperties() const
+  {
+    return HasFlag(NODE_HAS_PROPERTIES);
+  }
+
+
+
+
+
+  nsIPrincipal* NodePrincipal() const {
+    return mNodeInfo->NodeInfoManager()->DocumentPrincipal();
+  }
+
+
+
+
+
+  nsIContent* GetParent() const {
+    return (__builtin_expect(!!(GetBoolFlag(ParentIsContent)), 1)) ?
+      reinterpret_cast<nsIContent*>(mParent) : nullptr;
+  }
+
+
+
+
+
+
+  nsINode* GetParentNode() const
+  {
+    return mParent;
+  }
+# 945 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  inline nsINode* GetFlattenedTreeParentNode() const;
+
+
+
+
+
+
+
+  inline nsINode* GetFlattenedTreeParentNodeForStyle() const;
+
+
+
+
+
+  mozilla::dom::Element* GetParentElement() const
+  {
+    return mParent && mParent->IsElement() ? mParent->AsElement() : nullptr;
+  }
+
+
+
+
+
+  mozilla::dom::Element* GetParentElementCrossingShadowRoot() const;
+
+
+
+
+
+
+  nsINode* SubtreeRoot() const;
+
+
+
+
+
+  nsINode* GetRootNode(const mozilla::dom::GetRootNodeOptions& aOptions);
+
+
+
+
+  virtual nsresult AddEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc) override; virtual nsresult AddSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc) override; virtual nsresult RemoveEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture) override; virtual nsresult RemoveSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture) override; virtual nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval) override; virtual mozilla::dom::EventTarget * GetTargetForDOMEvent(void) override; virtual mozilla::dom::EventTarget * GetTargetForEventTargetChain(void) override; virtual nsresult GetEventTargetParent(mozilla::EventChainPreVisitor & aVisitor) override; virtual nsresult WillHandleEvent(mozilla::EventChainPostVisitor & aVisitor) override; virtual nsresult PostHandleEvent(mozilla::EventChainPostVisitor & aVisitor) override; virtual nsresult DispatchDOMEvent(mozilla::WidgetEvent *aEvent, nsIDOMEvent *aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) override; virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv) override;
+
+  virtual mozilla::EventListenerManager*
+    GetExistingListenerManager() const override;
+  virtual mozilla::EventListenerManager*
+    GetOrCreateListenerManager() override;
+
+  using mozilla::dom::EventTarget::RemoveEventListener;
+  using nsIDOMEventTarget::AddEventListener;
+  virtual void AddEventListener(const nsAString& aType,
+                                mozilla::dom::EventListener* aListener,
+                                const mozilla::dom::AddEventListenerOptionsOrBoolean& aOptions,
+                                const mozilla::dom::Nullable<bool>& aWantsUntrusted,
+                                mozilla::ErrorResult& aRv) override;
+  using nsIDOMEventTarget::AddSystemEventListener;
+
+  virtual bool IsApzAware() const override;
+
+  virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() override;
+  virtual nsIGlobalObject* GetOwnerGlobal() const override;
+
+
+
+
+
+
+  bool IsStyledByServo() const;
+
+
+
+
+  inline void UnsetRestyleFlagsIfGecko();
+# 1032 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void AddMutationObserver(nsIMutationObserver* aMutationObserver)
+  {
+    nsSlots* s = Slots();
+    do { } while(0);
+
+
+    s->mMutationObservers.AppendElement(aMutationObserver);
+  }
+# 1048 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void AddMutationObserverUnlessExists(nsIMutationObserver* aMutationObserver)
+  {
+    nsSlots* s = Slots();
+    s->mMutationObservers.AppendElementUnlessExists(aMutationObserver);
+  }
+
+
+
+
+
+
+
+  void AddAnimationObserver(nsIAnimationObserver* aAnimationObserver);
+
+
+
+
+
+  void AddAnimationObserverUnlessExists(nsIAnimationObserver* aAnimationObserver);
+
+
+
+
+  void RemoveMutationObserver(nsIMutationObserver* aMutationObserver)
+  {
+    nsSlots* s = GetExistingSlots();
+    if (s) {
+      s->mMutationObservers.RemoveElement(aMutationObserver);
+    }
+  }
+# 1088 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const = 0;
+
+
+
+  class nsSlots
+  {
+  public:
+    nsSlots();
+
+
+
+    virtual ~nsSlots();
+
+    void Traverse(nsCycleCollectionTraversalCallback &cb);
+    void Unlink();
+
+
+
+
+    nsTObserverArray<nsIMutationObserver*> mMutationObservers;
+
+
+
+
+
+
+    RefPtr<nsChildContentList> mChildNodes;
+
+
+
+
+
+    nsNodeWeakReference* mWeakReference;
+
+
+
+
+
+    uint32_t mEditableDescendantCount;
+  };
+# 1139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void SetFlags(FlagsType aFlagsToSet)
+  {
+    do { } while(0);
+
+
+
+
+
+
+
+    nsWrapperCache::SetFlags(aFlagsToSet);
+  }
+
+  void UnsetFlags(FlagsType aFlagsToUnset)
+  {
+    do { } while(0);
+
+
+
+
+    nsWrapperCache::UnsetFlags(aFlagsToUnset);
+  }
+
+  void ChangeEditableDescendantCount(int32_t aDelta);
+
+
+
+
+
+  uint32_t EditableDescendantCount();
+
+
+
+
+
+
+
+  void ResetEditableDescendantCount();
+
+  void SetEditableFlag(bool aEditable)
+  {
+    if (aEditable) {
+      SetFlags(NODE_IS_EDITABLE);
+    }
+    else {
+      UnsetFlags(NODE_IS_EDITABLE);
+    }
+  }
+
+  bool IsEditable() const
+  {
+
+    return IsEditableInternal();
+
+
+
+  }
+
+
+
+
+
+  bool IsNativeAnonymous() const
+  {
+    return HasFlag(NODE_IS_NATIVE_ANONYMOUS);
+  }
+
+
+
+
+  bool IsInNativeAnonymousSubtree() const
+  {
+
+
+
+
+
+
+
+    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE);
+
+  }
+
+  bool IsInAnonymousSubtree() const;
+
+
+  bool IsAnonymousContentInSVGUseSubtree() const;
+
+
+
+  bool ChromeOnlyAccess() const
+  {
+    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | NODE_CHROME_ONLY_ACCESS);
+  }
+
+  bool IsInShadowTree() const
+  {
+    return HasFlag(NODE_IS_IN_SHADOW_TREE);
+  }
+
+
+
+
+
+
+
+  bool IsSelectionDescendant() const
+  {
+    return IsDescendantOfCommonAncestorForRangeInSelection() ||
+           IsCommonAncestorForRangeInSelection();
+  }
+
+
+
+
+
+
+  nsIContent* GetTextEditorRootContent(nsIEditor** aEditor = nullptr);
+# 1266 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIContent* GetSelectionRootContent(nsIPresShell* aPresShell);
+
+  virtual nsINodeList* ChildNodes();
+  nsIContent* GetFirstChild() const { return mFirstChild; }
+  nsIContent* GetLastChild() const
+  {
+    uint32_t count;
+    nsIContent* const* children = GetChildArray(&count);
+
+    return count > 0 ? children[count - 1] : nullptr;
+  }
+
+
+
+
+
+  nsIDocument* GetOwnerDocument() const;
+
+  void Normalize();
+# 1294 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const = 0;
+  already_AddRefed<nsIURI> GetBaseURIObject() const;
+# 1305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  bool IsNodeApzAware() const
+  {
+    return NodeMayBeApzAware() ? IsNodeApzAwareInternal() : false;
+  }
+# 1318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  virtual bool IsNodeApzAwareInternal() const;
+
+
+
+  virtual bool IsHTMLShadowElement() const { return false; }
+
+
+
+  virtual bool IsHTMLContentElement() const { return false; }
+
+  void GetTextContent(nsAString& aTextContent,
+                      mozilla::OOMReporter& aError)
+  {
+    GetTextContentInternal(aTextContent, aError);
+  }
+  void SetTextContent(const nsAString& aTextContent,
+                      mozilla::ErrorResult& aError)
+  {
+    SetTextContentInternal(aTextContent, aError);
+  }
+
+  mozilla::dom::Element* QuerySelector(const nsAString& aSelector,
+                                       mozilla::ErrorResult& aResult);
+  already_AddRefed<nsINodeList> QuerySelectorAll(const nsAString& aSelector,
+                                                 mozilla::ErrorResult& aResult);
+
+protected:
+
+
+  mozilla::dom::Element* GetElementById(const nsAString& aId);
+# 1361 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult SetUserData(const nsAString& aKey, nsIVariant* aData,
+                       nsIVariant** aResult);
+# 1372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIVariant* GetUserData(const nsAString& aKey);
+
+public:
+  void LookupPrefix(const nsAString& aNamespace, nsAString& aResult);
+  bool IsDefaultNamespace(const nsAString& aNamespaceURI)
+  {
+    nsAutoString defaultNamespace;
+    LookupNamespaceURI(EmptyString(), defaultNamespace);
+    return aNamespaceURI.Equals(defaultNamespace);
+  }
+  void LookupNamespaceURI(const nsAString& aNamespacePrefix,
+                          nsAString& aNamespaceURI);
+
+  nsIContent* GetNextSibling() const { return mNextSibling; }
+  nsIContent* GetPreviousSibling() const { return mPreviousSibling; }
+# 1395 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIContent* GetNextNode(const nsINode* aRoot = nullptr) const
+  {
+    return GetNextNodeImpl(aRoot, false);
+  }
+# 1407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIContent* GetNextNonChildNode(const nsINode* aRoot = nullptr) const
+  {
+    return GetNextNodeImpl(aRoot, true);
+  }
+
+
+
+
+
+
+  bool Contains(const nsINode* aOther) const;
+
+  bool UnoptimizableCCNode() const;
+
+private:
+
+  nsIDocument* GetComposedDocInternal() const;
+
+  nsIContent* GetNextNodeImpl(const nsINode* aRoot,
+                              const bool aSkipChildren) const
+  {
+# 1438 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+    if (!aSkipChildren) {
+      nsIContent* kid = GetFirstChild();
+      if (kid) {
+        return kid;
+      }
+    }
+    if (this == aRoot) {
+      return nullptr;
+    }
+    const nsINode* cur = this;
+    while (1) {
+      nsIContent* next = cur->GetNextSibling();
+      if (next) {
+        return next;
+      }
+      nsINode* parent = cur->GetParentNode();
+      if (parent == aRoot) {
+        return nullptr;
+      }
+      cur = parent;
+    }
+    do { } while(0);
+  }
+
+public:
+# 1471 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsIContent* GetPreviousContent(const nsINode* aRoot = nullptr) const
+  {
+# 1484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+    if (this == aRoot) {
+      return nullptr;
+    }
+    nsIContent* cur = this->GetParent();
+    nsIContent* iter = this->GetPreviousSibling();
+    while (iter) {
+      cur = iter;
+      iter = reinterpret_cast<nsINode*>(iter)->GetLastChild();
+    }
+    return cur;
+  }
+
+
+
+
+private:
+  enum BooleanFlag {
+
+    NodeHasRenderingObservers,
+
+
+    IsInDocument,
+
+    ParentIsContent,
+
+    NodeIsElement,
+
+
+
+    ElementHasID,
+
+    ElementMayHaveClass,
+
+    ElementMayHaveStyle,
+
+    ElementHasName,
+
+    ElementMayHaveContentEditableAttr,
+
+
+    NodeIsCommonAncestorForRangeInSelection,
+
+    NodeIsDescendantOfCommonAncestorForRangeInSelection,
+
+    NodeIsCCMarkedRoot,
+
+    NodeIsCCBlackTree,
+
+
+    NodeIsPurpleRoot,
+
+    ElementHasLockedStyleStates,
+
+    ElementHasPointerLock,
+
+    NodeMayHaveDOMMutationObserver,
+
+    NodeIsContent,
+
+    ElementHasAnimations,
+
+    NodeHasValidDirAttribute,
+
+    NodeHasFixedDir,
+
+
+    NodeHasDirAutoSet,
+
+
+
+    NodeHasTextNodeDirectionalityMap,
+
+    NodeHasDirAuto,
+
+    NodeAncestorHasDirAuto,
+
+
+    ElementIsInStyleScope,
+
+    ElementIsScopedStyleRoot,
+
+    NodeHandlingClick,
+
+    NodeHasRelevantHoverRules,
+
+
+    ElementHasWeirdParserInsertionMode,
+
+    ParserHasNotified,
+
+    MayBeApzAware,
+
+    BooleanFlagCount
+  };
+
+  void SetBoolFlag(BooleanFlag name, bool value) {
+    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+                  "Too many boolean flags");
+    mBoolFlags = (mBoolFlags & ~(1 << name)) | (value << name);
+  }
+
+  void SetBoolFlag(BooleanFlag name) {
+    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+                  "Too many boolean flags");
+    mBoolFlags |= (1 << name);
+  }
+
+  void ClearBoolFlag(BooleanFlag name) {
+    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+                  "Too many boolean flags");
+    mBoolFlags &= ~(1 << name);
+  }
+
+  bool GetBoolFlag(BooleanFlag name) const {
+    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+                  "Too many boolean flags");
+    return mBoolFlags & (1 << name);
+  }
+
+public:
+  bool HasRenderingObservers() const
+    { return GetBoolFlag(NodeHasRenderingObservers); }
+  void SetHasRenderingObservers(bool aValue)
+    { SetBoolFlag(NodeHasRenderingObservers, aValue); }
+  bool IsContent() const { return GetBoolFlag(NodeIsContent); }
+  bool HasID() const { return GetBoolFlag(ElementHasID); }
+  bool MayHaveClass() const { return GetBoolFlag(ElementMayHaveClass); }
+  void SetMayHaveClass() { SetBoolFlag(ElementMayHaveClass); }
+  bool MayHaveStyle() const { return GetBoolFlag(ElementMayHaveStyle); }
+  bool HasName() const { return GetBoolFlag(ElementHasName); }
+  bool MayHaveContentEditableAttr() const
+    { return GetBoolFlag(ElementMayHaveContentEditableAttr); }
+  bool IsCommonAncestorForRangeInSelection() const
+    { return GetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+  void SetCommonAncestorForRangeInSelection()
+    { SetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+  void ClearCommonAncestorForRangeInSelection()
+    { ClearBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+  bool IsDescendantOfCommonAncestorForRangeInSelection() const
+    { return GetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+  void SetDescendantOfCommonAncestorForRangeInSelection()
+    { SetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+  void ClearDescendantOfCommonAncestorForRangeInSelection()
+    { ClearBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+
+  void SetCCMarkedRoot(bool aValue)
+    { SetBoolFlag(NodeIsCCMarkedRoot, aValue); }
+  bool CCMarkedRoot() const { return GetBoolFlag(NodeIsCCMarkedRoot); }
+  void SetInCCBlackTree(bool aValue)
+    { SetBoolFlag(NodeIsCCBlackTree, aValue); }
+  bool InCCBlackTree() const { return GetBoolFlag(NodeIsCCBlackTree); }
+  void SetIsPurpleRoot(bool aValue)
+    { SetBoolFlag(NodeIsPurpleRoot, aValue); }
+  bool IsPurpleRoot() const { return GetBoolFlag(NodeIsPurpleRoot); }
+  bool MayHaveDOMMutationObserver()
+    { return GetBoolFlag(NodeMayHaveDOMMutationObserver); }
+  void SetMayHaveDOMMutationObserver()
+    { SetBoolFlag(NodeMayHaveDOMMutationObserver, true); }
+  bool HasListenerManager() { return HasFlag(NODE_HAS_LISTENERMANAGER); }
+  bool HasPointerLock() const { return GetBoolFlag(ElementHasPointerLock); }
+  void SetPointerLock() { SetBoolFlag(ElementHasPointerLock); }
+  void ClearPointerLock() { ClearBoolFlag(ElementHasPointerLock); }
+  bool MayHaveAnimations() const { return GetBoolFlag(ElementHasAnimations); }
+  void SetMayHaveAnimations() { SetBoolFlag(ElementHasAnimations); }
+  void SetHasValidDir() { SetBoolFlag(NodeHasValidDirAttribute); }
+  void ClearHasValidDir() { ClearBoolFlag(NodeHasValidDirAttribute); }
+  bool HasValidDir() const { return GetBoolFlag(NodeHasValidDirAttribute); }
+  void SetHasFixedDir() {
+    do { } while (0);
+
+    SetBoolFlag(NodeHasFixedDir);
+  }
+  void ClearHasFixedDir() {
+    do { } while (0);
+
+    ClearBoolFlag(NodeHasFixedDir);
+  }
+  bool HasFixedDir() const { return GetBoolFlag(NodeHasFixedDir); }
+  void SetHasDirAutoSet() {
+    do { } while (0);
+
+    SetBoolFlag(NodeHasDirAutoSet);
+  }
+  void ClearHasDirAutoSet() {
+    do { } while (0);
+
+    ClearBoolFlag(NodeHasDirAutoSet);
+  }
+  bool HasDirAutoSet() const
+    { return GetBoolFlag(NodeHasDirAutoSet); }
+  void SetHasTextNodeDirectionalityMap() {
+    do { } while (0);
+
+    SetBoolFlag(NodeHasTextNodeDirectionalityMap);
+  }
+  void ClearHasTextNodeDirectionalityMap() {
+    do { } while (0);
+
+    ClearBoolFlag(NodeHasTextNodeDirectionalityMap);
+  }
+  bool HasTextNodeDirectionalityMap() const {
+    do { } while (0);
+
+    return GetBoolFlag(NodeHasTextNodeDirectionalityMap);
+  }
+
+  void SetHasDirAuto() { SetBoolFlag(NodeHasDirAuto); }
+  void ClearHasDirAuto() { ClearBoolFlag(NodeHasDirAuto); }
+  bool HasDirAuto() const { return GetBoolFlag(NodeHasDirAuto); }
+
+  void SetAncestorHasDirAuto() { SetBoolFlag(NodeAncestorHasDirAuto); }
+  void ClearAncestorHasDirAuto() { ClearBoolFlag(NodeAncestorHasDirAuto); }
+  bool AncestorHasDirAuto() const { return GetBoolFlag(NodeAncestorHasDirAuto); }
+
+  bool NodeOrAncestorHasDirAuto() const
+    { return HasDirAuto() || AncestorHasDirAuto(); }
+
+  void SetIsElementInStyleScope(bool aValue) {
+    do { } while (0);
+    SetBoolFlag(ElementIsInStyleScope, aValue);
+  }
+  void SetIsElementInStyleScope() {
+    do { } while (0);
+    SetBoolFlag(ElementIsInStyleScope);
+  }
+  void ClearIsElementInStyleScope() {
+    do { } while (0);
+    ClearBoolFlag(ElementIsInStyleScope);
+  }
+  bool IsElementInStyleScope() const { return GetBoolFlag(ElementIsInStyleScope); }
+
+  void SetIsScopedStyleRoot() { SetBoolFlag(ElementIsScopedStyleRoot); }
+  void ClearIsScopedStyleRoot() { ClearBoolFlag(ElementIsScopedStyleRoot); }
+  bool IsScopedStyleRoot() { return GetBoolFlag(ElementIsScopedStyleRoot); }
+  bool HasRelevantHoverRules() const { return GetBoolFlag(NodeHasRelevantHoverRules); }
+  void SetHasRelevantHoverRules() { SetBoolFlag(NodeHasRelevantHoverRules); }
+  void SetParserHasNotified() { SetBoolFlag(ParserHasNotified); };
+  bool HasParserNotified() { return GetBoolFlag(ParserHasNotified); }
+
+  void SetMayBeApzAware() { SetBoolFlag(MayBeApzAware); }
+  bool NodeMayBeApzAware() const
+  {
+    return GetBoolFlag(MayBeApzAware);
+  }
+protected:
+  void SetParentIsContent(bool aValue) { SetBoolFlag(ParentIsContent, aValue); }
+  void SetIsInDocument() { SetBoolFlag(IsInDocument); }
+  void SetNodeIsContent() { SetBoolFlag(NodeIsContent); }
+  void ClearInDocument() { ClearBoolFlag(IsInDocument); }
+  void SetIsElement() { SetBoolFlag(NodeIsElement); }
+  void SetHasID() { SetBoolFlag(ElementHasID); }
+  void ClearHasID() { ClearBoolFlag(ElementHasID); }
+  void SetMayHaveStyle() { SetBoolFlag(ElementMayHaveStyle); }
+  void SetHasName() { SetBoolFlag(ElementHasName); }
+  void ClearHasName() { ClearBoolFlag(ElementHasName); }
+  void SetMayHaveContentEditableAttr()
+    { SetBoolFlag(ElementMayHaveContentEditableAttr); }
+  void SetHasLockedStyleStates() { SetBoolFlag(ElementHasLockedStyleStates); }
+  void ClearHasLockedStyleStates() { ClearBoolFlag(ElementHasLockedStyleStates); }
+  bool HasLockedStyleStates() const
+    { return GetBoolFlag(ElementHasLockedStyleStates); }
+  void SetHasWeirdParserInsertionMode() { SetBoolFlag(ElementHasWeirdParserInsertionMode); }
+  bool HasWeirdParserInsertionMode() const
+  { return GetBoolFlag(ElementHasWeirdParserInsertionMode); }
+  bool HandlingClick() const { return GetBoolFlag(NodeHandlingClick); }
+  void SetHandlingClick() { SetBoolFlag(NodeHandlingClick); }
+  void ClearHandlingClick() { ClearBoolFlag(NodeHandlingClick); }
+
+  void SetSubtreeRootPointer(nsINode* aSubtreeRoot)
+  {
+    do { } while(0);
+    do { } while(0);
+
+    mSubtreeRoot = aSubtreeRoot;
+  }
+
+  void ClearSubtreeRootPointer()
+  {
+    mSubtreeRoot = nullptr;
+  }
+
+public:
+
+  void BindObject(nsISupports* aObject);
+
+
+  void UnbindObject(nsISupports* aObject);
+
+  void GetBoundMutationObservers(nsTArray<RefPtr<nsDOMMutationObserver> >& aResult);
+
+  already_AddRefed<mozilla::dom::AccessibleNode> GetAccessibleNode();
+
+
+
+
+
+  uint32_t Length() const;
+
+  void GetNodeName(mozilla::dom::DOMString& aNodeName)
+  {
+    const nsString& nodeName = NodeName();
+    aNodeName.SetStringBuffer(nsStringBuffer::FromString(nodeName),
+                              nodeName.Length());
+  }
+  __attribute__ ((warn_unused_result)) nsresult GetBaseURI(nsAString& aBaseURI) const;
+
+
+
+
+  void GetBaseURIFromJS(nsAString& aBaseURI,
+                        CallerType aCallerType,
+                        ErrorResult& aRv) const;
+  bool HasChildNodes() const
+  {
+    return HasChildren();
+  }
+  uint16_t CompareDocumentPosition(nsINode& aOther) const;
+  void GetNodeValue(nsAString& aNodeValue)
+  {
+    GetNodeValueInternal(aNodeValue);
+  }
+  void SetNodeValue(const nsAString& aNodeValue,
+                    mozilla::ErrorResult& aError)
+  {
+    SetNodeValueInternal(aNodeValue, aError);
+  }
+  virtual void GetNodeValueInternal(nsAString& aNodeValue);
+  virtual void SetNodeValueInternal(const nsAString& aNodeValue,
+                                    mozilla::ErrorResult& aError)
+  {
+
+
+  }
+  void EnsurePreInsertionValidity(nsINode& aNewChild, nsINode* aRefChild,
+                                  mozilla::ErrorResult& aError);
+  nsINode* InsertBefore(nsINode& aNode, nsINode* aChild,
+                        mozilla::ErrorResult& aError)
+  {
+    return ReplaceOrInsertBefore(false, &aNode, aChild, aError);
+  }
+  nsINode* AppendChild(nsINode& aNode, mozilla::ErrorResult& aError)
+  {
+    return InsertBefore(aNode, nullptr, aError);
+  }
+  nsINode* ReplaceChild(nsINode& aNode, nsINode& aChild,
+                        mozilla::ErrorResult& aError)
+  {
+    return ReplaceOrInsertBefore(true, &aNode, &aChild, aError);
+  }
+  nsINode* RemoveChild(nsINode& aChild, mozilla::ErrorResult& aError);
+  already_AddRefed<nsINode> CloneNode(bool aDeep, mozilla::ErrorResult& aError);
+  bool IsSameNode(nsINode* aNode);
+  bool IsEqualNode(nsINode* aNode);
+  void GetNamespaceURI(nsAString& aNamespaceURI) const
+  {
+    mNodeInfo->GetNamespaceURI(aNamespaceURI);
+  }
+
+  void GetPrefix(nsAString& aPrefix)
+  {
+    mNodeInfo->GetPrefix(aPrefix);
+  }
+
+  void GetLocalName(mozilla::dom::DOMString& aLocalName) const
+  {
+    const nsString& localName = LocalName();
+    if (localName.IsVoid()) {
+      aLocalName.SetNull();
+    } else {
+      aLocalName.SetStringBuffer(nsStringBuffer::FromString(localName),
+                                 localName.Length());
+    }
+  }
+
+  nsDOMAttributeMap* GetAttributes();
+  void SetUserData(JSContext* aCx, const nsAString& aKey,
+                   JS::Handle<JS::Value> aData,
+                   JS::MutableHandle<JS::Value> aRetval,
+                   mozilla::ErrorResult& aError);
+  void GetUserData(JSContext* aCx, const nsAString& aKey,
+                   JS::MutableHandle<JS::Value> aRetval,
+                   mozilla::ErrorResult& aError);
+
+
+
+
+  nsresult RemoveFromParent()
+  {
+    nsINode* parent = GetParentNode();
+    mozilla::ErrorResult rv;
+    parent->RemoveChild(*this, rv);
+    return rv.StealNSResult();
+  }
+
+
+  mozilla::dom::Element* GetPreviousElementSibling() const;
+  mozilla::dom::Element* GetNextElementSibling() const;
+
+  void Before(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
+  void After(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
+  void ReplaceWith(const Sequence<OwningNodeOrString>& aNodes,
+                   ErrorResult& aRv);
+
+
+
+  void Remove();
+
+
+  mozilla::dom::Element* GetFirstElementChild() const;
+  mozilla::dom::Element* GetLastElementChild() const;
+
+  void Prepend(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
+  void Append(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
+
+  void GetBoxQuads(const BoxQuadOptions& aOptions,
+                   nsTArray<RefPtr<DOMQuad> >& aResult,
+                   CallerType aCallerType,
+                   ErrorResult& aRv);
+
+  already_AddRefed<DOMQuad> ConvertQuadFromNode(DOMQuad& aQuad,
+                                                const TextOrElementOrDocument& aFrom,
+                                                const ConvertCoordinateOptions& aOptions,
+                                                CallerType aCallerType,
+                                                ErrorResult& aRv);
+  already_AddRefed<DOMQuad> ConvertRectFromNode(DOMRectReadOnly& aRect,
+                                                const TextOrElementOrDocument& aFrom,
+                                                const ConvertCoordinateOptions& aOptions,
+                                                CallerType aCallerType,
+                                                ErrorResult& aRv);
+  already_AddRefed<DOMPoint> ConvertPointFromNode(const DOMPointInit& aPoint,
+                                                  const TextOrElementOrDocument& aFrom,
+                                                  const ConvertCoordinateOptions& aOptions,
+                                                  CallerType aCallerType,
+                                                  ErrorResult& aRv);
+
+protected:
+
+
+
+  virtual nsINode::nsSlots* CreateSlots();
+
+  bool HasSlots() const
+  {
+    return mSlots != nullptr;
+  }
+
+  nsSlots* GetExistingSlots() const
+  {
+    return mSlots;
+  }
+
+  nsSlots* Slots()
+  {
+    if (!HasSlots()) {
+      mSlots = CreateSlots();
+      do { } while (0);
+    }
+    return GetExistingSlots();
+  }
+
+  nsTObserverArray<nsIMutationObserver*> *GetMutationObservers()
+  {
+    return HasSlots() ? &GetExistingSlots()->mMutationObservers : nullptr;
+  }
+
+  bool IsEditableInternal() const;
+  virtual bool IsEditableExternal() const
+  {
+    return IsEditableInternal();
+  }
+
+  virtual void GetTextContentInternal(nsAString& aTextContent,
+                                      mozilla::OOMReporter& aError);
+  virtual void SetTextContentInternal(const nsAString& aTextContent,
+                                      mozilla::ErrorResult& aError)
+  {
+  }
+# 1970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult GetParentNode(nsIDOMNode** aParentNode);
+  nsresult GetChildNodes(nsIDOMNodeList** aChildNodes);
+  nsresult GetFirstChild(nsIDOMNode** aFirstChild);
+  nsresult GetLastChild(nsIDOMNode** aLastChild);
+  nsresult GetPreviousSibling(nsIDOMNode** aPrevSibling);
+  nsresult GetNextSibling(nsIDOMNode** aNextSibling);
+  nsresult GetOwnerDocument(nsIDOMDocument** aOwnerDocument);
+
+  void EnsurePreInsertionValidity1(nsINode& aNewChild, nsINode* aRefChild,
+                                   mozilla::ErrorResult& aError);
+  void EnsurePreInsertionValidity2(bool aReplace, nsINode& aNewChild,
+                                   nsINode* aRefChild,
+                                   mozilla::ErrorResult& aError);
+  nsINode* ReplaceOrInsertBefore(bool aReplace, nsINode* aNewChild,
+                                 nsINode* aRefChild,
+                                 mozilla::ErrorResult& aError);
+  nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn);
+
+
+
+
+
+
+
+  virtual mozilla::dom::Element* GetNameSpaceElement() = 0;
+# 2007 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  void doRemoveChildAt(uint32_t aIndex, bool aNotify, nsIContent* aKid,
+                       nsAttrAndChildArray& aChildArray);
+# 2020 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsresult doInsertChildAt(nsIContent* aKid, uint32_t aIndex,
+                           bool aNotify, nsAttrAndChildArray& aChildArray);
+# 2031 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+  nsCSSSelectorList* ParseSelectorList(const nsAString& aSelectorString,
+                                       mozilla::ErrorResult& aRv);
+
+public:
+# 2048 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h" 1
+# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
+mozilla::dom::EventHandlerNonNull* GetOnabort(); void SetOnabort(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOncanplay(); void SetOncanplay(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOncanplaythrough(); void SetOncanplaythrough(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnchange(); void SetOnchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnauxclick(); void SetOnauxclick(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnclick(); void SetOnclick(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnclose(); void SetOnclose(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOncontextmenu(); void SetOncontextmenu(mozilla::dom::EventHandlerNonNull* listener);
+# 189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
+mozilla::dom::EventHandlerNonNull* GetOndblclick(); void SetOndblclick(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndrag(); void SetOndrag(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragend(); void SetOndragend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragenter(); void SetOndragenter(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragexit(); void SetOndragexit(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragleave(); void SetOndragleave(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragover(); void SetOndragover(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndragstart(); void SetOndragstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndrop(); void SetOndrop(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOndurationchange(); void SetOndurationchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnemptied(); void SetOnemptied(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnended(); void SetOnended(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnfullscreenchange(); void SetOnfullscreenchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnfullscreenerror(); void SetOnfullscreenerror(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOninput(); void SetOninput(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOninvalid(); void SetOninvalid(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnkeydown(); void SetOnkeydown(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnkeypress(); void SetOnkeypress(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnkeyup(); void SetOnkeyup(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozkeydownonplugin(); void SetOnmozkeydownonplugin(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozkeyuponplugin(); void SetOnmozkeyuponplugin(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnloadeddata(); void SetOnloadeddata(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnloadedmetadata(); void SetOnloadedmetadata(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnloadend(); void SetOnloadend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnloadstart(); void SetOnloadstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmousedown(); void SetOnmousedown(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmouseenter(); void SetOnmouseenter(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmouseleave(); void SetOnmouseleave(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmousemove(); void SetOnmousemove(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmouseout(); void SetOnmouseout(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmouseover(); void SetOnmouseover(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmouseup(); void SetOnmouseup(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozfullscreenchange(); void SetOnmozfullscreenchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozfullscreenerror(); void SetOnmozfullscreenerror(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozpointerlockchange(); void SetOnmozpointerlockchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnmozpointerlockerror(); void SetOnmozpointerlockerror(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerlockchange(); void SetOnpointerlockchange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerlockerror(); void SetOnpointerlockerror(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerdown(); void SetOnpointerdown(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointermove(); void SetOnpointermove(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerup(); void SetOnpointerup(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointercancel(); void SetOnpointercancel(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerover(); void SetOnpointerover(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerout(); void SetOnpointerout(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerenter(); void SetOnpointerenter(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpointerleave(); void SetOnpointerleave(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOngotpointercapture(); void SetOngotpointercapture(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnlostpointercapture(); void SetOnlostpointercapture(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnselectstart(); void SetOnselectstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpause(); void SetOnpause(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnplay(); void SetOnplay(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnplaying(); void SetOnplaying(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnprogress(); void SetOnprogress(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnratechange(); void SetOnratechange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnreset(); void SetOnreset(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnseeked(); void SetOnseeked(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnseeking(); void SetOnseeking(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnselect(); void SetOnselect(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnshow(); void SetOnshow(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnstalled(); void SetOnstalled(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnsubmit(); void SetOnsubmit(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnsuspend(); void SetOnsuspend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntimeupdate(); void SetOntimeupdate(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntoggle(); void SetOntoggle(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnvolumechange(); void SetOnvolumechange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwaiting(); void SetOnwaiting(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwheel(); void SetOnwheel(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOncopy(); void SetOncopy(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOncut(); void SetOncut(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnpaste(); void SetOnpaste(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnbeforescriptexecute(); void SetOnbeforescriptexecute(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnafterscriptexecute(); void SetOnafterscriptexecute(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnblur(); void SetOnblur(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnerror(); void SetOnerror(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnfocus(); void SetOnfocus(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnfocusin(); void SetOnfocusin(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnfocusout(); void SetOnfocusout(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnload(); void SetOnload(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnresize(); void SetOnresize(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnscroll(); void SetOnscroll(mozilla::dom::EventHandlerNonNull* listener);
+# 652 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
+mozilla::dom::EventHandlerNonNull* GetOntouchstart(); void SetOntouchstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntouchend(); void SetOntouchend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntouchmove(); void SetOntouchmove(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntouchcancel(); void SetOntouchcancel(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnreadystatechange(); void SetOnreadystatechange(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnselectionchange(); void SetOnselectionchange(mozilla::dom::EventHandlerNonNull* listener);
+# 970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
+mozilla::dom::EventHandlerNonNull* GetOntransitionstart(); void SetOntransitionstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntransitionrun(); void SetOntransitionrun(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntransitionend(); void SetOntransitionend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOntransitioncancel(); void SetOntransitioncancel(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnanimationstart(); void SetOnanimationstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnanimationend(); void SetOnanimationend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnanimationiteration(); void SetOnanimationiteration(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnanimationcancel(); void SetOnanimationcancel(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationEnd(); void SetOnwebkitAnimationEnd(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationIteration(); void SetOnwebkitAnimationIteration(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationStart(); void SetOnwebkitAnimationStart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitTransitionEnd(); void SetOnwebkitTransitionEnd(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationend(); void SetOnwebkitanimationend(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationiteration(); void SetOnwebkitanimationiteration(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationstart(); void SetOnwebkitanimationstart(mozilla::dom::EventHandlerNonNull* listener);
+
+
+
+mozilla::dom::EventHandlerNonNull* GetOnwebkittransitionend(); void SetOnwebkittransitionend(mozilla::dom::EventHandlerNonNull* listener);
+# 2049 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
+
+
+
+
+protected:
+  static bool Traverse(nsINode *tmp, nsCycleCollectionTraversalCallback &cb);
+  static void Unlink(nsINode *tmp);
+
+  RefPtr<mozilla::dom::NodeInfo> mNodeInfo;
+
+
+
+
+  nsINode* mParent;
+
+private:
+
+  uint32_t mBoolFlags;
+
+protected:
+
+
+  nsIContent* mNextSibling;
+  nsIContent* mPreviousSibling;
+
+
+
+  nsIContent* mFirstChild;
+
+  union {
+
+    nsIFrame* mPrimaryFrame;
+
+
+
+
+    nsINode* mSubtreeRoot;
+  };
+
+
+  nsSlots* mSlots;
+};
+
+inline nsIDOMNode* GetAsDOMNode(nsINode* aNode)
+{
+  return aNode ? aNode->AsDOMNode() : nullptr;
+}
+
+
+
+
+
+
+template<class C, class D>
+inline nsINode* NODE_FROM(C& aContent, D& aDocument)
+{
+  if (aContent)
+    return static_cast<nsINode*>(aContent);
+  return static_cast<nsINode*>(aDocument);
+}
+
+template<typename T> struct nsINode::COMTypeInfo<nsINode, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINode::COMTypeInfo<nsINode, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x70ba4547, 0x7699, 0x44fc, { 0xb3, 0x20, 0x52, 0xdb, 0xe3, 0xd1, 0xf9, 0x0a } };
+
+inline nsISupports*
+ToSupports(nsINode* aPointer)
+{
+  return aPointer;
+}
+
+inline nsISupports*
+ToCanonicalSupports(nsINode* aPointer)
+{
+  return aPointer;
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h" 2
+
+
+class nsAString;
+class nsIAtom;
+class nsIURI;
+class nsRuleWalker;
+class nsAttrValue;
+class nsAttrName;
+class nsTextFragment;
+class nsIFrame;
+class nsXBLBinding;
+
+namespace mozilla {
+class EventChainPreVisitor;
+namespace dom {
+class ShadowRoot;
+}
+namespace widget {
+struct IMEState;
+}
+}
+
+enum nsLinkState {
+  eLinkState_Unvisited = 1,
+  eLinkState_Visited = 2,
+  eLinkState_NotLink = 3
+};
+# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+class nsIContent : public nsINode {
+public:
+  typedef mozilla::widget::IMEState IMEState;
+
+
+
+
+
+  explicit nsIContent(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
+    : nsINode(aNodeInfo)
+  {
+    do { } while (0);
+    SetNodeIsContent();
+  }
+
+
+  template<typename T, typename U> struct COMTypeInfo;
+# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+                              nsIContent* aBindingParent,
+                              bool aCompileEventHandlers) = 0;
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual void UnbindFromTree(bool aDeep = true,
+                              bool aNullParent = true) = 0;
+
+  enum {
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+    eAllChildren = 0,
+# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+    eAllButXBL = 1,
+
+
+
+
+
+    eSkipPlaceholderContent = 2,
+
+
+
+
+
+
+    eSkipDocumentLevelNativeAnonymousContent = 4,
+  };
+# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) = 0;
+
+
+
+
+
+
+  bool IsRootOfNativeAnonymousSubtree() const
+  {
+    do { } while(0);
+
+
+
+    return HasFlag(NODE_IS_NATIVE_ANONYMOUS_ROOT);
+  }
+
+  bool IsRootOfChromeAccessOnlySubtree() const
+  {
+    return HasFlag(NODE_IS_NATIVE_ANONYMOUS_ROOT |
+                   NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS);
+  }
+
+
+
+
+
+  void SetIsNativeAnonymousRoot()
+  {
+    SetFlags(NODE_IS_ANONYMOUS_ROOT | NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
+             NODE_IS_NATIVE_ANONYMOUS_ROOT | NODE_IS_NATIVE_ANONYMOUS);
+  }
+
+
+
+
+
+  virtual nsIContent* FindFirstNonChromeOnlyAccessContent() const;
+
+
+
+
+
+  bool IsRootOfAnonymousSubtree() const
+  {
+    do { } while(0);
+
+
+
+    do { } while(0);
+# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+    return HasFlag(NODE_IS_ANONYMOUS_ROOT);
+  }
+
+
+
+
+
+
+  bool IsInAnonymousSubtree() const
+  {
+    do { } while(0);
+
+
+
+
+    return IsInNativeAnonymousSubtree() || (!IsInShadowTree() && GetBindingParent() != nullptr);
+  }
+
+
+
+
+
+  inline bool IsInHTMLDocument() const;
+
+
+
+
+
+  virtual bool IsInChromeDocument() const;
+
+
+
+
+
+  inline int32_t GetNameSpaceID() const
+  {
+    return mNodeInfo->NamespaceID();
+  }
+
+  inline bool IsHTMLElement() const
+  {
+    return IsInNamespace(3);
+  }
+
+  inline bool IsHTMLElement(nsIAtom* aTag) const
+  {
+    return mNodeInfo->Equals(aTag, 3);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const
+  {
+    return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsSVGElement() const
+  {
+    return IsInNamespace(10);
+  }
+
+  inline bool IsSVGElement(nsIAtom* aTag) const
+  {
+    return mNodeInfo->Equals(aTag, 10);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const
+  {
+    return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsXULElement() const
+  {
+    return IsInNamespace(9);
+  }
+
+  inline bool IsXULElement(nsIAtom* aTag) const
+  {
+    return mNodeInfo->Equals(aTag, 9);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const
+  {
+    return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+
+  inline bool IsMathMLElement() const
+  {
+    return IsInNamespace(7);
+  }
+
+  inline bool IsMathMLElement(nsIAtom* aTag) const
+  {
+    return mNodeInfo->Equals(aTag, 7);
+  }
+
+  template<typename First, typename... Args>
+  inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const
+  {
+    return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
+  }
+  inline bool IsActiveChildrenElement() const
+  {
+    return mNodeInfo->Equals(nsGkAtoms::children, 6) &&
+           GetBindingParent();
+  }
+
+  bool IsGeneratedContentContainerForBefore() const
+  {
+    return IsRootOfNativeAnonymousSubtree() &&
+           mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore;
+  }
+
+  bool IsGeneratedContentContainerForAfter() const
+  {
+    return IsRootOfNativeAnonymousSubtree() &&
+           mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentafter;
+  }
+# 361 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                   const nsAString& aValue, bool aNotify)
+  {
+    return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
+  }
+# 381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                           nsIAtom* aPrefix, const nsAString& aValue,
+                           bool aNotify) = 0;
+# 395 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+               nsAString& aResult) const;
+# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  bool HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const;
+# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  bool AttrValueIs(int32_t aNameSpaceID,
+                   nsIAtom* aName,
+                   const nsAString& aValue,
+                   nsCaseTreatment aCaseSensitive) const;
+# 432 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  bool AttrValueIs(int32_t aNameSpaceID,
+                   nsIAtom* aName,
+                   nsIAtom* aValue,
+                   nsCaseTreatment aCaseSensitive) const;
+
+  enum {
+    ATTR_MISSING = -1,
+    ATTR_VALUE_NO_MATCH = -2
+  };
+# 458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  typedef nsIAtom* const* const AttrValuesArray;
+  virtual int32_t FindAttrValueIn(int32_t aNameSpaceID,
+                                  nsIAtom* aName,
+                                  AttrValuesArray* aValues,
+                                  nsCaseTreatment aCaseSensitive) const
+  {
+    return ATTR_MISSING;
+  }
+# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttr,
+                             bool aNotify) = 0;
+# 490 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const = 0;
+
+
+
+
+  virtual mozilla::dom::BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const = 0;
+
+
+
+
+
+
+  virtual uint32_t GetAttrCount() const = 0;
+
+
+
+
+
+
+  virtual const nsTextFragment *GetText() = 0;
+
+
+
+
+
+  virtual uint32_t TextLength() const = 0;
+# 524 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual bool IsEventAttributeName(nsIAtom* aName)
+  {
+    return false;
+  }
+
+
+
+
+
+
+  virtual nsresult SetText(const char16_t* aBuffer, uint32_t aLength,
+                           bool aNotify) = 0;
+
+
+
+
+
+
+  virtual nsresult AppendText(const char16_t* aBuffer, uint32_t aLength,
+                              bool aNotify) = 0;
+
+
+
+
+
+
+  nsresult SetText(const nsAString& aStr, bool aNotify)
+  {
+    return SetText(aStr.BeginReading(), aStr.Length(), aNotify);
+  }
+
+
+
+
+
+  virtual bool TextIsOnlyWhitespace() = 0;
+
+
+
+
+  virtual bool ThreadSafeTextIsOnlyWhitespace() const = 0;
+
+
+
+
+
+
+
+  virtual bool HasTextForTranslation() = 0;
+
+
+
+
+
+  virtual void AppendTextTo(nsAString& aResult) = 0;
+
+
+
+
+
+  __attribute__ ((warn_unused_result))
+  virtual bool AppendTextTo(nsAString& aResult, const mozilla::fallible_t&) = 0;
+# 609 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  bool IsFocusable(int32_t* aTabIndex = nullptr, bool aWithMouse = false);
+  virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse);
+# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual bool PerformAccesskey(bool aKeyCausesActivation,
+                                bool aIsTrustedEvent)
+  {
+    return false;
+  }
+# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual IMEState GetDesiredIMEState();
+# 654 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual nsIContent *GetBindingParent() const = 0;
+
+
+
+
+
+
+  virtual nsXBLBinding *GetXBLBinding() const = 0;
+# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual void SetXBLBinding(nsXBLBinding* aBinding,
+                             nsBindingManager* aOldBindingManager = nullptr) = 0;
+
+
+
+
+
+
+
+  virtual void SetShadowRoot(mozilla::dom::ShadowRoot* aShadowRoot) = 0;
+
+
+
+
+
+
+  inline mozilla::dom::ShadowRoot *GetShadowRoot() const;
+# 701 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual mozilla::dom::ShadowRoot *GetContainingShadow() const = 0;
+
+
+
+
+
+
+  virtual nsTArray<nsIContent*> &DestInsertionPoints() = 0;
+
+
+
+
+
+
+  virtual nsTArray<nsIContent*> *GetExistingDestInsertionPoints() const = 0;
+
+
+
+
+
+
+
+  virtual nsIContent *GetXBLInsertionParent() const = 0;
+
+
+
+
+
+
+  virtual void SetXBLInsertionParent(nsIContent* aContent) = 0;
+
+
+
+
+
+  inline nsIContent *GetFlattenedTreeParent() const;
+
+
+  enum FlattenedParentType { eNotForStyle, eForStyle };
+  nsINode* GetFlattenedTreeParentNodeInternal(FlattenedParentType aType) const;
+# 755 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual bool IsLink(nsIURI** aURI) const = 0;
+# 764 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual already_AddRefed<nsIURI> GetHrefURI() const
+  {
+    return nullptr;
+  }
+# 796 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual void DoneCreatingElement()
+  {
+  }
+
+
+
+
+
+
+
+  virtual void BeginAddingChildren()
+  {
+  }
+# 829 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual void DoneAddingChildren(bool aHaveNotified)
+  {
+  }
+# 842 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual bool IsDoneAddingChildren()
+  {
+    return true;
+  }
+
+
+
+
+
+  nsIAtom* GetID() const {
+    if (HasID()) {
+      return DoGetID();
+    }
+    return nullptr;
+  }
+
+
+
+
+
+  virtual nsresult WalkContentStyleRules(nsRuleWalker* aRuleWalker) = 0;
+
+
+
+
+
+
+
+  virtual void UpdateEditableState(bool aNotify);
+
+
+
+
+
+  virtual void DestroyContent()
+  {
+  }
+
+
+
+
+  virtual void SaveSubtreeState() = 0;
+# 896 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  nsIFrame* GetPrimaryFrame() const
+  {
+    return (IsInUncomposedDoc() || IsInShadowTree()) ? mPrimaryFrame : nullptr;
+  }
+  void SetPrimaryFrame(nsIFrame* aFrame) {
+    do { } while (0);
+    do { } while(0);
+
+    mPrimaryFrame = aFrame;
+  }
+
+  nsresult LookupNamespaceURIInternal(const nsAString& aNamespacePrefix,
+                                      nsAString& aNamespaceURI) const;
+
+
+
+
+
+  bool HasIndependentSelection();
+
+
+
+
+
+
+  mozilla::dom::Element* GetEditingHost();
+
+
+
+
+
+
+  bool GetLang(nsAString& aResult) const {
+    for (const nsIContent* content = this; content; content = content->GetParent()) {
+      if (content->GetAttrCount() > 0) {
+
+
+        bool hasAttr = content->GetAttr(2, nsGkAtoms::lang,
+                                          aResult);
+        if (!hasAttr && (content->IsHTMLElement() || content->IsSVGElement() ||
+            content->IsXULElement())) {
+          hasAttr = content->GetAttr(kNameSpaceID_None, nsGkAtoms::lang,
+                                     aResult);
+        }
+        do { } while(0);
+
+        if (hasAttr) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+
+  bool IsNativeScrollbarContent() const {
+    return IsNativeAnonymous() &&
+           IsAnyOfXULElements(nsGkAtoms::scrollbar,
+                              nsGkAtoms::resizer,
+                              nsGkAtoms::scrollcorner);
+  }
+
+
+  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
+
+
+  already_AddRefed<nsIURI> GetBaseURIForStyleAttr() const;
+
+  virtual nsresult GetEventTargetParent(
+                     mozilla::EventChainPreVisitor& aVisitor) override;
+
+  virtual bool IsPurple() = 0;
+  virtual void RemovePurple() = 0;
+
+  virtual bool OwnedOnlyByTheDOMTree() { return false; }
+protected:
+
+
+
+
+  nsIAtom* DoGetID() const;
+
+
+  inline nsIURI* GetBaseURIWithoutXMLBase() const;
+
+public:
+# 1002 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
+  virtual void Describe(nsAString& aOutDescription) const {
+    aOutDescription = static_cast<const nsLiteralString&>(nsLiteralString(u"" "(not an element)"));
+  }
+
+  enum ETabFocusType {
+    eTabFocus_textControlsMask = (1<<0),
+    eTabFocus_formElementsMask = (1<<1),
+    eTabFocus_linksMask = (1<<2),
+    eTabFocus_any = 1 + (1<<1) + (1<<2)
+  };
+
+
+  static int32_t sTabFocusModel;
+
+
+
+  static bool sTabFocusModelAppliesToXUL;
+};
+
+template<typename T> struct nsIContent::COMTypeInfo<nsIContent, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContent::COMTypeInfo<nsIContent, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x8e1bab9d, 0x8815, 0x4d2c, { 0xa2, 0x4d, 0x7a, 0xba, 0x52, 0x39, 0xdc, 0x22 } };
+
+inline nsIContent* nsINode::AsContent()
+{
+  do { } while (0);
+  return static_cast<nsIContent*>(this);
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
+class nsIWeakReference : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult QueryReferent(const nsIID & uuid, void **result) = 0;
+
+     virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const = 0;
+};
+
+  template<typename T> struct nsIWeakReference::COMTypeInfo<nsIWeakReference, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIWeakReference::COMTypeInfo<nsIWeakReference, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9188bc85, 0xf92e, 0x11d2, { 0x81, 0xef, 0x00, 0x60, 0x08, 0x3a, 0x0b, 0xcf }};
+# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
+class nsISupportsWeakReference : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsISupportsWeakReference::COMTypeInfo<nsISupportsWeakReference, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupportsWeakReference::COMTypeInfo<nsISupportsWeakReference, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9188bc86, 0xf92e, 0x11d2, { 0x81, 0xef, 0x00, 0x60, 0x08, 0x3a, 0x0b, 0xcf }};
+# 176 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h" 2
+
+typedef nsCOMPtr<nsIWeakReference> nsWeakPtr;
+
+
+
+
+
+
+
+template<class T, class DestinationType>
+inline nsresult
+CallQueryReferent(T* aSource, DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return aSource->QueryReferent((DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                                reinterpret_cast<void**>(aDestination));
+}
+
+
+class nsQueryReferent final : public nsCOMPtr_helper
+{
+public:
+  nsQueryReferent(nsIWeakReference* aWeakPtr, nsresult* aError)
+    : mWeakPtr(aWeakPtr)
+    , mErrorPtr(aError)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID& aIID, void**) const
+    override;
+
+private:
+  nsIWeakReference* mWeakPtr;
+  nsresult* mErrorPtr;
+};
+
+inline const nsQueryReferent
+do_QueryReferent(nsIWeakReference* aRawPtr, nsresult* aError = 0)
+{
+  return nsQueryReferent(aRawPtr, aError);
+}
+
+
+
+
+
+extern nsIWeakReference* NS_GetWeakReference(nsISupports*,
+                                             nsresult* aResult = 0);
+# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h"
+inline already_AddRefed<nsIWeakReference>
+do_GetWeakReference(nsISupports* aRawPtr, nsresult* aError = 0)
+{
+  return dont_AddRef(NS_GetWeakReference(aRawPtr, aError));
+}
+
+inline void
+do_GetWeakReference(nsIWeakReference* aRawPtr, nsresult* aError = 0)
+{
+
+
+
+}
+
+template<class T>
+inline void
+do_GetWeakReference(already_AddRefed<T>&)
+{
+
+
+
+}
+
+template<class T>
+inline void
+do_GetWeakReference(already_AddRefed<T>&, nsresult*)
+{
+
+
+
+}
+# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 2
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+class nsAttrValue;
+class nsIAtom;
+class nsIContent;
+class nsIDocument;
+class nsINode;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+struct CharacterDataChangeInfo
+{
+
+
+
+  bool mAppend;
+
+
+
+
+  uint32_t mChangeStart;
+
+
+
+
+
+
+  uint32_t mChangeEnd;
+
+
+
+
+
+  uint32_t mReplaceLength;
+# 66 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  struct Details {
+    enum {
+      eMerge,
+      eSplit
+    } mType;
+
+
+
+
+    nsIContent* mNextSibling;
+  };
+
+
+
+
+  Details* mDetails;
+};
+# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+class nsIMutationObserver : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void CharacterDataWillChange(nsIDocument *aDocument,
+                                       nsIContent* aContent,
+                                       CharacterDataChangeInfo* aInfo) = 0;
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void CharacterDataChanged(nsIDocument *aDocument,
+                                    nsIContent* aContent,
+                                    CharacterDataChangeInfo* aInfo) = 0;
+# 170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void AttributeWillChange(nsIDocument* aDocument,
+                                   mozilla::dom::Element* aElement,
+                                   int32_t aNameSpaceID,
+                                   nsIAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aNewValue) = 0;
+# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void AttributeChanged(nsIDocument* aDocument,
+                                mozilla::dom::Element* aElement,
+                                int32_t aNameSpaceID,
+                                nsIAtom* aAttribute,
+                                int32_t aModType,
+                                const nsAttrValue* aOldValue) = 0;
+# 211 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void NativeAnonymousChildListChange(nsIDocument* aDocument,
+                                              nsIContent* aContent,
+                                              bool aIsRemove) {}
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void AttributeSetToCurrentValue(nsIDocument* aDocument,
+                                          mozilla::dom::Element* aElement,
+                                          int32_t aNameSpaceID,
+                                          nsIAtom* aAttribute) {}
+# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void ContentAppended(nsIDocument *aDocument,
+                               nsIContent* aContainer,
+                               nsIContent* aFirstNewContent,
+                               int32_t aNewIndexInContainer) = 0;
+# 270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void ContentInserted(nsIDocument *aDocument,
+                               nsIContent* aContainer,
+                               nsIContent* aChild,
+                               int32_t aIndexInContainer) = 0;
+# 297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void ContentRemoved(nsIDocument *aDocument,
+                              nsIContent* aContainer,
+                              nsIContent* aChild,
+                              int32_t aIndexInContainer,
+                              nsIContent* aPreviousSibling) = 0;
+# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void NodeWillBeDestroyed(const nsINode *aNode) = 0;
+# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
+  virtual void ParentChainChanged(nsIContent *aContent) = 0;
+};
+
+template<typename T> struct nsIMutationObserver::COMTypeInfo<nsIMutationObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMutationObserver::COMTypeInfo<nsIMutationObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x6d674c17, 0x0fbc, 0x4633, { 0x8f, 0x46, 0x73, 0x4e, 0x87, 0xeb, 0xf0, 0xc7 } };
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
+class nsCOMArray_base
+{
+  friend class nsArrayBase;
+protected:
+  nsCOMArray_base() {}
+  explicit nsCOMArray_base(int32_t aCount) : mArray(aCount) {}
+  nsCOMArray_base(const nsCOMArray_base& aOther);
+  ~nsCOMArray_base();
+
+  int32_t IndexOf(nsISupports* aObject, uint32_t aStartIndex = 0) const;
+  bool Contains(nsISupports* aObject) const
+  {
+    return IndexOf(aObject) != -1;
+  }
+
+  int32_t IndexOfObject(nsISupports* aObject) const;
+  bool ContainsObject(nsISupports* aObject) const
+  {
+    return IndexOfObject(aObject) != -1;
+  }
+
+  typedef bool (*nsBaseArrayEnumFunc)(void* aElement, void* aData);
+
+
+  bool EnumerateForwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
+
+  bool EnumerateBackwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
+
+  typedef int (*nsBaseArrayComparatorFunc)(nsISupports* aElement1,
+                                           nsISupports* aElement2,
+                                           void* aData);
+
+  struct nsCOMArrayComparatorContext
+  {
+    nsBaseArrayComparatorFunc mComparatorFunc;
+    void* mData;
+  };
+
+  static int nsCOMArrayComparator(const void* aElement1, const void* aElement2,
+                                  void* aData);
+  void Sort(nsBaseArrayComparatorFunc aFunc, void* aData);
+
+  bool InsertObjectAt(nsISupports* aObject, int32_t aIndex);
+  void InsertElementAt(uint32_t aIndex, nsISupports* aElement);
+  void InsertElementAt(uint32_t aIndex, already_AddRefed<nsISupports> aElement);
+  bool InsertObjectsAt(const nsCOMArray_base& aObjects, int32_t aIndex);
+  void InsertElementsAt(uint32_t aIndex, const nsCOMArray_base& aElements);
+  void InsertElementsAt(uint32_t aIndex, nsISupports* const* aElements,
+                        uint32_t aCount);
+  void ReplaceObjectAt(nsISupports* aObject, int32_t aIndex);
+  void ReplaceElementAt(uint32_t aIndex, nsISupports* aElement)
+  {
+    nsISupports* oldElement = mArray[aIndex];
+    ns_if_addref(mArray[aIndex] = aElement);
+    do { if (oldElement) { (oldElement)->Release(); (oldElement) = 0; } } while (0);
+  }
+  bool AppendObject(nsISupports* aObject)
+  {
+    return InsertObjectAt(aObject, Count());
+  }
+  void AppendElement(nsISupports* aElement)
+  {
+    InsertElementAt(Length(), aElement);
+  }
+  void AppendElement(already_AddRefed<nsISupports> aElement)
+  {
+    InsertElementAt(Length(), mozilla::Move(aElement));
+  }
+
+  bool AppendObjects(const nsCOMArray_base& aObjects)
+  {
+    return InsertObjectsAt(aObjects, Count());
+  }
+  void AppendElements(const nsCOMArray_base& aElements)
+  {
+    return InsertElementsAt(Length(), aElements);
+  }
+  void AppendElements(nsISupports* const* aElements, uint32_t aCount)
+  {
+    return InsertElementsAt(Length(), aElements, aCount);
+  }
+  bool RemoveObject(nsISupports* aObject);
+  nsISupports** Elements() { return mArray.Elements(); }
+  void SwapElements(nsCOMArray_base& aOther)
+  {
+    mArray.SwapElements(aOther.mArray);
+  }
+
+  void Adopt(nsISupports** aElements, uint32_t aCount);
+  uint32_t Forget(nsISupports*** aElements);
+public:
+
+  int32_t Count() const { return mArray.Length(); }
+
+  uint32_t Length() const { return mArray.Length(); }
+  bool IsEmpty() const { return mArray.IsEmpty(); }
+
+
+
+  bool SetCount(int32_t aNewCount);
+
+  void TruncateLength(uint32_t aNewLength)
+  {
+    if (mArray.Length() > aNewLength) {
+      RemoveElementsAt(aNewLength, mArray.Length() - aNewLength);
+    }
+  }
+
+
+  void Clear();
+
+  nsISupports* ObjectAt(int32_t aIndex) const { return mArray[aIndex]; }
+
+  nsISupports* ElementAt(uint32_t aIndex) const { return mArray[aIndex]; }
+
+  nsISupports* SafeObjectAt(int32_t aIndex) const
+  {
+    return mArray.SafeElementAt(aIndex, nullptr);
+  }
+
+  nsISupports* SafeElementAt(uint32_t aIndex) const
+  {
+    return mArray.SafeElementAt(aIndex, nullptr);
+  }
+
+  nsISupports* operator[](int32_t aIndex) const { return mArray[aIndex]; }
+
+
+
+  bool RemoveObjectAt(int32_t aIndex);
+
+  void RemoveElementAt(uint32_t aIndex);
+
+
+
+  bool RemoveObjectsAt(int32_t aIndex, int32_t aCount);
+
+  void RemoveElementsAt(uint32_t aIndex, uint32_t aCount);
+
+  void SwapElementsAt(uint32_t aIndex1, uint32_t aIndex2)
+  {
+    nsISupports* tmp = mArray[aIndex1];
+    mArray[aIndex1] = mArray[aIndex2];
+    mArray[aIndex2] = tmp;
+  }
+
+
+
+  void SetCapacity(uint32_t aCapacity) { mArray.SetCapacity(aCapacity); }
+  uint32_t Capacity() { return mArray.Capacity(); }
+# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+private:
+
+
+  nsTArray<nsISupports*> mArray;
+
+
+  nsCOMArray_base& operator=(const nsCOMArray_base& aOther) = delete;
+};
+
+inline void
+ImplCycleCollectionUnlink(nsCOMArray_base& aField)
+{
+  aField.Clear();
+}
+
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsCOMArray_base& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  aFlags |= CycleCollectionEdgeNameArrayFlag;
+  int32_t length = aField.Count();
+  for (int32_t i = 0; i < length; ++i) {
+    CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
+  }
+}
+# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
+template<class T>
+class nsCOMArray : public nsCOMArray_base
+{
+public:
+  typedef int32_t index_type;
+  typedef mozilla::ArrayIterator<T*, nsCOMArray> iterator;
+  typedef mozilla::ArrayIterator<const T*, nsCOMArray> const_iterator;
+  typedef mozilla::ReverseIterator<iterator> reverse_iterator;
+  typedef mozilla::ReverseIterator<const_iterator> const_reverse_iterator;
+
+  nsCOMArray() {}
+  explicit nsCOMArray(int32_t aCount) : nsCOMArray_base(aCount) {}
+  explicit nsCOMArray(const nsCOMArray<T>& aOther) : nsCOMArray_base(aOther) {}
+  nsCOMArray(nsCOMArray<T>&& aOther) { SwapElements(aOther); }
+  ~nsCOMArray() {}
+
+
+  nsCOMArray<T>& operator=(nsCOMArray<T> && aOther)
+  {
+    SwapElements(aOther);
+    return *this;
+  }
+
+
+  T* ObjectAt(int32_t aIndex) const
+  {
+    return static_cast<T*>(nsCOMArray_base::ObjectAt(aIndex));
+  }
+
+  T* ElementAt(uint32_t aIndex) const
+  {
+    return static_cast<T*>(nsCOMArray_base::ElementAt(aIndex));
+  }
+
+
+  T* SafeObjectAt(int32_t aIndex) const
+  {
+    return static_cast<T*>(nsCOMArray_base::SafeObjectAt(aIndex));
+  }
+
+  T* SafeElementAt(uint32_t aIndex) const
+  {
+    return static_cast<T*>(nsCOMArray_base::SafeElementAt(aIndex));
+  }
+
+
+  T* operator[](int32_t aIndex) const { return ObjectAt(aIndex); }
+
+
+
+
+  int32_t IndexOf(T* aObject, uint32_t aStartIndex = 0) const
+  {
+    return nsCOMArray_base::IndexOf(aObject, aStartIndex);
+  }
+  bool Contains(T* aObject) const
+  {
+    return nsCOMArray_base::Contains(aObject);
+  }
+
+
+
+
+
+
+  int32_t IndexOfObject(T* aObject) const
+  {
+    return nsCOMArray_base::IndexOfObject(aObject);
+  }
+  bool ContainsObject(nsISupports* aObject) const
+  {
+    return nsCOMArray_base::ContainsObject(aObject);
+  }
+
+
+
+  bool InsertObjectAt(T* aObject, int32_t aIndex)
+  {
+    return nsCOMArray_base::InsertObjectAt(aObject, aIndex);
+  }
+
+  void InsertElementAt(uint32_t aIndex, T* aElement)
+  {
+    nsCOMArray_base::InsertElementAt(aIndex, aElement);
+  }
+
+
+
+  bool InsertObjectsAt(const nsCOMArray<T>& aObjects, int32_t aIndex)
+  {
+    return nsCOMArray_base::InsertObjectsAt(aObjects, aIndex);
+  }
+
+  void InsertElementsAt(uint32_t aIndex, const nsCOMArray<T>& aElements)
+  {
+    nsCOMArray_base::InsertElementsAt(aIndex, aElements);
+  }
+  void InsertElementsAt(uint32_t aIndex, T* const* aElements, uint32_t aCount)
+  {
+    nsCOMArray_base::InsertElementsAt(
+      aIndex, reinterpret_cast<nsISupports* const*>(aElements), aCount);
+  }
+
+
+
+  void ReplaceObjectAt(T* aObject, int32_t aIndex)
+  {
+    nsCOMArray_base::ReplaceObjectAt(aObject, aIndex);
+  }
+
+  void ReplaceElementAt(uint32_t aIndex, T* aElement)
+  {
+    nsCOMArray_base::ReplaceElementAt(aIndex, aElement);
+  }
+
+  typedef int (*nsCOMArrayComparatorFunc)(T* aElement1, T* aElement2,
+                                          void* aData);
+
+  void Sort(nsCOMArrayComparatorFunc aFunc, void* aData)
+  {
+    nsCOMArray_base::Sort(nsBaseArrayComparatorFunc(aFunc), aData);
+  }
+
+
+  bool AppendObject(T* aObject)
+  {
+    return nsCOMArray_base::AppendObject(aObject);
+  }
+
+  void AppendElement(T* aElement)
+  {
+    nsCOMArray_base::AppendElement(aElement);
+  }
+  void AppendElement(already_AddRefed<T> aElement)
+  {
+    nsCOMArray_base::AppendElement(mozilla::Move(aElement));
+  }
+
+
+  bool AppendObjects(const nsCOMArray<T>& aObjects)
+  {
+    return nsCOMArray_base::AppendObjects(aObjects);
+  }
+
+  void AppendElements(const nsCOMArray<T>& aElements)
+  {
+    return nsCOMArray_base::AppendElements(aElements);
+  }
+  void AppendElements(T* const* aElements, uint32_t aCount)
+  {
+    InsertElementsAt(Length(), aElements, aCount);
+  }
+
+
+
+
+  bool RemoveObject(T* aObject)
+  {
+    return nsCOMArray_base::RemoveObject(aObject);
+  }
+
+  bool RemoveElement(T* aElement)
+  {
+    return nsCOMArray_base::RemoveObject(aElement);
+  }
+
+  T** Elements()
+  {
+    return reinterpret_cast<T**>(nsCOMArray_base::Elements());
+  }
+  void SwapElements(nsCOMArray<T>& aOther)
+  {
+    nsCOMArray_base::SwapElements(aOther);
+  }
+# 418 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
+  void Adopt(T** aElements, uint32_t aSize)
+  {
+    nsCOMArray_base::Adopt(reinterpret_cast<nsISupports**>(aElements), aSize);
+  }
+# 431 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
+  uint32_t Forget(T*** aElements)
+  {
+    return nsCOMArray_base::Forget(reinterpret_cast<nsISupports***>(aElements));
+  }
+
+
+  iterator begin() { return iterator(*this, 0); }
+  const_iterator begin() const { return const_iterator(*this, 0); }
+  const_iterator cbegin() const { return begin(); }
+  iterator end() { return iterator(*this, Length()); }
+  const_iterator end() const { return const_iterator(*this, Length()); }
+  const_iterator cend() const { return end(); }
+
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  const_reverse_iterator crend() const { return rend(); }
+
+private:
+
+
+  nsCOMArray<T>& operator=(const nsCOMArray<T>& aOther) = delete;
+};
+
+template<typename T>
+inline void
+ImplCycleCollectionUnlink(nsCOMArray<T>& aField)
+{
+  aField.Clear();
+}
+
+template<typename E>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsCOMArray<E>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  aFlags |= CycleCollectionEdgeNameArrayFlag;
+  int32_t length = aField.Count();
+  for (int32_t i = 0; i < length; ++i) {
+    CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
+  }
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 2
+
+struct CharacterDataChangeInfo;
+template<class E> class nsCOMArray;
+class nsCycleCollectionTraversalCallback;
+namespace mozilla {
+struct NonOwningAnimationTarget;
+namespace dom {
+class Animation;
+}
+}
+
+class nsNodeUtils
+{
+public:
+
+
+
+
+
+
+  static void CharacterDataWillChange(nsIContent* aContent,
+                                      CharacterDataChangeInfo* aInfo);
+
+
+
+
+
+
+
+  static void CharacterDataChanged(nsIContent* aContent,
+                                   CharacterDataChangeInfo* aInfo);
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static void AttributeWillChange(mozilla::dom::Element* aElement,
+                                  int32_t aNameSpaceID,
+                                  nsIAtom* aAttribute,
+                                  int32_t aModType,
+                                  const nsAttrValue* aNewValue);
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static void AttributeChanged(mozilla::dom::Element* aElement,
+                               int32_t aNameSpaceID,
+                               nsIAtom* aAttribute,
+                               int32_t aModType,
+                               const nsAttrValue* aOldValue);
+# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static void AttributeSetToCurrentValue(mozilla::dom::Element* aElement,
+                                         int32_t aNameSpaceID,
+                                         nsIAtom* aAttribute);
+# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static void ContentAppended(nsIContent* aContainer,
+                              nsIContent* aFirstNewContent,
+                              int32_t aNewIndexInContainer);
+
+
+
+
+
+
+
+  static void NativeAnonymousChildListChange(nsIContent* aContent,
+                                             bool aIsRemove);
+# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static void ContentInserted(nsINode* aContainer,
+                              nsIContent* aChild,
+                              int32_t aIndexInContainer);
+
+
+
+
+
+
+
+  static void ContentRemoved(nsINode* aContainer,
+                             nsIContent* aChild,
+                             int32_t aIndexInContainer,
+                             nsIContent* aPreviousSibling);
+
+
+
+
+
+  static inline void ParentChainChanged(nsIContent *aContent)
+  {
+    nsINode::nsSlots* slots = aContent->GetExistingSlots();
+    if (slots && !slots->mMutationObservers.IsEmpty()) {
+      do { nsTObserverArray<nsIMutationObserver *>::ForwardIterator iter_(slots->mMutationObservers); nsIMutationObserver* obs_; while (iter_.HasMore()) { obs_ = iter_.GetNext(); obs_ -> ParentChainChanged (aContent) ; } } while(0);
+
+
+
+    }
+  }
+
+
+
+
+
+
+  static mozilla::Maybe<mozilla::NonOwningAnimationTarget>
+    GetTargetForAnimation(const mozilla::dom::Animation* aAnimation);
+
+
+
+
+
+  static void AnimationAdded(mozilla::dom::Animation* aAnimation);
+  static void AnimationChanged(mozilla::dom::Animation* aAnimation);
+  static void AnimationRemoved(mozilla::dom::Animation* aAnimation);
+
+
+
+
+
+  static void LastRelease(nsINode* aNode);
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static nsresult Clone(nsINode *aNode, bool aDeep,
+                        nsNodeInfoManager *aNewNodeInfoManager,
+                        nsCOMArray<nsINode> &aNodesWithProperties,
+                        nsINode **aResult)
+  {
+    return CloneAndAdopt(aNode, true, aDeep, aNewNodeInfoManager,
+                         nullptr, aNodesWithProperties, nullptr, aResult);
+  }
+
+
+
+
+  static nsresult Clone(nsINode *aNode, bool aDeep, nsINode **aResult)
+  {
+    nsCOMArray<nsINode> dummyNodeWithProperties;
+    return CloneAndAdopt(aNode, true, aDeep, nullptr, nullptr,
+                         dummyNodeWithProperties, aNode->GetParent(), aResult);
+  }
+# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static nsresult Adopt(nsINode *aNode, nsNodeInfoManager *aNewNodeInfoManager,
+                        JS::Handle<JSObject*> aReparentScope,
+                        nsCOMArray<nsINode> &aNodesWithProperties)
+  {
+    nsCOMPtr<nsINode> node;
+    nsresult rv = CloneAndAdopt(aNode, false, true, aNewNodeInfoManager,
+                                aReparentScope, aNodesWithProperties,
+                                nullptr, getter_AddRefs(node));
+
+    nsMutationGuard::DidMutate();
+
+    return rv;
+  }
+
+
+
+
+
+
+
+  static void TraverseUserData(nsINode* aNode,
+                               nsCycleCollectionTraversalCallback &aCb);
+# 254 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static nsresult CloneNodeImpl(nsINode *aNode, bool aDeep, nsINode **aResult);
+
+
+
+
+
+
+  static void UnlinkUserData(nsINode *aNode);
+
+
+
+
+
+
+  static bool IsTemplateElement(const nsINode *aNode);
+# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static nsIContent* GetFirstChildOfTemplateOrNode(nsINode* aNode);
+
+private:
+# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
+  static nsresult CloneAndAdopt(nsINode *aNode, bool aClone, bool aDeep,
+                                nsNodeInfoManager *aNewNodeInfoManager,
+                                JS::Handle<JSObject*> aReparentScope,
+                                nsCOMArray<nsINode> &aNodesWithProperties,
+                                nsINode *aParent, nsINode **aResult);
+
+  enum class AnimationMutationType
+  {
+    Added,
+    Changed,
+    Removed
+  };
+
+
+
+
+
+
+  static void AnimationMutated(mozilla::dom::Animation* aAnimation,
+                               AnimationMutationType aMutatedType);
+
+};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMHTMLCollection.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMHTMLCollection.h"
+class nsIDOMHTMLCollection : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+
+  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) = 0;
+
+
+  virtual nsresult NamedItem(const nsAString & name, nsIDOMNode * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIDOMHTMLCollection::COMTypeInfo<nsIDOMHTMLCollection, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMHTMLCollection::COMTypeInfo<nsIDOMHTMLCollection, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbb07f567, 0x5b37, 0x4172, { 0x92, 0xaa, 0x7d, 0x00, 0xce, 0xed, 0x48, 0x09 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h" 2
+
+
+
+
+
+class nsINode;
+class nsString;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h"
+class nsIHTMLCollection : public nsIDOMHTMLCollection
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+  virtual nsINode* GetParentObject() = 0;
+
+  using nsIDOMHTMLCollection::Item;
+  using nsIDOMHTMLCollection::NamedItem;
+
+  uint32_t Length()
+  {
+    uint32_t length;
+    GetLength(&length);
+    return length;
+  }
+  virtual mozilla::dom::Element* GetElementAt(uint32_t index) = 0;
+  mozilla::dom::Element* Item(uint32_t index)
+  {
+    return GetElementAt(index);
+  }
+  mozilla::dom::Element* IndexedGetter(uint32_t index, bool& aFound)
+  {
+    mozilla::dom::Element* item = Item(index);
+    aFound = !!item;
+    return item;
+  }
+  mozilla::dom::Element* NamedItem(const nsAString& aName)
+  {
+    bool dummy;
+    return NamedGetter(aName, dummy);
+  }
+  mozilla::dom::Element* NamedGetter(const nsAString& aName, bool& aFound)
+  {
+    return GetFirstNamedElement(aName, aFound);
+  }
+  virtual mozilla::dom::Element*
+  GetFirstNamedElement(const nsAString& aName, bool& aFound) = 0;
+
+  virtual void GetSupportedNames(nsTArray<nsString>& aNames) = 0;
+
+  JSObject* GetWrapperPreserveColor()
+  {
+    return GetWrapperPreserveColorInternal();
+  }
+  JSObject* GetWrapper()
+  {
+    JSObject* obj = GetWrapperPreserveColor();
+    if (obj) {
+      JS::ExposeObjectToActiveJS(obj);
+    }
+    return obj;
+  }
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) = 0;
+protected:
+  virtual JSObject* GetWrapperPreserveColorInternal() = 0;
+};
+
+template<typename T> struct nsIHTMLCollection::COMTypeInfo<nsIHTMLCollection, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHTMLCollection::COMTypeInfo<nsIHTMLCollection, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x4e169191, 0x5196, 0x4e17, { 0xa4, 0x79, 0xd5, 0x35, 0x0b, 0x5b, 0x0a, 0xcd } };
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHashable.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHashable.h"
+class nsIHashable : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Equals(nsIHashable *aOther, bool *_retval) = 0;
+
+
+  virtual nsresult GetHashCode(uint32_t *aHashCode) = 0;
+
+};
+
+  template<typename T> struct nsIHashable::COMTypeInfo<nsIHashable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHashable::COMTypeInfo<nsIHashable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x17e595fa, 0xb57a, 0x4933, { 0xbd, 0x0f, 0xb1, 0x81, 0x2e, 0x8a, 0xb1, 0x88 }};
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+typedef uint32_t PLDHashNumber;
+
+class PLDHashTable;
+struct PLDHashTableOps;
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+struct PLDHashEntryHdr
+{
+private:
+  friend class PLDHashTable;
+
+  PLDHashNumber mKeyHash;
+};
+# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+class PLDHashTable
+{
+private:
+
+
+  class EntryStore
+  {
+  private:
+    char* mEntryStore;
+    uint32_t mGeneration;
+
+  public:
+    EntryStore() : mEntryStore(nullptr), mGeneration(0) {}
+
+    ~EntryStore()
+    {
+      free(mEntryStore);
+      mEntryStore = nullptr;
+      mGeneration++;
+    }
+
+    char* Get() { return mEntryStore; }
+    const char* Get() const { return mEntryStore; }
+
+    void Set(char* aEntryStore)
+    {
+      mEntryStore = aEntryStore;
+      mGeneration++;
+    }
+
+    uint32_t Generation() const { return mGeneration; }
+  };
+
+  const PLDHashTableOps* const mOps;
+  int16_t mHashShift;
+  const uint32_t mEntrySize;
+  uint32_t mEntryCount;
+  uint32_t mRemovedCount;
+  EntryStore mEntryStore;
+
+
+
+
+
+public:
+
+
+
+
+
+
+  static const uint32_t kMaxCapacity = ((uint32_t)1 << 26);
+
+  static const uint32_t kMinCapacity = 8;
+
+
+
+  static const uint32_t kMaxInitialLength = kMaxCapacity / 2;
+
+
+  static const uint32_t kDefaultInitialLength = 4;
+# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+  PLDHashTable(const PLDHashTableOps* aOps, uint32_t aEntrySize,
+               uint32_t aLength = kDefaultInitialLength);
+
+  PLDHashTable(PLDHashTable&& aOther)
+
+
+    : mOps(aOther.mOps)
+    , mEntrySize(aOther.mEntrySize)
+
+
+    , mEntryStore()
+
+
+
+  {
+    *this = mozilla::Move(aOther);
+  }
+
+  PLDHashTable& operator=(PLDHashTable&& aOther);
+
+  ~PLDHashTable();
+
+
+  const PLDHashTableOps* Ops() const { return mOps; }
+
+
+
+
+  uint32_t Capacity() const
+  {
+    return mEntryStore.Get() ? CapacityFromHashShift() : 0;
+  }
+
+  uint32_t EntrySize() const { return mEntrySize; }
+  uint32_t EntryCount() const { return mEntryCount; }
+  uint32_t Generation() const { return mEntryStore.Generation(); }
+
+
+
+
+
+
+
+  PLDHashEntryHdr* Search(const void* aKey);
+# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+  PLDHashEntryHdr* Add(const void* aKey, const mozilla::fallible_t&);
+
+
+
+  PLDHashEntryHdr* Add(const void* aKey);
+
+
+
+
+
+
+
+  void Remove(const void* aKey);
+
+
+
+
+
+
+
+  void RemoveEntry(PLDHashEntryHdr* aEntry);
+
+
+
+
+
+
+
+  void RawRemove(PLDHashEntryHdr* aEntry);
+
+
+
+  void Clear();
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+  void ClearAndPrepareForLength(uint32_t aLength);
+
+
+
+
+  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+# 396 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+  static const PLDHashTableOps* StubOps();
+
+
+  static PLDHashNumber HashVoidPtrKeyStub(const void* aKey);
+  static bool MatchEntryStub(const PLDHashEntryHdr* aEntry, const void* aKey);
+  static void MoveEntryStub(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
+                            PLDHashEntryHdr* aTo);
+  static void ClearEntryStub(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
+
+
+  static PLDHashNumber HashStringKey(const void* aKey);
+  static bool MatchStringKey(const PLDHashEntryHdr* aEntry, const void* aKey);
+# 435 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+  class Iterator
+  {
+  public:
+    explicit Iterator(PLDHashTable* aTable);
+    Iterator(Iterator&& aOther);
+    ~Iterator();
+
+
+    bool Done() const { return mNexts == mNextsLimit; }
+
+
+    PLDHashEntryHdr* Get() const
+    {
+      do { } while (0);
+
+      PLDHashEntryHdr* entry = reinterpret_cast<PLDHashEntryHdr*>(mCurrent);
+      do { } while (0);
+      return entry;
+    }
+
+
+    void Next();
+
+
+
+    void Remove();
+
+  protected:
+    PLDHashTable* mTable;
+
+  private:
+    char* mStart;
+    char* mLimit;
+    char* mCurrent;
+    uint32_t mNexts;
+    uint32_t mNextsLimit;
+
+    bool mHaveRemoved;
+
+    bool IsOnNonLiveEntry() const;
+    void MoveToNextEntry();
+
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&&) = delete;
+  };
+
+  Iterator Iter() { return Iterator(this); }
+
+
+
+  Iterator ConstIter() const
+  {
+    return Iterator(const_cast<PLDHashTable*>(this));
+  }
+
+private:
+
+
+  static const uint32_t kHashBits = 32;
+  static const uint32_t kGoldenRatio = 0x9E3779B9U;
+
+  static uint32_t HashShift(uint32_t aEntrySize, uint32_t aLength);
+
+  static const PLDHashNumber kCollisionFlag = 1;
+
+  static bool EntryIsFree(PLDHashEntryHdr* aEntry)
+  {
+    return aEntry->mKeyHash == 0;
+  }
+  static bool EntryIsRemoved(PLDHashEntryHdr* aEntry)
+  {
+    return aEntry->mKeyHash == 1;
+  }
+  static bool EntryIsLive(PLDHashEntryHdr* aEntry)
+  {
+    return aEntry->mKeyHash >= 2;
+  }
+
+  static void MarkEntryFree(PLDHashEntryHdr* aEntry)
+  {
+    aEntry->mKeyHash = 0;
+  }
+  static void MarkEntryRemoved(PLDHashEntryHdr* aEntry)
+  {
+    aEntry->mKeyHash = 1;
+  }
+
+  PLDHashNumber Hash1(PLDHashNumber aHash0);
+  void Hash2(PLDHashNumber aHash, uint32_t& aHash2Out, uint32_t& aSizeMaskOut);
+
+  static bool MatchEntryKeyhash(PLDHashEntryHdr* aEntry, PLDHashNumber aHash);
+  PLDHashEntryHdr* AddressEntry(uint32_t aIndex);
+
+
+
+  uint32_t CapacityFromHashShift() const
+  {
+    return ((uint32_t)1 << (kHashBits - mHashShift));
+  }
+
+  PLDHashNumber ComputeKeyHash(const void* aKey);
+
+  enum SearchReason { ForSearchOrRemove, ForAdd };
+
+  template <SearchReason Reason>
+  PLDHashEntryHdr*
+    SearchTable(const void* aKey, PLDHashNumber aKeyHash);
+
+  PLDHashEntryHdr* FindFreeEntry(PLDHashNumber aKeyHash);
+
+  bool ChangeTable(int aDeltaLog2);
+
+  void ShrinkIfAppropriate();
+
+  PLDHashTable(const PLDHashTable& aOther) = delete;
+  PLDHashTable& operator=(const PLDHashTable& aOther) = delete;
+};
+
+
+
+typedef PLDHashNumber (*PLDHashHashKey)(const void* aKey);
+
+
+
+typedef bool (*PLDHashMatchEntry)(const PLDHashEntryHdr* aEntry,
+                                  const void* aKey);
+
+
+
+
+
+typedef void (*PLDHashMoveEntry)(PLDHashTable* aTable,
+                                 const PLDHashEntryHdr* aFrom,
+                                 PLDHashEntryHdr* aTo);
+
+
+
+typedef void (*PLDHashClearEntry)(PLDHashTable* aTable,
+                                  PLDHashEntryHdr* aEntry);
+
+
+
+
+
+typedef void (*PLDHashInitEntry)(PLDHashEntryHdr* aEntry, const void* aKey);
+# 603 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
+struct PLDHashTableOps
+{
+
+  PLDHashHashKey hashKey;
+  PLDHashMatchEntry matchEntry;
+  PLDHashMoveEntry moveEntry;
+  PLDHashClearEntry clearEntry;
+
+
+  PLDHashInitEntry initEntry;
+};
+
+
+struct PLDHashEntryStub : public PLDHashEntryHdr
+{
+  const void* key;
+};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
+const char* NS_strspnp(const char* aDelims, const char* aStr);
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
+char* NS_strtok(const char* aDelims, char** aStr);
+
+
+
+
+uint32_t NS_strlen(const char16_t* aString);
+
+
+
+
+int NS_strcmp(const char16_t* aStrA, const char16_t* aStrB);
+
+
+
+
+int NS_strncmp(const char16_t* aStrA, const char16_t* aStrB, size_t aLen);
+
+
+
+
+char16_t* NS_strdup(const char16_t* aString);
+
+
+
+
+char* NS_strdup(const char* aString);
+# 72 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
+template<typename CharT>
+CharT* NS_strndup(const CharT* aString, uint32_t aLen);
+
+
+
+
+
+class nsLowerUpperUtils
+{
+public:
+  static const unsigned char kLower2Upper[256];
+  static const unsigned char kUpper2Lower[256];
+};
+
+inline char
+NS_ToUpper(char aChar)
+{
+  return (char)nsLowerUpperUtils::kLower2Upper[(unsigned char)aChar];
+}
+
+inline char
+NS_ToLower(char aChar)
+{
+  return (char)nsLowerUpperUtils::kUpper2Lower[(unsigned char)aChar];
+}
+
+bool NS_IsUpper(char aChar);
+bool NS_IsLower(char aChar);
+
+bool NS_IsAscii(char16_t aChar);
+bool NS_IsAscii(const char16_t* aString);
+bool NS_IsAsciiAlpha(char16_t aChar);
+bool NS_IsAsciiDigit(char16_t aChar);
+bool NS_IsAsciiWhitespace(char16_t aChar);
+bool NS_IsAscii(const char* aString);
+bool NS_IsAscii(const char* aString, uint32_t aLength);
+
+
+void NS_MakeRandomString(char* aBuf, int32_t aBufLen);
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
+void ToLowerCase(nsAString&);
+void ToUpperCase(nsAString&);
+
+void ToLowerCase(const nsAString& aSource, nsAString& aDest);
+void ToUpperCase(const nsAString& aSource, nsAString& aDest);
+
+uint32_t ToLowerCase(uint32_t);
+uint32_t ToUpperCase(uint32_t);
+uint32_t ToTitleCase(uint32_t);
+
+void ToLowerCase(const char16_t*, char16_t*, uint32_t);
+void ToUpperCase(const char16_t*, char16_t*, uint32_t);
+
+inline bool IsUpperCase(uint32_t c) {
+  return ToLowerCase(c) != c;
+}
+
+inline bool IsLowerCase(uint32_t c) {
+  return ToUpperCase(c) != c;
+}
+
+
+
+class nsCaseInsensitiveStringComparator : public nsStringComparator
+{
+public:
+  virtual int32_t operator() (const char16_t*,
+                              const char16_t*,
+                              uint32_t,
+                              uint32_t) const override;
+};
+
+class nsCaseInsensitiveUTF8StringComparator : public nsCStringComparator
+{
+public:
+  virtual int32_t operator() (const char*,
+                              const char*,
+                              uint32_t,
+                              uint32_t) const override;
+};
+
+class nsCaseInsensitiveStringArrayComparator
+{
+public:
+  template<class A, class B>
+  bool Equals(const A& a, const B& b) const {
+    return a.Equals(b, nsCaseInsensitiveStringComparator());
+  }
+};
+
+class nsASCIICaseInsensitiveStringComparator : public nsStringComparator
+{
+public:
+  nsASCIICaseInsensitiveStringComparator() {}
+  virtual int operator() (const char16_t*,
+                          const char16_t*,
+                          uint32_t,
+                          uint32_t) const override;
+};
+
+inline bool
+CaseInsensitiveFindInReadable(const nsAString& aPattern,
+                              nsAString::const_iterator& aSearchStart,
+                              nsAString::const_iterator& aSearchEnd)
+{
+  return FindInReadable(aPattern, aSearchStart, aSearchEnd,
+                        nsCaseInsensitiveStringComparator());
+}
+
+inline bool
+CaseInsensitiveFindInReadable(const nsAString& aPattern,
+                              const nsAString& aHay)
+{
+  nsAString::const_iterator searchBegin, searchEnd;
+  return FindInReadable(aPattern, aHay.BeginReading(searchBegin),
+                        aHay.EndReading(searchEnd),
+                        nsCaseInsensitiveStringComparator());
+}
+
+
+
+int32_t
+CaseInsensitiveCompare(const char16_t *a, const char16_t *b, uint32_t len);
+
+int32_t
+CaseInsensitiveCompare(const char* aLeft, const char* aRight,
+                       uint32_t aLeftBytes, uint32_t aRightBytes);
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
+bool
+CaseInsensitiveUTF8CharsEqual(const char* aLeft, const char* aRight,
+                              const char* aLeftEnd, const char* aRightEnd,
+                              const char** aLeftNext, const char** aRightNext,
+                              bool* aErr);
+
+namespace mozilla {
+# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
+uint32_t
+HashUTF8AsUTF16(const char* aUTF8, uint32_t aLength, bool* aErr);
+
+bool
+IsSegmentBreakSkipChar(uint32_t u);
+
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPointerHashKeys.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPointerHashKeys.h"
+template<class T>
+class nsPtrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef T* KeyType;
+  typedef const T* KeyTypePointer;
+
+  explicit nsPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
+  nsPtrHashKey(const nsPtrHashKey<T>& aToCopy) : mKey(aToCopy.mKey) {}
+  ~nsPtrHashKey() {}
+
+  KeyType GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return ((uint32_t)(intptr_t)(aKey)) >> 2;
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+protected:
+  T* mKey;
+};
+
+typedef nsPtrHashKey<const void> nsVoidPtrHashKey;
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
+
+
+
+
+
+namespace mozilla {
+
+
+
+inline uint32_t
+HashString(const nsAString& aStr)
+{
+  return HashString(aStr.BeginReading(), aStr.Length());
+}
+
+inline uint32_t
+HashString(const nsACString& aStr)
+{
+  return HashString(aStr.BeginReading(), aStr.Length());
+}
+
+}
+# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+class nsStringHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const nsAString& KeyType;
+  typedef const nsAString* KeyTypePointer;
+
+  explicit nsStringHashKey(KeyTypePointer aStr) : mStr(*aStr) {}
+  nsStringHashKey(const nsStringHashKey& aToCopy) : mStr(aToCopy.mStr) {}
+  ~nsStringHashKey() {}
+
+  KeyType GetKey() const { return mStr; }
+  bool KeyEquals(const KeyTypePointer aKey) const
+  {
+    return mStr.Equals(*aKey);
+  }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(const KeyTypePointer aKey)
+  {
+    return mozilla::HashString(*aKey);
+  }
+
+
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+  }
+
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const nsString mStr;
+};
+# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+class nsStringCaseInsensitiveHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const nsAString& KeyType;
+  typedef const nsAString* KeyTypePointer;
+
+  explicit nsStringCaseInsensitiveHashKey(KeyTypePointer aStr)
+    : mStr(*aStr)
+  {
+
+  }
+  nsStringCaseInsensitiveHashKey(const nsStringCaseInsensitiveHashKey& aToCopy)
+    : mStr(aToCopy.mStr)
+  {
+  }
+  ~nsStringCaseInsensitiveHashKey() {}
+
+  KeyType GetKey() const { return mStr; }
+  bool KeyEquals(const KeyTypePointer aKey) const
+  {
+    return mStr.Equals(*aKey, nsCaseInsensitiveStringComparator());
+  }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(const KeyTypePointer aKey)
+  {
+    nsAutoString tmKey(*aKey);
+    ToLowerCase(tmKey);
+    return mozilla::HashString(tmKey);
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+  }
+
+private:
+  const nsString mStr;
+};
+# 170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+class nsCStringHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const nsACString& KeyType;
+  typedef const nsACString* KeyTypePointer;
+
+  explicit nsCStringHashKey(const nsACString* aStr) : mStr(*aStr) {}
+  nsCStringHashKey(const nsCStringHashKey& aToCopy) : mStr(aToCopy.mStr) {}
+  ~nsCStringHashKey() {}
+
+  KeyType GetKey() const { return mStr; }
+  bool KeyEquals(KeyTypePointer aKey) const { return mStr.Equals(*aKey); }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return mozilla::HashString(*aKey);
+  }
+
+
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+  }
+
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const nsCString mStr;
+};
+
+
+
+
+
+
+class nsUint32HashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const uint32_t& KeyType;
+  typedef const uint32_t* KeyTypePointer;
+
+  explicit nsUint32HashKey(KeyTypePointer aKey) : mValue(*aKey) {}
+  nsUint32HashKey(const nsUint32HashKey& aToCopy) : mValue(aToCopy.mValue) {}
+  ~nsUint32HashKey() {}
+
+  KeyType GetKey() const { return mValue; }
+  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey) { return *aKey; }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const uint32_t mValue;
+};
+
+
+
+
+
+
+class nsUint64HashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const uint64_t& KeyType;
+  typedef const uint64_t* KeyTypePointer;
+
+  explicit nsUint64HashKey(KeyTypePointer aKey) : mValue(*aKey) {}
+  nsUint64HashKey(const nsUint64HashKey& aToCopy) : mValue(aToCopy.mValue) {}
+  ~nsUint64HashKey() {}
+
+  KeyType GetKey() const { return mValue; }
+  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return PLDHashNumber(*aKey);
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const uint64_t mValue;
+};
+
+
+
+
+
+
+class nsFloatHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const float& KeyType;
+  typedef const float* KeyTypePointer;
+
+  explicit nsFloatHashKey(KeyTypePointer aKey) : mValue(*aKey) {}
+  nsFloatHashKey(const nsFloatHashKey& aToCopy) : mValue(aToCopy.mValue) {}
+  ~nsFloatHashKey() {}
+
+  KeyType GetKey() const { return mValue; }
+  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return *reinterpret_cast<const uint32_t*>(aKey);
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const float mValue;
+};
+
+
+
+
+
+
+class nsISupportsHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef nsISupports* KeyType;
+  typedef const nsISupports* KeyTypePointer;
+
+  explicit nsISupportsHashKey(const nsISupports* aKey)
+    : mSupports(const_cast<nsISupports*>(aKey))
+  {
+  }
+  nsISupportsHashKey(const nsISupportsHashKey& aToCopy)
+    : mSupports(aToCopy.mSupports)
+  {
+  }
+  ~nsISupportsHashKey() {}
+
+  KeyType GetKey() const { return mSupports; }
+  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mSupports; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return ((uint32_t)(intptr_t)(aKey)) >> 2;
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  nsCOMPtr<nsISupports> mSupports;
+};
+
+
+
+
+
+
+template<class T>
+class nsRefPtrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef T* KeyType;
+  typedef const T* KeyTypePointer;
+
+  explicit nsRefPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
+  nsRefPtrHashKey(const nsRefPtrHashKey& aToCopy) : mKey(aToCopy.mKey) {}
+  ~nsRefPtrHashKey() {}
+
+  KeyType GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return ((uint32_t)(intptr_t)(aKey)) >> 2;
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  RefPtr<T> mKey;
+};
+
+template<class T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsRefPtrHashKey<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.GetKey(), aName, aFlags);
+}
+# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+template<class T>
+class nsClearingPtrHashKey : public nsPtrHashKey<T>
+{
+public:
+  explicit nsClearingPtrHashKey(const T* aKey) : nsPtrHashKey<T>(aKey) {}
+  nsClearingPtrHashKey(const nsClearingPtrHashKey<T>& aToCopy)
+    : nsPtrHashKey<T>(aToCopy)
+  {
+  }
+  ~nsClearingPtrHashKey() { nsPtrHashKey<T>::mKey = nullptr; }
+};
+
+typedef nsClearingPtrHashKey<const void> nsClearingVoidPtrHashKey;
+
+
+
+
+
+
+template<class T>
+class nsFuncPtrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef T& KeyType;
+  typedef const T* KeyTypePointer;
+
+  explicit nsFuncPtrHashKey(const T* aKey) : mKey(*const_cast<T*>(aKey)) {}
+  nsFuncPtrHashKey(const nsFuncPtrHashKey<T>& aToCopy) : mKey(aToCopy.mKey) {}
+  ~nsFuncPtrHashKey() {}
+
+  KeyType GetKey() const { return const_cast<T&>(mKey); }
+  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return ((uint32_t)(intptr_t)(*aKey)) >> 2;
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+protected:
+  T mKey;
+};
+
+
+
+
+
+
+class nsIDHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const nsID& KeyType;
+  typedef const nsID* KeyTypePointer;
+
+  explicit nsIDHashKey(const nsID* aInID) : mID(*aInID) {}
+  nsIDHashKey(const nsIDHashKey& aToCopy) : mID(aToCopy.mID) {}
+  ~nsIDHashKey() {}
+
+  KeyType GetKey() const { return mID; }
+  bool KeyEquals(KeyTypePointer aKey) const { return aKey->Equals(mID); }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+
+    return mozilla::HashBytes(aKey, sizeof(KeyType));
+  }
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const nsID mID;
+};
+# 455 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
+class nsDepCharHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const char* KeyType;
+  typedef const char* KeyTypePointer;
+
+  explicit nsDepCharHashKey(const char* aKey) : mKey(aKey) {}
+  nsDepCharHashKey(const nsDepCharHashKey& aToCopy) : mKey(aToCopy.mKey) {}
+  ~nsDepCharHashKey() {}
+
+  const char* GetKey() const { return mKey; }
+  bool KeyEquals(const char* aKey) const { return !strcmp(mKey, aKey); }
+
+  static const char* KeyToPointer(const char* aKey) { return aKey; }
+  static PLDHashNumber HashKey(const char* aKey)
+  {
+    return mozilla::HashString(aKey);
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const char* mKey;
+};
+
+
+
+
+
+
+class nsCharPtrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const char* KeyType;
+  typedef const char* KeyTypePointer;
+
+  explicit nsCharPtrHashKey(const char* aKey) : mKey(strdup(aKey)) {}
+  nsCharPtrHashKey(const nsCharPtrHashKey& aToCopy)
+    : mKey(strdup(aToCopy.mKey))
+  {
+  }
+
+  nsCharPtrHashKey(nsCharPtrHashKey&& aOther)
+    : mKey(aOther.mKey)
+  {
+    aOther.mKey = nullptr;
+  }
+
+  ~nsCharPtrHashKey()
+  {
+    if (mKey) {
+      free(const_cast<char*>(mKey));
+    }
+  }
+
+  const char* GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const { return !strcmp(mKey, aKey); }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return mozilla::HashString(aKey);
+  }
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(mKey);
+  }
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const char* mKey;
+};
+
+
+
+
+
+
+class nsUnicharPtrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const char16_t* KeyType;
+  typedef const char16_t* KeyTypePointer;
+
+  explicit nsUnicharPtrHashKey(const char16_t* aKey) : mKey(NS_strdup(aKey)) {}
+  nsUnicharPtrHashKey(const nsUnicharPtrHashKey& aToCopy)
+    : mKey(NS_strdup(aToCopy.mKey))
+  {
+  }
+
+  nsUnicharPtrHashKey(nsUnicharPtrHashKey&& aOther)
+    : mKey(aOther.mKey)
+  {
+    aOther.mKey = nullptr;
+  }
+
+  ~nsUnicharPtrHashKey()
+  {
+    if (mKey) {
+      free(const_cast<char16_t*>(mKey));
+    }
+  }
+
+  const char16_t* GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const { return !NS_strcmp(mKey, aKey); }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    return mozilla::HashString(aKey);
+  }
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(mKey);
+  }
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  const char16_t* mKey;
+};
+
+
+
+
+class nsHashableHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef nsIHashable* KeyType;
+  typedef const nsIHashable* KeyTypePointer;
+
+  explicit nsHashableHashKey(const nsIHashable* aKey)
+    : mKey(const_cast<nsIHashable*>(aKey))
+  {
+  }
+  nsHashableHashKey(const nsHashableHashKey& aToCopy) : mKey(aToCopy.mKey) {}
+  ~nsHashableHashKey() {}
+
+  nsIHashable* GetKey() const { return mKey; }
+
+  bool KeyEquals(const nsIHashable* aKey) const
+  {
+    bool eq;
+    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(mKey->Equals(const_cast<nsIHashable*>(aKey), &eq))), 1)))) {
+      return eq;
+    }
+    return false;
+  }
+
+  static const nsIHashable* KeyToPointer(nsIHashable* aKey) { return aKey; }
+  static PLDHashNumber HashKey(const nsIHashable* aKey)
+  {
+    uint32_t code = 8888;
+
+
+
+      const_cast<nsIHashable*>(aKey)->GetHashCode(&code);
+    do { } while(0);
+    return code;
+  }
+
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  nsCOMPtr<nsIHashable> mKey;
+};
+
+namespace mozilla {
+
+template <typename T>
+PLDHashNumber
+Hash(const T& aValue)
+{
+  return aValue.Hash();
+}
+
+}
+
+
+
+
+
+template<typename T>
+class nsGenericHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const T& KeyType;
+  typedef const T* KeyTypePointer;
+
+  explicit nsGenericHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
+  nsGenericHashKey(const nsGenericHashKey<T>& aOther) : mKey(aOther.mKey) {}
+
+  KeyType GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey) { return ::mozilla::Hash(*aKey); }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  T mKey;
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryChecking.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h" 2
+# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+template<class EntryType>
+class nsTHashtable
+{
+  typedef mozilla::fallible_t fallible_t;
+  static_assert(mozilla::IsPointer<typename EntryType::KeyTypePointer>::value,
+                "KeyTypePointer should be a pointer");
+
+public:
+
+
+  nsTHashtable()
+    : mTable(Ops(), sizeof(EntryType), PLDHashTable::kDefaultInitialLength)
+  {}
+  explicit nsTHashtable(uint32_t aInitLength)
+    : mTable(Ops(), sizeof(EntryType), aInitLength)
+  {}
+
+
+
+
+  ~nsTHashtable();
+
+  nsTHashtable(nsTHashtable<EntryType>&& aOther);
+
+
+
+
+
+  uint32_t GetGeneration() const { return mTable.Generation(); }
+
+
+
+
+  typedef typename EntryType::KeyType KeyType;
+
+
+
+
+  typedef typename EntryType::KeyTypePointer KeyTypePointer;
+
+
+
+
+
+  uint32_t Count() const { return mTable.EntryCount(); }
+
+
+
+
+  bool IsEmpty() const { return Count() == 0; }
+
+
+
+
+
+
+
+  EntryType* GetEntry(KeyType aKey) const
+  {
+    return static_cast<EntryType*>(
+      const_cast<PLDHashTable*>(&mTable)->Search(EntryType::KeyToPointer(aKey)));
+  }
+
+
+
+
+
+
+  bool Contains(KeyType aKey) const { return !!GetEntry(aKey); }
+
+
+
+
+
+
+
+  EntryType* PutEntry(KeyType aKey)
+  {
+
+    return static_cast<EntryType*>(mTable.Add(EntryType::KeyToPointer(aKey)));
+  }
+
+  __attribute__ ((warn_unused_result))
+  EntryType* PutEntry(KeyType aKey, const fallible_t&)
+  {
+    return static_cast<EntryType*>(mTable.Add(EntryType::KeyToPointer(aKey),
+                                              mozilla::fallible));
+  }
+
+
+
+
+
+  void RemoveEntry(KeyType aKey)
+  {
+    mTable.Remove(EntryType::KeyToPointer(aKey));
+  }
+
+
+
+
+
+  void RemoveEntry(EntryType* aEntry)
+  {
+    mTable.RemoveEntry(aEntry);
+  }
+# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+  void RawRemoveEntry(EntryType* aEntry)
+  {
+    mTable.RawRemove(aEntry);
+  }
+# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+  class Iterator : public PLDHashTable::Iterator
+  {
+  public:
+    typedef PLDHashTable::Iterator Base;
+
+    explicit Iterator(nsTHashtable* aTable) : Base(&aTable->mTable) {}
+    Iterator(Iterator&& aOther) : Base(aOther.mTable) {}
+    ~Iterator() {}
+
+    EntryType* Get() const { return static_cast<EntryType*>(Base::Get()); }
+
+  private:
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&&) = delete;
+  };
+
+  Iterator Iter() { return Iterator(this); }
+
+  Iterator ConstIter() const
+  {
+    return Iterator(const_cast<nsTHashtable*>(this));
+  }
+
+
+
+
+
+
+  void Clear()
+  {
+    mTable.Clear();
+  }
+# 247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    size_t n = ShallowSizeOfExcludingThis(aMallocSizeOf);
+    for (auto iter = ConstIter(); !iter.Done(); iter.Next()) {
+      n += (*iter.Get()).SizeOfExcludingThis(aMallocSizeOf);
+    }
+    return n;
+  }
+
+
+
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+  void SwapElements(nsTHashtable<EntryType>& aOther)
+  {
+    do { } while (0);
+
+    mozilla::Swap(this->mTable, aOther.mTable);
+  }
+# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+protected:
+  PLDHashTable mTable;
+
+  static PLDHashNumber s_HashKey(const void* aKey);
+
+  static bool s_MatchEntry(const PLDHashEntryHdr* aEntry,
+                           const void* aKey);
+
+  static void s_CopyEntry(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
+                          PLDHashEntryHdr* aTo);
+
+  static void s_ClearEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
+
+  static void s_InitEntry(PLDHashEntryHdr* aEntry, const void* aKey);
+
+private:
+
+  nsTHashtable(nsTHashtable<EntryType>& aToCopy) = delete;
+
+
+
+
+  static const PLDHashTableOps* Ops();
+
+
+  nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>& aToEqual) = delete;
+};
+
+
+
+
+
+template<class EntryType>
+nsTHashtable<EntryType>::nsTHashtable(nsTHashtable<EntryType>&& aOther)
+  : mTable(mozilla::Move(aOther.mTable))
+{
+
+
+  do {} while (0);
+}
+
+template<class EntryType>
+nsTHashtable<EntryType>::~nsTHashtable()
+{
+}
+
+template<class EntryType>
+             const PLDHashTableOps*
+nsTHashtable<EntryType>::Ops()
+{
+
+
+
+  static const PLDHashTableOps sOps =
+  {
+    s_HashKey,
+    s_MatchEntry,
+    EntryType::ALLOW_MEMMOVE ? PLDHashTable::MoveEntryStub : s_CopyEntry,
+    s_ClearEntry,
+    s_InitEntry
+  };
+  return &sOps;
+}
+
+
+
+template<class EntryType>
+PLDHashNumber
+nsTHashtable<EntryType>::s_HashKey(const void* aKey)
+{
+  return EntryType::HashKey(static_cast<const KeyTypePointer>(aKey));
+}
+
+template<class EntryType>
+bool
+nsTHashtable<EntryType>::s_MatchEntry(const PLDHashEntryHdr* aEntry,
+                                      const void* aKey)
+{
+  return ((const EntryType*)aEntry)->KeyEquals(
+    static_cast<const KeyTypePointer>(aKey));
+}
+
+template<class EntryType>
+void
+nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable* aTable,
+                                     const PLDHashEntryHdr* aFrom,
+                                     PLDHashEntryHdr* aTo)
+{
+  EntryType* fromEntry =
+    const_cast<EntryType*>(static_cast<const EntryType*>(aFrom));
+
+  new (mozilla::KnownNotNull, aTo) EntryType(mozilla::Move(*fromEntry));
+
+  fromEntry->~EntryType();
+}
+
+template<class EntryType>
+void
+nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable* aTable,
+                                      PLDHashEntryHdr* aEntry)
+{
+  static_cast<EntryType*>(aEntry)->~EntryType();
+}
+
+template<class EntryType>
+void
+nsTHashtable<EntryType>::s_InitEntry(PLDHashEntryHdr* aEntry,
+                                     const void* aKey)
+{
+  new (mozilla::KnownNotNull, aEntry) EntryType(static_cast<KeyTypePointer>(aKey));
+}
+
+class nsCycleCollectionTraversalCallback;
+
+template<class EntryType>
+inline void
+ImplCycleCollectionUnlink(nsTHashtable<EntryType>& aField)
+{
+  aField.Clear();
+}
+
+template<class EntryType>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsTHashtable<EntryType>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  for (auto iter = aField.Iter(); !iter.Done(); iter.Next()) {
+    EntryType* entry = iter.Get();
+    ImplCycleCollectionTraverse(aCallback, *entry, aName, aFlags);
+  }
+}
+# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
+namespace detail {
+
+class VoidPtrHashKey : public nsPtrHashKey<const void>
+{
+  typedef nsPtrHashKey<const void> Base;
+
+public:
+  explicit VoidPtrHashKey(const void* aKey) : Base(aKey) {}
+};
+
+}
+
+
+
+
+
+template<typename T>
+class nsTHashtable<nsPtrHashKey<T>> : protected nsTHashtable<::detail::VoidPtrHashKey>
+{
+  typedef nsTHashtable<::detail::VoidPtrHashKey> Base;
+  typedef nsPtrHashKey<T> EntryType;
+
+
+
+  static_assert(sizeof(nsPtrHashKey<T>) == sizeof(::detail::VoidPtrHashKey),
+                "hash keys must be the same size");
+
+  nsTHashtable(const nsTHashtable& aOther) = delete;
+  nsTHashtable& operator=(const nsTHashtable& aOther) = delete;
+
+public:
+  nsTHashtable() = default;
+  explicit nsTHashtable(uint32_t aInitLength)
+    : Base(aInitLength)
+  {}
+
+  ~nsTHashtable() = default;
+
+  nsTHashtable(nsTHashtable&&) = default;
+
+
+  using Base::GetGeneration;
+  using Base::Count;
+  using Base::IsEmpty;
+  using Base::Clear;
+
+  using Base::ShallowSizeOfExcludingThis;
+  using Base::ShallowSizeOfIncludingThis;
+
+
+
+
+
+  EntryType* GetEntry(T* aKey) const
+  {
+    return reinterpret_cast<EntryType*>(Base::GetEntry(aKey));
+  }
+
+  bool Contains(T* aKey) const
+  {
+    return Base::Contains(aKey);
+  }
+
+  EntryType* PutEntry(T* aKey)
+  {
+    return reinterpret_cast<EntryType*>(Base::PutEntry(aKey));
+  }
+
+  __attribute__ ((warn_unused_result))
+  EntryType* PutEntry(T* aKey, const mozilla::fallible_t&)
+  {
+    return reinterpret_cast<EntryType*>(
+      Base::PutEntry(aKey, mozilla::fallible));
+  }
+
+  void RemoveEntry(T* aKey)
+  {
+    Base::RemoveEntry(aKey);
+  }
+
+  void RemoveEntry(EntryType* aEntry)
+  {
+    Base::RemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
+  }
+
+  void RawRemoveEntry(EntryType* aEntry)
+  {
+    Base::RawRemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
+  }
+
+  class Iterator : public Base::Iterator
+  {
+  public:
+    typedef nsTHashtable::Base::Iterator Base;
+
+    explicit Iterator(nsTHashtable* aTable) : Base(aTable) {}
+    Iterator(Iterator&& aOther) : Base(mozilla::Move(aOther)) {}
+    ~Iterator() = default;
+
+    EntryType* Get() const { return reinterpret_cast<EntryType*>(Base::Get()); }
+
+  private:
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+    Iterator& operator=(Iterator&&) = delete;
+  };
+
+  Iterator Iter() { return Iterator(this); }
+
+  Iterator ConstIter() const
+  {
+    return Iterator(const_cast<nsTHashtable*>(this));
+  }
+
+  void SwapElements(nsTHashtable& aOther)
+  {
+    Base::SwapElements(aOther);
+  }
+};
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h" 2
+
+
+template<class KeyClass, class DataType, class UserDataType>
+class nsBaseHashtable;
+
+
+
+
+
+
+template<class KeyClass, class DataType>
+class nsBaseHashtableET : public KeyClass
+{
+public:
+  DataType mData;
+  friend class nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
+
+private:
+  typedef typename KeyClass::KeyType KeyType;
+  typedef typename KeyClass::KeyTypePointer KeyTypePointer;
+
+  explicit nsBaseHashtableET(KeyTypePointer aKey);
+  nsBaseHashtableET(nsBaseHashtableET<KeyClass, DataType>&& aToMove);
+  ~nsBaseHashtableET();
+};
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+template<class KeyClass, class DataType, class UserDataType>
+class nsBaseHashtable
+  : protected nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>
+{
+  typedef mozilla::fallible_t fallible_t;
+
+public:
+  typedef typename KeyClass::KeyType KeyType;
+  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
+
+  using nsTHashtable<EntryType>::Contains;
+
+  nsBaseHashtable() {}
+  explicit nsBaseHashtable(uint32_t aInitLength)
+    : nsTHashtable<EntryType>(aInitLength)
+  {
+  }
+
+
+
+
+
+  uint32_t Count() const { return nsTHashtable<EntryType>::Count(); }
+# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+  bool Get(KeyType aKey, UserDataType* aData) const
+  {
+    EntryType* ent = this->GetEntry(aKey);
+    if (!ent) {
+      return false;
+    }
+
+    if (aData) {
+      *aData = ent->mData;
+    }
+
+    return true;
+  }
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+  UserDataType Get(KeyType aKey) const
+  {
+    EntryType* ent = this->GetEntry(aKey);
+    if (!ent) {
+      return UserDataType{};
+    }
+
+    return ent->mData;
+  }
+
+
+
+
+
+
+  DataType& GetOrInsert(const KeyType& aKey)
+  {
+    EntryType* ent = this->GetEntry(aKey);
+    if (ent) {
+      return ent->mData;
+    }
+
+    ent = this->PutEntry(aKey);
+    return ent->mData;
+  }
+
+
+
+
+
+
+
+  void Put(KeyType aKey, const UserDataType& aData)
+  {
+    if (!Put(aKey, aData, mozilla::fallible)) {
+      NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
+    }
+  }
+
+  __attribute__ ((warn_unused_result)) bool Put(KeyType aKey, const UserDataType& aData,
+                        const fallible_t&)
+  {
+    EntryType* ent = this->PutEntry(aKey, mozilla::fallible);
+    if (!ent) {
+      return false;
+    }
+
+    ent->mData = aData;
+
+    return true;
+  }
+
+
+
+
+
+  void Remove(KeyType aKey) { this->RemoveEntry(aKey); }
+# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+  class Iterator : public PLDHashTable::Iterator
+  {
+  public:
+    typedef PLDHashTable::Iterator Base;
+
+    explicit Iterator(nsBaseHashtable* aTable) : Base(&aTable->mTable) {}
+    Iterator(Iterator&& aOther) : Base(aOther.mTable) {}
+    ~Iterator() {}
+
+    KeyType Key() const { return static_cast<EntryType*>(Get())->GetKey(); }
+    UserDataType UserData() const
+    {
+      return static_cast<EntryType*>(Get())->mData;
+    }
+    DataType& Data() const { return static_cast<EntryType*>(Get())->mData; }
+
+  private:
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&&) = delete;
+  };
+
+  Iterator Iter() { return Iterator(this); }
+
+  Iterator ConstIter() const
+  {
+    return Iterator(const_cast<nsBaseHashtable*>(this));
+  }
+
+
+
+
+  void Clear() { nsTHashtable<EntryType>::Clear(); }
+# 219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return this->mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+
+
+  void SwapElements(nsBaseHashtable& aOther)
+  {
+    nsTHashtable<EntryType>::SwapElements(aOther);
+  }
+
+
+
+
+
+};
+
+
+
+
+
+template<class KeyClass, class DataType>
+nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(KeyTypePointer aKey)
+  : KeyClass(aKey)
+  , mData()
+{
+}
+
+template<class KeyClass, class DataType>
+nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(
+      nsBaseHashtableET<KeyClass, DataType>&& aToMove)
+  : KeyClass(mozilla::Move(aToMove))
+  , mData(mozilla::Move(aToMove.mData))
+{
+}
+
+template<class KeyClass, class DataType>
+nsBaseHashtableET<KeyClass, DataType>::~nsBaseHashtableET()
+{
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 2
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
+template<class KeyClass, class DataType>
+class nsDataHashtable
+  : public nsBaseHashtable<KeyClass, DataType, DataType>
+{
+private:
+  typedef nsBaseHashtable<KeyClass, DataType, DataType> BaseClass;
+
+public:
+  using typename BaseClass::KeyType;
+  using typename BaseClass::EntryType;
+
+  nsDataHashtable() {}
+  explicit nsDataHashtable(uint32_t aInitLength)
+    : BaseClass(aInitLength)
+  {
+  }
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
+  mozilla::Maybe<DataType> GetAndRemove(KeyType aKey)
+  {
+    mozilla::Maybe<DataType> value;
+    if (EntryType* ent = this->GetEntry(aKey)) {
+      value.emplace(mozilla::Move(ent->mData));
+      this->RemoveEntry(ent);
+    }
+    return value;
+  }
+};
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
+
+class ContentUnbinder;
+class nsContentList;
+class nsDOMAttributeMap;
+class nsDOMTokenList;
+class nsIControllers;
+class nsICSSDeclaration;
+class nsIDocument;
+class nsDOMStringMap;
+class nsIURI;
+
+namespace mozilla {
+class DeclarationBlock;
+namespace dom {
+struct CustomElementData;
+class DOMIntersectionObserver;
+class Element;
+}
+}
+
+
+
+
+
+class nsNodeWeakReference final : public nsIWeakReference
+{
+public:
+  explicit nsNodeWeakReference(nsINode* aNode)
+    : mNode(aNode)
+  {
+  }
+
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+
+  virtual nsresult QueryReferent(const nsIID & uuid, void **result) override;
+  virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+  void NoticeNodeDestruction()
+  {
+    mNode = nullptr;
+  }
+
+private:
+  ~nsNodeWeakReference();
+
+  nsINode* mNode;
+};
+
+
+
+
+class nsNodeSupportsWeakRefTearoff final : public nsISupportsWeakReference
+{
+public:
+  explicit nsNodeSupportsWeakRefTearoff(nsINode* aNode)
+    : mNode(aNode)
+  {
+  }
+
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+
+
+  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) override;
+
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsNodeSupportsWeakRefTearoff"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsNodeSupportsWeakRefTearoff>(p)->DeleteCycleCollectable(); } static nsNodeSupportsWeakRefTearoff* Downcast(nsISupports* s) { return static_cast<nsNodeSupportsWeakRefTearoff*>(static_cast<nsNodeSupportsWeakRefTearoff*>(s)); } static nsISupports* Upcast(nsNodeSupportsWeakRefTearoff *p) { return static_cast<nsISupports*>(static_cast<nsNodeSupportsWeakRefTearoff*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsNodeSupportsWeakRefTearoff::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+private:
+  ~nsNodeSupportsWeakRefTearoff() {}
+
+  nsCOMPtr<nsINode> mNode;
+};
+
+
+
+
+
+namespace mozilla {
+namespace dom {
+
+class ShadowRoot;
+
+class FragmentOrElement : public nsIContent
+{
+public:
+  explicit FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
+  explicit FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+
+  virtual uint32_t GetChildCount() const override;
+  virtual nsIContent *GetChildAt(uint32_t aIndex) const override;
+  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const override;
+  virtual int32_t IndexOf(const nsINode* aPossibleChild) const override;
+  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
+                                 bool aNotify) override;
+  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) override;
+  virtual void GetTextContentInternal(nsAString& aTextContent,
+                                      mozilla::OOMReporter& aError) override;
+  virtual void SetTextContentInternal(const nsAString& aTextContent,
+                                      mozilla::ErrorResult& aError) override;
+
+
+  virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) override;
+  virtual const nsTextFragment *GetText() override;
+  virtual uint32_t TextLength() const override;
+  virtual nsresult SetText(const char16_t* aBuffer, uint32_t aLength,
+                           bool aNotify) override;
+
+  nsresult SetText(const nsAString& aStr, bool aNotify)
+  {
+    return SetText(aStr.BeginReading(), aStr.Length(), aNotify);
+  }
+  virtual nsresult AppendText(const char16_t* aBuffer, uint32_t aLength,
+                              bool aNotify) override;
+  virtual bool TextIsOnlyWhitespace() override;
+  virtual bool ThreadSafeTextIsOnlyWhitespace() const override;
+  virtual bool HasTextForTranslation() override;
+  virtual void AppendTextTo(nsAString& aResult) override;
+  __attribute__ ((warn_unused_result))
+  virtual bool AppendTextTo(nsAString& aResult, const mozilla::fallible_t&) override;
+  virtual nsIContent *GetBindingParent() const override;
+  virtual nsXBLBinding *GetXBLBinding() const override;
+  virtual void SetXBLBinding(nsXBLBinding* aBinding,
+                             nsBindingManager* aOldBindingManager = nullptr) override;
+  virtual ShadowRoot *GetContainingShadow() const override;
+  virtual nsTArray<nsIContent*> &DestInsertionPoints() override;
+  virtual nsTArray<nsIContent*> *GetExistingDestInsertionPoints() const override;
+  virtual void SetShadowRoot(ShadowRoot* aBinding) override;
+  virtual nsIContent *GetXBLInsertionParent() const override;
+  virtual void SetXBLInsertionParent(nsIContent* aContent) override;
+  virtual bool IsLink(nsIURI** aURI) const override;
+
+  virtual void DestroyContent() override;
+  virtual void SaveSubtreeState() override;
+
+  virtual nsresult WalkContentStyleRules(nsRuleWalker* aRuleWalker) override;
+
+  nsIHTMLCollection* Children();
+  uint32_t ChildElementCount()
+  {
+    return Children()->Length();
+  }
+
+
+
+
+
+
+
+  void SetIsElementInStyleScopeFlagOnSubtree(bool aInStyleScope);
+
+public:
+
+
+
+
+  static void FireNodeInserted(nsIDocument* aDoc,
+                               nsINode* aParent,
+                               nsTArray<nsCOMPtr<nsIContent> >& aNodes);
+
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "FragmentOrElement"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<FragmentOrElement>(p)->DeleteCycleCollectable(); } static FragmentOrElement* Downcast(nsISupports* s) { return static_cast<FragmentOrElement*>(static_cast<FragmentOrElement*>(s)); } static nsISupports* Upcast(FragmentOrElement *p) { return static_cast<nsISupports*>(static_cast<FragmentOrElement*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &FragmentOrElement::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+
+
+  void FireNodeRemovedForChildren();
+
+  virtual bool OwnedOnlyByTheDOMTree() override
+  {
+    uint32_t rc = mRefCnt.get();
+    if (GetParent()) {
+      --rc;
+    }
+    rc -= mAttrsAndChildren.ChildCount();
+    return rc == 0;
+  }
+
+  virtual bool IsPurple() override
+  {
+    return mRefCnt.IsPurple();
+  }
+
+  virtual void RemovePurple() override
+  {
+    mRefCnt.RemovePurple();
+  }
+
+  static void ClearContentUnbinder();
+  static bool CanSkip(nsINode* aNode, bool aRemovingAllowed);
+  static bool CanSkipInCC(nsINode* aNode);
+  static bool CanSkipThis(nsINode* aNode);
+  static void RemoveBlackMarkedNode(nsINode* aNode);
+  static void MarkNodeChildren(nsINode* aNode);
+  static void InitCCCallbacks();
+  static void MarkUserData(void* aObject, nsIAtom* aKey, void* aChild,
+                           void *aData);
+
+
+
+
+  static bool IsHTMLVoid(nsIAtom* aLocalName);
+protected:
+  virtual ~FragmentOrElement();
+
+
+
+
+
+  nsresult CopyInnerTo(FragmentOrElement* aDest);
+
+public:
+# 252 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h"
+  class nsDOMSlots : public nsINode::nsSlots
+  {
+  public:
+    nsDOMSlots();
+    virtual ~nsDOMSlots();
+
+    void Traverse(nsCycleCollectionTraversalCallback &cb, bool aIsXUL);
+    void Unlink(bool aIsXUL);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+
+
+
+
+
+    nsCOMPtr<nsICSSDeclaration> mStyle;
+
+
+
+
+
+    nsDOMStringMap* mDataset;
+
+
+
+
+
+    nsCOMPtr<nsICSSDeclaration> mSMILOverrideStyle;
+
+
+
+
+    RefPtr<mozilla::DeclarationBlock> mSMILOverrideStyleDeclaration;
+
+
+
+
+
+    RefPtr<nsDOMAttributeMap> mAttributeMap;
+
+    union {
+
+
+
+
+      nsIContent* mBindingParent;
+
+
+
+
+      nsIControllers* mControllers;
+    };
+
+
+
+
+    RefPtr<nsContentList> mChildrenList;
+
+
+
+
+    RefPtr<nsDOMTokenList> mClassList;
+
+
+
+
+    RefPtr<ShadowRoot> mShadowRoot;
+
+
+
+
+    RefPtr<ShadowRoot> mContainingShadow;
+
+
+
+
+
+    nsTArray<nsIContent*> mDestInsertionPoints;
+
+
+
+
+    RefPtr<nsXBLBinding> mXBLBinding;
+
+
+
+
+    nsCOMPtr<nsIContent> mXBLInsertionParent;
+
+
+
+
+    RefPtr<CustomElementData> mCustomElementData;
+
+
+
+
+    nsDataHashtable<nsRefPtrHashKey<DOMIntersectionObserver>, int32_t>
+      mRegisteredIntersectionObservers;
+  };
+
+protected:
+  void GetMarkup(bool aIncludeSelf, nsAString& aMarkup);
+  void SetInnerHTMLInternal(const nsAString& aInnerHTML, ErrorResult& aError);
+
+
+  virtual nsINode::nsSlots* CreateSlots() override;
+
+  nsDOMSlots *DOMSlots()
+  {
+    return static_cast<nsDOMSlots*>(Slots());
+  }
+
+  nsDOMSlots *GetExistingDOMSlots() const
+  {
+    return static_cast<nsDOMSlots*>(GetExistingSlots());
+  }
+
+
+
+
+
+
+
+  void SetIsElementInStyleScopeFlagOnShadowTree(bool aInStyleScope);
+
+  friend class ::ContentUnbinder;
+
+
+
+  nsAttrAndChildArray mAttrsAndChildren;
+};
+
+}
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
+class nsIContent;
+class nsAString;
+class nsAttrValue;
+class nsTextNode;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}
+}
+
+namespace mozilla {
+
+enum Directionality : uint8_t {
+  eDir_NotSet,
+  eDir_RTL,
+  eDir_LTR,
+  eDir_Auto
+};
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
+Directionality RecomputeDirectionality(mozilla::dom::Element* aElement,
+                                       bool aNotify = true);
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
+void SetDirectionalityOnDescendants(mozilla::dom::Element* aElement,
+                                    Directionality aDir,
+                                    bool aNotify = true);
+
+
+
+
+
+
+
+void WalkDescendantsResetAutoDirection(mozilla::dom::Element* aElement);
+# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
+void WalkDescendantsSetDirAuto(mozilla::dom::Element* aElement,
+                               bool aNotify = true);
+
+
+
+
+
+
+void WalkDescendantsClearAncestorDirAuto(mozilla::dom::Element* aElement);
+
+
+
+
+
+
+
+bool TextNodeWillChangeDirection(nsIContent* aTextNode, Directionality* aOldDir,
+                                 uint32_t aOffset);
+
+
+
+
+
+void TextNodeChangedDirection(nsTextNode* aTextNode, Directionality aOldDir,
+                              bool aNotify);
+
+
+
+
+
+void SetDirectionFromNewTextNode(nsTextNode* aTextNode);
+
+
+
+
+
+
+
+void ResetDirectionSetByTextNode(nsTextNode* aTextNode);
+
+
+
+
+
+void SetDirectionalityFromValue(mozilla::dom::Element* aElement,
+                                const nsAString& aValue,
+                                bool aNotify);
+# 125 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
+void OnSetDirAttr(mozilla::dom::Element* aElement,
+                  const nsAttrValue* aNewValue,
+                  bool hadValidDir,
+                  bool hadDirAuto,
+                  bool aNotify);
+
+
+
+
+
+
+void SetDirOnBind(mozilla::dom::Element* aElement, nsIContent* aParent);
+
+
+
+
+
+
+void ResetDir(mozilla::dom::Element* aElement);
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h"
+class nsIDOMMozNamedAttrMap;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h"
+class nsIDOMElement : public nsIDOMNode {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetTagName(nsAString & aTagName) = 0;
+
+
+  virtual nsresult GetAttributes(nsIDOMMozNamedAttrMap * *aAttributes) = 0;
+
+
+  virtual nsresult GetAttribute(const nsAString & name, nsAString & _retval) = 0;
+
+
+  virtual nsresult SetAttribute(const nsAString & name, const nsAString & value) = 0;
+
+
+  virtual nsresult HasAttribute(const nsAString & name, bool *_retval) = 0;
+
+
+  virtual nsresult GetAttributeNode(const nsAString & name, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult GetAttributeNodeNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIDOMElement::COMTypeInfo<nsIDOMElement, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMElement::COMTypeInfo<nsIDOMElement, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x6289999b, 0x1008, 0x4269, { 0xb4, 0x2a, 0x41, 0x3e, 0xc5, 0xa9, 0xd3, 0xf4 }};
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
+class nsIContent;
+class nsIDocShell;
+class nsIInputStream;
+class nsIRequest;
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
+class nsILinkHandler : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
+  virtual nsresult OnLinkClick(nsIContent* aContent,
+                         nsIURI* aURI,
+                         const char16_t* aTargetSpec,
+                         const nsAString& aFileName,
+                         nsIInputStream* aPostDataStream,
+                         nsIInputStream* aHeadersDataStream,
+                         bool aIsTrusted,
+                         nsIPrincipal* aTriggeringPrincipal) = 0;
+# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
+  virtual nsresult OnLinkClickSync(nsIContent* aContent,
+                             nsIURI* aURI,
+                             const char16_t* aTargetSpec,
+                             const nsAString& aFileName,
+                             nsIInputStream* aPostDataStream = 0,
+                             nsIInputStream* aHeadersDataStream = 0,
+                             bool aNoOpenerImplied = false,
+                             nsIDocShell** aDocShell = 0,
+                             nsIRequest** aRequest = 0,
+                             nsIPrincipal* aTriggeringPrincipal = nullptr) = 0;
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
+  virtual nsresult OnOverLink(nsIContent* aContent,
+                        nsIURI* aURLSpec,
+                        const char16_t* aTargetSpec) = 0;
+
+
+
+
+  virtual nsresult OnLeaveLink() = 0;
+};
+
+template<typename T> struct nsILinkHandler::COMTypeInfo<nsILinkHandler, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILinkHandler::COMTypeInfo<nsILinkHandler, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xceb9aade, 0x43da, 0x4f1a, { 0xac, 0x8a, 0xc7, 0x09, 0xfb, 0x22, 0x46, 0x64 } };
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNodeList.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNodeList.h"
+class nsIDOMNodeList : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) = 0;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+};
+
+  template<typename T> struct nsIDOMNodeList::COMTypeInfo<nsIDOMNodeList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMNodeList::COMTypeInfo<nsIDOMNodeList, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x450cf0ba, 0xde90, 0x4f86, { 0x85, 0xbf, 0xe1, 0x0c, 0xc8, 0xb8, 0x71, 0x3f }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h" 2
+
+
+
+
+
+
+
+
+class nsIContent;
+class nsINode;
+
+
+
+
+class nsINodeList : public nsIDOMNodeList,
+                    public nsWrapperCache
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+  virtual int32_t IndexOf(nsIContent* aContent) = 0;
+
+
+
+
+  virtual nsINode* GetParentObject() = 0;
+
+  using nsIDOMNodeList::Item;
+
+  uint32_t Length()
+  {
+    uint32_t length;
+    GetLength(&length);
+    return length;
+  }
+  virtual nsIContent* Item(uint32_t aIndex) = 0;
+  nsIContent* IndexedGetter(uint32_t aIndex, bool& aFound)
+  {
+    nsIContent* item = Item(aIndex);
+    aFound = !!item;
+    return item;
+  }
+};
+
+
+
+
+template<typename T> struct nsINodeList::COMTypeInfo<nsINodeList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINodeList::COMTypeInfo<nsINodeList, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xadb5e54c, 0x6e96, 0x4102, { 0x8d, 0x40, 0xe0, 0x12, 0x3d, 0xcf, 0x48, 0x7a } };
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h" 2
+
+namespace mozilla {
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h"
+enum class FlushType : uint8_t {
+  None = 0,
+  Content = 1,
+  ContentAndNotify = 2,
+
+
+  Style = 3,
+  Frames = Style,
+  InterruptibleLayout = 4,
+
+
+  Layout = 5,
+
+  Display = 6,
+
+  Count
+};
+
+struct ChangesToFlush {
+  ChangesToFlush(FlushType aFlushType, bool aFlushAnimations)
+    : mFlushType(aFlushType)
+    , mFlushAnimations(aFlushAnimations)
+  {}
+
+  FlushType mFlushType;
+  bool mFlushAnimations;
+};
+
+}
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAttribute.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAttribute.h"
+class nsDOMAttributeMap;
+
+
+
+
+
+class nsIAttribute : public nsINode
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  virtual void SetMap(nsDOMAttributeMap *aMap) = 0;
+
+  nsDOMAttributeMap *GetMap()
+  {
+    return mAttrMap;
+  }
+
+  mozilla::dom::NodeInfo *NodeInfo() const
+  {
+    return mNodeInfo;
+  }
+
+
+
+
+
+  virtual nsresult SetOwnerDocument(nsIDocument* aDocument) = 0;
+
+protected:
+
+  nsIAttribute(nsDOMAttributeMap *aAttrMap,
+               already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
+
+  virtual ~nsIAttribute();
+
+  RefPtr<nsDOMAttributeMap> mAttrMap;
+};
+
+template<typename T> struct nsIAttribute::COMTypeInfo<nsIAttribute, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAttribute::COMTypeInfo<nsIAttribute, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x84d43da7, 0xb45d, 0x47ae, { 0x8f, 0xbf, 0x95, 0x26, 0x78, 0x4d, 0x5e, 0x47 } };
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMAttr.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMAttr.h"
+class nsIDOMAttr : public nsIDOMNode {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetName(nsAString & aName) = 0;
+
+
+  virtual nsresult GetSpecified(bool *aSpecified) = 0;
+
+
+  virtual nsresult GetValue(nsAString & aValue) = 0;
+  virtual nsresult SetValue(const nsAString & aValue) = 0;
+
+
+  virtual nsresult GetOwnerElement(nsIDOMElement * *aOwnerElement) = 0;
+
+
+  virtual nsresult GetIsId(bool *aIsId) = 0;
+
+};
+
+  template<typename T> struct nsIDOMAttr::COMTypeInfo<nsIDOMAttr, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMAttr::COMTypeInfo<nsIDOMAttr, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x7db491e8, 0xa3a3, 0x4432, { 0xad, 0x67, 0xe6, 0xc3, 0x3e, 0x24, 0xac, 0x6d }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCharacterData.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCharacterData.h"
+class nsIDOMCharacterData : public nsIDOMNode {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetData(nsAString & aData) = 0;
+  virtual nsresult SetData(const nsAString & aData) = 0;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+
+  virtual nsresult SubstringData(uint32_t offset, uint32_t count, nsAString & _retval) = 0;
+
+
+  virtual nsresult AppendData(const nsAString & arg) = 0;
+
+
+  virtual nsresult InsertData(uint32_t offset, const nsAString & arg) = 0;
+
+
+  virtual nsresult DeleteData(uint32_t offset, uint32_t count) = 0;
+
+
+  virtual nsresult ReplaceData(uint32_t offset, uint32_t count, const nsAString & arg) = 0;
+
+};
+
+  template<typename T> struct nsIDOMCharacterData::COMTypeInfo<nsIDOMCharacterData, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMCharacterData::COMTypeInfo<nsIDOMCharacterData, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4109a2d2, 0xe7af, 0x445d, { 0xbb, 0x72, 0xc7, 0xc9, 0xb8, 0x75, 0xf3, 0x5e }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h"
+class nsIDOMText : public nsIDOMCharacterData {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult SplitText(uint32_t offset, nsIDOMText * *_retval) = 0;
+
+
+  virtual nsresult GetWholeText(nsAString & aWholeText) = 0;
+
+};
+
+  template<typename T> struct nsIDOMText::COMTypeInfo<nsIDOMText, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMText::COMTypeInfo<nsIDOMText, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x67273994, 0x6aff, 0x4091, { 0x9d, 0xe9, 0xb7, 0x88, 0xa2, 0x49, 0xf7, 0x83 }};
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStubMutationObserver.h" 1
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStubMutationObserver.h"
+class nsStubMutationObserver : public nsIMutationObserver {
+public:
+  virtual void CharacterDataWillChange(nsIDocument* aDocument, nsIContent* aContent, CharacterDataChangeInfo* aInfo) override; virtual void CharacterDataChanged(nsIDocument* aDocument, nsIContent* aContent, CharacterDataChangeInfo* aInfo) override; virtual void AttributeWillChange(nsIDocument* aDocument, mozilla::dom::Element* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType, const nsAttrValue* aNewValue) override; virtual void NativeAnonymousChildListChange(nsIDocument* aDocument, nsIContent* aContent, bool aIsRemove) override; virtual void AttributeChanged(nsIDocument* aDocument, mozilla::dom::Element* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType, const nsAttrValue* aOldValue) override; virtual void ContentAppended(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aFirstNewContent, int32_t aNewIndexInContainer) override; virtual void ContentInserted(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t aIndexInContainer) override; virtual void ContentRemoved(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t aIndexInContainer, nsIContent* aPreviousSibling) override; virtual void NodeWillBeDestroyed(const nsINode* aNode) override; virtual void ParentChainChanged(nsIContent *aContent) override;
+};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
+
+class nsIDocument;
+
+namespace mozilla {
+class EventChainPreVisitor;
+namespace dom {
+
+
+
+class Attr final : public nsIAttribute,
+                   public nsIDOMAttr
+{
+  virtual ~Attr() {}
+
+public:
+  Attr(nsDOMAttributeMap* aAttrMap,
+       already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
+       const nsAString& aValue);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+
+
+  virtual nsresult GetNodeName(nsAString& aNodeName) final override { aNodeName = nsINode::NodeName(); return NS_OK; } virtual nsresult GetNodeValue(nsAString& aNodeValue) final override { nsINode::GetNodeValue(aNodeValue); return NS_OK; } virtual nsresult SetNodeValue(const nsAString& aNodeValue) final override { mozilla::ErrorResult rv; nsINode::SetNodeValue(aNodeValue, rv); return rv.StealNSResult(); } virtual nsresult GetNodeType(uint16_t* aNodeType) final override { *aNodeType = nsINode::NodeType(); return NS_OK; } virtual nsresult GetParentNode(nsIDOMNode** aParentNode) final override { return nsINode::GetParentNode(aParentNode); } virtual nsresult GetChildNodes(nsIDOMNodeList** aChildNodes) final override { return nsINode::GetChildNodes(aChildNodes); } virtual nsresult GetFirstChild(nsIDOMNode** aFirstChild) final override { return nsINode::GetFirstChild(aFirstChild); } virtual nsresult GetLastChild(nsIDOMNode** aLastChild) final override { return nsINode::GetLastChild(aLastChild); } virtual nsresult GetPreviousSibling(nsIDOMNode** aPreviousSibling) final override { return nsINode::GetPreviousSibling(aPreviousSibling); } virtual nsresult GetNextSibling(nsIDOMNode** aNextSibling) final override { return nsINode::GetNextSibling(aNextSibling); } virtual nsresult GetOwnerDocument(nsIDOMDocument** aOwnerDocument) final override { return nsINode::GetOwnerDocument(aOwnerDocument); } virtual nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aResult) final override { return nsINode::RemoveChild(aOldChild, aResult); } virtual nsresult HasChildNodes(bool* aResult) final override { *aResult = nsINode::HasChildNodes(); return NS_OK; } virtual nsresult CloneNode(bool aDeep, uint8_t aArgc, nsIDOMNode** aResult) final override { if (aArgc == 0) { aDeep = true; } mozilla::ErrorResult rv; nsCOMPtr<nsINode> clone = nsINode::CloneNode(aDeep, rv); if (rv.Failed()) { return rv.StealNSResult(); } *aResult = clone.forget().take()->AsDOMNode(); return NS_OK; } virtual nsresult GetNamespaceURI(nsAString& aNamespaceURI) final override { nsINode::GetNamespaceURI(aNamespaceURI); return NS_OK; } virtual nsresult GetPrefix(nsAString& aPrefix) final override { nsINode::GetPrefix(aPrefix); return NS_OK; } virtual nsresult GetLocalName(nsAString& aLocalName) final override { aLocalName = nsINode::LocalName(); return NS_OK; } virtual nsresult GetTextContent(nsAString& aTextContent) final override { mozilla::ErrorResult rv; nsINode::GetTextContent(aTextContent, rv); return rv.StealNSResult(); } virtual nsresult SetTextContent(const nsAString& aTextContent) final override { mozilla::ErrorResult rv; nsINode::SetTextContent(aTextContent, rv); return rv.StealNSResult(); }
+  virtual void GetTextContentInternal(nsAString& aTextContent,
+                                      OOMReporter& aError) override;
+  virtual void SetTextContentInternal(const nsAString& aTextContent,
+                                      ErrorResult& aError) override;
+  virtual void GetNodeValueInternal(nsAString& aNodeValue) override;
+  virtual void SetNodeValueInternal(const nsAString& aNodeValue,
+                                    ErrorResult& aError) override;
+
+
+  virtual nsresult GetName(nsAString & aName) override; virtual nsresult GetSpecified(bool *aSpecified) override; virtual nsresult GetValue(nsAString & aValue) override; virtual nsresult SetValue(const nsAString & aValue) override; virtual nsresult GetOwnerElement(nsIDOMElement * *aOwnerElement) override; virtual nsresult GetIsId(bool *aIsId) override;
+
+  virtual nsresult GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
+
+
+  void SetMap(nsDOMAttributeMap *aMap) override;
+  Element* GetElement() const;
+  nsresult SetOwnerDocument(nsIDocument* aDocument) override;
+
+
+  virtual bool IsNodeOfType(uint32_t aFlags) const override;
+  virtual uint32_t GetChildCount() const override;
+  virtual nsIContent *GetChildAt(uint32_t aIndex) const override;
+  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const override;
+  virtual int32_t IndexOf(const nsINode* aPossibleChild) const override;
+  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
+                                 bool aNotify) override;
+  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) override;
+  virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const override;
+  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
+
+  static void Initialize();
+  static void Shutdown();
+
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "Attr"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<Attr>(p)->DeleteCycleCollectable(); } static Attr* Downcast(nsISupports* s) { return static_cast<Attr*>(static_cast<nsIAttribute*>(s)); } static nsISupports* Upcast(Attr *p) { return static_cast<nsISupports*>(static_cast<nsIAttribute*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &Attr::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  virtual nsIDOMNode* AsDOMNode() override { return this; }
+
+
+  virtual JSObject* WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+
+
+
+  void SetValue(const nsAString& aValue, ErrorResult& aRv);
+
+  bool Specified() const;
+
+
+
+
+
+  Element* GetOwnerElement(ErrorResult& aRv);
+
+protected:
+  virtual Element* GetNameSpaceElement() override
+  {
+    return GetElement();
+  }
+
+  static bool sInitialized;
+
+private:
+  nsString mValue;
+};
+
+}
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMMozNamedAttrMap.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMMozNamedAttrMap.h"
+class nsIDOMMozNamedAttrMap : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetNamedItem(const nsAString & name, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult RemoveNamedItem(const nsAString & name, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult Item(uint32_t index, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+
+  virtual nsresult GetNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr * *_retval) = 0;
+
+
+  virtual nsresult RemoveNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIDOMMozNamedAttrMap::COMTypeInfo<nsIDOMMozNamedAttrMap, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMMozNamedAttrMap::COMTypeInfo<nsIDOMMozNamedAttrMap, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcb5564cd, 0x26ec, 0x418f, { 0xa6, 0xd6, 0x1d, 0x57, 0xcd, 0x2c, 0x97, 0x1c }};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h"
+template<class KeyClass, class PtrType>
+class nsRefPtrHashtable
+  : public nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*>
+{
+public:
+  typedef typename KeyClass::KeyType KeyType;
+  typedef PtrType* UserDataType;
+  typedef nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*> base_type;
+
+  nsRefPtrHashtable() {}
+  explicit nsRefPtrHashtable(uint32_t aInitLength)
+    : nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*>(aInitLength)
+  {
+  }
+
+
+
+
+
+
+  bool Get(KeyType aKey, UserDataType* aData) const;
+
+
+
+
+
+
+
+  PtrType* GetWeak(KeyType aKey, bool* aFound = nullptr) const;
+
+
+  using base_type::Put;
+
+  void Put(KeyType aKey, already_AddRefed<PtrType> aData);
+
+  __attribute__ ((warn_unused_result)) bool Put(KeyType aKey, already_AddRefed<PtrType> aData,
+                        const mozilla::fallible_t&);
+
+
+  using base_type::Remove;
+# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h"
+  bool Remove(KeyType aKey, UserDataType* aData);
+};
+
+template<typename K, typename T>
+inline void
+ImplCycleCollectionUnlink(nsRefPtrHashtable<K, T>& aField)
+{
+  aField.Clear();
+}
+
+template<typename K, typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsRefPtrHashtable<K, T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  for (auto iter = aField.ConstIter(); !iter.Done(); iter.Next()) {
+    CycleCollectionNoteChild(aCallback, iter.UserData(), aName, aFlags);
+  }
+}
+
+
+
+
+
+template<class KeyClass, class PtrType>
+bool
+nsRefPtrHashtable<KeyClass, PtrType>::Get(KeyType aKey,
+                                          UserDataType* aRefPtr) const
+{
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+  if (ent) {
+    if (aRefPtr) {
+      *aRefPtr = ent->mData;
+
+      ns_if_addref(*aRefPtr);
+    }
+
+    return true;
+  }
+
+
+
+  if (aRefPtr) {
+    *aRefPtr = nullptr;
+  }
+
+  return false;
+}
+
+template<class KeyClass, class PtrType>
+PtrType*
+nsRefPtrHashtable<KeyClass, PtrType>::GetWeak(KeyType aKey, bool* aFound) const
+{
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+  if (ent) {
+    if (aFound) {
+      *aFound = true;
+    }
+
+    return ent->mData;
+  }
+
+
+  if (aFound) {
+    *aFound = false;
+  }
+
+  return nullptr;
+}
+
+template<class KeyClass, class PtrType>
+void
+nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
+                                          already_AddRefed<PtrType> aData)
+{
+  if (!Put(aKey, mozilla::Move(aData), mozilla::fallible)) {
+    NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
+  }
+}
+
+template<class KeyClass, class PtrType>
+bool
+nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
+                                          already_AddRefed<PtrType> aData,
+                                          const mozilla::fallible_t&)
+{
+  typename base_type::EntryType* ent = this->PutEntry(aKey);
+
+  if (!ent) {
+    return false;
+  }
+
+  ent->mData = aData;
+
+  return true;
+}
+
+template<class KeyClass, class PtrType>
+bool
+nsRefPtrHashtable<KeyClass, PtrType>::Remove(KeyType aKey,
+                                             UserDataType* aRefPtr)
+{
+  do { } while (0);
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+  if (ent) {
+    ent->mData.forget(aRefPtr);
+    this->Remove(aKey);
+    return true;
+  }
+
+
+
+  *aRefPtr = nullptr;
+  return false;
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
+
+
+
+class nsIAtom;
+class nsIDocument;
+
+
+
+
+class nsAttrKey
+{
+public:
+
+
+
+  int32_t mNamespaceID;
+
+
+
+
+
+  void* mLocalName;
+
+  nsAttrKey(int32_t aNs, nsIAtom* aName)
+    : mNamespaceID(aNs), mLocalName(aName) {}
+
+  nsAttrKey(const nsAttrKey& aAttr)
+    : mNamespaceID(aAttr.mNamespaceID), mLocalName(aAttr.mLocalName) {}
+};
+
+
+
+
+class nsAttrHashKey : public PLDHashEntryHdr
+{
+public:
+  typedef const nsAttrKey& KeyType;
+  typedef const nsAttrKey* KeyTypePointer;
+
+  explicit nsAttrHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
+  nsAttrHashKey(const nsAttrHashKey& aCopy) : mKey(aCopy.mKey) {}
+  ~nsAttrHashKey() {}
+
+  KeyType GetKey() const { return mKey; }
+  bool KeyEquals(KeyTypePointer aKey) const
+    {
+      return mKey.mLocalName == aKey->mLocalName &&
+             mKey.mNamespaceID == aKey->mNamespaceID;
+    }
+
+  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+    {
+      if (!aKey)
+        return 0;
+
+      return mozilla::HashGeneric(aKey->mNamespaceID, aKey->mLocalName);
+    }
+  enum { ALLOW_MEMMOVE = true };
+
+private:
+  nsAttrKey mKey;
+};
+
+
+class nsDOMAttributeMap final : public nsIDOMMozNamedAttrMap
+                              , public nsWrapperCache
+{
+public:
+  typedef mozilla::dom::Attr Attr;
+  typedef mozilla::dom::Element Element;
+  typedef mozilla::ErrorResult ErrorResult;
+
+  explicit nsDOMAttributeMap(Element *aContent);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsDOMAttributeMap"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsDOMAttributeMap>(p)->DeleteCycleCollectable(); } static nsDOMAttributeMap* Downcast(nsISupports* s) { return static_cast<nsDOMAttributeMap*>(static_cast<nsDOMAttributeMap*>(s)); } static nsISupports* Upcast(nsDOMAttributeMap *p) { return static_cast<nsISupports*>(static_cast<nsDOMAttributeMap*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsDOMAttributeMap::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  virtual nsresult GetNamedItem(const nsAString & name, nsIDOMAttr * *_retval) override; virtual nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr * *_retval) override; virtual nsresult RemoveNamedItem(const nsAString & name, nsIDOMAttr * *_retval) override; virtual nsresult Item(uint32_t index, nsIDOMAttr * *_retval) override; virtual nsresult GetLength(uint32_t *aLength) override; virtual nsresult GetNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) override; virtual nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr * *_retval) override; virtual nsresult RemoveNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) override;
+
+  void DropReference();
+
+  Element* GetContent()
+  {
+    return mContent;
+  }
+
+
+
+
+
+  nsresult SetOwnerDocument(nsIDocument* aDocument);
+
+
+
+
+
+  void DropAttribute(int32_t aNamespaceID, nsIAtom* aLocalName);
+# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h"
+  uint32_t Count() const;
+
+  typedef nsRefPtrHashtable<nsAttrHashKey, Attr> AttrCache;
+
+  static void BlastSubtreeToPieces(nsINode *aNode);
+
+  Element* GetParentObject() const
+  {
+    return mContent;
+  }
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+
+  Attr* GetNamedItem(const nsAString& aAttrName);
+  Attr* NamedGetter(const nsAString& aAttrName, bool& aFound);
+  already_AddRefed<Attr>
+  RemoveNamedItem(mozilla::dom::NodeInfo* aNodeInfo, ErrorResult& aError);
+  already_AddRefed<Attr>
+  RemoveNamedItem(const nsAString& aName, ErrorResult& aError);
+
+  Attr* Item(uint32_t aIndex);
+  Attr* IndexedGetter(uint32_t aIndex, bool& aFound);
+  uint32_t Length() const;
+
+  Attr*
+  GetNamedItemNS(const nsAString& aNamespaceURI,
+                 const nsAString& aLocalName);
+  already_AddRefed<Attr>
+  SetNamedItemNS(Attr& aNode, ErrorResult& aError);
+  already_AddRefed<Attr>
+  RemoveNamedItemNS(const nsAString& aNamespaceURI, const nsAString& aLocalName,
+                    ErrorResult& aError);
+
+  void
+  GetSupportedNames(nsTArray<nsString>& aNames);
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+protected:
+  virtual ~nsDOMAttributeMap();
+
+private:
+  nsCOMPtr<Element> mContent;
+
+
+
+
+  AttrCache mAttributeCache;
+
+  already_AddRefed<mozilla::dom::NodeInfo>
+  GetAttrNodeInfo(const nsAString& aNamespaceURI,
+                  const nsAString& aLocalName);
+
+  Attr* GetAttribute(mozilla::dom::NodeInfo* aNodeInfo);
+};
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h" 1
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h" 1
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+namespace mozilla {
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+namespace detail {
+const MozRefCountType DEAD = 0xffffdead;
+# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+enum RefCountAtomicity
+{
+  AtomicRefCount,
+  NonAtomicRefCount
+};
+
+template<typename T, RefCountAtomicity Atomicity>
+class RefCounted
+{
+protected:
+  RefCounted() : mRefCnt(0) {}
+  ~RefCounted() { do { } while (0); }
+
+public:
+
+  void AddRef() const
+  {
+
+    do { } while (0);
+
+    ++mRefCnt;
+
+
+
+
+
+
+
+  }
+
+  void Release() const
+  {
+
+    do { } while (0);
+
+    MozRefCountType cnt = --mRefCnt;
+# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+    if (0 == cnt) {
+
+
+
+
+
+
+
+      delete static_cast<const T*>(this);
+    }
+  }
+
+
+  void ref() { AddRef(); }
+  void deref() { Release(); }
+  MozRefCountType refCount() const { return mRefCnt; }
+  bool hasOneRef() const
+  {
+    do { } while (0);
+    return mRefCnt == 1;
+  }
+
+private:
+  mutable typename Conditional<Atomicity == AtomicRefCount,
+                               Atomic<MozRefCountType>,
+                               MozRefCountType>::Type mRefCnt;
+};
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+}
+
+template<typename T>
+class RefCounted : public detail::RefCounted<T, detail::NonAtomicRefCount>
+{
+public:
+  ~RefCounted()
+  {
+    static_assert(IsBaseOf<RefCounted, T>::value,
+                  "T must derive from RefCounted<T>");
+  }
+};
+
+namespace external {
+# 197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
+template<typename T>
+class AtomicRefCounted :
+  public mozilla::detail::RefCounted<T, mozilla::detail::AtomicRefCount>
+{
+public:
+  ~AtomicRefCounted()
+  {
+    static_assert(IsBaseOf<AtomicRefCounted, T>::value,
+                  "T must derive from AtomicRefCounted<T>");
+  }
+};
+
+}
+
+}
+# 74 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h" 2
+# 131 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
+namespace mozilla {
+
+template <typename T> class WeakPtr;
+template <typename T> class SupportsWeakPtr;
+# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
+namespace detail {
+
+
+
+template<class T>
+class WeakReference : public ::mozilla::RefCounted<WeakReference<T> >
+{
+public:
+  explicit WeakReference(T* p) : mPtr(p)
+  {
+    do { } while (false);
+  }
+
+  T* get() const {
+    do { } while (false);
+    return mPtr;
+  }
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
+private:
+  friend class mozilla::SupportsWeakPtr<T>;
+
+  void detach() {
+    do { } while (false);
+    mPtr = nullptr;
+  }
+
+  T* mPtr;
+
+};
+
+}
+
+template <typename T>
+class SupportsWeakPtr
+{
+protected:
+  ~SupportsWeakPtr()
+  {
+    static_assert(IsBaseOf<SupportsWeakPtr<T>, T>::value,
+                  "T must derive from SupportsWeakPtr<T>");
+    if (mSelfReferencingWeakPtr) {
+      mSelfReferencingWeakPtr.mRef->detach();
+    }
+  }
+
+private:
+  const WeakPtr<T>& SelfReferencingWeakPtr()
+  {
+    if (!mSelfReferencingWeakPtr) {
+      mSelfReferencingWeakPtr.mRef = new detail::WeakReference<T>(static_cast<T*>(this));
+    } else {
+      do { } while (false);
+    }
+    return mSelfReferencingWeakPtr;
+  }
+
+  const WeakPtr<const T>& SelfReferencingWeakPtr() const
+  {
+    const WeakPtr<T>& p = const_cast<SupportsWeakPtr*>(this)->SelfReferencingWeakPtr();
+    return reinterpret_cast<const WeakPtr<const T>&>(p);
+  }
+
+  friend class WeakPtr<T>;
+  friend class WeakPtr<const T>;
+
+  WeakPtr<T> mSelfReferencingWeakPtr;
+};
+
+template <typename T>
+class WeakPtr
+{
+  typedef detail::WeakReference<T> WeakReference;
+
+public:
+  WeakPtr& operator=(const WeakPtr& aOther)
+  {
+    mRef = aOther.mRef;
+    do { } while (false);
+    return *this;
+  }
+
+  WeakPtr(const WeakPtr& aOther)
+  {
+
+    *this = aOther;
+  }
+
+  WeakPtr& operator=(T* aOther)
+  {
+    if (aOther) {
+      *this = aOther->SelfReferencingWeakPtr();
+    } else if (!mRef || mRef->get()) {
+
+      mRef = new WeakReference(nullptr);
+    }
+
+
+    return *this;
+  }
+
+               WeakPtr(T* aOther)
+  {
+    *this = aOther;
+    do { } while (false);
+  }
+
+
+  WeakPtr() : mRef(new WeakReference(nullptr)) {}
+
+  operator T*() const { return mRef->get(); }
+  T& operator*() const { return *mRef->get(); }
+
+  T* operator->() const { return mRef->get(); }
+
+  T* get() const { return mRef->get(); }
+
+private:
+  friend class SupportsWeakPtr<T>;
+
+  explicit WeakPtr(const RefPtr<WeakReference>& aOther) : mRef(aOther) {}
+
+  RefPtr<WeakReference> mRef;
+};
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h" 1
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h"
+class nsQueryFrame
+{
+public:
+  enum FrameIID {
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameIdList.h" 1
+
+
+
+
+BRFrame_id,
+DetailsFrame_id,
+nsAutoRepeatBoxFrame_id,
+nsBCTableCellFrame_id,
+nsBackdropFrame_id,
+nsBlockFrame_id,
+nsBox_id,
+nsBoxFrame_id,
+nsBulletFrame_id,
+nsButtonBoxFrame_id,
+nsCanvasFrame_id,
+nsColorControlFrame_id,
+nsColumnSetFrame_id,
+nsComboboxControlFrame_id,
+nsComboboxDisplayFrame_id,
+nsContainerFrame_id,
+nsContinuingTextFrame_id,
+nsDateTimeControlFrame_id,
+nsDeckFrame_id,
+nsDocElementBoxFrame_id,
+nsFieldSetFrame_id,
+nsFileControlFrame_id,
+nsFirstLetterFrame_id,
+nsFirstLineFrame_id,
+nsFlexContainerFrame_id,
+nsFormControlFrame_id,
+nsFrame_id,
+nsGfxButtonControlFrame_id,
+nsGfxCheckboxControlFrame_id,
+nsGfxRadioControlFrame_id,
+nsGridContainerFrame_id,
+nsGridRowGroupFrame_id,
+nsGridRowLeafFrame_id,
+nsGroupBoxFrame_id,
+nsHTMLButtonControlFrame_id,
+nsHTMLCanvasFrame_id,
+nsHTMLFramesetBlankFrame_id,
+nsHTMLFramesetBorderFrame_id,
+nsHTMLFramesetFrame_id,
+nsHTMLScrollFrame_id,
+nsIAnonymousContentCreator_id,
+nsIComboboxControlFrame_id,
+nsIFormControlFrame_id,
+nsIFrame_id,
+nsIFrameFrame_id,
+nsIListControlFrame_id,
+nsIMathMLFrame_id,
+nsIMenuFrame_id,
+nsIObjectFrame_id,
+nsIPageSequenceFrame_id,
+nsIPercentBSizeObserver_id,
+nsIRootBox_id,
+nsSVGDisplayableFrame_id,
+nsISVGSVGFrame_id,
+nsIScrollableFrame_id,
+nsIScrollbarMediator_id,
+nsISelectControlFrame_id,
+nsIStatefulFrame_id,
+nsITableCellLayout_id,
+nsITableLayout_id,
+nsITextControlFrame_id,
+nsITreeBoxObject_id,
+nsImageBoxFrame_id,
+nsImageControlFrame_id,
+nsImageFrame_id,
+nsInlineFrame_id,
+nsLeafBoxFrame_id,
+nsLeafFrame_id,
+nsLegendFrame_id,
+nsListBoxBodyFrame_id,
+nsListControlFrame_id,
+nsListItemFrame_id,
+nsMathMLContainerFrame_id,
+nsMathMLFrame_id,
+nsMathMLmactionFrame_id,
+nsMathMLmathBlockFrame_id,
+nsMathMLmathInlineFrame_id,
+nsMathMLmencloseFrame_id,
+nsMathMLmfencedFrame_id,
+nsMathMLmfracFrame_id,
+nsMathMLmmultiscriptsFrame_id,
+nsMathMLmoFrame_id,
+nsMathMLmoverFrame_id,
+nsMathMLmpaddedFrame_id,
+nsMathMLmrootFrame_id,
+nsMathMLmrowFrame_id,
+nsMathMLmspaceFrame_id,
+nsMathMLmsqrtFrame_id,
+nsMathMLmstyleFrame_id,
+nsMathMLmtableFrame_id,
+nsMathMLmtableWrapperFrame_id,
+nsMathMLmtdFrame_id,
+nsMathMLmtdInnerFrame_id,
+nsMathMLmtrFrame_id,
+nsMathMLmunderFrame_id,
+nsMathMLmunderoverFrame_id,
+nsMathMLsemanticsFrame_id,
+nsMathMLTokenFrame_id,
+nsMenuBarFrame_id,
+nsMenuFrame_id,
+nsMenuPopupFrame_id,
+nsMeterFrame_id,
+nsNumberControlFrame_id,
+nsPluginFrame_id,
+nsPageBreakFrame_id,
+nsPageContentFrame_id,
+nsPageFrame_id,
+nsPlaceholderFrame_id,
+nsPopupSetFrame_id,
+nsProgressFrame_id,
+nsProgressMeterFrame_id,
+nsRangeFrame_id,
+nsResizerFrame_id,
+nsRootBoxFrame_id,
+nsRubyBaseContainerFrame_id,
+nsRubyBaseFrame_id,
+nsRubyContentFrame_id,
+nsRubyFrame_id,
+nsRubyTextContainerFrame_id,
+nsRubyTextFrame_id,
+nsScrollbarButtonFrame_id,
+nsScrollbarFrame_id,
+nsSelectsAreaFrame_id,
+nsSimplePageSequenceFrame_id,
+nsSliderFrame_id,
+nsSplittableFrame_id,
+nsSplitterFrame_id,
+nsStackFrame_id,
+nsSubDocumentFrame_id,
+nsSVGAFrame_id,
+nsSVGClipPathFrame_id,
+nsSVGContainerFrame_id,
+nsSVGDisplayContainerFrame_id,
+SVGFEContainerFrame_id,
+SVGFEImageFrame_id,
+SVGFELeafFrame_id,
+SVGFEUnstyledLeafFrame_id,
+nsSVGFilterFrame_id,
+nsSVGForeignObjectFrame_id,
+nsSVGGenericContainerFrame_id,
+nsSVGGFrame_id,
+nsSVGGradientFrame_id,
+nsSVGImageFrame_id,
+nsSVGInnerSVGFrame_id,
+nsSVGLinearGradientFrame_id,
+nsSVGMarkerFrame_id,
+nsSVGMarkerAnonChildFrame_id,
+nsSVGMaskFrame_id,
+nsSVGOuterSVGFrame_id,
+nsSVGOuterSVGAnonChildFrame_id,
+nsSVGPaintServerFrame_id,
+SVGGeometryFrame_id,
+nsSVGPatternFrame_id,
+nsSVGRadialGradientFrame_id,
+nsSVGStopFrame_id,
+nsSVGSwitchFrame_id,
+SVGTextFrame_id,
+nsSVGUseFrame_id,
+SVGViewFrame_id,
+nsTableCellFrame_id,
+nsTableColFrame_id,
+nsTableColGroupFrame_id,
+nsTableFrame_id,
+nsTableWrapperFrame_id,
+nsTableRowFrame_id,
+nsTableRowGroupFrame_id,
+nsTextBoxFrame_id,
+nsTextControlFrame_id,
+nsTextFrame_id,
+nsTitleBarFrame_id,
+nsTreeBodyFrame_id,
+nsTreeColFrame_id,
+nsVideoFrame_id,
+nsXULLabelFrame_id,
+nsXULScrollFrame_id,
+ViewportFrame_id,
+# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h" 2
+
+
+
+
+
+
+
+
+    NON_FRAME_MARKER = 0x20000000
+  };
+
+  virtual void* QueryFrame(FrameIID id) = 0;
+};
+
+class do_QueryFrame
+{
+public:
+  explicit do_QueryFrame(nsQueryFrame *s) : mRawPtr(s) { }
+
+
+
+  typedef void (do_QueryFrame::* MatchNullptr)(double, float);
+
+               do_QueryFrame(MatchNullptr aRawPtr) : mRawPtr(nullptr) {}
+
+  template<class Dest>
+  operator Dest*() {
+    static_assert(mozilla::IsSame<Dest, typename Dest::Has_NS_DECL_QUERYFRAME_TARGET>::value,
+                  "Dest must declare itself as a queryframe target");
+    if (!mRawPtr)
+      return nullptr;
+
+    return reinterpret_cast<Dest*>(mRawPtr->QueryFrame(Dest::kFrameIID));
+  }
+
+private:
+  nsQueryFrame *mRawPtr;
+};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 2
+
+namespace mozilla {
+
+enum ArenaObjectID {
+  eArenaObjectID_DummyBeforeFirstObjectID = nsQueryFrame::NON_FRAME_MARKER - 1,
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h" 1
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h"
+eArenaObjectID_nsLineBox,
+eArenaObjectID_nsRuleNode,
+eArenaObjectID_nsStyleContext,
+eArenaObjectID_nsInheritedStyleData,
+eArenaObjectID_nsResetStyleData,
+eArenaObjectID_nsConditionalResetStyleData,
+eArenaObjectID_nsConditionalResetStyleDataEntry,
+eArenaObjectID_nsFrameList,
+eArenaObjectID_CustomCounterStyle,
+eArenaObjectID_DependentBuiltinCounterStyle,
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
+eArenaObjectID_nsStyleFont,
+
+
+
+eArenaObjectID_nsStyleColor,
+
+
+eArenaObjectID_nsStyleList,
+
+
+
+
+eArenaObjectID_nsStyleText,
+
+
+
+
+
+eArenaObjectID_nsStyleVisibility,
+
+
+eArenaObjectID_nsStyleUserInterface,
+
+
+eArenaObjectID_nsStyleTableBorder,
+
+
+
+
+eArenaObjectID_nsStyleSVG,
+
+
+
+
+
+eArenaObjectID_nsStyleVariables,
+
+eArenaObjectID_nsStyleBackground,
+
+
+
+
+
+eArenaObjectID_nsStylePosition,
+
+
+
+
+eArenaObjectID_nsStyleTextReset,
+
+
+
+
+
+eArenaObjectID_nsStyleDisplay,
+
+
+
+
+eArenaObjectID_nsStyleContent,
+
+
+
+
+eArenaObjectID_nsStyleUIReset,
+
+
+eArenaObjectID_nsStyleTable,
+
+
+eArenaObjectID_nsStyleMargin,
+
+
+
+
+eArenaObjectID_nsStylePadding,
+
+
+
+
+eArenaObjectID_nsStyleBorder,
+
+
+
+
+
+eArenaObjectID_nsStyleOutline,
+
+
+
+
+
+eArenaObjectID_nsStyleXUL,
+
+
+eArenaObjectID_nsStyleSVGReset,
+
+
+
+
+
+eArenaObjectID_nsStyleColumn,
+
+
+
+
+
+eArenaObjectID_nsStyleEffects,
+# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 2
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h"
+  eArenaObjectID_NON_OBJECT_MARKER = 0x40000000
+};
+
+};
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+namespace mozilla {
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+template<class T>
+class StaticAutoPtr
+{
+public:
+# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+  StaticAutoPtr<T>& operator=(T* aRhs)
+  {
+    Assign(aRhs);
+    return *this;
+  }
+
+  T* get() const { return mRawPtr; }
+
+  operator T*() const { return get(); }
+
+  T* operator->() const
+  {
+    do { } while (0);
+    return get();
+  }
+
+  T& operator*() const { return *get(); }
+
+private:
+# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+  void Assign(T* aNewPtr)
+  {
+    do { } while (0);
+    T* oldPtr = mRawPtr;
+    mRawPtr = aNewPtr;
+    delete oldPtr;
+  }
+
+  T* mRawPtr;
+};
+
+template<class T>
+class StaticRefPtr
+{
+public:
+# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+  StaticRefPtr<T>& operator=(T* aRhs)
+  {
+    AssignWithAddref(aRhs);
+    return *this;
+  }
+
+  StaticRefPtr<T>& operator=(const StaticRefPtr<T>& aRhs)
+  {
+    return (this = aRhs.mRawPtr);
+  }
+
+  StaticRefPtr<T>& operator=(already_AddRefed<T>& aRhs)
+  {
+    AssignAssumingAddRef(aRhs.take());
+    return *this;
+  }
+
+  StaticRefPtr<T>& operator=(already_AddRefed<T>&& aRhs)
+  {
+    AssignAssumingAddRef(aRhs.take());
+    return *this;
+  }
+
+  already_AddRefed<T>
+  forget()
+  {
+    T* temp = mRawPtr;
+    mRawPtr = nullptr;
+    return already_AddRefed<T>(temp);
+  }
+
+  T* get() const { return mRawPtr; }
+
+  operator T*() const { return get(); }
+
+  T* operator->() const
+  {
+    do { } while (0);
+    return get();
+  }
+
+  T& operator*() const { return *get(); }
+
+private:
+  void AssignWithAddref(T* aNewPtr)
+  {
+    if (aNewPtr) {
+      aNewPtr->AddRef();
+    }
+    AssignAssumingAddRef(aNewPtr);
+  }
+
+  void AssignAssumingAddRef(T* aNewPtr)
+  {
+    T* oldPtr = mRawPtr;
+    mRawPtr = aNewPtr;
+    if (oldPtr) {
+      oldPtr->Release();
+    }
+  }
+
+  T* mRawPtr;
+};
+
+namespace StaticPtr_internal {
+class Zero;
+}
+# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
+template<class T, class U>
+inline bool
+operator==(const StaticAutoPtr<T>& aLhs, const StaticAutoPtr<U>& aRhs)
+{
+  return aLhs.get() == aRhs.get();
+}
+
+template<class T, class U>
+inline bool
+operator!=(const StaticAutoPtr<T>& aLhs, const StaticAutoPtr<U>& aRhs)
+{
+  return !(aLhs == aRhs);
+}
+
+template<class T, class U> inline bool operator==(const StaticAutoPtr<T>& lhs, const U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(const U* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticAutoPtr<T>& lhs, const U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(const U* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+template<class T, class U> inline bool operator==(const StaticAutoPtr<T>& lhs, U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(U* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticAutoPtr<T>& lhs, U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(U* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+
+template<class T> inline bool operator==(const StaticAutoPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return lhs.get() == nullptr; } template<class T> inline bool operator==(StaticPtr_internal::Zero* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T> inline bool operator!=(const StaticAutoPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return !(lhs == rhs); } template<class T> inline bool operator!=(StaticPtr_internal::Zero* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+
+
+template<class T, class U>
+inline bool
+operator==(const StaticRefPtr<T>& aLhs, const StaticRefPtr<U>& aRhs)
+{
+  return aLhs.get() == aRhs.get();
+}
+
+template<class T, class U>
+inline bool
+operator!=(const StaticRefPtr<T>& aLhs, const StaticRefPtr<U>& aRhs)
+{
+  return !(aLhs == aRhs);
+}
+
+template<class T, class U> inline bool operator==(const StaticRefPtr<T>& lhs, const U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(const U* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticRefPtr<T>& lhs, const U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(const U* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+template<class T, class U> inline bool operator==(const StaticRefPtr<T>& lhs, U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(U* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticRefPtr<T>& lhs, U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(U* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+
+template<class T> inline bool operator==(const StaticRefPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return lhs.get() == nullptr; } template<class T> inline bool operator==(StaticPtr_internal::Zero* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T> inline bool operator!=(const StaticRefPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return !(lhs == rhs); } template<class T> inline bool operator!=(StaticPtr_internal::Zero* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
+
+
+
+
+}
+
+
+template<class T> template<class U>
+RefPtr<T>::RefPtr(const mozilla::StaticRefPtr<U>& aOther)
+  : RefPtr(aOther.get())
+{}
+
+template<class T> template<class U>
+RefPtr<T>&
+RefPtr<T>::operator=(const mozilla::StaticRefPtr<U>& aOther)
+{
+  return operator=(aOther.get());
+}
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SheetType.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SheetType.h"
+namespace mozilla {
+
+
+
+
+
+
+enum class SheetType : uint8_t {
+  Agent,
+  User,
+  PresHint,
+  Doc,
+  ScopedDoc,
+  StyleAttr,
+  Override,
+  Animation,
+  Transition,
+
+  Count,
+  Unknown = 0xff
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleBackendType.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleBackendType.h"
+namespace mozilla {
+
+
+
+
+enum class StyleBackendType : uint8_t
+{
+  None,
+  Gecko,
+  Servo
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h"
+namespace mozilla {
+
+class StyleSheet;
+struct StyleSheetAtoms;
+
+namespace dom {
+
+struct NativePropertyHooks;
+class ProtoAndIfaceCache;
+
+}
+
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class CSSStyleSheetParsingMode : uint8_t {
+  Author,
+  User,
+  Agent,
+  EndGuard_
+};
+
+namespace CSSStyleSheetParsingModeValues {
+extern const EnumEntry strings[4];
+}
+
+bool
+ToJSValue(JSContext* aCx, CSSStyleSheetParsingMode aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+namespace CSSStyleSheetBinding {
+
+  typedef mozilla::StyleSheet NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::StyleSheet* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/net/ReferrerPolicy.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h"
+class nsILoadGroup;
+
+typedef uint32_t nsLoadFlags;
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h"
+class nsIRequest : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetName(nsACString & aName) = 0;
+
+
+  virtual nsresult IsPending(bool *_retval) = 0;
+
+
+  virtual nsresult GetStatus(nsresult *aStatus) = 0;
+
+
+  virtual nsresult Cancel(nsresult aStatus) = 0;
+
+
+  virtual nsresult Suspend(void) = 0;
+
+
+  virtual nsresult Resume(void) = 0;
+
+
+  virtual nsresult GetLoadGroup(nsILoadGroup * *aLoadGroup) = 0;
+  virtual nsresult SetLoadGroup(nsILoadGroup *aLoadGroup) = 0;
+
+
+  virtual nsresult GetLoadFlags(nsLoadFlags *aLoadFlags) = 0;
+  virtual nsresult SetLoadFlags(nsLoadFlags aLoadFlags) = 0;
+
+  enum {
+    LOAD_REQUESTMASK = 65535U,
+    LOAD_NORMAL = 0U,
+    LOAD_BACKGROUND = 1U,
+    LOAD_HTML_OBJECT_DATA = 2U,
+    INHIBIT_CACHING = 128U,
+    INHIBIT_PERSISTENT_CACHING = 256U,
+    LOAD_BYPASS_CACHE = 512U,
+    LOAD_FROM_CACHE = 1024U,
+    VALIDATE_ALWAYS = 2048U,
+    VALIDATE_NEVER = 4096U,
+    VALIDATE_ONCE_PER_SESSION = 8192U,
+    LOAD_ANONYMOUS = 16384U,
+    LOAD_FRESH_CONNECTION = 32768U
+  };
+
+};
+
+  template<typename T> struct nsIRequest::COMTypeInfo<nsIRequest, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRequest::COMTypeInfo<nsIRequest, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xef6bfbd2, 0xfd46, 0x48d8, { 0x96, 0xb7, 0x9f, 0x8f, 0x0f, 0xd3, 0x87, 0xfe }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h"
+class nsIURI;
+
+class nsIDOMNode;
+
+class nsIPrincipal;
+
+typedef uint32_t nsContentPolicyType;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h"
+class nsIContentPolicyBase : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    TYPE_INVALID = 0U,
+    TYPE_OTHER = 1U,
+    TYPE_SCRIPT = 2U,
+    TYPE_IMAGE = 3U,
+    TYPE_STYLESHEET = 4U,
+    TYPE_OBJECT = 5U,
+    TYPE_DOCUMENT = 6U,
+    TYPE_SUBDOCUMENT = 7U,
+    TYPE_REFRESH = 8U,
+    TYPE_XBL = 9U,
+    TYPE_PING = 10U,
+    TYPE_XMLHTTPREQUEST = 11U,
+    TYPE_DATAREQUEST = 11U,
+    TYPE_OBJECT_SUBREQUEST = 12U,
+    TYPE_DTD = 13U,
+    TYPE_FONT = 14U,
+    TYPE_MEDIA = 15U,
+    TYPE_WEBSOCKET = 16U,
+    TYPE_CSP_REPORT = 17U,
+    TYPE_XSLT = 18U,
+    TYPE_BEACON = 19U,
+    TYPE_FETCH = 20U,
+    TYPE_IMAGESET = 21U,
+    TYPE_WEB_MANIFEST = 22U,
+    TYPE_INTERNAL_SCRIPT = 23U,
+    TYPE_INTERNAL_WORKER = 24U,
+    TYPE_INTERNAL_SHARED_WORKER = 25U,
+    TYPE_INTERNAL_EMBED = 26U,
+    TYPE_INTERNAL_OBJECT = 27U,
+    TYPE_INTERNAL_FRAME = 28U,
+    TYPE_INTERNAL_IFRAME = 29U,
+    TYPE_INTERNAL_AUDIO = 30U,
+    TYPE_INTERNAL_VIDEO = 31U,
+    TYPE_INTERNAL_TRACK = 32U,
+    TYPE_INTERNAL_XMLHTTPREQUEST = 33U,
+    TYPE_INTERNAL_EVENTSOURCE = 34U,
+    TYPE_INTERNAL_SERVICE_WORKER = 35U,
+    TYPE_INTERNAL_SCRIPT_PRELOAD = 36U,
+    TYPE_INTERNAL_IMAGE = 37U,
+    TYPE_INTERNAL_IMAGE_PRELOAD = 38U,
+    TYPE_INTERNAL_STYLESHEET = 39U,
+    TYPE_INTERNAL_STYLESHEET_PRELOAD = 40U,
+    TYPE_INTERNAL_IMAGE_FAVICON = 41U,
+    TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS = 42U,
+    REJECT_REQUEST = -1,
+    REJECT_TYPE = -2,
+    REJECT_SERVER = -3,
+    REJECT_OTHER = -4,
+    ACCEPT = 1
+  };
+
+};
+
+  template<typename T> struct nsIContentPolicyBase::COMTypeInfo<nsIContentPolicyBase, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentPolicyBase::COMTypeInfo<nsIContentPolicyBase, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x17418187, 0xd86f, 0x48dd, { 0x92, 0xd1, 0x23, 0x88, 0x38, 0xdf, 0x0a, 0x4e }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h" 2
+
+
+
+
+
+
+class nsIURI;
+
+class nsIDOMNode;
+
+class nsIPrincipal;
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h"
+class nsIContentPolicy : public nsIContentPolicyBase {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult ShouldLoad(nsContentPolicyType aContentType, nsIURI *aContentLocation, nsIURI *aRequestOrigin, nsISupports *aContext, const nsACString & aMimeTypeGuess, nsISupports *aExtra, nsIPrincipal *aRequestPrincipal, int16_t *_retval) = 0;
+
+
+  virtual nsresult ShouldProcess(nsContentPolicyType aContentType, nsIURI *aContentLocation, nsIURI *aRequestOrigin, nsISupports *aContext, const nsACString & aMimeType, nsISupports *aExtra, nsIPrincipal *aRequestPrincipal, int16_t *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIContentPolicy::COMTypeInfo<nsIContentPolicy, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentPolicy::COMTypeInfo<nsIContentPolicy, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcaad4f1f, 0xd047, 0x46ac, { 0xae, 0x9d, 0xdc, 0x59, 0x8e, 0x4f, 0xb9, 0x1b }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
+class nsIDOMDocument;
+
+class nsINode;
+
+class nsIPrincipal;
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
+namespace mozilla {
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
+template<typename T>
+class RangedPtr
+{
+  T* mPtr;
+
+
+
+
+
+
+  void checkSanity()
+  {
+    do { } while (0);
+    do { } while (0);
+  }
+
+
+  RangedPtr<T> create(T* aPtr) const
+  {
+
+
+
+    return RangedPtr<T>(aPtr, nullptr, size_t(0));
+
+  }
+
+  uintptr_t asUintptr() const { return reinterpret_cast<uintptr_t>(mPtr); }
+
+public:
+  RangedPtr(T* aPtr, T* aStart, T* aEnd)
+    : mPtr(aPtr)
+
+
+
+  {
+    do { } while (0);
+    checkSanity();
+  }
+  RangedPtr(T* aPtr, T* aStart, size_t aLength)
+    : mPtr(aPtr)
+
+
+
+  {
+    do { } while (0);
+    do { } while (0);
+
+    checkSanity();
+  }
+
+
+  RangedPtr(T* aPtr, size_t aLength)
+    : mPtr(aPtr)
+
+
+
+  {
+    do { } while (0);
+    do { } while (0);
+
+    checkSanity();
+  }
+
+
+  template<size_t N>
+  explicit RangedPtr(T (&aArr)[N])
+    : mPtr(aArr)
+
+
+
+  {
+    checkSanity();
+  }
+
+  T* get() const { return mPtr; }
+
+  explicit operator bool() const { return mPtr != nullptr; }
+
+  void checkIdenticalRange(const RangedPtr<T>& aOther) const
+  {
+    do { } while (0);
+    do { } while (0);
+  }
+# 136 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
+  RangedPtr<T>& operator=(const RangedPtr<T>& aOther)
+  {
+    checkIdenticalRange(aOther);
+    mPtr = aOther.mPtr;
+    checkSanity();
+    return *this;
+  }
+
+  RangedPtr<T> operator+(size_t aInc) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return create(mPtr + aInc);
+  }
+
+  RangedPtr<T> operator-(size_t aDec) const
+  {
+    do { } while (0);
+    do { } while (0);
+    return create(mPtr - aDec);
+  }
+
+
+
+
+
+  template <typename U>
+  RangedPtr<T>& operator=(U* aPtr)
+  {
+    *this = create(aPtr);
+    return *this;
+  }
+
+  template <typename U>
+  RangedPtr<T>& operator=(const RangedPtr<U>& aPtr)
+  {
+    do { } while (0);
+    do { } while (0);
+    mPtr = aPtr.mPtr;
+    checkSanity();
+    return *this;
+  }
+
+  RangedPtr<T>& operator++()
+  {
+    return (*this += 1);
+  }
+
+  RangedPtr<T> operator++(int)
+  {
+    RangedPtr<T> rcp = *this;
+    ++*this;
+    return rcp;
+  }
+
+  RangedPtr<T>& operator--()
+  {
+    return (*this -= 1);
+  }
+
+  RangedPtr<T> operator--(int)
+  {
+    RangedPtr<T> rcp = *this;
+    --*this;
+    return rcp;
+  }
+
+  RangedPtr<T>& operator+=(size_t aInc)
+  {
+    *this = *this + aInc;
+    return *this;
+  }
+
+  RangedPtr<T>& operator-=(size_t aDec)
+  {
+    *this = *this - aDec;
+    return *this;
+  }
+
+  T& operator[](int aIndex) const
+  {
+    do { } while (0);
+    return *create(mPtr + aIndex);
+  }
+
+  T& operator*() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return *mPtr;
+  }
+
+  T* operator->() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mPtr;
+  }
+
+  template <typename U>
+  bool operator==(const RangedPtr<U>& aOther) const
+  {
+    return mPtr == aOther.mPtr;
+  }
+  template <typename U>
+  bool operator!=(const RangedPtr<U>& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  template<typename U>
+  bool operator==(const U* u) const
+  {
+    return mPtr == u;
+  }
+  template<typename U>
+  bool operator!=(const U* u) const
+  {
+    return !(*this == u);
+  }
+
+  template <typename U>
+  bool operator<(const RangedPtr<U>& aOther) const
+  {
+    return mPtr < aOther.mPtr;
+  }
+  template <typename U>
+  bool operator<=(const RangedPtr<U>& aOther) const
+  {
+    return mPtr <= aOther.mPtr;
+  }
+
+  template <typename U>
+  bool operator>(const RangedPtr<U>& aOther) const
+  {
+    return mPtr > aOther.mPtr;
+  }
+  template <typename U>
+  bool operator>=(const RangedPtr<U>& aOther) const
+  {
+    return mPtr >= aOther.mPtr;
+  }
+
+  size_t operator-(const RangedPtr<T>& aOther) const
+  {
+    do { } while (0);
+    return PointerRangeSize(aOther.mPtr, mPtr);
+  }
+
+private:
+  RangedPtr() = delete;
+};
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 2
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 2
+
+namespace mozilla {
+
+
+template <typename T>
+class Range
+{
+  const RangedPtr<T> mStart;
+  const RangedPtr<T> mEnd;
+
+public:
+  Range() : mStart(nullptr, 0), mEnd(nullptr, 0) {}
+  Range(T* aPtr, size_t aLength)
+    : mStart(aPtr, aPtr, aPtr + aLength),
+      mEnd(aPtr + aLength, aPtr, aPtr + aLength)
+  {}
+  Range(const RangedPtr<T>& aStart, const RangedPtr<T>& aEnd)
+    : mStart(aStart.get(), aStart.get(), aEnd.get()),
+      mEnd(aEnd.get(), aStart.get(), aEnd.get())
+  {
+
+    aStart.checkIdenticalRange(aEnd);
+    do { } while (0);
+  }
+
+  template<typename U,
+           class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
+                                     int>::Type>
+               Range(const Range<U>& aOther)
+    : mStart(aOther.mStart),
+      mEnd(aOther.mEnd)
+  {}
+
+               Range(Span<T> aSpan)
+    : Range(aSpan.Elements(), aSpan.Length())
+  {
+  }
+
+  template<typename U,
+           class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
+                                     int>::Type>
+               Range(const Span<U>& aSpan)
+    : Range(aSpan.Elements(), aSpan.Length())
+  {
+  }
+
+  RangedPtr<T> begin() const { return mStart; }
+  RangedPtr<T> end() const { return mEnd; }
+  size_t length() const { return mEnd - mStart; }
+
+  T& operator[](size_t aOffset) const { return mStart[aOffset]; }
+
+  explicit operator bool() const { return mStart != nullptr; }
+
+  operator Span<T>() { return Span<T>(mStart.get(), length()); }
+
+  operator Span<const T>() const { return Span<T>(mStart.get(), length()); }
+};
+
+template<class T>
+Span<T>
+MakeSpan(Range<T>& aRange)
+{
+  return aRange;
+}
+
+template<class T>
+Span<const T>
+MakeSpan(const Range<T>& aRange)
+{
+  return aRange;
+}
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+
+
+
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h" 1
+# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
+typedef bool
+(* JSNative)(JSContext* cx, unsigned argc, JS::Value* vp);
+
+namespace JS {
+
+extern const HandleValue UndefinedHandleValue;
+
+namespace detail {
+
+
+
+
+
+extern Value
+ComputeThis(JSContext* cx, JS::Value* vp);
+
+
+extern void
+CheckIsValidConstructible(const Value& v);
+
+
+class IncludeUsedRval
+{
+  protected:
+
+    mutable bool usedRval_;
+    void setUsedRval() const { usedRval_ = true; }
+    void clearUsedRval() const { usedRval_ = false; }
+    void assertUnusedRval() const { do { } while (0); }
+
+
+
+
+
+};
+
+class NoUsedRval
+{
+  protected:
+    void setUsedRval() const {}
+    void clearUsedRval() const {}
+    void assertUnusedRval() const {}
+};
+
+template<class WantUsedRval>
+class CallArgsBase : public WantUsedRval
+{
+    static_assert(mozilla::IsSame<WantUsedRval, IncludeUsedRval>::value ||
+                  mozilla::IsSame<WantUsedRval, NoUsedRval>::value,
+                  "WantUsedRval can only be IncludeUsedRval or NoUsedRval");
+
+  protected:
+    Value* argv_;
+    unsigned argc_;
+    bool constructing_:1;
+
+
+    bool ignoresReturnValue_:1;
+
+  public:
+
+
+
+
+
+
+    HandleValue calleev() const {
+        this->assertUnusedRval();
+        return HandleValue::fromMarkedLocation(&argv_[-2]);
+    }
+
+
+
+
+
+    JSObject& callee() const {
+        return calleev().toObject();
+    }
+
+
+
+    bool isConstructing() const {
+        if (!argv_[-1].isMagic())
+            return false;
+
+
+        if (!this->usedRval_)
+            CheckIsValidConstructible(calleev());
+
+
+        return true;
+    }
+
+    bool ignoresReturnValue() const {
+        return ignoresReturnValue_;
+    }
+
+    MutableHandleValue newTarget() const {
+        do { } while (0);
+        return MutableHandleValue::fromMarkedLocation(&this->argv_[argc_]);
+    }
+
+
+
+
+
+
+
+    HandleValue thisv() const {
+
+
+
+        return HandleValue::fromMarkedLocation(&argv_[-1]);
+    }
+
+    Value computeThis(JSContext* cx) const {
+        if (thisv().isObject())
+            return thisv();
+
+        return ComputeThis(cx, base());
+    }
+
+
+
+
+    unsigned length() const { return argc_; }
+
+
+    MutableHandleValue operator[](unsigned i) const {
+        do { } while (0);
+        return MutableHandleValue::fromMarkedLocation(&this->argv_[i]);
+    }
+
+
+
+
+
+    HandleValue get(unsigned i) const {
+        return i < length()
+               ? HandleValue::fromMarkedLocation(&this->argv_[i])
+               : UndefinedHandleValue;
+    }
+
+
+
+
+
+    bool hasDefined(unsigned i) const {
+        return i < argc_ && !this->argv_[i].isUndefined();
+    }
+# 241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
+    MutableHandleValue rval() const {
+        this->setUsedRval();
+        return MutableHandleValue::fromMarkedLocation(&argv_[-2]);
+    }
+
+  public:
+
+
+
+
+    void setCallee(const Value& aCalleev) const {
+        this->clearUsedRval();
+        argv_[-2] = aCalleev;
+    }
+
+    void setThis(const Value& aThisv) const {
+        argv_[-1] = aThisv;
+    }
+
+    MutableHandleValue mutableThisv() const {
+        return MutableHandleValue::fromMarkedLocation(&argv_[-1]);
+    }
+
+  public:
+
+
+
+
+    Value* array() const { return argv_; }
+    Value* end() const { return argv_ + argc_ + constructing_; }
+
+  public:
+
+
+
+    Value* base() const { return argv_ - 2; }
+
+    Value* spAfterCall() const {
+        this->setUsedRval();
+        return argv_ - 1;
+    }
+};
+
+}
+
+class CallArgs : public detail::CallArgsBase<detail::IncludeUsedRval>
+{
+  private:
+    friend CallArgs CallArgsFromVp(unsigned argc, Value* vp);
+    friend CallArgs CallArgsFromSp(unsigned stackSlots, Value* sp, bool constructing,
+                                   bool ignoresReturnValue);
+
+    static CallArgs create(unsigned argc, Value* argv, bool constructing,
+                           bool ignoresReturnValue = false) {
+        CallArgs args;
+        args.clearUsedRval();
+        args.argv_ = argv;
+        args.argc_ = argc;
+        args.constructing_ = constructing;
+        args.ignoresReturnValue_ = ignoresReturnValue;
+
+
+
+
+
+
+        return args;
+    }
+
+  public:
+
+
+
+
+    bool requireAtLeast(JSContext* cx, const char* fnname, unsigned required) const;
+
+};
+
+__attribute__((always_inline)) inline CallArgs
+CallArgsFromVp(unsigned argc, Value* vp)
+{
+    return CallArgs::create(argc, vp + 2, vp[1].isMagic(JS_IS_CONSTRUCTING));
+}
+
+
+
+
+__attribute__((always_inline)) inline CallArgs
+CallArgsFromSp(unsigned stackSlots, Value* sp, bool constructing = false,
+               bool ignoresReturnValue = false)
+{
+    return CallArgs::create(stackSlots - constructing, sp - stackSlots, constructing,
+                            ignoresReturnValue);
+}
+
+}
+# 353 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
+__attribute__((always_inline)) inline JS::Value
+JS_THIS(JSContext* cx, JS::Value* vp)
+{
+    return vp[1].isPrimitive() ? JS::detail::ComputeThis(cx, vp) : vp[1];
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
+class JSFlatString;
+
+namespace JS {
+
+
+
+
+
+
+
+class Latin1Chars : public mozilla::Range<Latin1Char>
+{
+    typedef mozilla::Range<Latin1Char> Base;
+
+  public:
+    using CharT = Latin1Char;
+
+    Latin1Chars() : Base() {}
+    Latin1Chars(char* aBytes, size_t aLength) : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength) {}
+    Latin1Chars(const Latin1Char* aBytes, size_t aLength)
+      : Base(const_cast<Latin1Char*>(aBytes), aLength)
+    {}
+    Latin1Chars(const char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<Latin1Char*>(const_cast<char*>(aBytes)), aLength)
+    {}
+};
+
+
+
+
+class Latin1CharsZ : public mozilla::RangedPtr<Latin1Char>
+{
+    typedef mozilla::RangedPtr<Latin1Char> Base;
+
+  public:
+    using CharT = Latin1Char;
+
+    Latin1CharsZ() : Base(nullptr, 0) {}
+
+    Latin1CharsZ(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength)
+    {
+        do { } while (0);
+    }
+
+    Latin1CharsZ(Latin1Char* aBytes, size_t aLength)
+      : Base(aBytes, aLength)
+    {
+        do { } while (0);
+    }
+
+    using Base::operator=;
+
+    char* c_str() { return reinterpret_cast<char*>(get()); }
+};
+
+class UTF8Chars : public mozilla::Range<unsigned char>
+{
+    typedef mozilla::Range<unsigned char> Base;
+
+  public:
+    using CharT = unsigned char;
+
+    UTF8Chars() : Base() {}
+    UTF8Chars(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
+    {}
+    UTF8Chars(const char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(const_cast<char*>(aBytes)), aLength)
+    {}
+};
+
+
+
+
+class UTF8CharsZ : public mozilla::RangedPtr<unsigned char>
+{
+    typedef mozilla::RangedPtr<unsigned char> Base;
+
+  public:
+    using CharT = unsigned char;
+
+    UTF8CharsZ() : Base(nullptr, 0) {}
+
+    UTF8CharsZ(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
+    {
+        do { } while (0);
+    }
+
+    UTF8CharsZ(unsigned char* aBytes, size_t aLength)
+      : Base(aBytes, aLength)
+    {
+        do { } while (0);
+    }
+
+    using Base::operator=;
+
+    char* c_str() { return reinterpret_cast<char*>(get()); }
+};
+
+
+
+
+
+
+
+class ConstUTF8CharsZ
+{
+    const char* data_;
+
+  public:
+    using CharT = unsigned char;
+
+    ConstUTF8CharsZ() : data_(nullptr)
+    {}
+
+    ConstUTF8CharsZ(const char* aBytes, size_t aLength)
+      : data_(aBytes)
+    {
+        do { } while (0);
+
+
+
+    }
+
+    const void* get() const { return data_; }
+
+    const char* c_str() const { return data_; }
+
+    explicit operator bool() const { return data_ != nullptr; }
+
+  private:
+
+
+
+};
+# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
+class TwoByteChars : public mozilla::Range<char16_t>
+{
+    typedef mozilla::Range<char16_t> Base;
+
+  public:
+    using CharT = char16_t;
+
+    TwoByteChars() : Base() {}
+    TwoByteChars(char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
+    TwoByteChars(const char16_t* aChars, size_t aLength) : Base(const_cast<char16_t*>(aChars), aLength) {}
+};
+
+
+
+
+class TwoByteCharsZ : public mozilla::RangedPtr<char16_t>
+{
+    typedef mozilla::RangedPtr<char16_t> Base;
+
+  public:
+    using CharT = char16_t;
+
+    TwoByteCharsZ() : Base(nullptr, 0) {}
+
+    TwoByteCharsZ(char16_t* chars, size_t length)
+      : Base(chars, length)
+    {
+        do { } while (0);
+    }
+
+    using Base::operator=;
+};
+
+typedef mozilla::RangedPtr<const char16_t> ConstCharPtr;
+
+
+
+
+class ConstTwoByteChars : public mozilla::Range<const char16_t>
+{
+    typedef mozilla::Range<const char16_t> Base;
+
+  public:
+    using CharT = char16_t;
+
+    ConstTwoByteChars() : Base() {}
+    ConstTwoByteChars(const char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
+};
+# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
+extern Latin1CharsZ
+LossyTwoByteCharsToNewLatin1CharsZ(JSContext* cx,
+                                   const mozilla::Range<const char16_t> tbchars);
+
+inline Latin1CharsZ
+LossyTwoByteCharsToNewLatin1CharsZ(JSContext* cx, const char16_t* begin, size_t length)
+{
+    const mozilla::Range<const char16_t> tbchars(begin, length);
+    return JS::LossyTwoByteCharsToNewLatin1CharsZ(cx, tbchars);
+}
+
+template <typename CharT>
+extern UTF8CharsZ
+CharsToNewUTF8CharsZ(JSContext* maybeCx, const mozilla::Range<CharT> chars);
+
+uint32_t
+Utf8ToOneUcs4Char(const uint8_t* utf8Buffer, int utf8Length);
+
+
+
+
+
+
+
+extern TwoByteCharsZ
+UTF8CharsToNewTwoByteCharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
+
+
+
+
+extern TwoByteCharsZ
+UTF8CharsToNewTwoByteCharsZ(JSContext* cx, const ConstUTF8CharsZ& utf8, size_t* outlen);
+
+
+
+
+
+
+extern TwoByteCharsZ
+LossyUTF8CharsToNewTwoByteCharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
+
+extern TwoByteCharsZ
+LossyUTF8CharsToNewTwoByteCharsZ(JSContext* cx, const ConstUTF8CharsZ& utf8, size_t* outlen);
+
+
+
+
+
+size_t
+GetDeflatedUTF8StringLength(JSFlatString* s);
+# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
+void
+DeflateStringToUTF8Buffer(JSFlatString* src, mozilla::RangedPtr<char> dst,
+                          size_t* dstlenp = nullptr, size_t* numcharsp = nullptr);
+
+
+
+
+
+enum class SmallestEncoding {
+    ASCII,
+    Latin1,
+    UTF16
+};
+
+
+
+
+
+
+SmallestEncoding
+FindSmallestEncoding(UTF8Chars utf8);
+
+
+
+
+
+
+
+extern Latin1CharsZ
+UTF8CharsToNewLatin1CharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
+
+
+
+
+
+
+extern Latin1CharsZ
+LossyUTF8CharsToNewLatin1CharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
+
+
+
+
+
+extern bool
+StringIsASCII(const char* s);
+
+}
+
+inline void JS_free(JS::Latin1CharsZ& ptr) { js_free((void*)ptr.get()); }
+inline void JS_free(JS::UTF8CharsZ& ptr) { js_free((void*)ptr.get()); }
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+struct JSAtomState;
+struct JSFreeOp;
+struct JSFunctionSpec;
+
+namespace js {
+
+struct Class;
+class FreeOp;
+class Shape;
+
+
+
+extern const js::Class* const FunctionClassPtr;
+
+}
+
+namespace JS {
+
+class AutoIdVector;
+
+
+
+
+
+enum class IsArrayAnswer
+{
+    Array,
+    NotArray,
+    RevokedProxy
+};
+# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+extern bool
+IsArray(JSContext* cx, HandleObject obj, bool* isArray);
+# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+extern bool
+IsArray(JSContext* cx, HandleObject obj, IsArrayAnswer* answer);
+# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+class ObjectOpResult
+{
+  private:
+# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    uintptr_t code_;
+
+  public:
+    enum SpecialCodes : uintptr_t {
+        OkCode = 0,
+        Uninitialized = uintptr_t(-1)
+    };
+
+    ObjectOpResult() : code_(Uninitialized) {}
+
+
+    bool ok() const {
+        do { } while (0);
+        return code_ == OkCode;
+    }
+
+    explicit operator bool() const { return ok(); }
+
+
+    bool succeed() {
+        code_ = OkCode;
+        return true;
+    }
+# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    bool fail(uint32_t msg) {
+        do { } while (0);
+        code_ = msg;
+        return true;
+    }
+
+    bool failCantRedefineProp();
+    bool failReadOnly();
+    bool failGetterOnly();
+    bool failCantDelete();
+
+    bool failCantSetInterposed();
+    bool failCantDefineWindowElement();
+    bool failCantDeleteWindowElement();
+    bool failCantDeleteWindowNamedProperty();
+    bool failCantPreventExtensions();
+    bool failCantSetProto();
+    bool failNoNamedSetter();
+    bool failNoIndexedSetter();
+
+    uint32_t failureCode() const {
+        do { } while (0);
+        return uint32_t(code_);
+    }
+# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    bool checkStrictErrorOrWarning(JSContext* cx, HandleObject obj, HandleId id, bool strict) {
+        if (ok())
+            return true;
+        return reportStrictErrorOrWarning(cx, obj, id, strict);
+    }
+
+
+
+
+
+
+
+    bool checkStrictErrorOrWarning(JSContext* cx, HandleObject obj, bool strict) {
+        return ok() || reportStrictErrorOrWarning(cx, obj, strict);
+    }
+
+
+    bool reportError(JSContext* cx, HandleObject obj, HandleId id) {
+        return reportStrictErrorOrWarning(cx, obj, id, true);
+    }
+
+
+
+
+
+    bool reportError(JSContext* cx, HandleObject obj) {
+        return reportStrictErrorOrWarning(cx, obj, true);
+    }
+
+
+    bool reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, HandleId id, bool strict);
+    bool reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, bool strict);
+
+
+
+
+
+    bool checkStrict(JSContext* cx, HandleObject obj, HandleId id) {
+        return checkStrictErrorOrWarning(cx, obj, id, true);
+    }
+
+
+
+
+
+    bool checkStrict(JSContext* cx, HandleObject obj) {
+        return checkStrictErrorOrWarning(cx, obj, true);
+    }
+};
+
+class PropertyResult
+{
+    union {
+        js::Shape* shape_;
+        uintptr_t bits_;
+    };
+
+    static const uintptr_t NotFound = 0;
+    static const uintptr_t NonNativeProperty = 1;
+    static const uintptr_t DenseOrTypedArrayElement = 1;
+
+  public:
+    PropertyResult() : bits_(NotFound) {}
+
+    explicit PropertyResult(js::Shape* propertyShape)
+      : shape_(propertyShape)
+    {
+        do { } while (0);
+    }
+
+    explicit operator bool() const {
+        return isFound();
+    }
+
+    bool isFound() const {
+        return bits_ != NotFound;
+    }
+
+    bool isNonNativeProperty() const {
+        return bits_ == NonNativeProperty;
+    }
+
+    bool isDenseOrTypedArrayElement() const {
+        return bits_ == DenseOrTypedArrayElement;
+    }
+
+    bool isNativeProperty() const {
+        return isFound() && !isNonNativeProperty();
+    }
+
+    js::Shape* maybeShape() const {
+        do { } while (0);
+        return isFound() ? shape_ : nullptr;
+    }
+
+    js::Shape* shape() const {
+        do { } while (0);
+        return shape_;
+    }
+
+    void setNotFound() {
+        bits_ = NotFound;
+    }
+
+    void setNativeProperty(js::Shape* propertyShape) {
+        shape_ = propertyShape;
+        do { } while (0);
+    }
+
+    void setNonNativeProperty() {
+        bits_ = NonNativeProperty;
+    }
+
+    void setDenseOrTypedArrayElement() {
+        bits_ = DenseOrTypedArrayElement;
+    }
+
+    void trace(JSTracer* trc);
+};
+
+}
+
+namespace js {
+
+template <class Wrapper>
+class WrappedPtrOperations<JS::PropertyResult, Wrapper>
+{
+    const JS::PropertyResult& value() const { return static_cast<const Wrapper*>(this)->get(); }
+
+  public:
+    bool isFound() const { return value().isFound(); }
+    explicit operator bool() const { return bool(value()); }
+    js::Shape* maybeShape() const { return value().maybeShape(); }
+    js::Shape* shape() const { return value().shape(); }
+    bool isNativeProperty() const { return value().isNativeProperty(); }
+    bool isNonNativeProperty() const { return value().isNonNativeProperty(); }
+    bool isDenseOrTypedArrayElement() const { return value().isDenseOrTypedArrayElement(); }
+    js::Shape* asTaggedShape() const { return value().asTaggedShape(); }
+};
+
+template <class Wrapper>
+class MutableWrappedPtrOperations<JS::PropertyResult, Wrapper>
+  : public WrappedPtrOperations<JS::PropertyResult, Wrapper>
+{
+    JS::PropertyResult& value() { return static_cast<Wrapper*>(this)->get(); }
+
+  public:
+    void setNotFound() {
+        value().setNotFound();
+    }
+    void setNativeProperty(js::Shape* shape) {
+        value().setNativeProperty(shape);
+    }
+    void setNonNativeProperty() {
+        value().setNonNativeProperty();
+    }
+    void setDenseOrTypedArrayElement() {
+        value().setDenseOrTypedArrayElement();
+    }
+};
+
+}
+# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSGetterOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+               JS::MutableHandleValue vp);
+
+
+typedef bool
+(* JSAddPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v);
+# 386 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSSetterOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+               JS::MutableHandleValue vp, JS::ObjectOpResult& result);
+# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSDeletePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                       JS::ObjectOpResult& result);
+# 422 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSNewEnumerateOp)(JSContext* cx, JS::HandleObject obj, JS::AutoIdVector& properties,
+                     bool enumerableOnly);
+
+
+
+
+
+typedef bool
+(* JSEnumerateOp)(JSContext* cx, JS::HandleObject obj);
+
+
+
+
+
+
+typedef JSString*
+(* JSFunToStringOp)(JSContext* cx, JS::HandleObject obj, unsigned indent);
+# 450 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSResolveOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                bool* resolvedp);
+# 465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef bool
+(* JSMayResolveOp)(const JSAtomState& names, jsid id, JSObject* maybeObj);
+
+
+
+
+
+
+typedef void
+(* JSFinalizeOp)(JSFreeOp* fop, JSObject* obj);
+
+
+struct JSStringFinalizer {
+    void (*finalize)(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
+};
+
+
+
+
+
+
+typedef bool
+(* JSHasInstanceOp)(JSContext* cx, JS::HandleObject obj, JS::MutableHandleValue vp,
+                    bool* bp);
+# 504 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+typedef void
+(* JSTraceOp)(JSTracer* trc, JSObject* obj);
+
+typedef JSObject*
+(* JSWeakmapKeyDelegateOp)(JSObject* obj);
+
+typedef void
+(* JSObjectMovedOp)(JSObject* obj, const JSObject* old);
+
+
+
+namespace js {
+
+typedef bool
+(* LookupPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                     JS::MutableHandleObject objp, JS::MutableHandle<JS::PropertyResult> propp);
+typedef bool
+(* DefinePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                     JS::Handle<JS::PropertyDescriptor> desc,
+                     JS::ObjectOpResult& result);
+typedef bool
+(* HasPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
+typedef bool
+(* GetPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleValue receiver, JS::HandleId id,
+                  JS::MutableHandleValue vp);
+typedef bool
+(* SetPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v,
+                  JS::HandleValue receiver, JS::ObjectOpResult& result);
+typedef bool
+(* GetOwnPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                     JS::MutableHandle<JS::PropertyDescriptor> desc);
+typedef bool
+(* DeletePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                     JS::ObjectOpResult& result);
+
+typedef bool
+(* WatchOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
+
+typedef bool
+(* UnwatchOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
+
+class ElementAdder
+{
+  public:
+    enum GetBehavior {
+
+
+        CheckHasElemPreserveHoles,
+
+
+        GetElement
+    };
+
+  private:
+
+    JS::RootedObject resObj_;
+    JS::Value* vp_;
+
+    uint32_t index_;
+
+
+
+    GetBehavior getBehavior_;
+
+  public:
+    ElementAdder(JSContext* cx, JSObject* obj, uint32_t length, GetBehavior behavior)
+      : resObj_(cx, obj), vp_(nullptr), index_(0),
+
+
+
+        getBehavior_(behavior)
+    {}
+    ElementAdder(JSContext* cx, JS::Value* vp, uint32_t length, GetBehavior behavior)
+      : resObj_(cx), vp_(vp), index_(0),
+
+
+
+        getBehavior_(behavior)
+    {}
+
+    GetBehavior getBehavior() const { return getBehavior_; }
+
+    bool append(JSContext* cx, JS::HandleValue v);
+    void appendHole();
+};
+
+typedef bool
+(* GetElementsOp)(JSContext* cx, JS::HandleObject obj, uint32_t begin, uint32_t end,
+                  ElementAdder* adder);
+
+typedef void
+(* FinalizeOp)(FreeOp* fop, JSObject* obj);
+# 635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+struct ClassOps
+{
+
+    JSAddPropertyOp addProperty;
+    JSDeletePropertyOp delProperty;
+    JSGetterOp getProperty;
+    JSSetterOp setProperty;
+    JSEnumerateOp enumerate;
+    JSResolveOp resolve;
+    JSMayResolveOp mayResolve;
+    FinalizeOp finalize;
+    JSNative call;
+    JSHasInstanceOp hasInstance;
+    JSNative construct;
+    JSTraceOp trace;
+};
+
+
+typedef JSObject* (*ClassObjectCreationOp)(JSContext* cx, JSProtoKey key);
+
+
+typedef bool (*FinishClassInitOp)(JSContext* cx, JS::HandleObject ctor,
+                                  JS::HandleObject proto);
+
+const size_t JSCLASS_CACHED_PROTO_WIDTH = 6;
+
+struct ClassSpec
+{
+    ClassObjectCreationOp createConstructor;
+    ClassObjectCreationOp createPrototype;
+    const JSFunctionSpec* constructorFunctions;
+    const JSPropertySpec* constructorProperties;
+    const JSFunctionSpec* prototypeFunctions;
+    const JSPropertySpec* prototypeProperties;
+    FinishClassInitOp finishInit;
+    uintptr_t flags;
+
+    static const size_t ProtoKeyWidth = JSCLASS_CACHED_PROTO_WIDTH;
+
+    static const uintptr_t ProtoKeyMask = (1 << ProtoKeyWidth) - 1;
+    static const uintptr_t DontDefineConstructor = 1 << ProtoKeyWidth;
+
+    bool defined() const { return !!createConstructor; }
+
+
+    JSProtoKey inheritanceProtoKey() const {
+        do { } while (0);
+        static_assert(JSProto_Null == 0, "zeroed key must be null");
+
+
+        if (!(flags & ProtoKeyMask))
+            return JSProto_Object;
+
+        return JSProtoKey(flags & ProtoKeyMask);
+    }
+
+    bool shouldDefineConstructor() const {
+        do { } while (0);
+        return !(flags & DontDefineConstructor);
+    }
+};
+
+struct ClassExtension
+{
+# 710 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    JSWeakmapKeyDelegateOp weakmapKeyDelegateOp;
+# 723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    JSObjectMovedOp objectMovedOp;
+};
+
+
+
+
+struct ObjectOps
+{
+    LookupPropertyOp lookupProperty;
+    DefinePropertyOp defineProperty;
+    HasPropertyOp hasProperty;
+    GetPropertyOp getProperty;
+    SetPropertyOp setProperty;
+    GetOwnPropertyOp getOwnPropertyDescriptor;
+    DeletePropertyOp deleteProperty;
+    WatchOp watch;
+    UnwatchOp unwatch;
+    GetElementsOp getElements;
+    JSNewEnumerateOp enumerate;
+    JSFunToStringOp funToString;
+};
+
+
+
+}
+
+
+
+typedef void (*JSClassInternal)();
+
+struct JSClassOps
+{
+
+    JSAddPropertyOp addProperty;
+    JSDeletePropertyOp delProperty;
+    JSGetterOp getProperty;
+    JSSetterOp setProperty;
+    JSEnumerateOp enumerate;
+    JSResolveOp resolve;
+    JSMayResolveOp mayResolve;
+    JSFinalizeOp finalize;
+    JSNative call;
+    JSHasInstanceOp hasInstance;
+    JSNative construct;
+    JSTraceOp trace;
+};
+
+
+
+struct JSClass {
+    const char* name; uint32_t flags; const JSClassOps* cOps; JSAddPropertyOp getAddProperty() const { return cOps ? cOps->addProperty : nullptr; } JSDeletePropertyOp getDelProperty() const { return cOps ? cOps->delProperty : nullptr; } JSGetterOp getGetProperty() const { return cOps ? cOps->getProperty : nullptr; } JSSetterOp getSetProperty() const { return cOps ? cOps->setProperty : nullptr; } JSEnumerateOp getEnumerate() const { return cOps ? cOps->enumerate : nullptr; } JSResolveOp getResolve() const { return cOps ? cOps->resolve : nullptr; } JSMayResolveOp getMayResolve() const { return cOps ? cOps->mayResolve : nullptr; } JSNative getCall() const { return cOps ? cOps->call : nullptr; } JSHasInstanceOp getHasInstance() const { return cOps ? cOps->hasInstance : nullptr; } JSNative getConstruct() const { return cOps ? cOps->construct : nullptr; } bool hasFinalize() const { return cOps && cOps->finalize; } bool hasTrace() const { return cOps && cOps->trace; } bool isTrace(JSTraceOp trace) const { return cOps && cOps->trace == trace; } void doFinalize(JSFreeOp* fop, JSObject* obj) const { do { } while (0); cOps->finalize(fop, obj); } void doTrace(JSTracer* trc, JSObject* obj) const { do { } while (0); cOps->trace(trc, obj); };
+
+    void* reserved[3];
+};
+# 877 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+namespace js {
+
+struct Class
+{
+    const char* name; uint32_t flags; const js::ClassOps* cOps; JSAddPropertyOp getAddProperty() const { return cOps ? cOps->addProperty : nullptr; } JSDeletePropertyOp getDelProperty() const { return cOps ? cOps->delProperty : nullptr; } JSGetterOp getGetProperty() const { return cOps ? cOps->getProperty : nullptr; } JSSetterOp getSetProperty() const { return cOps ? cOps->setProperty : nullptr; } JSEnumerateOp getEnumerate() const { return cOps ? cOps->enumerate : nullptr; } JSResolveOp getResolve() const { return cOps ? cOps->resolve : nullptr; } JSMayResolveOp getMayResolve() const { return cOps ? cOps->mayResolve : nullptr; } JSNative getCall() const { return cOps ? cOps->call : nullptr; } JSHasInstanceOp getHasInstance() const { return cOps ? cOps->hasInstance : nullptr; } JSNative getConstruct() const { return cOps ? cOps->construct : nullptr; } bool hasFinalize() const { return cOps && cOps->finalize; } bool hasTrace() const { return cOps && cOps->trace; } bool isTrace(JSTraceOp trace) const { return cOps && cOps->trace == trace; } void doFinalize(FreeOp* fop, JSObject* obj) const { do { } while (0); cOps->finalize(fop, obj); } void doTrace(JSTracer* trc, JSObject* obj) const { do { } while (0); cOps->trace(trc, obj); };
+    const ClassSpec* spec;
+    const ClassExtension* ext;
+    const ObjectOps* oOps;
+# 893 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
+    static const uint32_t NON_NATIVE = (1<<((8 + 8)+2));
+
+    bool isNative() const {
+        return !(flags & NON_NATIVE);
+    }
+
+    bool hasPrivate() const {
+        return !!(flags & (1<<0));
+    }
+
+    bool emulatesUndefined() const {
+        return flags & (1<<6);
+    }
+
+    bool isJSFunction() const {
+        return this == js::FunctionClassPtr;
+    }
+
+    bool nonProxyCallable() const {
+        do { } while (0);
+        return isJSFunction() || getCall();
+    }
+
+    bool isProxy() const {
+        return flags & (1<<((8 + 8)+4));
+    }
+
+    bool isDOMClass() const {
+        return flags & (1<<4);
+    }
+
+    bool shouldDelayMetadataBuilder() const {
+        return flags & (1<<1);
+    }
+
+    bool isWrappedNative() const {
+        return flags & (1<<2);
+    }
+
+    static size_t offsetOfFlags() { return __builtin_offsetof(Class, flags); }
+
+    bool specDefined() const { return spec ? spec->defined() : false; }
+    JSProtoKey specInheritanceProtoKey()
+                               const { return spec ? spec->inheritanceProtoKey() : JSProto_Null; }
+    bool specShouldDefineConstructor()
+                               const { return spec ? spec->shouldDefineConstructor() : true; }
+    ClassObjectCreationOp specCreateConstructorHook()
+                               const { return spec ? spec->createConstructor : nullptr; }
+    ClassObjectCreationOp specCreatePrototypeHook()
+                               const { return spec ? spec->createPrototype : nullptr; }
+    const JSFunctionSpec* specConstructorFunctions()
+                               const { return spec ? spec->constructorFunctions : nullptr; }
+    const JSPropertySpec* specConstructorProperties()
+                               const { return spec ? spec->constructorProperties : nullptr; }
+    const JSFunctionSpec* specPrototypeFunctions()
+                               const { return spec ? spec->prototypeFunctions : nullptr; }
+    const JSPropertySpec* specPrototypeProperties()
+                               const { return spec ? spec->prototypeProperties : nullptr; }
+    FinishClassInitOp specFinishInitHook()
+                               const { return spec ? spec->finishInit : nullptr; }
+
+    JSWeakmapKeyDelegateOp extWeakmapKeyDelegateOp()
+                               const { return ext ? ext->weakmapKeyDelegateOp : nullptr; }
+    JSObjectMovedOp extObjectMovedOp()
+                               const { return ext ? ext->objectMovedOp : nullptr; }
+
+    LookupPropertyOp getOpsLookupProperty() const { return oOps ? oOps->lookupProperty : nullptr; }
+    DefinePropertyOp getOpsDefineProperty() const { return oOps ? oOps->defineProperty : nullptr; }
+    HasPropertyOp getOpsHasProperty() const { return oOps ? oOps->hasProperty : nullptr; }
+    GetPropertyOp getOpsGetProperty() const { return oOps ? oOps->getProperty : nullptr; }
+    SetPropertyOp getOpsSetProperty() const { return oOps ? oOps->setProperty : nullptr; }
+    GetOwnPropertyOp getOpsGetOwnPropertyDescriptor()
+                                            const { return oOps ? oOps->getOwnPropertyDescriptor
+                                                                                     : nullptr; }
+    DeletePropertyOp getOpsDeleteProperty() const { return oOps ? oOps->deleteProperty : nullptr; }
+    WatchOp getOpsWatch() const { return oOps ? oOps->watch : nullptr; }
+    UnwatchOp getOpsUnwatch() const { return oOps ? oOps->unwatch : nullptr; }
+    GetElementsOp getOpsGetElements() const { return oOps ? oOps->getElements : nullptr; }
+    JSNewEnumerateOp getOpsEnumerate() const { return oOps ? oOps->enumerate : nullptr; }
+    JSFunToStringOp getOpsFunToString() const { return oOps ? oOps->funToString : nullptr; }
+};
+
+static_assert(__builtin_offsetof(JSClassOps, addProperty) == __builtin_offsetof(ClassOps, addProperty),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, delProperty) == __builtin_offsetof(ClassOps, delProperty),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, getProperty) == __builtin_offsetof(ClassOps, getProperty),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, setProperty) == __builtin_offsetof(ClassOps, setProperty),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, enumerate) == __builtin_offsetof(ClassOps, enumerate),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, resolve) == __builtin_offsetof(ClassOps, resolve),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, mayResolve) == __builtin_offsetof(ClassOps, mayResolve),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, finalize) == __builtin_offsetof(ClassOps, finalize),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, call) == __builtin_offsetof(ClassOps, call),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, construct) == __builtin_offsetof(ClassOps, construct),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, hasInstance) == __builtin_offsetof(ClassOps, hasInstance),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(__builtin_offsetof(JSClassOps, trace) == __builtin_offsetof(ClassOps, trace),
+              "ClassOps and JSClassOps must be consistent");
+static_assert(sizeof(JSClassOps) == sizeof(ClassOps),
+              "ClassOps and JSClassOps must be consistent");
+
+static_assert(__builtin_offsetof(JSClass, name) == __builtin_offsetof(Class, name),
+              "Class and JSClass must be consistent");
+static_assert(__builtin_offsetof(JSClass, flags) == __builtin_offsetof(Class, flags),
+              "Class and JSClass must be consistent");
+static_assert(__builtin_offsetof(JSClass, cOps) == __builtin_offsetof(Class, cOps),
+              "Class and JSClass must be consistent");
+static_assert(sizeof(JSClass) == sizeof(Class),
+              "Class and JSClass must be consistent");
+
+static __attribute__((always_inline)) inline const JSClass*
+Jsvalify(const Class* c)
+{
+    return (const JSClass*)c;
+}
+
+static __attribute__((always_inline)) inline const Class*
+Valueify(const JSClass* c)
+{
+    return (const Class*)c;
+}
+
+
+
+
+
+enum class ESClass {
+    Object,
+    Array,
+    Number,
+    String,
+    Boolean,
+    RegExp,
+    ArrayBuffer,
+    SharedArrayBuffer,
+    Date,
+    Set,
+    Map,
+    Promise,
+    MapIterator,
+    SetIterator,
+    Arguments,
+    Error,
+
+
+    Other
+};
+
+
+bool
+Unbox(JSContext* cx, JS::HandleObject obj, JS::MutableHandleValue vp);
+
+
+
+
+
+
+}
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Vector.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Vector.h"
+namespace js {
+
+class TempAllocPolicy;
+
+namespace detail {
+
+template <typename T>
+struct TypeIsGCThing : mozilla::FalseType
+{};
+
+
+
+
+
+
+}
+
+template <typename T,
+          size_t MinInlineCapacity = 0,
+          class AllocPolicy = TempAllocPolicy,
+
+         typename = typename mozilla::EnableIf<!detail::TypeIsGCThing<T>::value>::Type
+         >
+using Vector = mozilla::Vector<T, MinInlineCapacity, AllocPolicy>;
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h" 2
+
+namespace JS {
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h"
+template <typename T,
+          size_t MinInlineCapacity = 0,
+          typename AllocPolicy = js::TempAllocPolicy>
+class GCVector
+{
+    mozilla::Vector<T, MinInlineCapacity, AllocPolicy> vector;
+
+  public:
+    explicit GCVector(AllocPolicy alloc = AllocPolicy())
+      : vector(alloc)
+    {}
+
+    GCVector(GCVector&& vec)
+      : vector(mozilla::Move(vec.vector))
+    {}
+
+    GCVector& operator=(GCVector&& vec) {
+        vector = mozilla::Move(vec.vector);
+        return *this;
+    }
+
+    size_t length() const { return vector.length(); }
+    bool empty() const { return vector.empty(); }
+    size_t capacity() const { return vector.capacity(); }
+
+    T* begin() { return vector.begin(); }
+    const T* begin() const { return vector.begin(); }
+
+    T* end() { return vector.end(); }
+    const T* end() const { return vector.end(); }
+
+    T& operator[](size_t i) { return vector[i]; }
+    const T& operator[](size_t i) const { return vector[i]; }
+
+    T& back() { return vector.back(); }
+    const T& back() const { return vector.back(); }
+
+    bool initCapacity(size_t cap) { return vector.initCapacity(cap); }
+    __attribute__ ((warn_unused_result)) bool reserve(size_t req) { return vector.reserve(req); }
+    void shrinkBy(size_t amount) { return vector.shrinkBy(amount); }
+    __attribute__ ((warn_unused_result)) bool growBy(size_t amount) { return vector.growBy(amount); }
+    __attribute__ ((warn_unused_result)) bool resize(size_t newLen) { return vector.resize(newLen); }
+
+    void clear() { return vector.clear(); }
+    void clearAndFree() { return vector.clearAndFree(); }
+
+    template<typename U> bool append(U&& item) { return vector.append(mozilla::Forward<U>(item)); }
+
+    template<typename... Args>
+    __attribute__ ((warn_unused_result)) bool
+    emplaceBack(Args&&... args) {
+        return vector.emplaceBack(mozilla::Forward<Args>(args)...);
+    }
+
+    template<typename U>
+    void infallibleAppend(U&& aU) {
+        return vector.infallibleAppend(mozilla::Forward<U>(aU));
+    }
+    void infallibleAppendN(const T& aT, size_t aN) {
+        return vector.infallibleAppendN(aT, aN);
+    }
+    template<typename U> void
+    infallibleAppend(const U* aBegin, const U* aEnd) {
+        return vector.infallibleAppend(aBegin, aEnd);
+    }
+    template<typename U> void infallibleAppend(const U* aBegin, size_t aLength) {
+        return vector.infallibleAppend(aBegin, aLength);
+    }
+
+    template<typename U, size_t O, class BP>
+    __attribute__ ((warn_unused_result)) bool appendAll(const mozilla::Vector<U, O, BP>& aU) { return vector.appendAll(aU); }
+    template<typename U, size_t O, class BP>
+    __attribute__ ((warn_unused_result)) bool appendAll(const GCVector<U, O, BP>& aU) {
+        return vector.append(aU.begin(), aU.length());
+    }
+
+    __attribute__ ((warn_unused_result)) bool appendN(const T& val, size_t count) { return vector.appendN(val, count); }
+
+    template<typename U>
+    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd) {
+        return vector.append(aBegin, aEnd);
+    }
+    template<typename U>
+    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength) {
+        return vector.append(aBegin, aLength);
+    }
+
+    void popBack() { return vector.popBack(); }
+    T popCopy() { return vector.popCopy(); }
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return vector.sizeOfExcludingThis(mallocSizeOf);
+    }
+
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return vector.sizeOfIncludingThis(mallocSizeOf);
+    }
+
+    static void trace(GCVector* vec, JSTracer* trc) { vec->trace(trc); }
+
+    void trace(JSTracer* trc) {
+        for (auto& elem : vector)
+            GCPolicy<T>::trace(trc, &elem, "vector element");
+    }
+
+    void sweep() {
+        uint32_t src, dst = 0;
+        for (src = 0; src < length(); src++) {
+            if (!GCPolicy<T>::needsSweep(&vector[src])) {
+                if (dst != src)
+                    vector[dst] = vector[src].unbarrieredGet();
+                dst++;
+            }
+        }
+
+        if (dst != length())
+            vector.shrinkTo(dst);
+    }
+};
+
+}
+
+namespace js {
+
+template <typename Wrapper, typename T, size_t Capacity, typename AllocPolicy>
+class WrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
+{
+    using Vec = JS::GCVector<T, Capacity, AllocPolicy>;
+    const Vec& vec() const { return static_cast<const Wrapper*>(this)->get(); }
+
+  public:
+    const AllocPolicy& allocPolicy() const { return vec().allocPolicy(); }
+    size_t length() const { return vec().length(); }
+    bool empty() const { return vec().empty(); }
+    size_t capacity() const { return vec().capacity(); }
+    const T* begin() const { return vec().begin(); }
+    const T* end() const { return vec().end(); }
+    const T& back() const { return vec().back(); }
+
+    JS::Handle<T> operator[](size_t aIndex) const {
+        return JS::Handle<T>::fromMarkedLocation(&vec().operator[](aIndex));
+    }
+};
+
+template <typename Wrapper, typename T, size_t Capacity, typename AllocPolicy>
+class MutableWrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
+  : public WrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
+{
+    using Vec = JS::GCVector<T, Capacity, AllocPolicy>;
+    const Vec& vec() const { return static_cast<const Wrapper*>(this)->get(); }
+    Vec& vec() { return static_cast<Wrapper*>(this)->get(); }
+
+  public:
+    const AllocPolicy& allocPolicy() const { return vec().allocPolicy(); }
+    AllocPolicy& allocPolicy() { return vec().allocPolicy(); }
+    const T* begin() const { return vec().begin(); }
+    T* begin() { return vec().begin(); }
+    const T* end() const { return vec().end(); }
+    T* end() { return vec().end(); }
+    const T& back() const { return vec().back(); }
+    T& back() { return vec().back(); }
+
+    JS::Handle<T> operator[](size_t aIndex) const {
+        return JS::Handle<T>::fromMarkedLocation(&vec().operator[](aIndex));
+    }
+    JS::MutableHandle<T> operator[](size_t aIndex) {
+        return JS::MutableHandle<T>::fromMarkedLocation(&vec().operator[](aIndex));
+    }
+
+    __attribute__ ((warn_unused_result)) bool initCapacity(size_t aRequest) { return vec().initCapacity(aRequest); }
+    __attribute__ ((warn_unused_result)) bool reserve(size_t aRequest) { return vec().reserve(aRequest); }
+    void shrinkBy(size_t aIncr) { vec().shrinkBy(aIncr); }
+    __attribute__ ((warn_unused_result)) bool growBy(size_t aIncr) { return vec().growBy(aIncr); }
+    __attribute__ ((warn_unused_result)) bool resize(size_t aNewLength) { return vec().resize(aNewLength); }
+    __attribute__ ((warn_unused_result)) bool growByUninitialized(size_t aIncr) { return vec().growByUninitialized(aIncr); }
+    void infallibleGrowByUninitialized(size_t aIncr) { vec().infallibleGrowByUninitialized(aIncr); }
+    __attribute__ ((warn_unused_result)) bool resizeUninitialized(size_t aNewLength) { return vec().resizeUninitialized(aNewLength); }
+    void clear() { vec().clear(); }
+    void clearAndFree() { vec().clearAndFree(); }
+    template<typename U>
+    __attribute__ ((warn_unused_result)) bool append(U&& aU) { return vec().append(mozilla::Forward<U>(aU)); }
+    template<typename... Args>
+    __attribute__ ((warn_unused_result)) bool emplaceBack(Args&&... aArgs) {
+        return vec().emplaceBack(mozilla::Forward<Args...>(aArgs...));
+    }
+    template<typename U, size_t O, class BP>
+    __attribute__ ((warn_unused_result)) bool appendAll(const mozilla::Vector<U, O, BP>& aU) { return vec().appendAll(aU); }
+    template<typename U, size_t O, class BP>
+    __attribute__ ((warn_unused_result)) bool appendAll(const JS::GCVector<U, O, BP>& aU) { return vec().appendAll(aU); }
+    __attribute__ ((warn_unused_result)) bool appendN(const T& aT, size_t aN) { return vec().appendN(aT, aN); }
+    template<typename U>
+    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd) {
+        return vec().append(aBegin, aEnd);
+    }
+    template<typename U>
+    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength) {
+        return vec().append(aBegin, aLength);
+    }
+    template<typename U> void infallibleAppend(U&& aU) {
+        vec().infallibleAppend(mozilla::Forward<U>(aU));
+    }
+    void infallibleAppendN(const T& aT, size_t aN) { vec().infallibleAppendN(aT, aN); }
+    template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd) {
+        vec().infallibleAppend(aBegin, aEnd);
+    }
+    template<typename U> void infallibleAppend(const U* aBegin, size_t aLength) {
+        vec().infallibleAppend(aBegin, aLength);
+    }
+    void popBack() { vec().popBack(); }
+    T popCopy() { return vec().popCopy(); }
+    template<typename U> T* insert(T* aP, U&& aVal) {
+        return vec().insert(aP, mozilla::Forward<U>(aVal));
+    }
+    void erase(T* aT) { vec().erase(aT); }
+    void erase(T* aBegin, T* aEnd) { vec().erase(aBegin, aEnd); }
+};
+
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ScopeExit.h" 1
+# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ScopeExit.h"
+namespace mozilla {
+
+template <typename ExitFunction>
+class ScopeExit {
+  ExitFunction mExitFunction;
+  bool mExecuteOnDestruction;
+
+
+public:
+  explicit ScopeExit(ExitFunction&& cleanup
+                                                    )
+   : mExitFunction(cleanup)
+   , mExecuteOnDestruction(true)
+  {
+    do { } while (0);
+  }
+
+  ScopeExit(ScopeExit&& rhs)
+   : mExitFunction(mozilla::Move(rhs.mExitFunction))
+   , mExecuteOnDestruction(rhs.mExecuteOnDestruction)
+  {
+    rhs.release();
+  }
+
+  ~ScopeExit() {
+    if (mExecuteOnDestruction) {
+      mExitFunction();
+    }
+  }
+
+  void release() {
+    mExecuteOnDestruction = false;
+  }
+
+private:
+  explicit ScopeExit(const ScopeExit&) = delete;
+  ScopeExit& operator=(const ScopeExit&) = delete;
+  ScopeExit& operator=(ScopeExit&&) = delete;
+};
+
+template <typename ExitFunction>
+ScopeExit<ExitFunction>
+MakeScopeExit(ExitFunction&& exitFunction)
+{
+  return ScopeExit<ExitFunction>(mozilla::Move(exitFunction));
+}
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
+namespace mozilla {
+
+template<typename AllocPolicy>
+class BufferList : private AllocPolicy
+{
+
+
+  struct Segment
+  {
+    char* mData;
+    size_t mSize;
+    size_t mCapacity;
+
+    Segment(char* aData, size_t aSize, size_t aCapacity)
+     : mData(aData),
+       mSize(aSize),
+       mCapacity(aCapacity)
+    {
+    }
+
+    Segment(const Segment&) = delete;
+    Segment& operator=(const Segment&) = delete;
+
+    Segment(Segment&&) = default;
+    Segment& operator=(Segment&&) = default;
+
+    char* Start() const { return mData; }
+    char* End() const { return mData + mSize; }
+  };
+
+  template<typename OtherAllocPolicy>
+  friend class BufferList;
+
+ public:
+
+
+
+
+
+  static const size_t kSegmentAlignment = 8;
+
+
+
+
+
+
+  BufferList(size_t aInitialSize,
+             size_t aInitialCapacity,
+             size_t aStandardCapacity,
+             AllocPolicy aAP = AllocPolicy())
+   : AllocPolicy(aAP),
+     mOwning(true),
+     mSegments(aAP),
+     mSize(0),
+     mStandardCapacity(aStandardCapacity)
+  {
+    do { } while (0);
+    do { } while (0);
+
+    if (aInitialCapacity) {
+      AllocateSegment(aInitialSize, aInitialCapacity);
+    }
+  }
+
+  BufferList(const BufferList& aOther) = delete;
+
+  BufferList(BufferList&& aOther)
+   : mOwning(aOther.mOwning),
+     mSegments(Move(aOther.mSegments)),
+     mSize(aOther.mSize),
+     mStandardCapacity(aOther.mStandardCapacity)
+  {
+    aOther.mSegments.clear();
+    aOther.mSize = 0;
+  }
+
+  BufferList& operator=(const BufferList& aOther) = delete;
+
+  BufferList& operator=(BufferList&& aOther)
+  {
+    Clear();
+
+    mOwning = aOther.mOwning;
+    mSegments = Move(aOther.mSegments);
+    mSize = aOther.mSize;
+    aOther.mSegments.clear();
+    aOther.mSize = 0;
+    return *this;
+  }
+
+  ~BufferList() { Clear(); }
+
+
+  size_t Size() const { return mSize; }
+
+  void Clear()
+  {
+    if (mOwning) {
+      for (Segment& segment : mSegments) {
+        this->free_(segment.mData);
+      }
+    }
+    mSegments.clear();
+
+    mSize = 0;
+  }
+
+
+
+  class IterImpl
+  {
+
+
+
+
+    uintptr_t mSegment;
+    char* mData;
+    char* mDataEnd;
+
+    friend class BufferList;
+
+  public:
+    explicit IterImpl(const BufferList& aBuffers)
+     : mSegment(0),
+       mData(nullptr),
+       mDataEnd(nullptr)
+    {
+      if (!aBuffers.mSegments.empty()) {
+        mData = aBuffers.mSegments[0].Start();
+        mDataEnd = aBuffers.mSegments[0].End();
+      }
+    }
+
+
+
+    char* Data() const
+    {
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(!Done())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(!Done()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "!Done()" ")"); do { *((volatile int*) __null) = 162; ::abort(); } while (0); } } while (0);
+      return mData;
+    }
+
+
+
+    bool HasRoomFor(size_t aBytes) const
+    {
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 170; ::abort(); } while (0); } } while (0);
+      return size_t(mDataEnd - mData) >= aBytes;
+    }
+
+
+
+    size_t RemainingInSegment() const
+    {
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 178; ::abort(); } while (0); } } while (0);
+      return mDataEnd - mData;
+    }
+
+
+
+
+
+    void Advance(const BufferList& aBuffers, size_t aBytes)
+    {
+      const Segment& segment = aBuffers.mSegments[mSegment];
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(segment.Start() <= mData)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(segment.Start() <= mData))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "segment.Start() <= mData" ")"); do { *((volatile int*) __null) = 189; ::abort(); } while (0); } } while (0);
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 190; ::abort(); } while (0); } } while (0);
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mDataEnd == segment.End())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mDataEnd == segment.End()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mDataEnd == segment.End()" ")"); do { *((volatile int*) __null) = 191; ::abort(); } while (0); } } while (0);
+
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(HasRoomFor(aBytes))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(HasRoomFor(aBytes)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "HasRoomFor(aBytes)" ")"); do { *((volatile int*) __null) = 193; ::abort(); } while (0); } } while (0);
+      mData += aBytes;
+
+      if (mData == mDataEnd && mSegment + 1 < aBuffers.mSegments.length()) {
+        mSegment++;
+        const Segment& nextSegment = aBuffers.mSegments[mSegment];
+        mData = nextSegment.Start();
+        mDataEnd = nextSegment.End();
+        do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData < mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData < mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData < mDataEnd" ")"); do { *((volatile int*) __null) = 201; ::abort(); } while (0); } } while (0);
+      }
+    }
+
+
+
+
+    bool AdvanceAcrossSegments(const BufferList& aBuffers, size_t aBytes)
+    {
+      size_t bytes = aBytes;
+      while (bytes) {
+        size_t toAdvance = std::min(bytes, RemainingInSegment());
+        if (!toAdvance) {
+          return false;
+        }
+        Advance(aBuffers, toAdvance);
+        bytes -= toAdvance;
+      }
+      return true;
+    }
+
+
+    bool Done() const
+    {
+      return mData == mDataEnd;
+    }
+
+   private:
+
+
+    size_t BytesUntil(const BufferList& aBuffers, const IterImpl& aTarget) const {
+      size_t offset = 0;
+
+      do { } while (0);
+
+      char* data = mData;
+      for (uintptr_t segment = mSegment; segment < aTarget.mSegment; segment++) {
+        offset += aBuffers.mSegments[segment].End() - data;
+        data = aBuffers.mSegments[segment].mData;
+      }
+
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(IsIn(aBuffers))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(IsIn(aBuffers)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "IsIn(aBuffers)" ")"); do { *((volatile int*) __null) = 242; ::abort(); } while (0); } } while (0);
+      do { static_assert(mozilla::detail::AssertionConditionType<decltype(aTarget.mData >= data)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aTarget.mData >= data))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aTarget.mData >= data" ")"); do { *((volatile int*) __null) = 243; ::abort(); } while (0); } } while (0);
+
+      offset += aTarget.mData - data;
+      return offset;
+    }
+
+    bool IsIn(const BufferList& aBuffers) const {
+      return mSegment < aBuffers.mSegments.length() &&
+             mData >= aBuffers.mSegments[mSegment].mData &&
+             mData < aBuffers.mSegments[mSegment].End();
+    }
+  };
+
+
+  char* Start() { return mSegments[0].mData; }
+  const char* Start() const { return mSegments[0].mData; }
+
+  IterImpl Iter() const { return IterImpl(*this); }
+
+
+
+  inline bool WriteBytes(const char* aData, size_t aSize);
+
+
+
+
+  inline bool ReadBytes(IterImpl& aIter, char* aData, size_t aSize) const;
+
+
+
+
+
+
+
+  template<typename BorrowingAllocPolicy>
+  BufferList<BorrowingAllocPolicy> Borrow(IterImpl& aIter, size_t aSize, bool* aSuccess,
+                                          BorrowingAllocPolicy aAP = BorrowingAllocPolicy()) const;
+
+
+
+
+
+
+
+  template<typename OtherAllocPolicy>
+  BufferList<OtherAllocPolicy> MoveFallible(bool* aSuccess, OtherAllocPolicy aAP = OtherAllocPolicy());
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
+  BufferList Extract(IterImpl& aIter, size_t aSize, bool* aSuccess);
+
+
+
+  size_t RangeLength(const IterImpl& start, const IterImpl& end) const {
+    do { } while (0);
+    return start.BytesUntil(*this, end);
+  }
+
+private:
+  explicit BufferList(AllocPolicy aAP)
+   : AllocPolicy(aAP),
+     mOwning(false),
+     mSize(0),
+     mStandardCapacity(0)
+  {
+  }
+
+  void* AllocateSegment(size_t aSize, size_t aCapacity)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 318; ::abort(); } while (0); } } while (0);
+    do { } while (0);
+
+    char* data = this->template pod_malloc<char>(aCapacity);
+    if (!data) {
+      return nullptr;
+    }
+    if (!mSegments.append(Segment(data, aSize, aCapacity))) {
+      this->free_(data);
+      return nullptr;
+    }
+    mSize += aSize;
+    return data;
+  }
+
+  bool mOwning;
+  Vector<Segment, 1, AllocPolicy> mSegments;
+  size_t mSize;
+  size_t mStandardCapacity;
+};
+
+template<typename AllocPolicy>
+bool
+BufferList<AllocPolicy>::WriteBytes(const char* aData, size_t aSize)
+{
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 343; ::abort(); } while (0); } } while (0);
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mStandardCapacity)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mStandardCapacity))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mStandardCapacity" ")"); do { *((volatile int*) __null) = 344; ::abort(); } while (0); } } while (0);
+
+  size_t copied = 0;
+  size_t remaining = aSize;
+
+  if (!mSegments.empty()) {
+    Segment& lastSegment = mSegments.back();
+
+    size_t toCopy = std::min(aSize, lastSegment.mCapacity - lastSegment.mSize);
+    memcpy(lastSegment.mData + lastSegment.mSize, aData, toCopy);
+    lastSegment.mSize += toCopy;
+    mSize += toCopy;
+
+    copied += toCopy;
+    remaining -= toCopy;
+  }
+
+  while (remaining) {
+    size_t toCopy = std::min(remaining, mStandardCapacity);
+
+    void* data = AllocateSegment(toCopy, mStandardCapacity);
+    if (!data) {
+      return false;
+    }
+    memcpy(data, aData + copied, toCopy);
+
+    copied += toCopy;
+    remaining -= toCopy;
+  }
+
+  return true;
+}
+
+template<typename AllocPolicy>
+bool
+BufferList<AllocPolicy>::ReadBytes(IterImpl& aIter, char* aData, size_t aSize) const
+{
+  size_t copied = 0;
+  size_t remaining = aSize;
+  while (remaining) {
+    size_t toCopy = std::min(aIter.RemainingInSegment(), remaining);
+    if (!toCopy) {
+
+      return false;
+    }
+    memcpy(aData + copied, aIter.Data(), toCopy);
+    copied += toCopy;
+    remaining -= toCopy;
+
+    aIter.Advance(*this, toCopy);
+  }
+
+  return true;
+}
+
+template<typename AllocPolicy> template<typename BorrowingAllocPolicy>
+BufferList<BorrowingAllocPolicy>
+BufferList<AllocPolicy>::Borrow(IterImpl& aIter, size_t aSize, bool* aSuccess,
+                                BorrowingAllocPolicy aAP) const
+{
+  BufferList<BorrowingAllocPolicy> result(aAP);
+
+  size_t size = aSize;
+  while (size) {
+    size_t toAdvance = std::min(size, aIter.RemainingInSegment());
+
+    if (!toAdvance || !result.mSegments.append(typename BufferList<BorrowingAllocPolicy>::Segment(aIter.mData, toAdvance, toAdvance))) {
+      *aSuccess = false;
+      return result;
+    }
+    aIter.Advance(*this, toAdvance);
+    size -= toAdvance;
+  }
+
+  result.mSize = aSize;
+  *aSuccess = true;
+  return result;
+}
+
+template<typename AllocPolicy> template<typename OtherAllocPolicy>
+BufferList<OtherAllocPolicy>
+BufferList<AllocPolicy>::MoveFallible(bool* aSuccess, OtherAllocPolicy aAP)
+{
+  BufferList<OtherAllocPolicy> result(0, 0, mStandardCapacity, aAP);
+
+  IterImpl iter = Iter();
+  while (!iter.Done()) {
+    size_t toAdvance = iter.RemainingInSegment();
+
+    if (!toAdvance || !result.mSegments.append(typename BufferList<OtherAllocPolicy>::Segment(iter.mData, toAdvance, toAdvance))) {
+      *aSuccess = false;
+      result.mSegments.clear();
+      return result;
+    }
+    iter.Advance(*this, toAdvance);
+  }
+
+  result.mSize = mSize;
+  mSegments.clear();
+  mSize = 0;
+  *aSuccess = true;
+  return result;
+}
+
+template<typename AllocPolicy>
+BufferList<AllocPolicy>
+BufferList<AllocPolicy>::Extract(IterImpl& aIter, size_t aSize, bool* aSuccess)
+{
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(aSize)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aSize))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aSize" ")"); do { *((volatile int*) __null) = 452; ::abort(); } while (0); } } while (0);
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 453; ::abort(); } while (0); } } while (0);
+  do { } while (0);
+  do { } while (0);
+
+  IterImpl iter = aIter;
+  size_t size = aSize;
+  size_t toCopy = std::min(size, aIter.RemainingInSegment());
+  do { } while (0);
+
+  BufferList result(0, toCopy, mStandardCapacity);
+  BufferList error(0, 0, mStandardCapacity);
+
+
+  if (!result.WriteBytes(aIter.mData, toCopy)) {
+    *aSuccess = false;
+    return error;
+  }
+  iter.Advance(*this, toCopy);
+  size -= toCopy;
+
+
+  auto resultGuard = MakeScopeExit([&] {
+    *aSuccess = false;
+    result.mSegments.erase(result.mSegments.begin()+1, result.mSegments.end());
+  });
+
+  size_t movedSize = 0;
+  uintptr_t toRemoveStart = iter.mSegment;
+  uintptr_t toRemoveEnd = iter.mSegment;
+  while (!iter.Done() &&
+         !iter.HasRoomFor(size)) {
+    if (!result.mSegments.append(Segment(mSegments[iter.mSegment].mData,
+                                         mSegments[iter.mSegment].mSize,
+                                         mSegments[iter.mSegment].mCapacity))) {
+      return error;
+    }
+    movedSize += iter.RemainingInSegment();
+    size -= iter.RemainingInSegment();
+    toRemoveEnd++;
+    iter.Advance(*this, iter.RemainingInSegment());
+  }
+
+  if (size) {
+    if (!iter.HasRoomFor(size) ||
+        !result.WriteBytes(iter.Data(), size)) {
+      return error;
+    }
+    iter.Advance(*this, size);
+  }
+
+  mSegments.erase(mSegments.begin() + toRemoveStart, mSegments.begin() + toRemoveEnd);
+  mSize -= movedSize;
+  aIter.mSegment = iter.mSegment - (toRemoveEnd - toRemoveStart);
+  aIter.mData = iter.mData;
+  aIter.mDataEnd = iter.mDataEnd;
+  do { } while (0);
+  result.mSize = aSize;
+
+  resultGuard.release();
+  *aSuccess = true;
+  return result;
+}
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+struct JSRuntime;
+struct JSStructuredCloneReader;
+struct JSStructuredCloneWriter;
+
+
+
+namespace JS {
+
+enum class StructuredCloneScope : uint32_t {
+    SameProcessSameThread,
+    SameProcessDifferentThread,
+    DifferentProcess
+};
+
+enum TransferableOwnership {
+
+    SCTAG_TMO_UNFILLED = 0,
+
+
+    SCTAG_TMO_UNOWNED = 1,
+
+
+    SCTAG_TMO_FIRST_OWNED = 2,
+
+
+    SCTAG_TMO_ALLOC_DATA = 2,
+
+
+    SCTAG_TMO_MAPPED_DATA = 3,
+
+
+
+
+
+
+    SCTAG_TMO_CUSTOM = 4,
+
+    SCTAG_TMO_USER_MIN
+};
+
+class CloneDataPolicy
+{
+    bool sharedArrayBuffer_;
+
+  public:
+
+
+    CloneDataPolicy() :
+      sharedArrayBuffer_(true)
+    {}
+# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+    CloneDataPolicy& denySharedArrayBuffer() {
+        sharedArrayBuffer_ = false;
+        return *this;
+    }
+
+    bool isSharedArrayBufferAllowed() const {
+        return sharedArrayBuffer_;
+    }
+};
+
+}
+# 101 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+typedef JSObject* (*ReadStructuredCloneOp)(JSContext* cx, JSStructuredCloneReader* r,
+                                           uint32_t tag, uint32_t data, void* closure);
+# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+typedef bool (*WriteStructuredCloneOp)(JSContext* cx, JSStructuredCloneWriter* w,
+                                       JS::HandleObject obj, void* closure);
+
+
+
+
+
+
+typedef void (*StructuredCloneErrorOp)(JSContext* cx, uint32_t errorid);
+# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+typedef bool (*ReadTransferStructuredCloneOp)(JSContext* cx, JSStructuredCloneReader* r,
+                                              uint32_t tag, void* content, uint64_t extraData,
+                                              void* closure,
+                                              JS::MutableHandleObject returnObject);
+# 153 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+typedef bool (*TransferStructuredCloneOp)(JSContext* cx,
+                                          JS::Handle<JSObject*> obj,
+                                          void* closure,
+
+                                          uint32_t* tag,
+                                          JS::TransferableOwnership* ownership,
+                                          void** content,
+                                          uint64_t* extraData);
+
+
+
+
+
+
+typedef void (*FreeTransferStructuredCloneOp)(uint32_t tag, JS::TransferableOwnership ownership,
+                                              void* content, uint64_t extraData, void* closure);
+
+
+
+
+
+
+
+struct JSStructuredCloneCallbacks {
+    ReadStructuredCloneOp read;
+    WriteStructuredCloneOp write;
+    StructuredCloneErrorOp reportError;
+    ReadTransferStructuredCloneOp readTransfer;
+    TransferStructuredCloneOp writeTransfer;
+    FreeTransferStructuredCloneOp freeTransfer;
+};
+
+enum OwnTransferablePolicy {
+    OwnsTransferablesIfAny,
+    IgnoreTransferablesIfAny,
+    NoTransferables
+};
+
+class JSStructuredCloneData :
+    public mozilla::BufferList<js::SystemAllocPolicy>
+{
+    typedef js::SystemAllocPolicy AllocPolicy;
+    typedef mozilla::BufferList<js::SystemAllocPolicy> BufferList;
+
+    static const size_t kInitialSize = 0;
+    static const size_t kInitialCapacity = 4096;
+    static const size_t kStandardCapacity = 4096;
+
+    const JSStructuredCloneCallbacks* callbacks_;
+    void* closure_;
+    OwnTransferablePolicy ownTransferables_;
+
+    void setOptionalCallbacks(const JSStructuredCloneCallbacks* callbacks,
+                              void* closure,
+                              OwnTransferablePolicy policy) {
+        callbacks_ = callbacks;
+        closure_ = closure;
+        ownTransferables_ = policy;
+    }
+
+    friend struct JSStructuredCloneWriter;
+    friend class JSAutoStructuredCloneBuffer;
+
+public:
+    explicit JSStructuredCloneData(AllocPolicy aAP = AllocPolicy())
+        : BufferList(kInitialSize, kInitialCapacity, kStandardCapacity, aAP)
+        , callbacks_(nullptr)
+        , closure_(nullptr)
+        , ownTransferables_(OwnTransferablePolicy::NoTransferables)
+    {}
+                 JSStructuredCloneData(BufferList&& buffers)
+        : BufferList(Move(buffers))
+        , callbacks_(nullptr)
+        , closure_(nullptr)
+        , ownTransferables_(OwnTransferablePolicy::NoTransferables)
+    {}
+    JSStructuredCloneData(JSStructuredCloneData&& other) = default;
+    JSStructuredCloneData& operator=(JSStructuredCloneData&& other) = default;
+    ~JSStructuredCloneData();
+
+    using BufferList::BufferList;
+};
+
+
+bool
+JS_ReadStructuredClone(JSContext* cx, JSStructuredCloneData& data, uint32_t version,
+                       JS::StructuredCloneScope scope,
+                       JS::MutableHandleValue vp,
+                       const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
+
+bool
+JS_WriteStructuredClone(JSContext* cx, JS::HandleValue v, JSStructuredCloneData* data,
+                        JS::StructuredCloneScope scope,
+                        JS::CloneDataPolicy cloneDataPolicy,
+                        const JSStructuredCloneCallbacks* optionalCallbacks,
+                        void* closure, JS::HandleValue transferable);
+
+bool
+JS_StructuredCloneHasTransferables(JSStructuredCloneData& data, bool* hasTransferable);
+
+bool
+JS_StructuredClone(JSContext* cx, JS::HandleValue v, JS::MutableHandleValue vp,
+                   const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
+
+
+class JSAutoStructuredCloneBuffer {
+    const JS::StructuredCloneScope scope_;
+    JSStructuredCloneData data_;
+    uint32_t version_;
+
+  public:
+    JSAutoStructuredCloneBuffer(JS::StructuredCloneScope scope,
+                                const JSStructuredCloneCallbacks* callbacks, void* closure)
+        : scope_(scope), version_(8)
+    {
+        data_.setOptionalCallbacks(callbacks, closure, OwnTransferablePolicy::NoTransferables);
+    }
+
+    JSAutoStructuredCloneBuffer(JSAutoStructuredCloneBuffer&& other);
+    JSAutoStructuredCloneBuffer& operator=(JSAutoStructuredCloneBuffer&& other);
+
+    ~JSAutoStructuredCloneBuffer() { clear(); }
+
+    JSStructuredCloneData& data() { return data_; }
+    bool empty() const { return !data_.Size(); }
+
+    void clear(const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
+
+
+    bool copy(const JSStructuredCloneData& data, uint32_t version=8,
+              const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
+
+
+
+
+
+
+    void adopt(JSStructuredCloneData&& data, uint32_t version=8,
+               const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
+
+
+
+
+    void steal(JSStructuredCloneData* data, uint32_t* versionp=nullptr,
+               const JSStructuredCloneCallbacks** callbacks=nullptr, void** closure=nullptr);
+
+
+
+
+
+
+
+    void abandon() { data_.ownTransferables_ = OwnTransferablePolicy::IgnoreTransferablesIfAny; }
+
+    bool read(JSContext* cx, JS::MutableHandleValue vp,
+              const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
+
+    bool write(JSContext* cx, JS::HandleValue v,
+               const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
+
+    bool write(JSContext* cx, JS::HandleValue v, JS::HandleValue transferable,
+               JS::CloneDataPolicy cloneDataPolicy,
+               const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
+
+  private:
+
+    JSAutoStructuredCloneBuffer(const JSAutoStructuredCloneBuffer& other) = delete;
+    JSAutoStructuredCloneBuffer& operator=(const JSAutoStructuredCloneBuffer& other) = delete;
+};
+# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
+bool
+JS_ReadUint32Pair(JSStructuredCloneReader* r, uint32_t* p1, uint32_t* p2);
+
+bool
+JS_ReadBytes(JSStructuredCloneReader* r, void* p, size_t len);
+
+bool
+JS_ReadTypedArray(JSStructuredCloneReader* r, JS::MutableHandleValue vp);
+
+bool
+JS_WriteUint32Pair(JSStructuredCloneWriter* w, uint32_t tag, uint32_t data);
+
+bool
+JS_WriteBytes(JSStructuredCloneWriter* w, const void* p, size_t len);
+
+bool
+JS_WriteString(JSStructuredCloneWriter* w, JS::HandleString str);
+
+bool
+JS_WriteTypedArray(JSStructuredCloneWriter* w, JS::HandleValue v);
+
+bool
+JS_ObjectNotWritten(JSStructuredCloneWriter* w, JS::HandleObject obj);
+
+JS::StructuredCloneScope
+JS_GetStructuredCloneScope(JSStructuredCloneWriter* w);
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h" 2
+
+namespace js {
+    struct PerformanceGroup;
+}
+
+struct JSPrincipals {
+
+    mozilla::Atomic<int32_t> refcount;
+
+
+
+    uint32_t debugToken;
+
+
+    JSPrincipals() : refcount(0) {}
+
+    void setDebugToken(uint32_t token) {
+
+        debugToken = token;
+
+    }
+
+
+
+
+
+    virtual bool write(JSContext* cx, JSStructuredCloneWriter* writer) = 0;
+
+
+
+
+
+    void dump();
+};
+
+extern void
+JS_HoldPrincipals(JSPrincipals* principals);
+
+extern void
+JS_DropPrincipals(JSContext* cx, JSPrincipals* principals);
+
+
+
+
+typedef bool
+(* JSSubsumesOp)(JSPrincipals* first, JSPrincipals* second);
+
+
+
+
+
+typedef bool
+(* JSCSPEvalChecker)(JSContext* cx);
+
+struct JSSecurityCallbacks {
+    JSCSPEvalChecker contentSecurityPolicyAllows;
+    JSSubsumesOp subsumes;
+};
+
+extern void
+JS_SetSecurityCallbacks(JSContext* cx, const JSSecurityCallbacks* callbacks);
+
+extern const JSSecurityCallbacks*
+JS_GetSecurityCallbacks(JSContext* cx);
+# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
+extern void
+JS_SetTrustedPrincipals(JSContext* cx, JSPrincipals* prin);
+
+typedef void
+(* JSDestroyPrincipalsOp)(JSPrincipals* principals);
+
+
+
+
+
+
+extern void
+JS_InitDestroyPrincipalsCallback(JSContext* cx, JSDestroyPrincipalsOp destroyPrincipals);
+# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
+using JSReadPrincipalsOp = bool (*)(JSContext* cx, JSStructuredCloneReader* reader,
+                                    JSPrincipals** outPrincipals);
+
+
+
+
+
+extern void
+JS_InitReadPrincipalsCallback(JSContext* cx, JSReadPrincipalsOp read);
+# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Realm.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Realm.h"
+struct JSContext;
+class JSObject;
+
+namespace JS {
+
+extern JSObject*
+GetRealmObjectPrototype(JSContext* cx);
+
+extern JSObject*
+GetRealmFunctionPrototype(JSContext* cx);
+
+extern JSObject*
+GetRealmArrayPrototype(JSContext* cx);
+
+extern JSObject*
+GetRealmErrorPrototype(JSContext* cx);
+
+extern JSObject*
+GetRealmIteratorPrototype(JSContext* cx);
+
+}
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RefCounted.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RefCounted.h"
+namespace js {
+
+template <typename T>
+class RefCounted
+{
+    static const MozRefCountType DEAD = 0xffffdead;
+
+  protected:
+    RefCounted() : mRefCnt(0) {}
+    ~RefCounted() { do { } while (0); }
+
+  public:
+    void AddRef() const
+    {
+        do { } while (0);
+        ++mRefCnt;
+    }
+
+    void Release() const
+    {
+      do { } while (0);
+      MozRefCountType cnt = --mRefCnt;
+      if (0 == cnt) {
+
+
+
+          js_delete(const_cast<T*>(static_cast<const T*>(this)));
+      }
+    }
+
+  private:
+    mutable MozRefCountType mRefCnt;
+};
+
+template <typename T>
+class AtomicRefCounted
+{
+    static const MozRefCountType DEAD = 0xffffdead;
+
+  protected:
+    AtomicRefCounted() : mRefCnt(0) {}
+    ~AtomicRefCounted() { do { } while (0); }
+
+  public:
+    void AddRef() const
+    {
+        do { } while (0);
+        ++mRefCnt;
+    }
+
+    void Release() const
+    {
+        do { } while (0);
+        MozRefCountType cnt = --mRefCnt;
+        if (0 == cnt) {
+
+
+
+            js_delete(const_cast<T*>(static_cast<const T*>(this)));
+        }
+    }
+
+  private:
+    mutable mozilla::Atomic<MozRefCountType> mRefCnt;
+};
+
+}
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+namespace JS {
+
+class TwoByteChars;
+
+
+
+class AutoCheckRequestDepth
+{
+    JSContext* cx;
+  public:
+    explicit AutoCheckRequestDepth(JSContext* cx);
+    ~AutoCheckRequestDepth();
+};
+# 72 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+template <size_t N>
+class AutoValueArray : public AutoGCRooter
+{
+    const size_t length_;
+    Value elements_[N];
+
+  public:
+    explicit AutoValueArray(JSContext* cx
+                                                           )
+      : AutoGCRooter(cx, VALARRAY), length_(N)
+    {
+
+        mozilla::PodArrayZero(elements_);
+        do { } while (0);
+    }
+
+    unsigned length() const { return length_; }
+    const Value* begin() const { return elements_; }
+    Value* begin() { return elements_; }
+
+    HandleValue operator[](unsigned i) const {
+        do { } while (0);
+        return HandleValue::fromMarkedLocation(&elements_[i]);
+    }
+    MutableHandleValue operator[](unsigned i) {
+        do { } while (0);
+        return MutableHandleValue::fromMarkedLocation(&elements_[i]);
+    }
+
+
+};
+
+template<class T>
+class AutoVectorRooterBase : protected AutoGCRooter
+{
+    typedef js::Vector<T, 8> VectorImpl;
+    VectorImpl vector;
+
+  public:
+    explicit AutoVectorRooterBase(JSContext* cx, ptrdiff_t tag
+                                                             )
+      : AutoGCRooter(cx, tag), vector(cx)
+    {
+        do { } while (0);
+    }
+
+    typedef T ElementType;
+    typedef typename VectorImpl::Range Range;
+
+    size_t length() const { return vector.length(); }
+    bool empty() const { return vector.empty(); }
+
+    __attribute__ ((warn_unused_result)) bool append(const T& v) { return vector.append(v); }
+    __attribute__ ((warn_unused_result)) bool appendN(const T& v, size_t len) { return vector.appendN(v, len); }
+    __attribute__ ((warn_unused_result)) bool append(const T* ptr, size_t len) { return vector.append(ptr, len); }
+    __attribute__ ((warn_unused_result)) bool appendAll(const AutoVectorRooterBase<T>& other) {
+        return vector.appendAll(other.vector);
+    }
+
+    __attribute__ ((warn_unused_result)) bool insert(T* p, const T& val) { return vector.insert(p, val); }
+
+
+    void infallibleAppend(const T& v) { vector.infallibleAppend(v); }
+
+    void popBack() { vector.popBack(); }
+    T popCopy() { return vector.popCopy(); }
+
+    __attribute__ ((warn_unused_result)) bool growBy(size_t inc) {
+        size_t oldLength = vector.length();
+        if (!vector.growByUninitialized(inc))
+            return false;
+        makeRangeGCSafe(oldLength);
+        return true;
+    }
+
+    __attribute__ ((warn_unused_result)) bool resize(size_t newLength) {
+        size_t oldLength = vector.length();
+        if (newLength <= oldLength) {
+            vector.shrinkBy(oldLength - newLength);
+            return true;
+        }
+        if (!vector.growByUninitialized(newLength - oldLength))
+            return false;
+        makeRangeGCSafe(oldLength);
+        return true;
+    }
+
+    void clear() { vector.clear(); }
+
+    __attribute__ ((warn_unused_result)) bool reserve(size_t newLength) {
+        return vector.reserve(newLength);
+    }
+
+    JS::MutableHandle<T> operator[](size_t i) {
+        return JS::MutableHandle<T>::fromMarkedLocation(&vector[i]);
+    }
+    JS::Handle<T> operator[](size_t i) const {
+        return JS::Handle<T>::fromMarkedLocation(&vector[i]);
+    }
+
+    const T* begin() const { return vector.begin(); }
+    T* begin() { return vector.begin(); }
+
+    const T* end() const { return vector.end(); }
+    T* end() { return vector.end(); }
+
+    Range all() { return vector.all(); }
+
+    const T& back() const { return vector.back(); }
+
+    friend void AutoGCRooter::trace(JSTracer* trc);
+
+  private:
+    void makeRangeGCSafe(size_t oldLength) {
+        T* t = vector.begin() + oldLength;
+        for (size_t i = oldLength; i < vector.length(); ++i, ++t)
+            memset(t, 0, sizeof(T));
+    }
+
+
+};
+
+template <typename T>
+class AutoVectorRooter : public AutoVectorRooterBase<T>
+{
+  public:
+    explicit AutoVectorRooter(JSContext* cx
+                                                            )
+        : AutoVectorRooterBase<T>(cx, this->GetTag(T()))
+    {
+        do { } while (0);
+    }
+
+
+};
+
+class AutoValueVector : public Rooted<GCVector<Value, 8>> {
+    using Vec = GCVector<Value, 8>;
+    using Base = Rooted<Vec>;
+  public:
+    explicit AutoValueVector(JSContext* cx) : Base(cx, Vec(cx)) {}
+};
+
+class AutoIdVector : public Rooted<GCVector<jsid, 8>> {
+    using Vec = GCVector<jsid, 8>;
+    using Base = Rooted<Vec>;
+  public:
+    explicit AutoIdVector(JSContext* cx) : Base(cx, Vec(cx)) {}
+
+    bool appendAll(const AutoIdVector& other) { return this->Base::appendAll(other.get()); }
+};
+
+class AutoObjectVector : public Rooted<GCVector<JSObject*, 8>> {
+    using Vec = GCVector<JSObject*, 8>;
+    using Base = Rooted<Vec>;
+  public:
+    explicit AutoObjectVector(JSContext* cx) : Base(cx, Vec(cx)) {}
+};
+
+using ValueVector = JS::GCVector<JS::Value>;
+using IdVector = JS::GCVector<jsid>;
+using ScriptVector = JS::GCVector<JSScript*>;
+using StringVector = JS::GCVector<JSString*>;
+
+template<class Key, class Value>
+class AutoHashMapRooter : protected AutoGCRooter
+{
+  private:
+    typedef js::HashMap<Key, Value> HashMapImpl;
+
+  public:
+    explicit AutoHashMapRooter(JSContext* cx, ptrdiff_t tag
+                                                              )
+      : AutoGCRooter(cx, tag), map(cx)
+    {
+        do { } while (0);
+    }
+
+    typedef Key KeyType;
+    typedef Value ValueType;
+    typedef typename HashMapImpl::Entry Entry;
+    typedef typename HashMapImpl::Lookup Lookup;
+    typedef typename HashMapImpl::Ptr Ptr;
+    typedef typename HashMapImpl::AddPtr AddPtr;
+
+    bool init(uint32_t len = 16) {
+        return map.init(len);
+    }
+    bool initialized() const {
+        return map.initialized();
+    }
+    Ptr lookup(const Lookup& l) const {
+        return map.lookup(l);
+    }
+    void remove(Ptr p) {
+        map.remove(p);
+    }
+    AddPtr lookupForAdd(const Lookup& l) const {
+        return map.lookupForAdd(l);
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    bool add(AddPtr& p, const KeyInput& k, const ValueInput& v) {
+        return map.add(p, k, v);
+    }
+
+    bool add(AddPtr& p, const Key& k) {
+        return map.add(p, k);
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    bool relookupOrAdd(AddPtr& p, const KeyInput& k, const ValueInput& v) {
+        return map.relookupOrAdd(p, k, v);
+    }
+
+    typedef typename HashMapImpl::Range Range;
+    Range all() const {
+        return map.all();
+    }
+
+    typedef typename HashMapImpl::Enum Enum;
+
+    void clear() {
+        map.clear();
+    }
+
+    void finish() {
+        map.finish();
+    }
+
+    bool empty() const {
+        return map.empty();
+    }
+
+    uint32_t count() const {
+        return map.count();
+    }
+
+    size_t capacity() const {
+        return map.capacity();
+    }
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return map.sizeOfExcludingThis(mallocSizeOf);
+    }
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return map.sizeOfIncludingThis(mallocSizeOf);
+    }
+
+
+
+    bool has(const Lookup& l) const {
+        return map.has(l);
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    bool put(const KeyInput& k, const ValueInput& v) {
+        return map.put(k, v);
+    }
+
+    template<typename KeyInput, typename ValueInput>
+    bool putNew(const KeyInput& k, const ValueInput& v) {
+        return map.putNew(k, v);
+    }
+
+    Ptr lookupWithDefault(const Key& k, const Value& defaultValue) {
+        return map.lookupWithDefault(k, defaultValue);
+    }
+
+    void remove(const Lookup& l) {
+        map.remove(l);
+    }
+
+    friend void AutoGCRooter::trace(JSTracer* trc);
+
+  private:
+    AutoHashMapRooter(const AutoHashMapRooter& hmr) = delete;
+    AutoHashMapRooter& operator=(const AutoHashMapRooter& hmr) = delete;
+
+    HashMapImpl map;
+
+
+};
+
+template<class T>
+class AutoHashSetRooter : protected AutoGCRooter
+{
+  private:
+    typedef js::HashSet<T> HashSetImpl;
+
+  public:
+    explicit AutoHashSetRooter(JSContext* cx, ptrdiff_t tag
+                                                              )
+      : AutoGCRooter(cx, tag), set(cx)
+    {
+        do { } while (0);
+    }
+
+    typedef typename HashSetImpl::Lookup Lookup;
+    typedef typename HashSetImpl::Ptr Ptr;
+    typedef typename HashSetImpl::AddPtr AddPtr;
+
+    bool init(uint32_t len = 16) {
+        return set.init(len);
+    }
+    bool initialized() const {
+        return set.initialized();
+    }
+    Ptr lookup(const Lookup& l) const {
+        return set.lookup(l);
+    }
+    void remove(Ptr p) {
+        set.remove(p);
+    }
+    AddPtr lookupForAdd(const Lookup& l) const {
+        return set.lookupForAdd(l);
+    }
+
+    bool add(AddPtr& p, const T& t) {
+        return set.add(p, t);
+    }
+
+    bool relookupOrAdd(AddPtr& p, const Lookup& l, const T& t) {
+        return set.relookupOrAdd(p, l, t);
+    }
+
+    typedef typename HashSetImpl::Range Range;
+    Range all() const {
+        return set.all();
+    }
+
+    typedef typename HashSetImpl::Enum Enum;
+
+    void clear() {
+        set.clear();
+    }
+
+    void finish() {
+        set.finish();
+    }
+
+    bool empty() const {
+        return set.empty();
+    }
+
+    uint32_t count() const {
+        return set.count();
+    }
+
+    size_t capacity() const {
+        return set.capacity();
+    }
+
+    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return set.sizeOfExcludingThis(mallocSizeOf);
+    }
+    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+        return set.sizeOfIncludingThis(mallocSizeOf);
+    }
+
+
+
+    bool has(const Lookup& l) const {
+        return set.has(l);
+    }
+
+    bool put(const T& t) {
+        return set.put(t);
+    }
+
+    bool putNew(const T& t) {
+        return set.putNew(t);
+    }
+
+    void remove(const Lookup& l) {
+        set.remove(l);
+    }
+
+    friend void AutoGCRooter::trace(JSTracer* trc);
+
+  private:
+    AutoHashSetRooter(const AutoHashSetRooter& hmr) = delete;
+    AutoHashSetRooter& operator=(const AutoHashSetRooter& hmr) = delete;
+
+    HashSetImpl set;
+
+
+};
+
+
+
+
+class CustomAutoRooter : private AutoGCRooter
+{
+  public:
+    template <typename CX>
+    explicit CustomAutoRooter(const CX& cx )
+      : AutoGCRooter(cx, CUSTOM)
+    {
+        do { } while (0);
+    }
+
+    friend void AutoGCRooter::trace(JSTracer* trc);
+
+  protected:
+    virtual ~CustomAutoRooter() {}
+
+
+    virtual void trace(JSTracer* trc) = 0;
+
+  private:
+
+};
+
+
+class HandleValueArray
+{
+    const size_t length_;
+    const Value * const elements_;
+
+    HandleValueArray(size_t len, const Value* elements) : length_(len), elements_(elements) {}
+
+  public:
+    explicit HandleValueArray(const RootedValue& value) : length_(1), elements_(value.address()) {}
+
+                 HandleValueArray(const AutoValueVector& values)
+      : length_(values.length()), elements_(values.begin()) {}
+
+    template <size_t N>
+                 HandleValueArray(const AutoValueArray<N>& values) : length_(N), elements_(values.begin()) {}
+
+
+                 HandleValueArray(const JS::CallArgs& args) : length_(args.length()), elements_(args.array()) {}
+
+
+    static HandleValueArray fromMarkedLocation(size_t len, const Value* elements) {
+        return HandleValueArray(len, elements);
+    }
+
+    static HandleValueArray subarray(const HandleValueArray& values, size_t startIndex, size_t len) {
+        do { } while (0);
+        return HandleValueArray(len, values.begin() + startIndex);
+    }
+
+    static HandleValueArray empty() {
+        return HandleValueArray(0, nullptr);
+    }
+
+    size_t length() const { return length_; }
+    const Value* begin() const { return elements_; }
+
+    HandleValue operator[](size_t i) const {
+        do { } while (0);
+        return HandleValue::fromMarkedLocation(&elements_[i]);
+    }
+};
+
+}
+
+
+
+struct JSFreeOp {
+  protected:
+    JSRuntime* runtime_;
+
+    explicit JSFreeOp(JSRuntime* rt)
+      : runtime_(rt) { }
+
+  public:
+    JSRuntime* runtime() const {
+        do { } while (0);
+        return runtime_;
+    }
+};
+
+
+
+
+
+typedef enum JSGCStatus {
+    JSGC_BEGIN,
+    JSGC_END
+} JSGCStatus;
+
+typedef void
+(* JSGCCallback)(JSContext* cx, JSGCStatus status, void* data);
+
+typedef void
+(* JSObjectsTenuredCallback)(JSContext* cx, void* data);
+
+typedef enum JSFinalizeStatus {
+
+
+
+
+
+    JSFINALIZE_GROUP_START,
+
+
+
+
+
+
+
+    JSFINALIZE_GROUP_END,
+
+
+
+
+    JSFINALIZE_COLLECTION_END
+} JSFinalizeStatus;
+
+typedef void
+(* JSFinalizeCallback)(JSFreeOp* fop, JSFinalizeStatus status, bool isZoneGC, void* data);
+
+typedef void
+(* JSWeakPointerZonesCallback)(JSContext* cx, void* data);
+
+typedef void
+(* JSWeakPointerCompartmentCallback)(JSContext* cx, JSCompartment* comp, void* data);
+
+typedef bool
+(* JSInterruptCallback)(JSContext* cx);
+
+typedef JSObject*
+(* JSGetIncumbentGlobalCallback)(JSContext* cx);
+
+typedef bool
+(* JSEnqueuePromiseJobCallback)(JSContext* cx, JS::HandleObject job,
+                                JS::HandleObject allocationSite, JS::HandleObject incumbentGlobal,
+                                void* data);
+
+enum class PromiseRejectionHandlingState {
+    Unhandled,
+    Handled
+};
+
+typedef void
+(* JSPromiseRejectionTrackerCallback)(JSContext* cx, JS::HandleObject promise,
+                                      PromiseRejectionHandlingState state, void* data);
+
+typedef void
+(* JSProcessPromiseCallback)(JSContext* cx, JS::HandleObject promise);
+# 624 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef enum JSExnType {
+    JSEXN_ERR,
+    JSEXN_FIRST = JSEXN_ERR,
+        JSEXN_INTERNALERR,
+        JSEXN_EVALERR,
+        JSEXN_RANGEERR,
+        JSEXN_REFERENCEERR,
+        JSEXN_SYNTAXERR,
+        JSEXN_TYPEERR,
+        JSEXN_URIERR,
+        JSEXN_DEBUGGEEWOULDRUN,
+        JSEXN_WASMCOMPILEERROR,
+        JSEXN_WASMLINKERROR,
+        JSEXN_WASMRUNTIMEERROR,
+    JSEXN_ERROR_LIMIT,
+    JSEXN_WARN = JSEXN_ERROR_LIMIT,
+    JSEXN_NOTE,
+    JSEXN_LIMIT
+} JSExnType;
+
+typedef struct JSErrorFormatString {
+
+    const char* name;
+
+
+    const char* format;
+
+
+    uint16_t argCount;
+
+
+    int16_t exnType;
+} JSErrorFormatString;
+
+typedef const JSErrorFormatString*
+(* JSErrorCallback)(void* userRef, const unsigned errorNumber);
+
+typedef bool
+(* JSLocaleToUpperCase)(JSContext* cx, JS::HandleString src, JS::MutableHandleValue rval);
+
+typedef bool
+(* JSLocaleToLowerCase)(JSContext* cx, JS::HandleString src, JS::MutableHandleValue rval);
+
+typedef bool
+(* JSLocaleCompare)(JSContext* cx, JS::HandleString src1, JS::HandleString src2,
+                    JS::MutableHandleValue rval);
+
+typedef bool
+(* JSLocaleToUnicode)(JSContext* cx, const char* src, JS::MutableHandleValue rval);
+# 683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef JSObject*
+(* JSWrapObjectCallback)(JSContext* cx, JS::HandleObject existing, JS::HandleObject obj);
+
+
+
+
+
+
+typedef void
+(* JSPreWrapCallback)(JSContext* cx, JS::HandleObject scope, JS::HandleObject obj,
+                      JS::HandleObject objectPassedToWrap,
+                      JS::MutableHandleObject retObj);
+
+struct JSWrapObjectCallbacks
+{
+    JSWrapObjectCallback wrap;
+    JSPreWrapCallback preWrap;
+};
+
+typedef void
+(* JSDestroyCompartmentCallback)(JSFreeOp* fop, JSCompartment* compartment);
+
+typedef size_t
+(* JSSizeOfIncludingThisCompartmentCallback)(mozilla::MallocSizeOf mallocSizeOf,
+                                             JSCompartment* compartment);
+
+typedef void
+(* JSZoneCallback)(JS::Zone* zone);
+
+typedef void
+(* JSCompartmentNameCallback)(JSContext* cx, JSCompartment* compartment,
+                              char* buf, size_t bufsize);
+# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+using JSExternalStringSizeofCallback =
+    size_t (*)(JSString* str, mozilla::MallocSizeOf mallocSizeOf);
+
+
+
+static __attribute__((always_inline)) inline JS::Value
+JS_NumberValue(double d)
+{
+    int32_t i;
+    d = JS::CanonicalizeNaN(d);
+    if (mozilla::NumberIsInt32(d, &i))
+        return JS::Int32Value(i);
+    return JS::DoubleValue(d);
+}
+
+
+
+bool
+JS_StringHasBeenPinned(JSContext* cx, JSString* str);
+
+namespace JS {
+# 767 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class SourceBufferHolder final
+{
+  public:
+    enum Ownership {
+      NoOwnership,
+      GiveOwnership
+    };
+
+    SourceBufferHolder(const char16_t* data, size_t dataLength, Ownership ownership)
+      : data_(data),
+        length_(dataLength),
+        ownsChars_(ownership == GiveOwnership)
+    {
+
+
+        static const char16_t NullChar_ = 0;
+        if (!get()) {
+            data_ = &NullChar_;
+            length_ = 0;
+            ownsChars_ = false;
+        }
+    }
+
+    SourceBufferHolder(SourceBufferHolder&& other)
+      : data_(other.data_),
+        length_(other.length_),
+        ownsChars_(other.ownsChars_)
+    {
+        other.data_ = nullptr;
+        other.length_ = 0;
+        other.ownsChars_ = false;
+    }
+
+    ~SourceBufferHolder() {
+        if (ownsChars_)
+            js_free(const_cast<char16_t*>(data_));
+    }
+
+
+    const char16_t* get() const { return data_; }
+
+
+    size_t length() const { return length_; }
+
+
+
+    bool ownsChars() const { return ownsChars_; }
+# 827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    char16_t* take() {
+        do { } while (0);
+        ownsChars_ = false;
+        return const_cast<char16_t*>(data_);
+    }
+
+  private:
+    SourceBufferHolder(SourceBufferHolder&) = delete;
+    SourceBufferHolder& operator=(SourceBufferHolder&) = delete;
+
+    const char16_t* data_;
+    size_t length_;
+    bool ownsChars_;
+};
+
+}
+# 912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern int64_t
+JS_Now(void);
+
+
+extern JS::Value
+JS_GetNaNValue(JSContext* cx);
+
+extern JS::Value
+JS_GetNegativeInfinityValue(JSContext* cx);
+
+extern JS::Value
+JS_GetPositiveInfinityValue(JSContext* cx);
+
+extern JS::Value
+JS_GetEmptyStringValue(JSContext* cx);
+
+extern JSString*
+JS_GetEmptyString(JSContext* cx);
+
+extern bool
+JS_ValueToObject(JSContext* cx, JS::HandleValue v, JS::MutableHandleObject objp);
+
+extern JSFunction*
+JS_ValueToFunction(JSContext* cx, JS::HandleValue v);
+
+extern JSFunction*
+JS_ValueToConstructor(JSContext* cx, JS::HandleValue v);
+
+extern JSString*
+JS_ValueToSource(JSContext* cx, JS::Handle<JS::Value> v);
+
+extern bool
+JS_DoubleIsInt32(double d, int32_t* ip);
+
+extern JSType
+JS_TypeOfValue(JSContext* cx, JS::Handle<JS::Value> v);
+
+namespace JS {
+
+extern const char*
+InformalValueTypeName(const JS::Value& v);
+
+}
+
+extern bool
+JS_StrictlyEqual(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* equal);
+
+extern bool
+JS_LooselyEqual(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* equal);
+
+extern bool
+JS_SameValue(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* same);
+
+
+extern bool
+JS_IsBuiltinEvalFunction(JSFunction* fun);
+
+
+extern bool
+JS_IsBuiltinFunctionConstructor(JSFunction* fun);
+# 986 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSContext*
+JS_NewContext(uint32_t maxbytes,
+              uint32_t maxNurseryBytes = JS::DefaultNurseryBytes,
+              JSRuntime* parentRuntime = nullptr);
+
+
+
+
+
+
+
+extern void
+JS_YieldCooperativeContext(JSContext* cx);
+
+
+
+extern void
+JS_ResumeCooperativeContext(JSContext* cx);
+
+
+
+
+
+extern JSContext*
+JS_NewCooperativeContext(JSContext* siblingContext);
+
+
+
+
+extern void
+JS_DestroyContext(JSContext* cx);
+
+void*
+JS_GetContextPrivate(JSContext* cx);
+
+void
+JS_SetContextPrivate(JSContext* cx, void* data);
+
+extern JSRuntime*
+JS_GetParentRuntime(JSContext* cx);
+
+extern void
+JS_BeginRequest(JSContext* cx);
+
+extern void
+JS_EndRequest(JSContext* cx);
+
+extern void
+JS_SetFutexCanWait(JSContext* cx);
+
+namespace JS {
+# 1051 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef void (*BeginSingleThreadedExecutionCallback)(JSContext* cx);
+typedef void (*EndSingleThreadedExecutionCallback)(JSContext* cx);
+
+extern void
+SetSingleThreadedExecutionCallbacks(JSContext* cx,
+                                    BeginSingleThreadedExecutionCallback begin,
+                                    EndSingleThreadedExecutionCallback end);
+
+}
+
+namespace js {
+
+void
+AssertHeapIsIdle();
+
+}
+
+class JSAutoRequest
+{
+  public:
+    explicit JSAutoRequest(JSContext* cx
+                                                          )
+      : mContext(cx)
+    {
+        do { } while (0);
+        JS_BeginRequest(mContext);
+    }
+    ~JSAutoRequest() {
+        JS_EndRequest(mContext);
+    }
+
+  protected:
+    JSContext* mContext;
+
+
+
+
+
+
+
+};
+
+extern JSVersion
+JS_GetVersion(JSContext* cx);
+# 1104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+void
+JS_SetVersionForCompartment(JSCompartment* compartment, JSVersion version);
+
+extern const char*
+JS_VersionToString(JSVersion version);
+
+extern JSVersion
+JS_StringToVersion(const char* string);
+
+namespace JS {
+
+class ContextOptions {
+  public:
+    ContextOptions()
+      : baseline_(true),
+        ion_(true),
+        asmJS_(true),
+        wasm_(false),
+        wasmAlwaysBaseline_(false),
+        throwOnAsmJSValidationFailure_(false),
+        nativeRegExp_(true),
+        unboxedArrays_(false),
+        asyncStack_(true),
+        throwOnDebuggeeWouldRun_(true),
+        dumpStackOnDebuggeeWouldRun_(false),
+        werror_(false),
+        strictMode_(false),
+        extraWarnings_(false),
+
+        forEachStatement_(false)
+
+
+
+    {
+    }
+
+    bool baseline() const { return baseline_; }
+    ContextOptions& setBaseline(bool flag) {
+        baseline_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleBaseline() {
+        baseline_ = !baseline_;
+        return *this;
+    }
+
+    bool ion() const { return ion_; }
+    ContextOptions& setIon(bool flag) {
+        ion_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleIon() {
+        ion_ = !ion_;
+        return *this;
+    }
+
+    bool asmJS() const { return asmJS_; }
+    ContextOptions& setAsmJS(bool flag) {
+        asmJS_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleAsmJS() {
+        asmJS_ = !asmJS_;
+        return *this;
+    }
+
+    bool wasm() const { return wasm_; }
+    ContextOptions& setWasm(bool flag) {
+        wasm_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleWasm() {
+        wasm_ = !wasm_;
+        return *this;
+    }
+
+    bool wasmAlwaysBaseline() const { return wasmAlwaysBaseline_; }
+    ContextOptions& setWasmAlwaysBaseline(bool flag) {
+        wasmAlwaysBaseline_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleWasmAlwaysBaseline() {
+        wasmAlwaysBaseline_ = !wasmAlwaysBaseline_;
+        return *this;
+    }
+
+    bool throwOnAsmJSValidationFailure() const { return throwOnAsmJSValidationFailure_; }
+    ContextOptions& setThrowOnAsmJSValidationFailure(bool flag) {
+        throwOnAsmJSValidationFailure_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleThrowOnAsmJSValidationFailure() {
+        throwOnAsmJSValidationFailure_ = !throwOnAsmJSValidationFailure_;
+        return *this;
+    }
+
+    bool nativeRegExp() const { return nativeRegExp_; }
+    ContextOptions& setNativeRegExp(bool flag) {
+        nativeRegExp_ = flag;
+        return *this;
+    }
+
+    bool unboxedArrays() const { return unboxedArrays_; }
+    ContextOptions& setUnboxedArrays(bool flag) {
+        unboxedArrays_ = flag;
+        return *this;
+    }
+
+    bool asyncStack() const { return asyncStack_; }
+    ContextOptions& setAsyncStack(bool flag) {
+        asyncStack_ = flag;
+        return *this;
+    }
+
+    bool throwOnDebuggeeWouldRun() const { return throwOnDebuggeeWouldRun_; }
+    ContextOptions& setThrowOnDebuggeeWouldRun(bool flag) {
+        throwOnDebuggeeWouldRun_ = flag;
+        return *this;
+    }
+
+    bool dumpStackOnDebuggeeWouldRun() const { return dumpStackOnDebuggeeWouldRun_; }
+    ContextOptions& setDumpStackOnDebuggeeWouldRun(bool flag) {
+        dumpStackOnDebuggeeWouldRun_ = flag;
+        return *this;
+    }
+
+    bool werror() const { return werror_; }
+    ContextOptions& setWerror(bool flag) {
+        werror_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleWerror() {
+        werror_ = !werror_;
+        return *this;
+    }
+
+    bool strictMode() const { return strictMode_; }
+    ContextOptions& setStrictMode(bool flag) {
+        strictMode_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleStrictMode() {
+        strictMode_ = !strictMode_;
+        return *this;
+    }
+
+    bool extraWarnings() const { return extraWarnings_; }
+    ContextOptions& setExtraWarnings(bool flag) {
+        extraWarnings_ = flag;
+        return *this;
+    }
+    ContextOptions& toggleExtraWarnings() {
+        extraWarnings_ = !extraWarnings_;
+        return *this;
+    }
+
+    bool forEachStatement() const { return forEachStatement_; }
+    ContextOptions& setForEachStatement(bool flag) {
+        forEachStatement_ = flag;
+        return *this;
+    }
+# 1274 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+  private:
+    bool baseline_ : 1;
+    bool ion_ : 1;
+    bool asmJS_ : 1;
+    bool wasm_ : 1;
+    bool wasmAlwaysBaseline_ : 1;
+    bool throwOnAsmJSValidationFailure_ : 1;
+    bool nativeRegExp_ : 1;
+    bool unboxedArrays_ : 1;
+    bool asyncStack_ : 1;
+    bool throwOnDebuggeeWouldRun_ : 1;
+    bool dumpStackOnDebuggeeWouldRun_ : 1;
+    bool werror_ : 1;
+    bool strictMode_ : 1;
+    bool extraWarnings_ : 1;
+    bool forEachStatement_: 1;
+
+
+
+
+};
+
+ContextOptions&
+ContextOptionsRef(JSContext* cx);
+
+
+
+
+
+
+bool
+InitSelfHostedCode(JSContext* cx);
+
+
+
+
+
+void
+AssertObjectBelongsToCurrentThread(JSObject* obj);
+
+}
+
+extern const char*
+JS_GetImplementationVersion(void);
+
+extern void
+JS_SetDestroyCompartmentCallback(JSContext* cx, JSDestroyCompartmentCallback callback);
+
+extern void
+JS_SetSizeOfIncludingThisCompartmentCallback(JSContext* cx,
+                                             JSSizeOfIncludingThisCompartmentCallback callback);
+
+extern void
+JS_SetDestroyZoneCallback(JSContext* cx, JSZoneCallback callback);
+
+extern void
+JS_SetSweepZoneCallback(JSContext* cx, JSZoneCallback callback);
+
+extern void
+JS_SetCompartmentNameCallback(JSContext* cx, JSCompartmentNameCallback callback);
+
+extern void
+JS_SetWrapObjectCallbacks(JSContext* cx, const JSWrapObjectCallbacks* callbacks);
+
+extern void
+JS_SetExternalStringSizeofCallback(JSContext* cx, JSExternalStringSizeofCallback callback);
+
+extern void
+JS_SetCompartmentPrivate(JSCompartment* compartment, void* data);
+
+extern void*
+JS_GetCompartmentPrivate(JSCompartment* compartment);
+
+extern void
+JS_SetZoneUserData(JS::Zone* zone, void* data);
+
+extern void*
+JS_GetZoneUserData(JS::Zone* zone);
+
+extern bool
+JS_WrapObject(JSContext* cx, JS::MutableHandleObject objp);
+
+extern bool
+JS_WrapValue(JSContext* cx, JS::MutableHandleValue vp);
+
+extern JSObject*
+JS_TransplantObject(JSContext* cx, JS::HandleObject origobj, JS::HandleObject target);
+
+extern bool
+JS_RefreshCrossCompartmentWrappers(JSContext* cx, JS::Handle<JSObject*> obj);
+# 1400 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class JSAutoCompartment
+{
+    JSContext* cx_;
+    JSCompartment* oldCompartment_;
+  public:
+    JSAutoCompartment(JSContext* cx, JSObject* target
+                                                     );
+    JSAutoCompartment(JSContext* cx, JSScript* target
+                                                     );
+    ~JSAutoCompartment();
+
+
+};
+
+class JSAutoNullableCompartment
+{
+    JSContext* cx_;
+    JSCompartment* oldCompartment_;
+  public:
+    explicit JSAutoNullableCompartment(JSContext* cx, JSObject* targetOrNull
+                                                                      );
+    ~JSAutoNullableCompartment();
+
+
+};
+
+
+extern JSCompartment*
+JS_EnterCompartment(JSContext* cx, JSObject* target);
+
+extern void
+JS_LeaveCompartment(JSContext* cx, JSCompartment* oldCompartment);
+
+typedef void (*JSIterateCompartmentCallback)(JSContext* cx, void* data, JSCompartment* compartment);
+
+
+
+
+
+
+extern void
+JS_IterateCompartments(JSContext* cx, void* data,
+                       JSIterateCompartmentCallback compartmentCallback);
+
+
+
+
+
+
+
+extern void
+JS_MarkCrossZoneId(JSContext* cx, jsid id);
+
+
+
+
+
+extern void
+JS_MarkCrossZoneIdValue(JSContext* cx, const JS::Value& value);
+# 1467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_InitStandardClasses(JSContext* cx, JS::Handle<JSObject*> obj);
+# 1483 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ResolveStandardClass(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* resolved);
+
+extern bool
+JS_MayResolveStandardClass(const JSAtomState& names, jsid id, JSObject* maybeObj);
+
+extern bool
+JS_EnumerateStandardClasses(JSContext* cx, JS::HandleObject obj);
+
+extern bool
+JS_GetClassObject(JSContext* cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);
+
+extern bool
+JS_GetClassPrototype(JSContext* cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);
+
+namespace JS {
+
+
+
+
+
+
+extern JSProtoKey
+IdentifyStandardInstance(JSObject* obj);
+
+extern JSProtoKey
+IdentifyStandardPrototype(JSObject* obj);
+
+extern JSProtoKey
+IdentifyStandardInstanceOrPrototype(JSObject* obj);
+
+extern JSProtoKey
+IdentifyStandardConstructor(JSObject* obj);
+
+extern void
+ProtoKeyToId(JSContext* cx, JSProtoKey key, JS::MutableHandleId idp);
+
+}
+
+extern JSProtoKey
+JS_IdToProtoKey(JSContext* cx, JS::HandleId id);
+
+
+
+
+
+extern JSObject*
+JS_GetFunctionPrototype(JSContext* cx, JS::HandleObject forObj);
+
+
+
+
+
+extern JSObject*
+JS_GetObjectPrototype(JSContext* cx, JS::HandleObject forObj);
+
+
+
+
+
+extern JSObject*
+JS_GetArrayPrototype(JSContext* cx, JS::HandleObject forObj);
+
+
+
+
+
+extern JSObject*
+JS_GetErrorPrototype(JSContext* cx);
+
+
+
+
+
+extern JSObject*
+JS_GetIteratorPrototype(JSContext* cx);
+
+extern JSObject*
+JS_GetGlobalForObject(JSContext* cx, JSObject* obj);
+
+extern bool
+JS_IsGlobalObject(JSObject* obj);
+
+extern JSObject*
+JS_GlobalLexicalEnvironment(JSObject* obj);
+
+extern bool
+JS_HasExtensibleLexicalEnvironment(JSObject* obj);
+
+extern JSObject*
+JS_ExtensibleLexicalEnvironment(JSObject* obj);
+
+
+
+
+
+extern JSObject*
+JS_GetGlobalForCompartmentOrNull(JSContext* cx, JSCompartment* c);
+
+namespace JS {
+
+extern JSObject*
+CurrentGlobalOrNull(JSContext* cx);
+
+}
+
+
+
+
+
+extern bool
+JS_InitReflectParse(JSContext* cx, JS::HandleObject global);
+
+
+
+
+
+extern bool
+JS_DefineProfilingFunctions(JSContext* cx, JS::HandleObject obj);
+
+
+extern bool
+JS_DefineDebuggerObject(JSContext* cx, JS::HandleObject obj);
+
+
+
+
+
+
+extern bool
+JS_InitCTypesClass(JSContext* cx, JS::HandleObject global);
+
+
+
+
+
+
+typedef char*
+(* JSCTypesUnicodeToNativeFun)(JSContext* cx, const char16_t* source, size_t slen);
+
+
+
+
+
+
+struct JSCTypesCallbacks {
+    JSCTypesUnicodeToNativeFun unicodeToNative;
+};
+
+typedef struct JSCTypesCallbacks JSCTypesCallbacks;
+
+
+
+
+
+
+
+extern void
+JS_SetCTypesCallbacks(JSObject* ctypesObj, const JSCTypesCallbacks* callbacks);
+
+
+extern void*
+JS_malloc(JSContext* cx, size_t nbytes);
+
+extern void*
+JS_realloc(JSContext* cx, void* p, size_t oldBytes, size_t newBytes);
+
+
+
+
+
+
+extern void
+JS_free(JSContext* cx, void* p);
+
+
+
+
+
+extern void
+JS_freeop(JSFreeOp* fop, void* p);
+
+extern void
+JS_updateMallocCounter(JSContext* cx, size_t nbytes);
+
+extern char*
+JS_strdup(JSContext* cx, const char* s);
+# 1678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_AddExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
+
+
+extern void
+JS_RemoveExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
+
+
+
+
+extern void
+JS_GC(JSContext* cx);
+
+extern void
+JS_MaybeGC(JSContext* cx);
+
+extern void
+JS_SetGCCallback(JSContext* cx, JSGCCallback cb, void* data);
+
+extern void
+JS_SetObjectsTenuredCallback(JSContext* cx, JSObjectsTenuredCallback cb,
+                             void* data);
+
+extern bool
+JS_AddFinalizeCallback(JSContext* cx, JSFinalizeCallback cb, void* data);
+
+extern void
+JS_RemoveFinalizeCallback(JSContext* cx, JSFinalizeCallback cb);
+# 1741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_AddWeakPointerZonesCallback(JSContext* cx, JSWeakPointerZonesCallback cb, void* data);
+
+extern void
+JS_RemoveWeakPointerZonesCallback(JSContext* cx, JSWeakPointerZonesCallback cb);
+
+extern bool
+JS_AddWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb,
+                                     void* data);
+
+extern void
+JS_RemoveWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb);
+
+extern void
+JS_UpdateWeakPointerAfterGC(JS::Heap<JSObject*>* objp);
+
+extern void
+JS_UpdateWeakPointerAfterGCUnbarriered(JSObject** objp);
+
+typedef enum JSGCParamKey {
+
+    JSGC_MAX_BYTES = 0,
+
+
+    JSGC_MAX_MALLOC_BYTES = 1,
+
+
+    JSGC_MAX_NURSERY_BYTES = 2,
+
+
+    JSGC_BYTES = 3,
+
+
+    JSGC_NUMBER = 4,
+
+
+    JSGC_MODE = 6,
+
+
+    JSGC_UNUSED_CHUNKS = 7,
+
+
+    JSGC_TOTAL_CHUNKS = 8,
+
+
+    JSGC_SLICE_TIME_BUDGET = 9,
+
+
+    JSGC_MARK_STACK_LIMIT = 10,
+
+
+
+
+
+    JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11,
+
+
+    JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12,
+
+
+    JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13,
+
+
+    JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14,
+
+
+    JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15,
+
+
+    JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16,
+
+
+
+
+
+    JSGC_DYNAMIC_HEAP_GROWTH = 17,
+
+
+    JSGC_DYNAMIC_MARK_SLICE = 18,
+
+
+    JSGC_ALLOCATION_THRESHOLD = 19,
+
+
+
+
+
+    JSGC_MIN_EMPTY_CHUNK_COUNT = 21,
+
+
+    JSGC_MAX_EMPTY_CHUNK_COUNT = 22,
+
+
+    JSGC_COMPACTING_ENABLED = 23,
+
+
+    JSGC_REFRESH_FRAME_SLICES_ENABLED = 24,
+} JSGCParamKey;
+
+extern void
+JS_SetGCParameter(JSContext* cx, JSGCParamKey key, uint32_t value);
+
+extern uint32_t
+JS_GetGCParameter(JSContext* cx, JSGCParamKey key);
+
+extern void
+JS_SetGCParametersBasedOnAvailableMemory(JSContext* cx, uint32_t availMem);
+
+
+
+
+
+extern JSString*
+JS_NewExternalString(JSContext* cx, const char16_t* chars, size_t length,
+                     const JSStringFinalizer* fin);
+# 1864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSString*
+JS_NewMaybeExternalString(JSContext* cx, const char16_t* chars, size_t length,
+                          const JSStringFinalizer* fin, bool* isExternal);
+
+
+
+
+
+extern bool
+JS_IsExternalString(JSString* str);
+
+
+
+
+extern const JSStringFinalizer*
+JS_GetExternalStringFinalizer(JSString* str);
+# 1899 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+JS_SetNativeStackQuota(JSContext* cx, size_t systemCodeStackSize,
+                       size_t trustedScriptStackSize = 0,
+                       size_t untrustedScriptStackSize = 0);
+
+
+
+extern bool
+JS_ValueToId(JSContext* cx, JS::HandleValue v, JS::MutableHandleId idp);
+
+extern bool
+JS_StringToId(JSContext* cx, JS::HandleString s, JS::MutableHandleId idp);
+
+extern bool
+JS_IdToValue(JSContext* cx, jsid id, JS::MutableHandle<JS::Value> vp);
+
+namespace JS {
+# 1926 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+ToPrimitive(JSContext* cx, JS::HandleObject obj, JSType hint, JS::MutableHandleValue vp);
+# 1936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+GetFirstArgumentAsTypeHint(JSContext* cx, CallArgs args, JSType *result);
+
+}
+
+extern bool
+JS_PropertyStub(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                JS::MutableHandleValue vp);
+
+extern bool
+JS_StrictPropertyStub(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                      JS::MutableHandleValue vp, JS::ObjectOpResult& result);
+
+template<typename T>
+struct JSConstScalarSpec {
+    const char* name;
+    T val;
+};
+
+typedef JSConstScalarSpec<double> JSConstDoubleSpec;
+typedef JSConstScalarSpec<int32_t> JSConstIntegerSpec;
+
+struct JSJitInfo;
+
+
+
+
+
+
+typedef struct JSNativeWrapper {
+    JSNative op;
+    const JSJitInfo* info;
+} JSNativeWrapper;
+# 1981 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+struct JSPropertySpec {
+    struct SelfHostedWrapper {
+        void* unused;
+        const char* funname;
+    };
+
+    struct ValueWrapper {
+        uintptr_t type;
+        union {
+            const char* string;
+            int32_t int32;
+        };
+    };
+
+    const char* name;
+    uint8_t flags;
+    union {
+        struct {
+            union {
+                JSNativeWrapper native;
+                SelfHostedWrapper selfHosted;
+            } getter;
+            union {
+                JSNativeWrapper native;
+                SelfHostedWrapper selfHosted;
+            } setter;
+        } accessors;
+        ValueWrapper value;
+    };
+
+    bool isAccessor() const {
+        return !(flags & 0x80);
+    }
+    bool getValue(JSContext* cx, JS::MutableHandleValue value) const;
+
+    bool isSelfHosted() const {
+        do { } while (0);
+# 2026 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+        return (flags & 0x10);
+    }
+
+    static_assert(sizeof(SelfHostedWrapper) == sizeof(JSNativeWrapper),
+                  "JSPropertySpec::getter/setter must be compact");
+    static_assert(__builtin_offsetof(SelfHostedWrapper, funname) == __builtin_offsetof(JSNativeWrapper, info),
+                  "JS_SELF_HOSTED* macros below require that "
+                  "SelfHostedWrapper::funname overlay "
+                  "JSNativeWrapper::info");
+private:
+    void checkAccessorsAreNative() const {
+        do { } while (0);
+
+
+
+
+        do { } while (0);
+    }
+
+    void checkAccessorsAreSelfHosted() const {
+        do { } while (0);
+        do { } while (0);
+    }
+};
+
+namespace JS {
+namespace detail {
+
+
+inline int CheckIsNative(JSNative native);
+
+
+template<size_t N>
+inline int
+CheckIsCharacterLiteral(const char (&arr)[N]);
+
+
+inline int CheckIsInt32(int32_t value);
+
+
+inline int CheckIsGetterOp(JSGetterOp op);
+
+
+inline int CheckIsSetterOp(JSSetterOp op);
+
+}
+}
+# 2152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+struct JSFunctionSpec {
+    const char* name;
+    JSNativeWrapper call;
+    uint16_t nargs;
+    uint16_t flags;
+    const char* selfHostedName;
+};
+# 2200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+JS_InitClass(JSContext* cx, JS::HandleObject obj, JS::HandleObject parent_proto,
+             const JSClass* clasp, JSNative constructor, unsigned nargs,
+             const JSPropertySpec* ps, const JSFunctionSpec* fs,
+             const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs);
+
+
+
+
+
+extern bool
+JS_LinkConstructorAndPrototype(JSContext* cx, JS::Handle<JSObject*> ctor,
+                               JS::Handle<JSObject*> proto);
+
+extern const JSClass*
+JS_GetClass(JSObject* obj);
+
+extern bool
+JS_InstanceOf(JSContext* cx, JS::Handle<JSObject*> obj, const JSClass* clasp, JS::CallArgs* args);
+
+extern bool
+JS_HasInstance(JSContext* cx, JS::Handle<JSObject*> obj, JS::Handle<JS::Value> v, bool* bp);
+
+namespace JS {
+
+
+
+
+
+extern bool
+OrdinaryHasInstance(JSContext* cx, HandleObject objArg, HandleValue v, bool* bp);
+
+}
+
+extern void*
+JS_GetPrivate(JSObject* obj);
+
+extern void
+JS_SetPrivate(JSObject* obj, void* data);
+
+extern void*
+JS_GetInstancePrivate(JSContext* cx, JS::Handle<JSObject*> obj, const JSClass* clasp,
+                      JS::CallArgs* args);
+
+extern JSObject*
+JS_GetConstructor(JSContext* cx, JS::Handle<JSObject*> proto);
+
+namespace JS {
+
+
+enum ZoneSpecifier {
+
+
+    SystemZone,
+
+
+    ExistingZone,
+
+
+    NewZoneInNewZoneGroup,
+
+
+    NewZoneInSystemZoneGroup,
+
+
+    NewZoneInExistingZoneGroup
+};
+# 2276 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class CompartmentCreationOptions
+{
+  public:
+    CompartmentCreationOptions()
+      : addonId_(nullptr),
+        traceGlobal_(nullptr),
+        zoneSpec_(NewZoneInSystemZoneGroup),
+        zonePointer_(nullptr),
+        invisibleToDebugger_(false),
+        mergeable_(false),
+        preserveJitCode_(false),
+        cloneSingletons_(false),
+        experimentalNumberFormatFormatToPartsEnabled_(false),
+        sharedMemoryAndAtomics_(false),
+        secureContext_(false)
+    {}
+
+
+
+    JSAddonId* addonIdOrNull() const { return addonId_; }
+    CompartmentCreationOptions& setAddonId(JSAddonId* id) {
+        addonId_ = id;
+        return *this;
+    }
+
+    JSTraceOp getTrace() const {
+        return traceGlobal_;
+    }
+    CompartmentCreationOptions& setTrace(JSTraceOp op) {
+        traceGlobal_ = op;
+        return *this;
+    }
+
+    void* zonePointer() const { return zonePointer_; }
+    ZoneSpecifier zoneSpecifier() const { return zoneSpec_; }
+
+
+    CompartmentCreationOptions& setSystemZone();
+    CompartmentCreationOptions& setExistingZone(JSObject* obj);
+    CompartmentCreationOptions& setNewZoneInNewZoneGroup();
+    CompartmentCreationOptions& setNewZoneInSystemZoneGroup();
+    CompartmentCreationOptions& setNewZoneInExistingZoneGroup(JSObject* obj);
+
+
+
+
+
+    bool invisibleToDebugger() const { return invisibleToDebugger_; }
+    CompartmentCreationOptions& setInvisibleToDebugger(bool flag) {
+        invisibleToDebugger_ = flag;
+        return *this;
+    }
+
+
+
+
+
+    bool mergeable() const { return mergeable_; }
+    CompartmentCreationOptions& setMergeable(bool flag) {
+        mergeable_ = flag;
+        return *this;
+    }
+
+
+
+    bool preserveJitCode() const { return preserveJitCode_; }
+    CompartmentCreationOptions& setPreserveJitCode(bool flag) {
+        preserveJitCode_ = flag;
+        return *this;
+    }
+
+    bool cloneSingletons() const { return cloneSingletons_; }
+    CompartmentCreationOptions& setCloneSingletons(bool flag) {
+        cloneSingletons_ = flag;
+        return *this;
+    }
+# 2362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    bool experimentalNumberFormatFormatToPartsEnabled() const {
+        return experimentalNumberFormatFormatToPartsEnabled_;
+    }
+    CompartmentCreationOptions& setExperimentalNumberFormatFormatToPartsEnabled(bool flag) {
+        experimentalNumberFormatFormatToPartsEnabled_ = flag;
+        return *this;
+    }
+
+    bool getSharedMemoryAndAtomicsEnabled() const;
+    CompartmentCreationOptions& setSharedMemoryAndAtomicsEnabled(bool flag);
+
+
+
+
+
+    bool secureContext() const { return secureContext_; }
+    CompartmentCreationOptions& setSecureContext(bool flag) {
+        secureContext_ = flag;
+        return *this;
+    }
+
+  private:
+    JSAddonId* addonId_;
+    JSTraceOp traceGlobal_;
+    ZoneSpecifier zoneSpec_;
+    void* zonePointer_;
+    bool invisibleToDebugger_;
+    bool mergeable_;
+    bool preserveJitCode_;
+    bool cloneSingletons_;
+    bool experimentalNumberFormatFormatToPartsEnabled_;
+    bool sharedMemoryAndAtomics_;
+    bool secureContext_;
+};
+
+
+
+
+
+class CompartmentBehaviors
+{
+  public:
+    class Override {
+      public:
+        Override() : mode_(Default) {}
+
+        bool get(bool defaultValue) const {
+            if (mode_ == Default)
+                return defaultValue;
+            return mode_ == ForceTrue;
+        }
+
+        void set(bool overrideValue) {
+            mode_ = overrideValue ? ForceTrue : ForceFalse;
+        }
+
+        void reset() {
+            mode_ = Default;
+        }
+
+      private:
+        enum Mode {
+            Default,
+            ForceTrue,
+            ForceFalse
+        };
+
+        Mode mode_;
+    };
+
+    CompartmentBehaviors()
+      : version_(JSVERSION_UNKNOWN)
+      , discardSource_(false)
+      , disableLazyParsing_(false)
+      , singletonsAsTemplates_(true)
+    {
+    }
+
+    JSVersion version() const { return version_; }
+    CompartmentBehaviors& setVersion(JSVersion aVersion) {
+        do { } while (0);
+        version_ = aVersion;
+        return *this;
+    }
+
+
+
+    bool discardSource() const { return discardSource_; }
+    CompartmentBehaviors& setDiscardSource(bool flag) {
+        discardSource_ = flag;
+        return *this;
+    }
+
+    bool disableLazyParsing() const { return disableLazyParsing_; }
+    CompartmentBehaviors& setDisableLazyParsing(bool flag) {
+        disableLazyParsing_ = flag;
+        return *this;
+    }
+
+    bool extraWarnings(JSContext* cx) const;
+    Override& extraWarningsOverride() { return extraWarningsOverride_; }
+
+    bool getSingletonsAsTemplates() const {
+        return singletonsAsTemplates_;
+    }
+    CompartmentBehaviors& setSingletonsAsValues() {
+        singletonsAsTemplates_ = false;
+        return *this;
+    }
+
+  private:
+    JSVersion version_;
+    bool discardSource_;
+    bool disableLazyParsing_;
+    Override extraWarningsOverride_;
+
+
+
+
+    bool singletonsAsTemplates_;
+};
+
+
+
+
+
+
+
+class CompartmentOptions
+{
+  public:
+    explicit CompartmentOptions()
+      : creationOptions_(),
+        behaviors_()
+    {}
+
+    CompartmentOptions(const CompartmentCreationOptions& compartmentCreation,
+                       const CompartmentBehaviors& compartmentBehaviors)
+      : creationOptions_(compartmentCreation),
+        behaviors_(compartmentBehaviors)
+    {}
+
+
+
+
+    CompartmentCreationOptions& creationOptions() {
+        return creationOptions_;
+    }
+    const CompartmentCreationOptions& creationOptions() const {
+        return creationOptions_;
+    }
+
+
+
+    CompartmentBehaviors& behaviors() {
+        return behaviors_;
+    }
+    const CompartmentBehaviors& behaviors() const {
+        return behaviors_;
+    }
+
+  private:
+    CompartmentCreationOptions creationOptions_;
+    CompartmentBehaviors behaviors_;
+};
+
+const CompartmentCreationOptions&
+CompartmentCreationOptionsRef(JSCompartment* compartment);
+
+const CompartmentCreationOptions&
+CompartmentCreationOptionsRef(JSObject* obj);
+
+const CompartmentCreationOptions&
+CompartmentCreationOptionsRef(JSContext* cx);
+
+CompartmentBehaviors&
+CompartmentBehaviorsRef(JSCompartment* compartment);
+
+CompartmentBehaviors&
+CompartmentBehaviorsRef(JSObject* obj);
+
+CompartmentBehaviors&
+CompartmentBehaviorsRef(JSContext* cx);
+# 2568 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+enum OnNewGlobalHookOption {
+    FireOnNewGlobalHook,
+    DontFireOnNewGlobalHook
+};
+
+}
+
+extern JSObject*
+JS_NewGlobalObject(JSContext* cx, const JSClass* clasp, JSPrincipals* principals,
+                   JS::OnNewGlobalHookOption hookOption,
+                   const JS::CompartmentOptions& options);
+# 2588 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+JS_GlobalObjectTraceHook(JSTracer* trc, JSObject* global);
+
+extern void
+JS_FireOnNewGlobalObject(JSContext* cx, JS::HandleObject global);
+
+extern JSObject*
+JS_NewObject(JSContext* cx, const JSClass* clasp);
+
+extern bool
+JS_IsNative(JSObject* obj);
+
+
+
+
+
+extern JSObject*
+JS_NewObjectWithGivenProto(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
+
+
+extern JSObject*
+JS_NewPlainObject(JSContext* cx);
+
+
+
+
+
+
+extern bool
+JS_DeepFreezeObject(JSContext* cx, JS::Handle<JSObject*> obj);
+
+
+
+
+extern bool
+JS_FreezeObject(JSContext* cx, JS::Handle<JSObject*> obj);
+
+
+
+
+namespace JS {
+
+struct PropertyDescriptor {
+    JSObject* obj;
+    unsigned attrs;
+    JSGetterOp getter;
+    JSSetterOp setter;
+    JS::Value value;
+
+    PropertyDescriptor()
+      : obj(nullptr), attrs(0), getter(nullptr), setter(nullptr), value(JS::UndefinedValue())
+    {}
+
+    static void trace(PropertyDescriptor* self, JSTracer* trc) { self->trace(trc); }
+    void trace(JSTracer* trc);
+};
+
+}
+
+namespace js {
+
+template <typename Wrapper>
+class WrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
+{
+    const JS::PropertyDescriptor& desc() const { return static_cast<const Wrapper*>(this)->get(); }
+
+    bool has(unsigned bit) const {
+        do { } while (0);
+        do { } while (0);
+        return (desc().attrs & bit) != 0;
+    }
+
+    bool hasAny(unsigned bits) const {
+        return (desc().attrs & bits) != 0;
+    }
+
+    bool hasAll(unsigned bits) const {
+        return (desc().attrs & bits) == bits;
+    }
+
+
+    enum { SHADOWABLE = 0x80 };
+
+  public:
+
+
+    bool isAccessorDescriptor() const { return hasAny(0x10 | 0x20); }
+    bool isGenericDescriptor() const {
+        return (desc().attrs&
+                (0x10 | 0x20 | 0x8000 | 0x20000)) ==
+               (0x8000 | 0x20000);
+    }
+    bool isDataDescriptor() const { return !isAccessorDescriptor() && !isGenericDescriptor(); }
+
+    bool hasConfigurable() const { return !has(0x10000); }
+    bool configurable() const { do { } while (0); return !has(0x04); }
+
+    bool hasEnumerable() const { return !has(0x4000); }
+    bool enumerable() const { do { } while (0); return has(0x01); }
+
+    bool hasValue() const { return !isAccessorDescriptor() && !has(0x20000); }
+    JS::HandleValue value() const {
+        return JS::HandleValue::fromMarkedLocation(&desc().value);
+    }
+
+    bool hasWritable() const { return !isAccessorDescriptor() && !has(0x8000); }
+    bool writable() const { do { } while (0); return !has(0x02); }
+
+    bool hasGetterObject() const { return has(0x10); }
+    JS::HandleObject getterObject() const {
+        do { } while (0);
+        return JS::HandleObject::fromMarkedLocation(
+                reinterpret_cast<JSObject* const*>(&desc().getter));
+    }
+    bool hasSetterObject() const { return has(0x20); }
+    JS::HandleObject setterObject() const {
+        do { } while (0);
+        return JS::HandleObject::fromMarkedLocation(
+                reinterpret_cast<JSObject* const*>(&desc().setter));
+    }
+
+    bool hasGetterOrSetter() const { return desc().getter || desc().setter; }
+    bool isShared() const { return has(0x40); }
+
+    JS::HandleObject object() const {
+        return JS::HandleObject::fromMarkedLocation(&desc().obj);
+    }
+    unsigned attributes() const { return desc().attrs; }
+    JSGetterOp getter() const { return desc().getter; }
+    JSSetterOp setter() const { return desc().setter; }
+
+    void assertValid() const {
+# 2755 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    }
+
+    void assertComplete() const {
+# 2771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    }
+
+    void assertCompleteIfFound() const {
+
+
+
+
+    }
+};
+
+template <typename Wrapper>
+class MutableWrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
+    : public js::WrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
+{
+    JS::PropertyDescriptor& desc() { return static_cast<Wrapper*>(this)->get(); }
+
+  public:
+    void clear() {
+        object().set(nullptr);
+        setAttributes(0);
+        setGetter(nullptr);
+        setSetter(nullptr);
+        value().setUndefined();
+    }
+
+    void initFields(JS::HandleObject obj, JS::HandleValue v, unsigned attrs,
+                    JSGetterOp getterOp, JSSetterOp setterOp) {
+        do { } while (0);
+        do { } while (0);
+
+        object().set(obj);
+        value().set(v);
+        setAttributes(attrs);
+        setGetter(getterOp);
+        setSetter(setterOp);
+    }
+
+    void assign(JS::PropertyDescriptor& other) {
+        object().set(other.obj);
+        setAttributes(other.attrs);
+        setGetter(other.getter);
+        setSetter(other.setter);
+        value().set(other.value);
+    }
+
+    void setDataDescriptor(JS::HandleValue v, unsigned attrs) {
+        do { } while (0);
+
+
+
+
+
+        object().set(nullptr);
+        setAttributes(attrs);
+        setGetter(nullptr);
+        setSetter(nullptr);
+        value().set(v);
+    }
+
+    JS::MutableHandleObject object() {
+        return JS::MutableHandleObject::fromMarkedLocation(&desc().obj);
+    }
+    unsigned& attributesRef() { return desc().attrs; }
+    JSGetterOp& getter() { return desc().getter; }
+    JSSetterOp& setter() { return desc().setter; }
+    JS::MutableHandleValue value() {
+        return JS::MutableHandleValue::fromMarkedLocation(&desc().value);
+    }
+    void setValue(JS::HandleValue v) {
+        do { } while (0);
+        attributesRef() &= ~0x20000;
+        value().set(v);
+    }
+
+    void setConfigurable(bool configurable) {
+        setAttributes((desc().attrs & ~(0x10000 | 0x04)) |
+                      (configurable ? 0 : 0x04));
+    }
+    void setEnumerable(bool enumerable) {
+        setAttributes((desc().attrs & ~(0x4000 | 0x01)) |
+                      (enumerable ? 0x01 : 0));
+    }
+    void setWritable(bool writable) {
+        do { } while (0);
+        setAttributes((desc().attrs & ~(0x8000 | 0x02)) |
+                      (writable ? 0 : 0x02));
+    }
+    void setAttributes(unsigned attrs) { desc().attrs = attrs; }
+
+    void setGetter(JSGetterOp op) {
+        do { } while (0);
+        desc().getter = op;
+    }
+    void setSetter(JSSetterOp op) {
+        do { } while (0);
+        desc().setter = op;
+    }
+    void setGetterObject(JSObject* obj) {
+        desc().getter = reinterpret_cast<JSGetterOp>(obj);
+        desc().attrs &= ~(0x20000 | 0x8000 | 0x02);
+        desc().attrs |= 0x10 | 0x40;
+    }
+    void setSetterObject(JSObject* obj) {
+        desc().setter = reinterpret_cast<JSSetterOp>(obj);
+        desc().attrs &= ~(0x20000 | 0x8000 | 0x02);
+        desc().attrs |= 0x20 | 0x40;
+    }
+
+    JS::MutableHandleObject getterObject() {
+        do { } while (0);
+        return JS::MutableHandleObject::fromMarkedLocation(
+                reinterpret_cast<JSObject**>(&desc().getter));
+    }
+    JS::MutableHandleObject setterObject() {
+        do { } while (0);
+        return JS::MutableHandleObject::fromMarkedLocation(
+                reinterpret_cast<JSObject**>(&desc().setter));
+    }
+};
+
+}
+
+namespace JS {
+
+extern bool
+ObjectToCompletePropertyDescriptor(JSContext* cx,
+                                   JS::HandleObject obj,
+                                   JS::HandleValue descriptor,
+                                   JS::MutableHandle<PropertyDescriptor> desc);
+
+
+
+
+
+
+extern bool
+FromPropertyDescriptor(JSContext* cx,
+                       JS::Handle<JS::PropertyDescriptor> desc,
+                       JS::MutableHandleValue vp);
+
+}
+# 2936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_GetPrototype(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject result);
+# 2946 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_GetPrototypeIfOrdinary(JSContext* cx, JS::HandleObject obj, bool* isOrdinary,
+                          JS::MutableHandleObject result);
+# 2963 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_SetPrototype(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
+# 2973 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_IsExtensible(JSContext* cx, JS::HandleObject obj, bool* extensible);
+# 2984 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_PreventExtensions(JSContext* cx, JS::HandleObject obj, JS::ObjectOpResult& result);
+# 2996 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_SetImmutablePrototype(JSContext* cx, JS::HandleObject obj, bool* succeeded);
+
+
+
+
+
+
+
+extern bool
+JS_GetOwnPropertyDescriptorById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                                JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+extern bool
+JS_GetOwnPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char* name,
+                            JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+extern bool
+JS_GetOwnUCPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char16_t* name,
+                              JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+
+
+
+
+
+
+extern bool
+JS_GetPropertyDescriptorById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                             JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+extern bool
+JS_GetPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char* name,
+                         JS::MutableHandle<JS::PropertyDescriptor> desc);
+# 3042 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                      JS::Handle<JS::PropertyDescriptor> desc,
+                      JS::ObjectOpResult& result);
+
+
+
+
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                      JS::Handle<JS::PropertyDescriptor> desc);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleString value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, int32_t value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, uint32_t value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, double value,
+                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleValue value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleObject value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleString value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, int32_t value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, uint32_t value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, double value,
+                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::Handle<JS::PropertyDescriptor> desc,
+                    JS::ObjectOpResult& result);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::Handle<JS::PropertyDescriptor> desc);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::HandleValue value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::HandleObject value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::HandleString value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    int32_t value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    uint32_t value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    double value, unsigned attrs,
+                    JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleValue value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleObject value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleString value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, int32_t value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, uint32_t value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+
+extern bool
+JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, double value,
+                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
+# 3175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_HasPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
+
+extern bool
+JS_HasProperty(JSContext* cx, JS::HandleObject obj, const char* name, bool* foundp);
+
+extern bool
+JS_HasUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                 bool* vp);
+
+extern bool
+JS_HasElement(JSContext* cx, JS::HandleObject obj, uint32_t index, bool* foundp);
+
+
+
+
+
+
+extern bool
+JS_HasOwnPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
+
+extern bool
+JS_HasOwnProperty(JSContext* cx, JS::HandleObject obj, const char* name, bool* foundp);
+# 3210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ForwardGetPropertyTo(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                        JS::HandleValue receiver, JS::MutableHandleValue vp);
+
+extern bool
+JS_ForwardGetElementTo(JSContext* cx, JS::HandleObject obj, uint32_t index,
+                       JS::HandleObject receiver, JS::MutableHandleValue vp);
+
+
+
+
+
+
+
+extern bool
+JS_GetPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                   JS::MutableHandleValue vp);
+
+extern bool
+JS_GetProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::MutableHandleValue vp);
+
+extern bool
+JS_GetUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                 JS::MutableHandleValue vp);
+
+extern bool
+JS_GetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::MutableHandleValue vp);
+# 3246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ForwardSetPropertyTo(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v,
+                        JS::HandleValue receiver, JS::ObjectOpResult& result);
+
+
+
+
+
+
+
+extern bool
+JS_SetPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v);
+
+extern bool
+JS_SetProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleValue v);
+
+extern bool
+JS_SetUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                 JS::HandleValue v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleValue v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleObject v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleString v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, int32_t v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, uint32_t v);
+
+extern bool
+JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, double v);
+# 3295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_DeletePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                      JS::ObjectOpResult& result);
+
+extern bool
+JS_DeleteProperty(JSContext* cx, JS::HandleObject obj, const char* name,
+                  JS::ObjectOpResult& result);
+
+extern bool
+JS_DeleteUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
+                    JS::ObjectOpResult& result);
+
+extern bool
+JS_DeleteElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::ObjectOpResult& result);
+
+
+
+
+
+extern bool
+JS_DeletePropertyById(JSContext* cx, JS::HandleObject obj, jsid id);
+
+extern bool
+JS_DeleteProperty(JSContext* cx, JS::HandleObject obj, const char* name);
+
+extern bool
+JS_DeleteElement(JSContext* cx, JS::HandleObject obj, uint32_t index);
+# 3338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_Enumerate(JSContext* cx, JS::HandleObject obj, JS::MutableHandle<JS::IdVector> props);
+
+
+
+
+
+
+
+namespace JS {
+# 3358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+IsCallable(JSObject* obj);
+# 3372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+IsConstructor(JSObject* obj);
+
+}
+# 3384 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_CallFunctionValue(JSContext* cx, JS::HandleObject obj, JS::HandleValue fval,
+                     const JS::HandleValueArray& args, JS::MutableHandleValue rval);
+
+extern bool
+JS_CallFunction(JSContext* cx, JS::HandleObject obj, JS::HandleFunction fun,
+                const JS::HandleValueArray& args, JS::MutableHandleValue rval);
+
+
+
+
+extern bool
+JS_CallFunctionName(JSContext* cx, JS::HandleObject obj, const char* name,
+                    const JS::HandleValueArray& args, JS::MutableHandleValue rval);
+
+namespace JS {
+
+static inline bool
+Call(JSContext* cx, JS::HandleObject thisObj, JS::HandleFunction fun,
+     const JS::HandleValueArray& args, MutableHandleValue rval)
+{
+    return !!JS_CallFunction(cx, thisObj, fun, args, rval);
+}
+
+static inline bool
+Call(JSContext* cx, JS::HandleObject thisObj, JS::HandleValue fun, const JS::HandleValueArray& args,
+     MutableHandleValue rval)
+{
+    return !!JS_CallFunctionValue(cx, thisObj, fun, args, rval);
+}
+
+static inline bool
+Call(JSContext* cx, JS::HandleObject thisObj, const char* name, const JS::HandleValueArray& args,
+     MutableHandleValue rval)
+{
+    return !!JS_CallFunctionName(cx, thisObj, name, args, rval);
+}
+
+extern bool
+Call(JSContext* cx, JS::HandleValue thisv, JS::HandleValue fun, const JS::HandleValueArray& args,
+     MutableHandleValue rval);
+
+static inline bool
+Call(JSContext* cx, JS::HandleValue thisv, JS::HandleObject funObj, const JS::HandleValueArray& args,
+     MutableHandleValue rval)
+{
+    do { } while (0);
+    JS::RootedValue fun(cx, JS::ObjectValue(*funObj));
+    return Call(cx, thisv, fun, args, rval);
+}
+# 3447 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+Construct(JSContext* cx, JS::HandleValue fun, HandleObject newTarget,
+          const JS::HandleValueArray &args, MutableHandleObject objp);
+# 3458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+Construct(JSContext* cx, JS::HandleValue fun, const JS::HandleValueArray& args,
+          MutableHandleObject objp);
+
+}
+
+
+
+
+
+extern JSObject*
+JS_New(JSContext* cx, JS::HandleObject ctor, const JS::HandleValueArray& args);
+
+
+
+
+extern JSObject*
+JS_DefineObject(JSContext* cx, JS::HandleObject obj, const char* name,
+                const JSClass* clasp = nullptr, unsigned attrs = 0);
+
+extern bool
+JS_DefineConstDoubles(JSContext* cx, JS::HandleObject obj, const JSConstDoubleSpec* cds);
+
+extern bool
+JS_DefineConstIntegers(JSContext* cx, JS::HandleObject obj, const JSConstIntegerSpec* cis);
+
+extern bool
+JS_DefineProperties(JSContext* cx, JS::HandleObject obj, const JSPropertySpec* ps);
+
+
+
+
+extern bool
+JS_AlreadyHasOwnPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                             bool* foundp);
+
+extern bool
+JS_AlreadyHasOwnProperty(JSContext* cx, JS::HandleObject obj, const char* name,
+                         bool* foundp);
+
+extern bool
+JS_AlreadyHasOwnUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name,
+                           size_t namelen, bool* foundp);
+
+extern bool
+JS_AlreadyHasOwnElement(JSContext* cx, JS::HandleObject obj, uint32_t index, bool* foundp);
+
+extern JSObject*
+JS_NewArrayObject(JSContext* cx, const JS::HandleValueArray& contents);
+
+extern JSObject*
+JS_NewArrayObject(JSContext* cx, size_t length);
+# 3518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_IsArrayObject(JSContext* cx, JS::HandleValue value, bool* isArray);
+# 3528 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_IsArrayObject(JSContext* cx, JS::HandleObject obj, bool* isArray);
+
+extern bool
+JS_GetArrayLength(JSContext* cx, JS::Handle<JSObject*> obj, uint32_t* lengthp);
+
+extern bool
+JS_SetArrayLength(JSContext* cx, JS::Handle<JSObject*> obj, uint32_t length);
+
+namespace JS {
+# 3546 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+IsMapObject(JSContext* cx, JS::HandleObject obj, bool* isMap);
+# 3556 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+IsSetObject(JSContext* cx, JS::HandleObject obj, bool* isSet);
+
+}
+
+
+
+
+
+void
+JS_SetAllNonReservedSlotsToUndefined(JSContext* cx, JSObject* objArg);
+
+
+
+
+
+
+extern JSObject*
+JS_NewArrayBufferWithContents(JSContext* cx, size_t nbytes, void* contents);
+
+
+
+
+
+extern JSObject*
+JS_NewArrayBufferWithExternalContents(JSContext* cx, size_t nbytes, void* contents);
+
+
+
+
+
+
+
+extern void*
+JS_StealArrayBufferContents(JSContext* cx, JS::HandleObject obj);
+# 3608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void*
+JS_ExternalizeArrayBufferContents(JSContext* cx, JS::HandleObject obj);
+
+
+
+
+
+
+extern JSObject*
+JS_NewMappedArrayBufferWithContents(JSContext* cx, size_t nbytes, void* contents);
+
+
+
+
+
+extern void*
+JS_CreateMappedArrayBufferContents(int fd, size_t offset, size_t length);
+# 3633 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+JS_ReleaseMappedArrayBufferContents(void* contents, size_t length);
+
+extern JS::Value
+JS_GetReservedSlot(JSObject* obj, uint32_t index);
+
+extern void
+JS_SetReservedSlot(JSObject* obj, uint32_t index, const JS::Value& v);
+
+
+
+
+
+
+
+extern JSFunction*
+JS_NewFunction(JSContext* cx, JSNative call, unsigned nargs, unsigned flags,
+               const char* name);
+
+namespace JS {
+
+extern JSFunction*
+GetSelfHostedFunction(JSContext* cx, const char* selfHostedName, HandleId id,
+                      unsigned nargs);
+# 3666 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSFunction*
+NewFunctionFromSpec(JSContext* cx, const JSFunctionSpec* fs, HandleId id);
+
+}
+
+extern JSObject*
+JS_GetFunctionObject(JSFunction* fun);
+
+
+
+
+
+
+
+extern JSString*
+JS_GetFunctionId(JSFunction* fun);
+# 3690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSString*
+JS_GetFunctionDisplayId(JSFunction* fun);
+
+
+
+
+extern uint16_t
+JS_GetFunctionArity(JSFunction* fun);
+
+
+
+
+
+
+
+extern bool
+JS_ObjectIsFunction(JSContext* cx, JSObject* obj);
+
+extern bool
+JS_IsNativeFunction(JSObject* funobj, JSNative call);
+
+
+extern bool
+JS_IsConstructor(JSFunction* fun);
+
+extern bool
+JS_DefineFunctions(JSContext* cx, JS::Handle<JSObject*> obj, const JSFunctionSpec* fs);
+
+extern JSFunction*
+JS_DefineFunction(JSContext* cx, JS::Handle<JSObject*> obj, const char* name, JSNative call,
+                  unsigned nargs, unsigned attrs);
+
+extern JSFunction*
+JS_DefineUCFunction(JSContext* cx, JS::Handle<JSObject*> obj,
+                    const char16_t* name, size_t namelen, JSNative call,
+                    unsigned nargs, unsigned attrs);
+
+extern JSFunction*
+JS_DefineFunctionById(JSContext* cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JSNative call,
+                      unsigned nargs, unsigned attrs);
+
+extern bool
+JS_IsFunctionBound(JSFunction* fun);
+
+extern JSObject*
+JS_GetBoundFunctionTarget(JSFunction* fun);
+
+namespace JS {
+
+
+
+
+
+extern JSObject*
+CloneFunctionObject(JSContext* cx, HandleObject funobj);
+
+
+
+
+
+
+extern JSObject*
+CloneFunctionObject(JSContext* cx, HandleObject funobj, AutoObjectVector& scopeChain);
+
+}
+# 3763 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_BufferIsCompilableUnit(JSContext* cx, JS::Handle<JSObject*> obj, const char* utf8,
+                          size_t length);
+
+
+
+
+extern bool
+JS_CompileScript(JSContext* cx, const char* ascii, size_t length,
+                 const JS::CompileOptions& options,
+                 JS::MutableHandleScript script);
+
+
+
+
+extern bool
+JS_CompileUCScript(JSContext* cx, const char16_t* chars, size_t length,
+                   const JS::CompileOptions& options,
+                   JS::MutableHandleScript script);
+
+extern JSObject*
+JS_GetGlobalFromScript(JSScript* script);
+
+extern const char*
+JS_GetScriptFilename(JSScript* script);
+
+extern unsigned
+JS_GetScriptBaseLineNumber(JSContext* cx, JSScript* script);
+
+extern JSScript*
+JS_GetFunctionScript(JSContext* cx, JS::HandleFunction fun);
+
+namespace JS {
+# 3843 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+enum class AsmJSOption : uint8_t { Enabled, Disabled, DisabledByDebugger };
+
+
+
+
+
+
+
+class TransitiveCompileOptions
+{
+  protected:
+# 3865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    bool mutedErrors_;
+    const char* filename_;
+    const char* introducerFilename_;
+    const char16_t* sourceMapURL_;
+
+
+
+
+
+    TransitiveCompileOptions()
+      : mutedErrors_(false),
+        filename_(nullptr),
+        introducerFilename_(nullptr),
+        sourceMapURL_(nullptr),
+        version(JSVERSION_UNKNOWN),
+        versionSet(false),
+        utf8(false),
+        selfHostingMode(false),
+        canLazilyParse(true),
+        strictOption(false),
+        extraWarningsOption(false),
+        forEachStatementOption(false),
+        werrorOption(false),
+        asmJSOption(AsmJSOption::Disabled),
+        throwOnAsmJSValidationFailureOption(false),
+        forceAsync(false),
+        sourceIsLazy(false),
+        allowHTMLComments(true),
+        isProbablySystemOrAddonCode(false),
+        introductionType(nullptr),
+        introductionLineno(0),
+        introductionOffset(0),
+        hasIntroductionInfo(false)
+    { }
+
+
+
+    void copyPODTransitiveOptions(const TransitiveCompileOptions& rhs);
+
+  public:
+
+
+    bool mutedErrors() const { return mutedErrors_; }
+    const char* filename() const { return filename_; }
+    const char* introducerFilename() const { return introducerFilename_; }
+    const char16_t* sourceMapURL() const { return sourceMapURL_; }
+    virtual JSObject* element() const = 0;
+    virtual JSString* elementAttributeName() const = 0;
+    virtual JSScript* introductionScript() const = 0;
+
+
+    JSVersion version;
+    bool versionSet;
+    bool utf8;
+    bool selfHostingMode;
+    bool canLazilyParse;
+    bool strictOption;
+    bool extraWarningsOption;
+    bool forEachStatementOption;
+    bool werrorOption;
+    AsmJSOption asmJSOption;
+    bool throwOnAsmJSValidationFailureOption;
+    bool forceAsync;
+    bool sourceIsLazy;
+    bool allowHTMLComments;
+    bool isProbablySystemOrAddonCode;
+
+
+
+    const char* introductionType;
+    unsigned introductionLineno;
+    uint32_t introductionOffset;
+    bool hasIntroductionInfo;
+
+  private:
+    void operator=(const TransitiveCompileOptions&) = delete;
+};
+# 3951 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class ReadOnlyCompileOptions : public TransitiveCompileOptions
+{
+    friend class CompileOptions;
+
+  protected:
+    ReadOnlyCompileOptions()
+      : TransitiveCompileOptions(),
+        lineno(1),
+        column(0),
+        isRunOnce(false),
+        noScriptRval(false)
+    { }
+
+
+
+    void copyPODOptions(const ReadOnlyCompileOptions& rhs);
+
+  public:
+
+
+    bool mutedErrors() const { return mutedErrors_; }
+    const char* filename() const { return filename_; }
+    const char* introducerFilename() const { return introducerFilename_; }
+    const char16_t* sourceMapURL() const { return sourceMapURL_; }
+    virtual JSObject* element() const = 0;
+    virtual JSString* elementAttributeName() const = 0;
+    virtual JSScript* introductionScript() const = 0;
+
+
+    unsigned lineno;
+    unsigned column;
+
+    bool isRunOnce;
+    bool noScriptRval;
+
+  private:
+    void operator=(const ReadOnlyCompileOptions&) = delete;
+};
+# 4003 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class OwningCompileOptions : public ReadOnlyCompileOptions
+{
+    PersistentRootedObject elementRoot;
+    PersistentRootedString elementAttributeNameRoot;
+    PersistentRootedScript introductionScriptRoot;
+
+  public:
+
+
+
+
+    explicit OwningCompileOptions(JSContext* cx);
+    ~OwningCompileOptions();
+
+    JSObject* element() const override { return elementRoot; }
+    JSString* elementAttributeName() const override { return elementAttributeNameRoot; }
+    JSScript* introductionScript() const override { return introductionScriptRoot; }
+
+
+    bool copy(JSContext* cx, const ReadOnlyCompileOptions& rhs);
+
+
+    bool setFile(JSContext* cx, const char* f);
+    bool setFileAndLine(JSContext* cx, const char* f, unsigned l);
+    bool setSourceMapURL(JSContext* cx, const char16_t* s);
+    bool setIntroducerFilename(JSContext* cx, const char* s);
+
+
+    OwningCompileOptions& setLine(unsigned l) { lineno = l; return *this; }
+    OwningCompileOptions& setElement(JSObject* e) {
+        elementRoot = e;
+        return *this;
+    }
+    OwningCompileOptions& setElementAttributeName(JSString* p) {
+        elementAttributeNameRoot = p;
+        return *this;
+    }
+    OwningCompileOptions& setIntroductionScript(JSScript* s) {
+        introductionScriptRoot = s;
+        return *this;
+    }
+    OwningCompileOptions& setMutedErrors(bool mute) {
+        mutedErrors_ = mute;
+        return *this;
+    }
+    OwningCompileOptions& setVersion(JSVersion v) {
+        version = v;
+        versionSet = true;
+        return *this;
+    }
+    OwningCompileOptions& setUTF8(bool u) { utf8 = u; return *this; }
+    OwningCompileOptions& setColumn(unsigned c) { column = c; return *this; }
+    OwningCompileOptions& setIsRunOnce(bool once) { isRunOnce = once; return *this; }
+    OwningCompileOptions& setNoScriptRval(bool nsr) { noScriptRval = nsr; return *this; }
+    OwningCompileOptions& setSelfHostingMode(bool shm) { selfHostingMode = shm; return *this; }
+    OwningCompileOptions& setCanLazilyParse(bool clp) { canLazilyParse = clp; return *this; }
+    OwningCompileOptions& setSourceIsLazy(bool l) { sourceIsLazy = l; return *this; }
+    OwningCompileOptions& setIntroductionType(const char* t) { introductionType = t; return *this; }
+    bool setIntroductionInfo(JSContext* cx, const char* introducerFn, const char* intro,
+                             unsigned line, JSScript* script, uint32_t offset)
+    {
+        if (!setIntroducerFilename(cx, introducerFn))
+            return false;
+        introductionType = intro;
+        introductionLineno = line;
+        introductionScriptRoot = script;
+        introductionOffset = offset;
+        hasIntroductionInfo = true;
+        return true;
+    }
+
+  private:
+    void operator=(const CompileOptions& rhs) = delete;
+};
+# 4085 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class CompileOptions final : public ReadOnlyCompileOptions
+{
+    RootedObject elementRoot;
+    RootedString elementAttributeNameRoot;
+    RootedScript introductionScriptRoot;
+
+  public:
+    explicit CompileOptions(JSContext* cx, JSVersion version = JSVERSION_UNKNOWN);
+    CompileOptions(JSContext* cx, const ReadOnlyCompileOptions& rhs)
+      : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx),
+        introductionScriptRoot(cx)
+    {
+        copyPODOptions(rhs);
+
+        filename_ = rhs.filename();
+        introducerFilename_ = rhs.introducerFilename();
+        sourceMapURL_ = rhs.sourceMapURL();
+        elementRoot = rhs.element();
+        elementAttributeNameRoot = rhs.elementAttributeName();
+        introductionScriptRoot = rhs.introductionScript();
+    }
+
+    CompileOptions(JSContext* cx, const TransitiveCompileOptions& rhs)
+      : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx),
+        introductionScriptRoot(cx)
+    {
+        copyPODTransitiveOptions(rhs);
+
+        filename_ = rhs.filename();
+        introducerFilename_ = rhs.introducerFilename();
+        sourceMapURL_ = rhs.sourceMapURL();
+        elementRoot = rhs.element();
+        elementAttributeNameRoot = rhs.elementAttributeName();
+        introductionScriptRoot = rhs.introductionScript();
+    }
+
+    JSObject* element() const override { return elementRoot; }
+    JSString* elementAttributeName() const override { return elementAttributeNameRoot; }
+    JSScript* introductionScript() const override { return introductionScriptRoot; }
+
+    CompileOptions& setFile(const char* f) { filename_ = f; return *this; }
+    CompileOptions& setLine(unsigned l) { lineno = l; return *this; }
+    CompileOptions& setFileAndLine(const char* f, unsigned l) {
+        filename_ = f; lineno = l; return *this;
+    }
+    CompileOptions& setSourceMapURL(const char16_t* s) { sourceMapURL_ = s; return *this; }
+    CompileOptions& setElement(JSObject* e) { elementRoot = e; return *this; }
+    CompileOptions& setElementAttributeName(JSString* p) {
+        elementAttributeNameRoot = p;
+        return *this;
+    }
+    CompileOptions& setIntroductionScript(JSScript* s) {
+        introductionScriptRoot = s;
+        return *this;
+    }
+    CompileOptions& setMutedErrors(bool mute) {
+        mutedErrors_ = mute;
+        return *this;
+    }
+    CompileOptions& setVersion(JSVersion v) {
+        version = v;
+        versionSet = true;
+        return *this;
+    }
+    CompileOptions& setUTF8(bool u) { utf8 = u; return *this; }
+    CompileOptions& setColumn(unsigned c) { column = c; return *this; }
+    CompileOptions& setIsRunOnce(bool once) { isRunOnce = once; return *this; }
+    CompileOptions& setNoScriptRval(bool nsr) { noScriptRval = nsr; return *this; }
+    CompileOptions& setSelfHostingMode(bool shm) { selfHostingMode = shm; return *this; }
+    CompileOptions& setCanLazilyParse(bool clp) { canLazilyParse = clp; return *this; }
+    CompileOptions& setSourceIsLazy(bool l) { sourceIsLazy = l; return *this; }
+    CompileOptions& setIntroductionType(const char* t) { introductionType = t; return *this; }
+    CompileOptions& setIntroductionInfo(const char* introducerFn, const char* intro,
+                                        unsigned line, JSScript* script, uint32_t offset)
+    {
+        introducerFilename_ = introducerFn;
+        introductionType = intro;
+        introductionLineno = line;
+        introductionScriptRoot = script;
+        introductionOffset = offset;
+        hasIntroductionInfo = true;
+        return *this;
+    }
+    CompileOptions& maybeMakeStrictMode(bool strict) {
+        strictOption = strictOption || strict;
+        return *this;
+    }
+
+  private:
+    void operator=(const CompileOptions& rhs) = delete;
+};
+
+
+
+
+extern bool
+Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+        SourceBufferHolder& srcBuf, JS::MutableHandleScript script);
+
+extern bool
+Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+        const char* bytes, size_t length, JS::MutableHandleScript script);
+
+extern bool
+Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+        const char16_t* chars, size_t length, JS::MutableHandleScript script);
+
+extern bool
+Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+        FILE* file, JS::MutableHandleScript script);
+
+extern bool
+Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+        const char* filename, JS::MutableHandleScript script);
+
+extern bool
+CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
+                            SourceBufferHolder& srcBuf, JS::MutableHandleScript script);
+
+extern bool
+CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
+                            const char* bytes, size_t length, JS::MutableHandleScript script);
+
+extern bool
+CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
+                            const char16_t* chars, size_t length, JS::MutableHandleScript script);
+
+extern bool
+CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
+                            FILE* file, JS::MutableHandleScript script);
+
+extern bool
+CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
+                            const char* filename, JS::MutableHandleScript script);
+
+extern bool
+CanCompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options, size_t length);
+# 4240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+CompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options,
+                 const char16_t* chars, size_t length,
+                 OffThreadCompileCallback callback, void* callbackData);
+
+extern JSScript*
+FinishOffThreadScript(JSContext* cx, void* token);
+
+extern void
+CancelOffThreadScript(JSContext* cx, void* token);
+
+extern bool
+CompileOffThreadModule(JSContext* cx, const ReadOnlyCompileOptions& options,
+                       const char16_t* chars, size_t length,
+                       OffThreadCompileCallback callback, void* callbackData);
+
+extern JSObject*
+FinishOffThreadModule(JSContext* cx, void* token);
+
+extern void
+CancelOffThreadModule(JSContext* cx, void* token);
+
+extern bool
+DecodeOffThreadScript(JSContext* cx, const ReadOnlyCompileOptions& options,
+                      mozilla::Vector<uint8_t>& buffer , size_t cursor,
+                      OffThreadCompileCallback callback, void* callbackData);
+
+extern JSScript*
+FinishOffThreadScriptDecoder(JSContext* cx, void* token);
+
+extern void
+CancelOffThreadScriptDecoder(JSContext* cx, void* token);
+# 4280 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+CompileFunction(JSContext* cx, AutoObjectVector& envChain,
+                const ReadOnlyCompileOptions& options,
+                const char* name, unsigned nargs, const char* const* argnames,
+                const char16_t* chars, size_t length, JS::MutableHandleFunction fun);
+
+
+
+
+extern bool
+CompileFunction(JSContext* cx, AutoObjectVector& envChain,
+                const ReadOnlyCompileOptions& options,
+                const char* name, unsigned nargs, const char* const* argnames,
+                SourceBufferHolder& srcBuf, JS::MutableHandleFunction fun);
+
+
+
+
+extern bool
+CompileFunction(JSContext* cx, AutoObjectVector& envChain,
+                const ReadOnlyCompileOptions& options,
+                const char* name, unsigned nargs, const char* const* argnames,
+                const char* bytes, size_t length, JS::MutableHandleFunction fun);
+
+}
+
+extern JSString*
+JS_DecompileScript(JSContext* cx, JS::Handle<JSScript*> script, const char* name, unsigned indent);
+
+
+
+
+
+
+
+extern JSString*
+JS_DecompileFunction(JSContext* cx, JS::Handle<JSFunction*> fun, unsigned indent);
+# 4339 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ExecuteScript(JSContext* cx, JS::HandleScript script, JS::MutableHandleValue rval);
+
+extern bool
+JS_ExecuteScript(JSContext* cx, JS::HandleScript script);
+
+
+
+
+
+
+extern bool
+JS_ExecuteScript(JSContext* cx, JS::AutoObjectVector& envChain,
+                 JS::HandleScript script, JS::MutableHandleValue rval);
+
+extern bool
+JS_ExecuteScript(JSContext* cx, JS::AutoObjectVector& envChain, JS::HandleScript script);
+
+namespace JS {
+
+
+
+
+
+extern bool
+CloneAndExecuteScript(JSContext* cx, JS::Handle<JSScript*> script,
+                      JS::MutableHandleValue rval);
+
+}
+
+namespace JS {
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
+         SourceBufferHolder& srcBuf, JS::MutableHandleValue rval);
+
+
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options,
+         SourceBufferHolder& srcBuf, JS::MutableHandleValue rval);
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
+         const char16_t* chars, size_t length, JS::MutableHandleValue rval);
+
+
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options,
+         const char16_t* chars, size_t length, JS::MutableHandleValue rval);
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
+         const char* bytes, size_t length, JS::MutableHandleValue rval);
+
+
+
+
+extern bool
+Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
+         const char* filename, JS::MutableHandleValue rval);
+
+
+
+
+extern JSFunction*
+GetModuleResolveHook(JSContext* cx);
+
+
+
+
+extern void
+SetModuleResolveHook(JSContext* cx, JS::HandleFunction func);
+
+
+
+
+
+extern bool
+CompileModule(JSContext* cx, const ReadOnlyCompileOptions& options,
+              SourceBufferHolder& srcBuf, JS::MutableHandleObject moduleRecord);
+
+
+
+
+
+extern void
+SetModuleHostDefinedField(JSObject* module, const JS::Value& value);
+
+
+
+
+extern JS::Value
+GetModuleHostDefinedField(JSObject* module);
+# 4458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+ModuleDeclarationInstantiation(JSContext* cx, JS::HandleObject moduleRecord);
+# 4471 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+ModuleEvaluation(JSContext* cx, JS::HandleObject moduleRecord);
+# 4482 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+GetRequestedModules(JSContext* cx, JS::HandleObject moduleRecord);
+
+
+
+
+extern JSScript*
+GetModuleScript(JSContext* cx, JS::HandleObject moduleRecord);
+
+}
+
+extern bool
+JS_CheckForInterrupt(JSContext* cx);
+# 4509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_AddInterruptCallback(JSContext* cx, JSInterruptCallback callback);
+
+extern bool
+JS_DisableInterruptCallback(JSContext* cx);
+
+extern void
+JS_ResetInterruptCallback(JSContext* cx, bool enable);
+
+extern void
+JS_RequestInterruptCallback(JSContext* cx);
+
+namespace JS {
+# 4530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+SetGetIncumbentGlobalCallback(JSContext* cx, JSGetIncumbentGlobalCallback callback);
+# 4542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+SetEnqueuePromiseJobCallback(JSContext* cx, JSEnqueuePromiseJobCallback callback,
+                             void* data = nullptr);
+
+
+
+
+
+
+extern void
+SetPromiseRejectionTrackerCallback(JSContext* cx, JSPromiseRejectionTrackerCallback callback,
+                                   void* data = nullptr);
+
+
+
+
+
+
+
+extern JSObject*
+NewPromiseObject(JSContext* cx, JS::HandleObject executor, JS::HandleObject proto = nullptr);
+
+
+
+
+
+extern bool
+IsPromiseObject(JS::HandleObject obj);
+
+
+
+
+extern JSObject*
+GetPromiseConstructor(JSContext* cx);
+
+
+
+
+extern JSObject*
+GetPromisePrototype(JSContext* cx);
+
+
+enum class PromiseState {
+    Pending,
+    Fulfilled,
+    Rejected
+};
+
+
+
+
+extern PromiseState
+GetPromiseState(JS::HandleObject promise);
+
+
+
+
+uint64_t
+GetPromiseID(JS::HandleObject promise);
+
+
+
+
+
+extern JS::Value
+GetPromiseResult(JS::HandleObject promise);
+
+
+
+
+
+extern JSObject*
+GetPromiseAllocationSite(JS::HandleObject promise);
+
+extern JSObject*
+GetPromiseResolutionSite(JS::HandleObject promise);
+# 4631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+CallOriginalPromiseResolve(JSContext* cx, JS::HandleValue resolutionValue);
+
+
+
+
+
+extern JSObject*
+CallOriginalPromiseReject(JSContext* cx, JS::HandleValue rejectionValue);
+
+
+
+
+
+
+
+extern bool
+ResolvePromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue resolutionValue);
+
+
+
+
+
+
+
+extern bool
+RejectPromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue rejectionValue);
+# 4667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+CallOriginalPromiseThen(JSContext* cx, JS::HandleObject promise,
+                        JS::HandleObject onResolve, JS::HandleObject onReject);
+# 4682 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+AddPromiseReactions(JSContext* cx, JS::HandleObject promise,
+                    JS::HandleObject onResolve, JS::HandleObject onReject);
+# 4697 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+GetWaitForAllPromise(JSContext* cx, const JS::AutoObjectVector& promises);
+# 4707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+struct AsyncTask
+{
+    AsyncTask() : user(nullptr) {}
+    virtual ~AsyncTask() {}
+
+
+
+
+
+    virtual void finish(JSContext* cx) = 0;
+    virtual void cancel(JSContext* cx) = 0;
+
+
+    void* user;
+};
+# 4734 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef bool
+(*StartAsyncTaskCallback)(JSContext* cx, AsyncTask* task);
+# 4744 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef bool
+(*FinishAsyncTaskCallback)(AsyncTask* task);
+
+
+
+
+extern void
+SetAsyncTaskCallbacks(JSContext* cx, StartAsyncTaskCallback start, FinishAsyncTaskCallback finish);
+# 4770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class AutoSetAsyncStackForNewCalls
+{
+    JSContext* cx;
+    RootedObject oldAsyncStack;
+    const char* oldAsyncCause;
+    bool oldAsyncCallIsExplicit;
+
+  public:
+    enum class AsyncCallKind {
+
+
+        IMPLICIT,
+
+
+        EXPLICIT
+    };
+# 4796 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    AutoSetAsyncStackForNewCalls(JSContext* cx, HandleObject stack,
+                                 const char* asyncCause,
+                                 AsyncCallKind kind = AsyncCallKind::IMPLICIT);
+    ~AutoSetAsyncStackForNewCalls();
+};
+
+}
+# 4815 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSString*
+JS_NewStringCopyN(JSContext* cx, const char* s, size_t n);
+
+extern JSString*
+JS_NewStringCopyZ(JSContext* cx, const char* s);
+
+extern JSString*
+JS_NewStringCopyUTF8Z(JSContext* cx, const JS::ConstUTF8CharsZ s);
+
+extern JSString*
+JS_NewStringCopyUTF8N(JSContext* cx, const JS::UTF8Chars s);
+
+extern JSString*
+JS_AtomizeAndPinJSString(JSContext* cx, JS::HandleString str);
+
+extern JSString*
+JS_AtomizeStringN(JSContext* cx, const char* s, size_t length);
+
+extern JSString*
+JS_AtomizeString(JSContext* cx, const char* s);
+
+extern JSString*
+JS_AtomizeAndPinStringN(JSContext* cx, const char* s, size_t length);
+
+extern JSString*
+JS_AtomizeAndPinString(JSContext* cx, const char* s);
+
+extern JSString*
+JS_NewUCString(JSContext* cx, char16_t* chars, size_t length);
+
+extern JSString*
+JS_NewUCStringCopyN(JSContext* cx, const char16_t* s, size_t n);
+
+extern JSString*
+JS_NewUCStringCopyZ(JSContext* cx, const char16_t* s);
+
+extern JSString*
+JS_AtomizeUCStringN(JSContext* cx, const char16_t* s, size_t length);
+
+extern JSString*
+JS_AtomizeUCString(JSContext* cx, const char16_t* s);
+
+extern JSString*
+JS_AtomizeAndPinUCStringN(JSContext* cx, const char16_t* s, size_t length);
+
+extern JSString*
+JS_AtomizeAndPinUCString(JSContext* cx, const char16_t* s);
+
+extern bool
+JS_CompareStrings(JSContext* cx, JSString* str1, JSString* str2, int32_t* result);
+
+extern bool
+JS_StringEqualsAscii(JSContext* cx, JSString* str, const char* asciiBytes, bool* match);
+
+extern size_t
+JS_PutEscapedString(JSContext* cx, char* buffer, size_t size, JSString* str, char quote);
+
+extern bool
+JS_FileEscapedString(FILE* fp, JSString* str, char quote);
+# 4914 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern size_t
+JS_GetStringLength(JSString* str);
+
+extern bool
+JS_StringIsFlat(JSString* str);
+
+
+extern bool
+JS_StringHasLatin1Chars(JSString* str);
+
+extern const JS::Latin1Char*
+JS_GetLatin1StringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str,
+                                 size_t* length);
+
+extern const char16_t*
+JS_GetTwoByteStringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str,
+                                  size_t* length);
+
+extern bool
+JS_GetStringCharAt(JSContext* cx, JSString* str, size_t index, char16_t* res);
+
+extern char16_t
+JS_GetFlatStringCharAt(JSFlatString* str, size_t index);
+
+extern const char16_t*
+JS_GetTwoByteExternalStringChars(JSString* str);
+
+extern bool
+JS_CopyStringChars(JSContext* cx, mozilla::Range<char16_t> dest, JSString* str);
+
+extern JSFlatString*
+JS_FlattenString(JSContext* cx, JSString* str);
+
+extern const JS::Latin1Char*
+JS_GetLatin1FlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str);
+
+extern const char16_t*
+JS_GetTwoByteFlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str);
+
+static __attribute__((always_inline)) inline JSFlatString*
+JSID_TO_FLAT_STRING(jsid id)
+{
+    do { } while (0);
+    return (JSFlatString*)((id.asBits));
+}
+
+static __attribute__((always_inline)) inline JSFlatString*
+JS_ASSERT_STRING_IS_FLAT(JSString* str)
+{
+    do { } while (0);
+    return (JSFlatString*)str;
+}
+
+static __attribute__((always_inline)) inline JSString*
+JS_FORGET_STRING_FLATNESS(JSFlatString* fstr)
+{
+    return (JSString*)fstr;
+}
+
+
+
+
+
+extern bool
+JS_FlatStringEqualsAscii(JSFlatString* str, const char* asciiBytes);
+
+extern size_t
+JS_PutEscapedFlatString(char* buffer, size_t size, JSFlatString* str, char quote);
+
+
+
+
+
+
+extern JSString*
+JS_NewDependentString(JSContext* cx, JS::HandleString str, size_t start,
+                      size_t length);
+
+
+
+
+
+extern JSString*
+JS_ConcatStrings(JSContext* cx, JS::HandleString left, JS::HandleString right);
+# 5012 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+bool
+JS_DecodeBytes(JSContext* cx, const char* src, size_t srclen, char16_t* dst,
+               size_t* dstlenp);
+
+
+
+
+
+char*
+JS_EncodeString(JSContext* cx, JSString* str);
+
+
+
+
+char*
+JS_EncodeStringToUTF8(JSContext* cx, JS::HandleString str);
+
+
+
+
+
+
+size_t
+JS_GetStringEncodingLength(JSContext* cx, JSString* str);
+# 5045 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+size_t
+JS_EncodeStringToBuffer(JSContext* cx, JSString* str, char* buffer, size_t length);
+
+class JSAutoByteString
+{
+  public:
+    JSAutoByteString(JSContext* cx, JSString* str
+                                                    )
+      : mBytes(JS_EncodeString(cx, str))
+    {
+        do { } while (0);
+        do { } while (0);
+    }
+
+    explicit JSAutoByteString()
+      : mBytes(nullptr)
+    {
+        do { } while (0);
+    }
+
+    ~JSAutoByteString() {
+        JS_free(nullptr, mBytes);
+    }
+
+
+    void initBytes(char* bytes) {
+        do { } while (0);
+        mBytes = bytes;
+    }
+
+    char* encodeLatin1(JSContext* cx, JSString* str) {
+        do { } while (0);
+        do { } while (0);
+        mBytes = JS_EncodeString(cx, str);
+        return mBytes;
+    }
+
+    char* encodeUtf8(JSContext* cx, JS::HandleString str) {
+        do { } while (0);
+        do { } while (0);
+        mBytes = JS_EncodeStringToUTF8(cx, str);
+        return mBytes;
+    }
+
+    void clear() {
+        js_free(mBytes);
+        mBytes = nullptr;
+    }
+
+    char* ptr() const {
+        return mBytes;
+    }
+
+    bool operator!() const {
+        return !mBytes;
+    }
+
+    size_t length() const {
+        if (!mBytes)
+            return 0;
+        return strlen(mBytes);
+    }
+
+  private:
+    char* mBytes;
+
+
+
+    JSAutoByteString(const JSAutoByteString& another);
+    JSAutoByteString& operator=(const JSAutoByteString& another);
+};
+
+namespace JS {
+
+extern JSAddonId*
+NewAddonId(JSContext* cx, JS::HandleString str);
+
+extern JSString*
+StringOfAddonId(JSAddonId* id);
+
+extern JSAddonId*
+AddonIdOfObject(JSObject* obj);
+
+}
+
+
+
+
+
+
+namespace JS {
+# 5144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+Symbol*
+NewSymbol(JSContext* cx, HandleString description);
+# 5154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+Symbol*
+GetSymbolFor(JSContext* cx, HandleString key);
+
+
+
+
+
+
+
+JSString*
+GetSymbolDescription(HandleSymbol symbol);
+# 5181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+enum class SymbolCode : uint32_t {
+
+
+    isConcatSpreadable, iterator, match, replace, search, species, hasInstance, split, toPrimitive, toStringTag, unscopables, asyncIterator,
+
+    Limit,
+    InSymbolRegistry = 0xfffffffe,
+    UniqueSymbol = 0xffffffff
+};
+
+
+const size_t WellKnownSymbolLimit = size_t(SymbolCode::Limit);
+
+
+
+
+
+
+SymbolCode
+GetSymbolCode(Handle<Symbol*> symbol);
+
+
+
+
+
+
+
+Symbol*
+GetWellKnownSymbol(JSContext* cx, SymbolCode which);
+
+
+
+
+
+inline bool
+PropertySpecNameIsSymbol(const char* name)
+{
+    uintptr_t u = reinterpret_cast<uintptr_t>(name);
+    return u != 0 && u - 1 < WellKnownSymbolLimit;
+}
+
+bool
+PropertySpecNameEqualsId(const char* name, HandleId id);
+# 5233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+bool
+PropertySpecNameToPermanentId(JSContext* cx, const char* name, jsid* idp);
+
+}
+
+
+
+
+
+typedef bool (* JSONWriteCallback)(const char16_t* buf, uint32_t len, void* data);
+
+
+
+
+bool
+JS_Stringify(JSContext* cx, JS::MutableHandleValue value, JS::HandleObject replacer,
+             JS::HandleValue space, JSONWriteCallback callback, void* data);
+
+namespace JS {
+# 5270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+bool
+ToJSONMaybeSafely(JSContext* cx, JS::HandleObject input,
+                  JSONWriteCallback callback, void* data);
+
+}
+
+
+
+
+bool
+JS_ParseJSON(JSContext* cx, const char16_t* chars, uint32_t len, JS::MutableHandleValue vp);
+
+bool
+JS_ParseJSON(JSContext* cx, JS::HandleString str, JS::MutableHandleValue vp);
+
+bool
+JS_ParseJSONWithReviver(JSContext* cx, const char16_t* chars, uint32_t len, JS::HandleValue reviver,
+                        JS::MutableHandleValue vp);
+
+bool
+JS_ParseJSONWithReviver(JSContext* cx, JS::HandleString str, JS::HandleValue reviver,
+                        JS::MutableHandleValue vp);
+# 5302 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_SetDefaultLocale(JSContext* cx, const char* locale);
+
+
+
+
+extern JS::UniqueChars
+JS_GetDefaultLocale(JSContext* cx);
+
+
+
+
+extern void
+JS_ResetDefaultLocale(JSContext* cx);
+
+
+
+
+struct JSLocaleCallbacks {
+    JSLocaleToUpperCase localeToUpperCase;
+    JSLocaleToLowerCase localeToLowerCase;
+    JSLocaleCompare localeCompare;
+    JSLocaleToUnicode localeToUnicode;
+};
+
+
+
+
+
+extern void
+JS_SetLocaleCallbacks(JSContext* cx, const JSLocaleCallbacks* callbacks);
+
+
+
+
+
+extern const JSLocaleCallbacks*
+JS_GetLocaleCallbacks(JSContext* cx);
+
+
+
+
+
+
+
+namespace JS {
+const uint16_t MaxNumErrorArguments = 10;
+};
+
+
+
+
+
+extern void
+JS_ReportErrorASCII(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+extern void
+JS_ReportErrorLatin1(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+extern void
+JS_ReportErrorUTF8(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+
+
+
+extern void
+JS_ReportErrorNumberASCII(JSContext* cx, JSErrorCallback errorCallback,
+                          void* userRef, const unsigned errorNumber, ...);
+
+extern void
+JS_ReportErrorNumberASCIIVA(JSContext* cx, JSErrorCallback errorCallback,
+                            void* userRef, const unsigned errorNumber, va_list ap);
+
+extern void
+JS_ReportErrorNumberLatin1(JSContext* cx, JSErrorCallback errorCallback,
+                           void* userRef, const unsigned errorNumber, ...);
+
+
+extern void
+JS_ReportErrorNumberLatin1VA(JSContext* cx, JSErrorCallback errorCallback,
+                             void* userRef, const unsigned errorNumber, va_list ap);
+
+
+extern void
+JS_ReportErrorNumberUTF8(JSContext* cx, JSErrorCallback errorCallback,
+                           void* userRef, const unsigned errorNumber, ...);
+
+
+extern void
+JS_ReportErrorNumberUTF8VA(JSContext* cx, JSErrorCallback errorCallback,
+                           void* userRef, const unsigned errorNumber, va_list ap);
+
+
+
+
+
+extern void
+JS_ReportErrorNumberUC(JSContext* cx, JSErrorCallback errorCallback,
+                     void* userRef, const unsigned errorNumber, ...);
+
+extern void
+JS_ReportErrorNumberUCArray(JSContext* cx, JSErrorCallback errorCallback,
+                            void* userRef, const unsigned errorNumber,
+                            const char16_t** args);
+
+
+
+
+
+
+
+extern bool
+JS_ReportWarningASCII(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+extern bool
+JS_ReportWarningLatin1(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+extern bool
+JS_ReportWarningUTF8(JSContext* cx, const char* format, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+extern bool
+JS_ReportErrorFlagsAndNumberASCII(JSContext* cx, unsigned flags,
+                                  JSErrorCallback errorCallback, void* userRef,
+                                  const unsigned errorNumber, ...);
+
+extern bool
+JS_ReportErrorFlagsAndNumberLatin1(JSContext* cx, unsigned flags,
+                                   JSErrorCallback errorCallback, void* userRef,
+                                   const unsigned errorNumber, ...);
+
+extern bool
+JS_ReportErrorFlagsAndNumberUTF8(JSContext* cx, unsigned flags,
+                                 JSErrorCallback errorCallback, void* userRef,
+                                 const unsigned errorNumber, ...);
+
+extern bool
+JS_ReportErrorFlagsAndNumberUC(JSContext* cx, unsigned flags,
+                               JSErrorCallback errorCallback, void* userRef,
+                               const unsigned errorNumber, ...);
+
+
+
+
+extern void
+JS_ReportOutOfMemory(JSContext* cx);
+
+
+
+
+extern void
+JS_ReportAllocationOverflow(JSContext* cx);
+
+
+
+
+
+class JSErrorBase
+{
+
+
+    JS::ConstUTF8CharsZ message_;
+
+  public:
+    JSErrorBase()
+      : filename(nullptr), lineno(0), column(0),
+        errorNumber(0),
+        ownsMessage_(false)
+    {}
+
+    ~JSErrorBase() {
+        freeMessage();
+    }
+
+
+    const char* filename;
+
+
+    unsigned lineno;
+
+
+    unsigned column;
+
+
+    unsigned errorNumber;
+
+  private:
+    bool ownsMessage_ : 1;
+
+  public:
+    const JS::ConstUTF8CharsZ message() const {
+        return message_;
+    }
+
+    void initOwnedMessage(const char* messageArg) {
+        initBorrowedMessage(messageArg);
+        ownsMessage_ = true;
+    }
+    void initBorrowedMessage(const char* messageArg) {
+        do { } while (0);
+        message_ = JS::ConstUTF8CharsZ(messageArg, strlen(messageArg));
+    }
+
+    JSString* newMessageString(JSContext* cx);
+
+  private:
+    void freeMessage();
+};
+
+
+
+
+class JSErrorNotes
+{
+  public:
+    class Note : public JSErrorBase
+    {};
+
+  private:
+
+    js::Vector<js::UniquePtr<Note>, 1, js::SystemAllocPolicy> notes_;
+
+  public:
+    JSErrorNotes();
+    ~JSErrorNotes();
+
+
+    bool addNoteASCII(JSContext* cx,
+                      const char* filename, unsigned lineno, unsigned column,
+                      JSErrorCallback errorCallback, void* userRef,
+                      const unsigned errorNumber, ...);
+    bool addNoteLatin1(JSContext* cx,
+                       const char* filename, unsigned lineno, unsigned column,
+                       JSErrorCallback errorCallback, void* userRef,
+                       const unsigned errorNumber, ...);
+    bool addNoteUTF8(JSContext* cx,
+                     const char* filename, unsigned lineno, unsigned column,
+                     JSErrorCallback errorCallback, void* userRef,
+                     const unsigned errorNumber, ...);
+
+    size_t length();
+
+
+    js::UniquePtr<JSErrorNotes> copy(JSContext* cx);
+
+    class iterator : public std::iterator<std::input_iterator_tag, js::UniquePtr<Note>>
+    {
+        js::UniquePtr<Note>* note_;
+      public:
+        explicit iterator(js::UniquePtr<Note>* note = nullptr) : note_(note)
+        {}
+
+        bool operator==(iterator other) const {
+            return note_ == other.note_;
+        }
+        bool operator!=(iterator other) const {
+            return !(*this == other);
+        }
+        iterator& operator++() {
+            note_++;
+            return *this;
+        }
+        reference operator*() {
+            return *note_;
+        }
+    };
+    iterator begin();
+    iterator end();
+};
+
+
+
+
+class JSErrorReport : public JSErrorBase
+{
+
+
+    const char16_t* linebuf_;
+
+
+    size_t linebufLength_;
+
+
+    size_t tokenOffset_;
+
+  public:
+    JSErrorReport()
+      : linebuf_(nullptr), linebufLength_(0), tokenOffset_(0),
+        notes(nullptr),
+        flags(0), exnType(0), isMuted(false),
+        ownsLinebuf_(false)
+    {}
+
+    ~JSErrorReport() {
+        freeLinebuf();
+    }
+
+
+    js::UniquePtr<JSErrorNotes> notes;
+
+
+    unsigned flags;
+
+
+    int16_t exnType;
+
+
+    bool isMuted : 1;
+
+  private:
+    bool ownsLinebuf_ : 1;
+
+  public:
+    const char16_t* linebuf() const {
+        return linebuf_;
+    }
+    size_t linebufLength() const {
+        return linebufLength_;
+    }
+    size_t tokenOffset() const {
+        return tokenOffset_;
+    }
+    void initOwnedLinebuf(const char16_t* linebufArg, size_t linebufLengthArg,
+                          size_t tokenOffsetArg) {
+        initBorrowedLinebuf(linebufArg, linebufLengthArg, tokenOffsetArg);
+        ownsLinebuf_ = true;
+    }
+    void initBorrowedLinebuf(const char16_t* linebufArg, size_t linebufLengthArg,
+                             size_t tokenOffsetArg);
+
+  private:
+    void freeLinebuf();
+};
+# 5662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+namespace JS {
+
+using WarningReporter = void (*)(JSContext* cx, JSErrorReport* report);
+
+extern WarningReporter
+SetWarningReporter(JSContext* cx, WarningReporter reporter);
+
+extern WarningReporter
+GetWarningReporter(JSContext* cx);
+
+extern bool
+CreateError(JSContext* cx, JSExnType type, HandleObject stack,
+            HandleString fileName, uint32_t lineNumber, uint32_t columnNumber,
+            JSErrorReport* report, HandleString message, MutableHandleValue rval);
+
+
+
+
+
+
+
+extern JSObject*
+NewWeakMapObject(JSContext* cx);
+
+extern bool
+IsWeakMapObject(JSObject* obj);
+
+extern bool
+GetWeakMapEntry(JSContext* cx, JS::HandleObject mapObj, JS::HandleObject key,
+                JS::MutableHandleValue val);
+
+extern bool
+SetWeakMapEntry(JSContext* cx, JS::HandleObject mapObj, JS::HandleObject key,
+                JS::HandleValue val);
+
+
+
+
+extern JSObject*
+NewMapObject(JSContext* cx);
+
+extern uint32_t
+MapSize(JSContext* cx, HandleObject obj);
+
+extern bool
+MapGet(JSContext* cx, HandleObject obj,
+       HandleValue key, MutableHandleValue rval);
+
+extern bool
+MapHas(JSContext* cx, HandleObject obj, HandleValue key, bool* rval);
+
+extern bool
+MapSet(JSContext* cx, HandleObject obj, HandleValue key, HandleValue val);
+
+extern bool
+MapDelete(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
+
+extern bool
+MapClear(JSContext* cx, HandleObject obj);
+
+extern bool
+MapKeys(JSContext* cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+MapValues(JSContext* cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+MapEntries(JSContext* cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+MapForEach(JSContext *cx, HandleObject obj, HandleValue callbackFn, HandleValue thisVal);
+
+
+
+
+extern JSObject *
+NewSetObject(JSContext *cx);
+
+extern uint32_t
+SetSize(JSContext *cx, HandleObject obj);
+
+extern bool
+SetHas(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
+
+extern bool
+SetDelete(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
+
+extern bool
+SetAdd(JSContext *cx, HandleObject obj, HandleValue key);
+
+extern bool
+SetClear(JSContext *cx, HandleObject obj);
+
+extern bool
+SetKeys(JSContext *cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+SetValues(JSContext *cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+SetEntries(JSContext *cx, HandleObject obj, MutableHandleValue rval);
+
+extern bool
+SetForEach(JSContext *cx, HandleObject obj, HandleValue callbackFn, HandleValue thisVal);
+
+}
+
+
+
+
+
+extern JSObject*
+JS_NewDateObject(JSContext* cx, int year, int mon, int mday, int hour, int min, int sec);
+# 5783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ObjectIsDate(JSContext* cx, JS::HandleObject obj, bool* isDate);
+# 5797 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+JS_NewRegExpObject(JSContext* cx, const char* bytes, size_t length, unsigned flags);
+
+extern JSObject*
+JS_NewUCRegExpObject(JSContext* cx, const char16_t* chars, size_t length, unsigned flags);
+
+extern bool
+JS_SetRegExpInput(JSContext* cx, JS::HandleObject obj, JS::HandleString input);
+
+extern bool
+JS_ClearRegExpStatics(JSContext* cx, JS::HandleObject obj);
+
+extern bool
+JS_ExecuteRegExp(JSContext* cx, JS::HandleObject obj, JS::HandleObject reobj,
+                 char16_t* chars, size_t length, size_t* indexp, bool test,
+                 JS::MutableHandleValue rval);
+
+
+
+extern bool
+JS_ExecuteRegExpNoStatics(JSContext* cx, JS::HandleObject reobj, char16_t* chars, size_t length,
+                          size_t* indexp, bool test, JS::MutableHandleValue rval);
+# 5827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+JS_ObjectIsRegExp(JSContext* cx, JS::HandleObject obj, bool* isRegExp);
+
+extern unsigned
+JS_GetRegExpFlags(JSContext* cx, JS::HandleObject obj);
+
+extern JSString*
+JS_GetRegExpSource(JSContext* cx, JS::HandleObject obj);
+
+
+
+extern bool
+JS_IsExceptionPending(JSContext* cx);
+
+extern bool
+JS_GetPendingException(JSContext* cx, JS::MutableHandleValue vp);
+
+extern void
+JS_SetPendingException(JSContext* cx, JS::HandleValue v);
+
+extern void
+JS_ClearPendingException(JSContext* cx);
+
+namespace JS {
+# 5864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class AutoSaveExceptionState
+{
+  private:
+    JSContext* context;
+    bool wasPropagatingForcedReturn;
+    bool wasOverRecursed;
+    bool wasThrowing;
+    RootedValue exceptionValue;
+
+  public:
+
+
+
+
+    explicit AutoSaveExceptionState(JSContext* cx);
+
+
+
+
+
+    ~AutoSaveExceptionState();
+
+
+
+
+
+    void drop() {
+        wasPropagatingForcedReturn = false;
+        wasOverRecursed = false;
+        wasThrowing = false;
+        exceptionValue.setUndefined();
+    }
+
+
+
+
+
+
+    void restore();
+};
+
+}
+
+
+extern JSExceptionState*
+JS_SaveExceptionState(JSContext* cx);
+
+extern void
+JS_RestoreExceptionState(JSContext* cx, JSExceptionState* state);
+
+extern void
+JS_DropExceptionState(JSContext* cx, JSExceptionState* state);
+# 5924 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSErrorReport*
+JS_ErrorFromException(JSContext* cx, JS::HandleObject obj);
+# 5934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+ExceptionStackOrNull(JS::HandleObject obj);
+
+
+
+
+extern bool
+JS_ThrowStopIteration(JSContext* cx);
+
+extern bool
+JS_IsStopIteration(const JS::Value& v);
+# 5956 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+JS_AbortIfWrongThread(JSContext* cx);
+# 5966 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern JSObject*
+JS_NewObjectForConstructor(JSContext* cx, const JSClass* clasp, const JS::CallArgs& args);
+
+
+
+
+
+
+extern void
+JS_GetGCZealBits(JSContext* cx, uint32_t* zealBits, uint32_t* frequency, uint32_t* nextScheduled);
+
+extern void
+JS_SetGCZeal(JSContext* cx, uint8_t zeal, uint32_t frequency);
+
+extern void
+JS_ScheduleGC(JSContext* cx, uint32_t count);
+
+
+extern void
+JS_SetParallelParsingEnabled(JSContext* cx, bool enabled);
+
+extern void
+JS_SetOffthreadIonCompilationEnabled(JSContext* cx, bool enabled);
+# 6006 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef enum JSJitCompilerOption {
+
+
+
+    JSJITCOMPILER_BASELINE_WARMUP_TRIGGER, JSJITCOMPILER_ION_WARMUP_TRIGGER, JSJITCOMPILER_ION_GVN_ENABLE, JSJITCOMPILER_ION_FORCE_IC, JSJITCOMPILER_ION_ENABLE, JSJITCOMPILER_ION_INTERRUPT_WITHOUT_SIGNAL, JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS, JSJITCOMPILER_BASELINE_ENABLE, JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE, JSJITCOMPILER_FULL_DEBUG_CHECKS, JSJITCOMPILER_JUMP_THRESHOLD, JSJITCOMPILER_ASMJS_ATOMICS_ENABLE, JSJITCOMPILER_WASM_TEST_MODE, JSJITCOMPILER_WASM_FOLD_OFFSETS,
+
+
+    JSJITCOMPILER_NOT_AN_OPTION
+} JSJitCompilerOption;
+
+extern void
+JS_SetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t value);
+extern bool
+JS_GetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t* valueOut);
+
+
+
+
+extern bool
+JS_IndexToId(JSContext* cx, uint32_t index, JS::MutableHandleId);
+
+
+
+
+
+
+extern bool
+JS_CharsToId(JSContext* cx, JS::TwoByteChars chars, JS::MutableHandleId);
+
+
+
+
+extern bool
+JS_IsIdentifier(JSContext* cx, JS::HandleString str, bool* isIdentifier);
+
+
+
+
+
+
+extern bool
+JS_IsIdentifier(const char16_t* chars, size_t length);
+
+namespace js {
+class ScriptSource;
+}
+
+namespace JS {
+
+class AutoFilename
+{
+  private:
+    js::ScriptSource* ss_;
+    mozilla::Variant<const char*, UniqueChars> filename_;
+
+    AutoFilename(const AutoFilename&) = delete;
+    AutoFilename& operator=(const AutoFilename&) = delete;
+
+  public:
+    AutoFilename()
+      : ss_(nullptr),
+        filename_(mozilla::AsVariant<const char*>(nullptr))
+    {}
+
+    ~AutoFilename() {
+        reset();
+    }
+
+    void reset();
+
+    void setOwned(UniqueChars&& filename);
+    void setUnowned(const char* filename);
+    void setScriptSource(js::ScriptSource* ss);
+
+    const char* get() const;
+};
+# 6091 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+DescribeScriptedCaller(JSContext* cx, AutoFilename* filename = nullptr,
+                       unsigned* lineno = nullptr, unsigned* column = nullptr);
+
+extern JSObject*
+GetScriptedCallerGlobal(JSContext* cx);
+# 6110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+HideScriptedCaller(JSContext* cx);
+
+extern void
+UnhideScriptedCaller(JSContext* cx);
+
+class AutoHideScriptedCaller
+{
+  public:
+    explicit AutoHideScriptedCaller(JSContext* cx
+                                                                   )
+      : mContext(cx)
+    {
+        do { } while (0);
+        HideScriptedCaller(mContext);
+    }
+    ~AutoHideScriptedCaller() {
+        UnhideScriptedCaller(mContext);
+    }
+
+  protected:
+    JSContext* mContext;
+
+};
+
+
+
+
+
+typedef mozilla::Vector<uint8_t> TranscodeBuffer;
+
+enum TranscodeResult
+{
+
+    TranscodeResult_Ok = 0,
+
+
+    TranscodeResult_Failure = 0x100,
+    TranscodeResult_Failure_BadBuildId = TranscodeResult_Failure | 0x1,
+    TranscodeResult_Failure_RunOnceNotSupported = TranscodeResult_Failure | 0x2,
+    TranscodeResult_Failure_AsmJSNotSupported = TranscodeResult_Failure | 0x3,
+    TranscodeResult_Failure_UnknownClassKind = TranscodeResult_Failure | 0x4,
+    TranscodeResult_Failure_WrongCompileOption = TranscodeResult_Failure | 0x5,
+    TranscodeResult_Failure_NotInterpretedFun = TranscodeResult_Failure | 0x6,
+
+
+    TranscodeResult_Throw = 0x200
+};
+
+extern TranscodeResult
+EncodeScript(JSContext* cx, TranscodeBuffer& buffer, JS::HandleScript script);
+
+extern TranscodeResult
+EncodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, JS::HandleObject funobj);
+
+extern TranscodeResult
+DecodeScript(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleScript scriptp,
+             size_t cursorIndex = 0);
+
+extern TranscodeResult
+DecodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleFunction funp,
+                          size_t cursorIndex = 0);
+# 6186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+StartIncrementalEncoding(JSContext* cx, TranscodeBuffer& buffer, JS::HandleScript script);
+
+extern bool
+FinishIncrementalEncoding(JSContext* cx, JS::HandleScript script);
+
+}
+
+namespace js {
+
+enum class StackFormat { SpiderMonkey, V8, Default };
+# 6205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern void
+SetStackFormat(JSContext* cx, StackFormat format);
+
+extern StackFormat
+GetStackFormat(JSContext* cx);
+
+}
+
+namespace JS {
+# 6224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef bool
+(* OpenAsmJSCacheEntryForReadOp)(HandleObject global, const char16_t* begin, const char16_t* limit,
+                                 size_t* size, const uint8_t** memory, intptr_t* handle);
+typedef void
+(* CloseAsmJSCacheEntryForReadOp)(size_t size, const uint8_t* memory, intptr_t handle);
+
+
+enum AsmJSCacheResult
+{
+    AsmJSCache_Success,
+    AsmJSCache_MIN = AsmJSCache_Success,
+    AsmJSCache_ModuleTooSmall,
+    AsmJSCache_SynchronousScript,
+    AsmJSCache_QuotaExceeded,
+    AsmJSCache_StorageInitFailure,
+    AsmJSCache_Disabled_Internal,
+    AsmJSCache_Disabled_ShellFlags,
+    AsmJSCache_Disabled_JitInspector,
+    AsmJSCache_InternalError,
+    AsmJSCache_Disabled_PrivateBrowsing,
+    AsmJSCache_LIMIT
+};
+# 6256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef AsmJSCacheResult
+(* OpenAsmJSCacheEntryForWriteOp)(HandleObject global, const char16_t* begin,
+                                  const char16_t* end, size_t size,
+                                  uint8_t** memory, intptr_t* handle);
+typedef void
+(* CloseAsmJSCacheEntryForWriteOp)(size_t size, uint8_t* memory, intptr_t handle);
+
+struct AsmJSCacheOps
+{
+    OpenAsmJSCacheEntryForReadOp openEntryForRead;
+    CloseAsmJSCacheEntryForReadOp closeEntryForRead;
+    OpenAsmJSCacheEntryForWriteOp openEntryForWrite;
+    CloseAsmJSCacheEntryForWriteOp closeEntryForWrite;
+};
+
+extern void
+SetAsmJSCacheOps(JSContext* cx, const AsmJSCacheOps* callbacks);
+# 6281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef js::Vector<char, 0, js::SystemAllocPolicy> BuildIdCharVector;
+
+typedef bool
+(* BuildIdOp)(BuildIdCharVector* buildId);
+
+extern void
+SetBuildIdOp(JSContext* cx, BuildIdOp buildIdOp);
+# 6315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+struct WasmModule : js::AtomicRefCounted<WasmModule>
+{
+    virtual ~WasmModule() {}
+
+    virtual void serializedSize(size_t* maybeBytecodeSize, size_t* maybeCompiledSize) const = 0;
+    virtual void serialize(uint8_t* maybeBytecodeBegin, size_t maybeBytecodeSize,
+                           uint8_t* maybeCompiledBegin, size_t maybeCompiledSize) const = 0;
+
+    virtual JSObject* createObject(JSContext* cx) = 0;
+};
+
+extern bool
+IsWasmModuleObject(HandleObject obj);
+
+extern RefPtr<WasmModule>
+GetWasmModule(HandleObject obj);
+
+extern bool
+CompiledWasmModuleAssumptionsMatch(PRFileDesc* compiled, BuildIdCharVector&& buildId);
+
+extern RefPtr<WasmModule>
+DeserializeWasmModule(PRFileDesc* bytecode, PRFileDesc* maybeCompiled, BuildIdCharVector&& buildId,
+                      JS::UniqueChars filename, unsigned line, unsigned column);
+# 6356 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+class ForOfIterator {
+  protected:
+    JSContext* cx_;
+# 6373 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+    JS::RootedObject iterator;
+    uint32_t index;
+
+    static const uint32_t NOT_ARRAY = (4294967295U);
+
+    ForOfIterator(const ForOfIterator&) = delete;
+    ForOfIterator& operator=(const ForOfIterator&) = delete;
+
+  public:
+    explicit ForOfIterator(JSContext* cx) : cx_(cx), iterator(cx_), index(NOT_ARRAY) { }
+
+    enum NonIterableBehavior {
+        ThrowOnNonIterable,
+        AllowNonIterable
+    };
+
+
+
+
+
+
+
+    bool init(JS::HandleValue iterable,
+              NonIterableBehavior nonIterableBehavior = ThrowOnNonIterable);
+
+
+
+
+
+    bool next(JS::MutableHandleValue val, bool* done);
+
+
+
+
+
+    void closeThrow();
+
+
+
+
+
+    bool valueIsIterable() const {
+        return iterator;
+    }
+
+  private:
+    inline bool nextFromOptimizedArray(MutableHandleValue val, bool* done);
+    bool materializeArrayIterator();
+};
+# 6431 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef void
+(* LargeAllocationFailureCallback)(void* data);
+
+extern void
+SetLargeAllocationFailureCallback(JSContext* cx, LargeAllocationFailureCallback afc, void* data);
+# 6448 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+typedef void
+(* OutOfMemoryCallback)(JSContext* cx, void* data);
+
+extern void
+SetOutOfMemoryCallback(JSContext* cx, OutOfMemoryCallback cb, void* data);
+
+
+
+
+struct AllFrames { };
+
+
+
+
+struct MaxFrames
+{
+    uint32_t maxFrames;
+
+    explicit MaxFrames(uint32_t max)
+      : maxFrames(max)
+    {
+        do { } while (0);
+    }
+};
+
+
+
+
+
+
+struct FirstSubsumedFrame
+{
+    JSContext* cx;
+    JSPrincipals* principals;
+    bool ignoreSelfHosted;
+
+
+
+
+    explicit FirstSubsumedFrame(JSContext* cx, bool ignoreSelfHostedFrames = true);
+
+    explicit FirstSubsumedFrame(JSContext* ctx, JSPrincipals* p, bool ignoreSelfHostedFrames = true)
+      : cx(ctx)
+      , principals(p)
+      , ignoreSelfHosted(ignoreSelfHostedFrames)
+    {
+        if (principals)
+            JS_HoldPrincipals(principals);
+    }
+
+
+
+    FirstSubsumedFrame(const FirstSubsumedFrame&) = delete;
+    FirstSubsumedFrame& operator=(const FirstSubsumedFrame&) = delete;
+
+    FirstSubsumedFrame(FirstSubsumedFrame&& rhs)
+      : principals(rhs.principals)
+      , ignoreSelfHosted(rhs.ignoreSelfHosted)
+    {
+        do { } while (0);
+        rhs.principals = nullptr;
+    }
+
+    FirstSubsumedFrame& operator=(FirstSubsumedFrame&& rhs) {
+        new (this) FirstSubsumedFrame(mozilla::Move(rhs));
+        return *this;
+    }
+
+    ~FirstSubsumedFrame() {
+        if (principals)
+            JS_DropPrincipals(cx, principals);
+    }
+};
+
+using StackCapture = mozilla::Variant<AllFrames, MaxFrames, FirstSubsumedFrame>;
+# 6542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+CaptureCurrentStack(JSContext* cx, MutableHandleObject stackp,
+                    StackCapture&& capture = StackCapture(AllFrames()));
+# 6560 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+CopyAsyncStack(JSContext* cx, HandleObject asyncStack,
+               HandleString asyncCause, MutableHandleObject stackp,
+               unsigned maxFrameCount);
+# 6595 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+enum class SavedFrameResult {
+    Ok,
+    AccessDenied
+};
+
+enum class SavedFrameSelfHosted {
+    Include,
+    Exclude
+};
+
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameSource(JSContext* cx, HandleObject savedFrame, MutableHandleString sourcep,
+                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameLine(JSContext* cx, HandleObject savedFrame, uint32_t* linep,
+                  SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameColumn(JSContext* cx, HandleObject savedFrame, uint32_t* columnp,
+                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameFunctionDisplayName(JSContext* cx, HandleObject savedFrame, MutableHandleString namep,
+                                 SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameAsyncCause(JSContext* cx, HandleObject savedFrame, MutableHandleString asyncCausep,
+                        SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameAsyncParent(JSContext* cx, HandleObject savedFrame, MutableHandleObject asyncParentp,
+                SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+
+
+
+
+
+
+extern SavedFrameResult
+GetSavedFrameParent(JSContext* cx, HandleObject savedFrame, MutableHandleObject parentp,
+                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
+# 6673 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+BuildStackString(JSContext* cx, HandleObject stack, MutableHandleString stringp,
+                 size_t indent = 0, js::StackFormat stackFormat = js::StackFormat::Default);
+
+
+
+
+
+extern bool
+IsSavedFrame(JSObject* obj);
+
+}
+
+
+
+
+namespace js {
+
+class AutoStopwatch;
+
+
+
+
+
+
+
+struct PerformanceGroup {
+    PerformanceGroup();
+
+
+    uint64_t iteration() const;
+
+
+
+
+    bool isAcquired(uint64_t it) const;
+
+
+
+
+    bool isAcquired(uint64_t it, const AutoStopwatch* owner) const;
+
+
+
+    void acquire(uint64_t it, const AutoStopwatch* owner);
+
+
+
+    void release(uint64_t it, const AutoStopwatch* owner);
+
+
+
+
+
+    uint64_t recentCycles(uint64_t iteration) const;
+    void addRecentCycles(uint64_t iteration, uint64_t cycles);
+
+
+
+    uint64_t recentTicks(uint64_t iteration) const;
+    void addRecentTicks(uint64_t iteration, uint64_t ticks);
+
+
+
+    uint64_t recentCPOW(uint64_t iteration) const;
+    void addRecentCPOW(uint64_t iteration, uint64_t CPOW);
+
+
+    void resetRecentData();
+
+
+
+    bool isActive() const;
+    void setIsActive(bool);
+
+
+
+    bool isUsedInThisIteration() const;
+    void setIsUsedInThisIteration(bool);
+  protected:
+
+
+    virtual void Delete() = 0;
+
+  private:
+
+
+
+
+    uint64_t recentCycles_;
+
+
+
+    uint64_t recentTicks_;
+
+
+
+    uint64_t recentCPOW_;
+
+
+
+    uint64_t iteration_;
+
+
+
+    bool isActive_;
+
+
+
+    bool isUsedInThisIteration_;
+
+
+
+    const AutoStopwatch* owner_;
+
+  public:
+
+    void AddRef();
+    void Release();
+    uint64_t refCount_;
+};
+
+using PerformanceGroupVector = mozilla::Vector<RefPtr<js::PerformanceGroup>, 8, SystemAllocPolicy>;
+
+
+
+
+
+
+
+extern bool
+FlushPerformanceMonitoring(JSContext*);
+
+
+
+
+extern void
+ResetPerformanceMonitoring(JSContext*);
+
+
+
+
+extern void
+DisposePerformanceMonitoring(JSContext*);
+# 6825 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
+extern bool
+SetStopwatchIsMonitoringCPOW(JSContext*, bool);
+extern bool
+GetStopwatchIsMonitoringCPOW(JSContext*);
+extern bool
+SetStopwatchIsMonitoringJank(JSContext*, bool);
+extern bool
+GetStopwatchIsMonitoringJank(JSContext*);
+
+
+extern void
+GetPerfMonitoringTestCpuRescheduling(JSContext*, uint64_t* stayed, uint64_t* moved);
+
+
+
+
+
+
+extern void
+AddCPOWPerformanceDelta(JSContext*, uint64_t delta);
+
+typedef bool
+(*StopwatchStartCallback)(uint64_t, void*);
+extern bool
+SetStopwatchStartCallback(JSContext*, StopwatchStartCallback, void*);
+
+typedef bool
+(*StopwatchCommitCallback)(uint64_t, PerformanceGroupVector&, void*);
+extern bool
+SetStopwatchCommitCallback(JSContext*, StopwatchCommitCallback, void*);
+
+typedef bool
+(*GetGroupsCallback)(JSContext*, PerformanceGroupVector&, void*);
+extern bool
+SetGetPerformanceGroupsCallback(JSContext*, GetGroupsCallback, void*);
+
+}
+
+namespace js {
+
+enum class CompletionKind {
+    Normal,
+    Return,
+    Throw
+};
+
+}
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h"
+class nsIObjectInputStream;
+
+class nsIObjectOutputStream;
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h"
+class nsISerializable : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Read(nsIObjectInputStream *aInputStream) = 0;
+
+
+  virtual nsresult Write(nsIObjectOutputStream *aOutputStream) = 0;
+
+};
+
+  template<typename T> struct nsISerializable::COMTypeInfo<nsISerializable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISerializable::COMTypeInfo<nsISerializable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x91cca981, 0xc26d, 0x44a8, { 0xbe, 0xbe, 0xd9, 0xed, 0x48, 0x91, 0x50, 0x3a }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h" 2
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
+struct JSPrincipals;
+
+
+
+namespace mozilla {
+class OriginAttributes;
+}
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
+class nsIURI;
+
+class nsIContentSecurityPolicy;
+
+class nsIDOMDocument;
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
+class nsIPrincipal : public nsISerializable {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Equals(nsIPrincipal *other, bool *_retval) = 0;
+
+
+  virtual nsresult EqualsConsideringDomain(nsIPrincipal *other, bool *_retval) = 0;
+
+       inline bool Equals(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(Equals(aOther, &retVal))), 1))) && retVal); }
+      inline bool EqualsConsideringDomain(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(EqualsConsideringDomain(aOther, &retVal))), 1))) && retVal); }
+
+  virtual nsresult GetHashValue(uint32_t *aHashValue) = 0;
+
+
+  virtual nsresult GetURI(nsIURI * *aURI) = 0;
+
+
+  virtual nsresult GetDomain(nsIURI * *aDomain) = 0;
+  virtual nsresult SetDomain(nsIURI *aDomain) = 0;
+
+
+  virtual nsresult Subsumes(nsIPrincipal *other, bool *_retval) = 0;
+
+
+  virtual nsresult SubsumesConsideringDomain(nsIPrincipal *other, bool *_retval) = 0;
+
+
+  virtual nsresult SubsumesConsideringDomainIgnoringFPD(nsIPrincipal *other, bool *_retval) = 0;
+
+       inline bool Subsumes(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(Subsumes(aOther, &retVal))), 1))) && retVal); }
+      inline bool SubsumesConsideringDomain(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(SubsumesConsideringDomain(aOther, &retVal))), 1))) && retVal); }
+      inline bool SubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(SubsumesConsideringDomainIgnoringFPD(aOther, &retVal))), 1))) && retVal); }
+
+
+  virtual nsresult CheckMayLoad(nsIURI *uri, bool report, bool allowIfInheritsPrincipal) = 0;
+
+
+  virtual nsresult GetCsp(nsIContentSecurityPolicy * *aCsp) = 0;
+  virtual nsresult SetCsp(nsIContentSecurityPolicy *aCsp) = 0;
+
+
+  virtual nsresult EnsureCSP(nsIDOMDocument *aDocument, nsIContentSecurityPolicy * *_retval) = 0;
+
+
+  virtual nsresult GetPreloadCsp(nsIContentSecurityPolicy * *aPreloadCsp) = 0;
+
+
+  virtual nsresult EnsurePreloadCSP(nsIDOMDocument *aDocument, nsIContentSecurityPolicy * *_retval) = 0;
+
+
+  virtual nsresult GetCspJSON(nsAString & aCspJSON) = 0;
+
+
+  virtual nsresult GetOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) = 0;
+
+
+  virtual const mozilla::OriginAttributes & OriginAttributesRef(void) = 0;
+
+
+  virtual nsresult GetOrigin(nsACString & aOrigin) = 0;
+
+
+  virtual nsresult GetOriginNoSuffix(nsACString & aOriginNoSuffix) = 0;
+
+
+  virtual nsresult GetOriginSuffix(nsACString & aOriginSuffix) = 0;
+
+
+  virtual nsresult GetBaseDomain(nsACString & aBaseDomain) = 0;
+
+  enum {
+    APP_STATUS_NOT_INSTALLED = 0,
+    APP_STATUS_INSTALLED = 1,
+    APP_STATUS_PRIVILEGED = 2,
+    APP_STATUS_CERTIFIED = 3
+  };
+
+
+  virtual nsresult GetAppStatus(uint16_t *aAppStatus) = 0;
+  inline uint16_t GetAppStatus()
+  {
+    uint16_t result;
+    mozilla::DebugOnly<nsresult> rv = GetAppStatus(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetAppId(uint32_t *aAppId) = 0;
+  inline uint32_t GetAppId()
+  {
+    uint32_t result;
+    mozilla::DebugOnly<nsresult> rv = GetAppId(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetAddonId(nsAString & aAddonId) = 0;
+
+
+  virtual nsresult GetUserContextId(uint32_t *aUserContextId) = 0;
+  inline uint32_t GetUserContextId()
+  {
+    uint32_t result;
+    mozilla::DebugOnly<nsresult> rv = GetUserContextId(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetPrivateBrowsingId(uint32_t *aPrivateBrowsingId) = 0;
+  inline uint32_t GetPrivateBrowsingId()
+  {
+    uint32_t result;
+    mozilla::DebugOnly<nsresult> rv = GetPrivateBrowsingId(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsInIsolatedMozBrowserElement(bool *aIsInIsolatedMozBrowserElement) = 0;
+  inline bool GetIsInIsolatedMozBrowserElement()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsInIsolatedMozBrowserElement(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetUnknownAppId(bool *aUnknownAppId) = 0;
+  inline bool GetUnknownAppId()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetUnknownAppId(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsNullPrincipal(bool *aIsNullPrincipal) = 0;
+  inline bool GetIsNullPrincipal()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsNullPrincipal(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsCodebasePrincipal(bool *aIsCodebasePrincipal) = 0;
+  inline bool GetIsCodebasePrincipal()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsCodebasePrincipal(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsExpandedPrincipal(bool *aIsExpandedPrincipal) = 0;
+  inline bool GetIsExpandedPrincipal()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsExpandedPrincipal(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsSystemPrincipal(bool *aIsSystemPrincipal) = 0;
+  inline bool GetIsSystemPrincipal()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsSystemPrincipal(&result);
+    do { } while (0);
+    return result;
+  }
+
+};
+
+  template<typename T> struct nsIPrincipal::COMTypeInfo<nsIPrincipal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrincipal::COMTypeInfo<nsIPrincipal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf75f502d, 0x79fd, 0x48be, { 0xa0, 0x79, 0xe5, 0xa7, 0xb8, 0xf8, 0x0c, 0x8b }};
+# 658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
+class nsIExpandedPrincipal : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetAllowList(nsTArray<nsCOMPtr<nsIPrincipal> > **anAllowList) = 0;
+
+};
+
+  template<typename T> struct nsIExpandedPrincipal::COMTypeInfo<nsIExpandedPrincipal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIExpandedPrincipal::COMTypeInfo<nsIExpandedPrincipal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf3e177df, 0x6a5e, 0x489f, { 0x80, 0xa7, 0x2d, 0xd1, 0x48, 0x14, 0x71, 0xd8 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 2
+
+class nsJSPrincipals : public nsIPrincipal, public JSPrincipals
+{
+public:
+
+  static bool Subsume(JSPrincipals *jsprin, JSPrincipals *other);
+  static void Destroy(JSPrincipals *jsprin);
+
+
+  static bool ReadPrincipals(JSContext* aCx, JSStructuredCloneReader* aReader,
+                             JSPrincipals** aOutPrincipals);
+
+  static bool ReadKnownPrincipalType(JSContext* aCx,
+                                     JSStructuredCloneReader* aReader,
+                                     uint32_t aTag,
+                                     JSPrincipals** aOutPrincipals);
+
+  bool write(JSContext* aCx, JSStructuredCloneWriter* aWriter) final;
+
+
+
+
+
+  static nsJSPrincipals* get(JSPrincipals *principals) {
+    nsJSPrincipals *self = static_cast<nsJSPrincipals *>(principals);
+    do { } while (0);
+    return self;
+  }
+  static nsJSPrincipals* get(nsIPrincipal *principal) {
+    nsJSPrincipals *self = static_cast<nsJSPrincipals *>(principal);
+    do { } while (0);
+    return self;
+  }
+
+  virtual MozExternalRefCountType AddRef(void) override;
+  virtual MozExternalRefCountType Release(void) override;
+
+  nsJSPrincipals() {
+    refcount = 0;
+    setDebugToken(DEBUG_TOKEN);
+  }
+
+
+
+
+  virtual nsresult GetScriptLocation(nsACString &aStr) = 0;
+  static const uint32_t DEBUG_TOKEN = 0x0bf41760;
+
+protected:
+  virtual ~nsJSPrincipals() {
+    setDebugToken(0);
+  }
+
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h"
+namespace mozilla {
+namespace dom {
+
+class ChromeUtils;
+struct ChromeUtilsAtoms;
+struct CompileScriptOptionsDictionaryAtoms;
+struct NativePropertyHooks;
+struct OriginAttributesDictionaryAtoms;
+struct OriginAttributesPatternDictionaryAtoms;
+class ProtoAndIfaceCache;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+struct CompileScriptOptionsDictionary : public DictionaryBase
+{
+                        nsString mCharset;
+                        bool mHasReturnValue;
+                        bool mLazilyParse;
+
+  CompileScriptOptionsDictionary();
+
+  explicit inline CompileScriptOptionsDictionary(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline CompileScriptOptionsDictionary(const CompileScriptOptionsDictionary& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  CompileScriptOptionsDictionary&
+  operator=(const CompileScriptOptionsDictionary& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, CompileScriptOptionsDictionaryAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastCompileScriptOptionsDictionary : public CompileScriptOptionsDictionary
+{
+  inline FastCompileScriptOptionsDictionary()
+    : CompileScriptOptionsDictionary(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct OriginAttributesDictionary : public DictionaryBase
+{
+                        uint32_t mAppId;
+                        nsString mFirstPartyDomain;
+                        bool mInIsolatedMozBrowser;
+                        uint32_t mPrivateBrowsingId;
+                        uint32_t mUserContextId;
+
+  OriginAttributesDictionary();
+
+  explicit inline OriginAttributesDictionary(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline OriginAttributesDictionary(const OriginAttributesDictionary& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  OriginAttributesDictionary&
+  operator=(const OriginAttributesDictionary& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, OriginAttributesDictionaryAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastOriginAttributesDictionary : public OriginAttributesDictionary
+{
+  inline FastOriginAttributesDictionary()
+    : OriginAttributesDictionary(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct OriginAttributesPatternDictionary : public DictionaryBase
+{
+                        Optional<uint32_t> mAppId;
+                        Optional<nsString> mFirstPartyDomain;
+                        Optional<bool> mInIsolatedMozBrowser;
+                        Optional<uint32_t> mPrivateBrowsingId;
+                        Optional<uint32_t> mUserContextId;
+
+  OriginAttributesPatternDictionary();
+
+  explicit inline OriginAttributesPatternDictionary(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline OriginAttributesPatternDictionary(const OriginAttributesPatternDictionary& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  OriginAttributesPatternDictionary&
+  operator=(const OriginAttributesPatternDictionary& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, OriginAttributesPatternDictionaryAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastOriginAttributesPatternDictionary : public OriginAttributesPatternDictionary
+{
+  inline FastOriginAttributesPatternDictionary()
+    : OriginAttributesPatternDictionary(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+namespace ChromeUtilsBinding {
+
+  typedef mozilla::dom::ChromeUtils NativeType;
+
+  bool
+  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+# 209 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h"
+namespace mozilla {
+namespace dom {
+
+struct Base64URLDecodeOptionsAtoms;
+struct Base64URLEncodeOptionsAtoms;
+struct HeapSnapshotBoundariesAtoms;
+struct NativePropertyHooks;
+class ProtoAndIfaceCache;
+class ThreadSafeChromeUtils;
+struct ThreadSafeChromeUtilsAtoms;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class Base64URLDecodePadding : uint8_t {
+  Require,
+  Ignore,
+  Reject,
+  EndGuard_
+};
+
+namespace Base64URLDecodePaddingValues {
+extern const EnumEntry strings[4];
+}
+
+bool
+ToJSValue(JSContext* aCx, Base64URLDecodePadding aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+struct Base64URLDecodeOptions : public DictionaryBase
+{
+                        Base64URLDecodePadding mPadding;
+
+  Base64URLDecodeOptions();
+
+  explicit inline Base64URLDecodeOptions(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline Base64URLDecodeOptions(const Base64URLDecodeOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  Base64URLDecodeOptions&
+  operator=(const Base64URLDecodeOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, Base64URLDecodeOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastBase64URLDecodeOptions : public Base64URLDecodeOptions
+{
+  inline FastBase64URLDecodeOptions()
+    : Base64URLDecodeOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct Base64URLEncodeOptions : public DictionaryBase
+{
+                        bool mPad;
+
+  Base64URLEncodeOptions();
+
+  explicit inline Base64URLEncodeOptions(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline Base64URLEncodeOptions(const Base64URLEncodeOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  Base64URLEncodeOptions&
+  operator=(const Base64URLEncodeOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, Base64URLEncodeOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastBase64URLEncodeOptions : public Base64URLEncodeOptions
+{
+  inline FastBase64URLEncodeOptions()
+    : Base64URLEncodeOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct HeapSnapshotBoundaries : public DictionaryBase
+{
+                        Optional<JSObject*> mDebugger;
+                        Optional<Sequence<JSObject*>> mGlobals;
+                        Optional<bool> mRuntime;
+
+  HeapSnapshotBoundaries();
+
+  explicit inline HeapSnapshotBoundaries(const FastDictionaryInitializer& )
+  {
+
+  }
+
+private:
+  HeapSnapshotBoundaries(const HeapSnapshotBoundaries&) = delete;
+  HeapSnapshotBoundaries& operator=(const HeapSnapshotBoundaries&) = delete;
+
+  static bool
+  InitIds(JSContext* cx, HeapSnapshotBoundariesAtoms* atomsCache);
+
+public:
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+};
+
+namespace binding_detail {
+struct FastHeapSnapshotBoundaries : public HeapSnapshotBoundaries
+{
+  inline FastHeapSnapshotBoundaries()
+    : HeapSnapshotBoundaries(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+namespace ThreadSafeChromeUtilsBinding {
+
+  typedef mozilla::dom::ThreadSafeChromeUtils NativeType;
+
+  bool
+  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 2
+
+
+namespace mozilla {
+
+namespace devtools {
+class HeapSnapshot;
+}
+
+namespace dom {
+
+class ArrayBufferViewOrArrayBuffer;
+class PrecompiledScript;
+class Promise;
+
+class ThreadSafeChromeUtils
+{
+private:
+
+  static void SaveHeapSnapshotShared(GlobalObject& global,
+                                     const HeapSnapshotBoundaries& boundaries,
+                                     nsAString& filePath,
+                                     nsAString& snapshotId,
+                                     ErrorResult& rv);
+
+public:
+
+  static void SaveHeapSnapshot(GlobalObject& global,
+                               const HeapSnapshotBoundaries& boundaries,
+                               nsAString& filePath,
+                               ErrorResult& rv);
+
+
+  static void SaveHeapSnapshotGetId(GlobalObject& global,
+                                    const HeapSnapshotBoundaries& boundaries,
+                                    nsAString& snapshotId,
+                                    ErrorResult& rv);
+
+
+  static already_AddRefed<devtools::HeapSnapshot> ReadHeapSnapshot(GlobalObject& global,
+                                                                   const nsAString& filePath,
+                                                                   ErrorResult& rv);
+
+  static void NondeterministicGetWeakMapKeys(GlobalObject& aGlobal,
+                                             JS::Handle<JS::Value> aMap,
+                                             JS::MutableHandle<JS::Value> aRetval,
+                                             ErrorResult& aRv);
+
+  static void NondeterministicGetWeakSetKeys(GlobalObject& aGlobal,
+                                             JS::Handle<JS::Value> aSet,
+                                             JS::MutableHandle<JS::Value> aRetval,
+                                             ErrorResult& aRv);
+
+  static void Base64URLEncode(GlobalObject& aGlobal,
+                              const ArrayBufferViewOrArrayBuffer& aSource,
+                              const Base64URLEncodeOptions& aOptions,
+                              nsACString& aResult,
+                              ErrorResult& aRv);
+
+  static void Base64URLDecode(GlobalObject& aGlobal,
+                              const nsACString& aString,
+                              const Base64URLDecodeOptions& aOptions,
+                              JS::MutableHandle<JSObject*> aRetval,
+                              ErrorResult& aRv);
+};
+
+class ChromeUtils : public ThreadSafeChromeUtils
+{
+public:
+  static void
+  OriginAttributesToSuffix(GlobalObject& aGlobal,
+                           const dom::OriginAttributesDictionary& aAttrs,
+                           nsCString& aSuffix);
+
+  static bool
+  OriginAttributesMatchPattern(dom::GlobalObject& aGlobal,
+                               const dom::OriginAttributesDictionary& aAttrs,
+                               const dom::OriginAttributesPatternDictionary& aPattern);
+
+  static void
+  CreateOriginAttributesFromOrigin(dom::GlobalObject& aGlobal,
+                                   const nsAString& aOrigin,
+                                   dom::OriginAttributesDictionary& aAttrs,
+                                   ErrorResult& aRv);
+
+  static void
+  FillNonDefaultOriginAttributes(dom::GlobalObject& aGlobal,
+                                 const dom::OriginAttributesDictionary& aAttrs,
+                                 dom::OriginAttributesDictionary& aNewAttrs);
+
+  static bool
+  IsOriginAttributesEqual(dom::GlobalObject& aGlobal,
+                          const dom::OriginAttributesDictionary& aA,
+                          const dom::OriginAttributesDictionary& aB);
+
+  static bool
+  IsOriginAttributesEqual(const dom::OriginAttributesDictionary& aA,
+                          const dom::OriginAttributesDictionary& aB);
+
+  static bool
+  IsOriginAttributesEqualIgnoringFPD(const dom::OriginAttributesDictionary& aA,
+                                     const dom::OriginAttributesDictionary& aB)
+  {
+    return aA.mAppId == aB.mAppId &&
+           aA.mInIsolatedMozBrowser == aB.mInIsolatedMozBrowser &&
+           aA.mUserContextId == aB.mUserContextId &&
+           aA.mPrivateBrowsingId == aB.mPrivateBrowsingId;
+  }
+
+
+  static already_AddRefed<Promise>
+  CompileScript(GlobalObject& aGlobal,
+                const nsAString& aUrl,
+                const dom::CompileScriptOptionsDictionary& aOptions,
+                ErrorResult& aRv);
+};
+
+}
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h"
+class nsIURI;
+
+class nsIChannel;
+
+class nsIClassInfo;
+
+class nsIDocShell;
+
+class nsIDomainPolicy;
+
+class nsILoadContext;
+
+
+namespace mozilla {
+namespace dom {
+class DomainPolicyClone;
+}
+}
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h"
+class nsIScriptSecurityManager : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult CanCreateWrapper(JSContext *aJSContext, const nsIID & aIID, nsISupports *aObj, nsIClassInfo *aClassInfo) = 0;
+
+
+  virtual nsresult CanCreateInstance(JSContext *aJSContext, const nsCID & aCID) = 0;
+
+
+  virtual nsresult CanGetService(JSContext *aJSContext, const nsCID & aCID) = 0;
+
+
+  virtual nsresult CheckLoadURIFromScript(JSContext *cx, nsIURI *uri) = 0;
+
+  enum {
+    STANDARD = 0U,
+    LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT = 1U,
+    ALLOW_CHROME = 2U,
+    DISALLOW_INHERIT_PRINCIPAL = 4U,
+    DISALLOW_SCRIPT_OR_DATA = 4U,
+    DISALLOW_SCRIPT = 8U,
+    DONT_REPORT_ERRORS = 16U
+  };
+
+
+  virtual nsresult CheckLoadURIWithPrincipal(nsIPrincipal *aPrincipal, nsIURI *uri, uint32_t flags) = 0;
+
+
+  virtual nsresult CheckLoadURIStrWithPrincipal(nsIPrincipal *aPrincipal, const nsACString & uri, uint32_t flags) = 0;
+
+
+  virtual nsresult GetSystemPrincipal(nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetAppCodebasePrincipal(nsIURI *uri, uint32_t appId, bool inMozBrowser, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetLoadContextCodebasePrincipal(nsIURI *uri, nsILoadContext *loadContext, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetDocShellCodebasePrincipal(nsIURI *uri, nsIDocShell *docShell, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetNoAppCodebasePrincipal(nsIURI *uri, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetCodebasePrincipal(nsIURI *uri, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult CreateCodebasePrincipal(nsIURI *uri, JS::HandleValue originAttributes, JSContext* cx, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult CreateCodebasePrincipalFromOrigin(const nsACString & origin, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult CreateNullPrincipal(JS::HandleValue originAttributes, JSContext* cx, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult CheckSameOriginURI(nsIURI *aSourceURI, nsIURI *aTargetURI, bool reportError) = 0;
+
+
+  virtual nsresult GetChannelResultPrincipal(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetChannelResultPrincipalIfNotSandboxed(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult GetChannelURIPrincipal(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
+
+
+  virtual nsresult IsSystemPrincipal(nsIPrincipal *aPrincipal, bool *_retval) = 0;
+
+     bool IsSystemPrincipal(nsIPrincipal* aPrincipal) {
+      bool isSystem = false;
+      IsSystemPrincipal(aPrincipal, &isSystem);
+      return isSystem;
+    }
+  enum {
+    NO_APP_ID = 0U,
+    UNKNOWN_APP_ID = 4294967295U,
+    DEFAULT_USER_CONTEXT_ID = 0U
+  };
+
+
+  virtual nsresult ActivateDomainPolicy(nsIDomainPolicy * *_retval) = 0;
+
+
+  virtual nsresult GetDomainPolicyActive(bool *aDomainPolicyActive) = 0;
+
+
+  virtual nsresult ActivateDomainPolicyInternal(nsIDomainPolicy * *_retval) = 0;
+
+
+  virtual void CloneDomainPolicy(mozilla::dom::DomainPolicyClone *aClone) = 0;
+
+
+  virtual nsresult PolicyAllowsScript(nsIURI *aDomain, bool *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIScriptSecurityManager::COMTypeInfo<nsIScriptSecurityManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptSecurityManager::COMTypeInfo<nsIScriptSecurityManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x51daad87, 0x3a0c, 0x44cc, { 0xb6, 0x20, 0x73, 0x56, 0x80, 0x1c, 0x90, 0x22 }};
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 2
+
+namespace mozilla {
+
+class OriginAttributes : public dom::OriginAttributesDictionary
+{
+public:
+  OriginAttributes() {}
+
+  OriginAttributes(uint32_t aAppId, bool aInIsolatedMozBrowser)
+  {
+    mAppId = aAppId;
+    mInIsolatedMozBrowser = aInIsolatedMozBrowser;
+  }
+
+  explicit OriginAttributes(const OriginAttributesDictionary& aOther)
+    : OriginAttributesDictionary(aOther)
+  {}
+
+  void SetFirstPartyDomain(const bool aIsTopLevelDocument, nsIURI* aURI);
+  void SetFirstPartyDomain(const bool aIsTopLevelDocument, const nsACString& aDomain);
+
+  enum {
+    STRIP_FIRST_PARTY_DOMAIN = 0x01,
+    STRIP_USER_CONTEXT_ID = 0x02,
+  };
+
+  inline void StripAttributes(uint32_t aFlags)
+  {
+    if (aFlags & STRIP_FIRST_PARTY_DOMAIN) {
+      mFirstPartyDomain.Truncate();
+    }
+
+    if (aFlags & STRIP_USER_CONTEXT_ID) {
+      mUserContextId = nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID;
+    }
+  }
+
+  bool operator==(const OriginAttributes& aOther) const
+  {
+    return mAppId == aOther.mAppId &&
+           mInIsolatedMozBrowser == aOther.mInIsolatedMozBrowser &&
+           mUserContextId == aOther.mUserContextId &&
+           mPrivateBrowsingId == aOther.mPrivateBrowsingId &&
+           mFirstPartyDomain == aOther.mFirstPartyDomain;
+  }
+
+  bool operator!=(const OriginAttributes& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+
+
+
+  void CreateSuffix(nsACString& aStr) const;
+
+
+  void CreateAnonymizedSuffix(nsACString& aStr) const;
+
+  __attribute__ ((warn_unused_result)) bool PopulateFromSuffix(const nsACString& aStr);
+
+
+
+  __attribute__ ((warn_unused_result)) bool PopulateFromOrigin(const nsACString& aOrigin,
+                                       nsACString& aOriginNoSuffix);
+
+
+
+  void SyncAttributesWithPrivateBrowsing(bool aInPrivateBrowsing);
+
+
+  static inline bool IsFirstPartyEnabled()
+  {
+    return sFirstPartyIsolation;
+  }
+
+
+
+
+  static inline bool IsRestrictOpenerAccessForFPI()
+  {
+
+
+    return !sFirstPartyIsolation || sRestrictedOpenerAccess;
+  }
+
+
+
+  static bool IsPrivateBrowsing(const nsACString& aOrigin);
+
+  static void InitPrefs();
+
+private:
+  static bool sFirstPartyIsolation;
+  static bool sRestrictedOpenerAccess;
+};
+
+class OriginAttributesPattern : public dom::OriginAttributesPatternDictionary
+{
+public:
+
+
+
+
+
+
+  OriginAttributesPattern() {}
+
+  explicit OriginAttributesPattern(const OriginAttributesPatternDictionary& aOther)
+    : OriginAttributesPatternDictionary(aOther) {}
+
+
+  bool Matches(const OriginAttributes& aAttrs) const
+  {
+    if (mAppId.WasPassed() && mAppId.Value() != aAttrs.mAppId) {
+      return false;
+    }
+
+    if (mInIsolatedMozBrowser.WasPassed() && mInIsolatedMozBrowser.Value() != aAttrs.mInIsolatedMozBrowser) {
+      return false;
+    }
+
+    if (mUserContextId.WasPassed() && mUserContextId.Value() != aAttrs.mUserContextId) {
+      return false;
+    }
+
+    if (mPrivateBrowsingId.WasPassed() && mPrivateBrowsingId.Value() != aAttrs.mPrivateBrowsingId) {
+      return false;
+    }
+
+    if (mFirstPartyDomain.WasPassed() && mFirstPartyDomain.Value() != aAttrs.mFirstPartyDomain) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Overlaps(const OriginAttributesPattern& aOther) const
+  {
+    if (mAppId.WasPassed() && aOther.mAppId.WasPassed() &&
+        mAppId.Value() != aOther.mAppId.Value()) {
+      return false;
+    }
+
+    if (mInIsolatedMozBrowser.WasPassed() &&
+        aOther.mInIsolatedMozBrowser.WasPassed() &&
+        mInIsolatedMozBrowser.Value() != aOther.mInIsolatedMozBrowser.Value()) {
+      return false;
+    }
+
+    if (mUserContextId.WasPassed() && aOther.mUserContextId.WasPassed() &&
+        mUserContextId.Value() != aOther.mUserContextId.Value()) {
+      return false;
+    }
+
+    if (mPrivateBrowsingId.WasPassed() && aOther.mPrivateBrowsingId.WasPassed() &&
+        mPrivateBrowsingId.Value() != aOther.mPrivateBrowsingId.Value()) {
+      return false;
+    }
+
+    if (mFirstPartyDomain.WasPassed() && aOther.mFirstPartyDomain.WasPassed() &&
+        mFirstPartyDomain.Value() != aOther.mFirstPartyDomain.Value()) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 2
+
+class nsIContentSecurityPolicy;
+class nsIObjectOutputStream;
+class nsIObjectInputStream;
+class nsIURI;
+
+class ExpandedPrincipal;
+
+namespace mozilla {
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h"
+class BasePrincipal : public nsJSPrincipals
+{
+public:
+  enum PrincipalKind {
+    eNullPrincipal,
+    eCodebasePrincipal,
+    eExpandedPrincipal,
+    eSystemPrincipal
+  };
+
+  explicit BasePrincipal(PrincipalKind aKind);
+
+  enum DocumentDomainConsideration { DontConsiderDocumentDomain, ConsiderDocumentDomain};
+  bool Subsumes(nsIPrincipal* aOther, DocumentDomainConsideration aConsideration);
+
+  virtual nsresult GetOrigin(nsACString& aOrigin) final;
+  virtual nsresult GetOriginNoSuffix(nsACString& aOrigin) final;
+  virtual nsresult Equals(nsIPrincipal* other, bool* _retval) final;
+  virtual nsresult EqualsConsideringDomain(nsIPrincipal* other, bool* _retval) final;
+  virtual nsresult Subsumes(nsIPrincipal* other, bool* _retval) final;
+  virtual nsresult SubsumesConsideringDomain(nsIPrincipal* other, bool* _retval) final;
+  virtual nsresult SubsumesConsideringDomainIgnoringFPD(nsIPrincipal* other, bool* _retval) final;
+  virtual nsresult CheckMayLoad(nsIURI* uri, bool report, bool allowIfInheritsPrincipal) final;
+  virtual nsresult GetCsp(nsIContentSecurityPolicy** aCsp) override;
+  virtual nsresult SetCsp(nsIContentSecurityPolicy* aCsp) override;
+  virtual nsresult EnsureCSP(nsIDOMDocument* aDocument, nsIContentSecurityPolicy** aCSP) override;
+  virtual nsresult GetPreloadCsp(nsIContentSecurityPolicy** aPreloadCSP) override;
+  virtual nsresult EnsurePreloadCSP(nsIDOMDocument* aDocument, nsIContentSecurityPolicy** aCSP) override;
+  virtual nsresult GetCspJSON(nsAString& outCSPinJSON) override;
+  virtual nsresult GetIsNullPrincipal(bool* aResult) override;
+  virtual nsresult GetIsCodebasePrincipal(bool* aResult) override;
+  virtual nsresult GetIsExpandedPrincipal(bool* aResult) override;
+  virtual nsresult GetIsSystemPrincipal(bool* aResult) override;
+  virtual nsresult GetOriginAttributes(JSContext* aCx, JS::MutableHandle<JS::Value> aVal) final;
+  virtual nsresult GetOriginSuffix(nsACString& aOriginSuffix) final;
+  virtual nsresult GetAppStatus(uint16_t* aAppStatus) final;
+  virtual nsresult GetAppId(uint32_t* aAppStatus) final;
+  virtual nsresult GetIsInIsolatedMozBrowserElement(bool* aIsInIsolatedMozBrowserElement) final;
+  virtual nsresult GetUnknownAppId(bool* aUnknownAppId) final;
+  virtual nsresult GetUserContextId(uint32_t* aUserContextId) final;
+  virtual nsresult GetPrivateBrowsingId(uint32_t* aPrivateBrowsingId) final;
+
+  virtual bool AddonHasPermission(const nsAString& aPerm);
+
+  virtual bool IsCodebasePrincipal() const { return false; };
+
+  static BasePrincipal* Cast(nsIPrincipal* aPrin) { return static_cast<BasePrincipal*>(aPrin); }
+
+  static already_AddRefed<BasePrincipal>
+  CreateCodebasePrincipal(const nsACString& aOrigin);
+
+
+
+
+
+  static already_AddRefed<BasePrincipal>
+  CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs);
+
+  const OriginAttributes& OriginAttributesRef() final { return mOriginAttributes; }
+  uint32_t AppId() const { return mOriginAttributes.mAppId; }
+  uint32_t UserContextId() const { return mOriginAttributes.mUserContextId; }
+  uint32_t PrivateBrowsingId() const { return mOriginAttributes.mPrivateBrowsingId; }
+  bool IsInIsolatedMozBrowserElement() const { return mOriginAttributes.mInIsolatedMozBrowser; }
+
+  PrincipalKind Kind() const { return mKind; }
+
+  already_AddRefed<BasePrincipal> CloneStrippingUserContextIdAndFirstPartyDomain();
+
+
+
+
+  bool AddonAllowsLoad(nsIURI* aURI, bool aExplicit = false);
+
+
+  inline bool FastEquals(nsIPrincipal* aOther);
+  inline bool FastEqualsConsideringDomain(nsIPrincipal* aOther);
+  inline bool FastSubsumes(nsIPrincipal* aOther);
+  inline bool FastSubsumesConsideringDomain(nsIPrincipal* aOther);
+  inline bool FastSubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther);
+
+protected:
+  virtual ~BasePrincipal();
+
+
+
+  virtual bool SubsumesInternal(nsIPrincipal* aOther, DocumentDomainConsideration aConsider) = 0;
+
+
+
+
+  virtual bool MayLoadInternal(nsIURI* aURI) = 0;
+  friend class ::ExpandedPrincipal;
+
+  void
+  SetHasExplicitDomain()
+  {
+    mHasExplicitDomain = true;
+  }
+
+
+
+
+  void FinishInit(const nsACString& aOriginNoSuffix,
+                  const OriginAttributes& aOriginAttributes);
+
+  nsCOMPtr<nsIContentSecurityPolicy> mCSP;
+  nsCOMPtr<nsIContentSecurityPolicy> mPreloadCSP;
+
+private:
+  static already_AddRefed<BasePrincipal>
+  CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs,
+                          const nsACString& aOriginNoSuffix);
+
+  nsCOMPtr<nsIAtom> mOriginNoSuffix;
+  nsCOMPtr<nsIAtom> mOriginSuffix;
+
+  OriginAttributes mOriginAttributes;
+  PrincipalKind mKind;
+  bool mHasExplicitDomain;
+  bool mInitialized;
+};
+
+inline bool
+BasePrincipal::FastEquals(nsIPrincipal* aOther)
+{
+  auto other = Cast(aOther);
+  if (Kind() != other->Kind()) {
+
+    return false;
+  }
+
+
+
+
+
+
+  if (Kind() == eNullPrincipal || Kind() == eSystemPrincipal) {
+    return this == other;
+  }
+
+  if (Kind() == eCodebasePrincipal) {
+    return mOriginNoSuffix == other->mOriginNoSuffix &&
+           mOriginSuffix == other->mOriginSuffix;
+  }
+
+  do { } while (0);
+  return mOriginNoSuffix == other->mOriginNoSuffix;
+}
+
+inline bool
+BasePrincipal::FastEqualsConsideringDomain(nsIPrincipal* aOther)
+{
+
+
+  auto other = Cast(aOther);
+  if (!mHasExplicitDomain && !other->mHasExplicitDomain) {
+    return FastEquals(aOther);
+  }
+
+  return Subsumes(aOther, ConsiderDocumentDomain) &&
+         other->Subsumes(this, ConsiderDocumentDomain);
+}
+
+inline bool
+BasePrincipal::FastSubsumes(nsIPrincipal* aOther)
+{
+
+
+
+
+  auto other = Cast(aOther);
+  if (Kind() == eNullPrincipal && other->Kind() == eNullPrincipal) {
+    return this == other;
+  }
+  if (FastEquals(aOther)) {
+    return true;
+  }
+
+
+  return Subsumes(aOther, DontConsiderDocumentDomain);
+}
+
+inline bool
+BasePrincipal::FastSubsumesConsideringDomain(nsIPrincipal* aOther)
+{
+
+
+
+  if (!mHasExplicitDomain && !Cast(aOther)->mHasExplicitDomain) {
+    return FastSubsumes(aOther);
+  }
+
+  return Subsumes(aOther, ConsiderDocumentDomain);
+}
+
+inline bool
+BasePrincipal::FastSubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther)
+{
+  if (Kind() == eCodebasePrincipal &&
+      !dom::ChromeUtils::IsOriginAttributesEqualIgnoringFPD(
+            mOriginAttributes, Cast(aOther)->mOriginAttributes)) {
+    return false;
+  }
+
+ return SubsumesInternal(aOther, ConsiderDocumentDomain);
+}
+
+}
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h"
+namespace mozilla {
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h"
+enum class LoadTainting : uint8_t
+{
+  Basic = 0,
+  CORS = 1,
+  Opaque = 2
+};
+
+}
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
+class nsCString;
+typedef uint32_t nsSecurityFlags;
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
+class nsILoadInfo : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    SEC_NORMAL = 0U,
+    SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS = 1U,
+    SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED = 2U,
+    SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS = 4U,
+    SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL = 8U,
+    SEC_REQUIRE_CORS_DATA_INHERITS = 16U,
+    SEC_COOKIES_DEFAULT = 0U,
+    SEC_COOKIES_INCLUDE = 32U,
+    SEC_COOKIES_SAME_ORIGIN = 64U,
+    SEC_COOKIES_OMIT = 96U,
+    SEC_FORCE_INHERIT_PRINCIPAL = 128U,
+    SEC_SANDBOXED = 256U,
+    SEC_ABOUT_BLANK_INHERITS = 512U,
+    SEC_ALLOW_CHROME = 1024U,
+    SEC_DISALLOW_SCRIPT = 2048U,
+    SEC_DONT_FOLLOW_REDIRECTS = 4096U,
+    SEC_LOAD_ERROR_PAGE = 8192U,
+    SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER = 16384U
+  };
+
+
+  virtual nsresult GetLoadingPrincipal(nsIPrincipal * *aLoadingPrincipal) = 0;
+
+
+  virtual nsIPrincipal * LoadingPrincipal(void) = 0;
+
+
+  virtual nsresult GetTriggeringPrincipal(nsIPrincipal * *aTriggeringPrincipal) = 0;
+
+
+  virtual nsIPrincipal * TriggeringPrincipal(void) = 0;
+
+
+  virtual nsresult GetPrincipalToInherit(nsIPrincipal * *aPrincipalToInherit) = 0;
+  virtual nsresult SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit) = 0;
+
+
+  virtual nsIPrincipal * PrincipalToInherit(void) = 0;
+
+
+  virtual nsresult GetLoadingDocument(nsIDOMDocument * *aLoadingDocument) = 0;
+
+
+  virtual nsINode * LoadingNode(void) = 0;
+
+
+  virtual nsresult GetSecurityFlags(nsSecurityFlags *aSecurityFlags) = 0;
+
+   inline nsSecurityFlags GetSecurityFlags()
+  {
+    nsSecurityFlags result;
+    mozilla::DebugOnly<nsresult> rv = GetSecurityFlags(&result);
+    do { } while (0);
+    return result;
+  }
+
+  virtual nsresult GetSecurityMode(uint32_t *aSecurityMode) = 0;
+  inline uint32_t GetSecurityMode()
+  {
+    uint32_t result;
+    mozilla::DebugOnly<nsresult> rv = GetSecurityMode(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsInThirdPartyContext(bool *aIsInThirdPartyContext) = 0;
+  inline bool GetIsInThirdPartyContext()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsInThirdPartyContext(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetCookiePolicy(uint32_t *aCookiePolicy) = 0;
+  inline uint32_t GetCookiePolicy()
+  {
+    uint32_t result;
+    mozilla::DebugOnly<nsresult> rv = GetCookiePolicy(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetForceInheritPrincipal(bool *aForceInheritPrincipal) = 0;
+  inline bool GetForceInheritPrincipal()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipal(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner) = 0;
+  inline bool GetForceInheritPrincipalOverruleOwner()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalOverruleOwner(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetLoadingSandboxed(bool *aLoadingSandboxed) = 0;
+  inline bool GetLoadingSandboxed()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetLoadingSandboxed(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetAboutBlankInherits(bool *aAboutBlankInherits) = 0;
+  inline bool GetAboutBlankInherits()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetAboutBlankInherits(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetAllowChrome(bool *aAllowChrome) = 0;
+  inline bool GetAllowChrome()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetAllowChrome(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetDisallowScript(bool *aDisallowScript) = 0;
+  inline bool GetDisallowScript()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetDisallowScript(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetDontFollowRedirects(bool *aDontFollowRedirects) = 0;
+  inline bool GetDontFollowRedirects()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetDontFollowRedirects(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetLoadErrorPage(bool *aLoadErrorPage) = 0;
+  inline bool GetLoadErrorPage()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetLoadErrorPage(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType) = 0;
+
+   inline nsContentPolicyType GetExternalContentPolicyType()
+  {
+    nsContentPolicyType result;
+    mozilla::DebugOnly<nsresult> rv = GetExternalContentPolicyType(&result);
+    do { } while (0);
+    return result;
+  }
+
+  virtual nsContentPolicyType InternalContentPolicyType(void) = 0;
+
+
+  virtual nsresult GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests) = 0;
+  inline bool GetUpgradeInsecureRequests()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetUpgradeInsecureRequests(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetVerifySignedContent(bool *aVerifySignedContent) = 0;
+  inline bool GetVerifySignedContent()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetVerifySignedContent(&result);
+    do { } while (0);
+    return result;
+  }
+  virtual nsresult SetVerifySignedContent(bool aVerifySignedContent) = 0;
+
+
+  virtual nsresult GetEnforceSRI(bool *aEnforceSRI) = 0;
+  inline bool GetEnforceSRI()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetEnforceSRI(&result);
+    do { } while (0);
+    return result;
+  }
+  virtual nsresult SetEnforceSRI(bool aEnforceSRI) = 0;
+
+
+  virtual nsresult GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped) = 0;
+  inline bool GetForceInheritPrincipalDropped()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalDropped(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetInnerWindowID(uint64_t *aInnerWindowID) = 0;
+  inline uint64_t GetInnerWindowID()
+  {
+    uint64_t result;
+    mozilla::DebugOnly<nsresult> rv = GetInnerWindowID(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetOuterWindowID(uint64_t *aOuterWindowID) = 0;
+  inline uint64_t GetOuterWindowID()
+  {
+    uint64_t result;
+    mozilla::DebugOnly<nsresult> rv = GetOuterWindowID(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetParentOuterWindowID(uint64_t *aParentOuterWindowID) = 0;
+  inline uint64_t GetParentOuterWindowID()
+  {
+    uint64_t result;
+    mozilla::DebugOnly<nsresult> rv = GetParentOuterWindowID(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetFrameOuterWindowID(uint64_t *aFrameOuterWindowID) = 0;
+  inline uint64_t GetFrameOuterWindowID()
+  {
+    uint64_t result;
+    mozilla::DebugOnly<nsresult> rv = GetFrameOuterWindowID(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult ResetPrincipalToInheritToNullPrincipal(void) = 0;
+
+
+  virtual nsresult GetScriptableOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) = 0;
+  virtual nsresult SetScriptableOriginAttributes(JSContext* cx, JS::HandleValue aOriginAttributes) = 0;
+
+
+  virtual nsresult GetOriginAttributes(mozilla::OriginAttributes *_retval) = 0;
+
+
+  virtual nsresult SetOriginAttributes(const mozilla::OriginAttributes & aOriginAttrs) = 0;
+
+   inline mozilla::OriginAttributes GetOriginAttributes()
+  {
+    mozilla::OriginAttributes result;
+    mozilla::DebugOnly<nsresult> rv = GetOriginAttributes(&result);
+    do { } while (0);
+    return result;
+  }
+
+  virtual nsresult GetEnforceSecurity(bool *aEnforceSecurity) = 0;
+  inline bool GetEnforceSecurity()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetEnforceSecurity(&result);
+    do { } while (0);
+    return result;
+  }
+  virtual nsresult SetEnforceSecurity(bool aEnforceSecurity) = 0;
+
+
+  virtual nsresult GetInitialSecurityCheckDone(bool *aInitialSecurityCheckDone) = 0;
+  inline bool GetInitialSecurityCheckDone()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetInitialSecurityCheckDone(&result);
+    do { } while (0);
+    return result;
+  }
+  virtual nsresult SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) = 0;
+
+
+  virtual nsresult AppendRedirectedPrincipal(nsIPrincipal *principal, bool isInternalRedirect) = 0;
+
+
+  virtual nsresult GetRedirectChainIncludingInternalRedirects(JSContext* cx, JS::MutableHandleValue aRedirectChainIncludingInternalRedirects) = 0;
+
+
+  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & RedirectChainIncludingInternalRedirects(void) = 0;
+
+
+  virtual nsresult GetRedirectChain(JSContext* cx, JS::MutableHandleValue aRedirectChain) = 0;
+
+
+  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & RedirectChain(void) = 0;
+
+
+  virtual void SetCorsPreflightInfo(const nsTArray<nsCString> & unsafeHeaders, bool forcePreflight) = 0;
+
+
+  virtual const nsTArray<nsCString> & CorsUnsafeHeaders(void) = 0;
+
+
+  virtual nsresult GetForcePreflight(bool *aForcePreflight) = 0;
+  inline bool GetForcePreflight()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetForcePreflight(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsPreflight(bool *aIsPreflight) = 0;
+  inline bool GetIsPreflight()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsPreflight(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetForceHSTSPriming(bool *aForceHSTSPriming) = 0;
+  inline bool GetForceHSTSPriming()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetForceHSTSPriming(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetMixedContentWouldBlock(bool *aMixedContentWouldBlock) = 0;
+  inline bool GetMixedContentWouldBlock()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetMixedContentWouldBlock(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual void SetHSTSPriming(bool mixeContentWouldBlock) = 0;
+
+
+  virtual void ClearHSTSPriming(void) = 0;
+
+  enum {
+    TAINTING_BASIC = 0U,
+    TAINTING_CORS = 1U,
+    TAINTING_OPAQUE = 2U
+  };
+
+
+  virtual nsresult GetTainting(uint32_t *aTainting) = 0;
+
+
+  virtual nsresult MaybeIncreaseTainting(uint32_t aTainting) = 0;
+
+   static_assert(TAINTING_BASIC == static_cast<uint32_t>(mozilla::LoadTainting::Basic),
+                "basic tainting enums should match");
+  static_assert(TAINTING_CORS == static_cast<uint32_t>(mozilla::LoadTainting::CORS),
+                "cors tainting enums should match");
+  static_assert(TAINTING_OPAQUE == static_cast<uint32_t>(mozilla::LoadTainting::Opaque),
+                "opaque tainting enums should match");
+  mozilla::LoadTainting GetTainting()
+  {
+    uint32_t tainting = TAINTING_BASIC;
+    do { if ((((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetTainting(&tainting))), 1))))) { } } while (0);
+    return static_cast<mozilla::LoadTainting>(tainting);
+  }
+  void MaybeIncreaseTainting(mozilla::LoadTainting aTainting)
+  {
+    uint32_t tainting = static_cast<uint32_t>(aTainting);
+    do { if ((((bool)(__builtin_expect(!!(!NS_FAILED_impl(MaybeIncreaseTainting(tainting))), 1))))) { } } while (0);
+  }
+
+  virtual nsresult GetIsTopLevelLoad(bool *aIsTopLevelLoad) = 0;
+  inline bool GetIsTopLevelLoad()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsTopLevelLoad(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetSandboxedLoadingPrincipal(nsIPrincipal * *aSandboxedLoadingPrincipal) = 0;
+
+};
+
+  template<typename T> struct nsILoadInfo::COMTypeInfo<nsILoadInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILoadInfo::COMTypeInfo<nsILoadInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xddc65bf9, 0x2f60, 0x41ab, { 0xb2, 0x2a, 0x4f, 0x1a, 0xe9, 0xef, 0xcd, 0x36 }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 2
+
+
+
+
+
+
+class nsIURI;
+
+class nsIInterfaceRequestor;
+
+class nsIInputStream;
+
+class nsIStreamListener;
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h"
+class nsIChannel : public nsIRequest {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetOriginalURI(nsIURI * *aOriginalURI) = 0;
+  virtual nsresult SetOriginalURI(nsIURI *aOriginalURI) = 0;
+
+
+  virtual nsresult GetURI(nsIURI * *aURI) = 0;
+
+
+  virtual nsresult GetOwner(nsISupports * *aOwner) = 0;
+  virtual nsresult SetOwner(nsISupports *aOwner) = 0;
+
+
+  virtual nsresult GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) = 0;
+  virtual nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) = 0;
+
+
+  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
+
+
+  virtual nsresult GetContentType(nsACString & aContentType) = 0;
+  virtual nsresult SetContentType(const nsACString & aContentType) = 0;
+
+
+  virtual nsresult GetContentCharset(nsACString & aContentCharset) = 0;
+  virtual nsresult SetContentCharset(const nsACString & aContentCharset) = 0;
+
+
+  virtual nsresult GetContentLength(int64_t *aContentLength) = 0;
+  virtual nsresult SetContentLength(int64_t aContentLength) = 0;
+
+
+  virtual nsresult Open(nsIInputStream * *_retval) = 0;
+
+
+  virtual nsresult Open2(nsIInputStream * *_retval) = 0;
+
+
+  virtual nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) = 0;
+
+
+  virtual nsresult AsyncOpen2(nsIStreamListener *aListener) = 0;
+
+  enum {
+    LOAD_DOCUMENT_URI = 65536U,
+    LOAD_RETARGETED_DOCUMENT_URI = 131072U,
+    LOAD_REPLACE = 262144U,
+    LOAD_INITIAL_DOCUMENT_URI = 524288U,
+    LOAD_TARGETED = 1048576U,
+    LOAD_CALL_CONTENT_SNIFFERS = 2097152U,
+    LOAD_CLASSIFY_URI = 4194304U,
+    LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE = 8388608U,
+    LOAD_EXPLICIT_CREDENTIALS = 16777216U,
+    LOAD_BYPASS_SERVICE_WORKER = 33554432U
+  };
+
+
+  virtual nsresult GetContentDisposition(uint32_t *aContentDisposition) = 0;
+  virtual nsresult SetContentDisposition(uint32_t aContentDisposition) = 0;
+
+  enum {
+    DISPOSITION_INLINE = 0U,
+    DISPOSITION_ATTACHMENT = 1U
+  };
+
+
+  virtual nsresult GetContentDispositionFilename(nsAString & aContentDispositionFilename) = 0;
+  virtual nsresult SetContentDispositionFilename(const nsAString & aContentDispositionFilename) = 0;
+
+
+  virtual nsresult GetContentDispositionHeader(nsACString & aContentDispositionHeader) = 0;
+
+
+  virtual nsresult GetLoadInfo(nsILoadInfo * *aLoadInfo) = 0;
+  virtual nsresult SetLoadInfo(nsILoadInfo *aLoadInfo) = 0;
+
+   inline already_AddRefed<nsILoadInfo> GetLoadInfo()
+  {
+    nsCOMPtr<nsILoadInfo> result;
+    mozilla::DebugOnly<nsresult> rv = GetLoadInfo(getter_AddRefs(result));
+    do { } while (0);
+    return result.forget();
+  }
+};
+
+  template<typename T> struct nsIChannel::COMTypeInfo<nsIChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIChannel::COMTypeInfo<nsIChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2c389865, 0x23db, 0x4aa7, { 0x9f, 0xe5, 0x60, 0xcc, 0x7b, 0x00, 0x69, 0x7e }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h" 2
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
+class nsIHttpHeaderVisitor;
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
+class nsIHttpChannel : public nsIChannel {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestMethod(nsACString & aRequestMethod) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestMethod(const nsACString & aRequestMethod) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetReferrer(nsIURI * *aReferrer) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetReferrer(nsIURI *aReferrer) = 0;
+
+  enum {
+    REFERRER_POLICY_UNSET = 0U,
+    REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE = 1U,
+    REFERRER_POLICY_NO_REFERRER = 2U,
+    REFERRER_POLICY_ORIGIN = 3U,
+    REFERRER_POLICY_ORIGIN_WHEN_XORIGIN = 4U,
+    REFERRER_POLICY_UNSAFE_URL = 5U,
+    REFERRER_POLICY_SAME_ORIGIN = 6U,
+    REFERRER_POLICY_STRICT_ORIGIN = 7U,
+    REFERRER_POLICY_STRICT_ORIGIN_WHEN_XORIGIN = 8U
+  };
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetReferrerPolicy(uint32_t *aReferrerPolicy) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetProtocolVersion(nsACString & aProtocolVersion) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetTransferSize(uint64_t *aTransferSize) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetDecodedBodySize(uint64_t *aDecodedBodySize) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetEncodedBodySize(uint64_t *aEncodedBodySize) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestHeader(const nsACString & aHeader, nsACString & _retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestHeader(const nsACString & aHeader, const nsACString & aValue, bool aMerge) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetEmptyRequestHeader(const nsACString & aHeader) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetAllowPipelining(bool *aAllowPipelining) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetAllowPipelining(bool aAllowPipelining) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetAllowSTS(bool *aAllowSTS) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetAllowSTS(bool aAllowSTS) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRedirectionLimit(uint32_t aRedirectionLimit) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseStatus(uint32_t *aResponseStatus) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseStatusText(nsACString & aResponseStatusText) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestSucceeded(bool *aRequestSucceeded) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetIsMainDocumentChannel(bool *aIsMainDocumentChannel) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetIsMainDocumentChannel(bool aIsMainDocumentChannel) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseHeader(const nsACString & header, nsACString & _retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetResponseHeader(const nsACString & header, const nsACString & value, bool merge) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetOriginalResponseHeader(const nsACString & aHeader, nsIHttpHeaderVisitor *aVisitor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult VisitOriginalResponseHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult IsNoStoreResponse(bool *_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult IsNoCacheResponse(bool *_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult IsPrivateResponse(bool *_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult RedirectTo(nsIURI *aTargetURI) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestContextID(uint64_t *aRequestContextID) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestContextID(uint64_t aRequestContextID) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetChannelId(uint64_t *aChannelId) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetChannelId(uint64_t aChannelId) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetTopLevelContentWindowId(uint64_t *aTopLevelContentWindowId) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetTopLevelContentWindowId(uint64_t aTopLevelContentWindowId) = 0;
+
+
+  virtual nsresult GetIsTrackingResource(bool *aIsTrackingResource) = 0;
+  inline bool GetIsTrackingResource()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsTrackingResource(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetTopLevelOuterContentWindowId(uint64_t *aTopLevelOuterContentWindowId) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetTopLevelOuterContentWindowId(uint64_t aTopLevelOuterContentWindowId) = 0;
+
+};
+
+  template<typename T> struct nsIHttpChannel::COMTypeInfo<nsIHttpChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHttpChannel::COMTypeInfo<nsIHttpChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xc5a4a073, 0x4539, 0x49c7, { 0xa3, 0xf2, 0xce, 0xc3, 0xf0, 0x61, 0x9c, 0x6c }};
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/net/ReferrerPolicy.h" 2
+
+
+namespace mozilla { namespace net {
+
+enum ReferrerPolicy {
+
+  RP_No_Referrer = nsIHttpChannel::REFERRER_POLICY_NO_REFERRER,
+
+
+  RP_Origin = nsIHttpChannel::REFERRER_POLICY_ORIGIN,
+
+
+  RP_No_Referrer_When_Downgrade = nsIHttpChannel::REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE,
+
+
+  RP_Origin_When_Crossorigin = nsIHttpChannel::REFERRER_POLICY_ORIGIN_WHEN_XORIGIN,
+
+
+  RP_Unsafe_URL = nsIHttpChannel::REFERRER_POLICY_UNSAFE_URL,
+
+
+  RP_Same_Origin = nsIHttpChannel::REFERRER_POLICY_SAME_ORIGIN,
+
+
+  RP_Strict_Origin = nsIHttpChannel::REFERRER_POLICY_STRICT_ORIGIN,
+
+
+  RP_Strict_Origin_When_Cross_Origin = nsIHttpChannel::REFERRER_POLICY_STRICT_ORIGIN_WHEN_XORIGIN,
+
+
+
+  RP_Unset = nsIHttpChannel::REFERRER_POLICY_UNSET,
+};
+
+
+const char kRPS_Never[] = "never";
+const char kRPS_No_Referrer[] = "no-referrer";
+
+
+const char kRPS_Origin[] = "origin";
+
+
+const char kRPS_Default[] = "default";
+const char kRPS_No_Referrer_When_Downgrade[] = "no-referrer-when-downgrade";
+
+
+const char kRPS_Origin_When_Cross_Origin[] = "origin-when-cross-origin";
+const char kRPS_Origin_When_Crossorigin[] = "origin-when-crossorigin";
+
+
+const char kRPS_Same_Origin[] = "same-origin";
+
+
+const char kRPS_Strict_Origin[] = "strict-origin";
+
+
+const char kRPS_Strict_Origin_When_Cross_Origin[] = "strict-origin-when-cross-origin";
+
+
+const char kRPS_Always[] = "always";
+const char kRPS_Unsafe_URL[] = "unsafe-url";
+
+inline ReferrerPolicy
+ReferrerPolicyFromString(const nsAString& content)
+{
+  if (content.IsEmpty()) {
+    return RP_No_Referrer;
+  }
+
+  nsString lowerContent(content);
+  ToLowerCase(lowerContent);
+
+
+  if (lowerContent.EqualsLiteral(kRPS_Never) ||
+      lowerContent.EqualsLiteral(kRPS_No_Referrer)) {
+    return RP_No_Referrer;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Origin)) {
+    return RP_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Default) ||
+      lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)) {
+    return RP_No_Referrer_When_Downgrade;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin) ||
+      lowerContent.EqualsLiteral(kRPS_Origin_When_Crossorigin)) {
+    return RP_Origin_When_Crossorigin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Same_Origin)) {
+    return RP_Same_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin)) {
+    return RP_Strict_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)) {
+    return RP_Strict_Origin_When_Cross_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Always) ||
+      lowerContent.EqualsLiteral(kRPS_Unsafe_URL)) {
+    return RP_Unsafe_URL;
+  }
+
+  return RP_Unset;
+
+}
+
+inline bool
+IsValidReferrerPolicy(const nsAString& content)
+{
+  if (content.IsEmpty()) {
+    return true;
+  }
+
+  nsString lowerContent(content);
+  ToLowerCase(lowerContent);
+
+  return lowerContent.EqualsLiteral(kRPS_Never)
+      || lowerContent.EqualsLiteral(kRPS_No_Referrer)
+      || lowerContent.EqualsLiteral(kRPS_Origin)
+      || lowerContent.EqualsLiteral(kRPS_Default)
+      || lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)
+      || lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin)
+      || lowerContent.EqualsLiteral(kRPS_Origin_When_Crossorigin)
+      || lowerContent.EqualsLiteral(kRPS_Same_Origin)
+      || lowerContent.EqualsLiteral(kRPS_Strict_Origin)
+      || lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)
+      || lowerContent.EqualsLiteral(kRPS_Always)
+      || lowerContent.EqualsLiteral(kRPS_Unsafe_URL);
+}
+
+inline ReferrerPolicy
+AttributeReferrerPolicyFromString(const nsAString& content)
+{
+
+
+  if (content.IsEmpty()) {
+    return RP_Unset;
+  }
+
+  nsString lowerContent(content);
+  ToLowerCase(lowerContent);
+
+  if (lowerContent.EqualsLiteral(kRPS_No_Referrer)) {
+    return RP_No_Referrer;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Origin)) {
+    return RP_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)) {
+    return RP_No_Referrer_When_Downgrade;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin)) {
+    return RP_Origin_When_Crossorigin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Unsafe_URL)) {
+    return RP_Unsafe_URL;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin)) {
+    return RP_Strict_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Same_Origin)) {
+    return RP_Same_Origin;
+  }
+  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)) {
+    return RP_Strict_Origin_When_Cross_Origin;
+  }
+
+
+
+  return RP_Unset;
+}
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CORSMode.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CORSMode.h"
+namespace mozilla {
+
+enum CORSMode : uint8_t {
+
+
+
+  CORS_NONE,
+
+
+
+
+
+  CORS_ANONYMOUS,
+
+
+
+
+
+  CORS_USE_CREDENTIALS
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoUtils.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h" 2
+
+
+
+
+
+class nsICSSLoaderObserver : public nsISupports {
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h"
+  virtual nsresult StyleSheetLoaded(mozilla::StyleSheet* aSheet,
+                              bool aWasAlternate,
+                              nsresult aStatus) = 0;
+};
+
+template<typename T> struct nsICSSLoaderObserver::COMTypeInfo<nsICSSLoaderObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsICSSLoaderObserver::COMTypeInfo<nsICSSLoaderObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xf51fbf2c, 0xfe4b, 0x4a15, { 0xaf, 0x7e, 0x5e, 0x20, 0x64, 0x5f, 0xaf, 0x58 } };
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMStyleSheet.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMStyleSheet.h"
+class nsIDOMStyleSheet : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetType(nsAString & aType) = 0;
+
+
+  virtual nsresult GetDisabled(bool *aDisabled) = 0;
+  virtual nsresult SetDisabled(bool aDisabled) = 0;
+
+
+  virtual nsresult GetOwnerNode(nsIDOMNode * *aOwnerNode) = 0;
+
+
+  virtual nsresult GetParentStyleSheet(nsIDOMStyleSheet * *aParentStyleSheet) = 0;
+
+
+  virtual nsresult GetHref(nsAString & aHref) = 0;
+
+
+  virtual nsresult GetTitle(nsAString & aTitle) = 0;
+
+
+  virtual nsresult GetMedia(nsIDOMMediaList * *aMedia) = 0;
+
+};
+
+  template<typename T> struct nsIDOMStyleSheet::COMTypeInfo<nsIDOMStyleSheet, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMStyleSheet::COMTypeInfo<nsIDOMStyleSheet, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa6cf9080, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h"
+class nsIDOMCSSStyleSheet : public nsIDOMStyleSheet {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetOwnerRule(nsIDOMCSSRule * *aOwnerRule) = 0;
+
+
+  virtual nsresult GetCssRules(nsIDOMCSSRuleList * *aCssRules) = 0;
+
+
+  virtual nsresult InsertRule(const nsAString & rule, uint32_t index, uint32_t *_retval) = 0;
+
+
+  virtual nsresult DeleteRule(uint32_t index) = 0;
+
+};
+
+  template<typename T> struct nsIDOMCSSStyleSheet::COMTypeInfo<nsIDOMCSSStyleSheet, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMCSSStyleSheet::COMTypeInfo<nsIDOMCSSStyleSheet, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa6cf90c2, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
+
+
+class nsIDocument;
+class nsINode;
+class nsIPrincipal;
+class nsCSSRuleProcessor;
+
+namespace mozilla {
+
+class CSSStyleSheet;
+class ServoStyleSheet;
+struct StyleSheetInfo;
+struct CSSStyleSheetInner;
+
+namespace dom {
+class CSSRuleList;
+class MediaList;
+class SRIMetadata;
+}
+
+namespace css {
+class GroupRule;
+class ImportRule;
+class Rule;
+}
+
+
+
+
+class StyleSheet : public nsIDOMCSSStyleSheet
+                 , public nsICSSLoaderObserver
+                 , public nsWrapperCache
+{
+protected:
+  StyleSheet(StyleBackendType aType, css::SheetParsingMode aParsingMode);
+  StyleSheet(const StyleSheet& aCopy,
+             nsIDocument* aDocumentToUse,
+             nsINode* aOwningNodeToUse);
+  virtual ~StyleSheet();
+
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "StyleSheet"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<StyleSheet>(p)->DeleteCycleCollectable(); } static StyleSheet* Downcast(nsISupports* s) { return static_cast<StyleSheet*>(static_cast<nsIDOMCSSStyleSheet*>(s)); } static nsISupports* Upcast(StyleSheet *p) { return static_cast<nsISupports*>(static_cast<nsIDOMCSSStyleSheet*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &StyleSheet::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  void SetOwningNode(nsINode* aOwningNode)
+  {
+    mOwningNode = aOwningNode;
+  }
+
+  css::SheetParsingMode ParsingMode() { return mParsingMode; }
+  mozilla::dom::CSSStyleSheetParsingMode ParsingModeDOM();
+
+
+
+
+  bool IsComplete() const;
+  void SetComplete();
+# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
+  void SetEnabled(bool aEnabled);
+
+  bool IsGecko() const { return !IsServo(); } bool IsServo() const { return mType == StyleBackendType::Servo; } inline CSSStyleSheet* AsGecko(); inline ServoStyleSheet* AsServo(); inline const CSSStyleSheet* AsGecko() const; inline const ServoStyleSheet* AsServo() const; inline CSSStyleSheet* GetAsGecko(); inline ServoStyleSheet* GetAsServo(); inline const CSSStyleSheet* GetAsGecko() const; inline const ServoStyleSheet* GetAsServo() const;
+
+
+  inline bool IsInline() const;
+
+  inline nsIURI* GetSheetURI() const;
+
+
+  inline nsIURI* GetOriginalURI() const;
+  inline nsIURI* GetBaseURI() const;
+
+
+
+
+
+  inline void SetURIs(nsIURI* aSheetURI, nsIURI* aOriginalSheetURI,
+                      nsIURI* aBaseURI);
+
+
+
+
+
+
+
+  inline bool IsApplicable() const;
+  inline bool HasRules() const;
+
+  virtual already_AddRefed<StyleSheet> Clone(StyleSheet* aCloneParent,
+                                             css::ImportRule* aCloneOwnerRule,
+                                             nsIDocument* aCloneDocument,
+                                             nsINode* aCloneOwningNode) const = 0;
+
+  virtual bool IsModified() const = 0;
+
+
+  enum DocumentAssociationMode {
+
+
+    OwnedByDocument,
+
+
+    NotOwnedByDocument
+  };
+  nsIDocument* GetAssociatedDocument() const { return mDocument; }
+  bool IsOwnedByDocument() const {
+    return mDocumentAssociationMode == OwnedByDocument;
+  }
+
+  void SetAssociatedDocument(nsIDocument* aDocument,
+                             DocumentAssociationMode aMode);
+  void ClearAssociatedDocument();
+  nsINode* GetOwnerNode() const { return mOwningNode; }
+  inline StyleSheet* GetParentSheet() const { return mParent; }
+
+  void AppendStyleSheet(StyleSheet* aSheet);
+
+  StyleSheet* GetFirstChild() const;
+
+
+  inline nsIPrincipal* Principal() const;
+
+
+
+
+
+  inline void SetPrincipal(nsIPrincipal* aPrincipal);
+
+  void SetTitle(const nsAString& aTitle) { mTitle = aTitle; }
+  void SetMedia(dom::MediaList* aMedia);
+
+
+  inline CORSMode GetCORSMode() const;
+
+  inline net::ReferrerPolicy GetReferrerPolicy() const;
+
+  inline void GetIntegrity(dom::SRIMetadata& aResult) const;
+
+  virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
+  inline StyleSheet* GetParentStyleSheet() const;
+
+  dom::MediaList* Media();
+  bool Disabled() const { return mDisabled; }
+
+
+
+  virtual css::Rule* GetDOMOwnerRule() const = 0;
+  dom::CSSRuleList* GetCssRules(nsIPrincipal& aSubjectPrincipal,
+                                ErrorResult& aRv);
+  uint32_t InsertRule(const nsAString& aRule, uint32_t aIndex,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv);
+  void DeleteRule(uint32_t aIndex,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv);
+
+
+  inline dom::ParentObject GetParentObject() const;
+  JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
+
+
+  virtual nsresult GetType(nsAString& aType) final;
+  virtual nsresult GetDisabled(bool* aDisabled) final;
+  virtual nsresult SetDisabled(bool aDisabled) final;
+  virtual nsresult GetOwnerNode(nsIDOMNode** aOwnerNode) final;
+  virtual nsresult GetParentStyleSheet(nsIDOMStyleSheet** aParentStyleSheet) final;
+  virtual nsresult GetHref(nsAString& aHref) final;
+  virtual nsresult GetTitle(nsAString& aTitle) final;
+  virtual nsresult GetMedia(nsIDOMMediaList** aMedia) final;
+
+
+  virtual nsresult GetOwnerRule(nsIDOMCSSRule** aOwnerRule) final;
+  virtual nsresult GetCssRules(nsIDOMCSSRuleList** aCssRules) final;
+  virtual nsresult InsertRule(const nsAString& aRule, uint32_t aIndex,
+                      uint32_t* aReturn) final;
+  virtual nsresult DeleteRule(uint32_t aIndex) final;
+
+
+
+
+  inline void WillDirty();
+  inline void DidDirty();
+
+  nsresult DeleteRuleFromGroup(css::GroupRule* aGroup, uint32_t aIndex);
+  nsresult InsertRuleIntoGroup(const nsAString& aRule,
+                               css::GroupRule* aGroup, uint32_t aIndex);
+
+private:
+
+
+  inline StyleSheetInfo& SheetInfo();
+  inline const StyleSheetInfo& SheetInfo() const;
+
+
+
+
+
+  bool AreRulesAvailable(nsIPrincipal& aSubjectPrincipal,
+                         ErrorResult& aRv);
+
+protected:
+  struct ChildSheetListBuilder {
+    RefPtr<StyleSheet>* sheetSlot;
+    StyleSheet* parent;
+
+    void SetParentLinks(StyleSheet* aSheet);
+
+    static void ReparentChildList(StyleSheet* aPrimarySheet,
+                                  StyleSheet* aFirstChild);
+  };
+
+  void UnparentChildren();
+
+
+
+
+
+  void SubjectSubsumesInnerPrincipal(nsIPrincipal& aSubjectPrincipal,
+                                     ErrorResult& aRv);
+
+
+  void DropMedia();
+
+
+  void EnabledStateChanged();
+
+
+  virtual void UnlinkInner();
+
+  virtual void TraverseInner(nsCycleCollectionTraversalCallback &);
+
+  StyleSheet* mParent;
+
+  nsString mTitle;
+  nsIDocument* mDocument;
+  nsINode* mOwningNode;
+
+  RefPtr<dom::MediaList> mMedia;
+
+  RefPtr<StyleSheet> mNext;
+
+
+
+
+  css::SheetParsingMode mParsingMode;
+
+  const StyleBackendType mType;
+  bool mDisabled;
+
+
+
+
+  DocumentAssociationMode mDocumentAssociationMode;
+
+
+
+  StyleSheetInfo* mInner;
+
+  friend class ::nsCSSRuleProcessor;
+
+
+
+
+  friend class mozilla::CSSStyleSheet;
+  friend class mozilla::ServoStyleSheet;
+
+
+
+  friend struct mozilla::StyleSheetInfo;
+  friend struct mozilla::CSSStyleSheetInner;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSEnabledState.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSEnabledState.h"
+namespace mozilla {
+
+enum class CSSEnabledState
+{
+
+
+  eForAllContent = 0,
+
+  eInUASheets = 0x01,
+
+  eInChrome = 0x02,
+
+
+
+
+  eIgnoreEnabledState = 0xff
+};
+
+inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator |(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) | U(b))); } inline CSSEnabledState& operator |=(CSSEnabledState& a, CSSEnabledState b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator &(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) & U(b))); } inline CSSEnabledState& operator &=(CSSEnabledState& a, CSSEnabledState b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator ^(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) ^ U(b))); } inline CSSEnabledState& operator ^=(CSSEnabledState& a, CSSEnabledState b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator~(CSSEnabledState a) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(~(U(a)))); }
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
+namespace mozilla {
+
+
+
+typedef uint8_t CSSPseudoElementTypeBase;
+enum class CSSPseudoElementType : CSSPseudoElementTypeBase {
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h" 1
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h"
+after,
+before,
+
+backdrop,
+
+cue,
+
+
+firstLetter,
+
+
+firstLine,
+
+
+
+mozSelection,
+
+
+
+
+mozFocusInner,
+mozFocusOuter,
+
+
+
+mozListBullet,
+mozListNumber,
+
+mozMathAnonymous,
+
+
+mozNumberWrapper,
+
+
+mozNumberText,
+
+
+mozNumberSpinBox,
+
+
+mozNumberSpinUp,
+
+
+mozNumberSpinDown,
+
+
+mozProgressBar,
+
+mozRangeTrack,
+
+mozRangeProgress,
+
+mozRangeThumb,
+
+mozMeterBar,
+
+mozPlaceholder,
+
+placeholder,
+
+mozColorSwatch,
+# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
+
+  Count,
+  InheritingAnonBox = Count,
+
+  NonInheritingAnonBox,
+
+  XULTree,
+
+  NotPseudo,
+  MAX
+};
+
+}
+
+
+
+class nsICSSPseudoElement : public nsIAtom {};
+
+class nsCSSPseudoElements
+{
+  typedef mozilla::CSSPseudoElementType Type;
+  typedef mozilla::CSSEnabledState EnabledState;
+
+public:
+  static void AddRefAtoms();
+
+  static bool IsPseudoElement(nsIAtom *aAtom);
+
+  static bool IsCSS2PseudoElement(nsIAtom *aAtom);
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h" 1
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h"
+static nsICSSPseudoElement* after;
+static nsICSSPseudoElement* before;
+
+static nsICSSPseudoElement* backdrop;
+
+static nsICSSPseudoElement* cue;
+
+
+static nsICSSPseudoElement* firstLetter;
+
+
+static nsICSSPseudoElement* firstLine;
+
+
+
+static nsICSSPseudoElement* mozSelection;
+
+
+
+
+static nsICSSPseudoElement* mozFocusInner;
+static nsICSSPseudoElement* mozFocusOuter;
+
+
+
+static nsICSSPseudoElement* mozListBullet;
+static nsICSSPseudoElement* mozListNumber;
+
+static nsICSSPseudoElement* mozMathAnonymous;
+
+
+static nsICSSPseudoElement* mozNumberWrapper;
+
+
+static nsICSSPseudoElement* mozNumberText;
+
+
+static nsICSSPseudoElement* mozNumberSpinBox;
+
+
+static nsICSSPseudoElement* mozNumberSpinUp;
+
+
+static nsICSSPseudoElement* mozNumberSpinDown;
+
+
+static nsICSSPseudoElement* mozProgressBar;
+
+static nsICSSPseudoElement* mozRangeTrack;
+
+static nsICSSPseudoElement* mozRangeProgress;
+
+static nsICSSPseudoElement* mozRangeThumb;
+
+static nsICSSPseudoElement* mozMeterBar;
+
+static nsICSSPseudoElement* mozPlaceholder;
+
+static nsICSSPseudoElement* placeholder;
+
+static nsICSSPseudoElement* mozColorSwatch;
+# 88 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
+
+
+  static Type GetPseudoType(nsIAtom* aAtom, EnabledState aEnabledState);
+
+
+  static nsIAtom* GetPseudoAtom(Type aType);
+
+  static bool PseudoElementContainsElements(const Type aType) {
+    return PseudoElementHasFlags(aType, (1<<1));
+  }
+
+  static bool PseudoElementSupportsStyleAttribute(const Type aType) {
+    do { } while (0);
+    return PseudoElementHasFlags(aType,
+                                 (1<<2));
+  }
+
+  static bool PseudoElementSupportsUserActionState(const Type aType);
+
+  static bool PseudoElementIsJSCreatedNAC(Type aType)
+  {
+    return PseudoElementHasFlags(aType, (1<<5));
+  }
+
+  static bool IsEnabled(Type aType, EnabledState aEnabledState)
+  {
+    return !PseudoElementHasFlags(aType, (1<<4)) ||
+           (aEnabledState & EnabledState::eInUASheets);
+  }
+
+private:
+# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
+  static bool PseudoElementHasFlags(const Type aType, uint32_t aFlags)
+  {
+    do { } while (0);
+    return (kPseudoElementFlags[size_t(aType)] & aFlags) == aFlags;
+  }
+
+  static const uint32_t kPseudoElementFlags[size_t(Type::Count)];
+};
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
+
+
+namespace mozilla {
+class CSSStyleSheet;
+class ServoStyleSet;
+namespace dom {
+class Element;
+}
+}
+struct nsFontFaceRuleContainer;
+class nsIAtom;
+class nsIContent;
+class nsIDocument;
+class nsStyleContext;
+class nsStyleSet;
+class nsPresContext;
+struct TreeMatchContext;
+
+namespace mozilla {
+
+
+
+
+
+
+
+class StyleSetHandle
+{
+public:
+
+
+
+
+  class Ptr
+  {
+  public:
+    friend class ::mozilla::StyleSetHandle;
+
+    bool IsGecko() const { return !IsServo(); }
+    bool IsServo() const
+    {
+      do { } while (0);
+
+      return mValue & 0x1;
+
+
+
+    }
+
+    StyleBackendType BackendType() const
+    {
+      return IsGecko() ? StyleBackendType::Gecko :
+                         StyleBackendType::Servo;
+    }
+
+    nsStyleSet* AsGecko()
+    {
+      do { } while (0);
+      return reinterpret_cast<nsStyleSet*>(mValue);
+    }
+
+    ServoStyleSet* AsServo()
+    {
+      do { } while (0);
+      return reinterpret_cast<ServoStyleSet*>(mValue & ~0x1);
+    }
+
+    nsStyleSet* GetAsGecko() { return IsGecko() ? AsGecko() : nullptr; }
+    ServoStyleSet* GetAsServo() { return IsServo() ? AsServo() : nullptr; }
+
+    const nsStyleSet* AsGecko() const
+    {
+      return const_cast<Ptr*>(this)->AsGecko();
+    }
+
+    const ServoStyleSet* AsServo() const
+    {
+      do { } while (0);
+      return const_cast<Ptr*>(this)->AsServo();
+    }
+
+    const nsStyleSet* GetAsGecko() const { return IsGecko() ? AsGecko() : nullptr; }
+    const ServoStyleSet* GetAsServo() const { return IsServo() ? AsServo() : nullptr; }
+
+
+    inline void Delete();
+
+
+
+
+
+
+    inline void Init(nsPresContext* aPresContext);
+    inline void BeginShutdown();
+    inline void Shutdown();
+    inline bool GetAuthorStyleDisabled() const;
+    inline nsresult SetAuthorStyleDisabled(bool aStyleDisabled);
+    inline void BeginUpdate();
+    inline nsresult EndUpdate();
+    inline already_AddRefed<nsStyleContext>
+    ResolveStyleFor(dom::Element* aElement,
+                    nsStyleContext* aParentContext,
+                    LazyComputeBehavior aMayCompute);
+    inline already_AddRefed<nsStyleContext>
+    ResolveStyleFor(dom::Element* aElement,
+                    nsStyleContext* aParentContext,
+                    LazyComputeBehavior aMayCompute,
+                    TreeMatchContext& aTreeMatchContext);
+    inline already_AddRefed<nsStyleContext>
+    ResolveStyleForText(nsIContent* aTextNode,
+                        nsStyleContext* aParentContext);
+    inline already_AddRefed<nsStyleContext>
+    ResolveStyleForFirstLetterContinuation(nsStyleContext* aParentContext);
+    inline already_AddRefed<nsStyleContext>
+    ResolveStyleForPlaceholder();
+    inline already_AddRefed<nsStyleContext>
+    ResolvePseudoElementStyle(dom::Element* aParentElement,
+                              mozilla::CSSPseudoElementType aType,
+                              nsStyleContext* aParentContext,
+                              dom::Element* aPseudoElement);
+    inline already_AddRefed<nsStyleContext>
+    ResolveInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag,
+                                       nsStyleContext* aParentContext,
+                                       uint32_t aFlags = 0);
+    inline already_AddRefed<nsStyleContext>
+    ResolveNonInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag);
+    inline nsresult AppendStyleSheet(SheetType aType, StyleSheet* aSheet);
+    inline nsresult PrependStyleSheet(SheetType aType, StyleSheet* aSheet);
+    inline nsresult RemoveStyleSheet(SheetType aType, StyleSheet* aSheet);
+    inline nsresult ReplaceSheets(SheetType aType,
+                           const nsTArray<RefPtr<StyleSheet>>& aNewSheets);
+    inline nsresult InsertStyleSheetBefore(SheetType aType,
+                                    StyleSheet* aNewSheet,
+                                    StyleSheet* aReferenceSheet);
+    inline int32_t SheetCount(SheetType aType) const;
+    inline StyleSheet* StyleSheetAt(SheetType aType, int32_t aIndex) const;
+    inline nsresult RemoveDocStyleSheet(StyleSheet* aSheet);
+    inline nsresult AddDocStyleSheet(StyleSheet* aSheet, nsIDocument* aDocument);
+    inline already_AddRefed<nsStyleContext>
+    ProbePseudoElementStyle(dom::Element* aParentElement,
+                            mozilla::CSSPseudoElementType aType,
+                            nsStyleContext* aParentContext);
+    inline already_AddRefed<nsStyleContext>
+    ProbePseudoElementStyle(dom::Element* aParentElement,
+                            mozilla::CSSPseudoElementType aType,
+                            nsStyleContext* aParentContext,
+                            TreeMatchContext& aTreeMatchContext,
+                            dom::Element* aPseudoElement = nullptr);
+    inline nsRestyleHint HasStateDependentStyle(dom::Element* aElement,
+                                                EventStates aStateMask);
+    inline nsRestyleHint HasStateDependentStyle(
+        dom::Element* aElement,
+        mozilla::CSSPseudoElementType aPseudoType,
+        dom::Element* aPseudoElement,
+        EventStates aStateMask);
+
+    inline void RootStyleContextAdded();
+    inline void RootStyleContextRemoved();
+
+    inline bool AppendFontFaceRules(nsTArray<nsFontFaceRuleContainer>& aArray);
+
+  private:
+
+
+
+
+    uintptr_t mValue;
+  };
+
+  StyleSetHandle() { mPtr.mValue = 0; }
+  StyleSetHandle(const StyleSetHandle& aOth) { mPtr.mValue = aOth.mPtr.mValue; }
+               StyleSetHandle(nsStyleSet* aSet) { *this = aSet; }
+               StyleSetHandle(ServoStyleSet* aSet) { *this = aSet; }
+
+  StyleSetHandle& operator=(nsStyleSet* aStyleSet)
+  {
+    do { } while (0);
+
+    mPtr.mValue = reinterpret_cast<uintptr_t>(aStyleSet);
+    return *this;
+  }
+
+  StyleSetHandle& operator=(ServoStyleSet* aStyleSet)
+  {
+
+    do { } while (0);
+
+    mPtr.mValue =
+      aStyleSet ? (reinterpret_cast<uintptr_t>(aStyleSet) | 0x1) : 0;
+    return *this;
+
+
+
+
+  }
+
+
+  explicit operator bool() const { return !!mPtr.mValue; }
+  bool operator!() const { return !mPtr.mValue; }
+
+
+  Ptr* operator->() { return &mPtr; }
+  const Ptr* operator->() const { return &mPtr; }
+
+private:
+  Ptr mPtr;
+};
+
+
+
+}
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Triangle.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Triangle.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+template<class Units, class F = Float>
+struct TriangleTyped
+{
+  PointTyped<Units, F> p1, p2, p3;
+  F width, height;
+
+  TriangleTyped()
+    : p1(), p2(), p3() {}
+
+  TriangleTyped(PointTyped<Units, F> aP1,
+                PointTyped<Units, F> aP2,
+                PointTyped<Units, F> aP3)
+    : p1(aP1), p2(aP2), p3(aP3) {}
+
+  RectTyped<Units, F> BoundingBox() const
+  {
+    F minX = std::min(std::min(p1.x, p2.x), p3.x);
+    F maxX = std::max(std::max(p1.x, p2.x), p3.x);
+
+    F minY = std::min(std::min(p1.y, p2.y), p3.y);
+    F maxY = std::max(std::max(p1.y, p2.y), p3.y);
+
+    return RectTyped<Units, F>(minX, minY, maxX - minX, maxY - minY);
+  }
+};
+
+typedef TriangleTyped<UnknownUnits, Float> Triangle;
+
+template<class Units, class F = Float>
+struct TexturedTriangleTyped : public TriangleTyped<Units, F>
+{
+  explicit TexturedTriangleTyped(const TriangleTyped<Units, F>& aTriangle)
+    : TriangleTyped<Units, F>(aTriangle) {}
+
+  explicit TexturedTriangleTyped(TriangleTyped<Units, F>&& aTriangle)
+    : TriangleTyped<Units, F>(Move(aTriangle)) {}
+
+  TriangleTyped<Units, F> textureCoords;
+};
+
+typedef TexturedTriangleTyped<UnknownUnits, Float> TexturedTriangle;
+
+}
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/MatrixFwd.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/MatrixFwd.h"
+namespace mozilla {
+namespace gfx {
+
+struct UnknownUnits;
+
+template<class SourceUnits, class TargetUnits>
+class Matrix4x4Typed;
+
+typedef Matrix4x4Typed<UnknownUnits, UnknownUnits> Matrix4x4;
+
+}
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 2
+
+
+namespace mozilla {
+namespace gfx {
+
+class Quaternion
+{
+public:
+  Quaternion()
+    : x(0.0f), y(0.0f), z(0.0f), w(1.0f)
+  {}
+
+  Quaternion(Float aX, Float aY, Float aZ, Float aW)
+    : x(aX), y(aY), z(aZ), w(aW)
+  {}
+
+
+  Quaternion(const Quaternion& aOther)
+  {
+    memcpy(this, &aOther, sizeof(*this));
+  }
+
+  Float x, y, z, w;
+
+  friend std::ostream& operator<<(std::ostream& aStream, const Quaternion& aQuat);
+
+  void Set(Float aX, Float aY, Float aZ, Float aW)
+  {
+    x = aX; y = aY; z = aZ; w = aW;
+  }
+
+
+  void SetFromRotationMatrix(const Matrix4x4& aMatrix);
+
+
+  Quaternion operator*(const Quaternion &aQuat) const
+  {
+    Quaternion o;
+    const Float bx = aQuat.x, by = aQuat.y, bz = aQuat.z, bw = aQuat.w;
+
+    o.x = x*bw + w*bx + y*bz - z*by;
+    o.y = y*bw + w*by + z*bx - x*bz;
+    o.z = z*bw + w*bz + x*by - y*bx;
+    o.w = w*bw - x*bx - y*by - z*bz;
+    return o;
+  }
+
+  Quaternion& operator*=(const Quaternion &aQuat)
+  {
+    *this = *this * aQuat;
+    return *this;
+  }
+
+  Float Length() const
+  {
+    return sqrt(x*x + y*y + z*z + w*w);
+  }
+
+  Quaternion& Conjugate()
+  {
+    x *= -1.f; y *= -1.f; z *= -1.f;
+    return *this;
+  }
+
+  Quaternion& Normalize()
+  {
+    Float l = Length();
+    if (l) {
+      l = 1.0f / l;
+      x *= l; y *= l; z *= l; w *= l;
+    } else {
+      x = y = z = 0.f;
+      w = 1.f;
+    }
+    return *this;
+  }
+
+  Quaternion& Invert()
+  {
+    return Conjugate().Normalize();
+  }
+
+  Point3D RotatePoint(const Point3D& aPoint) {
+    Float uvx = Float(2.0) * (y*aPoint.z - z*aPoint.y);
+    Float uvy = Float(2.0) * (z*aPoint.x - x*aPoint.z);
+    Float uvz = Float(2.0) * (x*aPoint.y - y*aPoint.x);
+
+    return Point3D(aPoint.x + w*uvx + y*uvz - z*uvy,
+                   aPoint.y + w*uvy + z*uvx - x*uvz,
+                   aPoint.z + w*uvz + x*uvy - y*uvx);
+  }
+};
+
+}
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
+
+
+
+
+namespace mozilla {
+namespace gfx {
+
+static bool FuzzyEqual(Float aV1, Float aV2) {
+
+  return fabs(aV2 - aV1) < 1e-6;
+}
+
+class Matrix
+{
+public:
+  Matrix()
+    : _11(1.0f), _12(0)
+    , _21(0), _22(1.0f)
+    , _31(0), _32(0)
+  {}
+  Matrix(Float a11, Float a12, Float a21, Float a22, Float a31, Float a32)
+    : _11(a11), _12(a12)
+    , _21(a21), _22(a22)
+    , _31(a31), _32(a32)
+  {}
+  union {
+    struct {
+      Float _11, _12;
+      Float _21, _22;
+      Float _31, _32;
+    };
+    Float components[6];
+  };
+
+  __attribute__((always_inline)) inline Matrix Copy() const
+  {
+    return Matrix(*this);
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream, const Matrix& aMatrix);
+
+  Point TransformPoint(const Point &aPoint) const
+  {
+    Point retPoint;
+
+    retPoint.x = aPoint.x * _11 + aPoint.y * _21 + _31;
+    retPoint.y = aPoint.x * _12 + aPoint.y * _22 + _32;
+
+    return retPoint;
+  }
+
+  Size TransformSize(const Size &aSize) const
+  {
+    Size retSize;
+
+    retSize.width = aSize.width * _11 + aSize.height * _21;
+    retSize.height = aSize.width * _12 + aSize.height * _22;
+
+    return retSize;
+  }
+
+            Rect TransformBounds(const Rect& rect) const;
+
+  static Matrix Translation(Float aX, Float aY)
+  {
+    return Matrix(1.0f, 0.0f, 0.0f, 1.0f, aX, aY);
+  }
+
+  static Matrix Translation(Point aPoint)
+  {
+    return Translation(aPoint.x, aPoint.y);
+  }
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  Matrix &PreTranslate(Float aX, Float aY)
+  {
+    _31 += _11 * aX + _21 * aY;
+    _32 += _12 * aX + _22 * aY;
+
+    return *this;
+  }
+
+  Matrix &PreTranslate(const Point &aPoint)
+  {
+    return PreTranslate(aPoint.x, aPoint.y);
+  }
+# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  Matrix &PostTranslate(Float aX, Float aY)
+  {
+    _31 += aX;
+    _32 += aY;
+    return *this;
+  }
+
+  Matrix &PostTranslate(const Point &aPoint)
+  {
+    return PostTranslate(aPoint.x, aPoint.y);
+  }
+
+  static Matrix Scaling(Float aScaleX, Float aScaleY)
+  {
+    return Matrix(aScaleX, 0.0f, 0.0f, aScaleY, 0.0f, 0.0f);
+  }
+
+
+
+
+  Matrix &PreScale(Float aX, Float aY)
+  {
+    _11 *= aX;
+    _12 *= aX;
+    _21 *= aY;
+    _22 *= aY;
+
+    return *this;
+  }
+
+
+
+
+  Matrix &PostScale(Float aScaleX, Float aScaleY)
+  {
+    _11 *= aScaleX;
+    _12 *= aScaleY;
+    _21 *= aScaleX;
+    _22 *= aScaleY;
+    _31 *= aScaleX;
+    _32 *= aScaleY;
+
+    return *this;
+  }
+
+            static Matrix Rotation(Float aAngle);
+
+
+
+
+  Matrix &PreRotate(Float aAngle)
+  {
+    return *this = Matrix::Rotation(aAngle) * *this;
+  }
+
+  bool Invert()
+  {
+
+    Float A = _22;
+    Float B = -_21;
+    Float C = _21 * _32 - _22 * _31;
+    Float D = -_12;
+    Float E = _11;
+    Float F = _31 * _12 - _11 * _32;
+
+    Float det = Determinant();
+
+    if (!det) {
+      return false;
+    }
+
+    Float inv_det = 1 / det;
+
+    _11 = inv_det * A;
+    _12 = inv_det * D;
+    _21 = inv_det * B;
+    _22 = inv_det * E;
+    _31 = inv_det * C;
+    _32 = inv_det * F;
+
+    return true;
+  }
+
+  Matrix Inverse() const
+  {
+    Matrix clone = *this;
+    DebugOnly<bool> inverted = clone.Invert();
+    do { } while (0);
+    return clone;
+  }
+
+  Float Determinant() const
+  {
+    return _11 * _22 - _12 * _21;
+  }
+
+  Matrix operator*(const Matrix &aMatrix) const
+  {
+    Matrix resultMatrix;
+
+    resultMatrix._11 = this->_11 * aMatrix._11 + this->_12 * aMatrix._21;
+    resultMatrix._12 = this->_11 * aMatrix._12 + this->_12 * aMatrix._22;
+    resultMatrix._21 = this->_21 * aMatrix._11 + this->_22 * aMatrix._21;
+    resultMatrix._22 = this->_21 * aMatrix._12 + this->_22 * aMatrix._22;
+    resultMatrix._31 = this->_31 * aMatrix._11 + this->_32 * aMatrix._21 + aMatrix._31;
+    resultMatrix._32 = this->_31 * aMatrix._12 + this->_32 * aMatrix._22 + aMatrix._32;
+
+    return resultMatrix;
+  }
+
+  Matrix& operator*=(const Matrix &aMatrix)
+  {
+    *this = *this * aMatrix;
+    return *this;
+  }
+
+
+
+
+  Matrix &PreMultiply(const Matrix &aMatrix)
+  {
+    *this = aMatrix * *this;
+    return *this;
+  }
+
+
+
+
+  bool operator==(const Matrix& other) const
+  {
+    return FuzzyEqual(_11, other._11) && FuzzyEqual(_12, other._12) &&
+           FuzzyEqual(_21, other._21) && FuzzyEqual(_22, other._22) &&
+           FuzzyEqual(_31, other._31) && FuzzyEqual(_32, other._32);
+  }
+
+  bool operator!=(const Matrix& other) const
+  {
+    return !(*this == other);
+  }
+
+  bool ExactlyEquals(const Matrix& o) const
+  {
+    return _11 == o._11 && _12 == o._12 &&
+           _21 == o._21 && _22 == o._22 &&
+           _31 == o._31 && _32 == o._32;
+  }
+
+
+  bool IsFinite() const
+  {
+    return mozilla::IsFinite(_11) && mozilla::IsFinite(_12) &&
+           mozilla::IsFinite(_21) && mozilla::IsFinite(_22) &&
+           mozilla::IsFinite(_31) && mozilla::IsFinite(_32);
+  }
+
+
+
+
+  bool IsRectilinear() const {
+    if (FuzzyEqual(_12, 0) && FuzzyEqual(_21, 0)) {
+      return true;
+    } else if (FuzzyEqual(_22, 0) && FuzzyEqual(_11, 0)) {
+      return true;
+    }
+
+    return false;
+  }
+
+
+
+
+
+  bool HasNonIntegerTranslation() const {
+    return HasNonTranslation() ||
+      !FuzzyEqual(_31, floor(_31 + Float(0.5))) ||
+      !FuzzyEqual(_32, floor(_32 + Float(0.5)));
+  }
+
+
+
+
+  bool HasOnlyIntegerTranslation() const {
+    return !HasNonIntegerTranslation();
+  }
+
+
+
+
+
+  bool HasNonTranslation() const {
+    return !FuzzyEqual(_11, 1.0) || !FuzzyEqual(_22, 1.0) ||
+           !FuzzyEqual(_12, 0.0) || !FuzzyEqual(_21, 0.0);
+  }
+
+
+
+
+
+  bool HasNonTranslationOrFlip() const {
+      return !FuzzyEqual(_11, 1.0) ||
+             (!FuzzyEqual(_22, 1.0) && !FuzzyEqual(_22, -1.0)) ||
+             !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
+  }
+
+
+
+  bool IsIdentity() const
+  {
+    return _11 == 1.0f && _12 == 0.0f &&
+           _21 == 0.0f && _22 == 1.0f &&
+           _31 == 0.0f && _32 == 0.0f;
+  }
+
+
+
+  bool IsSingular() const
+  {
+    Float det = Determinant();
+    return !mozilla::IsFinite(det) || det == 0;
+  }
+
+            Matrix &NudgeToIntegers();
+
+  bool IsTranslation() const
+  {
+    return FuzzyEqual(_11, 1.0f) && FuzzyEqual(_12, 0.0f) &&
+           FuzzyEqual(_21, 0.0f) && FuzzyEqual(_22, 1.0f);
+  }
+
+  static bool FuzzyIsInteger(Float aValue)
+  {
+    return FuzzyEqual(aValue, floorf(aValue + 0.5f));
+  }
+
+  bool IsIntegerTranslation() const
+  {
+    return IsTranslation() && FuzzyIsInteger(_31) && FuzzyIsInteger(_32);
+  }
+
+  bool IsAllIntegers() const
+  {
+    return FuzzyIsInteger(_11) && FuzzyIsInteger(_12) &&
+           FuzzyIsInteger(_21) && FuzzyIsInteger(_22) &&
+           FuzzyIsInteger(_31) && FuzzyIsInteger(_32);
+  }
+
+  Point GetTranslation() const {
+    return Point(_31, _32);
+  }
+
+
+
+
+
+  bool PreservesAxisAlignedRectangles() const {
+      return ((FuzzyEqual(_11, 0.0) && FuzzyEqual(_22, 0.0))
+          || (FuzzyEqual(_12, 0.0) && FuzzyEqual(_21, 0.0)));
+  }
+
+
+
+
+
+
+  bool HasNonAxisAlignedTransform() const {
+      return !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
+  }
+
+
+
+
+  bool HasNegativeScaling() const {
+      return (_11 < 0.0) || (_22 < 0.0);
+  }
+};
+
+
+double
+SafeTangent(double aTheta);
+double
+FlushToZero(double aVal);
+
+template<class Units, class F>
+Point4DTyped<Units, F>
+ComputePerspectivePlaneIntercept(const Point4DTyped<Units, F>& aFirst,
+                                 const Point4DTyped<Units, F>& aSecond)
+{
+# 429 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  float t = -aFirst.w / (aSecond.w - aFirst.w);
+
+
+  return aFirst + (aSecond - aFirst) * t;
+}
+
+
+template <typename SourceUnits, typename TargetUnits>
+class Matrix4x4Typed
+{
+public:
+  typedef PointTyped<SourceUnits> SourcePoint;
+  typedef PointTyped<TargetUnits> TargetPoint;
+  typedef Point3DTyped<SourceUnits> SourcePoint3D;
+  typedef Point3DTyped<TargetUnits> TargetPoint3D;
+  typedef Point4DTyped<SourceUnits> SourcePoint4D;
+  typedef Point4DTyped<TargetUnits> TargetPoint4D;
+  typedef RectTyped<SourceUnits> SourceRect;
+  typedef RectTyped<TargetUnits> TargetRect;
+
+  Matrix4x4Typed()
+    : _11(1.0f), _12(0.0f), _13(0.0f), _14(0.0f)
+    , _21(0.0f), _22(1.0f), _23(0.0f), _24(0.0f)
+    , _31(0.0f), _32(0.0f), _33(1.0f), _34(0.0f)
+    , _41(0.0f), _42(0.0f), _43(0.0f), _44(1.0f)
+  {}
+
+  Matrix4x4Typed(Float a11, Float a12, Float a13, Float a14,
+                 Float a21, Float a22, Float a23, Float a24,
+                 Float a31, Float a32, Float a33, Float a34,
+                 Float a41, Float a42, Float a43, Float a44)
+    : _11(a11), _12(a12), _13(a13), _14(a14)
+    , _21(a21), _22(a22), _23(a23), _24(a24)
+    , _31(a31), _32(a32), _33(a33), _34(a34)
+    , _41(a41), _42(a42), _43(a43), _44(a44)
+  {}
+
+  explicit Matrix4x4Typed(const Float aArray[16])
+  {
+    memcpy(components, aArray, sizeof(components));
+  }
+
+  Matrix4x4Typed(const Matrix4x4Typed& aOther)
+  {
+    memcpy(this, &aOther, sizeof(*this));
+  }
+
+  union {
+    struct {
+      Float _11, _12, _13, _14;
+      Float _21, _22, _23, _24;
+      Float _31, _32, _33, _34;
+      Float _41, _42, _43, _44;
+    };
+    Float components[16];
+  };
+
+  friend std::ostream& operator<<(std::ostream& aStream, const Matrix4x4Typed& aMatrix)
+  {
+    const Float *f = &aMatrix._11;
+    aStream << "[ " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
+    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
+    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
+    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ]" << std::endl;
+    return aStream;
+  }
+
+  Point4D& operator[](int aIndex)
+  {
+      do { } while (0);
+      return *reinterpret_cast<Point4D*>((&_11)+4*aIndex);
+  }
+  const Point4D& operator[](int aIndex) const
+  {
+      do { } while (0);
+      return *reinterpret_cast<const Point4D*>((&_11)+4*aIndex);
+  }
+
+
+
+
+  bool Is2D() const
+  {
+    if (_13 != 0.0f || _14 != 0.0f ||
+        _23 != 0.0f || _24 != 0.0f ||
+        _31 != 0.0f || _32 != 0.0f || _33 != 1.0f || _34 != 0.0f ||
+        _43 != 0.0f || _44 != 1.0f) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Is2D(Matrix* aMatrix) const {
+    if (!Is2D()) {
+      return false;
+    }
+    if (aMatrix) {
+      aMatrix->_11 = _11;
+      aMatrix->_12 = _12;
+      aMatrix->_21 = _21;
+      aMatrix->_22 = _22;
+      aMatrix->_31 = _41;
+      aMatrix->_32 = _42;
+    }
+    return true;
+  }
+
+  Matrix As2D() const
+  {
+    do { } while (0);
+
+    return Matrix(_11, _12, _21, _22, _41, _42);
+  }
+
+  bool CanDraw2D(Matrix* aMatrix = nullptr) const {
+    if (_14 != 0.0f ||
+        _24 != 0.0f ||
+        _44 != 1.0f) {
+      return false;
+    }
+    if (aMatrix) {
+      aMatrix->_11 = _11;
+      aMatrix->_12 = _12;
+      aMatrix->_21 = _21;
+      aMatrix->_22 = _22;
+      aMatrix->_31 = _41;
+      aMatrix->_32 = _42;
+    }
+    return true;
+  }
+
+  Matrix4x4Typed& ProjectTo2D() {
+    _31 = 0.0f;
+    _32 = 0.0f;
+    _13 = 0.0f;
+    _23 = 0.0f;
+    _33 = 1.0f;
+    _43 = 0.0f;
+    _34 = 0.0f;
+
+
+
+
+
+
+
+    if (_14 == 0.0f && _24 == 0.0f &&
+        _44 != 1.0f && _44 != 0.0f) {
+      Float scale = 1.0f / _44;
+      _11 *= scale;
+      _12 *= scale;
+      _21 *= scale;
+      _22 *= scale;
+      _41 *= scale;
+      _42 *= scale;
+      _44 = 1.0f;
+    }
+    return *this;
+  }
+
+  template<class F>
+  Point4DTyped<TargetUnits, F>
+  ProjectPoint(const PointTyped<SourceUnits, F>& aPoint) const {
+
+
+
+
+
+
+    F z = -(aPoint.x * _13 + aPoint.y * _23 + _43) / _33;
+
+
+    return this->TransformPoint(Point4DTyped<SourceUnits, F>(aPoint.x, aPoint.y, z, 1));
+  }
+
+  template<class F>
+  RectTyped<TargetUnits, F>
+  ProjectRectBounds(const RectTyped<SourceUnits, F>& aRect, const RectTyped<TargetUnits, F>& aClip) const
+  {
+# 632 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+    Point4DTyped<TargetUnits, F> points[4];
+
+    points[0] = ProjectPoint(aRect.TopLeft());
+    points[1] = ProjectPoint(aRect.TopRight());
+    points[2] = ProjectPoint(aRect.BottomRight());
+    points[3] = ProjectPoint(aRect.BottomLeft());
+
+    F min_x = std::numeric_limits<F>::max();
+    F min_y = std::numeric_limits<F>::max();
+    F max_x = -std::numeric_limits<F>::max();
+    F max_y = -std::numeric_limits<F>::max();
+
+    for (int i=0; i<4; i++) {
+
+      if (points[i].HasPositiveWCoord()) {
+        PointTyped<TargetUnits, F> point2d = aClip.ClampPoint(points[i].As2DPoint());
+        min_x = std::min<F>(point2d.x, min_x);
+        max_x = std::max<F>(point2d.x, max_x);
+        min_y = std::min<F>(point2d.y, min_y);
+        max_y = std::max<F>(point2d.y, max_y);
+      }
+
+      int next = (i == 3) ? 0 : i + 1;
+      if (points[i].HasPositiveWCoord() != points[next].HasPositiveWCoord()) {
+
+
+
+        Point4DTyped<TargetUnits, F> intercept =
+          ComputePerspectivePlaneIntercept(points[i], points[next]);
+
+
+        if (intercept.x < 0.0f) {
+          min_x = aClip.x;
+        } else if (intercept.x > 0.0f) {
+          max_x = aClip.XMost();
+        }
+        if (intercept.y < 0.0f) {
+          min_y = aClip.y;
+        } else if (intercept.y > 0.0f) {
+          max_y = aClip.YMost();
+        }
+      }
+    }
+
+    if (max_x < min_x || max_y < min_y) {
+      return RectTyped<TargetUnits, F>(0, 0, 0, 0);
+    }
+
+    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
+  }
+
+
+
+
+
+  template<class F>
+  RectTyped<TargetUnits, F> TransformAndClipBounds(const RectTyped<SourceUnits, F>& aRect,
+                                                   const RectTyped<TargetUnits, F>& aClip) const
+  {
+    PointTyped<UnknownUnits, F> verts[kTransformAndClipRectMaxVerts];
+    size_t vertCount = TransformAndClipRect(aRect, aClip, verts);
+
+    F min_x = std::numeric_limits<F>::max();
+    F min_y = std::numeric_limits<F>::max();
+    F max_x = -std::numeric_limits<F>::max();
+    F max_y = -std::numeric_limits<F>::max();
+    for (size_t i=0; i < vertCount; i++) {
+      min_x = std::min(min_x, verts[i].x);
+      max_x = std::max(max_x, verts[i].x);
+      min_y = std::min(min_y, verts[i].y);
+      max_y = std::max(max_y, verts[i].y);
+    }
+
+    if (max_x < min_x || max_y < min_y) {
+      return RectTyped<TargetUnits, F>(0, 0, 0, 0);
+    }
+
+    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
+  }
+
+  template<class F>
+  RectTyped<TargetUnits, F> TransformAndClipBounds(const TriangleTyped<SourceUnits, F>& aTriangle,
+                                                   const RectTyped<TargetUnits, F>& aClip) const
+  {
+    return TransformAndClipBounds(aTriangle.BoundingBox(), aClip);
+  }
+# 729 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  template<class F>
+  size_t TransformAndClipRect(const RectTyped<SourceUnits, F>& aRect,
+                              const RectTyped<TargetUnits, F>& aClip,
+                              PointTyped<TargetUnits, F>* aVerts) const
+  {
+
+
+    Point4DTyped<UnknownUnits, F> points[2][kTransformAndClipRectMaxVerts];
+    Point4DTyped<UnknownUnits, F>* dstPoint = points[0];
+
+    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.x, aRect.y, 0, 1));
+    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.XMost(), aRect.y, 0, 1));
+    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.XMost(), aRect.YMost(), 0, 1));
+    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.x, aRect.YMost(), 0, 1));
+
+
+
+    Point4DTyped<UnknownUnits, F> planeNormals[4];
+    planeNormals[0] = Point4DTyped<UnknownUnits, F>(1.0, 0.0, 0.0, -aClip.x);
+    planeNormals[1] = Point4DTyped<UnknownUnits, F>(-1.0, 0.0, 0.0, aClip.XMost());
+    planeNormals[2] = Point4DTyped<UnknownUnits, F>(0.0, 1.0, 0.0, -aClip.y);
+    planeNormals[3] = Point4DTyped<UnknownUnits, F>(0.0, -1.0, 0.0, aClip.YMost());
+
+
+
+
+    for (int plane=0; plane < 4; plane++) {
+      planeNormals[plane].Normalize();
+      Point4DTyped<UnknownUnits, F>* srcPoint = points[plane & 1];
+      Point4DTyped<UnknownUnits, F>* srcPointEnd = dstPoint;
+
+      dstPoint = points[~plane & 1];
+      Point4DTyped<UnknownUnits, F>* dstPointStart = dstPoint;
+
+      Point4DTyped<UnknownUnits, F>* prevPoint = srcPointEnd - 1;
+      F prevDot = planeNormals[plane].DotProduct(*prevPoint);
+      while (srcPoint < srcPointEnd && ((dstPoint - dstPointStart) < kTransformAndClipRectMaxVerts)) {
+        F nextDot = planeNormals[plane].DotProduct(*srcPoint);
+
+        if ((nextDot >= 0.0) != (prevDot >= 0.0)) {
+
+
+          F t = -prevDot / (nextDot - prevDot);
+          *dstPoint++ = *srcPoint * t + *prevPoint * (1.0 - t);
+        }
+
+        if (nextDot >= 0.0) {
+
+
+          *dstPoint++ = *srcPoint;
+        }
+
+        prevPoint = srcPoint++;
+        prevDot = nextDot;
+      }
+
+      if (dstPoint == dstPointStart) {
+        break;
+      }
+    }
+
+    size_t dstPointCount = 0;
+    size_t srcPointCount = dstPoint - points[0];
+    for (Point4DTyped<UnknownUnits, F>* srcPoint = points[0]; srcPoint < points[0] + srcPointCount; srcPoint++) {
+
+      PointTyped<TargetUnits, F> p;
+      if (srcPoint->w == 0.0) {
+
+
+        p = PointTyped<TargetUnits, F>(0.0, 0.0);
+      } else {
+        p = srcPoint->As2DPoint();
+      }
+
+      if (dstPointCount == 0 || p != aVerts[dstPointCount - 1]) {
+        aVerts[dstPointCount++] = p;
+      }
+    }
+
+    return dstPointCount;
+  }
+
+  static const int kTransformAndClipRectMaxVerts = 32;
+
+  static Matrix4x4Typed From2D(const Matrix &aMatrix) {
+    Matrix4x4Typed matrix;
+    matrix._11 = aMatrix._11;
+    matrix._12 = aMatrix._12;
+    matrix._21 = aMatrix._21;
+    matrix._22 = aMatrix._22;
+    matrix._41 = aMatrix._31;
+    matrix._42 = aMatrix._32;
+    return matrix;
+  }
+
+  bool Is2DIntegerTranslation() const
+  {
+    return Is2D() && As2D().IsIntegerTranslation();
+  }
+
+  TargetPoint4D TransposeTransform4D(const SourcePoint4D& aPoint) const
+  {
+      Float x = aPoint.x * _11 + aPoint.y * _12 + aPoint.z * _13 + aPoint.w * _14;
+      Float y = aPoint.x * _21 + aPoint.y * _22 + aPoint.z * _23 + aPoint.w * _24;
+      Float z = aPoint.x * _31 + aPoint.y * _32 + aPoint.z * _33 + aPoint.w * _34;
+      Float w = aPoint.x * _41 + aPoint.y * _42 + aPoint.z * _43 + aPoint.w * _44;
+
+      return TargetPoint4D(x, y, z, w);
+  }
+
+  template<class F>
+  Point4DTyped<TargetUnits, F> TransformPoint(const Point4DTyped<SourceUnits, F>& aPoint) const
+  {
+    Point4DTyped<TargetUnits, F> retPoint;
+
+    retPoint.x = aPoint.x * _11 + aPoint.y * _21 + aPoint.z * _31 + aPoint.w * _41;
+    retPoint.y = aPoint.x * _12 + aPoint.y * _22 + aPoint.z * _32 + aPoint.w * _42;
+    retPoint.z = aPoint.x * _13 + aPoint.y * _23 + aPoint.z * _33 + aPoint.w * _43;
+    retPoint.w = aPoint.x * _14 + aPoint.y * _24 + aPoint.z * _34 + aPoint.w * _44;
+
+    return retPoint;
+  }
+
+  template<class F>
+  Point3DTyped<TargetUnits, F> TransformPoint(const Point3DTyped<SourceUnits, F>& aPoint) const
+  {
+    Point3DTyped<TargetUnits, F> result;
+    result.x = aPoint.x * _11 + aPoint.y * _21 + aPoint.z * _31 + _41;
+    result.y = aPoint.x * _12 + aPoint.y * _22 + aPoint.z * _32 + _42;
+    result.z = aPoint.x * _13 + aPoint.y * _23 + aPoint.z * _33 + _43;
+
+    result /= (aPoint.x * _14 + aPoint.y * _24 + aPoint.z * _34 + _44);
+
+    return result;
+  }
+
+  template<class F>
+  PointTyped<TargetUnits, F> TransformPoint(const PointTyped<SourceUnits, F> &aPoint) const
+  {
+    Point4DTyped<SourceUnits, F> temp(aPoint.x, aPoint.y, 0, 1);
+    return TransformPoint(temp).As2DPoint();
+  }
+
+  template<class F>
+            RectTyped<TargetUnits, F> TransformBounds(const RectTyped<SourceUnits, F>& aRect) const
+  {
+    Point4DTyped<TargetUnits, F> verts[4];
+    verts[0] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.x, aRect.y, 0.0, 1.0));
+    verts[1] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.XMost(), aRect.y, 0.0, 1.0));
+    verts[2] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.XMost(), aRect.YMost(), 0.0, 1.0));
+    verts[3] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.x, aRect.YMost(), 0.0, 1.0));
+
+    PointTyped<TargetUnits, F> quad[4];
+    F min_x, max_x;
+    F min_y, max_y;
+
+    quad[0] = TransformPoint(aRect.TopLeft());
+    quad[1] = TransformPoint(aRect.TopRight());
+    quad[2] = TransformPoint(aRect.BottomLeft());
+    quad[3] = TransformPoint(aRect.BottomRight());
+
+    min_x = max_x = quad[0].x;
+    min_y = max_y = quad[0].y;
+
+    for (int i = 1; i < 4; i++) {
+      if (quad[i].x < min_x) {
+        min_x = quad[i].x;
+      }
+      if (quad[i].x > max_x) {
+        max_x = quad[i].x;
+      }
+
+      if (quad[i].y < min_y) {
+        min_y = quad[i].y;
+      }
+      if (quad[i].y > max_y) {
+        max_y = quad[i].y;
+      }
+    }
+
+    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
+  }
+
+  static Matrix4x4Typed Translation(Float aX, Float aY, Float aZ)
+  {
+    return Matrix4x4Typed(1.0f, 0.0f, 0.0f, 0.0f,
+                          0.0f, 1.0f, 0.0f, 0.0f,
+                          0.0f, 0.0f, 1.0f, 0.0f,
+                          aX, aY, aZ, 1.0f);
+  }
+
+  static Matrix4x4Typed Translation(const TargetPoint3D& aP)
+  {
+    return Translation(aP.x, aP.y, aP.z);
+  }
+
+  static Matrix4x4Typed Translation(const TargetPoint& aP)
+  {
+    return Translation(aP.x, aP.y, 0);
+  }
+# 949 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  Matrix4x4Typed &PreTranslate(Float aX, Float aY, Float aZ)
+  {
+    _41 += aX * _11 + aY * _21 + aZ * _31;
+    _42 += aX * _12 + aY * _22 + aZ * _32;
+    _43 += aX * _13 + aY * _23 + aZ * _33;
+    _44 += aX * _14 + aY * _24 + aZ * _34;
+
+    return *this;
+  }
+
+  Matrix4x4Typed &PreTranslate(const Point3D& aPoint) {
+    return PreTranslate(aPoint.x, aPoint.y, aPoint.z);
+  }
+# 975 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
+  Matrix4x4Typed &PostTranslate(Float aX, Float aY, Float aZ)
+  {
+    _11 += _14 * aX;
+    _21 += _24 * aX;
+    _31 += _34 * aX;
+    _41 += _44 * aX;
+    _12 += _14 * aY;
+    _22 += _24 * aY;
+    _32 += _34 * aY;
+    _42 += _44 * aY;
+    _13 += _14 * aZ;
+    _23 += _24 * aZ;
+    _33 += _34 * aZ;
+    _43 += _44 * aZ;
+
+    return *this;
+  }
+
+  Matrix4x4Typed &PostTranslate(const TargetPoint3D& aPoint) {
+    return PostTranslate(aPoint.x, aPoint.y, aPoint.z);
+  }
+
+  Matrix4x4Typed &PostTranslate(const TargetPoint& aPoint) {
+    return PostTranslate(aPoint.x, aPoint.y, 0);
+  }
+
+  static Matrix4x4Typed Scaling(Float aScaleX, Float aScaleY, float aScaleZ)
+  {
+    return Matrix4x4Typed(aScaleX, 0.0f, 0.0f, 0.0f,
+                          0.0f, aScaleY, 0.0f, 0.0f,
+                          0.0f, 0.0f, aScaleZ, 0.0f,
+                          0.0f, 0.0f, 0.0f, 1.0f);
+  }
+
+
+
+
+  Matrix4x4Typed &PreScale(Float aX, Float aY, Float aZ)
+  {
+    _11 *= aX;
+    _12 *= aX;
+    _13 *= aX;
+    _14 *= aX;
+    _21 *= aY;
+    _22 *= aY;
+    _23 *= aY;
+    _24 *= aY;
+    _31 *= aZ;
+    _32 *= aZ;
+    _33 *= aZ;
+    _34 *= aZ;
+
+    return *this;
+  }
+
+
+
+
+  Matrix4x4Typed &PostScale(Float aScaleX, Float aScaleY, Float aScaleZ)
+  {
+    _11 *= aScaleX;
+    _21 *= aScaleX;
+    _31 *= aScaleX;
+    _41 *= aScaleX;
+    _12 *= aScaleY;
+    _22 *= aScaleY;
+    _32 *= aScaleY;
+    _42 *= aScaleY;
+    _13 *= aScaleZ;
+    _23 *= aScaleZ;
+    _33 *= aScaleZ;
+    _43 *= aScaleZ;
+
+    return *this;
+  }
+
+  void SkewXY(Float aSkew)
+  {
+    (*this)[1] += (*this)[0] * aSkew;
+  }
+
+  void SkewXZ(Float aSkew)
+  {
+      (*this)[2] += (*this)[0] * aSkew;
+  }
+
+  void SkewYZ(Float aSkew)
+  {
+      (*this)[2] += (*this)[1] * aSkew;
+  }
+
+  Matrix4x4Typed &ChangeBasis(const Point3D& aOrigin)
+  {
+    return ChangeBasis(aOrigin.x, aOrigin.y, aOrigin.z);
+  }
+
+  Matrix4x4Typed &ChangeBasis(Float aX, Float aY, Float aZ)
+  {
+
+    PreTranslate(-aX, -aY, -aZ);
+
+
+    PostTranslate(aX, aY, aZ);
+
+    return *this;
+  }
+
+  Matrix4x4Typed& Transpose() {
+    std::swap(_12, _21);
+    std::swap(_13, _31);
+    std::swap(_14, _41);
+
+    std::swap(_23, _32);
+    std::swap(_24, _42);
+
+    std::swap(_34, _43);
+
+    return *this;
+  }
+
+  bool operator==(const Matrix4x4Typed& o) const
+  {
+
+    return _11 == o._11 && _12 == o._12 && _13 == o._13 && _14 == o._14 &&
+           _21 == o._21 && _22 == o._22 && _23 == o._23 && _24 == o._24 &&
+           _31 == o._31 && _32 == o._32 && _33 == o._33 && _34 == o._34 &&
+           _41 == o._41 && _42 == o._42 && _43 == o._43 && _44 == o._44;
+  }
+
+  bool operator!=(const Matrix4x4Typed& o) const
+  {
+    return !((*this) == o);
+  }
+
+  template <typename NewTargetUnits>
+  Matrix4x4Typed<SourceUnits, NewTargetUnits> operator*(const Matrix4x4Typed<TargetUnits, NewTargetUnits> &aMatrix) const
+  {
+    Matrix4x4Typed<SourceUnits, NewTargetUnits> matrix;
+
+    matrix._11 = _11 * aMatrix._11 + _12 * aMatrix._21 + _13 * aMatrix._31 + _14 * aMatrix._41;
+    matrix._21 = _21 * aMatrix._11 + _22 * aMatrix._21 + _23 * aMatrix._31 + _24 * aMatrix._41;
+    matrix._31 = _31 * aMatrix._11 + _32 * aMatrix._21 + _33 * aMatrix._31 + _34 * aMatrix._41;
+    matrix._41 = _41 * aMatrix._11 + _42 * aMatrix._21 + _43 * aMatrix._31 + _44 * aMatrix._41;
+    matrix._12 = _11 * aMatrix._12 + _12 * aMatrix._22 + _13 * aMatrix._32 + _14 * aMatrix._42;
+    matrix._22 = _21 * aMatrix._12 + _22 * aMatrix._22 + _23 * aMatrix._32 + _24 * aMatrix._42;
+    matrix._32 = _31 * aMatrix._12 + _32 * aMatrix._22 + _33 * aMatrix._32 + _34 * aMatrix._42;
+    matrix._42 = _41 * aMatrix._12 + _42 * aMatrix._22 + _43 * aMatrix._32 + _44 * aMatrix._42;
+    matrix._13 = _11 * aMatrix._13 + _12 * aMatrix._23 + _13 * aMatrix._33 + _14 * aMatrix._43;
+    matrix._23 = _21 * aMatrix._13 + _22 * aMatrix._23 + _23 * aMatrix._33 + _24 * aMatrix._43;
+    matrix._33 = _31 * aMatrix._13 + _32 * aMatrix._23 + _33 * aMatrix._33 + _34 * aMatrix._43;
+    matrix._43 = _41 * aMatrix._13 + _42 * aMatrix._23 + _43 * aMatrix._33 + _44 * aMatrix._43;
+    matrix._14 = _11 * aMatrix._14 + _12 * aMatrix._24 + _13 * aMatrix._34 + _14 * aMatrix._44;
+    matrix._24 = _21 * aMatrix._14 + _22 * aMatrix._24 + _23 * aMatrix._34 + _24 * aMatrix._44;
+    matrix._34 = _31 * aMatrix._14 + _32 * aMatrix._24 + _33 * aMatrix._34 + _34 * aMatrix._44;
+    matrix._44 = _41 * aMatrix._14 + _42 * aMatrix._24 + _43 * aMatrix._34 + _44 * aMatrix._44;
+
+    return matrix;
+  }
+
+  Matrix4x4Typed& operator*=(const Matrix4x4Typed<TargetUnits, TargetUnits> &aMatrix)
+  {
+    *this = *this * aMatrix;
+    return *this;
+  }
+
+
+
+  bool IsIdentity() const
+  {
+    return _11 == 1.0f && _12 == 0.0f && _13 == 0.0f && _14 == 0.0f &&
+           _21 == 0.0f && _22 == 1.0f && _23 == 0.0f && _24 == 0.0f &&
+           _31 == 0.0f && _32 == 0.0f && _33 == 1.0f && _34 == 0.0f &&
+           _41 == 0.0f && _42 == 0.0f && _43 == 0.0f && _44 == 1.0f;
+  }
+
+  bool IsSingular() const
+  {
+    return Determinant() == 0.0;
+  }
+
+  Float Determinant() const
+  {
+    return _14 * _23 * _32 * _41
+         - _13 * _24 * _32 * _41
+         - _14 * _22 * _33 * _41
+         + _12 * _24 * _33 * _41
+         + _13 * _22 * _34 * _41
+         - _12 * _23 * _34 * _41
+         - _14 * _23 * _31 * _42
+         + _13 * _24 * _31 * _42
+         + _14 * _21 * _33 * _42
+         - _11 * _24 * _33 * _42
+         - _13 * _21 * _34 * _42
+         + _11 * _23 * _34 * _42
+         + _14 * _22 * _31 * _43
+         - _12 * _24 * _31 * _43
+         - _14 * _21 * _32 * _43
+         + _11 * _24 * _32 * _43
+         + _12 * _21 * _34 * _43
+         - _11 * _22 * _34 * _43
+         - _13 * _22 * _31 * _44
+         + _12 * _23 * _31 * _44
+         + _13 * _21 * _32 * _44
+         - _11 * _23 * _32 * _44
+         - _12 * _21 * _33 * _44
+         + _11 * _22 * _33 * _44;
+  }
+
+
+  bool Invert()
+  {
+    Float det = Determinant();
+    if (!det) {
+      return false;
+    }
+
+    Matrix4x4Typed<SourceUnits, TargetUnits> result;
+    result._11 = _23 * _34 * _42 - _24 * _33 * _42 + _24 * _32 * _43 - _22 * _34 * _43 - _23 * _32 * _44 + _22 * _33 * _44;
+    result._12 = _14 * _33 * _42 - _13 * _34 * _42 - _14 * _32 * _43 + _12 * _34 * _43 + _13 * _32 * _44 - _12 * _33 * _44;
+    result._13 = _13 * _24 * _42 - _14 * _23 * _42 + _14 * _22 * _43 - _12 * _24 * _43 - _13 * _22 * _44 + _12 * _23 * _44;
+    result._14 = _14 * _23 * _32 - _13 * _24 * _32 - _14 * _22 * _33 + _12 * _24 * _33 + _13 * _22 * _34 - _12 * _23 * _34;
+    result._21 = _24 * _33 * _41 - _23 * _34 * _41 - _24 * _31 * _43 + _21 * _34 * _43 + _23 * _31 * _44 - _21 * _33 * _44;
+    result._22 = _13 * _34 * _41 - _14 * _33 * _41 + _14 * _31 * _43 - _11 * _34 * _43 - _13 * _31 * _44 + _11 * _33 * _44;
+    result._23 = _14 * _23 * _41 - _13 * _24 * _41 - _14 * _21 * _43 + _11 * _24 * _43 + _13 * _21 * _44 - _11 * _23 * _44;
+    result._24 = _13 * _24 * _31 - _14 * _23 * _31 + _14 * _21 * _33 - _11 * _24 * _33 - _13 * _21 * _34 + _11 * _23 * _34;
+    result._31 = _22 * _34 * _41 - _24 * _32 * _41 + _24 * _31 * _42 - _21 * _34 * _42 - _22 * _31 * _44 + _21 * _32 * _44;
+    result._32 = _14 * _32 * _41 - _12 * _34 * _41 - _14 * _31 * _42 + _11 * _34 * _42 + _12 * _31 * _44 - _11 * _32 * _44;
+    result._33 = _12 * _24 * _41 - _14 * _22 * _41 + _14 * _21 * _42 - _11 * _24 * _42 - _12 * _21 * _44 + _11 * _22 * _44;
+    result._34 = _14 * _22 * _31 - _12 * _24 * _31 - _14 * _21 * _32 + _11 * _24 * _32 + _12 * _21 * _34 - _11 * _22 * _34;
+    result._41 = _23 * _32 * _41 - _22 * _33 * _41 - _23 * _31 * _42 + _21 * _33 * _42 + _22 * _31 * _43 - _21 * _32 * _43;
+    result._42 = _12 * _33 * _41 - _13 * _32 * _41 + _13 * _31 * _42 - _11 * _33 * _42 - _12 * _31 * _43 + _11 * _32 * _43;
+    result._43 = _13 * _22 * _41 - _12 * _23 * _41 - _13 * _21 * _42 + _11 * _23 * _42 + _12 * _21 * _43 - _11 * _22 * _43;
+    result._44 = _12 * _23 * _31 - _13 * _22 * _31 + _13 * _21 * _32 - _11 * _23 * _32 - _12 * _21 * _33 + _11 * _22 * _33;
+
+    result._11 /= det;
+    result._12 /= det;
+    result._13 /= det;
+    result._14 /= det;
+    result._21 /= det;
+    result._22 /= det;
+    result._23 /= det;
+    result._24 /= det;
+    result._31 /= det;
+    result._32 /= det;
+    result._33 /= det;
+    result._34 /= det;
+    result._41 /= det;
+    result._42 /= det;
+    result._43 /= det;
+    result._44 /= det;
+    *this = result;
+
+    return true;
+  }
+
+  Matrix4x4Typed<TargetUnits, SourceUnits> Inverse() const
+  {
+    typedef Matrix4x4Typed<TargetUnits, SourceUnits> InvertedMatrix;
+    InvertedMatrix clone = InvertedMatrix::FromUnknownMatrix(ToUnknownMatrix());
+    DebugOnly<bool> inverted = clone.Invert();
+    do { } while (0);
+    return clone;
+  }
+
+  Maybe<Matrix4x4Typed<TargetUnits, SourceUnits>> MaybeInverse() const
+  {
+    typedef Matrix4x4Typed<TargetUnits, SourceUnits> InvertedMatrix;
+    InvertedMatrix clone = InvertedMatrix::FromUnknownMatrix(ToUnknownMatrix());
+    if (clone.Invert()) {
+      return Some(clone);
+    }
+    return Nothing();
+  }
+
+  void Normalize()
+  {
+      for (int i = 0; i < 4; i++) {
+          for (int j = 0; j < 4; j++) {
+              (*this)[i][j] /= (*this)[3][3];
+         }
+      }
+  }
+
+  bool FuzzyEqual(const Matrix4x4Typed& o) const
+  {
+    return gfx::FuzzyEqual(_11, o._11) && gfx::FuzzyEqual(_12, o._12) &&
+           gfx::FuzzyEqual(_13, o._13) && gfx::FuzzyEqual(_14, o._14) &&
+           gfx::FuzzyEqual(_21, o._21) && gfx::FuzzyEqual(_22, o._22) &&
+           gfx::FuzzyEqual(_23, o._23) && gfx::FuzzyEqual(_24, o._24) &&
+           gfx::FuzzyEqual(_31, o._31) && gfx::FuzzyEqual(_32, o._32) &&
+           gfx::FuzzyEqual(_33, o._33) && gfx::FuzzyEqual(_34, o._34) &&
+           gfx::FuzzyEqual(_41, o._41) && gfx::FuzzyEqual(_42, o._42) &&
+           gfx::FuzzyEqual(_43, o._43) && gfx::FuzzyEqual(_44, o._44);
+  }
+
+  bool FuzzyEqualsMultiplicative(const Matrix4x4Typed& o) const
+  {
+    return ::mozilla::FuzzyEqualsMultiplicative(_11, o._11) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_12, o._12) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_13, o._13) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_14, o._14) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_21, o._21) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_22, o._22) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_23, o._23) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_24, o._24) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_31, o._31) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_32, o._32) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_33, o._33) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_34, o._34) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_41, o._41) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_42, o._42) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_43, o._43) &&
+           ::mozilla::FuzzyEqualsMultiplicative(_44, o._44);
+  }
+
+  bool IsBackfaceVisible() const
+  {
+
+    Float det = Determinant();
+    Float __33 = _12*_24*_41 - _14*_22*_41 +
+                _14*_21*_42 - _11*_24*_42 -
+                _12*_21*_44 + _11*_22*_44;
+    return (__33 * det) < 0;
+  }
+
+  Matrix4x4Typed &NudgeToIntegersFixedEpsilon()
+  {
+    NudgeToInteger(&_11);
+    NudgeToInteger(&_12);
+    NudgeToInteger(&_13);
+    NudgeToInteger(&_14);
+    NudgeToInteger(&_21);
+    NudgeToInteger(&_22);
+    NudgeToInteger(&_23);
+    NudgeToInteger(&_24);
+    NudgeToInteger(&_31);
+    NudgeToInteger(&_32);
+    NudgeToInteger(&_33);
+    NudgeToInteger(&_34);
+    static const float error = 1e-5f;
+    NudgeToInteger(&_41, error);
+    NudgeToInteger(&_42, error);
+    NudgeToInteger(&_43, error);
+    NudgeToInteger(&_44, error);
+    return *this;
+  }
+
+  Point4D TransposedVector(int aIndex) const
+  {
+      do { } while (0);
+      return Point4D(*((&_11)+aIndex), *((&_21)+aIndex), *((&_31)+aIndex), *((&_41)+aIndex));
+  }
+
+  void SetTransposedVector(int aIndex, Point4D &aVector)
+  {
+      do { } while (0);
+      *((&_11)+aIndex) = aVector.x;
+      *((&_21)+aIndex) = aVector.y;
+      *((&_31)+aIndex) = aVector.z;
+      *((&_41)+aIndex) = aVector.w;
+  }
+
+
+
+
+  void SetRotationFromQuaternion(const Quaternion& q)
+  {
+    const Float x2 = q.x + q.x, y2 = q.y + q.y, z2 = q.z + q.z;
+    const Float xx = q.x * x2, xy = q.x * y2, xz = q.x * z2;
+    const Float yy = q.y * y2, yz = q.y * z2, zz = q.z * z2;
+    const Float wx = q.w * x2, wy = q.w * y2, wz = q.w * z2;
+
+    _11 = 1.0f - (yy + zz);
+    _21 = xy + wz;
+    _31 = xz - wy;
+    _41 = 0.0f;
+
+    _12 = xy - wz;
+    _22 = 1.0f - (xx + zz);
+    _32 = yz + wx;
+    _42 = 0.0f;
+
+    _13 = xz + wy;
+    _23 = yz - wx;
+    _33 = 1.0f - (xx + yy);
+    _43 = 0.0f;
+
+    _14 = _42 = _43 = 0.0f;
+    _44 = 1.0f;
+  }
+
+
+  void SetNAN()
+  {
+    _11 = UnspecifiedNaN<Float>();
+    _21 = UnspecifiedNaN<Float>();
+    _31 = UnspecifiedNaN<Float>();
+    _41 = UnspecifiedNaN<Float>();
+    _12 = UnspecifiedNaN<Float>();
+    _22 = UnspecifiedNaN<Float>();
+    _32 = UnspecifiedNaN<Float>();
+    _42 = UnspecifiedNaN<Float>();
+    _13 = UnspecifiedNaN<Float>();
+    _23 = UnspecifiedNaN<Float>();
+    _33 = UnspecifiedNaN<Float>();
+    _43 = UnspecifiedNaN<Float>();
+    _14 = UnspecifiedNaN<Float>();
+    _24 = UnspecifiedNaN<Float>();
+    _34 = UnspecifiedNaN<Float>();
+    _44 = UnspecifiedNaN<Float>();
+  }
+
+  void SkewXY(double aXSkew, double aYSkew)
+  {
+
+    float tanX = SafeTangent(aXSkew);
+    float tanY = SafeTangent(aYSkew);
+    float temp;
+
+    temp = _11;
+    _11 += tanY * _21;
+    _21 += tanX * temp;
+
+    temp = _12;
+    _12 += tanY * _22;
+    _22 += tanX * temp;
+
+    temp = _13;
+    _13 += tanY * _23;
+    _23 += tanX * temp;
+
+    temp = _14;
+    _14 += tanY * _24;
+    _24 += tanX * temp;
+  }
+
+  void RotateX(double aTheta)
+  {
+
+    double cosTheta = FlushToZero(cos(aTheta));
+    double sinTheta = FlushToZero(sin(aTheta));
+
+    float temp;
+
+    temp = _21;
+    _21 = cosTheta * _21 + sinTheta * _31;
+    _31 = -sinTheta * temp + cosTheta * _31;
+
+    temp = _22;
+    _22 = cosTheta * _22 + sinTheta * _32;
+    _32 = -sinTheta * temp + cosTheta * _32;
+
+    temp = _23;
+    _23 = cosTheta * _23 + sinTheta * _33;
+    _33 = -sinTheta * temp + cosTheta * _33;
+
+    temp = _24;
+    _24 = cosTheta * _24 + sinTheta * _34;
+    _34 = -sinTheta * temp + cosTheta * _34;
+  }
+
+  void RotateY(double aTheta)
+  {
+
+    double cosTheta = FlushToZero(cos(aTheta));
+    double sinTheta = FlushToZero(sin(aTheta));
+
+    float temp;
+
+    temp = _11;
+    _11 = cosTheta * _11 + -sinTheta * _31;
+    _31 = sinTheta * temp + cosTheta * _31;
+
+    temp = _12;
+    _12 = cosTheta * _12 + -sinTheta * _32;
+    _32 = sinTheta * temp + cosTheta * _32;
+
+    temp = _13;
+    _13 = cosTheta * _13 + -sinTheta * _33;
+    _33 = sinTheta * temp + cosTheta * _33;
+
+    temp = _14;
+    _14 = cosTheta * _14 + -sinTheta * _34;
+    _34 = sinTheta * temp + cosTheta * _34;
+  }
+
+  void RotateZ(double aTheta)
+  {
+
+    double cosTheta = FlushToZero(cos(aTheta));
+    double sinTheta = FlushToZero(sin(aTheta));
+
+    float temp;
+
+    temp = _11;
+    _11 = cosTheta * _11 + sinTheta * _21;
+    _21 = -sinTheta * temp + cosTheta * _21;
+
+    temp = _12;
+    _12 = cosTheta * _12 + sinTheta * _22;
+    _22 = -sinTheta * temp + cosTheta * _22;
+
+    temp = _13;
+    _13 = cosTheta * _13 + sinTheta * _23;
+    _23 = -sinTheta * temp + cosTheta * _23;
+
+    temp = _14;
+    _14 = cosTheta * _14 + sinTheta * _24;
+    _24 = -sinTheta * temp + cosTheta * _24;
+  }
+
+
+
+
+
+  void SetRotateAxisAngle(double aX, double aY, double aZ, double aTheta)
+  {
+    Point3D vector(aX, aY, aZ);
+    if (!vector.Length()) {
+      return;
+    }
+    vector.Normalize();
+
+    double x = vector.x;
+    double y = vector.y;
+    double z = vector.z;
+
+    double cosTheta = FlushToZero(cos(aTheta));
+    double sinTheta = FlushToZero(sin(aTheta));
+
+
+    double sc = sinTheta / 2;
+
+    double sq = (1 - cosTheta) / 2;
+
+    _11 = 1 - 2 * (y * y + z * z) * sq;
+    _12 = 2 * (x * y * sq + z * sc);
+    _13 = 2 * (x * z * sq - y * sc);
+    _14 = 0.0f;
+    _21 = 2 * (x * y * sq - z * sc);
+    _22 = 1 - 2 * (x * x + z * z) * sq;
+    _23 = 2 * (y * z * sq + x * sc);
+    _24 = 0.0f;
+    _31 = 2 * (x * z * sq + y * sc);
+    _32 = 2 * (y * z * sq - x * sc);
+    _33 = 1 - 2 * (x * x + y * y) * sq;
+    _34 = 0.0f;
+    _41 = 0.0f;
+    _42 = 0.0f;
+    _43 = 0.0f;
+    _44 = 1.0f;
+  }
+
+  void Perspective(float aDepth)
+  {
+    do { } while (0);
+    _31 += -1.0/aDepth * _41;
+    _32 += -1.0/aDepth * _42;
+    _33 += -1.0/aDepth * _43;
+    _34 += -1.0/aDepth * _44;
+  }
+
+  Point3D GetNormalVector() const
+  {
+
+
+    Point3D a = TransformPoint(Point3D(0, 0, 0));
+    Point3D b = TransformPoint(Point3D(0, 1, 0));
+    Point3D c = TransformPoint(Point3D(1, 0, 0));
+
+
+    Point3D ab = b - a;
+    Point3D ac = c - a;
+
+    return ac.CrossProduct(ab);
+  }
+
+
+
+
+
+  bool HasNonTranslation() const {
+    return !gfx::FuzzyEqual(_11, 1.0) || !gfx::FuzzyEqual(_22, 1.0) ||
+           !gfx::FuzzyEqual(_12, 0.0) || !gfx::FuzzyEqual(_21, 0.0) ||
+           !gfx::FuzzyEqual(_13, 0.0) || !gfx::FuzzyEqual(_23, 0.0) ||
+           !gfx::FuzzyEqual(_31, 0.0) || !gfx::FuzzyEqual(_32, 0.0) ||
+           !gfx::FuzzyEqual(_33, 1.0);
+  }
+
+
+
+
+
+  bool HasNonIntegerTranslation() const {
+    return HasNonTranslation() ||
+      !gfx::FuzzyEqual(_41, floor(_41 + 0.5)) ||
+      !gfx::FuzzyEqual(_42, floor(_42 + 0.5)) ||
+      !gfx::FuzzyEqual(_43, floor(_43 + 0.5));
+  }
+
+
+
+
+  bool HasPerspectiveComponent() const {
+    return _14 != 0 || _24 != 0 || _34 != 0 || _44 != 1;
+  }
+
+
+
+
+  Matrix4x4 ToUnknownMatrix() const {
+    return Matrix4x4{_11, _12, _13, _14,
+                     _21, _22, _23, _24,
+                     _31, _32, _33, _34,
+                     _41, _42, _43, _44};
+  }
+  static Matrix4x4Typed FromUnknownMatrix(const Matrix4x4& aUnknown) {
+    return Matrix4x4Typed{aUnknown._11, aUnknown._12, aUnknown._13, aUnknown._14,
+                          aUnknown._21, aUnknown._22, aUnknown._23, aUnknown._24,
+                          aUnknown._31, aUnknown._32, aUnknown._33, aUnknown._34,
+                          aUnknown._41, aUnknown._42, aUnknown._43, aUnknown._44};
+  }
+};
+
+typedef Matrix4x4Typed<UnknownUnits, UnknownUnits> Matrix4x4;
+
+class Matrix5x4
+{
+public:
+  Matrix5x4()
+    : _11(1.0f), _12(0), _13(0), _14(0)
+    , _21(0), _22(1.0f), _23(0), _24(0)
+    , _31(0), _32(0), _33(1.0f), _34(0)
+    , _41(0), _42(0), _43(0), _44(1.0f)
+    , _51(0), _52(0), _53(0), _54(0)
+  {}
+  Matrix5x4(Float a11, Float a12, Float a13, Float a14,
+         Float a21, Float a22, Float a23, Float a24,
+         Float a31, Float a32, Float a33, Float a34,
+         Float a41, Float a42, Float a43, Float a44,
+         Float a51, Float a52, Float a53, Float a54)
+    : _11(a11), _12(a12), _13(a13), _14(a14)
+    , _21(a21), _22(a22), _23(a23), _24(a24)
+    , _31(a31), _32(a32), _33(a33), _34(a34)
+    , _41(a41), _42(a42), _43(a43), _44(a44)
+    , _51(a51), _52(a52), _53(a53), _54(a54)
+  {}
+
+  bool operator==(const Matrix5x4 &o) const
+  {
+    return _11 == o._11 && _12 == o._12 && _13 == o._13 && _14 == o._14 &&
+           _21 == o._21 && _22 == o._22 && _23 == o._23 && _24 == o._24 &&
+           _31 == o._31 && _32 == o._32 && _33 == o._33 && _34 == o._34 &&
+           _41 == o._41 && _42 == o._42 && _43 == o._43 && _44 == o._44 &&
+           _51 == o._51 && _52 == o._52 && _53 == o._53 && _54 == o._54;
+  }
+
+  bool operator!=(const Matrix5x4 &aMatrix) const
+  {
+    return !(*this == aMatrix);
+  }
+
+  Matrix5x4 operator*(const Matrix5x4 &aMatrix) const
+  {
+    Matrix5x4 resultMatrix;
+
+    resultMatrix._11 = this->_11 * aMatrix._11 + this->_12 * aMatrix._21 + this->_13 * aMatrix._31 + this->_14 * aMatrix._41;
+    resultMatrix._12 = this->_11 * aMatrix._12 + this->_12 * aMatrix._22 + this->_13 * aMatrix._32 + this->_14 * aMatrix._42;
+    resultMatrix._13 = this->_11 * aMatrix._13 + this->_12 * aMatrix._23 + this->_13 * aMatrix._33 + this->_14 * aMatrix._43;
+    resultMatrix._14 = this->_11 * aMatrix._14 + this->_12 * aMatrix._24 + this->_13 * aMatrix._34 + this->_14 * aMatrix._44;
+    resultMatrix._21 = this->_21 * aMatrix._11 + this->_22 * aMatrix._21 + this->_23 * aMatrix._31 + this->_24 * aMatrix._41;
+    resultMatrix._22 = this->_21 * aMatrix._12 + this->_22 * aMatrix._22 + this->_23 * aMatrix._32 + this->_24 * aMatrix._42;
+    resultMatrix._23 = this->_21 * aMatrix._13 + this->_22 * aMatrix._23 + this->_23 * aMatrix._33 + this->_24 * aMatrix._43;
+    resultMatrix._24 = this->_21 * aMatrix._14 + this->_22 * aMatrix._24 + this->_23 * aMatrix._34 + this->_24 * aMatrix._44;
+    resultMatrix._31 = this->_31 * aMatrix._11 + this->_32 * aMatrix._21 + this->_33 * aMatrix._31 + this->_34 * aMatrix._41;
+    resultMatrix._32 = this->_31 * aMatrix._12 + this->_32 * aMatrix._22 + this->_33 * aMatrix._32 + this->_34 * aMatrix._42;
+    resultMatrix._33 = this->_31 * aMatrix._13 + this->_32 * aMatrix._23 + this->_33 * aMatrix._33 + this->_34 * aMatrix._43;
+    resultMatrix._34 = this->_31 * aMatrix._14 + this->_32 * aMatrix._24 + this->_33 * aMatrix._34 + this->_34 * aMatrix._44;
+    resultMatrix._41 = this->_41 * aMatrix._11 + this->_42 * aMatrix._21 + this->_43 * aMatrix._31 + this->_44 * aMatrix._41;
+    resultMatrix._42 = this->_41 * aMatrix._12 + this->_42 * aMatrix._22 + this->_43 * aMatrix._32 + this->_44 * aMatrix._42;
+    resultMatrix._43 = this->_41 * aMatrix._13 + this->_42 * aMatrix._23 + this->_43 * aMatrix._33 + this->_44 * aMatrix._43;
+    resultMatrix._44 = this->_41 * aMatrix._14 + this->_42 * aMatrix._24 + this->_43 * aMatrix._34 + this->_44 * aMatrix._44;
+    resultMatrix._51 = this->_51 * aMatrix._11 + this->_52 * aMatrix._21 + this->_53 * aMatrix._31 + this->_54 * aMatrix._41 + aMatrix._51;
+    resultMatrix._52 = this->_51 * aMatrix._12 + this->_52 * aMatrix._22 + this->_53 * aMatrix._32 + this->_54 * aMatrix._42 + aMatrix._52;
+    resultMatrix._53 = this->_51 * aMatrix._13 + this->_52 * aMatrix._23 + this->_53 * aMatrix._33 + this->_54 * aMatrix._43 + aMatrix._53;
+    resultMatrix._54 = this->_51 * aMatrix._14 + this->_52 * aMatrix._24 + this->_53 * aMatrix._34 + this->_54 * aMatrix._44 + aMatrix._54;
+
+    return resultMatrix;
+  }
+
+  Matrix5x4& operator*=(const Matrix5x4 &aMatrix)
+  {
+    *this = *this * aMatrix;
+    return *this;
+  }
+
+  union {
+    struct {
+      Float _11, _12, _13, _14;
+      Float _21, _22, _23, _24;
+      Float _31, _32, _33, _34;
+      Float _41, _42, _43, _44;
+      Float _51, _52, _53, _54;
+    };
+    Float components[20];
+  };
+};
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h"
+typedef struct _cairo_surface cairo_surface_t;
+typedef struct _cairo_user_data_key cairo_user_data_key_t;
+
+typedef void (*thebes_destroy_func_t) (void *data);
+
+
+
+
+
+typedef double gfxFloat;
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h"
+enum class gfxBreakPriority {
+  eNoBreak = 0,
+  eWordWrapBreak,
+  eNormalBreak
+};
+
+enum class gfxSurfaceType {
+  Image,
+  PDF,
+  PS,
+  Xlib,
+  Xcb,
+  Glitz,
+  Quartz,
+  Win32,
+  BeOS,
+  DirectFB,
+  SVG,
+  OS2,
+  Win32Printing,
+  QuartzImage,
+  Script,
+  QPainter,
+  Recording,
+  VG,
+  GL,
+  DRM,
+  Tee,
+  XML,
+  Skia,
+  Subsurface,
+  Max
+};
+
+enum class gfxContentType {
+  COLOR = 0x1000,
+  ALPHA = 0x2000,
+  COLOR_ALPHA = 0x3000,
+  SENTINEL = 0xffff
+};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 2
+
+struct gfxSize : public mozilla::gfx::BaseSize<gfxFloat, gfxSize> {
+    typedef mozilla::gfx::BaseSize<gfxFloat, gfxSize> Super;
+
+    gfxSize() : Super() {}
+    gfxSize(gfxFloat aWidth, gfxFloat aHeight) : Super(aWidth, aHeight) {}
+                 gfxSize(const mozilla::gfx::IntSize& aSize) : Super(aSize.width, aSize.height) {}
+};
+
+struct gfxPoint : public mozilla::gfx::BasePoint<gfxFloat, gfxPoint> {
+    typedef mozilla::gfx::BasePoint<gfxFloat, gfxPoint> Super;
+
+    gfxPoint() : Super() {}
+    gfxPoint(gfxFloat aX, gfxFloat aY) : Super(aX, aY) {}
+                 gfxPoint(const nsIntPoint& aPoint) : Super(aPoint.x, aPoint.y) {}
+
+    bool WithinEpsilonOf(const gfxPoint& aPoint, gfxFloat aEpsilon) {
+        return fabs(aPoint.x - x) < aEpsilon && fabs(aPoint.y - y) < aEpsilon;
+    }
+
+    void Transform(const mozilla::gfx::Matrix4x4 &aMatrix)
+    {
+
+      double px = x;
+      double py = y;
+
+      x = px * aMatrix._11 + py * aMatrix._21 + aMatrix._41;
+      y = px * aMatrix._12 + py * aMatrix._22 + aMatrix._42;
+
+      double w = px * aMatrix._14 + py * aMatrix._24 + aMatrix._44;
+      x /= w;
+      y /= w;
+    }
+};
+
+inline gfxPoint
+operator*(const gfxPoint& aPoint, const gfxSize& aSize)
+{
+  return gfxPoint(aPoint.x * aSize.width, aPoint.y * aSize.height);
+}
+
+inline gfxPoint
+operator/(const gfxPoint& aPoint, const gfxSize& aSize)
+{
+  return gfxPoint(aPoint.x / aSize.width, aPoint.y / aSize.height);
+}
+
+inline gfxSize
+operator/(gfxFloat aValue, const gfxSize& aSize)
+{
+  return gfxSize(aValue / aSize.width, aValue / aSize.height);
+}
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionDisplay.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionDisplay.h"
+class nsISelectionDisplay : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    DISPLAY_TEXT = 1,
+    DISPLAY_IMAGES = 2,
+    DISPLAY_FRAMES = 4,
+    DISPLAY_ALL = 7
+  };
+
+
+  virtual nsresult SetSelectionFlags(int16_t toggle) = 0;
+
+
+  virtual nsresult GetSelectionFlags(int16_t *_retval) = 0;
+
+};
+
+  template<typename T> struct nsISelectionDisplay::COMTypeInfo<nsISelectionDisplay, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISelectionDisplay::COMTypeInfo<nsISelectionDisplay, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0ddf9e1c, 0x1dd2, 0x11b2, { 0xa1, 0x83, 0x90, 0x8a, 0x08, 0xaa, 0x75, 0xae }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h" 2
+
+
+
+
+
+
+typedef short SelectionRegion;
+class nsIContent;
+
+class nsIDOMNode;
+
+class nsISelection;
+
+class nsISelectionDisplay;
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
+class nsISelectionController : public nsISelectionDisplay {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    SELECTION_NONE = 0,
+    SELECTION_NORMAL = 1,
+    SELECTION_SPELLCHECK = 2,
+    SELECTION_IME_RAWINPUT = 4,
+    SELECTION_IME_SELECTEDRAWTEXT = 8,
+    SELECTION_IME_CONVERTEDTEXT = 16,
+    SELECTION_IME_SELECTEDCONVERTEDTEXT = 32,
+    SELECTION_ACCESSIBILITY = 64,
+    SELECTION_FIND = 128,
+    SELECTION_URLSECONDARY = 256,
+    SELECTION_URLSTRIKEOUT = 512,
+    NUM_SELECTIONTYPES = 11,
+    SELECTION_ANCHOR_REGION = 0,
+    SELECTION_FOCUS_REGION = 1,
+    SELECTION_WHOLE_SELECTION = 2,
+    NUM_SELECTION_REGIONS = 3,
+    SELECTION_OFF = 0,
+    SELECTION_HIDDEN = 1,
+    SELECTION_ON = 2,
+    SELECTION_DISABLED = 3,
+    SELECTION_ATTENTION = 4
+  };
+
+
+  virtual nsresult SetDisplaySelection(int16_t toggle) = 0;
+
+
+  virtual nsresult GetDisplaySelection(int16_t *_retval) = 0;
+
+
+  virtual nsresult GetSelection(int16_t type, nsISelection * *_retval) = 0;
+
+  enum {
+    SCROLL_SYNCHRONOUS = 2,
+    SCROLL_FIRST_ANCESTOR_ONLY = 4,
+    SCROLL_CENTER_VERTICALLY = 16,
+    SCROLL_OVERFLOW_HIDDEN = 32,
+    SCROLL_FOR_CARET_MOVE = 64
+  };
+
+
+  virtual nsresult ScrollSelectionIntoView(int16_t type, int16_t region, int16_t flags) = 0;
+
+
+  virtual nsresult RepaintSelection(int16_t type) = 0;
+
+
+  virtual nsresult SetCaretEnabled(bool enabled) = 0;
+
+
+  virtual nsresult SetCaretReadOnly(bool readOnly) = 0;
+
+
+  virtual nsresult GetCaretEnabled(bool *_retval) = 0;
+
+
+  virtual nsresult GetCaretVisible(bool *aCaretVisible) = 0;
+
+
+  virtual nsresult SetCaretVisibilityDuringSelection(bool visibility) = 0;
+
+
+  virtual nsresult CharacterMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult PhysicalMove(int16_t direction, int16_t amount, bool extend) = 0;
+
+  enum {
+    MOVE_LEFT = 0,
+    MOVE_RIGHT = 1,
+    MOVE_UP = 2,
+    MOVE_DOWN = 3
+  };
+
+
+  virtual nsresult CharacterExtendForDelete(void) = 0;
+
+
+  virtual nsresult CharacterExtendForBackspace(void) = 0;
+
+
+  virtual nsresult WordMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult WordExtendForDelete(bool forward) = 0;
+
+
+  virtual nsresult LineMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult IntraLineMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult PageMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult CompleteScroll(bool forward) = 0;
+
+
+  virtual nsresult CompleteMove(bool forward, bool extend) = 0;
+
+
+  virtual nsresult ScrollPage(bool forward) = 0;
+
+
+  virtual nsresult ScrollLine(bool forward) = 0;
+
+
+  virtual nsresult ScrollCharacter(bool right) = 0;
+
+
+  virtual nsresult SelectAll(void) = 0;
+
+
+  virtual nsresult CheckVisibility(nsIDOMNode *node, int16_t startOffset, int16_t endOffset, bool *_retval) = 0;
+
+
+  virtual nsresult CheckVisibilityContent(nsIContent *node, int16_t startOffset, int16_t endOffset, bool *_retval) = 0;
+
+};
+
+  template<typename T> struct nsISelectionController::COMTypeInfo<nsISelectionController, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISelectionController::COMTypeInfo<nsISelectionController, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3801c9d4, 0x8e69, 0x4bfc, { 0x9e, 0xdb, 0xb5, 0x82, 0x78, 0x62, 0x1f, 0x8f }};
+# 484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
+namespace mozilla {
+typedef short RawSelectionType;
+enum class SelectionType : RawSelectionType
+{
+  eInvalid = -1,
+  eNone = nsISelectionController::SELECTION_NONE,
+  eNormal = nsISelectionController::SELECTION_NORMAL,
+  eSpellCheck = nsISelectionController::SELECTION_SPELLCHECK,
+  eIMERawClause = nsISelectionController::SELECTION_IME_RAWINPUT,
+  eIMESelectedRawClause = nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT,
+  eIMEConvertedClause = nsISelectionController::SELECTION_IME_CONVERTEDTEXT,
+  eIMESelectedClause =
+    nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT,
+  eAccessibility = nsISelectionController::SELECTION_ACCESSIBILITY,
+  eFind = nsISelectionController::SELECTION_FIND,
+  eURLSecondary = nsISelectionController::SELECTION_URLSECONDARY,
+  eURLStrikeout = nsISelectionController::SELECTION_URLSTRIKEOUT,
+};
+
+
+
+
+
+enum : size_t
+{
+
+  kSelectionTypeCount = nsISelectionController::NUM_SELECTIONTYPES,
+
+  kPresentSelectionTypeCount = kSelectionTypeCount - 1
+};
+const char* ToChar(SelectionType aSelectionType);
+SelectionType ToSelectionType(RawSelectionType aRawSelectionType);
+RawSelectionType ToRawSelectionType(SelectionType aSelectionType);
+bool operator &(SelectionType aSelectionType,
+                RawSelectionType aRawSelectionTypes);
+}
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameManagerBase.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameManagerBase.h"
+class nsIFrame;
+class nsIPresShell;
+
+class nsFrameManagerBase
+{
+public:
+  nsFrameManagerBase();
+
+  bool IsDestroyingFrames() { return mIsDestroyingFrames; }
+
+
+
+
+
+
+  nsIFrame* GetRootFrame() const { return mRootFrame; }
+  void SetRootFrame(nsIFrame* aRootFrame)
+  {
+    do { } while(0);
+    mRootFrame = aRootFrame;
+  }
+
+protected:
+  class UndisplayedMap;
+
+
+  nsIPresShell* mPresShell;
+  nsIFrame* mRootFrame;
+  PLDHashTable mPlaceholderMap;
+  UndisplayedMap* mUndisplayedMap;
+  UndisplayedMap* mDisplayContentsMap;
+  bool mIsDestroyingFrames;
+};
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
+typedef mozilla::gfx::IntRect nsIntRect;
+
+struct nsRect :
+  public mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> {
+  typedef mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> Super;
+
+  static void VERIFY_COORD(nscoord aValue) { ::VERIFY_COORD(aValue); }
+
+
+  nsRect() : Super()
+  {
+                          ;
+  }
+  nsRect(const nsRect& aRect) : Super(aRect)
+  {
+                          ;
+  }
+  nsRect(const nsPoint& aOrigin, const nsSize &aSize) : Super(aOrigin, aSize)
+  {
+                          ;
+  }
+  nsRect(nscoord aX, nscoord aY, nscoord aWidth, nscoord aHeight) :
+      Super(aX, aY, aWidth, aHeight)
+  {
+                          ;
+  }
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
+  __attribute__ ((warn_unused_result)) nsRect SaturatingUnion(const nsRect& aRect) const
+  {
+    if (IsEmpty()) {
+      return aRect;
+    } else if (aRect.IsEmpty()) {
+      return *static_cast<const nsRect*>(this);
+    } else {
+      return SaturatingUnionEdges(aRect);
+    }
+  }
+
+  __attribute__ ((warn_unused_result)) nsRect SaturatingUnionEdges(const nsRect& aRect) const
+  {
+
+
+
+    nsRect result;
+    result.x = std::min(aRect.x, x);
+    int64_t w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
+    if ((__builtin_expect(!!(w > nscoord(1 << 30)), 0))) {
+
+      result.x = std::max(result.x, (-nscoord(1 << 30)) / 2);
+      w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
+      if ((__builtin_expect(!!(w > nscoord(1 << 30)), 0))) {
+        w = nscoord(1 << 30);
+      }
+    }
+    result.width = nscoord(w);
+
+    result.y = std::min(aRect.y, y);
+    int64_t h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
+    if ((__builtin_expect(!!(h > nscoord(1 << 30)), 0))) {
+
+      result.y = std::max(result.y, (-nscoord(1 << 30)) / 2);
+      h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
+      if ((__builtin_expect(!!(h > nscoord(1 << 30)), 0))) {
+        h = nscoord(1 << 30);
+      }
+    }
+    result.height = nscoord(h);
+    return result;
+
+  }
+
+
+
+  __attribute__ ((warn_unused_result)) nsRect UnionEdges(const nsRect& aRect) const
+  {
+    return SaturatingUnionEdges(aRect);
+  }
+  void UnionRectEdges(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    *this = aRect1.UnionEdges(aRect2);
+  }
+  __attribute__ ((warn_unused_result)) nsRect Union(const nsRect& aRect) const
+  {
+    return SaturatingUnion(aRect);
+  }
+  void UnionRect(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    *this = aRect1.Union(aRect2);
+  }
+
+
+  void SaturatingUnionRect(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    *this = aRect1.SaturatingUnion(aRect2);
+  }
+  void SaturatingUnionRectEdges(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    *this = aRect1.SaturatingUnionEdges(aRect2);
+  }
+
+
+  bool Overflows() const;
+# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
+  __attribute__ ((warn_unused_result)) inline nsRect
+    ScaleToOtherAppUnitsRoundOut(int32_t aFromAPP, int32_t aToAPP) const;
+  __attribute__ ((warn_unused_result)) inline nsRect
+    ScaleToOtherAppUnitsRoundIn(int32_t aFromAPP, int32_t aToAPP) const;
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ScaleToNearestPixels(float aXScale, float aYScale,
+                       nscoord aAppUnitsPerPixel) const;
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ToNearestPixels(nscoord aAppUnitsPerPixel) const;
+
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ScaleToOutsidePixels(float aXScale, float aYScale,
+                       nscoord aAppUnitsPerPixel) const;
+
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ToOutsidePixels(nscoord aAppUnitsPerPixel) const;
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ScaleToInsidePixels(float aXScale, float aYScale,
+                      nscoord aAppUnitsPerPixel) const;
+
+  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
+  ToInsidePixels(nscoord aAppUnitsPerPixel) const;
+
+
+  bool operator==(const nsRect& aRect) const
+  {
+    return IsEqualEdges(aRect);
+  }
+
+  __attribute__ ((warn_unused_result)) inline nsRect RemoveResolution(const float aResolution) const;
+};
+
+
+
+
+
+inline nsRect
+nsRect::ScaleToOtherAppUnitsRoundOut(int32_t aFromAPP, int32_t aToAPP) const
+{
+  if (aFromAPP == aToAPP) {
+    return *this;
+  }
+
+  nsRect rect;
+  nscoord right = NSToCoordCeil(NSCoordScale(XMost(), aFromAPP, aToAPP));
+  nscoord bottom = NSToCoordCeil(NSCoordScale(YMost(), aFromAPP, aToAPP));
+  rect.x = NSToCoordFloor(NSCoordScale(x, aFromAPP, aToAPP));
+  rect.y = NSToCoordFloor(NSCoordScale(y, aFromAPP, aToAPP));
+  rect.width = (right - rect.x);
+  rect.height = (bottom - rect.y);
+
+  return rect;
+}
+
+inline nsRect
+nsRect::ScaleToOtherAppUnitsRoundIn(int32_t aFromAPP, int32_t aToAPP) const
+{
+  if (aFromAPP == aToAPP) {
+    return *this;
+  }
+
+  nsRect rect;
+  nscoord right = NSToCoordFloor(NSCoordScale(XMost(), aFromAPP, aToAPP));
+  nscoord bottom = NSToCoordFloor(NSCoordScale(YMost(), aFromAPP, aToAPP));
+  rect.x = NSToCoordCeil(NSCoordScale(x, aFromAPP, aToAPP));
+  rect.y = NSToCoordCeil(NSCoordScale(y, aFromAPP, aToAPP));
+  rect.width = (right - rect.x);
+  rect.height = (bottom - rect.y);
+
+  return rect;
+}
+
+
+inline mozilla::gfx::IntRect
+nsRect::ScaleToNearestPixels(float aXScale, float aYScale,
+                             nscoord aAppUnitsPerPixel) const
+{
+  mozilla::gfx::IntRect rect;
+  rect.x = NSToIntRoundUp(NSAppUnitsToDoublePixels(x, aAppUnitsPerPixel) * aXScale);
+  rect.y = NSToIntRoundUp(NSAppUnitsToDoublePixels(y, aAppUnitsPerPixel) * aYScale);
+
+  rect.width = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(XMost(),
+                               aAppUnitsPerPixel) * aXScale) - rect.x);
+  rect.height = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(YMost(),
+                               aAppUnitsPerPixel) * aYScale) - rect.y);
+  return rect;
+}
+
+
+inline mozilla::gfx::IntRect
+nsRect::ScaleToOutsidePixels(float aXScale, float aYScale,
+                             nscoord aAppUnitsPerPixel) const
+{
+  mozilla::gfx::IntRect rect;
+  rect.x = NSToIntFloor(NSAppUnitsToFloatPixels(x, float(aAppUnitsPerPixel)) * aXScale);
+  rect.y = NSToIntFloor(NSAppUnitsToFloatPixels(y, float(aAppUnitsPerPixel)) * aYScale);
+
+  rect.width = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(XMost(),
+                            float(aAppUnitsPerPixel)) * aXScale) - rect.x);
+  rect.height = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(YMost(),
+                            float(aAppUnitsPerPixel)) * aYScale) - rect.y);
+  return rect;
+}
+
+
+inline mozilla::gfx::IntRect
+nsRect::ScaleToInsidePixels(float aXScale, float aYScale,
+                            nscoord aAppUnitsPerPixel) const
+{
+  mozilla::gfx::IntRect rect;
+  rect.x = NSToIntCeil(NSAppUnitsToFloatPixels(x, float(aAppUnitsPerPixel)) * aXScale);
+  rect.y = NSToIntCeil(NSAppUnitsToFloatPixels(y, float(aAppUnitsPerPixel)) * aYScale);
+
+  rect.width = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(XMost(),
+                             float(aAppUnitsPerPixel)) * aXScale) - rect.x);
+  rect.height = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(YMost(),
+                             float(aAppUnitsPerPixel)) * aYScale) - rect.y);
+  return rect;
+}
+
+inline mozilla::gfx::IntRect
+nsRect::ToNearestPixels(nscoord aAppUnitsPerPixel) const
+{
+  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
+}
+
+inline mozilla::gfx::IntRect
+nsRect::ToOutsidePixels(nscoord aAppUnitsPerPixel) const
+{
+  return ScaleToOutsidePixels(1.0f, 1.0f, aAppUnitsPerPixel);
+}
+
+inline mozilla::gfx::IntRect
+nsRect::ToInsidePixels(nscoord aAppUnitsPerPixel) const
+{
+  return ScaleToInsidePixels(1.0f, 1.0f, aAppUnitsPerPixel);
+}
+
+inline nsRect
+nsRect::RemoveResolution(const float aResolution) const
+{
+  do { } while (0);
+  nsRect rect;
+  rect.x = NSToCoordRound(NSCoordToFloat(x) / aResolution);
+  rect.y = NSToCoordRound(NSCoordToFloat(y) / aResolution);
+
+
+  if (width == 1 && height == 1) {
+    rect.width = rect.height = 1;
+  } else {
+    rect.width = NSToCoordCeil(NSCoordToFloat(width) / aResolution);
+    rect.height = NSToCoordCeil(NSCoordToFloat(height) / aResolution);
+  }
+
+  return rect;
+}
+
+const mozilla::gfx::IntRect& GetMaxSizedIntRect();
+
+
+template<class units>
+nsRect
+ToAppUnits(const mozilla::gfx::IntRectTyped<units>& aRect, nscoord aAppUnitsPerPixel)
+{
+  return nsRect(NSIntPixelsToAppUnits(aRect.x, aAppUnitsPerPixel),
+                NSIntPixelsToAppUnits(aRect.y, aAppUnitsPerPixel),
+                NSIntPixelsToAppUnits(aRect.width, aAppUnitsPerPixel),
+                NSIntPixelsToAppUnits(aRect.height, aAppUnitsPerPixel));
+}
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWeakReference.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWeakReference.h"
+class nsWeakReference;
+
+class nsSupportsWeakReference : public nsISupportsWeakReference
+{
+public:
+  nsSupportsWeakReference() : mProxy(0) {}
+
+  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) override;
+
+protected:
+  inline ~nsSupportsWeakReference();
+
+private:
+  friend class nsWeakReference;
+
+
+
+  void NoticeProxyDestruction() { mProxy = nullptr; }
+
+  nsWeakReference* mProxy;
+
+protected:
+
+  void ClearWeakReferences();
+  bool HasWeakReferences() const { return !!mProxy; }
+};
+
+inline
+nsSupportsWeakReference::~nsSupportsWeakReference()
+{
+  ClearWeakReferences();
+}
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h"
+template<class KeyClass, class T>
+class nsClassHashtable
+  : public nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>
+{
+public:
+  typedef typename KeyClass::KeyType KeyType;
+  typedef T* UserDataType;
+  typedef nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*> base_type;
+
+  using base_type::IsEmpty;
+
+  nsClassHashtable() {}
+  explicit nsClassHashtable(uint32_t aInitLength)
+    : nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>(aInitLength)
+  {
+  }
+
+
+
+
+
+  template<typename... Args>
+  UserDataType LookupOrAdd(KeyType aKey, Args&&... aConstructionArgs);
+
+
+
+
+
+  bool Get(KeyType aKey, UserDataType* aData) const;
+
+
+
+
+
+  UserDataType Get(KeyType aKey) const;
+# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h"
+  void RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut);
+};
+
+
+
+
+
+template<class KeyClass, class T>
+template<typename... Args>
+T*
+nsClassHashtable<KeyClass, T>::LookupOrAdd(KeyType aKey,
+                                           Args&&... aConstructionArgs)
+{
+  typename base_type::EntryType* ent = this->PutEntry(aKey);
+  if (!ent->mData) {
+    ent->mData = new T(mozilla::Forward<Args>(aConstructionArgs)...);
+  }
+  return ent->mData;
+}
+
+template<class KeyClass, class T>
+bool
+nsClassHashtable<KeyClass, T>::Get(KeyType aKey, T** aRetVal) const
+{
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+  if (ent) {
+    if (aRetVal) {
+      *aRetVal = ent->mData;
+    }
+
+    return true;
+  }
+
+  if (aRetVal) {
+    *aRetVal = nullptr;
+  }
+
+  return false;
+}
+
+template<class KeyClass, class T>
+T*
+nsClassHashtable<KeyClass, T>::Get(KeyType aKey) const
+{
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+  if (!ent) {
+    return nullptr;
+  }
+
+  return ent->mData;
+}
+
+template<class KeyClass, class T>
+void
+nsClassHashtable<KeyClass, T>::RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut)
+{
+  aOut = nullptr;
+
+  typename base_type::EntryType* ent = this->GetEntry(aKey);
+  if (!ent) {
+    return;
+  }
+
+
+  aOut = mozilla::Move(ent->mData);
+
+  this->Remove(aKey);
+}
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h"
+namespace mozilla {
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h"
+template<size_t ArenaSize, size_t Alignment=1>
+class ArenaAllocator
+{
+public:
+  constexpr ArenaAllocator()
+    : mHead()
+    , mCurrent(nullptr)
+  {
+     static_assert(mozilla::tl::FloorLog2<Alignment>::value ==
+                   mozilla::tl::CeilingLog2<Alignment>::value,
+                  "ArenaAllocator alignment must be a power of two");
+  }
+
+  ArenaAllocator(const ArenaAllocator&) = delete;
+  ArenaAllocator& operator=(const ArenaAllocator&) = delete;
+
+
+
+
+
+  ~ArenaAllocator()
+  {
+    Clear();
+  }
+
+
+
+
+
+
+  __attribute__((always_inline)) inline void* Allocate(size_t aSize, const fallible_t&)
+  {
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aSize)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aSize))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aSize" ") (" "Allocation size must be non-zero" ")"); do { *((volatile int*) __null) = 71; ::abort(); } while (0); } } while (0);
+    return InternalAllocate(AlignedSize(aSize));
+  }
+
+  void* Allocate(size_t aSize)
+  {
+    void* p = Allocate(aSize, fallible);
+    if ((__builtin_expect(!!(!p), 0))) {
+      NS_ABORT_OOM(std::max(aSize, ArenaSize));
+    }
+
+    return p;
+  }
+
+
+
+
+
+
+
+  void Clear()
+  {
+
+    auto a = mHead.next;
+    while (a) {
+      auto tmp = a;
+      a = a->next;
+      free(tmp);
+    }
+
+
+    mHead.next = nullptr;
+    mCurrent = nullptr;
+  }
+
+
+
+
+  static constexpr size_t AlignedSize(size_t aSize)
+  {
+    return (aSize + (Alignment - 1)) & ~(Alignment - 1);
+  }
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+  {
+    size_t s = 0;
+    for (auto arena = mHead.next; arena; arena = arena->next) {
+      s += aMallocSizeOf(arena);
+    }
+
+    return s;
+  }
+
+private:
+  struct ArenaHeader
+  {
+
+
+
+    uintptr_t offset;
+
+
+
+    uintptr_t tail;
+  };
+
+  struct ArenaChunk
+  {
+    constexpr ArenaChunk() : header{0, 0}, next(nullptr) {}
+
+    explicit ArenaChunk(size_t aSize)
+      : header{AlignedSize(uintptr_t(this + 1)), uintptr_t(this) + aSize}
+      , next(nullptr)
+    {
+    }
+
+    ArenaHeader header;
+    ArenaChunk* next;
+
+
+
+
+    void* Allocate(size_t aSize)
+    {
+      do { } while (0);
+      char* p = reinterpret_cast<char*>(header.offset);
+      header.offset += aSize;
+      do {} while (0);
+      return p;
+    }
+
+
+
+
+    size_t Available() const {
+      return header.tail - header.offset;
+    }
+  };
+
+
+
+
+  ArenaChunk* AllocateChunk(size_t aSize)
+  {
+    static const size_t kOffset = AlignedSize(sizeof(ArenaChunk));
+    do { } while (0);
+
+    const size_t chunkSize = aSize + kOffset;
+    void* p = malloc(chunkSize);
+    if (!p) {
+      return nullptr;
+    }
+
+    ArenaChunk* arena = new (KnownNotNull, p) ArenaChunk(chunkSize);
+    do {} while (0);
+
+
+
+    arena->next = mHead.next;
+    mHead.next = arena;
+
+
+
+
+    if (aSize == ArenaSize - kOffset) {
+      mCurrent = arena;
+    }
+
+    return arena;
+  }
+
+  __attribute__((always_inline)) inline void* InternalAllocate(size_t aSize)
+  {
+    static_assert(ArenaSize > AlignedSize(sizeof(ArenaChunk)),
+                  "Arena size must be greater than the header size");
+
+    static const size_t kMaxArenaCapacity =
+        ArenaSize - AlignedSize(sizeof(ArenaChunk));
+
+    if (mCurrent && aSize <= mCurrent->Available()) {
+      return mCurrent->Allocate(aSize);
+    }
+
+    ArenaChunk* arena = AllocateChunk(std::max(kMaxArenaCapacity, aSize));
+    return arena ? arena->Allocate(aSize) : nullptr;
+  }
+
+  ArenaChunk mHead;
+  ArenaChunk* mCurrent;
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h"
+class nsPresArena;
+
+namespace mozilla {
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h"
+template<typename T>
+class ArenaRefPtr
+{
+  friend class ::nsPresArena;
+
+public:
+  ArenaRefPtr()
+  {
+    AssertValidType();
+  }
+
+  template<typename I>
+               ArenaRefPtr(already_AddRefed<I>& aRhs)
+  {
+    AssertValidType();
+    assign(aRhs);
+  }
+
+  template<typename I>
+               ArenaRefPtr(already_AddRefed<I>&& aRhs)
+  {
+    AssertValidType();
+    assign(aRhs);
+  }
+
+               ArenaRefPtr(T* aRhs)
+  {
+    AssertValidType();
+    assign(aRhs);
+  }
+
+  template<typename I>
+  ArenaRefPtr<T>& operator=(already_AddRefed<I>& aRhs)
+  {
+    assign(aRhs);
+    return *this;
+  }
+
+  template<typename I>
+  ArenaRefPtr<T>& operator=(already_AddRefed<I>&& aRhs)
+  {
+    assign(aRhs);
+    return *this;
+  }
+
+  ArenaRefPtr<T>& operator=(T* aRhs)
+  {
+    assign(aRhs);
+    return *this;
+  }
+
+  ~ArenaRefPtr() { assign(nullptr); }
+
+  operator T*() const & { return get(); }
+  operator T*() const && = delete;
+  explicit operator bool() const { return !!mPtr; }
+  bool operator!() const { return !mPtr; }
+  T* operator->() const { return mPtr.operator->(); }
+  T& operator*() const { return *get(); }
+
+  T* get() const { return mPtr; }
+
+private:
+  void AssertValidType();
+
+
+
+
+
+
+
+  void ClearWithoutDeregistering()
+  {
+    mPtr = nullptr;
+  }
+
+  template<typename I>
+  void assign(already_AddRefed<I>& aSmartPtr)
+  {
+    RefPtr<T> newPtr(aSmartPtr);
+    assignFrom(newPtr);
+  }
+
+  template<typename I>
+  void assign(already_AddRefed<I>&& aSmartPtr)
+  {
+    RefPtr<T> newPtr(aSmartPtr);
+    assignFrom(newPtr);
+  }
+
+  void assign(T* aPtr) { assignFrom(aPtr); }
+
+  template<typename I>
+  void assignFrom(I& aPtr)
+  {
+    if (aPtr == mPtr) {
+      return;
+    }
+    bool sameArena = mPtr && aPtr && mPtr->Arena() == aPtr->Arena();
+    if (mPtr && !sameArena) {
+      do { } while (0);
+      mPtr->Arena()->DeregisterArenaRefPtr(this);
+    }
+    mPtr = Move(aPtr);
+    if (mPtr && !sameArena) {
+      do { } while (0);
+      mPtr->Arena()->RegisterArenaRefPtr(this);
+    }
+  }
+
+  RefPtr<T> mPtr;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
+struct nsArenaMemoryStats;
+
+class nsPresArena {
+public:
+  nsPresArena();
+  ~nsPresArena();
+
+
+
+
+  void* AllocateBySize(size_t aSize)
+  {
+    return Allocate(uint32_t(aSize) |
+                    uint32_t(mozilla::eArenaObjectID_NON_OBJECT_MARKER), aSize);
+  }
+  void FreeBySize(size_t aSize, void* aPtr)
+  {
+    Free(uint32_t(aSize) |
+         uint32_t(mozilla::eArenaObjectID_NON_OBJECT_MARKER), aPtr);
+  }
+
+
+
+
+
+  void* AllocateByFrameID(nsQueryFrame::FrameIID aID, size_t aSize)
+  {
+    return Allocate(aID, aSize);
+  }
+  void FreeByFrameID(nsQueryFrame::FrameIID aID, void* aPtr)
+  {
+    Free(aID, aPtr);
+  }
+
+
+
+
+
+  void* AllocateByObjectID(mozilla::ArenaObjectID aID, size_t aSize)
+  {
+    return Allocate(aID, aSize);
+  }
+  void FreeByObjectID(mozilla::ArenaObjectID aID, void* aPtr)
+  {
+    Free(aID, aPtr);
+  }
+# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
+  template<typename T>
+  void RegisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr);
+
+
+
+
+
+  template<typename T>
+  void DeregisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
+  {
+    do { } while (0);
+    mArenaRefPtrs.Remove(aPtr);
+  }
+
+
+
+
+
+
+  void ClearArenaRefPtrs();
+
+
+
+
+
+
+
+  void ClearArenaRefPtrs(mozilla::ArenaObjectID aObjectID);
+
+
+
+
+
+  void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                              nsArenaMemoryStats* aArenaStats);
+
+private:
+  void* Allocate(uint32_t aCode, size_t aSize);
+  void Free(uint32_t aCode, void* aPtr);
+
+  inline void ClearArenaRefPtrWithoutDeregistering(
+      void* aPtr,
+      mozilla::ArenaObjectID aObjectID);
+
+
+
+  class FreeList : public PLDHashEntryHdr
+  {
+  public:
+    typedef uint32_t KeyType;
+    nsTArray<void *> mEntries;
+    size_t mEntrySize;
+    size_t mEntriesEverAllocated;
+
+    typedef const void* KeyTypePointer;
+    KeyTypePointer mKey;
+
+    explicit FreeList(KeyTypePointer aKey)
+    : mEntrySize(0), mEntriesEverAllocated(0), mKey(aKey) {}
+
+
+    bool KeyEquals(KeyTypePointer const aKey) const
+    { return mKey == aKey; }
+
+    static KeyTypePointer KeyToPointer(KeyType aKey)
+    { return ((void*)(intptr_t)(aKey)); }
+
+    static PLDHashNumber HashKey(KeyTypePointer aKey)
+    { return ((int32_t)(intptr_t)(aKey)); }
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+    { return mEntries.ShallowSizeOfExcludingThis(aMallocSizeOf); }
+
+    enum { ALLOW_MEMMOVE = false };
+  };
+
+  nsTHashtable<FreeList> mFreeLists;
+  mozilla::ArenaAllocator<8192, 8> mPool;
+  nsDataHashtable<nsPtrHashKey<void>, mozilla::ArenaObjectID> mArenaRefPtrs;
+};
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h"
+class imgIRequest;
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h"
+class imgINotificationObserver : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    SIZE_AVAILABLE = 1,
+    FRAME_UPDATE = 2,
+    FRAME_COMPLETE = 3,
+    LOAD_COMPLETE = 4,
+    DECODE_COMPLETE = 5,
+    DISCARD = 6,
+    UNLOCKED_DRAW = 7,
+    IS_ANIMATED = 8,
+    HAS_TRANSPARENCY = 9
+  };
+
+
+  virtual nsresult Notify(imgIRequest *aProxy, int32_t aType, const nsIntRect *aRect) = 0;
+
+};
+
+  template<typename T> struct imgINotificationObserver::COMTypeInfo<imgINotificationObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID imgINotificationObserver::COMTypeInfo<imgINotificationObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x03da5641, 0xa333, 0x454a, { 0xa8, 0x59, 0x03, 0x6d, 0x0b, 0xb6, 0x83, 0xb7 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 2
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Visibility.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Visibility.h"
+namespace mozilla {
+
+
+enum class Visibility : uint8_t
+{
+
+  UNTRACKED,
+
+
+
+
+
+
+  APPROXIMATELY_NONVISIBLE,
+
+
+
+
+
+  APPROXIMATELY_VISIBLE
+};
+
+
+enum class OnNonvisible : uint8_t
+{
+  DISCARD_IMAGES
+};
+
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 2
+class imgIRequest;
+
+class nsIChannel;
+
+class nsIStreamListener;
+
+class nsIURI;
+
+class nsIDocument;
+
+class nsIFrame;
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h"
+class nsIImageLoadingContent : public imgINotificationObserver {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    UNKNOWN_REQUEST = -1,
+    CURRENT_REQUEST = 0,
+    PENDING_REQUEST = 1
+  };
+
+
+  virtual nsresult GetLoadingEnabled(bool *aLoadingEnabled) = 0;
+  virtual nsresult SetLoadingEnabled(bool aLoadingEnabled) = 0;
+
+
+  virtual nsresult GetImageBlockingStatus(int16_t *aImageBlockingStatus) = 0;
+
+
+  virtual nsresult AddObserver(imgINotificationObserver *aObserver) = 0;
+
+
+  virtual nsresult RemoveObserver(imgINotificationObserver *aObserver) = 0;
+
+
+  virtual nsresult GetRequest(int32_t aRequestType, imgIRequest * *_retval) = 0;
+
+
+  virtual bool CurrentRequestHasSize(void) = 0;
+
+
+  virtual void FrameCreated(nsIFrame *aFrame) = 0;
+
+
+  virtual void FrameDestroyed(nsIFrame *aFrame) = 0;
+
+
+  virtual nsresult GetRequestType(imgIRequest *aRequest, int32_t *_retval) = 0;
+
+
+  virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) = 0;
+
+
+  virtual nsresult LoadImageWithChannel(nsIChannel *aChannel, nsIStreamListener * *_retval) = 0;
+
+
+  virtual nsresult ForceReload(bool aNotify, uint8_t _argc) = 0;
+
+
+  virtual nsresult ForceImageState(bool aForce, uint64_t aState) = 0;
+
+
+  virtual nsresult GetNaturalWidth(uint32_t *aNaturalWidth) = 0;
+
+
+  virtual nsresult GetNaturalHeight(uint32_t *aNaturalHeight) = 0;
+
+
+  virtual void OnVisibilityChange(mozilla::Visibility aNewVisibility, const mozilla::Maybe<mozilla::OnNonvisible> & aNonvisibleAction) = 0;
+
+};
+
+  template<typename T> struct nsIImageLoadingContent::COMTypeInfo<nsIImageLoadingContent, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIImageLoadingContent::COMTypeInfo<nsIImageLoadingContent, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0357123d, 0x9224, 0x4d12, { 0xa4, 0x7e, 0x86, 0x8c, 0x32, 0x68, 0x97, 0x77 }};
+# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h"
+typedef uint64_t nsFrameState_size_t;
+
+
+
+enum nsFrameState : nsFrameState_size_t {
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h" 1
+# 56 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_FRAME_IN_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (0))),
+
+
+
+
+NS_FRAME_FIRST_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (1))),
+
+
+
+
+NS_FRAME_IS_FLUID_CONTINUATION = (nsFrameState(nsFrameState_size_t(1) << (2))),
+
+
+NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (3))),
+
+
+
+
+NS_FRAME_EXTERNAL_REFERENCE = (nsFrameState(nsFrameState_size_t(1) << (4))),
+
+
+
+
+
+NS_FRAME_CONTAINS_RELATIVE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (5))),
+
+
+NS_FRAME_GENERATED_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (6))),
+
+
+
+
+
+
+NS_FRAME_IS_OVERFLOW_CONTAINER = (nsFrameState(nsFrameState_size_t(1) << (7))),
+
+
+
+NS_FRAME_OUT_OF_FLOW = (nsFrameState(nsFrameState_size_t(1) << (8))),
+
+
+
+
+NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (9))),
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_FRAME_IS_DIRTY = (nsFrameState(nsFrameState_size_t(1) << (10))),
+
+
+
+
+NS_FRAME_TOO_DEEP_IN_FRAME_TREE = (nsFrameState(nsFrameState_size_t(1) << (11))),
+# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_FRAME_HAS_DIRTY_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (12))),
+
+
+NS_FRAME_HAS_VIEW = (nsFrameState(nsFrameState_size_t(1) << (13))),
+
+
+NS_FRAME_INDEPENDENT_SELECTION = (nsFrameState(nsFrameState_size_t(1) << (14))),
+
+
+
+
+
+NS_FRAME_PART_OF_IBSPLIT = (nsFrameState(nsFrameState_size_t(1) << (15))),
+
+
+
+
+
+
+NS_FRAME_MAY_BE_TRANSFORMED = (nsFrameState(nsFrameState_size_t(1) << (16))),
+
+
+
+NS_FRAME_IS_BIDI = (nsFrameState(nsFrameState_size_t(1) << (17))),
+
+
+NS_FRAME_HAS_CHILD_WITH_VIEW = (nsFrameState(nsFrameState_size_t(1) << (18))),
+
+
+
+NS_FRAME_REFLOW_ROOT = (nsFrameState(nsFrameState_size_t(1) << (19))),
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_FRAME_IS_PUSHED_FLOAT = (nsFrameState(nsFrameState_size_t(1) << (32))),
+
+
+NS_FRAME_DRAWING_AS_PAINTSERVER = (nsFrameState(nsFrameState_size_t(1) << (33))),
+
+
+
+
+NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (34))),
+
+
+
+
+
+NS_FRAME_SIMPLE_EVENT_REGIONS = (nsFrameState(nsFrameState_size_t(1) << (35))),
+
+
+
+
+
+NS_FRAME_UPDATE_LAYER_TREE = (nsFrameState(nsFrameState_size_t(1) << (36))),
+
+
+NS_FRAME_HAS_ABSPOS_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (37))),
+
+
+NS_FRAME_PAINTED_THEBES = (nsFrameState(nsFrameState_size_t(1) << (38))),
+
+
+
+
+NS_FRAME_IN_CONSTRAINED_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (39))),
+
+
+NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO = (nsFrameState(nsFrameState_size_t(1) << (40))),
+
+
+
+
+NS_FRAME_FONT_INFLATION_CONTAINER = (nsFrameState(nsFrameState_size_t(1) << (41))),
+
+
+
+
+NS_FRAME_FONT_INFLATION_FLOW_ROOT = (nsFrameState(nsFrameState_size_t(1) << (42))),
+
+
+
+
+NS_FRAME_SVG_LAYOUT = (nsFrameState(nsFrameState_size_t(1) << (43))),
+
+
+NS_FRAME_MAY_HAVE_GENERATED_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (44))),
+
+
+
+
+NS_FRAME_NO_COMPONENT_ALPHA = (nsFrameState(nsFrameState_size_t(1) << (45))),
+
+
+
+NS_FRAME_VISIBILITY_IS_TRACKED = (nsFrameState(nsFrameState_size_t(1) << (46))),
+
+
+
+NS_FRAME_IS_SVG_TEXT = (nsFrameState(nsFrameState_size_t(1) << (47))),
+
+
+NS_FRAME_NEEDS_PAINT = (nsFrameState(nsFrameState_size_t(1) << (48))),
+
+
+
+NS_FRAME_DESCENDANT_NEEDS_PAINT = (nsFrameState(nsFrameState_size_t(1) << (49))),
+
+
+NS_FRAME_IN_POPUP = (nsFrameState(nsFrameState_size_t(1) << (50))),
+
+
+
+
+
+NS_FRAME_ALL_DESCENDANTS_NEED_PAINT = (nsFrameState(nsFrameState_size_t(1) << (51))),
+
+
+
+NS_FRAME_HAS_INVALID_RECT = (nsFrameState(nsFrameState_size_t(1) << (52))),
+
+
+
+NS_FRAME_IS_NONDISPLAY = (nsFrameState(nsFrameState_size_t(1) << (53))),
+
+
+NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY = (nsFrameState(nsFrameState_size_t(1) << (54))),
+
+
+
+NS_FRAME_OWNS_ANON_BOXES = (nsFrameState(nsFrameState_size_t(1) << (55))),
+
+
+NS_FRAME_HAS_PROPERTIES = (nsFrameState(nsFrameState_size_t(1) << (56))),
+
+
+
+NS_FRAME_MATHML_SCRIPT_DESCENDANT = (nsFrameState(nsFrameState_size_t(1) << (58))),
+
+
+
+
+NS_FRAME_IS_IN_SINGLE_CHAR_MI = (nsFrameState(nsFrameState_size_t(1) << (59))),
+# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_STATE_BOX_CHILD_RESERVED = (nsFrameState(nsFrameState_size_t(1) << (20))),
+NS_STATE_STACK_NOT_POSITIONED = (nsFrameState(nsFrameState_size_t(1) << (21))),
+NS_STATE_IS_HORIZONTAL = (nsFrameState(nsFrameState_size_t(1) << (22))),
+NS_STATE_AUTO_STRETCH = (nsFrameState(nsFrameState_size_t(1) << (23))),
+NS_STATE_IS_ROOT = (nsFrameState(nsFrameState_size_t(1) << (24))),
+NS_STATE_CURRENTLY_IN_DEBUG = (nsFrameState(nsFrameState_size_t(1) << (25))),
+NS_STATE_SET_TO_DEBUG = (nsFrameState(nsFrameState_size_t(1) << (26))),
+NS_STATE_DEBUG_WAS_SET = (nsFrameState(nsFrameState_size_t(1) << (27))),
+NS_STATE_MENU_HAS_POPUP_LIST = (nsFrameState(nsFrameState_size_t(1) << (28))),
+NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK = (nsFrameState(nsFrameState_size_t(1) << (29))),
+NS_STATE_EQUAL_SIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
+NS_STATE_IS_DIRECTION_NORMAL = (nsFrameState(nsFrameState_size_t(1) << (31))),
+NS_FRAME_MOUSE_THROUGH_ALWAYS = (nsFrameState(nsFrameState_size_t(1) << (60))),
+NS_FRAME_MOUSE_THROUGH_NEVER = (nsFrameState(nsFrameState_size_t(1) << (61))),
+# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+
+
+NS_STATE_FLEX_IS_LEGACY_WEBKIT_BOX = (nsFrameState(nsFrameState_size_t(1) << (21))),
+
+
+NS_STATE_FLEX_SYNTHESIZE_BASELINE = (nsFrameState(nsFrameState_size_t(1) << (22))),
+
+
+
+
+
+
+
+NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+
+
+
+
+NS_STATE_GRID_DID_PUSH_ITEMS = (nsFrameState(nsFrameState_size_t(1) << (21))),
+
+
+NS_STATE_GRID_GENERATE_COMPUTED_VALUES = (nsFrameState(nsFrameState_size_t(1) << (22))),
+
+
+NS_STATE_GRID_SYNTHESIZE_BASELINE = (nsFrameState(nsFrameState_size_t(1) << (23))),
+
+
+
+
+
+
+NS_STATE_IS_OUTER_SVG = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+
+NS_STATE_SVG_CLIPPATH_CHILD = (nsFrameState(nsFrameState_size_t(1) << (21))),
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_STATE_SVG_POSITIONING_DIRTY = (nsFrameState(nsFrameState_size_t(1) << (22))),
+# 385 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES = (nsFrameState(nsFrameState_size_t(1) << (23))),
+
+NS_STATE_SVG_TEXT_IN_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (24))),
+# 400 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+TEXT_FIRST_LETTER = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+
+
+TEXT_START_OF_LINE = (nsFrameState(nsFrameState_size_t(1) << (21))),
+
+
+
+TEXT_END_OF_LINE = (nsFrameState(nsFrameState_size_t(1) << (22))),
+
+
+TEXT_HYPHEN_BREAK = (nsFrameState(nsFrameState_size_t(1) << (23))),
+
+
+
+TEXT_TRIMMED_TRAILING_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (24))),
+
+
+
+
+TEXT_JUSTIFICATION_ENABLED = (nsFrameState(nsFrameState_size_t(1) << (25))),
+
+
+TEXT_SELECTION_UNDERLINE_OVERFLOWED = (nsFrameState(nsFrameState_size_t(1) << (26))),
+
+
+
+
+
+
+TEXT_IS_ONLY_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (27))),
+
+
+TEXT_ISNOT_ONLY_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (28))),
+
+
+
+
+TEXT_IN_TEXTRUN_USER_DATA = (nsFrameState(nsFrameState_size_t(1) << (29))),
+
+
+
+TEXT_OFFSETS_NEED_FIXING = (nsFrameState(nsFrameState_size_t(1) << (30))),
+
+
+
+TEXT_HAS_NONCOLLAPSED_CHARACTERS = (nsFrameState(nsFrameState_size_t(1) << (31))),
+
+
+
+
+TEXT_IS_IN_TOKEN_MATHML = (nsFrameState(nsFrameState_size_t(1) << (32))),
+
+
+
+TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA = (nsFrameState(nsFrameState_size_t(1) << (60))),
+
+TEXT_HAS_FONT_INFLATION = (nsFrameState(nsFrameState_size_t(1) << (61))),
+
+
+TEXT_NO_RENDERED_GLYPHS = (nsFrameState(nsFrameState_size_t(1) << (62))),
+
+
+
+TEXT_IN_OFFSET_CACHE = (nsFrameState(nsFrameState_size_t(1) << (63))),
+# 474 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_BLOCK_NEEDS_BIDI_RESOLUTION = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+NS_BLOCK_HAS_PUSHED_FLOATS = (nsFrameState(nsFrameState_size_t(1) << (21))),
+# 486 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_BLOCK_MARGIN_ROOT = (nsFrameState(nsFrameState_size_t(1) << (22))),
+
+
+
+
+NS_BLOCK_FLOAT_MGR = (nsFrameState(nsFrameState_size_t(1) << (23))),
+
+
+
+
+NS_BLOCK_HAS_LINE_CURSOR = (nsFrameState(nsFrameState_size_t(1) << (24))),
+
+NS_BLOCK_HAS_OVERFLOW_LINES = (nsFrameState(nsFrameState_size_t(1) << (25))),
+
+NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS = (nsFrameState(nsFrameState_size_t(1) << (26))),
+
+
+
+
+NS_BLOCK_HAS_CLEAR_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (27))),
+
+
+
+
+NS_BLOCK_CLIP_PAGINATED_OVERFLOW = (nsFrameState(nsFrameState_size_t(1) << (28))),
+
+
+
+NS_BLOCK_HAS_FIRST_LETTER_STYLE = (nsFrameState(nsFrameState_size_t(1) << (29))),
+
+
+
+NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET = (nsFrameState(nsFrameState_size_t(1) << (30))),
+NS_BLOCK_FRAME_HAS_INSIDE_BULLET = (nsFrameState(nsFrameState_size_t(1) << (31))),
+
+
+
+
+NS_BLOCK_LOOK_FOR_DIRTY_FRAMES = (nsFrameState(nsFrameState_size_t(1) << (61))),
+# 534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_BLOCK_FRAME_INTRINSICS_INFLATED = (nsFrameState(nsFrameState_size_t(1) << (62))),
+
+
+
+
+
+NS_BLOCK_HAS_FIRST_LETTER_CHILD = (nsFrameState(nsFrameState_size_t(1) << (63))),
+
+
+
+
+
+
+BULLET_FRAME_HAS_FONT_INFLATION = (nsFrameState(nsFrameState_size_t(1) << (62))),
+BULLET_FRAME_IMAGE_LOADING = (nsFrameState(nsFrameState_size_t(1) << (63))),
+# 559 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_SCROLLFRAME_INVALIDATE_CONTENTS_ON_SCROLL = (nsFrameState(nsFrameState_size_t(1) << (20))),
+
+
+
+
+
+
+IMAGE_SIZECONSTRAINED = (nsFrameState(nsFrameState_size_t(1) << (20))),
+IMAGE_GOTINITIALREFLOW = (nsFrameState(nsFrameState_size_t(1) << (21))),
+# 580 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET = (nsFrameState(nsFrameState_size_t(1) << (21))),
+NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST = (nsFrameState(nsFrameState_size_t(1) << (22))),
+NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST = (nsFrameState(nsFrameState_size_t(1) << (23))),
+# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_RUBY_TEXT_FRAME_AUTOHIDE = (nsFrameState(nsFrameState_size_t(1) << (24))),
+
+
+
+
+
+
+NS_RUBY_TEXT_CONTAINER_IS_SPAN = (nsFrameState(nsFrameState_size_t(1) << (20))),
+# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+PLACEHOLDER_FOR_FLOAT = (nsFrameState(nsFrameState_size_t(1) << (20))),
+PLACEHOLDER_FOR_ABSPOS = (nsFrameState(nsFrameState_size_t(1) << (21))),
+PLACEHOLDER_FOR_FIXEDPOS = (nsFrameState(nsFrameState_size_t(1) << (22))),
+PLACEHOLDER_FOR_POPUP = (nsFrameState(nsFrameState_size_t(1) << (23))),
+PLACEHOLDER_FOR_TOPLAYER = (nsFrameState(nsFrameState_size_t(1) << (24))),
+# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN = (nsFrameState(nsFrameState_size_t(1) << (25))),
+
+
+
+
+
+
+NS_TABLE_CELL_HAS_PCT_OVER_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (28))),
+NS_TABLE_CELL_HAD_SPECIAL_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (29))),
+NS_TABLE_CELL_CONTENT_EMPTY = (nsFrameState(nsFrameState_size_t(1) << (31))),
+# 649 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_REPEATED_ROW_OR_ROWGROUP = (nsFrameState(nsFrameState_size_t(1) << (28))),
+# 658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
+NS_ROW_HAS_CELL_WITH_STYLE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (29))),
+
+NS_TABLE_ROW_HAS_UNPAGINATED_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
+
+
+
+
+
+
+NS_ROWGROUP_HAS_ROW_CURSOR = (nsFrameState(nsFrameState_size_t(1) << (27))),
+NS_ROWGROUP_HAS_STYLE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
+
+
+NS_ROWGROUP_REPEATABLE = (nsFrameState(nsFrameState_size_t(1) << (31))),
+
+
+
+NS_TABLE_PART_HAS_FIXED_BACKGROUND = (nsFrameState(nsFrameState_size_t(1) << (28))),
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h" 2
+
+};
+
+inline nsFrameState operator|(nsFrameState aLeft, nsFrameState aRight)
+{
+  return nsFrameState(nsFrameState_size_t(aLeft) | nsFrameState_size_t(aRight));
+}
+
+inline nsFrameState operator&(nsFrameState aLeft, nsFrameState aRight)
+{
+  return nsFrameState(nsFrameState_size_t(aLeft) & nsFrameState_size_t(aRight));
+}
+
+inline nsFrameState& operator|=(nsFrameState& aLeft, nsFrameState aRight)
+{
+  aLeft = aLeft | aRight;
+  return aLeft;
+}
+
+inline nsFrameState& operator&=(nsFrameState& aLeft, nsFrameState aRight)
+{
+  aLeft = aLeft & aRight;
+  return aLeft;
+}
+
+inline nsFrameState operator~(nsFrameState aRight)
+{
+  return nsFrameState(~nsFrameState_size_t(aRight));
+}
+
+inline nsFrameState operator^(nsFrameState aLeft, nsFrameState aRight)
+{
+  return nsFrameState(nsFrameState_size_t(aLeft) ^ nsFrameState_size_t(aRight));
+}
+
+inline nsFrameState& operator^=(nsFrameState& aLeft, nsFrameState aRight)
+{
+  aLeft = aLeft ^ aRight;
+  return aLeft;
+}
+
+
+
+
+
+namespace mozilla {
+
+
+
+
+}
+# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h"
+namespace mozilla {
+namespace gfx {
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h"
+template<class src, class dst>
+struct ScaleFactor {
+  float scale;
+
+  constexpr ScaleFactor() : scale(1.0) {}
+  constexpr ScaleFactor(const ScaleFactor<src, dst>& aCopy) : scale(aCopy.scale) {}
+  explicit constexpr ScaleFactor(float aScale) : scale(aScale) {}
+
+  ScaleFactor<dst, src> Inverse() {
+    return ScaleFactor<dst, src>(1 / scale);
+  }
+
+  bool operator==(const ScaleFactor<src, dst>& aOther) const {
+    return scale == aOther.scale;
+  }
+
+  bool operator!=(const ScaleFactor<src, dst>& aOther) const {
+    return !(*this == aOther);
+  }
+
+  bool operator<(const ScaleFactor<src, dst>& aOther) const {
+    return scale < aOther.scale;
+  }
+
+  bool operator<=(const ScaleFactor<src, dst>& aOther) const {
+    return scale <= aOther.scale;
+  }
+
+  bool operator>(const ScaleFactor<src, dst>& aOther) const {
+    return scale > aOther.scale;
+  }
+
+  bool operator>=(const ScaleFactor<src, dst>& aOther) const {
+    return scale >= aOther.scale;
+  }
+
+  template<class other>
+  ScaleFactor<other, dst> operator/(const ScaleFactor<src, other>& aOther) const {
+    return ScaleFactor<other, dst>(scale / aOther.scale);
+  }
+
+  template<class other>
+  ScaleFactor<src, other> operator/(const ScaleFactor<other, dst>& aOther) const {
+    return ScaleFactor<src, other>(scale / aOther.scale);
+  }
+
+  template<class other>
+  ScaleFactor<src, other> operator*(const ScaleFactor<dst, other>& aOther) const {
+    return ScaleFactor<src, other>(scale * aOther.scale);
+  }
+
+  template<class other>
+  ScaleFactor<other, dst> operator*(const ScaleFactor<other, src>& aOther) const {
+    return ScaleFactor<other, dst>(scale * aOther.scale);
+  }
+};
+
+}
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactors2D.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactors2D.h"
+namespace mozilla {
+namespace gfx {
+
+
+
+
+
+template<class src, class dst>
+struct ScaleFactors2D {
+  float xScale;
+  float yScale;
+
+  constexpr ScaleFactors2D() : xScale(1.0), yScale(1.0) {}
+  constexpr ScaleFactors2D(const ScaleFactors2D<src, dst>& aCopy)
+    : xScale(aCopy.xScale), yScale(aCopy.yScale) {}
+  constexpr ScaleFactors2D(float aXScale, float aYScale)
+    : xScale(aXScale), yScale(aYScale) {}
+
+  explicit constexpr ScaleFactors2D(const gfxSize& aSize)
+    : xScale(aSize.width), yScale(aSize.height) {}
+
+
+
+
+
+  explicit constexpr ScaleFactors2D(const ScaleFactor<src, dst>& aScale)
+    : xScale(aScale.scale), yScale(aScale.scale) {}
+
+  bool AreScalesSame() const {
+    return FuzzyEqualsMultiplicative(xScale, yScale);
+  }
+
+
+  ScaleFactor<src, dst> ToScaleFactor() const {
+    do { } while (0);
+    return ScaleFactor<src, dst>(xScale);
+  }
+
+  bool operator==(const ScaleFactors2D<src, dst>& aOther) const {
+    return xScale == aOther.xScale && yScale == aOther.yScale;
+  }
+
+  bool operator!=(const ScaleFactors2D<src, dst>& aOther) const {
+    return !(*this == aOther);
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const ScaleFactors2D<src, dst>& aScale) {
+    if (aScale.AreScalesSame()) {
+      return aStream << aScale.xScale;
+    } else {
+      return aStream << '(' << aScale.xScale << ',' << aScale.yScale << ')';
+    }
+  }
+
+  template<class other>
+  ScaleFactors2D<other, dst> operator/(const ScaleFactors2D<src, other>& aOther) const {
+    return ScaleFactors2D<other, dst>(xScale / aOther.xScale, yScale / aOther.yScale);
+  }
+
+  template<class other>
+  ScaleFactors2D<src, other> operator/(const ScaleFactors2D<other, dst>& aOther) const {
+    return ScaleFactors2D<src, other>(xScale / aOther.xScale, yScale / aOther.yScale);
+  }
+
+  template<class other>
+  ScaleFactors2D<src, other> operator*(const ScaleFactors2D<dst, other>& aOther) const {
+    return ScaleFactors2D<src, other>(xScale * aOther.xScale, yScale * aOther.yScale);
+  }
+
+  template<class other>
+  ScaleFactors2D<other, dst> operator*(const ScaleFactors2D<other, src>& aOther) const {
+    return ScaleFactors2D<other, dst>(xScale * aOther.xScale, yScale * aOther.yScale);
+  }
+
+  template<class other>
+  ScaleFactors2D<src, other> operator*(const ScaleFactor<dst, other>& aOther) const {
+    return *this * ScaleFactors2D<dst, other>(aOther);
+  }
+
+  template<class other>
+  ScaleFactors2D<other, dst> operator*(const ScaleFactor<other, src>& aOther) const {
+    return *this * ScaleFactors2D<other, src>(aOther);
+  }
+
+  template<class other>
+  ScaleFactors2D<src, other> operator/(const ScaleFactor<other, dst>& aOther) const {
+    return *this / ScaleFactors2D<other, dst>(aOther);
+  }
+
+  template<class other>
+  ScaleFactors2D<other, dst> operator/(const ScaleFactor<src, other>& aOther) const {
+    return *this / ScaleFactors2D<src, other>(aOther);
+  }
+
+  template<class other>
+  friend ScaleFactors2D<other, dst> operator*(const ScaleFactor<other, src>& aA,
+                                              const ScaleFactors2D<src, dst>& aB) {
+    return ScaleFactors2D<other, src>(aA) * aB;
+  }
+
+  template<class other>
+  friend ScaleFactors2D<other, src> operator/(const ScaleFactor<other, dst>& aA,
+                                              const ScaleFactors2D<src, dst>& aB) {
+    return ScaleFactors2D<other, src>(aA) / aB;
+  }
+
+
+
+
+  gfxSize operator/(const ScaleFactors2D& aOther) const {
+    return gfxSize(xScale / aOther.xScale, yScale / aOther.yScale);
+  }
+};
+
+}
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayView.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayView.h"
+namespace mozilla {
+namespace gfx {
+
+template<typename T>
+class ArrayView
+{
+    public:
+                     ArrayView(const nsTArray<T>& aData) :
+            mData(aData.Elements()), mLength(aData.Length())
+        {
+        }
+        ArrayView(const T* aData, const size_t aLength) :
+            mData(aData), mLength(aLength)
+        {
+        }
+        const T& operator[](const size_t aIdx) const
+        {
+            return mData[aIdx];
+        }
+        size_t Length() const
+        {
+            return mLength;
+        }
+        const T* Data() const
+        {
+            return mData;
+        }
+    private:
+        const T* mData;
+        const size_t mLength;
+};
+
+}
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 1
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/cairo/pixman-rename.h" 1
+# 74 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman-version.h" 1
+# 78 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 2
+# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+extern "C" {
+# 118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+typedef int pixman_bool_t;
+
+
+
+
+typedef int64_t pixman_fixed_32_32_t;
+typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
+typedef uint32_t pixman_fixed_1_31_t;
+typedef uint32_t pixman_fixed_1_16_t;
+typedef int32_t pixman_fixed_16_16_t;
+typedef pixman_fixed_16_16_t pixman_fixed_t;
+# 149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+typedef struct pixman_color pixman_color_t;
+typedef struct pixman_point_fixed pixman_point_fixed_t;
+typedef struct pixman_line_fixed pixman_line_fixed_t;
+typedef struct pixman_vector pixman_vector_t;
+typedef struct pixman_transform pixman_transform_t;
+
+struct pixman_color
+{
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint16_t alpha;
+};
+
+struct pixman_point_fixed
+{
+    pixman_fixed_t x;
+    pixman_fixed_t y;
+};
+
+struct pixman_line_fixed
+{
+    pixman_point_fixed_t p1, p2;
+};
+
+
+
+
+
+struct pixman_vector
+{
+    pixman_fixed_t vector[3];
+};
+
+struct pixman_transform
+{
+    pixman_fixed_t matrix[3][3];
+};
+
+
+struct pixman_box16;
+typedef union pixman_image pixman_image_t;
+
+void _moz_pixman_transform_init_identity (struct pixman_transform *matrix);
+pixman_bool_t _moz_pixman_transform_point_3d (const struct pixman_transform *transform,
+       struct pixman_vector *vector);
+pixman_bool_t _moz_pixman_transform_point (const struct pixman_transform *transform,
+       struct pixman_vector *vector);
+pixman_bool_t _moz_pixman_transform_multiply (struct pixman_transform *dst,
+       const struct pixman_transform *l,
+       const struct pixman_transform *r);
+void _moz_pixman_transform_init_scale (struct pixman_transform *t,
+       pixman_fixed_t sx,
+       pixman_fixed_t sy);
+pixman_bool_t _moz_pixman_transform_scale (struct pixman_transform *forward,
+       struct pixman_transform *reverse,
+       pixman_fixed_t sx,
+       pixman_fixed_t sy);
+void _moz_pixman_transform_init_rotate (struct pixman_transform *t,
+       pixman_fixed_t cos,
+       pixman_fixed_t sin);
+pixman_bool_t _moz_pixman_transform_rotate (struct pixman_transform *forward,
+       struct pixman_transform *reverse,
+       pixman_fixed_t c,
+       pixman_fixed_t s);
+void _moz_pixman_transform_init_translate (struct pixman_transform *t,
+       pixman_fixed_t tx,
+       pixman_fixed_t ty);
+pixman_bool_t _moz_pixman_transform_translate (struct pixman_transform *forward,
+       struct pixman_transform *reverse,
+       pixman_fixed_t tx,
+       pixman_fixed_t ty);
+pixman_bool_t _moz_pixman_transform_bounds (const struct pixman_transform *matrix,
+       struct pixman_box16 *b);
+pixman_bool_t _moz_pixman_transform_invert (struct pixman_transform *dst,
+       const struct pixman_transform *src);
+pixman_bool_t _moz_pixman_transform_is_identity (const struct pixman_transform *t);
+pixman_bool_t _moz_pixman_transform_is_scale (const struct pixman_transform *t);
+pixman_bool_t _moz_pixman_transform_is_int_translate (const struct pixman_transform *t);
+pixman_bool_t _moz_pixman_transform_is_inverse (const struct pixman_transform *a,
+       const struct pixman_transform *b);
+
+
+
+
+typedef struct pixman_f_transform pixman_f_transform_t;
+typedef struct pixman_f_vector pixman_f_vector_t;
+
+struct pixman_f_vector
+{
+    double v[3];
+};
+
+struct pixman_f_transform
+{
+    double m[3][3];
+};
+
+pixman_bool_t _moz_pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
+       const struct pixman_f_transform *ft);
+void _moz_pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
+       const struct pixman_transform *t);
+pixman_bool_t _moz_pixman_f_transform_invert (struct pixman_f_transform *dst,
+       const struct pixman_f_transform *src);
+pixman_bool_t _moz_pixman_f_transform_point (const struct pixman_f_transform *t,
+       struct pixman_f_vector *v);
+void _moz_pixman_f_transform_point_3d (const struct pixman_f_transform *t,
+       struct pixman_f_vector *v);
+void _moz_pixman_f_transform_multiply (struct pixman_f_transform *dst,
+       const struct pixman_f_transform *l,
+       const struct pixman_f_transform *r);
+void _moz_pixman_f_transform_init_scale (struct pixman_f_transform *t,
+       double sx,
+       double sy);
+pixman_bool_t _moz_pixman_f_transform_scale (struct pixman_f_transform *forward,
+       struct pixman_f_transform *reverse,
+       double sx,
+       double sy);
+void _moz_pixman_f_transform_init_rotate (struct pixman_f_transform *t,
+       double cos,
+       double sin);
+pixman_bool_t _moz_pixman_f_transform_rotate (struct pixman_f_transform *forward,
+       struct pixman_f_transform *reverse,
+       double c,
+       double s);
+void _moz_pixman_f_transform_init_translate (struct pixman_f_transform *t,
+       double tx,
+       double ty);
+pixman_bool_t _moz_pixman_f_transform_translate (struct pixman_f_transform *forward,
+       struct pixman_f_transform *reverse,
+       double tx,
+       double ty);
+pixman_bool_t _moz_pixman_f_transform_bounds (const struct pixman_f_transform *t,
+       struct pixman_box16 *b);
+void _moz_pixman_f_transform_init_identity (struct pixman_f_transform *t);
+
+typedef enum
+{
+    PIXMAN_REPEAT_NONE,
+    PIXMAN_REPEAT_NORMAL,
+    PIXMAN_REPEAT_PAD,
+    PIXMAN_REPEAT_REFLECT
+} pixman_repeat_t;
+
+typedef enum
+{
+    PIXMAN_FILTER_FAST,
+    PIXMAN_FILTER_GOOD,
+    PIXMAN_FILTER_BEST,
+    PIXMAN_FILTER_NEAREST,
+    PIXMAN_FILTER_BILINEAR,
+    PIXMAN_FILTER_CONVOLUTION,
+# 321 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+    PIXMAN_FILTER_SEPARABLE_CONVOLUTION
+} pixman_filter_t;
+
+typedef enum
+{
+    PIXMAN_OP_CLEAR = 0x00,
+    PIXMAN_OP_SRC = 0x01,
+    PIXMAN_OP_DST = 0x02,
+    PIXMAN_OP_OVER = 0x03,
+    PIXMAN_OP_OVER_REVERSE = 0x04,
+    PIXMAN_OP_IN = 0x05,
+    PIXMAN_OP_IN_REVERSE = 0x06,
+    PIXMAN_OP_OUT = 0x07,
+    PIXMAN_OP_OUT_REVERSE = 0x08,
+    PIXMAN_OP_ATOP = 0x09,
+    PIXMAN_OP_ATOP_REVERSE = 0x0a,
+    PIXMAN_OP_XOR = 0x0b,
+    PIXMAN_OP_ADD = 0x0c,
+    PIXMAN_OP_SATURATE = 0x0d,
+
+    PIXMAN_OP_DISJOINT_CLEAR = 0x10,
+    PIXMAN_OP_DISJOINT_SRC = 0x11,
+    PIXMAN_OP_DISJOINT_DST = 0x12,
+    PIXMAN_OP_DISJOINT_OVER = 0x13,
+    PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
+    PIXMAN_OP_DISJOINT_IN = 0x15,
+    PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
+    PIXMAN_OP_DISJOINT_OUT = 0x17,
+    PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
+    PIXMAN_OP_DISJOINT_ATOP = 0x19,
+    PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
+    PIXMAN_OP_DISJOINT_XOR = 0x1b,
+
+    PIXMAN_OP_CONJOINT_CLEAR = 0x20,
+    PIXMAN_OP_CONJOINT_SRC = 0x21,
+    PIXMAN_OP_CONJOINT_DST = 0x22,
+    PIXMAN_OP_CONJOINT_OVER = 0x23,
+    PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
+    PIXMAN_OP_CONJOINT_IN = 0x25,
+    PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
+    PIXMAN_OP_CONJOINT_OUT = 0x27,
+    PIXMAN_OP_CONJOINT_OUT_REVERSE = 0x28,
+    PIXMAN_OP_CONJOINT_ATOP = 0x29,
+    PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
+    PIXMAN_OP_CONJOINT_XOR = 0x2b,
+
+    PIXMAN_OP_MULTIPLY = 0x30,
+    PIXMAN_OP_SCREEN = 0x31,
+    PIXMAN_OP_OVERLAY = 0x32,
+    PIXMAN_OP_DARKEN = 0x33,
+    PIXMAN_OP_LIGHTEN = 0x34,
+    PIXMAN_OP_COLOR_DODGE = 0x35,
+    PIXMAN_OP_COLOR_BURN = 0x36,
+    PIXMAN_OP_HARD_LIGHT = 0x37,
+    PIXMAN_OP_SOFT_LIGHT = 0x38,
+    PIXMAN_OP_DIFFERENCE = 0x39,
+    PIXMAN_OP_EXCLUSION = 0x3a,
+    PIXMAN_OP_HSL_HUE = 0x3b,
+    PIXMAN_OP_HSL_SATURATION = 0x3c,
+    PIXMAN_OP_HSL_COLOR = 0x3d,
+    PIXMAN_OP_HSL_LUMINOSITY = 0x3e
+
+
+
+
+
+
+} pixman_op_t;
+
+
+
+
+typedef struct pixman_region16_data pixman_region16_data_t;
+typedef struct pixman_box16 pixman_box16_t;
+typedef struct pixman_rectangle16 pixman_rectangle16_t;
+typedef struct pixman_region16 pixman_region16_t;
+
+struct pixman_region16_data {
+    long size;
+    long numRects;
+
+};
+
+struct pixman_rectangle16
+{
+    int16_t x, y;
+    uint16_t width, height;
+};
+
+struct pixman_box16
+{
+    int16_t x1, y1, x2, y2;
+};
+
+struct pixman_region16
+{
+    pixman_box16_t extents;
+    pixman_region16_data_t *data;
+};
+
+typedef enum
+{
+    PIXMAN_REGION_OUT,
+    PIXMAN_REGION_IN,
+    PIXMAN_REGION_PART
+} pixman_region_overlap_t;
+
+
+
+
+void _moz_pixman_region_set_static_pointers (pixman_box16_t *empty_box,
+     pixman_region16_data_t *empty_data,
+     pixman_region16_data_t *broken_data);
+
+
+void _moz_pixman_region_init (pixman_region16_t *region);
+void _moz_pixman_region_init_rect (pixman_region16_t *region,
+         int x,
+         int y,
+         unsigned int width,
+         unsigned int height);
+pixman_bool_t _moz_pixman_region_init_rects (pixman_region16_t *region,
+         const pixman_box16_t *boxes,
+         int count);
+void _moz_pixman_region_init_with_extents (pixman_region16_t *region,
+         pixman_box16_t *extents);
+void _moz_pixman_region_init_from_image (pixman_region16_t *region,
+         pixman_image_t *image);
+void _moz_pixman_region_fini (pixman_region16_t *region);
+
+
+
+void _moz_pixman_region_translate (pixman_region16_t *region,
+         int x,
+         int y);
+pixman_bool_t _moz_pixman_region_copy (pixman_region16_t *dest,
+         pixman_region16_t *source);
+pixman_bool_t _moz_pixman_region_intersect (pixman_region16_t *new_reg,
+         pixman_region16_t *reg1,
+         pixman_region16_t *reg2);
+pixman_bool_t _moz_pixman_region_union (pixman_region16_t *new_reg,
+         pixman_region16_t *reg1,
+         pixman_region16_t *reg2);
+pixman_bool_t _moz_pixman_region_union_rect (pixman_region16_t *dest,
+         pixman_region16_t *source,
+         int x,
+         int y,
+         unsigned int width,
+         unsigned int height);
+pixman_bool_t _moz_pixman_region_intersect_rect (pixman_region16_t *dest,
+         pixman_region16_t *source,
+         int x,
+         int y,
+         unsigned int width,
+         unsigned int height);
+pixman_bool_t _moz_pixman_region_subtract (pixman_region16_t *reg_d,
+         pixman_region16_t *reg_m,
+         pixman_region16_t *reg_s);
+pixman_bool_t _moz_pixman_region_inverse (pixman_region16_t *new_reg,
+         pixman_region16_t *reg1,
+         pixman_box16_t *inv_rect);
+pixman_bool_t _moz_pixman_region_contains_point (pixman_region16_t *region,
+         int x,
+         int y,
+         pixman_box16_t *box);
+pixman_region_overlap_t _moz_pixman_region_contains_rectangle (pixman_region16_t *region,
+         pixman_box16_t *prect);
+pixman_bool_t _moz_pixman_region_not_empty (pixman_region16_t *region);
+pixman_box16_t * _moz_pixman_region_extents (pixman_region16_t *region);
+int _moz_pixman_region_n_rects (pixman_region16_t *region);
+pixman_box16_t * _moz_pixman_region_rectangles (pixman_region16_t *region,
+         int *n_rects);
+pixman_bool_t _moz_pixman_region_equal (pixman_region16_t *region1,
+         pixman_region16_t *region2);
+pixman_bool_t _moz_pixman_region_selfcheck (pixman_region16_t *region);
+void _moz_pixman_region_reset (pixman_region16_t *region,
+         pixman_box16_t *box);
+void _moz_pixman_region_clear (pixman_region16_t *region);
+
+
+
+typedef struct pixman_region32_data pixman_region32_data_t;
+typedef struct pixman_box32 pixman_box32_t;
+typedef struct pixman_rectangle32 pixman_rectangle32_t;
+typedef struct pixman_region32 pixman_region32_t;
+
+struct pixman_region32_data {
+    long size;
+    long numRects;
+
+};
+
+struct pixman_rectangle32
+{
+    int32_t x, y;
+    uint32_t width, height;
+};
+
+struct pixman_box32
+{
+    int32_t x1, y1, x2, y2;
+};
+
+struct pixman_region32
+{
+    pixman_box32_t extents;
+    pixman_region32_data_t *data;
+};
+
+
+void _moz_pixman_region32_init (pixman_region32_t *region);
+void _moz_pixman_region32_init_rect (pixman_region32_t *region,
+           int x,
+           int y,
+           unsigned int width,
+           unsigned int height);
+pixman_bool_t _moz_pixman_region32_init_rects (pixman_region32_t *region,
+           const pixman_box32_t *boxes,
+           int count);
+void _moz_pixman_region32_init_with_extents (pixman_region32_t *region,
+           pixman_box32_t *extents);
+void _moz_pixman_region32_init_from_image (pixman_region32_t *region,
+           pixman_image_t *image);
+void _moz_pixman_region32_fini (pixman_region32_t *region);
+
+
+
+void _moz_pixman_region32_translate (pixman_region32_t *region,
+           int x,
+           int y);
+pixman_bool_t _moz_pixman_region32_copy (pixman_region32_t *dest,
+           pixman_region32_t *source);
+pixman_bool_t _moz_pixman_region32_intersect (pixman_region32_t *new_reg,
+           pixman_region32_t *reg1,
+           pixman_region32_t *reg2);
+pixman_bool_t _moz_pixman_region32_union (pixman_region32_t *new_reg,
+           pixman_region32_t *reg1,
+           pixman_region32_t *reg2);
+pixman_bool_t _moz_pixman_region32_intersect_rect (pixman_region32_t *dest,
+           pixman_region32_t *source,
+           int x,
+           int y,
+           unsigned int width,
+           unsigned int height);
+pixman_bool_t _moz_pixman_region32_union_rect (pixman_region32_t *dest,
+           pixman_region32_t *source,
+           int x,
+           int y,
+           unsigned int width,
+           unsigned int height);
+pixman_bool_t _moz_pixman_region32_subtract (pixman_region32_t *reg_d,
+           pixman_region32_t *reg_m,
+           pixman_region32_t *reg_s);
+pixman_bool_t _moz_pixman_region32_inverse (pixman_region32_t *new_reg,
+           pixman_region32_t *reg1,
+           pixman_box32_t *inv_rect);
+pixman_bool_t _moz_pixman_region32_contains_point (pixman_region32_t *region,
+           int x,
+           int y,
+           pixman_box32_t *box);
+pixman_region_overlap_t _moz_pixman_region32_contains_rectangle (pixman_region32_t *region,
+           pixman_box32_t *prect);
+pixman_bool_t _moz_pixman_region32_not_empty (pixman_region32_t *region);
+pixman_box32_t * _moz_pixman_region32_extents (pixman_region32_t *region);
+int _moz_pixman_region32_n_rects (pixman_region32_t *region);
+pixman_box32_t * _moz_pixman_region32_rectangles (pixman_region32_t *region,
+           int *n_rects);
+pixman_bool_t _moz_pixman_region32_equal (pixman_region32_t *region1,
+           pixman_region32_t *region2);
+pixman_bool_t _moz_pixman_region32_selfcheck (pixman_region32_t *region);
+void _moz_pixman_region32_reset (pixman_region32_t *region,
+           pixman_box32_t *box);
+void _moz_pixman_region32_clear (pixman_region32_t *region);
+
+
+
+pixman_bool_t _moz_pixman_blt (uint32_t *src_bits,
+      uint32_t *dst_bits,
+      int src_stride,
+      int dst_stride,
+      int src_bpp,
+      int dst_bpp,
+      int src_x,
+      int src_y,
+      int dest_x,
+      int dest_y,
+      int width,
+      int height);
+pixman_bool_t _moz_pixman_fill (uint32_t *bits,
+      int stride,
+      int bpp,
+      int x,
+      int y,
+      int width,
+      int height,
+      uint32_t _xor);
+
+int _moz_pixman_version (void);
+const char* _moz_pixman_version_string (void);
+
+
+
+
+typedef struct pixman_indexed pixman_indexed_t;
+typedef struct pixman_gradient_stop pixman_gradient_stop_t;
+
+typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
+typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
+
+typedef void (* pixman_image_destroy_func_t) (pixman_image_t *image, void *data);
+
+struct pixman_gradient_stop {
+    pixman_fixed_t x;
+    pixman_color_t color;
+};
+
+
+
+
+typedef uint8_t pixman_index_type;
+
+
+struct pixman_indexed
+{
+    pixman_bool_t color;
+    uint32_t rgba[256];
+    pixman_index_type ent[32768];
+};
+# 694 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+typedef enum {
+    PIXMAN_a8r8g8b8 = (((32) << 24) | ((2) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_x8r8g8b8 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_a8b8g8r8 = (((32) << 24) | ((3) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_x8b8g8r8 = (((32) << 24) | ((3) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_b8g8r8a8 = (((32) << 24) | ((8) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_b8g8r8x8 = (((32) << 24) | ((8) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_r8g8b8a8 = (((32) << 24) | ((9) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_r8g8b8x8 = (((32) << 24) | ((9) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_x14r6g6b6 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((6) << 8) | ((6) << 4) | ((6))),
+    PIXMAN_x2r10g10b10 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
+    PIXMAN_a2r10g10b10 = (((32) << 24) | ((2) << 16) | ((2) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
+    PIXMAN_x2b10g10r10 = (((32) << 24) | ((3) << 16) | ((0) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
+    PIXMAN_a2b10g10r10 = (((32) << 24) | ((3) << 16) | ((2) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
+
+
+    PIXMAN_a8r8g8b8_sRGB = (((32) << 24) | ((10) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+
+
+    PIXMAN_r8g8b8 = (((24) << 24) | ((2) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+    PIXMAN_b8g8r8 = (((24) << 24) | ((3) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
+
+
+    PIXMAN_r5g6b5 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((5) << 8) | ((6) << 4) | ((5))),
+    PIXMAN_b5g6r5 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((5) << 8) | ((6) << 4) | ((5))),
+
+    PIXMAN_a1r5g5b5 = (((16) << 24) | ((2) << 16) | ((1) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
+    PIXMAN_x1r5g5b5 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
+    PIXMAN_a1b5g5r5 = (((16) << 24) | ((3) << 16) | ((1) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
+    PIXMAN_x1b5g5r5 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
+    PIXMAN_a4r4g4b4 = (((16) << 24) | ((2) << 16) | ((4) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
+    PIXMAN_x4r4g4b4 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
+    PIXMAN_a4b4g4r4 = (((16) << 24) | ((3) << 16) | ((4) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
+    PIXMAN_x4b4g4r4 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
+
+
+    PIXMAN_a8 = (((8) << 24) | ((1) << 16) | ((8) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_r3g3b2 = (((8) << 24) | ((2) << 16) | ((0) << 12) | ((3) << 8) | ((3) << 4) | ((2))),
+    PIXMAN_b2g3r3 = (((8) << 24) | ((3) << 16) | ((0) << 12) | ((3) << 8) | ((3) << 4) | ((2))),
+    PIXMAN_a2r2g2b2 = (((8) << 24) | ((2) << 16) | ((2) << 12) | ((2) << 8) | ((2) << 4) | ((2))),
+    PIXMAN_a2b2g2r2 = (((8) << 24) | ((3) << 16) | ((2) << 12) | ((2) << 8) | ((2) << 4) | ((2))),
+
+    PIXMAN_c8 = (((8) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_g8 = (((8) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+    PIXMAN_x4a4 = (((8) << 24) | ((1) << 16) | ((4) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+    PIXMAN_x4c4 = (((8) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_x4g4 = (((8) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+
+    PIXMAN_a4 = (((4) << 24) | ((1) << 16) | ((4) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_r1g2b1 = (((4) << 24) | ((2) << 16) | ((0) << 12) | ((1) << 8) | ((2) << 4) | ((1))),
+    PIXMAN_b1g2r1 = (((4) << 24) | ((3) << 16) | ((0) << 12) | ((1) << 8) | ((2) << 4) | ((1))),
+    PIXMAN_a1r1g1b1 = (((4) << 24) | ((2) << 16) | ((1) << 12) | ((1) << 8) | ((1) << 4) | ((1))),
+    PIXMAN_a1b1g1r1 = (((4) << 24) | ((3) << 16) | ((1) << 12) | ((1) << 8) | ((1) << 4) | ((1))),
+
+    PIXMAN_c4 = (((4) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_g4 = (((4) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+
+    PIXMAN_a1 = (((1) << 24) | ((1) << 16) | ((1) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+    PIXMAN_g1 = (((1) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+
+
+    PIXMAN_yuy2 = (((16) << 24) | ((6) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
+    PIXMAN_yv12 = (((12) << 24) | ((7) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
+} pixman_format_code_t;
+
+
+pixman_bool_t _moz_pixman_format_supported_destination (pixman_format_code_t format);
+pixman_bool_t _moz_pixman_format_supported_source (pixman_format_code_t format);
+
+
+pixman_image_t *_moz_pixman_image_create_solid_fill (const pixman_color_t *color);
+pixman_image_t *_moz_pixman_image_create_linear_gradient (const pixman_point_fixed_t *p1,
+            const pixman_point_fixed_t *p2,
+            const pixman_gradient_stop_t *stops,
+            int n_stops);
+pixman_image_t *_moz_pixman_image_create_radial_gradient (const pixman_point_fixed_t *inner,
+            const pixman_point_fixed_t *outer,
+            pixman_fixed_t inner_radius,
+            pixman_fixed_t outer_radius,
+            const pixman_gradient_stop_t *stops,
+            int n_stops);
+pixman_image_t *_moz_pixman_image_create_conical_gradient (const pixman_point_fixed_t *center,
+            pixman_fixed_t angle,
+            const pixman_gradient_stop_t *stops,
+            int n_stops);
+pixman_image_t *_moz_pixman_image_create_bits (pixman_format_code_t format,
+            int width,
+            int height,
+            uint32_t *bits,
+            int rowstride_bytes);
+pixman_image_t *pixman_image_create_bits_no_clear (pixman_format_code_t format,
+            int width,
+            int height,
+            uint32_t * bits,
+            int rowstride_bytes);
+
+
+pixman_image_t *_moz_pixman_image_ref (pixman_image_t *image);
+pixman_bool_t _moz_pixman_image_unref (pixman_image_t *image);
+
+void _moz_pixman_image_set_destroy_function (pixman_image_t *image,
+            pixman_image_destroy_func_t function,
+            void *data);
+void * _moz_pixman_image_get_destroy_data (pixman_image_t *image);
+
+
+pixman_bool_t _moz_pixman_image_set_clip_region (pixman_image_t *image,
+            pixman_region16_t *region);
+pixman_bool_t _moz_pixman_image_set_clip_region32 (pixman_image_t *image,
+            pixman_region32_t *region);
+void _moz_pixman_image_set_has_client_clip (pixman_image_t *image,
+            pixman_bool_t clien_clip);
+pixman_bool_t _moz_pixman_image_set_transform (pixman_image_t *image,
+            const pixman_transform_t *transform);
+void _moz_pixman_image_set_repeat (pixman_image_t *image,
+            pixman_repeat_t repeat);
+pixman_bool_t _moz_pixman_image_set_filter (pixman_image_t *image,
+            pixman_filter_t filter,
+            const pixman_fixed_t *filter_params,
+            int n_filter_params);
+void _moz_pixman_image_set_source_clipping (pixman_image_t *image,
+            pixman_bool_t source_clipping);
+void _moz_pixman_image_set_alpha_map (pixman_image_t *image,
+            pixman_image_t *alpha_map,
+            int16_t x,
+            int16_t y);
+void _moz_pixman_image_set_component_alpha (pixman_image_t *image,
+            pixman_bool_t component_alpha);
+pixman_bool_t _moz_pixman_image_get_component_alpha (pixman_image_t *image);
+void _moz_pixman_image_set_accessors (pixman_image_t *image,
+            pixman_read_memory_func_t read_func,
+            pixman_write_memory_func_t write_func);
+void _moz_pixman_image_set_indexed (pixman_image_t *image,
+            const pixman_indexed_t *indexed);
+uint32_t *_moz_pixman_image_get_data (pixman_image_t *image);
+int _moz_pixman_image_get_width (pixman_image_t *image);
+int _moz_pixman_image_get_height (pixman_image_t *image);
+int _moz_pixman_image_get_stride (pixman_image_t *image);
+int _moz_pixman_image_get_depth (pixman_image_t *image);
+pixman_format_code_t _moz_pixman_image_get_format (pixman_image_t *image);
+
+typedef enum
+{
+    PIXMAN_KERNEL_IMPULSE,
+    PIXMAN_KERNEL_BOX,
+    PIXMAN_KERNEL_LINEAR,
+    PIXMAN_KERNEL_CUBIC,
+    PIXMAN_KERNEL_GAUSSIAN,
+    PIXMAN_KERNEL_LANCZOS2,
+    PIXMAN_KERNEL_LANCZOS3,
+    PIXMAN_KERNEL_LANCZOS3_STRETCHED
+} pixman_kernel_t;
+
+
+
+
+pixman_fixed_t *
+pixman_filter_create_separable_convolution (int *n_values,
+         pixman_fixed_t scale_x,
+         pixman_fixed_t scale_y,
+         pixman_kernel_t reconstruct_x,
+         pixman_kernel_t reconstruct_y,
+         pixman_kernel_t sample_x,
+         pixman_kernel_t sample_y,
+         int subsample_bits_x,
+         int subsample_bits_y);
+
+pixman_bool_t _moz_pixman_image_fill_rectangles (pixman_op_t op,
+            pixman_image_t *image,
+            const pixman_color_t *color,
+            int n_rects,
+            const pixman_rectangle16_t *rects);
+pixman_bool_t _moz_pixman_image_fill_boxes (pixman_op_t op,
+                                                      pixman_image_t *dest,
+                                                      const pixman_color_t *color,
+                                                      int n_boxes,
+                                                      const pixman_box32_t *boxes);
+
+
+pixman_bool_t _moz_pixman_compute_composite_region (pixman_region16_t *region,
+            pixman_image_t *src_image,
+            pixman_image_t *mask_image,
+            pixman_image_t *dest_image,
+            int16_t src_x,
+            int16_t src_y,
+            int16_t mask_x,
+            int16_t mask_y,
+            int16_t dest_x,
+            int16_t dest_y,
+            uint16_t width,
+            uint16_t height);
+void _moz_pixman_image_composite (pixman_op_t op,
+            pixman_image_t *src,
+            pixman_image_t *mask,
+            pixman_image_t *dest,
+            int16_t src_x,
+            int16_t src_y,
+            int16_t mask_x,
+            int16_t mask_y,
+            int16_t dest_x,
+            int16_t dest_y,
+            uint16_t width,
+            uint16_t height);
+void _moz_pixman_image_composite32 (pixman_op_t op,
+            pixman_image_t *src,
+            pixman_image_t *mask,
+            pixman_image_t *dest,
+            int32_t src_x,
+            int32_t src_y,
+            int32_t mask_x,
+            int32_t mask_y,
+            int32_t dest_x,
+            int32_t dest_y,
+            int32_t width,
+            int32_t height);
+# 933 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
+void _moz_pixman_disable_out_of_bounds_workaround (void);
+
+
+
+
+typedef struct pixman_glyph_cache_t pixman_glyph_cache_t;
+typedef struct
+{
+    int x, y;
+    const void *glyph;
+} pixman_glyph_t;
+
+pixman_glyph_cache_t *_moz_pixman_glyph_cache_create (void);
+void _moz_pixman_glyph_cache_destroy (pixman_glyph_cache_t *cache);
+void _moz_pixman_glyph_cache_freeze (pixman_glyph_cache_t *cache);
+void _moz_pixman_glyph_cache_thaw (pixman_glyph_cache_t *cache);
+const void * _moz_pixman_glyph_cache_lookup (pixman_glyph_cache_t *cache,
+             void *font_key,
+             void *glyph_key);
+const void * _moz_pixman_glyph_cache_insert (pixman_glyph_cache_t *cache,
+             void *font_key,
+             void *glyph_key,
+             int origin_x,
+             int origin_y,
+             pixman_image_t *glyph_image);
+void _moz_pixman_glyph_cache_remove (pixman_glyph_cache_t *cache,
+             void *font_key,
+             void *glyph_key);
+void _moz_pixman_glyph_get_extents (pixman_glyph_cache_t *cache,
+             int n_glyphs,
+             pixman_glyph_t *glyphs,
+             pixman_box32_t *extents);
+pixman_format_code_t _moz_pixman_glyph_get_mask_format (pixman_glyph_cache_t *cache,
+             int n_glyphs,
+             const pixman_glyph_t *glyphs);
+void _moz_pixman_composite_glyphs (pixman_op_t op,
+             pixman_image_t *src,
+             pixman_image_t *dest,
+             pixman_format_code_t mask_format,
+             int32_t src_x,
+             int32_t src_y,
+             int32_t mask_x,
+             int32_t mask_y,
+             int32_t dest_x,
+             int32_t dest_y,
+             int32_t width,
+             int32_t height,
+             pixman_glyph_cache_t *cache,
+             int n_glyphs,
+             const pixman_glyph_t *glyphs);
+void _moz_pixman_composite_glyphs_no_mask (pixman_op_t op,
+             pixman_image_t *src,
+             pixman_image_t *dest,
+             int32_t src_x,
+             int32_t src_y,
+             int32_t dest_x,
+             int32_t dest_y,
+             pixman_glyph_cache_t *cache,
+             int n_glyphs,
+             const pixman_glyph_t *glyphs);
+
+
+
+
+typedef struct pixman_edge pixman_edge_t;
+typedef struct pixman_trapezoid pixman_trapezoid_t;
+typedef struct pixman_trap pixman_trap_t;
+typedef struct pixman_span_fix pixman_span_fix_t;
+typedef struct pixman_triangle pixman_triangle_t;
+
+
+
+
+
+
+struct pixman_edge
+{
+    pixman_fixed_t x;
+    pixman_fixed_t e;
+    pixman_fixed_t stepx;
+    pixman_fixed_t signdx;
+    pixman_fixed_t dy;
+    pixman_fixed_t dx;
+
+    pixman_fixed_t stepx_small;
+    pixman_fixed_t stepx_big;
+    pixman_fixed_t dx_small;
+    pixman_fixed_t dx_big;
+};
+
+struct pixman_trapezoid
+{
+    pixman_fixed_t top, bottom;
+    pixman_line_fixed_t left, right;
+};
+
+struct pixman_triangle
+{
+    pixman_point_fixed_t p1, p2, p3;
+};
+
+
+
+
+
+
+
+struct pixman_span_fix
+{
+    pixman_fixed_t l, r, y;
+};
+
+struct pixman_trap
+{
+    pixman_span_fix_t top, bot;
+};
+
+pixman_fixed_t _moz_pixman_sample_ceil_y (pixman_fixed_t y,
+         int bpp);
+pixman_fixed_t _moz_pixman_sample_floor_y (pixman_fixed_t y,
+         int bpp);
+void _moz_pixman_edge_step (pixman_edge_t *e,
+         int n);
+void _moz_pixman_edge_init (pixman_edge_t *e,
+         int bpp,
+         pixman_fixed_t y_start,
+         pixman_fixed_t x_top,
+         pixman_fixed_t y_top,
+         pixman_fixed_t x_bot,
+         pixman_fixed_t y_bot);
+void _moz_pixman_line_fixed_edge_init (pixman_edge_t *e,
+         int bpp,
+         pixman_fixed_t y,
+         const pixman_line_fixed_t *line,
+         int x_off,
+         int y_off);
+void _moz_pixman_rasterize_edges (pixman_image_t *image,
+         pixman_edge_t *l,
+         pixman_edge_t *r,
+         pixman_fixed_t t,
+         pixman_fixed_t b);
+void _moz_pixman_add_traps (pixman_image_t *image,
+         int16_t x_off,
+         int16_t y_off,
+         int ntrap,
+         const pixman_trap_t *traps);
+void _moz_pixman_add_trapezoids (pixman_image_t *image,
+         int16_t x_off,
+         int y_off,
+         int ntraps,
+         const pixman_trapezoid_t *traps);
+void _moz_pixman_rasterize_trapezoid (pixman_image_t *image,
+         const pixman_trapezoid_t *trap,
+         int x_off,
+         int y_off);
+void _moz_pixman_composite_trapezoids (pixman_op_t op,
+        pixman_image_t * src,
+        pixman_image_t * dst,
+        pixman_format_code_t mask_format,
+        int x_src,
+        int y_src,
+        int x_dst,
+        int y_dst,
+        int n_traps,
+        const pixman_trapezoid_t * traps);
+void _moz_pixman_composite_triangles (pixman_op_t op,
+       pixman_image_t * src,
+       pixman_image_t * dst,
+       pixman_format_code_t mask_format,
+       int x_src,
+       int y_src,
+       int x_dst,
+       int y_dst,
+       int n_tris,
+       const pixman_triangle_t * tris);
+void _moz_pixman_add_triangles (pixman_image_t *image,
+       int32_t x_off,
+       int32_t y_off,
+       int n_tris,
+       const pixman_triangle_t *tris);
+
+}
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+enum class VisitSide {
+ TOP,
+ BOTTOM,
+ LEFT,
+ RIGHT
+};
+
+class nsRegion
+{
+public:
+  typedef nsRect RectType;
+  typedef nsPoint PointType;
+  typedef nsMargin MarginType;
+
+  nsRegion () { _moz_pixman_region32_init(&mImpl); }
+               nsRegion (const nsRect& aRect) { _moz_pixman_region32_init_rect(&mImpl,
+                                                                          aRect.x,
+                                                                          aRect.y,
+                                                                          aRect.width,
+                                                                          aRect.height); }
+  explicit nsRegion (mozilla::gfx::ArrayView<pixman_box32_t> aRects)
+  {
+    _moz_pixman_region32_init_rects(&mImpl, aRects.Data(), aRects.Length());
+  }
+  nsRegion (const nsRegion& aRegion) { _moz_pixman_region32_init(&mImpl); _moz_pixman_region32_copy(&mImpl,aRegion.Impl()); }
+  nsRegion (nsRegion&& aRegion) { mImpl = aRegion.mImpl; _moz_pixman_region32_init(&aRegion.mImpl); }
+  nsRegion& operator = (nsRegion&& aRegion) {
+      _moz_pixman_region32_fini(&mImpl);
+      mImpl = aRegion.mImpl;
+      _moz_pixman_region32_init(&aRegion.mImpl);
+      return *this;
+  }
+ ~nsRegion () { _moz_pixman_region32_fini(&mImpl); }
+  nsRegion& operator = (const nsRect& aRect) { Copy (aRect); return *this; }
+  nsRegion& operator = (const nsRegion& aRegion) { Copy (aRegion); return *this; }
+  bool operator==(const nsRegion& aRgn) const
+  {
+    return IsEqual(aRgn);
+  }
+  bool operator!=(const nsRegion& aRgn) const
+  {
+    return !(*this == aRgn);
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const nsRegion& m);
+
+  void Swap(nsRegion* aOther)
+  {
+    pixman_region32_t tmp = mImpl;
+    mImpl = aOther->mImpl;
+    aOther->mImpl = tmp;
+  }
+
+  static
+  nsresult InitStatic()
+  {
+    return NS_OK;
+  }
+
+  static
+  void ShutdownStatic() {}
+
+  void AndWith(const nsRegion& aOther)
+  {
+    And(*this, aOther);
+  }
+  void AndWith(const nsRect& aOther)
+  {
+    And(*this, aOther);
+  }
+  nsRegion& And(const nsRegion& aRgn1, const nsRegion& aRgn2)
+  {
+    _moz_pixman_region32_intersect(&mImpl, aRgn1.Impl(), aRgn2.Impl());
+    return *this;
+  }
+  nsRegion& And(const nsRect& aRect, const nsRegion& aRegion)
+  {
+    return And(aRegion, aRect);
+  }
+  nsRegion& And(const nsRegion& aRegion, const nsRect& aRect)
+  {
+    _moz_pixman_region32_intersect_rect(&mImpl, aRegion.Impl(), aRect.x, aRect.y, aRect.width, aRect.height);
+    return *this;
+  }
+  nsRegion& And(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    nsRect TmpRect;
+
+    TmpRect.IntersectRect(aRect1, aRect2);
+    return Copy(TmpRect);
+  }
+
+  nsRegion& OrWith(const nsRegion& aOther)
+  {
+    return Or(*this, aOther);
+  }
+  nsRegion& OrWith(const nsRect& aOther)
+  {
+    return Or(*this, aOther);
+  }
+  nsRegion& Or(const nsRegion& aRgn1, const nsRegion& aRgn2)
+  {
+    _moz_pixman_region32_union(&mImpl, aRgn1.Impl(), aRgn2.Impl());
+    return *this;
+  }
+  nsRegion& Or(const nsRegion& aRegion, const nsRect& aRect)
+  {
+    _moz_pixman_region32_union_rect(&mImpl, aRegion.Impl(), aRect.x, aRect.y, aRect.width, aRect.height);
+    return *this;
+  }
+  nsRegion& Or(const nsRect& aRect, const nsRegion& aRegion)
+  {
+    return Or(aRegion, aRect);
+  }
+  nsRegion& Or(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    Copy (aRect1);
+    return Or (*this, aRect2);
+  }
+
+  nsRegion& XorWith(const nsRegion& aOther)
+  {
+    return Xor(*this, aOther);
+  }
+  nsRegion& XorWith(const nsRect& aOther)
+  {
+    return Xor(*this, aOther);
+  }
+  nsRegion& Xor(const nsRegion& aRgn1, const nsRegion& aRgn2)
+  {
+
+
+    nsRegion p;
+    p.Sub(aRgn1, aRgn2);
+    nsRegion q;
+    q.Sub(aRgn2, aRgn1);
+    return Or(p, q);
+  }
+  nsRegion& Xor(const nsRegion& aRegion, const nsRect& aRect)
+  {
+    return Xor(aRegion, nsRegion(aRect));
+  }
+  nsRegion& Xor(const nsRect& aRect, const nsRegion& aRegion)
+  {
+    return Xor(nsRegion(aRect), aRegion);
+  }
+  nsRegion& Xor(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    return Xor(nsRegion(aRect1), nsRegion(aRect2));
+  }
+
+  nsRegion ToAppUnits (nscoord aAppUnitsPerPixel) const;
+
+  nsRegion& SubOut(const nsRegion& aOther)
+  {
+    return Sub(*this, aOther);
+  }
+  nsRegion& SubOut(const nsRect& aOther)
+  {
+    return Sub(*this, aOther);
+  }
+  nsRegion& Sub(const nsRegion& aRgn1, const nsRegion& aRgn2)
+  {
+    _moz_pixman_region32_subtract(&mImpl, aRgn1.Impl(), aRgn2.Impl());
+    return *this;
+  }
+  nsRegion& Sub(const nsRegion& aRegion, const nsRect& aRect)
+  {
+    return Sub(aRegion, nsRegion(aRect));
+  }
+  nsRegion& Sub(const nsRect& aRect, const nsRegion& aRegion)
+  {
+    return Sub(nsRegion(aRect), aRegion);
+  }
+  nsRegion& Sub(const nsRect& aRect1, const nsRect& aRect2)
+  {
+    Copy(aRect1);
+    return Sub(*this, aRect2);
+  }
+
+
+
+
+
+
+  bool Contains (int aX, int aY) const
+  {
+    return _moz_pixman_region32_contains_point(Impl(), aX, aY, nullptr);
+  }
+  bool Contains (const nsRect& aRect) const
+  {
+    pixman_box32_t box = RectToBox(aRect);
+    return _moz_pixman_region32_contains_rectangle(Impl(), &box) == PIXMAN_REGION_IN;
+  }
+  bool Contains (const nsRegion& aRgn) const;
+  bool Intersects (const nsRect& aRect) const;
+
+  void MoveBy (int32_t aXOffset, int32_t aYOffset)
+  {
+    MoveBy (nsPoint (aXOffset, aYOffset));
+  }
+  void MoveBy (nsPoint aPt) { _moz_pixman_region32_translate(&mImpl, aPt.x, aPt.y); }
+  void SetEmpty ()
+  {
+    _moz_pixman_region32_clear(&mImpl);
+  }
+
+  nsRegion MovedBy(int32_t aXOffset, int32_t aYOffset) const
+  {
+    return MovedBy(nsPoint(aXOffset, aYOffset));
+  }
+  nsRegion MovedBy(const nsPoint& aPt) const
+  {
+    nsRegion copy(*this);
+    copy.MoveBy(aPt);
+    return copy;
+  }
+
+  nsRegion Intersect(const nsRegion& aOther) const
+  {
+    nsRegion intersection;
+    intersection.And(*this, aOther);
+    return intersection;
+  }
+
+  void Inflate(const nsMargin& aMargin);
+
+  nsRegion Inflated(const nsMargin& aMargin) const
+  {
+    nsRegion copy(*this);
+    copy.Inflate(aMargin);
+    return copy;
+  }
+
+  bool IsEmpty () const { return !_moz_pixman_region32_not_empty(Impl()); }
+  bool IsComplex () const { return GetNumRects() > 1; }
+  bool IsEqual (const nsRegion& aRegion) const
+  {
+    return _moz_pixman_region32_equal(Impl(), aRegion.Impl());
+  }
+  uint32_t GetNumRects () const
+  {
+
+
+    uint32_t result = _moz_pixman_region32_n_rects(Impl());
+    return (result == 1 && GetBounds().IsEmpty()) ? 0 : result;
+  }
+  const nsRect GetBounds () const { return BoxToRect(mImpl.extents); }
+  uint64_t Area () const;
+# 300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+  __attribute__ ((warn_unused_result)) nsRegion
+    ScaleToOtherAppUnitsRoundOut (int32_t aFromAPP, int32_t aToAPP) const;
+  __attribute__ ((warn_unused_result)) nsRegion
+    ScaleToOtherAppUnitsRoundIn (int32_t aFromAPP, int32_t aToAPP) const;
+  nsRegion& ScaleRoundOut(float aXScale, float aYScale);
+  nsRegion& ScaleInverseRoundOut(float aXScale, float aYScale);
+  nsRegion& Transform (const mozilla::gfx::Matrix4x4 &aTransform);
+  nsIntRegion ScaleToOutsidePixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
+  nsIntRegion ScaleToInsidePixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
+  nsIntRegion ScaleToNearestPixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
+  nsIntRegion ToOutsidePixels (nscoord aAppUnitsPerPixel) const;
+  nsIntRegion ToNearestPixels (nscoord aAppUnitsPerPixel) const;
+
+
+
+
+
+
+
+  nsRect GetLargestRectangle (const nsRect& aContainingRect = nsRect()) const;
+
+
+
+
+
+
+
+  void SimplifyOutward (uint32_t aMaxRects);
+
+
+
+
+
+
+  void SimplifyOutwardByArea(uint32_t aThreshold);
+
+
+
+
+
+  void SimplifyInward (uint32_t aMaxRects);
+# 354 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+  typedef void (*visitFn)(void *closure, VisitSide side, int x1, int y1, int x2, int y2);
+  void VisitEdges(visitFn, void *closure);
+
+  nsCString ToString() const;
+
+  class RectIterator
+  {
+    int mCurrent;
+    int mLimit;
+    mutable nsRect mTmp;
+    pixman_box32_t *mBoxes;
+
+  public:
+    explicit RectIterator(const nsRegion& aRegion)
+    {
+      mCurrent = 0;
+      mBoxes = _moz_pixman_region32_rectangles(aRegion.Impl(), &mLimit);
+
+
+      if (mLimit == 1 && nsRegion::BoxToRect(mBoxes[0]).IsEmpty()) {
+        mLimit = 0;
+      }
+    }
+
+    bool Done() const { return mCurrent == mLimit; }
+
+    const nsRect& Get() const
+    {
+      do { } while (0);
+      mTmp = nsRegion::BoxToRect(mBoxes[mCurrent]);
+      do { } while(0);
+      return mTmp;
+    }
+
+    void Next()
+    {
+      do { } while (0);
+      mCurrent++;
+    }
+  };
+
+  RectIterator RectIter() const { return RectIterator(*this); }
+
+private:
+  pixman_region32_t mImpl;
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
+  nsIntRegion ToPixels(nscoord aAppUnitsPerPixel, bool aOutsidePixels) const;
+
+  nsRegion& Copy (const nsRegion& aRegion)
+  {
+    _moz_pixman_region32_copy(&mImpl, aRegion.Impl());
+    return *this;
+  }
+
+  nsRegion& Copy (const nsRect& aRect)
+  {
+
+
+
+
+
+    if (aRect.IsEmpty()) {
+      _moz_pixman_region32_clear(&mImpl);
+    } else {
+      pixman_box32_t box = RectToBox(aRect);
+      _moz_pixman_region32_reset(&mImpl, &box);
+    }
+    return *this;
+  }
+
+  static inline pixman_box32_t RectToBox(const nsRect &aRect)
+  {
+    pixman_box32_t box = { aRect.x, aRect.y, aRect.XMost(), aRect.YMost() };
+    return box;
+  }
+
+  static inline pixman_box32_t RectToBox(const mozilla::gfx::IntRect &aRect)
+  {
+    pixman_box32_t box = { aRect.x, aRect.y, aRect.XMost(), aRect.YMost() };
+    return box;
+  }
+
+
+  static inline nsRect BoxToRect(const pixman_box32_t &aBox)
+  {
+    return nsRect(aBox.x1, aBox.y1,
+                  aBox.x2 - aBox.x1,
+                  aBox.y2 - aBox.y1);
+  }
+
+  pixman_region32_t* Impl() const
+  {
+    return const_cast<pixman_region32_t*>(&mImpl);
+  }
+};
+
+namespace mozilla {
+namespace gfx {
+
+
+
+
+template <typename Derived, typename Rect, typename Point, typename Margin>
+class BaseIntRegion
+{
+  friend class ::nsRegion;
+
+
+
+  template <typename units>
+  friend class IntRegionTyped;
+
+public:
+  typedef Rect RectType;
+  typedef Point PointType;
+  typedef Margin MarginType;
+
+  BaseIntRegion () {}
+               BaseIntRegion (const Rect& aRect) : mImpl (ToRect(aRect)) {}
+  explicit BaseIntRegion (mozilla::gfx::ArrayView<pixman_box32_t> aRects) : mImpl (aRects) {}
+  BaseIntRegion (const BaseIntRegion& aRegion) : mImpl (aRegion.mImpl) {}
+  BaseIntRegion (BaseIntRegion&& aRegion) : mImpl (mozilla::Move(aRegion.mImpl)) {}
+  Derived& operator = (const Rect& aRect) { mImpl = ToRect (aRect); return This(); }
+  Derived& operator = (const Derived& aRegion) { mImpl = aRegion.mImpl; return This(); }
+  Derived& operator = (Derived&& aRegion) { mImpl = mozilla::Move(aRegion.mImpl); return This(); }
+
+  bool operator==(const Derived& aRgn) const
+  {
+    return IsEqual(aRgn);
+  }
+  bool operator!=(const Derived& aRgn) const
+  {
+    return !(*this == aRgn);
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const Derived& m) {
+    return stream << m.mImpl;
+  }
+
+  void Swap(Derived* aOther)
+  {
+    mImpl.Swap(&aOther->mImpl);
+  }
+
+  void AndWith(const Derived& aOther)
+  {
+    And(This(), aOther);
+  }
+  void AndWith(const Rect& aOther)
+  {
+    And(This(), aOther);
+  }
+  Derived& And (const Derived& aRgn1, const Derived& aRgn2)
+  {
+    mImpl.And (aRgn1.mImpl, aRgn2.mImpl);
+    return This();
+  }
+  Derived& And (const Derived& aRegion, const Rect& aRect)
+  {
+    mImpl.And (aRegion.mImpl, ToRect (aRect));
+    return This();
+  }
+  Derived& And (const Rect& aRect, const Derived& aRegion)
+  {
+    return And (aRegion, aRect);
+  }
+  Derived& And (const Rect& aRect1, const Rect& aRect2)
+  {
+    Rect TmpRect;
+
+    TmpRect.IntersectRect (aRect1, aRect2);
+    mImpl = ToRect (TmpRect);
+    return This();
+  }
+
+  Derived& OrWith(const Derived& aOther)
+  {
+    return Or(This(), aOther);
+  }
+  Derived& OrWith(const Rect& aOther)
+  {
+    return Or(This(), aOther);
+  }
+  Derived& Or (const Derived& aRgn1, const Derived& aRgn2)
+  {
+    mImpl.Or (aRgn1.mImpl, aRgn2.mImpl);
+    return This();
+  }
+  Derived& Or (const Derived& aRegion, const Rect& aRect)
+  {
+    mImpl.Or (aRegion.mImpl, ToRect (aRect));
+    return This();
+  }
+  Derived& Or (const Rect& aRect, const Derived& aRegion)
+  {
+    return Or (aRegion, aRect);
+  }
+  Derived& Or (const Rect& aRect1, const Rect& aRect2)
+  {
+    mImpl = ToRect (aRect1);
+    return Or (This(), aRect2);
+  }
+
+  Derived& XorWith(const Derived& aOther)
+  {
+    return Xor(This(), aOther);
+  }
+  Derived& XorWith(const Rect& aOther)
+  {
+    return Xor(This(), aOther);
+  }
+  Derived& Xor (const Derived& aRgn1, const Derived& aRgn2)
+  {
+    mImpl.Xor (aRgn1.mImpl, aRgn2.mImpl);
+    return This();
+  }
+  Derived& Xor (const Derived& aRegion, const Rect& aRect)
+  {
+    mImpl.Xor (aRegion.mImpl, ToRect (aRect));
+    return This();
+  }
+  Derived& Xor (const Rect& aRect, const Derived& aRegion)
+  {
+    return Xor (aRegion, aRect);
+  }
+  Derived& Xor (const Rect& aRect1, const Rect& aRect2)
+  {
+    mImpl = ToRect (aRect1);
+    return Xor (This(), aRect2);
+  }
+
+  Derived& SubOut(const Derived& aOther)
+  {
+    return Sub(This(), aOther);
+  }
+  Derived& SubOut(const Rect& aOther)
+  {
+    return Sub(This(), aOther);
+  }
+  Derived& Sub (const Derived& aRgn1, const Derived& aRgn2)
+  {
+    mImpl.Sub (aRgn1.mImpl, aRgn2.mImpl);
+    return This();
+  }
+  Derived& Sub (const Derived& aRegion, const Rect& aRect)
+  {
+    mImpl.Sub (aRegion.mImpl, ToRect (aRect));
+    return This();
+  }
+  Derived& Sub (const Rect& aRect, const Derived& aRegion)
+  {
+    return Sub (Derived (aRect), aRegion);
+  }
+  Derived& Sub (const Rect& aRect1, const Rect& aRect2)
+  {
+    mImpl = ToRect (aRect1);
+    return Sub (This(), aRect2);
+  }
+
+
+
+
+
+
+  bool Contains (int aX, int aY) const
+  {
+    return mImpl.Contains(aX, aY);
+  }
+  bool Contains (const Rect& aRect) const
+  {
+    return mImpl.Contains (ToRect (aRect));
+  }
+  bool Contains (const Derived& aRgn) const
+  {
+    return mImpl.Contains (aRgn.mImpl);
+  }
+  bool Intersects (const Rect& aRect) const
+  {
+    return mImpl.Intersects (ToRect (aRect));
+  }
+
+  void MoveBy (int32_t aXOffset, int32_t aYOffset)
+  {
+    MoveBy (Point (aXOffset, aYOffset));
+  }
+  void MoveBy (Point aPt)
+  {
+    mImpl.MoveBy (aPt.x, aPt.y);
+  }
+  Derived MovedBy(int32_t aXOffset, int32_t aYOffset) const
+  {
+    return MovedBy(Point(aXOffset, aYOffset));
+  }
+  Derived MovedBy(const Point& aPt) const
+  {
+    Derived copy(This());
+    copy.MoveBy(aPt);
+    return copy;
+  }
+
+  Derived Intersect(const Derived& aOther) const
+  {
+    Derived intersection;
+    intersection.And(This(), aOther);
+    return intersection;
+  }
+
+  void Inflate(const Margin& aMargin)
+  {
+    mImpl.Inflate(nsMargin(aMargin.top, aMargin.right, aMargin.bottom, aMargin.left));
+  }
+  Derived Inflated(const Margin& aMargin) const
+  {
+    Derived copy(This());
+    copy.Inflate(aMargin);
+    return copy;
+  }
+
+  void SetEmpty ()
+  {
+    mImpl.SetEmpty ();
+  }
+
+  bool IsEmpty () const { return mImpl.IsEmpty (); }
+  bool IsComplex () const { return mImpl.IsComplex (); }
+  bool IsEqual (const Derived& aRegion) const
+  {
+    return mImpl.IsEqual (aRegion.mImpl);
+  }
+  uint32_t GetNumRects () const { return mImpl.GetNumRects (); }
+  Rect GetBounds () const { return FromRect (mImpl.GetBounds ()); }
+  uint64_t Area () const { return mImpl.Area(); }
+  nsRegion ToAppUnits (nscoord aAppUnitsPerPixel) const
+  {
+    nsRegion result;
+    for (auto iter = RectIter(); !iter.Done(); iter.Next()) {
+      nsRect appRect = ::ToAppUnits(iter.Get(), aAppUnitsPerPixel);
+      result.Or(result, appRect);
+    }
+    return result;
+  }
+  Rect GetLargestRectangle (const Rect& aContainingRect = Rect()) const
+  {
+    return FromRect (mImpl.GetLargestRectangle( ToRect(aContainingRect) ));
+  }
+
+  Derived& ScaleRoundOut (float aXScale, float aYScale)
+  {
+    mImpl.ScaleRoundOut(aXScale, aYScale);
+    return This();
+  }
+
+  Derived& ScaleInverseRoundOut (float aXScale, float aYScale)
+  {
+    mImpl.ScaleInverseRoundOut(aXScale, aYScale);
+    return This();
+  }
+
+
+
+
+
+  Derived& Transform (const mozilla::gfx::Matrix4x4 &aTransform)
+  {
+    mImpl.Transform(aTransform);
+    return This();
+  }
+
+
+
+
+
+
+
+  void SimplifyOutward (uint32_t aMaxRects)
+  {
+    mImpl.SimplifyOutward (aMaxRects);
+  }
+  void SimplifyOutwardByArea (uint32_t aThreshold)
+  {
+    mImpl.SimplifyOutwardByArea (aThreshold);
+  }
+
+
+
+
+
+  void SimplifyInward (uint32_t aMaxRects)
+  {
+    mImpl.SimplifyInward (aMaxRects);
+  }
+
+  typedef void (*visitFn)(void *closure, VisitSide side, int x1, int y1, int x2, int y2);
+  void VisitEdges (visitFn visit, void *closure)
+  {
+    mImpl.VisitEdges (visit, closure);
+  }
+
+  nsCString ToString() const { return mImpl.ToString(); }
+
+  class RectIterator
+  {
+    nsRegion::RectIterator mImpl;
+    mutable Rect mTmp;
+
+  public:
+    explicit RectIterator(const BaseIntRegion& aRegion)
+      : mImpl(aRegion.mImpl)
+    {}
+
+    bool Done() const { return mImpl.Done(); }
+
+    const Rect& Get() const
+    {
+      mTmp = FromRect(mImpl.Get());
+      return mTmp;
+    }
+
+    void Next() { mImpl.Next(); }
+  };
+
+  RectIterator RectIter() const { return RectIterator(*this); }
+
+protected:
+
+
+  explicit BaseIntRegion(const nsRegion& aImpl) : mImpl(aImpl) {}
+  const nsRegion& Impl() const { return mImpl; }
+private:
+  nsRegion mImpl;
+
+  static nsRect ToRect(const Rect& aRect)
+  {
+    return nsRect (aRect.x, aRect.y, aRect.width, aRect.height);
+  }
+  static Rect FromRect(const nsRect& aRect)
+  {
+    return Rect (aRect.x, aRect.y, aRect.width, aRect.height);
+  }
+
+  Derived& This()
+  {
+    return *static_cast<Derived*>(this);
+  }
+  const Derived& This() const
+  {
+    return *static_cast<const Derived*>(this);
+  }
+};
+
+template <class units>
+class IntRegionTyped :
+    public BaseIntRegion<IntRegionTyped<units>, IntRectTyped<units>, IntPointTyped<units>, IntMarginTyped<units>>
+{
+  typedef BaseIntRegion<IntRegionTyped<units>, IntRectTyped<units>, IntPointTyped<units>, IntMarginTyped<units>> Super;
+
+
+  template <typename OtherUnits>
+  friend class IntRegionTyped;
+
+  static_assert(IsPixel<units>::value, "'units' must be a coordinate system tag");
+
+public:
+  typedef IntRectTyped<units> RectType;
+  typedef IntPointTyped<units> PointType;
+  typedef IntMarginTyped<units> MarginType;
+
+
+  IntRegionTyped() {}
+               IntRegionTyped(const IntRectTyped<units>& aRect) : Super(aRect) {}
+  IntRegionTyped(const IntRegionTyped& aRegion) : Super(aRegion) {}
+  explicit IntRegionTyped(mozilla::gfx::ArrayView<pixman_box32_t> aRects) : Super(aRects) {}
+  IntRegionTyped(IntRegionTyped&& aRegion) : Super(mozilla::Move(aRegion)) {}
+
+
+
+  IntRegionTyped& operator=(const IntRegionTyped& aRegion)
+  {
+    return Super::operator=(aRegion);
+  }
+  IntRegionTyped& operator=(IntRegionTyped&& aRegion)
+  {
+    return Super::operator=(mozilla::Move(aRegion));
+  }
+
+  static IntRegionTyped FromUnknownRegion(const IntRegion& aRegion)
+  {
+    return IntRegionTyped(aRegion.Impl());
+  }
+  IntRegion ToUnknownRegion() const
+  {
+
+    return IntRegion(this->Impl());
+  }
+private:
+
+  explicit IntRegionTyped(const nsRegion& aRegion) : Super(aRegion) {}
+};
+
+}
+}
+
+typedef mozilla::gfx::IntRegion nsIntRegion;
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AppUnits.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AppUnits.h"
+namespace mozilla {
+inline int32_t AppUnitsPerCSSPixel() { return 60; }
+inline int32_t AppUnitsPerCSSInch() { return 96 * AppUnitsPerCSSPixel(); }
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
+
+
+namespace mozilla {
+
+template <typename T>
+struct IsPixel : FalseType {};
+
+
+struct CSSPixel;
+struct LayoutDevicePixel;
+struct LayerPixel;
+struct CSSTransformedLayerPixel;
+struct RenderTargetPixel;
+struct ScreenPixel;
+struct ParentLayerPixel;
+struct DesktopPixel;
+
+template<> struct IsPixel<CSSPixel> : TrueType {};
+template<> struct IsPixel<LayoutDevicePixel> : TrueType {};
+template<> struct IsPixel<LayerPixel> : TrueType {};
+template<> struct IsPixel<CSSTransformedLayerPixel> : TrueType {};
+template<> struct IsPixel<RenderTargetPixel> : TrueType {};
+template<> struct IsPixel<ScreenPixel> : TrueType {};
+template<> struct IsPixel<ParentLayerPixel> : TrueType {};
+template<> struct IsPixel<DesktopPixel> : TrueType {};
+
+typedef gfx::CoordTyped<CSSPixel> CSSCoord;
+typedef gfx::IntCoordTyped<CSSPixel> CSSIntCoord;
+typedef gfx::PointTyped<CSSPixel> CSSPoint;
+typedef gfx::IntPointTyped<CSSPixel> CSSIntPoint;
+typedef gfx::SizeTyped<CSSPixel> CSSSize;
+typedef gfx::IntSizeTyped<CSSPixel> CSSIntSize;
+typedef gfx::RectTyped<CSSPixel> CSSRect;
+typedef gfx::IntRectTyped<CSSPixel> CSSIntRect;
+typedef gfx::MarginTyped<CSSPixel> CSSMargin;
+typedef gfx::IntMarginTyped<CSSPixel> CSSIntMargin;
+typedef gfx::IntRegionTyped<CSSPixel> CSSIntRegion;
+
+typedef gfx::CoordTyped<LayoutDevicePixel> LayoutDeviceCoord;
+typedef gfx::IntCoordTyped<LayoutDevicePixel> LayoutDeviceIntCoord;
+typedef gfx::PointTyped<LayoutDevicePixel> LayoutDevicePoint;
+typedef gfx::IntPointTyped<LayoutDevicePixel> LayoutDeviceIntPoint;
+typedef gfx::SizeTyped<LayoutDevicePixel> LayoutDeviceSize;
+typedef gfx::IntSizeTyped<LayoutDevicePixel> LayoutDeviceIntSize;
+typedef gfx::RectTyped<LayoutDevicePixel> LayoutDeviceRect;
+typedef gfx::IntRectTyped<LayoutDevicePixel> LayoutDeviceIntRect;
+typedef gfx::MarginTyped<LayoutDevicePixel> LayoutDeviceMargin;
+typedef gfx::IntMarginTyped<LayoutDevicePixel> LayoutDeviceIntMargin;
+typedef gfx::IntRegionTyped<LayoutDevicePixel> LayoutDeviceIntRegion;
+
+typedef gfx::CoordTyped<LayerPixel> LayerCoord;
+typedef gfx::IntCoordTyped<LayerPixel> LayerIntCoord;
+typedef gfx::PointTyped<LayerPixel> LayerPoint;
+typedef gfx::IntPointTyped<LayerPixel> LayerIntPoint;
+typedef gfx::SizeTyped<LayerPixel> LayerSize;
+typedef gfx::IntSizeTyped<LayerPixel> LayerIntSize;
+typedef gfx::RectTyped<LayerPixel> LayerRect;
+typedef gfx::IntRectTyped<LayerPixel> LayerIntRect;
+typedef gfx::MarginTyped<LayerPixel> LayerMargin;
+typedef gfx::IntMarginTyped<LayerPixel> LayerIntMargin;
+typedef gfx::IntRegionTyped<LayerPixel> LayerIntRegion;
+
+typedef gfx::CoordTyped<CSSTransformedLayerPixel> CSSTransformedLayerCoord;
+typedef gfx::IntCoordTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntCoord;
+typedef gfx::PointTyped<CSSTransformedLayerPixel> CSSTransformedLayerPoint;
+typedef gfx::IntPointTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntPoint;
+typedef gfx::SizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerSize;
+typedef gfx::IntSizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntSize;
+typedef gfx::RectTyped<CSSTransformedLayerPixel> CSSTransformedLayerRect;
+typedef gfx::IntRectTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntRect;
+typedef gfx::MarginTyped<CSSTransformedLayerPixel> CSSTransformedLayerMargin;
+typedef gfx::IntMarginTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntMargin;
+typedef gfx::IntRegionTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntRegion;
+
+typedef gfx::PointTyped<RenderTargetPixel> RenderTargetPoint;
+typedef gfx::IntPointTyped<RenderTargetPixel> RenderTargetIntPoint;
+typedef gfx::SizeTyped<RenderTargetPixel> RenderTargetSize;
+typedef gfx::IntSizeTyped<RenderTargetPixel> RenderTargetIntSize;
+typedef gfx::RectTyped<RenderTargetPixel> RenderTargetRect;
+typedef gfx::IntRectTyped<RenderTargetPixel> RenderTargetIntRect;
+typedef gfx::MarginTyped<RenderTargetPixel> RenderTargetMargin;
+typedef gfx::IntMarginTyped<RenderTargetPixel> RenderTargetIntMargin;
+typedef gfx::IntRegionTyped<RenderTargetPixel> RenderTargetIntRegion;
+
+typedef gfx::CoordTyped<ScreenPixel> ScreenCoord;
+typedef gfx::IntCoordTyped<ScreenPixel> ScreenIntCoord;
+typedef gfx::PointTyped<ScreenPixel> ScreenPoint;
+typedef gfx::IntPointTyped<ScreenPixel> ScreenIntPoint;
+typedef gfx::SizeTyped<ScreenPixel> ScreenSize;
+typedef gfx::IntSizeTyped<ScreenPixel> ScreenIntSize;
+typedef gfx::RectTyped<ScreenPixel> ScreenRect;
+typedef gfx::IntRectTyped<ScreenPixel> ScreenIntRect;
+typedef gfx::MarginTyped<ScreenPixel> ScreenMargin;
+typedef gfx::IntMarginTyped<ScreenPixel> ScreenIntMargin;
+typedef gfx::IntRegionTyped<ScreenPixel> ScreenIntRegion;
+
+typedef gfx::CoordTyped<ParentLayerPixel> ParentLayerCoord;
+typedef gfx::IntCoordTyped<ParentLayerPixel> ParentLayerIntCoord;
+typedef gfx::PointTyped<ParentLayerPixel> ParentLayerPoint;
+typedef gfx::IntPointTyped<ParentLayerPixel> ParentLayerIntPoint;
+typedef gfx::SizeTyped<ParentLayerPixel> ParentLayerSize;
+typedef gfx::IntSizeTyped<ParentLayerPixel> ParentLayerIntSize;
+typedef gfx::RectTyped<ParentLayerPixel> ParentLayerRect;
+typedef gfx::IntRectTyped<ParentLayerPixel> ParentLayerIntRect;
+typedef gfx::MarginTyped<ParentLayerPixel> ParentLayerMargin;
+typedef gfx::IntMarginTyped<ParentLayerPixel> ParentLayerIntMargin;
+typedef gfx::IntRegionTyped<ParentLayerPixel> ParentLayerIntRegion;
+
+typedef gfx::CoordTyped<DesktopPixel> DesktopCoord;
+typedef gfx::IntCoordTyped<DesktopPixel> DesktopIntCoord;
+typedef gfx::PointTyped<DesktopPixel> DesktopPoint;
+typedef gfx::IntPointTyped<DesktopPixel> DesktopIntPoint;
+typedef gfx::SizeTyped<DesktopPixel> DesktopSize;
+typedef gfx::IntSizeTyped<DesktopPixel> DesktopIntSize;
+typedef gfx::RectTyped<DesktopPixel> DesktopRect;
+typedef gfx::IntRectTyped<DesktopPixel> DesktopIntRect;
+
+typedef gfx::ScaleFactor<CSSPixel, LayoutDevicePixel> CSSToLayoutDeviceScale;
+typedef gfx::ScaleFactor<CSSPixel, LayerPixel> CSSToLayerScale;
+typedef gfx::ScaleFactor<CSSPixel, ScreenPixel> CSSToScreenScale;
+typedef gfx::ScaleFactor<CSSPixel, ParentLayerPixel> CSSToParentLayerScale;
+typedef gfx::ScaleFactor<LayoutDevicePixel, CSSPixel> LayoutDeviceToCSSScale;
+typedef gfx::ScaleFactor<LayoutDevicePixel, LayerPixel> LayoutDeviceToLayerScale;
+typedef gfx::ScaleFactor<LayoutDevicePixel, ScreenPixel> LayoutDeviceToScreenScale;
+typedef gfx::ScaleFactor<LayoutDevicePixel, ParentLayerPixel> LayoutDeviceToParentLayerScale;
+typedef gfx::ScaleFactor<LayerPixel, CSSPixel> LayerToCSSScale;
+typedef gfx::ScaleFactor<LayerPixel, LayoutDevicePixel> LayerToLayoutDeviceScale;
+typedef gfx::ScaleFactor<LayerPixel, RenderTargetPixel> LayerToRenderTargetScale;
+typedef gfx::ScaleFactor<LayerPixel, ScreenPixel> LayerToScreenScale;
+typedef gfx::ScaleFactor<LayerPixel, ParentLayerPixel> LayerToParentLayerScale;
+typedef gfx::ScaleFactor<RenderTargetPixel, ScreenPixel> RenderTargetToScreenScale;
+typedef gfx::ScaleFactor<ScreenPixel, CSSPixel> ScreenToCSSScale;
+typedef gfx::ScaleFactor<ScreenPixel, LayoutDevicePixel> ScreenToLayoutDeviceScale;
+typedef gfx::ScaleFactor<ScreenPixel, LayerPixel> ScreenToLayerScale;
+typedef gfx::ScaleFactor<ScreenPixel, ParentLayerPixel> ScreenToParentLayerScale;
+typedef gfx::ScaleFactor<ParentLayerPixel, LayerPixel> ParentLayerToLayerScale;
+typedef gfx::ScaleFactor<ParentLayerPixel, ScreenPixel> ParentLayerToScreenScale;
+typedef gfx::ScaleFactor<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerScale;
+typedef gfx::ScaleFactor<DesktopPixel, LayoutDevicePixel> DesktopToLayoutDeviceScale;
+
+typedef gfx::ScaleFactors2D<CSSPixel, LayoutDevicePixel> CSSToLayoutDeviceScale2D;
+typedef gfx::ScaleFactors2D<CSSPixel, LayerPixel> CSSToLayerScale2D;
+typedef gfx::ScaleFactors2D<CSSPixel, ScreenPixel> CSSToScreenScale2D;
+typedef gfx::ScaleFactors2D<CSSPixel, ParentLayerPixel> CSSToParentLayerScale2D;
+typedef gfx::ScaleFactors2D<LayoutDevicePixel, CSSPixel> LayoutDeviceToCSSScale2D;
+typedef gfx::ScaleFactors2D<LayoutDevicePixel, LayerPixel> LayoutDeviceToLayerScale2D;
+typedef gfx::ScaleFactors2D<LayoutDevicePixel, ScreenPixel> LayoutDeviceToScreenScale2D;
+typedef gfx::ScaleFactors2D<LayoutDevicePixel, ParentLayerPixel> LayoutDeviceToParentLayerScale2D;
+typedef gfx::ScaleFactors2D<LayerPixel, CSSPixel> LayerToCSSScale2D;
+typedef gfx::ScaleFactors2D<LayerPixel, LayoutDevicePixel> LayerToLayoutDeviceScale2D;
+typedef gfx::ScaleFactors2D<LayerPixel, RenderTargetPixel> LayerToRenderTargetScale2D;
+typedef gfx::ScaleFactors2D<LayerPixel, ScreenPixel> LayerToScreenScale2D;
+typedef gfx::ScaleFactors2D<LayerPixel, ParentLayerPixel> LayerToParentLayerScale2D;
+typedef gfx::ScaleFactors2D<RenderTargetPixel, ScreenPixel> RenderTargetToScreenScale2D;
+typedef gfx::ScaleFactors2D<ScreenPixel, CSSPixel> ScreenToCSSScale2D;
+typedef gfx::ScaleFactors2D<ScreenPixel, LayoutDevicePixel> ScreenToLayoutDeviceScale2D;
+typedef gfx::ScaleFactors2D<ScreenPixel, LayerPixel> ScreenToLayerScale2D;
+typedef gfx::ScaleFactors2D<ScreenPixel, ParentLayerPixel> ScreenToParentLayerScale2D;
+typedef gfx::ScaleFactors2D<ParentLayerPixel, LayerPixel> ParentLayerToLayerScale2D;
+typedef gfx::ScaleFactors2D<ParentLayerPixel, ScreenPixel> ParentLayerToScreenScale2D;
+typedef gfx::ScaleFactors2D<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerScale2D;
+
+typedef gfx::Matrix4x4Typed<LayoutDevicePixel, LayoutDevicePixel> LayoutDeviceToLayoutDeviceMatrix4x4;
+typedef gfx::Matrix4x4Typed<LayerPixel, ParentLayerPixel> LayerToParentLayerMatrix4x4;
+typedef gfx::Matrix4x4Typed<ScreenPixel, ScreenPixel> ScreenToScreenMatrix4x4;
+typedef gfx::Matrix4x4Typed<ScreenPixel, ParentLayerPixel> ScreenToParentLayerMatrix4x4;
+typedef gfx::Matrix4x4Typed<ParentLayerPixel, LayerPixel> ParentLayerToLayerMatrix4x4;
+typedef gfx::Matrix4x4Typed<ParentLayerPixel, ScreenPixel> ParentLayerToScreenMatrix4x4;
+typedef gfx::Matrix4x4Typed<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerMatrix4x4;
+
+
+
+
+struct CSSPixel {
+
+
+
+  static CSSCoord FromAppUnits(nscoord aCoord) {
+    return NSAppUnitsToFloatPixels(aCoord, float(AppUnitsPerCSSPixel()));
+  }
+
+  static CSSPoint FromAppUnits(const nsPoint& aPoint) {
+    return CSSPoint(NSAppUnitsToFloatPixels(aPoint.x, float(AppUnitsPerCSSPixel())),
+                    NSAppUnitsToFloatPixels(aPoint.y, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSSize FromAppUnits(const nsSize& aSize) {
+    return CSSSize(NSAppUnitsToFloatPixels(aSize.width, float(AppUnitsPerCSSPixel())),
+                   NSAppUnitsToFloatPixels(aSize.height, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSRect FromAppUnits(const nsRect& aRect) {
+    return CSSRect(NSAppUnitsToFloatPixels(aRect.x, float(AppUnitsPerCSSPixel())),
+                   NSAppUnitsToFloatPixels(aRect.y, float(AppUnitsPerCSSPixel())),
+                   NSAppUnitsToFloatPixels(aRect.width, float(AppUnitsPerCSSPixel())),
+                   NSAppUnitsToFloatPixels(aRect.height, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSMargin FromAppUnits(const nsMargin& aMargin) {
+    return CSSMargin(NSAppUnitsToFloatPixels(aMargin.top, float(AppUnitsPerCSSPixel())),
+                     NSAppUnitsToFloatPixels(aMargin.right, float(AppUnitsPerCSSPixel())),
+                     NSAppUnitsToFloatPixels(aMargin.bottom, float(AppUnitsPerCSSPixel())),
+                     NSAppUnitsToFloatPixels(aMargin.left, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSIntPoint FromAppUnitsRounded(const nsPoint& aPoint) {
+    return CSSIntPoint(NSAppUnitsToIntPixels(aPoint.x, float(AppUnitsPerCSSPixel())),
+                       NSAppUnitsToIntPixels(aPoint.y, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSIntSize FromAppUnitsRounded(const nsSize& aSize)
+  {
+    return CSSIntSize(NSAppUnitsToIntPixels(aSize.width, float(AppUnitsPerCSSPixel())),
+                      NSAppUnitsToIntPixels(aSize.height, float(AppUnitsPerCSSPixel())));
+  }
+
+  static CSSIntRect FromAppUnitsRounded(const nsRect& aRect) {
+    return CSSIntRect(NSAppUnitsToIntPixels(aRect.x, float(AppUnitsPerCSSPixel())),
+                      NSAppUnitsToIntPixels(aRect.y, float(AppUnitsPerCSSPixel())),
+                      NSAppUnitsToIntPixels(aRect.width, float(AppUnitsPerCSSPixel())),
+                      NSAppUnitsToIntPixels(aRect.height, float(AppUnitsPerCSSPixel())));
+  }
+
+
+
+  static nscoord ToAppUnits(CSSCoord aCoord) {
+    return NSToCoordRoundWithClamp(aCoord * float(AppUnitsPerCSSPixel()));
+  }
+
+  static nsPoint ToAppUnits(const CSSPoint& aPoint) {
+    return nsPoint(NSToCoordRoundWithClamp(aPoint.x * float(AppUnitsPerCSSPixel())),
+                   NSToCoordRoundWithClamp(aPoint.y * float(AppUnitsPerCSSPixel())));
+  }
+
+  static nsPoint ToAppUnits(const CSSIntPoint& aPoint) {
+    return nsPoint(NSToCoordRoundWithClamp(float(aPoint.x) * float(AppUnitsPerCSSPixel())),
+                   NSToCoordRoundWithClamp(float(aPoint.y) * float(AppUnitsPerCSSPixel())));
+  }
+
+  static nsSize ToAppUnits(const CSSSize& aSize) {
+    return nsSize(NSToCoordRoundWithClamp(aSize.width * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(aSize.height * float(AppUnitsPerCSSPixel())));
+  }
+
+  static nsSize ToAppUnits(const CSSIntSize& aSize) {
+    return nsSize(NSToCoordRoundWithClamp(float(aSize.width) * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(float(aSize.height) * float(AppUnitsPerCSSPixel())));
+  }
+
+  static nsRect ToAppUnits(const CSSRect& aRect) {
+    return nsRect(NSToCoordRoundWithClamp(aRect.x * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(aRect.y * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(aRect.width * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(aRect.height * float(AppUnitsPerCSSPixel())));
+  }
+
+  static nsRect ToAppUnits(const CSSIntRect& aRect) {
+    return nsRect(NSToCoordRoundWithClamp(float(aRect.x) * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(float(aRect.y) * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(float(aRect.width) * float(AppUnitsPerCSSPixel())),
+                  NSToCoordRoundWithClamp(float(aRect.height) * float(AppUnitsPerCSSPixel())));
+  }
+};
+# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct LayoutDevicePixel {
+  static LayoutDeviceRect FromAppUnits(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceRect(NSAppUnitsToFloatPixels(aRect.x, float(aAppUnitsPerDevPixel)),
+                            NSAppUnitsToFloatPixels(aRect.y, float(aAppUnitsPerDevPixel)),
+                            NSAppUnitsToFloatPixels(aRect.width, float(aAppUnitsPerDevPixel)),
+                            NSAppUnitsToFloatPixels(aRect.height, float(aAppUnitsPerDevPixel)));
+  }
+
+  static LayoutDevicePoint FromAppUnits(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDevicePoint(NSAppUnitsToFloatPixels(aPoint.x, aAppUnitsPerDevPixel),
+                             NSAppUnitsToFloatPixels(aPoint.y, aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceMargin FromAppUnits(const nsMargin& aMargin, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceMargin(NSAppUnitsToFloatPixels(aMargin.top, aAppUnitsPerDevPixel),
+                              NSAppUnitsToFloatPixels(aMargin.right, aAppUnitsPerDevPixel),
+                              NSAppUnitsToFloatPixels(aMargin.bottom, aAppUnitsPerDevPixel),
+                              NSAppUnitsToFloatPixels(aMargin.left, aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntPoint FromAppUnitsRounded(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntPoint(NSAppUnitsToIntPixels(aPoint.x, aAppUnitsPerDevPixel),
+                                NSAppUnitsToIntPixels(aPoint.y, aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntPoint FromAppUnitsToNearest(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntPoint::FromUnknownPoint(aPoint.ToNearestPixels(aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntRect FromAppUnitsToNearest(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToNearestPixels(aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntRect FromAppUnitsToInside(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToInsidePixels(aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntRect FromAppUnitsToOutside(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToOutsidePixels(aAppUnitsPerDevPixel));
+  }
+
+  static LayoutDeviceIntSize FromAppUnitsRounded(const nsSize& aSize, nscoord aAppUnitsPerDevPixel) {
+    return LayoutDeviceIntSize(
+      NSAppUnitsToIntPixels(aSize.width, aAppUnitsPerDevPixel),
+      NSAppUnitsToIntPixels(aSize.height, aAppUnitsPerDevPixel));
+  }
+
+  static nsPoint ToAppUnits(const LayoutDeviceIntPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
+    return nsPoint(aPoint.x * aAppUnitsPerDevPixel,
+                   aPoint.y * aAppUnitsPerDevPixel);
+  }
+
+  static nsSize ToAppUnits(const LayoutDeviceIntSize& aSize, nscoord aAppUnitsPerDevPixel) {
+    return nsSize(aSize.width * aAppUnitsPerDevPixel,
+                  aSize.height * aAppUnitsPerDevPixel);
+  }
+
+  static nsSize ToAppUnits(const LayoutDeviceSize& aSize, nscoord aAppUnitsPerDevPixel) {
+    return nsSize(NSFloatPixelsToAppUnits(aSize.width, aAppUnitsPerDevPixel),
+                  NSFloatPixelsToAppUnits(aSize.height, aAppUnitsPerDevPixel));
+  }
+
+  static nsRect ToAppUnits(const LayoutDeviceIntRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return nsRect(aRect.x * aAppUnitsPerDevPixel,
+                  aRect.y * aAppUnitsPerDevPixel,
+                  aRect.width * aAppUnitsPerDevPixel,
+                  aRect.height * aAppUnitsPerDevPixel);
+  }
+
+  static nsRect ToAppUnits(const LayoutDeviceRect& aRect, nscoord aAppUnitsPerDevPixel) {
+    return nsRect(NSFloatPixelsToAppUnits(aRect.x, aAppUnitsPerDevPixel),
+                  NSFloatPixelsToAppUnits(aRect.y, aAppUnitsPerDevPixel),
+                  NSFloatPixelsToAppUnits(aRect.width, aAppUnitsPerDevPixel),
+                  NSFloatPixelsToAppUnits(aRect.height, aAppUnitsPerDevPixel));
+  }
+};
+# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct LayerPixel {
+};
+
+
+
+
+
+
+
+struct CSSTransformedLayerPixel {
+
+};
+# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct RenderTargetPixel {
+};
+# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct ScreenPixel {
+};
+# 425 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct ParentLayerPixel {
+};
+# 442 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
+struct DesktopPixel {
+};
+
+
+
+template<class src, class dst>
+gfx::CoordTyped<dst> operator*(const gfx::CoordTyped<src>& aCoord, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::CoordTyped<dst>(aCoord.value * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::CoordTyped<dst> operator/(const gfx::CoordTyped<src>& aCoord, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::CoordTyped<dst>(aCoord.value / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator*(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::PointTyped<dst>(aPoint.x * aScale.scale,
+                              aPoint.y * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator/(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::PointTyped<dst>(aPoint.x / aScale.scale,
+                              aPoint.y / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator*(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::PointTyped<dst>(aPoint.x * aScale.xScale,
+                              aPoint.y * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator/(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::PointTyped<dst>(aPoint.x / aScale.xScale,
+                              aPoint.y / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator*(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::PointTyped<dst>(float(aPoint.x) * aScale.scale,
+                              float(aPoint.y) * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator/(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::PointTyped<dst>(float(aPoint.x) / aScale.scale,
+                              float(aPoint.y) / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator*(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::PointTyped<dst>(float(aPoint.x) * aScale.xScale,
+                              float(aPoint.y) * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::PointTyped<dst> operator/(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::PointTyped<dst>(float(aPoint.x) / aScale.xScale,
+                              float(aPoint.y) / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator*(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::RectTyped<dst>(aRect.x * aScale.scale,
+                             aRect.y * aScale.scale,
+                             aRect.width * aScale.scale,
+                             aRect.height * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator/(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::RectTyped<dst>(aRect.x / aScale.scale,
+                             aRect.y / aScale.scale,
+                             aRect.width / aScale.scale,
+                             aRect.height / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator*(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::RectTyped<dst>(aRect.x * aScale.xScale,
+                             aRect.y * aScale.yScale,
+                             aRect.width * aScale.xScale,
+                             aRect.height * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator/(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::RectTyped<dst>(aRect.x / aScale.xScale,
+                             aRect.y / aScale.yScale,
+                             aRect.width / aScale.xScale,
+                             aRect.height / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator*(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::RectTyped<dst>(float(aRect.x) * aScale.scale,
+                             float(aRect.y) * aScale.scale,
+                             float(aRect.width) * aScale.scale,
+                             float(aRect.height) * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator/(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::RectTyped<dst>(float(aRect.x) / aScale.scale,
+                             float(aRect.y) / aScale.scale,
+                             float(aRect.width) / aScale.scale,
+                             float(aRect.height) / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator*(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::RectTyped<dst>(float(aRect.x) * aScale.xScale,
+                             float(aRect.y) * aScale.yScale,
+                             float(aRect.width) * aScale.xScale,
+                             float(aRect.height) * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::RectTyped<dst> operator/(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::RectTyped<dst>(float(aRect.x) / aScale.xScale,
+                             float(aRect.y) / aScale.yScale,
+                             float(aRect.width) / aScale.xScale,
+                             float(aRect.height) / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator*(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::SizeTyped<dst>(aSize.width * aScale.scale,
+                             aSize.height * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator/(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::SizeTyped<dst>(aSize.width / aScale.scale,
+                              aSize.height / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator*(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::SizeTyped<dst>(aSize.width * aScale.xScale,
+                             aSize.height * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator/(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::SizeTyped<dst>(aSize.width / aScale.xScale,
+                             aSize.height / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator*(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::SizeTyped<dst>(float(aSize.width) * aScale.scale,
+                             float(aSize.height) * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator/(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::SizeTyped<dst>(float(aSize.width) / aScale.scale,
+                             float(aSize.height) / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator*(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::SizeTyped<dst>(float(aSize.width) * aScale.xScale,
+                             float(aSize.height) * aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::SizeTyped<dst> operator/(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::SizeTyped<dst>(float(aSize.width) / aScale.xScale,
+                             float(aSize.height) / aScale.yScale);
+}
+
+template<class src, class dst>
+gfx::MarginTyped<dst> operator*(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactor<src, dst>& aScale) {
+  return gfx::MarginTyped<dst>(aMargin.top * aScale.scale,
+                               aMargin.right * aScale.scale,
+                               aMargin.bottom * aScale.scale,
+                               aMargin.left * aScale.scale);
+}
+
+template<class src, class dst>
+gfx::MarginTyped<dst> operator/(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactor<dst, src>& aScale) {
+  return gfx::MarginTyped<dst>(aMargin.top / aScale.scale,
+                               aMargin.right / aScale.scale,
+                               aMargin.bottom / aScale.scale,
+                               aMargin.left / aScale.scale);
+}
+
+template<class src, class dst>
+gfx::MarginTyped<dst> operator*(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactors2D<src, dst>& aScale) {
+  return gfx::MarginTyped<dst>(aMargin.top * aScale.yScale,
+                               aMargin.right * aScale.xScale,
+                               aMargin.bottom * aScale.yScale,
+                               aMargin.left * aScale.xScale);
+}
+
+template<class src, class dst>
+gfx::MarginTyped<dst> operator/(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactors2D<dst, src>& aScale) {
+  return gfx::MarginTyped<dst>(aMargin.top / aScale.yScale,
+                               aMargin.right / aScale.xScale,
+                               aMargin.bottom / aScale.yScale,
+                               aMargin.left / aScale.xScale);
+}
+
+
+
+
+template<class src, class dst>
+gfx::ScaleFactor<src, dst> MaxScaleRatio(const gfx::SizeTyped<dst>& aDestSize, const gfx::SizeTyped<src>& aSrcSize) {
+  return gfx::ScaleFactor<src, dst>(std::max(aDestSize.width / aSrcSize.width,
+                                             aDestSize.height / aSrcSize.height));
+}
+
+template<class src, class dst>
+gfx::ScaleFactor<src, dst> MinScaleRatio(const gfx::SizeTyped<dst>& aDestSize, const gfx::SizeTyped<src>& aSrcSize) {
+  return gfx::ScaleFactor<src, dst>(std::min(aDestSize.width / aSrcSize.width,
+                                             aDestSize.height / aSrcSize.height));
+}
+
+}
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
+
+
+
+
+
+class nsDocShell;
+class nsIDocument;
+class nsIFrame;
+class nsPresContext;
+class nsViewManager;
+class nsView;
+class nsRenderingContext;
+class nsIPageSequenceFrame;
+class nsCanvasFrame;
+class nsAString;
+class nsCaret;
+namespace mozilla {
+class AccessibleCaretEventHub;
+class CSSStyleSheet;
+}
+class nsFrameSelection;
+class nsFrameManager;
+class nsILayoutHistoryState;
+class nsIReflowCallback;
+class nsIDOMNode;
+class nsCSSFrameConstructor;
+class nsISelection;
+template<class E> class nsCOMArray;
+class AutoWeakFrame;
+class WeakFrame;
+class nsIScrollableFrame;
+class gfxContext;
+class nsIDOMEvent;
+class nsDisplayList;
+class nsDisplayListBuilder;
+class nsPIDOMWindowOuter;
+struct nsPoint;
+class nsINode;
+struct nsRect;
+class nsRegion;
+class nsRefreshDriver;
+class nsARefreshObserver;
+class nsAPostRefreshObserver;
+
+class nsAccessibilityService;
+namespace mozilla {
+namespace a11y {
+class DocAccessible;
+}
+}
+
+struct nsArenaMemoryStats;
+class nsITimer;
+
+namespace mozilla {
+class EventStates;
+
+namespace dom {
+class Element;
+class Touch;
+class Selection;
+class ShadowRoot;
+}
+
+namespace layers {
+class LayerManager;
+}
+
+namespace gfx {
+class SourceSurface;
+}
+}
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+typedef struct CapturingContentInfo {
+
+  bool mAllowed;
+  bool mPointerLock;
+  bool mRetargetToElement;
+  bool mPreventDrag;
+  mozilla::StaticRefPtr<nsIContent> mContent;
+} CapturingContentInfo;
+# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+enum nsRectVisibility {
+  nsRectVisibility_kVisible,
+  nsRectVisibility_kAboveViewport,
+  nsRectVisibility_kBelowViewport,
+  nsRectVisibility_kLeftOfViewport,
+  nsRectVisibility_kRightOfViewport
+};
+# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+class nsIPresShell : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+protected:
+  typedef mozilla::layers::LayerManager LayerManager;
+  typedef mozilla::gfx::SourceSurface SourceSurface;
+
+  enum eRenderFlag {
+    STATE_IGNORING_VIEWPORT_SCROLLING = 0x1,
+    STATE_DRAWWINDOW_NOT_FLUSHING = 0x2
+  };
+  typedef uint8_t RenderFlags;
+
+public:
+  nsIPresShell();
+# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual void Destroy() = 0;
+
+  bool IsDestroying() { return mIsDestroying; }
+# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  void* AllocateFrame(nsQueryFrame::FrameIID aID, size_t aSize)
+  {
+    void* result = mFrameArena.AllocateByFrameID(aID, aSize);
+    RecordAlloc(result);
+    return result;
+  }
+
+  void FreeFrame(nsQueryFrame::FrameIID aID, void* aPtr)
+  {
+    RecordFree(aPtr);
+    if (!mIsDestroying)
+      mFrameArena.FreeByFrameID(aID, aPtr);
+  }
+
+
+
+
+
+
+
+  void* AllocateByObjectID(mozilla::ArenaObjectID aID, size_t aSize)
+  {
+    void* result = mFrameArena.AllocateByObjectID(aID, aSize);
+    RecordAlloc(result);
+    return result;
+  }
+
+  void FreeByObjectID(mozilla::ArenaObjectID aID, void* aPtr)
+  {
+    RecordFree(aPtr);
+    if (!mIsDestroying)
+      mFrameArena.FreeByObjectID(aID, aPtr);
+  }
+# 261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  void* AllocateMisc(size_t aSize)
+  {
+    void* result = mFrameArena.AllocateBySize(aSize);
+    RecordAlloc(result);
+    return result;
+  }
+
+  void FreeMisc(size_t aSize, void* aPtr)
+  {
+    RecordFree(aPtr);
+    if (!mIsDestroying)
+      mFrameArena.FreeBySize(aSize, aPtr);
+  }
+
+  template<typename T>
+  void RegisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
+  {
+    mFrameArena.RegisterArenaRefPtr(aPtr);
+  }
+
+  template<typename T>
+  void DeregisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
+  {
+    mFrameArena.DeregisterArenaRefPtr(aPtr);
+  }
+
+  void ClearArenaRefPtrs(mozilla::ArenaObjectID aObjectID)
+  {
+    mFrameArena.ClearArenaRefPtrs(aObjectID);
+  }
+
+  nsIDocument* GetDocument() const { return mDocument; }
+
+  nsPresContext* GetPresContext() const { return mPresContext; }
+
+  nsViewManager* GetViewManager() const { return mViewManager; }
+
+  nsRefreshDriver* GetRefreshDriver() const;
+
+
+
+
+
+  mozilla::a11y::DocAccessible* GetDocAccessible() const
+  {
+    return mDocAccessible;
+  }
+
+
+
+
+  void SetDocAccessible(mozilla::a11y::DocAccessible* aDocAccessible)
+  {
+    mDocAccessible = aDocAccessible;
+  }
+
+
+
+  mozilla::StyleSetHandle StyleSet() const { return mStyleSet; }
+
+  nsCSSFrameConstructor* FrameConstructor() const { return mFrameConstructor; }
+
+  nsFrameManager* FrameManager() const {
+
+
+    return reinterpret_cast<nsFrameManager*>
+                           (const_cast<nsIPresShell*>(this)->mFrameManager);
+  }
+# 337 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  void SetAuthorStyleDisabled(bool aDisabled);
+  bool GetAuthorStyleDisabled() const;
+# 359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  void RestyleForCSSRuleChanges();
+
+
+
+
+
+  virtual void UpdatePreferenceStyles() = 0;
+
+
+
+
+
+
+  already_AddRefed<nsFrameSelection> FrameSelection();
+
+
+
+
+
+  const nsFrameSelection* ConstFrameSelection() const { return mSelection; }
+
+
+
+  virtual void BeginObservingDocument() = 0;
+
+
+  virtual void EndObservingDocument() = 0;
+
+
+
+
+  bool DidInitialize() const { return mDidInitialize; }
+# 403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult Initialize(nscoord aWidth, nscoord aHeight) = 0;
+
+
+
+
+
+  virtual nsresult ResizeReflow(nscoord aWidth, nscoord aHeight, nscoord aOldWidth = 0, nscoord aOldHeight = 0) = 0;
+
+
+
+
+  virtual nsresult ResizeReflowIgnoreOverride(nscoord aWidth, nscoord aHeight, nscoord aOldWidth, nscoord aOldHeight) = 0;
+
+
+
+
+  virtual bool GetIsViewportOverridden() = 0;
+
+
+
+
+  virtual bool IsLayoutFlushObserver() = 0;
+
+
+
+
+  virtual void LoadComplete() = 0;
+
+
+
+
+  virtual nsIFrame* GetRootFrameExternal() const;
+  nsIFrame* GetRootFrame() const {
+
+    return mFrameManager->GetRootFrame();
+
+
+
+  }
+
+
+
+
+  nsIFrame* GetRootScrollFrame() const;
+
+
+
+
+  nsIScrollableFrame* GetRootScrollFrameAsScrollable() const;
+
+
+
+
+
+  virtual nsIScrollableFrame* GetRootScrollFrameAsScrollableExternal() const;
+# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  enum ScrollDirection { eHorizontal, eVertical, eEither };
+  nsIScrollableFrame* GetFrameToScrollAsScrollable(ScrollDirection aDirection);
+
+
+
+
+
+  virtual nsIPageSequenceFrame* GetPageSequenceFrame() const = 0;
+
+
+
+
+
+  virtual nsCanvasFrame* GetCanvasFrame() const = 0;
+
+
+
+
+
+  virtual nsIFrame* GetPlaceholderFrameFor(nsIFrame* aFrame) const = 0;
+# 498 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  enum IntrinsicDirty {
+
+    eResize,
+    eTreeChange,
+    eStyleChange
+  };
+  enum ReflowRootHandling {
+    ePositionOrSizeChange,
+    eNoPositionOrSizeChange,
+    eInferFromBitToAdd
+
+
+
+  };
+  virtual void FrameNeedsReflow(nsIFrame *aFrame,
+                                IntrinsicDirty aIntrinsicDirty,
+                                nsFrameState aBitToAdd,
+                                ReflowRootHandling aRootHandling =
+                                  eInferFromBitToAdd) = 0;
+
+
+
+
+  virtual void MarkFixedFramesForReflow(IntrinsicDirty aIntrinsicDirty);
+# 534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual void FrameNeedsToContinueReflow(nsIFrame *aFrame) = 0;
+
+  virtual void CancelAllPendingReflows() = 0;
+
+  virtual void NotifyCounterStylesAreDirty() = 0;
+# 547 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual void DestroyFramesFor(nsIContent* aContent,
+                                nsIContent** aDestroyedFramesFor) = 0;
+
+
+
+
+
+  virtual void CreateFramesFor(nsIContent* aContent) = 0;
+
+
+
+
+  virtual nsresult RecreateFramesFor(nsIContent* aContent) = 0;
+
+  void PostRecreateFramesFor(mozilla::dom::Element* aElement);
+  void RestyleForAnimation(mozilla::dom::Element* aElement,
+                           nsRestyleHint aHint);
+
+
+
+
+  virtual void RecordShadowStyleChange(mozilla::dom::ShadowRoot* aShadowRoot) = 0;
+
+
+
+
+
+
+  virtual bool IsSafeToFlush() const = 0;
+# 592 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+public:
+  void FlushPendingNotifications(mozilla::FlushType aType)
+  {
+    if (!NeedFlush(aType)) {
+      return;
+    }
+
+    DoFlushPendingNotifications(aType);
+  }
+
+  void FlushPendingNotifications(mozilla::ChangesToFlush aType)
+  {
+    if (!NeedFlush(aType.mFlushType)) {
+      return;
+    }
+
+    DoFlushPendingNotifications(aType);
+  }
+
+protected:
+
+
+
+  virtual void DoFlushPendingNotifications(mozilla::FlushType aType) = 0;
+  virtual void DoFlushPendingNotifications(mozilla::ChangesToFlush aType) = 0;
+
+public:
+# 627 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  bool NeedFlush(mozilla::FlushType aType) const
+  {
+
+
+
+
+    do { } while (0);
+    return mNeedStyleFlush ||
+           (mNeedLayoutFlush &&
+            aType >= mozilla::FlushType::InterruptibleLayout) ||
+           aType >= mozilla::FlushType::Display ||
+           mNeedThrottledAnimationFlush ||
+           mInFlush;
+  }
+
+  inline void SetNeedStyleFlush();
+  inline void SetNeedLayoutFlush();
+  inline void SetNeedThrottledAnimationFlush();
+
+  bool ObservingStyleFlushes() const { return mObservingStyleFlushes; }
+  bool ObservingLayoutFlushes() const { return mObservingLayoutFlushes; }
+
+  void ObserveStyleFlushes()
+  {
+    if (!ObservingStyleFlushes())
+      DoObserveStyleFlushes();
+  }
+
+  bool NeedStyleFlush() const { return mNeedStyleFlush; }
+
+
+
+
+
+  virtual nsresult PostReflowCallback(nsIReflowCallback* aCallback) = 0;
+  virtual void CancelReflowCallback(nsIReflowCallback* aCallback) = 0;
+
+  virtual void ClearFrameRefs(nsIFrame* aFrame) = 0;
+
+
+
+
+
+
+  virtual already_AddRefed<gfxContext> CreateReferenceRenderingContext() = 0;
+# 682 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult GoToAnchor(const nsAString& aAnchorName, bool aScroll,
+                              uint32_t aAdditionalScrollFlags = 0) = 0;
+# 693 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult ScrollToAnchor() = 0;
+
+  enum {
+    SCROLL_TOP = 0,
+    SCROLL_BOTTOM = 100,
+    SCROLL_LEFT = 0,
+    SCROLL_RIGHT = 100,
+    SCROLL_CENTER = 50,
+    SCROLL_MINIMUM = -1
+  };
+
+  enum WhenToScroll {
+    SCROLL_ALWAYS,
+    SCROLL_IF_NOT_VISIBLE,
+    SCROLL_IF_NOT_FULLY_VISIBLE
+  };
+  typedef struct ScrollAxis {
+    int16_t mWhereToScroll;
+    WhenToScroll mWhenToScroll : 8;
+    bool mOnlyIfPerceivedScrollableDirection : 1;
+# 748 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+    explicit ScrollAxis(int16_t aWhere = SCROLL_MINIMUM,
+                        WhenToScroll aWhen = SCROLL_IF_NOT_FULLY_VISIBLE,
+                        bool aOnlyIfPerceivedScrollableDirection = false) :
+      mWhereToScroll(aWhere), mWhenToScroll(aWhen),
+      mOnlyIfPerceivedScrollableDirection(aOnlyIfPerceivedScrollableDirection)
+    {}
+  } ScrollAxis;
+# 786 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult ScrollContentIntoView(nsIContent* aContent,
+                                                     ScrollAxis aVertical,
+                                                     ScrollAxis aHorizontal,
+                                                     uint32_t aFlags) = 0;
+
+  enum {
+    SCROLL_FIRST_ANCESTOR_ONLY = 0x01,
+    SCROLL_OVERFLOW_HIDDEN = 0x02,
+    SCROLL_NO_PARENT_FRAMES = 0x04,
+    SCROLL_SMOOTH = 0x08,
+    SCROLL_SMOOTH_AUTO = 0x10
+  };
+# 817 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual bool ScrollFrameRectIntoView(nsIFrame* aFrame,
+                                       const nsRect& aRect,
+                                       ScrollAxis aVertical,
+                                       ScrollAxis aHorizontal,
+                                       uint32_t aFlags) = 0;
+# 837 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsRectVisibility GetRectVisibility(nsIFrame *aFrame,
+                                             const nsRect &aRect,
+                                             nscoord aMinTwips) const = 0;
+
+
+
+
+
+  virtual void SetIgnoreFrameDestruction(bool aIgnore) = 0;
+
+
+
+
+
+
+  virtual void NotifyDestroyingFrame(nsIFrame* aFrame) = 0;
+
+
+
+
+  virtual already_AddRefed<mozilla::AccessibleCaretEventHub> GetAccessibleCaretEventHub() const = 0;
+
+
+
+
+  virtual already_AddRefed<nsCaret> GetCaret() const = 0;
+
+
+
+
+  virtual void SetCaret(nsCaret *aNewCaret) = 0;
+
+
+
+
+
+  virtual void RestoreCaret() = 0;
+# 883 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult SetSelectionFlags(int16_t aInEnable) = 0;
+
+
+
+
+
+
+  int16_t GetSelectionFlags() const { return mSelectionFlags; }
+
+  virtual mozilla::dom::Selection*
+    GetCurrentSelection(mozilla::SelectionType aSelectionType) = 0;
+# 909 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual already_AddRefed<nsISelectionController>
+            GetSelectionControllerForFocusedContent(
+              nsIContent** aFocusedContent = nullptr) = 0;
+
+
+
+
+
+  virtual nsresult HandleEventWithTarget(
+                                 mozilla::WidgetEvent* aEvent,
+                                 nsIFrame* aFrame,
+                                 nsIContent* aContent,
+                                 nsEventStatus* aStatus) = 0;
+
+
+
+
+
+  virtual nsresult HandleDOMEventWithTarget(
+                                 nsIContent* aTargetContent,
+                                 mozilla::WidgetEvent* aEvent,
+                                 nsEventStatus* aStatus) = 0;
+
+
+
+
+
+  virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
+                                                        nsIDOMEvent* aEvent,
+                                                        nsEventStatus* aStatus) = 0;
+
+
+
+
+  virtual bool CanDispatchEvent(
+      const mozilla::WidgetGUIEvent* aEvent = nullptr) const = 0;
+
+
+
+
+  virtual nsIFrame* GetEventTargetFrame() = 0;
+
+
+
+
+  virtual already_AddRefed<nsIContent> GetEventTargetContent(
+                                                     mozilla::WidgetEvent* aEvent) = 0;
+
+
+
+
+
+  virtual nsresult CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) = 0;
+
+
+
+
+
+  bool IsReflowLocked() const { return mIsReflowing; }
+
+
+
+
+
+
+  bool IsPaintingSuppressed() const { return mPaintingSuppressed; }
+
+
+
+
+
+
+  virtual void PausePainting() = 0;
+
+
+
+
+
+
+  virtual void ResumePainting() = 0;
+
+
+
+
+  virtual void UnsuppressPainting() = 0;
+
+
+
+
+  void DisableThemeSupport()
+  {
+
+    mIsThemeSupportDisabled = true;
+  }
+
+
+
+
+  bool IsThemeSupportEnabled() const { return !mIsThemeSupportDisabled; }
+
+
+
+
+  virtual nsresult GetAgentStyleSheets(
+      nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
+
+
+
+
+  virtual nsresult SetAgentStyleSheets(
+      const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
+
+
+
+
+  virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
+
+
+
+
+  virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
+
+
+
+
+  virtual void ReconstructFrames() = 0;
+
+
+
+
+  virtual void ContentStateChanged(nsIDocument* aDocument,
+                                   nsIContent* aContent,
+                                   mozilla::EventStates aStateMask) = 0;
+
+
+
+
+
+
+  static bool GetVerifyReflowEnable();
+
+
+
+
+  static void SetVerifyReflowEnable(bool aEnabled);
+
+  virtual nsIFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame);
+
+
+  virtual void DumpReflows() = 0;
+  virtual void CountReflows(const char * aName, nsIFrame * aFrame) = 0;
+  virtual void PaintCount(const char * aName,
+                                      nsRenderingContext* aRenderingContext,
+                                      nsPresContext * aPresContext,
+                                      nsIFrame * aFrame,
+                                      const nsPoint& aOffset,
+                                      uint32_t aColor) = 0;
+  virtual void SetPaintFrameCount(bool aOn) = 0;
+  virtual bool IsPaintingFrameCounts() = 0;
+# 1082 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  static bool IsAccessibilityActive();
+
+
+
+
+  static nsAccessibilityService* AccService();
+
+
+
+
+
+
+
+  virtual void Freeze() = 0;
+  bool IsFrozen() { return mFrozen; }
+
+
+
+
+
+  virtual void Thaw() = 0;
+
+  virtual void FireOrClearDelayedEvents(bool aFireEvents) = 0;
+
+
+
+
+
+
+
+  void SetForwardingContainer(const mozilla::WeakPtr<nsDocShell> &aContainer);
+# 1152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  enum {
+    RENDER_IS_UNTRUSTED = 0x01,
+    RENDER_IGNORE_VIEWPORT_SCROLLING = 0x02,
+    RENDER_CARET = 0x04,
+    RENDER_USE_WIDGET_LAYERS = 0x08,
+    RENDER_ASYNC_DECODE_IMAGES = 0x10,
+    RENDER_DOCUMENT_RELATIVE = 0x20,
+    RENDER_DRAWWINDOW_NOT_FLUSHING = 0x40
+  };
+  virtual nsresult RenderDocument(const nsRect& aRect, uint32_t aFlags,
+                                  nscolor aBackgroundColor,
+                                  gfxContext* aRenderedContext) = 0;
+
+  enum {
+    RENDER_IS_IMAGE = 0x100,
+    RENDER_AUTO_SCALE = 0x80
+  };
+
+
+
+
+
+
+
+  virtual already_AddRefed<mozilla::gfx::SourceSurface>
+  RenderNode(nsIDOMNode* aNode,
+             nsIntRegion* aRegion,
+             const mozilla::LayoutDeviceIntPoint aPoint,
+             mozilla::LayoutDeviceIntRect* aScreenRect,
+             uint32_t aFlags) = 0;
+# 1199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual already_AddRefed<mozilla::gfx::SourceSurface>
+  RenderSelection(nsISelection* aSelection,
+                  const mozilla::LayoutDeviceIntPoint aPoint,
+                  mozilla::LayoutDeviceIntRect* aScreenRect,
+                  uint32_t aFlags) = 0;
+
+  void AddAutoWeakFrameInternal(AutoWeakFrame* aWeakFrame);
+  virtual void AddAutoWeakFrameExternal(AutoWeakFrame* aWeakFrame);
+  void AddWeakFrameInternal(WeakFrame* aWeakFrame);
+  virtual void AddWeakFrameExternal(WeakFrame* aWeakFrame);
+
+  void AddAutoWeakFrame(AutoWeakFrame* aWeakFrame)
+  {
+
+    AddAutoWeakFrameInternal(aWeakFrame);
+
+
+
+  }
+  void AddWeakFrame(WeakFrame* aWeakFrame)
+  {
+
+    AddWeakFrameInternal(aWeakFrame);
+
+
+
+  }
+
+  void RemoveAutoWeakFrameInternal(AutoWeakFrame* aWeakFrame);
+  virtual void RemoveAutoWeakFrameExternal(AutoWeakFrame* aWeakFrame);
+  void RemoveWeakFrameInternal(WeakFrame* aWeakFrame);
+  virtual void RemoveWeakFrameExternal(WeakFrame* aWeakFrame);
+
+  void RemoveAutoWeakFrame(AutoWeakFrame* aWeakFrame)
+  {
+
+    RemoveAutoWeakFrameInternal(aWeakFrame);
+
+
+
+  }
+  void RemoveWeakFrame(WeakFrame* aWeakFrame)
+  {
+
+    RemoveWeakFrameInternal(aWeakFrame);
+
+
+
+  }
+# 1260 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual void DisableNonTestMouseEvents(bool aDisable) = 0;
+# 1269 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  void SetCanvasBackground(nscolor aColor) { mCanvasBackgroundColor = aColor; }
+  nscolor GetCanvasBackground() { return mCanvasBackgroundColor; }
+
+
+
+
+
+  virtual void UpdateCanvasBackground() = 0;
+# 1285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  enum {
+    FORCE_DRAW = 0x01
+  };
+  virtual void AddCanvasBackgroundColorItem(nsDisplayListBuilder& aBuilder,
+                                            nsDisplayList& aList,
+                                            nsIFrame* aFrame,
+                                            const nsRect& aBounds,
+                                            nscolor aBackstopColor = ((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))),
+                                            uint32_t aFlags = 0) = 0;
+
+
+
+
+
+
+
+  virtual void AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
+                                             nsDisplayList& aList,
+                                             nsIFrame* aFrame,
+                                             const nsRect& aBounds) = 0;
+
+
+
+
+
+
+  virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot) = 0;
+
+  void ObserveNativeAnonMutationsForPrint(bool aObserve)
+  {
+    mObservesMutationsForPrint = aObserve;
+  }
+  bool ObservesNativeAnonMutationsForPrint()
+  {
+    return mObservesMutationsForPrint;
+  }
+
+  virtual nsresult SetIsActive(bool aIsActive) = 0;
+
+  bool IsActive()
+  {
+    return mIsActive;
+  }
+
+
+  static CapturingContentInfo gCaptureInfo;
+
+  class PointerCaptureInfo final
+  {
+  public:
+    nsCOMPtr<nsIContent> mPendingContent;
+    nsCOMPtr<nsIContent> mOverrideContent;
+
+    explicit PointerCaptureInfo(nsIContent* aPendingContent)
+      : mPendingContent(aPendingContent)
+    {
+                                        ;
+    }
+
+    ~PointerCaptureInfo()
+    {
+                                        ;
+    }
+
+    bool Empty()
+    {
+      return !(mPendingContent || mOverrideContent);
+    }
+  };
+
+  class PointerInfo final
+  {
+  public:
+    uint16_t mPointerType;
+    bool mActiveState;
+    bool mPrimaryState;
+    bool mPreventMouseEventByContent;
+    explicit PointerInfo(bool aActiveState, uint16_t aPointerType,
+                         bool aPrimaryState)
+      : mPointerType(aPointerType)
+      , mActiveState(aActiveState)
+      , mPrimaryState(aPrimaryState)
+      , mPreventMouseEventByContent(false)
+    {
+    }
+  };
+
+  static void DispatchGotOrLostPointerCaptureEvent(
+                bool aIsGotCapture,
+                const mozilla::WidgetPointerEvent* aPointerEvent,
+                nsIContent* aCaptureTarget);
+
+  static PointerCaptureInfo* GetPointerCaptureInfo(uint32_t aPointerId);
+  static void SetPointerCapturingContent(uint32_t aPointerId,
+                                         nsIContent* aContent);
+  static void ReleasePointerCapturingContent(uint32_t aPointerId);
+  static nsIContent* GetPointerCapturingContent(uint32_t aPointerId);
+
+
+
+  static void CheckPointerCaptureState(
+                const mozilla::WidgetPointerEvent* aPointerEvent);
+
+
+
+
+
+  static bool GetPointerInfo(uint32_t aPointerId, bool& aActiveState);
+
+
+
+  static uint16_t GetPointerType(uint32_t aPointerId);
+
+
+
+  static bool GetPointerPrimaryState(uint32_t aPointerId);
+# 1424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  static void SetCapturingContent(nsIContent* aContent, uint8_t aFlags);
+
+
+
+
+  static nsIContent* GetCapturingContent()
+  {
+    return gCaptureInfo.mContent;
+  }
+
+
+
+
+  static void AllowMouseCapture(bool aAllowed)
+  {
+    gCaptureInfo.mAllowed = aAllowed;
+  }
+
+
+
+
+
+  static bool IsMouseCapturePreventingDrag()
+  {
+    return gCaptureInfo.mPreventDrag && gCaptureInfo.mContent;
+  }
+
+
+
+
+
+  uint64_t GetPaintCount() { return mPaintCount; }
+  void IncrementPaintCount() { ++mPaintCount; }
+
+
+
+
+  virtual already_AddRefed<nsPIDOMWindowOuter> GetRootWindow() = 0;
+
+
+
+
+
+  virtual LayerManager* GetLayerManager() = 0;
+
+
+
+
+
+  virtual bool AsyncPanZoomEnabled() = 0;
+
+
+
+
+
+
+  virtual void SetIgnoreViewportScrolling(bool aIgnore) = 0;
+  bool IgnoringViewportScrolling() const
+  { return mRenderFlags & STATE_IGNORING_VIEWPORT_SCROLLING; }
+# 1493 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual nsresult SetResolution(float aResolution) = 0;
+  float GetResolution() const { return mResolution.valueOr(1.0); }
+  virtual float GetCumulativeResolution() = 0;
+
+
+
+
+
+  virtual float GetCumulativeNonRootScaleResolution() = 0;
+
+
+
+
+  bool IsResolutionSet() { return mResolution.isSome(); }
+
+
+
+
+
+  virtual nsresult SetResolutionAndScaleTo(float aResolution) = 0;
+
+
+
+
+
+
+  virtual bool ScaleToResolution() const = 0;
+
+
+
+
+
+  virtual void SetRestoreResolution(float aResolution,
+                                    mozilla::LayoutDeviceIntSize aDisplaySize) = 0;
+
+
+
+
+
+  bool InDrawWindowNotFlushing() const
+  { return mRenderFlags & STATE_DRAWWINDOW_NOT_FLUSHING; }
+
+
+
+
+  void SetIsFirstPaint(bool aIsFirstPaint) { mIsFirstPaint = aIsFirstPaint; }
+
+
+
+
+  bool GetIsFirstPaint() const { return mIsFirstPaint; }
+
+  uint32_t GetPresShellId() { return mPresShellId; }
+
+
+
+
+
+
+  virtual void SynthesizeMouseMove(bool aFromScroll) = 0;
+
+  enum PaintFlags {
+
+
+
+    PAINT_LAYERS = 0x01,
+
+    PAINT_COMPOSITE = 0x02,
+
+    PAINT_SYNC_DECODE_IMAGES = 0x04
+  };
+  virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
+                     uint32_t aFlags) = 0;
+  virtual nsresult HandleEvent(nsIFrame* aFrame,
+                               mozilla::WidgetGUIEvent* aEvent,
+                               bool aDontRetargetEvents,
+                               nsEventStatus* aEventStatus,
+                               nsIContent** aTargetContent = nullptr) = 0;
+  virtual bool ShouldIgnoreInvalidation() = 0;
+
+
+
+
+
+
+
+  virtual void WillPaint() = 0;
+
+
+
+
+
+  virtual void WillPaintWindow() = 0;
+
+
+
+
+
+  virtual void DidPaintWindow() = 0;
+# 1600 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  enum PaintType {
+    PAINT_DEFAULT,
+    PAINT_DELAYED_COMPRESS
+  };
+  virtual void ScheduleViewManagerFlush(PaintType aType = PAINT_DEFAULT) = 0;
+  virtual void ClearMouseCaptureOnView(nsView* aView) = 0;
+  virtual bool IsVisible() = 0;
+  virtual void DispatchSynthMouseMove(mozilla::WidgetGUIEvent* aEvent,
+                                      bool aFlushOnHoverChange) = 0;
+
+  virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                      nsArenaMemoryStats *aArenaObjectsSize,
+                                      size_t *aPresShellSize,
+                                      size_t *aStyleSetsSize,
+                                      size_t *aTextRunsSize,
+                                      size_t *aPresContextSize) = 0;
+
+
+
+
+  uint32_t FontSizeInflationEmPerLine() const {
+    return mFontSizeInflationEmPerLine;
+  }
+
+  uint32_t FontSizeInflationMinTwips() const {
+    return mFontSizeInflationMinTwips;
+  }
+
+  uint32_t FontSizeInflationLineThreshold() const {
+    return mFontSizeInflationLineThreshold;
+  }
+
+  bool FontSizeInflationForceEnabled() const {
+    return mFontSizeInflationForceEnabled;
+  }
+
+  bool FontSizeInflationDisabledInMasterProcess() const {
+    return mFontSizeInflationDisabledInMasterProcess;
+  }
+
+
+
+
+
+
+
+  bool FontSizeInflationEnabled();
+
+
+
+
+
+
+
+  void NotifyFontSizeInflationEnabledIsDirty()
+  {
+    mFontSizeInflationEnabledIsDirty = true;
+  }
+# 1667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  virtual void ScheduleApproximateFrameVisibilityUpdateSoon() = 0;
+
+
+
+
+
+  virtual void ScheduleApproximateFrameVisibilityUpdateNow() = 0;
+
+
+
+  virtual void RebuildApproximateFrameVisibilityDisplayList(const nsDisplayList& aList) = 0;
+  virtual void RebuildApproximateFrameVisibility(nsRect* aRect = nullptr,
+                                                 bool aRemoveOnly = false) = 0;
+
+
+  virtual void EnsureFrameInApproximatelyVisibleList(nsIFrame* aFrame) = 0;
+
+
+  virtual void RemoveFrameFromApproximatelyVisibleList(nsIFrame* aFrame) = 0;
+
+
+  virtual bool AssumeAllFramesVisible() = 0;
+# 1697 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  nsresult HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType,
+                                                   bool* aRetVal);
+
+
+
+
+protected:
+  virtual bool AddRefreshObserverExternal(nsARefreshObserver* aObserver,
+                                          mozilla::FlushType aFlushType);
+  bool AddRefreshObserverInternal(nsARefreshObserver* aObserver,
+                                  mozilla::FlushType aFlushType);
+  virtual bool RemoveRefreshObserverExternal(nsARefreshObserver* aObserver,
+                                             mozilla::FlushType aFlushType);
+  bool RemoveRefreshObserverInternal(nsARefreshObserver* aObserver,
+                                     mozilla::FlushType aFlushType);
+
+  void DoObserveStyleFlushes();
+  void DoObserveLayoutFlushes();
+
+
+
+
+
+
+  void RecomputeFontSizeInflationEnabled();
+
+
+
+
+  bool DetermineFontSizeInflationState();
+
+
+
+
+
+  void HandleSystemFontScale();
+
+  void RecordAlloc(void* aPtr) {
+
+
+
+
+  }
+
+  void RecordFree(void* aPtr) {
+
+
+
+
+  }
+
+public:
+  bool AddRefreshObserver(nsARefreshObserver* aObserver,
+                          mozilla::FlushType aFlushType) {
+
+    return AddRefreshObserverInternal(aObserver, aFlushType);
+
+
+
+  }
+
+  bool RemoveRefreshObserver(nsARefreshObserver* aObserver,
+                             mozilla::FlushType aFlushType) {
+
+    return RemoveRefreshObserverInternal(aObserver, aFlushType);
+
+
+
+  }
+
+  virtual bool AddPostRefreshObserver(nsAPostRefreshObserver* aObserver);
+  virtual bool RemovePostRefreshObserver(nsAPostRefreshObserver* aObserver);
+
+
+
+
+  static void InitializeStatics();
+  static void ReleaseStatics();
+
+
+
+  static void ClearMouseCapture(nsIFrame* aFrame);
+
+  void SetScrollPositionClampingScrollPortSize(nscoord aWidth, nscoord aHeight);
+  bool IsScrollPositionClampingScrollPortSizeSet() {
+    return mScrollPositionClampingScrollPortSizeSet;
+  }
+  nsSize GetScrollPositionClampingScrollPortSize() {
+    do { } while(0);
+    return mScrollPositionClampingScrollPortSize;
+  }
+
+  virtual void WindowSizeMoveDone() = 0;
+  virtual void SysColorChanged() = 0;
+  virtual void ThemeChanged() = 0;
+  virtual void BackingScaleFactorChanged() = 0;
+
+
+
+
+  bool IsNeverPainting() {
+    return mIsNeverPainting;
+  }
+
+  void SetNeverPainting(bool aNeverPainting) {
+    mIsNeverPainting = aNeverPainting;
+  }
+
+  bool HasPendingReflow() const
+    { return mObservingLayoutFlushes || mReflowContinueTimer; }
+
+  void SyncWindowProperties(nsView* aView);
+
+  virtual nsIDocument* GetPrimaryContentDocument() = 0;
+
+
+  virtual void NotifyStyleSheetServiceSheetAdded(mozilla::StyleSheet* aSheet,
+                                                 uint32_t aSheetType) = 0;
+  virtual void NotifyStyleSheetServiceSheetRemoved(mozilla::StyleSheet* aSheet,
+                                                   uint32_t aSheetType) = 0;
+
+protected:
+  friend class nsRefreshDriver;
+
+
+
+
+
+
+
+  nsCOMPtr<nsIDocument> mDocument;
+  RefPtr<nsPresContext> mPresContext;
+  mozilla::StyleSetHandle mStyleSet;
+  nsCSSFrameConstructor* mFrameConstructor;
+  nsViewManager* mViewManager;
+  nsPresArena mFrameArena;
+  RefPtr<nsFrameSelection> mSelection;
+
+
+  nsFrameManagerBase* mFrameManager;
+  mozilla::WeakPtr<nsDocShell> mForwardingContainer;
+
+  mozilla::a11y::DocAccessible* mDocAccessible;
+
+
+
+
+
+
+  nsCOMPtr<nsITimer> mReflowContinueTimer;
+# 1858 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  uint64_t mPaintCount;
+
+  nsSize mScrollPositionClampingScrollPortSize;
+
+
+  AutoWeakFrame* mAutoWeakFrames;
+
+
+  nsTHashtable<nsPtrHashKey<WeakFrame>> mWeakFrames;
+
+
+  nscolor mCanvasBackgroundColor;
+
+
+
+  mozilla::Maybe<float> mResolution;
+
+  int16_t mSelectionFlags;
+
+
+
+
+
+
+  RenderFlags mRenderFlags;
+
+
+
+
+  bool mStylesHaveChanged : 1;
+  bool mDidInitialize : 1;
+  bool mIsDestroying : 1;
+  bool mIsReflowing : 1;
+
+
+  bool mPaintingSuppressed : 1;
+
+
+  bool mIsThemeSupportDisabled : 1;
+
+  bool mIsActive : 1;
+  bool mFrozen : 1;
+  bool mIsFirstPaint : 1;
+  bool mObservesMutationsForPrint : 1;
+
+  bool mSuppressInterruptibleReflows : 1;
+  bool mScrollPositionClampingScrollPortSizeSet : 1;
+
+
+  bool mNeedLayoutFlush : 1;
+
+
+  bool mNeedStyleFlush : 1;
+
+
+  bool mObservingStyleFlushes: 1;
+
+
+
+
+
+  bool mObservingLayoutFlushes: 1;
+
+
+
+  bool mNeedThrottledAnimationFlush : 1;
+
+  uint32_t mPresShellId;
+# 1934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
+  AutoTArray<RefPtr<mozilla::dom::Element>,1> mChangedScopeStyleRoots;
+
+  static nsIContent* gKeyDownTarget;
+
+
+
+  uint32_t mFontSizeInflationEmPerLine;
+  uint32_t mFontSizeInflationMinTwips;
+  uint32_t mFontSizeInflationLineThreshold;
+  bool mFontSizeInflationForceEnabled;
+  bool mFontSizeInflationDisabledInMasterProcess;
+  bool mFontSizeInflationEnabled;
+
+
+  bool mFontSizeInflationEnabledIsDirty;
+
+  bool mPaintingIsFrozen;
+
+
+
+
+  bool mIsNeverPainting;
+
+
+
+  bool mInFlush;
+};
+
+template<typename T> struct nsIPresShell::COMTypeInfo<nsIPresShell, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPresShell::COMTypeInfo<nsIPresShell, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xa75573d6, 0x34c8, 0x4485, { 0x8f, 0xb7, 0xed, 0xcb, 0x6f, 0xc7, 0x0e, 0x12 } };
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFamilyList.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFamilyList.h"
+namespace mozilla {
+
+
+
+
+
+
+
+enum FontFamilyType : uint32_t {
+  eFamily_none = 0,
+
+
+  eFamily_named,
+  eFamily_named_quoted,
+
+
+  eFamily_serif,
+  eFamily_sans_serif,
+  eFamily_monospace,
+  eFamily_cursive,
+  eFamily_fantasy,
+
+
+  eFamily_moz_variable,
+  eFamily_moz_fixed,
+
+  eFamily_generic_first = eFamily_serif,
+  eFamily_generic_last = eFamily_fantasy,
+  eFamily_generic_count = (eFamily_fantasy - eFamily_serif + 1)
+};
+
+enum QuotedName { eQuotedName, eUnquotedName };
+
+
+
+
+
+
+struct FontFamilyName final {
+    FontFamilyName()
+        : mType(eFamily_named)
+    {}
+
+
+    explicit FontFamilyName(const nsAString& aFamilyName,
+                            QuotedName aQuoted = eUnquotedName) {
+        mType = (aQuoted == eQuotedName) ? eFamily_named_quoted : eFamily_named;
+        mName = aFamilyName;
+    }
+
+
+    explicit FontFamilyName(FontFamilyType aType) {
+        do { } while(0);
+
+
+
+        mName.Truncate();
+        mType = aType;
+    }
+
+    FontFamilyName(const FontFamilyName& aCopy) {
+        mType = aCopy.mType;
+        mName = aCopy.mName;
+    }
+
+    bool IsNamed() const {
+        return mType == eFamily_named || mType == eFamily_named_quoted;
+    }
+
+    bool IsGeneric() const {
+        return !IsNamed();
+    }
+
+    void AppendToString(nsAString& aFamilyList, bool aQuotes = true) const {
+        switch (mType) {
+            case eFamily_named:
+                aFamilyList.Append(mName);
+                break;
+            case eFamily_named_quoted:
+                if (aQuotes) {
+                    aFamilyList.Append('"');
+                }
+                aFamilyList.Append(mName);
+                if (aQuotes) {
+                    aFamilyList.Append('"');
+                }
+                break;
+            case eFamily_serif:
+                aFamilyList.AppendLiteral("serif");
+                break;
+            case eFamily_sans_serif:
+                aFamilyList.AppendLiteral("sans-serif");
+                break;
+            case eFamily_monospace:
+                aFamilyList.AppendLiteral("monospace");
+                break;
+            case eFamily_cursive:
+                aFamilyList.AppendLiteral("cursive");
+                break;
+            case eFamily_fantasy:
+                aFamilyList.AppendLiteral("fantasy");
+                break;
+            case eFamily_moz_fixed:
+                aFamilyList.AppendLiteral("-moz-fixed");
+                break;
+            default:
+                break;
+        }
+    }
+
+
+    static FontFamilyName
+    Convert(const nsAString& aFamilyOrGenericName) {
+
+
+
+        do { } while(0);
+
+
+        FontFamilyType genericType = eFamily_none;
+        if (aFamilyOrGenericName.LowerCaseEqualsLiteral("serif")) {
+            genericType = eFamily_serif;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("sans-serif")) {
+            genericType = eFamily_sans_serif;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("monospace")) {
+            genericType = eFamily_monospace;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("cursive")) {
+            genericType = eFamily_cursive;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("fantasy")) {
+            genericType = eFamily_fantasy;
+        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("-moz-fixed")) {
+            genericType = eFamily_moz_fixed;
+        } else {
+            return FontFamilyName(aFamilyOrGenericName, eUnquotedName);
+        }
+
+        return FontFamilyName(genericType);
+    }
+
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+        return mName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+    }
+
+    FontFamilyType mType;
+    nsString mName;
+};
+
+inline bool
+operator==(const FontFamilyName& a, const FontFamilyName& b) {
+    return a.mType == b.mType && a.mName == b.mName;
+}
+
+
+
+
+
+
+
+class FontFamilyList {
+public:
+    FontFamilyList()
+        : mDefaultFontType(eFamily_none)
+    {
+    }
+
+    explicit FontFamilyList(FontFamilyType aGenericType)
+        : mDefaultFontType(eFamily_none)
+    {
+        Append(FontFamilyName(aGenericType));
+    }
+
+    FontFamilyList(const nsAString& aFamilyName,
+                   QuotedName aQuoted)
+        : mDefaultFontType(eFamily_none)
+    {
+        Append(FontFamilyName(aFamilyName, aQuoted));
+    }
+
+    FontFamilyList(const FontFamilyList& aOther)
+        : mFontlist(aOther.mFontlist)
+        , mDefaultFontType(aOther.mDefaultFontType)
+    {
+    }
+
+    void Append(const FontFamilyName& aFamilyName) {
+        mFontlist.AppendElement(aFamilyName);
+    }
+
+    void Append(const nsTArray<nsString>& aFamilyNameList) {
+        uint32_t len = aFamilyNameList.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            mFontlist.AppendElement(FontFamilyName(aFamilyNameList[i],
+                                                   eUnquotedName));
+        }
+    }
+
+    void Clear() {
+        mFontlist.Clear();
+    }
+
+    uint32_t Length() const {
+        return mFontlist.Length();
+    }
+
+    bool IsEmpty() const {
+      return mFontlist.IsEmpty();
+    }
+
+    const nsTArray<FontFamilyName>& GetFontlist() const {
+        return mFontlist;
+    }
+
+    bool Equals(const FontFamilyList& aFontlist) const {
+        return mFontlist == aFontlist.mFontlist &&
+               mDefaultFontType == aFontlist.mDefaultFontType;
+    }
+
+    FontFamilyType FirstGeneric() const {
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.IsGeneric()) {
+                return name.mType;
+            }
+        }
+        return eFamily_none;
+    }
+
+    bool HasGeneric() const {
+        return FirstGeneric() != eFamily_none;
+    }
+
+    bool HasDefaultGeneric() const {
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.mType == mDefaultFontType) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+
+
+    bool PrioritizeFirstGeneric() {
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName name = mFontlist[i];
+            if (name.IsGeneric()) {
+                if (name.mType == eFamily_cursive ||
+                    name.mType == eFamily_fantasy) {
+                    continue;
+                }
+                if (i > 0) {
+                    mFontlist.RemoveElementAt(i);
+                    mFontlist.InsertElementAt(0, name);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void PrependGeneric(FontFamilyType aType) {
+        mFontlist.InsertElementAt(0, FontFamilyName(aType));
+    }
+
+    void ToString(nsAString& aFamilyList,
+                  bool aQuotes = true,
+                  bool aIncludeDefault = false) const {
+        aFamilyList.Truncate();
+        uint32_t len = mFontlist.Length();
+        for (uint32_t i = 0; i < len; i++) {
+            if (i != 0) {
+                aFamilyList.Append(',');
+            }
+            const FontFamilyName& name = mFontlist[i];
+            name.AppendToString(aFamilyList, aQuotes);
+        }
+        if (aIncludeDefault && mDefaultFontType != eFamily_none) {
+            if (!aFamilyList.IsEmpty()) {
+                aFamilyList.Append(',');
+            }
+            if (mDefaultFontType == eFamily_serif) {
+                aFamilyList.AppendLiteral("serif");
+            } else {
+                aFamilyList.AppendLiteral("sans-serif");
+            }
+        }
+    }
+
+
+    bool Contains(const nsAString& aFamilyName) const {
+        uint32_t len = mFontlist.Length();
+        nsAutoString fam(aFamilyName);
+        ToLowerCase(fam);
+        for (uint32_t i = 0; i < len; i++) {
+            const FontFamilyName& name = mFontlist[i];
+            if (name.mType != eFamily_named &&
+                name.mType != eFamily_named_quoted) {
+                continue;
+            }
+            nsAutoString listname(name.mName);
+            ToLowerCase(listname);
+            if (listname.Equals(fam)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    FontFamilyType GetDefaultFontType() const { return mDefaultFontType; }
+    void SetDefaultFontType(FontFamilyType aType) {
+        do { } while(0);
+
+
+        mDefaultFontType = aType;
+    }
+
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+        size_t n = 0;
+        n += mFontlist.ShallowSizeOfExcludingThis(aMallocSizeOf);
+        for (size_t i = 0; i < mFontlist.Length(); i++) {
+            n += mFontlist[i].SizeOfExcludingThis(aMallocSizeOf);
+        }
+        return n;
+    }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+        return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+    }
+
+private:
+    nsTArray<FontFamilyName> mFontlist;
+    FontFamilyType mDefaultFontType;
+};
+
+inline bool
+operator==(const FontFamilyList& a, const FontFamilyList& b) {
+    return a.Equals(b);
+}
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h" 1
+# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
+enum {
+    eFeatureAlternates_historical,
+    eFeatureAlternates_stylistic,
+    eFeatureAlternates_styleset,
+    eFeatureAlternates_character_variant,
+    eFeatureAlternates_swash,
+    eFeatureAlternates_ornaments,
+    eFeatureAlternates_annotation,
+
+    eFeatureAlternates_numFeatures
+};
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
+enum {
+    eFeatureEastAsian_jis78,
+    eFeatureEastAsian_jis83,
+    eFeatureEastAsian_jis90,
+    eFeatureEastAsian_jis04,
+    eFeatureEastAsian_simplified,
+    eFeatureEastAsian_traditional,
+    eFeatureEastAsian_full_width,
+    eFeatureEastAsian_prop_width,
+    eFeatureEastAsian_ruby,
+
+    eFeatureEastAsian_numFeatures
+};
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
+enum {
+    eFeatureLigatures_none,
+    eFeatureLigatures_common,
+    eFeatureLigatures_no_common,
+    eFeatureLigatures_discretionary,
+    eFeatureLigatures_no_discretionary,
+    eFeatureLigatures_historical,
+    eFeatureLigatures_no_historical,
+    eFeatureLigatures_contextual,
+    eFeatureLigatures_no_contextual,
+
+    eFeatureLigatures_numFeatures
+};
+# 168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
+enum {
+    eFeatureNumeric_lining,
+    eFeatureNumeric_oldstyle,
+    eFeatureNumeric_proportional,
+    eFeatureNumeric_tabular,
+    eFeatureNumeric_diagonal_fractions,
+    eFeatureNumeric_stacked_fractions,
+    eFeatureNumeric_slashedzero,
+    eFeatureNumeric_ordinal,
+
+    eFeatureNumeric_numFeatures
+};
+# 226 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
+enum eFontPrefLang {
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontPrefLangList.h" 1
+
+
+
+
+
+
+
+eFontPrefLang_Western,
+eFontPrefLang_Japanese,
+eFontPrefLang_ChineseTW,
+eFontPrefLang_ChineseCN,
+eFontPrefLang_ChineseHK,
+eFontPrefLang_Korean,
+eFontPrefLang_Cyrillic,
+eFontPrefLang_Greek,
+eFontPrefLang_Thai,
+eFontPrefLang_Hebrew,
+eFontPrefLang_Arabic,
+eFontPrefLang_Devanagari,
+eFontPrefLang_Tamil,
+eFontPrefLang_Armenian,
+eFontPrefLang_Bengali,
+eFontPrefLang_Canadian,
+eFontPrefLang_Ethiopic,
+eFontPrefLang_Georgian,
+eFontPrefLang_Gujarati,
+eFontPrefLang_Gurmukhi,
+eFontPrefLang_Khmer,
+eFontPrefLang_Malayalam,
+eFontPrefLang_Mathematics,
+eFontPrefLang_Oriya,
+eFontPrefLang_Telugu,
+eFontPrefLang_Kannada,
+eFontPrefLang_Sinhala,
+eFontPrefLang_Tibetan,
+eFontPrefLang_Others
+# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h" 2
+
+
+    , eFontPrefLang_CJKSet
+    , eFontPrefLang_First = eFontPrefLang_Western
+    , eFontPrefLang_Last = eFontPrefLang_Others
+    , eFontPrefLang_Count = (eFontPrefLang_Last - eFontPrefLang_First + 1)
+};
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFeatures.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFeatures.h"
+struct gfxFontFeature {
+    uint32_t mTag;
+    uint32_t mValue;
+
+};
+
+inline bool
+operator<(const gfxFontFeature& a, const gfxFontFeature& b)
+{
+    return (a.mTag < b.mTag) || ((a.mTag == b.mTag) && (a.mValue < b.mValue));
+}
+
+inline bool
+operator==(const gfxFontFeature& a, const gfxFontFeature& b)
+{
+    return (a.mTag == b.mTag) && (a.mValue == b.mValue);
+}
+
+struct gfxAlternateValue {
+    uint32_t alternate;
+    nsString value;
+};
+
+inline bool
+operator<(const gfxAlternateValue& a, const gfxAlternateValue& b)
+{
+    return (a.alternate < b.alternate) ||
+        ((a.alternate == b.alternate) && (a.value < b.value));
+}
+
+inline bool
+operator==(const gfxAlternateValue& a, const gfxAlternateValue& b)
+{
+    return (a.alternate == b.alternate) && (a.value == b.value);
+}
+
+class gfxFontFeatureValueSet final {
+public:
+    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<gfxFontFeatureValueSet>::value, "Reference-counted class " "gfxFontFeatureValueSet" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+    gfxFontFeatureValueSet();
+
+    struct ValueList {
+        ValueList(const nsAString& aName, const nsTArray<uint32_t>& aSelectors)
+          : name(aName), featureSelectors(aSelectors)
+        {}
+        nsString name;
+        nsTArray<uint32_t> featureSelectors;
+    };
+
+    struct FeatureValues {
+        uint32_t alternate;
+        nsTArray<ValueList> valuelist;
+    };
+
+
+    bool
+    GetFontFeatureValuesFor(const nsAString& aFamily,
+                            uint32_t aVariantProperty,
+                            const nsAString& aName,
+                            nsTArray<uint32_t>& aValues);
+    void
+    AddFontFeatureValues(const nsAString& aFamily,
+                const nsTArray<gfxFontFeatureValueSet::FeatureValues>& aValues);
+
+private:
+
+    ~gfxFontFeatureValueSet() {}
+
+    struct FeatureValueHashKey {
+        nsString mFamily;
+        uint32_t mPropVal;
+        nsString mName;
+
+        FeatureValueHashKey()
+            : mPropVal(0)
+        { }
+        FeatureValueHashKey(const nsAString& aFamily,
+                            uint32_t aPropVal,
+                            const nsAString& aName)
+            : mFamily(aFamily), mPropVal(aPropVal), mName(aName)
+        { }
+        FeatureValueHashKey(const FeatureValueHashKey& aKey)
+            : mFamily(aKey.mFamily), mPropVal(aKey.mPropVal), mName(aKey.mName)
+        { }
+    };
+
+    class FeatureValueHashEntry : public PLDHashEntryHdr {
+    public:
+        typedef const FeatureValueHashKey &KeyType;
+        typedef const FeatureValueHashKey *KeyTypePointer;
+
+        explicit FeatureValueHashEntry(KeyTypePointer aKey) { }
+        FeatureValueHashEntry(const FeatureValueHashEntry& toCopy)
+        {
+            do { } while(0);
+        }
+        ~FeatureValueHashEntry() { }
+
+        bool KeyEquals(const KeyTypePointer aKey) const;
+        static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+        static PLDHashNumber HashKey(const KeyTypePointer aKey);
+        enum { ALLOW_MEMMOVE = true };
+
+        FeatureValueHashKey mKey;
+        nsTArray<uint32_t> mValues;
+    };
+
+    nsTHashtable<FeatureValueHashEntry> mFontFeatureValues;
+  };
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontVariations.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontVariations.h"
+struct gfxFontVariation {
+    uint32_t mTag;
+    float mValue;
+};
+
+inline bool
+operator==(const gfxFontVariation& a, const gfxFontVariation& b)
+{
+    return (a.mTag == b.mTag) && (a.mValue == b.mValue);
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
+
+
+
+
+
+
+struct gfxFontStyle;
+
+
+
+
+
+typedef bool (*nsFontFamilyEnumFunc)(const nsString& aFamily, bool aGeneric, void *aData);
+
+
+
+
+const uint8_t kGenericFont_NONE = 0x00;
+
+const uint8_t kGenericFont_moz_variable = 0x00;
+const uint8_t kGenericFont_moz_fixed = 0x01;
+
+const uint8_t kGenericFont_serif = 0x02;
+const uint8_t kGenericFont_sans_serif = 0x04;
+const uint8_t kGenericFont_monospace = 0x08;
+const uint8_t kGenericFont_cursive = 0x10;
+const uint8_t kGenericFont_fantasy = 0x20;
+
+
+struct nsFont {
+
+
+  mozilla::FontFamilyList fontlist;
+
+
+  uint8_t style = 0;
+
+
+
+  bool systemFont = false;
+
+
+  uint8_t variantCaps = 0;
+  uint8_t variantNumeric = 0;
+  uint8_t variantPosition = 0;
+  uint8_t variantWidth = 0;
+
+  uint16_t variantLigatures = 0;
+  uint16_t variantEastAsian = 0;
+
+
+
+
+
+
+  uint16_t variantAlternates = 0;
+
+
+  uint8_t smoothing = 0;
+
+
+  uint16_t weight = 400;
+
+
+
+  int16_t stretch = 0;
+
+
+  uint8_t kerning = 0;
+
+
+  uint8_t synthesis = 0x1 | 0x2;
+
+
+  nscoord size = 0;
+
+
+
+
+
+  float sizeAdjust = -1.0f;
+
+
+  nsTArray<gfxAlternateValue> alternateValues;
+
+
+  RefPtr<gfxFontFeatureValueSet> featureValueLookup;
+
+
+  nsTArray<gfxFontFeature> fontFeatureSettings;
+
+
+  nsTArray<gfxFontVariation> fontVariationSettings;
+
+
+
+
+  uint32_t languageOverride = 0;
+
+
+  nsFont(const mozilla::FontFamilyList& aFontlist, nscoord aSize);
+
+
+  nsFont(mozilla::FontFamilyType aGenericType, nscoord aSize);
+
+
+  nsFont(const nsFont& aFont);
+
+
+  nsFont();
+
+  ~nsFont();
+
+  bool operator==(const nsFont& aOther) const {
+    return Equals(aOther);
+  }
+
+  bool operator!=(const nsFont& aOther) const {
+    return !Equals(aOther);
+  }
+
+  bool Equals(const nsFont& aOther) const;
+
+  nsFont& operator=(const nsFont& aOther);
+
+  void CopyAlternates(const nsFont& aOther);
+
+
+  void AddFontFeaturesToStyle(gfxFontStyle *aStyle) const;
+
+  void AddFontVariationsToStyle(gfxFontStyle *aStyle) const;
+};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserver.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserver.h"
+class nsIObserver : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) = 0;
+
+};
+
+  template<typename T> struct nsIObserver::COMTypeInfo<nsIObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIObserver::COMTypeInfo<nsIObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xdb242e01, 0xe4d9, 0x11d2, { 0x9d, 0xde, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }};
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
+class nsIObserver;
+
+class nsIEventTarget;
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
+class nsITimer;
+typedef void (*nsTimerCallbackFunc) (nsITimer *aTimer, void *aClosure);
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
+typedef void (*nsTimerNameCallbackFunc) (nsITimer *aTimer,
+                                         bool aAnonymize,
+                                         void *aClosure,
+                                         char *aBuf, size_t aLen);
+class nsITimer;
+# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
+class nsITimerCallback : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Notify(nsITimer *timer) = 0;
+
+};
+
+  template<typename T> struct nsITimerCallback::COMTypeInfo<nsITimerCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimerCallback::COMTypeInfo<nsITimerCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa796816d, 0x7d47, 0x4348, { 0x9a, 0xb8, 0xc7, 0xae, 0xb3, 0x21, 0x6a, 0x7d }};
+# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
+class nsITimer : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    TYPE_ONE_SHOT = 0,
+    TYPE_REPEATING_SLACK = 1,
+    TYPE_REPEATING_PRECISE = 2,
+    TYPE_REPEATING_PRECISE_CAN_SKIP = 3
+  };
+
+
+  virtual nsresult Init(nsIObserver *aObserver, uint32_t aDelay, uint32_t aType) = 0;
+
+
+  virtual nsresult InitWithFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType) = 0;
+
+
+  virtual nsresult InitWithCallback(nsITimerCallback *aCallback, uint32_t aDelay, uint32_t aType) = 0;
+
+
+  virtual nsresult Cancel(void) = 0;
+
+
+  virtual nsresult InitWithNamedFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType, const char * aName) = 0;
+
+
+  virtual nsresult InitWithNameableFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType, nsTimerNameCallbackFunc aNameCallback) = 0;
+
+
+  virtual nsresult GetDelay(uint32_t *aDelay) = 0;
+  virtual nsresult SetDelay(uint32_t aDelay) = 0;
+
+
+  virtual nsresult GetType(uint32_t *aType) = 0;
+  virtual nsresult SetType(uint32_t aType) = 0;
+
+
+  virtual nsresult GetClosure(void **aClosure) = 0;
+
+
+  virtual nsresult GetCallback(nsITimerCallback * *aCallback) = 0;
+
+
+  virtual nsresult GetTarget(nsIEventTarget * *aTarget) = 0;
+  virtual nsresult SetTarget(nsIEventTarget *aTarget) = 0;
+
+   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const = 0;
+};
+
+  template<typename T> struct nsITimer::COMTypeInfo<nsITimer, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimer::COMTypeInfo<nsITimer, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3de4b105, 0x363c, 0x482c, { 0xa4, 0x09, 0xba, 0xac, 0x83, 0xa0, 0x1b, 0xfc }};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 1
+
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h" 1
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern "C" {
+
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRUint32
+PL_strlen(const char *str);
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) PRUint32
+PL_strnlen(const char *str, PRUint32 max);
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strcpy(char *dest, const char *src);
+# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strncpy(char *dest, const char *src, PRUint32 max);
+# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strncpyz(char *dest, const char *src, PRUint32 max);
+# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strdup(const char *s);
+
+
+
+
+
+
+
+extern __attribute__((visibility("default"))) void
+PL_strfree(char *s);
+# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strndup(const char *s, PRUint32 max);
+# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strcat(char *dst, const char *src);
+# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strncat(char *dst, const char *src, PRUint32 max);
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strcatn(char *dst, PRUint32 max, const char *src);
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) PRIntn
+PL_strcmp(const char *a, const char *b);
+# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) PRIntn
+PL_strncmp(const char *a, const char *b, PRUint32 max);
+# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) PRIntn
+PL_strcasecmp(const char *a, const char *b);
+# 225 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) PRIntn
+PL_strncasecmp(const char *a, const char *b, PRUint32 max);
+# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strchr(const char *s, char c);
+# 247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strrchr(const char *s, char c);
+# 259 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnchr(const char *s, char c, PRUint32 n);
+# 271 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnrchr(const char *s, char c, PRUint32 n);
+# 287 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strpbrk(const char *s, const char *list);
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strprbrk(const char *s, const char *list);
+# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnpbrk(const char *s, const char *list, PRUint32 n);
+# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnprbrk(const char *s, const char *list, PRUint32 n);
+# 330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strstr(const char *big, const char *little);
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strrstr(const char *big, const char *little);
+# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnstr(const char *big, const char *little, PRUint32 n);
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strnrstr(const char *big, const char *little, PRUint32 max);
+# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strcasestr(const char *big, const char *little);
+# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strcaserstr(const char *big, const char *little);
+# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strncasestr(const char *big, const char *little, PRUint32 max);
+# 404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strncaserstr(const char *big, const char *little, PRUint32 max);
+# 426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
+extern __attribute__((visibility("default"))) char *
+PL_strtok_r(char *s1, const char *s2, char **lasts);
+
+
+
+
+
+
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h"
+extern const char16_t kIsoLatin1ToUCS2[256];
+
+
+
+class nsCRT
+{
+public:
+  enum
+  {
+    LF = '\n' ,
+    VTAB = '\v' ,
+    CR = '\r'
+  };
+
+
+  static int32_t strcmp(const char* aStr1, const char* aStr2)
+  {
+    return int32_t(PL_strcmp(aStr1, aStr2));
+  }
+
+  static int32_t strncmp(const char* aStr1, const char* aStr2,
+                         uint32_t aMaxLen)
+  {
+    return int32_t(PL_strncmp(aStr1, aStr2, aMaxLen));
+  }
+
+
+  static int32_t strcasecmp(const char* aStr1, const char* aStr2)
+  {
+    return int32_t(PL_strcasecmp(aStr1, aStr2));
+  }
+
+
+  static int32_t strncasecmp(const char* aStr1, const char* aStr2,
+                             uint32_t aMaxLen)
+  {
+    int32_t result = int32_t(PL_strncasecmp(aStr1, aStr2, aMaxLen));
+
+
+    if (result < 0) {
+      result = -1;
+    }
+    return result;
+  }
+
+  static int32_t strncmp(const char* aStr1, const char* aStr2, int32_t aMaxLen)
+  {
+
+    int32_t diff =
+      ((const unsigned char*)aStr1)[0] - ((const unsigned char*)aStr2)[0];
+    if (diff != 0) {
+      return diff;
+    }
+    return int32_t(PL_strncmp(aStr1, aStr2, unsigned(aMaxLen)));
+  }
+# 100 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h"
+  static char* strtok(char* aStr, const char* aDelims, char** aNewStr);
+
+
+  static int32_t strcmp(const char16_t* aStr1, const char16_t* aStr2);
+
+  static int32_t strncmp(const char16_t* aStr1, const char16_t* aStr2,
+                         uint32_t aMaxLen);
+
+
+
+
+  static const char* memmem(const char* aHaystack, uint32_t aHaystackLen,
+                            const char* aNeedle, uint32_t aNeedleLen);
+
+
+  static int64_t atoll(const char* aStr);
+
+  static char ToUpper(char aChar) { return NS_ToUpper(aChar); }
+  static char ToLower(char aChar) { return NS_ToLower(aChar); }
+
+  static bool IsUpper(char aChar) { return NS_IsUpper(aChar); }
+  static bool IsLower(char aChar) { return NS_IsLower(aChar); }
+
+  static bool IsAscii(char16_t aChar) { return NS_IsAscii(aChar); }
+  static bool IsAscii(const char16_t* aString) { return NS_IsAscii(aString); }
+  static bool IsAsciiAlpha(char16_t aChar) { return NS_IsAsciiAlpha(aChar); }
+  static bool IsAsciiDigit(char16_t aChar) { return NS_IsAsciiDigit(aChar); }
+  static bool IsAsciiSpace(char16_t aChar) { return NS_IsAsciiWhitespace(aChar); }
+  static bool IsAscii(const char* aString) { return NS_IsAscii(aString); }
+  static bool IsAscii(const char* aString, uint32_t aLength)
+  {
+    return NS_IsAscii(aString, aLength);
+  }
+};
+
+
+inline bool
+NS_IS_SPACE(char16_t aChar)
+{
+  return ((int(aChar) & 0x7f) == int(aChar)) && isspace(int(aChar));
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h"
+class nsView;
+class nsIPresShell;
+class nsIWidget;
+class nsIXULWindow;
+
+
+
+
+enum nsSizeMode
+{
+  nsSizeMode_Normal = 0,
+  nsSizeMode_Minimized,
+  nsSizeMode_Maximized,
+  nsSizeMode_Fullscreen,
+  nsSizeMode_Invalid
+};
+
+
+
+
+enum nsWindowZ
+{
+  nsWindowZTop = 0,
+  nsWindowZBottom,
+  nsWindowZRelative
+};
+
+class nsIWidgetListener
+{
+public:
+
+
+
+
+
+
+  virtual nsIXULWindow* GetXULWindow();
+
+
+
+
+  virtual nsView* GetView();
+
+
+
+
+  virtual nsIPresShell* GetPresShell();
+
+
+
+
+
+  virtual bool WindowMoved(nsIWidget* aWidget, int32_t aX, int32_t aY);
+
+
+
+
+
+  virtual bool WindowResized(nsIWidget* aWidget,
+                             int32_t aWidth, int32_t aHeight);
+
+
+
+
+  virtual void SizeModeChanged(nsSizeMode aSizeMode);
+
+
+
+
+
+  virtual void UIResolutionChanged();
+# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h"
+  virtual bool ZLevelChanged(bool aImmediate, nsWindowZ* aPlacement,
+                             nsIWidget* aRequestBelow,
+                             nsIWidget** aActualBelow);
+
+
+
+
+  virtual void FullscreenChanged(bool aInFullscreen);
+
+
+
+
+  virtual void WindowActivated();
+
+
+
+
+  virtual void WindowDeactivated();
+
+
+
+
+  virtual void OSToolbarButtonPressed();
+
+
+
+
+
+  virtual bool RequestWindowClose(nsIWidget* aWidget);
+
+
+
+
+
+
+  virtual void WillPaintWindow(nsIWidget* aWidget);
+
+
+
+
+
+
+
+  virtual bool PaintWindow(nsIWidget* aWidget,
+                           mozilla::LayoutDeviceIntRegion aRegion);
+
+
+
+
+
+
+
+  virtual void DidPaintWindow();
+
+  virtual void DidCompositeWindow(uint64_t aTransactionId,
+                                  const mozilla::TimeStamp& aCompositeStart,
+                                  const mozilla::TimeStamp& aCompositeEnd);
+
+
+
+
+  virtual void RequestRepaint();
+
+
+
+
+  virtual nsEventStatus HandleEvent(mozilla::WidgetGUIEvent* aEvent,
+                                    bool aUseAttachedEvents);
+};
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Unused.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Unused.h"
+namespace mozilla {
+
+
+
+
+
+struct unused_t
+{
+  template<typename T>
+  inline void
+  operator<<(const T& ) const {}
+};
+
+extern __attribute__((weak)) __attribute__((visibility("default"))) const unused_t Unused;
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h" 2
+
+
+
+
+class nsIFrame;
+
+namespace mozilla {
+
+struct FramePropertyDescriptorUntyped
+{
+
+
+
+  typedef void UntypedDestructor(void* aPropertyValue);
+  UntypedDestructor* mDestructor;
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+  typedef void UntypedDestructorWithFrame(const nsIFrame* aFrame,
+                                          void* aPropertyValue);
+  UntypedDestructorWithFrame* mDestructorWithFrame;
+
+
+
+
+
+protected:
+
+
+
+
+
+  constexpr FramePropertyDescriptorUntyped(
+    UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
+    : mDestructor(aDtor)
+    , mDestructorWithFrame(aDtorWithFrame)
+  {}
+};
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+template<typename T>
+struct FramePropertyDescriptor : public FramePropertyDescriptorUntyped
+{
+  typedef void Destructor(T* aPropertyValue);
+  typedef void DestructorWithFrame(const nsIFrame* aaFrame,
+                                   T* aPropertyValue);
+
+  template<Destructor Dtor>
+  static constexpr const FramePropertyDescriptor<T> NewWithDestructor()
+  {
+    return { Destruct<Dtor>, nullptr };
+  }
+
+  template<DestructorWithFrame Dtor>
+  static constexpr
+  const FramePropertyDescriptor<T> NewWithDestructorWithFrame()
+  {
+    return { nullptr, DestructWithFrame<Dtor> };
+  }
+
+  static constexpr const FramePropertyDescriptor<T> NewWithoutDestructor()
+  {
+    return { nullptr, nullptr };
+  }
+
+private:
+  constexpr FramePropertyDescriptor(
+    UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
+    : FramePropertyDescriptorUntyped(aDtor, aDtorWithFrame)
+  {}
+
+  template<Destructor Dtor>
+  static void Destruct(void* aPropertyValue)
+  {
+    Dtor(static_cast<T*>(aPropertyValue));
+  }
+
+  template<DestructorWithFrame Dtor>
+  static void DestructWithFrame(const nsIFrame* aFrame, void* aPropertyValue)
+  {
+    Dtor(aFrame, static_cast<T*>(aPropertyValue));
+  }
+};
+
+
+
+
+
+template<typename T>
+class SmallValueHolder;
+
+namespace detail {
+
+template<typename T>
+struct FramePropertyTypeHelper
+{
+  typedef T* Type;
+};
+template<typename T>
+struct FramePropertyTypeHelper<SmallValueHolder<T>>
+{
+  typedef T Type;
+};
+
+}
+# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+class FramePropertyTable {
+public:
+  template<typename T>
+  using Descriptor = const FramePropertyDescriptor<T>*;
+  using UntypedDescriptor = const FramePropertyDescriptorUntyped*;
+
+  template<typename T>
+  using PropertyType = typename detail::FramePropertyTypeHelper<T>::Type;
+
+  FramePropertyTable() : mLastFrame(nullptr), mLastEntry(nullptr)
+  {
+  }
+  ~FramePropertyTable()
+  {
+    DeleteAll();
+  }
+
+
+
+
+
+
+
+  template<typename T>
+  void Set(nsIFrame* aFrame, Descriptor<T> aProperty,
+           PropertyType<T> aValue)
+  {
+    void* ptr = ReinterpretHelper<T>::ToPointer(aValue);
+    SetInternal(aFrame, aProperty, ptr);
+  }
+# 197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+  template<typename T>
+  bool Has(const nsIFrame* aFrame, Descriptor<T> aProperty)
+  {
+    bool foundResult = false;
+    mozilla::Unused << GetInternal(aFrame, aProperty, false, &foundResult);
+    return foundResult;
+  }
+
+  template<typename T>
+  bool HasSkippingBitCheck(const nsIFrame* aFrame, Descriptor<T> aProperty)
+  {
+    bool foundResult = false;
+    mozilla::Unused << GetInternal(aFrame, aProperty, true, &foundResult);
+    return foundResult;
+  }
+# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+  template<typename T>
+  PropertyType<T> Get(const nsIFrame* aFrame, Descriptor<T> aProperty,
+                      bool* aFoundResult = nullptr)
+  {
+    void* ptr = GetInternal(aFrame, aProperty, false, aFoundResult);
+    return ReinterpretHelper<T>::FromPointer(ptr);
+  }
+# 243 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+  template<typename T>
+  PropertyType<T> Remove(nsIFrame* aFrame, Descriptor<T> aProperty,
+                         bool* aFoundResult = nullptr)
+  {
+    void* ptr = RemoveInternal(aFrame, aProperty, false, aFoundResult);
+    return ReinterpretHelper<T>::FromPointer(ptr);
+  }
+# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+  template<typename T>
+  void Delete(nsIFrame* aFrame, Descriptor<T> aProperty)
+  {
+    DeleteInternal(aFrame, aProperty, false);
+  }
+
+  template<typename T>
+  void DeleteSkippingBitCheck(nsIFrame* aFrame, Descriptor<T> aProperty)
+  {
+    DeleteInternal(aFrame, aProperty, true);
+  }
+
+
+
+
+  void DeleteAllFor(nsIFrame* aFrame);
+
+
+
+  void DeleteAll();
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+protected:
+  void SetInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
+                   void* aValue);
+
+  void* GetInternal(const nsIFrame* aFrame, UntypedDescriptor aProperty,
+                    bool aSkipBitCheck, bool* aFoundResult);
+
+  void* RemoveInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
+                       bool aSkipBitCheck, bool* aFoundResult);
+
+  void DeleteInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
+                      bool aSkipBitCheck);
+
+  template<typename T>
+  struct ReinterpretHelper
+  {
+    static_assert(sizeof(PropertyType<T>) <= sizeof(void*),
+                  "size of the value must never be larger than a pointer");
+
+    static void* ToPointer(PropertyType<T> aValue)
+    {
+      void* ptr = nullptr;
+      memcpy(&ptr, &aValue, sizeof(aValue));
+      return ptr;
+    }
+
+    static PropertyType<T> FromPointer(void* aPtr)
+    {
+      PropertyType<T> value;
+      memcpy(&value, &aPtr, sizeof(value));
+      return value;
+    }
+  };
+
+  template<typename T>
+  struct ReinterpretHelper<T*>
+  {
+    static void* ToPointer(T* aValue)
+    {
+      return static_cast<void*>(aValue);
+    }
+
+    static T* FromPointer(void* aPtr)
+    {
+      return static_cast<T*>(aPtr);
+    }
+  };
+
+
+
+
+
+  struct PropertyValue {
+    PropertyValue() : mProperty(nullptr), mValue(nullptr) {}
+    PropertyValue(UntypedDescriptor aProperty, void* aValue)
+      : mProperty(aProperty), mValue(aValue) {}
+
+    bool IsArray() { return !mProperty && mValue; }
+    nsTArray<PropertyValue>* ToArray()
+    {
+      do { } while(0);
+      return reinterpret_cast<nsTArray<PropertyValue>*>(&mValue);
+    }
+
+    void DestroyValueFor(const nsIFrame* aFrame) {
+      if (mProperty->mDestructor) {
+        mProperty->mDestructor(mValue);
+      } else if (mProperty->mDestructorWithFrame) {
+        mProperty->mDestructorWithFrame(aFrame, mValue);
+      }
+    }
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
+      size_t n = 0;
+
+
+
+
+
+      if (IsArray()) {
+        nsTArray<PropertyValue>* array = ToArray();
+        n += array->ShallowSizeOfExcludingThis(aMallocSizeOf);
+      }
+      return n;
+    }
+
+    UntypedDescriptor mProperty;
+    void* mValue;
+  };
+
+
+
+
+
+  class PropertyComparator {
+  public:
+    bool Equals(const PropertyValue& a, const PropertyValue& b) const {
+      return a.mProperty == b.mProperty;
+    }
+    bool Equals(UntypedDescriptor a, const PropertyValue& b) const {
+      return a == b.mProperty;
+    }
+    bool Equals(const PropertyValue& a, UntypedDescriptor b) const {
+      return a.mProperty == b;
+    }
+  };
+
+
+
+
+
+  class Entry : public nsPtrHashKey<const nsIFrame>
+  {
+  public:
+    explicit Entry(KeyTypePointer aKey) : nsPtrHashKey<const nsIFrame>(aKey) {}
+    Entry(const Entry &toCopy) :
+      nsPtrHashKey<const nsIFrame>(toCopy), mProp(toCopy.mProp) {}
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
+      return mProp.SizeOfExcludingThis(aMallocSizeOf);
+    }
+
+    PropertyValue mProp;
+  };
+
+  static void DeleteAllForEntry(Entry* aEntry);
+
+
+
+
+  nsTHashtable<Entry> mEntries;
+  const nsIFrame* mLastFrame;
+  Entry* mLastEntry;
+};
+# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
+template<class CVnsIFrame>
+class FramePropertiesBase {
+public:
+  template<typename T> using Descriptor = FramePropertyTable::Descriptor<T>;
+  template<typename T> using PropertyType = FramePropertyTable::PropertyType<T>;
+
+  template<typename T>
+  bool Has(Descriptor<T> aProperty) const
+  {
+    return mTable->Has(mFrame, aProperty);
+  }
+
+  template<typename T>
+  PropertyType<T> Get(Descriptor<T> aProperty,
+                      bool* aFoundResult = nullptr) const
+  {
+    return mTable->Get(mFrame, aProperty, aFoundResult);
+  }
+
+protected:
+  FramePropertiesBase(FramePropertyTable* aTable, CVnsIFrame* aFrame)
+    : mTable(aTable), mFrame(aFrame) {}
+
+  FramePropertyTable* const mTable;
+  CVnsIFrame* const mFrame;
+};
+
+class ConstFrameProperties : public FramePropertiesBase<const nsIFrame> {
+public:
+  ConstFrameProperties(FramePropertyTable* aTable, const nsIFrame* aFrame)
+    : FramePropertiesBase(aTable, aFrame)
+  {
+  }
+};
+
+class FrameProperties : public FramePropertiesBase<nsIFrame> {
+public:
+  FrameProperties(FramePropertyTable* aTable, nsIFrame* aFrame)
+    : FramePropertiesBase(aTable, aFrame)
+  {
+  }
+
+  template<typename T>
+  void Set(Descriptor<T> aProperty, PropertyType<T> aValue) const
+  {
+    mTable->Set(mFrame, aProperty, aValue);
+  }
+
+  template<typename T>
+  PropertyType<T> Remove(Descriptor<T> aProperty,
+                         bool* aFoundResult = nullptr) const
+  {
+    return mTable->Remove(mFrame, aProperty, aFoundResult);
+  }
+
+  template<typename T>
+  void Delete(Descriptor<T> aProperty) const
+  {
+    mTable->Delete(mFrame, aProperty);
+  }
+
+};
+
+}
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxRect.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxRect.h"
+struct gfxQuad;
+
+struct gfxMargin : public mozilla::gfx::BaseMargin<gfxFloat, gfxMargin> {
+  typedef mozilla::gfx::BaseMargin<gfxFloat, gfxMargin> Super;
+
+
+  gfxMargin() : Super() {}
+  gfxMargin(const gfxMargin& aMargin) : Super(aMargin) {}
+  gfxMargin(gfxFloat aTop, gfxFloat aRight, gfxFloat aBottom, gfxFloat aLeft)
+    : Super(aTop, aRight, aBottom, aLeft) {}
+};
+
+struct gfxRect :
+    public mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> {
+    typedef mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> Super;
+
+    gfxRect() : Super() {}
+    gfxRect(const gfxPoint& aPos, const gfxSize& aSize) :
+        Super(aPos, aSize) {}
+    gfxRect(gfxFloat aX, gfxFloat aY, gfxFloat aWidth, gfxFloat aHeight) :
+        Super(aX, aY, aWidth, aHeight) {}
+
+
+
+
+
+
+
+    bool WithinEpsilonOfIntegerPixels(gfxFloat aEpsilon) const;
+
+    gfxPoint AtCorner(mozilla::Corner corner) const {
+        switch (corner) {
+            case mozilla::eCornerTopLeft: return TopLeft();
+            case mozilla::eCornerTopRight: return TopRight();
+            case mozilla::eCornerBottomRight: return BottomRight();
+            case mozilla::eCornerBottomLeft: return BottomLeft();
+        }
+        return gfxPoint(0.0, 0.0);
+    }
+
+    gfxPoint CCWCorner(mozilla::Side side) const {
+        switch (side) {
+            case mozilla::eSideTop: return TopLeft();
+            case mozilla::eSideRight: return TopRight();
+            case mozilla::eSideBottom: return BottomRight();
+            case mozilla::eSideLeft: return BottomLeft();
+        }
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "Incomplete switch" ")"); do { *((volatile int*) __null) = 65; ::abort(); } while (0); } while (0);
+    }
+
+    gfxPoint CWCorner(mozilla::Side side) const {
+        switch (side) {
+            case mozilla::eSideTop: return TopRight();
+            case mozilla::eSideRight: return BottomRight();
+            case mozilla::eSideBottom: return BottomLeft();
+            case mozilla::eSideLeft: return TopLeft();
+        }
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "Incomplete switch" ")"); do { *((volatile int*) __null) = 75; ::abort(); } while (0); } while (0);
+    }
+
+
+
+
+
+    void Condition();
+
+    void Scale(gfxFloat k) {
+        do { } while(0);
+        x *= k;
+        y *= k;
+        width *= k;
+        height *= k;
+    }
+
+    void Scale(gfxFloat sx, gfxFloat sy) {
+        do { } while(0);
+        do { } while(0);
+        x *= sx;
+        y *= sy;
+        width *= sx;
+        height *= sy;
+    }
+
+    void ScaleInverse(gfxFloat k) {
+        do { } while(0);
+        x /= k;
+        y /= k;
+        width /= k;
+        height /= k;
+    }
+
+
+
+
+    gfxQuad TransformToQuad(const mozilla::gfx::Matrix4x4 &aMatrix) const;
+};
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prclist.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prclist.h"
+typedef struct PRCListStr PRCList;
+
+
+
+
+struct PRCListStr {
+    PRCList *next;
+    PRCList *prev;
+};
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/MainThreadUtils.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/MainThreadUtils.h"
+class nsIThread;
+
+
+
+
+
+
+
+extern nsresult NS_GetMainThread(nsIThread** aResult);
+
+
+
+
+
+
+extern nsIThread* NS_GetCurrentThread();
+
+
+
+bool NS_IsMainThread();
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h"
+class nsICancelableRunnable : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h"
+  virtual nsresult Cancel() = 0;
+
+protected:
+  nsICancelableRunnable() { }
+  virtual ~nsICancelableRunnable() {}
+};
+
+template<typename T> struct nsICancelableRunnable::COMTypeInfo<nsICancelableRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsICancelableRunnable::COMTypeInfo<nsICancelableRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xde93dc4c, 0x5eea, 0x4eb7, { 0xb6, 0xd1, 0xdb, 0xf1, 0xe0, 0xce, 0xf6, 0x5c } };
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h"
+namespace mozilla {
+class TimeStamp;
+}
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h"
+class nsIIdlePeriod : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetIdlePeriodHint(mozilla::TimeStamp *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIIdlePeriod::COMTypeInfo<nsIIdlePeriod, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIIdlePeriod::COMTypeInfo<nsIIdlePeriod, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x21dd35a2, 0xeae9, 0x4bd8, { 0xb4, 0x70, 0x0d, 0xfa, 0x35, 0xa0, 0xe3, 0xb9 }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIncrementalRunnable.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIncrementalRunnable.h"
+class nsIIncrementalRunnable : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+  virtual void SetDeadline(mozilla::TimeStamp aDeadline) = 0;
+
+protected:
+  nsIIncrementalRunnable() { }
+  virtual ~nsIIncrementalRunnable() {}
+};
+
+template<typename T> struct nsIIncrementalRunnable::COMTypeInfo<nsIIncrementalRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIIncrementalRunnable::COMTypeInfo<nsIIncrementalRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x688be92e, 0x7ade, 0x4fdc, { 0x9d, 0x83, 0x74, 0xcb, 0xef, 0xf4, 0xa5, 0x2c } };
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINamed.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINamed.h"
+class nsINamed : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetName(nsACString & aName) = 0;
+
+
+  virtual nsresult SetName(const char * aName) = 0;
+
+};
+
+  template<typename T> struct nsINamed::COMTypeInfo<nsINamed, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINamed::COMTypeInfo<nsINamed, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0c5fe7de, 0x7e83, 0x4d0d, { 0xa8, 0xa6, 0x4a, 0x65, 0x18, 0xb9, 0xa7, 0xb3 }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h"
+class nsIRunnable : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Run(void) = 0;
+
+};
+
+  template<typename T> struct nsIRunnable::COMTypeInfo<nsIRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRunnable::COMTypeInfo<nsIRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4a2abaf0, 0x6886, 0x11d3, { 0x93, 0x82, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }};
+# 103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h"
+class nsIRunnablePriority : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    PRIORITY_NORMAL = 0U,
+    PRIORITY_HIGH = 1U
+  };
+
+
+  virtual nsresult GetPriority(uint32_t *aPriority) = 0;
+
+};
+
+  template<typename T> struct nsIRunnablePriority::COMTypeInfo<nsIRunnablePriority, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRunnablePriority::COMTypeInfo<nsIRunnablePriority, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xe75aa42a, 0x80a9, 0x11e6, { 0xaf, 0xb5, 0xe8, 0x9d, 0x87, 0x34, 0x8e, 0x2c }};
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h"
+class nsIThread;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h"
+class nsIThreadManager : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    DEFAULT_STACK_SIZE = 0U
+  };
+
+
+  virtual nsresult NewThread(uint32_t creationFlags, uint32_t stackSize, nsIThread * *_retval) = 0;
+
+
+  virtual nsresult NewNamedThread(const nsACString & name, uint32_t stackSize, nsIThread * *_retval) = 0;
+
+
+  virtual nsresult GetThreadFromPRThread(PRThread *prthread, nsIThread * *_retval) = 0;
+
+
+  virtual nsresult GetMainThread(nsIThread * *aMainThread) = 0;
+
+
+  virtual nsresult GetCurrentThread(nsIThread * *aCurrentThread) = 0;
+
+
+  virtual nsresult GetIsMainThread(bool *aIsMainThread) = 0;
+
+};
+
+  template<typename T> struct nsIThreadManager::COMTypeInfo<nsIThreadManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThreadManager::COMTypeInfo<nsIThreadManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x1be89eca, 0xe2f7, 0x453b, { 0x8d, 0x38, 0xc1, 0x1b, 0xa2, 0x47, 0xf6, 0xf3 }};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIEventTarget.h" 1
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIEventTarget.h"
+class nsIEventTarget : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+     nsresult Dispatch(nsIRunnable* aEvent, uint32_t aFlags) {
+      return Dispatch(nsCOMPtr<nsIRunnable>(aEvent).forget(), aFlags);
+    }
+  enum {
+    DISPATCH_NORMAL = 0U,
+    DISPATCH_SYNC = 1U,
+    DISPATCH_AT_END = 2U
+  };
+
+
+  virtual nsresult IsOnCurrentThread(bool *_retval) = 0;
+
+
+  virtual nsresult Dispatch(already_AddRefed<nsIRunnable> event, uint32_t flags) = 0;
+
+
+  virtual nsresult DispatchFromScript(nsIRunnable *event, uint32_t flags) = 0;
+
+
+  virtual nsresult DelayedDispatch(already_AddRefed<nsIRunnable> event, uint32_t delay) = 0;
+
+};
+
+  template<typename T> struct nsIEventTarget::COMTypeInfo<nsIEventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIEventTarget::COMTypeInfo<nsIEventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x88145945, 0x3278, 0x424e, { 0x9f, 0x37, 0xd8, 0x74, 0xcb, 0xdd, 0x9f, 0x6f }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h" 2
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h"
+class nsIThread : public nsIEventTarget {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetPRThread(PRThread **aPRThread) = 0;
+
+
+  virtual nsresult GetCanInvokeJS(bool *aCanInvokeJS) = 0;
+  virtual nsresult SetCanInvokeJS(bool aCanInvokeJS) = 0;
+
+
+  virtual nsresult Shutdown(void) = 0;
+
+
+  virtual nsresult HasPendingEvents(bool *_retval) = 0;
+
+
+  virtual nsresult ProcessNextEvent(bool mayWait, bool *_retval) = 0;
+
+
+  virtual nsresult AsyncShutdown(void) = 0;
+
+
+  virtual nsresult RegisterIdlePeriod(already_AddRefed<nsIIdlePeriod> aIdlePeriod) = 0;
+
+
+  virtual nsresult IdleDispatch(already_AddRefed<nsIRunnable> event) = 0;
+
+};
+
+  template<typename T> struct nsIThread::COMTypeInfo<nsIThread, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThread::COMTypeInfo<nsIThread, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5801d193, 0x29d1, 0x4964, { 0xa6, 0xb7, 0x70, 0xeb, 0x69, 0x7d, 0xdf, 0x2b }};
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h" 1
+# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h" 2
+
+namespace mozilla {
+
+
+
+
+template<size_t... Indices>
+struct IndexSequence
+{
+  static constexpr size_t Size() { return sizeof...(Indices); }
+};
+
+namespace detail {
+
+
+
+template<size_t... Indices>
+struct IndexTuple
+{
+  typedef IndexTuple<Indices..., sizeof...(Indices)> Next;
+};
+
+
+template<size_t N>
+struct BuildIndexTuple
+{
+  typedef typename BuildIndexTuple<N - 1>::Type::Next Type;
+};
+
+template<>
+struct BuildIndexTuple<0>
+{
+  typedef IndexTuple<> Type;
+};
+
+template<size_t N, typename IndexTuple>
+struct MakeIndexSequenceImpl;
+
+template<size_t N, size_t... Indices>
+struct MakeIndexSequenceImpl<N, IndexTuple<Indices...>>
+{
+  typedef IndexSequence<Indices...> Type;
+};
+
+}
+
+
+
+
+
+
+
+template<size_t N>
+struct MakeIndexSequence
+{
+  typedef typename detail::MakeIndexSequenceImpl<N,
+    typename detail::BuildIndexTuple<N>::Type>::Type Type;
+};
+# 135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h"
+template<typename... Types>
+struct IndexSequenceFor
+{
+  typedef typename MakeIndexSequence<sizeof...(Types)>::Type Type;
+};
+
+}
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h" 2
+
+
+namespace mozilla {
+
+namespace detail {
+
+
+
+
+
+template<typename... Ts>
+struct Group;
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<typename Source, typename Target, bool SameSize>
+struct CheckConvertibilityImpl;
+
+template<typename Source, typename Target>
+struct CheckConvertibilityImpl<Source, Target, false>
+  : FalseType {};
+
+template<typename... SourceTypes, typename... TargetTypes>
+struct CheckConvertibilityImpl<Group<SourceTypes...>, Group<TargetTypes...>, true>
+  : IntegralConstant<bool, tl::And<IsConvertible<SourceTypes, TargetTypes>::value...>::value> { };
+
+template<typename Source, typename Target>
+struct CheckConvertibility;
+
+template<typename... SourceTypes, typename... TargetTypes>
+struct CheckConvertibility<Group<SourceTypes...>, Group<TargetTypes...>>
+  : CheckConvertibilityImpl<Group<SourceTypes...>, Group<TargetTypes...>,
+        sizeof...(SourceTypes) == sizeof...(TargetTypes)> { };
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<std::size_t Index, typename... Elements>
+struct TupleImpl;
+
+
+
+
+
+template<std::size_t Index>
+struct TupleImpl<Index> {
+  bool operator==(const TupleImpl<Index>& aOther) const
+  {
+    return true;
+  }
+};
+
+
+
+
+
+
+template<std::size_t Index, typename HeadT, typename... TailT>
+struct TupleImpl<Index, HeadT, TailT...>
+  : public TupleImpl<Index + 1, TailT...>
+{
+  typedef TupleImpl<Index + 1, TailT...> Base;
+
+
+
+
+
+
+  static HeadT& Head(TupleImpl& aTuple) { return aTuple.mHead; }
+  static const HeadT& Head(const TupleImpl& aTuple) { return aTuple.mHead; }
+  static Base& Tail(TupleImpl& aTuple) { return aTuple; }
+  static const Base& Tail(const TupleImpl& aTuple) { return aTuple; }
+
+  TupleImpl() : Base(), mHead() { }
+
+
+  explicit TupleImpl(const HeadT& aHead, const TailT&... aTail)
+    : Base(aTail...), mHead(aHead) { }
+
+
+
+
+
+  template <typename OtherHeadT, typename... OtherTailT,
+            typename = typename EnableIf<
+                CheckConvertibility<
+                    Group<OtherHeadT, OtherTailT...>,
+                    Group<HeadT, TailT...>>::value>::Type>
+  explicit TupleImpl(OtherHeadT&& aHead, OtherTailT&&... aTail)
+    : Base(Forward<OtherTailT>(aTail)...), mHead(Forward<OtherHeadT>(aHead)) { }
+
+
+
+
+  TupleImpl(const TupleImpl& aOther)
+    : Base(Tail(aOther))
+    , mHead(Head(aOther)) {}
+  TupleImpl(TupleImpl&& aOther)
+    : Base(Move(Tail(aOther)))
+    , mHead(Forward<HeadT>(Head(aOther))) {}
+
+
+
+  template <typename... OtherElements,
+            typename = typename EnableIf<
+                sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
+  TupleImpl& operator=(const TupleImpl<Index, OtherElements...>& aOther)
+  {
+    typedef TupleImpl<Index, OtherElements...> OtherT;
+    Head(*this) = OtherT::Head(aOther);
+    Tail(*this) = OtherT::Tail(aOther);
+    return *this;
+  }
+  template <typename... OtherElements,
+            typename = typename EnableIf<
+                sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
+  TupleImpl& operator=(TupleImpl<Index, OtherElements...>&& aOther)
+  {
+    typedef TupleImpl<Index, OtherElements...> OtherT;
+    Head(*this) = Move(OtherT::Head(aOther));
+    Tail(*this) = Move(OtherT::Tail(aOther));
+    return *this;
+  }
+
+
+  TupleImpl& operator=(const TupleImpl& aOther)
+  {
+    Head(*this) = Head(aOther);
+    Tail(*this) = Tail(aOther);
+    return *this;
+  }
+  TupleImpl& operator=(TupleImpl&& aOther)
+  {
+    Head(*this) = Move(Head(aOther));
+    Tail(*this) = Move(Tail(aOther));
+    return *this;
+  }
+  bool operator==(const TupleImpl& aOther) const
+  {
+    return Head(*this) == Head(aOther) && Tail(*this) == Tail(aOther);
+  }
+private:
+  HeadT mHead;
+};
+
+}
+# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<typename... Elements>
+class Tuple : public detail::TupleImpl<0, Elements...>
+{
+  typedef detail::TupleImpl<0, Elements...> Impl;
+public:
+
+
+
+  Tuple() : Impl() { }
+  explicit Tuple(const Elements&... aElements) : Impl(aElements...) { }
+
+
+
+
+  template <typename OtherHead, typename... OtherTail,
+            typename = typename EnableIf<
+                detail::CheckConvertibility<
+                    detail::Group<OtherHead, OtherTail...>,
+                    detail::Group<Elements...>>::value>::Type>
+  explicit Tuple(OtherHead&& aHead, OtherTail&&... aTail)
+    : Impl(Forward<OtherHead>(aHead), Forward<OtherTail>(aTail)...) { }
+  Tuple(const Tuple& aOther) : Impl(aOther) { }
+  Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
+
+  template <typename... OtherElements,
+            typename = typename EnableIf<
+                sizeof...(OtherElements) == sizeof...(Elements)>::Type>
+  Tuple& operator=(const Tuple<OtherElements...>& aOther)
+  {
+    static_cast<Impl&>(*this) = aOther;
+    return *this;
+  }
+  template <typename... OtherElements,
+            typename = typename EnableIf<
+                sizeof...(OtherElements) == sizeof...(Elements)>::Type>
+  Tuple& operator=(Tuple<OtherElements...>&& aOther)
+  {
+    static_cast<Impl&>(*this) = Move(aOther);
+    return *this;
+  }
+  Tuple& operator=(const Tuple& aOther)
+  {
+    static_cast<Impl&>(*this) = aOther;
+    return *this;
+  }
+  Tuple& operator=(Tuple&& aOther)
+  {
+    static_cast<Impl&>(*this) = Move(aOther);
+    return *this;
+  }
+  bool operator==(const Tuple& aOther) const
+  {
+    return static_cast<const Impl&>(*this) == static_cast<const Impl&>(aOther);
+  }
+};
+
+
+
+
+
+template <typename A, typename B>
+class Tuple<A, B> : public detail::TupleImpl<0, A, B>
+{
+  typedef detail::TupleImpl<0, A, B> Impl;
+
+public:
+
+
+
+  Tuple() : Impl() { }
+  explicit Tuple(const A& aA, const B& aB) : Impl(aA, aB) { }
+  template <typename AArg, typename BArg,
+            typename = typename EnableIf<
+                detail::CheckConvertibility<
+                    detail::Group<AArg, BArg>,
+                    detail::Group<A, B>>::value>::Type>
+  explicit Tuple(AArg&& aA, BArg&& aB)
+    : Impl(Forward<AArg>(aA), Forward<BArg>(aB)) { }
+  Tuple(const Tuple& aOther) : Impl(aOther) { }
+  Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
+  explicit Tuple(const Pair<A, B>& aOther)
+    : Impl(aOther.first(), aOther.second()) { }
+  explicit Tuple(Pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first()),
+                                    Forward<B>(aOther.second())) { }
+  explicit Tuple(const std::pair<A, B>& aOther)
+    : Impl(aOther.first, aOther.second) { }
+  explicit Tuple(std::pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first),
+                                    Forward<B>(aOther.second)) { }
+
+  template <typename AArg, typename BArg>
+  Tuple& operator=(const Tuple<AArg, BArg>& aOther)
+  {
+    static_cast<Impl&>(*this) = aOther;
+    return *this;
+  }
+  template <typename AArg, typename BArg>
+  Tuple& operator=(Tuple<AArg, BArg>&& aOther)
+  {
+    static_cast<Impl&>(*this) = Move(aOther);
+    return *this;
+  }
+  Tuple& operator=(const Tuple& aOther)
+  {
+    static_cast<Impl&>(*this) = aOther;
+    return *this;
+  }
+  Tuple& operator=(Tuple&& aOther)
+  {
+    static_cast<Impl&>(*this) = Move(aOther);
+    return *this;
+  }
+  template <typename AArg, typename BArg>
+  Tuple& operator=(const Pair<AArg, BArg>& aOther)
+  {
+    Impl::Head(*this) = aOther.first();
+    Impl::Tail(*this).Head(*this) = aOther.second();
+    return *this;
+  }
+  template <typename AArg, typename BArg>
+  Tuple& operator=(Pair<AArg, BArg>&& aOther)
+  {
+    Impl::Head(*this) = Forward<AArg>(aOther.first());
+    Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second());
+    return *this;
+  }
+  template <typename AArg, typename BArg>
+  Tuple& operator=(const std::pair<AArg, BArg>& aOther)
+  {
+    Impl::Head(*this) = aOther.first;
+    Impl::Tail(*this).Head(*this) = aOther.second;
+    return *this;
+  }
+  template <typename AArg, typename BArg>
+  Tuple& operator=(std::pair<AArg, BArg>&& aOther)
+  {
+    Impl::Head(*this) = Forward<AArg>(aOther.first);
+    Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second);
+    return *this;
+  }
+};
+
+
+
+
+
+
+
+template <>
+class Tuple<> {};
+
+namespace detail {
+# 369 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<std::size_t Index, typename... Elements>
+auto TupleGetHelper(TupleImpl<Index, Elements...>& aTuple)
+    -> decltype(TupleImpl<Index, Elements...>::Head(aTuple))
+{
+  return TupleImpl<Index, Elements...>::Head(aTuple);
+}
+
+
+template<std::size_t Index, typename... Elements>
+auto TupleGetHelper(const TupleImpl<Index, Elements...>& aTuple)
+    -> decltype(TupleImpl<Index, Elements...>::Head(aTuple))
+{
+  return TupleImpl<Index, Elements...>::Head(aTuple);
+}
+
+}
+# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<std::size_t Index, typename... Elements>
+auto Get(Tuple<Elements...>& aTuple)
+    -> decltype(detail::TupleGetHelper<Index>(aTuple))
+{
+  return detail::TupleGetHelper<Index>(aTuple);
+}
+
+
+template<std::size_t Index, typename... Elements>
+auto Get(const Tuple<Elements...>& aTuple)
+    -> decltype(detail::TupleGetHelper<Index>(aTuple))
+{
+  return detail::TupleGetHelper<Index>(aTuple);
+}
+
+
+template<std::size_t Index, typename... Elements>
+auto Get(Tuple<Elements...>&& aTuple)
+    -> decltype(Move(mozilla::Get<Index>(aTuple)))
+{
+
+
+  return Move(mozilla::Get<Index>(aTuple));
+}
+# 432 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<typename... Elements>
+inline Tuple<typename Decay<Elements>::Type...>
+MakeTuple(Elements&&... aElements)
+{
+  return Tuple<typename Decay<Elements>::Type...>(Forward<Elements>(aElements)...);
+}
+# 452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
+template<typename... Elements>
+inline Tuple<Elements&...>
+Tie(Elements&... aVariables)
+{
+  return Tuple<Elements&...>(aVariables...);
+}
+
+}
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern nsresult
+NS_NewThread(nsIThread** aResult,
+             nsIRunnable* aInitialEvent = nullptr,
+             uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE);
+
+
+
+
+extern nsresult
+NS_NewNamedThread(const nsACString& aName,
+                  nsIThread** aResult,
+                  nsIRunnable* aInitialEvent = nullptr,
+                  uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE);
+
+template<size_t LEN>
+inline nsresult
+NS_NewNamedThread(const char (&aName)[LEN],
+                  nsIThread** aResult,
+                  nsIRunnable* aInitialEvent = nullptr,
+                  uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE)
+{
+  static_assert(LEN <= 16,
+                "Thread name must be no more than 16 characters");
+  return NS_NewNamedThread(nsDependentCString(aName, LEN - 1),
+                           aResult, aInitialEvent, aStackSize);
+}
+
+
+
+
+
+
+
+extern nsresult NS_GetCurrentThread(nsIThread** aResult);
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern nsresult NS_DispatchToCurrentThread(nsIRunnable* aEvent);
+extern nsresult
+NS_DispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent);
+# 107 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern nsresult
+NS_DispatchToMainThread(nsIRunnable* aEvent,
+                        uint32_t aDispatchFlags = nsIEventTarget::DISPATCH_NORMAL);
+extern nsresult
+NS_DispatchToMainThread(already_AddRefed<nsIRunnable>&& aEvent,
+                        uint32_t aDispatchFlags = nsIEventTarget::DISPATCH_NORMAL);
+
+extern nsresult
+NS_DelayedDispatchToCurrentThread(
+  already_AddRefed<nsIRunnable>&& aEvent, uint32_t aDelayMs);
+
+extern nsresult
+NS_IdleDispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent);
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern nsresult
+NS_ProcessPendingEvents(nsIThread* aThread,
+                        PRIntervalTime aTimeout = 0xffffffffUL);
+# 156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern bool NS_HasPendingEvents(nsIThread* aThread = nullptr);
+# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern bool NS_ProcessNextEvent(nsIThread* aThread = nullptr,
+                                bool aMayWait = true);
+# 185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern bool NS_IsInCompositorThread();
+
+
+
+
+inline already_AddRefed<nsIThread>
+do_GetCurrentThread()
+{
+  nsIThread* thread = nullptr;
+  NS_GetCurrentThread(&thread);
+  return already_AddRefed<nsIThread>(thread);
+}
+
+inline already_AddRefed<nsIThread>
+do_GetMainThread()
+{
+  nsIThread* thread = nullptr;
+  NS_GetMainThread(&thread);
+  return already_AddRefed<nsIThread>(thread);
+}
+# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+extern nsIThread* NS_GetCurrentThread();
+
+
+
+
+
+
+namespace mozilla {
+
+
+class IdlePeriod : public nsIIdlePeriod
+{
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+  virtual nsresult GetIdlePeriodHint(mozilla::TimeStamp *_retval) override;
+
+  IdlePeriod() {}
+
+protected:
+  virtual ~IdlePeriod() {}
+private:
+  IdlePeriod(const IdlePeriod&) = delete;
+  IdlePeriod& operator=(const IdlePeriod&) = delete;
+  IdlePeriod& operator=(const IdlePeriod&&) = delete;
+};
+
+
+class Runnable : public nsIRunnable, public nsINamed
+{
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+  virtual nsresult Run(void) override;
+  virtual nsresult GetName(nsACString & aName) override; virtual nsresult SetName(const char * aName) override;
+
+  Runnable() {}
+
+
+
+
+  explicit Runnable(const char* aName) : mName(aName) {}
+
+
+protected:
+  virtual ~Runnable() {}
+private:
+  Runnable(const Runnable&) = delete;
+  Runnable& operator=(const Runnable&) = delete;
+  Runnable& operator=(const Runnable&&) = delete;
+
+
+  const char* mName = nullptr;
+
+};
+
+
+class CancelableRunnable : public Runnable,
+                           public nsICancelableRunnable
+{
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
+
+  virtual nsresult Cancel() override;
+
+  CancelableRunnable() {}
+  explicit CancelableRunnable(const char* aName) : Runnable(aName) {}
+
+protected:
+  virtual ~CancelableRunnable() {}
+private:
+  CancelableRunnable(const CancelableRunnable&) = delete;
+  CancelableRunnable& operator=(const CancelableRunnable&) = delete;
+  CancelableRunnable& operator=(const CancelableRunnable&&) = delete;
+};
+
+
+class IncrementalRunnable : public CancelableRunnable,
+                            public nsIIncrementalRunnable
+{
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
+
+  virtual void SetDeadline(TimeStamp aDeadline) override;
+
+  IncrementalRunnable() {}
+
+protected:
+  virtual ~IncrementalRunnable() {}
+private:
+  IncrementalRunnable(const IncrementalRunnable&) = delete;
+  IncrementalRunnable& operator=(const IncrementalRunnable&) = delete;
+  IncrementalRunnable& operator=(const IncrementalRunnable&&) = delete;
+};
+
+namespace detail {
+
+
+
+
+template<typename StoredFunction>
+class RunnableFunction : public Runnable
+{
+public:
+  template <typename F>
+  explicit RunnableFunction(F&& aFunction)
+    : mFunction(Forward<F>(aFunction))
+  { }
+
+  virtual nsresult Run() override {
+    static_assert(IsVoid<decltype(mFunction())>::value,
+                  "The lambda must return void!");
+    mFunction();
+    return NS_OK;
+  }
+private:
+  StoredFunction mFunction;
+};
+
+
+template<typename Function>
+using RunnableFunctionImpl =
+
+  typename detail::RunnableFunction<typename RemoveReference<Function>::Type>;
+
+template <typename T>
+inline already_AddRefed<T>
+SetRunnableName(already_AddRefed<T>&& aObj, const char* aName)
+{
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(aName)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aName))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aName" ")"); do { *((volatile int*) __null) = 340; ::abort(); } while (0); } } while (0);
+  RefPtr<T> ref(aObj);
+  ref->SetName(aName);
+  return ref.forget();
+}
+
+}
+
+namespace detail {
+
+template<typename CVRemoved>
+struct IsRefcountedSmartPointerHelper : FalseType {};
+
+template<typename Pointee>
+struct IsRefcountedSmartPointerHelper<RefPtr<Pointee>> : TrueType {};
+
+template<typename Pointee>
+struct IsRefcountedSmartPointerHelper<nsCOMPtr<Pointee>> : TrueType {};
+
+}
+
+template<typename T>
+struct IsRefcountedSmartPointer
+  : detail::IsRefcountedSmartPointerHelper<typename RemoveCV<T>::Type>
+{};
+
+namespace detail {
+
+template<typename T, typename CVRemoved>
+struct RemoveSmartPointerHelper
+{
+  typedef T Type;
+};
+
+template<typename T, typename Pointee>
+struct RemoveSmartPointerHelper<T, RefPtr<Pointee>>
+{
+  typedef Pointee Type;
+};
+
+template<typename T, typename Pointee>
+struct RemoveSmartPointerHelper<T, nsCOMPtr<Pointee>>
+{
+  typedef Pointee Type;
+};
+
+}
+
+template<typename T>
+struct RemoveSmartPointer
+  : detail::RemoveSmartPointerHelper<T, typename RemoveCV<T>::Type>
+{};
+
+namespace detail {
+
+template<typename T, typename CVRemoved>
+struct RemoveRawOrSmartPointerHelper
+{
+  typedef T Type;
+};
+
+template<typename T, typename Pointee>
+struct RemoveRawOrSmartPointerHelper<T, Pointee*>
+{
+  typedef Pointee Type;
+};
+
+template<typename T, typename Pointee>
+struct RemoveRawOrSmartPointerHelper<T, RefPtr<Pointee>>
+{
+  typedef Pointee Type;
+};
+
+template<typename T, typename Pointee>
+struct RemoveRawOrSmartPointerHelper<T, nsCOMPtr<Pointee>>
+{
+  typedef Pointee Type;
+};
+
+}
+
+template<typename T>
+struct RemoveRawOrSmartPointer
+  : detail::RemoveRawOrSmartPointerHelper<T, typename RemoveCV<T>::Type>
+{};
+
+}
+
+inline nsISupports*
+ToSupports(mozilla::Runnable *p)
+{
+  return static_cast<nsIRunnable*>(p);
+}
+
+template<typename Function>
+already_AddRefed<mozilla::Runnable>
+NS_NewRunnableFunction(Function&& aFunction)
+{
+
+
+  return do_AddRef(new mozilla::detail::RunnableFunctionImpl<Function>
+    (mozilla::Forward<Function>(aFunction)));
+}
+
+template<typename Function>
+already_AddRefed<mozilla::Runnable>
+NS_NewRunnableFunction(const char* aName, Function&& aFunction)
+{
+  return mozilla::detail::SetRunnableName(
+    NS_NewRunnableFunction(mozilla::Forward<Function>(aFunction)), aName);
+}
+
+
+
+
+template<class ClassType,
+         typename ReturnType = void,
+         bool Owning = true,
+         bool Cancelable = false>
+class nsRunnableMethod : public mozilla::Conditional<!Cancelable,
+                                                     mozilla::Runnable,
+                                                     mozilla::CancelableRunnable>::Type
+{
+public:
+  virtual void Revoke() = 0;
+
+
+
+
+  template<typename OtherReturnType>
+  class ReturnTypeEnforcer
+  {
+  public:
+    typedef int ReturnTypeIsSafe;
+  };
+
+  template<class T>
+  class ReturnTypeEnforcer<already_AddRefed<T>>
+  {
+
+  };
+
+
+  typedef typename ReturnTypeEnforcer<ReturnType>::ReturnTypeIsSafe check;
+};
+
+template<class ClassType, bool Owning>
+struct nsRunnableMethodReceiver
+{
+  RefPtr<ClassType> mObj;
+  explicit nsRunnableMethodReceiver(ClassType* aObj) : mObj(aObj) {}
+  ~nsRunnableMethodReceiver() { Revoke(); }
+  ClassType* Get() const { return mObj.get(); }
+  void Revoke() { mObj = nullptr; }
+};
+
+template<class ClassType>
+struct nsRunnableMethodReceiver<ClassType, false>
+{
+  ClassType* mObj;
+  explicit nsRunnableMethodReceiver(ClassType* aObj) : mObj(aObj) {}
+  ClassType* Get() const { return mObj; }
+  void Revoke() { mObj = nullptr; }
+};
+
+template<typename PtrType, typename Method, bool Owning, bool Cancelable>
+struct nsRunnableMethodTraits;
+
+template<typename PtrType, class C, typename R, bool Owning, bool Cancelable, typename... As>
+struct nsRunnableMethodTraits<PtrType, R(C::*)(As...), Owning, Cancelable>
+{
+  typedef typename mozilla::RemoveRawOrSmartPointer<PtrType>::Type class_type;
+  static_assert(mozilla::IsBaseOf<C, class_type>::value,
+                "Stored class must inherit from method's class");
+  typedef R return_type;
+  typedef nsRunnableMethod<C, R, Owning, Cancelable> base_type;
+  static const bool can_cancel = Cancelable;
+};
+
+template<typename PtrType, class C, typename R, bool Owning, bool Cancelable, typename... As>
+struct nsRunnableMethodTraits<PtrType, R(C::*)(As...) const, Owning, Cancelable>
+{
+  typedef const typename mozilla::RemoveRawOrSmartPointer<PtrType>::Type class_type;
+  static_assert(mozilla::IsBaseOf<C, class_type>::value,
+                "Stored class must inherit from method's class");
+  typedef R return_type;
+  typedef nsRunnableMethod<C, R, Owning, Cancelable> base_type;
+  static const bool can_cancel = Cancelable;
+};
+# 582 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+template<typename T>
+struct IsParameterStorageClass : public mozilla::FalseType {};
+
+
+
+
+template<typename T>
+struct StoreCopyPassByValue
+{
+  typedef T stored_type;
+  typedef T passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByValue(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByValue<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreCopyPassByConstLRef
+{
+  typedef T stored_type;
+  typedef const T& passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByConstLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByConstLRef<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreCopyPassByLRef
+{
+  typedef T stored_type;
+  typedef T& passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByLRef<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreCopyPassByRRef
+{
+  typedef T stored_type;
+  typedef T&& passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByRRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return mozilla::Move(m); }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByRRef<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreRefPassByLRef
+{
+  typedef T& stored_type;
+  typedef T& passed_type;
+  stored_type m;
+  template <typename A>
+               StoreRefPassByLRef(A& a) : m(a) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreRefPassByLRef<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreConstRefPassByConstLRef
+{
+  typedef const T& stored_type;
+  typedef const T& passed_type;
+  stored_type m;
+  template <typename A>
+               StoreConstRefPassByConstLRef(const A& a) : m(a) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreConstRefPassByConstLRef<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreRefPtrPassByPtr
+{
+  typedef RefPtr<T> stored_type;
+  typedef T* passed_type;
+  stored_type m;
+  template <typename A>
+               StoreRefPtrPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return m.get(); }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreRefPtrPassByPtr<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StorePtrPassByPtr
+{
+  typedef T* stored_type;
+  typedef T* passed_type;
+  stored_type m;
+  template <typename A>
+               StorePtrPassByPtr(A a) : m(a) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StorePtrPassByPtr<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreConstPtrPassByConstPtr
+{
+  typedef const T* stored_type;
+  typedef const T* passed_type;
+  stored_type m;
+  template <typename A>
+               StoreConstPtrPassByConstPtr(A a) : m(a) {}
+  passed_type PassAsParameter() { return m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreConstPtrPassByConstPtr<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreCopyPassByConstPtr
+{
+  typedef T stored_type;
+  typedef const T* passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByConstPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return &m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByConstPtr<S>>
+  : public mozilla::TrueType {};
+
+template<typename T>
+struct StoreCopyPassByPtr
+{
+  typedef T stored_type;
+  typedef T* passed_type;
+  stored_type m;
+  template <typename A>
+               StoreCopyPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+  passed_type PassAsParameter() { return &m; }
+};
+template<typename S>
+struct IsParameterStorageClass<StoreCopyPassByPtr<S>>
+  : public mozilla::TrueType {};
+
+namespace detail {
+
+template<typename>
+struct SFINAE1True : mozilla::TrueType
+{};
+
+template<class T>
+static auto HasRefCountMethodsTest(int)
+    -> SFINAE1True<decltype(mozilla::DeclVal<T>().AddRef(),
+                            mozilla::DeclVal<T>().Release())>;
+template<class>
+static auto HasRefCountMethodsTest(long) -> mozilla::FalseType;
+
+template<class T>
+struct HasRefCountMethods : decltype(HasRefCountMethodsTest<T>(0))
+{};
+
+template<typename TWithoutPointer>
+struct NonnsISupportsPointerStorageClass
+  : mozilla::Conditional<mozilla::IsConst<TWithoutPointer>::value,
+                         StoreConstPtrPassByConstPtr<
+                           typename mozilla::RemoveConst<TWithoutPointer>::Type>,
+                         StorePtrPassByPtr<TWithoutPointer>>
+{};
+
+template<typename TWithoutPointer>
+struct PointerStorageClass
+  : mozilla::Conditional<HasRefCountMethods<TWithoutPointer>::value,
+                         StoreRefPtrPassByPtr<TWithoutPointer>,
+                         typename NonnsISupportsPointerStorageClass<
+                           TWithoutPointer
+                         >::Type>
+{};
+
+template<typename TWithoutRef>
+struct LValueReferenceStorageClass
+  : mozilla::Conditional<mozilla::IsConst<TWithoutRef>::value,
+                         StoreConstRefPassByConstLRef<
+                           typename mozilla::RemoveConst<TWithoutRef>::Type>,
+                         StoreRefPassByLRef<TWithoutRef>>
+{};
+
+template<typename T>
+struct SmartPointerStorageClass
+  : mozilla::Conditional<mozilla::IsRefcountedSmartPointer<T>::value,
+                         StoreRefPtrPassByPtr<
+                           typename mozilla::RemoveSmartPointer<T>::Type>,
+                         StoreCopyPassByConstLRef<T>>
+{};
+
+template<typename T>
+struct NonLValueReferenceStorageClass
+  : mozilla::Conditional<mozilla::IsRvalueReference<T>::value,
+                         StoreCopyPassByRRef<
+                           typename mozilla::RemoveReference<T>::Type>,
+                         typename SmartPointerStorageClass<T>::Type>
+{};
+
+template<typename T>
+struct NonPointerStorageClass
+  : mozilla::Conditional<mozilla::IsLvalueReference<T>::value,
+                         typename LValueReferenceStorageClass<
+                           typename mozilla::RemoveReference<T>::Type
+                         >::Type,
+                         typename NonLValueReferenceStorageClass<T>::Type>
+{};
+
+template<typename T>
+struct NonParameterStorageClass
+  : mozilla::Conditional<mozilla::IsPointer<T>::value,
+                         typename PointerStorageClass<
+                           typename mozilla::RemovePointer<T>::Type
+                         >::Type,
+                         typename NonPointerStorageClass<T>::Type>
+{};
+# 837 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+template<typename T>
+struct ParameterStorage
+  : mozilla::Conditional<IsParameterStorageClass<T>::value,
+                         T,
+                         typename NonParameterStorageClass<T>::Type>
+{};
+
+}
+
+namespace mozilla {
+
+namespace detail {
+
+
+template <typename... Ts>
+struct RunnableMethodArguments final
+{
+  Tuple<typename ::detail::ParameterStorage<Ts>::Type...> mArguments;
+  template <typename... As>
+  explicit RunnableMethodArguments(As&&... aArguments)
+    : mArguments(Forward<As>(aArguments)...)
+  {}
+  template<typename C, typename M, typename... Args, size_t... Indices>
+  static auto
+  applyImpl(C* o, M m, Tuple<Args...>& args, IndexSequence<Indices...>)
+      -> decltype(((*o).*m)(Get<Indices>(args).PassAsParameter()...))
+  {
+    return ((*o).*m)(Get<Indices>(args).PassAsParameter()...);
+  }
+  template<class C, typename M> auto apply(C* o, M m)
+      -> decltype(applyImpl(o, m, mArguments,
+                  typename IndexSequenceFor<Ts...>::Type()))
+  {
+    return applyImpl(o, m, mArguments,
+        typename IndexSequenceFor<Ts...>::Type());
+  }
+};
+
+template<typename PtrType, typename Method, bool Owning, bool Cancelable, typename... Storages>
+class RunnableMethodImpl final
+  : public ::nsRunnableMethodTraits<PtrType, Method, Owning, Cancelable>::base_type
+{
+  typedef typename ::nsRunnableMethodTraits<PtrType, Method, Owning, Cancelable>::class_type
+      ClassType;
+  ::nsRunnableMethodReceiver<ClassType, Owning> mReceiver;
+  Method mMethod;
+  RunnableMethodArguments<Storages...> mArgs;
+private:
+  virtual ~RunnableMethodImpl() { Revoke(); };
+public:
+  template<typename ForwardedPtrType, typename... Args>
+  explicit RunnableMethodImpl(ForwardedPtrType&& aObj, Method aMethod,
+                              Args&&... aArgs)
+    : mReceiver(Forward<ForwardedPtrType>(aObj))
+    , mMethod(aMethod)
+    , mArgs(Forward<Args>(aArgs)...)
+  {
+    static_assert(sizeof...(Storages) == sizeof...(Args), "Storages and Args should have equal sizes");
+  }
+  virtual nsresult Run()
+  {
+    if ((__builtin_expect(!!(mReceiver.Get()), 1))) {
+      mArgs.apply(mReceiver.Get(), mMethod);
+    }
+    return NS_OK;
+  }
+  nsresult Cancel() {
+    static_assert(Cancelable, "Don't use me!");
+    Revoke();
+    return NS_OK;
+  }
+  void Revoke() { mReceiver.Revoke(); }
+};
+
+
+template<typename PtrType, typename Method>
+using OwningRunnableMethod = typename ::nsRunnableMethodTraits<
+  typename RemoveReference<PtrType>::Type, Method, true, false>::base_type;
+template<typename PtrType, typename Method, typename... Storages>
+using OwningRunnableMethodImpl = RunnableMethodImpl<
+  typename RemoveReference<PtrType>::Type, Method, true, false, Storages...>;
+
+
+template<typename PtrType, typename Method>
+using CancelableRunnableMethod = typename ::nsRunnableMethodTraits<
+  typename RemoveReference<PtrType>::Type, Method, true, true>::base_type;
+template<typename PtrType, typename Method, typename... Storages>
+using CancelableRunnableMethodImpl = RunnableMethodImpl<
+  typename RemoveReference<PtrType>::Type, Method, true, true, Storages...>;
+
+
+template<typename PtrType, typename Method>
+using NonOwningRunnableMethod = typename ::nsRunnableMethodTraits<
+  typename RemoveReference<PtrType>::Type, Method, false, false>::base_type;
+template<typename PtrType, typename Method, typename... Storages>
+using NonOwningRunnableMethodImpl = RunnableMethodImpl<
+  typename RemoveReference<PtrType>::Type, Method, false, false, Storages...>;
+
+
+template<typename PtrType, typename Method>
+using NonOwningCancelableRunnableMethod = typename ::nsRunnableMethodTraits<
+  typename RemoveReference<PtrType>::Type, Method, false, true>::base_type;
+template<typename PtrType, typename Method, typename... Storages>
+using NonOwningCancelableRunnableMethodImpl = RunnableMethodImpl<
+  typename RemoveReference<PtrType>::Type, Method, false, true, Storages...>;
+
+}
+# 1031 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+template<typename PtrType, typename Method>
+already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
+NewRunnableMethod(PtrType&& aPtr, Method aMethod)
+{
+  return do_AddRef(
+    new detail::OwningRunnableMethodImpl<PtrType, Method>
+      (Forward<PtrType>(aPtr), aMethod));
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
+NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
+{
+  return detail::SetRunnableName(
+    NewRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
+NewCancelableRunnableMethod(PtrType&& aPtr, Method aMethod)
+{
+  return do_AddRef(
+    new detail::CancelableRunnableMethodImpl<PtrType, Method>
+      (Forward<PtrType>(aPtr), aMethod));
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
+NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
+{
+  return detail::SetRunnableName(
+    NewCancelableRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
+NewNonOwningRunnableMethod(PtrType&& aPtr, Method aMethod)
+{
+  return do_AddRef(
+    new detail::NonOwningRunnableMethodImpl<PtrType, Method>
+      (Forward<PtrType>(aPtr), aMethod));
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
+NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
+{
+  return detail::SetRunnableName(
+    NewNonOwningRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
+NewNonOwningCancelableRunnableMethod(PtrType&& aPtr, Method aMethod)
+{
+  return do_AddRef(
+    new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method>
+      (Forward<PtrType>(aPtr), aMethod));
+}
+
+template<typename PtrType, typename Method>
+already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
+NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
+                                     Method aMethod)
+{
+  return detail::SetRunnableName(
+    NewNonOwningCancelableRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
+}
+
+
+
+
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
+NewRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return do_AddRef(
+    new detail::OwningRunnableMethodImpl<PtrType, Method, Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
+NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod, Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return detail::SetRunnableName(
+    NewRunnableMethod<Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
+NewNonOwningRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return do_AddRef(
+      new detail::NonOwningRunnableMethodImpl<PtrType, Method, Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
+NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
+                           Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return detail::SetRunnableName(
+    NewNonOwningRunnableMethod<Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
+NewCancelableRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return do_AddRef(
+    new detail::CancelableRunnableMethodImpl<PtrType, Method, Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
+NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
+                            Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return detail::SetRunnableName(
+    NewCancelableRunnableMethod<Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
+NewNonOwningCancelableRunnableMethod(PtrType&& aPtr, Method aMethod,
+                                     Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return do_AddRef(
+    new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method, Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+}
+
+template<typename... Storages, typename PtrType, typename Method, typename... Args>
+already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
+NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
+                                     Method aMethod, Args&&... aArgs)
+{
+  static_assert(sizeof...(Storages) == sizeof...(Args),
+                "<Storages...> size should be equal to number of arguments");
+  return detail::SetRunnableName(
+    NewNonOwningCancelableRunnableMethod<Storages...>
+      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
+}
+
+}
+# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
+template<class T>
+class nsRevocableEventPtr
+{
+public:
+  nsRevocableEventPtr() : mEvent(nullptr) {}
+  ~nsRevocableEventPtr() { Revoke(); }
+
+  const nsRevocableEventPtr& operator=(T* aEvent)
+  {
+    if (mEvent != aEvent) {
+      Revoke();
+      mEvent = aEvent;
+    }
+    return *this;
+  }
+
+  const nsRevocableEventPtr& operator=(already_AddRefed<T> aEvent)
+  {
+    RefPtr<T> event = aEvent;
+    if (mEvent != event) {
+      Revoke();
+      mEvent = event.forget();
+    }
+    return *this;
+  }
+
+  void Revoke()
+  {
+    if (mEvent) {
+      mEvent->Revoke();
+      mEvent = nullptr;
+    }
+  }
+
+  void Forget() { mEvent = nullptr; }
+  bool IsPending() { return mEvent != nullptr; }
+  T* get() { return mEvent; }
+
+private:
+
+  nsRevocableEventPtr(const nsRevocableEventPtr&);
+  nsRevocableEventPtr& operator=(const nsRevocableEventPtr&);
+
+  RefPtr<T> mEvent;
+};
+
+
+
+
+
+class nsThreadPoolNaming
+{
+public:
+  nsThreadPoolNaming() : mCounter(0) {}
+
+
+
+
+  nsCString GetNextThreadName(const nsACString& aPoolName);
+
+  template<size_t LEN>
+  nsCString GetNextThreadName(const char (&aPoolName)[LEN])
+  {
+    return GetNextThreadName(nsDependentCString(aPoolName, LEN - 1));
+  }
+
+private:
+  mozilla::Atomic<uint32_t> mCounter;
+
+  nsThreadPoolNaming(const nsThreadPoolNaming&) = delete;
+  void operator=(const nsThreadPoolNaming&) = delete;
+};
+
+
+
+
+
+
+
+class nsAutoLowPriorityIO
+{
+public:
+  nsAutoLowPriorityIO();
+  ~nsAutoLowPriorityIO();
+
+private:
+  bool lowIOPrioritySet;
+
+
+
+};
+
+void
+NS_SetMainThread();
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h" 2
+
+
+
+namespace mozilla {
+
+
+enum class StyleBasicShapeType : uint8_t {
+  Polygon,
+  Circle,
+  Ellipse,
+  Inset,
+};
+
+
+enum class StyleBoxAlign : uint8_t {
+  Stretch,
+  Start,
+  Center,
+  Baseline,
+  End,
+};
+
+
+enum class StyleBoxDecorationBreak : uint8_t {
+  Slice,
+  Clone,
+};
+
+
+enum class StyleBoxDirection : uint8_t {
+  Normal,
+  Reverse,
+};
+
+
+enum class StyleBoxOrient : uint8_t {
+  Horizontal,
+  Vertical,
+};
+
+
+enum class StyleBoxPack : uint8_t {
+  Start,
+  Center,
+  End,
+  Justify,
+};
+
+
+enum class StyleBoxSizing : uint8_t {
+  Content,
+  Border
+};
+
+
+enum class StyleBoxShadowType : uint8_t {
+  Inset,
+};
+
+
+enum class StyleClear : uint8_t {
+  None = 0,
+  Left,
+  Right,
+  InlineStart,
+  InlineEnd,
+  Both,
+
+
+  Line = 8,
+  Max = 13
+};
+
+
+
+enum class StyleGeometryBox : uint8_t {
+  ContentBox,
+  PaddingBox,
+  BorderBox,
+  MarginBox,
+
+
+
+  FillBox,
+  StrokeBox,
+  ViewBox,
+  NoClip,
+  Text,
+  NoBox,
+
+
+
+
+
+
+  MozAlmostPadding = 127
+
+
+
+
+
+
+};
+
+
+enum class StyleFillRule : uint8_t {
+  Nonzero,
+  Evenodd,
+};
+
+
+
+enum class StyleFloat : uint8_t {
+  None,
+  Left,
+  Right,
+  InlineStart,
+  InlineEnd
+};
+
+
+enum class StyleFloatEdge : uint8_t {
+  ContentBox,
+  MarginBox,
+};
+
+
+enum class StyleHyphens : uint8_t {
+  None,
+  Manual,
+  Auto,
+};
+
+
+enum class StyleShapeRadius : uint8_t {
+  ClosestSide,
+  FarthestSide,
+};
+
+
+enum class StyleShapeSourceType : uint8_t {
+  None,
+  URL,
+  Shape,
+  Box,
+};
+
+
+enum class StyleTextJustify : uint8_t {
+  None,
+  Auto,
+  InterWord,
+  InterCharacter,
+};
+
+
+enum class StyleUserFocus : uint8_t {
+  None,
+  Ignore,
+  Normal,
+  SelectAll,
+  SelectBefore,
+  SelectAfter,
+  SelectSame,
+  SelectMenu,
+};
+
+
+enum class StyleUserSelect : uint8_t {
+  None,
+  Text,
+  Element,
+  Elements,
+  All,
+  Toggle,
+  TriState,
+  Auto,
+  MozAll,
+  MozText,
+};
+
+
+enum class StyleUserInput : uint8_t {
+  None,
+  Enabled,
+  Disabled,
+  Auto,
+};
+
+
+enum class StyleUserModify : uint8_t {
+  ReadOnly,
+  ReadWrite,
+  WriteOnly,
+};
+
+
+enum class StyleWindowDragging : uint8_t {
+  Default,
+  Drag,
+  NoDrag,
+};
+
+
+enum class StyleOrient : uint8_t {
+  Inline,
+  Block,
+  Horizontal,
+  Vertical,
+};
+# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
+namespace dom {
+enum class PlaybackDirection : uint8_t;
+enum class FillMode : uint8_t;
+}
+# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
+enum class StyleDisplay : uint8_t {
+  None = 0,
+  Block,
+  FlowRoot,
+  Inline,
+  InlineBlock,
+  ListItem,
+  Table,
+  InlineTable,
+  TableRowGroup,
+  TableColumn,
+  TableColumnGroup,
+  TableHeaderGroup,
+  TableFooterGroup,
+  TableRow,
+  TableCell,
+  TableCaption,
+  Flex,
+  InlineFlex,
+  Grid,
+  InlineGrid,
+  Ruby,
+  RubyBase,
+  RubyBaseContainer,
+  RubyText,
+  RubyTextContainer,
+  Contents,
+  WebkitBox,
+  WebkitInlineBox,
+  MozBox,
+  MozInlineBox,
+
+  MozGrid,
+  MozInlineGrid,
+  MozGridGroup,
+  MozGridLine,
+  MozStack,
+  MozInlineStack,
+  MozDeck,
+  MozGroupbox,
+  MozPopup,
+
+};
+# 684 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
+enum class StyleGridTrackBreadth : uint8_t {
+  MaxContent = 1,
+  MinContent = 2,
+};
+# 1247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h"
+namespace mozilla {
+
+class WritingMode;
+
+
+enum LogicalAxis {
+  eLogicalAxisBlock = 0x0,
+  eLogicalAxisInline = 0x1
+};
+enum LogicalEdge {
+  eLogicalEdgeStart = 0x0,
+  eLogicalEdgeEnd = 0x1
+};
+enum LogicalSide {
+  eLogicalSideBStart = (eLogicalAxisBlock << 1) | eLogicalEdgeStart,
+  eLogicalSideBEnd = (eLogicalAxisBlock << 1) | eLogicalEdgeEnd,
+  eLogicalSideIStart = (eLogicalAxisInline << 1) | eLogicalEdgeStart,
+  eLogicalSideIEnd = (eLogicalAxisInline << 1) | eLogicalEdgeEnd
+};
+
+enum LogicalCorner
+{
+  eLogicalCornerBStartIStart = 0,
+  eLogicalCornerBStartIEnd = 1,
+  eLogicalCornerBEndIEnd = 2,
+  eLogicalCornerBEndIStart = 3
+};
+
+}
+
+enum nsStyleUnit : uint8_t {
+  eStyleUnit_Null = 0,
+  eStyleUnit_Normal = 1,
+  eStyleUnit_Auto = 2,
+  eStyleUnit_None = 3,
+  eStyleUnit_Percent = 10,
+  eStyleUnit_Factor = 11,
+  eStyleUnit_Degree = 12,
+  eStyleUnit_Grad = 13,
+  eStyleUnit_Radian = 14,
+  eStyleUnit_Turn = 15,
+  eStyleUnit_FlexFraction = 16,
+  eStyleUnit_Coord = 20,
+  eStyleUnit_Integer = 30,
+  eStyleUnit_Enumerated = 32,
+
+
+  eStyleUnit_Calc = 40,
+
+
+  eStyleUnit_MAX = 40
+};
+
+typedef union {
+  int32_t mInt;
+  float mFloat;
+
+
+  void* mPointer;
+} nsStyleUnion;
+# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h"
+class nsStyleCoord {
+public:
+
+
+  struct CalcValue {
+
+    nscoord mLength;
+    float mPercent;
+    bool mHasPercent;
+
+    bool operator==(const CalcValue& aOther) const {
+      return mLength == aOther.mLength &&
+             mPercent == aOther.mPercent &&
+             mHasPercent == aOther.mHasPercent;
+    }
+    bool operator!=(const CalcValue& aOther) const {
+      return !(*this == aOther);
+    }
+
+    nscoord ToLength() const {
+      do { } while (0);
+      return mLength;
+    }
+
+
+
+    bool IsDefinitelyZero() const { return mLength == 0 && mPercent == 0; }
+  };
+
+
+
+  struct Calc final : public CalcValue {
+    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Calc>::value, "Reference-counted class " "Calc" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+    Calc() {}
+
+  private:
+    Calc(const Calc&) = delete;
+    ~Calc() {}
+    Calc& operator=(const Calc&) = delete;
+  };
+
+  explicit nsStyleCoord(nsStyleUnit aUnit = eStyleUnit_Null);
+  enum CoordConstructorType { CoordConstructor };
+  inline nsStyleCoord(nscoord aValue, CoordConstructorType);
+  nsStyleCoord(int32_t aValue, nsStyleUnit aUnit);
+  nsStyleCoord(float aValue, nsStyleUnit aUnit);
+  inline nsStyleCoord(const nsStyleCoord& aCopy);
+  inline nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit);
+  ~nsStyleCoord() { Reset(); }
+
+  nsStyleCoord& operator=(const nsStyleCoord& aOther)
+  {
+    if (this != &aOther) {
+      SetValue(mUnit, mValue, aOther);
+    }
+    return *this;
+  }
+  bool operator==(const nsStyleCoord& aOther) const;
+  bool operator!=(const nsStyleCoord& aOther) const;
+
+  nsStyleUnit GetUnit() const {
+    do { } while(0);
+    return mUnit;
+  }
+
+  bool IsAngleValue() const {
+    return eStyleUnit_Degree <= mUnit && mUnit <= eStyleUnit_Turn;
+  }
+
+  static bool IsCalcUnit(nsStyleUnit aUnit) {
+    return aUnit == eStyleUnit_Calc;
+  }
+
+  static bool IsPointerUnit(nsStyleUnit aUnit) {
+    return IsCalcUnit(aUnit);
+  }
+
+  bool IsCalcUnit() const {
+    return IsCalcUnit(mUnit);
+  }
+
+  bool IsPointerValue() const {
+    return IsPointerUnit(mUnit);
+  }
+
+  bool IsCoordPercentCalcUnit() const {
+    return mUnit == eStyleUnit_Coord ||
+           mUnit == eStyleUnit_Percent ||
+           IsCalcUnit();
+  }
+
+
+
+  bool CalcHasPercent() const {
+    return GetCalcValue()->mHasPercent;
+  }
+
+  bool HasPercent() const {
+    return mUnit == eStyleUnit_Percent ||
+           (IsCalcUnit() && CalcHasPercent());
+  }
+
+  static bool ConvertsToLength(const nsStyleUnit aUnit,
+                               const nsStyleUnion aValue) {
+    return aUnit == eStyleUnit_Coord ||
+           (IsCalcUnit(aUnit) && !AsCalcValue(aValue)->mHasPercent);
+  }
+
+  bool ConvertsToLength() const {
+    return ConvertsToLength(mUnit, mValue);
+  }
+
+  static nscoord ToLength(nsStyleUnit aUnit, nsStyleUnion aValue) {
+    do { } while (0);
+    if (IsCalcUnit(aUnit)) {
+      return AsCalcValue(aValue)->ToLength();
+    }
+    do { } while (0);
+    return aValue.mInt;
+  }
+
+  nscoord ToLength() const {
+    return ToLength(GetUnit(), mValue);
+  }
+
+
+  static Calc* AsCalcValue(nsStyleUnion aValue) {
+    return static_cast<Calc*>(aValue.mPointer);
+  }
+
+  nscoord GetCoordValue() const;
+  int32_t GetIntValue() const;
+  float GetPercentValue() const;
+  float GetFactorValue() const;
+  float GetFactorOrPercentValue() const;
+  float GetAngleValue() const;
+  double GetAngleValueInDegrees() const;
+  double GetAngleValueInRadians() const;
+  float GetFlexFractionValue() const;
+  Calc* GetCalcValue() const;
+  uint32_t HashValue(uint32_t aHash) const;
+  template<typename T,
+           typename = typename std::enable_if<std::is_enum<T>::value>::type>
+  T GetEnumValue() const
+  {
+    do { } while (0);
+
+    return static_cast<T>(GetIntValue());
+  }
+
+
+
+  void Reset();
+
+  void SetCoordValue(nscoord aValue);
+  void SetIntValue(int32_t aValue, nsStyleUnit aUnit);
+  void SetPercentValue(float aValue);
+  void SetFactorValue(float aValue);
+  void SetAngleValue(float aValue, nsStyleUnit aUnit);
+  void SetFlexFractionValue(float aValue);
+  void SetNormalValue();
+  void SetAutoValue();
+  void SetNoneValue();
+  void SetCalcValue(Calc* aValue);
+  template<typename T,
+           typename = typename std::enable_if<std::is_enum<T>::value>::type>
+  void SetEnumValue(T aValue)
+  {
+    static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
+                  "aValue must be an enum that fits within mValue.mInt!");
+    SetIntValue(static_cast<int32_t>(aValue), eStyleUnit_Enumerated);
+  }
+
+
+  static inline void Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue);
+
+
+
+  static inline void SetValue(nsStyleUnit& aUnit,
+                              nsStyleUnion& aValue,
+                              nsStyleUnit aOtherUnit,
+                              const nsStyleUnion& aOtherValue);
+
+
+  static inline void SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
+                              const nsStyleCoord& aOther);
+
+
+  static inline void InitWithValue(nsStyleUnit& aUnit,
+                                   nsStyleUnion& aValue,
+                                   nsStyleUnit aOtherUnit,
+                                   const nsStyleUnion& aOtherValue);
+
+  static inline void InitWithValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
+                                   const nsStyleCoord& aOther);
+
+private:
+  nsStyleUnit mUnit;
+  nsStyleUnion mValue;
+};
+
+
+
+
+
+
+
+class nsStyleSides {
+public:
+  nsStyleSides();
+  nsStyleSides(const nsStyleSides&);
+  ~nsStyleSides();
+
+  nsStyleSides& operator=(const nsStyleSides& aCopy);
+  bool operator==(const nsStyleSides& aOther) const;
+  bool operator!=(const nsStyleSides& aOther) const;
+
+  inline nsStyleUnit GetUnit(mozilla::Side aSide) const;
+  inline nsStyleUnit GetLeftUnit() const;
+  inline nsStyleUnit GetTopUnit() const;
+  inline nsStyleUnit GetRightUnit() const;
+  inline nsStyleUnit GetBottomUnit() const;
+
+  inline nsStyleCoord Get(mozilla::Side aSide) const;
+  inline nsStyleCoord GetLeft() const;
+  inline nsStyleCoord GetTop() const;
+  inline nsStyleCoord GetRight() const;
+  inline nsStyleCoord GetBottom() const;
+
+
+
+
+
+  inline nsStyleUnit GetUnit(mozilla::WritingMode aWritingMode,
+                             mozilla::LogicalSide aSide) const;
+  inline nsStyleUnit GetIStartUnit(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleUnit GetBStartUnit(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleUnit GetIEndUnit(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleUnit GetBEndUnit(mozilla::WritingMode aWritingMode) const;
+
+
+  inline bool HasBlockAxisAuto(mozilla::WritingMode aWritingMode) const;
+  inline bool HasInlineAxisAuto(mozilla::WritingMode aWritingMode) const;
+
+  inline nsStyleCoord Get(mozilla::WritingMode aWritingMode,
+                          mozilla::LogicalSide aSide) const;
+  inline nsStyleCoord GetIStart(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleCoord GetBStart(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleCoord GetIEnd(mozilla::WritingMode aWritingMode) const;
+  inline nsStyleCoord GetBEnd(mozilla::WritingMode aWritingMode) const;
+
+
+
+
+  void Reset();
+
+  inline void Set(mozilla::Side aSide, const nsStyleCoord& aCoord);
+  inline void SetLeft(const nsStyleCoord& aCoord);
+  inline void SetTop(const nsStyleCoord& aCoord);
+  inline void SetRight(const nsStyleCoord& aCoord);
+  inline void SetBottom(const nsStyleCoord& aCoord);
+
+  nscoord ToLength(mozilla::Side aSide) const {
+    return nsStyleCoord::ToLength(mUnits[aSide], mValues[aSide]);
+  }
+
+  bool ConvertsToLength() const {
+    int32_t side354 = mozilla::eSideTop; for (mozilla::Side side; side354 <= mozilla::eSideLeft && ((side = mozilla::Side(side354)), true); ++side354) {
+      if (!nsStyleCoord::ConvertsToLength(mUnits[side], mValues[side])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+protected:
+  nsStyleUnit mUnits[4];
+  nsStyleUnion mValues[4];
+};
+
+
+
+
+
+
+
+class nsStyleCorners {
+public:
+  nsStyleCorners();
+  nsStyleCorners(const nsStyleCorners&);
+  ~nsStyleCorners();
+
+
+  nsStyleCorners& operator=(const nsStyleCorners& aCopy);
+  bool operator==(const nsStyleCorners& aOther) const;
+  bool operator!=(const nsStyleCorners& aOther) const;
+
+
+  inline nsStyleUnit GetUnit(uint8_t aHalfCorner) const;
+
+  inline nsStyleCoord Get(uint8_t aHalfCorner) const;
+
+
+
+
+  void Reset();
+
+  inline void Set(uint8_t aHalfCorner, const nsStyleCoord& aCoord);
+
+protected:
+
+
+
+
+
+  nsStyleUnit mUnits[8];
+  nsStyleUnion mValues[8];
+};
+
+
+
+
+
+inline nsStyleCoord::nsStyleCoord(nscoord aValue, CoordConstructorType)
+  : mUnit(eStyleUnit_Coord)
+{
+  mValue.mInt = aValue;
+}
+
+inline nsStyleCoord::nsStyleCoord(const nsStyleCoord& aCopy)
+  : mUnit(eStyleUnit_Null)
+{
+  InitWithValue(mUnit, mValue, aCopy);
+}
+
+inline nsStyleCoord::nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit)
+  : mUnit(eStyleUnit_Null)
+{
+  InitWithValue(mUnit, mValue, aUnit, aValue);
+}
+
+inline bool nsStyleCoord::operator!=(const nsStyleCoord& aOther) const
+{
+  return !((*this) == aOther);
+}
+
+inline nscoord nsStyleCoord::GetCoordValue() const
+{
+  do { } while(0);
+  if (mUnit == eStyleUnit_Coord) {
+    return mValue.mInt;
+  }
+  return 0;
+}
+
+inline int32_t nsStyleCoord::GetIntValue() const
+{
+  do { } while(0);
+
+  if ((mUnit == eStyleUnit_Enumerated) ||
+      (mUnit == eStyleUnit_Integer)) {
+    return mValue.mInt;
+  }
+  return 0;
+}
+
+inline float nsStyleCoord::GetPercentValue() const
+{
+  do { } while(0);
+  if (mUnit == eStyleUnit_Percent) {
+    return mValue.mFloat;
+  }
+  return 0.0f;
+}
+
+inline float nsStyleCoord::GetFactorValue() const
+{
+  do { } while(0);
+  if (mUnit == eStyleUnit_Factor) {
+    return mValue.mFloat;
+  }
+  return 0.0f;
+}
+
+inline float nsStyleCoord::GetFactorOrPercentValue() const
+{
+  do { } while(0);
+
+  if (mUnit == eStyleUnit_Factor || mUnit == eStyleUnit_Percent) {
+    return mValue.mFloat;
+  }
+  return 0.0f;
+}
+
+inline float nsStyleCoord::GetAngleValue() const
+{
+  do { } while(0);
+
+  if (mUnit >= eStyleUnit_Degree && mUnit <= eStyleUnit_Turn) {
+    return mValue.mFloat;
+  }
+  return 0.0f;
+}
+
+inline float nsStyleCoord::GetFlexFractionValue() const
+{
+  do { } while(0);
+  if (mUnit == eStyleUnit_FlexFraction) {
+    return mValue.mFloat;
+  }
+  return 0.0f;
+}
+
+inline nsStyleCoord::Calc* nsStyleCoord::GetCalcValue() const
+{
+  do { } while(0);
+  if (IsCalcUnit()) {
+    return AsCalcValue(mValue);
+  }
+  return nullptr;
+}
+
+             inline void
+nsStyleCoord::Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue)
+{
+  do { } while (0);
+
+
+  switch (aUnit) {
+    case eStyleUnit_Calc:
+      static_cast<Calc*>(aValue.mPointer)->Release();
+      break;
+    default:
+      do { } while (0);
+  }
+
+  aUnit = eStyleUnit_Null;
+  aValue.mInt = 0;
+}
+
+             inline void
+nsStyleCoord::SetValue(nsStyleUnit& aUnit,
+                       nsStyleUnion& aValue,
+                       nsStyleUnit aOtherUnit,
+                       const nsStyleUnion& aOtherValue)
+{
+  Reset(aUnit, aValue);
+  InitWithValue(aUnit, aValue, aOtherUnit, aOtherValue);
+}
+
+             inline void
+nsStyleCoord::InitWithValue(nsStyleUnit& aUnit,
+                            nsStyleUnion& aValue,
+                            nsStyleUnit aOtherUnit,
+                            const nsStyleUnion& aOtherValue)
+{
+  aUnit = aOtherUnit;
+  aValue = aOtherValue;
+
+  switch (aUnit) {
+    case eStyleUnit_Calc:
+      static_cast<Calc*>(aValue.mPointer)->AddRef();
+      break;
+    default:
+      do { } while (0);
+  }
+}
+
+             inline void
+nsStyleCoord::SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
+                       const nsStyleCoord& aOther)
+{
+  SetValue(aUnit, aValue, aOther.mUnit, aOther.mValue);
+}
+
+             inline void
+nsStyleCoord::InitWithValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
+                            const nsStyleCoord& aOther)
+{
+  InitWithValue(aUnit, aValue, aOther.mUnit, aOther.mValue);
+}
+
+
+
+
+
+inline bool nsStyleSides::operator!=(const nsStyleSides& aOther) const
+{
+  return !((*this) == aOther);
+}
+
+inline nsStyleUnit nsStyleSides::GetUnit(mozilla::Side aSide) const
+{
+  return (nsStyleUnit)mUnits[aSide];
+}
+
+inline nsStyleUnit nsStyleSides::GetLeftUnit() const
+{
+  return GetUnit(mozilla::eSideLeft);
+}
+
+inline nsStyleUnit nsStyleSides::GetTopUnit() const
+{
+  return GetUnit(mozilla::eSideTop);
+}
+
+inline nsStyleUnit nsStyleSides::GetRightUnit() const
+{
+  return GetUnit(mozilla::eSideRight);
+}
+
+inline nsStyleUnit nsStyleSides::GetBottomUnit() const
+{
+  return GetUnit(mozilla::eSideBottom);
+}
+
+inline nsStyleCoord nsStyleSides::Get(mozilla::Side aSide) const
+{
+  return nsStyleCoord(mValues[aSide], nsStyleUnit(mUnits[aSide]));
+}
+
+inline nsStyleCoord nsStyleSides::GetLeft() const
+{
+  return Get(mozilla::eSideLeft);
+}
+
+inline nsStyleCoord nsStyleSides::GetTop() const
+{
+  return Get(mozilla::eSideTop);
+}
+
+inline nsStyleCoord nsStyleSides::GetRight() const
+{
+  return Get(mozilla::eSideRight);
+}
+
+inline nsStyleCoord nsStyleSides::GetBottom() const
+{
+  return Get(mozilla::eSideBottom);
+}
+
+inline void nsStyleSides::Set(mozilla::Side aSide, const nsStyleCoord& aCoord)
+{
+  nsStyleCoord::SetValue(mUnits[aSide], mValues[aSide], aCoord);
+}
+
+inline void nsStyleSides::SetLeft(const nsStyleCoord& aCoord)
+{
+  Set(mozilla::eSideLeft, aCoord);
+}
+
+inline void nsStyleSides::SetTop(const nsStyleCoord& aCoord)
+{
+  Set(mozilla::eSideTop, aCoord);
+}
+
+inline void nsStyleSides::SetRight(const nsStyleCoord& aCoord)
+{
+  Set(mozilla::eSideRight, aCoord);
+}
+
+inline void nsStyleSides::SetBottom(const nsStyleCoord& aCoord)
+{
+  Set(mozilla::eSideBottom, aCoord);
+}
+
+
+
+
+inline bool nsStyleCorners::operator!=(const nsStyleCorners& aOther) const
+{
+  return !((*this) == aOther);
+}
+
+inline nsStyleUnit nsStyleCorners::GetUnit(uint8_t aCorner) const
+{
+  return (nsStyleUnit)mUnits[aCorner];
+}
+
+inline nsStyleCoord nsStyleCorners::Get(uint8_t aCorner) const
+{
+  return nsStyleCoord(mValues[aCorner], nsStyleUnit(mUnits[aCorner]));
+}
+
+inline void nsStyleCorners::Set(uint8_t aCorner, const nsStyleCoord& aCoord)
+{
+  nsStyleCoord::SetValue(mUnits[aCorner], mValues[aCorner], aCoord);
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 1
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 1
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsbytecode.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsbytecode.h"
+typedef uint8_t jsbytecode;
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h"
+namespace JS {
+
+
+typedef bool (*IsAcceptableThis)(HandleValue v);
+
+
+
+typedef bool (*NativeImpl)(JSContext* cx, const CallArgs& args);
+
+namespace detail {
+
+
+extern bool
+CallMethodIfWrapped(JSContext* cx, IsAcceptableThis test, NativeImpl impl, const CallArgs& args);
+
+}
+# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h"
+template<IsAcceptableThis Test, NativeImpl Impl>
+__attribute__((always_inline)) inline bool
+CallNonGenericMethod(JSContext* cx, const CallArgs& args)
+{
+    HandleValue thisv = args.thisv();
+    if (Test(thisv))
+        return Impl(cx, args);
+
+    return detail::CallMethodIfWrapped(cx, Test, Impl, args);
+}
+
+__attribute__((always_inline)) inline bool
+CallNonGenericMethod(JSContext* cx, IsAcceptableThis Test, NativeImpl Impl, const CallArgs& args)
+{
+    HandleValue thisv = args.thisv();
+    if (Test(thisv))
+        return Impl(cx, args);
+
+    return detail::CallMethodIfWrapped(cx, Test, Impl, args);
+}
+
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+class JSAtom;
+struct JSErrorFormatString;
+class JSLinearString;
+struct JSJitInfo;
+class JSErrorReport;
+
+namespace JS {
+template <class T>
+class Heap;
+}
+
+namespace js {
+class BaseProxyHandler;
+class InterpreterFrame;
+}
+
+extern void
+JS_SetGrayGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
+
+extern JSObject*
+JS_FindCompilationScope(JSContext* cx, JS::HandleObject obj);
+
+extern JSFunction*
+JS_GetObjectFunction(JSObject* obj);
+
+extern bool
+JS_SplicePrototype(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
+
+extern JSObject*
+JS_NewObjectWithUniqueType(JSContext* cx, const JSClass* clasp, JS::HandleObject proto);
+
+
+
+
+
+
+
+extern JSObject*
+JS_NewObjectWithoutMetadata(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
+
+extern uint32_t
+JS_ObjectCountDynamicSlots(JS::HandleObject obj);
+
+extern size_t
+JS_SetProtoCalled(JSContext* cx);
+
+extern size_t
+JS_GetCustomIteratorCount(JSContext* cx);
+
+extern bool
+JS_NondeterministicGetWeakMapKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
+
+extern bool
+JS_NondeterministicGetWeakSetKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
+
+
+extern unsigned
+JS_PCToLineNumber(JSScript* script, jsbytecode* pc, unsigned* columnp = nullptr);
+
+
+
+
+
+
+
+extern bool
+JS_IsDeadWrapper(JSObject* obj);
+
+
+
+
+
+extern void
+JS_TraceShapeCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr shape);
+extern void
+JS_TraceObjectGroupCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr group);
+
+enum {
+    JS_TELEMETRY_GC_REASON,
+    JS_TELEMETRY_GC_IS_ZONE_GC,
+    JS_TELEMETRY_GC_MS,
+    JS_TELEMETRY_GC_BUDGET_MS,
+    JS_TELEMETRY_GC_ANIMATION_MS,
+    JS_TELEMETRY_GC_MAX_PAUSE_MS,
+    JS_TELEMETRY_GC_MARK_MS,
+    JS_TELEMETRY_GC_SWEEP_MS,
+    JS_TELEMETRY_GC_COMPACT_MS,
+    JS_TELEMETRY_GC_MARK_ROOTS_MS,
+    JS_TELEMETRY_GC_MARK_GRAY_MS,
+    JS_TELEMETRY_GC_SLICE_MS,
+    JS_TELEMETRY_GC_SLOW_PHASE,
+    JS_TELEMETRY_GC_MMU_50,
+    JS_TELEMETRY_GC_RESET,
+    JS_TELEMETRY_GC_RESET_REASON,
+    JS_TELEMETRY_GC_INCREMENTAL_DISABLED,
+    JS_TELEMETRY_GC_NON_INCREMENTAL,
+    JS_TELEMETRY_GC_NON_INCREMENTAL_REASON,
+    JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS,
+    JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS,
+    JS_TELEMETRY_GC_MINOR_REASON,
+    JS_TELEMETRY_GC_MINOR_REASON_LONG,
+    JS_TELEMETRY_GC_MINOR_US,
+    JS_TELEMETRY_GC_NURSERY_BYTES,
+    JS_TELEMETRY_GC_PRETENURE_COUNT,
+    JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT,
+    JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_ADDONS,
+    JS_TELEMETRY_ADDON_EXCEPTIONS,
+    JS_TELEMETRY_AOT_USAGE,
+    JS_TELEMETRY_PRIVILEGED_PARSER_COMPILE_LAZY_AFTER_MS,
+    JS_TELEMETRY_WEB_PARSER_COMPILE_LAZY_AFTER_MS,
+    JS_TELEMETRY_END
+};
+
+typedef void
+(*JSAccumulateTelemetryDataCallback)(int id, uint32_t sample, const char* key);
+
+extern void
+JS_SetAccumulateTelemetryCallback(JSContext* cx, JSAccumulateTelemetryDataCallback callback);
+
+extern bool
+JS_GetIsSecureContext(JSCompartment* compartment);
+
+extern JSPrincipals*
+JS_GetCompartmentPrincipals(JSCompartment* compartment);
+
+extern void
+JS_SetCompartmentPrincipals(JSCompartment* compartment, JSPrincipals* principals);
+
+extern JSPrincipals*
+JS_GetScriptPrincipals(JSScript* script);
+
+extern bool
+JS_ScriptHasMutedErrors(JSScript* script);
+
+extern JSObject*
+JS_CloneObject(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
+# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_InitializePropertiesFromCompatibleNativeObject(JSContext* cx,
+                                                  JS::HandleObject dst,
+                                                  JS::HandleObject src);
+
+extern JSString*
+JS_BasicObjectToString(JSContext* cx, JS::HandleObject obj);
+
+namespace js {
+
+bool
+GetBuiltinClass(JSContext* cx, JS::HandleObject obj, ESClass* cls);
+
+const char*
+ObjectClassName(JSContext* cx, JS::HandleObject obj);
+
+void
+ReportOverRecursed(JSContext* maybecx);
+
+bool
+AddRawValueRoot(JSContext* cx, JS::Value* vp, const char* name);
+
+void
+RemoveRawValueRoot(JSContext* cx, JS::Value* vp);
+
+JSAtom*
+GetPropertyNameFromPC(JSScript* script, jsbytecode* pc);
+# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern void
+DumpString(JSString* str, FILE* fp);
+
+extern void
+DumpAtom(JSAtom* atom, FILE* fp);
+
+extern void
+DumpObject(JSObject* obj, FILE* fp);
+
+extern void
+DumpChars(const char16_t* s, size_t n, FILE* fp);
+
+extern void
+DumpValue(const JS::Value& val, FILE* fp);
+
+extern void
+DumpId(jsid id, FILE* fp);
+
+extern void
+DumpInterpreterFrame(JSContext* cx, FILE* fp, InterpreterFrame* start = nullptr);
+
+extern bool
+DumpPC(JSContext* cx, FILE* fp);
+
+extern bool
+DumpScript(JSContext* cx, JSScript* scriptArg, FILE* fp);
+
+
+
+extern void DumpString(JSString* str);
+extern void DumpAtom(JSAtom* atom);
+extern void DumpObject(JSObject* obj);
+extern void DumpChars(const char16_t* s, size_t n);
+extern void DumpValue(const JS::Value& val);
+extern void DumpId(jsid id);
+extern void DumpInterpreterFrame(JSContext* cx, InterpreterFrame* start = nullptr);
+extern bool DumpPC(JSContext* cx);
+extern bool DumpScript(JSContext* cx, JSScript* scriptArg);
+
+
+
+extern void
+DumpBacktrace(JSContext* cx, FILE* fp);
+
+extern void
+DumpBacktrace(JSContext* cx);
+
+}
+
+namespace JS {
+
+
+extern char*
+FormatStackDump(JSContext* cx, char* buf, bool showArgs, bool showLocals, bool showThisProps);
+
+
+
+
+
+extern bool
+ForceLexicalInitialization(JSContext *cx, HandleObject obj);
+
+
+
+
+
+
+extern int
+IsGCPoisoning();
+
+}
+# 297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_CopyPropertiesFrom(JSContext* cx, JS::HandleObject target, JS::HandleObject obj);
+# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+typedef enum {
+    MakeNonConfigurableIntoConfigurable,
+    CopyNonConfigurableAsIs
+} PropertyCopyBehavior;
+
+extern bool
+JS_CopyPropertyFrom(JSContext* cx, JS::HandleId id, JS::HandleObject target,
+                    JS::HandleObject obj,
+                    PropertyCopyBehavior copyBehavior = CopyNonConfigurableAsIs);
+
+extern bool
+JS_WrapPropertyDescriptor(JSContext* cx, JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+struct JSFunctionSpecWithHelp {
+    const char* name;
+    JSNative call;
+    uint16_t nargs;
+    uint16_t flags;
+    const JSJitInfo* jitInfo;
+    const char* usage;
+    const char* help;
+};
+# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_DefineFunctionsWithHelp(JSContext* cx, JS::HandleObject obj, const JSFunctionSpecWithHelp* fs);
+
+namespace js {
+
+extern const js::ClassOps ProxyClassOps;
+extern const js::ClassExtension ProxyClassExtension;
+extern const js::ObjectOps ProxyObjectOps;
+# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern JSObject*
+proxy_WeakmapKeyDelegate(JSObject* obj);
+# 391 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+class SourceHook {
+  public:
+    virtual ~SourceHook() { }
+
+
+
+
+
+
+    virtual bool load(JSContext* cx, const char* filename, char16_t** src, size_t* length) = 0;
+};
+
+
+
+
+
+
+
+extern void
+SetSourceHook(JSContext* cx, mozilla::UniquePtr<SourceHook> hook);
+
+
+extern mozilla::UniquePtr<SourceHook>
+ForgetSourceHook(JSContext* cx);
+
+extern JS::Zone*
+GetCompartmentZone(JSCompartment* comp);
+
+typedef bool
+(* PreserveWrapperCallback)(JSContext* cx, JSObject* obj);
+
+typedef enum {
+    CollectNurseryBeforeDump,
+    IgnoreNurseryObjects
+} DumpHeapNurseryBehaviour;
+
+
+
+
+
+extern void
+DumpHeap(JSContext* cx, FILE* fp, DumpHeapNurseryBehaviour nurseryBehaviour);
+
+
+bool obj_defineGetter(JSContext* cx, unsigned argc, JS::Value* vp);
+bool obj_defineSetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+
+extern bool
+IsSystemCompartment(JSCompartment* comp);
+
+extern bool
+IsSystemZone(JS::Zone* zone);
+
+extern bool
+IsAtomsCompartment(JSCompartment* comp);
+
+extern bool
+IsAtomsZone(JS::Zone* zone);
+
+struct WeakMapTracer
+{
+    JSContext* context;
+
+    explicit WeakMapTracer(JSContext* cx) : context(cx) {}
+
+
+
+
+
+
+
+    virtual void trace(JSObject* m, JS::GCCellPtr key, JS::GCCellPtr value) = 0;
+};
+
+extern void
+TraceWeakMaps(WeakMapTracer* trc);
+
+extern bool
+AreGCGrayBitsValid(JSContext* cx);
+
+extern bool
+ZoneGlobalsAreAllGray(JS::Zone* zone);
+
+typedef void
+(*GCThingCallback)(void* closure, JS::GCCellPtr thing);
+
+extern void
+VisitGrayWrapperTargets(JS::Zone* zone, GCThingCallback callback, void* closure);
+
+extern JSObject*
+GetWeakmapKeyDelegate(JSObject* key);
+
+
+
+
+extern void
+IterateGrayObjects(JS::Zone* zone, GCThingCallback cellCallback, void* data);
+
+
+
+
+
+extern void
+IterateGrayObjectsUnderCC(JS::Zone* zone, GCThingCallback cellCallback, void* data);
+# 508 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern size_t
+SizeOfDataIfCDataObject(mozilla::MallocSizeOf mallocSizeOf, JSObject* obj);
+
+
+extern JSCompartment*
+GetAnyCompartmentInZone(JS::Zone* zone);
+
+
+
+
+
+
+
+namespace shadow {
+
+struct ObjectGroup {
+    const Class* clasp;
+    JSObject* proto;
+    JSCompartment* compartment;
+};
+
+struct BaseShape {
+    const js::Class* clasp_;
+    JSObject* parent;
+};
+
+class Shape {
+public:
+    shadow::BaseShape* base;
+    jsid _1;
+    uint32_t slotInfo;
+
+    static const uint32_t FIXED_SLOTS_SHIFT = 27;
+};
+
+
+
+
+
+
+struct Object {
+    shadow::ObjectGroup* group;
+    shadow::Shape* shape;
+    JS::Value* slots;
+    void* _1;
+
+    size_t numFixedSlots() const { return shape->slotInfo >> Shape::FIXED_SLOTS_SHIFT; }
+    JS::Value* fixedSlots() const {
+        return (JS::Value*)(uintptr_t(this) + sizeof(shadow::Object));
+    }
+
+    JS::Value& slotRef(size_t slot) const {
+        size_t nfixed = numFixedSlots();
+        if (slot < nfixed)
+            return fixedSlots()[slot];
+        return slots[slot - nfixed];
+    }
+};
+
+struct Function {
+    Object base;
+    uint16_t nargs;
+    uint16_t flags;
+
+    JSNative native;
+    const JSJitInfo* jitinfo;
+    void* _1;
+};
+
+struct String
+{
+    static const uint32_t INLINE_CHARS_BIT = ((uint32_t)1 << (2));
+    static const uint32_t LATIN1_CHARS_BIT = ((uint32_t)1 << (6));
+    static const uint32_t ROPE_FLAGS = 0;
+    static const uint32_t EXTERNAL_FLAGS = ((uint32_t)1 << (5));
+    static const uint32_t TYPE_FLAGS_MASK = ((uint32_t)1 << (6)) - 1;
+    uint32_t flags;
+    uint32_t length;
+    union {
+        const JS::Latin1Char* nonInlineCharsLatin1;
+        const char16_t* nonInlineCharsTwoByte;
+        JS::Latin1Char inlineStorageLatin1[1];
+        char16_t inlineStorageTwoByte[1];
+    };
+    const JSStringFinalizer* externalFinalizer;
+};
+
+}
+
+
+
+extern const js::Class* const ObjectClassPtr;
+
+inline const js::Class*
+GetObjectClass(const JSObject* obj)
+{
+    return reinterpret_cast<const shadow::Object*>(obj)->group->clasp;
+}
+
+inline const JSClass*
+GetObjectJSClass(JSObject* obj)
+{
+    return js::Jsvalify(GetObjectClass(obj));
+}
+
+const Class*
+ProtoKeyToClass(JSProtoKey key);
+# 623 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+inline JSProtoKey
+InheritanceProtoKeyForStandardClass(JSProtoKey key)
+{
+
+    if (key == JSProto_Object)
+        return JSProto_Null;
+
+
+    if (ProtoKeyToClass(key)->specDefined())
+        return ProtoKeyToClass(key)->specInheritanceProtoKey();
+
+
+    return JSProto_Object;
+}
+
+bool
+IsFunctionObject(JSObject* obj);
+
+static __attribute__((always_inline)) inline JSCompartment*
+GetObjectCompartment(JSObject* obj)
+{
+    return reinterpret_cast<shadow::Object*>(obj)->group->compartment;
+}
+
+JSObject*
+GetGlobalForObjectCrossCompartment(JSObject* obj);
+
+JSObject*
+GetPrototypeNoProxy(JSObject* obj);
+
+void
+AssertSameCompartment(JSContext* cx, JSObject* obj);
+
+void
+AssertSameCompartment(JSContext* cx, JS::HandleValue v);
+
+
+void
+AssertSameCompartment(JSObject* objA, JSObject* objB);
+
+
+
+
+void
+NotifyAnimationActivity(JSObject* obj);
+# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+JSFunction*
+GetOutermostEnclosingFunctionOfScriptedCaller(JSContext* cx);
+
+JSFunction*
+DefineFunctionWithReserved(JSContext* cx, JSObject* obj, const char* name, JSNative call,
+                           unsigned nargs, unsigned attrs);
+
+JSFunction*
+NewFunctionWithReserved(JSContext* cx, JSNative call, unsigned nargs, unsigned flags,
+                        const char* name);
+
+JSFunction*
+NewFunctionByIdWithReserved(JSContext* cx, JSNative native, unsigned nargs, unsigned flags,
+                            jsid id);
+
+const JS::Value&
+GetFunctionNativeReserved(JSObject* fun, size_t which);
+
+void
+SetFunctionNativeReserved(JSObject* fun, size_t which, const JS::Value& val);
+
+bool
+FunctionHasNativeReserved(JSObject* fun);
+
+bool
+GetObjectProto(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject proto);
+
+extern JSObject*
+GetStaticPrototype(JSObject* obj);
+
+bool
+GetOriginalEval(JSContext* cx, JS::HandleObject scope,
+                JS::MutableHandleObject eval);
+
+inline void*
+GetObjectPrivate(JSObject* obj)
+{
+    do { } while (0);
+    const shadow::Object* nobj = reinterpret_cast<const shadow::Object*>(obj);
+    void** addr = reinterpret_cast<void**>(&nobj->fixedSlots()[nobj->numFixedSlots()]);
+    return *addr;
+}
+
+inline const JS::Value&
+GetReservedSlot(JSObject* obj, size_t slot)
+{
+    do { } while (0);
+    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
+}
+
+void
+SetReservedOrProxyPrivateSlotWithBarrier(JSObject* obj, size_t slot, const JS::Value& value);
+
+inline void
+SetReservedSlot(JSObject* obj, size_t slot, const JS::Value& value)
+{
+    do { } while (0);
+    shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
+    if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
+        SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
+    else
+        sobj->slotRef(slot) = value;
+}
+
+uint32_t
+GetObjectSlotSpan(JSObject* obj);
+
+inline const JS::Value&
+GetObjectSlot(JSObject* obj, size_t slot)
+{
+    do { } while (0);
+    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
+}
+
+__attribute__((always_inline)) inline size_t
+GetAtomLength(JSAtom* atom)
+{
+    return reinterpret_cast<shadow::String*>(atom)->length;
+}
+
+static const uint32_t MaxStringLength = (1 << 28) - 1;
+
+__attribute__((always_inline)) inline size_t
+GetStringLength(JSString* s)
+{
+    return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+__attribute__((always_inline)) inline size_t
+GetFlatStringLength(JSFlatString* s)
+{
+    return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+__attribute__((always_inline)) inline size_t
+GetLinearStringLength(JSLinearString* s)
+{
+    return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+__attribute__((always_inline)) inline bool
+LinearStringHasLatin1Chars(JSLinearString* s)
+{
+    return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+__attribute__((always_inline)) inline bool
+AtomHasLatin1Chars(JSAtom* atom)
+{
+    return reinterpret_cast<shadow::String*>(atom)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+__attribute__((always_inline)) inline bool
+StringHasLatin1Chars(JSString* s)
+{
+    return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+__attribute__((always_inline)) inline const JS::Latin1Char*
+GetLatin1LinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
+{
+    do { } while (0);
+
+    using shadow::String;
+    String* s = reinterpret_cast<String*>(linear);
+    if (s->flags & String::INLINE_CHARS_BIT)
+        return s->inlineStorageLatin1;
+    return s->nonInlineCharsLatin1;
+}
+
+__attribute__((always_inline)) inline const char16_t*
+GetTwoByteLinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
+{
+    do { } while (0);
+
+    using shadow::String;
+    String* s = reinterpret_cast<String*>(linear);
+    if (s->flags & String::INLINE_CHARS_BIT)
+        return s->inlineStorageTwoByte;
+    return s->nonInlineCharsTwoByte;
+}
+
+__attribute__((always_inline)) inline JSLinearString*
+AtomToLinearString(JSAtom* atom)
+{
+    return reinterpret_cast<JSLinearString*>(atom);
+}
+
+__attribute__((always_inline)) inline JSFlatString*
+AtomToFlatString(JSAtom* atom)
+{
+    return reinterpret_cast<JSFlatString*>(atom);
+}
+
+__attribute__((always_inline)) inline JSLinearString*
+FlatStringToLinearString(JSFlatString* s)
+{
+    return reinterpret_cast<JSLinearString*>(s);
+}
+
+__attribute__((always_inline)) inline const JS::Latin1Char*
+GetLatin1AtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
+{
+    return GetLatin1LinearStringChars(nogc, AtomToLinearString(atom));
+}
+
+__attribute__((always_inline)) inline const char16_t*
+GetTwoByteAtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
+{
+    return GetTwoByteLinearStringChars(nogc, AtomToLinearString(atom));
+}
+
+__attribute__((always_inline)) inline bool
+IsExternalString(JSString* str, const JSStringFinalizer** fin, const char16_t** chars)
+{
+    using shadow::String;
+    String* s = reinterpret_cast<String*>(str);
+
+    if ((s->flags & String::TYPE_FLAGS_MASK) != String::EXTERNAL_FLAGS)
+        return false;
+
+    do { } while (0);
+    *fin = s->externalFinalizer;
+    *chars = s->nonInlineCharsTwoByte;
+    return true;
+}
+
+JSLinearString*
+StringToLinearStringSlow(JSContext* cx, JSString* str);
+
+__attribute__((always_inline)) inline JSLinearString*
+StringToLinearString(JSContext* cx, JSString* str)
+{
+    using shadow::String;
+    String* s = reinterpret_cast<String*>(str);
+    if ((__builtin_expect(!!((s->flags & String::TYPE_FLAGS_MASK) == String::ROPE_FLAGS), 0)))
+        return StringToLinearStringSlow(cx, str);
+    return reinterpret_cast<JSLinearString*>(str);
+}
+
+template<typename CharType>
+__attribute__((always_inline)) inline void
+CopyLinearStringChars(CharType* dest, JSLinearString* s, size_t len, size_t start = 0);
+
+__attribute__((always_inline)) inline void
+CopyLinearStringChars(char16_t* dest, JSLinearString* s, size_t len, size_t start = 0)
+{
+    do { } while (0);
+    JS::AutoCheckCannotGC nogc;
+    if (LinearStringHasLatin1Chars(s)) {
+        const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
+        for (size_t i = 0; i < len; i++)
+            dest[i] = src[start + i];
+    } else {
+        const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
+        mozilla::PodCopy(dest, src + start, len);
+    }
+}
+
+__attribute__((always_inline)) inline void
+CopyLinearStringChars(char* dest, JSLinearString* s, size_t len, size_t start = 0)
+{
+    do { } while (0);
+    JS::AutoCheckCannotGC nogc;
+    if (LinearStringHasLatin1Chars(s)) {
+        const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
+        for (size_t i = 0; i < len; i++)
+           dest[i] = char(src[start + i]);
+    } else {
+      const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
+      for (size_t i = 0; i < len; i++)
+          dest[i] = char(src[start + i]);
+    }
+}
+
+template<typename CharType>
+inline bool
+CopyStringChars(JSContext* cx, CharType* dest, JSString* s, size_t len, size_t start = 0)
+{
+    JSLinearString* linear = StringToLinearString(cx, s);
+    if (!linear)
+        return false;
+
+    CopyLinearStringChars(dest, linear, len, start);
+    return true;
+}
+
+inline void
+CopyFlatStringChars(char16_t* dest, JSFlatString* s, size_t len)
+{
+    CopyLinearStringChars(dest, FlatStringToLinearString(s), len);
+}
+# 952 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+bool
+GetPropertyKeys(JSContext* cx, JS::HandleObject obj, unsigned flags, JS::AutoIdVector* props);
+
+bool
+AppendUnique(JSContext* cx, JS::AutoIdVector& base, JS::AutoIdVector& others);
+
+bool
+StringIsArrayIndex(JSLinearString* str, uint32_t* indexp);
+
+void
+SetPreserveWrapperCallback(JSContext* cx, PreserveWrapperCallback callback);
+
+bool
+IsObjectInContextCompartment(JSObject* obj, const JSContext* cx);
+# 980 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+bool
+RunningWithTrustedPrincipals(JSContext* cx);
+
+__attribute__((always_inline)) inline uintptr_t
+GetNativeStackLimit(JSContext* cx, JS::StackKind kind, int extraAllowance = 0)
+{
+    uintptr_t limit = JS::RootingContext::get(cx)->nativeStackLimit[kind];
+
+
+
+    limit -= extraAllowance;
+
+    return limit;
+}
+
+__attribute__((always_inline)) inline uintptr_t
+GetNativeStackLimit(JSContext* cx, int extraAllowance = 0)
+{
+    JS::StackKind kind = RunningWithTrustedPrincipals(cx) ? JS::StackForTrustedScript
+                                                          : JS::StackForUntrustedScript;
+    return GetNativeStackLimit(cx, kind, extraAllowance);
+}
+# 1012 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+__attribute__((always_inline)) inline bool
+CheckRecursionLimit(JSContext* cx, uintptr_t limit)
+{
+    int stackDummy;
+    if (!((__builtin_expect(!!((uintptr_t)(&stackDummy) > (limit)), 1)))) {
+        ReportOverRecursed(cx);
+        return false;
+    }
+    return true;
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitDontReport(JSContext* cx, uintptr_t limit)
+{
+    int stackDummy;
+    return ((__builtin_expect(!!((uintptr_t)(&stackDummy) > (limit)), 1)));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimit(JSContext* cx)
+{
+
+
+
+
+    uintptr_t untrustedLimit = GetNativeStackLimit(cx, JS::StackForUntrustedScript);
+    if ((__builtin_expect(!!(CheckRecursionLimitDontReport(cx, untrustedLimit)), 1)))
+        return true;
+    return CheckRecursionLimit(cx, GetNativeStackLimit(cx));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitDontReport(JSContext* cx)
+{
+    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitWithStackPointerDontReport(JSContext* cx, void* sp)
+{
+    return ((__builtin_expect(!!((uintptr_t)(sp) > (GetNativeStackLimit(cx))), 1)));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitWithStackPointer(JSContext* cx, void* sp)
+{
+    if (!((__builtin_expect(!!((uintptr_t)(sp) > (GetNativeStackLimit(cx))), 1)))) {
+        ReportOverRecursed(cx);
+        return false;
+    }
+    return true;
+}
+
+__attribute__((always_inline)) inline bool
+CheckSystemRecursionLimit(JSContext* cx)
+{
+    return CheckRecursionLimit(cx, GetNativeStackLimit(cx, JS::StackForSystemCode));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitConservative(JSContext* cx)
+{
+    return CheckRecursionLimit(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
+                                                       -1024 * int(sizeof(size_t))));
+}
+
+__attribute__((always_inline)) inline bool
+CheckRecursionLimitConservativeDontReport(JSContext* cx)
+{
+    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
+                                                                 -1024 * int(sizeof(size_t))));
+}
+
+void
+StartPCCountProfiling(JSContext* cx);
+
+void
+StopPCCountProfiling(JSContext* cx);
+
+void
+PurgePCCounts(JSContext* cx);
+
+size_t
+GetPCCountScriptCount(JSContext* cx);
+
+JSString*
+GetPCCountScriptSummary(JSContext* cx, size_t script);
+
+JSString*
+GetPCCountScriptContents(JSContext* cx, size_t script);
+# 1111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+char*
+GetCodeCoverageSummary(JSContext* cx, size_t* length);
+
+typedef void
+(* ActivityCallback)(void* arg, bool active);
+
+
+
+
+
+
+void
+SetActivityCallback(JSContext* cx, ActivityCallback cb, void* arg);
+
+typedef bool
+(* DOMInstanceClassHasProtoAtDepth)(const Class* instanceClass,
+                                    uint32_t protoID, uint32_t depth);
+struct JSDOMCallbacks {
+    DOMInstanceClassHasProtoAtDepth instanceClassMatchesProto;
+};
+typedef struct JSDOMCallbacks DOMCallbacks;
+
+extern void
+SetDOMCallbacks(JSContext* cx, const DOMCallbacks* callbacks);
+
+extern const DOMCallbacks*
+GetDOMCallbacks(JSContext* cx);
+
+extern JSObject*
+GetTestingFunctions(JSContext* cx);
+
+
+
+
+
+
+inline JSFreeOp*
+CastToJSFreeOp(FreeOp* fop)
+{
+    return reinterpret_cast<JSFreeOp*>(fop);
+}
+
+
+
+
+
+
+
+extern JSFlatString*
+GetErrorTypeName(JSContext* cx, int16_t exnType);
+
+
+extern unsigned
+GetEnterCompartmentDepth(JSContext* cx);
+
+
+extern bool
+RegExpToSharedNonInline(JSContext* cx, JS::HandleObject regexp,
+                        JS::MutableHandle<RegExpShared*> shared);
+
+
+typedef enum NukeReferencesToWindow {
+    NukeWindowReferences,
+    DontNukeWindowReferences
+} NukeReferencesToWindow;
+
+typedef enum NukeReferencesFromTarget {
+    NukeAllReferences,
+    NukeIncomingReferences,
+} NukeReferencesFromTarget;
+
+
+
+
+
+struct CompartmentFilter {
+    virtual bool match(JSCompartment* c) const = 0;
+};
+
+struct AllCompartments : public CompartmentFilter {
+    virtual bool match(JSCompartment* c) const override { return true; }
+};
+
+struct ContentCompartmentsOnly : public CompartmentFilter {
+    virtual bool match(JSCompartment* c) const override {
+        return !IsSystemCompartment(c);
+    }
+};
+
+struct ChromeCompartmentsOnly : public CompartmentFilter {
+    virtual bool match(JSCompartment* c) const override {
+        return IsSystemCompartment(c);
+    }
+};
+
+struct SingleCompartment : public CompartmentFilter {
+    JSCompartment* ours;
+    explicit SingleCompartment(JSCompartment* c) : ours(c) {}
+    virtual bool match(JSCompartment* c) const override { return c == ours; }
+};
+
+struct CompartmentsWithPrincipals : public CompartmentFilter {
+    JSPrincipals* principals;
+    explicit CompartmentsWithPrincipals(JSPrincipals* p) : principals(p) {}
+    virtual bool match(JSCompartment* c) const override {
+        return JS_GetCompartmentPrincipals(c) == principals;
+    }
+};
+
+extern bool
+NukeCrossCompartmentWrappers(JSContext* cx,
+                             const CompartmentFilter& sourceFilter,
+                             const CompartmentFilter& targetFilter,
+                             NukeReferencesToWindow nukeReferencesToWindow,
+                             NukeReferencesFromTarget nukeReferencesFromTarget);
+# 1252 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+struct ExpandoAndGeneration {
+  ExpandoAndGeneration()
+    : expando(JS::UndefinedValue()),
+      generation(0)
+  {}
+
+  void OwnerUnlinked()
+  {
+      ++generation;
+  }
+
+  static size_t offsetOfExpando()
+  {
+      return __builtin_offsetof(ExpandoAndGeneration, expando);
+  }
+
+  static size_t offsetOfGeneration()
+  {
+      return __builtin_offsetof(ExpandoAndGeneration, generation);
+  }
+
+  JS::Heap<JS::Value> expando;
+  uint64_t generation;
+};
+
+typedef enum DOMProxyShadowsResult {
+  ShadowCheckFailed,
+  Shadows,
+  DoesntShadow,
+  DoesntShadowUnique,
+  ShadowsViaDirectExpando,
+  ShadowsViaIndirectExpando
+} DOMProxyShadowsResult;
+typedef DOMProxyShadowsResult
+(* DOMProxyShadowsCheck)(JSContext* cx, JS::HandleObject object, JS::HandleId id);
+void
+SetDOMProxyInformation(const void* domProxyHandlerFamily, uint32_t domProxyExpandoSlot,
+                       DOMProxyShadowsCheck domProxyShadowsCheck);
+
+const void* GetDOMProxyHandlerFamily();
+uint32_t GetDOMProxyExpandoSlot();
+DOMProxyShadowsCheck GetDOMProxyShadowsCheck();
+inline bool DOMProxyIsShadowing(DOMProxyShadowsResult result) {
+    return result == Shadows ||
+           result == ShadowsViaDirectExpando ||
+           result == ShadowsViaIndirectExpando;
+}
+
+
+
+
+extern bool
+DateIsValid(JSContext* cx, JS::HandleObject obj, bool* isValid);
+
+extern bool
+DateGetMsecSinceEpoch(JSContext* cx, JS::HandleObject obj, double* msecSinceEpoch);
+
+}
+
+
+
+
+
+
+
+typedef enum JSErrNum {
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js.msg" 1
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js.msg"
+JSMSG_NOT_AN_ERROR,
+JSMSG_NOT_DEFINED,
+JSMSG_MORE_ARGS_NEEDED,
+JSMSG_INCOMPATIBLE_PROTO,
+JSMSG_NO_CONSTRUCTOR,
+JSMSG_BAD_SORT_ARG,
+JSMSG_CANT_WATCH,
+JSMSG_READ_ONLY,
+JSMSG_CANT_DELETE,
+JSMSG_CANT_TRUNCATE_ARRAY,
+JSMSG_NOT_FUNCTION,
+JSMSG_NOT_CONSTRUCTOR,
+JSMSG_CANT_CONVERT_TO,
+JSMSG_TOPRIMITIVE_NOT_CALLABLE,
+JSMSG_TOPRIMITIVE_RETURNED_OBJECT,
+JSMSG_NO_PROPERTIES,
+JSMSG_BAD_REGEXP_FLAG,
+JSMSG_ARG_INDEX_OUT_OF_RANGE,
+JSMSG_SPREAD_TOO_LARGE,
+JSMSG_BAD_WEAKMAP_KEY,
+JSMSG_BAD_GETTER_OR_SETTER,
+JSMSG_BAD_ARRAY_LENGTH,
+JSMSG_REDECLARED_PREV,
+JSMSG_REDECLARED_VAR,
+JSMSG_UNDECLARED_VAR,
+JSMSG_GETTER_ONLY,
+JSMSG_OVERWRITING_ACCESSOR,
+JSMSG_UNDEFINED_PROP,
+JSMSG_INVALID_MAP_ITERABLE,
+JSMSG_NESTING_GENERATOR,
+JSMSG_INCOMPATIBLE_METHOD,
+JSMSG_OBJECT_WATCH_DEPRECATED,
+JSMSG_BAD_SURROGATE_CHAR,
+JSMSG_UTF8_CHAR_TOO_LARGE,
+JSMSG_MALFORMED_UTF8_CHAR,
+JSMSG_BUILTIN_CTOR_NO_NEW,
+JSMSG_BAD_GENERATOR_YIELD,
+JSMSG_EMPTY_ARRAY_REDUCE,
+JSMSG_UNEXPECTED_TYPE,
+JSMSG_MISSING_FUN_ARG,
+JSMSG_NOT_NONNULL_OBJECT,
+JSMSG_NOT_NONNULL_OBJECT_NAME,
+JSMSG_NOT_NONNULL_OBJECT_ARG,
+JSMSG_SET_NON_OBJECT_RECEIVER,
+JSMSG_INVALID_DESCRIPTOR,
+JSMSG_OBJECT_NOT_EXTENSIBLE,
+JSMSG_CANT_DEFINE_PROP_OBJECT_NOT_EXTENSIBLE,
+JSMSG_CANT_REDEFINE_PROP,
+JSMSG_CANT_REDEFINE_ARRAY_LENGTH,
+JSMSG_CANT_DEFINE_PAST_ARRAY_LENGTH,
+JSMSG_BAD_GET_SET_FIELD,
+JSMSG_THROW_TYPE_ERROR,
+JSMSG_NOT_EXPECTED_TYPE,
+JSMSG_NOT_ITERABLE,
+JSMSG_NOT_ITERATOR,
+JSMSG_ALREADY_HAS_PRAGMA,
+JSMSG_GET_ITER_RETURNED_PRIMITIVE,
+JSMSG_ITER_METHOD_RETURNED_PRIMITIVE,
+JSMSG_CANT_SET_PROTO,
+JSMSG_CANT_SET_PROTO_OF,
+JSMSG_CANT_SET_PROTO_CYCLE,
+JSMSG_INVALID_ARG_TYPE,
+JSMSG_TERMINATED,
+JSMSG_PROTO_NOT_OBJORNULL,
+JSMSG_CANT_CALL_CLASS_CONSTRUCTOR,
+JSMSG_UNINITIALIZED_THIS,
+JSMSG_UNINITIALIZED_THIS_ARROW,
+JSMSG_BAD_DERIVED_RETURN,
+
+
+JSMSG_JSON_BAD_PARSE,
+JSMSG_JSON_CYCLIC_VALUE,
+
+
+JSMSG_BAD_INSTANCEOF_RHS,
+JSMSG_BAD_LEFTSIDE_OF_ASS,
+JSMSG_BAD_PROTOTYPE,
+JSMSG_IN_NOT_OBJECT,
+JSMSG_TOO_MANY_CON_SPREADARGS,
+JSMSG_TOO_MANY_FUN_SPREADARGS,
+JSMSG_UNINITIALIZED_LEXICAL,
+JSMSG_BAD_CONST_ASSIGN,
+JSMSG_CANT_DECLARE_GLOBAL_BINDING,
+
+
+JSMSG_INVALID_DATE,
+JSMSG_BAD_TOISOSTRING_PROP,
+JSMSG_DEPRECATED_TOLOCALEFORMAT,
+
+
+JSMSG_BAD_URI,
+JSMSG_INVALID_NORMALIZE_FORM,
+JSMSG_NEGATIVE_REPETITION_COUNT,
+JSMSG_NOT_A_CODEPOINT,
+JSMSG_RESULTING_STRING_TOO_LARGE,
+JSMSG_DEPRECATED_STRING_METHOD,
+
+
+JSMSG_BAD_RADIX,
+JSMSG_PRECISION_RANGE,
+
+
+JSMSG_BAD_APPLY_ARGS,
+JSMSG_BAD_FORMAL,
+JSMSG_CALLER_IS_STRICT,
+JSMSG_DEPRECATED_USAGE,
+JSMSG_NOT_SCRIPTED_FUNCTION,
+JSMSG_NO_REST_NAME,
+JSMSG_PARAMETER_AFTER_REST,
+JSMSG_TOO_MANY_ARGUMENTS,
+
+
+JSMSG_CSP_BLOCKED_EVAL,
+JSMSG_CSP_BLOCKED_FUNCTION,
+
+
+JSMSG_ACCESSOR_DEF_DENIED,
+JSMSG_DEAD_OBJECT,
+JSMSG_OBJECT_ACCESS_DENIED,
+JSMSG_PROPERTY_ACCESS_DENIED,
+
+
+JSMSG_BAD_CLONE_FUNOBJ_SCOPE,
+JSMSG_CANT_CLONE_OBJECT,
+JSMSG_CANT_OPEN,
+JSMSG_USER_DEFINED_ERROR,
+
+
+JSMSG_ALLOC_OVERFLOW,
+JSMSG_BAD_BYTECODE,
+JSMSG_BUFFER_TOO_SMALL,
+JSMSG_BUILD_ID_NOT_AVAILABLE,
+JSMSG_BYTECODE_TOO_BIG,
+JSMSG_ERR_DURING_THROW,
+JSMSG_NEED_DIET,
+JSMSG_OUT_OF_MEMORY,
+JSMSG_OVER_RECURSED,
+JSMSG_TOO_BIG_TO_ENCODE,
+JSMSG_TOO_DEEP,
+JSMSG_UNCAUGHT_EXCEPTION,
+JSMSG_UNKNOWN_FORMAT,
+
+
+JSMSG_ACCESSOR_WRONG_ARGS,
+JSMSG_ARRAY_COMP_LEFTSIDE,
+JSMSG_ARRAY_INIT_TOO_BIG,
+JSMSG_AS_AFTER_IMPORT_STAR,
+JSMSG_AS_AFTER_RESERVED_WORD,
+JSMSG_ASYNC_GENERATOR,
+JSMSG_AWAIT_IN_DEFAULT,
+JSMSG_AWAIT_OUTSIDE_ASYNC,
+JSMSG_BAD_ARROW_ARGS,
+JSMSG_BAD_BINDING,
+JSMSG_BAD_CONST_DECL,
+JSMSG_BAD_CONTINUE,
+JSMSG_BAD_DESTRUCT_ASS,
+JSMSG_BAD_DESTRUCT_TARGET,
+JSMSG_BAD_DESTRUCT_PARENS,
+JSMSG_BAD_DESTRUCT_DECL,
+JSMSG_BAD_DUP_ARGS,
+JSMSG_BAD_FOR_EACH_LOOP,
+JSMSG_BAD_FOR_LEFTSIDE,
+JSMSG_LEXICAL_DECL_DEFINES_LET,
+JSMSG_LET_STARTING_FOROF_LHS,
+JSMSG_BAD_FUNCTION_YIELD,
+JSMSG_BAD_GENERATOR_RETURN,
+JSMSG_BAD_GENEXP_BODY,
+JSMSG_BAD_INCOP_OPERAND,
+JSMSG_BAD_METHOD_DEF,
+JSMSG_BAD_OCTAL,
+JSMSG_BAD_POW_LEFTSIDE,
+JSMSG_BAD_PROP_ID,
+JSMSG_BAD_RETURN_OR_YIELD,
+JSMSG_BAD_STRICT_ASSIGN,
+JSMSG_BAD_SWITCH,
+JSMSG_BAD_SUPER,
+JSMSG_BAD_SUPERPROP,
+JSMSG_BAD_SUPERCALL,
+JSMSG_BRACKET_AFTER_ARRAY_COMPREHENSION,
+JSMSG_BRACKET_AFTER_LIST,
+JSMSG_BRACKET_IN_INDEX,
+JSMSG_BRACKET_OPENED,
+JSMSG_CATCH_AFTER_GENERAL,
+JSMSG_CATCH_IDENTIFIER,
+JSMSG_CATCH_OR_FINALLY,
+JSMSG_CATCH_WITHOUT_TRY,
+JSMSG_COLON_AFTER_CASE,
+JSMSG_COLON_AFTER_ID,
+JSMSG_COLON_IN_COND,
+JSMSG_COMP_PROP_UNTERM_EXPR,
+JSMSG_CONTRARY_NONDIRECTIVE,
+JSMSG_CURLY_AFTER_BODY,
+JSMSG_CURLY_OPENED,
+JSMSG_CURLY_AFTER_CATCH,
+JSMSG_CURLY_AFTER_FINALLY,
+JSMSG_CURLY_AFTER_LIST,
+JSMSG_CURLY_AFTER_TRY,
+JSMSG_CURLY_BEFORE_BODY,
+JSMSG_CURLY_BEFORE_CATCH,
+JSMSG_CURLY_BEFORE_CLASS,
+JSMSG_CURLY_BEFORE_FINALLY,
+JSMSG_CURLY_BEFORE_SWITCH,
+JSMSG_CURLY_BEFORE_TRY,
+JSMSG_CURLY_IN_COMPOUND,
+JSMSG_DECLARATION_AFTER_EXPORT,
+JSMSG_DECLARATION_AFTER_IMPORT,
+JSMSG_DEPRECATED_DELETE_OPERAND,
+JSMSG_DEPRECATED_EXPR_CLOSURE,
+JSMSG_DEPRECATED_FOR_EACH,
+JSMSG_DEPRECATED_OCTAL,
+JSMSG_DEPRECATED_PRAGMA,
+JSMSG_DEPRECATED_BLOCK_SCOPE_FUN_REDECL,
+JSMSG_DUPLICATE_EXPORT_NAME,
+JSMSG_DUPLICATE_FORMAL,
+JSMSG_DUPLICATE_LABEL,
+JSMSG_DUPLICATE_PROPERTY,
+JSMSG_DUPLICATE_PROTO_PROPERTY,
+JSMSG_EMPTY_CONSEQUENT,
+JSMSG_EQUAL_AS_ASSIGN,
+JSMSG_EXPORT_DECL_AT_TOP_LEVEL,
+JSMSG_FINALLY_WITHOUT_TRY,
+JSMSG_FORBIDDEN_AS_STATEMENT,
+JSMSG_FROM_AFTER_IMPORT_CLAUSE,
+JSMSG_FROM_AFTER_EXPORT_STAR,
+JSMSG_GARBAGE_AFTER_INPUT,
+JSMSG_IDSTART_AFTER_NUMBER,
+JSMSG_ILLEGAL_CHARACTER,
+JSMSG_IMPORT_DECL_AT_TOP_LEVEL,
+JSMSG_OF_AFTER_FOR_LOOP_DECL,
+JSMSG_IN_AFTER_LEXICAL_FOR_DECL,
+JSMSG_INVALID_FOR_IN_DECL_WITH_INIT,
+JSMSG_INVALID_ID,
+JSMSG_LABEL_NOT_FOUND,
+JSMSG_LET_COMP_BINDING,
+JSMSG_LEXICAL_DECL_NOT_IN_BLOCK,
+JSMSG_LEXICAL_DECL_LABEL,
+JSMSG_GENERATOR_LABEL,
+JSMSG_FUNCTION_LABEL,
+JSMSG_SLOPPY_FUNCTION_LABEL,
+JSMSG_LINE_BREAK_AFTER_THROW,
+JSMSG_LINE_BREAK_BEFORE_ARROW,
+JSMSG_MALFORMED_ESCAPE,
+JSMSG_MISSING_BINARY_DIGITS,
+JSMSG_MISSING_EXPONENT,
+JSMSG_MISSING_EXPR_AFTER_THROW,
+JSMSG_MISSING_FORMAL,
+JSMSG_MISSING_HEXDIGITS,
+JSMSG_MISSING_OCTAL_DIGITS,
+JSMSG_MODULE_SPEC_AFTER_FROM,
+JSMSG_NAME_AFTER_DOT,
+JSMSG_NAMED_IMPORTS_OR_NAMESPACE_IMPORT,
+JSMSG_NO_BINDING_NAME,
+JSMSG_NO_EXPORT_NAME,
+JSMSG_NO_IMPORT_NAME,
+JSMSG_NO_VARIABLE_NAME,
+JSMSG_OF_AFTER_FOR_NAME,
+JSMSG_PAREN_AFTER_ARGS,
+JSMSG_PAREN_AFTER_CATCH,
+JSMSG_PAREN_AFTER_COND,
+JSMSG_PAREN_AFTER_FOR,
+JSMSG_PAREN_AFTER_FORMAL,
+JSMSG_PAREN_AFTER_FOR_CTRL,
+JSMSG_PAREN_AFTER_FOR_OF_ITERABLE,
+JSMSG_PAREN_AFTER_SWITCH,
+JSMSG_PAREN_AFTER_WITH,
+JSMSG_PAREN_BEFORE_CATCH,
+JSMSG_PAREN_BEFORE_COND,
+JSMSG_PAREN_BEFORE_FORMAL,
+JSMSG_PAREN_BEFORE_SWITCH,
+JSMSG_PAREN_BEFORE_WITH,
+JSMSG_PAREN_IN_PAREN,
+JSMSG_RC_AFTER_EXPORT_SPEC_LIST,
+JSMSG_RC_AFTER_IMPORT_SPEC_LIST,
+JSMSG_REDECLARED_CATCH_IDENTIFIER,
+JSMSG_RESERVED_ID,
+JSMSG_REST_WITH_COMMA,
+JSMSG_REST_WITH_DEFAULT,
+JSMSG_SELFHOSTED_TOP_LEVEL_LEXICAL,
+JSMSG_SELFHOSTED_METHOD_CALL,
+JSMSG_SELFHOSTED_UNBOUND_NAME,
+JSMSG_SEMI_AFTER_FOR_COND,
+JSMSG_SEMI_AFTER_FOR_INIT,
+JSMSG_SEMI_BEFORE_STMNT,
+JSMSG_SOURCE_TOO_LONG,
+JSMSG_STMT_AFTER_RETURN,
+JSMSG_STRICT_CODE_WITH,
+JSMSG_STRICT_NON_SIMPLE_PARAMS,
+JSMSG_TEMPLSTR_UNTERM_EXPR,
+JSMSG_SIMD_NOT_A_VECTOR,
+JSMSG_TOO_MANY_CASES,
+JSMSG_TOO_MANY_CATCH_VARS,
+JSMSG_TOO_MANY_CON_ARGS,
+JSMSG_TOO_MANY_DEFAULTS,
+JSMSG_TOO_MANY_FUN_ARGS,
+JSMSG_TOO_MANY_LOCALS,
+JSMSG_TOO_MANY_YIELDS,
+JSMSG_TOUGH_BREAK,
+JSMSG_UNEXPECTED_TOKEN,
+JSMSG_UNEXPECTED_PARAMLIST_END,
+JSMSG_UNNAMED_CLASS_STMT,
+JSMSG_UNNAMED_FUNCTION_STMT,
+JSMSG_UNTERMINATED_COMMENT,
+JSMSG_UNTERMINATED_REGEXP,
+JSMSG_UNTERMINATED_STRING,
+JSMSG_USELESS_EXPR,
+JSMSG_USE_ASM_DIRECTIVE_FAIL,
+JSMSG_VAR_HIDES_ARG,
+JSMSG_WHILE_AFTER_DO,
+JSMSG_YIELD_IN_ARROW,
+JSMSG_YIELD_IN_DEFAULT,
+JSMSG_YIELD_IN_METHOD,
+JSMSG_BAD_COLUMN_NUMBER,
+JSMSG_COMPUTED_NAME_IN_PATTERN,
+JSMSG_DEFAULT_IN_PATTERN,
+JSMSG_BAD_NEWTARGET,
+JSMSG_ESCAPED_KEYWORD,
+
+
+JSMSG_USE_ASM_TYPE_FAIL,
+JSMSG_USE_ASM_LINK_FAIL,
+JSMSG_USE_ASM_TYPE_OK,
+
+
+JSMSG_WASM_COMPILE_ERROR,
+JSMSG_WASM_BAD_IMPORT_TYPE,
+JSMSG_WASM_BAD_IMPORT_SIG,
+JSMSG_WASM_BAD_IMP_SIZE,
+JSMSG_WASM_BAD_IMP_MAX,
+JSMSG_WASM_BAD_FIT,
+JSMSG_WASM_IND_CALL_TO_NULL,
+JSMSG_WASM_IND_CALL_BAD_SIG,
+JSMSG_WASM_UNREACHABLE,
+JSMSG_WASM_INTEGER_OVERFLOW,
+JSMSG_WASM_INVALID_CONVERSION,
+JSMSG_WASM_INT_DIVIDE_BY_ZERO,
+JSMSG_WASM_OUT_OF_BOUNDS,
+JSMSG_WASM_UNALIGNED_ACCESS,
+JSMSG_WASM_BAD_UINT32,
+JSMSG_WASM_BAD_GROW,
+JSMSG_WASM_BAD_BUF_ARG,
+JSMSG_WASM_BAD_MOD_ARG,
+JSMSG_WASM_BAD_BUF_MOD_ARG,
+JSMSG_WASM_BAD_DESC_ARG,
+JSMSG_WASM_BAD_ELEMENT,
+JSMSG_WASM_BAD_IMPORT_ARG,
+JSMSG_WASM_BAD_IMPORT_FIELD,
+JSMSG_WASM_BAD_TABLE_VALUE,
+JSMSG_WASM_BAD_I64,
+JSMSG_WASM_NO_TRANSFER,
+JSMSG_WASM_TEXT_FAIL,
+
+
+JSMSG_BAD_TRAP_RETURN_VALUE,
+JSMSG_BAD_GETPROTOTYPEOF_TRAP_RETURN,
+JSMSG_INCONSISTENT_GETPROTOTYPEOF_TRAP,
+JSMSG_PROXY_SETPROTOTYPEOF_RETURNED_FALSE,
+JSMSG_PROXY_ISEXTENSIBLE_RETURNED_FALSE,
+JSMSG_INCONSISTENT_SETPROTOTYPEOF_TRAP,
+JSMSG_CANT_CHANGE_EXTENSIBILITY,
+JSMSG_CANT_DEFINE_INVALID,
+JSMSG_CANT_DEFINE_NEW,
+JSMSG_CANT_DEFINE_NE_AS_NC,
+JSMSG_PROXY_DEFINE_RETURNED_FALSE,
+JSMSG_PROXY_DELETE_RETURNED_FALSE,
+JSMSG_PROXY_PREVENTEXTENSIONS_RETURNED_FALSE,
+JSMSG_PROXY_SET_RETURNED_FALSE,
+JSMSG_CANT_REPORT_AS_NON_EXTENSIBLE,
+JSMSG_CANT_REPORT_C_AS_NC,
+JSMSG_CANT_REPORT_E_AS_NE,
+JSMSG_CANT_REPORT_INVALID,
+JSMSG_CANT_REPORT_NC_AS_NE,
+JSMSG_CANT_REPORT_NEW,
+JSMSG_CANT_REPORT_NE_AS_NC,
+JSMSG_CANT_SET_NW_NC,
+JSMSG_CANT_SET_WO_SETTER,
+JSMSG_CANT_SKIP_NC,
+JSMSG_ONWKEYS_STR_SYM,
+JSMSG_MUST_REPORT_SAME_VALUE,
+JSMSG_MUST_REPORT_UNDEFINED,
+JSMSG_PROXY_CONSTRUCT_OBJECT,
+JSMSG_PROXY_EXTENSIBILITY,
+JSMSG_PROXY_GETOWN_OBJORUNDEF,
+JSMSG_PROXY_REVOKED,
+JSMSG_PROXY_ARG_REVOKED,
+JSMSG_BAD_TRAP,
+
+
+JSMSG_SC_BAD_CLONE_VERSION,
+JSMSG_SC_BAD_SERIALIZED_DATA,
+JSMSG_SC_DUP_TRANSFERABLE,
+JSMSG_SC_NOT_TRANSFERABLE,
+JSMSG_SC_UNSUPPORTED_TYPE,
+JSMSG_SC_NOT_CLONABLE,
+JSMSG_SC_SAB_TRANSFERABLE,
+JSMSG_SC_SAB_DISABLED,
+
+
+JSMSG_ASSIGN_FUNCTION_OR_NULL,
+JSMSG_DEBUG_BAD_LINE,
+JSMSG_DEBUG_BAD_OFFSET,
+JSMSG_DEBUG_BAD_REFERENT,
+JSMSG_DEBUG_BAD_RESUMPTION,
+JSMSG_DEBUG_BAD_YIELD,
+JSMSG_DEBUG_CANT_DEBUG_GLOBAL,
+JSMSG_DEBUG_CCW_REQUIRED,
+JSMSG_DEBUG_COMPARTMENT_MISMATCH,
+JSMSG_DEBUG_LOOP,
+JSMSG_DEBUG_NOT_DEBUGGEE,
+JSMSG_DEBUG_NOT_DEBUGGING,
+JSMSG_DEBUG_NOT_IDLE,
+JSMSG_DEBUG_NOT_LIVE,
+JSMSG_DEBUG_NO_ENV_OBJECT,
+JSMSG_DEBUG_PROTO,
+JSMSG_DEBUG_WRONG_OWNER,
+JSMSG_DEBUG_OPTIMIZED_OUT,
+JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED,
+JSMSG_DEBUG_VARIABLE_NOT_FOUND,
+JSMSG_DEBUG_WRAPPER_IN_WAY,
+JSMSG_DEBUGGEE_WOULD_RUN,
+JSMSG_NOT_CALLABLE_OR_UNDEFINED,
+JSMSG_NOT_TRACKING_ALLOCATIONS,
+JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET,
+JSMSG_QUERY_INNERMOST_WITHOUT_LINE_URL,
+JSMSG_QUERY_LINE_WITHOUT_URL,
+JSMSG_DEBUG_CANT_SET_OPT_ENV,
+JSMSG_DEBUG_INVISIBLE_COMPARTMENT,
+JSMSG_DEBUG_CENSUS_BREAKDOWN,
+JSMSG_DEBUG_PROMISE_NOT_RESOLVED,
+JSMSG_DEBUG_PROMISE_NOT_FULFILLED,
+JSMSG_DEBUG_PROMISE_NOT_REJECTED,
+
+
+JSMSG_TRACELOGGER_ENABLE_FAIL,
+
+
+JSMSG_DATE_NOT_FINITE,
+JSMSG_INTERNAL_INTL_ERROR,
+JSMSG_INTL_OBJECT_NOT_INITED,
+JSMSG_INVALID_CURRENCY_CODE,
+JSMSG_INVALID_DIGITS_VALUE,
+JSMSG_INVALID_KEYS_TYPE,
+JSMSG_INVALID_KEY,
+JSMSG_INVALID_LANGUAGE_TAG,
+JSMSG_INVALID_LOCALES_ELEMENT,
+JSMSG_INVALID_LOCALE_MATCHER,
+JSMSG_INVALID_OPTION_VALUE,
+JSMSG_INVALID_TIME_ZONE,
+JSMSG_UNDEFINED_CURRENCY,
+
+
+JSMSG_BACK_REF_OUT_OF_RANGE,
+JSMSG_BAD_CLASS_RANGE,
+JSMSG_ESCAPE_AT_END_OF_REGEXP,
+JSMSG_EXEC_NOT_OBJORNULL,
+JSMSG_INVALID_DECIMAL_ESCAPE,
+JSMSG_INVALID_GROUP,
+JSMSG_INVALID_IDENTITY_ESCAPE,
+JSMSG_INVALID_UNICODE_ESCAPE,
+JSMSG_MISSING_PAREN,
+JSMSG_NEWREGEXP_FLAGGED,
+JSMSG_NOTHING_TO_REPEAT,
+JSMSG_NUMBERS_OUT_OF_ORDER,
+JSMSG_RANGE_WITH_CLASS_ESCAPE,
+JSMSG_RAW_BRACE_IN_REGEP,
+JSMSG_RAW_BRACKET_IN_REGEP,
+JSMSG_TOO_MANY_PARENS,
+JSMSG_UNICODE_OVERFLOW,
+JSMSG_UNMATCHED_RIGHT_PAREN,
+JSMSG_UNTERM_CLASS,
+
+
+JSMSG_DEFAULT_LOCALE_ERROR,
+JSMSG_NO_SUCH_SELF_HOSTED_PROP,
+
+
+JSMSG_INVALID_PROTOTYPE,
+JSMSG_TYPEDOBJECT_BAD_ARGS,
+JSMSG_TYPEDOBJECT_BINARYARRAY_BAD_INDEX,
+JSMSG_TYPEDOBJECT_HANDLE_UNATTACHED,
+JSMSG_TYPEDOBJECT_STRUCTTYPE_BAD_ARGS,
+JSMSG_TYPEDOBJECT_TOO_BIG,
+JSMSG_SIMD_FAILED_CONVERSION,
+JSMSG_SIMD_TO_NUMBER,
+
+
+JSMSG_TOO_LONG_ARRAY,
+
+
+JSMSG_BAD_INDEX,
+JSMSG_NON_ARRAY_BUFFER_RETURNED,
+JSMSG_SAME_ARRAY_BUFFER_RETURNED,
+JSMSG_SHORT_ARRAY_BUFFER_RETURNED,
+JSMSG_TYPED_ARRAY_BAD_ARGS,
+JSMSG_TYPED_ARRAY_NEGATIVE_ARG,
+JSMSG_TYPED_ARRAY_DETACHED,
+JSMSG_TYPED_ARRAY_CONSTRUCT_BOUNDS,
+JSMSG_TYPED_ARRAY_CALL_OR_CONSTRUCT,
+JSMSG_NON_TYPED_ARRAY_RETURNED,
+JSMSG_SHORT_TYPED_ARRAY_RETURNED,
+
+
+JSMSG_SHARED_ARRAY_BAD_LENGTH,
+JSMSG_NON_SHARED_ARRAY_BUFFER_RETURNED,
+JSMSG_SAME_SHARED_ARRAY_BUFFER_RETURNED,
+JSMSG_SHORT_SHARED_ARRAY_BUFFER_RETURNED,
+
+
+JSMSG_BAD_PARSE_NODE,
+
+
+JSMSG_SYMBOL_TO_STRING,
+JSMSG_SYMBOL_TO_NUMBER,
+
+
+JSMSG_ATOMICS_BAD_ARRAY,
+JSMSG_ATOMICS_TOO_LONG,
+JSMSG_ATOMICS_WAIT_NOT_ALLOWED,
+
+
+JSMSG_CANT_SET_INTERPOSED,
+JSMSG_CANT_DEFINE_WINDOW_ELEMENT,
+JSMSG_CANT_DELETE_WINDOW_ELEMENT,
+JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY,
+JSMSG_CANT_PREVENT_EXTENSIONS,
+JSMSG_NO_NAMED_SETTER,
+JSMSG_NO_INDEXED_SETTER,
+
+
+JSMSG_CANT_DELETE_SUPER,
+JSMSG_REINIT_THIS,
+
+
+JSMSG_BAD_DEFAULT_EXPORT,
+JSMSG_MISSING_INDIRECT_EXPORT,
+JSMSG_AMBIGUOUS_INDIRECT_EXPORT,
+JSMSG_MISSING_IMPORT,
+JSMSG_AMBIGUOUS_IMPORT,
+JSMSG_MISSING_NAMESPACE_EXPORT,
+JSMSG_MISSING_EXPORT,
+JSMSG_MODULE_INSTANTIATE_FAILED,
+JSMSG_BAD_MODULE_STATE,
+
+
+JSMSG_CANNOT_RESOLVE_PROMISE_WITH_ITSELF,
+JSMSG_PROMISE_CAPABILITY_HAS_SOMETHING_ALREADY,
+JSMSG_PROMISE_RESOLVE_FUNCTION_NOT_CALLABLE,
+JSMSG_PROMISE_REJECT_FUNCTION_NOT_CALLABLE,
+JSMSG_PROMISE_ERROR_IN_WRAPPED_REJECTION_REASON,
+
+
+JSMSG_RETURN_NOT_CALLABLE,
+JSMSG_ITERATOR_NO_THROW,
+
+
+JSMSG_FOR_AWAIT_NOT_OF,
+JSMSG_NOT_AN_ASYNC_GENERATOR,
+JSMSG_NOT_AN_ASYNC_ITERATOR,
+JSMSG_GET_ASYNC_ITER_RETURNED_PRIMITIVE,
+# 1321 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
+
+    JSErr_Limit
+} JSErrNum;
+
+namespace js {
+
+extern const JSErrorFormatString*
+GetErrorMessage(void* userRef, const unsigned errorNumber);
+# 1342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+class AutoStableStringChars
+{
+
+
+
+
+
+    static const size_t InlineCapacity = 24;
+
+
+    JS::RootedString s_;
+    union {
+        const char16_t* twoByteChars_;
+        const JS::Latin1Char* latin1Chars_;
+    };
+    mozilla::Maybe<Vector<uint8_t, InlineCapacity>> ownChars_;
+    enum State { Uninitialized, Latin1, TwoByte };
+    State state_;
+
+  public:
+    explicit AutoStableStringChars(JSContext* cx)
+      : s_(cx), state_(Uninitialized)
+    {}
+
+    __attribute__ ((warn_unused_result))
+    bool init(JSContext* cx, JSString* s);
+
+
+    __attribute__ ((warn_unused_result))
+    bool initTwoByte(JSContext* cx, JSString* s);
+
+    bool isLatin1() const { return state_ == Latin1; }
+    bool isTwoByte() const { return state_ == TwoByte; }
+
+    const char16_t* twoByteChars() const {
+        do { } while (0);
+        return twoByteChars_;
+    }
+
+    mozilla::Range<const JS::Latin1Char> latin1Range() const {
+        do { } while (0);
+        return mozilla::Range<const JS::Latin1Char>(latin1Chars_,
+                                                    GetStringLength(s_));
+    }
+
+    mozilla::Range<const char16_t> twoByteRange() const {
+        do { } while (0);
+        return mozilla::Range<const char16_t>(twoByteChars_,
+                                              GetStringLength(s_));
+    }
+
+
+    bool maybeGiveOwnershipToCaller() {
+        do { } while (0);
+        if (!ownChars_.isSome() || !ownChars_->extractRawBuffer())
+            return false;
+        state_ = Uninitialized;
+        ownChars_.reset();
+        return true;
+    }
+
+  private:
+    AutoStableStringChars(const AutoStableStringChars& other) = delete;
+    void operator=(const AutoStableStringChars& other) = delete;
+
+    bool baseIsInline(JS::Handle<JSLinearString*> linearString);
+    template <typename T> T* allocOwnChars(JSContext* cx, size_t count);
+    bool copyLatin1Chars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
+    bool copyTwoByteChars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
+    bool copyAndInflateLatin1Chars(JSContext*, JS::Handle<JSLinearString*> linearString);
+};
+
+struct ErrorReport
+{
+    explicit ErrorReport(JSContext* cx);
+    ~ErrorReport();
+
+    enum SniffingBehavior {
+        WithSideEffects,
+        NoSideEffects
+    };
+# 1452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+    bool init(JSContext* cx, JS::HandleValue exn,
+              SniffingBehavior sniffingBehavior);
+
+    JSErrorReport* report()
+    {
+        return reportp;
+    }
+
+    const JS::ConstUTF8CharsZ toStringResult()
+    {
+        return toStringResult_;
+    }
+
+  private:
+
+
+
+
+
+
+    bool populateUncaughtExceptionReportUTF8(JSContext* cx, ...);
+    bool populateUncaughtExceptionReportUTF8VA(JSContext* cx, va_list ap);
+
+
+    void ReportAddonExceptionToTelementry(JSContext* cx);
+
+
+    JSErrorReport* reportp;
+
+
+    JSErrorReport ownedReport;
+
+
+
+    JS::RootedString str;
+
+
+    AutoStableStringChars strChars;
+
+
+    JS::RootedObject exnObject;
+
+
+    JSAutoByteString filename;
+
+
+
+
+    JS::ConstUTF8CharsZ toStringResult_;
+    JSAutoByteString toStringResultBytesStorage;
+};
+
+
+extern uint64_t
+GetSCOffset(JSStructuredCloneWriter* writer);
+
+namespace Scalar {
+
+
+
+
+
+
+
+enum Type {
+    Int8 = 0,
+    Uint8,
+    Int16,
+    Uint16,
+    Int32,
+    Uint32,
+    Float32,
+    Float64,
+
+
+
+
+
+    Uint8Clamped,
+
+
+
+
+    MaxTypedArrayViewType,
+
+    Int64,
+    Float32x4,
+    Int8x16,
+    Int16x8,
+    Int32x4
+};
+
+static inline size_t
+byteSize(Type atype)
+{
+    switch (atype) {
+      case Int8:
+      case Uint8:
+      case Uint8Clamped:
+        return 1;
+      case Int16:
+      case Uint16:
+        return 2;
+      case Int32:
+      case Uint32:
+      case Float32:
+        return 4;
+      case Int64:
+      case Float64:
+        return 8;
+      case Int8x16:
+      case Int16x8:
+      case Int32x4:
+      case Float32x4:
+        return 16;
+      default:
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1568; ::abort(); } while (0); } while (0);
+    }
+}
+
+static inline bool
+isSignedIntType(Type atype) {
+    switch (atype) {
+      case Int8:
+      case Int16:
+      case Int32:
+      case Int64:
+      case Int8x16:
+      case Int16x8:
+      case Int32x4:
+        return true;
+      case Uint8:
+      case Uint8Clamped:
+      case Uint16:
+      case Uint32:
+      case Float32:
+      case Float64:
+      case Float32x4:
+        return false;
+      default:
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1592; ::abort(); } while (0); } while (0);
+    }
+}
+
+static inline bool
+isSimdType(Type atype) {
+    switch (atype) {
+      case Int8:
+      case Uint8:
+      case Uint8Clamped:
+      case Int16:
+      case Uint16:
+      case Int32:
+      case Uint32:
+      case Int64:
+      case Float32:
+      case Float64:
+        return false;
+      case Int8x16:
+      case Int16x8:
+      case Int32x4:
+      case Float32x4:
+        return true;
+      case MaxTypedArrayViewType:
+        break;
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1618; ::abort(); } while (0); } while (0);
+}
+
+static inline size_t
+scalarByteSize(Type atype) {
+    switch (atype) {
+      case Int8x16:
+        return 1;
+      case Int16x8:
+        return 2;
+      case Int32x4:
+      case Float32x4:
+        return 4;
+      case Int8:
+      case Uint8:
+      case Uint8Clamped:
+      case Int16:
+      case Uint16:
+      case Int32:
+      case Uint32:
+      case Int64:
+      case Float32:
+      case Float64:
+      case MaxTypedArrayViewType:
+        break;
+    }
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid simd type" ")"); do { *((volatile int*) __null) = 1644; ::abort(); } while (0); } while (0);
+}
+
+}
+}
+
+
+
+
+
+
+
+extern JSObject*
+JS_NewInt8Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewUint8Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewUint8ClampedArray(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewInt16Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewUint16Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewInt32Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewUint32Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewFloat32Array(JSContext* cx, uint32_t nelements);
+extern JSObject*
+JS_NewFloat64Array(JSContext* cx, uint32_t nelements);
+# 1683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern JSObject*
+JS_NewInt8ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewUint8ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewUint8ClampedArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewInt16ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewUint16ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewInt32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewUint32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewFloat32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JSObject*
+JS_NewFloat64ArrayFromArray(JSContext* cx, JS::HandleObject array);
+# 1709 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern JSObject*
+JS_NewInt8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                          uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewUint8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                           uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewUint8ClampedArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                                  uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewInt16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                           uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewUint16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                            uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewInt32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                           uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewUint32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                            uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewFloat32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                             uint32_t byteOffset, int32_t length);
+extern JSObject*
+JS_NewFloat64ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+                             uint32_t byteOffset, int32_t length);
+
+
+
+
+
+
+
+extern JSObject*
+JS_NewSharedArrayBuffer(JSContext* cx, uint32_t nbytes);
+
+
+
+
+extern JSObject*
+JS_NewArrayBuffer(JSContext* cx, uint32_t nbytes);
+
+
+
+
+
+
+
+extern bool
+JS_IsTypedArrayObject(JSObject* obj);
+# 1768 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_IsArrayBufferViewObject(JSObject* obj);
+
+
+
+
+
+extern bool
+JS_IsInt8Array(JSObject* obj);
+extern bool
+JS_IsUint8Array(JSObject* obj);
+extern bool
+JS_IsUint8ClampedArray(JSObject* obj);
+extern bool
+JS_IsInt16Array(JSObject* obj);
+extern bool
+JS_IsUint16Array(JSObject* obj);
+extern bool
+JS_IsInt32Array(JSObject* obj);
+extern bool
+JS_IsUint32Array(JSObject* obj);
+extern bool
+JS_IsFloat32Array(JSObject* obj);
+extern bool
+JS_IsFloat64Array(JSObject* obj);
+# 1802 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_GetTypedArraySharedness(JSObject* obj);
+
+
+
+
+
+
+namespace js {
+
+extern JSObject*
+UnwrapInt8Array(JSObject* obj);
+extern JSObject*
+UnwrapUint8Array(JSObject* obj);
+extern JSObject*
+UnwrapUint8ClampedArray(JSObject* obj);
+extern JSObject*
+UnwrapInt16Array(JSObject* obj);
+extern JSObject*
+UnwrapUint16Array(JSObject* obj);
+extern JSObject*
+UnwrapInt32Array(JSObject* obj);
+extern JSObject*
+UnwrapUint32Array(JSObject* obj);
+extern JSObject*
+UnwrapFloat32Array(JSObject* obj);
+extern JSObject*
+UnwrapFloat64Array(JSObject* obj);
+
+extern JSObject*
+UnwrapArrayBuffer(JSObject* obj);
+
+extern JSObject*
+UnwrapArrayBufferView(JSObject* obj);
+
+extern JSObject*
+UnwrapSharedArrayBuffer(JSObject* obj);
+
+
+namespace detail {
+
+extern const Class* const Int8ArrayClassPtr;
+extern const Class* const Uint8ArrayClassPtr;
+extern const Class* const Uint8ClampedArrayClassPtr;
+extern const Class* const Int16ArrayClassPtr;
+extern const Class* const Uint16ArrayClassPtr;
+extern const Class* const Int32ArrayClassPtr;
+extern const Class* const Uint32ArrayClassPtr;
+extern const Class* const Float32ArrayClassPtr;
+extern const Class* const Float64ArrayClassPtr;
+
+const size_t TypedArrayLengthSlot = 1;
+
+}
+# 1868 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+inline void GetInt8ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int8_t*>(GetObjectPrivate(obj)); }
+inline void GetUint8ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint8_t*>(GetObjectPrivate(obj)); }
+inline void GetUint8ClampedArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint8_t*>(GetObjectPrivate(obj)); }
+inline void GetInt16ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int16_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int16_t*>(GetObjectPrivate(obj)); }
+inline void GetUint16ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint16_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint16_t*>(GetObjectPrivate(obj)); }
+inline void GetInt32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int32_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int32_t*>(GetObjectPrivate(obj)); }
+inline void GetUint32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint32_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint32_t*>(GetObjectPrivate(obj)); }
+inline void GetFloat32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, float** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<float*>(GetObjectPrivate(obj)); }
+inline void GetFloat64ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, double** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<double*>(GetObjectPrivate(obj)); }
+
+
+
+
+
+extern void
+GetArrayBufferViewLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+
+
+
+
+
+extern void
+GetArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+
+
+
+
+extern void
+GetSharedArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+}
+
+uint8_t*
+JS_GetSharedArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+
+
+
+
+
+extern JSObject*
+JS_GetObjectAsInt8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int8_t** data);
+extern JSObject*
+JS_GetObjectAsUint8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+extern JSObject*
+JS_GetObjectAsUint8ClampedArray(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+extern JSObject*
+JS_GetObjectAsInt16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int16_t** data);
+extern JSObject*
+JS_GetObjectAsUint16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint16_t** data);
+extern JSObject*
+JS_GetObjectAsInt32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int32_t** data);
+extern JSObject*
+JS_GetObjectAsUint32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint32_t** data);
+extern JSObject*
+JS_GetObjectAsFloat32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, float** data);
+extern JSObject*
+JS_GetObjectAsFloat64Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, double** data);
+extern JSObject*
+JS_GetObjectAsArrayBufferView(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+
+
+
+extern JSObject*
+JS_GetObjectAsArrayBuffer(JSObject* obj, uint32_t* length, uint8_t** data);
+# 1944 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern js::Scalar::Type
+JS_GetArrayBufferViewType(JSObject* obj);
+
+extern js::Scalar::Type
+JS_GetSharedArrayBufferViewType(JSObject* obj);
+
+
+
+
+
+
+
+extern bool
+JS_IsArrayBufferObject(JSObject* obj);
+
+extern bool
+JS_IsSharedArrayBufferObject(JSObject* obj);
+# 1969 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern uint32_t
+JS_GetArrayBufferByteLength(JSObject* obj);
+
+extern uint32_t
+JS_GetSharedArrayBufferByteLength(JSObject* obj);
+# 1983 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+JS_ArrayBufferHasData(JSObject* obj);
+# 2000 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern uint8_t*
+JS_GetArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+
+
+
+
+
+extern bool
+JS_IsMappedArrayBufferObject(JSObject* obj);
+# 2018 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern uint32_t
+JS_GetTypedArrayLength(JSObject* obj);
+# 2029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern uint32_t
+JS_GetTypedArrayByteOffset(JSObject* obj);
+# 2039 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern uint32_t
+JS_GetTypedArrayByteLength(JSObject* obj);
+
+
+
+
+
+
+extern bool
+JS_IsArrayBufferViewObject(JSObject* obj);
+
+
+
+
+extern uint32_t
+JS_GetArrayBufferViewByteLength(JSObject* obj);
+# 2071 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern int8_t*
+JS_GetInt8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern uint8_t*
+JS_GetUint8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern uint8_t*
+JS_GetUint8ClampedArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern int16_t*
+JS_GetInt16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern uint16_t*
+JS_GetUint16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern int32_t*
+JS_GetInt32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern uint32_t*
+JS_GetUint32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern float*
+JS_GetFloat32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern double*
+JS_GetFloat64ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+
+
+
+
+extern void*
+JS_GetArrayBufferViewData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+
+
+
+
+
+extern JSObject*
+JS_GetArrayBufferViewBuffer(JSContext* cx, JS::HandleObject obj, bool* isSharedMemory);
+
+
+
+
+
+
+
+extern bool
+JS_DetachArrayBuffer(JSContext* cx, JS::HandleObject obj);
+
+
+
+
+
+
+extern bool
+JS_IsDetachedArrayBufferObject(JSObject* obj);
+
+
+
+
+bool
+JS_IsDataViewObject(JSObject* obj);
+# 2135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+JSObject*
+JS_NewDataView(JSContext* cx, JS::HandleObject buffer, uint32_t byteOffset, int32_t byteLength);
+# 2146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+uint32_t
+JS_GetDataViewByteOffset(JSObject* obj);
+# 2157 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+uint32_t
+JS_GetDataViewByteLength(JSObject* obj);
+# 2171 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+void*
+JS_GetDataViewData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+namespace js {
+# 2185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+WatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
+# 2196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+UnwatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
+
+namespace jit {
+
+enum class InlinableNative : uint16_t;
+
+}
+
+}
+
+
+
+
+
+class JSJitGetterCallArgs : protected JS::MutableHandleValue
+{
+  public:
+    explicit JSJitGetterCallArgs(const JS::CallArgs& args)
+      : JS::MutableHandleValue(args.rval())
+    {}
+
+    explicit JSJitGetterCallArgs(JS::RootedValue* rooted)
+      : JS::MutableHandleValue(rooted)
+    {}
+
+    JS::MutableHandleValue rval() {
+        return *this;
+    }
+};
+
+
+
+
+
+class JSJitSetterCallArgs : protected JS::MutableHandleValue
+{
+  public:
+    explicit JSJitSetterCallArgs(const JS::CallArgs& args)
+      : JS::MutableHandleValue(args[0])
+    {}
+
+    JS::MutableHandleValue operator[](unsigned i) {
+        do { } while (0);
+        return *this;
+    }
+
+    unsigned length() const { return 1; }
+
+
+};
+
+struct JSJitMethodCallArgsTraits;
+
+
+
+
+
+class JSJitMethodCallArgs : protected JS::detail::CallArgsBase<JS::detail::NoUsedRval>
+{
+  private:
+    typedef JS::detail::CallArgsBase<JS::detail::NoUsedRval> Base;
+    friend struct JSJitMethodCallArgsTraits;
+
+  public:
+    explicit JSJitMethodCallArgs(const JS::CallArgs& args) {
+        argv_ = args.array();
+        argc_ = args.length();
+    }
+
+    JS::MutableHandleValue rval() const {
+        return Base::rval();
+    }
+
+    unsigned length() const { return Base::length(); }
+
+    JS::MutableHandleValue operator[](unsigned i) const {
+        return Base::operator[](i);
+    }
+
+    bool hasDefined(unsigned i) const {
+        return Base::hasDefined(i);
+    }
+
+    JSObject& callee() const {
+
+
+        return argv_[-2].toObject();
+    }
+
+    JS::HandleValue get(unsigned i) const {
+        return Base::get(i);
+    }
+};
+
+struct JSJitMethodCallArgsTraits
+{
+    static const size_t offsetOfArgv = __builtin_offsetof(JSJitMethodCallArgs, argv_);
+    static const size_t offsetOfArgc = __builtin_offsetof(JSJitMethodCallArgs, argc_);
+};
+
+typedef bool
+(* JSJitGetterOp)(JSContext* cx, JS::HandleObject thisObj,
+                  void* specializedThis, JSJitGetterCallArgs args);
+typedef bool
+(* JSJitSetterOp)(JSContext* cx, JS::HandleObject thisObj,
+                  void* specializedThis, JSJitSetterCallArgs args);
+typedef bool
+(* JSJitMethodOp)(JSContext* cx, JS::HandleObject thisObj,
+                  void* specializedThis, const JSJitMethodCallArgs& args);
+
+
+
+
+
+
+struct JSJitInfo {
+    enum OpType {
+        Getter,
+        Setter,
+        Method,
+        StaticMethod,
+        InlinableNative,
+        IgnoresReturnValueNative,
+
+        OpTypeCount
+    };
+
+    enum ArgType {
+
+        String = (1 << 0),
+        Integer = (1 << 1),
+        Double = (1 << 2),
+        Boolean = (1 << 3),
+        Object = (1 << 4),
+        Null = (1 << 5),
+
+
+        Numeric = Integer | Double,
+
+
+        Primitive = Numeric | Boolean | Null | String,
+        ObjectOrNull = Object | Null,
+        Any = ObjectOrNull | Primitive,
+
+
+        ArgTypeListEnd = (1 << 31)
+    };
+
+    static_assert(Any & String, "Any must include String.");
+    static_assert(Any & Integer, "Any must include Integer.");
+    static_assert(Any & Double, "Any must include Double.");
+    static_assert(Any & Boolean, "Any must include Boolean.");
+    static_assert(Any & Object, "Any must include Object.");
+    static_assert(Any & Null, "Any must include Null.");
+
+
+
+
+
+
+    enum AliasSet {
+
+
+
+
+        AliasNone,
+
+
+
+
+
+        AliasDOMSets,
+
+
+
+
+
+        AliasEverything,
+
+
+        AliasSetCount
+    };
+
+    bool needsOuterizedThisObject() const
+    {
+        return type() != Getter && type() != Setter;
+    }
+
+    bool isTypedMethodJitInfo() const
+    {
+        return isTypedMethod;
+    }
+
+    OpType type() const
+    {
+        return OpType(type_);
+    }
+
+    AliasSet aliasSet() const
+    {
+        return AliasSet(aliasSet_);
+    }
+
+    JSValueType returnType() const
+    {
+        return JSValueType(returnType_);
+    }
+
+    union {
+        JSJitGetterOp getter;
+        JSJitSetterOp setter;
+        JSJitMethodOp method;
+
+        JSNative staticMethod;
+        JSNative ignoresReturnValueMethod;
+    };
+
+    static unsigned offsetOfIgnoresReturnValueNative() {
+        return __builtin_offsetof(JSJitInfo, ignoresReturnValueMethod);
+    }
+
+    union {
+        uint16_t protoID;
+        js::jit::InlinableNative inlinableNative;
+    };
+
+    union {
+        uint16_t depth;
+
+
+        uint16_t nativeOp;
+    };
+# 2440 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+    uint32_t type_ : 4;
+
+
+
+
+
+
+
+    uint32_t aliasSet_ : 4;
+
+
+    uint32_t returnType_ : 8;
+
+    static_assert(OpTypeCount <= (1 << 4),
+                  "Not enough space for OpType");
+    static_assert(AliasSetCount <= (1 << 4),
+                  "Not enough space for AliasSet");
+    static_assert((sizeof(JSValueType) * 8) <= 8,
+                  "Not enough space for JSValueType");
+
+
+
+
+
+
+    uint32_t isInfallible : 1;
+
+
+
+
+
+
+
+    uint32_t isMovable : 1;
+
+
+
+
+
+
+    uint32_t isEliminatable : 1;
+
+
+
+
+
+
+    uint32_t isAlwaysInSlot : 1;
+
+
+
+
+
+    uint32_t isLazilyCachedInSlot : 1;
+
+
+    uint32_t isTypedMethod : 1;
+
+
+
+
+
+
+    uint32_t slotIndex : 10;
+
+    static const size_t maxSlotIndex = (1 << 10) - 1;
+
+
+};
+
+static_assert(sizeof(JSJitInfo) == (sizeof(void*) + 2 * sizeof(uint32_t)),
+              "There are several thousand instances of JSJitInfo stored in "
+              "a binary. Please don't increase its space requirements without "
+              "verifying that there is no other way forward (better packing, "
+              "smaller datatypes for fields, subclassing, etc.).");
+
+struct JSTypedMethodJitInfo
+{
+# 2526 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+    JSJitInfo base;
+
+    const JSJitInfo::ArgType* const argTypes;
+
+
+
+
+
+};
+
+namespace js {
+
+static __attribute__((always_inline)) inline shadow::Function*
+FunctionObjectToShadowFunction(JSObject* fun)
+{
+    do { } while (0);
+    return reinterpret_cast<shadow::Function*>(fun);
+}
+
+
+static const unsigned JS_FUNCTION_INTERPRETED_BITS = 0x0201;
+
+
+static __attribute__((always_inline)) inline bool
+FunctionObjectIsNative(JSObject* fun)
+{
+    return !(FunctionObjectToShadowFunction(fun)->flags & JS_FUNCTION_INTERPRETED_BITS);
+}
+
+static __attribute__((always_inline)) inline JSNative
+GetFunctionObjectNative(JSObject* fun)
+{
+    do { } while (0);
+    return FunctionObjectToShadowFunction(fun)->native;
+}
+
+}
+
+static __attribute__((always_inline)) inline const JSJitInfo*
+FUNCTION_VALUE_TO_JITINFO(const JS::Value& v)
+{
+    do { } while (0);
+    return js::FunctionObjectToShadowFunction(&v.toObject())->jitinfo;
+}
+
+static __attribute__((always_inline)) inline void
+SET_JITINFO(JSFunction * func, const JSJitInfo* info)
+{
+    js::shadow::Function* fun = reinterpret_cast<js::shadow::Function*>(func);
+    do { } while (0);
+    fun->jitinfo = info;
+}
+
+
+
+
+
+
+static __attribute__((always_inline)) inline jsid
+JSID_FROM_BITS(size_t bits)
+{
+    jsid id;
+    (id.asBits) = bits;
+    return id;
+}
+
+namespace js {
+namespace detail {
+bool IdMatchesAtom(jsid id, JSAtom* atom);
+}
+}
+# 2619 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+static __attribute__((always_inline)) inline jsid
+NON_INTEGER_ATOM_TO_JSID(JSAtom* atom)
+{
+    do { } while (0);
+    jsid id = JSID_FROM_BITS((size_t)atom);
+    do { } while (0);
+    return id;
+}
+
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_ATOM(jsid id)
+{
+    return JSID_IS_STRING(id);
+}
+
+static __attribute__((always_inline)) inline bool
+JSID_IS_ATOM(jsid id, JSAtom* atom)
+{
+    return id == JSID_FROM_BITS((size_t)atom);
+}
+
+static __attribute__((always_inline)) inline JSAtom*
+JSID_TO_ATOM(jsid id)
+{
+    return (JSAtom*)JSID_TO_STRING(id);
+}
+
+static_assert(sizeof(jsid) == sizeof(void*), "JS_STATIC_ASSERT");
+
+namespace js {
+
+static __attribute__((always_inline)) inline JS::Value
+IdToValue(jsid id)
+{
+    if (JSID_IS_STRING(id))
+        return JS::StringValue(JSID_TO_STRING(id));
+    if (JSID_IS_INT(id))
+        return JS::Int32Value(JSID_TO_INT(id));
+    if (JSID_IS_SYMBOL(id))
+        return JS::SymbolValue(JSID_TO_SYMBOL(id));
+    do { } while (0);
+    return JS::UndefinedValue();
+}
+# 2681 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+struct ScriptEnvironmentPreparer {
+    struct Closure {
+        virtual bool operator()(JSContext* cx) = 0;
+    };
+
+    virtual void invoke(JS::HandleObject scope, Closure& closure) = 0;
+};
+
+extern void
+PrepareScriptEnvironmentAndInvoke(JSContext* cx, JS::HandleObject scope,
+                                  ScriptEnvironmentPreparer::Closure& closure);
+
+void
+SetScriptEnvironmentPreparer(JSContext* cx, ScriptEnvironmentPreparer* preparer);
+
+enum CTypesActivityType {
+    CTYPES_CALL_BEGIN,
+    CTYPES_CALL_END,
+    CTYPES_CALLBACK_BEGIN,
+    CTYPES_CALLBACK_END
+};
+
+typedef void
+(* CTypesActivityCallback)(JSContext* cx, CTypesActivityType type);
+
+
+
+
+
+void
+SetCTypesActivityCallback(JSContext* cx, CTypesActivityCallback cb);
+
+class AutoCTypesActivityCallback {
+  private:
+    JSContext* cx;
+    CTypesActivityCallback callback;
+    CTypesActivityType endType;
+
+
+  public:
+    AutoCTypesActivityCallback(JSContext* cx, CTypesActivityType beginType,
+                               CTypesActivityType endType
+                                                              );
+    ~AutoCTypesActivityCallback() {
+        DoEndCallback();
+    }
+    void DoEndCallback() {
+        if (callback) {
+            callback(cx, endType);
+            callback = nullptr;
+        }
+    }
+};
+
+
+
+struct AllocationMetadataBuilder {
+    AllocationMetadataBuilder() { }
+
+
+
+
+
+
+
+    virtual JSObject* build(JSContext* cx, JS::HandleObject obj,
+                            AutoEnterOOMUnsafeRegion& oomUnsafe) const
+    {
+        return nullptr;
+    }
+};
+
+
+
+
+
+
+void
+SetAllocationMetadataBuilder(JSContext* cx, const AllocationMetadataBuilder *callback);
+
+
+JSObject*
+GetAllocationMetadata(JSObject* obj);
+
+bool
+GetElementsWithAdder(JSContext* cx, JS::HandleObject obj, JS::HandleObject receiver,
+                     uint32_t begin, uint32_t end, js::ElementAdder* adder);
+
+bool
+ForwardToNative(JSContext* cx, JSNative native, const JS::CallArgs& args);
+# 2792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+bool
+SetPropertyIgnoringNamedGetter(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                               JS::HandleValue v, JS::HandleValue receiver,
+                               JS::Handle<JS::PropertyDescriptor> ownDesc,
+                               JS::ObjectOpResult& result);
+
+
+extern bool
+ExecuteInGlobalAndReturnScope(JSContext* cx, JS::HandleObject obj, JS::HandleScript script,
+                              JS::MutableHandleObject scope);
+# 2838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern JSObject*
+GetNearestEnclosingWithEnvironmentObjectForFunction(JSFunction* fun);
+# 2849 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern JSObject*
+GetFirstSubsumedSavedFrame(JSContext* cx, JS::HandleObject savedFrame, JS::SavedFrameSelfHosted selfHosted);
+
+extern bool
+ReportIsNotFunction(JSContext* cx, JS::HandleValue v);
+
+extern JSObject*
+ConvertArgsToArray(JSContext* cx, const JS::CallArgs& args);
+# 2878 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern void
+SetWindowProxyClass(JSContext* cx, const Class* clasp);
+
+
+
+
+
+extern void
+SetWindowProxy(JSContext* cx, JS::HandleObject global, JS::HandleObject windowProxy);
+
+namespace detail {
+
+bool
+IsWindowSlow(JSObject* obj);
+
+}
+
+
+
+
+
+inline bool
+IsWindow(JSObject* obj)
+{
+    if (GetObjectClass(obj)->flags & (1<<((8 + 8)+1)))
+        return detail::IsWindowSlow(obj);
+    return false;
+}
+
+
+
+
+bool
+IsWindowProxy(JSObject* obj);
+
+
+
+
+
+
+extern JSObject*
+ToWindowProxyIfWindow(JSObject* obj);
+
+
+
+
+
+
+extern JSObject*
+ToWindowIfWindowProxy(JSObject* obj);
+
+
+
+
+extern bool
+AddPluralRulesConstructor(JSContext* cx, JS::Handle<JSObject*> intl);
+# 2947 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
+extern bool
+AddMozDateTimeFormatConstructor(JSContext* cx, JS::Handle<JSObject*> intl);
+
+class AutoAssertNoContentJS
+{
+  public:
+    explicit AutoAssertNoContentJS(JSContext* cx);
+    ~AutoAssertNoContentJS();
+
+  private:
+    JSContext* context_;
+    bool prevAllowContentJS_;
+};
+
+
+
+
+
+extern void
+EnableAccessValidation(JSContext* cx, bool enabled);
+
+
+
+
+
+extern void
+SetCompartmentValidAccessPtr(JSContext* cx, JS::HandleObject global, bool* accessp);
+
+}
+
+class NativeProfiler
+{
+  public:
+    virtual ~NativeProfiler() {};
+    virtual void sampleNative(void* addr, uint32_t size) = 0;
+    virtual void removeNative(void* addr) = 0;
+    virtual void reset() = 0;
+};
+
+class GCHeapProfiler
+{
+  public:
+    virtual ~GCHeapProfiler() {};
+    virtual void sampleTenured(void* addr, uint32_t size) = 0;
+    virtual void sampleNursery(void* addr, uint32_t size) = 0;
+    virtual void markTenuredStart() = 0;
+    virtual void markTenured(void* addr) = 0;
+    virtual void sweepTenured() = 0;
+    virtual void sweepNursery() = 0;
+    virtual void moveNurseryToTenured(void* addrOld, void* addrNew) = 0;
+    virtual void reset() = 0;
+};
+
+class MemProfiler
+{
+    static mozilla::Atomic<uint32_t, mozilla::Relaxed> sActiveProfilerCount;
+    static NativeProfiler* sNativeProfiler;
+
+    static GCHeapProfiler* GetGCHeapProfiler(void* addr);
+    static GCHeapProfiler* GetGCHeapProfiler(JSRuntime* runtime);
+
+    static NativeProfiler* GetNativeProfiler() {
+        return sNativeProfiler;
+    }
+
+    GCHeapProfiler* mGCHeapProfiler;
+    JSRuntime* mRuntime;
+
+  public:
+    explicit MemProfiler(JSRuntime* aRuntime) : mGCHeapProfiler(nullptr), mRuntime(aRuntime) {}
+
+    void start(GCHeapProfiler* aGCHeapProfiler);
+    void stop();
+
+    GCHeapProfiler* getGCHeapProfiler() const {
+        return mGCHeapProfiler;
+    }
+
+    static __attribute__((always_inline)) inline bool enabled() {
+        return sActiveProfilerCount > 0;
+    }
+
+    static MemProfiler* GetMemProfiler(JSContext* context);
+
+    static void SetNativeProfiler(NativeProfiler* aProfiler) {
+        sNativeProfiler = aProfiler;
+    }
+
+    static __attribute__((always_inline)) inline void SampleNative(void* addr, uint32_t size) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        NativeProfiler* profiler = GetNativeProfiler();
+        if (profiler)
+            profiler->sampleNative(addr, size);
+    }
+
+    static __attribute__((always_inline)) inline void SampleTenured(void* addr, uint32_t size) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+        if (profiler)
+            profiler->sampleTenured(addr, size);
+    }
+
+    static __attribute__((always_inline)) inline void SampleNursery(void* addr, uint32_t size) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+        if (profiler)
+            profiler->sampleNursery(addr, size);
+    }
+
+    static __attribute__((always_inline)) inline void RemoveNative(void* addr) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        NativeProfiler* profiler = GetNativeProfiler();
+        if (profiler)
+            profiler->removeNative(addr);
+    }
+
+    static __attribute__((always_inline)) inline void MarkTenuredStart(JSRuntime* runtime) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+        if (profiler)
+            profiler->markTenuredStart();
+    }
+
+    static __attribute__((always_inline)) inline void MarkTenured(void* addr) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+        if (profiler)
+            profiler->markTenured(addr);
+    }
+
+    static __attribute__((always_inline)) inline void SweepTenured(JSRuntime* runtime) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+        if (profiler)
+            profiler->sweepTenured();
+    }
+
+    static __attribute__((always_inline)) inline void SweepNursery(JSRuntime* runtime) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+        if (profiler)
+            profiler->sweepNursery();
+    }
+
+    static __attribute__((always_inline)) inline void MoveNurseryToTenured(void* addrOld, void* addrNew) {
+        JS::AutoSuppressGCAnalysis nogc;
+
+        if ((__builtin_expect(!!(!enabled()), 1)))
+            return;
+
+        GCHeapProfiler* profiler = GetGCHeapProfiler(addrOld);
+        if (profiler)
+            profiler->moveNurseryToTenured(addrOld, addrNew);
+    }
+};
+# 8 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FakeString.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FakeString.h"
+namespace mozilla {
+namespace dom {
+namespace binding_detail {
+
+
+
+struct FakeString {
+  FakeString() :
+    mFlags(nsString::F_TERMINATED)
+  {
+  }
+
+  ~FakeString() {
+    if (mFlags & nsString::F_SHARED) {
+      nsStringBuffer::FromData(mData)->Release();
+    }
+  }
+
+  void Rebind(const nsString::char_type* aData, nsString::size_type aLength) {
+    do { } while (0);
+    mData = const_cast<nsString::char_type*>(aData);
+    mLength = aLength;
+  }
+
+
+
+
+  void ShareOrDependUpon(const nsAString& aString) {
+    RefPtr<nsStringBuffer> sharedBuffer = nsStringBuffer::FromString(aString);
+    if (!sharedBuffer) {
+      Rebind(aString.Data(), aString.Length());
+    } else {
+      AssignFromStringBuffer(sharedBuffer.forget());
+      mLength = aString.Length();
+    }
+  }
+
+  void Truncate() {
+    do { } while (0);
+    mData = nsString::char_traits::sEmptyBuffer;
+    mLength = 0;
+  }
+
+  void SetIsVoid(bool aValue) {
+    do { } while (0);
+
+    Truncate();
+    mFlags |= nsString::F_VOIDED;
+  }
+
+  const nsString::char_type* Data() const
+  {
+    return mData;
+  }
+
+  nsString::char_type* BeginWriting()
+  {
+    return mData;
+  }
+
+  nsString::size_type Length() const
+  {
+    return mLength;
+  }
+
+
+  bool SetLength(nsString::size_type aLength, mozilla::fallible_t const&) {
+
+    if (aLength < sInlineCapacity) {
+      SetData(mInlineStorage);
+    } else {
+      RefPtr<nsStringBuffer> buf = nsStringBuffer::Alloc((aLength + 1) * sizeof(nsString::char_type));
+      if ((__builtin_expect(!!(!buf), 0))) {
+        return false;
+      }
+
+      AssignFromStringBuffer(buf.forget());
+    }
+    mLength = aLength;
+    mData[mLength] = char16_t(0);
+    return true;
+  }
+
+
+
+  const nsAString* ToAStringPtr() const {
+    return reinterpret_cast<const nsString*>(this);
+  }
+
+operator const nsAString& () const {
+    return *reinterpret_cast<const nsString*>(this);
+  }
+
+private:
+  nsAString* ToAStringPtr() {
+    return reinterpret_cast<nsString*>(this);
+  }
+
+  nsString::char_type* mData;
+  nsString::size_type mLength;
+  uint32_t mFlags;
+
+  static const size_t sInlineCapacity = 64;
+  nsString::char_type mInlineStorage[sInlineCapacity];
+
+  FakeString(const FakeString& other) = delete;
+  void operator=(const FakeString& other) = delete;
+
+  void SetData(nsString::char_type* aData) {
+    do { } while (0);
+    mData = const_cast<nsString::char_type*>(aData);
+  }
+  void AssignFromStringBuffer(already_AddRefed<nsStringBuffer> aBuffer) {
+    SetData(static_cast<nsString::char_type*>(aBuffer.take()->Data()));
+    mFlags = nsString::F_SHARED | nsString::F_TERMINATED;
+  }
+
+  friend class NonNull<nsAString>;
+
+
+
+  class StringAsserter;
+  friend class StringAsserter;
+
+  class StringAsserter : public nsString {
+  public:
+    static void StaticAsserts() {
+      static_assert(__builtin_offsetof(FakeString, mInlineStorage) ==
+                      sizeof(nsString),
+                    "FakeString should include all nsString members");
+      static_assert(__builtin_offsetof(FakeString, mData) ==
+                      __builtin_offsetof(StringAsserter, mData),
+                    "Offset of mData should match");
+      static_assert(__builtin_offsetof(FakeString, mLength) ==
+                      __builtin_offsetof(StringAsserter, mLength),
+                    "Offset of mLength should match");
+      static_assert(__builtin_offsetof(FakeString, mFlags) ==
+                      __builtin_offsetof(StringAsserter, mFlags),
+                    "Offset of mFlags should match");
+    }
+  };
+};
+}
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h"
+namespace mozilla {
+namespace dom {
+
+
+
+
+struct TypedArrayObjectStorage : AllTypedArraysBase {
+protected:
+  JSObject* mTypedObj;
+  JSObject* mWrappedObj;
+
+  TypedArrayObjectStorage()
+    : mTypedObj(nullptr),
+      mWrappedObj(nullptr)
+  {
+  }
+
+  TypedArrayObjectStorage(TypedArrayObjectStorage&& aOther)
+    : mTypedObj(aOther.mTypedObj),
+      mWrappedObj(aOther.mWrappedObj)
+  {
+    aOther.mTypedObj = nullptr;
+    aOther.mWrappedObj = nullptr;
+  }
+
+public:
+  inline void TraceSelf(JSTracer* trc)
+  {
+    JS::UnsafeTraceRoot(trc, &mTypedObj, "TypedArray.mTypedObj");
+    JS::UnsafeTraceRoot(trc, &mTypedObj, "TypedArray.mWrappedObj");
+  }
+
+private:
+  TypedArrayObjectStorage(const TypedArrayObjectStorage&) = delete;
+};
+
+
+
+
+
+
+
+template<typename T,
+         JSObject* UnwrapArray(JSObject*),
+         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*, T**)>
+struct TypedArray_base : public TypedArrayObjectStorage {
+  typedef T element_type;
+
+  TypedArray_base()
+    : mData(nullptr),
+      mLength(0),
+      mShared(false),
+      mComputed(false)
+  {
+  }
+
+  TypedArray_base(TypedArray_base&& aOther)
+    : TypedArrayObjectStorage(Move(aOther)),
+      mData(aOther.mData),
+      mLength(aOther.mLength),
+      mShared(aOther.mShared),
+      mComputed(aOther.mComputed)
+  {
+    aOther.mData = nullptr;
+    aOther.mLength = 0;
+    aOther.mShared = false;
+    aOther.mComputed = false;
+  }
+
+private:
+  mutable T* mData;
+  mutable uint32_t mLength;
+  mutable bool mShared;
+  mutable bool mComputed;
+
+public:
+  inline bool Init(JSObject* obj)
+  {
+    do { } while (0);
+    mTypedObj = mWrappedObj = UnwrapArray(obj);
+    return inited();
+  }
+
+  inline bool inited() const {
+    return !!mTypedObj;
+  }
+# 147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h"
+  inline bool IsShared() const {
+    do { } while (0);
+    return mShared;
+  }
+
+  inline T *Data() const {
+    do { } while (0);
+    if (mShared)
+      return nullptr;
+    return mData;
+  }
+
+  inline T *DataAllowShared() const {
+    do { } while (0);
+    return mData;
+  }
+
+  inline uint32_t Length() const {
+    do { } while (0);
+    if (mShared)
+      return 0;
+    return mLength;
+  }
+
+  inline uint32_t LengthAllowShared() const {
+    do { } while (0);
+    return mLength;
+  }
+
+  inline JSObject *Obj() const {
+    do { } while (0);
+    return mWrappedObj;
+  }
+
+  inline bool WrapIntoNewCompartment(JSContext* cx)
+  {
+    return JS_WrapObject(cx,
+      JS::MutableHandle<JSObject*>::fromMarkedLocation(&mWrappedObj));
+  }
+
+  inline void ComputeLengthAndData() const
+  {
+    do { } while (0);
+    do { } while (0);
+    GetLengthAndDataAndSharedness(mTypedObj, &mLength, &mShared, &mData);
+    mComputed = true;
+  }
+
+private:
+  TypedArray_base(const TypedArray_base&) = delete;
+};
+
+template<typename T,
+         JSObject* UnwrapArray(JSObject*),
+         T* GetData(JSObject*, bool* isShared, const JS::AutoCheckCannotGC&),
+         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*, T**),
+         JSObject* CreateNew(JSContext*, uint32_t)>
+struct TypedArray
+  : public TypedArray_base<T, UnwrapArray, GetLengthAndDataAndSharedness>
+{
+private:
+  typedef TypedArray_base<T, UnwrapArray, GetLengthAndDataAndSharedness> Base;
+
+public:
+  TypedArray()
+    : Base()
+  {}
+
+  TypedArray(TypedArray&& aOther)
+    : Base(Move(aOther))
+  {
+  }
+
+  static inline JSObject*
+  Create(JSContext* cx, nsWrapperCache* creator, uint32_t length,
+         const T* data = nullptr) {
+    JS::Rooted<JSObject*> creatorWrapper(cx);
+    Maybe<JSAutoCompartment> ac;
+    if (creator && (creatorWrapper = creator->GetWrapperPreserveColor())) {
+      ac.emplace(cx, creatorWrapper);
+    }
+
+    return CreateCommon(cx, length, data);
+  }
+
+  static inline JSObject*
+  Create(JSContext* cx, uint32_t length, const T* data = nullptr) {
+    return CreateCommon(cx, length, data);
+  }
+
+private:
+  static inline JSObject*
+  CreateCommon(JSContext* cx, uint32_t length, const T* data) {
+    JSObject* obj = CreateNew(cx, length);
+    if (!obj) {
+      return nullptr;
+    }
+    if (data) {
+      JS::AutoCheckCannotGC nogc;
+      bool isShared;
+      T* buf = static_cast<T*>(GetData(obj, &isShared, nogc));
+
+
+      do { } while (0);
+      memcpy(buf, data, length*sizeof(T));
+    }
+    return obj;
+  }
+
+  TypedArray(const TypedArray&) = delete;
+};
+
+template<JSObject* UnwrapArray(JSObject*),
+         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*,
+                                            uint8_t**),
+         js::Scalar::Type GetViewType(JSObject*)>
+struct ArrayBufferView_base
+  : public TypedArray_base<uint8_t, UnwrapArray, GetLengthAndDataAndSharedness>
+{
+private:
+  typedef TypedArray_base<uint8_t, UnwrapArray, GetLengthAndDataAndSharedness>
+          Base;
+
+public:
+  ArrayBufferView_base()
+    : Base()
+  {
+  }
+
+  ArrayBufferView_base(ArrayBufferView_base&& aOther)
+    : Base(Move(aOther)),
+      mType(aOther.mType)
+  {
+    aOther.mType = js::Scalar::MaxTypedArrayViewType;
+  }
+
+private:
+  js::Scalar::Type mType;
+
+public:
+  inline bool Init(JSObject* obj)
+  {
+    if (!Base::Init(obj)) {
+      return false;
+    }
+
+    mType = GetViewType(this->Obj());
+    return true;
+  }
+
+  inline js::Scalar::Type Type() const
+  {
+    do { } while (0);
+    return mType;
+  }
+};
+
+typedef TypedArray<int8_t, js::UnwrapInt8Array, JS_GetInt8ArrayData,
+                   js::GetInt8ArrayLengthAndData, JS_NewInt8Array>
+        Int8Array;
+typedef TypedArray<uint8_t, js::UnwrapUint8Array, JS_GetUint8ArrayData,
+                   js::GetUint8ArrayLengthAndData, JS_NewUint8Array>
+        Uint8Array;
+typedef TypedArray<uint8_t, js::UnwrapUint8ClampedArray, JS_GetUint8ClampedArrayData,
+                   js::GetUint8ClampedArrayLengthAndData, JS_NewUint8ClampedArray>
+        Uint8ClampedArray;
+typedef TypedArray<int16_t, js::UnwrapInt16Array, JS_GetInt16ArrayData,
+                   js::GetInt16ArrayLengthAndData, JS_NewInt16Array>
+        Int16Array;
+typedef TypedArray<uint16_t, js::UnwrapUint16Array, JS_GetUint16ArrayData,
+                   js::GetUint16ArrayLengthAndData, JS_NewUint16Array>
+        Uint16Array;
+typedef TypedArray<int32_t, js::UnwrapInt32Array, JS_GetInt32ArrayData,
+                   js::GetInt32ArrayLengthAndData, JS_NewInt32Array>
+        Int32Array;
+typedef TypedArray<uint32_t, js::UnwrapUint32Array, JS_GetUint32ArrayData,
+                   js::GetUint32ArrayLengthAndData, JS_NewUint32Array>
+        Uint32Array;
+typedef TypedArray<float, js::UnwrapFloat32Array, JS_GetFloat32ArrayData,
+                   js::GetFloat32ArrayLengthAndData, JS_NewFloat32Array>
+        Float32Array;
+typedef TypedArray<double, js::UnwrapFloat64Array, JS_GetFloat64ArrayData,
+                   js::GetFloat64ArrayLengthAndData, JS_NewFloat64Array>
+        Float64Array;
+typedef ArrayBufferView_base<js::UnwrapArrayBufferView,
+                             js::GetArrayBufferViewLengthAndData,
+                             JS_GetArrayBufferViewType>
+        ArrayBufferView;
+typedef TypedArray<uint8_t, js::UnwrapArrayBuffer, JS_GetArrayBufferData,
+                   js::GetArrayBufferLengthAndData, JS_NewArrayBuffer>
+        ArrayBuffer;
+
+typedef TypedArray<uint8_t, js::UnwrapSharedArrayBuffer, JS_GetSharedArrayBufferData,
+                   js::GetSharedArrayBufferLengthAndData, JS_NewSharedArrayBuffer>
+        SharedArrayBuffer;
+
+
+
+
+
+template<typename TypedArrayType>
+class TypedArrayCreator
+{
+  typedef nsTArray<typename TypedArrayType::element_type> ArrayType;
+
+  public:
+    explicit TypedArrayCreator(const ArrayType& aArray)
+      : mArray(aArray)
+    {}
+
+    JSObject* Create(JSContext* aCx) const
+    {
+      return TypedArrayType::Create(aCx, mArray.Length(), mArray.Elements());
+    }
+
+  private:
+    const ArrayType& mArray;
+};
+
+
+template<typename ArrayType>
+class TypedArrayRooter : private JS::CustomAutoRooter
+{
+public:
+  template <typename CX>
+  TypedArrayRooter(const CX& cx,
+                   ArrayType* aArray ) :
+    JS::CustomAutoRooter(cx ),
+    mArray(aArray)
+  {
+  }
+
+  virtual void trace(JSTracer* trc) override
+  {
+    mArray->TraceSelf(trc);
+  }
+
+private:
+  TypedArrayObjectStorage* const mArray;
+};
+
+
+template<typename Inner> struct Nullable;
+template<typename ArrayType>
+class TypedArrayRooter<Nullable<ArrayType> > :
+    private JS::CustomAutoRooter
+{
+public:
+  template <typename CX>
+  TypedArrayRooter(const CX& cx,
+                   Nullable<ArrayType>* aArray ) :
+    JS::CustomAutoRooter(cx ),
+    mArray(aArray)
+  {
+  }
+
+  virtual void trace(JSTracer* trc) override
+  {
+    if (!mArray->IsNull()) {
+      mArray->Value().TraceSelf(trc);
+    }
+  }
+
+private:
+  Nullable<ArrayType>* const mArray;
+};
+
+
+template<typename ArrayType>
+class RootedTypedArray final : public ArrayType,
+                                        private TypedArrayRooter<ArrayType>
+{
+public:
+  template <typename CX>
+  explicit RootedTypedArray(const CX& cx ) :
+    ArrayType(),
+    TypedArrayRooter<ArrayType>(cx, this
+                                                                         )
+  {
+  }
+
+  template <typename CX>
+  RootedTypedArray(const CX& cx, JSObject* obj ) :
+    ArrayType(obj),
+    TypedArrayRooter<ArrayType>(cx, this
+                                                                         )
+  {
+  }
+};
+
+}
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UnionMember.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UnionMember.h"
+namespace mozilla {
+namespace dom {
+
+
+
+template<class T>
+class UnionMember
+{
+  AlignedStorage2<T> mStorage;
+
+
+
+  UnionMember(const UnionMember&) = delete;
+
+public:
+  UnionMember() = default;
+  ~UnionMember() = default;
+
+  T& SetValue()
+  {
+    new (mStorage.addr()) T();
+    return *mStorage.addr();
+  }
+  template <typename T1>
+  T& SetValue(const T1& aValue)
+  {
+    new (mStorage.addr()) T(aValue);
+    return *mStorage.addr();
+  }
+  template<typename T1, typename T2>
+  T& SetValue(const T1& aValue1, const T2& aValue2)
+  {
+    new (mStorage.addr()) T(aValue1, aValue2);
+    return *mStorage.addr();
+  }
+  T& Value()
+  {
+    return *mStorage.addr();
+  }
+  const T& Value() const
+  {
+    return *mStorage.addr();
+  }
+  void Destroy()
+  {
+    mStorage.addr()->~T();
+  }
+};
+
+}
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
+
+namespace mozilla {
+namespace dom {
+
+class Blob;
+class CanvasRenderingContext2D;
+struct ChannelPixelLayoutAtoms;
+class HTMLCanvasElement;
+class HTMLImageElement;
+class HTMLVideoElement;
+class ImageBitmap;
+struct ImageBitmapAtoms;
+class ImageData;
+struct NativePropertyHooks;
+class OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer;
+class ProtoAndIfaceCache;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class ImageBitmapFormat : uint8_t {
+  RGBA32,
+  BGRA32,
+  RGB24,
+  BGR24,
+  GRAY8,
+  YUV444P,
+  YUV422P,
+  YUV420P,
+  YUV420SP_NV12,
+  YUV420SP_NV21,
+  HSV,
+  Lab,
+  DEPTH,
+  EndGuard_
+};
+
+namespace ImageBitmapFormatValues {
+extern const EnumEntry strings[14];
+}
+
+bool
+ToJSValue(JSContext* aCx, ImageBitmapFormat aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+enum class ChannelPixelLayoutDataType : uint8_t {
+  Uint8,
+  Int8,
+  Uint16,
+  Int16,
+  Uint32,
+  Int32,
+  Float32,
+  Float64,
+  EndGuard_
+};
+
+namespace ChannelPixelLayoutDataTypeValues {
+extern const EnumEntry strings[9];
+}
+
+bool
+ToJSValue(JSContext* aCx, ChannelPixelLayoutDataType aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion, const char* aName, uint32_t aFlags = 0);
+
+
+void
+ImplCycleCollectionUnlink(OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion);
+
+
+struct ChannelPixelLayout : public DictionaryBase
+{
+                        ChannelPixelLayoutDataType mDataType;
+                        uint32_t mHeight;
+                        uint32_t mOffset;
+                        uint32_t mSkip;
+                        uint32_t mStride;
+                        uint32_t mWidth;
+
+  ChannelPixelLayout();
+
+  explicit inline ChannelPixelLayout(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline ChannelPixelLayout(const ChannelPixelLayout& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  ChannelPixelLayout&
+  operator=(const ChannelPixelLayout& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, ChannelPixelLayoutAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastChannelPixelLayout : public ChannelPixelLayout
+{
+  inline FastChannelPixelLayout()
+    : ChannelPixelLayout(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+class HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer
+{
+  friend class HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBufferArgument;
+  enum Type
+  {
+    eUninitialized,
+    eHTMLImageElement,
+    eHTMLVideoElement,
+    eHTMLCanvasElement,
+    eBlob,
+    eImageData,
+    eCanvasRenderingContext2D,
+    eImageBitmap,
+    eArrayBufferView,
+    eArrayBuffer
+  };
+
+  union Value
+  {
+    UnionMember<NonNull<mozilla::dom::HTMLImageElement> > mHTMLImageElement;
+    UnionMember<NonNull<mozilla::dom::HTMLVideoElement> > mHTMLVideoElement;
+    UnionMember<NonNull<mozilla::dom::HTMLCanvasElement> > mHTMLCanvasElement;
+    UnionMember<NonNull<mozilla::dom::Blob> > mBlob;
+    UnionMember<NonNull<mozilla::dom::ImageData> > mImageData;
+    UnionMember<NonNull<mozilla::dom::CanvasRenderingContext2D> > mCanvasRenderingContext2D;
+    UnionMember<NonNull<mozilla::dom::ImageBitmap> > mImageBitmap;
+    UnionMember<RootedTypedArray<ArrayBufferView> > mArrayBufferView;
+    UnionMember<RootedTypedArray<ArrayBuffer> > mArrayBuffer;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+  HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer(const HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
+  HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& operator=(const HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
+public:
+  explicit inline HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
+    : mType(eUninitialized)
+  {
+  }
+
+  inline ~HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
+  {
+    Uninit();
+  }
+
+  inline NonNull<mozilla::dom::HTMLImageElement>&
+  RawSetAsHTMLImageElement()
+  {
+    if (mType == eHTMLImageElement) {
+      return mValue.mHTMLImageElement.Value();
+    }
+    do { } while (0);
+    mType = eHTMLImageElement;
+    return mValue.mHTMLImageElement.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::HTMLImageElement>&
+  SetAsHTMLImageElement()
+  {
+    if (mType == eHTMLImageElement) {
+      return mValue.mHTMLImageElement.Value();
+    }
+    Uninit();
+    mType = eHTMLImageElement;
+    return mValue.mHTMLImageElement.SetValue();
+  }
+
+  inline bool
+  IsHTMLImageElement() const
+  {
+    return mType == eHTMLImageElement;
+  }
+
+  inline NonNull<mozilla::dom::HTMLImageElement>&
+  GetAsHTMLImageElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLImageElement.Value();
+  }
+
+  inline mozilla::dom::HTMLImageElement&
+  GetAsHTMLImageElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLImageElement.Value();
+  }
+
+  inline NonNull<mozilla::dom::HTMLVideoElement>&
+  RawSetAsHTMLVideoElement()
+  {
+    if (mType == eHTMLVideoElement) {
+      return mValue.mHTMLVideoElement.Value();
+    }
+    do { } while (0);
+    mType = eHTMLVideoElement;
+    return mValue.mHTMLVideoElement.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::HTMLVideoElement>&
+  SetAsHTMLVideoElement()
+  {
+    if (mType == eHTMLVideoElement) {
+      return mValue.mHTMLVideoElement.Value();
+    }
+    Uninit();
+    mType = eHTMLVideoElement;
+    return mValue.mHTMLVideoElement.SetValue();
+  }
+
+  inline bool
+  IsHTMLVideoElement() const
+  {
+    return mType == eHTMLVideoElement;
+  }
+
+  inline NonNull<mozilla::dom::HTMLVideoElement>&
+  GetAsHTMLVideoElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLVideoElement.Value();
+  }
+
+  inline mozilla::dom::HTMLVideoElement&
+  GetAsHTMLVideoElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLVideoElement.Value();
+  }
+
+  inline NonNull<mozilla::dom::HTMLCanvasElement>&
+  RawSetAsHTMLCanvasElement()
+  {
+    if (mType == eHTMLCanvasElement) {
+      return mValue.mHTMLCanvasElement.Value();
+    }
+    do { } while (0);
+    mType = eHTMLCanvasElement;
+    return mValue.mHTMLCanvasElement.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::HTMLCanvasElement>&
+  SetAsHTMLCanvasElement()
+  {
+    if (mType == eHTMLCanvasElement) {
+      return mValue.mHTMLCanvasElement.Value();
+    }
+    Uninit();
+    mType = eHTMLCanvasElement;
+    return mValue.mHTMLCanvasElement.SetValue();
+  }
+
+  inline bool
+  IsHTMLCanvasElement() const
+  {
+    return mType == eHTMLCanvasElement;
+  }
+
+  inline NonNull<mozilla::dom::HTMLCanvasElement>&
+  GetAsHTMLCanvasElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLCanvasElement.Value();
+  }
+
+  inline mozilla::dom::HTMLCanvasElement&
+  GetAsHTMLCanvasElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLCanvasElement.Value();
+  }
+
+  inline NonNull<mozilla::dom::Blob>&
+  RawSetAsBlob()
+  {
+    if (mType == eBlob) {
+      return mValue.mBlob.Value();
+    }
+    do { } while (0);
+    mType = eBlob;
+    return mValue.mBlob.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::Blob>&
+  SetAsBlob()
+  {
+    if (mType == eBlob) {
+      return mValue.mBlob.Value();
+    }
+    Uninit();
+    mType = eBlob;
+    return mValue.mBlob.SetValue();
+  }
+
+  inline bool
+  IsBlob() const
+  {
+    return mType == eBlob;
+  }
+
+  inline NonNull<mozilla::dom::Blob>&
+  GetAsBlob()
+  {
+    do { } while (0);
+    return mValue.mBlob.Value();
+  }
+
+  inline mozilla::dom::Blob&
+  GetAsBlob() const
+  {
+    do { } while (0);
+    return mValue.mBlob.Value();
+  }
+
+  inline NonNull<mozilla::dom::ImageData>&
+  RawSetAsImageData()
+  {
+    if (mType == eImageData) {
+      return mValue.mImageData.Value();
+    }
+    do { } while (0);
+    mType = eImageData;
+    return mValue.mImageData.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::ImageData>&
+  SetAsImageData()
+  {
+    if (mType == eImageData) {
+      return mValue.mImageData.Value();
+    }
+    Uninit();
+    mType = eImageData;
+    return mValue.mImageData.SetValue();
+  }
+
+  inline bool
+  IsImageData() const
+  {
+    return mType == eImageData;
+  }
+
+  inline NonNull<mozilla::dom::ImageData>&
+  GetAsImageData()
+  {
+    do { } while (0);
+    return mValue.mImageData.Value();
+  }
+
+  inline mozilla::dom::ImageData&
+  GetAsImageData() const
+  {
+    do { } while (0);
+    return mValue.mImageData.Value();
+  }
+
+  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
+  RawSetAsCanvasRenderingContext2D()
+  {
+    if (mType == eCanvasRenderingContext2D) {
+      return mValue.mCanvasRenderingContext2D.Value();
+    }
+    do { } while (0);
+    mType = eCanvasRenderingContext2D;
+    return mValue.mCanvasRenderingContext2D.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
+  SetAsCanvasRenderingContext2D()
+  {
+    if (mType == eCanvasRenderingContext2D) {
+      return mValue.mCanvasRenderingContext2D.Value();
+    }
+    Uninit();
+    mType = eCanvasRenderingContext2D;
+    return mValue.mCanvasRenderingContext2D.SetValue();
+  }
+
+  inline bool
+  IsCanvasRenderingContext2D() const
+  {
+    return mType == eCanvasRenderingContext2D;
+  }
+
+  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
+  GetAsCanvasRenderingContext2D()
+  {
+    do { } while (0);
+    return mValue.mCanvasRenderingContext2D.Value();
+  }
+
+  inline mozilla::dom::CanvasRenderingContext2D&
+  GetAsCanvasRenderingContext2D() const
+  {
+    do { } while (0);
+    return mValue.mCanvasRenderingContext2D.Value();
+  }
+
+  inline NonNull<mozilla::dom::ImageBitmap>&
+  RawSetAsImageBitmap()
+  {
+    if (mType == eImageBitmap) {
+      return mValue.mImageBitmap.Value();
+    }
+    do { } while (0);
+    mType = eImageBitmap;
+    return mValue.mImageBitmap.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::ImageBitmap>&
+  SetAsImageBitmap()
+  {
+    if (mType == eImageBitmap) {
+      return mValue.mImageBitmap.Value();
+    }
+    Uninit();
+    mType = eImageBitmap;
+    return mValue.mImageBitmap.SetValue();
+  }
+
+  inline bool
+  IsImageBitmap() const
+  {
+    return mType == eImageBitmap;
+  }
+
+  inline NonNull<mozilla::dom::ImageBitmap>&
+  GetAsImageBitmap()
+  {
+    do { } while (0);
+    return mValue.mImageBitmap.Value();
+  }
+
+  inline mozilla::dom::ImageBitmap&
+  GetAsImageBitmap() const
+  {
+    do { } while (0);
+    return mValue.mImageBitmap.Value();
+  }
+
+  inline RootedTypedArray<ArrayBufferView>&
+  RawSetAsArrayBufferView(JSContext* cx)
+  {
+    if (mType == eArrayBufferView) {
+      return mValue.mArrayBufferView.Value();
+    }
+    do { } while (0);
+    mType = eArrayBufferView;
+    return mValue.mArrayBufferView.SetValue(cx);
+  }
+
+  inline RootedTypedArray<ArrayBufferView>&
+  SetAsArrayBufferView(JSContext* cx)
+  {
+    if (mType == eArrayBufferView) {
+      return mValue.mArrayBufferView.Value();
+    }
+    Uninit();
+    mType = eArrayBufferView;
+    return mValue.mArrayBufferView.SetValue(cx);
+  }
+
+  inline bool
+  IsArrayBufferView() const
+  {
+    return mType == eArrayBufferView;
+  }
+
+  inline RootedTypedArray<ArrayBufferView>&
+  GetAsArrayBufferView()
+  {
+    do { } while (0);
+    return mValue.mArrayBufferView.Value();
+  }
+
+  inline ArrayBufferView const &
+  GetAsArrayBufferView() const
+  {
+    do { } while (0);
+    return mValue.mArrayBufferView.Value();
+  }
+
+  inline RootedTypedArray<ArrayBuffer>&
+  RawSetAsArrayBuffer(JSContext* cx)
+  {
+    if (mType == eArrayBuffer) {
+      return mValue.mArrayBuffer.Value();
+    }
+    do { } while (0);
+    mType = eArrayBuffer;
+    return mValue.mArrayBuffer.SetValue(cx);
+  }
+
+  inline RootedTypedArray<ArrayBuffer>&
+  SetAsArrayBuffer(JSContext* cx)
+  {
+    if (mType == eArrayBuffer) {
+      return mValue.mArrayBuffer.Value();
+    }
+    Uninit();
+    mType = eArrayBuffer;
+    return mValue.mArrayBuffer.SetValue(cx);
+  }
+
+  inline bool
+  IsArrayBuffer() const
+  {
+    return mType == eArrayBuffer;
+  }
+
+  inline RootedTypedArray<ArrayBuffer>&
+  GetAsArrayBuffer()
+  {
+    do { } while (0);
+    return mValue.mArrayBuffer.Value();
+  }
+
+  inline ArrayBuffer const &
+  GetAsArrayBuffer() const
+  {
+    do { } while (0);
+    return mValue.mArrayBuffer.Value();
+  }
+
+  inline void
+  Uninit()
+  {
+    switch (mType) {
+      case eUninitialized: {
+        break;
+      }
+      case eHTMLImageElement: {
+        DestroyHTMLImageElement();
+        break;
+      }
+      case eHTMLVideoElement: {
+        DestroyHTMLVideoElement();
+        break;
+      }
+      case eHTMLCanvasElement: {
+        DestroyHTMLCanvasElement();
+        break;
+      }
+      case eBlob: {
+        DestroyBlob();
+        break;
+      }
+      case eImageData: {
+        DestroyImageData();
+        break;
+      }
+      case eCanvasRenderingContext2D: {
+        DestroyCanvasRenderingContext2D();
+        break;
+      }
+      case eImageBitmap: {
+        DestroyImageBitmap();
+        break;
+      }
+      case eArrayBufferView: {
+        DestroyArrayBufferView();
+        break;
+      }
+      case eArrayBuffer: {
+        DestroyArrayBuffer();
+        break;
+      }
+    }
+  }
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+private:
+  inline void
+  DestroyHTMLImageElement()
+  {
+    do { } while (0);
+    mValue.mHTMLImageElement.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyHTMLVideoElement()
+  {
+    do { } while (0);
+    mValue.mHTMLVideoElement.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyHTMLCanvasElement()
+  {
+    do { } while (0);
+    mValue.mHTMLCanvasElement.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyBlob()
+  {
+    do { } while (0);
+    mValue.mBlob.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyImageData()
+  {
+    do { } while (0);
+    mValue.mImageData.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyCanvasRenderingContext2D()
+  {
+    do { } while (0);
+    mValue.mCanvasRenderingContext2D.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyImageBitmap()
+  {
+    do { } while (0);
+    mValue.mImageBitmap.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyArrayBufferView()
+  {
+    do { } while (0);
+    mValue.mArrayBufferView.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyArrayBuffer()
+  {
+    do { } while (0);
+    mValue.mArrayBuffer.Destroy();
+    mType = eUninitialized;
+  }
+};
+
+
+class OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer : public AllOwningUnionBase
+{
+  friend void ImplCycleCollectionUnlink(OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion);
+  enum Type
+  {
+    eUninitialized,
+    eHTMLImageElement,
+    eHTMLVideoElement,
+    eHTMLCanvasElement,
+    eBlob,
+    eImageData,
+    eCanvasRenderingContext2D,
+    eImageBitmap,
+    eArrayBufferView,
+    eArrayBuffer
+  };
+
+  union Value
+  {
+    UnionMember<OwningNonNull<mozilla::dom::HTMLImageElement> > mHTMLImageElement;
+    UnionMember<OwningNonNull<mozilla::dom::HTMLVideoElement> > mHTMLVideoElement;
+    UnionMember<OwningNonNull<mozilla::dom::HTMLCanvasElement> > mHTMLCanvasElement;
+    UnionMember<OwningNonNull<mozilla::dom::Blob> > mBlob;
+    UnionMember<OwningNonNull<mozilla::dom::ImageData> > mImageData;
+    UnionMember<OwningNonNull<mozilla::dom::CanvasRenderingContext2D> > mCanvasRenderingContext2D;
+    UnionMember<OwningNonNull<mozilla::dom::ImageBitmap> > mImageBitmap;
+    UnionMember<ArrayBufferView > mArrayBufferView;
+    UnionMember<ArrayBuffer > mArrayBuffer;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+  OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer(const OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
+  OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& operator=(const OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
+public:
+  explicit inline OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
+    : mType(eUninitialized)
+  {
+  }
+
+  inline ~OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
+  {
+    Uninit();
+  }
+
+  OwningNonNull<mozilla::dom::HTMLImageElement>&
+  RawSetAsHTMLImageElement();
+
+  OwningNonNull<mozilla::dom::HTMLImageElement>&
+  SetAsHTMLImageElement();
+
+  bool
+  TrySetToHTMLImageElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsHTMLImageElement() const
+  {
+    return mType == eHTMLImageElement;
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLImageElement>&
+  GetAsHTMLImageElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLImageElement.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLImageElement> const &
+  GetAsHTMLImageElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLImageElement.Value();
+  }
+
+  OwningNonNull<mozilla::dom::HTMLVideoElement>&
+  RawSetAsHTMLVideoElement();
+
+  OwningNonNull<mozilla::dom::HTMLVideoElement>&
+  SetAsHTMLVideoElement();
+
+  bool
+  TrySetToHTMLVideoElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsHTMLVideoElement() const
+  {
+    return mType == eHTMLVideoElement;
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLVideoElement>&
+  GetAsHTMLVideoElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLVideoElement.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLVideoElement> const &
+  GetAsHTMLVideoElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLVideoElement.Value();
+  }
+
+  OwningNonNull<mozilla::dom::HTMLCanvasElement>&
+  RawSetAsHTMLCanvasElement();
+
+  OwningNonNull<mozilla::dom::HTMLCanvasElement>&
+  SetAsHTMLCanvasElement();
+
+  bool
+  TrySetToHTMLCanvasElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsHTMLCanvasElement() const
+  {
+    return mType == eHTMLCanvasElement;
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLCanvasElement>&
+  GetAsHTMLCanvasElement()
+  {
+    do { } while (0);
+    return mValue.mHTMLCanvasElement.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::HTMLCanvasElement> const &
+  GetAsHTMLCanvasElement() const
+  {
+    do { } while (0);
+    return mValue.mHTMLCanvasElement.Value();
+  }
+
+  OwningNonNull<mozilla::dom::Blob>&
+  RawSetAsBlob();
+
+  OwningNonNull<mozilla::dom::Blob>&
+  SetAsBlob();
+
+  bool
+  TrySetToBlob(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsBlob() const
+  {
+    return mType == eBlob;
+  }
+
+  inline OwningNonNull<mozilla::dom::Blob>&
+  GetAsBlob()
+  {
+    do { } while (0);
+    return mValue.mBlob.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::Blob> const &
+  GetAsBlob() const
+  {
+    do { } while (0);
+    return mValue.mBlob.Value();
+  }
+
+  OwningNonNull<mozilla::dom::ImageData>&
+  RawSetAsImageData();
+
+  OwningNonNull<mozilla::dom::ImageData>&
+  SetAsImageData();
+
+  bool
+  TrySetToImageData(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsImageData() const
+  {
+    return mType == eImageData;
+  }
+
+  inline OwningNonNull<mozilla::dom::ImageData>&
+  GetAsImageData()
+  {
+    do { } while (0);
+    return mValue.mImageData.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::ImageData> const &
+  GetAsImageData() const
+  {
+    do { } while (0);
+    return mValue.mImageData.Value();
+  }
+
+  OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
+  RawSetAsCanvasRenderingContext2D();
+
+  OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
+  SetAsCanvasRenderingContext2D();
+
+  bool
+  TrySetToCanvasRenderingContext2D(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsCanvasRenderingContext2D() const
+  {
+    return mType == eCanvasRenderingContext2D;
+  }
+
+  inline OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
+  GetAsCanvasRenderingContext2D()
+  {
+    do { } while (0);
+    return mValue.mCanvasRenderingContext2D.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::CanvasRenderingContext2D> const &
+  GetAsCanvasRenderingContext2D() const
+  {
+    do { } while (0);
+    return mValue.mCanvasRenderingContext2D.Value();
+  }
+
+  OwningNonNull<mozilla::dom::ImageBitmap>&
+  RawSetAsImageBitmap();
+
+  OwningNonNull<mozilla::dom::ImageBitmap>&
+  SetAsImageBitmap();
+
+  bool
+  TrySetToImageBitmap(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsImageBitmap() const
+  {
+    return mType == eImageBitmap;
+  }
+
+  inline OwningNonNull<mozilla::dom::ImageBitmap>&
+  GetAsImageBitmap()
+  {
+    do { } while (0);
+    return mValue.mImageBitmap.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::ImageBitmap> const &
+  GetAsImageBitmap() const
+  {
+    do { } while (0);
+    return mValue.mImageBitmap.Value();
+  }
+
+  ArrayBufferView&
+  RawSetAsArrayBufferView();
+
+  ArrayBufferView&
+  SetAsArrayBufferView();
+
+  bool
+  TrySetToArrayBufferView(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsArrayBufferView() const
+  {
+    return mType == eArrayBufferView;
+  }
+
+  inline ArrayBufferView&
+  GetAsArrayBufferView()
+  {
+    do { } while (0);
+    return mValue.mArrayBufferView.Value();
+  }
+
+  inline ArrayBufferView const &
+  GetAsArrayBufferView() const
+  {
+    do { } while (0);
+    return mValue.mArrayBufferView.Value();
+  }
+
+  ArrayBuffer&
+  RawSetAsArrayBuffer();
+
+  ArrayBuffer&
+  SetAsArrayBuffer();
+
+  bool
+  TrySetToArrayBuffer(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsArrayBuffer() const
+  {
+    return mType == eArrayBuffer;
+  }
+
+  inline ArrayBuffer&
+  GetAsArrayBuffer()
+  {
+    do { } while (0);
+    return mValue.mArrayBuffer.Value();
+  }
+
+  inline ArrayBuffer const &
+  GetAsArrayBuffer() const
+  {
+    do { } while (0);
+    return mValue.mArrayBuffer.Value();
+  }
+
+  void
+  Uninit();
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceUnion(JSTracer* trc);
+
+private:
+  void
+  DestroyHTMLImageElement();
+
+  void
+  DestroyHTMLVideoElement();
+
+  void
+  DestroyHTMLCanvasElement();
+
+  void
+  DestroyBlob();
+
+  void
+  DestroyImageData();
+
+  void
+  DestroyCanvasRenderingContext2D();
+
+  void
+  DestroyImageBitmap();
+
+  void
+  DestroyArrayBufferView();
+
+  void
+  DestroyArrayBuffer();
+};
+
+
+namespace ImageBitmapBinding {
+
+  typedef mozilla::dom::ImageBitmap NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::ImageBitmap* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 1070 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 7 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 1
+# 8 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+namespace js {
+
+using JS::AutoIdVector;
+using JS::CallArgs;
+using JS::Handle;
+using JS::HandleId;
+using JS::HandleObject;
+using JS::HandleValue;
+using JS::IsAcceptableThis;
+using JS::MutableHandle;
+using JS::MutableHandleObject;
+using JS::MutableHandleValue;
+using JS::NativeImpl;
+using JS::ObjectOpResult;
+using JS::PrivateValue;
+using JS::PropertyDescriptor;
+using JS::Value;
+
+class RegExpShared;
+
+class Wrapper;
+# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+class BaseProxyHandler
+{
+# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+    const void* mFamily;
+# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+    bool mHasPrototype;
+
+
+
+
+
+
+
+    bool mHasSecurityPolicy;
+
+  public:
+    explicit constexpr BaseProxyHandler(const void* aFamily, bool aHasPrototype = false,
+                                            bool aHasSecurityPolicy = false)
+      : mFamily(aFamily),
+        mHasPrototype(aHasPrototype),
+        mHasSecurityPolicy(aHasSecurityPolicy)
+    { }
+
+    bool hasPrototype() const {
+        return mHasPrototype;
+    }
+
+    bool hasSecurityPolicy() const {
+        return mHasSecurityPolicy;
+    }
+
+    inline const void* family() const {
+        return mFamily;
+    }
+    static size_t offsetOfFamily() {
+        return __builtin_offsetof(BaseProxyHandler, mFamily);
+    }
+
+    virtual bool finalizeInBackground(const Value& priv) const {
+
+
+
+
+        return true;
+    }
+
+    virtual bool canNurseryAllocate() const {
+
+
+
+
+        return false;
+    }
+# 248 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+    typedef uint32_t Action;
+    enum {
+        NONE = 0x00,
+        GET = 0x01,
+        SET = 0x02,
+        CALL = 0x04,
+        ENUMERATE = 0x08,
+        GET_PROPERTY_DESCRIPTOR = 0x10
+    };
+
+    virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Action act, bool mayThrow,
+                       bool* bp) const;
+
+
+    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
+                                          MutableHandle<PropertyDescriptor> desc) const = 0;
+    virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
+                                Handle<PropertyDescriptor> desc,
+                                ObjectOpResult& result) const = 0;
+    virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
+                                 AutoIdVector& props) const = 0;
+    virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
+                         ObjectOpResult& result) const = 0;
+
+
+
+
+
+
+
+    virtual bool getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject protop) const;
+    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
+                              ObjectOpResult& result) const;
+
+
+    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
+                                        MutableHandleObject protop) const = 0;
+    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy, bool* succeeded) const;
+
+    virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
+                                   ObjectOpResult& result) const = 0;
+    virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const = 0;
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+    virtual bool has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
+    virtual bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
+                     HandleId id, MutableHandleValue vp) const;
+    virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
+                     HandleValue receiver, ObjectOpResult& result) const;
+# 316 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+    virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
+    virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
+
+
+    virtual bool enumerate(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const;
+    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
+                                       MutableHandle<PropertyDescriptor> desc) const;
+    virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
+    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
+                                              AutoIdVector& props) const;
+    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
+                            const CallArgs& args) const;
+    virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v, bool* bp) const;
+    virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy,
+                                 ESClass* cls) const;
+    virtual bool isArray(JSContext* cx, HandleObject proxy, JS::IsArrayAnswer* answer) const;
+    virtual const char* className(JSContext* cx, HandleObject proxy) const;
+    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy, unsigned indent) const;
+    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
+                                 MutableHandle<js::RegExpShared*> shared) const;
+    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const;
+    virtual void trace(JSTracer* trc, JSObject* proxy) const;
+    virtual void finalize(JSFreeOp* fop, JSObject* proxy) const;
+    virtual void objectMoved(JSObject* proxy, const JSObject* old) const;
+
+
+
+
+
+    virtual bool isCallable(JSObject* obj) const;
+    virtual bool isConstructor(JSObject* obj) const;
+
+
+
+    virtual bool watch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
+                       JS::HandleObject callable) const;
+    virtual bool unwatch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id) const;
+
+    virtual bool getElements(JSContext* cx, HandleObject proxy, uint32_t begin, uint32_t end,
+                             ElementAdder* adder) const;
+
+
+    virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const;
+    virtual bool isScripted() const { return false; }
+};
+
+extern const js::Class* const ProxyClassPtr;
+
+inline bool IsProxy(const JSObject* obj)
+{
+    return GetObjectClass(obj)->isProxy();
+}
+
+namespace detail {
+const uint32_t PROXY_EXTRA_SLOTS = 2;
+
+
+
+
+
+
+struct ProxyValueArray
+{
+    Value privateSlot;
+    Value extraSlots[PROXY_EXTRA_SLOTS];
+
+    ProxyValueArray()
+      : privateSlot(JS::UndefinedValue())
+    {
+        for (size_t i = 0; i < PROXY_EXTRA_SLOTS; i++)
+            extraSlots[i] = JS::UndefinedValue();
+    }
+
+    static size_t offsetOfPrivateSlot() {
+        return __builtin_offsetof(ProxyValueArray, privateSlot);
+    }
+};
+# 402 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+struct ProxyDataLayout
+{
+    ProxyValueArray* values;
+    const BaseProxyHandler* handler;
+};
+
+const uint32_t ProxyDataOffset = 2 * sizeof(void*);
+
+inline ProxyDataLayout*
+GetProxyDataLayout(JSObject* obj)
+{
+    do { } while (0);
+    return reinterpret_cast<ProxyDataLayout*>(reinterpret_cast<uint8_t*>(obj) + ProxyDataOffset);
+}
+
+inline const ProxyDataLayout*
+GetProxyDataLayout(const JSObject* obj)
+{
+    do { } while (0);
+    return reinterpret_cast<const ProxyDataLayout*>(reinterpret_cast<const uint8_t*>(obj) +
+                                                    ProxyDataOffset);
+}
+}
+
+inline const BaseProxyHandler*
+GetProxyHandler(const JSObject* obj)
+{
+    return detail::GetProxyDataLayout(obj)->handler;
+}
+
+inline const Value&
+GetProxyPrivate(const JSObject* obj)
+{
+    return detail::GetProxyDataLayout(obj)->values->privateSlot;
+}
+
+inline JSObject*
+GetProxyTargetObject(JSObject* obj)
+{
+    return GetProxyPrivate(obj).toObjectOrNull();
+}
+
+inline const Value&
+GetProxyExtra(const JSObject* obj, size_t n)
+{
+    do { } while (0);
+    return detail::GetProxyDataLayout(obj)->values->extraSlots[n];
+}
+
+inline void
+SetProxyHandler(JSObject* obj, const BaseProxyHandler* handler)
+{
+    detail::GetProxyDataLayout(obj)->handler = handler;
+}
+
+void
+SetValueInProxy(Value* slot, const Value& value);
+
+inline void
+SetProxyExtra(JSObject* obj, size_t n, const Value& extra)
+{
+    do { } while (0);
+    Value* vp = &detail::GetProxyDataLayout(obj)->values->extraSlots[n];
+
+
+    if (vp->isGCThing() || extra.isGCThing())
+        SetValueInProxy(vp, extra);
+    else
+        *vp = extra;
+}
+
+inline bool
+IsScriptedProxy(const JSObject* obj)
+{
+    return IsProxy(obj) && GetProxyHandler(obj)->isScripted();
+}
+
+inline const Value&
+GetReservedOrProxyPrivateSlot(const JSObject* obj, size_t slot)
+{
+    do { } while (0);
+    do { } while (0);
+    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
+}
+
+inline void
+SetReservedOrProxyPrivateSlot(JSObject* obj, size_t slot, const Value& value)
+{
+    do { } while (0);
+    do { } while (0);
+    shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
+    if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
+        SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
+    else
+        sobj->slotRef(slot) = value;
+}
+
+class ProxyOptions {
+  protected:
+
+    explicit ProxyOptions(bool singletonArg, bool lazyProtoArg = false)
+      : singleton_(singletonArg),
+        lazyProto_(lazyProtoArg),
+        clasp_(ProxyClassPtr)
+    {}
+
+  public:
+    ProxyOptions() : singleton_(false),
+                     lazyProto_(false),
+                     clasp_(ProxyClassPtr)
+    {}
+
+    bool singleton() const { return singleton_; }
+    ProxyOptions& setSingleton(bool flag) {
+        singleton_ = flag;
+        return *this;
+    }
+
+    bool lazyProto() const { return lazyProto_; }
+    ProxyOptions& setLazyProto(bool flag) {
+        lazyProto_ = flag;
+        return *this;
+    }
+
+    const Class* clasp() const {
+        return clasp_;
+    }
+    ProxyOptions& setClass(const Class* claspArg) {
+        clasp_ = claspArg;
+        return *this;
+    }
+
+  private:
+    bool singleton_;
+    bool lazyProto_;
+    const Class* clasp_;
+};
+
+JSObject*
+NewProxyObject(JSContext* cx, const BaseProxyHandler* handler, HandleValue priv,
+               JSObject* proto, const ProxyOptions& options = ProxyOptions());
+
+JSObject*
+RenewProxyObject(JSContext* cx, JSObject* obj, BaseProxyHandler* handler, const Value& priv);
+
+class AutoEnterPolicy
+{
+  public:
+    typedef BaseProxyHandler::Action Action;
+    AutoEnterPolicy(JSContext* cx, const BaseProxyHandler* handler,
+                    HandleObject wrapper, HandleId id, Action act, bool mayThrow)
+
+        : context(nullptr)
+
+    {
+        allow = handler->hasSecurityPolicy() ? handler->enter(cx, wrapper, id, act, mayThrow, &rv)
+                                             : true;
+        recordEnter(cx, wrapper, id, act);
+
+
+
+
+
+        if (!allow && !rv && mayThrow)
+            reportErrorIfExceptionIsNotPending(cx, id);
+    }
+
+    virtual ~AutoEnterPolicy() { recordLeave(); }
+    inline bool allowed() { return allow; }
+    inline bool returnValue() { do { } while (0); return rv; }
+
+  protected:
+
+    AutoEnterPolicy()
+
+        : context(nullptr)
+        , enteredAction(BaseProxyHandler::NONE)
+
+        {}
+    void reportErrorIfExceptionIsNotPending(JSContext* cx, jsid id);
+    bool allow;
+    bool rv;
+
+
+    JSContext* context;
+    mozilla::Maybe<HandleObject> enteredProxy;
+    mozilla::Maybe<HandleId> enteredId;
+    Action enteredAction;
+
+
+
+
+    AutoEnterPolicy* prev;
+    void recordEnter(JSContext* cx, HandleObject proxy, HandleId id, Action act);
+    void recordLeave();
+
+    friend void assertEnteredPolicy(JSContext* cx, JSObject* proxy, jsid id, Action act);
+
+
+
+
+
+  private:
+
+
+
+
+
+
+    AutoEnterPolicy(const AutoEnterPolicy&) = delete;
+    AutoEnterPolicy& operator=(const AutoEnterPolicy&) = delete;
+};
+
+
+class AutoWaivePolicy : public AutoEnterPolicy {
+public:
+    AutoWaivePolicy(JSContext* cx, HandleObject proxy, HandleId id,
+                    BaseProxyHandler::Action act)
+    {
+        allow = true;
+        recordEnter(cx, proxy, id, act);
+    }
+};
+# 635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
+extern void
+assertEnteredPolicy(JSContext* cx, JSObject* obj, jsid id,
+                    BaseProxyHandler::Action act);
+
+
+
+
+
+
+extern JSObject*
+InitProxyClass(JSContext* cx, JS::HandleObject obj);
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h" 2
+
+namespace js {
+
+
+
+
+
+
+
+class WrapperOptions : public ProxyOptions {
+  public:
+    WrapperOptions() : ProxyOptions(false),
+                       proto_()
+    {}
+
+    explicit WrapperOptions(JSContext* cx) : ProxyOptions(false),
+                                             proto_()
+    {
+        proto_.emplace(cx);
+    }
+
+    inline JSObject* proto() const;
+    WrapperOptions& setProto(JSObject* protoArg) {
+        do { } while (0);
+        *proto_ = protoArg;
+        return *this;
+    }
+
+  private:
+    mozilla::Maybe<JS::RootedObject> proto_;
+};
+# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
+class Wrapper : public BaseProxyHandler
+{
+    unsigned mFlags;
+
+  public:
+    explicit constexpr Wrapper(unsigned aFlags, bool aHasPrototype = false,
+                                   bool aHasSecurityPolicy = false)
+      : BaseProxyHandler(&family, aHasPrototype, aHasSecurityPolicy),
+        mFlags(aFlags)
+    { }
+
+    virtual bool finalizeInBackground(const Value& priv) const override;
+
+
+    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
+                                          MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
+                                Handle<PropertyDescriptor> desc,
+                                ObjectOpResult& result) const override;
+    virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
+                                 AutoIdVector& props) const override;
+    virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
+                         ObjectOpResult& result) const override;
+    virtual bool enumerate(JSContext* cx, HandleObject proxy,
+                           MutableHandleObject objp) const override;
+    virtual bool getPrototype(JSContext* cx, HandleObject proxy,
+                              MutableHandleObject protop) const override;
+    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
+                              ObjectOpResult& result) const override;
+    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
+                                        MutableHandleObject protop) const override;
+    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
+                                       bool* succeeded) const override;
+    virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
+                                   ObjectOpResult& result) const override;
+    virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const override;
+    virtual bool has(JSContext* cx, HandleObject proxy, HandleId id,
+                     bool* bp) const override;
+    virtual bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
+                     HandleId id, MutableHandleValue vp) const override;
+    virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
+                     HandleValue receiver, ObjectOpResult& result) const override;
+    virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
+    virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
+
+
+    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
+                                       MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id,
+                        bool* bp) const override;
+    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
+                                              AutoIdVector& props) const override;
+    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
+                            const CallArgs& args) const override;
+    virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v,
+                             bool* bp) const override;
+    virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy, ESClass* cls) const override;
+    virtual bool isArray(JSContext* cx, HandleObject proxy,
+                         JS::IsArrayAnswer* answer) const override;
+    virtual const char* className(JSContext* cx, HandleObject proxy) const override;
+    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy,
+                                   unsigned indent) const override;
+    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
+                                 MutableHandle<RegExpShared*> shared) const override;
+    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy,
+                                  MutableHandleValue vp) const override;
+    virtual bool isCallable(JSObject* obj) const override;
+    virtual bool isConstructor(JSObject* obj) const override;
+    virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const override;
+
+  public:
+    using BaseProxyHandler::Action;
+
+    enum Flags {
+        CROSS_COMPARTMENT = 1 << 0,
+        LAST_USED_FLAG = CROSS_COMPARTMENT
+    };
+
+    static JSObject* New(JSContext* cx, JSObject* obj, const Wrapper* handler,
+                         const WrapperOptions& options = WrapperOptions());
+
+    static JSObject* Renew(JSObject* existing, JSObject* obj, const Wrapper* handler);
+
+    static const Wrapper* wrapperHandler(JSObject* wrapper);
+
+    static JSObject* wrappedObject(JSObject* wrapper);
+
+    unsigned flags() const {
+        return mFlags;
+    }
+
+    static const char family;
+    static const Wrapper singleton;
+    static const Wrapper singletonWithPrototype;
+
+    static JSObject* defaultProto;
+};
+
+inline JSObject*
+WrapperOptions::proto() const
+{
+    return proto_ ? *proto_ : Wrapper::defaultProto;
+}
+
+
+class CrossCompartmentWrapper : public Wrapper
+{
+  public:
+    explicit constexpr CrossCompartmentWrapper(unsigned aFlags, bool aHasPrototype = false,
+                                                   bool aHasSecurityPolicy = false)
+      : Wrapper(CROSS_COMPARTMENT | aFlags, aHasPrototype, aHasSecurityPolicy)
+    { }
+
+
+    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
+                                          MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
+                                Handle<PropertyDescriptor> desc,
+                                ObjectOpResult& result) const override;
+    virtual bool ownPropertyKeys(JSContext* cx, HandleObject wrapper,
+                                 AutoIdVector& props) const override;
+    virtual bool delete_(JSContext* cx, HandleObject wrapper, HandleId id,
+                         ObjectOpResult& result) const override;
+    virtual bool enumerate(JSContext* cx, HandleObject wrapper, MutableHandleObject objp) const override;
+    virtual bool getPrototype(JSContext* cx, HandleObject proxy,
+                              MutableHandleObject protop) const override;
+    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
+                              ObjectOpResult& result) const override;
+
+    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
+                                        MutableHandleObject protop) const override;
+    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
+                                       bool* succeeded) const override;
+    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
+                                   ObjectOpResult& result) const override;
+    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
+    virtual bool has(JSContext* cx, HandleObject wrapper, HandleId id, bool* bp) const override;
+    virtual bool get(JSContext* cx, HandleObject wrapper, HandleValue receiver,
+                     HandleId id, MutableHandleValue vp) const override;
+    virtual bool set(JSContext* cx, HandleObject wrapper, HandleId id, HandleValue v,
+                     HandleValue receiver, ObjectOpResult& result) const override;
+    virtual bool call(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
+    virtual bool construct(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
+
+
+    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
+                                       MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id, bool* bp) const override;
+    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
+                                              AutoIdVector& props) const override;
+    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
+                            const CallArgs& args) const override;
+    virtual bool hasInstance(JSContext* cx, HandleObject wrapper, MutableHandleValue v,
+                             bool* bp) const override;
+    virtual const char* className(JSContext* cx, HandleObject proxy) const override;
+    virtual JSString* fun_toString(JSContext* cx, HandleObject wrapper,
+                                   unsigned indent) const override;
+    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
+                                 MutableHandle<RegExpShared*> shared) const override;
+    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const override;
+
+
+    virtual bool canNurseryAllocate() const override { return true; }
+
+    static const CrossCompartmentWrapper singleton;
+    static const CrossCompartmentWrapper singletonWithPrototype;
+};
+
+class OpaqueCrossCompartmentWrapper : public CrossCompartmentWrapper
+{
+  public:
+    explicit constexpr OpaqueCrossCompartmentWrapper() : CrossCompartmentWrapper(0)
+    { }
+
+
+    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
+                                          MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
+                                Handle<PropertyDescriptor> desc,
+                                ObjectOpResult& result) const override;
+    virtual bool ownPropertyKeys(JSContext* cx, HandleObject wrapper,
+                                 AutoIdVector& props) const override;
+    virtual bool delete_(JSContext* cx, HandleObject wrapper, HandleId id,
+                         ObjectOpResult& result) const override;
+    virtual bool enumerate(JSContext* cx, HandleObject wrapper,
+                           MutableHandleObject objp) const override;
+    virtual bool getPrototype(JSContext* cx, HandleObject wrapper,
+                              MutableHandleObject protop) const override;
+    virtual bool setPrototype(JSContext* cx, HandleObject wrapper, HandleObject proto,
+                              ObjectOpResult& result) const override;
+    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject wrapper, bool* isOrdinary,
+                                        MutableHandleObject protop) const override;
+    virtual bool setImmutablePrototype(JSContext* cx, HandleObject wrapper,
+                                       bool* succeeded) const override;
+    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
+                                   ObjectOpResult& result) const override;
+    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
+    virtual bool has(JSContext* cx, HandleObject wrapper, HandleId id,
+                     bool* bp) const override;
+    virtual bool get(JSContext* cx, HandleObject wrapper, HandleValue receiver,
+                     HandleId id, MutableHandleValue vp) const override;
+    virtual bool set(JSContext* cx, HandleObject wrapper, HandleId id, HandleValue v,
+                     HandleValue receiver, ObjectOpResult& result) const override;
+    virtual bool call(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
+    virtual bool construct(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
+
+
+    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
+                                       MutableHandle<PropertyDescriptor> desc) const override;
+    virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id,
+                        bool* bp) const override;
+    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
+                                              AutoIdVector& props) const override;
+    virtual bool getBuiltinClass(JSContext* cx, HandleObject wrapper, ESClass* cls) const override;
+    virtual bool isArray(JSContext* cx, HandleObject obj,
+                         JS::IsArrayAnswer* answer) const override;
+    virtual const char* className(JSContext* cx, HandleObject wrapper) const override;
+    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy, unsigned indent) const override;
+
+    static const OpaqueCrossCompartmentWrapper singleton;
+};
+# 289 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
+template <class Base>
+class SecurityWrapper : public Base
+{
+  public:
+    explicit constexpr SecurityWrapper(unsigned flags, bool hasPrototype = false)
+      : Base(flags, hasPrototype, true)
+    { }
+
+    virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Wrapper::Action act,
+                       bool mayThrow, bool* bp) const override;
+
+    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
+                                Handle<PropertyDescriptor> desc,
+                                ObjectOpResult& result) const override;
+    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
+    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
+                                   ObjectOpResult& result) const override;
+    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
+                              ObjectOpResult& result) const override;
+    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy, bool* succeeded) const override;
+
+    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
+                            const CallArgs& args) const override;
+    virtual bool getBuiltinClass(JSContext* cx, HandleObject wrapper, ESClass* cls) const override;
+    virtual bool isArray(JSContext* cx, HandleObject wrapper, JS::IsArrayAnswer* answer) const override;
+    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
+                                 MutableHandle<RegExpShared*> shared) const override;
+    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const override;
+
+
+
+
+    virtual bool watch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
+                       JS::HandleObject callable) const override;
+    virtual bool unwatch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id) const override;
+
+
+
+
+
+    typedef Base Permissive;
+    typedef SecurityWrapper<Base> Restrictive;
+};
+
+typedef SecurityWrapper<CrossCompartmentWrapper> CrossCompartmentSecurityWrapper;
+
+extern JSObject*
+TransparentObjectWrapper(JSContext* cx, HandleObject existing, HandleObject obj);
+
+inline bool
+IsWrapper(JSObject* obj)
+{
+    return IsProxy(obj) && GetProxyHandler(obj)->family() == &Wrapper::family;
+}
+
+
+
+
+
+JSObject*
+UncheckedUnwrap(JSObject* obj, bool stopAtWindowProxy = true, unsigned* flagsp = nullptr);
+
+
+
+
+
+JSObject*
+CheckedUnwrap(JSObject* obj, bool stopAtWindowProxy = true);
+
+
+
+JSObject*
+UnwrapOneChecked(JSObject* obj, bool stopAtWindowProxy = true);
+
+void
+ReportAccessDenied(JSContext* cx);
+
+bool
+IsCrossCompartmentWrapper(JSObject* obj);
+
+void
+NukeCrossCompartmentWrapper(JSContext* cx, JSObject* wrapper);
+
+void
+RemapWrapper(JSContext* cx, JSObject* wobj, JSObject* newTarget);
+
+bool
+RemapAllWrappersForObject(JSContext* cx, JSObject* oldTarget,
+                          JSObject* newTarget);
+
+
+
+bool
+RecomputeWrappers(JSContext* cx, const CompartmentFilter& sourceFilter,
+                  const CompartmentFilter& targetFilter);
+
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HoldDropJSObjects.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HoldDropJSObjects.h"
+class nsISupports;
+class nsScriptObjectTracer;
+
+
+
+namespace mozilla {
+namespace cyclecollector {
+
+void HoldJSObjectsImpl(void* aHolder, nsScriptObjectTracer* aTracer);
+void HoldJSObjectsImpl(nsISupports* aHolder);
+void DropJSObjectsImpl(void* aHolder);
+void DropJSObjectsImpl(nsISupports* aHolder);
+
+}
+
+
+template<class T, bool isISupports = IsBaseOf<nsISupports, T>::value>
+struct HoldDropJSObjectsHelper
+{
+  static void Hold(T* aHolder)
+  {
+    cyclecollector::HoldJSObjectsImpl(aHolder,
+                                      T::cycleCollection::GetParticipant());
+  }
+  static void Drop(T* aHolder)
+  {
+    cyclecollector::DropJSObjectsImpl(aHolder);
+  }
+};
+
+template<class T>
+struct HoldDropJSObjectsHelper<T, true>
+{
+  static void Hold(T* aHolder)
+  {
+    cyclecollector::HoldJSObjectsImpl(ToSupports(aHolder));
+  }
+  static void Drop(T* aHolder)
+  {
+    cyclecollector::DropJSObjectsImpl(ToSupports(aHolder));
+  }
+};
+
+
+template<class T>
+void
+HoldJSObjects(T* aHolder)
+{
+  HoldDropJSObjectsHelper<T>::Hold(aHolder);
+}
+
+template<class T>
+void
+DropJSObjects(T* aHolder)
+{
+  HoldDropJSObjectsHelper<T>::Drop(aHolder);
+}
+
+
+
+
+
+}
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TaskCategory.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TaskCategory.h"
+namespace mozilla {
+
+
+
+enum class TaskCategory {
+
+  UI,
+
+
+  Network,
+
+
+  Timer,
+
+
+  Worker,
+
+
+  IdleCallback,
+
+
+  RefreshDriver,
+
+
+  GarbageCollection,
+
+
+  Other,
+
+  Count
+};
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h" 2
+
+class nsIEventTarget;
+class nsIRunnable;
+
+namespace mozilla {
+class AbstractThread;
+namespace dom {
+class TabGroup;
+
+
+
+
+
+class DispatcherTrait {
+public:
+
+
+  virtual nsresult Dispatch(const char* aName,
+                            TaskCategory aCategory,
+                            already_AddRefed<nsIRunnable>&& aRunnable);
+
+
+
+
+  virtual nsIEventTarget* EventTargetFor(TaskCategory aCategory) const;
+
+
+
+  virtual AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
+};
+
+}
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h" 2
+
+
+
+
+
+
+
+
+class nsACString;
+class nsCString;
+class nsCycleCollectionTraversalCallback;
+class nsIPrincipal;
+
+class nsIGlobalObject : public nsISupports,
+                        public mozilla::dom::DispatcherTrait
+{
+  nsTArray<nsCString> mHostObjectURIs;
+  bool mIsDying;
+
+protected:
+  nsIGlobalObject()
+   : mIsDying(false)
+  {}
+
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h"
+  bool
+  IsDying() const
+  {
+    return mIsDying;
+  }
+
+
+
+
+
+
+
+  virtual JSObject* GetGlobalJSObject() = 0;
+
+
+  nsIPrincipal* PrincipalOrNull();
+
+  void RegisterHostObjectURI(const nsACString& aURI);
+
+  void UnregisterHostObjectURI(const nsACString& aURI);
+
+
+
+  void UnlinkHostObjectURIs();
+  void TraverseHostObjectURIs(nsCycleCollectionTraversalCallback &aCb);
+
+protected:
+  virtual ~nsIGlobalObject();
+
+  void
+  StartDying()
+  {
+    mIsDying = true;
+  }
+};
+
+template<typename T> struct nsIGlobalObject::COMTypeInfo<nsIGlobalObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIGlobalObject::COMTypeInfo<nsIGlobalObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x11afa8be, 0xd997, 0x4e07, { 0xa6, 0xa3, 0x6f, 0x87, 0x2e, 0xc3, 0xee, 0x7f } };
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+namespace js {
+class Debugger;
+}
+
+namespace JS {
+namespace dbg {
+# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+class BuilderOrigin;
+
+class Builder {
+
+
+    PersistentRootedObject debuggerObject;
+
+
+    js::Debugger* debugger;
+
+
+
+
+
+
+
+    void assertBuilt(JSObject* obj) { }
+
+
+  protected:
+
+
+    template<typename T>
+    class BuiltThing {
+        friend class BuilderOrigin;
+
+      protected:
+
+        Builder& owner;
+
+
+        PersistentRooted<T> value;
+
+        BuiltThing(JSContext* cx, Builder& owner_, T value_ = GCPolicy<T>::initial())
+          : owner(owner_), value(cx, value_)
+        {
+            owner.assertBuilt(value_);
+        }
+
+
+        js::Debugger* debugger() const { return owner.debugger; }
+        JSObject* debuggerObject() const { return owner.debuggerObject; }
+
+      public:
+        BuiltThing(const BuiltThing& rhs) : owner(rhs.owner), value(rhs.value) { }
+        BuiltThing& operator=(const BuiltThing& rhs) {
+            do { } while (0);
+            owner.assertBuilt(rhs.value);
+            value = rhs.value;
+            return *this;
+        }
+
+        explicit operator bool() const {
+
+            return value;
+        }
+
+      private:
+        BuiltThing() = delete;
+    };
+
+  public:
+
+
+
+    class Object: private BuiltThing<JSObject*> {
+        friend class Builder;
+        friend class BuilderOrigin;
+
+        typedef BuiltThing<JSObject*> Base;
+
+
+
+        Object(JSContext* cx, Builder& owner_, HandleObject obj) : Base(cx, owner_, obj.get()) { }
+
+        bool definePropertyToTrusted(JSContext* cx, const char* name,
+                                     JS::MutableHandleValue value);
+
+      public:
+        Object(JSContext* cx, Builder& owner_) : Base(cx, owner_, nullptr) { }
+        Object(const Object& rhs) : Base(rhs) { }
+# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+        bool defineProperty(JSContext* cx, const char* name, JS::HandleValue value);
+        bool defineProperty(JSContext* cx, const char* name, JS::HandleObject value);
+        bool defineProperty(JSContext* cx, const char* name, Object& value);
+
+        using Base::operator bool;
+    };
+
+
+
+    Object newObject(JSContext* cx);
+
+  protected:
+    Builder(JSContext* cx, js::Debugger* debugger);
+};
+
+
+
+class BuilderOrigin : public Builder {
+    template<typename T>
+    T unwrapAny(const BuiltThing<T>& thing) {
+        do { } while (0);
+        return thing.value.get();
+    }
+
+  public:
+    BuilderOrigin(JSContext* cx, js::Debugger* debugger_)
+      : Builder(cx, debugger_)
+    { }
+
+    JSObject* unwrap(Object& object) { return unwrapAny(object); }
+};
+# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+void
+SetDebuggerMallocSizeOf(JSContext* cx, mozilla::MallocSizeOf mallocSizeOf);
+
+
+
+mozilla::MallocSizeOf
+GetDebuggerMallocSizeOf(JSContext* cx);
+# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+bool
+FireOnGarbageCollectionHook(JSContext* cx, GarbageCollectionEvent::Ptr&& data);
+# 303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+void
+onNewPromise(JSContext* cx, HandleObject promise);
+# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+void
+onPromiseSettled(JSContext* cx, HandleObject promise);
+
+
+
+
+bool
+IsDebugger(JSObject& obj);
+
+
+
+bool
+GetDebuggeeGlobals(JSContext* cx, JSObject& dbgObj, AutoObjectVector& vector);
+# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+class AutoEntryMonitor {
+    JSContext* cx_;
+    AutoEntryMonitor* savedMonitor_;
+
+  public:
+    explicit AutoEntryMonitor(JSContext* cx);
+    ~AutoEntryMonitor();
+# 363 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
+    virtual void Entry(JSContext* cx, JSFunction* function,
+                       HandleValue asyncStack,
+                       const char* asyncCause) = 0;
+
+
+
+
+    virtual void Entry(JSContext* cx, JSScript* script,
+                       HandleValue asyncStack,
+                       const char* asyncCause) = 0;
+
+
+    virtual void Exit(JSContext* cx) { }
+};
+
+
+
+}
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 2
+
+class nsPIDOMWindowInner;
+class nsGlobalWindow;
+class nsIScriptContext;
+class nsIDocument;
+class nsIDocShell;
+
+namespace mozilla {
+namespace dom {
+
+
+
+
+
+void InitScriptSettings();
+void DestroyScriptSettings();
+bool ScriptSettingsInitialized();
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+void UseEntryScriptProfiling();
+void UnuseEntryScriptProfiling();
+# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+nsIGlobalObject* GetEntryGlobal();
+
+
+
+nsIDocument* GetEntryDocument();
+
+
+
+nsIGlobalObject* GetIncumbentGlobal();
+
+
+nsIGlobalObject* GetCurrentGlobal();
+# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+nsIPrincipal* GetWebIDLCallerPrincipal();
+
+
+
+
+inline JSObject& IncumbentJSGlobal()
+{
+  return *GetIncumbentGlobal()->GetGlobalJSObject();
+}
+
+
+
+
+bool IsJSAPIActive();
+
+namespace danger {
+
+
+
+
+JSContext* GetJSContext();
+
+}
+
+JS::RootingContext* RootingCx();
+
+class ScriptSettingsStack;
+class ScriptSettingsStackEntry {
+  friend class ScriptSettingsStack;
+
+public:
+  ~ScriptSettingsStackEntry();
+
+  bool NoJSAPI() const { return mType == eNoJSAPI; }
+  bool IsEntryCandidate() const {
+    return mType == eEntryScript || mType == eNoJSAPI;
+  }
+  bool IsIncumbentCandidate() { return mType != eJSAPI; }
+  bool IsIncumbentScript() { return mType == eIncumbentScript; }
+
+protected:
+  enum Type {
+    eEntryScript,
+    eIncumbentScript,
+    eJSAPI,
+    eNoJSAPI
+  };
+
+  ScriptSettingsStackEntry(nsIGlobalObject *aGlobal,
+                           Type aEntryType);
+
+  nsCOMPtr<nsIGlobalObject> mGlobalObject;
+  Type mType;
+
+private:
+  ScriptSettingsStackEntry *mOlder;
+};
+# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+class AutoJSAPI : protected ScriptSettingsStackEntry {
+public:
+
+
+  AutoJSAPI();
+
+  ~AutoJSAPI();
+# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+  void Init();
+# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+  __attribute__ ((warn_unused_result)) bool Init(nsIGlobalObject* aGlobalObject);
+
+
+
+  __attribute__ ((warn_unused_result)) bool Init(JSObject* aObject);
+# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+  __attribute__ ((warn_unused_result)) bool Init(nsIGlobalObject* aGlobalObject, JSContext* aCx);
+
+
+
+  __attribute__ ((warn_unused_result)) bool Init(nsPIDOMWindowInner* aWindow);
+  __attribute__ ((warn_unused_result)) bool Init(nsPIDOMWindowInner* aWindow, JSContext* aCx);
+
+  __attribute__ ((warn_unused_result)) bool Init(nsGlobalWindow* aWindow);
+  __attribute__ ((warn_unused_result)) bool Init(nsGlobalWindow* aWindow, JSContext* aCx);
+
+  JSContext* cx() const {
+    do { } while (0);
+    do { } while (0);
+    return mCx;
+  }
+
+
+
+
+
+
+  void ReportException();
+
+  bool HasException() const {
+    do { } while (0);
+    return JS_IsExceptionPending(cx());
+  };
+
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool StealException(JS::MutableHandle<JS::Value> aVal);
+
+
+
+
+
+
+
+  __attribute__ ((warn_unused_result)) bool PeekException(JS::MutableHandle<JS::Value> aVal);
+
+  void ClearException() {
+    do { } while (0);
+    JS_ClearPendingException(cx());
+  }
+
+protected:
+
+
+  AutoJSAPI(nsIGlobalObject* aGlobalObject, bool aIsMainThread, Type aType);
+
+private:
+  mozilla::Maybe<JSAutoRequest> mAutoRequest;
+  mozilla::Maybe<JSAutoNullableCompartment> mAutoNullableCompartment;
+  JSContext *mCx;
+
+
+  bool mIsMainThread;
+  Maybe<JS::WarningReporter> mOldWarningReporter;
+
+  void InitInternal(nsIGlobalObject* aGlobalObject, JSObject* aGlobal,
+                    JSContext* aCx, bool aIsMainThread);
+
+  AutoJSAPI(const AutoJSAPI&) = delete;
+  AutoJSAPI& operator= (const AutoJSAPI&) = delete;
+};
+# 319 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+class AutoEntryScript : public AutoJSAPI {
+public:
+  AutoEntryScript(nsIGlobalObject* aGlobalObject,
+                  const char *aReason,
+                  bool aIsMainThread = NS_IsMainThread());
+
+  AutoEntryScript(JSObject* aObject,
+                  const char *aReason,
+                  bool aIsMainThread = NS_IsMainThread());
+
+  ~AutoEntryScript();
+
+  void SetWebIDLCallerPrincipal(nsIPrincipal *aPrincipal) {
+    mWebIDLCallerPrincipal = aPrincipal;
+  }
+
+private:
+
+  class DocshellEntryMonitor final : public JS::dbg::AutoEntryMonitor
+  {
+  public:
+    DocshellEntryMonitor(JSContext* aCx, const char* aReason);
+
+
+
+
+
+
+    void Entry(JSContext* aCx, JSFunction* aFunction,
+               JS::Handle<JS::Value> aAsyncStack,
+               const char* aAsyncCause) override
+    {
+      Entry(aCx, aFunction, nullptr, aAsyncStack, aAsyncCause);
+    }
+
+    void Entry(JSContext* aCx, JSScript* aScript,
+               JS::Handle<JS::Value> aAsyncStack,
+               const char* aAsyncCause) override
+    {
+      Entry(aCx, nullptr, aScript, aAsyncStack, aAsyncCause);
+    }
+
+    void Exit(JSContext* aCx) override;
+
+  private:
+    void Entry(JSContext* aCx, JSFunction* aFunction, JSScript* aScript,
+               JS::Handle<JS::Value> aAsyncStack,
+               const char* aAsyncCause);
+
+    const char* mReason;
+  };
+# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+  nsIPrincipal* mWebIDLCallerPrincipal;
+  friend nsIPrincipal* GetWebIDLCallerPrincipal();
+
+  Maybe<DocshellEntryMonitor> mDocShellEntryMonitor;
+  JS::AutoHideScriptedCaller mCallerOverride;
+};
+
+
+
+
+class AutoIncumbentScript : protected ScriptSettingsStackEntry {
+public:
+  explicit AutoIncumbentScript(nsIGlobalObject* aGlobalObject);
+  ~AutoIncumbentScript();
+
+private:
+  JS::AutoHideScriptedCaller mCallerOverride;
+};
+# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+class AutoNoJSAPI : protected ScriptSettingsStackEntry {
+public:
+  explicit AutoNoJSAPI();
+  ~AutoNoJSAPI();
+};
+
+}
+
+
+
+
+
+
+class AutoJSContext {
+public:
+  explicit AutoJSContext();
+  operator JSContext*() const;
+
+protected:
+  JSContext* mCx;
+  dom::AutoJSAPI mJSAPI;
+
+};
+
+
+
+
+
+
+
+class AutoSafeJSContext : public dom::AutoJSAPI {
+public:
+  explicit AutoSafeJSContext();
+  operator JSContext*() const
+  {
+    return cx();
+  }
+
+private:
+
+};
+# 455 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
+class AutoSlowOperation : public dom::AutoJSAPI
+{
+public:
+  explicit AutoSlowOperation();
+  void CheckForInterrupt();
+private:
+
+};
+
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 1
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h"
+class nsIScriptGlobalObject;
+
+
+
+
+
+class nsIOffThreadScriptReceiver;
+
+
+
+
+
+class nsIScriptContext : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+  virtual nsIScriptGlobalObject *GetGlobalObject() = 0;
+
+
+
+
+  virtual nsresult InitContext() = 0;
+# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h"
+  virtual bool IsContextInitialized() = 0;
+
+
+
+  virtual nsresult SetProperty(JS::Handle<JSObject*> aTarget,
+                               const char* aPropName, nsISupports* aVal) = 0;
+
+
+
+
+  virtual bool GetProcessingScriptTag() = 0;
+  virtual void SetProcessingScriptTag(bool aResult) = 0;
+
+
+
+
+
+
+
+  virtual nsresult InitClasses(JS::Handle<JSObject*> aGlobalObj) = 0;
+
+
+
+
+  virtual void WillInitializeContext() = 0;
+
+
+
+
+  virtual void DidInitializeContext() = 0;
+
+
+
+
+  virtual void SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) = 0;
+  virtual JSObject* GetWindowProxy() = 0;
+};
+
+template<typename T> struct nsIScriptContext::COMTypeInfo<nsIScriptContext, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptContext::COMTypeInfo<nsIScriptContext, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x54cbe9cf, 0x7282, 0x421a, { 0x91, 0x6f, 0xd0, 0x70, 0x73, 0xde, 0xb8, 0xc0 } };
+
+
+
+
+
+class nsIOffThreadScriptReceiver : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+
+  virtual nsresult OnScriptCompileComplete(JSScript* aScript, nsresult aStatus) = 0;
+};
+
+template<typename T> struct nsIOffThreadScriptReceiver::COMTypeInfo<nsIOffThreadScriptReceiver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIOffThreadScriptReceiver::COMTypeInfo<nsIOffThreadScriptReceiver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3a980010, 0x878d, 0x46a9, {0x93, 0xad, 0xbc, 0xfd, 0xd3, 0x8e, 0xa0, 0xc2}};
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
+class nsIScriptContext;
+class nsIScriptGlobalObject;
+
+namespace mozilla {
+namespace dom {
+struct ErrorEventInit;
+}
+}
+
+
+
+
+
+
+bool
+NS_HandleScriptError(nsIScriptGlobalObject *aScriptGlobal,
+                     const mozilla::dom::ErrorEventInit &aErrorEvent,
+                     nsEventStatus *aStatus);
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
+class nsIScriptGlobalObject : public nsIGlobalObject
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
+  virtual nsresult EnsureScriptEnvironment() = 0;
+
+
+
+  virtual nsIScriptContext *GetScriptContext() = 0;
+
+  nsIScriptContext* GetContext() {
+    return GetScriptContext();
+  }
+
+
+
+
+  virtual nsresult HandleScriptError(
+                     const mozilla::dom::ErrorEventInit &aErrorEventInit,
+                     nsEventStatus *aEventStatus) {
+    do { if ((__builtin_expect(!!(!(NS_HandleScriptError(this, aErrorEventInit, aEventStatus))), 0))) { do { } while(0); return NS_ERROR_UNEXPECTED; } } while(0);
+    return NS_OK;
+  }
+
+  virtual bool IsBlackForCC(bool aTracingNeeded = true) { return false; }
+
+protected:
+  virtual ~nsIScriptGlobalObject() {}
+};
+
+template<typename T> struct nsIScriptGlobalObject::COMTypeInfo<nsIScriptGlobalObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptGlobalObject::COMTypeInfo<nsIScriptGlobalObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x876f83bd, 0x6314, 0x460a, { 0xa0, 0x45, 0x1c, 0x8f, 0x46, 0x2f, 0xb8, 0xe1 } };
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
+extern "C" {
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
+extern __attribute__((visibility("default"))) PRInt64 LL_MaxInt(void);
+extern __attribute__((visibility("default"))) PRInt64 LL_MinInt(void);
+extern __attribute__((visibility("default"))) PRInt64 LL_Zero(void);
+extern __attribute__((visibility("default"))) PRUint64 LL_MaxUint(void);
+# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h" 2
+
+extern "C" {
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+typedef PRInt64 PRTime;
+
+
+
+
+
+
+typedef struct PRTimeParameters {
+    PRInt32 tp_gmt_offset;
+    PRInt32 tp_dst_offset;
+} PRTimeParameters;
+# 83 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+typedef struct PRExplodedTime {
+    PRInt32 tm_usec;
+    PRInt32 tm_sec;
+
+    PRInt32 tm_min;
+    PRInt32 tm_hour;
+    PRInt32 tm_mday;
+
+    PRInt32 tm_month;
+    PRInt16 tm_year;
+
+
+    PRInt8 tm_wday;
+
+    PRInt16 tm_yday;
+
+
+    PRTimeParameters tm_params;
+} PRExplodedTime;
+# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+typedef PRTimeParameters ( *PRTimeParamFn)(const PRExplodedTime *gmt);
+# 145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+extern __attribute__((visibility("default"))) PRTime
+PR_Now(void);
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+extern __attribute__((visibility("default"))) void PR_ExplodeTime(
+    PRTime usecs, PRTimeParamFn params, PRExplodedTime *exploded);
+
+
+extern __attribute__((visibility("default"))) PRTime
+PR_ImplodeTime(const PRExplodedTime *exploded);
+# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+extern __attribute__((visibility("default"))) void PR_NormalizeTime(
+    PRExplodedTime *exploded, PRTimeParamFn params);
+
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRTimeParameters PR_LocalTimeParameters(const PRExplodedTime *gmt);
+
+
+extern __attribute__((visibility("default"))) PRTimeParameters PR_GMTParameters(const PRExplodedTime *gmt);
+
+
+
+
+
+extern __attribute__((visibility("default"))) PRTimeParameters PR_USPacificTimeParameters(const PRExplodedTime *gmt);
+# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeStringToExplodedTime (
+        const char *string,
+        PRBool default_to_gmt,
+        PRExplodedTime *result);
+# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
+extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeString (
+ const char *string,
+ PRBool default_to_gmt,
+ PRTime *result);
+
+
+extern __attribute__((visibility("default"))) PRUint32 PR_FormatTime(char *buf, int buflen, const char *fmt,
+                                 const PRExplodedTime *time);
+
+
+
+
+extern __attribute__((visibility("default"))) PRUint32
+PR_FormatTimeUSEnglish(char *buf, PRUint32 bufSize,
+                       const char *format, const PRExplodedTime *time);
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+struct JSFreeOp;
+class nsWrapperCache;
+class nsAXPCNativeCallContext;
+class nsIXPCScriptable;
+
+class nsIXPConnect;
+
+class nsIXPConnectWrappedNative;
+
+class nsIInterfaceInfo;
+
+class nsIXPCSecurityManager;
+
+class nsIPrincipal;
+
+class nsIClassInfo;
+
+class nsIVariant;
+
+class nsIStackFrame;
+
+class nsIObjectInputStream;
+
+class nsIObjectOutputStream;
+# 56 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPConnectJSObjectHolder : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual JSObject * GetJSObject(void) = 0;
+
+};
+
+  template<typename T> struct nsIXPConnectJSObjectHolder::COMTypeInfo<nsIXPConnectJSObjectHolder, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectJSObjectHolder::COMTypeInfo<nsIXPConnectJSObjectHolder, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x73e6ff4a, 0xab99, 0x4d99, { 0xac, 0x00, 0xba, 0x39, 0xcc, 0xb8, 0xe4, 0xd7 }};
+# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPConnectWrappedNative : public nsIXPConnectJSObjectHolder {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetNative(nsISupports * *aNative) = 0;
+
+
+  virtual nsresult GetJSObjectPrototype(JSObject **aJSObjectPrototype) = 0;
+
+
+  virtual nsresult FindInterfaceWithMember(JS::Handle<jsid> nameID, nsIInterfaceInfo * *_retval) = 0;
+
+
+  virtual nsresult FindInterfaceWithName(JS::Handle<jsid> nameID, nsIInterfaceInfo * *_retval) = 0;
+
+
+  virtual bool HasNativeMember(JS::Handle<jsid> name) = 0;
+
+
+  virtual nsresult DebugDump(int16_t depth) = 0;
+
+
+
+
+    nsISupports* Native() const { return mIdentity; }
+protected:
+    nsCOMPtr<nsISupports> mIdentity;
+public:
+};
+
+  template<typename T> struct nsIXPConnectWrappedNative::COMTypeInfo<nsIXPConnectWrappedNative, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedNative::COMTypeInfo<nsIXPConnectWrappedNative, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xe787be29, 0xdb5d, 0x4a45, { 0xa3, 0xd6, 0x1d, 0xe1, 0xd6, 0xb8, 0x5c, 0x30 }};
+# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+inline
+const nsQueryInterface
+do_QueryWrappedNative(nsIXPConnectWrappedNative *aWrappedNative)
+{
+    return nsQueryInterface(aWrappedNative->Native());
+}
+inline
+const nsQueryInterfaceWithError
+do_QueryWrappedNative(nsIXPConnectWrappedNative *aWrappedNative,
+                      nsresult *aError)
+{
+    return nsQueryInterfaceWithError(aWrappedNative->Native(), aError);
+}
+# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPConnectWrappedJS : public nsIXPConnectJSObjectHolder {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetInterfaceInfo(nsIInterfaceInfo * *aInterfaceInfo) = 0;
+
+
+  virtual nsresult GetInterfaceIID(nsIID **aInterfaceIID) = 0;
+
+
+  virtual nsresult DebugDump(int16_t depth) = 0;
+
+
+  virtual nsresult AggregatedQueryInterface(const nsIID & uuid, void **result) = 0;
+
+};
+
+  template<typename T> struct nsIXPConnectWrappedJS::COMTypeInfo<nsIXPConnectWrappedJS, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedJS::COMTypeInfo<nsIXPConnectWrappedJS, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3a01b0d6, 0x074b, 0x49ed, { 0xba, 0xc3, 0x08, 0xc7, 0x63, 0x66, 0xca, 0xe4 }};
+# 415 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPConnectWrappedJSUnmarkGray : public nsIXPConnectWrappedJS {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct nsIXPConnectWrappedJSUnmarkGray::COMTypeInfo<nsIXPConnectWrappedJSUnmarkGray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedJSUnmarkGray::COMTypeInfo<nsIXPConnectWrappedJSUnmarkGray, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xc02a0ce6, 0x275f, 0x4ea1, { 0x9c, 0x23, 0x08, 0x49, 0x48, 0x98, 0xb0, 0x70 }};
+# 484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPCWrappedJSObjectGetter : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetNeverCalled(nsISupports * *aNeverCalled) = 0;
+
+};
+
+  template<typename T> struct nsIXPCWrappedJSObjectGetter::COMTypeInfo<nsIXPCWrappedJSObjectGetter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCWrappedJSObjectGetter::COMTypeInfo<nsIXPCWrappedJSObjectGetter, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x254bb2e0, 0x6439, 0x11d4, { 0x8f, 0xe0, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
+# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPCFunctionThisTranslator : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult TranslateThis(nsISupports *aInitialThis, nsISupports * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIXPCFunctionThisTranslator::COMTypeInfo<nsIXPCFunctionThisTranslator, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCFunctionThisTranslator::COMTypeInfo<nsIXPCFunctionThisTranslator, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf5f84b70, 0x92eb, 0x41f1, { 0xa1, 0xdd, 0x2e, 0xaa, 0xc0, 0xed, 0x56, 0x4c }};
+# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
+class nsIXPConnect : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+   static const nsID& GetCID() {static const nsID cid = { 0xcb6593e0, 0xf9b2, 0x11d2, { 0xbd, 0xd6, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }; return cid;}
+
+  virtual nsresult InitClassesWithNewWrappedGlobal(JSContext *aJSContext, nsISupports *aCOMObj, nsIPrincipal *aPrincipal, uint32_t aFlags, JS::CompartmentOptions & aOptions, nsIXPConnectJSObjectHolder * *_retval) = 0;
+
+  enum {
+    INIT_JS_STANDARD_CLASSES = 1U,
+    DONT_FIRE_ONNEWGLOBALHOOK = 2U,
+    OMIT_COMPONENTS_OBJECT = 4U
+  };
+
+
+  virtual nsresult WrapNative(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, JSObject **_retval) = 0;
+
+
+  virtual nsresult WrapNativeHolder(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectJSObjectHolder * *_retval) = 0;
+
+
+  virtual nsresult WrapNativeToJSVal(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, nsWrapperCache *aCache, const nsIID *aIID, bool aAllowWrapper, JS::MutableHandleValue aVal) = 0;
+
+
+  virtual nsresult WrapJS(JSContext *aJSContext, JSObject *aJSObj, const nsIID & aIID, void **result) = 0;
+
+
+  virtual nsresult JSValToVariant(JSContext *cx, JS::HandleValue aJSVal, nsIVariant * *_retval) = 0;
+
+
+  virtual nsresult GetWrappedNativeOfJSObject(JSContext *aJSContext, JSObject *aJSObj, nsIXPConnectWrappedNative * *_retval) = 0;
+
+
+  virtual nsISupports * GetNativeOfWrapper(JSContext *aJSContext, JSObject *aJSObj) = 0;
+
+
+  virtual nsresult GetCurrentJSStack(nsIStackFrame * *aCurrentJSStack) = 0;
+
+
+  virtual nsresult GetCurrentNativeCallContext(nsAXPCNativeCallContext **aCurrentNativeCallContext) = 0;
+
+
+  virtual nsresult DebugDump(int16_t depth) = 0;
+
+
+  virtual nsresult DebugDumpObject(nsISupports *aCOMObj, int16_t depth) = 0;
+
+
+  virtual nsresult DebugDumpJSStack(bool showArgs, bool showLocals, bool showThisProps) = 0;
+
+
+  virtual nsresult WrapJSAggregatedToNative(nsISupports *aOuter, JSContext *aJSContext, JSObject *aJSObj, const nsIID & aIID, void **result) = 0;
+
+
+  virtual nsresult GetWrappedNativeOfNativeObject(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectWrappedNative * *_retval) = 0;
+
+
+  virtual nsresult SetFunctionThisTranslator(const nsIID & aIID, nsIXPCFunctionThisTranslator *aTranslator) = 0;
+
+
+  virtual nsresult GetWrappedNativePrototype(JSContext *aJSContext, JSObject *aScope, nsIClassInfo *aClassInfo, JSObject **_retval) = 0;
+
+
+  virtual nsresult VariantToJS(JSContext *ctx, JSObject *scope, nsIVariant *value, JS::MutableHandleValue _retval) = 0;
+
+
+  virtual nsresult JSToVariant(JSContext *ctx, JS::HandleValue value, nsIVariant * *_retval) = 0;
+
+
+  virtual nsresult CreateSandbox(JSContext *cx, nsIPrincipal *principal, JSObject **_retval) = 0;
+
+
+  virtual nsresult EvalInSandboxObject(const nsAString & source, const char * filename, JSContext *cx, JSObject *sandbox, JS::MutableHandleValue _retval) = 0;
+
+
+  virtual nsresult GarbageCollect(uint32_t reason) = 0;
+
+
+  virtual nsresult NotifyDidPaint(void) = 0;
+
+
+
+
+
+
+
+    virtual nsIPrincipal* GetPrincipal(JSObject* obj,
+                                       bool allowShortCircuit) const = 0;
+    virtual char* DebugPrintJSStack(bool showArgs,
+                                    bool showLocals,
+                                    bool showThisProps) = 0;
+
+  virtual nsresult WriteScript(nsIObjectOutputStream *aStream, JSContext *aJSContext, JSScript *aJSScript) = 0;
+
+
+  virtual nsresult ReadScript(nsIObjectInputStream *aStream, JSContext *aJSContext, JSScript **_retval) = 0;
+
+
+  virtual nsresult WriteFunction(nsIObjectOutputStream *aStream, JSContext *aJSContext, JSObject *aJSObject) = 0;
+
+
+  virtual nsresult ReadFunction(nsIObjectInputStream *aStream, JSContext *aJSContext, JSObject **_retval) = 0;
+
+};
+
+  template<typename T> struct nsIXPConnect::COMTypeInfo<nsIXPConnect, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnect::COMTypeInfo<nsIXPConnect, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x768507b5, 0xb981, 0x40c7, { 0x82, 0x76, 0xf6, 0xa1, 0xda, 0x50, 0x2a, 0x24 }};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h"
+class nsISimpleEnumerator;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h"
+class nsIArray : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+
+  virtual nsresult QueryElementAt(uint32_t index, const nsIID & uuid, void **result) = 0;
+
+
+  virtual nsresult IndexOf(uint32_t startIndex, nsISupports *element, uint32_t *_retval) = 0;
+
+
+  virtual nsresult Enumerate(nsISimpleEnumerator * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIArray::COMTypeInfo<nsIArray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIArray::COMTypeInfo<nsIArray, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x114744d9, 0xc369, 0x456e, { 0xb5, 0x5a, 0x52, 0xfe, 0x52, 0x88, 0x0d, 0x2d }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIURI.h" 1
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIURI.h"
+class nsIURI : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetSpec(nsACString & aSpec) = 0;
+  virtual nsresult SetSpec(const nsACString & aSpec) = 0;
+
+
+
+
+
+    nsCString GetSpecOrDefault()
+    {
+        nsCString spec;
+        nsresult rv = GetSpec(spec);
+        if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
+            spec.Assign("[nsIURI::GetSpec failed]");
+        }
+        return spec;
+    }
+
+  virtual nsresult GetPrePath(nsACString & aPrePath) = 0;
+
+
+  virtual nsresult GetScheme(nsACString & aScheme) = 0;
+  virtual nsresult SetScheme(const nsACString & aScheme) = 0;
+
+
+  virtual nsresult GetUserPass(nsACString & aUserPass) = 0;
+  virtual nsresult SetUserPass(const nsACString & aUserPass) = 0;
+
+
+  virtual nsresult GetUsername(nsACString & aUsername) = 0;
+  virtual nsresult SetUsername(const nsACString & aUsername) = 0;
+
+
+  virtual nsresult GetPassword(nsACString & aPassword) = 0;
+  virtual nsresult SetPassword(const nsACString & aPassword) = 0;
+
+
+  virtual nsresult GetHostPort(nsACString & aHostPort) = 0;
+  virtual nsresult SetHostPort(const nsACString & aHostPort) = 0;
+
+
+  virtual nsresult SetHostAndPort(const nsACString & hostport) = 0;
+
+
+  virtual nsresult GetHost(nsACString & aHost) = 0;
+  virtual nsresult SetHost(const nsACString & aHost) = 0;
+
+
+  virtual nsresult GetPort(int32_t *aPort) = 0;
+  virtual nsresult SetPort(int32_t aPort) = 0;
+
+
+  virtual nsresult GetPath(nsACString & aPath) = 0;
+  virtual nsresult SetPath(const nsACString & aPath) = 0;
+
+
+  virtual nsresult Equals(nsIURI *other, bool *_retval) = 0;
+
+
+  virtual nsresult SchemeIs(const char * scheme, bool *_retval) = 0;
+
+
+  virtual nsresult Clone(nsIURI * *_retval) = 0;
+
+
+  virtual nsresult Resolve(const nsACString & relativePath, nsACString & _retval) = 0;
+
+
+  virtual nsresult GetAsciiSpec(nsACString & aAsciiSpec) = 0;
+
+
+  virtual nsresult GetAsciiHostPort(nsACString & aAsciiHostPort) = 0;
+
+
+  virtual nsresult GetAsciiHost(nsACString & aAsciiHost) = 0;
+
+
+  virtual nsresult GetOriginCharset(nsACString & aOriginCharset) = 0;
+
+
+  virtual nsresult GetRef(nsACString & aRef) = 0;
+  virtual nsresult SetRef(const nsACString & aRef) = 0;
+
+
+  virtual nsresult EqualsExceptRef(nsIURI *other, bool *_retval) = 0;
+
+
+  virtual nsresult CloneIgnoringRef(nsIURI * *_retval) = 0;
+
+
+  virtual nsresult CloneWithNewRef(const nsACString & newRef, nsIURI * *_retval) = 0;
+
+
+  virtual nsresult GetSpecIgnoringRef(nsACString & aSpecIgnoringRef) = 0;
+
+
+  virtual nsresult GetHasRef(bool *aHasRef) = 0;
+
+
+  virtual nsresult GetFilePath(nsACString & aFilePath) = 0;
+  virtual nsresult SetFilePath(const nsACString & aFilePath) = 0;
+
+
+  virtual nsresult GetQuery(nsACString & aQuery) = 0;
+  virtual nsresult SetQuery(const nsACString & aQuery) = 0;
+
+};
+
+  template<typename T> struct nsIURI::COMTypeInfo<nsIURI, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIURI::COMTypeInfo<nsIURI, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x92073a54, 0x6d78, 0x4f30, { 0x91, 0x3a, 0xb8, 0x71, 0x81, 0x32, 0x08, 0xc6 }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
+class nsIControllers;
+
+class nsIDOMBlob;
+
+class nsIDOMLocation;
+
+class nsIDOMOfflineResourceList;
+
+class nsIPrompt;
+
+class nsISelection;
+
+class nsIVariant;
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
+class nsIDOMWindow : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct nsIDOMWindow::COMTypeInfo<nsIDOMWindow, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMWindow::COMTypeInfo<nsIDOMWindow, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb8343993, 0x0383, 0x4add, { 0x99, 0x30, 0xad, 0x17, 0x6b, 0x18, 0x92, 0x40 }};
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
+class nsIDOMWindowInternal : public nsIDOMWindow {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct nsIDOMWindowInternal::COMTypeInfo<nsIDOMWindowInternal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMWindowInternal::COMTypeInfo<nsIDOMWindowInternal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8c589e65, 0x3237, 0x4cd1, { 0x8b, 0xad, 0xc5, 0xc4, 0x71, 0x35, 0xe7, 0x9b }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h"
+class mozIDOMWindow : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct mozIDOMWindow::COMTypeInfo<mozIDOMWindow, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID mozIDOMWindow::COMTypeInfo<mozIDOMWindow, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x75fbabd6, 0x7a2e, 0x4787, { 0xaa, 0x33, 0x44, 0x9a, 0x33, 0x51, 0x21, 0x35 }};
+# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h"
+class mozIDOMWindowProxy : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct mozIDOMWindowProxy::COMTypeInfo<mozIDOMWindowProxy, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID mozIDOMWindowProxy::COMTypeInfo<mozIDOMWindowProxy, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x53ca090c, 0xe739, 0x48b9, { 0x89, 0x11, 0x20, 0x8c, 0x72, 0xf9, 0x19, 0x1e }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+class nsGlobalWindow;
+class nsIArray;
+class nsIContent;
+class nsICSSDeclaration;
+class nsIDocShell;
+class nsIDocShellLoadInfo;
+class nsIDocument;
+class nsIEventTarget;
+class nsIIdleObserver;
+class nsIPrincipal;
+class nsIScriptTimeoutHandler;
+class nsIURI;
+class nsPIDOMWindowInner;
+class nsPIDOMWindowOuter;
+class nsPIWindowRoot;
+class nsXBLPrototypeHandler;
+
+typedef uint32_t SuspendTypes;
+
+namespace mozilla {
+class ThrottledEventQueue;
+namespace dom {
+class AudioContext;
+class DocGroup;
+class TabGroup;
+class Element;
+class Performance;
+class ServiceWorkerRegistration;
+class Timeout;
+class TimeoutManager;
+class CustomElementRegistry;
+enum class CallerType : uint32_t;
+}
+}
+
+
+
+
+
+
+enum PopupControlState {
+  openAllowed = 0,
+  openControlled,
+  openAbused,
+  openOverridden
+};
+
+enum UIStateChangeType
+{
+  UIStateChangeType_NoChange,
+  UIStateChangeType_Set,
+  UIStateChangeType_Clear,
+  UIStateChangeType_Invalid
+};
+
+enum class FullscreenReason
+{
+
+  ForFullscreenMode,
+
+  ForFullscreenAPI,
+
+
+
+  ForForceExitFullscreen
+};
+
+namespace mozilla {
+namespace dom {
+
+
+
+
+enum class LargeAllocStatus : uint8_t
+{
+
+
+
+  NONE,
+  SUCCESS,
+
+
+
+
+  NON_GET,
+  NON_E10S,
+  NOT_ONLY_TOPLEVEL_IN_TABGROUP,
+  NON_WIN32
+};
+}
+}
+
+
+
+
+template<class T>
+class nsPIDOMWindow : public T
+{
+public:
+  nsPIDOMWindowInner* AsInner();
+  const nsPIDOMWindowInner* AsInner() const;
+  nsPIDOMWindowOuter* AsOuter();
+  const nsPIDOMWindowOuter* AsOuter() const;
+
+  virtual nsPIDOMWindowOuter* GetPrivateRoot() = 0;
+  virtual mozilla::dom::CustomElementRegistry* CustomElements() = 0;
+
+  virtual void ActivateOrDeactivate(bool aActivate) = 0;
+# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual already_AddRefed<nsPIDOMWindowOuter> GetTop() = 0;
+  virtual already_AddRefed<nsPIDOMWindowOuter> GetParent() = 0;
+  virtual nsPIDOMWindowOuter* GetScriptableTop() = 0;
+  virtual nsPIDOMWindowOuter* GetScriptableParent() = 0;
+  virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() = 0;
+
+  bool IsRootOuterWindow()
+  {
+    do { } while (0);
+    return mIsRootOuterWindow;
+  }
+
+
+
+
+
+  virtual nsPIDOMWindowOuter* GetScriptableParentOrNull() = 0;
+
+
+  virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
+  virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
+
+  virtual bool IsTopLevelWindowActive() = 0;
+
+
+  virtual void SetActive(bool aActive)
+  {
+    do { } while (0);
+    mIsActive = aActive;
+  }
+
+  virtual void SetIsBackground(bool aIsBackground)
+  {
+    do { } while (0);
+    mIsBackground = aIsBackground;
+  }
+
+  mozilla::dom::EventTarget* GetChromeEventHandler() const
+  {
+    return mChromeEventHandler;
+  }
+
+
+  virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler) = 0;
+
+  mozilla::dom::EventTarget* GetParentTarget()
+  {
+    if (!mParentTarget) {
+      UpdateParentTarget();
+    }
+    return mParentTarget;
+  }
+
+  virtual void MaybeUpdateTouchState() {}
+
+  nsIDocument* GetExtantDoc() const
+  {
+    return mDoc;
+  }
+  nsIURI* GetDocumentURI() const;
+  nsIURI* GetDocBaseURI() const;
+
+  nsIDocument* GetDoc()
+  {
+    if (!mDoc) {
+      MaybeCreateDoc();
+    }
+    return mDoc;
+  }
+
+protected:
+
+
+  void MaybeCreateDoc();
+
+public:
+
+  inline bool IsLoading() const;
+  inline bool IsHandlingResizeEvent() const;
+
+
+
+
+  virtual void SetInitialPrincipalToSubject() = 0;
+
+  virtual PopupControlState PushPopupControlState(PopupControlState aState,
+                                                  bool aForce) const = 0;
+  virtual void PopPopupControlState(PopupControlState state) const = 0;
+  virtual PopupControlState GetPopupControlState() const = 0;
+
+
+
+  virtual already_AddRefed<nsISupports> SaveWindowState() = 0;
+
+
+  virtual nsresult RestoreWindowState(nsISupports *aState) = 0;
+
+
+
+
+
+  virtual bool IsSuspended() const = 0;
+  virtual bool IsFrozen() const = 0;
+
+
+
+  virtual nsresult FireDelayedDOMEvents() = 0;
+
+  nsPIDOMWindowOuter* GetOuterWindow()
+  {
+    return mIsInnerWindow ? mOuterWindow.get() : AsOuter();
+  }
+
+  bool IsInnerWindow() const
+  {
+    return mIsInnerWindow;
+  }
+
+  bool IsOuterWindow() const
+  {
+    return !IsInnerWindow();
+  }
+
+
+  virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument) = 0;
+
+
+
+
+  nsIDocShell *GetDocShell() const;
+
+
+
+
+
+  virtual void SetDocShell(nsIDocShell *aDocShell) = 0;
+
+
+
+
+  virtual void DetachFromDocShell() = 0;
+# 302 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual nsresult SetNewDocument(nsIDocument *aDocument,
+                                  nsISupports *aState,
+                                  bool aForceReuseInnerWindow) = 0;
+# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual void SetOpenerWindow(nsPIDOMWindowOuter* aOpener,
+                               bool aOriginalOpener) = 0;
+
+  virtual void EnsureSizeUpToDate() = 0;
+
+
+
+
+
+  virtual void EnterModalState() = 0;
+  virtual void LeaveModalState() = 0;
+
+
+  virtual bool CanClose() = 0;
+  virtual void ForceClose() = 0;
+
+  bool IsModalContentWindow() const
+  {
+    return mIsModalContentWindow;
+  }
+
+
+
+
+
+  void SetHasPaintEventListeners()
+  {
+    mMayHavePaintEventListener = true;
+  }
+
+
+
+
+
+  bool HasPaintEventListeners()
+  {
+    return mMayHavePaintEventListener;
+  }
+
+
+
+
+
+  void SetHasTouchEventListeners()
+  {
+    if (!mMayHaveTouchEventListener) {
+      mMayHaveTouchEventListener = true;
+      MaybeUpdateTouchState();
+    }
+  }
+
+
+
+
+
+
+
+  virtual nsresult SetFullscreenInternal(
+    FullscreenReason aReason, bool aIsFullscreen) = 0;
+# 383 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual void FinishFullscreenChange(bool aIsFullscreen) = 0;
+
+  virtual JSObject* GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) = 0;
+  virtual void CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
+                                        JS::Handle<JSObject*> aHandler) = 0;
+# 397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  nsIContent* GetFocusedNode() const;
+  virtual void SetFocusedNode(nsIContent* aNode,
+                              uint32_t aFocusMethod = 0,
+                              bool aNeedsFocus = false) = 0;
+
+
+
+
+  virtual uint32_t GetFocusMethod() = 0;
+# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod) = 0;
+
+
+
+
+
+  virtual void SetReadyForFocus() = 0;
+
+
+
+
+  virtual bool ShouldShowFocusRing() = 0;
+
+
+
+
+  virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
+                                     UIStateChangeType aShowFocusRings) = 0;
+
+
+
+
+
+  virtual void PageHidden() = 0;
+
+
+
+
+
+  virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI,
+                                           nsIURI *aNewURI) = 0;
+
+
+
+
+  virtual nsresult DispatchSyncPopState() = 0;
+
+
+
+
+
+
+
+  virtual void EnableDeviceSensor(uint32_t aType) = 0;
+
+
+
+
+
+
+
+  virtual void DisableDeviceSensor(uint32_t aType) = 0;
+
+
+
+
+
+
+  virtual void EnableTimeChangeNotifications() = 0;
+  virtual void DisableTimeChangeNotifications() = 0;
+# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual void SetHasGamepadEventListener(bool aHasGamepad = true) = 0;
+# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  virtual nsresult SetArguments(nsIArray *aArguments) = 0;
+
+
+
+
+
+
+  virtual uint32_t GetSerial() = 0;
+
+
+
+
+  uint64_t WindowID() const { return mWindowID; }
+
+
+
+
+
+
+
+  virtual bool DispatchCustomEvent(const nsAString& aEventName) = 0;
+
+
+
+
+
+
+  virtual nsresult
+  OpenNoNavigate(const nsAString& aUrl, const nsAString& aName,
+                 const nsAString& aOptions, nsPIDOMWindowOuter **_retval) = 0;
+
+
+
+
+  virtual void
+  FirePopupBlockedEvent(nsIDocument* aDoc,
+                        nsIURI* aPopupURI,
+                        const nsAString& aPopupWindowName,
+                        const nsAString& aPopupWindowFeatures) = 0;
+
+
+  void MarkUncollectableForCCGeneration(uint32_t aGeneration)
+  {
+    mMarkedCCGeneration = aGeneration;
+  }
+
+  uint32_t GetMarkedCCGeneration()
+  {
+    return mMarkedCCGeneration;
+  }
+
+  virtual nsIDOMScreen* GetScreen() = 0;
+  virtual nsIDOMNavigator* GetNavigator() = 0;
+  virtual nsIDOMLocation* GetLocation() = 0;
+  virtual nsresult GetPrompter(nsIPrompt** aPrompt) = 0;
+  virtual nsresult GetControllers(nsIControllers** aControllers) = 0;
+  virtual already_AddRefed<nsISelection> GetSelection() = 0;
+  virtual already_AddRefed<nsPIDOMWindowOuter> GetOpener() = 0;
+  virtual already_AddRefed<nsIDOMWindowCollection> GetFrames() = 0;
+
+
+
+  virtual nsresult Open(const nsAString& aUrl, const nsAString& aName,
+                        const nsAString& aOptions,
+                        nsIDocShellLoadInfo* aLoadInfo,
+                        bool aForceNoOpener,
+                        nsPIDOMWindowOuter **_retval) = 0;
+  virtual nsresult OpenDialog(const nsAString& aUrl, const nsAString& aName,
+                              const nsAString& aOptions,
+                              nsISupports* aExtraArgument,
+                              nsPIDOMWindowOuter** _retval) = 0;
+
+  virtual nsresult GetInnerWidth(int32_t* aWidth) = 0;
+  virtual nsresult GetInnerHeight(int32_t* aHeight) = 0;
+  virtual already_AddRefed<nsICSSDeclaration>
+    GetComputedStyle(mozilla::dom::Element& aElt, const nsAString& aPseudoElt,
+                     mozilla::ErrorResult& aError) = 0;
+  virtual already_AddRefed<nsIDOMElement> GetFrameElement() = 0;
+  virtual already_AddRefed<nsIDOMOfflineResourceList> GetApplicationCache() = 0;
+  virtual bool Closed() = 0;
+  virtual bool GetFullScreen() = 0;
+  virtual nsresult SetFullScreen(bool aFullScreen) = 0;
+
+  virtual nsresult Focus() = 0;
+  virtual nsresult Close() = 0;
+
+  virtual nsresult MoveBy(int32_t aXDif, int32_t aYDif) = 0;
+  virtual nsresult UpdateCommands(const nsAString& anAction, nsISelection* aSel, int16_t aReason) = 0;
+
+  mozilla::dom::TabGroup* TabGroup();
+
+  mozilla::dom::DocGroup* GetDocGroup() const;
+
+  virtual nsIEventTarget*
+  EventTargetFor(mozilla::TaskCategory aCategory) const = 0;
+
+protected:
+
+
+
+
+  explicit nsPIDOMWindow<T>(nsPIDOMWindowOuter *aOuterWindow);
+
+  ~nsPIDOMWindow<T>();
+
+  void SetChromeEventHandlerInternal(mozilla::dom::EventTarget* aChromeEventHandler) {
+    mChromeEventHandler = aChromeEventHandler;
+
+    mParentTarget = nullptr;
+  }
+
+  virtual void UpdateParentTarget() = 0;
+
+
+
+
+  nsCOMPtr<mozilla::dom::EventTarget> mChromeEventHandler;
+  nsCOMPtr<nsIDocument> mDoc;
+
+  nsCOMPtr<nsIURI> mDocumentURI;
+  nsCOMPtr<nsIURI> mDocBaseURI;
+
+  nsCOMPtr<mozilla::dom::EventTarget> mParentTarget;
+
+
+  nsCOMPtr<mozilla::dom::Element> mFrameElement;
+
+
+
+  nsIDocShell* mDocShell;
+
+
+  RefPtr<mozilla::dom::Performance> mPerformance;
+
+  mozilla::UniquePtr<mozilla::dom::TimeoutManager> mTimeoutManager;
+
+  typedef nsRefPtrHashtable<nsStringHashKey,
+                            mozilla::dom::ServiceWorkerRegistration>
+          ServiceWorkerRegistrationTable;
+  ServiceWorkerRegistrationTable mServiceWorkerRegistrationTable;
+
+  uint32_t mModalStateDepth;
+
+
+  uint32_t mMutationBits;
+
+  bool mIsDocumentLoaded;
+  bool mIsHandlingResizeEvent;
+  bool mIsInnerWindow;
+  bool mMayHavePaintEventListener;
+  bool mMayHaveTouchEventListener;
+  bool mMayHaveMouseEnterLeaveEventListener;
+  bool mMayHavePointerEnterLeaveEventListener;
+
+
+
+
+  bool mInnerObjectsFreed;
+
+
+
+
+  bool mIsModalContentWindow;
+
+
+
+  bool mIsActive;
+
+
+
+
+  bool mIsBackground;
+# 699 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  SuspendTypes mMediaSuspend;
+
+  bool mAudioMuted;
+  float mAudioVolume;
+
+  bool mAudioCaptured;
+
+
+  bool mDesktopModeViewport;
+
+  bool mIsRootOuterWindow;
+
+
+  nsPIDOMWindowInner* mInnerWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> mOuterWindow;
+
+
+
+  nsCOMPtr<nsIContent> mFocusedNode;
+
+
+  nsTArray<mozilla::dom::AudioContext*> mAudioContexts;
+
+
+  RefPtr<mozilla::dom::TabGroup> mTabGroup;
+
+
+
+  uint64_t mWindowID;
+
+
+
+  bool mHasNotifiedGlobalCreated;
+
+  uint32_t mMarkedCCGeneration;
+
+
+
+  bool mServiceWorkersTestingEnabled;
+
+  mozilla::dom::LargeAllocStatus mLargeAllocStatus;
+
+
+
+  bool mShouldResumeOnFirstActiveMediaComponent;
+};
+# 756 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+class nsPIDOMWindowInner : public nsPIDOMWindow<mozIDOMWindow>
+{
+  friend nsGlobalWindow;
+
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  static nsPIDOMWindowInner* From(mozIDOMWindow* aFrom) {
+    return static_cast<nsPIDOMWindowInner*>(aFrom);
+  }
+
+
+
+  inline bool IsCurrentInnerWindow() const;
+
+
+
+
+  inline bool HasActiveDocument();
+
+  bool AddAudioContext(mozilla::dom::AudioContext* aAudioContext);
+  void RemoveAudioContext(mozilla::dom::AudioContext* aAudioContext);
+  void MuteAudioContexts();
+  void UnmuteAudioContexts();
+
+  bool GetAudioCaptured() const;
+  nsresult SetAudioCapture(bool aCapture);
+
+  already_AddRefed<mozilla::dom::ServiceWorkerRegistration>
+    GetServiceWorkerRegistration(const nsAString& aScope);
+  void InvalidateServiceWorkerRegistration(const nsAString& aScope);
+
+  mozilla::dom::Performance* GetPerformance();
+
+  bool HasMutationListeners(uint32_t aMutationEventType) const
+  {
+    if (!mOuterWindow) {
+      do { } while(0);
+
+      return false;
+    }
+
+    return (mMutationBits & aMutationEventType) != 0;
+  }
+
+  void SetMutationListeners(uint32_t aType)
+  {
+    if (!mOuterWindow) {
+      do { } while(0);
+
+      return;
+    }
+
+    mMutationBits |= aType;
+  }
+
+
+
+
+
+  bool HasMouseEnterLeaveEventListeners()
+  {
+    return mMayHaveMouseEnterLeaveEventListener;
+  }
+
+
+
+
+
+  void SetHasMouseEnterLeaveEventListeners()
+  {
+    mMayHaveMouseEnterLeaveEventListener = true;
+  }
+
+
+
+
+
+  bool HasPointerEnterLeaveEventListeners()
+  {
+    return mMayHavePointerEnterLeaveEventListener;
+  }
+
+
+
+
+
+  void SetHasPointerEnterLeaveEventListeners()
+  {
+    mMayHavePointerEnterLeaveEventListener = true;
+  }
+
+
+
+
+  bool InnerObjectsFreed() const
+  {
+    return mInnerObjectsFreed;
+  }
+
+
+
+
+  bool IsSecureContext() const;
+  bool IsSecureContextIfOpenerIgnored() const;
+# 869 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  void Suspend();
+  void Resume();
+# 879 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+  void Freeze();
+  void Thaw();
+
+
+
+  void SyncStateFromParentWindow();
+
+  bool IsPlayingAudio();
+
+  mozilla::dom::TimeoutManager& TimeoutManager();
+
+  bool IsRunningTimeout();
+
+protected:
+  void CreatePerformanceObjectIfNeeded();
+};
+
+template<typename T> struct nsPIDOMWindowInner::COMTypeInfo<nsPIDOMWindowInner, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsPIDOMWindowInner::COMTypeInfo<nsPIDOMWindowInner, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x775dabc9, 0x8f43, 0x4277, { 0x9a, 0xdb, 0xf1, 0x99, 0x0d, 0x77, 0xcf, 0xfb } };
+
+
+
+class nsPIDOMWindowOuter : public nsPIDOMWindow<mozIDOMWindowProxy>
+{
+protected:
+  void RefreshMediaElementsVolume();
+  void RefreshMediaElementsSuspend(SuspendTypes aSuspend);
+  bool IsDisposableSuspend(SuspendTypes aSuspend) const;
+  void MaybeNotifyMediaResumedFromBlock(SuspendTypes aSuspend);
+
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  static nsPIDOMWindowOuter* From(mozIDOMWindowProxy* aFrom) {
+    return static_cast<nsPIDOMWindowOuter*>(aFrom);
+  }
+
+
+
+  static nsPIDOMWindowOuter* GetFromCurrentInner(nsPIDOMWindowInner* aInner);
+
+  nsPIDOMWindowInner* GetCurrentInnerWindow() const
+  {
+    return mInnerWindow;
+  }
+
+  nsPIDOMWindowInner* EnsureInnerWindow()
+  {
+    do { } while (0);
+
+    GetDoc();
+    return GetCurrentInnerWindow();
+  }
+
+
+
+
+  void SetInitialKeyboardIndicators(UIStateChangeType aShowAccelerators,
+                                    UIStateChangeType aShowFocusRings);
+
+
+
+
+  mozilla::dom::Element* GetFrameElementInternal() const;
+  void SetFrameElementInternal(mozilla::dom::Element* aFrameElement);
+
+  bool IsActive()
+  {
+    return mIsActive;
+  }
+
+  void SetDesktopModeViewport(bool aDesktopModeViewport)
+  {
+    mDesktopModeViewport = aDesktopModeViewport;
+  }
+  bool IsDesktopModeViewport() const
+  {
+    return mDesktopModeViewport;
+  }
+  bool IsBackground()
+  {
+    return mIsBackground;
+  }
+
+
+  SuspendTypes GetMediaSuspend() const;
+  void SetMediaSuspend(SuspendTypes aSuspend);
+
+  bool GetAudioMuted() const;
+  void SetAudioMuted(bool aMuted);
+
+  float GetAudioVolume() const;
+  nsresult SetAudioVolume(float aVolume);
+
+  void NotifyCreatedNewMediaComponent();
+  void MaybeActiveMediaComponents();
+
+  void SetServiceWorkersTestingEnabled(bool aEnabled);
+  bool GetServiceWorkersTestingEnabled();
+
+  float GetDevicePixelRatio(mozilla::dom::CallerType aCallerType);
+
+  void SetLargeAllocStatus(mozilla::dom::LargeAllocStatus aStatus);
+
+  bool IsTopLevelWindow();
+  bool HadOriginalOpener() const;
+};
+
+template<typename T> struct nsPIDOMWindowOuter::COMTypeInfo<nsPIDOMWindowOuter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsPIDOMWindowOuter::COMTypeInfo<nsPIDOMWindowOuter, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x769693d4, 0xb009, 0x4fe2, { 0xaf, 0x18, 0x7d, 0xc8, 0xdf, 0x74, 0x96, 0xdf } };
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindowInlines.h" 1
+
+
+
+
+template<class T>
+nsPIDOMWindowInner*
+nsPIDOMWindow<T>::AsInner()
+{
+  do { } while (0);
+  return reinterpret_cast<nsPIDOMWindowInner*>(this);
+}
+
+template<class T>
+const nsPIDOMWindowInner*
+nsPIDOMWindow<T>::AsInner() const
+{
+  do { } while (0);
+  return reinterpret_cast<const nsPIDOMWindowInner*>(this);
+}
+
+template<class T>
+nsPIDOMWindowOuter*
+nsPIDOMWindow<T>::AsOuter()
+{
+  do { } while (0);
+  return reinterpret_cast<nsPIDOMWindowOuter*>(this);
+}
+
+template<class T>
+const nsPIDOMWindowOuter*
+nsPIDOMWindow<T>::AsOuter() const
+{
+  do { } while (0);
+  return reinterpret_cast<const nsPIDOMWindowOuter*>(this);
+}
+
+template <class T>
+bool
+nsPIDOMWindow<T>::IsLoading() const
+{
+  if (IsOuterWindow()) {
+    auto* win = AsOuter()->GetCurrentInnerWindow();
+
+    if (!win) {
+      do { } while(0);
+
+      return false;
+    }
+
+    return win->IsLoading();
+  }
+
+  if (!mOuterWindow) {
+    do { } while(0);
+
+    return false;
+  }
+
+  return !mIsDocumentLoaded;
+}
+
+template <class T>
+bool
+nsPIDOMWindow<T>::IsHandlingResizeEvent() const
+{
+  if (IsOuterWindow()) {
+    auto* win = AsOuter()->GetCurrentInnerWindow();
+
+    if (!win) {
+      do { } while(0);
+
+      return false;
+    }
+
+    return win->IsHandlingResizeEvent();
+  }
+
+  if (!mOuterWindow) {
+    do { } while(0);
+
+    return false;
+  }
+
+  return mIsHandlingResizeEvent;
+}
+
+bool
+nsPIDOMWindowInner::IsCurrentInnerWindow() const
+{
+  return mOuterWindow && mOuterWindow->GetCurrentInnerWindow() == AsInner();
+}
+
+bool
+nsPIDOMWindowInner::HasActiveDocument()
+{
+  return IsCurrentInnerWindow() ||
+    (mOuterWindow &&
+     mOuterWindow->GetCurrentInnerWindow() &&
+     mOuterWindow->GetCurrentInnerWindow()->GetDoc() == mDoc);
+}
+
+template <class T>
+nsIDocShell*
+nsPIDOMWindow<T>::GetDocShell() const
+{
+  if (mOuterWindow) {
+    return mOuterWindow->GetDocShell();
+  }
+
+  return mDocShell;
+}
+
+template <class T>
+nsIContent*
+nsPIDOMWindow<T>::GetFocusedNode() const
+{
+  if (IsOuterWindow()) {
+    return mInnerWindow ? mInnerWindow->GetFocusedNode() : nullptr;
+  }
+
+  return mFocusedNode;
+}
+# 989 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
+
+
+PopupControlState
+PushPopupControlState(PopupControlState aState, bool aForce);
+
+void
+PopPopupControlState(PopupControlState aState);
+# 1008 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+class nsAutoPopupStatePusherInternal
+{
+public:
+
+  explicit nsAutoPopupStatePusherInternal(PopupControlState aState, bool aForce = false)
+    : mOldState(::PushPopupControlState(aState, aForce))
+  {
+  }
+
+  ~nsAutoPopupStatePusherInternal()
+  {
+    PopPopupControlState(mOldState);
+  }
+# 1038 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
+protected:
+
+
+
+  PopupControlState mOldState;
+
+private:
+
+  static void* operator new(size_t ) throw() { return nullptr; }
+  static void operator delete(void* ) {}
+};
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/JSSlots.h" 1
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h"
+class nsIObserver;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h"
+class nsIPrefBranch : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    PREF_INVALID = 0,
+    PREF_STRING = 32,
+    PREF_INT = 64,
+    PREF_BOOL = 128
+  };
+
+
+  virtual nsresult GetRoot(char * *aRoot) = 0;
+
+
+  virtual nsresult GetPrefType(const char * aPrefName, int32_t *_retval) = 0;
+
+
+  virtual nsresult GetBoolPrefWithDefault(const char * aPrefName, bool aDefaultValue, uint8_t _argc, bool *_retval) = 0;
+
+
+  virtual nsresult GetBoolPref(const char * aPrefName, bool *_retval) = 0;
+
+
+  virtual nsresult SetBoolPref(const char * aPrefName, bool aValue) = 0;
+
+
+  virtual nsresult GetFloatPrefWithDefault(const char * aPrefName, float aDefaultValue, uint8_t _argc, float *_retval) = 0;
+
+
+  virtual nsresult GetFloatPref(const char * aPrefName, float *_retval) = 0;
+
+
+  virtual nsresult GetCharPrefWithDefault(const char * aPrefName, const char * aDefaultValue, uint8_t _argc, char * *_retval) = 0;
+
+
+  virtual nsresult GetCharPref(const char * aPrefName, char * *_retval) = 0;
+
+
+  virtual nsresult SetCharPref(const char * aPrefName, const char * aValue) = 0;
+
+
+  virtual nsresult GetStringPref(const char * aPrefName, const nsACString & aDefaultValue, uint8_t _argc, nsACString & _retval) = 0;
+
+
+  virtual nsresult SetStringPref(const char * aPrefName, const nsACString & aValue) = 0;
+
+
+  virtual nsresult GetIntPrefWithDefault(const char * aPrefName, int32_t aDefaultValue, uint8_t _argc, int32_t *_retval) = 0;
+
+
+  virtual nsresult GetIntPref(const char * aPrefName, int32_t *_retval) = 0;
+
+
+  virtual nsresult SetIntPref(const char * aPrefName, int32_t aValue) = 0;
+
+
+  virtual nsresult GetComplexValue(const char * aPrefName, const nsIID & aType, void **aValue) = 0;
+
+
+  virtual nsresult SetComplexValue(const char * aPrefName, const nsIID & aType, nsISupports *aValue) = 0;
+
+
+  virtual nsresult ClearUserPref(const char * aPrefName) = 0;
+
+
+  virtual nsresult LockPref(const char * aPrefName) = 0;
+
+
+  virtual nsresult PrefHasUserValue(const char * aPrefName, bool *_retval) = 0;
+
+
+  virtual nsresult PrefIsLocked(const char * aPrefName, bool *_retval) = 0;
+
+
+  virtual nsresult UnlockPref(const char * aPrefName) = 0;
+
+
+  virtual nsresult DeleteBranch(const char * aStartingAt) = 0;
+
+
+  virtual nsresult GetChildList(const char * aStartingAt, uint32_t *aCount, char * **aChildArray) = 0;
+
+
+  virtual nsresult ResetBranch(const char * aStartingAt) = 0;
+
+
+  virtual nsresult AddObserver(const char * aDomain, nsIObserver *aObserver, bool aHoldWeak) = 0;
+
+
+  virtual nsresult RemoveObserver(const char * aDomain, nsIObserver *aObserver) = 0;
+
+};
+
+  template<typename T> struct nsIPrefBranch::COMTypeInfo<nsIPrefBranch, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranch::COMTypeInfo<nsIPrefBranch, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x55d25e49, 0x793f, 0x4727, { 0xa6, 0x9f, 0xde, 0x8b, 0x15, 0xf4, 0xb9, 0x85 }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h" 2
+
+
+
+
+
+
+struct PrefTuple;
+
+class nsIFile;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h"
+class nsIPrefService : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult ReadUserPrefs(nsIFile *aFile) = 0;
+
+
+  virtual nsresult ResetPrefs(void) = 0;
+
+
+  virtual nsresult ResetUserPrefs(void) = 0;
+
+
+  virtual nsresult SavePrefFile(nsIFile *aFile) = 0;
+
+
+  virtual nsresult GetBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) = 0;
+
+
+  virtual nsresult GetDefaultBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) = 0;
+
+
+  virtual nsresult GetDirty(bool *aDirty) = 0;
+
+};
+
+  template<typename T> struct nsIPrefService::COMTypeInfo<nsIPrefService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefService::COMTypeInfo<nsIPrefService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x1f84fd56, 0x3956, 0x40df, { 0xb8, 0x6a, 0x1e, 0xa0, 0x14, 0x02, 0xee, 0x96 }};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch2.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch2.h"
+class nsIPrefBranch2 : public nsIPrefBranch {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct nsIPrefBranch2::COMTypeInfo<nsIPrefBranch2, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranch2::COMTypeInfo<nsIPrefBranch2, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8892016d, 0x07f7, 0x4530, { 0xb5, 0xc1, 0xd7, 0x3d, 0xfc, 0xde, 0x4a, 0x1c }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h"
+class nsIPrefBranchInternal : public nsIPrefBranch2 {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+};
+
+  template<typename T> struct nsIPrefBranchInternal::COMTypeInfo<nsIPrefBranchInternal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranchInternal::COMTypeInfo<nsIPrefBranchInternal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x355bd1e9, 0x248a, 0x438b, { 0x80, 0x9d, 0xe0, 0xdb, 0x1b, 0x28, 0x78, 0x82 }};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 2
+
+
+
+
+
+
+
+class nsIFile;
+class nsAdoptingString;
+class nsAdoptingCString;
+
+
+typedef void (*PrefChangedFunc)(const char *, void *);
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+namespace mozilla {
+
+namespace dom {
+class PrefSetting;
+}
+
+class Preferences final : public nsIPrefService,
+                          public nsIObserver,
+                          public nsIPrefBranchInternal,
+                          public nsSupportsWeakReference
+{
+public:
+  typedef mozilla::dom::PrefSetting PrefSetting;
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+  virtual nsresult ReadUserPrefs(nsIFile *aFile) override; virtual nsresult ResetPrefs(void) override; virtual nsresult ResetUserPrefs(void) override; virtual nsresult SavePrefFile(nsIFile *aFile) override; virtual nsresult GetBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) override; virtual nsresult GetDefaultBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) override; virtual nsresult GetDirty(bool *aDirty) override;
+  virtual nsresult GetRoot(char * *aRoot) override { return sRootBranch-> GetRoot(aRoot); } virtual nsresult GetPrefType(const char * aPrefName, int32_t *_retval) override { return sRootBranch-> GetPrefType(aPrefName, _retval); } virtual nsresult GetBoolPrefWithDefault(const char * aPrefName, bool aDefaultValue, uint8_t _argc, bool *_retval) override { return sRootBranch-> GetBoolPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetBoolPref(const char * aPrefName, bool *_retval) override { return sRootBranch-> GetBoolPref(aPrefName, _retval); } virtual nsresult SetBoolPref(const char * aPrefName, bool aValue) override { return sRootBranch-> SetBoolPref(aPrefName, aValue); } virtual nsresult GetFloatPrefWithDefault(const char * aPrefName, float aDefaultValue, uint8_t _argc, float *_retval) override { return sRootBranch-> GetFloatPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetFloatPref(const char * aPrefName, float *_retval) override { return sRootBranch-> GetFloatPref(aPrefName, _retval); } virtual nsresult GetCharPrefWithDefault(const char * aPrefName, const char * aDefaultValue, uint8_t _argc, char * *_retval) override { return sRootBranch-> GetCharPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetCharPref(const char * aPrefName, char * *_retval) override { return sRootBranch-> GetCharPref(aPrefName, _retval); } virtual nsresult SetCharPref(const char * aPrefName, const char * aValue) override { return sRootBranch-> SetCharPref(aPrefName, aValue); } virtual nsresult GetStringPref(const char * aPrefName, const nsACString & aDefaultValue, uint8_t _argc, nsACString & _retval) override { return sRootBranch-> GetStringPref(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult SetStringPref(const char * aPrefName, const nsACString & aValue) override { return sRootBranch-> SetStringPref(aPrefName, aValue); } virtual nsresult GetIntPrefWithDefault(const char * aPrefName, int32_t aDefaultValue, uint8_t _argc, int32_t *_retval) override { return sRootBranch-> GetIntPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetIntPref(const char * aPrefName, int32_t *_retval) override { return sRootBranch-> GetIntPref(aPrefName, _retval); } virtual nsresult SetIntPref(const char * aPrefName, int32_t aValue) override { return sRootBranch-> SetIntPref(aPrefName, aValue); } virtual nsresult GetComplexValue(const char * aPrefName, const nsIID & aType, void **aValue) override { return sRootBranch-> GetComplexValue(aPrefName, aType, aValue); } virtual nsresult SetComplexValue(const char * aPrefName, const nsIID & aType, nsISupports *aValue) override { return sRootBranch-> SetComplexValue(aPrefName, aType, aValue); } virtual nsresult ClearUserPref(const char * aPrefName) override { return sRootBranch-> ClearUserPref(aPrefName); } virtual nsresult LockPref(const char * aPrefName) override { return sRootBranch-> LockPref(aPrefName); } virtual nsresult PrefHasUserValue(const char * aPrefName, bool *_retval) override { return sRootBranch-> PrefHasUserValue(aPrefName, _retval); } virtual nsresult PrefIsLocked(const char * aPrefName, bool *_retval) override { return sRootBranch-> PrefIsLocked(aPrefName, _retval); } virtual nsresult UnlockPref(const char * aPrefName) override { return sRootBranch-> UnlockPref(aPrefName); } virtual nsresult DeleteBranch(const char * aStartingAt) override { return sRootBranch-> DeleteBranch(aStartingAt); } virtual nsresult GetChildList(const char * aStartingAt, uint32_t *aCount, char * **aChildArray) override { return sRootBranch-> GetChildList(aStartingAt, aCount, aChildArray); } virtual nsresult ResetBranch(const char * aStartingAt) override { return sRootBranch-> ResetBranch(aStartingAt); } virtual nsresult AddObserver(const char * aDomain, nsIObserver *aObserver, bool aHoldWeak) override { return sRootBranch-> AddObserver(aDomain, aObserver, aHoldWeak); } virtual nsresult RemoveObserver(const char * aDomain, nsIObserver *aObserver) override { return sRootBranch-> RemoveObserver(aDomain, aObserver); }
+  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
+
+  Preferences();
+
+  nsresult Init();
+
+
+
+
+  static bool IsServiceAvailable();
+
+
+
+
+  static nsresult ResetAndReadUserPrefs();
+
+
+
+
+  static Preferences* GetInstanceForService();
+
+
+
+
+  static void Shutdown();
+
+
+
+
+
+  static nsIPrefService* GetService()
+  {
+    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
+    return sPreferences;
+  }
+
+
+
+
+
+  static nsIPrefBranch* GetRootBranch()
+  {
+    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
+    return sRootBranch;
+  }
+
+
+
+
+
+  static nsIPrefBranch* GetDefaultRootBranch()
+  {
+    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
+    return sDefaultRootBranch;
+  }
+
+
+
+
+
+  static bool GetBool(const char* aPref, bool aDefault = false)
+  {
+    bool result = aDefault;
+    GetBool(aPref, &result);
+    return result;
+  }
+
+  static int32_t GetInt(const char* aPref, int32_t aDefault = 0)
+  {
+    int32_t result = aDefault;
+    GetInt(aPref, &result);
+    return result;
+  }
+
+  static uint32_t GetUint(const char* aPref, uint32_t aDefault = 0)
+  {
+    uint32_t result = aDefault;
+    GetUint(aPref, &result);
+    return result;
+  }
+
+  static float GetFloat(const char* aPref, float aDefault = 0)
+  {
+    float result = aDefault;
+    GetFloat(aPref, &result);
+    return result;
+  }
+# 172 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+  static nsAdoptingCString GetCString(const char* aPref);
+  static nsAdoptingString GetString(const char* aPref);
+  static nsAdoptingCString GetLocalizedCString(const char* aPref);
+  static nsAdoptingString GetLocalizedString(const char* aPref);
+# 185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+  static nsresult GetBool(const char* aPref, bool* aResult);
+  static nsresult GetInt(const char* aPref, int32_t* aResult);
+  static nsresult GetFloat(const char* aPref, float* aResult);
+  static nsresult GetUint(const char* aPref, uint32_t* aResult)
+  {
+    int32_t result;
+    nsresult rv = GetInt(aPref, &result);
+    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
+      *aResult = static_cast<uint32_t>(result);
+    }
+    return rv;
+  }
+# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+  static nsresult GetCString(const char* aPref, nsACString* aResult);
+  static nsresult GetString(const char* aPref, nsAString* aResult);
+  static nsresult GetLocalizedCString(const char* aPref, nsACString* aResult);
+  static nsresult GetLocalizedString(const char* aPref, nsAString* aResult);
+
+  static nsresult GetComplex(const char* aPref, const nsIID &aType,
+                             void** aResult);
+
+
+
+
+  static nsresult SetBool(const char* aPref, bool aValue);
+  static nsresult SetInt(const char* aPref, int32_t aValue);
+  static nsresult SetUint(const char* aPref, uint32_t aValue)
+  {
+    return SetInt(aPref, static_cast<int32_t>(aValue));
+  }
+  static nsresult SetFloat(const char* aPref, float aValue);
+  static nsresult SetCString(const char* aPref, const char* aValue);
+  static nsresult SetCString(const char* aPref, const nsACString &aValue);
+  static nsresult SetString(const char* aPref, const char16ptr_t aValue);
+  static nsresult SetString(const char* aPref, const nsAString &aValue);
+
+  static nsresult SetComplex(const char* aPref, const nsIID &aType,
+                             nsISupports* aValue);
+
+
+
+
+  static nsresult ClearUser(const char* aPref);
+
+
+
+
+  static bool HasUserValue(const char* aPref);
+
+
+
+
+  static int32_t GetType(const char* aPref);
+
+
+
+
+
+
+
+  static nsresult AddStrongObserver(nsIObserver* aObserver, const char* aPref);
+  static nsresult AddWeakObserver(nsIObserver* aObserver, const char* aPref);
+  static nsresult RemoveObserver(nsIObserver* aObserver, const char* aPref);
+
+
+
+
+
+  static nsresult AddStrongObservers(nsIObserver* aObserver,
+                                     const char** aPrefs);
+  static nsresult AddWeakObservers(nsIObserver* aObserver,
+                                   const char** aPrefs);
+  static nsresult RemoveObservers(nsIObserver* aObserver,
+                                  const char** aPrefs);
+
+
+
+
+  static nsresult RegisterCallback(PrefChangedFunc aCallback,
+                                   const char* aPref,
+                                   void* aClosure = nullptr)
+  {
+    return RegisterCallback(aCallback, aPref, aClosure, ExactMatch);
+  }
+  static nsresult UnregisterCallback(PrefChangedFunc aCallback,
+                                     const char* aPref,
+                                     void* aClosure = nullptr)
+  {
+    return UnregisterCallback(aCallback, aPref, aClosure, ExactMatch);
+  }
+
+
+  static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
+                                          const char* aPref,
+                                          void* aClosure = nullptr)
+  {
+    return RegisterCallbackAndCall(aCallback, aPref, aClosure, ExactMatch);
+  }
+
+
+
+
+
+  static nsresult RegisterPrefixCallback(PrefChangedFunc aCallback,
+                                         const char* aPref,
+                                         void* aClosure = nullptr)
+  {
+    return RegisterCallback(aCallback, aPref, aClosure, PrefixMatch);
+  }
+
+
+
+
+
+  static nsresult RegisterPrefixCallbackAndCall(PrefChangedFunc aCallback,
+                                                const char* aPref,
+                                                void* aClosure = nullptr)
+  {
+    return RegisterCallbackAndCall(aCallback, aPref, aClosure, PrefixMatch);
+  }
+
+
+
+
+
+  static nsresult UnregisterPrefixCallback(PrefChangedFunc aCallback,
+                                           const char* aPref,
+                                           void* aClosure = nullptr)
+  {
+    return UnregisterCallback(aCallback, aPref, aClosure, PrefixMatch);
+  }
+
+
+
+
+
+
+
+  static nsresult AddBoolVarCache(bool* aVariable,
+                                  const char* aPref,
+                                  bool aDefault = false);
+  static nsresult AddIntVarCache(int32_t* aVariable,
+                                 const char* aPref,
+                                 int32_t aDefault = 0);
+  static nsresult AddUintVarCache(uint32_t* aVariable,
+                                  const char* aPref,
+                                  uint32_t aDefault = 0);
+  template <MemoryOrdering Order>
+  static nsresult AddAtomicUintVarCache(Atomic<uint32_t, Order>* aVariable,
+                                        const char* aPref,
+                                        uint32_t aDefault = 0);
+  static nsresult AddFloatVarCache(float* aVariable,
+                                   const char* aPref,
+                                   float aDefault = 0.0f);
+
+
+
+
+
+
+
+  static nsresult GetDefaultBool(const char* aPref, bool* aResult);
+  static nsresult GetDefaultInt(const char* aPref, int32_t* aResult);
+  static nsresult GetDefaultUint(const char* aPref, uint32_t* aResult)
+  {
+    return GetDefaultInt(aPref, reinterpret_cast<int32_t*>(aResult));
+  }
+
+
+
+
+
+
+
+  static bool GetDefaultBool(const char* aPref, bool aFailedResult)
+  {
+    bool result;
+    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetDefaultBool(aPref, &result))), 1))) ? result :
+                                                          aFailedResult;
+  }
+  static int32_t GetDefaultInt(const char* aPref, int32_t aFailedResult)
+  {
+    int32_t result;
+    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetDefaultInt(aPref, &result))), 1))) ? result : aFailedResult;
+  }
+  static uint32_t GetDefaultUint(const char* aPref, uint32_t aFailedResult)
+  {
+   return static_cast<uint32_t>(
+     GetDefaultInt(aPref, static_cast<int32_t>(aFailedResult)));
+  }
+# 391 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
+  static nsAdoptingString GetDefaultString(const char* aPref);
+  static nsAdoptingCString GetDefaultCString(const char* aPref);
+  static nsAdoptingString GetDefaultLocalizedString(const char* aPref);
+  static nsAdoptingCString GetDefaultLocalizedCString(const char* aPref);
+
+  static nsresult GetDefaultCString(const char* aPref, nsACString* aResult);
+  static nsresult GetDefaultString(const char* aPref, nsAString* aResult);
+  static nsresult GetDefaultLocalizedCString(const char* aPref,
+                                             nsACString* aResult);
+  static nsresult GetDefaultLocalizedString(const char* aPref,
+                                            nsAString* aResult);
+
+  static nsresult GetDefaultComplex(const char* aPref, const nsIID &aType,
+                                    void** aResult);
+
+
+
+
+  static int32_t GetDefaultType(const char* aPref);
+
+
+  static void GetPreferences(InfallibleTArray<PrefSetting>* aPrefs);
+  static void GetPreference(PrefSetting* aPref);
+  static void SetPreference(const PrefSetting& aPref);
+
+  static void SetInitPreferences(nsTArray<PrefSetting>* aPrefs);
+
+
+
+
+
+
+  static int64_t SizeOfIncludingThisAndOtherStuff(mozilla::MallocSizeOf aMallocSizeOf);
+
+  static void DirtyCallback();
+
+protected:
+  virtual ~Preferences();
+
+  nsresult NotifyServiceObservers(const char *aSubject);
+
+
+
+
+
+
+  nsresult UseDefaultPrefFile();
+  nsresult UseUserPrefFile();
+  nsresult ReadAndOwnUserPrefFile(nsIFile *aFile);
+  nsresult ReadAndOwnSharedUserPrefFile(nsIFile *aFile);
+  nsresult SavePrefFileInternal(nsIFile* aFile);
+  nsresult WritePrefFile(nsIFile* aFile);
+  nsresult MakeBackupPrefFile(nsIFile *aFile);
+
+
+
+
+
+public:
+
+  enum MatchKind {
+    PrefixMatch,
+    ExactMatch,
+  };
+
+protected:
+  static nsresult RegisterCallback(PrefChangedFunc aCallback,
+                                   const char* aPref,
+                                   void* aClosure,
+                                   MatchKind aMatchKind);
+  static nsresult UnregisterCallback(PrefChangedFunc aCallback,
+                                     const char* aPref,
+                                     void* aClosure,
+                                     MatchKind aMatchKind);
+  static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
+                                          const char* aPref,
+                                          void* aClosure,
+                                          MatchKind aMatchKind);
+
+private:
+  nsCOMPtr<nsIFile> mCurrentFile;
+  bool mDirty;
+
+  static Preferences* sPreferences;
+  static nsIPrefBranch* sRootBranch;
+  static nsIPrefBranch* sDefaultRootBranch;
+  static bool sShutdown;
+
+
+
+
+  static bool InitStaticMembers();
+};
+
+}
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
+
+class nsGlobalWindow;
+class nsIPrincipal;
+class nsScriptNameSpaceManager;
+class nsIMemoryReporterCallback;
+
+namespace mozilla {
+namespace dom {
+class Exception;
+}
+}
+
+typedef void (* xpcGCCallback)(JSGCStatus status);
+
+namespace xpc {
+
+class Scriptability {
+public:
+    explicit Scriptability(JSCompartment* c);
+    bool Allowed();
+    bool IsImmuneToScriptPolicy();
+
+    void Block();
+    void Unblock();
+    void SetDocShellAllowsScript(bool aAllowed);
+
+    static Scriptability& Get(JSObject* aScope);
+
+private:
+
+
+
+
+    uint32_t mScriptBlocks;
+
+
+
+    bool mDocShellAllowsScript;
+
+
+
+    bool mImmuneToScriptPolicy;
+
+
+
+    bool mScriptBlockedByPolicy;
+};
+
+JSObject*
+TransplantObject(JSContext* cx, JS::HandleObject origobj, JS::HandleObject target);
+
+bool IsContentXBLScope(JSCompartment* compartment);
+bool IsInContentXBLScope(JSObject* obj);
+# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+JSObject*
+GetXBLScope(JSContext* cx, JSObject* contentScope);
+
+inline JSObject*
+GetXBLScopeOrGlobal(JSContext* cx, JSObject* obj)
+{
+    if (IsInContentXBLScope(obj))
+        return js::GetGlobalForObjectCrossCompartment(obj);
+    return GetXBLScope(cx, obj);
+}
+
+
+
+
+
+JSObject*
+GetScopeForXBLExecution(JSContext* cx, JS::HandleObject obj, JSAddonId* addonId);
+
+
+
+bool
+AllowContentXBLScope(JSCompartment* c);
+
+
+
+
+
+bool
+UseContentXBLScope(JSCompartment* c);
+
+
+
+void
+ClearContentXBLScope(JSObject* global);
+
+bool
+IsInAddonScope(JSObject* obj);
+
+JSObject*
+GetAddonScope(JSContext* cx, JS::HandleObject contentScope, JSAddonId* addonId);
+
+bool
+IsSandboxPrototypeProxy(JSObject* obj);
+
+bool
+IsReflector(JSObject* obj);
+
+bool
+IsXrayWrapper(JSObject* obj);
+
+
+
+
+
+
+JSObject*
+XrayAwareCalleeGlobal(JSObject* fun);
+# 165 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+bool
+XrayAwareCalleeGlobalForSpecializedGetters(JSContext* cx,
+                                           JS::Handle<JSObject*> thisObj,
+                                           JS::MutableHandle<JSObject*> global);
+
+
+void
+TraceXPCGlobal(JSTracer* trc, JSObject* obj);
+
+}
+
+namespace JS {
+
+struct RuntimeStats;
+
+}
+# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+inline JSObject*
+xpc_FastGetCachedWrapper(JSContext* cx, nsWrapperCache* cache, JS::MutableHandleValue vp)
+{
+    if (cache) {
+        JSObject* wrapper = cache->GetWrapper();
+        if (wrapper &&
+            js::GetObjectCompartment(wrapper) == js::GetContextCompartment(cx))
+        {
+            vp.setObject(*wrapper);
+            return wrapper;
+        }
+    }
+
+    return nullptr;
+}
+
+
+
+extern void
+xpc_MarkInCCGeneration(nsISupports* aVariant, uint32_t aGeneration);
+
+
+extern void
+xpc_TryUnmarkWrappedGrayObject(nsISupports* aWrappedJS);
+
+extern void
+xpc_UnmarkSkippableJSHolders();
+
+
+class XPCStringConvert
+{
+
+
+
+
+
+    struct ZoneStringCache
+    {
+# 241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+        void* mBuffer = nullptr;
+        uint32_t mLength = 0;
+        JSString* mString = nullptr;
+    };
+
+public:
+
+
+
+
+    static bool ReadableToJSVal(JSContext* cx, const nsAString& readable,
+                                nsStringBuffer** sharedBuffer,
+                                JS::MutableHandleValue vp);
+
+
+    static __attribute__((always_inline)) inline bool
+    StringBufferToJSVal(JSContext* cx, nsStringBuffer* buf, uint32_t length,
+                        JS::MutableHandleValue rval, bool* sharedBuffer)
+    {
+        JS::Zone* zone = js::GetContextZone(cx);
+        ZoneStringCache* cache = static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone));
+        if (cache && buf == cache->mBuffer && length == cache->mLength) {
+            do { } while (0);
+            JS::StringReadBarrier(cache->mString);
+            rval.setString(cache->mString);
+            *sharedBuffer = false;
+            return true;
+        }
+
+        bool isExternal;
+        JSString* str = JS_NewMaybeExternalString(cx,
+                                                  static_cast<char16_t*>(buf->Data()),
+                                                  length, &sDOMStringFinalizer, &isExternal);
+        if (!str) {
+            return false;
+        }
+        rval.setString(str);
+
+
+
+        if (!isExternal) {
+            *sharedBuffer = false;
+            return true;
+        }
+
+        if (!cache) {
+            cache = new ZoneStringCache();
+            JS_SetZoneUserData(zone, cache);
+        }
+        cache->mBuffer = buf;
+        cache->mLength = length;
+        cache->mString = str;
+        *sharedBuffer = true;
+        return true;
+    }
+
+    static void FreeZoneCache(JS::Zone* zone);
+    static void ClearZoneCache(JS::Zone* zone);
+
+    static __attribute__((always_inline)) inline bool IsLiteral(JSString* str)
+    {
+        return JS_IsExternalString(str) &&
+               JS_GetExternalStringFinalizer(str) == &sLiteralFinalizer;
+    }
+
+    static __attribute__((always_inline)) inline bool IsDOMString(JSString* str)
+    {
+        return JS_IsExternalString(str) &&
+               JS_GetExternalStringFinalizer(str) == &sDOMStringFinalizer;
+    }
+
+private:
+    static const JSStringFinalizer sLiteralFinalizer, sDOMStringFinalizer;
+
+    static void FinalizeLiteral(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
+
+    static void FinalizeDOMString(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
+
+    XPCStringConvert() = delete;
+};
+
+class nsIAddonInterposition;
+
+namespace xpc {
+
+
+bool Base64Encode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
+bool Base64Decode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
+
+
+
+
+
+
+bool NonVoidStringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval);
+inline bool StringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval)
+{
+
+    if (str.IsVoid()) {
+        rval.setNull();
+        return true;
+    }
+    return NonVoidStringToJsval(cx, str, rval);
+}
+
+inline bool
+NonVoidStringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
+{
+    nsString mutableCopy;
+    if (!mutableCopy.Assign(str, mozilla::fallible)) {
+        JS_ReportOutOfMemory(cx);
+        return false;
+    }
+    return NonVoidStringToJsval(cx, mutableCopy, rval);
+}
+
+inline bool
+StringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
+{
+    nsString mutableCopy;
+    if (!mutableCopy.Assign(str, mozilla::fallible)) {
+        JS_ReportOutOfMemory(cx);
+        return false;
+    }
+    return StringToJsval(cx, mutableCopy, rval);
+}
+
+
+
+
+inline
+bool NonVoidStringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
+                          JS::MutableHandleValue rval)
+{
+    if (!str.HasStringBuffer()) {
+
+        return NonVoidStringToJsval(cx, str.AsAString(), rval);
+    }
+
+    uint32_t length = str.StringBufferLength();
+    if (length == 0) {
+        rval.set(JS_GetEmptyStringValue(cx));
+        return true;
+    }
+
+    nsStringBuffer* buf = str.StringBuffer();
+    bool shared;
+    if (!XPCStringConvert::StringBufferToJSVal(cx, buf, length, rval,
+                                               &shared)) {
+        return false;
+    }
+    if (shared) {
+
+        str.RelinquishBufferOwnership();
+    }
+    return true;
+}
+
+__attribute__((always_inline)) inline
+bool StringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
+                   JS::MutableHandleValue rval)
+{
+    if (str.IsNull()) {
+        rval.setNull();
+        return true;
+    }
+    return NonVoidStringToJsval(cx, str, rval);
+}
+
+nsIPrincipal* GetCompartmentPrincipal(JSCompartment* compartment);
+
+void NukeAllWrappersForCompartment(JSContext* cx, JSCompartment* compartment,
+                                   js::NukeReferencesToWindow nukeReferencesToWindow = js::NukeWindowReferences);
+
+void SetLocationForGlobal(JSObject* global, const nsACString& location);
+void SetLocationForGlobal(JSObject* global, nsIURI* locationURI);
+
+void SetDocGroupValidation(JSObject* global);
+
+
+
+class ZoneStatsExtras {
+public:
+    ZoneStatsExtras() {}
+
+    nsCString pathPrefix;
+
+private:
+    ZoneStatsExtras(const ZoneStatsExtras& other) = delete;
+    ZoneStatsExtras& operator=(const ZoneStatsExtras& other) = delete;
+};
+
+
+
+class CompartmentStatsExtras {
+public:
+    CompartmentStatsExtras() {}
+
+    nsCString jsPathPrefix;
+    nsCString domPathPrefix;
+    nsCOMPtr<nsIURI> location;
+
+private:
+    CompartmentStatsExtras(const CompartmentStatsExtras& other) = delete;
+    CompartmentStatsExtras& operator=(const CompartmentStatsExtras& other) = delete;
+};
+
+
+
+
+
+void
+ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
+                                 const nsACString& rtPath,
+                                 nsIMemoryReporterCallback* handleReport,
+                                 nsISupports* data,
+                                 bool anonymize,
+                                 size_t* rtTotal = nullptr);
+
+
+
+
+bool
+Throw(JSContext* cx, nsresult rv);
+
+
+
+
+
+nsISupports*
+UnwrapReflectorToISupports(JSObject* reflector);
+# 480 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+JSObject*
+UnprivilegedJunkScope();
+
+JSObject*
+PrivilegedJunkScope();
+
+
+
+
+
+
+JSObject*
+CompilationScope();
+
+
+
+
+nsIGlobalObject*
+NativeGlobal(JSObject* aObj);
+
+
+
+
+
+nsGlobalWindow*
+WindowOrNull(JSObject* aObj);
+
+
+
+
+
+nsGlobalWindow*
+WindowGlobalOrNull(JSObject* aObj);
+
+
+
+
+
+
+nsGlobalWindow*
+AddonWindowOrNull(JSObject* aObj);
+
+
+
+
+
+nsGlobalWindow*
+CurrentWindowOrNull(JSContext* cx);
+
+void
+SimulateActivityCallback(bool aActive);
+
+
+
+bool
+ShouldDiscardSystemSource();
+
+bool
+SharedMemoryEnabled();
+
+bool
+SetAddonInterposition(const nsACString& addonId, nsIAddonInterposition* interposition);
+
+bool
+AllowCPOWsInAddon(const nsACString& addonId, bool allow);
+
+bool
+ExtraWarningsForSystemJS();
+
+class ErrorBase {
+  public:
+    nsString mErrorMsg;
+    nsString mFileName;
+    uint32_t mLineNumber;
+    uint32_t mColumn;
+
+    ErrorBase() : mLineNumber(0)
+                , mColumn(0)
+    {}
+
+    void Init(JSErrorBase* aReport);
+
+    void AppendErrorDetailsTo(nsCString& error);
+};
+
+class ErrorNote : public ErrorBase {
+  public:
+    void Init(JSErrorNotes::Note* aNote);
+
+
+
+
+    static void ErrorNoteToMessageString(JSErrorNotes::Note* aNote,
+                                         nsAString& aString);
+
+
+    void LogToStderr();
+};
+
+class ErrorReport : public ErrorBase {
+  public:
+    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ErrorReport>::value, "Reference-counted class " "ErrorReport" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
+
+    nsTArray<ErrorNote> mNotes;
+
+    nsCString mCategory;
+    nsString mSourceLine;
+    nsString mErrorMsgName;
+    uint64_t mWindowID;
+    uint32_t mFlags;
+    bool mIsMuted;
+
+    ErrorReport() : mWindowID(0)
+                  , mFlags(0)
+                  , mIsMuted(false)
+    {}
+
+    void Init(JSErrorReport* aReport, const char* aToStringResult,
+              bool aIsChrome, uint64_t aWindowID);
+    void Init(JSContext* aCx, mozilla::dom::Exception* aException,
+              bool aIsChrome, uint64_t aWindowID);
+
+
+
+    void LogToConsole();
+
+
+
+    void LogToConsoleWithStack(JS::HandleObject aStack);
+
+
+
+
+    static void ErrorReportToMessageString(JSErrorReport* aReport,
+                                           nsAString& aString);
+
+
+    void LogToStderr();
+
+  private:
+    ~ErrorReport() {}
+};
+
+void
+DispatchScriptErrorEvent(nsPIDOMWindowInner* win, JS::RootingContext* rootingCx,
+                         xpc::ErrorReport* xpcReport, JS::Handle<JS::Value> exception);
+# 638 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
+JSObject*
+FindExceptionStackForConsoleReport(nsPIDOMWindowInner* win,
+                                   JS::HandleValue exceptionValue);
+
+
+
+
+extern void
+GetCurrentCompartmentName(JSContext*, nsCString& name);
+
+void AddGCCallback(xpcGCCallback cb);
+void RemoveGCCallback(xpcGCCallback cb);
+
+inline bool
+AreNonLocalConnectionsDisabled()
+{
+    static int disabledForTest = -1;
+    if (disabledForTest == -1) {
+        char *s = getenv("MOZ_DISABLE_NONLOCAL_CONNECTIONS");
+        if (s) {
+            disabledForTest = *s != '0';
+        } else {
+            disabledForTest = 0;
+        }
+    }
+    return disabledForTest;
+}
+
+inline bool
+IsInAutomation()
+{
+    const char* prefName =
+      "security.turn_off_all_security_so_that_viruses_can_take_over_this_computer";
+    return mozilla::Preferences::GetBool(prefName) &&
+        AreNonLocalConnectionsDisabled();
+}
+
+}
+
+namespace mozilla {
+namespace dom {
+
+
+
+
+
+bool IsChromeOrXBL(JSContext* cx, JSObject* );
+
+
+
+
+bool ThreadSafeIsChromeOrXBL(JSContext* cx, JSObject* obj);
+
+}
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
+
+class nsICycleCollectorListener;
+class nsScriptNameSpaceManager;
+
+namespace JS {
+class AutoValueVector;
+}
+
+namespace mozilla {
+template <class> class Maybe;
+struct CycleCollectorResults;
+}
+
+
+
+
+
+
+
+class nsJSContext : public nsIScriptContext
+{
+public:
+  nsJSContext(bool aGCOnDestruction, nsIScriptGlobalObject* aGlobalObject);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsJSContext"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsJSContext>(p)->DeleteCycleCollectable(); } static nsJSContext* Downcast(nsISupports* s) { return static_cast<nsJSContext*>(static_cast<nsIScriptContext*>(s)); } static nsISupports* Upcast(nsJSContext *p) { return static_cast<nsISupports*>(static_cast<nsIScriptContext*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsJSContext::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  virtual nsIScriptGlobalObject *GetGlobalObject() override;
+  inline nsIScriptGlobalObject *GetGlobalObjectRef() { return mGlobalObjectRef; }
+
+  virtual nsresult InitContext() override;
+  virtual bool IsContextInitialized() override;
+
+  virtual nsresult SetProperty(JS::Handle<JSObject*> aTarget, const char* aPropName, nsISupports* aVal) override;
+
+  virtual bool GetProcessingScriptTag() override;
+  virtual void SetProcessingScriptTag(bool aResult) override;
+
+  virtual nsresult InitClasses(JS::Handle<JSObject*> aGlobalObj) override;
+
+  virtual void WillInitializeContext() override;
+  virtual void DidInitializeContext() override;
+
+  virtual void SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) override;
+  virtual JSObject* GetWindowProxy() override;
+
+  static void LoadStart();
+  static void LoadEnd();
+
+  enum IsShrinking {
+    ShrinkingGC,
+    NonShrinkingGC
+  };
+
+  enum IsIncremental {
+    IncrementalGC,
+    NonIncrementalGC
+  };
+
+
+  void EnsureStatics();
+
+  static void GarbageCollectNow(JS::gcreason::Reason reason,
+                                IsIncremental aIncremental = NonIncrementalGC,
+                                IsShrinking aShrinking = NonShrinkingGC,
+                                int64_t aSliceMillis = 0);
+
+
+
+  static void CycleCollectNow(nsICycleCollectorListener *aListener = nullptr,
+                              int32_t aExtraForgetSkippableCalls = 0);
+
+
+  static void RunCycleCollectorSlice();
+
+
+  static void RunCycleCollectorWorkSlice(int64_t aWorkBudget);
+
+  static void BeginCycleCollectionCallback();
+  static void EndCycleCollectionCallback(mozilla::CycleCollectorResults &aResults);
+
+
+  static uint32_t GetMaxCCSliceTimeSinceClear();
+  static void ClearMaxCCSliceTime();
+
+  static void RunNextCollectorTimer();
+
+
+  static void PokeGC(JS::gcreason::Reason aReason, JSObject* aObj, int aDelay = 0);
+  static void KillGCTimer();
+
+  static void PokeShrinkingGC();
+  static void KillShrinkingGCTimer();
+
+  static void MaybePokeCC();
+  static void KillCCTimer();
+  static void KillICCTimer();
+  static void KillFullGCTimer();
+  static void KillInterSliceGCTimer();
+
+
+  static void LikelyShortLivingObjectCreated();
+
+  static uint32_t CleanupsSinceLastGC();
+
+  nsIScriptGlobalObject* GetCachedGlobalObject()
+  {
+
+
+    JSObject* global = GetWindowProxy();
+    return global ? mGlobalObjectRef.get() : nullptr;
+  }
+
+  static void NotifyDidPaint();
+protected:
+  virtual ~nsJSContext();
+
+
+  nsresult ConvertSupportsTojsvals(nsISupports *aArgs,
+                                   JS::Handle<JSObject*> aScope,
+                                   JS::AutoValueVector &aArgsOut);
+
+  nsresult AddSupportsPrimitiveTojsvals(nsISupports *aArg, JS::Value *aArgv);
+
+private:
+  void Destroy();
+
+  JS::Heap<JSObject*> mWindowProxy;
+
+  bool mIsInitialized;
+  bool mGCOnDestruction;
+  bool mProcessingScriptTag;
+
+  PRTime mModalStateTime;
+  uint32_t mModalStateDepth;
+
+
+
+  nsCOMPtr<nsIScriptGlobalObject> mGlobalObjectRef;
+
+  static bool DOMOperationCallback(JSContext *cx);
+};
+
+namespace mozilla {
+namespace dom {
+
+void StartupJSEnvironment();
+void ShutdownJSEnvironment();
+
+
+nsScriptNameSpaceManager* GetNameSpaceManager();
+
+
+nsScriptNameSpaceManager* PeekNameSpaceManager();
+
+
+class AsyncErrorReporter final : public mozilla::Runnable
+{
+public:
+
+  explicit AsyncErrorReporter(xpc::ErrorReport* aReport)
+    : mReport(aReport)
+  {}
+
+  virtual nsresult Run() override
+  {
+    mReport->LogToConsole();
+    return NS_OK;
+  }
+
+protected:
+  RefPtr<xpc::ErrorReport> mReport;
+};
+
+}
+}
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h"
+class nsIJSArgArray : public nsIArray
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+  virtual nsresult GetArgs(uint32_t *argc, void **argv) = 0;
+};
+
+template<typename T> struct nsIJSArgArray::COMTypeInfo<nsIJSArgArray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIJSArgArray::COMTypeInfo<nsIJSArgArray, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xb6acdac8, 0xf5c6, 0x432c, { 0xa8, 0x6e, 0x33, 0xee, 0xb1, 0xb0, 0xcd, 0xdc } };
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
+
+
+
+
+namespace mozilla {
+namespace dom {
+
+
+
+
+
+class CallbackObject : public nsISupports
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "CallbackObject"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<CallbackObject>(p)->DeleteCycleCollectable(); } static CallbackObject* Downcast(nsISupports* s) { return static_cast<CallbackObject*>(static_cast<CallbackObject*>(s)); } static nsISupports* Upcast(CallbackObject *p) { return static_cast<nsISupports*>(static_cast<CallbackObject*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &CallbackObject::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+  explicit CallbackObject(JSContext* aCx, JS::Handle<JSObject*> aCallback,
+                          nsIGlobalObject* aIncumbentGlobal)
+  {
+    if (aCx && JS::ContextOptionsRef(aCx).asyncStack()) {
+      JS::RootedObject stack(aCx);
+      if (!JS::CaptureCurrentStack(aCx, &stack)) {
+        JS_ClearPendingException(aCx);
+      }
+      Init(aCallback, stack, aIncumbentGlobal);
+    } else {
+      Init(aCallback, nullptr, aIncumbentGlobal);
+    }
+  }
+
+
+
+
+  explicit CallbackObject(JS::Handle<JSObject*> aCallback,
+                          JS::Handle<JSObject*> aAsyncStack,
+                          nsIGlobalObject* aIncumbentGlobal)
+  {
+    Init(aCallback, aAsyncStack, aIncumbentGlobal);
+  }
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+  JS::Handle<JSObject*> CallbackOrNull() const
+  {
+    mCallback.exposeToActiveJS();
+    return CallbackPreserveColor();
+  }
+
+  JSObject* GetCreationStack() const
+  {
+    return mCreationStack;
+  }
+
+  void MarkForCC()
+  {
+    mCallback.exposeToActiveJS();
+    mCreationStack.exposeToActiveJS();
+  }
+# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+  JS::Handle<JSObject*> CallbackPreserveColor() const
+  {
+
+
+    return JS::Handle<JSObject*>::fromMarkedLocation(mCallback.address());
+  }
+
+
+
+
+
+
+  JS::Handle<JSObject*> CallbackKnownNotGray() const
+  {
+    do { } while (0);
+    return CallbackPreserveColor();
+  }
+
+  nsIGlobalObject* IncumbentGlobalOrNull() const
+  {
+    return mIncumbentGlobal;
+  }
+
+  enum ExceptionHandling {
+
+    eReportExceptions,
+
+
+
+    eRethrowContentExceptions,
+
+
+
+
+    eRethrowExceptions
+  };
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this);
+  }
+
+protected:
+  virtual ~CallbackObject()
+  {
+    DropJSObjects();
+  }
+
+  explicit CallbackObject(CallbackObject* aCallbackObject)
+  {
+    Init(aCallbackObject->mCallback, aCallbackObject->mCreationStack,
+         aCallbackObject->mIncumbentGlobal);
+  }
+
+  bool operator==(const CallbackObject& aOther) const
+  {
+    JSObject* wrappedThis = CallbackPreserveColor();
+    JSObject* wrappedOther = aOther.CallbackPreserveColor();
+    if (!wrappedThis || !wrappedOther) {
+      return this == &aOther;
+    }
+
+    JSObject* thisObj = js::UncheckedUnwrap(wrappedThis);
+    JSObject* otherObj = js::UncheckedUnwrap(wrappedOther);
+    return thisObj == otherObj;
+  }
+
+  class JSObjectsDropper final
+  {
+  public:
+    explicit JSObjectsDropper(CallbackObject* aHolder)
+      : mHolder(aHolder)
+    {}
+
+    ~JSObjectsDropper()
+    {
+      mHolder->DropJSObjects();
+    }
+
+  private:
+    RefPtr<CallbackObject> mHolder;
+  };
+
+private:
+  inline void InitNoHold(JSObject* aCallback, JSObject* aCreationStack,
+                         nsIGlobalObject* aIncumbentGlobal)
+  {
+    do { } while (0);
+
+
+    mCallback = aCallback;
+    mCreationStack = aCreationStack;
+    if (aIncumbentGlobal) {
+      mIncumbentGlobal = aIncumbentGlobal;
+      mIncumbentJSGlobal = aIncumbentGlobal->GetGlobalJSObject();
+    }
+  }
+
+  inline void Init(JSObject* aCallback, JSObject* aCreationStack,
+                   nsIGlobalObject* aIncumbentGlobal)
+  {
+    InitNoHold(aCallback, aCreationStack, aIncumbentGlobal);
+    mozilla::HoldJSObjects(this);
+  }
+
+  inline void ClearJSReferences()
+  {
+    mCallback = nullptr;
+    mCreationStack = nullptr;
+    mIncumbentJSGlobal = nullptr;
+  }
+
+  CallbackObject(const CallbackObject&) = delete;
+  CallbackObject& operator =(const CallbackObject&) = delete;
+
+protected:
+  void DropJSObjects()
+  {
+    do { } while (0);
+    if (mCallback) {
+      ClearJSReferences();
+      mozilla::DropJSObjects(this);
+    }
+  }
+
+
+  void Trace(JSTracer* aTracer);
+
+
+
+
+
+  void FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx);
+
+
+
+
+
+
+
+  struct FastCallbackConstructor {
+  };
+
+
+
+
+
+
+  CallbackObject(JS::Handle<JSObject*> aCallback,
+                 const FastCallbackConstructor&)
+  {
+    InitNoHold(aCallback, nullptr, nullptr);
+  }
+
+
+
+
+
+  JS::Heap<JSObject*> mCallback;
+  JS::Heap<JSObject*> mCreationStack;
+# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+  nsCOMPtr<nsIGlobalObject> mIncumbentGlobal;
+  JS::TenuredHeap<JSObject*> mIncumbentJSGlobal;
+
+  class CallSetup
+  {
+
+
+
+
+
+
+  public:
+
+
+
+
+
+
+
+    CallSetup(CallbackObject* aCallback, ErrorResult& aRv,
+              const char* aExecutionReason,
+              ExceptionHandling aExceptionHandling,
+              JSCompartment* aCompartment = nullptr,
+              bool aIsJSImplementedWebIDL = false);
+    ~CallSetup();
+
+    JSContext* GetContext() const
+    {
+      return mCx;
+    }
+
+  private:
+
+    CallSetup(const CallSetup&) = delete;
+
+    bool ShouldRethrowException(JS::Handle<JS::Value> aException);
+
+
+    JSContext* mCx;
+
+
+
+    JSCompartment* mCompartment;
+
+
+    Maybe<AutoEntryScript> mAutoEntryScript;
+    Maybe<AutoIncumbentScript> mAutoIncumbentScript;
+
+    Maybe<JS::Rooted<JSObject*> > mRootedCallable;
+
+
+    Maybe<JS::Rooted<JSObject*>> mAsyncStack;
+    Maybe<JS::AutoSetAsyncStackForNewCalls> mAsyncStackSetter;
+
+
+
+
+
+    Maybe<JSAutoCompartment> mAc;
+
+
+
+    ErrorResult& mErrorResult;
+    const ExceptionHandling mExceptionHandling;
+    const bool mIsMainThread;
+  };
+};
+
+template<class WebIDLCallbackT, class XPCOMCallbackT>
+class CallbackObjectHolder;
+
+template<class T, class U>
+void ImplCycleCollectionUnlink(CallbackObjectHolder<T, U>& aField);
+
+class CallbackObjectHolderBase
+{
+protected:
+
+  already_AddRefed<nsISupports> ToXPCOMCallback(CallbackObject* aCallback,
+                                                const nsIID& aIID) const;
+};
+
+template<class WebIDLCallbackT, class XPCOMCallbackT>
+class CallbackObjectHolder : CallbackObjectHolderBase
+{
+# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
+public:
+  explicit CallbackObjectHolder(WebIDLCallbackT* aCallback)
+    : mPtrBits(reinterpret_cast<uintptr_t>(aCallback))
+  {
+    ns_if_addref(aCallback);
+  }
+
+  explicit CallbackObjectHolder(XPCOMCallbackT* aCallback)
+    : mPtrBits(reinterpret_cast<uintptr_t>(aCallback) | XPCOMCallbackFlag)
+  {
+    ns_if_addref(aCallback);
+  }
+
+  CallbackObjectHolder(CallbackObjectHolder&& aOther)
+    : mPtrBits(aOther.mPtrBits)
+  {
+    aOther.mPtrBits = 0;
+    static_assert(sizeof(CallbackObjectHolder) == sizeof(void*),
+                  "This object is expected to be as small as a pointer, and it "
+                  "is currently passed by value in various places. If it is "
+                  "bloating, we may want to pass it by reference then.");
+  }
+
+  CallbackObjectHolder(const CallbackObjectHolder& aOther) = delete;
+
+  CallbackObjectHolder()
+    : mPtrBits(0)
+  {}
+
+  ~CallbackObjectHolder()
+  {
+    UnlinkSelf();
+  }
+
+  void operator=(WebIDLCallbackT* aCallback)
+  {
+    UnlinkSelf();
+    mPtrBits = reinterpret_cast<uintptr_t>(aCallback);
+    ns_if_addref(aCallback);
+  }
+
+  void operator=(XPCOMCallbackT* aCallback)
+  {
+    UnlinkSelf();
+    mPtrBits = reinterpret_cast<uintptr_t>(aCallback) | XPCOMCallbackFlag;
+    ns_if_addref(aCallback);
+  }
+
+  void operator=(CallbackObjectHolder&& aOther)
+  {
+    UnlinkSelf();
+    mPtrBits = aOther.mPtrBits;
+    aOther.mPtrBits = 0;
+  }
+
+  void operator=(const CallbackObjectHolder& aOther) = delete;
+
+  nsISupports* GetISupports() const
+  {
+    return reinterpret_cast<nsISupports*>(mPtrBits & ~XPCOMCallbackFlag);
+  }
+
+
+  explicit operator bool() const
+  {
+    return GetISupports();
+  }
+
+  CallbackObjectHolder Clone() const
+  {
+    CallbackObjectHolder result;
+    result.mPtrBits = mPtrBits;
+    ns_if_addref(GetISupports());
+    return result;
+  }
+
+
+
+  bool HasWebIDLCallback() const
+  {
+    return !(mPtrBits & XPCOMCallbackFlag);
+  }
+
+  WebIDLCallbackT* GetWebIDLCallback() const
+  {
+    do { } while (0);
+    return reinterpret_cast<WebIDLCallbackT*>(mPtrBits);
+  }
+
+  XPCOMCallbackT* GetXPCOMCallback() const
+  {
+    do { } while (0);
+    return reinterpret_cast<XPCOMCallbackT*>(mPtrBits & ~XPCOMCallbackFlag);
+  }
+
+  bool operator==(WebIDLCallbackT* aOtherCallback) const
+  {
+    if (!aOtherCallback) {
+
+      return !GetISupports();
+    }
+
+    if (!HasWebIDLCallback() || !GetWebIDLCallback()) {
+
+
+      return false;
+    }
+
+    return *GetWebIDLCallback() == *aOtherCallback;
+  }
+
+  bool operator==(XPCOMCallbackT* aOtherCallback) const
+  {
+    return (!aOtherCallback && !GetISupports()) ||
+      (!HasWebIDLCallback() && GetXPCOMCallback() == aOtherCallback);
+  }
+
+  bool operator==(const CallbackObjectHolder& aOtherCallback) const
+  {
+    if (aOtherCallback.HasWebIDLCallback()) {
+      return *this == aOtherCallback.GetWebIDLCallback();
+    }
+
+    return *this == aOtherCallback.GetXPCOMCallback();
+  }
+
+
+  already_AddRefed<XPCOMCallbackT> ToXPCOMCallback() const
+  {
+    if (!HasWebIDLCallback()) {
+      RefPtr<XPCOMCallbackT> callback = GetXPCOMCallback();
+      return callback.forget();
+    }
+
+    nsCOMPtr<nsISupports> supp =
+      CallbackObjectHolderBase::ToXPCOMCallback(GetWebIDLCallback(),
+                                                (XPCOMCallbackT::template COMTypeInfo<XPCOMCallbackT, void>::kIID));
+    if (supp) {
+
+      return supp.forget().downcast<XPCOMCallbackT>();
+    }
+    return nullptr;
+  }
+
+
+  already_AddRefed<WebIDLCallbackT> ToWebIDLCallback() const
+  {
+    if (HasWebIDLCallback()) {
+      RefPtr<WebIDLCallbackT> callback = GetWebIDLCallback();
+      return callback.forget();
+    }
+    return nullptr;
+  }
+
+private:
+  static const uintptr_t XPCOMCallbackFlag = 1u;
+
+  friend void
+  ImplCycleCollectionUnlink<WebIDLCallbackT,
+                            XPCOMCallbackT>(CallbackObjectHolder& aField);
+
+  void UnlinkSelf()
+  {
+
+    nsISupports* ptr = GetISupports();
+    do { if (ptr) { (ptr)->Release(); (ptr) = 0; } } while (0);
+    mPtrBits = 0;
+  }
+
+  uintptr_t mPtrBits;
+};
+
+template<typename T> struct CallbackObject::COMTypeInfo<CallbackObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID CallbackObject::COMTypeInfo<CallbackObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xbe74c190, 0x6d76, 0x4991, { 0x84, 0xb9, 0x65, 0x06, 0x99, 0xe6, 0x93, 0x2b } };
+
+template<class T, class U>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            CallbackObjectHolder<T, U>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  if (aField) {
+    CycleCollectionNoteChild(aCallback, aField.GetISupports(), aName, aFlags);
+  }
+}
+
+template<class T, class U>
+void
+ImplCycleCollectionUnlink(CallbackObjectHolder<T, U>& aField)
+{
+  aField.UnlinkSelf();
+}
+
+
+
+
+
+template<typename T>
+class RootedCallback : public JS::Rooted<T>
+{
+public:
+  explicit RootedCallback(JSContext* cx)
+    : JS::Rooted<T>(cx)
+    , mCx(cx)
+  {}
+
+
+
+  template<typename S>
+  void operator=(S* arg)
+  {
+    this->get().operator=(arg);
+  }
+
+
+
+  void operator=(decltype(nullptr) arg)
+  {
+    this->get().operator=(arg);
+  }
+
+
+  JS::Handle<JSObject*> CallbackOrNull() const
+  {
+    return this->get()->CallbackOrNull();
+  }
+
+  ~RootedCallback()
+  {
+
+
+
+
+    if (IsInitialized(this->get())) {
+      this->get()->FinishSlowJSInitIfMoreThanOneOwner(mCx);
+    }
+  }
+
+private:
+  template<typename U>
+  static bool IsInitialized(U& aArg);
+
+  template<typename U>
+  static bool IsInitialized(RefPtr<U>& aRefPtr)
+  {
+    return aRefPtr;
+  }
+
+  template<typename U>
+  static bool IsInitialized(OwningNonNull<U>& aOwningNonNull)
+  {
+    return aOwningNonNull.isInitialized();
+  }
+
+  JSContext* mCx;
+};
+
+}
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h" 2
+
+namespace mozilla {
+namespace dom {
+
+class CallbackFunction : public CallbackObject
+{
+public:
+
+  explicit CallbackFunction(JSContext* aCx, JS::Handle<JSObject*> aCallable,
+                            nsIGlobalObject* aIncumbentGlobal)
+    : CallbackObject(aCx, aCallable, aIncumbentGlobal)
+  {
+  }
+
+
+  explicit CallbackFunction(JS::Handle<JSObject*> aCallable,
+                            JS::Handle<JSObject*> aAsyncStack,
+                            nsIGlobalObject* aIncumbentGlobal)
+    : CallbackObject(aCallable, aAsyncStack, aIncumbentGlobal)
+  {
+  }
+
+  JS::Handle<JSObject*> CallableOrNull() const
+  {
+    return CallbackOrNull();
+  }
+
+  JS::Handle<JSObject*> CallablePreserveColor() const
+  {
+    return CallbackPreserveColor();
+  }
+
+  bool HasGrayCallable() const
+  {
+
+    return mCallback && JS::ObjectIsMarkedGray(mCallback);
+  }
+
+protected:
+  explicit CallbackFunction(CallbackFunction* aCallbackFunction)
+    : CallbackObject(aCallbackFunction)
+  {
+  }
+
+
+  CallbackFunction(JS::Handle<JSObject*> aCallable,
+                   const FastCallbackConstructor&)
+    : CallbackObject(aCallable, FastCallbackConstructor())
+  {
+  }
+};
+
+}
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h" 2
+
+
+
+
+
+
+struct JSContext;
+
+namespace js {
+
+
+extern bool
+ToBooleanSlow(JS::HandleValue v);
+
+
+extern bool
+ToNumberSlow(JSContext* cx, JS::HandleValue v, double* dp);
+
+
+extern bool
+ToInt8Slow(JSContext *cx, JS::HandleValue v, int8_t *out);
+
+
+extern bool
+ToUint8Slow(JSContext *cx, JS::HandleValue v, uint8_t *out);
+
+
+extern bool
+ToInt16Slow(JSContext *cx, JS::HandleValue v, int16_t *out);
+
+
+extern bool
+ToInt32Slow(JSContext* cx, JS::HandleValue v, int32_t* out);
+
+
+extern bool
+ToUint32Slow(JSContext* cx, JS::HandleValue v, uint32_t* out);
+
+
+extern bool
+ToUint16Slow(JSContext* cx, JS::HandleValue v, uint16_t* out);
+
+
+extern bool
+ToInt64Slow(JSContext* cx, JS::HandleValue v, int64_t* out);
+
+
+extern bool
+ToUint64Slow(JSContext* cx, JS::HandleValue v, uint64_t* out);
+
+
+extern JSString*
+ToStringSlow(JSContext* cx, JS::HandleValue v);
+
+
+extern JSObject*
+ToObjectSlow(JSContext* cx, JS::HandleValue v, bool reportScanStack);
+
+}
+
+namespace JS {
+
+namespace detail {
+
+
+
+
+
+
+
+extern void
+AssertArgumentsAreSane(JSContext* cx, HandleValue v);
+
+
+
+
+
+}
+# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
+extern bool
+OrdinaryToPrimitive(JSContext* cx, HandleObject obj, JSType type, MutableHandleValue vp);
+
+
+__attribute__((always_inline)) inline bool
+ToBoolean(HandleValue v)
+{
+    if (v.isBoolean())
+        return v.toBoolean();
+    if (v.isInt32())
+        return v.toInt32() != 0;
+    if (v.isNullOrUndefined())
+        return false;
+    if (v.isDouble()) {
+        double d = v.toDouble();
+        return !mozilla::IsNaN(d) && d != 0;
+    }
+    if (v.isSymbol())
+        return true;
+
+
+    return js::ToBooleanSlow(v);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToNumber(JSContext* cx, HandleValue v, double* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isNumber()) {
+        *out = v.toNumber();
+        return true;
+    }
+    return js::ToNumberSlow(cx, v, out);
+}
+
+
+inline double
+ToInteger(double d)
+{
+    if (d == 0)
+        return d;
+
+    if (!mozilla::IsFinite(d)) {
+        if (mozilla::IsNaN(d))
+            return 0;
+        return d;
+    }
+
+    return d < 0 ? ceil(d) : floor(d);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToInt32(JSContext* cx, JS::HandleValue v, int32_t* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = v.toInt32();
+        return true;
+    }
+    return js::ToInt32Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToUint32(JSContext* cx, HandleValue v, uint32_t* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = uint32_t(v.toInt32());
+        return true;
+    }
+    return js::ToUint32Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToInt16(JSContext *cx, JS::HandleValue v, int16_t *out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = int16_t(v.toInt32());
+        return true;
+    }
+    return js::ToInt16Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToUint16(JSContext* cx, HandleValue v, uint16_t* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = uint16_t(v.toInt32());
+        return true;
+    }
+    return js::ToUint16Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToInt8(JSContext *cx, JS::HandleValue v, int8_t *out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = int8_t(v.toInt32());
+        return true;
+    }
+    return js::ToInt8Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline bool
+ToUint8(JSContext *cx, JS::HandleValue v, uint8_t *out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = uint8_t(v.toInt32());
+        return true;
+    }
+    return js::ToUint8Slow(cx, v, out);
+}
+
+
+
+
+
+__attribute__((always_inline)) inline bool
+ToInt64(JSContext* cx, HandleValue v, int64_t* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = int64_t(v.toInt32());
+        return true;
+    }
+    return js::ToInt64Slow(cx, v, out);
+}
+
+
+
+
+
+__attribute__((always_inline)) inline bool
+ToUint64(JSContext* cx, HandleValue v, uint64_t* out)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isInt32()) {
+        *out = uint64_t(v.toInt32());
+        return true;
+    }
+    return js::ToUint64Slow(cx, v, out);
+}
+
+
+__attribute__((always_inline)) inline JSString*
+ToString(JSContext* cx, HandleValue v)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isString())
+        return v.toString();
+    return js::ToStringSlow(cx, v);
+}
+
+
+inline JSObject*
+ToObject(JSContext* cx, HandleValue v)
+{
+    detail::AssertArgumentsAreSane(cx, v);
+
+    if (v.isObject())
+        return &v.toObject();
+    return js::ToObjectSlow(cx, v, false);
+}
+
+namespace detail {
+# 304 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
+template<typename ResultType>
+inline ResultType
+ToUintWidth(double d)
+{
+    static_assert(mozilla::IsUnsigned<ResultType>::value,
+                  "ResultType must be an unsigned type");
+
+    uint64_t bits = mozilla::BitwiseCast<uint64_t>(d);
+    unsigned DoubleExponentShift = mozilla::FloatingPoint<double>::kExponentShift;
+
+
+
+    int_fast16_t exp =
+        int_fast16_t((bits & mozilla::FloatingPoint<double>::kExponentBits) >> DoubleExponentShift) -
+        int_fast16_t(mozilla::FloatingPoint<double>::kExponentBias);
+
+
+
+    if (exp < 0)
+        return 0;
+
+    uint_fast16_t exponent = mozilla::AssertedCast<uint_fast16_t>(exp);
+
+
+
+
+
+
+
+    const size_t ResultWidth = 8 * sizeof(ResultType);
+    if (exponent >= DoubleExponentShift + ResultWidth)
+        return 0;
+
+
+
+
+    static_assert(sizeof(ResultType) <= sizeof(uint64_t),
+                  "Left-shifting below would lose upper bits");
+    ResultType result = (exponent > DoubleExponentShift)
+                        ? ResultType(bits << (exponent - DoubleExponentShift))
+                        : ResultType(bits >> (DoubleExponentShift - exponent));
+# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
+    if (exponent < ResultWidth) {
+        ResultType implicitOne = ResultType(1) << exponent;
+        result &= implicitOne - 1;
+        result += implicitOne;
+    }
+
+
+    return (bits & mozilla::FloatingPoint<double>::kSignBit) ? ~result + 1 : result;
+}
+
+template<typename ResultType>
+inline ResultType
+ToIntWidth(double d)
+{
+    static_assert(mozilla::IsSigned<ResultType>::value,
+                  "ResultType must be a signed type");
+
+    const ResultType MaxValue = (1ULL << (8 * sizeof(ResultType) - 1)) - 1;
+    const ResultType MinValue = -MaxValue - 1;
+
+    typedef typename mozilla::MakeUnsigned<ResultType>::Type UnsignedResult;
+    UnsignedResult u = ToUintWidth<UnsignedResult>(d);
+    if (u <= UnsignedResult(MaxValue))
+        return static_cast<ResultType>(u);
+    return (MinValue + static_cast<ResultType>(u - MaxValue)) - 1;
+}
+
+}
+
+
+inline int32_t
+ToInt32(double d)
+{
+# 527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
+    return detail::ToIntWidth<int32_t>(d);
+
+}
+
+
+inline uint32_t
+ToUint32(double d)
+{
+    return detail::ToUintWidth<uint32_t>(d);
+}
+
+
+inline int8_t
+ToInt8(double d)
+{
+    return detail::ToIntWidth<int8_t>(d);
+}
+
+
+inline int8_t
+ToUint8(double d)
+{
+    return detail::ToUintWidth<uint8_t>(d);
+}
+
+
+inline int16_t
+ToInt16(double d)
+{
+    return detail::ToIntWidth<int16_t>(d);
+}
+
+inline uint16_t
+ToUint16(double d)
+{
+    return detail::ToUintWidth<uint16_t>(d);
+}
+
+
+inline int64_t
+ToInt64(double d)
+{
+    return detail::ToIntWidth<int64_t>(d);
+}
+
+
+inline uint64_t
+ToUint64(double d)
+{
+    return detail::ToUintWidth<uint64_t>(d);
+}
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<bool _TrivialValueTypes>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        {
+   _ForwardIterator __cur = __result;
+   try
+     {
+       for (; __first != __last; ++__first, (void)++__cur)
+  std::_Construct(std::__addressof(*__cur), *__first);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__result, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+# 105 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+
+
+
+
+      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
+      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
+      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
+
+
+      return std::__uninitialized_copy<__is_trivial(_ValueType1)
+           && __is_trivial(_ValueType2)
+           && __assignable>::
+ __uninit_copy(__first, __last, __result);
+    }
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+
+      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill(__first, __last, __x);
+    }
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        { return std::fill_n(__first, __n, __x); }
+    };
+# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill_n(__first, __n, __x);
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __first != __last; ++__first, (void)++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
+      std::make_move_iterator(__last),
+      __result, __alloc);
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_if_noexcept_a(_InputIterator __first,
+           _InputIterator __last,
+           _ForwardIterator __result,
+           _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a
+ (std::__make_move_if_noexcept_iterator(__first),
+  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { return std::uninitialized_fill_n(__first, __n, __x); }
+# 370 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_1
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+
+   std::fill(__first, __last, _ValueType());
+ }
+    };
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+
+   return std::fill_n(__first, __n, _ValueType());
+ }
+    };
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default(_ForwardIterator __first,
+       _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      std::__uninitialized_default_1<__is_trivial(_ValueType)
+         && __assignable>::
+ __uninit_default(__first, __last);
+    }
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_default_n_1<__is_trivial(_ValueType)
+           && __assignable>::
+ __uninit_default_n(__first, __n);
+    }
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         allocator<_Tp>&)
+    { std::__uninitialized_default(__first, __last); }
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Size, typename _Allocator>
+    _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    allocator<_Tp>&)
+    { return std::__uninitialized_default_n(__first, __n); }
+
+
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    _ForwardIterator
+    __uninitialized_copy_n(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline _ForwardIterator
+    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    { return std::uninitialized_copy(__first, __first + __n, __result); }
+# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy_n(_InputIterator __first, _Size __n,
+    _ForwardIterator __result)
+    { return std::__uninitialized_copy_n(__first, __n, __result,
+      std::__iterator_category(__first)); }
+
+
+
+}
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 1 3
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  constexpr inline size_t
+  __deque_buf_size(size_t __size)
+  { return (__size < 512
+     ? size_t(512 / __size) : size_t(1)); }
+# 105 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator
+    {
+
+
+
+
+
+
+    private:
+      template<typename _Up>
+ using __ptr_to = typename pointer_traits<_Ptr>::template rebind<_Up>;
+      template<typename _CvTp>
+ using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
+    public:
+      typedef __iter<_Tp> iterator;
+      typedef __iter<const _Tp> const_iterator;
+      typedef __ptr_to<_Tp> _Elt_pointer;
+      typedef __ptr_to<_Elt_pointer> _Map_pointer;
+
+
+      static size_t _S_buffer_size() noexcept
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+      typedef std::random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Ptr pointer;
+      typedef _Ref reference;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Deque_iterator _Self;
+
+      _Elt_pointer _M_cur;
+      _Elt_pointer _M_first;
+      _Elt_pointer _M_last;
+      _Map_pointer _M_node;
+
+      _Deque_iterator(_Elt_pointer __x, _Map_pointer __y) noexcept
+      : _M_cur(__x), _M_first(*__y),
+        _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
+
+      _Deque_iterator() noexcept
+      : _M_cur(), _M_first(), _M_last(), _M_node() { }
+
+      _Deque_iterator(const iterator& __x) noexcept
+      : _M_cur(__x._M_cur), _M_first(__x._M_first),
+        _M_last(__x._M_last), _M_node(__x._M_node) { }
+
+      iterator
+      _M_const_cast() const noexcept
+      { return iterator(_M_cur, _M_node); }
+
+      reference
+      operator*() const noexcept
+      { return *_M_cur; }
+
+      pointer
+      operator->() const noexcept
+      { return _M_cur; }
+
+      _Self&
+      operator++() noexcept
+      {
+ ++_M_cur;
+ if (_M_cur == _M_last)
+   {
+     _M_set_node(_M_node + 1);
+     _M_cur = _M_first;
+   }
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ ++*this;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ if (_M_cur == _M_first)
+   {
+     _M_set_node(_M_node - 1);
+     _M_cur = _M_last;
+   }
+ --_M_cur;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ --*this;
+ return __tmp;
+      }
+
+      _Self&
+      operator+=(difference_type __n) noexcept
+      {
+ const difference_type __offset = __n + (_M_cur - _M_first);
+ if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
+   _M_cur += __n;
+ else
+   {
+     const difference_type __node_offset =
+       __offset > 0 ? __offset / difference_type(_S_buffer_size())
+                    : -difference_type((-__offset - 1)
+           / _S_buffer_size()) - 1;
+     _M_set_node(_M_node + __node_offset);
+     _M_cur = _M_first + (__offset - __node_offset
+     * difference_type(_S_buffer_size()));
+   }
+ return *this;
+      }
+
+      _Self
+      operator+(difference_type __n) const noexcept
+      {
+ _Self __tmp = *this;
+ return __tmp += __n;
+      }
+
+      _Self&
+      operator-=(difference_type __n) noexcept
+      { return *this += -__n; }
+
+      _Self
+      operator-(difference_type __n) const noexcept
+      {
+ _Self __tmp = *this;
+ return __tmp -= __n;
+      }
+
+      reference
+      operator[](difference_type __n) const noexcept
+      { return *(*this + __n); }
+
+
+
+
+
+
+      void
+      _M_set_node(_Map_pointer __new_node) noexcept
+      {
+ _M_node = __new_node;
+ _M_first = *__new_node;
+ _M_last = _M_first + difference_type(_S_buffer_size());
+      }
+    };
+
+
+
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+                                          : (__x._M_node < __y._M_node); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+                                   : (__x._M_node < __y._M_node); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return __y < __x; }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return __y < __x; }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return !(__y < __x); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return !(__y < __x); }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    { return !(__x < __y); }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    { return !(__x < __y); }
+
+
+
+
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+    operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
+    {
+      return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+ (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
+ * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ + (__y._M_last - __y._M_cur);
+    }
+
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+    operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+    {
+      return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+ (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
+ * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ + (__y._M_last - __y._M_cur);
+    }
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline _Deque_iterator<_Tp, _Ref, _Ptr>
+    operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
+    noexcept
+    { return __x + __n; }
+
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
+  const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
+         _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
+         __result); }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy_backward(_Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__first),
+    _Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__last),
+    __result); }
+
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
+         _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
+         __result); }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::move_backward(_Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__first),
+    _Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__last),
+    __result); }
+# 457 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    class _Deque_base
+    {
+    protected:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
+
+
+
+
+
+      typedef typename _Alloc_traits::pointer _Ptr;
+      typedef typename _Alloc_traits::const_pointer _Ptr_const;
+
+
+      typedef typename _Alloc_traits::template rebind<_Ptr>::other
+ _Map_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits;
+
+    public:
+      typedef _Alloc allocator_type;
+      typedef typename _Alloc_traits::size_type size_type;
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
+
+      _Deque_base()
+      : _M_impl()
+      { _M_initialize_map(0); }
+
+      _Deque_base(size_t __num_elements)
+      : _M_impl()
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a, size_t __num_elements)
+      : _M_impl(__a)
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { }
+
+
+      _Deque_base(_Deque_base&& __x, false_type)
+      : _M_impl(__x._M_move_impl())
+      { }
+
+      _Deque_base(_Deque_base&& __x, true_type)
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      {
+ _M_initialize_map(0);
+ if (__x._M_impl._M_map)
+   this->_M_impl._M_swap_data(__x._M_impl);
+      }
+
+      _Deque_base(_Deque_base&& __x)
+      : _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
+      { }
+
+      _Deque_base(_Deque_base&& __x, const allocator_type& __a, size_type __n)
+      : _M_impl(__a)
+      {
+ if (__x.get_allocator() == __a)
+   {
+     if (__x._M_impl._M_map)
+       {
+  _M_initialize_map(0);
+  this->_M_impl._M_swap_data(__x._M_impl);
+       }
+   }
+ else
+   {
+     _M_initialize_map(__n);
+   }
+      }
+
+
+      ~_Deque_base() noexcept;
+
+    protected:
+      typedef typename iterator::_Map_pointer _Map_pointer;
+
+
+
+
+      struct _Deque_impl
+      : public _Tp_alloc_type
+      {
+ _Map_pointer _M_map;
+ size_t _M_map_size;
+ iterator _M_start;
+ iterator _M_finish;
+
+ _Deque_impl()
+ : _Tp_alloc_type(), _M_map(), _M_map_size(0),
+   _M_start(), _M_finish()
+ { }
+
+ _Deque_impl(const _Tp_alloc_type& __a) noexcept
+ : _Tp_alloc_type(__a), _M_map(), _M_map_size(0),
+   _M_start(), _M_finish()
+ { }
+
+
+ _Deque_impl(_Deque_impl&&) = default;
+
+ _Deque_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
+   _M_start(), _M_finish()
+ { }
+
+
+ void _M_swap_data(_Deque_impl& __x) noexcept
+ {
+   using std::swap;
+   swap(this->_M_start, __x._M_start);
+   swap(this->_M_finish, __x._M_finish);
+   swap(this->_M_map, __x._M_map);
+   swap(this->_M_map_size, __x._M_map_size);
+ }
+      };
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+
+      _Map_alloc_type
+      _M_get_map_allocator() const noexcept
+      { return _Map_alloc_type(_M_get_Tp_allocator()); }
+
+      _Ptr
+      _M_allocate_node()
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
+ return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
+      }
+
+      void
+      _M_deallocate_node(_Ptr __p) noexcept
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
+ _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
+      }
+
+      _Map_pointer
+      _M_allocate_map(size_t __n)
+      {
+ _Map_alloc_type __map_alloc = _M_get_map_allocator();
+ return _Map_alloc_traits::allocate(__map_alloc, __n);
+      }
+
+      void
+      _M_deallocate_map(_Map_pointer __p, size_t __n) noexcept
+      {
+ _Map_alloc_type __map_alloc = _M_get_map_allocator();
+ _Map_alloc_traits::deallocate(__map_alloc, __p, __n);
+      }
+
+    protected:
+      void _M_initialize_map(size_t);
+      void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish);
+      void _M_destroy_nodes(_Map_pointer __nstart,
+       _Map_pointer __nfinish) noexcept;
+      enum { _S_initial_map_size = 8 };
+
+      _Deque_impl _M_impl;
+
+
+    private:
+      _Deque_impl
+      _M_move_impl()
+      {
+ if (!_M_impl._M_map)
+   return std::move(_M_impl);
+
+
+ _Tp_alloc_type __alloc{_M_get_Tp_allocator()};
+
+ _Tp_alloc_type __sink __attribute((__unused__)) {std::move(__alloc)};
+
+ _Deque_base __empty{__alloc};
+ __empty._M_initialize_map(0);
+
+ _Deque_impl __ret{std::move(_M_get_Tp_allocator())};
+ _M_impl._M_swap_data(__ret);
+ _M_impl._M_swap_data(__empty._M_impl);
+ return __ret;
+      }
+
+    };
+
+  template<typename _Tp, typename _Alloc>
+    _Deque_base<_Tp, _Alloc>::
+    ~_Deque_base() noexcept
+    {
+      if (this->_M_impl._M_map)
+ {
+   _M_destroy_nodes(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+ }
+    }
+# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_initialize_map(size_t __num_elements)
+    {
+      const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
+      + 1);
+
+      this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
+        size_t(__num_nodes + 2));
+      this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
+
+
+
+
+
+
+      _Map_pointer __nstart = (this->_M_impl._M_map
+          + (this->_M_impl._M_map_size - __num_nodes) / 2);
+      _Map_pointer __nfinish = __nstart + __num_nodes;
+
+      try
+ { _M_create_nodes(__nstart, __nfinish); }
+      catch(...)
+ {
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+   this->_M_impl._M_map = _Map_pointer();
+   this->_M_impl._M_map_size = 0;
+   throw;
+ }
+
+      this->_M_impl._M_start._M_set_node(__nstart);
+      this->_M_impl._M_finish._M_set_node(__nfinish - 1);
+      this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
+      this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
+     + __num_elements
+     % __deque_buf_size(sizeof(_Tp)));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish)
+    {
+      _Map_pointer __cur;
+      try
+ {
+   for (__cur = __nstart; __cur < __nfinish; ++__cur)
+     *__cur = this->_M_allocate_node();
+ }
+      catch(...)
+ {
+   _M_destroy_nodes(__nstart, __cur);
+   throw;
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_destroy_nodes(_Map_pointer __nstart,
+       _Map_pointer __nfinish) noexcept
+    {
+      for (_Map_pointer __n = __nstart; __n < __nfinish; ++__n)
+ _M_deallocate_node(*__n);
+    }
+# 828 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class deque : protected _Deque_base<_Tp, _Alloc>
+    {
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+
+
+
+
+
+      typedef _Deque_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef typename _Base::_Alloc_traits _Alloc_traits;
+      typedef typename _Base::_Map_pointer _Map_pointer;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    protected:
+      static size_t _S_buffer_size() noexcept
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+
+      using _Base::_M_initialize_map;
+      using _Base::_M_create_nodes;
+      using _Base::_M_destroy_nodes;
+      using _Base::_M_allocate_node;
+      using _Base::_M_deallocate_node;
+      using _Base::_M_allocate_map;
+      using _Base::_M_deallocate_map;
+      using _Base::_M_get_Tp_allocator;
+
+
+
+
+
+      using _Base::_M_impl;
+
+    public:
+
+
+
+
+
+
+      deque() : _Base() { }
+
+
+
+
+
+      explicit
+      deque(const allocator_type& __a)
+      : _Base(__a, 0) { }
+# 903 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      explicit
+      deque(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__a, __n)
+      { _M_default_initialize(); }
+# 916 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque(size_type __n, const value_type& __value,
+     const allocator_type& __a = allocator_type())
+      : _Base(__a, __n)
+      { _M_fill_initialize(__value); }
+# 943 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque(const deque& __x)
+      : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()),
+       __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
+        this->_M_impl._M_start,
+        _M_get_Tp_allocator()); }
+# 958 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque(deque&& __x)
+      : _Base(std::move(__x)) { }
+
+
+      deque(const deque& __x, const allocator_type& __a)
+      : _Base(__a, __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
+        this->_M_impl._M_start,
+        _M_get_Tp_allocator()); }
+
+
+      deque(deque&& __x, const allocator_type& __a)
+      : _Base(std::move(__x), __a, __x.size())
+      {
+ if (__x.get_allocator() != __a)
+   {
+     std::__uninitialized_move_a(__x.begin(), __x.end(),
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+     __x.clear();
+   }
+      }
+# 992 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque(initializer_list<value_type> __l,
+     const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+# 1017 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        deque(_InputIterator __first, _InputIterator __last,
+       const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 1040 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      ~deque()
+      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
+# 1050 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque&
+      operator=(const deque& __x);
+# 1062 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque&
+      operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
+      {
+ using __always_equal = typename _Alloc_traits::is_always_equal;
+ _M_move_assign1(std::move(__x), __always_equal{});
+ return *this;
+      }
+# 1081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      deque&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 1099 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 1116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+# 1143 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      { this->assign(__l.begin(), __l.end()); }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _Base::get_allocator(); }
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return this->_M_impl._M_start; }
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return this->_M_impl._M_start; }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return this->_M_impl._M_finish; }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return this->_M_impl._M_finish; }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return this->_M_impl._M_start; }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return this->_M_impl._M_finish; }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+      size_type
+      size() const noexcept
+      { return this->_M_impl._M_finish - this->_M_impl._M_start; }
+
+
+      size_type
+      max_size() const noexcept
+      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
+# 1282 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      resize(size_type __new_size)
+      {
+ const size_type __len = size();
+ if (__new_size > __len)
+   _M_default_append(__new_size - __len);
+ else if (__new_size < __len)
+   _M_erase_at_end(this->_M_impl._M_start
+     + difference_type(__new_size));
+      }
+# 1304 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+ const size_type __len = size();
+ if (__new_size > __len)
+   insert(this->_M_impl._M_finish, __new_size - __len, __x);
+ else if (__new_size < __len)
+   _M_erase_at_end(this->_M_impl._M_start
+     + difference_type(__new_size));
+      }
+# 1340 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      shrink_to_fit() noexcept
+      { _M_shrink_to_fit(); }
+
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
+# 1365 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+# 1380 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      const_reference
+      operator[](size_type __n) const noexcept
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+
+    protected:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)"),
+
+
+       __n, this->size());
+      }
+
+    public:
+# 1408 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 1426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+
+
+
+
+
+      reference
+      front() noexcept
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+# 1483 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      push_front(const value_type& __x)
+      {
+ if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_start._M_cur - 1,
+                              __x);
+     --this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_push_front_aux(__x);
+      }
+
+
+      void
+      push_front(value_type&& __x)
+      { emplace_front(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_front(_Args&&... __args);
+# 1516 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_last - 1)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_finish._M_cur, __x);
+     ++this->_M_impl._M_finish._M_cur;
+   }
+ else
+   _M_push_back_aux(__x);
+      }
+
+
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args);
+# 1548 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      pop_front() noexcept
+      {
+ if (this->_M_impl._M_start._M_cur
+     != this->_M_impl._M_start._M_last - 1)
+   {
+     _Alloc_traits::destroy(this->_M_impl,
+                            this->_M_impl._M_start._M_cur);
+     ++this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_pop_front_aux();
+      }
+# 1570 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      pop_back() noexcept
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_first)
+   {
+     --this->_M_impl._M_finish._M_cur;
+     _Alloc_traits::destroy(this->_M_impl,
+                            this->_M_impl._M_finish._M_cur);
+   }
+ else
+   _M_pop_back_aux();
+      }
+# 1594 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+# 1607 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1633 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1646 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1662 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(__position._M_const_cast(), __n, __x);
+ return begin() + __offset;
+      }
+# 1696 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(__position._M_const_cast(),
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+# 1742 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+
+      erase(const_iterator __position)
+
+
+
+      { return _M_erase(__position._M_const_cast()); }
+# 1766 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+
+
+
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+# 1783 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      swap(deque& __x) noexcept
+      {
+ _M_impl._M_swap_data(__x._M_impl);
+ _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
+      __x._M_get_Tp_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_erase_at_end(begin()); }
+
+    protected:
+
+
+
+
+
+
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        {
+   _M_initialize_map(static_cast<size_type>(__n));
+   _M_fill_initialize(__x);
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+# 1839 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag);
+# 1861 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      _M_fill_initialize(const value_type& __value);
+
+
+
+      void
+      _M_default_initialize();
+# 1877 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_assign_aux(__first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag)
+        {
+   const size_type __len = std::distance(__first, __last);
+   if (__len > size())
+     {
+       _ForwardIterator __mid = __first;
+       std::advance(__mid, size());
+       std::copy(__first, __mid, begin());
+       insert(end(), __mid, __last);
+     }
+   else
+     _M_erase_at_end(std::copy(__first, __last, begin()));
+ }
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val)
+      {
+ if (__n > size())
+   {
+     std::fill(begin(), end(), __val);
+     insert(end(), __n - size(), __val);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + difference_type(__n));
+     std::fill(begin(), end(), __val);
+   }
+      }
+# 1941 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename... _Args>
+        void _M_push_back_aux(_Args&&... __args);
+
+      template<typename... _Args>
+        void _M_push_front_aux(_Args&&... __args);
+
+
+      void _M_pop_back_aux();
+
+      void _M_pop_front_aux();
+# 1960 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos,
+      _Integer __n, _Integer __x, __true_type)
+        { _M_fill_insert(__pos, __n, __x); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos,
+      _InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+          _M_range_insert_aux(__pos, __first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag);
+
+
+
+
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+
+
+
+
+
+      template<typename... _Args>
+        iterator
+        _M_insert_aux(iterator __pos, _Args&&... __args);
+
+
+
+      void
+      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_insert_aux(iterator __pos,
+        _ForwardIterator __first, _ForwardIterator __last,
+        size_type __n);
+
+
+
+
+      void
+      _M_destroy_data_aux(iterator __first, iterator __last);
+
+
+
+      template<typename _Alloc1>
+        void
+        _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
+        { _M_destroy_data_aux(__first, __last); }
+
+      void
+      _M_destroy_data(iterator __first, iterator __last,
+        const std::allocator<_Tp>&)
+      {
+ if (!__has_trivial_destructor(value_type))
+   _M_destroy_data_aux(__first, __last);
+      }
+
+
+      void
+      _M_erase_at_begin(iterator __pos)
+      {
+ _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
+ _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
+ this->_M_impl._M_start = __pos;
+      }
+
+
+
+      void
+      _M_erase_at_end(iterator __pos)
+      {
+ _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
+ _M_destroy_nodes(__pos._M_node + 1,
+    this->_M_impl._M_finish._M_node + 1);
+ this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __pos);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+
+
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+
+
+
+
+      iterator
+      _M_reserve_elements_at_front(size_type __n)
+      {
+ const size_type __vacancies = this->_M_impl._M_start._M_cur
+                               - this->_M_impl._M_start._M_first;
+ if (__n > __vacancies)
+   _M_new_elements_at_front(__n - __vacancies);
+ return this->_M_impl._M_start - difference_type(__n);
+      }
+
+      iterator
+      _M_reserve_elements_at_back(size_type __n)
+      {
+ const size_type __vacancies = (this->_M_impl._M_finish._M_last
+           - this->_M_impl._M_finish._M_cur) - 1;
+ if (__n > __vacancies)
+   _M_new_elements_at_back(__n - __vacancies);
+ return this->_M_impl._M_finish + difference_type(__n);
+      }
+
+      void
+      _M_new_elements_at_front(size_type __new_elements);
+
+      void
+      _M_new_elements_at_back(size_type __new_elements);
+# 2111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+      void
+      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add + 1 > this->_M_impl._M_map_size
+     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, false);
+      }
+
+      void
+      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
+           - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, true);
+      }
+
+      void
+      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+
+
+
+
+
+      void
+      _M_move_assign1(deque&& __x, true_type) noexcept
+      {
+ this->_M_impl._M_swap_data(__x._M_impl);
+ __x.clear();
+ std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+
+
+
+
+      void
+      _M_move_assign1(deque&& __x, false_type)
+      {
+ constexpr bool __move_storage =
+   _Alloc_traits::_S_propagate_on_move_assign();
+ _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
+      }
+
+
+
+      template<typename... _Args>
+      void
+      _M_replace_map(_Args&&... __args)
+      {
+
+ deque __newobj(std::forward<_Args>(__args)...);
+
+ clear();
+ _M_deallocate_node(*begin()._M_node);
+ _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+ this->_M_impl._M_map = nullptr;
+ this->_M_impl._M_map_size = 0;
+
+ this->_M_impl._M_swap_data(__newobj._M_impl);
+      }
+
+
+      void
+      _M_move_assign2(deque&& __x, true_type)
+      {
+
+ auto __alloc = __x._M_get_Tp_allocator();
+
+
+ _M_replace_map(std::move(__x));
+
+ _M_get_Tp_allocator() = std::move(__alloc);
+      }
+
+
+
+      void
+      _M_move_assign2(deque&& __x, false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   {
+
+
+     _M_replace_map(std::move(__x), __x.get_allocator());
+   }
+ else
+   {
+
+
+     this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
+    std::__make_move_if_noexcept_iterator(__x.end()));
+     __x.clear();
+   }
+      }
+
+    };
+# 2218 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __x,
+                         const deque<_Tp, _Alloc>& __y)
+    { return __x.size() == __y.size()
+             && std::equal(__x.begin(), __x.end(), __y.begin()); }
+# 2236 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __x,
+       const deque<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __x,
+       const deque<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+}
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/deque.tcc" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/deque.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_initialize()
+    {
+      _Map_pointer __cur;
+      try
+        {
+          for (__cur = this->_M_impl._M_start._M_node;
+        __cur < this->_M_impl._M_finish._M_node;
+        ++__cur)
+            std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
+        _M_get_Tp_allocator());
+          std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
+      this->_M_impl._M_finish._M_cur,
+      _M_get_Tp_allocator());
+        }
+      catch(...)
+        {
+          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+   _M_get_Tp_allocator());
+          throw;
+        }
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    deque<_Tp, _Alloc>&
+    deque<_Tp, _Alloc>::
+    operator=(const deque& __x)
+    {
+      if (&__x != this)
+ {
+
+   if (_Alloc_traits::_S_propagate_on_copy_assign())
+     {
+       if (!_Alloc_traits::_S_always_equal()
+           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+         {
+
+
+    _M_replace_map(__x, __x.get_allocator());
+    std::__alloc_on_copy(_M_get_Tp_allocator(),
+           __x._M_get_Tp_allocator());
+    return *this;
+  }
+       std::__alloc_on_copy(_M_get_Tp_allocator(),
+       __x._M_get_Tp_allocator());
+     }
+
+   const size_type __len = size();
+   if (__len >= __x.size())
+     _M_erase_at_end(std::copy(__x.begin(), __x.end(),
+          this->_M_impl._M_start));
+   else
+     {
+       const_iterator __mid = __x.begin() + difference_type(__len);
+       std::copy(__x.begin(), __mid, this->_M_impl._M_start);
+       insert(this->_M_impl._M_finish, __mid, __x.end());
+     }
+ }
+      return *this;
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      emplace_front(_Args&&... __args)
+      {
+ if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_start._M_cur - 1,
+                std::forward<_Args>(__args)...);
+     --this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_push_front_aux(std::forward<_Args>(__args)...);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_last - 1)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_finish._M_cur,
+                std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish._M_cur;
+   }
+ else
+   _M_push_back_aux(std::forward<_Args>(__args)...);
+      }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+ if (__position._M_cur == this->_M_impl._M_start._M_cur)
+   {
+     emplace_front(std::forward<_Args>(__args)...);
+     return this->_M_impl._M_start;
+   }
+ else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+   {
+     emplace_back(std::forward<_Args>(__args)...);
+     iterator __tmp = this->_M_impl._M_finish;
+     --__tmp;
+     return __tmp;
+   }
+ else
+   return _M_insert_aux(__position._M_const_cast(),
+          std::forward<_Args>(__args)...);
+      }
+
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      if (__position._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   push_front(__x);
+   return this->_M_impl._M_start;
+ }
+      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   push_back(__x);
+   iterator __tmp = this->_M_impl._M_finish;
+   --__tmp;
+   return __tmp;
+ }
+      else
+ return _M_insert_aux(__position._M_const_cast(), __x);
+   }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      iterator __next = __position;
+      ++__next;
+      const difference_type __index = __position - begin();
+      if (static_cast<size_type>(__index) < (size() >> 1))
+ {
+   if (__position != begin())
+     std::move_backward(begin(), __position, __next);
+   pop_front();
+ }
+      else
+ {
+   if (__next != end())
+     std::move(__next, end(), __position);
+   pop_back();
+ }
+      return begin() + __index;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first == __last)
+ return __first;
+      else if (__first == begin() && __last == end())
+ {
+   clear();
+   return end();
+ }
+      else
+ {
+   const difference_type __n = __last - __first;
+   const difference_type __elems_before = __first - begin();
+   if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
+     {
+       if (__first != begin())
+  std::move_backward(begin(), __first, __last);
+       _M_erase_at_begin(begin() + __n);
+     }
+   else
+     {
+       if (__last != end())
+  std::move(__last, end(), __first);
+       _M_erase_at_end(end() - __n);
+     }
+   return begin() + __elems_before;
+ }
+    }
+
+  template <typename _Tp, class _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+        iterator __cur = begin();
+        for (; __first != __last && __cur != end(); ++__cur, ++__first)
+          *__cur = *__first;
+        if (__first == __last)
+          _M_erase_at_end(__cur);
+        else
+          insert(end(), __first, __last);
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
+    {
+      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   try
+     {
+       std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
+       __x, _M_get_Tp_allocator());
+       this->_M_impl._M_start = __new_start;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   try
+     {
+       std::__uninitialized_fill_a(this->_M_impl._M_finish,
+       __new_finish, __x,
+       _M_get_Tp_allocator());
+       this->_M_impl._M_finish = __new_finish;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+      else
+        _M_insert_aux(__pos, __n, __x);
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n)
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   try
+     {
+       std::__uninitialized_default_a(this->_M_impl._M_finish,
+          __new_finish,
+          _M_get_Tp_allocator());
+       this->_M_impl._M_finish = __new_finish;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    bool
+    deque<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      const difference_type __front_capacity
+ = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
+      if (__front_capacity == 0)
+ return false;
+
+      const difference_type __back_capacity
+ = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
+      if (__front_capacity + __back_capacity < _S_buffer_size())
+ return false;
+
+      return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_initialize(const value_type& __value)
+    {
+      _Map_pointer __cur;
+      try
+        {
+          for (__cur = this->_M_impl._M_start._M_node;
+        __cur < this->_M_impl._M_finish._M_node;
+        ++__cur)
+            std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
+     __value, _M_get_Tp_allocator());
+          std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
+          this->_M_impl._M_finish._M_cur,
+          __value, _M_get_Tp_allocator());
+        }
+      catch(...)
+        {
+          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+   _M_get_Tp_allocator());
+          throw;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      {
+        this->_M_initialize_map(0);
+        try
+          {
+            for (; __first != __last; ++__first)
+
+       emplace_back(*__first);
+
+
+
+          }
+        catch(...)
+          {
+            clear();
+            throw;
+          }
+      }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        this->_M_initialize_map(__n);
+
+        _Map_pointer __cur_node;
+        try
+          {
+            for (__cur_node = this->_M_impl._M_start._M_node;
+                 __cur_node < this->_M_impl._M_finish._M_node;
+                 ++__cur_node)
+       {
+  _ForwardIterator __mid = __first;
+  std::advance(__mid, _S_buffer_size());
+  std::__uninitialized_copy_a(__first, __mid, *__cur_node,
+         _M_get_Tp_allocator());
+  __first = __mid;
+       }
+            std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_finish._M_first,
+     _M_get_Tp_allocator());
+          }
+        catch(...)
+          {
+            std::_Destroy(this->_M_impl._M_start,
+     iterator(*__cur_node, __cur_node),
+     _M_get_Tp_allocator());
+            throw;
+          }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_back_aux(_Args&&... __args)
+
+
+
+
+
+      {
+ _M_reserve_map_at_back();
+ *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
+ try
+   {
+
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_finish._M_cur,
+                std::forward<_Args>(__args)...);
+
+
+
+     this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+      + 1);
+     this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
+   }
+ catch(...)
+   {
+     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
+     throw;
+   }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_front_aux(_Args&&... __args)
+
+
+
+
+
+      {
+ _M_reserve_map_at_front();
+ *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
+ try
+   {
+     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
+            - 1);
+     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
+
+     _Alloc_traits::construct(this->_M_impl,
+                              this->_M_impl._M_start._M_cur,
+                std::forward<_Args>(__args)...);
+
+
+
+   }
+ catch(...)
+   {
+     ++this->_M_impl._M_start;
+     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
+     throw;
+   }
+      }
+
+
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_back_aux()
+    {
+      _M_deallocate_node(this->_M_impl._M_finish._M_first);
+      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
+      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
+      _Alloc_traits::destroy(_M_get_Tp_allocator(),
+        this->_M_impl._M_finish._M_cur);
+    }
+
+
+
+
+
+
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_front_aux()
+    {
+      _Alloc_traits::destroy(_M_get_Tp_allocator(),
+        this->_M_impl._M_start._M_cur);
+      _M_deallocate_node(this->_M_impl._M_start._M_first);
+      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
+      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      { std::copy(__first, __last, std::inserter(*this, __pos)); }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last, __new_start,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_start = __new_start;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+        else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+   {
+     iterator __new_finish = _M_reserve_elements_at_back(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last,
+         this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_finish = __new_finish;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+     __new_finish._M_node + 1);
+  throw;
+       }
+   }
+        else
+          _M_insert_aux(__pos, __first, __last, __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos, _Args&&... __args)
+      {
+ value_type __x_copy(std::forward<_Args>(__args)...);
+
+
+
+
+
+
+
+ difference_type __index = __pos - this->_M_impl._M_start;
+ if (static_cast<size_type>(__index) < size() / 2)
+   {
+     push_front(std::move(front()));
+     iterator __front1 = this->_M_impl._M_start;
+     ++__front1;
+     iterator __front2 = __front1;
+     ++__front2;
+     __pos = this->_M_impl._M_start + __index;
+     iterator __pos1 = __pos;
+     ++__pos1;
+     std::move(__front2, __pos1, __front1);
+   }
+ else
+   {
+     push_back(std::move(back()));
+     iterator __back1 = this->_M_impl._M_finish;
+     --__back1;
+     iterator __back2 = __back1;
+     --__back2;
+     __pos = this->_M_impl._M_start + __index;
+     std::move_backward(__pos, __back2, __back1);
+   }
+ *__pos = std::move(__x_copy);
+ return __pos;
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
+    {
+      const difference_type __elems_before = __pos - this->_M_impl._M_start;
+      const size_type __length = this->size();
+      value_type __x_copy = __x;
+      if (__elems_before < difference_type(__length / 2))
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   iterator __old_start = this->_M_impl._M_start;
+   __pos = this->_M_impl._M_start + __elems_before;
+   try
+     {
+       if (__elems_before >= difference_type(__n))
+  {
+    iterator __start_n = (this->_M_impl._M_start
+     + difference_type(__n));
+    std::__uninitialized_move_a(this->_M_impl._M_start,
+           __start_n, __new_start,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::move(__start_n, __pos, __old_start);
+    std::fill(__pos - difference_type(__n), __pos, __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_move_fill(this->_M_impl._M_start,
+       __pos, __new_start,
+       this->_M_impl._M_start,
+       __x_copy,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::fill(__old_start, __pos, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   iterator __old_finish = this->_M_impl._M_finish;
+   const difference_type __elems_after =
+     difference_type(__length) - __elems_before;
+   __pos = this->_M_impl._M_finish - __elems_after;
+   try
+     {
+       if (__elems_after > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::move_backward(__pos, __finish_n, __old_finish);
+    std::fill(__pos, __pos + difference_type(__n), __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_fill_move(this->_M_impl._M_finish,
+       __pos + difference_type(__n),
+       __x_copy, __pos,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::fill(__pos, __old_finish, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos,
+                    _ForwardIterator __first, _ForwardIterator __last,
+                    size_type __n)
+      {
+        const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
+        const size_type __length = size();
+        if (static_cast<size_type>(__elemsbefore) < __length / 2)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     iterator __old_start = this->_M_impl._M_start;
+     __pos = this->_M_impl._M_start + __elemsbefore;
+     try
+       {
+  if (__elemsbefore >= difference_type(__n))
+    {
+      iterator __start_n = (this->_M_impl._M_start
+       + difference_type(__n));
+      std::__uninitialized_move_a(this->_M_impl._M_start,
+      __start_n, __new_start,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::move(__start_n, __pos, __old_start);
+      std::copy(__first, __last, __pos - difference_type(__n));
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, difference_type(__n) - __elemsbefore);
+      std::__uninitialized_move_copy(this->_M_impl._M_start,
+         __pos, __first, __mid,
+         __new_start,
+         _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::copy(__mid, __last, __old_start);
+    }
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+        else
+        {
+          iterator __new_finish = _M_reserve_elements_at_back(__n);
+          iterator __old_finish = this->_M_impl._M_finish;
+          const difference_type __elemsafter =
+            difference_type(__length) - __elemsbefore;
+          __pos = this->_M_impl._M_finish - __elemsafter;
+          try
+            {
+              if (__elemsafter > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::move_backward(__pos, __finish_n, __old_finish);
+    std::copy(__first, __last, __pos);
+  }
+              else
+  {
+    _ForwardIterator __mid = __first;
+    std::advance(__mid, __elemsafter);
+    std::__uninitialized_copy_move(__mid, __last, __pos,
+       this->_M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::copy(__first, __mid, __pos);
+  }
+            }
+          catch(...)
+            {
+              _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+              throw;
+            }
+        }
+      }
+
+   template<typename _Tp, typename _Alloc>
+     void
+     deque<_Tp, _Alloc>::
+     _M_destroy_data_aux(iterator __first, iterator __last)
+     {
+       for (_Map_pointer __node = __first._M_node + 1;
+     __node < __last._M_node; ++__node)
+  std::_Destroy(*__node, *__node + _S_buffer_size(),
+         _M_get_Tp_allocator());
+
+       if (__first._M_node != __last._M_node)
+  {
+    std::_Destroy(__first._M_cur, __first._M_last,
+    _M_get_Tp_allocator());
+    std::_Destroy(__last._M_first, __last._M_cur,
+    _M_get_Tp_allocator());
+  }
+       else
+  std::_Destroy(__first._M_cur, __last._M_cur,
+         _M_get_Tp_allocator());
+     }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_front(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_front"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_front(__new_nodes);
+      size_type __i;
+      try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
+        }
+      catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
+          throw;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_back(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_back"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_back(__new_nodes);
+      size_type __i;
+      try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
+        }
+      catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
+          throw;
+        }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
+    {
+      const size_type __old_num_nodes
+ = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
+      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+      _Map_pointer __new_nstart;
+      if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
+ {
+   __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
+      - __new_num_nodes) / 2
+                  + (__add_at_front ? __nodes_to_add : 0);
+   if (__new_nstart < this->_M_impl._M_start._M_node)
+     std::copy(this->_M_impl._M_start._M_node,
+        this->_M_impl._M_finish._M_node + 1,
+        __new_nstart);
+   else
+     std::copy_backward(this->_M_impl._M_start._M_node,
+          this->_M_impl._M_finish._M_node + 1,
+          __new_nstart + __old_num_nodes);
+ }
+      else
+ {
+   size_type __new_map_size = this->_M_impl._M_map_size
+                              + std::max(this->_M_impl._M_map_size,
+      __nodes_to_add) + 2;
+
+   _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
+   __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+                  + (__add_at_front ? __nodes_to_add : 0);
+   std::copy(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1,
+      __new_nstart);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+
+   this->_M_impl._M_map = __new_map;
+   this->_M_impl._M_map_size = __new_map_size;
+ }
+
+      this->_M_impl._M_start._M_set_node(__new_nstart);
+      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+    }
+
+
+
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
+  const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+
+      for (typename _Self::_Map_pointer __node = __first._M_node + 1;
+           __node < __last._M_node; ++__node)
+ std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
+
+      if (__first._M_node != __last._M_node)
+ {
+   std::fill(__first._M_cur, __first._M_last, __value);
+   std::fill(__last._M_first, __last._M_cur, __value);
+ }
+      else
+ std::fill(__first._M_cur, __last._M_cur, __value);
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   const difference_type __clen
+     = std::min(__len, std::min(__first._M_last - __first._M_cur,
+           __result._M_last - __result._M_cur));
+   std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
+   __first += __clen;
+   __result += __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   difference_type __llen = __last._M_cur - __last._M_first;
+   _Tp* __lend = __last._M_cur;
+
+   difference_type __rlen = __result._M_cur - __result._M_first;
+   _Tp* __rend = __result._M_cur;
+
+   if (!__llen)
+     {
+       __llen = _Self::_S_buffer_size();
+       __lend = *(__last._M_node - 1) + __llen;
+     }
+   if (!__rlen)
+     {
+       __rlen = _Self::_S_buffer_size();
+       __rend = *(__result._M_node - 1) + __rlen;
+     }
+
+   const difference_type __clen = std::min(__len,
+        std::min(__llen, __rlen));
+   std::copy_backward(__lend - __clen, __lend, __rend);
+   __last -= __clen;
+   __result -= __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   const difference_type __clen
+     = std::min(__len, std::min(__first._M_last - __first._M_cur,
+           __result._M_last - __result._M_cur));
+   std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
+   __first += __clen;
+   __result += __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   difference_type __llen = __last._M_cur - __last._M_first;
+   _Tp* __lend = __last._M_cur;
+
+   difference_type __rlen = __result._M_cur - __result._M_first;
+   _Tp* __rend = __result._M_cur;
+
+   if (!__llen)
+     {
+       __llen = _Self::_S_buffer_size();
+       __lend = *(__last._M_node - 1) + __llen;
+     }
+   if (!__rlen)
+     {
+       __rlen = _Self::_S_buffer_size();
+       __rend = *(__result._M_node - 1) + __rlen;
+     }
+
+   const difference_type __clen = std::min(__len,
+        std::min(__llen, __rlen));
+   std::move_backward(__lend - __clen, __lend, __rend);
+   __last -= __clen;
+   __result -= __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+
+
+
+}
+# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
+# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 3
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 1 3
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Tp>::other _Tp_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
+        pointer;
+
+      struct _Vector_impl
+      : public _Tp_alloc_type
+      {
+ pointer _M_start;
+ pointer _M_finish;
+ pointer _M_end_of_storage;
+
+ _Vector_impl()
+ : _Tp_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+ _Vector_impl(_Tp_alloc_type const& __a) noexcept
+ : _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Vector_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a)),
+   _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ void _M_swap_data(_Vector_impl& __x) noexcept
+ {
+   std::swap(_M_start, __x._M_start);
+   std::swap(_M_finish, __x._M_finish);
+   std::swap(_M_end_of_storage, __x._M_end_of_storage);
+ }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      _Vector_base()
+      : _M_impl() { }
+
+      _Vector_base(const allocator_type& __a) noexcept
+      : _M_impl(__a) { }
+
+      _Vector_base(size_t __n)
+      : _M_impl()
+      { _M_create_storage(__n); }
+
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_create_storage(__n); }
+
+
+      _Vector_base(_Tp_alloc_type&& __a) noexcept
+      : _M_impl(std::move(__a)) { }
+
+      _Vector_base(_Vector_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      { this->_M_impl._M_swap_data(__x._M_impl); }
+
+      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_impl._M_swap_data(__x._M_impl);
+ else
+   {
+     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
+     _M_create_storage(__n);
+   }
+      }
+
+
+      ~_Vector_base() noexcept
+      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
+        - this->_M_impl._M_start); }
+
+    public:
+      _Vector_impl _M_impl;
+
+      pointer
+      _M_allocate(size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
+      }
+
+      void
+      _M_deallocate(pointer __p, size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ if (__p)
+   _Tr::deallocate(_M_impl, __p, __n);
+      }
+
+    private:
+      void
+      _M_create_storage(size_t __n)
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+    };
+# 213 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+
+
+
+
+
+      typedef _Vector_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Base::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+
+    public:
+
+
+
+
+
+
+      vector()
+
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+
+      : _Base() { }
+
+
+
+
+
+      explicit
+      vector(const allocator_type& __a) noexcept
+      : _Base(__a) { }
+# 278 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_default_initialize(__n); }
+# 291 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector(size_type __n, const value_type& __value,
+      const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+# 320 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector(const vector& __x)
+      : _Base(__x.size(),
+        _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
+      { this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+# 337 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector(vector&& __x) noexcept
+      : _Base(std::move(__x)) { }
+
+
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__x.size(), __a)
+      { this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+
+
+      vector(vector&& __rv, const allocator_type& __m)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _Base(std::move(__rv), __m)
+      {
+ if (__rv.get_allocator() != __m)
+   {
+     this->_M_impl._M_finish =
+       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+       this->_M_impl._M_start,
+       _M_get_Tp_allocator());
+     __rv.clear();
+   }
+      }
+# 375 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector(initializer_list<value_type> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+# 401 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      ~vector() noexcept
+      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator()); }
+# 437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector&
+      operator=(const vector& __x);
+# 449 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+        constexpr bool __move_storage =
+          _Alloc_traits::_S_propagate_on_move_assign()
+          || _Alloc_traits::_S_always_equal();
+        _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+# 470 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 488 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 505 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+# 533 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      { this->assign(__l.begin(), __l.end()); }
+
+
+
+      using _Base::get_allocator;
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+
+
+      size_type
+      size() const noexcept
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
+# 673 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size)
+      {
+ if (__new_size > size())
+   _M_default_append(__new_size - size());
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 693 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+ if (__new_size > size())
+   insert(end(), __new_size - size(), __x);
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 725 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return begin() == end(); }
+# 764 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      reserve(size_type __n);
+# 779 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      { return *(this->_M_impl._M_start + __n); }
+# 794 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      const_reference
+      operator[](size_type __n) const noexcept
+      { return *(this->_M_impl._M_start + __n); }
+
+    protected:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+
+
+       __n, this->size());
+      }
+
+    public:
+# 822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 840 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+
+
+
+
+
+      reference
+      front() noexcept
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back() noexcept
+      { return *(end() - 1); }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      { return *(end() - 1); }
+# 887 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      _Tp*
+
+
+
+      data() noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+
+
+      const _Tp*
+
+
+
+      data() const noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+# 913 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+                              __x);
+     ++this->_M_impl._M_finish;
+   }
+ else
+
+   _M_emplace_back_aux(__x);
+
+
+
+      }
+
+
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace_back(_Args&&... __args);
+# 949 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      pop_back() noexcept
+      {
+ --this->_M_impl._M_finish;
+ _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      }
+# 969 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+# 984 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1014 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1031 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      { return this->insert(__position, __l.begin(), __l.end()); }
+# 1051 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(begin() + __offset, __n, __x);
+ return begin() + __offset;
+      }
+# 1093 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(begin() + __offset,
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+# 1145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __position)
+      { return _M_erase(begin() + (__position - cbegin())); }
+# 1172 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+      {
+ const auto __beg = begin();
+ const auto __cbeg = cbegin();
+ return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
+      }
+# 1194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      void
+      swap(vector& __x) noexcept
+      {
+ this->_M_impl._M_swap_data(__x._M_impl);
+ _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
+                           __x._M_get_Tp_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_erase_at_end(this->_M_impl._M_start); }
+
+    protected:
+
+
+
+
+      template<typename _ForwardIterator>
+        pointer
+        _M_allocate_and_copy(size_type __n,
+        _ForwardIterator __first, _ForwardIterator __last)
+        {
+   pointer __result = this->_M_allocate(__n);
+   try
+     {
+       std::__uninitialized_copy_a(__first, __last, __result,
+       _M_get_Tp_allocator());
+       return __result;
+     }
+   catch(...)
+     {
+       _M_deallocate(__result, __n);
+       throw;
+     }
+ }
+# 1243 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
+        {
+   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
+   this->_M_impl._M_end_of_storage =
+     this->_M_impl._M_start + static_cast<size_type>(__n);
+   _M_fill_initialize(static_cast<size_type>(__n), __value);
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag)
+        {
+   for (; __first != __last; ++__first)
+
+     emplace_back(*__first);
+
+
+
+ }
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag)
+        {
+   const size_type __n = std::distance(__first, __last);
+   this->_M_impl._M_start = this->_M_allocate(__n);
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+   this->_M_impl._M_finish =
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+ }
+
+
+
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+     _M_get_Tp_allocator());
+      }
+
+
+
+      void
+      _M_default_initialize(size_type __n)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
+        _M_get_Tp_allocator());
+      }
+# 1321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_assign_aux(__first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+# 1361 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+      __true_type)
+        { _M_fill_insert(__pos, __n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos, _InputIterator __first,
+      _InputIterator __last, __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_insert(__pos, __first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_range_insert(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert(iterator __pos, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+
+
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+
+
+
+
+
+
+
+      template<typename... _Args>
+        void
+        _M_insert_aux(iterator __position, _Args&&... __args);
+
+      template<typename... _Args>
+        void
+        _M_emplace_back_aux(_Args&&... __args);
+
+
+
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+
+
+
+
+
+      void
+      _M_erase_at_end(pointer __pos) noexcept
+      {
+ std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __position);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+
+    private:
+
+
+
+      void
+      _M_move_assign(vector&& __x, std::true_type) noexcept
+      {
+ vector __tmp(get_allocator());
+ this->_M_impl._M_swap_data(__tmp._M_impl);
+ this->_M_impl._M_swap_data(__x._M_impl);
+ std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+
+
+
+      void
+      _M_move_assign(vector&& __x, std::false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   _M_move_assign(std::move(__x), std::true_type());
+ else
+   {
+
+
+     this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
+    std::__make_move_if_noexcept_iterator(__x.end()));
+     __x.clear();
+   }
+      }
+
+
+
+      template<typename _Up>
+ _Up*
+ _M_data_ptr(_Up* __ptr) const
+ { return __ptr; }
+
+      template<typename _Ptr>
+ typename std::pointer_traits<_Ptr>::element_type*
+ _M_data_ptr(_Ptr __ptr) const
+ { return empty() ? nullptr : std::__addressof(*__ptr); }
+
+
+
+
+
+
+    };
+# 1507 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+# 1524 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+}
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
+
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+
+    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
+
+    operator bool() const noexcept
+    { return !!(*_M_p & _M_mask); }
+
+    _Bit_reference&
+    operator=(bool __x) noexcept
+    {
+      if (__x)
+ *_M_p |= _M_mask;
+      else
+ *_M_p &= ~_M_mask;
+      return *this;
+    }
+
+    _Bit_reference&
+    operator=(const _Bit_reference& __x) noexcept
+    { return *this = bool(__x); }
+
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+
+    void
+    flip() noexcept
+    { *_M_p ^= _M_mask; }
+  };
+
+
+  inline void
+  swap(_Bit_reference __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(_Bit_reference __x, bool& __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(bool& __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+ {
+   _M_offset = 0;
+   ++_M_p;
+ }
+    }
+
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+ {
+   _M_offset = int(_S_word_bit) - 1;
+   --_M_p;
+ }
+    }
+
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+ {
+   __n += int(_S_word_bit);
+   --_M_p;
+ }
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+
+    bool
+    operator==(const _Bit_iterator_base& __i) const
+    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
+
+    bool
+    operator<(const _Bit_iterator_base& __i) const
+    {
+      return _M_p < __i._M_p
+      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
+    }
+
+    bool
+    operator!=(const _Bit_iterator_base& __i) const
+    { return !(*this == __i); }
+
+    bool
+    operator>(const _Bit_iterator_base& __i) const
+    { return __i < *this; }
+
+    bool
+    operator<=(const _Bit_iterator_base& __i) const
+    { return !(__i < *this); }
+
+    bool
+    operator>=(const _Bit_iterator_base& __i) const
+    { return !(*this < __i); }
+  };
+
+  inline ptrdiff_t
+  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+  {
+    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+     + __x._M_offset - __y._M_offset);
+  }
+
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference reference;
+    typedef _Bit_reference* pointer;
+    typedef _Bit_iterator iterator;
+
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    iterator
+    _M_const_cast() const
+    { return *this; }
+
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    iterator
+    operator+(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    iterator
+    operator-(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_iterator
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
+
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool reference;
+    typedef bool const_reference;
+    typedef const bool* pointer;
+    typedef _Bit_const_iterator const_iterator;
+
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+
+    _Bit_iterator
+    _M_const_cast() const
+    { return _Bit_iterator(_M_p, _M_offset); }
+
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    const_iterator
+    operator+(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    const_iterator
+    operator-(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_const_iterator
+  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
+  { return __x + __n; }
+
+  inline void
+  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
+  {
+    for (; __first != __last; ++__first)
+      *__first = __x;
+  }
+
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
+ __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
+ __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
+      }
+    else
+      __fill_bvector(__first, __last, __x);
+  }
+
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Bit_type>::other _Bit_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
+ _Bit_alloc_traits;
+      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
+
+      struct _Bvector_impl
+      : public _Bit_alloc_type
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_pointer _M_end_of_storage;
+
+ _Bvector_impl()
+ : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+ _Bvector_impl(const _Bit_alloc_type& __a)
+ : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Bvector_impl(_Bit_alloc_type&& __a)
+ : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
+   _M_end_of_storage()
+ { }
+
+
+ _Bit_type*
+ _M_end_addr() const noexcept
+ {
+   if (_M_end_of_storage)
+     return std::__addressof(_M_end_of_storage[-1]) + 1;
+   return 0;
+ }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Bit_alloc_type&
+      _M_get_Bit_allocator() noexcept
+      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
+
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const noexcept
+      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Bit_allocator()); }
+
+      _Bvector_base()
+      : _M_impl() { }
+
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+
+
+      _Bvector_base(_Bvector_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Bit_allocator()))
+      {
+ this->_M_impl._M_start = __x._M_impl._M_start;
+ this->_M_impl._M_finish = __x._M_impl._M_finish;
+ this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
+ __x._M_impl._M_start = _Bit_iterator();
+ __x._M_impl._M_finish = _Bit_iterator();
+ __x._M_impl._M_end_of_storage = nullptr;
+      }
+
+
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+
+    protected:
+      _Bvector_impl _M_impl;
+
+      _Bit_pointer
+      _M_allocate(size_t __n)
+      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
+
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   {
+     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
+     _Bit_alloc_traits::deallocate(_M_impl,
+       _M_impl._M_end_of_storage - __n,
+       __n);
+   }
+      }
+
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+
+}
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 540 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+template<typename _Alloc>
+  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+  {
+    typedef _Bvector_base<_Alloc> _Base;
+    typedef typename _Base::_Bit_pointer _Bit_pointer;
+    typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
+
+
+    template<typename> friend struct hash;
+
+
+  public:
+    typedef bool value_type;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Bit_reference reference;
+    typedef bool const_reference;
+    typedef _Bit_reference* pointer;
+    typedef const bool* const_pointer;
+    typedef _Bit_iterator iterator;
+    typedef _Bit_const_iterator const_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef _Alloc allocator_type;
+
+    allocator_type get_allocator() const
+    { return _Base::get_allocator(); }
+
+  protected:
+    using _Base::_M_allocate;
+    using _Base::_M_deallocate;
+    using _Base::_S_nword;
+    using _Base::_M_get_Bit_allocator;
+
+  public:
+    vector()
+
+      noexcept(is_nothrow_default_constructible<allocator_type>::value)
+
+    : _Base() { }
+
+    explicit
+    vector(const allocator_type& __a)
+    : _Base(__a) { }
+
+
+    explicit
+    vector(size_type __n, const allocator_type& __a = allocator_type())
+    : vector(__n, false, __a)
+    { }
+
+    vector(size_type __n, const bool& __value,
+    const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize(__n);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
+  __value ? ~0 : 0);
+    }
+# 611 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+    vector(const vector& __x)
+    : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+
+
+    vector(vector&& __x) noexcept
+    : _Base(std::move(__x)) { }
+
+    vector(vector&& __x, const allocator_type& __a)
+    noexcept(_Bit_alloc_traits::_S_always_equal())
+    : _Base(__a)
+    {
+      if (__x.get_allocator() == __a)
+ {
+   this->_M_impl._M_start = __x._M_impl._M_start;
+   this->_M_impl._M_finish = __x._M_impl._M_finish;
+   this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
+   __x._M_impl._M_start = _Bit_iterator();
+   __x._M_impl._M_finish = _Bit_iterator();
+   __x._M_impl._M_end_of_storage = nullptr;
+ }
+      else
+ {
+   _M_initialize(__x.size());
+   _M_copy_aligned(__x.begin(), __x.end(), begin());
+   __x.clear();
+ }
+    }
+
+    vector(const vector& __x, const allocator_type& __a)
+    : _Base(__a)
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+
+    vector(initializer_list<bool> __l,
+    const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize_range(__l.begin(), __l.end(),
+     random_access_iterator_tag());
+    }
+
+
+
+    template<typename _InputIterator,
+      typename = std::_RequireInputIter<_InputIterator>>
+      vector(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+    ~vector() noexcept { }
+
+    vector&
+    operator=(const vector& __x)
+    {
+      if (&__x == this)
+ return *this;
+
+      if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
+ {
+   if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
+     {
+       this->_M_deallocate();
+       std::__alloc_on_copy(_M_get_Bit_allocator(),
+       __x._M_get_Bit_allocator());
+       _M_initialize(__x.size());
+     }
+   else
+     std::__alloc_on_copy(_M_get_Bit_allocator(),
+     __x._M_get_Bit_allocator());
+ }
+
+      if (__x.size() > capacity())
+ {
+   this->_M_deallocate();
+   _M_initialize(__x.size());
+ }
+      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+      begin());
+      return *this;
+    }
+
+
+    vector&
+    operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
+    {
+      if (_Bit_alloc_traits::_S_propagate_on_move_assign()
+   || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
+ {
+   this->_M_deallocate();
+   this->_M_impl._M_start = __x._M_impl._M_start;
+   this->_M_impl._M_finish = __x._M_impl._M_finish;
+   this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
+   __x._M_impl._M_start = _Bit_iterator();
+   __x._M_impl._M_finish = _Bit_iterator();
+   __x._M_impl._M_end_of_storage = nullptr;
+   std::__alloc_on_move(_M_get_Bit_allocator(),
+          __x._M_get_Bit_allocator());
+ }
+      else
+ {
+   if (__x.size() > capacity())
+     {
+       this->_M_deallocate();
+       _M_initialize(__x.size());
+     }
+   this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+          begin());
+   __x.clear();
+ }
+      return *this;
+    }
+
+    vector&
+    operator=(initializer_list<bool> __l)
+    {
+      this->assign (__l.begin(), __l.end());
+      return *this;
+    }
+
+
+
+
+
+
+    void
+    assign(size_type __n, const bool& __x)
+    { _M_fill_assign(__n, __x); }
+
+
+    template<typename _InputIterator,
+      typename = std::_RequireInputIter<_InputIterator>>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      { _M_assign_dispatch(__first, __last, __false_type()); }
+# 773 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+    void
+    assign(initializer_list<bool> __l)
+    { this->assign(__l.begin(), __l.end()); }
+
+
+    iterator
+    begin() noexcept
+    { return this->_M_impl._M_start; }
+
+    const_iterator
+    begin() const noexcept
+    { return this->_M_impl._M_start; }
+
+    iterator
+    end() noexcept
+    { return this->_M_impl._M_finish; }
+
+    const_iterator
+    end() const noexcept
+    { return this->_M_impl._M_finish; }
+
+    reverse_iterator
+    rbegin() noexcept
+    { return reverse_iterator(end()); }
+
+    const_reverse_iterator
+    rbegin() const noexcept
+    { return const_reverse_iterator(end()); }
+
+    reverse_iterator
+    rend() noexcept
+    { return reverse_iterator(begin()); }
+
+    const_reverse_iterator
+    rend() const noexcept
+    { return const_reverse_iterator(begin()); }
+
+
+    const_iterator
+    cbegin() const noexcept
+    { return this->_M_impl._M_start; }
+
+    const_iterator
+    cend() const noexcept
+    { return this->_M_impl._M_finish; }
+
+    const_reverse_iterator
+    crbegin() const noexcept
+    { return const_reverse_iterator(end()); }
+
+    const_reverse_iterator
+    crend() const noexcept
+    { return const_reverse_iterator(begin()); }
+
+
+    size_type
+    size() const noexcept
+    { return size_type(end() - begin()); }
+
+    size_type
+    max_size() const noexcept
+    {
+      const size_type __isize =
+ __gnu_cxx::__numeric_traits<difference_type>::__max
+ - int(_S_word_bit) + 1;
+      const size_type __asize
+ = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
+      return (__asize <= __isize / int(_S_word_bit)
+       ? __asize * int(_S_word_bit) : __isize);
+    }
+
+    size_type
+    capacity() const noexcept
+    { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
+         - begin()); }
+
+    bool
+    empty() const noexcept
+    { return begin() == end(); }
+
+    reference
+    operator[](size_type __n)
+    {
+      return *iterator(this->_M_impl._M_start._M_p
+         + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+    const_reference
+    operator[](size_type __n) const
+    {
+      return *const_iterator(this->_M_impl._M_start._M_p
+        + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+  protected:
+    void
+    _M_range_check(size_type __n) const
+    {
+      if (__n >= this->size())
+ __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+
+
+     __n, this->size());
+    }
+
+  public:
+    reference
+    at(size_type __n)
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    const_reference
+    at(size_type __n) const
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    void
+    reserve(size_type __n)
+    {
+      if (__n > max_size())
+ __throw_length_error(("vector::reserve"));
+      if (capacity() < __n)
+ _M_reallocate(__n);
+    }
+
+    reference
+    front()
+    { return *begin(); }
+
+    const_reference
+    front() const
+    { return *begin(); }
+
+    reference
+    back()
+    { return *(end() - 1); }
+
+    const_reference
+    back() const
+    { return *(end() - 1); }
+
+
+
+
+
+
+    void
+    data() noexcept { }
+
+    void
+    push_back(bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(end(), __x);
+    }
+
+    void
+    swap(vector& __x) noexcept
+    {
+      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+      std::swap(this->_M_impl._M_end_of_storage,
+  __x._M_impl._M_end_of_storage);
+      _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
+        __x._M_get_Bit_allocator());
+    }
+
+
+    static void
+    swap(reference __x, reference __y) noexcept
+    {
+      bool __tmp = __x;
+      __x = __y;
+      __y = __tmp;
+    }
+
+    iterator
+
+    insert(const_iterator __position, const bool& __x = bool())
+
+
+
+    {
+      const difference_type __n = __position - begin();
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
+   && __position == end())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(__position._M_const_cast(), __x);
+      return begin() + __n;
+    }
+
+
+    template<typename _InputIterator,
+      typename = std::_RequireInputIter<_InputIterator>>
+      iterator
+      insert(const_iterator __position,
+      _InputIterator __first, _InputIterator __last)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_insert_dispatch(__position._M_const_cast(),
+      __first, __last, __false_type());
+ return begin() + __offset;
+      }
+# 989 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
+    iterator
+    insert(const_iterator __position, size_type __n, const bool& __x)
+    {
+      difference_type __offset = __position - cbegin();
+      _M_fill_insert(__position._M_const_cast(), __n, __x);
+      return begin() + __offset;
+    }
+
+
+
+
+
+
+
+    iterator
+    insert(const_iterator __p, initializer_list<bool> __l)
+    { return this->insert(__p, __l.begin(), __l.end()); }
+
+
+    void
+    pop_back()
+    { --this->_M_impl._M_finish; }
+
+    iterator
+
+    erase(const_iterator __position)
+
+
+
+    { return _M_erase(__position._M_const_cast()); }
+
+    iterator
+
+    erase(const_iterator __first, const_iterator __last)
+
+
+
+    { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+    void
+    resize(size_type __new_size, bool __x = bool())
+    {
+      if (__new_size < size())
+        _M_erase_at_end(begin() + difference_type(__new_size));
+      else
+        insert(end(), __new_size - size(), __x);
+    }
+
+
+    void
+    shrink_to_fit()
+    { _M_shrink_to_fit(); }
+
+
+    void
+    flip() noexcept
+    {
+      _Bit_type * const __end = this->_M_impl._M_end_addr();
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
+        *__p = ~*__p;
+    }
+
+    void
+    clear() noexcept
+    { _M_erase_at_end(begin()); }
+
+
+    template<typename... _Args>
+      void
+      emplace_back(_Args&&... __args)
+      { push_back(bool(__args...)); }
+
+    template<typename... _Args>
+      iterator
+      emplace(const_iterator __pos, _Args&&... __args)
+      { return insert(__pos, bool(__args...)); }
+
+
+  protected:
+
+    iterator
+    _M_copy_aligned(const_iterator __first, const_iterator __last,
+      iterator __result)
+    {
+      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+      return std::copy(const_iterator(__last._M_p, 0), __last,
+         iterator(__q, 0));
+    }
+
+    void
+    _M_initialize(size_type __n)
+    {
+      _Bit_pointer __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+      this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
+      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+    }
+
+    void
+    _M_reallocate(size_type __n);
+
+
+    bool
+    _M_shrink_to_fit();
+
+
+
+
+
+
+    template<typename _Integer>
+      void
+      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+      {
+ _M_initialize(static_cast<size_type>(__n));
+ std::fill(this->_M_impl._M_start._M_p,
+    this->_M_impl._M_end_addr(), __x ? ~0 : 0);
+      }
+
+    template<typename _InputIterator>
+      void
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+        __false_type)
+      { _M_initialize_range(__first, __last,
+       std::__iterator_category(__first)); }
+
+    template<typename _InputIterator>
+      void
+      _M_initialize_range(_InputIterator __first, _InputIterator __last,
+     std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   push_back(*__first);
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+     std::forward_iterator_tag)
+      {
+ const size_type __n = std::distance(__first, __last);
+ _M_initialize(__n);
+ std::copy(__first, __last, this->_M_impl._M_start);
+      }
+
+
+
+    template<typename _Integer>
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign(__n, __val); }
+
+    template<class _InputIterator>
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+
+    void
+    _M_fill_assign(size_t __n, bool __x)
+    {
+      if (__n > size())
+ {
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_addr(), __x ? ~0 : 0);
+   insert(end(), __n - size(), __x);
+ }
+      else
+ {
+   _M_erase_at_end(begin() + __n);
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_addr(), __x ? ~0 : 0);
+ }
+    }
+
+    template<typename _InputIterator>
+      void
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ iterator __cur = begin();
+ for (; __first != __last && __cur != end(); ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+ if (__len < size())
+   _M_erase_at_end(std::copy(__first, __last, begin()));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, begin());
+     insert(end(), __mid, __last);
+   }
+      }
+
+
+
+
+
+    template<typename _Integer>
+      void
+      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+    __true_type)
+      { _M_fill_insert(__pos, __n, __x); }
+
+    template<typename _InputIterator>
+      void
+      _M_insert_dispatch(iterator __pos,
+    _InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_insert_range(__pos, __first, __last,
+   std::__iterator_category(__first)); }
+
+    void
+    _M_fill_insert(iterator __position, size_type __n, bool __x);
+
+    template<typename _InputIterator>
+      void
+      _M_insert_range(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag);
+
+    void
+    _M_insert_aux(iterator __position, bool __x);
+
+    size_type
+    _M_check_len(size_type __n, const char* __s) const
+    {
+      if (max_size() - size() < __n)
+ __throw_length_error((__s));
+
+      const size_type __len = size() + std::max(size(), __n);
+      return (__len < size() || __len > max_size()) ? max_size() : __len;
+    }
+
+    void
+    _M_erase_at_end(iterator __pos)
+    { this->_M_impl._M_finish = __pos; }
+
+    iterator
+    _M_erase(iterator __pos);
+
+    iterator
+    _M_erase(iterator __first, iterator __last);
+  };
+
+
+}
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Alloc>
+    struct hash<std::vector<bool, _Alloc>>
+    : public __hash_base<size_t, std::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const std::vector<bool, _Alloc>&) const noexcept;
+    };
+
+
+}
+# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/vector.tcc" 1 3
+# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/vector.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp = _M_allocate_and_copy(__n,
+     std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
+     std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __tmp;
+   this->_M_impl._M_finish = __tmp + __old_size;
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish;
+   }
+ else
+   _M_emplace_back_aux(std::forward<_Args>(__args)...);
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+   && __position == end())
+ {
+   _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+
+   const auto __pos = begin() + (__position - cbegin());
+   if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+     {
+       _Tp __x_copy = __x;
+       _M_insert_aux(__pos, std::move(__x_copy));
+     }
+   else
+     _M_insert_aux(__pos, __x);
+
+
+
+ }
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+ std::move(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      return __position;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ {
+   if (__last != end())
+     std::move(__last, end(), __first);
+   _M_erase_at_end(__first.base() + (end() - __last));
+ }
+      return __first;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+ {
+
+   if (_Alloc_traits::_S_propagate_on_copy_assign())
+     {
+       if (!_Alloc_traits::_S_always_equal()
+           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+         {
+
+    this->clear();
+    _M_deallocate(this->_M_impl._M_start,
+    this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start);
+    this->_M_impl._M_start = nullptr;
+    this->_M_impl._M_finish = nullptr;
+    this->_M_impl._M_end_of_storage = nullptr;
+  }
+       std::__alloc_on_copy(_M_get_Tp_allocator(),
+       __x._M_get_Tp_allocator());
+     }
+
+   const size_type __xlen = __x.size();
+   if (__xlen > capacity())
+     {
+       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+         __x.end());
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __tmp;
+       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+     }
+   else if (size() >= __xlen)
+     {
+       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+       end(), _M_get_Tp_allocator());
+     }
+   else
+     {
+       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+   this->_M_impl._M_start);
+       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+       __x._M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+ }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+ {
+   vector __tmp(__n, __val, _M_get_Tp_allocator());
+   __tmp._M_impl._M_swap_data(this->_M_impl);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   this->_M_impl._M_finish =
+     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+       __n - size(), __val,
+       _M_get_Tp_allocator());
+ }
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ pointer __cur(this->_M_impl._M_start);
+ for (; __first != __last && __cur != this->_M_impl._M_finish;
+      ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+
+ if (__len > capacity())
+   {
+     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     _M_deallocate(this->_M_impl._M_start,
+     this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_start);
+     this->_M_impl._M_start = __tmp;
+     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+   }
+ else if (size() >= __len)
+   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, this->_M_impl._M_start);
+     this->_M_impl._M_finish =
+       std::__uninitialized_copy_a(__mid, __last,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+   }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename vector<_Tp, _Alloc>::iterator
+      vector<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+ const size_type __n = __position - begin();
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+     && __position == end())
+   {
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish;
+   }
+ else
+   _M_insert_aux(begin() + (__position - cbegin()),
+   std::forward<_Args>(__args)...);
+ return iterator(this->_M_impl._M_start + __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_insert_aux(iterator __position, _Args&&... __args)
+
+
+
+
+
+
+    {
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ {
+   _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+              std::move(*(this->_M_impl._M_finish - 1)));
+
+   ++this->_M_impl._M_finish;
+
+
+
+   std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);
+
+
+
+
+
+   *__position = _Tp(std::forward<_Args>(__args)...);
+
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector::_M_insert_aux");
+   const size_type __elems_before = __position - begin();
+   pointer __new_start(this->_M_allocate(__len));
+   pointer __new_finish(__new_start);
+   try
+     {
+
+
+
+
+       _Alloc_traits::construct(this->_M_impl,
+                         __new_start + __elems_before,
+
+           std::forward<_Args>(__args)...);
+
+
+
+       __new_finish = pointer();
+
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (this->_M_impl._M_start, __position.base(),
+   __new_start, _M_get_Tp_allocator());
+
+       ++__new_finish;
+
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (__position.base(), this->_M_impl._M_finish,
+   __new_finish, _M_get_Tp_allocator());
+     }
+          catch(...)
+     {
+       if (!__new_finish)
+  _Alloc_traits::destroy(this->_M_impl,
+                         __new_start + __elems_before);
+       else
+  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+       _M_deallocate(__new_start, __len);
+       throw;
+     }
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __new_start;
+   this->_M_impl._M_finish = __new_finish;
+   this->_M_impl._M_end_of_storage = __new_start + __len;
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_emplace_back_aux(_Args&&... __args)
+      {
+ const size_type __len =
+   _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
+ pointer __new_start(this->_M_allocate(__len));
+ pointer __new_finish(__new_start);
+ try
+   {
+     _Alloc_traits::construct(this->_M_impl, __new_start + size(),
+         std::forward<_Args>(__args)...);
+     __new_finish = pointer();
+
+     __new_finish
+       = std::__uninitialized_move_if_noexcept_a
+       (this->_M_impl._M_start, this->_M_impl._M_finish,
+        __new_start, _M_get_Tp_allocator());
+
+     ++__new_finish;
+   }
+ catch(...)
+   {
+     if (!__new_finish)
+       _Alloc_traits::destroy(this->_M_impl, __new_start + size());
+     else
+       std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+     _M_deallocate(__new_start, __len);
+     throw;
+   }
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator());
+ _M_deallocate(this->_M_impl._M_start,
+        this->_M_impl._M_end_of_storage
+        - this->_M_impl._M_start);
+ this->_M_impl._M_start = __new_start;
+ this->_M_impl._M_finish = __new_finish;
+ this->_M_impl._M_end_of_storage = __new_start + __len;
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+       value_type __x_copy = __x;
+       const size_type __elems_after = end() - __position;
+       pointer __old_finish(this->_M_impl._M_finish);
+       if (__elems_after > __n)
+  {
+    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n;
+    std::move_backward(__position.base(), __old_finish - __n, __old_finish);
+
+    std::fill(__position.base(), __position.base() + __n,
+       __x_copy);
+  }
+       else
+  {
+    this->_M_impl._M_finish =
+      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+        __n - __elems_after,
+        __x_copy,
+        _M_get_Tp_allocator());
+    std::__uninitialized_move_a(__position.base(), __old_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __elems_after;
+    std::fill(__position.base(), __old_finish, __x_copy);
+  }
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_fill_insert");
+       const size_type __elems_before = __position - begin();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+
+    std::__uninitialized_fill_n_a(__new_start + __elems_before,
+      __n, __x,
+      _M_get_Tp_allocator());
+    __new_finish = pointer();
+
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (this->_M_impl._M_start, __position.base(),
+       __new_start, _M_get_Tp_allocator());
+
+    __new_finish += __n;
+
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (__position.base(), this->_M_impl._M_finish,
+       __new_finish, _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (!__new_finish)
+      std::_Destroy(__new_start + __elems_before,
+      __new_start + __elems_before + __n,
+      _M_get_Tp_allocator());
+    else
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+       this->_M_impl._M_finish =
+  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+       __n, _M_get_Tp_allocator());
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_default_append");
+       const size_type __old_size = this->size();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (this->_M_impl._M_start, this->_M_impl._M_finish,
+       __new_start, _M_get_Tp_allocator());
+    __new_finish =
+      std::__uninitialized_default_n_a(__new_finish, __n,
+           _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    std::_Destroy(__new_start, __new_finish,
+    _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    bool
+    vector<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() == size())
+ return false;
+      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     const size_type __n = std::distance(__first, __last);
+     if (size_type(this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_finish) >= __n)
+       {
+  const size_type __elems_after = end() - __position;
+  pointer __old_finish(this->_M_impl._M_finish);
+  if (__elems_after > __n)
+    {
+      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+      this->_M_impl._M_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n;
+      std::move_backward(__position.base(), __old_finish - __n, __old_finish);
+
+      std::copy(__first, __last, __position);
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, __elems_after);
+      std::__uninitialized_copy_a(__mid, __last,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n - __elems_after;
+      std::__uninitialized_move_a(__position.base(),
+      __old_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __elems_after;
+      std::copy(__first, __mid, __position);
+    }
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector::_M_range_insert");
+  pointer __new_start(this->_M_allocate(__len));
+  pointer __new_finish(__new_start);
+  try
+    {
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (this->_M_impl._M_start, __position.base(),
+         __new_start, _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_copy_a(__first, __last,
+          __new_finish,
+          _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (__position.base(), this->_M_impl._M_finish,
+         __new_finish, _M_get_Tp_allocator());
+    }
+  catch(...)
+    {
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+      _M_deallocate(__new_start, __len);
+      throw;
+    }
+  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  _M_deallocate(this->_M_impl._M_start,
+         this->_M_impl._M_end_of_storage
+         - this->_M_impl._M_start);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+  this->_M_impl._M_end_of_storage = __new_start + __len;
+       }
+   }
+      }
+
+
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_reallocate(size_type __n)
+    {
+      _Bit_pointer __q = this->_M_allocate(__n);
+      iterator __start(std::__addressof(*__q), 0);
+      this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), __start);
+      this->_M_deallocate();
+      this->_M_impl._M_start = __start;
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+    }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+ return;
+      if (capacity() - size() >= __n)
+ {
+   std::copy_backward(__position, end(),
+        this->_M_impl._M_finish + difference_type(__n));
+   std::fill(__position, __position + difference_type(__n), __x);
+   this->_M_impl._M_finish += difference_type(__n);
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(__n, "vector<bool>::_M_fill_insert");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   std::fill(__i, __i + difference_type(__n), __x);
+   this->_M_impl._M_finish = std::copy(__position, end(),
+           __i + difference_type(__n));
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+ }
+    }
+
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     size_type __n = std::distance(__first, __last);
+     if (capacity() - size() >= __n)
+       {
+  std::copy_backward(__position, end(),
+       this->_M_impl._M_finish
+       + difference_type(__n));
+  std::copy(__first, __last, __position);
+  this->_M_impl._M_finish += difference_type(__n);
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector<bool>::_M_insert_range");
+  _Bit_pointer __q = this->_M_allocate(__len);
+  iterator __start(std::__addressof(*__q), 0);
+  iterator __i = _M_copy_aligned(begin(), __position, __start);
+  __i = std::copy(__first, __last, __i);
+  this->_M_impl._M_finish = std::copy(__position, end(), __i);
+  this->_M_deallocate();
+  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+  this->_M_impl._M_start = __start;
+       }
+   }
+      }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+ {
+   std::copy_backward(__position, this->_M_impl._M_finish,
+        this->_M_impl._M_finish + 1);
+   *__position = __x;
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   *__i++ = __x;
+   this->_M_impl._M_finish = std::copy(__position, end(), __i);
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+ }
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+
+  template<typename _Alloc>
+    bool
+    vector<bool, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() - size() < int(_S_word_bit))
+ return false;
+      try
+ {
+   _M_reallocate(size());
+   return true;
+ }
+      catch(...)
+ { return false; }
+    }
+
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Alloc>
+    size_t
+    hash<std::vector<bool, _Alloc>>::
+    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
+    {
+      size_t __hash = 0;
+      using std::_S_word_bit;
+      using std::_Bit_type;
+
+      const size_t __words = __b.size() / _S_word_bit;
+      if (__words)
+ {
+   const size_t __clength = __words * sizeof(_Bit_type);
+   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
+ }
+
+      const size_t __extrabits = __b.size() % _S_word_bit;
+      if (__extrabits)
+ {
+   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
+   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
+
+   const size_t __clength
+     = (__extrabits + 8 - 1) / 8;
+   if (__words)
+     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
+   else
+     __hash = std::_Hash_impl::hash(&__hiword, __clength);
+ }
+
+      return __hash;
+    }
+
+
+}
+# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
+# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 1 3
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 95 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+  template<typename _Tp, typename _Sequence = deque<_Tp> >
+    class queue
+    {
+
+      typedef typename _Sequence::value_type _Sequence_value_type;
+
+
+
+
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
+
+      template<typename _Tp1, typename _Seq1>
+        friend bool
+        operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
+
+
+      template<typename _Alloc>
+ using _Uses = typename
+   enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
+
+
+    public:
+      typedef typename _Sequence::value_type value_type;
+      typedef typename _Sequence::reference reference;
+      typedef typename _Sequence::const_reference const_reference;
+      typedef typename _Sequence::size_type size_type;
+      typedef _Sequence container_type;
+
+    protected:
+# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      _Sequence c;
+
+    public:
+# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      explicit
+      queue(const _Sequence& __c)
+      : c(__c) { }
+
+      explicit
+      queue(_Sequence&& __c = _Sequence())
+      : c(std::move(__c)) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ explicit
+ queue(const _Alloc& __a)
+ : c(__a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ queue(const _Sequence& __c, const _Alloc& __a)
+ : c(__c, __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ queue(_Sequence&& __c, const _Alloc& __a)
+ : c(std::move(__c), __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ queue(const queue& __q, const _Alloc& __a)
+ : c(__q.c, __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ queue(queue&& __q, const _Alloc& __a)
+ : c(std::move(__q.c), __a) { }
+
+
+
+
+
+      bool
+      empty() const
+      { return c.empty(); }
+
+
+      size_type
+      size() const
+      { return c.size(); }
+
+
+
+
+
+      reference
+      front()
+      {
+                              ;
+ return c.front();
+      }
+
+
+
+
+
+      const_reference
+      front() const
+      {
+                              ;
+ return c.front();
+      }
+
+
+
+
+
+      reference
+      back()
+      {
+                              ;
+ return c.back();
+      }
+
+
+
+
+
+      const_reference
+      back() const
+      {
+                              ;
+ return c.back();
+      }
+# 241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      void
+      push(const value_type& __x)
+      { c.push_back(__x); }
+
+
+      void
+      push(value_type&& __x)
+      { c.push_back(std::move(__x)); }
+
+      template<typename... _Args>
+        void
+        emplace(_Args&&... __args)
+ { c.emplace_back(std::forward<_Args>(__args)...); }
+# 267 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      void
+      pop()
+      {
+                              ;
+ c.pop_front();
+      }
+
+
+      void
+      swap(queue& __q)
+      noexcept(__is_nothrow_swappable<_Tp>::value)
+      {
+ using std::swap;
+ swap(c, __q.c);
+      }
+
+    };
+# 296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __x.c == __y.c; }
+# 314 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __x.c < __y.c; }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Seq>
+    inline void
+    swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Seq, typename _Alloc>
+    struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
+    : public uses_allocator<_Seq, _Alloc>::type { };
+# 395 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+  template<typename _Tp, typename _Sequence = vector<_Tp>,
+    typename _Compare = less<typename _Sequence::value_type> >
+    class priority_queue
+    {
+
+      typedef typename _Sequence::value_type _Sequence_value_type;
+# 409 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      template<typename _Alloc>
+ using _Uses = typename
+   enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
+
+
+    public:
+      typedef typename _Sequence::value_type value_type;
+      typedef typename _Sequence::reference reference;
+      typedef typename _Sequence::const_reference const_reference;
+      typedef typename _Sequence::size_type size_type;
+      typedef _Sequence container_type;
+
+    protected:
+
+      _Sequence c;
+      _Compare comp;
+
+    public:
+# 437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      explicit
+      priority_queue(const _Compare& __x,
+       const _Sequence& __s)
+      : c(__s), comp(__x)
+      { std::make_heap(c.begin(), c.end(), comp); }
+
+      explicit
+      priority_queue(const _Compare& __x = _Compare(),
+       _Sequence&& __s = _Sequence())
+      : c(std::move(__s)), comp(__x)
+      { std::make_heap(c.begin(), c.end(), comp); }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ explicit
+ priority_queue(const _Alloc& __a)
+ : c(__a), comp() { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ priority_queue(const _Compare& __x, const _Alloc& __a)
+ : c(__a), comp(__x) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ priority_queue(const _Compare& __x, const _Sequence& __c,
+         const _Alloc& __a)
+ : c(__c, __a), comp(__x) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ priority_queue(const _Compare& __x, _Sequence&& __c, const _Alloc& __a)
+ : c(std::move(__c), __a), comp(__x) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ priority_queue(const priority_queue& __q, const _Alloc& __a)
+ : c(__q.c, __a), comp(__q.comp) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ priority_queue(priority_queue&& __q, const _Alloc& __a)
+ : c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
+# 503 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      template<typename _InputIterator>
+        priority_queue(_InputIterator __first, _InputIterator __last,
+         const _Compare& __x,
+         const _Sequence& __s)
+ : c(__s), comp(__x)
+        {
+                                                  ;
+   c.insert(c.end(), __first, __last);
+   std::make_heap(c.begin(), c.end(), comp);
+ }
+
+      template<typename _InputIterator>
+        priority_queue(_InputIterator __first, _InputIterator __last,
+         const _Compare& __x = _Compare(),
+         _Sequence&& __s = _Sequence())
+ : c(std::move(__s)), comp(__x)
+        {
+                                                  ;
+   c.insert(c.end(), __first, __last);
+   std::make_heap(c.begin(), c.end(), comp);
+ }
+
+
+
+
+
+      bool
+      empty() const
+      { return c.empty(); }
+
+
+      size_type
+      size() const
+      { return c.size(); }
+
+
+
+
+
+      const_reference
+      top() const
+      {
+                              ;
+ return c.front();
+      }
+# 557 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      void
+      push(const value_type& __x)
+      {
+ c.push_back(__x);
+ std::push_heap(c.begin(), c.end(), comp);
+      }
+
+
+      void
+      push(value_type&& __x)
+      {
+ c.push_back(std::move(__x));
+ std::push_heap(c.begin(), c.end(), comp);
+      }
+
+      template<typename... _Args>
+        void
+        emplace(_Args&&... __args)
+ {
+   c.emplace_back(std::forward<_Args>(__args)...);
+   std::push_heap(c.begin(), c.end(), comp);
+ }
+# 592 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
+      void
+      pop()
+      {
+                              ;
+ std::pop_heap(c.begin(), c.end(), comp);
+ c.pop_back();
+      }
+
+
+      void
+      swap(priority_queue& __pq)
+      noexcept(__is_nothrow_swappable<_Tp>::value
+               && __is_nothrow_swappable<_Compare>::value)
+      {
+ using std::swap;
+ swap(c, __pq.c);
+ swap(comp, __pq.comp);
+      }
+
+    };
+
+
+
+
+  template<typename _Tp, typename _Sequence, typename _Compare>
+    inline void
+    swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
+  priority_queue<_Tp, _Sequence, _Compare>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Sequence, typename _Compare,
+    typename _Alloc>
+    struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
+    : public uses_allocator<_Sequence, _Alloc>::type { };
+
+
+
+}
+# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DeferredFinalize.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DeferredFinalize.h"
+class nsISupports;
+
+namespace mozilla {
+
+
+
+
+typedef void* (*DeferredFinalizeAppendFunction)(void* aPointers, void* aThing);
+
+
+
+
+
+typedef bool (*DeferredFinalizeFunction)(uint32_t aSlice, void* aData);
+
+void DeferredFinalize(DeferredFinalizeAppendFunction aAppendFunc,
+                      DeferredFinalizeFunction aFunc,
+                      void* aThing);
+
+void DeferredFinalize(nsISupports* aSupports);
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h" 1
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
+namespace mozilla {
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
+template<typename T,
+         size_t IdealSegmentSize = 4096,
+         typename AllocPolicy = MallocAllocPolicy>
+class SegmentedVector : private AllocPolicy
+{
+  template<size_t SegmentCapacity>
+  struct SegmentImpl
+    : public mozilla::LinkedListElement<SegmentImpl<SegmentCapacity>>
+  {
+    SegmentImpl() : mLength(0) {}
+
+    ~SegmentImpl()
+    {
+      for (uint32_t i = 0; i < mLength; i++) {
+        (*this)[i].~T();
+      }
+    }
+
+    uint32_t Length() const { return mLength; }
+
+    T* Elems() { return reinterpret_cast<T*>(&mStorage.mBuf); }
+
+    T& operator[](size_t aIndex)
+    {
+      do { } while (0);
+      return Elems()[aIndex];
+    }
+
+    const T& operator[](size_t aIndex) const
+    {
+      do { } while (0);
+      return Elems()[aIndex];
+    }
+
+    template<typename U>
+    void Append(U&& aU)
+    {
+      do { } while (0);
+
+      mLength++;
+      T* elem = &(*this)[mLength - 1];
+      new (elem) T(mozilla::Forward<U>(aU));
+    }
+
+    void PopLast()
+    {
+      do { } while (0);
+      (*this)[mLength - 1].~T();
+      mLength--;
+    }
+
+    uint32_t mLength;
+
+
+    union Storage
+    {
+      char mBuf[sizeof(T) * SegmentCapacity];
+      mozilla::AlignedElem<mozilla::AlignmentFinder<T>::alignment> mAlign;
+    } mStorage;
+
+    static_assert(mozilla::AlignmentFinder<T>::alignment == mozilla::AlignmentFinder<Storage>::alignment,
+                  "SegmentedVector provides incorrect alignment");
+  };
+
+
+
+
+  static const size_t kSingleElementSegmentSize = sizeof(SegmentImpl<1>);
+  static const size_t kSegmentCapacity =
+    kSingleElementSegmentSize <= IdealSegmentSize
+    ? (IdealSegmentSize - kSingleElementSegmentSize) / sizeof(T) + 1
+    : 1;
+
+  typedef SegmentImpl<kSegmentCapacity> Segment;
+
+public:
+
+
+
+
+  explicit SegmentedVector(size_t aIdealSegmentSize = 0)
+  {
+
+
+
+    do { } while (0);
+
+
+
+  }
+
+  ~SegmentedVector() { Clear(); }
+
+  bool IsEmpty() const { return !mSegments.getFirst(); }
+
+
+
+  size_t Length() const
+  {
+    size_t n = 0;
+    for (auto segment = mSegments.getFirst();
+         segment;
+         segment = segment->getNext()) {
+      n += segment->Length();
+    }
+    return n;
+  }
+
+
+
+  template<typename U>
+  __attribute__ ((warn_unused_result)) bool Append(U&& aU)
+  {
+    Segment* last = mSegments.getLast();
+    if (!last || last->Length() == kSegmentCapacity) {
+      last = this->template pod_malloc<Segment>(1);
+      if (!last) {
+        return false;
+      }
+      new (last) Segment();
+      mSegments.insertBack(last);
+    }
+    last->Append(mozilla::Forward<U>(aU));
+    return true;
+  }
+
+
+
+  template<typename U>
+  void InfallibleAppend(U&& aU)
+  {
+    bool ok = Append(mozilla::Forward<U>(aU));
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(ok)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ok))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "ok" ")"); do { *((volatile int*) __null) = 183; ::abort(); } while (0); } } while (0);
+  }
+
+  void Clear()
+  {
+    Segment* segment;
+    while ((segment = mSegments.popFirst())) {
+      segment->~Segment();
+      this->free_(segment);
+    }
+  }
+
+  T& GetLast()
+  {
+    do { } while (0);
+    Segment* last = mSegments.getLast();
+    return (*last)[last->Length() - 1];
+  }
+
+  const T& GetLast() const
+  {
+    do { } while (0);
+    Segment* last = mSegments.getLast();
+    return (*last)[last->Length() - 1];
+  }
+
+  void PopLast()
+  {
+    do { } while (0);
+    Segment* last = mSegments.getLast();
+    last->PopLast();
+    if (!last->Length()) {
+      mSegments.popLast();
+      last->~Segment();
+      this->free_(last);
+    }
+  }
+
+
+
+  void PopLastN(uint32_t aNumElements)
+  {
+    do { } while (0);
+
+    Segment* last;
+
+
+
+
+    do {
+      last = mSegments.getLast();
+
+
+      if (!last) {
+        return;
+      }
+
+
+
+      uint32_t segmentLen = last->Length();
+      if (segmentLen > aNumElements) {
+        break;
+      }
+
+
+      mSegments.popLast();
+      last->~Segment();
+      this->free_(last);
+
+      do { } while (0);
+      aNumElements -= segmentLen;
+      if (aNumElements == 0) {
+        return;
+      }
+    } while (true);
+
+
+
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+    for (uint32_t i = 0; i < aNumElements; ++i) {
+      last->PopLast();
+    }
+    do { } while (0);
+  }
+# 278 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
+  class IterImpl
+  {
+    friend class SegmentedVector;
+
+    Segment* mSegment;
+    size_t mIndex;
+
+    explicit IterImpl(SegmentedVector* aVector)
+      : mSegment(aVector->mSegments.getFirst())
+      , mIndex(0)
+    {}
+
+  public:
+    bool Done() const { return !mSegment; }
+
+    T& Get()
+    {
+      do { } while (0);
+      return (*mSegment)[mIndex];
+    }
+
+    const T& Get() const
+    {
+      do { } while (0);
+      return (*mSegment)[mIndex];
+    }
+
+    void Next()
+    {
+      do { } while (0);
+      mIndex++;
+      if (mIndex == mSegment->Length()) {
+        mSegment = mSegment->getNext();
+        mIndex = 0;
+      }
+    }
+  };
+
+  IterImpl Iter() { return IterImpl(this); }
+
+
+
+
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return mSegments.sizeOfExcludingThis(aMallocSizeOf);
+  }
+
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+private:
+  mozilla::LinkedList<Segment> mSegments;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
+class nsCycleCollectionNoteRootCallback;
+class nsIException;
+class nsIRunnable;
+class nsThread;
+class nsWrapperCache;
+
+namespace js {
+struct Class;
+}
+
+namespace mozilla {
+
+class JSGCThingParticipant: public nsCycleCollectionParticipant
+{
+public:
+  constexpr JSGCThingParticipant()
+    : nsCycleCollectionParticipant(false) {}
+
+  virtual void Root(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void Unlink(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void Unroot(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void DeleteCycleCollectable(void* aPtr) override
+  {
+    do { } while (0);
+  }
+
+  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
+    override;
+
+  virtual const char* ClassName() override { return "JSGCThingParticipant"; };
+};
+
+class JSZoneParticipant : public nsCycleCollectionParticipant
+{
+public:
+  constexpr JSZoneParticipant(): nsCycleCollectionParticipant(false)
+  {
+  }
+
+  virtual void Root(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void Unlink(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void Unroot(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual void DeleteCycleCollectable(void*) override
+  {
+    do { } while (0);
+  }
+
+  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
+    override;
+
+  virtual const char* ClassName() override { return "JSZoneParticipant"; };
+};
+
+class IncrementalFinalizeRunnable;
+
+
+struct CycleCollectorResults
+{
+  CycleCollectorResults()
+  {
+
+
+    Init();
+  }
+
+  void Init()
+  {
+    mForcedGC = false;
+    mMergedZones = false;
+    mAnyManual = false;
+    mVisitedRefCounted = 0;
+    mVisitedGCed = 0;
+    mFreedRefCounted = 0;
+    mFreedGCed = 0;
+    mFreedJSZones = 0;
+    mNumSlices = 1;
+
+
+  }
+
+  bool mForcedGC;
+  bool mMergedZones;
+  bool mAnyManual;
+  uint32_t mVisitedRefCounted;
+  uint32_t mVisitedGCed;
+  uint32_t mFreedRefCounted;
+  uint32_t mFreedGCed;
+  uint32_t mFreedJSZones;
+  uint32_t mNumSlices;
+};
+
+class CycleCollectedJSContext
+{
+  friend class JSGCThingParticipant;
+  friend class JSZoneParticipant;
+  friend class IncrementalFinalizeRunnable;
+protected:
+  CycleCollectedJSContext();
+  virtual ~CycleCollectedJSContext();
+
+
+  nsresult Initialize(JSRuntime* aParentRuntime,
+                      uint32_t aMaxBytes,
+                      uint32_t aMaxNurseryBytes);
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+  void UnmarkSkippableJSHolders();
+
+  virtual void
+  TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& aCb) {}
+  virtual void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) {}
+
+  virtual void CustomGCCallback(JSGCStatus aStatus) {}
+  virtual void CustomOutOfMemoryCallback() {}
+  virtual void CustomLargeAllocationFailureCallback() {}
+
+  std::queue<nsCOMPtr<nsIRunnable>> mPromiseMicroTaskQueue;
+  std::queue<nsCOMPtr<nsIRunnable>> mDebuggerPromiseMicroTaskQueue;
+
+private:
+  void
+  DescribeGCThing(bool aIsMarked, JS::GCCellPtr aThing,
+                  nsCycleCollectionTraversalCallback& aCb) const;
+
+  virtual bool
+  DescribeCustomObjects(JSObject* aObject, const js::Class* aClasp,
+                        char (&aName)[72]) const
+  {
+    return false;
+  }
+
+  void
+  NoteGCThingJSChildren(JS::GCCellPtr aThing,
+                        nsCycleCollectionTraversalCallback& aCb) const;
+
+  void
+  NoteGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
+                           nsCycleCollectionTraversalCallback& aCb) const;
+
+  virtual bool
+  NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
+                                 nsCycleCollectionTraversalCallback& aCb) const
+  {
+    return false;
+  }
+
+  enum TraverseSelect {
+    TRAVERSE_CPP,
+    TRAVERSE_FULL
+  };
+
+  void
+  TraverseGCThing(TraverseSelect aTs, JS::GCCellPtr aThing,
+                  nsCycleCollectionTraversalCallback& aCb);
+
+  void
+  TraverseZone(JS::Zone* aZone, nsCycleCollectionTraversalCallback& aCb);
+
+  static void
+  TraverseObjectShim(void* aData, JS::GCCellPtr aThing);
+
+  void TraverseNativeRoots(nsCycleCollectionNoteRootCallback& aCb);
+
+  static void TraceBlackJS(JSTracer* aTracer, void* aData);
+  static void TraceGrayJS(JSTracer* aTracer, void* aData);
+  static void GCCallback(JSContext* aContext, JSGCStatus aStatus, void* aData);
+  static void GCSliceCallback(JSContext* aContext, JS::GCProgress aProgress,
+                              const JS::GCDescription& aDesc);
+  static void GCNurseryCollectionCallback(JSContext* aContext,
+                                          JS::GCNurseryProgress aProgress,
+                                          JS::gcreason::Reason aReason);
+  static void OutOfMemoryCallback(JSContext* aContext, void* aData);
+  static void LargeAllocationFailureCallback(void* aData);
+
+
+
+  static size_t SizeofExternalStringCallback(JSString* aStr,
+                                             mozilla::MallocSizeOf aMallocSizeOf);
+
+  static bool ContextCallback(JSContext* aCx, unsigned aOperation,
+                              void* aData);
+  static JSObject* GetIncumbentGlobalCallback(JSContext* aCx);
+  static bool EnqueuePromiseJobCallback(JSContext* aCx,
+                                        JS::HandleObject aJob,
+                                        JS::HandleObject aAllocationSite,
+                                        JS::HandleObject aIncumbentGlobal,
+                                        void* aData);
+  static void PromiseRejectionTrackerCallback(JSContext* aCx,
+                                              JS::HandleObject aPromise,
+                                              PromiseRejectionHandlingState state,
+                                              void* aData);
+
+  virtual void TraceNativeBlackRoots(JSTracer* aTracer) { };
+  void TraceNativeGrayRoots(JSTracer* aTracer);
+
+  void AfterProcessMicrotask(uint32_t aRecursionDepth);
+public:
+  void ProcessStableStateQueue();
+private:
+  void ProcessMetastableStateQueue(uint32_t aRecursionDepth);
+
+public:
+  enum DeferredFinalizeType {
+    FinalizeIncrementally,
+    FinalizeNow,
+  };
+
+  void FinalizeDeferredThings(DeferredFinalizeType aType);
+
+
+
+  enum class OOMState : uint32_t {
+
+    OK,
+# 271 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
+    Reporting,
+# 281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
+    Reported,
+
+
+
+
+
+    Recovered
+  };
+
+private:
+  void AnnotateAndSetOutOfMemory(OOMState* aStatePtr, OOMState aNewState);
+  void OnGC(JSGCStatus aStatus);
+  void OnOutOfMemory();
+  void OnLargeAllocationFailure();
+
+public:
+  void AddJSHolder(void* aHolder, nsScriptObjectTracer* aTracer);
+  void RemoveJSHolder(void* aHolder);
+
+
+
+
+
+  already_AddRefed<nsIException> GetPendingException() const;
+  void SetPendingException(nsIException* aException);
+
+  std::queue<nsCOMPtr<nsIRunnable>>& GetPromiseMicroTaskQueue();
+  std::queue<nsCOMPtr<nsIRunnable>>& GetDebuggerPromiseMicroTaskQueue();
+
+  nsCycleCollectionParticipant* GCThingParticipant();
+  nsCycleCollectionParticipant* ZoneParticipant();
+
+  nsresult TraverseRoots(nsCycleCollectionNoteRootCallback& aCb);
+  virtual bool UsefulToMergeZones() const;
+  void FixWeakMappingGrayBits() const;
+  void CheckGrayBits() const;
+  bool AreGCGrayBitsValid() const;
+  void GarbageCollect(uint32_t aReason) const;
+
+  void NurseryWrapperAdded(nsWrapperCache* aCache);
+  void NurseryWrapperPreserved(JSObject* aWrapper);
+  void JSObjectsTenured();
+
+  void DeferredFinalize(DeferredFinalizeAppendFunction aAppendFunc,
+                        DeferredFinalizeFunction aFunc,
+                        void* aThing);
+  void DeferredFinalize(nsISupports* aSupports);
+
+  void DumpJSHeap(FILE* aFile);
+
+  virtual void PrepareForForgetSkippable() = 0;
+  virtual void BeginCycleCollectionCallback() = 0;
+  virtual void EndCycleCollectionCallback(CycleCollectorResults& aResults) = 0;
+  virtual void DispatchDeferredDeletion(bool aContinuation, bool aPurge = false) = 0;
+
+  JSContext* Context() const
+  {
+    do { } while (0);
+    return mJSContext;
+  }
+
+  JS::RootingContext* RootingCx() const
+  {
+    do { } while (0);
+    return JS::RootingContext::get(mJSContext);
+  }
+
+  bool MicroTaskCheckpointDisabled() const
+  {
+    return mDisableMicroTaskCheckpoint;
+  }
+
+  void DisableMicroTaskCheckpoint(bool aDisable)
+  {
+    mDisableMicroTaskCheckpoint = aDisable;
+  }
+
+  class AutoDisableMicroTaskCheckpoint
+  {
+    public:
+    AutoDisableMicroTaskCheckpoint()
+    : mCCJSCX(CycleCollectedJSContext::Get())
+    {
+      mOldValue = mCCJSCX->MicroTaskCheckpointDisabled();
+      mCCJSCX->DisableMicroTaskCheckpoint(true);
+    }
+
+    ~AutoDisableMicroTaskCheckpoint()
+    {
+      mCCJSCX->DisableMicroTaskCheckpoint(mOldValue);
+    }
+
+    CycleCollectedJSContext* mCCJSCX;
+    bool mOldValue;
+  };
+
+protected:
+  JSContext* MaybeContext() const { return mJSContext; }
+
+public:
+
+  virtual void BeforeProcessTask(bool aMightBlock) { };
+  virtual void AfterProcessTask(uint32_t aRecursionDepth);
+
+
+  void AfterProcessMicrotask();
+
+  uint32_t RecursionDepth();
+
+
+  void RunInStableState(already_AddRefed<nsIRunnable>&& aRunnable);
+
+
+  void RunInMetastableState(already_AddRefed<nsIRunnable>&& aRunnable);
+
+
+
+  static CycleCollectedJSContext* Get();
+
+
+  void AddZoneWaitingForGC(JS::Zone* aZone)
+  {
+    mZonesWaitingForGC.PutEntry(aZone);
+  }
+
+
+
+
+
+  void PrepareWaitingZonesForGC();
+
+
+  virtual void DispatchToMicroTask(already_AddRefed<nsIRunnable> aRunnable);
+
+
+
+
+
+
+
+  JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mUncaughtRejections;
+
+
+
+
+  JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mConsumedRejections;
+  nsTArray<nsCOMPtr<nsISupports >> mUncaughtRejectionObservers;
+
+private:
+  JSGCThingParticipant mGCThingCycleCollectorGlobal;
+
+  JSZoneParticipant mJSZoneCycleCollectorGlobal;
+
+  JSContext* mJSContext;
+
+  JS::GCSliceCallback mPrevGCSliceCallback;
+  JS::GCNurseryCollectionCallback mPrevGCNurseryCollectionCallback;
+
+  nsDataHashtable<nsPtrHashKey<void>, nsScriptObjectTracer*> mJSHolders;
+
+  typedef nsDataHashtable<nsFuncPtrHashKey<DeferredFinalizeFunction>, void*>
+    DeferredFinalizerTable;
+  DeferredFinalizerTable mDeferredFinalizerTable;
+
+  RefPtr<IncrementalFinalizeRunnable> mFinalizeRunnable;
+
+  nsCOMPtr<nsIException> mPendingException;
+  nsThread* mOwningThread;
+
+  struct RunInMetastableStateData
+  {
+    nsCOMPtr<nsIRunnable> mRunnable;
+    uint32_t mRecursionDepth;
+  };
+
+  nsTArray<nsCOMPtr<nsIRunnable>> mStableStateEvents;
+  nsTArray<RunInMetastableStateData> mMetastableStateEvents;
+  uint32_t mBaseRecursionDepth;
+  bool mDoingStableStates;
+
+  bool mDisableMicroTaskCheckpoint;
+
+  OOMState mOutOfMemoryState;
+  OOMState mLargeAllocationFailureState;
+
+  static const size_t kSegmentSize = 512;
+  SegmentedVector<nsWrapperCache*, kSegmentSize, InfallibleAllocPolicy>
+    mNurseryObjects;
+  SegmentedVector<JS::PersistentRooted<JSObject*>, kSegmentSize,
+                  InfallibleAllocPolicy>
+    mPreservedNurseryObjects;
+
+  nsTHashtable<nsPtrHashKey<JS::Zone>> mZonesWaitingForGC;
+
+  struct EnvironmentPreparer : public js::ScriptEnvironmentPreparer {
+    void invoke(JS::HandleObject scope, Closure& closure) override;
+  };
+  EnvironmentPreparer mEnvironmentPreparer;
+};
+
+void TraceScriptHolder(nsISupports* aHolder, JSTracer* aTracer);
+
+
+inline bool AddToCCKind(JS::TraceKind aKind)
+{
+  return aKind == JS::TraceKind::Object ||
+         aKind == JS::TraceKind::Script ||
+         aKind == JS::TraceKind::Scope ||
+         aKind == JS::TraceKind::RegExpShared;
+}
+
+bool
+GetBuildId(JS::BuildIdCharVector* aBuildID);
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/PrototypeList.h" 1
+
+
+
+
+
+namespace mozilla {
+namespace dom {
+namespace prototypes {
+
+namespace id {
+
+enum ID : uint16_t
+{
+  _ID_Start = 0,
+  ANGLE_instanced_arrays = _ID_Start,
+  AccessibleNode,
+  Addon,
+  AddonEvent,
+  AddonInstall,
+  AddonManager,
+  AnalyserNode,
+  Animation,
+  AnimationEffectReadOnly,
+  AnimationEffectTiming,
+  AnimationEffectTimingReadOnly,
+  AnimationEvent,
+  AnimationPlaybackEvent,
+  AnimationTimeline,
+  AnonymousContent,
+  Attr,
+  AudioBuffer,
+  AudioBufferSourceNode,
+  AudioContext,
+  AudioDestinationNode,
+  AudioListener,
+  AudioNode,
+  AudioParam,
+  AudioProcessingEvent,
+  AudioScheduledSourceNode,
+  AudioStreamTrack,
+  AudioTrack,
+  AudioTrackList,
+  AudioWorkletGlobalScope,
+  AutocompleteErrorEvent,
+  BarProp,
+  BaseAudioContext,
+  BatteryManager,
+  BeforeUnloadEvent,
+  BiquadFilterNode,
+  Blob,
+  BlobEvent,
+  BoxObject,
+  BroadcastChannel,
+  BrowserElementAudioChannel,
+  BrowserFeedWriter,
+  CDATASection,
+  CSS2Properties,
+  CSSAnimation,
+  CSSConditionRule,
+  CSSCounterStyleRule,
+  CSSFontFaceRule,
+  CSSFontFeatureValuesRule,
+  CSSGroupingRule,
+  CSSImportRule,
+  CSSKeyframeRule,
+  CSSKeyframesRule,
+  CSSLexer,
+  CSSMediaRule,
+  CSSMozDocumentRule,
+  CSSNamespaceRule,
+  CSSPageRule,
+  CSSPrimitiveValue,
+  CSSPseudoElement,
+  CSSRule,
+  CSSRuleList,
+  CSSStyleDeclaration,
+  CSSStyleRule,
+  CSSStyleSheet,
+  CSSSupportsRule,
+  CSSTransition,
+  CSSValue,
+  CSSValueList,
+  Cache,
+  CacheStorage,
+  CanvasCaptureMediaStream,
+  CanvasGradient,
+  CanvasPattern,
+  CanvasRenderingContext2D,
+  CaretPosition,
+  CaretStateChangedEvent,
+  ChannelMergerNode,
+  ChannelSplitterNode,
+  CharacterData,
+  CheckerboardReportService,
+  ChromeNodeList,
+  ChromeWorker,
+  Client,
+  Clients,
+  ClipboardEvent,
+  CloseEvent,
+  CommandEvent,
+  Comment,
+  CompositionEvent,
+  ConstantSourceNode,
+  ContainerBoxObject,
+  ConvolverNode,
+  Coordinates,
+  CreateOfferRequest,
+  Crypto,
+  CryptoKey,
+  CustomElementRegistry,
+  CustomEvent,
+  DOMCursor,
+  DOMError,
+  DOMException,
+  DOMImplementation,
+  DOMMatrix,
+  DOMMatrixReadOnly,
+  DOMParser,
+  DOMPoint,
+  DOMPointReadOnly,
+  DOMQuad,
+  DOMRect,
+  DOMRectList,
+  DOMRectReadOnly,
+  DOMRequest,
+  DOMStringList,
+  DOMStringMap,
+  DOMTokenList,
+  DataChannel,
+  DataContainerEvent,
+  DataTransfer,
+  DataTransferItem,
+  DataTransferItemList,
+  DedicatedWorkerGlobalScope,
+  DelayNode,
+  DesktopNotification,
+  DesktopNotificationCenter,
+  DeviceAcceleration,
+  DeviceLightEvent,
+  DeviceMotionEvent,
+  DeviceOrientationEvent,
+  DeviceProximityEvent,
+  DeviceRotationRate,
+  Directory,
+  Document,
+  DocumentFragment,
+  DocumentTimeline,
+  DocumentType,
+  DominatorTree,
+  DragEvent,
+  DynamicsCompressorNode,
+  EXT_blend_minmax,
+  EXT_color_buffer_float,
+  EXT_color_buffer_half_float,
+  EXT_disjoint_timer_query,
+  EXT_frag_depth,
+  EXT_sRGB,
+  EXT_shader_texture_lod,
+  EXT_texture_filter_anisotropic,
+  Element,
+  ErrorEvent,
+  Event,
+  EventSource,
+  EventTarget,
+  Exception,
+  ExtendableEvent,
+  ExtendableMessageEvent,
+  External,
+  FetchController,
+  FetchEvent,
+  FetchObserver,
+  FetchSignal,
+  File,
+  FileList,
+  FileReader,
+  FileReaderSync,
+  FileSystem,
+  FileSystemDirectoryEntry,
+  FileSystemDirectoryReader,
+  FileSystemEntry,
+  FileSystemFileEntry,
+  FlyWebDiscoveryManager,
+  FlyWebFetchEvent,
+  FlyWebPublishedServer,
+  FlyWebWebSocketEvent,
+  FocusEvent,
+  FontFace,
+  FontFaceSet,
+  FontFaceSetIterator,
+  FontFaceSetLoadEvent,
+  FormData,
+  FormDataIterator,
+  GainNode,
+  Gamepad,
+  GamepadAxisMoveEvent,
+  GamepadButton,
+  GamepadButtonEvent,
+  GamepadEvent,
+  GamepadHapticActuator,
+  GamepadPose,
+  GamepadServiceTest,
+  Geolocation,
+  GetUserMediaRequest,
+  Grid,
+  GridArea,
+  GridDimension,
+  GridLine,
+  GridLines,
+  GridTrack,
+  GridTracks,
+  GroupedHistoryEvent,
+  HTMLAllCollection,
+  HTMLAnchorElement,
+  HTMLAppletElement,
+  HTMLAreaElement,
+  HTMLAudioElement,
+  HTMLBRElement,
+  HTMLBaseElement,
+  HTMLBodyElement,
+  HTMLButtonElement,
+  HTMLCanvasElement,
+  HTMLCollection,
+  HTMLContentElement,
+  HTMLDListElement,
+  HTMLDataElement,
+  HTMLDataListElement,
+  HTMLDetailsElement,
+  HTMLDialogElement,
+  HTMLDirectoryElement,
+  HTMLDivElement,
+  HTMLDocument,
+  HTMLElement,
+  HTMLEmbedElement,
+  HTMLFieldSetElement,
+  HTMLFontElement,
+  HTMLFormControlsCollection,
+  HTMLFormElement,
+  HTMLFrameElement,
+  HTMLFrameSetElement,
+  HTMLHRElement,
+  HTMLHeadElement,
+  HTMLHeadingElement,
+  HTMLHtmlElement,
+  HTMLIFrameElement,
+  HTMLImageElement,
+  HTMLInputElement,
+  HTMLLIElement,
+  HTMLLabelElement,
+  HTMLLegendElement,
+  HTMLLinkElement,
+  HTMLMapElement,
+  HTMLMediaElement,
+  HTMLMenuElement,
+  HTMLMenuItemElement,
+  HTMLMetaElement,
+  HTMLMeterElement,
+  HTMLModElement,
+  HTMLOListElement,
+  HTMLObjectElement,
+  HTMLOptGroupElement,
+  HTMLOptionElement,
+  HTMLOptionsCollection,
+  HTMLOutputElement,
+  HTMLParagraphElement,
+  HTMLParamElement,
+  HTMLPictureElement,
+  HTMLPreElement,
+  HTMLProgressElement,
+  HTMLQuoteElement,
+  HTMLScriptElement,
+  HTMLSelectElement,
+  HTMLShadowElement,
+  HTMLSourceElement,
+  HTMLSpanElement,
+  HTMLStyleElement,
+  HTMLTableCaptionElement,
+  HTMLTableCellElement,
+  HTMLTableColElement,
+  HTMLTableElement,
+  HTMLTableRowElement,
+  HTMLTableSectionElement,
+  HTMLTemplateElement,
+  HTMLTextAreaElement,
+  HTMLTimeElement,
+  HTMLTitleElement,
+  HTMLTrackElement,
+  HTMLUListElement,
+  HTMLUnknownElement,
+  HTMLVideoElement,
+  HashChangeEvent,
+  Headers,
+  HeadersIterator,
+  HeapSnapshot,
+  HiddenPluginEvent,
+  History,
+  IDBCursor,
+  IDBCursorWithValue,
+  IDBDatabase,
+  IDBFactory,
+  IDBFileHandle,
+  IDBFileRequest,
+  IDBIndex,
+  IDBKeyRange,
+  IDBLocaleAwareKeyRange,
+  IDBMutableFile,
+  IDBObjectStore,
+  IDBOpenDBRequest,
+  IDBRequest,
+  IDBTransaction,
+  IDBVersionChangeEvent,
+  IIRFilterNode,
+  IdleDeadline,
+  ImageBitmap,
+  ImageBitmapRenderingContext,
+  ImageCapture,
+  ImageCaptureError,
+  ImageCaptureErrorEvent,
+  ImageData,
+  ImageDocument,
+  InputEvent,
+  InstallTriggerImpl,
+  IntersectionObserver,
+  IntersectionObserverEntry,
+  IntlUtils,
+  KeyboardEvent,
+  KeyframeEffect,
+  KeyframeEffectReadOnly,
+  LegacyMozTCPSocket,
+  ListBoxObject,
+  LocalMediaStream,
+  Location,
+  MOZ_debug_get,
+  MediaDeviceInfo,
+  MediaDevices,
+  MediaElementAudioSourceNode,
+  MediaEncryptedEvent,
+  MediaError,
+  MediaKeyError,
+  MediaKeyMessageEvent,
+  MediaKeySession,
+  MediaKeyStatusMap,
+  MediaKeyStatusMapIterator,
+  MediaKeySystemAccess,
+  MediaKeys,
+  MediaList,
+  MediaQueryList,
+  MediaRecorder,
+  MediaSource,
+  MediaStream,
+  MediaStreamAudioDestinationNode,
+  MediaStreamAudioSourceNode,
+  MediaStreamError,
+  MediaStreamEvent,
+  MediaStreamList,
+  MediaStreamTrack,
+  MediaStreamTrackEvent,
+  MenuBoxObject,
+  MessageChannel,
+  MessageEvent,
+  MessagePort,
+  MimeType,
+  MimeTypeArray,
+  MouseEvent,
+  MouseScrollEvent,
+  MozCanvasPrintState,
+  MozPowerManager,
+  MozSelfSupport,
+  MozTimeManager,
+  MozWakeLock,
+  MutationEvent,
+  MutationObserver,
+  MutationRecord,
+  NamedNodeMap,
+  Navigator,
+  NetworkInformation,
+  Node,
+  NodeIterator,
+  NodeList,
+  Notification,
+  NotificationEvent,
+  NotifyPaintEvent,
+  OES_element_index_uint,
+  OES_standard_derivatives,
+  OES_texture_float,
+  OES_texture_float_linear,
+  OES_texture_half_float,
+  OES_texture_half_float_linear,
+  OES_vertex_array_object,
+  OfflineAudioCompletionEvent,
+  OfflineAudioContext,
+  OfflineResourceList,
+  OffscreenCanvas,
+  OnlyForUseInConstructor,
+  OscillatorNode,
+  PageTransitionEvent,
+  PaintRequest,
+  PaintRequestList,
+  PaintWorkletGlobalScope,
+  PannerNode,
+  Path2D,
+  PeerConnectionImpl,
+  PeerConnectionObserver,
+  Performance,
+  PerformanceEntry,
+  PerformanceEntryEvent,
+  PerformanceMark,
+  PerformanceMeasure,
+  PerformanceNavigation,
+  PerformanceObserver,
+  PerformanceObserverEntryList,
+  PerformanceResourceTiming,
+  PerformanceTiming,
+  PeriodicWave,
+  PermissionStatus,
+  Permissions,
+  Plugin,
+  PluginArray,
+  PluginCrashedEvent,
+  PointerEvent,
+  PopStateEvent,
+  PopupBlockedEvent,
+  PopupBoxObject,
+  Position,
+  PositionError,
+  PrecompiledScript,
+  Presentation,
+  PresentationAvailability,
+  PresentationConnection,
+  PresentationConnectionAvailableEvent,
+  PresentationConnectionCloseEvent,
+  PresentationConnectionList,
+  PresentationDeviceInfoManager,
+  PresentationReceiver,
+  PresentationRequest,
+  ProcessingInstruction,
+  ProgressEvent,
+  PromiseNativeHandler,
+  PushEvent,
+  PushManager,
+  PushManagerImpl,
+  PushMessageData,
+  PushSubscription,
+  PushSubscriptionOptions,
+  RGBColor,
+  RTCCertificate,
+  RTCDTMFSender,
+  RTCDTMFToneChangeEvent,
+  RTCDataChannelEvent,
+  RTCIceCandidate,
+  RTCIdentityProviderRegistrar,
+  RTCPeerConnection,
+  RTCPeerConnectionIceEvent,
+  RTCPeerConnectionStatic,
+  RTCRtpReceiver,
+  RTCRtpSender,
+  RTCSessionDescription,
+  RTCStatsReport,
+  RTCTrackEvent,
+  RadioNodeList,
+  Range,
+  RecordErrorEvent,
+  Rect,
+  Request,
+  Response,
+  SEChannel,
+  SEManager,
+  SEReader,
+  SEResponse,
+  SESession,
+  SVGAElement,
+  SVGAngle,
+  SVGAnimateElement,
+  SVGAnimateMotionElement,
+  SVGAnimateTransformElement,
+  SVGAnimatedAngle,
+  SVGAnimatedBoolean,
+  SVGAnimatedEnumeration,
+  SVGAnimatedInteger,
+  SVGAnimatedLength,
+  SVGAnimatedLengthList,
+  SVGAnimatedNumber,
+  SVGAnimatedNumberList,
+  SVGAnimatedPreserveAspectRatio,
+  SVGAnimatedRect,
+  SVGAnimatedString,
+  SVGAnimatedTransformList,
+  SVGAnimationElement,
+  SVGCircleElement,
+  SVGClipPathElement,
+  SVGComponentTransferFunctionElement,
+  SVGDefsElement,
+  SVGDescElement,
+  SVGElement,
+  SVGEllipseElement,
+  SVGFEBlendElement,
+  SVGFEColorMatrixElement,
+  SVGFEComponentTransferElement,
+  SVGFECompositeElement,
+  SVGFEConvolveMatrixElement,
+  SVGFEDiffuseLightingElement,
+  SVGFEDisplacementMapElement,
+  SVGFEDistantLightElement,
+  SVGFEDropShadowElement,
+  SVGFEFloodElement,
+  SVGFEFuncAElement,
+  SVGFEFuncBElement,
+  SVGFEFuncGElement,
+  SVGFEFuncRElement,
+  SVGFEGaussianBlurElement,
+  SVGFEImageElement,
+  SVGFEMergeElement,
+  SVGFEMergeNodeElement,
+  SVGFEMorphologyElement,
+  SVGFEOffsetElement,
+  SVGFEPointLightElement,
+  SVGFESpecularLightingElement,
+  SVGFESpotLightElement,
+  SVGFETileElement,
+  SVGFETurbulenceElement,
+  SVGFilterElement,
+  SVGForeignObjectElement,
+  SVGGElement,
+  SVGGeometryElement,
+  SVGGradientElement,
+  SVGGraphicsElement,
+  SVGImageElement,
+  SVGLength,
+  SVGLengthList,
+  SVGLineElement,
+  SVGLinearGradientElement,
+  SVGMPathElement,
+  SVGMarkerElement,
+  SVGMaskElement,
+  SVGMatrix,
+  SVGMetadataElement,
+  SVGNumber,
+  SVGNumberList,
+  SVGPathElement,
+  SVGPathSeg,
+  SVGPathSegArcAbs,
+  SVGPathSegArcRel,
+  SVGPathSegClosePath,
+  SVGPathSegCurvetoCubicAbs,
+  SVGPathSegCurvetoCubicRel,
+  SVGPathSegCurvetoCubicSmoothAbs,
+  SVGPathSegCurvetoCubicSmoothRel,
+  SVGPathSegCurvetoQuadraticAbs,
+  SVGPathSegCurvetoQuadraticRel,
+  SVGPathSegCurvetoQuadraticSmoothAbs,
+  SVGPathSegCurvetoQuadraticSmoothRel,
+  SVGPathSegLinetoAbs,
+  SVGPathSegLinetoHorizontalAbs,
+  SVGPathSegLinetoHorizontalRel,
+  SVGPathSegLinetoRel,
+  SVGPathSegLinetoVerticalAbs,
+  SVGPathSegLinetoVerticalRel,
+  SVGPathSegList,
+  SVGPathSegMovetoAbs,
+  SVGPathSegMovetoRel,
+  SVGPatternElement,
+  SVGPoint,
+  SVGPointList,
+  SVGPolygonElement,
+  SVGPolylineElement,
+  SVGPreserveAspectRatio,
+  SVGRadialGradientElement,
+  SVGRect,
+  SVGRectElement,
+  SVGSVGElement,
+  SVGScriptElement,
+  SVGSetElement,
+  SVGStopElement,
+  SVGStringList,
+  SVGStyleElement,
+  SVGSwitchElement,
+  SVGSymbolElement,
+  SVGTSpanElement,
+  SVGTextContentElement,
+  SVGTextElement,
+  SVGTextPathElement,
+  SVGTextPositioningElement,
+  SVGTitleElement,
+  SVGTransform,
+  SVGTransformList,
+  SVGUseElement,
+  SVGViewElement,
+  ScopedCredential,
+  ScopedCredentialInfo,
+  Screen,
+  ScreenOrientation,
+  ScriptProcessorNode,
+  ScrollAreaEvent,
+  ScrollBoxObject,
+  ScrollViewChangeEvent,
+  Selection,
+  ServiceWorker,
+  ServiceWorkerContainer,
+  ServiceWorkerGlobalScope,
+  ServiceWorkerRegistration,
+  ShadowRoot,
+  SharedWorker,
+  SharedWorkerGlobalScope,
+  SimpleGestureEvent,
+  SourceBuffer,
+  SourceBufferList,
+  SpeechGrammar,
+  SpeechGrammarList,
+  SpeechRecognition,
+  SpeechRecognitionAlternative,
+  SpeechRecognitionError,
+  SpeechRecognitionEvent,
+  SpeechRecognitionResult,
+  SpeechRecognitionResultList,
+  SpeechSynthesis,
+  SpeechSynthesisErrorEvent,
+  SpeechSynthesisEvent,
+  SpeechSynthesisUtterance,
+  SpeechSynthesisVoice,
+  StereoPannerNode,
+  Storage,
+  StorageEvent,
+  StorageManager,
+  StyleRuleChangeEvent,
+  StyleSheet,
+  StyleSheetApplicableStateChangeEvent,
+  StyleSheetChangeEvent,
+  StyleSheetList,
+  SubtleCrypto,
+  TCPServerSocket,
+  TCPServerSocketEvent,
+  TCPSocket,
+  TCPSocketErrorEvent,
+  TCPSocketEvent,
+  TestCImplementedInterface,
+  TestCImplementedInterface2,
+  TestChildInterface,
+  TestCppKeywordNamedMethodsInterface,
+  TestDeprecatedInterface,
+  TestExampleInterface,
+  TestExampleProxyInterface,
+  TestExampleWorkerInterface,
+  TestFunctions,
+  TestHTMLConstructorInterface,
+  TestIndexedAndNamedGetterAndSetterInterface,
+  TestIndexedAndNamedGetterInterface,
+  TestIndexedAndNamedSetterInterface,
+  TestIndexedGetterAndSetterAndNamedGetterInterface,
+  TestIndexedGetterInterface,
+  TestIndexedSetterInterface,
+  TestInterface,
+  TestInterfaceIterableDouble,
+  TestInterfaceIterableDoubleIterator,
+  TestInterfaceIterableDoubleUnion,
+  TestInterfaceIterableDoubleUnionIterator,
+  TestInterfaceIterableSingle,
+  TestInterfaceJS,
+  TestInterfaceJSMaplike,
+  TestInterfaceMaplike,
+  TestInterfaceMaplikeObject,
+  TestInterfaceSetlike,
+  TestInterfaceSetlikeNode,
+  TestInterfaceWithPromiseConstructorArg,
+  TestJSImplInterface,
+  TestJSImplInterface2,
+  TestJSImplInterface3,
+  TestJSImplInterface4,
+  TestJSImplInterface5,
+  TestJSImplInterface6,
+  TestJSImplNoInterfaceObject,
+  TestNamedDeleterInterface,
+  TestNamedDeleterWithRetvalInterface,
+  TestNamedGetterInterface,
+  TestNamedSetterInterface,
+  TestNavigator,
+  TestNavigatorWithConstructor,
+  TestNonWrapperCacheInterface,
+  TestParentInterface,
+  TestRenamedInterface,
+  TestSecureContextInterface,
+  TestWorkerExposedInterface,
+  Text,
+  TextClause,
+  TextDecoder,
+  TextEncoder,
+  TextMetrics,
+  TextTrack,
+  TextTrackCue,
+  TextTrackCueList,
+  TextTrackList,
+  TimeEvent,
+  TimeRanges,
+  Touch,
+  TouchEvent,
+  TouchList,
+  TrackEvent,
+  TransitionEvent,
+  TreeBoxObject,
+  TreeColumn,
+  TreeColumns,
+  TreeWalker,
+  U2F,
+  UDPMessageEvent,
+  UDPSocket,
+  UIEvent,
+  URL,
+  URLSearchParams,
+  URLSearchParamsIterator,
+  UserProximityEvent,
+  VRDisplay,
+  VRDisplayCapabilities,
+  VRDisplayEvent,
+  VREyeParameters,
+  VRFieldOfView,
+  VRFrameData,
+  VRMockController,
+  VRMockDisplay,
+  VRPose,
+  VRServiceTest,
+  VRStageParameters,
+  VTTCue,
+  VTTRegion,
+  ValidityState,
+  VideoPlaybackQuality,
+  VideoStreamTrack,
+  VideoTrack,
+  VideoTrackList,
+  WEBGL_color_buffer_float,
+  WEBGL_compressed_texture_astc,
+  WEBGL_compressed_texture_atc,
+  WEBGL_compressed_texture_etc,
+  WEBGL_compressed_texture_etc1,
+  WEBGL_compressed_texture_pvrtc,
+  WEBGL_compressed_texture_s3tc,
+  WEBGL_debug_renderer_info,
+  WEBGL_debug_shaders,
+  WEBGL_depth_texture,
+  WEBGL_draw_buffers,
+  WEBGL_lose_context,
+  WaveShaperNode,
+  WebAuthentication,
+  WebAuthnAssertion,
+  WebAuthnAttestation,
+  WebGL2RenderingContext,
+  WebGLActiveInfo,
+  WebGLBuffer,
+  WebGLContextEvent,
+  WebGLFramebuffer,
+  WebGLProgram,
+  WebGLQuery,
+  WebGLRenderbuffer,
+  WebGLRenderingContext,
+  WebGLSampler,
+  WebGLShader,
+  WebGLShaderPrecisionFormat,
+  WebGLSync,
+  WebGLTexture,
+  WebGLTransformFeedback,
+  WebGLUniformLocation,
+  WebGLVertexArrayObject,
+  WebKitCSSMatrix,
+  WebSocket,
+  WheelEvent,
+  Window,
+  WindowClient,
+  WindowRoot,
+  Worker,
+  WorkerDebuggerGlobalScope,
+  WorkerGlobalScope,
+  WorkerLocation,
+  WorkerNavigator,
+  Worklet,
+  WorkletGlobalScope,
+  XMLDocument,
+  XMLHttpRequest,
+  XMLHttpRequestEventTarget,
+  XMLHttpRequestUpload,
+  XMLSerializer,
+  XMLStylesheetProcessingInstruction,
+  XPathEvaluator,
+  XPathExpression,
+  XPathResult,
+  XSLTProcessor,
+  XULCommandEvent,
+  XULDocument,
+  XULElement,
+  mozRTCIceCandidate,
+  mozRTCPeerConnection,
+  mozRTCSessionDescription,
+  _ID_Count
+};
+
+}
+
+typedef id::ID ID;
+
+static_assert(id::_ID_Count < (uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->protoID) * 8)), "Too many prototypes!");
+
+}
+}
+}
+
+
+
+static_assert(8 < (uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->depth) * 8)), "Some inheritance chain is too long!");
+
+namespace mozilla {
+namespace dom {
+namespace constructors {
+
+namespace id {
+
+enum ID : uint16_t
+{
+  _ID_Start = prototypes::id::_ID_Count,
+  AccessibleNode = _ID_Start,
+  Addon,
+  AddonEvent,
+  AddonInstall,
+  AddonManager,
+  AddonManagerPermissions,
+  AnalyserNode,
+  Animation,
+  AnimationEffectReadOnly,
+  AnimationEffectTiming,
+  AnimationEffectTimingReadOnly,
+  AnimationEvent,
+  AnimationPlaybackEvent,
+  AnimationTimeline,
+  AnonymousContent,
+  Attr,
+  AudioBuffer,
+  AudioBufferSourceNode,
+  AudioContext,
+  AudioDestinationNode,
+  AudioListener,
+  AudioNode,
+  AudioParam,
+  AudioProcessingEvent,
+  AudioScheduledSourceNode,
+  AudioStreamTrack,
+  AudioTrack,
+  AudioTrackList,
+  AudioWorkletGlobalScope,
+  AutocompleteErrorEvent,
+  BarProp,
+  BaseAudioContext,
+  BatteryManager,
+  BeforeUnloadEvent,
+  BiquadFilterNode,
+  Blob,
+  BlobEvent,
+  BoxObject,
+  BroadcastChannel,
+  BrowserElementAudioChannel,
+  BrowserFeedWriter,
+  CDATASection,
+  CSS,
+  CSS2Properties,
+  CSSAnimation,
+  CSSConditionRule,
+  CSSCounterStyleRule,
+  CSSFontFaceRule,
+  CSSFontFeatureValuesRule,
+  CSSGroupingRule,
+  CSSImportRule,
+  CSSKeyframeRule,
+  CSSKeyframesRule,
+  CSSLexer,
+  CSSMediaRule,
+  CSSMozDocumentRule,
+  CSSNamespaceRule,
+  CSSPageRule,
+  CSSPrimitiveValue,
+  CSSPseudoElement,
+  CSSRule,
+  CSSRuleList,
+  CSSStyleDeclaration,
+  CSSStyleRule,
+  CSSStyleSheet,
+  CSSSupportsRule,
+  CSSTransition,
+  CSSValue,
+  CSSValueList,
+  Cache,
+  CacheStorage,
+  CanvasCaptureMediaStream,
+  CanvasGradient,
+  CanvasPattern,
+  CanvasRenderingContext2D,
+  CaretPosition,
+  CaretStateChangedEvent,
+  ChannelMergerNode,
+  ChannelSplitterNode,
+  CharacterData,
+  CheckerboardReportService,
+  ChromeNodeList,
+  ChromeUtils,
+  ChromeWindow,
+  ChromeWorker,
+  Client,
+  Clients,
+  ClipboardEvent,
+  CloseEvent,
+  CommandEvent,
+  Comment,
+  CompositionEvent,
+  ConstantSourceNode,
+  ConvolverNode,
+  CreateOfferRequest,
+  Crypto,
+  CryptoKey,
+  CustomElementRegistry,
+  CustomEvent,
+  DOMCursor,
+  DOMError,
+  DOMException,
+  DOMImplementation,
+  DOMMatrix,
+  DOMMatrixReadOnly,
+  DOMParser,
+  DOMPoint,
+  DOMPointReadOnly,
+  DOMQuad,
+  DOMRect,
+  DOMRectList,
+  DOMRectReadOnly,
+  DOMRequest,
+  DOMStringList,
+  DOMStringMap,
+  DOMTokenList,
+  DataChannel,
+  DataContainerEvent,
+  DataTransfer,
+  DataTransferItem,
+  DataTransferItemList,
+  DedicatedWorkerGlobalScope,
+  DelayNode,
+  DesktopNotification,
+  DesktopNotificationCenter,
+  DeviceLightEvent,
+  DeviceMotionEvent,
+  DeviceOrientationEvent,
+  DeviceProximityEvent,
+  Directory,
+  Document,
+  DocumentFragment,
+  DocumentTimeline,
+  DocumentType,
+  DominatorTree,
+  DragEvent,
+  DynamicsCompressorNode,
+  Element,
+  ErrorEvent,
+  Event,
+  EventSource,
+  EventTarget,
+  ExtendableEvent,
+  ExtendableMessageEvent,
+  External,
+  FetchController,
+  FetchEvent,
+  FetchObserver,
+  FetchSignal,
+  File,
+  FileList,
+  FileReader,
+  FileReaderSync,
+  FileSystem,
+  FileSystemDirectoryEntry,
+  FileSystemDirectoryReader,
+  FileSystemEntry,
+  FileSystemFileEntry,
+  FlyWebDiscoveryManager,
+  FlyWebFetchEvent,
+  FlyWebPublishedServer,
+  FlyWebWebSocketEvent,
+  FocusEvent,
+  FontFace,
+  FontFaceSet,
+  FontFaceSetLoadEvent,
+  FormData,
+  GainNode,
+  Gamepad,
+  GamepadAxisMoveEvent,
+  GamepadButton,
+  GamepadButtonEvent,
+  GamepadEvent,
+  GamepadHapticActuator,
+  GamepadPose,
+  GamepadServiceTest,
+  Grid,
+  GridArea,
+  GridDimension,
+  GridLine,
+  GridLines,
+  GridTrack,
+  GridTracks,
+  GroupedHistoryEvent,
+  HTMLAllCollection,
+  HTMLAnchorElement,
+  HTMLAppletElement,
+  HTMLAreaElement,
+  HTMLAudioElement,
+  HTMLBRElement,
+  HTMLBaseElement,
+  HTMLBodyElement,
+  HTMLButtonElement,
+  HTMLCanvasElement,
+  HTMLCollection,
+  HTMLContentElement,
+  HTMLDListElement,
+  HTMLDataElement,
+  HTMLDataListElement,
+  HTMLDetailsElement,
+  HTMLDialogElement,
+  HTMLDirectoryElement,
+  HTMLDivElement,
+  HTMLDocument,
+  HTMLElement,
+  HTMLEmbedElement,
+  HTMLFieldSetElement,
+  HTMLFontElement,
+  HTMLFormControlsCollection,
+  HTMLFormElement,
+  HTMLFrameElement,
+  HTMLFrameSetElement,
+  HTMLHRElement,
+  HTMLHeadElement,
+  HTMLHeadingElement,
+  HTMLHtmlElement,
+  HTMLIFrameElement,
+  HTMLImageElement,
+  HTMLInputElement,
+  HTMLLIElement,
+  HTMLLabelElement,
+  HTMLLegendElement,
+  HTMLLinkElement,
+  HTMLMapElement,
+  HTMLMediaElement,
+  HTMLMenuElement,
+  HTMLMenuItemElement,
+  HTMLMetaElement,
+  HTMLMeterElement,
+  HTMLModElement,
+  HTMLOListElement,
+  HTMLObjectElement,
+  HTMLOptGroupElement,
+  HTMLOptionElement,
+  HTMLOptionsCollection,
+  HTMLOutputElement,
+  HTMLParagraphElement,
+  HTMLParamElement,
+  HTMLPictureElement,
+  HTMLPreElement,
+  HTMLProgressElement,
+  HTMLQuoteElement,
+  HTMLScriptElement,
+  HTMLSelectElement,
+  HTMLShadowElement,
+  HTMLSourceElement,
+  HTMLSpanElement,
+  HTMLStyleElement,
+  HTMLTableCaptionElement,
+  HTMLTableCellElement,
+  HTMLTableColElement,
+  HTMLTableElement,
+  HTMLTableRowElement,
+  HTMLTableSectionElement,
+  HTMLTemplateElement,
+  HTMLTextAreaElement,
+  HTMLTimeElement,
+  HTMLTitleElement,
+  HTMLTrackElement,
+  HTMLUListElement,
+  HTMLUnknownElement,
+  HTMLVideoElement,
+  HashChangeEvent,
+  Headers,
+  HeapSnapshot,
+  HiddenPluginEvent,
+  History,
+  IDBCursor,
+  IDBCursorWithValue,
+  IDBDatabase,
+  IDBFactory,
+  IDBFileHandle,
+  IDBFileRequest,
+  IDBIndex,
+  IDBKeyRange,
+  IDBLocaleAwareKeyRange,
+  IDBMutableFile,
+  IDBObjectStore,
+  IDBOpenDBRequest,
+  IDBRequest,
+  IDBTransaction,
+  IDBVersionChangeEvent,
+  IIRFilterNode,
+  IdleDeadline,
+  ImageBitmap,
+  ImageBitmapRenderingContext,
+  ImageCapture,
+  ImageCaptureErrorEvent,
+  ImageData,
+  ImageDocument,
+  InputEvent,
+  InstallTriggerImpl,
+  IntersectionObserver,
+  IntersectionObserverEntry,
+  KeyEvent,
+  KeyboardEvent,
+  KeyframeEffect,
+  KeyframeEffectReadOnly,
+  LocalMediaStream,
+  Location,
+  MediaDeviceInfo,
+  MediaDevices,
+  MediaElementAudioSourceNode,
+  MediaEncryptedEvent,
+  MediaError,
+  MediaKeyError,
+  MediaKeyMessageEvent,
+  MediaKeySession,
+  MediaKeyStatusMap,
+  MediaKeySystemAccess,
+  MediaKeys,
+  MediaList,
+  MediaQueryList,
+  MediaRecorder,
+  MediaSource,
+  MediaStream,
+  MediaStreamAudioDestinationNode,
+  MediaStreamAudioSourceNode,
+  MediaStreamEvent,
+  MediaStreamList,
+  MediaStreamTrack,
+  MediaStreamTrackEvent,
+  MenuBoxObject,
+  MessageChannel,
+  MessageEvent,
+  MessagePort,
+  MimeType,
+  MimeTypeArray,
+  MouseEvent,
+  MouseScrollEvent,
+  MozCanvasPrintState,
+  MozPowerManager,
+  MozSelfSupport,
+  MozTimeManager,
+  MozWakeLock,
+  MutationEvent,
+  MutationObserver,
+  MutationRecord,
+  NamedNodeMap,
+  Navigator,
+  NetworkInformation,
+  Node,
+  NodeFilter,
+  NodeIterator,
+  NodeList,
+  Notification,
+  NotificationEvent,
+  NotifyPaintEvent,
+  OfflineAudioCompletionEvent,
+  OfflineAudioContext,
+  OfflineResourceList,
+  OffscreenCanvas,
+  OnlyForUseInConstructor,
+  OscillatorNode,
+  PageTransitionEvent,
+  PaintRequest,
+  PaintRequestList,
+  PaintWorkletGlobalScope,
+  PannerNode,
+  Path2D,
+  PeerConnectionImpl,
+  PeerConnectionObserver,
+  Performance,
+  PerformanceEntry,
+  PerformanceEntryEvent,
+  PerformanceMark,
+  PerformanceMeasure,
+  PerformanceNavigation,
+  PerformanceObserver,
+  PerformanceObserverEntryList,
+  PerformanceResourceTiming,
+  PerformanceTiming,
+  PeriodicWave,
+  PermissionStatus,
+  Permissions,
+  Plugin,
+  PluginArray,
+  PluginCrashedEvent,
+  PointerEvent,
+  PopStateEvent,
+  PopupBlockedEvent,
+  PopupBoxObject,
+  PrecompiledScript,
+  Presentation,
+  PresentationAvailability,
+  PresentationConnection,
+  PresentationConnectionAvailableEvent,
+  PresentationConnectionCloseEvent,
+  PresentationConnectionList,
+  PresentationDeviceInfoManager,
+  PresentationReceiver,
+  PresentationRequest,
+  ProcessingInstruction,
+  ProgressEvent,
+  PromiseDebugging,
+  PushEvent,
+  PushManager,
+  PushManagerImpl,
+  PushMessageData,
+  PushSubscription,
+  PushSubscriptionOptions,
+  RGBColor,
+  RTCCertificate,
+  RTCDTMFSender,
+  RTCDTMFToneChangeEvent,
+  RTCDataChannelEvent,
+  RTCIceCandidate,
+  RTCPeerConnection,
+  RTCPeerConnectionIceEvent,
+  RTCPeerConnectionStatic,
+  RTCRtpReceiver,
+  RTCRtpSender,
+  RTCSessionDescription,
+  RTCStatsReport,
+  RTCTrackEvent,
+  RadioNodeList,
+  Range,
+  RecordErrorEvent,
+  Rect,
+  Request,
+  Response,
+  SEChannel,
+  SEReader,
+  SEResponse,
+  SESession,
+  SVGAElement,
+  SVGAngle,
+  SVGAnimateElement,
+  SVGAnimateMotionElement,
+  SVGAnimateTransformElement,
+  SVGAnimatedAngle,
+  SVGAnimatedBoolean,
+  SVGAnimatedEnumeration,
+  SVGAnimatedInteger,
+  SVGAnimatedLength,
+  SVGAnimatedLengthList,
+  SVGAnimatedNumber,
+  SVGAnimatedNumberList,
+  SVGAnimatedPreserveAspectRatio,
+  SVGAnimatedRect,
+  SVGAnimatedString,
+  SVGAnimatedTransformList,
+  SVGAnimationElement,
+  SVGCircleElement,
+  SVGClipPathElement,
+  SVGComponentTransferFunctionElement,
+  SVGDefsElement,
+  SVGDescElement,
+  SVGElement,
+  SVGEllipseElement,
+  SVGFEBlendElement,
+  SVGFEColorMatrixElement,
+  SVGFEComponentTransferElement,
+  SVGFECompositeElement,
+  SVGFEConvolveMatrixElement,
+  SVGFEDiffuseLightingElement,
+  SVGFEDisplacementMapElement,
+  SVGFEDistantLightElement,
+  SVGFEDropShadowElement,
+  SVGFEFloodElement,
+  SVGFEFuncAElement,
+  SVGFEFuncBElement,
+  SVGFEFuncGElement,
+  SVGFEFuncRElement,
+  SVGFEGaussianBlurElement,
+  SVGFEImageElement,
+  SVGFEMergeElement,
+  SVGFEMergeNodeElement,
+  SVGFEMorphologyElement,
+  SVGFEOffsetElement,
+  SVGFEPointLightElement,
+  SVGFESpecularLightingElement,
+  SVGFESpotLightElement,
+  SVGFETileElement,
+  SVGFETurbulenceElement,
+  SVGFilterElement,
+  SVGForeignObjectElement,
+  SVGGElement,
+  SVGGeometryElement,
+  SVGGradientElement,
+  SVGGraphicsElement,
+  SVGImageElement,
+  SVGLength,
+  SVGLengthList,
+  SVGLineElement,
+  SVGLinearGradientElement,
+  SVGMPathElement,
+  SVGMarkerElement,
+  SVGMaskElement,
+  SVGMatrix,
+  SVGMetadataElement,
+  SVGNumber,
+  SVGNumberList,
+  SVGPathElement,
+  SVGPathSeg,
+  SVGPathSegArcAbs,
+  SVGPathSegArcRel,
+  SVGPathSegClosePath,
+  SVGPathSegCurvetoCubicAbs,
+  SVGPathSegCurvetoCubicRel,
+  SVGPathSegCurvetoCubicSmoothAbs,
+  SVGPathSegCurvetoCubicSmoothRel,
+  SVGPathSegCurvetoQuadraticAbs,
+  SVGPathSegCurvetoQuadraticRel,
+  SVGPathSegCurvetoQuadraticSmoothAbs,
+  SVGPathSegCurvetoQuadraticSmoothRel,
+  SVGPathSegLinetoAbs,
+  SVGPathSegLinetoHorizontalAbs,
+  SVGPathSegLinetoHorizontalRel,
+  SVGPathSegLinetoRel,
+  SVGPathSegLinetoVerticalAbs,
+  SVGPathSegLinetoVerticalRel,
+  SVGPathSegList,
+  SVGPathSegMovetoAbs,
+  SVGPathSegMovetoRel,
+  SVGPatternElement,
+  SVGPoint,
+  SVGPointList,
+  SVGPolygonElement,
+  SVGPolylineElement,
+  SVGPreserveAspectRatio,
+  SVGRadialGradientElement,
+  SVGRect,
+  SVGRectElement,
+  SVGSVGElement,
+  SVGScriptElement,
+  SVGSetElement,
+  SVGStopElement,
+  SVGStringList,
+  SVGStyleElement,
+  SVGSwitchElement,
+  SVGSymbolElement,
+  SVGTSpanElement,
+  SVGTextContentElement,
+  SVGTextElement,
+  SVGTextPathElement,
+  SVGTextPositioningElement,
+  SVGTitleElement,
+  SVGTransform,
+  SVGTransformList,
+  SVGUnitTypes,
+  SVGUseElement,
+  SVGViewElement,
+  SVGZoomAndPan,
+  ScopedCredential,
+  ScopedCredentialInfo,
+  Screen,
+  ScreenOrientation,
+  ScriptProcessorNode,
+  ScrollAreaEvent,
+  ScrollViewChangeEvent,
+  Selection,
+  ServiceWorker,
+  ServiceWorkerContainer,
+  ServiceWorkerGlobalScope,
+  ServiceWorkerRegistration,
+  ShadowRoot,
+  SharedWorker,
+  SharedWorkerGlobalScope,
+  SimpleGestureEvent,
+  SourceBuffer,
+  SourceBufferList,
+  SpeechGrammar,
+  SpeechGrammarList,
+  SpeechRecognition,
+  SpeechRecognitionAlternative,
+  SpeechRecognitionError,
+  SpeechRecognitionEvent,
+  SpeechRecognitionResult,
+  SpeechRecognitionResultList,
+  SpeechSynthesis,
+  SpeechSynthesisErrorEvent,
+  SpeechSynthesisEvent,
+  SpeechSynthesisUtterance,
+  SpeechSynthesisVoice,
+  StereoPannerNode,
+  Storage,
+  StorageEvent,
+  StorageManager,
+  StyleRuleChangeEvent,
+  StyleSheet,
+  StyleSheetApplicableStateChangeEvent,
+  StyleSheetChangeEvent,
+  StyleSheetList,
+  SubtleCrypto,
+  TCPServerSocket,
+  TCPServerSocketEvent,
+  TCPSocket,
+  TCPSocketErrorEvent,
+  TCPSocketEvent,
+  TestCImplementedInterface,
+  TestCImplementedInterface2,
+  TestChildInterface,
+  TestCppKeywordNamedMethodsInterface,
+  TestDeprecatedInterface,
+  TestExampleInterface,
+  TestExampleProxyInterface,
+  TestExampleWorkerInterface,
+  TestFunctions,
+  TestHTMLConstructorInterface,
+  TestIndexedAndNamedGetterAndSetterInterface,
+  TestIndexedAndNamedGetterInterface,
+  TestIndexedAndNamedSetterInterface,
+  TestIndexedGetterAndSetterAndNamedGetterInterface,
+  TestIndexedGetterInterface,
+  TestIndexedSetterInterface,
+  TestInterface,
+  TestInterfaceIterableDouble,
+  TestInterfaceIterableDoubleUnion,
+  TestInterfaceIterableSingle,
+  TestInterfaceJS,
+  TestInterfaceJSMaplike,
+  TestInterfaceMaplike,
+  TestInterfaceMaplikeObject,
+  TestInterfaceSetlike,
+  TestInterfaceSetlikeNode,
+  TestInterfaceWithPromiseConstructorArg,
+  TestJSImplInterface,
+  TestJSImplInterface2,
+  TestJSImplInterface3,
+  TestJSImplInterface4,
+  TestJSImplInterface5,
+  TestJSImplInterface6,
+  TestNamedDeleterInterface,
+  TestNamedDeleterWithRetvalInterface,
+  TestNamedGetterInterface,
+  TestNamedSetterInterface,
+  TestNamespace,
+  TestNavigator,
+  TestNavigatorWithConstructor,
+  TestNonWrapperCacheInterface,
+  TestParentInterface,
+  TestProtoObjectHackedNamespace,
+  TestRenamedInterface,
+  TestRenamedNamespace,
+  TestSecureContextInterface,
+  TestWorkerExposedInterface,
+  Text,
+  TextClause,
+  TextDecoder,
+  TextEncoder,
+  TextMetrics,
+  TextTrack,
+  TextTrackCue,
+  TextTrackCueList,
+  TextTrackList,
+  ThreadSafeChromeUtils,
+  TimeEvent,
+  TimeRanges,
+  Touch,
+  TouchEvent,
+  TouchList,
+  TrackEvent,
+  TransitionEvent,
+  TreeColumn,
+  TreeColumns,
+  TreeWalker,
+  U2F,
+  UDPMessageEvent,
+  UDPSocket,
+  UIEvent,
+  URL,
+  URLSearchParams,
+  UserProximityEvent,
+  VRDisplay,
+  VRDisplayCapabilities,
+  VRDisplayEvent,
+  VREyeParameters,
+  VRFieldOfView,
+  VRFrameData,
+  VRMockController,
+  VRMockDisplay,
+  VRPose,
+  VRServiceTest,
+  VRStageParameters,
+  VTTCue,
+  VTTRegion,
+  ValidityState,
+  VideoPlaybackQuality,
+  VideoStreamTrack,
+  VideoTrack,
+  VideoTrackList,
+  WaveShaperNode,
+  WebAuthentication,
+  WebAuthnAssertion,
+  WebAuthnAttestation,
+  WebGL2RenderingContext,
+  WebGLActiveInfo,
+  WebGLBuffer,
+  WebGLContextEvent,
+  WebGLFramebuffer,
+  WebGLProgram,
+  WebGLQuery,
+  WebGLRenderbuffer,
+  WebGLRenderingContext,
+  WebGLSampler,
+  WebGLShader,
+  WebGLShaderPrecisionFormat,
+  WebGLSync,
+  WebGLTexture,
+  WebGLTransformFeedback,
+  WebGLUniformLocation,
+  WebGLVertexArrayObject,
+  WebKitCSSMatrix,
+  WebSocket,
+  WebrtcGlobalInformation,
+  WheelEvent,
+  Window,
+  WindowClient,
+  WindowRoot,
+  Worker,
+  WorkerDebuggerGlobalScope,
+  WorkerGlobalScope,
+  WorkerLocation,
+  WorkerNavigator,
+  Worklet,
+  WorkletGlobalScope,
+  XMLDocument,
+  XMLHttpRequest,
+  XMLHttpRequestEventTarget,
+  XMLHttpRequestUpload,
+  XMLSerializer,
+  XMLStylesheetProcessingInstruction,
+  XPathEvaluator,
+  XPathExpression,
+  XPathResult,
+  XSLTProcessor,
+  XULCommandEvent,
+  XULDocument,
+  XULElement,
+  console,
+  mozRTCIceCandidate,
+  mozRTCPeerConnection,
+  mozRTCSessionDescription,
+  _ID_Count
+};
+
+}
+
+typedef id::ID ID;
+
+}
+}
+}
+
+namespace mozilla {
+namespace dom {
+namespace namedpropertiesobjects {
+
+namespace id {
+
+enum ID : uint16_t
+{
+  _ID_Start = constructors::id::_ID_Count,
+  Window = _ID_Start,
+  _ID_Count
+};
+
+}
+
+typedef id::ID ID;
+
+}
+}
+}
+
+namespace mozilla {
+namespace dom {
+template <prototypes::ID PrototypeID>
+struct PrototypeTraits;
+template <>
+struct PrototypeTraits<prototypes::id::ANGLE_instanced_arrays>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AccessibleNode>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Addon>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AddonEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AddonInstall>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AddonManager>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnalyserNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Animation>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationEffectReadOnly>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationEffectTiming>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationEffectTimingReadOnly>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationPlaybackEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnimationTimeline>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AnonymousContent>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Attr>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioBuffer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioBufferSourceNode>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioContext>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioDestinationNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioListener>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioNode>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioParam>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioProcessingEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioScheduledSourceNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioStreamTrack>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioTrack>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioTrackList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AudioWorkletGlobalScope>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::AutocompleteErrorEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BarProp>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BaseAudioContext>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BatteryManager>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BeforeUnloadEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BiquadFilterNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Blob>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BlobEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BoxObject>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BroadcastChannel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BrowserElementAudioChannel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::BrowserFeedWriter>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CDATASection>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSS2Properties>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSAnimation>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSConditionRule>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSCounterStyleRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSFontFaceRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSFontFeatureValuesRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSGroupingRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSImportRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSKeyframeRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSKeyframesRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSLexer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSMediaRule>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSMozDocumentRule>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSNamespaceRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSPageRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSPrimitiveValue>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSPseudoElement>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSRule>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSRuleList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSStyleDeclaration>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSStyleRule>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSStyleSheet>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSSupportsRule>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSTransition>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSValue>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CSSValueList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Cache>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CacheStorage>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CanvasCaptureMediaStream>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CanvasGradient>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CanvasPattern>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CanvasRenderingContext2D>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CaretPosition>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CaretStateChangedEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ChannelMergerNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ChannelSplitterNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CharacterData>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CheckerboardReportService>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ChromeNodeList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ChromeWorker>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Client>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Clients>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ClipboardEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CloseEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CommandEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Comment>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CompositionEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ConstantSourceNode>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ContainerBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ConvolverNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Coordinates>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CreateOfferRequest>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Crypto>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CryptoKey>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CustomElementRegistry>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::CustomEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMCursor>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMError>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMException>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMImplementation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMMatrix>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMMatrixReadOnly>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMParser>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMPoint>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMPointReadOnly>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMQuad>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMRect>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMRectList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMRectReadOnly>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMRequest>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMStringList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMStringMap>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DOMTokenList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DataChannel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DataContainerEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DataTransfer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DataTransferItem>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DataTransferItemList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DedicatedWorkerGlobalScope>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DelayNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DesktopNotification>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DesktopNotificationCenter>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceAcceleration>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceLightEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceMotionEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceOrientationEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceProximityEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DeviceRotationRate>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Directory>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Document>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DocumentFragment>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DocumentTimeline>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DocumentType>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DominatorTree>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DragEvent>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::DynamicsCompressorNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_blend_minmax>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_color_buffer_float>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_color_buffer_half_float>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_disjoint_timer_query>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_frag_depth>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_sRGB>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_shader_texture_lod>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EXT_texture_filter_anisotropic>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Element>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ErrorEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Event>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EventSource>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::EventTarget>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Exception>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ExtendableEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ExtendableMessageEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::External>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FetchController>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FetchEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FetchObserver>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FetchSignal>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::File>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileReader>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileReaderSync>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileSystem>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileSystemDirectoryEntry>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileSystemDirectoryReader>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileSystemEntry>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FileSystemFileEntry>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FlyWebDiscoveryManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FlyWebFetchEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FlyWebPublishedServer>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FlyWebWebSocketEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FocusEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FontFace>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FontFaceSet>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FontFaceSetIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FontFaceSetLoadEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FormData>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::FormDataIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GainNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Gamepad>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadAxisMoveEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadButton>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadButtonEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadHapticActuator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadPose>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GamepadServiceTest>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Geolocation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GetUserMediaRequest>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Grid>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridArea>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridDimension>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridLine>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridLines>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridTrack>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GridTracks>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::GroupedHistoryEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLAllCollection>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLAnchorElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLAppletElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLAreaElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLAudioElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLBRElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLBaseElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLBodyElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLButtonElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLCanvasElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLCollection>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLContentElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDListElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDataElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDataListElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDetailsElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDialogElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDirectoryElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDivElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLDocument>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLElement>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLEmbedElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFieldSetElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFontElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFormControlsCollection>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFormElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFrameElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLFrameSetElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLHRElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLHeadElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLHeadingElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLHtmlElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLIFrameElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLImageElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLInputElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLLIElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLLabelElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLLegendElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLLinkElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMapElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMediaElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMenuElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMenuItemElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMetaElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLMeterElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLModElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLOListElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLObjectElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLOptGroupElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLOptionElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLOptionsCollection>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLOutputElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLParagraphElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLParamElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLPictureElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLPreElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLProgressElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLQuoteElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLScriptElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLSelectElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLShadowElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLSourceElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLSpanElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLStyleElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableCaptionElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableCellElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableColElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableRowElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTableSectionElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTemplateElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTextAreaElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTimeElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTitleElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLTrackElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLUListElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLUnknownElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HTMLVideoElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HashChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Headers>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HeadersIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HeapSnapshot>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::HiddenPluginEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::History>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBCursor>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBCursorWithValue>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBDatabase>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBFactory>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBFileHandle>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBFileRequest>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBIndex>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBKeyRange>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBLocaleAwareKeyRange>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBMutableFile>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBObjectStore>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBOpenDBRequest>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBRequest>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBTransaction>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IDBVersionChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IIRFilterNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IdleDeadline>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageBitmap>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageBitmapRenderingContext>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageCapture>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageCaptureError>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageCaptureErrorEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageData>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ImageDocument>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::InputEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::InstallTriggerImpl>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IntersectionObserver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IntersectionObserverEntry>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::IntlUtils>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::KeyboardEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::KeyframeEffect>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::KeyframeEffectReadOnly>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::LegacyMozTCPSocket>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ListBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::LocalMediaStream>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Location>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MOZ_debug_get>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaDeviceInfo>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaDevices>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaElementAudioSourceNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaEncryptedEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaError>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeyError>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeyMessageEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeySession>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeyStatusMap>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeyStatusMapIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeySystemAccess>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaKeys>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaQueryList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaRecorder>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaSource>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStream>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamAudioDestinationNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamAudioSourceNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamError>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamTrack>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MediaStreamTrackEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MenuBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MessageChannel>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MessageEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MessagePort>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MimeType>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MimeTypeArray>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MouseEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MouseScrollEvent>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MozCanvasPrintState>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MozPowerManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MozSelfSupport>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MozTimeManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MozWakeLock>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MutationEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MutationObserver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::MutationRecord>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NamedNodeMap>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Navigator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NetworkInformation>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Node>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NodeIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NodeList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Notification>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NotificationEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::NotifyPaintEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_element_index_uint>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_standard_derivatives>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_texture_float>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_texture_float_linear>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_texture_half_float>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_texture_half_float_linear>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OES_vertex_array_object>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OfflineAudioCompletionEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OfflineAudioContext>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OfflineResourceList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OffscreenCanvas>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OnlyForUseInConstructor>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::OscillatorNode>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PageTransitionEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PaintRequest>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PaintRequestList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PaintWorkletGlobalScope>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PannerNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Path2D>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PeerConnectionImpl>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PeerConnectionObserver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Performance>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceEntry>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceEntryEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceMark>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceMeasure>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceNavigation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceObserver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceObserverEntryList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceResourceTiming>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PerformanceTiming>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PeriodicWave>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PermissionStatus>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Permissions>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Plugin>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PluginArray>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PluginCrashedEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PointerEvent>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PopStateEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PopupBlockedEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PopupBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Position>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PositionError>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PrecompiledScript>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Presentation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationAvailability>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationConnection>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationConnectionAvailableEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationConnectionCloseEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationConnectionList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationDeviceInfoManager>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationReceiver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PresentationRequest>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ProcessingInstruction>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ProgressEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PromiseNativeHandler>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushManagerImpl>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushMessageData>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushSubscription>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::PushSubscriptionOptions>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RGBColor>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCCertificate>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCDTMFSender>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCDTMFToneChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCDataChannelEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCIceCandidate>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCIdentityProviderRegistrar>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCPeerConnection>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCPeerConnectionIceEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCPeerConnectionStatic>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCRtpReceiver>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCRtpSender>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCSessionDescription>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCStatsReport>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RTCTrackEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RadioNodeList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Range>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::RecordErrorEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Rect>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Request>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Response>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SEChannel>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SEManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SEReader>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SEResponse>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SESession>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAngle>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimateElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimateMotionElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimateTransformElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedAngle>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedBoolean>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedEnumeration>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedInteger>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedLength>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedLengthList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedNumber>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedNumberList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedPreserveAspectRatio>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedRect>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedString>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimatedTransformList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGAnimationElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGCircleElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGClipPathElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGComponentTransferFunctionElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGDefsElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGDescElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGElement>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGEllipseElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEBlendElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEColorMatrixElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEComponentTransferElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFECompositeElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEConvolveMatrixElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEDiffuseLightingElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEDisplacementMapElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEDistantLightElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEDropShadowElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEFloodElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEFuncAElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEFuncBElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEFuncGElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEFuncRElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEGaussianBlurElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEImageElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEMergeElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEMergeNodeElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEMorphologyElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEOffsetElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFEPointLightElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFESpecularLightingElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFESpotLightElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFETileElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFETurbulenceElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGFilterElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGForeignObjectElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGGElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGGeometryElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGGradientElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGGraphicsElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGImageElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGLength>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGLengthList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGLineElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGLinearGradientElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGMPathElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGMarkerElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGMaskElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGMatrix>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGMetadataElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGNumber>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGNumberList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathElement>
+{
+  enum
+  {
+    Depth = 6
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSeg>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegArcAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegArcRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegClosePath>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicSmoothAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicSmoothRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticSmoothAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticSmoothRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoHorizontalAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoHorizontalRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoVerticalAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegLinetoVerticalRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegMovetoAbs>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPathSegMovetoRel>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPatternElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPoint>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPointList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPolygonElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPolylineElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGPreserveAspectRatio>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGRadialGradientElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGRect>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGRectElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGSVGElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGScriptElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGSetElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGStopElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGStringList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGStyleElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGSwitchElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGSymbolElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTSpanElement>
+{
+  enum
+  {
+    Depth = 7
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTextContentElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTextElement>
+{
+  enum
+  {
+    Depth = 7
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTextPathElement>
+{
+  enum
+  {
+    Depth = 6
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTextPositioningElement>
+{
+  enum
+  {
+    Depth = 6
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTitleElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTransform>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGTransformList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGUseElement>
+{
+  enum
+  {
+    Depth = 5
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SVGViewElement>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScopedCredential>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScopedCredentialInfo>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Screen>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScreenOrientation>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScriptProcessorNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScrollAreaEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScrollBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ScrollViewChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Selection>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ServiceWorker>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ServiceWorkerContainer>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ServiceWorkerGlobalScope>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ServiceWorkerRegistration>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ShadowRoot>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SharedWorker>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SharedWorkerGlobalScope>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SimpleGestureEvent>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SourceBuffer>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SourceBufferList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechGrammar>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechGrammarList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognition>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognitionAlternative>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognitionError>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognitionEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognitionResult>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechRecognitionResultList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechSynthesis>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechSynthesisErrorEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechSynthesisEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechSynthesisUtterance>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SpeechSynthesisVoice>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StereoPannerNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Storage>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StorageEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StorageManager>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StyleRuleChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StyleSheet>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StyleSheetApplicableStateChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StyleSheetChangeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::StyleSheetList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::SubtleCrypto>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TCPServerSocket>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TCPServerSocketEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TCPSocket>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TCPSocketErrorEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TCPSocketEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestCImplementedInterface>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestCImplementedInterface2>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestChildInterface>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestCppKeywordNamedMethodsInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestDeprecatedInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestExampleInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestExampleProxyInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestExampleWorkerInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestFunctions>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestHTMLConstructorInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedAndNamedGetterAndSetterInterface>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedAndNamedGetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedAndNamedSetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedGetterAndSetterAndNamedGetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedGetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestIndexedSetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceIterableDouble>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleUnion>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleUnionIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceIterableSingle>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceJS>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceJSMaplike>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceMaplike>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceMaplikeObject>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceSetlike>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceSetlikeNode>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestInterfaceWithPromiseConstructorArg>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface2>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface3>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface4>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface5>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplInterface6>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestJSImplNoInterfaceObject>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNamedDeleterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNamedDeleterWithRetvalInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNamedGetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNamedSetterInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNavigator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNavigatorWithConstructor>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestNonWrapperCacheInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestParentInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestRenamedInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestSecureContextInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TestWorkerExposedInterface>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Text>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextClause>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextDecoder>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextEncoder>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextMetrics>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextTrack>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextTrackCue>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextTrackCueList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TextTrackList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TimeEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TimeRanges>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Touch>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TouchEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TouchList>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TrackEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TransitionEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TreeBoxObject>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TreeColumn>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TreeColumns>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::TreeWalker>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::U2F>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::UDPMessageEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::UDPSocket>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::UIEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::URL>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::URLSearchParams>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::URLSearchParamsIterator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::UserProximityEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRDisplay>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRDisplayCapabilities>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRDisplayEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VREyeParameters>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRFieldOfView>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRFrameData>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRMockController>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRMockDisplay>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRPose>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRServiceTest>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VRStageParameters>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VTTCue>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VTTRegion>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::ValidityState>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VideoPlaybackQuality>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VideoStreamTrack>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VideoTrack>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::VideoTrackList>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_color_buffer_float>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_astc>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_atc>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_etc>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_etc1>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_pvrtc>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_s3tc>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_debug_renderer_info>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_debug_shaders>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_depth_texture>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_draw_buffers>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WEBGL_lose_context>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WaveShaperNode>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebAuthentication>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebAuthnAssertion>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebAuthnAttestation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGL2RenderingContext>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLActiveInfo>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLBuffer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLContextEvent>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLFramebuffer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLProgram>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLQuery>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLRenderbuffer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLRenderingContext>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLSampler>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLShader>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLShaderPrecisionFormat>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLSync>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLTexture>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLTransformFeedback>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLUniformLocation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebGLVertexArrayObject>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebKitCSSMatrix>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WebSocket>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WheelEvent>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Window>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WindowClient>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WindowRoot>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Worker>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WorkerDebuggerGlobalScope>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WorkerGlobalScope>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WorkerLocation>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WorkerNavigator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::Worklet>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::WorkletGlobalScope>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLDocument>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLHttpRequest>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLHttpRequestEventTarget>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLHttpRequestUpload>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLSerializer>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XMLStylesheetProcessingInstruction>
+{
+  enum
+  {
+    Depth = 4
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XPathEvaluator>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XPathExpression>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XPathResult>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XSLTProcessor>
+{
+  enum
+  {
+    Depth = 0
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XULCommandEvent>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XULDocument>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::XULElement>
+{
+  enum
+  {
+    Depth = 3
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::mozRTCIceCandidate>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::mozRTCPeerConnection>
+{
+  enum
+  {
+    Depth = 2
+  };
+};
+template <>
+struct PrototypeTraits<prototypes::id::mozRTCSessionDescription>
+{
+  enum
+  {
+    Depth = 1
+  };
+};
+extern const char *NamesOfInterfacesWithProtos(unsigned int aIndex);
+}
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h" 2
+
+
+
+class nsCycleCollectionParticipant;
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+namespace mozilla {
+namespace dom {
+# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+inline bool
+IsSecureContextOrObjectIsFromSecureContext(JSContext* aCx, JSObject* aObj)
+{
+  return JS::CompartmentCreationOptionsRef(js::GetContextCompartment(aCx)).secureContext() ||
+         JS::CompartmentCreationOptionsRef(js::GetObjectCompartment(aObj)).secureContext();
+}
+
+typedef bool
+(* ResolveOwnProperty)(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                       JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                       JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+typedef bool
+(* EnumerateOwnProperties)(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                           JS::Handle<JSObject*> obj,
+                           JS::AutoIdVector& props);
+
+typedef bool
+(* DeleteNamedProperty)(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                        JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                        JS::ObjectOpResult& opresult);
+
+
+
+bool
+IsNonExposedGlobal(JSContext* aCx, JSObject* aGlobal,
+                   uint32_t aNonExposedGlobals);
+
+struct ConstantSpec
+{
+  const char* name;
+  JS::Value value;
+};
+
+typedef bool (*PropertyEnabled)(JSContext* cx, JSObject* global);
+
+namespace GlobalNames {
+
+
+
+static const uint32_t Window = 1u << 0;
+static const uint32_t BackstagePass = 1u << 1;
+static const uint32_t DedicatedWorkerGlobalScope = 1u << 2;
+static const uint32_t SharedWorkerGlobalScope = 1u << 3;
+static const uint32_t ServiceWorkerGlobalScope = 1u << 4;
+static const uint32_t WorkerDebuggerGlobalScope = 1u << 5;
+static const uint32_t WorkletGlobalScope = 1u << 6;
+}
+
+struct PrefableDisablers {
+  inline bool isEnabled(JSContext* cx, JS::Handle<JSObject*> obj) const {
+# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+    if (nonExposedGlobals &&
+        IsNonExposedGlobal(cx, js::GetGlobalForObjectCrossCompartment(obj),
+                           nonExposedGlobals)) {
+      return false;
+    }
+    if (!enabled) {
+      return false;
+    }
+    if (secureContext && !IsSecureContextOrObjectIsFromSecureContext(cx, obj)) {
+      return false;
+    }
+    if (enabledFunc &&
+        !enabledFunc(cx, js::GetGlobalForObjectCrossCompartment(obj))) {
+      return false;
+    }
+    return true;
+  }
+
+
+
+  bool enabled;
+
+
+  const bool secureContext;
+
+
+  const uint16_t nonExposedGlobals;
+
+
+
+
+  const PropertyEnabled enabledFunc;
+};
+
+template<typename T>
+struct Prefable {
+  inline bool isEnabled(JSContext* cx, JS::Handle<JSObject*> obj) const {
+    if ((__builtin_expect(!!(!disablers), 1))) {
+      return true;
+    }
+    return disablers->isEnabled(cx, obj);
+  }
+
+
+
+  PrefableDisablers* const disablers;
+
+
+
+
+  const T* const specs;
+};
+# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+template <int N>
+struct NativePropertiesN {
+
+
+
+
+  struct Trio {
+    const void* const mPrefables;
+    const jsid* const mIds;
+    const void* const mSpecs;
+  };
+
+  const int32_t iteratorAliasMethodIndex;
+
+  constexpr const NativePropertiesN<7>* Upcast() const {
+    return reinterpret_cast<const NativePropertiesN<7>*>(this);
+  }
+# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+  public: const uint32_t mHasStaticMethods:1; const uint32_t mStaticMethodsOffset:3; private: const Trio* StaticMethodsTrio() const { do { } while (0); return &trios[mStaticMethodsOffset]; } public: bool HasStaticMethods() const { return mHasStaticMethods; } const Prefable<const JSFunctionSpec>* StaticMethods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( StaticMethodsTrio()->mPrefables); } const jsid* StaticMethodIds() const { return StaticMethodsTrio()->mIds; } const JSFunctionSpec* StaticMethodSpecs() const { return static_cast<const JSFunctionSpec*>( StaticMethodsTrio()->mSpecs); }
+  public: const uint32_t mHasStaticAttributes:1; const uint32_t mStaticAttributesOffset:3; private: const Trio* StaticAttributesTrio() const { do { } while (0); return &trios[mStaticAttributesOffset]; } public: bool HasStaticAttributes() const { return mHasStaticAttributes; } const Prefable<const JSPropertySpec>* StaticAttributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( StaticAttributesTrio()->mPrefables); } const jsid* StaticAttributeIds() const { return StaticAttributesTrio()->mIds; } const JSPropertySpec* StaticAttributeSpecs() const { return static_cast<const JSPropertySpec*>( StaticAttributesTrio()->mSpecs); }
+  public: const uint32_t mHasMethods:1; const uint32_t mMethodsOffset:3; private: const Trio* MethodsTrio() const { do { } while (0); return &trios[mMethodsOffset]; } public: bool HasMethods() const { return mHasMethods; } const Prefable<const JSFunctionSpec>* Methods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( MethodsTrio()->mPrefables); } const jsid* MethodIds() const { return MethodsTrio()->mIds; } const JSFunctionSpec* MethodSpecs() const { return static_cast<const JSFunctionSpec*>( MethodsTrio()->mSpecs); }
+  public: const uint32_t mHasAttributes:1; const uint32_t mAttributesOffset:3; private: const Trio* AttributesTrio() const { do { } while (0); return &trios[mAttributesOffset]; } public: bool HasAttributes() const { return mHasAttributes; } const Prefable<const JSPropertySpec>* Attributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( AttributesTrio()->mPrefables); } const jsid* AttributeIds() const { return AttributesTrio()->mIds; } const JSPropertySpec* AttributeSpecs() const { return static_cast<const JSPropertySpec*>( AttributesTrio()->mSpecs); }
+  public: const uint32_t mHasUnforgeableMethods:1; const uint32_t mUnforgeableMethodsOffset:3; private: const Trio* UnforgeableMethodsTrio() const { do { } while (0); return &trios[mUnforgeableMethodsOffset]; } public: bool HasUnforgeableMethods() const { return mHasUnforgeableMethods; } const Prefable<const JSFunctionSpec>* UnforgeableMethods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( UnforgeableMethodsTrio()->mPrefables); } const jsid* UnforgeableMethodIds() const { return UnforgeableMethodsTrio()->mIds; } const JSFunctionSpec* UnforgeableMethodSpecs() const { return static_cast<const JSFunctionSpec*>( UnforgeableMethodsTrio()->mSpecs); }
+  public: const uint32_t mHasUnforgeableAttributes:1; const uint32_t mUnforgeableAttributesOffset:3; private: const Trio* UnforgeableAttributesTrio() const { do { } while (0); return &trios[mUnforgeableAttributesOffset]; } public: bool HasUnforgeableAttributes() const { return mHasUnforgeableAttributes; } const Prefable<const JSPropertySpec>* UnforgeableAttributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( UnforgeableAttributesTrio()->mPrefables); } const jsid* UnforgeableAttributeIds() const { return UnforgeableAttributesTrio()->mIds; } const JSPropertySpec* UnforgeableAttributeSpecs() const { return static_cast<const JSPropertySpec*>( UnforgeableAttributesTrio()->mSpecs); }
+  public: const uint32_t mHasConstants:1; const uint32_t mConstantsOffset:3; private: const Trio* ConstantsTrio() const { do { } while (0); return &trios[mConstantsOffset]; } public: bool HasConstants() const { return mHasConstants; } const Prefable<const ConstantSpec>* Constants() const { return static_cast<const Prefable<const ConstantSpec>*> ( ConstantsTrio()->mPrefables); } const jsid* ConstantIds() const { return ConstantsTrio()->mIds; } const ConstantSpec* ConstantSpecs() const { return static_cast<const ConstantSpec*>( ConstantsTrio()->mSpecs); }
+
+
+
+  const Trio trios[N];
+};
+
+
+
+static_assert(sizeof(NativePropertiesN<1>) == 8 + 3*sizeof(void*), "1 size");
+static_assert(sizeof(NativePropertiesN<2>) == 8 + 6*sizeof(void*), "2 size");
+static_assert(sizeof(NativePropertiesN<3>) == 8 + 9*sizeof(void*), "3 size");
+static_assert(sizeof(NativePropertiesN<4>) == 8 + 12*sizeof(void*), "4 size");
+static_assert(sizeof(NativePropertiesN<5>) == 8 + 15*sizeof(void*), "5 size");
+static_assert(sizeof(NativePropertiesN<6>) == 8 + 18*sizeof(void*), "6 size");
+static_assert(sizeof(NativePropertiesN<7>) == 8 + 21*sizeof(void*), "7 size");
+
+
+typedef NativePropertiesN<7> NativeProperties;
+
+struct NativePropertiesHolder
+{
+  const NativeProperties* regular;
+  const NativeProperties* chromeOnly;
+};
+
+
+
+
+struct NativePropertyHooks
+{
+
+
+  ResolveOwnProperty mResolveOwnProperty;
+
+
+  EnumerateOwnProperties mEnumerateOwnProperties;
+# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+  DeleteNamedProperty mDeleteNamedProperty;
+
+
+  NativePropertiesHolder mNativeProperties;
+
+
+
+
+  prototypes::ID mPrototypeID;
+
+
+
+
+  constructors::ID mConstructorID;
+
+
+
+  const NativePropertyHooks* mProtoHooks;
+
+
+
+  const JSClass* mXrayExpandoClass;
+};
+
+enum DOMObjectType : uint8_t {
+  eInstance,
+  eGlobalInstance,
+  eInterface,
+  eInterfacePrototype,
+  eGlobalInterfacePrototype,
+  eNamedPropertiesObject
+};
+
+inline
+bool
+IsInstance(DOMObjectType type)
+{
+  return type == eInstance || type == eGlobalInstance;
+}
+
+inline
+bool
+IsInterfacePrototype(DOMObjectType type)
+{
+  return type == eInterfacePrototype || type == eGlobalInterfacePrototype;
+}
+
+typedef JSObject* (*AssociatedGlobalGetter)(JSContext* aCx,
+                                            JS::Handle<JSObject*> aObj);
+
+typedef JSObject* (*ProtoGetter)(JSContext* aCx);
+# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
+typedef JS::Handle<JSObject*> (*ProtoHandleGetter)(JSContext* aCx);
+
+
+struct DOMJSClass
+{
+
+
+
+  const js::Class mBase;
+
+
+
+  const prototypes::ID mInterfaceChain[8];
+
+
+
+
+
+  const bool mDOMObjectIsISupports;
+
+  const NativePropertyHooks* mNativeHooks;
+
+
+
+
+  AssociatedGlobalGetter mGetAssociatedGlobal;
+  ProtoHandleGetter mGetProto;
+
+
+
+
+  nsCycleCollectionParticipant* mParticipant;
+
+  static const DOMJSClass* FromJSClass(const JSClass* base) {
+    do { } while (0);
+    return reinterpret_cast<const DOMJSClass*>(base);
+  }
+
+  static const DOMJSClass* FromJSClass(const js::Class* base) {
+    return FromJSClass(Jsvalify(base));
+  }
+
+  const JSClass* ToJSClass() const { return Jsvalify(&mBase); }
+};
+
+
+struct DOMIfaceAndProtoJSClass
+{
+
+
+
+
+  const js::Class mBase;
+
+
+
+  DOMObjectType mType;
+
+
+
+
+  bool wantsInterfaceHasInstance;
+
+  const prototypes::ID mPrototypeID;
+  const uint32_t mDepth;
+
+  const NativePropertyHooks* mNativeHooks;
+
+
+
+  const char* mToString;
+
+  ProtoGetter mGetParentProto;
+
+  static const DOMIfaceAndProtoJSClass* FromJSClass(const JSClass* base) {
+    do { } while (0);
+    return reinterpret_cast<const DOMIfaceAndProtoJSClass*>(base);
+  }
+  static const DOMIfaceAndProtoJSClass* FromJSClass(const js::Class* base) {
+    return FromJSClass(Jsvalify(base));
+  }
+
+  const JSClass* ToJSClass() const { return Jsvalify(&mBase); }
+};
+
+class ProtoAndIfaceCache;
+
+inline bool
+DOMGlobalHasProtoAndIFaceCache(JSObject* global)
+{
+  do { } while (0);
+
+  return !js::GetReservedSlot(global, (5 + JSProto_LIMIT * 2 + 46)).isUndefined();
+}
+
+inline bool
+HasProtoAndIfaceCache(JSObject* global)
+{
+  if (!(js::GetObjectClass(global)->flags & (1<<7))) {
+    return false;
+  }
+  return DOMGlobalHasProtoAndIFaceCache(global);
+}
+
+inline ProtoAndIfaceCache*
+GetProtoAndIfaceCache(JSObject* global)
+{
+  do { } while (0);
+  return static_cast<ProtoAndIfaceCache*>(
+    js::GetReservedSlot(global, (5 + JSProto_LIMIT * 2 + 46)).toPrivate());
+}
+
+}
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
+namespace mozilla {
+namespace dom {
+
+enum {
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
+  JSPROXYSLOT_EXPANDO = 0
+};
+
+template<typename T> struct Prefable;
+
+class BaseDOMProxyHandler : public js::BaseProxyHandler
+{
+public:
+  explicit constexpr BaseDOMProxyHandler(const void* aProxyFamily, bool aHasPrototype = false)
+    : js::BaseProxyHandler(aProxyFamily, aHasPrototype)
+  {}
+
+
+
+  bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                JS::Handle<jsid> id,
+                                JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
+  virtual bool ownPropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
+                               JS::AutoIdVector &props) const override;
+
+  virtual bool getPrototypeIfOrdinary(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                      bool* isOrdinary,
+                                      JS::MutableHandle<JSObject*> proto) const override;
+
+
+
+
+
+  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                            JS::AutoIdVector &props) const override;
+
+  bool watch(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+             JS::Handle<JSObject*> callable) const override;
+  bool unwatch(JSContext* cx, JS::Handle<JSObject*> proxy,
+               JS::Handle<jsid> id) const override;
+
+protected:
+
+
+
+
+  virtual bool ownPropNames(JSContext* cx, JS::Handle<JSObject*> proxy,
+                            unsigned flags,
+                            JS::AutoIdVector& props) const = 0;
+
+
+
+
+
+  virtual bool getOwnPropDescriptor(JSContext* cx,
+                                    JS::Handle<JSObject*> proxy,
+                                    JS::Handle<jsid> id,
+                                    bool ignoreNamedProps,
+                                    JS::MutableHandle<JS::PropertyDescriptor> desc) const = 0;
+};
+
+class DOMProxyHandler : public BaseDOMProxyHandler
+{
+public:
+  constexpr DOMProxyHandler()
+    : BaseDOMProxyHandler(&family)
+  {}
+
+  bool defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+                      JS::Handle<JS::PropertyDescriptor> desc,
+                      JS::ObjectOpResult &result) const override
+  {
+    bool unused;
+    return defineProperty(cx, proxy, id, desc, result, &unused);
+  }
+  virtual bool defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+                              JS::Handle<JS::PropertyDescriptor> desc,
+                              JS::ObjectOpResult &result, bool *defined) const;
+  bool delete_(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+               JS::ObjectOpResult &result) const override;
+  bool preventExtensions(JSContext* cx, JS::Handle<JSObject*> proxy,
+                         JS::ObjectOpResult& result) const override;
+  bool isExtensible(JSContext *cx, JS::Handle<JSObject*> proxy, bool *extensible)
+                    const override;
+  bool set(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+           JS::Handle<JS::Value> v, JS::Handle<JS::Value> receiver, JS::ObjectOpResult &result)
+           const override;
+
+
+
+
+
+
+  virtual bool setCustom(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
+                         JS::Handle<JS::Value> v, bool *done) const;
+
+
+
+
+  static JSObject* GetExpandoObject(JSObject* obj);
+# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
+  static void ClearExternalRefsForWrapperRelease(JSObject* obj);
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
+  static JSObject* GetAndClearExpandoObject(JSObject* obj);
+
+
+
+
+
+  static JSObject* EnsureExpandoObject(JSContext* cx,
+                                       JS::Handle<JSObject*> obj);
+
+  static const char family;
+};
+
+
+
+class ShadowingDOMProxyHandler : public DOMProxyHandler
+{
+  virtual void trace(JSTracer* trc, JSObject* proxy) const override;
+};
+
+inline bool IsDOMProxy(JSObject *obj)
+{
+    const js::Class* clasp = js::GetObjectClass(obj);
+    return clasp->isProxy() &&
+           js::GetProxyHandler(obj)->family() == &DOMProxyHandler::family;
+}
+
+inline const DOMProxyHandler*
+GetDOMProxyHandler(JSObject* obj)
+{
+  do { } while (0);
+  return static_cast<const DOMProxyHandler*>(js::GetProxyHandler(obj));
+}
+
+extern jsid s_length_id;
+
+
+
+inline uint32_t
+GetArrayIndexFromId(JSContext* cx, JS::Handle<jsid> id)
+{
+
+
+
+  if ((__builtin_expect(!!(JSID_IS_INT(id)), 1))) {
+    return JSID_TO_INT(id);
+  }
+  if ((__builtin_expect(!!(id == s_length_id), 1))) {
+    return (4294967295U);
+  }
+  if ((__builtin_expect(!!(!JSID_IS_ATOM(id)), 0))) {
+    return (4294967295U);
+  }
+
+  JSLinearString* str = js::AtomToLinearString(JSID_TO_ATOM(id));
+  char16_t s;
+  {
+    JS::AutoCheckCannotGC nogc;
+    if (js::LinearStringHasLatin1Chars(str)) {
+      s = *js::GetLatin1LinearStringChars(nogc, str);
+    } else {
+      s = *js::GetTwoByteLinearStringChars(nogc, str);
+    }
+  }
+  if ((__builtin_expect(!!((unsigned)s >= 'a' && (unsigned)s <= 'z'), 1)))
+    return (4294967295U);
+
+  uint32_t i;
+  return js::StringIsArrayIndex(str, &i) ? i : (4294967295U);
+}
+
+inline bool
+IsArrayIndex(uint32_t index)
+{
+  return index < (4294967295U);
+}
+
+inline void
+FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
+                       JSObject* obj, bool readonly, bool enumerable = true)
+{
+  desc.object().set(obj);
+  desc.setAttributes((readonly ? 0x02 : 0) |
+                     (enumerable ? 0x01 : 0));
+  desc.setGetter(nullptr);
+  desc.setSetter(nullptr);
+}
+
+inline void
+FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
+                       JSObject* obj, const JS::Value& v,
+                       bool readonly, bool enumerable = true)
+{
+  desc.value().set(v);
+  FillPropertyDescriptor(desc, obj, readonly, enumerable);
+}
+
+inline void
+FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
+                       JSObject* obj, unsigned attributes, const JS::Value& v)
+{
+  desc.object().set(obj);
+  desc.value().set(v);
+  desc.setAttributes(attributes);
+  desc.setGetter(nullptr);
+  desc.setSetter(nullptr);
+}
+
+}
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h" 1
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h"
+class nsIStackFrame : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetLanguage(uint32_t *aLanguage) = 0;
+
+
+  virtual nsresult GetLanguageName(nsACString & aLanguageName) = 0;
+
+
+  virtual nsresult GetFilename(JSContext* cx, nsAString & aFilename) = 0;
+
+
+  virtual nsresult GetName(JSContext* cx, nsAString & aName) = 0;
+
+
+  virtual nsresult GetLineNumber(JSContext* cx, int32_t *aLineNumber) = 0;
+
+
+  virtual nsresult GetColumnNumber(JSContext* cx, int32_t *aColumnNumber) = 0;
+
+
+  virtual nsresult GetSourceLine(nsACString & aSourceLine) = 0;
+
+
+  virtual nsresult GetAsyncCause(JSContext* cx, nsAString & aAsyncCause) = 0;
+
+
+  virtual nsresult GetAsyncCaller(JSContext* cx, nsIStackFrame * *aAsyncCaller) = 0;
+
+
+  virtual nsresult GetCaller(JSContext* cx, nsIStackFrame * *aCaller) = 0;
+
+
+  virtual nsresult GetFormattedStack(JSContext* cx, nsAString & aFormattedStack) = 0;
+
+
+  virtual nsresult GetNativeSavedFrame(JS::MutableHandleValue aNativeSavedFrame) = 0;
+
+
+  virtual nsresult ToString(JSContext* cx, nsACString & _retval) = 0;
+
+};
+
+  template<typename T> struct nsIStackFrame::COMTypeInfo<nsIStackFrame, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStackFrame::COMTypeInfo<nsIStackFrame, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x28bfb2a2, 0x5ea6, 0x4738, { 0x91, 0x8b, 0x04, 0x9d, 0xc4, 0xd5, 0x1f, 0x0b }};
+# 261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h"
+class nsIException : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetMessageMoz(nsACString & aMessage) = 0;
+
+
+  virtual nsresult GetResult(nsresult *aResult) = 0;
+
+
+  virtual nsresult GetName(nsACString & aName) = 0;
+
+
+  virtual nsresult GetFilename(JSContext* cx, nsAString & aFilename) = 0;
+
+
+  virtual nsresult GetLineNumber(JSContext* cx, uint32_t *aLineNumber) = 0;
+
+
+  virtual nsresult GetColumnNumber(uint32_t *aColumnNumber) = 0;
+
+
+  virtual nsresult GetLocation(nsIStackFrame * *aLocation) = 0;
+
+
+  virtual nsresult GetData(nsISupports * *aData) = 0;
+
+
+  virtual nsresult ToString(JSContext* cx, nsACString & _retval) = 0;
+
+};
+
+  template<typename T> struct nsIException::COMTypeInfo<nsIException, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIException::COMTypeInfo<nsIException, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4371b5bf, 0x6845, 0x487f, { 0x8d, 0x9d, 0x3f, 0x1e, 0x4a, 0x9b, 0xad, 0xd2 }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h" 2
+
+
+
+class nsIStackFrame;
+class nsPIDOMWindowInner;
+template <class T>
+struct already_AddRefed;
+
+namespace mozilla {
+namespace dom {
+
+class Exception;
+
+
+
+bool
+Throw(JSContext* cx, nsresult rv, const nsACString& message = EmptyCString());
+
+
+void
+ThrowAndReport(nsPIDOMWindowInner* aWindow, nsresult aRv);
+
+
+
+void
+ThrowExceptionObject(JSContext* aCx, Exception* aException);
+void
+ThrowExceptionObject(JSContext* aCx, nsIException* aException);
+
+
+
+
+
+
+already_AddRefed<Exception>
+CreateException(nsresult aRv, const nsACString& aMessage = EmptyCString());
+
+
+
+
+already_AddRefed<nsIStackFrame>
+GetCurrentJSStack(int32_t aMaxDepth = -1);
+
+
+namespace exceptions {
+
+already_AddRefed<nsIStackFrame>
+CreateStack(JSContext* aCx, JS::StackCapture&& aCaptureMode);
+
+}
+}
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NonRefcountedDOMObject.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NonRefcountedDOMObject.h"
+namespace mozilla {
+namespace dom {
+
+
+
+
+
+
+
+class NonRefcountedDOMObject
+{
+protected:
+  NonRefcountedDOMObject()
+  {
+                                          ;
+  }
+  ~NonRefcountedDOMObject()
+  {
+                                          ;
+  }
+};
+
+}
+}
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/RootedDictionary.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/RootedDictionary.h"
+namespace mozilla {
+namespace dom {
+
+template<typename T>
+class RootedDictionary final : public T,
+                                         private JS::CustomAutoRooter
+{
+public:
+  template <typename CX>
+  explicit RootedDictionary(const CX& cx ) :
+    T(),
+    JS::CustomAutoRooter(cx )
+  {
+  }
+
+  virtual void trace(JSTracer *trc) override
+  {
+    this->TraceDictionary(trc);
+  }
+};
+
+template<typename T>
+class NullableRootedDictionary final : public Nullable<T>,
+                                                 private JS::CustomAutoRooter
+{
+public:
+  template <typename CX>
+  explicit NullableRootedDictionary(const CX& cx ) :
+    Nullable<T>(),
+    JS::CustomAutoRooter(cx )
+  {
+  }
+
+  virtual void trace(JSTracer *trc) override
+  {
+    if (!this->IsNull()) {
+      this->Value().TraceDictionary(trc);
+    }
+  }
+};
+
+}
+}
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCompatibility.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCompatibility.h"
+enum nsCompatibility {
+  eCompatibility_FullStandards = 1,
+  eCompatibility_AlmostStandards = 2,
+  eCompatibility_NavQuirks = 3
+};
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+class nsIContent;
+class nsIDocument;
+
+namespace mozilla {
+namespace css {
+class Rule;
+}
+}
+
+
+
+
+
+typedef uint32_t nsUpdateType;
+
+
+
+
+
+
+class nsIDocumentObserver : public nsIMutationObserver
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+  virtual void BeginUpdate(nsIDocument *aDocument,
+                           nsUpdateType aUpdateType) = 0;
+
+
+
+
+
+  virtual void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType) = 0;
+
+
+
+
+  virtual void BeginLoad(nsIDocument *aDocument) = 0;
+
+
+
+
+
+
+  virtual void EndLoad(nsIDocument *aDocument) = 0;
+# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void ContentStateChanged(nsIDocument* aDocument,
+                                   nsIContent* aContent,
+                                   mozilla::EventStates aStateMask) = 0;
+
+
+
+
+
+
+
+  virtual void DocumentStatesChanged(nsIDocument* aDocument,
+                                     mozilla::EventStates aStateMask) = 0;
+# 103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleSheetAdded(mozilla::StyleSheet* aStyleSheet,
+                               bool aDocumentSheet) = 0;
+# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleSheetRemoved(mozilla::StyleSheet* aStyleSheet,
+                                 bool aDocumentSheet) = 0;
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleSheetApplicableStateChanged(mozilla::StyleSheet* aStyleSheet) = 0;
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet) = 0;
+# 150 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet) = 0;
+# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
+  virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet) = 0;
+};
+
+template<typename T> struct nsIDocumentObserver::COMTypeInfo<nsIDocumentObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDocumentObserver::COMTypeInfo<nsIDocumentObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x71041fa3, 0x6dd7, 0x4cde, { 0xbb, 0x76, 0xae, 0xcc, 0x69, 0xe1, 0x75, 0x78 } };
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h"
+class nsISimpleEnumerator;
+
+class nsIRequestObserver;
+
+class nsIInterfaceRequestor;
+
+class nsIRequestContext;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h"
+class nsILoadGroup : public nsIRequest {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetGroupObserver(nsIRequestObserver * *aGroupObserver) = 0;
+  virtual nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver) = 0;
+
+
+  virtual nsresult GetDefaultLoadRequest(nsIRequest * *aDefaultLoadRequest) = 0;
+  virtual nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest) = 0;
+
+
+  virtual nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext) = 0;
+
+
+  virtual nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus) = 0;
+
+
+  virtual nsresult GetRequests(nsISimpleEnumerator * *aRequests) = 0;
+
+
+  virtual nsresult GetActiveCount(uint32_t *aActiveCount) = 0;
+
+
+  virtual nsresult GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) = 0;
+  virtual nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) = 0;
+
+
+  virtual nsresult GetRequestContextID(uint64_t *aRequestContextID) = 0;
+
+
+  virtual nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags) = 0;
+  virtual nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags) = 0;
+
+
+  virtual nsresult GetUserAgentOverrideCache(nsACString & aUserAgentOverrideCache) = 0;
+  virtual nsresult SetUserAgentOverrideCache(const nsACString & aUserAgentOverrideCache) = 0;
+
+};
+
+  template<typename T> struct nsILoadGroup::COMTypeInfo<nsILoadGroup, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILoadGroup::COMTypeInfo<nsILoadGroup, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf0c87725, 0x7a35, 0x463c, { 0x9c, 0xeb, 0x2c, 0x07, 0xf2, 0x34, 0x06, 0xcc }};
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h"
+class nsIRequest;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h"
+class nsIRequestObserver : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) = 0;
+
+
+  virtual nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode) = 0;
+
+};
+
+  template<typename T> struct nsIRequestObserver::COMTypeInfo<nsIRequestObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRequestObserver::COMTypeInfo<nsIRequestObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xfd91e2e0, 0x1481, 0x11d3, { 0x93, 0x33, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h" 2
+
+
+
+
+
+
+class nsIInputStream;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h"
+class nsIStreamListener : public nsIRequestObserver {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext, nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount) = 0;
+
+};
+
+  template<typename T> struct nsIStreamListener::COMTypeInfo<nsIStreamListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStreamListener::COMTypeInfo<nsIStreamListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3b4c8a77, 0x76ba, 0x4610, { 0xb3, 0x16, 0x67, 0x8c, 0x73, 0xa3, 0xb8, 0x8c }};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h"
+class nsScanner;
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h"
+class nsITokenizer : public nsISupports {
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  virtual nsresult WillTokenize(bool aIsFinalChunk)=0;
+  virtual nsresult ConsumeToken(nsScanner& aScanner,bool& aFlushTokens)=0;
+};
+
+template<typename T> struct nsITokenizer::COMTypeInfo<nsITokenizer, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITokenizer::COMTypeInfo<nsITokenizer, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0Xae98a348, 0X5e91, 0X41a8, { 0Xa5, 0Xb4, 0Xd2, 0X20, 0Xf3, 0X1f, 0Xc4, 0Xab } };
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h" 2
+
+
+
+
+
+enum eAutoDetectResult {
+    eUnknownDetect,
+    eValidDetect,
+    ePrimaryDetect,
+    eInvalidDetect
+};
+
+enum nsDTDMode {
+    eDTDMode_unknown = 0,
+    eDTDMode_quirks,
+    eDTDMode_almost_standards,
+    eDTDMode_full_standards,
+    eDTDMode_autodetect,
+    eDTDMode_fragment
+};
+
+
+class nsIContentSink;
+class CParserContext;
+
+class nsIDTD : public nsISupports
+{
+public:
+
+    template<typename T, typename U> struct COMTypeInfo;
+
+    virtual nsresult WillBuildModel(const CParserContext& aParserContext,
+                              nsITokenizer* aTokenizer,
+                              nsIContentSink* aSink) = 0;
+
+
+
+
+
+
+
+    virtual nsresult DidBuildModel(nsresult anErrorCode) = 0;
+# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
+    virtual nsresult BuildModel(nsITokenizer* aTokenizer, nsIContentSink* aSink) = 0;
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
+    virtual bool CanContain(int32_t aParent,int32_t aChild) const = 0;
+# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
+    virtual bool IsContainer(int32_t aTag) const = 0;
+# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
+    virtual void Terminate() = 0;
+
+    virtual int32_t GetType() = 0;
+
+
+
+
+
+    virtual nsDTDMode GetMode() const = 0;
+};
+
+template<typename T> struct nsIDTD::COMTypeInfo<nsIDTD, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDTD::COMTypeInfo<nsIDTD, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x3de05873, 0xefa7, 0x410d, { 0xa4, 0x61, 0x80, 0x33, 0xaf, 0xd9, 0xe3, 0x26 } };
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsParserBase.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsParserBase.h"
+class nsParserBase : public nsISupports
+{
+  public:
+    virtual bool IsParserEnabled() { return true; }
+    virtual nsresult GetChannel(nsIChannel** aChannel) {
+      *aChannel = nullptr;
+      return NS_OK;
+    }
+};
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
+
+
+
+
+
+class nsIContentSink;
+class nsIRequestObserver;
+class nsString;
+class nsIURI;
+class nsIChannel;
+
+enum eParserCommands {
+  eViewNormal,
+  eViewSource,
+  eViewFragment,
+  eViewErrors
+};
+
+enum eParserDocType {
+  ePlainText = 0,
+  eXML,
+  eHTML_Quirks,
+  eHTML_Strict
+};
+
+enum eStreamState {eNone,eOnStart,eOnDataAvail,eOnStop};
+# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+class nsIParser : public nsParserBase {
+  public:
+
+    template<typename T, typename U> struct COMTypeInfo;
+
+
+
+
+
+
+
+    virtual void SetContentSink(nsIContentSink* aSink)=0;
+
+
+
+
+
+
+
+    virtual nsIContentSink* GetContentSink(void)=0;
+# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+    virtual void GetCommand(nsCString& aCommand)=0;
+    virtual void SetCommand(const char* aCommand)=0;
+    virtual void SetCommand(eParserCommands aParserCommand)=0;
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+    virtual void SetDocumentCharset(const nsACString& aCharset, int32_t aSource)=0;
+    virtual void GetDocumentCharset(nsACString& oCharset, int32_t& oSource)=0;
+
+
+
+
+
+
+
+    virtual nsresult GetChannel(nsIChannel** aChannel) override = 0;
+
+
+
+
+
+
+
+    virtual nsresult GetDTD(nsIDTD** aDTD) = 0;
+
+
+
+
+    virtual nsIStreamListener* GetStreamListener() = 0;
+# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+    virtual nsresult ContinueInterruptedParsing() = 0;
+
+
+    virtual void BlockParser() = 0;
+
+
+
+
+
+    virtual void UnblockParser() = 0;
+
+
+
+
+    virtual void ContinueInterruptedParsingAsync() = 0;
+
+    virtual bool IsParserEnabled() override = 0;
+    virtual bool IsComplete() = 0;
+
+    virtual nsresult Parse(nsIURI* aURL,
+                     nsIRequestObserver* aListener = nullptr,
+                     void* aKey = 0,
+                     nsDTDMode aMode = eDTDMode_autodetect) = 0;
+
+    virtual nsresult Terminate(void) = 0;
+# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+    virtual nsresult ParseFragment(const nsAString& aSourceBuffer,
+                             nsTArray<nsString>& aTagStack) = 0;
+
+
+
+
+
+
+
+    virtual nsresult BuildModel(void) = 0;
+# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
+    virtual nsresult CancelParsingEvents() = 0;
+
+    virtual void Reset() = 0;
+
+
+
+
+    virtual bool IsInsertionPointDefined() = 0;
+
+
+
+
+
+    virtual void PushDefinedInsertionPoint() = 0;
+
+
+
+
+
+
+    virtual void PopDefinedInsertionPoint() = 0;
+
+
+
+
+    virtual void MarkAsNotScriptCreated(const char* aCommand) = 0;
+
+
+
+
+    virtual bool IsScriptCreated() = 0;
+};
+
+template<typename T> struct nsIParser::COMTypeInfo<nsIParser, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIParser::COMTypeInfo<nsIParser, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x2c4ad90a, 0x740e, 0x4212, { 0xba, 0x3f, 0xfe, 0xac, 0xda, 0x4b, 0x92, 0x9e } };
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h"
+class nsIServiceManager : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetService(const nsCID & aClass, const nsIID & aIID, void **result) = 0;
+
+
+  virtual nsresult GetServiceByContractID(const char * aContractID, const nsIID & aIID, void **result) = 0;
+
+
+  virtual nsresult IsServiceInstantiated(const nsCID & aClass, const nsIID & aIID, bool *_retval) = 0;
+
+
+  virtual nsresult IsServiceInstantiatedByContractID(const char * aContractID, const nsIID & aIID, bool *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIServiceManager::COMTypeInfo<nsIServiceManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIServiceManager::COMTypeInfo<nsIServiceManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8bb35ed9, 0xe332, 0x462d, { 0x91, 0x55, 0x4a, 0x00, 0x2a, 0xb5, 0xc9, 0x58 }};
+# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFactory.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFactory.h"
+class nsIFactory : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult CreateInstance(nsISupports *aOuter, const nsIID & iid, void **result) = 0;
+
+
+  virtual nsresult LockFactory(bool lock) = 0;
+
+};
+
+  template<typename T> struct nsIFactory::COMTypeInfo<nsIFactory, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFactory::COMTypeInfo<nsIFactory, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x00000001, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 }};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h" 2
+
+
+nsresult CallCreateInstance(const nsCID& aClass, nsISupports* aDelegate,
+                            const nsIID& aIID, void** aResult);
+
+nsresult CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
+                            const nsIID& aIID, void** aResult);
+
+nsresult CallGetClassObject(const nsCID& aClass, const nsIID& aIID,
+                            void** aResult);
+
+nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
+                            void** aResult);
+
+
+class nsCreateInstanceByCID final : public nsCOMPtr_helper
+{
+public:
+  nsCreateInstanceByCID(const nsCID& aCID, nsresult* aErrorPtr)
+    : mCID(aCID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const
+    override;
+
+private:
+  const nsCID& mCID;
+  nsresult* mErrorPtr;
+};
+
+class nsCreateInstanceByContractID final : public nsCOMPtr_helper
+{
+public:
+  nsCreateInstanceByContractID(const char* aContractID, nsresult* aErrorPtr)
+    : mContractID(aContractID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const override;
+
+private:
+  const char* mContractID;
+  nsresult* mErrorPtr;
+};
+
+class nsCreateInstanceFromFactory final : public nsCOMPtr_helper
+{
+public:
+  nsCreateInstanceFromFactory(nsIFactory* aFactory, nsresult* aErrorPtr)
+    : mFactory(aFactory)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const override;
+
+private:
+  nsIFactory* mFactory;
+  nsresult* mErrorPtr;
+};
+
+
+inline const nsCreateInstanceByCID
+do_CreateInstance(const nsCID& aCID, nsresult* aError = 0)
+{
+  return nsCreateInstanceByCID(aCID, aError);
+}
+
+inline const nsCreateInstanceByContractID
+do_CreateInstance(const char* aContractID, nsresult* aError = 0)
+{
+  return nsCreateInstanceByContractID(aContractID, aError);
+}
+
+inline const nsCreateInstanceFromFactory
+do_CreateInstance(nsIFactory* aFactory, nsresult* aError = 0)
+{
+  return nsCreateInstanceFromFactory(aFactory, aError);
+}
+
+
+class nsGetClassObjectByCID final : public nsCOMPtr_helper
+{
+public:
+  nsGetClassObjectByCID(const nsCID& aCID, nsresult* aErrorPtr)
+    : mCID(aCID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const override;
+
+private:
+  const nsCID& mCID;
+  nsresult* mErrorPtr;
+};
+
+class nsGetClassObjectByContractID final : public nsCOMPtr_helper
+{
+public:
+  nsGetClassObjectByContractID(const char* aContractID, nsresult* aErrorPtr)
+    : mContractID(aContractID)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const override;
+
+private:
+  const char* mContractID;
+  nsresult* mErrorPtr;
+};
+# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h"
+inline const nsGetClassObjectByCID
+do_GetClassObject(const nsCID& aCID, nsresult* aError = 0)
+{
+  return nsGetClassObjectByCID(aCID, aError);
+}
+
+inline const nsGetClassObjectByContractID
+do_GetClassObject(const char* aContractID, nsresult* aError = 0)
+{
+  return nsGetClassObjectByContractID(aContractID, aError);
+}
+
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(const nsCID& aClass,
+                   nsISupports* aDelegate,
+                   DestinationType** aDestination)
+{
+  do { } while(0);
+
+  return CallCreateInstance(aClass, aDelegate,
+                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(const nsCID& aClass, DestinationType** aDestination)
+{
+  do { } while(0);
+
+  return CallCreateInstance(aClass, nullptr,
+                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(const char* aContractID,
+                   nsISupports* aDelegate,
+                   DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return CallCreateInstance(aContractID,
+                            aDelegate,
+                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(const char* aContractID, DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return CallCreateInstance(aContractID, nullptr,
+                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(nsIFactory* aFactory,
+                   nsISupports* aDelegate,
+                   DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return aFactory->CreateInstance(aDelegate,
+                                  (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                                  reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallCreateInstance(nsIFactory* aFactory, DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return aFactory->CreateInstance(nullptr,
+                                  (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                                  reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallGetClassObject(const nsCID& aClass, DestinationType** aDestination)
+{
+  do { } while(0);
+
+  return CallGetClassObject(aClass, (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallGetClassObject(const char* aContractID, DestinationType** aDestination)
+{
+  do { } while(0);
+
+  return CallGetClassObject(aContractID, (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                            reinterpret_cast<void**>(aDestination));
+}
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h" 2
+
+
+inline const nsGetServiceByCID
+do_GetService(const nsCID& aCID)
+{
+  return nsGetServiceByCID(aCID);
+}
+
+inline const nsGetServiceByCIDWithError
+do_GetService(const nsCID& aCID, nsresult* aError)
+{
+  return nsGetServiceByCIDWithError(aCID, aError);
+}
+
+inline const nsGetServiceByContractID
+do_GetService(const char* aContractID)
+{
+  return nsGetServiceByContractID(aContractID);
+}
+
+inline const nsGetServiceByContractIDWithError
+do_GetService(const char* aContractID, nsresult* aError)
+{
+  return nsGetServiceByContractIDWithError(aContractID, aError);
+}
+
+class nsGetServiceFromCategory final : public nsCOMPtr_helper
+{
+public:
+  nsGetServiceFromCategory(const char* aCategory, const char* aEntry,
+                           nsresult* aErrorPtr)
+    : mCategory(aCategory)
+    , mEntry(aEntry)
+    , mErrorPtr(aErrorPtr)
+  {
+  }
+
+  virtual nsresult operator()(const nsIID&, void**) const
+    override;
+protected:
+  const char* mCategory;
+  const char* mEntry;
+  nsresult* mErrorPtr;
+};
+
+inline const nsGetServiceFromCategory
+do_GetServiceFromCategory(const char* aCategory, const char* aEntry,
+                          nsresult* aError = 0)
+{
+  return nsGetServiceFromCategory(aCategory, aEntry, aError);
+}
+
+nsresult CallGetService(const nsCID& aClass, const nsIID& aIID, void** aResult);
+
+nsresult CallGetService(const char* aContractID, const nsIID& aIID,
+                        void** aResult);
+
+
+template<class DestinationType>
+inline nsresult
+CallGetService(const nsCID& aClass,
+               DestinationType** aDestination)
+{
+  do { } while(0);
+
+  return CallGetService(aClass,
+                        (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                        reinterpret_cast<void**>(aDestination));
+}
+
+template<class DestinationType>
+inline nsresult
+CallGetService(const char* aContractID,
+               DestinationType** aDestination)
+{
+  do { } while(0);
+  do { } while(0);
+
+  return CallGetService(aContractID,
+                        (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
+                        reinterpret_cast<void**>(aDestination));
+}
+# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIUUIDGenerator.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIUUIDGenerator.h"
+class nsIUUIDGenerator : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GenerateUUID(nsID **_retval) = 0;
+
+
+  virtual nsresult GenerateUUIDInPlace(nsID *id) = 0;
+
+};
+
+  template<typename T> struct nsIUUIDGenerator::COMTypeInfo<nsIUUIDGenerator, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIUUIDGenerator::COMTypeInfo<nsIUUIDGenerator, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x138ad1b2, 0xc694, 0x41cc, { 0xb2, 0x01, 0x33, 0x3c, 0xe9, 0x36, 0xd8, 0xb8 }};
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsURIHashKey.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsURIHashKey.h"
+class nsURIHashKey : public PLDHashEntryHdr
+{
+public:
+    typedef nsIURI* KeyType;
+    typedef const nsIURI* KeyTypePointer;
+
+    explicit nsURIHashKey(const nsIURI* aKey) :
+        mKey(const_cast<nsIURI*>(aKey)) { ; }
+    nsURIHashKey(const nsURIHashKey& toCopy) :
+        mKey(toCopy.mKey) { ; }
+    ~nsURIHashKey() { ; }
+
+    nsIURI* GetKey() const { return mKey; }
+
+    bool KeyEquals(const nsIURI* aKey) const {
+        bool eq;
+        if (!mKey) {
+            return !aKey;
+        }
+        if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(mKey->Equals(const_cast<nsIURI*>(aKey), &eq))), 1)))) {
+            return eq;
+        }
+        return false;
+    }
+
+    static const nsIURI* KeyToPointer(nsIURI* aKey) { return aKey; }
+    static PLDHashNumber HashKey(const nsIURI* aKey) {
+        if (!aKey) {
+
+            return mozilla::HashString(EmptyCString());
+        }
+        nsAutoCString spec;
+
+
+        mozilla::Unused << const_cast<nsIURI*>(aKey)->GetSpec(spec);
+        return mozilla::HashString(spec);
+    }
+
+    enum { ALLOW_MEMMOVE = true };
+
+protected:
+    nsCOMPtr<nsIURI> mKey;
+};
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h"
+namespace mozilla {
+
+enum UseCounter : int16_t {
+  eUseCounter_UNKNOWN = -1,
+
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UseCounterList.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UseCounterList.h"
+eUseCounter_SVGSVGElement_getElementById,
+eUseCounter_SVGSVGElement_currentScale_getter, eUseCounter_SVGSVGElement_currentScale_setter,
+eUseCounter_property_Fill,
+eUseCounter_property_FillOpacity,
+eUseCounter_PushManager_subscribe,
+eUseCounter_PushSubscription_unsubscribe,
+eUseCounter_Window_sidebar_getter, eUseCounter_Window_sidebar_setter,
+eUseCounter_External_addSearchEngine,
+eUseCounter_OfflineResourceList_swapCache,
+eUseCounter_OfflineResourceList_update,
+eUseCounter_OfflineResourceList_status_getter, eUseCounter_OfflineResourceList_status_setter,
+eUseCounter_OfflineResourceList_onchecking_getter, eUseCounter_OfflineResourceList_onchecking_setter,
+eUseCounter_OfflineResourceList_onerror_getter, eUseCounter_OfflineResourceList_onerror_setter,
+eUseCounter_OfflineResourceList_onnoupdate_getter, eUseCounter_OfflineResourceList_onnoupdate_setter,
+eUseCounter_OfflineResourceList_ondownloading_getter, eUseCounter_OfflineResourceList_ondownloading_setter,
+eUseCounter_OfflineResourceList_onprogress_getter, eUseCounter_OfflineResourceList_onprogress_setter,
+eUseCounter_OfflineResourceList_onupdateready_getter, eUseCounter_OfflineResourceList_onupdateready_setter,
+eUseCounter_OfflineResourceList_oncached_getter, eUseCounter_OfflineResourceList_oncached_setter,
+eUseCounter_OfflineResourceList_onobsolete_getter, eUseCounter_OfflineResourceList_onobsolete_setter,
+eUseCounter_IDBDatabase_createMutableFile,
+eUseCounter_IDBDatabase_mozCreateFileHandle,
+eUseCounter_IDBMutableFile_open,
+eUseCounter_IDBMutableFile_getFile,
+eUseCounter_DataTransfer_addElement,
+eUseCounter_DataTransfer_mozItemCount_getter, eUseCounter_DataTransfer_mozItemCount_setter,
+eUseCounter_DataTransfer_mozCursor_getter, eUseCounter_DataTransfer_mozCursor_setter,
+eUseCounter_DataTransfer_mozTypesAt,
+eUseCounter_DataTransfer_mozClearDataAt,
+eUseCounter_DataTransfer_mozSetDataAt,
+eUseCounter_DataTransfer_mozGetDataAt,
+eUseCounter_DataTransfer_mozUserCancelled_getter, eUseCounter_DataTransfer_mozUserCancelled_setter,
+eUseCounter_DataTransfer_mozSourceNode_getter, eUseCounter_DataTransfer_mozSourceNode_setter,
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h"
+eUseCounter_GetAttributeNode,
+eUseCounter_SetAttributeNode,
+eUseCounter_GetAttributeNodeNS,
+eUseCounter_SetAttributeNodeNS,
+eUseCounter_RemoveAttributeNode,
+eUseCounter_CreateAttribute,
+eUseCounter_CreateAttributeNS,
+eUseCounter_NodeValue,
+eUseCounter_TextContent,
+eUseCounter_EnablePrivilege,
+eUseCounter_DOMExceptionCode,
+eUseCounter_NoExposedProps,
+eUseCounter_MutationEvent,
+eUseCounter_Components,
+eUseCounter_PrefixedVisibilityAPI,
+eUseCounter_NodeIteratorDetach,
+eUseCounter_LenientThis,
+eUseCounter_GetPreventDefault,
+eUseCounter_GetSetUserData,
+eUseCounter_MozGetAsFile,
+eUseCounter_UseOfCaptureEvents,
+eUseCounter_UseOfReleaseEvents,
+eUseCounter_UseOfDOM3LoadMethod,
+eUseCounter_ChromeUseOfDOM3LoadMethod,
+eUseCounter_ShowModalDialog,
+eUseCounter_Window_Content,
+eUseCounter_SyncXMLHttpRequest,
+eUseCounter_DataContainerEvent,
+eUseCounter_Window_Controllers,
+eUseCounter_ImportXULIntoContent,
+eUseCounter_PannerNodeDoppler,
+eUseCounter_NavigatorGetUserMedia,
+eUseCounter_WebrtcDeprecatedPrefix,
+eUseCounter_RTCPeerConnectionGetStreams,
+eUseCounter_AppCache,
+eUseCounter_PrefixedImageSmoothingEnabled,
+eUseCounter_PrefixedFullscreenAPI,
+eUseCounter_LenientSetter,
+eUseCounter_FileLastModifiedDate,
+eUseCounter_ImageBitmapRenderingContext_TransferImageBitmap,
+eUseCounter_URLCreateObjectURL_MediaStream,
+eUseCounter_XMLBaseAttribute,
+eUseCounter_XMLBaseAttributeForStyleAttr,
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 2
+
+
+  eUseCounter_Count
+};
+
+}
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h"
+class nsContentList;
+class nsIAtom;
+class nsIContent;
+class nsINode;
+
+class nsString;
+class nsAString;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}
+}
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h"
+typedef bool (*nsContentListMatchFunc)(mozilla::dom::Element* aElement,
+                                       int32_t aNamespaceID,
+                                       nsIAtom* aAtom,
+                                       void* aData);
+
+typedef void (*nsContentListDestroyFunc)(void* aData);
+
+
+
+
+
+
+typedef void* (*nsFuncStringContentListDataAllocator)(nsINode* aRootNode,
+                                                      const nsString* aString);
+
+
+
+
+
+
+already_AddRefed<nsContentList>
+NS_GetContentList(nsINode* aRootNode,
+                  int32_t aMatchNameSpaceId,
+                  const nsAString& aTagname);
+
+already_AddRefed<nsContentList>
+NS_GetFuncStringNodeList(nsINode* aRootNode,
+                         nsContentListMatchFunc aFunc,
+                         nsContentListDestroyFunc aDestroyFunc,
+                         nsFuncStringContentListDataAllocator aDataAllocator,
+                         const nsAString& aString);
+already_AddRefed<nsContentList>
+NS_GetFuncStringHTMLCollection(nsINode* aRootNode,
+                               nsContentListMatchFunc aFunc,
+                               nsContentListDestroyFunc aDestroyFunc,
+                               nsFuncStringContentListDataAllocator aDataAllocator,
+                               const nsAString& aString);
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h" 1
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
+namespace mozilla {
+# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
+enum class LogLevel {
+  Disabled = 0,
+  Error,
+  Warning,
+  Info,
+  Debug,
+  Verbose,
+};
+
+
+
+
+LogLevel ToLogLevel(int32_t aLevel);
+
+class LogModule
+{
+public:
+  ~LogModule() { ::free(mName); }
+# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
+  static LogModule* Get(const char* aName);
+
+  static void Init();
+
+
+
+
+  static void SetLogFile(const char* aFilename);
+
+
+
+
+
+
+
+  static uint32_t GetLogFile(char *aBuffer, size_t aLength);
+
+
+
+
+  static void SetAddTimestamp(bool aAddTimestamp);
+
+
+
+
+  static void SetIsSync(bool aIsSync);
+
+
+
+
+  bool ShouldLog(LogLevel aLevel) const { return mLevel >= aLevel; }
+
+
+
+
+  LogLevel Level() const { return mLevel; }
+
+
+
+
+  void SetLevel(LogLevel level) { mLevel = level; }
+
+
+
+
+  void Printv(LogLevel aLevel, const char* aFmt, va_list aArgs) const;
+
+
+
+
+  const char* Name() const { return mName; }
+
+private:
+  friend class LogModuleManager;
+
+  explicit LogModule(const char* aName, LogLevel aLevel)
+    : mName(strdup(aName)), mLevel(aLevel)
+  {
+  }
+
+  LogModule(LogModule&) = delete;
+  LogModule& operator=(const LogModule&) = delete;
+
+  char* mName;
+  Atomic<LogLevel, Relaxed> mLevel;
+};
+# 156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
+class LazyLogModule final
+{
+public:
+  explicit constexpr LazyLogModule(const char* aLogName)
+    : mLogName(aLogName)
+    , mLog(nullptr)
+  {
+  }
+
+  operator LogModule*()
+  {
+
+
+
+
+    LogModule* tmp = mLog;
+    if ((__builtin_expect(!!(!tmp), 0))) {
+      tmp = LogModule::Get(mLogName);
+      mLog = tmp;
+    }
+
+    return tmp;
+  }
+
+private:
+  const char* const mLogName;
+  Atomic<LogModule*, ReleaseAcquire> mLog;
+};
+
+namespace detail {
+
+inline bool log_test(const LogModule* module, LogLevel level) {
+  do { } while (0);
+  return module && module->ShouldLog(level);
+}
+
+void log_print(const LogModule* aModule,
+               LogLevel aLevel,
+               const char* aFmt, ...) __attribute__ ((format (printf, 3, 4)));
+}
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h"
+class nsIObserver;
+
+class nsISimpleEnumerator;
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h"
+class nsIObserverService : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult AddObserver(nsIObserver *anObserver, const char * aTopic, bool ownsWeak) = 0;
+
+
+  virtual nsresult RemoveObserver(nsIObserver *anObserver, const char * aTopic) = 0;
+
+
+  virtual nsresult NotifyObservers(nsISupports *aSubject, const char * aTopic, const char16_t * someData) = 0;
+
+
+  virtual nsresult EnumerateObservers(const char * aTopic, nsISimpleEnumerator * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIObserverService::COMTypeInfo<nsIObserverService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIObserverService::COMTypeInfo<nsIObserverService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xd07f5192, 0xe3d1, 0x11d2, { 0x8a, 0xcd, 0x00, 0x10, 0x5a, 0x1b, 0x88, 0x60 }};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServiceList.h" 1
+
+
+
+
+
+
+
+class nsIChromeRegistry;
+
+class nsIToolkitChromeRegistry;
+
+class nsIXULChromeRegistry;
+
+class nsIXULOverlayProvider;
+
+class nsIIOService;
+
+class nsIObserverService;
+
+class nsIStringBundleService;
+
+class nsIXPConnect;
+
+class inIDOMUtils;
+
+class nsIPermissionManager;;
+
+class nsIServiceWorkerManager;;
+
+class nsIAsyncShutdownService;
+
+class nsIUUIDGenerator;;
+
+class nsIGfxInfo;;
+
+
+
+namespace mozilla {
+
+
+class IHistory;
+
+
+
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 2
+
+
+
+namespace mozilla {
+namespace services {
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServiceList.h" 1
+
+
+
+
+
+
+
+already_AddRefed<nsIChromeRegistry> GetChromeRegistryService();
+
+already_AddRefed<nsIToolkitChromeRegistry> GetToolkitChromeRegistryService();
+
+already_AddRefed<nsIXULChromeRegistry> GetXULChromeRegistryService();
+
+already_AddRefed<nsIXULOverlayProvider> GetXULOverlayProviderService();
+
+already_AddRefed<nsIIOService> GetIOService();
+
+already_AddRefed<nsIObserverService> GetObserverService();
+
+already_AddRefed<nsIStringBundleService> GetStringBundleService();
+
+already_AddRefed<nsIXPConnect> GetXPConnect();
+
+already_AddRefed<inIDOMUtils> GetInDOMUtils();
+
+already_AddRefed<nsIPermissionManager> GetPermissionManager();;
+
+already_AddRefed<nsIServiceWorkerManager> GetServiceWorkerManager();;
+
+already_AddRefed<nsIAsyncShutdownService> GetAsyncShutdown();
+
+already_AddRefed<nsIUUIDGenerator> GetUUIDGenerator();;
+
+already_AddRefed<nsIGfxInfo> GetGfxInfo();;
+
+
+
+
+
+
+already_AddRefed<IHistory> GetHistoryService();
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 2
+
+
+
+}
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
+
+
+
+
+
+
+struct nsExpirationState
+{
+  enum
+  {
+    NOT_TRACKED = (1U << 4) - 1,
+    MAX_INDEX_IN_GENERATION = (1U << 28) - 1
+  };
+
+  nsExpirationState() : mGeneration(NOT_TRACKED) {}
+  bool IsTracked() { return mGeneration != NOT_TRACKED; }
+
+
+
+
+  uint32_t mGeneration:4;
+  uint32_t mIndexInGeneration:28;
+};
+# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+template<typename T, uint32_t K, typename Mutex, typename AutoLock>
+class ExpirationTrackerImpl
+{
+public:
+# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+  ExpirationTrackerImpl(uint32_t aTimerPeriod,
+                        const char* aName,
+                        nsIEventTarget* aEventTarget = nullptr)
+    : mTimerPeriod(aTimerPeriod)
+    , mNewestGeneration(0)
+    , mInAgeOneGeneration(false)
+    , mName(aName)
+    , mEventTarget(aEventTarget)
+  {
+    static_assert(K >= 2 && K <= nsExpirationState::NOT_TRACKED,
+                  "Unsupported number of generations (must be 2 <= K <= 15)");
+    do { } while (0);
+    if (mEventTarget) {
+      bool current = false;
+
+
+
+
+      if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(NS_FAILED_impl(mEventTarget->IsOnCurrentThread(&current))), 0))) || !current), 0))) {
+
+        do { AnnotateMozCrashReason("MOZ_CRASH(" "Provided event target must be on the main thread" ")"); do { *((volatile int*) __null) = 126; ::abort(); } while (0); } while (0);
+      }
+    }
+    mObserver = new ExpirationTrackerObserver();
+    mObserver->Init(this);
+  }
+
+  virtual ~ExpirationTrackerImpl()
+  {
+    do { } while (0);
+    if (mTimer) {
+      mTimer->Cancel();
+    }
+    mObserver->Destroy();
+  }
+
+
+
+
+
+
+  nsresult AddObjectLocked(T* aObj, const AutoLock& aAutoLock)
+  {
+    nsExpirationState* state = aObj->GetExpirationState();
+    do { } while(0);
+
+    nsTArray<T*>& generation = mGenerations[mNewestGeneration];
+    uint32_t index = generation.Length();
+    if (index > nsExpirationState::MAX_INDEX_IN_GENERATION) {
+      do { } while(0);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    if (index == 0) {
+
+      nsresult rv = CheckStartTimerLocked(aAutoLock);
+      if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
+        return rv;
+      }
+    }
+    if (!generation.AppendElement(aObj)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    state->mGeneration = mNewestGeneration;
+    state->mIndexInGeneration = index;
+    return NS_OK;
+  }
+
+
+
+
+  void RemoveObjectLocked(T* aObj, const AutoLock& aAutoLock)
+  {
+    nsExpirationState* state = aObj->GetExpirationState();
+    do { } while(0);
+    nsTArray<T*>& generation = mGenerations[state->mGeneration];
+    uint32_t index = state->mIndexInGeneration;
+    do { } while(0);
+
+
+    uint32_t last = generation.Length() - 1;
+    T* lastObj = generation[last];
+    generation[index] = lastObj;
+    lastObj->GetExpirationState()->mIndexInGeneration = index;
+    generation.RemoveElementAt(last);
+    state->mGeneration = nsExpirationState::NOT_TRACKED;
+
+
+
+
+
+  }
+
+
+
+
+
+  nsresult MarkUsedLocked(T* aObj, const AutoLock& aAutoLock)
+  {
+    nsExpirationState* state = aObj->GetExpirationState();
+    if (mNewestGeneration == state->mGeneration) {
+      return NS_OK;
+    }
+    RemoveObjectLocked(aObj, aAutoLock);
+    return AddObjectLocked(aObj, aAutoLock);
+  }
+
+
+
+
+
+  void AgeOneGenerationLocked(const AutoLock& aAutoLock)
+  {
+    if (mInAgeOneGeneration) {
+      do { } while(0);
+      return;
+    }
+
+    mInAgeOneGeneration = true;
+    uint32_t reapGeneration =
+      mNewestGeneration > 0 ? mNewestGeneration - 1 : K - 1;
+    nsTArray<T*>& generation = mGenerations[reapGeneration];
+# 235 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+    size_t index = generation.Length();
+    for (;;) {
+
+
+      index = XPCOM_MIN(index, generation.Length());
+      if (index == 0) {
+        break;
+      }
+      --index;
+      NotifyExpiredLocked(generation[index], aAutoLock);
+    }
+
+
+    if (!generation.IsEmpty()) {
+      do { } while(0);
+    }
+
+
+    generation.Compact();
+    mNewestGeneration = reapGeneration;
+    mInAgeOneGeneration = false;
+  }
+# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+  void AgeAllGenerationsLocked(const AutoLock& aAutoLock)
+  {
+    uint32_t i;
+    for (i = 0; i < K; ++i) {
+      AgeOneGenerationLocked(aAutoLock);
+    }
+  }
+
+  class Iterator
+  {
+  private:
+    ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mTracker;
+    uint32_t mGeneration;
+    uint32_t mIndex;
+  public:
+    Iterator(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aTracker,
+             AutoLock& aAutoLock)
+      : mTracker(aTracker)
+      , mGeneration(0)
+      , mIndex(0)
+    {
+    }
+
+    T* Next()
+    {
+      while (mGeneration < K) {
+        nsTArray<T*>* generation = &mTracker->mGenerations[mGeneration];
+        if (mIndex < generation->Length()) {
+          ++mIndex;
+          return (*generation)[mIndex - 1];
+        }
+        ++mGeneration;
+        mIndex = 0;
+      }
+      return nullptr;
+    }
+  };
+
+  friend class Iterator;
+
+  bool IsEmptyLocked(const AutoLock& aAutoLock)
+  {
+    for (uint32_t i = 0; i < K; ++i) {
+      if (!mGenerations[i].IsEmpty()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+protected:
+# 342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
+  virtual void NotifyExpiredLocked(T*, const AutoLock&) = 0;
+
+  virtual Mutex& GetMutex() = 0;
+
+private:
+  class ExpirationTrackerObserver;
+  RefPtr<ExpirationTrackerObserver> mObserver;
+  nsTArray<T*> mGenerations[K];
+  nsCOMPtr<nsITimer> mTimer;
+  uint32_t mTimerPeriod;
+  uint32_t mNewestGeneration;
+  bool mInAgeOneGeneration;
+  const char* const mName;
+  const nsCOMPtr<nsIEventTarget> mEventTarget;
+
+
+
+
+
+  class ExpirationTrackerObserver final : public nsIObserver
+  {
+  public:
+    void Init(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aObj)
+    {
+      mOwner = aObj;
+      nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+      if (obs) {
+        obs->AddObserver(this, "memory-pressure", false);
+      }
+    }
+    void Destroy()
+    {
+      mOwner = nullptr;
+      nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+      if (obs) {
+        obs->RemoveObserver(this, "memory-pressure");
+      }
+    }
+    public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+    virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
+  private:
+    ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mOwner;
+  };
+
+  void HandleLowMemory() {
+    AutoLock lock(GetMutex());
+    AgeAllGenerationsLocked(lock);
+  }
+
+  void HandleTimeout() {
+    AutoLock lock(GetMutex());
+    AgeOneGenerationLocked(lock);
+
+    if (IsEmptyLocked(lock)) {
+      mTimer->Cancel();
+      mTimer = nullptr;
+    }
+  }
+
+  static void TimerCallback(nsITimer* aTimer, void* aThis)
+  {
+    ExpirationTrackerImpl* tracker = static_cast<ExpirationTrackerImpl*>(aThis);
+    tracker->HandleTimeout();
+  }
+
+  nsresult CheckStartTimerLocked(const AutoLock& aAutoLock)
+  {
+    if (mTimer || !mTimerPeriod) {
+      return NS_OK;
+    }
+    mTimer = do_CreateInstance("@mozilla.org/timer;1");
+    if (!mTimer) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    if (mEventTarget) {
+      mTimer->SetTarget(mEventTarget);
+    } else if (!NS_IsMainThread()) {
+
+
+      nsCOMPtr<nsIEventTarget> target = do_GetMainThread();
+      do { if ((__builtin_expect(!!(!(target)), 0))) { do { } while(0); return NS_ERROR_UNEXPECTED; } } while(0);
+      mTimer->SetTarget(target);
+    }
+    mTimer->InitWithNamedFuncCallback(TimerCallback, this, mTimerPeriod,
+                                      nsITimer::TYPE_REPEATING_SLACK, mName);
+    return NS_OK;
+  }
+};
+
+namespace detail {
+
+class PlaceholderLock {
+public:
+  void Lock() {}
+  void Unlock() {}
+};
+
+class PlaceholderAutoLock {
+public:
+  explicit PlaceholderAutoLock(PlaceholderLock&) { }
+  ~PlaceholderAutoLock() = default;
+
+};
+
+template<typename T, uint32_t K>
+using SingleThreadedExpirationTracker =
+  ExpirationTrackerImpl<T, K, PlaceholderLock, PlaceholderAutoLock>;
+
+}
+
+template<typename T, uint32_t K>
+class nsExpirationTracker : protected ::detail::SingleThreadedExpirationTracker<T, K>
+{
+  typedef ::detail::PlaceholderLock Lock;
+  typedef ::detail::PlaceholderAutoLock AutoLock;
+
+  Lock mLock;
+
+  AutoLock FakeLock() {
+    return AutoLock(mLock);
+  }
+
+  Lock& GetMutex() override
+  {
+    return mLock;
+  }
+
+  void NotifyExpiredLocked(T* aObject, const AutoLock&) override
+  {
+    NotifyExpired(aObject);
+  }
+
+protected:
+  virtual void NotifyExpired(T* aObj) = 0;
+
+public:
+  nsExpirationTracker(uint32_t aTimerPeriod,
+                      const char* aName,
+                      nsIEventTarget* aEventTarget = nullptr)
+    : ::detail::SingleThreadedExpirationTracker<T, K>(aTimerPeriod,
+                                                      aName,
+                                                      aEventTarget)
+  { }
+
+  virtual ~nsExpirationTracker()
+  { }
+
+  nsresult AddObject(T* aObj)
+  {
+    return this->AddObjectLocked(aObj, FakeLock());
+  }
+
+  void RemoveObject(T* aObj)
+  {
+    this->RemoveObjectLocked(aObj, FakeLock());
+  }
+
+  nsresult MarkUsed(T* aObj)
+  {
+    return this->MarkUsedLocked(aObj, FakeLock());
+  }
+
+  void AgeOneGeneration()
+  {
+    this->AgeOneGenerationLocked(FakeLock());
+  }
+
+  void AgeAllGenerations()
+  {
+    this->AgeAllGenerationsLocked(FakeLock());
+  }
+
+  class Iterator
+  {
+  private:
+    AutoLock mAutoLock;
+    typename ExpirationTrackerImpl<T, K, Lock, AutoLock>::Iterator mIterator;
+  public:
+    explicit Iterator(nsExpirationTracker<T, K>* aTracker)
+      : mAutoLock(aTracker->GetMutex())
+      , mIterator(aTracker, mAutoLock)
+    {
+    }
+
+    T* Next()
+    {
+      return mIterator.Next();
+    }
+  };
+
+  friend class Iterator;
+
+  bool IsEmpty()
+  {
+    return this->IsEmptyLocked(FakeLock());
+  }
+};
+
+template<typename T, uint32_t K, typename Mutex, typename AutoLock>
+nsresult
+ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ExpirationTrackerObserver::Observe(
+    nsISupports* aSubject, const char* aTopic, const char16_t* aData)
+{
+  if (!strcmp(aTopic, "memory-pressure") && mOwner) {
+    mOwner->HandleLowMemory();
+  }
+  return NS_OK;
+}
+
+template<class T, uint32_t K, typename Mutex, typename AutoLock>
+MozExternalRefCountType
+ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ExpirationTrackerObserver::AddRef(void)
+{
+  do { } while (0);
+  ((void)0);
+  ++mRefCnt;
+                                                                          ;
+  return mRefCnt;
+}
+
+template<class T, uint32_t K, typename Mutex, typename AutoLock>
+MozExternalRefCountType
+ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ExpirationTrackerObserver::Release(void)
+{
+  do { } while (0);
+  ((void)0);
+  --mRefCnt;
+                                                            ;
+  if (mRefCnt == 0) {
+    ((void)0);
+    mRefCnt = 1;
+    delete (this);
+    return 0;
+  }
+  return mRefCnt;
+}
+
+template<class T, uint32_t K, typename Mutex, typename AutoLock>
+nsresult
+ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ExpirationTrackerObserver::QueryInterface(
+    const nsIID& aIID, void** aInstancePtr)
+{
+  do { } while(0);
+
+  nsresult rv = NS_ERROR_FAILURE;
+  static_assert( sizeof("(nsIObserver)") != sizeof("()") && (11) > 10 && (int)(0.01) == 0, "MOZ_STATIC_ASSERT_VALID_ARG_COUNT requires 1 to 50 arguments"); static const QITableEntry table[] = { { &(nsIObserver::COMTypeInfo<nsIObserver, void>::kIID), int32_t(reinterpret_cast<char*>( static_cast<nsIObserver*>((ExpirationTrackerObserver*) 0x1000)) - reinterpret_cast<char*>((ExpirationTrackerObserver*) 0x1000)) }, { &(nsISupports::COMTypeInfo<nsISupports, void>::kIID), int32_t(reinterpret_cast<char*>( static_cast<nsISupports*>( static_cast<nsIObserver*>( (ExpirationTrackerObserver*) 0x1000))) - reinterpret_cast<char*>((ExpirationTrackerObserver*) 0x1000)) }, { nullptr, 0 } }; static_assert((sizeof(table)/sizeof(table[0])) > 1, "need at least 1 interface"); rv = NS_TableDrivenQI(static_cast<void*>(this), aIID, aInstancePtr, table);
+  return rv;
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 1 3
+# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+  template<size_t _Nw>
+    struct _Base_bitset
+    {
+      typedef unsigned long _WordT;
+
+
+      _WordT _M_w[_Nw];
+
+      constexpr _Base_bitset() noexcept
+      : _M_w() { }
+
+
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+      : _M_w{ _WordT(__val)
+
+
+
+       } { }
+
+
+
+
+
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t __pos) noexcept
+      { return _M_w[_S_whichword(__pos)]; }
+
+      constexpr _WordT
+      _M_getword(size_t __pos) const noexcept
+      { return _M_w[_S_whichword(__pos)]; }
+
+
+      const _WordT*
+      _M_getdata() const noexcept
+      { return _M_w; }
+
+
+      _WordT&
+      _M_hiword() noexcept
+      { return _M_w[_Nw - 1]; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return _M_w[_Nw - 1]; }
+
+      void
+      _M_do_and(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] &= __x._M_w[__i];
+      }
+
+      void
+      _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] |= __x._M_w[__i];
+      }
+
+      void
+      _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] ^= __x._M_w[__i];
+      }
+
+      void
+      _M_do_left_shift(size_t __shift) noexcept;
+
+      void
+      _M_do_right_shift(size_t __shift) noexcept;
+
+      void
+      _M_do_flip() noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~_M_w[__i];
+      }
+
+      void
+      _M_do_set() noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~static_cast<_WordT>(0);
+      }
+
+      void
+      _M_do_reset() noexcept
+      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+
+      bool
+      _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; ++__i)
+   if (_M_w[__i] != __x._M_w[__i])
+     return false;
+ return true;
+      }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        {
+   for (size_t __i = 0; __i < _Nw - 1; __i++)
+     if (_M_w[__i] != ~static_cast<_WordT>(0))
+       return false;
+   return _M_hiword() == (~static_cast<_WordT>(0)
+     >> (_Nw * (8 * 8)
+         - _Nb));
+ }
+
+      bool
+      _M_is_any() const noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   if (_M_w[__i] != static_cast<_WordT>(0))
+     return true;
+ return false;
+      }
+
+      size_t
+      _M_do_count() const noexcept
+      {
+ size_t __result = 0;
+ for (size_t __i = 0; __i < _Nw; __i++)
+   __result += __builtin_popcountl(_M_w[__i]);
+ return __result;
+      }
+
+      unsigned long
+      _M_do_to_ulong() const;
+
+
+      unsigned long long
+      _M_do_to_ullong() const;
+
+
+
+      size_t
+      _M_do_find_first(size_t) const noexcept;
+
+
+      size_t
+      _M_do_find_next(size_t, size_t) const noexcept;
+    };
+
+
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+
+   if (__offset == 0)
+     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+       _M_w[__n] = _M_w[__n - __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
+        | (_M_w[__n - __wshift - 1] >> __sub_offset));
+       _M_w[__wshift] = _M_w[0] << __offset;
+     }
+
+   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
+ }
+    }
+
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+   const size_t __limit = _Nw - __wshift - 1;
+
+   if (__offset == 0)
+     for (size_t __n = 0; __n <= __limit; ++__n)
+       _M_w[__n] = _M_w[__n + __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = 0; __n < __limit; ++__n)
+  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
+        | (_M_w[__n + __wshift + 1] << __sub_offset));
+       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+     }
+
+   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
+ }
+    }
+
+  template<size_t _Nw>
+    unsigned long
+    _Base_bitset<_Nw>::_M_do_to_ulong() const
+    {
+      for (size_t __i = 1; __i < _Nw; ++__i)
+ if (_M_w[__i])
+   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
+      return _M_w[0];
+    }
+
+
+  template<size_t _Nw>
+    unsigned long long
+    _Base_bitset<_Nw>::_M_do_to_ullong() const
+    {
+      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
+      for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
+ if (_M_w[__i])
+   __throw_overflow_error(("_Base_bitset::_M_do_to_ullong"));
+
+      if (__dw)
+ return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
+     << (8 * 8));
+      return _M_w[0];
+    }
+
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_first(size_t __not_found) const noexcept
+    {
+      for (size_t __i = 0; __i < _Nw; __i++)
+ {
+   _WordT __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+
+      return __not_found;
+    }
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
+    {
+
+      ++__prev;
+
+
+      if (__prev >= _Nw * (8 * 8))
+ return __not_found;
+
+
+      size_t __i = _S_whichword(__prev);
+      _WordT __thisword = _M_w[__i];
+
+
+      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+      if (__thisword != static_cast<_WordT>(0))
+ return (__i * (8 * 8)
+  + __builtin_ctzl(__thisword));
+
+
+      __i++;
+      for (; __i < _Nw; __i++)
+ {
+   __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+
+      return __not_found;
+    }
+
+
+
+
+
+
+  template<>
+    struct _Base_bitset<1>
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w;
+
+      constexpr _Base_bitset() noexcept
+      : _M_w(0)
+      { }
+
+
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+
+
+
+      : _M_w(__val)
+      { }
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t) noexcept
+      { return _M_w; }
+
+      constexpr _WordT
+      _M_getword(size_t) const noexcept
+      { return _M_w; }
+
+
+      const _WordT*
+      _M_getdata() const noexcept
+      { return &_M_w; }
+
+
+      _WordT&
+      _M_hiword() noexcept
+      { return _M_w; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return _M_w; }
+
+      void
+      _M_do_and(const _Base_bitset<1>& __x) noexcept
+      { _M_w &= __x._M_w; }
+
+      void
+      _M_do_or(const _Base_bitset<1>& __x) noexcept
+      { _M_w |= __x._M_w; }
+
+      void
+      _M_do_xor(const _Base_bitset<1>& __x) noexcept
+      { _M_w ^= __x._M_w; }
+
+      void
+      _M_do_left_shift(size_t __shift) noexcept
+      { _M_w <<= __shift; }
+
+      void
+      _M_do_right_shift(size_t __shift) noexcept
+      { _M_w >>= __shift; }
+
+      void
+      _M_do_flip() noexcept
+      { _M_w = ~_M_w; }
+
+      void
+      _M_do_set() noexcept
+      { _M_w = ~static_cast<_WordT>(0); }
+
+      void
+      _M_do_reset() noexcept
+      { _M_w = 0; }
+
+      bool
+      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
+      { return _M_w == __x._M_w; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        { return _M_w == (~static_cast<_WordT>(0)
+     >> ((8 * 8) - _Nb)); }
+
+      bool
+      _M_is_any() const noexcept
+      { return _M_w != 0; }
+
+      size_t
+      _M_do_count() const noexcept
+      { return __builtin_popcountl(_M_w); }
+
+      unsigned long
+      _M_do_to_ulong() const noexcept
+      { return _M_w; }
+
+
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return _M_w; }
+
+
+      size_t
+      _M_do_find_first(size_t __not_found) const noexcept
+      {
+        if (_M_w != 0)
+          return __builtin_ctzl(_M_w);
+        else
+          return __not_found;
+      }
+
+
+      size_t
+      _M_do_find_next(size_t __prev, size_t __not_found) const
+ noexcept
+      {
+ ++__prev;
+ if (__prev >= ((size_t) (8 * 8)))
+   return __not_found;
+
+ _WordT __x = _M_w >> __prev;
+ if (__x != 0)
+   return __builtin_ctzl(__x) + __prev;
+ else
+   return __not_found;
+      }
+    };
+
+
+
+
+
+
+  template<>
+    struct _Base_bitset<0>
+    {
+      typedef unsigned long _WordT;
+
+      constexpr _Base_bitset() noexcept
+      { }
+
+
+      constexpr _Base_bitset(unsigned long long) noexcept
+
+
+
+      { }
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+# 556 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      _WordT&
+      _M_getword(size_t) noexcept
+      {
+ __throw_out_of_range(("_Base_bitset::_M_getword"));
+ return *new _WordT;
+      }
+
+      constexpr _WordT
+      _M_getword(size_t __pos) const noexcept
+      { return 0; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return 0; }
+
+      void
+      _M_do_and(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_or(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_xor(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_left_shift(size_t) noexcept
+      { }
+
+      void
+      _M_do_right_shift(size_t) noexcept
+      { }
+
+      void
+      _M_do_flip() noexcept
+      { }
+
+      void
+      _M_do_set() noexcept
+      { }
+
+      void
+      _M_do_reset() noexcept
+      { }
+
+
+
+
+      bool
+      _M_is_equal(const _Base_bitset<0>&) const noexcept
+      { return true; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        { return true; }
+
+      bool
+      _M_is_any() const noexcept
+      { return false; }
+
+      size_t
+      _M_do_count() const noexcept
+      { return 0; }
+
+      unsigned long
+      _M_do_to_ulong() const noexcept
+      { return 0; }
+
+
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return 0; }
+
+
+
+
+      size_t
+      _M_do_find_first(size_t) const noexcept
+      { return 0; }
+
+      size_t
+      _M_do_find_next(size_t, size_t) const noexcept
+      { return 0; }
+    };
+
+
+
+  template<size_t _Extrabits>
+    struct _Sanitize
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT& __val) noexcept
+      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
+    };
+
+  template<>
+    struct _Sanitize<0>
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT) noexcept { }
+    };
+
+
+  template<size_t _Nb, bool = (_Nb < (8 * 8))>
+    struct _Sanitize_val
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val; }
+    };
+
+  template<size_t _Nb>
+    struct _Sanitize_val<_Nb, true>
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
+    };
+# 746 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+  template<size_t _Nb>
+    class bitset
+    : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
+    {
+    private:
+      typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
+      typedef unsigned long _WordT;
+
+      template<class _CharT, class _Traits, class _Alloc>
+      void
+      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+    size_t __position) const
+      {
+ if (__position > __s.size())
+   __throw_out_of_range_fmt(("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)"),
+
+
+       __position, __s.size());
+      }
+
+      void _M_check(size_t __position, const char *__s) const
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range_fmt(("%s: __position (which is %zu) " ">= _Nb (which is %zu)"),
+
+       __s, __position, _Nb);
+      }
+
+      void
+      _M_do_sanitize() noexcept
+      {
+ typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
+ __sanitize_type::_S_do_sanitize(this->_M_hiword());
+      }
+
+
+      template<typename> friend struct hash;
+
+
+    public:
+# 798 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      class reference
+      {
+ friend class bitset;
+
+ _WordT* _M_wp;
+ size_t _M_bpos;
+
+
+ reference();
+
+      public:
+ reference(bitset& __b, size_t __pos) noexcept
+ {
+   _M_wp = &__b._M_getword(__pos);
+   _M_bpos = _Base::_S_whichbit(__pos);
+ }
+
+ ~reference() noexcept
+ { }
+
+
+ reference&
+ operator=(bool __x) noexcept
+ {
+   if (__x)
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+
+
+ reference&
+ operator=(const reference& __j) noexcept
+ {
+   if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+
+
+ bool
+ operator~() const noexcept
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
+
+
+ operator bool() const noexcept
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
+
+
+ reference&
+ flip() noexcept
+ {
+   *_M_wp ^= _Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+      };
+      friend class reference;
+
+
+
+      constexpr bitset() noexcept
+      { }
+
+
+
+      constexpr bitset(unsigned long long __val) noexcept
+      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
+# 883 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ explicit
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position = 0)
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position,
+         std::basic_string<_CharT, _Traits, _Alloc>::npos,
+         _CharT('0'), _CharT('1'));
+ }
+# 905 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n)
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
+ }
+
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n,
+        _CharT __zero, _CharT __one = _CharT('1'))
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position, __n, __zero, __one);
+ }
+# 936 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      template<typename _CharT>
+        explicit
+        bitset(const _CharT* __str,
+        typename std::basic_string<_CharT>::size_type __n
+        = std::basic_string<_CharT>::npos,
+        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
+        : _Base()
+        {
+   if (!__str)
+     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));
+
+   if (__n == std::basic_string<_CharT>::npos)
+     __n = std::char_traits<_CharT>::length(__str);
+   _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
+            __n, __zero,
+            __one);
+ }
+# 963 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_and(__rhs);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_or(__rhs);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_xor(__rhs);
+ return *this;
+      }
+# 992 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      bitset<_Nb>&
+      operator<<=(size_t __position) noexcept
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_left_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator>>=(size_t __position) noexcept
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_right_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+# 1025 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos, int __val) noexcept
+      {
+ if (__val)
+   this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ else
+   this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_reset(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_flip(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      constexpr bool
+      _Unchecked_test(size_t __pos) const noexcept
+      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
+  != static_cast<_WordT>(0)); }
+
+
+
+
+
+
+      bitset<_Nb>&
+      set() noexcept
+      {
+ this->_M_do_set();
+ this->_M_do_sanitize();
+ return *this;
+      }
+
+
+
+
+
+
+
+      bitset<_Nb>&
+      set(size_t __position, bool __val = true)
+      {
+ this->_M_check(__position, ("bitset::set"));
+ return _Unchecked_set(__position, __val);
+      }
+
+
+
+
+      bitset<_Nb>&
+      reset() noexcept
+      {
+ this->_M_do_reset();
+ return *this;
+      }
+# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      bitset<_Nb>&
+      reset(size_t __position)
+      {
+ this->_M_check(__position, ("bitset::reset"));
+ return _Unchecked_reset(__position);
+      }
+
+
+
+
+      bitset<_Nb>&
+      flip() noexcept
+      {
+ this->_M_do_flip();
+ this->_M_do_sanitize();
+ return *this;
+      }
+
+
+
+
+
+
+      bitset<_Nb>&
+      flip(size_t __position)
+      {
+ this->_M_check(__position, ("bitset::flip"));
+ return _Unchecked_flip(__position);
+      }
+
+
+      bitset<_Nb>
+      operator~() const noexcept
+      { return bitset<_Nb>(*this).flip(); }
+# 1154 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      reference
+      operator[](size_t __position)
+      { return reference(*this, __position); }
+
+      constexpr bool
+      operator[](size_t __position) const
+      { return _Unchecked_test(__position); }
+# 1169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      unsigned long
+      to_ulong() const
+      { return this->_M_do_to_ulong(); }
+
+
+      unsigned long long
+      to_ullong() const
+      { return this->_M_do_to_ullong(); }
+# 1187 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string() const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
+   return __result;
+ }
+
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, __zero, __one);
+   return __result;
+ }
+
+
+
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string() const
+ { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+
+
+
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ { return to_string<_CharT, _Traits,
+                    std::allocator<_CharT> >(__zero, __one); }
+
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string() const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >();
+ }
+
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >(__zero, __one);
+ }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >();
+      }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >(__zero, __one);
+      }
+
+
+      template<class _CharT, class _Traits>
+        void
+        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
+    _CharT, _CharT);
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n,
+       _CharT __zero, _CharT __one)
+ { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
+         __zero, __one); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
+     _CharT, _CharT) const;
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n)
+ { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
+ { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
+
+
+      size_t
+      count() const noexcept
+      { return this->_M_do_count(); }
+
+
+      constexpr size_t
+      size() const noexcept
+      { return _Nb; }
+
+
+
+      bool
+      operator==(const bitset<_Nb>& __rhs) const noexcept
+      { return this->_M_is_equal(__rhs); }
+
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const noexcept
+      { return !this->_M_is_equal(__rhs); }
+# 1312 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      bool
+      test(size_t __position) const
+      {
+ this->_M_check(__position, ("bitset::test"));
+ return _Unchecked_test(__position);
+      }
+
+
+
+
+
+
+
+      bool
+      all() const noexcept
+      { return this->template _M_are_all<_Nb>(); }
+
+
+
+
+
+      bool
+      any() const noexcept
+      { return this->_M_is_any(); }
+
+
+
+
+
+      bool
+      none() const noexcept
+      { return !this->_M_is_any(); }
+
+
+
+      bitset<_Nb>
+      operator<<(size_t __position) const noexcept
+      { return bitset<_Nb>(*this) <<= __position; }
+
+      bitset<_Nb>
+      operator>>(size_t __position) const noexcept
+      { return bitset<_Nb>(*this) >>= __position; }
+# 1362 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      size_t
+      _Find_first() const noexcept
+      { return this->_M_do_find_first(_Nb); }
+# 1373 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+      size_t
+      _Find_next(size_t __prev) const noexcept
+      { return this->_M_do_find_next(__prev, _Nb); }
+    };
+
+
+  template<size_t _Nb>
+    template<class _CharT, class _Traits>
+      void
+      bitset<_Nb>::
+      _M_copy_from_ptr(const _CharT* __s, size_t __len,
+         size_t __pos, size_t __n, _CharT __zero, _CharT __one)
+      {
+ reset();
+ const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
+ for (size_t __i = __nbits; __i > 0; --__i)
+   {
+     const _CharT __c = __s[__pos + __nbits - __i];
+     if (_Traits::eq(__c, __zero))
+       ;
+     else if (_Traits::eq(__c, __one))
+       _Unchecked_set(__i - 1);
+     else
+       __throw_invalid_argument(("bitset::_M_copy_from_ptr"));
+   }
+      }
+
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+      void
+      bitset<_Nb>::
+      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
+   _CharT __zero, _CharT __one) const
+      {
+ __s.assign(_Nb, __zero);
+ for (size_t __i = _Nb; __i > 0; --__i)
+   if (_Unchecked_test(__i - 1))
+     _Traits::assign(__s[_Nb - __i], __one);
+      }
+# 1423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result &= __y;
+      return __result;
+    }
+
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result |= __y;
+      return __result;
+    }
+
+  template <size_t _Nb>
+    inline bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
+# 1460 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+  template<class _CharT, class _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    {
+      typedef typename _Traits::char_type char_type;
+      typedef std::basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::ios_base __ios_base;
+
+      std::basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(_Nb);
+
+
+
+      const char_type __zero = __is.widen('0');
+      const char_type __one = __is.widen('1');
+
+      typename __ios_base::iostate __state = __ios_base::goodbit;
+      typename __istream_type::sentry __sentry(__is);
+      if (__sentry)
+ {
+   try
+     {
+       for (size_t __i = _Nb; __i > 0; --__i)
+  {
+    static typename _Traits::int_type __eof = _Traits::eof();
+
+    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
+    if (_Traits::eq_int_type(__c1, __eof))
+      {
+        __state |= __ios_base::eofbit;
+        break;
+      }
+    else
+      {
+        const char_type __c2 = _Traits::to_char_type(__c1);
+        if (_Traits::eq(__c2, __zero))
+   __tmp.push_back(__zero);
+        else if (_Traits::eq(__c2, __one))
+   __tmp.push_back(__one);
+        else if (_Traits::
+          eq_int_type(__is.rdbuf()->sputbackc(__c2),
+        __eof))
+   {
+     __state |= __ios_base::failbit;
+     break;
+   }
+      }
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __is._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __is._M_setstate(__ios_base::badbit); }
+ }
+
+      if (__tmp.empty() && _Nb)
+ __state |= __ios_base::failbit;
+      else
+ __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
+    __zero, __one);
+      if (__state)
+ __is.setstate(__state);
+      return __is;
+    }
+
+  template <class _CharT, class _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const bitset<_Nb>& __x)
+    {
+      std::basic_string<_CharT, _Traits> __tmp;
+
+
+
+      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
+      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
+      return __os << __tmp;
+    }
+
+
+
+}
+# 1554 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<size_t _Nb>
+    struct hash<std::bitset<_Nb>>
+    : public __hash_base<size_t, std::bitset<_Nb>>
+    {
+      size_t
+      operator()(const std::bitset<_Nb>& __b) const noexcept
+      {
+ const size_t __clength = (_Nb + 8 - 1) / 8;
+ return std::_Hash_impl::hash(__b._M_getdata(), __clength);
+      }
+    };
+
+  template<>
+    struct hash<std::bitset<0>>
+    : public __hash_base<size_t, std::bitset<0>>
+    {
+      size_t
+      operator()(const std::bitset<0>&) const noexcept
+      { return 0; }
+    };
+
+
+}
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h"
+class nsIDocument;
+struct nsIDocumentAtoms;
+
+namespace mozilla {
+namespace dom {
+
+struct ElementCreationOptionsAtoms;
+struct NativePropertyHooks;
+class ProtoAndIfaceCache;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class VisibilityState : uint8_t {
+  Hidden,
+  Visible,
+  Prerender,
+  EndGuard_
+};
+
+namespace VisibilityStateValues {
+extern const EnumEntry strings[4];
+}
+
+bool
+ToJSValue(JSContext* aCx, VisibilityState aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+enum class FlashClassification : uint8_t {
+  Unclassified,
+  Unknown,
+  Allowed,
+  Denied,
+  EndGuard_
+};
+
+namespace FlashClassificationValues {
+extern const EnumEntry strings[5];
+}
+
+bool
+ToJSValue(JSContext* aCx, FlashClassification aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+struct ElementCreationOptions : public DictionaryBase
+{
+                        Optional<nsString> mIs;
+                        Optional<nsString> mPseudo;
+
+  ElementCreationOptions();
+
+  explicit inline ElementCreationOptions(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline ElementCreationOptions(const ElementCreationOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  ElementCreationOptions&
+  operator=(const ElementCreationOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, ElementCreationOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastElementCreationOptions : public ElementCreationOptions
+{
+  inline FastElementCreationOptions()
+    : ElementCreationOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+class ElementCreationOptionsOrString
+{
+  friend class ElementCreationOptionsOrStringArgument;
+  enum Type
+  {
+    eUninitialized,
+    eElementCreationOptions,
+    eString
+  };
+
+  union Value
+  {
+    UnionMember<binding_detail::FastElementCreationOptions > mElementCreationOptions;
+    UnionMember<binding_detail::FakeString > mString;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+  ElementCreationOptionsOrString(const ElementCreationOptionsOrString&) = delete;
+  ElementCreationOptionsOrString& operator=(const ElementCreationOptionsOrString&) = delete;
+public:
+  explicit inline ElementCreationOptionsOrString()
+    : mType(eUninitialized)
+  {
+  }
+
+  inline ~ElementCreationOptionsOrString()
+  {
+    Uninit();
+  }
+
+  inline binding_detail::FastElementCreationOptions&
+  RawSetAsElementCreationOptions()
+  {
+    if (mType == eElementCreationOptions) {
+      return mValue.mElementCreationOptions.Value();
+    }
+    do { } while (0);
+    mType = eElementCreationOptions;
+    return mValue.mElementCreationOptions.SetValue();
+  }
+
+  inline binding_detail::FastElementCreationOptions&
+  SetAsElementCreationOptions()
+  {
+    if (mType == eElementCreationOptions) {
+      return mValue.mElementCreationOptions.Value();
+    }
+    Uninit();
+    mType = eElementCreationOptions;
+    return mValue.mElementCreationOptions.SetValue();
+  }
+
+  inline bool
+  IsElementCreationOptions() const
+  {
+    return mType == eElementCreationOptions;
+  }
+
+  inline binding_detail::FastElementCreationOptions&
+  GetAsElementCreationOptions()
+  {
+    do { } while (0);
+    return mValue.mElementCreationOptions.Value();
+  }
+
+  inline const ElementCreationOptions&
+  GetAsElementCreationOptions() const
+  {
+    do { } while (0);
+    return mValue.mElementCreationOptions.Value();
+  }
+
+  inline binding_detail::FakeString&
+  RawSetAsString()
+  {
+    if (mType == eString) {
+      return mValue.mString.Value();
+    }
+    do { } while (0);
+    mType = eString;
+    return mValue.mString.SetValue();
+  }
+
+  inline binding_detail::FakeString&
+  SetAsString()
+  {
+    if (mType == eString) {
+      return mValue.mString.Value();
+    }
+    Uninit();
+    mType = eString;
+    return mValue.mString.SetValue();
+  }
+
+  inline bool
+  IsString() const
+  {
+    return mType == eString;
+  }
+
+  inline binding_detail::FakeString&
+  GetAsString()
+  {
+    do { } while (0);
+    return mValue.mString.Value();
+  }
+
+  inline const nsAString&
+  GetAsString() const
+  {
+    do { } while (0);
+    return mValue.mString.Value();
+  }
+
+  inline void
+  Uninit()
+  {
+    switch (mType) {
+      case eUninitialized: {
+        break;
+      }
+      case eElementCreationOptions: {
+        DestroyElementCreationOptions();
+        break;
+      }
+      case eString: {
+        DestroyString();
+        break;
+      }
+    }
+  }
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+private:
+  inline void
+  DestroyElementCreationOptions()
+  {
+    do { } while (0);
+    mValue.mElementCreationOptions.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyString()
+  {
+    do { } while (0);
+    mValue.mString.Destroy();
+    mType = eUninitialized;
+  }
+};
+
+
+class OwningElementCreationOptionsOrString : public AllOwningUnionBase
+{
+  friend void ImplCycleCollectionUnlink(OwningElementCreationOptionsOrString& aUnion);
+  enum Type
+  {
+    eUninitialized,
+    eElementCreationOptions,
+    eString
+  };
+
+  union Value
+  {
+    UnionMember<ElementCreationOptions > mElementCreationOptions;
+    UnionMember<nsString > mString;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+public:
+  explicit inline OwningElementCreationOptionsOrString()
+    : mType(eUninitialized)
+  {
+  }
+
+  explicit inline OwningElementCreationOptionsOrString(const OwningElementCreationOptionsOrString& aOther)
+    : mType(eUninitialized)
+  {
+    *this = aOther;
+  }
+
+  inline ~OwningElementCreationOptionsOrString()
+  {
+    Uninit();
+  }
+
+  ElementCreationOptions&
+  RawSetAsElementCreationOptions();
+
+  ElementCreationOptions&
+  SetAsElementCreationOptions();
+
+  bool
+  TrySetToElementCreationOptions(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsElementCreationOptions() const
+  {
+    return mType == eElementCreationOptions;
+  }
+
+  inline ElementCreationOptions&
+  GetAsElementCreationOptions()
+  {
+    do { } while (0);
+    return mValue.mElementCreationOptions.Value();
+  }
+
+  inline ElementCreationOptions const &
+  GetAsElementCreationOptions() const
+  {
+    do { } while (0);
+    return mValue.mElementCreationOptions.Value();
+  }
+
+  nsString&
+  RawSetAsString();
+
+  nsString&
+  SetAsString();
+
+  bool
+  TrySetToString(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline void
+  SetStringData(const nsString::char_type* aData, nsString::size_type aLength)
+  {
+    RawSetAsString().Assign(aData, aLength);
+  }
+
+  inline bool
+  IsString() const
+  {
+    return mType == eString;
+  }
+
+  inline nsString&
+  GetAsString()
+  {
+    do { } while (0);
+    return mValue.mString.Value();
+  }
+
+  inline nsString const &
+  GetAsString() const
+  {
+    do { } while (0);
+    return mValue.mString.Value();
+  }
+
+  void
+  Uninit();
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceUnion(JSTracer* trc);
+
+  OwningElementCreationOptionsOrString&
+  operator=(const OwningElementCreationOptionsOrString& aOther);
+
+private:
+  void
+  DestroyElementCreationOptions();
+
+  void
+  DestroyString();
+};
+
+
+namespace DocumentBinding {
+
+  typedef nsIDocument NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, nsIDocument* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JSObject*
+  GetProtoObject(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+
+
+
+
+
+
+
+
+class gfxUserFontSet;
+class imgIRequest;
+class nsAString;
+class nsBindingManager;
+class nsIDocShell;
+class nsDocShell;
+class nsDOMNavigationTiming;
+class nsFrameLoader;
+class nsHTMLCSSStyleSheet;
+class nsHTMLDocument;
+class nsHTMLStyleSheet;
+class nsIAtom;
+class nsIBFCacheEntry;
+class nsIChannel;
+class nsIContent;
+class nsIContentSink;
+class nsIDocShell;
+class nsIDocShellTreeItem;
+class nsIDocumentEncoder;
+class nsIDocumentObserver;
+class nsIDOMDocument;
+class nsIDOMDocumentType;
+class nsIDOMElement;
+class nsIDOMNodeFilter;
+class nsIDOMNodeList;
+class nsIHTMLCollection;
+class nsILayoutHistoryState;
+class nsILoadContext;
+class nsIObjectLoadingContent;
+class nsIObserver;
+class nsIPresShell;
+class nsIPrincipal;
+class nsIRequest;
+class nsIRunnable;
+class nsIStreamListener;
+class nsIStructuredCloneContainer;
+class nsIURI;
+class nsIVariant;
+class nsViewManager;
+class nsPresContext;
+class nsRange;
+class nsScriptLoader;
+class nsSMILAnimationController;
+class nsSVGElement;
+class nsTextNode;
+class nsWindowSizes;
+class nsDOMCaretPosition;
+class nsViewportInfo;
+class nsIGlobalObject;
+struct nsCSSSelectorList;
+
+namespace mozilla {
+class AbstractThread;
+class CSSStyleSheet;
+class ErrorResult;
+class EventStates;
+class PendingAnimationTracker;
+class StyleSetHandle;
+template<typename> class OwningNonNull;
+
+namespace css {
+class Loader;
+class ImageLoader;
+class Rule;
+}
+
+namespace dom {
+class Animation;
+class AnonymousContent;
+class Attr;
+class BoxObject;
+class CDATASection;
+class Comment;
+struct CustomElementDefinition;
+class DocGroup;
+class DocumentFragment;
+class DocumentTimeline;
+class DocumentType;
+class DOMImplementation;
+class DOMIntersectionObserver;
+class DOMStringList;
+class Element;
+struct ElementCreationOptions;
+struct ElementRegistrationOptions;
+class Event;
+class EventTarget;
+class FontFaceSet;
+class FrameRequestCallback;
+struct FullscreenRequest;
+class ImageTracker;
+class ImportManager;
+class HTMLBodyElement;
+struct LifecycleCallbackArgs;
+class Link;
+class Location;
+class MediaQueryList;
+class GlobalObject;
+class NodeFilter;
+class NodeIterator;
+enum class OrientationType : uint8_t;
+class ProcessingInstruction;
+class Promise;
+class StyleSheetList;
+class SVGDocument;
+class SVGSVGElement;
+class Touch;
+class TouchList;
+class TreeWalker;
+class XPathEvaluator;
+class XPathExpression;
+class XPathNSResolver;
+class XPathResult;
+template<typename> class Sequence;
+
+template<typename, typename> class CallbackObjectHolder;
+typedef CallbackObjectHolder<NodeFilter, nsIDOMNodeFilter> NodeFilterHolder;
+
+enum class CallerType : uint32_t;
+
+}
+}
+
+
+
+
+
+
+enum DocumentFlavor {
+  DocumentFlavorLegacyGuess,
+  DocumentFlavorHTML,
+  DocumentFlavorSVG,
+  DocumentFlavorPlain,
+};
+
+
+enum class HSTSPrimingState {
+  eNO_HSTS_PRIMING = 0,
+  eHSTS_PRIMING_ALLOW = 1,
+  eHSTS_PRIMING_BLOCK = 2
+};
+# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+class nsContentList;
+
+
+
+
+
+class nsIDocument : public nsINode,
+                    public mozilla::dom::DispatcherTrait
+{
+  typedef mozilla::dom::GlobalObject GlobalObject;
+
+public:
+  typedef mozilla::net::ReferrerPolicy ReferrerPolicyEnum;
+  typedef mozilla::dom::Element Element;
+  typedef mozilla::dom::FullscreenRequest FullscreenRequest;
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  nsIDocument();
+
+
+
+
+  class PageUnloadingEventTimeStamp
+  {
+    nsCOMPtr<nsIDocument> mDocument;
+    bool mSet;
+
+  public:
+    explicit PageUnloadingEventTimeStamp(nsIDocument* aDocument)
+      : mDocument(aDocument)
+      , mSet(false)
+    {
+      do { } while (0);
+      if (mDocument->mPageUnloadingEventTimeStamp.IsNull()) {
+        mDocument->SetPageUnloadingEventTimeStamp();
+        mSet = true;
+      }
+    }
+
+    ~PageUnloadingEventTimeStamp()
+    {
+      if (mSet) {
+        mDocument->CleanUnloadEventsTimeStamp();
+      }
+    }
+  };
+# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual nsresult StartDocumentLoad(const char* aCommand,
+                                     nsIChannel* aChannel,
+                                     nsILoadGroup* aLoadGroup,
+                                     nsISupports* aContainer,
+                                     nsIStreamListener **aDocListener,
+                                     bool aReset,
+                                     nsIContentSink* aSink = nullptr) = 0;
+  virtual void StopDocumentLoad() = 0;
+
+  virtual void SetSuppressParserErrorElement(bool aSuppress) {}
+  virtual bool SuppressParserErrorElement() { return false; }
+
+  virtual void SetSuppressParserErrorConsoleMessages(bool aSuppress) {}
+  virtual bool SuppressParserErrorConsoleMessages() { return false; }
+
+
+
+
+
+
+
+  virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) = 0;
+# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsIURI* GetDocumentURI() const
+  {
+    return mDocumentURI;
+  }
+# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsIURI* GetOriginalURI() const
+  {
+    return mOriginalURI;
+  }
+
+
+
+
+
+  virtual void SetDocumentURI(nsIURI* aURI) = 0;
+
+
+
+
+
+  virtual void SetChromeXHRDocURI(nsIURI* aURI) = 0;
+
+
+
+
+
+  virtual void SetChromeXHRDocBaseURI(nsIURI* aURI) = 0;
+
+
+
+
+  virtual void ApplySettingsFromCSP(bool aSpeculative) = 0;
+
+  virtual already_AddRefed<nsIParser> CreatorParserOrNull() = 0;
+
+
+
+
+
+  ReferrerPolicyEnum GetReferrerPolicy() const
+  {
+    return mReferrerPolicy;
+  }
+
+
+
+
+  uint32_t ReferrerPolicy() const
+  {
+    return GetReferrerPolicy();
+  }
+
+
+
+
+
+
+  bool GetBlockAllMixedContent(bool aPreload) const
+  {
+    if (aPreload) {
+      return mBlockAllMixedContentPreloads;
+    }
+    return mBlockAllMixedContent;
+  }
+# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  bool GetUpgradeInsecureRequests(bool aPreload) const
+  {
+    if (aPreload) {
+      return mUpgradeInsecurePreloads;
+    }
+    return mUpgradeInsecureRequests;
+  }
+
+  void SetReferrer(const nsACString& aReferrer) {
+    mReferrer = aReferrer;
+  }
+
+
+
+
+
+  HSTSPrimingState GetHSTSPrimingStateForLocation(nsIURI* aContentLocation) const
+  {
+    HSTSPrimingState state;
+    if (mHSTSPrimingURIList.Get(aContentLocation, &state)) {
+      return state;
+    }
+    return HSTSPrimingState::eNO_HSTS_PRIMING;
+  }
+
+
+
+
+
+
+  void AddHSTSPrimingLocation(nsIURI* aContentLocation, HSTSPrimingState aState)
+  {
+    mHSTSPrimingURIList.Put(aContentLocation, aState);
+  }
+
+  void ClearHSTSPrimingLocation(nsIURI* aContentLocation)
+  {
+    mHSTSPrimingURIList.Remove(aContentLocation);
+  }
+
+
+
+
+  virtual void SetPrincipal(nsIPrincipal *aPrincipal) = 0;
+
+
+
+
+  already_AddRefed<nsILoadGroup> GetDocumentLoadGroup() const
+  {
+    nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
+    return group.forget();
+  }
+
+
+
+
+
+
+
+  nsIURI* GetFallbackBaseURI() const
+  {
+    if (mIsSrcdocDocument && mParentDocument) {
+      return mParentDocument->GetDocBaseURI();
+    }
+    return mDocumentURI;
+  }
+# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsIURI* GetDocBaseURI() const
+  {
+    if (mDocumentBaseURI) {
+      return mDocumentBaseURI;
+    }
+    return GetFallbackBaseURI();
+  }
+  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
+
+  virtual void SetBaseURI(nsIURI* aURI) = 0;
+
+
+
+
+  virtual void GetBaseTarget(nsAString &aBaseTarget) = 0;
+  void SetBaseTarget(const nsString& aBaseTarget) {
+    mBaseTarget = aBaseTarget;
+  }
+
+
+
+
+  const nsCString& GetDocumentCharacterSet() const
+  {
+    return mCharacterSet;
+  }
+
+
+
+
+
+  virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) = 0;
+
+  int32_t GetDocumentCharacterSetSource() const
+  {
+    return mCharacterSetSource;
+  }
+
+
+
+  void SetDocumentCharacterSetSource(int32_t aCharsetSource)
+  {
+    mCharacterSetSource = aCharsetSource;
+  }
+
+
+
+
+  virtual nsresult AddCharSetObserver(nsIObserver* aObserver) = 0;
+
+
+
+
+  virtual void RemoveCharSetObserver(nsIObserver* aObserver) = 0;
+# 539 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  typedef bool (* IDTargetObserver)(Element* aOldElement,
+                                      Element* aNewelement, void* aData);
+# 553 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
+                                       void* aData, bool aForImage) = 0;
+
+
+
+
+  virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
+                                      void* aData, bool aForImage) = 0;
+
+
+
+
+
+
+  virtual nsresult GetContentType(nsAString& aContentType) = 0;
+
+
+
+
+  virtual void SetContentType(const nsAString& aContentType) = 0;
+
+
+
+
+  void GetContentLanguage(nsAString& aContentLanguage) const
+  {
+    CopyASCIItoUTF16(mContentLanguage, aContentLanguage);
+  }
+# 589 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  bool GetBidiEnabled() const
+  {
+    return mBidiEnabled;
+  }
+
+
+
+
+
+
+
+  void SetBidiEnabled()
+  {
+    mBidiEnabled = true;
+  }
+
+
+
+
+  bool GetMathMLEnabled() const
+  {
+    return mMathMLEnabled;
+  }
+
+  void SetMathMLEnabled()
+  {
+    mMathMLEnabled = true;
+  }
+
+
+
+
+  bool IsInitialDocument() const
+  {
+    return mIsInitialDocumentInWindow;
+  }
+
+
+
+
+
+  void SetIsInitialDocument(bool aIsInitialDocument)
+  {
+    mIsInitialDocumentInWindow = aIsInitialDocument;
+  }
+
+
+
+
+
+
+  void IgnoreDocGroupMismatches()
+  {
+    mIgnoreDocGroupMismatches = true;
+  }
+
+
+
+
+
+  uint32_t GetBidiOptions() const
+  {
+    return mBidiOptions;
+  }
+
+
+
+
+
+
+
+  void SetBidiOptions(uint32_t aBidiOptions)
+  {
+    mBidiOptions = aBidiOptions;
+  }
+
+
+
+
+  bool GetHasMixedActiveContentLoaded()
+  {
+    return mHasMixedActiveContentLoaded;
+  }
+
+
+
+
+  void SetHasMixedActiveContentLoaded(bool aHasMixedActiveContentLoaded)
+  {
+    mHasMixedActiveContentLoaded = aHasMixedActiveContentLoaded;
+  }
+
+
+
+
+  bool GetHasMixedActiveContentBlocked()
+  {
+    return mHasMixedActiveContentBlocked;
+  }
+
+
+
+
+  void SetHasMixedActiveContentBlocked(bool aHasMixedActiveContentBlocked)
+  {
+    mHasMixedActiveContentBlocked = aHasMixedActiveContentBlocked;
+  }
+
+
+
+
+  bool GetHasMixedDisplayContentLoaded()
+  {
+    return mHasMixedDisplayContentLoaded;
+  }
+
+
+
+
+  void SetHasMixedDisplayContentLoaded(bool aHasMixedDisplayContentLoaded)
+  {
+    mHasMixedDisplayContentLoaded = aHasMixedDisplayContentLoaded;
+  }
+
+
+
+
+  bool GetHasMixedDisplayContentBlocked()
+  {
+    return mHasMixedDisplayContentBlocked;
+  }
+
+
+
+
+  void SetHasReferrerPolicyCSP(bool aHasReferrerPolicyCSP)
+  {
+    mHasReferrerPolicyCSP = aHasReferrerPolicyCSP;
+  }
+
+
+
+
+  void SetHasMixedDisplayContentBlocked(bool aHasMixedDisplayContentBlocked)
+  {
+    mHasMixedDisplayContentBlocked = aHasMixedDisplayContentBlocked;
+  }
+
+
+
+
+  void SetHasMixedContentObjectSubrequest(bool aHasMixedContentObjectSubrequest)
+  {
+    mHasMixedContentObjectSubrequest = aHasMixedContentObjectSubrequest;
+  }
+
+
+
+
+  void SetHasCSP(bool aHasCSP)
+  {
+    mHasCSP = aHasCSP;
+  }
+
+
+
+
+  void SetHasUnsafeInlineCSP(bool aHasUnsafeInlineCSP)
+  {
+    mHasUnsafeInlineCSP = aHasUnsafeInlineCSP;
+  }
+
+
+
+
+  void SetHasUnsafeEvalCSP(bool aHasUnsafeEvalCSP)
+  {
+    mHasUnsafeEvalCSP = aHasUnsafeEvalCSP;
+  }
+
+
+
+
+  bool GetHasTrackingContentBlocked()
+  {
+    return mHasTrackingContentBlocked;
+  }
+
+
+
+
+  void SetHasTrackingContentBlocked(bool aHasTrackingContentBlocked)
+  {
+    mHasTrackingContentBlocked = aHasTrackingContentBlocked;
+  }
+
+
+
+
+  bool GetHasTrackingContentLoaded()
+  {
+    return mHasTrackingContentLoaded;
+  }
+
+
+
+
+  void SetHasTrackingContentLoaded(bool aHasTrackingContentLoaded)
+  {
+    mHasTrackingContentLoaded = aHasTrackingContentLoaded;
+  }
+
+
+
+
+
+  uint32_t GetSandboxFlags() const
+  {
+    return mSandboxFlags;
+  }
+
+
+
+
+  void GetSandboxFlagsAsString(nsAString& aFlags);
+
+
+
+
+
+  void SetSandboxFlags(uint32_t sandboxFlags)
+  {
+    mSandboxFlags = sandboxFlags;
+  }
+
+
+
+
+
+  virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const = 0;
+  virtual void SetHeaderData(nsIAtom* aheaderField, const nsAString& aData) = 0;
+# 838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual already_AddRefed<nsIPresShell> CreateShell(
+      nsPresContext* aContext,
+      nsViewManager* aViewManager,
+      mozilla::StyleSetHandle aStyleSet) = 0;
+  virtual void DeleteShell() = 0;
+
+  nsIPresShell* GetShell() const
+  {
+    return GetBFCacheEntry() ? nullptr : mPresShell;
+  }
+
+
+
+  void DisallowBFCaching()
+  {
+    do { } while(0);
+    mBFCacheDisallowed = true;
+  }
+
+  bool IsBFCachingAllowed() const
+  {
+    return !mBFCacheDisallowed;
+  }
+
+  void SetBFCacheEntry(nsIBFCacheEntry* aEntry)
+  {
+    do { } while(0);
+
+
+    mBFCacheEntry = aEntry;
+  }
+
+  nsIBFCacheEntry* GetBFCacheEntry() const
+  {
+    return mBFCacheEntry;
+  }
+
+
+
+
+
+
+  nsIDocument *GetParentDocument() const
+  {
+    return mParentDocument;
+  }
+
+
+
+
+  void SetParentDocument(nsIDocument* aParent)
+  {
+    mParentDocument = aParent;
+    if (aParent) {
+      mIgnoreDocGroupMismatches = aParent->mIgnoreDocGroupMismatches;
+    }
+  }
+
+
+
+
+  virtual bool GetAllowPlugins () = 0;
+
+
+
+
+  virtual nsresult SetSubDocumentFor(Element* aContent,
+                                     nsIDocument* aSubDoc) = 0;
+
+
+
+
+  virtual nsIDocument *GetSubDocumentFor(nsIContent *aContent) const = 0;
+
+
+
+
+  virtual Element* FindContentForSubDocument(nsIDocument* aDocument) const = 0;
+
+
+
+
+  mozilla::dom::DocumentType* GetDoctype() const;
+
+
+
+
+  Element* GetRootElement() const;
+# 940 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize) = 0;
+
+
+
+
+  virtual bool WillIgnoreCharsetOverride() {
+    return true;
+  }
+
+
+
+
+  bool IsSrcdocDocument() const {
+    return mIsSrcdocDocument;
+  }
+
+
+
+
+  void SetIsSrcdocDocument(bool aIsSrcdocDocument) {
+    mIsSrcdocDocument = aIsSrcdocDocument;
+  }
+
+
+
+
+
+
+  nsresult GetSrcdocData(nsAString& aSrcdocData);
+
+  bool DidDocumentOpen() {
+    return mDidDocumentOpen;
+  }
+
+  already_AddRefed<mozilla::dom::AnonymousContent>
+  InsertAnonymousContent(mozilla::dom::Element& aElement,
+                         mozilla::ErrorResult& aError);
+  void RemoveAnonymousContent(mozilla::dom::AnonymousContent& aContent,
+                              mozilla::ErrorResult& aError);
+
+
+
+
+
+
+  Element* GetAnonRootIfInAnonymousContentContainer(nsINode* aNode) const;
+  nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& GetAnonymousContents() {
+    return mAnonymousContents;
+  }
+
+  static nsresult GenerateDocumentId(nsAString& aId);
+  nsresult GetOrCreateId(nsAString& aId);
+  void SetId(const nsAString& aId);
+
+  mozilla::TimeStamp GetPageUnloadingEventTimeStamp() const
+  {
+    if (!mParentDocument) {
+      return mPageUnloadingEventTimeStamp;
+    }
+
+    mozilla::TimeStamp parentTimeStamp(mParentDocument->GetPageUnloadingEventTimeStamp());
+    if (parentTimeStamp.IsNull()) {
+      return mPageUnloadingEventTimeStamp;
+    }
+
+    if (!mPageUnloadingEventTimeStamp ||
+        parentTimeStamp < mPageUnloadingEventTimeStamp) {
+      return parentTimeStamp;
+    }
+
+    return mPageUnloadingEventTimeStamp;
+  }
+
+  virtual void NotifyLayerManagerRecreated() = 0;
+# 1022 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void ScheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG) = 0;
+
+  virtual void UnscheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG) = 0;
+
+
+  virtual void ResolveScheduledSVGPresAttrs() = 0;
+
+protected:
+  virtual Element *GetRootElementInternal() const = 0;
+
+  void SetPageUnloadingEventTimeStamp()
+  {
+    do { } while (0);
+    mPageUnloadingEventTimeStamp = mozilla::TimeStamp::NowLoRes();
+  }
+
+  void CleanUnloadEventsTimeStamp()
+  {
+    do { } while (0);
+    mPageUnloadingEventTimeStamp = mozilla::TimeStamp();
+  }
+
+private:
+  class SelectorCacheKey
+  {
+    public:
+      explicit SelectorCacheKey(const nsAString& aString) : mKey(aString)
+      {
+                                        ;
+      }
+
+      nsString mKey;
+      nsExpirationState mState;
+
+      nsExpirationState* GetExpirationState() { return &mState; }
+
+      ~SelectorCacheKey()
+      {
+                                        ;
+      }
+  };
+
+  class SelectorCacheKeyDeleter;
+
+public:
+  class SelectorCache final
+    : public nsExpirationTracker<SelectorCacheKey, 4>
+  {
+    public:
+      explicit SelectorCache(nsIEventTarget* aEventTarget);
+
+
+      void CacheList(const nsAString& aSelector, nsCSSSelectorList* aSelectorList);
+
+      virtual void NotifyExpired(SelectorCacheKey* aSelector) override;
+
+
+
+
+
+
+      bool GetList(const nsAString& aSelector, nsCSSSelectorList** aList)
+      {
+        return mTable.Get(aSelector, aList);
+      }
+
+      ~SelectorCache();
+
+    private:
+      nsClassHashtable<nsStringHashKey, nsCSSSelectorList> mTable;
+  };
+
+  SelectorCache& GetSelectorCache() {
+    if (!mSelectorCache) {
+      mSelectorCache =
+        new SelectorCache(EventTargetFor(mozilla::TaskCategory::Other));
+    }
+    return *mSelectorCache;
+  }
+
+
+  Element* GetHtmlElement() const;
+
+
+  Element* GetHtmlChildElement(nsIAtom* aTag);
+
+
+  mozilla::dom::HTMLBodyElement* GetBodyElement();
+
+
+  Element* GetHeadElement() {
+    return GetHtmlChildElement(nsGkAtoms::head);
+  }
+# 1141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet) = 0;
+
+
+
+
+
+
+
+  virtual int32_t GetNumberOfStyleSheets() const = 0;
+
+
+
+
+
+
+
+  virtual mozilla::StyleSheet* GetStyleSheetAt(int32_t aIndex) const = 0;
+# 1166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void InsertStyleSheetAt(mozilla::StyleSheet* aSheet,
+                                  int32_t aIndex) = 0;
+
+
+
+
+
+
+
+  virtual int32_t GetIndexOfStyleSheet(
+      const mozilla::StyleSheet* aSheet) const = 0;
+# 1186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void UpdateStyleSheets(
+      nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets,
+      nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets) = 0;
+
+
+
+
+  virtual void AddStyleSheet(mozilla::StyleSheet* aSheet) = 0;
+
+
+
+
+  virtual void RemoveStyleSheet(mozilla::StyleSheet* aSheet) = 0;
+
+
+
+
+
+  virtual void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet,
+                                            bool aApplicable) = 0;
+
+  enum additionalSheetType {
+    eAgentSheet,
+    eUserSheet,
+    eAuthorSheet,
+    AdditionalSheetTypeCount
+  };
+
+  virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType,
+                                            nsIURI* aSheetURI) = 0;
+  virtual nsresult AddAdditionalStyleSheet(additionalSheetType aType,
+                                           mozilla::StyleSheet* aSheet) = 0;
+  virtual void RemoveAdditionalStyleSheet(additionalSheetType aType,
+                                          nsIURI* sheetURI) = 0;
+  virtual mozilla::StyleSheet* GetFirstAdditionalAuthorSheet() = 0;
+# 1229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  template<typename T>
+  size_t FindDocStyleSheetInsertionPoint(const nsTArray<RefPtr<T>>& aDocSheets,
+                                         T* aSheet);
+
+
+
+
+  mozilla::css::Loader* CSSLoader() const {
+    return mCSSLoader;
+  }
+
+  mozilla::StyleBackendType GetStyleBackendType() const {
+    if (mStyleBackendType == mozilla::StyleBackendType::None) {
+      const_cast<nsIDocument*>(this)->UpdateStyleBackendType();
+    }
+    do { } while (0);
+    return mStyleBackendType;
+  }
+
+  void UpdateStyleBackendType();
+
+  bool IsStyledByServo() const {
+    return GetStyleBackendType() == mozilla::StyleBackendType::Servo;
+  }
+
+
+
+
+  mozilla::css::ImageLoader* StyleImageLoader() const {
+    return mStyleImageLoader;
+  }
+
+
+
+
+
+
+  virtual nsIChannel* GetChannel() const = 0;
+
+
+
+
+
+  nsHTMLStyleSheet* GetAttributeStyleSheet() const {
+    return mAttrStyleSheet;
+  }
+
+
+
+
+
+  nsHTMLCSSStyleSheet* GetInlineStyleSheet() const {
+    return mStyleAttrStyleSheet;
+  }
+
+  virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) = 0;
+# 1295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsIScriptGlobalObject*
+    GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const
+  {
+    aHasHadScriptHandlingObject = mHasHadScriptHandlingObject;
+    return mScriptGlobalObject ? mScriptGlobalObject.get() :
+                                 GetScriptHandlingObjectInternal();
+  }
+  virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) = 0;
+# 1311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual nsIGlobalObject* GetScopeObject() const = 0;
+  virtual void SetScopeObject(nsIGlobalObject* aGlobal) = 0;
+
+
+
+
+  nsPIDOMWindowOuter *GetWindow() const
+  {
+    return mWindow ? mWindow->GetOuterWindow() : GetWindowInternal();
+  }
+
+  bool IsInBackgroundWindow() const
+  {
+    auto* outer = mWindow ? mWindow->GetOuterWindow() : nullptr;
+    return outer && outer->IsBackground();
+  }
+
+
+
+
+
+
+  nsPIDOMWindowInner* GetInnerWindow() const
+  {
+    return mRemovedFromDocShell ? nullptr : mWindow;
+  }
+
+
+
+
+  uint64_t OuterWindowID() const
+  {
+    nsPIDOMWindowOuter* window = GetWindow();
+    return window ? window->WindowID() : 0;
+  }
+
+
+
+
+  uint64_t InnerWindowID() const
+  {
+    nsPIDOMWindowInner* window = GetInnerWindow();
+    return window ? window->WindowID() : 0;
+  }
+
+
+
+
+  virtual nsScriptLoader* ScriptLoader() = 0;
+
+
+
+
+  virtual void AddToIdTable(Element* aElement, nsIAtom* aId) = 0;
+  virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) = 0;
+  virtual void AddToNameTable(Element* aElement, nsIAtom* aName) = 0;
+  virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) = 0;
+
+
+
+
+  virtual nsTArray<Element*> GetFullscreenStack() const = 0;
+# 1385 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void AsyncRequestFullScreen(
+    mozilla::UniquePtr<FullscreenRequest>&& aRequest) = 0;
+
+
+
+
+
+
+
+  virtual nsresult
+    RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement) = 0;
+# 1406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+   virtual nsresult RemoteFrameFullscreenReverted() = 0;
+
+
+
+
+
+
+  virtual void RestorePreviousFullScreenState() = 0;
+
+
+
+
+
+  virtual bool IsFullscreenLeaf() = 0;
+
+
+
+
+
+
+  virtual nsIDocument* GetFullscreenRoot() = 0;
+
+
+
+
+
+  virtual void SetFullscreenRoot(nsIDocument* aRoot) = 0;
+# 1446 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  static void ExitFullscreenInDocTree(nsIDocument* aDocument);
+# 1457 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  static void AsyncExitFullscreen(nsIDocument* aDocument);
+
+
+
+
+
+
+  static bool HandlePendingFullscreenRequests(nsIDocument* aDocument);
+
+
+
+
+
+  void DispatchFullscreenError(const char* aMessage);
+
+  virtual void RequestPointerLock(Element* aElement,
+                                  mozilla::dom::CallerType aCallerType) = 0;
+
+  static void UnlockPointer(nsIDocument* aDoc = nullptr);
+
+
+
+  virtual void SetCurrentOrientation(mozilla::dom::OrientationType aType,
+                                     uint16_t aAngle) = 0;
+  virtual uint16_t CurrentOrientationAngle() const = 0;
+  virtual mozilla::dom::OrientationType CurrentOrientationType() const = 0;
+  virtual void SetOrientationPendingPromise(mozilla::dom::Promise* aPromise) = 0;
+  virtual mozilla::dom::Promise* GetOrientationPendingPromise() const = 0;
+# 1496 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void AddObserver(nsIDocumentObserver* aObserver) = 0;
+
+
+
+
+
+  virtual bool RemoveObserver(nsIDocumentObserver* aObserver) = 0;
+
+
+
+
+
+  virtual void BeginUpdate(nsUpdateType aUpdateType) = 0;
+  virtual void EndUpdate(nsUpdateType aUpdateType) = 0;
+  virtual void BeginLoad() = 0;
+  virtual void EndLoad() = 0;
+
+  enum ReadyState { READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4};
+  virtual void SetReadyStateInternal(ReadyState rs) = 0;
+  ReadyState GetReadyStateEnum()
+  {
+    return mReadyState;
+  }
+
+
+
+  virtual void ContentStateChanged(nsIContent* aContent,
+                                   mozilla::EventStates aStateMask) = 0;
+
+
+
+
+  virtual void DocumentStatesChanged(mozilla::EventStates aStateMask) = 0;
+
+
+
+  virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet,
+                                mozilla::css::Rule* aStyleRule) = 0;
+  virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet,
+                              mozilla::css::Rule* aStyleRule) = 0;
+  virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet,
+                                mozilla::css::Rule* aStyleRule) = 0;
+
+
+
+
+
+  virtual void FlushPendingNotifications(mozilla::FlushType aType) = 0;
+
+
+
+
+
+
+
+  virtual void FlushExternalResources(mozilla::FlushType aType) = 0;
+
+  nsBindingManager* BindingManager() const
+  {
+    return mNodeInfoManager->GetBindingManager();
+  }
+
+
+
+
+
+  nsNodeInfoManager* NodeInfoManager() const
+  {
+    return mNodeInfoManager;
+  }
+
+
+
+
+
+
+  virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) = 0;
+
+
+
+
+
+
+  virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,
+                          nsIPrincipal* aPrincipal) = 0;
+
+
+
+
+
+  virtual void SetContainer(nsDocShell* aContainer);
+
+
+
+
+  virtual nsISupports* GetContainer() const;
+
+
+
+
+  nsILoadContext* GetLoadContext() const;
+
+
+
+
+  nsIDocShell* GetDocShell() const;
+
+
+
+
+
+
+
+  virtual void SetXMLDeclaration(const char16_t *aVersion,
+                                 const char16_t *aEncoding,
+                                 const int32_t aStandalone) = 0;
+  virtual void GetXMLDeclaration(nsAString& aVersion,
+                                 nsAString& aEncoding,
+                                 nsAString& Standalone) = 0;
+
+
+
+
+
+
+
+  bool IsHTMLDocument() const
+  {
+    return mType == eHTML;
+  }
+  bool IsHTMLOrXHTML() const
+  {
+    return mType == eHTML || mType == eXHTML;
+  }
+  bool IsXMLDocument() const
+  {
+    return !IsHTMLDocument();
+  }
+  bool IsSVGDocument() const
+  {
+    return mType == eSVG;
+  }
+  bool IsXULDocument() const
+  {
+    return mType == eXUL;
+  }
+  bool IsUnstyledDocument()
+  {
+    return IsLoadedAsData() || IsLoadedAsInteractiveData();
+  }
+  bool LoadsFullXULStyleSheetUpFront()
+  {
+    return IsXULDocument() || AllowXULXBL();
+  }
+
+  virtual bool IsScriptEnabled() = 0;
+
+
+
+
+
+  virtual already_AddRefed<Element> CreateElem(const nsAString& aName,
+                                               nsIAtom* aPrefix,
+                                               int32_t aNamespaceID,
+                                               const nsAString* aIs = nullptr) = 0;
+# 1669 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsISupports *GetSecurityInfo()
+  {
+    return mSecurityInfo;
+  }
+
+
+
+
+
+  virtual nsIChannel* GetFailedChannel() const = 0;
+
+
+
+
+
+  virtual void SetFailedChannel(nsIChannel* aChannel) = 0;
+
+
+
+
+
+  int32_t GetDefaultNamespaceID() const
+  {
+    return mDefaultElementType;
+  }
+
+  void DeleteAllProperties();
+  void DeleteAllPropertiesFor(nsINode* aNode);
+
+  nsPropertyTable* PropertyTable(uint16_t aCategory) {
+    if (aCategory == 0)
+      return &mPropertyTable;
+    return GetExtraPropertyTable(aCategory);
+  }
+  uint32_t GetPropertyTableCount()
+  { return mExtraPropertyTables.Length() + 1; }
+
+
+
+
+  void SetPartID(uint32_t aID) {
+    mPartID = aID;
+  }
+
+
+
+
+  uint32_t GetPartID() const {
+    return mPartID;
+  }
+
+
+
+
+
+  virtual void Sanitize() = 0;
+
+
+
+
+
+
+  typedef bool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);
+  virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
+                                     void *aData) = 0;
+# 1752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual bool CanSavePresentation(nsIRequest *aNewRequest) = 0;
+
+
+
+
+
+
+  virtual void Destroy() = 0;
+
+
+
+
+
+
+
+  virtual void RemovedFromDocShell() = 0;
+
+
+
+
+
+
+  virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const = 0;
+# 1783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void BlockOnload() = 0;
+
+
+
+
+
+
+  virtual void UnblockOnload(bool aFireSync) = 0;
+
+  void BlockDOMContentLoaded()
+  {
+    ++mBlockDOMContentLoaded;
+  }
+
+  virtual void UnblockDOMContentLoaded() = 0;
+# 1811 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void OnPageShow(bool aPersisted,
+                          mozilla::dom::EventTarget* aDispatchStartTarget) = 0;
+# 1826 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void OnPageHide(bool aPersisted,
+                          mozilla::dom::EventTarget* aDispatchStartTarget) = 0;
+# 1836 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) = 0;
+
+
+
+
+
+
+  virtual void ForgetLink(mozilla::dom::Link* aLink) = 0;
+
+
+
+
+
+
+  virtual void ClearBoxObjectFor(nsIContent *aContent) = 0;
+
+
+
+
+
+  virtual already_AddRefed<mozilla::dom::BoxObject>
+    GetBoxObjectFor(mozilla::dom::Element* aElement,
+                    mozilla::ErrorResult& aRv) = 0;
+
+
+
+
+
+  already_AddRefed<mozilla::dom::MediaQueryList>
+    MatchMedia(const nsAString& aMediaQueryList);
+
+  const PRCList* MediaQueryLists() const {
+    return &mDOMMediaQueryLists;
+  }
+
+
+
+
+  nsCompatibility GetCompatibilityMode() const {
+    return mCompatMode;
+  }
+
+
+
+
+
+  bool HaveFiredDOMTitleChange() const {
+    return mHaveFiredTitleChange;
+  }
+
+
+
+
+  virtual Element*
+    GetAnonymousElementByAttribute(nsIContent* aElement,
+                                   nsIAtom* aAttrName,
+                                   const nsAString& aAttrValue) const = 0;
+
+
+
+
+
+
+
+  virtual Element* ElementFromPointHelper(float aX, float aY,
+                                          bool aIgnoreRootScrollFrame,
+                                          bool aFlushLayout) = 0;
+
+  enum ElementsFromPointFlags {
+    IGNORE_ROOT_SCROLL_FRAME = 1,
+    FLUSH_LAYOUT = 2,
+    IS_ELEMENT_FROM_POINT = 4
+  };
+
+  virtual void ElementsFromPointHelper(float aX, float aY,
+                                       uint32_t aFlags,
+                                       nsTArray<RefPtr<mozilla::dom::Element>>& aElements) = 0;
+
+  virtual nsresult NodesFromRectHelper(float aX, float aY,
+                                       float aTopSize, float aRightSize,
+                                       float aBottomSize, float aLeftSize,
+                                       bool aIgnoreRootScrollFrame,
+                                       bool aFlushLayout,
+                                       nsIDOMNodeList** aReturn) = 0;
+
+
+
+
+  virtual void FlushSkinBindings() = 0;
+# 1933 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  void MayDispatchMutationEvent(nsINode* aTarget)
+  {
+    if (mSubtreeModifiedDepth > 0) {
+      mSubtreeModifiedTargets.AppendObject(aTarget);
+    }
+  }
+
+
+
+
+
+  void MarkUncollectableForCCGeneration(uint32_t aGeneration)
+  {
+    mMarkedCCGeneration = aGeneration;
+  }
+
+
+
+
+  uint32_t GetMarkedCCGeneration()
+  {
+    return mMarkedCCGeneration;
+  }
+
+  bool IsLoadedAsData()
+  {
+    return mLoadedAsData;
+  }
+
+  bool IsLoadedAsInteractiveData()
+  {
+    return mLoadedAsInteractiveData;
+  }
+
+  bool MayStartLayout()
+  {
+    return mMayStartLayout;
+  }
+
+  virtual void SetMayStartLayout(bool aMayStartLayout)
+  {
+    mMayStartLayout = aMayStartLayout;
+  }
+
+  already_AddRefed<nsIDocumentEncoder> GetCachedEncoder();
+
+  void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder);
+
+
+  virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) = 0;
+
+
+  virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader, nsIRunnable* aFinalizer) = 0;
+
+  virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) = 0;
+
+
+
+
+
+  bool IsRootDisplayDocument() const
+  {
+    return !mParentDocument && !mDisplayDocument;
+  }
+
+  bool IsBeingUsedAsImage() const {
+    return mIsBeingUsedAsImage;
+  }
+
+  void SetIsBeingUsedAsImage() {
+    mIsBeingUsedAsImage = true;
+  }
+
+  bool IsResourceDoc() const {
+    return IsBeingUsedAsImage() ||
+      mHasDisplayDocument;
+  }
+
+
+
+
+
+
+
+  nsIDocument* GetDisplayDocument() const
+  {
+    return mDisplayDocument;
+  }
+
+
+
+
+
+  void SetDisplayDocument(nsIDocument* aDisplayDocument)
+  {
+    do { } while (0);
+
+
+
+
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+
+    mDisplayDocument = aDisplayDocument;
+    mHasDisplayDocument = !!aDisplayDocument;
+  }
+# 2051 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  class ExternalResourceLoad : public nsISupports
+  {
+  public:
+    virtual ~ExternalResourceLoad() {}
+
+    void AddObserver(nsIObserver* aObserver) {
+      do { } while (0);
+      mObservers.AppendElement(aObserver);
+    }
+
+    const nsTArray< nsCOMPtr<nsIObserver> > & Observers() {
+      return mObservers;
+    }
+  protected:
+    AutoTArray< nsCOMPtr<nsIObserver>, 8 > mObservers;
+  };
+# 2081 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual nsIDocument*
+    RequestExternalResource(nsIURI* aURI,
+                            nsINode* aRequestingNode,
+                            ExternalResourceLoad** aPendingLoad) = 0;
+
+
+
+
+
+
+  virtual void EnumerateExternalResources(nsSubDocEnumFunc aCallback,
+                                          void* aData) = 0;
+
+
+
+
+
+
+  bool IsShowing() const { return mIsShowing; }
+
+
+
+
+  bool IsVisible() const { return mVisible; }
+
+
+
+
+
+  bool IsVisibleConsideringAncestors() const;
+
+
+
+
+
+
+
+  bool IsActive() const { return mDocumentContainer && !mRemovedFromDocShell; }
+# 2127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  bool IsCurrentActiveDocument() const
+  {
+    nsPIDOMWindowInner* inner = GetInnerWindow();
+    return inner && inner->IsCurrentInnerWindow() && inner->GetDoc() == this;
+  }
+
+
+
+
+
+
+
+  void RegisterActivityObserver(nsISupports* aSupports);
+  bool UnregisterActivityObserver(nsISupports* aSupports);
+
+  typedef void (* ActivityObserverEnumerator)(nsISupports*, void*);
+  void EnumerateActivityObservers(ActivityObserverEnumerator aEnumerator,
+                                  void* aData);
+
+
+
+
+  bool HasAnimationController() { return !!mAnimationController; }
+
+
+
+
+  virtual nsSMILAnimationController* GetAnimationController() = 0;
+
+
+
+
+
+  virtual mozilla::PendingAnimationTracker* GetPendingAnimationTracker() = 0;
+
+
+
+
+  virtual mozilla::PendingAnimationTracker*
+  GetOrCreatePendingAnimationTracker() = 0;
+
+
+
+
+
+  virtual void SuppressEventHandling(uint32_t aIncrease = 1) = 0;
+
+
+
+
+
+
+  virtual void UnsuppressEventHandlingAndFireEvents(bool aFireEvents) = 0;
+
+  uint32_t EventHandlingSuppressed() const { return mEventsSuppressed; }
+
+  bool IsEventHandlingEnabled() {
+    return !EventHandlingSuppressed() && mScriptGlobalObject;
+  }
+
+
+
+
+  void BeginEvaluatingExternalScript() { ++mExternalScriptsBeingEvaluated; }
+
+
+
+
+  void EndEvaluatingExternalScript() { --mExternalScriptsBeingEvaluated; }
+
+  bool IsDNSPrefetchAllowed() const { return mAllowDNSPrefetch; }
+
+
+
+
+
+  bool AllowXULXBL() {
+    return mAllowXULXBL == eTriTrue ? true :
+           mAllowXULXBL == eTriFalse ? false :
+           InternalAllowXULXBL();
+  }
+
+  void ForceEnableXULXBL() {
+    mAllowXULXBL = eTriTrue;
+  }
+
+
+
+
+
+  virtual nsIDocument* GetTemplateContentsOwner() = 0;
+# 2228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  bool IsStaticDocument() { return mIsStaticDocument; }
+# 2241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual already_AddRefed<nsIDocument>
+  CreateStaticClone(nsIDocShell* aCloneContainer);
+
+
+
+
+
+  nsIDocument* GetOriginalDocument()
+  {
+    do { } while (0);
+    return mOriginalDocument;
+  }
+
+
+
+
+
+  void UnlinkOriginalDocumentIfStatic();
+# 2272 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual void PreloadPictureOpened() = 0;
+
+  virtual void PreloadPictureClosed() = 0;
+
+  virtual void PreloadPictureImageSource(const nsAString& aSrcsetAttr,
+                                         const nsAString& aSizesAttr,
+                                         const nsAString& aTypeAttr,
+                                         const nsAString& aMediaAttr) = 0;
+# 2288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual already_AddRefed<nsIURI>
+    ResolvePreloadImage(nsIURI *aBaseURI,
+                        const nsAString& aSrcAttr,
+                        const nsAString& aSrcsetAttr,
+                        const nsAString& aSizesAttr) = 0;
+
+
+
+
+
+
+  virtual void MaybePreLoadImage(nsIURI* uri,
+                                 const nsAString& aCrossOriginAttr,
+                                 ReferrerPolicyEnum aReferrerPolicy) = 0;
+
+
+
+
+
+  virtual void ForgetImagePreload(nsIURI* aURI) = 0;
+
+
+
+
+
+
+  virtual void PreloadStyle(nsIURI* aURI, const nsAString& aCharset,
+                            const nsAString& aCrossOriginAttr,
+                            ReferrerPolicyEnum aReferrerPolicy,
+                            const nsAString& aIntegrity) = 0;
+# 2327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
+                                       RefPtr<mozilla::StyleSheet>* aSheet) = 0;
+# 2337 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual bool IsDocumentRightToLeft() { return false; }
+
+
+
+
+  virtual void MaybePreconnect(nsIURI* uri,
+                               mozilla::CORSMode aCORSMode) = 0;
+
+  enum DocumentTheme {
+    Doc_Theme_Uninitialized,
+    Doc_Theme_None,
+    Doc_Theme_Neutral,
+    Doc_Theme_Dark,
+    Doc_Theme_Bright
+  };
+
+
+
+
+
+  void SetStateObject(nsIStructuredCloneContainer *scContainer);
+
+
+
+
+
+
+
+  virtual int GetDocumentLWTheme() { return Doc_Theme_None; }
+
+
+
+
+
+
+  virtual mozilla::EventStates GetDocumentState() = 0;
+  virtual mozilla::EventStates ThreadSafeGetDocumentState() const = 0;
+
+  virtual nsISupports* GetCurrentContentSink() = 0;
+
+  virtual void SetScrollToRef(nsIURI *aDocumentURI) = 0;
+  virtual void ScrollToRef() = 0;
+  virtual void ResetScrolledToRefAlready() = 0;
+  virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) = 0;
+
+
+
+
+
+
+
+  virtual Element* GetElementById(const nsAString& aElementId) = 0;
+
+
+
+
+
+  virtual const nsTArray<Element*>* GetAllElementsForId(const nsAString& aElementId) const = 0;
+# 2403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  virtual Element* LookupImageElement(const nsAString& aElementId) = 0;
+
+  virtual mozilla::dom::DocumentTimeline* Timeline() = 0;
+  virtual mozilla::LinkedList<mozilla::dom::DocumentTimeline>& Timelines() = 0;
+
+  virtual void GetAnimations(
+      nsTArray<RefPtr<mozilla::dom::Animation>>& aAnimations) = 0;
+
+  mozilla::dom::SVGSVGElement* GetSVGRootElement() const;
+
+  nsresult ScheduleFrameRequestCallback(mozilla::dom::FrameRequestCallback& aCallback,
+                                        int32_t *aHandle);
+  void CancelFrameRequestCallback(int32_t aHandle);
+
+  typedef nsTArray<RefPtr<mozilla::dom::FrameRequestCallback>> FrameRequestCallbackList;
+
+
+
+
+  void TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks);
+
+
+
+
+
+
+  bool ShouldThrottleFrameRequests();
+
+
+  bool InUnlinkOrDeletion() { return mInUnlinkOrDeletion; }
+
+  mozilla::dom::ImageTracker* ImageTracker();
+
+  virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) = 0;
+  virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) = 0;
+  virtual void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins) = 0;
+
+  virtual nsresult AddResponsiveContent(nsIContent* aContent) = 0;
+  virtual void RemoveResponsiveContent(nsIContent* aContent) = 0;
+  virtual void NotifyMediaFeatureValuesChanged() = 0;
+
+  virtual nsresult GetStateObject(nsIVariant** aResult) = 0;
+
+  virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0;
+
+  virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0;
+
+  virtual Element* FindImageMap(const nsAString& aNormalizedMapName) = 0;
+
+
+  void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink);
+
+
+
+  void UnregisterPendingLinkUpdate(mozilla::dom::Link* aElement);
+
+
+
+  void FlushPendingLinkUpdates();
+
+
+  enum DeprecatedOperations {
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h"
+eGetAttributeNode,
+eSetAttributeNode,
+eGetAttributeNodeNS,
+eSetAttributeNodeNS,
+eRemoveAttributeNode,
+eCreateAttribute,
+eCreateAttributeNS,
+eNodeValue,
+eTextContent,
+eEnablePrivilege,
+eDOMExceptionCode,
+eNoExposedProps,
+eMutationEvent,
+eComponents,
+ePrefixedVisibilityAPI,
+eNodeIteratorDetach,
+eLenientThis,
+eGetPreventDefault,
+eGetSetUserData,
+eMozGetAsFile,
+eUseOfCaptureEvents,
+eUseOfReleaseEvents,
+eUseOfDOM3LoadMethod,
+eChromeUseOfDOM3LoadMethod,
+eShowModalDialog,
+eWindow_Content,
+eSyncXMLHttpRequest,
+eDataContainerEvent,
+eWindow_Controllers,
+eImportXULIntoContent,
+ePannerNodeDoppler,
+eNavigatorGetUserMedia,
+eWebrtcDeprecatedPrefix,
+eRTCPeerConnectionGetStreams,
+eAppCache,
+ePrefixedImageSmoothingEnabled,
+ePrefixedFullscreenAPI,
+eLenientSetter,
+eFileLastModifiedDate,
+eImageBitmapRenderingContext_TransferImageBitmap,
+eURLCreateObjectURL_MediaStream,
+eXMLBaseAttribute,
+eXMLBaseAttributeForStyleAttr,
+# 2466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+ eDeprecatedOperationCount
+  };
+
+  bool HasWarnedAbout(DeprecatedOperations aOperation) const;
+  void WarnOnceAbout(DeprecatedOperations aOperation,
+                     bool asError = false) const;
+
+
+  enum DocumentWarnings {
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDocumentWarningList.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDocumentWarningList.h"
+eIgnoringWillChangeOverBudget,
+ePreventDefaultFromPassiveListener,
+eSVGReferenceLoop,
+eSVGReferenceChainLengthExceeded,
+# 2476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
+ eDocumentWarningCount
+  };
+
+  bool HasWarnedAbout(DocumentWarnings aWarning) const;
+  void WarnOnceAbout(DocumentWarnings aWarning,
+                     bool asError = false,
+                     const char16_t **aParams = nullptr,
+                     uint32_t aParamsLength = 0) const;
+
+  virtual void PostVisibilityUpdateEvent() = 0;
+
+  bool IsSyntheticDocument() const { return mIsSyntheticDocument; }
+
+
+
+
+
+  virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const;
+
+
+
+  virtual void DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const;
+
+  bool MayHaveDOMMutationObservers()
+  {
+    return mMayHaveDOMMutationObservers;
+  }
+
+  void SetMayHaveDOMMutationObservers()
+  {
+    mMayHaveDOMMutationObservers = true;
+  }
+
+  bool MayHaveAnimationObservers()
+  {
+    return mMayHaveAnimationObservers;
+  }
+
+  void SetMayHaveAnimationObservers()
+  {
+    mMayHaveAnimationObservers = true;
+  }
+
+  bool IsInSyncOperation()
+  {
+    return mInSyncOperationCount != 0;
+  }
+
+  void SetIsInSyncOperation(bool aSync)
+  {
+    if (aSync) {
+      ++mInSyncOperationCount;
+    } else {
+      --mInSyncOperationCount;
+    }
+  }
+
+  bool CreatingStaticClone() const
+  {
+    return mCreatingStaticClone;
+  }
+
+
+
+
+
+  already_AddRefed<Element> CreateHTMLElement(nsIAtom* aTag);
+
+
+  nsIGlobalObject* GetParentObject() const
+  {
+    return GetScopeObject();
+  }
+  static already_AddRefed<nsIDocument>
+    Constructor(const GlobalObject& aGlobal,
+                mozilla::ErrorResult& rv);
+  virtual mozilla::dom::DOMImplementation*
+    GetImplementation(mozilla::ErrorResult& rv) = 0;
+  __attribute__ ((warn_unused_result)) nsresult GetURL(nsString& retval) const;
+  __attribute__ ((warn_unused_result)) nsresult GetDocumentURI(nsString& retval) const;
+
+
+
+
+  void GetDocumentURIFromJS(nsString& aDocumentURI,
+                            mozilla::dom::CallerType aCallerType,
+                            mozilla::ErrorResult& aRv) const;
+  void GetCompatMode(nsString& retval) const;
+  void GetCharacterSet(nsAString& retval) const;
+
+
+  Element* GetDocumentElement() const
+  {
+    return GetRootElement();
+  }
+
+  enum ElementCallbackType {
+    eCreated,
+    eAttached,
+    eDetached,
+    eAttributeChanged
+  };
+
+  nsIDocument* GetTopLevelContentDocument();
+
+  virtual void
+    RegisterElement(JSContext* aCx, const nsAString& aName,
+                    const mozilla::dom::ElementRegistrationOptions& aOptions,
+                    JS::MutableHandle<JSObject*> aRetval,
+                    mozilla::ErrorResult& rv) = 0;
+  virtual already_AddRefed<mozilla::dom::CustomElementRegistry>
+    GetCustomElementRegistry() = 0;
+
+  already_AddRefed<nsContentList>
+  GetElementsByTagName(const nsAString& aTagName)
+  {
+    return NS_GetContentList(this, -1, aTagName);
+  }
+  already_AddRefed<nsContentList>
+    GetElementsByTagNameNS(const nsAString& aNamespaceURI,
+                           const nsAString& aLocalName,
+                           mozilla::ErrorResult& aResult);
+  already_AddRefed<nsContentList>
+    GetElementsByClassName(const nsAString& aClasses);
+
+  virtual already_AddRefed<Element>
+    CreateElement(const nsAString& aTagName,
+                  const mozilla::dom::ElementCreationOptionsOrString& aOptions,
+                  mozilla::ErrorResult& rv) = 0;
+  virtual already_AddRefed<Element>
+    CreateElementNS(const nsAString& aNamespaceURI,
+                    const nsAString& aQualifiedName,
+                    const mozilla::dom::ElementCreationOptionsOrString& aOptions,
+                    mozilla::ErrorResult& rv) = 0;
+  already_AddRefed<mozilla::dom::DocumentFragment>
+    CreateDocumentFragment() const;
+  already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData) const;
+  already_AddRefed<mozilla::dom::Comment>
+    CreateComment(const nsAString& aData) const;
+  already_AddRefed<mozilla::dom::ProcessingInstruction>
+    CreateProcessingInstruction(const nsAString& target, const nsAString& data,
+                                mozilla::ErrorResult& rv) const;
+  already_AddRefed<nsINode>
+    ImportNode(nsINode& aNode, bool aDeep, mozilla::ErrorResult& rv) const;
+  nsINode* AdoptNode(nsINode& aNode, mozilla::ErrorResult& rv);
+  already_AddRefed<mozilla::dom::Event>
+    CreateEvent(const nsAString& aEventType, mozilla::ErrorResult& rv) const;
+  already_AddRefed<nsRange> CreateRange(mozilla::ErrorResult& rv);
+  already_AddRefed<mozilla::dom::NodeIterator>
+    CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
+                       mozilla::dom::NodeFilter* aFilter,
+                       mozilla::ErrorResult& rv) const;
+  already_AddRefed<mozilla::dom::NodeIterator>
+    CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
+                       mozilla::dom::NodeFilterHolder aFilter,
+                       mozilla::ErrorResult& rv) const;
+  already_AddRefed<mozilla::dom::TreeWalker>
+    CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
+                     mozilla::dom::NodeFilter* aFilter, mozilla::ErrorResult& rv) const;
+  already_AddRefed<mozilla::dom::TreeWalker>
+    CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
+                     mozilla::dom::NodeFilterHolder aFilter,
+                     mozilla::ErrorResult& rv) const;
+
+
+  already_AddRefed<mozilla::dom::CDATASection>
+    CreateCDATASection(const nsAString& aData, mozilla::ErrorResult& rv);
+  already_AddRefed<mozilla::dom::Attr>
+    CreateAttribute(const nsAString& aName, mozilla::ErrorResult& rv);
+  already_AddRefed<mozilla::dom::Attr>
+    CreateAttributeNS(const nsAString& aNamespaceURI,
+                      const nsAString& aQualifiedName,
+                      mozilla::ErrorResult& rv);
+  void GetInputEncoding(nsAString& aInputEncoding) const;
+  already_AddRefed<mozilla::dom::Location> GetLocation() const;
+  void GetReferrer(nsAString& aReferrer) const;
+  void GetLastModified(nsAString& aLastModified) const;
+  void GetReadyState(nsAString& aReadyState) const;
+
+
+
+  virtual void GetTitle(nsString& aTitle) = 0;
+  virtual void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv) = 0;
+  void GetDir(nsAString& aDirection) const;
+  void SetDir(const nsAString& aDirection);
+  nsPIDOMWindowOuter* GetDefaultView() const
+  {
+    return GetWindow();
+  }
+  Element* GetActiveElement();
+  bool HasFocus(mozilla::ErrorResult& rv) const;
+  mozilla::TimeStamp LastFocusTime() const;
+  void SetLastFocusTime(const mozilla::TimeStamp& aFocusTime);
+
+  bool MozSyntheticDocument() const
+  {
+    return IsSyntheticDocument();
+  }
+  Element* GetCurrentScript();
+  void ReleaseCapture() const;
+  virtual void MozSetImageElement(const nsAString& aImageElementId,
+                                  Element* aElement) = 0;
+  nsIURI* GetDocumentURIObject() const;
+
+  virtual bool FullscreenEnabled(mozilla::dom::CallerType aCallerType) = 0;
+  virtual Element* GetFullscreenElement() = 0;
+  bool Fullscreen()
+  {
+    return !!GetFullscreenElement();
+  }
+  void ExitFullscreen();
+  Element* GetPointerLockElement();
+  void ExitPointerLock()
+  {
+    UnlockPointer(this);
+  }
+
+  bool Hidden() const
+  {
+    return mVisibilityState != mozilla::dom::VisibilityState::Visible;
+  }
+  mozilla::dom::VisibilityState VisibilityState() const
+  {
+    return mVisibilityState;
+  }
+
+  virtual mozilla::dom::StyleSheetList* StyleSheets() = 0;
+  void GetSelectedStyleSheetSet(nsAString& aSheetSet);
+  virtual void SetSelectedStyleSheetSet(const nsAString& aSheetSet) = 0;
+  virtual void GetLastStyleSheetSet(nsString& aSheetSet) = 0;
+  void GetPreferredStyleSheetSet(nsAString& aSheetSet);
+  virtual mozilla::dom::DOMStringList* StyleSheetSets() = 0;
+  virtual void EnableStyleSheetsForSet(const nsAString& aSheetSet) = 0;
+  Element* ElementFromPoint(float aX, float aY);
+  void ElementsFromPoint(float aX,
+                         float aY,
+                         nsTArray<RefPtr<mozilla::dom::Element>>& aElements);
+# 2723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  already_AddRefed<nsDOMCaretPosition>
+    CaretPositionFromPoint(float aX, float aY);
+
+  Element* GetScrollingElement();
+
+
+  nsINodeList* GetAnonymousNodes(Element& aElement);
+  Element* GetAnonymousElementByAttribute(Element& aElement,
+                                          const nsAString& aAttrName,
+                                          const nsAString& aAttrValue);
+  Element* GetBindingParent(nsINode& aNode);
+  void LoadBindingDocument(const nsAString& aURI,
+                           nsIPrincipal& aSubjectPrincipal,
+                           mozilla::ErrorResult& rv);
+  void LoadBindingDocument(const nsAString& aURI,
+                           const mozilla::Maybe<nsIPrincipal*>& aSubjectPrincipal,
+                           mozilla::ErrorResult& rv);
+  mozilla::dom::XPathExpression*
+    CreateExpression(const nsAString& aExpression,
+                     mozilla::dom::XPathNSResolver* aResolver,
+                     mozilla::ErrorResult& rv);
+  nsINode* CreateNSResolver(nsINode& aNodeResolver);
+  already_AddRefed<mozilla::dom::XPathResult>
+    Evaluate(JSContext* aCx, const nsAString& aExpression, nsINode& aContextNode,
+             mozilla::dom::XPathNSResolver* aResolver, uint16_t aType,
+             JS::Handle<JSObject*> aResult, mozilla::ErrorResult& rv);
+
+  already_AddRefed<mozilla::dom::Touch>
+    CreateTouch(nsGlobalWindow* aView, mozilla::dom::EventTarget* aTarget,
+                int32_t aIdentifier, int32_t aPageX, int32_t aPageY,
+                int32_t aScreenX, int32_t aScreenY, int32_t aClientX,
+                int32_t aClientY, int32_t aRadiusX, int32_t aRadiusY,
+                float aRotationAngle, float aForce);
+  already_AddRefed<mozilla::dom::TouchList> CreateTouchList();
+  already_AddRefed<mozilla::dom::TouchList>
+    CreateTouchList(mozilla::dom::Touch& aTouch,
+                    const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches);
+  already_AddRefed<mozilla::dom::TouchList>
+    CreateTouchList(const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches);
+
+  void SetStyleSheetChangeEventsEnabled(bool aValue)
+  {
+    mStyleSheetChangeEventsEnabled = aValue;
+  }
+
+  bool StyleSheetChangeEventsEnabled() const
+  {
+    return mStyleSheetChangeEventsEnabled;
+  }
+
+  void ObsoleteSheet(nsIURI *aSheetURI, mozilla::ErrorResult& rv);
+
+  void ObsoleteSheet(const nsAString& aSheetURI, mozilla::ErrorResult& rv);
+
+  already_AddRefed<mozilla::dom::Promise> BlockParsing(mozilla::dom::Promise& aPromise,
+                                                       mozilla::ErrorResult& aRv);
+
+  already_AddRefed<nsIURI> GetMozDocumentURIIfNotForErrorPages();
+
+
+  nsIHTMLCollection* Children();
+  uint32_t ChildElementCount();
+
+  virtual nsHTMLDocument* AsHTMLDocument() { return nullptr; }
+  virtual mozilla::dom::SVGDocument* AsSVGDocument() { return nullptr; }
+
+
+
+  virtual nsIDocument* MasterDocument() = 0;
+  virtual void SetMasterDocument(nsIDocument* master) = 0;
+  virtual bool IsMasterDocument() = 0;
+  virtual mozilla::dom::ImportManager* ImportManager() = 0;
+
+  virtual bool HasSubImportLink(nsINode* aLink) = 0;
+  virtual uint32_t IndexOfSubImportLink(nsINode* aLink) = 0;
+  virtual void AddSubImportLink(nsINode* aLink) = 0;
+  virtual nsINode* GetSubImportLink(uint32_t aIdx) = 0;
+
+
+
+
+
+
+  void AddBlockedTrackingNode(nsINode *node)
+  {
+    if (!node) {
+      return;
+    }
+
+    nsWeakPtr weakNode = do_GetWeakReference(node);
+
+    if (weakNode) {
+      mBlockedTrackingNodes.AppendElement(weakNode);
+    }
+  }
+
+  gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true);
+  void FlushUserFontSet();
+  void RebuildUserFontSet();
+  mozilla::dom::FontFaceSet* GetFonts() { return mFontFaceSet; }
+
+
+  mozilla::dom::FontFaceSet* Fonts();
+
+  bool DidFireDOMContentLoaded() const { return mDidFireDOMContentLoaded; }
+
+  void SetDocumentUseCounter(mozilla::UseCounter aUseCounter)
+  {
+    if (!mUseCounters[aUseCounter]) {
+      mUseCounters[aUseCounter] = true;
+    }
+  }
+
+  void SetPageUseCounter(mozilla::UseCounter aUseCounter);
+
+  void SetDocumentAndPageUseCounter(mozilla::UseCounter aUseCounter)
+  {
+    SetDocumentUseCounter(aUseCounter);
+    SetPageUseCounter(aUseCounter);
+  }
+
+  void PropagateUseCounters(nsIDocument* aParentDocument);
+
+  void SetUserHasInteracted(bool aUserHasInteracted)
+  {
+    mUserHasInteracted = aUserHasInteracted;
+  }
+
+  bool UserHasInteracted()
+  {
+    return mUserHasInteracted;
+  }
+
+  bool HasScriptsBlockedBySandbox();
+
+  bool InlineScriptAllowedByCSP();
+
+  void ReportHasScrollLinkedEffect();
+  bool HasScrollLinkedEffect() const
+  {
+    return mHasScrollLinkedEffect;
+  }
+
+  mozilla::dom::DocGroup* GetDocGroup() const;
+
+  virtual void AddIntersectionObserver(
+    mozilla::dom::DOMIntersectionObserver* aObserver) = 0;
+  virtual void RemoveIntersectionObserver(
+    mozilla::dom::DOMIntersectionObserver* aObserver) = 0;
+
+  virtual void UpdateIntersectionObservations() = 0;
+  virtual void ScheduleIntersectionObserverNotification() = 0;
+  virtual void NotifyIntersectionObservers() = 0;
+
+
+  virtual nsresult Dispatch(const char* aName,
+                            mozilla::TaskCategory aCategory,
+                            already_AddRefed<nsIRunnable>&& aRunnable) override;
+
+  virtual nsIEventTarget*
+  EventTargetFor(mozilla::TaskCategory aCategory) const override;
+
+  virtual mozilla::AbstractThread*
+  AbstractMainThreadFor(mozilla::TaskCategory aCategory) override;
+
+
+
+
+  void NoteScriptTrackingStatus(const nsACString& aURL, bool isTracking);
+  bool IsScriptTracking(const nsACString& aURL) const;
+
+  bool PrerenderHref(nsIURI* aHref);
+
+
+
+  virtual mozilla::dom::FlashClassification DocumentFlashClassification() = 0;
+  virtual bool IsThirdParty() = 0;
+
+protected:
+  bool GetUseCounter(mozilla::UseCounter aUseCounter)
+  {
+    return mUseCounters[aUseCounter];
+  }
+
+  void SetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
+  {
+    if (!mChildDocumentUseCounters[aUseCounter]) {
+      mChildDocumentUseCounters[aUseCounter] = true;
+    }
+  }
+
+  bool GetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
+  {
+    return mChildDocumentUseCounters[aUseCounter];
+  }
+
+private:
+  mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout;
+  mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout;
+
+  nsAutoPtr<SelectorCache> mSelectorCache;
+
+protected:
+  ~nsIDocument();
+  nsPropertyTable* GetExtraPropertyTable(uint16_t aCategory);
+
+
+  virtual nsPIDOMWindowOuter* GetWindowInternal() const = 0;
+
+
+  virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const = 0;
+
+
+  virtual bool InternalAllowXULXBL() = 0;
+
+
+
+
+
+
+  virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0;
+  virtual void MutationEventDispatched(nsINode* aTarget) = 0;
+  friend class mozAutoSubtreeModified;
+
+  virtual Element* GetNameSpaceElement() override
+  {
+    return GetRootElement();
+  }
+
+  void SetContentTypeInternal(const nsACString& aType);
+
+  nsCString GetContentTypeInternal() const
+  {
+    return mContentType;
+  }
+
+  mozilla::dom::XPathEvaluator* XPathEvaluator();
+
+  void HandleRebuildUserFontSet() {
+    mPostedFlushUserFontSet = false;
+    FlushUserFontSet();
+  }
+
+  const nsString& GetId() const
+  {
+    return mId;
+  }
+
+
+
+
+
+
+  void UpdateFrameRequestCallbackSchedulingState(nsIPresShell* aOldShell = nullptr);
+
+  nsCString mReferrer;
+  nsString mLastModified;
+
+  nsCOMPtr<nsIURI> mDocumentURI;
+  nsCOMPtr<nsIURI> mOriginalURI;
+  nsCOMPtr<nsIURI> mChromeXHRDocURI;
+  nsCOMPtr<nsIURI> mDocumentBaseURI;
+  nsCOMPtr<nsIURI> mChromeXHRDocBaseURI;
+
+  nsWeakPtr mDocumentLoadGroup;
+
+  bool mReferrerPolicySet;
+  ReferrerPolicyEnum mReferrerPolicy;
+
+  bool mBlockAllMixedContent;
+  bool mBlockAllMixedContentPreloads;
+  bool mUpgradeInsecureRequests;
+  bool mUpgradeInsecurePreloads;
+
+
+
+
+  nsDataHashtable<nsURIHashKey, HSTSPrimingState> mHSTSPrimingURIList;
+
+  mozilla::WeakPtr<nsDocShell> mDocumentContainer;
+
+  nsCString mCharacterSet;
+  int32_t mCharacterSetSource;
+
+
+  nsIDocument* mParentDocument;
+
+
+  mozilla::dom::Element* mCachedRootElement;
+
+
+
+  nsNodeInfoManager* mNodeInfoManager;
+  RefPtr<mozilla::css::Loader> mCSSLoader;
+  RefPtr<mozilla::css::ImageLoader> mStyleImageLoader;
+  RefPtr<nsHTMLStyleSheet> mAttrStyleSheet;
+  RefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet;
+
+
+  RefPtr<mozilla::dom::ImageTracker> mImageTracker;
+
+
+
+
+
+
+  nsAutoPtr<nsTHashtable<nsPtrHashKey<nsISupports> > > mActivityObservers;
+
+
+
+
+  nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mLinksToUpdate;
+
+
+  RefPtr<nsSMILAnimationController> mAnimationController;
+
+
+  nsPropertyTable mPropertyTable;
+  nsTArray<nsAutoPtr<nsPropertyTable> > mExtraPropertyTables;
+
+
+  nsCOMPtr<nsIHTMLCollection> mChildrenCollection;
+
+
+  RefPtr<mozilla::dom::FontFaceSet> mFontFaceSet;
+
+
+
+  mozilla::TimeStamp mLastFocusTime;
+
+
+  bool mBidiEnabled : 1;
+
+  bool mMathMLEnabled : 1;
+
+
+
+
+
+  bool mIsInitialDocumentInWindow : 1;
+
+  bool mIgnoreDocGroupMismatches : 1;
+
+
+
+  bool mLoadedAsData : 1;
+
+
+
+
+  bool mLoadedAsInteractiveData : 1;
+
+
+
+  bool mMayStartLayout : 1;
+
+
+  bool mHaveFiredTitleChange : 1;
+
+
+
+
+
+  bool mIsShowing : 1;
+
+
+
+
+  bool mVisible : 1;
+
+
+  bool mHasReferrerPolicyCSP : 1;
+
+
+
+
+  bool mRemovedFromDocShell : 1;
+
+
+
+  bool mAllowDNSPrefetch : 1;
+
+
+  bool mIsStaticDocument : 1;
+
+
+  bool mCreatingStaticClone : 1;
+
+
+  bool mInUnlinkOrDeletion : 1;
+
+
+  bool mHasHadScriptHandlingObject : 1;
+
+
+  bool mIsBeingUsedAsImage : 1;
+
+
+
+  bool mIsSyntheticDocument : 1;
+
+
+  bool mHasLinksToUpdate : 1;
+
+
+  bool mMayHaveDOMMutationObservers : 1;
+
+
+  bool mMayHaveAnimationObservers : 1;
+
+
+  bool mHasMixedActiveContentLoaded : 1;
+
+
+  bool mHasMixedActiveContentBlocked : 1;
+
+
+  bool mHasMixedDisplayContentLoaded : 1;
+
+
+  bool mHasMixedDisplayContentBlocked : 1;
+
+
+  bool mHasMixedContentObjectSubrequest : 1;
+
+
+  bool mHasCSP : 1;
+
+
+  bool mHasUnsafeEvalCSP : 1;
+
+
+  bool mHasUnsafeInlineCSP : 1;
+
+
+  bool mHasTrackingContentBlocked : 1;
+
+
+  bool mHasTrackingContentLoaded : 1;
+
+
+  bool mBFCacheDisallowed : 1;
+
+  bool mHasHadDefaultView : 1;
+
+
+  bool mStyleSheetChangeEventsEnabled : 1;
+
+
+  bool mIsSrcdocDocument : 1;
+
+
+
+
+  bool mDidDocumentOpen : 1;
+
+
+
+
+
+  bool mHasDisplayDocument : 1;
+
+
+  bool mFontFaceSetDirty : 1;
+
+
+  bool mGetUserFontSetCalled : 1;
+
+
+  bool mPostedFlushUserFontSet : 1;
+
+
+
+  bool mDidFireDOMContentLoaded : 1;
+
+
+  bool mHasScrollLinkedEffect : 1;
+
+
+
+
+  bool mFrameRequestCallbacksScheduled : 1;
+
+
+  nsCompatibility mCompatMode;
+
+
+  ReadyState mReadyState;
+
+
+
+  mozilla::StyleBackendType mStyleBackendType;
+
+
+
+  mozilla::dom::VisibilityState mVisibilityState;
+  static_assert(sizeof(mozilla::dom::VisibilityState) == sizeof(uint8_t),
+                "Error size of mVisibilityState and mDummy");
+
+
+
+
+  enum Type {
+    eUnknown,
+    eHTML,
+    eXHTML,
+    eGenericXML,
+    eSVG,
+    eXUL
+  };
+
+  Type mType;
+
+  uint8_t mDefaultElementType;
+
+  enum Tri {
+    eTriUnset = 0,
+    eTriFalse,
+    eTriTrue
+  };
+
+  Tri mAllowXULXBL;
+# 3257 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
+  nsCOMPtr<nsIScriptGlobalObject> mScriptGlobalObject;
+
+
+
+  nsCOMPtr<nsIDocument> mOriginalDocument;
+
+
+
+  uint32_t mBidiOptions;
+
+
+
+
+  uint32_t mSandboxFlags;
+
+  nsCString mContentLanguage;
+
+
+  nsCOMPtr<nsIChannel> mChannel;
+private:
+  nsCString mContentType;
+  nsString mId;
+protected:
+
+
+  nsCOMPtr<nsISupports> mSecurityInfo;
+
+
+
+  nsCOMPtr<nsIChannel> mFailedChannel;
+
+
+
+  uint32_t mPartID;
+
+
+
+  uint32_t mMarkedCCGeneration;
+
+  nsIPresShell* mPresShell;
+
+  nsCOMArray<nsINode> mSubtreeModifiedTargets;
+  uint32_t mSubtreeModifiedDepth;
+
+
+
+
+  nsCOMPtr<nsIDocument> mDisplayDocument;
+
+  uint32_t mEventsSuppressed;
+
+
+
+
+
+  uint32_t mExternalScriptsBeingEvaluated;
+
+
+
+
+  int32_t mFrameRequestCallbackCounter;
+
+
+  uint32_t mStaticCloneCount;
+
+
+
+
+
+
+  nsTArray<nsWeakPtr> mBlockedTrackingNodes;
+
+
+
+  nsPIDOMWindowInner* mWindow;
+
+  nsCOMPtr<nsIDocumentEncoder> mCachedEncoder;
+
+  struct FrameRequest;
+
+  nsTArray<FrameRequest> mFrameRequestCallbacks;
+
+
+
+  nsIBFCacheEntry *mBFCacheEntry;
+
+
+  nsString mBaseTarget;
+
+  nsCOMPtr<nsIStructuredCloneContainer> mStateObjectContainer;
+  nsCOMPtr<nsIVariant> mStateObjectCached;
+
+  uint32_t mInSyncOperationCount;
+
+  RefPtr<mozilla::dom::XPathEvaluator> mXPathEvaluator;
+
+  nsTArray<RefPtr<mozilla::dom::AnonymousContent>> mAnonymousContents;
+
+  uint32_t mBlockDOMContentLoaded;
+
+
+  PRCList mDOMMediaQueryLists;
+
+
+  std::bitset<mozilla::eUseCounter_Count> mUseCounters;
+
+  std::bitset<mozilla::eUseCounter_Count> mChildDocumentUseCounters;
+
+
+  std::bitset<mozilla::eUseCounter_Count> mNotifiedPageForUseCounter;
+
+
+  bool mUserHasInteracted;
+
+  mozilla::TimeStamp mPageUnloadingEventTimeStamp;
+
+  RefPtr<mozilla::dom::DocGroup> mDocGroup;
+
+
+
+
+  nsTHashtable<nsCStringHashKey> mTrackingScripts;
+};
+
+template<typename T> struct nsIDocument::COMTypeInfo<nsIDocument, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDocument::COMTypeInfo<nsIDocument, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xce1f7627, 0x7109, 0x4977, { 0xba, 0x77, 0x49, 0x0f, 0xfd, 0xe0, 0x7a, 0xaa } };
+
+
+
+
+
+
+class mozAutoSubtreeModified
+{
+public:
+
+
+
+
+
+
+  mozAutoSubtreeModified(nsIDocument* aSubtreeOwner, nsINode* aTarget)
+  {
+    UpdateTarget(aSubtreeOwner, aTarget);
+  }
+
+  ~mozAutoSubtreeModified()
+  {
+    UpdateTarget(nullptr, nullptr);
+  }
+
+  void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget)
+  {
+    if (mSubtreeOwner) {
+      mSubtreeOwner->MutationEventDispatched(mTarget);
+    }
+
+    mTarget = aTarget;
+    mSubtreeOwner = aSubtreeOwner;
+    if (mSubtreeOwner) {
+      mSubtreeOwner->WillDispatchMutationEvent(mTarget);
+    }
+  }
+
+private:
+  nsCOMPtr<nsINode> mTarget;
+  nsCOMPtr<nsIDocument> mSubtreeOwner;
+};
+
+class nsAutoSyncOperation
+{
+public:
+  explicit nsAutoSyncOperation(nsIDocument* aDocument);
+  ~nsAutoSyncOperation();
+private:
+  nsCOMArray<nsIDocument> mDocuments;
+  uint32_t mMicroTaskLevel;
+};
+
+
+nsresult
+NS_NewHTMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false);
+
+nsresult
+NS_NewXMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false,
+                  bool aIsPlainDocument = false);
+
+nsresult
+NS_NewSVGDocument(nsIDocument** aInstancePtrResult);
+
+nsresult
+NS_NewImageDocument(nsIDocument** aInstancePtrResult);
+
+nsresult
+NS_NewVideoDocument(nsIDocument** aInstancePtrResult);
+
+
+
+
+nsresult
+NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
+                  const nsAString& aNamespaceURI,
+                  const nsAString& aQualifiedName,
+                  nsIDOMDocumentType* aDoctype,
+                  nsIURI* aDocumentURI,
+                  nsIURI* aBaseURI,
+                  nsIPrincipal* aPrincipal,
+                  bool aLoadedAsData,
+                  nsIGlobalObject* aEventObject,
+                  DocumentFlavor aFlavor);
+
+
+
+nsresult
+NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult,
+                  nsIURI* aDocumentURI,
+                  nsIURI* aBaseURI,
+                  nsIPrincipal* aPrincipal);
+
+nsresult
+NS_NewPluginDocument(nsIDocument** aInstancePtrResult);
+
+inline nsIDocument*
+nsINode::GetOwnerDocument() const
+{
+  nsIDocument* ownerDoc = OwnerDoc();
+
+  return ownerDoc != this ? ownerDoc : nullptr;
+}
+
+inline nsINode*
+nsINode::OwnerDocAsNode() const
+{
+  return OwnerDoc();
+}
+
+inline mozilla::dom::ParentObject
+nsINode::GetParentObject() const
+{
+  mozilla::dom::ParentObject p(OwnerDoc());
+
+
+  p.mUseXBLScope = IsInAnonymousSubtree() && !IsAnonymousContentInSVGUseSubtree();
+  return p;
+}
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 1
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+namespace mozilla {
+class TimeStamp;
+
+namespace dom {
+class Promise;
+}
+
+}
+
+class nsIProfilerStartParams;
+
+enum TracingKind {
+  TRACING_EVENT,
+  TRACING_INTERVAL_START,
+  TRACING_INTERVAL_END,
+};
+
+class ProfilerBacktrace;
+
+struct ProfilerBacktraceDestructor
+{
+  void operator()(ProfilerBacktrace*);
+};
+using UniqueProfilerBacktrace =
+  mozilla::UniquePtr<ProfilerBacktrace, ProfilerBacktraceDestructor>;
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+void profiler_tracing(const char* aCategory, const char* aInfo, TracingKind aKind = TRACING_EVENT);
+
+void profiler_tracing(const char* aCategory, const char* aInfo, UniqueProfilerBacktrace aCause, TracingKind aKind = TRACING_EVENT);
+
+
+
+
+
+
+void profiler_init(void* stackTop);
+
+
+
+
+void profiler_shutdown();
+
+
+
+
+
+
+
+void profiler_start(int aEntries, double aInterval, const char** aFeatures, uint32_t aFeatureCount, const char** aThreadNameFilters, uint32_t aFilterCount);
+
+
+
+
+
+
+
+void profiler_stop();
+
+
+
+
+
+
+
+void profiler_pause();
+void profiler_resume();
+
+
+bool profiler_is_paused();
+
+
+
+UniqueProfilerBacktrace profiler_get_backtrace();
+
+void profiler_get_backtrace_noalloc(char *output, size_t outputSize);
+# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+bool profiler_is_active();
+
+
+
+
+
+bool profiler_feature_active(const char*);
+
+
+
+void profiler_set_frame_number(int frameNumber);
+
+
+
+mozilla::UniquePtr<char[]> profiler_get_profile(double aSinceTime = 0);
+
+
+
+
+JSObject* profiler_get_profile_jsobject(JSContext* aCx, double aSinceTime = 0);
+
+
+
+
+
+void profiler_get_profile_jsobject_async(double aSinceTime = 0, mozilla::dom::Promise* = 0);
+
+
+
+
+void profiler_get_start_params(int* aEntrySize, double* aInterval, mozilla::Vector<const char*>* aFeatures, mozilla::Vector<const char*>* aFilters);
+# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+extern "C" {
+void profiler_save_profile_to_file(const char* aFilename);
+}
+
+
+
+
+const char** profiler_get_features();
+
+
+
+
+void profiler_get_buffer_info_helper(uint32_t* aCurrentPosition, uint32_t* aEntries, uint32_t* aGeneration);
+# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+static inline void profiler_get_buffer_info(uint32_t* aCurrentPosition,
+                                            uint32_t* aEntries,
+                                            uint32_t* aGeneration)
+{
+  *aCurrentPosition = 0;
+  *aEntries = 0;
+  *aGeneration = 0;
+
+  profiler_get_buffer_info_helper(aCurrentPosition, aEntries, aGeneration);
+}
+
+
+
+void profiler_register_thread(const char* name, void* guessStackTop);
+
+void profiler_unregister_thread();
+
+
+
+
+
+void profiler_thread_sleep();
+void profiler_thread_wake();
+bool profiler_thread_is_sleeping();
+
+
+
+
+void profiler_js_interrupt_callback();
+
+
+
+double profiler_time();
+
+void profiler_log(const char *str);
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h"
+struct JSRuntime;
+class JSTracer;
+
+namespace js {
+
+
+
+
+
+
+class ProfileEntry
+{
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h"
+    const char * volatile string;
+
+
+    const char * volatile dynamicString;
+
+
+    void * volatile spOrScript;
+
+
+    int32_t volatile lineOrPcOffset;
+
+
+    uint32_t volatile flags_;
+
+  public:
+
+    enum Flags : uint32_t {
+
+
+
+
+        IS_CPP_ENTRY = 0x01,
+
+
+
+        FRAME_LABEL_COPY = 0x02,
+
+
+
+        BEGIN_PSEUDO_JS = 0x04,
+
+
+
+        OSR = 0x08,
+
+
+        ALL = IS_CPP_ENTRY|FRAME_LABEL_COPY|BEGIN_PSEUDO_JS|OSR,
+
+
+        CATEGORY_MASK = ~ALL
+    };
+
+
+    enum class Category : uint32_t {
+        OTHER = 0x10,
+        CSS = 0x20,
+        JS = 0x40,
+        GC = 0x80,
+        CC = 0x100,
+        NETWORK = 0x200,
+        GRAPHICS = 0x400,
+        STORAGE = 0x800,
+        EVENTS = 0x1000,
+
+        FIRST = OTHER,
+        LAST = EVENTS
+    };
+
+    static_assert((static_cast<int>(Category::FIRST) & Flags::ALL) == 0,
+                  "The category bitflags should not intersect with the other flags!");
+
+
+
+
+
+
+    bool isCpp() const volatile { return hasFlag(IS_CPP_ENTRY); }
+    bool isJs() const volatile { return !isCpp(); }
+
+    bool isCopyLabel() const volatile { return hasFlag(FRAME_LABEL_COPY); }
+
+    void setLabel(const char* aString) volatile { string = aString; }
+    const char* label() const volatile { return string; }
+
+    void setDynamicString(const char* aDynamicString) volatile { dynamicString = aDynamicString; }
+    const char* getDynamicString() const volatile { return dynamicString; }
+
+    void initJsFrame(JSScript* aScript, jsbytecode* aPc) volatile {
+        flags_ = 0;
+        spOrScript = aScript;
+        setPC(aPc);
+    }
+    void initCppFrame(void* aSp, uint32_t aLine) volatile {
+        flags_ = IS_CPP_ENTRY;
+        spOrScript = aSp;
+        lineOrPcOffset = static_cast<int32_t>(aLine);
+    }
+
+    void setFlag(uint32_t flag) volatile {
+        do { } while (0);
+        flags_ |= flag;
+    }
+    void unsetFlag(uint32_t flag) volatile {
+        do { } while (0);
+        flags_ &= ~flag;
+    }
+    bool hasFlag(uint32_t flag) const volatile {
+        return bool(flags_ & flag);
+    }
+
+    uint32_t flags() const volatile {
+        return flags_;
+    }
+
+    uint32_t category() const volatile {
+        return flags_ & CATEGORY_MASK;
+    }
+    void setCategory(Category c) volatile {
+        do { } while (0);
+        do { } while (0);
+        flags_ &= ~CATEGORY_MASK;
+        setFlag(static_cast<uint32_t>(c));
+    }
+
+    void setOSR() volatile {
+        do { } while (0);
+        setFlag(OSR);
+    }
+    void unsetOSR() volatile {
+        do { } while (0);
+        unsetFlag(OSR);
+    }
+    bool isOSR() const volatile {
+        return hasFlag(OSR);
+    }
+
+    void* stackAddress() const volatile {
+        do { } while (0);
+        return spOrScript;
+    }
+    JSScript* script() const volatile;
+    uint32_t line() const volatile {
+        do { } while (0);
+        return static_cast<uint32_t>(lineOrPcOffset);
+    }
+
+
+    JSScript* rawScript() const volatile {
+        do { } while (0);
+        return (JSScript*)spOrScript;
+    }
+
+
+    jsbytecode* pc() const volatile;
+    void setPC(jsbytecode* pc) volatile;
+
+    void trace(JSTracer* trc);
+
+
+
+
+    static const int32_t NullPCOffset = -1;
+
+    static size_t offsetOfLabel() { return __builtin_offsetof(ProfileEntry, string); }
+    static size_t offsetOfSpOrScript() { return __builtin_offsetof(ProfileEntry, spOrScript); }
+    static size_t offsetOfLineOrPcOffset() { return __builtin_offsetof(ProfileEntry, lineOrPcOffset); }
+    static size_t offsetOfFlags() { return __builtin_offsetof(ProfileEntry, flags_); }
+};
+
+void
+SetContextProfilingStack(JSContext* cx, ProfileEntry* stack, uint32_t* size,
+                         uint32_t max);
+
+void
+EnableContextProfilingStack(JSContext* cx, bool enabled);
+
+void
+RegisterContextProfilingEventMarker(JSContext* cx, void (*fn)(const char*));
+
+jsbytecode*
+ProfilingGetPC(JSContext* cx, JSScript* script, void* ip);
+
+}
+# 308 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Sprintf.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Sprintf.h"
+template <size_t N>
+int VsprintfLiteral(char (&buffer)[N], const char* format, va_list args)
+{
+    do { } while (0);
+    int result = vsnprintf(buffer, N, format, args);
+    buffer[N - 1] = '\0';
+    return result;
+}
+
+template <size_t N>
+__attribute__ ((format (printf, 2, 3)))
+int SprintfLiteral(char (&buffer)[N], const char* format, ...)
+{
+  va_list args;
+  __builtin_va_start(args, format);
+  int result = VsprintfLiteral(buffer, format, args);
+  __builtin_va_end(args);
+  return result;
+}
+# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h" 1
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+namespace mozilla {
+
+
+
+
+
+
+
+typedef sig_atomic_t sig_safe_t;
+
+
+namespace detail {
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+template<typename T>
+class ThreadLocal
+{
+# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+  bool initialized() const {
+
+    return true;
+
+
+
+  }
+
+public:
+# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+  __attribute__ ((warn_unused_result)) inline bool init();
+
+  inline T get() const;
+
+  inline void set(const T aValue);
+
+private:
+
+  T mValue;
+
+
+
+
+};
+
+template<typename T>
+inline bool
+ThreadLocal<T>::init()
+{
+  static_assert(mozilla::IsPointer<T>::value || mozilla::IsIntegral<T>::value,
+                "mozilla::ThreadLocal must be used with a pointer or "
+                "integral type");
+  static_assert(sizeof(T) <= sizeof(void*),
+                "mozilla::ThreadLocal can't be used for types larger than "
+                "a pointer");
+
+
+  return true;
+# 173 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+}
+
+template<typename T>
+inline T
+ThreadLocal<T>::get() const
+{
+
+  return mValue;
+# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+}
+
+template<typename T>
+inline void
+ThreadLocal<T>::set(const T aValue)
+{
+
+  mValue = aValue;
+# 211 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
+}
+
+
+
+
+
+
+
+}
+}
+# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 2
+# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+class ProfilerMarkerPayload;
+template<typename T>
+class ProfilerLinkedList;
+class SpliceableJSONWriter;
+class UniqueStacks;
+
+class ProfilerMarker
+{
+  friend class ProfilerLinkedList<ProfilerMarker>;
+
+public:
+  explicit ProfilerMarker(const char* aMarkerName,
+                          ProfilerMarkerPayload* aPayload = nullptr,
+                          double aTime = 0);
+  ~ProfilerMarker();
+
+  const char* GetMarkerName() const { return mMarkerName; }
+
+  void StreamJSON(SpliceableJSONWriter& aWriter,
+                  const mozilla::TimeStamp& aStartTime,
+                  UniqueStacks& aUniqueStacks) const;
+
+  void SetGeneration(uint32_t aGenID);
+
+  bool HasExpired(uint32_t aGenID) const { return mGenID + 2 <= aGenID; }
+
+  double GetTime() const;
+
+private:
+  char* mMarkerName;
+  ProfilerMarkerPayload* mPayload;
+  ProfilerMarker* mNext;
+  double mTime;
+  uint32_t mGenID;
+};
+
+template<typename T>
+class ProfilerLinkedList
+{
+public:
+  ProfilerLinkedList()
+    : mHead(nullptr)
+    , mTail(nullptr)
+  {}
+
+  void insert(T* aElem)
+  {
+    if (!mTail) {
+      mHead = aElem;
+      mTail = aElem;
+    } else {
+      mTail->mNext = aElem;
+      mTail = aElem;
+    }
+    aElem->mNext = nullptr;
+  }
+
+  T* popHead()
+  {
+    if (!mHead) {
+      do { } while (0);
+      return nullptr;
+    }
+
+    T* head = mHead;
+
+    mHead = head->mNext;
+    if (!mHead) {
+      mTail = nullptr;
+    }
+
+    return head;
+  }
+
+  const T* peek() {
+    return mHead;
+  }
+
+private:
+  T* mHead;
+  T* mTail;
+};
+
+typedef ProfilerLinkedList<ProfilerMarker> ProfilerMarkerLinkedList;
+
+template<typename T>
+class ProfilerSignalSafeLinkedList {
+public:
+  ProfilerSignalSafeLinkedList()
+    : mSignalLock(false)
+  {}
+
+  ~ProfilerSignalSafeLinkedList()
+  {
+    if (mSignalLock) {
+
+
+      abort();
+    }
+
+    while (mList.peek()) {
+      delete mList.popHead();
+    }
+  }
+
+
+
+
+
+
+  void insert(T* aElement)
+  {
+    do { } while (0);
+
+    mSignalLock = true;
+    asm volatile("" ::: "memory");;
+
+    mList.insert(aElement);
+
+    asm volatile("" ::: "memory");;
+    mSignalLock = false;
+  }
+
+
+
+
+
+  ProfilerLinkedList<T>* accessList()
+  {
+    return mSignalLock ? nullptr : &mList;
+  }
+
+private:
+  ProfilerLinkedList<T> mList;
+
+
+
+  volatile bool mSignalLock;
+};
+
+
+void ProfilerJSEventMarker(const char* aEvent);
+
+
+
+
+
+
+struct PseudoStack
+{
+public:
+  PseudoStack()
+    : mStackPointer(0)
+    , mSleep(AWAKE)
+    , mContext(nullptr)
+    , mJSSampling(INACTIVE)
+  {
+                               ;
+  }
+
+  ~PseudoStack()
+  {
+                               ;
+
+
+
+
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mStackPointer == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mStackPointer == 0))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mStackPointer == 0" ")"); do { *((volatile int*) __null) = 219; ::abort(); } while (0); } } while (0);
+  }
+
+
+
+  void reinitializeOnResume()
+  {
+
+
+
+
+    (void)mSleep.compareExchange(SLEEPING_OBSERVED, SLEEPING_NOT_OBSERVED);
+  }
+
+  void addMarker(const char* aMarkerStr, ProfilerMarkerPayload* aPayload,
+                 double aTime)
+  {
+    ProfilerMarker* marker = new ProfilerMarker(aMarkerStr, aPayload, aTime);
+    mPendingMarkers.insert(marker);
+  }
+
+
+  ProfilerMarkerLinkedList* getPendingMarkers()
+  {
+
+
+
+    return mPendingMarkers.accessList();
+  }
+
+  void push(const char* aName, js::ProfileEntry::Category aCategory,
+            uint32_t line)
+  {
+    push(aName, aCategory, nullptr, false, line, nullptr);
+  }
+
+  void push(const char* aName, js::ProfileEntry::Category aCategory,
+            void* aStackAddress, bool aCopy, uint32_t line,
+            const char* aDynamicString)
+  {
+    if (size_t(mStackPointer) >= mozilla::ArrayLength(mStack)) {
+      mStackPointer++;
+      return;
+    }
+
+    volatile js::ProfileEntry& entry = mStack[mStackPointer];
+
+
+
+    entry.initCppFrame(aStackAddress, line);
+    entry.setLabel(aName);
+    entry.setDynamicString(aDynamicString);
+    do { } while (0);
+    entry.setCategory(aCategory);
+
+
+    if (aCopy) {
+      entry.setFlag(js::ProfileEntry::FRAME_LABEL_COPY);
+    } else {
+      entry.unsetFlag(js::ProfileEntry::FRAME_LABEL_COPY);
+    }
+
+
+    asm volatile("" ::: "memory");;
+    mStackPointer++;
+  }
+
+
+  void pop() { mStackPointer--; }
+
+  uint32_t stackSize() const
+  {
+    return std::min(mStackPointer,
+                    mozilla::sig_safe_t(mozilla::ArrayLength(mStack)));
+  }
+
+
+
+  void setJSContext(JSContext* aContext)
+  {
+
+
+    do { } while (0);
+
+    mContext = aContext;
+
+    js::SetContextProfilingStack(aContext,
+                                 (js::ProfileEntry*) mStack,
+                                 (uint32_t*) &mStackPointer,
+                                 (uint32_t) mozilla::ArrayLength(mStack));
+    pollJSSampling();
+  }
+
+
+
+
+  void startJSSampling()
+  {
+
+
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED" ")"); do { *((volatile int*) __null) = 320; ::abort(); } while (0); } } while (0);
+
+    mJSSampling = ACTIVE_REQUESTED;
+  }
+
+
+
+  void stopJSSampling()
+  {
+
+
+    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED" ")"); do { *((volatile int*) __null) = 331; ::abort(); } while (0); } } while (0);
+
+    mJSSampling = INACTIVE_REQUESTED;
+  }
+
+
+  void pollJSSampling()
+  {
+
+
+
+    if (mContext) {
+# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+      if (mJSSampling.compareExchange(ACTIVE_REQUESTED, ACTIVE)) {
+        js::EnableContextProfilingStack(mContext, true);
+        js::RegisterContextProfilingEventMarker(mContext,
+                                                &ProfilerJSEventMarker);
+
+      } else if (mJSSampling.compareExchange(INACTIVE_REQUESTED, INACTIVE)) {
+        js::EnableContextProfilingStack(mContext, false);
+      }
+    }
+  }
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    size_t n = aMallocSizeOf(this);
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+    return n;
+  }
+
+
+  bool CanDuplicateLastSampleDueToSleep()
+  {
+    if (mSleep == AWAKE) {
+      return false;
+    }
+
+    if (mSleep.compareExchange(SLEEPING_NOT_OBSERVED, SLEEPING_OBSERVED)) {
+      return false;
+    }
+
+    return true;
+  }
+
+
+
+  void setSleeping()
+  {
+    do { } while (0);
+    mSleep = SLEEPING_NOT_OBSERVED;
+  }
+
+
+
+  void setAwake()
+  {
+    do { } while (0);
+    mSleep = AWAKE;
+  }
+
+  bool isSleeping() { return mSleep != AWAKE; }
+
+private:
+
+  PseudoStack(const PseudoStack&) = delete;
+  void operator=(const PseudoStack&) = delete;
+
+  void flushSamplerOnJSShutdown();
+
+public:
+
+  js::ProfileEntry volatile mStack[1024];
+
+private:
+
+  ProfilerSignalSafeLinkedList<ProfilerMarker> mPendingMarkers;
+
+
+
+  mozilla::sig_safe_t mStackPointer;
+# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+  static const int AWAKE = 0;
+  static const int SLEEPING_NOT_OBSERVED = 1;
+  static const int SLEEPING_OBSERVED = 2;
+  mozilla::Atomic<int> mSleep;
+
+public:
+
+
+  JSContext* mContext;
+
+private:
+# 514 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
+  static const int INACTIVE = 0;
+  static const int ACTIVE_REQUESTED = 1;
+  static const int ACTIVE = 2;
+  static const int INACTIVE_REQUESTED = 3;
+  mozilla::Atomic<int> mJSSampling;
+};
+# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class mozIDOMWindowProxy;
+
+class nsIRunnable;
+
+class nsISimpleEnumerator;
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class nsIMemoryReporterCallback : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Callback(const nsACString & process, const nsACString & path, int32_t kind, int32_t units, int64_t amount, const nsACString & description, nsISupports *data) = 0;
+
+};
+
+  template<typename T> struct nsIMemoryReporterCallback::COMTypeInfo<nsIMemoryReporterCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporterCallback::COMTypeInfo<nsIMemoryReporterCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x62ef0e1c, 0xdbd6, 0x11e3, { 0xaa, 0x75, 0x3c, 0x97, 0x0e, 0x9f, 0x42, 0x38 }};
+# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class nsIMemoryReporter : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult CollectReports(nsIMemoryReporterCallback *callback, nsISupports *data, bool anonymize) = 0;
+
+  enum {
+    KIND_NONHEAP = 0,
+    KIND_HEAP = 1,
+    KIND_OTHER = 2,
+    UNITS_BYTES = 0,
+    UNITS_COUNT = 1,
+    UNITS_COUNT_CUMULATIVE = 2,
+    UNITS_PERCENTAGE = 3
+  };
+
+};
+
+  template<typename T> struct nsIMemoryReporter::COMTypeInfo<nsIMemoryReporter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporter::COMTypeInfo<nsIMemoryReporter, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x92a36db1, 0x46bd, 0x4fe6, { 0x98, 0x8e, 0x47, 0xdb, 0x47, 0x23, 0x6d, 0x8b }};
+# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class nsIFinishReportingCallback : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Callback(nsISupports *data) = 0;
+
+};
+
+  template<typename T> struct nsIFinishReportingCallback::COMTypeInfo<nsIFinishReportingCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFinishReportingCallback::COMTypeInfo<nsIFinishReportingCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x548b3909, 0xc04d, 0x4ca6, { 0x84, 0x66, 0xb8, 0xbe, 0xe3, 0x83, 0x74, 0x57 }};
+# 279 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class nsIMemoryReporterManager : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult Init(void) = 0;
+
+
+  virtual nsresult RegisterStrongReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult RegisterStrongAsyncReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult RegisterWeakReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult RegisterWeakAsyncReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult UnregisterStrongReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult UnregisterWeakReporter(nsIMemoryReporter *reporter) = 0;
+
+
+  virtual nsresult BlockRegistrationAndHideExistingReporters(void) = 0;
+
+
+  virtual nsresult UnblockRegistrationAndRestoreOriginalReporters(void) = 0;
+
+
+  virtual nsresult RegisterStrongReporterEvenIfBlocked(nsIMemoryReporter *aReporter) = 0;
+
+
+  virtual nsresult GetReports(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData, bool anonymize) = 0;
+
+
+  virtual nsresult GetReportsExtended(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData, bool anonymize, bool minimizeMemoryUsage, const nsAString & DMDDumpIdent) = 0;
+
+
+  virtual nsresult GetReportsForThisProcessExtended(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, bool anonymize, FILE *DMDFile, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData) = 0;
+
+
+  virtual nsresult EndReport(void) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetVsize(int64_t *aVsize) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetVsizeMaxContiguous(int64_t *aVsizeMaxContiguous) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResident(int64_t *aResident) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentFast(int64_t *aResidentFast) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentPeak(int64_t *aResidentPeak) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentUnique(int64_t *aResidentUnique) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetHeapAllocated(int64_t *aHeapAllocated) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetHeapOverheadFraction(int64_t *aHeapOverheadFraction) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeGCHeap(int64_t *aJSMainRuntimeGCHeap) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeTemporaryPeak(int64_t *aJSMainRuntimeTemporaryPeak) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeCompartmentsSystem(int64_t *aJSMainRuntimeCompartmentsSystem) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeCompartmentsUser(int64_t *aJSMainRuntimeCompartmentsUser) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetImagesContentUsedUncompressed(int64_t *aImagesContentUsedUncompressed) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetStorageSQLite(int64_t *aStorageSQLite) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetLowMemoryEventsVirtual(int64_t *aLowMemoryEventsVirtual) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetLowMemoryEventsPhysical(int64_t *aLowMemoryEventsPhysical) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetGhostWindows(int64_t *aGhostWindows) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetPageFaultsHard(int64_t *aPageFaultsHard) = 0;
+
+
+  virtual nsresult GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize) = 0;
+  inline bool GetHasMozMallocUsableSize()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetHasMozMallocUsableSize(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsDMDEnabled(bool *aIsDMDEnabled) = 0;
+  inline bool GetIsDMDEnabled()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsDMDEnabled(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  virtual nsresult GetIsDMDRunning(bool *aIsDMDRunning) = 0;
+  inline bool GetIsDMDRunning()
+  {
+    bool result;
+    mozilla::DebugOnly<nsresult> rv = GetIsDMDRunning(&result);
+    do { } while (0);
+    return result;
+  }
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult MinimizeMemoryUsage(nsIRunnable *callback) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SizeOfTab(mozIDOMWindowProxy *window, int64_t *jsObjectsSize, int64_t *jsStringsSize, int64_t *jsOtherSize, int64_t *domSize, int64_t *styleSize, int64_t *otherSize, int64_t *totalSize, double *jsMilliseconds, double *nonJSMilliseconds) = 0;
+
+};
+
+  template<typename T> struct nsIMemoryReporterManager::COMTypeInfo<nsIMemoryReporterManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporterManager::COMTypeInfo<nsIMemoryReporterManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2998574d, 0x8993, 0x407a, { 0xb1, 0xa5, 0x8a, 0xd7, 0x41, 0x76, 0x53, 0xe1 }};
+# 851 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
+class nsPIDOMWindowOuter;
+
+
+typedef nsIMemoryReporterCallback nsIHandleReportCallback;
+namespace mozilla {
+
+
+
+
+extern "C" nsresult RegisterStrongMemoryReporter(nsIMemoryReporter* aReporter);
+extern "C" nsresult RegisterStrongAsyncMemoryReporter(nsIMemoryReporter* aReporter);
+
+
+extern "C" nsresult RegisterWeakMemoryReporter(nsIMemoryReporter* aReporter);
+extern "C" nsresult RegisterWeakAsyncMemoryReporter(nsIMemoryReporter* aReporter);
+
+extern "C" nsresult UnregisterStrongMemoryReporter(nsIMemoryReporter* aReporter);
+
+extern "C" nsresult UnregisterWeakMemoryReporter(nsIMemoryReporter* aReporter);
+
+
+
+
+
+typedef int64_t (*InfallibleAmountFn)();
+
+
+
+
+nsresult RegisterJSMainRuntimeGCHeapDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterJSMainRuntimeTemporaryPeakDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterJSMainRuntimeCompartmentsSystemDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterJSMainRuntimeCompartmentsUserDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterImagesContentUsedUncompressedDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult UnregisterImagesContentUsedUncompressedDistinguishedAmount();
+nsresult RegisterStorageSQLiteDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult UnregisterStorageSQLiteDistinguishedAmount();
+nsresult RegisterLowMemoryEventsVirtualDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterLowMemoryEventsPhysicalDistinguishedAmount(InfallibleAmountFn aAmountFn);
+nsresult RegisterGhostWindowsDistinguishedAmount(InfallibleAmountFn aAmountFn);
+
+
+
+typedef __attribute__ ((warn_unused_result)) nsresult (*JSSizeOfTabFn)(JSObject* aObj,
+                                               size_t* aJsObjectsSize,
+                                               size_t* aJsStringSize,
+                                               size_t* aJsPrivateSize,
+                                               size_t* aJsOtherSize);
+typedef __attribute__ ((warn_unused_result)) nsresult (*NonJSSizeOfTabFn)(nsPIDOMWindowOuter* aWindow,
+                                                  size_t* aDomSize,
+                                                  size_t* aStyleSize,
+                                                  size_t* aOtherSize);
+nsresult RegisterJSSizeOfTab(JSSizeOfTabFn aSizeOfTabFn);
+nsresult RegisterNonJSSizeOfTab(NonJSSizeOfTabFn aSizeOfTabFn);
+}
+# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
+
+
+
+
+
+
+class nsISupports;
+class ProfilerMarkerPayload;
+# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+extern __thread mozilla::detail::ThreadLocal<PseudoStack*> tlsPseudoStack;
+
+class ProfilerState;
+
+
+
+
+
+extern ProfilerState* gPS;
+# 353 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+static inline void*
+profiler_call_enter(const char* aInfo,
+                    js::ProfileEntry::Category aCategory,
+                    void *aFrameAddress, bool aCopy, uint32_t line,
+                    const char* aDynamicString = nullptr)
+{
+
+
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 361; ::abort(); } while (0); } } while (0);
+
+  PseudoStack* stack = tlsPseudoStack.get();
+  if (!stack) {
+    return stack;
+  }
+  stack->push(aInfo, aCategory, aFrameAddress, aCopy, line, aDynamicString);
+
+
+
+  return stack;
+}
+
+static inline void
+profiler_call_exit(void* aHandle)
+{
+
+
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 379; ::abort(); } while (0); } } while (0);
+
+  if (!aHandle) {
+    return;
+  }
+
+  PseudoStack *stack = (PseudoStack*)aHandle;
+  stack->pop();
+}
+
+
+
+void profiler_add_marker(const char *aMarker,
+                         ProfilerMarkerPayload *aPayload = nullptr);
+
+
+
+__attribute__((visibility("default")))
+void profiler_save_profile_to_file_async(double aSinceTime,
+                                         const char* aFileName);
+
+
+
+void profiler_will_gather_OOP_profile();
+void profiler_gathered_OOP_profile();
+void profiler_OOP_exit_profile(const nsCString& aProfile);
+# 470 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
+namespace mozilla {
+
+class SamplerStackFrameRAII {
+public:
+
+
+  SamplerStackFrameRAII(const char *aInfo,
+    js::ProfileEntry::Category aCategory, uint32_t line
+                                   )
+  {
+    do { } while (0);
+    mHandle = profiler_call_enter(aInfo, aCategory, this, false, line);
+  }
+  ~SamplerStackFrameRAII() {
+    profiler_call_exit(mHandle);
+  }
+private:
+
+  void* mHandle;
+};
+
+class SamplerStackFrameDynamicRAII {
+public:
+  SamplerStackFrameDynamicRAII(const char* aInfo,
+    js::ProfileEntry::Category aCategory, uint32_t aLine,
+    const char* aDynamicString)
+  {
+    mHandle = profiler_call_enter(aInfo, aCategory, this, true, aLine,
+                                  aDynamicString);
+  }
+
+  ~SamplerStackFrameDynamicRAII() {
+    profiler_call_exit(mHandle);
+  }
+
+private:
+  void* mHandle;
+};
+
+}
+
+inline PseudoStack*
+profiler_get_pseudo_stack(void)
+{
+
+
+  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 516; ::abort(); } while (0); } } while (0);
+
+  return tlsPseudoStack.get();
+}
+
+void profiler_set_js_context(JSContext* aCx);
+void profiler_clear_js_context();
+
+class GeckoProfilerReporter final : public nsIMemoryReporter
+{
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  GeckoProfilerReporter() {}
+
+  virtual nsresult
+  CollectReports(nsIHandleReportCallback* aHandleReport,
+                 nsISupports* aData, bool aAnonymize) override;
+
+private:
+  ~GeckoProfilerReporter() {}
+};
+
+
+
+namespace mozilla {
+
+class GeckoProfilerInitRAII {
+public:
+  explicit GeckoProfilerInitRAII(void* stackTop) {
+    profiler_init(stackTop);
+  }
+  ~GeckoProfilerInitRAII() {
+    profiler_shutdown();
+  }
+};
+
+class GeckoProfilerThreadSleepRAII {
+public:
+  GeckoProfilerThreadSleepRAII() {
+    profiler_thread_sleep();
+  }
+  ~GeckoProfilerThreadSleepRAII() {
+    profiler_thread_wake();
+  }
+};
+
+
+
+class GeckoProfilerThreadWakeRAII {
+public:
+  GeckoProfilerThreadWakeRAII()
+    : mIssuedWake(profiler_thread_is_sleeping())
+  {
+    if (mIssuedWake) {
+      profiler_thread_wake();
+    }
+  }
+  ~GeckoProfilerThreadWakeRAII() {
+    if (mIssuedWake) {
+      do { } while (0);
+      profiler_thread_sleep();
+    }
+  }
+private:
+  bool mIssuedWake;
+};
+
+class GeckoProfilerTracingRAII {
+public:
+  GeckoProfilerTracingRAII(const char* aCategory, const char* aInfo,
+                           UniqueProfilerBacktrace aBacktrace
+                                                          )
+    : mCategory(aCategory)
+    , mInfo(aInfo)
+  {
+    do { } while (0);
+    profiler_tracing(mCategory, mInfo, Move(aBacktrace), TRACING_INTERVAL_START);
+  }
+
+  GeckoProfilerTracingRAII(const char* aCategory, const char* aInfo
+                                                          )
+    : mCategory(aCategory)
+    , mInfo(aInfo)
+  {
+    do { } while (0);
+    profiler_tracing(mCategory, mInfo, TRACING_INTERVAL_START);
+  }
+
+  ~GeckoProfilerTracingRAII() {
+    profiler_tracing(mCategory, mInfo, TRACING_INTERVAL_END);
+  }
+
+protected:
+
+  const char* mCategory;
+  const char* mInfo;
+};
+
+
+
+class AutoProfilerRegister final
+{
+public:
+  explicit AutoProfilerRegister(const char* aName)
+  {
+    profiler_register_thread(aName, this);
+  }
+  ~AutoProfilerRegister()
+  {
+    profiler_unregister_thread();
+  }
+private:
+  AutoProfilerRegister(const AutoProfilerRegister&) = delete;
+  AutoProfilerRegister& operator=(const AutoProfilerRegister&) = delete;
+};
+
+}
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h" 2
+
+
+
+
+
+class nsIScriptContext;
+class nsIScriptGlobalObject;
+
+namespace mozilla {
+namespace dom {
+class AutoJSAPI;
+class Element;
+}
+}
+
+class nsJSUtils
+{
+public:
+  static bool GetCallingLocation(JSContext* aContext, nsACString& aFilename,
+                                 uint32_t* aLineno = nullptr,
+                                 uint32_t* aColumn = nullptr);
+  static bool GetCallingLocation(JSContext* aContext, nsAString& aFilename,
+                                 uint32_t* aLineno = nullptr,
+                                 uint32_t* aColumn = nullptr);
+
+  static nsIScriptGlobalObject *GetStaticScriptGlobal(JSObject* aObj);
+
+  static nsIScriptContext *GetStaticScriptContext(JSObject* aObj);
+# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
+  static uint64_t GetCurrentlyRunningCodeInnerWindowID(JSContext *aContext);
+
+  static nsresult CompileFunction(mozilla::dom::AutoJSAPI& jsapi,
+                                  JS::AutoObjectVector& aScopeChain,
+                                  JS::CompileOptions& aOptions,
+                                  const nsACString& aName,
+                                  uint32_t aArgCount,
+                                  const char** aArgArray,
+                                  const nsAString& aBody,
+                                  JSObject** aFunctionObject);
+
+
+
+  class ExecutionContext {
+
+
+    mozilla::SamplerStackFrameRAII mSamplerRAII;
+
+
+    JSContext* mCx;
+
+
+    JSAutoCompartment mCompartment;
+
+
+    JS::Rooted<JS::Value> mRetValue;
+
+
+    JS::AutoObjectVector mScopeChain;
+
+
+
+    nsresult mRv;
+
+
+
+    bool mSkip;
+
+
+    bool mCoerceToString;
+# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
+   public:
+
+
+
+
+    ExecutionContext(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
+
+    ExecutionContext(const ExecutionContext&) = delete;
+    ExecutionContext(ExecutionContext&&) = delete;
+
+    ~ExecutionContext() {
+
+      do { } while (0);
+    }
+
+
+
+    ExecutionContext& SetCoerceToString(bool aCoerceToString) {
+      mCoerceToString = aCoerceToString;
+      return *this;
+    }
+
+
+    void SetScopeChain(const JS::AutoObjectVector& aScopeChain);
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
+    __attribute__ ((warn_unused_result)) nsresult
+    ExtractReturnValue(JS::MutableHandle<JS::Value> aRetValue);
+
+
+
+
+
+
+    __attribute__ ((warn_unused_result)) nsresult SyncAndExec(void **aOffThreadToken,
+                                      JS::MutableHandle<JSScript*> aScript);
+
+
+    nsresult CompileAndExec(JS::CompileOptions& aCompileOptions,
+                            JS::SourceBufferHolder& aSrcBuf);
+
+
+    nsresult CompileAndExec(JS::CompileOptions& aCompileOptions,
+                            const nsAString& aScript);
+  };
+
+  static nsresult CompileModule(JSContext* aCx,
+                                JS::SourceBufferHolder& aSrcBuf,
+                                JS::Handle<JSObject*> aEvaluationGlobal,
+                                JS::CompileOptions &aCompileOptions,
+                                JS::MutableHandle<JSObject*> aModule);
+
+  static nsresult ModuleDeclarationInstantiation(JSContext* aCx,
+                                                 JS::Handle<JSObject*> aModule);
+
+  static nsresult ModuleEvaluation(JSContext* aCx,
+                                   JS::Handle<JSObject*> aModule);
+
+
+
+  static bool GetScopeChainForElement(JSContext* aCx,
+                                      mozilla::dom::Element* aElement,
+                                      JS::AutoObjectVector& aScopeChain);
+
+  static void ResetTimeZone();
+};
+
+template<typename T>
+inline bool
+AssignJSString(JSContext *cx, T &dest, JSString *s)
+{
+  size_t len = js::GetStringLength(s);
+  static_assert(js::MaxStringLength < (1 << 28),
+                "Shouldn't overflow here or in SetCapacity");
+  if ((__builtin_expect(!!(!dest.SetLength(len, mozilla::fallible)), 0))) {
+    JS_ReportOutOfMemory(cx);
+    return false;
+  }
+  return js::CopyStringChars(cx, dest.BeginWriting(), s, len);
+}
+
+inline void
+AssignJSFlatString(nsAString &dest, JSFlatString *s)
+{
+  size_t len = js::GetFlatStringLength(s);
+  static_assert(js::MaxStringLength < (1 << 28),
+                "Shouldn't overflow here or in SetCapacity");
+  dest.SetLength(len);
+  js::CopyFlatStringChars(dest.BeginWriting(), s, len);
+}
+
+class nsAutoJSString : public nsAutoString
+{
+public:
+
+
+
+
+
+  nsAutoJSString() {}
+
+  bool init(JSContext* aContext, JSString* str)
+  {
+    return AssignJSString(aContext, *this, str);
+  }
+
+  bool init(JSContext* aContext, const JS::Value &v)
+  {
+    if (v.isString()) {
+      return init(aContext, v.toString());
+    }
+
+
+    JS::Rooted<JSString*> str(aContext);
+    if (v.isObject()) {
+      str = JS_NewStringCopyZ(aContext, "[Object]");
+    } else {
+      JS::Rooted<JS::Value> rootedVal(aContext, v);
+      str = JS::ToString(aContext, rootedVal);
+    }
+
+    return str && init(aContext, str);
+  }
+
+  bool init(JSContext* aContext, jsid id)
+  {
+    JS::Rooted<JS::Value> v(aContext);
+    return JS_IdToValue(aContext, id, &v) && init(aContext, v);
+  }
+
+  bool init(const JS::Value &v);
+
+  ~nsAutoJSString() {}
+};
+# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h"
+class nsIXPCScriptable;
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h"
+class nsIClassInfo : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetInterfaces(uint32_t *count, nsIID ***array) = 0;
+
+
+  virtual nsresult GetScriptableHelper(nsIXPCScriptable * *_retval) = 0;
+
+
+  virtual nsresult GetContractID(char * *aContractID) = 0;
+
+
+  virtual nsresult GetClassDescription(char * *aClassDescription) = 0;
+
+
+  virtual nsresult GetClassID(nsCID **aClassID) = 0;
+
+  enum {
+    SINGLETON = 1U,
+    THREADSAFE = 2U,
+    MAIN_THREAD_ONLY = 4U,
+    DOM_OBJECT = 8U,
+    PLUGIN_OBJECT = 16U,
+    SINGLETON_CLASSINFO = 32U,
+    CONTENT_NODE = 64U,
+    RESERVED = 2147483648U
+  };
+
+
+  virtual nsresult GetFlags(uint32_t *aFlags) = 0;
+
+
+  virtual nsresult GetClassIDNoAlloc(nsCID *aClassIDNoAlloc) = 0;
+
+};
+
+  template<typename T> struct nsIClassInfo::COMTypeInfo<nsIClassInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIClassInfo::COMTypeInfo<nsIClassInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa60569d7, 0xd401, 0x4677, { 0xba, 0x63, 0x2a, 0xa5, 0x97, 0x1a, 0xf2, 0x5d }};
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h" 1
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
+struct JSFreeOp;
+namespace js {
+struct Class;
+}
+class nsIXPConnectWrappedNative;
+# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
+class nsIXPCScriptable : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetClassName(char * *aClassName) = 0;
+
+
+  virtual uint32_t GetScriptableFlags(void) = 0;
+
+
+  virtual const js::Class * GetClass(void) = 0;
+
+
+  virtual const JSClass * GetJSClass(void) = 0;
+
+
+  virtual nsresult PreCreate(nsISupports *nativeObj, JSContext *cx, JSObject *globalObj, JSObject **parentObj) = 0;
+
+
+  virtual nsresult GetProperty(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, JS::Value *vp, bool *_retval) = 0;
+
+
+  virtual nsresult SetProperty(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, JS::Value *vp, bool *_retval) = 0;
+
+
+  virtual nsresult Enumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, bool *_retval) = 0;
+
+
+  virtual nsresult NewEnumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, JS::AutoIdVector & properties, bool *_retval) = 0;
+
+
+  virtual nsresult Resolve(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, bool *resolvedp, bool *_retval) = 0;
+
+
+  virtual nsresult Finalize(nsIXPConnectWrappedNative *wrapper, JSFreeOp *fop, JSObject *obj) = 0;
+
+
+  virtual nsresult Call(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, const JS::CallArgs & args, bool *_retval) = 0;
+
+
+  virtual nsresult Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, const JS::CallArgs & args, bool *_retval) = 0;
+
+
+  virtual nsresult HasInstance(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, JS::HandleValue val, bool *bp, bool *_retval) = 0;
+
+
+  virtual nsresult PostCreatePrototype(JSContext *cx, JSObject *proto) = 0;
+
+
+
+
+
+    bool WantPreCreate() { return 0 != (GetScriptableFlags() & (1 << 0)); }
+    bool WantGetProperty() { return 0 != (GetScriptableFlags() & (1 << 1)); }
+    bool WantSetProperty() { return 0 != (GetScriptableFlags() & (1 << 2)); }
+    bool WantEnumerate() { return 0 != (GetScriptableFlags() & (1 << 3)); }
+    bool WantNewEnumerate() { return 0 != (GetScriptableFlags() & (1 << 4)); }
+    bool WantResolve() { return 0 != (GetScriptableFlags() & (1 << 5)); }
+    bool WantFinalize() { return 0 != (GetScriptableFlags() & (1 << 6)); }
+    bool WantCall() { return 0 != (GetScriptableFlags() & (1 << 7)); }
+    bool WantConstruct() { return 0 != (GetScriptableFlags() & (1 << 8)); }
+    bool WantHasInstance() { return 0 != (GetScriptableFlags() & (1 << 9)); }
+    bool UseJSStubForAddProperty() { return 0 != (GetScriptableFlags() & (1 << 10)); }
+    bool UseJSStubForDelProperty() { return 0 != (GetScriptableFlags() & (1 << 11)); }
+    bool UseJSStubForSetProperty() { return 0 != (GetScriptableFlags() & (1 << 12)); }
+    bool DontEnumQueryInterface() { return 0 != (GetScriptableFlags() & (1 << 13)); }
+    bool DontAskInstanceForScriptable() { return 0 != (GetScriptableFlags() & (1 << 14)); }
+    bool ClassInfoInterfacesOnly() { return 0 != (GetScriptableFlags() & (1 << 15)); }
+    bool AllowPropModsDuringResolve() { return 0 != (GetScriptableFlags() & (1 << 16)); }
+    bool AllowPropModsToPrototype() { return 0 != (GetScriptableFlags() & (1 << 17)); }
+    bool IsGlobalObject() { return 0 != (GetScriptableFlags() & (1 << 18)); }
+    bool DontReflectInterfaceNames() { return 0 != (GetScriptableFlags() & (1 << 19)); }
+
+};
+
+  template<typename T> struct nsIXPCScriptable::COMTypeInfo<nsIXPCScriptable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCScriptable::COMTypeInfo<nsIXPCScriptable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x19b70b26, 0x7c3f, 0x437f, { 0xa0, 0x4a, 0x2a, 0x8f, 0x9e, 0x28, 0xb6, 0x17 }};
+# 345 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
+class nsXPCClassInfo : public nsIClassInfo,
+                                    public nsIXPCScriptable
+{
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+  virtual MozExternalRefCountType AddRef() override = 0;
+  virtual MozExternalRefCountType Release() override = 0;
+  virtual void PreserveWrapper(nsISupports *aNative) = 0;
+};
+template<typename T> struct nsXPCClassInfo::COMTypeInfo<nsXPCClassInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsXPCClassInfo::COMTypeInfo<nsXPCClassInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x43b67f01, 0xd4ce, 0x4b82, { 0xb3, 0xf8, 0xeb, 0xf2, 0x13, 0x60, 0xfb, 0x7e } };
+inline
+nsresult
+CallQueryInterface(nsISupports* aSourcePtr,
+                   RefPtrGetterAddRefs<nsXPCClassInfo> aDestPtr)
+{
+  return CallQueryInterface(aSourcePtr,
+                            static_cast<nsXPCClassInfo**>(aDestPtr));
+}
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 2
+
+
+class xpcObjectHelper
+{
+public:
+    explicit xpcObjectHelper(nsISupports* aObject, nsWrapperCache* aCache = nullptr)
+      : mCanonical(nullptr)
+      , mObject(aObject)
+      , mCache(aCache)
+    {
+        if (!mCache) {
+            if (aObject)
+                CallQueryInterface(aObject, &mCache);
+            else
+                mCache = nullptr;
+        }
+    }
+
+    nsISupports* Object()
+    {
+        return mObject;
+    }
+
+    nsISupports* GetCanonical()
+    {
+        if (!mCanonical) {
+            mCanonicalStrong = do_QueryInterface(mObject);
+            mCanonical = mCanonicalStrong;
+        }
+        return mCanonical;
+    }
+
+    already_AddRefed<nsISupports> forgetCanonical()
+    {
+        do { } while (0);
+
+        if (!mCanonicalStrong)
+            mCanonicalStrong = mCanonical;
+        mCanonical = nullptr;
+        return mCanonicalStrong.forget();
+    }
+
+    nsIClassInfo* GetClassInfo()
+    {
+        if (mXPCClassInfo)
+          return mXPCClassInfo;
+        if (!mClassInfo)
+            mClassInfo = do_QueryInterface(mObject);
+        return mClassInfo;
+    }
+    nsXPCClassInfo* GetXPCClassInfo()
+    {
+        if (!mXPCClassInfo) {
+            CallQueryInterface(mObject, getter_AddRefs(mXPCClassInfo));
+        }
+        return mXPCClassInfo;
+    }
+
+    already_AddRefed<nsXPCClassInfo> forgetXPCClassInfo()
+    {
+        GetXPCClassInfo();
+
+        return mXPCClassInfo.forget();
+    }
+
+
+    uint32_t GetScriptableFlags()
+    {
+
+        nsCOMPtr<nsIXPCScriptable> sinfo = GetXPCClassInfo();
+
+
+        if (!sinfo)
+            sinfo = do_QueryInterface(GetCanonical());
+
+
+        do { } while (0);
+
+
+        return sinfo->GetScriptableFlags();
+    }
+
+    nsWrapperCache* GetWrapperCache()
+    {
+        return mCache;
+    }
+
+protected:
+    xpcObjectHelper(nsISupports* aObject, nsISupports* aCanonical,
+                    nsWrapperCache* aCache)
+      : mCanonical(aCanonical)
+      , mObject(aObject)
+      , mCache(aCache)
+    {
+        if (!mCache && aObject)
+            CallQueryInterface(aObject, &mCache);
+    }
+
+    nsCOMPtr<nsISupports> mCanonicalStrong;
+    nsISupports* mCanonical;
+
+
+
+private:
+    xpcObjectHelper(xpcObjectHelper& aOther) = delete;
+
+    nsISupports* mObject;
+
+
+    nsWrapperCache* mCache;
+    nsCOMPtr<nsIClassInfo> mClassInfo;
+    RefPtr<nsXPCClassInfo> mXPCClassInfo;
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h" 2
+
+
+
+
+
+class qsObjectHelper : public xpcObjectHelper
+{
+public:
+    template <class T>
+    inline
+    qsObjectHelper(T* aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject), ToCanonicalSupports(aObject),
+                          aCache)
+    {}
+
+    template <class T>
+    inline
+    qsObjectHelper(nsCOMPtr<T>& aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject.get()),
+                          ToCanonicalSupports(aObject.get()), aCache)
+    {
+        if (mCanonical) {
+
+            mCanonicalStrong = dont_AddRef(mCanonical);
+            aObject.forget();
+        }
+    }
+
+    template <class T>
+    inline
+    qsObjectHelper(RefPtr<T>& aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject.get()),
+                          ToCanonicalSupports(aObject.get()), aCache)
+    {
+        if (mCanonical) {
+
+            mCanonicalStrong = dont_AddRef(mCanonical);
+            aObject.forget();
+        }
+    }
+};
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCacheInlines.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCacheInlines.h"
+inline JSObject*
+nsWrapperCache::GetWrapper() const
+{
+    JSObject* obj = GetWrapperPreserveColor();
+    if (obj) {
+      JS::ExposeObjectToActiveJS(obj);
+    }
+    return obj;
+}
+
+inline bool
+nsWrapperCache::HasKnownLiveWrapper() const
+{
+
+
+
+
+
+  JSObject* o = GetWrapperPreserveColor();
+  return o && !JS::ObjectIsMarkedGray(o);
+}
+
+static void
+SearchGray(JS::GCCellPtr aGCThing, const char* aName, void* aClosure)
+{
+  bool* hasGrayObjects = static_cast<bool*>(aClosure);
+  if (!*hasGrayObjects && aGCThing && JS::GCThingIsMarkedGray(aGCThing)) {
+    *hasGrayObjects = true;
+  }
+}
+
+inline bool
+nsWrapperCache::HasNothingToTrace(nsISupports* aThis)
+{
+  nsXPCOMCycleCollectionParticipant* participant = nullptr;
+  CallQueryInterface(aThis, &participant);
+  bool hasGrayObjects = false;
+  participant->Trace(aThis, TraceCallbackFunc(SearchGray), &hasGrayObjects);
+  return !hasGrayObjects;
+}
+
+inline bool
+nsWrapperCache::HasKnownLiveWrapperAndDoesNotNeedTracing(nsISupports* aThis)
+{
+  return HasKnownLiveWrapper() && HasNothingToTrace(aThis);
+}
+
+inline void
+nsWrapperCache::MarkWrapperLive()
+{
+
+
+  GetWrapper();
+}
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
+
+class nsGenericHTMLElement;
+class nsIJSID;
+
+namespace mozilla {
+
+enum UseCounter : int16_t;
+
+namespace dom {
+template<typename KeyType, typename ValueType> class Record;
+
+nsresult
+UnwrapArgImpl(JSContext* cx, JS::Handle<JSObject*> src, const nsIID& iid,
+              void** ppArg);
+
+nsresult
+UnwrapWindowProxyImpl(JSContext* cx, JS::Handle<JSObject*> src,
+                      nsPIDOMWindowOuter** ppArg);
+
+
+template <class Interface>
+inline nsresult
+UnwrapArg(JSContext* cx, JS::Handle<JSObject*> src, Interface** ppArg)
+{
+  return UnwrapArgImpl(cx, src, (Interface::template COMTypeInfo<Interface, void>::kIID),
+                       reinterpret_cast<void**>(ppArg));
+}
+
+template <>
+inline nsresult
+UnwrapArg<nsPIDOMWindowOuter>(JSContext* cx, JS::Handle<JSObject*> src,
+                              nsPIDOMWindowOuter** ppArg)
+{
+  return UnwrapWindowProxyImpl(cx, src, ppArg);
+}
+
+bool
+ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
+                 bool aSecurityError, const char* aInterfaceName);
+
+bool
+ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
+                 bool aSecurityError, prototypes::ID aProtoId);
+
+
+inline bool
+IsDOMClass(const JSClass* clasp)
+{
+  return clasp->flags & (1<<4);
+}
+
+inline bool
+IsDOMClass(const js::Class* clasp)
+{
+  return IsDOMClass(Jsvalify(clasp));
+}
+
+
+inline bool
+IsNonProxyDOMClass(const js::Class* clasp)
+{
+  return IsDOMClass(clasp) && !clasp->isProxy();
+}
+
+inline bool
+IsNonProxyDOMClass(const JSClass* clasp)
+{
+  return IsNonProxyDOMClass(js::Valueify(clasp));
+}
+
+
+
+inline bool
+IsDOMIfaceAndProtoClass(const JSClass* clasp)
+{
+  return clasp->flags & (1<<((8 + 8)+6));
+}
+
+inline bool
+IsDOMIfaceAndProtoClass(const js::Class* clasp)
+{
+  return IsDOMIfaceAndProtoClass(Jsvalify(clasp));
+}
+
+static_assert(0 == 0,
+              "DOM_OBJECT_SLOT doesn't match the proxy private slot.  "
+              "Expect bad things");
+template <class T>
+inline T*
+UnwrapDOMObject(JSObject* obj)
+{
+  do { } while (0);
+
+
+  JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, 0);
+  return static_cast<T*>(val.toPrivate());
+}
+
+template <class T>
+inline T*
+UnwrapPossiblyNotInitializedDOMObject(JSObject* obj)
+{
+
+
+
+
+  do { } while (0);
+
+
+  JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, 0);
+  if (val.isUndefined()) {
+    return nullptr;
+  }
+  return static_cast<T*>(val.toPrivate());
+}
+
+inline const DOMJSClass*
+GetDOMClass(const js::Class* clasp)
+{
+  return IsDOMClass(clasp) ? DOMJSClass::FromJSClass(clasp) : nullptr;
+}
+
+inline const DOMJSClass*
+GetDOMClass(JSObject* obj)
+{
+  return GetDOMClass(js::GetObjectClass(obj));
+}
+
+inline nsISupports*
+UnwrapDOMObjectToISupports(JSObject* aObject)
+{
+  const DOMJSClass* clasp = GetDOMClass(aObject);
+  if (!clasp || !clasp->mDOMObjectIsISupports) {
+    return nullptr;
+  }
+
+  return UnwrapPossiblyNotInitializedDOMObject<nsISupports>(aObject);
+}
+
+inline bool
+IsDOMObject(JSObject* obj)
+{
+  return IsDOMClass(js::GetObjectClass(obj));
+}
+# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template <class T, typename U>
+__attribute__((always_inline)) inline nsresult
+UnwrapObject(JSObject* obj, U& value, prototypes::ID protoID,
+             uint32_t protoDepth)
+{
+
+  const DOMJSClass* domClass = GetDOMClass(obj);
+  if (!domClass) {
+
+    if (!js::IsWrapper(obj)) {
+
+      return NS_ERROR_XPC_BAD_CONVERT_JS;
+    }
+
+    obj = js::CheckedUnwrap(obj, false);
+    if (!obj) {
+      return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
+    }
+    do { } while (0);
+    domClass = GetDOMClass(obj);
+    if (!domClass) {
+
+      return NS_ERROR_XPC_BAD_CONVERT_JS;
+    }
+  }
+
+
+
+
+  if (domClass->mInterfaceChain[protoDepth] == protoID) {
+    value = UnwrapDOMObject<T>(obj);
+    return NS_OK;
+  }
+
+
+  return NS_ERROR_XPC_BAD_CONVERT_JS;
+}
+
+template <prototypes::ID PrototypeID, class T, typename U>
+__attribute__((always_inline)) inline nsresult
+UnwrapObject(JSObject* obj, U& value)
+{
+  return UnwrapObject<T>(obj, value, PrototypeID,
+                         PrototypeTraits<PrototypeID>::Depth);
+}
+
+__attribute__((always_inline)) inline bool
+IsConvertibleToDictionary(JS::Handle<JS::Value> val)
+{
+  return val.isNullOrUndefined() || val.isObject();
+}
+
+
+
+
+
+
+static_assert((size_t)constructors::id::_ID_Start ==
+              (size_t)prototypes::id::_ID_Count &&
+              (size_t)namedpropertiesobjects::id::_ID_Start ==
+              (size_t)constructors::id::_ID_Count,
+              "Overlapping or discontiguous indexes.");
+const size_t kProtoAndIfaceCacheCount = namedpropertiesobjects::id::_ID_Count;
+
+class ProtoAndIfaceCache
+{
+
+
+
+
+
+
+  class ArrayCache : public Array<JS::Heap<JSObject*>, kProtoAndIfaceCacheCount>
+  {
+  public:
+    JSObject* EntrySlotIfExists(size_t i) {
+      return (*this)[i];
+    }
+
+    JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+      return (*this)[i];
+    }
+
+    JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+      return (*this)[i];
+    }
+
+    void Trace(JSTracer* aTracer) {
+      for (size_t i = 0; i < ArrayLength(*this); ++i) {
+        JS::TraceEdge(aTracer, &(*this)[i], "protoAndIfaceCache[i]");
+      }
+    }
+
+    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+      return aMallocSizeOf(this);
+    }
+  };
+
+  class PageTableCache
+  {
+  public:
+    PageTableCache() {
+      memset(&mPages, 0, sizeof(mPages));
+    }
+
+    ~PageTableCache() {
+      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+        delete mPages[i];
+      }
+    }
+
+    JSObject* EntrySlotIfExists(size_t i) {
+      do { } while (0);
+      size_t pageIndex = i / kPageSize;
+      size_t leafIndex = i % kPageSize;
+      Page* p = mPages[pageIndex];
+      if (!p) {
+        return nullptr;
+      }
+      return (*p)[leafIndex];
+    }
+
+    JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+      do { } while (0);
+      size_t pageIndex = i / kPageSize;
+      size_t leafIndex = i % kPageSize;
+      Page* p = mPages[pageIndex];
+      if (!p) {
+        p = new Page;
+        mPages[pageIndex] = p;
+      }
+      return (*p)[leafIndex];
+    }
+
+    JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+      do { } while (0);
+      size_t pageIndex = i / kPageSize;
+      size_t leafIndex = i % kPageSize;
+      Page* p = mPages[pageIndex];
+      do { } while (0);
+      return (*p)[leafIndex];
+    }
+
+    void Trace(JSTracer* trc) {
+      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+        Page* p = mPages[i];
+        if (p) {
+          for (size_t j = 0; j < ArrayLength(*p); ++j) {
+            JS::TraceEdge(trc, &(*p)[j], "protoAndIfaceCache[i]");
+          }
+        }
+      }
+    }
+
+    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+      size_t n = aMallocSizeOf(this);
+      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
+        n += aMallocSizeOf(mPages[i]);
+      }
+      return n;
+    }
+
+  private:
+    static const size_t kPageSize = 16;
+    typedef Array<JS::Heap<JSObject*>, kPageSize> Page;
+    static const size_t kNPages = kProtoAndIfaceCacheCount / kPageSize +
+      size_t(bool(kProtoAndIfaceCacheCount % kPageSize));
+    Array<Page*, kNPages> mPages;
+  };
+
+public:
+  enum Kind {
+    WindowLike,
+    NonWindowLike
+  };
+
+  explicit ProtoAndIfaceCache(Kind aKind) : mKind(aKind) {
+                                      ;
+    if (aKind == WindowLike) {
+      mArrayCache = new ArrayCache();
+    } else {
+      mPageTableCache = new PageTableCache();
+    }
+  }
+
+  ~ProtoAndIfaceCache() {
+    if (mKind == WindowLike) {
+      delete mArrayCache;
+    } else {
+      delete mPageTableCache;
+    }
+                                      ;
+  }
+# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+  JSObject* EntrySlotIfExists(size_t i) {
+    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotIfExists (i); } else { return mPageTableCache->EntrySlotIfExists (i); } } while(0);
+  }
+
+
+
+  JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
+    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotOrCreate (i); } else { return mPageTableCache->EntrySlotOrCreate (i); } } while(0);
+  }
+
+
+
+
+  JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
+    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotMustExist (i); } else { return mPageTableCache->EntrySlotMustExist (i); } } while(0);
+  }
+
+  void Trace(JSTracer *aTracer) {
+    do { if (mKind == WindowLike) { return mArrayCache->Trace (aTracer); } else { return mPageTableCache->Trace (aTracer); } } while(0);
+  }
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+    size_t n = aMallocSizeOf(this);
+    n += (mKind == WindowLike
+          ? mArrayCache->SizeOfIncludingThis(aMallocSizeOf)
+          : mPageTableCache->SizeOfIncludingThis(aMallocSizeOf));
+    return n;
+  }
+
+
+private:
+  union {
+    ArrayCache *mArrayCache;
+    PageTableCache *mPageTableCache;
+  };
+  Kind mKind;
+};
+
+inline void
+AllocateProtoAndIfaceCache(JSObject* obj, ProtoAndIfaceCache::Kind aKind)
+{
+  do { } while (0);
+  do { } while (0);
+
+  ProtoAndIfaceCache* protoAndIfaceCache = new ProtoAndIfaceCache(aKind);
+
+  js::SetReservedSlot(obj, (5 + JSProto_LIMIT * 2 + 46),
+                      JS::PrivateValue(protoAndIfaceCache));
+}
+# 469 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+inline void
+TraceProtoAndIfaceCache(JSTracer* trc, JSObject* obj)
+{
+  do { } while (0);
+# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+  if (!DOMGlobalHasProtoAndIFaceCache(obj))
+    return;
+  ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
+  protoAndIfaceCache->Trace(trc);
+}
+
+inline void
+DestroyProtoAndIfaceCache(JSObject* obj)
+{
+  do { } while (0);
+
+  if (!DOMGlobalHasProtoAndIFaceCache(obj)) {
+    return;
+  }
+
+  ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
+
+  delete protoAndIfaceCache;
+}
+
+
+
+
+bool
+DefineConstants(JSContext* cx, JS::Handle<JSObject*> obj,
+                const ConstantSpec* cs);
+
+struct JSNativeHolder
+{
+  JSNative mNative;
+  const NativePropertyHooks* mPropertyHooks;
+};
+
+struct NamedConstructor
+{
+  const char* mName;
+  const JSNativeHolder mHolder;
+  unsigned mNargs;
+};
+# 575 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+void
+CreateInterfaceObjects(JSContext* cx, JS::Handle<JSObject*> global,
+                       JS::Handle<JSObject*> protoProto,
+                       const js::Class* protoClass, JS::Heap<JSObject*>* protoCache,
+                       JS::Handle<JSObject*> interfaceProto,
+                       const js::Class* constructorClass,
+                       unsigned ctorNargs, const NamedConstructor* namedConstructors,
+                       JS::Heap<JSObject*>* constructorCache,
+                       const NativeProperties* regularProperties,
+                       const NativeProperties* chromeOnlyProperties,
+                       const char* name, bool defineOnGlobal,
+                       const char* const* unscopableNames,
+                       bool isGlobal);
+# 602 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+DefineProperties(JSContext* cx, JS::Handle<JSObject*> obj,
+                 const NativeProperties* properties,
+                 const NativeProperties* chromeOnlyProperties);
+
+
+
+
+bool
+DefineUnforgeableMethods(JSContext* cx, JS::Handle<JSObject*> obj,
+                         const Prefable<const JSFunctionSpec>* props);
+
+
+
+
+bool
+DefineUnforgeableAttributes(JSContext* cx, JS::Handle<JSObject*> obj,
+                            const Prefable<const JSPropertySpec>* props);
+# 643 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template<class T>
+struct NativeHasMember
+{
+  private: typedef char yes[1]; typedef char no[2];
+
+  private: template<typename V> static yes& CheckGetParentObject(char (*)[sizeof(&V::GetParentObject) + 1]); template<typename V> static no& CheckGetParentObject(...); public: static bool const GetParentObject = sizeof(CheckGetParentObject<T>(nullptr)) == sizeof(yes);
+  private: template<typename V> static yes& CheckWrapObject(char (*)[sizeof(&V::WrapObject) + 1]); template<typename V> static no& CheckWrapObject(...); public: static bool const WrapObject = sizeof(CheckWrapObject<T>(nullptr)) == sizeof(yes);
+};
+
+template<class T>
+struct IsSmartPtr
+{
+  private: typedef char yes[1]; typedef char no[2];
+
+  private: template<typename V> static yes& Checkget(char (*)[sizeof(&V::get) + 1]); template<typename V> static no& Checkget(...); public: static bool const value = sizeof(Checkget<T>(nullptr)) == sizeof(yes);
+};
+
+template<class T>
+struct IsRefcounted
+{
+  private: typedef char yes[1]; typedef char no[2];
+
+  private: template<typename V> static yes& CheckAddRef(char (*)[sizeof(&V::AddRef) + 1]); template<typename V> static no& CheckAddRef(...); public: static bool const HasAddref = sizeof(CheckAddRef<T>(nullptr)) == sizeof(yes);
+  private: template<typename V> static yes& CheckRelease(char (*)[sizeof(&V::Release) + 1]); template<typename V> static no& CheckRelease(...); public: static bool const HasRelease = sizeof(CheckRelease<T>(nullptr)) == sizeof(yes);
+
+public:
+  static bool const value = HasAddref && HasRelease;
+
+private:
+
+
+
+  static_assert(!IsBaseOf<nsISupports, T>::value || IsRefcounted::value,
+                "Classes derived from nsISupports are refcounted!");
+
+};
+# 707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+__attribute__((always_inline)) inline bool
+CouldBeDOMBinding(void*)
+{
+  return true;
+}
+
+__attribute__((always_inline)) inline bool
+CouldBeDOMBinding(nsWrapperCache* aCache)
+{
+  return aCache->IsDOMBinding();
+}
+
+inline bool
+TryToOuterize(JS::MutableHandle<JS::Value> rval)
+{
+  if (js::IsWindow(&rval.toObject())) {
+    JSObject* obj = js::ToWindowProxyIfWindow(&rval.toObject());
+    do { } while (0);
+    rval.set(JS::ObjectValue(*obj));
+  }
+
+  return true;
+}
+
+
+
+__attribute__((always_inline)) inline
+bool
+MaybeWrapStringValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  JSString* str = rval.toString();
+  if (JS::GetStringZone(str) != js::GetContextZone(cx)) {
+    return JS_WrapValue(cx, rval);
+  }
+  return true;
+}
+
+
+
+__attribute__((always_inline)) inline
+bool
+MaybeWrapObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+
+
+  JSObject* obj = &rval.toObject();
+  if (js::GetObjectCompartment(obj) != js::GetContextCompartment(cx)) {
+    return JS_WrapValue(cx, rval);
+  }
+
+
+
+  if (IsDOMObject(obj)) {
+    return TryToOuterize(rval);
+  }
+
+
+
+  return true;
+}
+
+
+__attribute__((always_inline)) inline
+bool
+MaybeWrapObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  if (rval.isNull()) {
+    return true;
+  }
+  return MaybeWrapObjectValue(cx, rval);
+}
+
+
+__attribute__((always_inline)) inline
+bool
+MaybeWrapNonDOMObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  do { } while (0);
+  do { } while (0);
+
+
+  JSObject* obj = &rval.toObject();
+  if (js::GetObjectCompartment(obj) == js::GetContextCompartment(cx)) {
+    return true;
+  }
+  return JS_WrapValue(cx, rval);
+}
+
+
+__attribute__((always_inline)) inline
+bool
+MaybeWrapNonDOMObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  if (rval.isNull()) {
+    return true;
+  }
+  return MaybeWrapNonDOMObjectValue(cx, rval);
+}
+
+
+
+
+__attribute__((always_inline)) inline bool
+MaybeWrapValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
+{
+  if (rval.isGCThing()) {
+    if (rval.isString()) {
+      return MaybeWrapStringValue(cx, rval);
+    }
+    if (rval.isObject()) {
+      return MaybeWrapObjectValue(cx, rval);
+    }
+    do { } while (0);
+    JS_MarkCrossZoneId(cx, SYMBOL_TO_JSID(rval.toSymbol()));
+  }
+  return true;
+}
+
+namespace binding_detail {
+enum GetOrCreateReflectorWrapBehavior {
+  eWrapIntoContextCompartment,
+  eDontWrapIntoContextCompartment
+};
+
+template <class T>
+struct TypeNeedsOuterization
+{
+
+
+  static const bool value =
+    IsBaseOf<nsGlobalWindow, T>::value || IsSame<EventTarget, T>::value;
+};
+# 898 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template <class T, GetOrCreateReflectorWrapBehavior wrapBehavior>
+__attribute__((always_inline)) inline bool
+DoGetOrCreateDOMReflector(JSContext* cx, T* value,
+                          JS::Handle<JSObject*> givenProto,
+                          JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  do { } while (0);
+
+  bool couldBeDOMBinding = CouldBeDOMBinding(value);
+  JSObject* obj = value->GetWrapper();
+  if (obj) {
+
+
+
+
+
+
+  } else {
+
+    if (!couldBeDOMBinding) {
+      return false;
+    }
+
+    obj = value->WrapObject(cx, givenProto);
+    if (!obj) {
+
+
+
+      return false;
+    }
+
+
+
+
+
+
+  }
+# 953 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+  rval.set(JS::ObjectValue(*obj));
+
+  bool sameCompartment =
+    js::GetObjectCompartment(obj) == js::GetContextCompartment(cx);
+  if (sameCompartment && couldBeDOMBinding) {
+    return TypeNeedsOuterization<T>::value ? TryToOuterize(rval) : true;
+  }
+
+  if (wrapBehavior == eDontWrapIntoContextCompartment) {
+    if (TypeNeedsOuterization<T>::value) {
+      JSAutoCompartment ac(cx, obj);
+      return TryToOuterize(rval);
+    }
+
+    return true;
+  }
+
+  return JS_WrapValue(cx, rval);
+}
+
+}
+# 984 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template <class T>
+__attribute__((always_inline)) inline bool
+GetOrCreateDOMReflector(JSContext* cx, T* value,
+                        JS::MutableHandle<JS::Value> rval,
+                        JS::Handle<JSObject*> givenProto = nullptr)
+{
+  using namespace binding_detail;
+  return DoGetOrCreateDOMReflector<T, eWrapIntoContextCompartment>(cx, value,
+                                                                   givenProto,
+                                                                   rval);
+}
+
+
+
+template <class T>
+__attribute__((always_inline)) inline bool
+GetOrCreateDOMReflectorNoWrap(JSContext* cx, T* value,
+                              JS::MutableHandle<JS::Value> rval)
+{
+  using namespace binding_detail;
+  return DoGetOrCreateDOMReflector<T, eDontWrapIntoContextCompartment>(cx,
+                                                                       value,
+                                                                       nullptr,
+                                                                       rval);
+}
+
+
+
+
+template <class T>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx,
+                                     JS::Handle<JSObject*> scopeArg,
+                                     T* value,
+                                     JS::MutableHandle<JS::Value> rval,
+                                     JS::Handle<JSObject*> givenProto = nullptr)
+{
+  static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
+  do { } while (0);
+
+  JS::Rooted<JSObject*> obj(cx);
+  {
+
+
+    Maybe<JSAutoCompartment> ac;
+
+
+
+    JS::Rooted<JSObject*> scope(cx, scopeArg);
+    JS::Rooted<JSObject*> proto(cx, givenProto);
+    if (js::IsWrapper(scope)) {
+      scope = js::CheckedUnwrap(scope, false);
+      if (!scope)
+        return false;
+      ac.emplace(cx, scope);
+      if (!JS_WrapObject(cx, &proto)) {
+        return false;
+      }
+    }
+
+    do { } while (0);
+    if (!value->WrapObject(cx, proto, &obj)) {
+      return false;
+    }
+  }
+
+
+
+  rval.set(JS::ObjectValue(*obj));
+  return MaybeWrapObjectValue(cx, rval);
+}
+
+
+
+
+
+template <class T>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx,
+                                     JS::Handle<JSObject*> scopeArg,
+                                     nsAutoPtr<T>& value,
+                                     JS::MutableHandle<JS::Value> rval,
+                                     JS::Handle<JSObject*> givenProto = nullptr)
+{
+  static_assert(!IsRefcounted<T>::value, "Only pass owned classes in here.");
+
+
+  if (!value) {
+    do { AnnotateMozCrashReason("MOZ_CRASH(" "Don't try to wrap null objects" ")"); do { *((volatile int*) __null) = 1072; ::abort(); } while (0); } while (0);
+  }
+
+  JS::Rooted<JSObject*> obj(cx);
+  {
+
+
+    Maybe<JSAutoCompartment> ac;
+
+
+
+    JS::Rooted<JSObject*> scope(cx, scopeArg);
+    JS::Rooted<JSObject*> proto(cx, givenProto);
+    if (js::IsWrapper(scope)) {
+      scope = js::CheckedUnwrap(scope, false);
+      if (!scope)
+        return false;
+      ac.emplace(cx, scope);
+      if (!JS_WrapObject(cx, &proto)) {
+        return false;
+      }
+    }
+
+    do { } while (0);
+    if (!value->WrapObject(cx, proto, &obj)) {
+      return false;
+    }
+
+    value.forget();
+  }
+
+
+
+  rval.set(JS::ObjectValue(*obj));
+  return MaybeWrapObjectValue(cx, rval);
+}
+
+
+template <template <typename> class SmartPtr, typename T,
+          typename U=typename EnableIf<IsRefcounted<T>::value, T>::Type,
+          typename V=typename EnableIf<IsSmartPtr<SmartPtr<T>>::value, T>::Type>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
+                                     const SmartPtr<T>& value,
+                                     JS::MutableHandle<JS::Value> rval,
+                                     JS::Handle<JSObject*> givenProto = nullptr)
+{
+  return WrapNewBindingNonWrapperCachedObject(cx, scope, value.get(), rval,
+                                              givenProto);
+}
+
+
+template <typename T,
+          typename U=typename EnableIf<!IsSmartPtr<T>::value, T>::Type>
+inline bool
+WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
+                                     T& value,
+                                     JS::MutableHandle<JS::Value> rval,
+                                     JS::Handle<JSObject*> givenProto = nullptr)
+{
+  return WrapNewBindingNonWrapperCachedObject(cx, scope, &value, rval,
+                                              givenProto);
+}
+
+
+
+bool
+NativeInterface2JSObjectAndThrowIfFailed(JSContext* aCx,
+                                         JS::Handle<JSObject*> aScope,
+                                         JS::MutableHandle<JS::Value> aRetval,
+                                         xpcObjectHelper& aHelper,
+                                         const nsIID* aIID,
+                                         bool aAllowNativeWrapper);
+
+
+
+
+
+template <class T>
+__attribute__((always_inline)) inline bool
+HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
+                                T* value, JS::MutableHandle<JS::Value> rval)
+{
+  if (JS_IsExceptionPending(cx)) {
+    return false;
+  }
+
+  qsObjectHelper helper(value, GetWrapperCache(value));
+  return NativeInterface2JSObjectAndThrowIfFailed(cx, scope, rval,
+                                                  helper, nullptr, true);
+}
+
+
+
+
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct HandleNewBindingWrappingFailureHelper
+{
+  static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope,
+                          const T& value, JS::MutableHandle<JS::Value> rval)
+  {
+    return HandleNewBindingWrappingFailure(cx, scope, value.get(), rval);
+  }
+};
+
+template <class T>
+struct HandleNewBindingWrappingFailureHelper<T, false>
+{
+  static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
+                          JS::MutableHandle<JS::Value> rval)
+  {
+    return HandleNewBindingWrappingFailure(cx, scope, &value, rval);
+  }
+};
+
+template<class T>
+inline bool
+HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
+                                T& value, JS::MutableHandle<JS::Value> rval)
+{
+  return HandleNewBindingWrappingFailureHelper<T>::Wrap(cx, scope, value, rval);
+}
+
+template<bool Fatal>
+inline bool
+EnumValueNotFound(JSContext* cx, JS::HandleString str, const char* type,
+                  const char* sourceDescription);
+
+template<>
+inline bool
+EnumValueNotFound<false>(JSContext* cx, JS::HandleString str, const char* type,
+                         const char* sourceDescription)
+{
+
+  return true;
+}
+
+template<>
+inline bool
+EnumValueNotFound<true>(JSContext* cx, JS::HandleString str, const char* type,
+                        const char* sourceDescription)
+{
+  JSAutoByteString deflated;
+  if (!deflated.encodeUtf8(cx, str)) {
+    return false;
+  }
+  return ThrowErrorMessage(cx, MSG_INVALID_ENUM_VALUE, sourceDescription,
+                           deflated.ptr(), type);
+}
+
+template<typename CharT>
+inline int
+FindEnumStringIndexImpl(const CharT* chars, size_t length, const EnumEntry* values)
+{
+  int i = 0;
+  for (const EnumEntry* value = values; value->value; ++value, ++i) {
+    if (length != value->length) {
+      continue;
+    }
+
+    bool equal = true;
+    const char* val = value->value;
+    for (size_t j = 0; j != length; ++j) {
+      if (unsigned(val[j]) != unsigned(chars[j])) {
+        equal = false;
+        break;
+      }
+    }
+
+    if (equal) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+template<bool InvalidValueFatal>
+inline bool
+FindEnumStringIndex(JSContext* cx, JS::Handle<JS::Value> v, const EnumEntry* values,
+                    const char* type, const char* sourceDescription, int* index)
+{
+
+  JS::RootedString str(cx, JS::ToString(cx, v));
+  if (!str) {
+    return false;
+  }
+
+  {
+    size_t length;
+    JS::AutoCheckCannotGC nogc;
+    if (js::StringHasLatin1Chars(str)) {
+      const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, str,
+                                                                     &length);
+      if (!chars) {
+        return false;
+      }
+      *index = FindEnumStringIndexImpl(chars, length, values);
+    } else {
+      const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, str,
+                                                                &length);
+      if (!chars) {
+        return false;
+      }
+      *index = FindEnumStringIndexImpl(chars, length, values);
+    }
+    if (*index >= 0) {
+      return true;
+    }
+  }
+
+  return EnumValueNotFound<InvalidValueFatal>(cx, str, type, sourceDescription);
+}
+
+inline nsWrapperCache*
+GetWrapperCache(const ParentObject& aParentObject)
+{
+  return aParentObject.mWrapperCache;
+}
+
+template<class T>
+inline T*
+GetParentPointer(T* aObject)
+{
+  return aObject;
+}
+
+inline nsISupports*
+GetParentPointer(const ParentObject& aObject)
+{
+  return aObject.mObject;
+}
+
+template <typename T>
+inline bool
+GetUseXBLScope(T* aParentObject)
+{
+  return false;
+}
+
+inline bool
+GetUseXBLScope(const ParentObject& aParentObject)
+{
+  return aParentObject.mUseXBLScope;
+}
+
+template<class T>
+inline void
+ClearWrapper(T* p, nsWrapperCache* cache)
+{
+  cache->ClearWrapper();
+}
+
+template<class T>
+inline void
+ClearWrapper(T* p, void*)
+{
+  nsWrapperCache* cache;
+  CallQueryInterface(p, &cache);
+  ClearWrapper(p, cache);
+}
+
+template<class T>
+inline void
+UpdateWrapper(T* p, nsWrapperCache* cache, JSObject* obj, const JSObject* old)
+{
+  JS::AutoAssertGCCallback inCallback(obj);
+  cache->UpdateWrapper(obj, old);
+}
+
+template<class T>
+inline void
+UpdateWrapper(T* p, void*, JSObject* obj, const JSObject* old)
+{
+  JS::AutoAssertGCCallback inCallback(obj);
+  nsWrapperCache* cache;
+  CallQueryInterface(p, &cache);
+  UpdateWrapper(p, cache, obj, old);
+}
+# 1360 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+TryPreserveWrapper(JSObject* obj);
+
+
+bool
+InstanceClassHasProtoAtDepth(const js::Class* clasp,
+                             uint32_t protoID, uint32_t depth);
+
+
+
+bool
+XPCOMObjectToJsval(JSContext* cx, JS::Handle<JSObject*> scope,
+                   xpcObjectHelper& helper, const nsIID* iid,
+                   bool allowNativeWrapper, JS::MutableHandle<JS::Value> rval);
+
+
+bool
+VariantToJsval(JSContext* aCx, nsIVariant* aVariant,
+               JS::MutableHandle<JS::Value> aRetval);
+
+
+
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, nsWrapperCache* cache, const nsIID* iid,
+           JS::MutableHandle<JS::Value> rval)
+{
+  if (xpc_FastGetCachedWrapper(cx, cache, rval))
+    return true;
+  qsObjectHelper helper(p, cache);
+  JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
+  return XPCOMObjectToJsval(cx, scope, helper, iid, true, rval);
+}
+
+
+
+template<>
+inline bool
+WrapObject<nsIVariant>(JSContext* cx, nsIVariant* p,
+                       nsWrapperCache* cache, const nsIID* iid,
+                       JS::MutableHandle<JS::Value> rval)
+{
+  do { } while (0);
+  do { } while (0);
+  return VariantToJsval(cx, p, rval);
+}
+
+
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, const nsIID* iid,
+           JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p, GetWrapperCache(p), iid, rval);
+}
+
+
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, T* p, JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p, nullptr, rval);
+}
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
+           const nsIID* iid, JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p.get(), iid, rval);
+}
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
+           JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p, nullptr, rval);
+}
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const RefPtr<T>& p,
+           const nsIID* iid, JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p.get(), iid, rval);
+}
+
+
+template<class T>
+inline bool
+WrapObject(JSContext* cx, const RefPtr<T>& p,
+           JS::MutableHandle<JS::Value> rval)
+{
+  return WrapObject(cx, p, nullptr, rval);
+}
+
+
+template<>
+inline bool
+WrapObject<JSObject>(JSContext* cx, JSObject* p,
+                     JS::MutableHandle<JS::Value> rval)
+{
+  rval.set(JS::ObjectOrNullValue(p));
+  return true;
+}
+
+inline bool
+WrapObject(JSContext* cx, JSObject& p, JS::MutableHandle<JS::Value> rval)
+{
+  rval.set(JS::ObjectValue(p));
+  return true;
+}
+
+
+
+
+
+template<typename T>
+static inline JSObject*
+WrapNativeISupports(JSContext* cx, T* p, nsWrapperCache* cache)
+{
+  qsObjectHelper helper(ToSupports(p), cache);
+  JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
+  JS::Rooted<JS::Value> v(cx);
+  return XPCOMObjectToJsval(cx, scope, helper, nullptr, false, &v) ?
+         v.toObjectOrNull() :
+         nullptr;
+}
+
+
+
+template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct WrapNativeFallback
+{
+  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+  {
+    return nullptr;
+  }
+};
+
+
+
+template<typename T >
+struct WrapNativeFallback<T, true >
+{
+  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+  {
+    return WrapNativeISupports(cx, parent, cache);
+  }
+};
+
+
+
+template<typename T, bool hasWrapObject=NativeHasMember<T>::WrapObject>
+struct WrapNativeHelper
+{
+  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+  {
+    do { } while (0);
+
+    JSObject* obj;
+    if ((obj = cache->GetWrapper())) {
+
+      do { } while (0);
+      return obj;
+    }
+
+
+    if (!CouldBeDOMBinding(parent)) {
+
+      obj = WrapNativeFallback<T>::Wrap(cx, parent, cache);
+      do { } while (0);
+    } else {
+
+      obj = parent->WrapObject(cx, nullptr);
+      do { } while (0);
+    }
+
+    return obj;
+  }
+};
+
+
+
+template<typename T>
+struct WrapNativeHelper<T, false>
+{
+  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
+  {
+    JSObject* obj;
+    if (cache && (obj = cache->GetWrapper())) {
+
+
+
+
+
+
+      do { } while (0);
+      return obj;
+    }
+
+    obj = WrapNativeISupports(cx, parent, cache);
+    do { } while (0);
+    return obj;
+  }
+};
+
+
+template<typename T>
+static inline JSObject*
+FindAssociatedGlobal(JSContext* cx, T* p, nsWrapperCache* cache,
+                     bool useXBLScope = false)
+{
+  if (!p) {
+    return JS::CurrentGlobalOrNull(cx);
+  }
+
+  JSObject* obj = WrapNativeHelper<T>::Wrap(cx, p, cache);
+  if (!obj) {
+    return nullptr;
+  }
+  do { } while (0);
+
+  obj = js::GetGlobalForObjectCrossCompartment(obj);
+
+  if (!useXBLScope) {
+    return obj;
+  }
+
+
+
+
+  if (xpc::IsInContentXBLScope(obj)) {
+    return obj;
+  }
+  JS::Rooted<JSObject*> rootedObj(cx, obj);
+  JSObject* xblScope = xpc::GetXBLScope(cx, rootedObj);
+  do { } while (0);
+  do { } while (0);
+  return xblScope;
+}
+
+
+
+template<typename T>
+static inline JSObject*
+FindAssociatedGlobal(JSContext* cx, const T& p)
+{
+  return FindAssociatedGlobal(cx, GetParentPointer(p), GetWrapperCache(p), GetUseXBLScope(p));
+}
+
+
+
+template<>
+inline JSObject*
+FindAssociatedGlobal(JSContext* cx, nsIGlobalObject* const& p)
+{
+  if (!p) {
+    return JS::CurrentGlobalOrNull(cx);
+  }
+
+  JSObject* global = p->GetGlobalJSObject();
+  if (!global) {
+    return nullptr;
+  }
+
+  do { } while (0);
+
+
+  JS::ExposeObjectToActiveJS(global);
+  return global;
+}
+
+template<typename T,
+         bool hasAssociatedGlobal=NativeHasMember<T>::GetParentObject>
+struct FindAssociatedGlobalForNative
+{
+  static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
+  {
+    do { } while (0);
+    T* native = UnwrapDOMObject<T>(obj);
+    return FindAssociatedGlobal(cx, native->GetParentObject());
+  }
+};
+
+template<typename T>
+struct FindAssociatedGlobalForNative<T, false>
+{
+  static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
+  {
+    do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 1660; ::abort(); } while (0); } while (0);
+    return nullptr;
+  }
+};
+
+
+
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetOrCreateDOMReflectorHelper
+{
+  static inline bool GetOrCreate(JSContext* cx, const T& value,
+                                 JS::Handle<JSObject*> givenProto,
+                                 JS::MutableHandle<JS::Value> rval)
+  {
+    return GetOrCreateDOMReflector(cx, value.get(), rval, givenProto);
+  }
+};
+
+template <class T>
+struct GetOrCreateDOMReflectorHelper<T, false>
+{
+  static inline bool GetOrCreate(JSContext* cx, T& value,
+                                 JS::Handle<JSObject*> givenProto,
+                                 JS::MutableHandle<JS::Value> rval)
+  {
+    static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
+    return GetOrCreateDOMReflector(cx, &value, rval, givenProto);
+  }
+};
+
+template<class T>
+inline bool
+GetOrCreateDOMReflector(JSContext* cx, T& value,
+                        JS::MutableHandle<JS::Value> rval,
+                        JS::Handle<JSObject*> givenProto = nullptr)
+{
+  return GetOrCreateDOMReflectorHelper<T>::GetOrCreate(cx, value, givenProto,
+                                                       rval);
+}
+
+
+
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetOrCreateDOMReflectorNoWrapHelper
+{
+  static inline bool GetOrCreate(JSContext* cx, const T& value,
+                                 JS::MutableHandle<JS::Value> rval)
+  {
+    return GetOrCreateDOMReflectorNoWrap(cx, value.get(), rval);
+  }
+};
+
+template <class T>
+struct GetOrCreateDOMReflectorNoWrapHelper<T, false>
+{
+  static inline bool GetOrCreate(JSContext* cx, T& value,
+                                 JS::MutableHandle<JS::Value> rval)
+  {
+    return GetOrCreateDOMReflectorNoWrap(cx, &value, rval);
+  }
+};
+
+template<class T>
+inline bool
+GetOrCreateDOMReflectorNoWrap(JSContext* cx, T& value,
+                              JS::MutableHandle<JS::Value> rval)
+{
+  return
+    GetOrCreateDOMReflectorNoWrapHelper<T>::GetOrCreate(cx, value, rval);
+}
+
+template <class T>
+inline JSObject*
+GetCallbackFromCallbackObject(T* aObj)
+{
+  return aObj->CallbackOrNull();
+}
+
+
+
+
+template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
+struct GetCallbackFromCallbackObjectHelper
+{
+  static inline JSObject* Get(const T& aObj)
+  {
+    return GetCallbackFromCallbackObject(aObj.get());
+  }
+};
+
+template <class T>
+struct GetCallbackFromCallbackObjectHelper<T, false>
+{
+  static inline JSObject* Get(T& aObj)
+  {
+    return GetCallbackFromCallbackObject(&aObj);
+  }
+};
+
+template<class T>
+inline JSObject*
+GetCallbackFromCallbackObject(T& aObj)
+{
+  return GetCallbackFromCallbackObjectHelper<T>::Get(aObj);
+}
+
+static inline bool
+AtomizeAndPinJSString(JSContext* cx, jsid& id, const char* chars)
+{
+  if (JSString *str = ::JS_AtomizeAndPinString(cx, chars)) {
+    id = INTERNED_STRING_TO_JSID(cx, str);
+    return true;
+  }
+  return false;
+}
+
+
+template <typename Spec>
+static bool
+InitIds(JSContext* cx, const Prefable<Spec>* prefableSpecs, jsid* ids)
+{
+  do { } while (0);
+  do { } while (0);
+  do {
+
+
+    Spec* spec = prefableSpecs->specs;
+    do {
+      if (!JS::PropertySpecNameToPermanentId(cx, spec->name, ids)) {
+        return false;
+      }
+    } while (++ids, (++spec)->name);
+
+
+
+    *ids = JSID_VOID;
+    ++ids;
+  } while ((++prefableSpecs)->specs);
+
+  return true;
+}
+
+bool
+QueryInterface(JSContext* cx, unsigned argc, JS::Value* vp);
+
+template <class T>
+struct
+WantsQueryInterface
+{
+  static_assert(IsBaseOf<nsISupports, T>::value,
+                "QueryInterface can't work without an nsISupports.");
+  static bool Enabled(JSContext* aCx, JSObject* aGlobal)
+  {
+    return NS_IsMainThread() && IsChromeOrXBL(aCx, aGlobal);
+  }
+};
+
+void
+GetInterfaceImpl(JSContext* aCx, nsIInterfaceRequestor* aRequestor,
+                 nsWrapperCache* aCache, nsIJSID* aIID,
+                 JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError);
+
+template<class T>
+void
+GetInterface(JSContext* aCx, T* aThis, nsIJSID* aIID,
+             JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError)
+{
+  GetInterfaceImpl(aCx, aThis, aThis, aIID, aRetval, aError);
+}
+
+bool
+ThrowingConstructor(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+ThrowConstructorWithoutNew(JSContext* cx, const char* name);
+
+bool
+GetPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
+                       JS::Handle<JS::Value> receiver, JS::Handle<jsid> id,
+                       bool* found, JS::MutableHandle<JS::Value> vp);
+
+
+bool
+HasPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
+                       JS::Handle<jsid> id, bool* has);
+
+
+
+
+
+
+bool
+AppendNamedPropertyIds(JSContext* cx, JS::Handle<JSObject*> proxy,
+                       nsTArray<nsString>& names,
+                       bool shadowPrototypeProperties, JS::AutoIdVector& props);
+
+enum StringificationBehavior {
+  eStringify,
+  eEmpty,
+  eNull
+};
+
+template<typename T>
+static inline bool
+ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v,
+                       StringificationBehavior nullBehavior,
+                       StringificationBehavior undefinedBehavior,
+                       T& result)
+{
+  JSString *s;
+  if (v.isString()) {
+    s = v.toString();
+  } else {
+    StringificationBehavior behavior;
+    if (v.isNull()) {
+      behavior = nullBehavior;
+    } else if (v.isUndefined()) {
+      behavior = undefinedBehavior;
+    } else {
+      behavior = eStringify;
+    }
+
+    if (behavior != eStringify) {
+      if (behavior == eEmpty) {
+        result.Truncate();
+      } else {
+        result.SetIsVoid(true);
+      }
+      return true;
+    }
+
+    s = JS::ToString(cx, v);
+    if (!s) {
+      return false;
+    }
+  }
+
+  return AssignJSString(cx, result, s);
+}
+
+template<typename T>
+static inline bool
+ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v, T& result)
+{
+  return ConvertJSValueToString(cx, v, eStringify, eStringify, result);
+}
+
+void
+NormalizeUSVString(nsAString& aString);
+
+void
+NormalizeUSVString(binding_detail::FakeString& aString);
+
+template<typename T>
+static inline bool
+ConvertJSValueToUSVString(JSContext* cx, JS::Handle<JS::Value> v, T& result)
+{
+  if (!ConvertJSValueToString(cx, v, eStringify, eStringify, result)) {
+    return false;
+  }
+
+  NormalizeUSVString(result);
+  return true;
+}
+
+template<typename T>
+inline bool
+ConvertIdToString(JSContext* cx, JS::HandleId id, T& result, bool& isSymbol)
+{
+  if ((__builtin_expect(!!(JSID_IS_STRING(id)), 1))) {
+    if (!AssignJSString(cx, result, JSID_TO_STRING(id))) {
+      return false;
+    }
+  } else if (JSID_IS_SYMBOL(id)) {
+    isSymbol = true;
+    return true;
+  } else {
+    JS::RootedValue nameVal(cx, js::IdToValue(id));
+    if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify, result)) {
+      return false;
+    }
+  }
+  isSymbol = false;
+  return true;
+}
+
+bool
+ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
+                           bool nullable, nsACString& result);
+
+inline bool
+ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
+                           nsACString& result)
+{
+  return ConvertJSValueToByteString(cx, v, false, result);
+}
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq);
+template<typename T>
+void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq);
+
+
+
+template<typename T,
+         bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
+         bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
+         bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
+class SequenceTracer
+{
+  explicit SequenceTracer() = delete;
+};
+
+
+template<>
+class SequenceTracer<JSObject*, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, JSObject** objp, JSObject** end) {
+    for (; objp != end; ++objp) {
+      JS::UnsafeTraceRoot(trc, objp, "sequence<object>");
+    }
+  }
+};
+
+
+template<>
+class SequenceTracer<JS::Value, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, JS::Value* valp, JS::Value* end) {
+    for (; valp != end; ++valp) {
+      JS::UnsafeTraceRoot(trc, valp, "sequence<any>");
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<Sequence<T>, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, Sequence<T>* seqp, Sequence<T>* end) {
+    for (; seqp != end; ++seqp) {
+      DoTraceSequence(trc, *seqp);
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<nsTArray<T>, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, nsTArray<T>* seqp, nsTArray<T>* end) {
+    for (; seqp != end; ++seqp) {
+      DoTraceSequence(trc, *seqp);
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<T, true, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, T* dictp, T* end) {
+    for (; dictp != end; ++dictp) {
+      dictp->TraceDictionary(trc);
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<T, false, true, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
+    for (; arrayp != end; ++arrayp) {
+      arrayp->TraceSelf(trc);
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<T, false, false, true>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
+    for (; arrayp != end; ++arrayp) {
+      arrayp->TraceUnion(trc);
+    }
+  }
+};
+
+
+template<typename T>
+class SequenceTracer<Nullable<T>, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, Nullable<T>* seqp,
+                            Nullable<T>* end) {
+    for (; seqp != end; ++seqp) {
+      if (!seqp->IsNull()) {
+
+
+        T& val = seqp->Value();
+        T* ptr = &val;
+        SequenceTracer<T>::TraceSequence(trc, ptr, ptr+1);
+      }
+    }
+  }
+};
+
+template<typename K, typename V>
+void TraceRecord(JSTracer* trc, Record<K, V>& record)
+{
+  for (auto& entry : record.Entries()) {
+
+    SequenceTracer<V>::TraceSequence(trc, &entry.mValue, &entry.mValue + 1);
+  }
+}
+
+
+template<typename K, typename V>
+class SequenceTracer<Record<K, V>, false, false, false>
+{
+  explicit SequenceTracer() = delete;
+
+public:
+  static void TraceSequence(JSTracer* trc, Record<K, V>* seqp,
+                            Record<K, V>* end) {
+    for (; seqp != end; ++seqp) {
+      TraceRecord(trc, *seqp);
+    }
+  }
+};
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq)
+{
+  SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
+                                   seq.Elements() + seq.Length());
+}
+
+template<typename T>
+void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq)
+{
+  SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
+                                   seq.Elements() + seq.Length());
+}
+
+
+template<typename T>
+class SequenceRooter final : private JS::CustomAutoRooter
+{
+public:
+  SequenceRooter(JSContext *aCx, FallibleTArray<T>* aSequence
+                                                )
+    : JS::CustomAutoRooter(aCx ),
+      mFallibleArray(aSequence),
+      mSequenceType(eFallibleArray)
+  {
+  }
+
+  SequenceRooter(JSContext *aCx, InfallibleTArray<T>* aSequence
+                                                )
+    : JS::CustomAutoRooter(aCx ),
+      mInfallibleArray(aSequence),
+      mSequenceType(eInfallibleArray)
+  {
+  }
+
+  SequenceRooter(JSContext *aCx, Nullable<nsTArray<T> >* aSequence
+                                                )
+    : JS::CustomAutoRooter(aCx ),
+      mNullableArray(aSequence),
+      mSequenceType(eNullableArray)
+  {
+  }
+
+ private:
+  enum SequenceType {
+    eInfallibleArray,
+    eFallibleArray,
+    eNullableArray
+  };
+
+  virtual void trace(JSTracer *trc) override
+  {
+    if (mSequenceType == eFallibleArray) {
+      DoTraceSequence(trc, *mFallibleArray);
+    } else if (mSequenceType == eInfallibleArray) {
+      DoTraceSequence(trc, *mInfallibleArray);
+    } else {
+      do { } while (0);
+      if (!mNullableArray->IsNull()) {
+        DoTraceSequence(trc, mNullableArray->Value());
+      }
+    }
+  }
+
+  union {
+    InfallibleTArray<T>* mInfallibleArray;
+    FallibleTArray<T>* mFallibleArray;
+    Nullable<nsTArray<T> >* mNullableArray;
+  };
+
+  SequenceType mSequenceType;
+};
+
+
+template<typename K, typename V>
+class RecordRooter final : private JS::CustomAutoRooter
+{
+public:
+  RecordRooter(JSContext *aCx, Record<K, V>* aRecord
+                                              )
+    : JS::CustomAutoRooter(aCx ),
+      mRecord(aRecord),
+      mRecordType(eRecord)
+  {
+  }
+
+  RecordRooter(JSContext *aCx, Nullable<Record<K, V>>* aRecord
+                                                )
+    : JS::CustomAutoRooter(aCx ),
+      mNullableRecord(aRecord),
+      mRecordType(eNullableRecord)
+  {
+  }
+
+private:
+  enum RecordType {
+    eRecord,
+    eNullableRecord
+  };
+
+  virtual void trace(JSTracer *trc) override
+  {
+    if (mRecordType == eRecord) {
+      TraceRecord(trc, *mRecord);
+    } else {
+      do { } while (0);
+      if (!mNullableRecord->IsNull()) {
+        TraceRecord(trc, mNullableRecord->Value());
+      }
+    }
+  }
+
+  union {
+    Record<K, V>* mRecord;
+    Nullable<Record<K, V>>* mNullableRecord;
+  };
+
+  RecordType mRecordType;
+};
+
+template<typename T>
+class RootedUnion : public T,
+                             private JS::CustomAutoRooter
+{
+public:
+  explicit RootedUnion(JSContext* cx ) :
+    T(),
+    JS::CustomAutoRooter(cx )
+  {
+  }
+
+  virtual void trace(JSTracer *trc) override
+  {
+    this->TraceUnion(trc);
+  }
+};
+
+template<typename T>
+class NullableRootedUnion : public Nullable<T>,
+                                            private JS::CustomAutoRooter
+{
+public:
+  explicit NullableRootedUnion(JSContext* cx ) :
+    Nullable<T>(),
+    JS::CustomAutoRooter(cx )
+  {
+  }
+
+  virtual void trace(JSTracer *trc) override
+  {
+    if (!this->IsNull()) {
+      this->Value().TraceUnion(trc);
+    }
+  }
+};
+
+inline bool
+IdEquals(jsid id, const char* string)
+{
+  return JSID_IS_STRING(id) &&
+         JS_FlatStringEqualsAscii(JSID_TO_FLAT_STRING(id), string);
+}
+
+inline bool
+AddStringToIDVector(JSContext* cx, JS::AutoIdVector& vector, const char* name)
+{
+  return vector.growBy(1) &&
+         AtomizeAndPinJSString(cx, *(vector[vector.length() - 1]).address(), name);
+}
+# 2295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+enum {
+  CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT = 0
+};
+
+bool
+Constructor(JSContext* cx, unsigned argc, JS::Value* vp);
+# 2311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+XrayResolveOwnProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                       JS::Handle<JSObject*> obj,
+                       JS::Handle<jsid> id,
+                       JS::MutableHandle<JS::PropertyDescriptor> desc,
+                       bool& cacheOnHolder);
+# 2329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+XrayDefineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                   JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                   JS::Handle<JS::PropertyDescriptor> desc,
+                   JS::ObjectOpResult &result,
+                   bool *defined);
+# 2345 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+XrayOwnPropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                    JS::Handle<JSObject*> obj,
+                    unsigned flags, JS::AutoIdVector& props);
+# 2360 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+inline bool
+XrayGetNativeProto(JSContext* cx, JS::Handle<JSObject*> obj,
+                   JS::MutableHandle<JSObject*> protop)
+{
+  JS::Rooted<JSObject*> global(cx, js::GetGlobalForObjectCrossCompartment(obj));
+  {
+    JSAutoCompartment ac(cx, global);
+    const DOMJSClass* domClass = GetDOMClass(obj);
+    if (domClass) {
+      ProtoHandleGetter protoGetter = domClass->mGetProto;
+      if (protoGetter) {
+        protop.set(protoGetter(cx));
+      } else {
+        protop.set(JS::GetRealmObjectPrototype(cx));
+      }
+    } else if (JS_ObjectIsFunction(cx, obj)) {
+      do { } while (0);
+      protop.set(JS::GetRealmFunctionPrototype(cx));
+    } else {
+      const js::Class* clasp = js::GetObjectClass(obj);
+      do { } while (0);
+      ProtoGetter protoGetter =
+        DOMIfaceAndProtoJSClass::FromJSClass(clasp)->mGetParentProto;
+      protop.set(protoGetter(cx));
+    }
+  }
+
+  return JS_WrapObject(cx, protop);
+}
+
+
+
+
+const JSClass*
+XrayGetExpandoClass(JSContext* cx, JS::Handle<JSObject*> obj);
+# 2404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+XrayDeleteNamedProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
+                        JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                        JS::ObjectOpResult& opresult);
+# 2423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+JSObject*
+GetCachedSlotStorageObjectSlow(JSContext* cx, JS::Handle<JSObject*> obj,
+                               bool* isXray);
+
+inline JSObject*
+GetCachedSlotStorageObject(JSContext* cx, JS::Handle<JSObject*> obj,
+                           bool* isXray) {
+  if (IsDOMObject(obj)) {
+    *isXray = false;
+    return obj;
+  }
+
+  return GetCachedSlotStorageObjectSlow(cx, obj, isXray);
+}
+
+extern NativePropertyHooks sEmptyNativePropertyHooks;
+
+extern const js::ClassOps sBoringInterfaceObjectClassClassOps;
+
+extern const js::ObjectOps sInterfaceObjectClassObjectOps;
+
+inline bool
+UseDOMXray(JSObject* obj)
+{
+  const js::Class* clasp = js::GetObjectClass(obj);
+  return IsDOMClass(clasp) ||
+         JS_IsNativeFunction(obj, Constructor) ||
+         IsDOMIfaceAndProtoClass(clasp);
+}
+# 2463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template<typename T>
+const T& Constify(T& arg)
+{
+  return arg;
+}
+
+
+template<typename T>
+T& NonNullHelper(T& aArg)
+{
+  return aArg;
+}
+
+template<typename T>
+T& NonNullHelper(NonNull<T>& aArg)
+{
+  return aArg;
+}
+
+template<typename T>
+const T& NonNullHelper(const NonNull<T>& aArg)
+{
+  return aArg;
+}
+
+template<typename T>
+T& NonNullHelper(OwningNonNull<T>& aArg)
+{
+  return aArg;
+}
+
+template<typename T>
+const T& NonNullHelper(const OwningNonNull<T>& aArg)
+{
+  return aArg;
+}
+
+inline
+void NonNullHelper(NonNull<binding_detail::FakeString>& aArg)
+{
+
+
+
+
+}
+
+inline
+void NonNullHelper(const NonNull<binding_detail::FakeString>& aArg)
+{
+
+
+
+
+}
+
+inline
+void NonNullHelper(binding_detail::FakeString& aArg)
+{
+
+
+
+
+}
+
+__attribute__((always_inline)) inline
+const nsAString& NonNullHelper(const binding_detail::FakeString& aArg)
+{
+  return aArg;
+}
+
+
+
+nsresult
+ReparentWrapper(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+
+
+
+bool
+InterfaceHasInstance(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+InterfaceHasInstance(JSContext* cx, int prototypeID, int depth,
+                     JS::Handle<JSObject*> instance,
+                     bool* bp);
+
+
+
+bool
+ReportLenientThisUnwrappingFailure(JSContext* cx, JSObject* obj);
+
+
+
+
+bool
+GetContentGlobalForJSImplementedObject(JSContext* cx, JS::Handle<JSObject*> obj,
+                                       nsIGlobalObject** global);
+
+void
+ConstructJSImplementation(const char* aContractId,
+                          nsIGlobalObject* aGlobal,
+                          JS::MutableHandle<JSObject*> aObject,
+                          ErrorResult& aRv);
+
+already_AddRefed<nsIGlobalObject>
+ConstructJSImplementation(const char* aContractId,
+                          const GlobalObject& aGlobal,
+                          JS::MutableHandle<JSObject*> aObject,
+                          ErrorResult& aRv);
+
+
+
+
+
+
+
+bool NonVoidByteStringToJsval(JSContext *cx, const nsACString &str,
+                              JS::MutableHandle<JS::Value> rval);
+inline bool ByteStringToJsval(JSContext *cx, const nsACString &str,
+                              JS::MutableHandle<JS::Value> rval)
+{
+    if (str.IsVoid()) {
+        rval.setNull();
+        return true;
+    }
+    return NonVoidByteStringToJsval(cx, str, rval);
+}
+
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct PreserveWrapperHelper
+{
+  static void PreserveWrapper(T* aObject)
+  {
+    aObject->PreserveWrapper(aObject, T::cycleCollection::GetParticipant());
+  }
+};
+
+template<class T>
+struct PreserveWrapperHelper<T, true>
+{
+  static void PreserveWrapper(T* aObject)
+  {
+    aObject->PreserveWrapper(reinterpret_cast<nsISupports*>(aObject));
+  }
+};
+
+template<class T>
+void PreserveWrapper(T* aObject)
+{
+  PreserveWrapperHelper<T>::PreserveWrapper(aObject);
+}
+
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct CastingAssertions
+{
+  static bool ToSupportsIsCorrect(T*)
+  {
+    return true;
+  }
+  static bool ToSupportsIsOnPrimaryInheritanceChain(T*, nsWrapperCache*)
+  {
+    return true;
+  }
+};
+
+template<class T>
+struct CastingAssertions<T, true>
+{
+  static bool ToSupportsIsCorrect(T* aObject)
+  {
+    return ToSupports(aObject) == reinterpret_cast<nsISupports*>(aObject);
+  }
+  static bool ToSupportsIsOnPrimaryInheritanceChain(T* aObject,
+                                                    nsWrapperCache* aCache)
+  {
+    return reinterpret_cast<void*>(aObject) != aCache;
+  }
+};
+
+template<class T>
+bool
+ToSupportsIsCorrect(T* aObject)
+{
+  return CastingAssertions<T>::ToSupportsIsCorrect(aObject);
+}
+
+template<class T>
+bool
+ToSupportsIsOnPrimaryInheritanceChain(T* aObject, nsWrapperCache* aCache)
+{
+  return CastingAssertions<T>::ToSupportsIsOnPrimaryInheritanceChain(aObject,
+                                                                     aCache);
+}
+# 2667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template<class T>
+class BindingJSObjectCreator
+{
+public:
+  explicit BindingJSObjectCreator(JSContext* aCx)
+    : mReflector(aCx)
+  {
+  }
+
+  ~BindingJSObjectCreator()
+  {
+    if (mReflector) {
+      js::SetReservedOrProxyPrivateSlot(mReflector, 0,
+                                        JS::UndefinedValue());
+    }
+  }
+
+  void
+  CreateProxyObject(JSContext* aCx, const js::Class* aClass,
+                    const DOMProxyHandler* aHandler,
+                    JS::Handle<JSObject*> aProto, T* aNative,
+                    JS::MutableHandle<JSObject*> aReflector)
+  {
+    js::ProxyOptions options;
+    options.setClass(aClass);
+    JS::Rooted<JS::Value> proxyPrivateVal(aCx, JS::PrivateValue(aNative));
+    aReflector.set(js::NewProxyObject(aCx, aHandler, proxyPrivateVal, aProto,
+                                      options));
+    if (aReflector) {
+      mNative = aNative;
+      mReflector = aReflector;
+    }
+  }
+
+  void
+  CreateObject(JSContext* aCx, const JSClass* aClass,
+               JS::Handle<JSObject*> aProto,
+               T* aNative, JS::MutableHandle<JSObject*> aReflector)
+  {
+    aReflector.set(JS_NewObjectWithGivenProto(aCx, aClass, aProto));
+    if (aReflector) {
+      js::SetReservedSlot(aReflector, 0, JS::PrivateValue(aNative));
+      mNative = aNative;
+      mReflector = aReflector;
+    }
+  }
+
+  void
+  InitializationSucceeded()
+  {
+    void* dummy;
+    mNative.forget(&dummy);
+    mReflector = nullptr;
+  }
+
+private:
+  struct OwnedNative
+  {
+
+
+    static_assert(IsBaseOf<NonRefcountedDOMObject, T>::value,
+                  "Non-refcounted objects with DOM bindings should inherit "
+                  "from NonRefcountedDOMObject.");
+
+    OwnedNative&
+    operator=(T* aNative)
+    {
+      return *this;
+    }
+
+
+
+    void
+    forget(void**)
+    {
+    }
+  };
+
+  JS::Rooted<JSObject*> mReflector;
+  typename Conditional<IsRefcounted<T>::value, RefPtr<T>, OwnedNative>::Type mNative;
+};
+
+template<class T>
+struct DeferredFinalizerImpl
+{
+  typedef typename Conditional<IsSame<T, nsISupports>::value,
+                               nsCOMPtr<T>,
+                               typename Conditional<IsRefcounted<T>::value,
+                                                    RefPtr<T>,
+                                                    nsAutoPtr<T>>::Type>::Type SmartPtr;
+  typedef SegmentedVector<SmartPtr> SmartPtrArray;
+
+  static_assert(IsSame<T, nsISupports>::value || !IsBaseOf<nsISupports, T>::value,
+                "nsISupports classes should all use the nsISupports instantiation");
+
+  static inline void
+  AppendAndTake(SegmentedVector<nsCOMPtr<nsISupports>>& smartPtrArray, nsISupports* ptr)
+  {
+    smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
+  }
+  template<class U>
+  static inline void
+  AppendAndTake(SegmentedVector<RefPtr<U>>& smartPtrArray, U* ptr)
+  {
+    smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
+  }
+  template<class U>
+  static inline void
+  AppendAndTake(SegmentedVector<nsAutoPtr<U>>& smartPtrArray, U* ptr)
+  {
+    smartPtrArray.InfallibleAppend(ptr);
+  }
+
+  static void*
+  AppendDeferredFinalizePointer(void* aData, void* aObject)
+  {
+    SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
+    if (!pointers) {
+      pointers = new SmartPtrArray();
+    }
+    AppendAndTake(*pointers, static_cast<T*>(aObject));
+    return pointers;
+  }
+  static bool
+  DeferredFinalize(uint32_t aSlice, void* aData)
+  {
+    do { } while (0);
+    SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
+    uint32_t oldLen = pointers->Length();
+    if (oldLen < aSlice) {
+      aSlice = oldLen;
+    }
+    uint32_t newLen = oldLen - aSlice;
+    pointers->PopLastN(aSlice);
+    if (newLen == 0) {
+      delete pointers;
+      return true;
+    }
+    return false;
+  }
+};
+
+template<class T,
+         bool isISupports=IsBaseOf<nsISupports, T>::value>
+struct DeferredFinalizer
+{
+  static void
+  AddForDeferredFinalization(T* aObject)
+  {
+    typedef DeferredFinalizerImpl<T> Impl;
+    DeferredFinalize(Impl::AppendDeferredFinalizePointer,
+                     Impl::DeferredFinalize, aObject);
+  }
+};
+
+template<class T>
+struct DeferredFinalizer<T, true>
+{
+  static void
+  AddForDeferredFinalization(T* aObject)
+  {
+    DeferredFinalize(reinterpret_cast<nsISupports*>(aObject));
+  }
+};
+
+template<class T>
+static void
+AddForDeferredFinalization(T* aObject)
+{
+  DeferredFinalizer<T>::AddForDeferredFinalization(aObject);
+}
+
+
+
+
+template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
+class GetCCParticipant
+{
+
+  template<class U>
+  static constexpr nsCycleCollectionParticipant*
+  GetHelper(int, typename U::cycleCollection* dummy=nullptr)
+  {
+    return T::cycleCollection::GetParticipant();
+  }
+
+  template<class U>
+  static constexpr nsCycleCollectionParticipant*
+  GetHelper(double)
+  {
+    return nullptr;
+  }
+
+public:
+  static constexpr nsCycleCollectionParticipant*
+  Get()
+  {
+
+
+
+
+    return GetHelper<T>(int());
+  }
+};
+
+template<class T>
+class GetCCParticipant<T, true>
+{
+public:
+  static constexpr nsCycleCollectionParticipant*
+  Get()
+  {
+    return nullptr;
+  }
+};
+
+void
+FinalizeGlobal(JSFreeOp* aFop, JSObject* aObj);
+
+bool
+ResolveGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
+              JS::Handle<jsid> aId, bool* aResolvedp);
+
+bool
+MayResolveGlobal(const JSAtomState& aNames, jsid aId, JSObject* aMaybeObj);
+
+bool
+EnumerateGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+template <class T>
+struct CreateGlobalOptions
+{
+  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+    ProtoAndIfaceCache::NonWindowLike;
+  static void TraceGlobal(JSTracer* aTrc, JSObject* aObj)
+  {
+    mozilla::dom::TraceProtoAndIfaceCache(aTrc, aObj);
+  }
+  static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
+  {
+    do { if ((TryPreserveWrapper(aGlobal))) { } } while (0);
+
+    return true;
+  }
+};
+
+template <>
+struct CreateGlobalOptions<nsGlobalWindow>
+{
+  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+    ProtoAndIfaceCache::WindowLike;
+  static void TraceGlobal(JSTracer* aTrc, JSObject* aObj);
+  static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
+};
+
+nsresult
+RegisterDOMNames();
+# 2932 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+template <class T, ProtoHandleGetter GetProto>
+bool
+CreateGlobal(JSContext* aCx, T* aNative, nsWrapperCache* aCache,
+             const JSClass* aClass, JS::CompartmentOptions& aOptions,
+             JSPrincipals* aPrincipal, bool aInitStandardClasses,
+             JS::MutableHandle<JSObject*> aGlobal)
+{
+  aOptions.creationOptions().setTrace(CreateGlobalOptions<T>::TraceGlobal);
+  if (xpc::SharedMemoryEnabled()) {
+    aOptions.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
+  }
+
+  aGlobal.set(JS_NewGlobalObject(aCx, aClass, aPrincipal,
+                                 JS::DontFireOnNewGlobalHook, aOptions));
+  if (!aGlobal) {
+    do { } while(0);
+    return false;
+  }
+
+  JSAutoCompartment ac(aCx, aGlobal);
+
+  {
+    js::SetReservedSlot(aGlobal, 0, JS::PrivateValue(aNative));
+    (aNative)->AddRef();
+
+    aCache->SetWrapper(aGlobal);
+
+    dom::AllocateProtoAndIfaceCache(aGlobal,
+                                    CreateGlobalOptions<T>::ProtoAndIfaceCacheKind);
+
+    if (!CreateGlobalOptions<T>::PostCreateGlobal(aCx, aGlobal)) {
+      return false;
+    }
+  }
+
+  if (aInitStandardClasses &&
+      !JS_InitStandardClasses(aCx, aGlobal)) {
+    do { } while(0);
+    return false;
+  }
+
+  JS::Handle<JSObject*> proto = GetProto(aCx);
+  if (!proto || !JS_SplicePrototype(aCx, aGlobal, proto)) {
+    do { } while(0);
+    return false;
+  }
+
+  bool succeeded;
+  if (!JS_SetImmutablePrototype(aCx, aGlobal, &succeeded)) {
+    return false;
+  }
+  do { } while (0);
+
+
+
+  return true;
+}
+
+
+
+
+
+class PinnedStringId
+{
+  jsid id;
+
+ public:
+  PinnedStringId() : id(JSID_VOID) {}
+
+  bool init(JSContext *cx, const char *string) {
+    JSString* str = JS_AtomizeAndPinString(cx, string);
+    if (!str)
+      return false;
+    id = INTERNED_STRING_TO_JSID(cx, str);
+    return true;
+  }
+
+  operator const jsid& () {
+    return id;
+  }
+
+  operator JS::Handle<jsid> () {
+
+    return JS::Handle<jsid>::fromMarkedLocation(&id);
+  }
+};
+
+bool
+GenericBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericPromiseReturningBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericBindingSetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+GenericPromiseReturningBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+StaticMethodPromiseWrapper(JSContext* cx, unsigned argc, JS::Value* vp);
+# 3045 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+ConvertExceptionToPromise(JSContext* cx,
+                          JSObject* promiseScope,
+                          JS::MutableHandle<JS::Value> rval);
+# 3062 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool
+EnforceNotInPrerendering(JSContext* aCx, JSObject* aObj);
+
+
+
+
+void
+HandlePrerenderingViolation(nsPIDOMWindowInner* aWindow);
+
+bool
+CallerSubsumes(JSObject* aObject);
+
+__attribute__((always_inline)) inline bool
+CallerSubsumes(JS::Handle<JS::Value> aValue)
+{
+  if (!aValue.isObject()) {
+    return true;
+  }
+  return CallerSubsumes(&aValue.toObject());
+}
+
+template<class T>
+inline bool
+WrappedJSToDictionary(JSContext* aCx, nsISupports* aObject, T& aDictionary)
+{
+  nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
+  if (!wrappedObj) {
+    return false;
+  }
+
+  JS::Rooted<JSObject*> obj(aCx, wrappedObj->GetJSObject());
+  if (!obj) {
+    return false;
+  }
+
+  JSAutoCompartment ac(aCx, obj);
+  JS::Rooted<JS::Value> v(aCx, JS::ObjectValue(*obj));
+  return aDictionary.Init(aCx, v);
+}
+
+template<class T>
+inline bool
+WrappedJSToDictionary(nsISupports* aObject, T& aDictionary)
+{
+  nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
+  do { if ((__builtin_expect(!!(!(wrappedObj)), 0))) { do { } while(0); return false; } } while(0);
+  JS::Rooted<JSObject*> obj(RootingCx(), wrappedObj->GetJSObject());
+  do { if ((__builtin_expect(!!(!(obj)), 0))) { do { } while(0); return false; } } while(0);
+
+  nsIGlobalObject* global = xpc::NativeGlobal(obj);
+  do { if ((__builtin_expect(!!(!(global)), 0))) { do { } while(0); return false; } } while(0);
+
+
+
+  AutoEntryScript aes(global, "WebIDL dictionary creation");
+
+  JS::Rooted<JS::Value> v(aes.cx(), JS::ObjectValue(*obj));
+  return aDictionary.Init(aes.cx(), v);
+}
+
+
+template<class T, class S>
+inline RefPtr<T>
+StrongOrRawPtr(already_AddRefed<S>&& aPtr)
+{
+  return aPtr.template downcast<T>();
+}
+
+template<class T,
+         class ReturnType=typename Conditional<IsRefcounted<T>::value, T*,
+                                               nsAutoPtr<T>>::Type>
+inline ReturnType
+StrongOrRawPtr(T* aPtr)
+{
+  return ReturnType(aPtr);
+}
+
+template<class T, template<typename> class SmartPtr, class S>
+inline void
+StrongOrRawPtr(SmartPtr<S>&& aPtr) = delete;
+
+template<class T>
+struct StrongPtrForMember
+{
+  typedef typename Conditional<IsRefcounted<T>::value,
+                               RefPtr<T>, nsAutoPtr<T>>::Type Type;
+};
+
+namespace binding_detail {
+inline
+JSObject*
+GetHackedNamespaceProtoObject(JSContext* aCx)
+{
+  return JS_NewPlainObject(aCx);
+}
+}
+
+
+
+
+bool SystemGlobalResolve(JSContext* cx, JS::Handle<JSObject*> obj,
+                         JS::Handle<jsid> id, bool* resolvedp);
+
+
+
+
+bool SystemGlobalEnumerate(JSContext* cx, JS::Handle<JSObject*> obj);
+# 3177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+bool ForEachHandler(JSContext* aCx, unsigned aArgc, JS::Value* aVp);
+
+
+
+
+
+
+bool GetMaplikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
+                             size_t aSlotIndex,
+                             JS::MutableHandle<JSObject*> aBackingObj,
+                             bool* aBackingObjCreated);
+bool GetSetlikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
+                             size_t aSlotIndex,
+                             JS::MutableHandle<JSObject*> aBackingObj,
+                             bool* aBackingObjCreated);
+
+
+
+bool
+GetDesiredProto(JSContext* aCx, const JS::CallArgs& aCallArgs,
+                JS::MutableHandle<JSObject*> aDesiredProto);
+
+
+
+
+already_AddRefed<nsGenericHTMLElement>
+CreateHTMLElement(const GlobalObject& aGlobal, const JS::CallArgs& aCallArgs,
+                  ErrorResult& aRv);
+
+void
+SetDocumentAndPageUseCounter(JSContext* aCx, JSObject* aObject,
+                             UseCounter aUseCounter);
+
+
+void
+DeprecationWarning(JSContext* aCx, JSObject* aObject,
+                   nsIDocument::DeprecatedOperations aOperation);
+
+void
+DeprecationWarning(const GlobalObject& aGlobal,
+                   nsIDocument::DeprecatedOperations aOperation);
+
+
+JSString*
+InterfaceObjectToString(JSContext* aCx, JS::Handle<JSObject*> aObject,
+                        unsigned );
+
+namespace binding_detail {
+# 3240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
+JSObject* UnprivilegedJunkScopeOrWorkerGlobal();
+}
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h" 2
+
+
+
+
+
+
+namespace mozilla {
+namespace dom {
+
+class Promise;
+
+
+
+
+
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const nsAString& aArgument,
+          JS::MutableHandle<JS::Value> aValue);
+
+
+
+
+
+
+template<typename T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsSame<T, bool>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          T aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setBoolean(aArgument);
+  return true;
+}
+
+
+inline bool
+ToJSValue(JSContext* aCx,
+          int32_t aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setInt32(aArgument);
+  return true;
+}
+
+inline bool
+ToJSValue(JSContext* aCx,
+          uint32_t aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setNumber(aArgument);
+  return true;
+}
+
+inline bool
+ToJSValue(JSContext* aCx,
+          int64_t aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setNumber(double(aArgument));
+  return true;
+}
+
+inline bool
+ToJSValue(JSContext* aCx,
+          uint64_t aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setNumber(double(aArgument));
+  return true;
+}
+
+
+inline bool
+ToJSValue(JSContext* aCx,
+          float aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setNumber(aArgument);
+  return true;
+}
+
+inline bool
+ToJSValue(JSContext* aCx,
+          double aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setNumber(aArgument);
+  return true;
+}
+
+
+__attribute__ ((warn_unused_result)) inline bool
+ToJSValue(JSContext* aCx,
+          CallbackObject& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  aValue.setObjectOrNull(aArgument.CallbackOrNull());
+
+  return MaybeWrapValue(aCx, aValue);
+}
+
+
+
+template <class T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsBaseOf<nsWrapperCache, T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          T& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  do { } while (0);
+
+  return GetOrCreateDOMReflector(aCx, aArgument, aValue);
+}
+
+
+template<typename T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsBaseOf<AllTypedArraysBase, T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          const TypedArrayCreator<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  JSObject* obj = aArgument.Create(aCx);
+  if (!obj) {
+    return false;
+  }
+  aValue.setObject(*obj);
+  return true;
+}
+
+
+
+template <class T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<!IsBaseOf<nsWrapperCache, T>::value &&
+                  !IsBaseOf<CallbackObject, T>::value &&
+                  IsBaseOf<nsISupports, T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          T& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  qsObjectHelper helper(ToSupports(&aArgument), nullptr);
+  JS::Rooted<JSObject*> scope(aCx, JS::CurrentGlobalOrNull(aCx));
+  return XPCOMObjectToJsval(aCx, scope, helper, nullptr, true, aValue);
+}
+
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const nsCOMPtr<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, *aArgument.get(), aValue);
+}
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const RefPtr<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, *aArgument.get(), aValue);
+}
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const NonNull<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, *aArgument.get(), aValue);
+}
+
+
+template <class T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsBaseOf<DictionaryBase, T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          const T& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return aArgument.ToObjectInternal(aCx, aValue);
+}
+
+
+__attribute__ ((warn_unused_result)) inline bool
+ToJSValue(JSContext* aCx, JS::Handle<JS::Value> aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  aValue.set(aArgument);
+  return MaybeWrapValue(aCx, aValue);
+}
+
+
+__attribute__ ((warn_unused_result)) inline bool
+ToJSValue(JSContext* aCx, const JS::Heap<JS::Value>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  aValue.set(aArgument);
+  return MaybeWrapValue(aCx, aValue);
+}
+
+
+__attribute__ ((warn_unused_result)) inline bool
+ToJSValue(JSContext* aCx, const JS::Rooted<JS::Value>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  aValue.set(aArgument);
+  return MaybeWrapValue(aCx, aValue);
+}
+
+
+
+__attribute__ ((warn_unused_result)) inline bool
+ToJSValue(JSContext* aCx, const JS::Rooted<JSObject*>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  aValue.setObjectOrNull(aArgument);
+  return MaybeWrapObjectOrNullValue(aCx, aValue);
+}
+
+
+
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          nsresult aArgument,
+          JS::MutableHandle<JS::Value> aValue);
+
+
+
+
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          ErrorResult& aArgument,
+          JS::MutableHandle<JS::Value> aValue);
+
+
+template <typename T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsBaseOf<AllOwningUnionBase, T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          const T& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
+  return aArgument.ToJSVal(aCx, global, aValue);
+}
+
+
+template <typename T>
+__attribute__ ((warn_unused_result))
+typename EnableIf<IsPointer<T>::value, bool>::Type
+ToJSValue(JSContext* aCx,
+          T aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, *aArgument, aValue);
+}
+
+
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          Promise& aArgument,
+          JS::MutableHandle<JS::Value> aValue);
+
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          T* aArguments,
+          size_t aLength,
+          JS::MutableHandle<JS::Value> aValue)
+{
+
+  do { } while (0);
+
+  JS::AutoValueVector v(aCx);
+  if (!v.resize(aLength)) {
+    return false;
+  }
+  for (size_t i = 0; i < aLength; ++i) {
+    if (!ToJSValue(aCx, aArguments[i], v[i])) {
+      return false;
+    }
+  }
+  JSObject* arrayObj = JS_NewArrayObject(aCx, v);
+  if (!arrayObj) {
+    return false;
+  }
+  aValue.setObject(*arrayObj);
+  return true;
+}
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const nsTArray<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, aArgument.Elements(),
+                   aArgument.Length(), aValue);
+}
+
+template <typename T>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const FallibleTArray<T>& aArgument,
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, aArgument.Elements(),
+                   aArgument.Length(), aValue);
+}
+
+template <typename T, int N>
+__attribute__ ((warn_unused_result)) bool
+ToJSValue(JSContext* aCx,
+          const T(&aArgument)[N],
+          JS::MutableHandle<JS::Value> aValue)
+{
+  return ToJSValue(aCx, aArgument, N, aValue);
+}
+
+}
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
+
+
+class nsGlobalWindow;
+struct nsGlobalWindowAtoms;
+class nsPIDOMWindowOuter;
+
+namespace mozilla {
+namespace dom {
+
+class ChromeWindow;
+struct ChromeWindowAtoms;
+class External;
+class FrameRequestCallback;
+class IdleDeadline;
+class IdleRequestCallback;
+struct IdleRequestOptionsAtoms;
+struct NativePropertyHooks;
+class OwningExternalOrWindowProxy;
+class ProtoAndIfaceCache;
+struct ScrollOptionsAtoms;
+struct ScrollToOptionsAtoms;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class ScrollBehavior : uint8_t {
+  Auto,
+  Instant,
+  Smooth,
+  EndGuard_
+};
+
+namespace ScrollBehaviorValues {
+extern const EnumEntry strings[4];
+}
+
+bool
+ToJSValue(JSContext* aCx, ScrollBehavior aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningExternalOrWindowProxy& aUnion, const char* aName, uint32_t aFlags = 0);
+
+
+void
+ImplCycleCollectionUnlink(OwningExternalOrWindowProxy& aUnion);
+
+
+class ExternalOrWindowProxy
+{
+  friend class ExternalOrWindowProxyArgument;
+  enum Type
+  {
+    eUninitialized,
+    eExternal,
+    eWindowProxy
+  };
+
+  union Value
+  {
+    UnionMember<NonNull<mozilla::dom::External> > mExternal;
+    UnionMember<nsPIDOMWindowOuter* > mWindowProxy;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+  ExternalOrWindowProxy(const ExternalOrWindowProxy&) = delete;
+  ExternalOrWindowProxy& operator=(const ExternalOrWindowProxy&) = delete;
+public:
+  explicit inline ExternalOrWindowProxy()
+    : mType(eUninitialized)
+  {
+  }
+
+  inline ~ExternalOrWindowProxy()
+  {
+    Uninit();
+  }
+
+  inline NonNull<mozilla::dom::External>&
+  RawSetAsExternal()
+  {
+    if (mType == eExternal) {
+      return mValue.mExternal.Value();
+    }
+    do { } while (0);
+    mType = eExternal;
+    return mValue.mExternal.SetValue();
+  }
+
+  inline NonNull<mozilla::dom::External>&
+  SetAsExternal()
+  {
+    if (mType == eExternal) {
+      return mValue.mExternal.Value();
+    }
+    Uninit();
+    mType = eExternal;
+    return mValue.mExternal.SetValue();
+  }
+
+  inline bool
+  IsExternal() const
+  {
+    return mType == eExternal;
+  }
+
+  inline NonNull<mozilla::dom::External>&
+  GetAsExternal()
+  {
+    do { } while (0);
+    return mValue.mExternal.Value();
+  }
+
+  inline mozilla::dom::External&
+  GetAsExternal() const
+  {
+    do { } while (0);
+    return mValue.mExternal.Value();
+  }
+
+  inline nsPIDOMWindowOuter*&
+  RawSetAsWindowProxy()
+  {
+    if (mType == eWindowProxy) {
+      return mValue.mWindowProxy.Value();
+    }
+    do { } while (0);
+    mType = eWindowProxy;
+    return mValue.mWindowProxy.SetValue();
+  }
+
+  inline nsPIDOMWindowOuter*&
+  SetAsWindowProxy()
+  {
+    if (mType == eWindowProxy) {
+      return mValue.mWindowProxy.Value();
+    }
+    Uninit();
+    mType = eWindowProxy;
+    return mValue.mWindowProxy.SetValue();
+  }
+
+  inline bool
+  IsWindowProxy() const
+  {
+    return mType == eWindowProxy;
+  }
+
+  inline nsPIDOMWindowOuter*&
+  GetAsWindowProxy()
+  {
+    do { } while (0);
+    return mValue.mWindowProxy.Value();
+  }
+
+  inline nsPIDOMWindowOuter*
+  GetAsWindowProxy() const
+  {
+    do { } while (0);
+    return mValue.mWindowProxy.Value();
+  }
+
+  inline void
+  Uninit()
+  {
+    switch (mType) {
+      case eUninitialized: {
+        break;
+      }
+      case eExternal: {
+        DestroyExternal();
+        break;
+      }
+      case eWindowProxy: {
+        DestroyWindowProxy();
+        break;
+      }
+    }
+  }
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+private:
+  inline void
+  DestroyExternal()
+  {
+    do { } while (0);
+    mValue.mExternal.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyWindowProxy()
+  {
+    do { } while (0);
+    mValue.mWindowProxy.Destroy();
+    mType = eUninitialized;
+  }
+};
+
+
+class OwningExternalOrWindowProxy : public AllOwningUnionBase
+{
+  friend void ImplCycleCollectionUnlink(OwningExternalOrWindowProxy& aUnion);
+  enum Type
+  {
+    eUninitialized,
+    eExternal,
+    eWindowProxy
+  };
+
+  union Value
+  {
+    UnionMember<OwningNonNull<mozilla::dom::External> > mExternal;
+    UnionMember<RefPtr<nsPIDOMWindowOuter> > mWindowProxy;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+public:
+  explicit inline OwningExternalOrWindowProxy()
+    : mType(eUninitialized)
+  {
+  }
+
+  explicit inline OwningExternalOrWindowProxy(const OwningExternalOrWindowProxy& aOther)
+    : mType(eUninitialized)
+  {
+    *this = aOther;
+  }
+
+  inline ~OwningExternalOrWindowProxy()
+  {
+    Uninit();
+  }
+
+  OwningNonNull<mozilla::dom::External>&
+  RawSetAsExternal();
+
+  OwningNonNull<mozilla::dom::External>&
+  SetAsExternal();
+
+  bool
+  TrySetToExternal(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsExternal() const
+  {
+    return mType == eExternal;
+  }
+
+  inline OwningNonNull<mozilla::dom::External>&
+  GetAsExternal()
+  {
+    do { } while (0);
+    return mValue.mExternal.Value();
+  }
+
+  inline OwningNonNull<mozilla::dom::External> const &
+  GetAsExternal() const
+  {
+    do { } while (0);
+    return mValue.mExternal.Value();
+  }
+
+  RefPtr<nsPIDOMWindowOuter>&
+  RawSetAsWindowProxy();
+
+  RefPtr<nsPIDOMWindowOuter>&
+  SetAsWindowProxy();
+
+  bool
+  TrySetToWindowProxy(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsWindowProxy() const
+  {
+    return mType == eWindowProxy;
+  }
+
+  inline RefPtr<nsPIDOMWindowOuter>&
+  GetAsWindowProxy()
+  {
+    do { } while (0);
+    return mValue.mWindowProxy.Value();
+  }
+
+  inline RefPtr<nsPIDOMWindowOuter> const &
+  GetAsWindowProxy() const
+  {
+    do { } while (0);
+    return mValue.mWindowProxy.Value();
+  }
+
+  void
+  Uninit();
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceUnion(JSTracer* trc);
+
+  OwningExternalOrWindowProxy&
+  operator=(const OwningExternalOrWindowProxy& aOther);
+
+private:
+  void
+  DestroyExternal();
+
+  void
+  DestroyWindowProxy();
+};
+
+
+struct IdleRequestOptions : public DictionaryBase
+{
+                        Optional<uint32_t> mTimeout;
+
+  IdleRequestOptions();
+
+  explicit inline IdleRequestOptions(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline IdleRequestOptions(const IdleRequestOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  IdleRequestOptions&
+  operator=(const IdleRequestOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, IdleRequestOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastIdleRequestOptions : public IdleRequestOptions
+{
+  inline FastIdleRequestOptions()
+    : IdleRequestOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct ScrollOptions : public DictionaryBase
+{
+                        ScrollBehavior mBehavior;
+
+  ScrollOptions();
+
+  explicit inline ScrollOptions(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline ScrollOptions(const ScrollOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  ScrollOptions&
+  operator=(const ScrollOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, ScrollOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastScrollOptions : public ScrollOptions
+{
+  inline FastScrollOptions()
+    : ScrollOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct ScrollToOptions : public ScrollOptions
+{
+                        Optional<double> mLeft;
+                        Optional<double> mTop;
+
+  ScrollToOptions();
+
+  explicit inline ScrollToOptions(const FastDictionaryInitializer& )
+    : ScrollOptions(FastDictionaryInitializer())
+  {
+
+  }
+
+  explicit inline ScrollToOptions(const ScrollToOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  ScrollToOptions&
+  operator=(const ScrollToOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, ScrollToOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastScrollToOptions : public ScrollToOptions
+{
+  inline FastScrollToOptions()
+    : ScrollToOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+class FrameRequestCallback : public CallbackFunction
+{
+public:
+  explicit inline FrameRequestCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline FrameRequestCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
+    : CallbackFunction(aCallback, FastCallbackConstructor())
+  {
+    do { } while (0);
+  }
+
+  explicit inline FrameRequestCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline FrameRequestCallback(CallbackFunction* aOther)
+    : CallbackFunction(aOther)
+  {
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, double time, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "FrameRequestCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    JS::Rooted<JS::Value> thisValJS(s.GetContext());
+    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+    return Call(s.GetContext(), thisValJS, time, aRv);
+  }
+
+  inline void
+  Call(double time, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "FrameRequestCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    return Call(s.GetContext(), JS::UndefinedHandleValue, time, aRv);
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, double time, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(thisVal, time, rv, aExecutionReason);
+  }
+
+  inline void
+  Call(double time, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(time, rv, aExecutionReason, eReportExceptions, nullptr);
+  }
+
+  inline bool
+  operator==(const FrameRequestCallback& aOther) const
+  {
+    return CallbackFunction::operator==(aOther);
+  }
+
+private:
+  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, double time, ErrorResult& aRv);
+};
+
+
+class IdleRequestCallback : public CallbackFunction
+{
+public:
+  explicit inline IdleRequestCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline IdleRequestCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
+    : CallbackFunction(aCallback, FastCallbackConstructor())
+  {
+    do { } while (0);
+  }
+
+  explicit inline IdleRequestCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline IdleRequestCallback(CallbackFunction* aOther)
+    : CallbackFunction(aOther)
+  {
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, IdleDeadline& deadline, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "IdleRequestCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    JS::Rooted<JS::Value> thisValJS(s.GetContext());
+    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+    return Call(s.GetContext(), thisValJS, deadline, aRv);
+  }
+
+  inline void
+  Call(IdleDeadline& deadline, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "IdleRequestCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    return Call(s.GetContext(), JS::UndefinedHandleValue, deadline, aRv);
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, IdleDeadline& deadline, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(thisVal, deadline, rv, aExecutionReason);
+  }
+
+  inline void
+  Call(IdleDeadline& deadline, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(deadline, rv, aExecutionReason, eReportExceptions, nullptr);
+  }
+
+  inline bool
+  operator==(const IdleRequestCallback& aOther) const
+  {
+    return CallbackFunction::operator==(aOther);
+  }
+
+private:
+  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, IdleDeadline& deadline, ErrorResult& aRv);
+};
+
+
+namespace binding_detail {
+class FastFrameRequestCallback : public FrameRequestCallback
+{
+public:
+  explicit inline FastFrameRequestCallback(JS::Handle<JSObject*> aCallback)
+    : FrameRequestCallback(aCallback, FastCallbackConstructor())
+  {
+  }
+
+  inline void
+  Trace(JSTracer* aTracer)
+  {
+    FrameRequestCallback::Trace(aTracer);
+  }
+
+  inline void
+  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
+  {
+    FrameRequestCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
+  }
+};
+}
+
+
+namespace binding_detail {
+class FastIdleRequestCallback : public IdleRequestCallback
+{
+public:
+  explicit inline FastIdleRequestCallback(JS::Handle<JSObject*> aCallback)
+    : IdleRequestCallback(aCallback, FastCallbackConstructor())
+  {
+  }
+
+  inline void
+  Trace(JSTracer* aTracer)
+  {
+    IdleRequestCallback::Trace(aTracer);
+  }
+
+  inline void
+  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
+  {
+    IdleRequestCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
+  }
+};
+}
+
+
+namespace ChromeWindowBinding {
+
+  typedef mozilla::dom::ChromeWindow NativeType;
+
+  bool
+  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+# 729 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+namespace WindowBinding {
+
+  typedef nsGlobalWindow NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, nsGlobalWindow* aObject, nsWrapperCache* aCache, JS::CompartmentOptions& aOptions, JSPrincipals* aPrincipal, bool aInitStandardClasses, JS::MutableHandle<JSObject*> aReflector);
+# 764 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  bool
+  ClearCachedDocumentValue(JSContext* aCx, nsGlobalWindow* aObject);
+
+  bool
+  ClearCachedPerformanceValue(JSContext* aCx, nsGlobalWindow* aObject);
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+  inline bool IsPermitted(JSFlatString* prop, char16_t propFirstChar, bool set)
+  {
+    switch (propFirstChar) {
+      case 'b': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "blur")) {
+          return true;
+        }
+        break;
+      }
+      case 'c': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "close")) {
+          return true;
+        }
+        if (!set && JS_FlatStringEqualsAscii(prop, "closed")) {
+          return true;
+        }
+        break;
+      }
+      case 'f': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "focus")) {
+          return true;
+        }
+        if (!set && JS_FlatStringEqualsAscii(prop, "frames")) {
+          return true;
+        }
+        break;
+      }
+      case 'l': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "length")) {
+          return true;
+        }
+        if (JS_FlatStringEqualsAscii(prop, "location")) {
+          return true;
+        }
+        break;
+      }
+      case 'o': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "opener")) {
+          return true;
+        }
+        break;
+      }
+      case 'p': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "parent")) {
+          return true;
+        }
+        if (!set && JS_FlatStringEqualsAscii(prop, "postMessage")) {
+          return true;
+        }
+        break;
+      }
+      case 's': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "self")) {
+          return true;
+        }
+        break;
+      }
+      case 't': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "top")) {
+          return true;
+        }
+        break;
+      }
+      case 'w': {
+        if (!set && JS_FlatStringEqualsAscii(prop, "window")) {
+          return true;
+        }
+        break;
+      }
+    }
+
+    return false;
+  }
+
+}
+
+
+
+}
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
+
+
+struct nsStyleDisplay;
+
+namespace mozilla {
+
+struct ScrollbarStyles
+{
+
+
+  uint8_t mHorizontal;
+  uint8_t mVertical;
+
+
+  uint8_t mScrollBehavior;
+
+
+  uint8_t mScrollSnapTypeX;
+  uint8_t mScrollSnapTypeY;
+  nsStyleCoord mScrollSnapPointsX;
+  nsStyleCoord mScrollSnapPointsY;
+  nsStyleCoord::CalcValue mScrollSnapDestinationX;
+  nsStyleCoord::CalcValue mScrollSnapDestinationY;
+
+  ScrollbarStyles(uint8_t aH, uint8_t aV)
+    : mHorizontal(aH), mVertical(aV),
+      mScrollBehavior(0),
+      mScrollSnapTypeX(0),
+      mScrollSnapTypeY(0),
+      mScrollSnapPointsX(nsStyleCoord(eStyleUnit_None)),
+      mScrollSnapPointsY(nsStyleCoord(eStyleUnit_None)) {
+
+    mScrollSnapDestinationX.mPercent = 0;
+    mScrollSnapDestinationX.mLength = nscoord(0.0f);
+    mScrollSnapDestinationX.mHasPercent = false;
+    mScrollSnapDestinationY.mPercent = 0;
+    mScrollSnapDestinationY.mLength = nscoord(0.0f);
+    mScrollSnapDestinationY.mHasPercent = false;
+  }
+
+  explicit ScrollbarStyles(const nsStyleDisplay* aDisplay);
+  ScrollbarStyles(uint8_t aH, uint8_t aV, const nsStyleDisplay* aDisplay);
+  ScrollbarStyles() {}
+  bool operator==(const ScrollbarStyles& aStyles) const {
+    return aStyles.mHorizontal == mHorizontal && aStyles.mVertical == mVertical &&
+           aStyles.mScrollBehavior == mScrollBehavior &&
+           aStyles.mScrollSnapTypeX == mScrollSnapTypeX &&
+           aStyles.mScrollSnapTypeY == mScrollSnapTypeY &&
+           aStyles.mScrollSnapPointsX == mScrollSnapPointsX &&
+           aStyles.mScrollSnapPointsY == mScrollSnapPointsY &&
+           aStyles.mScrollSnapDestinationX == mScrollSnapDestinationX &&
+           aStyles.mScrollSnapDestinationY == mScrollSnapDestinationY;
+  }
+  bool operator!=(const ScrollbarStyles& aStyles) const {
+    return !(*this == aStyles);
+  }
+  bool IsHiddenInBothDirections() const {
+    return mHorizontal == 1 &&
+           mVertical == 1;
+  }
+  bool IsSmoothScroll(dom::ScrollBehavior aBehavior) const {
+    return aBehavior == dom::ScrollBehavior::Smooth ||
+             (aBehavior == dom::ScrollBehavior::Auto &&
+               mScrollBehavior == 1);
+  }
+};
+
+}
+# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class mozIDOMWindowProxy;
+
+class nsIDocShell;
+
+class nsIContent;
+
+class nsIFrameLoader;
+
+class nsIPrincipal;
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIMessageListener : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult ReceiveMessage(void) = 0;
+
+};
+
+  template<typename T> struct nsIMessageListener::COMTypeInfo<nsIMessageListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageListener::COMTypeInfo<nsIMessageListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2b44eb57, 0xa9c6, 0x4773, { 0x9a, 0x1e, 0xfe, 0x08, 0x18, 0x73, 0x9a, 0x4c }};
+# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIMessageListenerManager : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult AddMessageListener(const nsAString & messageName, nsIMessageListener *listener, bool listenWhenClosed) = 0;
+
+
+  virtual nsresult RemoveMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
+
+
+  virtual nsresult AddWeakMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
+
+
+  virtual nsresult RemoveWeakMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
+
+
+  virtual bool MarkForCC(void) = 0;
+
+};
+
+  template<typename T> struct nsIMessageListenerManager::COMTypeInfo<nsIMessageListenerManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageListenerManager::COMTypeInfo<nsIMessageListenerManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb949bfec, 0xbb7d, 0x47bc, { 0xb3, 0x87, 0xac, 0x6a, 0x9b, 0x65, 0x50, 0x72 }};
+# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIMessageSender : public nsIMessageListenerManager {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult SendAsyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JS::HandleValue transfers, JSContext* cx, uint8_t _argc) = 0;
+
+
+  virtual nsresult GetProcessMessageManager(nsIMessageSender * *aProcessMessageManager) = 0;
+
+};
+
+  template<typename T> struct nsIMessageSender::COMTypeInfo<nsIMessageSender, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageSender::COMTypeInfo<nsIMessageSender, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbb5d79e4, 0xe73c, 0x45e7, { 0x96, 0x51, 0x4d, 0x71, 0x8f, 0x4b, 0x99, 0x4c }};
+# 336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIMessageBroadcaster : public nsIMessageListenerManager {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult BroadcastAsyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, JSContext* cx, uint8_t _argc) = 0;
+
+
+  virtual nsresult GetChildCount(uint32_t *aChildCount) = 0;
+
+
+  virtual nsresult GetChildAt(uint32_t aIndex, nsIMessageListenerManager * *_retval) = 0;
+
+
+  virtual nsresult ReleaseCachedProcesses(void) = 0;
+
+};
+
+  template<typename T> struct nsIMessageBroadcaster::COMTypeInfo<nsIMessageBroadcaster, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageBroadcaster::COMTypeInfo<nsIMessageBroadcaster, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4d7d62ad, 0x4725, 0x4f39, { 0x86, 0xcf, 0x8f, 0xb2, 0x2b, 0xf9, 0xc1, 0xd8 }};
+# 453 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsISyncMessageSender : public nsIMessageSender {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult SendSyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JSContext* cx, uint8_t _argc, JS::MutableHandleValue _retval) = 0;
+
+
+  virtual nsresult SendRpcMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JSContext* cx, uint8_t _argc, JS::MutableHandleValue _retval) = 0;
+
+};
+
+  template<typename T> struct nsISyncMessageSender::COMTypeInfo<nsISyncMessageSender, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISyncMessageSender::COMTypeInfo<nsISyncMessageSender, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0e602c9e, 0x1977, 0x422a, { 0xa8, 0xe4, 0xfe, 0x0d, 0x4a, 0x4f, 0x78, 0xd0 }};
+# 544 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIMessageManagerGlobal : public nsISyncMessageSender {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Dump(const nsAString & aStr) = 0;
+
+
+  virtual nsresult PrivateNoteIntentionalCrash(void) = 0;
+
+
+  virtual nsresult Atob(const nsAString & aAsciiString, nsAString & _retval) = 0;
+
+
+  virtual nsresult Btoa(const nsAString & aBase64Data, nsAString & _retval) = 0;
+
+};
+
+  template<typename T> struct nsIMessageManagerGlobal::COMTypeInfo<nsIMessageManagerGlobal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageManagerGlobal::COMTypeInfo<nsIMessageManagerGlobal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x13f3555f, 0x769e, 0x44ea, { 0xb6, 0x07, 0x52, 0x39, 0x23, 0x0c, 0x31, 0x62 }};
+# 661 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIContentFrameMessageManager : public nsIMessageManagerGlobal {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetContent(mozIDOMWindowProxy * *aContent) = 0;
+
+
+  virtual nsresult GetDocShell(nsIDocShell * *aDocShell) = 0;
+
+};
+
+  template<typename T> struct nsIContentFrameMessageManager::COMTypeInfo<nsIContentFrameMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentFrameMessageManager::COMTypeInfo<nsIContentFrameMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x694e367c, 0xaa25, 0x4446, { 0x84, 0x99, 0x2c, 0x52, 0x7c, 0x4b, 0xd8, 0x38 }};
+# 752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIInProcessContentFrameMessageManager : public nsIContentFrameMessageManager {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsIContent * GetOwnerContent(void) = 0;
+
+
+  virtual void CacheFrameLoader(nsIFrameLoader *aFrameLoader) = 0;
+
+};
+
+  template<typename T> struct nsIInProcessContentFrameMessageManager::COMTypeInfo<nsIInProcessContentFrameMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIInProcessContentFrameMessageManager::COMTypeInfo<nsIInProcessContentFrameMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb39a3324, 0xb574, 0x4f85, { 0x8c, 0xdb, 0x27, 0x4d, 0x04, 0xf8, 0x07, 0xef }};
+# 843 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIContentProcessMessageManager : public nsIMessageManagerGlobal {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetInitialProcessData(JSContext* cx, JS::MutableHandleValue aInitialProcessData) = 0;
+
+};
+
+  template<typename T> struct nsIContentProcessMessageManager::COMTypeInfo<nsIContentProcessMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentProcessMessageManager::COMTypeInfo<nsIContentProcessMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x6d12e467, 0x2446, 0x46db, { 0x99, 0x65, 0xe4, 0xe9, 0x3c, 0xb8, 0x7c, 0xa5 }};
+# 921 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIFrameScriptLoader : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad, bool aRunInGlobalScope) = 0;
+
+
+  virtual nsresult RemoveDelayedFrameScript(const nsAString & aURL) = 0;
+
+
+  virtual nsresult GetDelayedFrameScripts(JSContext* cx, JS::MutableHandleValue _retval) = 0;
+
+};
+
+  template<typename T> struct nsIFrameScriptLoader::COMTypeInfo<nsIFrameScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFrameScriptLoader::COMTypeInfo<nsIFrameScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbf61446b, 0xba24, 0x4b1d, { 0x88, 0xc7, 0x4f, 0x94, 0x72, 0x4b, 0x9c, 0xe1 }};
+# 1025 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIProcessScriptLoader : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult LoadProcessScript(const nsAString & aURL, bool aAllowDelayedLoad) = 0;
+
+
+  virtual nsresult RemoveDelayedProcessScript(const nsAString & aURL) = 0;
+
+
+  virtual nsresult GetDelayedProcessScripts(JSContext* cx, JS::MutableHandleValue _retval) = 0;
+
+};
+
+  template<typename T> struct nsIProcessScriptLoader::COMTypeInfo<nsIProcessScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIProcessScriptLoader::COMTypeInfo<nsIProcessScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x7e1e1a20, 0xb24f, 0x11e4, { 0xab, 0x27, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 }};
+# 1129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
+class nsIGlobalProcessScriptLoader : public nsIProcessScriptLoader {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetInitialProcessData(JSContext* cx, JS::MutableHandleValue aInitialProcessData) = 0;
+
+};
+
+  template<typename T> struct nsIGlobalProcessScriptLoader::COMTypeInfo<nsIGlobalProcessScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIGlobalProcessScriptLoader::COMTypeInfo<nsIGlobalProcessScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5b390753, 0xabb3, 0x49b0, { 0xae, 0x3b, 0xb8, 0x03, 0xda, 0xb5, 0x81, 0x44 }};
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h"
+namespace mozilla {
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h"
+template<class T>
+class AutoRestore
+{
+private:
+  T& mLocation;
+  T mValue;
+
+public:
+  explicit AutoRestore(T& aValue )
+    : mLocation(aValue)
+    , mValue(aValue)
+  {
+    do { } while (0);
+  }
+  ~AutoRestore()
+  {
+    mLocation = mValue;
+  }
+  T SavedValue() const
+  {
+    return mValue;
+  }
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h" 2
+# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
+extern "C" {
+# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
+extern __attribute__((visibility("default"))) char* PR_GetEnv(const char *var);
+# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
+extern __attribute__((visibility("default"))) char* PR_GetEnvSecure(const char *var);
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
+extern __attribute__((visibility("default"))) PRStatus PR_SetEnv(const char *string);
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
+extern __attribute__((visibility("default"))) char ** PR_DuplicateEnvironment(void);
+
+}
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILanguageAtomService.h" 1
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILanguageAtomService.h"
+class nsILanguageAtomService : public nsISupports
+{
+ public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+  virtual nsIAtom* LookupLanguage(const nsACString &aLanguage,
+                                  nsresult *aError = nullptr) = 0;
+  virtual already_AddRefed<nsIAtom>
+  LookupCharSet(const nsACString& aCharSet) = 0;
+
+  virtual nsIAtom* GetLocaleLanguage() = 0;
+
+  virtual nsIAtom* GetLanguageGroup(nsIAtom *aLanguage,
+                                    nsresult *aError = nullptr) = 0;
+};
+
+template<typename T> struct nsILanguageAtomService::COMTypeInfo<nsILanguageAtomService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILanguageAtomService::COMTypeInfo<nsILanguageAtomService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcb3892a0, 0x6a76, 0x461c, { 0xb0, 0x24, 0x23, 0x0e, 0xe3, 0xe0, 0x81, 0x1a }};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h" 2
+
+namespace mozilla {
+
+struct LangGroupFontPrefs {
+
+  LangGroupFontPrefs()
+    : mLangGroup(nullptr)
+    , mMinimumFontSize(0)
+    , mDefaultVariableFont(mozilla::eFamily_serif, 0)
+    , mDefaultFixedFont(mozilla::eFamily_monospace, 0)
+    , mDefaultSerifFont(mozilla::eFamily_serif, 0)
+    , mDefaultSansSerifFont(mozilla::eFamily_sans_serif, 0)
+    , mDefaultMonospaceFont(mozilla::eFamily_monospace, 0)
+    , mDefaultCursiveFont(mozilla::eFamily_cursive, 0)
+    , mDefaultFantasyFont(mozilla::eFamily_fantasy, 0)
+  {}
+
+  void Reset()
+  {
+
+    mNext = nullptr;
+
+
+    mLangGroup = nullptr;
+  }
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+    size_t n = 0;
+    LangGroupFontPrefs* curr = mNext;
+    while (curr) {
+      n += aMallocSizeOf(curr);
+
+
+
+
+
+
+      curr = curr->mNext;
+    }
+    return n;
+  }
+
+  nsCOMPtr<nsIAtom> mLangGroup;
+  nscoord mMinimumFontSize;
+  nsFont mDefaultVariableFont;
+  nsFont mDefaultFixedFont;
+  nsFont mDefaultSerifFont;
+  nsFont mDefaultSansSerifFont;
+  nsFont mDefaultMonospaceFont;
+  nsFont mDefaultCursiveFont;
+  nsFont mDefaultFantasyFont;
+  nsAutoPtr<LangGroupFontPrefs> mNext;
+};
+
+
+
+
+
+
+
+class StaticPresData
+{
+public:
+
+  static void Init();
+  static void Shutdown();
+
+
+
+  static StaticPresData* Get();
+
+
+
+
+
+  const nscoord* GetBorderWidthTable() { return mBorderWidthTable; }
+# 107 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
+  const LangGroupFontPrefs* GetFontPrefsForLangHelper(nsIAtom* aLanguage,
+                                                      const LangGroupFontPrefs* aPrefs) const;
+# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
+  const nsFont* GetDefaultFontHelper(uint8_t aFontID,
+                                     nsIAtom* aLanguage,
+                                     const LangGroupFontPrefs* aPrefs) const;
+
+
+
+
+
+  const nsFont* GetDefaultFont(uint8_t aFontID, nsIAtom* aLanguage) const
+  {
+    do { } while (0);
+    return GetDefaultFontHelper(aFontID, aLanguage, GetFontPrefsForLang(aLanguage));
+  }
+  const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom* aLanguage) const
+  {
+    do { } while (0);
+    return GetFontPrefsForLangHelper(aLanguage, &mStaticLangGroupFontPrefs);
+  }
+
+  void ResetCachedFontPrefs() { mStaticLangGroupFontPrefs.Reset(); }
+
+private:
+  StaticPresData();
+  ~StaticPresData() {}
+
+  nsCOMPtr<nsILanguageAtomService> mLangService;
+  nscoord mBorderWidthTable[3];
+  LangGroupFontPrefs mStaticLangGroupFontPrefs;
+};
+
+}
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
+
+
+class nsAString;
+class nsIPrintSettings;
+class nsDocShell;
+class nsIDocShell;
+class nsIDocument;
+class nsILanguageAtomService;
+class nsITheme;
+class nsIContent;
+class nsIFrame;
+class nsFrameManager;
+class nsILinkHandler;
+class nsIAtom;
+class nsIRunnable;
+class gfxUserFontEntry;
+class gfxUserFontSet;
+class gfxTextPerfMetrics;
+class nsPluginFrame;
+class nsTransitionManager;
+class nsAnimationManager;
+class nsRefreshDriver;
+class nsIWidget;
+class nsDeviceContext;
+class gfxMissingFontRecorder;
+
+namespace mozilla {
+class EffectCompositor;
+class EventStateManager;
+class CounterStyleManager;
+class RestyleManager;
+namespace layers {
+class ContainerLayer;
+class LayerManager;
+}
+namespace dom {
+class Element;
+}
+}
+
+
+enum nsPresContext_CachedBoolPrefType {
+  kPresContext_UseDocumentFonts = 1,
+  kPresContext_UnderlineLinks
+};
+
+
+enum nsPresContext_CachedIntPrefType {
+  kPresContext_ScrollbarSide = 1,
+  kPresContext_BidiDirection
+};
+
+
+
+const uint8_t kPresContext_DefaultVariableFont_ID = 0x00;
+const uint8_t kPresContext_DefaultFixedFont_ID = 0x01;
+# 119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+class nsRootPresContext;
+
+
+
+
+class nsPresContext : public nsIObserver,
+                      public mozilla::SupportsWeakPtr<nsPresContext> {
+public:
+  typedef mozilla::FramePropertyTable FramePropertyTable;
+  typedef mozilla::LangGroupFontPrefs LangGroupFontPrefs;
+  typedef mozilla::ScrollbarStyles ScrollbarStyles;
+  typedef mozilla::StaticPresData StaticPresData;
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsPresContext"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsPresContext>(p)->DeleteCycleCollectable(); } static nsPresContext* Downcast(nsISupports* s) { return static_cast<nsPresContext*>(static_cast<nsPresContext*>(s)); } static nsISupports* Upcast(nsPresContext *p) { return static_cast<nsISupports*>(static_cast<nsPresContext*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsPresContext::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  enum nsPresContextType {
+    eContext_Galley,
+    eContext_PrintPreview,
+    eContext_Print,
+    eContext_PageLayout
+  };
+
+  nsPresContext(nsIDocument* aDocument, nsPresContextType aType);
+
+
+
+
+  nsresult Init(nsDeviceContext* aDeviceContext);
+
+
+
+
+
+  void AttachShell(nsIPresShell* aShell, mozilla::StyleBackendType aBackendType);
+  void DetachShell();
+
+
+  nsPresContextType Type() const { return mType; }
+
+
+
+
+  nsIPresShell* PresShell() const
+  {
+    do { } while(0);
+    return mShell;
+  }
+
+  nsIPresShell* GetPresShell() const { return mShell; }
+
+
+
+
+
+  nsPresContext* GetParentPresContext();
+
+
+
+
+
+  nsPresContext* GetToplevelContentDocumentPresContext();
+# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  nsIWidget* GetNearestWidget(nsPoint* aOffset = nullptr);
+
+
+
+
+
+  nsIWidget* GetRootWidget();
+
+
+
+
+
+
+  nsRootPresContext* GetRootPresContext();
+
+  virtual bool IsRoot() { return false; }
+
+  nsIDocument* Document() const
+  {
+      do { } while(0);
+
+
+      return mDocument;
+  }
+
+
+  mozilla::StyleSetHandle StyleSet() const { return GetPresShell()->StyleSet(); }
+
+  nsFrameManager* FrameManager()
+    { return PresShell()->FrameManager(); }
+
+  nsCSSFrameConstructor* FrameConstructor()
+    { return PresShell()->FrameConstructor(); }
+
+  mozilla::EffectCompositor* EffectCompositor() { return mEffectCompositor; }
+  nsTransitionManager* TransitionManager() { return mTransitionManager; }
+  nsAnimationManager* AnimationManager() { return mAnimationManager; }
+
+  nsRefreshDriver* RefreshDriver() { return mRefreshDriver; }
+
+  mozilla::RestyleManager* RestyleManager() {
+    do { } while (0);
+    return mRestyleManager;
+  }
+
+  mozilla::CounterStyleManager* CounterStyleManager() const {
+    return mCounterStyleManager;
+  }
+# 249 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void RebuildAllStyleData(nsChangeHint aExtraHint, nsRestyleHint aRestyleHint);
+
+
+
+
+  void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint,
+                                    nsRestyleHint aRestyleHint);
+# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void MediaFeatureValuesChanged(nsRestyleHint aRestyleHint,
+                                 nsChangeHint aChangeHint = nsChangeHint(0));
+
+
+
+
+
+  void MediaFeatureValuesChangedAllDocuments(nsRestyleHint aRestyleHint,
+                                             nsChangeHint aChangeHint = nsChangeHint(0));
+
+  void PostMediaFeatureValuesChangedEvent();
+  void HandleMediaFeatureValuesChangedEvent();
+  void FlushPendingMediaFeatureValuesChanged() {
+    if (mPendingMediaFeatureValuesChanged)
+      MediaFeatureValuesChanged(nsRestyleHint(0));
+  }
+
+
+
+
+
+
+  void SizeModeChanged(nsSizeMode aSizeMode);
+
+
+
+
+
+  nsCompatibility CompatibilityMode() const;
+
+
+
+
+  void CompatibilityModeChanged();
+
+
+
+
+  uint16_t ImageAnimationMode() const { return mImageAnimationMode; }
+  virtual void SetImageAnimationModeExternal(uint16_t aMode);
+  void SetImageAnimationModeInternal(uint16_t aMode);
+
+  void SetImageAnimationMode(uint16_t aMode)
+  { SetImageAnimationModeInternal(aMode); }
+# 329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  nsIAtom* Medium() {
+    if (!mIsEmulatingMedia)
+      return mMedium;
+    return mMediaEmulated;
+  }
+
+
+
+
+
+  void EmulateMedium(const nsAString& aMediaType);
+
+
+
+
+  void StopEmulatingMedium();
+
+  void* AllocateFromShell(size_t aSize)
+  {
+    if (mShell)
+      return mShell->AllocateMisc(aSize);
+    return nullptr;
+  }
+
+  void FreeToShell(size_t aSize, void* aFreeChunk)
+  {
+    do { } while(0);
+    if (mShell)
+      mShell->FreeMisc(aSize, aFreeChunk);
+  }
+
+
+
+
+
+
+
+  const nsFont* GetDefaultFont(uint8_t aFontID,
+                               nsIAtom *aLanguage) const
+  {
+    nsIAtom* lang = aLanguage ? aLanguage : mLanguage.get();
+    return StaticPresData::Get()->GetDefaultFontHelper(aFontID, lang,
+                                                       GetFontPrefsForLang(lang));
+  }
+
+
+
+  bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const
+  {
+
+
+    switch (aPrefType) {
+    case kPresContext_UseDocumentFonts:
+      return mUseDocumentFonts;
+    case kPresContext_UnderlineLinks:
+      return mUnderlineLinks;
+    default:
+      do { } while(0);
+    }
+
+    return false;
+  }
+
+
+
+  int32_t GetCachedIntPref(nsPresContext_CachedIntPrefType aPrefType) const
+  {
+
+
+    switch (aPrefType) {
+    case kPresContext_ScrollbarSide:
+      return mPrefScrollbarSide;
+    case kPresContext_BidiDirection:
+      return mPrefBidiDirection;
+    default:
+      do { } while(0);
+    }
+
+    return false;
+  }
+
+
+
+
+  nscolor DefaultColor() const { return mDefaultColor; }
+  nscolor DefaultBackgroundColor() const { return mBackgroundColor; }
+  nscolor DefaultLinkColor() const { return mLinkColor; }
+  nscolor DefaultActiveLinkColor() const { return mActiveLinkColor; }
+  nscolor DefaultVisitedLinkColor() const { return mVisitedLinkColor; }
+  nscolor FocusBackgroundColor() const { return mFocusBackgroundColor; }
+  nscolor FocusTextColor() const { return mFocusTextColor; }
+
+
+
+
+  nscolor BodyTextColor() const { return mBodyTextColor; }
+  void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }
+
+  bool GetUseFocusColors() const { return mUseFocusColors; }
+  uint8_t FocusRingWidth() const { return mFocusRingWidth; }
+  bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }
+  uint8_t GetFocusRingStyle() const { return mFocusRingStyle; }
+
+  void SetContainer(nsIDocShell* aContainer);
+
+  virtual nsISupports* GetContainerWeakExternal() const;
+  nsISupports* GetContainerWeakInternal() const;
+
+  nsISupports* GetContainerWeak() const
+  { return GetContainerWeakInternal(); }
+
+
+
+
+
+  nsIDocShell* GetDocShell() const;
+
+
+  void SetLinkHandler(nsILinkHandler* aHandler) { mLinkHandler = aHandler; }
+  nsILinkHandler* GetLinkHandler() { return mLinkHandler; }
+
+
+
+
+
+
+  virtual void Detach();
+
+
+
+
+
+
+
+  nsRect GetVisibleArea() const { return mVisibleArea; }
+
+
+
+
+
+  void SetVisibleArea(const nsRect& r) {
+    if (!r.IsEqualEdges(mVisibleArea)) {
+      mVisibleArea = r;
+
+      if (!IsPaginated() && HasCachedStyleData()) {
+        mPendingViewportChange = true;
+        PostMediaFeatureValuesChangedEvent();
+      }
+    }
+  }
+
+
+
+
+
+  bool IsPaginated() const { return mPaginated; }
+
+
+
+
+
+  void SetPaginatedScrolling(bool aResult);
+
+
+
+
+
+  bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }
+
+
+
+
+  nsSize GetPageSize() { return mPageSize; }
+  void SetPageSize(nsSize aSize) { mPageSize = aSize; }
+
+
+
+
+
+
+  bool IsRootPaginatedDocument() { return mIsRootPaginatedDocument; }
+  void SetIsRootPaginatedDocument(bool aIsRootPaginatedDocument)
+    { mIsRootPaginatedDocument = aIsRootPaginatedDocument; }
+
+
+
+
+
+
+
+  float GetPageScale() { return mPageScale; }
+  void SetPageScale(float aScale) { mPageScale = aScale; }
+# 530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  float GetPrintPreviewScale() { return mPPScale; }
+  void SetPrintPreviewScale(float aScale) { mPPScale = aScale; }
+
+  nsDeviceContext* DeviceContext() const { return mDeviceContext; }
+  mozilla::EventStateManager* EventStateManager() { return mEventManager; }
+  nsIAtom* GetLanguageFromCharset() const { return mLanguage; }
+  already_AddRefed<nsIAtom> GetContentLanguage() const;
+
+
+
+
+
+  float GetSystemFontScale() const { return mSystemFontScale; }
+  void SetSystemFontScale(float aFontScale) {
+    do { } while (0);
+    if (aFontScale == mSystemFontScale || IsPrintingOrPrintPreview()) {
+      return;
+    }
+
+    mSystemFontScale = aFontScale;
+    UpdateEffectiveTextZoom();
+  }
+# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  float TextZoom() const { return mTextZoom; }
+  void SetTextZoom(float aZoom) {
+    do { } while (0);
+    if (aZoom == mTextZoom)
+      return;
+
+    mTextZoom = aZoom;
+    UpdateEffectiveTextZoom();
+  }
+
+protected:
+  void UpdateEffectiveTextZoom();
+
+public:
+# 584 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  float EffectiveTextZoom() const { return mEffectiveTextZoom; }
+
+
+
+
+
+
+
+  int32_t MinFontSize(nsIAtom *aLanguage) const {
+    const LangGroupFontPrefs *prefs = GetFontPrefsForLang(aLanguage);
+    return std::max(mBaseMinFontSize, prefs->mMinimumFontSize);
+  }
+
+
+
+
+
+  int32_t BaseMinFontSize() const {
+    return mBaseMinFontSize;
+  }
+
+
+
+
+
+  void SetBaseMinFontSize(int32_t aMinFontSize) {
+    if (aMinFontSize == mBaseMinFontSize)
+      return;
+
+    mBaseMinFontSize = aMinFontSize;
+    if (HasCachedStyleData()) {
+
+
+      MediaFeatureValuesChanged(eRestyle_ForceDescendants,
+                                nsChangeHint(nsChangeHint(nsChangeHint_RepaintFrame | nsChangeHint_SyncFrameView | nsChangeHint_SchedulePaint) | nsChangeHint(nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition| nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow)));
+    }
+  }
+
+  float GetFullZoom() { return mFullZoom; }
+  void SetFullZoom(float aZoom);
+
+  float GetOverrideDPPX() { return mOverrideDPPX; }
+  void SetOverrideDPPX(float aDPPX);
+
+  nscoord GetAutoQualityMinFontSize() {
+    return DevPixelsToAppUnits(mAutoQualityMinFontSizePixelsPref);
+  }
+# 641 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  gfxSize ScreenSizeInchesForFontInflation(bool* aChanged = nullptr);
+
+  static int32_t AppUnitsPerCSSPixel() { return mozilla::AppUnitsPerCSSPixel(); }
+  int32_t AppUnitsPerDevPixel() const;
+  static int32_t AppUnitsPerCSSInch() { return mozilla::AppUnitsPerCSSInch(); }
+
+  static nscoord CSSPixelsToAppUnits(int32_t aPixels)
+  { return NSToCoordRoundWithClamp(float(aPixels) *
+             float(AppUnitsPerCSSPixel())); }
+
+  static nscoord CSSPixelsToAppUnits(float aPixels)
+  { return NSToCoordRoundWithClamp(aPixels *
+             float(AppUnitsPerCSSPixel())); }
+
+  static int32_t AppUnitsToIntCSSPixels(nscoord aAppUnits)
+  { return NSAppUnitsToIntPixels(aAppUnits,
+             float(AppUnitsPerCSSPixel())); }
+
+  static float AppUnitsToFloatCSSPixels(nscoord aAppUnits)
+  { return NSAppUnitsToFloatPixels(aAppUnits,
+             float(AppUnitsPerCSSPixel())); }
+
+  static double AppUnitsToDoubleCSSPixels(nscoord aAppUnits)
+  { return NSAppUnitsToDoublePixels(aAppUnits,
+             double(AppUnitsPerCSSPixel())); }
+
+  nscoord DevPixelsToAppUnits(int32_t aPixels) const
+  { return NSIntPixelsToAppUnits(aPixels, AppUnitsPerDevPixel()); }
+
+  int32_t AppUnitsToDevPixels(nscoord aAppUnits) const
+  { return NSAppUnitsToIntPixels(aAppUnits,
+             float(AppUnitsPerDevPixel())); }
+
+  float AppUnitsToFloatDevPixels(nscoord aAppUnits)
+  { return aAppUnits / float(AppUnitsPerDevPixel()); }
+
+  int32_t CSSPixelsToDevPixels(int32_t aPixels)
+  { return AppUnitsToDevPixels(CSSPixelsToAppUnits(aPixels)); }
+
+  float CSSPixelsToDevPixels(float aPixels)
+  {
+    return NSAppUnitsToFloatPixels(CSSPixelsToAppUnits(aPixels),
+                                   float(AppUnitsPerDevPixel()));
+  }
+
+  int32_t DevPixelsToIntCSSPixels(int32_t aPixels)
+  { return AppUnitsToIntCSSPixels(DevPixelsToAppUnits(aPixels)); }
+
+  float DevPixelsToFloatCSSPixels(int32_t aPixels)
+  { return AppUnitsToFloatCSSPixels(DevPixelsToAppUnits(aPixels)); }
+
+  mozilla::CSSToLayoutDeviceScale CSSToDevPixelScale() const
+  {
+    return mozilla::CSSToLayoutDeviceScale(
+        float(AppUnitsPerCSSPixel()) / float(AppUnitsPerDevPixel()));
+  }
+
+
+  nscoord GfxUnitsToAppUnits(gfxFloat aGfxUnits) const;
+
+  gfxFloat AppUnitsToGfxUnits(nscoord aAppUnits) const;
+
+  gfxRect AppUnitsToGfxUnits(const nsRect& aAppRect) const
+  { return gfxRect(AppUnitsToGfxUnits(aAppRect.x),
+                   AppUnitsToGfxUnits(aAppRect.y),
+                   AppUnitsToGfxUnits(aAppRect.width),
+                   AppUnitsToGfxUnits(aAppRect.height)); }
+
+  static nscoord CSSTwipsToAppUnits(float aTwips)
+  { return NSToCoordRoundWithClamp(
+      mozilla::AppUnitsPerCSSInch() * NSTwipsToUnits((aTwips), 1.0f / 72.0f)); }
+
+
+  static nsMargin CSSTwipsToAppUnits(const nsIntMargin &marginInTwips)
+  { return nsMargin(CSSTwipsToAppUnits(float(marginInTwips.top)),
+                    CSSTwipsToAppUnits(float(marginInTwips.right)),
+                    CSSTwipsToAppUnits(float(marginInTwips.bottom)),
+                    CSSTwipsToAppUnits(float(marginInTwips.left))); }
+
+  static nscoord CSSPointsToAppUnits(float aPoints)
+  { return NSToCoordRound(aPoints * mozilla::AppUnitsPerCSSInch() /
+                          72.0f); }
+
+  nscoord RoundAppUnitsToNearestDevPixels(nscoord aAppUnits) const
+  { return DevPixelsToAppUnits(AppUnitsToDevPixels(aAppUnits)); }
+# 737 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  nsIContent* UpdateViewportScrollbarStylesOverride();
+  const ScrollbarStyles& GetViewportScrollbarStylesOverride()
+  {
+    return mViewportStyleScrollbar;
+  }
+
+
+
+
+
+  bool ElementWouldPropagateScrollbarStyles(mozilla::dom::Element* aElement);
+
+
+
+
+  bool GetBackgroundImageDraw() const { return mDrawImageBackground; }
+  void SetBackgroundImageDraw(bool aCanDraw)
+  {
+    mDrawImageBackground = aCanDraw;
+  }
+
+  bool GetBackgroundColorDraw() const { return mDrawColorBackground; }
+  void SetBackgroundColorDraw(bool aCanDraw)
+  {
+    mDrawColorBackground = aCanDraw;
+  }
+# 772 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  bool BidiEnabled() const { return BidiEnabledInternal(); }
+
+
+
+  virtual bool BidiEnabledExternal() const;
+  bool BidiEnabledInternal() const;
+
+
+
+
+
+
+  void SetBidiEnabled() const;
+# 800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void SetVisualMode(bool aIsVisual)
+  {
+    mIsVisual = aIsVisual;
+  }
+
+
+
+
+
+
+  bool IsVisualMode() const { return mIsVisual; }
+
+  enum class InteractionType : uint32_t {
+    eClickInteraction,
+    eKeyInteraction,
+    eMouseMoveInteraction,
+    eScrollInteraction
+  };
+
+  void RecordInteractionTime(InteractionType aType,
+                             const mozilla::TimeStamp& aTimeStamp);
+
+  void DisableInteractionTimeRecording()
+  {
+    mInteractionTimeEnabled = false;
+  }
+
+
+
+
+
+
+  void SetBidi(uint32_t aBidiOptions,
+                           bool aForceRestyle = false);
+
+
+
+
+
+
+  uint32_t GetBidi() const;
+
+
+
+
+  void SetIsRenderingOnlySelection(bool aResult)
+  {
+    mIsRenderingOnlySelection = aResult;
+  }
+
+  bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }
+
+  bool IsTopLevelWindowInactive();
+
+
+
+
+  nsITheme* GetTheme();
+
+
+
+
+
+
+
+  void ThemeChanged();
+
+
+
+
+
+
+
+  void UIResolutionChanged();
+
+
+
+
+  void UIResolutionChangedSync();
+
+
+
+
+  void SysColorChanged();
+
+
+  void SetPrintSettings(nsIPrintSettings *aPrintSettings);
+
+  nsIPrintSettings* GetPrintSettings() { return mPrintSettings; }
+
+
+  FramePropertyTable* PropertyTable() { return &mPropertyTable; }
+
+
+
+
+
+  bool EnsureVisible();
+
+
+  void CountReflows(const char * aName,
+                                nsIFrame * aFrame);
+
+
+  void RestyledElement() {
+    ++mElementsRestyled;
+  }
+  void ConstructedFrame() {
+    ++mFramesConstructed;
+  }
+  void ReflowedFrame() {
+    ++mFramesReflowed;
+  }
+
+  uint64_t ElementsRestyledCount() {
+    return mElementsRestyled;
+  }
+  uint64_t FramesConstructedCount() {
+    return mFramesConstructed;
+  }
+  uint64_t FramesReflowedCount() {
+    return mFramesReflowed;
+  }
+
+
+
+
+
+  void SetTelemetryScrollY(nscoord aScrollY)
+  {
+    nscoord delta = abs(aScrollY - mTelemetryScrollLastY);
+    mTelemetryScrollLastY = aScrollY;
+
+    mTelemetryScrollTotalY += delta;
+    if (aScrollY > mTelemetryScrollMaxY) {
+      mTelemetryScrollMaxY = aScrollY;
+    }
+  }
+  nscoord TelemetryScrollMaxY() const
+  {
+    return mTelemetryScrollMaxY;
+  }
+  nscoord TelemetryScrollTotalY() const
+  {
+    return mTelemetryScrollTotalY;
+  }
+
+  static nscoord GetBorderWidthForKeyword(unsigned int aBorderWidthKeyword)
+  {
+
+
+    static const nscoord kBorderWidths[] = {
+      CSSPixelsToAppUnits(1),
+      CSSPixelsToAppUnits(3),
+      CSSPixelsToAppUnits(5)
+    };
+    do { } while (0);
+
+    return kBorderWidths[aBorderWidthKeyword];
+  }
+
+  gfxTextPerfMetrics *GetTextPerfMetrics() { return mTextPerf; }
+
+  bool IsDynamic() { return (mType == eContext_PageLayout || mType == eContext_Galley); }
+  bool IsScreen() { return (mMedium == nsGkAtoms::screen ||
+                              mType == eContext_PageLayout ||
+                              mType == eContext_PrintPreview); }
+  bool IsPrintingOrPrintPreview() { return (mType == eContext_Print || mType == eContext_PrintPreview); }
+
+
+  bool IsChrome() const { return mIsChrome; }
+  bool IsChromeOriginImage() const { return mIsChromeOriginImage; }
+  void UpdateIsChrome();
+
+
+  bool HasAuthorSpecifiedRules(const nsIFrame *aFrame,
+                               uint32_t ruleTypeMask) const;
+
+
+  bool UseDocumentColors() const {
+    do { } while (0);
+
+    return mUseDocumentColors;
+  }
+
+
+  void SetPaintFlashing(bool aPaintFlashing) {
+    mPaintFlashing = aPaintFlashing;
+    mPaintFlashingInitialized = true;
+  }
+
+
+
+  bool GetPaintFlashing() const;
+
+  bool SuppressingResizeReflow() const { return mSuppressResizeReflow; }
+
+  gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true);
+
+
+
+
+  void UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont = nullptr);
+
+  gfxMissingFontRecorder *MissingFontRecorder() { return mMissingFonts; }
+  void NotifyMissingFonts();
+
+  void FlushCounterStyles();
+  void RebuildCounterStyles();
+
+
+
+
+  void EnsureSafeToHandOutCSSRules();
+
+
+
+
+
+  void NotifyInvalidation(uint64_t aTransactionId, const nsRect& aRect);
+
+  void NotifyInvalidation(uint64_t aTransactionId, const nsIntRect& aRect);
+  void NotifyDidPaintForSubtree(uint64_t aTransactionId = 0,
+                                const mozilla::TimeStamp& aTimeStamp = mozilla::TimeStamp());
+  void FireDOMPaintEvent(nsTArray<nsRect>* aList, uint64_t aTransactionId,
+                         mozilla::TimeStamp aTimeStamp = mozilla::TimeStamp());
+
+
+
+  static void NotifySubDocInvalidation(mozilla::layers::ContainerLayer* aContainer,
+                                       const nsIntRegion& aRegion);
+  void SetNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
+  static void ClearNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
+  bool IsDOMPaintEventPending();
+
+
+
+
+  uint64_t GetRestyleGeneration() const;
+
+
+
+
+  bool HasPendingRestyleOrReflow();
+
+
+
+
+
+  void NotifyFontFaceSetOnRefresh();
+# 1060 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void ReflowStarted(bool aInterruptible);
+
+
+
+
+  class InterruptPreventer;
+  friend class InterruptPreventer;
+  class InterruptPreventer {
+  public:
+    explicit InterruptPreventer(nsPresContext* aCtx) :
+      mCtx(aCtx),
+      mInterruptsEnabled(aCtx->mInterruptsEnabled),
+      mHasPendingInterrupt(aCtx->mHasPendingInterrupt)
+    {
+      mCtx->mInterruptsEnabled = false;
+      mCtx->mHasPendingInterrupt = false;
+    }
+    ~InterruptPreventer() {
+      mCtx->mInterruptsEnabled = mInterruptsEnabled;
+      mCtx->mHasPendingInterrupt = mHasPendingInterrupt;
+    }
+
+  private:
+    nsPresContext* mCtx;
+    bool mInterruptsEnabled;
+    bool mHasPendingInterrupt;
+  };
+# 1096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  bool CheckForInterrupt(nsIFrame* aFrame);
+
+
+
+
+  bool HasPendingInterrupt() { return mHasPendingInterrupt; }
+
+
+
+
+
+  void SetPendingInterruptFromTest() { mPendingInterruptFromTest = true; }
+
+
+
+
+
+
+
+  nsIFrame* GetPrimaryFrameFor(nsIContent* aContent);
+
+  void NotifyDestroyingFrame(nsIFrame* aFrame)
+  {
+    PropertyTable()->DeleteAllFor(aFrame);
+  }
+
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  bool IsRootContentDocument() const;
+
+  bool HadNonBlankPaint() const {
+    return mHadNonBlankPaint;
+  }
+
+  void NotifyNonBlankPaint();
+
+  bool IsGlyph() const {
+    return mIsGlyph;
+  }
+
+  void SetIsGlyph(bool aValue) {
+    mIsGlyph = aValue;
+  }
+
+  bool UsesRootEMUnits() const {
+    return mUsesRootEMUnits;
+  }
+
+  void SetUsesRootEMUnits(bool aValue) {
+    mUsesRootEMUnits = aValue;
+  }
+
+  bool UsesExChUnits() const {
+    return mUsesExChUnits;
+  }
+
+  void SetUsesExChUnits(bool aValue) {
+    mUsesExChUnits = aValue;
+  }
+
+  bool UsesViewportUnits() const {
+    return mUsesViewportUnits;
+  }
+
+  void SetUsesViewportUnits(bool aValue) {
+    mUsesViewportUnits = aValue;
+  }
+
+
+
+
+  bool ExistThrottledUpdates() const {
+    return mExistThrottledUpdates;
+  }
+
+  void SetExistThrottledUpdates(bool aExistThrottledUpdates) {
+    mExistThrottledUpdates = aExistThrottledUpdates;
+  }
+
+  bool IsDeviceSizePageSize();
+
+  bool HasWarnedAboutPositionedTableParts() const {
+    return mHasWarnedAboutPositionedTableParts;
+  }
+
+  void SetHasWarnedAboutPositionedTableParts() {
+    mHasWarnedAboutPositionedTableParts = true;
+  }
+
+  bool HasWarnedAboutTooLargeDashedOrDottedRadius() const {
+    return mHasWarnedAboutTooLargeDashedOrDottedRadius;
+  }
+
+  void SetHasWarnedAboutTooLargeDashedOrDottedRadius() {
+    mHasWarnedAboutTooLargeDashedOrDottedRadius = true;
+  }
+
+protected:
+  friend class nsRunnableMethod<nsPresContext>;
+  void ThemeChangedInternal();
+  void SysColorChangedInternal();
+
+
+  void UIResolutionChangedInternal();
+
+
+
+  void UIResolutionChangedInternalScale(double aScale);
+
+
+
+
+  static bool
+  UIResolutionChangedSubdocumentCallback(nsIDocument* aDocument, void* aData);
+
+  void SetImgAnimations(nsIContent *aParent, uint16_t aMode);
+  void SetSMILAnimations(nsIDocument *aDoc, uint16_t aNewMode,
+                                     uint16_t aOldMode);
+  void GetDocumentColorPreferences();
+
+  void PreferenceChanged(const char* aPrefName);
+  static void PrefChangedCallback(const char*, void*);
+
+  void UpdateAfterPreferencesChanged();
+  static void PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
+
+  void GetUserPreferences();
+
+
+
+
+
+  const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom *aLanguage) const
+  {
+    nsIAtom* lang = aLanguage ? aLanguage : mLanguage.get();
+    return StaticPresData::Get()->GetFontPrefsForLangHelper(lang, &mLangGroupFontPrefs);
+  }
+
+  void UpdateCharSet(const nsCString& aCharSet);
+
+  static bool NotifyDidPaintSubdocumentCallback(nsIDocument* aDocument, void* aData);
+
+public:
+  void DoChangeCharSet(const nsCString& aCharSet);
+
+
+
+
+  bool MayHavePaintEventListener();
+
+
+
+
+
+
+  bool MayHavePaintEventListenerInSubDocument();
+# 1264 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void InvalidatePaintedLayers();
+
+protected:
+
+  void Destroy();
+
+  void AppUnitsPerDevPixelChanged();
+
+  void HandleRebuildCounterStyles() {
+    mPostedFlushCounterStyles = false;
+    FlushCounterStyles();
+  }
+
+  bool HavePendingInputEvent();
+
+
+  bool HasCachedStyleData();
+
+
+
+  already_AddRefed<nsITimer> CreateTimer(nsTimerCallbackFunc aCallback,
+                                         const char* aName,
+                                         uint32_t aDelay);
+
+
+
+
+
+  nsPresContextType mType;
+
+
+  nsIPresShell* mShell;
+  nsCOMPtr<nsIDocument> mDocument;
+  RefPtr<nsDeviceContext> mDeviceContext;
+
+
+
+
+  RefPtr<mozilla::EventStateManager> mEventManager;
+  RefPtr<nsRefreshDriver> mRefreshDriver;
+  RefPtr<mozilla::EffectCompositor> mEffectCompositor;
+  RefPtr<nsTransitionManager> mTransitionManager;
+  RefPtr<nsAnimationManager> mAnimationManager;
+  RefPtr<mozilla::RestyleManager> mRestyleManager;
+  RefPtr<mozilla::CounterStyleManager> mCounterStyleManager;
+  nsIAtom* mMedium;
+  nsCOMPtr<nsIAtom> mMediaEmulated;
+
+
+
+  nsILinkHandler* mLinkHandler;
+
+
+
+
+
+
+  nsCOMPtr<nsIAtom> mLanguage;
+
+public:
+
+
+
+
+
+  bool mInflationDisabledForShrinkWrap;
+
+protected:
+
+  mozilla::WeakPtr<nsDocShell> mContainer;
+
+
+  int32_t mBaseMinFontSize;
+  float mSystemFontScale;
+  float mTextZoom;
+  float mEffectiveTextZoom;
+  float mFullZoom;
+  float mOverrideDPPX;
+  gfxSize mLastFontInflationScreenSize;
+
+  int32_t mCurAppUnitsPerDevPixel;
+  int32_t mAutoQualityMinFontSizePixelsPref;
+
+  nsCOMPtr<nsITheme> mTheme;
+  nsCOMPtr<nsILanguageAtomService> mLangService;
+  nsCOMPtr<nsIPrintSettings> mPrintSettings;
+  nsCOMPtr<nsITimer> mPrefChangedTimer;
+
+  FramePropertyTable mPropertyTable;
+
+  struct TransactionInvalidations {
+    uint64_t mTransactionId;
+    nsTArray<nsRect> mInvalidations;
+  };
+  AutoTArray<TransactionInvalidations, 4> mTransactions;
+
+
+  nsAutoPtr<gfxTextPerfMetrics> mTextPerf;
+
+  nsAutoPtr<gfxMissingFontRecorder> mMissingFonts;
+
+  nsRect mVisibleArea;
+  nsSize mPageSize;
+  float mPageScale;
+  float mPPScale;
+
+  nscolor mDefaultColor;
+  nscolor mBackgroundColor;
+
+  nscolor mLinkColor;
+  nscolor mActiveLinkColor;
+  nscolor mVisitedLinkColor;
+
+  nscolor mFocusBackgroundColor;
+  nscolor mFocusTextColor;
+
+  nscolor mBodyTextColor;
+
+  ScrollbarStyles mViewportStyleScrollbar;
+  uint8_t mFocusRingWidth;
+
+  bool mExistThrottledUpdates;
+
+  uint16_t mImageAnimationMode;
+  uint16_t mImageAnimationModePref;
+
+
+
+
+
+
+  LangGroupFontPrefs mLangGroupFontPrefs;
+
+  nscoord mBorderWidthTable[3];
+
+  uint32_t mInterruptChecksToSkip;
+
+
+
+  uint64_t mElementsRestyled;
+  uint64_t mFramesConstructed;
+  uint64_t mFramesReflowed;
+
+  mozilla::TimeStamp mReflowStartTime;
+
+
+
+  mozilla::TimeStamp mFirstNonBlankPaintTime;
+  mozilla::TimeStamp mFirstClickTime;
+  mozilla::TimeStamp mFirstKeyTime;
+  mozilla::TimeStamp mFirstMouseMoveTime;
+  mozilla::TimeStamp mFirstScrollTime;
+  bool mInteractionTimeEnabled;
+
+
+  mozilla::TimeStamp mLastStyleUpdateForAllAnimations;
+
+  nscoord mTelemetryScrollLastY;
+  nscoord mTelemetryScrollMaxY;
+  nscoord mTelemetryScrollTotalY;
+
+  unsigned mHasPendingInterrupt : 1;
+  unsigned mPendingInterruptFromTest : 1;
+  unsigned mInterruptsEnabled : 1;
+  unsigned mUseDocumentFonts : 1;
+  unsigned mUseDocumentColors : 1;
+  unsigned mUnderlineLinks : 1;
+  unsigned mSendAfterPaintToContent : 1;
+  unsigned mUseFocusColors : 1;
+  unsigned mFocusRingOnAnything : 1;
+  unsigned mFocusRingStyle : 1;
+  unsigned mDrawImageBackground : 1;
+  unsigned mDrawColorBackground : 1;
+  unsigned mNeverAnimate : 1;
+  unsigned mIsRenderingOnlySelection : 1;
+  unsigned mPaginated : 1;
+  unsigned mCanPaginatedScroll : 1;
+  unsigned mDoScaledTwips : 1;
+  unsigned mIsRootPaginatedDocument : 1;
+  unsigned mPrefBidiDirection : 1;
+  unsigned mPrefScrollbarSide : 2;
+  unsigned mPendingSysColorChanged : 1;
+  unsigned mPendingThemeChanged : 1;
+  unsigned mPendingUIResolutionChanged : 1;
+  unsigned mPendingMediaFeatureValuesChanged : 1;
+  unsigned mPrefChangePendingNeedsReflow : 1;
+  unsigned mIsEmulatingMedia : 1;
+
+
+  unsigned mIsGlyph : 1;
+
+
+  unsigned mUsesRootEMUnits : 1;
+
+  unsigned mUsesExChUnits : 1;
+
+  unsigned mUsesViewportUnits : 1;
+
+
+  unsigned mPendingViewportChange : 1;
+
+
+  unsigned mCounterStylesDirty : 1;
+
+  unsigned mPostedFlushCounterStyles: 1;
+
+
+
+  unsigned mSuppressResizeReflow : 1;
+
+  unsigned mIsVisual : 1;
+
+  unsigned mFireAfterPaintEvents : 1;
+
+  unsigned mIsChrome : 1;
+  unsigned mIsChromeOriginImage : 1;
+
+
+
+  mutable unsigned mPaintFlashing : 1;
+  mutable unsigned mPaintFlashingInitialized : 1;
+
+  unsigned mHasWarnedAboutPositionedTableParts : 1;
+
+  unsigned mHasWarnedAboutTooLargeDashedOrDottedRadius : 1;
+
+
+  unsigned mQuirkSheetAdded : 1;
+
+
+  unsigned mNeedsPrefUpdate : 1;
+
+
+  unsigned mHadNonBlankPaint : 1;
+# 1509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+protected:
+
+  virtual ~nsPresContext();
+
+  nscolor MakeColorPref(const nsString& aColor);
+
+  void LastRelease();
+# 1527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+};
+
+class nsRootPresContext final : public nsPresContext {
+public:
+  nsRootPresContext(nsIDocument* aDocument, nsPresContextType aType);
+  virtual ~nsRootPresContext();
+  virtual void Detach() override;
+
+
+
+
+
+  void EnsureEventualDidPaintEvent(uint64_t aTransactionId);
+
+
+
+
+
+  void CancelDidPaintTimers(uint64_t aTransactionId);
+
+
+
+
+  void CancelAllDidPaintTimers();
+
+
+
+
+
+
+
+  void RegisterPluginForGeometryUpdates(nsIContent* aPlugin);
+
+
+
+
+
+  void UnregisterPluginForGeometryUpdates(nsIContent* aPlugin);
+
+  bool NeedToComputePluginGeometryUpdates()
+  {
+    return mRegisteredPlugins.Count() > 0;
+  }
+# 1581 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
+  void ComputePluginGeometryUpdates(nsIFrame* aFrame,
+                                    nsDisplayListBuilder* aBuilder,
+                                    nsDisplayList* aList);
+
+
+
+
+
+
+  void ApplyPluginGeometryUpdates();
+
+
+
+
+
+  void CollectPluginGeometryUpdates(mozilla::layers::LayerManager* aLayerManager);
+
+  virtual bool IsRoot() override { return true; }
+
+
+
+
+
+
+  void IncrementDOMGeneration() { mDOMGeneration++; }
+
+
+
+
+  uint32_t GetDOMGeneration() { return mDOMGeneration; }
+
+
+
+
+
+
+  void AddWillPaintObserver(nsIRunnable* aRunnable);
+
+
+
+
+  void FlushWillPaintObservers();
+
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+protected:
+
+
+
+  void InitApplyPluginGeometryTimer();
+
+
+
+  void CancelApplyPluginGeometryTimer();
+
+  class RunWillPaintObservers : public mozilla::Runnable {
+  public:
+    explicit RunWillPaintObservers(nsRootPresContext* aPresContext)
+      : Runnable("nsPresContextType::RunWillPaintObservers")
+      , mPresContext(aPresContext) {}
+    void Revoke() { mPresContext = nullptr; }
+    virtual nsresult Run() override
+    {
+      if (mPresContext) {
+        mPresContext->FlushWillPaintObservers();
+      }
+      return NS_OK;
+    }
+
+    nsRootPresContext* mPresContext;
+  };
+
+  friend class nsPresContext;
+
+  struct NotifyDidPaintTimer {
+    uint64_t mTransactionId;
+    nsCOMPtr<nsITimer> mTimer;
+  };
+  AutoTArray<NotifyDidPaintTimer, 4> mNotifyDidPaintTimers;
+
+  nsCOMPtr<nsITimer> mApplyPluginGeometryTimer;
+  nsTHashtable<nsRefPtrHashKey<nsIContent> > mRegisteredPlugins;
+  nsTArray<nsCOMPtr<nsIRunnable> > mWillPaintObservers;
+  nsRevocableEventPtr<RunWillPaintObservers> mWillPaintFallbackEvent;
+  uint32_t mDOMGeneration;
+};
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h"
+class gfxContext;
+class nsPresContext;
+class nsRegion;
+
+namespace mozilla {
+namespace gfx {
+class DrawTarget;
+class Path;
+}
+}
+
+namespace mozilla {
+
+
+
+
+
+
+
+class DisplayItemClip {
+  typedef mozilla::gfx::Color Color;
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::gfx::Path Path;
+
+public:
+  struct RoundedRect {
+    nsRect mRect;
+
+    nscoord mRadii[8];
+
+    RoundedRect operator+(const nsPoint& aOffset) const {
+      RoundedRect r = *this;
+      r.mRect += aOffset;
+      return r;
+    }
+    bool operator==(const RoundedRect& aOther) const {
+      if (!mRect.IsEqualInterior(aOther.mRect)) {
+        return false;
+      }
+
+      int32_t corner54 = mozilla::eCornerTopLeftX; for (mozilla::HalfCorner corner; corner54 <= mozilla::eCornerBottomLeftY && (corner = mozilla::HalfCorner(corner54), true); ++corner54) {
+        if (mRadii[corner] != aOther.mRadii[corner]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    bool operator!=(const RoundedRect& aOther) const {
+      return !(*this == aOther);
+    }
+  };
+
+
+  DisplayItemClip() : mHaveClipRect(false) {}
+
+  void SetTo(const nsRect& aRect);
+  void SetTo(const nsRect& aRect, const nscoord* aRadii);
+  void SetTo(const nsRect& aRect, const nsRect& aRoundedRect, const nscoord* aRadii);
+  void IntersectWith(const DisplayItemClip& aOther);
+
+
+
+
+  void ApplyTo(gfxContext* aContext, nsPresContext* aPresContext,
+               uint32_t aBegin = 0, uint32_t aEnd = (4294967295U));
+
+  void ApplyRectTo(gfxContext* aContext, int32_t A2D) const;
+
+
+
+  void ApplyRoundedRectClipsTo(gfxContext* aContext, int32_t A2DPRInt32,
+                               uint32_t aBegin, uint32_t aEnd) const;
+
+
+  void FillIntersectionOfRoundedRectClips(gfxContext* aContext,
+                                          const Color& aColor,
+                                          int32_t aAppUnitsPerDevPixel,
+                                          uint32_t aBegin,
+                                          uint32_t aEnd) const;
+
+  already_AddRefed<Path> MakeRoundedRectPath(DrawTarget& aDrawTarget,
+                                                  int32_t A2D,
+                                                  const RoundedRect &aRoundRect) const;
+
+
+
+
+
+
+  bool MayIntersect(const nsRect& aRect) const;
+
+
+
+
+  nsRect ApproximateIntersectInward(const nsRect& aRect) const;
+# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h"
+  bool ComputeRegionInClips(DisplayItemClip* aOldClip,
+                            const nsPoint& aShift,
+                            nsRegion* aCombined) const;
+
+
+
+
+
+  bool IsRectClippedByRoundedCorner(const nsRect& aRect) const;
+
+
+
+  bool IsRectAffectedByClip(const nsRect& aRect) const;
+  bool IsRectAffectedByClip(const nsIntRect& aRect, float aXScale, float aYScale, int32_t A2D) const;
+
+
+  nsRect NonRoundedIntersection() const;
+
+
+
+  nsRect ApplyNonRoundedIntersection(const nsRect& aRect) const;
+
+
+  void RemoveRoundedCorners();
+
+
+
+  void AddOffsetAndComputeDifference(uint32_t aStart, const nsPoint& aPoint, const nsRect& aBounds,
+                                     const DisplayItemClip& aOther, uint32_t aOtherStart, const nsRect& aOtherBounds,
+                                     nsRegion* aDifference);
+
+  bool operator==(const DisplayItemClip& aOther) const {
+    return mHaveClipRect == aOther.mHaveClipRect &&
+           (!mHaveClipRect || mClipRect.IsEqualInterior(aOther.mClipRect)) &&
+           mRoundedClipRects == aOther.mRoundedClipRects;
+  }
+  bool operator!=(const DisplayItemClip& aOther) const {
+    return !(*this == aOther);
+  }
+
+  bool HasClip() const { return mHaveClipRect; }
+  const nsRect& GetClipRect() const
+  {
+    do { } while(0);
+    return mClipRect;
+  }
+
+  void MoveBy(nsPoint aPoint);
+
+  nsCString ToString() const;
+
+
+
+
+
+  uint32_t GetCommonRoundedRectCount(const DisplayItemClip& aOther,
+                                     uint32_t aMax) const;
+  uint32_t GetRoundedRectCount() const { return mRoundedClipRects.Length(); }
+  void AppendRoundedRects(nsTArray<RoundedRect>* aArray, uint32_t aCount) const;
+
+  static const DisplayItemClip& NoClip();
+
+  static void Shutdown();
+
+private:
+  nsRect mClipRect;
+  nsTArray<RoundedRect> mRoundedClipRects;
+
+
+  bool mHaveClipRect;
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h"
+class nsScrollbarFrame;
+class nsIFrame;
+
+class nsIScrollbarMediator : public nsQueryFrame
+{
+public:
+  static const nsQueryFrame::FrameIID kFrameIID = nsQueryFrame::nsIScrollbarMediator_id; typedef nsIScrollbarMediator Has_NS_DECL_QUERYFRAME_TARGET;
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h"
+  enum ScrollSnapMode { DISABLE_SNAP, ENABLE_SNAP };
+
+
+
+
+
+
+  virtual void ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
+  virtual void ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
+  virtual void ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection,
+                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
+
+
+
+
+
+
+  virtual void RepeatButtonScroll(nsScrollbarFrame* aScrollbar) = 0;
+
+
+
+
+
+
+
+  virtual void ThumbMoved(nsScrollbarFrame* aScrollbar,
+                          nscoord aOldPos,
+                          nscoord aNewPos) = 0;
+
+
+
+
+  virtual void ScrollbarReleased(nsScrollbarFrame* aScrollbar) = 0;
+  virtual void VisibilityChanged(bool aVisible) = 0;
+
+
+
+
+
+  virtual nsIFrame* GetScrollbarBox(bool aVertical) = 0;
+
+
+
+
+  virtual void ScrollbarActivityStarted() const = 0;
+  virtual void ScrollbarActivityStopped() const = 0;
+
+  virtual bool IsScrollbarOnRight() const = 0;
+
+
+
+
+
+  virtual bool ShouldSuppressScrollbarRepaints() const = 0;
+};
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 1 3
+# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+      struct __xfer_bufptrs;
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+
+    protected:
+
+      ios_base::openmode _M_mode;
+
+
+      __string_type _M_string;
+
+    public:
+# 99 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+# 112 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
+      { _M_stringbuf_init(__mode); }
+
+
+      basic_stringbuf(const basic_stringbuf&) = delete;
+
+      basic_stringbuf(basic_stringbuf&& __rhs)
+      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
+      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
+
+
+
+      basic_stringbuf&
+      operator=(const basic_stringbuf&) = delete;
+
+      basic_stringbuf&
+      operator=(basic_stringbuf&& __rhs)
+      {
+ __xfer_bufptrs __st{__rhs, this};
+ const __streambuf_type& __base = __rhs;
+ __streambuf_type::operator=(__base);
+ this->pubimbue(__rhs.getloc());
+ _M_mode = __rhs._M_mode;
+ _M_string = std::move(__rhs._M_string);
+ __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
+ return *this;
+      }
+
+      void
+      swap(basic_stringbuf& __rhs)
+      {
+ __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
+ __xfer_bufptrs __r_st{__rhs, this};
+ __streambuf_type& __base = __rhs;
+ __streambuf_type::swap(__base);
+ __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
+ std::swap(_M_mode, __rhs._M_mode);
+ std::swap(_M_string, __rhs._M_string);
+      }
+# 165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      __string_type
+      str() const
+      {
+ __string_type __ret;
+ if (this->pptr())
+   {
+
+     if (this->pptr() > this->egptr())
+       __ret = __string_type(this->pbase(), this->pptr());
+     else
+        __ret = __string_type(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      void
+      str(const __string_type& __s)
+      {
+
+
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+
+    protected:
+
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+# 242 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+
+
+
+
+
+
+     _M_string.clear();
+
+
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+
+
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+
+
+
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+
+
+
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+
+    private:
+
+
+
+
+      struct __xfer_bufptrs
+      {
+ __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
+ : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
+ {
+   const _CharT* __str = __from._M_string.data();
+   if (__from.eback())
+     {
+     _M_goff[0] = __from.eback() - __str;
+     _M_goff[1] = __from.gptr() - __str;
+     _M_goff[2] = __from.egptr() - __str;
+     }
+   if (__from.pbase())
+     {
+       _M_poff[0] = __from.pbase() - __str;
+       _M_poff[1] = __from.pptr() - __from.pbase();
+       _M_poff[2] = __from.epptr() - __str;
+     }
+ }
+
+ ~__xfer_bufptrs()
+ {
+   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
+   if (_M_goff[0] != -1)
+     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
+   if (_M_poff[0] != -1)
+     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
+ }
+
+ basic_stringbuf* _M_to;
+ off_type _M_goff[3];
+ off_type _M_poff[3];
+      };
+# 343 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
+      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
+      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
+      { }
+
+    };
+# 366 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 402 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_istringstream(ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 420 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_istringstream()
+      { }
+
+
+      basic_istringstream(const basic_istringstream&) = delete;
+
+      basic_istringstream(basic_istringstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __istream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_istringstream&
+      operator=(const basic_istringstream&) = delete;
+
+      basic_istringstream&
+      operator=(basic_istringstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_istringstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 471 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 510 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 546 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 564 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_ostringstream()
+      { }
+
+
+      basic_ostringstream(const basic_ostringstream&) = delete;
+
+      basic_ostringstream(basic_ostringstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __ostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_ostringstream&
+      operator=(const basic_ostringstream&) = delete;
+
+      basic_ostringstream&
+      operator=(basic_ostringstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ostringstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 615 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 654 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 689 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+# 705 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_stringstream()
+      { }
+
+
+      basic_stringstream(const basic_stringstream&) = delete;
+
+      basic_stringstream(basic_stringstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __iostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_stringstream&
+      operator=(const basic_stringstream&) = delete;
+
+      basic_stringstream&
+      operator=(basic_stringstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_stringstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 756 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
+  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+}
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+
+
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+
+      const __size_type __capacity = _M_string.capacity();
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+
+
+
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+# 110 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 3
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp;
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+
+   _M_update_egptr();
+
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+
+
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->setg(this->eback(), this->eback() + __newoffi,
+    this->egptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       _M_pbump(this->pbase(), this->epptr(), __newoffo);
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->setg(this->eback(), this->eback() + __pos,
+      this->egptr());
+       if (__testout)
+  _M_pbump(this->pbase(), this->epptr(), __pos);
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+
+      if (__base != _M_string.data())
+ {
+
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   _M_pbump(__base, __endp, __o);
+
+
+
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+ {
+   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+   __off -= __gnu_cxx::__numeric_traits<int>::__max;
+ }
+      this->pbump(__off);
+    }
+
+
+
+
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+
+
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+
+
+
+
+}
+# 814 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 2 3
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 2
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/LoggingConstants.h" 1
+
+
+
+
+
+
+
+
+namespace mozilla {
+namespace gfx {
+
+
+
+
+const int LOG_CRITICAL = 1;
+const int LOG_WARNING = 2;
+const int LOG_DEBUG = 3;
+const int LOG_DEBUG_PRLOG = 4;
+const int LOG_EVERYTHING = 5;
+
+
+
+
+const int LOG_DEFAULT = LOG_CRITICAL;
+
+
+}
+}
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 2
+
+
+extern mozilla::LogModule* GetGFX2DLog();
+
+
+namespace mozilla {
+namespace gfx {
+
+
+inline mozilla::LogLevel PRLogLevelForLevel(int aLevel) {
+  switch (aLevel) {
+  case LOG_CRITICAL:
+    return LogLevel::Error;
+  case LOG_WARNING:
+    return LogLevel::Warning;
+  case LOG_DEBUG:
+    return LogLevel::Debug;
+  case LOG_DEBUG_PRLOG:
+    return LogLevel::Debug;
+  case LOG_EVERYTHING:
+    return LogLevel::Error;
+  }
+  return LogLevel::Debug;
+}
+
+
+class LoggingPrefs
+{
+public:
+
+
+
+
+
+  static int32_t sGfxLogLevel;
+};
+# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+enum class LogReason : int {
+  MustBeMoreThanThis = -1,
+
+
+  D3D11InvalidCallDeviceRemoved = 0,
+  D3D11InvalidCall,
+  D3DLockTimeout,
+  D3D10FinalizeFrame,
+  D3D11FinalizeFrame,
+  D3D10SyncLock,
+  D3D11SyncLock,
+  D2D1NoWriteMap,
+  JobStatusError,
+  FilterInputError,
+  FilterInputData,
+  FilterInputRect,
+  FilterInputSet,
+  FilterInputFormat,
+  FilterNodeD2D1Target,
+  FilterNodeD2D1Backend,
+  SourceSurfaceIncompatible,
+  GlyphAllocFailedCairo,
+  GlyphAllocFailedCG,
+  InvalidRect,
+  CannotDraw3D,
+  IncompatibleBasicTexturedEffect,
+  InvalidFont,
+  PAllocTextureBackendMismatch,
+  GetFontFileDataFailed,
+  MessageChannelCloseFailure,
+  MessageChannelInvalidHandle,
+  TextureAliveAfterShutdown,
+  InvalidContext,
+  InvalidCommandList,
+  AsyncTransactionTimeout,
+  TextureCreation,
+  InvalidCacheSurface,
+  AlphaWithBasicClient,
+  UnbalancedClipStack,
+  ProcessingError,
+  InvalidDrawTarget,
+  NativeFontResourceNotFound,
+
+  MustBeLessThanThis = 101,
+};
+
+struct BasicLogger
+{
+
+
+
+  static bool ShouldOutputMessage(int aLevel) {
+    if (LoggingPrefs::sGfxLogLevel >= aLevel) {
+
+
+
+
+      if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
+        return true;
+      } else
+
+      if ((LoggingPrefs::sGfxLogLevel >= LOG_DEBUG_PRLOG) ||
+                 (aLevel < LOG_DEBUG)) {
+        return true;
+      }
+
+    }
+    return false;
+  }
+
+
+  static void CrashAction(LogReason aReason) {}
+
+  static void OutputMessage(const std::string &aString,
+                            int aLevel,
+                            bool aNoNewline) {
+# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+    if (LoggingPrefs::sGfxLogLevel >= aLevel) {
+
+
+
+
+      if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
+        do { if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) { mozilla::detail::log_print(GetGFX2DLog(), PRLogLevelForLevel(aLevel), "%s%s", aString.c_str(), aNoNewline ? "" : "\n"); } } while (0);
+      } else
+
+      if ((LoggingPrefs::sGfxLogLevel >= LOG_DEBUG_PRLOG) ||
+                 (aLevel < LOG_DEBUG)) {
+        printf("%s%s", aString.c_str(), aNoNewline ? "" : "\n");
+      }
+
+    }
+  }
+};
+
+struct CriticalLogger {
+  static void OutputMessage(const std::string &aString, int aLevel, bool aNoNewline);
+  static void CrashAction(LogReason aReason);
+};
+
+
+
+
+
+typedef mozilla::Tuple<int32_t,std::string,double> LoggingRecordEntry;
+
+
+
+typedef std::vector<LoggingRecordEntry> LoggingRecord;
+class LogForwarder {
+public:
+  virtual ~LogForwarder() {}
+  virtual void Log(const std::string &aString) = 0;
+  virtual void CrashAction(LogReason aReason) = 0;
+  virtual bool UpdateStringsVector(const std::string& aString) = 0;
+
+
+  virtual LoggingRecord LoggingRecordCopy() = 0;
+};
+
+class NoLog
+{
+public:
+  NoLog() {}
+  ~NoLog() {}
+
+
+               NoLog(const NoLog&) {}
+
+  template<typename T>
+  NoLog &operator <<(const T &aLogText) { return *this; }
+};
+
+enum class LogOptions : int {
+  NoNewline = 0x01,
+  AutoPrefix = 0x02,
+  AssertOnCall = 0x04,
+  CrashAction = 0x08,
+};
+
+template<typename T>
+struct Hexa {
+  explicit Hexa(T aVal) : mVal(aVal) {}
+  T mVal;
+};
+template<typename T>
+Hexa<T> hexa(T val) { return Hexa<T>(val); }
+
+template<int L, typename Logger = BasicLogger>
+class Log
+{
+public:
+
+
+  static int DefaultOptions(bool aWithAssert = true) {
+    return (int(LogOptions::AutoPrefix) |
+            (aWithAssert ? int(LogOptions::AssertOnCall) : 0));
+  }
+
+
+
+
+
+  explicit Log(int aOptions = Log::DefaultOptions(L == LOG_CRITICAL),
+               LogReason aReason = LogReason::MustBeMoreThanThis)
+  : mOptions(0)
+  , mLogIt(false)
+  {
+    Init(aOptions, BasicLogger::ShouldOutputMessage(L), aReason);
+  }
+
+  ~Log() {
+    Flush();
+  }
+
+  void Flush() {
+    if ((__builtin_expect(!!(!LogIt()), 1))) return;
+
+    std::string str = mMessage.str();
+    if (!str.empty()) {
+      WriteLog(str);
+    }
+    mMessage.str("");
+  }
+
+  Log &operator <<(char aChar) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aChar;
+    }
+    return *this;
+  }
+  Log &operator <<(const std::string &aLogText) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aLogText;
+    }
+    return *this;
+  }
+  Log &operator <<(const char aStr[]) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << static_cast<const char*>(aStr);
+    }
+    return *this;
+  }
+  Log &operator <<(bool aBool) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << (aBool ? "true" : "false");
+    }
+    return *this;
+  }
+  Log &operator <<(int aInt) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aInt;
+    }
+    return *this;
+  }
+  Log &operator <<(unsigned int aInt) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aInt;
+    }
+    return *this;
+  }
+  Log &operator <<(long aLong) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aLong;
+    }
+    return *this;
+  }
+  Log &operator <<(unsigned long aLong) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aLong;
+    }
+    return *this;
+  }
+  Log &operator <<(long long aLong) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aLong;
+    }
+    return *this;
+  }
+  Log &operator <<(unsigned long long aLong) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aLong;
+    }
+    return *this;
+  }
+  Log &operator <<(Float aFloat) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aFloat;
+    }
+    return *this;
+  }
+  Log &operator <<(double aDouble) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << aDouble;
+    }
+    return *this;
+  }
+  template <typename T, typename Sub, typename Coord>
+  Log &operator <<(const BasePoint<T, Sub, Coord>& aPoint) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << "Point" << aPoint;
+    }
+    return *this;
+  }
+  template <typename T, typename Sub>
+  Log &operator <<(const BaseSize<T, Sub>& aSize) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << "Size(" << aSize.width << "," << aSize.height << ")";
+    }
+    return *this;
+  }
+  template <typename T, typename Sub, typename Point, typename SizeT, typename Margin>
+  Log &operator <<(const BaseRect<T, Sub, Point, SizeT, Margin>& aRect) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << "Rect" << aRect;
+    }
+    return *this;
+  }
+  Log &operator<<(const Matrix& aMatrix) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << "Matrix(" << aMatrix._11 << " " << aMatrix._12 << " ; " << aMatrix._21 << " " << aMatrix._22 << " ; " << aMatrix._31 << " " << aMatrix._32 << ")";
+    }
+    return *this;
+  }
+  template<typename T>
+  Log &operator<<(Hexa<T> aHex) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      mMessage << std::showbase << std::hex
+               << aHex.mVal
+               << std::noshowbase << std::dec;
+    }
+    return *this;
+  }
+
+  Log& operator<<(SurfaceFormat aFormat) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      switch(aFormat) {
+        case SurfaceFormat::B8G8R8A8:
+          mMessage << "SurfaceFormat::B8G8R8A8";
+          break;
+        case SurfaceFormat::B8G8R8X8:
+          mMessage << "SurfaceFormat::B8G8R8X8";
+          break;
+        case SurfaceFormat::R8G8B8A8:
+          mMessage << "SurfaceFormat::R8G8B8A8";
+          break;
+        case SurfaceFormat::R8G8B8X8:
+          mMessage << "SurfaceFormat::R8G8B8X8";
+          break;
+        case SurfaceFormat::R5G6B5_UINT16:
+          mMessage << "SurfaceFormat::R5G6B5_UINT16";
+          break;
+        case SurfaceFormat::A8:
+          mMessage << "SurfaceFormat::A8";
+          break;
+        case SurfaceFormat::YUV:
+          mMessage << "SurfaceFormat::YUV";
+          break;
+        case SurfaceFormat::UNKNOWN:
+          mMessage << "SurfaceFormat::UNKNOWN";
+          break;
+        default:
+          mMessage << "Invalid SurfaceFormat (" << (int)aFormat << ")";
+          break;
+      }
+    }
+    return *this;
+  }
+
+  Log& operator<<(SurfaceType aType) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      switch(aType) {
+        case SurfaceType::DATA:
+          mMessage << "SurfaceType::DATA";
+          break;
+        case SurfaceType::D2D1_BITMAP:
+          mMessage << "SurfaceType::D2D1_BITMAP";
+          break;
+        case SurfaceType::D2D1_DRAWTARGET:
+          mMessage << "SurfaceType::D2D1_DRAWTARGET";
+          break;
+        case SurfaceType::CAIRO:
+          mMessage << "SurfaceType::CAIRO";
+          break;
+        case SurfaceType::CAIRO_IMAGE:
+          mMessage << "SurfaceType::CAIRO_IMAGE";
+          break;
+        case SurfaceType::COREGRAPHICS_IMAGE:
+          mMessage << "SurfaceType::COREGRAPHICS_IMAGE";
+          break;
+        case SurfaceType::COREGRAPHICS_CGCONTEXT:
+          mMessage << "SurfaceType::COREGRAPHICS_CGCONTEXT";
+          break;
+        case SurfaceType::SKIA:
+          mMessage << "SurfaceType::SKIA";
+          break;
+        case SurfaceType::DUAL_DT:
+          mMessage << "SurfaceType::DUAL_DT";
+          break;
+        case SurfaceType::D2D1_1_IMAGE:
+          mMessage << "SurfaceType::D2D1_1_IMAGE";
+          break;
+        case SurfaceType::RECORDING:
+          mMessage << "SurfaceType::RECORDING";
+          break;
+        case SurfaceType::TILED:
+          mMessage << "SurfaceType::TILED";
+          break;
+        case SurfaceType::DATA_SHARED:
+          mMessage << "SurfaceType::DATA_SHARED";
+          break;
+        default:
+          mMessage << "Invalid SurfaceType (" << (int)aType << ")";
+          break;
+      }
+    }
+    return *this;
+  }
+
+  inline bool LogIt() const { return mLogIt; }
+  inline bool NoNewline() const { return mOptions & int(LogOptions::NoNewline); }
+  inline bool AutoPrefix() const { return mOptions & int(LogOptions::AutoPrefix); }
+  inline bool ValidReason() const { return (int)mReason > (int)LogReason::MustBeMoreThanThis && (int)mReason < (int)LogReason::MustBeLessThanThis; }
+
+
+
+               Log(const Log& log) { Init(log.mOptions, false, log.mReason); }
+
+private:
+
+  void Init(int aOptions, bool aLogIt, LogReason aReason) {
+    mOptions = aOptions;
+    mReason = aReason;
+    mLogIt = aLogIt;
+    if (mLogIt) {
+      if (AutoPrefix()) {
+        if (mOptions & int(LogOptions::AssertOnCall)) {
+          mMessage << "[GFX" << L;
+        } else {
+          mMessage << "[GFX" << L << "-";
+        }
+      }
+      if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
+        mMessage << " " << (int)mReason;
+      }
+      if (AutoPrefix()) {
+        mMessage << "]: ";
+      }
+    }
+  }
+
+  void WriteLog(const std::string &aString) {
+    if ((__builtin_expect(!!(LogIt()), 0))) {
+      Logger::OutputMessage(aString, L, NoNewline());
+# 522 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+      if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
+        Logger::CrashAction(mReason);
+      }
+    }
+  }
+
+  std::stringstream mMessage;
+  int mOptions;
+  LogReason mReason;
+  bool mLogIt;
+};
+
+typedef Log<LOG_DEBUG> DebugLog;
+typedef Log<LOG_WARNING> WarningLog;
+typedef Log<LOG_CRITICAL, CriticalLogger> CriticalLog;
+# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+inline bool MOZ2D_error_if_impl(bool aCondition, const char* aExpr,
+                                const char* aFile, int32_t aLine)
+{
+  if ((__builtin_expect(!!(aCondition), 0))) {
+    mozilla::gfx::CriticalLog() << aExpr << " at " << aFile << ":" << aLine;
+  }
+  return aCondition;
+}
+# 618 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
+const int INDENT_PER_LEVEL = 2;
+
+class TreeLog
+{
+public:
+  explicit TreeLog(const std::string& aPrefix = "")
+        : mLog(int(LogOptions::NoNewline)),
+          mPrefix(aPrefix),
+          mDepth(0),
+          mStartOfLine(true),
+          mConditionedOnPref(false),
+          mPrefFunction(nullptr) {}
+
+  template <typename T>
+  TreeLog& operator<<(const T& aObject) {
+    if (mConditionedOnPref && !mPrefFunction()) {
+      return *this;
+    }
+    if (mStartOfLine) {
+      mLog << '[' << mPrefix << "] " << std::string(mDepth * INDENT_PER_LEVEL, ' ');
+      mStartOfLine = false;
+    }
+    mLog << aObject;
+    if (EndsInNewline(aObject)) {
+
+
+      mLog.Flush();
+      mStartOfLine = true;
+    }
+    return *this;
+  }
+
+  void IncreaseIndent() { ++mDepth; }
+  void DecreaseIndent() {
+    do { } while (0);
+    --mDepth;
+  }
+
+  void ConditionOnPrefFunction(bool(*aPrefFunction)()) {
+    mConditionedOnPref = true;
+    mPrefFunction = aPrefFunction;
+  }
+private:
+  Log<LOG_DEBUG> mLog;
+  std::string mPrefix;
+  uint32_t mDepth;
+  bool mStartOfLine;
+  bool mConditionedOnPref;
+  bool (*mPrefFunction)();
+
+  template <typename T>
+  static bool EndsInNewline(const T& aObject) {
+    return false;
+  }
+
+  static bool EndsInNewline(const std::string& aString) {
+    return !aString.empty() && aString[aString.length() - 1] == '\n';
+  }
+
+  static bool EndsInNewline(char aChar) {
+    return aChar == '\n';
+  }
+
+  static bool EndsInNewline(const char* aString) {
+    return EndsInNewline(std::string(aString));
+  }
+};
+
+class TreeAutoIndent
+{
+public:
+  explicit TreeAutoIndent(TreeLog& aTreeLog) : mTreeLog(aTreeLog) {
+    mTreeLog.IncreaseIndent();
+  }
+
+  TreeAutoIndent(const TreeAutoIndent& aTreeAutoIndent) :
+      TreeAutoIndent(aTreeAutoIndent.mTreeLog) {
+    mTreeLog.IncreaseIndent();
+  }
+
+  TreeAutoIndent& operator=(const TreeAutoIndent& aTreeAutoIndent) = delete;
+
+  ~TreeAutoIndent() {
+    mTreeLog.DecreaseIndent();
+  }
+private:
+  TreeLog& mTreeLog;
+};
+
+}
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h" 2
+
+
+
+
+
+namespace IPC {
+template <typename T> struct ParamTraits;
+}
+
+namespace mozilla {
+namespace layers {
+
+
+
+
+
+struct ScrollUpdateInfo {
+  uint32_t mScrollGeneration;
+  CSSPoint mScrollOffset;
+};
+
+
+
+
+
+
+
+struct FrameMetrics {
+  friend struct IPC::ParamTraits<mozilla::layers::FrameMetrics>;
+public:
+
+  typedef uint64_t ViewID;
+  static const ViewID NULL_SCROLL_ID;
+  static const ViewID START_SCROLL_ID = 2;
+
+
+  enum ScrollOffsetUpdateType : uint8_t {
+    eNone,
+    eMainThread,
+    ePending,
+
+
+    eUserAction,
+
+
+
+    eRestore,
+
+
+
+
+    eSentinel
+  };
+
+  FrameMetrics()
+    : mScrollId(NULL_SCROLL_ID)
+    , mPresShellResolution(1)
+    , mCompositionBounds(0, 0, 0, 0)
+    , mDisplayPort(0, 0, 0, 0)
+    , mCriticalDisplayPort(0, 0, 0, 0)
+    , mScrollableRect(0, 0, 0, 0)
+    , mCumulativeResolution()
+    , mDevPixelsPerCSSPixel(1)
+    , mScrollOffset(0, 0)
+    , mZoom()
+    , mScrollGeneration(0)
+    , mSmoothScrollOffset(0, 0)
+    , mRootCompositionSize(0, 0)
+    , mDisplayPortMargins(0, 0, 0, 0)
+    , mPresShellId(-1)
+    , mViewport(0, 0, 0, 0)
+    , mExtraResolution()
+    , mPaintRequestTime()
+    , mScrollUpdateType(eNone)
+    , mIsRootContent(false)
+    , mDoSmoothScroll(false)
+    , mUseDisplayPortMargins(false)
+    , mIsScrollInfoLayer(false)
+  {
+  }
+
+
+
+  bool operator==(const FrameMetrics& aOther) const
+  {
+
+    return mScrollId == aOther.mScrollId &&
+           mPresShellResolution == aOther.mPresShellResolution &&
+           mCompositionBounds.IsEqualEdges(aOther.mCompositionBounds) &&
+           mDisplayPort.IsEqualEdges(aOther.mDisplayPort) &&
+           mCriticalDisplayPort.IsEqualEdges(aOther.mCriticalDisplayPort) &&
+           mScrollableRect.IsEqualEdges(aOther.mScrollableRect) &&
+           mCumulativeResolution == aOther.mCumulativeResolution &&
+           mDevPixelsPerCSSPixel == aOther.mDevPixelsPerCSSPixel &&
+           mScrollOffset == aOther.mScrollOffset &&
+
+           mScrollGeneration == aOther.mScrollGeneration &&
+           mSmoothScrollOffset == aOther.mSmoothScrollOffset &&
+           mRootCompositionSize == aOther.mRootCompositionSize &&
+           mDisplayPortMargins == aOther.mDisplayPortMargins &&
+           mPresShellId == aOther.mPresShellId &&
+           mViewport.IsEqualEdges(aOther.mViewport) &&
+           mExtraResolution == aOther.mExtraResolution &&
+           mPaintRequestTime == aOther.mPaintRequestTime &&
+           mScrollUpdateType == aOther.mScrollUpdateType &&
+           mIsRootContent == aOther.mIsRootContent &&
+           mDoSmoothScroll == aOther.mDoSmoothScroll &&
+           mUseDisplayPortMargins == aOther.mUseDisplayPortMargins &&
+           mIsScrollInfoLayer == aOther.mIsScrollInfoLayer;
+  }
+
+  bool operator!=(const FrameMetrics& aOther) const
+  {
+    return !operator==(aOther);
+  }
+
+  bool IsScrollable() const
+  {
+    return mScrollId != NULL_SCROLL_ID;
+  }
+
+  CSSToScreenScale2D DisplayportPixelsPerCSSPixel() const
+  {
+
+
+
+
+
+
+
+    return mZoom * ParentLayerToLayerScale(1.0f) / mExtraResolution;
+  }
+
+  CSSToLayerScale2D LayersPixelsPerCSSPixel() const
+  {
+    return mDevPixelsPerCSSPixel * mCumulativeResolution;
+  }
+
+
+  LayerToParentLayerScale GetAsyncZoom() const
+  {
+
+
+    return (mZoom / LayersPixelsPerCSSPixel()).ToScaleFactor();
+  }
+
+
+
+
+
+
+
+  CSSRect GetExpandedScrollableRect() const
+  {
+    CSSRect scrollableRect = mScrollableRect;
+    CSSSize compSize = CalculateCompositedSizeInCssPixels();
+    if (scrollableRect.width < compSize.width) {
+      scrollableRect.x = std::max(0.f,
+                                  scrollableRect.x - (compSize.width - scrollableRect.width));
+      scrollableRect.width = compSize.width;
+    }
+
+    if (scrollableRect.height < compSize.height) {
+      scrollableRect.y = std::max(0.f,
+                                  scrollableRect.y - (compSize.height - scrollableRect.height));
+      scrollableRect.height = compSize.height;
+    }
+
+    return scrollableRect;
+  }
+
+  CSSSize CalculateCompositedSizeInCssPixels() const
+  {
+    if (GetZoom() == CSSToParentLayerScale2D(0, 0)) {
+      return CSSSize();
+    }
+    return mCompositionBounds.Size() / GetZoom();
+  }
+
+  CSSRect CalculateCompositedRectInCssPixels() const
+  {
+    if (GetZoom() == CSSToParentLayerScale2D(0, 0)) {
+      return CSSRect();
+    }
+    return mCompositionBounds / GetZoom();
+  }
+
+  CSSSize CalculateBoundedCompositedSizeInCssPixels() const
+  {
+    CSSSize size = CalculateCompositedSizeInCssPixels();
+    size.width = std::min(size.width, mRootCompositionSize.width);
+    size.height = std::min(size.height, mRootCompositionSize.height);
+    return size;
+  }
+
+  CSSRect CalculateScrollRange() const
+  {
+    CSSSize scrollPortSize = CalculateCompositedSizeInCssPixels();
+    CSSRect scrollRange = mScrollableRect;
+    scrollRange.width = std::max(scrollRange.width - scrollPortSize.width, 0.0f);
+    scrollRange.height = std::max(scrollRange.height - scrollPortSize.height, 0.0f);
+    return scrollRange;
+  }
+
+  void ScrollBy(const CSSPoint& aPoint)
+  {
+    mScrollOffset += aPoint;
+  }
+
+  void ZoomBy(float aScale)
+  {
+    ZoomBy(gfxSize(aScale, aScale));
+  }
+
+  void ZoomBy(const gfxSize& aScale)
+  {
+    mZoom.xScale *= aScale.width;
+    mZoom.yScale *= aScale.height;
+  }
+
+  void CopyScrollInfoFrom(const FrameMetrics& aOther)
+  {
+    mScrollOffset = aOther.mScrollOffset;
+    mScrollGeneration = aOther.mScrollGeneration;
+  }
+
+  void CopySmoothScrollInfoFrom(const FrameMetrics& aOther)
+  {
+    mSmoothScrollOffset = aOther.mSmoothScrollOffset;
+    mScrollGeneration = aOther.mScrollGeneration;
+    mDoSmoothScroll = aOther.mDoSmoothScroll;
+  }
+
+  void UpdatePendingScrollInfo(const ScrollUpdateInfo& aInfo)
+  {
+    mScrollOffset = aInfo.mScrollOffset;
+    mScrollGeneration = aInfo.mScrollGeneration;
+    mScrollUpdateType = ePending;
+  }
+
+  void SetRepaintDrivenByUserAction(bool aUserAction)
+  {
+    mScrollUpdateType = aUserAction ? eUserAction : eNone;
+  }
+
+public:
+  void SetPresShellResolution(float aPresShellResolution)
+  {
+    mPresShellResolution = aPresShellResolution;
+  }
+
+  float GetPresShellResolution() const
+  {
+    return mPresShellResolution;
+  }
+
+  void SetCompositionBounds(const ParentLayerRect& aCompositionBounds)
+  {
+    mCompositionBounds = aCompositionBounds;
+  }
+
+  const ParentLayerRect& GetCompositionBounds() const
+  {
+    return mCompositionBounds;
+  }
+
+  void SetDisplayPort(const CSSRect& aDisplayPort)
+  {
+    mDisplayPort = aDisplayPort;
+  }
+
+  const CSSRect& GetDisplayPort() const
+  {
+    return mDisplayPort;
+  }
+
+  void SetCriticalDisplayPort(const CSSRect& aCriticalDisplayPort)
+  {
+    mCriticalDisplayPort = aCriticalDisplayPort;
+  }
+
+  const CSSRect& GetCriticalDisplayPort() const
+  {
+    return mCriticalDisplayPort;
+  }
+
+  void SetCumulativeResolution(const LayoutDeviceToLayerScale2D& aCumulativeResolution)
+  {
+    mCumulativeResolution = aCumulativeResolution;
+  }
+
+  const LayoutDeviceToLayerScale2D& GetCumulativeResolution() const
+  {
+    return mCumulativeResolution;
+  }
+
+  void SetDevPixelsPerCSSPixel(const CSSToLayoutDeviceScale& aDevPixelsPerCSSPixel)
+  {
+    mDevPixelsPerCSSPixel = aDevPixelsPerCSSPixel;
+  }
+
+  const CSSToLayoutDeviceScale& GetDevPixelsPerCSSPixel() const
+  {
+    return mDevPixelsPerCSSPixel;
+  }
+
+  void SetIsRootContent(bool aIsRootContent)
+  {
+    mIsRootContent = aIsRootContent;
+  }
+
+  bool IsRootContent() const
+  {
+    return mIsRootContent;
+  }
+
+  void SetScrollOffset(const CSSPoint& aScrollOffset)
+  {
+    mScrollOffset = aScrollOffset;
+  }
+
+  const CSSPoint& GetScrollOffset() const
+  {
+    return mScrollOffset;
+  }
+
+  void SetSmoothScrollOffset(const CSSPoint& aSmoothScrollDestination)
+  {
+    mSmoothScrollOffset = aSmoothScrollDestination;
+  }
+
+  const CSSPoint& GetSmoothScrollOffset() const
+  {
+    return mSmoothScrollOffset;
+  }
+
+  void SetZoom(const CSSToParentLayerScale2D& aZoom)
+  {
+    mZoom = aZoom;
+  }
+
+  const CSSToParentLayerScale2D& GetZoom() const
+  {
+    return mZoom;
+  }
+
+  void SetScrollOffsetUpdated(uint32_t aScrollGeneration)
+  {
+    mScrollUpdateType = eMainThread;
+    mScrollGeneration = aScrollGeneration;
+  }
+
+  void SetScrollOffsetRestored(uint32_t aScrollGeneration)
+  {
+    mScrollUpdateType = eRestore;
+    mScrollGeneration = aScrollGeneration;
+  }
+
+  void SetSmoothScrollOffsetUpdated(int32_t aScrollGeneration)
+  {
+    mDoSmoothScroll = true;
+    mScrollGeneration = aScrollGeneration;
+  }
+
+  ScrollOffsetUpdateType GetScrollUpdateType() const
+  {
+    return mScrollUpdateType;
+  }
+
+  bool GetScrollOffsetUpdated() const
+  {
+    return mScrollUpdateType != eNone;
+  }
+
+  bool GetDoSmoothScroll() const
+  {
+    return mDoSmoothScroll;
+  }
+
+  uint32_t GetScrollGeneration() const
+  {
+    return mScrollGeneration;
+  }
+
+  ViewID GetScrollId() const
+  {
+    return mScrollId;
+  }
+
+  void SetScrollId(ViewID scrollId)
+  {
+    mScrollId = scrollId;
+  }
+
+  void SetRootCompositionSize(const CSSSize& aRootCompositionSize)
+  {
+    mRootCompositionSize = aRootCompositionSize;
+  }
+
+  const CSSSize& GetRootCompositionSize() const
+  {
+    return mRootCompositionSize;
+  }
+
+  void SetDisplayPortMargins(const ScreenMargin& aDisplayPortMargins)
+  {
+    mDisplayPortMargins = aDisplayPortMargins;
+  }
+
+  const ScreenMargin& GetDisplayPortMargins() const
+  {
+    return mDisplayPortMargins;
+  }
+
+  void SetUseDisplayPortMargins(bool aValue)
+  {
+    mUseDisplayPortMargins = aValue;
+  }
+
+  bool GetUseDisplayPortMargins() const
+  {
+    return mUseDisplayPortMargins;
+  }
+
+  uint32_t GetPresShellId() const
+  {
+    return mPresShellId;
+  }
+
+  void SetPresShellId(uint32_t aPresShellId)
+  {
+    mPresShellId = aPresShellId;
+  }
+
+  void SetViewport(const CSSRect& aViewport)
+  {
+    mViewport = aViewport;
+  }
+
+  const CSSRect& GetViewport() const
+  {
+    return mViewport;
+  }
+
+  void SetExtraResolution(const ScreenToLayerScale2D& aExtraResolution)
+  {
+    mExtraResolution = aExtraResolution;
+  }
+
+  const ScreenToLayerScale2D& GetExtraResolution() const
+  {
+    return mExtraResolution;
+  }
+
+  const CSSRect& GetScrollableRect() const
+  {
+    return mScrollableRect;
+  }
+
+  void SetScrollableRect(const CSSRect& aScrollableRect)
+  {
+    mScrollableRect = aScrollableRect;
+  }
+
+  void SetPaintRequestTime(const TimeStamp& aTime) {
+    mPaintRequestTime = aTime;
+  }
+  const TimeStamp& GetPaintRequestTime() const {
+    return mPaintRequestTime;
+  }
+
+  void SetIsScrollInfoLayer(bool aIsScrollInfoLayer) {
+    mIsScrollInfoLayer = aIsScrollInfoLayer;
+  }
+  bool IsScrollInfoLayer() const {
+    return mIsScrollInfoLayer;
+  }
+
+private:
+
+  ViewID mScrollId;
+# 506 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  float mPresShellResolution;
+# 523 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  ParentLayerRect mCompositionBounds;
+# 536 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  CSSRect mDisplayPort;
+
+
+
+
+
+
+
+  CSSRect mCriticalDisplayPort;
+# 557 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  CSSRect mScrollableRect;
+# 566 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  LayoutDeviceToLayerScale2D mCumulativeResolution;
+# 575 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  CSSToLayoutDeviceScale mDevPixelsPerCSSPixel;
+# 592 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  CSSPoint mScrollOffset;
+
+
+
+
+
+  CSSToParentLayerScale2D mZoom;
+
+
+  uint32_t mScrollGeneration;
+
+
+
+  CSSPoint mSmoothScrollOffset;
+
+
+  CSSSize mRootCompositionSize;
+
+
+
+  ScreenMargin mDisplayPortMargins;
+
+  uint32_t mPresShellId;
+# 625 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  CSSRect mViewport;
+
+
+
+  ScreenToLayerScale2D mExtraResolution;
+
+
+  TimeStamp mPaintRequestTime;
+
+
+
+  ScrollOffsetUpdateType mScrollUpdateType;
+
+
+  bool mIsRootContent:1;
+
+
+
+  bool mDoSmoothScroll:1;
+
+
+
+  bool mUseDisplayPortMargins:1;
+
+
+  bool mIsScrollInfoLayer:1;
+# 668 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+  void SetDoSmoothScroll(bool aValue) {
+    mDoSmoothScroll = aValue;
+  }
+};
+
+struct ScrollSnapInfo {
+  ScrollSnapInfo()
+    : mScrollSnapTypeX(0)
+    , mScrollSnapTypeY(0)
+  {}
+
+  bool operator==(const ScrollSnapInfo& aOther) const
+  {
+    return mScrollSnapTypeX == aOther.mScrollSnapTypeX &&
+           mScrollSnapTypeY == aOther.mScrollSnapTypeY &&
+           mScrollSnapIntervalX == aOther.mScrollSnapIntervalX &&
+           mScrollSnapIntervalY == aOther.mScrollSnapIntervalY &&
+           mScrollSnapDestination == aOther.mScrollSnapDestination &&
+           mScrollSnapCoordinates == aOther.mScrollSnapCoordinates;
+  }
+
+
+
+  uint8_t mScrollSnapTypeX;
+  uint8_t mScrollSnapTypeY;
+
+
+  Maybe<nscoord> mScrollSnapIntervalX;
+  Maybe<nscoord> mScrollSnapIntervalY;
+
+
+
+  nsPoint mScrollSnapDestination;
+
+
+
+  nsTArray<nsPoint> mScrollSnapCoordinates;
+};
+
+
+
+
+
+struct LayerClip {
+  friend struct IPC::ParamTraits<mozilla::layers::LayerClip>;
+
+public:
+  LayerClip()
+    : mClipRect()
+    , mMaskLayerIndex()
+  {}
+
+  explicit LayerClip(const ParentLayerIntRect& aClipRect)
+    : mClipRect(aClipRect)
+    , mMaskLayerIndex()
+  {}
+
+  bool operator==(const LayerClip& aOther) const
+  {
+    return mClipRect == aOther.mClipRect &&
+           mMaskLayerIndex == aOther.mMaskLayerIndex;
+  }
+
+  void SetClipRect(const ParentLayerIntRect& aClipRect) {
+    mClipRect = aClipRect;
+  }
+  const ParentLayerIntRect& GetClipRect() const {
+    return mClipRect;
+  }
+
+  void SetMaskLayerIndex(const Maybe<size_t>& aIndex) {
+    mMaskLayerIndex = aIndex;
+  }
+  const Maybe<size_t>& GetMaskLayerIndex() const {
+    return mMaskLayerIndex;
+  }
+
+private:
+  ParentLayerIntRect mClipRect;
+
+
+
+  Maybe<size_t> mMaskLayerIndex;
+};
+
+typedef Maybe<LayerClip> MaybeLayerClip;
+# 762 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+struct ScrollMetadata {
+  friend struct IPC::ParamTraits<mozilla::layers::ScrollMetadata>;
+
+  typedef FrameMetrics::ViewID ViewID;
+public:
+  static StaticAutoPtr<const ScrollMetadata> sNullMetadata;
+
+  ScrollMetadata()
+    : mMetrics()
+    , mSnapInfo()
+    , mScrollParentId(FrameMetrics::NULL_SCROLL_ID)
+    , mBackgroundColor()
+    , mContentDescription()
+    , mLineScrollAmount(0, 0)
+    , mPageScrollAmount(0, 0)
+    , mScrollClip()
+    , mHasScrollgrab(false)
+    , mAllowVerticalScrollWithWheel(false)
+    , mIsLayersIdRoot(false)
+    , mUsesContainerScrolling(false)
+    , mForceDisableApz(false)
+  {}
+
+  bool operator==(const ScrollMetadata& aOther) const
+  {
+    return mMetrics == aOther.mMetrics &&
+           mSnapInfo == aOther.mSnapInfo &&
+           mScrollParentId == aOther.mScrollParentId &&
+           mBackgroundColor == aOther.mBackgroundColor &&
+
+           mLineScrollAmount == aOther.mLineScrollAmount &&
+           mPageScrollAmount == aOther.mPageScrollAmount &&
+           mScrollClip == aOther.mScrollClip &&
+           mHasScrollgrab == aOther.mHasScrollgrab &&
+           mAllowVerticalScrollWithWheel == aOther.mAllowVerticalScrollWithWheel &&
+           mIsLayersIdRoot == aOther.mIsLayersIdRoot &&
+           mUsesContainerScrolling == aOther.mUsesContainerScrolling &&
+           mForceDisableApz == aOther.mForceDisableApz;
+  }
+
+  bool operator!=(const ScrollMetadata& aOther) const
+  {
+    return !operator==(aOther);
+  }
+
+  bool IsDefault() const
+  {
+    ScrollMetadata def;
+
+    def.mMetrics.SetPresShellId(mMetrics.GetPresShellId());
+    return (def == *this);
+  }
+
+  FrameMetrics& GetMetrics() { return mMetrics; }
+  const FrameMetrics& GetMetrics() const { return mMetrics; }
+
+  void SetSnapInfo(ScrollSnapInfo&& aSnapInfo) {
+    mSnapInfo = Move(aSnapInfo);
+  }
+  const ScrollSnapInfo& GetSnapInfo() const { return mSnapInfo; }
+
+  ViewID GetScrollParentId() const {
+    return mScrollParentId;
+  }
+
+  void SetScrollParentId(ViewID aParentId) {
+    mScrollParentId = aParentId;
+  }
+  const gfx::Color& GetBackgroundColor() const {
+    return mBackgroundColor;
+  }
+  void SetBackgroundColor(const gfx::Color& aBackgroundColor) {
+    mBackgroundColor = aBackgroundColor;
+  }
+  const nsCString& GetContentDescription() const {
+    return mContentDescription;
+  }
+  void SetContentDescription(const nsCString& aContentDescription) {
+    mContentDescription = aContentDescription;
+  }
+  const LayoutDeviceIntSize& GetLineScrollAmount() const {
+    return mLineScrollAmount;
+  }
+  void SetLineScrollAmount(const LayoutDeviceIntSize& size) {
+    mLineScrollAmount = size;
+  }
+  const LayoutDeviceIntSize& GetPageScrollAmount() const {
+    return mPageScrollAmount;
+  }
+  void SetPageScrollAmount(const LayoutDeviceIntSize& size) {
+    mPageScrollAmount = size;
+  }
+
+  void SetScrollClip(const Maybe<LayerClip>& aScrollClip) {
+    mScrollClip = aScrollClip;
+  }
+  const Maybe<LayerClip>& GetScrollClip() const {
+    return mScrollClip;
+  }
+  bool HasScrollClip() const {
+    return mScrollClip.isSome();
+  }
+  const LayerClip& ScrollClip() const {
+    return mScrollClip.ref();
+  }
+  LayerClip& ScrollClip() {
+    return mScrollClip.ref();
+  }
+
+  bool HasMaskLayer() const {
+    return HasScrollClip() && ScrollClip().GetMaskLayerIndex();
+  }
+  Maybe<ParentLayerIntRect> GetClipRect() const {
+    return mScrollClip.isSome() ? Some(mScrollClip->GetClipRect()) : Nothing();
+  }
+
+  void SetHasScrollgrab(bool aHasScrollgrab) {
+    mHasScrollgrab = aHasScrollgrab;
+  }
+  bool GetHasScrollgrab() const {
+    return mHasScrollgrab;
+  }
+  bool AllowVerticalScrollWithWheel() const {
+    return mAllowVerticalScrollWithWheel;
+  }
+  void SetAllowVerticalScrollWithWheel(bool aValue) {
+    mAllowVerticalScrollWithWheel = aValue;
+  }
+  void SetIsLayersIdRoot(bool aValue) {
+    mIsLayersIdRoot = aValue;
+  }
+  bool IsLayersIdRoot() const {
+    return mIsLayersIdRoot;
+  }
+
+
+  void SetUsesContainerScrolling(bool aValue);
+  bool UsesContainerScrolling() const {
+    return mUsesContainerScrolling;
+  }
+  void SetForceDisableApz(bool aForceDisable) {
+    mForceDisableApz = aForceDisable;
+  }
+  bool IsApzForceDisabled() const {
+    return mForceDisableApz;
+  }
+
+private:
+  FrameMetrics mMetrics;
+
+
+  ScrollSnapInfo mSnapInfo;
+
+
+  ViewID mScrollParentId;
+
+
+  gfx::Color mBackgroundColor;
+
+
+
+
+  nsCString mContentDescription;
+
+
+  LayoutDeviceIntSize mLineScrollAmount;
+
+
+  LayoutDeviceIntSize mPageScrollAmount;
+
+
+
+
+
+
+
+  Maybe<LayerClip> mScrollClip;
+
+
+  bool mHasScrollgrab:1;
+
+
+  bool mAllowVerticalScrollWithWheel:1;
+
+
+
+  bool mIsLayersIdRoot:1;
+
+
+
+  bool mUsesContainerScrolling:1;
+
+
+
+  bool mForceDisableApz:1;
+# 967 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+};
+# 977 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
+struct ScrollableLayerGuid {
+  uint64_t mLayersId;
+  uint32_t mPresShellId;
+  FrameMetrics::ViewID mScrollId;
+
+  ScrollableLayerGuid()
+    : mLayersId(0)
+    , mPresShellId(0)
+    , mScrollId(0)
+  {
+  }
+
+  ScrollableLayerGuid(uint64_t aLayersId, uint32_t aPresShellId,
+                      FrameMetrics::ViewID aScrollId)
+    : mLayersId(aLayersId)
+    , mPresShellId(aPresShellId)
+    , mScrollId(aScrollId)
+  {
+  }
+
+  ScrollableLayerGuid(uint64_t aLayersId, const FrameMetrics& aMetrics)
+    : mLayersId(aLayersId)
+    , mPresShellId(aMetrics.GetPresShellId())
+    , mScrollId(aMetrics.GetScrollId())
+  {
+  }
+
+  ScrollableLayerGuid(const ScrollableLayerGuid& other)
+    : mLayersId(other.mLayersId)
+    , mPresShellId(other.mPresShellId)
+    , mScrollId(other.mScrollId)
+  {
+  }
+
+  ~ScrollableLayerGuid()
+  {
+  }
+
+  bool operator==(const ScrollableLayerGuid& other) const
+  {
+    return mLayersId == other.mLayersId
+        && mPresShellId == other.mPresShellId
+        && mScrollId == other.mScrollId;
+  }
+
+  bool operator!=(const ScrollableLayerGuid& other) const
+  {
+    return !(*this == other);
+  }
+
+  bool operator<(const ScrollableLayerGuid& other) const
+  {
+    if (mLayersId < other.mLayersId) {
+      return true;
+    }
+    if (mLayersId == other.mLayersId) {
+      if (mPresShellId < other.mPresShellId) {
+        return true;
+      }
+      if (mPresShellId == other.mPresShellId) {
+        return mScrollId < other.mScrollId;
+      }
+    }
+    return false;
+  }
+
+  uint32_t Hash() const
+  {
+    return HashGeneric(mLayersId, mPresShellId, mScrollId);
+  }
+};
+
+template <int LogLevel>
+gfx::Log<LogLevel>& operator<<(gfx::Log<LogLevel>& log, const ScrollableLayerGuid& aGuid) {
+  return log << '(' << aGuid.mLayersId << ',' << aGuid.mPresShellId << ',' << aGuid.mScrollId << ')';
+}
+
+struct ZoomConstraints {
+  bool mAllowZoom;
+  bool mAllowDoubleTapZoom;
+  CSSToParentLayerScale mMinZoom;
+  CSSToParentLayerScale mMaxZoom;
+
+  ZoomConstraints()
+    : mAllowZoom(true)
+    , mAllowDoubleTapZoom(true)
+  {
+                                   ;
+  }
+
+  ZoomConstraints(bool aAllowZoom,
+                  bool aAllowDoubleTapZoom,
+                  const CSSToParentLayerScale& aMinZoom,
+                  const CSSToParentLayerScale& aMaxZoom)
+    : mAllowZoom(aAllowZoom)
+    , mAllowDoubleTapZoom(aAllowDoubleTapZoom)
+    , mMinZoom(aMinZoom)
+    , mMaxZoom(aMaxZoom)
+  {
+                                   ;
+  }
+
+  ZoomConstraints(const ZoomConstraints& other)
+    : mAllowZoom(other.mAllowZoom)
+    , mAllowDoubleTapZoom(other.mAllowDoubleTapZoom)
+    , mMinZoom(other.mMinZoom)
+    , mMaxZoom(other.mMaxZoom)
+  {
+                                   ;
+  }
+
+  ~ZoomConstraints()
+  {
+                                   ;
+  }
+
+  bool operator==(const ZoomConstraints& other) const
+  {
+    return mAllowZoom == other.mAllowZoom
+        && mAllowDoubleTapZoom == other.mAllowDoubleTapZoom
+        && mMinZoom == other.mMinZoom
+        && mMaxZoom == other.mMaxZoom;
+  }
+
+  bool operator!=(const ZoomConstraints& other) const
+  {
+    return !(*this == other);
+  }
+};
+
+typedef Maybe<ZoomConstraints> MaybeZoomConstraints;
+
+}
+}
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
+
+
+
+
+class nsBoxLayoutState;
+class nsIScrollPositionListener;
+class nsIFrame;
+class nsPresContext;
+class nsIContent;
+class nsRenderingContext;
+class nsIAtom;
+class nsDisplayListBuilder;
+
+namespace mozilla {
+struct ContainerLayerParameters;
+namespace layers {
+class Layer;
+}
+}
+
+
+
+
+
+
+class nsIScrollableFrame : public nsIScrollbarMediator {
+public:
+  typedef mozilla::CSSIntPoint CSSIntPoint;
+  typedef mozilla::ContainerLayerParameters ContainerLayerParameters;
+  typedef mozilla::layers::FrameMetrics FrameMetrics;
+  typedef mozilla::layers::ScrollSnapInfo ScrollSnapInfo;
+
+  static const nsQueryFrame::FrameIID kFrameIID = nsQueryFrame::nsIScrollableFrame_id; typedef nsIScrollableFrame Has_NS_DECL_QUERYFRAME_TARGET;
+
+
+
+
+
+  virtual nsIFrame* GetScrolledFrame() const = 0;
+
+
+
+
+
+
+  virtual mozilla::ScrollbarStyles GetScrollbarStyles() const = 0;
+
+  enum { HORIZONTAL = 0x01, VERTICAL = 0x02 };
+
+
+
+
+
+  virtual uint32_t GetScrollbarVisibility() const = 0;
+
+
+
+
+
+  uint32_t GetPerceivedScrollingDirections() const;
+
+
+
+
+
+
+  virtual nsMargin GetActualScrollbarSizes() const = 0;
+
+
+
+
+
+  virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) = 0;
+
+
+
+
+
+  virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
+                                            nsRenderingContext* aRC) = 0;
+
+
+
+  virtual nscoord
+  GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
+                                   nsRenderingContext* aRC,
+                                   mozilla::WritingMode aWM) = 0;
+# 122 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual nsRect GetScrolledRect() const = 0;
+
+
+
+
+
+  virtual nsRect GetScrollPortRect() const = 0;
+
+
+
+
+
+  virtual nsPoint GetScrollPosition() const = 0;
+
+
+
+  virtual nsPoint GetLogicalScrollPosition() const = 0;
+# 147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual nsRect GetScrollRange() const = 0;
+
+
+
+
+  virtual nsSize GetScrollPositionClampingScrollPortSize() const = 0;
+
+
+
+
+  virtual nsSize GetLineScrollAmount() const = 0;
+
+
+
+
+  virtual nsSize GetPageScrollAmount() const = 0;
+# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  enum ScrollMode { INSTANT, SMOOTH, SMOOTH_MSD, NORMAL };
+# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  enum ScrollMomentum { NOT_MOMENTUM, SYNTHESIZED_MOMENTUM_EVENT };
+# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void ScrollTo(nsPoint aScrollPosition, ScrollMode aMode,
+                        const nsRect* aRange = nullptr,
+                        nsIScrollbarMediator::ScrollSnapMode aSnap
+                          = nsIScrollbarMediator::DISABLE_SNAP) = 0;
+# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void ScrollToCSSPixels(const CSSIntPoint& aScrollPosition,
+                                 nsIScrollableFrame::ScrollMode aMode
+                                   = nsIScrollableFrame::INSTANT) = 0;
+# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void ScrollToCSSPixelsApproximate(const mozilla::CSSPoint& aScrollPosition,
+                                            nsIAtom *aOrigin = nullptr) = 0;
+
+
+
+
+
+  virtual CSSIntPoint GetScrollPositionCSSPixels() = 0;
+
+
+
+  enum ScrollUnit { DEVICE_PIXELS, LINES, PAGES, WHOLE };
+# 264 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void ScrollBy(nsIntPoint aDelta, ScrollUnit aUnit, ScrollMode aMode,
+                        nsIntPoint* aOverflow = nullptr,
+                        nsIAtom* aOrigin = nullptr,
+                        ScrollMomentum aMomentum = NOT_MOMENTUM,
+                        nsIScrollbarMediator::ScrollSnapMode aSnap
+                          = nsIScrollbarMediator::DISABLE_SNAP) = 0;
+
+
+
+
+
+
+
+  virtual void ScrollSnap() = 0;
+# 288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void ScrollToRestoredPosition() = 0;
+
+
+
+
+
+  virtual void AddScrollPositionListener(nsIScrollPositionListener* aListener) = 0;
+
+
+
+  virtual void RemoveScrollPositionListener(nsIScrollPositionListener* aListener) = 0;
+
+
+
+
+
+  virtual void CurPosAttributeChanged(nsIContent* aChild) = 0;
+
+
+
+
+
+  virtual nsresult PostScrolledAreaEventForCurrentArea() = 0;
+
+
+
+
+
+
+  virtual bool IsScrollingActive(nsDisplayListBuilder* aBuilder) = 0;
+
+
+
+
+  virtual bool IsProcessingAsyncScroll() = 0;
+
+
+
+
+  virtual void ResetScrollPositionForLayerPixelAlignment() = 0;
+
+
+
+  virtual bool DidHistoryRestore() const = 0;
+
+
+
+
+
+  virtual void ClearDidHistoryRestore() = 0;
+
+
+
+
+  virtual bool IsRectNearlyVisible(const nsRect& aRect) = 0;
+
+
+
+
+  virtual nsRect ExpandRectToNearlyVisible(const nsRect& aRect) const = 0;
+
+
+
+
+
+  virtual nsIAtom* LastScrollOrigin() = 0;
+# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual void AllowScrollOriginDowngrade() = 0;
+# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual nsIAtom* LastSmoothScrollOrigin() = 0;
+
+
+
+
+  virtual uint32_t CurrentScrollGeneration() = 0;
+
+
+
+
+  virtual nsPoint LastScrollDestination() = 0;
+
+
+
+
+
+  virtual void ResetScrollInfoIfGeneration(uint32_t aGeneration) = 0;
+
+
+
+
+  virtual bool WantAsyncScroll() const = 0;
+
+
+
+
+  virtual mozilla::Maybe<mozilla::layers::ScrollMetadata> ComputeScrollMetadata(
+    mozilla::layers::Layer* aLayer,
+    nsIFrame* aContainerReferenceFrame,
+    const ContainerLayerParameters& aParameters,
+    const mozilla::DisplayItemClip* aClip) const = 0;
+
+
+
+
+  virtual bool IsIgnoringViewportClipping() const = 0;
+
+
+
+
+  virtual void MarkScrollbarsDirtyForReflow() const = 0;
+
+  virtual void SetTransformingByAPZ(bool aTransforming) = 0;
+  virtual bool IsTransformingByAPZ() const = 0;
+
+
+
+
+
+
+
+  virtual void SetScrollableByAPZ(bool aScrollable) = 0;
+
+
+
+
+  virtual void SetZoomableByAPZ(bool aZoomable) = 0;
+
+
+
+
+  virtual bool UsesContainerScrolling() const = 0;
+# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
+  virtual bool DecideScrollableLayer(nsDisplayListBuilder* aBuilder,
+                                     nsRect* aDirtyRect,
+                                     bool aAllowCreateDisplayPort) = 0;
+
+
+
+
+
+
+  virtual void NotifyApproximateFrameVisibilityUpdate(bool aIgnoreDisplayPort) = 0;
+
+
+
+
+
+
+  virtual bool GetDisplayPortAtLastApproximateFrameVisibilityUpdate(nsRect* aDisplayPort) = 0;
+
+
+
+
+
+
+  virtual void TriggerDisplayPortExpiration() = 0;
+
+
+
+
+  virtual ScrollSnapInfo GetScrollSnapInfo() const = 0;
+
+
+
+
+
+
+
+  virtual bool DragScroll(mozilla::WidgetEvent* aEvent) = 0;
+
+  virtual void AsyncScrollbarDragRejected() = 0;
+
+
+
+
+
+
+  virtual bool IsRootScrollFrameOfDocument() const = 0;
+};
+# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
+class nsSMILValue;
+class nsIContent;
+class nsAString;
+
+namespace mozilla {
+namespace dom {
+class SVGAnimationElement;
+}
+}
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
+class nsISMILAttr
+{
+public:
+# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
+  virtual nsresult ValueFromString(const nsAString& aStr,
+                                   const mozilla::dom::SVGAnimationElement* aSrcElement,
+                                   nsSMILValue& aValue,
+                                   bool& aPreventCachingOfSandwich) const = 0;
+
+
+
+
+
+
+
+  virtual nsSMILValue GetBaseValue() const = 0;
+
+
+
+
+
+
+
+  virtual void ClearAnimValue() = 0;
+
+
+
+
+
+
+
+  virtual nsresult SetAnimValue(const nsSMILValue& aValue) = 0;
+# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
+  virtual const nsIContent* GetTargetNode() const { return nullptr; }
+
+
+
+
+  virtual ~nsISMILAttr() {}
+};
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRect.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRect.h"
+class nsIDOMClientRect : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetLeft(float *aLeft) = 0;
+
+
+  virtual nsresult GetTop(float *aTop) = 0;
+
+
+  virtual nsresult GetRight(float *aRight) = 0;
+
+
+  virtual nsresult GetBottom(float *aBottom) = 0;
+
+
+  virtual nsresult GetWidth(float *aWidth) = 0;
+
+
+  virtual nsresult GetHeight(float *aHeight) = 0;
+
+};
+
+  template<typename T> struct nsIDOMClientRect::COMTypeInfo<nsIDOMClientRect, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMClientRect::COMTypeInfo<nsIDOMClientRect, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb2f824c4, 0xd9d3, 0x499b, { 0x8d, 0x3b, 0x45, 0xc8, 0x24, 0x54, 0x97, 0xc6 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRectList.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRectList.h"
+class nsIDOMClientRectList : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetLength(uint32_t *aLength) = 0;
+
+
+  virtual nsresult Item(uint32_t index, nsIDOMClientRect * *_retval) = 0;
+
+};
+
+  template<typename T> struct nsIDOMClientRectList::COMTypeInfo<nsIDOMClientRectList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMClientRectList::COMTypeInfo<nsIDOMClientRectList, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf474c567, 0xcbcb, 0x458f, { 0xab, 0xad, 0xae, 0x42, 0x36, 0x3d, 0xa2, 0x87 }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 2
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
+struct nsRect;
+
+namespace mozilla {
+namespace dom {
+
+class DOMRectReadOnly : public nsISupports
+                      , public nsWrapperCache
+{
+protected:
+  virtual ~DOMRectReadOnly() {}
+
+public:
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMRectReadOnly"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMRectReadOnly>(p)->DeleteCycleCollectable(); } static DOMRectReadOnly* Downcast(nsISupports* s) { return static_cast<DOMRectReadOnly*>(static_cast<DOMRectReadOnly*>(s)); } static nsISupports* Upcast(DOMRectReadOnly *p) { return static_cast<nsISupports*>(static_cast<DOMRectReadOnly*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMRectReadOnly::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+  explicit DOMRectReadOnly(nsISupports* aParent)
+    : mParent(aParent)
+  {
+  }
+
+  nsISupports* GetParentObject() const
+  {
+    do { } while (0);
+    return mParent;
+  }
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+  virtual double X() const = 0;
+  virtual double Y() const = 0;
+  virtual double Width() const = 0;
+  virtual double Height() const = 0;
+
+  double Left() const
+  {
+    double x = X(), w = Width();
+    return std::min(x, x + w);
+  }
+  double Top() const
+  {
+    double y = Y(), h = Height();
+    return std::min(y, y + h);
+  }
+  double Right() const
+  {
+    double x = X(), w = Width();
+    return std::max(x, x + w);
+  }
+  double Bottom() const
+  {
+    double y = Y(), h = Height();
+    return std::max(y, y + h);
+  }
+
+protected:
+  nsCOMPtr<nsISupports> mParent;
+};
+
+class DOMRect final : public DOMRectReadOnly
+                    , public nsIDOMClientRect
+{
+public:
+  explicit DOMRect(nsISupports* aParent, double aX = 0, double aY = 0,
+                   double aWidth = 0, double aHeight = 0)
+    : DOMRectReadOnly(aParent)
+    , mX(aX)
+    , mY(aY)
+    , mWidth(aWidth)
+    , mHeight(aHeight)
+  {
+  }
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
+  virtual nsresult GetLeft(float *aLeft) override; virtual nsresult GetTop(float *aTop) override; virtual nsresult GetRight(float *aRight) override; virtual nsresult GetBottom(float *aBottom) override; virtual nsresult GetWidth(float *aWidth) override; virtual nsresult GetHeight(float *aHeight) override;
+
+  static already_AddRefed<DOMRect>
+  Constructor(const GlobalObject& aGlobal, ErrorResult& aRV);
+  static already_AddRefed<DOMRect>
+  Constructor(const GlobalObject& aGlobal, double aX, double aY,
+              double aWidth, double aHeight, ErrorResult& aRV);
+
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+  void SetRect(float aX, float aY, float aWidth, float aHeight) {
+    mX = aX; mY = aY; mWidth = aWidth; mHeight = aHeight;
+  }
+  void SetLayoutRect(const nsRect& aLayoutRect);
+
+  virtual double X() const override
+  {
+    return mX;
+  }
+  virtual double Y() const override
+  {
+    return mY;
+  }
+  virtual double Width() const override
+  {
+    return mWidth;
+  }
+  virtual double Height() const override
+  {
+    return mHeight;
+  }
+
+  void SetX(double aX)
+  {
+    mX = aX;
+  }
+  void SetY(double aY)
+  {
+    mY = aY;
+  }
+  void SetWidth(double aWidth)
+  {
+    mWidth = aWidth;
+  }
+  void SetHeight(double aHeight)
+  {
+    mHeight = aHeight;
+  }
+
+protected:
+  double mX, mY, mWidth, mHeight;
+
+private:
+  ~DOMRect() {};
+};
+
+class DOMRectList final : public nsIDOMClientRectList,
+                          public nsWrapperCache
+{
+  ~DOMRectList() {}
+
+public:
+  explicit DOMRectList(nsISupports *aParent) : mParent(aParent)
+  {
+  }
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMRectList"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMRectList>(p)->DeleteCycleCollectable(); } static DOMRectList* Downcast(nsISupports* s) { return static_cast<DOMRectList*>(static_cast<DOMRectList*>(s)); } static nsISupports* Upcast(DOMRectList *p) { return static_cast<nsISupports*>(static_cast<DOMRectList*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMRectList::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+  virtual nsresult GetLength(uint32_t *aLength) override; virtual nsresult Item(uint32_t index, nsIDOMClientRect * *_retval) override;
+
+  virtual JSObject* WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
+
+  nsISupports* GetParentObject()
+  {
+    return mParent;
+  }
+
+  void Append(DOMRect* aElement) { mArray.AppendElement(aElement); }
+
+  static DOMRectList* FromSupports(nsISupports* aSupports)
+  {
+# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
+    return static_cast<DOMRectList*>(aSupports);
+  }
+
+  uint32_t Length()
+  {
+    return mArray.Length();
+  }
+  DOMRect* Item(uint32_t aIndex)
+  {
+    return mArray.SafeElementAt(aIndex);
+  }
+  DOMRect* IndexedGetter(uint32_t aIndex, bool& aFound)
+  {
+    aFound = aIndex < mArray.Length();
+    if (!aFound) {
+      return nullptr;
+    }
+    return mArray[aIndex];
+  }
+
+protected:
+  nsTArray<RefPtr<DOMRect> > mArray;
+  nsCOMPtr<nsISupports> mParent;
+};
+
+}
+}
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMTokenListSupportedTokens.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMTokenListSupportedTokens.h"
+namespace mozilla {
+namespace dom {
+
+
+typedef const char* const DOMTokenListSupportedToken;
+
+
+
+
+
+
+typedef DOMTokenListSupportedToken* DOMTokenListSupportedTokenArray;
+
+}
+}
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h"
+namespace mozilla {
+namespace dom {
+
+class Element;
+struct ElementAtoms;
+struct NativePropertyHooks;
+class ProtoAndIfaceCache;
+struct ScrollIntoViewOptionsAtoms;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+enum class ScrollLogicalPosition : uint8_t {
+  Start,
+  End,
+  EndGuard_
+};
+
+namespace ScrollLogicalPositionValues {
+extern const EnumEntry strings[3];
+}
+
+bool
+ToJSValue(JSContext* aCx, ScrollLogicalPosition aArgument, JS::MutableHandle<JS::Value> aValue);
+
+
+struct ScrollIntoViewOptions : public ScrollOptions
+{
+                        ScrollLogicalPosition mBlock;
+
+  ScrollIntoViewOptions();
+
+  explicit inline ScrollIntoViewOptions(const FastDictionaryInitializer& )
+    : ScrollOptions(FastDictionaryInitializer())
+  {
+
+  }
+
+  explicit inline ScrollIntoViewOptions(const ScrollIntoViewOptions& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  Init(const nsAString& aJSON);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  bool
+  ToJSON(nsAString& aJSON) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  ScrollIntoViewOptions&
+  operator=(const ScrollIntoViewOptions& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, ScrollIntoViewOptionsAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastScrollIntoViewOptions : public ScrollIntoViewOptions
+{
+  inline FastScrollIntoViewOptions()
+    : ScrollIntoViewOptions(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+namespace ElementBinding {
+
+  typedef mozilla::dom::Element NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::Element* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JSObject*
+  GetProtoObject(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 1
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
+namespace mozilla {
+namespace dom {
+
+class DOMRect;
+struct DOMRectAtoms;
+struct DOMRectInitAtoms;
+class DOMRectReadOnly;
+struct DOMRectReadOnlyAtoms;
+struct NativePropertyHooks;
+class ProtoAndIfaceCache;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+struct DOMRectInit : public DictionaryBase
+{
+                        double mHeight;
+                        double mWidth;
+                        double mX;
+                        double mY;
+
+  DOMRectInit();
+
+  explicit inline DOMRectInit(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline DOMRectInit(const DOMRectInit& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  DOMRectInit&
+  operator=(const DOMRectInit& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, DOMRectInitAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastDOMRectInit : public DOMRectInit
+{
+  inline FastDOMRectInit()
+    : DOMRectInit(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+namespace DOMRectBinding {
+
+  typedef mozilla::dom::DOMRect NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::DOMRect* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+namespace DOMRectReadOnlyBinding {
+
+  typedef mozilla::dom::DOMRectReadOnly NativeType;
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::DOMRectReadOnly* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JSObject*
+  GetProtoObject(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 7 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 2
+
+
+
+
+
+namespace mozilla {
+namespace dom {
+
+class DOMIntersectionObserver;
+struct DOMIntersectionObserverAtoms;
+class DOMIntersectionObserverEntry;
+struct DOMIntersectionObserverEntryAtoms;
+struct DOMRectInit;
+class DoubleOrDoubleSequence;
+class Element;
+class IntersectionCallback;
+struct IntersectionObserverEntryInitAtoms;
+struct IntersectionObserverInitAtoms;
+struct NativePropertyHooks;
+class OwningDoubleOrDoubleSequence;
+class ProtoAndIfaceCache;
+
+}
+}
+
+namespace mozilla {
+namespace dom {
+
+class DoubleOrDoubleSequence
+{
+  friend class DoubleOrDoubleSequenceArgument;
+  enum Type
+  {
+    eUninitialized,
+    eDouble,
+    eDoubleSequence
+  };
+
+  union Value
+  {
+    UnionMember<double > mDouble;
+    UnionMember<binding_detail::AutoSequence<double> > mDoubleSequence;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+  DoubleOrDoubleSequence(const DoubleOrDoubleSequence&) = delete;
+  DoubleOrDoubleSequence& operator=(const DoubleOrDoubleSequence&) = delete;
+public:
+  explicit inline DoubleOrDoubleSequence()
+    : mType(eUninitialized)
+  {
+  }
+
+  inline ~DoubleOrDoubleSequence()
+  {
+    Uninit();
+  }
+
+  inline double&
+  RawSetAsDouble()
+  {
+    if (mType == eDouble) {
+      return mValue.mDouble.Value();
+    }
+    do { } while (0);
+    mType = eDouble;
+    return mValue.mDouble.SetValue();
+  }
+
+  inline double&
+  SetAsDouble()
+  {
+    if (mType == eDouble) {
+      return mValue.mDouble.Value();
+    }
+    Uninit();
+    mType = eDouble;
+    return mValue.mDouble.SetValue();
+  }
+
+  inline bool
+  IsDouble() const
+  {
+    return mType == eDouble;
+  }
+
+  inline double&
+  GetAsDouble()
+  {
+    do { } while (0);
+    return mValue.mDouble.Value();
+  }
+
+  inline double
+  GetAsDouble() const
+  {
+    do { } while (0);
+    return mValue.mDouble.Value();
+  }
+
+  inline binding_detail::AutoSequence<double>&
+  RawSetAsDoubleSequence()
+  {
+    if (mType == eDoubleSequence) {
+      return mValue.mDoubleSequence.Value();
+    }
+    do { } while (0);
+    mType = eDoubleSequence;
+    return mValue.mDoubleSequence.SetValue();
+  }
+
+  inline binding_detail::AutoSequence<double>&
+  SetAsDoubleSequence()
+  {
+    if (mType == eDoubleSequence) {
+      return mValue.mDoubleSequence.Value();
+    }
+    Uninit();
+    mType = eDoubleSequence;
+    return mValue.mDoubleSequence.SetValue();
+  }
+
+  inline bool
+  IsDoubleSequence() const
+  {
+    return mType == eDoubleSequence;
+  }
+
+  inline binding_detail::AutoSequence<double>&
+  GetAsDoubleSequence()
+  {
+    do { } while (0);
+    return mValue.mDoubleSequence.Value();
+  }
+
+  inline const Sequence<double>&
+  GetAsDoubleSequence() const
+  {
+    do { } while (0);
+    return mValue.mDoubleSequence.Value();
+  }
+
+  inline void
+  Uninit()
+  {
+    switch (mType) {
+      case eUninitialized: {
+        break;
+      }
+      case eDouble: {
+        DestroyDouble();
+        break;
+      }
+      case eDoubleSequence: {
+        DestroyDoubleSequence();
+        break;
+      }
+    }
+  }
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+private:
+  inline void
+  DestroyDouble()
+  {
+    do { } while (0);
+    mValue.mDouble.Destroy();
+    mType = eUninitialized;
+  }
+
+  inline void
+  DestroyDoubleSequence()
+  {
+    do { } while (0);
+    mValue.mDoubleSequence.Destroy();
+    mType = eUninitialized;
+  }
+};
+
+
+class OwningDoubleOrDoubleSequence : public AllOwningUnionBase
+{
+  friend void ImplCycleCollectionUnlink(OwningDoubleOrDoubleSequence& aUnion);
+  enum Type
+  {
+    eUninitialized,
+    eDouble,
+    eDoubleSequence
+  };
+
+  union Value
+  {
+    UnionMember<double > mDouble;
+    UnionMember<Sequence<double> > mDoubleSequence;
+
+  };
+
+  Type mType;
+  Value mValue;
+
+public:
+  explicit inline OwningDoubleOrDoubleSequence()
+    : mType(eUninitialized)
+  {
+  }
+
+  explicit inline OwningDoubleOrDoubleSequence(const OwningDoubleOrDoubleSequence& aOther)
+    : mType(eUninitialized)
+  {
+    *this = aOther;
+  }
+
+  inline ~OwningDoubleOrDoubleSequence()
+  {
+    Uninit();
+  }
+
+  double&
+  RawSetAsDouble();
+
+  double&
+  SetAsDouble();
+
+  bool
+  TrySetToDouble(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsDouble() const
+  {
+    return mType == eDouble;
+  }
+
+  inline double&
+  GetAsDouble()
+  {
+    do { } while (0);
+    return mValue.mDouble.Value();
+  }
+
+  inline double const &
+  GetAsDouble() const
+  {
+    do { } while (0);
+    return mValue.mDouble.Value();
+  }
+
+  Sequence<double>&
+  RawSetAsDoubleSequence();
+
+  Sequence<double>&
+  SetAsDoubleSequence();
+
+  bool
+  TrySetToDoubleSequence(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
+
+  inline bool
+  IsDoubleSequence() const
+  {
+    return mType == eDoubleSequence;
+  }
+
+  inline Sequence<double>&
+  GetAsDoubleSequence()
+  {
+    do { } while (0);
+    return mValue.mDoubleSequence.Value();
+  }
+
+  inline Sequence<double> const &
+  GetAsDoubleSequence() const
+  {
+    do { } while (0);
+    return mValue.mDoubleSequence.Value();
+  }
+
+  void
+  Uninit();
+
+  bool
+  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceUnion(JSTracer* trc);
+
+  OwningDoubleOrDoubleSequence&
+  operator=(const OwningDoubleOrDoubleSequence& aOther);
+
+private:
+  void
+  DestroyDouble();
+
+  void
+  DestroyDoubleSequence();
+};
+
+
+struct IntersectionObserverEntryInit : public DictionaryBase
+{
+                        DOMRectInit mBoundingClientRect;
+                        DOMRectInit mIntersectionRect;
+                        DOMRectInit mRootBounds;
+                        OwningNonNull<mozilla::dom::Element> mTarget;
+                        double mTime;
+
+  IntersectionObserverEntryInit();
+
+  explicit inline IntersectionObserverEntryInit(const FastDictionaryInitializer& )
+    : mBoundingClientRect(FastDictionaryInitializer()),
+      mIntersectionRect(FastDictionaryInitializer()),
+      mRootBounds(FastDictionaryInitializer())
+  {
+
+  }
+
+  explicit inline IntersectionObserverEntryInit(const IntersectionObserverEntryInit& aOther)
+    : mBoundingClientRect(FastDictionaryInitializer()),
+      mIntersectionRect(FastDictionaryInitializer()),
+      mRootBounds(FastDictionaryInitializer())
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  IntersectionObserverEntryInit&
+  operator=(const IntersectionObserverEntryInit& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, IntersectionObserverEntryInitAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastIntersectionObserverEntryInit : public IntersectionObserverEntryInit
+{
+  inline FastIntersectionObserverEntryInit()
+    : IntersectionObserverEntryInit(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+struct IntersectionObserverInit : public DictionaryBase
+{
+                        RefPtr<mozilla::dom::Element> mRoot;
+                        nsString mRootMargin;
+                        OwningDoubleOrDoubleSequence mThreshold;
+
+  IntersectionObserverInit();
+
+  explicit inline IntersectionObserverInit(const FastDictionaryInitializer& )
+  {
+
+  }
+
+  explicit inline IntersectionObserverInit(const IntersectionObserverInit& aOther)
+  {
+    *this = aOther;
+  }
+
+  bool
+  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
+
+  bool
+  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
+
+  void
+  TraceDictionary(JSTracer* trc);
+
+  IntersectionObserverInit&
+  operator=(const IntersectionObserverInit& aOther);
+
+private:
+  static bool
+  InitIds(JSContext* cx, IntersectionObserverInitAtoms* atomsCache);
+};
+
+namespace binding_detail {
+struct FastIntersectionObserverInit : public IntersectionObserverInit
+{
+  inline FastIntersectionObserverInit()
+    : IntersectionObserverInit(FastDictionaryInitializer())
+  {
+
+  }
+};
+}
+
+
+class IntersectionCallback : public CallbackFunction
+{
+public:
+  explicit inline IntersectionCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline IntersectionCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
+    : CallbackFunction(aCallback, FastCallbackConstructor())
+  {
+    do { } while (0);
+  }
+
+  explicit inline IntersectionCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
+    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
+  {
+    do { } while (0);
+  }
+
+  explicit inline IntersectionCallback(CallbackFunction* aOther)
+    : CallbackFunction(aOther)
+  {
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "IntersectionCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    JS::Rooted<JS::Value> thisValJS(s.GetContext());
+    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+    return Call(s.GetContext(), thisValJS, entries, observer, aRv);
+  }
+
+  inline void
+  Call(const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
+  {
+    do { } while (0);
+    if (!aExecutionReason) {
+      aExecutionReason = "IntersectionCallback";
+    }
+    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+    if (!s.GetContext()) {
+      do { } while (0);
+      return;
+    }
+    return Call(s.GetContext(), JS::UndefinedHandleValue, entries, observer, aRv);
+  }
+
+  template <typename T>
+  inline void
+  Call(const T& thisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(thisVal, entries, observer, rv, aExecutionReason);
+  }
+
+  inline void
+  Call(const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, const char* aExecutionReason = nullptr)
+  {
+    IgnoredErrorResult rv;
+    return Call(entries, observer, rv, aExecutionReason, eReportExceptions, nullptr);
+  }
+
+  inline bool
+  operator==(const IntersectionCallback& aOther) const
+  {
+    return CallbackFunction::operator==(aOther);
+  }
+
+private:
+  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv);
+};
+
+
+namespace binding_detail {
+class FastIntersectionCallback : public IntersectionCallback
+{
+public:
+  explicit inline FastIntersectionCallback(JS::Handle<JSObject*> aCallback)
+    : IntersectionCallback(aCallback, FastCallbackConstructor())
+  {
+  }
+
+  inline void
+  Trace(JSTracer* aTracer)
+  {
+    IntersectionCallback::Trace(aTracer);
+  }
+
+  inline void
+  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
+  {
+    IntersectionCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
+  }
+};
+}
+
+
+namespace IntersectionObserverBinding {
+
+  typedef mozilla::dom::DOMIntersectionObserver NativeType;
+
+  bool
+  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::DOMIntersectionObserver* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 558 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+namespace IntersectionObserverEntryBinding {
+
+  typedef mozilla::dom::DOMIntersectionObserverEntry NativeType;
+
+  bool
+  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
+
+  JSObject*
+  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
+
+  const JSClass*
+  GetJSClass();
+
+  bool
+  Wrap(JSContext* aCx, mozilla::dom::DOMIntersectionObserverEntry* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+
+  template <class T>
+  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
+  {
+    JS::Rooted<JSObject*> reflector(aCx);
+    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+  }
+# 606 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h"
+  extern const NativePropertyHooks sNativePropertyHooks[];
+
+  void
+  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
+
+  JS::Handle<JSObject*>
+  GetProtoObjectHandle(JSContext* aCx);
+
+  JS::Handle<JSObject*>
+  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
+
+  JSObject*
+  GetConstructorObject(JSContext* aCx);
+
+}
+
+
+
+}
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h"
+namespace mozilla {
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h"
+struct StyleComplexColor
+{
+  nscolor mColor;
+  uint8_t mForegroundRatio;
+
+
+
+
+  bool mIsAuto;
+
+  static StyleComplexColor FromColor(nscolor aColor) {
+    return {aColor, 0, false};
+  }
+  static StyleComplexColor CurrentColor() {
+    return {((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))), 255, false};
+  }
+  static StyleComplexColor Auto() {
+    return {((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))), 255, true};
+  }
+
+  bool IsNumericColor() const { return mForegroundRatio == 0; }
+  bool IsCurrentColor() const { return mForegroundRatio == 255; }
+
+  bool operator==(const StyleComplexColor& aOther) const {
+    return mForegroundRatio == aOther.mForegroundRatio &&
+           (IsCurrentColor() || mColor == aOther.mColor) &&
+           mIsAuto == aOther.mIsAuto;
+  }
+  bool operator!=(const StyleComplexColor& aOther) const {
+    return !(*this == aOther);
+  }
+};
+
+}
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h"
+enum nsCSSKeyword : int16_t {
+  eCSSKeyword_UNKNOWN = -1,
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywordList.h" 1
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywordList.h"
+eCSSKeyword__moz_activehyperlinktext,
+eCSSKeyword__moz_all,
+eCSSKeyword__moz_alt_content,
+eCSSKeyword__moz_anchor_decoration,
+eCSSKeyword__moz_available,
+eCSSKeyword__moz_box,
+eCSSKeyword__moz_button,
+eCSSKeyword__moz_buttondefault,
+eCSSKeyword__moz_buttonhoverface,
+eCSSKeyword__moz_buttonhovertext,
+eCSSKeyword__moz_cellhighlight,
+eCSSKeyword__moz_cellhighlighttext,
+eCSSKeyword__moz_center,
+eCSSKeyword__moz_combobox,
+eCSSKeyword__moz_comboboxtext,
+eCSSKeyword__moz_block_height,
+eCSSKeyword__moz_deck,
+eCSSKeyword__moz_default_background_color,
+eCSSKeyword__moz_default_color,
+eCSSKeyword__moz_desktop,
+eCSSKeyword__moz_dialog,
+eCSSKeyword__moz_dialogtext,
+eCSSKeyword__moz_document,
+eCSSKeyword__moz_dragtargetzone,
+eCSSKeyword__moz_element,
+eCSSKeyword__moz_eventreerow,
+eCSSKeyword__moz_field,
+eCSSKeyword__moz_fieldtext,
+eCSSKeyword__moz_fit_content,
+eCSSKeyword__moz_fixed,
+eCSSKeyword__moz_grabbing,
+eCSSKeyword__moz_grab,
+eCSSKeyword__moz_grid_group,
+eCSSKeyword__moz_grid_line,
+eCSSKeyword__moz_grid,
+eCSSKeyword__moz_groupbox,
+eCSSKeyword__moz_gtk_info_bar,
+eCSSKeyword__moz_gtk_info_bar_text,
+eCSSKeyword__moz_hidden_unscrollable,
+eCSSKeyword__moz_hyperlinktext,
+eCSSKeyword__moz_html_cellhighlight,
+eCSSKeyword__moz_html_cellhighlighttext,
+eCSSKeyword__moz_image_rect,
+eCSSKeyword__moz_info,
+eCSSKeyword__moz_inline_box,
+eCSSKeyword__moz_inline_grid,
+eCSSKeyword__moz_inline_stack,
+eCSSKeyword__moz_left,
+eCSSKeyword__moz_list,
+eCSSKeyword__moz_mac_buttonactivetext,
+eCSSKeyword__moz_mac_chrome_active,
+eCSSKeyword__moz_mac_chrome_inactive,
+eCSSKeyword__moz_mac_defaultbuttontext,
+eCSSKeyword__moz_mac_focusring,
+eCSSKeyword__moz_mac_fullscreen_button,
+eCSSKeyword__moz_mac_menuselect,
+eCSSKeyword__moz_mac_menushadow,
+eCSSKeyword__moz_mac_menutextdisable,
+eCSSKeyword__moz_mac_menutextselect,
+eCSSKeyword__moz_mac_disabledtoolbartext,
+eCSSKeyword__moz_mac_secondaryhighlight,
+eCSSKeyword__moz_max_content,
+eCSSKeyword__moz_menuhover,
+eCSSKeyword__moz_menuhovertext,
+eCSSKeyword__moz_menubartext,
+eCSSKeyword__moz_menubarhovertext,
+eCSSKeyword__moz_middle_with_baseline,
+eCSSKeyword__moz_min_content,
+eCSSKeyword__moz_nativehyperlinktext,
+eCSSKeyword__moz_none,
+eCSSKeyword__moz_oddtreerow,
+eCSSKeyword__moz_popup,
+eCSSKeyword__moz_pre_space,
+eCSSKeyword__moz_pull_down_menu,
+eCSSKeyword__moz_right,
+eCSSKeyword__moz_scrollbars_horizontal,
+eCSSKeyword__moz_scrollbars_none,
+eCSSKeyword__moz_scrollbars_vertical,
+eCSSKeyword__moz_stack,
+eCSSKeyword__moz_text,
+eCSSKeyword__moz_use_system_font,
+eCSSKeyword__moz_visitedhyperlinktext,
+eCSSKeyword__moz_window,
+eCSSKeyword__moz_workspace,
+eCSSKeyword__moz_zoom_in,
+eCSSKeyword__moz_zoom_out,
+eCSSKeyword__webkit_box,
+eCSSKeyword__webkit_flex,
+eCSSKeyword__webkit_inline_box,
+eCSSKeyword__webkit_inline_flex,
+eCSSKeyword_absolute,
+eCSSKeyword_active,
+eCSSKeyword_activeborder,
+eCSSKeyword_activecaption,
+eCSSKeyword_add,
+eCSSKeyword_additive,
+eCSSKeyword_alias,
+eCSSKeyword_all,
+eCSSKeyword_all_petite_caps,
+eCSSKeyword_all_scroll,
+eCSSKeyword_all_small_caps,
+eCSSKeyword_alpha,
+eCSSKeyword_alternate,
+eCSSKeyword_alternate_reverse,
+eCSSKeyword_always,
+eCSSKeyword_annotation,
+eCSSKeyword_appworkspace,
+eCSSKeyword_auto,
+eCSSKeyword_auto_fill,
+eCSSKeyword_auto_fit,
+eCSSKeyword_auto_flow,
+eCSSKeyword_avoid,
+eCSSKeyword_background,
+eCSSKeyword_backwards,
+eCSSKeyword_balance,
+eCSSKeyword_baseline,
+eCSSKeyword_bidi_override,
+eCSSKeyword_blink,
+eCSSKeyword_block,
+eCSSKeyword_block_axis,
+eCSSKeyword_blur,
+eCSSKeyword_bold,
+eCSSKeyword_bold_fraktur,
+eCSSKeyword_bold_italic,
+eCSSKeyword_bold_sans_serif,
+eCSSKeyword_bold_script,
+eCSSKeyword_bolder,
+eCSSKeyword_border_box,
+eCSSKeyword_both,
+eCSSKeyword_bottom,
+eCSSKeyword_bottom_outside,
+eCSSKeyword_break_all,
+eCSSKeyword_break_word,
+eCSSKeyword_brightness,
+eCSSKeyword_browser,
+eCSSKeyword_bullets,
+eCSSKeyword_button,
+eCSSKeyword_buttonface,
+eCSSKeyword_buttonhighlight,
+eCSSKeyword_buttonshadow,
+eCSSKeyword_buttontext,
+eCSSKeyword_capitalize,
+eCSSKeyword_caption,
+eCSSKeyword_captiontext,
+eCSSKeyword_cell,
+eCSSKeyword_center,
+eCSSKeyword_ch,
+eCSSKeyword_character_variant,
+eCSSKeyword_circle,
+eCSSKeyword_cjk_decimal,
+eCSSKeyword_clip,
+eCSSKeyword_clone,
+eCSSKeyword_close_quote,
+eCSSKeyword_closest_corner,
+eCSSKeyword_closest_side,
+eCSSKeyword_cm,
+eCSSKeyword_col_resize,
+eCSSKeyword_collapse,
+eCSSKeyword_color,
+eCSSKeyword_color_burn,
+eCSSKeyword_color_dodge,
+eCSSKeyword_common_ligatures,
+eCSSKeyword_column,
+eCSSKeyword_column_reverse,
+eCSSKeyword_condensed,
+eCSSKeyword_contain,
+eCSSKeyword_content_box,
+eCSSKeyword_contents,
+eCSSKeyword_context_fill,
+eCSSKeyword_context_fill_opacity,
+eCSSKeyword_context_menu,
+eCSSKeyword_context_stroke,
+eCSSKeyword_context_stroke_opacity,
+eCSSKeyword_context_value,
+eCSSKeyword_continuous,
+eCSSKeyword_contrast,
+eCSSKeyword_copy,
+eCSSKeyword_contextual,
+eCSSKeyword_cover,
+eCSSKeyword_crop,
+eCSSKeyword_cross,
+eCSSKeyword_crosshair,
+eCSSKeyword_currentcolor,
+eCSSKeyword_cursive,
+eCSSKeyword_cyclic,
+eCSSKeyword_darken,
+eCSSKeyword_dashed,
+eCSSKeyword_dense,
+eCSSKeyword_decimal,
+eCSSKeyword_default,
+eCSSKeyword_deg,
+eCSSKeyword_diagonal_fractions,
+eCSSKeyword_dialog,
+eCSSKeyword_difference,
+eCSSKeyword_digits,
+eCSSKeyword_disabled,
+eCSSKeyword_disc,
+eCSSKeyword_disclosure_closed,
+eCSSKeyword_disclosure_open,
+eCSSKeyword_discretionary_ligatures,
+eCSSKeyword_distribute,
+eCSSKeyword_dot,
+eCSSKeyword_dotted,
+eCSSKeyword_double,
+eCSSKeyword_double_circle,
+eCSSKeyword_double_struck,
+eCSSKeyword_drag,
+eCSSKeyword_drop_shadow,
+eCSSKeyword_e_resize,
+eCSSKeyword_ease,
+eCSSKeyword_ease_in,
+eCSSKeyword_ease_in_out,
+eCSSKeyword_ease_out,
+eCSSKeyword_economy,
+eCSSKeyword_element,
+eCSSKeyword_elements,
+eCSSKeyword_ellipse,
+eCSSKeyword_ellipsis,
+eCSSKeyword_em,
+eCSSKeyword_embed,
+eCSSKeyword_enabled,
+eCSSKeyword_end,
+eCSSKeyword_ethiopic_numeric,
+eCSSKeyword_ex,
+eCSSKeyword_exact,
+eCSSKeyword_exclude,
+eCSSKeyword_exclusion,
+eCSSKeyword_expanded,
+eCSSKeyword_extends,
+eCSSKeyword_extra_condensed,
+eCSSKeyword_extra_expanded,
+eCSSKeyword_ew_resize,
+eCSSKeyword_fallback,
+eCSSKeyword_fantasy,
+eCSSKeyword_farthest_side,
+eCSSKeyword_farthest_corner,
+eCSSKeyword_fill,
+eCSSKeyword_filled,
+eCSSKeyword_fill_box,
+eCSSKeyword_first,
+eCSSKeyword_fit_content,
+eCSSKeyword_fixed,
+eCSSKeyword_flat,
+eCSSKeyword_flex,
+eCSSKeyword_flex_end,
+eCSSKeyword_flex_start,
+eCSSKeyword_flip,
+eCSSKeyword_flow_root,
+eCSSKeyword_forwards,
+eCSSKeyword_fraktur,
+eCSSKeyword_frames,
+eCSSKeyword_from_image,
+eCSSKeyword_full_width,
+eCSSKeyword_fullscreen,
+eCSSKeyword_grab,
+eCSSKeyword_grabbing,
+eCSSKeyword_grad,
+eCSSKeyword_grayscale,
+eCSSKeyword_graytext,
+eCSSKeyword_grid,
+eCSSKeyword_groove,
+eCSSKeyword_hard_light,
+eCSSKeyword_hebrew,
+eCSSKeyword_help,
+eCSSKeyword_hidden,
+eCSSKeyword_hide,
+eCSSKeyword_highlight,
+eCSSKeyword_highlighttext,
+eCSSKeyword_historical_forms,
+eCSSKeyword_historical_ligatures,
+eCSSKeyword_horizontal,
+eCSSKeyword_horizontal_tb,
+eCSSKeyword_hue,
+eCSSKeyword_hue_rotate,
+eCSSKeyword_hz,
+eCSSKeyword_icon,
+eCSSKeyword_ignore,
+eCSSKeyword_in,
+eCSSKeyword_interlace,
+eCSSKeyword_inactive,
+eCSSKeyword_inactiveborder,
+eCSSKeyword_inactivecaption,
+eCSSKeyword_inactivecaptiontext,
+eCSSKeyword_infinite,
+eCSSKeyword_infobackground,
+eCSSKeyword_infotext,
+eCSSKeyword_inherit,
+eCSSKeyword_initial,
+eCSSKeyword_inline,
+eCSSKeyword_inline_axis,
+eCSSKeyword_inline_block,
+eCSSKeyword_inline_end,
+eCSSKeyword_inline_flex,
+eCSSKeyword_inline_grid,
+eCSSKeyword_inline_start,
+eCSSKeyword_inline_table,
+eCSSKeyword_inset,
+eCSSKeyword_inside,
+eCSSKeyword_inter_character,
+eCSSKeyword_inter_word,
+eCSSKeyword_interpolatematrix,
+eCSSKeyword_accumulatematrix,
+eCSSKeyword_intersect,
+eCSSKeyword_isolate,
+eCSSKeyword_isolate_override,
+eCSSKeyword_invert,
+eCSSKeyword_italic,
+eCSSKeyword_japanese_formal,
+eCSSKeyword_japanese_informal,
+eCSSKeyword_jis78,
+eCSSKeyword_jis83,
+eCSSKeyword_jis90,
+eCSSKeyword_jis04,
+eCSSKeyword_justify,
+eCSSKeyword_keep_all,
+eCSSKeyword_khz,
+eCSSKeyword_korean_hangul_formal,
+eCSSKeyword_korean_hanja_formal,
+eCSSKeyword_korean_hanja_informal,
+eCSSKeyword_landscape,
+eCSSKeyword_large,
+eCSSKeyword_larger,
+eCSSKeyword_last,
+eCSSKeyword_last_baseline,
+eCSSKeyword_layout,
+eCSSKeyword_left,
+eCSSKeyword_legacy,
+eCSSKeyword_lighten,
+eCSSKeyword_lighter,
+eCSSKeyword_line_through,
+eCSSKeyword_linear,
+eCSSKeyword_lining_nums,
+eCSSKeyword_list_item,
+eCSSKeyword_local,
+eCSSKeyword_logical,
+eCSSKeyword_looped,
+eCSSKeyword_lowercase,
+eCSSKeyword_lr,
+eCSSKeyword_lr_tb,
+eCSSKeyword_ltr,
+eCSSKeyword_luminance,
+eCSSKeyword_luminosity,
+eCSSKeyword_mandatory,
+eCSSKeyword_manipulation,
+eCSSKeyword_manual,
+eCSSKeyword_margin_box,
+eCSSKeyword_markers,
+eCSSKeyword_match_parent,
+eCSSKeyword_match_source,
+eCSSKeyword_matrix,
+eCSSKeyword_matrix3d,
+eCSSKeyword_max_content,
+eCSSKeyword_medium,
+eCSSKeyword_menu,
+eCSSKeyword_menutext,
+eCSSKeyword_message_box,
+eCSSKeyword_middle,
+eCSSKeyword_min_content,
+eCSSKeyword_minmax,
+eCSSKeyword_mix,
+eCSSKeyword_mixed,
+eCSSKeyword_mm,
+eCSSKeyword_monospace,
+eCSSKeyword_move,
+eCSSKeyword_ms,
+eCSSKeyword_multiply,
+eCSSKeyword_n_resize,
+eCSSKeyword_narrower,
+eCSSKeyword_ne_resize,
+eCSSKeyword_nesw_resize,
+eCSSKeyword_no_clip,
+eCSSKeyword_no_close_quote,
+eCSSKeyword_no_common_ligatures,
+eCSSKeyword_no_contextual,
+eCSSKeyword_no_discretionary_ligatures,
+eCSSKeyword_no_drag,
+eCSSKeyword_no_drop,
+eCSSKeyword_no_historical_ligatures,
+eCSSKeyword_no_open_quote,
+eCSSKeyword_no_repeat,
+eCSSKeyword_none,
+eCSSKeyword_normal,
+eCSSKeyword_not_allowed,
+eCSSKeyword_nowrap,
+eCSSKeyword_numeric,
+eCSSKeyword_ns_resize,
+eCSSKeyword_nw_resize,
+eCSSKeyword_nwse_resize,
+eCSSKeyword_oblique,
+eCSSKeyword_oldstyle_nums,
+eCSSKeyword_opacity,
+eCSSKeyword_open,
+eCSSKeyword_open_quote,
+eCSSKeyword_optional,
+eCSSKeyword_ordinal,
+eCSSKeyword_ornaments,
+eCSSKeyword_outset,
+eCSSKeyword_outside,
+eCSSKeyword_over,
+eCSSKeyword_overlay,
+eCSSKeyword_overline,
+eCSSKeyword_paint,
+eCSSKeyword_padding_box,
+eCSSKeyword_painted,
+eCSSKeyword_pan_x,
+eCSSKeyword_pan_y,
+eCSSKeyword_paused,
+eCSSKeyword_pc,
+eCSSKeyword_perspective,
+eCSSKeyword_petite_caps,
+eCSSKeyword_physical,
+eCSSKeyword_plaintext,
+eCSSKeyword_pointer,
+eCSSKeyword_polygon,
+eCSSKeyword_portrait,
+eCSSKeyword_pre,
+eCSSKeyword_pre_wrap,
+eCSSKeyword_pre_line,
+eCSSKeyword_preserve_3d,
+eCSSKeyword_progress,
+eCSSKeyword_progressive,
+eCSSKeyword_proportional_nums,
+eCSSKeyword_proportional_width,
+eCSSKeyword_proximity,
+eCSSKeyword_pt,
+eCSSKeyword_px,
+eCSSKeyword_rad,
+eCSSKeyword_read_only,
+eCSSKeyword_read_write,
+eCSSKeyword_relative,
+eCSSKeyword_repeat,
+eCSSKeyword_repeat_x,
+eCSSKeyword_repeat_y,
+eCSSKeyword_reverse,
+eCSSKeyword_ridge,
+eCSSKeyword_right,
+eCSSKeyword_rl,
+eCSSKeyword_rl_tb,
+eCSSKeyword_rotate,
+eCSSKeyword_rotate3d,
+eCSSKeyword_rotatex,
+eCSSKeyword_rotatey,
+eCSSKeyword_rotatez,
+eCSSKeyword_round,
+eCSSKeyword_row,
+eCSSKeyword_row_resize,
+eCSSKeyword_row_reverse,
+eCSSKeyword_rtl,
+eCSSKeyword_ruby,
+eCSSKeyword_ruby_base,
+eCSSKeyword_ruby_base_container,
+eCSSKeyword_ruby_text,
+eCSSKeyword_ruby_text_container,
+eCSSKeyword_running,
+eCSSKeyword_s,
+eCSSKeyword_s_resize,
+eCSSKeyword_safe,
+eCSSKeyword_saturate,
+eCSSKeyword_saturation,
+eCSSKeyword_scale,
+eCSSKeyword_scale_down,
+eCSSKeyword_scale3d,
+eCSSKeyword_scalex,
+eCSSKeyword_scaley,
+eCSSKeyword_scalez,
+eCSSKeyword_screen,
+eCSSKeyword_script,
+eCSSKeyword_scroll,
+eCSSKeyword_scrollbar,
+eCSSKeyword_scrollbar_small,
+eCSSKeyword_scrollbar_horizontal,
+eCSSKeyword_scrollbar_vertical,
+eCSSKeyword_se_resize,
+eCSSKeyword_select_after,
+eCSSKeyword_select_all,
+eCSSKeyword_select_before,
+eCSSKeyword_select_menu,
+eCSSKeyword_select_same,
+eCSSKeyword_self_end,
+eCSSKeyword_self_start,
+eCSSKeyword_semi_condensed,
+eCSSKeyword_semi_expanded,
+eCSSKeyword_separate,
+eCSSKeyword_sepia,
+eCSSKeyword_serif,
+eCSSKeyword_sesame,
+eCSSKeyword_show,
+eCSSKeyword_sideways,
+eCSSKeyword_sideways_lr,
+eCSSKeyword_sideways_right,
+eCSSKeyword_sideways_rl,
+eCSSKeyword_simp_chinese_formal,
+eCSSKeyword_simp_chinese_informal,
+eCSSKeyword_simplified,
+eCSSKeyword_skew,
+eCSSKeyword_skewx,
+eCSSKeyword_skewy,
+eCSSKeyword_slashed_zero,
+eCSSKeyword_slice,
+eCSSKeyword_small,
+eCSSKeyword_small_caps,
+eCSSKeyword_small_caption,
+eCSSKeyword_smaller,
+eCSSKeyword_smooth,
+eCSSKeyword_soft,
+eCSSKeyword_soft_light,
+eCSSKeyword_solid,
+eCSSKeyword_space_around,
+eCSSKeyword_space_between,
+eCSSKeyword_space_evenly,
+eCSSKeyword_span,
+eCSSKeyword_spell_out,
+eCSSKeyword_square,
+eCSSKeyword_stacked_fractions,
+eCSSKeyword_start,
+eCSSKeyword_static,
+eCSSKeyword_standalone,
+eCSSKeyword_status_bar,
+eCSSKeyword_step_end,
+eCSSKeyword_step_start,
+eCSSKeyword_sticky,
+eCSSKeyword_stretch,
+eCSSKeyword_stretch_to_fit,
+eCSSKeyword_stretched,
+eCSSKeyword_strict,
+eCSSKeyword_stroke,
+eCSSKeyword_stroke_box,
+eCSSKeyword_style,
+eCSSKeyword_styleset,
+eCSSKeyword_stylistic,
+eCSSKeyword_sub,
+eCSSKeyword_subgrid,
+eCSSKeyword_subtract,
+eCSSKeyword_super,
+eCSSKeyword_sw_resize,
+eCSSKeyword_swash,
+eCSSKeyword_swap,
+eCSSKeyword_table,
+eCSSKeyword_table_caption,
+eCSSKeyword_table_cell,
+eCSSKeyword_table_column,
+eCSSKeyword_table_column_group,
+eCSSKeyword_table_footer_group,
+eCSSKeyword_table_header_group,
+eCSSKeyword_table_row,
+eCSSKeyword_table_row_group,
+eCSSKeyword_tabular_nums,
+eCSSKeyword_tailed,
+eCSSKeyword_tb,
+eCSSKeyword_tb_rl,
+eCSSKeyword_text,
+eCSSKeyword_text_bottom,
+eCSSKeyword_text_top,
+eCSSKeyword_thick,
+eCSSKeyword_thin,
+eCSSKeyword_threeddarkshadow,
+eCSSKeyword_threedface,
+eCSSKeyword_threedhighlight,
+eCSSKeyword_threedlightshadow,
+eCSSKeyword_threedshadow,
+eCSSKeyword_titling_caps,
+eCSSKeyword_toggle,
+eCSSKeyword_top,
+eCSSKeyword_top_outside,
+eCSSKeyword_trad_chinese_formal,
+eCSSKeyword_trad_chinese_informal,
+eCSSKeyword_traditional,
+eCSSKeyword_translate,
+eCSSKeyword_translate3d,
+eCSSKeyword_translatex,
+eCSSKeyword_translatey,
+eCSSKeyword_translatez,
+eCSSKeyword_transparent,
+eCSSKeyword_triangle,
+eCSSKeyword_tri_state,
+eCSSKeyword_ultra_condensed,
+eCSSKeyword_ultra_expanded,
+eCSSKeyword_under,
+eCSSKeyword_underline,
+eCSSKeyword_unicase,
+eCSSKeyword_unsafe,
+eCSSKeyword_unset,
+eCSSKeyword_uppercase,
+eCSSKeyword_upright,
+eCSSKeyword_vertical,
+eCSSKeyword_vertical_lr,
+eCSSKeyword_vertical_rl,
+eCSSKeyword_vertical_text,
+eCSSKeyword_view_box,
+eCSSKeyword_visible,
+eCSSKeyword_visiblefill,
+eCSSKeyword_visiblepainted,
+eCSSKeyword_visiblestroke,
+eCSSKeyword_w_resize,
+eCSSKeyword_wait,
+eCSSKeyword_wavy,
+eCSSKeyword_weight,
+eCSSKeyword_wider,
+eCSSKeyword_window,
+eCSSKeyword_windowframe,
+eCSSKeyword_windowtext,
+eCSSKeyword_words,
+eCSSKeyword_wrap,
+eCSSKeyword_wrap_reverse,
+eCSSKeyword_write_only,
+eCSSKeyword_x_large,
+eCSSKeyword_x_small,
+eCSSKeyword_xx_large,
+eCSSKeyword_xx_small,
+eCSSKeyword_zoom_in,
+eCSSKeyword_zoom_out,
+
+
+eCSSKeyword_radio,
+eCSSKeyword_checkbox,
+eCSSKeyword_button_bevel,
+eCSSKeyword_toolbox,
+eCSSKeyword_toolbar,
+eCSSKeyword_toolbarbutton,
+eCSSKeyword_toolbargripper,
+eCSSKeyword_dualbutton,
+eCSSKeyword_toolbarbutton_dropdown,
+eCSSKeyword_button_arrow_up,
+eCSSKeyword_button_arrow_down,
+eCSSKeyword_button_arrow_next,
+eCSSKeyword_button_arrow_previous,
+eCSSKeyword_separator,
+eCSSKeyword_splitter,
+eCSSKeyword_statusbar,
+eCSSKeyword_statusbarpanel,
+eCSSKeyword_resizerpanel,
+eCSSKeyword_resizer,
+eCSSKeyword_listbox,
+eCSSKeyword_listitem,
+eCSSKeyword_numbers,
+eCSSKeyword_number_input,
+eCSSKeyword_treeview,
+eCSSKeyword_treeitem,
+eCSSKeyword_treetwisty,
+eCSSKeyword_treetwistyopen,
+eCSSKeyword_treeline,
+eCSSKeyword_treeheader,
+eCSSKeyword_treeheadercell,
+eCSSKeyword_treeheadersortarrow,
+eCSSKeyword_progressbar,
+eCSSKeyword_progressbar_vertical,
+eCSSKeyword_progresschunk,
+eCSSKeyword_progresschunk_vertical,
+eCSSKeyword_tab,
+eCSSKeyword_tabpanels,
+eCSSKeyword_tabpanel,
+eCSSKeyword_tab_scroll_arrow_back,
+eCSSKeyword_tab_scroll_arrow_forward,
+eCSSKeyword_tooltip,
+eCSSKeyword_spinner,
+eCSSKeyword_spinner_upbutton,
+eCSSKeyword_spinner_downbutton,
+eCSSKeyword_spinner_textfield,
+eCSSKeyword_scrollbarbutton_up,
+eCSSKeyword_scrollbarbutton_down,
+eCSSKeyword_scrollbarbutton_left,
+eCSSKeyword_scrollbarbutton_right,
+eCSSKeyword_scrollbartrack_horizontal,
+eCSSKeyword_scrollbartrack_vertical,
+eCSSKeyword_scrollbarthumb_horizontal,
+eCSSKeyword_scrollbarthumb_vertical,
+eCSSKeyword_sheet,
+eCSSKeyword_textfield,
+eCSSKeyword_textfield_multiline,
+eCSSKeyword_caret,
+eCSSKeyword_searchfield,
+eCSSKeyword_menubar,
+eCSSKeyword_menupopup,
+eCSSKeyword_menuitem,
+eCSSKeyword_checkmenuitem,
+eCSSKeyword_radiomenuitem,
+eCSSKeyword_menucheckbox,
+eCSSKeyword_menuradio,
+eCSSKeyword_menuseparator,
+eCSSKeyword_menuarrow,
+eCSSKeyword_menuimage,
+eCSSKeyword_menuitemtext,
+eCSSKeyword_menulist,
+eCSSKeyword_menulist_button,
+eCSSKeyword_menulist_text,
+eCSSKeyword_menulist_textfield,
+eCSSKeyword_meterbar,
+eCSSKeyword_meterchunk,
+eCSSKeyword_minimal_ui,
+eCSSKeyword_range,
+eCSSKeyword_range_thumb,
+eCSSKeyword_sans_serif,
+eCSSKeyword_sans_serif_bold_italic,
+eCSSKeyword_sans_serif_italic,
+eCSSKeyword_scale_horizontal,
+eCSSKeyword_scale_vertical,
+eCSSKeyword_scalethumb_horizontal,
+eCSSKeyword_scalethumb_vertical,
+eCSSKeyword_scalethumbstart,
+eCSSKeyword_scalethumbend,
+eCSSKeyword_scalethumbtick,
+eCSSKeyword_groupbox,
+eCSSKeyword_checkbox_container,
+eCSSKeyword_radio_container,
+eCSSKeyword_checkbox_label,
+eCSSKeyword_radio_label,
+eCSSKeyword_button_focus,
+eCSSKeyword__moz_win_media_toolbox,
+eCSSKeyword__moz_win_communications_toolbox,
+eCSSKeyword__moz_win_browsertabbar_toolbox,
+eCSSKeyword__moz_win_mediatext,
+eCSSKeyword__moz_win_communicationstext,
+eCSSKeyword__moz_win_glass,
+eCSSKeyword__moz_win_borderless_glass,
+eCSSKeyword__moz_window_titlebar,
+eCSSKeyword__moz_window_titlebar_maximized,
+eCSSKeyword__moz_window_frame_left,
+eCSSKeyword__moz_window_frame_right,
+eCSSKeyword__moz_window_frame_bottom,
+eCSSKeyword__moz_window_button_close,
+eCSSKeyword__moz_window_button_minimize,
+eCSSKeyword__moz_window_button_maximize,
+eCSSKeyword__moz_window_button_restore,
+eCSSKeyword__moz_window_button_box,
+eCSSKeyword__moz_window_button_box_maximized,
+eCSSKeyword__moz_mac_help_button,
+eCSSKeyword__moz_win_exclude_glass,
+eCSSKeyword__moz_mac_vibrancy_light,
+eCSSKeyword__moz_mac_vibrancy_dark,
+eCSSKeyword__moz_mac_disclosure_button_closed,
+eCSSKeyword__moz_mac_disclosure_button_open,
+eCSSKeyword__moz_mac_source_list,
+eCSSKeyword__moz_mac_source_list_selection,
+eCSSKeyword__moz_mac_active_source_list_selection,
+eCSSKeyword_alphabetic,
+eCSSKeyword_bevel,
+eCSSKeyword_butt,
+eCSSKeyword_central,
+eCSSKeyword_crispedges,
+eCSSKeyword_evenodd,
+eCSSKeyword_geometricprecision,
+eCSSKeyword_hanging,
+eCSSKeyword_ideographic,
+eCSSKeyword_linearrgb,
+eCSSKeyword_mathematical,
+
+eCSSKeyword_miter,
+eCSSKeyword_no_change,
+eCSSKeyword_non_scaling_stroke,
+eCSSKeyword_nonzero,
+eCSSKeyword_optimizelegibility,
+eCSSKeyword_optimizequality,
+eCSSKeyword_optimizespeed,
+eCSSKeyword_reset_size,
+
+
+eCSSKeyword_srgb,
+eCSSKeyword_symbolic,
+eCSSKeyword_symbols,
+eCSSKeyword_text_after_edge,
+eCSSKeyword_text_before_edge,
+eCSSKeyword_use_script,
+eCSSKeyword__moz_crisp_edges,
+eCSSKeyword_space,
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h" 2
+ eCSSKeyword_COUNT
+};
+
+
+
+class nsCSSKeywords {
+public:
+  static void AddRefTable(void);
+  static void ReleaseTable(void);
+
+
+  static nsCSSKeyword LookupKeyword(const nsACString& aKeyword);
+  static nsCSSKeyword LookupKeyword(const nsAString& aKeyword);
+
+
+  static const nsAFlatCString& GetStringValue(nsCSSKeyword aKeyword);
+};
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 1
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h"
+enum nsCSSPropertyID {
+  eCSSProperty_UNKNOWN = -1,
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h" 1
+# 328 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_align_content,
+# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_align_items,
+# 348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_align_self,
+# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_delay,
+# 381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_direction,
+# 392 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_duration,
+# 403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_fill_mode,
+# 414 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_iteration_count,
+# 428 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_name,
+# 441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_play_state,
+# 452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_animation_timing_function,
+# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_appearance,
+# 474 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_appearance,
+# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_backface_visibility,
+# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_attachment,
+# 514 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_blend_mode,
+# 527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_clip,
+# 540 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_color,
+# 554 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_image,
+# 569 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_origin,
+# 589 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_position_x,
+# 603 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_position_y,
+# 617 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_repeat,
+# 630 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_size,
+# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_binding,
+# 655 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_block_size,
+# 685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_end_color,
+# 701 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_end_style,
+# 717 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_end_width,
+# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_start_color,
+# 756 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_start_style,
+# 771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_start_width,
+# 794 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom_color,
+# 807 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_border_bottom_colors,
+# 819 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom_left_radius,
+# 832 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom_right_radius,
+# 845 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom_style,
+# 856 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom_width,
+# 870 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_collapse,
+# 893 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_image_outset,
+# 904 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_image_repeat,
+# 915 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_image_slice,
+# 926 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_image_source,
+# 938 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_image_width,
+# 955 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_end_color,
+# 970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_end_style,
+# 985 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_end_width,
+# 1008 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_start_color,
+# 1022 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_start_style,
+# 1036 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_start_width,
+# 1058 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_left_color,
+# 1071 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_border_left_colors,
+# 1083 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_left_style,
+# 1094 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_left_width,
+# 1120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_right_color,
+# 1133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_border_right_colors,
+# 1145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_right_style,
+# 1156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_right_width,
+# 1170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_spacing,
+# 1194 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_top_color,
+# 1207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_border_top_colors,
+# 1219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_top_left_radius,
+# 1232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_top_right_radius,
+# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_top_style,
+# 1256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_top_width,
+# 1277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_bottom,
+# 1290 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_align,
+# 1300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_box_decoration_break,
+# 1310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_direction,
+# 1320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_flex,
+# 1331 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_ordinal_group,
+# 1342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_orient,
+# 1352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_box_pack,
+# 1362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_box_shadow,
+# 1376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_box_sizing,
+# 1386 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_caption_side,
+# 1396 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_caret_color,
+# 1407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_clear,
+# 1417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_clip,
+# 1428 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_clip_path,
+# 1441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_clip_rule,
+# 1451 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_color,
+# 1465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_color_adjust,
+# 1475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_color_interpolation,
+# 1485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_color_interpolation_filters,
+# 1495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_count,
+# 1508 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_fill,
+# 1518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_gap,
+# 1535 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_rule_color,
+# 1546 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_rule_style,
+# 1556 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_rule_width,
+# 1567 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_span,
+# 1577 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_width,
+# 1594 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_contain,
+# 1607 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_content,
+# 1619 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_control_character_visibility,
+# 1631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_counter_increment,
+# 1641 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_counter_reset,
+# 1651 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_cursor,
+# 1665 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_direction,
+# 1676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_display,
+# 1690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_dominant_baseline,
+# 1700 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_empty_cells,
+# 1710 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_fill,
+# 1720 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_fill_opacity,
+# 1730 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_fill_rule,
+# 1740 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_filter,
+# 1758 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_basis,
+# 1773 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_direction,
+# 1789 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_grow,
+# 1803 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_shrink,
+# 1817 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_wrap,
+# 1827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_float_,
+# 1838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_float_edge,
+# 1848 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flood_color,
+# 1858 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flood_opacity,
+# 1874 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_family,
+# 1887 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_feature_settings,
+# 1900 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_kerning,
+# 1912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_language_override,
+# 1924 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_size,
+# 1940 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_size_adjust,
+# 1953 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_stretch,
+# 1965 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_style,
+# 1977 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_synthesis,
+# 1996 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_alternates,
+# 2009 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_caps,
+# 2021 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_east_asian,
+# 2034 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_ligatures,
+# 2047 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_numeric,
+# 2060 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant_position,
+# 2072 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variation_settings,
+# 2086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_weight,
+# 2100 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_force_broken_image_icon,
+# 2123 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_auto_columns,
+# 2135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_auto_flow,
+# 2146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_auto_rows,
+# 2164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_column_end,
+# 2174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_column_gap,
+# 2186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_column_start,
+# 2208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_row_end,
+# 2218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_row_gap,
+# 2230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_row_start,
+# 2246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_template_areas,
+# 2257 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_template_columns,
+# 2270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_template_rows,
+# 2283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_height,
+# 2297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_hyphens,
+# 2307 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_initial_letter,
+# 2318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_image_orientation,
+# 2329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_image_region,
+# 2339 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_image_rendering,
+# 2349 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_ime_mode,
+# 2359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_inline_size,
+# 2376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_isolation,
+# 2387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_justify_content,
+# 2397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_justify_items,
+# 2408 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_justify_self,
+# 2420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__x_lang,
+# 2433 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_left,
+# 2446 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_letter_spacing,
+# 2459 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_lighting_color,
+# 2469 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_line_height,
+# 2489 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_list_style_image,
+# 2500 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_list_style_position,
+# 2510 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_list_style_type,
+# 2529 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_block_end,
+# 2548 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_block_start,
+# 2566 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_bottom,
+# 2581 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_inline_end,
+# 2598 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_inline_start,
+# 2614 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_left,
+# 2629 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_right,
+# 2644 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin_top,
+# 2665 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_marker_end,
+# 2675 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_marker_mid,
+# 2685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_marker_start,
+# 2714 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_clip,
+# 2725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_composite,
+# 2736 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_image,
+# 2749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_mode,
+# 2760 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_origin,
+# 2778 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_position_x,
+# 2790 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_position_y,
+# 2802 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_repeat,
+# 2813 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_size,
+# 2827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_type,
+# 2839 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_math_display,
+# 2851 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_math_variant,
+# 2864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_max_block_size,
+# 2882 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_max_height,
+# 2895 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_max_inline_size,
+# 2912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_max_width,
+# 2925 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_min_block_size,
+# 2944 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_min_font_size_ratio,
+# 2957 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_min_height,
+# 2970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_min_inline_size,
+# 2987 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_min_width,
+# 3000 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mix_blend_mode,
+# 3011 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_object_fit,
+# 3021 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_object_position,
+# 3032 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_offset_block_end,
+# 3049 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_offset_block_start,
+# 3065 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_offset_inline_end,
+# 3081 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_offset_inline_start,
+# 3096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_opacity,
+# 3109 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_order,
+# 3119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_orient,
+# 3129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_osx_font_smoothing,
+# 3147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_outline_color,
+# 3158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_outline_offset,
+# 3174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_outline_radius_bottomleft,
+# 3186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_outline_radius_bottomright,
+# 3198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_outline_radius_topleft,
+# 3210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_outline_radius_topright,
+# 3222 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_outline_style,
+# 3232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_outline_width,
+# 3249 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_overflow_clip_box,
+# 3261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_overflow_x,
+# 3273 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_overflow_y,
+# 3292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_block_end,
+# 3313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_block_start,
+# 3333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_bottom,
+# 3350 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_inline_end,
+# 3370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_inline_start,
+# 3389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_left,
+# 3406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_right,
+# 3423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding_top,
+# 3440 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_page_break_after,
+# 3450 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_page_break_before,
+# 3460 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_page_break_inside,
+# 3470 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_paint_order,
+# 3480 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_perspective,
+# 3493 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_perspective_origin,
+# 3523 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_pointer_events,
+# 3534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_position,
+# 3547 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_quotes,
+# 3557 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_resize,
+# 3571 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_right,
+# 3584 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_ruby_align,
+# 3594 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_ruby_position,
+# 3606 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_script_level,
+# 3624 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_script_min_size,
+# 3635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_script_size_multiplier,
+# 3648 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_behavior,
+# 3658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_coordinate,
+# 3671 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_destination,
+# 3683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_points_x,
+# 3695 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_points_y,
+# 3713 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_type_x,
+# 3723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_type_y,
+# 3733 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_shape_outside,
+# 3745 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_shape_rendering,
+# 3757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__x_span,
+# 3770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_stack_sizing,
+# 3780 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stop_color,
+# 3790 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stop_opacity,
+# 3800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke,
+# 3810 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_dasharray,
+# 3823 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_dashoffset,
+# 3834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_linecap,
+# 3844 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_linejoin,
+# 3854 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_miterlimit,
+# 3865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_opacity,
+# 3875 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_stroke_width,
+# 3888 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__x_system_font,
+# 3902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_tab_size,
+# 3913 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_table_layout,
+# 3923 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_align,
+# 3936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_align_last,
+# 3946 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_anchor,
+# 3956 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_combine_upright,
+# 3973 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_decoration_color,
+# 3986 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_decoration_line,
+# 3999 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_decoration_style,
+# 4017 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_emphasis_color,
+# 4028 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_emphasis_position,
+# 4039 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_emphasis_style,
+# 4050 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__webkit_text_fill_color,
+# 4063 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_indent,
+# 4075 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_justify,
+# 4086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_orientation,
+# 4096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_overflow,
+# 4108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_rendering,
+# 4118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_shadow,
+# 4133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_text_size_adjust,
+# 4149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__webkit_text_stroke_color,
+# 4162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__webkit_text_stroke_width,
+# 4175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_transform,
+# 4189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__x_text_zoom,
+# 4202 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_top,
+# 4216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_top_layer,
+# 4229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_touch_action,
+# 4240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transform,
+# 4263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transform_box,
+# 4273 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transform_origin,
+# 4285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transform_style,
+# 4303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transition_delay,
+# 4314 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transition_duration,
+# 4325 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transition_property,
+# 4336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transition_timing_function,
+# 4348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_unicode_bidi,
+# 4359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_user_focus,
+# 4369 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_user_input,
+# 4379 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_user_modify,
+# 4389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_user_select,
+# 4399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_vector_effect,
+# 4412 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_vertical_align,
+# 4426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_visibility,
+# 4436 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_white_space,
+# 4448 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_width,
+# 4462 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_will_change,
+# 4473 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_window_dragging,
+# 4484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_window_shadow,
+# 4497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_word_break,
+# 4507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_word_spacing,
+# 4521 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_overflow_wrap,
+# 4531 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_writing_mode,
+# 4541 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_z_index,
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+
+
+  eCSSProperty_COUNT_no_shorthands,
+
+  eCSSProperty_COUNT_DUMMY = eCSSProperty_COUNT_no_shorthands - 1,
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h" 1
+# 358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_all,
+
+
+
+
+
+eCSSProperty_animation,
+# 495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background,
+# 582 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_background_position,
+# 673 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border,
+
+
+
+
+
+eCSSProperty_border_block_end,
+# 735 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_block_start,
+# 788 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_bottom,
+# 880 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_color,
+
+
+
+
+
+
+eCSSProperty_border_image,
+# 949 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_end,
+# 1002 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_inline_start,
+# 1052 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_left,
+# 1108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_radius,
+
+
+
+
+
+eCSSProperty_border_right,
+# 1182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_style,
+
+
+
+
+
+eCSSProperty_border_top,
+# 1270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_border_width,
+# 1529 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_column_rule,
+# 1588 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_columns,
+# 1752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex,
+# 1783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_flex_flow,
+# 1868 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font,
+# 1990 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_font_variant,
+# 2111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid,
+
+
+
+
+
+eCSSProperty_grid_area,
+# 2158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_column,
+# 2196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_gap,
+
+
+
+
+
+eCSSProperty_grid_row,
+# 2240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_grid_template,
+# 2483 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_list_style,
+# 2521 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_margin,
+# 2659 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_marker,
+# 2708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask,
+# 2771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_mask_position,
+# 3141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_outline,
+# 3168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_outline_radius,
+# 3243 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_overflow,
+# 3285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_padding,
+# 3505 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_place_content,
+
+
+
+
+
+eCSSProperty_place_items,
+
+
+
+
+
+eCSSProperty_place_self,
+# 3707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_scroll_snap_type,
+# 3967 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_decoration,
+# 4011 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_text_emphasis,
+# 4143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__webkit_text_stroke,
+# 4256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty__moz_transform,
+# 4297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
+eCSSProperty_transition,
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+
+  eCSSProperty_COUNT,
+
+  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1,
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h" 1
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h"
+eCSSPropertyAlias_WordWrap,
+
+
+
+eCSSPropertyAlias_MozTransformOrigin,
+
+
+
+eCSSPropertyAlias_MozPerspectiveOrigin,
+
+
+
+eCSSPropertyAlias_MozPerspective,
+
+
+
+eCSSPropertyAlias_MozTransformStyle,
+
+
+
+eCSSPropertyAlias_MozBackfaceVisibility,
+
+
+
+eCSSPropertyAlias_MozBorderImage,
+
+
+
+eCSSPropertyAlias_MozTransition,
+
+
+
+eCSSPropertyAlias_MozTransitionDelay,
+
+
+
+eCSSPropertyAlias_MozTransitionDuration,
+
+
+
+eCSSPropertyAlias_MozTransitionProperty,
+
+
+
+eCSSPropertyAlias_MozTransitionTimingFunction,
+
+
+
+eCSSPropertyAlias_MozAnimation,
+
+
+
+eCSSPropertyAlias_MozAnimationDelay,
+
+
+
+eCSSPropertyAlias_MozAnimationDirection,
+
+
+
+eCSSPropertyAlias_MozAnimationDuration,
+
+
+
+eCSSPropertyAlias_MozAnimationFillMode,
+
+
+
+eCSSPropertyAlias_MozAnimationIterationCount,
+
+
+
+eCSSPropertyAlias_MozAnimationName,
+
+
+
+eCSSPropertyAlias_MozAnimationPlayState,
+
+
+
+eCSSPropertyAlias_MozAnimationTimingFunction,
+
+
+
+eCSSPropertyAlias_MozBoxSizing,
+
+
+
+eCSSPropertyAlias_MozFontFeatureSettings,
+
+
+
+eCSSPropertyAlias_MozFontLanguageOverride,
+
+
+
+eCSSPropertyAlias_MozPaddingEnd,
+
+
+
+eCSSPropertyAlias_MozPaddingStart,
+
+
+
+eCSSPropertyAlias_MozMarginEnd,
+
+
+
+eCSSPropertyAlias_MozMarginStart,
+
+
+
+eCSSPropertyAlias_MozBorderEnd,
+
+
+
+eCSSPropertyAlias_MozBorderEndColor,
+
+
+
+eCSSPropertyAlias_MozBorderEndStyle,
+
+
+
+eCSSPropertyAlias_MozBorderEndWidth,
+
+
+
+eCSSPropertyAlias_MozBorderStart,
+
+
+
+eCSSPropertyAlias_MozBorderStartColor,
+
+
+
+eCSSPropertyAlias_MozBorderStartStyle,
+
+
+
+eCSSPropertyAlias_MozBorderStartWidth,
+
+
+
+eCSSPropertyAlias_MozHyphens,
+
+
+
+eCSSPropertyAlias_MozColumnCount,
+
+
+
+eCSSPropertyAlias_MozColumnFill,
+
+
+
+eCSSPropertyAlias_MozColumnGap,
+
+
+
+eCSSPropertyAlias_MozColumnRule,
+
+
+
+eCSSPropertyAlias_MozColumnRuleColor,
+
+
+
+eCSSPropertyAlias_MozColumnRuleStyle,
+
+
+
+eCSSPropertyAlias_MozColumnRuleWidth,
+
+
+
+eCSSPropertyAlias_MozColumnWidth,
+
+
+
+eCSSPropertyAlias_MozColumns,
+
+
+
+
+
+
+
+eCSSPropertyAlias_WebkitAnimation,
+
+
+
+eCSSPropertyAlias_WebkitAnimationDelay,
+
+
+
+eCSSPropertyAlias_WebkitAnimationDirection,
+
+
+
+eCSSPropertyAlias_WebkitAnimationDuration,
+
+
+
+eCSSPropertyAlias_WebkitAnimationFillMode,
+
+
+
+eCSSPropertyAlias_WebkitAnimationIterationCount,
+
+
+
+eCSSPropertyAlias_WebkitAnimationName,
+
+
+
+eCSSPropertyAlias_WebkitAnimationPlayState,
+
+
+
+eCSSPropertyAlias_WebkitAnimationTimingFunction,
+
+
+
+
+eCSSPropertyAlias_WebkitAppearance,
+
+
+
+
+eCSSPropertyAlias_WebkitFilter,
+
+
+
+eCSSPropertyAlias_WebkitTextSizeAdjust,
+
+
+
+
+eCSSPropertyAlias_WebkitTransform,
+
+
+
+eCSSPropertyAlias_WebkitTransformOrigin,
+
+
+
+eCSSPropertyAlias_WebkitTransformStyle,
+
+
+
+eCSSPropertyAlias_WebkitBackfaceVisibility,
+
+
+
+eCSSPropertyAlias_WebkitPerspective,
+
+
+
+eCSSPropertyAlias_WebkitPerspectiveOrigin,
+
+
+
+
+eCSSPropertyAlias_WebkitTransition,
+
+
+
+eCSSPropertyAlias_WebkitTransitionDelay,
+
+
+
+eCSSPropertyAlias_WebkitTransitionDuration,
+
+
+
+eCSSPropertyAlias_WebkitTransitionProperty,
+
+
+
+eCSSPropertyAlias_WebkitTransitionTimingFunction,
+
+
+
+
+eCSSPropertyAlias_WebkitBorderRadius,
+
+
+
+eCSSPropertyAlias_WebkitBorderTopLeftRadius,
+
+
+
+eCSSPropertyAlias_WebkitBorderTopRightRadius,
+
+
+
+eCSSPropertyAlias_WebkitBorderBottomLeftRadius,
+
+
+
+eCSSPropertyAlias_WebkitBorderBottomRightRadius,
+
+
+
+
+eCSSPropertyAlias_WebkitBackgroundClip,
+
+
+
+eCSSPropertyAlias_WebkitBackgroundOrigin,
+
+
+
+eCSSPropertyAlias_WebkitBackgroundSize,
+
+
+
+
+eCSSPropertyAlias_WebkitBorderImage,
+
+
+
+
+eCSSPropertyAlias_WebkitBoxShadow,
+
+
+
+eCSSPropertyAlias_WebkitBoxSizing,
+# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h"
+eCSSPropertyAlias_WebkitBoxFlex,
+
+
+
+eCSSPropertyAlias_WebkitBoxOrdinalGroup,
+
+
+
+eCSSPropertyAlias_WebkitBoxOrient,
+
+
+
+eCSSPropertyAlias_WebkitBoxDirection,
+
+
+
+eCSSPropertyAlias_WebkitBoxAlign,
+
+
+
+eCSSPropertyAlias_WebkitBoxPack,
+
+
+
+
+
+
+eCSSPropertyAlias_WebkitFlexDirection,
+
+
+
+eCSSPropertyAlias_WebkitFlexWrap,
+
+
+
+eCSSPropertyAlias_WebkitFlexFlow,
+
+
+
+eCSSPropertyAlias_WebkitOrder,
+
+
+
+eCSSPropertyAlias_WebkitFlex,
+
+
+
+eCSSPropertyAlias_WebkitFlexGrow,
+
+
+
+eCSSPropertyAlias_WebkitFlexShrink,
+
+
+
+eCSSPropertyAlias_WebkitFlexBasis,
+
+
+
+eCSSPropertyAlias_WebkitJustifyContent,
+
+
+
+eCSSPropertyAlias_WebkitAlignItems,
+
+
+
+eCSSPropertyAlias_WebkitAlignSelf,
+
+
+
+eCSSPropertyAlias_WebkitAlignContent,
+
+
+
+
+eCSSPropertyAlias_WebkitUserSelect,
+
+
+
+
+
+eCSSPropertyAlias_WebkitMask,
+
+
+
+eCSSPropertyAlias_WebkitMaskClip,
+
+
+
+eCSSPropertyAlias_WebkitMaskComposite,
+
+
+
+eCSSPropertyAlias_WebkitMaskImage,
+
+
+
+eCSSPropertyAlias_WebkitMaskOrigin,
+
+
+
+eCSSPropertyAlias_WebkitMaskPosition,
+
+
+
+eCSSPropertyAlias_WebkitMaskPositionX,
+
+
+
+eCSSPropertyAlias_WebkitMaskPositionY,
+
+
+
+eCSSPropertyAlias_WebkitMaskRepeat,
+
+
+
+eCSSPropertyAlias_WebkitMaskSize,
+# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+
+  eCSSProperty_COUNT_with_aliases,
+
+  eCSSProperty_COUNT_DUMMY3 = eCSSProperty_COUNT_with_aliases - 1,
+
+
+
+
+
+
+  eCSSPropertyExtra_no_properties,
+  eCSSPropertyExtra_all_properties,
+
+
+  eCSSPropertyExtra_x_none_value,
+  eCSSPropertyExtra_x_auto_value,
+
+
+  eCSSPropertyExtra_variable,
+
+
+  eCSSProperty_DOM
+};
+
+namespace mozilla {
+
+template<>
+inline PLDHashNumber
+Hash<nsCSSPropertyID>(const nsCSSPropertyID& aValue)
+{
+  return uint32_t(aValue);
+}
+
+}
+
+
+
+enum nsCSSFontDesc {
+  eCSSFontDesc_UNKNOWN = -1,
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSFontDescList.h" 1
+
+
+
+
+
+eCSSFontDesc_Family,
+eCSSFontDesc_Style,
+eCSSFontDesc_Weight,
+eCSSFontDesc_Stretch,
+eCSSFontDesc_Src,
+eCSSFontDesc_UnicodeRange,
+eCSSFontDesc_FontFeatureSettings,
+eCSSFontDesc_FontLanguageOverride,
+eCSSFontDesc_Display,
+# 89 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+  eCSSFontDesc_COUNT
+};
+
+
+
+enum nsCSSCounterDesc {
+  eCSSCounterDesc_UNKNOWN = -1,
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSCounterDescList.h" 1
+
+
+
+
+
+eCSSCounterDesc_System,
+eCSSCounterDesc_Symbols,
+eCSSCounterDesc_AdditiveSymbols,
+eCSSCounterDesc_Negative,
+eCSSCounterDesc_Prefix,
+eCSSCounterDesc_Suffix,
+eCSSCounterDesc_Range,
+eCSSCounterDesc_Pad,
+eCSSCounterDesc_Fallback,
+eCSSCounterDesc_SpeakAs,
+# 99 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+  eCSSCounterDesc_COUNT
+};
+
+enum nsCSSPropertyLogicalGroup {
+  eCSSPropertyLogicalGroup_UNKNOWN = -1,
+
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropLogicalGroupList.h" 1
+# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropLogicalGroupList.h"
+eCSSPropertyLogicalGroup_BorderColor,
+eCSSPropertyLogicalGroup_BorderStyle,
+eCSSPropertyLogicalGroup_BorderWidth,
+eCSSPropertyLogicalGroup_Margin,
+eCSSPropertyLogicalGroup_MaxSize,
+eCSSPropertyLogicalGroup_Offset,
+eCSSPropertyLogicalGroup_Padding,
+eCSSPropertyLogicalGroup_MinSize,
+eCSSPropertyLogicalGroup_Size,
+# 112 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
+
+
+
+  eCSSPropertyLogicalGroup_COUNT
+};
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h"
+enum nsStyleStructID {
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h"
+nsStyleStructID_None = -1,
+nsStyleStructID_Inherited_Start = 0,
+
+nsStyleStructID_DUMMY1 = nsStyleStructID_Inherited_Start - 1,
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
+eStyleStruct_Font,
+
+
+
+eStyleStruct_Color,
+
+
+eStyleStruct_List,
+
+
+
+
+eStyleStruct_Text,
+
+
+
+
+
+eStyleStruct_Visibility,
+
+
+eStyleStruct_UserInterface,
+
+
+eStyleStruct_TableBorder,
+
+
+
+
+eStyleStruct_SVG,
+
+
+
+
+
+eStyleStruct_Variables,
+# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 2
+
+
+
+nsStyleStructID_Reset_Start,
+
+nsStyleStructID_DUMMY2 = nsStyleStructID_Reset_Start - 1,
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
+# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
+eStyleStruct_Background,
+
+
+
+
+
+eStyleStruct_Position,
+
+
+
+
+eStyleStruct_TextReset,
+
+
+
+
+
+eStyleStruct_Display,
+
+
+
+
+eStyleStruct_Content,
+
+
+
+
+eStyleStruct_UIReset,
+
+
+eStyleStruct_Table,
+
+
+eStyleStruct_Margin,
+
+
+
+
+eStyleStruct_Padding,
+
+
+
+
+eStyleStruct_Border,
+
+
+
+
+
+eStyleStruct_Outline,
+
+
+
+
+
+eStyleStruct_XUL,
+
+
+eStyleStruct_SVGReset,
+
+
+
+
+
+eStyleStruct_Column,
+
+
+
+
+
+eStyleStruct_Effects,
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 2
+
+
+
+
+nsStyleStructID_Length,
+
+nsStyleStructID_Inherited_Count =
+  nsStyleStructID_Reset_Start - nsStyleStructID_Inherited_Start,
+nsStyleStructID_Reset_Count =
+  nsStyleStructID_Length - nsStyleStructID_Reset_Start,
+
+};
+
+
+
+
+typedef decltype(nsStyleStructID(0) + nsStyleStructID(0)) nsStyleStructID_size_t;
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 2
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xrecore.h" 1
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h" 1
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
+struct PRFileDesc;
+struct PRLibrary;
+
+class nsISimpleEnumerator;
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
+class nsIFile : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    NORMAL_FILE_TYPE = 0U,
+    DIRECTORY_TYPE = 1U
+  };
+
+
+  virtual nsresult Append(const nsAString & node) = 0;
+
+
+  virtual nsresult AppendNative(const nsACString & node) = 0;
+
+
+  virtual nsresult Normalize(void) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult Create(uint32_t type, uint32_t permissions) = 0;
+
+
+  virtual nsresult GetLeafName(nsAString & aLeafName) = 0;
+  virtual nsresult SetLeafName(const nsAString & aLeafName) = 0;
+
+
+  virtual nsresult GetNativeLeafName(nsACString & aNativeLeafName) = 0;
+  virtual nsresult SetNativeLeafName(const nsACString & aNativeLeafName) = 0;
+
+
+  virtual nsresult CopyTo(nsIFile *newParentDir, const nsAString & newName) = 0;
+
+
+  virtual nsresult CopyToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
+
+
+  virtual nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString & newName) = 0;
+
+
+  virtual nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsACString & newName) = 0;
+
+
+  virtual nsresult MoveTo(nsIFile *newParentDir, const nsAString & newName) = 0;
+
+
+  virtual nsresult MoveToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
+
+
+  virtual nsresult RenameTo(nsIFile *newParentDir, const nsAString & newName) = 0;
+
+
+  virtual nsresult RenameToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
+
+
+  virtual nsresult Remove(bool recursive) = 0;
+
+
+  virtual nsresult GetPermissions(uint32_t *aPermissions) = 0;
+  virtual nsresult SetPermissions(uint32_t aPermissions) = 0;
+
+
+  virtual nsresult GetPermissionsOfLink(uint32_t *aPermissionsOfLink) = 0;
+  virtual nsresult SetPermissionsOfLink(uint32_t aPermissionsOfLink) = 0;
+
+
+  virtual nsresult GetLastModifiedTime(PRTime *aLastModifiedTime) = 0;
+  virtual nsresult SetLastModifiedTime(PRTime aLastModifiedTime) = 0;
+
+
+  virtual nsresult GetLastModifiedTimeOfLink(PRTime *aLastModifiedTimeOfLink) = 0;
+  virtual nsresult SetLastModifiedTimeOfLink(PRTime aLastModifiedTimeOfLink) = 0;
+
+
+  virtual nsresult GetFileSize(int64_t *aFileSize) = 0;
+  virtual nsresult SetFileSize(int64_t aFileSize) = 0;
+
+
+  virtual nsresult GetFileSizeOfLink(int64_t *aFileSizeOfLink) = 0;
+
+
+  virtual nsresult GetTarget(nsAString & aTarget) = 0;
+
+
+  virtual nsresult GetNativeTarget(nsACString & aNativeTarget) = 0;
+
+
+  virtual nsresult GetPath(nsAString & aPath) = 0;
+
+
+  virtual nsresult GetNativePath(nsACString & aNativePath) = 0;
+
+
+  virtual nsresult Exists(bool *_retval) = 0;
+
+
+  virtual nsresult IsWritable(bool *_retval) = 0;
+
+
+  virtual nsresult IsReadable(bool *_retval) = 0;
+
+
+  virtual nsresult IsExecutable(bool *_retval) = 0;
+
+
+  virtual nsresult IsHidden(bool *_retval) = 0;
+
+
+  virtual nsresult IsDirectory(bool *_retval) = 0;
+
+
+  virtual nsresult IsFile(bool *_retval) = 0;
+
+
+  virtual nsresult IsSymlink(bool *_retval) = 0;
+
+
+  virtual nsresult IsSpecial(bool *_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult CreateUnique(uint32_t type, uint32_t permissions) = 0;
+
+
+  virtual nsresult Clone(nsIFile * *_retval) = 0;
+
+
+  virtual nsresult Equals(nsIFile *inFile, bool *_retval) = 0;
+
+
+  virtual nsresult Contains(nsIFile *inFile, bool *_retval) = 0;
+
+
+  virtual nsresult GetParent(nsIFile * *aParent) = 0;
+
+
+  virtual nsresult GetDirectoryEntries(nsISimpleEnumerator * *aDirectoryEntries) = 0;
+
+
+  virtual nsresult InitWithPath(const nsAString & filePath) = 0;
+
+
+  virtual nsresult InitWithNativePath(const nsACString & filePath) = 0;
+
+
+  virtual nsresult InitWithFile(nsIFile *aFile) = 0;
+
+
+  virtual nsresult GetFollowLinks(bool *aFollowLinks) = 0;
+  virtual nsresult SetFollowLinks(bool aFollowLinks) = 0;
+
+  enum {
+    OS_READAHEAD = 1073741824U,
+    DELETE_ON_CLOSE = 2147483648U
+  };
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult OpenANSIFileDesc(const char * mode, FILE **_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult Load(PRLibrary **_retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable) = 0;
+
+
+  virtual nsresult AppendRelativePath(const nsAString & relativeFilePath) = 0;
+
+
+  virtual nsresult AppendRelativeNativePath(const nsACString & relativeFilePath) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetPersistentDescriptor(nsACString & aPersistentDescriptor) = 0;
+  __attribute__ ((warn_unused_result)) virtual nsresult SetPersistentDescriptor(const nsACString & aPersistentDescriptor) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult Reveal(void) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult Launch(void) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRelativeDescriptor(nsIFile *fromFile, nsACString & _retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRelativeDescriptor(nsIFile *fromFile, const nsACString & relativeDesc) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult GetRelativePath(nsIFile *fromFile, nsACString & _retval) = 0;
+
+
+  __attribute__ ((warn_unused_result)) virtual nsresult SetRelativePath(nsIFile *fromFile, const nsACString & relativeDesc) = 0;
+
+};
+
+  template<typename T> struct nsIFile::COMTypeInfo<nsIFile, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFile::COMTypeInfo<nsIFile, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2fa6884a, 0xae65, 0x412a, { 0x9d, 0x4c, 0xce, 0x6e, 0x34, 0x54, 0x4b, 0xa1 }};
+# 920 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIProperties.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIProperties.h"
+class nsIProperties : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult Get(const char * prop, const nsIID & iid, void **result) = 0;
+
+
+  virtual nsresult Set(const char * prop, nsISupports *value) = 0;
+
+
+  virtual nsresult Has(const char * prop, bool *_retval) = 0;
+
+
+  virtual nsresult Undefine(const char * prop) = 0;
+
+
+  virtual nsresult GetKeys(uint32_t *count, char * **keys) = 0;
+
+};
+
+  template<typename T> struct nsIProperties::COMTypeInfo<nsIProperties, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIProperties::COMTypeInfo<nsIProperties, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x78650582, 0x4e93, 0x4b60, { 0x8e, 0x85, 0x26, 0xeb, 0xd3, 0xeb, 0x14, 0xca }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 2
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 2
+
+inline nsresult
+NS_GetSpecialDirectory(const char* aSpecialDirName, nsIFile** aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIProperties> serv(do_GetService("@mozilla.org/file/directory_service;1",
+                                             &rv));
+  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
+    return rv;
+  }
+
+  return serv->Get(aSpecialDirName, (nsIFile::COMTypeInfo<nsIFile, void>::kIID),
+                   reinterpret_cast<void**>(aResult));
+}
+# 921 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 2
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h" 2
+# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+namespace mozilla {
+
+struct StaticXREAppData;
+
+
+
+
+class XREAppData
+{
+public:
+  XREAppData() { }
+  ~XREAppData() { }
+  XREAppData(const XREAppData& aOther)
+  {
+    *this = aOther;
+  }
+
+  explicit XREAppData(const StaticXREAppData& aOther)
+  {
+    *this = aOther;
+  }
+
+  XREAppData& operator=(const StaticXREAppData& aOther);
+  XREAppData& operator=(const XREAppData& aOther);
+  XREAppData& operator=(XREAppData&& aOther) = default;
+
+  struct NSFreePolicy
+  {
+    void operator()(const void* ptr) {
+      free(const_cast<void*>(ptr));
+    }
+  };
+
+
+
+  class CharPtr
+  {
+  public:
+    explicit CharPtr() = default;
+    explicit CharPtr(const char* v)
+    {
+      *this = v;
+    }
+    CharPtr(CharPtr&&) = default;
+    ~CharPtr() = default;
+
+    CharPtr& operator=(const char* v)
+    {
+      if (v) {
+        mValue.reset(NS_strdup(v));
+      } else {
+        mValue = nullptr;
+      }
+      return *this;
+    }
+    CharPtr& operator=(const CharPtr& v)
+    {
+      *this = (const char*) v;
+      return *this;
+    }
+
+    operator const char*() const {
+      return mValue.get();
+    }
+
+  private:
+    UniquePtr<const char, NSFreePolicy> mValue;
+  };
+
+
+
+
+
+  nsCOMPtr<nsIFile> directory;
+
+
+
+
+
+
+  CharPtr vendor;
+
+
+
+
+
+
+  CharPtr name;
+
+
+
+
+
+
+  CharPtr remotingName;
+
+
+
+
+
+
+  CharPtr version;
+
+
+
+
+  CharPtr buildID;
+# 145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+  CharPtr ID;
+
+
+
+
+
+  CharPtr copyright;
+
+
+
+
+  uint32_t flags = 0;
+
+
+
+
+
+  nsCOMPtr<nsIFile> xreDirectory;
+
+
+
+
+  CharPtr minVersion;
+  CharPtr maxVersion;
+
+
+
+
+  CharPtr crashReporterURL;
+# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+  CharPtr profile;
+
+
+
+
+  CharPtr UAName;
+# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+};
+# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
+struct StaticXREAppData
+{
+  const char* vendor;
+  const char* name;
+  const char* remotingName;
+  const char* version;
+  const char* buildID;
+  const char* ID;
+  const char* copyright;
+  uint32_t flags;
+  const char* minVersion;
+  const char* maxVersion;
+  const char* crashReporterURL;
+  const char* profile;
+  const char* UAName;
+};
+
+}
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h" 1
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h"
+struct XREChildData
+{
+# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h"
+};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREShellData.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREShellData.h"
+struct XREShellData
+{
+
+
+
+
+
+
+};
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
+# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+namespace mozilla {
+struct BootstrapConfig;
+}
+int XRE_main (int argc, char* argv[], const mozilla::BootstrapConfig& aConfig);
+# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_GetFileFromPath (const char* aPath, nsIFile** aResult);
+# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_GetBinaryPath (const char* aArgv0, nsIFile** aResult);
+
+
+
+
+
+const mozilla::Module* XRE_GetStaticModule ();
+# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_LockProfileDirectory (nsIFile* aDirectory, nsISupports** aLockObject);
+# 269 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_InitEmbedding2 (nsIFile* aLibXULDirectory, nsIFile* aAppDirectory, nsIDirectoryServiceProvider* aAppDirProvider);
+# 279 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_AddStaticComponent (const mozilla::Module* aComponent);
+# 300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+enum NSLocationType
+{
+  NS_APP_LOCATION,
+  NS_EXTENSION_LOCATION,
+  NS_SKIN_LOCATION,
+  NS_BOOTSTRAPPED_LOCATION
+};
+
+nsresult XRE_AddManifestLocation (NSLocationType aType, nsIFile* aLocation);
+# 329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_AddJarManifestLocation (NSLocationType aType, nsIFile* aLocation);
+# 359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+void XRE_NotifyProfile ();
+
+
+
+
+
+void XRE_TermEmbedding ();
+# 375 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
+nsresult XRE_ParseAppData (nsIFile* aINIFile, mozilla::XREAppData& aAppData);
+
+
+
+enum GeckoProcessType
+{
+  GeckoProcessType_Default = 0,
+
+  GeckoProcessType_Plugin,
+  GeckoProcessType_Content,
+
+  GeckoProcessType_IPDLUnitTest,
+
+  GeckoProcessType_GMPlugin,
+
+  GeckoProcessType_GPU,
+
+  GeckoProcessType_End,
+  GeckoProcessType_Invalid = GeckoProcessType_End
+};
+
+static const char* const kGeckoProcessTypeString[] = {
+  "default",
+  "plugin",
+  "tab",
+  "ipdlunittest",
+  "geckomediaplugin",
+  "gpu"
+};
+
+static_assert(sizeof(mozilla::detail::ArrayLengthHelper(kGeckoProcessTypeString)) ==
+              GeckoProcessType_End,
+              "Array length mismatch");
+
+const char* XRE_ChildProcessTypeToString (GeckoProcessType aProcessType);
+
+
+
+
+
+
+
+void XRE_SetProcessType (const char* aProcessTypeString);
+
+
+
+
+bool XRE_TakeMinidumpForChild (uint32_t aChildPid, nsIFile** aDump, uint32_t* aSequence);
+
+
+
+
+bool XRE_SetRemoteExceptionHandler (const char* aPipe);
+
+
+
+namespace mozilla {
+namespace gmp {
+class GMPLoader;
+}
+}
+
+nsresult XRE_InitChildProcess (int aArgc, char* aArgv[], const XREChildData* aChildData);
+
+
+
+
+GeckoProcessType XRE_GetProcessType ();
+
+
+bool XRE_IsParentProcess ();
+
+
+bool XRE_IsContentProcess ();
+
+
+bool XRE_IsGPUProcess ();
+
+
+typedef void (*MainFunction)(void* aData);
+
+nsresult XRE_InitParentProcess (int aArgc, char* aArgv[], MainFunction aMainFunction, void* aMainFunctionExtraData);
+
+
+
+
+
+int XRE_RunIPDLTest (int aArgc, char* aArgv[]);
+
+
+
+nsresult XRE_RunAppShell ();
+
+
+nsresult XRE_InitCommandLine (int aArgc, char* aArgv[]);
+
+
+nsresult XRE_DeinitCommandLine ();
+
+
+class MessageLoop;
+
+void XRE_ShutdownChildProcess ();
+
+
+MessageLoop* XRE_GetIOMessageLoop ();
+
+
+bool XRE_SendTestShellCommand (JSContext* aCx, JSString* aCommand, void* aCallback);
+
+
+
+bool XRE_ShutdownTestShell ();
+
+
+void XRE_InstallX11ErrorHandler ();
+
+
+void XRE_TelemetryAccumulate (int aID, uint32_t aSample);
+
+
+void XRE_StartupTimelineRecord (int aEvent, mozilla::TimeStamp aWhen);
+
+
+void XRE_InitOmnijar (nsIFile* aGreOmni, nsIFile* aAppOmni);
+
+
+void XRE_StopLateWriteChecks (void);
+
+
+void XRE_EnableSameExecutableForContentProc ();
+
+
+int XRE_XPCShellMain (int argc, char** argv, char** envp, const XREShellData* aShellData);
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 2
+# 188 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+static_assert(((7<<9) &
+               (1<<12)) == 0,
+              "didn't leave enough room for the parse property constants");
+# 289 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+enum nsStyleAnimType {
+
+
+  eStyleAnimType_Custom,
+
+
+  eStyleAnimType_Coord,
+
+
+
+  eStyleAnimType_Sides_Top,
+  eStyleAnimType_Sides_Right,
+  eStyleAnimType_Sides_Bottom,
+  eStyleAnimType_Sides_Left,
+
+
+
+  eStyleAnimType_Corner_TopLeft,
+  eStyleAnimType_Corner_TopRight,
+  eStyleAnimType_Corner_BottomRight,
+  eStyleAnimType_Corner_BottomLeft,
+
+
+  eStyleAnimType_nscoord,
+
+
+  eStyleAnimType_float,
+
+
+  eStyleAnimType_Color,
+
+
+  eStyleAnimType_ComplexColor,
+
+
+  eStyleAnimType_PaintServer,
+
+
+  eStyleAnimType_Shadow,
+
+
+  eStyleAnimType_Discrete,
+
+
+  eStyleAnimType_None
+};
+
+class nsCSSProps {
+public:
+  typedef mozilla::CSSEnabledState EnabledState;
+
+  struct KTableEntry
+  {
+
+
+
+    constexpr KTableEntry(nsCSSKeyword aKeyword, int16_t aValue)
+      : mKeyword(aKeyword)
+      , mValue(aValue)
+    {
+    }
+
+    template<typename T,
+             typename = typename std::enable_if<std::is_enum<T>::value>::type>
+    constexpr KTableEntry(nsCSSKeyword aKeyword, T aValue)
+      : mKeyword(aKeyword)
+      , mValue(static_cast<int16_t>(aValue))
+    {
+      static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+                    "aValue must be an enum that fits within mValue");
+    }
+
+    nsCSSKeyword mKeyword;
+    int16_t mValue;
+  };
+
+  static void AddRefTable(void);
+  static void ReleaseTable(void);
+
+
+
+
+  static nsCSSPropertyID LookupProperty(const nsAString& aProperty,
+                                      EnabledState aEnabled);
+  static nsCSSPropertyID LookupProperty(const nsACString& aProperty,
+                                      EnabledState aEnabled);
+
+
+  static nsCSSPropertyID LookupPropertyByIDLName(
+      const nsAString& aPropertyIDLName,
+      EnabledState aEnabled);
+  static nsCSSPropertyID LookupPropertyByIDLName(
+      const nsACString& aPropertyIDLName,
+      EnabledState aEnabled);
+
+
+
+  static bool IsCustomPropertyName(const nsAString& aProperty);
+  static bool IsCustomPropertyName(const nsACString& aProperty);
+
+  static inline bool IsShorthand(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+    return (aProperty >= eCSSProperty_COUNT_no_shorthands);
+  }
+
+
+  static bool IsInherited(nsCSSPropertyID aProperty);
+
+
+  static nsCSSFontDesc LookupFontDesc(const nsAString& aProperty);
+  static nsCSSFontDesc LookupFontDesc(const nsACString& aProperty);
+
+
+  static nsCSSCounterDesc LookupCounterDesc(const nsAString& aProperty);
+  static nsCSSCounterDesc LookupCounterDesc(const nsACString& aProperty);
+
+
+  static bool IsPredefinedCounterStyle(const nsAString& aStyle);
+  static bool IsPredefinedCounterStyle(const nsACString& aStyle);
+
+
+  static const nsAFlatCString& GetStringValue(nsCSSPropertyID aProperty);
+  static const nsAFlatCString& GetStringValue(nsCSSFontDesc aFontDesc);
+  static const nsAFlatCString& GetStringValue(nsCSSCounterDesc aCounterDesc);
+
+
+
+
+  static const nsAFlatCString& LookupPropertyValue(nsCSSPropertyID aProperty, int32_t aValue);
+
+
+
+  static bool GetColorName(int32_t aPropID, nsCString &aStr);
+
+
+
+
+  static int32_t FindIndexOfKeyword(nsCSSKeyword aKeyword,
+                                    const KTableEntry aTable[]);
+
+
+
+  static bool FindKeyword(nsCSSKeyword aKeyword, const KTableEntry aTable[],
+                          int32_t& aValue);
+
+
+  static nsCSSKeyword ValueToKeywordEnum(int32_t aValue,
+                                         const KTableEntry aTable[]);
+  template<typename T,
+           typename = typename std::enable_if<std::is_enum<T>::value>::type>
+  static nsCSSKeyword ValueToKeywordEnum(T aValue,
+                                         const KTableEntry aTable[])
+  {
+    static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+                  "aValue must be an enum that fits within KTableEntry::mValue");
+    return ValueToKeywordEnum(static_cast<int16_t>(aValue), aTable);
+  }
+
+  static const nsAFlatCString& ValueToKeyword(int32_t aValue,
+                                              const KTableEntry aTable[]);
+  template<typename T,
+           typename = typename std::enable_if<std::is_enum<T>::value>::type>
+  static const nsAFlatCString& ValueToKeyword(T aValue,
+                                              const KTableEntry aTable[])
+  {
+    static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+                  "aValue must be an enum that fits within KTableEntry::mValue");
+    return ValueToKeyword(static_cast<int16_t>(aValue), aTable);
+  }
+
+  static const nsStyleStructID kSIDTable[eCSSProperty_COUNT_no_shorthands];
+  static const KTableEntry* const kKeywordTableTable[eCSSProperty_COUNT_no_shorthands];
+  static const nsStyleAnimType kAnimTypeTable[eCSSProperty_COUNT_no_shorthands];
+  static const ptrdiff_t
+    kStyleStructOffsetTable[eCSSProperty_COUNT_no_shorthands];
+
+private:
+  static const uint32_t kFlagsTable[eCSSProperty_COUNT];
+
+public:
+  static inline bool PropHasFlags(nsCSSPropertyID aProperty, uint32_t aFlags)
+  {
+    do { } while (0);
+
+    do { } while (0);
+
+
+
+    return (nsCSSProps::kFlagsTable[aProperty] & aFlags) == aFlags;
+  }
+
+  static inline uint32_t PropertyParseType(nsCSSPropertyID aProperty)
+  {
+    do { } while (0);
+
+    return nsCSSProps::kFlagsTable[aProperty] &
+           (7<<9);
+  }
+
+  static inline uint32_t ValueRestrictions(nsCSSPropertyID aProperty)
+  {
+    do { } while (0);
+
+    return nsCSSProps::kFlagsTable[aProperty] &
+           (3<<13);
+  }
+
+private:
+
+  static const uint32_t kParserVariantTable[eCSSProperty_COUNT_no_shorthands];
+
+public:
+  static inline uint32_t ParserVariant(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+    return nsCSSProps::kParserVariantTable[aProperty];
+  }
+
+private:
+
+
+  static const nsCSSPropertyID *const
+    kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands];
+
+public:
+  static inline
+  const nsCSSPropertyID * SubpropertyEntryFor(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+
+    return nsCSSProps::kSubpropertyTable[aProperty -
+                                         eCSSProperty_COUNT_no_shorthands];
+  }
+
+
+
+
+  static const nsCSSPropertyID * ShorthandsContaining(nsCSSPropertyID aProperty) {
+    do { } while (0);
+    do { } while (0);
+
+    return gShorthandsContainingTable[aProperty];
+  }
+private:
+
+
+
+
+
+  static nsCSSPropertyID *gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
+  static nsCSSPropertyID* gShorthandsContainingPool;
+  static bool BuildShorthandsContainingTable();
+
+private:
+  static const size_t gPropertyCountInStruct[nsStyleStructID_Length];
+  static const size_t gPropertyIndexInStruct[eCSSProperty_COUNT_no_shorthands];
+public:
+
+
+
+
+  static size_t PropertyCountInStruct(nsStyleStructID aSID) {
+    do { } while (0);
+
+    return gPropertyCountInStruct[aSID];
+  }
+
+
+
+
+  static size_t PropertyIndexInStruct(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+    return gPropertyIndexInStruct[aProperty];
+  }
+
+private:
+
+
+  static const nsCSSPropertyID* const
+    kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT];
+
+public:
+# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+  static const nsCSSPropertyID* LogicalGroup(nsCSSPropertyID aProperty);
+
+private:
+  static bool gPropertyEnabled[eCSSProperty_COUNT_with_aliases];
+
+private:
+
+  static const char* const kIDLNameTable[eCSSProperty_COUNT];
+
+public:
+# 611 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+  static const char* PropertyIDLName(nsCSSPropertyID aProperty)
+  {
+    do { } while (0);
+
+    return kIDLNameTable[aProperty];
+  }
+
+private:
+  static const int32_t kIDLNameSortPositionTable[eCSSProperty_COUNT];
+
+public:
+
+
+
+
+  static int32_t PropertyIDLNameSortPosition(nsCSSPropertyID aProperty)
+  {
+    do { } while (0);
+
+    return kIDLNameSortPositionTable[aProperty];
+  }
+
+  static bool IsEnabled(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+
+
+
+    do { } while (0);
+
+
+    return gPropertyEnabled[aProperty];
+  }
+
+
+
+
+  static const mozilla::UseCounter gPropertyUseCounter[eCSSProperty_COUNT_no_shorthands];
+
+public:
+
+  static mozilla::UseCounter UseCounterFor(nsCSSPropertyID aProperty) {
+    do { } while (0);
+
+    return gPropertyUseCounter[aProperty];
+  }
+
+  static bool IsEnabled(nsCSSPropertyID aProperty, EnabledState aEnabled)
+  {
+    if (IsEnabled(aProperty)) {
+      return true;
+    }
+    if (aEnabled == EnabledState::eIgnoreEnabledState) {
+      return true;
+    }
+    if ((aEnabled & EnabledState::eInUASheets) &&
+        PropHasFlags(aProperty, (1<<22)))
+    {
+      return true;
+    }
+    if ((aEnabled & EnabledState::eInChrome) &&
+        PropHasFlags(aProperty, (1<<23)))
+    {
+      return true;
+    }
+    return false;
+  }
+
+public:
+# 693 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
+  static const KTableEntry kAnimationDirectionKTable[];
+  static const KTableEntry kAnimationFillModeKTable[];
+  static const KTableEntry kAnimationIterationCountKTable[];
+  static const KTableEntry kAnimationPlayStateKTable[];
+  static const KTableEntry kAnimationTimingFunctionKTable[];
+  static const KTableEntry kAppearanceKTable[];
+  static const KTableEntry kMozAppearanceKTable[];
+  static const KTableEntry kAzimuthKTable[];
+  static const KTableEntry kBackfaceVisibilityKTable[];
+  static const KTableEntry kTransformStyleKTable[];
+  static const KTableEntry kImageLayerAttachmentKTable[];
+  static const KTableEntry kBackgroundOriginKTable[];
+  static const KTableEntry kMaskOriginKTable[];
+  static const KTableEntry kImageLayerPositionKTable[];
+  static const KTableEntry kImageLayerRepeatKTable[];
+  static const KTableEntry kImageLayerRepeatPartKTable[];
+  static const KTableEntry kImageLayerSizeKTable[];
+  static const KTableEntry kImageLayerCompositeKTable[];
+  static const KTableEntry kImageLayerModeKTable[];
+
+
+  static KTableEntry kBackgroundClipKTable[];
+  static const KTableEntry kMaskClipKTable[];
+  static const KTableEntry kBlendModeKTable[];
+  static const KTableEntry kBorderCollapseKTable[];
+  static const KTableEntry kBorderImageRepeatKTable[];
+  static const KTableEntry kBorderImageSliceKTable[];
+  static const KTableEntry kBorderStyleKTable[];
+  static const KTableEntry kBorderWidthKTable[];
+  static const KTableEntry kBoxAlignKTable[];
+  static const KTableEntry kBoxDecorationBreakKTable[];
+  static const KTableEntry kBoxDirectionKTable[];
+  static const KTableEntry kBoxOrientKTable[];
+  static const KTableEntry kBoxPackKTable[];
+  static const KTableEntry kClipPathGeometryBoxKTable[];
+  static const KTableEntry kCounterRangeKTable[];
+  static const KTableEntry kCounterSpeakAsKTable[];
+  static const KTableEntry kCounterSymbolsSystemKTable[];
+  static const KTableEntry kCounterSystemKTable[];
+  static const KTableEntry kDominantBaselineKTable[];
+  static const KTableEntry kShapeRadiusKTable[];
+  static const KTableEntry kFillRuleKTable[];
+  static const KTableEntry kFilterFunctionKTable[];
+  static const KTableEntry kImageRenderingKTable[];
+  static const KTableEntry kShapeOutsideShapeBoxKTable[];
+  static const KTableEntry kShapeRenderingKTable[];
+  static const KTableEntry kStrokeLinecapKTable[];
+  static const KTableEntry kStrokeLinejoinKTable[];
+  static const KTableEntry kStrokeContextValueKTable[];
+  static const KTableEntry kVectorEffectKTable[];
+  static const KTableEntry kTextAnchorKTable[];
+  static const KTableEntry kTextRenderingKTable[];
+  static const KTableEntry kColorAdjustKTable[];
+  static const KTableEntry kColorInterpolationKTable[];
+  static const KTableEntry kColumnFillKTable[];
+  static const KTableEntry kColumnSpanKTable[];
+  static const KTableEntry kBoxPropSourceKTable[];
+  static const KTableEntry kBoxShadowTypeKTable[];
+  static const KTableEntry kBoxSizingKTable[];
+  static const KTableEntry kCaptionSideKTable[];
+
+
+  static KTableEntry kClearKTable[];
+  static const KTableEntry kColorKTable[];
+  static const KTableEntry kContentKTable[];
+  static const KTableEntry kControlCharacterVisibilityKTable[];
+  static const KTableEntry kCursorKTable[];
+  static const KTableEntry kDirectionKTable[];
+
+
+  static KTableEntry kDisplayKTable[];
+  static const KTableEntry kElevationKTable[];
+  static const KTableEntry kEmptyCellsKTable[];
+
+  static const KTableEntry kAlignAllKeywords[];
+  static const KTableEntry kAlignOverflowPosition[];
+  static const KTableEntry kAlignSelfPosition[];
+  static const KTableEntry kAlignLegacy[];
+  static const KTableEntry kAlignLegacyPosition[];
+  static const KTableEntry kAlignAutoNormalStretchBaseline[];
+  static const KTableEntry kAlignNormalStretchBaseline[];
+  static const KTableEntry kAlignNormalBaseline[];
+  static const KTableEntry kAlignContentDistribution[];
+  static const KTableEntry kAlignContentPosition[];
+
+  static const KTableEntry kAutoCompletionAlignJustifySelf[];
+  static const KTableEntry kAutoCompletionAlignItems[];
+  static const KTableEntry kAutoCompletionAlignJustifyContent[];
+
+  static const KTableEntry kFlexDirectionKTable[];
+  static const KTableEntry kFlexWrapKTable[];
+
+
+  static KTableEntry kFloatKTable[];
+  static const KTableEntry kFloatEdgeKTable[];
+  static const KTableEntry kFontDisplayKTable[];
+  static const KTableEntry kFontKTable[];
+  static const KTableEntry kFontKerningKTable[];
+  static const KTableEntry kFontSizeKTable[];
+  static const KTableEntry kFontSmoothingKTable[];
+  static const KTableEntry kFontStretchKTable[];
+  static const KTableEntry kFontStyleKTable[];
+  static const KTableEntry kFontSynthesisKTable[];
+  static const KTableEntry kFontVariantKTable[];
+  static const KTableEntry kFontVariantAlternatesKTable[];
+  static const KTableEntry kFontVariantAlternatesFuncsKTable[];
+  static const KTableEntry kFontVariantCapsKTable[];
+  static const KTableEntry kFontVariantEastAsianKTable[];
+  static const KTableEntry kFontVariantLigaturesKTable[];
+  static const KTableEntry kFontVariantNumericKTable[];
+  static const KTableEntry kFontVariantPositionKTable[];
+  static const KTableEntry kFontWeightKTable[];
+  static const KTableEntry kGridAutoFlowKTable[];
+  static const KTableEntry kGridTrackBreadthKTable[];
+  static const KTableEntry kHyphensKTable[];
+  static const KTableEntry kImageOrientationKTable[];
+  static const KTableEntry kImageOrientationFlipKTable[];
+  static const KTableEntry kIsolationKTable[];
+  static const KTableEntry kIMEModeKTable[];
+  static const KTableEntry kLineHeightKTable[];
+  static const KTableEntry kListStylePositionKTable[];
+  static const KTableEntry kListStyleKTable[];
+  static const KTableEntry kMaskTypeKTable[];
+  static const KTableEntry kMathVariantKTable[];
+  static const KTableEntry kMathDisplayKTable[];
+  static const KTableEntry kContainKTable[];
+  static const KTableEntry kContextOpacityKTable[];
+  static const KTableEntry kContextPatternKTable[];
+  static const KTableEntry kObjectFitKTable[];
+  static const KTableEntry kOrientKTable[];
+  static const KTableEntry kOutlineStyleKTable[];
+  static const KTableEntry kOverflowKTable[];
+  static const KTableEntry kOverflowSubKTable[];
+  static const KTableEntry kOverflowClipBoxKTable[];
+  static const KTableEntry kOverflowWrapKTable[];
+  static const KTableEntry kPageBreakKTable[];
+  static const KTableEntry kPageBreakInsideKTable[];
+  static const KTableEntry kPageMarksKTable[];
+  static const KTableEntry kPageSizeKTable[];
+  static const KTableEntry kPitchKTable[];
+  static const KTableEntry kPointerEventsKTable[];
+  static const KTableEntry kPositionKTable[];
+  static const KTableEntry kRadialGradientShapeKTable[];
+  static const KTableEntry kRadialGradientSizeKTable[];
+  static const KTableEntry kRadialGradientLegacySizeKTable[];
+  static const KTableEntry kResizeKTable[];
+  static const KTableEntry kRubyAlignKTable[];
+  static const KTableEntry kRubyPositionKTable[];
+  static const KTableEntry kScrollBehaviorKTable[];
+  static const KTableEntry kScrollSnapTypeKTable[];
+  static const KTableEntry kSpeakKTable[];
+  static const KTableEntry kSpeakHeaderKTable[];
+  static const KTableEntry kSpeakNumeralKTable[];
+  static const KTableEntry kSpeakPunctuationKTable[];
+  static const KTableEntry kSpeechRateKTable[];
+  static const KTableEntry kStackSizingKTable[];
+  static const KTableEntry kTableLayoutKTable[];
+
+
+  static KTableEntry kTextAlignKTable[];
+  static KTableEntry kTextAlignLastKTable[];
+  static const KTableEntry kTextCombineUprightKTable[];
+  static const KTableEntry kTextDecorationLineKTable[];
+  static const KTableEntry kTextDecorationStyleKTable[];
+  static const KTableEntry kTextEmphasisPositionKTable[];
+  static const KTableEntry kTextEmphasisStyleFillKTable[];
+  static const KTableEntry kTextEmphasisStyleShapeKTable[];
+  static const KTableEntry kTextJustifyKTable[];
+  static const KTableEntry kTextOrientationKTable[];
+  static const KTableEntry kTextOverflowKTable[];
+  static const KTableEntry kTextSizeAdjustKTable[];
+  static const KTableEntry kTextTransformKTable[];
+  static const KTableEntry kTouchActionKTable[];
+  static const KTableEntry kTopLayerKTable[];
+  static const KTableEntry kTransformBoxKTable[];
+  static const KTableEntry kTransitionTimingFunctionKTable[];
+  static const KTableEntry kUnicodeBidiKTable[];
+  static const KTableEntry kUserFocusKTable[];
+  static const KTableEntry kUserInputKTable[];
+  static const KTableEntry kUserModifyKTable[];
+  static const KTableEntry kUserSelectKTable[];
+  static const KTableEntry kVerticalAlignKTable[];
+  static const KTableEntry kVisibilityKTable[];
+  static const KTableEntry kVolumeKTable[];
+  static const KTableEntry kWhitespaceKTable[];
+  static const KTableEntry kWidthKTable[];
+  static const KTableEntry kWindowDraggingKTable[];
+  static const KTableEntry kWindowShadowKTable[];
+  static const KTableEntry kWordBreakKTable[];
+  static const KTableEntry kWritingModeKTable[];
+};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h" 1
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h"
+class nsIEventTarget;
+class nsIRunnable;
+
+namespace mozilla {
+class AbstractThread;
+namespace dom {
+class TabGroup;
+}
+# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h"
+class Dispatcher
+{
+public:
+  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
+
+
+  virtual nsresult Dispatch(const char* aName,
+                            TaskCategory aCategory,
+                            already_AddRefed<nsIRunnable>&& aRunnable) = 0;
+
+
+
+  virtual nsIEventTarget* EventTargetFor(TaskCategory aCategory) const = 0;
+
+
+
+  AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
+
+
+
+  virtual dom::TabGroup* AsTabGroup() { return nullptr; }
+
+  static nsresult UnlabeledDispatch(const char* aName,
+                                    TaskCategory aCategory,
+                                    already_AddRefed<nsIRunnable>&& aRunnable);
+
+protected:
+
+
+  virtual AbstractThread* AbstractMainThreadForImpl(TaskCategory aCategory) = 0;
+};
+
+class ValidatingDispatcher : public Dispatcher
+{
+public:
+  ValidatingDispatcher();
+
+  class AutoProcessEvent final {
+  public:
+    AutoProcessEvent();
+    ~AutoProcessEvent();
+
+  private:
+    ValidatingDispatcher* mPrevRunningDispatcher;
+  };
+
+
+  bool AccessAllowed() const
+  {
+    return !sRunningDispatcher || mAccessValid;
+  }
+
+
+  void ValidateAccess() const
+  {
+    do { } while (0);
+  }
+
+  class Runnable;
+  friend class Runnable;
+
+  bool* GetValidAccessPtr() { return &mAccessValid; }
+
+  nsresult Dispatch(const char* aName,
+                    TaskCategory aCategory,
+                    already_AddRefed<nsIRunnable>&& aRunnable) override;
+
+  nsIEventTarget* EventTargetFor(TaskCategory aCategory) const override;
+
+protected:
+
+
+  AbstractThread* AbstractMainThreadForImpl(TaskCategory aCategory) override;
+
+
+  virtual already_AddRefed<nsIEventTarget>
+  CreateEventTargetFor(TaskCategory aCategory);
+
+
+
+  static ValidatingDispatcher* FromEventTarget(nsIEventTarget* aEventTarget);
+
+  nsresult LabeledDispatch(const char* aName,
+                           TaskCategory aCategory,
+                           already_AddRefed<nsIRunnable>&& aRunnable);
+
+  void CreateEventTargets(bool aNeedValidation);
+
+
+
+  void Shutdown(bool aXPCOMShutdown);
+
+  enum ValidationType {
+    StartValidation,
+    EndValidation,
+  };
+  void SetValidatingAccess(ValidationType aType);
+
+  static ValidatingDispatcher* sRunningDispatcher;
+  bool mAccessValid;
+
+  nsCOMPtr<nsIEventTarget> mEventTargets[size_t(TaskCategory::Count)];
+  RefPtr<AbstractThread> mAbstractThreads[size_t(TaskCategory::Count)];
+};
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h" 2
+
+
+
+
+
+
+namespace mozilla {
+
+class SystemGroup
+{
+ public:
+
+  static nsresult Dispatch(const char* aName,
+                           TaskCategory aCategory,
+                           already_AddRefed<nsIRunnable>&& aRunnable);
+
+
+  static nsIEventTarget* EventTargetFor(TaskCategory aCategory);
+
+
+
+  static AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
+
+  static void InitStatic();
+  static void Shutdown();
+};
+
+}
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h" 2
+
+
+
+
+
+
+
+namespace detail {
+
+template<typename T>
+class ProxyReleaseEvent : public mozilla::Runnable
+{
+public:
+  explicit ProxyReleaseEvent(already_AddRefed<T> aDoomed)
+  : Runnable("ProxyReleaseEvent"), mDoomed(aDoomed.take()) {}
+
+  virtual nsresult Run() override
+  {
+    do { if (mDoomed) { (mDoomed)->Release(); (mDoomed) = 0; } } while (0);
+    return NS_OK;
+  }
+
+private:
+  T* mDoomed;
+};
+
+template<typename T>
+void
+ProxyRelease(nsIEventTarget* aTarget, already_AddRefed<T> aDoomed, bool aAlwaysProxy)
+{
+
+  RefPtr<T> doomed = aDoomed;
+  nsresult rv;
+
+  if (!doomed || !aTarget) {
+    return;
+  }
+
+  if (!aAlwaysProxy) {
+    bool onCurrentThread = false;
+    rv = aTarget->IsOnCurrentThread(&onCurrentThread);
+    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))) && onCurrentThread) {
+      return;
+    }
+  }
+
+  nsCOMPtr<nsIRunnable> ev = new ProxyReleaseEvent<T>(doomed.forget());
+
+  rv = aTarget->Dispatch(ev, nsIEventTarget::DISPATCH_NORMAL);
+  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
+    do { } while(0);
+
+
+  }
+}
+
+template<bool nsISupportsBased>
+struct ProxyReleaseChooser
+{
+  template<typename T>
+  static void ProxyRelease(nsIEventTarget* aTarget,
+                           already_AddRefed<T> aDoomed,
+                           bool aAlwaysProxy)
+  {
+    ::detail::ProxyRelease(aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
+  }
+};
+
+template<>
+struct ProxyReleaseChooser<true>
+{
+
+
+  template<typename T>
+  static void ProxyRelease(nsIEventTarget* aTarget,
+                           already_AddRefed<T> aDoomed,
+                           bool aAlwaysProxy)
+  {
+    ProxyReleaseISupports(aTarget, ToSupports(aDoomed.take()), aAlwaysProxy);
+  }
+
+  static void ProxyReleaseISupports(nsIEventTarget* aTarget,
+                                    nsISupports* aDoomed,
+                                    bool aAlwaysProxy);
+};
+
+}
+# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
+template<class T>
+inline __attribute__ ((visibility ("hidden"))) void
+NS_ProxyRelease(nsIEventTarget* aTarget, already_AddRefed<T> aDoomed,
+                bool aAlwaysProxy = false)
+{
+  ::detail::ProxyReleaseChooser<mozilla::IsBaseOf<nsISupports, T>::value>
+    ::ProxyRelease(aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
+}
+# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
+template<class T>
+inline __attribute__ ((visibility ("hidden"))) void
+NS_ReleaseOnMainThread(already_AddRefed<T> aDoomed,
+                       bool aAlwaysProxy = false)
+{
+
+
+
+  nsCOMPtr<nsIThread> mainThread;
+  if (!NS_IsMainThread() || aAlwaysProxy) {
+    nsresult rv = NS_GetMainThread(getter_AddRefs(mainThread));
+
+    if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
+      do { } while (0);
+      mozilla::Unused << aDoomed.take();
+      return;
+    }
+  }
+
+  NS_ProxyRelease(mainThread, mozilla::Move(aDoomed), aAlwaysProxy);
+}
+
+
+
+
+
+template<class T>
+inline __attribute__ ((visibility ("hidden"))) void
+NS_ReleaseOnMainThreadSystemGroup(already_AddRefed<T> aDoomed,
+                                  bool aAlwaysProxy = false)
+{
+
+
+
+  nsCOMPtr<nsIEventTarget> systemGroupEventTarget;
+  if (!NS_IsMainThread() || aAlwaysProxy) {
+    systemGroupEventTarget = mozilla::SystemGroup::EventTargetFor(mozilla::TaskCategory::Other);
+
+    if (!systemGroupEventTarget) {
+      do { } while (0);
+      mozilla::Unused << aDoomed.take();
+      return;
+    }
+  }
+
+  NS_ProxyRelease(systemGroupEventTarget, mozilla::Move(aDoomed), aAlwaysProxy);
+}
+# 226 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
+template<class T>
+class nsMainThreadPtrHolder final
+{
+public:
+
+
+
+
+
+  explicit nsMainThreadPtrHolder(T* aPtr, bool aStrict = true)
+    : mRawPtr(nullptr)
+    , mStrict(aStrict)
+  {
+
+
+    do { } while (0);
+    ns_if_addref(mRawPtr = aPtr);
+  }
+  explicit nsMainThreadPtrHolder(already_AddRefed<T> aPtr, bool aString = true)
+    : mRawPtr(aPtr.take())
+    , mStrict(aString)
+  {
+
+
+  }
+
+private:
+
+  ~nsMainThreadPtrHolder()
+  {
+    if (NS_IsMainThread()) {
+      do { if (mRawPtr) { (mRawPtr)->Release(); (mRawPtr) = 0; } } while (0);
+    } else if (mRawPtr) {
+      NS_ReleaseOnMainThread(dont_AddRef(mRawPtr));
+    }
+  }
+
+public:
+  T* get()
+  {
+
+    if (mStrict && (__builtin_expect(!!(!NS_IsMainThread()), 0))) {
+      do { } while(0);
+      do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 269; ::abort(); } while (0); } while (0);
+    }
+    return mRawPtr;
+  }
+
+  bool operator==(const nsMainThreadPtrHolder<T>& aOther) const
+  {
+    return mRawPtr == aOther.mRawPtr;
+  }
+  bool operator!() const
+  {
+    return !mRawPtr;
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsMainThreadPtrHolder<T> >::value, "Reference-counted class " "nsMainThreadPtrHolder<T>" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+private:
+
+  T* mRawPtr;
+
+
+  bool mStrict;
+
+
+
+  T& operator=(nsMainThreadPtrHolder& aOther);
+  nsMainThreadPtrHolder(const nsMainThreadPtrHolder& aOther);
+};
+
+template<class T>
+class nsMainThreadPtrHandle
+{
+  RefPtr<nsMainThreadPtrHolder<T>> mPtr;
+
+public:
+  nsMainThreadPtrHandle() : mPtr(nullptr) {}
+               nsMainThreadPtrHandle(decltype(nullptr)) : mPtr(nullptr) {}
+  explicit nsMainThreadPtrHandle(nsMainThreadPtrHolder<T>* aHolder)
+    : mPtr(aHolder)
+  {
+  }
+  explicit nsMainThreadPtrHandle(
+      already_AddRefed<nsMainThreadPtrHolder<T>> aHolder)
+    : mPtr(aHolder)
+  {
+  }
+  nsMainThreadPtrHandle(const nsMainThreadPtrHandle& aOther)
+    : mPtr(aOther.mPtr)
+  {
+  }
+  nsMainThreadPtrHandle& operator=(const nsMainThreadPtrHandle& aOther)
+  {
+    mPtr = aOther.mPtr;
+    return *this;
+  }
+  nsMainThreadPtrHandle& operator=(nsMainThreadPtrHolder<T>* aHolder)
+  {
+    mPtr = aHolder;
+    return *this;
+  }
+
+
+
+
+  T* get()
+  {
+    if (mPtr) {
+      return mPtr.get()->get();
+    }
+    return nullptr;
+  }
+  const T* get() const
+  {
+    if (mPtr) {
+      return mPtr.get()->get();
+    }
+    return nullptr;
+  }
+
+  operator T*() { return get(); }
+  T* operator->() { return get(); }
+
+
+  bool operator==(const nsMainThreadPtrHandle<T>& aOther) const
+  {
+    if (!mPtr || !aOther.mPtr) {
+      return mPtr == aOther.mPtr;
+    }
+    return *mPtr == *aOther.mPtr;
+  }
+  bool operator!=(const nsMainThreadPtrHandle<T>& aOther) const
+  {
+    return !operator==(aOther);
+  }
+  bool operator==(decltype(nullptr)) const { return mPtr == nullptr; }
+  bool operator!=(decltype(nullptr)) const { return mPtr != nullptr; }
+  bool operator!() const {
+    return !mPtr || !*mPtr;
+  }
+};
+
+namespace mozilla {
+
+template<typename T>
+using PtrHolder = nsMainThreadPtrHolder<T>;
+
+template<typename T>
+using PtrHandle = nsMainThreadPtrHandle<T>;
+
+}
+# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
+# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+class imgRequestProxy;
+class nsIAtom;
+class nsIContent;
+class nsIDocument;
+class nsIPrincipal;
+class nsIURI;
+class nsPresContext;
+template <class T>
+class nsPtrHashKey;
+
+namespace mozilla {
+class CSSStyleSheet;
+}
+# 93 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+namespace mozilla {
+namespace css {
+
+struct URLExtraData
+{
+  URLExtraData(already_AddRefed<nsIURI> aBaseURI,
+               already_AddRefed<nsIURI> aReferrer,
+               already_AddRefed<nsIPrincipal> aPrincipal)
+    : mBaseURI(Move(aBaseURI))
+    , mReferrer(Move(aReferrer))
+    , mPrincipal(Move(aPrincipal))
+  {
+    do { } while (0);
+  }
+
+  URLExtraData(nsIURI* aBaseURI, nsIURI* aReferrer, nsIPrincipal* aPrincipal)
+    : URLExtraData(do_AddRef(aBaseURI),
+                   do_AddRef(aReferrer),
+                   do_AddRef(aPrincipal)) {}
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLExtraData>::value, "Reference-counted class " "URLExtraData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+  nsIURI* BaseURI() const { return mBaseURI; }
+  nsIURI* GetReferrer() const { return mReferrer; }
+  nsIPrincipal* GetPrincipal() const { return mPrincipal; }
+
+private:
+  ~URLExtraData();
+
+  RefPtr<nsIURI> mBaseURI;
+  RefPtr<nsIURI> mReferrer;
+  RefPtr<nsIPrincipal> mPrincipal;
+};
+
+struct URLValueData
+{
+protected:
+# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  URLValueData(nsStringBuffer* aString,
+               already_AddRefed<URLExtraData> aExtraData);
+
+  URLValueData(already_AddRefed<PtrHolder<nsIURI>> aURI,
+               nsStringBuffer* aString,
+               already_AddRefed<URLExtraData> aExtraData);
+
+public:
+
+
+
+
+  bool Equals(const URLValueData& aOther) const;
+# 159 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  bool DefinitelyEqualURIs(const URLValueData& aOther) const;
+
+
+
+  bool DefinitelyEqualURIsAndPrincipal(const URLValueData& aOther) const;
+
+  nsIURI* GetURI() const;
+
+  bool IsLocalRef() const { return mIsLocalRef; }
+
+  bool HasRef() const;
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLValueData>::value, "Reference-counted class " "URLValueData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+
+
+  already_AddRefed<nsIURI> ResolveLocalRef(nsIURI* aURI) const;
+  already_AddRefed<nsIURI> ResolveLocalRef(nsIContent* aContent) const;
+
+
+
+  void GetSourceString(nsString& aRef) const;
+
+  bool EqualsExceptRef(nsIURI* aURI) const;
+
+private:
+
+
+  mutable PtrHandle<nsIURI> mURI;
+public:
+  RefPtr<nsStringBuffer> mString;
+  RefPtr<URLExtraData> mExtraData;
+private:
+  mutable bool mURIResolved;
+
+  bool mIsLocalRef;
+
+protected:
+  virtual ~URLValueData() = default;
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+  URLValueData(const URLValueData& aOther) = delete;
+  URLValueData& operator=(const URLValueData& aOther) = delete;
+};
+
+struct URLValue final : public URLValueData
+{
+
+  URLValue(nsStringBuffer* aString, nsIURI* aBaseURI, nsIURI* aReferrer,
+           nsIPrincipal* aOriginPrincipal);
+  URLValue(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aBaseURI,
+           nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal);
+
+
+  URLValue(nsStringBuffer* aString,
+           already_AddRefed<URLExtraData> aExtraData)
+    : URLValueData(aString, Move(aExtraData)) {}
+
+  URLValue(const URLValue&) = delete;
+  URLValue& operator=(const URLValue&) = delete;
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+};
+
+struct ImageValue final : public URLValueData
+{
+
+
+
+
+
+
+  ImageValue(nsIURI* aURI, nsStringBuffer* aString,
+             already_AddRefed<URLExtraData> aExtraData,
+             nsIDocument* aDocument);
+
+
+
+  ImageValue(nsStringBuffer* aString,
+             already_AddRefed<URLExtraData> aExtraData);
+
+  ImageValue(const ImageValue&) = delete;
+  ImageValue& operator=(const ImageValue&) = delete;
+
+  void Initialize(nsIDocument* aDocument);
+
+
+
+protected:
+  ~ImageValue();
+
+public:
+
+
+  nsRefPtrHashtable<nsPtrHashKey<nsIDocument>, imgRequestProxy> mRequests;
+
+private:
+
+
+
+};
+
+struct GridNamedArea {
+  nsString mName;
+  uint32_t mColumnStart;
+  uint32_t mColumnEnd;
+  uint32_t mRowStart;
+  uint32_t mRowEnd;
+};
+
+struct GridTemplateAreasValue final {
+
+  nsTArray<GridNamedArea> mNamedAreas;
+
+
+
+  nsTArray<nsString> mTemplates;
+
+
+
+  uint32_t mNColumns;
+
+
+
+  uint32_t NRows() const {
+    return mTemplates.Length();
+  }
+
+  GridTemplateAreasValue()
+    : mNColumns(0)
+
+  {
+  }
+
+  bool operator==(const GridTemplateAreasValue& aOther) const
+  {
+    return mTemplates == aOther.mTemplates;
+  }
+
+  bool operator!=(const GridTemplateAreasValue& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<GridTemplateAreasValue>::value, "Reference-counted class " "GridTemplateAreasValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+
+  ~GridTemplateAreasValue()
+  {
+  }
+
+  GridTemplateAreasValue(const GridTemplateAreasValue& aOther) = delete;
+  GridTemplateAreasValue&
+  operator=(const GridTemplateAreasValue& aOther) = delete;
+};
+
+class FontFamilyListRefCnt final : public FontFamilyList {
+public:
+    FontFamilyListRefCnt()
+        : FontFamilyList()
+    {}
+
+    explicit FontFamilyListRefCnt(FontFamilyType aGenericType)
+        : FontFamilyList(aGenericType)
+    {}
+
+    FontFamilyListRefCnt(const nsAString& aFamilyName,
+                         QuotedName aQuoted)
+        : FontFamilyList(aFamilyName, aQuoted)
+    {}
+
+    FontFamilyListRefCnt(const FontFamilyListRefCnt& aOther)
+        : FontFamilyList(aOther)
+    {}
+
+    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<FontFamilyListRefCnt>::value, "Reference-counted class " "FontFamilyListRefCnt" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:;
+
+private:
+    ~FontFamilyListRefCnt() {}
+};
+
+struct RGBAColorData
+{
+
+
+
+  float mR;
+  float mG;
+  float mB;
+  float mA;
+
+  RGBAColorData() = default;
+               RGBAColorData(nscolor aColor)
+    : mR(((uint8_t) ((aColor) & 0xff)) * (1.0f / 255.0f))
+    , mG(((uint8_t) (((aColor) >> 8) & 0xff)) * (1.0f / 255.0f))
+    , mB(((uint8_t) (((aColor) >> 16) & 0xff)) * (1.0f / 255.0f))
+    , mA(((uint8_t) (((aColor) >> 24) & 0xff)) * (1.0f / 255.0f))
+  {}
+  RGBAColorData(float aR, float aG, float aB, float aA)
+    : mR(aR), mG(aG), mB(aB), mA(aA) {}
+
+  bool operator==(const RGBAColorData& aOther) const
+  {
+    return mR == aOther.mR && mG == aOther.mG &&
+           mB == aOther.mB && mA == aOther.mA;
+  }
+  bool operator!=(const RGBAColorData& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  nscolor ToColor() const
+  {
+    return ((nscolor) (((ClampColor(mA * 255.0f)) << 24) | ((ClampColor(mB * 255.0f))<<16) | ((ClampColor(mG * 255.0f))<<8) | (ClampColor(mR * 255.0f))));
+
+
+
+  }
+
+  RGBAColorData WithAlpha(float aAlpha) const
+  {
+    RGBAColorData result = *this;
+    result.mA = aAlpha;
+    return result;
+  }
+};
+
+struct ComplexColorData
+{
+  RGBAColorData mColor;
+  float mForegroundRatio;
+
+  ComplexColorData() = default;
+  ComplexColorData(const RGBAColorData& aColor, float aForegroundRatio)
+    : mColor(aColor), mForegroundRatio(aForegroundRatio) {}
+  ComplexColorData(nscolor aColor, float aForegroundRatio)
+    : mColor(aColor), mForegroundRatio(aForegroundRatio) {}
+  explicit ComplexColorData(const StyleComplexColor& aColor)
+    : mColor(aColor.mColor)
+    , mForegroundRatio(aColor.mForegroundRatio * (1.0f / 255.0f)) {}
+
+  bool operator==(const ComplexColorData& aOther) const
+  {
+    return mForegroundRatio == aOther.mForegroundRatio &&
+           (IsCurrentColor() || mColor == aOther.mColor);
+  }
+  bool operator!=(const ComplexColorData& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  bool IsCurrentColor() const { return mForegroundRatio >= 1.0f; }
+  bool IsNumericColor() const { return mForegroundRatio <= 0.0f; }
+
+  StyleComplexColor ToComplexColor() const
+  {
+    return {mColor.ToColor(), ClampColor(mForegroundRatio * 255.0f)};
+  }
+};
+
+struct ComplexColorValue final : public ComplexColorData
+{
+
+  template<typename... Args>
+  explicit ComplexColorValue(Args&&... aArgs)
+    : ComplexColorData(Forward<Args>(aArgs)...) {}
+  ComplexColorValue(const ComplexColorValue&) = delete;
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ComplexColorValue>::value, "Reference-counted class " "ComplexColorValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
+
+private:
+  ~ComplexColorValue() {}
+};
+
+}
+}
+
+enum nsCSSUnit {
+  eCSSUnit_Null = 0,
+  eCSSUnit_Auto = 1,
+  eCSSUnit_Inherit = 2,
+  eCSSUnit_Initial = 3,
+  eCSSUnit_Unset = 4,
+  eCSSUnit_None = 5,
+  eCSSUnit_Normal = 6,
+  eCSSUnit_System_Font = 7,
+  eCSSUnit_All = 8,
+  eCSSUnit_Dummy = 9,
+
+  eCSSUnit_DummyInherit = 10,
+
+
+  eCSSUnit_String = 11,
+  eCSSUnit_Ident = 12,
+  eCSSUnit_Attr = 14,
+  eCSSUnit_Local_Font = 15,
+  eCSSUnit_Font_Format = 16,
+  eCSSUnit_Element = 17,
+
+  eCSSUnit_Array = 20,
+  eCSSUnit_Counter = 21,
+  eCSSUnit_Counters = 22,
+  eCSSUnit_Cubic_Bezier = 23,
+  eCSSUnit_Steps = 24,
+  eCSSUnit_Symbols = 25,
+  eCSSUnit_Function = 26,
+# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  eCSSUnit_Calc = 30,
+
+
+  eCSSUnit_Calc_Plus = 31,
+  eCSSUnit_Calc_Minus = 32,
+  eCSSUnit_Calc_Times_L = 33,
+  eCSSUnit_Calc_Times_R = 34,
+  eCSSUnit_Calc_Divided = 35,
+
+  eCSSUnit_URL = 40,
+  eCSSUnit_Image = 41,
+  eCSSUnit_Gradient = 42,
+  eCSSUnit_TokenStream = 43,
+  eCSSUnit_GridTemplateAreas = 44,
+
+
+  eCSSUnit_Pair = 50,
+  eCSSUnit_Triplet = 51,
+  eCSSUnit_Rect = 52,
+  eCSSUnit_List = 53,
+  eCSSUnit_ListDep = 54,
+
+  eCSSUnit_SharedList = 55,
+
+  eCSSUnit_PairList = 56,
+  eCSSUnit_PairListDep = 57,
+
+
+  eCSSUnit_FontFamilyList = 58,
+
+
+  eCSSUnit_AtomIdent = 60,
+
+  eCSSUnit_Integer = 70,
+  eCSSUnit_Enumerated = 71,
+
+  eCSSUnit_EnumColor = 80,
+  eCSSUnit_RGBColor = 81,
+  eCSSUnit_RGBAColor = 82,
+  eCSSUnit_HexColor = 83,
+  eCSSUnit_ShortHexColor = 84,
+  eCSSUnit_HexColorAlpha = 85,
+  eCSSUnit_ShortHexColorAlpha = 86,
+  eCSSUnit_PercentageRGBColor = 87,
+
+
+
+  eCSSUnit_PercentageRGBAColor = 88,
+
+
+
+  eCSSUnit_HSLColor = 89,
+  eCSSUnit_HSLAColor = 90,
+  eCSSUnit_ComplexColor = 91,
+
+  eCSSUnit_Percent = 100,
+  eCSSUnit_Number = 101,
+
+
+  eCSSUnit_PhysicalMillimeter = 200,
+
+
+
+  eCSSUnit_ViewportWidth = 700,
+  eCSSUnit_ViewportHeight = 701,
+  eCSSUnit_ViewportMin = 702,
+  eCSSUnit_ViewportMax = 703,
+
+
+  eCSSUnit_EM = 800,
+  eCSSUnit_XHeight = 801,
+  eCSSUnit_Char = 802,
+  eCSSUnit_RootEM = 803,
+
+
+  eCSSUnit_Point = 900,
+  eCSSUnit_Inch = 901,
+  eCSSUnit_Millimeter = 902,
+  eCSSUnit_Centimeter = 903,
+  eCSSUnit_Pica = 904,
+  eCSSUnit_Quarter = 905,
+  eCSSUnit_Pixel = 906,
+
+
+  eCSSUnit_Degree = 1000,
+  eCSSUnit_Grad = 1001,
+  eCSSUnit_Radian = 1002,
+  eCSSUnit_Turn = 1003,
+
+
+  eCSSUnit_Hertz = 2000,
+  eCSSUnit_Kilohertz = 2001,
+
+
+  eCSSUnit_Seconds = 3000,
+  eCSSUnit_Milliseconds = 3001,
+
+
+  eCSSUnit_FlexFraction = 4000
+};
+
+struct nsCSSValueGradient;
+struct nsCSSValuePair;
+struct nsCSSValuePair_heap;
+struct nsCSSValueTokenStream;
+struct nsCSSRect;
+struct nsCSSRect_heap;
+struct nsCSSValueList;
+struct nsCSSValueList_heap;
+struct nsCSSValueSharedList;
+struct nsCSSValuePairList;
+struct nsCSSValuePairList_heap;
+struct nsCSSValueTriplet;
+struct nsCSSValueTriplet_heap;
+class nsCSSValueFloatColor;
+
+class nsCSSValue {
+public:
+  struct Array;
+  friend struct Array;
+
+  friend struct mozilla::css::URLValueData;
+
+  friend struct mozilla::css::ImageValue;
+
+
+  explicit nsCSSValue(nsCSSUnit aUnit = eCSSUnit_Null)
+    : mUnit(aUnit)
+  {
+    do { } while (0);
+  }
+
+  nsCSSValue(int32_t aValue, nsCSSUnit aUnit);
+  nsCSSValue(float aValue, nsCSSUnit aUnit);
+  nsCSSValue(const nsString& aValue, nsCSSUnit aUnit);
+  nsCSSValue(Array* aArray, nsCSSUnit aUnit);
+  explicit nsCSSValue(mozilla::css::URLValue* aValue);
+  explicit nsCSSValue(mozilla::css::ImageValue* aValue);
+  explicit nsCSSValue(nsCSSValueGradient* aValue);
+  explicit nsCSSValue(nsCSSValueTokenStream* aValue);
+  explicit nsCSSValue(mozilla::css::GridTemplateAreasValue* aValue);
+  explicit nsCSSValue(mozilla::css::FontFamilyListRefCnt* aValue);
+  nsCSSValue(const nsCSSValue& aCopy);
+  nsCSSValue(nsCSSValue&& aOther)
+    : mUnit(aOther.mUnit)
+    , mValue(aOther.mValue)
+  {
+    aOther.mUnit = eCSSUnit_Null;
+  }
+  ~nsCSSValue() { Reset(); }
+
+  nsCSSValue& operator=(const nsCSSValue& aCopy);
+  nsCSSValue& operator=(nsCSSValue&& aCopy);
+  bool operator==(const nsCSSValue& aOther) const;
+
+  bool operator!=(const nsCSSValue& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+
+  enum Serialization { eNormalized, eAuthorSpecified };
+
+
+
+
+
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      Serialization aValueSerialization) const;
+
+  nsCSSUnit GetUnit() const { return mUnit; }
+  bool IsLengthUnit() const
+    { return eCSSUnit_PhysicalMillimeter <= mUnit && mUnit <= eCSSUnit_Pixel; }
+  bool IsLengthPercentCalcUnit() const
+    { return IsLengthUnit() || mUnit == eCSSUnit_Percent || IsCalcUnit(); }
+
+
+
+
+
+  bool IsFixedLengthUnit() const
+    { return mUnit == eCSSUnit_PhysicalMillimeter; }
+# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  bool IsRelativeLengthUnit() const
+    { return eCSSUnit_EM <= mUnit && mUnit <= eCSSUnit_RootEM; }
+
+
+
+  static bool IsPixelLengthUnit(nsCSSUnit aUnit)
+    { return eCSSUnit_Point <= aUnit && aUnit <= eCSSUnit_Pixel; }
+  bool IsPixelLengthUnit() const
+    { return IsPixelLengthUnit(mUnit); }
+  static bool IsPercentLengthUnit(nsCSSUnit aUnit)
+    { return aUnit == eCSSUnit_Percent; }
+  bool IsPercentLengthUnit()
+    { return IsPercentLengthUnit(mUnit); }
+  static bool IsFloatUnit(nsCSSUnit aUnit)
+    { return eCSSUnit_Number <= aUnit; }
+  bool IsAngularUnit() const
+    { return eCSSUnit_Degree <= mUnit && mUnit <= eCSSUnit_Turn; }
+  bool IsFrequencyUnit() const
+    { return eCSSUnit_Hertz <= mUnit && mUnit <= eCSSUnit_Kilohertz; }
+  bool IsTimeUnit() const
+    { return eCSSUnit_Seconds <= mUnit && mUnit <= eCSSUnit_Milliseconds; }
+  bool IsCalcUnit() const
+    { return eCSSUnit_Calc <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
+
+  bool UnitHasStringValue() const
+    { return eCSSUnit_String <= mUnit && mUnit <= eCSSUnit_Element; }
+  bool UnitHasArrayValue() const
+    { return eCSSUnit_Array <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
+# 725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  bool IsIntegerColorUnit() const { return IsIntegerColorUnit(mUnit); }
+  bool IsFloatColorUnit() const { return IsFloatColorUnit(mUnit); }
+  bool IsNumericColorUnit() const { return IsNumericColorUnit(mUnit); }
+  static bool IsIntegerColorUnit(nsCSSUnit aUnit)
+  { return eCSSUnit_RGBColor <= aUnit && aUnit <= eCSSUnit_ShortHexColorAlpha; }
+  static bool IsFloatColorUnit(nsCSSUnit aUnit)
+  { return eCSSUnit_PercentageRGBColor <= aUnit &&
+           aUnit <= eCSSUnit_HSLAColor; }
+  static bool IsNumericColorUnit(nsCSSUnit aUnit)
+  { return IsIntegerColorUnit(aUnit) || IsFloatColorUnit(aUnit); }
+
+  int32_t GetIntValue() const
+  {
+    do { } while (0);
+
+
+
+    return mValue.mInt;
+  }
+
+  nsCSSKeyword GetKeywordValue() const
+  {
+    do { } while (0);
+    return static_cast<nsCSSKeyword>(mValue.mInt);
+  }
+
+  float GetPercentValue() const
+  {
+    do { } while (0);
+    return mValue.mFloat;
+  }
+
+  float GetFloatValue() const
+  {
+    do { } while (0);
+    do { } while (0);
+    return mValue.mFloat;
+  }
+
+  float GetAngleValue() const
+  {
+    do { } while (0);
+
+    return mValue.mFloat;
+  }
+
+
+  double GetAngleValueInRadians() const;
+
+
+  double GetAngleValueInDegrees() const;
+
+  nsAString& GetStringValue(nsAString& aBuffer) const
+  {
+    do { } while (0);
+    aBuffer.Truncate();
+    uint32_t len = NS_strlen(GetBufferValue(mValue.mString));
+    mValue.mString->ToString(len, aBuffer);
+    return aBuffer;
+  }
+
+  const char16_t* GetStringBufferValue() const
+  {
+    do { } while (0);
+    return GetBufferValue(mValue.mString);
+  }
+
+  nscolor GetColorValue() const;
+  bool IsNonTransparentColor() const;
+  mozilla::StyleComplexColor GetStyleComplexColorValue() const
+  {
+    do { } while (0);
+    return mValue.mComplexColor->ToComplexColor();
+  }
+
+  Array* GetArrayValue() const
+  {
+    do { } while (0);
+    return mValue.mArray;
+  }
+
+  nsIURI* GetURLValue() const
+  {
+    do { } while (0);
+
+    return mUnit == eCSSUnit_URL ?
+      mValue.mURL->GetURI() : mValue.mImage->GetURI();
+  }
+
+  nsCSSValueGradient* GetGradientValue() const
+  {
+    do { } while (0);
+    return mValue.mGradient;
+  }
+
+  nsCSSValueTokenStream* GetTokenStreamValue() const
+  {
+    do { } while (0);
+    return mValue.mTokenStream;
+  }
+
+  nsCSSValueSharedList* GetSharedListValue() const
+  {
+    do { } while (0);
+    return mValue.mSharedList;
+  }
+
+  mozilla::FontFamilyList* GetFontFamilyListValue() const
+  {
+    do { } while (0);
+
+    do { } while(0);
+
+    return mValue.mFontFamilyList;
+  }
+
+
+  inline nsCSSValuePair& GetPairValue();
+  inline const nsCSSValuePair& GetPairValue() const;
+
+  inline nsCSSRect& GetRectValue();
+  inline const nsCSSRect& GetRectValue() const;
+
+  inline nsCSSValueList* GetListValue();
+  inline const nsCSSValueList* GetListValue() const;
+
+  inline nsCSSValuePairList* GetPairListValue();
+  inline const nsCSSValuePairList* GetPairListValue() const;
+
+  inline nsCSSValueTriplet& GetTripletValue();
+  inline const nsCSSValueTriplet& GetTripletValue() const;
+
+
+  mozilla::css::URLValue* GetURLStructValue() const
+  {
+
+
+    do { } while (0);
+    return mValue.mURL;
+  }
+
+  mozilla::css::ImageValue* GetImageStructValue() const
+  {
+    do { } while (0);
+    return mValue.mImage;
+  }
+
+  mozilla::css::GridTemplateAreasValue* GetGridTemplateAreas() const
+  {
+    do { } while (0);
+
+    return mValue.mGridTemplateAreas;
+  }
+
+  const char16_t* GetOriginalURLValue() const
+  {
+    do { } while (0);
+
+    return GetBufferValue(mUnit == eCSSUnit_URL ?
+                            mValue.mURL->mString :
+                            mValue.mImage->mString);
+  }
+
+
+
+
+  imgRequestProxy* GetImageValue(nsIDocument* aDocument) const;
+
+
+
+  already_AddRefed<imgRequestProxy> GetPossiblyStaticImageValue(
+      nsIDocument* aDocument, nsPresContext* aPresContext) const;
+
+  nscoord GetFixedLength(nsPresContext* aPresContext) const;
+  nscoord GetPixelLength() const;
+
+  nsCSSValueFloatColor* GetFloatColorValue() const
+  {
+    do { } while (0);
+    return mValue.mFloatColor;
+  }
+
+  nsIAtom* GetAtomValue() const {
+    do { } while (0);
+    return mValue.mAtom;
+  }
+
+  void Reset()
+  {
+    if (mUnit != eCSSUnit_Null)
+      DoReset();
+  }
+private:
+  void DoReset();
+
+public:
+  void SetIntValue(int32_t aValue, nsCSSUnit aUnit);
+  template<typename T,
+           typename = typename std::enable_if<std::is_enum<T>::value>::type>
+  void SetEnumValue(T aValue)
+  {
+    static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
+                  "aValue must be an enum that fits within mValue.mInt");
+    SetIntValue(static_cast<int32_t>(aValue), eCSSUnit_Enumerated);
+  }
+  void SetPercentValue(float aValue);
+  void SetFloatValue(float aValue, nsCSSUnit aUnit);
+  void SetStringValue(const nsString& aValue, nsCSSUnit aUnit);
+  void SetColorValue(nscolor aValue);
+  void SetIntegerColorValue(nscolor aValue, nsCSSUnit aUnit);
+
+  void SetIntegerCoordValue(nscoord aCoord);
+  void SetFloatColorValue(float aComponent1,
+                          float aComponent2,
+                          float aComponent3,
+                          float aAlpha, nsCSSUnit aUnit);
+  void SetRGBAColorValue(const mozilla::css::RGBAColorData& aValue);
+  void SetComplexColorValue(
+    already_AddRefed<mozilla::css::ComplexColorValue> aValue);
+  void SetArrayValue(nsCSSValue::Array* aArray, nsCSSUnit aUnit);
+  void SetURLValue(mozilla::css::URLValue* aURI);
+  void SetImageValue(mozilla::css::ImageValue* aImage);
+  void SetGradientValue(nsCSSValueGradient* aGradient);
+  void SetTokenStreamValue(nsCSSValueTokenStream* aTokenStream);
+  void SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue* aValue);
+  void SetFontFamilyListValue(mozilla::css::FontFamilyListRefCnt* aFontListValue);
+  void SetPairValue(const nsCSSValuePair* aPair);
+  void SetPairValue(const nsCSSValue& xValue, const nsCSSValue& yValue);
+  void SetSharedListValue(nsCSSValueSharedList* aList);
+  void SetDependentListValue(nsCSSValueList* aList);
+  void SetDependentPairListValue(nsCSSValuePairList* aList);
+  void SetTripletValue(const nsCSSValueTriplet* aTriplet);
+  void SetTripletValue(const nsCSSValue& xValue, const nsCSSValue& yValue, const nsCSSValue& zValue);
+  void SetAutoValue();
+  void SetInheritValue();
+  void SetInitialValue();
+  void SetUnsetValue();
+  void SetNoneValue();
+  void SetAllValue();
+  void SetNormalValue();
+  void SetSystemFontValue();
+  void SetDummyValue();
+  void SetDummyInheritValue();
+
+
+  void SetCalcValue(const nsStyleCoord::CalcValue* aCalc);
+
+  nsStyleCoord::CalcValue GetCalcValue() const;
+
+
+
+  nsCSSRect& SetRectValue();
+  nsCSSValueList* SetListValue();
+  nsCSSValuePairList* SetPairListValue();
+
+
+  void AdoptListValue(mozilla::UniquePtr<nsCSSValueList> aValue);
+  void AdoptPairListValue(mozilla::UniquePtr<nsCSSValuePairList> aValue);
+
+  void StartImageLoad(nsIDocument* aDocument) const;
+
+
+  Array* InitFunction(nsCSSKeyword aFunctionId, uint32_t aNumArgs);
+
+  bool EqualsFunction(nsCSSKeyword aFunctionId) const;
+
+
+
+  static already_AddRefed<nsStringBuffer>
+    BufferFromString(const nsString& aValue);
+
+
+  void AtomizeIdentValue();
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  static void
+  AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],
+                               const nsCSSValue* aValues[],
+                               nsAString& aString,
+                               Serialization aSerialization);
+  static void
+  AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],
+                                 const nsCSSValue* aValues[],
+                                 nsAString& aResult,
+                                 Serialization aValueSerialization);
+  static void
+  AppendAlignJustifyValueToString(int32_t aValue, nsAString& aResult);
+
+private:
+  static const char16_t* GetBufferValue(nsStringBuffer* aBuffer) {
+    return static_cast<char16_t*>(aBuffer->Data());
+  }
+
+  void AppendPolygonToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                             Serialization aValueSerialization) const;
+  void AppendPositionCoordinateToString(const nsCSSValue& aValue,
+                                        nsCSSPropertyID aProperty,
+                                        nsAString& aResult,
+                                        Serialization aSerialization) const;
+  void AppendCircleOrEllipseToString(
+           nsCSSKeyword aFunctionId,
+           nsCSSPropertyID aProperty, nsAString& aResult,
+           Serialization aValueSerialization) const;
+  void AppendBasicShapePositionToString(
+           nsAString& aResult,
+           Serialization aValueSerialization) const;
+  void AppendInsetToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                           Serialization aValueSerialization) const;
+protected:
+  nsCSSUnit mUnit;
+  union {
+    int32_t mInt;
+    float mFloat;
+
+
+    nsStringBuffer* mString;
+    nscolor mColor;
+    nsIAtom* mAtom;
+    Array* mArray;
+    mozilla::css::URLValue* mURL;
+    mozilla::css::ImageValue* mImage;
+    mozilla::css::GridTemplateAreasValue* mGridTemplateAreas;
+    nsCSSValueGradient* mGradient;
+    nsCSSValueTokenStream* mTokenStream;
+    nsCSSValuePair_heap* mPair;
+    nsCSSRect_heap* mRect;
+    nsCSSValueTriplet_heap* mTriplet;
+    nsCSSValueList_heap* mList;
+    nsCSSValueList* mListDependent;
+    nsCSSValueSharedList* mSharedList;
+    nsCSSValuePairList_heap* mPairList;
+    nsCSSValuePairList* mPairListDependent;
+    nsCSSValueFloatColor* mFloatColor;
+    mozilla::css::FontFamilyListRefCnt* mFontFamilyList;
+    mozilla::css::ComplexColorValue* mComplexColor;
+  } mValue;
+};
+
+struct nsCSSValue::Array final {
+
+
+  static Array* Create(size_t aItemCount) {
+    return new (aItemCount) Array(aItemCount);
+  }
+
+  nsCSSValue& operator[](size_t aIndex) {
+    do { } while (0);
+    return mArray[aIndex];
+  }
+
+  const nsCSSValue& operator[](size_t aIndex) const {
+    do { } while (0);
+    return mArray[aIndex];
+  }
+
+  nsCSSValue& Item(size_t aIndex) { return (*this)[aIndex]; }
+  const nsCSSValue& Item(size_t aIndex) const { return (*this)[aIndex]; }
+
+  size_t Count() const { return mCount; }
+
+
+  nsCSSValue* ItemStorage() {
+    return this->First();
+  }
+
+  bool operator==(const Array& aOther) const
+  {
+    if (mCount != aOther.mCount)
+      return false;
+    for (size_t i = 0; i < mCount; ++i)
+      if ((*this)[i] != aOther[i])
+        return false;
+    return true;
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Array>::value, "Reference-counted class " "Array" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
+private:
+
+  const size_t mCount;
+
+
+
+  nsCSSValue mArray[1];
+
+  void* operator new(size_t aSelfSize, size_t aItemCount) throw() {
+    do { } while (0);
+    return ::operator new(aSelfSize + sizeof(nsCSSValue) * (aItemCount - 1));
+  }
+
+  void operator delete(void* aPtr) { ::operator delete(aPtr); }
+
+  nsCSSValue* First() { return mArray; }
+
+  const nsCSSValue* First() const { return mArray; }
+
+
+
+
+
+  explicit Array(size_t aItemCount)
+    : mRefCnt(0)
+    , mCount(aItemCount)
+  {
+    for (nsCSSValue *val = First() + 1, *val_end = First() + mCount; val != val_end; ++val) {
+      new (val) nsCSSValue();
+    }
+  }
+
+  ~Array()
+  {
+    for (nsCSSValue *val = First() + 1, *val_end = First() + mCount; val != val_end; ++val) {
+      val->~nsCSSValue();
+    }
+  }
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+
+
+private:
+  Array(const Array& aOther) = delete;
+  Array& operator=(const Array& aOther) = delete;
+};
+
+
+struct nsCSSValueList {
+  nsCSSValueList() : mNext(nullptr) { ; }
+  ~nsCSSValueList();
+
+  nsCSSValueList* Clone() const;
+  void CloneInto(nsCSSValueList* aList) const;
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      nsCSSValue::Serialization aValueSerialization) const;
+
+  static bool Equal(const nsCSSValueList* aList1,
+                    const nsCSSValueList* aList2);
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  nsCSSValue mValue;
+  nsCSSValueList* mNext;
+
+private:
+  nsCSSValueList(const nsCSSValueList& aCopy)
+    : mValue(aCopy.mValue), mNext(nullptr)
+  {
+                                  ;
+  }
+
+
+
+
+  bool operator==(nsCSSValueList const& aOther) const = delete;
+  bool operator!=(const nsCSSValueList& aOther) const = delete;
+};
+
+
+
+
+struct nsCSSValueList_heap final : public nsCSSValueList {
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueList_heap>::value, "Reference-counted class " "nsCSSValueList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSValueList_heap()
+  {
+  }
+};
+
+
+
+
+
+struct nsCSSValueSharedList final {
+  nsCSSValueSharedList()
+    : mHead(nullptr)
+  {
+  }
+
+
+  explicit nsCSSValueSharedList(nsCSSValueList* aList)
+    : mHead(aList)
+  {
+  }
+
+private:
+
+  ~nsCSSValueSharedList();
+
+public:
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueSharedList>::value, "Reference-counted class " "nsCSSValueSharedList" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      nsCSSValue::Serialization aValueSerialization) const;
+
+  bool operator==(nsCSSValueSharedList const& aOther) const;
+  bool operator!=(const nsCSSValueSharedList& aOther) const
+  { return !(*this == aOther); }
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  nsCSSValueList* mHead;
+};
+
+
+
+inline nsCSSValueList*
+nsCSSValue::GetListValue()
+{
+  if (mUnit == eCSSUnit_List)
+    return mValue.mList;
+  else {
+    do { } while (0);
+    return mValue.mListDependent;
+  }
+}
+
+inline const nsCSSValueList*
+nsCSSValue::GetListValue() const
+{
+  if (mUnit == eCSSUnit_List)
+    return mValue.mList;
+  else {
+    do { } while (0);
+    return mValue.mListDependent;
+  }
+}
+
+struct nsCSSRect {
+  nsCSSRect(void);
+  nsCSSRect(const nsCSSRect& aCopy);
+  ~nsCSSRect();
+
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      nsCSSValue::Serialization aValueSerialization) const;
+
+  bool operator==(const nsCSSRect& aOther) const {
+    return mTop == aOther.mTop &&
+           mRight == aOther.mRight &&
+           mBottom == aOther.mBottom &&
+           mLeft == aOther.mLeft;
+  }
+
+  bool operator!=(const nsCSSRect& aOther) const {
+    return mTop != aOther.mTop ||
+           mRight != aOther.mRight ||
+           mBottom != aOther.mBottom ||
+           mLeft != aOther.mLeft;
+  }
+
+  void SetAllSidesTo(const nsCSSValue& aValue);
+
+  bool AllSidesEqualTo(const nsCSSValue& aValue) const {
+    return mTop == aValue &&
+           mRight == aValue &&
+           mBottom == aValue &&
+           mLeft == aValue;
+  }
+
+  void Reset() {
+    mTop.Reset();
+    mRight.Reset();
+    mBottom.Reset();
+    mLeft.Reset();
+  }
+
+  bool HasValue() const {
+    return
+      mTop.GetUnit() != eCSSUnit_Null ||
+      mRight.GetUnit() != eCSSUnit_Null ||
+      mBottom.GetUnit() != eCSSUnit_Null ||
+      mLeft.GetUnit() != eCSSUnit_Null;
+  }
+
+  nsCSSValue mTop;
+  nsCSSValue mRight;
+  nsCSSValue mBottom;
+  nsCSSValue mLeft;
+
+  typedef nsCSSValue nsCSSRect::*side_type;
+  static const side_type sides[4];
+};
+
+
+
+
+struct nsCSSRect_heap final : public nsCSSRect {
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSRect_heap>::value, "Reference-counted class " "nsCSSRect_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSRect_heap()
+  {
+  }
+};
+
+
+
+inline nsCSSRect&
+nsCSSValue::GetRectValue()
+{
+  do { } while (0);
+  return *mValue.mRect;
+}
+
+inline const nsCSSRect&
+nsCSSValue::GetRectValue() const
+{
+  do { } while (0);
+  return *mValue.mRect;
+}
+
+struct nsCSSValuePair {
+  nsCSSValuePair()
+  {
+                                  ;
+  }
+  explicit nsCSSValuePair(nsCSSUnit aUnit)
+    : mXValue(aUnit), mYValue(aUnit)
+  {
+                                  ;
+  }
+  nsCSSValuePair(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
+    : mXValue(aXValue), mYValue(aYValue)
+  {
+                                  ;
+  }
+  nsCSSValuePair(const nsCSSValuePair& aCopy)
+    : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue)
+  {
+                                  ;
+  }
+  ~nsCSSValuePair()
+  {
+                                  ;
+  }
+
+  nsCSSValuePair& operator=(const nsCSSValuePair& aOther) {
+    mXValue = aOther.mXValue;
+    mYValue = aOther.mYValue;
+    return *this;
+  }
+
+  bool operator==(const nsCSSValuePair& aOther) const {
+    return mXValue == aOther.mXValue &&
+           mYValue == aOther.mYValue;
+  }
+
+  bool operator!=(const nsCSSValuePair& aOther) const {
+    return mXValue != aOther.mXValue ||
+           mYValue != aOther.mYValue;
+  }
+
+  bool BothValuesEqualTo(const nsCSSValue& aValue) const {
+    return mXValue == aValue &&
+           mYValue == aValue;
+  }
+
+  void SetBothValuesTo(const nsCSSValue& aValue) {
+    mXValue = aValue;
+    mYValue = aValue;
+  }
+
+  void Reset() {
+    mXValue.Reset();
+    mYValue.Reset();
+  }
+
+  bool HasValue() const {
+    return mXValue.GetUnit() != eCSSUnit_Null ||
+           mYValue.GetUnit() != eCSSUnit_Null;
+  }
+
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      nsCSSValue::Serialization aValueSerialization) const;
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  nsCSSValue mXValue;
+  nsCSSValue mYValue;
+};
+
+
+
+
+struct nsCSSValuePair_heap final : public nsCSSValuePair {
+
+  nsCSSValuePair_heap(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
+      : nsCSSValuePair(aXValue, aYValue)
+  {}
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePair_heap>::value, "Reference-counted class " "nsCSSValuePair_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSValuePair_heap()
+  {
+  }
+};
+
+struct nsCSSValueTriplet {
+    nsCSSValueTriplet()
+    {
+                                         ;
+    }
+    explicit nsCSSValueTriplet(nsCSSUnit aUnit)
+        : mXValue(aUnit), mYValue(aUnit), mZValue(aUnit)
+    {
+                                         ;
+    }
+    nsCSSValueTriplet(const nsCSSValue& aXValue,
+                      const nsCSSValue& aYValue,
+                      const nsCSSValue& aZValue)
+        : mXValue(aXValue), mYValue(aYValue), mZValue(aZValue)
+    {
+                                         ;
+    }
+    nsCSSValueTriplet(const nsCSSValueTriplet& aCopy)
+        : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mZValue(aCopy.mZValue)
+    {
+                                         ;
+    }
+    ~nsCSSValueTriplet()
+    {
+                                         ;
+    }
+
+    bool operator==(const nsCSSValueTriplet& aOther) const {
+        return mXValue == aOther.mXValue &&
+               mYValue == aOther.mYValue &&
+               mZValue == aOther.mZValue;
+    }
+
+    bool operator!=(const nsCSSValueTriplet& aOther) const {
+        return mXValue != aOther.mXValue ||
+               mYValue != aOther.mYValue ||
+               mZValue != aOther.mZValue;
+    }
+
+    bool AllValuesEqualTo(const nsCSSValue& aValue) const {
+        return mXValue == aValue &&
+               mYValue == aValue &&
+               mZValue == aValue;
+    }
+
+    void SetAllValuesTo(const nsCSSValue& aValue) {
+        mXValue = aValue;
+        mYValue = aValue;
+        mZValue = aValue;
+    }
+
+    void Reset() {
+        mXValue.Reset();
+        mYValue.Reset();
+        mZValue.Reset();
+    }
+
+    bool HasValue() const {
+        return mXValue.GetUnit() != eCSSUnit_Null ||
+               mYValue.GetUnit() != eCSSUnit_Null ||
+               mZValue.GetUnit() != eCSSUnit_Null;
+    }
+
+    void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                        nsCSSValue::Serialization aValueSerialization) const;
+
+    nsCSSValue mXValue;
+    nsCSSValue mYValue;
+    nsCSSValue mZValue;
+};
+
+
+
+
+struct nsCSSValueTriplet_heap final : public nsCSSValueTriplet {
+
+  nsCSSValueTriplet_heap(const nsCSSValue& aXValue, const nsCSSValue& aYValue, const nsCSSValue& aZValue)
+    : nsCSSValueTriplet(aXValue, aYValue, aZValue)
+  {}
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTriplet_heap>::value, "Reference-counted class " "nsCSSValueTriplet_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSValueTriplet_heap()
+  {
+  }
+};
+
+
+
+inline nsCSSValuePair&
+nsCSSValue::GetPairValue()
+{
+  do { } while (0);
+  return *mValue.mPair;
+}
+
+inline const nsCSSValuePair&
+nsCSSValue::GetPairValue() const
+{
+  do { } while (0);
+  return *mValue.mPair;
+}
+
+inline nsCSSValueTriplet&
+nsCSSValue::GetTripletValue()
+{
+    do { } while (0);
+    return *mValue.mTriplet;
+}
+
+inline const nsCSSValueTriplet&
+nsCSSValue::GetTripletValue() const
+{
+    do { } while (0);
+    return *mValue.mTriplet;
+}
+
+
+struct nsCSSValuePairList {
+  nsCSSValuePairList() : mNext(nullptr) { ; }
+  ~nsCSSValuePairList();
+
+  nsCSSValuePairList* Clone() const;
+  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+                      nsCSSValue::Serialization aValueSerialization) const;
+
+  static bool Equal(const nsCSSValuePairList* aList1,
+                    const nsCSSValuePairList* aList2);
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  nsCSSValue mXValue;
+  nsCSSValue mYValue;
+  nsCSSValuePairList* mNext;
+
+private:
+  nsCSSValuePairList(const nsCSSValuePairList& aCopy)
+    : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mNext(nullptr)
+  {
+                                      ;
+  }
+
+
+
+
+  bool operator==(const nsCSSValuePairList& aOther) const = delete;
+  bool operator!=(const nsCSSValuePairList& aOther) const = delete;
+};
+
+
+
+
+struct nsCSSValuePairList_heap final : public nsCSSValuePairList {
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePairList_heap>::value, "Reference-counted class " "nsCSSValuePairList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSValuePairList_heap()
+  {
+  }
+};
+
+
+
+inline nsCSSValuePairList*
+nsCSSValue::GetPairListValue()
+{
+  if (mUnit == eCSSUnit_PairList)
+    return mValue.mPairList;
+  else {
+    do { } while (0);
+    return mValue.mPairListDependent;
+  }
+}
+
+inline const nsCSSValuePairList*
+nsCSSValue::GetPairListValue() const
+{
+  if (mUnit == eCSSUnit_PairList)
+    return mValue.mPairList;
+  else {
+    do { } while (0);
+    return mValue.mPairListDependent;
+  }
+}
+
+struct nsCSSValueGradientStop {
+public:
+  nsCSSValueGradientStop();
+
+
+  nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther);
+  ~nsCSSValueGradientStop();
+
+  nsCSSValue mLocation;
+  nsCSSValue mColor;
+
+
+  bool mIsInterpolationHint;
+
+  bool operator==(const nsCSSValueGradientStop& aOther) const
+  {
+    return (mLocation == aOther.mLocation &&
+            mIsInterpolationHint == aOther.mIsInterpolationHint &&
+            (mIsInterpolationHint || mColor == aOther.mColor));
+  }
+
+  bool operator!=(const nsCSSValueGradientStop& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+};
+
+struct nsCSSValueGradient final {
+  nsCSSValueGradient(bool aIsRadial, bool aIsRepeating);
+
+
+  bool mIsRadial;
+  bool mIsRepeating;
+  bool mIsLegacySyntax;
+  bool mIsExplicitSize;
+
+  nsCSSValuePair mBgPos;
+  nsCSSValue mAngle;
+
+
+private:
+  nsCSSValue mRadialValues[2];
+public:
+  nsCSSValue& GetRadialShape()
+  {
+    do { } while (0);
+    return mRadialValues[0];
+  }
+  const nsCSSValue& GetRadialShape() const
+  {
+    do { } while (0);
+    return mRadialValues[0];
+  }
+  nsCSSValue& GetRadialSize()
+  {
+    do { } while (0);
+    return mRadialValues[1];
+  }
+  const nsCSSValue& GetRadialSize() const
+  {
+    do { } while (0);
+    return mRadialValues[1];
+  }
+  nsCSSValue& GetRadiusX()
+  {
+    do { } while (0);
+    return mRadialValues[0];
+  }
+  const nsCSSValue& GetRadiusX() const
+  {
+    do { } while (0);
+    return mRadialValues[0];
+  }
+  nsCSSValue& GetRadiusY()
+  {
+    do { } while (0);
+    return mRadialValues[1];
+  }
+  const nsCSSValue& GetRadiusY() const
+  {
+    do { } while (0);
+    return mRadialValues[1];
+  }
+
+  InfallibleTArray<nsCSSValueGradientStop> mStops;
+
+  bool operator==(const nsCSSValueGradient& aOther) const
+  {
+    if (mIsRadial != aOther.mIsRadial ||
+        mIsRepeating != aOther.mIsRepeating ||
+        mIsLegacySyntax != aOther.mIsLegacySyntax ||
+        mIsExplicitSize != aOther.mIsExplicitSize ||
+        mBgPos != aOther.mBgPos ||
+        mAngle != aOther.mAngle ||
+        mRadialValues[0] != aOther.mRadialValues[0] ||
+        mRadialValues[1] != aOther.mRadialValues[1])
+      return false;
+
+    if (mStops.Length() != aOther.mStops.Length())
+      return false;
+
+    for (uint32_t i = 0; i < mStops.Length(); i++) {
+      if (mStops[i] != aOther.mStops[i])
+        return false;
+    }
+
+    return true;
+  }
+
+  bool operator!=(const nsCSSValueGradient& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueGradient>::value, "Reference-counted class " "nsCSSValueGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+private:
+
+  ~nsCSSValueGradient()
+  {
+  }
+
+  nsCSSValueGradient(const nsCSSValueGradient& aOther) = delete;
+  nsCSSValueGradient& operator=(const nsCSSValueGradient& aOther) = delete;
+};
+# 1769 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+struct nsCSSValueTokenStream final {
+  nsCSSValueTokenStream();
+
+private:
+
+  ~nsCSSValueTokenStream();
+
+public:
+  bool operator==(const nsCSSValueTokenStream& aOther) const
+  {
+    bool eq;
+    return mPropertyID == aOther.mPropertyID &&
+           mShorthandPropertyID == aOther.mShorthandPropertyID &&
+           mTokenStream.Equals(aOther.mTokenStream) &&
+           mLevel == aOther.mLevel &&
+           (mBaseURI == aOther.mBaseURI ||
+            (mBaseURI && aOther.mBaseURI &&
+             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mBaseURI->Equals(aOther.mBaseURI, &eq))), 1))) &&
+             eq)) &&
+           (mSheetURI == aOther.mSheetURI ||
+            (mSheetURI && aOther.mSheetURI &&
+             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mSheetURI->Equals(aOther.mSheetURI, &eq))), 1))) &&
+             eq)) &&
+           (mSheetPrincipal == aOther.mSheetPrincipal ||
+            (mSheetPrincipal && aOther.mSheetPrincipal &&
+             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mSheetPrincipal->Equals(aOther.mSheetPrincipal, &eq))), 1))) &&
+
+             eq));
+  }
+
+  bool operator!=(const nsCSSValueTokenStream& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTokenStream>::value, "Reference-counted class " "nsCSSValueTokenStream" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+
+
+
+
+  nsCSSPropertyID mPropertyID;
+
+
+
+
+  nsCSSPropertyID mShorthandPropertyID;
+
+
+
+
+
+  nsString mTokenStream;
+
+  nsCOMPtr<nsIURI> mBaseURI;
+  nsCOMPtr<nsIURI> mSheetURI;
+  nsCOMPtr<nsIPrincipal> mSheetPrincipal;
+
+
+  uint32_t mLineNumber;
+  uint32_t mLineOffset;
+  mozilla::SheetType mLevel;
+
+private:
+  nsCSSValueTokenStream(const nsCSSValueTokenStream& aOther) = delete;
+  nsCSSValueTokenStream& operator=(const nsCSSValueTokenStream& aOther) = delete;
+};
+
+class nsCSSValueFloatColor final {
+public:
+  nsCSSValueFloatColor(float aComponent1, float aComponent2, float aComponent3,
+                       float aAlpha)
+    : mComponent1(aComponent1)
+    , mComponent2(aComponent2)
+    , mComponent3(aComponent3)
+    , mAlpha(aAlpha)
+  {}
+
+private:
+
+  ~nsCSSValueFloatColor()
+  {}
+
+public:
+  bool operator==(nsCSSValueFloatColor& aOther) const;
+
+  nscolor GetColorValue(nsCSSUnit aUnit) const;
+  float Comp1() const { return mComponent1; }
+  float Comp2() const { return mComponent2; }
+  float Comp3() const { return mComponent3; }
+  float Alpha() const { return mAlpha; }
+  bool IsNonTransparentColor() const;
+
+  void AppendToString(nsCSSUnit aUnit, nsAString& aResult) const;
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueFloatColor>::value, "Reference-counted class " "nsCSSValueFloatColor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+private:
+# 1881 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
+  float mComponent1;
+  float mComponent2;
+  float mComponent3;
+  float mAlpha;
+
+  nsCSSValueFloatColor(const nsCSSValueFloatColor& aOther) = delete;
+  nsCSSValueFloatColor& operator=(const nsCSSValueFloatColor& aOther)
+                                                                   = delete;
+};
+
+struct nsCSSCornerSizes {
+  nsCSSCornerSizes(void);
+  nsCSSCornerSizes(const nsCSSCornerSizes& aCopy);
+  ~nsCSSCornerSizes();
+
+
+  nsCSSValue const & GetCorner(uint32_t aCorner) const {
+    return this->*corners[aCorner];
+  }
+  nsCSSValue & GetCorner(uint32_t aCorner) {
+    return this->*corners[aCorner];
+  }
+
+  bool operator==(const nsCSSCornerSizes& aOther) const {
+    int32_t corner1905 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1905 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1905), true); ++corner1905) {
+      if (this->GetCorner(corner) != aOther.GetCorner(corner))
+        return false;
+    }
+    return true;
+  }
+
+  bool operator!=(const nsCSSCornerSizes& aOther) const {
+    int32_t corner1913 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1913 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1913), true); ++corner1913) {
+      if (this->GetCorner(corner) != aOther.GetCorner(corner))
+        return true;
+    }
+    return false;
+  }
+
+  bool HasValue() const {
+    int32_t corner1921 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1921 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1921), true); ++corner1921) {
+      if (this->GetCorner(corner).GetUnit() != eCSSUnit_Null)
+        return true;
+    }
+    return false;
+  }
+
+  void Reset();
+
+  nsCSSValue mTopLeft;
+  nsCSSValue mTopRight;
+  nsCSSValue mBottomRight;
+  nsCSSValue mBottomLeft;
+
+protected:
+  typedef nsCSSValue nsCSSCornerSizes::*corner_type;
+  static const corner_type corners[4];
+};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 2
+
+
+using mozilla::dom::DOMRect;
+using mozilla::dom::Element;
+
+namespace mozilla {
+namespace dom {
+
+class DOMIntersectionObserver;
+
+class DOMIntersectionObserverEntry final : public nsISupports,
+                                           public nsWrapperCache
+{
+  ~DOMIntersectionObserverEntry() {}
+
+public:
+  DOMIntersectionObserverEntry(nsISupports* aOwner,
+                               DOMHighResTimeStamp aTime,
+                               RefPtr<DOMRect> aRootBounds,
+                               RefPtr<DOMRect> aBoundingClientRect,
+                               RefPtr<DOMRect> aIntersectionRect,
+                               bool aIsIntersecting,
+                               Element* aTarget,
+                               double aIntersectionRatio)
+  : mOwner(aOwner),
+    mTime(aTime),
+    mRootBounds(aRootBounds),
+    mBoundingClientRect(aBoundingClientRect),
+    mIntersectionRect(aIntersectionRect),
+    mIsIntersecting(aIsIntersecting),
+    mTarget(aTarget),
+    mIntersectionRatio(aIntersectionRatio)
+  {
+  }
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMIntersectionObserverEntry"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMIntersectionObserverEntry>(p)->DeleteCycleCollectable(); } static DOMIntersectionObserverEntry* Downcast(nsISupports* s) { return static_cast<DOMIntersectionObserverEntry*>(static_cast<DOMIntersectionObserverEntry*>(s)); } static nsISupports* Upcast(DOMIntersectionObserverEntry *p) { return static_cast<nsISupports*>(static_cast<DOMIntersectionObserverEntry*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMIntersectionObserverEntry::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+  nsISupports* GetParentObject() const
+  {
+    return mOwner;
+  }
+
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
+  {
+    return mozilla::dom::IntersectionObserverEntryBinding::Wrap(aCx, this, aGivenProto);
+  }
+
+  DOMHighResTimeStamp Time()
+  {
+    return mTime;
+  }
+
+  DOMRect* GetRootBounds()
+  {
+    return mRootBounds;
+  }
+
+  DOMRect* BoundingClientRect()
+  {
+    return mBoundingClientRect;
+  }
+
+  DOMRect* IntersectionRect()
+  {
+    return mIntersectionRect;
+  }
+
+  bool IsIntersecting()
+  {
+    return mIsIntersecting;
+  }
+
+  double IntersectionRatio()
+  {
+    return mIntersectionRatio;
+  }
+
+  Element* Target()
+  {
+    return mTarget;
+  }
+
+protected:
+  nsCOMPtr<nsISupports> mOwner;
+  DOMHighResTimeStamp mTime;
+  RefPtr<DOMRect> mRootBounds;
+  RefPtr<DOMRect> mBoundingClientRect;
+  RefPtr<DOMRect> mIntersectionRect;
+  bool mIsIntersecting;
+  RefPtr<Element> mTarget;
+  double mIntersectionRatio;
+};
+
+
+
+
+
+class DOMIntersectionObserver final : public nsISupports,
+                                      public nsWrapperCache
+{
+  virtual ~DOMIntersectionObserver() {
+    Disconnect();
+  }
+
+public:
+  DOMIntersectionObserver(already_AddRefed<nsPIDOMWindowInner>&& aOwner,
+                          mozilla::dom::IntersectionCallback& aCb)
+  : mOwner(aOwner), mDocument(mOwner->GetExtantDoc()), mCallback(&aCb), mConnected(false)
+  {
+  }
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMIntersectionObserver"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMIntersectionObserver>(p)->DeleteCycleCollectable(); } static DOMIntersectionObserver* Downcast(nsISupports* s) { return static_cast<DOMIntersectionObserver*>(static_cast<DOMIntersectionObserver*>(s)); } static nsISupports* Upcast(DOMIntersectionObserver *p) { return static_cast<nsISupports*>(static_cast<DOMIntersectionObserver*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMIntersectionObserver::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+  template<typename T, typename U> struct COMTypeInfo;
+
+  static already_AddRefed<DOMIntersectionObserver>
+  Constructor(const mozilla::dom::GlobalObject& aGlobal,
+              mozilla::dom::IntersectionCallback& aCb,
+              mozilla::ErrorResult& aRv);
+  static already_AddRefed<DOMIntersectionObserver>
+  Constructor(const mozilla::dom::GlobalObject& aGlobal,
+              mozilla::dom::IntersectionCallback& aCb,
+              const mozilla::dom::IntersectionObserverInit& aOptions,
+              mozilla::ErrorResult& aRv);
+
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
+  {
+    return mozilla::dom::IntersectionObserverBinding::Wrap(aCx, this, aGivenProto);
+  }
+
+  nsISupports* GetParentObject() const
+  {
+    return mOwner;
+  }
+
+  Element* GetRoot() const {
+    return mRoot;
+  }
+
+  void GetRootMargin(mozilla::dom::DOMString& aRetVal);
+  void GetThresholds(nsTArray<double>& aRetVal);
+  void Observe(Element& aTarget);
+  void Unobserve(Element& aTarget);
+
+  void UnlinkTarget(Element& aTarget);
+  void Disconnect();
+
+  void TakeRecords(nsTArray<RefPtr<DOMIntersectionObserverEntry>>& aRetVal);
+
+  mozilla::dom::IntersectionCallback* IntersectionCallback() { return mCallback; }
+
+  bool SetRootMargin(const nsAString& aString);
+
+  void Update(nsIDocument* aDocument, DOMHighResTimeStamp time);
+  void Notify();
+
+protected:
+  void Connect();
+  void QueueIntersectionObserverEntry(Element* aTarget,
+                                      DOMHighResTimeStamp time,
+                                      const Maybe<nsRect>& aRootRect,
+                                      const nsRect& aTargetRect,
+                                      const Maybe<nsRect>& aIntersectionRect,
+                                      double aIntersectionRatio);
+
+  nsCOMPtr<nsPIDOMWindowInner> mOwner;
+  RefPtr<nsIDocument> mDocument;
+  RefPtr<mozilla::dom::IntersectionCallback> mCallback;
+  RefPtr<Element> mRoot;
+  nsCSSRect mRootMargin;
+  nsTArray<double> mThresholds;
+  nsTHashtable<nsPtrHashKey<Element>> mObservationTargets;
+  nsTArray<RefPtr<DOMIntersectionObserverEntry>> mQueuedEntries;
+  bool mConnected;
+};
+
+template<typename T> struct DOMIntersectionObserver::COMTypeInfo<DOMIntersectionObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID DOMIntersectionObserver::COMTypeInfo<DOMIntersectionObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x8570a575, 0xe303, 0x4d18, { 0xb6, 0xb1, 0x4d, 0x2b, 0x49, 0xd8, 0xef, 0x94 } };
+
+}
+}
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
+
+class mozAutoDocUpdate;
+class nsIFrame;
+class nsIDOMMozNamedAttrMap;
+class nsIMozBrowserFrame;
+class nsIURI;
+class nsIScrollableFrame;
+class nsAttrValueOrString;
+class nsContentList;
+class nsDOMTokenList;
+struct nsRect;
+class nsFocusManager;
+class nsGlobalWindow;
+class nsICSSDeclaration;
+class nsISMILAttr;
+class nsDocument;
+class nsDOMStringMap;
+
+namespace mozilla {
+class DeclarationBlock;
+namespace dom {
+  struct AnimationFilter;
+  struct ScrollIntoViewOptions;
+  struct ScrollToOptions;
+  class DOMIntersectionObserver;
+  class ElementOrCSSPseudoElement;
+  class UnrestrictedDoubleOrKeyframeAnimationOptions;
+  enum class CallerType : uint32_t;
+}
+}
+
+
+already_AddRefed<nsContentList>
+NS_GetContentList(nsINode* aRootNode,
+                  int32_t aMatchNameSpaceId,
+                  const nsAString& aTagname);
+
+
+
+
+enum {
+
+  ELEMENT_HAS_PENDING_RESTYLE = NODE_SHARED_RESTYLE_BIT_1,
+
+
+
+
+  ELEMENT_IS_POTENTIAL_RESTYLE_ROOT = NODE_SHARED_RESTYLE_BIT_2,
+
+
+
+
+
+  ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (0)))),
+
+
+
+
+  ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (1)))),
+
+
+
+  ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (2)))),
+
+
+  ELEMENT_PENDING_RESTYLE_FLAGS =
+    ELEMENT_HAS_PENDING_RESTYLE |
+    ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE,
+
+
+  ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS =
+    ELEMENT_IS_POTENTIAL_RESTYLE_ROOT |
+    ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT,
+
+
+  ELEMENT_ALL_RESTYLE_FLAGS = ELEMENT_PENDING_RESTYLE_FLAGS |
+                              ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS |
+                              ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR,
+
+
+  ELEMENT_HAS_SCROLLGRAB = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (3)))),
+
+
+  ELEMENT_TYPE_SPECIFIC_BITS_OFFSET = NODE_TYPE_SPECIFIC_BITS_OFFSET + 4
+};
+
+
+
+
+static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (ELEMENT_TYPE_SPECIFIC_BITS_OFFSET) <= sizeof(nsWrapperCache::FlagsType) * 8, "Not enough space for our bits");
+
+namespace mozilla {
+enum class CSSPseudoElementType : uint8_t;
+class EventChainPostVisitor;
+class EventChainPreVisitor;
+class EventChainVisitor;
+class EventListenerManager;
+class EventStateManager;
+
+namespace dom {
+
+class Animation;
+class CustomElementRegistry;
+class Link;
+class DOMRect;
+class DOMRectList;
+class DestinationInsertionPointList;
+class Grid;
+
+
+
+
+
+
+class Element : public FragmentOrElement
+{
+public:
+
+  explicit Element(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo) :
+    FragmentOrElement(aNodeInfo),
+    mState((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 29)))
+  {
+    do { } while (0);
+
+    SetIsElement();
+  }
+
+  ~Element()
+  {
+
+    do { } while(0);
+
+  }
+
+
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override;
+
+
+
+
+
+  EventStates State() const
+  {
+
+
+    return mState;
+  }
+# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  void UpdateState(bool aNotify);
+
+
+
+
+  void UpdateLinkState(EventStates aState);
+
+  virtual int32_t TabIndexDefault()
+  {
+    return -1;
+  }
+
+
+
+
+  int32_t TabIndex();
+
+
+
+
+  void SetTabIndex(int32_t aTabIndex, mozilla::ErrorResult& aError);
+
+
+
+
+  virtual void Focus(mozilla::ErrorResult& aError);
+
+
+
+
+  virtual void Blur(mozilla::ErrorResult& aError);
+
+
+
+
+
+  EventStates StyleState() const
+  {
+    if (!HasLockedStyleStates()) {
+      return mState;
+    }
+    return StyleStateFromLocks();
+  }
+
+
+
+
+
+  struct StyleStateLocks {
+
+    EventStates mLocks;
+
+    EventStates mValues;
+  };
+
+
+
+
+  StyleStateLocks LockedStyleStates() const;
+
+
+
+
+
+  void LockStyleStates(EventStates aStates, bool aEnabled);
+
+
+
+
+  void UnlockStyleStates(EventStates aStates);
+
+
+
+
+  void ClearStyleStateLocks();
+
+
+
+
+  DeclarationBlock* GetInlineStyleDeclaration() const;
+
+
+
+
+  const nsMappedAttributes* GetMappedAttributes() const;
+
+  void ClearMappedServoStyle() {
+    mAttrsAndChildren.ClearMappedServoStyle();
+  }
+
+
+
+
+
+  virtual nsresult SetInlineStyleDeclaration(DeclarationBlock* aDeclaration,
+                                             const nsAString* aSerialized,
+                                             bool aNotify);
+
+
+
+
+
+  virtual DeclarationBlock* GetSMILOverrideStyleDeclaration();
+
+
+
+
+
+
+  virtual nsresult SetSMILOverrideStyleDeclaration(
+    DeclarationBlock* aDeclaration, bool aNotify);
+
+
+
+
+
+  virtual UniquePtr<nsISMILAttr> GetAnimatedAttr(int32_t aNamespaceID,
+                                                 nsIAtom* aName)
+  {
+    return nullptr;
+  }
+# 336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual nsICSSDeclaration* GetSMILOverrideStyle();
+
+
+
+
+  virtual bool IsLabelable() const;
+
+
+
+
+  virtual bool IsInteractiveHTMLContent(bool aIgnoreTabindex) const;
+# 356 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual nsIMozBrowserFrame* GetAsMozBrowserFrame() { return nullptr; }
+# 365 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual bool IsAttributeMapped(const nsIAtom* aAttribute) const;
+
+
+
+
+
+
+
+  virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
+                                              int32_t aModType) const;
+
+  inline Directionality GetDirectionality() const {
+    if (HasFlag(NODE_HAS_DIRECTION_RTL)) {
+      return eDir_RTL;
+    }
+
+    if (HasFlag(NODE_HAS_DIRECTION_LTR)) {
+      return eDir_LTR;
+    }
+
+    return eDir_NotSet;
+  }
+
+  inline void SetDirectionality(Directionality aDir, bool aNotify) {
+    UnsetFlags(NODE_ALL_DIRECTION_FLAGS);
+    if (!aNotify) {
+      RemoveStatesSilently(((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 44)) | (mozilla::EventStates(mozilla::EventStates::InternalType(1) << 45))));
+    }
+
+    switch (aDir) {
+      case (eDir_RTL):
+        SetFlags(NODE_HAS_DIRECTION_RTL);
+        if (!aNotify) {
+          AddStatesSilently((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 45)));
+        }
+        break;
+
+      case(eDir_LTR):
+        SetFlags(NODE_HAS_DIRECTION_LTR);
+        if (!aNotify) {
+          AddStatesSilently((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 44)));
+        }
+        break;
+
+      default:
+        break;
+    }
+
+
+
+
+
+
+    if (aNotify) {
+      UpdateState(true);
+    }
+  }
+
+  bool GetBindingURL(nsIDocument* aDocument, css::URLValue **aResult);
+
+
+
+
+
+  inline bool HasDirAuto() const {
+    return (!HasFixedDir() &&
+            (HasValidDir() || IsHTMLElement(nsGkAtoms::bdi)));
+  }
+
+  Directionality GetComputedDirectionality() const;
+
+  inline Element* GetFlattenedTreeParentElement() const;
+  inline Element* GetFlattenedTreeParentElementForStyle() const;
+
+  bool HasDirtyDescendantsForServo() const
+  {
+    do { } while (0);
+    return HasFlag(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
+  }
+
+  void SetHasDirtyDescendantsForServo() {
+    do { } while (0);
+    SetFlags(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
+  }
+
+  void UnsetHasDirtyDescendantsForServo() {
+    do { } while (0);
+    UnsetFlags(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
+  }
+
+  inline void NoteDirtyDescendantsForServo();
+
+
+
+
+
+  bool HasServoData() const {
+
+    return !!mServoData.Get();
+
+
+
+  }
+
+  void ClearServoData();
+
+
+
+
+
+
+
+  inline CustomElementData* GetCustomElementData() const
+  {
+    nsDOMSlots *slots = GetExistingDOMSlots();
+    if (slots) {
+      return slots->mCustomElementData;
+    }
+    return nullptr;
+  }
+
+
+
+
+
+
+
+  void SetCustomElementData(CustomElementData* aData);
+
+protected:
+
+
+
+
+
+
+  virtual EventStates IntrinsicState() const;
+
+
+
+
+
+
+
+  void AddStatesSilently(EventStates aStates)
+  {
+    mState |= aStates;
+  }
+
+
+
+
+
+
+
+  void RemoveStatesSilently(EventStates aStates)
+  {
+    mState &= ~aStates;
+  }
+
+private:
+
+
+  friend class mozilla::EventStateManager;
+  friend class ::nsGlobalWindow;
+  friend class ::nsFocusManager;
+
+
+  friend class CustomElementRegistry;
+
+
+  friend class Link;
+
+  void NotifyStateChange(EventStates aStates);
+
+  void NotifyStyleStateChange(EventStates aStates);
+
+
+  EventStates StyleStateFromLocks() const;
+
+protected:
+
+
+
+
+  virtual void AddStates(EventStates aStates)
+  {
+    do { } while(0);
+
+    AddStatesSilently(aStates);
+    NotifyStateChange(aStates);
+  }
+  virtual void RemoveStates(EventStates aStates)
+  {
+    do { } while(0);
+
+    RemoveStatesSilently(aStates);
+    NotifyStateChange(aStates);
+  }
+public:
+
+  void AddManuallyManagedStates(EventStates aStates)
+  {
+    do { } while (0);
+
+    AddStates(aStates);
+  }
+  void RemoveManuallyManagedStates(EventStates aStates)
+  {
+    do { } while (0);
+
+    RemoveStates(aStates);
+  }
+
+  virtual void UpdateEditableState(bool aNotify) override;
+
+  virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+                              nsIContent* aBindingParent,
+                              bool aCompileEventHandlers) override;
+  virtual void UnbindFromTree(bool aDeep = true,
+                              bool aNullParent = true) override;
+# 597 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  already_AddRefed<mozilla::dom::NodeInfo>
+  GetExistingAttrNameFromQName(const nsAString& aStr) const;
+
+  nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                   const nsAString& aValue, bool aNotify)
+  {
+    return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
+  }
+# 622 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  bool MaybeCheckSameAttrVal(int32_t aNamespaceID, nsIAtom* aName,
+                             nsIAtom* aPrefix,
+                             const nsAttrValueOrString& aValue,
+                             bool aNotify, nsAttrValue& aOldValue,
+                             uint8_t* aModType, bool* aHasListeners);
+
+  bool OnlyNotifySameValueSet(int32_t aNamespaceID, nsIAtom* aName,
+                              nsIAtom* aPrefix,
+                              const nsAttrValueOrString& aValue,
+                              bool aNotify, nsAttrValue& aOldValue,
+                              uint8_t* aModType, bool* aHasListeners);
+
+  virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
+                           const nsAString& aValue, bool aNotify) override;
+
+
+  nsresult SetParsedAttr(int32_t aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
+                         nsAttrValue& aParsedValue, bool aNotify);
+
+
+  bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+               nsAString& aResult) const;
+  inline bool HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const;
+
+  inline bool AttrValueIs(int32_t aNameSpaceID, nsIAtom* aName,
+                          const nsAString& aValue,
+                          nsCaseTreatment aCaseSensitive) const;
+  inline bool AttrValueIs(int32_t aNameSpaceID, nsIAtom* aName,
+                          nsIAtom* aValue,
+                          nsCaseTreatment aCaseSensitive) const;
+  virtual int32_t FindAttrValueIn(int32_t aNameSpaceID,
+                                  nsIAtom* aName,
+                                  AttrValuesArray* aValues,
+                                  nsCaseTreatment aCaseSensitive) const override;
+  virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
+                             bool aNotify) override;
+  virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const override;
+  virtual BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const override;
+  virtual uint32_t GetAttrCount() const override;
+  virtual bool IsNodeOfType(uint32_t aFlags) const override;
+
+
+
+
+
+
+  const nsAttrValue* GetClasses() const {
+    if (MayHaveClass()) {
+      return DoGetClasses();
+    }
+    return nullptr;
+  }
+# 685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  void Describe(nsAString& aOutDescription) const override;
+
+
+
+
+  struct MappedAttributeEntry {
+    nsIAtom** attribute;
+  };
+
+
+
+
+
+
+
+  template<size_t N>
+  static bool
+  FindAttributeDependence(const nsIAtom* aAttribute,
+                          const MappedAttributeEntry* const (&aMaps)[N])
+  {
+    return FindAttributeDependence(aAttribute, aMaps, N);
+  }
+
+  static nsIAtom*** HTMLSVGPropertiesToTraverseAndUnlink();
+
+private:
+  void DescribeAttribute(uint32_t index, nsAString& aOutDescription) const;
+
+  static bool
+  FindAttributeDependence(const nsIAtom* aAttribute,
+                          const MappedAttributeEntry* const aMaps[],
+                          uint32_t aMapCount);
+
+protected:
+  inline bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                      DOMString& aResult) const
+  {
+    do { } while(0);
+    do { } while(0);
+
+    do { } while (0);
+
+    const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
+    if (val) {
+      val->ToString(aResult);
+      return true;
+    }
+
+    return false;
+  }
+
+public:
+  bool HasAttrs() const { return mAttrsAndChildren.HasAttrs(); }
+
+  inline bool GetAttr(const nsAString& aName, DOMString& aResult) const
+  {
+    do { } while (0);
+
+    const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName);
+    if (val) {
+      val->ToString(aResult);
+      return true;
+    }
+
+    return false;
+  }
+
+  void GetTagName(nsAString& aTagName) const
+  {
+    aTagName = NodeName();
+  }
+  void GetId(nsAString& aId) const
+  {
+    GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
+  }
+  void GetId(DOMString& aId) const
+  {
+    GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
+  }
+  void SetId(const nsAString& aId)
+  {
+    SetAttr(kNameSpaceID_None, nsGkAtoms::id, aId, true);
+  }
+  void GetClassName(nsAString& aClassName)
+  {
+    GetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName);
+  }
+  void GetClassName(DOMString& aClassName)
+  {
+    GetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName);
+  }
+  void SetClassName(const nsAString& aClassName)
+  {
+    SetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName, true);
+  }
+
+  nsDOMTokenList* ClassList();
+  nsDOMAttributeMap* Attributes()
+  {
+    nsDOMSlots* slots = DOMSlots();
+    if (!slots->mAttributeMap) {
+      slots->mAttributeMap = new nsDOMAttributeMap(this);
+    }
+
+    return slots->mAttributeMap;
+  }
+
+  void GetAttributeNames(nsTArray<nsString>& aResult);
+
+  void GetAttribute(const nsAString& aName, nsString& aReturn)
+  {
+    DOMString str;
+    GetAttribute(aName, str);
+    str.ToString(aReturn);
+  }
+
+  void GetAttribute(const nsAString& aName, DOMString& aReturn);
+  void GetAttributeNS(const nsAString& aNamespaceURI,
+                      const nsAString& aLocalName,
+                      nsAString& aReturn);
+  void SetAttribute(const nsAString& aName, const nsAString& aValue,
+                    ErrorResult& aError);
+  void SetAttributeNS(const nsAString& aNamespaceURI,
+                      const nsAString& aLocalName,
+                      const nsAString& aValue,
+                      ErrorResult& aError);
+  void RemoveAttribute(const nsAString& aName,
+                       ErrorResult& aError);
+  void RemoveAttributeNS(const nsAString& aNamespaceURI,
+                         const nsAString& aLocalName,
+                         ErrorResult& aError);
+  bool HasAttribute(const nsAString& aName) const
+  {
+    return InternalGetAttrNameFromQName(aName) != nullptr;
+  }
+  bool HasAttributeNS(const nsAString& aNamespaceURI,
+                      const nsAString& aLocalName) const;
+  bool HasAttributes() const
+  {
+    return HasAttrs();
+  }
+  Element* Closest(const nsAString& aSelector,
+                   ErrorResult& aResult);
+  bool Matches(const nsAString& aSelector,
+               ErrorResult& aError);
+  already_AddRefed<nsIHTMLCollection>
+    GetElementsByTagName(const nsAString& aQualifiedName);
+  already_AddRefed<nsIHTMLCollection>
+    GetElementsByTagNameNS(const nsAString& aNamespaceURI,
+                           const nsAString& aLocalName,
+                           ErrorResult& aError);
+  already_AddRefed<nsIHTMLCollection>
+    GetElementsByClassName(const nsAString& aClassNames);
+
+  CSSPseudoElementType GetPseudoElementType() const {
+    if (!HasProperties()) {
+      return CSSPseudoElementType::NotPseudo;
+    }
+    nsresult rv = NS_OK;
+    auto raw = GetProperty(nsGkAtoms::pseudoProperty, &rv);
+    if (rv == NS_PROPTABLE_PROP_NOT_THERE) {
+      return CSSPseudoElementType::NotPseudo;
+    }
+    return CSSPseudoElementType(reinterpret_cast<uintptr_t>(raw));
+  }
+
+  void SetPseudoElementType(CSSPseudoElementType aPseudo) {
+    static_assert(sizeof(CSSPseudoElementType) <= sizeof(uintptr_t),
+                  "Need to be able to store this in a void*");
+    do { } while (0);
+    SetProperty(nsGkAtoms::pseudoProperty, reinterpret_cast<void*>(aPseudo));
+  }
+
+private:
+
+
+
+
+
+  nsINode* InsertAdjacent(const nsAString& aWhere,
+                          nsINode* aNode,
+                          ErrorResult& aError);
+
+public:
+  Element* InsertAdjacentElement(const nsAString& aWhere,
+                                 Element& aElement,
+                                 ErrorResult& aError);
+
+  void InsertAdjacentText(const nsAString& aWhere,
+                          const nsAString& aData,
+                          ErrorResult& aError);
+
+  void SetPointerCapture(int32_t aPointerId, ErrorResult& aError)
+  {
+    bool activeState = false;
+    if (!nsIPresShell::GetPointerInfo(aPointerId, activeState)) {
+      aError.Throw(NS_ERROR_DOM_INVALID_POINTER_ERR);
+      return;
+    }
+    if (!IsInUncomposedDoc()) {
+      aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+      return;
+    }
+    if (!activeState) {
+      return;
+    }
+    nsIPresShell::SetPointerCapturingContent(aPointerId, this);
+  }
+  void ReleasePointerCapture(int32_t aPointerId, ErrorResult& aError)
+  {
+    bool activeState = false;
+    if (!nsIPresShell::GetPointerInfo(aPointerId, activeState)) {
+      aError.Throw(NS_ERROR_DOM_INVALID_POINTER_ERR);
+      return;
+    }
+    if (HasPointerCapture(aPointerId)) {
+      nsIPresShell::ReleasePointerCapturingContent(aPointerId);
+    }
+  }
+  bool HasPointerCapture(long aPointerId)
+  {
+    nsIPresShell::PointerCaptureInfo* pointerCaptureInfo =
+      nsIPresShell::GetPointerCaptureInfo(aPointerId);
+    if (pointerCaptureInfo && pointerCaptureInfo->mPendingContent == this) {
+      return true;
+    }
+    return false;
+  }
+  void SetCapture(bool aRetargetToElement)
+  {
+
+
+
+    if (!nsIPresShell::GetCapturingContent()) {
+      nsIPresShell::SetCapturingContent(this, 4 |
+        (aRetargetToElement ? 2 : 0));
+    }
+  }
+
+  void SetCaptureAlways(bool aRetargetToElement)
+  {
+    nsIPresShell::SetCapturingContent(this,
+        4 | 1 |
+        (aRetargetToElement ? 2 : 0));
+  }
+
+  void ReleaseCapture()
+  {
+    if (nsIPresShell::GetCapturingContent() == this) {
+      nsIPresShell::SetCapturingContent(nullptr, 0);
+    }
+  }
+
+  void RequestFullscreen(CallerType aCallerType, ErrorResult& aError);
+  void RequestPointerLock(CallerType aCallerType);
+  Attr* GetAttributeNode(const nsAString& aName);
+  already_AddRefed<Attr> SetAttributeNode(Attr& aNewAttr,
+                                          ErrorResult& aError);
+  already_AddRefed<Attr> RemoveAttributeNode(Attr& aOldAttr,
+                                             ErrorResult& aError);
+  Attr* GetAttributeNodeNS(const nsAString& aNamespaceURI,
+                           const nsAString& aLocalName);
+  already_AddRefed<Attr> SetAttributeNodeNS(Attr& aNewAttr,
+                                            ErrorResult& aError);
+
+  already_AddRefed<DOMRectList> GetClientRects();
+  already_AddRefed<DOMRect> GetBoundingClientRect();
+
+  already_AddRefed<ShadowRoot> CreateShadowRoot(ErrorResult& aError);
+  already_AddRefed<DestinationInsertionPointList> GetDestinationInsertionPoints();
+
+  ShadowRoot *FastGetShadowRoot() const
+  {
+    nsDOMSlots* slots = GetExistingDOMSlots();
+    return slots ? slots->mShadowRoot.get() : nullptr;
+  }
+
+  void ScrollIntoView();
+  void ScrollIntoView(bool aTop);
+  void ScrollIntoView(const ScrollIntoViewOptions &aOptions);
+  void Scroll(double aXScroll, double aYScroll);
+  void Scroll(const ScrollToOptions& aOptions);
+  void ScrollTo(double aXScroll, double aYScroll);
+  void ScrollTo(const ScrollToOptions& aOptions);
+  void ScrollBy(double aXScrollDif, double aYScrollDif);
+  void ScrollBy(const ScrollToOptions& aOptions);
+
+
+
+
+  bool ScrollByNoFlush(int32_t aDx, int32_t aDy);
+  int32_t ScrollTop();
+  void SetScrollTop(int32_t aScrollTop);
+  int32_t ScrollLeft();
+  void SetScrollLeft(int32_t aScrollLeft);
+  int32_t ScrollWidth();
+  int32_t ScrollHeight();
+  void MozScrollSnap();
+  int32_t ClientTop()
+  {
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().y);
+  }
+  int32_t ClientLeft()
+  {
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().x);
+  }
+  int32_t ClientWidth()
+  {
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().width);
+  }
+  int32_t ClientHeight()
+  {
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().height);
+  }
+  int32_t ScrollTopMin()
+  {
+    nsIScrollableFrame* sf = GetScrollFrame();
+    return sf ?
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().y) : 0;
+  }
+  int32_t ScrollTopMax()
+  {
+    nsIScrollableFrame* sf = GetScrollFrame();
+    return sf ?
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().YMost()) :
+           0;
+  }
+  int32_t ScrollLeftMin()
+  {
+    nsIScrollableFrame* sf = GetScrollFrame();
+    return sf ?
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().x) : 0;
+  }
+  int32_t ScrollLeftMax()
+  {
+    nsIScrollableFrame* sf = GetScrollFrame();
+    return sf ?
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().XMost()) :
+           0;
+  }
+
+  void GetGridFragments(nsTArray<RefPtr<Grid>>& aResult);
+
+  already_AddRefed<Animation>
+  Animate(JSContext* aContext,
+          JS::Handle<JSObject*> aKeyframes,
+          const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
+          ErrorResult& aError);
+
+
+
+  static already_AddRefed<Animation>
+  Animate(const Nullable<ElementOrCSSPseudoElement>& aTarget,
+          JSContext* aContext,
+          JS::Handle<JSObject*> aKeyframes,
+          const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
+          ErrorResult& aError);
+
+
+
+
+  void GetAnimations(const AnimationFilter& filter,
+                     nsTArray<RefPtr<Animation>>& aAnimations);
+  static void GetAnimationsUnsorted(Element* aElement,
+                                    CSSPseudoElementType aPseudoType,
+                                    nsTArray<RefPtr<Animation>>& aAnimations);
+
+  virtual nsresult GetInnerHTML(nsAString& aInnerHTML);
+  virtual void SetInnerHTML(const nsAString& aInnerHTML, ErrorResult& aError);
+  void GetOuterHTML(nsAString& aOuterHTML);
+  void SetOuterHTML(const nsAString& aOuterHTML, ErrorResult& aError);
+  void InsertAdjacentHTML(const nsAString& aPosition, const nsAString& aText,
+                          ErrorResult& aError);
+# 1068 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  nsresult SetEventHandler(nsIAtom* aEventName,
+                           const nsAString& aValue,
+                           bool aDefer = true);
+
+
+
+
+  nsresult LeaveLink(nsPresContext* aPresContext);
+
+  static bool ShouldBlur(nsIContent *aContent);
+# 1089 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  static nsresult DispatchClickEvent(nsPresContext* aPresContext,
+                                     WidgetInputEvent* aSourceEvent,
+                                     nsIContent* aTarget,
+                                     bool aFullDispatch,
+                                     const EventFlags* aFlags,
+                                     nsEventStatus* aStatus);
+# 1103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  using nsIContent::DispatchEvent;
+  static nsresult DispatchEvent(nsPresContext* aPresContext,
+                                WidgetEvent* aEvent,
+                                nsIContent* aTarget,
+                                bool aFullDispatch,
+                                nsEventStatus* aStatus);
+# 1117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  nsIFrame* GetPrimaryFrame(FlushType aType);
+
+  nsIFrame* GetPrimaryFrame() const { return nsIContent::GetPrimaryFrame(); }
+
+  const nsAttrValue* GetParsedAttr(nsIAtom* aAttr) const
+  {
+    return mAttrsAndChildren.GetAttr(aAttr);
+  }
+
+  const nsAttrValue* GetParsedAttr(nsIAtom* aAttr, int32_t aNameSpaceID) const
+  {
+    return mAttrsAndChildren.GetAttr(aAttr, aNameSpaceID);
+  }
+
+
+
+
+
+
+  nsDOMAttributeMap *GetAttributeMap()
+  {
+    nsDOMSlots *slots = GetExistingDOMSlots();
+
+    return slots ? slots->mAttributeMap.get() : nullptr;
+  }
+
+  virtual void RecompileScriptEventListeners()
+  {
+  }
+# 1155 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual BorrowedAttrInfo GetAttrInfo(int32_t aNamespaceID, nsIAtom* aName) const;
+# 1166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual void NodeInfoChanged(nsIDocument* aOldDoc) {}
+
+
+
+
+
+
+  static void ParseCORSValue(const nsAString& aValue, nsAttrValue& aResult);
+
+
+
+
+  static CORSMode StringToCORSMode(const nsAString& aValue);
+
+
+
+
+
+  static CORSMode AttrValueToCORSMode(const nsAttrValue* aValue);
+
+  virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) final override;
+
+  nsINode* GetScopeChainParent() const override;
+
+
+
+
+  nsIEditor* GetEditorInternal();
+# 1203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  bool GetBoolAttr(nsIAtom* aAttr) const
+  {
+    return HasAttr(kNameSpaceID_None, aAttr);
+  }
+# 1216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  nsresult SetBoolAttr(nsIAtom* aAttr, bool aValue);
+# 1227 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  void GetEnumAttr(nsIAtom* aAttr,
+                   const char* aDefault,
+                   nsAString& aResult) const;
+# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  void GetEnumAttr(nsIAtom* aAttr,
+                   const char* aDefaultMissing,
+                   const char* aDefaultInvalid,
+                   nsAString& aResult) const;
+
+
+
+
+  void UnsetAttr(nsIAtom* aAttr, ErrorResult& aError)
+  {
+    aError = UnsetAttr(kNameSpaceID_None, aAttr, true);
+  }
+
+
+
+
+  void SetAttr(nsIAtom* aAttr, const nsAString& aValue, ErrorResult& aError)
+  {
+    aError = SetAttr(kNameSpaceID_None, aAttr, aValue, true);
+  }
+
+
+
+
+
+
+  void SetOrRemoveNullableStringAttr(nsIAtom* aName, const nsAString& aValue,
+                                     ErrorResult& aError);
+# 1288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  float FontSizeInflation();
+
+  net::ReferrerPolicy GetReferrerPolicyAsEnum();
+
+
+
+
+
+
+  already_AddRefed<nsDOMStringMap> Dataset();
+
+
+  void ClearDataset();
+
+  void RegisterIntersectionObserver(DOMIntersectionObserver* aObserver);
+  void UnregisterIntersectionObserver(DOMIntersectionObserver* aObserver);
+  bool UpdateIntersectionObservation(DOMIntersectionObserver* aObserver, int32_t threshold);
+
+protected:
+
+
+
+
+  static const bool kFireMutationEvent = true;
+  static const bool kDontFireMutationEvent = false;
+  static const bool kNotifyDocumentObservers = true;
+  static const bool kDontNotifyDocumentObservers = false;
+  static const bool kCallAfterSetAttr = true;
+  static const bool kDontCallAfterSetAttr = false;
+# 1347 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  nsresult SetAttrAndNotify(int32_t aNamespaceID,
+                            nsIAtom* aName,
+                            nsIAtom* aPrefix,
+                            const nsAttrValue& aOldValue,
+                            nsAttrValue& aParsedValue,
+                            uint8_t aModType,
+                            bool aFireMutation,
+                            bool aNotify,
+                            bool aCallAfterSetAttr,
+                            nsIDocument* aComposedDocument,
+                            const mozAutoDocUpdate& aGuard);
+# 1368 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  void Scroll(const CSSIntPoint& aScroll, const ScrollOptions& aOptions);
+# 1381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual bool ParseAttribute(int32_t aNamespaceID,
+                                nsIAtom* aAttribute,
+                                const nsAString& aValue,
+                                nsAttrValue& aResult);
+# 1399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual bool SetMappedAttribute(nsIDocument* aDocument,
+                                    nsIAtom* aName,
+                                    nsAttrValue& aValue,
+                                    nsresult* aRetval);
+# 1420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+                                 const nsAttrValueOrString* aValue,
+                                 bool aNotify)
+  {
+    return NS_OK;
+  }
+# 1441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+                                const nsAttrValue* aValue, bool aNotify)
+  {
+    return NS_OK;
+  }
+
+
+
+
+
+  virtual EventListenerManager*
+    GetEventListenerManagerForAttr(nsIAtom* aAttrName, bool* aDefer);
+
+
+
+
+
+
+  const nsAttrName*
+  InternalGetAttrNameFromQName(const nsAString& aStr,
+                               nsAutoString* aNameToUse = nullptr) const;
+
+  nsIFrame* GetStyledFrame();
+
+  virtual Element* GetNameSpaceElement() override
+  {
+    return this;
+  }
+
+  Attr* GetAttributeNodeNSInternal(const nsAString& aNamespaceURI,
+                                   const nsAString& aLocalName);
+
+  inline void RegisterActivityObserver();
+  inline void UnregisterActivityObserver();
+
+
+
+
+  void AddToIdTable(nsIAtom* aId);
+  void RemoveFromIdTable();
+# 1495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  bool CheckHandleEventForLinksPrecondition(EventChainVisitor& aVisitor,
+                                            nsIURI** aURI) const;
+
+
+
+
+  nsresult GetEventTargetParentForLinks(EventChainPreVisitor& aVisitor);
+
+
+
+
+  nsresult PostHandleEventForLinks(EventChainPostVisitor& aVisitor);
+# 1518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
+  virtual void GetLinkTarget(nsAString& aTarget);
+
+  nsDOMTokenList* GetTokenList(nsIAtom* aAtom,
+                               const DOMTokenListSupportedTokenArray aSupportedTokens = nullptr);
+
+  nsDataHashtable<nsRefPtrHashKey<DOMIntersectionObserver>, int32_t>*
+    RegisteredIntersectionObservers();
+
+private:
+
+
+
+
+  const nsAttrValue* DoGetClasses() const;
+
+
+
+
+
+  nsRect GetClientAreaRect();
+
+  nsIScrollableFrame* GetScrollFrame(nsIFrame **aStyledFrame = nullptr,
+                                     bool aFlushLayout = true);
+
+
+  EventStates mState;
+
+
+  mozilla::ServoCell<ServoNodeData*> mServoData;
+
+};
+
+class RemoveFromBindingManagerRunnable : public mozilla::Runnable
+{
+public:
+  RemoveFromBindingManagerRunnable(nsBindingManager* aManager,
+                                   nsIContent* aContent,
+                                   nsIDocument* aDoc);
+
+  virtual nsresult Run() override;
+private:
+  virtual ~RemoveFromBindingManagerRunnable();
+  RefPtr<nsBindingManager> mManager;
+  RefPtr<nsIContent> mContent;
+  nsCOMPtr<nsIDocument> mDoc;
+};
+
+class DestinationInsertionPointList : public nsINodeList
+{
+public:
+  explicit DestinationInsertionPointList(Element* aElement);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DestinationInsertionPointList"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DestinationInsertionPointList>(p)->DeleteCycleCollectable(); } static DestinationInsertionPointList* Downcast(nsISupports* s) { return static_cast<DestinationInsertionPointList*>(static_cast<DestinationInsertionPointList*>(s)); } static nsISupports* Upcast(DestinationInsertionPointList *p) { return static_cast<nsISupports*>(static_cast<DestinationInsertionPointList*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DestinationInsertionPointList::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+
+  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) override; virtual nsresult GetLength(uint32_t *aLength) override;
+
+
+  virtual nsIContent* Item(uint32_t aIndex) override;
+  virtual int32_t IndexOf(nsIContent* aContent) override;
+  virtual nsINode* GetParentObject() override { return mParent; }
+  virtual uint32_t Length() const;
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+protected:
+  virtual ~DestinationInsertionPointList();
+
+  RefPtr<Element> mParent;
+  nsCOMArray<nsIContent> mDestinationPoints;
+};
+
+template<typename T> struct Element::COMTypeInfo<Element, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID Element::COMTypeInfo<Element, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc67ed254, 0xfd3b, 0x4b10, { 0x96, 0xa2, 0xc5, 0x8b, 0x7b, 0x64, 0x97, 0xd1 } };
+
+inline bool
+Element::HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const
+{
+  do { } while(0);
+  do { } while(0);
+
+
+  return mAttrsAndChildren.IndexOfAttr(aName, aNameSpaceID) >= 0;
+}
+
+inline bool
+Element::AttrValueIs(int32_t aNameSpaceID,
+                     nsIAtom* aName,
+                     const nsAString& aValue,
+                     nsCaseTreatment aCaseSensitive) const
+{
+  do { } while(0);
+  do { } while(0);
+
+  const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
+  return val && val->Equals(aValue, aCaseSensitive);
+}
+
+inline bool
+Element::AttrValueIs(int32_t aNameSpaceID,
+                     nsIAtom* aName,
+                     nsIAtom* aValue,
+                     nsCaseTreatment aCaseSensitive) const
+{
+  do { } while(0);
+  do { } while(0);
+  do { } while(0);
+
+  const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
+  return val && val->Equals(aValue, aCaseSensitive);
+}
+
+}
+}
+
+inline mozilla::dom::Element* nsINode::AsElement()
+{
+  do { } while (0);
+  return static_cast<mozilla::dom::Element*>(this);
+}
+
+inline const mozilla::dom::Element* nsINode::AsElement() const
+{
+  do { } while (0);
+  return static_cast<const mozilla::dom::Element*>(this);
+}
+
+inline void nsINode::UnsetRestyleFlagsIfGecko()
+{
+  if (IsElement() && !AsElement()->IsStyledByServo()) {
+    UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS);
+  }
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AnimationTarget.h" 1
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AnimationTarget.h"
+namespace mozilla {
+
+namespace dom {
+class Element;
+}
+
+struct OwningAnimationTarget
+{
+  OwningAnimationTarget(dom::Element* aElement, CSSPseudoElementType aType)
+    : mElement(aElement), mPseudoType(aType) { }
+
+  explicit OwningAnimationTarget(dom::Element* aElement)
+    : mElement(aElement) { }
+
+  bool operator==(const OwningAnimationTarget& aOther) const
+  {
+     return mElement == aOther.mElement &&
+            mPseudoType == aOther.mPseudoType;
+  }
+
+
+
+  RefPtr<dom::Element> mElement;
+  CSSPseudoElementType mPseudoType = CSSPseudoElementType::NotPseudo;
+};
+
+struct NonOwningAnimationTarget
+{
+  NonOwningAnimationTarget() = default;
+
+  NonOwningAnimationTarget(dom::Element* aElement, CSSPseudoElementType aType)
+    : mElement(aElement), mPseudoType(aType) { }
+
+  explicit NonOwningAnimationTarget(const OwningAnimationTarget& aOther)
+    : mElement(aOther.mElement), mPseudoType(aOther.mPseudoType) { }
+
+  bool operator==(const NonOwningAnimationTarget& aOther) const
+  {
+    return mElement == aOther.mElement &&
+           mPseudoType == aOther.mPseudoType;
+  }
+
+
+
+  dom::Element* mElement = nullptr;
+  CSSPseudoElementType mPseudoType = CSSPseudoElementType::NotPseudo;
+};
+
+
+
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            Maybe<OwningAnimationTarget>& aTarget,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  if (aTarget) {
+    ImplCycleCollectionTraverse(aCallback, aTarget->mElement, aName, aFlags);
+  }
+}
+
+inline void
+ImplCycleCollectionUnlink(Maybe<OwningAnimationTarget>& aTarget)
+{
+  if (aTarget) {
+    ImplCycleCollectionUnlink(aTarget->mElement);
+  }
+}
+
+}
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 2
+
+
+
+namespace mozilla {
+
+
+class PseudoElementHashEntry : public PLDHashEntryHdr
+{
+public:
+  typedef NonOwningAnimationTarget KeyType;
+  typedef const NonOwningAnimationTarget* KeyTypePointer;
+
+  explicit PseudoElementHashEntry(KeyTypePointer aKey)
+    : mElement(aKey->mElement)
+    , mPseudoType(aKey->mPseudoType) { }
+  explicit PseudoElementHashEntry(const PseudoElementHashEntry& aCopy)=default;
+
+  ~PseudoElementHashEntry() = default;
+
+  KeyType GetKey() const { return { mElement, mPseudoType }; }
+  bool KeyEquals(KeyTypePointer aKey) const
+  {
+    return mElement == aKey->mElement &&
+           mPseudoType == aKey->mPseudoType;
+  }
+
+  static KeyTypePointer KeyToPointer(KeyType& aKey) { return &aKey; }
+  static PLDHashNumber HashKey(KeyTypePointer aKey)
+  {
+    if (!aKey)
+      return 0;
+
+
+
+
+    return mozilla::HashGeneric(aKey->mElement,
+                                static_cast<uint8_t>(aKey->mPseudoType));
+  }
+  enum { ALLOW_MEMMOVE = true };
+
+  RefPtr<dom::Element> mElement;
+  CSSPseudoElementType mPseudoType;
+};
+
+}
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 2
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
+struct RuleProcessorData;
+struct ElementRuleProcessorData;
+struct PseudoElementRuleProcessorData;
+struct AnonBoxRuleProcessorData;
+
+struct XULTreeRuleProcessorData;
+
+struct StateRuleProcessorData;
+struct PseudoElementStateRuleProcessorData;
+struct AttributeRuleProcessorData;
+class nsPresContext;
+# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
+class nsIStyleRuleProcessor : public nsISupports {
+public:
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+
+  typedef bool (* EnumFunc)(nsIStyleRuleProcessor*, void*);
+
+
+
+
+
+
+
+  virtual void RulesMatching(ElementRuleProcessorData* aData) = 0;
+
+
+
+
+
+  virtual void RulesMatching(PseudoElementRuleProcessorData* aData) = 0;
+
+
+
+
+  virtual void RulesMatching(AnonBoxRuleProcessorData* aData) = 0;
+
+
+
+
+
+
+  virtual void RulesMatching(XULTreeRuleProcessorData* aData) = 0;
+
+
+
+
+
+
+
+  virtual bool
+    HasDocumentStateDependentStyle(StateRuleProcessorData* aData) = 0;
+# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
+  virtual nsRestyleHint
+    HasStateDependentStyle(StateRuleProcessorData* aData) = 0;
+  virtual nsRestyleHint
+    HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData) = 0;
+# 118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
+  virtual nsRestyleHint HasAttributeDependentStyle(
+      AttributeRuleProcessorData* aData,
+      mozilla::RestyleHintData& aRestyleHintDataResult) = 0;
+
+
+
+
+
+
+  virtual bool MediumFeaturesChanged(nsPresContext* aPresContext) = 0;
+
+
+
+
+
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const = 0;
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const = 0;
+};
+
+template<typename T> struct nsIStyleRuleProcessor::COMTypeInfo<nsIStyleRuleProcessor, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStyleRuleProcessor::COMTypeInfo<nsIStyleRuleProcessor, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc1d6001e, 0x4fcb, 0x4c40, {0xbc, 0xe1, 0x5e, 0xba, 0x80, 0xbf, 0xd8, 0xf3} };
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 2
+
+
+class nsCSSPropertyIDSet;
+class nsIAtom;
+class nsIFrame;
+class nsIStyleRule;
+class nsPresContext;
+class nsStyleContext;
+struct RawServoAnimationValueMap;
+typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowed;
+
+namespace mozilla {
+
+class EffectSet;
+class RestyleTracker;
+class StyleAnimationValue;
+struct AnimationPerformanceWarning;
+struct AnimationProperty;
+struct NonOwningAnimationTarget;
+
+namespace dom {
+class Animation;
+class Element;
+}
+
+class EffectCompositor
+{
+public:
+  explicit EffectCompositor(nsPresContext* aPresContext)
+    : mPresContext(aPresContext)
+  {
+    for (size_t i = 0; i < kCascadeLevelCount; i++) {
+      CascadeLevel cascadeLevel = CascadeLevel(i);
+      mRuleProcessors[cascadeLevel] =
+        new AnimationStyleRuleProcessor(this, cascadeLevel);
+    }
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<EffectCompositor>::value, "Reference-counted class " "EffectCompositor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
+  void DeleteCycleCollectable(void) { delete this; } class cycleCollection : public nsCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsCycleCollectionParticipant(aSkip) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "EffectCompositor"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<EffectCompositor>(n)->DeleteCycleCollectable(); } static EffectCompositor* Downcast(void* s) { return DowncastCCParticipant<EffectCompositor>(s); } static void* Upcast(EffectCompositor *p) { return static_cast<void*>(p); } static constexpr nsCycleCollectionParticipant* GetParticipant() { return &EffectCompositor::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
+
+  void Disconnect() {
+    mPresContext = nullptr;
+  }
+
+
+  enum class CascadeLevel : uint32_t {
+
+
+    Animations = 0,
+
+    Transitions = 1
+  };
+
+
+  static const size_t kCascadeLevelCount =
+    static_cast<size_t>(CascadeLevel::Transitions) + 1;
+
+
+  nsPresContext* PresContext() const { return mPresContext; }
+
+  enum class RestyleType {
+
+
+
+    Throttled,
+
+    Standard,
+
+
+
+
+
+
+
+    Layer
+  };
+
+
+
+
+
+  void RequestRestyle(dom::Element* aElement,
+                      CSSPseudoElementType aPseudoType,
+                      RestyleType aRestyleType,
+                      CascadeLevel aCascadeLevel);
+
+
+
+
+
+  void PostRestyleForAnimation(dom::Element* aElement,
+                               CSSPseudoElementType aPseudoType,
+                               CascadeLevel aCascadeLevel);
+
+
+
+
+  void PostRestyleForThrottledAnimations();
+
+
+
+
+
+  template<typename StyleType>
+  void UpdateEffectProperties(StyleType&& aStyleType,
+                              dom::Element* aElement,
+                              CSSPseudoElementType aPseudoType);
+# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
+  void MaybeUpdateAnimationRule(dom::Element* aElement,
+                                CSSPseudoElementType aPseudoType,
+                                CascadeLevel aCascadeLevel,
+                                nsStyleContext *aStyleContext);
+# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
+  nsIStyleRule* GetAnimationRule(dom::Element* aElement,
+                                 CSSPseudoElementType aPseudoType,
+                                 CascadeLevel aCascadeLevel,
+                                 nsStyleContext* aStyleContext);
+
+
+
+
+
+
+  bool GetServoAnimationRule(
+    const dom::Element* aElement,
+    CSSPseudoElementType aPseudoType,
+    CascadeLevel aCascadeLevel,
+    RawServoAnimationValueMapBorrowed aAnimationValues);
+
+  bool HasPendingStyleUpdates() const;
+  bool HasThrottledStyleUpdates() const;
+
+
+
+
+  void AddStyleUpdatesTo(RestyleTracker& aTracker);
+
+  nsIStyleRuleProcessor* RuleProcessor(CascadeLevel aCascadeLevel) const
+  {
+    return mRuleProcessors[aCascadeLevel];
+  }
+
+  static bool HasAnimationsForCompositor(const nsIFrame* aFrame,
+                                         nsCSSPropertyID aProperty);
+
+  static nsTArray<RefPtr<dom::Animation>>
+  GetAnimationsForCompositor(const nsIFrame* aFrame,
+                             nsCSSPropertyID aProperty);
+
+  static void ClearIsRunningOnCompositor(const nsIFrame* aFrame,
+                                         nsCSSPropertyID aProperty);
+# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
+  static void
+  MaybeUpdateCascadeResults(dom::Element* aElement,
+                            CSSPseudoElementType aPseudoType,
+                            nsStyleContext* aStyleContext);
+
+
+
+
+
+  static void
+  MaybeUpdateCascadeResults(dom::Element* aElement,
+                            CSSPseudoElementType aPseudoType);
+
+
+
+
+
+
+
+  static void
+  UpdateCascadeResults(dom::Element* aElement,
+                       CSSPseudoElementType aPseudoType,
+                       nsStyleContext* aStyleContext);
+# 233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
+  static Maybe<NonOwningAnimationTarget>
+  GetAnimationElementAndPseudoForFrame(const nsIFrame* aFrame);
+
+
+
+  static void SetPerformanceWarning(
+    const nsIFrame* aFrame,
+    nsCSSPropertyID aProperty,
+    const AnimationPerformanceWarning& aWarning);
+
+
+
+
+
+  bool PreTraverse();
+
+
+  bool PreTraverse(dom::Element* aElement, nsIAtom* aPseudoTagOrNull);
+
+private:
+  ~EffectCompositor() = default;
+
+
+
+  static void ComposeAnimationRule(dom::Element* aElement,
+                                   CSSPseudoElementType aPseudoType,
+                                   CascadeLevel aCascadeLevel);
+
+  static dom::Element* GetElementToRestyle(dom::Element* aElement,
+                                           CSSPseudoElementType
+                                             aPseudoType);
+
+
+
+
+  static void
+  GetOverriddenProperties(nsStyleContext* aStyleContext,
+                          EffectSet& aEffectSet,
+                          nsCSSPropertyIDSet& aPropertiesOverridden);
+
+  static void
+  UpdateCascadeResults(EffectSet& aEffectSet,
+                       dom::Element* aElement,
+                       CSSPseudoElementType aPseudoType,
+                       nsStyleContext* aStyleContext);
+
+  static nsPresContext* GetPresContext(dom::Element* aElement);
+
+  nsPresContext* mPresContext;
+
+
+
+
+
+
+  EnumeratedArray<CascadeLevel, CascadeLevel(kCascadeLevelCount),
+                  nsDataHashtable<PseudoElementHashEntry, bool>>
+                    mElementsToRestyle;
+
+  class AnimationStyleRuleProcessor final : public nsIStyleRuleProcessor
+  {
+  public:
+    AnimationStyleRuleProcessor(EffectCompositor* aCompositor,
+                                CascadeLevel aCascadeLevel)
+      : mCompositor(aCompositor)
+      , mCascadeLevel(aCascadeLevel)
+    {
+      do { } while (0);
+    }
+
+    public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+
+    nsRestyleHint HasStateDependentStyle(
+                        StateRuleProcessorData* aData) override;
+    nsRestyleHint HasStateDependentStyle(
+                        PseudoElementStateRuleProcessorData* aData) override;
+    bool HasDocumentStateDependentStyle(StateRuleProcessorData* aData) override;
+    nsRestyleHint HasAttributeDependentStyle(
+                        AttributeRuleProcessorData* aData,
+                        RestyleHintData& aRestyleHintDataResult) override;
+    bool MediumFeaturesChanged(nsPresContext* aPresContext) override;
+    void RulesMatching(ElementRuleProcessorData* aData) override;
+    void RulesMatching(PseudoElementRuleProcessorData* aData) override;
+    void RulesMatching(AnonBoxRuleProcessorData* aData) override;
+
+    void RulesMatching(XULTreeRuleProcessorData* aData) override;
+
+    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf)
+      const override;
+    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf)
+      const override;
+
+  private:
+    ~AnimationStyleRuleProcessor() = default;
+
+    EffectCompositor* mCompositor;
+    CascadeLevel mCascadeLevel;
+  };
+
+  EnumeratedArray<CascadeLevel, CascadeLevel(kCascadeLevelCount),
+                  OwningNonNull<AnimationStyleRuleProcessor>>
+                    mRuleProcessors;
+};
+
+}
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSMILKeySpline.h" 1
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSMILKeySpline.h"
+class nsSMILKeySpline
+{
+public:
+  nsSMILKeySpline() { }
+
+
+
+
+
+
+
+  nsSMILKeySpline(double aX1, double aY1,
+                  double aX2, double aY2)
+  {
+    Init(aX1, aY1, aX2, aY2);
+  }
+
+  double X1() const { return mX1; }
+  double Y1() const { return mY1; }
+  double X2() const { return mX2; }
+  double Y2() const { return mY2; }
+
+  void Init(double aX1, double aY1,
+            double aX2, double aY2);
+
+
+
+
+
+
+
+  double GetSplineValue(double aX) const;
+
+  void GetSplineDerivativeValues(double aX, double& aDX, double& aDY) const;
+
+  bool operator==(const nsSMILKeySpline& aOther) const {
+    return mX1 == aOther.mX1 &&
+           mY1 == aOther.mY1 &&
+           mX2 == aOther.mX2 &&
+           mY2 == aOther.mY2;
+  }
+  bool operator!=(const nsSMILKeySpline& aOther) const {
+    return !(*this == aOther);
+  }
+  int32_t Compare(const nsSMILKeySpline& aRhs) const {
+    if (mX1 != aRhs.mX1) return mX1 < aRhs.mX1 ? -1 : 1;
+    if (mY1 != aRhs.mY1) return mY1 < aRhs.mY1 ? -1 : 1;
+    if (mX2 != aRhs.mX2) return mX2 < aRhs.mX2 ? -1 : 1;
+    if (mY2 != aRhs.mY2) return mY2 < aRhs.mY2 ? -1 : 1;
+    return 0;
+  }
+
+private:
+  void
+  CalcSampleValues();
+
+
+
+
+  static double
+  CalcBezier(double aT, double aA1, double aA2);
+
+
+
+
+  static double
+  GetSlope(double aT, double aA1, double aA2);
+
+  double
+  GetTForX(double aX) const;
+
+  double
+  NewtonRaphsonIterate(double aX, double aGuessT) const;
+
+  double
+  BinarySubdivide(double aX, double aA, double aB) const;
+
+  static double
+  A(double aA1, double aA2)
+  {
+    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+  }
+
+  static double
+  B(double aA1, double aA2)
+  {
+    return 3.0 * aA2 - 6.0 * aA1;
+  }
+
+  static double
+  C(double aA1)
+  {
+    return 3.0 * aA1;
+  }
+
+  double mX1;
+  double mY1;
+  double mX2;
+  double mY2;
+
+  enum { kSplineTableSize = 11 };
+  double mSampleValues[kSplineTableSize];
+
+  static const double kSampleStepSize;
+};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
+namespace mozilla {
+namespace css {
+class ErrorReporter;
+}
+}
+
+
+
+
+
+
+
+enum nsCSSTokenType {
+
+
+
+  eCSSToken_Whitespace,
+
+  eCSSToken_Comment,
+
+
+
+
+
+
+  eCSSToken_Ident,
+  eCSSToken_Function,
+  eCSSToken_AtKeyword,
+  eCSSToken_ID,
+  eCSSToken_Hash,
+# 54 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
+  eCSSToken_Number,
+  eCSSToken_Dimension,
+  eCSSToken_Percentage,
+
+
+
+
+
+
+  eCSSToken_String,
+  eCSSToken_Bad_String,
+  eCSSToken_URL,
+  eCSSToken_Bad_URL,
+
+
+  eCSSToken_Symbol,
+
+
+
+
+
+  eCSSToken_Includes,
+  eCSSToken_Dashmatch,
+  eCSSToken_Beginsmatch,
+  eCSSToken_Endsmatch,
+  eCSSToken_Containsmatch,
+# 89 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
+  eCSSToken_URange,
+
+
+
+
+
+
+
+  eCSSToken_HTMLComment,
+};
+# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
+enum nsCSSTokenSerializationType {
+  eCSSTokenSerialization_Nothing,
+  eCSSTokenSerialization_Whitespace,
+  eCSSTokenSerialization_AtKeyword_or_Hash,
+  eCSSTokenSerialization_Number,
+  eCSSTokenSerialization_Dimension,
+  eCSSTokenSerialization_Percentage,
+  eCSSTokenSerialization_URange,
+  eCSSTokenSerialization_URL_or_BadURL,
+  eCSSTokenSerialization_Function,
+  eCSSTokenSerialization_Ident,
+  eCSSTokenSerialization_CDC,
+  eCSSTokenSerialization_DashMatch,
+  eCSSTokenSerialization_ContainsMatch,
+  eCSSTokenSerialization_Symbol_Hash,
+  eCSSTokenSerialization_Symbol_At,
+  eCSSTokenSerialization_Symbol_Dot_or_Plus,
+  eCSSTokenSerialization_Symbol_Minus,
+  eCSSTokenSerialization_Symbol_OpenParen,
+  eCSSTokenSerialization_Symbol_Question,
+  eCSSTokenSerialization_Symbol_Assorted,
+  eCSSTokenSerialization_Symbol_Equals,
+  eCSSTokenSerialization_Symbol_Bar,
+  eCSSTokenSerialization_Symbol_Slash,
+  eCSSTokenSerialization_Symbol_Asterisk,
+  eCSSTokenSerialization_Other
+};
+
+
+
+
+struct nsCSSToken {
+  nsAutoString mIdent;
+  float mNumber;
+  int32_t mInteger;
+  int32_t mInteger2;
+  nsCSSTokenType mType;
+  char16_t mSymbol;
+  bool mIntegerValid;
+  bool mHasSign;
+
+  nsCSSToken()
+    : mNumber(0), mInteger(0), mInteger2(0), mType(eCSSToken_Whitespace),
+      mSymbol('\0'), mIntegerValid(false), mHasSign(false)
+  {}
+
+  bool IsSymbol(char16_t aSymbol) const {
+    return mType == eCSSToken_Symbol && mSymbol == aSymbol;
+  }
+
+  void AppendToString(nsString& aBuffer) const;
+};
+
+
+class nsCSSScannerPosition {
+  friend class nsCSSScanner;
+public:
+  nsCSSScannerPosition() : mInitialized(false) { }
+
+  uint32_t LineNumber() {
+    do { } while (0);
+    return mLineNumber;
+  }
+
+  uint32_t LineOffset() {
+    do { } while (0);
+    return mLineOffset;
+  }
+
+private:
+  uint32_t mOffset;
+  uint32_t mLineNumber;
+  uint32_t mLineOffset;
+  uint32_t mTokenLineNumber;
+  uint32_t mTokenLineOffset;
+  uint32_t mTokenOffset;
+  bool mInitialized;
+};
+
+enum nsCSSScannerExclude {
+
+  eCSSScannerExclude_None,
+
+  eCSSScannerExclude_Comments,
+
+  eCSSScannerExclude_WhitespaceAndComments
+};
+
+
+
+
+class nsCSSScanner {
+  public:
+
+
+
+
+  nsCSSScanner(const nsAString& aBuffer, uint32_t aLineNumber);
+  ~nsCSSScanner();
+
+  void SetErrorReporter(mozilla::css::ErrorReporter* aReporter) {
+    mReporter = aReporter;
+  }
+
+
+  void ClearSeenBadToken() { mSeenBadToken = false; }
+  bool SeenBadToken() const { return mSeenBadToken; }
+
+
+  void ClearSeenVariableReference() { mSeenVariableReference = false; }
+  bool SeenVariableReference() const { return mSeenVariableReference; }
+
+
+
+  uint32_t GetLineNumber() const { return mTokenLineNumber; }
+
+
+
+  uint32_t GetColumnNumber() const
+  { return mTokenOffset - mTokenLineOffset; }
+
+  uint32_t GetTokenOffset() const
+  { return mTokenOffset; }
+
+  uint32_t GetTokenEndOffset() const
+  { return mOffset; }
+
+
+
+  nsDependentSubstring GetCurrentLine() const;
+
+
+
+
+  bool Next(nsCSSToken& aTokenResult, nsCSSScannerExclude aSkip);
+
+
+
+
+
+
+  void NextURL(nsCSSToken& aTokenResult);
+# 258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
+  void Backup(uint32_t n);
+
+
+  void StartRecording();
+
+
+  void StopRecording();
+
+
+
+  void StopRecording(nsString& aBuffer);
+
+
+  uint32_t RecordingLength() const;
+
+
+
+
+
+
+  void SavePosition(nsCSSScannerPosition& aState);
+
+
+  void RestoreSavedPosition(const nsCSSScannerPosition& aState);
+
+  enum EOFCharacters {
+    eEOFCharacters_None = 0x0000,
+
+
+    eEOFCharacters_DropBackslash = 0x0001,
+
+
+    eEOFCharacters_ReplacementChar = 0x0002,
+
+
+    eEOFCharacters_Asterisk = 0x0004,
+    eEOFCharacters_Slash = 0x0008,
+
+
+    eEOFCharacters_DoubleQuote = 0x0010,
+
+
+    eEOFCharacters_SingleQuote = 0x0020,
+
+
+    eEOFCharacters_CloseParen = 0x0040,
+  };
+
+
+
+
+
+  static void AppendImpliedEOFCharacters(EOFCharacters aEOFCharacters,
+                                         nsAString& aString);
+
+  EOFCharacters GetEOFCharacters() const {
+
+
+
+    return mEOFCharacters;
+  }
+
+
+
+
+
+protected:
+  int32_t Peek(uint32_t n = 0);
+  void Advance(uint32_t n = 1);
+  void AdvanceLine();
+
+  void SkipWhitespace();
+  void SkipComment();
+
+  bool GatherEscape(nsString& aOutput, bool aInString);
+  bool GatherText(uint8_t aClass, nsString& aIdent);
+
+  bool ScanIdent(nsCSSToken& aResult);
+  bool ScanAtKeyword(nsCSSToken& aResult);
+  bool ScanHash(nsCSSToken& aResult);
+  bool ScanNumber(nsCSSToken& aResult);
+  bool ScanString(nsCSSToken& aResult);
+  bool ScanURange(nsCSSToken& aResult);
+
+  void SetEOFCharacters(uint32_t aEOFCharacters);
+  void AddEOFCharacters(uint32_t aEOFCharacters);
+
+  const char16_t *mBuffer;
+  uint32_t mOffset;
+  uint32_t mCount;
+
+  uint32_t mLineNumber;
+  uint32_t mLineOffset;
+
+  uint32_t mTokenLineNumber;
+  uint32_t mTokenLineOffset;
+  uint32_t mTokenOffset;
+
+  uint32_t mRecordStartOffset;
+  EOFCharacters mEOFCharacters;
+
+  mozilla::css::ErrorReporter *mReporter;
+
+  bool mRecording;
+  bool mSeenBadToken;
+  bool mSeenVariableReference;
+};
+
+
+
+struct nsCSSGridTemplateAreaToken {
+  nsAutoString mName;
+  bool isTrash;
+};
+
+
+class nsCSSGridTemplateAreaScanner {
+public:
+  explicit nsCSSGridTemplateAreaScanner(const nsAString& aBuffer);
+
+
+
+  bool Next(nsCSSGridTemplateAreaToken& aTokenResult);
+
+private:
+  const char16_t *mBuffer;
+  uint32_t mOffset;
+  uint32_t mCount;
+};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h" 2
+
+
+
+namespace mozilla {
+
+class CSSVariableResolver;
+
+class CSSVariableValues
+{
+public:
+  CSSVariableValues();
+  CSSVariableValues(const CSSVariableValues& aOther);
+
+
+
+  CSSVariableValues& operator=(const CSSVariableValues& aOther);
+
+  bool operator==(const CSSVariableValues& aOther) const;
+  bool operator!=(const CSSVariableValues& aOther) const
+    { return !(*this == aOther); }
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
+  bool Get(const nsAString& aName, nsString& aValue) const;
+# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
+  bool Get(const nsAString& aName,
+           nsString& aValue,
+           nsCSSTokenSerializationType& aFirstToken,
+           nsCSSTokenSerializationType& aLastToken) const;
+# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
+  void GetVariableAt(size_t aIndex, nsAString& aName) const;
+
+
+
+
+  size_t Count() const;
+# 93 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
+  void Put(const nsAString& aName,
+           nsString aValue,
+           nsCSSTokenSerializationType aFirstToken,
+           nsCSSTokenSerializationType aLastToken);
+
+
+
+
+
+  void AddVariablesToResolver(CSSVariableResolver* aResolver) const;
+
+private:
+  struct Variable
+  {
+    Variable()
+      : mFirstToken(eCSSTokenSerialization_Nothing)
+      , mLastToken(eCSSTokenSerialization_Nothing)
+    {}
+
+    Variable(const nsAString& aVariableName,
+             nsString aValue,
+             nsCSSTokenSerializationType aFirstToken,
+             nsCSSTokenSerializationType aLastToken)
+      : mVariableName(aVariableName)
+      , mValue(aValue)
+      , mFirstToken(aFirstToken)
+      , mLastToken(aLastToken)
+    {}
+
+    nsString mVariableName;
+    nsString mValue;
+    nsCSSTokenSerializationType mFirstToken;
+    nsCSSTokenSerializationType mLastToken;
+  };
+
+
+
+
+  void CopyVariablesFrom(const CSSVariableValues& aOther);
+
+
+
+
+
+  nsDataHashtable<nsStringHashKey, size_t> mVariableIDs;
+
+
+
+
+  nsTArray<Variable> mVariables;
+};
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThemeConstants.h" 1
+# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h" 1
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h"
+class imgIContainer;
+
+class imgINotificationObserver;
+
+class nsIURI;
+
+class nsIPrincipal;
+# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h"
+class imgIRequest : public nsIRequest {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetImage(imgIContainer * *aImage) = 0;
+
+  enum {
+    STATUS_NONE = 0,
+    STATUS_SIZE_AVAILABLE = 1,
+    STATUS_LOAD_COMPLETE = 2,
+    STATUS_ERROR = 4,
+    STATUS_FRAME_COMPLETE = 8,
+    STATUS_DECODE_COMPLETE = 16,
+    STATUS_IS_ANIMATED = 32,
+    STATUS_HAS_TRANSPARENCY = 64
+  };
+
+
+  virtual nsresult GetImageStatus(uint32_t *aImageStatus) = 0;
+
+
+  virtual nsresult GetImageErrorCode(nsresult *aImageErrorCode) = 0;
+
+
+  virtual nsresult GetURI(nsIURI * *aURI) = 0;
+
+
+  virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) = 0;
+
+
+  virtual nsresult GetNotificationObserver(imgINotificationObserver * *aNotificationObserver) = 0;
+
+
+  virtual nsresult GetMimeType(char * *aMimeType) = 0;
+
+
+  virtual nsresult Clone(imgINotificationObserver *aObserver, imgIRequest * *_retval) = 0;
+
+
+  virtual nsresult GetImagePrincipal(nsIPrincipal * *aImagePrincipal) = 0;
+
+
+  virtual nsresult GetMultipart(bool *aMultipart) = 0;
+
+  enum {
+    CORS_NONE = 1,
+    CORS_ANONYMOUS = 2,
+    CORS_USE_CREDENTIALS = 3
+  };
+
+
+  virtual nsresult GetCORSMode(int32_t *aCORSMode) = 0;
+
+
+  virtual nsresult CancelAndForgetObserver(nsresult aStatus) = 0;
+
+
+  virtual nsresult StartDecoding(uint32_t aFlags) = 0;
+
+
+  virtual bool StartDecodingWithResult(uint32_t aFlags) = 0;
+
+
+  virtual nsresult LockImage(void) = 0;
+
+
+  virtual nsresult UnlockImage(void) = 0;
+
+
+  virtual nsresult RequestDiscard(void) = 0;
+
+
+  virtual nsresult GetStaticRequest(imgIRequest * *_retval) = 0;
+
+
+  virtual nsresult IncrementAnimationConsumers(void) = 0;
+
+
+  virtual nsresult DecrementAnimationConsumers(void) = 0;
+
+};
+
+  template<typename T> struct imgIRequest::COMTypeInfo<imgIRequest, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID imgIRequest::COMTypeInfo<imgIRequest, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xdb0a945c, 0x3883, 0x424a, { 0x98, 0xd0, 0x2e, 0xe0, 0x52, 0x3b, 0x02, 0x55 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISecurityInfoProvider.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISecurityInfoProvider.h"
+class nsISecurityInfoProvider : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
+
+
+  virtual nsresult GetHasTransferredData(bool *aHasTransferredData) = 0;
+
+};
+
+  template<typename T> struct nsISecurityInfoProvider::COMTypeInfo<nsISecurityInfoProvider, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISecurityInfoProvider::COMTypeInfo<nsISecurityInfoProvider, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb8cc9126, 0x9319, 0x4415, { 0xaf, 0xd9, 0xb8, 0x22, 0x20, 0xd4, 0x53, 0xed }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsPriority.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsPriority.h"
+class nsISupportsPriority : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    PRIORITY_HIGHEST = -20,
+    PRIORITY_HIGH = -10,
+    PRIORITY_NORMAL = 0,
+    PRIORITY_LOW = 10,
+    PRIORITY_LOWEST = 20
+  };
+
+
+  virtual nsresult GetPriority(int32_t *aPriority) = 0;
+  virtual nsresult SetPriority(int32_t aPriority) = 0;
+
+
+  virtual nsresult AdjustPriority(int32_t delta) = 0;
+
+};
+
+  template<typename T> struct nsISupportsPriority::COMTypeInfo<nsISupportsPriority, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupportsPriority::COMTypeInfo<nsISupportsPriority, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xaa578b44, 0xabd5, 0x4c19, { 0x8b, 0x14, 0x36, 0xd4, 0xde, 0x6f, 0xdc, 0x36 }};
+# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h"
+class nsIPrincipal;
+
+namespace mozilla {
+class TimeStamp;
+}
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h"
+class nsITimedChannel : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetTimingEnabled(bool *aTimingEnabled) = 0;
+  virtual nsresult SetTimingEnabled(bool aTimingEnabled) = 0;
+
+
+  virtual nsresult GetRedirectCount(uint16_t *aRedirectCount) = 0;
+  virtual nsresult SetRedirectCount(uint16_t aRedirectCount) = 0;
+
+
+  virtual nsresult GetChannelCreation(mozilla::TimeStamp *aChannelCreation) = 0;
+
+
+  virtual nsresult GetAsyncOpen(mozilla::TimeStamp *aAsyncOpen) = 0;
+
+
+  virtual nsresult GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) = 0;
+
+
+  virtual nsresult GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) = 0;
+
+
+  virtual nsresult GetConnectStart(mozilla::TimeStamp *aConnectStart) = 0;
+
+
+  virtual nsresult GetConnectEnd(mozilla::TimeStamp *aConnectEnd) = 0;
+
+
+  virtual nsresult GetRequestStart(mozilla::TimeStamp *aRequestStart) = 0;
+
+
+  virtual nsresult GetResponseStart(mozilla::TimeStamp *aResponseStart) = 0;
+
+
+  virtual nsresult GetResponseEnd(mozilla::TimeStamp *aResponseEnd) = 0;
+
+
+  virtual nsresult GetRedirectStart(mozilla::TimeStamp *aRedirectStart) = 0;
+  virtual nsresult SetRedirectStart(mozilla::TimeStamp aRedirectStart) = 0;
+
+
+  virtual nsresult GetRedirectEnd(mozilla::TimeStamp *aRedirectEnd) = 0;
+  virtual nsresult SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) = 0;
+
+
+  virtual nsresult GetInitiatorType(nsAString & aInitiatorType) = 0;
+  virtual nsresult SetInitiatorType(const nsAString & aInitiatorType) = 0;
+
+
+  virtual nsresult GetAllRedirectsSameOrigin(bool *aAllRedirectsSameOrigin) = 0;
+  virtual nsresult SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) = 0;
+
+
+  virtual nsresult GetAllRedirectsPassTimingAllowCheck(bool *aAllRedirectsPassTimingAllowCheck) = 0;
+  virtual nsresult SetAllRedirectsPassTimingAllowCheck(bool aAllRedirectsPassTimingAllowCheck) = 0;
+
+
+  virtual nsresult TimingAllowCheck(nsIPrincipal *origin, bool *_retval) = 0;
+
+   inline bool TimingAllowCheck(nsIPrincipal* aOrigin) {
+    bool allowed = false;
+    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(TimingAllowCheck(aOrigin, &allowed))), 1))) && allowed;
+  }
+
+  virtual nsresult GetCacheReadStart(mozilla::TimeStamp *aCacheReadStart) = 0;
+
+
+  virtual nsresult GetCacheReadEnd(mozilla::TimeStamp *aCacheReadEnd) = 0;
+
+
+  virtual nsresult GetChannelCreationTime(PRTime *aChannelCreationTime) = 0;
+
+
+  virtual nsresult GetAsyncOpenTime(PRTime *aAsyncOpenTime) = 0;
+
+
+  virtual nsresult GetDomainLookupStartTime(PRTime *aDomainLookupStartTime) = 0;
+
+
+  virtual nsresult GetDomainLookupEndTime(PRTime *aDomainLookupEndTime) = 0;
+
+
+  virtual nsresult GetConnectStartTime(PRTime *aConnectStartTime) = 0;
+
+
+  virtual nsresult GetConnectEndTime(PRTime *aConnectEndTime) = 0;
+
+
+  virtual nsresult GetRequestStartTime(PRTime *aRequestStartTime) = 0;
+
+
+  virtual nsresult GetResponseStartTime(PRTime *aResponseStartTime) = 0;
+
+
+  virtual nsresult GetResponseEndTime(PRTime *aResponseEndTime) = 0;
+
+
+  virtual nsresult GetCacheReadStartTime(PRTime *aCacheReadStartTime) = 0;
+
+
+  virtual nsresult GetCacheReadEndTime(PRTime *aCacheReadEndTime) = 0;
+
+
+  virtual nsresult GetRedirectStartTime(PRTime *aRedirectStartTime) = 0;
+
+
+  virtual nsresult GetRedirectEndTime(PRTime *aRedirectEndTime) = 0;
+
+};
+
+  template<typename T> struct nsITimedChannel::COMTypeInfo<nsITimedChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimedChannel::COMTypeInfo<nsITimedChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xca63784d, 0x959c, 0x4c3a, { 0x9a, 0x59, 0x23, 0x4a, 0x2a, 0x52, 0x0d, 0xe0 }};
+# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h"
+class nsIChannel;
+
+class nsIAsyncVerifyRedirectCallback;
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h"
+class nsIChannelEventSink : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+  enum {
+    REDIRECT_TEMPORARY = 1U,
+    REDIRECT_PERMANENT = 2U,
+    REDIRECT_INTERNAL = 4U,
+    REDIRECT_STS_UPGRADE = 8U
+  };
+
+
+  virtual nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags, nsIAsyncVerifyRedirectCallback *callback) = 0;
+
+};
+
+  template<typename T> struct nsIChannelEventSink::COMTypeInfo<nsIChannelEventSink, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIChannelEventSink::COMTypeInfo<nsIChannelEventSink, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0197720d, 0x37ed, 0x4e75, { 0x89, 0x56, 0xd0, 0xd2, 0x96, 0xe4, 0xd8, 0xa6 }};
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIInterfaceRequestor.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIInterfaceRequestor.h"
+class nsIInterfaceRequestor : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult GetInterface(const nsIID & uuid, void **result) = 0;
+
+};
+
+  template<typename T> struct nsIInterfaceRequestor::COMTypeInfo<nsIInterfaceRequestor, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIInterfaceRequestor::COMTypeInfo<nsIInterfaceRequestor, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x033a1470, 0x8b2a, 0x11d3, { 0xaf, 0x88, 0x00, 0xa0, 0x24, 0xff, 0xc0, 0x8c }};
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadRetargetableStreamListener.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadRetargetableStreamListener.h"
+class nsIThreadRetargetableStreamListener : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult CheckListenerChain(void) = 0;
+
+};
+
+  template<typename T> struct nsIThreadRetargetableStreamListener::COMTypeInfo<nsIThreadRetargetableStreamListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThreadRetargetableStreamListener::COMTypeInfo<nsIThreadRetargetableStreamListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xfb2304b8, 0xf82f, 0x4433, { 0xaf, 0x68, 0xd8, 0x74, 0xa2, 0xeb, 0xbd, 0xc1 }};
+# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAsyncVerifyRedirectCallback.h" 1
+# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAsyncVerifyRedirectCallback.h"
+class nsIAsyncVerifyRedirectCallback : public nsISupports {
+ public:
+
+  template<typename T, typename U> struct COMTypeInfo;
+
+
+  virtual nsresult OnRedirectVerifyCallback(nsresult result) = 0;
+
+};
+
+  template<typename T> struct nsIAsyncVerifyRedirectCallback::COMTypeInfo<nsIAsyncVerifyRedirectCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAsyncVerifyRedirectCallback::COMTypeInfo<nsIAsyncVerifyRedirectCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8d171460, 0xa716, 0x41f1, { 0x92, 0xbe, 0x8c, 0x65, 0x9d, 0xb3, 0x9b, 0x45 }};
+# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 1
+# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h" 1
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
+namespace mozilla {
+# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
+class BlockingResourceBase
+{
+public:
+
+  enum BlockingResourceType { eMutex, eReentrantMonitor, eCondVar };
+
+
+
+
+
+  static const char* const kResourceTypeName[];
+# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
+  BlockingResourceBase(const char* aName, BlockingResourceType aType) {}
+
+  ~BlockingResourceBase() {}
+
+
+};
+
+
+}
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PlatformMutex.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PlatformMutex.h"
+namespace mozilla {
+
+namespace detail {
+
+class ConditionVariableImpl;
+
+class MutexImpl
+{
+public:
+  struct PlatformData;
+
+  __attribute__((weak)) __attribute__((visibility("default"))) MutexImpl();
+  __attribute__((weak)) __attribute__((visibility("default"))) ~MutexImpl();
+
+  bool operator==(const MutexImpl& rhs) {
+    return platformData_ == rhs.platformData_;
+  }
+
+protected:
+  __attribute__((weak)) __attribute__((visibility("default"))) void lock();
+  __attribute__((weak)) __attribute__((visibility("default"))) void unlock();
+
+private:
+  MutexImpl(const MutexImpl&) = delete;
+  void operator=(const MutexImpl&) = delete;
+  MutexImpl(MutexImpl&&) = delete;
+  void operator=(MutexImpl&&) = delete;
+
+  PlatformData* platformData();
+
+
+  void* platformData_[sizeof(pthread_mutex_t) / sizeof(void*)];
+  static_assert(sizeof(pthread_mutex_t) / sizeof(void*) != 0 &&
+                sizeof(pthread_mutex_t) % sizeof(void*) == 0,
+                "pthread_mutex_t must have pointer alignment");
+
+
+
+
+  friend class mozilla::detail::ConditionVariableImpl;
+};
+
+}
+
+}
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 2
+# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+namespace mozilla {
+
+
+
+
+
+
+class OffTheBooksMutex : public detail::MutexImpl, BlockingResourceBase
+{
+public:
+
+
+
+
+
+
+  explicit OffTheBooksMutex(const char* aName)
+    : detail::MutexImpl()
+    , BlockingResourceBase(aName, eMutex)
+
+
+
+  {
+  }
+
+  ~OffTheBooksMutex()
+  {
+
+
+
+  }
+
+
+
+
+
+  void Lock() { this->lock(); }
+
+
+
+
+  void Unlock() { this->unlock(); }
+
+
+
+
+
+
+  void AssertCurrentThreadOwns() const {}
+# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+  void AssertNotCurrentThreadOwns() const {}
+# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+private:
+  OffTheBooksMutex();
+  OffTheBooksMutex(const OffTheBooksMutex&);
+  OffTheBooksMutex& operator=(const OffTheBooksMutex&);
+
+  friend class CondVar;
+
+
+
+
+};
+
+
+
+
+
+
+class Mutex : public OffTheBooksMutex
+{
+public:
+  explicit Mutex(const char* aName)
+    : OffTheBooksMutex(aName)
+  {
+                         ;
+  }
+
+  ~Mutex()
+  {
+                         ;
+  }
+
+private:
+  Mutex();
+  Mutex(const Mutex&);
+  Mutex& operator=(const Mutex&);
+};
+# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+template<typename T>
+class BaseAutoLock
+{
+public:
+# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+  explicit BaseAutoLock(T& aLock )
+    : mLock(&aLock)
+  {
+    do { } while (0);
+    do { } while(0);
+    mLock->Lock();
+  }
+
+  ~BaseAutoLock(void)
+  {
+    mLock->Unlock();
+  }
+
+private:
+  BaseAutoLock();
+  BaseAutoLock(BaseAutoLock&);
+  BaseAutoLock& operator=(BaseAutoLock&);
+  static void* operator new(size_t) throw();
+
+  T* mLock;
+
+};
+
+typedef BaseAutoLock<Mutex> MutexAutoLock;
+typedef BaseAutoLock<OffTheBooksMutex> OffTheBooksMutexAutoLock;
+# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
+template<typename T>
+class BaseAutoUnlock
+{
+public:
+  explicit BaseAutoUnlock(T& aLock )
+    : mLock(&aLock)
+  {
+    do { } while (0);
+    do { } while(0);
+    mLock->Unlock();
+  }
+
+  ~BaseAutoUnlock()
+  {
+    mLock->Lock();
+  }
+
+private:
+  BaseAutoUnlock();
+  BaseAutoUnlock(BaseAutoUnlock&);
+  BaseAutoUnlock& operator=(BaseAutoUnlock&);
+  static void* operator new(size_t) throw();
+
+  T* mLock;
+
+};
+
+typedef BaseAutoUnlock<Mutex> MutexAutoUnlock;
+typedef BaseAutoUnlock<OffTheBooksMutex> OffTheBooksMutexAutoUnlock;
+
+}
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h" 1
+# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h"
+class nsIDocument;
+class nsIURI;
+
+namespace mozilla {
+namespace image {
+
+class ImageURL;
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h"
+class ImageCacheKey final
+{
+public:
+  ImageCacheKey(nsIURI* aURI, const OriginAttributes& aAttrs,
+                nsIDocument* aDocument, nsresult& aRv);
+  ImageCacheKey(ImageURL* aURI, const OriginAttributes& aAttrs,
+                nsIDocument* aDocument);
+
+  ImageCacheKey(const ImageCacheKey& aOther);
+  ImageCacheKey(ImageCacheKey&& aOther);
+
+  bool operator==(const ImageCacheKey& aOther) const;
+  uint32_t Hash() const { return mHash; }
+
+
+  const char* Spec() const;
+
+
+  bool IsChrome() const { return mIsChrome; }
+
+
+
+  void* ControlledDocument() const { return mControlledDocument; }
+
+private:
+  static uint32_t ComputeHash(ImageURL* aURI,
+                              const Maybe<uint64_t>& aBlobSerial,
+                              const OriginAttributes& aAttrs,
+                              void* aControlledDocument);
+  static void* GetControlledDocumentToken(nsIDocument* aDocument);
+
+  RefPtr<ImageURL> mURI;
+  Maybe<uint64_t> mBlobSerial;
+  OriginAttributes mOriginAttributes;
+  void* mControlledDocument;
+  uint32_t mHash;
+  bool mIsChrome;
+};
+
+}
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
+
+class imgCacheValidator;
+class imgLoader;
+class imgRequestProxy;
+class imgCacheEntry;
+class nsIApplicationCache;
+class nsIProperties;
+class nsIRequest;
+class nsITimedChannel;
+class nsIURI;
+
+namespace mozilla {
+namespace image {
+class Image;
+class ImageURL;
+class ProgressTracker;
+}
+}
+
+struct NewPartResult;
+
+class imgRequest final : public nsIStreamListener,
+                         public nsIThreadRetargetableStreamListener,
+                         public nsIChannelEventSink,
+                         public nsIInterfaceRequestor,
+                         public nsIAsyncVerifyRedirectCallback
+{
+  typedef mozilla::image::Image Image;
+  typedef mozilla::image::ImageCacheKey ImageCacheKey;
+  typedef mozilla::image::ImageURL ImageURL;
+  typedef mozilla::image::ProgressTracker ProgressTracker;
+  typedef mozilla::net::ReferrerPolicy ReferrerPolicy;
+
+public:
+  imgRequest(imgLoader* aLoader, const ImageCacheKey& aCacheKey);
+
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+  virtual nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext, nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount) override;
+  virtual nsresult CheckListenerChain(void) override;
+  virtual nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) override; virtual nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode) override;
+  virtual nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags, nsIAsyncVerifyRedirectCallback *callback) override;
+  virtual nsresult GetInterface(const nsIID & uuid, void **result) override;
+  virtual nsresult OnRedirectVerifyCallback(nsresult result) override;
+
+  __attribute__ ((warn_unused_result)) nsresult Init(nsIURI* aURI,
+                             nsIURI* aCurrentURI,
+                             bool aHadInsecureRedirect,
+                             nsIRequest* aRequest,
+                             nsIChannel* aChannel,
+                             imgCacheEntry* aCacheEntry,
+                             nsISupports* aCX,
+                             nsIPrincipal* aLoadingPrincipal,
+                             int32_t aCORSMode,
+                             ReferrerPolicy aReferrerPolicy);
+
+  void ClearLoader();
+
+
+  void AddProxy(imgRequestProxy* proxy);
+
+  nsresult RemoveProxy(imgRequestProxy* proxy, nsresult aStatus);
+
+
+
+
+  void CancelAndAbort(nsresult aStatus);
+
+
+  void ContinueCancel(nsresult aStatus);
+
+
+  void ContinueEvict();
+
+
+  void StartDecoding();
+
+  inline uint64_t InnerWindowID() const {
+    return mInnerWindowId;
+  }
+
+
+
+
+
+  static void SetCacheValidation(imgCacheEntry* aEntry, nsIRequest* aRequest);
+
+
+
+
+
+  bool CacheChanged(nsIRequest* aNewRequest);
+
+  bool GetMultipart() const;
+
+
+
+  bool HadInsecureRedirect() const;
+
+
+  int32_t GetCORSMode() const { return mCORSMode; }
+
+
+  ReferrerPolicy GetReferrerPolicy() const { return mReferrerPolicy; }
+
+
+
+  already_AddRefed<nsIPrincipal> GetLoadingPrincipal() const
+  {
+    nsCOMPtr<nsIPrincipal> principal = mLoadingPrincipal;
+    return principal.forget();
+  }
+
+
+
+
+  already_AddRefed<ProgressTracker> GetProgressTracker() const;
+
+
+  already_AddRefed<Image> GetImage() const;
+
+
+  inline nsIPrincipal* GetPrincipal() const { return mPrincipal.get(); }
+
+
+  const ImageCacheKey& CacheKey() const { return mCacheKey; }
+
+
+  void ResetCacheEntry();
+
+
+  nsresult GetURI(ImageURL** aURI);
+  nsresult GetCurrentURI(nsIURI** aURI);
+  bool IsChrome() const;
+
+  nsresult GetImageErrorCode(void);
+
+
+  bool HasTransferredData() const;
+
+
+  const char* GetMimeType() const { return mContentType.get(); }
+
+
+
+  int32_t Priority() const;
+
+
+
+  void AdjustPriority(imgRequestProxy* aProxy, int32_t aDelta);
+
+
+  nsIRequest* GetRequest() const { return mRequest; }
+
+  nsITimedChannel* GetTimedChannel() const { return mTimedChannel; }
+
+  nsresult GetSecurityInfo(nsISupports** aSecurityInfoOut);
+
+  imgCacheValidator* GetValidator() const { return mValidator; }
+  void SetValidator(imgCacheValidator* aValidator) { mValidator = aValidator; }
+
+  void* LoadId() const { return mLoadId; }
+  void SetLoadId(void* aLoadId) { mLoadId = aLoadId; }
+
+
+
+
+  void SetCacheEntry(imgCacheEntry* aEntry);
+
+
+  bool HasCacheEntry() const;
+
+
+
+
+  void SetIsInCache(bool aCacheable);
+
+  void EvictFromCache();
+  void RemoveFromCache();
+
+
+  void SetProperties(const nsACString& aContentType,
+                     const nsACString& aContentDisposition);
+
+  nsIProperties* Properties() const { return mProperties; }
+
+  bool HasConsumers() const;
+
+private:
+  friend class FinishPreparingForNewPartRunnable;
+
+  virtual ~imgRequest();
+
+  void FinishPreparingForNewPart(const NewPartResult& aResult);
+
+  void Cancel(nsresult aStatus);
+
+
+  void UpdateCacheEntrySize();
+
+
+  bool IsDecodeRequested() const;
+
+
+  imgLoader* mLoader;
+  nsCOMPtr<nsIRequest> mRequest;
+
+
+
+  RefPtr<ImageURL> mURI;
+
+  nsCOMPtr<nsIURI> mCurrentURI;
+
+
+  nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
+
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCOMPtr<nsIProperties> mProperties;
+  nsCOMPtr<nsISupports> mSecurityInfo;
+  nsCOMPtr<nsIChannel> mChannel;
+  nsCOMPtr<nsIInterfaceRequestor> mPrevChannelSink;
+  nsCOMPtr<nsIApplicationCache> mApplicationCache;
+
+  nsCOMPtr<nsITimedChannel> mTimedChannel;
+
+  nsCString mContentType;
+
+
+  RefPtr<imgCacheEntry> mCacheEntry;
+
+
+  ImageCacheKey mCacheKey;
+
+  void* mLoadId;
+
+
+
+  void* mFirstProxy;
+
+  imgCacheValidator* mValidator;
+  nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
+  nsCOMPtr<nsIChannel> mNewRedirectChannel;
+
+
+  uint64_t mInnerWindowId;
+
+
+
+  int32_t mCORSMode;
+
+
+  ReferrerPolicy mReferrerPolicy;
+
+  nsresult mImageErrorCode;
+
+  mutable mozilla::Mutex mMutex;
+
+
+
+
+  RefPtr<ProgressTracker> mProgressTracker;
+  RefPtr<Image> mImage;
+  bool mIsMultiPartChannel : 1;
+  bool mGotData : 1;
+  bool mIsInCache : 1;
+  bool mDecodeRequested : 1;
+  bool mNewPartPending : 1;
+  bool mHadInsecureRedirect : 1;
+};
+# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h" 1
+# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h"
+namespace mozilla {
+namespace image {
+# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h"
+class IProgressObserver : public SupportsWeakPtr<IProgressObserver>
+{
+public:
+
+
+
+
+  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
+
+
+  virtual void Notify(int32_t aType, const nsIntRect* aRect = nullptr) = 0;
+  virtual void OnLoadComplete(bool aLastPart) = 0;
+
+
+  virtual void BlockOnload() = 0;
+  virtual void UnblockOnload() = 0;
+
+
+  virtual void SetHasImage() = 0;
+  virtual bool NotificationsDeferred() const = 0;
+  virtual void SetNotificationsDeferred(bool aDeferNotifications) = 0;
+
+protected:
+  virtual ~IProgressObserver() { }
+};
+
+}
+}
+# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
+# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h"
+class imgINotificationObserver;
+class imgStatusNotifyRunnable;
+class ProxyBehaviour;
+
+namespace mozilla {
+namespace image {
+class Image;
+class ImageURL;
+class ProgressTracker;
+}
+}
+
+class imgRequestProxy : public imgIRequest,
+                        public mozilla::image::IProgressObserver,
+                        public nsISupportsPriority,
+                        public nsISecurityInfoProvider,
+                        public nsITimedChannel
+{
+protected:
+  virtual ~imgRequestProxy();
+
+public:
+  typedef mozilla::image::Image Image;
+  typedef mozilla::image::ImageURL ImageURL;
+  typedef mozilla::image::ProgressTracker ProgressTracker;
+
+  const char* typeName() const { return "imgRequestProxy"; } size_t typeSize() const { return sizeof(*this); }
+  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+  virtual nsresult GetImage(imgIContainer * *aImage) override; virtual nsresult GetImageStatus(uint32_t *aImageStatus) override; virtual nsresult GetImageErrorCode(nsresult *aImageErrorCode) override; virtual nsresult GetURI(nsIURI * *aURI) override; virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) override; virtual nsresult GetNotificationObserver(imgINotificationObserver * *aNotificationObserver) override; virtual nsresult GetMimeType(char * *aMimeType) override; virtual nsresult Clone(imgINotificationObserver *aObserver, imgIRequest * *_retval) override; virtual nsresult GetImagePrincipal(nsIPrincipal * *aImagePrincipal) override; virtual nsresult GetMultipart(bool *aMultipart) override; virtual nsresult GetCORSMode(int32_t *aCORSMode) override; virtual nsresult CancelAndForgetObserver(nsresult aStatus) override; virtual nsresult StartDecoding(uint32_t aFlags) override; virtual bool StartDecodingWithResult(uint32_t aFlags) override; virtual nsresult LockImage(void) override; virtual nsresult UnlockImage(void) override; virtual nsresult RequestDiscard(void) override; virtual nsresult GetStaticRequest(imgIRequest * *_retval) override; virtual nsresult IncrementAnimationConsumers(void) override; virtual nsresult DecrementAnimationConsumers(void) override;
+  virtual nsresult GetName(nsACString & aName) override; virtual nsresult IsPending(bool *_retval) override; virtual nsresult GetStatus(nsresult *aStatus) override; virtual nsresult Cancel(nsresult aStatus) override; virtual nsresult Suspend(void) override; virtual nsresult Resume(void) override; virtual nsresult GetLoadGroup(nsILoadGroup * *aLoadGroup) override; virtual nsresult SetLoadGroup(nsILoadGroup *aLoadGroup) override; virtual nsresult GetLoadFlags(nsLoadFlags *aLoadFlags) override; virtual nsresult SetLoadFlags(nsLoadFlags aLoadFlags) override;
+  virtual nsresult GetPriority(int32_t *aPriority) override; virtual nsresult SetPriority(int32_t aPriority) override; virtual nsresult AdjustPriority(int32_t delta) override;
+  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) override; virtual nsresult GetHasTransferredData(bool *aHasTransferredData) override;
+
+
+  imgRequestProxy();
+
+
+
+  nsresult Init(imgRequest* aOwner,
+                nsILoadGroup* aLoadGroup,
+                ImageURL* aURI,
+                imgINotificationObserver* aObserver);
+
+  nsresult ChangeOwner(imgRequest* aNewOwner);
+
+
+
+
+  void AddToLoadGroup();
+  void RemoveFromLoadGroup(bool releaseLoadGroup);
+
+  inline bool HasObserver() const {
+    return mListener != nullptr;
+  }
+
+
+
+
+
+  void NotifyListener();
+
+
+
+
+  void SyncNotifyListener();
+
+
+  virtual void Notify(int32_t aType,
+                      const mozilla::gfx::IntRect* aRect = nullptr) override;
+  virtual void OnLoadComplete(bool aLastPart) override;
+
+
+  virtual void BlockOnload() override;
+  virtual void UnblockOnload() override;
+
+
+  virtual void SetHasImage() override;
+
+
+
+  virtual bool NotificationsDeferred() const override
+  {
+    return mDeferNotifications;
+  }
+  virtual void SetNotificationsDeferred(bool aDeferNotifications) override
+  {
+    mDeferNotifications = aDeferNotifications;
+  }
+
+
+
+
+
+  void ClearAnimationConsumers();
+
+  virtual nsresult Clone(imgINotificationObserver* aObserver,
+                         imgRequestProxy** aClone);
+  nsresult GetStaticRequest(imgRequestProxy** aReturn);
+
+  nsresult GetURI(ImageURL** aURI);
+
+protected:
+  friend class mozilla::image::ProgressTracker;
+  friend class imgStatusNotifyRunnable;
+
+  class imgCancelRunnable;
+  friend class imgCancelRunnable;
+
+  class imgCancelRunnable : public mozilla::Runnable
+  {
+    public:
+      imgCancelRunnable(imgRequestProxy* owner, nsresult status)
+        : Runnable("imgCancelRunnable"), mOwner(owner), mStatus(status)
+      { }
+
+      virtual nsresult Run() override {
+        mOwner->DoCancel(mStatus);
+        return NS_OK;
+      }
+
+    private:
+      RefPtr<imgRequestProxy> mOwner;
+      nsresult mStatus;
+  };
+
+
+  void DoCancel(nsresult status);
+
+
+  void NullOutListener();
+
+  void DoRemoveFromLoadGroup() {
+    RemoveFromLoadGroup(true);
+  }
+
+
+
+
+
+  already_AddRefed<ProgressTracker> GetProgressTracker() const;
+
+  nsITimedChannel* TimedChannel()
+  {
+    if (!GetOwner()) {
+      return nullptr;
+    }
+    return GetOwner()->GetTimedChannel();
+  }
+
+  already_AddRefed<Image> GetImage() const;
+  bool HasImage() const;
+  imgRequest* GetOwner() const;
+
+  nsresult PerformClone(imgINotificationObserver* aObserver,
+                        imgRequestProxy* (aAllocFn)(imgRequestProxy*),
+                        imgRequestProxy** aClone);
+
+public:
+  virtual nsresult GetTimingEnabled(bool *aTimingEnabled) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetTimingEnabled(aTimingEnabled); } virtual nsresult SetTimingEnabled(bool aTimingEnabled) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetTimingEnabled(aTimingEnabled); } virtual nsresult GetRedirectCount(uint16_t *aRedirectCount) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectCount(aRedirectCount); } virtual nsresult SetRedirectCount(uint16_t aRedirectCount) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectCount(aRedirectCount); } virtual nsresult GetChannelCreation(mozilla::TimeStamp *aChannelCreation) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetChannelCreation(aChannelCreation); } virtual nsresult GetAsyncOpen(mozilla::TimeStamp *aAsyncOpen) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAsyncOpen(aAsyncOpen); } virtual nsresult GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupStart(aDomainLookupStart); } virtual nsresult GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupEnd(aDomainLookupEnd); } virtual nsresult GetConnectStart(mozilla::TimeStamp *aConnectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectStart(aConnectStart); } virtual nsresult GetConnectEnd(mozilla::TimeStamp *aConnectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectEnd(aConnectEnd); } virtual nsresult GetRequestStart(mozilla::TimeStamp *aRequestStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRequestStart(aRequestStart); } virtual nsresult GetResponseStart(mozilla::TimeStamp *aResponseStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseStart(aResponseStart); } virtual nsresult GetResponseEnd(mozilla::TimeStamp *aResponseEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseEnd(aResponseEnd); } virtual nsresult GetRedirectStart(mozilla::TimeStamp *aRedirectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectStart(aRedirectStart); } virtual nsresult SetRedirectStart(mozilla::TimeStamp aRedirectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectStart(aRedirectStart); } virtual nsresult GetRedirectEnd(mozilla::TimeStamp *aRedirectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectEnd(aRedirectEnd); } virtual nsresult SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectEnd(aRedirectEnd); } virtual nsresult GetInitiatorType(nsAString & aInitiatorType) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetInitiatorType(aInitiatorType); } virtual nsresult SetInitiatorType(const nsAString & aInitiatorType) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetInitiatorType(aInitiatorType); } virtual nsresult GetAllRedirectsSameOrigin(bool *aAllRedirectsSameOrigin) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAllRedirectsSameOrigin(aAllRedirectsSameOrigin); } virtual nsresult SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetAllRedirectsSameOrigin(aAllRedirectsSameOrigin); } virtual nsresult GetAllRedirectsPassTimingAllowCheck(bool *aAllRedirectsPassTimingAllowCheck) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAllRedirectsPassTimingAllowCheck(aAllRedirectsPassTimingAllowCheck); } virtual nsresult SetAllRedirectsPassTimingAllowCheck(bool aAllRedirectsPassTimingAllowCheck) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetAllRedirectsPassTimingAllowCheck(aAllRedirectsPassTimingAllowCheck); } virtual nsresult TimingAllowCheck(nsIPrincipal *origin, bool *_retval) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->TimingAllowCheck(origin, _retval); } virtual nsresult GetCacheReadStart(mozilla::TimeStamp *aCacheReadStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadStart(aCacheReadStart); } virtual nsresult GetCacheReadEnd(mozilla::TimeStamp *aCacheReadEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadEnd(aCacheReadEnd); } virtual nsresult GetChannelCreationTime(PRTime *aChannelCreationTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetChannelCreationTime(aChannelCreationTime); } virtual nsresult GetAsyncOpenTime(PRTime *aAsyncOpenTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAsyncOpenTime(aAsyncOpenTime); } virtual nsresult GetDomainLookupStartTime(PRTime *aDomainLookupStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupStartTime(aDomainLookupStartTime); } virtual nsresult GetDomainLookupEndTime(PRTime *aDomainLookupEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupEndTime(aDomainLookupEndTime); } virtual nsresult GetConnectStartTime(PRTime *aConnectStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectStartTime(aConnectStartTime); } virtual nsresult GetConnectEndTime(PRTime *aConnectEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectEndTime(aConnectEndTime); } virtual nsresult GetRequestStartTime(PRTime *aRequestStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRequestStartTime(aRequestStartTime); } virtual nsresult GetResponseStartTime(PRTime *aResponseStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseStartTime(aResponseStartTime); } virtual nsresult GetResponseEndTime(PRTime *aResponseEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseEndTime(aResponseEndTime); } virtual nsresult GetCacheReadStartTime(PRTime *aCacheReadStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadStartTime(aCacheReadStartTime); } virtual nsresult GetCacheReadEndTime(PRTime *aCacheReadEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadEndTime(aCacheReadEndTime); } virtual nsresult GetRedirectStartTime(PRTime *aRedirectStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectStartTime(aRedirectStartTime); } virtual nsresult GetRedirectEndTime(PRTime *aRedirectEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectEndTime(aRedirectEndTime); }
+
+protected:
+  mozilla::UniquePtr<ProxyBehaviour> mBehaviour;
+
+private:
+  friend class imgCacheValidator;
+  friend imgRequestProxy* NewStaticProxy(imgRequestProxy* aThis);
+
+
+  RefPtr<ImageURL> mURI;
+
+
+
+
+  imgINotificationObserver* mListener;
+
+
+
+  nsCOMPtr<nsILoadGroup> mLoadGroup;
+
+  nsLoadFlags mLoadFlags;
+  uint32_t mLockCount;
+  uint32_t mAnimationConsumers;
+  bool mCanceled;
+  bool mIsInLoadGroup;
+  bool mListenerIsStrongRef;
+  bool mDecodeRequested;
+
+
+
+  bool mDeferNotifications;
+};
+
+
+
+class imgRequestProxyStatic : public imgRequestProxy
+{
+
+public:
+  imgRequestProxyStatic(Image* aImage, nsIPrincipal* aPrincipal);
+
+  virtual nsresult GetImagePrincipal(nsIPrincipal** aPrincipal) override;
+
+  using imgRequestProxy::Clone;
+
+  virtual nsresult Clone(imgINotificationObserver* aObserver,
+                         imgRequestProxy** aClone) override;
+
+protected:
+  friend imgRequestProxy* NewStaticProxy(imgRequestProxy*);
+
+
+
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+};
+# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Orientation.h" 1
+# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Orientation.h"
+namespace mozilla {
+namespace image {
+
+enum class Angle : uint8_t {
+  D0,
+  D90,
+  D180,
+  D270
+};
+
+enum class Flip : uint8_t {
+  Unflipped,
+  Horizontal
+};
+
+
+
+
+
+
+struct Orientation
+{
+  explicit Orientation(Angle aRotation = Angle::D0,
+                       Flip mFlip = Flip::Unflipped)
+    : rotation(aRotation)
+    , flip(mFlip)
+  { }
+
+  bool IsIdentity() const {
+    return (rotation == Angle::D0) && (flip == Flip::Unflipped);
+  }
+
+  bool SwapsWidthAndHeight() const {
+    return (rotation == Angle::D90) || (rotation == Angle::D270);
+  }
+
+  bool operator==(const Orientation& aOther) const {
+    return (rotation == aOther.rotation) && (flip == aOther.flip);
+  }
+
+  bool operator!=(const Orientation& aOther) const {
+    return !(*this == aOther);
+  }
+
+  Angle rotation;
+  Flip flip;
+};
+
+}
+}
+# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/CounterStyleManager.h" 1
+# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/CounterStyleManager.h"
+class nsPresContext;
+
+namespace mozilla {
+
+class WritingMode;
+
+typedef int32_t CounterValue;
+
+class CounterStyleManager;
+class AnonymousCounterStyle;
+
+struct NegativeType;
+struct PadType;
+
+class CounterStyle
+{
+protected:
+  explicit constexpr CounterStyle(int32_t aStyle)
+    : mStyle(aStyle)
+  {
+  }
+
+private:
+  CounterStyle(const CounterStyle& aOther) = delete;
+  void operator=(const CounterStyle& other) = delete;
+
+public:
+  int32_t GetStyle() const { return mStyle; }
+  bool IsNone() const { return mStyle == 0; }
+  bool IsCustomStyle() const { return mStyle == -1; }
+
+
+
+  bool IsDependentStyle() const;
+
+  virtual void GetStyleName(nsSubstring& aResult) = 0;
+  virtual void GetPrefix(nsSubstring& aResult) = 0;
+  virtual void GetSuffix(nsSubstring& aResult) = 0;
+  void GetCounterText(CounterValue aOrdinal,
+                      WritingMode aWritingMode,
+                      nsSubstring& aResult,
+                      bool& aIsRTL);
+  virtual void GetSpokenCounterText(CounterValue aOrdinal,
+                                    WritingMode aWritingMode,
+                                    nsSubstring& aResult,
+                                    bool& aIsBullet);
+
+
+
+  virtual bool IsBullet() = 0;
+
+  virtual void GetNegative(NegativeType& aResult) = 0;
+
+
+
+
+
+  virtual bool IsOrdinalInRange(CounterValue aOrdinal) = 0;
+
+
+
+
+
+  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) = 0;
+  virtual void GetPad(PadType& aResult) = 0;
+  virtual CounterStyle* GetFallback() = 0;
+  virtual uint8_t GetSpeakAs() = 0;
+  virtual bool UseNegativeSign() = 0;
+
+  virtual void CallFallbackStyle(CounterValue aOrdinal,
+                                 WritingMode aWritingMode,
+                                 nsSubstring& aResult,
+                                 bool& aIsRTL);
+  virtual bool GetInitialCounterText(CounterValue aOrdinal,
+                                     WritingMode aWritingMode,
+                                     nsSubstring& aResult,
+                                     bool& aIsRTL) = 0;
+
+  virtual AnonymousCounterStyle* AsAnonymous() { return nullptr; }
+
+  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
+
+protected:
+  int32_t mStyle;
+};
+
+class AnonymousCounterStyle final : public CounterStyle
+{
+public:
+  explicit AnonymousCounterStyle(const nsSubstring& aContent);
+  explicit AnonymousCounterStyle(const nsCSSValue::Array* aValue);
+
+  virtual void GetStyleName(nsAString& aResult) override;
+  virtual void GetPrefix(nsAString& aResult) override;
+  virtual void GetSuffix(nsAString& aResult) override;
+  virtual bool IsBullet() override;
+
+  virtual void GetNegative(NegativeType& aResult) override;
+  virtual bool IsOrdinalInRange(CounterValue aOrdinal) override;
+  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) override;
+  virtual void GetPad(PadType& aResult) override;
+  virtual CounterStyle* GetFallback() override;
+  virtual uint8_t GetSpeakAs() override;
+  virtual bool UseNegativeSign() override;
+
+  virtual bool GetInitialCounterText(CounterValue aOrdinal,
+                                     WritingMode aWritingMode,
+                                     nsSubstring& aResult,
+                                     bool& aIsRTL) override;
+
+  virtual AnonymousCounterStyle* AsAnonymous() override { return this; }
+
+  bool IsSingleString() const { return mSingleString; }
+  uint8_t GetSystem() const { return mSystem; }
+  const nsTArray<nsString>& GetSymbols() const { return mSymbols; }
+
+  public: MozExternalRefCountType AddRef(void) override { static_assert(!mozilla::IsDestructible<AnonymousCounterStyle>::value, "Reference-counted class " "AnonymousCounterStyle" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) override { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+private:
+  ~AnonymousCounterStyle() {}
+
+  bool mSingleString;
+  uint8_t mSystem;
+  nsTArray<nsString> mSymbols;
+};
+
+class CounterStyleManager final
+{
+private:
+  ~CounterStyleManager();
+public:
+  explicit CounterStyleManager(nsPresContext* aPresContext);
+
+  static void InitializeBuiltinCounterStyles();
+
+  void Disconnect();
+
+  bool IsInitial() const
+  {
+
+    return mCacheTable.Count() == 2;
+  }
+
+  CounterStyle* BuildCounterStyle(const nsSubstring& aName);
+
+  static CounterStyle* GetBuiltinStyle(int32_t aStyle);
+  static CounterStyle* GetNoneStyle()
+  {
+    return GetBuiltinStyle(0);
+  }
+  static CounterStyle* GetDecimalStyle()
+  {
+    return GetBuiltinStyle(4);
+  }
+
+
+
+
+
+  bool NotifyRuleChanged();
+
+  nsPresContext* PresContext() const { return mPresContext; }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<CounterStyleManager>::value, "Reference-counted class " "CounterStyleManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
+
+private:
+  nsPresContext* mPresContext;
+  nsRefPtrHashtable<nsStringHashKey, CounterStyle> mCacheTable;
+};
+
+}
+# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
+# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
+
+class nsIFrame;
+class nsIURI;
+class nsStyleContext;
+class nsTextFrame;
+class imgIContainer;
+struct nsStyleVisibility;
+namespace mozilla {
+namespace dom {
+class ImageTracker;
+}
+}
+# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+static_assert(int(mozilla::SheetType::Count) - 1 <=
+                (0xf0000000 >> 28),
+              "NS_RULE_NODE_LEVEL_MASK cannot fit SheetType");
+
+static_assert(0x000ffffff == (1 << nsStyleStructID_Length) - 1,
+              "NS_STYLE_INHERIT_MASK is not correct");
+
+static_assert((0x01000000 & 0x000ffffff) == 0,
+  "NS_RULE_NODE_IS_ANIMATION_RULE must not overlap the style struct bits.");
+
+namespace mozilla {
+
+struct Position {
+  using Coord = nsStyleCoord::CalcValue;
+
+  Coord mXPosition, mYPosition;
+
+
+  Position() {}
+
+
+
+  void SetInitialPercentValues(float aPercentVal);
+
+
+
+  void SetInitialZeroValues();
+
+
+
+  bool DependsOnPositioningAreaSize() const {
+    return mXPosition.mPercent != 0.0f || mYPosition.mPercent != 0.0f;
+  }
+
+  bool operator==(const Position& aOther) const {
+    return mXPosition == aOther.mXPosition &&
+      mYPosition == aOther.mYPosition;
+  }
+  bool operator!=(const Position& aOther) const {
+    return !(*this == aOther);
+  }
+};
+
+}
+
+
+struct nsStyleFont
+{
+  nsStyleFont(const nsFont& aFont, const nsPresContext* aContext);
+  nsStyleFont(const nsStyleFont& aStyleFont);
+  explicit nsStyleFont(const nsPresContext* aContext);
+  ~nsStyleFont() {
+                               ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  nsChangeHint CalcDifference(const nsStyleFont& aNewData) const;
+
+
+
+
+
+
+  static nscoord ZoomText(const nsPresContext* aPresContext, nscoord aSize);
+
+
+
+
+
+  static nscoord UnZoomText(nsPresContext* aPresContext, nscoord aSize);
+  static already_AddRefed<nsIAtom> GetLanguage(const nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleFont* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleFont, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  void EnableZoom(nsPresContext* aContext, bool aEnable);
+
+  nsFont mFont;
+  nscoord mSize;
+
+
+
+
+
+  uint8_t mGenericID;
+
+
+
+  int8_t mScriptLevel;
+
+  uint8_t mMathVariant;
+
+  uint8_t mMathDisplay;
+
+
+  uint8_t mMinFontSizeRatio;
+
+
+  bool mExplicitLanguage;
+
+
+
+  bool mAllowZoom;
+
+
+  nscoord mScriptUnconstrainedSize;
+  nscoord mScriptMinSize;
+  float mScriptSizeMultiplier;
+  nsCOMPtr<nsIAtom> mLanguage;
+};
+
+struct nsStyleGradientStop
+{
+  nsStyleCoord mLocation;
+  nscolor mColor;
+  bool mIsInterpolationHint;
+
+
+  bool operator==(const nsStyleGradientStop&) const = delete;
+  bool operator!=(const nsStyleGradientStop&) const = delete;
+};
+
+class nsStyleGradient final
+{
+public:
+  nsStyleGradient();
+  uint8_t mShape;
+  uint8_t mSize;
+
+  bool mRepeating;
+  bool mLegacySyntax;
+
+  nsStyleCoord mBgPosX;
+  nsStyleCoord mBgPosY;
+  nsStyleCoord mAngle;
+
+  nsStyleCoord mRadiusX;
+  nsStyleCoord mRadiusY;
+
+
+  nsTArray<nsStyleGradientStop> mStops;
+
+  bool operator==(const nsStyleGradient& aOther) const;
+  bool operator!=(const nsStyleGradient& aOther) const {
+    return !(*this == aOther);
+  }
+
+  bool IsOpaque();
+  bool HasCalc();
+  uint32_t Hash(PLDHashNumber aHash);
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleGradient>::value, "Reference-counted class " "nsStyleGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+private:
+
+  ~nsStyleGradient() {}
+
+  nsStyleGradient(const nsStyleGradient& aOther) = delete;
+  nsStyleGradient& operator=(const nsStyleGradient& aOther) = delete;
+};
+# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+class nsStyleImageRequest
+{
+public:
+
+
+
+
+  enum class Mode : uint8_t {
+
+
+
+
+
+
+
+    Track = 0x1,
+
+
+
+
+
+    Discard = 0x2,
+  };
+
+
+
+
+  nsStyleImageRequest(Mode aModeFlags,
+                      imgRequestProxy* aRequestProxy,
+                      mozilla::css::ImageValue* aImageValue,
+                      mozilla::dom::ImageTracker* aImageTracker);
+
+
+
+  nsStyleImageRequest(
+      Mode aModeFlags,
+      nsStringBuffer* aURLBuffer,
+      already_AddRefed<mozilla::css::URLExtraData> aExtraData);
+
+  bool Resolve(nsPresContext* aPresContext);
+  bool IsResolved() const { return mResolved; }
+
+  imgRequestProxy* get() {
+    do { } while (0);
+    do { } while (0);
+    return mRequestProxy.get();
+  }
+  const imgRequestProxy* get() const {
+    return const_cast<nsStyleImageRequest*>(this)->get();
+  }
+
+
+
+  bool DefinitelyEquals(const nsStyleImageRequest& aOther) const;
+
+  mozilla::css::ImageValue* GetImageValue() const { return mImageValue; }
+
+  already_AddRefed<nsIURI> GetImageURI() const;
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleImageRequest>::value, "Reference-counted class " "nsStyleImageRequest" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
+
+private:
+  ~nsStyleImageRequest();
+  nsStyleImageRequest& operator=(const nsStyleImageRequest& aOther) = delete;
+
+  void MaybeTrackAndLock();
+
+  RefPtr<imgRequestProxy> mRequestProxy;
+  RefPtr<mozilla::css::ImageValue> mImageValue;
+  RefPtr<mozilla::dom::ImageTracker> mImageTracker;
+
+
+  RefPtr<mozilla::dom::DocGroup> mDocGroup;
+
+  Mode mModeFlags;
+  bool mResolved;
+};
+
+inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator |(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) | U(b))); } inline nsStyleImageRequest::Mode& operator |=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator &(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) & U(b))); } inline nsStyleImageRequest::Mode& operator &=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator ^(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) ^ U(b))); } inline nsStyleImageRequest::Mode& operator ^=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator~(nsStyleImageRequest::Mode a) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(~(U(a)))); }
+
+enum nsStyleImageType {
+  eStyleImageType_Null,
+  eStyleImageType_Image,
+  eStyleImageType_Gradient,
+  eStyleImageType_Element
+};
+
+struct CachedBorderImageData
+{
+
+
+  void SetCachedSVGViewportSize(const mozilla::Maybe<nsSize>& aSVGViewportSize);
+  const mozilla::Maybe<nsSize>& GetCachedSVGViewportSize();
+  void PurgeCachedImages();
+  void SetSubImage(uint8_t aIndex, imgIContainer* aSubImage);
+  imgIContainer* GetSubImage(uint8_t aIndex);
+
+private:
+
+
+
+  mozilla::Maybe<nsSize> mCachedSVGViewportSize;
+  nsCOMArray<imgIContainer> mSubImages;
+};
+# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+struct nsStyleImage
+{
+  nsStyleImage();
+  ~nsStyleImage();
+  nsStyleImage(const nsStyleImage& aOther);
+  nsStyleImage& operator=(const nsStyleImage& aOther);
+
+  void SetNull();
+  void SetImageRequest(already_AddRefed<nsStyleImageRequest> aImage);
+  void SetGradientData(nsStyleGradient* aGradient);
+  void SetElementId(const char16_t* aElementId);
+  void SetCropRect(mozilla::UniquePtr<nsStyleSides> aCropRect);
+
+  void ResolveImage(nsPresContext* aContext) {
+    do { } while (0);
+    if (mType == eStyleImageType_Image && !mImage->IsResolved()) {
+      mImage->Resolve(aContext);
+    }
+  }
+
+  nsStyleImageType GetType() const {
+    return mType;
+  }
+  nsStyleImageRequest* GetImageRequest() const {
+    do { } while (0);
+    do { } while (0);
+    return mImage;
+  }
+  imgRequestProxy* GetImageData() const {
+    return GetImageRequest()->get();
+  }
+  nsStyleGradient* GetGradientData() const {
+    do { } while(0);
+    return mGradient;
+  }
+  const char16_t* GetElementId() const {
+    do { } while(0);
+    return mElementId;
+  }
+  const mozilla::UniquePtr<nsStyleSides>& GetCropRect() const {
+    do { } while(0);
+
+    return mCropRect;
+  }
+
+  already_AddRefed<nsIURI> GetImageURI() const;
+# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  bool ComputeActualCropRect(nsIntRect& aActualCropRect,
+                               bool* aIsEntireImage = nullptr) const;
+
+
+
+
+
+
+
+  bool StartDecoding() const;
+
+
+
+
+  bool IsOpaque() const;
+
+
+
+
+
+  bool IsComplete() const;
+
+
+
+
+
+  bool IsLoaded() const;
+
+
+
+
+  bool IsEmpty() const {
+
+
+
+
+
+
+
+    return mType == eStyleImageType_Null;
+  }
+
+  bool operator==(const nsStyleImage& aOther) const;
+  bool operator!=(const nsStyleImage& aOther) const {
+    return !(*this == aOther);
+  }
+
+  bool ImageDataEquals(const nsStyleImage& aOther) const
+  {
+    return GetType() == eStyleImageType_Image &&
+           aOther.GetType() == eStyleImageType_Image &&
+           GetImageData() == aOther.GetImageData();
+  }
+
+
+
+  inline void SetSubImage(uint8_t aIndex, imgIContainer* aSubImage) const;
+  inline imgIContainer* GetSubImage(uint8_t aIndex) const;
+  void PurgeCacheForViewportChange(
+    const mozilla::Maybe<nsSize>& aSVGViewportSize,
+    const bool aHasIntrinsicRatio) const;
+
+private:
+  void DoCopy(const nsStyleImage& aOther);
+  void EnsureCachedBIData() const;
+
+
+
+  mozilla::UniquePtr<CachedBorderImageData> mCachedBIData;
+
+  nsStyleImageType mType;
+  union {
+    nsStyleImageRequest* mImage;
+    nsStyleGradient* mGradient;
+    char16_t* mElementId;
+  };
+
+
+  mozilla::UniquePtr<nsStyleSides> mCropRect;
+};
+
+struct nsStyleColor
+{
+  explicit nsStyleColor(const nsPresContext* aContext);
+  nsStyleColor(const nsStyleColor& aOther);
+  ~nsStyleColor() {
+                                ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  nscolor CalcComplexColor(const mozilla::StyleComplexColor& aColor) const {
+    return mozilla::LinearBlendColors(aColor.mColor, mColor,
+                                      aColor.mForegroundRatio);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleColor& aNewData) const;
+
+  void* operator new(size_t sz, nsStyleColor* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleColor, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleColor();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleColor, this);
+  }
+
+
+
+  nscolor mColor;
+};
+
+struct nsStyleImageLayers {
+
+  enum {
+    shorthand = 0,
+    color,
+    image,
+    repeat,
+    positionX,
+    positionY,
+    clip,
+    origin,
+    size,
+    attachment,
+    maskMode,
+    composite
+  };
+
+  enum class LayerType : uint8_t {
+    Background = 0,
+    Mask
+  };
+
+  explicit nsStyleImageLayers(LayerType aType);
+  nsStyleImageLayers(const nsStyleImageLayers &aSource);
+  ~nsStyleImageLayers() {
+                                      ;
+  }
+
+  static bool IsInitialPositionForLayerType(mozilla::Position aPosition, LayerType aType);
+
+  struct Size;
+  friend struct Size;
+  struct Size {
+    struct Dimension : public nsStyleCoord::CalcValue {
+      nscoord ResolveLengthPercentage(nscoord aAvailable) const {
+        double d = double(mPercent) * double(aAvailable) + double(mLength);
+        if (d < 0.0) {
+          return 0;
+        }
+        return NSToCoordRoundWithClamp(float(d));
+      }
+    };
+    Dimension mWidth, mHeight;
+
+    bool IsInitialValue() const {
+      return mWidthType == eAuto && mHeightType == eAuto;
+    }
+
+    nscoord ResolveWidthLengthPercentage(const nsSize& aBgPositioningArea) const {
+      do { } while (0);
+
+      return mWidth.ResolveLengthPercentage(aBgPositioningArea.width);
+    }
+
+    nscoord ResolveHeightLengthPercentage(const nsSize& aBgPositioningArea) const {
+      do { } while (0);
+
+      return mHeight.ResolveLengthPercentage(aBgPositioningArea.height);
+    }
+
+
+
+
+
+    enum DimensionType {
+
+
+
+      eContain, eCover,
+
+      eAuto,
+      eLengthPercentage,
+      eDimensionType_COUNT
+    };
+    uint8_t mWidthType, mHeightType;
+
+
+
+
+    bool DependsOnPositioningAreaSize(const nsStyleImage& aImage) const;
+
+
+    Size() {}
+
+
+    void SetInitialValues();
+
+    bool operator==(const Size& aOther) const;
+    bool operator!=(const Size& aOther) const {
+      return !(*this == aOther);
+    }
+  };
+
+  struct Repeat;
+  friend struct Repeat;
+  struct Repeat {
+    uint8_t mXRepeat, mYRepeat;
+
+
+    Repeat() {}
+
+    bool IsInitialValue() const {
+      return mXRepeat == 0x03 &&
+             mYRepeat == 0x03;
+    }
+
+    bool DependsOnPositioningAreaSize() const {
+      return mXRepeat == 0x04 ||
+             mYRepeat == 0x04;
+    }
+
+
+    void SetInitialValues() {
+      mXRepeat = 0x03;
+      mYRepeat = 0x03;
+    }
+
+    bool operator==(const Repeat& aOther) const {
+      return mXRepeat == aOther.mXRepeat &&
+             mYRepeat == aOther.mYRepeat;
+    }
+    bool operator!=(const Repeat& aOther) const {
+      return !(*this == aOther);
+    }
+  };
+
+  struct Layer;
+  friend struct Layer;
+  struct Layer {
+    typedef mozilla::StyleGeometryBox StyleGeometryBox;
+
+    nsStyleImage mImage;
+    RefPtr<mozilla::css::URLValueData> mSourceURI;
+
+
+
+
+
+
+
+    mozilla::Position mPosition;
+    Size mSize;
+    StyleGeometryBox mClip;
+
+      StyleGeometryBox mOrigin;
+    uint8_t mAttachment;
+
+
+
+
+
+    uint8_t mBlendMode;
+
+
+
+
+
+    uint8_t mComposite;
+
+
+
+
+
+    uint8_t mMaskMode;
+
+
+
+
+
+    Repeat mRepeat;
+
+
+
+    Layer();
+    ~Layer();
+
+
+    void Initialize(LayerType aType);
+
+    void ResolveImage(nsPresContext* aContext) {
+      if (mImage.GetType() == eStyleImageType_Image) {
+        mImage.ResolveImage(aContext);
+      }
+    }
+
+
+
+
+
+
+    bool RenderingMightDependOnPositioningAreaSizeChange() const;
+
+
+    nsChangeHint CalcDifference(const Layer& aNewLayer) const;
+
+
+
+    bool operator==(const Layer& aOther) const;
+    bool operator!=(const Layer& aOther) const {
+      return !(*this == aOther);
+    }
+  };
+
+
+
+  uint32_t mAttachmentCount,
+           mClipCount,
+           mOriginCount,
+           mRepeatCount,
+           mPositionXCount,
+           mPositionYCount,
+           mImageCount,
+           mSizeCount,
+           mMaskModeCount,
+           mBlendModeCount,
+           mCompositeCount;
+# 816 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  nsStyleAutoArray<Layer> mLayers;
+
+  const Layer& BottomLayer() const { return mLayers[mImageCount - 1]; }
+
+  void ResolveImages(nsPresContext* aContext) {
+    for (uint32_t i = 0; i < mImageCount; ++i) {
+      mLayers[i].ResolveImage(aContext);
+    }
+  }
+
+  nsChangeHint CalcDifference(const nsStyleImageLayers& aNewLayers,
+                              nsStyleImageLayers::LayerType aType) const;
+
+  nsStyleImageLayers& operator=(const nsStyleImageLayers& aOther);
+  nsStyleImageLayers& operator=(nsStyleImageLayers&& aOther);
+  bool operator==(const nsStyleImageLayers& aOther) const;
+
+  static const nsCSSPropertyID kBackgroundLayerTable[];
+  static const nsCSSPropertyID kMaskLayerTable[];
+
+
+
+
+
+
+
+};
+
+struct nsStyleBackground {
+  explicit nsStyleBackground(const nsPresContext* aContext);
+  nsStyleBackground(const nsStyleBackground& aOther);
+  ~nsStyleBackground();
+
+
+
+
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleBackground* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleBackground, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStyleBackground& aNewData) const;
+
+
+  nscolor BackgroundColor(const nsIFrame* aFrame) const;
+  nscolor BackgroundColor(nsStyleContext* aContext) const;
+
+
+  bool IsTransparent(const nsIFrame* aFrame) const;
+  bool IsTransparent(nsStyleContext* aContext) const;
+
+
+
+
+
+  bool HasFixedBackground(nsIFrame* aFrame) const;
+
+
+
+  inline bool HasLocalBackground() const;
+
+  const nsStyleImageLayers::Layer& BottomLayer() const { return mImage.BottomLayer(); }
+
+  nsStyleImageLayers mImage;
+  mozilla::StyleComplexColor mBackgroundColor;
+};
+
+
+
+
+
+
+struct nsStyleMargin
+{
+  explicit nsStyleMargin(const nsPresContext* aContext);
+  nsStyleMargin(const nsStyleMargin& aMargin);
+  ~nsStyleMargin() {
+                                 ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleMargin* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleMargin, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStyleMargin& aNewData) const;
+
+  bool GetMargin(nsMargin& aMargin) const
+  {
+    if (!mMargin.ConvertsToLength()) {
+      return false;
+    }
+
+    int32_t side916 = mozilla::eSideTop; for (mozilla::Side side; side916 <= mozilla::eSideLeft && ((side = mozilla::Side(side916)), true); ++side916) {
+      aMargin.Side(side) = mMargin.ToLength(side);
+    }
+    return true;
+  }
+
+
+
+  inline bool HasBlockAxisAuto(mozilla::WritingMode aWM) const;
+  inline bool HasInlineAxisAuto(mozilla::WritingMode aWM) const;
+
+  nsStyleSides mMargin;
+};
+
+struct nsStylePadding
+{
+  explicit nsStylePadding(const nsPresContext* aContext);
+  nsStylePadding(const nsStylePadding& aPadding);
+  ~nsStylePadding() {
+                                  ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStylePadding* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStylePadding, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStylePadding& aNewData) const;
+
+  nsStyleSides mPadding;
+
+  bool IsWidthDependent() const {
+    return !mPadding.ConvertsToLength();
+  }
+
+  bool GetPadding(nsMargin& aPadding) const
+  {
+    if (!mPadding.ConvertsToLength()) {
+      return false;
+    }
+
+    int32_t side960 = mozilla::eSideTop; for (mozilla::Side side; side960 <= mozilla::eSideLeft && ((side = mozilla::Side(side960)), true); ++side960) {
+
+      aPadding.Side(side) = std::max(mPadding.ToLength(side), 0);
+    }
+    return true;
+  }
+};
+
+struct nsBorderColors
+{
+  nsBorderColors* mNext;
+  nscolor mColor;
+
+  nsBorderColors() : mNext(nullptr), mColor(((nscolor) ((255 << 24) | ((0)<<16) | ((0)<<8) | (0)))) {}
+  explicit nsBorderColors(const nscolor& aColor) : mNext(nullptr), mColor(aColor) {}
+  ~nsBorderColors();
+
+  nsBorderColors* Clone() const { return Clone(true); }
+
+  static bool Equal(const nsBorderColors* c1,
+                      const nsBorderColors* c2) {
+    if (c1 == c2) {
+      return true;
+    }
+    while (c1 && c2) {
+      if (c1->mColor != c2->mColor) {
+        return false;
+      }
+      c1 = c1->mNext;
+      c2 = c2->mNext;
+    }
+
+
+    return !c1 && !c2;
+  }
+
+private:
+  nsBorderColors* Clone(bool aDeep) const;
+};
+
+struct nsCSSShadowItem
+{
+  nscoord mXOffset;
+  nscoord mYOffset;
+  nscoord mRadius;
+  nscoord mSpread;
+
+  nscolor mColor;
+  bool mHasColor;
+  bool mInset;
+
+  nsCSSShadowItem() : mHasColor(false) {
+                                   ;
+  }
+  ~nsCSSShadowItem() {
+                                   ;
+  }
+
+  bool operator==(const nsCSSShadowItem& aOther) const {
+    return (mXOffset == aOther.mXOffset &&
+            mYOffset == aOther.mYOffset &&
+            mRadius == aOther.mRadius &&
+            mHasColor == aOther.mHasColor &&
+            mSpread == aOther.mSpread &&
+            mInset == aOther.mInset &&
+            (!mHasColor || mColor == aOther.mColor));
+  }
+  bool operator!=(const nsCSSShadowItem& aOther) const {
+    return !(*this == aOther);
+  }
+};
+
+class nsCSSShadowArray final
+{
+public:
+  void* operator new(size_t aBaseSize, uint32_t aArrayLen) {
+
+
+
+
+
+    return ::operator new(aBaseSize +
+                          (aArrayLen - 1) * sizeof(nsCSSShadowItem));
+  }
+
+  explicit nsCSSShadowArray(uint32_t aArrayLen) :
+    mLength(aArrayLen)
+  {
+    for (uint32_t i = 1; i < mLength; ++i) {
+
+
+      new (&mArray[i]) nsCSSShadowItem();
+    }
+  }
+
+private:
+
+  ~nsCSSShadowArray() {
+    for (uint32_t i = 1; i < mLength; ++i) {
+      mArray[i].~nsCSSShadowItem();
+    }
+  }
+
+public:
+  uint32_t Length() const { return mLength; }
+  nsCSSShadowItem* ShadowAt(uint32_t i) {
+    do { } while (0);
+    return &mArray[i];
+  }
+  const nsCSSShadowItem* ShadowAt(uint32_t i) const {
+    do { } while (0);
+    return &mArray[i];
+  }
+
+  bool HasShadowWithInset(bool aInset) {
+    for (uint32_t i = 0; i < mLength; ++i) {
+      if (mArray[i].mInset == aInset) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool operator==(const nsCSSShadowArray& aOther) const {
+    if (mLength != aOther.Length()) {
+      return false;
+    }
+
+    for (uint32_t i = 0; i < mLength; ++i) {
+      if (ShadowAt(i) != aOther.ShadowAt(i)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSShadowArray>::value, "Reference-counted class " "nsCSSShadowArray" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
+
+private:
+  uint32_t mLength;
+  nsCSSShadowItem mArray[1];
+};
+# 1118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+static bool IsVisibleBorderStyle(uint8_t aStyle)
+{
+  return (aStyle != 0 &&
+          aStyle != 9);
+}
+
+struct nsStyleBorder
+{
+  explicit nsStyleBorder(const nsPresContext* aContext);
+  nsStyleBorder(const nsStyleBorder& aBorder);
+  ~nsStyleBorder();
+
+
+
+
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleBorder* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleBorder, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStyleBorder& aNewData) const;
+
+  void EnsureBorderColors() {
+    if (!mBorderColors) {
+      mBorderColors = new nsBorderColors*[4];
+      if (mBorderColors) {
+        for (int32_t i = 0; i < 4; i++) {
+          mBorderColors[i] = nullptr;
+        }
+      }
+    }
+  }
+
+  void ClearBorderColors(mozilla::Side aSide) {
+    if (mBorderColors && mBorderColors[aSide]) {
+      delete mBorderColors[aSide];
+      mBorderColors[aSide] = nullptr;
+    }
+  }
+
+
+
+
+
+
+  bool HasVisibleStyle(mozilla::Side aSide) const
+  {
+    return IsVisibleBorderStyle(mBorderStyle[aSide]);
+  }
+
+
+  void SetBorderWidth(mozilla::Side aSide, nscoord aBorderWidth)
+  {
+    nscoord roundedWidth =
+      ((aBorderWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aBorderWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));
+    mBorder.Side(aSide) = roundedWidth;
+    if (HasVisibleStyle(aSide)) {
+      mComputedBorder.Side(aSide) = roundedWidth;
+    }
+  }
+
+
+
+
+  const nsMargin& GetComputedBorder() const
+  {
+    return mComputedBorder;
+  }
+
+  bool HasBorder() const
+  {
+    return mComputedBorder != nsMargin(0,0,0,0) || !mBorderImageSource.IsEmpty();
+  }
+
+
+
+
+
+  nscoord GetComputedBorderWidth(mozilla::Side aSide) const
+  {
+    return GetComputedBorder().Side(aSide);
+  }
+
+  uint8_t GetBorderStyle(mozilla::Side aSide) const
+  {
+    do { } while(0);
+    return mBorderStyle[aSide];
+  }
+
+  void SetBorderStyle(mozilla::Side aSide, uint8_t aStyle)
+  {
+    do { } while(0);
+    mBorderStyle[aSide] = aStyle;
+    mComputedBorder.Side(aSide) =
+      (HasVisibleStyle(aSide) ? mBorder.Side(aSide) : 0);
+  }
+
+  inline bool IsBorderImageLoaded() const
+  {
+    return mBorderImageSource.IsLoaded();
+  }
+
+  void ResolveImage(nsPresContext* aContext)
+  {
+    if (mBorderImageSource.GetType() == eStyleImageType_Image) {
+      mBorderImageSource.ResolveImage(aContext);
+    }
+  }
+
+  nsMargin GetImageOutset() const;
+
+  void GetCompositeColors(int32_t aIndex, nsBorderColors** aColors) const
+  {
+    if (!mBorderColors) {
+      *aColors = nullptr;
+    } else {
+      *aColors = mBorderColors[aIndex];
+    }
+  }
+
+  void AppendBorderColor(int32_t aIndex, nscolor aColor)
+  {
+    do { } while(0);
+    nsBorderColors* colorEntry = new nsBorderColors(aColor);
+    if (!mBorderColors[aIndex]) {
+      mBorderColors[aIndex] = colorEntry;
+    } else {
+      nsBorderColors* last = mBorderColors[aIndex];
+      while (last->mNext) {
+        last = last->mNext;
+      }
+      last->mNext = colorEntry;
+    }
+  }
+
+  imgIRequest* GetBorderImageRequest() const
+  {
+    if (mBorderImageSource.GetType() == eStyleImageType_Image) {
+      return mBorderImageSource.GetImageData();
+    }
+    return nullptr;
+  }
+
+public:
+  nsBorderColors** mBorderColors;
+  nsStyleCorners mBorderRadius;
+  nsStyleImage mBorderImageSource;
+  nsStyleSides mBorderImageSlice;
+  nsStyleSides mBorderImageWidth;
+  nsStyleSides mBorderImageOutset;
+
+  uint8_t mBorderImageFill;
+  uint8_t mBorderImageRepeatH;
+  uint8_t mBorderImageRepeatV;
+  mozilla::StyleFloatEdge mFloatEdge;
+  mozilla::StyleBoxDecorationBreak mBoxDecorationBreak;
+
+protected:
+  uint8_t mBorderStyle[4];
+
+public:
+
+
+  union {
+    struct {
+      mozilla::StyleComplexColor mBorderTopColor;
+      mozilla::StyleComplexColor mBorderRightColor;
+      mozilla::StyleComplexColor mBorderBottomColor;
+      mozilla::StyleComplexColor mBorderLeftColor;
+    };
+    mozilla::StyleComplexColor mBorderColor[4];
+  };
+
+  static mozilla::StyleComplexColor nsStyleBorder::*
+  BorderColorFieldFor(mozilla::Side aSide) {
+    switch (aSide) {
+      case mozilla::eSideTop:
+        return &nsStyleBorder::mBorderTopColor;
+      case mozilla::eSideRight:
+        return &nsStyleBorder::mBorderRightColor;
+      case mozilla::eSideBottom:
+        return &nsStyleBorder::mBorderBottomColor;
+      case mozilla::eSideLeft:
+        return &nsStyleBorder::mBorderLeftColor;
+    }
+    do { } while (0);
+    return nullptr;
+  }
+
+protected:
+
+
+
+
+
+
+  nsMargin mComputedBorder;
+# 1331 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  nsMargin mBorder;
+
+private:
+  nscoord mTwipsPerPixel;
+
+  nsStyleBorder& operator=(const nsStyleBorder& aOther) = delete;
+};
+# 1346 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+static_assert(__builtin_offsetof(nsStyleBorder, mBorderTopColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideTop) * sizeof(mozilla::StyleComplexColor), "mBorder" "Top" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Top" "]");
+static_assert(__builtin_offsetof(nsStyleBorder, mBorderRightColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideRight) * sizeof(mozilla::StyleComplexColor), "mBorder" "Right" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Right" "]");
+static_assert(__builtin_offsetof(nsStyleBorder, mBorderBottomColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideBottom) * sizeof(mozilla::StyleComplexColor), "mBorder" "Bottom" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Bottom" "]");
+static_assert(__builtin_offsetof(nsStyleBorder, mBorderLeftColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideLeft) * sizeof(mozilla::StyleComplexColor), "mBorder" "Left" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Left" "]");
+
+
+
+struct nsStyleOutline
+{
+  explicit nsStyleOutline(const nsPresContext* aContext);
+  nsStyleOutline(const nsStyleOutline& aOutline);
+  ~nsStyleOutline() {
+                                  ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleOutline* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleOutline, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleOutline();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleOutline, this);
+  }
+
+  void RecalcData();
+  nsChangeHint CalcDifference(const nsStyleOutline& aNewData) const;
+
+  nsStyleCorners mOutlineRadius;
+
+
+
+
+
+
+  nscoord mOutlineWidth;
+  nscoord mOutlineOffset;
+  mozilla::StyleComplexColor mOutlineColor;
+  uint8_t mOutlineStyle;
+
+  nscoord GetOutlineWidth() const
+  {
+    return mActualOutlineWidth;
+  }
+
+  bool ShouldPaintOutline() const
+  {
+    return mOutlineStyle == 10 ||
+           (GetOutlineWidth() > 0 &&
+            mOutlineStyle != 0);
+  }
+
+protected:
+
+
+
+  nscoord mActualOutlineWidth;
+  nscoord mTwipsPerPixel;
+};
+
+
+
+
+
+
+
+class nsStyleQuoteValues
+{
+public:
+  typedef nsTArray<std::pair<nsString, nsString>> QuotePairArray;
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleQuoteValues>::value, "Reference-counted class " "nsStyleQuoteValues" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
+  QuotePairArray mQuotePairs;
+
+private:
+  ~nsStyleQuoteValues() {}
+};
+
+struct nsStyleList
+{
+  explicit nsStyleList(const nsPresContext* aContext);
+  nsStyleList(const nsStyleList& aStyleList);
+  ~nsStyleList();
+
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleList* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleList, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleList();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleList, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleList& aNewData) const;
+
+  static void Shutdown() {
+    sInitialQuotes = nullptr;
+    sNoneQuotes = nullptr;
+  }
+
+  imgRequestProxy* GetListStyleImage() const
+  {
+    return mListStyleImage ? mListStyleImage->get() : nullptr;
+  }
+
+  already_AddRefed<nsIURI> GetListStyleImageURI() const;
+
+  void GetListStyleType(nsSubstring& aType) const { mCounterStyle->GetStyleName(aType); }
+  mozilla::CounterStyle* GetCounterStyle() const
+  {
+    return mCounterStyle.get();
+  }
+  void SetCounterStyle(mozilla::CounterStyle* aStyle)
+  {
+
+
+    do { } while (0);
+    mCounterStyle = aStyle;
+  }
+  void SetListStyleType(const nsSubstring& aType,
+                        nsPresContext* aPresContext)
+  {
+    SetCounterStyle(aPresContext->CounterStyleManager()->BuildCounterStyle(aType));
+  }
+
+  const nsStyleQuoteValues::QuotePairArray& GetQuotePairs() const;
+
+  void SetQuotesInherit(const nsStyleList* aOther);
+  void SetQuotesInitial();
+  void SetQuotesNone();
+  void SetQuotes(nsStyleQuoteValues::QuotePairArray&& aValues);
+
+  uint8_t mListStylePosition;
+  RefPtr<nsStyleImageRequest> mListStyleImage;
+private:
+  RefPtr<mozilla::CounterStyle> mCounterStyle;
+  RefPtr<nsStyleQuoteValues> mQuotes;
+  nsStyleList& operator=(const nsStyleList& aOther) = delete;
+public:
+  nsRect mImageRegion;
+
+private:
+
+  static mozilla::StaticRefPtr<nsStyleQuoteValues> sInitialQuotes;
+  static mozilla::StaticRefPtr<nsStyleQuoteValues> sNoneQuotes;
+};
+
+struct nsStyleGridLine
+{
+
+
+  bool mHasSpan;
+  int32_t mInteger;
+  nsString mLineName;
+
+
+
+
+  static const int32_t kMinLine = -10000;
+  static const int32_t kMaxLine = 10000;
+
+  nsStyleGridLine()
+    : mHasSpan(false)
+    , mInteger(0)
+
+  {
+  }
+
+  nsStyleGridLine(const nsStyleGridLine& aOther)
+  {
+    (*this) = aOther;
+  }
+
+  void operator=(const nsStyleGridLine& aOther)
+  {
+    mHasSpan = aOther.mHasSpan;
+    mInteger = aOther.mInteger;
+    mLineName = aOther.mLineName;
+  }
+
+  bool operator!=(const nsStyleGridLine& aOther) const
+  {
+    return mHasSpan != aOther.mHasSpan ||
+           mInteger != aOther.mInteger ||
+           mLineName != aOther.mLineName;
+  }
+
+  void SetToInteger(uint32_t value)
+  {
+    mHasSpan = false;
+    mInteger = value;
+    mLineName.Truncate();
+  }
+
+  void SetAuto()
+  {
+    mHasSpan = false;
+    mInteger = 0;
+    mLineName.Truncate();
+  }
+
+  bool IsAuto() const
+  {
+    bool haveInitialValues = mInteger == 0 && mLineName.IsEmpty();
+    do { } while (0);
+
+
+    return haveInitialValues;
+  }
+};
+# 1602 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+struct nsStyleGridTemplate
+{
+  nsTArray<nsTArray<nsString>> mLineNameLists;
+  nsTArray<nsStyleCoord> mMinTrackSizingFunctions;
+  nsTArray<nsStyleCoord> mMaxTrackSizingFunctions;
+  nsTArray<nsString> mRepeatAutoLineNameListBefore;
+  nsTArray<nsString> mRepeatAutoLineNameListAfter;
+  int16_t mRepeatAutoIndex;
+  bool mIsAutoFill : 1;
+  bool mIsSubgrid : 1;
+
+  nsStyleGridTemplate()
+    : mRepeatAutoIndex(-1)
+    , mIsAutoFill(false)
+    , mIsSubgrid(false)
+  {
+  }
+
+  inline bool operator!=(const nsStyleGridTemplate& aOther) const {
+    return
+      mIsSubgrid != aOther.mIsSubgrid ||
+      mLineNameLists != aOther.mLineNameLists ||
+      mMinTrackSizingFunctions != aOther.mMinTrackSizingFunctions ||
+      mMaxTrackSizingFunctions != aOther.mMaxTrackSizingFunctions ||
+      mIsAutoFill != aOther.mIsAutoFill ||
+      mRepeatAutoIndex != aOther.mRepeatAutoIndex ||
+      mRepeatAutoLineNameListBefore != aOther.mRepeatAutoLineNameListBefore ||
+      mRepeatAutoLineNameListAfter != aOther.mRepeatAutoLineNameListAfter;
+  }
+
+  bool HasRepeatAuto() const {
+    return mRepeatAutoIndex != -1;
+  }
+
+  bool IsRepeatAutoIndex(uint32_t aIndex) const {
+    do { } while (0);
+    return int32_t(aIndex) == mRepeatAutoIndex;
+  }
+};
+
+struct nsStylePosition
+{
+  explicit nsStylePosition(const nsPresContext* aContext);
+  nsStylePosition(const nsStylePosition& aOther);
+  ~nsStylePosition();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStylePosition* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStylePosition, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStylePosition();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStylePosition, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStylePosition& aNewData,
+                              const nsStyleVisibility* aOldStyleVisibility) const;
+
+
+
+
+
+  uint8_t UsedAlignSelf(nsStyleContext* aParent) const;
+
+
+
+
+
+  uint8_t ComputedJustifyItems(nsStyleContext* aParent) const;
+
+
+
+
+
+  uint8_t UsedJustifySelf(nsStyleContext* aParent) const;
+
+  mozilla::Position mObjectPosition;
+  nsStyleSides mOffset;
+  nsStyleCoord mWidth;
+  nsStyleCoord mMinWidth;
+  nsStyleCoord mMaxWidth;
+  nsStyleCoord mHeight;
+  nsStyleCoord mMinHeight;
+  nsStyleCoord mMaxHeight;
+  nsStyleCoord mFlexBasis;
+  nsStyleCoord mGridAutoColumnsMin;
+  nsStyleCoord mGridAutoColumnsMax;
+  nsStyleCoord mGridAutoRowsMin;
+  nsStyleCoord mGridAutoRowsMax;
+  uint8_t mGridAutoFlow;
+  mozilla::StyleBoxSizing mBoxSizing;
+
+  uint16_t mAlignContent;
+  uint8_t mAlignItems;
+  uint8_t mAlignSelf;
+  uint16_t mJustifyContent;
+private:
+  friend class nsRuleNode;
+
+
+
+
+  uint8_t mJustifyItems;
+public:
+  uint8_t mJustifySelf;
+  uint8_t mFlexDirection;
+  uint8_t mFlexWrap;
+  uint8_t mObjectFit;
+  int32_t mOrder;
+  float mFlexGrow;
+  float mFlexShrink;
+  nsStyleCoord mZIndex;
+  nsStyleGridTemplate mGridTemplateColumns;
+  nsStyleGridTemplate mGridTemplateRows;
+
+
+  RefPtr<mozilla::css::GridTemplateAreasValue> mGridTemplateAreas;
+
+  nsStyleGridLine mGridColumnStart;
+  nsStyleGridLine mGridColumnEnd;
+  nsStyleGridLine mGridRowStart;
+  nsStyleGridLine mGridRowEnd;
+  nsStyleCoord mGridColumnGap;
+  nsStyleCoord mGridRowGap;
+
+
+
+
+
+
+  bool WidthDependsOnContainer() const
+    {
+      return mWidth.GetUnit() == eStyleUnit_Auto ||
+        WidthCoordDependsOnContainer(mWidth);
+    }
+# 1749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  bool MinWidthDependsOnContainer() const
+    { return WidthCoordDependsOnContainer(mMinWidth); }
+  bool MaxWidthDependsOnContainer() const
+    { return WidthCoordDependsOnContainer(mMaxWidth); }
+# 1761 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  bool HeightDependsOnContainer() const
+    {
+      return mHeight.GetUnit() == eStyleUnit_Auto ||
+        HeightCoordDependsOnContainer(mHeight);
+    }
+
+
+
+  bool MinHeightDependsOnContainer() const
+    { return HeightCoordDependsOnContainer(mMinHeight); }
+  bool MaxHeightDependsOnContainer() const
+    { return HeightCoordDependsOnContainer(mMaxHeight); }
+
+  bool OffsetHasPercent(mozilla::Side aSide) const
+  {
+    return mOffset.Get(aSide).HasPercent();
+  }
+
+
+
+
+
+  inline nsStyleCoord& ISize(mozilla::WritingMode aWM);
+  inline nsStyleCoord& MinISize(mozilla::WritingMode aWM);
+  inline nsStyleCoord& MaxISize(mozilla::WritingMode aWM);
+  inline nsStyleCoord& BSize(mozilla::WritingMode aWM);
+  inline nsStyleCoord& MinBSize(mozilla::WritingMode aWM);
+  inline nsStyleCoord& MaxBSize(mozilla::WritingMode aWM);
+  inline const nsStyleCoord& ISize(mozilla::WritingMode aWM) const;
+  inline const nsStyleCoord& MinISize(mozilla::WritingMode aWM) const;
+  inline const nsStyleCoord& MaxISize(mozilla::WritingMode aWM) const;
+  inline const nsStyleCoord& BSize(mozilla::WritingMode aWM) const;
+  inline const nsStyleCoord& MinBSize(mozilla::WritingMode aWM) const;
+  inline const nsStyleCoord& MaxBSize(mozilla::WritingMode aWM) const;
+  inline bool ISizeDependsOnContainer(mozilla::WritingMode aWM) const;
+  inline bool MinISizeDependsOnContainer(mozilla::WritingMode aWM) const;
+  inline bool MaxISizeDependsOnContainer(mozilla::WritingMode aWM) const;
+  inline bool BSizeDependsOnContainer(mozilla::WritingMode aWM) const;
+  inline bool MinBSizeDependsOnContainer(mozilla::WritingMode aWM) const;
+  inline bool MaxBSizeDependsOnContainer(mozilla::WritingMode aWM) const;
+
+private:
+  static bool WidthCoordDependsOnContainer(const nsStyleCoord &aCoord);
+  static bool HeightCoordDependsOnContainer(const nsStyleCoord &aCoord)
+    { return aCoord.HasPercent(); }
+};
+
+struct nsStyleTextOverflowSide
+{
+  nsStyleTextOverflowSide() : mType(0) {}
+
+  bool operator==(const nsStyleTextOverflowSide& aOther) const {
+    return mType == aOther.mType &&
+           (mType != 2 ||
+            mString == aOther.mString);
+  }
+  bool operator!=(const nsStyleTextOverflowSide& aOther) const {
+    return !(*this == aOther);
+  }
+
+  nsString mString;
+  uint8_t mType;
+};
+
+struct nsStyleTextOverflow
+{
+  nsStyleTextOverflow() : mLogicalDirections(true) {}
+  bool operator==(const nsStyleTextOverflow& aOther) const {
+    return mLeft == aOther.mLeft && mRight == aOther.mRight;
+  }
+  bool operator!=(const nsStyleTextOverflow& aOther) const {
+    return !(*this == aOther);
+  }
+
+
+  const nsStyleTextOverflowSide& GetLeft(uint8_t aDirection) const {
+    do { } while(0);
+
+    return !mLogicalDirections || aDirection == 0 ?
+             mLeft : mRight;
+  }
+
+
+  const nsStyleTextOverflowSide& GetRight(uint8_t aDirection) const {
+    do { } while(0);
+
+    return !mLogicalDirections || aDirection == 0 ?
+             mRight : mLeft;
+  }
+
+
+  const nsStyleTextOverflowSide* GetFirstValue() const {
+    return mLogicalDirections ? &mRight : &mLeft;
+  }
+
+
+  const nsStyleTextOverflowSide* GetSecondValue() const {
+    return mLogicalDirections ? nullptr : &mRight;
+  }
+
+  nsStyleTextOverflowSide mLeft;
+  nsStyleTextOverflowSide mRight;
+  bool mLogicalDirections;
+};
+
+struct nsStyleTextReset
+{
+  explicit nsStyleTextReset(const nsPresContext* aContext);
+  nsStyleTextReset(const nsStyleTextReset& aOther);
+  ~nsStyleTextReset();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleTextReset* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTextReset, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleTextReset();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTextReset, this);
+  }
+
+
+
+  bool HasTextDecorationLines() const {
+    return mTextDecorationLine != 0 &&
+           mTextDecorationLine != 0x20;
+  }
+
+  nsChangeHint CalcDifference(const nsStyleTextReset& aNewData) const;
+
+  nsStyleTextOverflow mTextOverflow;
+
+  uint8_t mTextDecorationLine;
+  uint8_t mTextDecorationStyle;
+  uint8_t mUnicodeBidi;
+  nscoord mInitialLetterSink;
+  float mInitialLetterSize;
+  mozilla::StyleComplexColor mTextDecorationColor;
+};
+
+struct nsStyleText
+{
+  explicit nsStyleText(const nsPresContext* aContext);
+  nsStyleText(const nsStyleText& aOther);
+  ~nsStyleText();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleText* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleText, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleText();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleText, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleText& aNewData) const;
+
+  uint8_t mTextAlign;
+  uint8_t mTextAlignLast;
+  bool mTextAlignTrue : 1;
+  bool mTextAlignLastTrue : 1;
+  mozilla::StyleTextJustify mTextJustify;
+  uint8_t mTextTransform;
+  uint8_t mWhiteSpace;
+  uint8_t mWordBreak;
+  uint8_t mOverflowWrap;
+  mozilla::StyleHyphens mHyphens;
+  uint8_t mRubyAlign;
+  uint8_t mRubyPosition;
+  uint8_t mTextSizeAdjust;
+  uint8_t mTextCombineUpright;
+  uint8_t mControlCharacterVisibility;
+  uint8_t mTextEmphasisPosition;
+  uint8_t mTextEmphasisStyle;
+  uint8_t mTextRendering;
+  mozilla::StyleComplexColor mTextEmphasisColor;
+  mozilla::StyleComplexColor mWebkitTextFillColor;
+  mozilla::StyleComplexColor mWebkitTextStrokeColor;
+
+  nsStyleCoord mTabSize;
+  nsStyleCoord mWordSpacing;
+  nsStyleCoord mLetterSpacing;
+  nsStyleCoord mLineHeight;
+  nsStyleCoord mTextIndent;
+  nscoord mWebkitTextStrokeWidth;
+
+  RefPtr<nsCSSShadowArray> mTextShadow;
+
+  nsString mTextEmphasisStyleString;
+
+  bool WhiteSpaceIsSignificant() const {
+    return mWhiteSpace == 1 ||
+           mWhiteSpace == 3 ||
+           mWhiteSpace == 5;
+  }
+
+  bool NewlineIsSignificantStyle() const {
+    return mWhiteSpace == 1 ||
+           mWhiteSpace == 3 ||
+           mWhiteSpace == 4;
+  }
+
+  bool WhiteSpaceOrNewlineIsSignificant() const {
+    return mWhiteSpace == 1 ||
+           mWhiteSpace == 3 ||
+           mWhiteSpace == 4 ||
+           mWhiteSpace == 5;
+  }
+
+  bool TabIsSignificant() const {
+    return mWhiteSpace == 1 ||
+           mWhiteSpace == 3;
+  }
+
+  bool WhiteSpaceCanWrapStyle() const {
+    return mWhiteSpace == 0 ||
+           mWhiteSpace == 3 ||
+           mWhiteSpace == 4;
+  }
+
+  bool WordCanWrapStyle() const {
+    return WhiteSpaceCanWrapStyle() &&
+           mOverflowWrap == 1;
+  }
+
+  bool HasTextEmphasis() const {
+    return !mTextEmphasisStyleString.IsEmpty();
+  }
+
+  bool HasWebkitTextStroke() const {
+    return mWebkitTextStrokeWidth > 0;
+  }
+
+
+  inline bool HasTextShadow() const;
+  inline nsCSSShadowArray* GetTextShadow() const;
+
+
+
+
+
+  inline bool NewlineIsSignificant(const nsTextFrame* aContextFrame) const;
+  inline bool WhiteSpaceCanWrap(const nsIFrame* aContextFrame) const;
+  inline bool WordCanWrap(const nsIFrame* aContextFrame) const;
+
+  mozilla::LogicalSide TextEmphasisSide(mozilla::WritingMode aWM) const;
+};
+
+struct nsStyleImageOrientation
+{
+  static nsStyleImageOrientation CreateAsAngleAndFlip(double aRadians,
+                                                      bool aFlip) {
+    uint8_t orientation(0);
+
+
+    double roundedAngle = fmod(aRadians, 2 * 3.14159265358979323846);
+    if (roundedAngle < 0.25 * 3.14159265358979323846) { orientation = ANGLE_0; }
+    else if (roundedAngle < 0.75 * 3.14159265358979323846) { orientation = ANGLE_90; }
+    else if (roundedAngle < 1.25 * 3.14159265358979323846) { orientation = ANGLE_180;}
+    else if (roundedAngle < 1.75 * 3.14159265358979323846) { orientation = ANGLE_270;}
+    else { orientation = ANGLE_0; }
+
+
+    if (aFlip) {
+      orientation |= FLIP_MASK;
+    }
+
+    return nsStyleImageOrientation(orientation);
+  }
+
+  static nsStyleImageOrientation CreateAsFlip() {
+    return nsStyleImageOrientation(FLIP_MASK);
+  }
+
+  static nsStyleImageOrientation CreateAsFromImage() {
+    return nsStyleImageOrientation(FROM_IMAGE_MASK);
+  }
+
+
+  nsStyleImageOrientation() : mOrientation(0) { }
+
+  bool IsDefault() const { return mOrientation == 0; }
+  bool IsFlipped() const { return mOrientation & FLIP_MASK; }
+  bool IsFromImage() const { return mOrientation & FROM_IMAGE_MASK; }
+  bool SwapsWidthAndHeight() const {
+    uint8_t angle = mOrientation & ORIENTATION_MASK;
+    return (angle == ANGLE_90) || (angle == ANGLE_270);
+  }
+
+  mozilla::image::Angle Angle() const {
+    switch (mOrientation & ORIENTATION_MASK) {
+      case ANGLE_0: return mozilla::image::Angle::D0;
+      case ANGLE_90: return mozilla::image::Angle::D90;
+      case ANGLE_180: return mozilla::image::Angle::D180;
+      case ANGLE_270: return mozilla::image::Angle::D270;
+      default:
+        do { } while(0);
+        return mozilla::image::Angle::D0;
+    }
+  }
+
+  nsStyleCoord AngleAsCoord() const {
+    switch (mOrientation & ORIENTATION_MASK) {
+      case ANGLE_0: return nsStyleCoord(0.0f, eStyleUnit_Degree);
+      case ANGLE_90: return nsStyleCoord(90.0f, eStyleUnit_Degree);
+      case ANGLE_180: return nsStyleCoord(180.0f, eStyleUnit_Degree);
+      case ANGLE_270: return nsStyleCoord(270.0f, eStyleUnit_Degree);
+      default:
+        do { } while(0);
+        return nsStyleCoord();
+    }
+  }
+
+  bool operator==(const nsStyleImageOrientation& aOther) const {
+    return aOther.mOrientation == mOrientation;
+  }
+
+  bool operator!=(const nsStyleImageOrientation& aOther) const {
+    return !(*this == aOther);
+  }
+
+protected:
+  enum Bits {
+    ORIENTATION_MASK = 0x1 | 0x2,
+    FLIP_MASK = 0x4,
+    FROM_IMAGE_MASK = 0x8,
+  };
+
+  enum Angles {
+    ANGLE_0 = 0,
+    ANGLE_90 = 1,
+    ANGLE_180 = 2,
+    ANGLE_270 = 3,
+  };
+
+  explicit nsStyleImageOrientation(uint8_t aOrientation)
+    : mOrientation(aOrientation)
+  { }
+
+  uint8_t mOrientation;
+};
+
+struct nsStyleVisibility
+{
+  explicit nsStyleVisibility(const nsPresContext* aContext);
+  nsStyleVisibility(const nsStyleVisibility& aVisibility);
+  ~nsStyleVisibility() {
+                                     ;
+  }
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleVisibility* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleVisibility, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleVisibility();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleVisibility, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleVisibility& aNewData) const;
+
+  nsStyleImageOrientation mImageOrientation;
+  uint8_t mDirection;
+  uint8_t mVisible;
+  uint8_t mImageRendering;
+  uint8_t mWritingMode;
+  uint8_t mTextOrientation;
+  uint8_t mColorAdjust;
+
+  bool IsVisible() const {
+    return (mVisible == 1);
+  }
+
+  bool IsVisibleOrCollapsed() const {
+    return ((mVisible == 1) ||
+            (mVisible == 2));
+  }
+};
+
+struct nsTimingFunction
+{
+
+  enum class Type {
+    Ease,
+    Linear,
+    EaseIn,
+    EaseOut,
+    EaseInOut,
+    StepStart,
+    StepEnd,
+    CubicBezier,
+    Frames,
+  };
+
+
+
+  static bool IsSplineType(Type aType)
+  {
+    return aType != Type::StepStart &&
+           aType != Type::StepEnd &&
+           aType != Type::Frames;
+  }
+
+  explicit nsTimingFunction(int32_t aTimingFunctionType
+                              = 0)
+  {
+    AssignFromKeyword(aTimingFunctionType);
+  }
+
+  nsTimingFunction(float x1, float y1, float x2, float y2)
+    : mType(Type::CubicBezier)
+  {
+    mFunc.mX1 = x1;
+    mFunc.mY1 = y1;
+    mFunc.mX2 = x2;
+    mFunc.mY2 = y2;
+  }
+
+  enum class Keyword { Implicit, Explicit };
+
+  nsTimingFunction(Type aType, uint32_t aStepsOrFrames)
+    : mType(aType)
+  {
+    do { } while (0);
+
+
+
+    mStepsOrFrames = aStepsOrFrames;
+  }
+
+  nsTimingFunction(const nsTimingFunction& aOther)
+  {
+    *this = aOther;
+  }
+
+  Type mType;
+  union {
+    struct {
+      float mX1;
+      float mY1;
+      float mX2;
+      float mY2;
+    } mFunc;
+    struct {
+      uint32_t mStepsOrFrames;
+    };
+  };
+
+  nsTimingFunction&
+  operator=(const nsTimingFunction& aOther)
+  {
+    if (&aOther == this) {
+      return *this;
+    }
+
+    mType = aOther.mType;
+
+    if (HasSpline()) {
+      mFunc.mX1 = aOther.mFunc.mX1;
+      mFunc.mY1 = aOther.mFunc.mY1;
+      mFunc.mX2 = aOther.mFunc.mX2;
+      mFunc.mY2 = aOther.mFunc.mY2;
+    } else {
+      mStepsOrFrames = aOther.mStepsOrFrames;
+    }
+
+    return *this;
+  }
+
+  bool operator==(const nsTimingFunction& aOther) const
+  {
+    if (mType != aOther.mType) {
+      return false;
+    }
+    if (HasSpline()) {
+      return mFunc.mX1 == aOther.mFunc.mX1 && mFunc.mY1 == aOther.mFunc.mY1 &&
+             mFunc.mX2 == aOther.mFunc.mX2 && mFunc.mY2 == aOther.mFunc.mY2;
+    }
+    return mStepsOrFrames == aOther.mStepsOrFrames;
+  }
+
+  bool operator!=(const nsTimingFunction& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  bool HasSpline() const { return IsSplineType(mType); }
+
+private:
+  void AssignFromKeyword(int32_t aTimingFunctionType);
+};
+
+namespace mozilla {
+
+struct StyleTransition
+{
+  StyleTransition() { }
+  explicit StyleTransition(const StyleTransition& aCopy);
+
+  void SetInitialValues();
+
+
+
+  const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
+  float GetDelay() const { return mDelay; }
+  float GetDuration() const { return mDuration; }
+  nsCSSPropertyID GetProperty() const { return mProperty; }
+  nsIAtom* GetUnknownProperty() const { return mUnknownProperty; }
+
+  float GetCombinedDuration() const {
+
+    return std::max(mDuration, 0.0f) + mDelay;
+  }
+
+  void SetTimingFunction(const nsTimingFunction& aTimingFunction)
+    { mTimingFunction = aTimingFunction; }
+  void SetDelay(float aDelay) { mDelay = aDelay; }
+  void SetDuration(float aDuration) { mDuration = aDuration; }
+  void SetProperty(nsCSSPropertyID aProperty)
+    {
+      do { } while(0);
+
+
+      mProperty = aProperty;
+    }
+  void SetUnknownProperty(nsCSSPropertyID aProperty,
+                          const nsAString& aPropertyString);
+  void CopyPropertyFrom(const StyleTransition& aOther)
+    {
+      mProperty = aOther.mProperty;
+      mUnknownProperty = aOther.mUnknownProperty;
+    }
+
+  nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
+
+  bool operator==(const StyleTransition& aOther) const;
+  bool operator!=(const StyleTransition& aOther) const
+    { return !(*this == aOther); }
+
+private:
+  nsTimingFunction mTimingFunction;
+  float mDuration;
+  float mDelay;
+  nsCSSPropertyID mProperty;
+  nsCOMPtr<nsIAtom> mUnknownProperty;
+
+
+};
+
+struct StyleAnimation
+{
+  StyleAnimation() { }
+  explicit StyleAnimation(const StyleAnimation& aCopy);
+
+  void SetInitialValues();
+
+
+
+  const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
+  float GetDelay() const { return mDelay; }
+  float GetDuration() const { return mDuration; }
+  const nsString& GetName() const { return mName; }
+  dom::PlaybackDirection GetDirection() const { return mDirection; }
+  dom::FillMode GetFillMode() const { return mFillMode; }
+  uint8_t GetPlayState() const { return mPlayState; }
+  float GetIterationCount() const { return mIterationCount; }
+
+  void SetTimingFunction(const nsTimingFunction& aTimingFunction)
+    { mTimingFunction = aTimingFunction; }
+  void SetDelay(float aDelay) { mDelay = aDelay; }
+  void SetDuration(float aDuration) { mDuration = aDuration; }
+  void SetName(const nsSubstring& aName) { mName = aName; }
+  void SetDirection(dom::PlaybackDirection aDirection) { mDirection = aDirection; }
+  void SetFillMode(dom::FillMode aFillMode) { mFillMode = aFillMode; }
+  void SetPlayState(uint8_t aPlayState) { mPlayState = aPlayState; }
+  void SetIterationCount(float aIterationCount)
+    { mIterationCount = aIterationCount; }
+
+  nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
+
+  bool operator==(const StyleAnimation& aOther) const;
+  bool operator!=(const StyleAnimation& aOther) const
+    { return !(*this == aOther); }
+
+private:
+  nsTimingFunction mTimingFunction;
+  float mDuration;
+  float mDelay;
+  nsString mName;
+  dom::PlaybackDirection mDirection;
+  dom::FillMode mFillMode;
+  uint8_t mPlayState;
+  float mIterationCount;
+};
+
+class StyleBasicShape final
+{
+public:
+  explicit StyleBasicShape(StyleBasicShapeType type)
+    : mType(type),
+      mFillRule(StyleFillRule::Nonzero)
+  {
+    mPosition.SetInitialPercentValues(0.5f);
+  }
+
+  StyleBasicShapeType GetShapeType() const { return mType; }
+  nsCSSKeyword GetShapeTypeName() const;
+
+  StyleFillRule GetFillRule() const { return mFillRule; }
+  void SetFillRule(StyleFillRule aFillRule)
+  {
+    do { } while (0);
+    mFillRule = aFillRule;
+  }
+
+  Position& GetPosition() {
+    do { } while (0);
+
+
+    return mPosition;
+  }
+  const Position& GetPosition() const {
+    do { } while (0);
+
+
+    return mPosition;
+  }
+
+  bool HasRadius() const {
+    do { } while (0);
+    nsStyleCoord zero;
+    zero.SetCoordValue(0);
+    int32_t corner2401 = mozilla::eCornerTopLeftX; for (mozilla::HalfCorner corner; corner2401 <= mozilla::eCornerBottomLeftY && (corner = mozilla::HalfCorner(corner2401), true); ++corner2401) {
+      if (mRadius.Get(corner) != zero) {
+        return true;
+      }
+    }
+    return false;
+  }
+  nsStyleCorners& GetRadius() {
+    do { } while (0);
+    return mRadius;
+  }
+  const nsStyleCorners& GetRadius() const {
+    do { } while (0);
+    return mRadius;
+  }
+
+
+
+  nsTArray<nsStyleCoord>& Coordinates()
+  {
+    return mCoordinates;
+  }
+
+  const nsTArray<nsStyleCoord>& Coordinates() const
+  {
+    return mCoordinates;
+  }
+
+  bool operator==(const StyleBasicShape& aOther) const
+  {
+    return mType == aOther.mType &&
+           mFillRule == aOther.mFillRule &&
+           mCoordinates == aOther.mCoordinates &&
+           mPosition == aOther.mPosition &&
+           mRadius == aOther.mRadius;
+  }
+  bool operator!=(const StyleBasicShape& aOther) const {
+    return !(*this == aOther);
+  }
+
+  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<StyleBasicShape>::value, "Reference-counted class " "StyleBasicShape" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
+
+private:
+  ~StyleBasicShape() {}
+
+  StyleBasicShapeType mType;
+  StyleFillRule mFillRule;
+
+
+
+
+  nsTArray<nsStyleCoord> mCoordinates;
+
+  Position mPosition;
+
+  nsStyleCorners mRadius;
+};
+
+struct StyleShapeSource
+{
+  StyleShapeSource()
+    : mURL(nullptr)
+  {}
+
+  StyleShapeSource(const StyleShapeSource& aSource)
+    : StyleShapeSource()
+  {
+    if (aSource.mType == StyleShapeSourceType::URL) {
+      SetURL(aSource.mURL);
+    } else if (aSource.mType == StyleShapeSourceType::Shape) {
+      SetBasicShape(aSource.mBasicShape, aSource.mReferenceBox);
+    } else if (aSource.mType == StyleShapeSourceType::Box) {
+      SetReferenceBox(aSource.mReferenceBox);
+    }
+  }
+
+  ~StyleShapeSource()
+  {
+    ReleaseRef();
+  }
+
+  StyleShapeSource& operator=(const StyleShapeSource& aOther)
+  {
+    if (this == &aOther) {
+      return *this;
+    }
+
+    if (aOther.mType == StyleShapeSourceType::URL) {
+      SetURL(aOther.mURL);
+    } else if (aOther.mType == StyleShapeSourceType::Shape) {
+      SetBasicShape(aOther.mBasicShape, aOther.mReferenceBox);
+    } else if (aOther.mType == StyleShapeSourceType::Box) {
+      SetReferenceBox(aOther.mReferenceBox);
+    } else {
+      ReleaseRef();
+      mReferenceBox = StyleGeometryBox::NoBox;
+      mType = StyleShapeSourceType::None;
+    }
+    return *this;
+  }
+
+  bool operator==(const StyleShapeSource& aOther) const
+  {
+    return EqualsInternal<true>(aOther);
+  }
+
+  bool DefinitelyEquals(const StyleShapeSource& aOther) const
+  {
+    return EqualsInternal<false>(aOther);
+  }
+
+  template<bool aPrecise>
+  bool EqualsInternal(const StyleShapeSource& aOther) const
+  {
+    if (mType != aOther.mType) {
+      return false;
+    }
+
+    if (mType == StyleShapeSourceType::URL) {
+      return aPrecise ? mURL->Equals(*aOther.mURL)
+                      : mURL->DefinitelyEqualURIs(*aOther.mURL);
+    } else if (mType == StyleShapeSourceType::Shape) {
+      return *mBasicShape == *aOther.mBasicShape &&
+             mReferenceBox == aOther.mReferenceBox;
+    } else if (mType == StyleShapeSourceType::Box) {
+      return mReferenceBox == aOther.mReferenceBox;
+    }
+
+    return true;
+  }
+
+  bool operator!=(const StyleShapeSource& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  StyleShapeSourceType GetType() const
+  {
+    return mType;
+  }
+
+  css::URLValue* GetURL() const
+  {
+    do { } while (0);
+    return mURL;
+  }
+
+  bool SetURL(css::URLValue* aValue)
+  {
+    do { } while (0);
+    ReleaseRef();
+    mURL = aValue;
+    mURL->AddRef();
+    mType = StyleShapeSourceType::URL;
+    return true;
+  }
+
+  StyleBasicShape* GetBasicShape() const
+  {
+    do { } while (0);
+    return mBasicShape;
+  }
+
+  void SetBasicShape(StyleBasicShape* aBasicShape,
+                     StyleGeometryBox aReferenceBox)
+  {
+    do { } while(0);
+    ReleaseRef();
+    mBasicShape = aBasicShape;
+    mBasicShape->AddRef();
+    mReferenceBox = aReferenceBox;
+    mType = StyleShapeSourceType::Shape;
+  }
+
+  StyleGeometryBox GetReferenceBox() const
+  {
+    do { } while (0);
+
+
+    return mReferenceBox;
+  }
+
+  void SetReferenceBox(StyleGeometryBox aReferenceBox)
+  {
+    ReleaseRef();
+    mReferenceBox = aReferenceBox;
+    mType = StyleShapeSourceType::Box;
+  }
+
+private:
+  void ReleaseRef()
+  {
+    if (mType == StyleShapeSourceType::Shape) {
+      do { } while(0);
+      mBasicShape->Release();
+    } else if (mType == StyleShapeSourceType::URL) {
+      do { } while(0);
+      mURL->Release();
+    }
+
+
+    mURL = nullptr;
+  }
+
+  void* operator new(size_t) = delete;
+
+  union {
+    StyleBasicShape* mBasicShape;
+    css::URLValue* mURL;
+  };
+  StyleShapeSourceType mType = StyleShapeSourceType::None;
+  StyleGeometryBox mReferenceBox = StyleGeometryBox::NoBox;
+};
+
+}
+
+
+
+
+
+
+class BindingHolder {
+public:
+  BindingHolder() {}
+  explicit BindingHolder(mozilla::css::URLValue* aPtr) : mPtr(aPtr) {}
+  operator mozilla::css::URLValue*() const { return Get(); }
+  mozilla::css::URLValue* operator->() const { return Get(); }
+  mozilla::css::URLValue* Get() const { return (mPtr && mPtr->GetURI()) ? mPtr.get() : nullptr; }
+  mozilla::css::URLValue* ForceGet() const { return mPtr.get(); }
+  void Set(mozilla::css::URLValue* aPtr) { mPtr = aPtr; }
+private:
+  RefPtr<mozilla::css::URLValue> mPtr;
+};
+
+struct nsStyleDisplay
+{
+  typedef mozilla::StyleGeometryBox StyleGeometryBox;
+
+  explicit nsStyleDisplay(const nsPresContext* aContext);
+  nsStyleDisplay(const nsStyleDisplay& aOther);
+  ~nsStyleDisplay();
+
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleDisplay* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleDisplay, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleDisplay();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleDisplay, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleDisplay& aNewData) const;
+
+
+
+  BindingHolder mBinding;
+  mozilla::StyleDisplay mDisplay;
+  mozilla::StyleDisplay mOriginalDisplay;
+
+
+
+
+  uint8_t mContain;
+private:
+  friend class nsComputedDOMStyle;
+  friend class nsRuleNode;
+  uint8_t mMozAppearance;
+  uint8_t mAppearance;
+public:
+  __attribute__ ((warn_unused_result)) uint8_t UsedAppearance() const {
+    if (mAppearance == 0) {
+      return 0;
+    }
+    do { } while (0);
+    return mMozAppearance;
+  }
+
+  uint8_t mPosition;
+
+
+  mozilla::StyleFloat mFloat;
+
+  mozilla::StyleFloat mOriginalFloat;
+
+  mozilla::StyleClear mBreakType;
+  uint8_t mBreakInside;
+  bool mBreakBefore;
+  bool mBreakAfter;
+  uint8_t mOverflowX;
+  uint8_t mOverflowY;
+  uint8_t mOverflowClipBox;
+  uint8_t mResize;
+  mozilla::StyleOrient mOrient;
+  uint8_t mIsolation;
+  uint8_t mTopLayer;
+  uint8_t mWillChangeBitField;
+
+
+
+
+
+  nsCOMArray<nsIAtom> mWillChange;
+
+  uint8_t mTouchAction;
+  uint8_t mScrollBehavior;
+  uint8_t mScrollSnapTypeX;
+  uint8_t mScrollSnapTypeY;
+  nsStyleCoord mScrollSnapPointsX;
+  nsStyleCoord mScrollSnapPointsY;
+  mozilla::Position mScrollSnapDestination;
+  nsTArray<mozilla::Position> mScrollSnapCoordinate;
+
+
+
+
+
+  uint8_t mBackfaceVisibility;
+  uint8_t mTransformStyle;
+  StyleGeometryBox mTransformBox;
+  RefPtr<nsCSSValueSharedList> mSpecifiedTransform;
+  nsStyleCoord mTransformOrigin[3];
+  nsStyleCoord mChildPerspective;
+  nsStyleCoord mPerspectiveOrigin[2];
+
+  nsStyleCoord mVerticalAlign;
+
+  nsStyleAutoArray<mozilla::StyleTransition> mTransitions;
+
+
+
+  uint32_t mTransitionTimingFunctionCount,
+           mTransitionDurationCount,
+           mTransitionDelayCount,
+           mTransitionPropertyCount;
+
+  nsStyleAutoArray<mozilla::StyleAnimation> mAnimations;
+
+
+
+  uint32_t mAnimationTimingFunctionCount,
+           mAnimationDurationCount,
+           mAnimationDelayCount,
+           mAnimationNameCount,
+           mAnimationDirectionCount,
+           mAnimationFillModeCount,
+           mAnimationPlayStateCount,
+           mAnimationIterationCountCount;
+
+  mozilla::StyleShapeSource mShapeOutside;
+
+  bool IsBlockInsideStyle() const {
+    return mozilla::StyleDisplay::Block == mDisplay ||
+           mozilla::StyleDisplay::ListItem == mDisplay ||
+           mozilla::StyleDisplay::InlineBlock == mDisplay ||
+           mozilla::StyleDisplay::TableCaption == mDisplay ||
+           mozilla::StyleDisplay::FlowRoot == mDisplay;
+
+
+
+  }
+
+  bool IsBlockOutsideStyle() const {
+    return mozilla::StyleDisplay::Block == mDisplay ||
+           mozilla::StyleDisplay::Flex == mDisplay ||
+           mozilla::StyleDisplay::WebkitBox == mDisplay ||
+           mozilla::StyleDisplay::Grid == mDisplay ||
+           mozilla::StyleDisplay::ListItem == mDisplay ||
+           mozilla::StyleDisplay::Table == mDisplay ||
+           mozilla::StyleDisplay::FlowRoot == mDisplay;
+  }
+
+  static bool IsDisplayTypeInlineOutside(mozilla::StyleDisplay aDisplay) {
+    return mozilla::StyleDisplay::Inline == aDisplay ||
+           mozilla::StyleDisplay::InlineBlock == aDisplay ||
+           mozilla::StyleDisplay::InlineTable == aDisplay ||
+           mozilla::StyleDisplay::MozInlineBox == aDisplay ||
+           mozilla::StyleDisplay::InlineFlex == aDisplay ||
+           mozilla::StyleDisplay::WebkitInlineBox == aDisplay ||
+           mozilla::StyleDisplay::InlineGrid == aDisplay ||
+           mozilla::StyleDisplay::MozInlineGrid == aDisplay ||
+           mozilla::StyleDisplay::MozInlineStack == aDisplay ||
+           mozilla::StyleDisplay::Ruby == aDisplay ||
+           mozilla::StyleDisplay::RubyBase == aDisplay ||
+           mozilla::StyleDisplay::RubyBaseContainer == aDisplay ||
+           mozilla::StyleDisplay::RubyText == aDisplay ||
+           mozilla::StyleDisplay::RubyTextContainer == aDisplay ||
+           mozilla::StyleDisplay::Contents == aDisplay;
+  }
+
+  bool IsInlineOutsideStyle() const {
+    return IsDisplayTypeInlineOutside(mDisplay);
+  }
+
+  bool IsOriginalDisplayInlineOutsideStyle() const {
+    return IsDisplayTypeInlineOutside(mOriginalDisplay);
+  }
+
+  bool IsInnerTableStyle() const {
+    return mozilla::StyleDisplay::TableCaption == mDisplay ||
+           mozilla::StyleDisplay::TableCell == mDisplay ||
+           mozilla::StyleDisplay::TableRow == mDisplay ||
+           mozilla::StyleDisplay::TableRowGroup == mDisplay ||
+           mozilla::StyleDisplay::TableHeaderGroup == mDisplay ||
+           mozilla::StyleDisplay::TableFooterGroup == mDisplay ||
+           mozilla::StyleDisplay::TableColumn == mDisplay ||
+           mozilla::StyleDisplay::TableColumnGroup == mDisplay;
+  }
+
+  bool IsFloatingStyle() const {
+    return mozilla::StyleFloat::None != mFloat;
+  }
+
+  bool IsAbsolutelyPositionedStyle() const {
+    return 2 == mPosition ||
+           3 == mPosition;
+  }
+
+  bool IsRelativelyPositionedStyle() const {
+    return 1 == mPosition ||
+           4 == mPosition;
+  }
+  bool IsPositionForcingStackingContext() const {
+    return 4 == mPosition ||
+           3 == mPosition;
+  }
+
+  static bool IsRubyDisplayType(mozilla::StyleDisplay aDisplay) {
+    return mozilla::StyleDisplay::Ruby == aDisplay ||
+           mozilla::StyleDisplay::RubyBase == aDisplay ||
+           mozilla::StyleDisplay::RubyBaseContainer == aDisplay ||
+           mozilla::StyleDisplay::RubyText == aDisplay ||
+           mozilla::StyleDisplay::RubyTextContainer == aDisplay;
+  }
+
+  bool IsRubyDisplayType() const {
+    return IsRubyDisplayType(mDisplay);
+  }
+
+  bool IsOutOfFlowStyle() const {
+    return (IsAbsolutelyPositionedStyle() || IsFloatingStyle());
+  }
+
+  bool IsScrollableOverflow() const {
+
+
+    return mOverflowX != 0 &&
+           mOverflowX != 4;
+  }
+
+  bool IsContainPaint() const {
+    return 0x8 & mContain;
+  }
+
+
+
+  bool HasTransformStyle() const {
+    return mSpecifiedTransform != nullptr ||
+           mTransformStyle == 1 ||
+           (mWillChangeBitField & (1<<1));
+  }
+
+  bool HasPerspectiveStyle() const {
+    return mChildPerspective.GetUnit() == eStyleUnit_Coord;
+  }
+
+  bool BackfaceIsHidden() const {
+    return mBackfaceVisibility == 0;
+  }
+
+
+
+
+
+
+
+  inline bool IsBlockInside(const nsIFrame* aContextFrame) const;
+  inline bool IsBlockOutside(const nsIFrame* aContextFrame) const;
+  inline bool IsInlineOutside(const nsIFrame* aContextFrame) const;
+  inline bool IsOriginalDisplayInlineOutside(const nsIFrame* aContextFrame) const;
+  inline mozilla::StyleDisplay GetDisplay(const nsIFrame* aContextFrame) const;
+  inline bool IsFloating(const nsIFrame* aContextFrame) const;
+  inline bool IsRelativelyPositioned(const nsIFrame* aContextFrame) const;
+  inline bool IsAbsolutelyPositioned(const nsIFrame* aContextFrame) const;
+# 2896 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+  inline bool IsAbsPosContainingBlock(const nsIFrame* aContextFrame) const;
+
+
+
+
+
+
+  template<class StyleContextLike>
+  inline bool IsAbsPosContainingBlockForAppropriateFrame(
+                StyleContextLike* aStyleContext) const;
+
+
+
+
+
+
+  inline bool HasTransform(const nsIFrame* aContextFrame) const;
+
+
+
+
+
+
+  inline bool IsFixedPosContainingBlock(const nsIFrame* aContextFrame) const;
+
+
+
+
+
+
+  template<class StyleContextLike>
+  inline bool IsFixedPosContainingBlockForAppropriateFrame(
+                StyleContextLike* aStyleContext) const;
+
+private:
+
+
+  template<class StyleContextLike>
+  inline bool HasAbsPosContainingBlockStyleInternal(
+                StyleContextLike* aStyleContext) const;
+  template<class StyleContextLike>
+  inline bool HasFixedPosContainingBlockStyleInternal(
+                StyleContextLike* aStyleContext) const;
+
+public:
+
+
+
+  inline mozilla::StyleFloat PhysicalFloats(mozilla::WritingMode aWM) const;
+  inline mozilla::StyleClear PhysicalBreakType(mozilla::WritingMode aWM) const;
+};
+
+struct nsStyleTable
+{
+  explicit nsStyleTable(const nsPresContext* aContext);
+  nsStyleTable(const nsStyleTable& aOther);
+  ~nsStyleTable();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleTable* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTable, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleTable();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTable, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleTable& aNewData) const;
+
+  uint8_t mLayoutStrategy;
+  int32_t mSpan;
+};
+
+struct nsStyleTableBorder
+{
+  explicit nsStyleTableBorder(const nsPresContext* aContext);
+  nsStyleTableBorder(const nsStyleTableBorder& aOther);
+  ~nsStyleTableBorder();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleTableBorder* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTableBorder, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleTableBorder();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTableBorder, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleTableBorder& aNewData) const;
+
+  nscoord mBorderSpacingCol;
+  nscoord mBorderSpacingRow;
+  uint8_t mBorderCollapse;
+  uint8_t mCaptionSide;
+  uint8_t mEmptyCells;
+};
+
+enum nsStyleContentType {
+  eStyleContentType_String = 1,
+  eStyleContentType_Image = 10,
+  eStyleContentType_Attr = 20,
+  eStyleContentType_Counter = 30,
+  eStyleContentType_Counters = 31,
+  eStyleContentType_OpenQuote = 40,
+  eStyleContentType_CloseQuote = 41,
+  eStyleContentType_NoOpenQuote = 42,
+  eStyleContentType_NoCloseQuote = 43,
+  eStyleContentType_AltContent = 50,
+  eStyleContentType_Uninitialized
+};
+
+class nsStyleContentData
+{
+public:
+  nsStyleContentData()
+    : mType(eStyleContentType_Uninitialized)
+  {
+                                      ;
+    mContent.mString = nullptr;
+  }
+  nsStyleContentData(const nsStyleContentData&);
+
+  ~nsStyleContentData();
+  nsStyleContentData& operator=(const nsStyleContentData& aOther);
+  bool operator==(const nsStyleContentData& aOther) const;
+
+  bool operator!=(const nsStyleContentData& aOther) const {
+    return !(*this == aOther);
+  }
+
+  nsStyleContentType GetType() const { return mType; }
+
+  char16_t* GetString() const
+  {
+    do { } while (0);
+
+    return mContent.mString;
+  }
+
+  nsCSSValue::Array* GetCounters() const
+  {
+    do { } while (0);
+
+    return mContent.mCounters;
+  }
+
+  nsStyleImageRequest* GetImageRequest() const
+  {
+    do { } while (0);
+    return mContent.mImage;
+  }
+
+  imgRequestProxy* GetImage() const
+  {
+    return GetImageRequest()->get();
+  }
+
+  void SetKeyword(nsStyleContentType aType)
+  {
+    do { } while (0);
+
+
+
+
+    do { } while (0);
+
+    mType = aType;
+  }
+
+  void SetString(nsStyleContentType aType, const char16_t* aString)
+  {
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+
+    mType = aType;
+    mContent.mString = NS_strdup(aString);
+  }
+
+  void SetCounters(nsStyleContentType aType, nsCSSValue::Array* aCounters)
+  {
+    do { } while (0);
+
+    do { } while (0);
+    do { } while (0);
+    do { } while (0);
+
+    mType = aType;
+    mContent.mCounters = aCounters;
+    mContent.mCounters->AddRef();
+  }
+
+  void SetImageRequest(already_AddRefed<nsStyleImageRequest> aRequest)
+  {
+    do { } while (0);
+
+    mType = eStyleContentType_Image;
+    mContent.mImage = aRequest.take();
+    do { } while (0);
+  }
+
+  void Resolve(nsPresContext* aPresContext) {
+    if (mType == eStyleContentType_Image && !mContent.mImage->IsResolved()) {
+      mContent.mImage->Resolve(aPresContext);
+    }
+  }
+
+private:
+  nsStyleContentType mType;
+  union {
+    char16_t *mString;
+    nsStyleImageRequest* mImage;
+    nsCSSValue::Array* mCounters;
+  } mContent;
+};
+
+struct nsStyleCounterData
+{
+  nsString mCounter;
+  int32_t mValue;
+
+  bool operator==(const nsStyleCounterData& aOther) const {
+    return mValue == aOther.mValue && mCounter == aOther.mCounter;
+  }
+
+  bool operator!=(const nsStyleCounterData& aOther) const {
+    return !(*this == aOther);
+  }
+};
+
+struct nsStyleContent
+{
+  explicit nsStyleContent(const nsPresContext* aContext);
+  nsStyleContent(const nsStyleContent& aContent);
+  ~nsStyleContent();
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleContent* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleContent, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStyleContent& aNewData) const;
+
+  uint32_t ContentCount() const { return mContents.Length(); }
+
+  const nsStyleContentData& ContentAt(uint32_t aIndex) const {
+    return mContents[aIndex];
+  }
+
+  nsStyleContentData& ContentAt(uint32_t aIndex) { return mContents[aIndex]; }
+
+  void AllocateContents(uint32_t aCount) {
+
+
+
+
+
+    mContents.Clear();
+    mContents.SetLength(aCount);
+  }
+
+  uint32_t CounterIncrementCount() const { return mIncrements.Length(); }
+  const nsStyleCounterData& CounterIncrementAt(uint32_t aIndex) const {
+    return mIncrements[aIndex];
+  }
+
+  void AllocateCounterIncrements(uint32_t aCount) {
+    mIncrements.Clear();
+    mIncrements.SetLength(aCount);
+  }
+
+  void SetCounterIncrementAt(uint32_t aIndex, const nsString& aCounter, int32_t aIncrement) {
+    mIncrements[aIndex].mCounter = aCounter;
+    mIncrements[aIndex].mValue = aIncrement;
+  }
+
+  uint32_t CounterResetCount() const { return mResets.Length(); }
+  const nsStyleCounterData& CounterResetAt(uint32_t aIndex) const {
+    return mResets[aIndex];
+  }
+
+  void AllocateCounterResets(uint32_t aCount) {
+    mResets.Clear();
+    mResets.SetLength(aCount);
+  }
+
+  void SetCounterResetAt(uint32_t aIndex, const nsString& aCounter, int32_t aValue) {
+    mResets[aIndex].mCounter = aCounter;
+    mResets[aIndex].mValue = aValue;
+  }
+
+protected:
+  nsTArray<nsStyleContentData> mContents;
+  nsTArray<nsStyleCounterData> mIncrements;
+  nsTArray<nsStyleCounterData> mResets;
+};
+
+struct nsStyleUIReset
+{
+  explicit nsStyleUIReset(const nsPresContext* aContext);
+  nsStyleUIReset(const nsStyleUIReset& aOther);
+  ~nsStyleUIReset();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleUIReset* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleUIReset, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleUIReset();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleUIReset, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleUIReset& aNewData) const;
+
+  mozilla::StyleUserSelect mUserSelect;
+  uint8_t mForceBrokenImageIcon;
+  uint8_t mIMEMode;
+  mozilla::StyleWindowDragging mWindowDragging;
+  uint8_t mWindowShadow;
+};
+
+struct nsCursorImage
+{
+  bool mHaveHotspot;
+  float mHotspotX, mHotspotY;
+  RefPtr<nsStyleImageRequest> mImage;
+
+  nsCursorImage();
+  nsCursorImage(const nsCursorImage& aOther);
+
+  nsCursorImage& operator=(const nsCursorImage& aOther);
+
+  bool operator==(const nsCursorImage& aOther) const;
+  bool operator!=(const nsCursorImage& aOther) const
+  {
+    return !(*this == aOther);
+  }
+
+  imgRequestProxy* GetImage() const {
+    return mImage->get();
+  }
+};
+
+struct nsStyleUserInterface
+{
+  explicit nsStyleUserInterface(const nsPresContext* aContext);
+  nsStyleUserInterface(const nsStyleUserInterface& aOther);
+  ~nsStyleUserInterface();
+
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleUserInterface* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleUserInterface, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleUserInterface();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleUserInterface, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleUserInterface& aNewData) const;
+
+  mozilla::StyleUserInput mUserInput;
+  mozilla::StyleUserModify mUserModify;
+  mozilla::StyleUserFocus mUserFocus;
+  uint8_t mPointerEvents;
+
+  uint8_t mCursor;
+  nsTArray<nsCursorImage> mCursorImages;
+  mozilla::StyleComplexColor mCaretColor;
+
+  inline uint8_t GetEffectivePointerEvents(nsIFrame* aFrame) const;
+};
+
+struct nsStyleXUL
+{
+  explicit nsStyleXUL(const nsPresContext* aContext);
+  nsStyleXUL(const nsStyleXUL& aSource);
+  ~nsStyleXUL();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleXUL* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleXUL, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleXUL();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleXUL, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleXUL& aNewData) const;
+
+  float mBoxFlex;
+  uint32_t mBoxOrdinal;
+  mozilla::StyleBoxAlign mBoxAlign;
+  mozilla::StyleBoxDirection mBoxDirection;
+  mozilla::StyleBoxOrient mBoxOrient;
+  mozilla::StyleBoxPack mBoxPack;
+  bool mStretchStack;
+};
+
+struct nsStyleColumn
+{
+  explicit nsStyleColumn(const nsPresContext* aContext);
+  nsStyleColumn(const nsStyleColumn& aSource);
+  ~nsStyleColumn();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleColumn* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleColumn, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleColumn();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleColumn, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleColumn& aNewData) const;
+
+
+
+
+
+  static const uint32_t kMaxColumnCount = 1000;
+
+  uint32_t mColumnCount;
+  nsStyleCoord mColumnWidth;
+  nsStyleCoord mColumnGap;
+
+  mozilla::StyleComplexColor mColumnRuleColor;
+  uint8_t mColumnRuleStyle;
+  uint8_t mColumnFill;
+  uint8_t mColumnSpan;
+
+  void SetColumnRuleWidth(nscoord aWidth) {
+    mColumnRuleWidth = ((aWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));
+  }
+
+  nscoord GetComputedColumnRuleWidth() const {
+    return (IsVisibleBorderStyle(mColumnRuleStyle) ? mColumnRuleWidth : 0);
+  }
+
+protected:
+  nscoord mColumnRuleWidth;
+  nscoord mTwipsPerPixel;
+};
+
+enum nsStyleSVGPaintType {
+  eStyleSVGPaintType_None = 1,
+  eStyleSVGPaintType_Color,
+  eStyleSVGPaintType_Server,
+  eStyleSVGPaintType_ContextFill,
+  eStyleSVGPaintType_ContextStroke
+};
+
+enum nsStyleSVGOpacitySource : uint8_t {
+  eStyleSVGOpacitySource_Normal,
+  eStyleSVGOpacitySource_ContextFillOpacity,
+  eStyleSVGOpacitySource_ContextStrokeOpacity
+};
+
+class nsStyleSVGPaint
+{
+public:
+  explicit nsStyleSVGPaint(nsStyleSVGPaintType aType = nsStyleSVGPaintType(0));
+  nsStyleSVGPaint(const nsStyleSVGPaint& aSource);
+  ~nsStyleSVGPaint();
+
+  nsStyleSVGPaint& operator=(const nsStyleSVGPaint& aOther);
+
+  nsStyleSVGPaintType Type() const { return mType; }
+
+  void SetNone();
+  void SetColor(nscolor aColor);
+  void SetPaintServer(mozilla::css::URLValue* aPaintServer,
+                      nscolor aFallbackColor);
+  void SetContextValue(nsStyleSVGPaintType aType,
+                       nscolor aFallbackColor);
+
+  nscolor GetColor() const {
+    do { } while (0);
+    return mPaint.mColor;
+  }
+
+  mozilla::css::URLValue* GetPaintServer() const {
+    do { } while (0);
+    return mPaint.mPaintServer;
+  }
+
+  nscolor GetFallbackColor() const {
+    do { } while (0);
+
+
+    return mFallbackColor;
+  }
+
+  bool operator==(const nsStyleSVGPaint& aOther) const;
+  bool operator!=(const nsStyleSVGPaint& aOther) const {
+    return !(*this == aOther);
+  }
+
+private:
+  void Reset();
+  void Assign(const nsStyleSVGPaint& aOther);
+
+  union {
+    nscolor mColor;
+    mozilla::css::URLValue* mPaintServer;
+  } mPaint;
+  nsStyleSVGPaintType mType;
+  nscolor mFallbackColor;
+};
+
+struct nsStyleSVG
+{
+  explicit nsStyleSVG(const nsPresContext* aContext);
+  nsStyleSVG(const nsStyleSVG& aSource);
+  ~nsStyleSVG();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleSVG* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleSVG, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleSVG();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleSVG, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleSVG& aNewData) const;
+
+  nsStyleSVGPaint mFill;
+  nsStyleSVGPaint mStroke;
+  RefPtr<mozilla::css::URLValue> mMarkerEnd;
+  RefPtr<mozilla::css::URLValue> mMarkerMid;
+  RefPtr<mozilla::css::URLValue> mMarkerStart;
+  nsTArray<nsStyleCoord> mStrokeDasharray;
+
+  nsStyleCoord mStrokeDashoffset;
+  nsStyleCoord mStrokeWidth;
+
+  float mFillOpacity;
+  float mStrokeMiterlimit;
+  float mStrokeOpacity;
+
+  mozilla::StyleFillRule mClipRule;
+  uint8_t mColorInterpolation;
+  uint8_t mColorInterpolationFilters;
+  mozilla::StyleFillRule mFillRule;
+  uint8_t mPaintOrder;
+  uint8_t mShapeRendering;
+  uint8_t mStrokeLinecap;
+  uint8_t mStrokeLinejoin;
+  uint8_t mTextAnchor;
+
+  nsStyleSVGOpacitySource FillOpacitySource() const {
+    uint8_t value = (mContextFlags & FILL_OPACITY_SOURCE_MASK) >>
+                    FILL_OPACITY_SOURCE_SHIFT;
+    return nsStyleSVGOpacitySource(value);
+  }
+  nsStyleSVGOpacitySource StrokeOpacitySource() const {
+    uint8_t value = (mContextFlags & STROKE_OPACITY_SOURCE_MASK) >>
+                    STROKE_OPACITY_SOURCE_SHIFT;
+    return nsStyleSVGOpacitySource(value);
+  }
+  bool StrokeDasharrayFromObject() const {
+    return mContextFlags & STROKE_DASHARRAY_CONTEXT;
+  }
+  bool StrokeDashoffsetFromObject() const {
+    return mContextFlags & STROKE_DASHOFFSET_CONTEXT;
+  }
+  bool StrokeWidthFromObject() const {
+    return mContextFlags & STROKE_WIDTH_CONTEXT;
+  }
+
+  void SetFillOpacitySource(nsStyleSVGOpacitySource aValue) {
+    mContextFlags = (mContextFlags & ~FILL_OPACITY_SOURCE_MASK) |
+                    (aValue << FILL_OPACITY_SOURCE_SHIFT);
+  }
+  void SetStrokeOpacitySource(nsStyleSVGOpacitySource aValue) {
+    mContextFlags = (mContextFlags & ~STROKE_OPACITY_SOURCE_MASK) |
+                    (aValue << STROKE_OPACITY_SOURCE_SHIFT);
+  }
+  void SetStrokeDasharrayFromObject(bool aValue) {
+    mContextFlags = (mContextFlags & ~STROKE_DASHARRAY_CONTEXT) |
+                    (aValue ? STROKE_DASHARRAY_CONTEXT : 0);
+  }
+  void SetStrokeDashoffsetFromObject(bool aValue) {
+    mContextFlags = (mContextFlags & ~STROKE_DASHOFFSET_CONTEXT) |
+                    (aValue ? STROKE_DASHOFFSET_CONTEXT : 0);
+  }
+  void SetStrokeWidthFromObject(bool aValue) {
+    mContextFlags = (mContextFlags & ~STROKE_WIDTH_CONTEXT) |
+                    (aValue ? STROKE_WIDTH_CONTEXT : 0);
+  }
+
+  bool HasMarker() const {
+    return mMarkerStart || mMarkerMid || mMarkerEnd;
+  }
+
+
+
+
+
+  bool HasStroke() const {
+    return mStroke.Type() != eStyleSVGPaintType_None && mStrokeOpacity > 0;
+  }
+
+
+
+
+
+  bool HasFill() const {
+    return mFill.Type() != eStyleSVGPaintType_None && mFillOpacity > 0;
+  }
+
+private:
+
+
+
+  enum {
+    FILL_OPACITY_SOURCE_MASK = 0x03,
+    STROKE_OPACITY_SOURCE_MASK = 0x0C,
+    STROKE_DASHARRAY_CONTEXT = 0x10,
+    STROKE_DASHOFFSET_CONTEXT = 0x20,
+    STROKE_WIDTH_CONTEXT = 0x40,
+    FILL_OPACITY_SOURCE_SHIFT = 0,
+    STROKE_OPACITY_SOURCE_SHIFT = 2,
+  };
+
+  uint8_t mContextFlags;
+};
+
+struct nsStyleFilter
+{
+  nsStyleFilter();
+  nsStyleFilter(const nsStyleFilter& aSource);
+  ~nsStyleFilter();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  nsStyleFilter& operator=(const nsStyleFilter& aOther);
+
+  bool operator==(const nsStyleFilter& aOther) const;
+  bool operator!=(const nsStyleFilter& aOther) const {
+    return !(*this == aOther);
+  }
+
+  uint32_t GetType() const {
+    return mType;
+  }
+
+  const nsStyleCoord& GetFilterParameter() const {
+    do { } while(0);
+
+
+    return mFilterParameter;
+  }
+  void SetFilterParameter(const nsStyleCoord& aFilterParameter,
+                          int32_t aType);
+
+  mozilla::css::URLValue* GetURL() const {
+    do { } while (0);
+    return mURL;
+  }
+
+  bool SetURL(mozilla::css::URLValue* aValue);
+
+  nsCSSShadowArray* GetDropShadow() const {
+    do { } while(0);
+    return mDropShadow;
+  }
+  void SetDropShadow(nsCSSShadowArray* aDropShadow);
+
+private:
+  void ReleaseRef();
+
+  uint32_t mType;
+  nsStyleCoord mFilterParameter;
+  union {
+    mozilla::css::URLValue* mURL;
+    nsCSSShadowArray* mDropShadow;
+  };
+};
+
+template<>
+struct nsTArray_CopyChooser<nsStyleFilter>
+{
+  typedef nsTArray_CopyWithConstructors<nsStyleFilter> Type;
+};
+
+struct nsStyleSVGReset
+{
+  explicit nsStyleSVGReset(const nsPresContext* aContext);
+  nsStyleSVGReset(const nsStyleSVGReset& aSource);
+  ~nsStyleSVGReset();
+
+
+
+
+  void FinishStyle(nsPresContext* aPresContext);
+
+  void* operator new(size_t sz, nsStyleSVGReset* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleSVGReset, sz);
+  }
+  void Destroy(nsPresContext* aContext);
+
+  nsChangeHint CalcDifference(const nsStyleSVGReset& aNewData) const;
+
+  bool HasClipPath() const {
+    return mClipPath.GetType() != mozilla::StyleShapeSourceType::None;
+  }
+
+  bool HasMask() const;
+
+  bool HasNonScalingStroke() const {
+    return mVectorEffect == 1;
+  }
+
+  nsStyleImageLayers mMask;
+  mozilla::StyleShapeSource mClipPath;
+  nscolor mStopColor;
+  nscolor mFloodColor;
+  nscolor mLightingColor;
+
+  float mStopOpacity;
+  float mFloodOpacity;
+
+  uint8_t mDominantBaseline;
+  uint8_t mVectorEffect;
+  uint8_t mMaskType;
+};
+
+struct nsStyleVariables
+{
+  nsStyleVariables();
+  explicit nsStyleVariables(const nsPresContext* aContext);
+  nsStyleVariables(const nsStyleVariables& aSource);
+  ~nsStyleVariables();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleVariables* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleVariables, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleVariables();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleVariables, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleVariables& aNewData) const;
+
+  mozilla::CSSVariableValues mVariables;
+};
+
+struct nsStyleEffects
+{
+  explicit nsStyleEffects(const nsPresContext* aContext);
+  nsStyleEffects(const nsStyleEffects& aSource);
+  ~nsStyleEffects();
+  void FinishStyle(nsPresContext* aPresContext) {}
+
+  void* operator new(size_t sz, nsStyleEffects* aSelf) { return aSelf; }
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleEffects, sz);
+  }
+  void Destroy(nsPresContext* aContext) {
+    this->~nsStyleEffects();
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsStyleEffects, this);
+  }
+
+  nsChangeHint CalcDifference(const nsStyleEffects& aNewData) const;
+
+  bool HasFilters() const {
+    return !mFilters.IsEmpty();
+  }
+
+  nsTArray<nsStyleFilter> mFilters;
+  RefPtr<nsCSSShadowArray> mBoxShadow;
+  nsRect mClip;
+  float mOpacity;
+  uint8_t mClipFlags;
+  uint8_t mMixBlendMode;
+};
+# 3726 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
+struct nsPoint_Simple {
+  nscoord x, y;
+};
+
+static_assert(sizeof(nsPoint) == sizeof(nsPoint_Simple), "Size mismatch between " "nsPoint" " and " "nsPoint_Simple"); static_assert(alignof(nsPoint) == alignof(nsPoint_Simple), "Align mismatch between " "nsPoint" " and " "nsPoint_Simple");;
+static_assert(__builtin_offsetof(nsPoint, x) == __builtin_offsetof(nsPoint_Simple, x), "Field offset mismatch of " "x" " between " "nsPoint" " and " "nsPoint_Simple");;
+static_assert(__builtin_offsetof(nsPoint, y) == __builtin_offsetof(nsPoint_Simple, y), "Field offset mismatch of " "y" " between " "nsPoint" " and " "nsPoint_Simple");;
+
+
+
+
+struct nsMargin_Simple {
+  nscoord top, right, bottom, left;
+};
+
+static_assert(sizeof(nsMargin) == sizeof(nsMargin_Simple), "Size mismatch between " "nsMargin" " and " "nsMargin_Simple"); static_assert(alignof(nsMargin) == alignof(nsMargin_Simple), "Align mismatch between " "nsMargin" " and " "nsMargin_Simple");;
+static_assert(__builtin_offsetof(nsMargin, top) == __builtin_offsetof(nsMargin_Simple, top), "Field offset mismatch of " "top" " between " "nsMargin" " and " "nsMargin_Simple");;
+static_assert(__builtin_offsetof(nsMargin, right) == __builtin_offsetof(nsMargin_Simple, right), "Field offset mismatch of " "right" " between " "nsMargin" " and " "nsMargin_Simple");;
+static_assert(__builtin_offsetof(nsMargin, bottom) == __builtin_offsetof(nsMargin_Simple, bottom), "Field offset mismatch of " "bottom" " between " "nsMargin" " and " "nsMargin_Simple");;
+static_assert(__builtin_offsetof(nsMargin, left) == __builtin_offsetof(nsMargin_Simple, left), "Field offset mismatch of " "left" " between " "nsMargin" " and " "nsMargin_Simple");;
+
+
+
+
+struct nsRect_Simple {
+  nscoord x, y, width, height;
+};
+
+static_assert(sizeof(nsRect) == sizeof(nsRect_Simple), "Size mismatch between " "nsRect" " and " "nsRect_Simple"); static_assert(alignof(nsRect) == alignof(nsRect_Simple), "Align mismatch between " "nsRect" " and " "nsRect_Simple");;
+static_assert(__builtin_offsetof(nsRect, x) == __builtin_offsetof(nsRect_Simple, x), "Field offset mismatch of " "x" " between " "nsRect" " and " "nsRect_Simple");;
+static_assert(__builtin_offsetof(nsRect, y) == __builtin_offsetof(nsRect_Simple, y), "Field offset mismatch of " "y" " between " "nsRect" " and " "nsRect_Simple");;
+static_assert(__builtin_offsetof(nsRect, width) == __builtin_offsetof(nsRect_Simple, width), "Field offset mismatch of " "width" " between " "nsRect" " and " "nsRect_Simple");;
+static_assert(__builtin_offsetof(nsRect, height) == __builtin_offsetof(nsRect_Simple, height), "Field offset mismatch of " "height" " between " "nsRect" " and " "nsRect_Simple");;
+
+
+
+
+struct nsSize_Simple {
+  nscoord width, height;
+};
+
+static_assert(sizeof(nsSize) == sizeof(nsSize_Simple), "Size mismatch between " "nsSize" " and " "nsSize_Simple"); static_assert(alignof(nsSize) == alignof(nsSize_Simple), "Align mismatch between " "nsSize" " and " "nsSize_Simple");;
+static_assert(__builtin_offsetof(nsSize, width) == __builtin_offsetof(nsSize_Simple, width), "Field offset mismatch of " "width" " between " "nsSize" " and " "nsSize_Simple");;
+static_assert(__builtin_offsetof(nsSize, height) == __builtin_offsetof(nsSize_Simple, height), "Field offset mismatch of " "height" " between " "nsSize" " and " "nsSize_Simple");;
+
+
+
+
+
+
+
+template<typename T, typename Deleter = mozilla::DefaultDelete<T>>
+struct UniquePtr_Simple {
+  T* mPtr;
+};
+
+static_assert(sizeof(mozilla::UniquePtr<int>) == sizeof(UniquePtr_Simple<int>), "Size mismatch between " "mozilla::UniquePtr<int>" " and " "UniquePtr_Simple<int>"); static_assert(alignof(mozilla::UniquePtr<int>) == alignof(UniquePtr_Simple<int>), "Align mismatch between " "mozilla::UniquePtr<int>" " and " "UniquePtr_Simple<int>");;
+
+
+
+
+template<typename T>
+class nsTArray_Simple {
+  T* mBuffer;
+public:
+
+
+  ~nsTArray_Simple() {};
+};
+
+static_assert(sizeof(nsTArray<nsStyleImageLayers::Layer>) == sizeof(nsTArray_Simple<nsStyleImageLayers::Layer>), "Size mismatch between " "nsTArray<nsStyleImageLayers::Layer>" " and " "nsTArray_Simple<nsStyleImageLayers::Layer>"); static_assert(alignof(nsTArray<nsStyleImageLayers::Layer>) == alignof(nsTArray_Simple<nsStyleImageLayers::Layer>), "Align mismatch between " "nsTArray<nsStyleImageLayers::Layer>" " and " "nsTArray_Simple<nsStyleImageLayers::Layer>");;
+
+static_assert(sizeof(nsTArray<mozilla::StyleTransition>) == sizeof(nsTArray_Simple<mozilla::StyleTransition>), "Size mismatch between " "nsTArray<mozilla::StyleTransition>" " and " "nsTArray_Simple<mozilla::StyleTransition>"); static_assert(alignof(nsTArray<mozilla::StyleTransition>) == alignof(nsTArray_Simple<mozilla::StyleTransition>), "Align mismatch between " "nsTArray<mozilla::StyleTransition>" " and " "nsTArray_Simple<mozilla::StyleTransition>");;
+
+static_assert(sizeof(nsTArray<mozilla::StyleAnimation>) == sizeof(nsTArray_Simple<mozilla::StyleAnimation>), "Size mismatch between " "nsTArray<mozilla::StyleAnimation>" " and " "nsTArray_Simple<mozilla::StyleAnimation>"); static_assert(alignof(nsTArray<mozilla::StyleAnimation>) == alignof(nsTArray_Simple<mozilla::StyleAnimation>), "Align mismatch between " "nsTArray<mozilla::StyleAnimation>" " and " "nsTArray_Simple<mozilla::StyleAnimation>");;
+
+
+
+
+
+
+
+template<typename T>
+class nsCOMArray_Simple {
+  nsTArray<nsISupports*> mBuffer;
+};
+
+static_assert(sizeof(nsCOMArray<nsIContent>) == sizeof(nsCOMArray_Simple<nsIContent>), "Size mismatch between " "nsCOMArray<nsIContent>" " and " "nsCOMArray_Simple<nsIContent>"); static_assert(alignof(nsCOMArray<nsIContent>) == alignof(nsCOMArray_Simple<nsIContent>), "Align mismatch between " "nsCOMArray<nsIContent>" " and " "nsCOMArray_Simple<nsIContent>");;
+
+static_assert(sizeof(nsCOMArray<nsINode>) == sizeof(nsCOMArray_Simple<nsINode>), "Size mismatch between " "nsCOMArray<nsINode>" " and " "nsCOMArray_Simple<nsINode>"); static_assert(alignof(nsCOMArray<nsINode>) == alignof(nsCOMArray_Simple<nsINode>), "Align mismatch between " "nsCOMArray<nsINode>" " and " "nsCOMArray_Simple<nsINode>");;
+
+static_assert(sizeof(nsCOMArray<imgIContainer>) == sizeof(nsCOMArray_Simple<imgIContainer>), "Size mismatch between " "nsCOMArray<imgIContainer>" " and " "nsCOMArray_Simple<imgIContainer>"); static_assert(alignof(nsCOMArray<imgIContainer>) == alignof(nsCOMArray_Simple<imgIContainer>), "Align mismatch between " "nsCOMArray<imgIContainer>" " and " "nsCOMArray_Simple<imgIContainer>");;
+# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 2
+
+namespace mozilla {
+
+class ComputedTimingFunction
+{
+public:
+  static ComputedTimingFunction
+  CubicBezier(double x1, double y1, double x2, double y2)
+  {
+    return ComputedTimingFunction(x1, y1, x2, y2);
+  }
+  static ComputedTimingFunction
+  Steps(nsTimingFunction::Type aType, uint32_t aSteps)
+  {
+    do { } while (0);
+
+
+
+    do { } while (0);
+    return ComputedTimingFunction(aType, aSteps);
+  }
+  static ComputedTimingFunction
+  Frames(uint32_t aFrames)
+  {
+    do { } while (0);
+    return ComputedTimingFunction(nsTimingFunction::Type::Frames, aFrames);
+  }
+
+  ComputedTimingFunction() = default;
+  explicit ComputedTimingFunction(const nsTimingFunction& aFunction)
+  {
+    Init(aFunction);
+  }
+  void Init(const nsTimingFunction& aFunction);
+
+
+
+  enum class BeforeFlag {
+    Unset,
+    Set
+  };
+  double GetValue(double aPortion, BeforeFlag aBeforeFlag) const;
+  const nsSMILKeySpline* GetFunction() const
+  {
+    do { } while(0);
+    return &mTimingFunction;
+  }
+  nsTimingFunction::Type GetType() const { return mType; }
+  bool HasSpline() const { return nsTimingFunction::IsSplineType(mType); }
+  uint32_t GetSteps() const
+  {
+    do { } while (0);
+
+    return mStepsOrFrames;
+  }
+  uint32_t GetFrames() const
+  {
+    do { } while (0);
+    return mStepsOrFrames;
+  }
+  bool operator==(const ComputedTimingFunction& aOther) const
+  {
+    return mType == aOther.mType &&
+           (HasSpline() ?
+            mTimingFunction == aOther.mTimingFunction :
+            mStepsOrFrames == aOther.mStepsOrFrames);
+  }
+  bool operator!=(const ComputedTimingFunction& aOther) const
+  {
+    return !(*this == aOther);
+  }
+  int32_t Compare(const ComputedTimingFunction& aRhs) const;
+  void AppendToString(nsAString& aResult) const;
+
+  static double GetPortion(const Maybe<ComputedTimingFunction>& aFunction,
+                           double aPortion,
+                           BeforeFlag aBeforeFlag)
+  {
+    return aFunction ? aFunction->GetValue(aPortion, aBeforeFlag) : aPortion;
+  }
+  static int32_t Compare(const Maybe<ComputedTimingFunction>& aLhs,
+                         const Maybe<ComputedTimingFunction>& aRhs);
+
+private:
+  ComputedTimingFunction(double x1, double y1, double x2, double y2)
+    : mType(nsTimingFunction::Type::CubicBezier)
+    , mTimingFunction(x1, y1, x2, y2) { }
+  ComputedTimingFunction(nsTimingFunction::Type aType, uint32_t aStepsOrFrames)
+    : mType(aType)
+    , mStepsOrFrames(aStepsOrFrames) { }
+
+  nsTimingFunction::Type mType = nsTimingFunction::Type::Linear;
+  nsSMILKeySpline mTimingFunction;
+  uint32_t mStepsOrFrames;
+};
+
+}
+# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h" 1
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h"
+class nsIAtom;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}
+
+
+
+typedef uint8_t CSSPseudoClassTypeBase;
+enum class CSSPseudoClassType : CSSPseudoClassTypeBase
+{
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClassList.h" 1
+# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClassList.h"
+empty,
+mozOnlyWhitespace,
+mozEmptyExceptChildrenWithLocalname,
+lang,
+root,
+any,
+
+firstChild,
+firstNode,
+lastChild,
+lastNode,
+onlyChild,
+firstOfType,
+lastOfType,
+onlyOfType,
+nthChild,
+nthLastChild,
+nthOfType,
+nthLastOfType,
+
+
+mozIsHTML,
+
+
+ unresolved,
+
+
+
+
+mozNativeAnonymous,
+
+
+
+mozSystemMetric,
+
+
+
+mozLocaleDir,
+
+
+mozLWTheme,
+
+
+mozLWThemeBrightText,
+
+
+mozLWThemeDarkText,
+
+
+mozWindowInactive,
+
+
+
+mozTableBorderNonzero,
+
+
+
+mozBrowserFrame,
+
+
+
+
+scope,
+
+
+
+negation,
+
+
+
+dir,
+
+
+link,
+
+mozAnyLink,
+
+anyLink,
+
+visited,
+
+active,
+checked,
+disabled,
+enabled,
+focus,
+focusWithin,
+hover,
+mozDragOver,
+target,
+indeterminate,
+
+
+mozDevtoolsHighlighted,
+
+mozStyleeditorTransitioning,
+
+
+
+
+fullscreen,
+
+
+
+mozFullScreen,
+
+
+mozFocusRing,
+
+
+mozBroken,
+mozLoading,
+
+mozUserDisabled,
+
+
+mozSuppressed,
+
+
+mozHandlerClickToPlay,
+
+
+mozHandlerVulnerableUpdatable,
+
+
+mozHandlerVulnerableNoUpdate,
+
+
+mozHandlerDisabled,
+
+
+mozHandlerBlocked,
+
+
+mozHandlerCrashed,
+
+
+
+mozMathIncrementScriptLevel,
+
+
+
+
+
+required,
+optional,
+valid,
+invalid,
+inRange,
+outOfRange,
+defaultPseudo,
+placeholderShown,
+
+mozReadOnly,
+
+mozReadWrite,
+
+mozSubmitInvalid,
+
+mozUIInvalid,
+
+mozUIValid,
+
+mozMeterOptimum,
+
+mozMeterSubOptimum,
+
+mozMeterSubSubOptimum,
+
+
+
+mozPlaceholder,
+# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h" 2
+
+  Count,
+  NotPseudo,
+  MAX
+};
+
+}
+
+class nsCSSPseudoClasses
+{
+  typedef mozilla::CSSPseudoClassType Type;
+  typedef mozilla::CSSEnabledState EnabledState;
+
+public:
+  static void AddRefAtoms();
+
+  static Type GetPseudoType(nsIAtom* aAtom, EnabledState aEnabledState);
+  static bool HasStringArg(Type aType);
+  static bool HasNthPairArg(Type aType);
+  static bool HasSelectorListArg(Type aType) {
+    return aType == Type::any;
+  }
+  static bool IsUserActionPseudoClass(Type aType);
+
+
+  static void PseudoTypeToString(Type aType, nsAString& aString);
+
+  static bool IsEnabled(Type aType, EnabledState aEnabledState)
+  {
+    auto index = static_cast<size_t>(aType);
+    do { } while (0);
+    if (sPseudoClassEnabled[index] ||
+        aEnabledState == EnabledState::eIgnoreEnabledState) {
+      return true;
+    }
+    auto flags = kPseudoClassFlags[index];
+    if (((aEnabledState & EnabledState::eInChrome) &&
+         (flags & (1<<1))) ||
+        ((aEnabledState & EnabledState::eInUASheets) &&
+         (flags & (1<<0)))) {
+      return true;
+    }
+    return false;
+  }
+
+
+
+
+  static mozilla::Maybe<bool>
+    MatchesElement(Type aType, const mozilla::dom::Element* aElement);
+
+private:
+  static const uint32_t kPseudoClassFlags[size_t(Type::Count)];
+  static bool sPseudoClassEnabled[size_t(Type::Count)];
+};
+# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
+class nsIAtom;
+class nsIPrincipal;
+class nsIURI;
+struct nsFont;
+namespace mozilla {
+  class ServoStyleSheet;
+  class FontFamilyList;
+  enum FontFamilyType : uint32_t;
+  struct Keyframe;
+  namespace css {
+    struct URLValue;
+  };
+  enum class UpdateAnimationsTasks : uint8_t;
+}
+using mozilla::FontFamilyList;
+using mozilla::FontFamilyType;
+using mozilla::ServoElementSnapshot;
+class nsCSSFontFaceRule;
+struct nsMediaFeature;
+struct nsStyleList;
+struct nsStyleImage;
+struct nsStyleGradientStop;
+class nsStyleGradient;
+class nsStyleCoord;
+struct nsStyleDisplay;
+# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
+struct nsTArrayBorrowed_uintptr_t { nsTArray<uintptr_t>* mArray; nsTArrayBorrowed_uintptr_t(nsTArray<uintptr_t>* aArray) : mArray(aArray) {} };
+
+
+extern "C" {
+
+class ServoBundledURI
+{
+public:
+  already_AddRefed<mozilla::css::URLValue> IntoCssUrl();
+  const uint8_t* mURLString;
+  uint32_t mURLStringLength;
+  mozilla::css::URLExtraData* mExtraData;
+};
+
+
+uint32_t Gecko_ChildrenCount(RawGeckoNodeBorrowed node);
+bool Gecko_NodeIsElement(RawGeckoNodeBorrowed node);
+bool Gecko_IsInDocument(RawGeckoNodeBorrowed node);
+bool Gecko_FlattenedTreeParentIsParent(RawGeckoNodeBorrowed node);
+bool Gecko_IsSignificantChild(RawGeckoNodeBorrowed node,
+                              bool text_is_significant,
+                              bool whitespace_is_significant);
+RawGeckoNodeBorrowedOrNull Gecko_GetParentNode(RawGeckoNodeBorrowed node);
+RawGeckoNodeBorrowedOrNull Gecko_GetFirstChild(RawGeckoNodeBorrowed node);
+RawGeckoNodeBorrowedOrNull Gecko_GetLastChild(RawGeckoNodeBorrowed node);
+RawGeckoNodeBorrowedOrNull Gecko_GetPrevSibling(RawGeckoNodeBorrowed node);
+RawGeckoNodeBorrowedOrNull Gecko_GetNextSibling(RawGeckoNodeBorrowed node);
+RawGeckoElementBorrowedOrNull Gecko_GetFirstChildElement(RawGeckoElementBorrowed element);
+RawGeckoElementBorrowedOrNull Gecko_GetLastChildElement(RawGeckoElementBorrowed element);
+RawGeckoElementBorrowedOrNull Gecko_GetPrevSiblingElement(RawGeckoElementBorrowed element);
+RawGeckoElementBorrowedOrNull Gecko_GetNextSiblingElement(RawGeckoElementBorrowed element);
+RawGeckoElementBorrowedOrNull Gecko_GetDocumentElement(RawGeckoDocumentBorrowed document);
+void Gecko_LoadStyleSheet(mozilla::css::Loader* loader,
+                          mozilla::ServoStyleSheet* parent,
+                          RawServoStyleSheetBorrowed child_sheet,
+                          RawGeckoURLExtraData* base_url_data,
+                          const uint8_t* url_bytes,
+                          uint32_t url_length,
+                          const uint8_t* media_bytes,
+                          uint32_t media_length);
+
+
+
+RawGeckoURLExtraData* Gecko_URLExtraData_CreateDummy();
+
+
+
+
+
+
+
+StyleChildrenIteratorOwnedOrNull Gecko_MaybeCreateStyleChildrenIterator(RawGeckoNodeBorrowed node);
+void Gecko_DropStyleChildrenIterator(StyleChildrenIteratorOwned it);
+RawGeckoNodeBorrowedOrNull Gecko_GetNextStyleChild(StyleChildrenIteratorBorrowedMut it);
+
+
+uint64_t Gecko_ElementState(RawGeckoElementBorrowed element);
+bool Gecko_IsTextNode(RawGeckoNodeBorrowed node);
+bool Gecko_IsRootElement(RawGeckoElementBorrowed element);
+bool Gecko_MatchesElement(mozilla::CSSPseudoClassType type, RawGeckoElementBorrowed element);
+nsIAtom* Gecko_LocalName(RawGeckoElementBorrowed element);
+nsIAtom* Gecko_Namespace(RawGeckoElementBorrowed element);
+nsIAtom* Gecko_GetElementId(RawGeckoElementBorrowed element);
+
+nsIAtom* Gecko_GetXMLLangValue(RawGeckoElementBorrowed element);
+# 166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
+nsIAtom* Gecko_AtomAttrValue(RawGeckoElementBorrowed element, nsIAtom* attribute); bool Gecko_HasAttr(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name); bool Gecko_AttrEquals(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str, bool ignoreCase); bool Gecko_AttrDashEquals(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrIncludes(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasSubstring(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasPrefix(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasSuffix(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); uint32_t Gecko_ClassOrClassList(RawGeckoElementBorrowed element, nsIAtom** class_, nsIAtom*** classList);
+nsIAtom* Gecko_SnapshotAtomAttrValue(const ServoElementSnapshot* element, nsIAtom* attribute); bool Gecko_SnapshotHasAttr(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name); bool Gecko_SnapshotAttrEquals(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str, bool ignoreCase); bool Gecko_SnapshotAttrDashEquals(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrIncludes(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasSubstring(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasPrefix(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasSuffix(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); uint32_t Gecko_SnapshotClassOrClassList(const ServoElementSnapshot* element, nsIAtom** class_, nsIAtom*** classList);
+
+
+
+
+
+RawServoDeclarationBlockStrongBorrowedOrNull
+Gecko_GetStyleAttrDeclarationBlock(RawGeckoElementBorrowed element);
+RawServoDeclarationBlockStrongBorrowedOrNull
+Gecko_GetHTMLPresentationAttrDeclarationBlock(RawGeckoElementBorrowed element);
+RawServoDeclarationBlockStrongBorrowedOrNull
+Gecko_GetExtraContentStyleDeclarations(RawGeckoElementBorrowed element);
+
+
+bool
+Gecko_GetAnimationRule(RawGeckoElementBorrowed aElement,
+                       nsIAtom* aPseudoTag,
+                       mozilla::EffectCompositor::CascadeLevel aCascadeLevel,
+                       RawServoAnimationValueMapBorrowed aAnimationValues);
+bool Gecko_StyleAnimationsEquals(RawGeckoStyleAnimationListBorrowed,
+                                 RawGeckoStyleAnimationListBorrowed);
+void Gecko_UpdateAnimations(RawGeckoElementBorrowed aElement,
+                            nsIAtom* aPseudoTagOrNull,
+                            ServoComputedValuesBorrowedOrNull aComputedValues,
+                            ServoComputedValuesBorrowedOrNull aParentComputedValues,
+                            mozilla::UpdateAnimationsTasks aTaskBits);
+bool Gecko_ElementHasAnimations(RawGeckoElementBorrowed aElement,
+                                nsIAtom* aPseudoTagOrNull);
+bool Gecko_ElementHasCSSAnimations(RawGeckoElementBorrowed aElement,
+                                   nsIAtom* aPseudoTagOrNull);
+double Gecko_GetProgressFromComputedTiming(RawGeckoComputedTimingBorrowed aComputedTiming);
+double Gecko_GetPositionInSegment(
+  RawGeckoAnimationPropertySegmentBorrowed aSegment,
+  double aProgress,
+  mozilla::ComputedTimingFunction::BeforeFlag aBeforeFlag);
+
+
+
+
+RawServoAnimationValueBorrowedOrNull Gecko_AnimationGetBaseStyle(
+  void* aBaseStyles,
+  nsCSSPropertyID aProperty);
+
+
+nsIAtom* Gecko_Atomize(const char* aString, uint32_t aLength);
+void Gecko_AddRefAtom(nsIAtom* aAtom);
+void Gecko_ReleaseAtom(nsIAtom* aAtom);
+const uint16_t* Gecko_GetAtomAsUTF16(nsIAtom* aAtom, uint32_t* aLength);
+bool Gecko_AtomEqualsUTF8(nsIAtom* aAtom, const char* aString, uint32_t aLength);
+bool Gecko_AtomEqualsUTF8IgnoreCase(nsIAtom* aAtom, const char* aString, uint32_t aLength);
+
+
+void Gecko_FontFamilyList_Clear(FontFamilyList* aList);
+void Gecko_FontFamilyList_AppendNamed(FontFamilyList* aList, nsIAtom* aName, bool aQuoted);
+void Gecko_FontFamilyList_AppendGeneric(FontFamilyList* list, FontFamilyType familyType);
+void Gecko_CopyFontFamilyFrom(nsFont* dst, const nsFont* src);
+
+
+void Gecko_SetListStyleType(nsStyleList* style_struct, uint32_t type);
+void Gecko_CopyListStyleTypeFrom(nsStyleList* dst, const nsStyleList* src);
+
+
+
+void Gecko_SetNullImageValue(nsStyleImage* image);
+void Gecko_SetGradientImageValue(nsStyleImage* image, nsStyleGradient* gradient);
+void Gecko_SetUrlImageValue(nsStyleImage* image,
+                            ServoBundledURI uri);
+void Gecko_CopyImageValueFrom(nsStyleImage* image, const nsStyleImage* other);
+void Gecko_InitializeImageCropRect(nsStyleImage* image);
+
+nsStyleGradient* Gecko_CreateGradient(uint8_t shape,
+                                      uint8_t size,
+                                      bool repeating,
+                                      bool legacy_syntax,
+                                      uint32_t stops);
+
+
+void Gecko_SetListStyleImageNone(nsStyleList* style_struct);
+void Gecko_SetListStyleImage(nsStyleList* style_struct,
+                             ServoBundledURI uri);
+void Gecko_CopyListStyleImageFrom(nsStyleList* dest, const nsStyleList* src);
+
+
+void Gecko_SetCursorArrayLength(nsStyleUserInterface* ui, size_t len);
+void Gecko_SetCursorImage(nsCursorImage* cursor,
+                          ServoBundledURI uri);
+void Gecko_CopyCursorArrayFrom(nsStyleUserInterface* dest,
+                               const nsStyleUserInterface* src);
+
+void Gecko_SetContentDataImage(nsStyleContentData* content_data, ServoBundledURI uri);
+void Gecko_SetContentDataArray(nsStyleContentData* content_data, nsStyleContentType type, uint32_t len);
+
+
+uint32_t Gecko_GetNodeFlags(RawGeckoNodeBorrowed node);
+void Gecko_SetNodeFlags(RawGeckoNodeBorrowed node, uint32_t flags);
+void Gecko_UnsetNodeFlags(RawGeckoNodeBorrowed node, uint32_t flags);
+void Gecko_SetOwnerDocumentNeedsStyleFlush(RawGeckoElementBorrowed element);
+
+
+
+
+nsStyleContext* Gecko_GetStyleContext(RawGeckoNodeBorrowed node,
+                                      nsIAtom* aPseudoTagOrNull);
+nsChangeHint Gecko_CalcStyleDifference(nsStyleContext* oldstyle,
+                                       ServoComputedValuesBorrowed newstyle);
+nsChangeHint Gecko_HintsHandledForDescendants(nsChangeHint aHint);
+
+
+ServoElementSnapshotOwned Gecko_CreateElementSnapshot(RawGeckoElementBorrowed element);
+void Gecko_DropElementSnapshot(ServoElementSnapshotOwned snapshot);
+
+
+
+
+void Gecko_EnsureTArrayCapacity(void* array, size_t capacity, size_t elem_size);
+
+
+
+
+
+void Gecko_ClearPODTArray(void* array, size_t elem_size, size_t elem_align);
+
+
+
+void Gecko_ClearAndResizeStyleContents(nsStyleContent* content,
+                                       uint32_t how_many);
+void Gecko_ClearAndResizeCounterIncrements(nsStyleContent* content,
+                                           uint32_t how_many);
+void Gecko_ClearAndResizeCounterResets(nsStyleContent* content,
+                                       uint32_t how_many);
+void Gecko_CopyStyleContentsFrom(nsStyleContent* content, const nsStyleContent* other);
+void Gecko_CopyCounterResetsFrom(nsStyleContent* content, const nsStyleContent* other);
+void Gecko_CopyCounterIncrementsFrom(nsStyleContent* content, const nsStyleContent* other);
+
+void Gecko_EnsureImageLayersLength(nsStyleImageLayers* layers, size_t len,
+                                   nsStyleImageLayers::LayerType layer_type);
+
+void Gecko_EnsureStyleAnimationArrayLength(void* array, size_t len);
+void Gecko_EnsureStyleTransitionArrayLength(void* array, size_t len);
+
+void Gecko_ClearWillChange(nsStyleDisplay* display, size_t length);
+void Gecko_AppendWillChange(nsStyleDisplay* display, nsIAtom* atom);
+void Gecko_CopyWillChangeFrom(nsStyleDisplay* dest, nsStyleDisplay* src);
+
+mozilla::Keyframe* Gecko_AnimationAppendKeyframe(RawGeckoKeyframeListBorrowedMut keyframes,
+                                                 float offset,
+                                                 const nsTimingFunction* timingFunction);
+
+
+void Gecko_ResetStyleCoord(nsStyleUnit* unit, nsStyleUnion* value);
+
+
+void Gecko_SetStyleCoordCalcValue(nsStyleUnit* unit, nsStyleUnion* value, nsStyleCoord::CalcValue calc);
+
+void Gecko_CopyClipPathValueFrom(mozilla::StyleShapeSource* dst, const mozilla::StyleShapeSource* src);
+
+void Gecko_DestroyClipPath(mozilla::StyleShapeSource* clip);
+mozilla::StyleBasicShape* Gecko_NewBasicShape(mozilla::StyleBasicShapeType type);
+void Gecko_StyleClipPath_SetURLValue(mozilla::StyleShapeSource* clip, ServoBundledURI uri);
+
+void Gecko_ResetFilters(nsStyleEffects* effects, size_t new_len);
+void Gecko_CopyFiltersFrom(nsStyleEffects* aSrc, nsStyleEffects* aDest);
+void Gecko_nsStyleFilter_SetURLValue(nsStyleFilter* effects, ServoBundledURI uri);
+
+void Gecko_nsStyleSVGPaint_CopyFrom(nsStyleSVGPaint* dest, const nsStyleSVGPaint* src);
+void Gecko_nsStyleSVGPaint_SetURLValue(nsStyleSVGPaint* paint, ServoBundledURI uri);
+void Gecko_nsStyleSVGPaint_Reset(nsStyleSVGPaint* paint);
+
+void Gecko_nsStyleSVG_SetDashArrayLength(nsStyleSVG* svg, uint32_t len);
+void Gecko_nsStyleSVG_CopyDashArray(nsStyleSVG* dst, const nsStyleSVG* src);
+
+mozilla::css::URLValue* Gecko_NewURLValue(ServoBundledURI uri);
+void Gecko_AddRefCSSURLValueArbitraryThread(mozilla::css::URLValue* aPtr); void Gecko_ReleaseCSSURLValueArbitraryThread(mozilla::css::URLValue* aPtr);;
+void Gecko_AddRefURLExtraDataArbitraryThread(RawGeckoURLExtraData* aPtr); void Gecko_ReleaseURLExtraDataArbitraryThread(RawGeckoURLExtraData* aPtr);;
+
+void Gecko_FillAllBackgroundLists(nsStyleImageLayers* layers, uint32_t max_len);
+void Gecko_FillAllMaskLists(nsStyleImageLayers* layers, uint32_t max_len);
+void Gecko_AddRefCalcArbitraryThread(nsStyleCoord::Calc* aPtr); void Gecko_ReleaseCalcArbitraryThread(nsStyleCoord::Calc* aPtr);;
+
+nsCSSShadowArray* Gecko_NewCSSShadowArray(uint32_t len);
+void Gecko_AddRefCSSShadowArrayArbitraryThread(nsCSSShadowArray* aPtr); void Gecko_ReleaseCSSShadowArrayArbitraryThread(nsCSSShadowArray* aPtr);;
+
+nsStyleQuoteValues* Gecko_NewStyleQuoteValues(uint32_t len);
+void Gecko_AddRefQuoteValuesArbitraryThread(nsStyleQuoteValues* aPtr); void Gecko_ReleaseQuoteValuesArbitraryThread(nsStyleQuoteValues* aPtr);;
+
+nsCSSValueSharedList* Gecko_NewCSSValueSharedList(uint32_t len);
+
+
+nsCSSValueBorrowedMut Gecko_CSSValue_GetArrayItem(nsCSSValueBorrowedMut css_value, int32_t index);
+
+nsCSSValueBorrowed Gecko_CSSValue_GetArrayItemConst(nsCSSValueBorrowed css_value, int32_t index);
+nscoord Gecko_CSSValue_GetAbsoluteLength(nsCSSValueBorrowed css_value);
+float Gecko_CSSValue_GetAngle(nsCSSValueBorrowed css_value);
+nsCSSKeyword Gecko_CSSValue_GetKeyword(nsCSSValueBorrowed aCSSValue);
+float Gecko_CSSValue_GetNumber(nsCSSValueBorrowed css_value);
+float Gecko_CSSValue_GetPercentage(nsCSSValueBorrowed css_value);
+nsStyleCoord::CalcValue Gecko_CSSValue_GetCalc(nsCSSValueBorrowed aCSSValue);
+
+void Gecko_CSSValue_SetAbsoluteLength(nsCSSValueBorrowedMut css_value, nscoord len);
+void Gecko_CSSValue_SetNormal(nsCSSValueBorrowedMut css_value);
+void Gecko_CSSValue_SetNumber(nsCSSValueBorrowedMut css_value, float number);
+void Gecko_CSSValue_SetKeyword(nsCSSValueBorrowedMut css_value, nsCSSKeyword keyword);
+void Gecko_CSSValue_SetPercentage(nsCSSValueBorrowedMut css_value, float percent);
+void Gecko_CSSValue_SetAngle(nsCSSValueBorrowedMut css_value, float radians);
+void Gecko_CSSValue_SetCalc(nsCSSValueBorrowedMut css_value, nsStyleCoord::CalcValue calc);
+void Gecko_CSSValue_SetFunction(nsCSSValueBorrowedMut css_value, int32_t len);
+void Gecko_CSSValue_SetString(nsCSSValueBorrowedMut css_value,
+                              const uint8_t* string, uint32_t len, nsCSSUnit unit);
+void Gecko_CSSValue_SetStringFromAtom(nsCSSValueBorrowedMut css_value,
+                                      nsIAtom* atom, nsCSSUnit unit);
+void Gecko_CSSValue_SetArray(nsCSSValueBorrowedMut css_value, int32_t len);
+void Gecko_CSSValue_SetURL(nsCSSValueBorrowedMut css_value, ServoBundledURI uri);
+void Gecko_CSSValue_SetInt(nsCSSValueBorrowedMut css_value, int32_t integer, nsCSSUnit unit);
+void Gecko_CSSValue_Drop(nsCSSValueBorrowedMut css_value);
+void Gecko_AddRefCSSValueSharedListArbitraryThread(nsCSSValueSharedList* aPtr); void Gecko_ReleaseCSSValueSharedListArbitraryThread(nsCSSValueSharedList* aPtr);;
+bool Gecko_PropertyId_IsPrefEnabled(nsCSSPropertyID id);
+
+void Gecko_nsStyleFont_SetLang(nsStyleFont* font, nsIAtom* atom);
+void Gecko_nsStyleFont_CopyLangFrom(nsStyleFont* aFont, const nsStyleFont* aSource);
+nscoord Gecko_nsStyleFont_GetBaseSize(const nsStyleFont* font, RawGeckoPresContextBorrowed pres_context);
+
+const nsMediaFeature* Gecko_GetMediaFeatures();
+
+
+
+nsCSSFontFaceRule* Gecko_CSSFontFaceRule_Create();
+void Gecko_CSSFontFaceRule_GetCssText(const nsCSSFontFaceRule* rule, nsAString* result);
+void Gecko_CSSFontFaceRule_AddRef(nsCSSFontFaceRule* aPtr); void Gecko_CSSFontFaceRule_Release(nsCSSFontFaceRule* aPtr);;
+
+RawGeckoElementBorrowedOrNull Gecko_GetBody(RawGeckoPresContextBorrowed pres_context);
+
+
+
+nscolor Gecko_GetLookAndFeelSystemColor(int32_t color_id,
+                                        RawGeckoPresContextBorrowed pres_context);
+
+bool Gecko_MatchStringArgPseudo(RawGeckoElementBorrowed element,
+                                mozilla::CSSPseudoClassType type,
+                                const char16_t* ident,
+                                bool* set_slow_selector);
+# 416 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
+void Gecko_Construct_Default_nsStyleFont( nsStyleFont* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleFont(nsStyleFont* ptr, const nsStyleFont* other); void Gecko_Destroy_nsStyleFont(nsStyleFont* ptr);
+
+
+
+void Gecko_Construct_Default_nsStyleColor( nsStyleColor* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleColor(nsStyleColor* ptr, const nsStyleColor* other); void Gecko_Destroy_nsStyleColor(nsStyleColor* ptr);
+
+
+void Gecko_Construct_Default_nsStyleList( nsStyleList* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleList(nsStyleList* ptr, const nsStyleList* other); void Gecko_Destroy_nsStyleList(nsStyleList* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleText( nsStyleText* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleText(nsStyleText* ptr, const nsStyleText* other); void Gecko_Destroy_nsStyleText(nsStyleText* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleVisibility( nsStyleVisibility* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleVisibility(nsStyleVisibility* ptr, const nsStyleVisibility* other); void Gecko_Destroy_nsStyleVisibility(nsStyleVisibility* ptr);
+
+
+void Gecko_Construct_Default_nsStyleUserInterface( nsStyleUserInterface* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleUserInterface(nsStyleUserInterface* ptr, const nsStyleUserInterface* other); void Gecko_Destroy_nsStyleUserInterface(nsStyleUserInterface* ptr);
+
+
+void Gecko_Construct_Default_nsStyleTableBorder( nsStyleTableBorder* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTableBorder(nsStyleTableBorder* ptr, const nsStyleTableBorder* other); void Gecko_Destroy_nsStyleTableBorder(nsStyleTableBorder* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleSVG( nsStyleSVG* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleSVG(nsStyleSVG* ptr, const nsStyleSVG* other); void Gecko_Destroy_nsStyleSVG(nsStyleSVG* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleVariables( nsStyleVariables* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleVariables(nsStyleVariables* ptr, const nsStyleVariables* other); void Gecko_Destroy_nsStyleVariables(nsStyleVariables* ptr);
+
+void Gecko_Construct_Default_nsStyleBackground( nsStyleBackground* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleBackground(nsStyleBackground* ptr, const nsStyleBackground* other); void Gecko_Destroy_nsStyleBackground(nsStyleBackground* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStylePosition( nsStylePosition* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStylePosition(nsStylePosition* ptr, const nsStylePosition* other); void Gecko_Destroy_nsStylePosition(nsStylePosition* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleTextReset( nsStyleTextReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTextReset(nsStyleTextReset* ptr, const nsStyleTextReset* other); void Gecko_Destroy_nsStyleTextReset(nsStyleTextReset* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleDisplay( nsStyleDisplay* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleDisplay(nsStyleDisplay* ptr, const nsStyleDisplay* other); void Gecko_Destroy_nsStyleDisplay(nsStyleDisplay* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleContent( nsStyleContent* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleContent(nsStyleContent* ptr, const nsStyleContent* other); void Gecko_Destroy_nsStyleContent(nsStyleContent* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleUIReset( nsStyleUIReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleUIReset(nsStyleUIReset* ptr, const nsStyleUIReset* other); void Gecko_Destroy_nsStyleUIReset(nsStyleUIReset* ptr);
+
+
+void Gecko_Construct_Default_nsStyleTable( nsStyleTable* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTable(nsStyleTable* ptr, const nsStyleTable* other); void Gecko_Destroy_nsStyleTable(nsStyleTable* ptr);
+
+
+void Gecko_Construct_Default_nsStyleMargin( nsStyleMargin* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleMargin(nsStyleMargin* ptr, const nsStyleMargin* other); void Gecko_Destroy_nsStyleMargin(nsStyleMargin* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStylePadding( nsStylePadding* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStylePadding(nsStylePadding* ptr, const nsStylePadding* other); void Gecko_Destroy_nsStylePadding(nsStylePadding* ptr);
+
+
+
+
+void Gecko_Construct_Default_nsStyleBorder( nsStyleBorder* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleBorder(nsStyleBorder* ptr, const nsStyleBorder* other); void Gecko_Destroy_nsStyleBorder(nsStyleBorder* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleOutline( nsStyleOutline* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleOutline(nsStyleOutline* ptr, const nsStyleOutline* other); void Gecko_Destroy_nsStyleOutline(nsStyleOutline* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleXUL( nsStyleXUL* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleXUL(nsStyleXUL* ptr, const nsStyleXUL* other); void Gecko_Destroy_nsStyleXUL(nsStyleXUL* ptr);
+
+
+void Gecko_Construct_Default_nsStyleSVGReset( nsStyleSVGReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleSVGReset(nsStyleSVGReset* ptr, const nsStyleSVGReset* other); void Gecko_Destroy_nsStyleSVGReset(nsStyleSVGReset* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleColumn( nsStyleColumn* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleColumn(nsStyleColumn* ptr, const nsStyleColumn* other); void Gecko_Destroy_nsStyleColumn(nsStyleColumn* ptr);
+
+
+
+
+
+void Gecko_Construct_Default_nsStyleEffects( nsStyleEffects* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleEffects(nsStyleEffects* ptr, const nsStyleEffects* other); void Gecko_Destroy_nsStyleEffects(nsStyleEffects* ptr);
+# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+
+
+void Gecko_Construct_nsStyleVariables(nsStyleVariables* ptr);
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 1
+# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
+void Servo_Element_ClearData(RawGeckoElementBorrowed node);
+
+
+RawServoStyleSheetStrong Servo_StyleSheet_Empty(mozilla::css::SheetParsingMode parsing_mode);
+
+RawServoStyleSheetStrong Servo_StyleSheet_FromUTF8Bytes(mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, const nsACString* data, mozilla::css::SheetParsingMode parsing_mode, RawGeckoURLExtraData* extra_data);
+
+
+
+
+
+RawServoStyleSheetStrong Servo_ImportRule_GetSheet(const RawServoImportRuleBorrowed import_rule);
+
+
+void Servo_StyleSheet_ClearAndUpdate(RawServoStyleSheetBorrowed stylesheet, mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, const nsACString* data, RawGeckoURLExtraData* extra_data);
+
+
+
+
+
+
+bool Servo_StyleSheet_HasRules(RawServoStyleSheetBorrowed sheet);
+
+ServoCssRulesStrong Servo_StyleSheet_GetRules(RawServoStyleSheetBorrowed sheet);
+
+RawServoStyleSetOwned Servo_StyleSet_Init(RawGeckoPresContextOwned pres_context);
+void Servo_StyleSet_RebuildData(RawServoStyleSetBorrowed set);
+
+void Servo_StyleSet_Drop(RawServoStyleSetOwned set);
+void Servo_StyleSet_AppendStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
+
+void Servo_StyleSet_PrependStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
+
+void Servo_StyleSet_RemoveStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
+
+void Servo_StyleSet_InsertStyleSheetBefore(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, RawServoStyleSheetBorrowed reference, bool flush);
+
+
+void Servo_StyleSet_FlushStyleSheets(RawServoStyleSetBorrowed set);
+void Servo_StyleSet_NoteStyleSheetsChanged(RawServoStyleSetBorrowed set);
+
+bool Servo_StyleSet_FillKeyframesForName(RawServoStyleSetBorrowed set, const nsACString* property, nsTimingFunctionBorrowed timing_function, ServoComputedValuesBorrowed computed_values, RawGeckoKeyframeListBorrowedMut keyframe_list);
+
+
+
+
+
+void Servo_StyleSet_GetFontFaceRules(RawServoStyleSetBorrowed set, RawGeckoFontFaceRuleListBorrowedMut list);
+
+
+
+
+void Servo_CssRules_ListTypes(ServoCssRulesBorrowed rules, nsTArrayBorrowed_uintptr_t result);
+
+
+nsresult Servo_CssRules_InsertRule(ServoCssRulesBorrowed rules, RawServoStyleSheetBorrowed sheet, const nsACString* rule, uint32_t index, bool nested, mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, uint16_t* rule_type);
+
+
+
+
+
+nsresult Servo_CssRules_DeleteRule(ServoCssRulesBorrowed rules, uint32_t index);
+# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
+RawServoStyleRuleStrong Servo_CssRules_GetStyleRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_StyleRule_Debug(RawServoStyleRuleBorrowed rule, nsACString* result); void Servo_StyleRule_GetCssText(RawServoStyleRuleBorrowed rule, nsAString* result);
+RawServoMediaRuleStrong Servo_CssRules_GetMediaRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_MediaRule_Debug(RawServoMediaRuleBorrowed rule, nsACString* result); void Servo_MediaRule_GetCssText(RawServoMediaRuleBorrowed rule, nsAString* result);
+RawServoNamespaceRuleStrong Servo_CssRules_GetNamespaceRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_NamespaceRule_Debug(RawServoNamespaceRuleBorrowed rule, nsACString* result); void Servo_NamespaceRule_GetCssText(RawServoNamespaceRuleBorrowed rule, nsAString* result);
+
+nsCSSFontFaceRule* Servo_CssRules_GetFontFaceRuleAt(ServoCssRulesBorrowed rules, uint32_t index);
+
+RawServoDeclarationBlockStrong Servo_StyleRule_GetStyle(RawServoStyleRuleBorrowed rule);
+
+void Servo_StyleRule_SetStyle(RawServoStyleRuleBorrowed rule, RawServoDeclarationBlockBorrowed declarations);
+
+
+void Servo_StyleRule_GetSelectorText(RawServoStyleRuleBorrowed rule, nsAString* result);
+
+RawServoMediaListStrong Servo_MediaRule_GetMedia(RawServoMediaRuleBorrowed rule);
+
+ServoCssRulesStrong Servo_MediaRule_GetRules(RawServoMediaRuleBorrowed rule);
+
+nsIAtom* Servo_NamespaceRule_GetPrefix(RawServoNamespaceRuleBorrowed rule);
+
+nsIAtom* Servo_NamespaceRule_GetURI(RawServoNamespaceRuleBorrowed rule);
+
+
+
+RawServoDeclarationBlockStrong Servo_ParseProperty(const nsACString* property, const nsACString* value, RawGeckoURLExtraData* data);
+
+
+
+bool Servo_ParseEasing(const nsAString* easing, RawGeckoURLExtraData* data, nsTimingFunctionBorrowedMut output);
+
+
+
+void Servo_GetComputedKeyframeValues(RawGeckoKeyframeListBorrowed keyframes, ServoComputedValuesBorrowed style, ServoComputedValuesBorrowedOrNull parent_style, RawServoStyleSetBorrowed set, RawGeckoComputedKeyframeValuesListBorrowedMut result);
+
+
+
+
+
+void Servo_AnimationValueMap_Push(RawServoAnimationValueMapBorrowed, nsCSSPropertyID property, RawServoAnimationValueBorrowed value);
+
+
+
+RawServoAnimationValueStrong Servo_ComputedValues_ExtractAnimationValue(ServoComputedValuesBorrowed computed_values, nsCSSPropertyID property);
+
+
+
+
+
+RawServoAnimationValueStrong Servo_AnimationValues_Interpolate(RawServoAnimationValueBorrowed from, RawServoAnimationValueBorrowed to, double progress);
+
+
+
+
+void Servo_AnimationValue_Serialize(RawServoAnimationValueBorrowed value, nsCSSPropertyID property, nsAString* buffer);
+
+
+
+float Servo_AnimationValue_GetOpacity(RawServoAnimationValueBorrowed value);
+
+void Servo_AnimationValue_GetTransform(RawServoAnimationValueBorrowed value, RefPtr<nsCSSValueSharedList>* list);
+
+
+bool Servo_AnimationValue_DeepEqual(RawServoAnimationValueBorrowed, RawServoAnimationValueBorrowed);
+
+
+
+
+RawServoDeclarationBlockStrong Servo_ParseStyleAttribute(const nsACString* data, RawGeckoURLExtraData* extra_data);
+
+
+RawServoDeclarationBlockStrong Servo_DeclarationBlock_CreateEmpty();
+
+RawServoDeclarationBlockStrong Servo_DeclarationBlock_Clone(RawServoDeclarationBlockBorrowed declarations);
+
+bool Servo_DeclarationBlock_Equals(RawServoDeclarationBlockBorrowed a, RawServoDeclarationBlockBorrowed b);
+
+
+void Servo_DeclarationBlock_GetCssText(RawServoDeclarationBlockBorrowed declarations, nsAString* result);
+
+
+void Servo_DeclarationBlock_SerializeOneValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsAString* buffer);
+
+
+uint32_t Servo_DeclarationBlock_Count(RawServoDeclarationBlockBorrowed declarations);
+
+bool Servo_DeclarationBlock_GetNthProperty(RawServoDeclarationBlockBorrowed declarations, uint32_t index, nsAString* result);
+
+
+void Servo_DeclarationBlock_GetPropertyValue(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, nsAString* value);
+
+
+void Servo_DeclarationBlock_GetPropertyValueById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsAString* value);
+
+
+bool Servo_DeclarationBlock_GetPropertyIsImportant(RawServoDeclarationBlockBorrowed declarations, const nsACString* property);
+
+
+bool Servo_DeclarationBlock_SetProperty(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
+
+
+
+
+bool Servo_DeclarationBlock_SetPropertyById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
+
+
+
+
+void Servo_DeclarationBlock_RemoveProperty(RawServoDeclarationBlockBorrowed declarations, const nsACString* property);
+
+
+void Servo_DeclarationBlock_RemovePropertyById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
+
+
+
+
+
+void Servo_AnimationCompose(RawServoAnimationValueMapBorrowed animation_values, void* base_values, nsCSSPropertyID property, RawGeckoAnimationPropertySegmentBorrowed animation_segment, RawGeckoComputedTimingBorrowed computed_timing);
+
+
+
+
+
+
+
+bool Servo_DeclarationBlock_PropertyIsSet(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
+
+
+void Servo_DeclarationBlock_SetIdentStringValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsIAtom* value);
+
+
+
+void Servo_DeclarationBlock_SetKeywordValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
+
+
+
+void Servo_DeclarationBlock_SetIntValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
+
+
+
+void Servo_DeclarationBlock_SetPixelValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
+
+
+
+void Servo_DeclarationBlock_SetPercentValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
+
+
+
+void Servo_DeclarationBlock_SetAutoValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
+
+
+void Servo_DeclarationBlock_SetCurrentColor(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
+
+
+void Servo_DeclarationBlock_SetColorValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nscolor value);
+
+
+
+void Servo_DeclarationBlock_SetFontFamily(RawServoDeclarationBlockBorrowed declarations, const nsAString& value);
+
+
+void Servo_DeclarationBlock_SetTextDecorationColorOverride(RawServoDeclarationBlockBorrowed declarations);
+
+
+
+void Servo_MediaList_GetText(RawServoMediaListBorrowed list, nsAString* result);
+
+void Servo_MediaList_SetText(RawServoMediaListBorrowed list, const nsACString* text);
+
+uint32_t Servo_MediaList_GetLength(RawServoMediaListBorrowed list);
+
+bool Servo_MediaList_GetMediumAt(RawServoMediaListBorrowed list, uint32_t index, nsAString* result);
+
+
+void Servo_MediaList_AppendMedium(RawServoMediaListBorrowed list, const nsACString* new_medium);
+
+bool Servo_MediaList_DeleteMedium(RawServoMediaListBorrowed list, const nsACString* old_medium);
+
+
+
+bool Servo_CSSSupports2(const nsACString* name, const nsACString* value);
+
+bool Servo_CSSSupports(const nsACString* cond);
+
+
+
+ServoComputedValuesStrong Servo_ComputedValues_GetForAnonymousBox(ServoComputedValuesBorrowedOrNull parent_style_or_null, nsIAtom* pseudoTag, bool skip_display_fixup, RawServoStyleSetBorrowed set);
+
+
+
+
+ServoComputedValuesStrong Servo_ComputedValues_Inherit(RawServoStyleSetBorrowed set, ServoComputedValuesBorrowedOrNull parent_style);
+
+
+
+
+void Servo_Initialize();
+
+void Servo_Shutdown();
+
+
+
+ServoElementSnapshot* Servo_Element_GetSnapshot(RawGeckoElementBorrowed element);
+
+
+
+void Servo_NoteExplicitHints(RawGeckoElementBorrowed element, nsRestyleHint restyle_hint, nsChangeHint change_hint);
+
+nsChangeHint Servo_TakeChangeHint(RawGeckoElementBorrowed element);
+ServoComputedValuesStrong Servo_ResolveStyle(RawGeckoElementBorrowed element, RawServoStyleSetBorrowed set, bool allow_stale);
+
+
+
+ServoComputedValuesStrong Servo_ResolvePseudoStyle(RawGeckoElementBorrowed element, nsIAtom* pseudo_tag, bool is_probe, RawServoStyleSetBorrowed set);
+# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
+ServoComputedValuesStrong Servo_ResolveStyleLazily(RawGeckoElementBorrowed element, nsIAtom* pseudo_tag, RawServoStyleSetBorrowed set);
+
+
+
+
+
+bool Servo_TraverseSubtree(RawGeckoElementBorrowed root, RawServoStyleSetBorrowed set, mozilla::TraversalRootBehavior root_behavior);
+
+
+
+
+void Servo_AssertTreeIsClean(RawGeckoElementBorrowed root);
+
+
+ServoComputedValuesStrong Servo_StyleSet_GetBaseComputedValuesForElement(RawServoStyleSetBorrowed set, RawGeckoElementBorrowed element, nsIAtom* pseudo_tag);
+# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
+# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
+struct nsStyleFont; const nsStyleFont* Servo_GetStyleFont(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+struct nsStyleColor; const nsStyleColor* Servo_GetStyleColor(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleList; const nsStyleList* Servo_GetStyleList(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleText; const nsStyleText* Servo_GetStyleText(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleVisibility; const nsStyleVisibility* Servo_GetStyleVisibility(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleUserInterface; const nsStyleUserInterface* Servo_GetStyleUserInterface(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleTableBorder; const nsStyleTableBorder* Servo_GetStyleTableBorder(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleSVG; const nsStyleSVG* Servo_GetStyleSVG(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleVariables; const nsStyleVariables* Servo_GetStyleVariables(ServoComputedValuesBorrowedOrNull computed_values);
+
+struct nsStyleBackground; const nsStyleBackground* Servo_GetStyleBackground(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStylePosition; const nsStylePosition* Servo_GetStylePosition(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleTextReset; const nsStyleTextReset* Servo_GetStyleTextReset(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleDisplay; const nsStyleDisplay* Servo_GetStyleDisplay(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleContent; const nsStyleContent* Servo_GetStyleContent(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleUIReset; const nsStyleUIReset* Servo_GetStyleUIReset(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleTable; const nsStyleTable* Servo_GetStyleTable(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleMargin; const nsStyleMargin* Servo_GetStyleMargin(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStylePadding; const nsStylePadding* Servo_GetStylePadding(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+struct nsStyleBorder; const nsStyleBorder* Servo_GetStyleBorder(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleOutline; const nsStyleOutline* Servo_GetStyleOutline(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleXUL; const nsStyleXUL* Servo_GetStyleXUL(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+struct nsStyleSVGReset; const nsStyleSVGReset* Servo_GetStyleSVGReset(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleColumn; const nsStyleColumn* Servo_GetStyleColumn(ServoComputedValuesBorrowedOrNull computed_values);
+
+
+
+
+
+struct nsStyleEffects; const nsStyleEffects* Servo_GetStyleEffects(ServoComputedValuesBorrowedOrNull computed_values);
+# 344 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 2
+
+
+
+
+
+
+# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
+
+
+
+
+
+
+
+
+void Servo_CssRules_AddRef(ServoCssRulesBorrowed); void Servo_CssRules_Release(ServoCssRulesBorrowed);
+void Servo_StyleSheet_AddRef(RawServoStyleSheetBorrowed); void Servo_StyleSheet_Release(RawServoStyleSheetBorrowed);
+void Servo_ComputedValues_AddRef(ServoComputedValuesBorrowed); void Servo_ComputedValues_Release(ServoComputedValuesBorrowed);
+void Servo_DeclarationBlock_AddRef(RawServoDeclarationBlockBorrowed); void Servo_DeclarationBlock_Release(RawServoDeclarationBlockBorrowed);
+void Servo_StyleRule_AddRef(RawServoStyleRuleBorrowed); void Servo_StyleRule_Release(RawServoStyleRuleBorrowed);
+void Servo_ImportRule_AddRef(RawServoImportRuleBorrowed); void Servo_ImportRule_Release(RawServoImportRuleBorrowed);
+void Servo_AnimationValue_AddRef(RawServoAnimationValueBorrowed); void Servo_AnimationValue_Release(RawServoAnimationValueBorrowed);
+void Servo_AnimationValueMap_AddRef(RawServoAnimationValueMapBorrowed); void Servo_AnimationValueMap_Release(RawServoAnimationValueMapBorrowed);
+void Servo_MediaList_AddRef(RawServoMediaListBorrowed); void Servo_MediaList_Release(RawServoMediaListBorrowed);
+void Servo_MediaRule_AddRef(RawServoMediaRuleBorrowed); void Servo_MediaRule_Release(RawServoMediaRuleBorrowed);
+void Servo_NamespaceRule_AddRef(RawServoNamespaceRuleBorrowed); void Servo_NamespaceRule_Release(RawServoNamespaceRuleBorrowed);
+# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 2
+# 423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
+
+
+}
+# 2 "stylo.cpp" 2
+
diff --git a/bindgen-tests/tests/stylo_sanity.rs b/bindgen-tests/tests/stylo_sanity.rs
new file mode 100755
index 00000000..52b96355
--- /dev/null
+++ b/bindgen-tests/tests/stylo_sanity.rs
@@ -0,0 +1,556 @@
+// Don't want to copy that nasty `cfg` below...
+#[allow(unused_extern_crates)]
+extern crate bindgen;
+
+/// A sanity test that we can generate bindings for Stylo.
+///
+/// We don't assert on expected output because its just too big. The output will
+/// change too often, and it won't be clear what is going on at a glance, unlike
+/// the other tests with smaller input headers.
+///
+/// This test is relatively slow, so we also only run it in release mode.
+///
+/// Finally, uncomment the `panic!` at the bottom of the test to get logs timing
+/// how long bindings generation takes for Stylo. Stylo bindings generation
+/// takes too long to be a proper `#[bench]`.
+#[test]
+#[cfg(not(any(debug_assertions, feature = "testing_only_extra_assertions",)))]
+#[cfg(any(
+    feature = "testing_only_libclang_5",
+    feature = "testing_only_libclang_9"
+))]
+fn sanity_check_can_generate_stylo_bindings() {
+    use std::time::Instant;
+
+    let then = Instant::now();
+
+    bindgen::builder()
+        .time_phases(true)
+        .disable_header_comment()
+        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/stylo.hpp"))
+        .allowlist_function("Servo_.*")
+        .allowlist_function("Gecko_.*")
+        .blocklist_type("nsACString_internal")
+        .blocklist_type("nsAString_internal")
+        .blocklist_type("mozilla::css::URLValue")
+        .blocklist_type("RawGeckoAnimationPropertySegment")
+        .blocklist_type("RawGeckoComputedTiming")
+        .blocklist_type("RawGeckoDocument")
+        .blocklist_type("RawGeckoElement")
+        .blocklist_type("RawGeckoKeyframeList")
+        .blocklist_type("RawGeckoComputedKeyframeValuesList")
+        .blocklist_type("RawGeckoFontFaceRuleList")
+        .blocklist_type("RawGeckoNode")
+        .blocklist_type("RawGeckoAnimationValueList")
+        .blocklist_type("RawServoAnimationValue")
+        .blocklist_type("RawServoAnimationValueMap")
+        .blocklist_type("RawServoDeclarationBlock")
+        .blocklist_type("RawGeckoPresContext")
+        .blocklist_type("RawGeckoPresContextOwned")
+        .blocklist_type("RawGeckoStyleAnimationList")
+        .blocklist_type("RawGeckoURLExtraData")
+        .blocklist_type("RefPtr")
+        .blocklist_type("CSSPseudoClassType")
+        .blocklist_type("TraversalRootBehavior")
+        .blocklist_type("ComputedTimingFunction_BeforeFlag")
+        .blocklist_type("FontFamilyList")
+        .blocklist_type("FontFamilyType")
+        .blocklist_type("Keyframe")
+        .blocklist_type("ServoBundledURI")
+        .blocklist_type("ServoElementSnapshot")
+        .blocklist_type("SheetParsingMode")
+        .blocklist_type("StyleBasicShape")
+        .blocklist_type("StyleBasicShapeType")
+        .blocklist_type("StyleShapeSource")
+        .blocklist_type("nsCSSFontFaceRule")
+        .blocklist_type("nsCSSKeyword")
+        .blocklist_type("nsCSSPropertyID")
+        .blocklist_type("nsCSSShadowArray")
+        .blocklist_type("nsCSSUnit")
+        .blocklist_type("nsCSSValue")
+        .blocklist_type("nsCSSValueSharedList")
+        .blocklist_type("nsChangeHint")
+        .blocklist_type("nsCursorImage")
+        .blocklist_type("nsFont")
+        .blocklist_type("nsIAtom")
+        .blocklist_type("nsMediaFeature")
+        .blocklist_type("nsRestyleHint")
+        .blocklist_type("nsStyleBackground")
+        .blocklist_type("nsStyleBorder")
+        .blocklist_type("nsStyleColor")
+        .blocklist_type("nsStyleColumn")
+        .blocklist_type("nsStyleContent")
+        .blocklist_type("nsStyleContentData")
+        .blocklist_type("nsStyleContentType")
+        .blocklist_type("nsStyleContext")
+        .blocklist_type("nsStyleCoord")
+        .blocklist_type("nsStyleCoord_Calc")
+        .blocklist_type("nsStyleCoord_CalcValue")
+        .blocklist_type("nsStyleDisplay")
+        .blocklist_type("nsStyleEffects")
+        .blocklist_type("nsStyleFilter")
+        .blocklist_type("nsStyleFont")
+        .blocklist_type("nsStyleGradient")
+        .blocklist_type("nsStyleGradientStop")
+        .blocklist_type("nsStyleImage")
+        .blocklist_type("nsStyleImageLayers")
+        .blocklist_type("nsStyleImageLayers_Layer")
+        .blocklist_type("nsStyleImageLayers_LayerType")
+        .blocklist_type("nsStyleImageRequest")
+        .blocklist_type("nsStyleList")
+        .blocklist_type("nsStyleMargin")
+        .blocklist_type("nsStyleOutline")
+        .blocklist_type("nsStylePadding")
+        .blocklist_type("nsStylePosition")
+        .blocklist_type("nsStyleQuoteValues")
+        .blocklist_type("nsStyleSVG")
+        .blocklist_type("nsStyleSVGPaint")
+        .blocklist_type("nsStyleSVGReset")
+        .blocklist_type("nsStyleTable")
+        .blocklist_type("nsStyleTableBorder")
+        .blocklist_type("nsStyleText")
+        .blocklist_type("nsStyleTextReset")
+        .blocklist_type("nsStyleUIReset")
+        .blocklist_type("nsStyleUnion")
+        .blocklist_type("nsStyleUnit")
+        .blocklist_type("nsStyleUserInterface")
+        .blocklist_type("nsStyleVariables")
+        .blocklist_type("nsStyleVisibility")
+        .blocklist_type("nsStyleXUL")
+        .blocklist_type("nsTimingFunction")
+        .blocklist_type("nscolor")
+        .blocklist_type("nscoord")
+        .blocklist_type("nsresult")
+        .blocklist_type("Loader")
+        .blocklist_type("ServoStyleSheet")
+        .blocklist_type("EffectCompositor_CascadeLevel")
+        .blocklist_type("UpdateAnimationsTasks")
+        .blocklist_type("nsTArrayBorrowed_uintptr_t")
+        .blocklist_type("ServoCssRulesStrong")
+        .blocklist_type("ServoCssRulesBorrowed")
+        .blocklist_type("ServoCssRulesBorrowedOrNull")
+        .blocklist_type("ServoCssRules")
+        .blocklist_type("RawServoStyleSheetStrong")
+        .blocklist_type("RawServoStyleSheetBorrowed")
+        .blocklist_type("RawServoStyleSheetBorrowedOrNull")
+        .blocklist_type("RawServoStyleSheet")
+        .blocklist_type("ServoComputedValuesStrong")
+        .blocklist_type("ServoComputedValuesBorrowed")
+        .blocklist_type("ServoComputedValuesBorrowedOrNull")
+        .blocklist_type("ServoComputedValues")
+        .blocklist_type("RawServoDeclarationBlockStrong")
+        .blocklist_type("RawServoDeclarationBlockBorrowed")
+        .blocklist_type("RawServoDeclarationBlockBorrowedOrNull")
+        .blocklist_type("RawServoStyleRuleStrong")
+        .blocklist_type("RawServoStyleRuleBorrowed")
+        .blocklist_type("RawServoStyleRuleBorrowedOrNull")
+        .blocklist_type("RawServoStyleRule")
+        .blocklist_type("RawServoImportRuleStrong")
+        .blocklist_type("RawServoImportRuleBorrowed")
+        .blocklist_type("RawServoImportRuleBorrowedOrNull")
+        .blocklist_type("RawServoImportRule")
+        .blocklist_type("RawServoAnimationValueStrong")
+        .blocklist_type("RawServoAnimationValueBorrowed")
+        .blocklist_type("RawServoAnimationValueBorrowedOrNull")
+        .blocklist_type("RawServoAnimationValueMapStrong")
+        .blocklist_type("RawServoAnimationValueMapBorrowed")
+        .blocklist_type("RawServoAnimationValueMapBorrowedOrNull")
+        .blocklist_type("RawServoMediaListStrong")
+        .blocklist_type("RawServoMediaListBorrowed")
+        .blocklist_type("RawServoMediaListBorrowedOrNull")
+        .blocklist_type("RawServoMediaList")
+        .blocklist_type("RawServoMediaRuleStrong")
+        .blocklist_type("RawServoMediaRuleBorrowed")
+        .blocklist_type("RawServoMediaRuleBorrowedOrNull")
+        .blocklist_type("RawServoMediaRule")
+        .blocklist_type("RawServoNamespaceRuleStrong")
+        .blocklist_type("RawServoNamespaceRuleBorrowed")
+        .blocklist_type("RawServoNamespaceRuleBorrowedOrNull")
+        .blocklist_type("RawServoNamespaceRule")
+        .blocklist_type("RawServoStyleSetOwned")
+        .blocklist_type("RawServoStyleSetOwnedOrNull")
+        .blocklist_type("RawServoStyleSetBorrowed")
+        .blocklist_type("RawServoStyleSetBorrowedOrNull")
+        .blocklist_type("RawServoStyleSetBorrowedMut")
+        .blocklist_type("RawServoStyleSetBorrowedMutOrNull")
+        .blocklist_type("RawServoStyleSet")
+        .blocklist_type("StyleChildrenIteratorOwned")
+        .blocklist_type("StyleChildrenIteratorOwnedOrNull")
+        .blocklist_type("StyleChildrenIteratorBorrowed")
+        .blocklist_type("StyleChildrenIteratorBorrowedOrNull")
+        .blocklist_type("StyleChildrenIteratorBorrowedMut")
+        .blocklist_type("StyleChildrenIteratorBorrowedMutOrNull")
+        .blocklist_type("StyleChildrenIterator")
+        .blocklist_type("ServoElementSnapshotOwned")
+        .blocklist_type("ServoElementSnapshotOwnedOrNull")
+        .blocklist_type("ServoElementSnapshotBorrowed")
+        .blocklist_type("ServoElementSnapshotBorrowedOrNull")
+        .blocklist_type("ServoElementSnapshotBorrowedMut")
+        .blocklist_type("ServoElementSnapshotBorrowedMutOrNull")
+        .blocklist_type("RawGeckoNodeBorrowed")
+        .blocklist_type("RawGeckoNodeBorrowedOrNull")
+        .blocklist_type("RawGeckoElementBorrowed")
+        .blocklist_type("RawGeckoElementBorrowedOrNull")
+        .blocklist_type("RawGeckoDocumentBorrowed")
+        .blocklist_type("RawGeckoDocumentBorrowedOrNull")
+        .blocklist_type("RawServoDeclarationBlockStrongBorrowed")
+        .blocklist_type("RawServoDeclarationBlockStrongBorrowedOrNull")
+        .blocklist_type("RawGeckoPresContextBorrowed")
+        .blocklist_type("RawGeckoPresContextBorrowedOrNull")
+        .blocklist_type("RawGeckoStyleAnimationListBorrowed")
+        .blocklist_type("RawGeckoStyleAnimationListBorrowedOrNull")
+        .blocklist_type("nsCSSValueBorrowed")
+        .blocklist_type("nsCSSValueBorrowedOrNull")
+        .blocklist_type("nsCSSValueBorrowedMut")
+        .blocklist_type("nsCSSValueBorrowedMutOrNull")
+        .blocklist_type("nsTimingFunctionBorrowed")
+        .blocklist_type("nsTimingFunctionBorrowedOrNull")
+        .blocklist_type("nsTimingFunctionBorrowedMut")
+        .blocklist_type("nsTimingFunctionBorrowedMutOrNull")
+        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowed")
+        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedOrNull")
+        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedMut")
+        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedMutOrNull")
+        .blocklist_type("RawGeckoAnimationValueListBorrowed")
+        .blocklist_type("RawGeckoAnimationValueListBorrowedOrNull")
+        .blocklist_type("RawGeckoAnimationValueListBorrowedMut")
+        .blocklist_type("RawGeckoAnimationValueListBorrowedMutOrNull")
+        .blocklist_type("RawGeckoComputedTimingBorrowed")
+        .blocklist_type("RawGeckoComputedTimingBorrowedOrNull")
+        .blocklist_type("RawGeckoComputedTimingBorrowedMut")
+        .blocklist_type("RawGeckoComputedTimingBorrowedMutOrNull")
+        .blocklist_type("RawGeckoKeyframeListBorrowed")
+        .blocklist_type("RawGeckoKeyframeListBorrowedOrNull")
+        .blocklist_type("RawGeckoKeyframeListBorrowedMut")
+        .blocklist_type("RawGeckoKeyframeListBorrowedMutOrNull")
+        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowed")
+        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedOrNull")
+        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedMut")
+        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedMutOrNull")
+        .blocklist_type("RawGeckoFontFaceRuleListBorrowed")
+        .blocklist_type("RawGeckoFontFaceRuleListBorrowedOrNull")
+        .blocklist_type("RawGeckoFontFaceRuleListBorrowedMut")
+        .blocklist_type("RawGeckoFontFaceRuleListBorrowedMutOrNull")
+        .raw_line(r#"pub use nsstring::{nsACString, nsAString, nsString};"#)
+        .raw_line(r#"type nsACString_internal = nsACString;"#)
+        .raw_line(r#"type nsAString_internal = nsAString;"#)
+        .raw_line(r#"use gecko_bindings::structs::mozilla::css::URLValue;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoAnimationPropertySegment;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoComputedTiming;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoDocument;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoElement;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoKeyframeList;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoComputedKeyframeValuesList;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoFontFaceRuleList;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoNode;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoAnimationValueList;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawServoAnimationValue;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawServoAnimationValueMap;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawServoDeclarationBlock;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoPresContext;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoPresContextOwned;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoStyleAnimationList;"#)
+        .raw_line(r#"use gecko_bindings::structs::RawGeckoURLExtraData;"#)
+        .raw_line(r#"use gecko_bindings::structs::RefPtr;"#)
+        .raw_line(r#"use gecko_bindings::structs::CSSPseudoClassType;"#)
+        .raw_line(r#"use gecko_bindings::structs::TraversalRootBehavior;"#)
+        .raw_line(r#"use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;"#)
+        .raw_line(r#"use gecko_bindings::structs::FontFamilyList;"#)
+        .raw_line(r#"use gecko_bindings::structs::FontFamilyType;"#)
+        .raw_line(r#"use gecko_bindings::structs::Keyframe;"#)
+        .raw_line(r#"use gecko_bindings::structs::ServoBundledURI;"#)
+        .raw_line(r#"use gecko_bindings::structs::ServoElementSnapshot;"#)
+        .raw_line(r#"use gecko_bindings::structs::SheetParsingMode;"#)
+        .raw_line(r#"use gecko_bindings::structs::StyleBasicShape;"#)
+        .raw_line(r#"use gecko_bindings::structs::StyleBasicShapeType;"#)
+        .raw_line(r#"use gecko_bindings::structs::StyleShapeSource;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSFontFaceRule;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSKeyword;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSPropertyID;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSShadowArray;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSUnit;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSValue;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCSSValueSharedList;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsChangeHint;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsCursorImage;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsFont;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsIAtom;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsMediaFeature;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsRestyleHint;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleBackground;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleBackground {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleBackground {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleBorder;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleBorder {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleBorder {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleColor;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleColor {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleColor {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleColumn;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleColumn {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleColumn {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleContent;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleContent {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleContent {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleContentData;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleContentData {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleContentData {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleContentType;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleContentType {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleContentType {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleContext;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleContext {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleContext {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleCoord {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleCoord {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord_Calc;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleCoord_Calc {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleCoord_Calc {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord_CalcValue;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleCoord_CalcValue {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleCoord_CalcValue {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleDisplay;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleDisplay {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleDisplay {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleEffects;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleEffects {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleEffects {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleFilter;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleFilter {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleFilter {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleFont;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleFont {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleFont {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleGradient;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleGradient {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleGradient {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleGradientStop;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleGradientStop {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleGradientStop {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleImage;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleImage {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleImage {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleImageLayers {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers_Layer;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleImageLayers_Layer {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers_Layer {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers_LayerType;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleImageLayers_LayerType {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers_LayerType {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleImageRequest;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleImageRequest {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleImageRequest {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleList;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleList {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleList {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleMargin;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleMargin {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleMargin {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleOutline;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleOutline {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleOutline {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStylePadding;"#)
+        .raw_line(r#"unsafe impl Send for nsStylePadding {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStylePadding {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStylePosition;"#)
+        .raw_line(r#"unsafe impl Send for nsStylePosition {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStylePosition {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleQuoteValues;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleQuoteValues {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleQuoteValues {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleSVG;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleSVG {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleSVG {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleSVGPaint;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleSVGPaint {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleSVGPaint {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleSVGReset;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleSVGReset {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleSVGReset {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleTable;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleTable {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleTable {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleTableBorder;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleTableBorder {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleTableBorder {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleText;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleText {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleText {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleTextReset;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleTextReset {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleTextReset {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleUIReset;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleUIReset {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleUIReset {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleUnion;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleUnion {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleUnion {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleUnit;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleUnit {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleUnit {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleUserInterface;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleUserInterface {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleUserInterface {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleVariables;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleVariables {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleVariables {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleVisibility;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleVisibility {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleVisibility {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsStyleXUL;"#)
+        .raw_line(r#"unsafe impl Send for nsStyleXUL {}"#)
+        .raw_line(r#"unsafe impl Sync for nsStyleXUL {}"#)
+        .raw_line(r#"use gecko_bindings::structs::nsTimingFunction;"#)
+        .raw_line(r#"use gecko_bindings::structs::nscolor;"#)
+        .raw_line(r#"use gecko_bindings::structs::nscoord;"#)
+        .raw_line(r#"use gecko_bindings::structs::nsresult;"#)
+        .raw_line(r#"use gecko_bindings::structs::Loader;"#)
+        .raw_line(r#"use gecko_bindings::structs::ServoStyleSheet;"#)
+        .raw_line(r#"use gecko_bindings::structs::EffectCompositor_CascadeLevel;"#)
+        .raw_line(r#"use gecko_bindings::structs::UpdateAnimationsTasks;"#)
+        .raw_line(r#"pub type nsTArrayBorrowed_uintptr_t<'a> = &'a mut ::gecko_bindings::structs::nsTArray<usize>;"#)
+        .raw_line(r#"pub type ServoCssRulesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoCssRules>;"#)
+        .raw_line(r#"pub type ServoCssRulesBorrowed<'a> = &'a ServoCssRules;"#)
+        .raw_line(r#"pub type ServoCssRulesBorrowedOrNull<'a> = Option<&'a ServoCssRules>;"#)
+        .raw_line(r#"enum ServoCssRulesVoid { }"#)
+        .raw_line(r#"pub struct ServoCssRules(ServoCssRulesVoid);"#)
+        .raw_line(r#"pub type RawServoStyleSheetStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleSheet>;"#)
+        .raw_line(r#"pub type RawServoStyleSheetBorrowed<'a> = &'a RawServoStyleSheet;"#)
+        .raw_line(r#"pub type RawServoStyleSheetBorrowedOrNull<'a> = Option<&'a RawServoStyleSheet>;"#)
+        .raw_line(r#"enum RawServoStyleSheetVoid { }"#)
+        .raw_line(r#"pub struct RawServoStyleSheet(RawServoStyleSheetVoid);"#)
+        .raw_line(r#"pub type ServoComputedValuesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoComputedValues>;"#)
+        .raw_line(r#"pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;"#)
+        .raw_line(r#"pub type ServoComputedValuesBorrowedOrNull<'a> = Option<&'a ServoComputedValues>;"#)
+        .raw_line(r#"enum ServoComputedValuesVoid { }"#)
+        .raw_line(r#"pub struct ServoComputedValues(ServoComputedValuesVoid);"#)
+        .raw_line(r#"pub type RawServoDeclarationBlockStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoDeclarationBlock>;"#)
+        .raw_line(r#"pub type RawServoDeclarationBlockBorrowed<'a> = &'a RawServoDeclarationBlock;"#)
+        .raw_line(r#"pub type RawServoDeclarationBlockBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlock>;"#)
+        .raw_line(r#"pub type RawServoStyleRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleRule>;"#)
+        .raw_line(r#"pub type RawServoStyleRuleBorrowed<'a> = &'a RawServoStyleRule;"#)
+        .raw_line(r#"pub type RawServoStyleRuleBorrowedOrNull<'a> = Option<&'a RawServoStyleRule>;"#)
+        .raw_line(r#"enum RawServoStyleRuleVoid { }"#)
+        .raw_line(r#"pub struct RawServoStyleRule(RawServoStyleRuleVoid);"#)
+        .raw_line(r#"pub type RawServoImportRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoImportRule>;"#)
+        .raw_line(r#"pub type RawServoImportRuleBorrowed<'a> = &'a RawServoImportRule;"#)
+        .raw_line(r#"pub type RawServoImportRuleBorrowedOrNull<'a> = Option<&'a RawServoImportRule>;"#)
+        .raw_line(r#"enum RawServoImportRuleVoid { }"#)
+        .raw_line(r#"pub struct RawServoImportRule(RawServoImportRuleVoid);"#)
+        .raw_line(r#"pub type RawServoAnimationValueStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoAnimationValue>;"#)
+        .raw_line(r#"pub type RawServoAnimationValueBorrowed<'a> = &'a RawServoAnimationValue;"#)
+        .raw_line(r#"pub type RawServoAnimationValueBorrowedOrNull<'a> = Option<&'a RawServoAnimationValue>;"#)
+        .raw_line(r#"pub type RawServoAnimationValueMapStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoAnimationValueMap>;"#)
+        .raw_line(r#"pub type RawServoAnimationValueMapBorrowed<'a> = &'a RawServoAnimationValueMap;"#)
+        .raw_line(r#"pub type RawServoAnimationValueMapBorrowedOrNull<'a> = Option<&'a RawServoAnimationValueMap>;"#)
+        .raw_line(r#"pub type RawServoMediaListStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaList>;"#)
+        .raw_line(r#"pub type RawServoMediaListBorrowed<'a> = &'a RawServoMediaList;"#)
+        .raw_line(r#"pub type RawServoMediaListBorrowedOrNull<'a> = Option<&'a RawServoMediaList>;"#)
+        .raw_line(r#"enum RawServoMediaListVoid { }"#)
+        .raw_line(r#"pub struct RawServoMediaList(RawServoMediaListVoid);"#)
+        .raw_line(r#"pub type RawServoMediaRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaRule>;"#)
+        .raw_line(r#"pub type RawServoMediaRuleBorrowed<'a> = &'a RawServoMediaRule;"#)
+        .raw_line(r#"pub type RawServoMediaRuleBorrowedOrNull<'a> = Option<&'a RawServoMediaRule>;"#)
+        .raw_line(r#"enum RawServoMediaRuleVoid { }"#)
+        .raw_line(r#"pub struct RawServoMediaRule(RawServoMediaRuleVoid);"#)
+        .raw_line(r#"pub type RawServoNamespaceRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoNamespaceRule>;"#)
+        .raw_line(r#"pub type RawServoNamespaceRuleBorrowed<'a> = &'a RawServoNamespaceRule;"#)
+        .raw_line(r#"pub type RawServoNamespaceRuleBorrowedOrNull<'a> = Option<&'a RawServoNamespaceRule>;"#)
+        .raw_line(r#"enum RawServoNamespaceRuleVoid { }"#)
+        .raw_line(r#"pub struct RawServoNamespaceRule(RawServoNamespaceRuleVoid);"#)
+        .raw_line(r#"pub type RawServoStyleSetOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoStyleSet>;"#)
+        .raw_line(r#"pub type RawServoStyleSetOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoStyleSet>;"#)
+        .raw_line(r#"pub type RawServoStyleSetBorrowed<'a> = &'a RawServoStyleSet;"#)
+        .raw_line(r#"pub type RawServoStyleSetBorrowedOrNull<'a> = Option<&'a RawServoStyleSet>;"#)
+        .raw_line(r#"pub type RawServoStyleSetBorrowedMut<'a> = &'a mut RawServoStyleSet;"#)
+        .raw_line(r#"pub type RawServoStyleSetBorrowedMutOrNull<'a> = Option<&'a mut RawServoStyleSet>;"#)
+        .raw_line(r#"enum RawServoStyleSetVoid { }"#)
+        .raw_line(r#"pub struct RawServoStyleSet(RawServoStyleSetVoid);"#)
+        .raw_line(r#"pub type StyleChildrenIteratorOwned = ::gecko_bindings::sugar::ownership::Owned<StyleChildrenIterator>;"#)
+        .raw_line(r#"pub type StyleChildrenIteratorOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<StyleChildrenIterator>;"#)
+        .raw_line(r#"pub type StyleChildrenIteratorBorrowed<'a> = &'a StyleChildrenIterator;"#)
+        .raw_line(r#"pub type StyleChildrenIteratorBorrowedOrNull<'a> = Option<&'a StyleChildrenIterator>;"#)
+        .raw_line(r#"pub type StyleChildrenIteratorBorrowedMut<'a> = &'a mut StyleChildrenIterator;"#)
+        .raw_line(r#"pub type StyleChildrenIteratorBorrowedMutOrNull<'a> = Option<&'a mut StyleChildrenIterator>;"#)
+        .raw_line(r#"enum StyleChildrenIteratorVoid { }"#)
+        .raw_line(r#"pub struct StyleChildrenIterator(StyleChildrenIteratorVoid);"#)
+        .raw_line(r#"pub type ServoElementSnapshotOwned = ::gecko_bindings::sugar::ownership::Owned<ServoElementSnapshot>;"#)
+        .raw_line(r#"pub type ServoElementSnapshotOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<ServoElementSnapshot>;"#)
+        .raw_line(r#"pub type ServoElementSnapshotBorrowed<'a> = &'a ServoElementSnapshot;"#)
+        .raw_line(r#"pub type ServoElementSnapshotBorrowedOrNull<'a> = Option<&'a ServoElementSnapshot>;"#)
+        .raw_line(r#"pub type ServoElementSnapshotBorrowedMut<'a> = &'a mut ServoElementSnapshot;"#)
+        .raw_line(r#"pub type ServoElementSnapshotBorrowedMutOrNull<'a> = Option<&'a mut ServoElementSnapshot>;"#)
+        .raw_line(r#"pub type RawGeckoNodeBorrowed<'a> = &'a RawGeckoNode;"#)
+        .raw_line(r#"pub type RawGeckoNodeBorrowedOrNull<'a> = Option<&'a RawGeckoNode>;"#)
+        .raw_line(r#"pub type RawGeckoElementBorrowed<'a> = &'a RawGeckoElement;"#)
+        .raw_line(r#"pub type RawGeckoElementBorrowedOrNull<'a> = Option<&'a RawGeckoElement>;"#)
+        .raw_line(r#"pub type RawGeckoDocumentBorrowed<'a> = &'a RawGeckoDocument;"#)
+        .raw_line(r#"pub type RawGeckoDocumentBorrowedOrNull<'a> = Option<&'a RawGeckoDocument>;"#)
+        .raw_line(r#"pub type RawServoDeclarationBlockStrongBorrowed<'a> = &'a RawServoDeclarationBlockStrong;"#)
+        .raw_line(r#"pub type RawServoDeclarationBlockStrongBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlockStrong>;"#)
+        .raw_line(r#"pub type RawGeckoPresContextBorrowed<'a> = &'a RawGeckoPresContext;"#)
+        .raw_line(r#"pub type RawGeckoPresContextBorrowedOrNull<'a> = Option<&'a RawGeckoPresContext>;"#)
+        .raw_line(r#"pub type RawGeckoStyleAnimationListBorrowed<'a> = &'a RawGeckoStyleAnimationList;"#)
+        .raw_line(r#"pub type RawGeckoStyleAnimationListBorrowedOrNull<'a> = Option<&'a RawGeckoStyleAnimationList>;"#)
+        .raw_line(r#"pub type nsCSSValueBorrowed<'a> = &'a nsCSSValue;"#)
+        .raw_line(r#"pub type nsCSSValueBorrowedOrNull<'a> = Option<&'a nsCSSValue>;"#)
+        .raw_line(r#"pub type nsCSSValueBorrowedMut<'a> = &'a mut nsCSSValue;"#)
+        .raw_line(r#"pub type nsCSSValueBorrowedMutOrNull<'a> = Option<&'a mut nsCSSValue>;"#)
+        .raw_line(r#"pub type nsTimingFunctionBorrowed<'a> = &'a nsTimingFunction;"#)
+        .raw_line(r#"pub type nsTimingFunctionBorrowedOrNull<'a> = Option<&'a nsTimingFunction>;"#)
+        .raw_line(r#"pub type nsTimingFunctionBorrowedMut<'a> = &'a mut nsTimingFunction;"#)
+        .raw_line(r#"pub type nsTimingFunctionBorrowedMutOrNull<'a> = Option<&'a mut nsTimingFunction>;"#)
+        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowed<'a> = &'a RawGeckoAnimationPropertySegment;"#)
+        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationPropertySegment>;"#)
+        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedMut<'a> = &'a mut RawGeckoAnimationPropertySegment;"#)
+        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationPropertySegment>;"#)
+        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowed<'a> = &'a RawGeckoAnimationValueList;"#)
+        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationValueList>;"#)
+        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedMut<'a> = &'a mut RawGeckoAnimationValueList;"#)
+        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationValueList>;"#)
+        .raw_line(r#"pub type RawGeckoComputedTimingBorrowed<'a> = &'a RawGeckoComputedTiming;"#)
+        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedOrNull<'a> = Option<&'a RawGeckoComputedTiming>;"#)
+        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedMut<'a> = &'a mut RawGeckoComputedTiming;"#)
+        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedTiming>;"#)
+        .raw_line(r#"pub type RawGeckoKeyframeListBorrowed<'a> = &'a RawGeckoKeyframeList;"#)
+        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedOrNull<'a> = Option<&'a RawGeckoKeyframeList>;"#)
+        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedMut<'a> = &'a mut RawGeckoKeyframeList;"#)
+        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoKeyframeList>;"#)
+        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowed<'a> = &'a RawGeckoComputedKeyframeValuesList;"#)
+        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedOrNull<'a> = Option<&'a RawGeckoComputedKeyframeValuesList>;"#)
+        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedMut<'a> = &'a mut RawGeckoComputedKeyframeValuesList;"#)
+        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedKeyframeValuesList>;"#)
+        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowed<'a> = &'a RawGeckoFontFaceRuleList;"#)
+        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedOrNull<'a> = Option<&'a RawGeckoFontFaceRuleList>;"#)
+        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedMut<'a> = &'a mut RawGeckoFontFaceRuleList;"#)
+        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoFontFaceRuleList>;"#)
+        .clang_arg("-x")
+        .clang_arg("c++")
+        .clang_arg("-std=c++14")
+        .clang_arg("-DTRACING=1")
+        .clang_arg("-DIMPL_LIBXUL")
+        .clang_arg("-DMOZ_STYLO_BINDINGS=1")
+        .clang_arg("-DMOZILLA_INTERNAL_API")
+        .clang_arg("-DRUST_BINDGEN")
+        .clang_arg("-DMOZ_STYLO")
+        .clang_arg("-DOS_POSIX=1")
+        .clang_arg("-DOS_LINUX=1")
+        .generate()
+        .expect("Should generate stylo bindings");
+
+    let now = Instant::now();
+
+    println!();
+    println!();
+    println!(
+        "Generated Stylo bindings in: {:?}",
+        now.duration_since(then)
+    );
+    println!();
+    println!();
+
+    // panic!("Uncomment this line to get timing logs");
+}
diff --git a/bindgen-tests/tests/test-one.sh b/bindgen-tests/tests/test-one.sh
new file mode 100755
index 00000000..91da55b1
--- /dev/null
+++ b/bindgen-tests/tests/test-one.sh
@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+
+# Usage:
+#
+#     ./tests/test-one.sh <fuzzy-name>
+#
+# Generate bindings for the first match of `./tests/headers/*<fuzzy-name>*`, use
+# `rustc` to compile the bindings with unit tests enabled, and run the generated
+# layout tests.
+
+set -eu
+
+if [ $# -ne 1 ]; then
+    echo "Usage: $0 <fuzzy-name>"
+    exit 1
+fi
+
+cd "$(dirname "$0")"
+cd ..
+
+export RUST_BACKTRACE=1
+
+unique_fuzzy_file() {
+    local pattern="$1"
+    local results="$(find ./tests/headers -type f | egrep -i "$pattern")"
+    local num_results=$(echo "$results" | wc -l)
+
+    if [[ -z "$results" ]]; then
+        >&2 echo "ERROR: no files found with pattern \"$pattern\""
+        exit 1
+    elif [[ "$num_results" -ne 1 ]]; then
+        >&2 echo "ERROR: Expected exactly 1 result, got $num_results:"
+        >&2 echo "$results"
+        exit 1
+    fi
+
+    echo "$results"
+}
+
+TEST="$(unique_fuzzy_file "$1")"
+
+BINDINGS=$(mktemp -t bindings.rs.XXXXXX)
+TEST_BINDINGS_BINARY=$(mktemp -t bindings.XXXXXX)
+
+FLAGS="$(grep "// bindgen-flags: " "$TEST" || echo)"
+FLAGS="${FLAGS/\/\/ bindgen\-flags:/}"
+# Prepend the default flags added in test.rs's `create_bindgen_builder`.
+FLAGS="--rustfmt-bindings --with-derive-default --raw-line '' --raw-line '#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]' --raw-line '' $FLAGS"
+
+
+eval ./target/debug/bindgen \
+    "\"$TEST\"" \
+    --emit-ir \
+    --emit-ir-graphviz ir.dot \
+    --emit-clang-ast \
+    -o "\"$BINDINGS\"" \
+    $FLAGS
+
+rustup run nightly rustfmt "$BINDINGS" || true
+
+dot -Tpng ir.dot -o ir.png
+
+echo
+echo "=== Input header ========================================================"
+echo
+
+cat "$TEST"
+
+echo
+echo "=== Generated bindings =================================================="
+echo
+
+cat "$BINDINGS"
+
+echo
+echo "=== Diff w/ expected bindings ==========================================="
+echo
+
+EXPECTED=${TEST/headers/expectations\/tests}
+EXPECTED=${EXPECTED/.hpp/.rs}
+EXPECTED=${EXPECTED/.h/.rs}
+
+rustup run nightly rustfmt "$EXPECTED" || true
+
+# Don't exit early if there is a diff.
+diff -U8 "$EXPECTED" "$BINDINGS" || true
+
+echo
+echo "=== Building bindings ==================================================="
+echo
+
+rustc --test -o "$TEST_BINDINGS_BINARY" "$BINDINGS" --crate-name bindgen_test_one
+
+echo
+echo "=== Testing bindings ===================================================="
+echo
+
+"$TEST_BINDINGS_BINARY"
diff --git a/bindgen-tests/tests/tests.rs b/bindgen-tests/tests/tests.rs
new file mode 100644
index 00000000..ca081e26
--- /dev/null
+++ b/bindgen-tests/tests/tests.rs
@@ -0,0 +1,715 @@
+extern crate bindgen;
+extern crate clap;
+extern crate diff;
+#[cfg(feature = "logging")]
+extern crate env_logger;
+extern crate shlex;
+
+use bindgen::{clang_version, Builder};
+use std::env;
+use std::fs;
+use std::io::{self, BufRead, BufReader, Error, ErrorKind, Read, Write};
+use std::path::{Path, PathBuf};
+use std::process;
+use std::sync::Once;
+
+use crate::options::builder_from_flags;
+
+#[path = "../../bindgen-cli/options.rs"]
+mod options;
+
+mod parse_callbacks;
+
+// Run `rustfmt` on the given source string and return a tuple of the formatted
+// bindings, and rustfmt's stderr.
+fn rustfmt(source: String) -> (String, String) {
+    static CHECK_RUSTFMT: Once = Once::new();
+
+    CHECK_RUSTFMT.call_once(|| {
+        if env::var_os("RUSTFMT").is_some() {
+            return;
+        }
+
+        let mut rustfmt = {
+            let mut p = process::Command::new("rustup");
+            p.args(["run", "nightly", "rustfmt", "--version"]);
+            p
+        };
+
+        let have_working_rustfmt = rustfmt
+            .stdout(process::Stdio::null())
+            .stderr(process::Stdio::null())
+            .status()
+            .ok()
+            .map_or(false, |status| status.success());
+
+        if !have_working_rustfmt {
+            panic!(
+                "
+The latest `rustfmt` is required to run the `bindgen` test suite. Install
+`rustfmt` with:
+
+    $ rustup update nightly
+    $ rustup component add rustfmt --toolchain nightly
+"
+            );
+        }
+    });
+
+    let mut child = match env::var_os("RUSTFMT") {
+        Some(r) => process::Command::new(r),
+        None => {
+            let mut p = process::Command::new("rustup");
+            p.args(["run", "nightly", "rustfmt"]);
+            p
+        }
+    };
+
+    let mut child = child
+        .args([
+            "--config-path",
+            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/rustfmt.toml"),
+        ])
+        .stdin(process::Stdio::piped())
+        .stdout(process::Stdio::piped())
+        .stderr(process::Stdio::piped())
+        .spawn()
+        .expect("should spawn `rustup run nightly rustfmt`");
+
+    let mut stdin = child.stdin.take().unwrap();
+    let mut stdout = child.stdout.take().unwrap();
+    let mut stderr = child.stderr.take().unwrap();
+
+    // Write to stdin in a new thread, so that we can read from stdout on this
+    // thread. This keeps the child from blocking on writing to its stdout which
+    // might block us from writing to its stdin.
+    let stdin_handle =
+        ::std::thread::spawn(move || stdin.write_all(source.as_bytes()));
+
+    // Read stderr on a new thread for similar reasons.
+    let stderr_handle = ::std::thread::spawn(move || {
+        let mut output = vec![];
+        io::copy(&mut stderr, &mut output)
+            .map(|_| String::from_utf8_lossy(&output).to_string())
+    });
+
+    let mut output = vec![];
+    io::copy(&mut stdout, &mut output).expect("Should copy stdout into vec OK");
+
+    // Ignore actual rustfmt status because it is often non-zero for trivial
+    // things.
+    let _ = child.wait().expect("should wait on rustfmt child OK");
+
+    stdin_handle
+        .join()
+        .expect("writer thread should not have panicked")
+        .expect("should have written to child rustfmt's stdin OK");
+
+    let bindings = String::from_utf8(output)
+        .expect("rustfmt should only emit valid utf-8");
+
+    let stderr = stderr_handle
+        .join()
+        .expect("stderr reader thread should not have panicked")
+        .expect("should have read child rustfmt's stderr OK");
+
+    (bindings, stderr)
+}
+
+fn should_overwrite_expected() -> bool {
+    if let Some(var) = env::var_os("BINDGEN_OVERWRITE_EXPECTED") {
+        if var == "1" {
+            return true;
+        }
+        if var != "0" && var != "" {
+            panic!("Invalid value of BINDGEN_OVERWRITE_EXPECTED");
+        }
+    }
+    false
+}
+
+fn error_diff_mismatch(
+    actual: &str,
+    expected: &str,
+    header: Option<&Path>,
+    filename: &Path,
+) -> Result<(), Error> {
+    println!("diff expected generated");
+    println!("--- expected: {:?}", filename);
+    if let Some(header) = header {
+        println!("+++ generated from: {:?}", header);
+    }
+
+    for diff in diff::lines(expected, actual) {
+        match diff {
+            diff::Result::Left(l) => println!("-{}", l),
+            diff::Result::Both(l, _) => println!(" {}", l),
+            diff::Result::Right(r) => println!("+{}", r),
+        }
+    }
+
+    if should_overwrite_expected() {
+        // Overwrite the expectation with actual output.
+        let mut expectation_file = fs::File::create(filename)?;
+        expectation_file.write_all(actual.as_bytes())?;
+    }
+
+    if let Some(var) = env::var_os("BINDGEN_TESTS_DIFFTOOL") {
+        //usecase: var = "meld" -> You can hand check differences
+        let name = match filename.components().last() {
+            Some(std::path::Component::Normal(name)) => name,
+            _ => panic!("Why is the header variable so weird?"),
+        };
+        let actual_result_path =
+            PathBuf::from(env::var("OUT_DIR").unwrap()).join(name);
+        let mut actual_result_file = fs::File::create(&actual_result_path)?;
+        actual_result_file.write_all(actual.as_bytes())?;
+        std::process::Command::new(var)
+            .args([filename, &actual_result_path])
+            .output()?;
+    }
+
+    Err(Error::new(ErrorKind::Other, "Header and binding differ! Run with BINDGEN_OVERWRITE_EXPECTED=1 in the environment to automatically overwrite the expectation or with BINDGEN_TESTS_DIFFTOOL=meld to do this manually."))
+}
+
+fn compare_generated_header(
+    header: &Path,
+    builder: BuilderState,
+    check_roundtrip: bool,
+) -> Result<(), Error> {
+    let file_name = header.file_name().ok_or_else(|| {
+        Error::new(ErrorKind::Other, "compare_generated_header expects a file")
+    })?;
+
+    let mut expectation = PathBuf::from(header);
+    expectation.pop();
+    expectation.pop();
+    expectation.push("expectations");
+    expectation.push("tests");
+
+    let mut looked_at = vec![];
+    let mut expectation_file;
+
+    // Try more specific expectations first.
+    {
+        let mut expectation = expectation.clone();
+
+        if cfg!(feature = "testing_only_libclang_9") {
+            expectation.push("libclang-9");
+        } else if cfg!(feature = "testing_only_libclang_5") {
+            expectation.push("libclang-5");
+        } else {
+            match clang_version().parsed {
+                None => expectation.push("libclang-9"),
+                Some(version) => {
+                    let (maj, min) = version;
+                    let version_str = if maj >= 9 {
+                        "9".to_owned()
+                    } else if maj >= 5 {
+                        "5".to_owned()
+                    } else if maj >= 4 {
+                        "4".to_owned()
+                    } else {
+                        format!("{}.{}", maj, min)
+                    };
+                    expectation.push(format!("libclang-{}", version_str));
+                }
+            }
+        }
+
+        expectation.push(file_name);
+        expectation.set_extension("rs");
+        expectation_file = fs::File::open(&expectation).ok();
+        looked_at.push(expectation);
+    }
+
+    // Try the default path otherwise.
+    if expectation_file.is_none() {
+        expectation.push(file_name);
+        expectation.set_extension("rs");
+        expectation_file = fs::File::open(&expectation).ok();
+        looked_at.push(expectation.clone());
+    }
+
+    let mut expected = String::new();
+    match expectation_file {
+        Some(f) => {
+            BufReader::new(f).read_to_string(&mut expected)?;
+        }
+        None => panic!(
+            "missing test expectation file and/or 'testing_only_libclang_$VERSION' \
+             feature for header '{}'; looking for expectation file at '{:?}'",
+            header.display(),
+            looked_at,
+        ),
+    };
+
+    let (builder, roundtrip_builder) = builder.into_builder(check_roundtrip)?;
+
+    // We skip the generate() error here so we get a full diff below
+    let (actual, rustfmt_stderr) = match builder.generate() {
+        Ok(bindings) => {
+            let actual = bindings.to_string();
+            rustfmt(actual)
+        }
+        Err(_) => ("<error generating bindings>".to_string(), "".to_string()),
+    };
+    println!("{}", rustfmt_stderr);
+
+    let (expected, rustfmt_stderr) = rustfmt(expected);
+    println!("{}", rustfmt_stderr);
+
+    if actual.is_empty() {
+        return Err(Error::new(
+            ErrorKind::Other,
+            "Something's gone really wrong!",
+        ));
+    }
+
+    if actual != expected {
+        println!("{}", rustfmt_stderr);
+        return error_diff_mismatch(
+            &actual,
+            &expected,
+            Some(header),
+            looked_at.last().unwrap(),
+        );
+    }
+
+    if let Some(roundtrip_builder) = roundtrip_builder {
+        if let Err(e) =
+            compare_generated_header(header, roundtrip_builder, false)
+        {
+            return Err(Error::new(ErrorKind::Other, format!("Checking CLI flags roundtrip errored! You probably need to fix Builder::command_line_flags. {}", e)));
+        }
+    }
+
+    Ok(())
+}
+
+fn builder() -> Builder {
+    #[cfg(feature = "logging")]
+    let _ = env_logger::try_init();
+
+    bindgen::builder().disable_header_comment()
+}
+
+struct BuilderState {
+    builder: Builder,
+    parse_callbacks: Option<String>,
+}
+
+impl BuilderState {
+    fn into_builder(
+        self,
+        with_roundtrip_builder: bool,
+    ) -> Result<(Builder, Option<BuilderState>), Error> {
+        let roundtrip_builder = if with_roundtrip_builder {
+            let mut flags = self.builder.command_line_flags();
+            flags.insert(0, "bindgen".into());
+            let mut builder = builder_from_flags(flags.into_iter())?.0;
+            if let Some(ref parse_cb) = self.parse_callbacks {
+                builder =
+                    builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
+            }
+            Some(BuilderState {
+                builder,
+                parse_callbacks: self.parse_callbacks,
+            })
+        } else {
+            None
+        };
+        Ok((self.builder, roundtrip_builder))
+    }
+}
+
+fn create_bindgen_builder(header: &Path) -> Result<BuilderState, Error> {
+    #[cfg(feature = "logging")]
+    let _ = env_logger::try_init();
+
+    let source = fs::File::open(header)?;
+    let reader = BufReader::new(source);
+
+    // Scoop up bindgen-flags from test header
+    let mut flags = Vec::with_capacity(2);
+    let mut parse_callbacks = None;
+
+    for line in reader.lines() {
+        let line = line?;
+        if !line.starts_with("// bindgen") {
+            continue;
+        }
+
+        if line.contains("bindgen-flags: ") {
+            let extra_flags = line
+                .split("bindgen-flags: ")
+                .last()
+                .and_then(shlex::split)
+                .unwrap();
+            flags.extend(extra_flags.into_iter());
+        } else if line.contains("bindgen-osx-only") {
+            let prepend_flags = ["--raw-line", "#![cfg(target_os=\"macos\")]"];
+            flags = prepend_flags
+                .iter()
+                .map(ToString::to_string)
+                .chain(flags)
+                .collect();
+        } else if line.contains("bindgen-parse-callbacks: ") {
+            let parse_cb =
+                line.split("bindgen-parse-callbacks: ").last().unwrap();
+            parse_callbacks = Some(parse_cb.to_owned());
+        }
+    }
+
+    // Different platforms have various different conventions like struct padding, mangling, etc.
+    // We make the default target as x86_64-unknown-linux
+    if flags.iter().all(|flag| !flag.starts_with("--target=")) {
+        if !flags.iter().any(|flag| flag == "--") {
+            flags.push("--".into());
+        }
+        flags.push("--target=x86_64-unknown-linux".into());
+    }
+
+    // Fool builder_from_flags() into believing it has real env::args_os...
+    // - add "bindgen" as executable name 0th element
+    // - add header filename as 1st element
+    // - prepend raw lines so they're in the right order for expected output
+    // - append the test header's bindgen flags
+    let header_str = header.to_str().ok_or_else(|| {
+        Error::new(ErrorKind::Other, "Invalid header file name")
+    })?;
+
+    let prepend = [
+        "bindgen",
+        // We format in `compare_generated_header` ourselves to have a little
+        // more control.
+        "--no-rustfmt-bindings",
+        "--with-derive-default",
+        "--disable-header-comment",
+        "--vtable-generation",
+        header_str,
+        "--raw-line",
+        "",
+        "--raw-line",
+        "#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]",
+        "--raw-line",
+        "",
+    ];
+
+    let args = prepend
+        .iter()
+        .map(ToString::to_string)
+        .chain(flags.into_iter());
+
+    let mut builder = builder_from_flags(args)?.0;
+    if let Some(ref parse_cb) = parse_callbacks {
+        builder = builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
+    }
+    Ok(BuilderState {
+        builder,
+        parse_callbacks,
+    })
+}
+
+macro_rules! test_header {
+    ($function:ident, $header:expr) => {
+        #[test]
+        fn $function() {
+            let header = PathBuf::from($header);
+            let result = create_bindgen_builder(&header).and_then(|builder| {
+                let check_roundtrip =
+                    env::var_os("BINDGEN_DISABLE_ROUNDTRIP_TEST").is_none();
+                compare_generated_header(&header, builder, check_roundtrip)
+            });
+
+            if let Err(err) = result {
+                panic!("{}", err);
+            }
+        }
+    };
+}
+
+// This file is generated by build.rs
+include!(concat!(env!("OUT_DIR"), "/tests.rs"));
+
+#[test]
+#[cfg_attr(target_os = "windows", ignore)]
+fn test_clang_env_args() {
+    std::env::set_var(
+        "BINDGEN_EXTRA_CLANG_ARGS",
+        "-D_ENV_ONE=1 -D_ENV_TWO=\"2 -DNOT_THREE=1\"",
+    );
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents(
+            "test.hpp",
+            "#ifdef _ENV_ONE\nextern const int x[] = { 42 };\n#endif\n\
+             #ifdef _ENV_TWO\nextern const int y[] = { 42 };\n#endif\n\
+             #ifdef NOT_THREE\nextern const int z[] = { 42 };\n#endif\n",
+        )
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let (actual, stderr) = rustfmt(actual);
+    println!("{}", stderr);
+
+    let (expected, _) = rustfmt(
+        "extern \"C\" {
+    pub static x: [::std::os::raw::c_int; 1usize];
+}
+extern \"C\" {
+    pub static y: [::std::os::raw::c_int; 1usize];
+}
+"
+        .to_string(),
+    );
+
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn test_header_contents() {
+    let actual = builder()
+        .disable_header_comment()
+        .header_contents("test.h", "int foo(const char* a);")
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let (actual, stderr) = rustfmt(actual);
+    println!("{}", stderr);
+
+    let (expected, _) = rustfmt(
+        "extern \"C\" {
+    pub fn foo(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
+}
+"
+        .to_string(),
+    );
+
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn test_multiple_header_calls_in_builder() {
+    let actual = builder()
+        .header(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/tests/headers/func_ptr.h"
+        ))
+        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h"))
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let (actual, stderr) = rustfmt(actual);
+    println!("{}", stderr);
+
+    let expected_filename = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/expectations/tests/test_multiple_header_calls_in_builder.rs"
+    );
+    let expected = include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/expectations/tests/test_multiple_header_calls_in_builder.rs"
+    ));
+    let (expected, _) = rustfmt(expected.to_string());
+
+    if actual != expected {
+        println!("Generated bindings differ from expected!");
+        error_diff_mismatch(
+            &actual,
+            &expected,
+            None,
+            Path::new(expected_filename),
+        )
+        .unwrap();
+    }
+}
+
+#[test]
+fn test_multiple_header_contents() {
+    let actual = builder()
+        .header_contents("test.h", "int foo(const char* a);")
+        .header_contents("test2.h", "float foo2(const char* b);")
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let (actual, stderr) = rustfmt(actual);
+    println!("{}", stderr);
+
+    let (expected, _) = rustfmt(
+        "extern \"C\" {
+    pub fn foo2(b: *const ::std::os::raw::c_char) -> f32;
+}
+extern \"C\" {
+    pub fn foo(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
+}
+"
+        .to_string(),
+    );
+
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn test_mixed_header_and_header_contents() {
+    let actual = builder()
+        .header(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/tests/headers/func_ptr.h"
+        ))
+        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h"))
+        .header_contents("test.h", "int bar(const char* a);")
+        .header_contents("test2.h", "float bar2(const char* b);")
+        .clang_arg("--target=x86_64-unknown-linux")
+        .generate()
+        .unwrap()
+        .to_string();
+
+    let (actual, stderr) = rustfmt(actual);
+    println!("{}", stderr);
+
+    let expected_filename = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/expectations/tests/test_mixed_header_and_header_contents.rs"
+    );
+    let expected = include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/expectations/tests/test_mixed_header_and_header_contents.rs"
+    ));
+    let (expected, _) = rustfmt(expected.to_string());
+    if expected != actual {
+        error_diff_mismatch(
+            &actual,
+            &expected,
+            None,
+            Path::new(expected_filename),
+        )
+        .unwrap();
+    }
+}
+
+#[test]
+// Doesn't support executing sh file on Windows.
+// We may want to implement it in Rust so that we support all systems.
+#[cfg(not(target_os = "windows"))]
+fn no_system_header_includes() {
+    use std::process::Command;
+    assert!(Command::new("../ci/no-includes.sh")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .spawn()
+        .expect("should spawn ../ci/no-includes.sh OK")
+        .wait()
+        .expect("should wait for ../ci/no-includes OK")
+        .success());
+}
+
+#[test]
+fn emit_depfile() {
+    let header = PathBuf::from("tests/headers/enum-default-rust.h");
+    let expected_depfile = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("expectations")
+        .join("tests")
+        .join("enum-default-rust.d");
+    let observed_depfile = tempfile::NamedTempFile::new().unwrap();
+    let mut builder = create_bindgen_builder(&header).unwrap();
+    builder.builder = builder.builder.depfile(
+        "tests/expectations/tests/enum-default-rust.rs",
+        observed_depfile.path(),
+    );
+
+    let check_roundtrip =
+        env::var_os("BINDGEN_DISABLE_ROUNDTRIP_TEST").is_none();
+    let (builder, _roundtrip_builder) =
+        builder.into_builder(check_roundtrip).unwrap();
+    let _bindings = builder.generate().unwrap();
+
+    let observed = std::fs::read_to_string(observed_depfile).unwrap();
+    let expected = std::fs::read_to_string(expected_depfile).unwrap();
+    assert_eq!(observed.trim(), expected.trim());
+}
+
+#[test]
+fn dump_preprocessed_input() {
+    let arg_keyword =
+        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/arg_keyword.hpp");
+    let empty_layout = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/headers/cpp-empty-layout.hpp"
+    );
+
+    builder()
+        .header(arg_keyword)
+        .header(empty_layout)
+        .dump_preprocessed_input()
+        .expect("should dump preprocessed input");
+
+    fn slurp(p: &str) -> String {
+        let mut contents = String::new();
+        let mut file = fs::File::open(p).unwrap();
+        file.read_to_string(&mut contents).unwrap();
+        contents
+    }
+
+    let bindgen_ii = slurp("__bindgen.ii");
+    let arg_keyword = slurp(arg_keyword);
+    let empty_layout = slurp(empty_layout);
+
+    assert!(
+        bindgen_ii.contains(&arg_keyword),
+        "arg_keyword.hpp is in the preprocessed file"
+    );
+    assert!(
+        bindgen_ii.contains(&empty_layout),
+        "cpp-empty-layout.hpp is in the preprocessed file"
+    );
+}
+
+#[test]
+fn allowlist_warnings() {
+    let header = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/headers/allowlist_warnings.h"
+    );
+
+    let bindings = builder()
+        .header(header)
+        .allowlist_function("doesnt_match_anything")
+        .generate()
+        .expect("unable to generate bindings");
+
+    assert_eq!(1, bindings.warnings().len());
+}
+
+fn build_flags_output_helper(builder: &bindgen::Builder) {
+    let mut command_line_flags = builder.command_line_flags();
+    command_line_flags.insert(0, "bindgen".to_string());
+
+    let flags_quoted: Vec<String> = command_line_flags
+        .iter()
+        .map(|x| format!("{}", shlex::quote(x)))
+        .collect();
+    let flags_str = flags_quoted.join(" ");
+    println!("{}", flags_str);
+
+    let (builder, _output, _verbose) =
+        crate::options::builder_from_flags(command_line_flags.into_iter())
+            .unwrap();
+    builder.generate().expect("failed to generate bindings");
+}
+
+#[test]
+fn commandline_multiple_headers() {
+    let bindings = bindgen::Builder::default()
+        .header("tests/headers/char.h")
+        .header("tests/headers/func_ptr.h")
+        .header("tests/headers/16-byte-alignment.h");
+    build_flags_output_helper(&bindings);
+}
diff --git a/bindgen-tests/tests/uses/.gitignore b/bindgen-tests/tests/uses/.gitignore
new file mode 100644
index 00000000..40d7cb4c
--- /dev/null
+++ b/bindgen-tests/tests/uses/.gitignore
@@ -0,0 +1,2 @@
+*.c
+*.cpp
diff --git a/bindgen/Cargo.toml b/bindgen/Cargo.toml
new file mode 100644
index 00000000..dca779bd
--- /dev/null
+++ b/bindgen/Cargo.toml
@@ -0,0 +1,69 @@
+[package]
+authors = [
+  "Jyun-Yan You <jyyou.tw@gmail.com>",
+  "Emilio Cobos Álvarez <emilio@crisal.io>",
+  "Nick Fitzgerald <fitzgen@gmail.com>",
+  "The Servo project developers",
+]
+description = "Automatically generates Rust FFI bindings to C and C++ libraries."
+keywords = ["bindings", "ffi", "code-generation"]
+categories = ["external-ffi-bindings", "development-tools::ffi"]
+license = "BSD-3-Clause"
+name = "bindgen"
+readme = "README.md"
+repository = "https://github.com/rust-lang/rust-bindgen"
+documentation = "https://docs.rs/bindgen"
+homepage = "https://rust-lang.github.io/rust-bindgen/"
+version = "0.60.1"
+edition = "2018"
+build = "build.rs"
+# If you change this, also update README.md and msrv in .github/workflows/bindgen.yml
+rust-version = "1.57.0"
+
+include = [
+  "LICENSE",
+  "README.md",
+  "Cargo.toml",
+  "build.rs",
+  "src/*.rs",
+  "src/**/*.rs",
+]
+
+
+[lib]
+name = "bindgen"
+path = "./lib.rs"
+
+[badges]
+travis-ci = { repository = "rust-lang/rust-bindgen" }
+
+[dependencies]
+bitflags = "1.0.3"
+cexpr = "0.6"
+clang-sys = { version = "1", features = ["clang_6_0"] }
+lazycell = "1"
+lazy_static = "1"
+peeking_take_while = "0.1.2"
+quote = { version = "1", default-features = false }
+syn = { version = "1.0.99", features = ["full", "extra-traits"]}
+regex = { version = "1.5", default-features = false , features = ["std", "unicode"] }
+which = { version = "4.2.1", optional = true, default-features = false }
+shlex = "1"
+rustc-hash = "1.0.1"
+proc-macro2 = { version = "1", default-features = false }
+log = { version = "0.4", optional = true }
+
+[features]
+default = ["logging", "runtime", "which-rustfmt"]
+logging = ["log"]
+static = ["clang-sys/static"]
+runtime = ["clang-sys/runtime"]
+# Dynamically discover a `rustfmt` binary using the `which` crate
+which-rustfmt = ["which"]
+
+# These features only exist for CI testing -- don't use them if you're not hacking
+# on bindgen!
+testing_only_docs = []
+testing_only_extra_assertions = []
+testing_only_libclang_9 = []
+testing_only_libclang_5 = []
diff --git a/bindgen/build.rs b/bindgen/build.rs
new file mode 100644
index 00000000..8407ceae
--- /dev/null
+++ b/bindgen/build.rs
@@ -0,0 +1,29 @@
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+
+    let mut dst =
+        File::create(Path::new(&out_dir).join("host-target.txt")).unwrap();
+    dst.write_all(env::var("TARGET").unwrap().as_bytes())
+        .unwrap();
+
+    // On behalf of clang_sys, rebuild ourselves if important configuration
+    // variables change, to ensure that bindings get rebuilt if the
+    // underlying libclang changes.
+    println!("cargo:rerun-if-env-changed=LLVM_CONFIG_PATH");
+    println!("cargo:rerun-if-env-changed=LIBCLANG_PATH");
+    println!("cargo:rerun-if-env-changed=LIBCLANG_STATIC_PATH");
+    println!("cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS");
+    println!(
+        "cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS_{}",
+        std::env::var("TARGET").unwrap()
+    );
+    println!(
+        "cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS_{}",
+        std::env::var("TARGET").unwrap().replace('-', "_")
+    );
+}
diff --git a/bindgen/callbacks.rs b/bindgen/callbacks.rs
new file mode 100644
index 00000000..9b345449
--- /dev/null
+++ b/bindgen/callbacks.rs
@@ -0,0 +1,106 @@
+//! A public API for more fine-grained customization of bindgen behavior.
+
+pub use crate::ir::analysis::DeriveTrait;
+pub use crate::ir::derive::CanDerive as ImplementsTrait;
+pub use crate::ir::enum_ty::{EnumVariantCustomBehavior, EnumVariantValue};
+pub use crate::ir::int::IntKind;
+use std::fmt;
+use std::panic::UnwindSafe;
+
+/// An enum to allow ignoring parsing of macros.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum MacroParsingBehavior {
+    /// Ignore the macro, generating no code for it, or anything that depends on
+    /// it.
+    Ignore,
+    /// The default behavior bindgen would have otherwise.
+    Default,
+}
+
+impl Default for MacroParsingBehavior {
+    fn default() -> Self {
+        MacroParsingBehavior::Default
+    }
+}
+
+/// A trait to allow configuring different kinds of types in different
+/// situations.
+pub trait ParseCallbacks: fmt::Debug + UnwindSafe {
+    /// This function will be run on every macro that is identified.
+    fn will_parse_macro(&self, _name: &str) -> MacroParsingBehavior {
+        MacroParsingBehavior::Default
+    }
+
+    /// The integer kind an integer macro should have, given a name and the
+    /// value of that macro, or `None` if you want the default to be chosen.
+    fn int_macro(&self, _name: &str, _value: i64) -> Option<IntKind> {
+        None
+    }
+
+    /// This will be run on every string macro. The callback cannot influence the further
+    /// treatment of the macro, but may use the value to generate additional code or configuration.
+    fn str_macro(&self, _name: &str, _value: &[u8]) {}
+
+    /// This will be run on every function-like macro. The callback cannot
+    /// influence the further treatment of the macro, but may use the value to
+    /// generate additional code or configuration.
+    ///
+    /// The first parameter represents the name and argument list (including the
+    /// parentheses) of the function-like macro. The second parameter represents
+    /// the expansion of the macro as a sequence of tokens.
+    fn func_macro(&self, _name: &str, _value: &[&[u8]]) {}
+
+    /// This function should return whether, given an enum variant
+    /// name, and value, this enum variant will forcibly be a constant.
+    fn enum_variant_behavior(
+        &self,
+        _enum_name: Option<&str>,
+        _original_variant_name: &str,
+        _variant_value: EnumVariantValue,
+    ) -> Option<EnumVariantCustomBehavior> {
+        None
+    }
+
+    /// Allows to rename an enum variant, replacing `_original_variant_name`.
+    fn enum_variant_name(
+        &self,
+        _enum_name: Option<&str>,
+        _original_variant_name: &str,
+        _variant_value: EnumVariantValue,
+    ) -> Option<String> {
+        None
+    }
+
+    /// Allows to rename an item, replacing `_original_item_name`.
+    fn item_name(&self, _original_item_name: &str) -> Option<String> {
+        None
+    }
+
+    /// This will be called on every file inclusion, with the full path of the included file.
+    fn include_file(&self, _filename: &str) {}
+
+    /// This will be called to determine whether a particular blocklisted type
+    /// implements a trait or not. This will be used to implement traits on
+    /// other types containing the blocklisted type.
+    ///
+    /// * `None`: use the default behavior
+    /// * `Some(ImplementsTrait::Yes)`: `_name` implements `_derive_trait`
+    /// * `Some(ImplementsTrait::Manually)`: any type including `_name` can't
+    ///   derive `_derive_trait` but can implemented it manually
+    /// * `Some(ImplementsTrait::No)`: `_name` doesn't implement `_derive_trait`
+    fn blocklisted_type_implements_trait(
+        &self,
+        _name: &str,
+        _derive_trait: DeriveTrait,
+    ) -> Option<ImplementsTrait> {
+        None
+    }
+
+    /// Provide a list of custom derive attributes.
+    ///
+    /// If no additional attributes are wanted, this function should return an
+    /// empty `Vec`.
+    fn add_derives(&self, _name: &str) -> Vec<String> {
+        vec![]
+    }
+}
diff --git a/bindgen/clang.rs b/bindgen/clang.rs
new file mode 100644
index 00000000..ea505c87
--- /dev/null
+++ b/bindgen/clang.rs
@@ -0,0 +1,2216 @@
+//! A higher level Clang API built on top of the generated bindings in the
+//! `clang_sys` module.
+
+#![allow(non_upper_case_globals, dead_code)]
+
+use crate::ir::context::BindgenContext;
+use clang_sys::*;
+use std::ffi::{CStr, CString};
+use std::fmt;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
+use std::{mem, ptr, slice};
+
+/// Type representing a clang attribute.
+///
+/// Values of this type can be used to check for different attributes using the `has_attrs`
+/// function.
+pub struct Attribute {
+    name: &'static [u8],
+    kind: Option<CXCursorKind>,
+    token_kind: CXTokenKind,
+}
+
+impl Attribute {
+    /// A `warn_unused_result` attribute.
+    pub const MUST_USE: Self = Self {
+        name: b"warn_unused_result",
+        // FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
+        kind: Some(440),
+        token_kind: CXToken_Identifier,
+    };
+
+    /// A `_Noreturn` attribute.
+    pub const NO_RETURN: Self = Self {
+        name: b"_Noreturn",
+        kind: None,
+        token_kind: CXToken_Keyword,
+    };
+
+    /// A `[[noreturn]]` attribute.
+    pub const NO_RETURN_CPP: Self = Self {
+        name: b"noreturn",
+        kind: None,
+        token_kind: CXToken_Identifier,
+    };
+}
+
+/// A cursor into the Clang AST, pointing to an AST node.
+///
+/// We call the AST node pointed to by the cursor the cursor's "referent".
+#[derive(Copy, Clone)]
+pub struct Cursor {
+    x: CXCursor,
+}
+
+impl fmt::Debug for Cursor {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            fmt,
+            "Cursor({} kind: {}, loc: {}, usr: {:?})",
+            self.spelling(),
+            kind_to_str(self.kind()),
+            self.location(),
+            self.usr()
+        )
+    }
+}
+
+impl Cursor {
+    /// Get the Unified Symbol Resolution for this cursor's referent, if
+    /// available.
+    ///
+    /// The USR can be used to compare entities across translation units.
+    pub fn usr(&self) -> Option<String> {
+        let s = unsafe { cxstring_into_string(clang_getCursorUSR(self.x)) };
+        if s.is_empty() {
+            None
+        } else {
+            Some(s)
+        }
+    }
+
+    /// Is this cursor's referent a declaration?
+    pub fn is_declaration(&self) -> bool {
+        unsafe { clang_isDeclaration(self.kind()) != 0 }
+    }
+
+    /// Get this cursor's referent's spelling.
+    pub fn spelling(&self) -> String {
+        unsafe { cxstring_into_string(clang_getCursorSpelling(self.x)) }
+    }
+
+    /// Get this cursor's referent's display name.
+    ///
+    /// This is not necessarily a valid identifier. It includes extra
+    /// information, such as parameters for a function, etc.
+    pub fn display_name(&self) -> String {
+        unsafe { cxstring_into_string(clang_getCursorDisplayName(self.x)) }
+    }
+
+    /// Get the mangled name of this cursor's referent.
+    pub fn mangling(&self) -> String {
+        unsafe { cxstring_into_string(clang_Cursor_getMangling(self.x)) }
+    }
+
+    /// Gets the C++ manglings for this cursor, or an error if the manglings
+    /// are not available.
+    pub fn cxx_manglings(&self) -> Result<Vec<String>, ()> {
+        use clang_sys::*;
+        unsafe {
+            let manglings = clang_Cursor_getCXXManglings(self.x);
+            if manglings.is_null() {
+                return Err(());
+            }
+            let count = (*manglings).Count as usize;
+
+            let mut result = Vec::with_capacity(count);
+            for i in 0..count {
+                let string_ptr = (*manglings).Strings.add(i);
+                result.push(cxstring_to_string_leaky(*string_ptr));
+            }
+            clang_disposeStringSet(manglings);
+            Ok(result)
+        }
+    }
+
+    /// Returns whether the cursor refers to a built-in definition.
+    pub fn is_builtin(&self) -> bool {
+        let (file, _, _, _) = self.location().location();
+        file.name().is_none()
+    }
+
+    /// Get the `Cursor` for this cursor's referent's lexical parent.
+    ///
+    /// The lexical parent is the parent of the definition. The semantic parent
+    /// is the parent of the declaration. Generally, the lexical parent doesn't
+    /// have any effect on semantics, while the semantic parent does.
+    ///
+    /// In the following snippet, the `Foo` class would be the semantic parent
+    /// of the out-of-line `method` definition, while the lexical parent is the
+    /// translation unit.
+    ///
+    /// ```c++
+    /// class Foo {
+    ///     void method();
+    /// };
+    ///
+    /// void Foo::method() { /* ... */ }
+    /// ```
+    pub fn lexical_parent(&self) -> Cursor {
+        unsafe {
+            Cursor {
+                x: clang_getCursorLexicalParent(self.x),
+            }
+        }
+    }
+
+    /// Get the referent's semantic parent, if one is available.
+    ///
+    /// See documentation for `lexical_parent` for details on semantic vs
+    /// lexical parents.
+    pub fn fallible_semantic_parent(&self) -> Option<Cursor> {
+        let sp = unsafe {
+            Cursor {
+                x: clang_getCursorSemanticParent(self.x),
+            }
+        };
+        if sp == *self || !sp.is_valid() {
+            return None;
+        }
+        Some(sp)
+    }
+
+    /// Get the referent's semantic parent.
+    ///
+    /// See documentation for `lexical_parent` for details on semantic vs
+    /// lexical parents.
+    pub fn semantic_parent(&self) -> Cursor {
+        self.fallible_semantic_parent().unwrap()
+    }
+
+    /// Return the number of template arguments used by this cursor's referent,
+    /// if the referent is either a template instantiation. Returns `None`
+    /// otherwise.
+    ///
+    /// NOTE: This may not return `Some` for partial template specializations,
+    /// see #193 and #194.
+    pub fn num_template_args(&self) -> Option<u32> {
+        // XXX: `clang_Type_getNumTemplateArguments` is sort of reliable, while
+        // `clang_Cursor_getNumTemplateArguments` is totally unreliable.
+        // Therefore, try former first, and only fallback to the latter if we
+        // have to.
+        self.cur_type()
+            .num_template_args()
+            .or_else(|| {
+                let n: c_int =
+                    unsafe { clang_Cursor_getNumTemplateArguments(self.x) };
+
+                if n >= 0 {
+                    Some(n as u32)
+                } else {
+                    debug_assert_eq!(n, -1);
+                    None
+                }
+            })
+            .or_else(|| {
+                let canonical = self.canonical();
+                if canonical != *self {
+                    canonical.num_template_args()
+                } else {
+                    None
+                }
+            })
+    }
+
+    /// Get a cursor pointing to this referent's containing translation unit.
+    ///
+    /// Note that we shouldn't create a `TranslationUnit` struct here, because
+    /// bindgen assumes there will only be one of them alive at a time, and
+    /// disposes it on drop. That can change if this would be required, but I
+    /// think we can survive fine without it.
+    pub fn translation_unit(&self) -> Cursor {
+        assert!(self.is_valid());
+        unsafe {
+            let tu = clang_Cursor_getTranslationUnit(self.x);
+            let cursor = Cursor {
+                x: clang_getTranslationUnitCursor(tu),
+            };
+            assert!(cursor.is_valid());
+            cursor
+        }
+    }
+
+    /// Is the referent a top level construct?
+    pub fn is_toplevel(&self) -> bool {
+        let mut semantic_parent = self.fallible_semantic_parent();
+
+        while semantic_parent.is_some() &&
+            (semantic_parent.unwrap().kind() == CXCursor_Namespace ||
+                semantic_parent.unwrap().kind() ==
+                    CXCursor_NamespaceAlias ||
+                semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
+        {
+            semantic_parent =
+                semantic_parent.unwrap().fallible_semantic_parent();
+        }
+
+        let tu = self.translation_unit();
+        // Yes, this can happen with, e.g., macro definitions.
+        semantic_parent == tu.fallible_semantic_parent()
+    }
+
+    /// There are a few kinds of types that we need to treat specially, mainly
+    /// not tracking the type declaration but the location of the cursor, given
+    /// clang doesn't expose a proper declaration for these types.
+    pub fn is_template_like(&self) -> bool {
+        matches!(
+            self.kind(),
+            CXCursor_ClassTemplate |
+                CXCursor_ClassTemplatePartialSpecialization |
+                CXCursor_TypeAliasTemplateDecl
+        )
+    }
+
+    /// Is this Cursor pointing to a function-like macro definition?
+    pub fn is_macro_function_like(&self) -> bool {
+        unsafe { clang_Cursor_isMacroFunctionLike(self.x) != 0 }
+    }
+
+    /// Get the kind of referent this cursor is pointing to.
+    pub fn kind(&self) -> CXCursorKind {
+        self.x.kind
+    }
+
+    /// Returns true if the cursor is a definition
+    pub fn is_definition(&self) -> bool {
+        unsafe { clang_isCursorDefinition(self.x) != 0 }
+    }
+
+    /// Is the referent a template specialization?
+    pub fn is_template_specialization(&self) -> bool {
+        self.specialized().is_some()
+    }
+
+    /// Is the referent a fully specialized template specialization without any
+    /// remaining free template arguments?
+    pub fn is_fully_specialized_template(&self) -> bool {
+        self.is_template_specialization() &&
+            self.kind() != CXCursor_ClassTemplatePartialSpecialization &&
+            self.num_template_args().unwrap_or(0) > 0
+    }
+
+    /// Is the referent a template specialization that still has remaining free
+    /// template arguments?
+    pub fn is_in_non_fully_specialized_template(&self) -> bool {
+        if self.is_toplevel() {
+            return false;
+        }
+
+        let parent = self.semantic_parent();
+        if parent.is_fully_specialized_template() {
+            return false;
+        }
+
+        if !parent.is_template_like() {
+            return parent.is_in_non_fully_specialized_template();
+        }
+
+        true
+    }
+
+    /// Is the referent any kind of template parameter?
+    pub fn is_template_parameter(&self) -> bool {
+        matches!(
+            self.kind(),
+            CXCursor_TemplateTemplateParameter |
+                CXCursor_TemplateTypeParameter |
+                CXCursor_NonTypeTemplateParameter
+        )
+    }
+
+    /// Does the referent's type or value depend on a template parameter?
+    pub fn is_dependent_on_template_parameter(&self) -> bool {
+        fn visitor(
+            found_template_parameter: &mut bool,
+            cur: Cursor,
+        ) -> CXChildVisitResult {
+            // If we found a template parameter, it is dependent.
+            if cur.is_template_parameter() {
+                *found_template_parameter = true;
+                return CXChildVisit_Break;
+            }
+
+            // Get the referent and traverse it as well.
+            if let Some(referenced) = cur.referenced() {
+                if referenced.is_template_parameter() {
+                    *found_template_parameter = true;
+                    return CXChildVisit_Break;
+                }
+
+                referenced
+                    .visit(|next| visitor(found_template_parameter, next));
+                if *found_template_parameter {
+                    return CXChildVisit_Break;
+                }
+            }
+
+            // Continue traversing the AST at the original cursor.
+            CXChildVisit_Recurse
+        }
+
+        if self.is_template_parameter() {
+            return true;
+        }
+
+        let mut found_template_parameter = false;
+        self.visit(|next| visitor(&mut found_template_parameter, next));
+
+        found_template_parameter
+    }
+
+    /// Is this cursor pointing a valid referent?
+    pub fn is_valid(&self) -> bool {
+        unsafe { clang_isInvalid(self.kind()) == 0 }
+    }
+
+    /// Get the source location for the referent.
+    pub fn location(&self) -> SourceLocation {
+        unsafe {
+            SourceLocation {
+                x: clang_getCursorLocation(self.x),
+            }
+        }
+    }
+
+    /// Get the source location range for the referent.
+    pub fn extent(&self) -> CXSourceRange {
+        unsafe { clang_getCursorExtent(self.x) }
+    }
+
+    /// Get the raw declaration comment for this referent, if one exists.
+    pub fn raw_comment(&self) -> Option<String> {
+        let s = unsafe {
+            cxstring_into_string(clang_Cursor_getRawCommentText(self.x))
+        };
+        if s.is_empty() {
+            None
+        } else {
+            Some(s)
+        }
+    }
+
+    /// Get the referent's parsed comment.
+    pub fn comment(&self) -> Comment {
+        unsafe {
+            Comment {
+                x: clang_Cursor_getParsedComment(self.x),
+            }
+        }
+    }
+
+    /// Get the referent's type.
+    pub fn cur_type(&self) -> Type {
+        unsafe {
+            Type {
+                x: clang_getCursorType(self.x),
+            }
+        }
+    }
+
+    /// Given that this cursor's referent is a reference to another type, or is
+    /// a declaration, get the cursor pointing to the referenced type or type of
+    /// the declared thing.
+    pub fn definition(&self) -> Option<Cursor> {
+        unsafe {
+            let ret = Cursor {
+                x: clang_getCursorDefinition(self.x),
+            };
+
+            if ret.is_valid() && ret.kind() != CXCursor_NoDeclFound {
+                Some(ret)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Given that this cursor's referent is reference type, get the cursor
+    /// pointing to the referenced type.
+    pub fn referenced(&self) -> Option<Cursor> {
+        unsafe {
+            let ret = Cursor {
+                x: clang_getCursorReferenced(self.x),
+            };
+
+            if ret.is_valid() {
+                Some(ret)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Get the canonical cursor for this referent.
+    ///
+    /// Many types can be declared multiple times before finally being properly
+    /// defined. This method allows us to get the canonical cursor for the
+    /// referent type.
+    pub fn canonical(&self) -> Cursor {
+        unsafe {
+            Cursor {
+                x: clang_getCanonicalCursor(self.x),
+            }
+        }
+    }
+
+    /// Given that this cursor points to either a template specialization or a
+    /// template instantiation, get a cursor pointing to the template definition
+    /// that is being specialized.
+    pub fn specialized(&self) -> Option<Cursor> {
+        unsafe {
+            let ret = Cursor {
+                x: clang_getSpecializedCursorTemplate(self.x),
+            };
+            if ret.is_valid() {
+                Some(ret)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Assuming that this cursor's referent is a template declaration, get the
+    /// kind of cursor that would be generated for its specializations.
+    pub fn template_kind(&self) -> CXCursorKind {
+        unsafe { clang_getTemplateCursorKind(self.x) }
+    }
+
+    /// Traverse this cursor's referent and its children.
+    ///
+    /// Call the given function on each AST node traversed.
+    pub fn visit<Visitor>(&self, mut visitor: Visitor)
+    where
+        Visitor: FnMut(Cursor) -> CXChildVisitResult,
+    {
+        let data = &mut visitor as *mut Visitor;
+        unsafe {
+            clang_visitChildren(self.x, visit_children::<Visitor>, data.cast());
+        }
+    }
+
+    /// Collect all of this cursor's children into a vec and return them.
+    pub fn collect_children(&self) -> Vec<Cursor> {
+        let mut children = vec![];
+        self.visit(|c| {
+            children.push(c);
+            CXChildVisit_Continue
+        });
+        children
+    }
+
+    /// Does this cursor have any children?
+    pub fn has_children(&self) -> bool {
+        let mut has_children = false;
+        self.visit(|_| {
+            has_children = true;
+            CXChildVisit_Break
+        });
+        has_children
+    }
+
+    /// Does this cursor have at least `n` children?
+    pub fn has_at_least_num_children(&self, n: usize) -> bool {
+        assert!(n > 0);
+        let mut num_left = n;
+        self.visit(|_| {
+            num_left -= 1;
+            if num_left == 0 {
+                CXChildVisit_Break
+            } else {
+                CXChildVisit_Continue
+            }
+        });
+        num_left == 0
+    }
+
+    /// Returns whether the given location contains a cursor with the given
+    /// kind in the first level of nesting underneath (doesn't look
+    /// recursively).
+    pub fn contains_cursor(&self, kind: CXCursorKind) -> bool {
+        let mut found = false;
+
+        self.visit(|c| {
+            if c.kind() == kind {
+                found = true;
+                CXChildVisit_Break
+            } else {
+                CXChildVisit_Continue
+            }
+        });
+
+        found
+    }
+
+    /// Is the referent an inlined function?
+    pub fn is_inlined_function(&self) -> bool {
+        unsafe { clang_Cursor_isFunctionInlined(self.x) != 0 }
+    }
+
+    /// Is the referent a defaulted function?
+    pub fn is_defaulted_function(&self) -> bool {
+        unsafe { clang_CXXMethod_isDefaulted(self.x) != 0 }
+    }
+
+    /// Is the referent a deleted function?
+    pub fn is_deleted_function(&self) -> bool {
+        // Unfortunately, libclang doesn't yet have an API for checking if a
+        // member function is deleted, but the following should be a good
+        // enough approximation.
+        // Deleted functions are implicitly inline according to paragraph 4 of
+        // [dcl.fct.def.delete] in the C++ standard. Normal inline functions
+        // have a definition in the same translation unit, so if this is an
+        // inline function without a definition, and it's not a defaulted
+        // function, we can reasonably safely conclude that it's a deleted
+        // function.
+        self.is_inlined_function() &&
+            self.definition().is_none() &&
+            !self.is_defaulted_function()
+    }
+
+    /// Is the referent a bit field declaration?
+    pub fn is_bit_field(&self) -> bool {
+        unsafe { clang_Cursor_isBitField(self.x) != 0 }
+    }
+
+    /// Get a cursor to the bit field's width expression, or `None` if it's not
+    /// a bit field.
+    pub fn bit_width_expr(&self) -> Option<Cursor> {
+        if !self.is_bit_field() {
+            return None;
+        }
+
+        let mut result = None;
+        self.visit(|cur| {
+            // The first child may or may not be a TypeRef, depending on whether
+            // the field's type is builtin. Skip it.
+            if cur.kind() == CXCursor_TypeRef {
+                return CXChildVisit_Continue;
+            }
+
+            // The next expression or literal is the bit width.
+            result = Some(cur);
+
+            CXChildVisit_Break
+        });
+
+        result
+    }
+
+    /// Get the width of this cursor's referent bit field, or `None` if the
+    /// referent is not a bit field or if the width could not be evaluated.
+    pub fn bit_width(&self) -> Option<u32> {
+        // It is not safe to check the bit width without ensuring it doesn't
+        // depend on a template parameter. See
+        // https://github.com/rust-lang/rust-bindgen/issues/2239
+        if self.bit_width_expr()?.is_dependent_on_template_parameter() {
+            return None;
+        }
+
+        unsafe {
+            let w = clang_getFieldDeclBitWidth(self.x);
+            if w == -1 {
+                None
+            } else {
+                Some(w as u32)
+            }
+        }
+    }
+
+    /// Get the integer representation type used to hold this cursor's referent
+    /// enum type.
+    pub fn enum_type(&self) -> Option<Type> {
+        unsafe {
+            let t = Type {
+                x: clang_getEnumDeclIntegerType(self.x),
+            };
+            if t.is_valid() {
+                Some(t)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Get the boolean constant value for this cursor's enum variant referent.
+    ///
+    /// Returns None if the cursor's referent is not an enum variant.
+    pub fn enum_val_boolean(&self) -> Option<bool> {
+        unsafe {
+            if self.kind() == CXCursor_EnumConstantDecl {
+                Some(clang_getEnumConstantDeclValue(self.x) != 0)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Get the signed constant value for this cursor's enum variant referent.
+    ///
+    /// Returns None if the cursor's referent is not an enum variant.
+    pub fn enum_val_signed(&self) -> Option<i64> {
+        unsafe {
+            if self.kind() == CXCursor_EnumConstantDecl {
+                Some(clang_getEnumConstantDeclValue(self.x) as i64)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Get the unsigned constant value for this cursor's enum variant referent.
+    ///
+    /// Returns None if the cursor's referent is not an enum variant.
+    pub fn enum_val_unsigned(&self) -> Option<u64> {
+        unsafe {
+            if self.kind() == CXCursor_EnumConstantDecl {
+                Some(clang_getEnumConstantDeclUnsignedValue(self.x) as u64)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Does this cursor have the given attributes?
+    pub fn has_attrs<const N: usize>(
+        &self,
+        attrs: &[Attribute; N],
+    ) -> [bool; N] {
+        let mut found_attrs = [false; N];
+        let mut found_count = 0;
+
+        self.visit(|cur| {
+            let kind = cur.kind();
+            for (idx, attr) in attrs.iter().enumerate() {
+                let found_attr = &mut found_attrs[idx];
+                if !*found_attr {
+                    // `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
+                    if attr.kind.map_or(false, |k| k == kind) ||
+                        (kind == CXCursor_UnexposedAttr &&
+                            cur.tokens().iter().any(|t| {
+                                t.kind == attr.token_kind &&
+                                    t.spelling() == attr.name
+                            }))
+                    {
+                        *found_attr = true;
+                        found_count += 1;
+
+                        if found_count == N {
+                            return CXChildVisit_Break;
+                        }
+                    }
+                }
+            }
+
+            CXChildVisit_Continue
+        });
+
+        found_attrs
+    }
+
+    /// Given that this cursor's referent is a `typedef`, get the `Type` that is
+    /// being aliased.
+    pub fn typedef_type(&self) -> Option<Type> {
+        let inner = Type {
+            x: unsafe { clang_getTypedefDeclUnderlyingType(self.x) },
+        };
+
+        if inner.is_valid() {
+            Some(inner)
+        } else {
+            None
+        }
+    }
+
+    /// Get the linkage kind for this cursor's referent.
+    ///
+    /// This only applies to functions and variables.
+    pub fn linkage(&self) -> CXLinkageKind {
+        unsafe { clang_getCursorLinkage(self.x) }
+    }
+
+    /// Get the visibility of this cursor's referent.
+    pub fn visibility(&self) -> CXVisibilityKind {
+        unsafe { clang_getCursorVisibility(self.x) }
+    }
+
+    /// Given that this cursor's referent is a function, return cursors to its
+    /// parameters.
+    ///
+    /// Returns None if the cursor's referent is not a function/method call or
+    /// declaration.
+    pub fn args(&self) -> Option<Vec<Cursor>> {
+        // match self.kind() {
+        // CXCursor_FunctionDecl |
+        // CXCursor_CXXMethod => {
+        self.num_args().ok().map(|num| {
+            (0..num)
+                .map(|i| Cursor {
+                    x: unsafe { clang_Cursor_getArgument(self.x, i as c_uint) },
+                })
+                .collect()
+        })
+    }
+
+    /// Given that this cursor's referent is a function/method call or
+    /// declaration, return the number of arguments it takes.
+    ///
+    /// Returns Err if the cursor's referent is not a function/method call or
+    /// declaration.
+    pub fn num_args(&self) -> Result<u32, ()> {
+        unsafe {
+            let w = clang_Cursor_getNumArguments(self.x);
+            if w == -1 {
+                Err(())
+            } else {
+                Ok(w as u32)
+            }
+        }
+    }
+
+    /// Get the access specifier for this cursor's referent.
+    pub fn access_specifier(&self) -> CX_CXXAccessSpecifier {
+        unsafe { clang_getCXXAccessSpecifier(self.x) }
+    }
+
+    /// Is the cursor's referrent publically accessible in C++?
+    ///
+    /// Returns true if self.access_specifier() is `CX_CXXPublic` or
+    /// `CX_CXXInvalidAccessSpecifier`.
+    pub fn public_accessible(&self) -> bool {
+        let access = self.access_specifier();
+        access == CX_CXXPublic || access == CX_CXXInvalidAccessSpecifier
+    }
+
+    /// Is this cursor's referent a field declaration that is marked as
+    /// `mutable`?
+    pub fn is_mutable_field(&self) -> bool {
+        unsafe { clang_CXXField_isMutable(self.x) != 0 }
+    }
+
+    /// Get the offset of the field represented by the Cursor.
+    pub fn offset_of_field(&self) -> Result<usize, LayoutError> {
+        let offset = unsafe { clang_Cursor_getOffsetOfField(self.x) };
+
+        if offset < 0 {
+            Err(LayoutError::from(offset as i32))
+        } else {
+            Ok(offset as usize)
+        }
+    }
+
+    /// Is this cursor's referent a member function that is declared `static`?
+    pub fn method_is_static(&self) -> bool {
+        unsafe { clang_CXXMethod_isStatic(self.x) != 0 }
+    }
+
+    /// Is this cursor's referent a member function that is declared `const`?
+    pub fn method_is_const(&self) -> bool {
+        unsafe { clang_CXXMethod_isConst(self.x) != 0 }
+    }
+
+    /// Is this cursor's referent a member function that is virtual?
+    pub fn method_is_virtual(&self) -> bool {
+        unsafe { clang_CXXMethod_isVirtual(self.x) != 0 }
+    }
+
+    /// Is this cursor's referent a member function that is pure virtual?
+    pub fn method_is_pure_virtual(&self) -> bool {
+        unsafe { clang_CXXMethod_isPureVirtual(self.x) != 0 }
+    }
+
+    /// Is this cursor's referent a struct or class with virtual members?
+    pub fn is_virtual_base(&self) -> bool {
+        unsafe { clang_isVirtualBase(self.x) != 0 }
+    }
+
+    /// Try to evaluate this cursor.
+    pub fn evaluate(&self) -> Option<EvalResult> {
+        EvalResult::new(*self)
+    }
+
+    /// Return the result type for this cursor
+    pub fn ret_type(&self) -> Option<Type> {
+        let rt = Type {
+            x: unsafe { clang_getCursorResultType(self.x) },
+        };
+        if rt.is_valid() {
+            Some(rt)
+        } else {
+            None
+        }
+    }
+
+    /// Gets the tokens that correspond to that cursor.
+    pub fn tokens(&self) -> RawTokens {
+        RawTokens::new(self)
+    }
+
+    /// Gets the tokens that correspond to that cursor as  `cexpr` tokens.
+    pub fn cexpr_tokens(self) -> Vec<cexpr::token::Token> {
+        self.tokens()
+            .iter()
+            .filter_map(|token| token.as_cexpr_token())
+            .collect()
+    }
+
+    /// Obtain the real path name of a cursor of InclusionDirective kind.
+    ///
+    /// Returns None if the cursor does not include a file, otherwise the file's full name
+    pub fn get_included_file_name(&self) -> Option<String> {
+        let file = unsafe { clang_sys::clang_getIncludedFile(self.x) };
+        if file.is_null() {
+            None
+        } else {
+            Some(unsafe {
+                cxstring_into_string(clang_sys::clang_getFileName(file))
+            })
+        }
+    }
+}
+
+/// A struct that owns the tokenizer result from a given cursor.
+pub struct RawTokens<'a> {
+    cursor: &'a Cursor,
+    tu: CXTranslationUnit,
+    tokens: *mut CXToken,
+    token_count: c_uint,
+}
+
+impl<'a> RawTokens<'a> {
+    fn new(cursor: &'a Cursor) -> Self {
+        let mut tokens = ptr::null_mut();
+        let mut token_count = 0;
+        let range = cursor.extent();
+        let tu = unsafe { clang_Cursor_getTranslationUnit(cursor.x) };
+        unsafe { clang_tokenize(tu, range, &mut tokens, &mut token_count) };
+        Self {
+            cursor,
+            tu,
+            tokens,
+            token_count,
+        }
+    }
+
+    fn as_slice(&self) -> &[CXToken] {
+        if self.tokens.is_null() {
+            return &[];
+        }
+        unsafe { slice::from_raw_parts(self.tokens, self.token_count as usize) }
+    }
+
+    /// Get an iterator over these tokens.
+    pub fn iter(&self) -> ClangTokenIterator {
+        ClangTokenIterator {
+            tu: self.tu,
+            raw: self.as_slice().iter(),
+        }
+    }
+}
+
+impl<'a> Drop for RawTokens<'a> {
+    fn drop(&mut self) {
+        if !self.tokens.is_null() {
+            unsafe {
+                clang_disposeTokens(
+                    self.tu,
+                    self.tokens,
+                    self.token_count as c_uint,
+                );
+            }
+        }
+    }
+}
+
+/// A raw clang token, that exposes only kind, spelling, and extent. This is a
+/// slightly more convenient version of `CXToken` which owns the spelling
+/// string and extent.
+#[derive(Debug)]
+pub struct ClangToken {
+    spelling: CXString,
+    /// The extent of the token. This is the same as the relevant member from
+    /// `CXToken`.
+    pub extent: CXSourceRange,
+    /// The kind of the token. This is the same as the relevant member from
+    /// `CXToken`.
+    pub kind: CXTokenKind,
+}
+
+impl ClangToken {
+    /// Get the token spelling, without being converted to utf-8.
+    pub fn spelling(&self) -> &[u8] {
+        let c_str = unsafe {
+            CStr::from_ptr(clang_getCString(self.spelling) as *const _)
+        };
+        c_str.to_bytes()
+    }
+
+    /// Converts a ClangToken to a `cexpr` token if possible.
+    pub fn as_cexpr_token(&self) -> Option<cexpr::token::Token> {
+        use cexpr::token;
+
+        let kind = match self.kind {
+            CXToken_Punctuation => token::Kind::Punctuation,
+            CXToken_Literal => token::Kind::Literal,
+            CXToken_Identifier => token::Kind::Identifier,
+            CXToken_Keyword => token::Kind::Keyword,
+            // NB: cexpr is not too happy about comments inside
+            // expressions, so we strip them down here.
+            CXToken_Comment => return None,
+            _ => {
+                warn!("Found unexpected token kind: {:?}", self);
+                return None;
+            }
+        };
+
+        Some(token::Token {
+            kind,
+            raw: self.spelling().to_vec().into_boxed_slice(),
+        })
+    }
+}
+
+impl Drop for ClangToken {
+    fn drop(&mut self) {
+        unsafe { clang_disposeString(self.spelling) }
+    }
+}
+
+/// An iterator over a set of Tokens.
+pub struct ClangTokenIterator<'a> {
+    tu: CXTranslationUnit,
+    raw: slice::Iter<'a, CXToken>,
+}
+
+impl<'a> Iterator for ClangTokenIterator<'a> {
+    type Item = ClangToken;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let raw = self.raw.next()?;
+        unsafe {
+            let kind = clang_getTokenKind(*raw);
+            let spelling = clang_getTokenSpelling(self.tu, *raw);
+            let extent = clang_getTokenExtent(self.tu, *raw);
+            Some(ClangToken {
+                kind,
+                extent,
+                spelling,
+            })
+        }
+    }
+}
+
+/// Checks whether the name looks like an identifier, i.e. is alphanumeric
+/// (including '_') and does not start with a digit.
+pub fn is_valid_identifier(name: &str) -> bool {
+    let mut chars = name.chars();
+    let first_valid = chars
+        .next()
+        .map(|c| c.is_alphabetic() || c == '_')
+        .unwrap_or(false);
+
+    first_valid && chars.all(|c| c.is_alphanumeric() || c == '_')
+}
+
+extern "C" fn visit_children<Visitor>(
+    cur: CXCursor,
+    _parent: CXCursor,
+    data: CXClientData,
+) -> CXChildVisitResult
+where
+    Visitor: FnMut(Cursor) -> CXChildVisitResult,
+{
+    let func: &mut Visitor = unsafe { &mut *(data as *mut Visitor) };
+    let child = Cursor { x: cur };
+
+    (*func)(child)
+}
+
+impl PartialEq for Cursor {
+    fn eq(&self, other: &Cursor) -> bool {
+        unsafe { clang_equalCursors(self.x, other.x) == 1 }
+    }
+}
+
+impl Eq for Cursor {}
+
+impl Hash for Cursor {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        unsafe { clang_hashCursor(self.x) }.hash(state)
+    }
+}
+
+/// The type of a node in clang's AST.
+#[derive(Clone, Copy)]
+pub struct Type {
+    x: CXType,
+}
+
+impl PartialEq for Type {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe { clang_equalTypes(self.x, other.x) != 0 }
+    }
+}
+
+impl Eq for Type {}
+
+impl fmt::Debug for Type {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            fmt,
+            "Type({}, kind: {}, cconv: {}, decl: {:?}, canon: {:?})",
+            self.spelling(),
+            type_to_str(self.kind()),
+            self.call_conv(),
+            self.declaration(),
+            self.declaration().canonical()
+        )
+    }
+}
+
+/// An error about the layout of a struct, class, or type.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum LayoutError {
+    /// Asked for the layout of an invalid type.
+    Invalid,
+    /// Asked for the layout of an incomplete type.
+    Incomplete,
+    /// Asked for the layout of a dependent type.
+    Dependent,
+    /// Asked for the layout of a type that does not have constant size.
+    NotConstantSize,
+    /// Asked for the layout of a field in a type that does not have such a
+    /// field.
+    InvalidFieldName,
+    /// An unknown layout error.
+    Unknown,
+}
+
+impl ::std::convert::From<i32> for LayoutError {
+    fn from(val: i32) -> Self {
+        use self::LayoutError::*;
+
+        match val {
+            CXTypeLayoutError_Invalid => Invalid,
+            CXTypeLayoutError_Incomplete => Incomplete,
+            CXTypeLayoutError_Dependent => Dependent,
+            CXTypeLayoutError_NotConstantSize => NotConstantSize,
+            CXTypeLayoutError_InvalidFieldName => InvalidFieldName,
+            _ => Unknown,
+        }
+    }
+}
+
+impl Type {
+    /// Get this type's kind.
+    pub fn kind(&self) -> CXTypeKind {
+        self.x.kind
+    }
+
+    /// Get a cursor pointing to this type's declaration.
+    pub fn declaration(&self) -> Cursor {
+        unsafe {
+            Cursor {
+                x: clang_getTypeDeclaration(self.x),
+            }
+        }
+    }
+
+    /// Get the canonical declaration of this type, if it is available.
+    pub fn canonical_declaration(
+        &self,
+        location: Option<&Cursor>,
+    ) -> Option<CanonicalTypeDeclaration> {
+        let mut declaration = self.declaration();
+        if !declaration.is_valid() {
+            if let Some(location) = location {
+                let mut location = *location;
+                if let Some(referenced) = location.referenced() {
+                    location = referenced;
+                }
+                if location.is_template_like() {
+                    declaration = location;
+                }
+            }
+        }
+
+        let canonical = declaration.canonical();
+        if canonical.is_valid() && canonical.kind() != CXCursor_NoDeclFound {
+            Some(CanonicalTypeDeclaration(*self, canonical))
+        } else {
+            None
+        }
+    }
+
+    /// Get a raw display name for this type.
+    pub fn spelling(&self) -> String {
+        let s = unsafe { cxstring_into_string(clang_getTypeSpelling(self.x)) };
+        // Clang 5.0 introduced changes in the spelling API so it returned the
+        // full qualified name. Let's undo that here.
+        if s.split("::").all(is_valid_identifier) {
+            if let Some(s) = s.split("::").last() {
+                return s.to_owned();
+            }
+        }
+
+        s
+    }
+
+    /// Is this type const qualified?
+    pub fn is_const(&self) -> bool {
+        unsafe { clang_isConstQualifiedType(self.x) != 0 }
+    }
+
+    #[inline]
+    fn is_non_deductible_auto_type(&self) -> bool {
+        debug_assert_eq!(self.kind(), CXType_Auto);
+        self.canonical_type() == *self
+    }
+
+    #[inline]
+    fn clang_size_of(&self, ctx: &BindgenContext) -> c_longlong {
+        match self.kind() {
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
+            CXType_RValueReference | CXType_LValueReference => {
+                ctx.target_pointer_size() as c_longlong
+            }
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+            CXType_Auto if self.is_non_deductible_auto_type() => -6,
+            _ => unsafe { clang_Type_getSizeOf(self.x) },
+        }
+    }
+
+    #[inline]
+    fn clang_align_of(&self, ctx: &BindgenContext) -> c_longlong {
+        match self.kind() {
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
+            CXType_RValueReference | CXType_LValueReference => {
+                ctx.target_pointer_size() as c_longlong
+            }
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+            CXType_Auto if self.is_non_deductible_auto_type() => -6,
+            _ => unsafe { clang_Type_getAlignOf(self.x) },
+        }
+    }
+
+    /// What is the size of this type? Paper over invalid types by returning `0`
+    /// for them.
+    pub fn size(&self, ctx: &BindgenContext) -> usize {
+        let val = self.clang_size_of(ctx);
+        if val < 0 {
+            0
+        } else {
+            val as usize
+        }
+    }
+
+    /// What is the size of this type?
+    pub fn fallible_size(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Result<usize, LayoutError> {
+        let val = self.clang_size_of(ctx);
+        if val < 0 {
+            Err(LayoutError::from(val as i32))
+        } else {
+            Ok(val as usize)
+        }
+    }
+
+    /// What is the alignment of this type? Paper over invalid types by
+    /// returning `0`.
+    pub fn align(&self, ctx: &BindgenContext) -> usize {
+        let val = self.clang_align_of(ctx);
+        if val < 0 {
+            0
+        } else {
+            val as usize
+        }
+    }
+
+    /// What is the alignment of this type?
+    pub fn fallible_align(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Result<usize, LayoutError> {
+        let val = self.clang_align_of(ctx);
+        if val < 0 {
+            Err(LayoutError::from(val as i32))
+        } else {
+            Ok(val as usize)
+        }
+    }
+
+    /// Get the layout for this type, or an error describing why it does not
+    /// have a valid layout.
+    pub fn fallible_layout(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Result<crate::ir::layout::Layout, LayoutError> {
+        use crate::ir::layout::Layout;
+        let size = self.fallible_size(ctx)?;
+        let align = self.fallible_align(ctx)?;
+        Ok(Layout::new(size, align))
+    }
+
+    /// Get the number of template arguments this type has, or `None` if it is
+    /// not some kind of template.
+    pub fn num_template_args(&self) -> Option<u32> {
+        let n = unsafe { clang_Type_getNumTemplateArguments(self.x) };
+        if n >= 0 {
+            Some(n as u32)
+        } else {
+            debug_assert_eq!(n, -1);
+            None
+        }
+    }
+
+    /// If this type is a class template specialization, return its
+    /// template arguments. Otherwise, return None.
+    pub fn template_args(&self) -> Option<TypeTemplateArgIterator> {
+        self.num_template_args().map(|n| TypeTemplateArgIterator {
+            x: self.x,
+            length: n,
+            index: 0,
+        })
+    }
+
+    /// Given that this type is a function prototype, return the types of its parameters.
+    ///
+    /// Returns None if the type is not a function prototype.
+    pub fn args(&self) -> Option<Vec<Type>> {
+        self.num_args().ok().map(|num| {
+            (0..num)
+                .map(|i| Type {
+                    x: unsafe { clang_getArgType(self.x, i as c_uint) },
+                })
+                .collect()
+        })
+    }
+
+    /// Given that this type is a function prototype, return the number of arguments it takes.
+    ///
+    /// Returns Err if the type is not a function prototype.
+    pub fn num_args(&self) -> Result<u32, ()> {
+        unsafe {
+            let w = clang_getNumArgTypes(self.x);
+            if w == -1 {
+                Err(())
+            } else {
+                Ok(w as u32)
+            }
+        }
+    }
+
+    /// Given that this type is a pointer type, return the type that it points
+    /// to.
+    pub fn pointee_type(&self) -> Option<Type> {
+        match self.kind() {
+            CXType_Pointer |
+            CXType_RValueReference |
+            CXType_LValueReference |
+            CXType_MemberPointer |
+            CXType_BlockPointer |
+            CXType_ObjCObjectPointer => {
+                let ret = Type {
+                    x: unsafe { clang_getPointeeType(self.x) },
+                };
+                debug_assert!(ret.is_valid());
+                Some(ret)
+            }
+            _ => None,
+        }
+    }
+
+    /// Given that this type is an array, vector, or complex type, return the
+    /// type of its elements.
+    pub fn elem_type(&self) -> Option<Type> {
+        let current_type = Type {
+            x: unsafe { clang_getElementType(self.x) },
+        };
+        if current_type.is_valid() {
+            Some(current_type)
+        } else {
+            None
+        }
+    }
+
+    /// Given that this type is an array or vector type, return its number of
+    /// elements.
+    pub fn num_elements(&self) -> Option<usize> {
+        let num_elements_returned = unsafe { clang_getNumElements(self.x) };
+        if num_elements_returned != -1 {
+            Some(num_elements_returned as usize)
+        } else {
+            None
+        }
+    }
+
+    /// Get the canonical version of this type. This sees through `typedef`s and
+    /// aliases to get the underlying, canonical type.
+    pub fn canonical_type(&self) -> Type {
+        unsafe {
+            Type {
+                x: clang_getCanonicalType(self.x),
+            }
+        }
+    }
+
+    /// Is this type a variadic function type?
+    pub fn is_variadic(&self) -> bool {
+        unsafe { clang_isFunctionTypeVariadic(self.x) != 0 }
+    }
+
+    /// Given that this type is a function type, get the type of its return
+    /// value.
+    pub fn ret_type(&self) -> Option<Type> {
+        let rt = Type {
+            x: unsafe { clang_getResultType(self.x) },
+        };
+        if rt.is_valid() {
+            Some(rt)
+        } else {
+            None
+        }
+    }
+
+    /// Given that this type is a function type, get its calling convention. If
+    /// this is not a function type, `CXCallingConv_Invalid` is returned.
+    pub fn call_conv(&self) -> CXCallingConv {
+        unsafe { clang_getFunctionTypeCallingConv(self.x) }
+    }
+
+    /// For elaborated types (types which use `class`, `struct`, or `union` to
+    /// disambiguate types from local bindings), get the underlying type.
+    pub fn named(&self) -> Type {
+        unsafe {
+            Type {
+                x: clang_Type_getNamedType(self.x),
+            }
+        }
+    }
+
+    /// Is this a valid type?
+    pub fn is_valid(&self) -> bool {
+        self.kind() != CXType_Invalid
+    }
+
+    /// Is this a valid and exposed type?
+    pub fn is_valid_and_exposed(&self) -> bool {
+        self.is_valid() && self.kind() != CXType_Unexposed
+    }
+
+    /// Is this type a fully instantiated template?
+    pub fn is_fully_instantiated_template(&self) -> bool {
+        // Yep, the spelling of this containing type-parameter is extremely
+        // nasty... But can happen in <type_traits>. Unfortunately I couldn't
+        // reduce it enough :(
+        self.template_args().map_or(false, |args| args.len() > 0) &&
+            !matches!(
+                self.declaration().kind(),
+                CXCursor_ClassTemplatePartialSpecialization |
+                    CXCursor_TypeAliasTemplateDecl |
+                    CXCursor_TemplateTemplateParameter
+            )
+    }
+
+    /// Is this type an associated template type? Eg `T::Associated` in
+    /// this example:
+    ///
+    /// ```c++
+    /// template <typename T>
+    /// class Foo {
+    ///     typename T::Associated member;
+    /// };
+    /// ```
+    pub fn is_associated_type(&self) -> bool {
+        // This is terrible :(
+        fn hacky_parse_associated_type<S: AsRef<str>>(spelling: S) -> bool {
+            lazy_static! {
+                static ref ASSOC_TYPE_RE: regex::Regex = regex::Regex::new(
+                    r"typename type\-parameter\-\d+\-\d+::.+"
+                )
+                .unwrap();
+            }
+            ASSOC_TYPE_RE.is_match(spelling.as_ref())
+        }
+
+        self.kind() == CXType_Unexposed &&
+            (hacky_parse_associated_type(self.spelling()) ||
+                hacky_parse_associated_type(
+                    self.canonical_type().spelling(),
+                ))
+    }
+}
+
+/// The `CanonicalTypeDeclaration` type exists as proof-by-construction that its
+/// cursor is the canonical declaration for its type. If you have a
+/// `CanonicalTypeDeclaration` instance, you know for sure that the type and
+/// cursor match up in a canonical declaration relationship, and it simply
+/// cannot be otherwise.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CanonicalTypeDeclaration(Type, Cursor);
+
+impl CanonicalTypeDeclaration {
+    /// Get the type.
+    pub fn ty(&self) -> &Type {
+        &self.0
+    }
+
+    /// Get the type's canonical declaration cursor.
+    pub fn cursor(&self) -> &Cursor {
+        &self.1
+    }
+}
+
+/// An iterator for a type's template arguments.
+pub struct TypeTemplateArgIterator {
+    x: CXType,
+    length: u32,
+    index: u32,
+}
+
+impl Iterator for TypeTemplateArgIterator {
+    type Item = Type;
+    fn next(&mut self) -> Option<Type> {
+        if self.index < self.length {
+            let idx = self.index as c_uint;
+            self.index += 1;
+            Some(Type {
+                x: unsafe { clang_Type_getTemplateArgumentAsType(self.x, idx) },
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl ExactSizeIterator for TypeTemplateArgIterator {
+    fn len(&self) -> usize {
+        assert!(self.index <= self.length);
+        (self.length - self.index) as usize
+    }
+}
+
+/// A `SourceLocation` is a file, line, column, and byte offset location for
+/// some source text.
+pub struct SourceLocation {
+    x: CXSourceLocation,
+}
+
+impl SourceLocation {
+    /// Get the (file, line, column, byte offset) tuple for this source
+    /// location.
+    pub fn location(&self) -> (File, usize, usize, usize) {
+        unsafe {
+            let mut file = mem::zeroed();
+            let mut line = 0;
+            let mut col = 0;
+            let mut off = 0;
+            clang_getSpellingLocation(
+                self.x, &mut file, &mut line, &mut col, &mut off,
+            );
+            (File { x: file }, line as usize, col as usize, off as usize)
+        }
+    }
+}
+
+impl fmt::Display for SourceLocation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let (file, line, col, _) = self.location();
+        if let Some(name) = file.name() {
+            write!(f, "{}:{}:{}", name, line, col)
+        } else {
+            "builtin definitions".fmt(f)
+        }
+    }
+}
+
+impl fmt::Debug for SourceLocation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+/// A comment in the source text.
+///
+/// Comments are sort of parsed by Clang, and have a tree structure.
+pub struct Comment {
+    x: CXComment,
+}
+
+impl Comment {
+    /// What kind of comment is this?
+    pub fn kind(&self) -> CXCommentKind {
+        unsafe { clang_Comment_getKind(self.x) }
+    }
+
+    /// Get this comment's children comment
+    pub fn get_children(&self) -> CommentChildrenIterator {
+        CommentChildrenIterator {
+            parent: self.x,
+            length: unsafe { clang_Comment_getNumChildren(self.x) },
+            index: 0,
+        }
+    }
+
+    /// Given that this comment is the start or end of an HTML tag, get its tag
+    /// name.
+    pub fn get_tag_name(&self) -> String {
+        unsafe { cxstring_into_string(clang_HTMLTagComment_getTagName(self.x)) }
+    }
+
+    /// Given that this comment is an HTML start tag, get its attributes.
+    pub fn get_tag_attrs(&self) -> CommentAttributesIterator {
+        CommentAttributesIterator {
+            x: self.x,
+            length: unsafe { clang_HTMLStartTag_getNumAttrs(self.x) },
+            index: 0,
+        }
+    }
+}
+
+/// An iterator for a comment's children
+pub struct CommentChildrenIterator {
+    parent: CXComment,
+    length: c_uint,
+    index: c_uint,
+}
+
+impl Iterator for CommentChildrenIterator {
+    type Item = Comment;
+    fn next(&mut self) -> Option<Comment> {
+        if self.index < self.length {
+            let idx = self.index;
+            self.index += 1;
+            Some(Comment {
+                x: unsafe { clang_Comment_getChild(self.parent, idx) },
+            })
+        } else {
+            None
+        }
+    }
+}
+
+/// An HTML start tag comment attribute
+pub struct CommentAttribute {
+    /// HTML start tag attribute name
+    pub name: String,
+    /// HTML start tag attribute value
+    pub value: String,
+}
+
+/// An iterator for a comment's attributes
+pub struct CommentAttributesIterator {
+    x: CXComment,
+    length: c_uint,
+    index: c_uint,
+}
+
+impl Iterator for CommentAttributesIterator {
+    type Item = CommentAttribute;
+    fn next(&mut self) -> Option<CommentAttribute> {
+        if self.index < self.length {
+            let idx = self.index;
+            self.index += 1;
+            Some(CommentAttribute {
+                name: unsafe {
+                    cxstring_into_string(clang_HTMLStartTag_getAttrName(
+                        self.x, idx,
+                    ))
+                },
+                value: unsafe {
+                    cxstring_into_string(clang_HTMLStartTag_getAttrValue(
+                        self.x, idx,
+                    ))
+                },
+            })
+        } else {
+            None
+        }
+    }
+}
+
+/// A source file.
+pub struct File {
+    x: CXFile,
+}
+
+impl File {
+    /// Get the name of this source file.
+    pub fn name(&self) -> Option<String> {
+        if self.x.is_null() {
+            return None;
+        }
+        Some(unsafe { cxstring_into_string(clang_getFileName(self.x)) })
+    }
+}
+
+fn cxstring_to_string_leaky(s: CXString) -> String {
+    if s.data.is_null() {
+        return "".to_owned();
+    }
+    let c_str = unsafe { CStr::from_ptr(clang_getCString(s) as *const _) };
+    c_str.to_string_lossy().into_owned()
+}
+
+fn cxstring_into_string(s: CXString) -> String {
+    let ret = cxstring_to_string_leaky(s);
+    unsafe { clang_disposeString(s) };
+    ret
+}
+
+/// An `Index` is an environment for a set of translation units that will
+/// typically end up linked together in one final binary.
+pub struct Index {
+    x: CXIndex,
+}
+
+impl Index {
+    /// Construct a new `Index`.
+    ///
+    /// The `pch` parameter controls whether declarations in pre-compiled
+    /// headers are included when enumerating a translation unit's "locals".
+    ///
+    /// The `diag` parameter controls whether debugging diagnostics are enabled.
+    pub fn new(pch: bool, diag: bool) -> Index {
+        unsafe {
+            Index {
+                x: clang_createIndex(pch as c_int, diag as c_int),
+            }
+        }
+    }
+}
+
+impl fmt::Debug for Index {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Index {{ }}")
+    }
+}
+
+impl Drop for Index {
+    fn drop(&mut self) {
+        unsafe {
+            clang_disposeIndex(self.x);
+        }
+    }
+}
+
+/// A translation unit (or "compilation unit").
+pub struct TranslationUnit {
+    x: CXTranslationUnit,
+}
+
+impl fmt::Debug for TranslationUnit {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "TranslationUnit {{ }}")
+    }
+}
+
+impl TranslationUnit {
+    /// Parse a source file into a translation unit.
+    pub fn parse(
+        ix: &Index,
+        file: &str,
+        cmd_args: &[String],
+        unsaved: &[UnsavedFile],
+        opts: CXTranslationUnit_Flags,
+    ) -> Option<TranslationUnit> {
+        let fname = CString::new(file).unwrap();
+        let _c_args: Vec<CString> = cmd_args
+            .iter()
+            .map(|s| CString::new(s.clone()).unwrap())
+            .collect();
+        let c_args: Vec<*const c_char> =
+            _c_args.iter().map(|s| s.as_ptr()).collect();
+        let mut c_unsaved: Vec<CXUnsavedFile> =
+            unsaved.iter().map(|f| f.x).collect();
+        let tu = unsafe {
+            clang_parseTranslationUnit(
+                ix.x,
+                fname.as_ptr(),
+                c_args.as_ptr(),
+                c_args.len() as c_int,
+                c_unsaved.as_mut_ptr(),
+                c_unsaved.len() as c_uint,
+                opts,
+            )
+        };
+        if tu.is_null() {
+            None
+        } else {
+            Some(TranslationUnit { x: tu })
+        }
+    }
+
+    /// Get the Clang diagnostic information associated with this translation
+    /// unit.
+    pub fn diags(&self) -> Vec<Diagnostic> {
+        unsafe {
+            let num = clang_getNumDiagnostics(self.x) as usize;
+            let mut diags = vec![];
+            for i in 0..num {
+                diags.push(Diagnostic {
+                    x: clang_getDiagnostic(self.x, i as c_uint),
+                });
+            }
+            diags
+        }
+    }
+
+    /// Get a cursor pointing to the root of this translation unit's AST.
+    pub fn cursor(&self) -> Cursor {
+        unsafe {
+            Cursor {
+                x: clang_getTranslationUnitCursor(self.x),
+            }
+        }
+    }
+
+    /// Is this the null translation unit?
+    pub fn is_null(&self) -> bool {
+        self.x.is_null()
+    }
+}
+
+impl Drop for TranslationUnit {
+    fn drop(&mut self) {
+        unsafe {
+            clang_disposeTranslationUnit(self.x);
+        }
+    }
+}
+
+/// A diagnostic message generated while parsing a translation unit.
+pub struct Diagnostic {
+    x: CXDiagnostic,
+}
+
+impl Diagnostic {
+    /// Format this diagnostic message as a string, using the given option bit
+    /// flags.
+    pub fn format(&self) -> String {
+        unsafe {
+            let opts = clang_defaultDiagnosticDisplayOptions();
+            cxstring_into_string(clang_formatDiagnostic(self.x, opts))
+        }
+    }
+
+    /// What is the severity of this diagnostic message?
+    pub fn severity(&self) -> CXDiagnosticSeverity {
+        unsafe { clang_getDiagnosticSeverity(self.x) }
+    }
+}
+
+impl Drop for Diagnostic {
+    /// Destroy this diagnostic message.
+    fn drop(&mut self) {
+        unsafe {
+            clang_disposeDiagnostic(self.x);
+        }
+    }
+}
+
+/// A file which has not been saved to disk.
+pub struct UnsavedFile {
+    x: CXUnsavedFile,
+    /// The name of the unsaved file. Kept here to avoid leaving dangling pointers in
+    /// `CXUnsavedFile`.
+    pub name: CString,
+    contents: CString,
+}
+
+impl UnsavedFile {
+    /// Construct a new unsaved file with the given `name` and `contents`.
+    pub fn new(name: &str, contents: &str) -> UnsavedFile {
+        let name = CString::new(name).unwrap();
+        let contents = CString::new(contents).unwrap();
+        let x = CXUnsavedFile {
+            Filename: name.as_ptr(),
+            Contents: contents.as_ptr(),
+            Length: contents.as_bytes().len() as c_ulong,
+        };
+        UnsavedFile { x, name, contents }
+    }
+}
+
+impl fmt::Debug for UnsavedFile {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            fmt,
+            "UnsavedFile(name: {:?}, contents: {:?})",
+            self.name, self.contents
+        )
+    }
+}
+
+/// Convert a cursor kind into a static string.
+pub fn kind_to_str(x: CXCursorKind) -> String {
+    unsafe { cxstring_into_string(clang_getCursorKindSpelling(x)) }
+}
+
+/// Convert a type kind to a static string.
+pub fn type_to_str(x: CXTypeKind) -> String {
+    unsafe { cxstring_into_string(clang_getTypeKindSpelling(x)) }
+}
+
+/// Dump the Clang AST to stdout for debugging purposes.
+pub fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
+    fn print_indent<S: AsRef<str>>(depth: isize, s: S) {
+        for _ in 0..depth {
+            print!("    ");
+        }
+        println!("{}", s.as_ref());
+    }
+
+    fn print_cursor<S: AsRef<str>>(depth: isize, prefix: S, c: &Cursor) {
+        let prefix = prefix.as_ref();
+        print_indent(
+            depth,
+            format!(" {}kind = {}", prefix, kind_to_str(c.kind())),
+        );
+        print_indent(
+            depth,
+            format!(" {}spelling = \"{}\"", prefix, c.spelling()),
+        );
+        print_indent(depth, format!(" {}location = {}", prefix, c.location()));
+        print_indent(
+            depth,
+            format!(" {}is-definition? {}", prefix, c.is_definition()),
+        );
+        print_indent(
+            depth,
+            format!(" {}is-declaration? {}", prefix, c.is_declaration()),
+        );
+        print_indent(
+            depth,
+            format!(
+                " {}is-inlined-function? {}",
+                prefix,
+                c.is_inlined_function()
+            ),
+        );
+
+        let templ_kind = c.template_kind();
+        if templ_kind != CXCursor_NoDeclFound {
+            print_indent(
+                depth,
+                format!(
+                    " {}template-kind = {}",
+                    prefix,
+                    kind_to_str(templ_kind)
+                ),
+            );
+        }
+        if let Some(usr) = c.usr() {
+            print_indent(depth, format!(" {}usr = \"{}\"", prefix, usr));
+        }
+        if let Ok(num) = c.num_args() {
+            print_indent(depth, format!(" {}number-of-args = {}", prefix, num));
+        }
+        if let Some(num) = c.num_template_args() {
+            print_indent(
+                depth,
+                format!(" {}number-of-template-args = {}", prefix, num),
+            );
+        }
+
+        if c.is_bit_field() {
+            let width = match c.bit_width() {
+                Some(w) => w.to_string(),
+                None => "<unevaluable>".to_string(),
+            };
+            print_indent(depth, format!(" {}bit-width = {}", prefix, width));
+        }
+
+        if let Some(ty) = c.enum_type() {
+            print_indent(
+                depth,
+                format!(" {}enum-type = {}", prefix, type_to_str(ty.kind())),
+            );
+        }
+        if let Some(val) = c.enum_val_signed() {
+            print_indent(depth, format!(" {}enum-val = {}", prefix, val));
+        }
+        if let Some(ty) = c.typedef_type() {
+            print_indent(
+                depth,
+                format!(" {}typedef-type = {}", prefix, type_to_str(ty.kind())),
+            );
+        }
+        if let Some(ty) = c.ret_type() {
+            print_indent(
+                depth,
+                format!(" {}ret-type = {}", prefix, type_to_str(ty.kind())),
+            );
+        }
+
+        if let Some(refd) = c.referenced() {
+            if refd != *c {
+                println!();
+                print_cursor(
+                    depth,
+                    String::from(prefix) + "referenced.",
+                    &refd,
+                );
+            }
+        }
+
+        let canonical = c.canonical();
+        if canonical != *c {
+            println!();
+            print_cursor(
+                depth,
+                String::from(prefix) + "canonical.",
+                &canonical,
+            );
+        }
+
+        if let Some(specialized) = c.specialized() {
+            if specialized != *c {
+                println!();
+                print_cursor(
+                    depth,
+                    String::from(prefix) + "specialized.",
+                    &specialized,
+                );
+            }
+        }
+
+        if let Some(parent) = c.fallible_semantic_parent() {
+            println!();
+            print_cursor(
+                depth,
+                String::from(prefix) + "semantic-parent.",
+                &parent,
+            );
+        }
+    }
+
+    fn print_type<S: AsRef<str>>(depth: isize, prefix: S, ty: &Type) {
+        let prefix = prefix.as_ref();
+
+        let kind = ty.kind();
+        print_indent(depth, format!(" {}kind = {}", prefix, type_to_str(kind)));
+        if kind == CXType_Invalid {
+            return;
+        }
+
+        print_indent(depth, format!(" {}cconv = {}", prefix, ty.call_conv()));
+
+        print_indent(
+            depth,
+            format!(" {}spelling = \"{}\"", prefix, ty.spelling()),
+        );
+        let num_template_args =
+            unsafe { clang_Type_getNumTemplateArguments(ty.x) };
+        if num_template_args >= 0 {
+            print_indent(
+                depth,
+                format!(
+                    " {}number-of-template-args = {}",
+                    prefix, num_template_args
+                ),
+            );
+        }
+        if let Some(num) = ty.num_elements() {
+            print_indent(
+                depth,
+                format!(" {}number-of-elements = {}", prefix, num),
+            );
+        }
+        print_indent(
+            depth,
+            format!(" {}is-variadic? {}", prefix, ty.is_variadic()),
+        );
+
+        let canonical = ty.canonical_type();
+        if canonical != *ty {
+            println!();
+            print_type(depth, String::from(prefix) + "canonical.", &canonical);
+        }
+
+        if let Some(pointee) = ty.pointee_type() {
+            if pointee != *ty {
+                println!();
+                print_type(depth, String::from(prefix) + "pointee.", &pointee);
+            }
+        }
+
+        if let Some(elem) = ty.elem_type() {
+            if elem != *ty {
+                println!();
+                print_type(depth, String::from(prefix) + "elements.", &elem);
+            }
+        }
+
+        if let Some(ret) = ty.ret_type() {
+            if ret != *ty {
+                println!();
+                print_type(depth, String::from(prefix) + "return.", &ret);
+            }
+        }
+
+        let named = ty.named();
+        if named != *ty && named.is_valid() {
+            println!();
+            print_type(depth, String::from(prefix) + "named.", &named);
+        }
+    }
+
+    print_indent(depth, "(");
+    print_cursor(depth, "", c);
+
+    println!();
+    let ty = c.cur_type();
+    print_type(depth, "type.", &ty);
+
+    let declaration = ty.declaration();
+    if declaration != *c && declaration.kind() != CXCursor_NoDeclFound {
+        println!();
+        print_cursor(depth, "type.declaration.", &declaration);
+    }
+
+    // Recurse.
+    let mut found_children = false;
+    c.visit(|s| {
+        if !found_children {
+            println!();
+            found_children = true;
+        }
+        ast_dump(&s, depth + 1)
+    });
+
+    print_indent(depth, ")");
+
+    CXChildVisit_Continue
+}
+
+/// Try to extract the clang version to a string
+pub fn extract_clang_version() -> String {
+    unsafe { cxstring_into_string(clang_getClangVersion()) }
+}
+
+/// A wrapper for the result of evaluating an expression.
+#[derive(Debug)]
+pub struct EvalResult {
+    x: CXEvalResult,
+}
+
+impl EvalResult {
+    /// Evaluate `cursor` and return the result.
+    pub fn new(cursor: Cursor) -> Option<Self> {
+        // Work around https://bugs.llvm.org/show_bug.cgi?id=42532, see:
+        //  * https://github.com/rust-lang/rust-bindgen/issues/283
+        //  * https://github.com/rust-lang/rust-bindgen/issues/1590
+        {
+            let mut found_cant_eval = false;
+            cursor.visit(|c| {
+                if c.kind() == CXCursor_TypeRef &&
+                    c.cur_type().canonical_type().kind() == CXType_Unexposed
+                {
+                    found_cant_eval = true;
+                    return CXChildVisit_Break;
+                }
+
+                CXChildVisit_Recurse
+            });
+
+            if found_cant_eval {
+                return None;
+            }
+        }
+        Some(EvalResult {
+            x: unsafe { clang_Cursor_Evaluate(cursor.x) },
+        })
+    }
+
+    fn kind(&self) -> CXEvalResultKind {
+        unsafe { clang_EvalResult_getKind(self.x) }
+    }
+
+    /// Try to get back the result as a double.
+    pub fn as_double(&self) -> Option<f64> {
+        match self.kind() {
+            CXEval_Float => {
+                Some(unsafe { clang_EvalResult_getAsDouble(self.x) } as f64)
+            }
+            _ => None,
+        }
+    }
+
+    /// Try to get back the result as an integer.
+    pub fn as_int(&self) -> Option<i64> {
+        if self.kind() != CXEval_Int {
+            return None;
+        }
+
+        if unsafe { clang_EvalResult_isUnsignedInt(self.x) } != 0 {
+            let value = unsafe { clang_EvalResult_getAsUnsigned(self.x) };
+            if value > i64::max_value() as c_ulonglong {
+                return None;
+            }
+
+            return Some(value as i64);
+        }
+
+        let value = unsafe { clang_EvalResult_getAsLongLong(self.x) };
+        if value > i64::max_value() as c_longlong {
+            return None;
+        }
+        if value < i64::min_value() as c_longlong {
+            return None;
+        }
+        Some(value as i64)
+    }
+
+    /// Evaluates the expression as a literal string, that may or may not be
+    /// valid utf-8.
+    pub fn as_literal_string(&self) -> Option<Vec<u8>> {
+        match self.kind() {
+            CXEval_StrLiteral => {
+                let ret = unsafe {
+                    CStr::from_ptr(clang_EvalResult_getAsStr(self.x))
+                };
+                Some(ret.to_bytes().to_vec())
+            }
+            _ => None,
+        }
+    }
+}
+
+impl Drop for EvalResult {
+    fn drop(&mut self) {
+        unsafe { clang_EvalResult_dispose(self.x) };
+    }
+}
+
+/// Target information obtained from libclang.
+#[derive(Debug)]
+pub struct TargetInfo {
+    /// The target triple.
+    pub triple: String,
+    /// The width of the pointer _in bits_.
+    pub pointer_width: usize,
+}
+
+impl TargetInfo {
+    /// Tries to obtain target information from libclang.
+    pub fn new(tu: &TranslationUnit) -> Self {
+        let triple;
+        let pointer_width;
+        unsafe {
+            let ti = clang_getTranslationUnitTargetInfo(tu.x);
+            triple = cxstring_into_string(clang_TargetInfo_getTriple(ti));
+            pointer_width = clang_TargetInfo_getPointerWidth(ti);
+            clang_TargetInfo_dispose(ti);
+        }
+        assert!(pointer_width > 0);
+        assert_eq!(pointer_width % 8, 0);
+        TargetInfo {
+            triple,
+            pointer_width: pointer_width as usize,
+        }
+    }
+}
diff --git a/bindgen/codegen/bitfield_unit.rs b/bindgen/codegen/bitfield_unit.rs
new file mode 100644
index 00000000..73ec2bd6
--- /dev/null
+++ b/bindgen/codegen/bitfield_unit.rs
@@ -0,0 +1,102 @@
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+    storage: Storage,
+}
+
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage }
+    }
+}
+
+impl<Storage> __BindgenBitfieldUnit<Storage>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+
+        let mask = 1 << bit_index;
+
+        byte & mask == mask
+    }
+
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+
+        let mut val = 0;
+
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+
+        val
+    }
+
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!(
+            (bit_offset + (bit_width as usize)) / 8 <=
+                self.storage.as_ref().len()
+        );
+
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
diff --git a/bindgen/codegen/bitfield_unit_tests.rs b/bindgen/codegen/bitfield_unit_tests.rs
new file mode 100644
index 00000000..e143e4ea
--- /dev/null
+++ b/bindgen/codegen/bitfield_unit_tests.rs
@@ -0,0 +1,260 @@
+//! Tests for `__BindgenBitfieldUnit`.
+//!
+//! Note that bit-fields are allocated right to left (least to most significant
+//! bits).
+//!
+//! From the x86 PS ABI:
+//!
+//! ```c
+//! struct {
+//!     int j : 5;
+//!     int k : 6;
+//!     int m : 7;
+//! };
+//! ```
+//!
+//! ```ignore
+//! +------------------------------------------------------------+
+//! |                     |              |            |          |
+//! |       padding       |       m      |     k      |    j     |
+//! |31                 18|17          11|10         5|4        0|
+//! +------------------------------------------------------------+
+//! ```
+
+use super::bitfield_unit::__BindgenBitfieldUnit;
+
+#[test]
+fn bitfield_unit_get_bit() {
+    let unit = __BindgenBitfieldUnit::<[u8; 2]>::new([0b10011101, 0b00011101]);
+
+    let mut bits = vec![];
+    for i in 0..16 {
+        bits.push(unit.get_bit(i));
+    }
+
+    println!();
+    println!("bits = {:?}", bits);
+    assert_eq!(
+        bits,
+        &[
+            // 0b10011101
+            true, false, true, true, true, false, false, true,
+            // 0b00011101
+            true, false, true, true, true, false, false, false
+        ]
+    );
+}
+
+#[test]
+fn bitfield_unit_set_bit() {
+    let mut unit =
+        __BindgenBitfieldUnit::<[u8; 2]>::new([0b00000000, 0b00000000]);
+
+    for i in 0..16 {
+        if i % 3 == 0 {
+            unit.set_bit(i, true);
+        }
+    }
+
+    for i in 0..16 {
+        assert_eq!(unit.get_bit(i), i % 3 == 0);
+    }
+
+    let mut unit =
+        __BindgenBitfieldUnit::<[u8; 2]>::new([0b11111111, 0b11111111]);
+
+    for i in 0..16 {
+        if i % 3 == 0 {
+            unit.set_bit(i, false);
+        }
+    }
+
+    for i in 0..16 {
+        assert_eq!(unit.get_bit(i), i % 3 != 0);
+    }
+}
+
+macro_rules! bitfield_unit_get {
+    (
+        $(
+            With $storage:expr , then get($start:expr, $len:expr) is $expected:expr;
+        )*
+    ) => {
+        #[test]
+        fn bitfield_unit_get() {
+            $({
+                let expected = $expected;
+                let unit = __BindgenBitfieldUnit::<_>::new($storage);
+                let actual = unit.get($start, $len);
+
+                println!();
+                println!("expected = {:064b}", expected);
+                println!("actual   = {:064b}", actual);
+
+                assert_eq!(expected, actual);
+            })*
+        }
+   }
+}
+
+bitfield_unit_get! {
+    // Let's just exhaustively test getting the bits from a single byte, since
+    // there are few enough combinations...
+
+    With [0b11100010], then get(0, 1) is 0;
+    With [0b11100010], then get(1, 1) is 1;
+    With [0b11100010], then get(2, 1) is 0;
+    With [0b11100010], then get(3, 1) is 0;
+    With [0b11100010], then get(4, 1) is 0;
+    With [0b11100010], then get(5, 1) is 1;
+    With [0b11100010], then get(6, 1) is 1;
+    With [0b11100010], then get(7, 1) is 1;
+
+    With [0b11100010], then get(0, 2) is 0b10;
+    With [0b11100010], then get(1, 2) is 0b01;
+    With [0b11100010], then get(2, 2) is 0b00;
+    With [0b11100010], then get(3, 2) is 0b00;
+    With [0b11100010], then get(4, 2) is 0b10;
+    With [0b11100010], then get(5, 2) is 0b11;
+    With [0b11100010], then get(6, 2) is 0b11;
+
+    With [0b11100010], then get(0, 3) is 0b010;
+    With [0b11100010], then get(1, 3) is 0b001;
+    With [0b11100010], then get(2, 3) is 0b000;
+    With [0b11100010], then get(3, 3) is 0b100;
+    With [0b11100010], then get(4, 3) is 0b110;
+    With [0b11100010], then get(5, 3) is 0b111;
+
+    With [0b11100010], then get(0, 4) is 0b0010;
+    With [0b11100010], then get(1, 4) is 0b0001;
+    With [0b11100010], then get(2, 4) is 0b1000;
+    With [0b11100010], then get(3, 4) is 0b1100;
+    With [0b11100010], then get(4, 4) is 0b1110;
+
+    With [0b11100010], then get(0, 5) is 0b00010;
+    With [0b11100010], then get(1, 5) is 0b10001;
+    With [0b11100010], then get(2, 5) is 0b11000;
+    With [0b11100010], then get(3, 5) is 0b11100;
+
+    With [0b11100010], then get(0, 6) is 0b100010;
+    With [0b11100010], then get(1, 6) is 0b110001;
+    With [0b11100010], then get(2, 6) is 0b111000;
+
+    With [0b11100010], then get(0, 7) is 0b1100010;
+    With [0b11100010], then get(1, 7) is 0b1110001;
+
+    With [0b11100010], then get(0, 8) is 0b11100010;
+
+    // OK. Now let's test getting bits from across byte boundaries.
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(0, 16) is 0b1111111101010101;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(1, 16) is 0b0111111110101010;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(2, 16) is 0b0011111111010101;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(3, 16) is 0b0001111111101010;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(4, 16) is 0b0000111111110101;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(5, 16) is 0b0000011111111010;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(6, 16) is 0b0000001111111101;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(7, 16) is 0b0000000111111110;
+
+    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
+    then get(8, 16) is 0b0000000011111111;
+}
+
+macro_rules! bitfield_unit_set {
+    (
+        $(
+            set($start:expr, $len:expr, $val:expr) is $expected:expr;
+        )*
+    ) => {
+        #[test]
+        fn bitfield_unit_set() {
+            $(
+                let mut unit = __BindgenBitfieldUnit::<[u8; 4]>::new([0, 0, 0, 0]);
+                unit.set($start, $len, $val);
+                let actual = unit.get(0, 32);
+
+                println!();
+                println!("set({}, {}, {:032b}", $start, $len, $val);
+                println!("expected = {:064b}", $expected);
+                println!("actual   = {:064b}", actual);
+
+                assert_eq!($expected, actual);
+            )*
+        }
+    }
+}
+
+bitfield_unit_set! {
+    // Once again, let's exhaustively test single byte combinations.
+
+    set(0, 1, 0b11111111) is 0b00000001;
+    set(1, 1, 0b11111111) is 0b00000010;
+    set(2, 1, 0b11111111) is 0b00000100;
+    set(3, 1, 0b11111111) is 0b00001000;
+    set(4, 1, 0b11111111) is 0b00010000;
+    set(5, 1, 0b11111111) is 0b00100000;
+    set(6, 1, 0b11111111) is 0b01000000;
+    set(7, 1, 0b11111111) is 0b10000000;
+
+    set(0, 2, 0b11111111) is 0b00000011;
+    set(1, 2, 0b11111111) is 0b00000110;
+    set(2, 2, 0b11111111) is 0b00001100;
+    set(3, 2, 0b11111111) is 0b00011000;
+    set(4, 2, 0b11111111) is 0b00110000;
+    set(5, 2, 0b11111111) is 0b01100000;
+    set(6, 2, 0b11111111) is 0b11000000;
+
+    set(0, 3, 0b11111111) is 0b00000111;
+    set(1, 3, 0b11111111) is 0b00001110;
+    set(2, 3, 0b11111111) is 0b00011100;
+    set(3, 3, 0b11111111) is 0b00111000;
+    set(4, 3, 0b11111111) is 0b01110000;
+    set(5, 3, 0b11111111) is 0b11100000;
+
+    set(0, 4, 0b11111111) is 0b00001111;
+    set(1, 4, 0b11111111) is 0b00011110;
+    set(2, 4, 0b11111111) is 0b00111100;
+    set(3, 4, 0b11111111) is 0b01111000;
+    set(4, 4, 0b11111111) is 0b11110000;
+
+    set(0, 5, 0b11111111) is 0b00011111;
+    set(1, 5, 0b11111111) is 0b00111110;
+    set(2, 5, 0b11111111) is 0b01111100;
+    set(3, 5, 0b11111111) is 0b11111000;
+
+    set(0, 6, 0b11111111) is 0b00111111;
+    set(1, 6, 0b11111111) is 0b01111110;
+    set(2, 6, 0b11111111) is 0b11111100;
+
+    set(0, 7, 0b11111111) is 0b01111111;
+    set(1, 7, 0b11111111) is 0b11111110;
+
+    set(0, 8, 0b11111111) is 0b11111111;
+
+    // And, now let's cross byte boundaries.
+
+    set(0, 16, 0b1111111111111111) is 0b00000000000000001111111111111111;
+    set(1, 16, 0b1111111111111111) is 0b00000000000000011111111111111110;
+    set(2, 16, 0b1111111111111111) is 0b00000000000000111111111111111100;
+    set(3, 16, 0b1111111111111111) is 0b00000000000001111111111111111000;
+    set(4, 16, 0b1111111111111111) is 0b00000000000011111111111111110000;
+    set(5, 16, 0b1111111111111111) is 0b00000000000111111111111111100000;
+    set(6, 16, 0b1111111111111111) is 0b00000000001111111111111111000000;
+    set(7, 16, 0b1111111111111111) is 0b00000000011111111111111110000000;
+    set(8, 16, 0b1111111111111111) is 0b00000000111111111111111100000000;
+}
diff --git a/bindgen/codegen/dyngen.rs b/bindgen/codegen/dyngen.rs
new file mode 100644
index 00000000..26cfe5cc
--- /dev/null
+++ b/bindgen/codegen/dyngen.rs
@@ -0,0 +1,181 @@
+use crate::codegen;
+use crate::ir::function::Abi;
+use proc_macro2::Ident;
+
+/// Used to build the output tokens for dynamic bindings.
+#[derive(Default)]
+pub struct DynamicItems {
+    /// Tracks the tokens that will appears inside the library struct -- e.g.:
+    /// ```ignore
+    /// struct Lib {
+    ///    __library: ::libloading::Library,
+    ///    pub x: Result<unsafe extern ..., ::libloading::Error>, // <- tracks these
+    ///    ...
+    /// }
+    /// ```
+    struct_members: Vec<proc_macro2::TokenStream>,
+
+    /// Tracks the tokens that will appear inside the library struct's implementation, e.g.:
+    ///
+    /// ```ignore
+    /// impl Lib {
+    ///     ...
+    ///     pub unsafe fn foo(&self, ...) { // <- tracks these
+    ///         ...
+    ///     }
+    /// }
+    /// ```
+    struct_implementation: Vec<proc_macro2::TokenStream>,
+
+    /// Tracks the initialization of the fields inside the `::new` constructor of the library
+    /// struct, e.g.:
+    /// ```ignore
+    /// impl Lib {
+    ///
+    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    ///     where
+    ///         P: AsRef<::std::ffi::OsStr>,
+    ///     {
+    ///         ...
+    ///         let foo = __library.get(...) ...; // <- tracks these
+    ///         ...
+    ///     }
+    ///
+    ///     ...
+    /// }
+    /// ```
+    constructor_inits: Vec<proc_macro2::TokenStream>,
+
+    /// Tracks the information that is passed to the library struct at the end of the `::new`
+    /// constructor, e.g.:
+    /// ```ignore
+    /// impl LibFoo {
+    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    ///     where
+    ///         P: AsRef<::std::ffi::OsStr>,
+    ///     {
+    ///         ...
+    ///         Ok(LibFoo {
+    ///             __library: __library,
+    ///             foo,
+    ///             bar, // <- tracks these
+    ///             ...
+    ///         })
+    ///     }
+    /// }
+    /// ```
+    init_fields: Vec<proc_macro2::TokenStream>,
+}
+
+impl DynamicItems {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn get_tokens(&self, lib_ident: Ident) -> proc_macro2::TokenStream {
+        let struct_members = &self.struct_members;
+        let constructor_inits = &self.constructor_inits;
+        let init_fields = &self.init_fields;
+        let struct_implementation = &self.struct_implementation;
+
+        quote! {
+            extern crate libloading;
+
+            pub struct #lib_ident {
+                __library: ::libloading::Library,
+                #(#struct_members)*
+            }
+
+            impl #lib_ident {
+                pub unsafe fn new<P>(
+                    path: P
+                ) -> Result<Self, ::libloading::Error>
+                where P: AsRef<::std::ffi::OsStr> {
+                    let library = ::libloading::Library::new(path)?;
+                    Self::from_library(library)
+                }
+
+                pub unsafe fn from_library<L>(
+                    library: L
+                ) -> Result<Self, ::libloading::Error>
+                where L: Into<::libloading::Library> {
+                    let __library = library.into();
+                    #( #constructor_inits )*
+                    Ok(#lib_ident {
+                        __library,
+                        #( #init_fields ),*
+                    })
+                }
+
+                #( #struct_implementation )*
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn push(
+        &mut self,
+        ident: Ident,
+        abi: Abi,
+        is_variadic: bool,
+        is_required: bool,
+        args: Vec<proc_macro2::TokenStream>,
+        args_identifiers: Vec<proc_macro2::TokenStream>,
+        ret: proc_macro2::TokenStream,
+        ret_ty: proc_macro2::TokenStream,
+        attributes: Vec<proc_macro2::TokenStream>,
+    ) {
+        if !is_variadic {
+            assert_eq!(args.len(), args_identifiers.len());
+        }
+
+        let signature = quote! { unsafe extern #abi fn ( #( #args),* ) #ret };
+        let member = if is_required {
+            signature
+        } else {
+            quote! { Result<#signature, ::libloading::Error> }
+        };
+
+        self.struct_members.push(quote! {
+            pub #ident: #member,
+        });
+
+        // N.B: If the signature was required, it won't be wrapped in a Result<...>
+        //      and we can simply call it directly.
+        let fn_ = if is_required {
+            quote! { self.#ident }
+        } else {
+            quote! { self.#ident.as_ref().expect("Expected function, got error.") }
+        };
+        let call_body = quote! {
+            (#fn_)(#( #args_identifiers ),*)
+        };
+
+        // We can't implement variadic functions from C easily, so we allow to
+        // access the function pointer so that the user can call it just fine.
+        if !is_variadic {
+            self.struct_implementation.push(quote! {
+                #(#attributes)*
+                pub unsafe fn #ident ( &self, #( #args ),* ) -> #ret_ty {
+                    #call_body
+                }
+            });
+        }
+
+        // N.B: Unwrap the signature upon construction if it is required to be resolved.
+        let ident_str = codegen::helpers::ast_ty::cstr_expr(ident.to_string());
+        self.constructor_inits.push(if is_required {
+            quote! {
+                let #ident = __library.get(#ident_str).map(|sym| *sym)?;
+            }
+        } else {
+            quote! {
+                let #ident = __library.get(#ident_str).map(|sym| *sym);
+            }
+        });
+
+        self.init_fields.push(quote! {
+            #ident
+        });
+    }
+}
diff --git a/bindgen/codegen/error.rs b/bindgen/codegen/error.rs
new file mode 100644
index 00000000..c1bcf4e1
--- /dev/null
+++ b/bindgen/codegen/error.rs
@@ -0,0 +1,33 @@
+use std::error;
+use std::fmt;
+
+/// Errors that can occur during code generation.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Error {
+    /// Tried to generate an opaque blob for a type that did not have a layout.
+    NoLayoutForOpaqueBlob,
+
+    /// Tried to instantiate an opaque template definition, or a template
+    /// definition that is too difficult for us to understand (like a partial
+    /// template specialization).
+    InstantiationOfOpaqueType,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            Error::NoLayoutForOpaqueBlob => {
+                "Tried to generate an opaque blob, but had no layout"
+            }
+            Error::InstantiationOfOpaqueType => {
+                "Instantiation of opaque template type or partial template \
+                 specialization"
+            }
+        })
+    }
+}
+
+impl error::Error for Error {}
+
+/// A `Result` of `T` or an error of `bindgen::codegen::error::Error`.
+pub type Result<T> = ::std::result::Result<T, Error>;
diff --git a/bindgen/codegen/helpers.rs b/bindgen/codegen/helpers.rs
new file mode 100644
index 00000000..5bf36acb
--- /dev/null
+++ b/bindgen/codegen/helpers.rs
@@ -0,0 +1,309 @@
+//! Helpers for code generation that don't need macro expansion.
+
+use crate::ir::context::BindgenContext;
+use crate::ir::layout::Layout;
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::TokenStreamExt;
+
+pub mod attributes {
+    use proc_macro2::{Ident, Span, TokenStream};
+    use std::str::FromStr;
+
+    pub fn repr(which: &str) -> TokenStream {
+        let which = Ident::new(which, Span::call_site());
+        quote! {
+            #[repr( #which )]
+        }
+    }
+
+    pub fn repr_list(which_ones: &[&str]) -> TokenStream {
+        let which_ones = which_ones
+            .iter()
+            .cloned()
+            .map(|one| TokenStream::from_str(one).expect("repr to be valid"));
+        quote! {
+            #[repr( #( #which_ones ),* )]
+        }
+    }
+
+    pub fn derives(which_ones: &[&str]) -> TokenStream {
+        let which_ones = which_ones
+            .iter()
+            .cloned()
+            .map(|one| TokenStream::from_str(one).expect("derive to be valid"));
+        quote! {
+            #[derive( #( #which_ones ),* )]
+        }
+    }
+
+    pub fn inline() -> TokenStream {
+        quote! {
+            #[inline]
+        }
+    }
+
+    pub fn must_use() -> TokenStream {
+        quote! {
+            #[must_use]
+        }
+    }
+
+    pub fn non_exhaustive() -> TokenStream {
+        quote! {
+            #[non_exhaustive]
+        }
+    }
+
+    pub fn doc(comment: String) -> TokenStream {
+        // NOTE(emilio): By this point comments are already preprocessed and in
+        // `///` form. Quote turns them into `#[doc]` comments, but oh well.
+        TokenStream::from_str(&comment).unwrap()
+    }
+
+    pub fn link_name(name: &str) -> TokenStream {
+        // LLVM mangles the name by default but it's already mangled.
+        // Prefixing the name with \u{1} should tell LLVM to not mangle it.
+        let name = format!("\u{1}{}", name);
+        quote! {
+            #[link_name = #name]
+        }
+    }
+}
+
+/// Generates a proper type for a field or type with a given `Layout`, that is,
+/// a type with the correct size and alignment restrictions.
+pub fn blob(ctx: &BindgenContext, layout: Layout) -> TokenStream {
+    let opaque = layout.opaque();
+
+    // FIXME(emilio, #412): We fall back to byte alignment, but there are
+    // some things that legitimately are more than 8-byte aligned.
+    //
+    // Eventually we should be able to `unwrap` here, but...
+    let ty_name = match opaque.known_rust_type_for_array(ctx) {
+        Some(ty) => ty,
+        None => {
+            warn!("Found unknown alignment on code generation!");
+            "u8"
+        }
+    };
+
+    let ty_name = Ident::new(ty_name, Span::call_site());
+
+    let data_len = opaque.array_size(ctx).unwrap_or(layout.size);
+
+    if data_len == 1 {
+        quote! {
+            #ty_name
+        }
+    } else {
+        quote! {
+            [ #ty_name ; #data_len ]
+        }
+    }
+}
+
+/// Integer type of the same size as the given `Layout`.
+pub fn integer_type(
+    ctx: &BindgenContext,
+    layout: Layout,
+) -> Option<TokenStream> {
+    let name = Layout::known_type_for_size(ctx, layout.size)?;
+    let name = Ident::new(name, Span::call_site());
+    Some(quote! { #name })
+}
+
+/// Generates a bitfield allocation unit type for a type with the given `Layout`.
+pub fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> TokenStream {
+    let mut tokens = quote! {};
+
+    if ctx.options().enable_cxx_namespaces {
+        tokens.append_all(quote! { root:: });
+    }
+
+    let size = layout.size;
+    tokens.append_all(quote! {
+        __BindgenBitfieldUnit<[u8; #size]>
+    });
+
+    tokens
+}
+
+pub mod ast_ty {
+    use crate::ir::context::BindgenContext;
+    use crate::ir::function::FunctionSig;
+    use crate::ir::layout::Layout;
+    use crate::ir::ty::FloatKind;
+    use proc_macro2::{self, TokenStream};
+    use std::str::FromStr;
+
+    pub fn c_void(ctx: &BindgenContext) -> TokenStream {
+        // ctypes_prefix takes precedence
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
+                quote! {
+                    #prefix::c_void
+                }
+            }
+            None => {
+                if ctx.options().use_core &&
+                    ctx.options().rust_features.core_ffi_c_void
+                {
+                    quote! { ::core::ffi::c_void }
+                } else {
+                    quote! { ::std::os::raw::c_void }
+                }
+            }
+        }
+    }
+
+    pub fn raw_type(ctx: &BindgenContext, name: &str) -> TokenStream {
+        let ident = ctx.rust_ident_raw(name);
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
+                quote! {
+                    #prefix::#ident
+                }
+            }
+            None => {
+                if ctx.options().use_core &&
+                    ctx.options().rust_features().core_ffi_c
+                {
+                    quote! {
+                        ::core::ffi::#ident
+                    }
+                } else {
+                    quote! {
+                        ::std::os::raw::#ident
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn float_kind_rust_type(
+        ctx: &BindgenContext,
+        fk: FloatKind,
+        layout: Option<Layout>,
+    ) -> TokenStream {
+        // TODO: we probably should take the type layout into account more
+        // often?
+        //
+        // Also, maybe this one shouldn't be the default?
+        match (fk, ctx.options().convert_floats) {
+            (FloatKind::Float, true) => quote! { f32 },
+            (FloatKind::Double, true) => quote! { f64 },
+            (FloatKind::Float, false) => raw_type(ctx, "c_float"),
+            (FloatKind::Double, false) => raw_type(ctx, "c_double"),
+            (FloatKind::LongDouble, _) => {
+                match layout {
+                    Some(layout) => {
+                        match layout.size {
+                            4 => quote! { f32 },
+                            8 => quote! { f64 },
+                            // TODO(emilio): If rust ever gains f128 we should
+                            // use it here and below.
+                            _ => super::integer_type(ctx, layout)
+                                .unwrap_or(quote! { f64 }),
+                        }
+                    }
+                    None => {
+                        debug_assert!(
+                            false,
+                            "How didn't we know the layout for a primitive type?"
+                        );
+                        quote! { f64 }
+                    }
+                }
+            }
+            (FloatKind::Float128, _) => {
+                if ctx.options().rust_features.i128_and_u128 {
+                    quote! { u128 }
+                } else {
+                    quote! { [u64; 2] }
+                }
+            }
+        }
+    }
+
+    pub fn int_expr(val: i64) -> TokenStream {
+        // Don't use quote! { #val } because that adds the type suffix.
+        let val = proc_macro2::Literal::i64_unsuffixed(val);
+        quote!(#val)
+    }
+
+    pub fn uint_expr(val: u64) -> TokenStream {
+        // Don't use quote! { #val } because that adds the type suffix.
+        let val = proc_macro2::Literal::u64_unsuffixed(val);
+        quote!(#val)
+    }
+
+    pub fn byte_array_expr(bytes: &[u8]) -> TokenStream {
+        let mut bytes: Vec<_> = bytes.to_vec();
+        bytes.push(0);
+        quote! { [ #(#bytes),* ] }
+    }
+
+    pub fn cstr_expr(mut string: String) -> TokenStream {
+        string.push('\0');
+        let b = proc_macro2::Literal::byte_string(string.as_bytes());
+        quote! {
+            #b
+        }
+    }
+
+    pub fn float_expr(ctx: &BindgenContext, f: f64) -> Result<TokenStream, ()> {
+        if f.is_finite() {
+            let val = proc_macro2::Literal::f64_unsuffixed(f);
+
+            return Ok(quote!(#val));
+        }
+
+        let prefix = ctx.trait_prefix();
+
+        if f.is_nan() {
+            return Ok(quote! {
+                ::#prefix::f64::NAN
+            });
+        }
+
+        if f.is_infinite() {
+            return Ok(if f.is_sign_positive() {
+                quote! {
+                    ::#prefix::f64::INFINITY
+                }
+            } else {
+                quote! {
+                    ::#prefix::f64::NEG_INFINITY
+                }
+            });
+        }
+
+        warn!("Unknown non-finite float number: {:?}", f);
+        Err(())
+    }
+
+    pub fn arguments_from_signature(
+        signature: &FunctionSig,
+        ctx: &BindgenContext,
+    ) -> Vec<TokenStream> {
+        let mut unnamed_arguments = 0;
+        signature
+            .argument_types()
+            .iter()
+            .map(|&(ref name, _ty)| match *name {
+                Some(ref name) => {
+                    let name = ctx.rust_ident(name);
+                    quote! { #name }
+                }
+                None => {
+                    unnamed_arguments += 1;
+                    let name =
+                        ctx.rust_ident(format!("arg{}", unnamed_arguments));
+                    quote! { #name }
+                }
+            })
+            .collect()
+    }
+}
diff --git a/bindgen/codegen/impl_debug.rs b/bindgen/codegen/impl_debug.rs
new file mode 100644
index 00000000..0e2cd33a
--- /dev/null
+++ b/bindgen/codegen/impl_debug.rs
@@ -0,0 +1,245 @@
+use crate::ir::comp::{BitfieldUnit, CompKind, Field, FieldData, FieldMethods};
+use crate::ir::context::BindgenContext;
+use crate::ir::item::{HasTypeParamInArray, IsOpaque, Item, ItemCanonicalName};
+use crate::ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
+
+pub fn gen_debug_impl(
+    ctx: &BindgenContext,
+    fields: &[Field],
+    item: &Item,
+    kind: CompKind,
+) -> proc_macro2::TokenStream {
+    let struct_name = item.canonical_name(ctx);
+    let mut format_string = format!("{} {{{{ ", struct_name);
+    let mut tokens = vec![];
+
+    if item.is_opaque(ctx, &()) {
+        format_string.push_str("opaque");
+    } else {
+        match kind {
+            CompKind::Union => {
+                format_string.push_str("union");
+            }
+            CompKind::Struct => {
+                let processed_fields = fields.iter().filter_map(|f| match f {
+                    Field::DataMember(ref fd) => fd.impl_debug(ctx, ()),
+                    Field::Bitfields(ref bu) => bu.impl_debug(ctx, ()),
+                });
+
+                for (i, (fstring, toks)) in processed_fields.enumerate() {
+                    if i > 0 {
+                        format_string.push_str(", ");
+                    }
+                    tokens.extend(toks);
+                    format_string.push_str(&fstring);
+                }
+            }
+        }
+    }
+
+    format_string.push_str(" }}");
+    tokens.insert(0, quote! { #format_string });
+
+    let prefix = ctx.trait_prefix();
+
+    quote! {
+        fn fmt(&self, f: &mut ::#prefix::fmt::Formatter<'_>) -> ::#prefix ::fmt::Result {
+            write!(f, #( #tokens ),*)
+        }
+    }
+}
+
+/// A trait for the things which we can codegen tokens that contribute towards a
+/// generated `impl Debug`.
+pub trait ImplDebug<'a> {
+    /// Any extra parameter required by this a particular `ImplDebug` implementation.
+    type Extra;
+
+    /// Generate a format string snippet to be included in the larger `impl Debug`
+    /// format string, and the code to get the format string's interpolation values.
+    fn impl_debug(
+        &self,
+        ctx: &BindgenContext,
+        extra: Self::Extra,
+    ) -> Option<(String, Vec<proc_macro2::TokenStream>)>;
+}
+
+impl<'a> ImplDebug<'a> for FieldData {
+    type Extra = ();
+
+    fn impl_debug(
+        &self,
+        ctx: &BindgenContext,
+        _: Self::Extra,
+    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
+        if let Some(name) = self.name() {
+            ctx.resolve_item(self.ty()).impl_debug(ctx, name)
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a> ImplDebug<'a> for BitfieldUnit {
+    type Extra = ();
+
+    fn impl_debug(
+        &self,
+        ctx: &BindgenContext,
+        _: Self::Extra,
+    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
+        let mut format_string = String::new();
+        let mut tokens = vec![];
+        for (i, bitfield) in self.bitfields().iter().enumerate() {
+            if i > 0 {
+                format_string.push_str(", ");
+            }
+
+            if let Some(bitfield_name) = bitfield.name() {
+                format_string.push_str(&format!("{} : {{:?}}", bitfield_name));
+                let getter_name = bitfield.getter_name();
+                let name_ident = ctx.rust_ident_raw(getter_name);
+                tokens.push(quote! {
+                    self.#name_ident ()
+                });
+            }
+        }
+
+        Some((format_string, tokens))
+    }
+}
+
+impl<'a> ImplDebug<'a> for Item {
+    type Extra = &'a str;
+
+    fn impl_debug(
+        &self,
+        ctx: &BindgenContext,
+        name: &str,
+    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
+        let name_ident = ctx.rust_ident(name);
+
+        // We don't know if blocklisted items `impl Debug` or not, so we can't
+        // add them to the format string we're building up.
+        if !ctx.allowlisted_items().contains(&self.id()) {
+            return None;
+        }
+
+        let ty = match self.as_type() {
+            Some(ty) => ty,
+            None => {
+                return None;
+            }
+        };
+
+        fn debug_print(
+            name: &str,
+            name_ident: proc_macro2::TokenStream,
+        ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
+            Some((
+                format!("{}: {{:?}}", name),
+                vec![quote! {
+                    self.#name_ident
+                }],
+            ))
+        }
+
+        match *ty.kind() {
+            // Handle the simple cases.
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::Reference(..) |
+            TypeKind::UnresolvedTypeRef(..) |
+            TypeKind::ObjCInterface(..) |
+            TypeKind::ObjCId |
+            TypeKind::Comp(..) |
+            TypeKind::ObjCSel => debug_print(name, quote! { #name_ident }),
+
+            TypeKind::TemplateInstantiation(ref inst) => {
+                if inst.is_opaque(ctx, self) {
+                    Some((format!("{}: opaque", name), vec![]))
+                } else {
+                    debug_print(name, quote! { #name_ident })
+                }
+            }
+
+            // The generic is not required to implement Debug, so we can not debug print that type
+            TypeKind::TypeParam => {
+                Some((format!("{}: Non-debuggable generic", name), vec![]))
+            }
+
+            TypeKind::Array(_, len) => {
+                // Generics are not required to implement Debug
+                if self.has_type_param_in_array(ctx) {
+                    Some((
+                        format!("{}: Array with length {}", name, len),
+                        vec![],
+                    ))
+                } else if len < RUST_DERIVE_IN_ARRAY_LIMIT ||
+                    ctx.options().rust_features().larger_arrays
+                {
+                    // The simple case
+                    debug_print(name, quote! { #name_ident })
+                } else if ctx.options().use_core {
+                    // There is no String in core; reducing field visibility to avoid breaking
+                    // no_std setups.
+                    Some((format!("{}: [...]", name), vec![]))
+                } else {
+                    // Let's implement our own print function
+                    Some((
+                        format!("{}: [{{}}]", name),
+                        vec![quote! {
+                            self.#name_ident
+                                .iter()
+                                .enumerate()
+                                .map(|(i, v)| format!("{}{:?}", if i > 0 { ", " } else { "" }, v))
+                                .collect::<String>()
+                        }],
+                    ))
+                }
+            }
+            TypeKind::Vector(_, len) => {
+                if ctx.options().use_core {
+                    // There is no format! in core; reducing field visibility to avoid breaking
+                    // no_std setups.
+                    Some((format!("{}(...)", name), vec![]))
+                } else {
+                    let self_ids = 0..len;
+                    Some((
+                        format!("{}({{}})", name),
+                        vec![quote! {
+                            #(format!("{:?}", self.#self_ids)),*
+                        }],
+                    ))
+                }
+            }
+
+            TypeKind::ResolvedTypeRef(t) |
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::BlockPointer(t) => {
+                // We follow the aliases
+                ctx.resolve_item(t).impl_debug(ctx, name)
+            }
+
+            TypeKind::Pointer(inner) => {
+                let inner_type = ctx.resolve_type(inner).canonical_type(ctx);
+                match *inner_type.kind() {
+                    TypeKind::Function(ref sig)
+                        if !sig.function_pointers_can_derive() =>
+                    {
+                        Some((format!("{}: FunctionPointer", name), vec![]))
+                    }
+                    _ => debug_print(name, quote! { #name_ident }),
+                }
+            }
+
+            TypeKind::Opaque => None,
+        }
+    }
+}
diff --git a/bindgen/codegen/impl_partialeq.rs b/bindgen/codegen/impl_partialeq.rs
new file mode 100644
index 00000000..960306ff
--- /dev/null
+++ b/bindgen/codegen/impl_partialeq.rs
@@ -0,0 +1,142 @@
+use crate::ir::comp::{CompInfo, CompKind, Field, FieldMethods};
+use crate::ir::context::BindgenContext;
+use crate::ir::item::{IsOpaque, Item};
+use crate::ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
+
+/// Generate a manual implementation of `PartialEq` trait for the
+/// specified compound type.
+pub fn gen_partialeq_impl(
+    ctx: &BindgenContext,
+    comp_info: &CompInfo,
+    item: &Item,
+    ty_for_impl: &proc_macro2::TokenStream,
+) -> Option<proc_macro2::TokenStream> {
+    let mut tokens = vec![];
+
+    if item.is_opaque(ctx, &()) {
+        tokens.push(quote! {
+            &self._bindgen_opaque_blob[..] == &other._bindgen_opaque_blob[..]
+        });
+    } else if comp_info.kind() == CompKind::Union {
+        assert!(!ctx.options().rust_features().untagged_union);
+        tokens.push(quote! {
+            &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
+        });
+    } else {
+        for base in comp_info.base_members().iter() {
+            if !base.requires_storage(ctx) {
+                continue;
+            }
+
+            let ty_item = ctx.resolve_item(base.ty);
+            let field_name = &base.field_name;
+
+            if ty_item.is_opaque(ctx, &()) {
+                let field_name = ctx.rust_ident(field_name);
+                tokens.push(quote! {
+                    &self. #field_name [..] == &other. #field_name [..]
+                });
+            } else {
+                tokens.push(gen_field(ctx, ty_item, field_name));
+            }
+        }
+
+        for field in comp_info.fields() {
+            match *field {
+                Field::DataMember(ref fd) => {
+                    let ty_item = ctx.resolve_item(fd.ty());
+                    let name = fd.name().unwrap();
+                    tokens.push(gen_field(ctx, ty_item, name));
+                }
+                Field::Bitfields(ref bu) => {
+                    for bitfield in bu.bitfields() {
+                        if bitfield.name().is_some() {
+                            let getter_name = bitfield.getter_name();
+                            let name_ident = ctx.rust_ident_raw(getter_name);
+                            tokens.push(quote! {
+                                self.#name_ident () == other.#name_ident ()
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Some(quote! {
+        fn eq(&self, other: & #ty_for_impl) -> bool {
+            #( #tokens )&&*
+        }
+    })
+}
+
+fn gen_field(
+    ctx: &BindgenContext,
+    ty_item: &Item,
+    name: &str,
+) -> proc_macro2::TokenStream {
+    fn quote_equals(
+        name_ident: proc_macro2::Ident,
+    ) -> proc_macro2::TokenStream {
+        quote! { self.#name_ident == other.#name_ident }
+    }
+
+    let name_ident = ctx.rust_ident(name);
+    let ty = ty_item.expect_type();
+
+    match *ty.kind() {
+        TypeKind::Void |
+        TypeKind::NullPtr |
+        TypeKind::Int(..) |
+        TypeKind::Complex(..) |
+        TypeKind::Float(..) |
+        TypeKind::Enum(..) |
+        TypeKind::TypeParam |
+        TypeKind::UnresolvedTypeRef(..) |
+        TypeKind::Reference(..) |
+        TypeKind::ObjCInterface(..) |
+        TypeKind::ObjCId |
+        TypeKind::ObjCSel |
+        TypeKind::Comp(..) |
+        TypeKind::Pointer(_) |
+        TypeKind::Function(..) |
+        TypeKind::Opaque => quote_equals(name_ident),
+
+        TypeKind::TemplateInstantiation(ref inst) => {
+            if inst.is_opaque(ctx, ty_item) {
+                quote! {
+                    &self. #name_ident [..] == &other. #name_ident [..]
+                }
+            } else {
+                quote_equals(name_ident)
+            }
+        }
+
+        TypeKind::Array(_, len) => {
+            if len <= RUST_DERIVE_IN_ARRAY_LIMIT ||
+                ctx.options().rust_features().larger_arrays
+            {
+                quote_equals(name_ident)
+            } else {
+                quote! {
+                    &self. #name_ident [..] == &other. #name_ident [..]
+                }
+            }
+        }
+        TypeKind::Vector(_, len) => {
+            let self_ids = 0..len;
+            let other_ids = 0..len;
+            quote! {
+                #(self.#self_ids == other.#other_ids &&)* true
+            }
+        }
+
+        TypeKind::ResolvedTypeRef(t) |
+        TypeKind::TemplateAlias(t, _) |
+        TypeKind::Alias(t) |
+        TypeKind::BlockPointer(t) => {
+            let inner_item = ctx.resolve_item(t);
+            gen_field(ctx, inner_item, name)
+        }
+    }
+}
diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs
new file mode 100644
index 00000000..7e0d7aa0
--- /dev/null
+++ b/bindgen/codegen/mod.rs
@@ -0,0 +1,5050 @@
+mod dyngen;
+mod error;
+mod helpers;
+mod impl_debug;
+mod impl_partialeq;
+mod postprocessing;
+pub mod struct_layout;
+
+#[cfg(test)]
+#[allow(warnings)]
+pub(crate) mod bitfield_unit;
+#[cfg(all(test, target_endian = "little"))]
+mod bitfield_unit_tests;
+
+use self::dyngen::DynamicItems;
+use self::helpers::attributes;
+use self::struct_layout::StructLayoutTracker;
+
+use super::BindgenOptions;
+
+use crate::ir::analysis::{HasVtable, Sizedness};
+use crate::ir::annotations::FieldAccessorKind;
+use crate::ir::comment;
+use crate::ir::comp::{
+    Bitfield, BitfieldUnit, CompInfo, CompKind, Field, FieldData, FieldMethods,
+    Method, MethodKind,
+};
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::derive::{
+    CanDerive, CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
+    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
+};
+use crate::ir::dot;
+use crate::ir::enum_ty::{Enum, EnumVariant, EnumVariantValue};
+use crate::ir::function::{Abi, Function, FunctionKind, FunctionSig, Linkage};
+use crate::ir::int::IntKind;
+use crate::ir::item::{IsOpaque, Item, ItemCanonicalName, ItemCanonicalPath};
+use crate::ir::item_kind::ItemKind;
+use crate::ir::layout::Layout;
+use crate::ir::module::Module;
+use crate::ir::objc::{ObjCInterface, ObjCMethod};
+use crate::ir::template::{
+    AsTemplateParam, TemplateInstantiation, TemplateParameters,
+};
+use crate::ir::ty::{Type, TypeKind};
+use crate::ir::var::Var;
+
+use proc_macro2::{self, Ident, Span};
+use quote::TokenStreamExt;
+
+use crate::{Entry, HashMap, HashSet};
+use std::borrow::Cow;
+use std::cell::Cell;
+use std::collections::VecDeque;
+use std::fmt::Write;
+use std::iter;
+use std::ops;
+use std::str::FromStr;
+
+// Name of type defined in constified enum module
+pub static CONSTIFIED_ENUM_MODULE_REPR_NAME: &str = "Type";
+
+fn top_level_path(
+    ctx: &BindgenContext,
+    item: &Item,
+) -> Vec<proc_macro2::TokenStream> {
+    let mut path = vec![quote! { self }];
+
+    if ctx.options().enable_cxx_namespaces {
+        for _ in 0..item.codegen_depth(ctx) {
+            path.push(quote! { super });
+        }
+    }
+
+    path
+}
+
+fn root_import(
+    ctx: &BindgenContext,
+    module: &Item,
+) -> proc_macro2::TokenStream {
+    assert!(ctx.options().enable_cxx_namespaces, "Somebody messed it up");
+    assert!(module.is_module());
+
+    let mut path = top_level_path(ctx, module);
+
+    let root = ctx.root_module().canonical_name(ctx);
+    let root_ident = ctx.rust_ident(&root);
+    path.push(quote! { #root_ident });
+
+    let mut tokens = quote! {};
+    tokens.append_separated(path, quote!(::));
+
+    quote! {
+        #[allow(unused_imports)]
+        use #tokens ;
+    }
+}
+
+bitflags! {
+    struct DerivableTraits: u16 {
+        const DEBUG       = 1 << 0;
+        const DEFAULT     = 1 << 1;
+        const COPY        = 1 << 2;
+        const CLONE       = 1 << 3;
+        const HASH        = 1 << 4;
+        const PARTIAL_ORD = 1 << 5;
+        const ORD         = 1 << 6;
+        const PARTIAL_EQ  = 1 << 7;
+        const EQ          = 1 << 8;
+    }
+}
+
+fn derives_of_item(
+    item: &Item,
+    ctx: &BindgenContext,
+    packed: bool,
+) -> DerivableTraits {
+    let mut derivable_traits = DerivableTraits::empty();
+
+    let all_template_params = item.all_template_params(ctx);
+
+    if item.can_derive_copy(ctx) && !item.annotations().disallow_copy() {
+        derivable_traits |= DerivableTraits::COPY;
+
+        if ctx.options().rust_features().builtin_clone_impls ||
+            !all_template_params.is_empty()
+        {
+            // FIXME: This requires extra logic if you have a big array in a
+            // templated struct. The reason for this is that the magic:
+            //     fn clone(&self) -> Self { *self }
+            // doesn't work for templates.
+            //
+            // It's not hard to fix though.
+            derivable_traits |= DerivableTraits::CLONE;
+        }
+    } else if packed {
+        // If the struct or union is packed, deriving from Copy is required for
+        // deriving from any other trait.
+        return derivable_traits;
+    }
+
+    if item.can_derive_debug(ctx) && !item.annotations().disallow_debug() {
+        derivable_traits |= DerivableTraits::DEBUG;
+    }
+
+    if item.can_derive_default(ctx) && !item.annotations().disallow_default() {
+        derivable_traits |= DerivableTraits::DEFAULT;
+    }
+
+    if item.can_derive_hash(ctx) {
+        derivable_traits |= DerivableTraits::HASH;
+    }
+
+    if item.can_derive_partialord(ctx) {
+        derivable_traits |= DerivableTraits::PARTIAL_ORD;
+    }
+
+    if item.can_derive_ord(ctx) {
+        derivable_traits |= DerivableTraits::ORD;
+    }
+
+    if item.can_derive_partialeq(ctx) {
+        derivable_traits |= DerivableTraits::PARTIAL_EQ;
+    }
+
+    if item.can_derive_eq(ctx) {
+        derivable_traits |= DerivableTraits::EQ;
+    }
+
+    derivable_traits
+}
+
+impl From<DerivableTraits> for Vec<&'static str> {
+    fn from(derivable_traits: DerivableTraits) -> Vec<&'static str> {
+        [
+            (DerivableTraits::DEBUG, "Debug"),
+            (DerivableTraits::DEFAULT, "Default"),
+            (DerivableTraits::COPY, "Copy"),
+            (DerivableTraits::CLONE, "Clone"),
+            (DerivableTraits::HASH, "Hash"),
+            (DerivableTraits::PARTIAL_ORD, "PartialOrd"),
+            (DerivableTraits::ORD, "Ord"),
+            (DerivableTraits::PARTIAL_EQ, "PartialEq"),
+            (DerivableTraits::EQ, "Eq"),
+        ]
+        .iter()
+        .filter_map(|&(flag, derive)| {
+            Some(derive).filter(|_| derivable_traits.contains(flag))
+        })
+        .collect()
+    }
+}
+
+struct CodegenResult<'a> {
+    items: Vec<proc_macro2::TokenStream>,
+    dynamic_items: DynamicItems,
+
+    /// A monotonic counter used to add stable unique id's to stuff that doesn't
+    /// need to be referenced by anything.
+    codegen_id: &'a Cell<usize>,
+
+    /// Whether a bindgen union has been generated at least once.
+    saw_bindgen_union: bool,
+
+    /// Whether an incomplete array has been generated at least once.
+    saw_incomplete_array: bool,
+
+    /// Whether Objective C types have been seen at least once.
+    saw_objc: bool,
+
+    /// Whether Apple block types have been seen at least once.
+    saw_block: bool,
+
+    /// Whether a bitfield allocation unit has been seen at least once.
+    saw_bitfield_unit: bool,
+
+    items_seen: HashSet<ItemId>,
+    /// The set of generated function/var names, needed because in C/C++ is
+    /// legal to do something like:
+    ///
+    /// ```c++
+    /// extern "C" {
+    ///   void foo();
+    ///   extern int bar;
+    /// }
+    ///
+    /// extern "C" {
+    ///   void foo();
+    ///   extern int bar;
+    /// }
+    /// ```
+    ///
+    /// Being these two different declarations.
+    functions_seen: HashSet<String>,
+    vars_seen: HashSet<String>,
+
+    /// Used for making bindings to overloaded functions. Maps from a canonical
+    /// function name to the number of overloads we have already codegen'd for
+    /// that name. This lets us give each overload a unique suffix.
+    overload_counters: HashMap<String, u32>,
+}
+
+impl<'a> CodegenResult<'a> {
+    fn new(codegen_id: &'a Cell<usize>) -> Self {
+        CodegenResult {
+            items: vec![],
+            dynamic_items: DynamicItems::new(),
+            saw_bindgen_union: false,
+            saw_incomplete_array: false,
+            saw_objc: false,
+            saw_block: false,
+            saw_bitfield_unit: false,
+            codegen_id,
+            items_seen: Default::default(),
+            functions_seen: Default::default(),
+            vars_seen: Default::default(),
+            overload_counters: Default::default(),
+        }
+    }
+
+    fn dynamic_items(&mut self) -> &mut DynamicItems {
+        &mut self.dynamic_items
+    }
+
+    fn saw_bindgen_union(&mut self) {
+        self.saw_bindgen_union = true;
+    }
+
+    fn saw_incomplete_array(&mut self) {
+        self.saw_incomplete_array = true;
+    }
+
+    fn saw_objc(&mut self) {
+        self.saw_objc = true;
+    }
+
+    fn saw_block(&mut self) {
+        self.saw_block = true;
+    }
+
+    fn saw_bitfield_unit(&mut self) {
+        self.saw_bitfield_unit = true;
+    }
+
+    fn seen<Id: Into<ItemId>>(&self, item: Id) -> bool {
+        self.items_seen.contains(&item.into())
+    }
+
+    fn set_seen<Id: Into<ItemId>>(&mut self, item: Id) {
+        self.items_seen.insert(item.into());
+    }
+
+    fn seen_function(&self, name: &str) -> bool {
+        self.functions_seen.contains(name)
+    }
+
+    fn saw_function(&mut self, name: &str) {
+        self.functions_seen.insert(name.into());
+    }
+
+    /// Get the overload number for the given function name. Increments the
+    /// counter internally so the next time we ask for the overload for this
+    /// name, we get the incremented value, and so on.
+    fn overload_number(&mut self, name: &str) -> u32 {
+        let counter = self.overload_counters.entry(name.into()).or_insert(0);
+        let number = *counter;
+        *counter += 1;
+        number
+    }
+
+    fn seen_var(&self, name: &str) -> bool {
+        self.vars_seen.contains(name)
+    }
+
+    fn saw_var(&mut self, name: &str) {
+        self.vars_seen.insert(name.into());
+    }
+
+    fn inner<F>(&mut self, cb: F) -> Vec<proc_macro2::TokenStream>
+    where
+        F: FnOnce(&mut Self),
+    {
+        let mut new = Self::new(self.codegen_id);
+
+        cb(&mut new);
+
+        self.saw_incomplete_array |= new.saw_incomplete_array;
+        self.saw_objc |= new.saw_objc;
+        self.saw_block |= new.saw_block;
+        self.saw_bitfield_unit |= new.saw_bitfield_unit;
+        self.saw_bindgen_union |= new.saw_bindgen_union;
+
+        new.items
+    }
+}
+
+impl<'a> ops::Deref for CodegenResult<'a> {
+    type Target = Vec<proc_macro2::TokenStream>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.items
+    }
+}
+
+impl<'a> ops::DerefMut for CodegenResult<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.items
+    }
+}
+
+/// A trait to convert a rust type into a pointer, optionally const, to the same
+/// type.
+trait ToPtr {
+    fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream;
+}
+
+impl ToPtr for proc_macro2::TokenStream {
+    fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream {
+        if is_const {
+            quote! { *const #self }
+        } else {
+            quote! { *mut #self }
+        }
+    }
+}
+
+/// An extension trait for `proc_macro2::TokenStream` that lets us append any implicit
+/// template parameters that exist for some type, if necessary.
+trait AppendImplicitTemplateParams {
+    fn append_implicit_template_params(
+        &mut self,
+        ctx: &BindgenContext,
+        item: &Item,
+    );
+}
+
+impl AppendImplicitTemplateParams for proc_macro2::TokenStream {
+    fn append_implicit_template_params(
+        &mut self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) {
+        let item = item.id().into_resolver().through_type_refs().resolve(ctx);
+
+        match *item.expect_type().kind() {
+            TypeKind::UnresolvedTypeRef(..) => {
+                unreachable!("already resolved unresolved type refs")
+            }
+            TypeKind::ResolvedTypeRef(..) => {
+                unreachable!("we resolved item through type refs")
+            }
+
+            // None of these types ever have implicit template parameters.
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Pointer(..) |
+            TypeKind::Reference(..) |
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Array(..) |
+            TypeKind::TypeParam |
+            TypeKind::Opaque |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel |
+            TypeKind::TemplateInstantiation(..) => return,
+            _ => {}
+        }
+
+        let params: Vec<_> = item
+            .used_template_params(ctx)
+            .iter()
+            .map(|p| {
+                p.try_to_rust_ty(ctx, &())
+                    .expect("template params cannot fail to be a rust type")
+            })
+            .collect();
+        if !params.is_empty() {
+            self.append_all(quote! {
+                < #( #params ),* >
+            });
+        }
+    }
+}
+
+trait CodeGenerator {
+    /// Extra information from the caller.
+    type Extra;
+
+    /// Extra information returned to the caller.
+    type Return;
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        extra: &Self::Extra,
+    ) -> Self::Return;
+}
+
+impl Item {
+    fn process_before_codegen(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult,
+    ) -> bool {
+        if !self.is_enabled_for_codegen(ctx) {
+            return false;
+        }
+
+        if self.is_blocklisted(ctx) || result.seen(self.id()) {
+            debug!(
+                "<Item as CodeGenerator>::process_before_codegen: Ignoring hidden or seen: \
+                 self = {:?}",
+                self
+            );
+            return false;
+        }
+
+        if !ctx.codegen_items().contains(&self.id()) {
+            // TODO(emilio, #453): Figure out what to do when this happens
+            // legitimately, we could track the opaque stuff and disable the
+            // assertion there I guess.
+            warn!("Found non-allowlisted item in code generation: {:?}", self);
+        }
+
+        result.set_seen(self.id());
+        true
+    }
+}
+
+impl CodeGenerator for Item {
+    type Extra = ();
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        _extra: &(),
+    ) {
+        debug!("<Item as CodeGenerator>::codegen: self = {:?}", self);
+        if !self.process_before_codegen(ctx, result) {
+            return;
+        }
+
+        match *self.kind() {
+            ItemKind::Module(ref module) => {
+                module.codegen(ctx, result, self);
+            }
+            ItemKind::Function(ref fun) => {
+                fun.codegen(ctx, result, self);
+            }
+            ItemKind::Var(ref var) => {
+                var.codegen(ctx, result, self);
+            }
+            ItemKind::Type(ref ty) => {
+                ty.codegen(ctx, result, self);
+            }
+        }
+    }
+}
+
+impl CodeGenerator for Module {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug!("<Module as CodeGenerator>::codegen: item = {:?}", item);
+
+        let codegen_self = |result: &mut CodegenResult,
+                            found_any: &mut bool| {
+            for child in self.children() {
+                if ctx.codegen_items().contains(child) {
+                    *found_any = true;
+                    ctx.resolve_item(*child).codegen(ctx, result, &());
+                }
+            }
+
+            if item.id() == ctx.root_module() {
+                if result.saw_block {
+                    utils::prepend_block_header(ctx, &mut *result);
+                }
+                if result.saw_bindgen_union {
+                    utils::prepend_union_types(ctx, &mut *result);
+                }
+                if result.saw_incomplete_array {
+                    utils::prepend_incomplete_array_types(ctx, &mut *result);
+                }
+                if ctx.need_bindgen_complex_type() {
+                    utils::prepend_complex_type(&mut *result);
+                }
+                if result.saw_objc {
+                    utils::prepend_objc_header(ctx, &mut *result);
+                }
+                if result.saw_bitfield_unit {
+                    utils::prepend_bitfield_unit_type(ctx, &mut *result);
+                }
+            }
+        };
+
+        if !ctx.options().enable_cxx_namespaces ||
+            (self.is_inline() &&
+                !ctx.options().conservative_inline_namespaces)
+        {
+            codegen_self(result, &mut false);
+            return;
+        }
+
+        let mut found_any = false;
+        let inner_items = result.inner(|result| {
+            result.push(root_import(ctx, item));
+
+            let path = item.namespace_aware_canonical_path(ctx).join("::");
+            if let Some(raw_lines) = ctx.options().module_lines.get(&path) {
+                for raw_line in raw_lines {
+                    found_any = true;
+                    result.push(
+                        proc_macro2::TokenStream::from_str(raw_line).unwrap(),
+                    );
+                }
+            }
+
+            codegen_self(result, &mut found_any);
+        });
+
+        // Don't bother creating an empty module.
+        if !found_any {
+            return;
+        }
+
+        let name = item.canonical_name(ctx);
+        let ident = ctx.rust_ident(name);
+        result.push(if item.id() == ctx.root_module() {
+            quote! {
+                #[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+                pub mod #ident {
+                    #( #inner_items )*
+                }
+            }
+        } else {
+            quote! {
+                pub mod #ident {
+                    #( #inner_items )*
+                }
+            }
+        });
+    }
+}
+
+impl CodeGenerator for Var {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        use crate::ir::var::VarType;
+        debug!("<Var as CodeGenerator>::codegen: item = {:?}", item);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        let canonical_name = item.canonical_name(ctx);
+
+        if result.seen_var(&canonical_name) {
+            return;
+        }
+        result.saw_var(&canonical_name);
+
+        let canonical_ident = ctx.rust_ident(&canonical_name);
+
+        // We can't generate bindings to static variables of templates. The
+        // number of actual variables for a single declaration are open ended
+        // and we don't know what instantiations do or don't exist.
+        if !item.all_template_params(ctx).is_empty() {
+            return;
+        }
+
+        let mut attrs = vec![];
+        if let Some(comment) = item.comment(ctx) {
+            attrs.push(attributes::doc(comment));
+        }
+
+        let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
+
+        if let Some(val) = self.val() {
+            match *val {
+                VarType::Bool(val) => {
+                    result.push(quote! {
+                        #(#attrs)*
+                        pub const #canonical_ident : #ty = #val ;
+                    });
+                }
+                VarType::Int(val) => {
+                    let int_kind = self
+                        .ty()
+                        .into_resolver()
+                        .through_type_aliases()
+                        .through_type_refs()
+                        .resolve(ctx)
+                        .expect_type()
+                        .as_integer()
+                        .unwrap();
+                    let val = if int_kind.is_signed() {
+                        helpers::ast_ty::int_expr(val)
+                    } else {
+                        helpers::ast_ty::uint_expr(val as _)
+                    };
+                    result.push(quote! {
+                        #(#attrs)*
+                        pub const #canonical_ident : #ty = #val ;
+                    });
+                }
+                VarType::String(ref bytes) => {
+                    // Account the trailing zero.
+                    //
+                    // TODO: Here we ignore the type we just made up, probably
+                    // we should refactor how the variable type and ty id work.
+                    let len = bytes.len() + 1;
+                    let ty = quote! {
+                        [u8; #len]
+                    };
+
+                    match String::from_utf8(bytes.clone()) {
+                        Ok(string) => {
+                            let cstr = helpers::ast_ty::cstr_expr(string);
+                            if ctx
+                                .options()
+                                .rust_features
+                                .static_lifetime_elision
+                            {
+                                result.push(quote! {
+                                    #(#attrs)*
+                                    pub const #canonical_ident : &#ty = #cstr ;
+                                });
+                            } else {
+                                result.push(quote! {
+                                    #(#attrs)*
+                                    pub const #canonical_ident : &'static #ty = #cstr ;
+                                });
+                            }
+                        }
+                        Err(..) => {
+                            let bytes = helpers::ast_ty::byte_array_expr(bytes);
+                            result.push(quote! {
+                                #(#attrs)*
+                                pub const #canonical_ident : #ty = #bytes ;
+                            });
+                        }
+                    }
+                }
+                VarType::Float(f) => {
+                    if let Ok(expr) = helpers::ast_ty::float_expr(ctx, f) {
+                        result.push(quote! {
+                            #(#attrs)*
+                            pub const #canonical_ident : #ty = #expr ;
+                        });
+                    }
+                }
+                VarType::Char(c) => {
+                    result.push(quote! {
+                        #(#attrs)*
+                        pub const #canonical_ident : #ty = #c ;
+                    });
+                }
+            }
+        } else {
+            // If necessary, apply a `#[link_name]` attribute
+            let link_name = self.mangled_name().unwrap_or_else(|| self.name());
+            if !utils::names_will_be_identical_after_mangling(
+                &canonical_name,
+                link_name,
+                None,
+            ) {
+                attrs.push(attributes::link_name(link_name));
+            }
+
+            let maybe_mut = if self.is_const() {
+                quote! {}
+            } else {
+                quote! { mut }
+            };
+
+            let tokens = quote!(
+                extern "C" {
+                    #(#attrs)*
+                    pub static #maybe_mut #canonical_ident: #ty;
+                }
+            );
+
+            result.push(tokens);
+        }
+    }
+}
+
+impl CodeGenerator for Type {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug!("<Type as CodeGenerator>::codegen: item = {:?}", item);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        match *self.kind() {
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Array(..) |
+            TypeKind::Vector(..) |
+            TypeKind::Pointer(..) |
+            TypeKind::Reference(..) |
+            TypeKind::Function(..) |
+            TypeKind::ResolvedTypeRef(..) |
+            TypeKind::Opaque |
+            TypeKind::TypeParam => {
+                // These items don't need code generation, they only need to be
+                // converted to rust types in fields, arguments, and such.
+                // NOTE(emilio): If you add to this list, make sure to also add
+                // it to BindgenContext::compute_allowlisted_and_codegen_items.
+            }
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.codegen(ctx, result, item)
+            }
+            TypeKind::BlockPointer(inner) => {
+                if !ctx.options().generate_block {
+                    return;
+                }
+
+                let inner_item =
+                    inner.into_resolver().through_type_refs().resolve(ctx);
+                let name = item.canonical_name(ctx);
+
+                let inner_rust_type = {
+                    if let TypeKind::Function(fnsig) =
+                        inner_item.kind().expect_type().kind()
+                    {
+                        utils::fnsig_block(ctx, fnsig)
+                    } else {
+                        panic!("invalid block typedef: {:?}", inner_item)
+                    }
+                };
+
+                let rust_name = ctx.rust_ident(&name);
+
+                let mut tokens = if let Some(comment) = item.comment(ctx) {
+                    attributes::doc(comment)
+                } else {
+                    quote! {}
+                };
+
+                tokens.append_all(quote! {
+                    pub type #rust_name = #inner_rust_type ;
+                });
+
+                result.push(tokens);
+                result.saw_block();
+            }
+            TypeKind::Comp(ref ci) => ci.codegen(ctx, result, item),
+            TypeKind::TemplateAlias(inner, _) | TypeKind::Alias(inner) => {
+                let inner_item =
+                    inner.into_resolver().through_type_refs().resolve(ctx);
+                let name = item.canonical_name(ctx);
+                let path = item.canonical_path(ctx);
+
+                {
+                    let through_type_aliases = inner
+                        .into_resolver()
+                        .through_type_refs()
+                        .through_type_aliases()
+                        .resolve(ctx);
+
+                    // Try to catch the common pattern:
+                    //
+                    // typedef struct foo { ... } foo;
+                    //
+                    // here, and also other more complex cases like #946.
+                    if through_type_aliases.canonical_path(ctx) == path {
+                        return;
+                    }
+                }
+
+                // If this is a known named type, disallow generating anything
+                // for it too. If size_t -> usize conversions are enabled, we
+                // need to check that these conversions are permissible, but
+                // nothing needs to be generated, still.
+                let spelling = self.name().expect("Unnamed alias?");
+                if utils::type_from_named(ctx, spelling).is_some() {
+                    if let "size_t" | "ssize_t" = spelling {
+                        let layout = inner_item
+                            .kind()
+                            .expect_type()
+                            .layout(ctx)
+                            .expect("No layout?");
+                        assert_eq!(
+                            layout.size,
+                            ctx.target_pointer_size(),
+                            "Target platform requires `--no-size_t-is-usize`. The size of `{}` ({}) does not match the target pointer size ({})",
+                            spelling,
+                            layout.size,
+                            ctx.target_pointer_size(),
+                            );
+                        assert_eq!(
+                            layout.align,
+                            ctx.target_pointer_size(),
+                            "Target platform requires `--no-size_t-is-usize`. The alignment of `{}` ({}) does not match the target pointer size ({})",
+                            spelling,
+                            layout.align,
+                            ctx.target_pointer_size(),
+                        );
+                    }
+                    return;
+                }
+
+                let mut outer_params = item.used_template_params(ctx);
+
+                let is_opaque = item.is_opaque(ctx, &());
+                let inner_rust_type = if is_opaque {
+                    outer_params = vec![];
+                    self.to_opaque(ctx, item)
+                } else {
+                    // Its possible that we have better layout information than
+                    // the inner type does, so fall back to an opaque blob based
+                    // on our layout if converting the inner item fails.
+                    let mut inner_ty = inner_item
+                        .try_to_rust_ty_or_opaque(ctx, &())
+                        .unwrap_or_else(|_| self.to_opaque(ctx, item));
+                    inner_ty.append_implicit_template_params(ctx, inner_item);
+                    inner_ty
+                };
+
+                {
+                    // FIXME(emilio): This is a workaround to avoid generating
+                    // incorrect type aliases because of types that we haven't
+                    // been able to resolve (because, eg, they depend on a
+                    // template parameter).
+                    //
+                    // It's kind of a shame not generating them even when they
+                    // could be referenced, but we already do the same for items
+                    // with invalid template parameters, and at least this way
+                    // they can be replaced, instead of generating plain invalid
+                    // code.
+                    let inner_canon_type =
+                        inner_item.expect_type().canonical_type(ctx);
+                    if inner_canon_type.is_invalid_type_param() {
+                        warn!(
+                            "Item contained invalid named type, skipping: \
+                             {:?}, {:?}",
+                            item, inner_item
+                        );
+                        return;
+                    }
+                }
+
+                let rust_name = ctx.rust_ident(&name);
+
+                let mut tokens = if let Some(comment) = item.comment(ctx) {
+                    attributes::doc(comment)
+                } else {
+                    quote! {}
+                };
+
+                let alias_style = if ctx.options().type_alias.matches(&name) {
+                    AliasVariation::TypeAlias
+                } else if ctx.options().new_type_alias.matches(&name) {
+                    AliasVariation::NewType
+                } else if ctx.options().new_type_alias_deref.matches(&name) {
+                    AliasVariation::NewTypeDeref
+                } else {
+                    ctx.options().default_alias_style
+                };
+
+                // We prefer using `pub use` over `pub type` because of:
+                // https://github.com/rust-lang/rust/issues/26264
+                // These are the only characters allowed in simple
+                // paths, eg `good::dogs::Bront`.
+                if inner_rust_type.to_string().chars().all(|c| matches!(c, 'A'..='Z' | 'a'..='z' | '0'..='9' | ':' | '_' | ' ')) && outer_params.is_empty() &&
+                    !is_opaque &&
+                    alias_style == AliasVariation::TypeAlias &&
+                    inner_item.expect_type().canonical_type(ctx).is_enum()
+                {
+                    tokens.append_all(quote! {
+                        pub use
+                    });
+                    let path = top_level_path(ctx, item);
+                    tokens.append_separated(path, quote!(::));
+                    tokens.append_all(quote! {
+                        :: #inner_rust_type  as #rust_name ;
+                    });
+                    result.push(tokens);
+                    return;
+                }
+
+                tokens.append_all(match alias_style {
+                    AliasVariation::TypeAlias => quote! {
+                        pub type #rust_name
+                    },
+                    AliasVariation::NewType | AliasVariation::NewTypeDeref => {
+                        assert!(
+                            ctx.options().rust_features().repr_transparent,
+                            "repr_transparent feature is required to use {:?}",
+                            alias_style
+                        );
+
+                        let mut attributes =
+                            vec![attributes::repr("transparent")];
+                        let packed = false; // Types can't be packed in Rust.
+                        let derivable_traits =
+                            derives_of_item(item, ctx, packed);
+                        if !derivable_traits.is_empty() {
+                            let derives: Vec<_> = derivable_traits.into();
+                            attributes.push(attributes::derives(&derives))
+                        }
+
+                        quote! {
+                            #( #attributes )*
+                            pub struct #rust_name
+                        }
+                    }
+                });
+
+                let params: Vec<_> = outer_params
+                    .into_iter()
+                    .filter_map(|p| p.as_template_param(ctx, &()))
+                    .collect();
+                if params
+                    .iter()
+                    .any(|p| ctx.resolve_type(*p).is_invalid_type_param())
+                {
+                    warn!(
+                        "Item contained invalid template \
+                         parameter: {:?}",
+                        item
+                    );
+                    return;
+                }
+                let params: Vec<_> = params
+                    .iter()
+                    .map(|p| {
+                        p.try_to_rust_ty(ctx, &()).expect(
+                            "type parameters can always convert to rust ty OK",
+                        )
+                    })
+                    .collect();
+
+                if !params.is_empty() {
+                    tokens.append_all(quote! {
+                        < #( #params ),* >
+                    });
+                }
+
+                tokens.append_all(match alias_style {
+                    AliasVariation::TypeAlias => quote! {
+                        = #inner_rust_type ;
+                    },
+                    AliasVariation::NewType | AliasVariation::NewTypeDeref => {
+                        quote! {
+                            (pub #inner_rust_type) ;
+                        }
+                    }
+                });
+
+                if alias_style == AliasVariation::NewTypeDeref {
+                    let prefix = ctx.trait_prefix();
+                    tokens.append_all(quote! {
+                        impl ::#prefix::ops::Deref for #rust_name {
+                            type Target = #inner_rust_type;
+                            #[inline]
+                            fn deref(&self) -> &Self::Target {
+                                &self.0
+                            }
+                        }
+                        impl ::#prefix::ops::DerefMut for #rust_name {
+                            #[inline]
+                            fn deref_mut(&mut self) -> &mut Self::Target {
+                                &mut self.0
+                            }
+                        }
+                    });
+                }
+
+                result.push(tokens);
+            }
+            TypeKind::Enum(ref ei) => ei.codegen(ctx, result, item),
+            TypeKind::ObjCId | TypeKind::ObjCSel => {
+                result.saw_objc();
+            }
+            TypeKind::ObjCInterface(ref interface) => {
+                interface.codegen(ctx, result, item)
+            }
+            ref u @ TypeKind::UnresolvedTypeRef(..) => {
+                unreachable!("Should have been resolved after parsing {:?}!", u)
+            }
+        }
+    }
+}
+
+struct Vtable<'a> {
+    item_id: ItemId,
+    /// A reference to the originating compound object.
+    #[allow(dead_code)]
+    comp_info: &'a CompInfo,
+}
+
+impl<'a> Vtable<'a> {
+    fn new(item_id: ItemId, comp_info: &'a CompInfo) -> Self {
+        Vtable { item_id, comp_info }
+    }
+}
+
+impl<'a> CodeGenerator for Vtable<'a> {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'b>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'b>,
+        item: &Item,
+    ) {
+        assert_eq!(item.id(), self.item_id);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+        let name = ctx.rust_ident(&self.canonical_name(ctx));
+
+        // For now, we will only generate vtables for classes that:
+        // - do not inherit from others (compilers merge VTable from primary parent class).
+        // - do not contain a virtual destructor (requires ordering; platforms generate different vtables).
+        if ctx.options().vtable_generation &&
+            self.comp_info.base_members().is_empty() &&
+            self.comp_info.destructor().is_none()
+        {
+            let class_ident = ctx.rust_ident(self.item_id.canonical_name(ctx));
+
+            let methods = self
+                .comp_info
+                .methods()
+                .iter()
+                .filter_map(|m| {
+                    if !m.is_virtual() {
+                        return None;
+                    }
+
+                    let function_item = ctx.resolve_item(m.signature());
+                    let function = function_item.expect_function();
+                    let signature_item = ctx.resolve_item(function.signature());
+                    let signature = match signature_item.expect_type().kind() {
+                        TypeKind::Function(ref sig) => sig,
+                        _ => panic!("Function signature type mismatch"),
+                    };
+
+                    // FIXME: Is there a canonical name without the class prepended?
+                    let function_name = function_item.canonical_name(ctx);
+
+                    // FIXME: Need to account for overloading with times_seen (separately from regular function path).
+                    let function_name = ctx.rust_ident(function_name);
+                    let mut args = utils::fnsig_arguments(ctx, signature);
+                    let ret = utils::fnsig_return_ty(ctx, signature);
+
+                    args[0] = if m.is_const() {
+                        quote! { this: *const #class_ident }
+                    } else {
+                        quote! { this: *mut #class_ident }
+                    };
+
+                    Some(quote! {
+                        pub #function_name : unsafe extern "C" fn( #( #args ),* ) #ret
+                    })
+                })
+                .collect::<Vec<_>>();
+
+            result.push(quote! {
+                #[repr(C)]
+                pub struct #name {
+                    #( #methods ),*
+                }
+            })
+        } else {
+            // For the cases we don't support, simply generate an empty struct.
+            let void = helpers::ast_ty::c_void(ctx);
+
+            result.push(quote! {
+                #[repr(C)]
+                pub struct #name ( #void );
+            });
+        }
+    }
+}
+
+impl<'a> ItemCanonicalName for Vtable<'a> {
+    fn canonical_name(&self, ctx: &BindgenContext) -> String {
+        format!("{}__bindgen_vtable", self.item_id.canonical_name(ctx))
+    }
+}
+
+impl<'a> TryToRustTy for Vtable<'a> {
+    type Extra = ();
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<proc_macro2::TokenStream> {
+        let name = ctx.rust_ident(self.canonical_name(ctx));
+        Ok(quote! {
+            #name
+        })
+    }
+}
+
+impl CodeGenerator for TemplateInstantiation {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        // Although uses of instantiations don't need code generation, and are
+        // just converted to rust types in fields, vars, etc, we take this
+        // opportunity to generate tests for their layout here. If the
+        // instantiation is opaque, then its presumably because we don't
+        // properly understand it (maybe because of specializations), and so we
+        // shouldn't emit layout tests either.
+        if !ctx.options().layout_tests || self.is_opaque(ctx, item) {
+            return;
+        }
+
+        // If there are any unbound type parameters, then we can't generate a
+        // layout test because we aren't dealing with a concrete type with a
+        // concrete size and alignment.
+        if ctx.uses_any_template_parameters(item.id()) {
+            return;
+        }
+
+        let layout = item.kind().expect_type().layout(ctx);
+
+        if let Some(layout) = layout {
+            let size = layout.size;
+            let align = layout.align;
+
+            let name = item.full_disambiguated_name(ctx);
+            let mut fn_name =
+                format!("__bindgen_test_layout_{}_instantiation", name);
+            let times_seen = result.overload_number(&fn_name);
+            if times_seen > 0 {
+                write!(&mut fn_name, "_{}", times_seen).unwrap();
+            }
+
+            let fn_name = ctx.rust_ident_raw(fn_name);
+
+            let prefix = ctx.trait_prefix();
+            let ident = item.to_rust_ty_or_opaque(ctx, &());
+            let size_of_expr = quote! {
+                ::#prefix::mem::size_of::<#ident>()
+            };
+            let align_of_expr = quote! {
+                ::#prefix::mem::align_of::<#ident>()
+            };
+
+            let item = quote! {
+                #[test]
+                fn #fn_name() {
+                    assert_eq!(#size_of_expr, #size,
+                               concat!("Size of template specialization: ",
+                                       stringify!(#ident)));
+                    assert_eq!(#align_of_expr, #align,
+                               concat!("Alignment of template specialization: ",
+                                       stringify!(#ident)));
+                }
+            };
+
+            result.push(item);
+        }
+    }
+}
+
+/// Trait for implementing the code generation of a struct or union field.
+trait FieldCodegen<'a> {
+    type Extra;
+
+    #[allow(clippy::too_many_arguments)]
+    fn codegen<F, M>(
+        &self,
+        ctx: &BindgenContext,
+        fields_should_be_private: bool,
+        codegen_depth: usize,
+        accessor_kind: FieldAccessorKind,
+        parent: &CompInfo,
+        result: &mut CodegenResult,
+        struct_layout: &mut StructLayoutTracker,
+        fields: &mut F,
+        methods: &mut M,
+        extra: Self::Extra,
+    ) where
+        F: Extend<proc_macro2::TokenStream>,
+        M: Extend<proc_macro2::TokenStream>;
+}
+
+impl<'a> FieldCodegen<'a> for Field {
+    type Extra = ();
+
+    fn codegen<F, M>(
+        &self,
+        ctx: &BindgenContext,
+        fields_should_be_private: bool,
+        codegen_depth: usize,
+        accessor_kind: FieldAccessorKind,
+        parent: &CompInfo,
+        result: &mut CodegenResult,
+        struct_layout: &mut StructLayoutTracker,
+        fields: &mut F,
+        methods: &mut M,
+        _: (),
+    ) where
+        F: Extend<proc_macro2::TokenStream>,
+        M: Extend<proc_macro2::TokenStream>,
+    {
+        match *self {
+            Field::DataMember(ref data) => {
+                data.codegen(
+                    ctx,
+                    fields_should_be_private,
+                    codegen_depth,
+                    accessor_kind,
+                    parent,
+                    result,
+                    struct_layout,
+                    fields,
+                    methods,
+                    (),
+                );
+            }
+            Field::Bitfields(ref unit) => {
+                unit.codegen(
+                    ctx,
+                    fields_should_be_private,
+                    codegen_depth,
+                    accessor_kind,
+                    parent,
+                    result,
+                    struct_layout,
+                    fields,
+                    methods,
+                    (),
+                );
+            }
+        }
+    }
+}
+
+fn wrap_union_field_if_needed(
+    ctx: &BindgenContext,
+    struct_layout: &StructLayoutTracker,
+    ty: proc_macro2::TokenStream,
+    result: &mut CodegenResult,
+) -> proc_macro2::TokenStream {
+    if struct_layout.is_rust_union() {
+        if struct_layout.can_copy_union_fields() {
+            ty
+        } else {
+            let prefix = ctx.trait_prefix();
+            quote! {
+                ::#prefix::mem::ManuallyDrop<#ty>
+            }
+        }
+    } else {
+        result.saw_bindgen_union();
+        if ctx.options().enable_cxx_namespaces {
+            quote! {
+                root::__BindgenUnionField<#ty>
+            }
+        } else {
+            quote! {
+                __BindgenUnionField<#ty>
+            }
+        }
+    }
+}
+
+impl<'a> FieldCodegen<'a> for FieldData {
+    type Extra = ();
+
+    fn codegen<F, M>(
+        &self,
+        ctx: &BindgenContext,
+        fields_should_be_private: bool,
+        codegen_depth: usize,
+        accessor_kind: FieldAccessorKind,
+        parent: &CompInfo,
+        result: &mut CodegenResult,
+        struct_layout: &mut StructLayoutTracker,
+        fields: &mut F,
+        methods: &mut M,
+        _: (),
+    ) where
+        F: Extend<proc_macro2::TokenStream>,
+        M: Extend<proc_macro2::TokenStream>,
+    {
+        // Bitfields are handled by `FieldCodegen` implementations for
+        // `BitfieldUnit` and `Bitfield`.
+        assert!(self.bitfield_width().is_none());
+
+        let field_item =
+            self.ty().into_resolver().through_type_refs().resolve(ctx);
+        let field_ty = field_item.expect_type();
+        let mut ty = self.ty().to_rust_ty_or_opaque(ctx, &());
+        ty.append_implicit_template_params(ctx, field_item);
+
+        // NB: If supported, we use proper `union` types.
+        let ty = if parent.is_union() {
+            wrap_union_field_if_needed(ctx, struct_layout, ty, result)
+        } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
+            result.saw_incomplete_array();
+
+            let inner = item.to_rust_ty_or_opaque(ctx, &());
+
+            if ctx.options().enable_cxx_namespaces {
+                quote! {
+                    root::__IncompleteArrayField<#inner>
+                }
+            } else {
+                quote! {
+                    __IncompleteArrayField<#inner>
+                }
+            }
+        } else {
+            ty
+        };
+
+        let mut field = quote! {};
+        if ctx.options().generate_comments {
+            if let Some(raw_comment) = self.comment() {
+                let comment =
+                    comment::preprocess(raw_comment, codegen_depth + 1);
+                field = attributes::doc(comment);
+            }
+        }
+
+        let field_name = self
+            .name()
+            .map(|name| ctx.rust_mangle(name).into_owned())
+            .expect("Each field should have a name in codegen!");
+        let field_ident = ctx.rust_ident_raw(field_name.as_str());
+
+        if let Some(padding_field) =
+            struct_layout.saw_field(&field_name, field_ty, self.offset())
+        {
+            fields.extend(Some(padding_field));
+        }
+
+        let is_private = (!self.is_public() &&
+            ctx.options().respect_cxx_access_specs) ||
+            self.annotations()
+                .private_fields()
+                .unwrap_or(fields_should_be_private);
+
+        let accessor_kind =
+            self.annotations().accessor_kind().unwrap_or(accessor_kind);
+
+        if is_private {
+            field.append_all(quote! {
+                #field_ident : #ty ,
+            });
+        } else {
+            field.append_all(quote! {
+                pub #field_ident : #ty ,
+            });
+        }
+
+        fields.extend(Some(field));
+
+        // TODO: Factor the following code out, please!
+        if accessor_kind == FieldAccessorKind::None {
+            return;
+        }
+
+        let getter_name = ctx.rust_ident_raw(format!("get_{}", field_name));
+        let mutable_getter_name =
+            ctx.rust_ident_raw(format!("get_{}_mut", field_name));
+        let field_name = ctx.rust_ident_raw(field_name);
+
+        methods.extend(Some(match accessor_kind {
+            FieldAccessorKind::None => unreachable!(),
+            FieldAccessorKind::Regular => {
+                quote! {
+                    #[inline]
+                    pub fn #getter_name(&self) -> & #ty {
+                        &self.#field_name
+                    }
+
+                    #[inline]
+                    pub fn #mutable_getter_name(&mut self) -> &mut #ty {
+                        &mut self.#field_name
+                    }
+                }
+            }
+            FieldAccessorKind::Unsafe => {
+                quote! {
+                    #[inline]
+                    pub unsafe fn #getter_name(&self) -> & #ty {
+                        &self.#field_name
+                    }
+
+                    #[inline]
+                    pub unsafe fn #mutable_getter_name(&mut self) -> &mut #ty {
+                        &mut self.#field_name
+                    }
+                }
+            }
+            FieldAccessorKind::Immutable => {
+                quote! {
+                    #[inline]
+                    pub fn #getter_name(&self) -> & #ty {
+                        &self.#field_name
+                    }
+                }
+            }
+        }));
+    }
+}
+
+impl BitfieldUnit {
+    /// Get the constructor name for this bitfield unit.
+    fn ctor_name(&self) -> proc_macro2::TokenStream {
+        let ctor_name = Ident::new(
+            &format!("new_bitfield_{}", self.nth()),
+            Span::call_site(),
+        );
+        quote! {
+            #ctor_name
+        }
+    }
+}
+
+impl Bitfield {
+    /// Extend an under construction bitfield unit constructor with this
+    /// bitfield. This sets the relevant bits on the `__bindgen_bitfield_unit`
+    /// variable that's being constructed.
+    fn extend_ctor_impl(
+        &self,
+        ctx: &BindgenContext,
+        param_name: proc_macro2::TokenStream,
+        mut ctor_impl: proc_macro2::TokenStream,
+    ) -> proc_macro2::TokenStream {
+        let bitfield_ty = ctx.resolve_type(self.ty());
+        let bitfield_ty_layout = bitfield_ty
+            .layout(ctx)
+            .expect("Bitfield without layout? Gah!");
+        let bitfield_int_ty = helpers::integer_type(ctx, bitfield_ty_layout)
+            .expect(
+                "Should already have verified that the bitfield is \
+                 representable as an int",
+            );
+
+        let offset = self.offset_into_unit();
+        let width = self.width() as u8;
+        let prefix = ctx.trait_prefix();
+
+        ctor_impl.append_all(quote! {
+            __bindgen_bitfield_unit.set(
+                #offset,
+                #width,
+                {
+                    let #param_name: #bitfield_int_ty = unsafe {
+                        ::#prefix::mem::transmute(#param_name)
+                    };
+                    #param_name as u64
+                }
+            );
+        });
+
+        ctor_impl
+    }
+}
+
+fn access_specifier(
+    ctx: &BindgenContext,
+    is_pub: bool,
+) -> proc_macro2::TokenStream {
+    if is_pub || !ctx.options().respect_cxx_access_specs {
+        quote! { pub }
+    } else {
+        quote! {}
+    }
+}
+
+impl<'a> FieldCodegen<'a> for BitfieldUnit {
+    type Extra = ();
+
+    fn codegen<F, M>(
+        &self,
+        ctx: &BindgenContext,
+        fields_should_be_private: bool,
+        codegen_depth: usize,
+        accessor_kind: FieldAccessorKind,
+        parent: &CompInfo,
+        result: &mut CodegenResult,
+        struct_layout: &mut StructLayoutTracker,
+        fields: &mut F,
+        methods: &mut M,
+        _: (),
+    ) where
+        F: Extend<proc_macro2::TokenStream>,
+        M: Extend<proc_macro2::TokenStream>,
+    {
+        use crate::ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
+
+        result.saw_bitfield_unit();
+
+        let layout = self.layout();
+        let unit_field_ty = helpers::bitfield_unit(ctx, layout);
+        let field_ty = if parent.is_union() {
+            wrap_union_field_if_needed(
+                ctx,
+                struct_layout,
+                unit_field_ty.clone(),
+                result,
+            )
+        } else {
+            unit_field_ty.clone()
+        };
+
+        {
+            let align_field_name = format!("_bitfield_align_{}", self.nth());
+            let align_field_ident = ctx.rust_ident(&align_field_name);
+            let align_ty = match self.layout().align {
+                n if n >= 8 => quote! { u64 },
+                4 => quote! { u32 },
+                2 => quote! { u16 },
+                _ => quote! { u8  },
+            };
+            let align_field = quote! {
+                pub #align_field_ident: [#align_ty; 0],
+            };
+            fields.extend(Some(align_field));
+        }
+
+        let unit_field_name = format!("_bitfield_{}", self.nth());
+        let unit_field_ident = ctx.rust_ident(&unit_field_name);
+
+        let ctor_name = self.ctor_name();
+        let mut ctor_params = vec![];
+        let mut ctor_impl = quote! {};
+
+        // We cannot generate any constructor if the underlying storage can't
+        // implement AsRef<[u8]> / AsMut<[u8]> / etc, or can't derive Default.
+        //
+        // We don't check `larger_arrays` here because Default does still have
+        // the 32 items limitation.
+        let mut generate_ctor = layout.size <= RUST_DERIVE_IN_ARRAY_LIMIT;
+
+        let mut access_spec = !fields_should_be_private;
+        for bf in self.bitfields() {
+            // Codegen not allowed for anonymous bitfields
+            if bf.name().is_none() {
+                continue;
+            }
+
+            if layout.size > RUST_DERIVE_IN_ARRAY_LIMIT &&
+                !ctx.options().rust_features().larger_arrays
+            {
+                continue;
+            }
+
+            access_spec &= bf.is_public();
+            let mut bitfield_representable_as_int = true;
+
+            bf.codegen(
+                ctx,
+                fields_should_be_private,
+                codegen_depth,
+                accessor_kind,
+                parent,
+                result,
+                struct_layout,
+                fields,
+                methods,
+                (&unit_field_name, &mut bitfield_representable_as_int),
+            );
+
+            // Generating a constructor requires the bitfield to be representable as an integer.
+            if !bitfield_representable_as_int {
+                generate_ctor = false;
+                continue;
+            }
+
+            let param_name = bitfield_getter_name(ctx, bf);
+            let bitfield_ty_item = ctx.resolve_item(bf.ty());
+            let bitfield_ty = bitfield_ty_item.expect_type();
+            let bitfield_ty =
+                bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item);
+
+            ctor_params.push(quote! {
+                #param_name : #bitfield_ty
+            });
+            ctor_impl = bf.extend_ctor_impl(ctx, param_name, ctor_impl);
+        }
+
+        let access_spec = access_specifier(ctx, access_spec);
+
+        let field = quote! {
+            #access_spec #unit_field_ident : #field_ty ,
+        };
+        fields.extend(Some(field));
+
+        if generate_ctor {
+            methods.extend(Some(quote! {
+                #[inline]
+                #access_spec fn #ctor_name ( #( #ctor_params ),* ) -> #unit_field_ty {
+                    let mut __bindgen_bitfield_unit: #unit_field_ty = Default::default();
+                    #ctor_impl
+                    __bindgen_bitfield_unit
+                }
+            }));
+        }
+
+        struct_layout.saw_bitfield_unit(layout);
+    }
+}
+
+fn bitfield_getter_name(
+    ctx: &BindgenContext,
+    bitfield: &Bitfield,
+) -> proc_macro2::TokenStream {
+    let name = bitfield.getter_name();
+    let name = ctx.rust_ident_raw(name);
+    quote! { #name }
+}
+
+fn bitfield_setter_name(
+    ctx: &BindgenContext,
+    bitfield: &Bitfield,
+) -> proc_macro2::TokenStream {
+    let setter = bitfield.setter_name();
+    let setter = ctx.rust_ident_raw(setter);
+    quote! { #setter }
+}
+
+impl<'a> FieldCodegen<'a> for Bitfield {
+    type Extra = (&'a str, &'a mut bool);
+
+    fn codegen<F, M>(
+        &self,
+        ctx: &BindgenContext,
+        fields_should_be_private: bool,
+        _codegen_depth: usize,
+        _accessor_kind: FieldAccessorKind,
+        parent: &CompInfo,
+        _result: &mut CodegenResult,
+        struct_layout: &mut StructLayoutTracker,
+        _fields: &mut F,
+        methods: &mut M,
+        (unit_field_name, bitfield_representable_as_int): (&'a str, &mut bool),
+    ) where
+        F: Extend<proc_macro2::TokenStream>,
+        M: Extend<proc_macro2::TokenStream>,
+    {
+        let prefix = ctx.trait_prefix();
+        let getter_name = bitfield_getter_name(ctx, self);
+        let setter_name = bitfield_setter_name(ctx, self);
+        let unit_field_ident = Ident::new(unit_field_name, Span::call_site());
+
+        let bitfield_ty_item = ctx.resolve_item(self.ty());
+        let bitfield_ty = bitfield_ty_item.expect_type();
+
+        let bitfield_ty_layout = bitfield_ty
+            .layout(ctx)
+            .expect("Bitfield without layout? Gah!");
+        let bitfield_int_ty =
+            match helpers::integer_type(ctx, bitfield_ty_layout) {
+                Some(int_ty) => {
+                    *bitfield_representable_as_int = true;
+                    int_ty
+                }
+                None => {
+                    *bitfield_representable_as_int = false;
+                    return;
+                }
+            };
+
+        let bitfield_ty =
+            bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item);
+
+        let offset = self.offset_into_unit();
+        let width = self.width() as u8;
+        let access_spec = access_specifier(
+            ctx,
+            self.is_public() && !fields_should_be_private,
+        );
+
+        if parent.is_union() && !struct_layout.is_rust_union() {
+            methods.extend(Some(quote! {
+                #[inline]
+                #access_spec fn #getter_name(&self) -> #bitfield_ty {
+                    unsafe {
+                        ::#prefix::mem::transmute(
+                            self.#unit_field_ident.as_ref().get(#offset, #width)
+                                as #bitfield_int_ty
+                        )
+                    }
+                }
+
+                #[inline]
+                #access_spec fn #setter_name(&mut self, val: #bitfield_ty) {
+                    unsafe {
+                        let val: #bitfield_int_ty = ::#prefix::mem::transmute(val);
+                        self.#unit_field_ident.as_mut().set(
+                            #offset,
+                            #width,
+                            val as u64
+                        )
+                    }
+                }
+            }));
+        } else {
+            methods.extend(Some(quote! {
+                #[inline]
+                #access_spec fn #getter_name(&self) -> #bitfield_ty {
+                    unsafe {
+                        ::#prefix::mem::transmute(
+                            self.#unit_field_ident.get(#offset, #width)
+                                as #bitfield_int_ty
+                        )
+                    }
+                }
+
+                #[inline]
+                #access_spec fn #setter_name(&mut self, val: #bitfield_ty) {
+                    unsafe {
+                        let val: #bitfield_int_ty = ::#prefix::mem::transmute(val);
+                        self.#unit_field_ident.set(
+                            #offset,
+                            #width,
+                            val as u64
+                        )
+                    }
+                }
+            }));
+        }
+    }
+}
+
+impl CodeGenerator for CompInfo {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug!("<CompInfo as CodeGenerator>::codegen: item = {:?}", item);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        // Don't output classes with template parameters that aren't types, and
+        // also don't output template specializations, neither total or partial.
+        if self.has_non_type_template_params() {
+            return;
+        }
+
+        let ty = item.expect_type();
+        let layout = ty.layout(ctx);
+        let mut packed = self.is_packed(ctx, layout.as_ref());
+
+        let canonical_name = item.canonical_name(ctx);
+        let canonical_ident = ctx.rust_ident(&canonical_name);
+
+        // Generate the vtable from the method list if appropriate.
+        //
+        // TODO: I don't know how this could play with virtual methods that are
+        // not in the list of methods found by us, we'll see. Also, could the
+        // order of the vtable pointers vary?
+        //
+        // FIXME: Once we generate proper vtables, we need to codegen the
+        // vtable, but *not* generate a field for it in the case that
+        // HasVtable::has_vtable_ptr is false but HasVtable::has_vtable is true.
+        //
+        // Also, we need to generate the vtable in such a way it "inherits" from
+        // the parent too.
+        let is_opaque = item.is_opaque(ctx, &());
+        let mut fields = vec![];
+        let mut struct_layout =
+            StructLayoutTracker::new(ctx, self, ty, &canonical_name);
+
+        if !is_opaque {
+            if item.has_vtable_ptr(ctx) {
+                let vtable = Vtable::new(item.id(), self);
+                vtable.codegen(ctx, result, item);
+
+                let vtable_type = vtable
+                    .try_to_rust_ty(ctx, &())
+                    .expect("vtable to Rust type conversion is infallible")
+                    .to_ptr(true);
+
+                fields.push(quote! {
+                    pub vtable_: #vtable_type ,
+                });
+
+                struct_layout.saw_vtable();
+            }
+
+            for base in self.base_members() {
+                if !base.requires_storage(ctx) {
+                    continue;
+                }
+
+                let inner_item = ctx.resolve_item(base.ty);
+                let mut inner = inner_item.to_rust_ty_or_opaque(ctx, &());
+                inner.append_implicit_template_params(ctx, inner_item);
+                let field_name = ctx.rust_ident(&base.field_name);
+
+                struct_layout.saw_base(inner_item.expect_type());
+
+                let access_spec = access_specifier(ctx, base.is_public());
+                fields.push(quote! {
+                    #access_spec #field_name: #inner,
+                });
+            }
+        }
+
+        let mut methods = vec![];
+        if !is_opaque {
+            let codegen_depth = item.codegen_depth(ctx);
+            let fields_should_be_private =
+                item.annotations().private_fields().unwrap_or(false);
+            let struct_accessor_kind = item
+                .annotations()
+                .accessor_kind()
+                .unwrap_or(FieldAccessorKind::None);
+            for field in self.fields() {
+                field.codegen(
+                    ctx,
+                    fields_should_be_private,
+                    codegen_depth,
+                    struct_accessor_kind,
+                    self,
+                    result,
+                    &mut struct_layout,
+                    &mut fields,
+                    &mut methods,
+                    (),
+                );
+            }
+            // Check whether an explicit padding field is needed
+            // at the end.
+            if let Some(comp_layout) = layout {
+                fields.extend(
+                    struct_layout
+                        .add_tail_padding(&canonical_name, comp_layout),
+                );
+            }
+        }
+
+        if is_opaque {
+            // Opaque item should not have generated methods, fields.
+            debug_assert!(fields.is_empty());
+            debug_assert!(methods.is_empty());
+        }
+
+        let is_union = self.kind() == CompKind::Union;
+        let layout = item.kind().expect_type().layout(ctx);
+        let zero_sized = item.is_zero_sized(ctx);
+        let forward_decl = self.is_forward_declaration();
+
+        let mut explicit_align = None;
+
+        // C++ requires every struct to be addressable, so what C++ compilers do
+        // is making the struct 1-byte sized.
+        //
+        // This is apparently not the case for C, see:
+        // https://github.com/rust-lang/rust-bindgen/issues/551
+        //
+        // Just get the layout, and assume C++ if not.
+        //
+        // NOTE: This check is conveniently here to avoid the dummy fields we
+        // may add for unused template parameters.
+        if !forward_decl && zero_sized {
+            let has_address = if is_opaque {
+                // Generate the address field if it's an opaque type and
+                // couldn't determine the layout of the blob.
+                layout.is_none()
+            } else {
+                layout.map_or(true, |l| l.size != 0)
+            };
+
+            if has_address {
+                let layout = Layout::new(1, 1);
+                let ty = helpers::blob(ctx, Layout::new(1, 1));
+                struct_layout.saw_field_with_layout(
+                    "_address",
+                    layout,
+                    /* offset = */ Some(0),
+                );
+                fields.push(quote! {
+                    pub _address: #ty,
+                });
+            }
+        }
+
+        if is_opaque {
+            match layout {
+                Some(l) => {
+                    explicit_align = Some(l.align);
+
+                    let ty = helpers::blob(ctx, l);
+                    fields.push(quote! {
+                        pub _bindgen_opaque_blob: #ty ,
+                    });
+                }
+                None => {
+                    warn!("Opaque type without layout! Expect dragons!");
+                }
+            }
+        } else if !is_union && !zero_sized {
+            if let Some(padding_field) =
+                layout.and_then(|layout| struct_layout.pad_struct(layout))
+            {
+                fields.push(padding_field);
+            }
+
+            if let Some(layout) = layout {
+                if struct_layout.requires_explicit_align(layout) {
+                    if layout.align == 1 {
+                        packed = true;
+                    } else {
+                        explicit_align = Some(layout.align);
+                        if !ctx.options().rust_features.repr_align {
+                            let ty = helpers::blob(
+                                ctx,
+                                Layout::new(0, layout.align),
+                            );
+                            fields.push(quote! {
+                                pub __bindgen_align: #ty ,
+                            });
+                        }
+                    }
+                }
+            }
+        } else if is_union && !forward_decl {
+            // TODO(emilio): It'd be nice to unify this with the struct path
+            // above somehow.
+            let layout = layout.expect("Unable to get layout information?");
+            if struct_layout.requires_explicit_align(layout) {
+                explicit_align = Some(layout.align);
+            }
+
+            if !struct_layout.is_rust_union() {
+                let ty = helpers::blob(ctx, layout);
+                fields.push(quote! {
+                    pub bindgen_union_field: #ty ,
+                })
+            }
+        }
+
+        if forward_decl {
+            fields.push(quote! {
+                _unused: [u8; 0],
+            });
+        }
+
+        let mut generic_param_names = vec![];
+
+        for (idx, ty) in item.used_template_params(ctx).iter().enumerate() {
+            let param = ctx.resolve_type(*ty);
+            let name = param.name().unwrap();
+            let ident = ctx.rust_ident(name);
+            generic_param_names.push(ident.clone());
+
+            let prefix = ctx.trait_prefix();
+            let field_name = ctx.rust_ident(format!("_phantom_{}", idx));
+            fields.push(quote! {
+                pub #field_name : ::#prefix::marker::PhantomData<
+                    ::#prefix::cell::UnsafeCell<#ident>
+                > ,
+            });
+        }
+
+        let generics = if !generic_param_names.is_empty() {
+            let generic_param_names = generic_param_names.clone();
+            quote! {
+                < #( #generic_param_names ),* >
+            }
+        } else {
+            quote! {}
+        };
+
+        let mut attributes = vec![];
+        let mut needs_clone_impl = false;
+        let mut needs_default_impl = false;
+        let mut needs_debug_impl = false;
+        let mut needs_partialeq_impl = false;
+        if let Some(comment) = item.comment(ctx) {
+            attributes.push(attributes::doc(comment));
+        }
+        if packed && !is_opaque {
+            let n = layout.map_or(1, |l| l.align);
+            assert!(ctx.options().rust_features().repr_packed_n || n == 1);
+            let packed_repr = if n == 1 {
+                "packed".to_string()
+            } else {
+                format!("packed({})", n)
+            };
+            attributes.push(attributes::repr_list(&["C", &packed_repr]));
+        } else {
+            attributes.push(attributes::repr("C"));
+        }
+
+        if ctx.options().rust_features().repr_align {
+            if let Some(explicit) = explicit_align {
+                // Ensure that the struct has the correct alignment even in
+                // presence of alignas.
+                let explicit = helpers::ast_ty::int_expr(explicit as i64);
+                attributes.push(quote! {
+                    #[repr(align(#explicit))]
+                });
+            }
+        }
+
+        let derivable_traits = derives_of_item(item, ctx, packed);
+        if !derivable_traits.contains(DerivableTraits::DEBUG) {
+            needs_debug_impl = ctx.options().derive_debug &&
+                ctx.options().impl_debug &&
+                !ctx.no_debug_by_name(item) &&
+                !item.annotations().disallow_debug();
+        }
+
+        if !derivable_traits.contains(DerivableTraits::DEFAULT) {
+            needs_default_impl = ctx.options().derive_default &&
+                !self.is_forward_declaration() &&
+                !ctx.no_default_by_name(item) &&
+                !item.annotations().disallow_default();
+        }
+
+        let all_template_params = item.all_template_params(ctx);
+
+        if derivable_traits.contains(DerivableTraits::COPY) &&
+            !derivable_traits.contains(DerivableTraits::CLONE)
+        {
+            needs_clone_impl = true;
+        }
+
+        if !derivable_traits.contains(DerivableTraits::PARTIAL_EQ) {
+            needs_partialeq_impl = ctx.options().derive_partialeq &&
+                ctx.options().impl_partialeq &&
+                ctx.lookup_can_derive_partialeq_or_partialord(item.id()) ==
+                    CanDerive::Manually;
+        }
+
+        let mut derives: Vec<_> = derivable_traits.into();
+        derives.extend(item.annotations().derives().iter().map(String::as_str));
+
+        // The custom derives callback may return a list of derive attributes;
+        // add them to the end of the list.
+        let custom_derives;
+        if let Some(cb) = &ctx.options().parse_callbacks {
+            custom_derives = cb.add_derives(&canonical_name);
+            // In most cases this will be a no-op, since custom_derives will be empty.
+            derives.extend(custom_derives.iter().map(|s| s.as_str()));
+        };
+
+        if !derives.is_empty() {
+            attributes.push(attributes::derives(&derives))
+        }
+
+        if item.must_use(ctx) {
+            attributes.push(attributes::must_use());
+        }
+
+        let mut tokens = if is_union && struct_layout.is_rust_union() {
+            quote! {
+                #( #attributes )*
+                pub union #canonical_ident
+            }
+        } else {
+            quote! {
+                #( #attributes )*
+                pub struct #canonical_ident
+            }
+        };
+
+        tokens.append_all(quote! {
+            #generics {
+                #( #fields )*
+            }
+        });
+        result.push(tokens);
+
+        // Generate the inner types and all that stuff.
+        //
+        // TODO: In the future we might want to be smart, and use nested
+        // modules, and whatnot.
+        for ty in self.inner_types() {
+            let child_item = ctx.resolve_item(*ty);
+            // assert_eq!(child_item.parent_id(), item.id());
+            child_item.codegen(ctx, result, &());
+        }
+
+        // NOTE: Some unexposed attributes (like alignment attributes) may
+        // affect layout, so we're bad and pray to the gods for avoid sending
+        // all the tests to shit when parsing things like max_align_t.
+        if self.found_unknown_attr() {
+            warn!(
+                "Type {} has an unknown attribute that may affect layout",
+                canonical_ident
+            );
+        }
+
+        if all_template_params.is_empty() {
+            if !is_opaque {
+                for var in self.inner_vars() {
+                    ctx.resolve_item(*var).codegen(ctx, result, &());
+                }
+            }
+
+            if ctx.options().layout_tests && !self.is_forward_declaration() {
+                if let Some(layout) = layout {
+                    let fn_name =
+                        format!("bindgen_test_layout_{}", canonical_ident);
+                    let fn_name = ctx.rust_ident_raw(fn_name);
+                    let prefix = ctx.trait_prefix();
+                    let size_of_expr = quote! {
+                        ::#prefix::mem::size_of::<#canonical_ident>()
+                    };
+                    let align_of_expr = quote! {
+                        ::#prefix::mem::align_of::<#canonical_ident>()
+                    };
+                    let size = layout.size;
+                    let align = layout.align;
+
+                    let check_struct_align = if align >
+                        ctx.target_pointer_size() &&
+                        !ctx.options().rust_features().repr_align
+                    {
+                        None
+                    } else {
+                        Some(quote! {
+                            assert_eq!(#align_of_expr,
+                                   #align,
+                                   concat!("Alignment of ", stringify!(#canonical_ident)));
+
+                        })
+                    };
+
+                    // FIXME when [issue #465](https://github.com/rust-lang/rust-bindgen/issues/465) ready
+                    let too_many_base_vtables = self
+                        .base_members()
+                        .iter()
+                        .filter(|base| base.ty.has_vtable(ctx))
+                        .count() >
+                        1;
+
+                    let should_skip_field_offset_checks =
+                        is_opaque || too_many_base_vtables;
+
+                    let check_field_offset = if should_skip_field_offset_checks
+                    {
+                        vec![]
+                    } else {
+                        self.fields()
+                            .iter()
+                            .filter_map(|field| match *field {
+                                Field::DataMember(ref f) if f.name().is_some() => Some(f),
+                                _ => None,
+                            })
+                            .flat_map(|field| {
+                                let name = field.name().unwrap();
+                                field.offset().map(|offset| {
+                                    let field_offset = offset / 8;
+                                    let field_name = ctx.rust_ident(name);
+                                    quote! {
+                                        assert_eq!(
+                                            unsafe {
+                                                ::#prefix::ptr::addr_of!((*ptr).#field_name) as usize - ptr as usize
+                                            },
+                                            #field_offset,
+                                            concat!("Offset of field: ", stringify!(#canonical_ident), "::", stringify!(#field_name))
+                                        );
+                                    }
+                                })
+                            })
+                            .collect()
+                    };
+
+                    let uninit_decl = if !check_field_offset.is_empty() {
+                        // FIXME: When MSRV >= 1.59.0, we can use
+                        // > const PTR: *const #canonical_ident = ::#prefix::mem::MaybeUninit::uninit().as_ptr();
+                        Some(quote! {
+                            // Use a shared MaybeUninit so that rustc with
+                            // opt-level=0 doesn't take too much stack space,
+                            // see #2218.
+                            const UNINIT: ::#prefix::mem::MaybeUninit<#canonical_ident> = ::#prefix::mem::MaybeUninit::uninit();
+                            let ptr = UNINIT.as_ptr();
+                        })
+                    } else {
+                        None
+                    };
+
+                    let item = quote! {
+                        #[test]
+                        fn #fn_name() {
+                            #uninit_decl
+                            assert_eq!(#size_of_expr,
+                                       #size,
+                                       concat!("Size of: ", stringify!(#canonical_ident)));
+                            #check_struct_align
+                            #( #check_field_offset )*
+                        }
+                    };
+                    result.push(item);
+                }
+            }
+
+            let mut method_names = Default::default();
+            if ctx.options().codegen_config.methods() {
+                for method in self.methods() {
+                    assert!(method.kind() != MethodKind::Constructor);
+                    method.codegen_method(
+                        ctx,
+                        &mut methods,
+                        &mut method_names,
+                        result,
+                        self,
+                    );
+                }
+            }
+
+            if ctx.options().codegen_config.constructors() {
+                for sig in self.constructors() {
+                    Method::new(
+                        MethodKind::Constructor,
+                        *sig,
+                        /* const */
+                        false,
+                    )
+                    .codegen_method(
+                        ctx,
+                        &mut methods,
+                        &mut method_names,
+                        result,
+                        self,
+                    );
+                }
+            }
+
+            if ctx.options().codegen_config.destructors() {
+                if let Some((kind, destructor)) = self.destructor() {
+                    debug_assert!(kind.is_destructor());
+                    Method::new(kind, destructor, false).codegen_method(
+                        ctx,
+                        &mut methods,
+                        &mut method_names,
+                        result,
+                        self,
+                    );
+                }
+            }
+        }
+
+        // NB: We can't use to_rust_ty here since for opaque types this tries to
+        // use the specialization knowledge to generate a blob field.
+        let ty_for_impl = quote! {
+            #canonical_ident #generics
+        };
+
+        if needs_clone_impl {
+            result.push(quote! {
+                impl #generics Clone for #ty_for_impl {
+                    fn clone(&self) -> Self { *self }
+                }
+            });
+        }
+
+        if needs_default_impl {
+            let prefix = ctx.trait_prefix();
+            let body = if ctx.options().rust_features().maybe_uninit {
+                quote! {
+                    let mut s = ::#prefix::mem::MaybeUninit::<Self>::uninit();
+                    unsafe {
+                        ::#prefix::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+                        s.assume_init()
+                    }
+                }
+            } else {
+                quote! {
+                    unsafe {
+                        let mut s: Self = ::#prefix::mem::uninitialized();
+                        ::#prefix::ptr::write_bytes(&mut s, 0, 1);
+                        s
+                    }
+                }
+            };
+            // Note we use `ptr::write_bytes()` instead of `mem::zeroed()` because the latter does
+            // not necessarily ensure padding bytes are zeroed. Some C libraries are sensitive to
+            // non-zero padding bytes, especially when forwards/backwards compatability is
+            // involved.
+            result.push(quote! {
+                impl #generics Default for #ty_for_impl {
+                    fn default() -> Self {
+                        #body
+                    }
+                }
+            });
+        }
+
+        if needs_debug_impl {
+            let impl_ = impl_debug::gen_debug_impl(
+                ctx,
+                self.fields(),
+                item,
+                self.kind(),
+            );
+
+            let prefix = ctx.trait_prefix();
+
+            result.push(quote! {
+                impl #generics ::#prefix::fmt::Debug for #ty_for_impl {
+                    #impl_
+                }
+            });
+        }
+
+        if needs_partialeq_impl {
+            if let Some(impl_) = impl_partialeq::gen_partialeq_impl(
+                ctx,
+                self,
+                item,
+                &ty_for_impl,
+            ) {
+                let partialeq_bounds = if !generic_param_names.is_empty() {
+                    let bounds = generic_param_names.iter().map(|t| {
+                        quote! { #t: PartialEq }
+                    });
+                    quote! { where #( #bounds ),* }
+                } else {
+                    quote! {}
+                };
+
+                let prefix = ctx.trait_prefix();
+                result.push(quote! {
+                    impl #generics ::#prefix::cmp::PartialEq for #ty_for_impl #partialeq_bounds {
+                        #impl_
+                    }
+                });
+            }
+        }
+
+        if !methods.is_empty() {
+            result.push(quote! {
+                impl #generics #ty_for_impl {
+                    #( #methods )*
+                }
+            });
+        }
+    }
+}
+
+trait MethodCodegen {
+    fn codegen_method<'a>(
+        &self,
+        ctx: &BindgenContext,
+        methods: &mut Vec<proc_macro2::TokenStream>,
+        method_names: &mut HashMap<String, usize>,
+        result: &mut CodegenResult<'a>,
+        parent: &CompInfo,
+    );
+}
+
+impl MethodCodegen for Method {
+    fn codegen_method<'a>(
+        &self,
+        ctx: &BindgenContext,
+        methods: &mut Vec<proc_macro2::TokenStream>,
+        method_names: &mut HashMap<String, usize>,
+        result: &mut CodegenResult<'a>,
+        _parent: &CompInfo,
+    ) {
+        assert!({
+            let cc = &ctx.options().codegen_config;
+            match self.kind() {
+                MethodKind::Constructor => cc.constructors(),
+                MethodKind::Destructor => cc.destructors(),
+                MethodKind::VirtualDestructor { .. } => cc.destructors(),
+                MethodKind::Static |
+                MethodKind::Normal |
+                MethodKind::Virtual { .. } => cc.methods(),
+            }
+        });
+
+        // TODO(emilio): We could generate final stuff at least.
+        if self.is_virtual() {
+            return; // FIXME
+        }
+
+        // First of all, output the actual function.
+        let function_item = ctx.resolve_item(self.signature());
+        if !function_item.process_before_codegen(ctx, result) {
+            return;
+        }
+        let function = function_item.expect_function();
+        let times_seen = function.codegen(ctx, result, function_item);
+        let times_seen = match times_seen {
+            Some(seen) => seen,
+            None => return,
+        };
+        let signature_item = ctx.resolve_item(function.signature());
+        let mut name = match self.kind() {
+            MethodKind::Constructor => "new".into(),
+            MethodKind::Destructor => "destruct".into(),
+            _ => function.name().to_owned(),
+        };
+
+        let signature = match *signature_item.expect_type().kind() {
+            TypeKind::Function(ref sig) => sig,
+            _ => panic!("How in the world?"),
+        };
+
+        let supported_abi = match signature.abi() {
+            Abi::ThisCall => ctx.options().rust_features().thiscall_abi,
+            Abi::Vectorcall => ctx.options().rust_features().vectorcall_abi,
+            _ => true,
+        };
+
+        if !supported_abi {
+            return;
+        }
+
+        // Do not generate variadic methods, since rust does not allow
+        // implementing them, and we don't do a good job at it anyway.
+        if signature.is_variadic() {
+            return;
+        }
+
+        let count = {
+            let count = method_names.entry(name.clone()).or_insert(0);
+            *count += 1;
+            *count - 1
+        };
+
+        if count != 0 {
+            name.push_str(&count.to_string());
+        }
+
+        let mut function_name = function_item.canonical_name(ctx);
+        if times_seen > 0 {
+            write!(&mut function_name, "{}", times_seen).unwrap();
+        }
+        let function_name = ctx.rust_ident(function_name);
+        let mut args = utils::fnsig_arguments(ctx, signature);
+        let mut ret = utils::fnsig_return_ty(ctx, signature);
+
+        if !self.is_static() && !self.is_constructor() {
+            args[0] = if self.is_const() {
+                quote! { &self }
+            } else {
+                quote! { &mut self }
+            };
+        }
+
+        // If it's a constructor, we always return `Self`, and we inject the
+        // "this" parameter, so there's no need to ask the user for it.
+        //
+        // Note that constructors in Clang are represented as functions with
+        // return-type = void.
+        if self.is_constructor() {
+            args.remove(0);
+            ret = quote! { -> Self };
+        }
+
+        let mut exprs =
+            helpers::ast_ty::arguments_from_signature(signature, ctx);
+
+        let mut stmts = vec![];
+
+        // If it's a constructor, we need to insert an extra parameter with a
+        // variable called `__bindgen_tmp` we're going to create.
+        if self.is_constructor() {
+            let prefix = ctx.trait_prefix();
+            let tmp_variable_decl = if ctx
+                .options()
+                .rust_features()
+                .maybe_uninit
+            {
+                exprs[0] = quote! {
+                    __bindgen_tmp.as_mut_ptr()
+                };
+                quote! {
+                    let mut __bindgen_tmp = ::#prefix::mem::MaybeUninit::uninit()
+                }
+            } else {
+                exprs[0] = quote! {
+                    &mut __bindgen_tmp
+                };
+                quote! {
+                    let mut __bindgen_tmp = ::#prefix::mem::uninitialized()
+                }
+            };
+            stmts.push(tmp_variable_decl);
+        } else if !self.is_static() {
+            assert!(!exprs.is_empty());
+            exprs[0] = quote! {
+                self
+            };
+        };
+
+        let call = quote! {
+            #function_name (#( #exprs ),* )
+        };
+
+        stmts.push(call);
+
+        if self.is_constructor() {
+            stmts.push(if ctx.options().rust_features().maybe_uninit {
+                quote! {
+                    __bindgen_tmp.assume_init()
+                }
+            } else {
+                quote! {
+                    __bindgen_tmp
+                }
+            })
+        }
+
+        let block = quote! {
+            #( #stmts );*
+        };
+
+        let mut attrs = vec![attributes::inline()];
+
+        if signature.must_use() &&
+            ctx.options().rust_features().must_use_function
+        {
+            attrs.push(attributes::must_use());
+        }
+
+        let name = ctx.rust_ident(&name);
+        methods.push(quote! {
+            #(#attrs)*
+            pub unsafe fn #name ( #( #args ),* ) #ret {
+                #block
+            }
+        });
+    }
+}
+
+/// A helper type that represents different enum variations.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum EnumVariation {
+    /// The code for this enum will use a Rust enum. Note that creating this in unsafe code
+    /// (including FFI) with an invalid value will invoke undefined behaviour, whether or not
+    /// its marked as non_exhaustive.
+    Rust {
+        /// Indicates whether the generated struct should be `#[non_exhaustive]`
+        non_exhaustive: bool,
+    },
+    /// The code for this enum will use a newtype
+    NewType {
+        /// Indicates whether the newtype will have bitwise operators
+        is_bitfield: bool,
+        /// Indicates whether the variants will be represented as global constants
+        is_global: bool,
+    },
+    /// The code for this enum will use consts
+    Consts,
+    /// The code for this enum will use a module containing consts
+    ModuleConsts,
+}
+
+impl EnumVariation {
+    fn is_rust(&self) -> bool {
+        matches!(*self, EnumVariation::Rust { .. })
+    }
+
+    /// Both the `Const` and `ModuleConsts` variants will cause this to return
+    /// true.
+    fn is_const(&self) -> bool {
+        matches!(*self, EnumVariation::Consts | EnumVariation::ModuleConsts)
+    }
+}
+
+impl Default for EnumVariation {
+    fn default() -> EnumVariation {
+        EnumVariation::Consts
+    }
+}
+
+impl std::str::FromStr for EnumVariation {
+    type Err = std::io::Error;
+
+    /// Create a `EnumVariation` from a string.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "rust" => Ok(EnumVariation::Rust {
+                non_exhaustive: false,
+            }),
+            "rust_non_exhaustive" => Ok(EnumVariation::Rust {
+                non_exhaustive: true,
+            }),
+            "bitfield" => Ok(EnumVariation::NewType {
+                is_bitfield: true,
+                is_global: false,
+            }),
+            "consts" => Ok(EnumVariation::Consts),
+            "moduleconsts" => Ok(EnumVariation::ModuleConsts),
+            "newtype" => Ok(EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: false,
+            }),
+            "newtype_global" => Ok(EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: true,
+            }),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid EnumVariation. Accepted values ",
+                    "are 'rust', 'rust_non_exhaustive', 'bitfield', 'consts',",
+                    "'moduleconsts', 'newtype' and 'newtype_global'."
+                ),
+            )),
+        }
+    }
+}
+
+/// A helper type to construct different enum variations.
+enum EnumBuilder<'a> {
+    Rust {
+        codegen_depth: usize,
+        attrs: Vec<proc_macro2::TokenStream>,
+        ident: Ident,
+        tokens: proc_macro2::TokenStream,
+        emitted_any_variants: bool,
+    },
+    NewType {
+        codegen_depth: usize,
+        canonical_name: &'a str,
+        tokens: proc_macro2::TokenStream,
+        is_bitfield: bool,
+        is_global: bool,
+    },
+    Consts {
+        variants: Vec<proc_macro2::TokenStream>,
+        codegen_depth: usize,
+    },
+    ModuleConsts {
+        codegen_depth: usize,
+        module_name: &'a str,
+        module_items: Vec<proc_macro2::TokenStream>,
+    },
+}
+
+impl<'a> EnumBuilder<'a> {
+    /// Returns the depth of the code generation for a variant of this enum.
+    fn codegen_depth(&self) -> usize {
+        match *self {
+            EnumBuilder::Rust { codegen_depth, .. } |
+            EnumBuilder::NewType { codegen_depth, .. } |
+            EnumBuilder::ModuleConsts { codegen_depth, .. } |
+            EnumBuilder::Consts { codegen_depth, .. } => codegen_depth,
+        }
+    }
+
+    /// Returns true if the builder is for a rustified enum.
+    fn is_rust_enum(&self) -> bool {
+        matches!(*self, EnumBuilder::Rust { .. })
+    }
+
+    /// Create a new enum given an item builder, a canonical name, a name for
+    /// the representation, and which variation it should be generated as.
+    fn new(
+        name: &'a str,
+        mut attrs: Vec<proc_macro2::TokenStream>,
+        repr: proc_macro2::TokenStream,
+        enum_variation: EnumVariation,
+        enum_codegen_depth: usize,
+    ) -> Self {
+        let ident = Ident::new(name, Span::call_site());
+
+        match enum_variation {
+            EnumVariation::NewType {
+                is_bitfield,
+                is_global,
+            } => EnumBuilder::NewType {
+                codegen_depth: enum_codegen_depth,
+                canonical_name: name,
+                tokens: quote! {
+                    #( #attrs )*
+                    pub struct #ident (pub #repr);
+                },
+                is_bitfield,
+                is_global,
+            },
+
+            EnumVariation::Rust { .. } => {
+                // `repr` is guaranteed to be Rustified in Enum::codegen
+                attrs.insert(0, quote! { #[repr( #repr )] });
+                let tokens = quote!();
+                EnumBuilder::Rust {
+                    codegen_depth: enum_codegen_depth + 1,
+                    attrs,
+                    ident,
+                    tokens,
+                    emitted_any_variants: false,
+                }
+            }
+
+            EnumVariation::Consts => {
+                let mut variants = Vec::new();
+
+                variants.push(quote! {
+                    #( #attrs )*
+                    pub type #ident = #repr;
+                });
+
+                EnumBuilder::Consts {
+                    variants,
+                    codegen_depth: enum_codegen_depth,
+                }
+            }
+
+            EnumVariation::ModuleConsts => {
+                let ident = Ident::new(
+                    CONSTIFIED_ENUM_MODULE_REPR_NAME,
+                    Span::call_site(),
+                );
+                let type_definition = quote! {
+                    #( #attrs )*
+                    pub type #ident = #repr;
+                };
+
+                EnumBuilder::ModuleConsts {
+                    codegen_depth: enum_codegen_depth + 1,
+                    module_name: name,
+                    module_items: vec![type_definition],
+                }
+            }
+        }
+    }
+
+    /// Add a variant to this enum.
+    fn with_variant<'b>(
+        self,
+        ctx: &BindgenContext,
+        variant: &EnumVariant,
+        mangling_prefix: Option<&str>,
+        rust_ty: proc_macro2::TokenStream,
+        result: &mut CodegenResult<'b>,
+        is_ty_named: bool,
+    ) -> Self {
+        let variant_name = ctx.rust_mangle(variant.name());
+        let is_rust_enum = self.is_rust_enum();
+        let expr = match variant.val() {
+            EnumVariantValue::Boolean(v) if is_rust_enum => {
+                helpers::ast_ty::uint_expr(v as u64)
+            }
+            EnumVariantValue::Boolean(v) => quote!(#v),
+            EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v),
+            EnumVariantValue::Unsigned(v) => helpers::ast_ty::uint_expr(v),
+        };
+
+        let mut doc = quote! {};
+        if ctx.options().generate_comments {
+            if let Some(raw_comment) = variant.comment() {
+                let comment =
+                    comment::preprocess(raw_comment, self.codegen_depth());
+                doc = attributes::doc(comment);
+            }
+        }
+
+        match self {
+            EnumBuilder::Rust {
+                attrs,
+                ident,
+                tokens,
+                emitted_any_variants: _,
+                codegen_depth,
+            } => {
+                let name = ctx.rust_ident(variant_name);
+                EnumBuilder::Rust {
+                    attrs,
+                    ident,
+                    codegen_depth,
+                    tokens: quote! {
+                        #tokens
+                        #doc
+                        #name = #expr,
+                    },
+                    emitted_any_variants: true,
+                }
+            }
+
+            EnumBuilder::NewType {
+                canonical_name,
+                is_global,
+                ..
+            } => {
+                if ctx.options().rust_features().associated_const &&
+                    is_ty_named &&
+                    !is_global
+                {
+                    let enum_ident = ctx.rust_ident(canonical_name);
+                    let variant_ident = ctx.rust_ident(variant_name);
+
+                    result.push(quote! {
+                        impl #enum_ident {
+                            #doc
+                            pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
+                        }
+                    });
+                } else {
+                    let ident = ctx.rust_ident(match mangling_prefix {
+                        Some(prefix) => {
+                            Cow::Owned(format!("{}_{}", prefix, variant_name))
+                        }
+                        None => variant_name,
+                    });
+                    result.push(quote! {
+                        #doc
+                        pub const #ident : #rust_ty = #rust_ty ( #expr );
+                    });
+                }
+
+                self
+            }
+
+            EnumBuilder::Consts { .. } => {
+                let constant_name = match mangling_prefix {
+                    Some(prefix) => {
+                        Cow::Owned(format!("{}_{}", prefix, variant_name))
+                    }
+                    None => variant_name,
+                };
+
+                let ident = ctx.rust_ident(constant_name);
+                result.push(quote! {
+                    #doc
+                    pub const #ident : #rust_ty = #expr ;
+                });
+
+                self
+            }
+            EnumBuilder::ModuleConsts {
+                codegen_depth,
+                module_name,
+                mut module_items,
+            } => {
+                let name = ctx.rust_ident(variant_name);
+                let ty = ctx.rust_ident(CONSTIFIED_ENUM_MODULE_REPR_NAME);
+                module_items.push(quote! {
+                    #doc
+                    pub const #name : #ty = #expr ;
+                });
+
+                EnumBuilder::ModuleConsts {
+                    module_name,
+                    module_items,
+                    codegen_depth,
+                }
+            }
+        }
+    }
+
+    fn build<'b>(
+        self,
+        ctx: &BindgenContext,
+        rust_ty: proc_macro2::TokenStream,
+        result: &mut CodegenResult<'b>,
+    ) -> proc_macro2::TokenStream {
+        match self {
+            EnumBuilder::Rust {
+                attrs,
+                ident,
+                tokens,
+                emitted_any_variants,
+                ..
+            } => {
+                let variants = if !emitted_any_variants {
+                    quote!(__bindgen_cannot_repr_c_on_empty_enum = 0)
+                } else {
+                    tokens
+                };
+
+                quote! {
+                    #( #attrs )*
+                    pub enum #ident {
+                        #variants
+                    }
+                }
+            }
+            EnumBuilder::NewType {
+                canonical_name,
+                tokens,
+                is_bitfield,
+                ..
+            } => {
+                if !is_bitfield {
+                    return tokens;
+                }
+
+                let rust_ty_name = ctx.rust_ident_raw(canonical_name);
+                let prefix = ctx.trait_prefix();
+
+                result.push(quote! {
+                    impl ::#prefix::ops::BitOr<#rust_ty> for #rust_ty {
+                        type Output = Self;
+
+                        #[inline]
+                        fn bitor(self, other: Self) -> Self {
+                            #rust_ty_name(self.0 | other.0)
+                        }
+                    }
+                });
+
+                result.push(quote! {
+                    impl ::#prefix::ops::BitOrAssign for #rust_ty {
+                        #[inline]
+                        fn bitor_assign(&mut self, rhs: #rust_ty) {
+                            self.0 |= rhs.0;
+                        }
+                    }
+                });
+
+                result.push(quote! {
+                    impl ::#prefix::ops::BitAnd<#rust_ty> for #rust_ty {
+                        type Output = Self;
+
+                        #[inline]
+                        fn bitand(self, other: Self) -> Self {
+                            #rust_ty_name(self.0 & other.0)
+                        }
+                    }
+                });
+
+                result.push(quote! {
+                    impl ::#prefix::ops::BitAndAssign for #rust_ty {
+                        #[inline]
+                        fn bitand_assign(&mut self, rhs: #rust_ty) {
+                            self.0 &= rhs.0;
+                        }
+                    }
+                });
+
+                tokens
+            }
+            EnumBuilder::Consts { variants, .. } => quote! { #( #variants )* },
+            EnumBuilder::ModuleConsts {
+                module_items,
+                module_name,
+                ..
+            } => {
+                let ident = ctx.rust_ident(module_name);
+                quote! {
+                    pub mod #ident {
+                        #( #module_items )*
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl CodeGenerator for Enum {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug!("<Enum as CodeGenerator>::codegen: item = {:?}", item);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        let name = item.canonical_name(ctx);
+        let ident = ctx.rust_ident(&name);
+        let enum_ty = item.expect_type();
+        let layout = enum_ty.layout(ctx);
+        let variation = self.computed_enum_variation(ctx, item);
+
+        let repr_translated;
+        let repr = match self.repr().map(|repr| ctx.resolve_type(repr)) {
+            Some(repr)
+                if !ctx.options().translate_enum_integer_types &&
+                    !variation.is_rust() =>
+            {
+                repr
+            }
+            repr => {
+                // An enum's integer type is translated to a native Rust
+                // integer type in 3 cases:
+                // * the enum is Rustified and we need a translated type for
+                //   the repr attribute
+                // * the representation couldn't be determined from the C source
+                // * it was explicitly requested as a bindgen option
+
+                let kind = match repr {
+                    Some(repr) => match *repr.canonical_type(ctx).kind() {
+                        TypeKind::Int(int_kind) => int_kind,
+                        _ => panic!("Unexpected type as enum repr"),
+                    },
+                    None => {
+                        warn!(
+                            "Guessing type of enum! Forward declarations of enums \
+                             shouldn't be legal!"
+                        );
+                        IntKind::Int
+                    }
+                };
+
+                let signed = kind.is_signed();
+                let size = layout
+                    .map(|l| l.size)
+                    .or_else(|| kind.known_size())
+                    .unwrap_or(0);
+
+                let translated = match (signed, size) {
+                    (true, 1) => IntKind::I8,
+                    (false, 1) => IntKind::U8,
+                    (true, 2) => IntKind::I16,
+                    (false, 2) => IntKind::U16,
+                    (true, 4) => IntKind::I32,
+                    (false, 4) => IntKind::U32,
+                    (true, 8) => IntKind::I64,
+                    (false, 8) => IntKind::U64,
+                    _ => {
+                        warn!(
+                            "invalid enum decl: signed: {}, size: {}",
+                            signed, size
+                        );
+                        IntKind::I32
+                    }
+                };
+
+                repr_translated =
+                    Type::new(None, None, TypeKind::Int(translated), false);
+                &repr_translated
+            }
+        };
+
+        let mut attrs = vec![];
+
+        // TODO(emilio): Delegate this to the builders?
+        match variation {
+            EnumVariation::Rust { non_exhaustive } => {
+                if non_exhaustive &&
+                    ctx.options().rust_features().non_exhaustive
+                {
+                    attrs.push(attributes::non_exhaustive());
+                } else if non_exhaustive &&
+                    !ctx.options().rust_features().non_exhaustive
+                {
+                    panic!("The rust target you're using doesn't seem to support non_exhaustive enums");
+                }
+            }
+            EnumVariation::NewType { .. } => {
+                if ctx.options().rust_features.repr_transparent {
+                    attrs.push(attributes::repr("transparent"));
+                } else {
+                    attrs.push(attributes::repr("C"));
+                }
+            }
+            _ => {}
+        };
+
+        if let Some(comment) = item.comment(ctx) {
+            attrs.push(attributes::doc(comment));
+        }
+
+        if item.must_use(ctx) {
+            attrs.push(attributes::must_use());
+        }
+
+        if !variation.is_const() {
+            let packed = false; // Enums can't be packed in Rust.
+            let mut derives = derives_of_item(item, ctx, packed);
+            // For backwards compat, enums always derive
+            // Clone/Eq/PartialEq/Hash, even if we don't generate those by
+            // default.
+            derives.insert(
+                DerivableTraits::CLONE |
+                    DerivableTraits::HASH |
+                    DerivableTraits::PARTIAL_EQ |
+                    DerivableTraits::EQ,
+            );
+            let mut derives: Vec<_> = derives.into();
+            for derive in item.annotations().derives().iter() {
+                if !derives.contains(&derive.as_str()) {
+                    derives.push(derive);
+                }
+            }
+
+            // The custom derives callback may return a list of derive attributes;
+            // add them to the end of the list.
+            let custom_derives;
+            if let Some(cb) = &ctx.options().parse_callbacks {
+                custom_derives = cb.add_derives(&name);
+                // In most cases this will be a no-op, since custom_derives will be empty.
+                derives.extend(custom_derives.iter().map(|s| s.as_str()));
+            };
+
+            attrs.push(attributes::derives(&derives));
+        }
+
+        fn add_constant<'a>(
+            ctx: &BindgenContext,
+            enum_: &Type,
+            // Only to avoid recomputing every time.
+            enum_canonical_name: &Ident,
+            // May be the same as "variant" if it's because the
+            // enum is unnamed and we still haven't seen the
+            // value.
+            variant_name: &Ident,
+            referenced_name: &Ident,
+            enum_rust_ty: proc_macro2::TokenStream,
+            result: &mut CodegenResult<'a>,
+        ) {
+            let constant_name = if enum_.name().is_some() {
+                if ctx.options().prepend_enum_name {
+                    format!("{}_{}", enum_canonical_name, variant_name)
+                } else {
+                    format!("{}", variant_name)
+                }
+            } else {
+                format!("{}", variant_name)
+            };
+            let constant_name = ctx.rust_ident(constant_name);
+
+            result.push(quote! {
+                pub const #constant_name : #enum_rust_ty =
+                    #enum_canonical_name :: #referenced_name ;
+            });
+        }
+
+        let repr = repr.to_rust_ty_or_opaque(ctx, item);
+
+        let mut builder = EnumBuilder::new(
+            &name,
+            attrs,
+            repr,
+            variation,
+            item.codegen_depth(ctx),
+        );
+
+        // A map where we keep a value -> variant relation.
+        let mut seen_values = HashMap::<_, Ident>::default();
+        let enum_rust_ty = item.to_rust_ty_or_opaque(ctx, &());
+        let is_toplevel = item.is_toplevel(ctx);
+
+        // Used to mangle the constants we generate in the unnamed-enum case.
+        let parent_canonical_name = if is_toplevel {
+            None
+        } else {
+            Some(item.parent_id().canonical_name(ctx))
+        };
+
+        let constant_mangling_prefix = if ctx.options().prepend_enum_name {
+            if enum_ty.name().is_none() {
+                parent_canonical_name.as_deref()
+            } else {
+                Some(&*name)
+            }
+        } else {
+            None
+        };
+
+        // NB: We defer the creation of constified variants, in case we find
+        // another variant with the same value (which is the common thing to
+        // do).
+        let mut constified_variants = VecDeque::new();
+
+        let mut iter = self.variants().iter().peekable();
+        while let Some(variant) =
+            iter.next().or_else(|| constified_variants.pop_front())
+        {
+            if variant.hidden() {
+                continue;
+            }
+
+            if variant.force_constification() && iter.peek().is_some() {
+                constified_variants.push_back(variant);
+                continue;
+            }
+
+            match seen_values.entry(variant.val()) {
+                Entry::Occupied(ref entry) => {
+                    if variation.is_rust() {
+                        let variant_name = ctx.rust_mangle(variant.name());
+                        let mangled_name =
+                            if is_toplevel || enum_ty.name().is_some() {
+                                variant_name
+                            } else {
+                                let parent_name =
+                                    parent_canonical_name.as_ref().unwrap();
+
+                                Cow::Owned(format!(
+                                    "{}_{}",
+                                    parent_name, variant_name
+                                ))
+                            };
+
+                        let existing_variant_name = entry.get();
+                        // Use associated constants for named enums.
+                        if enum_ty.name().is_some() &&
+                            ctx.options().rust_features().associated_const
+                        {
+                            let enum_canonical_name = &ident;
+                            let variant_name =
+                                ctx.rust_ident_raw(&*mangled_name);
+                            result.push(quote! {
+                                impl #enum_rust_ty {
+                                    pub const #variant_name : #enum_rust_ty =
+                                        #enum_canonical_name :: #existing_variant_name ;
+                                }
+                            });
+                        } else {
+                            add_constant(
+                                ctx,
+                                enum_ty,
+                                &ident,
+                                &Ident::new(&mangled_name, Span::call_site()),
+                                existing_variant_name,
+                                enum_rust_ty.clone(),
+                                result,
+                            );
+                        }
+                    } else {
+                        builder = builder.with_variant(
+                            ctx,
+                            variant,
+                            constant_mangling_prefix,
+                            enum_rust_ty.clone(),
+                            result,
+                            enum_ty.name().is_some(),
+                        );
+                    }
+                }
+                Entry::Vacant(entry) => {
+                    builder = builder.with_variant(
+                        ctx,
+                        variant,
+                        constant_mangling_prefix,
+                        enum_rust_ty.clone(),
+                        result,
+                        enum_ty.name().is_some(),
+                    );
+
+                    let variant_name = ctx.rust_ident(variant.name());
+
+                    // If it's an unnamed enum, or constification is enforced,
+                    // we also generate a constant so it can be properly
+                    // accessed.
+                    if (variation.is_rust() && enum_ty.name().is_none()) ||
+                        variant.force_constification()
+                    {
+                        let mangled_name = if is_toplevel {
+                            variant_name.clone()
+                        } else {
+                            let parent_name =
+                                parent_canonical_name.as_ref().unwrap();
+
+                            Ident::new(
+                                &format!("{}_{}", parent_name, variant_name),
+                                Span::call_site(),
+                            )
+                        };
+
+                        add_constant(
+                            ctx,
+                            enum_ty,
+                            &ident,
+                            &mangled_name,
+                            &variant_name,
+                            enum_rust_ty.clone(),
+                            result,
+                        );
+                    }
+
+                    entry.insert(variant_name);
+                }
+            }
+        }
+
+        let item = builder.build(ctx, enum_rust_ty, result);
+        result.push(item);
+    }
+}
+
+/// Enum for the default type of macro constants.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum MacroTypeVariation {
+    /// Use i32 or i64
+    Signed,
+    /// Use u32 or u64
+    Unsigned,
+}
+
+impl MacroTypeVariation {
+    /// Convert a `MacroTypeVariation` to its str representation.
+    pub fn as_str(&self) -> &str {
+        match self {
+            MacroTypeVariation::Signed => "signed",
+            MacroTypeVariation::Unsigned => "unsigned",
+        }
+    }
+}
+
+impl Default for MacroTypeVariation {
+    fn default() -> MacroTypeVariation {
+        MacroTypeVariation::Unsigned
+    }
+}
+
+impl std::str::FromStr for MacroTypeVariation {
+    type Err = std::io::Error;
+
+    /// Create a `MacroTypeVariation` from a string.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "signed" => Ok(MacroTypeVariation::Signed),
+            "unsigned" => Ok(MacroTypeVariation::Unsigned),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid MacroTypeVariation. Accepted values ",
+                    "are 'signed' and 'unsigned'"
+                ),
+            )),
+        }
+    }
+}
+
+/// Enum for how aliases should be translated.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum AliasVariation {
+    /// Convert to regular Rust alias
+    TypeAlias,
+    /// Create a new type by wrapping the old type in a struct and using #[repr(transparent)]
+    NewType,
+    /// Same as NewStruct but also impl Deref to be able to use the methods of the wrapped type
+    NewTypeDeref,
+}
+
+impl AliasVariation {
+    /// Convert an `AliasVariation` to its str representation.
+    pub fn as_str(&self) -> &str {
+        match self {
+            AliasVariation::TypeAlias => "type_alias",
+            AliasVariation::NewType => "new_type",
+            AliasVariation::NewTypeDeref => "new_type_deref",
+        }
+    }
+}
+
+impl Default for AliasVariation {
+    fn default() -> AliasVariation {
+        AliasVariation::TypeAlias
+    }
+}
+
+impl std::str::FromStr for AliasVariation {
+    type Err = std::io::Error;
+
+    /// Create an `AliasVariation` from a string.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "type_alias" => Ok(AliasVariation::TypeAlias),
+            "new_type" => Ok(AliasVariation::NewType),
+            "new_type_deref" => Ok(AliasVariation::NewTypeDeref),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid AliasVariation. Accepted values ",
+                    "are 'type_alias', 'new_type', and 'new_type_deref'"
+                ),
+            )),
+        }
+    }
+}
+
+/// Enum for how non-Copy unions should be translated.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum NonCopyUnionStyle {
+    /// Wrap members in a type generated by bindgen.
+    BindgenWrapper,
+    /// Wrap members in [`::core::mem::ManuallyDrop`].
+    ///
+    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
+    /// MSRV is lower.
+    ManuallyDrop,
+}
+
+impl NonCopyUnionStyle {
+    /// Convert an `NonCopyUnionStyle` to its str representation.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::BindgenWrapper => "bindgen_wrapper",
+            Self::ManuallyDrop => "manually_drop",
+        }
+    }
+}
+
+impl Default for NonCopyUnionStyle {
+    fn default() -> Self {
+        Self::BindgenWrapper
+    }
+}
+
+impl std::str::FromStr for NonCopyUnionStyle {
+    type Err = std::io::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "bindgen_wrapper" => Ok(Self::BindgenWrapper),
+            "manually_drop" => Ok(Self::ManuallyDrop),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                concat!(
+                    "Got an invalid NonCopyUnionStyle. Accepted values ",
+                    "are 'bindgen_wrapper' and 'manually_drop'"
+                ),
+            )),
+        }
+    }
+}
+
+/// Fallible conversion to an opaque blob.
+///
+/// Implementors of this trait should provide the `try_get_layout` method to
+/// fallibly get this thing's layout, which the provided `try_to_opaque` trait
+/// method will use to convert the `Layout` into an opaque blob Rust type.
+trait TryToOpaque {
+    type Extra;
+
+    /// Get the layout for this thing, if one is available.
+    fn try_get_layout(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> error::Result<Layout>;
+
+    /// Do not override this provided trait method.
+    fn try_to_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> error::Result<proc_macro2::TokenStream> {
+        self.try_get_layout(ctx, extra)
+            .map(|layout| helpers::blob(ctx, layout))
+    }
+}
+
+/// Infallible conversion of an IR thing to an opaque blob.
+///
+/// The resulting layout is best effort, and is unfortunately not guaranteed to
+/// be correct. When all else fails, we fall back to a single byte layout as a
+/// last resort, because C++ does not permit zero-sized types. See the note in
+/// the `ToRustTyOrOpaque` doc comment about fallible versus infallible traits
+/// and when each is appropriate.
+///
+/// Don't implement this directly. Instead implement `TryToOpaque`, and then
+/// leverage the blanket impl for this trait.
+trait ToOpaque: TryToOpaque {
+    fn get_layout(&self, ctx: &BindgenContext, extra: &Self::Extra) -> Layout {
+        self.try_get_layout(ctx, extra)
+            .unwrap_or_else(|_| Layout::for_size(ctx, 1))
+    }
+
+    fn to_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> proc_macro2::TokenStream {
+        let layout = self.get_layout(ctx, extra);
+        helpers::blob(ctx, layout)
+    }
+}
+
+impl<T> ToOpaque for T where T: TryToOpaque {}
+
+/// Fallible conversion from an IR thing to an *equivalent* Rust type.
+///
+/// If the C/C++ construct represented by the IR thing cannot (currently) be
+/// represented in Rust (for example, instantiations of templates with
+/// const-value generic parameters) then the impl should return an `Err`. It
+/// should *not* attempt to return an opaque blob with the correct size and
+/// alignment. That is the responsibility of the `TryToOpaque` trait.
+trait TryToRustTy {
+    type Extra;
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> error::Result<proc_macro2::TokenStream>;
+}
+
+/// Fallible conversion to a Rust type or an opaque blob with the correct size
+/// and alignment.
+///
+/// Don't implement this directly. Instead implement `TryToRustTy` and
+/// `TryToOpaque`, and then leverage the blanket impl for this trait below.
+trait TryToRustTyOrOpaque: TryToRustTy + TryToOpaque {
+    type Extra;
+
+    fn try_to_rust_ty_or_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &<Self as TryToRustTyOrOpaque>::Extra,
+    ) -> error::Result<proc_macro2::TokenStream>;
+}
+
+impl<E, T> TryToRustTyOrOpaque for T
+where
+    T: TryToRustTy<Extra = E> + TryToOpaque<Extra = E>,
+{
+    type Extra = E;
+
+    fn try_to_rust_ty_or_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &E,
+    ) -> error::Result<proc_macro2::TokenStream> {
+        self.try_to_rust_ty(ctx, extra).or_else(|_| {
+            if let Ok(layout) = self.try_get_layout(ctx, extra) {
+                Ok(helpers::blob(ctx, layout))
+            } else {
+                Err(error::Error::NoLayoutForOpaqueBlob)
+            }
+        })
+    }
+}
+
+/// Infallible conversion to a Rust type, or an opaque blob with a best effort
+/// of correct size and alignment.
+///
+/// Don't implement this directly. Instead implement `TryToRustTy` and
+/// `TryToOpaque`, and then leverage the blanket impl for this trait below.
+///
+/// ### Fallible vs. Infallible Conversions to Rust Types
+///
+/// When should one use this infallible `ToRustTyOrOpaque` trait versus the
+/// fallible `TryTo{RustTy, Opaque, RustTyOrOpaque}` triats? All fallible trait
+/// implementations that need to convert another thing into a Rust type or
+/// opaque blob in a nested manner should also use fallible trait methods and
+/// propagate failure up the stack. Only infallible functions and methods like
+/// CodeGenerator implementations should use the infallible
+/// `ToRustTyOrOpaque`. The further out we push error recovery, the more likely
+/// we are to get a usable `Layout` even if we can't generate an equivalent Rust
+/// type for a C++ construct.
+trait ToRustTyOrOpaque: TryToRustTy + ToOpaque {
+    type Extra;
+
+    fn to_rust_ty_or_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &<Self as ToRustTyOrOpaque>::Extra,
+    ) -> proc_macro2::TokenStream;
+}
+
+impl<E, T> ToRustTyOrOpaque for T
+where
+    T: TryToRustTy<Extra = E> + ToOpaque<Extra = E>,
+{
+    type Extra = E;
+
+    fn to_rust_ty_or_opaque(
+        &self,
+        ctx: &BindgenContext,
+        extra: &E,
+    ) -> proc_macro2::TokenStream {
+        self.try_to_rust_ty(ctx, extra)
+            .unwrap_or_else(|_| self.to_opaque(ctx, extra))
+    }
+}
+
+impl<T> TryToOpaque for T
+where
+    T: Copy + Into<ItemId>,
+{
+    type Extra = ();
+
+    fn try_get_layout(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<Layout> {
+        ctx.resolve_item((*self).into()).try_get_layout(ctx, &())
+    }
+}
+
+impl<T> TryToRustTy for T
+where
+    T: Copy + Into<ItemId>,
+{
+    type Extra = ();
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<proc_macro2::TokenStream> {
+        ctx.resolve_item((*self).into()).try_to_rust_ty(ctx, &())
+    }
+}
+
+impl TryToOpaque for Item {
+    type Extra = ();
+
+    fn try_get_layout(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<Layout> {
+        self.kind().expect_type().try_get_layout(ctx, self)
+    }
+}
+
+impl TryToRustTy for Item {
+    type Extra = ();
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<proc_macro2::TokenStream> {
+        self.kind().expect_type().try_to_rust_ty(ctx, self)
+    }
+}
+
+impl TryToOpaque for Type {
+    type Extra = Item;
+
+    fn try_get_layout(
+        &self,
+        ctx: &BindgenContext,
+        _: &Item,
+    ) -> error::Result<Layout> {
+        self.layout(ctx).ok_or(error::Error::NoLayoutForOpaqueBlob)
+    }
+}
+
+impl TryToRustTy for Type {
+    type Extra = Item;
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> error::Result<proc_macro2::TokenStream> {
+        use self::helpers::ast_ty::*;
+
+        match *self.kind() {
+            TypeKind::Void => Ok(c_void(ctx)),
+            // TODO: we should do something smart with nullptr, or maybe *const
+            // c_void is enough?
+            TypeKind::NullPtr => Ok(c_void(ctx).to_ptr(true)),
+            TypeKind::Int(ik) => {
+                match ik {
+                    IntKind::Bool => Ok(quote! { bool }),
+                    IntKind::Char { .. } => Ok(raw_type(ctx, "c_char")),
+                    IntKind::SChar => Ok(raw_type(ctx, "c_schar")),
+                    IntKind::UChar => Ok(raw_type(ctx, "c_uchar")),
+                    IntKind::Short => Ok(raw_type(ctx, "c_short")),
+                    IntKind::UShort => Ok(raw_type(ctx, "c_ushort")),
+                    IntKind::Int => Ok(raw_type(ctx, "c_int")),
+                    IntKind::UInt => Ok(raw_type(ctx, "c_uint")),
+                    IntKind::Long => Ok(raw_type(ctx, "c_long")),
+                    IntKind::ULong => Ok(raw_type(ctx, "c_ulong")),
+                    IntKind::LongLong => Ok(raw_type(ctx, "c_longlong")),
+                    IntKind::ULongLong => Ok(raw_type(ctx, "c_ulonglong")),
+                    IntKind::WChar => {
+                        let layout = self
+                            .layout(ctx)
+                            .expect("Couldn't compute wchar_t's layout?");
+                        let ty = Layout::known_type_for_size(ctx, layout.size)
+                            .expect("Non-representable wchar_t?");
+                        let ident = ctx.rust_ident_raw(ty);
+                        Ok(quote! { #ident })
+                    }
+
+                    IntKind::I8 => Ok(quote! { i8 }),
+                    IntKind::U8 => Ok(quote! { u8 }),
+                    IntKind::I16 => Ok(quote! { i16 }),
+                    IntKind::U16 => Ok(quote! { u16 }),
+                    IntKind::I32 => Ok(quote! { i32 }),
+                    IntKind::U32 => Ok(quote! { u32 }),
+                    IntKind::I64 => Ok(quote! { i64 }),
+                    IntKind::U64 => Ok(quote! { u64 }),
+                    IntKind::Custom { name, .. } => {
+                        Ok(proc_macro2::TokenStream::from_str(name).unwrap())
+                    }
+                    IntKind::U128 => {
+                        Ok(if ctx.options().rust_features.i128_and_u128 {
+                            quote! { u128 }
+                        } else {
+                            // Best effort thing, but wrong alignment
+                            // unfortunately.
+                            quote! { [u64; 2] }
+                        })
+                    }
+                    IntKind::I128 => {
+                        Ok(if ctx.options().rust_features.i128_and_u128 {
+                            quote! { i128 }
+                        } else {
+                            quote! { [u64; 2] }
+                        })
+                    }
+                }
+            }
+            TypeKind::Float(fk) => {
+                Ok(float_kind_rust_type(ctx, fk, self.layout(ctx)))
+            }
+            TypeKind::Complex(fk) => {
+                let float_path =
+                    float_kind_rust_type(ctx, fk, self.layout(ctx));
+
+                ctx.generated_bindgen_complex();
+                Ok(if ctx.options().enable_cxx_namespaces {
+                    quote! {
+                        root::__BindgenComplex<#float_path>
+                    }
+                } else {
+                    quote! {
+                        __BindgenComplex<#float_path>
+                    }
+                })
+            }
+            TypeKind::Function(ref fs) => {
+                // We can't rely on the sizeof(Option<NonZero<_>>) ==
+                // sizeof(NonZero<_>) optimization with opaque blobs (because
+                // they aren't NonZero), so don't *ever* use an or_opaque
+                // variant here.
+                let ty = fs.try_to_rust_ty(ctx, &())?;
+
+                let prefix = ctx.trait_prefix();
+                Ok(quote! {
+                    ::#prefix::option::Option<#ty>
+                })
+            }
+            TypeKind::Array(item, len) | TypeKind::Vector(item, len) => {
+                let ty = item.try_to_rust_ty(ctx, &())?;
+                Ok(quote! {
+                    [ #ty ; #len ]
+                })
+            }
+            TypeKind::Enum(..) => {
+                let path = item.namespace_aware_canonical_path(ctx);
+                let path = proc_macro2::TokenStream::from_str(&path.join("::"))
+                    .unwrap();
+                Ok(quote!(#path))
+            }
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.try_to_rust_ty(ctx, item)
+            }
+            TypeKind::ResolvedTypeRef(inner) => inner.try_to_rust_ty(ctx, &()),
+            TypeKind::TemplateAlias(..) |
+            TypeKind::Alias(..) |
+            TypeKind::BlockPointer(..) => {
+                if self.is_block_pointer() && !ctx.options().generate_block {
+                    let void = c_void(ctx);
+                    return Ok(void.to_ptr(/* is_const = */ false));
+                }
+
+                if item.is_opaque(ctx, &()) &&
+                    item.used_template_params(ctx)
+                        .into_iter()
+                        .any(|param| param.is_template_param(ctx, &()))
+                {
+                    self.try_to_opaque(ctx, item)
+                } else if let Some(ty) = self
+                    .name()
+                    .and_then(|name| utils::type_from_named(ctx, name))
+                {
+                    Ok(ty)
+                } else {
+                    utils::build_path(item, ctx)
+                }
+            }
+            TypeKind::Comp(ref info) => {
+                let template_params = item.all_template_params(ctx);
+                if info.has_non_type_template_params() ||
+                    (item.is_opaque(ctx, &()) && !template_params.is_empty())
+                {
+                    return self.try_to_opaque(ctx, item);
+                }
+
+                utils::build_path(item, ctx)
+            }
+            TypeKind::Opaque => self.try_to_opaque(ctx, item),
+            TypeKind::Pointer(inner) | TypeKind::Reference(inner) => {
+                let is_const = ctx.resolve_type(inner).is_const();
+
+                let inner =
+                    inner.into_resolver().through_type_refs().resolve(ctx);
+                let inner_ty = inner.expect_type();
+
+                let is_objc_pointer =
+                    matches!(inner_ty.kind(), TypeKind::ObjCInterface(..));
+
+                // Regardless if we can properly represent the inner type, we
+                // should always generate a proper pointer here, so use
+                // infallible conversion of the inner type.
+                let mut ty = inner.to_rust_ty_or_opaque(ctx, &());
+                ty.append_implicit_template_params(ctx, inner);
+
+                // Avoid the first function pointer level, since it's already
+                // represented in Rust.
+                if inner_ty.canonical_type(ctx).is_function() || is_objc_pointer
+                {
+                    Ok(ty)
+                } else {
+                    Ok(ty.to_ptr(is_const))
+                }
+            }
+            TypeKind::TypeParam => {
+                let name = item.canonical_name(ctx);
+                let ident = ctx.rust_ident(&name);
+                Ok(quote! {
+                    #ident
+                })
+            }
+            TypeKind::ObjCSel => Ok(quote! {
+                objc::runtime::Sel
+            }),
+            TypeKind::ObjCId => Ok(quote! {
+                id
+            }),
+            TypeKind::ObjCInterface(ref interface) => {
+                let name = ctx.rust_ident(interface.name());
+                Ok(quote! {
+                    #name
+                })
+            }
+            ref u @ TypeKind::UnresolvedTypeRef(..) => {
+                unreachable!("Should have been resolved after parsing {:?}!", u)
+            }
+        }
+    }
+}
+
+impl TryToOpaque for TemplateInstantiation {
+    type Extra = Item;
+
+    fn try_get_layout(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> error::Result<Layout> {
+        item.expect_type()
+            .layout(ctx)
+            .ok_or(error::Error::NoLayoutForOpaqueBlob)
+    }
+}
+
+impl TryToRustTy for TemplateInstantiation {
+    type Extra = Item;
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> error::Result<proc_macro2::TokenStream> {
+        if self.is_opaque(ctx, item) {
+            return Err(error::Error::InstantiationOfOpaqueType);
+        }
+
+        let def = self
+            .template_definition()
+            .into_resolver()
+            .through_type_refs()
+            .resolve(ctx);
+
+        let mut ty = quote! {};
+        let def_path = def.namespace_aware_canonical_path(ctx);
+        ty.append_separated(
+            def_path.into_iter().map(|p| ctx.rust_ident(p)),
+            quote!(::),
+        );
+
+        let def_params = def.self_template_params(ctx);
+        if def_params.is_empty() {
+            // This can happen if we generated an opaque type for a partial
+            // template specialization, and we've hit an instantiation of
+            // that partial specialization.
+            extra_assert!(def.is_opaque(ctx, &()));
+            return Err(error::Error::InstantiationOfOpaqueType);
+        }
+
+        // TODO: If the definition type is a template class/struct
+        // definition's member template definition, it could rely on
+        // generic template parameters from its outer template
+        // class/struct. When we emit bindings for it, it could require
+        // *more* type arguments than we have here, and we will need to
+        // reconstruct them somehow. We don't have any means of doing
+        // that reconstruction at this time.
+
+        let template_args = self
+            .template_arguments()
+            .iter()
+            .zip(def_params.iter())
+            // Only pass type arguments for the type parameters that
+            // the def uses.
+            .filter(|&(_, param)| ctx.uses_template_parameter(def.id(), *param))
+            .map(|(arg, _)| {
+                let arg = arg.into_resolver().through_type_refs().resolve(ctx);
+                let mut ty = arg.try_to_rust_ty(ctx, &())?;
+                ty.append_implicit_template_params(ctx, arg);
+                Ok(ty)
+            })
+            .collect::<error::Result<Vec<_>>>()?;
+
+        if template_args.is_empty() {
+            return Ok(ty);
+        }
+
+        Ok(quote! {
+            #ty < #( #template_args ),* >
+        })
+    }
+}
+
+impl TryToRustTy for FunctionSig {
+    type Extra = ();
+
+    fn try_to_rust_ty(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> error::Result<proc_macro2::TokenStream> {
+        // TODO: we might want to consider ignoring the reference return value.
+        let ret = utils::fnsig_return_ty(ctx, self);
+        let arguments = utils::fnsig_arguments(ctx, self);
+        let abi = self.abi();
+
+        match abi {
+            Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => {
+                warn!("Skipping function with thiscall ABI that isn't supported by the configured Rust target");
+                Ok(proc_macro2::TokenStream::new())
+            }
+            Abi::Vectorcall
+                if !ctx.options().rust_features().vectorcall_abi =>
+            {
+                warn!("Skipping function with vectorcall ABI that isn't supported by the configured Rust target");
+                Ok(proc_macro2::TokenStream::new())
+            }
+            _ => Ok(quote! {
+                unsafe extern #abi fn ( #( #arguments ),* ) #ret
+            }),
+        }
+    }
+}
+
+impl CodeGenerator for Function {
+    type Extra = Item;
+
+    /// If we've actually generated the symbol, the number of times we've seen
+    /// it.
+    type Return = Option<u32>;
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) -> Self::Return {
+        debug!("<Function as CodeGenerator>::codegen: item = {:?}", item);
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        // We can't currently do anything with Internal functions so just
+        // avoid generating anything for them.
+        match self.linkage() {
+            Linkage::Internal => return None,
+            Linkage::External => {}
+        }
+
+        // Pure virtual methods have no actual symbol, so we can't generate
+        // something meaningful for them.
+        let is_dynamic_function = match self.kind() {
+            FunctionKind::Method(ref method_kind)
+                if method_kind.is_pure_virtual() =>
+            {
+                return None;
+            }
+            FunctionKind::Function => {
+                ctx.options().dynamic_library_name.is_some()
+            }
+            _ => false,
+        };
+
+        // Similar to static member variables in a class template, we can't
+        // generate bindings to template functions, because the set of
+        // instantiations is open ended and we have no way of knowing which
+        // monomorphizations actually exist.
+        if !item.all_template_params(ctx).is_empty() {
+            return None;
+        }
+
+        let name = self.name();
+        let mut canonical_name = item.canonical_name(ctx);
+        let mangled_name = self.mangled_name();
+
+        {
+            let seen_symbol_name = mangled_name.unwrap_or(&canonical_name);
+
+            // TODO: Maybe warn here if there's a type/argument mismatch, or
+            // something?
+            if result.seen_function(seen_symbol_name) {
+                return None;
+            }
+            result.saw_function(seen_symbol_name);
+        }
+
+        let signature_item = ctx.resolve_item(self.signature());
+        let signature = signature_item.kind().expect_type().canonical_type(ctx);
+        let signature = match *signature.kind() {
+            TypeKind::Function(ref sig) => sig,
+            _ => panic!("Signature kind is not a Function: {:?}", signature),
+        };
+
+        let args = utils::fnsig_arguments(ctx, signature);
+        let ret = utils::fnsig_return_ty(ctx, signature);
+
+        let mut attributes = vec![];
+
+        if ctx.options().rust_features().must_use_function {
+            let must_use = signature.must_use() || {
+                let ret_ty = signature
+                    .return_type()
+                    .into_resolver()
+                    .through_type_refs()
+                    .resolve(ctx);
+                ret_ty.must_use(ctx)
+            };
+
+            if must_use {
+                attributes.push(attributes::must_use());
+            }
+        }
+
+        if let Some(comment) = item.comment(ctx) {
+            attributes.push(attributes::doc(comment));
+        }
+
+        let abi = match signature.abi() {
+            Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => {
+                warn!("Skipping function with thiscall ABI that isn't supported by the configured Rust target");
+                return None;
+            }
+            Abi::Vectorcall
+                if !ctx.options().rust_features().vectorcall_abi =>
+            {
+                warn!("Skipping function with vectorcall ABI that isn't supported by the configured Rust target");
+                return None;
+            }
+            Abi::Win64 if signature.is_variadic() => {
+                warn!("Skipping variadic function with Win64 ABI that isn't supported");
+                return None;
+            }
+            Abi::Unknown(unknown_abi) => {
+                panic!(
+                    "Invalid or unknown abi {:?} for function {:?} ({:?})",
+                    unknown_abi, canonical_name, self
+                );
+            }
+            abi => abi,
+        };
+
+        // Handle overloaded functions by giving each overload its own unique
+        // suffix.
+        let times_seen = result.overload_number(&canonical_name);
+        if times_seen > 0 {
+            write!(&mut canonical_name, "{}", times_seen).unwrap();
+        }
+
+        let link_name = mangled_name.unwrap_or(name);
+        if !is_dynamic_function &&
+            !utils::names_will_be_identical_after_mangling(
+                &canonical_name,
+                link_name,
+                Some(abi),
+            )
+        {
+            attributes.push(attributes::link_name(link_name));
+        }
+
+        // Unfortunately this can't piggyback on the `attributes` list because
+        // the #[link(wasm_import_module)] needs to happen before the `extern
+        // "C"` block. It doesn't get picked up properly otherwise
+        let wasm_link_attribute =
+            ctx.options().wasm_import_module_name.as_ref().map(|name| {
+                quote! { #[link(wasm_import_module = #name)] }
+            });
+
+        let ident = ctx.rust_ident(canonical_name);
+        let tokens = quote! {
+            #wasm_link_attribute
+            extern #abi {
+                #(#attributes)*
+                pub fn #ident ( #( #args ),* ) #ret;
+            }
+        };
+
+        // If we're doing dynamic binding generation, add to the dynamic items.
+        if is_dynamic_function {
+            let args_identifiers =
+                utils::fnsig_argument_identifiers(ctx, signature);
+            let return_item = ctx.resolve_item(signature.return_type());
+            let ret_ty = match *return_item.kind().expect_type().kind() {
+                TypeKind::Void => quote! {()},
+                _ => return_item.to_rust_ty_or_opaque(ctx, &()),
+            };
+            result.dynamic_items().push(
+                ident,
+                abi,
+                signature.is_variadic(),
+                ctx.options().dynamic_link_require_all,
+                args,
+                args_identifiers,
+                ret,
+                ret_ty,
+                attributes,
+            );
+        } else {
+            result.push(tokens);
+        }
+        Some(times_seen)
+    }
+}
+
+fn objc_method_codegen(
+    ctx: &BindgenContext,
+    method: &ObjCMethod,
+    methods: &mut Vec<proc_macro2::TokenStream>,
+    class_name: Option<&str>,
+    rust_class_name: &str,
+    prefix: &str,
+) {
+    // This would ideally resolve the method into an Item, and use
+    // Item::process_before_codegen; however, ObjC methods are not currently
+    // made into function items.
+    let name = format!("{}::{}{}", rust_class_name, prefix, method.rust_name());
+    if ctx.options().blocklisted_items.matches(name) {
+        return;
+    }
+
+    let signature = method.signature();
+    let fn_args = utils::fnsig_arguments(ctx, signature);
+    let fn_ret = utils::fnsig_return_ty(ctx, signature);
+
+    let sig = if method.is_class_method() {
+        let fn_args = fn_args.clone();
+        quote! {
+            ( #( #fn_args ),* ) #fn_ret
+        }
+    } else {
+        let fn_args = fn_args.clone();
+        let args = iter::once(quote! { &self }).chain(fn_args.into_iter());
+        quote! {
+            ( #( #args ),* ) #fn_ret
+        }
+    };
+
+    let methods_and_args = method.format_method_call(&fn_args);
+
+    let body = if method.is_class_method() {
+        let class_name = ctx.rust_ident(
+            class_name.expect("Generating a class method without class name?"),
+        );
+        quote! {
+            msg_send!(class!(#class_name), #methods_and_args)
+        }
+    } else {
+        quote! {
+            msg_send!(*self, #methods_and_args)
+        }
+    };
+
+    let method_name =
+        ctx.rust_ident(format!("{}{}", prefix, method.rust_name()));
+
+    methods.push(quote! {
+        unsafe fn #method_name #sig where <Self as std::ops::Deref>::Target: objc::Message + Sized {
+            #body
+        }
+    });
+}
+
+impl CodeGenerator for ObjCInterface {
+    type Extra = Item;
+    type Return = ();
+
+    fn codegen<'a>(
+        &self,
+        ctx: &BindgenContext,
+        result: &mut CodegenResult<'a>,
+        item: &Item,
+    ) {
+        debug_assert!(item.is_enabled_for_codegen(ctx));
+
+        let mut impl_items = vec![];
+        let rust_class_name = item.path_for_allowlisting(ctx)[1..].join("::");
+
+        for method in self.methods() {
+            objc_method_codegen(
+                ctx,
+                method,
+                &mut impl_items,
+                None,
+                &rust_class_name,
+                "",
+            );
+        }
+
+        for class_method in self.class_methods() {
+            let ambiquity = self
+                .methods()
+                .iter()
+                .map(|m| m.rust_name())
+                .any(|x| x == class_method.rust_name());
+            let prefix = if ambiquity { "class_" } else { "" };
+            objc_method_codegen(
+                ctx,
+                class_method,
+                &mut impl_items,
+                Some(self.name()),
+                &rust_class_name,
+                prefix,
+            );
+        }
+
+        let trait_name = ctx.rust_ident(self.rust_name());
+        let trait_constraints = quote! {
+            Sized + std::ops::Deref
+        };
+        let trait_block = if self.is_template() {
+            let template_names: Vec<Ident> = self
+                .template_names
+                .iter()
+                .map(|g| ctx.rust_ident(g))
+                .collect();
+
+            quote! {
+                pub trait #trait_name <#(#template_names:'static),*> : #trait_constraints {
+                    #( #impl_items )*
+                }
+            }
+        } else {
+            quote! {
+                pub trait #trait_name : #trait_constraints {
+                    #( #impl_items )*
+                }
+            }
+        };
+
+        let class_name = ctx.rust_ident(self.name());
+        if !self.is_category() && !self.is_protocol() {
+            let struct_block = quote! {
+                #[repr(transparent)]
+                #[derive(Debug, Copy, Clone)]
+                pub struct #class_name(pub id);
+                impl std::ops::Deref for #class_name {
+                    type Target = objc::runtime::Object;
+                    fn deref(&self) -> &Self::Target {
+                        unsafe {
+                            &*self.0
+                        }
+                    }
+                }
+                unsafe impl objc::Message for #class_name { }
+                impl #class_name {
+                    pub fn alloc() -> Self {
+                        Self(unsafe {
+                            msg_send!(class!(#class_name), alloc)
+                        })
+                    }
+                }
+            };
+            result.push(struct_block);
+            let mut protocol_set: HashSet<ItemId> = Default::default();
+            for protocol_id in self.conforms_to.iter() {
+                protocol_set.insert(*protocol_id);
+                let protocol_name = ctx.rust_ident(
+                    ctx.resolve_type(protocol_id.expect_type_id(ctx))
+                        .name()
+                        .unwrap(),
+                );
+                let impl_trait = quote! {
+                    impl #protocol_name for #class_name { }
+                };
+                result.push(impl_trait);
+            }
+            let mut parent_class = self.parent_class;
+            while let Some(parent_id) = parent_class {
+                let parent = parent_id
+                    .expect_type_id(ctx)
+                    .into_resolver()
+                    .through_type_refs()
+                    .resolve(ctx)
+                    .expect_type()
+                    .kind();
+
+                let parent = match parent {
+                    TypeKind::ObjCInterface(ref parent) => parent,
+                    _ => break,
+                };
+                parent_class = parent.parent_class;
+
+                let parent_name = ctx.rust_ident(parent.rust_name());
+                let impl_trait = if parent.is_template() {
+                    let template_names: Vec<Ident> = parent
+                        .template_names
+                        .iter()
+                        .map(|g| ctx.rust_ident(g))
+                        .collect();
+                    quote! {
+                        impl <#(#template_names :'static),*> #parent_name <#(#template_names),*> for #class_name {
+                        }
+                    }
+                } else {
+                    quote! {
+                        impl #parent_name for #class_name { }
+                    }
+                };
+                result.push(impl_trait);
+                for protocol_id in parent.conforms_to.iter() {
+                    if protocol_set.insert(*protocol_id) {
+                        let protocol_name = ctx.rust_ident(
+                            ctx.resolve_type(protocol_id.expect_type_id(ctx))
+                                .name()
+                                .unwrap(),
+                        );
+                        let impl_trait = quote! {
+                            impl #protocol_name for #class_name { }
+                        };
+                        result.push(impl_trait);
+                    }
+                }
+                if !parent.is_template() {
+                    let parent_struct_name = parent.name();
+                    let child_struct_name = self.name();
+                    let parent_struct = ctx.rust_ident(parent_struct_name);
+                    let from_block = quote! {
+                        impl From<#class_name> for #parent_struct {
+                            fn from(child: #class_name) -> #parent_struct {
+                                #parent_struct(child.0)
+                            }
+                        }
+                    };
+                    result.push(from_block);
+
+                    let error_msg = format!(
+                        "This {} cannot be downcasted to {}",
+                        parent_struct_name, child_struct_name
+                    );
+                    let try_into_block = quote! {
+                        impl std::convert::TryFrom<#parent_struct> for #class_name {
+                            type Error = &'static str;
+                            fn try_from(parent: #parent_struct) -> Result<#class_name, Self::Error> {
+                                let is_kind_of : bool = unsafe { msg_send!(parent, isKindOfClass:class!(#class_name))};
+                                if is_kind_of {
+                                    Ok(#class_name(parent.0))
+                                } else {
+                                    Err(#error_msg)
+                                }
+                            }
+                        }
+                    };
+                    result.push(try_into_block);
+                }
+            }
+        }
+
+        if !self.is_protocol() {
+            let impl_block = if self.is_template() {
+                let template_names: Vec<Ident> = self
+                    .template_names
+                    .iter()
+                    .map(|g| ctx.rust_ident(g))
+                    .collect();
+                quote! {
+                    impl <#(#template_names :'static),*> #trait_name <#(#template_names),*> for #class_name {
+                    }
+                }
+            } else {
+                quote! {
+                    impl #trait_name for #class_name {
+                    }
+                }
+            };
+            result.push(impl_block);
+        }
+
+        result.push(trait_block);
+        result.saw_objc();
+    }
+}
+
+pub(crate) fn codegen(
+    context: BindgenContext,
+) -> (proc_macro2::TokenStream, BindgenOptions, Vec<String>) {
+    context.gen(|context| {
+        let _t = context.timer("codegen");
+        let counter = Cell::new(0);
+        let mut result = CodegenResult::new(&counter);
+
+        debug!("codegen: {:?}", context.options());
+
+        if context.options().emit_ir {
+            let codegen_items = context.codegen_items();
+            for (id, item) in context.items() {
+                if codegen_items.contains(&id) {
+                    println!("ir: {:?} = {:#?}", id, item);
+                }
+            }
+        }
+
+        if let Some(path) = context.options().emit_ir_graphviz.as_ref() {
+            match dot::write_dot_file(context, path) {
+                Ok(()) => info!(
+                    "Your dot file was generated successfully into: {}",
+                    path
+                ),
+                Err(e) => warn!("{}", e),
+            }
+        }
+
+        if let Some(spec) = context.options().depfile.as_ref() {
+            match spec.write(context.deps()) {
+                Ok(()) => info!(
+                    "Your depfile was generated successfully into: {}",
+                    spec.depfile_path.display()
+                ),
+                Err(e) => warn!("{}", e),
+            }
+        }
+
+        context.resolve_item(context.root_module()).codegen(
+            context,
+            &mut result,
+            &(),
+        );
+
+        if let Some(ref lib_name) = context.options().dynamic_library_name {
+            let lib_ident = context.rust_ident(lib_name);
+            let dynamic_items_tokens =
+                result.dynamic_items().get_tokens(lib_ident);
+            result.push(dynamic_items_tokens);
+        }
+
+        postprocessing::postprocessing(result.items, context.options())
+    })
+}
+
+pub mod utils {
+    use super::{error, ToRustTyOrOpaque};
+    use crate::ir::context::BindgenContext;
+    use crate::ir::function::{Abi, FunctionSig};
+    use crate::ir::item::{Item, ItemCanonicalPath};
+    use crate::ir::ty::TypeKind;
+    use proc_macro2;
+    use std::borrow::Cow;
+    use std::mem;
+    use std::str::FromStr;
+
+    pub fn prepend_bitfield_unit_type(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        let bitfield_unit_src = include_str!("./bitfield_unit.rs");
+        let bitfield_unit_src = if ctx.options().rust_features().min_const_fn {
+            Cow::Borrowed(bitfield_unit_src)
+        } else {
+            Cow::Owned(bitfield_unit_src.replace("const fn ", "fn "))
+        };
+        let bitfield_unit_type =
+            proc_macro2::TokenStream::from_str(&bitfield_unit_src).unwrap();
+        let bitfield_unit_type = quote!(#bitfield_unit_type);
+
+        let items = vec![bitfield_unit_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items);
+    }
+
+    pub fn prepend_objc_header(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        let use_objc = if ctx.options().objc_extern_crate {
+            quote! {
+                #[macro_use]
+                extern crate objc;
+            }
+        } else {
+            quote! {
+                use objc::{self, msg_send, sel, sel_impl, class};
+            }
+        };
+
+        let id_type = quote! {
+            #[allow(non_camel_case_types)]
+            pub type id = *mut objc::runtime::Object;
+        };
+
+        let items = vec![use_objc, id_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
+    pub fn prepend_block_header(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        let use_block = if ctx.options().block_extern_crate {
+            quote! {
+                extern crate block;
+            }
+        } else {
+            quote! {
+                use block;
+            }
+        };
+
+        let items = vec![use_block];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
+    pub fn prepend_union_types(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        let prefix = ctx.trait_prefix();
+
+        // If the target supports `const fn`, declare eligible functions
+        // as `const fn` else just `fn`.
+        let const_fn = if ctx.options().rust_features().min_const_fn {
+            quote! { const fn }
+        } else {
+            quote! { fn }
+        };
+
+        // TODO(emilio): The fmt::Debug impl could be way nicer with
+        // std::intrinsics::type_name, but...
+        let union_field_decl = quote! {
+            #[repr(C)]
+            pub struct __BindgenUnionField<T>(::#prefix::marker::PhantomData<T>);
+        };
+
+        let union_field_impl = quote! {
+            impl<T> __BindgenUnionField<T> {
+                #[inline]
+                pub #const_fn new() -> Self {
+                    __BindgenUnionField(::#prefix::marker::PhantomData)
+                }
+
+                #[inline]
+                pub unsafe fn as_ref(&self) -> &T {
+                    ::#prefix::mem::transmute(self)
+                }
+
+                #[inline]
+                pub unsafe fn as_mut(&mut self) -> &mut T {
+                    ::#prefix::mem::transmute(self)
+                }
+            }
+        };
+
+        let union_field_default_impl = quote! {
+            impl<T> ::#prefix::default::Default for __BindgenUnionField<T> {
+                #[inline]
+                fn default() -> Self {
+                    Self::new()
+                }
+            }
+        };
+
+        let union_field_clone_impl = quote! {
+            impl<T> ::#prefix::clone::Clone for __BindgenUnionField<T> {
+                #[inline]
+                fn clone(&self) -> Self {
+                    Self::new()
+                }
+            }
+        };
+
+        let union_field_copy_impl = quote! {
+            impl<T> ::#prefix::marker::Copy for __BindgenUnionField<T> {}
+        };
+
+        let union_field_debug_impl = quote! {
+            impl<T> ::#prefix::fmt::Debug for __BindgenUnionField<T> {
+                fn fmt(&self, fmt: &mut ::#prefix::fmt::Formatter<'_>)
+                       -> ::#prefix::fmt::Result {
+                    fmt.write_str("__BindgenUnionField")
+                }
+            }
+        };
+
+        // The actual memory of the filed will be hashed, so that's why these
+        // field doesn't do anything with the hash.
+        let union_field_hash_impl = quote! {
+            impl<T> ::#prefix::hash::Hash for __BindgenUnionField<T> {
+                fn hash<H: ::#prefix::hash::Hasher>(&self, _state: &mut H) {
+                }
+            }
+        };
+
+        let union_field_partialeq_impl = quote! {
+            impl<T> ::#prefix::cmp::PartialEq for __BindgenUnionField<T> {
+               fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+                   true
+               }
+           }
+        };
+
+        let union_field_eq_impl = quote! {
+           impl<T> ::#prefix::cmp::Eq for __BindgenUnionField<T> {
+           }
+        };
+
+        let items = vec![
+            union_field_decl,
+            union_field_impl,
+            union_field_default_impl,
+            union_field_clone_impl,
+            union_field_copy_impl,
+            union_field_debug_impl,
+            union_field_hash_impl,
+            union_field_partialeq_impl,
+            union_field_eq_impl,
+        ];
+
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
+    pub fn prepend_incomplete_array_types(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        let prefix = ctx.trait_prefix();
+
+        // If the target supports `const fn`, declare eligible functions
+        // as `const fn` else just `fn`.
+        let const_fn = if ctx.options().rust_features().min_const_fn {
+            quote! { const fn }
+        } else {
+            quote! { fn }
+        };
+
+        let incomplete_array_decl = quote! {
+            #[repr(C)]
+            #[derive(Default)]
+            pub struct __IncompleteArrayField<T>(
+                ::#prefix::marker::PhantomData<T>, [T; 0]);
+        };
+
+        let incomplete_array_impl = quote! {
+            impl<T> __IncompleteArrayField<T> {
+                #[inline]
+                pub #const_fn new() -> Self {
+                    __IncompleteArrayField(::#prefix::marker::PhantomData, [])
+                }
+
+                #[inline]
+                pub fn as_ptr(&self) -> *const T {
+                    self as *const _ as *const T
+                }
+
+                #[inline]
+                pub fn as_mut_ptr(&mut self) -> *mut T {
+                    self as *mut _ as *mut T
+                }
+
+                #[inline]
+                pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+                    ::#prefix::slice::from_raw_parts(self.as_ptr(), len)
+                }
+
+                #[inline]
+                pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+                    ::#prefix::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+                }
+            }
+        };
+
+        let incomplete_array_debug_impl = quote! {
+            impl<T> ::#prefix::fmt::Debug for __IncompleteArrayField<T> {
+                fn fmt(&self, fmt: &mut ::#prefix::fmt::Formatter<'_>)
+                       -> ::#prefix::fmt::Result {
+                    fmt.write_str("__IncompleteArrayField")
+                }
+            }
+        };
+
+        let items = vec![
+            incomplete_array_decl,
+            incomplete_array_impl,
+            incomplete_array_debug_impl,
+        ];
+
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
+    pub fn prepend_complex_type(result: &mut Vec<proc_macro2::TokenStream>) {
+        let complex_type = quote! {
+            #[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+            #[repr(C)]
+            pub struct __BindgenComplex<T> {
+                pub re: T,
+                pub im: T
+            }
+        };
+
+        let items = vec![complex_type];
+        let old_items = mem::replace(result, items);
+        result.extend(old_items.into_iter());
+    }
+
+    pub fn build_path(
+        item: &Item,
+        ctx: &BindgenContext,
+    ) -> error::Result<proc_macro2::TokenStream> {
+        let path = item.namespace_aware_canonical_path(ctx);
+        let tokens =
+            proc_macro2::TokenStream::from_str(&path.join("::")).unwrap();
+
+        Ok(tokens)
+    }
+
+    fn primitive_ty(
+        ctx: &BindgenContext,
+        name: &str,
+    ) -> proc_macro2::TokenStream {
+        let ident = ctx.rust_ident_raw(name);
+        quote! {
+            #ident
+        }
+    }
+
+    pub fn type_from_named(
+        ctx: &BindgenContext,
+        name: &str,
+    ) -> Option<proc_macro2::TokenStream> {
+        // FIXME: We could use the inner item to check this is really a
+        // primitive type but, who the heck overrides these anyway?
+        Some(match name {
+            "int8_t" => primitive_ty(ctx, "i8"),
+            "uint8_t" => primitive_ty(ctx, "u8"),
+            "int16_t" => primitive_ty(ctx, "i16"),
+            "uint16_t" => primitive_ty(ctx, "u16"),
+            "int32_t" => primitive_ty(ctx, "i32"),
+            "uint32_t" => primitive_ty(ctx, "u32"),
+            "int64_t" => primitive_ty(ctx, "i64"),
+            "uint64_t" => primitive_ty(ctx, "u64"),
+
+            "size_t" if ctx.options().size_t_is_usize => {
+                primitive_ty(ctx, "usize")
+            }
+            "uintptr_t" => primitive_ty(ctx, "usize"),
+
+            "ssize_t" if ctx.options().size_t_is_usize => {
+                primitive_ty(ctx, "isize")
+            }
+            "intptr_t" | "ptrdiff_t" => primitive_ty(ctx, "isize"),
+            _ => return None,
+        })
+    }
+
+    pub fn fnsig_return_ty(
+        ctx: &BindgenContext,
+        sig: &FunctionSig,
+    ) -> proc_macro2::TokenStream {
+        if sig.is_divergent() {
+            return quote! { -> ! };
+        }
+
+        let return_item = ctx.resolve_item(sig.return_type());
+        if let TypeKind::Void = *return_item.kind().expect_type().kind() {
+            quote! {}
+        } else {
+            let ret_ty = return_item.to_rust_ty_or_opaque(ctx, &());
+            quote! {
+                -> #ret_ty
+            }
+        }
+    }
+
+    pub fn fnsig_arguments(
+        ctx: &BindgenContext,
+        sig: &FunctionSig,
+    ) -> Vec<proc_macro2::TokenStream> {
+        use super::ToPtr;
+
+        let mut unnamed_arguments = 0;
+        let mut args = sig
+            .argument_types()
+            .iter()
+            .map(|&(ref name, ty)| {
+                let arg_item = ctx.resolve_item(ty);
+                let arg_ty = arg_item.kind().expect_type();
+
+                // From the C90 standard[1]:
+                //
+                //     A declaration of a parameter as "array of type" shall be
+                //     adjusted to "qualified pointer to type", where the type
+                //     qualifiers (if any) are those specified within the [ and ] of
+                //     the array type derivation.
+                //
+                // [1]: http://c0x.coding-guidelines.com/6.7.5.3.html
+                let arg_ty = match *arg_ty.canonical_type(ctx).kind() {
+                    TypeKind::Array(t, _) => {
+                        let stream =
+                            if ctx.options().array_pointers_in_arguments {
+                                arg_ty.to_rust_ty_or_opaque(ctx, arg_item)
+                            } else {
+                                t.to_rust_ty_or_opaque(ctx, &())
+                            };
+                        stream.to_ptr(ctx.resolve_type(t).is_const())
+                    }
+                    TypeKind::Pointer(inner) => {
+                        let inner = ctx.resolve_item(inner);
+                        let inner_ty = inner.expect_type();
+                        if let TypeKind::ObjCInterface(ref interface) =
+                            *inner_ty.canonical_type(ctx).kind()
+                        {
+                            let name = ctx.rust_ident(interface.name());
+                            quote! {
+                                #name
+                            }
+                        } else {
+                            arg_item.to_rust_ty_or_opaque(ctx, &())
+                        }
+                    }
+                    _ => arg_item.to_rust_ty_or_opaque(ctx, &()),
+                };
+
+                let arg_name = match *name {
+                    Some(ref name) => ctx.rust_mangle(name).into_owned(),
+                    None => {
+                        unnamed_arguments += 1;
+                        format!("arg{}", unnamed_arguments)
+                    }
+                };
+
+                assert!(!arg_name.is_empty());
+                let arg_name = ctx.rust_ident(arg_name);
+
+                quote! {
+                    #arg_name : #arg_ty
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if sig.is_variadic() {
+            args.push(quote! { ... })
+        }
+
+        args
+    }
+
+    pub fn fnsig_argument_identifiers(
+        ctx: &BindgenContext,
+        sig: &FunctionSig,
+    ) -> Vec<proc_macro2::TokenStream> {
+        let mut unnamed_arguments = 0;
+        let args = sig
+            .argument_types()
+            .iter()
+            .map(|&(ref name, _ty)| {
+                let arg_name = match *name {
+                    Some(ref name) => ctx.rust_mangle(name).into_owned(),
+                    None => {
+                        unnamed_arguments += 1;
+                        format!("arg{}", unnamed_arguments)
+                    }
+                };
+
+                assert!(!arg_name.is_empty());
+                let arg_name = ctx.rust_ident(arg_name);
+
+                quote! {
+                    #arg_name
+                }
+            })
+            .collect::<Vec<_>>();
+
+        args
+    }
+
+    pub fn fnsig_block(
+        ctx: &BindgenContext,
+        sig: &FunctionSig,
+    ) -> proc_macro2::TokenStream {
+        let args = sig.argument_types().iter().map(|&(_, ty)| {
+            let arg_item = ctx.resolve_item(ty);
+
+            arg_item.to_rust_ty_or_opaque(ctx, &())
+        });
+
+        let return_item = ctx.resolve_item(sig.return_type());
+        let ret_ty =
+            if let TypeKind::Void = *return_item.kind().expect_type().kind() {
+                quote! { () }
+            } else {
+                return_item.to_rust_ty_or_opaque(ctx, &())
+            };
+
+        quote! {
+            *const ::block::Block<(#(#args,)*), #ret_ty>
+        }
+    }
+
+    // Returns true if `canonical_name` will end up as `mangled_name` at the
+    // machine code level, i.e. after LLVM has applied any target specific
+    // mangling.
+    pub fn names_will_be_identical_after_mangling(
+        canonical_name: &str,
+        mangled_name: &str,
+        call_conv: Option<Abi>,
+    ) -> bool {
+        // If the mangled name and the canonical name are the same then no
+        // mangling can have happened between the two versions.
+        if canonical_name == mangled_name {
+            return true;
+        }
+
+        // Working with &[u8] makes indexing simpler than with &str
+        let canonical_name = canonical_name.as_bytes();
+        let mangled_name = mangled_name.as_bytes();
+
+        let (mangling_prefix, expect_suffix) = match call_conv {
+            Some(Abi::C) |
+            // None is the case for global variables
+            None => {
+                (b'_', false)
+            }
+            Some(Abi::Stdcall) => (b'_', true),
+            Some(Abi::Fastcall) => (b'@', true),
+
+            // This is something we don't recognize, stay on the safe side
+            // by emitting the `#[link_name]` attribute
+            Some(_) => return false,
+        };
+
+        // Check that the mangled name is long enough to at least contain the
+        // canonical name plus the expected prefix.
+        if mangled_name.len() < canonical_name.len() + 1 {
+            return false;
+        }
+
+        // Return if the mangled name does not start with the prefix expected
+        // for the given calling convention.
+        if mangled_name[0] != mangling_prefix {
+            return false;
+        }
+
+        // Check that the mangled name contains the canonical name after the
+        // prefix
+        if &mangled_name[1..canonical_name.len() + 1] != canonical_name {
+            return false;
+        }
+
+        // If the given calling convention also prescribes a suffix, check that
+        // it exists too
+        if expect_suffix {
+            let suffix = &mangled_name[canonical_name.len() + 1..];
+
+            // The shortest suffix is "@0"
+            if suffix.len() < 2 {
+                return false;
+            }
+
+            // Check that the suffix starts with '@' and is all ASCII decimals
+            // after that.
+            if suffix[0] != b'@' || !suffix[1..].iter().all(u8::is_ascii_digit)
+            {
+                return false;
+            }
+        } else if mangled_name.len() != canonical_name.len() + 1 {
+            // If we don't expect a prefix but there is one, we need the
+            // #[link_name] attribute
+            return false;
+        }
+
+        true
+    }
+}
diff --git a/bindgen/codegen/postprocessing/merge_extern_blocks.rs b/bindgen/codegen/postprocessing/merge_extern_blocks.rs
new file mode 100644
index 00000000..2b761494
--- /dev/null
+++ b/bindgen/codegen/postprocessing/merge_extern_blocks.rs
@@ -0,0 +1,46 @@
+use syn::{Item, ItemForeignMod};
+
+pub(super) fn merge_extern_blocks(items: &mut Vec<Item>) {
+    // Keep all the extern blocks in a different `Vec` for faster search.
+    let mut foreign_mods = Vec::<ItemForeignMod>::new();
+
+    for item in std::mem::take(items) {
+        match item {
+            Item::ForeignMod(ItemForeignMod {
+                attrs,
+                abi,
+                brace_token,
+                items: foreign_items,
+            }) => {
+                let mut exists = false;
+                for foreign_mod in &mut foreign_mods {
+                    // Check if there is a extern block with the same ABI and
+                    // attributes.
+                    if foreign_mod.attrs == attrs && foreign_mod.abi == abi {
+                        // Merge the items of the two blocks.
+                        foreign_mod.items.extend_from_slice(&foreign_items);
+                        exists = true;
+                        break;
+                    }
+                }
+                // If no existing extern block had the same ABI and attributes, store
+                // it.
+                if !exists {
+                    foreign_mods.push(ItemForeignMod {
+                        attrs,
+                        abi,
+                        brace_token,
+                        items: foreign_items,
+                    });
+                }
+            }
+            // If the item is not an extern block, we don't have to do anything.
+            _ => items.push(item),
+        }
+    }
+
+    // Move all the extern blocks alongside the rest of the items.
+    for foreign_mod in foreign_mods {
+        items.push(Item::ForeignMod(foreign_mod));
+    }
+}
diff --git a/bindgen/codegen/postprocessing/mod.rs b/bindgen/codegen/postprocessing/mod.rs
new file mode 100644
index 00000000..c6612f2b
--- /dev/null
+++ b/bindgen/codegen/postprocessing/mod.rs
@@ -0,0 +1,66 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::Item;
+
+use crate::BindgenOptions;
+
+mod merge_extern_blocks;
+mod sort_semantically;
+
+use merge_extern_blocks::merge_extern_blocks;
+use sort_semantically::sort_semantically;
+
+struct PostProcessingPass {
+    should_run: fn(&BindgenOptions) -> bool,
+    run: fn(&mut Vec<Item>),
+}
+
+// TODO: This can be a const fn when mutable references are allowed in const
+// context.
+macro_rules! pass {
+    ($pass:ident) => {
+        PostProcessingPass {
+            should_run: |options| options.$pass,
+            run: |items| $pass(items),
+        }
+    };
+}
+
+const PASSES: &[PostProcessingPass] =
+    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
+
+pub(crate) fn postprocessing(
+    items: Vec<TokenStream>,
+    options: &BindgenOptions,
+) -> TokenStream {
+    let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options));
+    if !require_syn {
+        return items.into_iter().collect();
+    }
+    let module_wrapped_tokens =
+        quote!(mod wrapper_for_sorting_hack { #( #items )* });
+
+    // This syn business is a hack, for now. This means that we are re-parsing already
+    // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
+    // control over the elements.
+    // One caveat is that some of the items coming from `quote`d output might have
+    // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
+    // The two `unwrap`s here are deliberate because
+    //      The first one won't panic because we build the `mod` and know it is there
+    //      The second one won't panic because we know original output has something in
+    //      it already.
+    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
+        .unwrap()
+        .content
+        .unwrap();
+
+    for pass in PASSES {
+        if (pass.should_run)(options) {
+            (pass.run)(&mut items);
+        }
+    }
+
+    let synful_items = items.into_iter().map(|item| item.into_token_stream());
+
+    quote! { #( #synful_items )* }
+}
diff --git a/bindgen/codegen/postprocessing/sort_semantically.rs b/bindgen/codegen/postprocessing/sort_semantically.rs
new file mode 100644
index 00000000..96596cb0
--- /dev/null
+++ b/bindgen/codegen/postprocessing/sort_semantically.rs
@@ -0,0 +1,24 @@
+use syn::Item;
+
+pub(super) fn sort_semantically(items: &mut [Item]) {
+    items.sort_by_key(|item| match item {
+        Item::Type(_) => 0,
+        Item::Struct(_) => 1,
+        Item::Const(_) => 2,
+        Item::Fn(_) => 3,
+        Item::Enum(_) => 4,
+        Item::Union(_) => 5,
+        Item::Static(_) => 6,
+        Item::Trait(_) => 7,
+        Item::TraitAlias(_) => 8,
+        Item::Impl(_) => 9,
+        Item::Mod(_) => 10,
+        Item::Use(_) => 11,
+        Item::Verbatim(_) => 12,
+        Item::ExternCrate(_) => 13,
+        Item::ForeignMod(_) => 14,
+        Item::Macro(_) => 15,
+        Item::Macro2(_) => 16,
+        _ => 18,
+    });
+}
diff --git a/bindgen/codegen/struct_layout.rs b/bindgen/codegen/struct_layout.rs
new file mode 100644
index 00000000..ddac1b0a
--- /dev/null
+++ b/bindgen/codegen/struct_layout.rs
@@ -0,0 +1,444 @@
+//! Helpers for code generation that need struct layout
+
+use super::helpers;
+
+use crate::ir::comp::CompInfo;
+use crate::ir::context::BindgenContext;
+use crate::ir::layout::Layout;
+use crate::ir::ty::{Type, TypeKind};
+use proc_macro2::{self, Ident, Span};
+use std::cmp;
+
+const MAX_GUARANTEED_ALIGN: usize = 8;
+
+/// Trace the layout of struct.
+#[derive(Debug)]
+pub struct StructLayoutTracker<'a> {
+    name: &'a str,
+    ctx: &'a BindgenContext,
+    comp: &'a CompInfo,
+    is_packed: bool,
+    known_type_layout: Option<Layout>,
+    is_rust_union: bool,
+    can_copy_union_fields: bool,
+    latest_offset: usize,
+    padding_count: usize,
+    latest_field_layout: Option<Layout>,
+    max_field_align: usize,
+    last_field_was_bitfield: bool,
+}
+
+/// Returns a size aligned to a given value.
+pub fn align_to(size: usize, align: usize) -> usize {
+    if align == 0 {
+        return size;
+    }
+
+    let rem = size % align;
+    if rem == 0 {
+        return size;
+    }
+
+    size + align - rem
+}
+
+/// Returns the lower power of two byte count that can hold at most n bits.
+pub fn bytes_from_bits_pow2(mut n: usize) -> usize {
+    if n == 0 {
+        return 0;
+    }
+
+    if n <= 8 {
+        return 1;
+    }
+
+    if !n.is_power_of_two() {
+        n = n.next_power_of_two();
+    }
+
+    n / 8
+}
+
+#[test]
+fn test_align_to() {
+    assert_eq!(align_to(1, 1), 1);
+    assert_eq!(align_to(1, 2), 2);
+    assert_eq!(align_to(1, 4), 4);
+    assert_eq!(align_to(5, 1), 5);
+    assert_eq!(align_to(17, 4), 20);
+}
+
+#[test]
+fn test_bytes_from_bits_pow2() {
+    assert_eq!(bytes_from_bits_pow2(0), 0);
+    for i in 1..9 {
+        assert_eq!(bytes_from_bits_pow2(i), 1);
+    }
+    for i in 9..17 {
+        assert_eq!(bytes_from_bits_pow2(i), 2);
+    }
+    for i in 17..33 {
+        assert_eq!(bytes_from_bits_pow2(i), 4);
+    }
+}
+
+impl<'a> StructLayoutTracker<'a> {
+    pub fn new(
+        ctx: &'a BindgenContext,
+        comp: &'a CompInfo,
+        ty: &'a Type,
+        name: &'a str,
+    ) -> Self {
+        let known_type_layout = ty.layout(ctx);
+        let is_packed = comp.is_packed(ctx, known_type_layout.as_ref());
+        let (is_rust_union, can_copy_union_fields) =
+            comp.is_rust_union(ctx, known_type_layout.as_ref(), name);
+        StructLayoutTracker {
+            name,
+            ctx,
+            comp,
+            is_packed,
+            known_type_layout,
+            is_rust_union,
+            can_copy_union_fields,
+            latest_offset: 0,
+            padding_count: 0,
+            latest_field_layout: None,
+            max_field_align: 0,
+            last_field_was_bitfield: false,
+        }
+    }
+
+    pub fn can_copy_union_fields(&self) -> bool {
+        self.can_copy_union_fields
+    }
+
+    pub fn is_rust_union(&self) -> bool {
+        self.is_rust_union
+    }
+
+    pub fn saw_vtable(&mut self) {
+        debug!("saw vtable for {}", self.name);
+
+        let ptr_size = self.ctx.target_pointer_size();
+        self.latest_offset += ptr_size;
+        self.latest_field_layout = Some(Layout::new(ptr_size, ptr_size));
+        self.max_field_align = ptr_size;
+    }
+
+    pub fn saw_base(&mut self, base_ty: &Type) {
+        debug!("saw base for {}", self.name);
+        if let Some(layout) = base_ty.layout(self.ctx) {
+            self.align_to_latest_field(layout);
+
+            self.latest_offset += self.padding_bytes(layout) + layout.size;
+            self.latest_field_layout = Some(layout);
+            self.max_field_align = cmp::max(self.max_field_align, layout.align);
+        }
+    }
+
+    pub fn saw_bitfield_unit(&mut self, layout: Layout) {
+        debug!("saw bitfield unit for {}: {:?}", self.name, layout);
+
+        self.align_to_latest_field(layout);
+
+        self.latest_offset += layout.size;
+
+        debug!(
+            "Offset: <bitfield>: {} -> {}",
+            self.latest_offset - layout.size,
+            self.latest_offset
+        );
+
+        self.latest_field_layout = Some(layout);
+        self.last_field_was_bitfield = true;
+        // NB: We intentionally don't update the max_field_align here, since our
+        // bitfields code doesn't necessarily guarantee it, so we need to
+        // actually generate the dummy alignment.
+    }
+
+    /// Returns a padding field if necessary for a given new field _before_
+    /// adding that field.
+    pub fn saw_field(
+        &mut self,
+        field_name: &str,
+        field_ty: &Type,
+        field_offset: Option<usize>,
+    ) -> Option<proc_macro2::TokenStream> {
+        let mut field_layout = field_ty.layout(self.ctx)?;
+
+        if let TypeKind::Array(inner, len) =
+            *field_ty.canonical_type(self.ctx).kind()
+        {
+            // FIXME(emilio): As an _ultra_ hack, we correct the layout returned
+            // by arrays of structs that have a bigger alignment than what we
+            // can support.
+            //
+            // This means that the structs in the array are super-unsafe to
+            // access, since they won't be properly aligned, but there's not too
+            // much we can do about it.
+            if let Some(layout) = self.ctx.resolve_type(inner).layout(self.ctx)
+            {
+                if layout.align > MAX_GUARANTEED_ALIGN {
+                    field_layout.size =
+                        align_to(layout.size, layout.align) * len;
+                    field_layout.align = MAX_GUARANTEED_ALIGN;
+                }
+            }
+        }
+        self.saw_field_with_layout(field_name, field_layout, field_offset)
+    }
+
+    pub fn saw_field_with_layout(
+        &mut self,
+        field_name: &str,
+        field_layout: Layout,
+        field_offset: Option<usize>,
+    ) -> Option<proc_macro2::TokenStream> {
+        let will_merge_with_bitfield = self.align_to_latest_field(field_layout);
+
+        let is_union = self.comp.is_union();
+        let padding_bytes = match field_offset {
+            Some(offset) if offset / 8 > self.latest_offset => {
+                offset / 8 - self.latest_offset
+            }
+            _ => {
+                if will_merge_with_bitfield ||
+                    field_layout.align == 0 ||
+                    is_union
+                {
+                    0
+                } else if !self.is_packed {
+                    self.padding_bytes(field_layout)
+                } else if let Some(l) = self.known_type_layout {
+                    self.padding_bytes(l)
+                } else {
+                    0
+                }
+            }
+        };
+
+        self.latest_offset += padding_bytes;
+
+        let padding_layout = if self.is_packed || is_union {
+            None
+        } else {
+            let force_padding = self.ctx.options().force_explicit_padding;
+
+            // Otherwise the padding is useless.
+            let need_padding = force_padding ||
+                padding_bytes >= field_layout.align ||
+                field_layout.align > MAX_GUARANTEED_ALIGN;
+
+            debug!(
+                "Offset: <padding>: {} -> {}",
+                self.latest_offset - padding_bytes,
+                self.latest_offset
+            );
+
+            debug!(
+                "align field {} to {}/{} with {} padding bytes {:?}",
+                field_name,
+                self.latest_offset,
+                field_offset.unwrap_or(0) / 8,
+                padding_bytes,
+                field_layout
+            );
+
+            let padding_align = if force_padding {
+                1
+            } else {
+                cmp::min(field_layout.align, MAX_GUARANTEED_ALIGN)
+            };
+
+            if need_padding && padding_bytes != 0 {
+                Some(Layout::new(padding_bytes, padding_align))
+            } else {
+                None
+            }
+        };
+
+        self.latest_offset += field_layout.size;
+        self.latest_field_layout = Some(field_layout);
+        self.max_field_align =
+            cmp::max(self.max_field_align, field_layout.align);
+        self.last_field_was_bitfield = false;
+
+        debug!(
+            "Offset: {}: {} -> {}",
+            field_name,
+            self.latest_offset - field_layout.size,
+            self.latest_offset
+        );
+
+        padding_layout.map(|layout| self.padding_field(layout))
+    }
+
+    pub fn add_tail_padding(
+        &mut self,
+        comp_name: &str,
+        comp_layout: Layout,
+    ) -> Option<proc_macro2::TokenStream> {
+        // Only emit an padding field at the end of a struct if the
+        // user configures explicit padding.
+        if !self.ctx.options().force_explicit_padding {
+            return None;
+        }
+
+        // Padding doesn't make sense for rust unions.
+        if self.is_rust_union {
+            return None;
+        }
+
+        if self.latest_offset == comp_layout.size {
+            // This struct does not contain tail padding.
+            return None;
+        }
+
+        trace!(
+            "need a tail padding field for {}: offset {} -> size {}",
+            comp_name,
+            self.latest_offset,
+            comp_layout.size
+        );
+        let size = comp_layout.size - self.latest_offset;
+        Some(self.padding_field(Layout::new(size, 0)))
+    }
+
+    pub fn pad_struct(
+        &mut self,
+        layout: Layout,
+    ) -> Option<proc_macro2::TokenStream> {
+        debug!(
+            "pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}",
+            self, layout
+        );
+
+        if layout.size < self.latest_offset {
+            warn!(
+                "Calculated wrong layout for {}, too more {} bytes",
+                self.name,
+                self.latest_offset - layout.size
+            );
+            return None;
+        }
+
+        let padding_bytes = layout.size - self.latest_offset;
+        if padding_bytes == 0 {
+            return None;
+        }
+
+        let repr_align = self.ctx.options().rust_features().repr_align;
+
+        // We always pad to get to the correct size if the struct is one of
+        // those we can't align properly.
+        //
+        // Note that if the last field we saw was a bitfield, we may need to pad
+        // regardless, because bitfields don't respect alignment as strictly as
+        // other fields.
+        if padding_bytes >= layout.align ||
+            (self.last_field_was_bitfield &&
+                padding_bytes >= self.latest_field_layout.unwrap().align) ||
+            (!repr_align && layout.align > MAX_GUARANTEED_ALIGN)
+        {
+            let layout = if self.is_packed {
+                Layout::new(padding_bytes, 1)
+            } else if self.last_field_was_bitfield ||
+                layout.align > MAX_GUARANTEED_ALIGN
+            {
+                // We've already given up on alignment here.
+                Layout::for_size(self.ctx, padding_bytes)
+            } else {
+                Layout::new(padding_bytes, layout.align)
+            };
+
+            debug!("pad bytes to struct {}, {:?}", self.name, layout);
+
+            Some(self.padding_field(layout))
+        } else {
+            None
+        }
+    }
+
+    pub fn requires_explicit_align(&self, layout: Layout) -> bool {
+        let repr_align = self.ctx.options().rust_features().repr_align;
+
+        // Always force explicit repr(align) for stuff more than 16-byte aligned
+        // to work-around https://github.com/rust-lang/rust/issues/54341.
+        //
+        // Worst-case this just generates redundant alignment attributes.
+        if repr_align && self.max_field_align >= 16 {
+            return true;
+        }
+
+        if self.max_field_align >= layout.align {
+            return false;
+        }
+
+        // We can only generate up-to a 8-bytes of alignment unless we support
+        // repr(align).
+        repr_align || layout.align <= MAX_GUARANTEED_ALIGN
+    }
+
+    fn padding_bytes(&self, layout: Layout) -> usize {
+        align_to(self.latest_offset, layout.align) - self.latest_offset
+    }
+
+    fn padding_field(&mut self, layout: Layout) -> proc_macro2::TokenStream {
+        let ty = helpers::blob(self.ctx, layout);
+        let padding_count = self.padding_count;
+
+        self.padding_count += 1;
+
+        let padding_field_name = Ident::new(
+            &format!("__bindgen_padding_{}", padding_count),
+            Span::call_site(),
+        );
+
+        self.max_field_align = cmp::max(self.max_field_align, layout.align);
+
+        quote! {
+            pub #padding_field_name : #ty ,
+        }
+    }
+
+    /// Returns whether the new field is known to merge with a bitfield.
+    ///
+    /// This is just to avoid doing the same check also in pad_field.
+    fn align_to_latest_field(&mut self, new_field_layout: Layout) -> bool {
+        if self.is_packed {
+            // Skip to align fields when packed.
+            return false;
+        }
+
+        let layout = match self.latest_field_layout {
+            Some(l) => l,
+            None => return false,
+        };
+
+        // If it was, we may or may not need to align, depending on what the
+        // current field alignment and the bitfield size and alignment are.
+        debug!(
+            "align_to_bitfield? {}: {:?} {:?}",
+            self.last_field_was_bitfield, layout, new_field_layout
+        );
+
+        // Avoid divide-by-zero errors if align is 0.
+        let align = cmp::max(1, layout.align);
+
+        if self.last_field_was_bitfield &&
+            new_field_layout.align <= layout.size % align &&
+            new_field_layout.size <= layout.size % align
+        {
+            // The new field will be coalesced into some of the remaining bits.
+            //
+            // FIXME(emilio): I think this may not catch everything?
+            debug!("Will merge with bitfield");
+            return true;
+        }
+
+        // Else, just align the obvious way.
+        self.latest_offset += self.padding_bytes(layout);
+        false
+    }
+}
diff --git a/bindgen/csmith-fuzzing/README.md b/bindgen/csmith-fuzzing/README.md
new file mode 100644
index 00000000..cdd6d086
--- /dev/null
+++ b/bindgen/csmith-fuzzing/README.md
@@ -0,0 +1,65 @@
+# Fuzzing `bindgen` with `csmith`
+
+[`csmith`][csmith] generates random C and C++ programs that can be used as test
+cases for compilers. When testing `bindgen` with `csmith`, we interpret the
+generated programs as header files, and emit Rust bindings to them. If `bindgen`
+panics, the emitted bindings won't compile with `rustc`, or the generated layout
+tests in the bindings fail, then we report an issue containing the test case!
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Prerequisites](#prerequisites)
+- [Running the Fuzzer](#running-the-fuzzer)
+- [Reporting Issues](#reporting-issues)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Prerequisites
+
+Requires `python3`, `csmith`, and `creduce` to be in `$PATH`.
+
+Many OS package managers have `csmith` and `creduce` packages:
+
+```
+$ sudo apt install csmith creduce
+$ brew install csmith creduce
+$ # Etc...
+```
+
+## Running the Fuzzer
+
+Run `csmith` and test `bindgen` on the generated test cases with this command:
+
+```
+$ ./driver.py
+```
+
+The driver will keep running until it encounters an error in `bindgen`.
+
+Each invocation of `./driver.py` will use its own temporary directories, so
+running it in multiple terminals in parallel is supported.
+
+`csmith` is run with `--no-checksum --nomain --max-block-size 1
+--max-block-depth 1` which disables the `main` function, and makes function
+bodies as simple as possible as `bindgen` does not care about them, but they
+cannot be completely disabled in `csmith`. Run `csmith --help` to see what
+exactly those options do.
+
+## Reporting Issues
+
+Once the fuzz driver finds a test case that causes some kind of error in
+`bindgen` or its emitted bindings, it is helpful to
+[run C-Reduce on the test case][creducing] to remove the parts that are
+irrelevant to reproducing the error. This is ***very*** helpful for the folks
+who further investigate the issue and come up with a fix!
+
+Additionally, mention that you discovered the issue via `csmith` and we will add
+the `A-csmith` label. You can find all the issues discovered with `csmith`, and
+related to fuzzing with `csmith`, by looking up
+[all issues tagged with the `A-csmith` label][csmith-issues].
+
+[csmith]: https://github.com/csmith-project/csmith
+[creducing]: ../CONTRIBUTING.md#using-creduce-to-minimize-test-cases
+[csmith-issues]: https://github.com/rust-lang/rust-bindgen/issues?q=label%3AA-csmith
diff --git a/bindgen/csmith-fuzzing/csmith.h b/bindgen/csmith-fuzzing/csmith.h
new file mode 100644
index 00000000..faaef5b1
--- /dev/null
+++ b/bindgen/csmith-fuzzing/csmith.h
@@ -0,0 +1,15 @@
+// Type definitions from csmith's csmith_minimal.h included in csmith.h .
+// Since other header contents are not needed we put them in here
+// so the other original header is not needed anymore.
+
+#define int8_t signed char
+#define uint8_t unsigned char
+
+#define int16_t short
+#define uint16_t unsigned short
+
+#define int32_t int
+#define uint32_t unsigned
+
+#define int64_t long long
+#define uint64_t unsigned long long
diff --git a/bindgen/csmith-fuzzing/driver.py b/bindgen/csmith-fuzzing/driver.py
new file mode 100755
index 00000000..1d3af540
--- /dev/null
+++ b/bindgen/csmith-fuzzing/driver.py
@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import re
+import shlex
+import sys
+from subprocess import run, SubprocessError, DEVNULL, PIPE
+from tempfile import NamedTemporaryFile
+
+DESC = """
+
+A `csmith` fuzzing driver for `bindgen`.
+
+Generates random C source files with `csmith` and then passes them to `bindgen`
+(via `predicate.py`). If `bindgen` can't emit bindings, `rustc` can't compile
+those bindings, or the compiled bindings' layout tests fail, then the driver has
+found a bug, and will report the problematic test case to you.
+
+"""
+
+parser = argparse.ArgumentParser(
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    description=DESC.strip())
+
+parser.add_argument(
+    "--keep-going",
+    action="store_true",
+    help="Do not stop after finding a test case that exhibits a bug in `bindgen`. Instead, keep going.")
+
+CSMITH_ARGS="\
+--no-checksum \
+--nomain \
+--max-block-size 1 \
+--max-block-depth 1"
+
+parser.add_argument(
+    "--csmith-args",
+    type=str,
+    default=CSMITH_ARGS,
+    help="Pass this argument string to `csmith`. By default, very small functions are generated.")
+
+BINDGEN_ARGS = "--with-derive-partialeq \
+--with-derive-eq \
+--with-derive-partialord \
+--with-derive-ord \
+--with-derive-hash \
+--with-derive-default"
+
+parser.add_argument(
+    "--bindgen-args",
+    type=str,
+    default=BINDGEN_ARGS,
+    help="Pass this argument string to `bindgen`. By default, all traits are derived.")
+
+parser.add_argument(
+    "--no-creduce",
+    action="store_false",
+    dest="creduce",
+    help="Do not run `creduce` on any buggy test case(s) discovered.")
+
+################################################################################
+
+def cat(path, title=None):
+    if not title:
+        title = path
+    print("-------------------- {} --------------------".format(title))
+    print()
+    print()
+    run(["cat", path])
+
+def decode(f):
+    return f.decode(encoding="utf-8", errors="ignore")
+
+def run_logged(cmd):
+    result = run(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE)
+    result.stdout = decode(result.stdout)
+    result.stderr = decode(result.stderr)
+    if result.returncode != 0:
+        print()
+        print()
+        print("Error: {} exited with code {}".format(cmd, result.returncode))
+        print()
+        print()
+        for line in result.stdout.splitlines():
+            sys.stdout.write("+")
+            sys.stdout.write(line)
+            sys.stdout.write("\n")
+        for line in result.stderr.splitlines():
+            sys.stderr.write("+")
+            sys.stderr.write(line)
+            sys.stderr.write("\n")
+    return result
+
+def main():
+    os.environ["RUST_BACKTRACE"] = "full"
+    args = parser.parse_args()
+
+    bindgen_args = args.bindgen_args
+    if bindgen_args.find(" -- ") == -1:
+        bindgen_args = bindgen_args + " -- "
+    bindgen_args = bindgen_args + " -I{}".format(os.path.abspath(os.path.dirname(sys.argv[0])))
+    args.bindgen_args = bindgen_args
+
+    print()
+    print()
+    print("Fuzzing `bindgen` with C-Smith...")
+    print()
+    print()
+
+    iterations = 0
+    while True:
+        print("\rIteration: {}".format(iterations), end="", flush=True)
+        iterations += 1
+
+        input = NamedTemporaryFile(delete=False, prefix="input-", suffix=".h")
+        input.close()
+        result = run_logged(["csmith", "-o", input.name] + shlex.split(args.csmith_args))
+        if result.returncode != 0:
+            exit(1)
+
+        predicate_command = [
+            "./predicate.py",
+            "--bindgen-args",
+            args.bindgen_args,
+            input.name
+        ]
+        result = run_logged(predicate_command)
+
+        if result.returncode != 0:
+            print()
+            print()
+            cat(input.name, title="Failing test case: {}".format(input.name))
+            print()
+            print()
+
+            if args.creduce:
+                creduce(args, input.name, result)
+
+            print_issue_template(args, input.name, predicate_command, result)
+
+            if args.keep_going:
+                continue
+            exit(1)
+
+        os.remove(input.name)
+
+RUSTC_ERROR_REGEX = re.compile(r".*(error\[.*].*)")
+LAYOUT_TEST_FAILURE = re.compile(r".*(test bindgen_test_layout_.* \.\.\. FAILED)")
+
+def creduce(args, failing_test_case, result):
+    print()
+    print()
+    print("Reducing failing test case with `creduce`...")
+
+    match = re.search(RUSTC_ERROR_REGEX, result.stderr)
+    if match:
+        error_msg = match.group(1)
+        print("...searching for \"{}\".".format(error_msg))
+        return creduce_with_predicate_flags(
+            args,
+            failing_test_case,
+            "--bindgen-args '{}' --expect-compile-fail --rustc-grep '{}'".format(
+                args.bindgen_args,
+                re.escape(error_msg)
+            )
+        )
+
+    match = re.search(LAYOUT_TEST_FAILURE, result.stdout)
+    if match:
+        layout_failure = match.group(1)
+        struct_name = layout_failure[len("test bindgen_test_layout_"):layout_failure.rindex(" ... FAILED")]
+        print("...searching for \"{}\".".format(layout_failure))
+        return creduce_with_predicate_flags(
+            args,
+            failing_test_case,
+            "--bindgen-args '{}' --expect-layout-tests-fail --bindings-grep '{}' --layout-tests-grep '{}'".format(
+                args.bindgen_args,
+                re.escape(struct_name),
+                re.escape(layout_failure)
+            )
+        )
+
+    print("...nevermind, don't know how to `creduce` this bug. Skipping.")
+
+def creduce_with_predicate_flags(args, failing_test_case, predicate_flags):
+    predicate = """
+#!/usr/bin/env bash
+set -eu
+{} {} {}
+    """.format(
+        os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "predicate.py")),
+        predicate_flags,
+        os.path.basename(failing_test_case)
+    )
+
+    print("...and reducing with this script:")
+    print()
+    print()
+    print(predicate)
+    print()
+    print()
+
+    predicate_path = failing_test_case + ".predicate.sh"
+    with open(predicate_path, "w") as p:
+        p.write(predicate)
+    os.chmod(predicate_path, 0o755)
+
+    creduce_command = ["creduce", "--n", str(os.cpu_count()), predicate_path, failing_test_case]
+    print("Running:", creduce_command)
+    result = run(creduce_command)
+    if result.returncode == 0:
+        print()
+        print()
+        print("`creduce` reduced the failing test case to:")
+        print()
+        print()
+        cat(failing_test_case)
+        print()
+        print()
+    else:
+        print()
+        print()
+        print("`creduce` failed!")
+        if not args.keep_going:
+            sys.exit(1)
+
+def print_issue_template(args, failing_test_case, predicate_command, result):
+    test_case_contents = None
+    with open(failing_test_case, "r") as f:
+        test_case_contents = f.read()
+
+    print("""
+
+! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
+! File this issue at https://github.com/rust-lang/rust-bindgen/issues/new !
+! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
+
+   --------------- 8< --------------- 8< --------------- 8< ---------------
+
+This bug was found with `csmith` and `driver.py`.
+
+### Input Header
+
+```c
+{}
+```
+
+### `bindgen` Invocation
+
+```
+$ {}
+```
+
+### Actual Results
+
+<details>
+
+```
+{}
+```
+
+</details>
+
+### Expected Results
+
+`bindgen` emits bindings OK, then `rustc` compiles those bindings OK, then the
+compiled bindings' layout tests pass OK.
+
+   --------------- 8< --------------- 8< --------------- 8< ---------------
+
+                         <3 <3 <3 Thank you! <3 <3 <3
+    """.format(
+        test_case_contents,
+        " ".join(map(lambda s: "'{}'".format(s), predicate_command)),
+        result.stdout + result.stderr
+    ))
+
+if __name__ == "__main__":
+    try:
+        os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
+        main()
+    except KeyboardInterrupt:
+        exit()
diff --git a/bindgen/csmith-fuzzing/predicate.py b/bindgen/csmith-fuzzing/predicate.py
new file mode 100755
index 00000000..6ca50476
--- /dev/null
+++ b/bindgen/csmith-fuzzing/predicate.py
@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import re
+import shlex
+import subprocess
+import sys
+from tempfile import NamedTemporaryFile
+
+DESC = """
+
+Determine whether `bindgen` can successfully process a C or C++ input header.
+
+First, `bindgen` is run on the input header. Then the emitted bindings are
+compiled with `rustc`. Finally, the compiled bindings' layout tests are run.
+
+By default, this script will exit zero if all of the above steps are successful,
+and non-zero if any of them fail. This is appropriate for determining if some
+test case (perhaps generated with `csmith` or another fuzzer) uncovers any bugs
+in `bindgen`.
+
+However, this script can also be used when reducing (perhaps with `creduce`) a
+known-bad test case into a new, smaller test case that exhibits the same bad
+behavior. In this mode, you might expect that the emitted bindings fail to
+compile with `rustc`, and want to exit non-zero early if that is not the
+case. See the "reducing arguments" for details and what knobs are available.
+
+"""
+
+parser = argparse.ArgumentParser(
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    description=DESC.strip())
+
+BINDGEN_ARGS = "--with-derive-partialeq \
+--with-derive-eq \
+--with-derive-partialord \
+--with-derive-ord \
+--with-derive-hash \
+--with-derive-default"
+
+parser.add_argument(
+    "--bindgen-args",
+    type=str,
+    default=BINDGEN_ARGS,
+    help="An argument string that `bindgen` should be invoked with. By default, all traits are derived. Note that the input header and output bindings file will automatically be provided by this script, and you should not manually specify them.")
+
+parser.add_argument(
+    "--save-temp-files",
+    action="store_true",
+    help="Do not delete temporary files.")
+
+parser.add_argument(
+    "input",
+    type=str,
+    default="input.h",
+    help="The input header file. Defaults to 'input.h'.")
+
+REDUCING_DESC = """
+
+Arguments that are useful when reducing known-bad test cases into
+equivalent-but-smaller test cases that exhibit the same bug with `creduce`.
+
+"""
+
+reducing = parser.add_argument_group("reducing arguments", REDUCING_DESC.strip())
+
+reducing.add_argument(
+    "--release",
+    action="store_true",
+    help="Use a release instead of a debug build.")
+reducing.add_argument(
+    "--expect-bindgen-fail",
+    action="store_true",
+    help="Exit non-zero if `bindgen` successfully emits bindings.")
+reducing.add_argument(
+    "--bindgen-grep",
+    type=str,
+    help="Exit non-zero if the given regexp pattern is not found in `bindgen`'s output.")
+reducing.add_argument(
+    "--bindings-grep",
+    type=str,
+    nargs='*',
+    help="Exit non-zero if the given regexp pattern is not found in the emitted bindings.")
+
+reducing.add_argument(
+    "--no-compile-bindings",
+    action="store_false",
+    dest="rustc",
+    help="Do not attempt to compile the emitted bindings with `rustc`.")
+reducing.add_argument(
+    "--extra-compile-file",
+    type=str,
+    help="Append the content of this extra file to the end of the emitted bindings just before compiling it.")
+reducing.add_argument(
+    "--expect-compile-fail",
+    action="store_true",
+    help="Exit non-zero if `rustc` successfully compiles the emitted bindings.")
+reducing.add_argument(
+    "--rustc-grep",
+    type=str,
+    help="Exit non-zero if the output from compiling the bindings with `rustc` does not contain the given regexp pattern")
+
+reducing.add_argument(
+    "--no-layout-tests",
+    action="store_false",
+    dest="layout_tests",
+    help="Do not run the compiled bindings' layout tests.")
+reducing.add_argument(
+    "--expect-layout-tests-fail",
+    action="store_true",
+    help="Exit non-zero if the compiled bindings' layout tests pass.")
+reducing.add_argument(
+    "--layout-tests-grep",
+    type=str,
+    help="Exit non-zero if the output of running the compiled bindings' layout tests does not contain the given regexp pattern.")
+
+################################################################################
+
+class ExitOne(Exception):
+    pass
+
+def exit_1(msg, child=None):
+    print(msg)
+
+    if child:
+        stdout = decode(child.stdout)
+        for line in stdout.splitlines():
+            sys.stdout.write("+")
+            sys.stdout.write(line)
+            sys.stdout.write("\n")
+        stderr = decode(child.stderr)
+        for line in stderr.splitlines():
+            sys.stderr.write("+")
+            sys.stderr.write(line)
+            sys.stderr.write("\n")
+
+    raise ExitOne()
+
+def main():
+    args = parser.parse_args()
+    os.environ["RUST_BACKTRACE"] = "full"
+
+    exit_code = 0
+    try:
+        bindings = new_temp_file(prefix="bindings-", suffix=".rs")
+        run_bindgen(args, bindings)
+
+        if args.rustc and not args.expect_bindgen_fail:
+            test_exe = new_temp_file(prefix="layout-tests-")
+            run_rustc(args, bindings, test_exe)
+
+            if args.layout_tests and not args.expect_compile_fail:
+                run_layout_tests(args, test_exe)
+    except ExitOne:
+        exit_code = 1
+    except Exception as e:
+        exit_code = 2
+        print("Unexpected exception:", e)
+
+    if not args.save_temp_files:
+        for path in TEMP_FILES:
+            try:
+                os.remove(path)
+            except Exception as e:
+                print("Unexpected exception:", e)
+
+    sys.exit(exit_code)
+
+def run(cmd, **kwargs):
+    print("Running:", cmd)
+    return subprocess.run(cmd, **kwargs)
+
+def decode(f):
+    return f.decode(encoding="utf-8", errors="ignore")
+
+TEMP_FILES = []
+
+def new_temp_file(prefix, suffix=None):
+    temp = NamedTemporaryFile(delete=False, prefix=prefix, suffix=suffix)
+    temp.close()
+    TEMP_FILES.append(temp.name)
+    return temp.name
+
+def contains(pattern, lines):
+    for line in lines:
+        if re.match(pattern, line):
+            return True
+    return False
+
+def regexp(pattern):
+    if not pattern.startswith("^"):
+        pattern = ".*" + pattern
+    if not pattern.endswith("$"):
+        pattern = pattern + ".*"
+    return re.compile(pattern)
+
+def run_bindgen(args, bindings):
+    manifest_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),
+                                                 "..",
+                                                 "Cargo.toml"))
+    command = ["cargo", "run", "--manifest-path", manifest_path]
+    if args.release:
+        command += ["--release"]
+    command += ["--", args.input, "-o", bindings]
+    command += shlex.split(args.bindgen_args)
+
+    child = run(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+
+    if args.bindgen_grep:
+        pattern = regexp(args.bindgen_grep)
+        if not (contains(pattern, decode(child.stdout).splitlines()) or
+                contains(pattern, decode(child.stderr).splitlines())):
+            exit_1("Error: did not find '{}' in `bindgen`'s output".format(args.bindgen_grep), child)
+
+    if args.expect_bindgen_fail and child.returncode == 0:
+        exit_1("Error: expected running `bindgen` to fail, but it didn't", child)
+
+    if not args.expect_bindgen_fail and child.returncode != 0:
+        exit_1("Error: running `bindgen` failed", child)
+
+    for arg in args.bindings_grep or []:
+        pattern = regexp(arg)
+        with open(bindings, mode="r") as f:
+            if not contains(pattern, f):
+                print("Error: expected the emitted bindings to contain '{}', but they didn't".format(arg))
+                print("---------- {} ----------------------------------------------".format(bindings))
+                f.seek(0)
+                print(f.read())
+                raise ExitOne()
+
+def run_rustc(args, bindings, test_exe):
+    if args.extra_compile_file:
+        with open(bindings, mode="a") as outfile:
+            with open(args.extra_compile_file, mode="r") as infile:
+                outfile.write(infile.read())
+    child = run(
+        ["rustc", "--crate-type", "lib", "--test", "-o", test_exe, bindings],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE)
+
+    if args.rustc_grep:
+        pattern = regexp(args.rustc_grep)
+        if not (contains(pattern, decode(child.stdout).splitlines()) or
+                contains(pattern, decode(child.stderr).splitlines())):
+            exit_1("Error: did not find '{}' in `rustc`'s output".format(args.rustc_grep), child)
+
+    if args.expect_compile_fail and child.returncode == 0:
+        exit_1("Error: expected running `rustc` on the emitted bindings to fail, but it didn't", child)
+
+    if not args.expect_compile_fail and child.returncode != 0:
+        exit_1("Error: running `rustc` on the emitted bindings failed", child)
+
+def run_layout_tests(args, test_exe):
+    child = run(
+        [test_exe],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE)
+
+    if args.layout_tests_grep:
+        pattern = regexp(args.layout_tests_grep)
+        if not (contains(pattern, decode(child.stdout).splitlines()) or
+                contains(pattern, decode(child.stderr).splitlines())):
+            exit_1("Error: did not find '{}' in the compiled bindings' layout tests' output".format(args.layout_tests_grep), child)
+
+    if args.expect_layout_tests_fail and child.returncode == 0:
+        exit_1("Error: expected running the compiled bindings' layout tests to fail, but it didn't", child)
+
+    if not args.expect_layout_tests_fail and child.returncode != 0:
+        exit_1("Error: running the compiled bindings' layout tests failed", child)
+
+if __name__ == "__main__":
+    main()
diff --git a/bindgen/deps.rs b/bindgen/deps.rs
new file mode 100644
index 00000000..987225b2
--- /dev/null
+++ b/bindgen/deps.rs
@@ -0,0 +1,20 @@
+/// Generating build depfiles from parsed bindings.
+use std::{collections::BTreeSet, path::PathBuf};
+
+#[derive(Clone, Debug)]
+pub(crate) struct DepfileSpec {
+    pub output_module: String,
+    pub depfile_path: PathBuf,
+}
+
+impl DepfileSpec {
+    pub fn write(&self, deps: &BTreeSet<String>) -> std::io::Result<()> {
+        let mut buf = format!("{}:", self.output_module);
+
+        for file in deps {
+            buf = format!("{} {}", buf, file);
+        }
+
+        std::fs::write(&self.depfile_path, &buf)
+    }
+}
diff --git a/bindgen/extra_assertions.rs b/bindgen/extra_assertions.rs
new file mode 100644
index 00000000..0888bf39
--- /dev/null
+++ b/bindgen/extra_assertions.rs
@@ -0,0 +1,34 @@
+//! Macros for defining extra assertions that should only be checked in testing
+//! and/or CI when the `testing_only_extra_assertions` feature is enabled.
+
+/// Simple macro that forwards to assert! when using
+/// testing_only_extra_assertions.
+#[macro_export]
+macro_rules! extra_assert {
+    ( $cond:expr ) => {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            assert!($cond);
+        }
+    };
+    ( $cond:expr , $( $arg:tt )+ ) => {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            assert!($cond, $( $arg )* )
+        }
+    };
+}
+
+/// Simple macro that forwards to assert_eq! when using
+/// testing_only_extra_assertions.
+#[macro_export]
+macro_rules! extra_assert_eq {
+    ( $lhs:expr , $rhs:expr ) => {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            assert_eq!($lhs, $rhs);
+        }
+    };
+    ( $lhs:expr , $rhs:expr , $( $arg:tt )+ ) => {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            assert!($lhs, $rhs, $( $arg )* );
+        }
+    };
+}
diff --git a/bindgen/features.rs b/bindgen/features.rs
new file mode 100644
index 00000000..4f05b9eb
--- /dev/null
+++ b/bindgen/features.rs
@@ -0,0 +1,313 @@
+//! Contains code for selecting features
+
+#![deny(missing_docs)]
+#![deny(unused_extern_crates)]
+
+use std::io;
+use std::str::FromStr;
+
+/// Define RustTarget struct definition, Default impl, and conversions
+/// between RustTarget and String.
+macro_rules! rust_target_def {
+    ( $( $( #[$attr:meta] )* => $release:ident => $value:expr; )* ) => {
+        /// Represents the version of the Rust language to target.
+        ///
+        /// To support a beta release, use the corresponding stable release.
+        ///
+        /// This enum will have more variants added as necessary.
+        #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Hash)]
+        #[allow(non_camel_case_types)]
+        pub enum RustTarget {
+            $(
+                $(
+                    #[$attr]
+                )*
+                $release,
+            )*
+        }
+
+        impl Default for RustTarget {
+            /// Gives the latest stable Rust version
+            fn default() -> RustTarget {
+                LATEST_STABLE_RUST
+            }
+        }
+
+        impl FromStr for RustTarget {
+            type Err = io::Error;
+
+            /// Create a `RustTarget` from a string.
+            ///
+            /// * The stable/beta versions of Rust are of the form "1.0",
+            /// "1.19", etc.
+            /// * The nightly version should be specified with "nightly".
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s.as_ref() {
+                    $(
+                        stringify!($value) => Ok(RustTarget::$release),
+                    )*
+                    _ => Err(
+                        io::Error::new(
+                            io::ErrorKind::InvalidInput,
+                            concat!(
+                                "Got an invalid rust target. Accepted values ",
+                                "are of the form ",
+                                "\"1.0\" or \"nightly\"."))),
+                }
+            }
+        }
+
+        impl From<RustTarget> for String {
+            fn from(target: RustTarget) -> Self {
+                match target {
+                    $(
+                        RustTarget::$release => stringify!($value),
+                    )*
+                }.into()
+            }
+        }
+    }
+}
+
+/// Defines an array slice with all RustTarget values
+macro_rules! rust_target_values_def {
+    ( $( $( #[$attr:meta] )* => $release:ident => $value:expr; )* ) => {
+        /// Strings of allowed `RustTarget` values
+        pub static RUST_TARGET_STRINGS: &'static [&str] = &[
+            $(
+                stringify!($value),
+            )*
+        ];
+    }
+}
+
+/// Defines macro which takes a macro
+macro_rules! rust_target_base {
+    ( $x_macro:ident ) => {
+        $x_macro!(
+            /// Rust stable 1.0
+            => Stable_1_0 => 1.0;
+            /// Rust stable 1.17
+            ///  * Static lifetime elision ([RFC 1623](https://github.com/rust-lang/rfcs/blob/master/text/1623-static.md))
+            => Stable_1_17 => 1.17;
+            /// Rust stable 1.19
+            ///  * Untagged unions ([RFC 1444](https://github.com/rust-lang/rfcs/blob/master/text/1444-union.md))
+            => Stable_1_19 => 1.19;
+            /// Rust stable 1.20
+            ///  * Associated constants ([PR](https://github.com/rust-lang/rust/pull/42809))
+            => Stable_1_20 => 1.20;
+            /// Rust stable 1.21
+            ///  * Builtin impls for `Clone` ([PR](https://github.com/rust-lang/rust/pull/43690))
+            => Stable_1_21 => 1.21;
+            /// Rust stable 1.25
+            ///  * `repr(align)` ([PR](https://github.com/rust-lang/rust/pull/47006))
+            => Stable_1_25 => 1.25;
+            /// Rust stable 1.26
+            ///  * [i128 / u128 support](https://doc.rust-lang.org/std/primitive.i128.html)
+            => Stable_1_26 => 1.26;
+            /// Rust stable 1.27
+            ///  * `must_use` attribute on functions ([PR](https://github.com/rust-lang/rust/pull/48925))
+            => Stable_1_27 => 1.27;
+            /// Rust stable 1.28
+            ///  * `repr(transparent)` ([PR](https://github.com/rust-lang/rust/pull/51562))
+            => Stable_1_28 => 1.28;
+            /// Rust stable 1.30
+            ///  * `const fn` support for limited cases ([PR](https://github.com/rust-lang/rust/pull/54835/)
+            /// *  [c_void available in core](https://doc.rust-lang.org/core/ffi/enum.c_void.html)
+            => Stable_1_30 => 1.30;
+            /// Rust stable 1.33
+            ///  * repr(packed(N)) ([PR](https://github.com/rust-lang/rust/pull/57049))
+            => Stable_1_33 => 1.33;
+            /// Rust stable 1.36
+            ///  * `MaybeUninit` instead of `mem::uninitialized()` ([PR](https://github.com/rust-lang/rust/pull/60445))
+            => Stable_1_36 => 1.36;
+            /// Rust stable 1.40
+            /// * `non_exhaustive` enums/structs ([Tracking issue](https://github.com/rust-lang/rust/issues/44109))
+            => Stable_1_40 => 1.40;
+            /// Rust stable 1.47
+            /// * `larger_arrays` ([Tracking issue](https://github.com/rust-lang/rust/pull/74060))
+            => Stable_1_47 => 1.47;
+            /// Rust stable 1.64
+            ///  * `core_ffi_c` ([Tracking issue](https://github.com/rust-lang/rust/issues/94501))
+            => Stable_1_64 => 1.64;
+            /// Nightly rust
+            ///  * `thiscall` calling convention ([Tracking issue](https://github.com/rust-lang/rust/issues/42202))
+            ///  * `vectorcall` calling convention (no tracking issue)
+            => Nightly => nightly;
+        );
+    }
+}
+
+rust_target_base!(rust_target_def);
+rust_target_base!(rust_target_values_def);
+
+/// Latest stable release of Rust
+pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_64;
+
+/// Create RustFeatures struct definition, new(), and a getter for each field
+macro_rules! rust_feature_def {
+    (
+        $( $rust_target:ident {
+            $( $( #[$attr:meta] )* => $feature:ident; )*
+        } )*
+    ) => {
+        /// Features supported by a rust target
+        #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+        #[allow(missing_docs)] // Documentation should go into the relevant variants.
+        pub(crate) struct RustFeatures {
+            $( $(
+                $(
+                    #[$attr]
+                )*
+                pub $feature: bool,
+            )* )*
+        }
+
+        impl RustFeatures {
+            /// Gives a RustFeatures struct with all features disabled
+            fn new() -> Self {
+                RustFeatures {
+                    $( $(
+                        $feature: false,
+                    )* )*
+                }
+            }
+        }
+
+        impl From<RustTarget> for RustFeatures {
+            fn from(rust_target: RustTarget) -> Self {
+                let mut features = RustFeatures::new();
+
+                $(
+                if rust_target >= RustTarget::$rust_target {
+                    $(
+                    features.$feature = true;
+                    )*
+                }
+                )*
+
+                features
+            }
+        }
+    }
+}
+
+// NOTE(emilio): When adding or removing features here, make sure to update the
+// documentation for the relevant variant in the rust_target_base macro
+// definition.
+rust_feature_def!(
+    Stable_1_17 {
+        => static_lifetime_elision;
+    }
+    Stable_1_19 {
+        => untagged_union;
+    }
+    Stable_1_20 {
+        => associated_const;
+    }
+    Stable_1_21 {
+        => builtin_clone_impls;
+    }
+    Stable_1_25 {
+        => repr_align;
+    }
+    Stable_1_26 {
+        => i128_and_u128;
+    }
+    Stable_1_27 {
+        => must_use_function;
+    }
+    Stable_1_28 {
+        => repr_transparent;
+    }
+    Stable_1_30 {
+        => min_const_fn;
+        => core_ffi_c_void;
+    }
+    Stable_1_33 {
+        => repr_packed_n;
+    }
+    Stable_1_36 {
+        => maybe_uninit;
+    }
+    Stable_1_40 {
+        => non_exhaustive;
+    }
+    Stable_1_47 {
+        => larger_arrays;
+    }
+    Stable_1_64 {
+        => core_ffi_c;
+    }
+    Nightly {
+        => thiscall_abi;
+        => vectorcall_abi;
+    }
+);
+
+impl Default for RustFeatures {
+    fn default() -> Self {
+        let default_rust_target: RustTarget = Default::default();
+        Self::from(default_rust_target)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #![allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn target_features() {
+        let f_1_0 = RustFeatures::from(RustTarget::Stable_1_0);
+        assert!(
+            !f_1_0.static_lifetime_elision &&
+                !f_1_0.core_ffi_c_void &&
+                !f_1_0.untagged_union &&
+                !f_1_0.associated_const &&
+                !f_1_0.builtin_clone_impls &&
+                !f_1_0.repr_align &&
+                !f_1_0.thiscall_abi &&
+                !f_1_0.vectorcall_abi
+        );
+        let f_1_21 = RustFeatures::from(RustTarget::Stable_1_21);
+        assert!(
+            f_1_21.static_lifetime_elision &&
+                !f_1_21.core_ffi_c_void &&
+                f_1_21.untagged_union &&
+                f_1_21.associated_const &&
+                f_1_21.builtin_clone_impls &&
+                !f_1_21.repr_align &&
+                !f_1_21.thiscall_abi &&
+                !f_1_21.vectorcall_abi
+        );
+        let f_nightly = RustFeatures::from(RustTarget::Nightly);
+        assert!(
+            f_nightly.static_lifetime_elision &&
+                f_nightly.core_ffi_c_void &&
+                f_nightly.untagged_union &&
+                f_nightly.associated_const &&
+                f_nightly.builtin_clone_impls &&
+                f_nightly.maybe_uninit &&
+                f_nightly.repr_align &&
+                f_nightly.thiscall_abi &&
+                f_nightly.vectorcall_abi
+        );
+    }
+
+    fn test_target(target_str: &str, target: RustTarget) {
+        let target_string: String = target.into();
+        assert_eq!(target_str, target_string);
+        assert_eq!(target, RustTarget::from_str(target_str).unwrap());
+    }
+
+    #[test]
+    fn str_to_target() {
+        test_target("1.0", RustTarget::Stable_1_0);
+        test_target("1.17", RustTarget::Stable_1_17);
+        test_target("1.19", RustTarget::Stable_1_19);
+        test_target("1.21", RustTarget::Stable_1_21);
+        test_target("1.25", RustTarget::Stable_1_25);
+        test_target("nightly", RustTarget::Nightly);
+    }
+}
diff --git a/bindgen/ir/analysis/derive.rs b/bindgen/ir/analysis/derive.rs
new file mode 100644
index 00000000..d888cd55
--- /dev/null
+++ b/bindgen/ir/analysis/derive.rs
@@ -0,0 +1,732 @@
+//! Determining which types for which we cannot emit `#[derive(Trait)]`.
+
+use std::fmt;
+
+use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
+use crate::ir::analysis::has_vtable::HasVtable;
+use crate::ir::comp::CompKind;
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::derive::CanDerive;
+use crate::ir::function::FunctionSig;
+use crate::ir::item::{IsOpaque, Item};
+use crate::ir::layout::Layout;
+use crate::ir::template::TemplateParameters;
+use crate::ir::traversal::{EdgeKind, Trace};
+use crate::ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
+use crate::ir::ty::{Type, TypeKind};
+use crate::{Entry, HashMap, HashSet};
+
+/// Which trait to consider when doing the `CannotDerive` analysis.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum DeriveTrait {
+    /// The `Copy` trait.
+    Copy,
+    /// The `Debug` trait.
+    Debug,
+    /// The `Default` trait.
+    Default,
+    /// The `Hash` trait.
+    Hash,
+    /// The `PartialEq` and `PartialOrd` traits.
+    PartialEqOrPartialOrd,
+}
+
+/// An analysis that finds for each IR item whether a trait cannot be derived.
+///
+/// We use the monotone constraint function `cannot_derive`, defined as follows
+/// for type T:
+///
+/// * If T is Opaque and the layout of the type is known, get this layout as an
+///   opaquetype and check whether it can derive using trivial checks.
+///
+/// * If T is Array, a trait cannot be derived if the array is incomplete,
+///   if the length of the array is larger than the limit (unless the trait
+///   allows it), or the trait cannot be derived for the type of data the array
+///   contains.
+///
+/// * If T is Vector, a trait cannot be derived if the trait cannot be derived
+///   for the type of data the vector contains.
+///
+/// * If T is a type alias, a templated alias or an indirection to another type,
+///   the trait cannot be derived if the trait cannot be derived for type T
+///   refers to.
+///
+/// * If T is a compound type, the trait cannot be derived if the trait cannot
+///   be derived for any of its base members or fields.
+///
+/// * If T is an instantiation of an abstract template definition, the trait
+///   cannot be derived if any of the template arguments or template definition
+///   cannot derive the trait.
+///
+/// * For all other (simple) types, compiler and standard library limitations
+///   dictate whether the trait is implemented.
+#[derive(Debug, Clone)]
+pub struct CannotDerive<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    derive_trait: DeriveTrait,
+
+    // The incremental result of this analysis's computation.
+    // Contains information whether particular item can derive `derive_trait`
+    can_derive: HashMap<ItemId, CanDerive>,
+
+    // Dependencies saying that if a key ItemId has been inserted into the
+    // `cannot_derive_partialeq_or_partialord` set, then each of the ids
+    // in Vec<ItemId> need to be considered again.
+    //
+    // This is a subset of the natural IR graph with reversed edges, where we
+    // only include the edges from the IR graph that can affect whether a type
+    // can derive `derive_trait`.
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+}
+
+type EdgePredicate = fn(EdgeKind) -> bool;
+
+fn consider_edge_default(kind: EdgeKind) -> bool {
+    match kind {
+        // These are the only edges that can affect whether a type can derive
+        EdgeKind::BaseMember |
+        EdgeKind::Field |
+        EdgeKind::TypeReference |
+        EdgeKind::VarType |
+        EdgeKind::TemplateArgument |
+        EdgeKind::TemplateDeclaration |
+        EdgeKind::TemplateParameterDefinition => true,
+
+        EdgeKind::Constructor |
+        EdgeKind::Destructor |
+        EdgeKind::FunctionReturn |
+        EdgeKind::FunctionParameter |
+        EdgeKind::InnerType |
+        EdgeKind::InnerVar |
+        EdgeKind::Method |
+        EdgeKind::Generic => false,
+    }
+}
+
+impl<'ctx> CannotDerive<'ctx> {
+    fn insert<Id: Into<ItemId>>(
+        &mut self,
+        id: Id,
+        can_derive: CanDerive,
+    ) -> ConstrainResult {
+        let id = id.into();
+        trace!(
+            "inserting {:?} can_derive<{}>={:?}",
+            id,
+            self.derive_trait,
+            can_derive
+        );
+
+        if let CanDerive::Yes = can_derive {
+            return ConstrainResult::Same;
+        }
+
+        match self.can_derive.entry(id) {
+            Entry::Occupied(mut entry) => {
+                if *entry.get() < can_derive {
+                    entry.insert(can_derive);
+                    ConstrainResult::Changed
+                } else {
+                    ConstrainResult::Same
+                }
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(can_derive);
+                ConstrainResult::Changed
+            }
+        }
+    }
+
+    fn constrain_type(&mut self, item: &Item, ty: &Type) -> CanDerive {
+        if !self.ctx.allowlisted_items().contains(&item.id()) {
+            let can_derive = self
+                .ctx
+                .blocklisted_type_implements_trait(item, self.derive_trait);
+            match can_derive {
+                CanDerive::Yes => trace!(
+                    "    blocklisted type explicitly implements {}",
+                    self.derive_trait
+                ),
+                CanDerive::Manually => trace!(
+                    "    blocklisted type requires manual implementation of {}",
+                    self.derive_trait
+                ),
+                CanDerive::No => trace!(
+                    "    cannot derive {} for blocklisted type",
+                    self.derive_trait
+                ),
+            }
+            return can_derive;
+        }
+
+        if self.derive_trait.not_by_name(self.ctx, item) {
+            trace!(
+                "    cannot derive {} for explicitly excluded type",
+                self.derive_trait
+            );
+            return CanDerive::No;
+        }
+
+        trace!("ty: {:?}", ty);
+        if item.is_opaque(self.ctx, &()) {
+            if !self.derive_trait.can_derive_union() &&
+                ty.is_union() &&
+                self.ctx.options().rust_features().untagged_union
+            {
+                trace!(
+                    "    cannot derive {} for Rust unions",
+                    self.derive_trait
+                );
+                return CanDerive::No;
+            }
+
+            let layout_can_derive =
+                ty.layout(self.ctx).map_or(CanDerive::Yes, |l| {
+                    l.opaque().array_size_within_derive_limit(self.ctx)
+                });
+
+            match layout_can_derive {
+                CanDerive::Yes => {
+                    trace!(
+                        "    we can trivially derive {} for the layout",
+                        self.derive_trait
+                    );
+                }
+                _ => {
+                    trace!(
+                        "    we cannot derive {} for the layout",
+                        self.derive_trait
+                    );
+                }
+            };
+            return layout_can_derive;
+        }
+
+        match *ty.kind() {
+            // Handle the simple cases. These can derive traits without further
+            // information.
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Float(..) |
+            TypeKind::Enum(..) |
+            TypeKind::TypeParam |
+            TypeKind::UnresolvedTypeRef(..) |
+            TypeKind::Reference(..) |
+            TypeKind::ObjCInterface(..) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel => {
+                return self.derive_trait.can_derive_simple(ty.kind());
+            }
+            TypeKind::Pointer(inner) => {
+                let inner_type =
+                    self.ctx.resolve_type(inner).canonical_type(self.ctx);
+                if let TypeKind::Function(ref sig) = *inner_type.kind() {
+                    self.derive_trait.can_derive_fnptr(sig)
+                } else {
+                    self.derive_trait.can_derive_pointer()
+                }
+            }
+            TypeKind::Function(ref sig) => {
+                self.derive_trait.can_derive_fnptr(sig)
+            }
+
+            // Complex cases need more information
+            TypeKind::Array(t, len) => {
+                let inner_type =
+                    self.can_derive.get(&t.into()).cloned().unwrap_or_default();
+                if inner_type != CanDerive::Yes {
+                    trace!(
+                        "    arrays of T for which we cannot derive {} \
+                         also cannot derive {}",
+                        self.derive_trait,
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                if len == 0 && !self.derive_trait.can_derive_incomplete_array()
+                {
+                    trace!(
+                        "    cannot derive {} for incomplete arrays",
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                if self.derive_trait.can_derive_large_array(self.ctx) {
+                    trace!("    array can derive {}", self.derive_trait);
+                    return CanDerive::Yes;
+                }
+
+                if len > RUST_DERIVE_IN_ARRAY_LIMIT {
+                    trace!(
+                        "    array is too large to derive {}, but it may be implemented", self.derive_trait
+                    );
+                    return CanDerive::Manually;
+                }
+                trace!(
+                    "    array is small enough to derive {}",
+                    self.derive_trait
+                );
+                CanDerive::Yes
+            }
+            TypeKind::Vector(t, len) => {
+                let inner_type =
+                    self.can_derive.get(&t.into()).cloned().unwrap_or_default();
+                if inner_type != CanDerive::Yes {
+                    trace!(
+                        "    vectors of T for which we cannot derive {} \
+                         also cannot derive {}",
+                        self.derive_trait,
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+                assert_ne!(len, 0, "vectors cannot have zero length");
+                self.derive_trait.can_derive_vector()
+            }
+
+            TypeKind::Comp(ref info) => {
+                assert!(
+                    !info.has_non_type_template_params(),
+                    "The early ty.is_opaque check should have handled this case"
+                );
+
+                if !self.derive_trait.can_derive_compound_forward_decl() &&
+                    info.is_forward_declaration()
+                {
+                    trace!(
+                        "    cannot derive {} for forward decls",
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                // NOTE: Take into account that while unions in C and C++ are copied by
+                // default, the may have an explicit destructor in C++, so we can't
+                // defer this check just for the union case.
+                if !self.derive_trait.can_derive_compound_with_destructor() &&
+                    self.ctx.lookup_has_destructor(
+                        item.id().expect_type_id(self.ctx),
+                    )
+                {
+                    trace!(
+                        "    comp has destructor which cannot derive {}",
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                if info.kind() == CompKind::Union {
+                    if self.derive_trait.can_derive_union() {
+                        if self.ctx.options().rust_features().untagged_union &&
+                           // https://github.com/rust-lang/rust/issues/36640
+                           (!info.self_template_params(self.ctx).is_empty() ||
+                            !item.all_template_params(self.ctx).is_empty())
+                        {
+                            trace!(
+                                "    cannot derive {} for Rust union because issue 36640", self.derive_trait
+                            );
+                            return CanDerive::No;
+                        }
+                    // fall through to be same as non-union handling
+                    } else {
+                        if self.ctx.options().rust_features().untagged_union {
+                            trace!(
+                                "    cannot derive {} for Rust unions",
+                                self.derive_trait
+                            );
+                            return CanDerive::No;
+                        }
+
+                        let layout_can_derive =
+                            ty.layout(self.ctx).map_or(CanDerive::Yes, |l| {
+                                l.opaque()
+                                    .array_size_within_derive_limit(self.ctx)
+                            });
+                        match layout_can_derive {
+                            CanDerive::Yes => {
+                                trace!(
+                                    "    union layout can trivially derive {}",
+                                    self.derive_trait
+                                );
+                            }
+                            _ => {
+                                trace!(
+                                    "    union layout cannot derive {}",
+                                    self.derive_trait
+                                );
+                            }
+                        };
+                        return layout_can_derive;
+                    }
+                }
+
+                if !self.derive_trait.can_derive_compound_with_vtable() &&
+                    item.has_vtable(self.ctx)
+                {
+                    trace!(
+                        "    cannot derive {} for comp with vtable",
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                // Bitfield units are always represented as arrays of u8, but
+                // they're not traced as arrays, so we need to check here
+                // instead.
+                if !self.derive_trait.can_derive_large_array(self.ctx) &&
+                    info.has_too_large_bitfield_unit() &&
+                    !item.is_opaque(self.ctx, &())
+                {
+                    trace!(
+                        "    cannot derive {} for comp with too large bitfield unit",
+                        self.derive_trait
+                    );
+                    return CanDerive::No;
+                }
+
+                let pred = self.derive_trait.consider_edge_comp();
+                self.constrain_join(item, pred)
+            }
+
+            TypeKind::ResolvedTypeRef(..) |
+            TypeKind::TemplateAlias(..) |
+            TypeKind::Alias(..) |
+            TypeKind::BlockPointer(..) => {
+                let pred = self.derive_trait.consider_edge_typeref();
+                self.constrain_join(item, pred)
+            }
+
+            TypeKind::TemplateInstantiation(..) => {
+                let pred = self.derive_trait.consider_edge_tmpl_inst();
+                self.constrain_join(item, pred)
+            }
+
+            TypeKind::Opaque => unreachable!(
+                "The early ty.is_opaque check should have handled this case"
+            ),
+        }
+    }
+
+    fn constrain_join(
+        &mut self,
+        item: &Item,
+        consider_edge: EdgePredicate,
+    ) -> CanDerive {
+        let mut candidate = None;
+
+        item.trace(
+            self.ctx,
+            &mut |sub_id, edge_kind| {
+                // Ignore ourselves, since union with ourself is a
+                // no-op. Ignore edges that aren't relevant to the
+                // analysis.
+                if sub_id == item.id() || !consider_edge(edge_kind) {
+                    return;
+                }
+
+                let can_derive = self.can_derive
+                    .get(&sub_id)
+                    .cloned()
+                    .unwrap_or_default();
+
+                match can_derive {
+                    CanDerive::Yes => trace!("    member {:?} can derive {}", sub_id, self.derive_trait),
+                    CanDerive::Manually => trace!("    member {:?} cannot derive {}, but it may be implemented", sub_id, self.derive_trait),
+                    CanDerive::No => trace!("    member {:?} cannot derive {}", sub_id, self.derive_trait),
+                }
+
+                *candidate.get_or_insert(CanDerive::Yes) |= can_derive;
+            },
+            &(),
+        );
+
+        if candidate.is_none() {
+            trace!(
+                "    can derive {} because there are no members",
+                self.derive_trait
+            );
+        }
+        candidate.unwrap_or_default()
+    }
+}
+
+impl DeriveTrait {
+    fn not_by_name(&self, ctx: &BindgenContext, item: &Item) -> bool {
+        match self {
+            DeriveTrait::Copy => ctx.no_copy_by_name(item),
+            DeriveTrait::Debug => ctx.no_debug_by_name(item),
+            DeriveTrait::Default => ctx.no_default_by_name(item),
+            DeriveTrait::Hash => ctx.no_hash_by_name(item),
+            DeriveTrait::PartialEqOrPartialOrd => {
+                ctx.no_partialeq_by_name(item)
+            }
+        }
+    }
+
+    fn consider_edge_comp(&self) -> EdgePredicate {
+        match self {
+            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
+            _ => |kind| matches!(kind, EdgeKind::BaseMember | EdgeKind::Field),
+        }
+    }
+
+    fn consider_edge_typeref(&self) -> EdgePredicate {
+        match self {
+            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
+            _ => |kind| kind == EdgeKind::TypeReference,
+        }
+    }
+
+    fn consider_edge_tmpl_inst(&self) -> EdgePredicate {
+        match self {
+            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
+            _ => |kind| {
+                matches!(
+                    kind,
+                    EdgeKind::TemplateArgument | EdgeKind::TemplateDeclaration
+                )
+            },
+        }
+    }
+
+    fn can_derive_large_array(&self, ctx: &BindgenContext) -> bool {
+        if ctx.options().rust_features().larger_arrays {
+            !matches!(self, DeriveTrait::Default)
+        } else {
+            matches!(self, DeriveTrait::Copy)
+        }
+    }
+
+    fn can_derive_union(&self) -> bool {
+        matches!(self, DeriveTrait::Copy)
+    }
+
+    fn can_derive_compound_with_destructor(&self) -> bool {
+        !matches!(self, DeriveTrait::Copy)
+    }
+
+    fn can_derive_compound_with_vtable(&self) -> bool {
+        !matches!(self, DeriveTrait::Default)
+    }
+
+    fn can_derive_compound_forward_decl(&self) -> bool {
+        matches!(self, DeriveTrait::Copy | DeriveTrait::Debug)
+    }
+
+    fn can_derive_incomplete_array(&self) -> bool {
+        !matches!(
+            self,
+            DeriveTrait::Copy |
+                DeriveTrait::Hash |
+                DeriveTrait::PartialEqOrPartialOrd
+        )
+    }
+
+    fn can_derive_fnptr(&self, f: &FunctionSig) -> CanDerive {
+        match (self, f.function_pointers_can_derive()) {
+            (DeriveTrait::Copy, _) | (DeriveTrait::Default, _) | (_, true) => {
+                trace!("    function pointer can derive {}", self);
+                CanDerive::Yes
+            }
+            (DeriveTrait::Debug, false) => {
+                trace!("    function pointer cannot derive {}, but it may be implemented", self);
+                CanDerive::Manually
+            }
+            (_, false) => {
+                trace!("    function pointer cannot derive {}", self);
+                CanDerive::No
+            }
+        }
+    }
+
+    fn can_derive_vector(&self) -> CanDerive {
+        match self {
+            DeriveTrait::PartialEqOrPartialOrd => {
+                // FIXME: vectors always can derive PartialEq, but they should
+                // not derive PartialOrd:
+                // https://github.com/rust-lang-nursery/packed_simd/issues/48
+                trace!("    vectors cannot derive PartialOrd");
+                CanDerive::No
+            }
+            _ => {
+                trace!("    vector can derive {}", self);
+                CanDerive::Yes
+            }
+        }
+    }
+
+    fn can_derive_pointer(&self) -> CanDerive {
+        match self {
+            DeriveTrait::Default => {
+                trace!("    pointer cannot derive Default");
+                CanDerive::No
+            }
+            _ => {
+                trace!("    pointer can derive {}", self);
+                CanDerive::Yes
+            }
+        }
+    }
+
+    fn can_derive_simple(&self, kind: &TypeKind) -> CanDerive {
+        match (self, kind) {
+            // === Default ===
+            (DeriveTrait::Default, TypeKind::Void) |
+            (DeriveTrait::Default, TypeKind::NullPtr) |
+            (DeriveTrait::Default, TypeKind::Enum(..)) |
+            (DeriveTrait::Default, TypeKind::Reference(..)) |
+            (DeriveTrait::Default, TypeKind::TypeParam) |
+            (DeriveTrait::Default, TypeKind::ObjCInterface(..)) |
+            (DeriveTrait::Default, TypeKind::ObjCId) |
+            (DeriveTrait::Default, TypeKind::ObjCSel) => {
+                trace!("    types that always cannot derive Default");
+                CanDerive::No
+            }
+            (DeriveTrait::Default, TypeKind::UnresolvedTypeRef(..)) => {
+                unreachable!(
+                    "Type with unresolved type ref can't reach derive default"
+                )
+            }
+            // === Hash ===
+            (DeriveTrait::Hash, TypeKind::Float(..)) |
+            (DeriveTrait::Hash, TypeKind::Complex(..)) => {
+                trace!("    float cannot derive Hash");
+                CanDerive::No
+            }
+            // === others ===
+            _ => {
+                trace!("    simple type that can always derive {}", self);
+                CanDerive::Yes
+            }
+        }
+    }
+}
+
+impl fmt::Display for DeriveTrait {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match self {
+            DeriveTrait::Copy => "Copy",
+            DeriveTrait::Debug => "Debug",
+            DeriveTrait::Default => "Default",
+            DeriveTrait::Hash => "Hash",
+            DeriveTrait::PartialEqOrPartialOrd => "PartialEq/PartialOrd",
+        };
+        s.fmt(f)
+    }
+}
+
+impl<'ctx> MonotoneFramework for CannotDerive<'ctx> {
+    type Node = ItemId;
+    type Extra = (&'ctx BindgenContext, DeriveTrait);
+    type Output = HashMap<ItemId, CanDerive>;
+
+    fn new(
+        (ctx, derive_trait): (&'ctx BindgenContext, DeriveTrait),
+    ) -> CannotDerive<'ctx> {
+        let can_derive = HashMap::default();
+        let dependencies = generate_dependencies(ctx, consider_edge_default);
+
+        CannotDerive {
+            ctx,
+            derive_trait,
+            can_derive,
+            dependencies,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        // The transitive closure of all allowlisted items, including explicitly
+        // blocklisted items.
+        self.ctx
+            .allowlisted_items()
+            .iter()
+            .cloned()
+            .flat_map(|i| {
+                let mut reachable = vec![i];
+                i.trace(
+                    self.ctx,
+                    &mut |s, _| {
+                        reachable.push(s);
+                    },
+                    &(),
+                );
+                reachable
+            })
+            .collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        trace!("constrain: {:?}", id);
+
+        if let Some(CanDerive::No) = self.can_derive.get(&id).cloned() {
+            trace!("    already know it cannot derive {}", self.derive_trait);
+            return ConstrainResult::Same;
+        }
+
+        let item = self.ctx.resolve_item(id);
+        let can_derive = match item.as_type() {
+            Some(ty) => {
+                let mut can_derive = self.constrain_type(item, ty);
+                if let CanDerive::Yes = can_derive {
+                    let is_reached_limit =
+                        |l: Layout| l.align > RUST_DERIVE_IN_ARRAY_LIMIT;
+                    if !self.derive_trait.can_derive_large_array(self.ctx) &&
+                        ty.layout(self.ctx).map_or(false, is_reached_limit)
+                    {
+                        // We have to be conservative: the struct *could* have enough
+                        // padding that we emit an array that is longer than
+                        // `RUST_DERIVE_IN_ARRAY_LIMIT`. If we moved padding calculations
+                        // into the IR and computed them before this analysis, then we could
+                        // be precise rather than conservative here.
+                        can_derive = CanDerive::Manually;
+                    }
+                }
+                can_derive
+            }
+            None => self.constrain_join(item, consider_edge_default),
+        };
+
+        self.insert(id, can_derive)
+    }
+
+    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<CannotDerive<'ctx>> for HashMap<ItemId, CanDerive> {
+    fn from(analysis: CannotDerive<'ctx>) -> Self {
+        extra_assert!(analysis
+            .can_derive
+            .values()
+            .all(|v| *v != CanDerive::Yes));
+
+        analysis.can_derive
+    }
+}
+
+/// Convert a `HashMap<ItemId, CanDerive>` into a `HashSet<ItemId>`.
+///
+/// Elements that are not `CanDerive::Yes` are kept in the set, so that it
+/// represents all items that cannot derive.
+pub fn as_cannot_derive_set(
+    can_derive: HashMap<ItemId, CanDerive>,
+) -> HashSet<ItemId> {
+    can_derive
+        .into_iter()
+        .filter_map(|(k, v)| if v != CanDerive::Yes { Some(k) } else { None })
+        .collect()
+}
diff --git a/bindgen/ir/analysis/has_destructor.rs b/bindgen/ir/analysis/has_destructor.rs
new file mode 100644
index 00000000..74fd73d1
--- /dev/null
+++ b/bindgen/ir/analysis/has_destructor.rs
@@ -0,0 +1,176 @@
+//! Determining which types have destructors
+
+use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
+use crate::ir::comp::{CompKind, Field, FieldMethods};
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::traversal::EdgeKind;
+use crate::ir::ty::TypeKind;
+use crate::{HashMap, HashSet};
+
+/// An analysis that finds for each IR item whether it has a destructor or not
+///
+/// We use the monotone function `has destructor`, defined as follows:
+///
+/// * If T is a type alias, a templated alias, or an indirection to another type,
+///   T has a destructor if the type T refers to has a destructor.
+/// * If T is a compound type, T has a destructor if we saw a destructor when parsing it,
+///   or if it's a struct, T has a destructor if any of its base members has a destructor,
+///   or if any of its fields have a destructor.
+/// * If T is an instantiation of an abstract template definition, T has
+///   a destructor if its template definition has a destructor,
+///   or if any of the template arguments has a destructor.
+/// * If T is the type of a field, that field has a destructor if it's not a bitfield,
+///   and if T has a destructor.
+#[derive(Debug, Clone)]
+pub struct HasDestructorAnalysis<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    // The incremental result of this analysis's computation. Everything in this
+    // set definitely has a destructor.
+    have_destructor: HashSet<ItemId>,
+
+    // Dependencies saying that if a key ItemId has been inserted into the
+    // `have_destructor` set, then each of the ids in Vec<ItemId> need to be
+    // considered again.
+    //
+    // This is a subset of the natural IR graph with reversed edges, where we
+    // only include the edges from the IR graph that can affect whether a type
+    // has a destructor or not.
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+}
+
+impl<'ctx> HasDestructorAnalysis<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        // These are the only edges that can affect whether a type has a
+        // destructor or not.
+        matches!(
+            kind,
+            EdgeKind::TypeReference |
+                EdgeKind::BaseMember |
+                EdgeKind::Field |
+                EdgeKind::TemplateArgument |
+                EdgeKind::TemplateDeclaration
+        )
+    }
+
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
+        let was_not_already_in_set = self.have_destructor.insert(id);
+        assert!(
+            was_not_already_in_set,
+            "We shouldn't try and insert {:?} twice because if it was \
+             already in the set, `constrain` should have exited early.",
+            id
+        );
+        ConstrainResult::Changed
+    }
+}
+
+impl<'ctx> MonotoneFramework for HasDestructorAnalysis<'ctx> {
+    type Node = ItemId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashSet<ItemId>;
+
+    fn new(ctx: &'ctx BindgenContext) -> Self {
+        let have_destructor = HashSet::default();
+        let dependencies = generate_dependencies(ctx, Self::consider_edge);
+
+        HasDestructorAnalysis {
+            ctx,
+            have_destructor,
+            dependencies,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        self.ctx.allowlisted_items().iter().cloned().collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        if self.have_destructor.contains(&id) {
+            // We've already computed that this type has a destructor and that can't
+            // change.
+            return ConstrainResult::Same;
+        }
+
+        let item = self.ctx.resolve_item(id);
+        let ty = match item.as_type() {
+            None => return ConstrainResult::Same,
+            Some(ty) => ty,
+        };
+
+        match *ty.kind() {
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::ResolvedTypeRef(t) => {
+                if self.have_destructor.contains(&t.into()) {
+                    self.insert(id)
+                } else {
+                    ConstrainResult::Same
+                }
+            }
+
+            TypeKind::Comp(ref info) => {
+                if info.has_own_destructor() {
+                    return self.insert(id);
+                }
+
+                match info.kind() {
+                    CompKind::Union => ConstrainResult::Same,
+                    CompKind::Struct => {
+                        let base_or_field_destructor =
+                            info.base_members().iter().any(|base| {
+                                self.have_destructor.contains(&base.ty.into())
+                            }) || info.fields().iter().any(
+                                |field| match *field {
+                                    Field::DataMember(ref data) => self
+                                        .have_destructor
+                                        .contains(&data.ty().into()),
+                                    Field::Bitfields(_) => false,
+                                },
+                            );
+                        if base_or_field_destructor {
+                            self.insert(id)
+                        } else {
+                            ConstrainResult::Same
+                        }
+                    }
+                }
+            }
+
+            TypeKind::TemplateInstantiation(ref inst) => {
+                let definition_or_arg_destructor = self
+                    .have_destructor
+                    .contains(&inst.template_definition().into()) ||
+                    inst.template_arguments().iter().any(|arg| {
+                        self.have_destructor.contains(&arg.into())
+                    });
+                if definition_or_arg_destructor {
+                    self.insert(id)
+                } else {
+                    ConstrainResult::Same
+                }
+            }
+
+            _ => ConstrainResult::Same,
+        }
+    }
+
+    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<HasDestructorAnalysis<'ctx>> for HashSet<ItemId> {
+    fn from(analysis: HasDestructorAnalysis<'ctx>) -> Self {
+        analysis.have_destructor
+    }
+}
diff --git a/bindgen/ir/analysis/has_float.rs b/bindgen/ir/analysis/has_float.rs
new file mode 100644
index 00000000..bbf2126f
--- /dev/null
+++ b/bindgen/ir/analysis/has_float.rs
@@ -0,0 +1,252 @@
+//! Determining which types has float.
+
+use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
+use crate::ir::comp::Field;
+use crate::ir::comp::FieldMethods;
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::traversal::EdgeKind;
+use crate::ir::ty::TypeKind;
+use crate::{HashMap, HashSet};
+
+/// An analysis that finds for each IR item whether it has float or not.
+///
+/// We use the monotone constraint function `has_float`,
+/// defined as follows:
+///
+/// * If T is float or complex float, T trivially has.
+/// * If T is a type alias, a templated alias or an indirection to another type,
+///   it has float if the type T refers to has.
+/// * If T is a compound type, it has float if any of base memter or field
+///   has.
+/// * If T is an instantiation of an abstract template definition, T has
+///   float if any of the template arguments or template definition
+///   has.
+#[derive(Debug, Clone)]
+pub struct HasFloat<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    // The incremental result of this analysis's computation. Everything in this
+    // set has float.
+    has_float: HashSet<ItemId>,
+
+    // Dependencies saying that if a key ItemId has been inserted into the
+    // `has_float` set, then each of the ids in Vec<ItemId> need to be
+    // considered again.
+    //
+    // This is a subset of the natural IR graph with reversed edges, where we
+    // only include the edges from the IR graph that can affect whether a type
+    // has float or not.
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+}
+
+impl<'ctx> HasFloat<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        match kind {
+            EdgeKind::BaseMember |
+            EdgeKind::Field |
+            EdgeKind::TypeReference |
+            EdgeKind::VarType |
+            EdgeKind::TemplateArgument |
+            EdgeKind::TemplateDeclaration |
+            EdgeKind::TemplateParameterDefinition => true,
+
+            EdgeKind::Constructor |
+            EdgeKind::Destructor |
+            EdgeKind::FunctionReturn |
+            EdgeKind::FunctionParameter |
+            EdgeKind::InnerType |
+            EdgeKind::InnerVar |
+            EdgeKind::Method => false,
+            EdgeKind::Generic => false,
+        }
+    }
+
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
+        trace!("inserting {:?} into the has_float set", id);
+
+        let was_not_already_in_set = self.has_float.insert(id);
+        assert!(
+            was_not_already_in_set,
+            "We shouldn't try and insert {:?} twice because if it was \
+             already in the set, `constrain` should have exited early.",
+            id
+        );
+
+        ConstrainResult::Changed
+    }
+}
+
+impl<'ctx> MonotoneFramework for HasFloat<'ctx> {
+    type Node = ItemId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashSet<ItemId>;
+
+    fn new(ctx: &'ctx BindgenContext) -> HasFloat<'ctx> {
+        let has_float = HashSet::default();
+        let dependencies = generate_dependencies(ctx, Self::consider_edge);
+
+        HasFloat {
+            ctx,
+            has_float,
+            dependencies,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        self.ctx.allowlisted_items().iter().cloned().collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        trace!("constrain: {:?}", id);
+
+        if self.has_float.contains(&id) {
+            trace!("    already know it do not have float");
+            return ConstrainResult::Same;
+        }
+
+        let item = self.ctx.resolve_item(id);
+        let ty = match item.as_type() {
+            Some(ty) => ty,
+            None => {
+                trace!("    not a type; ignoring");
+                return ConstrainResult::Same;
+            }
+        };
+
+        match *ty.kind() {
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(..) |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::Reference(..) |
+            TypeKind::TypeParam |
+            TypeKind::Opaque |
+            TypeKind::Pointer(..) |
+            TypeKind::UnresolvedTypeRef(..) |
+            TypeKind::ObjCInterface(..) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel => {
+                trace!("    simple type that do not have float");
+                ConstrainResult::Same
+            }
+
+            TypeKind::Float(..) | TypeKind::Complex(..) => {
+                trace!("    float type has float");
+                self.insert(id)
+            }
+
+            TypeKind::Array(t, _) => {
+                if self.has_float.contains(&t.into()) {
+                    trace!(
+                        "    Array with type T that has float also has float"
+                    );
+                    return self.insert(id);
+                }
+                trace!("    Array with type T that do not have float also do not have float");
+                ConstrainResult::Same
+            }
+            TypeKind::Vector(t, _) => {
+                if self.has_float.contains(&t.into()) {
+                    trace!(
+                        "    Vector with type T that has float also has float"
+                    );
+                    return self.insert(id);
+                }
+                trace!("    Vector with type T that do not have float also do not have float");
+                ConstrainResult::Same
+            }
+
+            TypeKind::ResolvedTypeRef(t) |
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::BlockPointer(t) => {
+                if self.has_float.contains(&t.into()) {
+                    trace!(
+                        "    aliases and type refs to T which have float \
+                         also have float"
+                    );
+                    self.insert(id)
+                } else {
+                    trace!("    aliases and type refs to T which do not have float \
+                            also do not have floaarrayt");
+                    ConstrainResult::Same
+                }
+            }
+
+            TypeKind::Comp(ref info) => {
+                let bases_have = info
+                    .base_members()
+                    .iter()
+                    .any(|base| self.has_float.contains(&base.ty.into()));
+                if bases_have {
+                    trace!("    bases have float, so we also have");
+                    return self.insert(id);
+                }
+                let fields_have = info.fields().iter().any(|f| match *f {
+                    Field::DataMember(ref data) => {
+                        self.has_float.contains(&data.ty().into())
+                    }
+                    Field::Bitfields(ref bfu) => bfu
+                        .bitfields()
+                        .iter()
+                        .any(|b| self.has_float.contains(&b.ty().into())),
+                });
+                if fields_have {
+                    trace!("    fields have float, so we also have");
+                    return self.insert(id);
+                }
+
+                trace!("    comp doesn't have float");
+                ConstrainResult::Same
+            }
+
+            TypeKind::TemplateInstantiation(ref template) => {
+                let args_have = template
+                    .template_arguments()
+                    .iter()
+                    .any(|arg| self.has_float.contains(&arg.into()));
+                if args_have {
+                    trace!(
+                        "    template args have float, so \
+                         insantiation also has float"
+                    );
+                    return self.insert(id);
+                }
+
+                let def_has = self
+                    .has_float
+                    .contains(&template.template_definition().into());
+                if def_has {
+                    trace!(
+                        "    template definition has float, so \
+                         insantiation also has"
+                    );
+                    return self.insert(id);
+                }
+
+                trace!("    template instantiation do not have float");
+                ConstrainResult::Same
+            }
+        }
+    }
+
+    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<HasFloat<'ctx>> for HashSet<ItemId> {
+    fn from(analysis: HasFloat<'ctx>) -> Self {
+        analysis.has_float
+    }
+}
diff --git a/bindgen/ir/analysis/has_type_param_in_array.rs b/bindgen/ir/analysis/has_type_param_in_array.rs
new file mode 100644
index 00000000..aa523047
--- /dev/null
+++ b/bindgen/ir/analysis/has_type_param_in_array.rs
@@ -0,0 +1,252 @@
+//! Determining which types has typed parameters in array.
+
+use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
+use crate::ir::comp::Field;
+use crate::ir::comp::FieldMethods;
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::traversal::EdgeKind;
+use crate::ir::ty::TypeKind;
+use crate::{HashMap, HashSet};
+
+/// An analysis that finds for each IR item whether it has array or not.
+///
+/// We use the monotone constraint function `has_type_parameter_in_array`,
+/// defined as follows:
+///
+/// * If T is Array type with type parameter, T trivially has.
+/// * If T is a type alias, a templated alias or an indirection to another type,
+///   it has type parameter in array if the type T refers to has.
+/// * If T is a compound type, it has array if any of base memter or field
+///   has type paramter in array.
+/// * If T is an instantiation of an abstract template definition, T has
+///   type parameter in array if any of the template arguments or template definition
+///   has.
+#[derive(Debug, Clone)]
+pub struct HasTypeParameterInArray<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    // The incremental result of this analysis's computation. Everything in this
+    // set has array.
+    has_type_parameter_in_array: HashSet<ItemId>,
+
+    // Dependencies saying that if a key ItemId has been inserted into the
+    // `has_type_parameter_in_array` set, then each of the ids in Vec<ItemId> need to be
+    // considered again.
+    //
+    // This is a subset of the natural IR graph with reversed edges, where we
+    // only include the edges from the IR graph that can affect whether a type
+    // has array or not.
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+}
+
+impl<'ctx> HasTypeParameterInArray<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        match kind {
+            // These are the only edges that can affect whether a type has type parameter
+            // in array or not.
+            EdgeKind::BaseMember |
+            EdgeKind::Field |
+            EdgeKind::TypeReference |
+            EdgeKind::VarType |
+            EdgeKind::TemplateArgument |
+            EdgeKind::TemplateDeclaration |
+            EdgeKind::TemplateParameterDefinition => true,
+
+            EdgeKind::Constructor |
+            EdgeKind::Destructor |
+            EdgeKind::FunctionReturn |
+            EdgeKind::FunctionParameter |
+            EdgeKind::InnerType |
+            EdgeKind::InnerVar |
+            EdgeKind::Method => false,
+            EdgeKind::Generic => false,
+        }
+    }
+
+    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
+        let id = id.into();
+        trace!(
+            "inserting {:?} into the has_type_parameter_in_array set",
+            id
+        );
+
+        let was_not_already_in_set =
+            self.has_type_parameter_in_array.insert(id);
+        assert!(
+            was_not_already_in_set,
+            "We shouldn't try and insert {:?} twice because if it was \
+             already in the set, `constrain` should have exited early.",
+            id
+        );
+
+        ConstrainResult::Changed
+    }
+}
+
+impl<'ctx> MonotoneFramework for HasTypeParameterInArray<'ctx> {
+    type Node = ItemId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashSet<ItemId>;
+
+    fn new(ctx: &'ctx BindgenContext) -> HasTypeParameterInArray<'ctx> {
+        let has_type_parameter_in_array = HashSet::default();
+        let dependencies = generate_dependencies(ctx, Self::consider_edge);
+
+        HasTypeParameterInArray {
+            ctx,
+            has_type_parameter_in_array,
+            dependencies,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        self.ctx.allowlisted_items().iter().cloned().collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        trace!("constrain: {:?}", id);
+
+        if self.has_type_parameter_in_array.contains(&id) {
+            trace!("    already know it do not have array");
+            return ConstrainResult::Same;
+        }
+
+        let item = self.ctx.resolve_item(id);
+        let ty = match item.as_type() {
+            Some(ty) => ty,
+            None => {
+                trace!("    not a type; ignoring");
+                return ConstrainResult::Same;
+            }
+        };
+
+        match *ty.kind() {
+            // Handle the simple cases. These cannot have array in type parameter
+            // without further information.
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Vector(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::Reference(..) |
+            TypeKind::TypeParam |
+            TypeKind::Opaque |
+            TypeKind::Pointer(..) |
+            TypeKind::UnresolvedTypeRef(..) |
+            TypeKind::ObjCInterface(..) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel => {
+                trace!("    simple type that do not have array");
+                ConstrainResult::Same
+            }
+
+            TypeKind::Array(t, _) => {
+                let inner_ty =
+                    self.ctx.resolve_type(t).canonical_type(self.ctx);
+                match *inner_ty.kind() {
+                    TypeKind::TypeParam => {
+                        trace!("    Array with Named type has type parameter");
+                        self.insert(id)
+                    }
+                    _ => {
+                        trace!(
+                            "    Array without Named type does have type parameter"
+                        );
+                        ConstrainResult::Same
+                    }
+                }
+            }
+
+            TypeKind::ResolvedTypeRef(t) |
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::BlockPointer(t) => {
+                if self.has_type_parameter_in_array.contains(&t.into()) {
+                    trace!(
+                        "    aliases and type refs to T which have array \
+                         also have array"
+                    );
+                    self.insert(id)
+                } else {
+                    trace!(
+                        "    aliases and type refs to T which do not have array \
+                            also do not have array"
+                    );
+                    ConstrainResult::Same
+                }
+            }
+
+            TypeKind::Comp(ref info) => {
+                let bases_have = info.base_members().iter().any(|base| {
+                    self.has_type_parameter_in_array.contains(&base.ty.into())
+                });
+                if bases_have {
+                    trace!("    bases have array, so we also have");
+                    return self.insert(id);
+                }
+                let fields_have = info.fields().iter().any(|f| match *f {
+                    Field::DataMember(ref data) => self
+                        .has_type_parameter_in_array
+                        .contains(&data.ty().into()),
+                    Field::Bitfields(..) => false,
+                });
+                if fields_have {
+                    trace!("    fields have array, so we also have");
+                    return self.insert(id);
+                }
+
+                trace!("    comp doesn't have array");
+                ConstrainResult::Same
+            }
+
+            TypeKind::TemplateInstantiation(ref template) => {
+                let args_have =
+                    template.template_arguments().iter().any(|arg| {
+                        self.has_type_parameter_in_array.contains(&arg.into())
+                    });
+                if args_have {
+                    trace!(
+                        "    template args have array, so \
+                         insantiation also has array"
+                    );
+                    return self.insert(id);
+                }
+
+                let def_has = self
+                    .has_type_parameter_in_array
+                    .contains(&template.template_definition().into());
+                if def_has {
+                    trace!(
+                        "    template definition has array, so \
+                         insantiation also has"
+                    );
+                    return self.insert(id);
+                }
+
+                trace!("    template instantiation do not have array");
+                ConstrainResult::Same
+            }
+        }
+    }
+
+    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<HasTypeParameterInArray<'ctx>> for HashSet<ItemId> {
+    fn from(analysis: HasTypeParameterInArray<'ctx>) -> Self {
+        analysis.has_type_parameter_in_array
+    }
+}
diff --git a/bindgen/ir/analysis/has_vtable.rs b/bindgen/ir/analysis/has_vtable.rs
new file mode 100644
index 00000000..8ac47a65
--- /dev/null
+++ b/bindgen/ir/analysis/has_vtable.rs
@@ -0,0 +1,240 @@
+//! Determining which types has vtable
+
+use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::traversal::EdgeKind;
+use crate::ir::ty::TypeKind;
+use crate::{Entry, HashMap};
+use std::cmp;
+use std::ops;
+
+/// The result of the `HasVtableAnalysis` for an individual item.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum HasVtableResult {
+    /// The item does not have a vtable pointer.
+    No,
+
+    /// The item has a vtable and the actual vtable pointer is within this item.
+    SelfHasVtable,
+
+    /// The item has a vtable, but the actual vtable pointer is in a base
+    /// member.
+    BaseHasVtable,
+}
+
+impl Default for HasVtableResult {
+    fn default() -> Self {
+        HasVtableResult::No
+    }
+}
+
+impl HasVtableResult {
+    /// Take the least upper bound of `self` and `rhs`.
+    pub fn join(self, rhs: Self) -> Self {
+        cmp::max(self, rhs)
+    }
+}
+
+impl ops::BitOr for HasVtableResult {
+    type Output = Self;
+
+    fn bitor(self, rhs: HasVtableResult) -> Self::Output {
+        self.join(rhs)
+    }
+}
+
+impl ops::BitOrAssign for HasVtableResult {
+    fn bitor_assign(&mut self, rhs: HasVtableResult) {
+        *self = self.join(rhs)
+    }
+}
+
+/// An analysis that finds for each IR item whether it has vtable or not
+///
+/// We use the monotone function `has vtable`, defined as follows:
+///
+/// * If T is a type alias, a templated alias, an indirection to another type,
+///   or a reference of a type, T has vtable if the type T refers to has vtable.
+/// * If T is a compound type, T has vtable if we saw a virtual function when
+///   parsing it or any of its base member has vtable.
+/// * If T is an instantiation of an abstract template definition, T has
+///   vtable if template definition has vtable
+#[derive(Debug, Clone)]
+pub struct HasVtableAnalysis<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    // The incremental result of this analysis's computation. Everything in this
+    // set definitely has a vtable.
+    have_vtable: HashMap<ItemId, HasVtableResult>,
+
+    // Dependencies saying that if a key ItemId has been inserted into the
+    // `have_vtable` set, then each of the ids in Vec<ItemId> need to be
+    // considered again.
+    //
+    // This is a subset of the natural IR graph with reversed edges, where we
+    // only include the edges from the IR graph that can affect whether a type
+    // has a vtable or not.
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+}
+
+impl<'ctx> HasVtableAnalysis<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        // These are the only edges that can affect whether a type has a
+        // vtable or not.
+        matches!(
+            kind,
+            EdgeKind::TypeReference |
+                EdgeKind::BaseMember |
+                EdgeKind::TemplateDeclaration
+        )
+    }
+
+    fn insert<Id: Into<ItemId>>(
+        &mut self,
+        id: Id,
+        result: HasVtableResult,
+    ) -> ConstrainResult {
+        if let HasVtableResult::No = result {
+            return ConstrainResult::Same;
+        }
+
+        let id = id.into();
+        match self.have_vtable.entry(id) {
+            Entry::Occupied(mut entry) => {
+                if *entry.get() < result {
+                    entry.insert(result);
+                    ConstrainResult::Changed
+                } else {
+                    ConstrainResult::Same
+                }
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(result);
+                ConstrainResult::Changed
+            }
+        }
+    }
+
+    fn forward<Id1, Id2>(&mut self, from: Id1, to: Id2) -> ConstrainResult
+    where
+        Id1: Into<ItemId>,
+        Id2: Into<ItemId>,
+    {
+        let from = from.into();
+        let to = to.into();
+
+        match self.have_vtable.get(&from).cloned() {
+            None => ConstrainResult::Same,
+            Some(r) => self.insert(to, r),
+        }
+    }
+}
+
+impl<'ctx> MonotoneFramework for HasVtableAnalysis<'ctx> {
+    type Node = ItemId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashMap<ItemId, HasVtableResult>;
+
+    fn new(ctx: &'ctx BindgenContext) -> HasVtableAnalysis<'ctx> {
+        let have_vtable = HashMap::default();
+        let dependencies = generate_dependencies(ctx, Self::consider_edge);
+
+        HasVtableAnalysis {
+            ctx,
+            have_vtable,
+            dependencies,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        self.ctx.allowlisted_items().iter().cloned().collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        trace!("constrain {:?}", id);
+
+        let item = self.ctx.resolve_item(id);
+        let ty = match item.as_type() {
+            None => return ConstrainResult::Same,
+            Some(ty) => ty,
+        };
+
+        // TODO #851: figure out a way to handle deriving from template type parameters.
+        match *ty.kind() {
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::ResolvedTypeRef(t) |
+            TypeKind::Reference(t) => {
+                trace!(
+                    "    aliases and references forward to their inner type"
+                );
+                self.forward(t, id)
+            }
+
+            TypeKind::Comp(ref info) => {
+                trace!("    comp considers its own methods and bases");
+                let mut result = HasVtableResult::No;
+
+                if info.has_own_virtual_method() {
+                    trace!("    comp has its own virtual method");
+                    result |= HasVtableResult::SelfHasVtable;
+                }
+
+                let bases_has_vtable = info.base_members().iter().any(|base| {
+                    trace!("    comp has a base with a vtable: {:?}", base);
+                    self.have_vtable.contains_key(&base.ty.into())
+                });
+                if bases_has_vtable {
+                    result |= HasVtableResult::BaseHasVtable;
+                }
+
+                self.insert(id, result)
+            }
+
+            TypeKind::TemplateInstantiation(ref inst) => {
+                self.forward(inst.template_definition(), id)
+            }
+
+            _ => ConstrainResult::Same,
+        }
+    }
+
+    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<HasVtableAnalysis<'ctx>> for HashMap<ItemId, HasVtableResult> {
+    fn from(analysis: HasVtableAnalysis<'ctx>) -> Self {
+        // We let the lack of an entry mean "No" to save space.
+        extra_assert!(analysis
+            .have_vtable
+            .values()
+            .all(|v| { *v != HasVtableResult::No }));
+
+        analysis.have_vtable
+    }
+}
+
+/// A convenience trait for the things for which we might wonder if they have a
+/// vtable during codegen.
+///
+/// This is not for _computing_ whether the thing has a vtable, it is for
+/// looking up the results of the HasVtableAnalysis's computations for a
+/// specific thing.
+pub trait HasVtable {
+    /// Return `true` if this thing has vtable, `false` otherwise.
+    fn has_vtable(&self, ctx: &BindgenContext) -> bool;
+
+    /// Return `true` if this thing has an actual vtable pointer in itself, as
+    /// opposed to transitively in a base member.
+    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool;
+}
diff --git a/bindgen/ir/analysis/mod.rs b/bindgen/ir/analysis/mod.rs
new file mode 100644
index 00000000..40dfc6d6
--- /dev/null
+++ b/bindgen/ir/analysis/mod.rs
@@ -0,0 +1,402 @@
+//! Fix-point analyses on the IR using the "monotone framework".
+//!
+//! A lattice is a set with a partial ordering between elements, where there is
+//! a single least upper bound and a single greatest least bound for every
+//! subset. We are dealing with finite lattices, which means that it has a
+//! finite number of elements, and it follows that there exists a single top and
+//! a single bottom member of the lattice. For example, the power set of a
+//! finite set forms a finite lattice where partial ordering is defined by set
+//! inclusion, that is `a <= b` if `a` is a subset of `b`. Here is the finite
+//! lattice constructed from the set {0,1,2}:
+//!
+//! ```text
+//!                    .----- Top = {0,1,2} -----.
+//!                   /            |              \
+//!                  /             |               \
+//!                 /              |                \
+//!              {0,1} -------.  {0,2}  .--------- {1,2}
+//!                |           \ /   \ /             |
+//!                |            /     \              |
+//!                |           / \   / \             |
+//!               {0} --------'   {1}   `---------- {2}
+//!                 \              |                /
+//!                  \             |               /
+//!                   \            |              /
+//!                    `------ Bottom = {} ------'
+//! ```
+//!
+//! A monotone function `f` is a function where if `x <= y`, then it holds that
+//! `f(x) <= f(y)`. It should be clear that running a monotone function to a
+//! fix-point on a finite lattice will always terminate: `f` can only "move"
+//! along the lattice in a single direction, and therefore can only either find
+//! a fix-point in the middle of the lattice or continue to the top or bottom
+//! depending if it is ascending or descending the lattice respectively.
+//!
+//! For a deeper introduction to the general form of this kind of analysis, see
+//! [Static Program Analysis by Anders Møller and Michael I. Schwartzbach][spa].
+//!
+//! [spa]: https://cs.au.dk/~amoeller/spa/spa.pdf
+
+// Re-export individual analyses.
+mod template_params;
+pub use self::template_params::UsedTemplateParameters;
+mod derive;
+pub use self::derive::{as_cannot_derive_set, CannotDerive, DeriveTrait};
+mod has_vtable;
+pub use self::has_vtable::{HasVtable, HasVtableAnalysis, HasVtableResult};
+mod has_destructor;
+pub use self::has_destructor::HasDestructorAnalysis;
+mod has_type_param_in_array;
+pub use self::has_type_param_in_array::HasTypeParameterInArray;
+mod has_float;
+pub use self::has_float::HasFloat;
+mod sizedness;
+pub use self::sizedness::{Sizedness, SizednessAnalysis, SizednessResult};
+
+use crate::ir::context::{BindgenContext, ItemId};
+
+use crate::ir::traversal::{EdgeKind, Trace};
+use crate::HashMap;
+use std::fmt;
+use std::ops;
+
+/// An analysis in the monotone framework.
+///
+/// Implementors of this trait must maintain the following two invariants:
+///
+/// 1. The concrete data must be a member of a finite-height lattice.
+/// 2. The concrete `constrain` method must be monotone: that is,
+///    if `x <= y`, then `constrain(x) <= constrain(y)`.
+///
+/// If these invariants do not hold, iteration to a fix-point might never
+/// complete.
+///
+/// For a simple example analysis, see the `ReachableFrom` type in the `tests`
+/// module below.
+pub trait MonotoneFramework: Sized + fmt::Debug {
+    /// The type of node in our dependency graph.
+    ///
+    /// This is just generic (and not `ItemId`) so that we can easily unit test
+    /// without constructing real `Item`s and their `ItemId`s.
+    type Node: Copy;
+
+    /// Any extra data that is needed during computation.
+    ///
+    /// Again, this is just generic (and not `&BindgenContext`) so that we can
+    /// easily unit test without constructing real `BindgenContext`s full of
+    /// real `Item`s and real `ItemId`s.
+    type Extra: Sized;
+
+    /// The final output of this analysis. Once we have reached a fix-point, we
+    /// convert `self` into this type, and return it as the final result of the
+    /// analysis.
+    type Output: From<Self> + fmt::Debug;
+
+    /// Construct a new instance of this analysis.
+    fn new(extra: Self::Extra) -> Self;
+
+    /// Get the initial set of nodes from which to start the analysis. Unless
+    /// you are sure of some domain-specific knowledge, this should be the
+    /// complete set of nodes.
+    fn initial_worklist(&self) -> Vec<Self::Node>;
+
+    /// Update the analysis for the given node.
+    ///
+    /// If this results in changing our internal state (ie, we discovered that
+    /// we have not reached a fix-point and iteration should continue), return
+    /// `ConstrainResult::Changed`. Otherwise, return `ConstrainResult::Same`.
+    /// When `constrain` returns `ConstrainResult::Same` for all nodes in the
+    /// set, we have reached a fix-point and the analysis is complete.
+    fn constrain(&mut self, node: Self::Node) -> ConstrainResult;
+
+    /// For each node `d` that depends on the given `node`'s current answer when
+    /// running `constrain(d)`, call `f(d)`. This informs us which new nodes to
+    /// queue up in the worklist when `constrain(node)` reports updated
+    /// information.
+    fn each_depending_on<F>(&self, node: Self::Node, f: F)
+    where
+        F: FnMut(Self::Node);
+}
+
+/// Whether an analysis's `constrain` function modified the incremental results
+/// or not.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ConstrainResult {
+    /// The incremental results were updated, and the fix-point computation
+    /// should continue.
+    Changed,
+
+    /// The incremental results were not updated.
+    Same,
+}
+
+impl Default for ConstrainResult {
+    fn default() -> Self {
+        ConstrainResult::Same
+    }
+}
+
+impl ops::BitOr for ConstrainResult {
+    type Output = Self;
+
+    fn bitor(self, rhs: ConstrainResult) -> Self::Output {
+        if self == ConstrainResult::Changed || rhs == ConstrainResult::Changed {
+            ConstrainResult::Changed
+        } else {
+            ConstrainResult::Same
+        }
+    }
+}
+
+impl ops::BitOrAssign for ConstrainResult {
+    fn bitor_assign(&mut self, rhs: ConstrainResult) {
+        *self = *self | rhs;
+    }
+}
+
+/// Run an analysis in the monotone framework.
+pub fn analyze<Analysis>(extra: Analysis::Extra) -> Analysis::Output
+where
+    Analysis: MonotoneFramework,
+{
+    let mut analysis = Analysis::new(extra);
+    let mut worklist = analysis.initial_worklist();
+
+    while let Some(node) = worklist.pop() {
+        if let ConstrainResult::Changed = analysis.constrain(node) {
+            analysis.each_depending_on(node, |needs_work| {
+                worklist.push(needs_work);
+            });
+        }
+    }
+
+    analysis.into()
+}
+
+/// Generate the dependency map for analysis
+pub fn generate_dependencies<F>(
+    ctx: &BindgenContext,
+    consider_edge: F,
+) -> HashMap<ItemId, Vec<ItemId>>
+where
+    F: Fn(EdgeKind) -> bool,
+{
+    let mut dependencies = HashMap::default();
+
+    for &item in ctx.allowlisted_items() {
+        dependencies.entry(item).or_insert_with(Vec::new);
+
+        {
+            // We reverse our natural IR graph edges to find dependencies
+            // between nodes.
+            item.trace(
+                ctx,
+                &mut |sub_item: ItemId, edge_kind| {
+                    if ctx.allowlisted_items().contains(&sub_item) &&
+                        consider_edge(edge_kind)
+                    {
+                        dependencies
+                            .entry(sub_item)
+                            .or_insert_with(Vec::new)
+                            .push(item);
+                    }
+                },
+                &(),
+            );
+        }
+    }
+    dependencies
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{HashMap, HashSet};
+
+    // Here we find the set of nodes that are reachable from any given
+    // node. This is a lattice mapping nodes to subsets of all nodes. Our join
+    // function is set union.
+    //
+    // This is our test graph:
+    //
+    //     +---+                    +---+
+    //     |   |                    |   |
+    //     | 1 |               .----| 2 |
+    //     |   |               |    |   |
+    //     +---+               |    +---+
+    //       |                 |      ^
+    //       |                 |      |
+    //       |      +---+      '------'
+    //       '----->|   |
+    //              | 3 |
+    //       .------|   |------.
+    //       |      +---+      |
+    //       |        ^        |
+    //       v        |        v
+    //     +---+      |      +---+    +---+
+    //     |   |      |      |   |    |   |
+    //     | 4 |      |      | 5 |--->| 6 |
+    //     |   |      |      |   |    |   |
+    //     +---+      |      +---+    +---+
+    //       |        |        |        |
+    //       |        |        |        v
+    //       |      +---+      |      +---+
+    //       |      |   |      |      |   |
+    //       '----->| 7 |<-----'      | 8 |
+    //              |   |             |   |
+    //              +---+             +---+
+    //
+    // And here is the mapping from a node to the set of nodes that are
+    // reachable from it within the test graph:
+    //
+    //     1: {3,4,5,6,7,8}
+    //     2: {2}
+    //     3: {3,4,5,6,7,8}
+    //     4: {3,4,5,6,7,8}
+    //     5: {3,4,5,6,7,8}
+    //     6: {8}
+    //     7: {3,4,5,6,7,8}
+    //     8: {}
+
+    #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+    struct Node(usize);
+
+    #[derive(Clone, Debug, Default, PartialEq, Eq)]
+    struct Graph(HashMap<Node, Vec<Node>>);
+
+    impl Graph {
+        fn make_test_graph() -> Graph {
+            let mut g = Graph::default();
+            g.0.insert(Node(1), vec![Node(3)]);
+            g.0.insert(Node(2), vec![Node(2)]);
+            g.0.insert(Node(3), vec![Node(4), Node(5)]);
+            g.0.insert(Node(4), vec![Node(7)]);
+            g.0.insert(Node(5), vec![Node(6), Node(7)]);
+            g.0.insert(Node(6), vec![Node(8)]);
+            g.0.insert(Node(7), vec![Node(3)]);
+            g.0.insert(Node(8), vec![]);
+            g
+        }
+
+        fn reverse(&self) -> Graph {
+            let mut reversed = Graph::default();
+            for (node, edges) in self.0.iter() {
+                reversed.0.entry(*node).or_insert_with(Vec::new);
+                for referent in edges.iter() {
+                    reversed
+                        .0
+                        .entry(*referent)
+                        .or_insert_with(Vec::new)
+                        .push(*node);
+                }
+            }
+            reversed
+        }
+    }
+
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    struct ReachableFrom<'a> {
+        reachable: HashMap<Node, HashSet<Node>>,
+        graph: &'a Graph,
+        reversed: Graph,
+    }
+
+    impl<'a> MonotoneFramework for ReachableFrom<'a> {
+        type Node = Node;
+        type Extra = &'a Graph;
+        type Output = HashMap<Node, HashSet<Node>>;
+
+        fn new(graph: &'a Graph) -> ReachableFrom {
+            let reversed = graph.reverse();
+            ReachableFrom {
+                reachable: Default::default(),
+                graph,
+                reversed,
+            }
+        }
+
+        fn initial_worklist(&self) -> Vec<Node> {
+            self.graph.0.keys().cloned().collect()
+        }
+
+        fn constrain(&mut self, node: Node) -> ConstrainResult {
+            // The set of nodes reachable from a node `x` is
+            //
+            //     reachable(x) = s_0 U s_1 U ... U reachable(s_0) U reachable(s_1) U ...
+            //
+            // where there exist edges from `x` to each of `s_0, s_1, ...`.
+            //
+            // Yes, what follows is a **terribly** inefficient set union
+            // implementation. Don't copy this code outside of this test!
+
+            let original_size = self
+                .reachable
+                .entry(node)
+                .or_insert_with(HashSet::default)
+                .len();
+
+            for sub_node in self.graph.0[&node].iter() {
+                self.reachable.get_mut(&node).unwrap().insert(*sub_node);
+
+                let sub_reachable = self
+                    .reachable
+                    .entry(*sub_node)
+                    .or_insert_with(HashSet::default)
+                    .clone();
+
+                for transitive in sub_reachable {
+                    self.reachable.get_mut(&node).unwrap().insert(transitive);
+                }
+            }
+
+            let new_size = self.reachable[&node].len();
+            if original_size != new_size {
+                ConstrainResult::Changed
+            } else {
+                ConstrainResult::Same
+            }
+        }
+
+        fn each_depending_on<F>(&self, node: Node, mut f: F)
+        where
+            F: FnMut(Node),
+        {
+            for dep in self.reversed.0[&node].iter() {
+                f(*dep);
+            }
+        }
+    }
+
+    impl<'a> From<ReachableFrom<'a>> for HashMap<Node, HashSet<Node>> {
+        fn from(reachable: ReachableFrom<'a>) -> Self {
+            reachable.reachable
+        }
+    }
+
+    #[test]
+    fn monotone() {
+        let g = Graph::make_test_graph();
+        let reachable = analyze::<ReachableFrom>(&g);
+        println!("reachable = {:#?}", reachable);
+
+        fn nodes<A>(nodes: A) -> HashSet<Node>
+        where
+            A: AsRef<[usize]>,
+        {
+            nodes.as_ref().iter().cloned().map(Node).collect()
+        }
+
+        let mut expected = HashMap::default();
+        expected.insert(Node(1), nodes([3, 4, 5, 6, 7, 8]));
+        expected.insert(Node(2), nodes([2]));
+        expected.insert(Node(3), nodes([3, 4, 5, 6, 7, 8]));
+        expected.insert(Node(4), nodes([3, 4, 5, 6, 7, 8]));
+        expected.insert(Node(5), nodes([3, 4, 5, 6, 7, 8]));
+        expected.insert(Node(6), nodes([8]));
+        expected.insert(Node(7), nodes([3, 4, 5, 6, 7, 8]));
+        expected.insert(Node(8), nodes([]));
+        println!("expected = {:#?}", expected);
+
+        assert_eq!(reachable, expected);
+    }
+}
diff --git a/bindgen/ir/analysis/sizedness.rs b/bindgen/ir/analysis/sizedness.rs
new file mode 100644
index 00000000..251c3747
--- /dev/null
+++ b/bindgen/ir/analysis/sizedness.rs
@@ -0,0 +1,361 @@
+//! Determining the sizedness of types (as base classes and otherwise).
+
+use super::{
+    generate_dependencies, ConstrainResult, HasVtable, MonotoneFramework,
+};
+use crate::ir::context::{BindgenContext, TypeId};
+use crate::ir::item::IsOpaque;
+use crate::ir::traversal::EdgeKind;
+use crate::ir::ty::TypeKind;
+use crate::{Entry, HashMap};
+use std::{cmp, ops};
+
+/// The result of the `Sizedness` analysis for an individual item.
+///
+/// This is a chain lattice of the form:
+///
+/// ```ignore
+///                   NonZeroSized
+///                        |
+///                DependsOnTypeParam
+///                        |
+///                     ZeroSized
+/// ```
+///
+/// We initially assume that all types are `ZeroSized` and then update our
+/// understanding as we learn more about each type.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum SizednessResult {
+    /// The type is zero-sized.
+    ///
+    /// This means that if it is a C++ type, and is not being used as a base
+    /// member, then we must add an `_address` byte to enforce the
+    /// unique-address-per-distinct-object-instance rule.
+    ZeroSized,
+
+    /// Whether this type is zero-sized or not depends on whether a type
+    /// parameter is zero-sized or not.
+    ///
+    /// For example, given these definitions:
+    ///
+    /// ```c++
+    /// template<class T>
+    /// class Flongo : public T {};
+    ///
+    /// class Empty {};
+    ///
+    /// class NonEmpty { int x; };
+    /// ```
+    ///
+    /// Then `Flongo<Empty>` is zero-sized, and needs an `_address` byte
+    /// inserted, while `Flongo<NonEmpty>` is *not* zero-sized, and should *not*
+    /// have an `_address` byte inserted.
+    ///
+    /// We don't properly handle this situation correctly right now:
+    /// https://github.com/rust-lang/rust-bindgen/issues/586
+    DependsOnTypeParam,
+
+    /// Has some size that is known to be greater than zero. That doesn't mean
+    /// it has a static size, but it is not zero sized for sure. In other words,
+    /// it might contain an incomplete array or some other dynamically sized
+    /// type.
+    NonZeroSized,
+}
+
+impl Default for SizednessResult {
+    fn default() -> Self {
+        SizednessResult::ZeroSized
+    }
+}
+
+impl SizednessResult {
+    /// Take the least upper bound of `self` and `rhs`.
+    pub fn join(self, rhs: Self) -> Self {
+        cmp::max(self, rhs)
+    }
+}
+
+impl ops::BitOr for SizednessResult {
+    type Output = Self;
+
+    fn bitor(self, rhs: SizednessResult) -> Self::Output {
+        self.join(rhs)
+    }
+}
+
+impl ops::BitOrAssign for SizednessResult {
+    fn bitor_assign(&mut self, rhs: SizednessResult) {
+        *self = self.join(rhs)
+    }
+}
+
+/// An analysis that computes the sizedness of all types.
+///
+/// * For types with known sizes -- for example pointers, scalars, etc... --
+/// they are assigned `NonZeroSized`.
+///
+/// * For compound structure types with one or more fields, they are assigned
+/// `NonZeroSized`.
+///
+/// * For compound structure types without any fields, the results of the bases
+/// are `join`ed.
+///
+/// * For type parameters, `DependsOnTypeParam` is assigned.
+#[derive(Debug)]
+pub struct SizednessAnalysis<'ctx> {
+    ctx: &'ctx BindgenContext,
+    dependencies: HashMap<TypeId, Vec<TypeId>>,
+    // Incremental results of the analysis. Missing entries are implicitly
+    // considered `ZeroSized`.
+    sized: HashMap<TypeId, SizednessResult>,
+}
+
+impl<'ctx> SizednessAnalysis<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        // These are the only edges that can affect whether a type is
+        // zero-sized or not.
+        matches!(
+            kind,
+            EdgeKind::TemplateArgument |
+                EdgeKind::TemplateParameterDefinition |
+                EdgeKind::TemplateDeclaration |
+                EdgeKind::TypeReference |
+                EdgeKind::BaseMember |
+                EdgeKind::Field
+        )
+    }
+
+    /// Insert an incremental result, and return whether this updated our
+    /// knowledge of types and we should continue the analysis.
+    fn insert(
+        &mut self,
+        id: TypeId,
+        result: SizednessResult,
+    ) -> ConstrainResult {
+        trace!("inserting {:?} for {:?}", result, id);
+
+        if let SizednessResult::ZeroSized = result {
+            return ConstrainResult::Same;
+        }
+
+        match self.sized.entry(id) {
+            Entry::Occupied(mut entry) => {
+                if *entry.get() < result {
+                    entry.insert(result);
+                    ConstrainResult::Changed
+                } else {
+                    ConstrainResult::Same
+                }
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(result);
+                ConstrainResult::Changed
+            }
+        }
+    }
+
+    fn forward(&mut self, from: TypeId, to: TypeId) -> ConstrainResult {
+        match self.sized.get(&from).cloned() {
+            None => ConstrainResult::Same,
+            Some(r) => self.insert(to, r),
+        }
+    }
+}
+
+impl<'ctx> MonotoneFramework for SizednessAnalysis<'ctx> {
+    type Node = TypeId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashMap<TypeId, SizednessResult>;
+
+    fn new(ctx: &'ctx BindgenContext) -> SizednessAnalysis<'ctx> {
+        let dependencies = generate_dependencies(ctx, Self::consider_edge)
+            .into_iter()
+            .filter_map(|(id, sub_ids)| {
+                id.as_type_id(ctx).map(|id| {
+                    (
+                        id,
+                        sub_ids
+                            .into_iter()
+                            .filter_map(|s| s.as_type_id(ctx))
+                            .collect::<Vec<_>>(),
+                    )
+                })
+            })
+            .collect();
+
+        let sized = HashMap::default();
+
+        SizednessAnalysis {
+            ctx,
+            dependencies,
+            sized,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<TypeId> {
+        self.ctx
+            .allowlisted_items()
+            .iter()
+            .cloned()
+            .filter_map(|id| id.as_type_id(self.ctx))
+            .collect()
+    }
+
+    fn constrain(&mut self, id: TypeId) -> ConstrainResult {
+        trace!("constrain {:?}", id);
+
+        if let Some(SizednessResult::NonZeroSized) =
+            self.sized.get(&id).cloned()
+        {
+            trace!("    already know it is not zero-sized");
+            return ConstrainResult::Same;
+        }
+
+        if id.has_vtable_ptr(self.ctx) {
+            trace!("    has an explicit vtable pointer, therefore is not zero-sized");
+            return self.insert(id, SizednessResult::NonZeroSized);
+        }
+
+        let ty = self.ctx.resolve_type(id);
+
+        if id.is_opaque(self.ctx, &()) {
+            trace!("    type is opaque; checking layout...");
+            let result =
+                ty.layout(self.ctx).map_or(SizednessResult::ZeroSized, |l| {
+                    if l.size == 0 {
+                        trace!("    ...layout has size == 0");
+                        SizednessResult::ZeroSized
+                    } else {
+                        trace!("    ...layout has size > 0");
+                        SizednessResult::NonZeroSized
+                    }
+                });
+            return self.insert(id, result);
+        }
+
+        match *ty.kind() {
+            TypeKind::Void => {
+                trace!("    void is zero-sized");
+                self.insert(id, SizednessResult::ZeroSized)
+            }
+
+            TypeKind::TypeParam => {
+                trace!(
+                    "    type params sizedness depends on what they're \
+                     instantiated as"
+                );
+                self.insert(id, SizednessResult::DependsOnTypeParam)
+            }
+
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::Reference(..) |
+            TypeKind::NullPtr |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel |
+            TypeKind::Pointer(..) => {
+                trace!("    {:?} is known not to be zero-sized", ty.kind());
+                self.insert(id, SizednessResult::NonZeroSized)
+            }
+
+            TypeKind::ObjCInterface(..) => {
+                trace!("    obj-c interfaces always have at least the `isa` pointer");
+                self.insert(id, SizednessResult::NonZeroSized)
+            }
+
+            TypeKind::TemplateAlias(t, _) |
+            TypeKind::Alias(t) |
+            TypeKind::BlockPointer(t) |
+            TypeKind::ResolvedTypeRef(t) => {
+                trace!("    aliases and type refs forward to their inner type");
+                self.forward(t, id)
+            }
+
+            TypeKind::TemplateInstantiation(ref inst) => {
+                trace!(
+                    "    template instantiations are zero-sized if their \
+                     definition is zero-sized"
+                );
+                self.forward(inst.template_definition(), id)
+            }
+
+            TypeKind::Array(_, 0) => {
+                trace!("    arrays of zero elements are zero-sized");
+                self.insert(id, SizednessResult::ZeroSized)
+            }
+            TypeKind::Array(..) => {
+                trace!("    arrays of > 0 elements are not zero-sized");
+                self.insert(id, SizednessResult::NonZeroSized)
+            }
+            TypeKind::Vector(..) => {
+                trace!("    vectors are not zero-sized");
+                self.insert(id, SizednessResult::NonZeroSized)
+            }
+
+            TypeKind::Comp(ref info) => {
+                trace!("    comp considers its own fields and bases");
+
+                if !info.fields().is_empty() {
+                    return self.insert(id, SizednessResult::NonZeroSized);
+                }
+
+                let result = info
+                    .base_members()
+                    .iter()
+                    .filter_map(|base| self.sized.get(&base.ty))
+                    .fold(SizednessResult::ZeroSized, |a, b| a.join(*b));
+
+                self.insert(id, result)
+            }
+
+            TypeKind::Opaque => {
+                unreachable!("covered by the .is_opaque() check above")
+            }
+
+            TypeKind::UnresolvedTypeRef(..) => {
+                unreachable!("Should have been resolved after parsing!");
+            }
+        }
+    }
+
+    fn each_depending_on<F>(&self, id: TypeId, mut f: F)
+    where
+        F: FnMut(TypeId),
+    {
+        if let Some(edges) = self.dependencies.get(&id) {
+            for ty in edges {
+                trace!("enqueue {:?} into worklist", ty);
+                f(*ty);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<SizednessAnalysis<'ctx>> for HashMap<TypeId, SizednessResult> {
+    fn from(analysis: SizednessAnalysis<'ctx>) -> Self {
+        // We let the lack of an entry mean "ZeroSized" to save space.
+        extra_assert!(analysis
+            .sized
+            .values()
+            .all(|v| { *v != SizednessResult::ZeroSized }));
+
+        analysis.sized
+    }
+}
+
+/// A convenience trait for querying whether some type or id is sized.
+///
+/// This is not for _computing_ whether the thing is sized, it is for looking up
+/// the results of the `Sizedness` analysis's computations for a specific thing.
+pub trait Sizedness {
+    /// Get the sizedness of this type.
+    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult;
+
+    /// Is the sizedness for this type `SizednessResult::ZeroSized`?
+    fn is_zero_sized(&self, ctx: &BindgenContext) -> bool {
+        self.sizedness(ctx) == SizednessResult::ZeroSized
+    }
+}
diff --git a/bindgen/ir/analysis/template_params.rs b/bindgen/ir/analysis/template_params.rs
new file mode 100644
index 00000000..e88b774d
--- /dev/null
+++ b/bindgen/ir/analysis/template_params.rs
@@ -0,0 +1,608 @@
+//! Discover which template type parameters are actually used.
+//!
+//! ### Why do we care?
+//!
+//! C++ allows ignoring template parameters, while Rust does not. Usually we can
+//! blindly stick a `PhantomData<T>` inside a generic Rust struct to make up for
+//! this. That doesn't work for templated type aliases, however:
+//!
+//! ```C++
+//! template <typename T>
+//! using Fml = int;
+//! ```
+//!
+//! If we generate the naive Rust code for this alias, we get:
+//!
+//! ```ignore
+//! pub type Fml<T> = ::std::os::raw::int;
+//! ```
+//!
+//! And this is rejected by `rustc` due to the unused type parameter.
+//!
+//! (Aside: in these simple cases, `libclang` will often just give us the
+//! aliased type directly, and we will never even know we were dealing with
+//! aliases, let alone templated aliases. It's the more convoluted scenarios
+//! where we get to have some fun...)
+//!
+//! For such problematic template aliases, we could generate a tuple whose
+//! second member is a `PhantomData<T>`. Or, if we wanted to go the extra mile,
+//! we could even generate some smarter wrapper that implements `Deref`,
+//! `DerefMut`, `From`, `Into`, `AsRef`, and `AsMut` to the actually aliased
+//! type. However, this is still lackluster:
+//!
+//! 1. Even with a billion conversion-trait implementations, using the generated
+//!    bindings is rather un-ergonomic.
+//! 2. With either of these solutions, we need to keep track of which aliases
+//!    we've transformed like this in order to generate correct uses of the
+//!    wrapped type.
+//!
+//! Given that we have to properly track which template parameters ended up used
+//! for (2), we might as well leverage that information to make ergonomic
+//! bindings that don't contain any unused type parameters at all, and
+//! completely avoid the pain of (1).
+//!
+//! ### How do we determine which template parameters are used?
+//!
+//! Determining which template parameters are actually used is a trickier
+//! problem than it might seem at a glance. On the one hand, trivial uses are
+//! easy to detect:
+//!
+//! ```C++
+//! template <typename T>
+//! class Foo {
+//!     T trivial_use_of_t;
+//! };
+//! ```
+//!
+//! It gets harder when determining if one template parameter is used depends on
+//! determining if another template parameter is used. In this example, whether
+//! `U` is used depends on whether `T` is used.
+//!
+//! ```C++
+//! template <typename T>
+//! class DoesntUseT {
+//!     int x;
+//! };
+//!
+//! template <typename U>
+//! class Fml {
+//!     DoesntUseT<U> lololol;
+//! };
+//! ```
+//!
+//! We can express the set of used template parameters as a constraint solving
+//! problem (where the set of template parameters used by a given IR item is the
+//! union of its sub-item's used template parameters) and iterate to a
+//! fixed-point.
+//!
+//! We use the `ir::analysis::MonotoneFramework` infrastructure for this
+//! fix-point analysis, where our lattice is the mapping from each IR item to
+//! the powerset of the template parameters that appear in the input C++ header,
+//! our join function is set union. The set of template parameters appearing in
+//! the program is finite, as is the number of IR items. We start at our
+//! lattice's bottom element: every item mapping to an empty set of template
+//! parameters. Our analysis only adds members to each item's set of used
+//! template parameters, never removes them, so it is monotone. Because our
+//! lattice is finite and our constraint function is monotone, iteration to a
+//! fix-point will terminate.
+//!
+//! See `src/ir/analysis.rs` for more.
+
+use super::{ConstrainResult, MonotoneFramework};
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::item::{Item, ItemSet};
+use crate::ir::template::{TemplateInstantiation, TemplateParameters};
+use crate::ir::traversal::{EdgeKind, Trace};
+use crate::ir::ty::TypeKind;
+use crate::{HashMap, HashSet};
+
+/// An analysis that finds for each IR item its set of template parameters that
+/// it uses.
+///
+/// We use the monotone constraint function `template_param_usage`, defined as
+/// follows:
+///
+/// * If `T` is a named template type parameter, it trivially uses itself:
+///
+/// ```ignore
+/// template_param_usage(T) = { T }
+/// ```
+///
+/// * If `inst` is a template instantiation, `inst.args` are the template
+///   instantiation's template arguments, `inst.def` is the template definition
+///   being instantiated, and `inst.def.params` is the template definition's
+///   template parameters, then the instantiation's usage is the union of each
+///   of its arguments' usages *if* the corresponding template parameter is in
+///   turn used by the template definition:
+///
+/// ```ignore
+/// template_param_usage(inst) = union(
+///     template_param_usage(inst.args[i])
+///         for i in 0..length(inst.args.length)
+///             if inst.def.params[i] in template_param_usage(inst.def)
+/// )
+/// ```
+///
+/// * Finally, for all other IR item kinds, we use our lattice's `join`
+/// operation: set union with each successor of the given item's template
+/// parameter usage:
+///
+/// ```ignore
+/// template_param_usage(v) =
+///     union(template_param_usage(w) for w in successors(v))
+/// ```
+///
+/// Note that we ignore certain edges in the graph, such as edges from a
+/// template declaration to its template parameters' definitions for this
+/// analysis. If we didn't, then we would mistakenly determine that ever
+/// template parameter is always used.
+///
+/// The final wrinkle is handling of blocklisted types. Normally, we say that
+/// the set of allowlisted items is the transitive closure of items explicitly
+/// called out for allowlisting, *without* any items explicitly called out as
+/// blocklisted. However, for the purposes of this analysis's correctness, we
+/// simplify and consider run the analysis on the full transitive closure of
+/// allowlisted items. We do, however, treat instantiations of blocklisted items
+/// specially; see `constrain_instantiation_of_blocklisted_template` and its
+/// documentation for details.
+#[derive(Debug, Clone)]
+pub struct UsedTemplateParameters<'ctx> {
+    ctx: &'ctx BindgenContext,
+
+    // The Option is only there for temporary moves out of the hash map. See the
+    // comments in `UsedTemplateParameters::constrain` below.
+    used: HashMap<ItemId, Option<ItemSet>>,
+
+    dependencies: HashMap<ItemId, Vec<ItemId>>,
+
+    // The set of allowlisted items, without any blocklisted items reachable
+    // from the allowlisted items which would otherwise be considered
+    // allowlisted as well.
+    allowlisted_items: HashSet<ItemId>,
+}
+
+impl<'ctx> UsedTemplateParameters<'ctx> {
+    fn consider_edge(kind: EdgeKind) -> bool {
+        match kind {
+            // For each of these kinds of edges, if the referent uses a template
+            // parameter, then it should be considered that the origin of the
+            // edge also uses the template parameter.
+            EdgeKind::TemplateArgument |
+            EdgeKind::BaseMember |
+            EdgeKind::Field |
+            EdgeKind::Constructor |
+            EdgeKind::Destructor |
+            EdgeKind::VarType |
+            EdgeKind::FunctionReturn |
+            EdgeKind::FunctionParameter |
+            EdgeKind::TypeReference => true,
+
+            // An inner var or type using a template parameter is orthogonal
+            // from whether we use it. See template-param-usage-{6,11}.hpp.
+            EdgeKind::InnerVar | EdgeKind::InnerType => false,
+
+            // We can't emit machine code for new monomorphizations of class
+            // templates' methods (and don't detect explicit instantiations) so
+            // we must ignore template parameters that are only used by
+            // methods. This doesn't apply to a function type's return or
+            // parameter types, however, because of type aliases of function
+            // pointers that use template parameters, eg
+            // tests/headers/struct_with_typedef_template_arg.hpp
+            EdgeKind::Method => false,
+
+            // If we considered these edges, we would end up mistakenly claiming
+            // that every template parameter always used.
+            EdgeKind::TemplateDeclaration |
+            EdgeKind::TemplateParameterDefinition => false,
+
+            // Since we have to be careful about which edges we consider for
+            // this analysis to be correct, we ignore generic edges. We also
+            // avoid a `_` wild card to force authors of new edge kinds to
+            // determine whether they need to be considered by this analysis.
+            EdgeKind::Generic => false,
+        }
+    }
+
+    fn take_this_id_usage_set<Id: Into<ItemId>>(
+        &mut self,
+        this_id: Id,
+    ) -> ItemSet {
+        let this_id = this_id.into();
+        self.used
+            .get_mut(&this_id)
+            .expect(
+                "Should have a set of used template params for every item \
+                 id",
+            )
+            .take()
+            .expect(
+                "Should maintain the invariant that all used template param \
+                 sets are `Some` upon entry of `constrain`",
+            )
+    }
+
+    /// We say that blocklisted items use all of their template parameters. The
+    /// blocklisted type is most likely implemented explicitly by the user,
+    /// since it won't be in the generated bindings, and we don't know exactly
+    /// what they'll to with template parameters, but we can push the issue down
+    /// the line to them.
+    fn constrain_instantiation_of_blocklisted_template(
+        &self,
+        this_id: ItemId,
+        used_by_this_id: &mut ItemSet,
+        instantiation: &TemplateInstantiation,
+    ) {
+        trace!(
+            "    instantiation of blocklisted template, uses all template \
+             arguments"
+        );
+
+        let args = instantiation
+            .template_arguments()
+            .iter()
+            .map(|a| {
+                a.into_resolver()
+                    .through_type_refs()
+                    .through_type_aliases()
+                    .resolve(self.ctx)
+                    .id()
+            })
+            .filter(|a| *a != this_id)
+            .flat_map(|a| {
+                self.used
+                    .get(&a)
+                    .expect("Should have a used entry for the template arg")
+                    .as_ref()
+                    .expect(
+                        "Because a != this_id, and all used template \
+                         param sets other than this_id's are `Some`, \
+                         a's used template param set should be `Some`",
+                    )
+                    .iter()
+                    .cloned()
+            });
+
+        used_by_this_id.extend(args);
+    }
+
+    /// A template instantiation's concrete template argument is only used if
+    /// the template definition uses the corresponding template parameter.
+    fn constrain_instantiation(
+        &self,
+        this_id: ItemId,
+        used_by_this_id: &mut ItemSet,
+        instantiation: &TemplateInstantiation,
+    ) {
+        trace!("    template instantiation");
+
+        let decl = self.ctx.resolve_type(instantiation.template_definition());
+        let args = instantiation.template_arguments();
+
+        let params = decl.self_template_params(self.ctx);
+
+        debug_assert!(this_id != instantiation.template_definition());
+        let used_by_def = self.used
+            .get(&instantiation.template_definition().into())
+            .expect("Should have a used entry for instantiation's template definition")
+            .as_ref()
+            .expect("And it should be Some because only this_id's set is None, and an \
+                     instantiation's template definition should never be the \
+                     instantiation itself");
+
+        for (arg, param) in args.iter().zip(params.iter()) {
+            trace!(
+                "      instantiation's argument {:?} is used if definition's \
+                 parameter {:?} is used",
+                arg,
+                param
+            );
+
+            if used_by_def.contains(&param.into()) {
+                trace!("        param is used by template definition");
+
+                let arg = arg
+                    .into_resolver()
+                    .through_type_refs()
+                    .through_type_aliases()
+                    .resolve(self.ctx)
+                    .id();
+
+                if arg == this_id {
+                    continue;
+                }
+
+                let used_by_arg = self
+                    .used
+                    .get(&arg)
+                    .expect("Should have a used entry for the template arg")
+                    .as_ref()
+                    .expect(
+                        "Because arg != this_id, and all used template \
+                         param sets other than this_id's are `Some`, \
+                         arg's used template param set should be \
+                         `Some`",
+                    )
+                    .iter()
+                    .cloned();
+                used_by_this_id.extend(used_by_arg);
+            }
+        }
+    }
+
+    /// The join operation on our lattice: the set union of all of this id's
+    /// successors.
+    fn constrain_join(&self, used_by_this_id: &mut ItemSet, item: &Item) {
+        trace!("    other item: join with successors' usage");
+
+        item.trace(
+            self.ctx,
+            &mut |sub_id, edge_kind| {
+                // Ignore ourselves, since union with ourself is a
+                // no-op. Ignore edges that aren't relevant to the
+                // analysis.
+                if sub_id == item.id() || !Self::consider_edge(edge_kind) {
+                    return;
+                }
+
+                let used_by_sub_id = self
+                    .used
+                    .get(&sub_id)
+                    .expect("Should have a used set for the sub_id successor")
+                    .as_ref()
+                    .expect(
+                        "Because sub_id != id, and all used template \
+                         param sets other than id's are `Some`, \
+                         sub_id's used template param set should be \
+                         `Some`",
+                    )
+                    .iter()
+                    .cloned();
+
+                trace!(
+                    "      union with {:?}'s usage: {:?}",
+                    sub_id,
+                    used_by_sub_id.clone().collect::<Vec<_>>()
+                );
+
+                used_by_this_id.extend(used_by_sub_id);
+            },
+            &(),
+        );
+    }
+}
+
+impl<'ctx> MonotoneFramework for UsedTemplateParameters<'ctx> {
+    type Node = ItemId;
+    type Extra = &'ctx BindgenContext;
+    type Output = HashMap<ItemId, ItemSet>;
+
+    fn new(ctx: &'ctx BindgenContext) -> UsedTemplateParameters<'ctx> {
+        let mut used = HashMap::default();
+        let mut dependencies = HashMap::default();
+        let allowlisted_items: HashSet<_> =
+            ctx.allowlisted_items().iter().cloned().collect();
+
+        let allowlisted_and_blocklisted_items: ItemSet = allowlisted_items
+            .iter()
+            .cloned()
+            .flat_map(|i| {
+                let mut reachable = vec![i];
+                i.trace(
+                    ctx,
+                    &mut |s, _| {
+                        reachable.push(s);
+                    },
+                    &(),
+                );
+                reachable
+            })
+            .collect();
+
+        for item in allowlisted_and_blocklisted_items {
+            dependencies.entry(item).or_insert_with(Vec::new);
+            used.entry(item).or_insert_with(|| Some(ItemSet::new()));
+
+            {
+                // We reverse our natural IR graph edges to find dependencies
+                // between nodes.
+                item.trace(
+                    ctx,
+                    &mut |sub_item: ItemId, _| {
+                        used.entry(sub_item)
+                            .or_insert_with(|| Some(ItemSet::new()));
+                        dependencies
+                            .entry(sub_item)
+                            .or_insert_with(Vec::new)
+                            .push(item);
+                    },
+                    &(),
+                );
+            }
+
+            // Additionally, whether a template instantiation's template
+            // arguments are used depends on whether the template declaration's
+            // generic template parameters are used.
+            let item_kind =
+                ctx.resolve_item(item).as_type().map(|ty| ty.kind());
+            if let Some(&TypeKind::TemplateInstantiation(ref inst)) = item_kind
+            {
+                let decl = ctx.resolve_type(inst.template_definition());
+                let args = inst.template_arguments();
+
+                // Although template definitions should always have
+                // template parameters, there is a single exception:
+                // opaque templates. Hence the unwrap_or.
+                let params = decl.self_template_params(ctx);
+
+                for (arg, param) in args.iter().zip(params.iter()) {
+                    let arg = arg
+                        .into_resolver()
+                        .through_type_aliases()
+                        .through_type_refs()
+                        .resolve(ctx)
+                        .id();
+
+                    let param = param
+                        .into_resolver()
+                        .through_type_aliases()
+                        .through_type_refs()
+                        .resolve(ctx)
+                        .id();
+
+                    used.entry(arg).or_insert_with(|| Some(ItemSet::new()));
+                    used.entry(param).or_insert_with(|| Some(ItemSet::new()));
+
+                    dependencies
+                        .entry(arg)
+                        .or_insert_with(Vec::new)
+                        .push(param);
+                }
+            }
+        }
+
+        if cfg!(feature = "testing_only_extra_assertions") {
+            // Invariant: The `used` map has an entry for every allowlisted
+            // item, as well as all explicitly blocklisted items that are
+            // reachable from allowlisted items.
+            //
+            // Invariant: the `dependencies` map has an entry for every
+            // allowlisted item.
+            //
+            // (This is so that every item we call `constrain` on is guaranteed
+            // to have a set of template parameters, and we can allow
+            // blocklisted templates to use all of their parameters).
+            for item in allowlisted_items.iter() {
+                extra_assert!(used.contains_key(item));
+                extra_assert!(dependencies.contains_key(item));
+                item.trace(
+                    ctx,
+                    &mut |sub_item, _| {
+                        extra_assert!(used.contains_key(&sub_item));
+                        extra_assert!(dependencies.contains_key(&sub_item));
+                    },
+                    &(),
+                )
+            }
+        }
+
+        UsedTemplateParameters {
+            ctx,
+            used,
+            dependencies,
+            allowlisted_items,
+        }
+    }
+
+    fn initial_worklist(&self) -> Vec<ItemId> {
+        // The transitive closure of all allowlisted items, including explicitly
+        // blocklisted items.
+        self.ctx
+            .allowlisted_items()
+            .iter()
+            .cloned()
+            .flat_map(|i| {
+                let mut reachable = vec![i];
+                i.trace(
+                    self.ctx,
+                    &mut |s, _| {
+                        reachable.push(s);
+                    },
+                    &(),
+                );
+                reachable
+            })
+            .collect()
+    }
+
+    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
+        // Invariant: all hash map entries' values are `Some` upon entering and
+        // exiting this method.
+        extra_assert!(self.used.values().all(|v| v.is_some()));
+
+        // Take the set for this id out of the hash map while we mutate it based
+        // on other hash map entries. We *must* put it back into the hash map at
+        // the end of this method. This allows us to side-step HashMap's lack of
+        // an analog to slice::split_at_mut.
+        let mut used_by_this_id = self.take_this_id_usage_set(id);
+
+        trace!("constrain {:?}", id);
+        trace!("  initially, used set is {:?}", used_by_this_id);
+
+        let original_len = used_by_this_id.len();
+
+        let item = self.ctx.resolve_item(id);
+        let ty_kind = item.as_type().map(|ty| ty.kind());
+        match ty_kind {
+            // Named template type parameters trivially use themselves.
+            Some(&TypeKind::TypeParam) => {
+                trace!("    named type, trivially uses itself");
+                used_by_this_id.insert(id);
+            }
+            // Template instantiations only use their template arguments if the
+            // template definition uses the corresponding template parameter.
+            Some(&TypeKind::TemplateInstantiation(ref inst)) => {
+                if self
+                    .allowlisted_items
+                    .contains(&inst.template_definition().into())
+                {
+                    self.constrain_instantiation(
+                        id,
+                        &mut used_by_this_id,
+                        inst,
+                    );
+                } else {
+                    self.constrain_instantiation_of_blocklisted_template(
+                        id,
+                        &mut used_by_this_id,
+                        inst,
+                    );
+                }
+            }
+            // Otherwise, add the union of each of its referent item's template
+            // parameter usage.
+            _ => self.constrain_join(&mut used_by_this_id, item),
+        }
+
+        trace!("  finally, used set is {:?}", used_by_this_id);
+
+        let new_len = used_by_this_id.len();
+        assert!(
+            new_len >= original_len,
+            "This is the property that ensures this function is monotone -- \
+             if it doesn't hold, the analysis might never terminate!"
+        );
+
+        // Put the set back in the hash map and restore our invariant.
+        debug_assert!(self.used[&id].is_none());
+        self.used.insert(id, Some(used_by_this_id));
+        extra_assert!(self.used.values().all(|v| v.is_some()));
+
+        if new_len != original_len {
+            ConstrainResult::Changed
+        } else {
+            ConstrainResult::Same
+        }
+    }
+
+    fn each_depending_on<F>(&self, item: ItemId, mut f: F)
+    where
+        F: FnMut(ItemId),
+    {
+        if let Some(edges) = self.dependencies.get(&item) {
+            for item in edges {
+                trace!("enqueue {:?} into worklist", item);
+                f(*item);
+            }
+        }
+    }
+}
+
+impl<'ctx> From<UsedTemplateParameters<'ctx>> for HashMap<ItemId, ItemSet> {
+    fn from(used_templ_params: UsedTemplateParameters<'ctx>) -> Self {
+        used_templ_params
+            .used
+            .into_iter()
+            .map(|(k, v)| (k, v.unwrap()))
+            .collect()
+    }
+}
diff --git a/bindgen/ir/annotations.rs b/bindgen/ir/annotations.rs
new file mode 100644
index 00000000..288c11eb
--- /dev/null
+++ b/bindgen/ir/annotations.rs
@@ -0,0 +1,211 @@
+//! Types and functions related to bindgen annotation comments.
+//!
+//! Users can add annotations in doc comments to types that they would like to
+//! replace other types with, mark as opaque, etc. This module deals with all of
+//! that stuff.
+
+use crate::clang;
+
+/// What kind of accessor should we provide for a field?
+#[derive(Copy, PartialEq, Eq, Clone, Debug)]
+pub enum FieldAccessorKind {
+    /// No accessor.
+    None,
+    /// Plain accessor.
+    Regular,
+    /// Unsafe accessor.
+    Unsafe,
+    /// Immutable accessor.
+    Immutable,
+}
+
+/// Annotations for a given item, or a field.
+///
+/// You can see the kind of comments that are accepted in the Doxygen
+/// documentation:
+///
+/// http://www.stack.nl/~dimitri/doxygen/manual/docblocks.html
+#[derive(Default, Clone, PartialEq, Eq, Debug)]
+pub struct Annotations {
+    /// Whether this item is marked as opaque. Only applies to types.
+    opaque: bool,
+    /// Whether this item should be hidden from the output. Only applies to
+    /// types, or enum variants.
+    hide: bool,
+    /// Whether this type should be replaced by another. The name is a
+    /// namespace-aware path.
+    use_instead_of: Option<Vec<String>>,
+    /// Manually disable deriving copy/clone on this type. Only applies to
+    /// struct or union types.
+    disallow_copy: bool,
+    /// Manually disable deriving debug on this type.
+    disallow_debug: bool,
+    /// Manually disable deriving/implement default on this type.
+    disallow_default: bool,
+    /// Whether to add a #[must_use] annotation to this type.
+    must_use_type: bool,
+    /// Whether fields should be marked as private or not. You can set this on
+    /// structs (it will apply to all the fields), or individual fields.
+    private_fields: Option<bool>,
+    /// The kind of accessor this field will have. Also can be applied to
+    /// structs so all the fields inside share it by default.
+    accessor_kind: Option<FieldAccessorKind>,
+    /// Whether this enum variant should be constified.
+    ///
+    /// This is controlled by the `constant` attribute, this way:
+    ///
+    /// ```cpp
+    /// enum Foo {
+    ///     Bar = 0, /**< <div rustbindgen constant></div> */
+    ///     Baz = 0,
+    /// };
+    /// ```
+    ///
+    /// In that case, bindgen will generate a constant for `Bar` instead of
+    /// `Baz`.
+    constify_enum_variant: bool,
+    /// List of explicit derives for this type.
+    derives: Vec<String>,
+}
+
+fn parse_accessor(s: &str) -> FieldAccessorKind {
+    match s {
+        "false" => FieldAccessorKind::None,
+        "unsafe" => FieldAccessorKind::Unsafe,
+        "immutable" => FieldAccessorKind::Immutable,
+        _ => FieldAccessorKind::Regular,
+    }
+}
+
+impl Annotations {
+    /// Construct new annotations for the given cursor and its bindgen comments
+    /// (if any).
+    pub fn new(cursor: &clang::Cursor) -> Option<Annotations> {
+        let mut anno = Annotations::default();
+        let mut matched_one = false;
+        anno.parse(&cursor.comment(), &mut matched_one);
+
+        if matched_one {
+            Some(anno)
+        } else {
+            None
+        }
+    }
+
+    /// Should this type be hidden?
+    pub fn hide(&self) -> bool {
+        self.hide
+    }
+
+    /// Should this type be opaque?
+    pub fn opaque(&self) -> bool {
+        self.opaque
+    }
+
+    /// For a given type, indicates the type it should replace.
+    ///
+    /// For example, in the following code:
+    ///
+    /// ```cpp
+    ///
+    /// /** <div rustbindgen replaces="Bar"></div> */
+    /// struct Foo { int x; };
+    ///
+    /// struct Bar { char foo; };
+    /// ```
+    ///
+    /// the generated code would look something like:
+    ///
+    /// ```
+    /// /** <div rustbindgen replaces="Bar"></div> */
+    /// struct Bar {
+    ///     x: ::std::os::raw::c_int,
+    /// };
+    /// ```
+    ///
+    /// That is, code for `Foo` is used to generate `Bar`.
+    pub fn use_instead_of(&self) -> Option<&[String]> {
+        self.use_instead_of.as_deref()
+    }
+
+    /// The list of derives that have been specified in this annotation.
+    pub fn derives(&self) -> &[String] {
+        &self.derives
+    }
+
+    /// Should we avoid implementing the `Copy` trait?
+    pub fn disallow_copy(&self) -> bool {
+        self.disallow_copy
+    }
+
+    /// Should we avoid implementing the `Debug` trait?
+    pub fn disallow_debug(&self) -> bool {
+        self.disallow_debug
+    }
+
+    /// Should we avoid implementing the `Default` trait?
+    pub fn disallow_default(&self) -> bool {
+        self.disallow_default
+    }
+
+    /// Should this type get a `#[must_use]` annotation?
+    pub fn must_use_type(&self) -> bool {
+        self.must_use_type
+    }
+
+    /// Should the fields be private?
+    pub fn private_fields(&self) -> Option<bool> {
+        self.private_fields
+    }
+
+    /// What kind of accessors should we provide for this type's fields?
+    pub fn accessor_kind(&self) -> Option<FieldAccessorKind> {
+        self.accessor_kind
+    }
+
+    fn parse(&mut self, comment: &clang::Comment, matched: &mut bool) {
+        use clang_sys::CXComment_HTMLStartTag;
+        if comment.kind() == CXComment_HTMLStartTag &&
+            comment.get_tag_name() == "div" &&
+            comment
+                .get_tag_attrs()
+                .next()
+                .map_or(false, |attr| attr.name == "rustbindgen")
+        {
+            *matched = true;
+            for attr in comment.get_tag_attrs() {
+                match attr.name.as_str() {
+                    "opaque" => self.opaque = true,
+                    "hide" => self.hide = true,
+                    "nocopy" => self.disallow_copy = true,
+                    "nodebug" => self.disallow_debug = true,
+                    "nodefault" => self.disallow_default = true,
+                    "mustusetype" => self.must_use_type = true,
+                    "replaces" => {
+                        self.use_instead_of = Some(
+                            attr.value.split("::").map(Into::into).collect(),
+                        )
+                    }
+                    "derive" => self.derives.push(attr.value),
+                    "private" => {
+                        self.private_fields = Some(attr.value != "false")
+                    }
+                    "accessor" => {
+                        self.accessor_kind = Some(parse_accessor(&attr.value))
+                    }
+                    "constant" => self.constify_enum_variant = true,
+                    _ => {}
+                }
+            }
+        }
+
+        for child in comment.get_children() {
+            self.parse(&child, matched);
+        }
+    }
+
+    /// Returns whether we've parsed a "constant" attribute.
+    pub fn constify_enum_variant(&self) -> bool {
+        self.constify_enum_variant
+    }
+}
diff --git a/bindgen/ir/comment.rs b/bindgen/ir/comment.rs
new file mode 100644
index 00000000..c96e3ebb
--- /dev/null
+++ b/bindgen/ir/comment.rs
@@ -0,0 +1,119 @@
+//! Utilities for manipulating C/C++ comments.
+
+/// The type of a comment.
+#[derive(Debug, PartialEq, Eq)]
+enum Kind {
+    /// A `///` comment, or something of the like.
+    /// All lines in a comment should start with the same symbol.
+    SingleLines,
+    /// A `/**` comment, where each other line can start with `*` and the
+    /// entire block ends with `*/`.
+    MultiLine,
+}
+
+/// Preprocesses a C/C++ comment so that it is a valid Rust comment.
+pub fn preprocess(comment: &str, indent: usize) -> String {
+    match self::kind(comment) {
+        Some(Kind::SingleLines) => preprocess_single_lines(comment, indent),
+        Some(Kind::MultiLine) => preprocess_multi_line(comment, indent),
+        None => comment.to_owned(),
+    }
+}
+
+/// Gets the kind of the doc comment, if it is one.
+fn kind(comment: &str) -> Option<Kind> {
+    if comment.starts_with("/*") {
+        Some(Kind::MultiLine)
+    } else if comment.starts_with("//") {
+        Some(Kind::SingleLines)
+    } else {
+        None
+    }
+}
+
+fn make_indent(indent: usize) -> String {
+    const RUST_INDENTATION: usize = 4;
+    " ".repeat(indent * RUST_INDENTATION)
+}
+
+/// Preprocesses multiple single line comments.
+///
+/// Handles lines starting with both `//` and `///`.
+fn preprocess_single_lines(comment: &str, indent: usize) -> String {
+    debug_assert!(comment.starts_with("//"), "comment is not single line");
+
+    let indent = make_indent(indent);
+    let mut is_first = true;
+    let lines: Vec<_> = comment
+        .lines()
+        .map(|l| l.trim().trim_start_matches('/'))
+        .map(|l| {
+            let indent = if is_first { "" } else { &*indent };
+            is_first = false;
+            format!("{}///{}", indent, l)
+        })
+        .collect();
+    lines.join("\n")
+}
+
+fn preprocess_multi_line(comment: &str, indent: usize) -> String {
+    let comment = comment
+        .trim_start_matches('/')
+        .trim_end_matches('/')
+        .trim_end_matches('*');
+
+    let indent = make_indent(indent);
+    // Strip any potential `*` characters preceding each line.
+    let mut is_first = true;
+    let mut lines: Vec<_> = comment
+        .lines()
+        .map(|line| line.trim().trim_start_matches('*').trim_start_matches('!'))
+        .skip_while(|line| line.trim().is_empty()) // Skip the first empty lines.
+        .map(|line| {
+            let indent = if is_first { "" } else { &*indent };
+            is_first = false;
+            format!("{}///{}", indent, line)
+        })
+        .collect();
+
+    // Remove the trailing line corresponding to the `*/`.
+    if lines
+        .last()
+        .map_or(false, |l| l.trim().is_empty() || l.trim() == "///")
+    {
+        lines.pop();
+    }
+
+    lines.join("\n")
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn picks_up_single_and_multi_line_doc_comments() {
+        assert_eq!(kind("/// hello"), Some(Kind::SingleLines));
+        assert_eq!(kind("/** world */"), Some(Kind::MultiLine));
+    }
+
+    #[test]
+    fn processes_single_lines_correctly() {
+        assert_eq!(preprocess("/// hello", 0), "/// hello");
+        assert_eq!(preprocess("// hello", 0), "/// hello");
+        assert_eq!(preprocess("//    hello", 0), "///    hello");
+    }
+
+    #[test]
+    fn processes_multi_lines_correctly() {
+        assert_eq!(
+            preprocess("/** hello \n * world \n * foo \n */", 0),
+            "/// hello\n/// world\n/// foo"
+        );
+
+        assert_eq!(
+            preprocess("/**\nhello\n*world\n*foo\n*/", 0),
+            "///hello\n///world\n///foo"
+        );
+    }
+}
diff --git a/bindgen/ir/comp.rs b/bindgen/ir/comp.rs
new file mode 100644
index 00000000..f44c5d67
--- /dev/null
+++ b/bindgen/ir/comp.rs
@@ -0,0 +1,1891 @@
+//! Compound types (unions and structs) in our intermediate representation.
+
+use super::analysis::Sizedness;
+use super::annotations::Annotations;
+use super::context::{BindgenContext, FunctionId, ItemId, TypeId, VarId};
+use super::dot::DotAttributes;
+use super::item::{IsOpaque, Item};
+use super::layout::Layout;
+use super::template::TemplateParameters;
+use super::traversal::{EdgeKind, Trace, Tracer};
+use super::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
+use crate::clang;
+use crate::codegen::struct_layout::{align_to, bytes_from_bits_pow2};
+use crate::ir::derive::CanDeriveCopy;
+use crate::parse::{ClangItemParser, ParseError};
+use crate::HashMap;
+use crate::NonCopyUnionStyle;
+use peeking_take_while::PeekableExt;
+use std::cmp;
+use std::io;
+use std::mem;
+
+/// The kind of compound type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum CompKind {
+    /// A struct.
+    Struct,
+    /// A union.
+    Union,
+}
+
+/// The kind of C++ method.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum MethodKind {
+    /// A constructor. We represent it as method for convenience, to avoid code
+    /// duplication.
+    Constructor,
+    /// A destructor.
+    Destructor,
+    /// A virtual destructor.
+    VirtualDestructor {
+        /// Whether it's pure virtual.
+        pure_virtual: bool,
+    },
+    /// A static method.
+    Static,
+    /// A normal method.
+    Normal,
+    /// A virtual method.
+    Virtual {
+        /// Whether it's pure virtual.
+        pure_virtual: bool,
+    },
+}
+
+impl MethodKind {
+    /// Is this a destructor method?
+    pub fn is_destructor(&self) -> bool {
+        matches!(
+            *self,
+            MethodKind::Destructor | MethodKind::VirtualDestructor { .. }
+        )
+    }
+
+    /// Is this a pure virtual method?
+    pub fn is_pure_virtual(&self) -> bool {
+        match *self {
+            MethodKind::Virtual { pure_virtual } |
+            MethodKind::VirtualDestructor { pure_virtual } => pure_virtual,
+            _ => false,
+        }
+    }
+}
+
+/// A struct representing a C++ method, either static, normal, or virtual.
+#[derive(Debug)]
+pub struct Method {
+    kind: MethodKind,
+    /// The signature of the method. Take into account this is not a `Type`
+    /// item, but a `Function` one.
+    ///
+    /// This is tricky and probably this field should be renamed.
+    signature: FunctionId,
+    is_const: bool,
+}
+
+impl Method {
+    /// Construct a new `Method`.
+    pub fn new(
+        kind: MethodKind,
+        signature: FunctionId,
+        is_const: bool,
+    ) -> Self {
+        Method {
+            kind,
+            signature,
+            is_const,
+        }
+    }
+
+    /// What kind of method is this?
+    pub fn kind(&self) -> MethodKind {
+        self.kind
+    }
+
+    /// Is this a constructor?
+    pub fn is_constructor(&self) -> bool {
+        self.kind == MethodKind::Constructor
+    }
+
+    /// Is this a virtual method?
+    pub fn is_virtual(&self) -> bool {
+        matches!(
+            self.kind,
+            MethodKind::Virtual { .. } | MethodKind::VirtualDestructor { .. }
+        )
+    }
+
+    /// Is this a static method?
+    pub fn is_static(&self) -> bool {
+        self.kind == MethodKind::Static
+    }
+
+    /// Get the id for the `Function` signature for this method.
+    pub fn signature(&self) -> FunctionId {
+        self.signature
+    }
+
+    /// Is this a const qualified method?
+    pub fn is_const(&self) -> bool {
+        self.is_const
+    }
+}
+
+/// Methods common to the various field types.
+pub trait FieldMethods {
+    /// Get the name of this field.
+    fn name(&self) -> Option<&str>;
+
+    /// Get the type of this field.
+    fn ty(&self) -> TypeId;
+
+    /// Get the comment for this field.
+    fn comment(&self) -> Option<&str>;
+
+    /// If this is a bitfield, how many bits does it need?
+    fn bitfield_width(&self) -> Option<u32>;
+
+    /// Is this feild declared public?
+    fn is_public(&self) -> bool;
+
+    /// Get the annotations for this field.
+    fn annotations(&self) -> &Annotations;
+
+    /// The offset of the field (in bits)
+    fn offset(&self) -> Option<usize>;
+}
+
+/// A contiguous set of logical bitfields that live within the same physical
+/// allocation unit. See 9.2.4 [class.bit] in the C++ standard and [section
+/// 2.4.II.1 in the Itanium C++
+/// ABI](http://itanium-cxx-abi.github.io/cxx-abi/abi.html#class-types).
+#[derive(Debug)]
+pub struct BitfieldUnit {
+    nth: usize,
+    layout: Layout,
+    bitfields: Vec<Bitfield>,
+}
+
+impl BitfieldUnit {
+    /// Get the 1-based index of this bitfield unit within its containing
+    /// struct. Useful for generating a Rust struct's field name for this unit
+    /// of bitfields.
+    pub fn nth(&self) -> usize {
+        self.nth
+    }
+
+    /// Get the layout within which these bitfields reside.
+    pub fn layout(&self) -> Layout {
+        self.layout
+    }
+
+    /// Get the bitfields within this unit.
+    pub fn bitfields(&self) -> &[Bitfield] {
+        &self.bitfields
+    }
+}
+
+/// A struct representing a C++ field.
+#[derive(Debug)]
+pub enum Field {
+    /// A normal data member.
+    DataMember(FieldData),
+
+    /// A physical allocation unit containing many logical bitfields.
+    Bitfields(BitfieldUnit),
+}
+
+impl Field {
+    /// Get this field's layout.
+    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
+        match *self {
+            Field::Bitfields(BitfieldUnit { layout, .. }) => Some(layout),
+            Field::DataMember(ref data) => {
+                ctx.resolve_type(data.ty).layout(ctx)
+            }
+        }
+    }
+}
+
+impl Trace for Field {
+    type Extra = ();
+
+    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
+    where
+        T: Tracer,
+    {
+        match *self {
+            Field::DataMember(ref data) => {
+                tracer.visit_kind(data.ty.into(), EdgeKind::Field);
+            }
+            Field::Bitfields(BitfieldUnit { ref bitfields, .. }) => {
+                for bf in bitfields {
+                    tracer.visit_kind(bf.ty().into(), EdgeKind::Field);
+                }
+            }
+        }
+    }
+}
+
+impl DotAttributes for Field {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        match *self {
+            Field::DataMember(ref data) => data.dot_attributes(ctx, out),
+            Field::Bitfields(BitfieldUnit {
+                layout,
+                ref bitfields,
+                ..
+            }) => {
+                writeln!(
+                    out,
+                    r#"<tr>
+                              <td>bitfield unit</td>
+                              <td>
+                                <table border="0">
+                                  <tr>
+                                    <td>unit.size</td><td>{}</td>
+                                  </tr>
+                                  <tr>
+                                    <td>unit.align</td><td>{}</td>
+                                  </tr>
+                         "#,
+                    layout.size, layout.align
+                )?;
+                for bf in bitfields {
+                    bf.dot_attributes(ctx, out)?;
+                }
+                writeln!(out, "</table></td></tr>")
+            }
+        }
+    }
+}
+
+impl DotAttributes for FieldData {
+    fn dot_attributes<W>(
+        &self,
+        _ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(
+            out,
+            "<tr><td>{}</td><td>{:?}</td></tr>",
+            self.name().unwrap_or("(anonymous)"),
+            self.ty()
+        )
+    }
+}
+
+impl DotAttributes for Bitfield {
+    fn dot_attributes<W>(
+        &self,
+        _ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(
+            out,
+            "<tr><td>{} : {}</td><td>{:?}</td></tr>",
+            self.name().unwrap_or("(anonymous)"),
+            self.width(),
+            self.ty()
+        )
+    }
+}
+
+/// A logical bitfield within some physical bitfield allocation unit.
+#[derive(Debug)]
+pub struct Bitfield {
+    /// Index of the bit within this bitfield's allocation unit where this
+    /// bitfield's bits begin.
+    offset_into_unit: usize,
+
+    /// The field data for this bitfield.
+    data: FieldData,
+
+    /// Name of the generated Rust getter for this bitfield.
+    ///
+    /// Should be assigned before codegen.
+    getter_name: Option<String>,
+
+    /// Name of the generated Rust setter for this bitfield.
+    ///
+    /// Should be assigned before codegen.
+    setter_name: Option<String>,
+}
+
+impl Bitfield {
+    /// Construct a new bitfield.
+    fn new(offset_into_unit: usize, raw: RawField) -> Bitfield {
+        assert!(raw.bitfield_width().is_some());
+
+        Bitfield {
+            offset_into_unit,
+            data: raw.0,
+            getter_name: None,
+            setter_name: None,
+        }
+    }
+
+    /// Get the index of the bit within this bitfield's allocation unit where
+    /// this bitfield begins.
+    pub fn offset_into_unit(&self) -> usize {
+        self.offset_into_unit
+    }
+
+    /// Get the mask value that when &'ed with this bitfield's allocation unit
+    /// produces this bitfield's value.
+    pub fn mask(&self) -> u64 {
+        use std::u64;
+
+        let unoffseted_mask =
+            if self.width() as u64 == mem::size_of::<u64>() as u64 * 8 {
+                u64::MAX
+            } else {
+                (1u64 << self.width()) - 1u64
+            };
+
+        unoffseted_mask << self.offset_into_unit()
+    }
+
+    /// Get the bit width of this bitfield.
+    pub fn width(&self) -> u32 {
+        self.data.bitfield_width().unwrap()
+    }
+
+    /// Name of the generated Rust getter for this bitfield.
+    ///
+    /// Panics if called before assigning bitfield accessor names or if
+    /// this bitfield have no name.
+    pub fn getter_name(&self) -> &str {
+        assert!(
+            self.name().is_some(),
+            "`Bitfield::getter_name` called on anonymous field"
+        );
+        self.getter_name.as_ref().expect(
+            "`Bitfield::getter_name` should only be called after\
+             assigning bitfield accessor names",
+        )
+    }
+
+    /// Name of the generated Rust setter for this bitfield.
+    ///
+    /// Panics if called before assigning bitfield accessor names or if
+    /// this bitfield have no name.
+    pub fn setter_name(&self) -> &str {
+        assert!(
+            self.name().is_some(),
+            "`Bitfield::setter_name` called on anonymous field"
+        );
+        self.setter_name.as_ref().expect(
+            "`Bitfield::setter_name` should only be called\
+             after assigning bitfield accessor names",
+        )
+    }
+}
+
+impl FieldMethods for Bitfield {
+    fn name(&self) -> Option<&str> {
+        self.data.name()
+    }
+
+    fn ty(&self) -> TypeId {
+        self.data.ty()
+    }
+
+    fn comment(&self) -> Option<&str> {
+        self.data.comment()
+    }
+
+    fn bitfield_width(&self) -> Option<u32> {
+        self.data.bitfield_width()
+    }
+
+    fn is_public(&self) -> bool {
+        self.data.is_public()
+    }
+
+    fn annotations(&self) -> &Annotations {
+        self.data.annotations()
+    }
+
+    fn offset(&self) -> Option<usize> {
+        self.data.offset()
+    }
+}
+
+/// A raw field might be either of a plain data member or a bitfield within a
+/// bitfield allocation unit, but we haven't processed it and determined which
+/// yet (which would involve allocating it into a bitfield unit if it is a
+/// bitfield).
+#[derive(Debug)]
+struct RawField(FieldData);
+
+impl RawField {
+    /// Construct a new `RawField`.
+    fn new(
+        name: Option<String>,
+        ty: TypeId,
+        comment: Option<String>,
+        annotations: Option<Annotations>,
+        bitfield_width: Option<u32>,
+        public: bool,
+        offset: Option<usize>,
+    ) -> RawField {
+        RawField(FieldData {
+            name,
+            ty,
+            comment,
+            annotations: annotations.unwrap_or_default(),
+            bitfield_width,
+            public,
+            offset,
+        })
+    }
+}
+
+impl FieldMethods for RawField {
+    fn name(&self) -> Option<&str> {
+        self.0.name()
+    }
+
+    fn ty(&self) -> TypeId {
+        self.0.ty()
+    }
+
+    fn comment(&self) -> Option<&str> {
+        self.0.comment()
+    }
+
+    fn bitfield_width(&self) -> Option<u32> {
+        self.0.bitfield_width()
+    }
+
+    fn is_public(&self) -> bool {
+        self.0.is_public()
+    }
+
+    fn annotations(&self) -> &Annotations {
+        self.0.annotations()
+    }
+
+    fn offset(&self) -> Option<usize> {
+        self.0.offset()
+    }
+}
+
+/// Convert the given ordered set of raw fields into a list of either plain data
+/// members, and/or bitfield units containing multiple bitfields.
+///
+/// If we do not have the layout for a bitfield's type, then we can't reliably
+/// compute its allocation unit. In such cases, we return an error.
+fn raw_fields_to_fields_and_bitfield_units<I>(
+    ctx: &BindgenContext,
+    raw_fields: I,
+    packed: bool,
+) -> Result<(Vec<Field>, bool), ()>
+where
+    I: IntoIterator<Item = RawField>,
+{
+    let mut raw_fields = raw_fields.into_iter().fuse().peekable();
+    let mut fields = vec![];
+    let mut bitfield_unit_count = 0;
+
+    loop {
+        // While we have plain old data members, just keep adding them to our
+        // resulting fields. We introduce a scope here so that we can use
+        // `raw_fields` again after the `by_ref` iterator adaptor is dropped.
+        {
+            let non_bitfields = raw_fields
+                .by_ref()
+                .peeking_take_while(|f| f.bitfield_width().is_none())
+                .map(|f| Field::DataMember(f.0));
+            fields.extend(non_bitfields);
+        }
+
+        // Now gather all the consecutive bitfields. Only consecutive bitfields
+        // may potentially share a bitfield allocation unit with each other in
+        // the Itanium C++ ABI.
+        let mut bitfields = raw_fields
+            .by_ref()
+            .peeking_take_while(|f| f.bitfield_width().is_some())
+            .peekable();
+
+        if bitfields.peek().is_none() {
+            break;
+        }
+
+        bitfields_to_allocation_units(
+            ctx,
+            &mut bitfield_unit_count,
+            &mut fields,
+            bitfields,
+            packed,
+        )?;
+    }
+
+    assert!(
+        raw_fields.next().is_none(),
+        "The above loop should consume all items in `raw_fields`"
+    );
+
+    Ok((fields, bitfield_unit_count != 0))
+}
+
+/// Given a set of contiguous raw bitfields, group and allocate them into
+/// (potentially multiple) bitfield units.
+fn bitfields_to_allocation_units<E, I>(
+    ctx: &BindgenContext,
+    bitfield_unit_count: &mut usize,
+    fields: &mut E,
+    raw_bitfields: I,
+    packed: bool,
+) -> Result<(), ()>
+where
+    E: Extend<Field>,
+    I: IntoIterator<Item = RawField>,
+{
+    assert!(ctx.collected_typerefs());
+
+    // NOTE: What follows is reverse-engineered from LLVM's
+    // lib/AST/RecordLayoutBuilder.cpp
+    //
+    // FIXME(emilio): There are some differences between Microsoft and the
+    // Itanium ABI, but we'll ignore those and stick to Itanium for now.
+    //
+    // Also, we need to handle packed bitfields and stuff.
+    //
+    // TODO(emilio): Take into account C++'s wide bitfields, and
+    // packing, sigh.
+
+    fn flush_allocation_unit<E>(
+        fields: &mut E,
+        bitfield_unit_count: &mut usize,
+        unit_size_in_bits: usize,
+        unit_align_in_bits: usize,
+        bitfields: Vec<Bitfield>,
+        packed: bool,
+    ) where
+        E: Extend<Field>,
+    {
+        *bitfield_unit_count += 1;
+        let align = if packed {
+            1
+        } else {
+            bytes_from_bits_pow2(unit_align_in_bits)
+        };
+        let size = align_to(unit_size_in_bits, 8) / 8;
+        let layout = Layout::new(size, align);
+        fields.extend(Some(Field::Bitfields(BitfieldUnit {
+            nth: *bitfield_unit_count,
+            layout,
+            bitfields,
+        })));
+    }
+
+    let mut max_align = 0;
+    let mut unfilled_bits_in_unit = 0;
+    let mut unit_size_in_bits = 0;
+    let mut unit_align = 0;
+    let mut bitfields_in_unit = vec![];
+
+    // TODO(emilio): Determine this from attributes or pragma ms_struct
+    // directives. Also, perhaps we should check if the target is MSVC?
+    const is_ms_struct: bool = false;
+
+    for bitfield in raw_bitfields {
+        let bitfield_width = bitfield.bitfield_width().unwrap() as usize;
+        let bitfield_layout =
+            ctx.resolve_type(bitfield.ty()).layout(ctx).ok_or(())?;
+        let bitfield_size = bitfield_layout.size;
+        let bitfield_align = bitfield_layout.align;
+
+        let mut offset = unit_size_in_bits;
+        if !packed {
+            if is_ms_struct {
+                if unit_size_in_bits != 0 &&
+                    (bitfield_width == 0 ||
+                        bitfield_width > unfilled_bits_in_unit)
+                {
+                    // We've reached the end of this allocation unit, so flush it
+                    // and its bitfields.
+                    unit_size_in_bits =
+                        align_to(unit_size_in_bits, unit_align * 8);
+                    flush_allocation_unit(
+                        fields,
+                        bitfield_unit_count,
+                        unit_size_in_bits,
+                        unit_align,
+                        mem::take(&mut bitfields_in_unit),
+                        packed,
+                    );
+
+                    // Now we're working on a fresh bitfield allocation unit, so reset
+                    // the current unit size and alignment.
+                    offset = 0;
+                    unit_align = 0;
+                }
+            } else if offset != 0 &&
+                (bitfield_width == 0 ||
+                    (offset & (bitfield_align * 8 - 1)) + bitfield_width >
+                        bitfield_size * 8)
+            {
+                offset = align_to(offset, bitfield_align * 8);
+            }
+        }
+
+        // According to the x86[-64] ABI spec: "Unnamed bit-fields’ types do not
+        // affect the alignment of a structure or union". This makes sense: such
+        // bit-fields are only used for padding, and we can't perform an
+        // un-aligned read of something we can't read because we can't even name
+        // it.
+        if bitfield.name().is_some() {
+            max_align = cmp::max(max_align, bitfield_align);
+
+            // NB: The `bitfield_width` here is completely, absolutely
+            // intentional.  Alignment of the allocation unit is based on the
+            // maximum bitfield width, not (directly) on the bitfields' types'
+            // alignment.
+            unit_align = cmp::max(unit_align, bitfield_width);
+        }
+
+        // Always keep all bitfields around. While unnamed bitifields are used
+        // for padding (and usually not needed hereafter), large unnamed
+        // bitfields over their types size cause weird allocation size behavior from clang.
+        // Therefore, all bitfields needed to be kept around in order to check for this
+        // and make the struct opaque in this case
+        bitfields_in_unit.push(Bitfield::new(offset, bitfield));
+
+        unit_size_in_bits = offset + bitfield_width;
+
+        // Compute what the physical unit's final size would be given what we
+        // have seen so far, and use that to compute how many bits are still
+        // available in the unit.
+        let data_size = align_to(unit_size_in_bits, bitfield_align * 8);
+        unfilled_bits_in_unit = data_size - unit_size_in_bits;
+    }
+
+    if unit_size_in_bits != 0 {
+        // Flush the last allocation unit and its bitfields.
+        flush_allocation_unit(
+            fields,
+            bitfield_unit_count,
+            unit_size_in_bits,
+            unit_align,
+            bitfields_in_unit,
+            packed,
+        );
+    }
+
+    Ok(())
+}
+
+/// A compound structure's fields are initially raw, and have bitfields that
+/// have not been grouped into allocation units. During this time, the fields
+/// are mutable and we build them up during parsing.
+///
+/// Then, once resolving typerefs is completed, we compute all structs' fields'
+/// bitfield allocation units, and they remain frozen and immutable forever
+/// after.
+#[derive(Debug)]
+enum CompFields {
+    Before(Vec<RawField>),
+    After {
+        fields: Vec<Field>,
+        has_bitfield_units: bool,
+    },
+    Error,
+}
+
+impl Default for CompFields {
+    fn default() -> CompFields {
+        CompFields::Before(vec![])
+    }
+}
+
+impl CompFields {
+    fn append_raw_field(&mut self, raw: RawField) {
+        match *self {
+            CompFields::Before(ref mut raws) => {
+                raws.push(raw);
+            }
+            _ => {
+                panic!(
+                    "Must not append new fields after computing bitfield allocation units"
+                );
+            }
+        }
+    }
+
+    fn compute_bitfield_units(&mut self, ctx: &BindgenContext, packed: bool) {
+        let raws = match *self {
+            CompFields::Before(ref mut raws) => mem::take(raws),
+            _ => {
+                panic!("Already computed bitfield units");
+            }
+        };
+
+        let result = raw_fields_to_fields_and_bitfield_units(ctx, raws, packed);
+
+        match result {
+            Ok((fields, has_bitfield_units)) => {
+                *self = CompFields::After {
+                    fields,
+                    has_bitfield_units,
+                };
+            }
+            Err(()) => {
+                *self = CompFields::Error;
+            }
+        }
+    }
+
+    fn deanonymize_fields(&mut self, ctx: &BindgenContext, methods: &[Method]) {
+        let fields = match *self {
+            CompFields::After { ref mut fields, .. } => fields,
+            // Nothing to do here.
+            CompFields::Error => return,
+            CompFields::Before(_) => {
+                panic!("Not yet computed bitfield units.");
+            }
+        };
+
+        fn has_method(
+            methods: &[Method],
+            ctx: &BindgenContext,
+            name: &str,
+        ) -> bool {
+            methods.iter().any(|method| {
+                let method_name = ctx.resolve_func(method.signature()).name();
+                method_name == name || ctx.rust_mangle(method_name) == name
+            })
+        }
+
+        struct AccessorNamesPair {
+            getter: String,
+            setter: String,
+        }
+
+        let mut accessor_names: HashMap<String, AccessorNamesPair> = fields
+            .iter()
+            .flat_map(|field| match *field {
+                Field::Bitfields(ref bu) => &*bu.bitfields,
+                Field::DataMember(_) => &[],
+            })
+            .filter_map(|bitfield| bitfield.name())
+            .map(|bitfield_name| {
+                let bitfield_name = bitfield_name.to_string();
+                let getter = {
+                    let mut getter =
+                        ctx.rust_mangle(&bitfield_name).to_string();
+                    if has_method(methods, ctx, &getter) {
+                        getter.push_str("_bindgen_bitfield");
+                    }
+                    getter
+                };
+                let setter = {
+                    let setter = format!("set_{}", bitfield_name);
+                    let mut setter = ctx.rust_mangle(&setter).to_string();
+                    if has_method(methods, ctx, &setter) {
+                        setter.push_str("_bindgen_bitfield");
+                    }
+                    setter
+                };
+                (bitfield_name, AccessorNamesPair { getter, setter })
+            })
+            .collect();
+
+        let mut anon_field_counter = 0;
+        for field in fields.iter_mut() {
+            match *field {
+                Field::DataMember(FieldData { ref mut name, .. }) => {
+                    if name.is_some() {
+                        continue;
+                    }
+
+                    anon_field_counter += 1;
+                    *name = Some(format!(
+                        "{}{}",
+                        ctx.options().anon_fields_prefix,
+                        anon_field_counter
+                    ));
+                }
+                Field::Bitfields(ref mut bu) => {
+                    for bitfield in &mut bu.bitfields {
+                        if bitfield.name().is_none() {
+                            continue;
+                        }
+
+                        if let Some(AccessorNamesPair { getter, setter }) =
+                            accessor_names.remove(bitfield.name().unwrap())
+                        {
+                            bitfield.getter_name = Some(getter);
+                            bitfield.setter_name = Some(setter);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Trace for CompFields {
+    type Extra = ();
+
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
+    where
+        T: Tracer,
+    {
+        match *self {
+            CompFields::Error => {}
+            CompFields::Before(ref fields) => {
+                for f in fields {
+                    tracer.visit_kind(f.ty().into(), EdgeKind::Field);
+                }
+            }
+            CompFields::After { ref fields, .. } => {
+                for f in fields {
+                    f.trace(context, tracer, &());
+                }
+            }
+        }
+    }
+}
+
+/// Common data shared across different field types.
+#[derive(Clone, Debug)]
+pub struct FieldData {
+    /// The name of the field, empty if it's an unnamed bitfield width.
+    name: Option<String>,
+
+    /// The inner type.
+    ty: TypeId,
+
+    /// The doc comment on the field if any.
+    comment: Option<String>,
+
+    /// Annotations for this field, or the default.
+    annotations: Annotations,
+
+    /// If this field is a bitfield, and how many bits does it contain if it is.
+    bitfield_width: Option<u32>,
+
+    /// If the C++ field is declared `public`
+    public: bool,
+
+    /// The offset of the field (in bits)
+    offset: Option<usize>,
+}
+
+impl FieldMethods for FieldData {
+    fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    fn ty(&self) -> TypeId {
+        self.ty
+    }
+
+    fn comment(&self) -> Option<&str> {
+        self.comment.as_deref()
+    }
+
+    fn bitfield_width(&self) -> Option<u32> {
+        self.bitfield_width
+    }
+
+    fn is_public(&self) -> bool {
+        self.public
+    }
+
+    fn annotations(&self) -> &Annotations {
+        &self.annotations
+    }
+
+    fn offset(&self) -> Option<usize> {
+        self.offset
+    }
+}
+
+/// The kind of inheritance a base class is using.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum BaseKind {
+    /// Normal inheritance, like:
+    ///
+    /// ```cpp
+    /// class A : public B {};
+    /// ```
+    Normal,
+    /// Virtual inheritance, like:
+    ///
+    /// ```cpp
+    /// class A: public virtual B {};
+    /// ```
+    Virtual,
+}
+
+/// A base class.
+#[derive(Clone, Debug)]
+pub struct Base {
+    /// The type of this base class.
+    pub ty: TypeId,
+    /// The kind of inheritance we're doing.
+    pub kind: BaseKind,
+    /// Name of the field in which this base should be stored.
+    pub field_name: String,
+    /// Whether this base is inherited from publically.
+    pub is_pub: bool,
+}
+
+impl Base {
+    /// Whether this base class is inheriting virtually.
+    pub fn is_virtual(&self) -> bool {
+        self.kind == BaseKind::Virtual
+    }
+
+    /// Whether this base class should have it's own field for storage.
+    pub fn requires_storage(&self, ctx: &BindgenContext) -> bool {
+        // Virtual bases are already taken into account by the vtable
+        // pointer.
+        //
+        // FIXME(emilio): Is this always right?
+        if self.is_virtual() {
+            return false;
+        }
+
+        // NB: We won't include zero-sized types in our base chain because they
+        // would contribute to our size given the dummy field we insert for
+        // zero-sized types.
+        if self.ty.is_zero_sized(ctx) {
+            return false;
+        }
+
+        true
+    }
+
+    /// Whether this base is inherited from publically.
+    pub fn is_public(&self) -> bool {
+        self.is_pub
+    }
+}
+
+/// A compound type.
+///
+/// Either a struct or union, a compound type is built up from the combination
+/// of fields which also are associated with their own (potentially compound)
+/// type.
+#[derive(Debug)]
+pub struct CompInfo {
+    /// Whether this is a struct or a union.
+    kind: CompKind,
+
+    /// The members of this struct or union.
+    fields: CompFields,
+
+    /// The abstract template parameters of this class. Note that these are NOT
+    /// concrete template arguments, and should always be a
+    /// `Type(TypeKind::TypeParam(name))`. For concrete template arguments, see
+    /// `TypeKind::TemplateInstantiation`.
+    template_params: Vec<TypeId>,
+
+    /// The method declarations inside this class, if in C++ mode.
+    methods: Vec<Method>,
+
+    /// The different constructors this struct or class contains.
+    constructors: Vec<FunctionId>,
+
+    /// The destructor of this type. The bool represents whether this destructor
+    /// is virtual.
+    destructor: Option<(MethodKind, FunctionId)>,
+
+    /// Vector of classes this one inherits from.
+    base_members: Vec<Base>,
+
+    /// The inner types that were declared inside this class, in something like:
+    ///
+    /// class Foo {
+    ///     typedef int FooTy;
+    ///     struct Bar {
+    ///         int baz;
+    ///     };
+    /// }
+    ///
+    /// static Foo::Bar const = {3};
+    inner_types: Vec<TypeId>,
+
+    /// Set of static constants declared inside this class.
+    inner_vars: Vec<VarId>,
+
+    /// Whether this type should generate an vtable (TODO: Should be able to
+    /// look at the virtual methods and ditch this field).
+    has_own_virtual_method: bool,
+
+    /// Whether this type has destructor.
+    has_destructor: bool,
+
+    /// Whether this type has a base type with more than one member.
+    ///
+    /// TODO: We should be able to compute this.
+    has_nonempty_base: bool,
+
+    /// If this type has a template parameter which is not a type (e.g.: a
+    /// size_t)
+    has_non_type_template_params: bool,
+
+    /// Whether this type has a bit field member whose width couldn't be
+    /// evaluated (e.g. if it depends on a template parameter). We generate an
+    /// opaque type in this case.
+    has_unevaluable_bit_field_width: bool,
+
+    /// Whether we saw `__attribute__((packed))` on or within this type.
+    packed_attr: bool,
+
+    /// Used to know if we've found an opaque attribute that could cause us to
+    /// generate a type with invalid layout. This is explicitly used to avoid us
+    /// generating bad alignments when parsing types like max_align_t.
+    ///
+    /// It's not clear what the behavior should be here, if generating the item
+    /// and pray, or behave as an opaque type.
+    found_unknown_attr: bool,
+
+    /// Used to indicate when a struct has been forward declared. Usually used
+    /// in headers so that APIs can't modify them directly.
+    is_forward_declaration: bool,
+}
+
+impl CompInfo {
+    /// Construct a new compound type.
+    pub fn new(kind: CompKind) -> Self {
+        CompInfo {
+            kind,
+            fields: CompFields::default(),
+            template_params: vec![],
+            methods: vec![],
+            constructors: vec![],
+            destructor: None,
+            base_members: vec![],
+            inner_types: vec![],
+            inner_vars: vec![],
+            has_own_virtual_method: false,
+            has_destructor: false,
+            has_nonempty_base: false,
+            has_non_type_template_params: false,
+            has_unevaluable_bit_field_width: false,
+            packed_attr: false,
+            found_unknown_attr: false,
+            is_forward_declaration: false,
+        }
+    }
+
+    /// Compute the layout of this type.
+    ///
+    /// This is called as a fallback under some circumstances where LLVM doesn't
+    /// give us the correct layout.
+    ///
+    /// If we're a union without known layout, we try to compute it from our
+    /// members. This is not ideal, but clang fails to report the size for these
+    /// kind of unions, see test/headers/template_union.hpp
+    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
+        // We can't do better than clang here, sorry.
+        if self.kind == CompKind::Struct {
+            return None;
+        }
+
+        // By definition, we don't have the right layout information here if
+        // we're a forward declaration.
+        if self.is_forward_declaration() {
+            return None;
+        }
+
+        // empty union case
+        if !self.has_fields() {
+            return None;
+        }
+
+        let mut max_size = 0;
+        // Don't allow align(0)
+        let mut max_align = 1;
+        self.each_known_field_layout(ctx, |layout| {
+            max_size = cmp::max(max_size, layout.size);
+            max_align = cmp::max(max_align, layout.align);
+        });
+
+        Some(Layout::new(max_size, max_align))
+    }
+
+    /// Get this type's set of fields.
+    pub fn fields(&self) -> &[Field] {
+        match self.fields {
+            CompFields::Error => &[],
+            CompFields::After { ref fields, .. } => fields,
+            CompFields::Before(..) => {
+                panic!("Should always have computed bitfield units first");
+            }
+        }
+    }
+
+    fn has_fields(&self) -> bool {
+        match self.fields {
+            CompFields::Error => false,
+            CompFields::After { ref fields, .. } => !fields.is_empty(),
+            CompFields::Before(ref raw_fields) => !raw_fields.is_empty(),
+        }
+    }
+
+    fn each_known_field_layout(
+        &self,
+        ctx: &BindgenContext,
+        mut callback: impl FnMut(Layout),
+    ) {
+        match self.fields {
+            CompFields::Error => {}
+            CompFields::After { ref fields, .. } => {
+                for field in fields.iter() {
+                    if let Some(layout) = field.layout(ctx) {
+                        callback(layout);
+                    }
+                }
+            }
+            CompFields::Before(ref raw_fields) => {
+                for field in raw_fields.iter() {
+                    let field_ty = ctx.resolve_type(field.0.ty);
+                    if let Some(layout) = field_ty.layout(ctx) {
+                        callback(layout);
+                    }
+                }
+            }
+        }
+    }
+
+    fn has_bitfields(&self) -> bool {
+        match self.fields {
+            CompFields::Error => false,
+            CompFields::After {
+                has_bitfield_units, ..
+            } => has_bitfield_units,
+            CompFields::Before(_) => {
+                panic!("Should always have computed bitfield units first");
+            }
+        }
+    }
+
+    /// Returns whether we have a too large bitfield unit, in which case we may
+    /// not be able to derive some of the things we should be able to normally
+    /// derive.
+    pub fn has_too_large_bitfield_unit(&self) -> bool {
+        if !self.has_bitfields() {
+            return false;
+        }
+        self.fields().iter().any(|field| match *field {
+            Field::DataMember(..) => false,
+            Field::Bitfields(ref unit) => {
+                unit.layout.size > RUST_DERIVE_IN_ARRAY_LIMIT
+            }
+        })
+    }
+
+    /// Does this type have any template parameters that aren't types
+    /// (e.g. int)?
+    pub fn has_non_type_template_params(&self) -> bool {
+        self.has_non_type_template_params
+    }
+
+    /// Do we see a virtual function during parsing?
+    /// Get the has_own_virtual_method boolean.
+    pub fn has_own_virtual_method(&self) -> bool {
+        self.has_own_virtual_method
+    }
+
+    /// Did we see a destructor when parsing this type?
+    pub fn has_own_destructor(&self) -> bool {
+        self.has_destructor
+    }
+
+    /// Get this type's set of methods.
+    pub fn methods(&self) -> &[Method] {
+        &self.methods
+    }
+
+    /// Get this type's set of constructors.
+    pub fn constructors(&self) -> &[FunctionId] {
+        &self.constructors
+    }
+
+    /// Get this type's destructor.
+    pub fn destructor(&self) -> Option<(MethodKind, FunctionId)> {
+        self.destructor
+    }
+
+    /// What kind of compound type is this?
+    pub fn kind(&self) -> CompKind {
+        self.kind
+    }
+
+    /// Is this a union?
+    pub fn is_union(&self) -> bool {
+        self.kind() == CompKind::Union
+    }
+
+    /// The set of types that this one inherits from.
+    pub fn base_members(&self) -> &[Base] {
+        &self.base_members
+    }
+
+    /// Construct a new compound type from a Clang type.
+    pub fn from_ty(
+        potential_id: ItemId,
+        ty: &clang::Type,
+        location: Option<clang::Cursor>,
+        ctx: &mut BindgenContext,
+    ) -> Result<Self, ParseError> {
+        use clang_sys::*;
+        assert!(
+            ty.template_args().is_none(),
+            "We handle template instantiations elsewhere"
+        );
+
+        let mut cursor = ty.declaration();
+        let mut kind = Self::kind_from_cursor(&cursor);
+        if kind.is_err() {
+            if let Some(location) = location {
+                kind = Self::kind_from_cursor(&location);
+                cursor = location;
+            }
+        }
+
+        let kind = kind?;
+
+        debug!("CompInfo::from_ty({:?}, {:?})", kind, cursor);
+
+        let mut ci = CompInfo::new(kind);
+        ci.is_forward_declaration =
+            location.map_or(true, |cur| match cur.kind() {
+                CXCursor_ParmDecl => true,
+                CXCursor_StructDecl | CXCursor_UnionDecl |
+                CXCursor_ClassDecl => !cur.is_definition(),
+                _ => false,
+            });
+
+        let mut maybe_anonymous_struct_field = None;
+        cursor.visit(|cur| {
+            if cur.kind() != CXCursor_FieldDecl {
+                if let Some((ty, clang_ty, public, offset)) =
+                    maybe_anonymous_struct_field.take()
+                {
+                    if cur.kind() == CXCursor_TypedefDecl &&
+                        cur.typedef_type().unwrap().canonical_type() ==
+                            clang_ty
+                    {
+                        // Typedefs of anonymous structs appear later in the ast
+                        // than the struct itself, that would otherwise be an
+                        // anonymous field. Detect that case here, and do
+                        // nothing.
+                    } else {
+                        let field = RawField::new(
+                            None, ty, None, None, None, public, offset,
+                        );
+                        ci.fields.append_raw_field(field);
+                    }
+                }
+            }
+
+            match cur.kind() {
+                CXCursor_FieldDecl => {
+                    if let Some((ty, clang_ty, public, offset)) =
+                        maybe_anonymous_struct_field.take()
+                    {
+                        let mut used = false;
+                        cur.visit(|child| {
+                            if child.cur_type() == clang_ty {
+                                used = true;
+                            }
+                            CXChildVisit_Continue
+                        });
+
+                        if !used {
+                            let field = RawField::new(
+                                None, ty, None, None, None, public, offset,
+                            );
+                            ci.fields.append_raw_field(field);
+                        }
+                    }
+
+                    let bit_width = if cur.is_bit_field() {
+                        let width = cur.bit_width();
+
+                        // Make opaque type if the bit width couldn't be
+                        // evaluated.
+                        if width.is_none() {
+                            ci.has_unevaluable_bit_field_width = true;
+                            return CXChildVisit_Break;
+                        }
+
+                        width
+                    } else {
+                        None
+                    };
+
+                    let field_type = Item::from_ty_or_ref(
+                        cur.cur_type(),
+                        cur,
+                        Some(potential_id),
+                        ctx,
+                    );
+
+                    let comment = cur.raw_comment();
+                    let annotations = Annotations::new(&cur);
+                    let name = cur.spelling();
+                    let is_public = cur.public_accessible();
+                    let offset = cur.offset_of_field().ok();
+
+                    // Name can be empty if there are bitfields, for example,
+                    // see tests/headers/struct_with_bitfields.h
+                    assert!(
+                        !name.is_empty() || bit_width.is_some(),
+                        "Empty field name?"
+                    );
+
+                    let name = if name.is_empty() { None } else { Some(name) };
+
+                    let field = RawField::new(
+                        name,
+                        field_type,
+                        comment,
+                        annotations,
+                        bit_width,
+                        is_public,
+                        offset,
+                    );
+                    ci.fields.append_raw_field(field);
+
+                    // No we look for things like attributes and stuff.
+                    cur.visit(|cur| {
+                        if cur.kind() == CXCursor_UnexposedAttr {
+                            ci.found_unknown_attr = true;
+                        }
+                        CXChildVisit_Continue
+                    });
+                }
+                CXCursor_UnexposedAttr => {
+                    ci.found_unknown_attr = true;
+                }
+                CXCursor_EnumDecl |
+                CXCursor_TypeAliasDecl |
+                CXCursor_TypeAliasTemplateDecl |
+                CXCursor_TypedefDecl |
+                CXCursor_StructDecl |
+                CXCursor_UnionDecl |
+                CXCursor_ClassTemplate |
+                CXCursor_ClassDecl => {
+                    // We can find non-semantic children here, clang uses a
+                    // StructDecl to note incomplete structs that haven't been
+                    // forward-declared before, see [1].
+                    //
+                    // Also, clang seems to scope struct definitions inside
+                    // unions, and other named struct definitions inside other
+                    // structs to the whole translation unit.
+                    //
+                    // Let's just assume that if the cursor we've found is a
+                    // definition, it's a valid inner type.
+                    //
+                    // [1]: https://github.com/rust-lang/rust-bindgen/issues/482
+                    let is_inner_struct =
+                        cur.semantic_parent() == cursor || cur.is_definition();
+                    if !is_inner_struct {
+                        return CXChildVisit_Continue;
+                    }
+
+                    // Even if this is a definition, we may not be the semantic
+                    // parent, see #1281.
+                    let inner = Item::parse(cur, Some(potential_id), ctx)
+                        .expect("Inner ClassDecl");
+
+                    // If we avoided recursion parsing this type (in
+                    // `Item::from_ty_with_id()`), then this might not be a
+                    // valid type ID, so check and gracefully handle this.
+                    if ctx.resolve_item_fallible(inner).is_some() {
+                        let inner = inner.expect_type_id(ctx);
+
+                        ci.inner_types.push(inner);
+
+                        // A declaration of an union or a struct without name
+                        // could also be an unnamed field, unfortunately.
+                        if cur.spelling().is_empty() &&
+                            cur.kind() != CXCursor_EnumDecl
+                        {
+                            let ty = cur.cur_type();
+                            let public = cur.public_accessible();
+                            let offset = cur.offset_of_field().ok();
+
+                            maybe_anonymous_struct_field =
+                                Some((inner, ty, public, offset));
+                        }
+                    }
+                }
+                CXCursor_PackedAttr => {
+                    ci.packed_attr = true;
+                }
+                CXCursor_TemplateTypeParameter => {
+                    let param = Item::type_param(None, cur, ctx).expect(
+                        "Item::type_param should't fail when pointing \
+                         at a TemplateTypeParameter",
+                    );
+                    ci.template_params.push(param);
+                }
+                CXCursor_CXXBaseSpecifier => {
+                    let is_virtual_base = cur.is_virtual_base();
+                    ci.has_own_virtual_method |= is_virtual_base;
+
+                    let kind = if is_virtual_base {
+                        BaseKind::Virtual
+                    } else {
+                        BaseKind::Normal
+                    };
+
+                    let field_name = match ci.base_members.len() {
+                        0 => "_base".into(),
+                        n => format!("_base_{}", n),
+                    };
+                    let type_id =
+                        Item::from_ty_or_ref(cur.cur_type(), cur, None, ctx);
+                    ci.base_members.push(Base {
+                        ty: type_id,
+                        kind,
+                        field_name,
+                        is_pub: cur.access_specifier() ==
+                            clang_sys::CX_CXXPublic,
+                    });
+                }
+                CXCursor_Constructor | CXCursor_Destructor |
+                CXCursor_CXXMethod => {
+                    let is_virtual = cur.method_is_virtual();
+                    let is_static = cur.method_is_static();
+                    debug_assert!(!(is_static && is_virtual), "How?");
+
+                    ci.has_destructor |= cur.kind() == CXCursor_Destructor;
+                    ci.has_own_virtual_method |= is_virtual;
+
+                    // This used to not be here, but then I tried generating
+                    // stylo bindings with this (without path filters), and
+                    // cried a lot with a method in gfx/Point.h
+                    // (ToUnknownPoint), that somehow was causing the same type
+                    // to be inserted in the map two times.
+                    //
+                    // I couldn't make a reduced test case, but anyway...
+                    // Methods of template functions not only used to be inlined,
+                    // but also instantiated, and we wouldn't be able to call
+                    // them, so just bail out.
+                    if !ci.template_params.is_empty() {
+                        return CXChildVisit_Continue;
+                    }
+
+                    // NB: This gets us an owned `Function`, not a
+                    // `FunctionSig`.
+                    let signature =
+                        match Item::parse(cur, Some(potential_id), ctx) {
+                            Ok(item)
+                                if ctx
+                                    .resolve_item(item)
+                                    .kind()
+                                    .is_function() =>
+                            {
+                                item
+                            }
+                            _ => return CXChildVisit_Continue,
+                        };
+
+                    let signature = signature.expect_function_id(ctx);
+
+                    match cur.kind() {
+                        CXCursor_Constructor => {
+                            ci.constructors.push(signature);
+                        }
+                        CXCursor_Destructor => {
+                            let kind = if is_virtual {
+                                MethodKind::VirtualDestructor {
+                                    pure_virtual: cur.method_is_pure_virtual(),
+                                }
+                            } else {
+                                MethodKind::Destructor
+                            };
+                            ci.destructor = Some((kind, signature));
+                        }
+                        CXCursor_CXXMethod => {
+                            let is_const = cur.method_is_const();
+                            let method_kind = if is_static {
+                                MethodKind::Static
+                            } else if is_virtual {
+                                MethodKind::Virtual {
+                                    pure_virtual: cur.method_is_pure_virtual(),
+                                }
+                            } else {
+                                MethodKind::Normal
+                            };
+
+                            let method =
+                                Method::new(method_kind, signature, is_const);
+
+                            ci.methods.push(method);
+                        }
+                        _ => unreachable!("How can we see this here?"),
+                    }
+                }
+                CXCursor_NonTypeTemplateParameter => {
+                    ci.has_non_type_template_params = true;
+                }
+                CXCursor_VarDecl => {
+                    let linkage = cur.linkage();
+                    if linkage != CXLinkage_External &&
+                        linkage != CXLinkage_UniqueExternal
+                    {
+                        return CXChildVisit_Continue;
+                    }
+
+                    let visibility = cur.visibility();
+                    if visibility != CXVisibility_Default {
+                        return CXChildVisit_Continue;
+                    }
+
+                    if let Ok(item) = Item::parse(cur, Some(potential_id), ctx)
+                    {
+                        ci.inner_vars.push(item.as_var_id_unchecked());
+                    }
+                }
+                // Intentionally not handled
+                CXCursor_CXXAccessSpecifier |
+                CXCursor_CXXFinalAttr |
+                CXCursor_FunctionTemplate |
+                CXCursor_ConversionFunction => {}
+                _ => {
+                    warn!(
+                        "unhandled comp member `{}` (kind {:?}) in `{}` ({})",
+                        cur.spelling(),
+                        clang::kind_to_str(cur.kind()),
+                        cursor.spelling(),
+                        cur.location()
+                    );
+                }
+            }
+            CXChildVisit_Continue
+        });
+
+        if let Some((ty, _, public, offset)) = maybe_anonymous_struct_field {
+            let field =
+                RawField::new(None, ty, None, None, None, public, offset);
+            ci.fields.append_raw_field(field);
+        }
+
+        Ok(ci)
+    }
+
+    fn kind_from_cursor(
+        cursor: &clang::Cursor,
+    ) -> Result<CompKind, ParseError> {
+        use clang_sys::*;
+        Ok(match cursor.kind() {
+            CXCursor_UnionDecl => CompKind::Union,
+            CXCursor_ClassDecl | CXCursor_StructDecl => CompKind::Struct,
+            CXCursor_CXXBaseSpecifier |
+            CXCursor_ClassTemplatePartialSpecialization |
+            CXCursor_ClassTemplate => match cursor.template_kind() {
+                CXCursor_UnionDecl => CompKind::Union,
+                _ => CompKind::Struct,
+            },
+            _ => {
+                warn!("Unknown kind for comp type: {:?}", cursor);
+                return Err(ParseError::Continue);
+            }
+        })
+    }
+
+    /// Get the set of types that were declared within this compound type
+    /// (e.g. nested class definitions).
+    pub fn inner_types(&self) -> &[TypeId] {
+        &self.inner_types
+    }
+
+    /// Get the set of static variables declared within this compound type.
+    pub fn inner_vars(&self) -> &[VarId] {
+        &self.inner_vars
+    }
+
+    /// Have we found a field with an opaque type that could potentially mess up
+    /// the layout of this compound type?
+    pub fn found_unknown_attr(&self) -> bool {
+        self.found_unknown_attr
+    }
+
+    /// Is this compound type packed?
+    pub fn is_packed(
+        &self,
+        ctx: &BindgenContext,
+        layout: Option<&Layout>,
+    ) -> bool {
+        if self.packed_attr {
+            return true;
+        }
+
+        // Even though `libclang` doesn't expose `#pragma packed(...)`, we can
+        // detect it through its effects.
+        if let Some(parent_layout) = layout {
+            let mut packed = false;
+            self.each_known_field_layout(ctx, |layout| {
+                packed = packed || layout.align > parent_layout.align;
+            });
+            if packed {
+                info!("Found a struct that was defined within `#pragma packed(...)`");
+                return true;
+            }
+
+            if self.has_own_virtual_method && parent_layout.align == 1 {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    /// Returns true if compound type has been forward declared
+    pub fn is_forward_declaration(&self) -> bool {
+        self.is_forward_declaration
+    }
+
+    /// Compute this compound structure's bitfield allocation units.
+    pub fn compute_bitfield_units(
+        &mut self,
+        ctx: &BindgenContext,
+        layout: Option<&Layout>,
+    ) {
+        let packed = self.is_packed(ctx, layout);
+        self.fields.compute_bitfield_units(ctx, packed)
+    }
+
+    /// Assign for each anonymous field a generated name.
+    pub fn deanonymize_fields(&mut self, ctx: &BindgenContext) {
+        self.fields.deanonymize_fields(ctx, &self.methods);
+    }
+
+    /// Returns whether the current union can be represented as a Rust `union`
+    ///
+    /// Requirements:
+    ///     1. Current RustTarget allows for `untagged_union`
+    ///     2. Each field can derive `Copy` or we use ManuallyDrop.
+    ///     3. It's not zero-sized.
+    ///
+    /// Second boolean returns whether all fields can be copied (and thus
+    /// ManuallyDrop is not needed).
+    pub fn is_rust_union(
+        &self,
+        ctx: &BindgenContext,
+        layout: Option<&Layout>,
+        name: &str,
+    ) -> (bool, bool) {
+        if !self.is_union() {
+            return (false, false);
+        }
+
+        if !ctx.options().rust_features().untagged_union {
+            return (false, false);
+        }
+
+        if self.is_forward_declaration() {
+            return (false, false);
+        }
+
+        let union_style = if ctx.options().bindgen_wrapper_union.matches(name) {
+            NonCopyUnionStyle::BindgenWrapper
+        } else if ctx.options().manually_drop_union.matches(name) {
+            NonCopyUnionStyle::ManuallyDrop
+        } else {
+            ctx.options().default_non_copy_union_style
+        };
+
+        let all_can_copy = self.fields().iter().all(|f| match *f {
+            Field::DataMember(ref field_data) => {
+                field_data.ty().can_derive_copy(ctx)
+            }
+            Field::Bitfields(_) => true,
+        });
+
+        if !all_can_copy && union_style == NonCopyUnionStyle::BindgenWrapper {
+            return (false, false);
+        }
+
+        if layout.map_or(false, |l| l.size == 0) {
+            return (false, false);
+        }
+
+        (true, all_can_copy)
+    }
+}
+
+impl DotAttributes for CompInfo {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(out, "<tr><td>CompKind</td><td>{:?}</td></tr>", self.kind)?;
+
+        if self.has_own_virtual_method {
+            writeln!(out, "<tr><td>has_vtable</td><td>true</td></tr>")?;
+        }
+
+        if self.has_destructor {
+            writeln!(out, "<tr><td>has_destructor</td><td>true</td></tr>")?;
+        }
+
+        if self.has_nonempty_base {
+            writeln!(out, "<tr><td>has_nonempty_base</td><td>true</td></tr>")?;
+        }
+
+        if self.has_non_type_template_params {
+            writeln!(
+                out,
+                "<tr><td>has_non_type_template_params</td><td>true</td></tr>"
+            )?;
+        }
+
+        if self.packed_attr {
+            writeln!(out, "<tr><td>packed_attr</td><td>true</td></tr>")?;
+        }
+
+        if self.is_forward_declaration {
+            writeln!(
+                out,
+                "<tr><td>is_forward_declaration</td><td>true</td></tr>"
+            )?;
+        }
+
+        if !self.fields().is_empty() {
+            writeln!(out, r#"<tr><td>fields</td><td><table border="0">"#)?;
+            for field in self.fields() {
+                field.dot_attributes(ctx, out)?;
+            }
+            writeln!(out, "</table></td></tr>")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl IsOpaque for CompInfo {
+    type Extra = Option<Layout>;
+
+    fn is_opaque(&self, ctx: &BindgenContext, layout: &Option<Layout>) -> bool {
+        if self.has_non_type_template_params ||
+            self.has_unevaluable_bit_field_width
+        {
+            return true;
+        }
+
+        // When we do not have the layout for a bitfield's type (for example, it
+        // is a type parameter), then we can't compute bitfield units. We are
+        // left with no choice but to make the whole struct opaque, or else we
+        // might generate structs with incorrect sizes and alignments.
+        if let CompFields::Error = self.fields {
+            return true;
+        }
+
+        // Bitfields with a width that is larger than their unit's width have
+        // some strange things going on, and the best we can do is make the
+        // whole struct opaque.
+        if self.fields().iter().any(|f| match *f {
+            Field::DataMember(_) => false,
+            Field::Bitfields(ref unit) => unit.bitfields().iter().any(|bf| {
+                let bitfield_layout = ctx
+                    .resolve_type(bf.ty())
+                    .layout(ctx)
+                    .expect("Bitfield without layout? Gah!");
+                bf.width() / 8 > bitfield_layout.size as u32
+            }),
+        }) {
+            return true;
+        }
+
+        if !ctx.options().rust_features().repr_packed_n {
+            // If we don't have `#[repr(packed(N)]`, the best we can
+            // do is make this struct opaque.
+            //
+            // See https://github.com/rust-lang/rust-bindgen/issues/537 and
+            // https://github.com/rust-lang/rust/issues/33158
+            if self.is_packed(ctx, layout.as_ref()) &&
+                layout.map_or(false, |l| l.align > 1)
+            {
+                warn!("Found a type that is both packed and aligned to greater than \
+                       1; Rust before version 1.33 doesn't have `#[repr(packed(N))]`, so we \
+                       are treating it as opaque. You may wish to set bindgen's rust target \
+                       version to 1.33 or later to enable `#[repr(packed(N))]` support.");
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+impl TemplateParameters for CompInfo {
+    fn self_template_params(&self, _ctx: &BindgenContext) -> Vec<TypeId> {
+        self.template_params.clone()
+    }
+}
+
+impl Trace for CompInfo {
+    type Extra = Item;
+
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
+    where
+        T: Tracer,
+    {
+        for p in item.all_template_params(context) {
+            tracer.visit_kind(p.into(), EdgeKind::TemplateParameterDefinition);
+        }
+
+        for ty in self.inner_types() {
+            tracer.visit_kind(ty.into(), EdgeKind::InnerType);
+        }
+
+        for &var in self.inner_vars() {
+            tracer.visit_kind(var.into(), EdgeKind::InnerVar);
+        }
+
+        for method in self.methods() {
+            tracer.visit_kind(method.signature.into(), EdgeKind::Method);
+        }
+
+        if let Some((_kind, signature)) = self.destructor() {
+            tracer.visit_kind(signature.into(), EdgeKind::Destructor);
+        }
+
+        for ctor in self.constructors() {
+            tracer.visit_kind(ctor.into(), EdgeKind::Constructor);
+        }
+
+        // Base members and fields are not generated for opaque types (but all
+        // of the above things are) so stop here.
+        if item.is_opaque(context, &()) {
+            return;
+        }
+
+        for base in self.base_members() {
+            tracer.visit_kind(base.ty.into(), EdgeKind::BaseMember);
+        }
+
+        self.fields.trace(context, tracer, &());
+    }
+}
diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs
new file mode 100644
index 00000000..12373952
--- /dev/null
+++ b/bindgen/ir/context.rs
@@ -0,0 +1,2855 @@
+//! Common context that is passed around during parsing and codegen.
+
+use super::super::time::Timer;
+use super::analysis::{
+    analyze, as_cannot_derive_set, CannotDerive, DeriveTrait,
+    HasDestructorAnalysis, HasFloat, HasTypeParameterInArray,
+    HasVtableAnalysis, HasVtableResult, SizednessAnalysis, SizednessResult,
+    UsedTemplateParameters,
+};
+use super::derive::{
+    CanDerive, CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
+    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
+};
+use super::function::Function;
+use super::int::IntKind;
+use super::item::{IsOpaque, Item, ItemAncestors, ItemSet};
+use super::item_kind::ItemKind;
+use super::module::{Module, ModuleKind};
+use super::template::{TemplateInstantiation, TemplateParameters};
+use super::traversal::{self, Edge, ItemTraversal};
+use super::ty::{FloatKind, Type, TypeKind};
+use crate::callbacks::ParseCallbacks;
+use crate::clang::{self, Cursor};
+use crate::parse::ClangItemParser;
+use crate::BindgenOptions;
+use crate::{Entry, HashMap, HashSet};
+use cexpr;
+use clang_sys;
+use proc_macro2::{Ident, Span};
+use std::borrow::Cow;
+use std::cell::{Cell, RefCell};
+use std::collections::{BTreeSet, HashMap as StdHashMap};
+use std::iter::IntoIterator;
+use std::mem;
+
+/// An identifier for some kind of IR item.
+#[derive(Debug, Copy, Clone, Eq, PartialOrd, Ord, Hash)]
+pub struct ItemId(usize);
+
+macro_rules! item_id_newtype {
+    (
+        $( #[$attr:meta] )*
+        pub struct $name:ident(ItemId)
+        where
+            $( #[$checked_attr:meta] )*
+            checked = $checked:ident with $check_method:ident,
+            $( #[$expected_attr:meta] )*
+            expected = $expected:ident,
+            $( #[$unchecked_attr:meta] )*
+            unchecked = $unchecked:ident;
+    ) => {
+        $( #[$attr] )*
+        #[derive(Debug, Copy, Clone, Eq, PartialOrd, Ord, Hash)]
+        pub struct $name(ItemId);
+
+        impl $name {
+            /// Create an `ItemResolver` from this id.
+            pub fn into_resolver(self) -> ItemResolver {
+                let id: ItemId = self.into();
+                id.into()
+            }
+        }
+
+        impl<T> ::std::cmp::PartialEq<T> for $name
+        where
+            T: Copy + Into<ItemId>
+        {
+            fn eq(&self, rhs: &T) -> bool {
+                let rhs: ItemId = (*rhs).into();
+                self.0 == rhs
+            }
+        }
+
+        impl From<$name> for ItemId {
+            fn from(id: $name) -> ItemId {
+                id.0
+            }
+        }
+
+        impl<'a> From<&'a $name> for ItemId {
+            fn from(id: &'a $name) -> ItemId {
+                id.0
+            }
+        }
+
+        impl ItemId {
+            $( #[$checked_attr] )*
+            pub fn $checked(&self, ctx: &BindgenContext) -> Option<$name> {
+                if ctx.resolve_item(*self).kind().$check_method() {
+                    Some($name(*self))
+                } else {
+                    None
+                }
+            }
+
+            $( #[$expected_attr] )*
+            pub fn $expected(&self, ctx: &BindgenContext) -> $name {
+                self.$checked(ctx)
+                    .expect(concat!(
+                        stringify!($expected),
+                        " called with ItemId that points to the wrong ItemKind"
+                    ))
+            }
+
+            $( #[$unchecked_attr] )*
+            pub fn $unchecked(&self) -> $name {
+                $name(*self)
+            }
+        }
+    }
+}
+
+item_id_newtype! {
+    /// An identifier for an `Item` whose `ItemKind` is known to be
+    /// `ItemKind::Type`.
+    pub struct TypeId(ItemId)
+    where
+        /// Convert this `ItemId` into a `TypeId` if its associated item is a type,
+        /// otherwise return `None`.
+        checked = as_type_id with is_type,
+
+        /// Convert this `ItemId` into a `TypeId`.
+        ///
+        /// If this `ItemId` does not point to a type, then panic.
+        expected = expect_type_id,
+
+        /// Convert this `ItemId` into a `TypeId` without actually checking whether
+        /// this id actually points to a `Type`.
+        unchecked = as_type_id_unchecked;
+}
+
+item_id_newtype! {
+    /// An identifier for an `Item` whose `ItemKind` is known to be
+    /// `ItemKind::Module`.
+    pub struct ModuleId(ItemId)
+    where
+        /// Convert this `ItemId` into a `ModuleId` if its associated item is a
+        /// module, otherwise return `None`.
+        checked = as_module_id with is_module,
+
+        /// Convert this `ItemId` into a `ModuleId`.
+        ///
+        /// If this `ItemId` does not point to a module, then panic.
+        expected = expect_module_id,
+
+        /// Convert this `ItemId` into a `ModuleId` without actually checking
+        /// whether this id actually points to a `Module`.
+        unchecked = as_module_id_unchecked;
+}
+
+item_id_newtype! {
+    /// An identifier for an `Item` whose `ItemKind` is known to be
+    /// `ItemKind::Var`.
+    pub struct VarId(ItemId)
+    where
+        /// Convert this `ItemId` into a `VarId` if its associated item is a var,
+        /// otherwise return `None`.
+        checked = as_var_id with is_var,
+
+        /// Convert this `ItemId` into a `VarId`.
+        ///
+        /// If this `ItemId` does not point to a var, then panic.
+        expected = expect_var_id,
+
+        /// Convert this `ItemId` into a `VarId` without actually checking whether
+        /// this id actually points to a `Var`.
+        unchecked = as_var_id_unchecked;
+}
+
+item_id_newtype! {
+    /// An identifier for an `Item` whose `ItemKind` is known to be
+    /// `ItemKind::Function`.
+    pub struct FunctionId(ItemId)
+    where
+        /// Convert this `ItemId` into a `FunctionId` if its associated item is a function,
+        /// otherwise return `None`.
+        checked = as_function_id with is_function,
+
+        /// Convert this `ItemId` into a `FunctionId`.
+        ///
+        /// If this `ItemId` does not point to a function, then panic.
+        expected = expect_function_id,
+
+        /// Convert this `ItemId` into a `FunctionId` without actually checking whether
+        /// this id actually points to a `Function`.
+        unchecked = as_function_id_unchecked;
+}
+
+impl From<ItemId> for usize {
+    fn from(id: ItemId) -> usize {
+        id.0
+    }
+}
+
+impl ItemId {
+    /// Get a numeric representation of this id.
+    pub fn as_usize(&self) -> usize {
+        (*self).into()
+    }
+}
+
+impl<T> ::std::cmp::PartialEq<T> for ItemId
+where
+    T: Copy + Into<ItemId>,
+{
+    fn eq(&self, rhs: &T) -> bool {
+        let rhs: ItemId = (*rhs).into();
+        self.0 == rhs.0
+    }
+}
+
+impl<T> CanDeriveDebug for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_debug && ctx.lookup_can_derive_debug(*self)
+    }
+}
+
+impl<T> CanDeriveDefault for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_default(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_default && ctx.lookup_can_derive_default(*self)
+    }
+}
+
+impl<T> CanDeriveCopy for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_copy && ctx.lookup_can_derive_copy(*self)
+    }
+}
+
+impl<T> CanDeriveHash for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_hash && ctx.lookup_can_derive_hash(*self)
+    }
+}
+
+impl<T> CanDerivePartialOrd for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_partialord &&
+            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
+                CanDerive::Yes
+    }
+}
+
+impl<T> CanDerivePartialEq for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_partialeq &&
+            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
+                CanDerive::Yes
+    }
+}
+
+impl<T> CanDeriveEq for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_eq &&
+            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
+                CanDerive::Yes &&
+            !ctx.lookup_has_float(*self)
+    }
+}
+
+impl<T> CanDeriveOrd for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool {
+        ctx.options().derive_ord &&
+            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
+                CanDerive::Yes &&
+            !ctx.lookup_has_float(*self)
+    }
+}
+
+/// A key used to index a resolved type, so we only process it once.
+///
+/// This is almost always a USR string (an unique identifier generated by
+/// clang), but it can also be the canonical declaration if the type is unnamed,
+/// in which case clang may generate the same USR for multiple nested unnamed
+/// types.
+#[derive(Eq, PartialEq, Hash, Debug)]
+enum TypeKey {
+    Usr(String),
+    Declaration(Cursor),
+}
+
+/// A context used during parsing and generation of structs.
+#[derive(Debug)]
+pub struct BindgenContext {
+    /// The map of all the items parsed so far, keyed off ItemId.
+    items: Vec<Option<Item>>,
+
+    /// Clang USR to type map. This is needed to be able to associate types with
+    /// item ids during parsing.
+    types: HashMap<TypeKey, TypeId>,
+
+    /// Maps from a cursor to the item id of the named template type parameter
+    /// for that cursor.
+    type_params: HashMap<clang::Cursor, TypeId>,
+
+    /// A cursor to module map. Similar reason than above.
+    modules: HashMap<Cursor, ModuleId>,
+
+    /// The root module, this is guaranteed to be an item of kind Module.
+    root_module: ModuleId,
+
+    /// Current module being traversed.
+    current_module: ModuleId,
+
+    /// A HashMap keyed on a type definition, and whose value is the parent id
+    /// of the declaration.
+    ///
+    /// This is used to handle the cases where the semantic and the lexical
+    /// parents of the cursor differ, like when a nested class is defined
+    /// outside of the parent class.
+    semantic_parents: HashMap<clang::Cursor, ItemId>,
+
+    /// A stack with the current type declarations and types we're parsing. This
+    /// is needed to avoid infinite recursion when parsing a type like:
+    ///
+    /// struct c { struct c* next; };
+    ///
+    /// This means effectively, that a type has a potential ID before knowing if
+    /// it's a correct type. But that's not important in practice.
+    ///
+    /// We could also use the `types` HashMap, but my intention with it is that
+    /// only valid types and declarations end up there, and this could
+    /// potentially break that assumption.
+    currently_parsed_types: Vec<PartialType>,
+
+    /// A map with all the already parsed macro names. This is done to avoid
+    /// hard errors while parsing duplicated macros, as well to allow macro
+    /// expression parsing.
+    ///
+    /// This needs to be an std::HashMap because the cexpr API requires it.
+    parsed_macros: StdHashMap<Vec<u8>, cexpr::expr::EvalResult>,
+
+    /// A set of all the included filenames.
+    deps: BTreeSet<String>,
+
+    /// The active replacements collected from replaces="xxx" annotations.
+    replacements: HashMap<Vec<String>, ItemId>,
+
+    collected_typerefs: bool,
+
+    in_codegen: bool,
+
+    /// The translation unit for parsing.
+    translation_unit: clang::TranslationUnit,
+
+    /// Target information that can be useful for some stuff.
+    target_info: clang::TargetInfo,
+
+    /// The options given by the user via cli or other medium.
+    options: BindgenOptions,
+
+    /// Whether a bindgen complex was generated
+    generated_bindgen_complex: Cell<bool>,
+
+    /// The set of `ItemId`s that are allowlisted. This the very first thing
+    /// computed after parsing our IR, and before running any of our analyses.
+    allowlisted: Option<ItemSet>,
+
+    /// Cache for calls to `ParseCallbacks::blocklisted_type_implements_trait`
+    blocklisted_types_implement_traits:
+        RefCell<HashMap<DeriveTrait, HashMap<ItemId, CanDerive>>>,
+
+    /// The set of `ItemId`s that are allowlisted for code generation _and_ that
+    /// we should generate accounting for the codegen options.
+    ///
+    /// It's computed right after computing the allowlisted items.
+    codegen_items: Option<ItemSet>,
+
+    /// Map from an item's id to the set of template parameter items that it
+    /// uses. See `ir::named` for more details. Always `Some` during the codegen
+    /// phase.
+    used_template_parameters: Option<HashMap<ItemId, ItemSet>>,
+
+    /// The set of `TypeKind::Comp` items found during parsing that need their
+    /// bitfield allocation units computed. Drained in `compute_bitfield_units`.
+    need_bitfield_allocation: Vec<ItemId>,
+
+    /// The set of (`ItemId`s of) types that can't derive debug.
+    ///
+    /// This is populated when we enter codegen by `compute_cannot_derive_debug`
+    /// and is always `None` before that and `Some` after.
+    cannot_derive_debug: Option<HashSet<ItemId>>,
+
+    /// The set of (`ItemId`s of) types that can't derive default.
+    ///
+    /// This is populated when we enter codegen by `compute_cannot_derive_default`
+    /// and is always `None` before that and `Some` after.
+    cannot_derive_default: Option<HashSet<ItemId>>,
+
+    /// The set of (`ItemId`s of) types that can't derive copy.
+    ///
+    /// This is populated when we enter codegen by `compute_cannot_derive_copy`
+    /// and is always `None` before that and `Some` after.
+    cannot_derive_copy: Option<HashSet<ItemId>>,
+
+    /// The set of (`ItemId`s of) types that can't derive hash.
+    ///
+    /// This is populated when we enter codegen by `compute_can_derive_hash`
+    /// and is always `None` before that and `Some` after.
+    cannot_derive_hash: Option<HashSet<ItemId>>,
+
+    /// The map why specified `ItemId`s of) types that can't derive hash.
+    ///
+    /// This is populated when we enter codegen by
+    /// `compute_cannot_derive_partialord_partialeq_or_eq` and is always `None`
+    /// before that and `Some` after.
+    cannot_derive_partialeq_or_partialord: Option<HashMap<ItemId, CanDerive>>,
+
+    /// The sizedness of types.
+    ///
+    /// This is populated by `compute_sizedness` and is always `None` before
+    /// that function is invoked and `Some` afterwards.
+    sizedness: Option<HashMap<TypeId, SizednessResult>>,
+
+    /// The set of (`ItemId's of`) types that has vtable.
+    ///
+    /// Populated when we enter codegen by `compute_has_vtable`; always `None`
+    /// before that and `Some` after.
+    have_vtable: Option<HashMap<ItemId, HasVtableResult>>,
+
+    /// The set of (`ItemId's of`) types that has destructor.
+    ///
+    /// Populated when we enter codegen by `compute_has_destructor`; always `None`
+    /// before that and `Some` after.
+    have_destructor: Option<HashSet<ItemId>>,
+
+    /// The set of (`ItemId's of`) types that has array.
+    ///
+    /// Populated when we enter codegen by `compute_has_type_param_in_array`; always `None`
+    /// before that and `Some` after.
+    has_type_param_in_array: Option<HashSet<ItemId>>,
+
+    /// The set of (`ItemId's of`) types that has float.
+    ///
+    /// Populated when we enter codegen by `compute_has_float`; always `None`
+    /// before that and `Some` after.
+    has_float: Option<HashSet<ItemId>>,
+
+    /// The set of warnings raised during binding generation.
+    warnings: Vec<String>,
+}
+
+/// A traversal of allowlisted items.
+struct AllowlistedItemsTraversal<'ctx> {
+    ctx: &'ctx BindgenContext,
+    traversal: ItemTraversal<'ctx, ItemSet, Vec<ItemId>>,
+}
+
+impl<'ctx> Iterator for AllowlistedItemsTraversal<'ctx> {
+    type Item = ItemId;
+
+    fn next(&mut self) -> Option<ItemId> {
+        loop {
+            let id = self.traversal.next()?;
+
+            if self.ctx.resolve_item(id).is_blocklisted(self.ctx) {
+                continue;
+            }
+
+            return Some(id);
+        }
+    }
+}
+
+impl<'ctx> AllowlistedItemsTraversal<'ctx> {
+    /// Construct a new allowlisted items traversal.
+    pub fn new<R>(
+        ctx: &'ctx BindgenContext,
+        roots: R,
+        predicate: for<'a> fn(&'a BindgenContext, Edge) -> bool,
+    ) -> Self
+    where
+        R: IntoIterator<Item = ItemId>,
+    {
+        AllowlistedItemsTraversal {
+            ctx,
+            traversal: ItemTraversal::new(ctx, roots, predicate),
+        }
+    }
+}
+
+impl BindgenContext {
+    /// Construct the context for the given `options`.
+    pub(crate) fn new(
+        options: BindgenOptions,
+        input_unsaved_files: &[clang::UnsavedFile],
+    ) -> Self {
+        // TODO(emilio): Use the CXTargetInfo here when available.
+        //
+        // see: https://reviews.llvm.org/D32389
+        let index = clang::Index::new(false, true);
+
+        let parse_options =
+            clang_sys::CXTranslationUnit_DetailedPreprocessingRecord;
+
+        let translation_unit = {
+            let _t =
+                Timer::new("translation_unit").with_output(options.time_phases);
+
+            clang::TranslationUnit::parse(
+                &index,
+                "",
+                &options.clang_args,
+                input_unsaved_files,
+                parse_options,
+            ).expect("libclang error; possible causes include:
+- Invalid flag syntax
+- Unrecognized flags
+- Invalid flag arguments
+- File I/O errors
+- Host vs. target architecture mismatch
+If you encounter an error missing from this list, please file an issue or a PR!")
+        };
+
+        let target_info = clang::TargetInfo::new(&translation_unit);
+        let root_module = Self::build_root_module(ItemId(0));
+        let root_module_id = root_module.id().as_module_id_unchecked();
+
+        // depfiles need to include the explicitly listed headers too
+        let mut deps = BTreeSet::default();
+        if let Some(filename) = &options.input_header {
+            deps.insert(filename.clone());
+        }
+        deps.extend(options.extra_input_headers.iter().cloned());
+
+        BindgenContext {
+            items: vec![Some(root_module)],
+            deps,
+            types: Default::default(),
+            type_params: Default::default(),
+            modules: Default::default(),
+            root_module: root_module_id,
+            current_module: root_module_id,
+            semantic_parents: Default::default(),
+            currently_parsed_types: vec![],
+            parsed_macros: Default::default(),
+            replacements: Default::default(),
+            collected_typerefs: false,
+            in_codegen: false,
+            translation_unit,
+            target_info,
+            options,
+            generated_bindgen_complex: Cell::new(false),
+            allowlisted: None,
+            blocklisted_types_implement_traits: Default::default(),
+            codegen_items: None,
+            used_template_parameters: None,
+            need_bitfield_allocation: Default::default(),
+            cannot_derive_debug: None,
+            cannot_derive_default: None,
+            cannot_derive_copy: None,
+            cannot_derive_hash: None,
+            cannot_derive_partialeq_or_partialord: None,
+            sizedness: None,
+            have_vtable: None,
+            have_destructor: None,
+            has_type_param_in_array: None,
+            has_float: None,
+            warnings: Vec::new(),
+        }
+    }
+
+    /// Returns `true` if the target architecture is wasm32
+    pub fn is_target_wasm32(&self) -> bool {
+        self.target_info.triple.starts_with("wasm32-")
+    }
+
+    /// Creates a timer for the current bindgen phase. If time_phases is `true`,
+    /// the timer will print to stderr when it is dropped, otherwise it will do
+    /// nothing.
+    pub fn timer<'a>(&self, name: &'a str) -> Timer<'a> {
+        Timer::new(name).with_output(self.options.time_phases)
+    }
+
+    /// Returns the pointer width to use for the target for the current
+    /// translation.
+    pub fn target_pointer_size(&self) -> usize {
+        self.target_info.pointer_width / 8
+    }
+
+    /// Get the stack of partially parsed types that we are in the middle of
+    /// parsing.
+    pub fn currently_parsed_types(&self) -> &[PartialType] {
+        &self.currently_parsed_types[..]
+    }
+
+    /// Begin parsing the given partial type, and push it onto the
+    /// `currently_parsed_types` stack so that we won't infinite recurse if we
+    /// run into a reference to it while parsing it.
+    pub fn begin_parsing(&mut self, partial_ty: PartialType) {
+        self.currently_parsed_types.push(partial_ty);
+    }
+
+    /// Finish parsing the current partial type, pop it off the
+    /// `currently_parsed_types` stack, and return it.
+    pub fn finish_parsing(&mut self) -> PartialType {
+        self.currently_parsed_types.pop().expect(
+            "should have been parsing a type, if we finished parsing a type",
+        )
+    }
+
+    /// Get the user-provided callbacks by reference, if any.
+    pub fn parse_callbacks(&self) -> Option<&dyn ParseCallbacks> {
+        self.options().parse_callbacks.as_deref()
+    }
+
+    /// Add another path to the set of included files.
+    pub fn include_file(&mut self, filename: String) {
+        if let Some(cbs) = self.parse_callbacks() {
+            cbs.include_file(&filename);
+        }
+        self.deps.insert(filename);
+    }
+
+    /// Get any included files.
+    pub fn deps(&self) -> &BTreeSet<String> {
+        &self.deps
+    }
+
+    /// Define a new item.
+    ///
+    /// This inserts it into the internal items set, and its type into the
+    /// internal types set.
+    pub fn add_item(
+        &mut self,
+        item: Item,
+        declaration: Option<Cursor>,
+        location: Option<Cursor>,
+    ) {
+        debug!(
+            "BindgenContext::add_item({:?}, declaration: {:?}, loc: {:?}",
+            item, declaration, location
+        );
+        debug_assert!(
+            declaration.is_some() ||
+                !item.kind().is_type() ||
+                item.kind().expect_type().is_builtin_or_type_param() ||
+                item.kind().expect_type().is_opaque(self, &item) ||
+                item.kind().expect_type().is_unresolved_ref(),
+            "Adding a type without declaration?"
+        );
+
+        let id = item.id();
+        let is_type = item.kind().is_type();
+        let is_unnamed = is_type && item.expect_type().name().is_none();
+        let is_template_instantiation =
+            is_type && item.expect_type().is_template_instantiation();
+
+        if item.id() != self.root_module {
+            self.add_item_to_module(&item);
+        }
+
+        if is_type && item.expect_type().is_comp() {
+            self.need_bitfield_allocation.push(id);
+        }
+
+        let old_item = mem::replace(&mut self.items[id.0], Some(item));
+        assert!(
+            old_item.is_none(),
+            "should not have already associated an item with the given id"
+        );
+
+        // Unnamed items can have an USR, but they can't be referenced from
+        // other sites explicitly and the USR can match if the unnamed items are
+        // nested, so don't bother tracking them.
+        if !is_type || is_template_instantiation {
+            return;
+        }
+        if let Some(mut declaration) = declaration {
+            if !declaration.is_valid() {
+                if let Some(location) = location {
+                    if location.is_template_like() {
+                        declaration = location;
+                    }
+                }
+            }
+            declaration = declaration.canonical();
+            if !declaration.is_valid() {
+                // This could happen, for example, with types like `int*` or
+                // similar.
+                //
+                // Fortunately, we don't care about those types being
+                // duplicated, so we can just ignore them.
+                debug!(
+                    "Invalid declaration {:?} found for type {:?}",
+                    declaration,
+                    self.resolve_item_fallible(id)
+                        .unwrap()
+                        .kind()
+                        .expect_type()
+                );
+                return;
+            }
+
+            let key = if is_unnamed {
+                TypeKey::Declaration(declaration)
+            } else if let Some(usr) = declaration.usr() {
+                TypeKey::Usr(usr)
+            } else {
+                warn!(
+                    "Valid declaration with no USR: {:?}, {:?}",
+                    declaration, location
+                );
+                TypeKey::Declaration(declaration)
+            };
+
+            let old = self.types.insert(key, id.as_type_id_unchecked());
+            debug_assert_eq!(old, None);
+        }
+    }
+
+    /// Ensure that every item (other than the root module) is in a module's
+    /// children list. This is to make sure that every allowlisted item get's
+    /// codegen'd, even if its parent is not allowlisted. See issue #769 for
+    /// details.
+    fn add_item_to_module(&mut self, item: &Item) {
+        assert!(item.id() != self.root_module);
+        assert!(self.resolve_item_fallible(item.id()).is_none());
+
+        if let Some(ref mut parent) = self.items[item.parent_id().0] {
+            if let Some(module) = parent.as_module_mut() {
+                debug!(
+                    "add_item_to_module: adding {:?} as child of parent module {:?}",
+                    item.id(),
+                    item.parent_id()
+                );
+
+                module.children_mut().insert(item.id());
+                return;
+            }
+        }
+
+        debug!(
+            "add_item_to_module: adding {:?} as child of current module {:?}",
+            item.id(),
+            self.current_module
+        );
+
+        self.items[(self.current_module.0).0]
+            .as_mut()
+            .expect("Should always have an item for self.current_module")
+            .as_module_mut()
+            .expect("self.current_module should always be a module")
+            .children_mut()
+            .insert(item.id());
+    }
+
+    /// Add a new named template type parameter to this context's item set.
+    pub fn add_type_param(&mut self, item: Item, definition: clang::Cursor) {
+        debug!(
+            "BindgenContext::add_type_param: item = {:?}; definition = {:?}",
+            item, definition
+        );
+
+        assert!(
+            item.expect_type().is_type_param(),
+            "Should directly be a named type, not a resolved reference or anything"
+        );
+        assert_eq!(
+            definition.kind(),
+            clang_sys::CXCursor_TemplateTypeParameter
+        );
+
+        self.add_item_to_module(&item);
+
+        let id = item.id();
+        let old_item = mem::replace(&mut self.items[id.0], Some(item));
+        assert!(
+            old_item.is_none(),
+            "should not have already associated an item with the given id"
+        );
+
+        let old_named_ty = self
+            .type_params
+            .insert(definition, id.as_type_id_unchecked());
+        assert!(
+            old_named_ty.is_none(),
+            "should not have already associated a named type with this id"
+        );
+    }
+
+    /// Get the named type defined at the given cursor location, if we've
+    /// already added one.
+    pub fn get_type_param(&self, definition: &clang::Cursor) -> Option<TypeId> {
+        assert_eq!(
+            definition.kind(),
+            clang_sys::CXCursor_TemplateTypeParameter
+        );
+        self.type_params.get(definition).cloned()
+    }
+
+    // TODO: Move all this syntax crap to other part of the code.
+
+    /// Mangles a name so it doesn't conflict with any keyword.
+    #[rustfmt::skip]
+    pub fn rust_mangle<'a>(&self, name: &'a str) -> Cow<'a, str> {
+        if name.contains('@') ||
+            name.contains('?') ||
+            name.contains('$') ||
+            matches!(
+                name,
+                "abstract" | "alignof" | "as" | "async" | "await" | "become" |
+                    "box" | "break" | "const" | "continue" | "crate" | "do" |
+                    "dyn" | "else" | "enum" | "extern" | "false" | "final" |
+                    "fn" | "for" | "if" | "impl" | "in" | "let" | "loop" |
+                    "macro" | "match" | "mod" | "move" | "mut" | "offsetof" |
+                    "override" | "priv" | "proc" | "pub" | "pure" | "ref" |
+                    "return" | "Self" | "self" | "sizeof" | "static" |
+                    "struct" | "super" | "trait" | "true" | "try" | "type" | "typeof" |
+                    "unsafe" | "unsized" | "use" | "virtual" | "where" |
+                    "while" | "yield" | "str" | "bool" | "f32" | "f64" |
+                    "usize" | "isize" | "u128" | "i128" | "u64" | "i64" |
+                    "u32" | "i32" | "u16" | "i16" | "u8" | "i8" | "_"
+            )
+        {
+            let mut s = name.to_owned();
+            s = s.replace('@', "_");
+            s = s.replace('?', "_");
+            s = s.replace('$', "_");
+            s.push('_');
+            return Cow::Owned(s);
+        }
+        Cow::Borrowed(name)
+    }
+
+    /// Returns a mangled name as a rust identifier.
+    pub fn rust_ident<S>(&self, name: S) -> Ident
+    where
+        S: AsRef<str>,
+    {
+        self.rust_ident_raw(self.rust_mangle(name.as_ref()))
+    }
+
+    /// Returns a mangled name as a rust identifier.
+    pub fn rust_ident_raw<T>(&self, name: T) -> Ident
+    where
+        T: AsRef<str>,
+    {
+        Ident::new(name.as_ref(), Span::call_site())
+    }
+
+    /// Iterate over all items that have been defined.
+    pub fn items(&self) -> impl Iterator<Item = (ItemId, &Item)> {
+        self.items.iter().enumerate().filter_map(|(index, item)| {
+            let item = item.as_ref()?;
+            Some((ItemId(index), item))
+        })
+    }
+
+    /// Have we collected all unresolved type references yet?
+    pub fn collected_typerefs(&self) -> bool {
+        self.collected_typerefs
+    }
+
+    /// Gather all the unresolved type references.
+    fn collect_typerefs(
+        &mut self,
+    ) -> Vec<(ItemId, clang::Type, clang::Cursor, Option<ItemId>)> {
+        debug_assert!(!self.collected_typerefs);
+        self.collected_typerefs = true;
+        let mut typerefs = vec![];
+
+        for (id, item) in self.items() {
+            let kind = item.kind();
+            let ty = match kind.as_type() {
+                Some(ty) => ty,
+                None => continue,
+            };
+
+            if let TypeKind::UnresolvedTypeRef(ref ty, loc, parent_id) =
+                *ty.kind()
+            {
+                typerefs.push((id, *ty, loc, parent_id));
+            };
+        }
+        typerefs
+    }
+
+    /// Collect all of our unresolved type references and resolve them.
+    fn resolve_typerefs(&mut self) {
+        let _t = self.timer("resolve_typerefs");
+
+        let typerefs = self.collect_typerefs();
+
+        for (id, ty, loc, parent_id) in typerefs {
+            let _resolved =
+                {
+                    let resolved = Item::from_ty(&ty, loc, parent_id, self)
+                    .unwrap_or_else(|_| {
+                        warn!("Could not resolve type reference, falling back \
+                               to opaque blob");
+                        Item::new_opaque_type(self.next_item_id(), &ty, self)
+                    });
+
+                    let item = self.items[id.0].as_mut().unwrap();
+                    *item.kind_mut().as_type_mut().unwrap().kind_mut() =
+                        TypeKind::ResolvedTypeRef(resolved);
+                    resolved
+                };
+
+            // Something in the STL is trolling me. I don't need this assertion
+            // right now, but worth investigating properly once this lands.
+            //
+            // debug_assert!(self.items.get(&resolved).is_some(), "How?");
+            //
+            // if let Some(parent_id) = parent_id {
+            //     assert_eq!(self.items[&resolved].parent_id(), parent_id);
+            // }
+        }
+    }
+
+    /// Temporarily loan `Item` with the given `ItemId`. This provides means to
+    /// mutably borrow `Item` while having a reference to `BindgenContext`.
+    ///
+    /// `Item` with the given `ItemId` is removed from the context, given
+    /// closure is executed and then `Item` is placed back.
+    ///
+    /// # Panics
+    ///
+    /// Panics if attempt to resolve given `ItemId` inside the given
+    /// closure is made.
+    fn with_loaned_item<F, T>(&mut self, id: ItemId, f: F) -> T
+    where
+        F: (FnOnce(&BindgenContext, &mut Item) -> T),
+    {
+        let mut item = self.items[id.0].take().unwrap();
+
+        let result = f(self, &mut item);
+
+        let existing = mem::replace(&mut self.items[id.0], Some(item));
+        assert!(existing.is_none());
+
+        result
+    }
+
+    /// Compute the bitfield allocation units for all `TypeKind::Comp` items we
+    /// parsed.
+    fn compute_bitfield_units(&mut self) {
+        let _t = self.timer("compute_bitfield_units");
+
+        assert!(self.collected_typerefs());
+
+        let need_bitfield_allocation =
+            mem::take(&mut self.need_bitfield_allocation);
+        for id in need_bitfield_allocation {
+            self.with_loaned_item(id, |ctx, item| {
+                let ty = item.kind_mut().as_type_mut().unwrap();
+                let layout = ty.layout(ctx);
+                ty.as_comp_mut()
+                    .unwrap()
+                    .compute_bitfield_units(ctx, layout.as_ref());
+            });
+        }
+    }
+
+    /// Assign a new generated name for each anonymous field.
+    fn deanonymize_fields(&mut self) {
+        let _t = self.timer("deanonymize_fields");
+
+        let comp_item_ids: Vec<ItemId> = self
+            .items()
+            .filter_map(|(id, item)| {
+                if item.kind().as_type()?.is_comp() {
+                    return Some(id);
+                }
+                None
+            })
+            .collect();
+
+        for id in comp_item_ids {
+            self.with_loaned_item(id, |ctx, item| {
+                item.kind_mut()
+                    .as_type_mut()
+                    .unwrap()
+                    .as_comp_mut()
+                    .unwrap()
+                    .deanonymize_fields(ctx);
+            });
+        }
+    }
+
+    /// Iterate over all items and replace any item that has been named in a
+    /// `replaces="SomeType"` annotation with the replacement type.
+    fn process_replacements(&mut self) {
+        let _t = self.timer("process_replacements");
+        if self.replacements.is_empty() {
+            debug!("No replacements to process");
+            return;
+        }
+
+        // FIXME: This is linear, but the replaces="xxx" annotation was already
+        // there, and for better or worse it's useful, sigh...
+        //
+        // We leverage the ResolvedTypeRef thing, though, which is cool :P.
+
+        let mut replacements = vec![];
+
+        for (id, item) in self.items() {
+            if item.annotations().use_instead_of().is_some() {
+                continue;
+            }
+
+            // Calls to `canonical_name` are expensive, so eagerly filter out
+            // items that cannot be replaced.
+            let ty = match item.kind().as_type() {
+                Some(ty) => ty,
+                None => continue,
+            };
+
+            match *ty.kind() {
+                TypeKind::Comp(..) |
+                TypeKind::TemplateAlias(..) |
+                TypeKind::Enum(..) |
+                TypeKind::Alias(..) => {}
+                _ => continue,
+            }
+
+            let path = item.path_for_allowlisting(self);
+            let replacement = self.replacements.get(&path[1..]);
+
+            if let Some(replacement) = replacement {
+                if *replacement != id {
+                    // We set this just after parsing the annotation. It's
+                    // very unlikely, but this can happen.
+                    if self.resolve_item_fallible(*replacement).is_some() {
+                        replacements.push((
+                            id.expect_type_id(self),
+                            replacement.expect_type_id(self),
+                        ));
+                    }
+                }
+            }
+        }
+
+        for (id, replacement_id) in replacements {
+            debug!("Replacing {:?} with {:?}", id, replacement_id);
+            let new_parent = {
+                let item_id: ItemId = id.into();
+                let item = self.items[item_id.0].as_mut().unwrap();
+                *item.kind_mut().as_type_mut().unwrap().kind_mut() =
+                    TypeKind::ResolvedTypeRef(replacement_id);
+                item.parent_id()
+            };
+
+            // Relocate the replacement item from where it was declared, to
+            // where the thing it is replacing was declared.
+            //
+            // First, we'll make sure that its parent id is correct.
+
+            let old_parent = self.resolve_item(replacement_id).parent_id();
+            if new_parent == old_parent {
+                // Same parent and therefore also same containing
+                // module. Nothing to do here.
+                continue;
+            }
+
+            let replacement_item_id: ItemId = replacement_id.into();
+            self.items[replacement_item_id.0]
+                .as_mut()
+                .unwrap()
+                .set_parent_for_replacement(new_parent);
+
+            // Second, make sure that it is in the correct module's children
+            // set.
+
+            let old_module = {
+                let immut_self = &*self;
+                old_parent
+                    .ancestors(immut_self)
+                    .chain(Some(immut_self.root_module.into()))
+                    .find(|id| {
+                        let item = immut_self.resolve_item(*id);
+                        item.as_module().map_or(false, |m| {
+                            m.children().contains(&replacement_id.into())
+                        })
+                    })
+            };
+            let old_module = old_module
+                .expect("Every replacement item should be in a module");
+
+            let new_module = {
+                let immut_self = &*self;
+                new_parent
+                    .ancestors(immut_self)
+                    .find(|id| immut_self.resolve_item(*id).is_module())
+            };
+            let new_module =
+                new_module.unwrap_or_else(|| self.root_module.into());
+
+            if new_module == old_module {
+                // Already in the correct module.
+                continue;
+            }
+
+            self.items[old_module.0]
+                .as_mut()
+                .unwrap()
+                .as_module_mut()
+                .unwrap()
+                .children_mut()
+                .remove(&replacement_id.into());
+
+            self.items[new_module.0]
+                .as_mut()
+                .unwrap()
+                .as_module_mut()
+                .unwrap()
+                .children_mut()
+                .insert(replacement_id.into());
+        }
+    }
+
+    /// Enter the code generation phase, invoke the given callback `cb`, and
+    /// leave the code generation phase.
+    pub(crate) fn gen<F, Out>(
+        mut self,
+        cb: F,
+    ) -> (Out, BindgenOptions, Vec<String>)
+    where
+        F: FnOnce(&Self) -> Out,
+    {
+        self.in_codegen = true;
+
+        self.resolve_typerefs();
+        self.compute_bitfield_units();
+        self.process_replacements();
+
+        self.deanonymize_fields();
+
+        self.assert_no_dangling_references();
+
+        // Compute the allowlisted set after processing replacements and
+        // resolving type refs, as those are the final mutations of the IR
+        // graph, and their completion means that the IR graph is now frozen.
+        self.compute_allowlisted_and_codegen_items();
+
+        // Make sure to do this after processing replacements, since that messes
+        // with the parentage and module children, and we want to assert that it
+        // messes with them correctly.
+        self.assert_every_item_in_a_module();
+
+        self.compute_has_vtable();
+        self.compute_sizedness();
+        self.compute_has_destructor();
+        self.find_used_template_parameters();
+        self.compute_cannot_derive_debug();
+        self.compute_cannot_derive_default();
+        self.compute_cannot_derive_copy();
+        self.compute_has_type_param_in_array();
+        self.compute_has_float();
+        self.compute_cannot_derive_hash();
+        self.compute_cannot_derive_partialord_partialeq_or_eq();
+
+        let ret = cb(&self);
+        (ret, self.options, self.warnings)
+    }
+
+    /// When the `testing_only_extra_assertions` feature is enabled, this
+    /// function walks the IR graph and asserts that we do not have any edges
+    /// referencing an ItemId for which we do not have an associated IR item.
+    fn assert_no_dangling_references(&self) {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            for _ in self.assert_no_dangling_item_traversal() {
+                // The iterator's next method does the asserting for us.
+            }
+        }
+    }
+
+    fn assert_no_dangling_item_traversal(
+        &self,
+    ) -> traversal::AssertNoDanglingItemsTraversal {
+        assert!(self.in_codegen_phase());
+        assert!(self.current_module == self.root_module);
+
+        let roots = self.items().map(|(id, _)| id);
+        traversal::AssertNoDanglingItemsTraversal::new(
+            self,
+            roots,
+            traversal::all_edges,
+        )
+    }
+
+    /// When the `testing_only_extra_assertions` feature is enabled, walk over
+    /// every item and ensure that it is in the children set of one of its
+    /// module ancestors.
+    fn assert_every_item_in_a_module(&self) {
+        if cfg!(feature = "testing_only_extra_assertions") {
+            assert!(self.in_codegen_phase());
+            assert!(self.current_module == self.root_module);
+
+            for (id, _item) in self.items() {
+                if id == self.root_module {
+                    continue;
+                }
+
+                assert!(
+                    {
+                        let id = id
+                            .into_resolver()
+                            .through_type_refs()
+                            .through_type_aliases()
+                            .resolve(self)
+                            .id();
+                        id.ancestors(self)
+                            .chain(Some(self.root_module.into()))
+                            .any(|ancestor| {
+                                debug!(
+                                    "Checking if {:?} is a child of {:?}",
+                                    id, ancestor
+                                );
+                                self.resolve_item(ancestor)
+                                    .as_module()
+                                    .map_or(false, |m| {
+                                        m.children().contains(&id)
+                                    })
+                            })
+                    },
+                    "{:?} should be in some ancestor module's children set",
+                    id
+                );
+            }
+        }
+    }
+
+    /// Compute for every type whether it is sized or not, and whether it is
+    /// sized or not as a base class.
+    fn compute_sizedness(&mut self) {
+        let _t = self.timer("compute_sizedness");
+        assert!(self.sizedness.is_none());
+        self.sizedness = Some(analyze::<SizednessAnalysis>(self));
+    }
+
+    /// Look up whether the type with the given id is sized or not.
+    pub fn lookup_sizedness(&self, id: TypeId) -> SizednessResult {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute sizedness after we've entered codegen"
+        );
+
+        self.sizedness
+            .as_ref()
+            .unwrap()
+            .get(&id)
+            .cloned()
+            .unwrap_or(SizednessResult::ZeroSized)
+    }
+
+    /// Compute whether the type has vtable.
+    fn compute_has_vtable(&mut self) {
+        let _t = self.timer("compute_has_vtable");
+        assert!(self.have_vtable.is_none());
+        self.have_vtable = Some(analyze::<HasVtableAnalysis>(self));
+    }
+
+    /// Look up whether the item with `id` has vtable or not.
+    pub fn lookup_has_vtable(&self, id: TypeId) -> HasVtableResult {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute vtables when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` has a
+        // vtable or not.
+        self.have_vtable
+            .as_ref()
+            .unwrap()
+            .get(&id.into())
+            .cloned()
+            .unwrap_or(HasVtableResult::No)
+    }
+
+    /// Compute whether the type has a destructor.
+    fn compute_has_destructor(&mut self) {
+        let _t = self.timer("compute_has_destructor");
+        assert!(self.have_destructor.is_none());
+        self.have_destructor = Some(analyze::<HasDestructorAnalysis>(self));
+    }
+
+    /// Look up whether the item with `id` has a destructor.
+    pub fn lookup_has_destructor(&self, id: TypeId) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute destructors when we enter codegen"
+        );
+
+        self.have_destructor.as_ref().unwrap().contains(&id.into())
+    }
+
+    fn find_used_template_parameters(&mut self) {
+        let _t = self.timer("find_used_template_parameters");
+        if self.options.allowlist_recursively {
+            let used_params = analyze::<UsedTemplateParameters>(self);
+            self.used_template_parameters = Some(used_params);
+        } else {
+            // If you aren't recursively allowlisting, then we can't really make
+            // any sense of template parameter usage, and you're on your own.
+            let mut used_params = HashMap::default();
+            for &id in self.allowlisted_items() {
+                used_params.entry(id).or_insert_with(|| {
+                    id.self_template_params(self)
+                        .into_iter()
+                        .map(|p| p.into())
+                        .collect()
+                });
+            }
+            self.used_template_parameters = Some(used_params);
+        }
+    }
+
+    /// Return `true` if `item` uses the given `template_param`, `false`
+    /// otherwise.
+    ///
+    /// This method may only be called during the codegen phase, because the
+    /// template usage information is only computed as we enter the codegen
+    /// phase.
+    ///
+    /// If the item is blocklisted, then we say that it always uses the template
+    /// parameter. This is a little subtle. The template parameter usage
+    /// analysis only considers allowlisted items, and if any blocklisted item
+    /// shows up in the generated bindings, it is the user's responsibility to
+    /// manually provide a definition for them. To give them the most
+    /// flexibility when doing that, we assume that they use every template
+    /// parameter and always pass template arguments through in instantiations.
+    pub fn uses_template_parameter(
+        &self,
+        item: ItemId,
+        template_param: TypeId,
+    ) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute template parameter usage as we enter codegen"
+        );
+
+        if self.resolve_item(item).is_blocklisted(self) {
+            return true;
+        }
+
+        let template_param = template_param
+            .into_resolver()
+            .through_type_refs()
+            .through_type_aliases()
+            .resolve(self)
+            .id();
+
+        self.used_template_parameters
+            .as_ref()
+            .expect("should have found template parameter usage if we're in codegen")
+            .get(&item)
+            .map_or(false, |items_used_params| items_used_params.contains(&template_param))
+    }
+
+    /// Return `true` if `item` uses any unbound, generic template parameters,
+    /// `false` otherwise.
+    ///
+    /// Has the same restrictions that `uses_template_parameter` has.
+    pub fn uses_any_template_parameters(&self, item: ItemId) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute template parameter usage as we enter codegen"
+        );
+
+        self.used_template_parameters
+            .as_ref()
+            .expect(
+                "should have template parameter usage info in codegen phase",
+            )
+            .get(&item)
+            .map_or(false, |used| !used.is_empty())
+    }
+
+    // This deserves a comment. Builtin types don't get a valid declaration, so
+    // we can't add it to the cursor->type map.
+    //
+    // That being said, they're not generated anyway, and are few, so the
+    // duplication and special-casing is fine.
+    //
+    // If at some point we care about the memory here, probably a map TypeKind
+    // -> builtin type ItemId would be the best to improve that.
+    fn add_builtin_item(&mut self, item: Item) {
+        debug!("add_builtin_item: item = {:?}", item);
+        debug_assert!(item.kind().is_type());
+        self.add_item_to_module(&item);
+        let id = item.id();
+        let old_item = mem::replace(&mut self.items[id.0], Some(item));
+        assert!(old_item.is_none(), "Inserted type twice?");
+    }
+
+    fn build_root_module(id: ItemId) -> Item {
+        let module = Module::new(Some("root".into()), ModuleKind::Normal);
+        Item::new(id, None, None, id, ItemKind::Module(module), None)
+    }
+
+    /// Get the root module.
+    pub fn root_module(&self) -> ModuleId {
+        self.root_module
+    }
+
+    /// Resolve a type with the given id.
+    ///
+    /// Panics if there is no item for the given `TypeId` or if the resolved
+    /// item is not a `Type`.
+    pub fn resolve_type(&self, type_id: TypeId) -> &Type {
+        self.resolve_item(type_id).kind().expect_type()
+    }
+
+    /// Resolve a function with the given id.
+    ///
+    /// Panics if there is no item for the given `FunctionId` or if the resolved
+    /// item is not a `Function`.
+    pub fn resolve_func(&self, func_id: FunctionId) -> &Function {
+        self.resolve_item(func_id).kind().expect_function()
+    }
+
+    /// Resolve the given `ItemId` as a type, or `None` if there is no item with
+    /// the given id.
+    ///
+    /// Panics if the id resolves to an item that is not a type.
+    pub fn safe_resolve_type(&self, type_id: TypeId) -> Option<&Type> {
+        self.resolve_item_fallible(type_id)
+            .map(|t| t.kind().expect_type())
+    }
+
+    /// Resolve the given `ItemId` into an `Item`, or `None` if no such item
+    /// exists.
+    pub fn resolve_item_fallible<Id: Into<ItemId>>(
+        &self,
+        id: Id,
+    ) -> Option<&Item> {
+        self.items.get(id.into().0)?.as_ref()
+    }
+
+    /// Resolve the given `ItemId` into an `Item`.
+    ///
+    /// Panics if the given id does not resolve to any item.
+    pub fn resolve_item<Id: Into<ItemId>>(&self, item_id: Id) -> &Item {
+        let item_id = item_id.into();
+        match self.resolve_item_fallible(item_id) {
+            Some(item) => item,
+            None => panic!("Not an item: {:?}", item_id),
+        }
+    }
+
+    /// Get the current module.
+    pub fn current_module(&self) -> ModuleId {
+        self.current_module
+    }
+
+    /// Add a semantic parent for a given type definition.
+    ///
+    /// We do this from the type declaration, in order to be able to find the
+    /// correct type definition afterwards.
+    ///
+    /// TODO(emilio): We could consider doing this only when
+    /// declaration.lexical_parent() != definition.lexical_parent(), but it's
+    /// not sure it's worth it.
+    pub fn add_semantic_parent(
+        &mut self,
+        definition: clang::Cursor,
+        parent_id: ItemId,
+    ) {
+        self.semantic_parents.insert(definition, parent_id);
+    }
+
+    /// Returns a known semantic parent for a given definition.
+    pub fn known_semantic_parent(
+        &self,
+        definition: clang::Cursor,
+    ) -> Option<ItemId> {
+        self.semantic_parents.get(&definition).cloned()
+    }
+
+    /// Given a cursor pointing to the location of a template instantiation,
+    /// return a tuple of the form `(declaration_cursor, declaration_id,
+    /// num_expected_template_args)`.
+    ///
+    /// Note that `declaration_id` is not guaranteed to be in the context's item
+    /// set! It is possible that it is a partial type that we are still in the
+    /// middle of parsing.
+    fn get_declaration_info_for_template_instantiation(
+        &self,
+        instantiation: &Cursor,
+    ) -> Option<(Cursor, ItemId, usize)> {
+        instantiation
+            .cur_type()
+            .canonical_declaration(Some(instantiation))
+            .and_then(|canon_decl| {
+                self.get_resolved_type(&canon_decl).and_then(
+                    |template_decl_id| {
+                        let num_params =
+                            template_decl_id.num_self_template_params(self);
+                        if num_params == 0 {
+                            None
+                        } else {
+                            Some((
+                                *canon_decl.cursor(),
+                                template_decl_id.into(),
+                                num_params,
+                            ))
+                        }
+                    },
+                )
+            })
+            .or_else(|| {
+                // If we haven't already parsed the declaration of
+                // the template being instantiated, then it *must*
+                // be on the stack of types we are currently
+                // parsing. If it wasn't then clang would have
+                // already errored out before we started
+                // constructing our IR because you can't instantiate
+                // a template until it is fully defined.
+                instantiation
+                    .referenced()
+                    .and_then(|referenced| {
+                        self.currently_parsed_types()
+                            .iter()
+                            .find(|partial_ty| *partial_ty.decl() == referenced)
+                            .cloned()
+                    })
+                    .and_then(|template_decl| {
+                        let num_template_params =
+                            template_decl.num_self_template_params(self);
+                        if num_template_params == 0 {
+                            None
+                        } else {
+                            Some((
+                                *template_decl.decl(),
+                                template_decl.id(),
+                                num_template_params,
+                            ))
+                        }
+                    })
+            })
+    }
+
+    /// Parse a template instantiation, eg `Foo<int>`.
+    ///
+    /// This is surprisingly difficult to do with libclang, due to the fact that
+    /// it doesn't provide explicit template argument information, except for
+    /// function template declarations(!?!??!).
+    ///
+    /// The only way to do this is manually inspecting the AST and looking for
+    /// TypeRefs and TemplateRefs inside. This, unfortunately, doesn't work for
+    /// more complex cases, see the comment on the assertion below.
+    ///
+    /// To add insult to injury, the AST itself has structure that doesn't make
+    /// sense. Sometimes `Foo<Bar<int>>` has an AST with nesting like you might
+    /// expect: `(Foo (Bar (int)))`. Other times, the AST we get is completely
+    /// flat: `(Foo Bar int)`.
+    ///
+    /// To see an example of what this method handles:
+    ///
+    /// ```c++
+    /// template<typename T>
+    /// class Incomplete {
+    ///   T p;
+    /// };
+    ///
+    /// template<typename U>
+    /// class Foo {
+    ///   Incomplete<U> bar;
+    /// };
+    /// ```
+    ///
+    /// Finally, template instantiations are always children of the current
+    /// module. They use their template's definition for their name, so the
+    /// parent is only useful for ensuring that their layout tests get
+    /// codegen'd.
+    fn instantiate_template(
+        &mut self,
+        with_id: ItemId,
+        template: TypeId,
+        ty: &clang::Type,
+        location: clang::Cursor,
+    ) -> Option<TypeId> {
+        let num_expected_args =
+            self.resolve_type(template).num_self_template_params(self);
+        if num_expected_args == 0 {
+            warn!(
+                "Tried to instantiate a template for which we could not \
+                 determine any template parameters"
+            );
+            return None;
+        }
+
+        let mut args = vec![];
+        let mut found_const_arg = false;
+        let mut children = location.collect_children();
+
+        if children.iter().all(|c| !c.has_children()) {
+            // This is insanity... If clang isn't giving us a properly nested
+            // AST for which template arguments belong to which template we are
+            // instantiating, we'll need to construct it ourselves. However,
+            // there is an extra `NamespaceRef, NamespaceRef, ..., TemplateRef`
+            // representing a reference to the outermost template declaration
+            // that we need to filter out of the children. We need to do this
+            // filtering because we already know which template declaration is
+            // being specialized via the `location`'s type, and if we do not
+            // filter it out, we'll add an extra layer of template instantiation
+            // on accident.
+            let idx = children
+                .iter()
+                .position(|c| c.kind() == clang_sys::CXCursor_TemplateRef);
+            if let Some(idx) = idx {
+                if children
+                    .iter()
+                    .take(idx)
+                    .all(|c| c.kind() == clang_sys::CXCursor_NamespaceRef)
+                {
+                    children = children.into_iter().skip(idx + 1).collect();
+                }
+            }
+        }
+
+        for child in children.iter().rev() {
+            match child.kind() {
+                clang_sys::CXCursor_TypeRef |
+                clang_sys::CXCursor_TypedefDecl |
+                clang_sys::CXCursor_TypeAliasDecl => {
+                    // The `with_id` id will potentially end up unused if we give up
+                    // on this type (for example, because it has const value
+                    // template args), so if we pass `with_id` as the parent, it is
+                    // potentially a dangling reference. Instead, use the canonical
+                    // template declaration as the parent. It is already parsed and
+                    // has a known-resolvable `ItemId`.
+                    let ty = Item::from_ty_or_ref(
+                        child.cur_type(),
+                        *child,
+                        Some(template.into()),
+                        self,
+                    );
+                    args.push(ty);
+                }
+                clang_sys::CXCursor_TemplateRef => {
+                    let (
+                        template_decl_cursor,
+                        template_decl_id,
+                        num_expected_template_args,
+                    ) = self.get_declaration_info_for_template_instantiation(
+                        child,
+                    )?;
+
+                    if num_expected_template_args == 0 ||
+                        child.has_at_least_num_children(
+                            num_expected_template_args,
+                        )
+                    {
+                        // Do a happy little parse. See comment in the TypeRef
+                        // match arm about parent IDs.
+                        let ty = Item::from_ty_or_ref(
+                            child.cur_type(),
+                            *child,
+                            Some(template.into()),
+                            self,
+                        );
+                        args.push(ty);
+                    } else {
+                        // This is the case mentioned in the doc comment where
+                        // clang gives us a flattened AST and we have to
+                        // reconstruct which template arguments go to which
+                        // instantiation :(
+                        let args_len = args.len();
+                        if args_len < num_expected_template_args {
+                            warn!(
+                                "Found a template instantiation without \
+                                 enough template arguments"
+                            );
+                            return None;
+                        }
+
+                        let mut sub_args: Vec<_> = args
+                            .drain(args_len - num_expected_template_args..)
+                            .collect();
+                        sub_args.reverse();
+
+                        let sub_name = Some(template_decl_cursor.spelling());
+                        let sub_inst = TemplateInstantiation::new(
+                            // This isn't guaranteed to be a type that we've
+                            // already finished parsing yet.
+                            template_decl_id.as_type_id_unchecked(),
+                            sub_args,
+                        );
+                        let sub_kind =
+                            TypeKind::TemplateInstantiation(sub_inst);
+                        let sub_ty = Type::new(
+                            sub_name,
+                            template_decl_cursor
+                                .cur_type()
+                                .fallible_layout(self)
+                                .ok(),
+                            sub_kind,
+                            false,
+                        );
+                        let sub_id = self.next_item_id();
+                        let sub_item = Item::new(
+                            sub_id,
+                            None,
+                            None,
+                            self.current_module.into(),
+                            ItemKind::Type(sub_ty),
+                            Some(child.location()),
+                        );
+
+                        // Bypass all the validations in add_item explicitly.
+                        debug!(
+                            "instantiate_template: inserting nested \
+                             instantiation item: {:?}",
+                            sub_item
+                        );
+                        self.add_item_to_module(&sub_item);
+                        debug_assert_eq!(sub_id, sub_item.id());
+                        self.items[sub_id.0] = Some(sub_item);
+                        args.push(sub_id.as_type_id_unchecked());
+                    }
+                }
+                _ => {
+                    warn!(
+                        "Found template arg cursor we can't handle: {:?}",
+                        child
+                    );
+                    found_const_arg = true;
+                }
+            }
+        }
+
+        if found_const_arg {
+            // This is a dependently typed template instantiation. That is, an
+            // instantiation of a template with one or more const values as
+            // template arguments, rather than only types as template
+            // arguments. For example, `Foo<true, 5>` versus `Bar<bool, int>`.
+            // We can't handle these instantiations, so just punt in this
+            // situation...
+            warn!(
+                "Found template instantiated with a const value; \
+                 bindgen can't handle this kind of template instantiation!"
+            );
+            return None;
+        }
+
+        if args.len() != num_expected_args {
+            warn!(
+                "Found a template with an unexpected number of template \
+                 arguments"
+            );
+            return None;
+        }
+
+        args.reverse();
+        let type_kind = TypeKind::TemplateInstantiation(
+            TemplateInstantiation::new(template, args),
+        );
+        let name = ty.spelling();
+        let name = if name.is_empty() { None } else { Some(name) };
+        let ty = Type::new(
+            name,
+            ty.fallible_layout(self).ok(),
+            type_kind,
+            ty.is_const(),
+        );
+        let item = Item::new(
+            with_id,
+            None,
+            None,
+            self.current_module.into(),
+            ItemKind::Type(ty),
+            Some(location.location()),
+        );
+
+        // Bypass all the validations in add_item explicitly.
+        debug!("instantiate_template: inserting item: {:?}", item);
+        self.add_item_to_module(&item);
+        debug_assert_eq!(with_id, item.id());
+        self.items[with_id.0] = Some(item);
+        Some(with_id.as_type_id_unchecked())
+    }
+
+    /// If we have already resolved the type for the given type declaration,
+    /// return its `ItemId`. Otherwise, return `None`.
+    pub fn get_resolved_type(
+        &self,
+        decl: &clang::CanonicalTypeDeclaration,
+    ) -> Option<TypeId> {
+        self.types
+            .get(&TypeKey::Declaration(*decl.cursor()))
+            .or_else(|| {
+                decl.cursor()
+                    .usr()
+                    .and_then(|usr| self.types.get(&TypeKey::Usr(usr)))
+            })
+            .cloned()
+    }
+
+    /// Looks up for an already resolved type, either because it's builtin, or
+    /// because we already have it in the map.
+    pub fn builtin_or_resolved_ty(
+        &mut self,
+        with_id: ItemId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+        location: Option<clang::Cursor>,
+    ) -> Option<TypeId> {
+        use clang_sys::{CXCursor_TypeAliasTemplateDecl, CXCursor_TypeRef};
+        debug!(
+            "builtin_or_resolved_ty: {:?}, {:?}, {:?}, {:?}",
+            ty, location, with_id, parent_id
+        );
+
+        if let Some(decl) = ty.canonical_declaration(location.as_ref()) {
+            if let Some(id) = self.get_resolved_type(&decl) {
+                debug!(
+                    "Already resolved ty {:?}, {:?}, {:?} {:?}",
+                    id, decl, ty, location
+                );
+                // If the declaration already exists, then either:
+                //
+                //   * the declaration is a template declaration of some sort,
+                //     and we are looking at an instantiation or specialization
+                //     of it, or
+                //   * we have already parsed and resolved this type, and
+                //     there's nothing left to do.
+                if let Some(location) = location {
+                    if decl.cursor().is_template_like() &&
+                        *ty != decl.cursor().cur_type()
+                    {
+                        // For specialized type aliases, there's no way to get the
+                        // template parameters as of this writing (for a struct
+                        // specialization we wouldn't be in this branch anyway).
+                        //
+                        // Explicitly return `None` if there aren't any
+                        // unspecialized parameters (contains any `TypeRef`) so we
+                        // resolve the canonical type if there is one and it's
+                        // exposed.
+                        //
+                        // This is _tricky_, I know :(
+                        if decl.cursor().kind() ==
+                            CXCursor_TypeAliasTemplateDecl &&
+                            !location.contains_cursor(CXCursor_TypeRef) &&
+                            ty.canonical_type().is_valid_and_exposed()
+                        {
+                            return None;
+                        }
+
+                        return self
+                            .instantiate_template(with_id, id, ty, location)
+                            .or(Some(id));
+                    }
+                }
+
+                return Some(self.build_ty_wrapper(with_id, id, parent_id, ty));
+            }
+        }
+
+        debug!("Not resolved, maybe builtin?");
+        self.build_builtin_ty(ty)
+    }
+
+    /// Make a new item that is a resolved type reference to the `wrapped_id`.
+    ///
+    /// This is unfortunately a lot of bloat, but is needed to properly track
+    /// constness et al.
+    ///
+    /// We should probably make the constness tracking separate, so it doesn't
+    /// bloat that much, but hey, we already bloat the heck out of builtin
+    /// types.
+    pub fn build_ty_wrapper(
+        &mut self,
+        with_id: ItemId,
+        wrapped_id: TypeId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+    ) -> TypeId {
+        self.build_wrapper(with_id, wrapped_id, parent_id, ty, ty.is_const())
+    }
+
+    /// A wrapper over a type that adds a const qualifier explicitly.
+    ///
+    /// Needed to handle const methods in C++, wrapping the type .
+    pub fn build_const_wrapper(
+        &mut self,
+        with_id: ItemId,
+        wrapped_id: TypeId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+    ) -> TypeId {
+        self.build_wrapper(
+            with_id, wrapped_id, parent_id, ty, /* is_const = */ true,
+        )
+    }
+
+    fn build_wrapper(
+        &mut self,
+        with_id: ItemId,
+        wrapped_id: TypeId,
+        parent_id: Option<ItemId>,
+        ty: &clang::Type,
+        is_const: bool,
+    ) -> TypeId {
+        let spelling = ty.spelling();
+        let layout = ty.fallible_layout(self).ok();
+        let location = ty.declaration().location();
+        let type_kind = TypeKind::ResolvedTypeRef(wrapped_id);
+        let ty = Type::new(Some(spelling), layout, type_kind, is_const);
+        let item = Item::new(
+            with_id,
+            None,
+            None,
+            parent_id.unwrap_or_else(|| self.current_module.into()),
+            ItemKind::Type(ty),
+            Some(location),
+        );
+        self.add_builtin_item(item);
+        with_id.as_type_id_unchecked()
+    }
+
+    /// Returns the next item id to be used for an item.
+    pub fn next_item_id(&mut self) -> ItemId {
+        let ret = ItemId(self.items.len());
+        self.items.push(None);
+        ret
+    }
+
+    fn build_builtin_ty(&mut self, ty: &clang::Type) -> Option<TypeId> {
+        use clang_sys::*;
+        let type_kind = match ty.kind() {
+            CXType_NullPtr => TypeKind::NullPtr,
+            CXType_Void => TypeKind::Void,
+            CXType_Bool => TypeKind::Int(IntKind::Bool),
+            CXType_Int => TypeKind::Int(IntKind::Int),
+            CXType_UInt => TypeKind::Int(IntKind::UInt),
+            CXType_Char_S => TypeKind::Int(IntKind::Char { is_signed: true }),
+            CXType_Char_U => TypeKind::Int(IntKind::Char { is_signed: false }),
+            CXType_SChar => TypeKind::Int(IntKind::SChar),
+            CXType_UChar => TypeKind::Int(IntKind::UChar),
+            CXType_Short => TypeKind::Int(IntKind::Short),
+            CXType_UShort => TypeKind::Int(IntKind::UShort),
+            CXType_WChar => TypeKind::Int(IntKind::WChar),
+            CXType_Char16 => TypeKind::Int(IntKind::U16),
+            CXType_Char32 => TypeKind::Int(IntKind::U32),
+            CXType_Long => TypeKind::Int(IntKind::Long),
+            CXType_ULong => TypeKind::Int(IntKind::ULong),
+            CXType_LongLong => TypeKind::Int(IntKind::LongLong),
+            CXType_ULongLong => TypeKind::Int(IntKind::ULongLong),
+            CXType_Int128 => TypeKind::Int(IntKind::I128),
+            CXType_UInt128 => TypeKind::Int(IntKind::U128),
+            CXType_Float => TypeKind::Float(FloatKind::Float),
+            CXType_Double => TypeKind::Float(FloatKind::Double),
+            CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),
+            CXType_Float128 => TypeKind::Float(FloatKind::Float128),
+            CXType_Complex => {
+                let float_type =
+                    ty.elem_type().expect("Not able to resolve complex type?");
+                let float_kind = match float_type.kind() {
+                    CXType_Float => FloatKind::Float,
+                    CXType_Double => FloatKind::Double,
+                    CXType_LongDouble => FloatKind::LongDouble,
+                    CXType_Float128 => FloatKind::Float128,
+                    _ => panic!(
+                        "Non floating-type complex? {:?}, {:?}",
+                        ty, float_type,
+                    ),
+                };
+                TypeKind::Complex(float_kind)
+            }
+            _ => return None,
+        };
+
+        let spelling = ty.spelling();
+        let is_const = ty.is_const();
+        let layout = ty.fallible_layout(self).ok();
+        let location = ty.declaration().location();
+        let ty = Type::new(Some(spelling), layout, type_kind, is_const);
+        let id = self.next_item_id();
+        let item = Item::new(
+            id,
+            None,
+            None,
+            self.root_module.into(),
+            ItemKind::Type(ty),
+            Some(location),
+        );
+        self.add_builtin_item(item);
+        Some(id.as_type_id_unchecked())
+    }
+
+    /// Get the current Clang translation unit that is being processed.
+    pub fn translation_unit(&self) -> &clang::TranslationUnit {
+        &self.translation_unit
+    }
+
+    /// Have we parsed the macro named `macro_name` already?
+    pub fn parsed_macro(&self, macro_name: &[u8]) -> bool {
+        self.parsed_macros.contains_key(macro_name)
+    }
+
+    /// Get the currently parsed macros.
+    pub fn parsed_macros(
+        &self,
+    ) -> &StdHashMap<Vec<u8>, cexpr::expr::EvalResult> {
+        debug_assert!(!self.in_codegen_phase());
+        &self.parsed_macros
+    }
+
+    /// Mark the macro named `macro_name` as parsed.
+    pub fn note_parsed_macro(
+        &mut self,
+        id: Vec<u8>,
+        value: cexpr::expr::EvalResult,
+    ) {
+        self.parsed_macros.insert(id, value);
+    }
+
+    /// Are we in the codegen phase?
+    pub fn in_codegen_phase(&self) -> bool {
+        self.in_codegen
+    }
+
+    /// Mark the type with the given `name` as replaced by the type with id
+    /// `potential_ty`.
+    ///
+    /// Replacement types are declared using the `replaces="xxx"` annotation,
+    /// and implies that the original type is hidden.
+    pub fn replace(&mut self, name: &[String], potential_ty: ItemId) {
+        match self.replacements.entry(name.into()) {
+            Entry::Vacant(entry) => {
+                debug!(
+                    "Defining replacement for {:?} as {:?}",
+                    name, potential_ty
+                );
+                entry.insert(potential_ty);
+            }
+            Entry::Occupied(occupied) => {
+                warn!(
+                    "Replacement for {:?} already defined as {:?}; \
+                     ignoring duplicate replacement definition as {:?}",
+                    name,
+                    occupied.get(),
+                    potential_ty
+                );
+            }
+        }
+    }
+
+    /// Has the item with the given `name` and `id` been replaced by another
+    /// type?
+    pub fn is_replaced_type<Id: Into<ItemId>>(
+        &self,
+        path: &[String],
+        id: Id,
+    ) -> bool {
+        let id = id.into();
+        matches!(self.replacements.get(path), Some(replaced_by) if *replaced_by != id)
+    }
+
+    /// Is the type with the given `name` marked as opaque?
+    pub fn opaque_by_name(&self, path: &[String]) -> bool {
+        debug_assert!(
+            self.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        self.options.opaque_types.matches(&path[1..].join("::"))
+    }
+
+    /// Get the options used to configure this bindgen context.
+    pub(crate) fn options(&self) -> &BindgenOptions {
+        &self.options
+    }
+
+    /// Tokenizes a namespace cursor in order to get the name and kind of the
+    /// namespace.
+    fn tokenize_namespace(
+        &self,
+        cursor: &clang::Cursor,
+    ) -> (Option<String>, ModuleKind) {
+        assert_eq!(
+            cursor.kind(),
+            ::clang_sys::CXCursor_Namespace,
+            "Be a nice person"
+        );
+
+        let mut module_name = None;
+        let spelling = cursor.spelling();
+        if !spelling.is_empty() {
+            module_name = Some(spelling)
+        }
+
+        let mut kind = ModuleKind::Normal;
+        let mut found_namespace_keyword = false;
+        for token in cursor.tokens().iter() {
+            match token.spelling() {
+                b"inline" => {
+                    assert!(!found_namespace_keyword);
+                    assert!(kind != ModuleKind::Inline);
+                    kind = ModuleKind::Inline;
+                }
+                // The double colon allows us to handle nested namespaces like
+                // namespace foo::bar { }
+                //
+                // libclang still gives us two namespace cursors, which is cool,
+                // but the tokenization of the second begins with the double
+                // colon. That's ok, so we only need to handle the weird
+                // tokenization here.
+                //
+                // Fortunately enough, inline nested namespace specifiers aren't
+                // a thing, and are invalid C++ :)
+                b"namespace" | b"::" => {
+                    found_namespace_keyword = true;
+                }
+                b"{" => {
+                    assert!(found_namespace_keyword);
+                    break;
+                }
+                name if found_namespace_keyword => {
+                    if module_name.is_none() {
+                        module_name =
+                            Some(String::from_utf8_lossy(name).into_owned());
+                    }
+                    break;
+                }
+                spelling if !found_namespace_keyword => {
+                    // This is _likely_, but not certainly, a macro that's been placed just before
+                    // the namespace keyword. Unfortunately, clang tokens don't let us easily see
+                    // through the ifdef tokens, so we don't know what this token should really be.
+                    // Instead of panicking though, we warn the user that we assumed the token was
+                    // blank, and then move on.
+                    //
+                    // See also https://github.com/rust-lang/rust-bindgen/issues/1676.
+                    warn!(
+                        "Ignored unknown namespace prefix '{}' at {:?} in {:?}",
+                        String::from_utf8_lossy(spelling),
+                        token,
+                        cursor
+                    );
+                }
+                spelling => {
+                    panic!(
+                        "Unknown token '{}' while processing namespace at {:?} in {:?}",
+                        String::from_utf8_lossy(spelling),
+                        token,
+                        cursor
+                    );
+                }
+            }
+        }
+
+        (module_name, kind)
+    }
+
+    /// Given a CXCursor_Namespace cursor, return the item id of the
+    /// corresponding module, or create one on the fly.
+    pub fn module(&mut self, cursor: clang::Cursor) -> ModuleId {
+        use clang_sys::*;
+        assert_eq!(cursor.kind(), CXCursor_Namespace, "Be a nice person");
+        let cursor = cursor.canonical();
+        if let Some(id) = self.modules.get(&cursor) {
+            return *id;
+        }
+
+        let (module_name, kind) = self.tokenize_namespace(&cursor);
+
+        let module_id = self.next_item_id();
+        let module = Module::new(module_name, kind);
+        let module = Item::new(
+            module_id,
+            None,
+            None,
+            self.current_module.into(),
+            ItemKind::Module(module),
+            Some(cursor.location()),
+        );
+
+        let module_id = module.id().as_module_id_unchecked();
+        self.modules.insert(cursor, module_id);
+
+        self.add_item(module, None, None);
+
+        module_id
+    }
+
+    /// Start traversing the module with the given `module_id`, invoke the
+    /// callback `cb`, and then return to traversing the original module.
+    pub fn with_module<F>(&mut self, module_id: ModuleId, cb: F)
+    where
+        F: FnOnce(&mut Self),
+    {
+        debug_assert!(self.resolve_item(module_id).kind().is_module(), "Wat");
+
+        let previous_id = self.current_module;
+        self.current_module = module_id;
+
+        cb(self);
+
+        self.current_module = previous_id;
+    }
+
+    /// Iterate over all (explicitly or transitively) allowlisted items.
+    ///
+    /// If no items are explicitly allowlisted, then all items are considered
+    /// allowlisted.
+    pub fn allowlisted_items(&self) -> &ItemSet {
+        assert!(self.in_codegen_phase());
+        assert!(self.current_module == self.root_module);
+
+        self.allowlisted.as_ref().unwrap()
+    }
+
+    /// Check whether a particular blocklisted type implements a trait or not.
+    /// Results may be cached.
+    pub fn blocklisted_type_implements_trait(
+        &self,
+        item: &Item,
+        derive_trait: DeriveTrait,
+    ) -> CanDerive {
+        assert!(self.in_codegen_phase());
+        assert!(self.current_module == self.root_module);
+
+        *self
+            .blocklisted_types_implement_traits
+            .borrow_mut()
+            .entry(derive_trait)
+            .or_default()
+            .entry(item.id())
+            .or_insert_with(|| {
+                item.expect_type()
+                    .name()
+                    .and_then(|name| match self.options.parse_callbacks {
+                        Some(ref cb) => cb.blocklisted_type_implements_trait(
+                            name,
+                            derive_trait,
+                        ),
+                        // Sized integer types from <stdint.h> get mapped to Rust primitive
+                        // types regardless of whether they are blocklisted, so ensure that
+                        // standard traits are considered derivable for them too.
+                        None => Some(if self.is_stdint_type(name) {
+                            CanDerive::Yes
+                        } else {
+                            CanDerive::No
+                        }),
+                    })
+                    .unwrap_or(CanDerive::No)
+            })
+    }
+
+    /// Is the given type a type from <stdint.h> that corresponds to a Rust primitive type?
+    pub fn is_stdint_type(&self, name: &str) -> bool {
+        match name {
+            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" | "int32_t" |
+            "uint32_t" | "int64_t" | "uint64_t" | "uintptr_t" |
+            "intptr_t" | "ptrdiff_t" => true,
+            "size_t" | "ssize_t" => self.options.size_t_is_usize,
+            _ => false,
+        }
+    }
+
+    /// Get a reference to the set of items we should generate.
+    pub fn codegen_items(&self) -> &ItemSet {
+        assert!(self.in_codegen_phase());
+        assert!(self.current_module == self.root_module);
+        self.codegen_items.as_ref().unwrap()
+    }
+
+    /// Compute the allowlisted items set and populate `self.allowlisted`.
+    fn compute_allowlisted_and_codegen_items(&mut self) {
+        assert!(self.in_codegen_phase());
+        assert!(self.current_module == self.root_module);
+        assert!(self.allowlisted.is_none());
+        let _t = self.timer("compute_allowlisted_and_codegen_items");
+
+        let roots = {
+            let mut roots = self
+                .items()
+                // Only consider roots that are enabled for codegen.
+                .filter(|&(_, item)| item.is_enabled_for_codegen(self))
+                .filter(|&(_, item)| {
+                    // If nothing is explicitly allowlisted, then everything is fair
+                    // game.
+                    if self.options().allowlisted_types.is_empty() &&
+                        self.options().allowlisted_functions.is_empty() &&
+                        self.options().allowlisted_vars.is_empty() &&
+                        self.options().allowlisted_files.is_empty()
+                    {
+                        return true;
+                    }
+
+                    // If this is a type that explicitly replaces another, we assume
+                    // you know what you're doing.
+                    if item.annotations().use_instead_of().is_some() {
+                        return true;
+                    }
+
+                    // Items with a source location in an explicitly allowlisted file
+                    // are always included.
+                    if !self.options().allowlisted_files.is_empty() {
+                        if let Some(location) = item.location() {
+                            let (file, _, _, _) = location.location();
+                            if let Some(filename) = file.name() {
+                                if self
+                                    .options()
+                                    .allowlisted_files
+                                    .matches(&filename)
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    let name = item.path_for_allowlisting(self)[1..].join("::");
+                    debug!("allowlisted_items: testing {:?}", name);
+                    match *item.kind() {
+                        ItemKind::Module(..) => true,
+                        ItemKind::Function(_) => {
+                            self.options().allowlisted_functions.matches(&name)
+                        }
+                        ItemKind::Var(_) => {
+                            self.options().allowlisted_vars.matches(&name)
+                        }
+                        ItemKind::Type(ref ty) => {
+                            if self.options().allowlisted_types.matches(&name) {
+                                return true;
+                            }
+
+                            // Auto-allowlist types that don't need code
+                            // generation if not allowlisting recursively, to
+                            // make the #[derive] analysis not be lame.
+                            if !self.options().allowlist_recursively {
+                                match *ty.kind() {
+                                    TypeKind::Void |
+                                    TypeKind::NullPtr |
+                                    TypeKind::Int(..) |
+                                    TypeKind::Float(..) |
+                                    TypeKind::Complex(..) |
+                                    TypeKind::Array(..) |
+                                    TypeKind::Vector(..) |
+                                    TypeKind::Pointer(..) |
+                                    TypeKind::Reference(..) |
+                                    TypeKind::Function(..) |
+                                    TypeKind::ResolvedTypeRef(..) |
+                                    TypeKind::Opaque |
+                                    TypeKind::TypeParam => return true,
+                                    _ => {}
+                                }
+                                if self.is_stdint_type(&name) {
+                                    return true;
+                                }
+                            }
+
+                            // Unnamed top-level enums are special and we
+                            // allowlist them via the `allowlisted_vars` filter,
+                            // since they're effectively top-level constants,
+                            // and there's no way for them to be referenced
+                            // consistently.
+                            let parent = self.resolve_item(item.parent_id());
+                            if !parent.is_module() {
+                                return false;
+                            }
+
+                            let enum_ = match *ty.kind() {
+                                TypeKind::Enum(ref e) => e,
+                                _ => return false,
+                            };
+
+                            if ty.name().is_some() {
+                                return false;
+                            }
+
+                            let mut prefix_path =
+                                parent.path_for_allowlisting(self).clone();
+                            enum_.variants().iter().any(|variant| {
+                                prefix_path.push(
+                                    variant.name_for_allowlisting().into(),
+                                );
+                                let name = prefix_path[1..].join("::");
+                                prefix_path.pop().unwrap();
+                                self.options().allowlisted_vars.matches(&name)
+                            })
+                        }
+                    }
+                })
+                .map(|(id, _)| id)
+                .collect::<Vec<_>>();
+
+            // The reversal preserves the expected ordering of traversal,
+            // resulting in more stable-ish bindgen-generated names for
+            // anonymous types (like unions).
+            roots.reverse();
+            roots
+        };
+
+        let allowlisted_items_predicate =
+            if self.options().allowlist_recursively {
+                traversal::all_edges
+            } else {
+                // Only follow InnerType edges from the allowlisted roots.
+                // Such inner types (e.g. anonymous structs/unions) are
+                // always emitted by codegen, and they need to be allowlisted
+                // to make sure they are processed by e.g. the derive analysis.
+                traversal::only_inner_type_edges
+            };
+
+        let allowlisted = AllowlistedItemsTraversal::new(
+            self,
+            roots.clone(),
+            allowlisted_items_predicate,
+        )
+        .collect::<ItemSet>();
+
+        let codegen_items = if self.options().allowlist_recursively {
+            AllowlistedItemsTraversal::new(
+                self,
+                roots,
+                traversal::codegen_edges,
+            )
+            .collect::<ItemSet>()
+        } else {
+            allowlisted.clone()
+        };
+
+        self.allowlisted = Some(allowlisted);
+        self.codegen_items = Some(codegen_items);
+
+        let mut warnings = Vec::new();
+
+        for item in self.options().allowlisted_functions.unmatched_items() {
+            warnings
+                .push(format!("unused option: --allowlist-function {}", item));
+        }
+
+        for item in self.options().allowlisted_vars.unmatched_items() {
+            warnings.push(format!("unused option: --allowlist-var {}", item));
+        }
+
+        for item in self.options().allowlisted_types.unmatched_items() {
+            warnings.push(format!("unused option: --allowlist-type {}", item));
+        }
+
+        for msg in warnings {
+            warn!("{}", msg);
+            self.warnings.push(msg);
+        }
+    }
+
+    /// Convenient method for getting the prefix to use for most traits in
+    /// codegen depending on the `use_core` option.
+    pub fn trait_prefix(&self) -> Ident {
+        if self.options().use_core {
+            self.rust_ident_raw("core")
+        } else {
+            self.rust_ident_raw("std")
+        }
+    }
+
+    /// Call if a bindgen complex is generated
+    pub fn generated_bindgen_complex(&self) {
+        self.generated_bindgen_complex.set(true)
+    }
+
+    /// Whether we need to generate the bindgen complex type
+    pub fn need_bindgen_complex_type(&self) -> bool {
+        self.generated_bindgen_complex.get()
+    }
+
+    /// Compute whether we can derive debug.
+    fn compute_cannot_derive_debug(&mut self) {
+        let _t = self.timer("compute_cannot_derive_debug");
+        assert!(self.cannot_derive_debug.is_none());
+        if self.options.derive_debug {
+            self.cannot_derive_debug =
+                Some(as_cannot_derive_set(analyze::<CannotDerive>((
+                    self,
+                    DeriveTrait::Debug,
+                ))));
+        }
+    }
+
+    /// Look up whether the item with `id` can
+    /// derive debug or not.
+    pub fn lookup_can_derive_debug<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute can_derive_debug when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` can
+        // derive debug or not.
+        !self.cannot_derive_debug.as_ref().unwrap().contains(&id)
+    }
+
+    /// Compute whether we can derive default.
+    fn compute_cannot_derive_default(&mut self) {
+        let _t = self.timer("compute_cannot_derive_default");
+        assert!(self.cannot_derive_default.is_none());
+        if self.options.derive_default {
+            self.cannot_derive_default =
+                Some(as_cannot_derive_set(analyze::<CannotDerive>((
+                    self,
+                    DeriveTrait::Default,
+                ))));
+        }
+    }
+
+    /// Look up whether the item with `id` can
+    /// derive default or not.
+    pub fn lookup_can_derive_default<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute can_derive_default when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` can
+        // derive default or not.
+        !self.cannot_derive_default.as_ref().unwrap().contains(&id)
+    }
+
+    /// Compute whether we can derive copy.
+    fn compute_cannot_derive_copy(&mut self) {
+        let _t = self.timer("compute_cannot_derive_copy");
+        assert!(self.cannot_derive_copy.is_none());
+        self.cannot_derive_copy =
+            Some(as_cannot_derive_set(analyze::<CannotDerive>((
+                self,
+                DeriveTrait::Copy,
+            ))));
+    }
+
+    /// Compute whether we can derive hash.
+    fn compute_cannot_derive_hash(&mut self) {
+        let _t = self.timer("compute_cannot_derive_hash");
+        assert!(self.cannot_derive_hash.is_none());
+        if self.options.derive_hash {
+            self.cannot_derive_hash =
+                Some(as_cannot_derive_set(analyze::<CannotDerive>((
+                    self,
+                    DeriveTrait::Hash,
+                ))));
+        }
+    }
+
+    /// Look up whether the item with `id` can
+    /// derive hash or not.
+    pub fn lookup_can_derive_hash<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        let id = id.into();
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute can_derive_debug when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` can
+        // derive hash or not.
+        !self.cannot_derive_hash.as_ref().unwrap().contains(&id)
+    }
+
+    /// Compute whether we can derive PartialOrd, PartialEq or Eq.
+    fn compute_cannot_derive_partialord_partialeq_or_eq(&mut self) {
+        let _t = self.timer("compute_cannot_derive_partialord_partialeq_or_eq");
+        assert!(self.cannot_derive_partialeq_or_partialord.is_none());
+        if self.options.derive_partialord ||
+            self.options.derive_partialeq ||
+            self.options.derive_eq
+        {
+            self.cannot_derive_partialeq_or_partialord =
+                Some(analyze::<CannotDerive>((
+                    self,
+                    DeriveTrait::PartialEqOrPartialOrd,
+                )));
+        }
+    }
+
+    /// Look up whether the item with `id` can derive `Partial{Eq,Ord}`.
+    pub fn lookup_can_derive_partialeq_or_partialord<Id: Into<ItemId>>(
+        &self,
+        id: Id,
+    ) -> CanDerive {
+        let id = id.into();
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute can_derive_partialeq_or_partialord when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` can
+        // derive partialeq or not.
+        self.cannot_derive_partialeq_or_partialord
+            .as_ref()
+            .unwrap()
+            .get(&id)
+            .cloned()
+            .unwrap_or(CanDerive::Yes)
+    }
+
+    /// Look up whether the item with `id` can derive `Copy` or not.
+    pub fn lookup_can_derive_copy<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute can_derive_debug when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` can
+        // derive `Copy` or not.
+        let id = id.into();
+
+        !self.lookup_has_type_param_in_array(id) &&
+            !self.cannot_derive_copy.as_ref().unwrap().contains(&id)
+    }
+
+    /// Compute whether the type has type parameter in array.
+    fn compute_has_type_param_in_array(&mut self) {
+        let _t = self.timer("compute_has_type_param_in_array");
+        assert!(self.has_type_param_in_array.is_none());
+        self.has_type_param_in_array =
+            Some(analyze::<HasTypeParameterInArray>(self));
+    }
+
+    /// Look up whether the item with `id` has type parameter in array or not.
+    pub fn lookup_has_type_param_in_array<Id: Into<ItemId>>(
+        &self,
+        id: Id,
+    ) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute has array when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` has
+        // type parameter in array or not.
+        self.has_type_param_in_array
+            .as_ref()
+            .unwrap()
+            .contains(&id.into())
+    }
+
+    /// Compute whether the type has float.
+    fn compute_has_float(&mut self) {
+        let _t = self.timer("compute_has_float");
+        assert!(self.has_float.is_none());
+        if self.options.derive_eq || self.options.derive_ord {
+            self.has_float = Some(analyze::<HasFloat>(self));
+        }
+    }
+
+    /// Look up whether the item with `id` has array or not.
+    pub fn lookup_has_float<Id: Into<ItemId>>(&self, id: Id) -> bool {
+        assert!(
+            self.in_codegen_phase(),
+            "We only compute has float when we enter codegen"
+        );
+
+        // Look up the computed value for whether the item with `id` has
+        // float or not.
+        self.has_float.as_ref().unwrap().contains(&id.into())
+    }
+
+    /// Check if `--no-partialeq` flag is enabled for this item.
+    pub fn no_partialeq_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().no_partialeq_types.matches(&name)
+    }
+
+    /// Check if `--no-copy` flag is enabled for this item.
+    pub fn no_copy_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().no_copy_types.matches(&name)
+    }
+
+    /// Check if `--no-debug` flag is enabled for this item.
+    pub fn no_debug_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().no_debug_types.matches(&name)
+    }
+
+    /// Check if `--no-default` flag is enabled for this item.
+    pub fn no_default_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().no_default_types.matches(&name)
+    }
+
+    /// Check if `--no-hash` flag is enabled for this item.
+    pub fn no_hash_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().no_hash_types.matches(&name)
+    }
+
+    /// Check if `--must-use-type` flag is enabled for this item.
+    pub fn must_use_type_by_name(&self, item: &Item) -> bool {
+        let name = item.path_for_allowlisting(self)[1..].join("::");
+        self.options().must_use_types.matches(&name)
+    }
+}
+
+/// A builder struct for configuring item resolution options.
+#[derive(Debug, Copy, Clone)]
+pub struct ItemResolver {
+    id: ItemId,
+    through_type_refs: bool,
+    through_type_aliases: bool,
+}
+
+impl ItemId {
+    /// Create an `ItemResolver` from this item id.
+    pub fn into_resolver(self) -> ItemResolver {
+        self.into()
+    }
+}
+
+impl<T> From<T> for ItemResolver
+where
+    T: Into<ItemId>,
+{
+    fn from(id: T) -> ItemResolver {
+        ItemResolver::new(id)
+    }
+}
+
+impl ItemResolver {
+    /// Construct a new `ItemResolver` from the given id.
+    pub fn new<Id: Into<ItemId>>(id: Id) -> ItemResolver {
+        let id = id.into();
+        ItemResolver {
+            id,
+            through_type_refs: false,
+            through_type_aliases: false,
+        }
+    }
+
+    /// Keep resolving through `Type::TypeRef` items.
+    pub fn through_type_refs(mut self) -> ItemResolver {
+        self.through_type_refs = true;
+        self
+    }
+
+    /// Keep resolving through `Type::Alias` items.
+    pub fn through_type_aliases(mut self) -> ItemResolver {
+        self.through_type_aliases = true;
+        self
+    }
+
+    /// Finish configuring and perform the actual item resolution.
+    pub fn resolve(self, ctx: &BindgenContext) -> &Item {
+        assert!(ctx.collected_typerefs());
+
+        let mut id = self.id;
+        let mut seen_ids = HashSet::default();
+        loop {
+            let item = ctx.resolve_item(id);
+
+            // Detect cycles and bail out. These can happen in certain cases
+            // involving incomplete qualified dependent types (#2085).
+            if !seen_ids.insert(id) {
+                return item;
+            }
+
+            let ty_kind = item.as_type().map(|t| t.kind());
+            match ty_kind {
+                Some(&TypeKind::ResolvedTypeRef(next_id))
+                    if self.through_type_refs =>
+                {
+                    id = next_id.into();
+                }
+                // We intentionally ignore template aliases here, as they are
+                // more complicated, and don't represent a simple renaming of
+                // some type.
+                Some(&TypeKind::Alias(next_id))
+                    if self.through_type_aliases =>
+                {
+                    id = next_id.into();
+                }
+                _ => return item,
+            }
+        }
+    }
+}
+
+/// A type that we are in the middle of parsing.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PartialType {
+    decl: Cursor,
+    // Just an ItemId, and not a TypeId, because we haven't finished this type
+    // yet, so there's still time for things to go wrong.
+    id: ItemId,
+}
+
+impl PartialType {
+    /// Construct a new `PartialType`.
+    pub fn new(decl: Cursor, id: ItemId) -> PartialType {
+        // assert!(decl == decl.canonical());
+        PartialType { decl, id }
+    }
+
+    /// The cursor pointing to this partial type's declaration location.
+    pub fn decl(&self) -> &Cursor {
+        &self.decl
+    }
+
+    /// The item ID allocated for this type. This is *NOT* a key for an entry in
+    /// the context's item set yet!
+    pub fn id(&self) -> ItemId {
+        self.id
+    }
+}
+
+impl TemplateParameters for PartialType {
+    fn self_template_params(&self, _ctx: &BindgenContext) -> Vec<TypeId> {
+        // Maybe at some point we will eagerly parse named types, but for now we
+        // don't and this information is unavailable.
+        vec![]
+    }
+
+    fn num_self_template_params(&self, _ctx: &BindgenContext) -> usize {
+        // Wouldn't it be nice if libclang would reliably give us this
+        // information‽
+        match self.decl().kind() {
+            clang_sys::CXCursor_ClassTemplate |
+            clang_sys::CXCursor_FunctionTemplate |
+            clang_sys::CXCursor_TypeAliasTemplateDecl => {
+                let mut num_params = 0;
+                self.decl().visit(|c| {
+                    match c.kind() {
+                        clang_sys::CXCursor_TemplateTypeParameter |
+                        clang_sys::CXCursor_TemplateTemplateParameter |
+                        clang_sys::CXCursor_NonTypeTemplateParameter => {
+                            num_params += 1;
+                        }
+                        _ => {}
+                    };
+                    clang_sys::CXChildVisit_Continue
+                });
+                num_params
+            }
+            _ => 0,
+        }
+    }
+}
diff --git a/bindgen/ir/derive.rs b/bindgen/ir/derive.rs
new file mode 100644
index 00000000..594ce2ab
--- /dev/null
+++ b/bindgen/ir/derive.rs
@@ -0,0 +1,135 @@
+//! Traits for determining whether we can derive traits for a thing or not.
+//!
+//! These traits tend to come in pairs:
+//!
+//! 1. A "trivial" version, whose implementations aren't allowed to recursively
+//! look at other types or the results of fix point analyses.
+//!
+//! 2. A "normal" version, whose implementations simply query the results of a
+//! fix point analysis.
+//!
+//! The former is used by the analyses when creating the results queried by the
+//! second.
+
+use super::context::BindgenContext;
+
+use std::cmp;
+use std::ops;
+
+/// A trait that encapsulates the logic for whether or not we can derive `Debug`
+/// for a given thing.
+pub trait CanDeriveDebug {
+    /// Return `true` if `Debug` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive `Copy`
+/// for a given thing.
+pub trait CanDeriveCopy {
+    /// Return `true` if `Copy` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive
+/// `Default` for a given thing.
+pub trait CanDeriveDefault {
+    /// Return `true` if `Default` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_default(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive `Hash`
+/// for a given thing.
+pub trait CanDeriveHash {
+    /// Return `true` if `Hash` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive
+/// `PartialEq` for a given thing.
+pub trait CanDerivePartialEq {
+    /// Return `true` if `PartialEq` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive
+/// `PartialOrd` for a given thing.
+pub trait CanDerivePartialOrd {
+    /// Return `true` if `PartialOrd` can be derived for this thing, `false`
+    /// otherwise.
+    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive `Eq`
+/// for a given thing.
+pub trait CanDeriveEq {
+    /// Return `true` if `Eq` can be derived for this thing, `false` otherwise.
+    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait that encapsulates the logic for whether or not we can derive `Ord`
+/// for a given thing.
+pub trait CanDeriveOrd {
+    /// Return `true` if `Ord` can be derived for this thing, `false` otherwise.
+    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// Whether it is possible or not to automatically derive trait for an item.
+///
+/// ```ignore
+///         No
+///          ^
+///          |
+///      Manually
+///          ^
+///          |
+///         Yes
+/// ```
+///
+/// Initially we assume that we can derive trait for all types and then
+/// update our understanding as we learn more about each type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum CanDerive {
+    /// Yes, we can derive automatically.
+    Yes,
+
+    /// The only thing that stops us from automatically deriving is that
+    /// array with more than maximum number of elements is used.
+    ///
+    /// This means we probably can "manually" implement such trait.
+    Manually,
+
+    /// No, we cannot.
+    No,
+}
+
+impl Default for CanDerive {
+    fn default() -> CanDerive {
+        CanDerive::Yes
+    }
+}
+
+impl CanDerive {
+    /// Take the least upper bound of `self` and `rhs`.
+    pub fn join(self, rhs: Self) -> Self {
+        cmp::max(self, rhs)
+    }
+}
+
+impl ops::BitOr for CanDerive {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        self.join(rhs)
+    }
+}
+
+impl ops::BitOrAssign for CanDerive {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = self.join(rhs)
+    }
+}
diff --git a/bindgen/ir/dot.rs b/bindgen/ir/dot.rs
new file mode 100644
index 00000000..f7d07f19
--- /dev/null
+++ b/bindgen/ir/dot.rs
@@ -0,0 +1,86 @@
+//! Generating Graphviz `dot` files from our IR.
+
+use super::context::{BindgenContext, ItemId};
+use super::traversal::Trace;
+use std::fs::File;
+use std::io::{self, Write};
+use std::path::Path;
+
+/// A trait for anything that can write attributes as `<table>` rows to a dot
+/// file.
+pub trait DotAttributes {
+    /// Write this thing's attributes to the given output. Each attribute must
+    /// be its own `<tr>...</tr>`.
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write;
+}
+
+/// Write a graphviz dot file containing our IR.
+pub fn write_dot_file<P>(ctx: &BindgenContext, path: P) -> io::Result<()>
+where
+    P: AsRef<Path>,
+{
+    let file = File::create(path)?;
+    let mut dot_file = io::BufWriter::new(file);
+    writeln!(&mut dot_file, "digraph {{")?;
+
+    let mut err: Option<io::Result<_>> = None;
+
+    for (id, item) in ctx.items() {
+        let is_allowlisted = ctx.allowlisted_items().contains(&id);
+
+        writeln!(
+            &mut dot_file,
+            r#"{} [fontname="courier", color={}, label=< <table border="0" align="left">"#,
+            id.as_usize(),
+            if is_allowlisted { "black" } else { "gray" }
+        )?;
+        item.dot_attributes(ctx, &mut dot_file)?;
+        writeln!(&mut dot_file, r#"</table> >];"#)?;
+
+        item.trace(
+            ctx,
+            &mut |sub_id: ItemId, edge_kind| {
+                if err.is_some() {
+                    return;
+                }
+
+                match writeln!(
+                    &mut dot_file,
+                    "{} -> {} [label={:?}, color={}];",
+                    id.as_usize(),
+                    sub_id.as_usize(),
+                    edge_kind,
+                    if is_allowlisted { "black" } else { "gray" }
+                ) {
+                    Ok(_) => {}
+                    Err(e) => err = Some(Err(e)),
+                }
+            },
+            &(),
+        );
+
+        if let Some(err) = err {
+            return err;
+        }
+
+        if let Some(module) = item.as_module() {
+            for child in module.children() {
+                writeln!(
+                    &mut dot_file,
+                    "{} -> {} [style=dotted, color=gray]",
+                    item.id().as_usize(),
+                    child.as_usize()
+                )?;
+            }
+        }
+    }
+
+    writeln!(&mut dot_file, "}}")?;
+    Ok(())
+}
diff --git a/bindgen/ir/enum_ty.rs b/bindgen/ir/enum_ty.rs
new file mode 100644
index 00000000..123d1d79
--- /dev/null
+++ b/bindgen/ir/enum_ty.rs
@@ -0,0 +1,320 @@
+//! Intermediate representation for C/C++ enumerations.
+
+use super::super::codegen::EnumVariation;
+use super::context::{BindgenContext, TypeId};
+use super::item::Item;
+use super::ty::{Type, TypeKind};
+use crate::clang;
+use crate::ir::annotations::Annotations;
+use crate::parse::{ClangItemParser, ParseError};
+use crate::regex_set::RegexSet;
+
+/// An enum representing custom handling that can be given to a variant.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum EnumVariantCustomBehavior {
+    /// This variant will be a module containing constants.
+    ModuleConstify,
+    /// This variant will be constified, that is, forced to generate a constant.
+    Constify,
+    /// This variant will be hidden entirely from the resulting enum.
+    Hide,
+}
+
+/// A C/C++ enumeration.
+#[derive(Debug)]
+pub struct Enum {
+    /// The representation used for this enum; it should be an `IntKind` type or
+    /// an alias to one.
+    ///
+    /// It's `None` if the enum is a forward declaration and isn't defined
+    /// anywhere else, see `tests/headers/func_ptr_in_struct.h`.
+    repr: Option<TypeId>,
+
+    /// The different variants, with explicit values.
+    variants: Vec<EnumVariant>,
+}
+
+impl Enum {
+    /// Construct a new `Enum` with the given representation and variants.
+    pub fn new(repr: Option<TypeId>, variants: Vec<EnumVariant>) -> Self {
+        Enum { repr, variants }
+    }
+
+    /// Get this enumeration's representation.
+    pub fn repr(&self) -> Option<TypeId> {
+        self.repr
+    }
+
+    /// Get this enumeration's variants.
+    pub fn variants(&self) -> &[EnumVariant] {
+        &self.variants
+    }
+
+    /// Construct an enumeration from the given Clang type.
+    pub fn from_ty(
+        ty: &clang::Type,
+        ctx: &mut BindgenContext,
+    ) -> Result<Self, ParseError> {
+        use clang_sys::*;
+        debug!("Enum::from_ty {:?}", ty);
+
+        if ty.kind() != CXType_Enum {
+            return Err(ParseError::Continue);
+        }
+
+        let declaration = ty.declaration().canonical();
+        let repr = declaration
+            .enum_type()
+            .and_then(|et| Item::from_ty(&et, declaration, None, ctx).ok());
+        let mut variants = vec![];
+
+        let variant_ty =
+            repr.and_then(|r| ctx.resolve_type(r).safe_canonical_type(ctx));
+        let is_bool = variant_ty.map_or(false, Type::is_bool);
+
+        // Assume signedness since the default type by the C standard is an int.
+        let is_signed = variant_ty.map_or(true, |ty| match *ty.kind() {
+            TypeKind::Int(ref int_kind) => int_kind.is_signed(),
+            ref other => {
+                panic!("Since when enums can be non-integers? {:?}", other)
+            }
+        });
+
+        let type_name = ty.spelling();
+        let type_name = if type_name.is_empty() {
+            None
+        } else {
+            Some(type_name)
+        };
+        let type_name = type_name.as_deref();
+
+        let definition = declaration.definition().unwrap_or(declaration);
+        definition.visit(|cursor| {
+            if cursor.kind() == CXCursor_EnumConstantDecl {
+                let value = if is_bool {
+                    cursor.enum_val_boolean().map(EnumVariantValue::Boolean)
+                } else if is_signed {
+                    cursor.enum_val_signed().map(EnumVariantValue::Signed)
+                } else {
+                    cursor.enum_val_unsigned().map(EnumVariantValue::Unsigned)
+                };
+                if let Some(val) = value {
+                    let name = cursor.spelling();
+                    let annotations = Annotations::new(&cursor);
+                    let custom_behavior = ctx
+                        .parse_callbacks()
+                        .and_then(|callbacks| {
+                            callbacks
+                                .enum_variant_behavior(type_name, &name, val)
+                        })
+                        .or_else(|| {
+                            let annotations = annotations.as_ref()?;
+                            if annotations.hide() {
+                                Some(EnumVariantCustomBehavior::Hide)
+                            } else if annotations.constify_enum_variant() {
+                                Some(EnumVariantCustomBehavior::Constify)
+                            } else {
+                                None
+                            }
+                        });
+
+                    let new_name = ctx
+                        .parse_callbacks()
+                        .and_then(|callbacks| {
+                            callbacks.enum_variant_name(type_name, &name, val)
+                        })
+                        .or_else(|| {
+                            annotations
+                                .as_ref()?
+                                .use_instead_of()?
+                                .last()
+                                .cloned()
+                        })
+                        .unwrap_or_else(|| name.clone());
+
+                    let comment = cursor.raw_comment();
+                    variants.push(EnumVariant::new(
+                        new_name,
+                        name,
+                        comment,
+                        val,
+                        custom_behavior,
+                    ));
+                }
+            }
+            CXChildVisit_Continue
+        });
+        Ok(Enum::new(repr, variants))
+    }
+
+    fn is_matching_enum(
+        &self,
+        ctx: &BindgenContext,
+        enums: &RegexSet,
+        item: &Item,
+    ) -> bool {
+        let path = item.path_for_allowlisting(ctx);
+        let enum_ty = item.expect_type();
+
+        if enums.matches(&path[1..].join("::")) {
+            return true;
+        }
+
+        // Test the variants if the enum is anonymous.
+        if enum_ty.name().is_some() {
+            return false;
+        }
+
+        self.variants().iter().any(|v| enums.matches(v.name()))
+    }
+
+    /// Returns the final representation of the enum.
+    pub fn computed_enum_variation(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> EnumVariation {
+        // ModuleConsts has higher precedence before Rust in order to avoid
+        // problems with overlapping match patterns.
+        if self.is_matching_enum(
+            ctx,
+            &ctx.options().constified_enum_modules,
+            item,
+        ) {
+            EnumVariation::ModuleConsts
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().bitfield_enums,
+            item,
+        ) {
+            EnumVariation::NewType {
+                is_bitfield: true,
+                is_global: false,
+            }
+        } else if self.is_matching_enum(ctx, &ctx.options().newtype_enums, item)
+        {
+            EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: false,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().newtype_global_enums,
+            item,
+        ) {
+            EnumVariation::NewType {
+                is_bitfield: false,
+                is_global: true,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().rustified_enums,
+            item,
+        ) {
+            EnumVariation::Rust {
+                non_exhaustive: false,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().rustified_non_exhaustive_enums,
+            item,
+        ) {
+            EnumVariation::Rust {
+                non_exhaustive: true,
+            }
+        } else if self.is_matching_enum(
+            ctx,
+            &ctx.options().constified_enums,
+            item,
+        ) {
+            EnumVariation::Consts
+        } else {
+            ctx.options().default_enum_style
+        }
+    }
+}
+
+/// A single enum variant, to be contained only in an enum.
+#[derive(Debug)]
+pub struct EnumVariant {
+    /// The name of the variant.
+    name: String,
+
+    /// The original name of the variant (without user mangling)
+    name_for_allowlisting: String,
+
+    /// An optional doc comment.
+    comment: Option<String>,
+
+    /// The integer value of the variant.
+    val: EnumVariantValue,
+
+    /// The custom behavior this variant may have, if any.
+    custom_behavior: Option<EnumVariantCustomBehavior>,
+}
+
+/// A constant value assigned to an enumeration variant.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EnumVariantValue {
+    /// A boolean constant.
+    Boolean(bool),
+
+    /// A signed constant.
+    Signed(i64),
+
+    /// An unsigned constant.
+    Unsigned(u64),
+}
+
+impl EnumVariant {
+    /// Construct a new enumeration variant from the given parts.
+    pub fn new(
+        name: String,
+        name_for_allowlisting: String,
+        comment: Option<String>,
+        val: EnumVariantValue,
+        custom_behavior: Option<EnumVariantCustomBehavior>,
+    ) -> Self {
+        EnumVariant {
+            name,
+            name_for_allowlisting,
+            comment,
+            val,
+            custom_behavior,
+        }
+    }
+
+    /// Get this variant's name.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Get this variant's name.
+    pub fn name_for_allowlisting(&self) -> &str {
+        &self.name_for_allowlisting
+    }
+
+    /// Get this variant's value.
+    pub fn val(&self) -> EnumVariantValue {
+        self.val
+    }
+
+    /// Get this variant's documentation.
+    pub fn comment(&self) -> Option<&str> {
+        self.comment.as_deref()
+    }
+
+    /// Returns whether this variant should be enforced to be a constant by code
+    /// generation.
+    pub fn force_constification(&self) -> bool {
+        self.custom_behavior
+            .map_or(false, |b| b == EnumVariantCustomBehavior::Constify)
+    }
+
+    /// Returns whether the current variant should be hidden completely from the
+    /// resulting rust enum.
+    pub fn hidden(&self) -> bool {
+        self.custom_behavior
+            .map_or(false, |b| b == EnumVariantCustomBehavior::Hide)
+    }
+}
diff --git a/bindgen/ir/function.rs b/bindgen/ir/function.rs
new file mode 100644
index 00000000..928b5aad
--- /dev/null
+++ b/bindgen/ir/function.rs
@@ -0,0 +1,690 @@
+//! Intermediate representation for C/C++ functions and methods.
+
+use super::comp::MethodKind;
+use super::context::{BindgenContext, TypeId};
+use super::dot::DotAttributes;
+use super::item::Item;
+use super::traversal::{EdgeKind, Trace, Tracer};
+use super::ty::TypeKind;
+use crate::clang::{self, Attribute};
+use crate::parse::{
+    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
+};
+use clang_sys::{self, CXCallingConv};
+use proc_macro2;
+use quote;
+use quote::TokenStreamExt;
+use std::io;
+
+const RUST_DERIVE_FUNPTR_LIMIT: usize = 12;
+
+/// What kind of a function are we looking at?
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FunctionKind {
+    /// A plain, free function.
+    Function,
+    /// A method of some kind.
+    Method(MethodKind),
+}
+
+impl FunctionKind {
+    /// Given a clang cursor, return the kind of function it represents, or
+    /// `None` otherwise.
+    pub fn from_cursor(cursor: &clang::Cursor) -> Option<FunctionKind> {
+        // FIXME(emilio): Deduplicate logic with `ir::comp`.
+        Some(match cursor.kind() {
+            clang_sys::CXCursor_FunctionDecl => FunctionKind::Function,
+            clang_sys::CXCursor_Constructor => {
+                FunctionKind::Method(MethodKind::Constructor)
+            }
+            clang_sys::CXCursor_Destructor => {
+                FunctionKind::Method(if cursor.method_is_virtual() {
+                    MethodKind::VirtualDestructor {
+                        pure_virtual: cursor.method_is_pure_virtual(),
+                    }
+                } else {
+                    MethodKind::Destructor
+                })
+            }
+            clang_sys::CXCursor_CXXMethod => {
+                if cursor.method_is_virtual() {
+                    FunctionKind::Method(MethodKind::Virtual {
+                        pure_virtual: cursor.method_is_pure_virtual(),
+                    })
+                } else if cursor.method_is_static() {
+                    FunctionKind::Method(MethodKind::Static)
+                } else {
+                    FunctionKind::Method(MethodKind::Normal)
+                }
+            }
+            _ => return None,
+        })
+    }
+}
+
+/// The style of linkage
+#[derive(Debug, Clone, Copy)]
+pub enum Linkage {
+    /// Externally visible and can be linked against
+    External,
+    /// Not exposed externally. 'static inline' functions will have this kind of linkage
+    Internal,
+}
+
+/// A function declaration, with a signature, arguments, and argument names.
+///
+/// The argument names vector must be the same length as the ones in the
+/// signature.
+#[derive(Debug)]
+pub struct Function {
+    /// The name of this function.
+    name: String,
+
+    /// The mangled name, that is, the symbol.
+    mangled_name: Option<String>,
+
+    /// The id pointing to the current function signature.
+    signature: TypeId,
+
+    /// The doc comment on the function, if any.
+    comment: Option<String>,
+
+    /// The kind of function this is.
+    kind: FunctionKind,
+
+    /// The linkage of the function.
+    linkage: Linkage,
+}
+
+impl Function {
+    /// Construct a new function.
+    pub fn new(
+        name: String,
+        mangled_name: Option<String>,
+        signature: TypeId,
+        comment: Option<String>,
+        kind: FunctionKind,
+        linkage: Linkage,
+    ) -> Self {
+        Function {
+            name,
+            mangled_name,
+            signature,
+            comment,
+            kind,
+            linkage,
+        }
+    }
+
+    /// Get this function's name.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Get this function's name.
+    pub fn mangled_name(&self) -> Option<&str> {
+        self.mangled_name.as_deref()
+    }
+
+    /// Get this function's signature type.
+    pub fn signature(&self) -> TypeId {
+        self.signature
+    }
+
+    /// Get this function's comment.
+    pub fn comment(&self) -> Option<&str> {
+        self.comment.as_deref()
+    }
+
+    /// Get this function's kind.
+    pub fn kind(&self) -> FunctionKind {
+        self.kind
+    }
+
+    /// Get this function's linkage.
+    pub fn linkage(&self) -> Linkage {
+        self.linkage
+    }
+}
+
+impl DotAttributes for Function {
+    fn dot_attributes<W>(
+        &self,
+        _ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        if let Some(ref mangled) = self.mangled_name {
+            let mangled: String =
+                mangled.chars().flat_map(|c| c.escape_default()).collect();
+            writeln!(
+                out,
+                "<tr><td>mangled name</td><td>{}</td></tr>",
+                mangled
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+/// An ABI extracted from a clang cursor.
+#[derive(Debug, Copy, Clone)]
+pub enum Abi {
+    /// The default C ABI.
+    C,
+    /// The "stdcall" ABI.
+    Stdcall,
+    /// The "fastcall" ABI.
+    Fastcall,
+    /// The "thiscall" ABI.
+    ThisCall,
+    /// The "vectorcall" ABI.
+    Vectorcall,
+    /// The "aapcs" ABI.
+    Aapcs,
+    /// The "win64" ABI.
+    Win64,
+    /// An unknown or invalid ABI.
+    Unknown(CXCallingConv),
+}
+
+impl Abi {
+    /// Returns whether this Abi is known or not.
+    fn is_unknown(&self) -> bool {
+        matches!(*self, Abi::Unknown(..))
+    }
+}
+
+impl quote::ToTokens for Abi {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        tokens.append_all(match *self {
+            Abi::C => quote! { "C" },
+            Abi::Stdcall => quote! { "stdcall" },
+            Abi::Fastcall => quote! { "fastcall" },
+            Abi::ThisCall => quote! { "thiscall" },
+            Abi::Vectorcall => quote! { "vectorcall" },
+            Abi::Aapcs => quote! { "aapcs" },
+            Abi::Win64 => quote! { "win64" },
+            Abi::Unknown(cc) => panic!(
+                "Cannot turn unknown calling convention to tokens: {:?}",
+                cc
+            ),
+        });
+    }
+}
+
+/// A function signature.
+#[derive(Debug)]
+pub struct FunctionSig {
+    /// The return type of the function.
+    return_type: TypeId,
+
+    /// The type of the arguments, optionally with the name of the argument when
+    /// declared.
+    argument_types: Vec<(Option<String>, TypeId)>,
+
+    /// Whether this function is variadic.
+    is_variadic: bool,
+    is_divergent: bool,
+
+    /// Whether this function's return value must be used.
+    must_use: bool,
+
+    /// The ABI of this function.
+    abi: Abi,
+}
+
+fn get_abi(cc: CXCallingConv) -> Abi {
+    use clang_sys::*;
+    match cc {
+        CXCallingConv_Default => Abi::C,
+        CXCallingConv_C => Abi::C,
+        CXCallingConv_X86StdCall => Abi::Stdcall,
+        CXCallingConv_X86FastCall => Abi::Fastcall,
+        CXCallingConv_X86ThisCall => Abi::ThisCall,
+        CXCallingConv_X86VectorCall => Abi::Vectorcall,
+        CXCallingConv_AAPCS => Abi::Aapcs,
+        CXCallingConv_X86_64Win64 => Abi::Win64,
+        other => Abi::Unknown(other),
+    }
+}
+
+/// Get the mangled name for the cursor's referent.
+pub fn cursor_mangling(
+    ctx: &BindgenContext,
+    cursor: &clang::Cursor,
+) -> Option<String> {
+    if !ctx.options().enable_mangling {
+        return None;
+    }
+
+    // We early return here because libclang may crash in some case
+    // if we pass in a variable inside a partial specialized template.
+    // See rust-lang/rust-bindgen#67, and rust-lang/rust-bindgen#462.
+    if cursor.is_in_non_fully_specialized_template() {
+        return None;
+    }
+
+    let is_destructor = cursor.kind() == clang_sys::CXCursor_Destructor;
+    if let Ok(mut manglings) = cursor.cxx_manglings() {
+        while let Some(m) = manglings.pop() {
+            // Only generate the destructor group 1, see below.
+            if is_destructor && !m.ends_with("D1Ev") {
+                continue;
+            }
+
+            return Some(m);
+        }
+    }
+
+    let mut mangling = cursor.mangling();
+    if mangling.is_empty() {
+        return None;
+    }
+
+    if is_destructor {
+        // With old (3.8-) libclang versions, and the Itanium ABI, clang returns
+        // the "destructor group 0" symbol, which means that it'll try to free
+        // memory, which definitely isn't what we want.
+        //
+        // Explicitly force the destructor group 1 symbol.
+        //
+        // See http://refspecs.linuxbase.org/cxxabi-1.83.html#mangling-special
+        // for the reference, and http://stackoverflow.com/a/6614369/1091587 for
+        // a more friendly explanation.
+        //
+        // We don't need to do this for constructors since clang seems to always
+        // have returned the C1 constructor.
+        //
+        // FIXME(emilio): Can a legit symbol in other ABIs end with this string?
+        // I don't think so, but if it can this would become a linker error
+        // anyway, not an invalid free at runtime.
+        //
+        // TODO(emilio, #611): Use cpp_demangle if this becomes nastier with
+        // time.
+        if mangling.ends_with("D0Ev") {
+            let new_len = mangling.len() - 4;
+            mangling.truncate(new_len);
+            mangling.push_str("D1Ev");
+        }
+    }
+
+    Some(mangling)
+}
+
+fn args_from_ty_and_cursor(
+    ty: &clang::Type,
+    cursor: &clang::Cursor,
+    ctx: &mut BindgenContext,
+) -> Vec<(Option<String>, TypeId)> {
+    let cursor_args = cursor.args().unwrap_or_default().into_iter();
+    let type_args = ty.args().unwrap_or_default().into_iter();
+
+    // Argument types can be found in either the cursor or the type, but argument names may only be
+    // found on the cursor. We often have access to both a type and a cursor for each argument, but
+    // in some cases we may only have one.
+    //
+    // Prefer using the type as the source of truth for the argument's type, but fall back to
+    // inspecting the cursor (this happens for Objective C interfaces).
+    //
+    // Prefer using the cursor for the argument's type, but fall back to using the parent's cursor
+    // (this happens for function pointer return types).
+    cursor_args
+        .map(Some)
+        .chain(std::iter::repeat(None))
+        .zip(type_args.map(Some).chain(std::iter::repeat(None)))
+        .take_while(|(cur, ty)| cur.is_some() || ty.is_some())
+        .map(|(arg_cur, arg_ty)| {
+            let name = arg_cur.map(|a| a.spelling()).and_then(|name| {
+                if name.is_empty() {
+                    None
+                } else {
+                    Some(name)
+                }
+            });
+
+            let cursor = arg_cur.unwrap_or(*cursor);
+            let ty = arg_ty.unwrap_or_else(|| cursor.cur_type());
+            (name, Item::from_ty_or_ref(ty, cursor, None, ctx))
+        })
+        .collect()
+}
+
+impl FunctionSig {
+    /// Construct a new function signature.
+    pub fn new(
+        return_type: TypeId,
+        argument_types: Vec<(Option<String>, TypeId)>,
+        is_variadic: bool,
+        is_divergent: bool,
+        must_use: bool,
+        abi: Abi,
+    ) -> Self {
+        FunctionSig {
+            return_type,
+            argument_types,
+            is_variadic,
+            is_divergent,
+            must_use,
+            abi,
+        }
+    }
+
+    /// Construct a new function signature from the given Clang type.
+    pub fn from_ty(
+        ty: &clang::Type,
+        cursor: &clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Result<Self, ParseError> {
+        use clang_sys::*;
+        debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
+
+        // Skip function templates
+        let kind = cursor.kind();
+        if kind == CXCursor_FunctionTemplate {
+            return Err(ParseError::Continue);
+        }
+
+        let spelling = cursor.spelling();
+
+        // Don't parse operatorxx functions in C++
+        let is_operator = |spelling: &str| {
+            spelling.starts_with("operator") &&
+                !clang::is_valid_identifier(spelling)
+        };
+        if is_operator(&spelling) {
+            return Err(ParseError::Continue);
+        }
+
+        // Constructors of non-type template parameter classes for some reason
+        // include the template parameter in their name. Just skip them, since
+        // we don't handle well non-type template parameters anyway.
+        if (kind == CXCursor_Constructor || kind == CXCursor_Destructor) &&
+            spelling.contains('<')
+        {
+            return Err(ParseError::Continue);
+        }
+
+        let cursor = if cursor.is_valid() {
+            *cursor
+        } else {
+            ty.declaration()
+        };
+
+        let mut args = match kind {
+            CXCursor_FunctionDecl |
+            CXCursor_Constructor |
+            CXCursor_CXXMethod |
+            CXCursor_ObjCInstanceMethodDecl |
+            CXCursor_ObjCClassMethodDecl => {
+                args_from_ty_and_cursor(ty, &cursor, ctx)
+            }
+            _ => {
+                // For non-CXCursor_FunctionDecl, visiting the cursor's children
+                // is the only reliable way to get parameter names.
+                let mut args = vec![];
+                cursor.visit(|c| {
+                    if c.kind() == CXCursor_ParmDecl {
+                        let ty =
+                            Item::from_ty_or_ref(c.cur_type(), c, None, ctx);
+                        let name = c.spelling();
+                        let name =
+                            if name.is_empty() { None } else { Some(name) };
+                        args.push((name, ty));
+                    }
+                    CXChildVisit_Continue
+                });
+
+                if args.is_empty() {
+                    // FIXME(emilio): Sometimes libclang doesn't expose the
+                    // right AST for functions tagged as stdcall and such...
+                    //
+                    // https://bugs.llvm.org/show_bug.cgi?id=45919
+                    args_from_ty_and_cursor(ty, &cursor, ctx)
+                } else {
+                    args
+                }
+            }
+        };
+
+        let (must_use, mut is_divergent) =
+            if ctx.options().enable_function_attribute_detection {
+                let [must_use, no_return, no_return_cpp] = cursor.has_attrs(&[
+                    Attribute::MUST_USE,
+                    Attribute::NO_RETURN,
+                    Attribute::NO_RETURN_CPP,
+                ]);
+                (must_use, no_return || no_return_cpp)
+            } else {
+                Default::default()
+            };
+
+        // This looks easy to break but the clang parser keeps the type spelling clean even if
+        // other attributes are added.
+        is_divergent =
+            is_divergent || ty.spelling().contains("__attribute__((noreturn))");
+
+        let is_method = kind == CXCursor_CXXMethod;
+        let is_constructor = kind == CXCursor_Constructor;
+        let is_destructor = kind == CXCursor_Destructor;
+        if (is_constructor || is_destructor || is_method) &&
+            cursor.lexical_parent() != cursor.semantic_parent()
+        {
+            // Only parse constructors once.
+            return Err(ParseError::Continue);
+        }
+
+        if is_method || is_constructor || is_destructor {
+            let is_const = is_method && cursor.method_is_const();
+            let is_virtual = is_method && cursor.method_is_virtual();
+            let is_static = is_method && cursor.method_is_static();
+            if !is_static && !is_virtual {
+                let parent = cursor.semantic_parent();
+                let class = Item::parse(parent, None, ctx)
+                    .expect("Expected to parse the class");
+                // The `class` most likely is not finished parsing yet, so use
+                // the unchecked variant.
+                let class = class.as_type_id_unchecked();
+
+                let class = if is_const {
+                    let const_class_id = ctx.next_item_id();
+                    ctx.build_const_wrapper(
+                        const_class_id,
+                        class,
+                        None,
+                        &parent.cur_type(),
+                    )
+                } else {
+                    class
+                };
+
+                let ptr =
+                    Item::builtin_type(TypeKind::Pointer(class), false, ctx);
+                args.insert(0, (Some("this".into()), ptr));
+            } else if is_virtual {
+                let void = Item::builtin_type(TypeKind::Void, false, ctx);
+                let ptr =
+                    Item::builtin_type(TypeKind::Pointer(void), false, ctx);
+                args.insert(0, (Some("this".into()), ptr));
+            }
+        }
+
+        let ty_ret_type = if kind == CXCursor_ObjCInstanceMethodDecl ||
+            kind == CXCursor_ObjCClassMethodDecl
+        {
+            ty.ret_type()
+                .or_else(|| cursor.ret_type())
+                .ok_or(ParseError::Continue)?
+        } else {
+            ty.ret_type().ok_or(ParseError::Continue)?
+        };
+
+        let ret = if is_constructor && ctx.is_target_wasm32() {
+            // Constructors in Clang wasm32 target return a pointer to the object
+            // being constructed.
+            let void = Item::builtin_type(TypeKind::Void, false, ctx);
+            Item::builtin_type(TypeKind::Pointer(void), false, ctx)
+        } else {
+            Item::from_ty_or_ref(ty_ret_type, cursor, None, ctx)
+        };
+
+        // Clang plays with us at "find the calling convention", see #549 and
+        // co. This seems to be a better fix than that commit.
+        let mut call_conv = ty.call_conv();
+        if let Some(ty) = cursor.cur_type().canonical_type().pointee_type() {
+            let cursor_call_conv = ty.call_conv();
+            if cursor_call_conv != CXCallingConv_Invalid {
+                call_conv = cursor_call_conv;
+            }
+        }
+        let abi = get_abi(call_conv);
+
+        if abi.is_unknown() {
+            warn!("Unknown calling convention: {:?}", call_conv);
+        }
+
+        Ok(Self::new(
+            ret,
+            args,
+            ty.is_variadic(),
+            is_divergent,
+            must_use,
+            abi,
+        ))
+    }
+
+    /// Get this function signature's return type.
+    pub fn return_type(&self) -> TypeId {
+        self.return_type
+    }
+
+    /// Get this function signature's argument (name, type) pairs.
+    pub fn argument_types(&self) -> &[(Option<String>, TypeId)] {
+        &self.argument_types
+    }
+
+    /// Get this function signature's ABI.
+    pub fn abi(&self) -> Abi {
+        self.abi
+    }
+
+    /// Is this function signature variadic?
+    pub fn is_variadic(&self) -> bool {
+        // Clang reports some functions as variadic when they *might* be
+        // variadic. We do the argument check because rust doesn't codegen well
+        // variadic functions without an initial argument.
+        self.is_variadic && !self.argument_types.is_empty()
+    }
+
+    /// Must this function's return value be used?
+    pub fn must_use(&self) -> bool {
+        self.must_use
+    }
+
+    /// Are function pointers with this signature able to derive Rust traits?
+    /// Rust only supports deriving traits for function pointers with a limited
+    /// number of parameters and a couple ABIs.
+    ///
+    /// For more details, see:
+    ///
+    /// * https://github.com/rust-lang/rust-bindgen/issues/547,
+    /// * https://github.com/rust-lang/rust/issues/38848,
+    /// * and https://github.com/rust-lang/rust/issues/40158
+    pub fn function_pointers_can_derive(&self) -> bool {
+        if self.argument_types.len() > RUST_DERIVE_FUNPTR_LIMIT {
+            return false;
+        }
+
+        matches!(self.abi, Abi::C | Abi::Unknown(..))
+    }
+
+    pub(crate) fn is_divergent(&self) -> bool {
+        self.is_divergent
+    }
+}
+
+impl ClangSubItemParser for Function {
+    fn parse(
+        cursor: clang::Cursor,
+        context: &mut BindgenContext,
+    ) -> Result<ParseResult<Self>, ParseError> {
+        use clang_sys::*;
+
+        let kind = match FunctionKind::from_cursor(&cursor) {
+            None => return Err(ParseError::Continue),
+            Some(k) => k,
+        };
+
+        debug!("Function::parse({:?}, {:?})", cursor, cursor.cur_type());
+
+        let visibility = cursor.visibility();
+        if visibility != CXVisibility_Default {
+            return Err(ParseError::Continue);
+        }
+
+        if cursor.access_specifier() == CX_CXXPrivate {
+            return Err(ParseError::Continue);
+        }
+
+        if cursor.is_inlined_function() {
+            if !context.options().generate_inline_functions {
+                return Err(ParseError::Continue);
+            }
+            if cursor.is_deleted_function() {
+                return Err(ParseError::Continue);
+            }
+        }
+
+        let linkage = cursor.linkage();
+        let linkage = match linkage {
+            CXLinkage_External | CXLinkage_UniqueExternal => Linkage::External,
+            CXLinkage_Internal => Linkage::Internal,
+            _ => return Err(ParseError::Continue),
+        };
+
+        // Grab the signature using Item::from_ty.
+        let sig = Item::from_ty(&cursor.cur_type(), cursor, None, context)?;
+
+        let mut name = cursor.spelling();
+        assert!(!name.is_empty(), "Empty function name?");
+
+        if cursor.kind() == CXCursor_Destructor {
+            // Remove the leading `~`. The alternative to this is special-casing
+            // code-generation for destructor functions, which seems less than
+            // ideal.
+            if name.starts_with('~') {
+                name.remove(0);
+            }
+
+            // Add a suffix to avoid colliding with constructors. This would be
+            // technically fine (since we handle duplicated functions/methods),
+            // but seems easy enough to handle it here.
+            name.push_str("_destructor");
+        }
+
+        let mangled_name = cursor_mangling(context, &cursor);
+        let comment = cursor.raw_comment();
+
+        let function =
+            Self::new(name, mangled_name, sig, comment, kind, linkage);
+        Ok(ParseResult::New(function, Some(cursor)))
+    }
+}
+
+impl Trace for FunctionSig {
+    type Extra = ();
+
+    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
+    where
+        T: Tracer,
+    {
+        tracer.visit_kind(self.return_type().into(), EdgeKind::FunctionReturn);
+
+        for &(_, ty) in self.argument_types() {
+            tracer.visit_kind(ty.into(), EdgeKind::FunctionParameter);
+        }
+    }
+}
diff --git a/bindgen/ir/int.rs b/bindgen/ir/int.rs
new file mode 100644
index 00000000..22838e89
--- /dev/null
+++ b/bindgen/ir/int.rs
@@ -0,0 +1,127 @@
+//! Intermediate representation for integral types.
+
+/// Which integral type are we dealing with?
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum IntKind {
+    /// A `bool`.
+    Bool,
+
+    /// A `signed char`.
+    SChar,
+
+    /// An `unsigned char`.
+    UChar,
+
+    /// An `wchar_t`.
+    WChar,
+
+    /// A platform-dependent `char` type, with the signedness support.
+    Char {
+        /// Whether the char is signed for the target platform.
+        is_signed: bool,
+    },
+
+    /// A `short`.
+    Short,
+
+    /// An `unsigned short`.
+    UShort,
+
+    /// An `int`.
+    Int,
+
+    /// An `unsigned int`.
+    UInt,
+
+    /// A `long`.
+    Long,
+
+    /// An `unsigned long`.
+    ULong,
+
+    /// A `long long`.
+    LongLong,
+
+    /// An `unsigned long long`.
+    ULongLong,
+
+    /// A 8-bit signed integer.
+    I8,
+
+    /// A 8-bit unsigned integer.
+    U8,
+
+    /// A 16-bit signed integer.
+    I16,
+
+    /// Either a `char16_t` or a `wchar_t`.
+    U16,
+
+    /// A 32-bit signed integer.
+    I32,
+
+    /// A 32-bit unsigned integer.
+    U32,
+
+    /// A 64-bit signed integer.
+    I64,
+
+    /// A 64-bit unsigned integer.
+    U64,
+
+    /// An `int128_t`
+    I128,
+
+    /// A `uint128_t`.
+    U128,
+
+    /// A custom integer type, used to allow custom macro types depending on
+    /// range.
+    Custom {
+        /// The name of the type, which would be used without modification.
+        name: &'static str,
+        /// Whether the type is signed or not.
+        is_signed: bool,
+    },
+}
+
+impl IntKind {
+    /// Is this integral type signed?
+    pub fn is_signed(&self) -> bool {
+        use self::IntKind::*;
+        match *self {
+            // TODO(emilio): wchar_t can in theory be signed, but we have no way
+            // to know whether it is or not right now (unlike char, there's no
+            // WChar_S / WChar_U).
+            Bool | UChar | UShort | UInt | ULong | ULongLong | U8 | U16 |
+            WChar | U32 | U64 | U128 => false,
+
+            SChar | Short | Int | Long | LongLong | I8 | I16 | I32 | I64 |
+            I128 => true,
+
+            Char { is_signed } => is_signed,
+
+            Custom { is_signed, .. } => is_signed,
+        }
+    }
+
+    /// If this type has a known size, return it (in bytes). This is to
+    /// alleviate libclang sometimes not giving us a layout (like in the case
+    /// when an enum is defined inside a class with template parameters).
+    pub fn known_size(&self) -> Option<usize> {
+        use self::IntKind::*;
+        Some(match *self {
+            Bool | UChar | SChar | U8 | I8 | Char { .. } => 1,
+            U16 | I16 => 2,
+            U32 | I32 => 4,
+            U64 | I64 => 8,
+            I128 | U128 => 16,
+            _ => return None,
+        })
+    }
+
+    /// Whether this type's signedness matches the value.
+    pub fn signedness_matches(&self, val: i64) -> bool {
+        val >= 0 || self.is_signed()
+    }
+}
diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs
new file mode 100644
index 00000000..3b15cd6e
--- /dev/null
+++ b/bindgen/ir/item.rs
@@ -0,0 +1,2018 @@
+//! Bindgen's core intermediate representation type.
+
+use super::super::codegen::{EnumVariation, CONSTIFIED_ENUM_MODULE_REPR_NAME};
+use super::analysis::{HasVtable, HasVtableResult, Sizedness, SizednessResult};
+use super::annotations::Annotations;
+use super::comment;
+use super::comp::{CompKind, MethodKind};
+use super::context::{BindgenContext, ItemId, PartialType, TypeId};
+use super::derive::{
+    CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
+    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
+};
+use super::dot::DotAttributes;
+use super::function::{Function, FunctionKind};
+use super::item_kind::ItemKind;
+use super::layout::Opaque;
+use super::module::Module;
+use super::template::{AsTemplateParam, TemplateParameters};
+use super::traversal::{EdgeKind, Trace, Tracer};
+use super::ty::{Type, TypeKind};
+use crate::clang;
+use crate::parse::{
+    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
+};
+use clang_sys;
+use lazycell::LazyCell;
+use regex;
+use std::cell::Cell;
+use std::collections::BTreeSet;
+use std::fmt::Write;
+use std::io;
+use std::iter;
+
+/// A trait to get the canonical name from an item.
+///
+/// This is the trait that will eventually isolate all the logic related to name
+/// mangling and that kind of stuff.
+///
+/// This assumes no nested paths, at some point I'll have to make it a more
+/// complex thing.
+///
+/// This name is required to be safe for Rust, that is, is not expected to
+/// return any rust keyword from here.
+pub trait ItemCanonicalName {
+    /// Get the canonical name for this item.
+    fn canonical_name(&self, ctx: &BindgenContext) -> String;
+}
+
+/// The same, but specifies the path that needs to be followed to reach an item.
+///
+/// To contrast with canonical_name, here's an example:
+///
+/// ```c++
+/// namespace foo {
+///     const BAR = 3;
+/// }
+/// ```
+///
+/// For bar, the canonical path is `vec!["foo", "BAR"]`, while the canonical
+/// name is just `"BAR"`.
+pub trait ItemCanonicalPath {
+    /// Get the namespace-aware canonical path for this item. This means that if
+    /// namespaces are disabled, you'll get a single item, and otherwise you get
+    /// the whole path.
+    fn namespace_aware_canonical_path(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Vec<String>;
+
+    /// Get the canonical path for this item.
+    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String>;
+}
+
+/// A trait for determining if some IR thing is opaque or not.
+pub trait IsOpaque {
+    /// Extra context the IR thing needs to determine if it is opaque or not.
+    type Extra;
+
+    /// Returns `true` if the thing is opaque, and `false` otherwise.
+    ///
+    /// May only be called when `ctx` is in the codegen phase.
+    fn is_opaque(&self, ctx: &BindgenContext, extra: &Self::Extra) -> bool;
+}
+
+/// A trait for determining if some IR thing has type parameter in array or not.
+pub trait HasTypeParamInArray {
+    /// Returns `true` if the thing has Array, and `false` otherwise.
+    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait for determining if some IR thing has float or not.
+pub trait HasFloat {
+    /// Returns `true` if the thing has float, and `false` otherwise.
+    fn has_float(&self, ctx: &BindgenContext) -> bool;
+}
+
+/// A trait for iterating over an item and its parents and up its ancestor chain
+/// up to (but not including) the implicit root module.
+pub trait ItemAncestors {
+    /// Get an iterable over this item's ancestors.
+    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a>;
+}
+
+#[cfg(testing_only_extra_assertions)]
+type DebugOnlyItemSet = ItemSet;
+
+#[cfg(not(testing_only_extra_assertions))]
+struct DebugOnlyItemSet;
+
+#[cfg(not(testing_only_extra_assertions))]
+impl DebugOnlyItemSet {
+    fn new() -> Self {
+        DebugOnlyItemSet
+    }
+
+    fn contains(&self, _id: &ItemId) -> bool {
+        false
+    }
+
+    fn insert(&mut self, _id: ItemId) {}
+}
+
+/// An iterator over an item and its ancestors.
+pub struct ItemAncestorsIter<'a> {
+    item: ItemId,
+    ctx: &'a BindgenContext,
+    seen: DebugOnlyItemSet,
+}
+
+impl<'a> ItemAncestorsIter<'a> {
+    fn new<Id: Into<ItemId>>(ctx: &'a BindgenContext, id: Id) -> Self {
+        ItemAncestorsIter {
+            item: id.into(),
+            ctx,
+            seen: DebugOnlyItemSet::new(),
+        }
+    }
+}
+
+impl<'a> Iterator for ItemAncestorsIter<'a> {
+    type Item = ItemId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = self.ctx.resolve_item(self.item);
+
+        if item.parent_id() == self.item {
+            None
+        } else {
+            self.item = item.parent_id();
+
+            extra_assert!(!self.seen.contains(&item.id()));
+            self.seen.insert(item.id());
+
+            Some(item.id())
+        }
+    }
+}
+
+impl<T> AsTemplateParam for T
+where
+    T: Copy + Into<ItemId>,
+{
+    type Extra = ();
+
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> Option<TypeId> {
+        ctx.resolve_item((*self).into()).as_template_param(ctx, &())
+    }
+}
+
+impl AsTemplateParam for Item {
+    type Extra = ();
+
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        _: &(),
+    ) -> Option<TypeId> {
+        self.kind.as_template_param(ctx, self)
+    }
+}
+
+impl AsTemplateParam for ItemKind {
+    type Extra = Item;
+
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> Option<TypeId> {
+        match *self {
+            ItemKind::Type(ref ty) => ty.as_template_param(ctx, item),
+            ItemKind::Module(..) |
+            ItemKind::Function(..) |
+            ItemKind::Var(..) => None,
+        }
+    }
+}
+
+impl<T> ItemCanonicalName for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn canonical_name(&self, ctx: &BindgenContext) -> String {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.resolve_item(*self).canonical_name(ctx)
+    }
+}
+
+impl<T> ItemCanonicalPath for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn namespace_aware_canonical_path(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Vec<String> {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.resolve_item(*self).namespace_aware_canonical_path(ctx)
+    }
+
+    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.resolve_item(*self).canonical_path(ctx)
+    }
+}
+
+impl<T> ItemAncestors for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a> {
+        ItemAncestorsIter::new(ctx, *self)
+    }
+}
+
+impl ItemAncestors for Item {
+    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a> {
+        self.id().ancestors(ctx)
+    }
+}
+
+impl<Id> Trace for Id
+where
+    Id: Copy + Into<ItemId>,
+{
+    type Extra = ();
+
+    fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, extra: &())
+    where
+        T: Tracer,
+    {
+        ctx.resolve_item(*self).trace(ctx, tracer, extra);
+    }
+}
+
+impl Trace for Item {
+    type Extra = ();
+
+    fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, _extra: &())
+    where
+        T: Tracer,
+    {
+        // Even if this item is blocklisted/hidden, we want to trace it. It is
+        // traversal iterators' consumers' responsibility to filter items as
+        // needed. Generally, this filtering happens in the implementation of
+        // `Iterator` for `allowlistedItems`. Fully tracing blocklisted items is
+        // necessary for things like the template parameter usage analysis to
+        // function correctly.
+
+        match *self.kind() {
+            ItemKind::Type(ref ty) => {
+                // There are some types, like resolved type references, where we
+                // don't want to stop collecting types even though they may be
+                // opaque.
+                if ty.should_be_traced_unconditionally() ||
+                    !self.is_opaque(ctx, &())
+                {
+                    ty.trace(ctx, tracer, self);
+                }
+            }
+            ItemKind::Function(ref fun) => {
+                // Just the same way, it has not real meaning for a function to
+                // be opaque, so we trace across it.
+                tracer.visit(fun.signature().into());
+            }
+            ItemKind::Var(ref var) => {
+                tracer.visit_kind(var.ty().into(), EdgeKind::VarType);
+            }
+            ItemKind::Module(_) => {
+                // Module -> children edges are "weak", and we do not want to
+                // trace them. If we did, then allowlisting wouldn't work as
+                // expected: everything in every module would end up
+                // allowlisted.
+                //
+                // TODO: make a new edge kind for module -> children edges and
+                // filter them during allowlisting traversals.
+            }
+        }
+    }
+}
+
+impl CanDeriveDebug for Item {
+    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_debug(ctx)
+    }
+}
+
+impl CanDeriveDefault for Item {
+    fn can_derive_default(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_default(ctx)
+    }
+}
+
+impl CanDeriveCopy for Item {
+    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_copy(ctx)
+    }
+}
+
+impl CanDeriveHash for Item {
+    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_hash(ctx)
+    }
+}
+
+impl CanDerivePartialOrd for Item {
+    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_partialord(ctx)
+    }
+}
+
+impl CanDerivePartialEq for Item {
+    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_partialeq(ctx)
+    }
+}
+
+impl CanDeriveEq for Item {
+    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_eq(ctx)
+    }
+}
+
+impl CanDeriveOrd for Item {
+    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool {
+        self.id().can_derive_ord(ctx)
+    }
+}
+
+/// An item is the base of the bindgen representation, it can be either a
+/// module, a type, a function, or a variable (see `ItemKind` for more
+/// information).
+///
+/// Items refer to each other by `ItemId`. Every item has its parent's
+/// id. Depending on the kind of item this is, it may also refer to other items,
+/// such as a compound type item referring to other types. Collectively, these
+/// references form a graph.
+///
+/// The entry-point to this graph is the "root module": a meta-item used to hold
+/// all top-level items.
+///
+/// An item may have a comment, and annotations (see the `annotations` module).
+///
+/// Note that even though we parse all the types of annotations in comments, not
+/// all of them apply to every item. Those rules are described in the
+/// `annotations` module.
+#[derive(Debug)]
+pub struct Item {
+    /// This item's id.
+    id: ItemId,
+
+    /// The item's local id, unique only amongst its siblings. Only used for
+    /// anonymous items.
+    ///
+    /// Lazily initialized in local_id().
+    ///
+    /// Note that only structs, unions, and enums get a local type id. In any
+    /// case this is an implementation detail.
+    local_id: LazyCell<usize>,
+
+    /// The next local id to use for a child or template instantiation.
+    next_child_local_id: Cell<usize>,
+
+    /// A cached copy of the canonical name, as returned by `canonical_name`.
+    ///
+    /// This is a fairly used operation during codegen so this makes bindgen
+    /// considerably faster in those cases.
+    canonical_name: LazyCell<String>,
+
+    /// The path to use for allowlisting and other name-based checks, as
+    /// returned by `path_for_allowlisting`, lazily constructed.
+    path_for_allowlisting: LazyCell<Vec<String>>,
+
+    /// A doc comment over the item, if any.
+    comment: Option<String>,
+    /// Annotations extracted from the doc comment, or the default ones
+    /// otherwise.
+    annotations: Annotations,
+    /// An item's parent id. This will most likely be a class where this item
+    /// was declared, or a module, etc.
+    ///
+    /// All the items have a parent, except the root module, in which case the
+    /// parent id is its own id.
+    parent_id: ItemId,
+    /// The item kind.
+    kind: ItemKind,
+    /// The source location of the item.
+    location: Option<clang::SourceLocation>,
+}
+
+impl AsRef<ItemId> for Item {
+    fn as_ref(&self) -> &ItemId {
+        &self.id
+    }
+}
+
+impl Item {
+    /// Construct a new `Item`.
+    pub fn new(
+        id: ItemId,
+        comment: Option<String>,
+        annotations: Option<Annotations>,
+        parent_id: ItemId,
+        kind: ItemKind,
+        location: Option<clang::SourceLocation>,
+    ) -> Self {
+        debug_assert!(id != parent_id || kind.is_module());
+        Item {
+            id,
+            local_id: LazyCell::new(),
+            next_child_local_id: Cell::new(1),
+            canonical_name: LazyCell::new(),
+            path_for_allowlisting: LazyCell::new(),
+            parent_id,
+            comment,
+            annotations: annotations.unwrap_or_default(),
+            kind,
+            location,
+        }
+    }
+
+    /// Construct a new opaque item type.
+    pub fn new_opaque_type(
+        with_id: ItemId,
+        ty: &clang::Type,
+        ctx: &mut BindgenContext,
+    ) -> TypeId {
+        let location = ty.declaration().location();
+        let ty = Opaque::from_clang_ty(ty, ctx);
+        let kind = ItemKind::Type(ty);
+        let parent = ctx.root_module().into();
+        ctx.add_item(
+            Item::new(with_id, None, None, parent, kind, Some(location)),
+            None,
+            None,
+        );
+        with_id.as_type_id_unchecked()
+    }
+
+    /// Get this `Item`'s identifier.
+    pub fn id(&self) -> ItemId {
+        self.id
+    }
+
+    /// Get this `Item`'s parent's identifier.
+    ///
+    /// For the root module, the parent's ID is its own ID.
+    pub fn parent_id(&self) -> ItemId {
+        self.parent_id
+    }
+
+    /// Set this item's parent id.
+    ///
+    /// This is only used so replacements get generated in the proper module.
+    pub fn set_parent_for_replacement<Id: Into<ItemId>>(&mut self, id: Id) {
+        self.parent_id = id.into();
+    }
+
+    /// Returns the depth this item is indented to.
+    ///
+    /// FIXME(emilio): This may need fixes for the enums within modules stuff.
+    pub fn codegen_depth(&self, ctx: &BindgenContext) -> usize {
+        if !ctx.options().enable_cxx_namespaces {
+            return 0;
+        }
+
+        self.ancestors(ctx)
+            .filter(|id| {
+                ctx.resolve_item(*id).as_module().map_or(false, |module| {
+                    !module.is_inline() ||
+                        ctx.options().conservative_inline_namespaces
+                })
+            })
+            .count() +
+            1
+    }
+
+    /// Get this `Item`'s comment, if it has any, already preprocessed and with
+    /// the right indentation.
+    pub fn comment(&self, ctx: &BindgenContext) -> Option<String> {
+        if !ctx.options().generate_comments {
+            return None;
+        }
+
+        self.comment.as_ref().map(|comment| {
+            comment::preprocess(comment, self.codegen_depth(ctx))
+        })
+    }
+
+    /// What kind of item is this?
+    pub fn kind(&self) -> &ItemKind {
+        &self.kind
+    }
+
+    /// Get a mutable reference to this item's kind.
+    pub fn kind_mut(&mut self) -> &mut ItemKind {
+        &mut self.kind
+    }
+
+    /// Where in the source is this item located?
+    pub fn location(&self) -> Option<&clang::SourceLocation> {
+        self.location.as_ref()
+    }
+
+    /// Get an identifier that differentiates this item from its siblings.
+    ///
+    /// This should stay relatively stable in the face of code motion outside or
+    /// below this item's lexical scope, meaning that this can be useful for
+    /// generating relatively stable identifiers within a scope.
+    pub fn local_id(&self, ctx: &BindgenContext) -> usize {
+        *self.local_id.borrow_with(|| {
+            let parent = ctx.resolve_item(self.parent_id);
+            parent.next_child_local_id()
+        })
+    }
+
+    /// Get an identifier that differentiates a child of this item of other
+    /// related items.
+    ///
+    /// This is currently used for anonymous items, and template instantiation
+    /// tests, in both cases in order to reduce noise when system headers are at
+    /// place.
+    pub fn next_child_local_id(&self) -> usize {
+        let local_id = self.next_child_local_id.get();
+        self.next_child_local_id.set(local_id + 1);
+        local_id
+    }
+
+    /// Returns whether this item is a top-level item, from the point of view of
+    /// bindgen.
+    ///
+    /// This point of view changes depending on whether namespaces are enabled
+    /// or not. That way, in the following example:
+    ///
+    /// ```c++
+    /// namespace foo {
+    ///     static int var;
+    /// }
+    /// ```
+    ///
+    /// `var` would be a toplevel item if namespaces are disabled, but won't if
+    /// they aren't.
+    ///
+    /// This function is used to determine when the codegen phase should call
+    /// `codegen` on an item, since any item that is not top-level will be
+    /// generated by its parent.
+    pub fn is_toplevel(&self, ctx: &BindgenContext) -> bool {
+        // FIXME: Workaround for some types falling behind when parsing weird
+        // stl classes, for example.
+        if ctx.options().enable_cxx_namespaces &&
+            self.kind().is_module() &&
+            self.id() != ctx.root_module()
+        {
+            return false;
+        }
+
+        let mut parent = self.parent_id;
+        loop {
+            let parent_item = match ctx.resolve_item_fallible(parent) {
+                Some(item) => item,
+                None => return false,
+            };
+
+            if parent_item.id() == ctx.root_module() {
+                return true;
+            } else if ctx.options().enable_cxx_namespaces ||
+                !parent_item.kind().is_module()
+            {
+                return false;
+            }
+
+            parent = parent_item.parent_id();
+        }
+    }
+
+    /// Get a reference to this item's underlying `Type`. Panic if this is some
+    /// other kind of item.
+    pub fn expect_type(&self) -> &Type {
+        self.kind().expect_type()
+    }
+
+    /// Get a reference to this item's underlying `Type`, or `None` if this is
+    /// some other kind of item.
+    pub fn as_type(&self) -> Option<&Type> {
+        self.kind().as_type()
+    }
+
+    /// Get a reference to this item's underlying `Function`. Panic if this is
+    /// some other kind of item.
+    pub fn expect_function(&self) -> &Function {
+        self.kind().expect_function()
+    }
+
+    /// Is this item a module?
+    pub fn is_module(&self) -> bool {
+        matches!(self.kind, ItemKind::Module(..))
+    }
+
+    /// Get this item's annotations.
+    pub fn annotations(&self) -> &Annotations {
+        &self.annotations
+    }
+
+    /// Whether this item should be blocklisted.
+    ///
+    /// This may be due to either annotations or to other kind of configuration.
+    pub fn is_blocklisted(&self, ctx: &BindgenContext) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        if self.annotations.hide() {
+            return true;
+        }
+
+        if !ctx.options().blocklisted_files.is_empty() {
+            if let Some(location) = &self.location {
+                let (file, _, _, _) = location.location();
+                if let Some(filename) = file.name() {
+                    if ctx.options().blocklisted_files.matches(&filename) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        let path = self.path_for_allowlisting(ctx);
+        let name = path[1..].join("::");
+        ctx.options().blocklisted_items.matches(&name) ||
+            match self.kind {
+                ItemKind::Type(..) => {
+                    ctx.options().blocklisted_types.matches(&name) ||
+                        ctx.is_replaced_type(path, self.id)
+                }
+                ItemKind::Function(..) => {
+                    ctx.options().blocklisted_functions.matches(&name)
+                }
+                // TODO: Add constant / namespace blocklisting?
+                ItemKind::Var(..) | ItemKind::Module(..) => false,
+            }
+    }
+
+    /// Is this a reference to another type?
+    pub fn is_type_ref(&self) -> bool {
+        self.as_type().map_or(false, |ty| ty.is_type_ref())
+    }
+
+    /// Is this item a var type?
+    pub fn is_var(&self) -> bool {
+        matches!(*self.kind(), ItemKind::Var(..))
+    }
+
+    /// Take out item NameOptions
+    pub fn name<'a>(&'a self, ctx: &'a BindgenContext) -> NameOptions<'a> {
+        NameOptions::new(self, ctx)
+    }
+
+    /// Get the target item id for name generation.
+    fn name_target(&self, ctx: &BindgenContext) -> ItemId {
+        let mut targets_seen = DebugOnlyItemSet::new();
+        let mut item = self;
+
+        loop {
+            extra_assert!(!targets_seen.contains(&item.id()));
+            targets_seen.insert(item.id());
+
+            if self.annotations().use_instead_of().is_some() {
+                return self.id();
+            }
+
+            match *item.kind() {
+                ItemKind::Type(ref ty) => match *ty.kind() {
+                    TypeKind::ResolvedTypeRef(inner) => {
+                        item = ctx.resolve_item(inner);
+                    }
+                    TypeKind::TemplateInstantiation(ref inst) => {
+                        item = ctx.resolve_item(inst.template_definition());
+                    }
+                    _ => return item.id(),
+                },
+                _ => return item.id(),
+            }
+        }
+    }
+
+    /// Create a fully disambiguated name for an item, including template
+    /// parameters if it is a type
+    pub fn full_disambiguated_name(&self, ctx: &BindgenContext) -> String {
+        let mut s = String::new();
+        let level = 0;
+        self.push_disambiguated_name(ctx, &mut s, level);
+        s
+    }
+
+    /// Helper function for full_disambiguated_name
+    fn push_disambiguated_name(
+        &self,
+        ctx: &BindgenContext,
+        to: &mut String,
+        level: u8,
+    ) {
+        to.push_str(&self.canonical_name(ctx));
+        if let ItemKind::Type(ref ty) = *self.kind() {
+            if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() {
+                to.push_str(&format!("_open{}_", level));
+                for arg in inst.template_arguments() {
+                    arg.into_resolver()
+                        .through_type_refs()
+                        .resolve(ctx)
+                        .push_disambiguated_name(ctx, to, level + 1);
+                    to.push('_');
+                }
+                to.push_str(&format!("close{}", level));
+            }
+        }
+    }
+
+    /// Get this function item's name, or `None` if this item is not a function.
+    fn func_name(&self) -> Option<&str> {
+        match *self.kind() {
+            ItemKind::Function(ref func) => Some(func.name()),
+            _ => None,
+        }
+    }
+
+    /// Get the overload index for this method. If this is not a method, return
+    /// `None`.
+    fn overload_index(&self, ctx: &BindgenContext) -> Option<usize> {
+        self.func_name().and_then(|func_name| {
+            let parent = ctx.resolve_item(self.parent_id());
+            if let ItemKind::Type(ref ty) = *parent.kind() {
+                if let TypeKind::Comp(ref ci) = *ty.kind() {
+                    // All the constructors have the same name, so no need to
+                    // resolve and check.
+                    return ci
+                        .constructors()
+                        .iter()
+                        .position(|c| *c == self.id())
+                        .or_else(|| {
+                            ci.methods()
+                                .iter()
+                                .filter(|m| {
+                                    let item = ctx.resolve_item(m.signature());
+                                    let func = item.expect_function();
+                                    func.name() == func_name
+                                })
+                                .position(|m| m.signature() == self.id())
+                        });
+                }
+            }
+
+            None
+        })
+    }
+
+    /// Get this item's base name (aka non-namespaced name).
+    fn base_name(&self, ctx: &BindgenContext) -> String {
+        if let Some(path) = self.annotations().use_instead_of() {
+            return path.last().unwrap().clone();
+        }
+
+        match *self.kind() {
+            ItemKind::Var(ref var) => var.name().to_owned(),
+            ItemKind::Module(ref module) => {
+                module.name().map(ToOwned::to_owned).unwrap_or_else(|| {
+                    format!("_bindgen_mod_{}", self.exposed_id(ctx))
+                })
+            }
+            ItemKind::Type(ref ty) => {
+                ty.sanitized_name(ctx).map(Into::into).unwrap_or_else(|| {
+                    format!("_bindgen_ty_{}", self.exposed_id(ctx))
+                })
+            }
+            ItemKind::Function(ref fun) => {
+                let mut name = fun.name().to_owned();
+
+                if let Some(idx) = self.overload_index(ctx) {
+                    if idx > 0 {
+                        write!(&mut name, "{}", idx).unwrap();
+                    }
+                }
+
+                name
+            }
+        }
+    }
+
+    fn is_anon(&self) -> bool {
+        match self.kind() {
+            ItemKind::Module(module) => module.name().is_none(),
+            ItemKind::Type(ty) => ty.name().is_none(),
+            ItemKind::Function(_) => false,
+            ItemKind::Var(_) => false,
+        }
+    }
+
+    /// Get the canonical name without taking into account the replaces
+    /// annotation.
+    ///
+    /// This is the base logic used to implement hiding and replacing via
+    /// annotations, and also to implement proper name mangling.
+    ///
+    /// The idea is that each generated type in the same "level" (read: module
+    /// or namespace) has a unique canonical name.
+    ///
+    /// This name should be derived from the immutable state contained in the
+    /// type and the parent chain, since it should be consistent.
+    ///
+    /// If `BindgenOptions::disable_nested_struct_naming` is true then returned
+    /// name is the inner most non-anonymous name plus all the anonymous base names
+    /// that follows.
+    pub fn real_canonical_name(
+        &self,
+        ctx: &BindgenContext,
+        opt: &NameOptions,
+    ) -> String {
+        let target = ctx.resolve_item(self.name_target(ctx));
+
+        // Short-circuit if the target has an override, and just use that.
+        if let Some(path) = target.annotations.use_instead_of() {
+            if ctx.options().enable_cxx_namespaces {
+                return path.last().unwrap().clone();
+            }
+            return path.join("_");
+        }
+
+        let base_name = target.base_name(ctx);
+
+        // Named template type arguments are never namespaced, and never
+        // mangled.
+        if target.is_template_param(ctx, &()) {
+            return base_name;
+        }
+
+        // Ancestors' id iter
+        let mut ids_iter = target
+            .parent_id()
+            .ancestors(ctx)
+            .filter(|id| *id != ctx.root_module())
+            .take_while(|id| {
+                // Stop iterating ancestors once we reach a non-inline namespace
+                // when opt.within_namespaces is set.
+                !opt.within_namespaces || !ctx.resolve_item(*id).is_module()
+            })
+            .filter(|id| {
+                if !ctx.options().conservative_inline_namespaces {
+                    if let ItemKind::Module(ref module) =
+                        *ctx.resolve_item(*id).kind()
+                    {
+                        return !module.is_inline();
+                    }
+                }
+
+                true
+            });
+
+        let ids: Vec<_> = if ctx.options().disable_nested_struct_naming {
+            let mut ids = Vec::new();
+
+            // If target is anonymous we need find its first named ancestor.
+            if target.is_anon() {
+                for id in ids_iter.by_ref() {
+                    ids.push(id);
+
+                    if !ctx.resolve_item(id).is_anon() {
+                        break;
+                    }
+                }
+            }
+
+            ids
+        } else {
+            ids_iter.collect()
+        };
+
+        // Concatenate this item's ancestors' names together.
+        let mut names: Vec<_> = ids
+            .into_iter()
+            .map(|id| {
+                let item = ctx.resolve_item(id);
+                let target = ctx.resolve_item(item.name_target(ctx));
+                target.base_name(ctx)
+            })
+            .filter(|name| !name.is_empty())
+            .collect();
+
+        names.reverse();
+
+        if !base_name.is_empty() {
+            names.push(base_name);
+        }
+
+        if ctx.options().c_naming {
+            if let Some(prefix) = self.c_naming_prefix() {
+                names.insert(0, prefix.to_string());
+            }
+        }
+
+        let name = names.join("_");
+
+        let name = if opt.user_mangled == UserMangled::Yes {
+            ctx.parse_callbacks()
+                .and_then(|callbacks| callbacks.item_name(&name))
+                .unwrap_or(name)
+        } else {
+            name
+        };
+
+        ctx.rust_mangle(&name).into_owned()
+    }
+
+    /// The exposed id that represents an unique id among the siblings of a
+    /// given item.
+    pub fn exposed_id(&self, ctx: &BindgenContext) -> String {
+        // Only use local ids for enums, classes, structs and union types.  All
+        // other items use their global id.
+        let ty_kind = self.kind().as_type().map(|t| t.kind());
+        if let Some(ty_kind) = ty_kind {
+            match *ty_kind {
+                TypeKind::Comp(..) |
+                TypeKind::TemplateInstantiation(..) |
+                TypeKind::Enum(..) => return self.local_id(ctx).to_string(),
+                _ => {}
+            }
+        }
+
+        // Note that this `id_` prefix prevents (really unlikely) collisions
+        // between the global id and the local id of an item with the same
+        // parent.
+        format!("id_{}", self.id().as_usize())
+    }
+
+    /// Get a reference to this item's `Module`, or `None` if this is not a
+    /// `Module` item.
+    pub fn as_module(&self) -> Option<&Module> {
+        match self.kind {
+            ItemKind::Module(ref module) => Some(module),
+            _ => None,
+        }
+    }
+
+    /// Get a mutable reference to this item's `Module`, or `None` if this is
+    /// not a `Module` item.
+    pub fn as_module_mut(&mut self) -> Option<&mut Module> {
+        match self.kind {
+            ItemKind::Module(ref mut module) => Some(module),
+            _ => None,
+        }
+    }
+
+    /// Returns whether the item is a constified module enum
+    fn is_constified_enum_module(&self, ctx: &BindgenContext) -> bool {
+        // Do not jump through aliases, except for aliases that point to a type
+        // with the same name, since we dont generate coe for them.
+        let item = self.id.into_resolver().through_type_refs().resolve(ctx);
+        let type_ = match *item.kind() {
+            ItemKind::Type(ref type_) => type_,
+            _ => return false,
+        };
+
+        match *type_.kind() {
+            TypeKind::Enum(ref enum_) => {
+                enum_.computed_enum_variation(ctx, self) ==
+                    EnumVariation::ModuleConsts
+            }
+            TypeKind::Alias(inner_id) => {
+                // TODO(emilio): Make this "hop through type aliases that aren't
+                // really generated" an option in `ItemResolver`?
+                let inner_item = ctx.resolve_item(inner_id);
+                let name = item.canonical_name(ctx);
+
+                if inner_item.canonical_name(ctx) == name {
+                    inner_item.is_constified_enum_module(ctx)
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        }
+    }
+
+    /// Is this item of a kind that is enabled for code generation?
+    pub fn is_enabled_for_codegen(&self, ctx: &BindgenContext) -> bool {
+        let cc = &ctx.options().codegen_config;
+        match *self.kind() {
+            ItemKind::Module(..) => true,
+            ItemKind::Var(_) => cc.vars(),
+            ItemKind::Type(_) => cc.types(),
+            ItemKind::Function(ref f) => match f.kind() {
+                FunctionKind::Function => cc.functions(),
+                FunctionKind::Method(MethodKind::Constructor) => {
+                    cc.constructors()
+                }
+                FunctionKind::Method(MethodKind::Destructor) |
+                FunctionKind::Method(MethodKind::VirtualDestructor {
+                    ..
+                }) => cc.destructors(),
+                FunctionKind::Method(MethodKind::Static) |
+                FunctionKind::Method(MethodKind::Normal) |
+                FunctionKind::Method(MethodKind::Virtual { .. }) => {
+                    cc.methods()
+                }
+            },
+        }
+    }
+
+    /// Returns the path we should use for allowlisting / blocklisting, which
+    /// doesn't include user-mangling.
+    pub fn path_for_allowlisting(&self, ctx: &BindgenContext) -> &Vec<String> {
+        self.path_for_allowlisting
+            .borrow_with(|| self.compute_path(ctx, UserMangled::No))
+    }
+
+    fn compute_path(
+        &self,
+        ctx: &BindgenContext,
+        mangled: UserMangled,
+    ) -> Vec<String> {
+        if let Some(path) = self.annotations().use_instead_of() {
+            let mut ret =
+                vec![ctx.resolve_item(ctx.root_module()).name(ctx).get()];
+            ret.extend_from_slice(path);
+            return ret;
+        }
+
+        let target = ctx.resolve_item(self.name_target(ctx));
+        let mut path: Vec<_> = target
+            .ancestors(ctx)
+            .chain(iter::once(ctx.root_module().into()))
+            .map(|id| ctx.resolve_item(id))
+            .filter(|item| {
+                item.id() == target.id() ||
+                    item.as_module().map_or(false, |module| {
+                        !module.is_inline() ||
+                            ctx.options().conservative_inline_namespaces
+                    })
+            })
+            .map(|item| {
+                ctx.resolve_item(item.name_target(ctx))
+                    .name(ctx)
+                    .within_namespaces()
+                    .user_mangled(mangled)
+                    .get()
+            })
+            .collect();
+        path.reverse();
+        path
+    }
+
+    /// Returns a prefix for the canonical name when C naming is enabled.
+    fn c_naming_prefix(&self) -> Option<&str> {
+        let ty = match self.kind {
+            ItemKind::Type(ref ty) => ty,
+            _ => return None,
+        };
+
+        Some(match ty.kind() {
+            TypeKind::Comp(ref ci) => match ci.kind() {
+                CompKind::Struct => "struct",
+                CompKind::Union => "union",
+            },
+            TypeKind::Enum(..) => "enum",
+            _ => return None,
+        })
+    }
+
+    /// Whether this is a #[must_use] type.
+    pub fn must_use(&self, ctx: &BindgenContext) -> bool {
+        self.annotations().must_use_type() || ctx.must_use_type_by_name(self)
+    }
+}
+
+impl<T> IsOpaque for T
+where
+    T: Copy + Into<ItemId>,
+{
+    type Extra = ();
+
+    fn is_opaque(&self, ctx: &BindgenContext, _: &()) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.resolve_item((*self).into()).is_opaque(ctx, &())
+    }
+}
+
+impl IsOpaque for Item {
+    type Extra = ();
+
+    fn is_opaque(&self, ctx: &BindgenContext, _: &()) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        self.annotations.opaque() ||
+            self.as_type().map_or(false, |ty| ty.is_opaque(ctx, self)) ||
+            ctx.opaque_by_name(self.path_for_allowlisting(ctx))
+    }
+}
+
+impl<T> HasVtable for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn has_vtable(&self, ctx: &BindgenContext) -> bool {
+        let id: ItemId = (*self).into();
+        id.as_type_id(ctx).map_or(false, |id| {
+            !matches!(ctx.lookup_has_vtable(id), HasVtableResult::No)
+        })
+    }
+
+    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool {
+        let id: ItemId = (*self).into();
+        id.as_type_id(ctx).map_or(false, |id| {
+            matches!(ctx.lookup_has_vtable(id), HasVtableResult::SelfHasVtable)
+        })
+    }
+}
+
+impl HasVtable for Item {
+    fn has_vtable(&self, ctx: &BindgenContext) -> bool {
+        self.id().has_vtable(ctx)
+    }
+
+    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool {
+        self.id().has_vtable_ptr(ctx)
+    }
+}
+
+impl<T> Sizedness for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult {
+        let id: ItemId = (*self).into();
+        id.as_type_id(ctx)
+            .map_or(SizednessResult::default(), |id| ctx.lookup_sizedness(id))
+    }
+}
+
+impl Sizedness for Item {
+    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult {
+        self.id().sizedness(ctx)
+    }
+}
+
+impl<T> HasTypeParamInArray for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.lookup_has_type_param_in_array(*self)
+    }
+}
+
+impl HasTypeParamInArray for Item {
+    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.lookup_has_type_param_in_array(self.id())
+    }
+}
+
+impl<T> HasFloat for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn has_float(&self, ctx: &BindgenContext) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.lookup_has_float(*self)
+    }
+}
+
+impl HasFloat for Item {
+    fn has_float(&self, ctx: &BindgenContext) -> bool {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        ctx.lookup_has_float(self.id())
+    }
+}
+
+/// A set of items.
+pub type ItemSet = BTreeSet<ItemId>;
+
+impl DotAttributes for Item {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(
+            out,
+            "<tr><td>{:?}</td></tr>
+                       <tr><td>name</td><td>{}</td></tr>",
+            self.id,
+            self.name(ctx).get()
+        )?;
+
+        if self.is_opaque(ctx, &()) {
+            writeln!(out, "<tr><td>opaque</td><td>true</td></tr>")?;
+        }
+
+        self.kind.dot_attributes(ctx, out)
+    }
+}
+
+impl<T> TemplateParameters for T
+where
+    T: Copy + Into<ItemId>,
+{
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
+        ctx.resolve_item_fallible(*self)
+            .map_or(vec![], |item| item.self_template_params(ctx))
+    }
+}
+
+impl TemplateParameters for Item {
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
+        self.kind.self_template_params(ctx)
+    }
+}
+
+impl TemplateParameters for ItemKind {
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
+        match *self {
+            ItemKind::Type(ref ty) => ty.self_template_params(ctx),
+            // If we start emitting bindings to explicitly instantiated
+            // functions, then we'll need to check ItemKind::Function for
+            // template params.
+            ItemKind::Function(_) | ItemKind::Module(_) | ItemKind::Var(_) => {
+                vec![]
+            }
+        }
+    }
+}
+
+// An utility function to handle recursing inside nested types.
+fn visit_child(
+    cur: clang::Cursor,
+    id: ItemId,
+    ty: &clang::Type,
+    parent_id: Option<ItemId>,
+    ctx: &mut BindgenContext,
+    result: &mut Result<TypeId, ParseError>,
+) -> clang_sys::CXChildVisitResult {
+    use clang_sys::*;
+    if result.is_ok() {
+        return CXChildVisit_Break;
+    }
+
+    *result = Item::from_ty_with_id(id, ty, cur, parent_id, ctx);
+
+    match *result {
+        Ok(..) => CXChildVisit_Break,
+        Err(ParseError::Recurse) => {
+            cur.visit(|c| visit_child(c, id, ty, parent_id, ctx, result));
+            CXChildVisit_Continue
+        }
+        Err(ParseError::Continue) => CXChildVisit_Continue,
+    }
+}
+
+impl ClangItemParser for Item {
+    fn builtin_type(
+        kind: TypeKind,
+        is_const: bool,
+        ctx: &mut BindgenContext,
+    ) -> TypeId {
+        // Feel free to add more here, I'm just lazy.
+        match kind {
+            TypeKind::Void |
+            TypeKind::Int(..) |
+            TypeKind::Pointer(..) |
+            TypeKind::Float(..) => {}
+            _ => panic!("Unsupported builtin type"),
+        }
+
+        let ty = Type::new(None, None, kind, is_const);
+        let id = ctx.next_item_id();
+        let module = ctx.root_module().into();
+        ctx.add_item(
+            Item::new(id, None, None, module, ItemKind::Type(ty), None),
+            None,
+            None,
+        );
+        id.as_type_id_unchecked()
+    }
+
+    fn parse(
+        cursor: clang::Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<ItemId, ParseError> {
+        use crate::ir::var::Var;
+        use clang_sys::*;
+
+        if !cursor.is_valid() {
+            return Err(ParseError::Continue);
+        }
+
+        let comment = cursor.raw_comment();
+        let annotations = Annotations::new(&cursor);
+
+        let current_module = ctx.current_module().into();
+        let relevant_parent_id = parent_id.unwrap_or(current_module);
+
+        macro_rules! try_parse {
+            ($what:ident) => {
+                match $what::parse(cursor, ctx) {
+                    Ok(ParseResult::New(item, declaration)) => {
+                        let id = ctx.next_item_id();
+
+                        ctx.add_item(
+                            Item::new(
+                                id,
+                                comment,
+                                annotations,
+                                relevant_parent_id,
+                                ItemKind::$what(item),
+                                Some(cursor.location()),
+                            ),
+                            declaration,
+                            Some(cursor),
+                        );
+                        return Ok(id);
+                    }
+                    Ok(ParseResult::AlreadyResolved(id)) => {
+                        return Ok(id);
+                    }
+                    Err(ParseError::Recurse) => return Err(ParseError::Recurse),
+                    Err(ParseError::Continue) => {}
+                }
+            };
+        }
+
+        try_parse!(Module);
+
+        // NOTE: Is extremely important to parse functions and vars **before**
+        // types.  Otherwise we can parse a function declaration as a type
+        // (which is legal), and lose functions to generate.
+        //
+        // In general, I'm not totally confident this split between
+        // ItemKind::Function and TypeKind::FunctionSig is totally worth it, but
+        // I guess we can try.
+        try_parse!(Function);
+        try_parse!(Var);
+
+        // Types are sort of special, so to avoid parsing template classes
+        // twice, handle them separately.
+        {
+            let definition = cursor.definition();
+            let applicable_cursor = definition.unwrap_or(cursor);
+
+            let relevant_parent_id = match definition {
+                Some(definition) => {
+                    if definition != cursor {
+                        ctx.add_semantic_parent(definition, relevant_parent_id);
+                        return Ok(Item::from_ty_or_ref(
+                            applicable_cursor.cur_type(),
+                            cursor,
+                            parent_id,
+                            ctx,
+                        )
+                        .into());
+                    }
+                    ctx.known_semantic_parent(definition)
+                        .or(parent_id)
+                        .unwrap_or_else(|| ctx.current_module().into())
+                }
+                None => relevant_parent_id,
+            };
+
+            match Item::from_ty(
+                &applicable_cursor.cur_type(),
+                applicable_cursor,
+                Some(relevant_parent_id),
+                ctx,
+            ) {
+                Ok(ty) => return Ok(ty.into()),
+                Err(ParseError::Recurse) => return Err(ParseError::Recurse),
+                Err(ParseError::Continue) => {}
+            }
+        }
+
+        // Guess how does clang treat extern "C" blocks?
+        if cursor.kind() == CXCursor_UnexposedDecl {
+            Err(ParseError::Recurse)
+        } else {
+            // We allowlist cursors here known to be unhandled, to prevent being
+            // too noisy about this.
+            match cursor.kind() {
+                CXCursor_MacroDefinition |
+                CXCursor_MacroExpansion |
+                CXCursor_UsingDeclaration |
+                CXCursor_UsingDirective |
+                CXCursor_StaticAssert |
+                CXCursor_FunctionTemplate => {
+                    debug!(
+                        "Unhandled cursor kind {:?}: {:?}",
+                        cursor.kind(),
+                        cursor
+                    );
+                }
+                CXCursor_InclusionDirective => {
+                    let file = cursor.get_included_file_name();
+                    match file {
+                        None => {
+                            warn!(
+                                "Inclusion of a nameless file in {:?}",
+                                cursor
+                            );
+                        }
+                        Some(filename) => {
+                            ctx.include_file(filename);
+                        }
+                    }
+                }
+                _ => {
+                    // ignore toplevel operator overloads
+                    let spelling = cursor.spelling();
+                    if !spelling.starts_with("operator") {
+                        warn!(
+                            "Unhandled cursor kind {:?}: {:?}",
+                            cursor.kind(),
+                            cursor
+                        );
+                    }
+                }
+            }
+
+            Err(ParseError::Continue)
+        }
+    }
+
+    fn from_ty_or_ref(
+        ty: clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> TypeId {
+        let id = ctx.next_item_id();
+        Self::from_ty_or_ref_with_id(id, ty, location, parent_id, ctx)
+    }
+
+    /// Parse a C++ type. If we find a reference to a type that has not been
+    /// defined yet, use `UnresolvedTypeRef` as a placeholder.
+    ///
+    /// This logic is needed to avoid parsing items with the incorrect parent
+    /// and it's sort of complex to explain, so I'll just point to
+    /// `tests/headers/typeref.hpp` to see the kind of constructs that forced
+    /// this.
+    ///
+    /// Typerefs are resolved once parsing is completely done, see
+    /// `BindgenContext::resolve_typerefs`.
+    fn from_ty_or_ref_with_id(
+        potential_id: ItemId,
+        ty: clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> TypeId {
+        debug!(
+            "from_ty_or_ref_with_id: {:?} {:?}, {:?}, {:?}",
+            potential_id, ty, location, parent_id
+        );
+
+        if ctx.collected_typerefs() {
+            debug!("refs already collected, resolving directly");
+            return Item::from_ty_with_id(
+                potential_id,
+                &ty,
+                location,
+                parent_id,
+                ctx,
+            )
+            .unwrap_or_else(|_| Item::new_opaque_type(potential_id, &ty, ctx));
+        }
+
+        if let Some(ty) = ctx.builtin_or_resolved_ty(
+            potential_id,
+            parent_id,
+            &ty,
+            Some(location),
+        ) {
+            debug!("{:?} already resolved: {:?}", ty, location);
+            return ty;
+        }
+
+        debug!("New unresolved type reference: {:?}, {:?}", ty, location);
+
+        let is_const = ty.is_const();
+        let kind = TypeKind::UnresolvedTypeRef(ty, location, parent_id);
+        let current_module = ctx.current_module();
+
+        ctx.add_item(
+            Item::new(
+                potential_id,
+                None,
+                None,
+                parent_id.unwrap_or_else(|| current_module.into()),
+                ItemKind::Type(Type::new(None, None, kind, is_const)),
+                Some(location.location()),
+            ),
+            None,
+            None,
+        );
+        potential_id.as_type_id_unchecked()
+    }
+
+    fn from_ty(
+        ty: &clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<TypeId, ParseError> {
+        let id = ctx.next_item_id();
+        Item::from_ty_with_id(id, ty, location, parent_id, ctx)
+    }
+
+    /// This is one of the trickiest methods you'll find (probably along with
+    /// some of the ones that handle templates in `BindgenContext`).
+    ///
+    /// This method parses a type, given the potential id of that type (if
+    /// parsing it was correct), an optional location we're scanning, which is
+    /// critical some times to obtain information, an optional parent item id,
+    /// that will, if it's `None`, become the current module id, and the
+    /// context.
+    fn from_ty_with_id(
+        id: ItemId,
+        ty: &clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<TypeId, ParseError> {
+        use clang_sys::*;
+
+        debug!(
+            "Item::from_ty_with_id: {:?}\n\
+             \tty = {:?},\n\
+             \tlocation = {:?}",
+            id, ty, location
+        );
+
+        if ty.kind() == clang_sys::CXType_Unexposed ||
+            location.cur_type().kind() == clang_sys::CXType_Unexposed
+        {
+            if ty.is_associated_type() ||
+                location.cur_type().is_associated_type()
+            {
+                return Ok(Item::new_opaque_type(id, ty, ctx));
+            }
+
+            if let Some(param_id) = Item::type_param(None, location, ctx) {
+                return Ok(ctx.build_ty_wrapper(id, param_id, None, ty));
+            }
+        }
+
+        // Treat all types that are declared inside functions as opaque. The Rust binding
+        // won't be able to do anything with them anyway.
+        //
+        // (If we don't do this check here, we can have subtle logic bugs because we generally
+        // ignore function bodies. See issue #2036.)
+        if let Some(ref parent) = ty.declaration().fallible_semantic_parent() {
+            if FunctionKind::from_cursor(parent).is_some() {
+                debug!("Skipping type declared inside function: {:?}", ty);
+                return Ok(Item::new_opaque_type(id, ty, ctx));
+            }
+        }
+
+        let decl = {
+            let canonical_def = ty.canonical_type().declaration().definition();
+            canonical_def.unwrap_or_else(|| ty.declaration())
+        };
+
+        let comment = decl.raw_comment().or_else(|| location.raw_comment());
+        let annotations =
+            Annotations::new(&decl).or_else(|| Annotations::new(&location));
+
+        if let Some(ref annotations) = annotations {
+            if let Some(replaced) = annotations.use_instead_of() {
+                ctx.replace(replaced, id);
+            }
+        }
+
+        if let Some(ty) =
+            ctx.builtin_or_resolved_ty(id, parent_id, ty, Some(location))
+        {
+            return Ok(ty);
+        }
+
+        // First, check we're not recursing.
+        let mut valid_decl = decl.kind() != CXCursor_NoDeclFound;
+        let declaration_to_look_for = if valid_decl {
+            decl.canonical()
+        } else if location.kind() == CXCursor_ClassTemplate {
+            valid_decl = true;
+            location
+        } else {
+            decl
+        };
+
+        if valid_decl {
+            if let Some(partial) = ctx
+                .currently_parsed_types()
+                .iter()
+                .find(|ty| *ty.decl() == declaration_to_look_for)
+            {
+                debug!("Avoiding recursion parsing type: {:?}", ty);
+                // Unchecked because we haven't finished this type yet.
+                return Ok(partial.id().as_type_id_unchecked());
+            }
+        }
+
+        let current_module = ctx.current_module().into();
+        let partial_ty = PartialType::new(declaration_to_look_for, id);
+        if valid_decl {
+            ctx.begin_parsing(partial_ty);
+        }
+
+        let result = Type::from_clang_ty(id, ty, location, parent_id, ctx);
+        let relevant_parent_id = parent_id.unwrap_or(current_module);
+        let ret = match result {
+            Ok(ParseResult::AlreadyResolved(ty)) => {
+                Ok(ty.as_type_id_unchecked())
+            }
+            Ok(ParseResult::New(item, declaration)) => {
+                ctx.add_item(
+                    Item::new(
+                        id,
+                        comment,
+                        annotations,
+                        relevant_parent_id,
+                        ItemKind::Type(item),
+                        Some(location.location()),
+                    ),
+                    declaration,
+                    Some(location),
+                );
+                Ok(id.as_type_id_unchecked())
+            }
+            Err(ParseError::Continue) => Err(ParseError::Continue),
+            Err(ParseError::Recurse) => {
+                debug!("Item::from_ty recursing in the ast");
+                let mut result = Err(ParseError::Recurse);
+
+                // Need to pop here, otherwise we'll get stuck.
+                //
+                // TODO: Find a nicer interface, really. Also, the
+                // declaration_to_look_for suspiciously shares a lot of
+                // logic with ir::context, so we should refactor that.
+                if valid_decl {
+                    let finished = ctx.finish_parsing();
+                    assert_eq!(*finished.decl(), declaration_to_look_for);
+                }
+
+                location.visit(|cur| {
+                    visit_child(cur, id, ty, parent_id, ctx, &mut result)
+                });
+
+                if valid_decl {
+                    let partial_ty =
+                        PartialType::new(declaration_to_look_for, id);
+                    ctx.begin_parsing(partial_ty);
+                }
+
+                // If we have recursed into the AST all we know, and we still
+                // haven't found what we've got, let's just try and make a named
+                // type.
+                //
+                // This is what happens with some template members, for example.
+                if let Err(ParseError::Recurse) = result {
+                    warn!(
+                        "Unknown type, assuming named template type: \
+                         id = {:?}; spelling = {}",
+                        id,
+                        ty.spelling()
+                    );
+                    Item::type_param(Some(id), location, ctx)
+                        .map(Ok)
+                        .unwrap_or(Err(ParseError::Recurse))
+                } else {
+                    result
+                }
+            }
+        };
+
+        if valid_decl {
+            let partial_ty = ctx.finish_parsing();
+            assert_eq!(*partial_ty.decl(), declaration_to_look_for);
+        }
+
+        ret
+    }
+
+    /// A named type is a template parameter, e.g., the "T" in Foo<T>. They're
+    /// always local so it's the only exception when there's no declaration for
+    /// a type.
+    fn type_param(
+        with_id: Option<ItemId>,
+        location: clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Option<TypeId> {
+        let ty = location.cur_type();
+
+        debug!(
+            "Item::type_param:\n\
+             \twith_id = {:?},\n\
+             \tty = {} {:?},\n\
+             \tlocation: {:?}",
+            with_id,
+            ty.spelling(),
+            ty,
+            location
+        );
+
+        if ty.kind() != clang_sys::CXType_Unexposed {
+            // If the given cursor's type's kind is not Unexposed, then we
+            // aren't looking at a template parameter. This check may need to be
+            // updated in the future if they start properly exposing template
+            // type parameters.
+            return None;
+        }
+
+        let ty_spelling = ty.spelling();
+
+        // Clang does not expose any information about template type parameters
+        // via their clang::Type, nor does it give us their canonical cursors
+        // the straightforward way. However, there are three situations from
+        // which we can find the definition of the template type parameter, if
+        // the cursor is indeed looking at some kind of a template type
+        // parameter or use of one:
+        //
+        // 1. The cursor is pointing at the template type parameter's
+        // definition. This is the trivial case.
+        //
+        //     (kind = TemplateTypeParameter, ...)
+        //
+        // 2. The cursor is pointing at a TypeRef whose referenced() cursor is
+        // situation (1).
+        //
+        //     (kind = TypeRef,
+        //      referenced = (kind = TemplateTypeParameter, ...),
+        //      ...)
+        //
+        // 3. The cursor is pointing at some use of a template type parameter
+        // (for example, in a FieldDecl), and this cursor has a child cursor
+        // whose spelling is the same as the parent's type's spelling, and whose
+        // kind is a TypeRef of the situation (2) variety.
+        //
+        //    (kind = FieldDecl,
+        //     type = (kind = Unexposed,
+        //             spelling = "T",
+        //             ...),
+        //     children =
+        //        (kind = TypeRef,
+        //         spelling = "T",
+        //         referenced = (kind = TemplateTypeParameter,
+        //                       spelling = "T",
+        //                       ...),
+        //         ...)
+        //     ...)
+        //
+        // TODO: The alternative to this hacky pattern matching would be to
+        // maintain proper scopes of template parameters while parsing and use
+        // de Brujin indices to access template parameters, which clang exposes
+        // in the cursor's type's canonical type's spelling:
+        // "type-parameter-x-y". That is probably a better approach long-term,
+        // but maintaining these scopes properly would require more changes to
+        // the whole libclang -> IR parsing code.
+
+        fn is_template_with_spelling(
+            refd: &clang::Cursor,
+            spelling: &str,
+        ) -> bool {
+            lazy_static! {
+                static ref ANON_TYPE_PARAM_RE: regex::Regex =
+                    regex::Regex::new(r"^type\-parameter\-\d+\-\d+$").unwrap();
+            }
+
+            if refd.kind() != clang_sys::CXCursor_TemplateTypeParameter {
+                return false;
+            }
+
+            let refd_spelling = refd.spelling();
+            refd_spelling == spelling ||
+                // Allow for anonymous template parameters.
+                (refd_spelling.is_empty() && ANON_TYPE_PARAM_RE.is_match(spelling.as_ref()))
+        }
+
+        let definition = if is_template_with_spelling(&location, &ty_spelling) {
+            // Situation (1)
+            location
+        } else if location.kind() == clang_sys::CXCursor_TypeRef {
+            // Situation (2)
+            match location.referenced() {
+                Some(refd)
+                    if is_template_with_spelling(&refd, &ty_spelling) =>
+                {
+                    refd
+                }
+                _ => return None,
+            }
+        } else {
+            // Situation (3)
+            let mut definition = None;
+
+            location.visit(|child| {
+                let child_ty = child.cur_type();
+                if child_ty.kind() == clang_sys::CXCursor_TypeRef &&
+                    child_ty.spelling() == ty_spelling
+                {
+                    match child.referenced() {
+                        Some(refd)
+                            if is_template_with_spelling(
+                                &refd,
+                                &ty_spelling,
+                            ) =>
+                        {
+                            definition = Some(refd);
+                            return clang_sys::CXChildVisit_Break;
+                        }
+                        _ => {}
+                    }
+                }
+
+                clang_sys::CXChildVisit_Continue
+            });
+
+            definition?
+        };
+        assert!(is_template_with_spelling(&definition, &ty_spelling));
+
+        // Named types are always parented to the root module. They are never
+        // referenced with namespace prefixes, and they can't inherit anything
+        // from their parent either, so it is simplest to just hang them off
+        // something we know will always exist.
+        let parent = ctx.root_module().into();
+
+        if let Some(id) = ctx.get_type_param(&definition) {
+            if let Some(with_id) = with_id {
+                return Some(ctx.build_ty_wrapper(
+                    with_id,
+                    id,
+                    Some(parent),
+                    &ty,
+                ));
+            } else {
+                return Some(id);
+            }
+        }
+
+        // See tests/headers/const_tparam.hpp and
+        // tests/headers/variadic_tname.hpp.
+        let name = ty_spelling.replace("const ", "").replace('.', "");
+
+        let id = with_id.unwrap_or_else(|| ctx.next_item_id());
+        let item = Item::new(
+            id,
+            None,
+            None,
+            parent,
+            ItemKind::Type(Type::named(name)),
+            Some(location.location()),
+        );
+        ctx.add_type_param(item, definition);
+        Some(id.as_type_id_unchecked())
+    }
+}
+
+impl ItemCanonicalName for Item {
+    fn canonical_name(&self, ctx: &BindgenContext) -> String {
+        debug_assert!(
+            ctx.in_codegen_phase(),
+            "You're not supposed to call this yet"
+        );
+        self.canonical_name
+            .borrow_with(|| {
+                let in_namespace = ctx.options().enable_cxx_namespaces ||
+                    ctx.options().disable_name_namespacing;
+
+                if in_namespace {
+                    self.name(ctx).within_namespaces().get()
+                } else {
+                    self.name(ctx).get()
+                }
+            })
+            .clone()
+    }
+}
+
+impl ItemCanonicalPath for Item {
+    fn namespace_aware_canonical_path(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Vec<String> {
+        let mut path = self.canonical_path(ctx);
+
+        // ASSUMPTION: (disable_name_namespacing && cxx_namespaces)
+        // is equivalent to
+        // disable_name_namespacing
+        if ctx.options().disable_name_namespacing {
+            // Only keep the last item in path
+            let split_idx = path.len() - 1;
+            path = path.split_off(split_idx);
+        } else if !ctx.options().enable_cxx_namespaces {
+            // Ignore first item "root"
+            path = vec![path[1..].join("_")];
+        }
+
+        if self.is_constified_enum_module(ctx) {
+            path.push(CONSTIFIED_ENUM_MODULE_REPR_NAME.into());
+        }
+
+        path
+    }
+
+    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
+        self.compute_path(ctx, UserMangled::Yes)
+    }
+}
+
+/// Whether to use the user-mangled name (mangled by the `item_name` callback or
+/// not.
+///
+/// Most of the callers probably want just yes, but the ones dealing with
+/// allowlisting and blocklisting don't.
+#[derive(Copy, Clone, Debug, PartialEq)]
+enum UserMangled {
+    No,
+    Yes,
+}
+
+/// Builder struct for naming variations, which hold inside different
+/// flags for naming options.
+#[derive(Debug)]
+pub struct NameOptions<'a> {
+    item: &'a Item,
+    ctx: &'a BindgenContext,
+    within_namespaces: bool,
+    user_mangled: UserMangled,
+}
+
+impl<'a> NameOptions<'a> {
+    /// Construct a new `NameOptions`
+    pub fn new(item: &'a Item, ctx: &'a BindgenContext) -> Self {
+        NameOptions {
+            item,
+            ctx,
+            within_namespaces: false,
+            user_mangled: UserMangled::Yes,
+        }
+    }
+
+    /// Construct the name without the item's containing C++ namespaces mangled
+    /// into it. In other words, the item's name within the item's namespace.
+    pub fn within_namespaces(&mut self) -> &mut Self {
+        self.within_namespaces = true;
+        self
+    }
+
+    fn user_mangled(&mut self, user_mangled: UserMangled) -> &mut Self {
+        self.user_mangled = user_mangled;
+        self
+    }
+
+    /// Construct a name `String`
+    pub fn get(&self) -> String {
+        self.item.real_canonical_name(self.ctx, self)
+    }
+}
diff --git a/bindgen/ir/item_kind.rs b/bindgen/ir/item_kind.rs
new file mode 100644
index 00000000..4a12fef4
--- /dev/null
+++ b/bindgen/ir/item_kind.rs
@@ -0,0 +1,147 @@
+//! Different variants of an `Item` in our intermediate representation.
+
+use super::context::BindgenContext;
+use super::dot::DotAttributes;
+use super::function::Function;
+use super::module::Module;
+use super::ty::Type;
+use super::var::Var;
+use std::io;
+
+/// A item we parse and translate.
+#[derive(Debug)]
+pub enum ItemKind {
+    /// A module, created implicitly once (the root module), or via C++
+    /// namespaces.
+    Module(Module),
+
+    /// A type declared in any of the multiple ways it can be declared.
+    Type(Type),
+
+    /// A function or method declaration.
+    Function(Function),
+
+    /// A variable declaration, most likely a static.
+    Var(Var),
+}
+
+impl ItemKind {
+    /// Get a reference to this `ItemKind`'s underying `Module`, or `None` if it
+    /// is some other kind.
+    pub fn as_module(&self) -> Option<&Module> {
+        match *self {
+            ItemKind::Module(ref module) => Some(module),
+            _ => None,
+        }
+    }
+
+    /// Transform our `ItemKind` into a string.
+    pub fn kind_name(&self) -> &'static str {
+        match *self {
+            ItemKind::Module(..) => "Module",
+            ItemKind::Type(..) => "Type",
+            ItemKind::Function(..) => "Function",
+            ItemKind::Var(..) => "Var",
+        }
+    }
+
+    /// Is this a module?
+    pub fn is_module(&self) -> bool {
+        self.as_module().is_some()
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Module`, or panic if it
+    /// is some other kind.
+    pub fn expect_module(&self) -> &Module {
+        self.as_module().expect("Not a module")
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Function`, or `None` if
+    /// it is some other kind.
+    pub fn as_function(&self) -> Option<&Function> {
+        match *self {
+            ItemKind::Function(ref func) => Some(func),
+            _ => None,
+        }
+    }
+
+    /// Is this a function?
+    pub fn is_function(&self) -> bool {
+        self.as_function().is_some()
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Function`, or panic if
+    /// it is some other kind.
+    pub fn expect_function(&self) -> &Function {
+        self.as_function().expect("Not a function")
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Type`, or `None` if
+    /// it is some other kind.
+    pub fn as_type(&self) -> Option<&Type> {
+        match *self {
+            ItemKind::Type(ref ty) => Some(ty),
+            _ => None,
+        }
+    }
+
+    /// Get a mutable reference to this `ItemKind`'s underying `Type`, or `None`
+    /// if it is some other kind.
+    pub fn as_type_mut(&mut self) -> Option<&mut Type> {
+        match *self {
+            ItemKind::Type(ref mut ty) => Some(ty),
+            _ => None,
+        }
+    }
+
+    /// Is this a type?
+    pub fn is_type(&self) -> bool {
+        self.as_type().is_some()
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Type`, or panic if it is
+    /// some other kind.
+    pub fn expect_type(&self) -> &Type {
+        self.as_type().expect("Not a type")
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Var`, or `None` if it is
+    /// some other kind.
+    pub fn as_var(&self) -> Option<&Var> {
+        match *self {
+            ItemKind::Var(ref v) => Some(v),
+            _ => None,
+        }
+    }
+
+    /// Is this a variable?
+    pub fn is_var(&self) -> bool {
+        self.as_var().is_some()
+    }
+
+    /// Get a reference to this `ItemKind`'s underying `Var`, or panic if it is
+    /// some other kind.
+    pub fn expect_var(&self) -> &Var {
+        self.as_var().expect("Not a var")
+    }
+}
+
+impl DotAttributes for ItemKind {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(out, "<tr><td>kind</td><td>{}</td></tr>", self.kind_name())?;
+
+        match *self {
+            ItemKind::Module(ref module) => module.dot_attributes(ctx, out),
+            ItemKind::Type(ref ty) => ty.dot_attributes(ctx, out),
+            ItemKind::Function(ref func) => func.dot_attributes(ctx, out),
+            ItemKind::Var(ref var) => var.dot_attributes(ctx, out),
+        }
+    }
+}
diff --git a/bindgen/ir/layout.rs b/bindgen/ir/layout.rs
new file mode 100644
index 00000000..6f450307
--- /dev/null
+++ b/bindgen/ir/layout.rs
@@ -0,0 +1,143 @@
+//! Intermediate representation for the physical layout of some type.
+
+use super::derive::CanDerive;
+use super::ty::{Type, TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
+use crate::clang;
+use crate::ir::context::BindgenContext;
+use std::cmp;
+
+/// A type that represents the struct layout of a type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Layout {
+    /// The size (in bytes) of this layout.
+    pub size: usize,
+    /// The alignment (in bytes) of this layout.
+    pub align: usize,
+    /// Whether this layout's members are packed or not.
+    pub packed: bool,
+}
+
+#[test]
+fn test_layout_for_size() {
+    use std::mem;
+
+    let ptr_size = mem::size_of::<*mut ()>();
+    assert_eq!(
+        Layout::for_size_internal(ptr_size, ptr_size),
+        Layout::new(ptr_size, ptr_size)
+    );
+    assert_eq!(
+        Layout::for_size_internal(ptr_size, 3 * ptr_size),
+        Layout::new(3 * ptr_size, ptr_size)
+    );
+}
+
+impl Layout {
+    /// Gets the integer type name for a given known size.
+    pub fn known_type_for_size(
+        ctx: &BindgenContext,
+        size: usize,
+    ) -> Option<&'static str> {
+        Some(match size {
+            16 if ctx.options().rust_features.i128_and_u128 => "u128",
+            8 => "u64",
+            4 => "u32",
+            2 => "u16",
+            1 => "u8",
+            _ => return None,
+        })
+    }
+
+    /// Construct a new `Layout` with the given `size` and `align`. It is not
+    /// packed.
+    pub fn new(size: usize, align: usize) -> Self {
+        Layout {
+            size,
+            align,
+            packed: false,
+        }
+    }
+
+    fn for_size_internal(ptr_size: usize, size: usize) -> Self {
+        let mut next_align = 2;
+        while size % next_align == 0 && next_align <= ptr_size {
+            next_align *= 2;
+        }
+        Layout {
+            size,
+            align: next_align / 2,
+            packed: false,
+        }
+    }
+
+    /// Creates a non-packed layout for a given size, trying to use the maximum
+    /// alignment possible.
+    pub fn for_size(ctx: &BindgenContext, size: usize) -> Self {
+        Self::for_size_internal(ctx.target_pointer_size(), size)
+    }
+
+    /// Is this a zero-sized layout?
+    pub fn is_zero(&self) -> bool {
+        self.size == 0 && self.align == 0
+    }
+
+    /// Construct a zero-sized layout.
+    pub fn zero() -> Self {
+        Self::new(0, 0)
+    }
+
+    /// Get this layout as an opaque type.
+    pub fn opaque(&self) -> Opaque {
+        Opaque(*self)
+    }
+}
+
+/// When we are treating a type as opaque, it is just a blob with a `Layout`.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Opaque(pub Layout);
+
+impl Opaque {
+    /// Construct a new opaque type from the given clang type.
+    pub fn from_clang_ty(ty: &clang::Type, ctx: &BindgenContext) -> Type {
+        let layout = Layout::new(ty.size(ctx), ty.align(ctx));
+        let ty_kind = TypeKind::Opaque;
+        let is_const = ty.is_const();
+        Type::new(None, Some(layout), ty_kind, is_const)
+    }
+
+    /// Return the known rust type we should use to create a correctly-aligned
+    /// field with this layout.
+    pub fn known_rust_type_for_array(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Option<&'static str> {
+        Layout::known_type_for_size(ctx, self.0.align)
+    }
+
+    /// Return the array size that an opaque type for this layout should have if
+    /// we know the correct type for it, or `None` otherwise.
+    pub fn array_size(&self, ctx: &BindgenContext) -> Option<usize> {
+        if self.known_rust_type_for_array(ctx).is_some() {
+            Some(self.0.size / cmp::max(self.0.align, 1))
+        } else {
+            None
+        }
+    }
+
+    /// Return `true` if this opaque layout's array size will fit within the
+    /// maximum number of array elements that Rust allows deriving traits
+    /// with. Return `false` otherwise.
+    pub fn array_size_within_derive_limit(
+        &self,
+        ctx: &BindgenContext,
+    ) -> CanDerive {
+        if self
+            .array_size(ctx)
+            .map_or(false, |size| size <= RUST_DERIVE_IN_ARRAY_LIMIT)
+        {
+            CanDerive::Yes
+        } else {
+            CanDerive::Manually
+        }
+    }
+}
diff --git a/bindgen/ir/mod.rs b/bindgen/ir/mod.rs
new file mode 100644
index 00000000..8f6a2dac
--- /dev/null
+++ b/bindgen/ir/mod.rs
@@ -0,0 +1,24 @@
+//! The ir module defines bindgen's intermediate representation.
+//!
+//! Parsing C/C++ generates the IR, while code generation outputs Rust code from
+//! the IR.
+
+pub mod analysis;
+pub mod annotations;
+pub mod comment;
+pub mod comp;
+pub mod context;
+pub mod derive;
+pub mod dot;
+pub mod enum_ty;
+pub mod function;
+pub mod int;
+pub mod item;
+pub mod item_kind;
+pub mod layout;
+pub mod module;
+pub mod objc;
+pub mod template;
+pub mod traversal;
+pub mod ty;
+pub mod var;
diff --git a/bindgen/ir/module.rs b/bindgen/ir/module.rs
new file mode 100644
index 00000000..d5aca94a
--- /dev/null
+++ b/bindgen/ir/module.rs
@@ -0,0 +1,95 @@
+//! Intermediate representation for modules (AKA C++ namespaces).
+
+use super::context::BindgenContext;
+use super::dot::DotAttributes;
+use super::item::ItemSet;
+use crate::clang;
+use crate::parse::{ClangSubItemParser, ParseError, ParseResult};
+use crate::parse_one;
+use std::io;
+
+/// Whether this module is inline or not.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ModuleKind {
+    /// This module is not inline.
+    Normal,
+    /// This module is inline, as in `inline namespace foo {}`.
+    Inline,
+}
+
+/// A module, as in, a C++ namespace.
+#[derive(Clone, Debug)]
+pub struct Module {
+    /// The name of the module, or none if it's anonymous.
+    name: Option<String>,
+    /// The kind of module this is.
+    kind: ModuleKind,
+    /// The children of this module, just here for convenience.
+    children: ItemSet,
+}
+
+impl Module {
+    /// Construct a new `Module`.
+    pub fn new(name: Option<String>, kind: ModuleKind) -> Self {
+        Module {
+            name,
+            kind,
+            children: ItemSet::new(),
+        }
+    }
+
+    /// Get this module's name.
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    /// Get a mutable reference to this module's children.
+    pub fn children_mut(&mut self) -> &mut ItemSet {
+        &mut self.children
+    }
+
+    /// Get this module's children.
+    pub fn children(&self) -> &ItemSet {
+        &self.children
+    }
+
+    /// Whether this namespace is inline.
+    pub fn is_inline(&self) -> bool {
+        self.kind == ModuleKind::Inline
+    }
+}
+
+impl DotAttributes for Module {
+    fn dot_attributes<W>(
+        &self,
+        _ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(out, "<tr><td>ModuleKind</td><td>{:?}</td></tr>", self.kind)
+    }
+}
+
+impl ClangSubItemParser for Module {
+    fn parse(
+        cursor: clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Result<ParseResult<Self>, ParseError> {
+        use clang_sys::*;
+        match cursor.kind() {
+            CXCursor_Namespace => {
+                let module_id = ctx.module(cursor);
+                ctx.with_module(module_id, |ctx| {
+                    cursor.visit(|cursor| {
+                        parse_one(ctx, cursor, Some(module_id.into()))
+                    })
+                });
+
+                Ok(ParseResult::AlreadyResolved(module_id.into()))
+            }
+            _ => Err(ParseError::Continue),
+        }
+    }
+}
diff --git a/bindgen/ir/objc.rs b/bindgen/ir/objc.rs
new file mode 100644
index 00000000..0845ad0f
--- /dev/null
+++ b/bindgen/ir/objc.rs
@@ -0,0 +1,329 @@
+//! Objective C types
+
+use super::context::{BindgenContext, ItemId};
+use super::function::FunctionSig;
+use super::item::Item;
+use super::traversal::{Trace, Tracer};
+use super::ty::TypeKind;
+use crate::clang;
+use crate::parse::ClangItemParser;
+use clang_sys::CXChildVisit_Continue;
+use clang_sys::CXCursor_ObjCCategoryDecl;
+use clang_sys::CXCursor_ObjCClassMethodDecl;
+use clang_sys::CXCursor_ObjCClassRef;
+use clang_sys::CXCursor_ObjCInstanceMethodDecl;
+use clang_sys::CXCursor_ObjCProtocolDecl;
+use clang_sys::CXCursor_ObjCProtocolRef;
+use clang_sys::CXCursor_ObjCSuperClassRef;
+use clang_sys::CXCursor_TemplateTypeParameter;
+use proc_macro2::{Ident, Span, TokenStream};
+
+/// Objective C interface as used in TypeKind
+///
+/// Also protocols and categories are parsed as this type
+#[derive(Debug)]
+pub struct ObjCInterface {
+    /// The name
+    /// like, NSObject
+    name: String,
+
+    category: Option<String>,
+
+    is_protocol: bool,
+
+    /// The list of template names almost always, ObjectType or KeyType
+    pub template_names: Vec<String>,
+
+    /// The list of protocols that this interface conforms to.
+    pub conforms_to: Vec<ItemId>,
+
+    /// The direct parent for this interface.
+    pub parent_class: Option<ItemId>,
+
+    /// List of the methods defined in this interfae
+    methods: Vec<ObjCMethod>,
+
+    class_methods: Vec<ObjCMethod>,
+}
+
+/// The objective c methods
+#[derive(Debug)]
+pub struct ObjCMethod {
+    /// The original method selector name
+    /// like, dataWithBytes:length:
+    name: String,
+
+    /// Method name as converted to rust
+    /// like, dataWithBytes_length_
+    rust_name: String,
+
+    signature: FunctionSig,
+
+    /// Is class method?
+    is_class_method: bool,
+}
+
+impl ObjCInterface {
+    fn new(name: &str) -> ObjCInterface {
+        ObjCInterface {
+            name: name.to_owned(),
+            category: None,
+            is_protocol: false,
+            template_names: Vec::new(),
+            parent_class: None,
+            conforms_to: Vec::new(),
+            methods: Vec::new(),
+            class_methods: Vec::new(),
+        }
+    }
+
+    /// The name
+    /// like, NSObject
+    pub fn name(&self) -> &str {
+        self.name.as_ref()
+    }
+
+    /// Formats the name for rust
+    /// Can be like NSObject, but with categories might be like NSObject_NSCoderMethods
+    /// and protocols are like PNSObject
+    pub fn rust_name(&self) -> String {
+        if let Some(ref cat) = self.category {
+            format!("{}_{}", self.name(), cat)
+        } else if self.is_protocol {
+            format!("P{}", self.name())
+        } else {
+            format!("I{}", self.name().to_owned())
+        }
+    }
+
+    /// Is this a template interface?
+    pub fn is_template(&self) -> bool {
+        !self.template_names.is_empty()
+    }
+
+    /// List of the methods defined in this interface
+    pub fn methods(&self) -> &Vec<ObjCMethod> {
+        &self.methods
+    }
+
+    /// Is this a protocol?
+    pub fn is_protocol(&self) -> bool {
+        self.is_protocol
+    }
+
+    /// Is this a category?
+    pub fn is_category(&self) -> bool {
+        self.category.is_some()
+    }
+
+    /// List of the class methods defined in this interface
+    pub fn class_methods(&self) -> &Vec<ObjCMethod> {
+        &self.class_methods
+    }
+
+    /// Parses the Objective C interface from the cursor
+    pub fn from_ty(
+        cursor: &clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Option<Self> {
+        let name = cursor.spelling();
+        let mut interface = Self::new(&name);
+
+        if cursor.kind() == CXCursor_ObjCProtocolDecl {
+            interface.is_protocol = true;
+        }
+
+        cursor.visit(|c| {
+            match c.kind() {
+                CXCursor_ObjCClassRef => {
+                    if cursor.kind() == CXCursor_ObjCCategoryDecl {
+                        // We are actually a category extension, and we found the reference
+                        // to the original interface, so name this interface approriately
+                        interface.name = c.spelling();
+                        interface.category = Some(cursor.spelling());
+                    }
+                }
+                CXCursor_ObjCProtocolRef => {
+                    // Gather protocols this interface conforms to
+                    let needle = format!("P{}", c.spelling());
+                    let items_map = ctx.items();
+                    debug!(
+                        "Interface {} conforms to {}, find the item",
+                        interface.name, needle
+                    );
+
+                    for (id, item) in items_map {
+                        if let Some(ty) = item.as_type() {
+                            if let TypeKind::ObjCInterface(ref protocol) =
+                                *ty.kind()
+                            {
+                                if protocol.is_protocol {
+                                    debug!(
+                                        "Checking protocol {}, ty.name {:?}",
+                                        protocol.name,
+                                        ty.name()
+                                    );
+                                    if Some(needle.as_ref()) == ty.name() {
+                                        debug!(
+                                            "Found conforming protocol {:?}",
+                                            item
+                                        );
+                                        interface.conforms_to.push(id);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                CXCursor_ObjCInstanceMethodDecl |
+                CXCursor_ObjCClassMethodDecl => {
+                    let name = c.spelling();
+                    let signature =
+                        FunctionSig::from_ty(&c.cur_type(), &c, ctx)
+                            .expect("Invalid function sig");
+                    let is_class_method =
+                        c.kind() == CXCursor_ObjCClassMethodDecl;
+                    let method =
+                        ObjCMethod::new(&name, signature, is_class_method);
+                    interface.add_method(method);
+                }
+                CXCursor_TemplateTypeParameter => {
+                    let name = c.spelling();
+                    interface.template_names.push(name);
+                }
+                CXCursor_ObjCSuperClassRef => {
+                    let item = Item::from_ty_or_ref(c.cur_type(), c, None, ctx);
+                    interface.parent_class = Some(item.into());
+                }
+                _ => {}
+            }
+            CXChildVisit_Continue
+        });
+        Some(interface)
+    }
+
+    fn add_method(&mut self, method: ObjCMethod) {
+        if method.is_class_method {
+            self.class_methods.push(method);
+        } else {
+            self.methods.push(method);
+        }
+    }
+}
+
+impl ObjCMethod {
+    fn new(
+        name: &str,
+        signature: FunctionSig,
+        is_class_method: bool,
+    ) -> ObjCMethod {
+        let split_name: Vec<&str> = name.split(':').collect();
+
+        let rust_name = split_name.join("_");
+
+        ObjCMethod {
+            name: name.to_owned(),
+            rust_name,
+            signature,
+            is_class_method,
+        }
+    }
+
+    /// The original method selector name
+    /// like, dataWithBytes:length:
+    pub fn name(&self) -> &str {
+        self.name.as_ref()
+    }
+
+    /// Method name as converted to rust
+    /// like, dataWithBytes_length_
+    pub fn rust_name(&self) -> &str {
+        self.rust_name.as_ref()
+    }
+
+    /// Returns the methods signature as FunctionSig
+    pub fn signature(&self) -> &FunctionSig {
+        &self.signature
+    }
+
+    /// Is this a class method?
+    pub fn is_class_method(&self) -> bool {
+        self.is_class_method
+    }
+
+    /// Formats the method call
+    pub fn format_method_call(&self, args: &[TokenStream]) -> TokenStream {
+        let split_name: Vec<Option<Ident>> = self
+            .name
+            .split(':')
+            .map(|name| {
+                if name.is_empty() {
+                    None
+                } else {
+                    Some(Ident::new(name, Span::call_site()))
+                }
+            })
+            .collect();
+
+        // No arguments
+        if args.is_empty() && split_name.len() == 1 {
+            let name = &split_name[0];
+            return quote! {
+                #name
+            };
+        }
+
+        // Check right amount of arguments
+        assert!(
+            args.len() == split_name.len() - 1,
+            "Incorrect method name or arguments for objc method, {:?} vs {:?}",
+            args,
+            split_name
+        );
+
+        // Get arguments without type signatures to pass to `msg_send!`
+        let mut args_without_types = vec![];
+        for arg in args.iter() {
+            let arg = arg.to_string();
+            let name_and_sig: Vec<&str> = arg.split(' ').collect();
+            let name = name_and_sig[0];
+            args_without_types.push(Ident::new(name, Span::call_site()))
+        }
+
+        let args = split_name.into_iter().zip(args_without_types).map(
+            |(arg, arg_val)| {
+                if let Some(arg) = arg {
+                    quote! { #arg: #arg_val }
+                } else {
+                    quote! { #arg_val: #arg_val }
+                }
+            },
+        );
+
+        quote! {
+            #( #args )*
+        }
+    }
+}
+
+impl Trace for ObjCInterface {
+    type Extra = ();
+
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
+    where
+        T: Tracer,
+    {
+        for method in &self.methods {
+            method.signature.trace(context, tracer, &());
+        }
+
+        for class_method in &self.class_methods {
+            class_method.signature.trace(context, tracer, &());
+        }
+
+        for protocol in &self.conforms_to {
+            tracer.visit(*protocol);
+        }
+    }
+}
diff --git a/bindgen/ir/template.rs b/bindgen/ir/template.rs
new file mode 100644
index 00000000..8b06748e
--- /dev/null
+++ b/bindgen/ir/template.rs
@@ -0,0 +1,343 @@
+//! Template declaration and instantiation related things.
+//!
+//! The nomenclature surrounding templates is often confusing, so here are a few
+//! brief definitions:
+//!
+//! * "Template definition": a class/struct/alias/function definition that takes
+//! generic template parameters. For example:
+//!
+//! ```c++
+//! template<typename T>
+//! class List<T> {
+//!     // ...
+//! };
+//! ```
+//!
+//! * "Template instantiation": an instantiation is a use of a template with
+//! concrete template arguments. For example, `List<int>`.
+//!
+//! * "Template specialization": an alternative template definition providing a
+//! custom definition for instantiations with the matching template
+//! arguments. This C++ feature is unsupported by bindgen. For example:
+//!
+//! ```c++
+//! template<>
+//! class List<int> {
+//!     // Special layout for int lists...
+//! };
+//! ```
+
+use super::context::{BindgenContext, ItemId, TypeId};
+use super::item::{IsOpaque, Item, ItemAncestors};
+use super::traversal::{EdgeKind, Trace, Tracer};
+use crate::clang;
+use crate::parse::ClangItemParser;
+
+/// Template declaration (and such declaration's template parameters) related
+/// methods.
+///
+/// This trait's methods distinguish between `None` and `Some([])` for
+/// declarations that are not templates and template declarations with zero
+/// parameters, in general.
+///
+/// Consider this example:
+///
+/// ```c++
+/// template <typename T, typename U>
+/// class Foo {
+///     T use_of_t;
+///     U use_of_u;
+///
+///     template <typename V>
+///     using Bar = V*;
+///
+///     class Inner {
+///         T        x;
+///         U        y;
+///         Bar<int> z;
+///     };
+///
+///     template <typename W>
+///     class Lol {
+///         // No use of W, but here's a use of T.
+///         T t;
+///     };
+///
+///     template <typename X>
+///     class Wtf {
+///         // X is not used because W is not used.
+///         Lol<X> lololol;
+///     };
+/// };
+///
+/// class Qux {
+///     int y;
+/// };
+/// ```
+///
+/// The following table depicts the results of each trait method when invoked on
+/// each of the declarations above:
+///
+/// +------+----------------------+--------------------------+------------------------+----
+/// |Decl. | self_template_params | num_self_template_params | all_template_parameters| ...
+/// +------+----------------------+--------------------------+------------------------+----
+/// |Foo   | [T, U]               | 2                        | [T, U]                 | ...
+/// |Bar   | [V]                  | 1                        | [T, U, V]              | ...
+/// |Inner | []                   | 0                        | [T, U]                 | ...
+/// |Lol   | [W]                  | 1                        | [T, U, W]              | ...
+/// |Wtf   | [X]                  | 1                        | [T, U, X]              | ...
+/// |Qux   | []                   | 0                        | []                     | ...
+/// +------+----------------------+--------------------------+------------------------+----
+///
+/// ----+------+-----+----------------------+
+/// ... |Decl. | ... | used_template_params |
+/// ----+------+-----+----------------------+
+/// ... |Foo   | ... | [T, U]               |
+/// ... |Bar   | ... | [V]                  |
+/// ... |Inner | ... | []                   |
+/// ... |Lol   | ... | [T]                  |
+/// ... |Wtf   | ... | [T]                  |
+/// ... |Qux   | ... | []                   |
+/// ----+------+-----+----------------------+
+pub trait TemplateParameters: Sized {
+    /// Get the set of `ItemId`s that make up this template declaration's free
+    /// template parameters.
+    ///
+    /// Note that these might *not* all be named types: C++ allows
+    /// constant-value template parameters as well as template-template
+    /// parameters. Of course, Rust does not allow generic parameters to be
+    /// anything but types, so we must treat them as opaque, and avoid
+    /// instantiating them.
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>;
+
+    /// Get the number of free template parameters this template declaration
+    /// has.
+    fn num_self_template_params(&self, ctx: &BindgenContext) -> usize {
+        self.self_template_params(ctx).len()
+    }
+
+    /// Get the complete set of template parameters that can affect this
+    /// declaration.
+    ///
+    /// Note that this item doesn't need to be a template declaration itself for
+    /// `Some` to be returned here (in contrast to `self_template_params`). If
+    /// this item is a member of a template declaration, then the parent's
+    /// template parameters are included here.
+    ///
+    /// In the example above, `Inner` depends on both of the `T` and `U` type
+    /// parameters, even though it is not itself a template declaration and
+    /// therefore has no type parameters itself. Perhaps it helps to think about
+    /// how we would fully reference such a member type in C++:
+    /// `Foo<int,char>::Inner`. `Foo` *must* be instantiated with template
+    /// arguments before we can gain access to the `Inner` member type.
+    fn all_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
+    where
+        Self: ItemAncestors,
+    {
+        let mut ancestors: Vec<_> = self.ancestors(ctx).collect();
+        ancestors.reverse();
+        ancestors
+            .into_iter()
+            .flat_map(|id| id.self_template_params(ctx).into_iter())
+            .collect()
+    }
+
+    /// Get only the set of template parameters that this item uses. This is a
+    /// subset of `all_template_params` and does not necessarily contain any of
+    /// `self_template_params`.
+    fn used_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
+    where
+        Self: AsRef<ItemId>,
+    {
+        assert!(
+            ctx.in_codegen_phase(),
+            "template parameter usage is not computed until codegen"
+        );
+
+        let id = *self.as_ref();
+        ctx.resolve_item(id)
+            .all_template_params(ctx)
+            .into_iter()
+            .filter(|p| ctx.uses_template_parameter(id, *p))
+            .collect()
+    }
+}
+
+/// A trait for things which may or may not be a named template type parameter.
+pub trait AsTemplateParam {
+    /// Any extra information the implementor might need to make this decision.
+    type Extra;
+
+    /// Convert this thing to the item id of a named template type parameter.
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> Option<TypeId>;
+
+    /// Is this a named template type parameter?
+    fn is_template_param(
+        &self,
+        ctx: &BindgenContext,
+        extra: &Self::Extra,
+    ) -> bool {
+        self.as_template_param(ctx, extra).is_some()
+    }
+}
+
+/// A concrete instantiation of a generic template.
+#[derive(Clone, Debug)]
+pub struct TemplateInstantiation {
+    /// The template definition which this is instantiating.
+    definition: TypeId,
+    /// The concrete template arguments, which will be substituted in the
+    /// definition for the generic template parameters.
+    args: Vec<TypeId>,
+}
+
+impl TemplateInstantiation {
+    /// Construct a new template instantiation from the given parts.
+    pub fn new<I>(definition: TypeId, args: I) -> TemplateInstantiation
+    where
+        I: IntoIterator<Item = TypeId>,
+    {
+        TemplateInstantiation {
+            definition,
+            args: args.into_iter().collect(),
+        }
+    }
+
+    /// Get the template definition for this instantiation.
+    pub fn template_definition(&self) -> TypeId {
+        self.definition
+    }
+
+    /// Get the concrete template arguments used in this instantiation.
+    pub fn template_arguments(&self) -> &[TypeId] {
+        &self.args[..]
+    }
+
+    /// Parse a `TemplateInstantiation` from a clang `Type`.
+    pub fn from_ty(
+        ty: &clang::Type,
+        ctx: &mut BindgenContext,
+    ) -> Option<TemplateInstantiation> {
+        use clang_sys::*;
+
+        let template_args = ty.template_args().map_or(vec![], |args| match ty
+            .canonical_type()
+            .template_args()
+        {
+            Some(canonical_args) => {
+                let arg_count = args.len();
+                args.chain(canonical_args.skip(arg_count))
+                    .filter(|t| t.kind() != CXType_Invalid)
+                    .map(|t| {
+                        Item::from_ty_or_ref(t, t.declaration(), None, ctx)
+                    })
+                    .collect()
+            }
+            None => args
+                .filter(|t| t.kind() != CXType_Invalid)
+                .map(|t| Item::from_ty_or_ref(t, t.declaration(), None, ctx))
+                .collect(),
+        });
+
+        let declaration = ty.declaration();
+        let definition = if declaration.kind() == CXCursor_TypeAliasTemplateDecl
+        {
+            Some(declaration)
+        } else {
+            declaration.specialized().or_else(|| {
+                let mut template_ref = None;
+                ty.declaration().visit(|child| {
+                    if child.kind() == CXCursor_TemplateRef {
+                        template_ref = Some(child);
+                        return CXVisit_Break;
+                    }
+
+                    // Instantiations of template aliases might have the
+                    // TemplateRef to the template alias definition arbitrarily
+                    // deep, so we need to recurse here and not only visit
+                    // direct children.
+                    CXChildVisit_Recurse
+                });
+
+                template_ref.and_then(|cur| cur.referenced())
+            })
+        };
+
+        let definition = match definition {
+            Some(def) => def,
+            None => {
+                if !ty.declaration().is_builtin() {
+                    warn!(
+                        "Could not find template definition for template \
+                         instantiation"
+                    );
+                }
+                return None;
+            }
+        };
+
+        let template_definition =
+            Item::from_ty_or_ref(definition.cur_type(), definition, None, ctx);
+
+        Some(TemplateInstantiation::new(
+            template_definition,
+            template_args,
+        ))
+    }
+}
+
+impl IsOpaque for TemplateInstantiation {
+    type Extra = Item;
+
+    /// Is this an opaque template instantiation?
+    fn is_opaque(&self, ctx: &BindgenContext, item: &Item) -> bool {
+        if self.template_definition().is_opaque(ctx, &()) {
+            return true;
+        }
+
+        // TODO(#774): This doesn't properly handle opaque instantiations where
+        // an argument is itself an instantiation because `canonical_name` does
+        // not insert the template arguments into the name, ie it for nested
+        // template arguments it creates "Foo" instead of "Foo<int>". The fully
+        // correct fix is to make `canonical_{name,path}` include template
+        // arguments properly.
+
+        let mut path = item.path_for_allowlisting(ctx).clone();
+        let args: Vec<_> = self
+            .template_arguments()
+            .iter()
+            .map(|arg| {
+                let arg_path =
+                    ctx.resolve_item(*arg).path_for_allowlisting(ctx);
+                arg_path[1..].join("::")
+            })
+            .collect();
+        {
+            let last = path.last_mut().unwrap();
+            last.push('<');
+            last.push_str(&args.join(", "));
+            last.push('>');
+        }
+
+        ctx.opaque_by_name(&path)
+    }
+}
+
+impl Trace for TemplateInstantiation {
+    type Extra = ();
+
+    fn trace<T>(&self, _ctx: &BindgenContext, tracer: &mut T, _: &())
+    where
+        T: Tracer,
+    {
+        tracer
+            .visit_kind(self.definition.into(), EdgeKind::TemplateDeclaration);
+        for arg in self.template_arguments() {
+            tracer.visit_kind(arg.into(), EdgeKind::TemplateArgument);
+        }
+    }
+}
diff --git a/bindgen/ir/traversal.rs b/bindgen/ir/traversal.rs
new file mode 100644
index 00000000..f14483f2
--- /dev/null
+++ b/bindgen/ir/traversal.rs
@@ -0,0 +1,478 @@
+//! Traversal of the graph of IR items and types.
+
+use super::context::{BindgenContext, ItemId};
+use super::item::ItemSet;
+use std::collections::{BTreeMap, VecDeque};
+
+/// An outgoing edge in the IR graph is a reference from some item to another
+/// item:
+///
+///   from --> to
+///
+/// The `from` is left implicit: it is the concrete `Trace` implementer which
+/// yielded this outgoing edge.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Edge {
+    to: ItemId,
+    kind: EdgeKind,
+}
+
+impl Edge {
+    /// Construct a new edge whose referent is `to` and is of the given `kind`.
+    pub fn new(to: ItemId, kind: EdgeKind) -> Edge {
+        Edge { to, kind }
+    }
+}
+
+impl From<Edge> for ItemId {
+    fn from(val: Edge) -> Self {
+        val.to
+    }
+}
+
+/// The kind of edge reference. This is useful when we wish to only consider
+/// certain kinds of edges for a particular traversal or analysis.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EdgeKind {
+    /// A generic, catch-all edge.
+    Generic,
+
+    /// An edge from a template declaration, to the definition of a named type
+    /// parameter. For example, the edge from `Foo<T>` to `T` in the following
+    /// snippet:
+    ///
+    /// ```C++
+    /// template<typename T>
+    /// class Foo { };
+    /// ```
+    TemplateParameterDefinition,
+
+    /// An edge from a template instantiation to the template declaration that
+    /// is being instantiated. For example, the edge from `Foo<int>` to
+    /// to `Foo<T>`:
+    ///
+    /// ```C++
+    /// template<typename T>
+    /// class Foo { };
+    ///
+    /// using Bar = Foo<ant>;
+    /// ```
+    TemplateDeclaration,
+
+    /// An edge from a template instantiation to its template argument. For
+    /// example, `Foo<Bar>` to `Bar`:
+    ///
+    /// ```C++
+    /// template<typename T>
+    /// class Foo { };
+    ///
+    /// class Bar { };
+    ///
+    /// using FooBar = Foo<Bar>;
+    /// ```
+    TemplateArgument,
+
+    /// An edge from a compound type to one of its base member types. For
+    /// example, the edge from `Bar` to `Foo`:
+    ///
+    /// ```C++
+    /// class Foo { };
+    ///
+    /// class Bar : public Foo { };
+    /// ```
+    BaseMember,
+
+    /// An edge from a compound type to the types of one of its fields. For
+    /// example, the edge from `Foo` to `int`:
+    ///
+    /// ```C++
+    /// class Foo {
+    ///     int x;
+    /// };
+    /// ```
+    Field,
+
+    /// An edge from an class or struct type to an inner type member. For
+    /// example, the edge from `Foo` to `Foo::Bar` here:
+    ///
+    /// ```C++
+    /// class Foo {
+    ///     struct Bar { };
+    /// };
+    /// ```
+    InnerType,
+
+    /// An edge from an class or struct type to an inner static variable. For
+    /// example, the edge from `Foo` to `Foo::BAR` here:
+    ///
+    /// ```C++
+    /// class Foo {
+    ///     static const char* BAR;
+    /// };
+    /// ```
+    InnerVar,
+
+    /// An edge from a class or struct type to one of its method functions. For
+    /// example, the edge from `Foo` to `Foo::bar`:
+    ///
+    /// ```C++
+    /// class Foo {
+    ///     bool bar(int x, int y);
+    /// };
+    /// ```
+    Method,
+
+    /// An edge from a class or struct type to one of its constructor
+    /// functions. For example, the edge from `Foo` to `Foo::Foo(int x, int y)`:
+    ///
+    /// ```C++
+    /// class Foo {
+    ///     int my_x;
+    ///     int my_y;
+    ///
+    ///   public:
+    ///     Foo(int x, int y);
+    /// };
+    /// ```
+    Constructor,
+
+    /// An edge from a class or struct type to its destructor function. For
+    /// example, the edge from `Doggo` to `Doggo::~Doggo()`:
+    ///
+    /// ```C++
+    /// struct Doggo {
+    ///     char* wow;
+    ///
+    ///   public:
+    ///     ~Doggo();
+    /// };
+    /// ```
+    Destructor,
+
+    /// An edge from a function declaration to its return type. For example, the
+    /// edge from `foo` to `int`:
+    ///
+    /// ```C++
+    /// int foo(char* string);
+    /// ```
+    FunctionReturn,
+
+    /// An edge from a function declaration to one of its parameter types. For
+    /// example, the edge from `foo` to `char*`:
+    ///
+    /// ```C++
+    /// int foo(char* string);
+    /// ```
+    FunctionParameter,
+
+    /// An edge from a static variable to its type. For example, the edge from
+    /// `FOO` to `const char*`:
+    ///
+    /// ```C++
+    /// static const char* FOO;
+    /// ```
+    VarType,
+
+    /// An edge from a non-templated alias or typedef to the referenced type.
+    TypeReference,
+}
+
+/// A predicate to allow visiting only sub-sets of the whole IR graph by
+/// excluding certain edges from being followed by the traversal.
+///
+/// The predicate must return true if the traversal should follow this edge
+/// and visit everything that is reachable through it.
+pub type TraversalPredicate = for<'a> fn(&'a BindgenContext, Edge) -> bool;
+
+/// A `TraversalPredicate` implementation that follows all edges, and therefore
+/// traversals using this predicate will see the whole IR graph reachable from
+/// the traversal's roots.
+pub fn all_edges(_: &BindgenContext, _: Edge) -> bool {
+    true
+}
+
+/// A `TraversalPredicate` implementation that only follows
+/// `EdgeKind::InnerType` edges, and therefore traversals using this predicate
+/// will only visit the traversal's roots and their inner types. This is used
+/// in no-recursive-allowlist mode, where inner types such as anonymous
+/// structs/unions still need to be processed.
+pub fn only_inner_type_edges(_: &BindgenContext, edge: Edge) -> bool {
+    edge.kind == EdgeKind::InnerType
+}
+
+/// A `TraversalPredicate` implementation that only follows edges to items that
+/// are enabled for code generation. This lets us skip considering items for
+/// which are not reachable from code generation.
+pub fn codegen_edges(ctx: &BindgenContext, edge: Edge) -> bool {
+    let cc = &ctx.options().codegen_config;
+    match edge.kind {
+        EdgeKind::Generic => {
+            ctx.resolve_item(edge.to).is_enabled_for_codegen(ctx)
+        }
+
+        // We statically know the kind of item that non-generic edges can point
+        // to, so we don't need to actually resolve the item and check
+        // `Item::is_enabled_for_codegen`.
+        EdgeKind::TemplateParameterDefinition |
+        EdgeKind::TemplateArgument |
+        EdgeKind::TemplateDeclaration |
+        EdgeKind::BaseMember |
+        EdgeKind::Field |
+        EdgeKind::InnerType |
+        EdgeKind::FunctionReturn |
+        EdgeKind::FunctionParameter |
+        EdgeKind::VarType |
+        EdgeKind::TypeReference => cc.types(),
+        EdgeKind::InnerVar => cc.vars(),
+        EdgeKind::Method => cc.methods(),
+        EdgeKind::Constructor => cc.constructors(),
+        EdgeKind::Destructor => cc.destructors(),
+    }
+}
+
+/// The storage for the set of items that have been seen (although their
+/// outgoing edges might not have been fully traversed yet) in an active
+/// traversal.
+pub trait TraversalStorage<'ctx> {
+    /// Construct a new instance of this TraversalStorage, for a new traversal.
+    fn new(ctx: &'ctx BindgenContext) -> Self;
+
+    /// Add the given item to the storage. If the item has never been seen
+    /// before, return `true`. Otherwise, return `false`.
+    ///
+    /// The `from` item is the item from which we discovered this item, or is
+    /// `None` if this item is a root.
+    fn add(&mut self, from: Option<ItemId>, item: ItemId) -> bool;
+}
+
+impl<'ctx> TraversalStorage<'ctx> for ItemSet {
+    fn new(_: &'ctx BindgenContext) -> Self {
+        ItemSet::new()
+    }
+
+    fn add(&mut self, _: Option<ItemId>, item: ItemId) -> bool {
+        self.insert(item)
+    }
+}
+
+/// A `TraversalStorage` implementation that keeps track of how we first reached
+/// each item. This is useful for providing debug assertions with meaningful
+/// diagnostic messages about dangling items.
+#[derive(Debug)]
+pub struct Paths<'ctx>(BTreeMap<ItemId, ItemId>, &'ctx BindgenContext);
+
+impl<'ctx> TraversalStorage<'ctx> for Paths<'ctx> {
+    fn new(ctx: &'ctx BindgenContext) -> Self {
+        Paths(BTreeMap::new(), ctx)
+    }
+
+    fn add(&mut self, from: Option<ItemId>, item: ItemId) -> bool {
+        let newly_discovered =
+            self.0.insert(item, from.unwrap_or(item)).is_none();
+
+        if self.1.resolve_item_fallible(item).is_none() {
+            let mut path = vec![];
+            let mut current = item;
+            loop {
+                let predecessor = *self.0.get(&current).expect(
+                    "We know we found this item id, so it must have a \
+                     predecessor",
+                );
+                if predecessor == current {
+                    break;
+                }
+                path.push(predecessor);
+                current = predecessor;
+            }
+            path.reverse();
+            panic!(
+                "Found reference to dangling id = {:?}\nvia path = {:?}",
+                item, path
+            );
+        }
+
+        newly_discovered
+    }
+}
+
+/// The queue of seen-but-not-yet-traversed items.
+///
+/// Using a FIFO queue with a traversal will yield a breadth-first traversal,
+/// while using a LIFO queue will result in a depth-first traversal of the IR
+/// graph.
+pub trait TraversalQueue: Default {
+    /// Add a newly discovered item to the queue.
+    fn push(&mut self, item: ItemId);
+
+    /// Pop the next item to traverse, if any.
+    fn next(&mut self) -> Option<ItemId>;
+}
+
+impl TraversalQueue for Vec<ItemId> {
+    fn push(&mut self, item: ItemId) {
+        self.push(item);
+    }
+
+    fn next(&mut self) -> Option<ItemId> {
+        self.pop()
+    }
+}
+
+impl TraversalQueue for VecDeque<ItemId> {
+    fn push(&mut self, item: ItemId) {
+        self.push_back(item);
+    }
+
+    fn next(&mut self) -> Option<ItemId> {
+        self.pop_front()
+    }
+}
+
+/// Something that can receive edges from a `Trace` implementation.
+pub trait Tracer {
+    /// Note an edge between items. Called from within a `Trace` implementation.
+    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind);
+
+    /// A synonym for `tracer.visit_kind(item, EdgeKind::Generic)`.
+    fn visit(&mut self, item: ItemId) {
+        self.visit_kind(item, EdgeKind::Generic);
+    }
+}
+
+impl<F> Tracer for F
+where
+    F: FnMut(ItemId, EdgeKind),
+{
+    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind) {
+        (*self)(item, kind)
+    }
+}
+
+/// Trace all of the outgoing edges to other items. Implementations should call
+/// one of `tracer.visit(edge)` or `tracer.visit_kind(edge, EdgeKind::Whatever)`
+/// for each of their outgoing edges.
+pub trait Trace {
+    /// If a particular type needs extra information beyond what it has in
+    /// `self` and `context` to find its referenced items, its implementation
+    /// can define this associated type, forcing callers to pass the needed
+    /// information through.
+    type Extra;
+
+    /// Trace all of this item's outgoing edges to other items.
+    fn trace<T>(
+        &self,
+        context: &BindgenContext,
+        tracer: &mut T,
+        extra: &Self::Extra,
+    ) where
+        T: Tracer;
+}
+
+/// An graph traversal of the transitive closure of references between items.
+///
+/// See `BindgenContext::allowlisted_items` for more information.
+pub struct ItemTraversal<'ctx, Storage, Queue>
+where
+    Storage: TraversalStorage<'ctx>,
+    Queue: TraversalQueue,
+{
+    ctx: &'ctx BindgenContext,
+
+    /// The set of items we have seen thus far in this traversal.
+    seen: Storage,
+
+    /// The set of items that we have seen, but have yet to traverse.
+    queue: Queue,
+
+    /// The predicate that determines which edges this traversal will follow.
+    predicate: TraversalPredicate,
+
+    /// The item we are currently traversing.
+    currently_traversing: Option<ItemId>,
+}
+
+impl<'ctx, Storage, Queue> ItemTraversal<'ctx, Storage, Queue>
+where
+    Storage: TraversalStorage<'ctx>,
+    Queue: TraversalQueue,
+{
+    /// Begin a new traversal, starting from the given roots.
+    pub fn new<R>(
+        ctx: &'ctx BindgenContext,
+        roots: R,
+        predicate: TraversalPredicate,
+    ) -> ItemTraversal<'ctx, Storage, Queue>
+    where
+        R: IntoIterator<Item = ItemId>,
+    {
+        let mut seen = Storage::new(ctx);
+        let mut queue = Queue::default();
+
+        for id in roots {
+            seen.add(None, id);
+            queue.push(id);
+        }
+
+        ItemTraversal {
+            ctx,
+            seen,
+            queue,
+            predicate,
+            currently_traversing: None,
+        }
+    }
+}
+
+impl<'ctx, Storage, Queue> Tracer for ItemTraversal<'ctx, Storage, Queue>
+where
+    Storage: TraversalStorage<'ctx>,
+    Queue: TraversalQueue,
+{
+    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind) {
+        let edge = Edge::new(item, kind);
+        if !(self.predicate)(self.ctx, edge) {
+            return;
+        }
+
+        let is_newly_discovered =
+            self.seen.add(self.currently_traversing, item);
+        if is_newly_discovered {
+            self.queue.push(item)
+        }
+    }
+}
+
+impl<'ctx, Storage, Queue> Iterator for ItemTraversal<'ctx, Storage, Queue>
+where
+    Storage: TraversalStorage<'ctx>,
+    Queue: TraversalQueue,
+{
+    type Item = ItemId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let id = self.queue.next()?;
+
+        let newly_discovered = self.seen.add(None, id);
+        debug_assert!(
+            !newly_discovered,
+            "should have already seen anything we get out of our queue"
+        );
+        debug_assert!(
+            self.ctx.resolve_item_fallible(id).is_some(),
+            "should only get IDs of actual items in our context during traversal"
+        );
+
+        self.currently_traversing = Some(id);
+        id.trace(self.ctx, self, &());
+        self.currently_traversing = None;
+
+        Some(id)
+    }
+}
+
+/// An iterator to find any dangling items.
+///
+/// See `BindgenContext::assert_no_dangling_item_traversal` for more
+/// information.
+pub type AssertNoDanglingItemsTraversal<'ctx> =
+    ItemTraversal<'ctx, Paths<'ctx>, VecDeque<ItemId>>;
diff --git a/bindgen/ir/ty.rs b/bindgen/ir/ty.rs
new file mode 100644
index 00000000..6a3fd0e8
--- /dev/null
+++ b/bindgen/ir/ty.rs
@@ -0,0 +1,1266 @@
+//! Everything related to types in our intermediate representation.
+
+use super::comp::CompInfo;
+use super::context::{BindgenContext, ItemId, TypeId};
+use super::dot::DotAttributes;
+use super::enum_ty::Enum;
+use super::function::FunctionSig;
+use super::int::IntKind;
+use super::item::{IsOpaque, Item};
+use super::layout::{Layout, Opaque};
+use super::objc::ObjCInterface;
+use super::template::{
+    AsTemplateParam, TemplateInstantiation, TemplateParameters,
+};
+use super::traversal::{EdgeKind, Trace, Tracer};
+use crate::clang::{self, Cursor};
+use crate::parse::{ClangItemParser, ParseError, ParseResult};
+use std::borrow::Cow;
+use std::io;
+
+/// The base representation of a type in bindgen.
+///
+/// A type has an optional name, which if present cannot be empty, a `layout`
+/// (size, alignment and packedness) if known, a `Kind`, which determines which
+/// kind of type it is, and whether the type is const.
+#[derive(Debug)]
+pub struct Type {
+    /// The name of the type, or None if it was an unnamed struct or union.
+    name: Option<String>,
+    /// The layout of the type, if known.
+    layout: Option<Layout>,
+    /// The inner kind of the type
+    kind: TypeKind,
+    /// Whether this type is const-qualified.
+    is_const: bool,
+}
+
+/// The maximum number of items in an array for which Rust implements common
+/// traits, and so if we have a type containing an array with more than this
+/// many items, we won't be able to derive common traits on that type.
+///
+pub const RUST_DERIVE_IN_ARRAY_LIMIT: usize = 32;
+
+impl Type {
+    /// Get the underlying `CompInfo` for this type, or `None` if this is some
+    /// other kind of type.
+    pub fn as_comp(&self) -> Option<&CompInfo> {
+        match self.kind {
+            TypeKind::Comp(ref ci) => Some(ci),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying `CompInfo` for this type as a mutable reference, or
+    /// `None` if this is some other kind of type.
+    pub fn as_comp_mut(&mut self) -> Option<&mut CompInfo> {
+        match self.kind {
+            TypeKind::Comp(ref mut ci) => Some(ci),
+            _ => None,
+        }
+    }
+
+    /// Construct a new `Type`.
+    pub fn new(
+        name: Option<String>,
+        layout: Option<Layout>,
+        kind: TypeKind,
+        is_const: bool,
+    ) -> Self {
+        Type {
+            name,
+            layout,
+            kind,
+            is_const,
+        }
+    }
+
+    /// Which kind of type is this?
+    pub fn kind(&self) -> &TypeKind {
+        &self.kind
+    }
+
+    /// Get a mutable reference to this type's kind.
+    pub fn kind_mut(&mut self) -> &mut TypeKind {
+        &mut self.kind
+    }
+
+    /// Get this type's name.
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    /// Whether this is a block pointer type.
+    pub fn is_block_pointer(&self) -> bool {
+        matches!(self.kind, TypeKind::BlockPointer(..))
+    }
+
+    /// Is this a compound type?
+    pub fn is_comp(&self) -> bool {
+        matches!(self.kind, TypeKind::Comp(..))
+    }
+
+    /// Is this a union?
+    pub fn is_union(&self) -> bool {
+        match self.kind {
+            TypeKind::Comp(ref comp) => comp.is_union(),
+            _ => false,
+        }
+    }
+
+    /// Is this type of kind `TypeKind::TypeParam`?
+    pub fn is_type_param(&self) -> bool {
+        matches!(self.kind, TypeKind::TypeParam)
+    }
+
+    /// Is this a template instantiation type?
+    pub fn is_template_instantiation(&self) -> bool {
+        matches!(self.kind, TypeKind::TemplateInstantiation(..))
+    }
+
+    /// Is this a template alias type?
+    pub fn is_template_alias(&self) -> bool {
+        matches!(self.kind, TypeKind::TemplateAlias(..))
+    }
+
+    /// Is this a function type?
+    pub fn is_function(&self) -> bool {
+        matches!(self.kind, TypeKind::Function(..))
+    }
+
+    /// Is this an enum type?
+    pub fn is_enum(&self) -> bool {
+        matches!(self.kind, TypeKind::Enum(..))
+    }
+
+    /// Is this either a builtin or named type?
+    pub fn is_builtin_or_type_param(&self) -> bool {
+        matches!(
+            self.kind,
+            TypeKind::Void |
+                TypeKind::NullPtr |
+                TypeKind::Function(..) |
+                TypeKind::Array(..) |
+                TypeKind::Reference(..) |
+                TypeKind::Pointer(..) |
+                TypeKind::Int(..) |
+                TypeKind::Float(..) |
+                TypeKind::TypeParam
+        )
+    }
+
+    /// Creates a new named type, with name `name`.
+    pub fn named(name: String) -> Self {
+        let name = if name.is_empty() { None } else { Some(name) };
+        Self::new(name, None, TypeKind::TypeParam, false)
+    }
+
+    /// Is this a floating point type?
+    pub fn is_float(&self) -> bool {
+        matches!(self.kind, TypeKind::Float(..))
+    }
+
+    /// Is this a boolean type?
+    pub fn is_bool(&self) -> bool {
+        matches!(self.kind, TypeKind::Int(IntKind::Bool))
+    }
+
+    /// Is this an integer type?
+    pub fn is_integer(&self) -> bool {
+        matches!(self.kind, TypeKind::Int(..))
+    }
+
+    /// Cast this type to an integer kind, or `None` if it is not an integer
+    /// type.
+    pub fn as_integer(&self) -> Option<IntKind> {
+        match self.kind {
+            TypeKind::Int(int_kind) => Some(int_kind),
+            _ => None,
+        }
+    }
+
+    /// Is this a `const` qualified type?
+    pub fn is_const(&self) -> bool {
+        self.is_const
+    }
+
+    /// Is this a reference to another type?
+    pub fn is_type_ref(&self) -> bool {
+        matches!(
+            self.kind,
+            TypeKind::ResolvedTypeRef(_) | TypeKind::UnresolvedTypeRef(_, _, _)
+        )
+    }
+
+    /// Is this an unresolved reference?
+    pub fn is_unresolved_ref(&self) -> bool {
+        matches!(self.kind, TypeKind::UnresolvedTypeRef(_, _, _))
+    }
+
+    /// Is this a incomplete array type?
+    pub fn is_incomplete_array(&self, ctx: &BindgenContext) -> Option<ItemId> {
+        match self.kind {
+            TypeKind::Array(item, len) => {
+                if len == 0 {
+                    Some(item.into())
+                } else {
+                    None
+                }
+            }
+            TypeKind::ResolvedTypeRef(inner) => {
+                ctx.resolve_type(inner).is_incomplete_array(ctx)
+            }
+            _ => None,
+        }
+    }
+
+    /// What is the layout of this type?
+    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
+        self.layout.or_else(|| {
+            match self.kind {
+                TypeKind::Comp(ref ci) => ci.layout(ctx),
+                TypeKind::Array(inner, length) if length == 0 => Some(
+                    Layout::new(0, ctx.resolve_type(inner).layout(ctx)?.align),
+                ),
+                // FIXME(emilio): This is a hack for anonymous union templates.
+                // Use the actual pointer size!
+                TypeKind::Pointer(..) => Some(Layout::new(
+                    ctx.target_pointer_size(),
+                    ctx.target_pointer_size(),
+                )),
+                TypeKind::ResolvedTypeRef(inner) => {
+                    ctx.resolve_type(inner).layout(ctx)
+                }
+                _ => None,
+            }
+        })
+    }
+
+    /// Whether this named type is an invalid C++ identifier. This is done to
+    /// avoid generating invalid code with some cases we can't handle, see:
+    ///
+    /// tests/headers/381-decltype-alias.hpp
+    pub fn is_invalid_type_param(&self) -> bool {
+        match self.kind {
+            TypeKind::TypeParam => {
+                let name = self.name().expect("Unnamed named type?");
+                !clang::is_valid_identifier(name)
+            }
+            _ => false,
+        }
+    }
+
+    /// Takes `name`, and returns a suitable identifier representation for it.
+    fn sanitize_name(name: &str) -> Cow<str> {
+        if clang::is_valid_identifier(name) {
+            return Cow::Borrowed(name);
+        }
+
+        let name = name.replace(|c| c == ' ' || c == ':' || c == '.', "_");
+        Cow::Owned(name)
+    }
+
+    /// Get this type's santizied name.
+    pub fn sanitized_name<'a>(
+        &'a self,
+        ctx: &BindgenContext,
+    ) -> Option<Cow<'a, str>> {
+        let name_info = match *self.kind() {
+            TypeKind::Pointer(inner) => Some((inner, Cow::Borrowed("ptr"))),
+            TypeKind::Reference(inner) => Some((inner, Cow::Borrowed("ref"))),
+            TypeKind::Array(inner, length) => {
+                Some((inner, format!("array{}", length).into()))
+            }
+            _ => None,
+        };
+        if let Some((inner, prefix)) = name_info {
+            ctx.resolve_item(inner)
+                .expect_type()
+                .sanitized_name(ctx)
+                .map(|name| format!("{}_{}", prefix, name).into())
+        } else {
+            self.name().map(Self::sanitize_name)
+        }
+    }
+
+    /// See safe_canonical_type.
+    pub fn canonical_type<'tr>(
+        &'tr self,
+        ctx: &'tr BindgenContext,
+    ) -> &'tr Type {
+        self.safe_canonical_type(ctx)
+            .expect("Should have been resolved after parsing!")
+    }
+
+    /// Returns the canonical type of this type, that is, the "inner type".
+    ///
+    /// For example, for a `typedef`, the canonical type would be the
+    /// `typedef`ed type, for a template instantiation, would be the template
+    /// its specializing, and so on. Return None if the type is unresolved.
+    pub fn safe_canonical_type<'tr>(
+        &'tr self,
+        ctx: &'tr BindgenContext,
+    ) -> Option<&'tr Type> {
+        match self.kind {
+            TypeKind::TypeParam |
+            TypeKind::Array(..) |
+            TypeKind::Vector(..) |
+            TypeKind::Comp(..) |
+            TypeKind::Opaque |
+            TypeKind::Int(..) |
+            TypeKind::Float(..) |
+            TypeKind::Complex(..) |
+            TypeKind::Function(..) |
+            TypeKind::Enum(..) |
+            TypeKind::Reference(..) |
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Pointer(..) |
+            TypeKind::BlockPointer(..) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel |
+            TypeKind::ObjCInterface(..) => Some(self),
+
+            TypeKind::ResolvedTypeRef(inner) |
+            TypeKind::Alias(inner) |
+            TypeKind::TemplateAlias(inner, _) => {
+                ctx.resolve_type(inner).safe_canonical_type(ctx)
+            }
+            TypeKind::TemplateInstantiation(ref inst) => ctx
+                .resolve_type(inst.template_definition())
+                .safe_canonical_type(ctx),
+
+            TypeKind::UnresolvedTypeRef(..) => None,
+        }
+    }
+
+    /// There are some types we don't want to stop at when finding an opaque
+    /// item, so we can arrive to the proper item that needs to be generated.
+    pub fn should_be_traced_unconditionally(&self) -> bool {
+        matches!(
+            self.kind,
+            TypeKind::Comp(..) |
+                TypeKind::Function(..) |
+                TypeKind::Pointer(..) |
+                TypeKind::Array(..) |
+                TypeKind::Reference(..) |
+                TypeKind::TemplateInstantiation(..) |
+                TypeKind::ResolvedTypeRef(..)
+        )
+    }
+}
+
+impl IsOpaque for Type {
+    type Extra = Item;
+
+    fn is_opaque(&self, ctx: &BindgenContext, item: &Item) -> bool {
+        match self.kind {
+            TypeKind::Opaque => true,
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.is_opaque(ctx, item)
+            }
+            TypeKind::Comp(ref comp) => comp.is_opaque(ctx, &self.layout),
+            TypeKind::ResolvedTypeRef(to) => to.is_opaque(ctx, &()),
+            _ => false,
+        }
+    }
+}
+
+impl AsTemplateParam for Type {
+    type Extra = Item;
+
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> Option<TypeId> {
+        self.kind.as_template_param(ctx, item)
+    }
+}
+
+impl AsTemplateParam for TypeKind {
+    type Extra = Item;
+
+    fn as_template_param(
+        &self,
+        ctx: &BindgenContext,
+        item: &Item,
+    ) -> Option<TypeId> {
+        match *self {
+            TypeKind::TypeParam => Some(item.id().expect_type_id(ctx)),
+            TypeKind::ResolvedTypeRef(id) => id.as_template_param(ctx, &()),
+            _ => None,
+        }
+    }
+}
+
+impl DotAttributes for Type {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        if let Some(ref layout) = self.layout {
+            writeln!(
+                out,
+                "<tr><td>size</td><td>{}</td></tr>
+                           <tr><td>align</td><td>{}</td></tr>",
+                layout.size, layout.align
+            )?;
+            if layout.packed {
+                writeln!(out, "<tr><td>packed</td><td>true</td></tr>")?;
+            }
+        }
+
+        if self.is_const {
+            writeln!(out, "<tr><td>const</td><td>true</td></tr>")?;
+        }
+
+        self.kind.dot_attributes(ctx, out)
+    }
+}
+
+impl DotAttributes for TypeKind {
+    fn dot_attributes<W>(
+        &self,
+        ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        writeln!(
+            out,
+            "<tr><td>type kind</td><td>{}</td></tr>",
+            self.kind_name()
+        )?;
+
+        if let TypeKind::Comp(ref comp) = *self {
+            comp.dot_attributes(ctx, out)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl TypeKind {
+    fn kind_name(&self) -> &'static str {
+        match *self {
+            TypeKind::Void => "Void",
+            TypeKind::NullPtr => "NullPtr",
+            TypeKind::Comp(..) => "Comp",
+            TypeKind::Opaque => "Opaque",
+            TypeKind::Int(..) => "Int",
+            TypeKind::Float(..) => "Float",
+            TypeKind::Complex(..) => "Complex",
+            TypeKind::Alias(..) => "Alias",
+            TypeKind::TemplateAlias(..) => "TemplateAlias",
+            TypeKind::Array(..) => "Array",
+            TypeKind::Vector(..) => "Vector",
+            TypeKind::Function(..) => "Function",
+            TypeKind::Enum(..) => "Enum",
+            TypeKind::Pointer(..) => "Pointer",
+            TypeKind::BlockPointer(..) => "BlockPointer",
+            TypeKind::Reference(..) => "Reference",
+            TypeKind::TemplateInstantiation(..) => "TemplateInstantiation",
+            TypeKind::UnresolvedTypeRef(..) => "UnresolvedTypeRef",
+            TypeKind::ResolvedTypeRef(..) => "ResolvedTypeRef",
+            TypeKind::TypeParam => "TypeParam",
+            TypeKind::ObjCInterface(..) => "ObjCInterface",
+            TypeKind::ObjCId => "ObjCId",
+            TypeKind::ObjCSel => "ObjCSel",
+        }
+    }
+}
+
+#[test]
+fn is_invalid_type_param_valid() {
+    let ty = Type::new(Some("foo".into()), None, TypeKind::TypeParam, false);
+    assert!(!ty.is_invalid_type_param())
+}
+
+#[test]
+fn is_invalid_type_param_valid_underscore_and_numbers() {
+    let ty = Type::new(
+        Some("_foo123456789_".into()),
+        None,
+        TypeKind::TypeParam,
+        false,
+    );
+    assert!(!ty.is_invalid_type_param())
+}
+
+#[test]
+fn is_invalid_type_param_valid_unnamed_kind() {
+    let ty = Type::new(Some("foo".into()), None, TypeKind::Void, false);
+    assert!(!ty.is_invalid_type_param())
+}
+
+#[test]
+fn is_invalid_type_param_invalid_start() {
+    let ty = Type::new(Some("1foo".into()), None, TypeKind::TypeParam, false);
+    assert!(ty.is_invalid_type_param())
+}
+
+#[test]
+fn is_invalid_type_param_invalid_remaing() {
+    let ty = Type::new(Some("foo-".into()), None, TypeKind::TypeParam, false);
+    assert!(ty.is_invalid_type_param())
+}
+
+#[test]
+#[should_panic]
+fn is_invalid_type_param_unnamed() {
+    let ty = Type::new(None, None, TypeKind::TypeParam, false);
+    assert!(ty.is_invalid_type_param())
+}
+
+#[test]
+fn is_invalid_type_param_empty_name() {
+    let ty = Type::new(Some("".into()), None, TypeKind::TypeParam, false);
+    assert!(ty.is_invalid_type_param())
+}
+
+impl TemplateParameters for Type {
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
+        self.kind.self_template_params(ctx)
+    }
+}
+
+impl TemplateParameters for TypeKind {
+    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
+        match *self {
+            TypeKind::ResolvedTypeRef(id) => {
+                ctx.resolve_type(id).self_template_params(ctx)
+            }
+            TypeKind::Comp(ref comp) => comp.self_template_params(ctx),
+            TypeKind::TemplateAlias(_, ref args) => args.clone(),
+
+            TypeKind::Opaque |
+            TypeKind::TemplateInstantiation(..) |
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(_) |
+            TypeKind::Float(_) |
+            TypeKind::Complex(_) |
+            TypeKind::Array(..) |
+            TypeKind::Vector(..) |
+            TypeKind::Function(_) |
+            TypeKind::Enum(_) |
+            TypeKind::Pointer(_) |
+            TypeKind::BlockPointer(_) |
+            TypeKind::Reference(_) |
+            TypeKind::UnresolvedTypeRef(..) |
+            TypeKind::TypeParam |
+            TypeKind::Alias(_) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel |
+            TypeKind::ObjCInterface(_) => vec![],
+        }
+    }
+}
+
+/// The kind of float this type represents.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FloatKind {
+    /// A `float`.
+    Float,
+    /// A `double`.
+    Double,
+    /// A `long double`.
+    LongDouble,
+    /// A `__float128`.
+    Float128,
+}
+
+/// The different kinds of types that we can parse.
+#[derive(Debug)]
+pub enum TypeKind {
+    /// The void type.
+    Void,
+
+    /// The `nullptr_t` type.
+    NullPtr,
+
+    /// A compound type, that is, a class, struct, or union.
+    Comp(CompInfo),
+
+    /// An opaque type that we just don't understand. All usage of this shoulf
+    /// result in an opaque blob of bytes generated from the containing type's
+    /// layout.
+    Opaque,
+
+    /// An integer type, of a given kind. `bool` and `char` are also considered
+    /// integers.
+    Int(IntKind),
+
+    /// A floating point type.
+    Float(FloatKind),
+
+    /// A complex floating point type.
+    Complex(FloatKind),
+
+    /// A type alias, with a name, that points to another type.
+    Alias(TypeId),
+
+    /// A templated alias, pointing to an inner type, just as `Alias`, but with
+    /// template parameters.
+    TemplateAlias(TypeId, Vec<TypeId>),
+
+    /// A packed vector type: element type, number of elements
+    Vector(TypeId, usize),
+
+    /// An array of a type and a length.
+    Array(TypeId, usize),
+
+    /// A function type, with a given signature.
+    Function(FunctionSig),
+
+    /// An `enum` type.
+    Enum(Enum),
+
+    /// A pointer to a type. The bool field represents whether it's const or
+    /// not.
+    Pointer(TypeId),
+
+    /// A pointer to an Apple block.
+    BlockPointer(TypeId),
+
+    /// A reference to a type, as in: int& foo().
+    Reference(TypeId),
+
+    /// An instantiation of an abstract template definition with a set of
+    /// concrete template arguments.
+    TemplateInstantiation(TemplateInstantiation),
+
+    /// A reference to a yet-to-resolve type. This stores the clang cursor
+    /// itself, and postpones its resolution.
+    ///
+    /// These are gone in a phase after parsing where these are mapped to
+    /// already known types, and are converted to ResolvedTypeRef.
+    ///
+    /// see tests/headers/typeref.hpp to see somewhere where this is a problem.
+    UnresolvedTypeRef(
+        clang::Type,
+        clang::Cursor,
+        /* parent_id */
+        Option<ItemId>,
+    ),
+
+    /// An indirection to another type.
+    ///
+    /// These are generated after we resolve a forward declaration, or when we
+    /// replace one type with another.
+    ResolvedTypeRef(TypeId),
+
+    /// A named type, that is, a template parameter.
+    TypeParam,
+
+    /// Objective C interface. Always referenced through a pointer
+    ObjCInterface(ObjCInterface),
+
+    /// Objective C 'id' type, points to any object
+    ObjCId,
+
+    /// Objective C selector type
+    ObjCSel,
+}
+
+impl Type {
+    /// This is another of the nasty methods. This one is the one that takes
+    /// care of the core logic of converting a clang type to a `Type`.
+    ///
+    /// It's sort of nasty and full of special-casing, but hopefully the
+    /// comments in every special case justify why they're there.
+    pub fn from_clang_ty(
+        potential_id: ItemId,
+        ty: &clang::Type,
+        location: Cursor,
+        parent_id: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<ParseResult<Self>, ParseError> {
+        use clang_sys::*;
+        {
+            let already_resolved = ctx.builtin_or_resolved_ty(
+                potential_id,
+                parent_id,
+                ty,
+                Some(location),
+            );
+            if let Some(ty) = already_resolved {
+                debug!("{:?} already resolved: {:?}", ty, location);
+                return Ok(ParseResult::AlreadyResolved(ty.into()));
+            }
+        }
+
+        let layout = ty.fallible_layout(ctx).ok();
+        let cursor = ty.declaration();
+        let mut name = cursor.spelling();
+
+        debug!(
+            "from_clang_ty: {:?}, ty: {:?}, loc: {:?}",
+            potential_id, ty, location
+        );
+        debug!("currently_parsed_types: {:?}", ctx.currently_parsed_types());
+
+        let canonical_ty = ty.canonical_type();
+
+        // Parse objc protocols as if they were interfaces
+        let mut ty_kind = ty.kind();
+        match location.kind() {
+            CXCursor_ObjCProtocolDecl | CXCursor_ObjCCategoryDecl => {
+                ty_kind = CXType_ObjCInterface
+            }
+            _ => {}
+        }
+
+        // Objective C template type parameter
+        // FIXME: This is probably wrong, we are attempting to find the
+        //        objc template params, which seem to manifest as a typedef.
+        //        We are rewriting them as id to suppress multiple conflicting
+        //        typedefs at root level
+        if ty_kind == CXType_Typedef {
+            let is_template_type_param =
+                ty.declaration().kind() == CXCursor_TemplateTypeParameter;
+            let is_canonical_objcpointer =
+                canonical_ty.kind() == CXType_ObjCObjectPointer;
+
+            // We have found a template type for objc interface
+            if is_canonical_objcpointer && is_template_type_param {
+                // Objective-C generics are just ids with fancy name.
+                // To keep it simple, just name them ids
+                name = "id".to_owned();
+            }
+        }
+
+        if location.kind() == CXCursor_ClassTemplatePartialSpecialization {
+            // Sorry! (Not sorry)
+            warn!(
+                "Found a partial template specialization; bindgen does not \
+                 support partial template specialization! Constructing \
+                 opaque type instead."
+            );
+            return Ok(ParseResult::New(
+                Opaque::from_clang_ty(&canonical_ty, ctx),
+                None,
+            ));
+        }
+
+        let kind = if location.kind() == CXCursor_TemplateRef ||
+            (ty.template_args().is_some() && ty_kind != CXType_Typedef)
+        {
+            // This is a template instantiation.
+            match TemplateInstantiation::from_ty(ty, ctx) {
+                Some(inst) => TypeKind::TemplateInstantiation(inst),
+                None => TypeKind::Opaque,
+            }
+        } else {
+            match ty_kind {
+                CXType_Unexposed
+                    if *ty != canonical_ty &&
+                                    canonical_ty.kind() != CXType_Invalid &&
+                                    ty.ret_type().is_none() &&
+                                    // Sometime clang desugars some types more than
+                                    // what we need, specially with function
+                                    // pointers.
+                                    //
+                                    // We should also try the solution of inverting
+                                    // those checks instead of doing this, that is,
+                                    // something like:
+                                    //
+                                    // CXType_Unexposed if ty.ret_type().is_some()
+                                    //   => { ... }
+                                    //
+                                    // etc.
+                                    !canonical_ty.spelling().contains("type-parameter") =>
+                {
+                    debug!("Looking for canonical type: {:?}", canonical_ty);
+                    return Self::from_clang_ty(
+                        potential_id,
+                        &canonical_ty,
+                        location,
+                        parent_id,
+                        ctx,
+                    );
+                }
+                CXType_Unexposed | CXType_Invalid => {
+                    // For some reason Clang doesn't give us any hint in some
+                    // situations where we should generate a function pointer (see
+                    // tests/headers/func_ptr_in_struct.h), so we do a guess here
+                    // trying to see if it has a valid return type.
+                    if ty.ret_type().is_some() {
+                        let signature =
+                            FunctionSig::from_ty(ty, &location, ctx)?;
+                        TypeKind::Function(signature)
+                    // Same here, with template specialisations we can safely
+                    // assume this is a Comp(..)
+                    } else if ty.is_fully_instantiated_template() {
+                        debug!(
+                            "Template specialization: {:?}, {:?} {:?}",
+                            ty, location, canonical_ty
+                        );
+                        let complex = CompInfo::from_ty(
+                            potential_id,
+                            ty,
+                            Some(location),
+                            ctx,
+                        )
+                        .expect("C'mon");
+                        TypeKind::Comp(complex)
+                    } else {
+                        match location.kind() {
+                            CXCursor_CXXBaseSpecifier |
+                            CXCursor_ClassTemplate => {
+                                if location.kind() == CXCursor_CXXBaseSpecifier
+                                {
+                                    // In the case we're parsing a base specifier
+                                    // inside an unexposed or invalid type, it means
+                                    // that we're parsing one of two things:
+                                    //
+                                    //  * A template parameter.
+                                    //  * A complex class that isn't exposed.
+                                    //
+                                    // This means, unfortunately, that there's no
+                                    // good way to differentiate between them.
+                                    //
+                                    // Probably we could try to look at the
+                                    // declaration and complicate more this logic,
+                                    // but we'll keep it simple... if it's a valid
+                                    // C++ identifier, we'll consider it as a
+                                    // template parameter.
+                                    //
+                                    // This is because:
+                                    //
+                                    //  * We expect every other base that is a
+                                    //    proper identifier (that is, a simple
+                                    //    struct/union declaration), to be exposed,
+                                    //    so this path can't be reached in that
+                                    //    case.
+                                    //
+                                    //  * Quite conveniently, complex base
+                                    //    specifiers preserve their full names (that
+                                    //    is: Foo<T> instead of Foo). We can take
+                                    //    advantage of this.
+                                    //
+                                    // If we find some edge case where this doesn't
+                                    // work (which I guess is unlikely, see the
+                                    // different test cases[1][2][3][4]), we'd need
+                                    // to find more creative ways of differentiating
+                                    // these two cases.
+                                    //
+                                    // [1]: inherit_named.hpp
+                                    // [2]: forward-inherit-struct-with-fields.hpp
+                                    // [3]: forward-inherit-struct.hpp
+                                    // [4]: inherit-namespaced.hpp
+                                    if location.spelling().chars().all(|c| {
+                                        c.is_alphanumeric() || c == '_'
+                                    }) {
+                                        return Err(ParseError::Recurse);
+                                    }
+                                } else {
+                                    name = location.spelling();
+                                }
+
+                                let complex = CompInfo::from_ty(
+                                    potential_id,
+                                    ty,
+                                    Some(location),
+                                    ctx,
+                                );
+                                match complex {
+                                    Ok(complex) => TypeKind::Comp(complex),
+                                    Err(_) => {
+                                        warn!(
+                                            "Could not create complex type \
+                                             from class template or base \
+                                             specifier, using opaque blob"
+                                        );
+                                        let opaque =
+                                            Opaque::from_clang_ty(ty, ctx);
+                                        return Ok(ParseResult::New(
+                                            opaque, None,
+                                        ));
+                                    }
+                                }
+                            }
+                            CXCursor_TypeAliasTemplateDecl => {
+                                debug!("TypeAliasTemplateDecl");
+
+                                // We need to manually unwind this one.
+                                let mut inner = Err(ParseError::Continue);
+                                let mut args = vec![];
+
+                                location.visit(|cur| {
+                                    match cur.kind() {
+                                        CXCursor_TypeAliasDecl => {
+                                            let current = cur.cur_type();
+
+                                            debug_assert_eq!(
+                                                current.kind(),
+                                                CXType_Typedef
+                                            );
+
+                                            name = current.spelling();
+
+                                            let inner_ty = cur
+                                                .typedef_type()
+                                                .expect("Not valid Type?");
+                                            inner = Ok(Item::from_ty_or_ref(
+                                                inner_ty,
+                                                cur,
+                                                Some(potential_id),
+                                                ctx,
+                                            ));
+                                        }
+                                        CXCursor_TemplateTypeParameter => {
+                                            let param = Item::type_param(
+                                                None, cur, ctx,
+                                            )
+                                            .expect(
+                                                "Item::type_param shouldn't \
+                                                 ever fail if we are looking \
+                                                 at a TemplateTypeParameter",
+                                            );
+                                            args.push(param);
+                                        }
+                                        _ => {}
+                                    }
+                                    CXChildVisit_Continue
+                                });
+
+                                let inner_type = match inner {
+                                    Ok(inner) => inner,
+                                    Err(..) => {
+                                        warn!(
+                                            "Failed to parse template alias \
+                                             {:?}",
+                                            location
+                                        );
+                                        return Err(ParseError::Continue);
+                                    }
+                                };
+
+                                TypeKind::TemplateAlias(inner_type, args)
+                            }
+                            CXCursor_TemplateRef => {
+                                let referenced = location.referenced().unwrap();
+                                let referenced_ty = referenced.cur_type();
+
+                                debug!(
+                                    "TemplateRef: location = {:?}; referenced = \
+                                        {:?}; referenced_ty = {:?}",
+                                    location,
+                                    referenced,
+                                    referenced_ty
+                                );
+
+                                return Self::from_clang_ty(
+                                    potential_id,
+                                    &referenced_ty,
+                                    referenced,
+                                    parent_id,
+                                    ctx,
+                                );
+                            }
+                            CXCursor_TypeRef => {
+                                let referenced = location.referenced().unwrap();
+                                let referenced_ty = referenced.cur_type();
+                                let declaration = referenced_ty.declaration();
+
+                                debug!(
+                                    "TypeRef: location = {:?}; referenced = \
+                                     {:?}; referenced_ty = {:?}",
+                                    location, referenced, referenced_ty
+                                );
+
+                                let id = Item::from_ty_or_ref_with_id(
+                                    potential_id,
+                                    referenced_ty,
+                                    declaration,
+                                    parent_id,
+                                    ctx,
+                                );
+                                return Ok(ParseResult::AlreadyResolved(
+                                    id.into(),
+                                ));
+                            }
+                            CXCursor_NamespaceRef => {
+                                return Err(ParseError::Continue);
+                            }
+                            _ => {
+                                if ty.kind() == CXType_Unexposed {
+                                    warn!(
+                                        "Unexposed type {:?}, recursing inside, \
+                                          loc: {:?}",
+                                        ty,
+                                        location
+                                    );
+                                    return Err(ParseError::Recurse);
+                                }
+
+                                warn!("invalid type {:?}", ty);
+                                return Err(ParseError::Continue);
+                            }
+                        }
+                    }
+                }
+                CXType_Auto => {
+                    if canonical_ty == *ty {
+                        debug!("Couldn't find deduced type: {:?}", ty);
+                        return Err(ParseError::Continue);
+                    }
+
+                    return Self::from_clang_ty(
+                        potential_id,
+                        &canonical_ty,
+                        location,
+                        parent_id,
+                        ctx,
+                    );
+                }
+                // NOTE: We don't resolve pointers eagerly because the pointee type
+                // might not have been parsed, and if it contains templates or
+                // something else we might get confused, see the comment inside
+                // TypeRef.
+                //
+                // We might need to, though, if the context is already in the
+                // process of resolving them.
+                CXType_ObjCObjectPointer |
+                CXType_MemberPointer |
+                CXType_Pointer => {
+                    let mut pointee = ty.pointee_type().unwrap();
+                    if *ty != canonical_ty {
+                        let canonical_pointee =
+                            canonical_ty.pointee_type().unwrap();
+                        // clang sometimes loses pointee constness here, see
+                        // #2244.
+                        if canonical_pointee.is_const() != pointee.is_const() {
+                            pointee = canonical_pointee;
+                        }
+                    }
+                    let inner =
+                        Item::from_ty_or_ref(pointee, location, None, ctx);
+                    TypeKind::Pointer(inner)
+                }
+                CXType_BlockPointer => {
+                    let pointee = ty.pointee_type().expect("Not valid Type?");
+                    let inner =
+                        Item::from_ty_or_ref(pointee, location, None, ctx);
+                    TypeKind::BlockPointer(inner)
+                }
+                // XXX: RValueReference is most likely wrong, but I don't think we
+                // can even add bindings for that, so huh.
+                CXType_RValueReference | CXType_LValueReference => {
+                    let inner = Item::from_ty_or_ref(
+                        ty.pointee_type().unwrap(),
+                        location,
+                        None,
+                        ctx,
+                    );
+                    TypeKind::Reference(inner)
+                }
+                // XXX DependentSizedArray is wrong
+                CXType_VariableArray | CXType_DependentSizedArray => {
+                    let inner = Item::from_ty(
+                        ty.elem_type().as_ref().unwrap(),
+                        location,
+                        None,
+                        ctx,
+                    )
+                    .expect("Not able to resolve array element?");
+                    TypeKind::Pointer(inner)
+                }
+                CXType_IncompleteArray => {
+                    let inner = Item::from_ty(
+                        ty.elem_type().as_ref().unwrap(),
+                        location,
+                        None,
+                        ctx,
+                    )
+                    .expect("Not able to resolve array element?");
+                    TypeKind::Array(inner, 0)
+                }
+                CXType_FunctionNoProto | CXType_FunctionProto => {
+                    let signature = FunctionSig::from_ty(ty, &location, ctx)?;
+                    TypeKind::Function(signature)
+                }
+                CXType_Typedef => {
+                    let inner = cursor.typedef_type().expect("Not valid Type?");
+                    let inner =
+                        Item::from_ty_or_ref(inner, location, None, ctx);
+                    if inner == potential_id {
+                        warn!(
+                            "Generating oqaque type instead of self-referential \
+                            typedef");
+                        // This can happen if we bail out of recursive situations
+                        // within the clang parsing.
+                        TypeKind::Opaque
+                    } else {
+                        TypeKind::Alias(inner)
+                    }
+                }
+                CXType_Enum => {
+                    let enum_ = Enum::from_ty(ty, ctx).expect("Not an enum?");
+
+                    if name.is_empty() {
+                        let pretty_name = ty.spelling();
+                        if clang::is_valid_identifier(&pretty_name) {
+                            name = pretty_name;
+                        }
+                    }
+
+                    TypeKind::Enum(enum_)
+                }
+                CXType_Record => {
+                    let complex = CompInfo::from_ty(
+                        potential_id,
+                        ty,
+                        Some(location),
+                        ctx,
+                    )
+                    .expect("Not a complex type?");
+
+                    if name.is_empty() {
+                        // The pretty-printed name may contain typedefed name,
+                        // but may also be "struct (anonymous at .h:1)"
+                        let pretty_name = ty.spelling();
+                        if clang::is_valid_identifier(&pretty_name) {
+                            name = pretty_name;
+                        }
+                    }
+
+                    TypeKind::Comp(complex)
+                }
+                CXType_Vector => {
+                    let inner = Item::from_ty(
+                        ty.elem_type().as_ref().unwrap(),
+                        location,
+                        None,
+                        ctx,
+                    )
+                    .expect("Not able to resolve vector element?");
+                    TypeKind::Vector(inner, ty.num_elements().unwrap())
+                }
+                CXType_ConstantArray => {
+                    let inner = Item::from_ty(
+                        ty.elem_type().as_ref().unwrap(),
+                        location,
+                        None,
+                        ctx,
+                    )
+                    .expect("Not able to resolve array element?");
+                    TypeKind::Array(inner, ty.num_elements().unwrap())
+                }
+                CXType_Elaborated => {
+                    return Self::from_clang_ty(
+                        potential_id,
+                        &ty.named(),
+                        location,
+                        parent_id,
+                        ctx,
+                    );
+                }
+                CXType_ObjCId => TypeKind::ObjCId,
+                CXType_ObjCSel => TypeKind::ObjCSel,
+                CXType_ObjCClass | CXType_ObjCInterface => {
+                    let interface = ObjCInterface::from_ty(&location, ctx)
+                        .expect("Not a valid objc interface?");
+                    name = interface.rust_name();
+                    TypeKind::ObjCInterface(interface)
+                }
+                CXType_Dependent => {
+                    return Err(ParseError::Continue);
+                }
+                _ => {
+                    warn!(
+                        "unsupported type: kind = {:?}; ty = {:?}; at {:?}",
+                        ty.kind(),
+                        ty,
+                        location
+                    );
+                    return Err(ParseError::Continue);
+                }
+            }
+        };
+
+        let name = if name.is_empty() { None } else { Some(name) };
+
+        let is_const = ty.is_const() ||
+            (ty.kind() == CXType_ConstantArray &&
+                ty.elem_type()
+                    .map_or(false, |element| element.is_const()));
+
+        let ty = Type::new(name, layout, kind, is_const);
+        // TODO: maybe declaration.canonical()?
+        Ok(ParseResult::New(ty, Some(cursor.canonical())))
+    }
+}
+
+impl Trace for Type {
+    type Extra = Item;
+
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
+    where
+        T: Tracer,
+    {
+        if self
+            .name()
+            .map_or(false, |name| context.is_stdint_type(name))
+        {
+            // These types are special-cased in codegen and don't need to be traversed.
+            return;
+        }
+        match *self.kind() {
+            TypeKind::Pointer(inner) |
+            TypeKind::Reference(inner) |
+            TypeKind::Array(inner, _) |
+            TypeKind::Vector(inner, _) |
+            TypeKind::BlockPointer(inner) |
+            TypeKind::Alias(inner) |
+            TypeKind::ResolvedTypeRef(inner) => {
+                tracer.visit_kind(inner.into(), EdgeKind::TypeReference);
+            }
+            TypeKind::TemplateAlias(inner, ref template_params) => {
+                tracer.visit_kind(inner.into(), EdgeKind::TypeReference);
+                for param in template_params {
+                    tracer.visit_kind(
+                        param.into(),
+                        EdgeKind::TemplateParameterDefinition,
+                    );
+                }
+            }
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.trace(context, tracer, &());
+            }
+            TypeKind::Comp(ref ci) => ci.trace(context, tracer, item),
+            TypeKind::Function(ref sig) => sig.trace(context, tracer, &()),
+            TypeKind::Enum(ref en) => {
+                if let Some(repr) = en.repr() {
+                    tracer.visit(repr.into());
+                }
+            }
+            TypeKind::UnresolvedTypeRef(_, _, Some(id)) => {
+                tracer.visit(id);
+            }
+
+            TypeKind::ObjCInterface(ref interface) => {
+                interface.trace(context, tracer, &());
+            }
+
+            // None of these variants have edges to other items and types.
+            TypeKind::Opaque |
+            TypeKind::UnresolvedTypeRef(_, _, None) |
+            TypeKind::TypeParam |
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(_) |
+            TypeKind::Float(_) |
+            TypeKind::Complex(_) |
+            TypeKind::ObjCId |
+            TypeKind::ObjCSel => {}
+        }
+    }
+}
diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs
new file mode 100644
index 00000000..eecca4df
--- /dev/null
+++ b/bindgen/ir/var.rs
@@ -0,0 +1,413 @@
+//! Intermediate representation of variables.
+
+use super::super::codegen::MacroTypeVariation;
+use super::context::{BindgenContext, TypeId};
+use super::dot::DotAttributes;
+use super::function::cursor_mangling;
+use super::int::IntKind;
+use super::item::Item;
+use super::ty::{FloatKind, TypeKind};
+use crate::callbacks::MacroParsingBehavior;
+use crate::clang;
+use crate::clang::ClangToken;
+use crate::parse::{
+    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
+};
+use cexpr;
+use std::io;
+use std::num::Wrapping;
+
+/// The type for a constant variable.
+#[derive(Debug)]
+pub enum VarType {
+    /// A boolean.
+    Bool(bool),
+    /// An integer.
+    Int(i64),
+    /// A floating point number.
+    Float(f64),
+    /// A character.
+    Char(u8),
+    /// A string, not necessarily well-formed utf-8.
+    String(Vec<u8>),
+}
+
+/// A `Var` is our intermediate representation of a variable.
+#[derive(Debug)]
+pub struct Var {
+    /// The name of the variable.
+    name: String,
+    /// The mangled name of the variable.
+    mangled_name: Option<String>,
+    /// The type of the variable.
+    ty: TypeId,
+    /// The value of the variable, that needs to be suitable for `ty`.
+    val: Option<VarType>,
+    /// Whether this variable is const.
+    is_const: bool,
+}
+
+impl Var {
+    /// Construct a new `Var`.
+    pub fn new(
+        name: String,
+        mangled_name: Option<String>,
+        ty: TypeId,
+        val: Option<VarType>,
+        is_const: bool,
+    ) -> Var {
+        assert!(!name.is_empty());
+        Var {
+            name,
+            mangled_name,
+            ty,
+            val,
+            is_const,
+        }
+    }
+
+    /// Is this variable `const` qualified?
+    pub fn is_const(&self) -> bool {
+        self.is_const
+    }
+
+    /// The value of this constant variable, if any.
+    pub fn val(&self) -> Option<&VarType> {
+        self.val.as_ref()
+    }
+
+    /// Get this variable's type.
+    pub fn ty(&self) -> TypeId {
+        self.ty
+    }
+
+    /// Get this variable's name.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Get this variable's mangled name.
+    pub fn mangled_name(&self) -> Option<&str> {
+        self.mangled_name.as_deref()
+    }
+}
+
+impl DotAttributes for Var {
+    fn dot_attributes<W>(
+        &self,
+        _ctx: &BindgenContext,
+        out: &mut W,
+    ) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        if self.is_const {
+            writeln!(out, "<tr><td>const</td><td>true</td></tr>")?;
+        }
+
+        if let Some(ref mangled) = self.mangled_name {
+            writeln!(
+                out,
+                "<tr><td>mangled name</td><td>{}</td></tr>",
+                mangled
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+fn default_macro_constant_type(ctx: &BindgenContext, value: i64) -> IntKind {
+    if value < 0 ||
+        ctx.options().default_macro_constant_type ==
+            MacroTypeVariation::Signed
+    {
+        if value < i32::min_value() as i64 || value > i32::max_value() as i64 {
+            IntKind::I64
+        } else if !ctx.options().fit_macro_constants ||
+            value < i16::min_value() as i64 ||
+            value > i16::max_value() as i64
+        {
+            IntKind::I32
+        } else if value < i8::min_value() as i64 ||
+            value > i8::max_value() as i64
+        {
+            IntKind::I16
+        } else {
+            IntKind::I8
+        }
+    } else if value > u32::max_value() as i64 {
+        IntKind::U64
+    } else if !ctx.options().fit_macro_constants ||
+        value > u16::max_value() as i64
+    {
+        IntKind::U32
+    } else if value > u8::max_value() as i64 {
+        IntKind::U16
+    } else {
+        IntKind::U8
+    }
+}
+
+/// Parses tokens from a CXCursor_MacroDefinition pointing into a function-like
+/// macro, and calls the func_macro callback.
+fn handle_function_macro(
+    cursor: &clang::Cursor,
+    callbacks: &dyn crate::callbacks::ParseCallbacks,
+) {
+    let is_closing_paren = |t: &ClangToken| {
+        // Test cheap token kind before comparing exact spellings.
+        t.kind == clang_sys::CXToken_Punctuation && t.spelling() == b")"
+    };
+    let tokens: Vec<_> = cursor.tokens().iter().collect();
+    if let Some(boundary) = tokens.iter().position(is_closing_paren) {
+        let mut spelled = tokens.iter().map(ClangToken::spelling);
+        // Add 1, to convert index to length.
+        let left = spelled.by_ref().take(boundary + 1);
+        let left = left.collect::<Vec<_>>().concat();
+        if let Ok(left) = String::from_utf8(left) {
+            let right: Vec<_> = spelled.collect();
+            callbacks.func_macro(&left, &right);
+        }
+    }
+}
+
+impl ClangSubItemParser for Var {
+    fn parse(
+        cursor: clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Result<ParseResult<Self>, ParseError> {
+        use cexpr::expr::EvalResult;
+        use cexpr::literal::CChar;
+        use clang_sys::*;
+        match cursor.kind() {
+            CXCursor_MacroDefinition => {
+                if let Some(callbacks) = ctx.parse_callbacks() {
+                    match callbacks.will_parse_macro(&cursor.spelling()) {
+                        MacroParsingBehavior::Ignore => {
+                            return Err(ParseError::Continue);
+                        }
+                        MacroParsingBehavior::Default => {}
+                    }
+
+                    if cursor.is_macro_function_like() {
+                        handle_function_macro(&cursor, callbacks);
+                        // We handled the macro, skip macro processing below.
+                        return Err(ParseError::Continue);
+                    }
+                }
+
+                let value = parse_macro(ctx, &cursor);
+
+                let (id, value) = match value {
+                    Some(v) => v,
+                    None => return Err(ParseError::Continue),
+                };
+
+                assert!(!id.is_empty(), "Empty macro name?");
+
+                let previously_defined = ctx.parsed_macro(&id);
+
+                // NB: It's important to "note" the macro even if the result is
+                // not an integer, otherwise we might loose other kind of
+                // derived macros.
+                ctx.note_parsed_macro(id.clone(), value.clone());
+
+                if previously_defined {
+                    let name = String::from_utf8(id).unwrap();
+                    warn!("Duplicated macro definition: {}", name);
+                    return Err(ParseError::Continue);
+                }
+
+                // NOTE: Unwrapping, here and above, is safe, because the
+                // identifier of a token comes straight from clang, and we
+                // enforce utf8 there, so we should have already panicked at
+                // this point.
+                let name = String::from_utf8(id).unwrap();
+                let (type_kind, val) = match value {
+                    EvalResult::Invalid => return Err(ParseError::Continue),
+                    EvalResult::Float(f) => {
+                        (TypeKind::Float(FloatKind::Double), VarType::Float(f))
+                    }
+                    EvalResult::Char(c) => {
+                        let c = match c {
+                            CChar::Char(c) => {
+                                assert_eq!(c.len_utf8(), 1);
+                                c as u8
+                            }
+                            CChar::Raw(c) => {
+                                assert!(c <= ::std::u8::MAX as u64);
+                                c as u8
+                            }
+                        };
+
+                        (TypeKind::Int(IntKind::U8), VarType::Char(c))
+                    }
+                    EvalResult::Str(val) => {
+                        let char_ty = Item::builtin_type(
+                            TypeKind::Int(IntKind::U8),
+                            true,
+                            ctx,
+                        );
+                        if let Some(callbacks) = ctx.parse_callbacks() {
+                            callbacks.str_macro(&name, &val);
+                        }
+                        (TypeKind::Pointer(char_ty), VarType::String(val))
+                    }
+                    EvalResult::Int(Wrapping(value)) => {
+                        let kind = ctx
+                            .parse_callbacks()
+                            .and_then(|c| c.int_macro(&name, value))
+                            .unwrap_or_else(|| {
+                                default_macro_constant_type(ctx, value)
+                            });
+
+                        (TypeKind::Int(kind), VarType::Int(value))
+                    }
+                };
+
+                let ty = Item::builtin_type(type_kind, true, ctx);
+
+                Ok(ParseResult::New(
+                    Var::new(name, None, ty, Some(val), true),
+                    Some(cursor),
+                ))
+            }
+            CXCursor_VarDecl => {
+                let name = cursor.spelling();
+                if name.is_empty() {
+                    warn!("Empty constant name?");
+                    return Err(ParseError::Continue);
+                }
+
+                let ty = cursor.cur_type();
+
+                // TODO(emilio): do we have to special-case constant arrays in
+                // some other places?
+                let is_const = ty.is_const() ||
+                    (ty.kind() == CXType_ConstantArray &&
+                        ty.elem_type()
+                            .map_or(false, |element| element.is_const()));
+
+                let ty = match Item::from_ty(&ty, cursor, None, ctx) {
+                    Ok(ty) => ty,
+                    Err(e) => {
+                        assert_eq!(
+                            ty.kind(),
+                            CXType_Auto,
+                            "Couldn't resolve constant type, and it \
+                             wasn't an nondeductible auto type!"
+                        );
+                        return Err(e);
+                    }
+                };
+
+                // Note: Ty might not be totally resolved yet, see
+                // tests/headers/inner_const.hpp
+                //
+                // That's fine because in that case we know it's not a literal.
+                let canonical_ty = ctx
+                    .safe_resolve_type(ty)
+                    .and_then(|t| t.safe_canonical_type(ctx));
+
+                let is_integer = canonical_ty.map_or(false, |t| t.is_integer());
+                let is_float = canonical_ty.map_or(false, |t| t.is_float());
+
+                // TODO: We could handle `char` more gracefully.
+                // TODO: Strings, though the lookup is a bit more hard (we need
+                // to look at the canonical type of the pointee too, and check
+                // is char, u8, or i8 I guess).
+                let value = if is_integer {
+                    let kind = match *canonical_ty.unwrap().kind() {
+                        TypeKind::Int(kind) => kind,
+                        _ => unreachable!(),
+                    };
+
+                    let mut val = cursor.evaluate().and_then(|v| v.as_int());
+                    if val.is_none() || !kind.signedness_matches(val.unwrap()) {
+                        val = get_integer_literal_from_cursor(&cursor);
+                    }
+
+                    val.map(|val| {
+                        if kind == IntKind::Bool {
+                            VarType::Bool(val != 0)
+                        } else {
+                            VarType::Int(val)
+                        }
+                    })
+                } else if is_float {
+                    cursor
+                        .evaluate()
+                        .and_then(|v| v.as_double())
+                        .map(VarType::Float)
+                } else {
+                    cursor
+                        .evaluate()
+                        .and_then(|v| v.as_literal_string())
+                        .map(VarType::String)
+                };
+
+                let mangling = cursor_mangling(ctx, &cursor);
+                let var = Var::new(name, mangling, ty, value, is_const);
+
+                Ok(ParseResult::New(var, Some(cursor)))
+            }
+            _ => {
+                /* TODO */
+                Err(ParseError::Continue)
+            }
+        }
+    }
+}
+
+/// Try and parse a macro using all the macros parsed until now.
+fn parse_macro(
+    ctx: &BindgenContext,
+    cursor: &clang::Cursor,
+) -> Option<(Vec<u8>, cexpr::expr::EvalResult)> {
+    use cexpr::expr;
+
+    let cexpr_tokens = cursor.cexpr_tokens();
+
+    let parser = expr::IdentifierParser::new(ctx.parsed_macros());
+
+    match parser.macro_definition(&cexpr_tokens) {
+        Ok((_, (id, val))) => Some((id.into(), val)),
+        _ => None,
+    }
+}
+
+fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option<i64> {
+    use cexpr::expr;
+    use cexpr::expr::EvalResult;
+
+    let cexpr_tokens = cursor.cexpr_tokens();
+
+    // TODO(emilio): We can try to parse other kinds of literals.
+    match expr::expr(&cexpr_tokens) {
+        Ok((_, EvalResult::Int(Wrapping(val)))) => Some(val),
+        _ => None,
+    }
+}
+
+fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option<i64> {
+    use clang_sys::*;
+    let mut value = None;
+    cursor.visit(|c| {
+        match c.kind() {
+            CXCursor_IntegerLiteral | CXCursor_UnaryOperator => {
+                value = parse_int_literal_tokens(&c);
+            }
+            CXCursor_UnexposedExpr => {
+                value = get_integer_literal_from_cursor(&c);
+            }
+            _ => (),
+        }
+        if value.is_some() {
+            CXChildVisit_Break
+        } else {
+            CXChildVisit_Continue
+        }
+    });
+    value
+}
diff --git a/bindgen/lib.rs b/bindgen/lib.rs
new file mode 100644
index 00000000..6e6fa225
--- /dev/null
+++ b/bindgen/lib.rs
@@ -0,0 +1,2928 @@
+//! Generate Rust bindings for C and C++ libraries.
+//!
+//! Provide a C/C++ header file, receive Rust FFI code to call into C/C++
+//! functions and use types defined in the header.
+//!
+//! See the [`Builder`](./struct.Builder.html) struct for usage.
+//!
+//! See the [Users Guide](https://rust-lang.github.io/rust-bindgen/) for
+//! additional documentation.
+#![deny(missing_docs)]
+#![deny(unused_extern_crates)]
+// To avoid rather annoying warnings when matching with CXCursor_xxx as a
+// constant.
+#![allow(non_upper_case_globals)]
+// `quote!` nests quite deeply.
+#![recursion_limit = "128"]
+
+#[macro_use]
+extern crate bitflags;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate quote;
+
+#[cfg(feature = "logging")]
+#[macro_use]
+extern crate log;
+
+#[cfg(not(feature = "logging"))]
+#[macro_use]
+mod log_stubs;
+
+#[macro_use]
+mod extra_assertions;
+
+// A macro to declare an internal module for which we *must* provide
+// documentation for. If we are building with the "testing_only_docs" feature,
+// then the module is declared public, and our `#![deny(missing_docs)]` pragma
+// applies to it. This feature is used in CI, so we won't let anything slip by
+// undocumented. Normal builds, however, will leave the module private, so that
+// we don't expose internals to library consumers.
+macro_rules! doc_mod {
+    ($m:ident, $doc_mod_name:ident) => {
+        #[cfg(feature = "testing_only_docs")]
+        pub mod $doc_mod_name {
+            //! Autogenerated documentation module.
+            pub use super::$m::*;
+        }
+    };
+}
+
+mod clang;
+mod codegen;
+mod deps;
+mod features;
+mod ir;
+mod parse;
+mod regex_set;
+mod time;
+
+pub mod callbacks;
+
+doc_mod!(clang, clang_docs);
+doc_mod!(features, features_docs);
+doc_mod!(ir, ir_docs);
+doc_mod!(parse, parse_docs);
+doc_mod!(regex_set, regex_set_docs);
+
+pub use crate::codegen::{
+    AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
+};
+use crate::features::RustFeatures;
+pub use crate::features::{
+    RustTarget, LATEST_STABLE_RUST, RUST_TARGET_STRINGS,
+};
+use crate::ir::context::{BindgenContext, ItemId};
+use crate::ir::item::Item;
+use crate::parse::{ClangItemParser, ParseError};
+use crate::regex_set::RegexSet;
+
+use std::borrow::Cow;
+use std::fs::{File, OpenOptions};
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::rc::Rc;
+use std::{env, iter};
+
+// Some convenient typedefs for a fast hash map and hash set.
+type HashMap<K, V> = ::rustc_hash::FxHashMap<K, V>;
+type HashSet<K> = ::rustc_hash::FxHashSet<K>;
+pub(crate) use std::collections::hash_map::Entry;
+
+/// Default prefix for the anon fields.
+pub const DEFAULT_ANON_FIELDS_PREFIX: &str = "__bindgen_anon_";
+
+fn file_is_cpp(name_file: &str) -> bool {
+    name_file.ends_with(".hpp") ||
+        name_file.ends_with(".hxx") ||
+        name_file.ends_with(".hh") ||
+        name_file.ends_with(".h++")
+}
+
+fn args_are_cpp(clang_args: &[String]) -> bool {
+    for w in clang_args.windows(2) {
+        if w[0] == "-xc++" || w[1] == "-xc++" {
+            return true;
+        }
+        if w[0] == "-x" && w[1] == "c++" {
+            return true;
+        }
+        if w[0] == "-include" && file_is_cpp(&w[1]) {
+            return true;
+        }
+    }
+    false
+}
+
+bitflags! {
+    /// A type used to indicate which kind of items we have to generate.
+    pub struct CodegenConfig: u32 {
+        /// Whether to generate functions.
+        const FUNCTIONS = 1 << 0;
+        /// Whether to generate types.
+        const TYPES = 1 << 1;
+        /// Whether to generate constants.
+        const VARS = 1 << 2;
+        /// Whether to generate methods.
+        const METHODS = 1 << 3;
+        /// Whether to generate constructors
+        const CONSTRUCTORS = 1 << 4;
+        /// Whether to generate destructors.
+        const DESTRUCTORS = 1 << 5;
+    }
+}
+
+impl CodegenConfig {
+    /// Returns true if functions should be generated.
+    pub fn functions(self) -> bool {
+        self.contains(CodegenConfig::FUNCTIONS)
+    }
+
+    /// Returns true if types should be generated.
+    pub fn types(self) -> bool {
+        self.contains(CodegenConfig::TYPES)
+    }
+
+    /// Returns true if constants should be generated.
+    pub fn vars(self) -> bool {
+        self.contains(CodegenConfig::VARS)
+    }
+
+    /// Returns true if methds should be generated.
+    pub fn methods(self) -> bool {
+        self.contains(CodegenConfig::METHODS)
+    }
+
+    /// Returns true if constructors should be generated.
+    pub fn constructors(self) -> bool {
+        self.contains(CodegenConfig::CONSTRUCTORS)
+    }
+
+    /// Returns true if destructors should be generated.
+    pub fn destructors(self) -> bool {
+        self.contains(CodegenConfig::DESTRUCTORS)
+    }
+}
+
+impl Default for CodegenConfig {
+    fn default() -> Self {
+        CodegenConfig::all()
+    }
+}
+
+/// Configure and generate Rust bindings for a C/C++ header.
+///
+/// This is the main entry point to the library.
+///
+/// ```ignore
+/// use bindgen::builder;
+///
+/// // Configure and generate bindings.
+/// let bindings = builder().header("path/to/input/header")
+///     .allowlist_type("SomeCoolClass")
+///     .allowlist_function("do_some_cool_thing")
+///     .generate()?;
+///
+/// // Write the generated bindings to an output file.
+/// bindings.write_to_file("path/to/output.rs")?;
+/// ```
+///
+/// # Enums
+///
+/// Bindgen can map C/C++ enums into Rust in different ways. The way bindgen maps enums depends on
+/// the pattern passed to several methods:
+///
+/// 1. [`constified_enum_module()`](#method.constified_enum_module)
+/// 2. [`bitfield_enum()`](#method.bitfield_enum)
+/// 3. [`newtype_enum()`](#method.newtype_enum)
+/// 4. [`rustified_enum()`](#method.rustified_enum)
+///
+/// For each C enum, bindgen tries to match the pattern in the following order:
+///
+/// 1. Constified enum module
+/// 2. Bitfield enum
+/// 3. Newtype enum
+/// 4. Rustified enum
+///
+/// If none of the above patterns match, then bindgen will generate a set of Rust constants.
+///
+/// # Clang arguments
+///
+/// Extra arguments can be passed to with clang:
+/// 1. [`clang_arg()`](#method.clang_arg): takes a single argument
+/// 2. [`clang_args()`](#method.clang_args): takes an iterator of arguments
+/// 3. `BINDGEN_EXTRA_CLANG_ARGS` environment variable: whitespace separate
+///    environment variable of arguments
+///
+/// Clang arguments specific to your crate should be added via the
+/// `clang_arg()`/`clang_args()` methods.
+///
+/// End-users of the crate may need to set the `BINDGEN_EXTRA_CLANG_ARGS` environment variable to
+/// add additional arguments. For example, to build against a different sysroot a user could set
+/// `BINDGEN_EXTRA_CLANG_ARGS` to `--sysroot=/path/to/sysroot`.
+#[derive(Debug, Default)]
+pub struct Builder {
+    options: BindgenOptions,
+    input_headers: Vec<String>,
+    // Tuples of unsaved file contents of the form (name, contents).
+    input_header_contents: Vec<(String, String)>,
+}
+
+/// Construct a new [`Builder`](./struct.Builder.html).
+pub fn builder() -> Builder {
+    Default::default()
+}
+
+fn get_extra_clang_args() -> Vec<String> {
+    // Add any extra arguments from the environment to the clang command line.
+    let extra_clang_args =
+        match get_target_dependent_env_var("BINDGEN_EXTRA_CLANG_ARGS") {
+            None => return vec![],
+            Some(s) => s,
+        };
+    // Try to parse it with shell quoting. If we fail, make it one single big argument.
+    if let Some(strings) = shlex::split(&extra_clang_args) {
+        return strings;
+    }
+    vec![extra_clang_args]
+}
+
+impl Builder {
+    /// Generates the command line flags use for creating `Builder`.
+    pub fn command_line_flags(&self) -> Vec<String> {
+        let mut output_vector: Vec<String> = Vec::new();
+
+        if let Some(header) = self.input_headers.last().cloned() {
+            // Positional argument 'header'
+            output_vector.push(header);
+        }
+
+        output_vector.push("--rust-target".into());
+        output_vector.push(self.options.rust_target.into());
+
+        // FIXME(emilio): This is a bit hacky, maybe we should stop re-using the
+        // RustFeatures to store the "disable_untagged_union" call, and make it
+        // a different flag that we check elsewhere / in generate().
+        if !self.options.rust_features.untagged_union &&
+            RustFeatures::from(self.options.rust_target).untagged_union
+        {
+            output_vector.push("--disable-untagged-union".into());
+        }
+
+        if self.options.default_enum_style != Default::default() {
+            output_vector.push("--default-enum-style".into());
+            output_vector.push(
+                match self.options.default_enum_style {
+                    codegen::EnumVariation::Rust {
+                        non_exhaustive: false,
+                    } => "rust",
+                    codegen::EnumVariation::Rust {
+                        non_exhaustive: true,
+                    } => "rust_non_exhaustive",
+                    codegen::EnumVariation::NewType {
+                        is_bitfield: true,
+                        ..
+                    } => "bitfield",
+                    codegen::EnumVariation::NewType {
+                        is_bitfield: false,
+                        is_global,
+                    } => {
+                        if is_global {
+                            "newtype_global"
+                        } else {
+                            "newtype"
+                        }
+                    }
+                    codegen::EnumVariation::Consts => "consts",
+                    codegen::EnumVariation::ModuleConsts => "moduleconsts",
+                }
+                .into(),
+            )
+        }
+
+        if self.options.default_macro_constant_type != Default::default() {
+            output_vector.push("--default-macro-constant-type".into());
+            output_vector
+                .push(self.options.default_macro_constant_type.as_str().into());
+        }
+
+        if self.options.default_alias_style != Default::default() {
+            output_vector.push("--default-alias-style".into());
+            output_vector
+                .push(self.options.default_alias_style.as_str().into());
+        }
+
+        if self.options.default_non_copy_union_style != Default::default() {
+            output_vector.push("--default-non-copy-union-style".into());
+            output_vector.push(
+                self.options.default_non_copy_union_style.as_str().into(),
+            );
+        }
+
+        let regex_sets = &[
+            (&self.options.bitfield_enums, "--bitfield-enum"),
+            (&self.options.newtype_enums, "--newtype-enum"),
+            (&self.options.newtype_global_enums, "--newtype-global-enum"),
+            (&self.options.rustified_enums, "--rustified-enum"),
+            (
+                &self.options.rustified_non_exhaustive_enums,
+                "--rustified-enum-non-exhaustive",
+            ),
+            (
+                &self.options.constified_enum_modules,
+                "--constified-enum-module",
+            ),
+            (&self.options.constified_enums, "--constified-enum"),
+            (&self.options.type_alias, "--type-alias"),
+            (&self.options.new_type_alias, "--new-type-alias"),
+            (&self.options.new_type_alias_deref, "--new-type-alias-deref"),
+            (
+                &self.options.bindgen_wrapper_union,
+                "--bindgen-wrapper-union",
+            ),
+            (&self.options.manually_drop_union, "--manually-drop-union"),
+            (&self.options.blocklisted_types, "--blocklist-type"),
+            (&self.options.blocklisted_functions, "--blocklist-function"),
+            (&self.options.blocklisted_items, "--blocklist-item"),
+            (&self.options.blocklisted_files, "--blocklist-file"),
+            (&self.options.opaque_types, "--opaque-type"),
+            (&self.options.allowlisted_functions, "--allowlist-function"),
+            (&self.options.allowlisted_types, "--allowlist-type"),
+            (&self.options.allowlisted_vars, "--allowlist-var"),
+            (&self.options.allowlisted_files, "--allowlist-file"),
+            (&self.options.no_partialeq_types, "--no-partialeq"),
+            (&self.options.no_copy_types, "--no-copy"),
+            (&self.options.no_debug_types, "--no-debug"),
+            (&self.options.no_default_types, "--no-default"),
+            (&self.options.no_hash_types, "--no-hash"),
+            (&self.options.must_use_types, "--must-use-type"),
+        ];
+
+        for (set, flag) in regex_sets {
+            for item in set.get_items() {
+                output_vector.push((*flag).to_owned());
+                output_vector.push(item.to_owned());
+            }
+        }
+
+        if !self.options.layout_tests {
+            output_vector.push("--no-layout-tests".into());
+        }
+
+        if self.options.impl_debug {
+            output_vector.push("--impl-debug".into());
+        }
+
+        if self.options.impl_partialeq {
+            output_vector.push("--impl-partialeq".into());
+        }
+
+        if !self.options.derive_copy {
+            output_vector.push("--no-derive-copy".into());
+        }
+
+        if !self.options.derive_debug {
+            output_vector.push("--no-derive-debug".into());
+        }
+
+        if !self.options.derive_default {
+            output_vector.push("--no-derive-default".into());
+        } else {
+            output_vector.push("--with-derive-default".into());
+        }
+
+        if self.options.derive_hash {
+            output_vector.push("--with-derive-hash".into());
+        }
+
+        if self.options.derive_partialord {
+            output_vector.push("--with-derive-partialord".into());
+        }
+
+        if self.options.derive_ord {
+            output_vector.push("--with-derive-ord".into());
+        }
+
+        if self.options.derive_partialeq {
+            output_vector.push("--with-derive-partialeq".into());
+        }
+
+        if self.options.derive_eq {
+            output_vector.push("--with-derive-eq".into());
+        }
+
+        if self.options.time_phases {
+            output_vector.push("--time-phases".into());
+        }
+
+        if !self.options.generate_comments {
+            output_vector.push("--no-doc-comments".into());
+        }
+
+        if !self.options.allowlist_recursively {
+            output_vector.push("--no-recursive-allowlist".into());
+        }
+
+        if self.options.objc_extern_crate {
+            output_vector.push("--objc-extern-crate".into());
+        }
+
+        if self.options.generate_block {
+            output_vector.push("--generate-block".into());
+        }
+
+        if self.options.block_extern_crate {
+            output_vector.push("--block-extern-crate".into());
+        }
+
+        if self.options.builtins {
+            output_vector.push("--builtins".into());
+        }
+
+        if let Some(ref prefix) = self.options.ctypes_prefix {
+            output_vector.push("--ctypes-prefix".into());
+            output_vector.push(prefix.clone());
+        }
+
+        if self.options.anon_fields_prefix != DEFAULT_ANON_FIELDS_PREFIX {
+            output_vector.push("--anon-fields-prefix".into());
+            output_vector.push(self.options.anon_fields_prefix.clone());
+        }
+
+        if self.options.emit_ast {
+            output_vector.push("--emit-clang-ast".into());
+        }
+
+        if self.options.emit_ir {
+            output_vector.push("--emit-ir".into());
+        }
+        if let Some(ref graph) = self.options.emit_ir_graphviz {
+            output_vector.push("--emit-ir-graphviz".into());
+            output_vector.push(graph.clone())
+        }
+        if self.options.enable_cxx_namespaces {
+            output_vector.push("--enable-cxx-namespaces".into());
+        }
+        if self.options.enable_function_attribute_detection {
+            output_vector.push("--enable-function-attribute-detection".into());
+        }
+        if self.options.disable_name_namespacing {
+            output_vector.push("--disable-name-namespacing".into());
+        }
+        if self.options.disable_nested_struct_naming {
+            output_vector.push("--disable-nested-struct-naming".into());
+        }
+
+        if self.options.disable_header_comment {
+            output_vector.push("--disable-header-comment".into());
+        }
+
+        if !self.options.codegen_config.functions() {
+            output_vector.push("--ignore-functions".into());
+        }
+
+        output_vector.push("--generate".into());
+
+        //Temporary placeholder for below 4 options
+        let mut options: Vec<String> = Vec::new();
+        if self.options.codegen_config.functions() {
+            options.push("functions".into());
+        }
+        if self.options.codegen_config.types() {
+            options.push("types".into());
+        }
+        if self.options.codegen_config.vars() {
+            options.push("vars".into());
+        }
+        if self.options.codegen_config.methods() {
+            options.push("methods".into());
+        }
+        if self.options.codegen_config.constructors() {
+            options.push("constructors".into());
+        }
+        if self.options.codegen_config.destructors() {
+            options.push("destructors".into());
+        }
+
+        output_vector.push(options.join(","));
+
+        if !self.options.codegen_config.methods() {
+            output_vector.push("--ignore-methods".into());
+        }
+
+        if !self.options.convert_floats {
+            output_vector.push("--no-convert-floats".into());
+        }
+
+        if !self.options.prepend_enum_name {
+            output_vector.push("--no-prepend-enum-name".into());
+        }
+
+        if self.options.fit_macro_constants {
+            output_vector.push("--fit-macro-constant-types".into());
+        }
+
+        if self.options.array_pointers_in_arguments {
+            output_vector.push("--use-array-pointers-in-arguments".into());
+        }
+
+        if let Some(ref wasm_import_module_name) =
+            self.options.wasm_import_module_name
+        {
+            output_vector.push("--wasm-import-module-name".into());
+            output_vector.push(wasm_import_module_name.clone());
+        }
+
+        for line in &self.options.raw_lines {
+            output_vector.push("--raw-line".into());
+            output_vector.push(line.clone());
+        }
+
+        for (module, lines) in &self.options.module_lines {
+            for line in lines.iter() {
+                output_vector.push("--module-raw-line".into());
+                output_vector.push(module.clone());
+                output_vector.push(line.clone());
+            }
+        }
+
+        if self.options.use_core {
+            output_vector.push("--use-core".into());
+        }
+
+        if self.options.conservative_inline_namespaces {
+            output_vector.push("--conservative-inline-namespaces".into());
+        }
+
+        if self.options.generate_inline_functions {
+            output_vector.push("--generate-inline-functions".into());
+        }
+
+        if !self.options.record_matches {
+            output_vector.push("--no-record-matches".into());
+        }
+
+        if !self.options.size_t_is_usize {
+            output_vector.push("--no-size_t-is-usize".into());
+        }
+
+        if !self.options.rustfmt_bindings {
+            output_vector.push("--no-rustfmt-bindings".into());
+        }
+
+        if let Some(path) = self
+            .options
+            .rustfmt_configuration_file
+            .as_ref()
+            .and_then(|f| f.to_str())
+        {
+            output_vector.push("--rustfmt-configuration-file".into());
+            output_vector.push(path.into());
+        }
+
+        if let Some(ref name) = self.options.dynamic_library_name {
+            output_vector.push("--dynamic-loading".into());
+            output_vector.push(name.clone());
+        }
+
+        if self.options.dynamic_link_require_all {
+            output_vector.push("--dynamic-link-require-all".into());
+        }
+
+        if self.options.respect_cxx_access_specs {
+            output_vector.push("--respect-cxx-access-specs".into());
+        }
+
+        if self.options.translate_enum_integer_types {
+            output_vector.push("--translate-enum-integer-types".into());
+        }
+
+        if self.options.c_naming {
+            output_vector.push("--c-naming".into());
+        }
+
+        if self.options.force_explicit_padding {
+            output_vector.push("--explicit-padding".into());
+        }
+
+        if self.options.vtable_generation {
+            output_vector.push("--vtable-generation".into());
+        }
+
+        if self.options.sort_semantically {
+            output_vector.push("--sort-semantically".into());
+        }
+
+        if self.options.merge_extern_blocks {
+            output_vector.push("--merge-extern-blocks".into());
+        }
+
+        // Add clang arguments
+
+        output_vector.push("--".into());
+
+        if !self.options.clang_args.is_empty() {
+            output_vector.extend(self.options.clang_args.iter().cloned());
+        }
+
+        if self.input_headers.len() > 1 {
+            // To pass more than one header, we need to pass all but the last
+            // header via the `-include` clang arg
+            for header in &self.input_headers[..self.input_headers.len() - 1] {
+                output_vector.push("-include".to_string());
+                output_vector.push(header.clone());
+            }
+        }
+
+        output_vector
+    }
+
+    /// Add an input C/C++ header to generate bindings for.
+    ///
+    /// This can be used to generate bindings to a single header:
+    ///
+    /// ```ignore
+    /// let bindings = bindgen::Builder::default()
+    ///     .header("input.h")
+    ///     .generate()
+    ///     .unwrap();
+    /// ```
+    ///
+    /// Or you can invoke it multiple times to generate bindings to multiple
+    /// headers:
+    ///
+    /// ```ignore
+    /// let bindings = bindgen::Builder::default()
+    ///     .header("first.h")
+    ///     .header("second.h")
+    ///     .header("third.h")
+    ///     .generate()
+    ///     .unwrap();
+    /// ```
+    pub fn header<T: Into<String>>(mut self, header: T) -> Builder {
+        self.input_headers.push(header.into());
+        self
+    }
+
+    /// Add a depfile output which will be written alongside the generated bindings.
+    pub fn depfile<H: Into<String>, D: Into<PathBuf>>(
+        mut self,
+        output_module: H,
+        depfile: D,
+    ) -> Builder {
+        self.options.depfile = Some(deps::DepfileSpec {
+            output_module: output_module.into(),
+            depfile_path: depfile.into(),
+        });
+        self
+    }
+
+    /// Add `contents` as an input C/C++ header named `name`.
+    ///
+    /// The file `name` will be added to the clang arguments.
+    pub fn header_contents(mut self, name: &str, contents: &str) -> Builder {
+        // Apparently clang relies on having virtual FS correspondent to
+        // the real one, so we need absolute paths here
+        let absolute_path = env::current_dir()
+            .expect("Cannot retrieve current directory")
+            .join(name)
+            .to_str()
+            .expect("Cannot convert current directory name to string")
+            .to_owned();
+        self.input_header_contents
+            .push((absolute_path, contents.into()));
+        self
+    }
+
+    /// Specify the rust target
+    ///
+    /// The default is the latest stable Rust version
+    pub fn rust_target(mut self, rust_target: RustTarget) -> Self {
+        self.options.set_rust_target(rust_target);
+        self
+    }
+
+    /// Disable support for native Rust unions, if supported.
+    pub fn disable_untagged_union(mut self) -> Self {
+        self.options.rust_features.untagged_union = false;
+        self
+    }
+
+    /// Disable insertion of bindgen's version identifier into generated
+    /// bindings.
+    pub fn disable_header_comment(mut self) -> Self {
+        self.options.disable_header_comment = true;
+        self
+    }
+
+    /// Set the output graphviz file.
+    pub fn emit_ir_graphviz<T: Into<String>>(mut self, path: T) -> Builder {
+        let path = path.into();
+        self.options.emit_ir_graphviz = Some(path);
+        self
+    }
+
+    /// Whether the generated bindings should contain documentation comments
+    /// (docstrings) or not. This is set to true by default.
+    ///
+    /// Note that clang by default excludes comments from system headers, pass
+    /// `-fretain-comments-from-system-headers` as
+    /// [`clang_arg`][Builder::clang_arg] to include them. It can also be told
+    /// to process all comments (not just documentation ones) using the
+    /// `-fparse-all-comments` flag. See [slides on clang comment parsing](
+    /// https://llvm.org/devmtg/2012-11/Gribenko_CommentParsing.pdf) for
+    /// background and examples.
+    pub fn generate_comments(mut self, doit: bool) -> Self {
+        self.options.generate_comments = doit;
+        self
+    }
+
+    /// Whether to allowlist recursively or not. Defaults to true.
+    ///
+    /// Given that we have explicitly allowlisted the "initiate_dance_party"
+    /// function in this C header:
+    ///
+    /// ```c
+    /// typedef struct MoonBoots {
+    ///     int bouncy_level;
+    /// } MoonBoots;
+    ///
+    /// void initiate_dance_party(MoonBoots* boots);
+    /// ```
+    ///
+    /// We would normally generate bindings to both the `initiate_dance_party`
+    /// function and the `MoonBoots` struct that it transitively references. By
+    /// configuring with `allowlist_recursively(false)`, `bindgen` will not emit
+    /// bindings for anything except the explicitly allowlisted items, and there
+    /// would be no emitted struct definition for `MoonBoots`. However, the
+    /// `initiate_dance_party` function would still reference `MoonBoots`!
+    ///
+    /// **Disabling this feature will almost certainly cause `bindgen` to emit
+    /// bindings that will not compile!** If you disable this feature, then it
+    /// is *your* responsibility to provide definitions for every type that is
+    /// referenced from an explicitly allowlisted item. One way to provide the
+    /// definitions is by using the [`Builder::raw_line`](#method.raw_line)
+    /// method, another would be to define them in Rust and then `include!(...)`
+    /// the bindings immediately afterwards.
+    pub fn allowlist_recursively(mut self, doit: bool) -> Self {
+        self.options.allowlist_recursively = doit;
+        self
+    }
+
+    /// Deprecated alias for allowlist_recursively.
+    #[deprecated(note = "Use allowlist_recursively instead")]
+    pub fn whitelist_recursively(self, doit: bool) -> Self {
+        self.allowlist_recursively(doit)
+    }
+
+    /// Generate `#[macro_use] extern crate objc;` instead of `use objc;`
+    /// in the prologue of the files generated from objective-c files
+    pub fn objc_extern_crate(mut self, doit: bool) -> Self {
+        self.options.objc_extern_crate = doit;
+        self
+    }
+
+    /// Generate proper block signatures instead of void pointers.
+    pub fn generate_block(mut self, doit: bool) -> Self {
+        self.options.generate_block = doit;
+        self
+    }
+
+    /// Generate `#[macro_use] extern crate block;` instead of `use block;`
+    /// in the prologue of the files generated from apple block files
+    pub fn block_extern_crate(mut self, doit: bool) -> Self {
+        self.options.block_extern_crate = doit;
+        self
+    }
+
+    /// Whether to use the clang-provided name mangling. This is true by default
+    /// and probably needed for C++ features.
+    ///
+    /// However, some old libclang versions seem to return incorrect results in
+    /// some cases for non-mangled functions, see [1], so we allow disabling it.
+    ///
+    /// [1]: https://github.com/rust-lang/rust-bindgen/issues/528
+    pub fn trust_clang_mangling(mut self, doit: bool) -> Self {
+        self.options.enable_mangling = doit;
+        self
+    }
+
+    /// Hide the given type from the generated bindings. Regular expressions are
+    /// supported.
+    #[deprecated(note = "Use blocklist_type instead")]
+    pub fn hide_type<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.blocklist_type(arg)
+    }
+
+    /// Hide the given type from the generated bindings. Regular expressions are
+    /// supported.
+    #[deprecated(note = "Use blocklist_type instead")]
+    pub fn blacklist_type<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.blocklist_type(arg)
+    }
+
+    /// Hide the given type from the generated bindings. Regular expressions are
+    /// supported.
+    ///
+    /// To blocklist types prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn blocklist_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.blocklisted_types.insert(arg);
+        self
+    }
+
+    /// Hide the given function from the generated bindings. Regular expressions
+    /// are supported.
+    #[deprecated(note = "Use blocklist_function instead")]
+    pub fn blacklist_function<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.blocklist_function(arg)
+    }
+
+    /// Hide the given function from the generated bindings. Regular expressions
+    /// are supported.
+    ///
+    /// To blocklist functions prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn blocklist_function<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.blocklisted_functions.insert(arg);
+        self
+    }
+
+    /// Hide the given item from the generated bindings, regardless of
+    /// whether it's a type, function, module, etc. Regular
+    /// expressions are supported.
+    #[deprecated(note = "Use blocklist_item instead")]
+    pub fn blacklist_item<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.blocklisted_items.insert(arg);
+        self
+    }
+
+    /// Hide the given item from the generated bindings, regardless of
+    /// whether it's a type, function, module, etc. Regular
+    /// expressions are supported.
+    ///
+    /// To blocklist items prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn blocklist_item<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.blocklisted_items.insert(arg);
+        self
+    }
+
+    /// Hide any contents of the given file from the generated bindings,
+    /// regardless of whether it's a type, function, module etc.
+    pub fn blocklist_file<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.blocklisted_files.insert(arg);
+        self
+    }
+
+    /// Treat the given type as opaque in the generated bindings. Regular
+    /// expressions are supported.
+    ///
+    /// To change types prefixed with "mylib" into opaque, use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn opaque_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.opaque_types.insert(arg);
+        self
+    }
+
+    /// Allowlist the given type so that it (and all types that it transitively
+    /// refers to) appears in the generated bindings. Regular expressions are
+    /// supported.
+    #[deprecated(note = "use allowlist_type instead")]
+    pub fn whitelisted_type<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_type(arg)
+    }
+
+    /// Allowlist the given type so that it (and all types that it transitively
+    /// refers to) appears in the generated bindings. Regular expressions are
+    /// supported.
+    #[deprecated(note = "use allowlist_type instead")]
+    pub fn whitelist_type<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_type(arg)
+    }
+
+    /// Allowlist the given type so that it (and all types that it transitively
+    /// refers to) appears in the generated bindings. Regular expressions are
+    /// supported.
+    ///
+    /// To allowlist types prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn allowlist_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.allowlisted_types.insert(arg);
+        self
+    }
+
+    /// Allowlist the given function so that it (and all types that it
+    /// transitively refers to) appears in the generated bindings. Regular
+    /// expressions are supported.
+    ///
+    /// To allowlist functions prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn allowlist_function<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.allowlisted_functions.insert(arg);
+        self
+    }
+
+    /// Allowlist the given function.
+    ///
+    /// Deprecated: use allowlist_function instead.
+    #[deprecated(note = "use allowlist_function instead")]
+    pub fn whitelist_function<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_function(arg)
+    }
+
+    /// Allowlist the given function.
+    ///
+    /// Deprecated: use allowlist_function instead.
+    #[deprecated(note = "use allowlist_function instead")]
+    pub fn whitelisted_function<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_function(arg)
+    }
+
+    /// Allowlist the given variable so that it (and all types that it
+    /// transitively refers to) appears in the generated bindings. Regular
+    /// expressions are supported.
+    ///
+    /// To allowlist variables prefixed with "mylib" use `"mylib_.*"`.
+    /// For more complicated expressions check
+    /// [regex](https://docs.rs/regex/*/regex/) docs
+    pub fn allowlist_var<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.allowlisted_vars.insert(arg);
+        self
+    }
+
+    /// Allowlist the given file so that its contents appear in the generated bindings.
+    pub fn allowlist_file<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.allowlisted_files.insert(arg);
+        self
+    }
+
+    /// Deprecated: use allowlist_var instead.
+    #[deprecated(note = "use allowlist_var instead")]
+    pub fn whitelist_var<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_var(arg)
+    }
+
+    /// Allowlist the given variable.
+    ///
+    /// Deprecated: use allowlist_var instead.
+    #[deprecated(note = "use allowlist_var instead")]
+    pub fn whitelisted_var<T: AsRef<str>>(self, arg: T) -> Builder {
+        self.allowlist_var(arg)
+    }
+
+    /// Set the default style of code to generate for enums
+    pub fn default_enum_style(
+        mut self,
+        arg: codegen::EnumVariation,
+    ) -> Builder {
+        self.options.default_enum_style = arg;
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as being
+    /// bitfield-like. Regular expressions are supported.
+    ///
+    /// This makes bindgen generate a type that isn't a rust `enum`. Regular
+    /// expressions are supported.
+    ///
+    /// This is similar to the newtype enum style, but with the bitwise
+    /// operators implemented.
+    pub fn bitfield_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.bitfield_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a newtype.
+    /// Regular expressions are supported.
+    ///
+    /// This makes bindgen generate a type that isn't a Rust `enum`. Regular
+    /// expressions are supported.
+    pub fn newtype_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.newtype_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a newtype
+    /// whose variants are exposed as global constants.
+    ///
+    /// Regular expressions are supported.
+    ///
+    /// This makes bindgen generate a type that isn't a Rust `enum`. Regular
+    /// expressions are supported.
+    pub fn newtype_global_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.newtype_global_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a Rust
+    /// enum.
+    ///
+    /// This makes bindgen generate enums instead of constants. Regular
+    /// expressions are supported.
+    ///
+    /// **Use this with caution**, creating this in unsafe code
+    /// (including FFI) with an invalid value will invoke undefined behaviour.
+    /// You may want to use the newtype enum style instead.
+    pub fn rustified_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.rustified_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a Rust
+    /// enum with the `#[non_exhaustive]` attribute.
+    ///
+    /// This makes bindgen generate enums instead of constants. Regular
+    /// expressions are supported.
+    ///
+    /// **Use this with caution**, creating this in unsafe code
+    /// (including FFI) with an invalid value will invoke undefined behaviour.
+    /// You may want to use the newtype enum style instead.
+    pub fn rustified_non_exhaustive_enum<T: AsRef<str>>(
+        mut self,
+        arg: T,
+    ) -> Builder {
+        self.options.rustified_non_exhaustive_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a set of
+    /// constants that are not to be put into a module.
+    pub fn constified_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.constified_enums.insert(arg);
+        self
+    }
+
+    /// Mark the given enum (or set of enums, if using a pattern) as a set of
+    /// constants that should be put into a module.
+    ///
+    /// This makes bindgen generate modules containing constants instead of
+    /// just constants. Regular expressions are supported.
+    pub fn constified_enum_module<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.constified_enum_modules.insert(arg);
+        self
+    }
+
+    /// Set the default type for macro constants
+    pub fn default_macro_constant_type(
+        mut self,
+        arg: codegen::MacroTypeVariation,
+    ) -> Builder {
+        self.options.default_macro_constant_type = arg;
+        self
+    }
+
+    /// Set the default style of code to generate for typedefs
+    pub fn default_alias_style(
+        mut self,
+        arg: codegen::AliasVariation,
+    ) -> Builder {
+        self.options.default_alias_style = arg;
+        self
+    }
+
+    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
+    /// use regular Rust type aliasing.
+    ///
+    /// This is the default behavior and should be used if `default_alias_style`
+    /// was set to NewType or NewTypeDeref and you want to override it for a
+    /// set of typedefs.
+    pub fn type_alias<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.type_alias.insert(arg);
+        self
+    }
+
+    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
+    /// be generated as a new type by having the aliased type be wrapped in a
+    /// #[repr(transparent)] struct.
+    ///
+    /// Used to enforce stricter type checking.
+    pub fn new_type_alias<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.new_type_alias.insert(arg);
+        self
+    }
+
+    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
+    /// be generated as a new type by having the aliased type be wrapped in a
+    /// #[repr(transparent)] struct and also have an automatically generated
+    /// impl's of `Deref` and `DerefMut` to their aliased type.
+    pub fn new_type_alias_deref<T: AsRef<str>>(mut self, arg: T) -> Builder {
+        self.options.new_type_alias_deref.insert(arg);
+        self
+    }
+
+    /// Set the default style of code to generate for unions with a non-Copy member.
+    pub fn default_non_copy_union_style(
+        mut self,
+        arg: codegen::NonCopyUnionStyle,
+    ) -> Self {
+        self.options.default_non_copy_union_style = arg;
+        self
+    }
+
+    /// Mark the given union (or set of union, if using a pattern) to use
+    /// a bindgen-generated wrapper for its members if at least one is non-Copy.
+    pub fn bindgen_wrapper_union<T: AsRef<str>>(mut self, arg: T) -> Self {
+        self.options.bindgen_wrapper_union.insert(arg);
+        self
+    }
+
+    /// Mark the given union (or set of union, if using a pattern) to use
+    /// [`::core::mem::ManuallyDrop`] for its members if at least one is non-Copy.
+    ///
+    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
+    /// MSRV is lower.
+    pub fn manually_drop_union<T: AsRef<str>>(mut self, arg: T) -> Self {
+        self.options.manually_drop_union.insert(arg);
+        self
+    }
+
+    /// Add a string to prepend to the generated bindings. The string is passed
+    /// through without any modification.
+    pub fn raw_line<T: Into<String>>(mut self, arg: T) -> Self {
+        self.options.raw_lines.push(arg.into());
+        self
+    }
+
+    /// Add a given line to the beginning of module `mod`.
+    pub fn module_raw_line<T, U>(mut self, mod_: T, line: U) -> Self
+    where
+        T: Into<String>,
+        U: Into<String>,
+    {
+        self.options
+            .module_lines
+            .entry(mod_.into())
+            .or_insert_with(Vec::new)
+            .push(line.into());
+        self
+    }
+
+    /// Add a given set of lines to the beginning of module `mod`.
+    pub fn module_raw_lines<T, I>(mut self, mod_: T, lines: I) -> Self
+    where
+        T: Into<String>,
+        I: IntoIterator,
+        I::Item: Into<String>,
+    {
+        self.options
+            .module_lines
+            .entry(mod_.into())
+            .or_insert_with(Vec::new)
+            .extend(lines.into_iter().map(Into::into));
+        self
+    }
+
+    /// Add an argument to be passed straight through to clang.
+    pub fn clang_arg<T: Into<String>>(mut self, arg: T) -> Builder {
+        self.options.clang_args.push(arg.into());
+        self
+    }
+
+    /// Add arguments to be passed straight through to clang.
+    pub fn clang_args<I>(mut self, iter: I) -> Builder
+    where
+        I: IntoIterator,
+        I::Item: AsRef<str>,
+    {
+        for arg in iter {
+            self = self.clang_arg(arg.as_ref())
+        }
+        self
+    }
+
+    /// Emit bindings for builtin definitions (for example `__builtin_va_list`)
+    /// in the generated Rust.
+    pub fn emit_builtins(mut self) -> Builder {
+        self.options.builtins = true;
+        self
+    }
+
+    /// Avoid converting floats to `f32`/`f64` by default.
+    pub fn no_convert_floats(mut self) -> Self {
+        self.options.convert_floats = false;
+        self
+    }
+
+    /// Set whether layout tests should be generated.
+    pub fn layout_tests(mut self, doit: bool) -> Self {
+        self.options.layout_tests = doit;
+        self
+    }
+
+    /// Set whether `Debug` should be implemented, if it can not be derived automatically.
+    pub fn impl_debug(mut self, doit: bool) -> Self {
+        self.options.impl_debug = doit;
+        self
+    }
+
+    /// Set whether `PartialEq` should be implemented, if it can not be derived automatically.
+    pub fn impl_partialeq(mut self, doit: bool) -> Self {
+        self.options.impl_partialeq = doit;
+        self
+    }
+
+    /// Set whether `Copy` should be derived by default.
+    pub fn derive_copy(mut self, doit: bool) -> Self {
+        self.options.derive_copy = doit;
+        self
+    }
+
+    /// Set whether `Debug` should be derived by default.
+    pub fn derive_debug(mut self, doit: bool) -> Self {
+        self.options.derive_debug = doit;
+        self
+    }
+
+    /// Set whether `Default` should be derived by default.
+    pub fn derive_default(mut self, doit: bool) -> Self {
+        self.options.derive_default = doit;
+        self
+    }
+
+    /// Set whether `Hash` should be derived by default.
+    pub fn derive_hash(mut self, doit: bool) -> Self {
+        self.options.derive_hash = doit;
+        self
+    }
+
+    /// Set whether `PartialOrd` should be derived by default.
+    /// If we don't compute partialord, we also cannot compute
+    /// ord. Set the derive_ord to `false` when doit is `false`.
+    pub fn derive_partialord(mut self, doit: bool) -> Self {
+        self.options.derive_partialord = doit;
+        if !doit {
+            self.options.derive_ord = false;
+        }
+        self
+    }
+
+    /// Set whether `Ord` should be derived by default.
+    /// We can't compute `Ord` without computing `PartialOrd`,
+    /// so we set the same option to derive_partialord.
+    pub fn derive_ord(mut self, doit: bool) -> Self {
+        self.options.derive_ord = doit;
+        self.options.derive_partialord = doit;
+        self
+    }
+
+    /// Set whether `PartialEq` should be derived by default.
+    ///
+    /// If we don't derive `PartialEq`, we also cannot derive `Eq`, so deriving
+    /// `Eq` is also disabled when `doit` is `false`.
+    pub fn derive_partialeq(mut self, doit: bool) -> Self {
+        self.options.derive_partialeq = doit;
+        if !doit {
+            self.options.derive_eq = false;
+        }
+        self
+    }
+
+    /// Set whether `Eq` should be derived by default.
+    ///
+    /// We can't derive `Eq` without also deriving `PartialEq`, so we also
+    /// enable deriving `PartialEq` when `doit` is `true`.
+    pub fn derive_eq(mut self, doit: bool) -> Self {
+        self.options.derive_eq = doit;
+        if doit {
+            self.options.derive_partialeq = doit;
+        }
+        self
+    }
+
+    /// Set whether or not to time bindgen phases, and print information to
+    /// stderr.
+    pub fn time_phases(mut self, doit: bool) -> Self {
+        self.options.time_phases = doit;
+        self
+    }
+
+    /// Emit Clang AST.
+    pub fn emit_clang_ast(mut self) -> Builder {
+        self.options.emit_ast = true;
+        self
+    }
+
+    /// Emit IR.
+    pub fn emit_ir(mut self) -> Builder {
+        self.options.emit_ir = true;
+        self
+    }
+
+    /// Enable C++ namespaces.
+    pub fn enable_cxx_namespaces(mut self) -> Builder {
+        self.options.enable_cxx_namespaces = true;
+        self
+    }
+
+    /// Enable detecting must_use attributes on C functions.
+    ///
+    /// This is quite slow in some cases (see #1465), so it's disabled by
+    /// default.
+    ///
+    /// Note that for this to do something meaningful for now at least, the rust
+    /// target version has to have support for `#[must_use]`.
+    pub fn enable_function_attribute_detection(mut self) -> Self {
+        self.options.enable_function_attribute_detection = true;
+        self
+    }
+
+    /// Disable name auto-namespacing.
+    ///
+    /// By default, bindgen mangles names like `foo::bar::Baz` to look like
+    /// `foo_bar_Baz` instead of just `Baz`.
+    ///
+    /// This method disables that behavior.
+    ///
+    /// Note that this intentionally does not change the names used for
+    /// allowlisting and blocklisting, which should still be mangled with the
+    /// namespaces.
+    ///
+    /// Note, also, that this option may cause bindgen to generate duplicate
+    /// names.
+    pub fn disable_name_namespacing(mut self) -> Builder {
+        self.options.disable_name_namespacing = true;
+        self
+    }
+
+    /// Disable nested struct naming.
+    ///
+    /// The following structs have different names for C and C++. In case of C
+    /// they are visible as `foo` and `bar`. In case of C++ they are visible as
+    /// `foo` and `foo::bar`.
+    ///
+    /// ```c
+    /// struct foo {
+    ///     struct bar {
+    ///     } b;
+    /// };
+    /// ```
+    ///
+    /// Bindgen wants to avoid duplicate names by default so it follows C++ naming
+    /// and it generates `foo`/`foo_bar` instead of just `foo`/`bar`.
+    ///
+    /// This method disables this behavior and it is indented to be used only
+    /// for headers that were written for C.
+    pub fn disable_nested_struct_naming(mut self) -> Builder {
+        self.options.disable_nested_struct_naming = true;
+        self
+    }
+
+    /// Treat inline namespaces conservatively.
+    ///
+    /// This is tricky, because in C++ is technically legal to override an item
+    /// defined in an inline namespace:
+    ///
+    /// ```cpp
+    /// inline namespace foo {
+    ///     using Bar = int;
+    /// }
+    /// using Bar = long;
+    /// ```
+    ///
+    /// Even though referencing `Bar` is a compiler error.
+    ///
+    /// We want to support this (arguably esoteric) use case, but we don't want
+    /// to make the rest of bindgen users pay an usability penalty for that.
+    ///
+    /// To support this, we need to keep all the inline namespaces around, but
+    /// then bindgen usage is a bit more difficult, because you cannot
+    /// reference, e.g., `std::string` (you'd need to use the proper inline
+    /// namespace).
+    ///
+    /// We could complicate a lot of the logic to detect name collisions, and if
+    /// not detected generate a `pub use inline_ns::*` or something like that.
+    ///
+    /// That's probably something we can do if we see this option is needed in a
+    /// lot of cases, to improve it's usability, but my guess is that this is
+    /// not going to be too useful.
+    pub fn conservative_inline_namespaces(mut self) -> Builder {
+        self.options.conservative_inline_namespaces = true;
+        self
+    }
+
+    /// Whether inline functions should be generated or not.
+    ///
+    /// Note that they will usually not work. However you can use
+    /// `-fkeep-inline-functions` or `-fno-inline-functions` if you are
+    /// responsible of compiling the library to make them callable.
+    pub fn generate_inline_functions(mut self, doit: bool) -> Self {
+        self.options.generate_inline_functions = doit;
+        self
+    }
+
+    /// Ignore functions.
+    pub fn ignore_functions(mut self) -> Builder {
+        self.options.codegen_config.remove(CodegenConfig::FUNCTIONS);
+        self
+    }
+
+    /// Ignore methods.
+    pub fn ignore_methods(mut self) -> Builder {
+        self.options.codegen_config.remove(CodegenConfig::METHODS);
+        self
+    }
+
+    /// Avoid generating any unstable Rust, such as Rust unions, in the generated bindings.
+    #[deprecated(note = "please use `rust_target` instead")]
+    pub fn unstable_rust(self, doit: bool) -> Self {
+        let rust_target = if doit {
+            RustTarget::Nightly
+        } else {
+            LATEST_STABLE_RUST
+        };
+        self.rust_target(rust_target)
+    }
+
+    /// Use core instead of libstd in the generated bindings.
+    pub fn use_core(mut self) -> Builder {
+        self.options.use_core = true;
+        self
+    }
+
+    /// Use the given prefix for the raw types instead of `::std::os::raw`.
+    pub fn ctypes_prefix<T: Into<String>>(mut self, prefix: T) -> Builder {
+        self.options.ctypes_prefix = Some(prefix.into());
+        self
+    }
+
+    /// Use the given prefix for the anon fields.
+    pub fn anon_fields_prefix<T: Into<String>>(mut self, prefix: T) -> Builder {
+        self.options.anon_fields_prefix = prefix.into();
+        self
+    }
+
+    /// Allows configuring types in different situations, see the
+    /// [`ParseCallbacks`](./callbacks/trait.ParseCallbacks.html) documentation.
+    pub fn parse_callbacks(
+        mut self,
+        cb: Box<dyn callbacks::ParseCallbacks>,
+    ) -> Self {
+        self.options.parse_callbacks = Some(Rc::from(cb));
+        self
+    }
+
+    /// Choose what to generate using a
+    /// [`CodegenConfig`](./struct.CodegenConfig.html).
+    pub fn with_codegen_config(mut self, config: CodegenConfig) -> Self {
+        self.options.codegen_config = config;
+        self
+    }
+
+    /// Whether to detect include paths using clang_sys.
+    pub fn detect_include_paths(mut self, doit: bool) -> Self {
+        self.options.detect_include_paths = doit;
+        self
+    }
+
+    /// Whether to try to fit macro constants to types smaller than u32/i32
+    pub fn fit_macro_constants(mut self, doit: bool) -> Self {
+        self.options.fit_macro_constants = doit;
+        self
+    }
+
+    /// Prepend the enum name to constant or newtype variants.
+    pub fn prepend_enum_name(mut self, doit: bool) -> Self {
+        self.options.prepend_enum_name = doit;
+        self
+    }
+
+    /// Set whether `size_t` should be translated to `usize` automatically.
+    pub fn size_t_is_usize(mut self, is: bool) -> Self {
+        self.options.size_t_is_usize = is;
+        self
+    }
+
+    /// Set whether rustfmt should format the generated bindings.
+    pub fn rustfmt_bindings(mut self, doit: bool) -> Self {
+        self.options.rustfmt_bindings = doit;
+        self
+    }
+
+    /// Set whether we should record matched items in our regex sets.
+    pub fn record_matches(mut self, doit: bool) -> Self {
+        self.options.record_matches = doit;
+        self
+    }
+
+    /// Set the absolute path to the rustfmt configuration file, if None, the standard rustfmt
+    /// options are used.
+    pub fn rustfmt_configuration_file(mut self, path: Option<PathBuf>) -> Self {
+        self = self.rustfmt_bindings(true);
+        self.options.rustfmt_configuration_file = path;
+        self
+    }
+
+    /// Sets an explicit path to rustfmt, to be used when rustfmt is enabled.
+    pub fn with_rustfmt<P: Into<PathBuf>>(mut self, path: P) -> Self {
+        self.options.rustfmt_path = Some(path.into());
+        self
+    }
+
+    /// If true, always emit explicit padding fields.
+    ///
+    /// If a struct needs to be serialized in its native format (padding bytes
+    /// and all), for example writing it to a file or sending it on the network,
+    /// then this should be enabled, as anything reading the padding bytes of
+    /// a struct may lead to Undefined Behavior.
+    pub fn explicit_padding(mut self, doit: bool) -> Self {
+        self.options.force_explicit_padding = doit;
+        self
+    }
+
+    /// If true, enables experimental support to generate vtable functions.
+    ///
+    /// Should mostly work, though some edge cases are likely to be broken.
+    pub fn vtable_generation(mut self, doit: bool) -> Self {
+        self.options.vtable_generation = doit;
+        self
+    }
+
+    /// If true, enables the sorting of the output in a predefined manner.
+    ///
+    /// TODO: Perhaps move the sorting order out into a config
+    pub fn sort_semantically(mut self, doit: bool) -> Self {
+        self.options.sort_semantically = doit;
+        self
+    }
+
+    /// If true, merges extern blocks.
+    pub fn merge_extern_blocks(mut self, doit: bool) -> Self {
+        self.options.merge_extern_blocks = doit;
+        self
+    }
+
+    /// Generate the Rust bindings using the options built up thus far.
+    pub fn generate(mut self) -> Result<Bindings, BindgenError> {
+        // Add any extra arguments from the environment to the clang command line.
+        self.options.clang_args.extend(get_extra_clang_args());
+
+        // Transform input headers to arguments on the clang command line.
+        self.options.input_header = self.input_headers.pop();
+        self.options.extra_input_headers = self.input_headers;
+        self.options.clang_args.extend(
+            self.options.extra_input_headers.iter().flat_map(|header| {
+                iter::once("-include".into())
+                    .chain(iter::once(header.to_string()))
+            }),
+        );
+
+        let input_unsaved_files = self
+            .input_header_contents
+            .into_iter()
+            .map(|(name, contents)| clang::UnsavedFile::new(&name, &contents))
+            .collect::<Vec<_>>();
+
+        Bindings::generate(self.options, input_unsaved_files)
+    }
+
+    /// Preprocess and dump the input header files to disk.
+    ///
+    /// This is useful when debugging bindgen, using C-Reduce, or when filing
+    /// issues. The resulting file will be named something like `__bindgen.i` or
+    /// `__bindgen.ii`
+    pub fn dump_preprocessed_input(&self) -> io::Result<()> {
+        let clang =
+            clang_sys::support::Clang::find(None, &[]).ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    "Cannot find clang executable",
+                )
+            })?;
+
+        // The contents of a wrapper file that includes all the input header
+        // files.
+        let mut wrapper_contents = String::new();
+
+        // Whether we are working with C or C++ inputs.
+        let mut is_cpp = args_are_cpp(&self.options.clang_args);
+
+        // For each input header, add `#include "$header"`.
+        for header in &self.input_headers {
+            is_cpp |= file_is_cpp(header);
+
+            wrapper_contents.push_str("#include \"");
+            wrapper_contents.push_str(header);
+            wrapper_contents.push_str("\"\n");
+        }
+
+        // For each input header content, add a prefix line of `#line 0 "$name"`
+        // followed by the contents.
+        for &(ref name, ref contents) in &self.input_header_contents {
+            is_cpp |= file_is_cpp(name);
+
+            wrapper_contents.push_str("#line 0 \"");
+            wrapper_contents.push_str(name);
+            wrapper_contents.push_str("\"\n");
+            wrapper_contents.push_str(contents);
+        }
+
+        let wrapper_path = PathBuf::from(if is_cpp {
+            "__bindgen.cpp"
+        } else {
+            "__bindgen.c"
+        });
+
+        {
+            let mut wrapper_file = File::create(&wrapper_path)?;
+            wrapper_file.write_all(wrapper_contents.as_bytes())?;
+        }
+
+        let mut cmd = Command::new(&clang.path);
+        cmd.arg("-save-temps")
+            .arg("-E")
+            .arg("-C")
+            .arg("-c")
+            .arg(&wrapper_path)
+            .stdout(Stdio::piped());
+
+        for a in &self.options.clang_args {
+            cmd.arg(a);
+        }
+
+        for a in get_extra_clang_args() {
+            cmd.arg(a);
+        }
+
+        let mut child = cmd.spawn()?;
+
+        let mut preprocessed = child.stdout.take().unwrap();
+        let mut file = File::create(if is_cpp {
+            "__bindgen.ii"
+        } else {
+            "__bindgen.i"
+        })?;
+        io::copy(&mut preprocessed, &mut file)?;
+
+        if child.wait()?.success() {
+            Ok(())
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "clang exited with non-zero status",
+            ))
+        }
+    }
+
+    /// Don't derive `PartialEq` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_partialeq<T: Into<String>>(mut self, arg: T) -> Builder {
+        self.options.no_partialeq_types.insert(arg.into());
+        self
+    }
+
+    /// Don't derive `Copy` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_copy<T: Into<String>>(mut self, arg: T) -> Self {
+        self.options.no_copy_types.insert(arg.into());
+        self
+    }
+
+    /// Don't derive `Debug` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_debug<T: Into<String>>(mut self, arg: T) -> Self {
+        self.options.no_debug_types.insert(arg.into());
+        self
+    }
+
+    /// Don't derive/impl `Default` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_default<T: Into<String>>(mut self, arg: T) -> Self {
+        self.options.no_default_types.insert(arg.into());
+        self
+    }
+
+    /// Don't derive `Hash` for a given type. Regular
+    /// expressions are supported.
+    pub fn no_hash<T: Into<String>>(mut self, arg: T) -> Builder {
+        self.options.no_hash_types.insert(arg.into());
+        self
+    }
+
+    /// Add `#[must_use]` for the given type. Regular
+    /// expressions are supported.
+    pub fn must_use_type<T: Into<String>>(mut self, arg: T) -> Builder {
+        self.options.must_use_types.insert(arg.into());
+        self
+    }
+
+    /// Set whether `arr[size]` should be treated as `*mut T` or `*mut [T; size]` (same for mut)
+    pub fn array_pointers_in_arguments(mut self, doit: bool) -> Self {
+        self.options.array_pointers_in_arguments = doit;
+        self
+    }
+
+    /// Set the wasm import module name
+    pub fn wasm_import_module_name<T: Into<String>>(
+        mut self,
+        import_name: T,
+    ) -> Self {
+        self.options.wasm_import_module_name = Some(import_name.into());
+        self
+    }
+
+    /// Specify the dynamic library name if we are generating bindings for a shared library.
+    pub fn dynamic_library_name<T: Into<String>>(
+        mut self,
+        dynamic_library_name: T,
+    ) -> Self {
+        self.options.dynamic_library_name = Some(dynamic_library_name.into());
+        self
+    }
+
+    /// Require successful linkage for all routines in a shared library.
+    /// This allows us to optimize function calls by being able to safely assume function pointers
+    /// are valid.
+    pub fn dynamic_link_require_all(mut self, req: bool) -> Self {
+        self.options.dynamic_link_require_all = req;
+        self
+    }
+
+    /// Generate bindings as `pub` only if the bound item is publically accessible by C++.
+    pub fn respect_cxx_access_specs(mut self, doit: bool) -> Self {
+        self.options.respect_cxx_access_specs = doit;
+        self
+    }
+
+    /// Always translate enum integer types to native Rust integer types.
+    ///
+    /// This will result in enums having types such as `u32` and `i16` instead
+    /// of `c_uint` and `c_short`. Types for Rustified enums are always
+    /// translated.
+    pub fn translate_enum_integer_types(mut self, doit: bool) -> Self {
+        self.options.translate_enum_integer_types = doit;
+        self
+    }
+
+    /// Generate types with C style naming.
+    ///
+    /// This will add prefixes to the generated type names. For example instead of a struct `A` we
+    /// will generate struct `struct_A`. Currently applies to structs, unions, and enums.
+    pub fn c_naming(mut self, doit: bool) -> Self {
+        self.options.c_naming = doit;
+        self
+    }
+}
+
+/// Configuration options for generated bindings.
+#[derive(Clone, Debug)]
+struct BindgenOptions {
+    /// The set of types that have been blocklisted and should not appear
+    /// anywhere in the generated code.
+    blocklisted_types: RegexSet,
+
+    /// The set of functions that have been blocklisted and should not appear
+    /// in the generated code.
+    blocklisted_functions: RegexSet,
+
+    /// The set of items, regardless of item-type, that have been
+    /// blocklisted and should not appear in the generated code.
+    blocklisted_items: RegexSet,
+
+    /// The set of files whose contents should be blocklisted and should not
+    /// appear in the generated code.
+    blocklisted_files: RegexSet,
+
+    /// The set of types that should be treated as opaque structures in the
+    /// generated code.
+    opaque_types: RegexSet,
+
+    /// The explicit rustfmt path.
+    rustfmt_path: Option<PathBuf>,
+
+    /// The path to which we should write a Makefile-syntax depfile (if any).
+    depfile: Option<deps::DepfileSpec>,
+
+    /// The set of types that we should have bindings for in the generated
+    /// code.
+    ///
+    /// This includes all types transitively reachable from any type in this
+    /// set. One might think of allowlisted types/vars/functions as GC roots,
+    /// and the generated Rust code as including everything that gets marked.
+    allowlisted_types: RegexSet,
+
+    /// Allowlisted functions. See docs for `allowlisted_types` for more.
+    allowlisted_functions: RegexSet,
+
+    /// Allowlisted variables. See docs for `allowlisted_types` for more.
+    allowlisted_vars: RegexSet,
+
+    /// The set of files whose contents should be allowlisted.
+    allowlisted_files: RegexSet,
+
+    /// The default style of code to generate for enums
+    default_enum_style: codegen::EnumVariation,
+
+    /// The enum patterns to mark an enum as a bitfield
+    /// (newtype with bitwise operations).
+    bitfield_enums: RegexSet,
+
+    /// The enum patterns to mark an enum as a newtype.
+    newtype_enums: RegexSet,
+
+    /// The enum patterns to mark an enum as a global newtype.
+    newtype_global_enums: RegexSet,
+
+    /// The enum patterns to mark an enum as a Rust enum.
+    rustified_enums: RegexSet,
+
+    /// The enum patterns to mark an enum as a non-exhaustive Rust enum.
+    rustified_non_exhaustive_enums: RegexSet,
+
+    /// The enum patterns to mark an enum as a module of constants.
+    constified_enum_modules: RegexSet,
+
+    /// The enum patterns to mark an enum as a set of constants.
+    constified_enums: RegexSet,
+
+    /// The default type for C macro constants.
+    default_macro_constant_type: codegen::MacroTypeVariation,
+
+    /// The default style of code to generate for typedefs.
+    default_alias_style: codegen::AliasVariation,
+
+    /// Typedef patterns that will use regular type aliasing.
+    type_alias: RegexSet,
+
+    /// Typedef patterns that will be aliased by creating a new struct.
+    new_type_alias: RegexSet,
+
+    /// Typedef patterns that will be wrapped in a new struct and have
+    /// Deref and Deref to their aliased type.
+    new_type_alias_deref: RegexSet,
+
+    /// The default style of code to generate for union containing non-Copy
+    /// members.
+    default_non_copy_union_style: codegen::NonCopyUnionStyle,
+
+    /// The union patterns to mark an non-Copy union as using the bindgen
+    /// generated wrapper.
+    bindgen_wrapper_union: RegexSet,
+
+    /// The union patterns to mark an non-Copy union as using the
+    /// `::core::mem::ManuallyDrop` wrapper.
+    manually_drop_union: RegexSet,
+
+    /// Whether we should generate builtins or not.
+    builtins: bool,
+
+    /// True if we should dump the Clang AST for debugging purposes.
+    emit_ast: bool,
+
+    /// True if we should dump our internal IR for debugging purposes.
+    emit_ir: bool,
+
+    /// Output graphviz dot file.
+    emit_ir_graphviz: Option<String>,
+
+    /// True if we should emulate C++ namespaces with Rust modules in the
+    /// generated bindings.
+    enable_cxx_namespaces: bool,
+
+    /// True if we should try to find unexposed attributes in functions, in
+    /// order to be able to generate #[must_use] attributes in Rust.
+    enable_function_attribute_detection: bool,
+
+    /// True if we should avoid mangling names with namespaces.
+    disable_name_namespacing: bool,
+
+    /// True if we should avoid generating nested struct names.
+    disable_nested_struct_naming: bool,
+
+    /// True if we should avoid embedding version identifiers into source code.
+    disable_header_comment: bool,
+
+    /// True if we should generate layout tests for generated structures.
+    layout_tests: bool,
+
+    /// True if we should implement the Debug trait for C/C++ structures and types
+    /// that do not support automatically deriving Debug.
+    impl_debug: bool,
+
+    /// True if we should implement the PartialEq trait for C/C++ structures and types
+    /// that do not support automatically deriving PartialEq.
+    impl_partialeq: bool,
+
+    /// True if we should derive Copy trait implementations for C/C++ structures
+    /// and types.
+    derive_copy: bool,
+
+    /// True if we should derive Debug trait implementations for C/C++ structures
+    /// and types.
+    derive_debug: bool,
+
+    /// True if we should derive Default trait implementations for C/C++ structures
+    /// and types.
+    derive_default: bool,
+
+    /// True if we should derive Hash trait implementations for C/C++ structures
+    /// and types.
+    derive_hash: bool,
+
+    /// True if we should derive PartialOrd trait implementations for C/C++ structures
+    /// and types.
+    derive_partialord: bool,
+
+    /// True if we should derive Ord trait implementations for C/C++ structures
+    /// and types.
+    derive_ord: bool,
+
+    /// True if we should derive PartialEq trait implementations for C/C++ structures
+    /// and types.
+    derive_partialeq: bool,
+
+    /// True if we should derive Eq trait implementations for C/C++ structures
+    /// and types.
+    derive_eq: bool,
+
+    /// True if we should avoid using libstd to use libcore instead.
+    use_core: bool,
+
+    /// An optional prefix for the "raw" types, like `c_int`, `c_void`...
+    ctypes_prefix: Option<String>,
+
+    /// The prefix for the anon fields.
+    anon_fields_prefix: String,
+
+    /// Whether to time the bindgen phases.
+    time_phases: bool,
+
+    /// Whether we should convert float types to f32/f64 types.
+    convert_floats: bool,
+
+    /// The set of raw lines to prepend to the top-level module of generated
+    /// Rust code.
+    raw_lines: Vec<String>,
+
+    /// The set of raw lines to prepend to each of the modules.
+    ///
+    /// This only makes sense if the `enable_cxx_namespaces` option is set.
+    module_lines: HashMap<String, Vec<String>>,
+
+    /// The set of arguments to pass straight through to Clang.
+    clang_args: Vec<String>,
+
+    /// The input header file.
+    input_header: Option<String>,
+
+    /// Any additional input header files.
+    extra_input_headers: Vec<String>,
+
+    /// A user-provided visitor to allow customizing different kinds of
+    /// situations.
+    parse_callbacks: Option<Rc<dyn callbacks::ParseCallbacks>>,
+
+    /// Which kind of items should we generate? By default, we'll generate all
+    /// of them.
+    codegen_config: CodegenConfig,
+
+    /// Whether to treat inline namespaces conservatively.
+    ///
+    /// See the builder method description for more details.
+    conservative_inline_namespaces: bool,
+
+    /// Whether to keep documentation comments in the generated output. See the
+    /// documentation for more details. Defaults to true.
+    generate_comments: bool,
+
+    /// Whether to generate inline functions. Defaults to false.
+    generate_inline_functions: bool,
+
+    /// Whether to allowlist types recursively. Defaults to true.
+    allowlist_recursively: bool,
+
+    /// Instead of emitting 'use objc;' to files generated from objective c files,
+    /// generate '#[macro_use] extern crate objc;'
+    objc_extern_crate: bool,
+
+    /// Instead of emitting 'use block;' to files generated from objective c files,
+    /// generate '#[macro_use] extern crate block;'
+    generate_block: bool,
+
+    /// Instead of emitting 'use block;' to files generated from objective c files,
+    /// generate '#[macro_use] extern crate block;'
+    block_extern_crate: bool,
+
+    /// Whether to use the clang-provided name mangling. This is true and
+    /// probably needed for C++ features.
+    ///
+    /// However, some old libclang versions seem to return incorrect results in
+    /// some cases for non-mangled functions, see [1], so we allow disabling it.
+    ///
+    /// [1]: https://github.com/rust-lang/rust-bindgen/issues/528
+    enable_mangling: bool,
+
+    /// Whether to detect include paths using clang_sys.
+    detect_include_paths: bool,
+
+    /// Whether to try to fit macro constants into types smaller than u32/i32
+    fit_macro_constants: bool,
+
+    /// Whether to prepend the enum name to constant or newtype variants.
+    prepend_enum_name: bool,
+
+    /// Version of the Rust compiler to target
+    rust_target: RustTarget,
+
+    /// Features to enable, derived from `rust_target`
+    rust_features: RustFeatures,
+
+    /// Whether we should record which items in the regex sets ever matched.
+    ///
+    /// This may be a bit slower, but will enable reporting of unused allowlist
+    /// items via the `error!` log.
+    record_matches: bool,
+
+    /// Whether `size_t` should be translated to `usize` automatically.
+    size_t_is_usize: bool,
+
+    /// Whether rustfmt should format the generated bindings.
+    rustfmt_bindings: bool,
+
+    /// The absolute path to the rustfmt configuration file, if None, the standard rustfmt
+    /// options are used.
+    rustfmt_configuration_file: Option<PathBuf>,
+
+    /// The set of types that we should not derive `PartialEq` for.
+    no_partialeq_types: RegexSet,
+
+    /// The set of types that we should not derive `Copy` for.
+    no_copy_types: RegexSet,
+
+    /// The set of types that we should not derive `Debug` for.
+    no_debug_types: RegexSet,
+
+    /// The set of types that we should not derive/impl `Default` for.
+    no_default_types: RegexSet,
+
+    /// The set of types that we should not derive `Hash` for.
+    no_hash_types: RegexSet,
+
+    /// The set of types that we should be annotated with `#[must_use]`.
+    must_use_types: RegexSet,
+
+    /// Decide if C arrays should be regular pointers in rust or array pointers
+    array_pointers_in_arguments: bool,
+
+    /// Wasm import module name.
+    wasm_import_module_name: Option<String>,
+
+    /// The name of the dynamic library (if we are generating bindings for a shared library). If
+    /// this is None, no dynamic bindings are created.
+    dynamic_library_name: Option<String>,
+
+    /// Require successful linkage for all routines in a shared library.
+    /// This allows us to optimize function calls by being able to safely assume function pointers
+    /// are valid. No effect if `dynamic_library_name` is None.
+    dynamic_link_require_all: bool,
+
+    /// Only make generated bindings `pub` if the items would be publically accessible
+    /// by C++.
+    respect_cxx_access_specs: bool,
+
+    /// Always translate enum integer types to native Rust integer types.
+    translate_enum_integer_types: bool,
+
+    /// Generate types with C style naming.
+    c_naming: bool,
+
+    /// Always output explicit padding fields
+    force_explicit_padding: bool,
+
+    /// Emit vtable functions.
+    vtable_generation: bool,
+
+    /// Sort the code generation.
+    sort_semantically: bool,
+
+    /// Deduplicate `extern` blocks.
+    merge_extern_blocks: bool,
+}
+
+/// TODO(emilio): This is sort of a lie (see the error message that results from
+/// removing this), but since we don't share references across panic boundaries
+/// it's ok.
+impl ::std::panic::UnwindSafe for BindgenOptions {}
+
+impl BindgenOptions {
+    fn build(&mut self) {
+        let mut regex_sets = [
+            &mut self.allowlisted_vars,
+            &mut self.allowlisted_types,
+            &mut self.allowlisted_functions,
+            &mut self.allowlisted_files,
+            &mut self.blocklisted_types,
+            &mut self.blocklisted_functions,
+            &mut self.blocklisted_items,
+            &mut self.blocklisted_files,
+            &mut self.opaque_types,
+            &mut self.bitfield_enums,
+            &mut self.constified_enums,
+            &mut self.constified_enum_modules,
+            &mut self.newtype_enums,
+            &mut self.newtype_global_enums,
+            &mut self.rustified_enums,
+            &mut self.rustified_non_exhaustive_enums,
+            &mut self.type_alias,
+            &mut self.new_type_alias,
+            &mut self.new_type_alias_deref,
+            &mut self.bindgen_wrapper_union,
+            &mut self.manually_drop_union,
+            &mut self.no_partialeq_types,
+            &mut self.no_copy_types,
+            &mut self.no_debug_types,
+            &mut self.no_default_types,
+            &mut self.no_hash_types,
+            &mut self.must_use_types,
+        ];
+        let record_matches = self.record_matches;
+        for regex_set in &mut regex_sets {
+            regex_set.build(record_matches);
+        }
+    }
+
+    /// Update rust target version
+    pub fn set_rust_target(&mut self, rust_target: RustTarget) {
+        self.rust_target = rust_target;
+
+        // Keep rust_features synced with rust_target
+        self.rust_features = rust_target.into();
+    }
+
+    /// Get features supported by target Rust version
+    pub fn rust_features(&self) -> RustFeatures {
+        self.rust_features
+    }
+}
+
+impl Default for BindgenOptions {
+    fn default() -> BindgenOptions {
+        let rust_target = RustTarget::default();
+
+        BindgenOptions {
+            rust_target,
+            rust_features: rust_target.into(),
+            blocklisted_types: Default::default(),
+            blocklisted_functions: Default::default(),
+            blocklisted_items: Default::default(),
+            blocklisted_files: Default::default(),
+            opaque_types: Default::default(),
+            rustfmt_path: Default::default(),
+            depfile: Default::default(),
+            allowlisted_types: Default::default(),
+            allowlisted_functions: Default::default(),
+            allowlisted_vars: Default::default(),
+            allowlisted_files: Default::default(),
+            default_enum_style: Default::default(),
+            bitfield_enums: Default::default(),
+            newtype_enums: Default::default(),
+            newtype_global_enums: Default::default(),
+            rustified_enums: Default::default(),
+            rustified_non_exhaustive_enums: Default::default(),
+            constified_enums: Default::default(),
+            constified_enum_modules: Default::default(),
+            default_macro_constant_type: Default::default(),
+            default_alias_style: Default::default(),
+            type_alias: Default::default(),
+            new_type_alias: Default::default(),
+            new_type_alias_deref: Default::default(),
+            default_non_copy_union_style: Default::default(),
+            bindgen_wrapper_union: Default::default(),
+            manually_drop_union: Default::default(),
+            builtins: false,
+            emit_ast: false,
+            emit_ir: false,
+            emit_ir_graphviz: None,
+            layout_tests: true,
+            impl_debug: false,
+            impl_partialeq: false,
+            derive_copy: true,
+            derive_debug: true,
+            derive_default: false,
+            derive_hash: false,
+            derive_partialord: false,
+            derive_ord: false,
+            derive_partialeq: false,
+            derive_eq: false,
+            enable_cxx_namespaces: false,
+            enable_function_attribute_detection: false,
+            disable_name_namespacing: false,
+            disable_nested_struct_naming: false,
+            disable_header_comment: false,
+            use_core: false,
+            ctypes_prefix: None,
+            anon_fields_prefix: DEFAULT_ANON_FIELDS_PREFIX.into(),
+            convert_floats: true,
+            raw_lines: vec![],
+            module_lines: HashMap::default(),
+            clang_args: vec![],
+            input_header: None,
+            extra_input_headers: vec![],
+            parse_callbacks: None,
+            codegen_config: CodegenConfig::all(),
+            conservative_inline_namespaces: false,
+            generate_comments: true,
+            generate_inline_functions: false,
+            allowlist_recursively: true,
+            generate_block: false,
+            objc_extern_crate: false,
+            block_extern_crate: false,
+            enable_mangling: true,
+            detect_include_paths: true,
+            fit_macro_constants: false,
+            prepend_enum_name: true,
+            time_phases: false,
+            record_matches: true,
+            rustfmt_bindings: true,
+            size_t_is_usize: true,
+            rustfmt_configuration_file: None,
+            no_partialeq_types: Default::default(),
+            no_copy_types: Default::default(),
+            no_debug_types: Default::default(),
+            no_default_types: Default::default(),
+            no_hash_types: Default::default(),
+            must_use_types: Default::default(),
+            array_pointers_in_arguments: false,
+            wasm_import_module_name: None,
+            dynamic_library_name: None,
+            dynamic_link_require_all: false,
+            respect_cxx_access_specs: false,
+            translate_enum_integer_types: false,
+            c_naming: false,
+            force_explicit_padding: false,
+            vtable_generation: false,
+            sort_semantically: false,
+            merge_extern_blocks: false,
+        }
+    }
+}
+
+#[cfg(feature = "runtime")]
+fn ensure_libclang_is_loaded() {
+    if clang_sys::is_loaded() {
+        return;
+    }
+
+    // XXX (issue #350): Ensure that our dynamically loaded `libclang`
+    // doesn't get dropped prematurely, nor is loaded multiple times
+    // across different threads.
+
+    lazy_static! {
+        static ref LIBCLANG: std::sync::Arc<clang_sys::SharedLibrary> = {
+            clang_sys::load().expect("Unable to find libclang");
+            clang_sys::get_library().expect(
+                "We just loaded libclang and it had better still be \
+                 here!",
+            )
+        };
+    }
+
+    clang_sys::set_library(Some(LIBCLANG.clone()));
+}
+
+#[cfg(not(feature = "runtime"))]
+fn ensure_libclang_is_loaded() {}
+
+/// Error type for rust-bindgen.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum BindgenError {
+    /// The header was a folder.
+    FolderAsHeader(PathBuf),
+    /// Permissions to read the header is insufficient.
+    InsufficientPermissions(PathBuf),
+    /// The header does not exist.
+    NotExist(PathBuf),
+    /// Clang diagnosed an error.
+    ClangDiagnostic(String),
+}
+
+impl std::fmt::Display for BindgenError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BindgenError::FolderAsHeader(h) => {
+                write!(f, "'{}' is a folder", h.display())
+            }
+            BindgenError::InsufficientPermissions(h) => {
+                write!(f, "insufficient permissions to read '{}'", h.display())
+            }
+            BindgenError::NotExist(h) => {
+                write!(f, "header '{}' does not exist.", h.display())
+            }
+            BindgenError::ClangDiagnostic(message) => {
+                write!(f, "clang diagnosed error: {}", message)
+            }
+        }
+    }
+}
+
+impl std::error::Error for BindgenError {}
+
+/// Generated Rust bindings.
+#[derive(Debug)]
+pub struct Bindings {
+    options: BindgenOptions,
+    warnings: Vec<String>,
+    module: proc_macro2::TokenStream,
+}
+
+pub(crate) const HOST_TARGET: &str =
+    include_str!(concat!(env!("OUT_DIR"), "/host-target.txt"));
+
+// Some architecture triplets are different between rust and libclang, see #1211
+// and duplicates.
+fn rust_to_clang_target(rust_target: &str) -> String {
+    if rust_target.starts_with("aarch64-apple-") {
+        let mut clang_target = "arm64-apple-".to_owned();
+        clang_target
+            .push_str(rust_target.strip_prefix("aarch64-apple-").unwrap());
+        return clang_target;
+    } else if rust_target.starts_with("riscv64gc-") {
+        let mut clang_target = "riscv64-".to_owned();
+        clang_target.push_str(rust_target.strip_prefix("riscv64gc-").unwrap());
+        return clang_target;
+    }
+    rust_target.to_owned()
+}
+
+/// Returns the effective target, and whether it was explicitly specified on the
+/// clang flags.
+fn find_effective_target(clang_args: &[String]) -> (String, bool) {
+    let mut args = clang_args.iter();
+    while let Some(opt) = args.next() {
+        if opt.starts_with("--target=") {
+            let mut split = opt.split('=');
+            split.next();
+            return (split.next().unwrap().to_owned(), true);
+        }
+
+        if opt == "-target" {
+            if let Some(target) = args.next() {
+                return (target.clone(), true);
+            }
+        }
+    }
+
+    // If we're running from a build script, try to find the cargo target.
+    if let Ok(t) = env::var("TARGET") {
+        return (rust_to_clang_target(&t), false);
+    }
+
+    (rust_to_clang_target(HOST_TARGET), false)
+}
+
+impl Bindings {
+    /// Generate bindings for the given options.
+    pub(crate) fn generate(
+        mut options: BindgenOptions,
+        input_unsaved_files: Vec<clang::UnsavedFile>,
+    ) -> Result<Bindings, BindgenError> {
+        ensure_libclang_is_loaded();
+
+        #[cfg(feature = "runtime")]
+        debug!(
+            "Generating bindings, libclang at {}",
+            clang_sys::get_library().unwrap().path().display()
+        );
+        #[cfg(not(feature = "runtime"))]
+        debug!("Generating bindings, libclang linked");
+
+        options.build();
+
+        let (effective_target, explicit_target) =
+            find_effective_target(&options.clang_args);
+
+        let is_host_build =
+            rust_to_clang_target(HOST_TARGET) == effective_target;
+
+        // NOTE: The is_host_build check wouldn't be sound normally in some
+        // cases if we were to call a binary (if you have a 32-bit clang and are
+        // building on a 64-bit system for example).  But since we rely on
+        // opening libclang.so, it has to be the same architecture and thus the
+        // check is fine.
+        if !explicit_target && !is_host_build {
+            options
+                .clang_args
+                .insert(0, format!("--target={}", effective_target));
+        };
+
+        fn detect_include_paths(options: &mut BindgenOptions) {
+            if !options.detect_include_paths {
+                return;
+            }
+
+            // Filter out include paths and similar stuff, so we don't incorrectly
+            // promote them to `-isystem`.
+            let clang_args_for_clang_sys = {
+                let mut last_was_include_prefix = false;
+                options
+                    .clang_args
+                    .iter()
+                    .filter(|arg| {
+                        if last_was_include_prefix {
+                            last_was_include_prefix = false;
+                            return false;
+                        }
+
+                        let arg = &**arg;
+
+                        // https://clang.llvm.org/docs/ClangCommandLineReference.html
+                        // -isystem and -isystem-after are harmless.
+                        if arg == "-I" || arg == "--include-directory" {
+                            last_was_include_prefix = true;
+                            return false;
+                        }
+
+                        if arg.starts_with("-I") ||
+                            arg.starts_with("--include-directory=")
+                        {
+                            return false;
+                        }
+
+                        true
+                    })
+                    .cloned()
+                    .collect::<Vec<_>>()
+            };
+
+            debug!(
+                "Trying to find clang with flags: {:?}",
+                clang_args_for_clang_sys
+            );
+
+            let clang = match clang_sys::support::Clang::find(
+                None,
+                &clang_args_for_clang_sys,
+            ) {
+                None => return,
+                Some(clang) => clang,
+            };
+
+            debug!("Found clang: {:?}", clang);
+
+            // Whether we are working with C or C++ inputs.
+            let is_cpp = args_are_cpp(&options.clang_args) ||
+                options.input_header.as_deref().map_or(false, file_is_cpp);
+
+            let search_paths = if is_cpp {
+                clang.cpp_search_paths
+            } else {
+                clang.c_search_paths
+            };
+
+            if let Some(search_paths) = search_paths {
+                for path in search_paths.into_iter() {
+                    if let Ok(path) = path.into_os_string().into_string() {
+                        options.clang_args.push("-isystem".to_owned());
+                        options.clang_args.push(path);
+                    }
+                }
+            }
+        }
+
+        detect_include_paths(&mut options);
+
+        #[cfg(unix)]
+        fn can_read(perms: &std::fs::Permissions) -> bool {
+            use std::os::unix::fs::PermissionsExt;
+            perms.mode() & 0o444 > 0
+        }
+
+        #[cfg(not(unix))]
+        fn can_read(_: &std::fs::Permissions) -> bool {
+            true
+        }
+
+        if let Some(h) = options.input_header.as_ref() {
+            let path = Path::new(h);
+            if let Ok(md) = std::fs::metadata(path) {
+                if md.is_dir() {
+                    return Err(BindgenError::FolderAsHeader(path.into()));
+                }
+                if !can_read(&md.permissions()) {
+                    return Err(BindgenError::InsufficientPermissions(
+                        path.into(),
+                    ));
+                }
+                options.clang_args.push(h.clone())
+            } else {
+                return Err(BindgenError::NotExist(path.into()));
+            }
+        }
+
+        for (idx, f) in input_unsaved_files.iter().enumerate() {
+            if idx != 0 || options.input_header.is_some() {
+                options.clang_args.push("-include".to_owned());
+            }
+            options.clang_args.push(f.name.to_str().unwrap().to_owned())
+        }
+
+        debug!("Fixed-up options: {:?}", options);
+
+        let time_phases = options.time_phases;
+        let mut context = BindgenContext::new(options, &input_unsaved_files);
+
+        if is_host_build {
+            debug_assert_eq!(
+                context.target_pointer_size(),
+                std::mem::size_of::<*mut ()>(),
+                "{:?} {:?}",
+                effective_target,
+                HOST_TARGET
+            );
+        }
+
+        {
+            let _t = time::Timer::new("parse").with_output(time_phases);
+            parse(&mut context)?;
+        }
+
+        let (module, options, warnings) = codegen::codegen(context);
+
+        Ok(Bindings {
+            options,
+            warnings,
+            module,
+        })
+    }
+
+    /// Write these bindings as source text to a file.
+    pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+        let file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(path.as_ref())?;
+        self.write(Box::new(file))?;
+        Ok(())
+    }
+
+    /// Write these bindings as source text to the given `Write`able.
+    pub fn write<'a>(&self, mut writer: Box<dyn Write + 'a>) -> io::Result<()> {
+        if !self.options.disable_header_comment {
+            let version = option_env!("CARGO_PKG_VERSION");
+            let header = format!(
+                "/* automatically generated by rust-bindgen {} */\n\n",
+                version.unwrap_or("(unknown version)")
+            );
+            writer.write_all(header.as_bytes())?;
+        }
+
+        for line in self.options.raw_lines.iter() {
+            writer.write_all(line.as_bytes())?;
+            writer.write_all("\n".as_bytes())?;
+        }
+
+        if !self.options.raw_lines.is_empty() {
+            writer.write_all("\n".as_bytes())?;
+        }
+
+        let bindings = self.module.to_string();
+
+        match self.rustfmt_generated_string(&bindings) {
+            Ok(rustfmt_bindings) => {
+                writer.write_all(rustfmt_bindings.as_bytes())?;
+            }
+            Err(err) => {
+                eprintln!(
+                    "Failed to run rustfmt: {} (non-fatal, continuing)",
+                    err
+                );
+                writer.write_all(bindings.as_bytes())?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Gets the rustfmt path to rustfmt the generated bindings.
+    fn rustfmt_path(&self) -> io::Result<Cow<PathBuf>> {
+        debug_assert!(self.options.rustfmt_bindings);
+        if let Some(ref p) = self.options.rustfmt_path {
+            return Ok(Cow::Borrowed(p));
+        }
+        if let Ok(rustfmt) = env::var("RUSTFMT") {
+            return Ok(Cow::Owned(rustfmt.into()));
+        }
+        #[cfg(feature = "which-rustfmt")]
+        match which::which("rustfmt") {
+            Ok(p) => Ok(Cow::Owned(p)),
+            Err(e) => {
+                Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)))
+            }
+        }
+        #[cfg(not(feature = "which-rustfmt"))]
+        // No rustfmt binary was specified, so assume that the binary is called
+        // "rustfmt" and that it is in the user's PATH.
+        Ok(Cow::Owned("rustfmt".into()))
+    }
+
+    /// Checks if rustfmt_bindings is set and runs rustfmt on the string
+    fn rustfmt_generated_string<'a>(
+        &self,
+        source: &'a str,
+    ) -> io::Result<Cow<'a, str>> {
+        let _t = time::Timer::new("rustfmt_generated_string")
+            .with_output(self.options.time_phases);
+
+        if !self.options.rustfmt_bindings {
+            return Ok(Cow::Borrowed(source));
+        }
+
+        let rustfmt = self.rustfmt_path()?;
+        let mut cmd = Command::new(&*rustfmt);
+
+        cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
+
+        if let Some(path) = self
+            .options
+            .rustfmt_configuration_file
+            .as_ref()
+            .and_then(|f| f.to_str())
+        {
+            cmd.args(["--config-path", path]);
+        }
+
+        let mut child = cmd.spawn()?;
+        let mut child_stdin = child.stdin.take().unwrap();
+        let mut child_stdout = child.stdout.take().unwrap();
+
+        let source = source.to_owned();
+
+        // Write to stdin in a new thread, so that we can read from stdout on this
+        // thread. This keeps the child from blocking on writing to its stdout which
+        // might block us from writing to its stdin.
+        let stdin_handle = ::std::thread::spawn(move || {
+            let _ = child_stdin.write_all(source.as_bytes());
+            source
+        });
+
+        let mut output = vec![];
+        io::copy(&mut child_stdout, &mut output)?;
+
+        let status = child.wait()?;
+        let source = stdin_handle.join().expect(
+            "The thread writing to rustfmt's stdin doesn't do \
+             anything that could panic",
+        );
+
+        match String::from_utf8(output) {
+            Ok(bindings) => match status.code() {
+                Some(0) => Ok(Cow::Owned(bindings)),
+                Some(2) => Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Rustfmt parsing errors.".to_string(),
+                )),
+                Some(3) => {
+                    warn!("Rustfmt could not format some lines.");
+                    Ok(Cow::Owned(bindings))
+                }
+                _ => Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Internal rustfmt error".to_string(),
+                )),
+            },
+            _ => Ok(Cow::Owned(source)),
+        }
+    }
+
+    /// Emit all the warning messages raised while generating the bindings in a build script.
+    ///
+    /// If you are using `bindgen` outside of a build script you should use [`Bindings::warnings`]
+    /// and handle the messages accordingly instead.
+    #[inline]
+    pub fn emit_warnings(&self) {
+        for message in &self.warnings {
+            println!("cargo:warning={}", message);
+        }
+    }
+
+    /// Return all the warning messages raised while generating the bindings.
+    #[inline]
+    pub fn warnings(&self) -> &[String] {
+        &self.warnings
+    }
+}
+
+impl std::fmt::Display for Bindings {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bytes = vec![];
+        self.write(Box::new(&mut bytes) as Box<dyn Write>)
+            .expect("writing to a vec cannot fail");
+        f.write_str(
+            std::str::from_utf8(&bytes)
+                .expect("we should only write bindings that are valid utf-8"),
+        )
+    }
+}
+
+/// Determines whether the given cursor is in any of the files matched by the
+/// options.
+fn filter_builtins(ctx: &BindgenContext, cursor: &clang::Cursor) -> bool {
+    ctx.options().builtins || !cursor.is_builtin()
+}
+
+/// Parse one `Item` from the Clang cursor.
+fn parse_one(
+    ctx: &mut BindgenContext,
+    cursor: clang::Cursor,
+    parent: Option<ItemId>,
+) -> clang_sys::CXChildVisitResult {
+    if !filter_builtins(ctx, &cursor) {
+        return CXChildVisit_Continue;
+    }
+
+    use clang_sys::CXChildVisit_Continue;
+    match Item::parse(cursor, parent, ctx) {
+        Ok(..) => {}
+        Err(ParseError::Continue) => {}
+        Err(ParseError::Recurse) => {
+            cursor.visit(|child| parse_one(ctx, child, parent));
+        }
+    }
+    CXChildVisit_Continue
+}
+
+/// Parse the Clang AST into our `Item` internal representation.
+fn parse(context: &mut BindgenContext) -> Result<(), BindgenError> {
+    use clang_sys::*;
+
+    let mut error = None;
+    for d in context.translation_unit().diags().iter() {
+        let msg = d.format();
+        let is_err = d.severity() >= CXDiagnostic_Error;
+        if is_err {
+            let error = error.get_or_insert_with(String::new);
+            error.push_str(&msg);
+            error.push('\n');
+        } else {
+            eprintln!("clang diag: {}", msg);
+        }
+    }
+
+    if let Some(message) = error {
+        return Err(BindgenError::ClangDiagnostic(message));
+    }
+
+    let cursor = context.translation_unit().cursor();
+
+    if context.options().emit_ast {
+        fn dump_if_not_builtin(cur: &clang::Cursor) -> CXChildVisitResult {
+            if !cur.is_builtin() {
+                clang::ast_dump(cur, 0)
+            } else {
+                CXChildVisit_Continue
+            }
+        }
+        cursor.visit(|cur| dump_if_not_builtin(&cur));
+    }
+
+    let root = context.root_module();
+    context.with_module(root, |context| {
+        cursor.visit(|cursor| parse_one(context, cursor, None))
+    });
+
+    assert!(
+        context.current_module() == context.root_module(),
+        "How did this happen?"
+    );
+    Ok(())
+}
+
+/// Extracted Clang version data
+#[derive(Debug)]
+pub struct ClangVersion {
+    /// Major and minor semver, if parsing was successful
+    pub parsed: Option<(u32, u32)>,
+    /// full version string
+    pub full: String,
+}
+
+/// Get the major and the minor semver numbers of Clang's version
+pub fn clang_version() -> ClangVersion {
+    ensure_libclang_is_loaded();
+
+    //Debian clang version 11.0.1-2
+    let raw_v: String = clang::extract_clang_version();
+    let split_v: Option<Vec<&str>> = raw_v
+        .split_whitespace()
+        .find(|t| t.chars().next().map_or(false, |v| v.is_ascii_digit()))
+        .map(|v| v.split('.').collect());
+    if let Some(v) = split_v {
+        if v.len() >= 2 {
+            let maybe_major = v[0].parse::<u32>();
+            let maybe_minor = v[1].parse::<u32>();
+            if let (Ok(major), Ok(minor)) = (maybe_major, maybe_minor) {
+                return ClangVersion {
+                    parsed: Some((major, minor)),
+                    full: raw_v.clone(),
+                };
+            }
+        }
+    };
+    ClangVersion {
+        parsed: None,
+        full: raw_v.clone(),
+    }
+}
+
+/// Looks for the env var `var_${TARGET}`, and falls back to just `var` when it is not found.
+fn get_target_dependent_env_var(var: &str) -> Option<String> {
+    if let Ok(target) = env::var("TARGET") {
+        if let Ok(v) = env::var(&format!("{}_{}", var, target)) {
+            return Some(v);
+        }
+        if let Ok(v) =
+            env::var(&format!("{}_{}", var, target.replace('-', "_")))
+        {
+            return Some(v);
+        }
+    }
+    env::var(var).ok()
+}
+
+/// A ParseCallbacks implementation that will act on file includes by echoing a rerun-if-changed
+/// line
+///
+/// When running inside a `build.rs` script, this can be used to make cargo invalidate the
+/// generated bindings whenever any of the files included from the header change:
+/// ```
+/// use bindgen::builder;
+/// let bindings = builder()
+///     .header("path/to/input/header")
+///     .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+///     .generate();
+/// ```
+#[derive(Debug)]
+pub struct CargoCallbacks;
+
+impl callbacks::ParseCallbacks for CargoCallbacks {
+    fn include_file(&self, filename: &str) {
+        println!("cargo:rerun-if-changed={}", filename);
+    }
+}
+
+/// Test command_line_flag function.
+#[test]
+fn commandline_flag_unit_test_function() {
+    //Test 1
+    let bindings = crate::builder();
+    let command_line_flags = bindings.command_line_flags();
+
+    let test_cases = vec![
+        "--rust-target",
+        "--no-derive-default",
+        "--generate",
+        "functions,types,vars,methods,constructors,destructors",
+    ]
+    .iter()
+    .map(|&x| x.into())
+    .collect::<Vec<String>>();
+
+    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
+
+    //Test 2
+    let bindings = crate::builder()
+        .header("input_header")
+        .allowlist_type("Distinct_Type")
+        .allowlist_function("safe_function");
+
+    let command_line_flags = bindings.command_line_flags();
+    let test_cases = vec![
+        "--rust-target",
+        "input_header",
+        "--no-derive-default",
+        "--generate",
+        "functions,types,vars,methods,constructors,destructors",
+        "--allowlist-type",
+        "Distinct_Type",
+        "--allowlist-function",
+        "safe_function",
+    ]
+    .iter()
+    .map(|&x| x.into())
+    .collect::<Vec<String>>();
+    println!("{:?}", command_line_flags);
+
+    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
+}
+
+#[test]
+fn test_rust_to_clang_target() {
+    assert_eq!(rust_to_clang_target("aarch64-apple-ios"), "arm64-apple-ios");
+}
+
+#[test]
+fn test_rust_to_clang_target_riscv() {
+    assert_eq!(
+        rust_to_clang_target("riscv64gc-unknown-linux-gnu"),
+        "riscv64-unknown-linux-gnu"
+    )
+}
diff --git a/bindgen/log_stubs.rs b/bindgen/log_stubs.rs
new file mode 100644
index 00000000..83159831
--- /dev/null
+++ b/bindgen/log_stubs.rs
@@ -0,0 +1,32 @@
+#![allow(unused)]
+
+macro_rules! log {
+    (target: $target:expr, $lvl:expr, $($arg:tt)+) => {{
+        let _ = $target;
+        let _ = log!($lvl, $($arg)+);
+    }};
+    ($lvl:expr, $($arg:tt)+) => {{
+        let _ = $lvl;
+        let _ = format_args!($($arg)+);
+    }};
+}
+macro_rules! error {
+    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
+    ($($arg:tt)+) => { log!("", $($arg)+) };
+}
+macro_rules! warn {
+    (target: $target:expr, $($arg:tt)*) => { log!(target: $target, "", $($arg)*) };
+    ($($arg:tt)*) => { log!("", $($arg)*) };
+}
+macro_rules! info {
+    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
+    ($($arg:tt)+) => { log!("", $($arg)+) };
+}
+macro_rules! debug {
+    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
+    ($($arg:tt)+) => { log!("", $($arg)+) };
+}
+macro_rules! trace {
+    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
+    ($($arg:tt)+) => { log!("", $($arg)+) };
+}
diff --git a/bindgen/parse.rs b/bindgen/parse.rs
new file mode 100644
index 00000000..f60de431
--- /dev/null
+++ b/bindgen/parse.rs
@@ -0,0 +1,102 @@
+//! Common traits and types related to parsing our IR from Clang cursors.
+
+use crate::clang;
+use crate::ir::context::{BindgenContext, ItemId, TypeId};
+use crate::ir::ty::TypeKind;
+
+/// Not so much an error in the traditional sense, but a control flow message
+/// when walking over Clang's AST with a cursor.
+#[derive(Debug)]
+pub enum ParseError {
+    /// Recurse down the current AST node's children.
+    Recurse,
+    /// Continue on to the next sibling AST node, or back up to the parent's
+    /// siblings if we've exhausted all of this node's siblings (and so on).
+    Continue,
+}
+
+/// The result of parsing a Clang AST node.
+#[derive(Debug)]
+pub enum ParseResult<T> {
+    /// We've already resolved this item before, here is the extant `ItemId` for
+    /// it.
+    AlreadyResolved(ItemId),
+
+    /// This is a newly parsed item. If the cursor is `Some`, it points to the
+    /// AST node where the new `T` was declared.
+    New(T, Option<clang::Cursor>),
+}
+
+/// An intermediate representation "sub-item" (i.e. one of the types contained
+/// inside an `ItemKind` variant) that can be parsed from a Clang cursor.
+pub trait ClangSubItemParser: Sized {
+    /// Attempt to parse this type from the given cursor.
+    ///
+    /// The fact that is a reference guarantees it's held by the context, and
+    /// allow returning already existing types.
+    fn parse(
+        cursor: clang::Cursor,
+        context: &mut BindgenContext,
+    ) -> Result<ParseResult<Self>, ParseError>;
+}
+
+/// An intermediate representation item that can be parsed from a Clang cursor.
+pub trait ClangItemParser: Sized {
+    /// Parse this item from the given Clang cursor.
+    fn parse(
+        cursor: clang::Cursor,
+        parent: Option<ItemId>,
+        context: &mut BindgenContext,
+    ) -> Result<ItemId, ParseError>;
+
+    /// Parse this item from the given Clang type.
+    fn from_ty(
+        ty: &clang::Type,
+        location: clang::Cursor,
+        parent: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<TypeId, ParseError>;
+
+    /// Identical to `from_ty`, but use the given `id` as the `ItemId` for the
+    /// newly parsed item.
+    fn from_ty_with_id(
+        id: ItemId,
+        ty: &clang::Type,
+        location: clang::Cursor,
+        parent: Option<ItemId>,
+        ctx: &mut BindgenContext,
+    ) -> Result<TypeId, ParseError>;
+
+    /// Parse this item from the given Clang type, or if we haven't resolved all
+    /// the other items this one depends on, an unresolved reference.
+    fn from_ty_or_ref(
+        ty: clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        context: &mut BindgenContext,
+    ) -> TypeId;
+
+    /// Identical to `from_ty_or_ref`, but use the given `potential_id` as the
+    /// `ItemId` for the newly parsed item.
+    fn from_ty_or_ref_with_id(
+        potential_id: ItemId,
+        ty: clang::Type,
+        location: clang::Cursor,
+        parent_id: Option<ItemId>,
+        context: &mut BindgenContext,
+    ) -> TypeId;
+
+    /// Create a named template type.
+    fn type_param(
+        with_id: Option<ItemId>,
+        location: clang::Cursor,
+        ctx: &mut BindgenContext,
+    ) -> Option<TypeId>;
+
+    /// Create a builtin type.
+    fn builtin_type(
+        kind: TypeKind,
+        is_const: bool,
+        context: &mut BindgenContext,
+    ) -> TypeId;
+}
diff --git a/bindgen/regex_set.rs b/bindgen/regex_set.rs
new file mode 100644
index 00000000..9262c4ee
--- /dev/null
+++ b/bindgen/regex_set.rs
@@ -0,0 +1,92 @@
+//! A type that represents the union of a set of regular expressions.
+
+use regex::RegexSet as RxSet;
+use std::cell::Cell;
+
+/// A dynamic set of regular expressions.
+#[derive(Clone, Debug, Default)]
+pub struct RegexSet {
+    items: Vec<String>,
+    /// Whether any of the items in the set was ever matched. The length of this
+    /// vector is exactly the length of `items`.
+    matched: Vec<Cell<bool>>,
+    set: Option<RxSet>,
+    /// Whether we should record matching items in the `matched` vector or not.
+    record_matches: bool,
+}
+
+impl RegexSet {
+    /// Is this set empty?
+    pub fn is_empty(&self) -> bool {
+        self.items.is_empty()
+    }
+
+    /// Insert a new regex into this set.
+    pub fn insert<S>(&mut self, string: S)
+    where
+        S: AsRef<str>,
+    {
+        self.items.push(string.as_ref().to_owned());
+        self.matched.push(Cell::new(false));
+        self.set = None;
+    }
+
+    /// Returns slice of String from its field 'items'
+    pub fn get_items(&self) -> &[String] {
+        &self.items[..]
+    }
+
+    /// Returns an iterator over regexes in the set which didn't match any
+    /// strings yet.
+    pub fn unmatched_items(&self) -> impl Iterator<Item = &String> {
+        self.items.iter().enumerate().filter_map(move |(i, item)| {
+            if !self.record_matches || self.matched[i].get() {
+                return None;
+            }
+
+            Some(item)
+        })
+    }
+
+    /// Construct a RegexSet from the set of entries we've accumulated.
+    ///
+    /// Must be called before calling `matches()`, or it will always return
+    /// false.
+    pub fn build(&mut self, record_matches: bool) {
+        let items = self.items.iter().map(|item| format!("^{}$", item));
+        self.record_matches = record_matches;
+        self.set = match RxSet::new(items) {
+            Ok(x) => Some(x),
+            Err(e) => {
+                warn!("Invalid regex in {:?}: {:?}", self.items, e);
+                None
+            }
+        }
+    }
+
+    /// Does the given `string` match any of the regexes in this set?
+    pub fn matches<S>(&self, string: S) -> bool
+    where
+        S: AsRef<str>,
+    {
+        let s = string.as_ref();
+        let set = match self.set {
+            Some(ref set) => set,
+            None => return false,
+        };
+
+        if !self.record_matches {
+            return set.is_match(s);
+        }
+
+        let matches = set.matches(s);
+        if !matches.matched_any() {
+            return false;
+        }
+        for i in matches.iter() {
+            self.matched[i].set(true);
+        }
+
+        true
+    }
+}
diff --git a/bindgen/time.rs b/bindgen/time.rs
new file mode 100644
index 00000000..c13a640c
--- /dev/null
+++ b/bindgen/time.rs
@@ -0,0 +1,52 @@
+use std::io::{self, Write};
+use std::time::{Duration, Instant};
+
+/// RAII timer to measure how long phases take.
+#[derive(Debug)]
+pub struct Timer<'a> {
+    output: bool,
+    name: &'a str,
+    start: Instant,
+}
+
+impl<'a> Timer<'a> {
+    /// Creates a Timer with the given name, and starts it. By default,
+    /// will print to stderr when it is `drop`'d
+    pub fn new(name: &'a str) -> Self {
+        Timer {
+            output: true,
+            name,
+            start: Instant::now(),
+        }
+    }
+
+    /// Sets whether or not the Timer will print a message
+    /// when it is dropped.
+    pub fn with_output(mut self, output: bool) -> Self {
+        self.output = output;
+        self
+    }
+
+    /// Returns the time elapsed since the timer's creation
+    pub fn elapsed(&self) -> Duration {
+        Instant::now() - self.start
+    }
+
+    fn print_elapsed(&mut self) {
+        if self.output {
+            let elapsed = self.elapsed();
+            let time = (elapsed.as_secs() as f64) * 1e3 +
+                (elapsed.subsec_nanos() as f64) / 1e6;
+            let stderr = io::stderr();
+            // Arbitrary output format, subject to change.
+            writeln!(stderr.lock(), "  time: {:>9.3} ms.\t{}", time, self.name)
+                .expect("timer write should not fail");
+        }
+    }
+}
+
+impl<'a> Drop for Timer<'a> {
+    fn drop(&mut self) {
+        self.print_elapsed();
+    }
+}
diff --git a/book/src/command-line-usage.md b/book/src/command-line-usage.md
index d90eb442..b3356d70 100644
--- a/book/src/command-line-usage.md
+++ b/book/src/command-line-usage.md
@@ -3,7 +3,7 @@
 Install the `bindgen` executable with `cargo`:
 
 ```bash
-$ cargo install bindgen
+$ cargo install bindgen-cli
 ```
 
 The `bindgen` executable is installed to `~/.cargo/bin`. You have to add that
diff --git a/build.rs b/build.rs
deleted file mode 100644
index 8c05d59b..00000000
--- a/build.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-mod target {
-    use std::env;
-    use std::fs::File;
-    use std::io::Write;
-    use std::path::{Path, PathBuf};
-
-    pub fn main() {
-        let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
-
-        let mut dst =
-            File::create(Path::new(&out_dir).join("host-target.txt")).unwrap();
-        dst.write_all(env::var("TARGET").unwrap().as_bytes())
-            .unwrap();
-    }
-}
-
-mod testgen {
-    use std::char;
-    use std::env;
-    use std::ffi::OsStr;
-    use std::fs::{self, File};
-    use std::io::Write;
-    use std::path::{Path, PathBuf};
-
-    pub fn main() {
-        let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
-        let mut dst =
-            File::create(Path::new(&out_dir).join("tests.rs")).unwrap();
-
-        let manifest_dir =
-            PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
-        let headers_dir = manifest_dir.join("tests").join("headers");
-
-        let headers = match fs::read_dir(headers_dir) {
-            Ok(dir) => dir,
-            // We may not have headers directory after packaging.
-            Err(..) => return,
-        };
-
-        let entries =
-            headers.map(|result| result.expect("Couldn't read header file"));
-
-        println!("cargo:rerun-if-changed=tests/headers");
-
-        for entry in entries {
-            match entry.path().extension().and_then(OsStr::to_str) {
-                Some("h") | Some("hpp") => {
-                    let func = entry
-                        .file_name()
-                        .to_str()
-                        .unwrap()
-                        .replace(|c| !char::is_alphanumeric(c), "_")
-                        .replace("__", "_")
-                        .to_lowercase();
-                    writeln!(
-                        dst,
-                        "test_header!(header_{}, {:?});",
-                        func,
-                        entry.path(),
-                    )
-                    .unwrap();
-                }
-                _ => {}
-            }
-        }
-
-        dst.flush().unwrap();
-    }
-}
-
-fn main() {
-    target::main();
-    testgen::main();
-
-    // On behalf of clang_sys, rebuild ourselves if important configuration
-    // variables change, to ensure that bindings get rebuilt if the
-    // underlying libclang changes.
-    println!("cargo:rerun-if-env-changed=LLVM_CONFIG_PATH");
-    println!("cargo:rerun-if-env-changed=LIBCLANG_PATH");
-    println!("cargo:rerun-if-env-changed=LIBCLANG_STATIC_PATH");
-    println!("cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS");
-    println!(
-        "cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS_{}",
-        std::env::var("TARGET").unwrap()
-    );
-    println!(
-        "cargo:rerun-if-env-changed=BINDGEN_EXTRA_CLANG_ARGS_{}",
-        std::env::var("TARGET").unwrap().replace('-', "_")
-    );
-}
diff --git a/ci/no-includes.sh b/ci/no-includes.sh
index 6aa0fc12..97966cb0 100755
--- a/ci/no-includes.sh
+++ b/ci/no-includes.sh
@@ -7,7 +7,7 @@ cd "$(dirname "$0")/.."
 
 echo "Checking for #include directives of system headers..."
 
-grep -rn '#include\s*<.*>' tests/headers || {
+grep -rn '#include\s*<.*>' bindgen-tests/tests/headers || {
     echo "Found none; OK!"
     exit 0
 }
diff --git a/ci/test.sh b/ci/test.sh
index b58ed0f1..788c28fe 100755
--- a/ci/test.sh
+++ b/ci/test.sh
@@ -126,11 +126,11 @@ fi
 CARGO_ARGS=`get_cargo_args`
 
 # Ensure we build without warnings
-cargo rustc --lib $CARGO_ARGS -- -Dwarnings
+RUSTFLAGS="-Dwarnings" cargo check $CARGO_ARGS
 
 if [ "$BINDGEN_MAIN_TESTS" == "1" ]; then
   # Run the tests
-  cargo test $CARGO_ARGS
+  (cd bindgen-tests && cargo test $CARGO_ARGS)
 fi
 
 assert_no_diff
diff --git a/csmith-fuzzing/README.md b/csmith-fuzzing/README.md
deleted file mode 100644
index cdd6d086..00000000
--- a/csmith-fuzzing/README.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Fuzzing `bindgen` with `csmith`
-
-[`csmith`][csmith] generates random C and C++ programs that can be used as test
-cases for compilers. When testing `bindgen` with `csmith`, we interpret the
-generated programs as header files, and emit Rust bindings to them. If `bindgen`
-panics, the emitted bindings won't compile with `rustc`, or the generated layout
-tests in the bindings fail, then we report an issue containing the test case!
-
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
-
-- [Prerequisites](#prerequisites)
-- [Running the Fuzzer](#running-the-fuzzer)
-- [Reporting Issues](#reporting-issues)
-
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
-
-## Prerequisites
-
-Requires `python3`, `csmith`, and `creduce` to be in `$PATH`.
-
-Many OS package managers have `csmith` and `creduce` packages:
-
-```
-$ sudo apt install csmith creduce
-$ brew install csmith creduce
-$ # Etc...
-```
-
-## Running the Fuzzer
-
-Run `csmith` and test `bindgen` on the generated test cases with this command:
-
-```
-$ ./driver.py
-```
-
-The driver will keep running until it encounters an error in `bindgen`.
-
-Each invocation of `./driver.py` will use its own temporary directories, so
-running it in multiple terminals in parallel is supported.
-
-`csmith` is run with `--no-checksum --nomain --max-block-size 1
---max-block-depth 1` which disables the `main` function, and makes function
-bodies as simple as possible as `bindgen` does not care about them, but they
-cannot be completely disabled in `csmith`. Run `csmith --help` to see what
-exactly those options do.
-
-## Reporting Issues
-
-Once the fuzz driver finds a test case that causes some kind of error in
-`bindgen` or its emitted bindings, it is helpful to
-[run C-Reduce on the test case][creducing] to remove the parts that are
-irrelevant to reproducing the error. This is ***very*** helpful for the folks
-who further investigate the issue and come up with a fix!
-
-Additionally, mention that you discovered the issue via `csmith` and we will add
-the `A-csmith` label. You can find all the issues discovered with `csmith`, and
-related to fuzzing with `csmith`, by looking up
-[all issues tagged with the `A-csmith` label][csmith-issues].
-
-[csmith]: https://github.com/csmith-project/csmith
-[creducing]: ../CONTRIBUTING.md#using-creduce-to-minimize-test-cases
-[csmith-issues]: https://github.com/rust-lang/rust-bindgen/issues?q=label%3AA-csmith
diff --git a/csmith-fuzzing/csmith.h b/csmith-fuzzing/csmith.h
deleted file mode 100644
index faaef5b1..00000000
--- a/csmith-fuzzing/csmith.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// Type definitions from csmith's csmith_minimal.h included in csmith.h .
-// Since other header contents are not needed we put them in here
-// so the other original header is not needed anymore.
-
-#define int8_t signed char
-#define uint8_t unsigned char
-
-#define int16_t short
-#define uint16_t unsigned short
-
-#define int32_t int
-#define uint32_t unsigned
-
-#define int64_t long long
-#define uint64_t unsigned long long
diff --git a/csmith-fuzzing/driver.py b/csmith-fuzzing/driver.py
deleted file mode 100755
index 1d3af540..00000000
--- a/csmith-fuzzing/driver.py
+++ /dev/null
@@ -1,284 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import os
-import re
-import shlex
-import sys
-from subprocess import run, SubprocessError, DEVNULL, PIPE
-from tempfile import NamedTemporaryFile
-
-DESC = """
-
-A `csmith` fuzzing driver for `bindgen`.
-
-Generates random C source files with `csmith` and then passes them to `bindgen`
-(via `predicate.py`). If `bindgen` can't emit bindings, `rustc` can't compile
-those bindings, or the compiled bindings' layout tests fail, then the driver has
-found a bug, and will report the problematic test case to you.
-
-"""
-
-parser = argparse.ArgumentParser(
-    formatter_class=argparse.RawDescriptionHelpFormatter,
-    description=DESC.strip())
-
-parser.add_argument(
-    "--keep-going",
-    action="store_true",
-    help="Do not stop after finding a test case that exhibits a bug in `bindgen`. Instead, keep going.")
-
-CSMITH_ARGS="\
---no-checksum \
---nomain \
---max-block-size 1 \
---max-block-depth 1"
-
-parser.add_argument(
-    "--csmith-args",
-    type=str,
-    default=CSMITH_ARGS,
-    help="Pass this argument string to `csmith`. By default, very small functions are generated.")
-
-BINDGEN_ARGS = "--with-derive-partialeq \
---with-derive-eq \
---with-derive-partialord \
---with-derive-ord \
---with-derive-hash \
---with-derive-default"
-
-parser.add_argument(
-    "--bindgen-args",
-    type=str,
-    default=BINDGEN_ARGS,
-    help="Pass this argument string to `bindgen`. By default, all traits are derived.")
-
-parser.add_argument(
-    "--no-creduce",
-    action="store_false",
-    dest="creduce",
-    help="Do not run `creduce` on any buggy test case(s) discovered.")
-
-################################################################################
-
-def cat(path, title=None):
-    if not title:
-        title = path
-    print("-------------------- {} --------------------".format(title))
-    print()
-    print()
-    run(["cat", path])
-
-def decode(f):
-    return f.decode(encoding="utf-8", errors="ignore")
-
-def run_logged(cmd):
-    result = run(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE)
-    result.stdout = decode(result.stdout)
-    result.stderr = decode(result.stderr)
-    if result.returncode != 0:
-        print()
-        print()
-        print("Error: {} exited with code {}".format(cmd, result.returncode))
-        print()
-        print()
-        for line in result.stdout.splitlines():
-            sys.stdout.write("+")
-            sys.stdout.write(line)
-            sys.stdout.write("\n")
-        for line in result.stderr.splitlines():
-            sys.stderr.write("+")
-            sys.stderr.write(line)
-            sys.stderr.write("\n")
-    return result
-
-def main():
-    os.environ["RUST_BACKTRACE"] = "full"
-    args = parser.parse_args()
-
-    bindgen_args = args.bindgen_args
-    if bindgen_args.find(" -- ") == -1:
-        bindgen_args = bindgen_args + " -- "
-    bindgen_args = bindgen_args + " -I{}".format(os.path.abspath(os.path.dirname(sys.argv[0])))
-    args.bindgen_args = bindgen_args
-
-    print()
-    print()
-    print("Fuzzing `bindgen` with C-Smith...")
-    print()
-    print()
-
-    iterations = 0
-    while True:
-        print("\rIteration: {}".format(iterations), end="", flush=True)
-        iterations += 1
-
-        input = NamedTemporaryFile(delete=False, prefix="input-", suffix=".h")
-        input.close()
-        result = run_logged(["csmith", "-o", input.name] + shlex.split(args.csmith_args))
-        if result.returncode != 0:
-            exit(1)
-
-        predicate_command = [
-            "./predicate.py",
-            "--bindgen-args",
-            args.bindgen_args,
-            input.name
-        ]
-        result = run_logged(predicate_command)
-
-        if result.returncode != 0:
-            print()
-            print()
-            cat(input.name, title="Failing test case: {}".format(input.name))
-            print()
-            print()
-
-            if args.creduce:
-                creduce(args, input.name, result)
-
-            print_issue_template(args, input.name, predicate_command, result)
-
-            if args.keep_going:
-                continue
-            exit(1)
-
-        os.remove(input.name)
-
-RUSTC_ERROR_REGEX = re.compile(r".*(error\[.*].*)")
-LAYOUT_TEST_FAILURE = re.compile(r".*(test bindgen_test_layout_.* \.\.\. FAILED)")
-
-def creduce(args, failing_test_case, result):
-    print()
-    print()
-    print("Reducing failing test case with `creduce`...")
-
-    match = re.search(RUSTC_ERROR_REGEX, result.stderr)
-    if match:
-        error_msg = match.group(1)
-        print("...searching for \"{}\".".format(error_msg))
-        return creduce_with_predicate_flags(
-            args,
-            failing_test_case,
-            "--bindgen-args '{}' --expect-compile-fail --rustc-grep '{}'".format(
-                args.bindgen_args,
-                re.escape(error_msg)
-            )
-        )
-
-    match = re.search(LAYOUT_TEST_FAILURE, result.stdout)
-    if match:
-        layout_failure = match.group(1)
-        struct_name = layout_failure[len("test bindgen_test_layout_"):layout_failure.rindex(" ... FAILED")]
-        print("...searching for \"{}\".".format(layout_failure))
-        return creduce_with_predicate_flags(
-            args,
-            failing_test_case,
-            "--bindgen-args '{}' --expect-layout-tests-fail --bindings-grep '{}' --layout-tests-grep '{}'".format(
-                args.bindgen_args,
-                re.escape(struct_name),
-                re.escape(layout_failure)
-            )
-        )
-
-    print("...nevermind, don't know how to `creduce` this bug. Skipping.")
-
-def creduce_with_predicate_flags(args, failing_test_case, predicate_flags):
-    predicate = """
-#!/usr/bin/env bash
-set -eu
-{} {} {}
-    """.format(
-        os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "predicate.py")),
-        predicate_flags,
-        os.path.basename(failing_test_case)
-    )
-
-    print("...and reducing with this script:")
-    print()
-    print()
-    print(predicate)
-    print()
-    print()
-
-    predicate_path = failing_test_case + ".predicate.sh"
-    with open(predicate_path, "w") as p:
-        p.write(predicate)
-    os.chmod(predicate_path, 0o755)
-
-    creduce_command = ["creduce", "--n", str(os.cpu_count()), predicate_path, failing_test_case]
-    print("Running:", creduce_command)
-    result = run(creduce_command)
-    if result.returncode == 0:
-        print()
-        print()
-        print("`creduce` reduced the failing test case to:")
-        print()
-        print()
-        cat(failing_test_case)
-        print()
-        print()
-    else:
-        print()
-        print()
-        print("`creduce` failed!")
-        if not args.keep_going:
-            sys.exit(1)
-
-def print_issue_template(args, failing_test_case, predicate_command, result):
-    test_case_contents = None
-    with open(failing_test_case, "r") as f:
-        test_case_contents = f.read()
-
-    print("""
-
-! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
-! File this issue at https://github.com/rust-lang/rust-bindgen/issues/new !
-! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
-
-   --------------- 8< --------------- 8< --------------- 8< ---------------
-
-This bug was found with `csmith` and `driver.py`.
-
-### Input Header
-
-```c
-{}
-```
-
-### `bindgen` Invocation
-
-```
-$ {}
-```
-
-### Actual Results
-
-<details>
-
-```
-{}
-```
-
-</details>
-
-### Expected Results
-
-`bindgen` emits bindings OK, then `rustc` compiles those bindings OK, then the
-compiled bindings' layout tests pass OK.
-
-   --------------- 8< --------------- 8< --------------- 8< ---------------
-
-                         <3 <3 <3 Thank you! <3 <3 <3
-    """.format(
-        test_case_contents,
-        " ".join(map(lambda s: "'{}'".format(s), predicate_command)),
-        result.stdout + result.stderr
-    ))
-
-if __name__ == "__main__":
-    try:
-        os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
-        main()
-    except KeyboardInterrupt:
-        exit()
diff --git a/csmith-fuzzing/predicate.py b/csmith-fuzzing/predicate.py
deleted file mode 100755
index 6ca50476..00000000
--- a/csmith-fuzzing/predicate.py
+++ /dev/null
@@ -1,273 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import os
-import re
-import shlex
-import subprocess
-import sys
-from tempfile import NamedTemporaryFile
-
-DESC = """
-
-Determine whether `bindgen` can successfully process a C or C++ input header.
-
-First, `bindgen` is run on the input header. Then the emitted bindings are
-compiled with `rustc`. Finally, the compiled bindings' layout tests are run.
-
-By default, this script will exit zero if all of the above steps are successful,
-and non-zero if any of them fail. This is appropriate for determining if some
-test case (perhaps generated with `csmith` or another fuzzer) uncovers any bugs
-in `bindgen`.
-
-However, this script can also be used when reducing (perhaps with `creduce`) a
-known-bad test case into a new, smaller test case that exhibits the same bad
-behavior. In this mode, you might expect that the emitted bindings fail to
-compile with `rustc`, and want to exit non-zero early if that is not the
-case. See the "reducing arguments" for details and what knobs are available.
-
-"""
-
-parser = argparse.ArgumentParser(
-    formatter_class=argparse.RawDescriptionHelpFormatter,
-    description=DESC.strip())
-
-BINDGEN_ARGS = "--with-derive-partialeq \
---with-derive-eq \
---with-derive-partialord \
---with-derive-ord \
---with-derive-hash \
---with-derive-default"
-
-parser.add_argument(
-    "--bindgen-args",
-    type=str,
-    default=BINDGEN_ARGS,
-    help="An argument string that `bindgen` should be invoked with. By default, all traits are derived. Note that the input header and output bindings file will automatically be provided by this script, and you should not manually specify them.")
-
-parser.add_argument(
-    "--save-temp-files",
-    action="store_true",
-    help="Do not delete temporary files.")
-
-parser.add_argument(
-    "input",
-    type=str,
-    default="input.h",
-    help="The input header file. Defaults to 'input.h'.")
-
-REDUCING_DESC = """
-
-Arguments that are useful when reducing known-bad test cases into
-equivalent-but-smaller test cases that exhibit the same bug with `creduce`.
-
-"""
-
-reducing = parser.add_argument_group("reducing arguments", REDUCING_DESC.strip())
-
-reducing.add_argument(
-    "--release",
-    action="store_true",
-    help="Use a release instead of a debug build.")
-reducing.add_argument(
-    "--expect-bindgen-fail",
-    action="store_true",
-    help="Exit non-zero if `bindgen` successfully emits bindings.")
-reducing.add_argument(
-    "--bindgen-grep",
-    type=str,
-    help="Exit non-zero if the given regexp pattern is not found in `bindgen`'s output.")
-reducing.add_argument(
-    "--bindings-grep",
-    type=str,
-    nargs='*',
-    help="Exit non-zero if the given regexp pattern is not found in the emitted bindings.")
-
-reducing.add_argument(
-    "--no-compile-bindings",
-    action="store_false",
-    dest="rustc",
-    help="Do not attempt to compile the emitted bindings with `rustc`.")
-reducing.add_argument(
-    "--extra-compile-file",
-    type=str,
-    help="Append the content of this extra file to the end of the emitted bindings just before compiling it.")
-reducing.add_argument(
-    "--expect-compile-fail",
-    action="store_true",
-    help="Exit non-zero if `rustc` successfully compiles the emitted bindings.")
-reducing.add_argument(
-    "--rustc-grep",
-    type=str,
-    help="Exit non-zero if the output from compiling the bindings with `rustc` does not contain the given regexp pattern")
-
-reducing.add_argument(
-    "--no-layout-tests",
-    action="store_false",
-    dest="layout_tests",
-    help="Do not run the compiled bindings' layout tests.")
-reducing.add_argument(
-    "--expect-layout-tests-fail",
-    action="store_true",
-    help="Exit non-zero if the compiled bindings' layout tests pass.")
-reducing.add_argument(
-    "--layout-tests-grep",
-    type=str,
-    help="Exit non-zero if the output of running the compiled bindings' layout tests does not contain the given regexp pattern.")
-
-################################################################################
-
-class ExitOne(Exception):
-    pass
-
-def exit_1(msg, child=None):
-    print(msg)
-
-    if child:
-        stdout = decode(child.stdout)
-        for line in stdout.splitlines():
-            sys.stdout.write("+")
-            sys.stdout.write(line)
-            sys.stdout.write("\n")
-        stderr = decode(child.stderr)
-        for line in stderr.splitlines():
-            sys.stderr.write("+")
-            sys.stderr.write(line)
-            sys.stderr.write("\n")
-
-    raise ExitOne()
-
-def main():
-    args = parser.parse_args()
-    os.environ["RUST_BACKTRACE"] = "full"
-
-    exit_code = 0
-    try:
-        bindings = new_temp_file(prefix="bindings-", suffix=".rs")
-        run_bindgen(args, bindings)
-
-        if args.rustc and not args.expect_bindgen_fail:
-            test_exe = new_temp_file(prefix="layout-tests-")
-            run_rustc(args, bindings, test_exe)
-
-            if args.layout_tests and not args.expect_compile_fail:
-                run_layout_tests(args, test_exe)
-    except ExitOne:
-        exit_code = 1
-    except Exception as e:
-        exit_code = 2
-        print("Unexpected exception:", e)
-
-    if not args.save_temp_files:
-        for path in TEMP_FILES:
-            try:
-                os.remove(path)
-            except Exception as e:
-                print("Unexpected exception:", e)
-
-    sys.exit(exit_code)
-
-def run(cmd, **kwargs):
-    print("Running:", cmd)
-    return subprocess.run(cmd, **kwargs)
-
-def decode(f):
-    return f.decode(encoding="utf-8", errors="ignore")
-
-TEMP_FILES = []
-
-def new_temp_file(prefix, suffix=None):
-    temp = NamedTemporaryFile(delete=False, prefix=prefix, suffix=suffix)
-    temp.close()
-    TEMP_FILES.append(temp.name)
-    return temp.name
-
-def contains(pattern, lines):
-    for line in lines:
-        if re.match(pattern, line):
-            return True
-    return False
-
-def regexp(pattern):
-    if not pattern.startswith("^"):
-        pattern = ".*" + pattern
-    if not pattern.endswith("$"):
-        pattern = pattern + ".*"
-    return re.compile(pattern)
-
-def run_bindgen(args, bindings):
-    manifest_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),
-                                                 "..",
-                                                 "Cargo.toml"))
-    command = ["cargo", "run", "--manifest-path", manifest_path]
-    if args.release:
-        command += ["--release"]
-    command += ["--", args.input, "-o", bindings]
-    command += shlex.split(args.bindgen_args)
-
-    child = run(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
-
-    if args.bindgen_grep:
-        pattern = regexp(args.bindgen_grep)
-        if not (contains(pattern, decode(child.stdout).splitlines()) or
-                contains(pattern, decode(child.stderr).splitlines())):
-            exit_1("Error: did not find '{}' in `bindgen`'s output".format(args.bindgen_grep), child)
-
-    if args.expect_bindgen_fail and child.returncode == 0:
-        exit_1("Error: expected running `bindgen` to fail, but it didn't", child)
-
-    if not args.expect_bindgen_fail and child.returncode != 0:
-        exit_1("Error: running `bindgen` failed", child)
-
-    for arg in args.bindings_grep or []:
-        pattern = regexp(arg)
-        with open(bindings, mode="r") as f:
-            if not contains(pattern, f):
-                print("Error: expected the emitted bindings to contain '{}', but they didn't".format(arg))
-                print("---------- {} ----------------------------------------------".format(bindings))
-                f.seek(0)
-                print(f.read())
-                raise ExitOne()
-
-def run_rustc(args, bindings, test_exe):
-    if args.extra_compile_file:
-        with open(bindings, mode="a") as outfile:
-            with open(args.extra_compile_file, mode="r") as infile:
-                outfile.write(infile.read())
-    child = run(
-        ["rustc", "--crate-type", "lib", "--test", "-o", test_exe, bindings],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE)
-
-    if args.rustc_grep:
-        pattern = regexp(args.rustc_grep)
-        if not (contains(pattern, decode(child.stdout).splitlines()) or
-                contains(pattern, decode(child.stderr).splitlines())):
-            exit_1("Error: did not find '{}' in `rustc`'s output".format(args.rustc_grep), child)
-
-    if args.expect_compile_fail and child.returncode == 0:
-        exit_1("Error: expected running `rustc` on the emitted bindings to fail, but it didn't", child)
-
-    if not args.expect_compile_fail and child.returncode != 0:
-        exit_1("Error: running `rustc` on the emitted bindings failed", child)
-
-def run_layout_tests(args, test_exe):
-    child = run(
-        [test_exe],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE)
-
-    if args.layout_tests_grep:
-        pattern = regexp(args.layout_tests_grep)
-        if not (contains(pattern, decode(child.stdout).splitlines()) or
-                contains(pattern, decode(child.stderr).splitlines())):
-            exit_1("Error: did not find '{}' in the compiled bindings' layout tests' output".format(args.layout_tests_grep), child)
-
-    if args.expect_layout_tests_fail and child.returncode == 0:
-        exit_1("Error: expected running the compiled bindings' layout tests to fail, but it didn't", child)
-
-    if not args.expect_layout_tests_fail and child.returncode != 0:
-        exit_1("Error: running the compiled bindings' layout tests failed", child)
-
-if __name__ == "__main__":
-    main()
diff --git a/src/callbacks.rs b/src/callbacks.rs
deleted file mode 100644
index 9b345449..00000000
--- a/src/callbacks.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-//! A public API for more fine-grained customization of bindgen behavior.
-
-pub use crate::ir::analysis::DeriveTrait;
-pub use crate::ir::derive::CanDerive as ImplementsTrait;
-pub use crate::ir::enum_ty::{EnumVariantCustomBehavior, EnumVariantValue};
-pub use crate::ir::int::IntKind;
-use std::fmt;
-use std::panic::UnwindSafe;
-
-/// An enum to allow ignoring parsing of macros.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum MacroParsingBehavior {
-    /// Ignore the macro, generating no code for it, or anything that depends on
-    /// it.
-    Ignore,
-    /// The default behavior bindgen would have otherwise.
-    Default,
-}
-
-impl Default for MacroParsingBehavior {
-    fn default() -> Self {
-        MacroParsingBehavior::Default
-    }
-}
-
-/// A trait to allow configuring different kinds of types in different
-/// situations.
-pub trait ParseCallbacks: fmt::Debug + UnwindSafe {
-    /// This function will be run on every macro that is identified.
-    fn will_parse_macro(&self, _name: &str) -> MacroParsingBehavior {
-        MacroParsingBehavior::Default
-    }
-
-    /// The integer kind an integer macro should have, given a name and the
-    /// value of that macro, or `None` if you want the default to be chosen.
-    fn int_macro(&self, _name: &str, _value: i64) -> Option<IntKind> {
-        None
-    }
-
-    /// This will be run on every string macro. The callback cannot influence the further
-    /// treatment of the macro, but may use the value to generate additional code or configuration.
-    fn str_macro(&self, _name: &str, _value: &[u8]) {}
-
-    /// This will be run on every function-like macro. The callback cannot
-    /// influence the further treatment of the macro, but may use the value to
-    /// generate additional code or configuration.
-    ///
-    /// The first parameter represents the name and argument list (including the
-    /// parentheses) of the function-like macro. The second parameter represents
-    /// the expansion of the macro as a sequence of tokens.
-    fn func_macro(&self, _name: &str, _value: &[&[u8]]) {}
-
-    /// This function should return whether, given an enum variant
-    /// name, and value, this enum variant will forcibly be a constant.
-    fn enum_variant_behavior(
-        &self,
-        _enum_name: Option<&str>,
-        _original_variant_name: &str,
-        _variant_value: EnumVariantValue,
-    ) -> Option<EnumVariantCustomBehavior> {
-        None
-    }
-
-    /// Allows to rename an enum variant, replacing `_original_variant_name`.
-    fn enum_variant_name(
-        &self,
-        _enum_name: Option<&str>,
-        _original_variant_name: &str,
-        _variant_value: EnumVariantValue,
-    ) -> Option<String> {
-        None
-    }
-
-    /// Allows to rename an item, replacing `_original_item_name`.
-    fn item_name(&self, _original_item_name: &str) -> Option<String> {
-        None
-    }
-
-    /// This will be called on every file inclusion, with the full path of the included file.
-    fn include_file(&self, _filename: &str) {}
-
-    /// This will be called to determine whether a particular blocklisted type
-    /// implements a trait or not. This will be used to implement traits on
-    /// other types containing the blocklisted type.
-    ///
-    /// * `None`: use the default behavior
-    /// * `Some(ImplementsTrait::Yes)`: `_name` implements `_derive_trait`
-    /// * `Some(ImplementsTrait::Manually)`: any type including `_name` can't
-    ///   derive `_derive_trait` but can implemented it manually
-    /// * `Some(ImplementsTrait::No)`: `_name` doesn't implement `_derive_trait`
-    fn blocklisted_type_implements_trait(
-        &self,
-        _name: &str,
-        _derive_trait: DeriveTrait,
-    ) -> Option<ImplementsTrait> {
-        None
-    }
-
-    /// Provide a list of custom derive attributes.
-    ///
-    /// If no additional attributes are wanted, this function should return an
-    /// empty `Vec`.
-    fn add_derives(&self, _name: &str) -> Vec<String> {
-        vec![]
-    }
-}
diff --git a/src/clang.rs b/src/clang.rs
deleted file mode 100644
index ea505c87..00000000
--- a/src/clang.rs
+++ /dev/null
@@ -1,2216 +0,0 @@
-//! A higher level Clang API built on top of the generated bindings in the
-//! `clang_sys` module.
-
-#![allow(non_upper_case_globals, dead_code)]
-
-use crate::ir::context::BindgenContext;
-use clang_sys::*;
-use std::ffi::{CStr, CString};
-use std::fmt;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong};
-use std::{mem, ptr, slice};
-
-/// Type representing a clang attribute.
-///
-/// Values of this type can be used to check for different attributes using the `has_attrs`
-/// function.
-pub struct Attribute {
-    name: &'static [u8],
-    kind: Option<CXCursorKind>,
-    token_kind: CXTokenKind,
-}
-
-impl Attribute {
-    /// A `warn_unused_result` attribute.
-    pub const MUST_USE: Self = Self {
-        name: b"warn_unused_result",
-        // FIXME(emilio): clang-sys doesn't expose `CXCursor_WarnUnusedResultAttr` (from clang 9).
-        kind: Some(440),
-        token_kind: CXToken_Identifier,
-    };
-
-    /// A `_Noreturn` attribute.
-    pub const NO_RETURN: Self = Self {
-        name: b"_Noreturn",
-        kind: None,
-        token_kind: CXToken_Keyword,
-    };
-
-    /// A `[[noreturn]]` attribute.
-    pub const NO_RETURN_CPP: Self = Self {
-        name: b"noreturn",
-        kind: None,
-        token_kind: CXToken_Identifier,
-    };
-}
-
-/// A cursor into the Clang AST, pointing to an AST node.
-///
-/// We call the AST node pointed to by the cursor the cursor's "referent".
-#[derive(Copy, Clone)]
-pub struct Cursor {
-    x: CXCursor,
-}
-
-impl fmt::Debug for Cursor {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "Cursor({} kind: {}, loc: {}, usr: {:?})",
-            self.spelling(),
-            kind_to_str(self.kind()),
-            self.location(),
-            self.usr()
-        )
-    }
-}
-
-impl Cursor {
-    /// Get the Unified Symbol Resolution for this cursor's referent, if
-    /// available.
-    ///
-    /// The USR can be used to compare entities across translation units.
-    pub fn usr(&self) -> Option<String> {
-        let s = unsafe { cxstring_into_string(clang_getCursorUSR(self.x)) };
-        if s.is_empty() {
-            None
-        } else {
-            Some(s)
-        }
-    }
-
-    /// Is this cursor's referent a declaration?
-    pub fn is_declaration(&self) -> bool {
-        unsafe { clang_isDeclaration(self.kind()) != 0 }
-    }
-
-    /// Get this cursor's referent's spelling.
-    pub fn spelling(&self) -> String {
-        unsafe { cxstring_into_string(clang_getCursorSpelling(self.x)) }
-    }
-
-    /// Get this cursor's referent's display name.
-    ///
-    /// This is not necessarily a valid identifier. It includes extra
-    /// information, such as parameters for a function, etc.
-    pub fn display_name(&self) -> String {
-        unsafe { cxstring_into_string(clang_getCursorDisplayName(self.x)) }
-    }
-
-    /// Get the mangled name of this cursor's referent.
-    pub fn mangling(&self) -> String {
-        unsafe { cxstring_into_string(clang_Cursor_getMangling(self.x)) }
-    }
-
-    /// Gets the C++ manglings for this cursor, or an error if the manglings
-    /// are not available.
-    pub fn cxx_manglings(&self) -> Result<Vec<String>, ()> {
-        use clang_sys::*;
-        unsafe {
-            let manglings = clang_Cursor_getCXXManglings(self.x);
-            if manglings.is_null() {
-                return Err(());
-            }
-            let count = (*manglings).Count as usize;
-
-            let mut result = Vec::with_capacity(count);
-            for i in 0..count {
-                let string_ptr = (*manglings).Strings.add(i);
-                result.push(cxstring_to_string_leaky(*string_ptr));
-            }
-            clang_disposeStringSet(manglings);
-            Ok(result)
-        }
-    }
-
-    /// Returns whether the cursor refers to a built-in definition.
-    pub fn is_builtin(&self) -> bool {
-        let (file, _, _, _) = self.location().location();
-        file.name().is_none()
-    }
-
-    /// Get the `Cursor` for this cursor's referent's lexical parent.
-    ///
-    /// The lexical parent is the parent of the definition. The semantic parent
-    /// is the parent of the declaration. Generally, the lexical parent doesn't
-    /// have any effect on semantics, while the semantic parent does.
-    ///
-    /// In the following snippet, the `Foo` class would be the semantic parent
-    /// of the out-of-line `method` definition, while the lexical parent is the
-    /// translation unit.
-    ///
-    /// ```c++
-    /// class Foo {
-    ///     void method();
-    /// };
-    ///
-    /// void Foo::method() { /* ... */ }
-    /// ```
-    pub fn lexical_parent(&self) -> Cursor {
-        unsafe {
-            Cursor {
-                x: clang_getCursorLexicalParent(self.x),
-            }
-        }
-    }
-
-    /// Get the referent's semantic parent, if one is available.
-    ///
-    /// See documentation for `lexical_parent` for details on semantic vs
-    /// lexical parents.
-    pub fn fallible_semantic_parent(&self) -> Option<Cursor> {
-        let sp = unsafe {
-            Cursor {
-                x: clang_getCursorSemanticParent(self.x),
-            }
-        };
-        if sp == *self || !sp.is_valid() {
-            return None;
-        }
-        Some(sp)
-    }
-
-    /// Get the referent's semantic parent.
-    ///
-    /// See documentation for `lexical_parent` for details on semantic vs
-    /// lexical parents.
-    pub fn semantic_parent(&self) -> Cursor {
-        self.fallible_semantic_parent().unwrap()
-    }
-
-    /// Return the number of template arguments used by this cursor's referent,
-    /// if the referent is either a template instantiation. Returns `None`
-    /// otherwise.
-    ///
-    /// NOTE: This may not return `Some` for partial template specializations,
-    /// see #193 and #194.
-    pub fn num_template_args(&self) -> Option<u32> {
-        // XXX: `clang_Type_getNumTemplateArguments` is sort of reliable, while
-        // `clang_Cursor_getNumTemplateArguments` is totally unreliable.
-        // Therefore, try former first, and only fallback to the latter if we
-        // have to.
-        self.cur_type()
-            .num_template_args()
-            .or_else(|| {
-                let n: c_int =
-                    unsafe { clang_Cursor_getNumTemplateArguments(self.x) };
-
-                if n >= 0 {
-                    Some(n as u32)
-                } else {
-                    debug_assert_eq!(n, -1);
-                    None
-                }
-            })
-            .or_else(|| {
-                let canonical = self.canonical();
-                if canonical != *self {
-                    canonical.num_template_args()
-                } else {
-                    None
-                }
-            })
-    }
-
-    /// Get a cursor pointing to this referent's containing translation unit.
-    ///
-    /// Note that we shouldn't create a `TranslationUnit` struct here, because
-    /// bindgen assumes there will only be one of them alive at a time, and
-    /// disposes it on drop. That can change if this would be required, but I
-    /// think we can survive fine without it.
-    pub fn translation_unit(&self) -> Cursor {
-        assert!(self.is_valid());
-        unsafe {
-            let tu = clang_Cursor_getTranslationUnit(self.x);
-            let cursor = Cursor {
-                x: clang_getTranslationUnitCursor(tu),
-            };
-            assert!(cursor.is_valid());
-            cursor
-        }
-    }
-
-    /// Is the referent a top level construct?
-    pub fn is_toplevel(&self) -> bool {
-        let mut semantic_parent = self.fallible_semantic_parent();
-
-        while semantic_parent.is_some() &&
-            (semantic_parent.unwrap().kind() == CXCursor_Namespace ||
-                semantic_parent.unwrap().kind() ==
-                    CXCursor_NamespaceAlias ||
-                semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
-        {
-            semantic_parent =
-                semantic_parent.unwrap().fallible_semantic_parent();
-        }
-
-        let tu = self.translation_unit();
-        // Yes, this can happen with, e.g., macro definitions.
-        semantic_parent == tu.fallible_semantic_parent()
-    }
-
-    /// There are a few kinds of types that we need to treat specially, mainly
-    /// not tracking the type declaration but the location of the cursor, given
-    /// clang doesn't expose a proper declaration for these types.
-    pub fn is_template_like(&self) -> bool {
-        matches!(
-            self.kind(),
-            CXCursor_ClassTemplate |
-                CXCursor_ClassTemplatePartialSpecialization |
-                CXCursor_TypeAliasTemplateDecl
-        )
-    }
-
-    /// Is this Cursor pointing to a function-like macro definition?
-    pub fn is_macro_function_like(&self) -> bool {
-        unsafe { clang_Cursor_isMacroFunctionLike(self.x) != 0 }
-    }
-
-    /// Get the kind of referent this cursor is pointing to.
-    pub fn kind(&self) -> CXCursorKind {
-        self.x.kind
-    }
-
-    /// Returns true if the cursor is a definition
-    pub fn is_definition(&self) -> bool {
-        unsafe { clang_isCursorDefinition(self.x) != 0 }
-    }
-
-    /// Is the referent a template specialization?
-    pub fn is_template_specialization(&self) -> bool {
-        self.specialized().is_some()
-    }
-
-    /// Is the referent a fully specialized template specialization without any
-    /// remaining free template arguments?
-    pub fn is_fully_specialized_template(&self) -> bool {
-        self.is_template_specialization() &&
-            self.kind() != CXCursor_ClassTemplatePartialSpecialization &&
-            self.num_template_args().unwrap_or(0) > 0
-    }
-
-    /// Is the referent a template specialization that still has remaining free
-    /// template arguments?
-    pub fn is_in_non_fully_specialized_template(&self) -> bool {
-        if self.is_toplevel() {
-            return false;
-        }
-
-        let parent = self.semantic_parent();
-        if parent.is_fully_specialized_template() {
-            return false;
-        }
-
-        if !parent.is_template_like() {
-            return parent.is_in_non_fully_specialized_template();
-        }
-
-        true
-    }
-
-    /// Is the referent any kind of template parameter?
-    pub fn is_template_parameter(&self) -> bool {
-        matches!(
-            self.kind(),
-            CXCursor_TemplateTemplateParameter |
-                CXCursor_TemplateTypeParameter |
-                CXCursor_NonTypeTemplateParameter
-        )
-    }
-
-    /// Does the referent's type or value depend on a template parameter?
-    pub fn is_dependent_on_template_parameter(&self) -> bool {
-        fn visitor(
-            found_template_parameter: &mut bool,
-            cur: Cursor,
-        ) -> CXChildVisitResult {
-            // If we found a template parameter, it is dependent.
-            if cur.is_template_parameter() {
-                *found_template_parameter = true;
-                return CXChildVisit_Break;
-            }
-
-            // Get the referent and traverse it as well.
-            if let Some(referenced) = cur.referenced() {
-                if referenced.is_template_parameter() {
-                    *found_template_parameter = true;
-                    return CXChildVisit_Break;
-                }
-
-                referenced
-                    .visit(|next| visitor(found_template_parameter, next));
-                if *found_template_parameter {
-                    return CXChildVisit_Break;
-                }
-            }
-
-            // Continue traversing the AST at the original cursor.
-            CXChildVisit_Recurse
-        }
-
-        if self.is_template_parameter() {
-            return true;
-        }
-
-        let mut found_template_parameter = false;
-        self.visit(|next| visitor(&mut found_template_parameter, next));
-
-        found_template_parameter
-    }
-
-    /// Is this cursor pointing a valid referent?
-    pub fn is_valid(&self) -> bool {
-        unsafe { clang_isInvalid(self.kind()) == 0 }
-    }
-
-    /// Get the source location for the referent.
-    pub fn location(&self) -> SourceLocation {
-        unsafe {
-            SourceLocation {
-                x: clang_getCursorLocation(self.x),
-            }
-        }
-    }
-
-    /// Get the source location range for the referent.
-    pub fn extent(&self) -> CXSourceRange {
-        unsafe { clang_getCursorExtent(self.x) }
-    }
-
-    /// Get the raw declaration comment for this referent, if one exists.
-    pub fn raw_comment(&self) -> Option<String> {
-        let s = unsafe {
-            cxstring_into_string(clang_Cursor_getRawCommentText(self.x))
-        };
-        if s.is_empty() {
-            None
-        } else {
-            Some(s)
-        }
-    }
-
-    /// Get the referent's parsed comment.
-    pub fn comment(&self) -> Comment {
-        unsafe {
-            Comment {
-                x: clang_Cursor_getParsedComment(self.x),
-            }
-        }
-    }
-
-    /// Get the referent's type.
-    pub fn cur_type(&self) -> Type {
-        unsafe {
-            Type {
-                x: clang_getCursorType(self.x),
-            }
-        }
-    }
-
-    /// Given that this cursor's referent is a reference to another type, or is
-    /// a declaration, get the cursor pointing to the referenced type or type of
-    /// the declared thing.
-    pub fn definition(&self) -> Option<Cursor> {
-        unsafe {
-            let ret = Cursor {
-                x: clang_getCursorDefinition(self.x),
-            };
-
-            if ret.is_valid() && ret.kind() != CXCursor_NoDeclFound {
-                Some(ret)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Given that this cursor's referent is reference type, get the cursor
-    /// pointing to the referenced type.
-    pub fn referenced(&self) -> Option<Cursor> {
-        unsafe {
-            let ret = Cursor {
-                x: clang_getCursorReferenced(self.x),
-            };
-
-            if ret.is_valid() {
-                Some(ret)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Get the canonical cursor for this referent.
-    ///
-    /// Many types can be declared multiple times before finally being properly
-    /// defined. This method allows us to get the canonical cursor for the
-    /// referent type.
-    pub fn canonical(&self) -> Cursor {
-        unsafe {
-            Cursor {
-                x: clang_getCanonicalCursor(self.x),
-            }
-        }
-    }
-
-    /// Given that this cursor points to either a template specialization or a
-    /// template instantiation, get a cursor pointing to the template definition
-    /// that is being specialized.
-    pub fn specialized(&self) -> Option<Cursor> {
-        unsafe {
-            let ret = Cursor {
-                x: clang_getSpecializedCursorTemplate(self.x),
-            };
-            if ret.is_valid() {
-                Some(ret)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Assuming that this cursor's referent is a template declaration, get the
-    /// kind of cursor that would be generated for its specializations.
-    pub fn template_kind(&self) -> CXCursorKind {
-        unsafe { clang_getTemplateCursorKind(self.x) }
-    }
-
-    /// Traverse this cursor's referent and its children.
-    ///
-    /// Call the given function on each AST node traversed.
-    pub fn visit<Visitor>(&self, mut visitor: Visitor)
-    where
-        Visitor: FnMut(Cursor) -> CXChildVisitResult,
-    {
-        let data = &mut visitor as *mut Visitor;
-        unsafe {
-            clang_visitChildren(self.x, visit_children::<Visitor>, data.cast());
-        }
-    }
-
-    /// Collect all of this cursor's children into a vec and return them.
-    pub fn collect_children(&self) -> Vec<Cursor> {
-        let mut children = vec![];
-        self.visit(|c| {
-            children.push(c);
-            CXChildVisit_Continue
-        });
-        children
-    }
-
-    /// Does this cursor have any children?
-    pub fn has_children(&self) -> bool {
-        let mut has_children = false;
-        self.visit(|_| {
-            has_children = true;
-            CXChildVisit_Break
-        });
-        has_children
-    }
-
-    /// Does this cursor have at least `n` children?
-    pub fn has_at_least_num_children(&self, n: usize) -> bool {
-        assert!(n > 0);
-        let mut num_left = n;
-        self.visit(|_| {
-            num_left -= 1;
-            if num_left == 0 {
-                CXChildVisit_Break
-            } else {
-                CXChildVisit_Continue
-            }
-        });
-        num_left == 0
-    }
-
-    /// Returns whether the given location contains a cursor with the given
-    /// kind in the first level of nesting underneath (doesn't look
-    /// recursively).
-    pub fn contains_cursor(&self, kind: CXCursorKind) -> bool {
-        let mut found = false;
-
-        self.visit(|c| {
-            if c.kind() == kind {
-                found = true;
-                CXChildVisit_Break
-            } else {
-                CXChildVisit_Continue
-            }
-        });
-
-        found
-    }
-
-    /// Is the referent an inlined function?
-    pub fn is_inlined_function(&self) -> bool {
-        unsafe { clang_Cursor_isFunctionInlined(self.x) != 0 }
-    }
-
-    /// Is the referent a defaulted function?
-    pub fn is_defaulted_function(&self) -> bool {
-        unsafe { clang_CXXMethod_isDefaulted(self.x) != 0 }
-    }
-
-    /// Is the referent a deleted function?
-    pub fn is_deleted_function(&self) -> bool {
-        // Unfortunately, libclang doesn't yet have an API for checking if a
-        // member function is deleted, but the following should be a good
-        // enough approximation.
-        // Deleted functions are implicitly inline according to paragraph 4 of
-        // [dcl.fct.def.delete] in the C++ standard. Normal inline functions
-        // have a definition in the same translation unit, so if this is an
-        // inline function without a definition, and it's not a defaulted
-        // function, we can reasonably safely conclude that it's a deleted
-        // function.
-        self.is_inlined_function() &&
-            self.definition().is_none() &&
-            !self.is_defaulted_function()
-    }
-
-    /// Is the referent a bit field declaration?
-    pub fn is_bit_field(&self) -> bool {
-        unsafe { clang_Cursor_isBitField(self.x) != 0 }
-    }
-
-    /// Get a cursor to the bit field's width expression, or `None` if it's not
-    /// a bit field.
-    pub fn bit_width_expr(&self) -> Option<Cursor> {
-        if !self.is_bit_field() {
-            return None;
-        }
-
-        let mut result = None;
-        self.visit(|cur| {
-            // The first child may or may not be a TypeRef, depending on whether
-            // the field's type is builtin. Skip it.
-            if cur.kind() == CXCursor_TypeRef {
-                return CXChildVisit_Continue;
-            }
-
-            // The next expression or literal is the bit width.
-            result = Some(cur);
-
-            CXChildVisit_Break
-        });
-
-        result
-    }
-
-    /// Get the width of this cursor's referent bit field, or `None` if the
-    /// referent is not a bit field or if the width could not be evaluated.
-    pub fn bit_width(&self) -> Option<u32> {
-        // It is not safe to check the bit width without ensuring it doesn't
-        // depend on a template parameter. See
-        // https://github.com/rust-lang/rust-bindgen/issues/2239
-        if self.bit_width_expr()?.is_dependent_on_template_parameter() {
-            return None;
-        }
-
-        unsafe {
-            let w = clang_getFieldDeclBitWidth(self.x);
-            if w == -1 {
-                None
-            } else {
-                Some(w as u32)
-            }
-        }
-    }
-
-    /// Get the integer representation type used to hold this cursor's referent
-    /// enum type.
-    pub fn enum_type(&self) -> Option<Type> {
-        unsafe {
-            let t = Type {
-                x: clang_getEnumDeclIntegerType(self.x),
-            };
-            if t.is_valid() {
-                Some(t)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Get the boolean constant value for this cursor's enum variant referent.
-    ///
-    /// Returns None if the cursor's referent is not an enum variant.
-    pub fn enum_val_boolean(&self) -> Option<bool> {
-        unsafe {
-            if self.kind() == CXCursor_EnumConstantDecl {
-                Some(clang_getEnumConstantDeclValue(self.x) != 0)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Get the signed constant value for this cursor's enum variant referent.
-    ///
-    /// Returns None if the cursor's referent is not an enum variant.
-    pub fn enum_val_signed(&self) -> Option<i64> {
-        unsafe {
-            if self.kind() == CXCursor_EnumConstantDecl {
-                Some(clang_getEnumConstantDeclValue(self.x) as i64)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Get the unsigned constant value for this cursor's enum variant referent.
-    ///
-    /// Returns None if the cursor's referent is not an enum variant.
-    pub fn enum_val_unsigned(&self) -> Option<u64> {
-        unsafe {
-            if self.kind() == CXCursor_EnumConstantDecl {
-                Some(clang_getEnumConstantDeclUnsignedValue(self.x) as u64)
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Does this cursor have the given attributes?
-    pub fn has_attrs<const N: usize>(
-        &self,
-        attrs: &[Attribute; N],
-    ) -> [bool; N] {
-        let mut found_attrs = [false; N];
-        let mut found_count = 0;
-
-        self.visit(|cur| {
-            let kind = cur.kind();
-            for (idx, attr) in attrs.iter().enumerate() {
-                let found_attr = &mut found_attrs[idx];
-                if !*found_attr {
-                    // `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
-                    if attr.kind.map_or(false, |k| k == kind) ||
-                        (kind == CXCursor_UnexposedAttr &&
-                            cur.tokens().iter().any(|t| {
-                                t.kind == attr.token_kind &&
-                                    t.spelling() == attr.name
-                            }))
-                    {
-                        *found_attr = true;
-                        found_count += 1;
-
-                        if found_count == N {
-                            return CXChildVisit_Break;
-                        }
-                    }
-                }
-            }
-
-            CXChildVisit_Continue
-        });
-
-        found_attrs
-    }
-
-    /// Given that this cursor's referent is a `typedef`, get the `Type` that is
-    /// being aliased.
-    pub fn typedef_type(&self) -> Option<Type> {
-        let inner = Type {
-            x: unsafe { clang_getTypedefDeclUnderlyingType(self.x) },
-        };
-
-        if inner.is_valid() {
-            Some(inner)
-        } else {
-            None
-        }
-    }
-
-    /// Get the linkage kind for this cursor's referent.
-    ///
-    /// This only applies to functions and variables.
-    pub fn linkage(&self) -> CXLinkageKind {
-        unsafe { clang_getCursorLinkage(self.x) }
-    }
-
-    /// Get the visibility of this cursor's referent.
-    pub fn visibility(&self) -> CXVisibilityKind {
-        unsafe { clang_getCursorVisibility(self.x) }
-    }
-
-    /// Given that this cursor's referent is a function, return cursors to its
-    /// parameters.
-    ///
-    /// Returns None if the cursor's referent is not a function/method call or
-    /// declaration.
-    pub fn args(&self) -> Option<Vec<Cursor>> {
-        // match self.kind() {
-        // CXCursor_FunctionDecl |
-        // CXCursor_CXXMethod => {
-        self.num_args().ok().map(|num| {
-            (0..num)
-                .map(|i| Cursor {
-                    x: unsafe { clang_Cursor_getArgument(self.x, i as c_uint) },
-                })
-                .collect()
-        })
-    }
-
-    /// Given that this cursor's referent is a function/method call or
-    /// declaration, return the number of arguments it takes.
-    ///
-    /// Returns Err if the cursor's referent is not a function/method call or
-    /// declaration.
-    pub fn num_args(&self) -> Result<u32, ()> {
-        unsafe {
-            let w = clang_Cursor_getNumArguments(self.x);
-            if w == -1 {
-                Err(())
-            } else {
-                Ok(w as u32)
-            }
-        }
-    }
-
-    /// Get the access specifier for this cursor's referent.
-    pub fn access_specifier(&self) -> CX_CXXAccessSpecifier {
-        unsafe { clang_getCXXAccessSpecifier(self.x) }
-    }
-
-    /// Is the cursor's referrent publically accessible in C++?
-    ///
-    /// Returns true if self.access_specifier() is `CX_CXXPublic` or
-    /// `CX_CXXInvalidAccessSpecifier`.
-    pub fn public_accessible(&self) -> bool {
-        let access = self.access_specifier();
-        access == CX_CXXPublic || access == CX_CXXInvalidAccessSpecifier
-    }
-
-    /// Is this cursor's referent a field declaration that is marked as
-    /// `mutable`?
-    pub fn is_mutable_field(&self) -> bool {
-        unsafe { clang_CXXField_isMutable(self.x) != 0 }
-    }
-
-    /// Get the offset of the field represented by the Cursor.
-    pub fn offset_of_field(&self) -> Result<usize, LayoutError> {
-        let offset = unsafe { clang_Cursor_getOffsetOfField(self.x) };
-
-        if offset < 0 {
-            Err(LayoutError::from(offset as i32))
-        } else {
-            Ok(offset as usize)
-        }
-    }
-
-    /// Is this cursor's referent a member function that is declared `static`?
-    pub fn method_is_static(&self) -> bool {
-        unsafe { clang_CXXMethod_isStatic(self.x) != 0 }
-    }
-
-    /// Is this cursor's referent a member function that is declared `const`?
-    pub fn method_is_const(&self) -> bool {
-        unsafe { clang_CXXMethod_isConst(self.x) != 0 }
-    }
-
-    /// Is this cursor's referent a member function that is virtual?
-    pub fn method_is_virtual(&self) -> bool {
-        unsafe { clang_CXXMethod_isVirtual(self.x) != 0 }
-    }
-
-    /// Is this cursor's referent a member function that is pure virtual?
-    pub fn method_is_pure_virtual(&self) -> bool {
-        unsafe { clang_CXXMethod_isPureVirtual(self.x) != 0 }
-    }
-
-    /// Is this cursor's referent a struct or class with virtual members?
-    pub fn is_virtual_base(&self) -> bool {
-        unsafe { clang_isVirtualBase(self.x) != 0 }
-    }
-
-    /// Try to evaluate this cursor.
-    pub fn evaluate(&self) -> Option<EvalResult> {
-        EvalResult::new(*self)
-    }
-
-    /// Return the result type for this cursor
-    pub fn ret_type(&self) -> Option<Type> {
-        let rt = Type {
-            x: unsafe { clang_getCursorResultType(self.x) },
-        };
-        if rt.is_valid() {
-            Some(rt)
-        } else {
-            None
-        }
-    }
-
-    /// Gets the tokens that correspond to that cursor.
-    pub fn tokens(&self) -> RawTokens {
-        RawTokens::new(self)
-    }
-
-    /// Gets the tokens that correspond to that cursor as  `cexpr` tokens.
-    pub fn cexpr_tokens(self) -> Vec<cexpr::token::Token> {
-        self.tokens()
-            .iter()
-            .filter_map(|token| token.as_cexpr_token())
-            .collect()
-    }
-
-    /// Obtain the real path name of a cursor of InclusionDirective kind.
-    ///
-    /// Returns None if the cursor does not include a file, otherwise the file's full name
-    pub fn get_included_file_name(&self) -> Option<String> {
-        let file = unsafe { clang_sys::clang_getIncludedFile(self.x) };
-        if file.is_null() {
-            None
-        } else {
-            Some(unsafe {
-                cxstring_into_string(clang_sys::clang_getFileName(file))
-            })
-        }
-    }
-}
-
-/// A struct that owns the tokenizer result from a given cursor.
-pub struct RawTokens<'a> {
-    cursor: &'a Cursor,
-    tu: CXTranslationUnit,
-    tokens: *mut CXToken,
-    token_count: c_uint,
-}
-
-impl<'a> RawTokens<'a> {
-    fn new(cursor: &'a Cursor) -> Self {
-        let mut tokens = ptr::null_mut();
-        let mut token_count = 0;
-        let range = cursor.extent();
-        let tu = unsafe { clang_Cursor_getTranslationUnit(cursor.x) };
-        unsafe { clang_tokenize(tu, range, &mut tokens, &mut token_count) };
-        Self {
-            cursor,
-            tu,
-            tokens,
-            token_count,
-        }
-    }
-
-    fn as_slice(&self) -> &[CXToken] {
-        if self.tokens.is_null() {
-            return &[];
-        }
-        unsafe { slice::from_raw_parts(self.tokens, self.token_count as usize) }
-    }
-
-    /// Get an iterator over these tokens.
-    pub fn iter(&self) -> ClangTokenIterator {
-        ClangTokenIterator {
-            tu: self.tu,
-            raw: self.as_slice().iter(),
-        }
-    }
-}
-
-impl<'a> Drop for RawTokens<'a> {
-    fn drop(&mut self) {
-        if !self.tokens.is_null() {
-            unsafe {
-                clang_disposeTokens(
-                    self.tu,
-                    self.tokens,
-                    self.token_count as c_uint,
-                );
-            }
-        }
-    }
-}
-
-/// A raw clang token, that exposes only kind, spelling, and extent. This is a
-/// slightly more convenient version of `CXToken` which owns the spelling
-/// string and extent.
-#[derive(Debug)]
-pub struct ClangToken {
-    spelling: CXString,
-    /// The extent of the token. This is the same as the relevant member from
-    /// `CXToken`.
-    pub extent: CXSourceRange,
-    /// The kind of the token. This is the same as the relevant member from
-    /// `CXToken`.
-    pub kind: CXTokenKind,
-}
-
-impl ClangToken {
-    /// Get the token spelling, without being converted to utf-8.
-    pub fn spelling(&self) -> &[u8] {
-        let c_str = unsafe {
-            CStr::from_ptr(clang_getCString(self.spelling) as *const _)
-        };
-        c_str.to_bytes()
-    }
-
-    /// Converts a ClangToken to a `cexpr` token if possible.
-    pub fn as_cexpr_token(&self) -> Option<cexpr::token::Token> {
-        use cexpr::token;
-
-        let kind = match self.kind {
-            CXToken_Punctuation => token::Kind::Punctuation,
-            CXToken_Literal => token::Kind::Literal,
-            CXToken_Identifier => token::Kind::Identifier,
-            CXToken_Keyword => token::Kind::Keyword,
-            // NB: cexpr is not too happy about comments inside
-            // expressions, so we strip them down here.
-            CXToken_Comment => return None,
-            _ => {
-                warn!("Found unexpected token kind: {:?}", self);
-                return None;
-            }
-        };
-
-        Some(token::Token {
-            kind,
-            raw: self.spelling().to_vec().into_boxed_slice(),
-        })
-    }
-}
-
-impl Drop for ClangToken {
-    fn drop(&mut self) {
-        unsafe { clang_disposeString(self.spelling) }
-    }
-}
-
-/// An iterator over a set of Tokens.
-pub struct ClangTokenIterator<'a> {
-    tu: CXTranslationUnit,
-    raw: slice::Iter<'a, CXToken>,
-}
-
-impl<'a> Iterator for ClangTokenIterator<'a> {
-    type Item = ClangToken;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let raw = self.raw.next()?;
-        unsafe {
-            let kind = clang_getTokenKind(*raw);
-            let spelling = clang_getTokenSpelling(self.tu, *raw);
-            let extent = clang_getTokenExtent(self.tu, *raw);
-            Some(ClangToken {
-                kind,
-                extent,
-                spelling,
-            })
-        }
-    }
-}
-
-/// Checks whether the name looks like an identifier, i.e. is alphanumeric
-/// (including '_') and does not start with a digit.
-pub fn is_valid_identifier(name: &str) -> bool {
-    let mut chars = name.chars();
-    let first_valid = chars
-        .next()
-        .map(|c| c.is_alphabetic() || c == '_')
-        .unwrap_or(false);
-
-    first_valid && chars.all(|c| c.is_alphanumeric() || c == '_')
-}
-
-extern "C" fn visit_children<Visitor>(
-    cur: CXCursor,
-    _parent: CXCursor,
-    data: CXClientData,
-) -> CXChildVisitResult
-where
-    Visitor: FnMut(Cursor) -> CXChildVisitResult,
-{
-    let func: &mut Visitor = unsafe { &mut *(data as *mut Visitor) };
-    let child = Cursor { x: cur };
-
-    (*func)(child)
-}
-
-impl PartialEq for Cursor {
-    fn eq(&self, other: &Cursor) -> bool {
-        unsafe { clang_equalCursors(self.x, other.x) == 1 }
-    }
-}
-
-impl Eq for Cursor {}
-
-impl Hash for Cursor {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        unsafe { clang_hashCursor(self.x) }.hash(state)
-    }
-}
-
-/// The type of a node in clang's AST.
-#[derive(Clone, Copy)]
-pub struct Type {
-    x: CXType,
-}
-
-impl PartialEq for Type {
-    fn eq(&self, other: &Self) -> bool {
-        unsafe { clang_equalTypes(self.x, other.x) != 0 }
-    }
-}
-
-impl Eq for Type {}
-
-impl fmt::Debug for Type {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "Type({}, kind: {}, cconv: {}, decl: {:?}, canon: {:?})",
-            self.spelling(),
-            type_to_str(self.kind()),
-            self.call_conv(),
-            self.declaration(),
-            self.declaration().canonical()
-        )
-    }
-}
-
-/// An error about the layout of a struct, class, or type.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum LayoutError {
-    /// Asked for the layout of an invalid type.
-    Invalid,
-    /// Asked for the layout of an incomplete type.
-    Incomplete,
-    /// Asked for the layout of a dependent type.
-    Dependent,
-    /// Asked for the layout of a type that does not have constant size.
-    NotConstantSize,
-    /// Asked for the layout of a field in a type that does not have such a
-    /// field.
-    InvalidFieldName,
-    /// An unknown layout error.
-    Unknown,
-}
-
-impl ::std::convert::From<i32> for LayoutError {
-    fn from(val: i32) -> Self {
-        use self::LayoutError::*;
-
-        match val {
-            CXTypeLayoutError_Invalid => Invalid,
-            CXTypeLayoutError_Incomplete => Incomplete,
-            CXTypeLayoutError_Dependent => Dependent,
-            CXTypeLayoutError_NotConstantSize => NotConstantSize,
-            CXTypeLayoutError_InvalidFieldName => InvalidFieldName,
-            _ => Unknown,
-        }
-    }
-}
-
-impl Type {
-    /// Get this type's kind.
-    pub fn kind(&self) -> CXTypeKind {
-        self.x.kind
-    }
-
-    /// Get a cursor pointing to this type's declaration.
-    pub fn declaration(&self) -> Cursor {
-        unsafe {
-            Cursor {
-                x: clang_getTypeDeclaration(self.x),
-            }
-        }
-    }
-
-    /// Get the canonical declaration of this type, if it is available.
-    pub fn canonical_declaration(
-        &self,
-        location: Option<&Cursor>,
-    ) -> Option<CanonicalTypeDeclaration> {
-        let mut declaration = self.declaration();
-        if !declaration.is_valid() {
-            if let Some(location) = location {
-                let mut location = *location;
-                if let Some(referenced) = location.referenced() {
-                    location = referenced;
-                }
-                if location.is_template_like() {
-                    declaration = location;
-                }
-            }
-        }
-
-        let canonical = declaration.canonical();
-        if canonical.is_valid() && canonical.kind() != CXCursor_NoDeclFound {
-            Some(CanonicalTypeDeclaration(*self, canonical))
-        } else {
-            None
-        }
-    }
-
-    /// Get a raw display name for this type.
-    pub fn spelling(&self) -> String {
-        let s = unsafe { cxstring_into_string(clang_getTypeSpelling(self.x)) };
-        // Clang 5.0 introduced changes in the spelling API so it returned the
-        // full qualified name. Let's undo that here.
-        if s.split("::").all(is_valid_identifier) {
-            if let Some(s) = s.split("::").last() {
-                return s.to_owned();
-            }
-        }
-
-        s
-    }
-
-    /// Is this type const qualified?
-    pub fn is_const(&self) -> bool {
-        unsafe { clang_isConstQualifiedType(self.x) != 0 }
-    }
-
-    #[inline]
-    fn is_non_deductible_auto_type(&self) -> bool {
-        debug_assert_eq!(self.kind(), CXType_Auto);
-        self.canonical_type() == *self
-    }
-
-    #[inline]
-    fn clang_size_of(&self, ctx: &BindgenContext) -> c_longlong {
-        match self.kind() {
-            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
-            CXType_RValueReference | CXType_LValueReference => {
-                ctx.target_pointer_size() as c_longlong
-            }
-            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
-            CXType_Auto if self.is_non_deductible_auto_type() => -6,
-            _ => unsafe { clang_Type_getSizeOf(self.x) },
-        }
-    }
-
-    #[inline]
-    fn clang_align_of(&self, ctx: &BindgenContext) -> c_longlong {
-        match self.kind() {
-            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
-            CXType_RValueReference | CXType_LValueReference => {
-                ctx.target_pointer_size() as c_longlong
-            }
-            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
-            CXType_Auto if self.is_non_deductible_auto_type() => -6,
-            _ => unsafe { clang_Type_getAlignOf(self.x) },
-        }
-    }
-
-    /// What is the size of this type? Paper over invalid types by returning `0`
-    /// for them.
-    pub fn size(&self, ctx: &BindgenContext) -> usize {
-        let val = self.clang_size_of(ctx);
-        if val < 0 {
-            0
-        } else {
-            val as usize
-        }
-    }
-
-    /// What is the size of this type?
-    pub fn fallible_size(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Result<usize, LayoutError> {
-        let val = self.clang_size_of(ctx);
-        if val < 0 {
-            Err(LayoutError::from(val as i32))
-        } else {
-            Ok(val as usize)
-        }
-    }
-
-    /// What is the alignment of this type? Paper over invalid types by
-    /// returning `0`.
-    pub fn align(&self, ctx: &BindgenContext) -> usize {
-        let val = self.clang_align_of(ctx);
-        if val < 0 {
-            0
-        } else {
-            val as usize
-        }
-    }
-
-    /// What is the alignment of this type?
-    pub fn fallible_align(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Result<usize, LayoutError> {
-        let val = self.clang_align_of(ctx);
-        if val < 0 {
-            Err(LayoutError::from(val as i32))
-        } else {
-            Ok(val as usize)
-        }
-    }
-
-    /// Get the layout for this type, or an error describing why it does not
-    /// have a valid layout.
-    pub fn fallible_layout(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Result<crate::ir::layout::Layout, LayoutError> {
-        use crate::ir::layout::Layout;
-        let size = self.fallible_size(ctx)?;
-        let align = self.fallible_align(ctx)?;
-        Ok(Layout::new(size, align))
-    }
-
-    /// Get the number of template arguments this type has, or `None` if it is
-    /// not some kind of template.
-    pub fn num_template_args(&self) -> Option<u32> {
-        let n = unsafe { clang_Type_getNumTemplateArguments(self.x) };
-        if n >= 0 {
-            Some(n as u32)
-        } else {
-            debug_assert_eq!(n, -1);
-            None
-        }
-    }
-
-    /// If this type is a class template specialization, return its
-    /// template arguments. Otherwise, return None.
-    pub fn template_args(&self) -> Option<TypeTemplateArgIterator> {
-        self.num_template_args().map(|n| TypeTemplateArgIterator {
-            x: self.x,
-            length: n,
-            index: 0,
-        })
-    }
-
-    /// Given that this type is a function prototype, return the types of its parameters.
-    ///
-    /// Returns None if the type is not a function prototype.
-    pub fn args(&self) -> Option<Vec<Type>> {
-        self.num_args().ok().map(|num| {
-            (0..num)
-                .map(|i| Type {
-                    x: unsafe { clang_getArgType(self.x, i as c_uint) },
-                })
-                .collect()
-        })
-    }
-
-    /// Given that this type is a function prototype, return the number of arguments it takes.
-    ///
-    /// Returns Err if the type is not a function prototype.
-    pub fn num_args(&self) -> Result<u32, ()> {
-        unsafe {
-            let w = clang_getNumArgTypes(self.x);
-            if w == -1 {
-                Err(())
-            } else {
-                Ok(w as u32)
-            }
-        }
-    }
-
-    /// Given that this type is a pointer type, return the type that it points
-    /// to.
-    pub fn pointee_type(&self) -> Option<Type> {
-        match self.kind() {
-            CXType_Pointer |
-            CXType_RValueReference |
-            CXType_LValueReference |
-            CXType_MemberPointer |
-            CXType_BlockPointer |
-            CXType_ObjCObjectPointer => {
-                let ret = Type {
-                    x: unsafe { clang_getPointeeType(self.x) },
-                };
-                debug_assert!(ret.is_valid());
-                Some(ret)
-            }
-            _ => None,
-        }
-    }
-
-    /// Given that this type is an array, vector, or complex type, return the
-    /// type of its elements.
-    pub fn elem_type(&self) -> Option<Type> {
-        let current_type = Type {
-            x: unsafe { clang_getElementType(self.x) },
-        };
-        if current_type.is_valid() {
-            Some(current_type)
-        } else {
-            None
-        }
-    }
-
-    /// Given that this type is an array or vector type, return its number of
-    /// elements.
-    pub fn num_elements(&self) -> Option<usize> {
-        let num_elements_returned = unsafe { clang_getNumElements(self.x) };
-        if num_elements_returned != -1 {
-            Some(num_elements_returned as usize)
-        } else {
-            None
-        }
-    }
-
-    /// Get the canonical version of this type. This sees through `typedef`s and
-    /// aliases to get the underlying, canonical type.
-    pub fn canonical_type(&self) -> Type {
-        unsafe {
-            Type {
-                x: clang_getCanonicalType(self.x),
-            }
-        }
-    }
-
-    /// Is this type a variadic function type?
-    pub fn is_variadic(&self) -> bool {
-        unsafe { clang_isFunctionTypeVariadic(self.x) != 0 }
-    }
-
-    /// Given that this type is a function type, get the type of its return
-    /// value.
-    pub fn ret_type(&self) -> Option<Type> {
-        let rt = Type {
-            x: unsafe { clang_getResultType(self.x) },
-        };
-        if rt.is_valid() {
-            Some(rt)
-        } else {
-            None
-        }
-    }
-
-    /// Given that this type is a function type, get its calling convention. If
-    /// this is not a function type, `CXCallingConv_Invalid` is returned.
-    pub fn call_conv(&self) -> CXCallingConv {
-        unsafe { clang_getFunctionTypeCallingConv(self.x) }
-    }
-
-    /// For elaborated types (types which use `class`, `struct`, or `union` to
-    /// disambiguate types from local bindings), get the underlying type.
-    pub fn named(&self) -> Type {
-        unsafe {
-            Type {
-                x: clang_Type_getNamedType(self.x),
-            }
-        }
-    }
-
-    /// Is this a valid type?
-    pub fn is_valid(&self) -> bool {
-        self.kind() != CXType_Invalid
-    }
-
-    /// Is this a valid and exposed type?
-    pub fn is_valid_and_exposed(&self) -> bool {
-        self.is_valid() && self.kind() != CXType_Unexposed
-    }
-
-    /// Is this type a fully instantiated template?
-    pub fn is_fully_instantiated_template(&self) -> bool {
-        // Yep, the spelling of this containing type-parameter is extremely
-        // nasty... But can happen in <type_traits>. Unfortunately I couldn't
-        // reduce it enough :(
-        self.template_args().map_or(false, |args| args.len() > 0) &&
-            !matches!(
-                self.declaration().kind(),
-                CXCursor_ClassTemplatePartialSpecialization |
-                    CXCursor_TypeAliasTemplateDecl |
-                    CXCursor_TemplateTemplateParameter
-            )
-    }
-
-    /// Is this type an associated template type? Eg `T::Associated` in
-    /// this example:
-    ///
-    /// ```c++
-    /// template <typename T>
-    /// class Foo {
-    ///     typename T::Associated member;
-    /// };
-    /// ```
-    pub fn is_associated_type(&self) -> bool {
-        // This is terrible :(
-        fn hacky_parse_associated_type<S: AsRef<str>>(spelling: S) -> bool {
-            lazy_static! {
-                static ref ASSOC_TYPE_RE: regex::Regex = regex::Regex::new(
-                    r"typename type\-parameter\-\d+\-\d+::.+"
-                )
-                .unwrap();
-            }
-            ASSOC_TYPE_RE.is_match(spelling.as_ref())
-        }
-
-        self.kind() == CXType_Unexposed &&
-            (hacky_parse_associated_type(self.spelling()) ||
-                hacky_parse_associated_type(
-                    self.canonical_type().spelling(),
-                ))
-    }
-}
-
-/// The `CanonicalTypeDeclaration` type exists as proof-by-construction that its
-/// cursor is the canonical declaration for its type. If you have a
-/// `CanonicalTypeDeclaration` instance, you know for sure that the type and
-/// cursor match up in a canonical declaration relationship, and it simply
-/// cannot be otherwise.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct CanonicalTypeDeclaration(Type, Cursor);
-
-impl CanonicalTypeDeclaration {
-    /// Get the type.
-    pub fn ty(&self) -> &Type {
-        &self.0
-    }
-
-    /// Get the type's canonical declaration cursor.
-    pub fn cursor(&self) -> &Cursor {
-        &self.1
-    }
-}
-
-/// An iterator for a type's template arguments.
-pub struct TypeTemplateArgIterator {
-    x: CXType,
-    length: u32,
-    index: u32,
-}
-
-impl Iterator for TypeTemplateArgIterator {
-    type Item = Type;
-    fn next(&mut self) -> Option<Type> {
-        if self.index < self.length {
-            let idx = self.index as c_uint;
-            self.index += 1;
-            Some(Type {
-                x: unsafe { clang_Type_getTemplateArgumentAsType(self.x, idx) },
-            })
-        } else {
-            None
-        }
-    }
-}
-
-impl ExactSizeIterator for TypeTemplateArgIterator {
-    fn len(&self) -> usize {
-        assert!(self.index <= self.length);
-        (self.length - self.index) as usize
-    }
-}
-
-/// A `SourceLocation` is a file, line, column, and byte offset location for
-/// some source text.
-pub struct SourceLocation {
-    x: CXSourceLocation,
-}
-
-impl SourceLocation {
-    /// Get the (file, line, column, byte offset) tuple for this source
-    /// location.
-    pub fn location(&self) -> (File, usize, usize, usize) {
-        unsafe {
-            let mut file = mem::zeroed();
-            let mut line = 0;
-            let mut col = 0;
-            let mut off = 0;
-            clang_getSpellingLocation(
-                self.x, &mut file, &mut line, &mut col, &mut off,
-            );
-            (File { x: file }, line as usize, col as usize, off as usize)
-        }
-    }
-}
-
-impl fmt::Display for SourceLocation {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let (file, line, col, _) = self.location();
-        if let Some(name) = file.name() {
-            write!(f, "{}:{}:{}", name, line, col)
-        } else {
-            "builtin definitions".fmt(f)
-        }
-    }
-}
-
-impl fmt::Debug for SourceLocation {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self)
-    }
-}
-
-/// A comment in the source text.
-///
-/// Comments are sort of parsed by Clang, and have a tree structure.
-pub struct Comment {
-    x: CXComment,
-}
-
-impl Comment {
-    /// What kind of comment is this?
-    pub fn kind(&self) -> CXCommentKind {
-        unsafe { clang_Comment_getKind(self.x) }
-    }
-
-    /// Get this comment's children comment
-    pub fn get_children(&self) -> CommentChildrenIterator {
-        CommentChildrenIterator {
-            parent: self.x,
-            length: unsafe { clang_Comment_getNumChildren(self.x) },
-            index: 0,
-        }
-    }
-
-    /// Given that this comment is the start or end of an HTML tag, get its tag
-    /// name.
-    pub fn get_tag_name(&self) -> String {
-        unsafe { cxstring_into_string(clang_HTMLTagComment_getTagName(self.x)) }
-    }
-
-    /// Given that this comment is an HTML start tag, get its attributes.
-    pub fn get_tag_attrs(&self) -> CommentAttributesIterator {
-        CommentAttributesIterator {
-            x: self.x,
-            length: unsafe { clang_HTMLStartTag_getNumAttrs(self.x) },
-            index: 0,
-        }
-    }
-}
-
-/// An iterator for a comment's children
-pub struct CommentChildrenIterator {
-    parent: CXComment,
-    length: c_uint,
-    index: c_uint,
-}
-
-impl Iterator for CommentChildrenIterator {
-    type Item = Comment;
-    fn next(&mut self) -> Option<Comment> {
-        if self.index < self.length {
-            let idx = self.index;
-            self.index += 1;
-            Some(Comment {
-                x: unsafe { clang_Comment_getChild(self.parent, idx) },
-            })
-        } else {
-            None
-        }
-    }
-}
-
-/// An HTML start tag comment attribute
-pub struct CommentAttribute {
-    /// HTML start tag attribute name
-    pub name: String,
-    /// HTML start tag attribute value
-    pub value: String,
-}
-
-/// An iterator for a comment's attributes
-pub struct CommentAttributesIterator {
-    x: CXComment,
-    length: c_uint,
-    index: c_uint,
-}
-
-impl Iterator for CommentAttributesIterator {
-    type Item = CommentAttribute;
-    fn next(&mut self) -> Option<CommentAttribute> {
-        if self.index < self.length {
-            let idx = self.index;
-            self.index += 1;
-            Some(CommentAttribute {
-                name: unsafe {
-                    cxstring_into_string(clang_HTMLStartTag_getAttrName(
-                        self.x, idx,
-                    ))
-                },
-                value: unsafe {
-                    cxstring_into_string(clang_HTMLStartTag_getAttrValue(
-                        self.x, idx,
-                    ))
-                },
-            })
-        } else {
-            None
-        }
-    }
-}
-
-/// A source file.
-pub struct File {
-    x: CXFile,
-}
-
-impl File {
-    /// Get the name of this source file.
-    pub fn name(&self) -> Option<String> {
-        if self.x.is_null() {
-            return None;
-        }
-        Some(unsafe { cxstring_into_string(clang_getFileName(self.x)) })
-    }
-}
-
-fn cxstring_to_string_leaky(s: CXString) -> String {
-    if s.data.is_null() {
-        return "".to_owned();
-    }
-    let c_str = unsafe { CStr::from_ptr(clang_getCString(s) as *const _) };
-    c_str.to_string_lossy().into_owned()
-}
-
-fn cxstring_into_string(s: CXString) -> String {
-    let ret = cxstring_to_string_leaky(s);
-    unsafe { clang_disposeString(s) };
-    ret
-}
-
-/// An `Index` is an environment for a set of translation units that will
-/// typically end up linked together in one final binary.
-pub struct Index {
-    x: CXIndex,
-}
-
-impl Index {
-    /// Construct a new `Index`.
-    ///
-    /// The `pch` parameter controls whether declarations in pre-compiled
-    /// headers are included when enumerating a translation unit's "locals".
-    ///
-    /// The `diag` parameter controls whether debugging diagnostics are enabled.
-    pub fn new(pch: bool, diag: bool) -> Index {
-        unsafe {
-            Index {
-                x: clang_createIndex(pch as c_int, diag as c_int),
-            }
-        }
-    }
-}
-
-impl fmt::Debug for Index {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "Index {{ }}")
-    }
-}
-
-impl Drop for Index {
-    fn drop(&mut self) {
-        unsafe {
-            clang_disposeIndex(self.x);
-        }
-    }
-}
-
-/// A translation unit (or "compilation unit").
-pub struct TranslationUnit {
-    x: CXTranslationUnit,
-}
-
-impl fmt::Debug for TranslationUnit {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "TranslationUnit {{ }}")
-    }
-}
-
-impl TranslationUnit {
-    /// Parse a source file into a translation unit.
-    pub fn parse(
-        ix: &Index,
-        file: &str,
-        cmd_args: &[String],
-        unsaved: &[UnsavedFile],
-        opts: CXTranslationUnit_Flags,
-    ) -> Option<TranslationUnit> {
-        let fname = CString::new(file).unwrap();
-        let _c_args: Vec<CString> = cmd_args
-            .iter()
-            .map(|s| CString::new(s.clone()).unwrap())
-            .collect();
-        let c_args: Vec<*const c_char> =
-            _c_args.iter().map(|s| s.as_ptr()).collect();
-        let mut c_unsaved: Vec<CXUnsavedFile> =
-            unsaved.iter().map(|f| f.x).collect();
-        let tu = unsafe {
-            clang_parseTranslationUnit(
-                ix.x,
-                fname.as_ptr(),
-                c_args.as_ptr(),
-                c_args.len() as c_int,
-                c_unsaved.as_mut_ptr(),
-                c_unsaved.len() as c_uint,
-                opts,
-            )
-        };
-        if tu.is_null() {
-            None
-        } else {
-            Some(TranslationUnit { x: tu })
-        }
-    }
-
-    /// Get the Clang diagnostic information associated with this translation
-    /// unit.
-    pub fn diags(&self) -> Vec<Diagnostic> {
-        unsafe {
-            let num = clang_getNumDiagnostics(self.x) as usize;
-            let mut diags = vec![];
-            for i in 0..num {
-                diags.push(Diagnostic {
-                    x: clang_getDiagnostic(self.x, i as c_uint),
-                });
-            }
-            diags
-        }
-    }
-
-    /// Get a cursor pointing to the root of this translation unit's AST.
-    pub fn cursor(&self) -> Cursor {
-        unsafe {
-            Cursor {
-                x: clang_getTranslationUnitCursor(self.x),
-            }
-        }
-    }
-
-    /// Is this the null translation unit?
-    pub fn is_null(&self) -> bool {
-        self.x.is_null()
-    }
-}
-
-impl Drop for TranslationUnit {
-    fn drop(&mut self) {
-        unsafe {
-            clang_disposeTranslationUnit(self.x);
-        }
-    }
-}
-
-/// A diagnostic message generated while parsing a translation unit.
-pub struct Diagnostic {
-    x: CXDiagnostic,
-}
-
-impl Diagnostic {
-    /// Format this diagnostic message as a string, using the given option bit
-    /// flags.
-    pub fn format(&self) -> String {
-        unsafe {
-            let opts = clang_defaultDiagnosticDisplayOptions();
-            cxstring_into_string(clang_formatDiagnostic(self.x, opts))
-        }
-    }
-
-    /// What is the severity of this diagnostic message?
-    pub fn severity(&self) -> CXDiagnosticSeverity {
-        unsafe { clang_getDiagnosticSeverity(self.x) }
-    }
-}
-
-impl Drop for Diagnostic {
-    /// Destroy this diagnostic message.
-    fn drop(&mut self) {
-        unsafe {
-            clang_disposeDiagnostic(self.x);
-        }
-    }
-}
-
-/// A file which has not been saved to disk.
-pub struct UnsavedFile {
-    x: CXUnsavedFile,
-    /// The name of the unsaved file. Kept here to avoid leaving dangling pointers in
-    /// `CXUnsavedFile`.
-    pub name: CString,
-    contents: CString,
-}
-
-impl UnsavedFile {
-    /// Construct a new unsaved file with the given `name` and `contents`.
-    pub fn new(name: &str, contents: &str) -> UnsavedFile {
-        let name = CString::new(name).unwrap();
-        let contents = CString::new(contents).unwrap();
-        let x = CXUnsavedFile {
-            Filename: name.as_ptr(),
-            Contents: contents.as_ptr(),
-            Length: contents.as_bytes().len() as c_ulong,
-        };
-        UnsavedFile { x, name, contents }
-    }
-}
-
-impl fmt::Debug for UnsavedFile {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "UnsavedFile(name: {:?}, contents: {:?})",
-            self.name, self.contents
-        )
-    }
-}
-
-/// Convert a cursor kind into a static string.
-pub fn kind_to_str(x: CXCursorKind) -> String {
-    unsafe { cxstring_into_string(clang_getCursorKindSpelling(x)) }
-}
-
-/// Convert a type kind to a static string.
-pub fn type_to_str(x: CXTypeKind) -> String {
-    unsafe { cxstring_into_string(clang_getTypeKindSpelling(x)) }
-}
-
-/// Dump the Clang AST to stdout for debugging purposes.
-pub fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
-    fn print_indent<S: AsRef<str>>(depth: isize, s: S) {
-        for _ in 0..depth {
-            print!("    ");
-        }
-        println!("{}", s.as_ref());
-    }
-
-    fn print_cursor<S: AsRef<str>>(depth: isize, prefix: S, c: &Cursor) {
-        let prefix = prefix.as_ref();
-        print_indent(
-            depth,
-            format!(" {}kind = {}", prefix, kind_to_str(c.kind())),
-        );
-        print_indent(
-            depth,
-            format!(" {}spelling = \"{}\"", prefix, c.spelling()),
-        );
-        print_indent(depth, format!(" {}location = {}", prefix, c.location()));
-        print_indent(
-            depth,
-            format!(" {}is-definition? {}", prefix, c.is_definition()),
-        );
-        print_indent(
-            depth,
-            format!(" {}is-declaration? {}", prefix, c.is_declaration()),
-        );
-        print_indent(
-            depth,
-            format!(
-                " {}is-inlined-function? {}",
-                prefix,
-                c.is_inlined_function()
-            ),
-        );
-
-        let templ_kind = c.template_kind();
-        if templ_kind != CXCursor_NoDeclFound {
-            print_indent(
-                depth,
-                format!(
-                    " {}template-kind = {}",
-                    prefix,
-                    kind_to_str(templ_kind)
-                ),
-            );
-        }
-        if let Some(usr) = c.usr() {
-            print_indent(depth, format!(" {}usr = \"{}\"", prefix, usr));
-        }
-        if let Ok(num) = c.num_args() {
-            print_indent(depth, format!(" {}number-of-args = {}", prefix, num));
-        }
-        if let Some(num) = c.num_template_args() {
-            print_indent(
-                depth,
-                format!(" {}number-of-template-args = {}", prefix, num),
-            );
-        }
-
-        if c.is_bit_field() {
-            let width = match c.bit_width() {
-                Some(w) => w.to_string(),
-                None => "<unevaluable>".to_string(),
-            };
-            print_indent(depth, format!(" {}bit-width = {}", prefix, width));
-        }
-
-        if let Some(ty) = c.enum_type() {
-            print_indent(
-                depth,
-                format!(" {}enum-type = {}", prefix, type_to_str(ty.kind())),
-            );
-        }
-        if let Some(val) = c.enum_val_signed() {
-            print_indent(depth, format!(" {}enum-val = {}", prefix, val));
-        }
-        if let Some(ty) = c.typedef_type() {
-            print_indent(
-                depth,
-                format!(" {}typedef-type = {}", prefix, type_to_str(ty.kind())),
-            );
-        }
-        if let Some(ty) = c.ret_type() {
-            print_indent(
-                depth,
-                format!(" {}ret-type = {}", prefix, type_to_str(ty.kind())),
-            );
-        }
-
-        if let Some(refd) = c.referenced() {
-            if refd != *c {
-                println!();
-                print_cursor(
-                    depth,
-                    String::from(prefix) + "referenced.",
-                    &refd,
-                );
-            }
-        }
-
-        let canonical = c.canonical();
-        if canonical != *c {
-            println!();
-            print_cursor(
-                depth,
-                String::from(prefix) + "canonical.",
-                &canonical,
-            );
-        }
-
-        if let Some(specialized) = c.specialized() {
-            if specialized != *c {
-                println!();
-                print_cursor(
-                    depth,
-                    String::from(prefix) + "specialized.",
-                    &specialized,
-                );
-            }
-        }
-
-        if let Some(parent) = c.fallible_semantic_parent() {
-            println!();
-            print_cursor(
-                depth,
-                String::from(prefix) + "semantic-parent.",
-                &parent,
-            );
-        }
-    }
-
-    fn print_type<S: AsRef<str>>(depth: isize, prefix: S, ty: &Type) {
-        let prefix = prefix.as_ref();
-
-        let kind = ty.kind();
-        print_indent(depth, format!(" {}kind = {}", prefix, type_to_str(kind)));
-        if kind == CXType_Invalid {
-            return;
-        }
-
-        print_indent(depth, format!(" {}cconv = {}", prefix, ty.call_conv()));
-
-        print_indent(
-            depth,
-            format!(" {}spelling = \"{}\"", prefix, ty.spelling()),
-        );
-        let num_template_args =
-            unsafe { clang_Type_getNumTemplateArguments(ty.x) };
-        if num_template_args >= 0 {
-            print_indent(
-                depth,
-                format!(
-                    " {}number-of-template-args = {}",
-                    prefix, num_template_args
-                ),
-            );
-        }
-        if let Some(num) = ty.num_elements() {
-            print_indent(
-                depth,
-                format!(" {}number-of-elements = {}", prefix, num),
-            );
-        }
-        print_indent(
-            depth,
-            format!(" {}is-variadic? {}", prefix, ty.is_variadic()),
-        );
-
-        let canonical = ty.canonical_type();
-        if canonical != *ty {
-            println!();
-            print_type(depth, String::from(prefix) + "canonical.", &canonical);
-        }
-
-        if let Some(pointee) = ty.pointee_type() {
-            if pointee != *ty {
-                println!();
-                print_type(depth, String::from(prefix) + "pointee.", &pointee);
-            }
-        }
-
-        if let Some(elem) = ty.elem_type() {
-            if elem != *ty {
-                println!();
-                print_type(depth, String::from(prefix) + "elements.", &elem);
-            }
-        }
-
-        if let Some(ret) = ty.ret_type() {
-            if ret != *ty {
-                println!();
-                print_type(depth, String::from(prefix) + "return.", &ret);
-            }
-        }
-
-        let named = ty.named();
-        if named != *ty && named.is_valid() {
-            println!();
-            print_type(depth, String::from(prefix) + "named.", &named);
-        }
-    }
-
-    print_indent(depth, "(");
-    print_cursor(depth, "", c);
-
-    println!();
-    let ty = c.cur_type();
-    print_type(depth, "type.", &ty);
-
-    let declaration = ty.declaration();
-    if declaration != *c && declaration.kind() != CXCursor_NoDeclFound {
-        println!();
-        print_cursor(depth, "type.declaration.", &declaration);
-    }
-
-    // Recurse.
-    let mut found_children = false;
-    c.visit(|s| {
-        if !found_children {
-            println!();
-            found_children = true;
-        }
-        ast_dump(&s, depth + 1)
-    });
-
-    print_indent(depth, ")");
-
-    CXChildVisit_Continue
-}
-
-/// Try to extract the clang version to a string
-pub fn extract_clang_version() -> String {
-    unsafe { cxstring_into_string(clang_getClangVersion()) }
-}
-
-/// A wrapper for the result of evaluating an expression.
-#[derive(Debug)]
-pub struct EvalResult {
-    x: CXEvalResult,
-}
-
-impl EvalResult {
-    /// Evaluate `cursor` and return the result.
-    pub fn new(cursor: Cursor) -> Option<Self> {
-        // Work around https://bugs.llvm.org/show_bug.cgi?id=42532, see:
-        //  * https://github.com/rust-lang/rust-bindgen/issues/283
-        //  * https://github.com/rust-lang/rust-bindgen/issues/1590
-        {
-            let mut found_cant_eval = false;
-            cursor.visit(|c| {
-                if c.kind() == CXCursor_TypeRef &&
-                    c.cur_type().canonical_type().kind() == CXType_Unexposed
-                {
-                    found_cant_eval = true;
-                    return CXChildVisit_Break;
-                }
-
-                CXChildVisit_Recurse
-            });
-
-            if found_cant_eval {
-                return None;
-            }
-        }
-        Some(EvalResult {
-            x: unsafe { clang_Cursor_Evaluate(cursor.x) },
-        })
-    }
-
-    fn kind(&self) -> CXEvalResultKind {
-        unsafe { clang_EvalResult_getKind(self.x) }
-    }
-
-    /// Try to get back the result as a double.
-    pub fn as_double(&self) -> Option<f64> {
-        match self.kind() {
-            CXEval_Float => {
-                Some(unsafe { clang_EvalResult_getAsDouble(self.x) } as f64)
-            }
-            _ => None,
-        }
-    }
-
-    /// Try to get back the result as an integer.
-    pub fn as_int(&self) -> Option<i64> {
-        if self.kind() != CXEval_Int {
-            return None;
-        }
-
-        if unsafe { clang_EvalResult_isUnsignedInt(self.x) } != 0 {
-            let value = unsafe { clang_EvalResult_getAsUnsigned(self.x) };
-            if value > i64::max_value() as c_ulonglong {
-                return None;
-            }
-
-            return Some(value as i64);
-        }
-
-        let value = unsafe { clang_EvalResult_getAsLongLong(self.x) };
-        if value > i64::max_value() as c_longlong {
-            return None;
-        }
-        if value < i64::min_value() as c_longlong {
-            return None;
-        }
-        Some(value as i64)
-    }
-
-    /// Evaluates the expression as a literal string, that may or may not be
-    /// valid utf-8.
-    pub fn as_literal_string(&self) -> Option<Vec<u8>> {
-        match self.kind() {
-            CXEval_StrLiteral => {
-                let ret = unsafe {
-                    CStr::from_ptr(clang_EvalResult_getAsStr(self.x))
-                };
-                Some(ret.to_bytes().to_vec())
-            }
-            _ => None,
-        }
-    }
-}
-
-impl Drop for EvalResult {
-    fn drop(&mut self) {
-        unsafe { clang_EvalResult_dispose(self.x) };
-    }
-}
-
-/// Target information obtained from libclang.
-#[derive(Debug)]
-pub struct TargetInfo {
-    /// The target triple.
-    pub triple: String,
-    /// The width of the pointer _in bits_.
-    pub pointer_width: usize,
-}
-
-impl TargetInfo {
-    /// Tries to obtain target information from libclang.
-    pub fn new(tu: &TranslationUnit) -> Self {
-        let triple;
-        let pointer_width;
-        unsafe {
-            let ti = clang_getTranslationUnitTargetInfo(tu.x);
-            triple = cxstring_into_string(clang_TargetInfo_getTriple(ti));
-            pointer_width = clang_TargetInfo_getPointerWidth(ti);
-            clang_TargetInfo_dispose(ti);
-        }
-        assert!(pointer_width > 0);
-        assert_eq!(pointer_width % 8, 0);
-        TargetInfo {
-            triple,
-            pointer_width: pointer_width as usize,
-        }
-    }
-}
diff --git a/src/codegen/bitfield_unit.rs b/src/codegen/bitfield_unit.rs
deleted file mode 100644
index 73ec2bd6..00000000
--- a/src/codegen/bitfield_unit.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-
-        let mask = 1 << bit_index;
-
-        byte & mask == mask
-    }
-
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-
-        let mut val = 0;
-
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-
-        val
-    }
-
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
diff --git a/src/codegen/bitfield_unit_tests.rs b/src/codegen/bitfield_unit_tests.rs
deleted file mode 100644
index e143e4ea..00000000
--- a/src/codegen/bitfield_unit_tests.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-//! Tests for `__BindgenBitfieldUnit`.
-//!
-//! Note that bit-fields are allocated right to left (least to most significant
-//! bits).
-//!
-//! From the x86 PS ABI:
-//!
-//! ```c
-//! struct {
-//!     int j : 5;
-//!     int k : 6;
-//!     int m : 7;
-//! };
-//! ```
-//!
-//! ```ignore
-//! +------------------------------------------------------------+
-//! |                     |              |            |          |
-//! |       padding       |       m      |     k      |    j     |
-//! |31                 18|17          11|10         5|4        0|
-//! +------------------------------------------------------------+
-//! ```
-
-use super::bitfield_unit::__BindgenBitfieldUnit;
-
-#[test]
-fn bitfield_unit_get_bit() {
-    let unit = __BindgenBitfieldUnit::<[u8; 2]>::new([0b10011101, 0b00011101]);
-
-    let mut bits = vec![];
-    for i in 0..16 {
-        bits.push(unit.get_bit(i));
-    }
-
-    println!();
-    println!("bits = {:?}", bits);
-    assert_eq!(
-        bits,
-        &[
-            // 0b10011101
-            true, false, true, true, true, false, false, true,
-            // 0b00011101
-            true, false, true, true, true, false, false, false
-        ]
-    );
-}
-
-#[test]
-fn bitfield_unit_set_bit() {
-    let mut unit =
-        __BindgenBitfieldUnit::<[u8; 2]>::new([0b00000000, 0b00000000]);
-
-    for i in 0..16 {
-        if i % 3 == 0 {
-            unit.set_bit(i, true);
-        }
-    }
-
-    for i in 0..16 {
-        assert_eq!(unit.get_bit(i), i % 3 == 0);
-    }
-
-    let mut unit =
-        __BindgenBitfieldUnit::<[u8; 2]>::new([0b11111111, 0b11111111]);
-
-    for i in 0..16 {
-        if i % 3 == 0 {
-            unit.set_bit(i, false);
-        }
-    }
-
-    for i in 0..16 {
-        assert_eq!(unit.get_bit(i), i % 3 != 0);
-    }
-}
-
-macro_rules! bitfield_unit_get {
-    (
-        $(
-            With $storage:expr , then get($start:expr, $len:expr) is $expected:expr;
-        )*
-    ) => {
-        #[test]
-        fn bitfield_unit_get() {
-            $({
-                let expected = $expected;
-                let unit = __BindgenBitfieldUnit::<_>::new($storage);
-                let actual = unit.get($start, $len);
-
-                println!();
-                println!("expected = {:064b}", expected);
-                println!("actual   = {:064b}", actual);
-
-                assert_eq!(expected, actual);
-            })*
-        }
-   }
-}
-
-bitfield_unit_get! {
-    // Let's just exhaustively test getting the bits from a single byte, since
-    // there are few enough combinations...
-
-    With [0b11100010], then get(0, 1) is 0;
-    With [0b11100010], then get(1, 1) is 1;
-    With [0b11100010], then get(2, 1) is 0;
-    With [0b11100010], then get(3, 1) is 0;
-    With [0b11100010], then get(4, 1) is 0;
-    With [0b11100010], then get(5, 1) is 1;
-    With [0b11100010], then get(6, 1) is 1;
-    With [0b11100010], then get(7, 1) is 1;
-
-    With [0b11100010], then get(0, 2) is 0b10;
-    With [0b11100010], then get(1, 2) is 0b01;
-    With [0b11100010], then get(2, 2) is 0b00;
-    With [0b11100010], then get(3, 2) is 0b00;
-    With [0b11100010], then get(4, 2) is 0b10;
-    With [0b11100010], then get(5, 2) is 0b11;
-    With [0b11100010], then get(6, 2) is 0b11;
-
-    With [0b11100010], then get(0, 3) is 0b010;
-    With [0b11100010], then get(1, 3) is 0b001;
-    With [0b11100010], then get(2, 3) is 0b000;
-    With [0b11100010], then get(3, 3) is 0b100;
-    With [0b11100010], then get(4, 3) is 0b110;
-    With [0b11100010], then get(5, 3) is 0b111;
-
-    With [0b11100010], then get(0, 4) is 0b0010;
-    With [0b11100010], then get(1, 4) is 0b0001;
-    With [0b11100010], then get(2, 4) is 0b1000;
-    With [0b11100010], then get(3, 4) is 0b1100;
-    With [0b11100010], then get(4, 4) is 0b1110;
-
-    With [0b11100010], then get(0, 5) is 0b00010;
-    With [0b11100010], then get(1, 5) is 0b10001;
-    With [0b11100010], then get(2, 5) is 0b11000;
-    With [0b11100010], then get(3, 5) is 0b11100;
-
-    With [0b11100010], then get(0, 6) is 0b100010;
-    With [0b11100010], then get(1, 6) is 0b110001;
-    With [0b11100010], then get(2, 6) is 0b111000;
-
-    With [0b11100010], then get(0, 7) is 0b1100010;
-    With [0b11100010], then get(1, 7) is 0b1110001;
-
-    With [0b11100010], then get(0, 8) is 0b11100010;
-
-    // OK. Now let's test getting bits from across byte boundaries.
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(0, 16) is 0b1111111101010101;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(1, 16) is 0b0111111110101010;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(2, 16) is 0b0011111111010101;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(3, 16) is 0b0001111111101010;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(4, 16) is 0b0000111111110101;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(5, 16) is 0b0000011111111010;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(6, 16) is 0b0000001111111101;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(7, 16) is 0b0000000111111110;
-
-    With [0b01010101, 0b11111111, 0b00000000, 0b11111111],
-    then get(8, 16) is 0b0000000011111111;
-}
-
-macro_rules! bitfield_unit_set {
-    (
-        $(
-            set($start:expr, $len:expr, $val:expr) is $expected:expr;
-        )*
-    ) => {
-        #[test]
-        fn bitfield_unit_set() {
-            $(
-                let mut unit = __BindgenBitfieldUnit::<[u8; 4]>::new([0, 0, 0, 0]);
-                unit.set($start, $len, $val);
-                let actual = unit.get(0, 32);
-
-                println!();
-                println!("set({}, {}, {:032b}", $start, $len, $val);
-                println!("expected = {:064b}", $expected);
-                println!("actual   = {:064b}", actual);
-
-                assert_eq!($expected, actual);
-            )*
-        }
-    }
-}
-
-bitfield_unit_set! {
-    // Once again, let's exhaustively test single byte combinations.
-
-    set(0, 1, 0b11111111) is 0b00000001;
-    set(1, 1, 0b11111111) is 0b00000010;
-    set(2, 1, 0b11111111) is 0b00000100;
-    set(3, 1, 0b11111111) is 0b00001000;
-    set(4, 1, 0b11111111) is 0b00010000;
-    set(5, 1, 0b11111111) is 0b00100000;
-    set(6, 1, 0b11111111) is 0b01000000;
-    set(7, 1, 0b11111111) is 0b10000000;
-
-    set(0, 2, 0b11111111) is 0b00000011;
-    set(1, 2, 0b11111111) is 0b00000110;
-    set(2, 2, 0b11111111) is 0b00001100;
-    set(3, 2, 0b11111111) is 0b00011000;
-    set(4, 2, 0b11111111) is 0b00110000;
-    set(5, 2, 0b11111111) is 0b01100000;
-    set(6, 2, 0b11111111) is 0b11000000;
-
-    set(0, 3, 0b11111111) is 0b00000111;
-    set(1, 3, 0b11111111) is 0b00001110;
-    set(2, 3, 0b11111111) is 0b00011100;
-    set(3, 3, 0b11111111) is 0b00111000;
-    set(4, 3, 0b11111111) is 0b01110000;
-    set(5, 3, 0b11111111) is 0b11100000;
-
-    set(0, 4, 0b11111111) is 0b00001111;
-    set(1, 4, 0b11111111) is 0b00011110;
-    set(2, 4, 0b11111111) is 0b00111100;
-    set(3, 4, 0b11111111) is 0b01111000;
-    set(4, 4, 0b11111111) is 0b11110000;
-
-    set(0, 5, 0b11111111) is 0b00011111;
-    set(1, 5, 0b11111111) is 0b00111110;
-    set(2, 5, 0b11111111) is 0b01111100;
-    set(3, 5, 0b11111111) is 0b11111000;
-
-    set(0, 6, 0b11111111) is 0b00111111;
-    set(1, 6, 0b11111111) is 0b01111110;
-    set(2, 6, 0b11111111) is 0b11111100;
-
-    set(0, 7, 0b11111111) is 0b01111111;
-    set(1, 7, 0b11111111) is 0b11111110;
-
-    set(0, 8, 0b11111111) is 0b11111111;
-
-    // And, now let's cross byte boundaries.
-
-    set(0, 16, 0b1111111111111111) is 0b00000000000000001111111111111111;
-    set(1, 16, 0b1111111111111111) is 0b00000000000000011111111111111110;
-    set(2, 16, 0b1111111111111111) is 0b00000000000000111111111111111100;
-    set(3, 16, 0b1111111111111111) is 0b00000000000001111111111111111000;
-    set(4, 16, 0b1111111111111111) is 0b00000000000011111111111111110000;
-    set(5, 16, 0b1111111111111111) is 0b00000000000111111111111111100000;
-    set(6, 16, 0b1111111111111111) is 0b00000000001111111111111111000000;
-    set(7, 16, 0b1111111111111111) is 0b00000000011111111111111110000000;
-    set(8, 16, 0b1111111111111111) is 0b00000000111111111111111100000000;
-}
diff --git a/src/codegen/dyngen.rs b/src/codegen/dyngen.rs
deleted file mode 100644
index 26cfe5cc..00000000
--- a/src/codegen/dyngen.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-use crate::codegen;
-use crate::ir::function::Abi;
-use proc_macro2::Ident;
-
-/// Used to build the output tokens for dynamic bindings.
-#[derive(Default)]
-pub struct DynamicItems {
-    /// Tracks the tokens that will appears inside the library struct -- e.g.:
-    /// ```ignore
-    /// struct Lib {
-    ///    __library: ::libloading::Library,
-    ///    pub x: Result<unsafe extern ..., ::libloading::Error>, // <- tracks these
-    ///    ...
-    /// }
-    /// ```
-    struct_members: Vec<proc_macro2::TokenStream>,
-
-    /// Tracks the tokens that will appear inside the library struct's implementation, e.g.:
-    ///
-    /// ```ignore
-    /// impl Lib {
-    ///     ...
-    ///     pub unsafe fn foo(&self, ...) { // <- tracks these
-    ///         ...
-    ///     }
-    /// }
-    /// ```
-    struct_implementation: Vec<proc_macro2::TokenStream>,
-
-    /// Tracks the initialization of the fields inside the `::new` constructor of the library
-    /// struct, e.g.:
-    /// ```ignore
-    /// impl Lib {
-    ///
-    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    ///     where
-    ///         P: AsRef<::std::ffi::OsStr>,
-    ///     {
-    ///         ...
-    ///         let foo = __library.get(...) ...; // <- tracks these
-    ///         ...
-    ///     }
-    ///
-    ///     ...
-    /// }
-    /// ```
-    constructor_inits: Vec<proc_macro2::TokenStream>,
-
-    /// Tracks the information that is passed to the library struct at the end of the `::new`
-    /// constructor, e.g.:
-    /// ```ignore
-    /// impl LibFoo {
-    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    ///     where
-    ///         P: AsRef<::std::ffi::OsStr>,
-    ///     {
-    ///         ...
-    ///         Ok(LibFoo {
-    ///             __library: __library,
-    ///             foo,
-    ///             bar, // <- tracks these
-    ///             ...
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    init_fields: Vec<proc_macro2::TokenStream>,
-}
-
-impl DynamicItems {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn get_tokens(&self, lib_ident: Ident) -> proc_macro2::TokenStream {
-        let struct_members = &self.struct_members;
-        let constructor_inits = &self.constructor_inits;
-        let init_fields = &self.init_fields;
-        let struct_implementation = &self.struct_implementation;
-
-        quote! {
-            extern crate libloading;
-
-            pub struct #lib_ident {
-                __library: ::libloading::Library,
-                #(#struct_members)*
-            }
-
-            impl #lib_ident {
-                pub unsafe fn new<P>(
-                    path: P
-                ) -> Result<Self, ::libloading::Error>
-                where P: AsRef<::std::ffi::OsStr> {
-                    let library = ::libloading::Library::new(path)?;
-                    Self::from_library(library)
-                }
-
-                pub unsafe fn from_library<L>(
-                    library: L
-                ) -> Result<Self, ::libloading::Error>
-                where L: Into<::libloading::Library> {
-                    let __library = library.into();
-                    #( #constructor_inits )*
-                    Ok(#lib_ident {
-                        __library,
-                        #( #init_fields ),*
-                    })
-                }
-
-                #( #struct_implementation )*
-            }
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn push(
-        &mut self,
-        ident: Ident,
-        abi: Abi,
-        is_variadic: bool,
-        is_required: bool,
-        args: Vec<proc_macro2::TokenStream>,
-        args_identifiers: Vec<proc_macro2::TokenStream>,
-        ret: proc_macro2::TokenStream,
-        ret_ty: proc_macro2::TokenStream,
-        attributes: Vec<proc_macro2::TokenStream>,
-    ) {
-        if !is_variadic {
-            assert_eq!(args.len(), args_identifiers.len());
-        }
-
-        let signature = quote! { unsafe extern #abi fn ( #( #args),* ) #ret };
-        let member = if is_required {
-            signature
-        } else {
-            quote! { Result<#signature, ::libloading::Error> }
-        };
-
-        self.struct_members.push(quote! {
-            pub #ident: #member,
-        });
-
-        // N.B: If the signature was required, it won't be wrapped in a Result<...>
-        //      and we can simply call it directly.
-        let fn_ = if is_required {
-            quote! { self.#ident }
-        } else {
-            quote! { self.#ident.as_ref().expect("Expected function, got error.") }
-        };
-        let call_body = quote! {
-            (#fn_)(#( #args_identifiers ),*)
-        };
-
-        // We can't implement variadic functions from C easily, so we allow to
-        // access the function pointer so that the user can call it just fine.
-        if !is_variadic {
-            self.struct_implementation.push(quote! {
-                #(#attributes)*
-                pub unsafe fn #ident ( &self, #( #args ),* ) -> #ret_ty {
-                    #call_body
-                }
-            });
-        }
-
-        // N.B: Unwrap the signature upon construction if it is required to be resolved.
-        let ident_str = codegen::helpers::ast_ty::cstr_expr(ident.to_string());
-        self.constructor_inits.push(if is_required {
-            quote! {
-                let #ident = __library.get(#ident_str).map(|sym| *sym)?;
-            }
-        } else {
-            quote! {
-                let #ident = __library.get(#ident_str).map(|sym| *sym);
-            }
-        });
-
-        self.init_fields.push(quote! {
-            #ident
-        });
-    }
-}
diff --git a/src/codegen/error.rs b/src/codegen/error.rs
deleted file mode 100644
index c1bcf4e1..00000000
--- a/src/codegen/error.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use std::error;
-use std::fmt;
-
-/// Errors that can occur during code generation.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Error {
-    /// Tried to generate an opaque blob for a type that did not have a layout.
-    NoLayoutForOpaqueBlob,
-
-    /// Tried to instantiate an opaque template definition, or a template
-    /// definition that is too difficult for us to understand (like a partial
-    /// template specialization).
-    InstantiationOfOpaqueType,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match *self {
-            Error::NoLayoutForOpaqueBlob => {
-                "Tried to generate an opaque blob, but had no layout"
-            }
-            Error::InstantiationOfOpaqueType => {
-                "Instantiation of opaque template type or partial template \
-                 specialization"
-            }
-        })
-    }
-}
-
-impl error::Error for Error {}
-
-/// A `Result` of `T` or an error of `bindgen::codegen::error::Error`.
-pub type Result<T> = ::std::result::Result<T, Error>;
diff --git a/src/codegen/helpers.rs b/src/codegen/helpers.rs
deleted file mode 100644
index 5bf36acb..00000000
--- a/src/codegen/helpers.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-//! Helpers for code generation that don't need macro expansion.
-
-use crate::ir::context::BindgenContext;
-use crate::ir::layout::Layout;
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::TokenStreamExt;
-
-pub mod attributes {
-    use proc_macro2::{Ident, Span, TokenStream};
-    use std::str::FromStr;
-
-    pub fn repr(which: &str) -> TokenStream {
-        let which = Ident::new(which, Span::call_site());
-        quote! {
-            #[repr( #which )]
-        }
-    }
-
-    pub fn repr_list(which_ones: &[&str]) -> TokenStream {
-        let which_ones = which_ones
-            .iter()
-            .cloned()
-            .map(|one| TokenStream::from_str(one).expect("repr to be valid"));
-        quote! {
-            #[repr( #( #which_ones ),* )]
-        }
-    }
-
-    pub fn derives(which_ones: &[&str]) -> TokenStream {
-        let which_ones = which_ones
-            .iter()
-            .cloned()
-            .map(|one| TokenStream::from_str(one).expect("derive to be valid"));
-        quote! {
-            #[derive( #( #which_ones ),* )]
-        }
-    }
-
-    pub fn inline() -> TokenStream {
-        quote! {
-            #[inline]
-        }
-    }
-
-    pub fn must_use() -> TokenStream {
-        quote! {
-            #[must_use]
-        }
-    }
-
-    pub fn non_exhaustive() -> TokenStream {
-        quote! {
-            #[non_exhaustive]
-        }
-    }
-
-    pub fn doc(comment: String) -> TokenStream {
-        // NOTE(emilio): By this point comments are already preprocessed and in
-        // `///` form. Quote turns them into `#[doc]` comments, but oh well.
-        TokenStream::from_str(&comment).unwrap()
-    }
-
-    pub fn link_name(name: &str) -> TokenStream {
-        // LLVM mangles the name by default but it's already mangled.
-        // Prefixing the name with \u{1} should tell LLVM to not mangle it.
-        let name = format!("\u{1}{}", name);
-        quote! {
-            #[link_name = #name]
-        }
-    }
-}
-
-/// Generates a proper type for a field or type with a given `Layout`, that is,
-/// a type with the correct size and alignment restrictions.
-pub fn blob(ctx: &BindgenContext, layout: Layout) -> TokenStream {
-    let opaque = layout.opaque();
-
-    // FIXME(emilio, #412): We fall back to byte alignment, but there are
-    // some things that legitimately are more than 8-byte aligned.
-    //
-    // Eventually we should be able to `unwrap` here, but...
-    let ty_name = match opaque.known_rust_type_for_array(ctx) {
-        Some(ty) => ty,
-        None => {
-            warn!("Found unknown alignment on code generation!");
-            "u8"
-        }
-    };
-
-    let ty_name = Ident::new(ty_name, Span::call_site());
-
-    let data_len = opaque.array_size(ctx).unwrap_or(layout.size);
-
-    if data_len == 1 {
-        quote! {
-            #ty_name
-        }
-    } else {
-        quote! {
-            [ #ty_name ; #data_len ]
-        }
-    }
-}
-
-/// Integer type of the same size as the given `Layout`.
-pub fn integer_type(
-    ctx: &BindgenContext,
-    layout: Layout,
-) -> Option<TokenStream> {
-    let name = Layout::known_type_for_size(ctx, layout.size)?;
-    let name = Ident::new(name, Span::call_site());
-    Some(quote! { #name })
-}
-
-/// Generates a bitfield allocation unit type for a type with the given `Layout`.
-pub fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> TokenStream {
-    let mut tokens = quote! {};
-
-    if ctx.options().enable_cxx_namespaces {
-        tokens.append_all(quote! { root:: });
-    }
-
-    let size = layout.size;
-    tokens.append_all(quote! {
-        __BindgenBitfieldUnit<[u8; #size]>
-    });
-
-    tokens
-}
-
-pub mod ast_ty {
-    use crate::ir::context::BindgenContext;
-    use crate::ir::function::FunctionSig;
-    use crate::ir::layout::Layout;
-    use crate::ir::ty::FloatKind;
-    use proc_macro2::{self, TokenStream};
-    use std::str::FromStr;
-
-    pub fn c_void(ctx: &BindgenContext) -> TokenStream {
-        // ctypes_prefix takes precedence
-        match ctx.options().ctypes_prefix {
-            Some(ref prefix) => {
-                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
-                quote! {
-                    #prefix::c_void
-                }
-            }
-            None => {
-                if ctx.options().use_core &&
-                    ctx.options().rust_features.core_ffi_c_void
-                {
-                    quote! { ::core::ffi::c_void }
-                } else {
-                    quote! { ::std::os::raw::c_void }
-                }
-            }
-        }
-    }
-
-    pub fn raw_type(ctx: &BindgenContext, name: &str) -> TokenStream {
-        let ident = ctx.rust_ident_raw(name);
-        match ctx.options().ctypes_prefix {
-            Some(ref prefix) => {
-                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
-                quote! {
-                    #prefix::#ident
-                }
-            }
-            None => {
-                if ctx.options().use_core &&
-                    ctx.options().rust_features().core_ffi_c
-                {
-                    quote! {
-                        ::core::ffi::#ident
-                    }
-                } else {
-                    quote! {
-                        ::std::os::raw::#ident
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn float_kind_rust_type(
-        ctx: &BindgenContext,
-        fk: FloatKind,
-        layout: Option<Layout>,
-    ) -> TokenStream {
-        // TODO: we probably should take the type layout into account more
-        // often?
-        //
-        // Also, maybe this one shouldn't be the default?
-        match (fk, ctx.options().convert_floats) {
-            (FloatKind::Float, true) => quote! { f32 },
-            (FloatKind::Double, true) => quote! { f64 },
-            (FloatKind::Float, false) => raw_type(ctx, "c_float"),
-            (FloatKind::Double, false) => raw_type(ctx, "c_double"),
-            (FloatKind::LongDouble, _) => {
-                match layout {
-                    Some(layout) => {
-                        match layout.size {
-                            4 => quote! { f32 },
-                            8 => quote! { f64 },
-                            // TODO(emilio): If rust ever gains f128 we should
-                            // use it here and below.
-                            _ => super::integer_type(ctx, layout)
-                                .unwrap_or(quote! { f64 }),
-                        }
-                    }
-                    None => {
-                        debug_assert!(
-                            false,
-                            "How didn't we know the layout for a primitive type?"
-                        );
-                        quote! { f64 }
-                    }
-                }
-            }
-            (FloatKind::Float128, _) => {
-                if ctx.options().rust_features.i128_and_u128 {
-                    quote! { u128 }
-                } else {
-                    quote! { [u64; 2] }
-                }
-            }
-        }
-    }
-
-    pub fn int_expr(val: i64) -> TokenStream {
-        // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::i64_unsuffixed(val);
-        quote!(#val)
-    }
-
-    pub fn uint_expr(val: u64) -> TokenStream {
-        // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::u64_unsuffixed(val);
-        quote!(#val)
-    }
-
-    pub fn byte_array_expr(bytes: &[u8]) -> TokenStream {
-        let mut bytes: Vec<_> = bytes.to_vec();
-        bytes.push(0);
-        quote! { [ #(#bytes),* ] }
-    }
-
-    pub fn cstr_expr(mut string: String) -> TokenStream {
-        string.push('\0');
-        let b = proc_macro2::Literal::byte_string(string.as_bytes());
-        quote! {
-            #b
-        }
-    }
-
-    pub fn float_expr(ctx: &BindgenContext, f: f64) -> Result<TokenStream, ()> {
-        if f.is_finite() {
-            let val = proc_macro2::Literal::f64_unsuffixed(f);
-
-            return Ok(quote!(#val));
-        }
-
-        let prefix = ctx.trait_prefix();
-
-        if f.is_nan() {
-            return Ok(quote! {
-                ::#prefix::f64::NAN
-            });
-        }
-
-        if f.is_infinite() {
-            return Ok(if f.is_sign_positive() {
-                quote! {
-                    ::#prefix::f64::INFINITY
-                }
-            } else {
-                quote! {
-                    ::#prefix::f64::NEG_INFINITY
-                }
-            });
-        }
-
-        warn!("Unknown non-finite float number: {:?}", f);
-        Err(())
-    }
-
-    pub fn arguments_from_signature(
-        signature: &FunctionSig,
-        ctx: &BindgenContext,
-    ) -> Vec<TokenStream> {
-        let mut unnamed_arguments = 0;
-        signature
-            .argument_types()
-            .iter()
-            .map(|&(ref name, _ty)| match *name {
-                Some(ref name) => {
-                    let name = ctx.rust_ident(name);
-                    quote! { #name }
-                }
-                None => {
-                    unnamed_arguments += 1;
-                    let name =
-                        ctx.rust_ident(format!("arg{}", unnamed_arguments));
-                    quote! { #name }
-                }
-            })
-            .collect()
-    }
-}
diff --git a/src/codegen/impl_debug.rs b/src/codegen/impl_debug.rs
deleted file mode 100644
index 0e2cd33a..00000000
--- a/src/codegen/impl_debug.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use crate::ir::comp::{BitfieldUnit, CompKind, Field, FieldData, FieldMethods};
-use crate::ir::context::BindgenContext;
-use crate::ir::item::{HasTypeParamInArray, IsOpaque, Item, ItemCanonicalName};
-use crate::ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
-
-pub fn gen_debug_impl(
-    ctx: &BindgenContext,
-    fields: &[Field],
-    item: &Item,
-    kind: CompKind,
-) -> proc_macro2::TokenStream {
-    let struct_name = item.canonical_name(ctx);
-    let mut format_string = format!("{} {{{{ ", struct_name);
-    let mut tokens = vec![];
-
-    if item.is_opaque(ctx, &()) {
-        format_string.push_str("opaque");
-    } else {
-        match kind {
-            CompKind::Union => {
-                format_string.push_str("union");
-            }
-            CompKind::Struct => {
-                let processed_fields = fields.iter().filter_map(|f| match f {
-                    Field::DataMember(ref fd) => fd.impl_debug(ctx, ()),
-                    Field::Bitfields(ref bu) => bu.impl_debug(ctx, ()),
-                });
-
-                for (i, (fstring, toks)) in processed_fields.enumerate() {
-                    if i > 0 {
-                        format_string.push_str(", ");
-                    }
-                    tokens.extend(toks);
-                    format_string.push_str(&fstring);
-                }
-            }
-        }
-    }
-
-    format_string.push_str(" }}");
-    tokens.insert(0, quote! { #format_string });
-
-    let prefix = ctx.trait_prefix();
-
-    quote! {
-        fn fmt(&self, f: &mut ::#prefix::fmt::Formatter<'_>) -> ::#prefix ::fmt::Result {
-            write!(f, #( #tokens ),*)
-        }
-    }
-}
-
-/// A trait for the things which we can codegen tokens that contribute towards a
-/// generated `impl Debug`.
-pub trait ImplDebug<'a> {
-    /// Any extra parameter required by this a particular `ImplDebug` implementation.
-    type Extra;
-
-    /// Generate a format string snippet to be included in the larger `impl Debug`
-    /// format string, and the code to get the format string's interpolation values.
-    fn impl_debug(
-        &self,
-        ctx: &BindgenContext,
-        extra: Self::Extra,
-    ) -> Option<(String, Vec<proc_macro2::TokenStream>)>;
-}
-
-impl<'a> ImplDebug<'a> for FieldData {
-    type Extra = ();
-
-    fn impl_debug(
-        &self,
-        ctx: &BindgenContext,
-        _: Self::Extra,
-    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
-        if let Some(name) = self.name() {
-            ctx.resolve_item(self.ty()).impl_debug(ctx, name)
-        } else {
-            None
-        }
-    }
-}
-
-impl<'a> ImplDebug<'a> for BitfieldUnit {
-    type Extra = ();
-
-    fn impl_debug(
-        &self,
-        ctx: &BindgenContext,
-        _: Self::Extra,
-    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
-        let mut format_string = String::new();
-        let mut tokens = vec![];
-        for (i, bitfield) in self.bitfields().iter().enumerate() {
-            if i > 0 {
-                format_string.push_str(", ");
-            }
-
-            if let Some(bitfield_name) = bitfield.name() {
-                format_string.push_str(&format!("{} : {{:?}}", bitfield_name));
-                let getter_name = bitfield.getter_name();
-                let name_ident = ctx.rust_ident_raw(getter_name);
-                tokens.push(quote! {
-                    self.#name_ident ()
-                });
-            }
-        }
-
-        Some((format_string, tokens))
-    }
-}
-
-impl<'a> ImplDebug<'a> for Item {
-    type Extra = &'a str;
-
-    fn impl_debug(
-        &self,
-        ctx: &BindgenContext,
-        name: &str,
-    ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
-        let name_ident = ctx.rust_ident(name);
-
-        // We don't know if blocklisted items `impl Debug` or not, so we can't
-        // add them to the format string we're building up.
-        if !ctx.allowlisted_items().contains(&self.id()) {
-            return None;
-        }
-
-        let ty = match self.as_type() {
-            Some(ty) => ty,
-            None => {
-                return None;
-            }
-        };
-
-        fn debug_print(
-            name: &str,
-            name_ident: proc_macro2::TokenStream,
-        ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
-            Some((
-                format!("{}: {{:?}}", name),
-                vec![quote! {
-                    self.#name_ident
-                }],
-            ))
-        }
-
-        match *ty.kind() {
-            // Handle the simple cases.
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::Reference(..) |
-            TypeKind::UnresolvedTypeRef(..) |
-            TypeKind::ObjCInterface(..) |
-            TypeKind::ObjCId |
-            TypeKind::Comp(..) |
-            TypeKind::ObjCSel => debug_print(name, quote! { #name_ident }),
-
-            TypeKind::TemplateInstantiation(ref inst) => {
-                if inst.is_opaque(ctx, self) {
-                    Some((format!("{}: opaque", name), vec![]))
-                } else {
-                    debug_print(name, quote! { #name_ident })
-                }
-            }
-
-            // The generic is not required to implement Debug, so we can not debug print that type
-            TypeKind::TypeParam => {
-                Some((format!("{}: Non-debuggable generic", name), vec![]))
-            }
-
-            TypeKind::Array(_, len) => {
-                // Generics are not required to implement Debug
-                if self.has_type_param_in_array(ctx) {
-                    Some((
-                        format!("{}: Array with length {}", name, len),
-                        vec![],
-                    ))
-                } else if len < RUST_DERIVE_IN_ARRAY_LIMIT ||
-                    ctx.options().rust_features().larger_arrays
-                {
-                    // The simple case
-                    debug_print(name, quote! { #name_ident })
-                } else if ctx.options().use_core {
-                    // There is no String in core; reducing field visibility to avoid breaking
-                    // no_std setups.
-                    Some((format!("{}: [...]", name), vec![]))
-                } else {
-                    // Let's implement our own print function
-                    Some((
-                        format!("{}: [{{}}]", name),
-                        vec![quote! {
-                            self.#name_ident
-                                .iter()
-                                .enumerate()
-                                .map(|(i, v)| format!("{}{:?}", if i > 0 { ", " } else { "" }, v))
-                                .collect::<String>()
-                        }],
-                    ))
-                }
-            }
-            TypeKind::Vector(_, len) => {
-                if ctx.options().use_core {
-                    // There is no format! in core; reducing field visibility to avoid breaking
-                    // no_std setups.
-                    Some((format!("{}(...)", name), vec![]))
-                } else {
-                    let self_ids = 0..len;
-                    Some((
-                        format!("{}({{}})", name),
-                        vec![quote! {
-                            #(format!("{:?}", self.#self_ids)),*
-                        }],
-                    ))
-                }
-            }
-
-            TypeKind::ResolvedTypeRef(t) |
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::BlockPointer(t) => {
-                // We follow the aliases
-                ctx.resolve_item(t).impl_debug(ctx, name)
-            }
-
-            TypeKind::Pointer(inner) => {
-                let inner_type = ctx.resolve_type(inner).canonical_type(ctx);
-                match *inner_type.kind() {
-                    TypeKind::Function(ref sig)
-                        if !sig.function_pointers_can_derive() =>
-                    {
-                        Some((format!("{}: FunctionPointer", name), vec![]))
-                    }
-                    _ => debug_print(name, quote! { #name_ident }),
-                }
-            }
-
-            TypeKind::Opaque => None,
-        }
-    }
-}
diff --git a/src/codegen/impl_partialeq.rs b/src/codegen/impl_partialeq.rs
deleted file mode 100644
index 960306ff..00000000
--- a/src/codegen/impl_partialeq.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate::ir::comp::{CompInfo, CompKind, Field, FieldMethods};
-use crate::ir::context::BindgenContext;
-use crate::ir::item::{IsOpaque, Item};
-use crate::ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
-
-/// Generate a manual implementation of `PartialEq` trait for the
-/// specified compound type.
-pub fn gen_partialeq_impl(
-    ctx: &BindgenContext,
-    comp_info: &CompInfo,
-    item: &Item,
-    ty_for_impl: &proc_macro2::TokenStream,
-) -> Option<proc_macro2::TokenStream> {
-    let mut tokens = vec![];
-
-    if item.is_opaque(ctx, &()) {
-        tokens.push(quote! {
-            &self._bindgen_opaque_blob[..] == &other._bindgen_opaque_blob[..]
-        });
-    } else if comp_info.kind() == CompKind::Union {
-        assert!(!ctx.options().rust_features().untagged_union);
-        tokens.push(quote! {
-            &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
-        });
-    } else {
-        for base in comp_info.base_members().iter() {
-            if !base.requires_storage(ctx) {
-                continue;
-            }
-
-            let ty_item = ctx.resolve_item(base.ty);
-            let field_name = &base.field_name;
-
-            if ty_item.is_opaque(ctx, &()) {
-                let field_name = ctx.rust_ident(field_name);
-                tokens.push(quote! {
-                    &self. #field_name [..] == &other. #field_name [..]
-                });
-            } else {
-                tokens.push(gen_field(ctx, ty_item, field_name));
-            }
-        }
-
-        for field in comp_info.fields() {
-            match *field {
-                Field::DataMember(ref fd) => {
-                    let ty_item = ctx.resolve_item(fd.ty());
-                    let name = fd.name().unwrap();
-                    tokens.push(gen_field(ctx, ty_item, name));
-                }
-                Field::Bitfields(ref bu) => {
-                    for bitfield in bu.bitfields() {
-                        if bitfield.name().is_some() {
-                            let getter_name = bitfield.getter_name();
-                            let name_ident = ctx.rust_ident_raw(getter_name);
-                            tokens.push(quote! {
-                                self.#name_ident () == other.#name_ident ()
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    Some(quote! {
-        fn eq(&self, other: & #ty_for_impl) -> bool {
-            #( #tokens )&&*
-        }
-    })
-}
-
-fn gen_field(
-    ctx: &BindgenContext,
-    ty_item: &Item,
-    name: &str,
-) -> proc_macro2::TokenStream {
-    fn quote_equals(
-        name_ident: proc_macro2::Ident,
-    ) -> proc_macro2::TokenStream {
-        quote! { self.#name_ident == other.#name_ident }
-    }
-
-    let name_ident = ctx.rust_ident(name);
-    let ty = ty_item.expect_type();
-
-    match *ty.kind() {
-        TypeKind::Void |
-        TypeKind::NullPtr |
-        TypeKind::Int(..) |
-        TypeKind::Complex(..) |
-        TypeKind::Float(..) |
-        TypeKind::Enum(..) |
-        TypeKind::TypeParam |
-        TypeKind::UnresolvedTypeRef(..) |
-        TypeKind::Reference(..) |
-        TypeKind::ObjCInterface(..) |
-        TypeKind::ObjCId |
-        TypeKind::ObjCSel |
-        TypeKind::Comp(..) |
-        TypeKind::Pointer(_) |
-        TypeKind::Function(..) |
-        TypeKind::Opaque => quote_equals(name_ident),
-
-        TypeKind::TemplateInstantiation(ref inst) => {
-            if inst.is_opaque(ctx, ty_item) {
-                quote! {
-                    &self. #name_ident [..] == &other. #name_ident [..]
-                }
-            } else {
-                quote_equals(name_ident)
-            }
-        }
-
-        TypeKind::Array(_, len) => {
-            if len <= RUST_DERIVE_IN_ARRAY_LIMIT ||
-                ctx.options().rust_features().larger_arrays
-            {
-                quote_equals(name_ident)
-            } else {
-                quote! {
-                    &self. #name_ident [..] == &other. #name_ident [..]
-                }
-            }
-        }
-        TypeKind::Vector(_, len) => {
-            let self_ids = 0..len;
-            let other_ids = 0..len;
-            quote! {
-                #(self.#self_ids == other.#other_ids &&)* true
-            }
-        }
-
-        TypeKind::ResolvedTypeRef(t) |
-        TypeKind::TemplateAlias(t, _) |
-        TypeKind::Alias(t) |
-        TypeKind::BlockPointer(t) => {
-            let inner_item = ctx.resolve_item(t);
-            gen_field(ctx, inner_item, name)
-        }
-    }
-}
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
deleted file mode 100644
index 7e0d7aa0..00000000
--- a/src/codegen/mod.rs
+++ /dev/null
@@ -1,5050 +0,0 @@
-mod dyngen;
-mod error;
-mod helpers;
-mod impl_debug;
-mod impl_partialeq;
-mod postprocessing;
-pub mod struct_layout;
-
-#[cfg(test)]
-#[allow(warnings)]
-pub(crate) mod bitfield_unit;
-#[cfg(all(test, target_endian = "little"))]
-mod bitfield_unit_tests;
-
-use self::dyngen::DynamicItems;
-use self::helpers::attributes;
-use self::struct_layout::StructLayoutTracker;
-
-use super::BindgenOptions;
-
-use crate::ir::analysis::{HasVtable, Sizedness};
-use crate::ir::annotations::FieldAccessorKind;
-use crate::ir::comment;
-use crate::ir::comp::{
-    Bitfield, BitfieldUnit, CompInfo, CompKind, Field, FieldData, FieldMethods,
-    Method, MethodKind,
-};
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::derive::{
-    CanDerive, CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
-    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
-};
-use crate::ir::dot;
-use crate::ir::enum_ty::{Enum, EnumVariant, EnumVariantValue};
-use crate::ir::function::{Abi, Function, FunctionKind, FunctionSig, Linkage};
-use crate::ir::int::IntKind;
-use crate::ir::item::{IsOpaque, Item, ItemCanonicalName, ItemCanonicalPath};
-use crate::ir::item_kind::ItemKind;
-use crate::ir::layout::Layout;
-use crate::ir::module::Module;
-use crate::ir::objc::{ObjCInterface, ObjCMethod};
-use crate::ir::template::{
-    AsTemplateParam, TemplateInstantiation, TemplateParameters,
-};
-use crate::ir::ty::{Type, TypeKind};
-use crate::ir::var::Var;
-
-use proc_macro2::{self, Ident, Span};
-use quote::TokenStreamExt;
-
-use crate::{Entry, HashMap, HashSet};
-use std::borrow::Cow;
-use std::cell::Cell;
-use std::collections::VecDeque;
-use std::fmt::Write;
-use std::iter;
-use std::ops;
-use std::str::FromStr;
-
-// Name of type defined in constified enum module
-pub static CONSTIFIED_ENUM_MODULE_REPR_NAME: &str = "Type";
-
-fn top_level_path(
-    ctx: &BindgenContext,
-    item: &Item,
-) -> Vec<proc_macro2::TokenStream> {
-    let mut path = vec![quote! { self }];
-
-    if ctx.options().enable_cxx_namespaces {
-        for _ in 0..item.codegen_depth(ctx) {
-            path.push(quote! { super });
-        }
-    }
-
-    path
-}
-
-fn root_import(
-    ctx: &BindgenContext,
-    module: &Item,
-) -> proc_macro2::TokenStream {
-    assert!(ctx.options().enable_cxx_namespaces, "Somebody messed it up");
-    assert!(module.is_module());
-
-    let mut path = top_level_path(ctx, module);
-
-    let root = ctx.root_module().canonical_name(ctx);
-    let root_ident = ctx.rust_ident(&root);
-    path.push(quote! { #root_ident });
-
-    let mut tokens = quote! {};
-    tokens.append_separated(path, quote!(::));
-
-    quote! {
-        #[allow(unused_imports)]
-        use #tokens ;
-    }
-}
-
-bitflags! {
-    struct DerivableTraits: u16 {
-        const DEBUG       = 1 << 0;
-        const DEFAULT     = 1 << 1;
-        const COPY        = 1 << 2;
-        const CLONE       = 1 << 3;
-        const HASH        = 1 << 4;
-        const PARTIAL_ORD = 1 << 5;
-        const ORD         = 1 << 6;
-        const PARTIAL_EQ  = 1 << 7;
-        const EQ          = 1 << 8;
-    }
-}
-
-fn derives_of_item(
-    item: &Item,
-    ctx: &BindgenContext,
-    packed: bool,
-) -> DerivableTraits {
-    let mut derivable_traits = DerivableTraits::empty();
-
-    let all_template_params = item.all_template_params(ctx);
-
-    if item.can_derive_copy(ctx) && !item.annotations().disallow_copy() {
-        derivable_traits |= DerivableTraits::COPY;
-
-        if ctx.options().rust_features().builtin_clone_impls ||
-            !all_template_params.is_empty()
-        {
-            // FIXME: This requires extra logic if you have a big array in a
-            // templated struct. The reason for this is that the magic:
-            //     fn clone(&self) -> Self { *self }
-            // doesn't work for templates.
-            //
-            // It's not hard to fix though.
-            derivable_traits |= DerivableTraits::CLONE;
-        }
-    } else if packed {
-        // If the struct or union is packed, deriving from Copy is required for
-        // deriving from any other trait.
-        return derivable_traits;
-    }
-
-    if item.can_derive_debug(ctx) && !item.annotations().disallow_debug() {
-        derivable_traits |= DerivableTraits::DEBUG;
-    }
-
-    if item.can_derive_default(ctx) && !item.annotations().disallow_default() {
-        derivable_traits |= DerivableTraits::DEFAULT;
-    }
-
-    if item.can_derive_hash(ctx) {
-        derivable_traits |= DerivableTraits::HASH;
-    }
-
-    if item.can_derive_partialord(ctx) {
-        derivable_traits |= DerivableTraits::PARTIAL_ORD;
-    }
-
-    if item.can_derive_ord(ctx) {
-        derivable_traits |= DerivableTraits::ORD;
-    }
-
-    if item.can_derive_partialeq(ctx) {
-        derivable_traits |= DerivableTraits::PARTIAL_EQ;
-    }
-
-    if item.can_derive_eq(ctx) {
-        derivable_traits |= DerivableTraits::EQ;
-    }
-
-    derivable_traits
-}
-
-impl From<DerivableTraits> for Vec<&'static str> {
-    fn from(derivable_traits: DerivableTraits) -> Vec<&'static str> {
-        [
-            (DerivableTraits::DEBUG, "Debug"),
-            (DerivableTraits::DEFAULT, "Default"),
-            (DerivableTraits::COPY, "Copy"),
-            (DerivableTraits::CLONE, "Clone"),
-            (DerivableTraits::HASH, "Hash"),
-            (DerivableTraits::PARTIAL_ORD, "PartialOrd"),
-            (DerivableTraits::ORD, "Ord"),
-            (DerivableTraits::PARTIAL_EQ, "PartialEq"),
-            (DerivableTraits::EQ, "Eq"),
-        ]
-        .iter()
-        .filter_map(|&(flag, derive)| {
-            Some(derive).filter(|_| derivable_traits.contains(flag))
-        })
-        .collect()
-    }
-}
-
-struct CodegenResult<'a> {
-    items: Vec<proc_macro2::TokenStream>,
-    dynamic_items: DynamicItems,
-
-    /// A monotonic counter used to add stable unique id's to stuff that doesn't
-    /// need to be referenced by anything.
-    codegen_id: &'a Cell<usize>,
-
-    /// Whether a bindgen union has been generated at least once.
-    saw_bindgen_union: bool,
-
-    /// Whether an incomplete array has been generated at least once.
-    saw_incomplete_array: bool,
-
-    /// Whether Objective C types have been seen at least once.
-    saw_objc: bool,
-
-    /// Whether Apple block types have been seen at least once.
-    saw_block: bool,
-
-    /// Whether a bitfield allocation unit has been seen at least once.
-    saw_bitfield_unit: bool,
-
-    items_seen: HashSet<ItemId>,
-    /// The set of generated function/var names, needed because in C/C++ is
-    /// legal to do something like:
-    ///
-    /// ```c++
-    /// extern "C" {
-    ///   void foo();
-    ///   extern int bar;
-    /// }
-    ///
-    /// extern "C" {
-    ///   void foo();
-    ///   extern int bar;
-    /// }
-    /// ```
-    ///
-    /// Being these two different declarations.
-    functions_seen: HashSet<String>,
-    vars_seen: HashSet<String>,
-
-    /// Used for making bindings to overloaded functions. Maps from a canonical
-    /// function name to the number of overloads we have already codegen'd for
-    /// that name. This lets us give each overload a unique suffix.
-    overload_counters: HashMap<String, u32>,
-}
-
-impl<'a> CodegenResult<'a> {
-    fn new(codegen_id: &'a Cell<usize>) -> Self {
-        CodegenResult {
-            items: vec![],
-            dynamic_items: DynamicItems::new(),
-            saw_bindgen_union: false,
-            saw_incomplete_array: false,
-            saw_objc: false,
-            saw_block: false,
-            saw_bitfield_unit: false,
-            codegen_id,
-            items_seen: Default::default(),
-            functions_seen: Default::default(),
-            vars_seen: Default::default(),
-            overload_counters: Default::default(),
-        }
-    }
-
-    fn dynamic_items(&mut self) -> &mut DynamicItems {
-        &mut self.dynamic_items
-    }
-
-    fn saw_bindgen_union(&mut self) {
-        self.saw_bindgen_union = true;
-    }
-
-    fn saw_incomplete_array(&mut self) {
-        self.saw_incomplete_array = true;
-    }
-
-    fn saw_objc(&mut self) {
-        self.saw_objc = true;
-    }
-
-    fn saw_block(&mut self) {
-        self.saw_block = true;
-    }
-
-    fn saw_bitfield_unit(&mut self) {
-        self.saw_bitfield_unit = true;
-    }
-
-    fn seen<Id: Into<ItemId>>(&self, item: Id) -> bool {
-        self.items_seen.contains(&item.into())
-    }
-
-    fn set_seen<Id: Into<ItemId>>(&mut self, item: Id) {
-        self.items_seen.insert(item.into());
-    }
-
-    fn seen_function(&self, name: &str) -> bool {
-        self.functions_seen.contains(name)
-    }
-
-    fn saw_function(&mut self, name: &str) {
-        self.functions_seen.insert(name.into());
-    }
-
-    /// Get the overload number for the given function name. Increments the
-    /// counter internally so the next time we ask for the overload for this
-    /// name, we get the incremented value, and so on.
-    fn overload_number(&mut self, name: &str) -> u32 {
-        let counter = self.overload_counters.entry(name.into()).or_insert(0);
-        let number = *counter;
-        *counter += 1;
-        number
-    }
-
-    fn seen_var(&self, name: &str) -> bool {
-        self.vars_seen.contains(name)
-    }
-
-    fn saw_var(&mut self, name: &str) {
-        self.vars_seen.insert(name.into());
-    }
-
-    fn inner<F>(&mut self, cb: F) -> Vec<proc_macro2::TokenStream>
-    where
-        F: FnOnce(&mut Self),
-    {
-        let mut new = Self::new(self.codegen_id);
-
-        cb(&mut new);
-
-        self.saw_incomplete_array |= new.saw_incomplete_array;
-        self.saw_objc |= new.saw_objc;
-        self.saw_block |= new.saw_block;
-        self.saw_bitfield_unit |= new.saw_bitfield_unit;
-        self.saw_bindgen_union |= new.saw_bindgen_union;
-
-        new.items
-    }
-}
-
-impl<'a> ops::Deref for CodegenResult<'a> {
-    type Target = Vec<proc_macro2::TokenStream>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.items
-    }
-}
-
-impl<'a> ops::DerefMut for CodegenResult<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.items
-    }
-}
-
-/// A trait to convert a rust type into a pointer, optionally const, to the same
-/// type.
-trait ToPtr {
-    fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream;
-}
-
-impl ToPtr for proc_macro2::TokenStream {
-    fn to_ptr(self, is_const: bool) -> proc_macro2::TokenStream {
-        if is_const {
-            quote! { *const #self }
-        } else {
-            quote! { *mut #self }
-        }
-    }
-}
-
-/// An extension trait for `proc_macro2::TokenStream` that lets us append any implicit
-/// template parameters that exist for some type, if necessary.
-trait AppendImplicitTemplateParams {
-    fn append_implicit_template_params(
-        &mut self,
-        ctx: &BindgenContext,
-        item: &Item,
-    );
-}
-
-impl AppendImplicitTemplateParams for proc_macro2::TokenStream {
-    fn append_implicit_template_params(
-        &mut self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) {
-        let item = item.id().into_resolver().through_type_refs().resolve(ctx);
-
-        match *item.expect_type().kind() {
-            TypeKind::UnresolvedTypeRef(..) => {
-                unreachable!("already resolved unresolved type refs")
-            }
-            TypeKind::ResolvedTypeRef(..) => {
-                unreachable!("we resolved item through type refs")
-            }
-
-            // None of these types ever have implicit template parameters.
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Pointer(..) |
-            TypeKind::Reference(..) |
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Array(..) |
-            TypeKind::TypeParam |
-            TypeKind::Opaque |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel |
-            TypeKind::TemplateInstantiation(..) => return,
-            _ => {}
-        }
-
-        let params: Vec<_> = item
-            .used_template_params(ctx)
-            .iter()
-            .map(|p| {
-                p.try_to_rust_ty(ctx, &())
-                    .expect("template params cannot fail to be a rust type")
-            })
-            .collect();
-        if !params.is_empty() {
-            self.append_all(quote! {
-                < #( #params ),* >
-            });
-        }
-    }
-}
-
-trait CodeGenerator {
-    /// Extra information from the caller.
-    type Extra;
-
-    /// Extra information returned to the caller.
-    type Return;
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        extra: &Self::Extra,
-    ) -> Self::Return;
-}
-
-impl Item {
-    fn process_before_codegen(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult,
-    ) -> bool {
-        if !self.is_enabled_for_codegen(ctx) {
-            return false;
-        }
-
-        if self.is_blocklisted(ctx) || result.seen(self.id()) {
-            debug!(
-                "<Item as CodeGenerator>::process_before_codegen: Ignoring hidden or seen: \
-                 self = {:?}",
-                self
-            );
-            return false;
-        }
-
-        if !ctx.codegen_items().contains(&self.id()) {
-            // TODO(emilio, #453): Figure out what to do when this happens
-            // legitimately, we could track the opaque stuff and disable the
-            // assertion there I guess.
-            warn!("Found non-allowlisted item in code generation: {:?}", self);
-        }
-
-        result.set_seen(self.id());
-        true
-    }
-}
-
-impl CodeGenerator for Item {
-    type Extra = ();
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        _extra: &(),
-    ) {
-        debug!("<Item as CodeGenerator>::codegen: self = {:?}", self);
-        if !self.process_before_codegen(ctx, result) {
-            return;
-        }
-
-        match *self.kind() {
-            ItemKind::Module(ref module) => {
-                module.codegen(ctx, result, self);
-            }
-            ItemKind::Function(ref fun) => {
-                fun.codegen(ctx, result, self);
-            }
-            ItemKind::Var(ref var) => {
-                var.codegen(ctx, result, self);
-            }
-            ItemKind::Type(ref ty) => {
-                ty.codegen(ctx, result, self);
-            }
-        }
-    }
-}
-
-impl CodeGenerator for Module {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug!("<Module as CodeGenerator>::codegen: item = {:?}", item);
-
-        let codegen_self = |result: &mut CodegenResult,
-                            found_any: &mut bool| {
-            for child in self.children() {
-                if ctx.codegen_items().contains(child) {
-                    *found_any = true;
-                    ctx.resolve_item(*child).codegen(ctx, result, &());
-                }
-            }
-
-            if item.id() == ctx.root_module() {
-                if result.saw_block {
-                    utils::prepend_block_header(ctx, &mut *result);
-                }
-                if result.saw_bindgen_union {
-                    utils::prepend_union_types(ctx, &mut *result);
-                }
-                if result.saw_incomplete_array {
-                    utils::prepend_incomplete_array_types(ctx, &mut *result);
-                }
-                if ctx.need_bindgen_complex_type() {
-                    utils::prepend_complex_type(&mut *result);
-                }
-                if result.saw_objc {
-                    utils::prepend_objc_header(ctx, &mut *result);
-                }
-                if result.saw_bitfield_unit {
-                    utils::prepend_bitfield_unit_type(ctx, &mut *result);
-                }
-            }
-        };
-
-        if !ctx.options().enable_cxx_namespaces ||
-            (self.is_inline() &&
-                !ctx.options().conservative_inline_namespaces)
-        {
-            codegen_self(result, &mut false);
-            return;
-        }
-
-        let mut found_any = false;
-        let inner_items = result.inner(|result| {
-            result.push(root_import(ctx, item));
-
-            let path = item.namespace_aware_canonical_path(ctx).join("::");
-            if let Some(raw_lines) = ctx.options().module_lines.get(&path) {
-                for raw_line in raw_lines {
-                    found_any = true;
-                    result.push(
-                        proc_macro2::TokenStream::from_str(raw_line).unwrap(),
-                    );
-                }
-            }
-
-            codegen_self(result, &mut found_any);
-        });
-
-        // Don't bother creating an empty module.
-        if !found_any {
-            return;
-        }
-
-        let name = item.canonical_name(ctx);
-        let ident = ctx.rust_ident(name);
-        result.push(if item.id() == ctx.root_module() {
-            quote! {
-                #[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-                pub mod #ident {
-                    #( #inner_items )*
-                }
-            }
-        } else {
-            quote! {
-                pub mod #ident {
-                    #( #inner_items )*
-                }
-            }
-        });
-    }
-}
-
-impl CodeGenerator for Var {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        use crate::ir::var::VarType;
-        debug!("<Var as CodeGenerator>::codegen: item = {:?}", item);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        let canonical_name = item.canonical_name(ctx);
-
-        if result.seen_var(&canonical_name) {
-            return;
-        }
-        result.saw_var(&canonical_name);
-
-        let canonical_ident = ctx.rust_ident(&canonical_name);
-
-        // We can't generate bindings to static variables of templates. The
-        // number of actual variables for a single declaration are open ended
-        // and we don't know what instantiations do or don't exist.
-        if !item.all_template_params(ctx).is_empty() {
-            return;
-        }
-
-        let mut attrs = vec![];
-        if let Some(comment) = item.comment(ctx) {
-            attrs.push(attributes::doc(comment));
-        }
-
-        let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
-
-        if let Some(val) = self.val() {
-            match *val {
-                VarType::Bool(val) => {
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #val ;
-                    });
-                }
-                VarType::Int(val) => {
-                    let int_kind = self
-                        .ty()
-                        .into_resolver()
-                        .through_type_aliases()
-                        .through_type_refs()
-                        .resolve(ctx)
-                        .expect_type()
-                        .as_integer()
-                        .unwrap();
-                    let val = if int_kind.is_signed() {
-                        helpers::ast_ty::int_expr(val)
-                    } else {
-                        helpers::ast_ty::uint_expr(val as _)
-                    };
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #val ;
-                    });
-                }
-                VarType::String(ref bytes) => {
-                    // Account the trailing zero.
-                    //
-                    // TODO: Here we ignore the type we just made up, probably
-                    // we should refactor how the variable type and ty id work.
-                    let len = bytes.len() + 1;
-                    let ty = quote! {
-                        [u8; #len]
-                    };
-
-                    match String::from_utf8(bytes.clone()) {
-                        Ok(string) => {
-                            let cstr = helpers::ast_ty::cstr_expr(string);
-                            if ctx
-                                .options()
-                                .rust_features
-                                .static_lifetime_elision
-                            {
-                                result.push(quote! {
-                                    #(#attrs)*
-                                    pub const #canonical_ident : &#ty = #cstr ;
-                                });
-                            } else {
-                                result.push(quote! {
-                                    #(#attrs)*
-                                    pub const #canonical_ident : &'static #ty = #cstr ;
-                                });
-                            }
-                        }
-                        Err(..) => {
-                            let bytes = helpers::ast_ty::byte_array_expr(bytes);
-                            result.push(quote! {
-                                #(#attrs)*
-                                pub const #canonical_ident : #ty = #bytes ;
-                            });
-                        }
-                    }
-                }
-                VarType::Float(f) => {
-                    if let Ok(expr) = helpers::ast_ty::float_expr(ctx, f) {
-                        result.push(quote! {
-                            #(#attrs)*
-                            pub const #canonical_ident : #ty = #expr ;
-                        });
-                    }
-                }
-                VarType::Char(c) => {
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #c ;
-                    });
-                }
-            }
-        } else {
-            // If necessary, apply a `#[link_name]` attribute
-            let link_name = self.mangled_name().unwrap_or_else(|| self.name());
-            if !utils::names_will_be_identical_after_mangling(
-                &canonical_name,
-                link_name,
-                None,
-            ) {
-                attrs.push(attributes::link_name(link_name));
-            }
-
-            let maybe_mut = if self.is_const() {
-                quote! {}
-            } else {
-                quote! { mut }
-            };
-
-            let tokens = quote!(
-                extern "C" {
-                    #(#attrs)*
-                    pub static #maybe_mut #canonical_ident: #ty;
-                }
-            );
-
-            result.push(tokens);
-        }
-    }
-}
-
-impl CodeGenerator for Type {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug!("<Type as CodeGenerator>::codegen: item = {:?}", item);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        match *self.kind() {
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Array(..) |
-            TypeKind::Vector(..) |
-            TypeKind::Pointer(..) |
-            TypeKind::Reference(..) |
-            TypeKind::Function(..) |
-            TypeKind::ResolvedTypeRef(..) |
-            TypeKind::Opaque |
-            TypeKind::TypeParam => {
-                // These items don't need code generation, they only need to be
-                // converted to rust types in fields, arguments, and such.
-                // NOTE(emilio): If you add to this list, make sure to also add
-                // it to BindgenContext::compute_allowlisted_and_codegen_items.
-            }
-            TypeKind::TemplateInstantiation(ref inst) => {
-                inst.codegen(ctx, result, item)
-            }
-            TypeKind::BlockPointer(inner) => {
-                if !ctx.options().generate_block {
-                    return;
-                }
-
-                let inner_item =
-                    inner.into_resolver().through_type_refs().resolve(ctx);
-                let name = item.canonical_name(ctx);
-
-                let inner_rust_type = {
-                    if let TypeKind::Function(fnsig) =
-                        inner_item.kind().expect_type().kind()
-                    {
-                        utils::fnsig_block(ctx, fnsig)
-                    } else {
-                        panic!("invalid block typedef: {:?}", inner_item)
-                    }
-                };
-
-                let rust_name = ctx.rust_ident(&name);
-
-                let mut tokens = if let Some(comment) = item.comment(ctx) {
-                    attributes::doc(comment)
-                } else {
-                    quote! {}
-                };
-
-                tokens.append_all(quote! {
-                    pub type #rust_name = #inner_rust_type ;
-                });
-
-                result.push(tokens);
-                result.saw_block();
-            }
-            TypeKind::Comp(ref ci) => ci.codegen(ctx, result, item),
-            TypeKind::TemplateAlias(inner, _) | TypeKind::Alias(inner) => {
-                let inner_item =
-                    inner.into_resolver().through_type_refs().resolve(ctx);
-                let name = item.canonical_name(ctx);
-                let path = item.canonical_path(ctx);
-
-                {
-                    let through_type_aliases = inner
-                        .into_resolver()
-                        .through_type_refs()
-                        .through_type_aliases()
-                        .resolve(ctx);
-
-                    // Try to catch the common pattern:
-                    //
-                    // typedef struct foo { ... } foo;
-                    //
-                    // here, and also other more complex cases like #946.
-                    if through_type_aliases.canonical_path(ctx) == path {
-                        return;
-                    }
-                }
-
-                // If this is a known named type, disallow generating anything
-                // for it too. If size_t -> usize conversions are enabled, we
-                // need to check that these conversions are permissible, but
-                // nothing needs to be generated, still.
-                let spelling = self.name().expect("Unnamed alias?");
-                if utils::type_from_named(ctx, spelling).is_some() {
-                    if let "size_t" | "ssize_t" = spelling {
-                        let layout = inner_item
-                            .kind()
-                            .expect_type()
-                            .layout(ctx)
-                            .expect("No layout?");
-                        assert_eq!(
-                            layout.size,
-                            ctx.target_pointer_size(),
-                            "Target platform requires `--no-size_t-is-usize`. The size of `{}` ({}) does not match the target pointer size ({})",
-                            spelling,
-                            layout.size,
-                            ctx.target_pointer_size(),
-                            );
-                        assert_eq!(
-                            layout.align,
-                            ctx.target_pointer_size(),
-                            "Target platform requires `--no-size_t-is-usize`. The alignment of `{}` ({}) does not match the target pointer size ({})",
-                            spelling,
-                            layout.align,
-                            ctx.target_pointer_size(),
-                        );
-                    }
-                    return;
-                }
-
-                let mut outer_params = item.used_template_params(ctx);
-
-                let is_opaque = item.is_opaque(ctx, &());
-                let inner_rust_type = if is_opaque {
-                    outer_params = vec![];
-                    self.to_opaque(ctx, item)
-                } else {
-                    // Its possible that we have better layout information than
-                    // the inner type does, so fall back to an opaque blob based
-                    // on our layout if converting the inner item fails.
-                    let mut inner_ty = inner_item
-                        .try_to_rust_ty_or_opaque(ctx, &())
-                        .unwrap_or_else(|_| self.to_opaque(ctx, item));
-                    inner_ty.append_implicit_template_params(ctx, inner_item);
-                    inner_ty
-                };
-
-                {
-                    // FIXME(emilio): This is a workaround to avoid generating
-                    // incorrect type aliases because of types that we haven't
-                    // been able to resolve (because, eg, they depend on a
-                    // template parameter).
-                    //
-                    // It's kind of a shame not generating them even when they
-                    // could be referenced, but we already do the same for items
-                    // with invalid template parameters, and at least this way
-                    // they can be replaced, instead of generating plain invalid
-                    // code.
-                    let inner_canon_type =
-                        inner_item.expect_type().canonical_type(ctx);
-                    if inner_canon_type.is_invalid_type_param() {
-                        warn!(
-                            "Item contained invalid named type, skipping: \
-                             {:?}, {:?}",
-                            item, inner_item
-                        );
-                        return;
-                    }
-                }
-
-                let rust_name = ctx.rust_ident(&name);
-
-                let mut tokens = if let Some(comment) = item.comment(ctx) {
-                    attributes::doc(comment)
-                } else {
-                    quote! {}
-                };
-
-                let alias_style = if ctx.options().type_alias.matches(&name) {
-                    AliasVariation::TypeAlias
-                } else if ctx.options().new_type_alias.matches(&name) {
-                    AliasVariation::NewType
-                } else if ctx.options().new_type_alias_deref.matches(&name) {
-                    AliasVariation::NewTypeDeref
-                } else {
-                    ctx.options().default_alias_style
-                };
-
-                // We prefer using `pub use` over `pub type` because of:
-                // https://github.com/rust-lang/rust/issues/26264
-                // These are the only characters allowed in simple
-                // paths, eg `good::dogs::Bront`.
-                if inner_rust_type.to_string().chars().all(|c| matches!(c, 'A'..='Z' | 'a'..='z' | '0'..='9' | ':' | '_' | ' ')) && outer_params.is_empty() &&
-                    !is_opaque &&
-                    alias_style == AliasVariation::TypeAlias &&
-                    inner_item.expect_type().canonical_type(ctx).is_enum()
-                {
-                    tokens.append_all(quote! {
-                        pub use
-                    });
-                    let path = top_level_path(ctx, item);
-                    tokens.append_separated(path, quote!(::));
-                    tokens.append_all(quote! {
-                        :: #inner_rust_type  as #rust_name ;
-                    });
-                    result.push(tokens);
-                    return;
-                }
-
-                tokens.append_all(match alias_style {
-                    AliasVariation::TypeAlias => quote! {
-                        pub type #rust_name
-                    },
-                    AliasVariation::NewType | AliasVariation::NewTypeDeref => {
-                        assert!(
-                            ctx.options().rust_features().repr_transparent,
-                            "repr_transparent feature is required to use {:?}",
-                            alias_style
-                        );
-
-                        let mut attributes =
-                            vec![attributes::repr("transparent")];
-                        let packed = false; // Types can't be packed in Rust.
-                        let derivable_traits =
-                            derives_of_item(item, ctx, packed);
-                        if !derivable_traits.is_empty() {
-                            let derives: Vec<_> = derivable_traits.into();
-                            attributes.push(attributes::derives(&derives))
-                        }
-
-                        quote! {
-                            #( #attributes )*
-                            pub struct #rust_name
-                        }
-                    }
-                });
-
-                let params: Vec<_> = outer_params
-                    .into_iter()
-                    .filter_map(|p| p.as_template_param(ctx, &()))
-                    .collect();
-                if params
-                    .iter()
-                    .any(|p| ctx.resolve_type(*p).is_invalid_type_param())
-                {
-                    warn!(
-                        "Item contained invalid template \
-                         parameter: {:?}",
-                        item
-                    );
-                    return;
-                }
-                let params: Vec<_> = params
-                    .iter()
-                    .map(|p| {
-                        p.try_to_rust_ty(ctx, &()).expect(
-                            "type parameters can always convert to rust ty OK",
-                        )
-                    })
-                    .collect();
-
-                if !params.is_empty() {
-                    tokens.append_all(quote! {
-                        < #( #params ),* >
-                    });
-                }
-
-                tokens.append_all(match alias_style {
-                    AliasVariation::TypeAlias => quote! {
-                        = #inner_rust_type ;
-                    },
-                    AliasVariation::NewType | AliasVariation::NewTypeDeref => {
-                        quote! {
-                            (pub #inner_rust_type) ;
-                        }
-                    }
-                });
-
-                if alias_style == AliasVariation::NewTypeDeref {
-                    let prefix = ctx.trait_prefix();
-                    tokens.append_all(quote! {
-                        impl ::#prefix::ops::Deref for #rust_name {
-                            type Target = #inner_rust_type;
-                            #[inline]
-                            fn deref(&self) -> &Self::Target {
-                                &self.0
-                            }
-                        }
-                        impl ::#prefix::ops::DerefMut for #rust_name {
-                            #[inline]
-                            fn deref_mut(&mut self) -> &mut Self::Target {
-                                &mut self.0
-                            }
-                        }
-                    });
-                }
-
-                result.push(tokens);
-            }
-            TypeKind::Enum(ref ei) => ei.codegen(ctx, result, item),
-            TypeKind::ObjCId | TypeKind::ObjCSel => {
-                result.saw_objc();
-            }
-            TypeKind::ObjCInterface(ref interface) => {
-                interface.codegen(ctx, result, item)
-            }
-            ref u @ TypeKind::UnresolvedTypeRef(..) => {
-                unreachable!("Should have been resolved after parsing {:?}!", u)
-            }
-        }
-    }
-}
-
-struct Vtable<'a> {
-    item_id: ItemId,
-    /// A reference to the originating compound object.
-    #[allow(dead_code)]
-    comp_info: &'a CompInfo,
-}
-
-impl<'a> Vtable<'a> {
-    fn new(item_id: ItemId, comp_info: &'a CompInfo) -> Self {
-        Vtable { item_id, comp_info }
-    }
-}
-
-impl<'a> CodeGenerator for Vtable<'a> {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'b>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'b>,
-        item: &Item,
-    ) {
-        assert_eq!(item.id(), self.item_id);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-        let name = ctx.rust_ident(&self.canonical_name(ctx));
-
-        // For now, we will only generate vtables for classes that:
-        // - do not inherit from others (compilers merge VTable from primary parent class).
-        // - do not contain a virtual destructor (requires ordering; platforms generate different vtables).
-        if ctx.options().vtable_generation &&
-            self.comp_info.base_members().is_empty() &&
-            self.comp_info.destructor().is_none()
-        {
-            let class_ident = ctx.rust_ident(self.item_id.canonical_name(ctx));
-
-            let methods = self
-                .comp_info
-                .methods()
-                .iter()
-                .filter_map(|m| {
-                    if !m.is_virtual() {
-                        return None;
-                    }
-
-                    let function_item = ctx.resolve_item(m.signature());
-                    let function = function_item.expect_function();
-                    let signature_item = ctx.resolve_item(function.signature());
-                    let signature = match signature_item.expect_type().kind() {
-                        TypeKind::Function(ref sig) => sig,
-                        _ => panic!("Function signature type mismatch"),
-                    };
-
-                    // FIXME: Is there a canonical name without the class prepended?
-                    let function_name = function_item.canonical_name(ctx);
-
-                    // FIXME: Need to account for overloading with times_seen (separately from regular function path).
-                    let function_name = ctx.rust_ident(function_name);
-                    let mut args = utils::fnsig_arguments(ctx, signature);
-                    let ret = utils::fnsig_return_ty(ctx, signature);
-
-                    args[0] = if m.is_const() {
-                        quote! { this: *const #class_ident }
-                    } else {
-                        quote! { this: *mut #class_ident }
-                    };
-
-                    Some(quote! {
-                        pub #function_name : unsafe extern "C" fn( #( #args ),* ) #ret
-                    })
-                })
-                .collect::<Vec<_>>();
-
-            result.push(quote! {
-                #[repr(C)]
-                pub struct #name {
-                    #( #methods ),*
-                }
-            })
-        } else {
-            // For the cases we don't support, simply generate an empty struct.
-            let void = helpers::ast_ty::c_void(ctx);
-
-            result.push(quote! {
-                #[repr(C)]
-                pub struct #name ( #void );
-            });
-        }
-    }
-}
-
-impl<'a> ItemCanonicalName for Vtable<'a> {
-    fn canonical_name(&self, ctx: &BindgenContext) -> String {
-        format!("{}__bindgen_vtable", self.item_id.canonical_name(ctx))
-    }
-}
-
-impl<'a> TryToRustTy for Vtable<'a> {
-    type Extra = ();
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<proc_macro2::TokenStream> {
-        let name = ctx.rust_ident(self.canonical_name(ctx));
-        Ok(quote! {
-            #name
-        })
-    }
-}
-
-impl CodeGenerator for TemplateInstantiation {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        // Although uses of instantiations don't need code generation, and are
-        // just converted to rust types in fields, vars, etc, we take this
-        // opportunity to generate tests for their layout here. If the
-        // instantiation is opaque, then its presumably because we don't
-        // properly understand it (maybe because of specializations), and so we
-        // shouldn't emit layout tests either.
-        if !ctx.options().layout_tests || self.is_opaque(ctx, item) {
-            return;
-        }
-
-        // If there are any unbound type parameters, then we can't generate a
-        // layout test because we aren't dealing with a concrete type with a
-        // concrete size and alignment.
-        if ctx.uses_any_template_parameters(item.id()) {
-            return;
-        }
-
-        let layout = item.kind().expect_type().layout(ctx);
-
-        if let Some(layout) = layout {
-            let size = layout.size;
-            let align = layout.align;
-
-            let name = item.full_disambiguated_name(ctx);
-            let mut fn_name =
-                format!("__bindgen_test_layout_{}_instantiation", name);
-            let times_seen = result.overload_number(&fn_name);
-            if times_seen > 0 {
-                write!(&mut fn_name, "_{}", times_seen).unwrap();
-            }
-
-            let fn_name = ctx.rust_ident_raw(fn_name);
-
-            let prefix = ctx.trait_prefix();
-            let ident = item.to_rust_ty_or_opaque(ctx, &());
-            let size_of_expr = quote! {
-                ::#prefix::mem::size_of::<#ident>()
-            };
-            let align_of_expr = quote! {
-                ::#prefix::mem::align_of::<#ident>()
-            };
-
-            let item = quote! {
-                #[test]
-                fn #fn_name() {
-                    assert_eq!(#size_of_expr, #size,
-                               concat!("Size of template specialization: ",
-                                       stringify!(#ident)));
-                    assert_eq!(#align_of_expr, #align,
-                               concat!("Alignment of template specialization: ",
-                                       stringify!(#ident)));
-                }
-            };
-
-            result.push(item);
-        }
-    }
-}
-
-/// Trait for implementing the code generation of a struct or union field.
-trait FieldCodegen<'a> {
-    type Extra;
-
-    #[allow(clippy::too_many_arguments)]
-    fn codegen<F, M>(
-        &self,
-        ctx: &BindgenContext,
-        fields_should_be_private: bool,
-        codegen_depth: usize,
-        accessor_kind: FieldAccessorKind,
-        parent: &CompInfo,
-        result: &mut CodegenResult,
-        struct_layout: &mut StructLayoutTracker,
-        fields: &mut F,
-        methods: &mut M,
-        extra: Self::Extra,
-    ) where
-        F: Extend<proc_macro2::TokenStream>,
-        M: Extend<proc_macro2::TokenStream>;
-}
-
-impl<'a> FieldCodegen<'a> for Field {
-    type Extra = ();
-
-    fn codegen<F, M>(
-        &self,
-        ctx: &BindgenContext,
-        fields_should_be_private: bool,
-        codegen_depth: usize,
-        accessor_kind: FieldAccessorKind,
-        parent: &CompInfo,
-        result: &mut CodegenResult,
-        struct_layout: &mut StructLayoutTracker,
-        fields: &mut F,
-        methods: &mut M,
-        _: (),
-    ) where
-        F: Extend<proc_macro2::TokenStream>,
-        M: Extend<proc_macro2::TokenStream>,
-    {
-        match *self {
-            Field::DataMember(ref data) => {
-                data.codegen(
-                    ctx,
-                    fields_should_be_private,
-                    codegen_depth,
-                    accessor_kind,
-                    parent,
-                    result,
-                    struct_layout,
-                    fields,
-                    methods,
-                    (),
-                );
-            }
-            Field::Bitfields(ref unit) => {
-                unit.codegen(
-                    ctx,
-                    fields_should_be_private,
-                    codegen_depth,
-                    accessor_kind,
-                    parent,
-                    result,
-                    struct_layout,
-                    fields,
-                    methods,
-                    (),
-                );
-            }
-        }
-    }
-}
-
-fn wrap_union_field_if_needed(
-    ctx: &BindgenContext,
-    struct_layout: &StructLayoutTracker,
-    ty: proc_macro2::TokenStream,
-    result: &mut CodegenResult,
-) -> proc_macro2::TokenStream {
-    if struct_layout.is_rust_union() {
-        if struct_layout.can_copy_union_fields() {
-            ty
-        } else {
-            let prefix = ctx.trait_prefix();
-            quote! {
-                ::#prefix::mem::ManuallyDrop<#ty>
-            }
-        }
-    } else {
-        result.saw_bindgen_union();
-        if ctx.options().enable_cxx_namespaces {
-            quote! {
-                root::__BindgenUnionField<#ty>
-            }
-        } else {
-            quote! {
-                __BindgenUnionField<#ty>
-            }
-        }
-    }
-}
-
-impl<'a> FieldCodegen<'a> for FieldData {
-    type Extra = ();
-
-    fn codegen<F, M>(
-        &self,
-        ctx: &BindgenContext,
-        fields_should_be_private: bool,
-        codegen_depth: usize,
-        accessor_kind: FieldAccessorKind,
-        parent: &CompInfo,
-        result: &mut CodegenResult,
-        struct_layout: &mut StructLayoutTracker,
-        fields: &mut F,
-        methods: &mut M,
-        _: (),
-    ) where
-        F: Extend<proc_macro2::TokenStream>,
-        M: Extend<proc_macro2::TokenStream>,
-    {
-        // Bitfields are handled by `FieldCodegen` implementations for
-        // `BitfieldUnit` and `Bitfield`.
-        assert!(self.bitfield_width().is_none());
-
-        let field_item =
-            self.ty().into_resolver().through_type_refs().resolve(ctx);
-        let field_ty = field_item.expect_type();
-        let mut ty = self.ty().to_rust_ty_or_opaque(ctx, &());
-        ty.append_implicit_template_params(ctx, field_item);
-
-        // NB: If supported, we use proper `union` types.
-        let ty = if parent.is_union() {
-            wrap_union_field_if_needed(ctx, struct_layout, ty, result)
-        } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
-            result.saw_incomplete_array();
-
-            let inner = item.to_rust_ty_or_opaque(ctx, &());
-
-            if ctx.options().enable_cxx_namespaces {
-                quote! {
-                    root::__IncompleteArrayField<#inner>
-                }
-            } else {
-                quote! {
-                    __IncompleteArrayField<#inner>
-                }
-            }
-        } else {
-            ty
-        };
-
-        let mut field = quote! {};
-        if ctx.options().generate_comments {
-            if let Some(raw_comment) = self.comment() {
-                let comment =
-                    comment::preprocess(raw_comment, codegen_depth + 1);
-                field = attributes::doc(comment);
-            }
-        }
-
-        let field_name = self
-            .name()
-            .map(|name| ctx.rust_mangle(name).into_owned())
-            .expect("Each field should have a name in codegen!");
-        let field_ident = ctx.rust_ident_raw(field_name.as_str());
-
-        if let Some(padding_field) =
-            struct_layout.saw_field(&field_name, field_ty, self.offset())
-        {
-            fields.extend(Some(padding_field));
-        }
-
-        let is_private = (!self.is_public() &&
-            ctx.options().respect_cxx_access_specs) ||
-            self.annotations()
-                .private_fields()
-                .unwrap_or(fields_should_be_private);
-
-        let accessor_kind =
-            self.annotations().accessor_kind().unwrap_or(accessor_kind);
-
-        if is_private {
-            field.append_all(quote! {
-                #field_ident : #ty ,
-            });
-        } else {
-            field.append_all(quote! {
-                pub #field_ident : #ty ,
-            });
-        }
-
-        fields.extend(Some(field));
-
-        // TODO: Factor the following code out, please!
-        if accessor_kind == FieldAccessorKind::None {
-            return;
-        }
-
-        let getter_name = ctx.rust_ident_raw(format!("get_{}", field_name));
-        let mutable_getter_name =
-            ctx.rust_ident_raw(format!("get_{}_mut", field_name));
-        let field_name = ctx.rust_ident_raw(field_name);
-
-        methods.extend(Some(match accessor_kind {
-            FieldAccessorKind::None => unreachable!(),
-            FieldAccessorKind::Regular => {
-                quote! {
-                    #[inline]
-                    pub fn #getter_name(&self) -> & #ty {
-                        &self.#field_name
-                    }
-
-                    #[inline]
-                    pub fn #mutable_getter_name(&mut self) -> &mut #ty {
-                        &mut self.#field_name
-                    }
-                }
-            }
-            FieldAccessorKind::Unsafe => {
-                quote! {
-                    #[inline]
-                    pub unsafe fn #getter_name(&self) -> & #ty {
-                        &self.#field_name
-                    }
-
-                    #[inline]
-                    pub unsafe fn #mutable_getter_name(&mut self) -> &mut #ty {
-                        &mut self.#field_name
-                    }
-                }
-            }
-            FieldAccessorKind::Immutable => {
-                quote! {
-                    #[inline]
-                    pub fn #getter_name(&self) -> & #ty {
-                        &self.#field_name
-                    }
-                }
-            }
-        }));
-    }
-}
-
-impl BitfieldUnit {
-    /// Get the constructor name for this bitfield unit.
-    fn ctor_name(&self) -> proc_macro2::TokenStream {
-        let ctor_name = Ident::new(
-            &format!("new_bitfield_{}", self.nth()),
-            Span::call_site(),
-        );
-        quote! {
-            #ctor_name
-        }
-    }
-}
-
-impl Bitfield {
-    /// Extend an under construction bitfield unit constructor with this
-    /// bitfield. This sets the relevant bits on the `__bindgen_bitfield_unit`
-    /// variable that's being constructed.
-    fn extend_ctor_impl(
-        &self,
-        ctx: &BindgenContext,
-        param_name: proc_macro2::TokenStream,
-        mut ctor_impl: proc_macro2::TokenStream,
-    ) -> proc_macro2::TokenStream {
-        let bitfield_ty = ctx.resolve_type(self.ty());
-        let bitfield_ty_layout = bitfield_ty
-            .layout(ctx)
-            .expect("Bitfield without layout? Gah!");
-        let bitfield_int_ty = helpers::integer_type(ctx, bitfield_ty_layout)
-            .expect(
-                "Should already have verified that the bitfield is \
-                 representable as an int",
-            );
-
-        let offset = self.offset_into_unit();
-        let width = self.width() as u8;
-        let prefix = ctx.trait_prefix();
-
-        ctor_impl.append_all(quote! {
-            __bindgen_bitfield_unit.set(
-                #offset,
-                #width,
-                {
-                    let #param_name: #bitfield_int_ty = unsafe {
-                        ::#prefix::mem::transmute(#param_name)
-                    };
-                    #param_name as u64
-                }
-            );
-        });
-
-        ctor_impl
-    }
-}
-
-fn access_specifier(
-    ctx: &BindgenContext,
-    is_pub: bool,
-) -> proc_macro2::TokenStream {
-    if is_pub || !ctx.options().respect_cxx_access_specs {
-        quote! { pub }
-    } else {
-        quote! {}
-    }
-}
-
-impl<'a> FieldCodegen<'a> for BitfieldUnit {
-    type Extra = ();
-
-    fn codegen<F, M>(
-        &self,
-        ctx: &BindgenContext,
-        fields_should_be_private: bool,
-        codegen_depth: usize,
-        accessor_kind: FieldAccessorKind,
-        parent: &CompInfo,
-        result: &mut CodegenResult,
-        struct_layout: &mut StructLayoutTracker,
-        fields: &mut F,
-        methods: &mut M,
-        _: (),
-    ) where
-        F: Extend<proc_macro2::TokenStream>,
-        M: Extend<proc_macro2::TokenStream>,
-    {
-        use crate::ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
-
-        result.saw_bitfield_unit();
-
-        let layout = self.layout();
-        let unit_field_ty = helpers::bitfield_unit(ctx, layout);
-        let field_ty = if parent.is_union() {
-            wrap_union_field_if_needed(
-                ctx,
-                struct_layout,
-                unit_field_ty.clone(),
-                result,
-            )
-        } else {
-            unit_field_ty.clone()
-        };
-
-        {
-            let align_field_name = format!("_bitfield_align_{}", self.nth());
-            let align_field_ident = ctx.rust_ident(&align_field_name);
-            let align_ty = match self.layout().align {
-                n if n >= 8 => quote! { u64 },
-                4 => quote! { u32 },
-                2 => quote! { u16 },
-                _ => quote! { u8  },
-            };
-            let align_field = quote! {
-                pub #align_field_ident: [#align_ty; 0],
-            };
-            fields.extend(Some(align_field));
-        }
-
-        let unit_field_name = format!("_bitfield_{}", self.nth());
-        let unit_field_ident = ctx.rust_ident(&unit_field_name);
-
-        let ctor_name = self.ctor_name();
-        let mut ctor_params = vec![];
-        let mut ctor_impl = quote! {};
-
-        // We cannot generate any constructor if the underlying storage can't
-        // implement AsRef<[u8]> / AsMut<[u8]> / etc, or can't derive Default.
-        //
-        // We don't check `larger_arrays` here because Default does still have
-        // the 32 items limitation.
-        let mut generate_ctor = layout.size <= RUST_DERIVE_IN_ARRAY_LIMIT;
-
-        let mut access_spec = !fields_should_be_private;
-        for bf in self.bitfields() {
-            // Codegen not allowed for anonymous bitfields
-            if bf.name().is_none() {
-                continue;
-            }
-
-            if layout.size > RUST_DERIVE_IN_ARRAY_LIMIT &&
-                !ctx.options().rust_features().larger_arrays
-            {
-                continue;
-            }
-
-            access_spec &= bf.is_public();
-            let mut bitfield_representable_as_int = true;
-
-            bf.codegen(
-                ctx,
-                fields_should_be_private,
-                codegen_depth,
-                accessor_kind,
-                parent,
-                result,
-                struct_layout,
-                fields,
-                methods,
-                (&unit_field_name, &mut bitfield_representable_as_int),
-            );
-
-            // Generating a constructor requires the bitfield to be representable as an integer.
-            if !bitfield_representable_as_int {
-                generate_ctor = false;
-                continue;
-            }
-
-            let param_name = bitfield_getter_name(ctx, bf);
-            let bitfield_ty_item = ctx.resolve_item(bf.ty());
-            let bitfield_ty = bitfield_ty_item.expect_type();
-            let bitfield_ty =
-                bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item);
-
-            ctor_params.push(quote! {
-                #param_name : #bitfield_ty
-            });
-            ctor_impl = bf.extend_ctor_impl(ctx, param_name, ctor_impl);
-        }
-
-        let access_spec = access_specifier(ctx, access_spec);
-
-        let field = quote! {
-            #access_spec #unit_field_ident : #field_ty ,
-        };
-        fields.extend(Some(field));
-
-        if generate_ctor {
-            methods.extend(Some(quote! {
-                #[inline]
-                #access_spec fn #ctor_name ( #( #ctor_params ),* ) -> #unit_field_ty {
-                    let mut __bindgen_bitfield_unit: #unit_field_ty = Default::default();
-                    #ctor_impl
-                    __bindgen_bitfield_unit
-                }
-            }));
-        }
-
-        struct_layout.saw_bitfield_unit(layout);
-    }
-}
-
-fn bitfield_getter_name(
-    ctx: &BindgenContext,
-    bitfield: &Bitfield,
-) -> proc_macro2::TokenStream {
-    let name = bitfield.getter_name();
-    let name = ctx.rust_ident_raw(name);
-    quote! { #name }
-}
-
-fn bitfield_setter_name(
-    ctx: &BindgenContext,
-    bitfield: &Bitfield,
-) -> proc_macro2::TokenStream {
-    let setter = bitfield.setter_name();
-    let setter = ctx.rust_ident_raw(setter);
-    quote! { #setter }
-}
-
-impl<'a> FieldCodegen<'a> for Bitfield {
-    type Extra = (&'a str, &'a mut bool);
-
-    fn codegen<F, M>(
-        &self,
-        ctx: &BindgenContext,
-        fields_should_be_private: bool,
-        _codegen_depth: usize,
-        _accessor_kind: FieldAccessorKind,
-        parent: &CompInfo,
-        _result: &mut CodegenResult,
-        struct_layout: &mut StructLayoutTracker,
-        _fields: &mut F,
-        methods: &mut M,
-        (unit_field_name, bitfield_representable_as_int): (&'a str, &mut bool),
-    ) where
-        F: Extend<proc_macro2::TokenStream>,
-        M: Extend<proc_macro2::TokenStream>,
-    {
-        let prefix = ctx.trait_prefix();
-        let getter_name = bitfield_getter_name(ctx, self);
-        let setter_name = bitfield_setter_name(ctx, self);
-        let unit_field_ident = Ident::new(unit_field_name, Span::call_site());
-
-        let bitfield_ty_item = ctx.resolve_item(self.ty());
-        let bitfield_ty = bitfield_ty_item.expect_type();
-
-        let bitfield_ty_layout = bitfield_ty
-            .layout(ctx)
-            .expect("Bitfield without layout? Gah!");
-        let bitfield_int_ty =
-            match helpers::integer_type(ctx, bitfield_ty_layout) {
-                Some(int_ty) => {
-                    *bitfield_representable_as_int = true;
-                    int_ty
-                }
-                None => {
-                    *bitfield_representable_as_int = false;
-                    return;
-                }
-            };
-
-        let bitfield_ty =
-            bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item);
-
-        let offset = self.offset_into_unit();
-        let width = self.width() as u8;
-        let access_spec = access_specifier(
-            ctx,
-            self.is_public() && !fields_should_be_private,
-        );
-
-        if parent.is_union() && !struct_layout.is_rust_union() {
-            methods.extend(Some(quote! {
-                #[inline]
-                #access_spec fn #getter_name(&self) -> #bitfield_ty {
-                    unsafe {
-                        ::#prefix::mem::transmute(
-                            self.#unit_field_ident.as_ref().get(#offset, #width)
-                                as #bitfield_int_ty
-                        )
-                    }
-                }
-
-                #[inline]
-                #access_spec fn #setter_name(&mut self, val: #bitfield_ty) {
-                    unsafe {
-                        let val: #bitfield_int_ty = ::#prefix::mem::transmute(val);
-                        self.#unit_field_ident.as_mut().set(
-                            #offset,
-                            #width,
-                            val as u64
-                        )
-                    }
-                }
-            }));
-        } else {
-            methods.extend(Some(quote! {
-                #[inline]
-                #access_spec fn #getter_name(&self) -> #bitfield_ty {
-                    unsafe {
-                        ::#prefix::mem::transmute(
-                            self.#unit_field_ident.get(#offset, #width)
-                                as #bitfield_int_ty
-                        )
-                    }
-                }
-
-                #[inline]
-                #access_spec fn #setter_name(&mut self, val: #bitfield_ty) {
-                    unsafe {
-                        let val: #bitfield_int_ty = ::#prefix::mem::transmute(val);
-                        self.#unit_field_ident.set(
-                            #offset,
-                            #width,
-                            val as u64
-                        )
-                    }
-                }
-            }));
-        }
-    }
-}
-
-impl CodeGenerator for CompInfo {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug!("<CompInfo as CodeGenerator>::codegen: item = {:?}", item);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        // Don't output classes with template parameters that aren't types, and
-        // also don't output template specializations, neither total or partial.
-        if self.has_non_type_template_params() {
-            return;
-        }
-
-        let ty = item.expect_type();
-        let layout = ty.layout(ctx);
-        let mut packed = self.is_packed(ctx, layout.as_ref());
-
-        let canonical_name = item.canonical_name(ctx);
-        let canonical_ident = ctx.rust_ident(&canonical_name);
-
-        // Generate the vtable from the method list if appropriate.
-        //
-        // TODO: I don't know how this could play with virtual methods that are
-        // not in the list of methods found by us, we'll see. Also, could the
-        // order of the vtable pointers vary?
-        //
-        // FIXME: Once we generate proper vtables, we need to codegen the
-        // vtable, but *not* generate a field for it in the case that
-        // HasVtable::has_vtable_ptr is false but HasVtable::has_vtable is true.
-        //
-        // Also, we need to generate the vtable in such a way it "inherits" from
-        // the parent too.
-        let is_opaque = item.is_opaque(ctx, &());
-        let mut fields = vec![];
-        let mut struct_layout =
-            StructLayoutTracker::new(ctx, self, ty, &canonical_name);
-
-        if !is_opaque {
-            if item.has_vtable_ptr(ctx) {
-                let vtable = Vtable::new(item.id(), self);
-                vtable.codegen(ctx, result, item);
-
-                let vtable_type = vtable
-                    .try_to_rust_ty(ctx, &())
-                    .expect("vtable to Rust type conversion is infallible")
-                    .to_ptr(true);
-
-                fields.push(quote! {
-                    pub vtable_: #vtable_type ,
-                });
-
-                struct_layout.saw_vtable();
-            }
-
-            for base in self.base_members() {
-                if !base.requires_storage(ctx) {
-                    continue;
-                }
-
-                let inner_item = ctx.resolve_item(base.ty);
-                let mut inner = inner_item.to_rust_ty_or_opaque(ctx, &());
-                inner.append_implicit_template_params(ctx, inner_item);
-                let field_name = ctx.rust_ident(&base.field_name);
-
-                struct_layout.saw_base(inner_item.expect_type());
-
-                let access_spec = access_specifier(ctx, base.is_public());
-                fields.push(quote! {
-                    #access_spec #field_name: #inner,
-                });
-            }
-        }
-
-        let mut methods = vec![];
-        if !is_opaque {
-            let codegen_depth = item.codegen_depth(ctx);
-            let fields_should_be_private =
-                item.annotations().private_fields().unwrap_or(false);
-            let struct_accessor_kind = item
-                .annotations()
-                .accessor_kind()
-                .unwrap_or(FieldAccessorKind::None);
-            for field in self.fields() {
-                field.codegen(
-                    ctx,
-                    fields_should_be_private,
-                    codegen_depth,
-                    struct_accessor_kind,
-                    self,
-                    result,
-                    &mut struct_layout,
-                    &mut fields,
-                    &mut methods,
-                    (),
-                );
-            }
-            // Check whether an explicit padding field is needed
-            // at the end.
-            if let Some(comp_layout) = layout {
-                fields.extend(
-                    struct_layout
-                        .add_tail_padding(&canonical_name, comp_layout),
-                );
-            }
-        }
-
-        if is_opaque {
-            // Opaque item should not have generated methods, fields.
-            debug_assert!(fields.is_empty());
-            debug_assert!(methods.is_empty());
-        }
-
-        let is_union = self.kind() == CompKind::Union;
-        let layout = item.kind().expect_type().layout(ctx);
-        let zero_sized = item.is_zero_sized(ctx);
-        let forward_decl = self.is_forward_declaration();
-
-        let mut explicit_align = None;
-
-        // C++ requires every struct to be addressable, so what C++ compilers do
-        // is making the struct 1-byte sized.
-        //
-        // This is apparently not the case for C, see:
-        // https://github.com/rust-lang/rust-bindgen/issues/551
-        //
-        // Just get the layout, and assume C++ if not.
-        //
-        // NOTE: This check is conveniently here to avoid the dummy fields we
-        // may add for unused template parameters.
-        if !forward_decl && zero_sized {
-            let has_address = if is_opaque {
-                // Generate the address field if it's an opaque type and
-                // couldn't determine the layout of the blob.
-                layout.is_none()
-            } else {
-                layout.map_or(true, |l| l.size != 0)
-            };
-
-            if has_address {
-                let layout = Layout::new(1, 1);
-                let ty = helpers::blob(ctx, Layout::new(1, 1));
-                struct_layout.saw_field_with_layout(
-                    "_address",
-                    layout,
-                    /* offset = */ Some(0),
-                );
-                fields.push(quote! {
-                    pub _address: #ty,
-                });
-            }
-        }
-
-        if is_opaque {
-            match layout {
-                Some(l) => {
-                    explicit_align = Some(l.align);
-
-                    let ty = helpers::blob(ctx, l);
-                    fields.push(quote! {
-                        pub _bindgen_opaque_blob: #ty ,
-                    });
-                }
-                None => {
-                    warn!("Opaque type without layout! Expect dragons!");
-                }
-            }
-        } else if !is_union && !zero_sized {
-            if let Some(padding_field) =
-                layout.and_then(|layout| struct_layout.pad_struct(layout))
-            {
-                fields.push(padding_field);
-            }
-
-            if let Some(layout) = layout {
-                if struct_layout.requires_explicit_align(layout) {
-                    if layout.align == 1 {
-                        packed = true;
-                    } else {
-                        explicit_align = Some(layout.align);
-                        if !ctx.options().rust_features.repr_align {
-                            let ty = helpers::blob(
-                                ctx,
-                                Layout::new(0, layout.align),
-                            );
-                            fields.push(quote! {
-                                pub __bindgen_align: #ty ,
-                            });
-                        }
-                    }
-                }
-            }
-        } else if is_union && !forward_decl {
-            // TODO(emilio): It'd be nice to unify this with the struct path
-            // above somehow.
-            let layout = layout.expect("Unable to get layout information?");
-            if struct_layout.requires_explicit_align(layout) {
-                explicit_align = Some(layout.align);
-            }
-
-            if !struct_layout.is_rust_union() {
-                let ty = helpers::blob(ctx, layout);
-                fields.push(quote! {
-                    pub bindgen_union_field: #ty ,
-                })
-            }
-        }
-
-        if forward_decl {
-            fields.push(quote! {
-                _unused: [u8; 0],
-            });
-        }
-
-        let mut generic_param_names = vec![];
-
-        for (idx, ty) in item.used_template_params(ctx).iter().enumerate() {
-            let param = ctx.resolve_type(*ty);
-            let name = param.name().unwrap();
-            let ident = ctx.rust_ident(name);
-            generic_param_names.push(ident.clone());
-
-            let prefix = ctx.trait_prefix();
-            let field_name = ctx.rust_ident(format!("_phantom_{}", idx));
-            fields.push(quote! {
-                pub #field_name : ::#prefix::marker::PhantomData<
-                    ::#prefix::cell::UnsafeCell<#ident>
-                > ,
-            });
-        }
-
-        let generics = if !generic_param_names.is_empty() {
-            let generic_param_names = generic_param_names.clone();
-            quote! {
-                < #( #generic_param_names ),* >
-            }
-        } else {
-            quote! {}
-        };
-
-        let mut attributes = vec![];
-        let mut needs_clone_impl = false;
-        let mut needs_default_impl = false;
-        let mut needs_debug_impl = false;
-        let mut needs_partialeq_impl = false;
-        if let Some(comment) = item.comment(ctx) {
-            attributes.push(attributes::doc(comment));
-        }
-        if packed && !is_opaque {
-            let n = layout.map_or(1, |l| l.align);
-            assert!(ctx.options().rust_features().repr_packed_n || n == 1);
-            let packed_repr = if n == 1 {
-                "packed".to_string()
-            } else {
-                format!("packed({})", n)
-            };
-            attributes.push(attributes::repr_list(&["C", &packed_repr]));
-        } else {
-            attributes.push(attributes::repr("C"));
-        }
-
-        if ctx.options().rust_features().repr_align {
-            if let Some(explicit) = explicit_align {
-                // Ensure that the struct has the correct alignment even in
-                // presence of alignas.
-                let explicit = helpers::ast_ty::int_expr(explicit as i64);
-                attributes.push(quote! {
-                    #[repr(align(#explicit))]
-                });
-            }
-        }
-
-        let derivable_traits = derives_of_item(item, ctx, packed);
-        if !derivable_traits.contains(DerivableTraits::DEBUG) {
-            needs_debug_impl = ctx.options().derive_debug &&
-                ctx.options().impl_debug &&
-                !ctx.no_debug_by_name(item) &&
-                !item.annotations().disallow_debug();
-        }
-
-        if !derivable_traits.contains(DerivableTraits::DEFAULT) {
-            needs_default_impl = ctx.options().derive_default &&
-                !self.is_forward_declaration() &&
-                !ctx.no_default_by_name(item) &&
-                !item.annotations().disallow_default();
-        }
-
-        let all_template_params = item.all_template_params(ctx);
-
-        if derivable_traits.contains(DerivableTraits::COPY) &&
-            !derivable_traits.contains(DerivableTraits::CLONE)
-        {
-            needs_clone_impl = true;
-        }
-
-        if !derivable_traits.contains(DerivableTraits::PARTIAL_EQ) {
-            needs_partialeq_impl = ctx.options().derive_partialeq &&
-                ctx.options().impl_partialeq &&
-                ctx.lookup_can_derive_partialeq_or_partialord(item.id()) ==
-                    CanDerive::Manually;
-        }
-
-        let mut derives: Vec<_> = derivable_traits.into();
-        derives.extend(item.annotations().derives().iter().map(String::as_str));
-
-        // The custom derives callback may return a list of derive attributes;
-        // add them to the end of the list.
-        let custom_derives;
-        if let Some(cb) = &ctx.options().parse_callbacks {
-            custom_derives = cb.add_derives(&canonical_name);
-            // In most cases this will be a no-op, since custom_derives will be empty.
-            derives.extend(custom_derives.iter().map(|s| s.as_str()));
-        };
-
-        if !derives.is_empty() {
-            attributes.push(attributes::derives(&derives))
-        }
-
-        if item.must_use(ctx) {
-            attributes.push(attributes::must_use());
-        }
-
-        let mut tokens = if is_union && struct_layout.is_rust_union() {
-            quote! {
-                #( #attributes )*
-                pub union #canonical_ident
-            }
-        } else {
-            quote! {
-                #( #attributes )*
-                pub struct #canonical_ident
-            }
-        };
-
-        tokens.append_all(quote! {
-            #generics {
-                #( #fields )*
-            }
-        });
-        result.push(tokens);
-
-        // Generate the inner types and all that stuff.
-        //
-        // TODO: In the future we might want to be smart, and use nested
-        // modules, and whatnot.
-        for ty in self.inner_types() {
-            let child_item = ctx.resolve_item(*ty);
-            // assert_eq!(child_item.parent_id(), item.id());
-            child_item.codegen(ctx, result, &());
-        }
-
-        // NOTE: Some unexposed attributes (like alignment attributes) may
-        // affect layout, so we're bad and pray to the gods for avoid sending
-        // all the tests to shit when parsing things like max_align_t.
-        if self.found_unknown_attr() {
-            warn!(
-                "Type {} has an unknown attribute that may affect layout",
-                canonical_ident
-            );
-        }
-
-        if all_template_params.is_empty() {
-            if !is_opaque {
-                for var in self.inner_vars() {
-                    ctx.resolve_item(*var).codegen(ctx, result, &());
-                }
-            }
-
-            if ctx.options().layout_tests && !self.is_forward_declaration() {
-                if let Some(layout) = layout {
-                    let fn_name =
-                        format!("bindgen_test_layout_{}", canonical_ident);
-                    let fn_name = ctx.rust_ident_raw(fn_name);
-                    let prefix = ctx.trait_prefix();
-                    let size_of_expr = quote! {
-                        ::#prefix::mem::size_of::<#canonical_ident>()
-                    };
-                    let align_of_expr = quote! {
-                        ::#prefix::mem::align_of::<#canonical_ident>()
-                    };
-                    let size = layout.size;
-                    let align = layout.align;
-
-                    let check_struct_align = if align >
-                        ctx.target_pointer_size() &&
-                        !ctx.options().rust_features().repr_align
-                    {
-                        None
-                    } else {
-                        Some(quote! {
-                            assert_eq!(#align_of_expr,
-                                   #align,
-                                   concat!("Alignment of ", stringify!(#canonical_ident)));
-
-                        })
-                    };
-
-                    // FIXME when [issue #465](https://github.com/rust-lang/rust-bindgen/issues/465) ready
-                    let too_many_base_vtables = self
-                        .base_members()
-                        .iter()
-                        .filter(|base| base.ty.has_vtable(ctx))
-                        .count() >
-                        1;
-
-                    let should_skip_field_offset_checks =
-                        is_opaque || too_many_base_vtables;
-
-                    let check_field_offset = if should_skip_field_offset_checks
-                    {
-                        vec![]
-                    } else {
-                        self.fields()
-                            .iter()
-                            .filter_map(|field| match *field {
-                                Field::DataMember(ref f) if f.name().is_some() => Some(f),
-                                _ => None,
-                            })
-                            .flat_map(|field| {
-                                let name = field.name().unwrap();
-                                field.offset().map(|offset| {
-                                    let field_offset = offset / 8;
-                                    let field_name = ctx.rust_ident(name);
-                                    quote! {
-                                        assert_eq!(
-                                            unsafe {
-                                                ::#prefix::ptr::addr_of!((*ptr).#field_name) as usize - ptr as usize
-                                            },
-                                            #field_offset,
-                                            concat!("Offset of field: ", stringify!(#canonical_ident), "::", stringify!(#field_name))
-                                        );
-                                    }
-                                })
-                            })
-                            .collect()
-                    };
-
-                    let uninit_decl = if !check_field_offset.is_empty() {
-                        // FIXME: When MSRV >= 1.59.0, we can use
-                        // > const PTR: *const #canonical_ident = ::#prefix::mem::MaybeUninit::uninit().as_ptr();
-                        Some(quote! {
-                            // Use a shared MaybeUninit so that rustc with
-                            // opt-level=0 doesn't take too much stack space,
-                            // see #2218.
-                            const UNINIT: ::#prefix::mem::MaybeUninit<#canonical_ident> = ::#prefix::mem::MaybeUninit::uninit();
-                            let ptr = UNINIT.as_ptr();
-                        })
-                    } else {
-                        None
-                    };
-
-                    let item = quote! {
-                        #[test]
-                        fn #fn_name() {
-                            #uninit_decl
-                            assert_eq!(#size_of_expr,
-                                       #size,
-                                       concat!("Size of: ", stringify!(#canonical_ident)));
-                            #check_struct_align
-                            #( #check_field_offset )*
-                        }
-                    };
-                    result.push(item);
-                }
-            }
-
-            let mut method_names = Default::default();
-            if ctx.options().codegen_config.methods() {
-                for method in self.methods() {
-                    assert!(method.kind() != MethodKind::Constructor);
-                    method.codegen_method(
-                        ctx,
-                        &mut methods,
-                        &mut method_names,
-                        result,
-                        self,
-                    );
-                }
-            }
-
-            if ctx.options().codegen_config.constructors() {
-                for sig in self.constructors() {
-                    Method::new(
-                        MethodKind::Constructor,
-                        *sig,
-                        /* const */
-                        false,
-                    )
-                    .codegen_method(
-                        ctx,
-                        &mut methods,
-                        &mut method_names,
-                        result,
-                        self,
-                    );
-                }
-            }
-
-            if ctx.options().codegen_config.destructors() {
-                if let Some((kind, destructor)) = self.destructor() {
-                    debug_assert!(kind.is_destructor());
-                    Method::new(kind, destructor, false).codegen_method(
-                        ctx,
-                        &mut methods,
-                        &mut method_names,
-                        result,
-                        self,
-                    );
-                }
-            }
-        }
-
-        // NB: We can't use to_rust_ty here since for opaque types this tries to
-        // use the specialization knowledge to generate a blob field.
-        let ty_for_impl = quote! {
-            #canonical_ident #generics
-        };
-
-        if needs_clone_impl {
-            result.push(quote! {
-                impl #generics Clone for #ty_for_impl {
-                    fn clone(&self) -> Self { *self }
-                }
-            });
-        }
-
-        if needs_default_impl {
-            let prefix = ctx.trait_prefix();
-            let body = if ctx.options().rust_features().maybe_uninit {
-                quote! {
-                    let mut s = ::#prefix::mem::MaybeUninit::<Self>::uninit();
-                    unsafe {
-                        ::#prefix::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                        s.assume_init()
-                    }
-                }
-            } else {
-                quote! {
-                    unsafe {
-                        let mut s: Self = ::#prefix::mem::uninitialized();
-                        ::#prefix::ptr::write_bytes(&mut s, 0, 1);
-                        s
-                    }
-                }
-            };
-            // Note we use `ptr::write_bytes()` instead of `mem::zeroed()` because the latter does
-            // not necessarily ensure padding bytes are zeroed. Some C libraries are sensitive to
-            // non-zero padding bytes, especially when forwards/backwards compatability is
-            // involved.
-            result.push(quote! {
-                impl #generics Default for #ty_for_impl {
-                    fn default() -> Self {
-                        #body
-                    }
-                }
-            });
-        }
-
-        if needs_debug_impl {
-            let impl_ = impl_debug::gen_debug_impl(
-                ctx,
-                self.fields(),
-                item,
-                self.kind(),
-            );
-
-            let prefix = ctx.trait_prefix();
-
-            result.push(quote! {
-                impl #generics ::#prefix::fmt::Debug for #ty_for_impl {
-                    #impl_
-                }
-            });
-        }
-
-        if needs_partialeq_impl {
-            if let Some(impl_) = impl_partialeq::gen_partialeq_impl(
-                ctx,
-                self,
-                item,
-                &ty_for_impl,
-            ) {
-                let partialeq_bounds = if !generic_param_names.is_empty() {
-                    let bounds = generic_param_names.iter().map(|t| {
-                        quote! { #t: PartialEq }
-                    });
-                    quote! { where #( #bounds ),* }
-                } else {
-                    quote! {}
-                };
-
-                let prefix = ctx.trait_prefix();
-                result.push(quote! {
-                    impl #generics ::#prefix::cmp::PartialEq for #ty_for_impl #partialeq_bounds {
-                        #impl_
-                    }
-                });
-            }
-        }
-
-        if !methods.is_empty() {
-            result.push(quote! {
-                impl #generics #ty_for_impl {
-                    #( #methods )*
-                }
-            });
-        }
-    }
-}
-
-trait MethodCodegen {
-    fn codegen_method<'a>(
-        &self,
-        ctx: &BindgenContext,
-        methods: &mut Vec<proc_macro2::TokenStream>,
-        method_names: &mut HashMap<String, usize>,
-        result: &mut CodegenResult<'a>,
-        parent: &CompInfo,
-    );
-}
-
-impl MethodCodegen for Method {
-    fn codegen_method<'a>(
-        &self,
-        ctx: &BindgenContext,
-        methods: &mut Vec<proc_macro2::TokenStream>,
-        method_names: &mut HashMap<String, usize>,
-        result: &mut CodegenResult<'a>,
-        _parent: &CompInfo,
-    ) {
-        assert!({
-            let cc = &ctx.options().codegen_config;
-            match self.kind() {
-                MethodKind::Constructor => cc.constructors(),
-                MethodKind::Destructor => cc.destructors(),
-                MethodKind::VirtualDestructor { .. } => cc.destructors(),
-                MethodKind::Static |
-                MethodKind::Normal |
-                MethodKind::Virtual { .. } => cc.methods(),
-            }
-        });
-
-        // TODO(emilio): We could generate final stuff at least.
-        if self.is_virtual() {
-            return; // FIXME
-        }
-
-        // First of all, output the actual function.
-        let function_item = ctx.resolve_item(self.signature());
-        if !function_item.process_before_codegen(ctx, result) {
-            return;
-        }
-        let function = function_item.expect_function();
-        let times_seen = function.codegen(ctx, result, function_item);
-        let times_seen = match times_seen {
-            Some(seen) => seen,
-            None => return,
-        };
-        let signature_item = ctx.resolve_item(function.signature());
-        let mut name = match self.kind() {
-            MethodKind::Constructor => "new".into(),
-            MethodKind::Destructor => "destruct".into(),
-            _ => function.name().to_owned(),
-        };
-
-        let signature = match *signature_item.expect_type().kind() {
-            TypeKind::Function(ref sig) => sig,
-            _ => panic!("How in the world?"),
-        };
-
-        let supported_abi = match signature.abi() {
-            Abi::ThisCall => ctx.options().rust_features().thiscall_abi,
-            Abi::Vectorcall => ctx.options().rust_features().vectorcall_abi,
-            _ => true,
-        };
-
-        if !supported_abi {
-            return;
-        }
-
-        // Do not generate variadic methods, since rust does not allow
-        // implementing them, and we don't do a good job at it anyway.
-        if signature.is_variadic() {
-            return;
-        }
-
-        let count = {
-            let count = method_names.entry(name.clone()).or_insert(0);
-            *count += 1;
-            *count - 1
-        };
-
-        if count != 0 {
-            name.push_str(&count.to_string());
-        }
-
-        let mut function_name = function_item.canonical_name(ctx);
-        if times_seen > 0 {
-            write!(&mut function_name, "{}", times_seen).unwrap();
-        }
-        let function_name = ctx.rust_ident(function_name);
-        let mut args = utils::fnsig_arguments(ctx, signature);
-        let mut ret = utils::fnsig_return_ty(ctx, signature);
-
-        if !self.is_static() && !self.is_constructor() {
-            args[0] = if self.is_const() {
-                quote! { &self }
-            } else {
-                quote! { &mut self }
-            };
-        }
-
-        // If it's a constructor, we always return `Self`, and we inject the
-        // "this" parameter, so there's no need to ask the user for it.
-        //
-        // Note that constructors in Clang are represented as functions with
-        // return-type = void.
-        if self.is_constructor() {
-            args.remove(0);
-            ret = quote! { -> Self };
-        }
-
-        let mut exprs =
-            helpers::ast_ty::arguments_from_signature(signature, ctx);
-
-        let mut stmts = vec![];
-
-        // If it's a constructor, we need to insert an extra parameter with a
-        // variable called `__bindgen_tmp` we're going to create.
-        if self.is_constructor() {
-            let prefix = ctx.trait_prefix();
-            let tmp_variable_decl = if ctx
-                .options()
-                .rust_features()
-                .maybe_uninit
-            {
-                exprs[0] = quote! {
-                    __bindgen_tmp.as_mut_ptr()
-                };
-                quote! {
-                    let mut __bindgen_tmp = ::#prefix::mem::MaybeUninit::uninit()
-                }
-            } else {
-                exprs[0] = quote! {
-                    &mut __bindgen_tmp
-                };
-                quote! {
-                    let mut __bindgen_tmp = ::#prefix::mem::uninitialized()
-                }
-            };
-            stmts.push(tmp_variable_decl);
-        } else if !self.is_static() {
-            assert!(!exprs.is_empty());
-            exprs[0] = quote! {
-                self
-            };
-        };
-
-        let call = quote! {
-            #function_name (#( #exprs ),* )
-        };
-
-        stmts.push(call);
-
-        if self.is_constructor() {
-            stmts.push(if ctx.options().rust_features().maybe_uninit {
-                quote! {
-                    __bindgen_tmp.assume_init()
-                }
-            } else {
-                quote! {
-                    __bindgen_tmp
-                }
-            })
-        }
-
-        let block = quote! {
-            #( #stmts );*
-        };
-
-        let mut attrs = vec![attributes::inline()];
-
-        if signature.must_use() &&
-            ctx.options().rust_features().must_use_function
-        {
-            attrs.push(attributes::must_use());
-        }
-
-        let name = ctx.rust_ident(&name);
-        methods.push(quote! {
-            #(#attrs)*
-            pub unsafe fn #name ( #( #args ),* ) #ret {
-                #block
-            }
-        });
-    }
-}
-
-/// A helper type that represents different enum variations.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum EnumVariation {
-    /// The code for this enum will use a Rust enum. Note that creating this in unsafe code
-    /// (including FFI) with an invalid value will invoke undefined behaviour, whether or not
-    /// its marked as non_exhaustive.
-    Rust {
-        /// Indicates whether the generated struct should be `#[non_exhaustive]`
-        non_exhaustive: bool,
-    },
-    /// The code for this enum will use a newtype
-    NewType {
-        /// Indicates whether the newtype will have bitwise operators
-        is_bitfield: bool,
-        /// Indicates whether the variants will be represented as global constants
-        is_global: bool,
-    },
-    /// The code for this enum will use consts
-    Consts,
-    /// The code for this enum will use a module containing consts
-    ModuleConsts,
-}
-
-impl EnumVariation {
-    fn is_rust(&self) -> bool {
-        matches!(*self, EnumVariation::Rust { .. })
-    }
-
-    /// Both the `Const` and `ModuleConsts` variants will cause this to return
-    /// true.
-    fn is_const(&self) -> bool {
-        matches!(*self, EnumVariation::Consts | EnumVariation::ModuleConsts)
-    }
-}
-
-impl Default for EnumVariation {
-    fn default() -> EnumVariation {
-        EnumVariation::Consts
-    }
-}
-
-impl std::str::FromStr for EnumVariation {
-    type Err = std::io::Error;
-
-    /// Create a `EnumVariation` from a string.
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "rust" => Ok(EnumVariation::Rust {
-                non_exhaustive: false,
-            }),
-            "rust_non_exhaustive" => Ok(EnumVariation::Rust {
-                non_exhaustive: true,
-            }),
-            "bitfield" => Ok(EnumVariation::NewType {
-                is_bitfield: true,
-                is_global: false,
-            }),
-            "consts" => Ok(EnumVariation::Consts),
-            "moduleconsts" => Ok(EnumVariation::ModuleConsts),
-            "newtype" => Ok(EnumVariation::NewType {
-                is_bitfield: false,
-                is_global: false,
-            }),
-            "newtype_global" => Ok(EnumVariation::NewType {
-                is_bitfield: false,
-                is_global: true,
-            }),
-            _ => Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                concat!(
-                    "Got an invalid EnumVariation. Accepted values ",
-                    "are 'rust', 'rust_non_exhaustive', 'bitfield', 'consts',",
-                    "'moduleconsts', 'newtype' and 'newtype_global'."
-                ),
-            )),
-        }
-    }
-}
-
-/// A helper type to construct different enum variations.
-enum EnumBuilder<'a> {
-    Rust {
-        codegen_depth: usize,
-        attrs: Vec<proc_macro2::TokenStream>,
-        ident: Ident,
-        tokens: proc_macro2::TokenStream,
-        emitted_any_variants: bool,
-    },
-    NewType {
-        codegen_depth: usize,
-        canonical_name: &'a str,
-        tokens: proc_macro2::TokenStream,
-        is_bitfield: bool,
-        is_global: bool,
-    },
-    Consts {
-        variants: Vec<proc_macro2::TokenStream>,
-        codegen_depth: usize,
-    },
-    ModuleConsts {
-        codegen_depth: usize,
-        module_name: &'a str,
-        module_items: Vec<proc_macro2::TokenStream>,
-    },
-}
-
-impl<'a> EnumBuilder<'a> {
-    /// Returns the depth of the code generation for a variant of this enum.
-    fn codegen_depth(&self) -> usize {
-        match *self {
-            EnumBuilder::Rust { codegen_depth, .. } |
-            EnumBuilder::NewType { codegen_depth, .. } |
-            EnumBuilder::ModuleConsts { codegen_depth, .. } |
-            EnumBuilder::Consts { codegen_depth, .. } => codegen_depth,
-        }
-    }
-
-    /// Returns true if the builder is for a rustified enum.
-    fn is_rust_enum(&self) -> bool {
-        matches!(*self, EnumBuilder::Rust { .. })
-    }
-
-    /// Create a new enum given an item builder, a canonical name, a name for
-    /// the representation, and which variation it should be generated as.
-    fn new(
-        name: &'a str,
-        mut attrs: Vec<proc_macro2::TokenStream>,
-        repr: proc_macro2::TokenStream,
-        enum_variation: EnumVariation,
-        enum_codegen_depth: usize,
-    ) -> Self {
-        let ident = Ident::new(name, Span::call_site());
-
-        match enum_variation {
-            EnumVariation::NewType {
-                is_bitfield,
-                is_global,
-            } => EnumBuilder::NewType {
-                codegen_depth: enum_codegen_depth,
-                canonical_name: name,
-                tokens: quote! {
-                    #( #attrs )*
-                    pub struct #ident (pub #repr);
-                },
-                is_bitfield,
-                is_global,
-            },
-
-            EnumVariation::Rust { .. } => {
-                // `repr` is guaranteed to be Rustified in Enum::codegen
-                attrs.insert(0, quote! { #[repr( #repr )] });
-                let tokens = quote!();
-                EnumBuilder::Rust {
-                    codegen_depth: enum_codegen_depth + 1,
-                    attrs,
-                    ident,
-                    tokens,
-                    emitted_any_variants: false,
-                }
-            }
-
-            EnumVariation::Consts => {
-                let mut variants = Vec::new();
-
-                variants.push(quote! {
-                    #( #attrs )*
-                    pub type #ident = #repr;
-                });
-
-                EnumBuilder::Consts {
-                    variants,
-                    codegen_depth: enum_codegen_depth,
-                }
-            }
-
-            EnumVariation::ModuleConsts => {
-                let ident = Ident::new(
-                    CONSTIFIED_ENUM_MODULE_REPR_NAME,
-                    Span::call_site(),
-                );
-                let type_definition = quote! {
-                    #( #attrs )*
-                    pub type #ident = #repr;
-                };
-
-                EnumBuilder::ModuleConsts {
-                    codegen_depth: enum_codegen_depth + 1,
-                    module_name: name,
-                    module_items: vec![type_definition],
-                }
-            }
-        }
-    }
-
-    /// Add a variant to this enum.
-    fn with_variant<'b>(
-        self,
-        ctx: &BindgenContext,
-        variant: &EnumVariant,
-        mangling_prefix: Option<&str>,
-        rust_ty: proc_macro2::TokenStream,
-        result: &mut CodegenResult<'b>,
-        is_ty_named: bool,
-    ) -> Self {
-        let variant_name = ctx.rust_mangle(variant.name());
-        let is_rust_enum = self.is_rust_enum();
-        let expr = match variant.val() {
-            EnumVariantValue::Boolean(v) if is_rust_enum => {
-                helpers::ast_ty::uint_expr(v as u64)
-            }
-            EnumVariantValue::Boolean(v) => quote!(#v),
-            EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v),
-            EnumVariantValue::Unsigned(v) => helpers::ast_ty::uint_expr(v),
-        };
-
-        let mut doc = quote! {};
-        if ctx.options().generate_comments {
-            if let Some(raw_comment) = variant.comment() {
-                let comment =
-                    comment::preprocess(raw_comment, self.codegen_depth());
-                doc = attributes::doc(comment);
-            }
-        }
-
-        match self {
-            EnumBuilder::Rust {
-                attrs,
-                ident,
-                tokens,
-                emitted_any_variants: _,
-                codegen_depth,
-            } => {
-                let name = ctx.rust_ident(variant_name);
-                EnumBuilder::Rust {
-                    attrs,
-                    ident,
-                    codegen_depth,
-                    tokens: quote! {
-                        #tokens
-                        #doc
-                        #name = #expr,
-                    },
-                    emitted_any_variants: true,
-                }
-            }
-
-            EnumBuilder::NewType {
-                canonical_name,
-                is_global,
-                ..
-            } => {
-                if ctx.options().rust_features().associated_const &&
-                    is_ty_named &&
-                    !is_global
-                {
-                    let enum_ident = ctx.rust_ident(canonical_name);
-                    let variant_ident = ctx.rust_ident(variant_name);
-
-                    result.push(quote! {
-                        impl #enum_ident {
-                            #doc
-                            pub const #variant_ident : #rust_ty = #rust_ty ( #expr );
-                        }
-                    });
-                } else {
-                    let ident = ctx.rust_ident(match mangling_prefix {
-                        Some(prefix) => {
-                            Cow::Owned(format!("{}_{}", prefix, variant_name))
-                        }
-                        None => variant_name,
-                    });
-                    result.push(quote! {
-                        #doc
-                        pub const #ident : #rust_ty = #rust_ty ( #expr );
-                    });
-                }
-
-                self
-            }
-
-            EnumBuilder::Consts { .. } => {
-                let constant_name = match mangling_prefix {
-                    Some(prefix) => {
-                        Cow::Owned(format!("{}_{}", prefix, variant_name))
-                    }
-                    None => variant_name,
-                };
-
-                let ident = ctx.rust_ident(constant_name);
-                result.push(quote! {
-                    #doc
-                    pub const #ident : #rust_ty = #expr ;
-                });
-
-                self
-            }
-            EnumBuilder::ModuleConsts {
-                codegen_depth,
-                module_name,
-                mut module_items,
-            } => {
-                let name = ctx.rust_ident(variant_name);
-                let ty = ctx.rust_ident(CONSTIFIED_ENUM_MODULE_REPR_NAME);
-                module_items.push(quote! {
-                    #doc
-                    pub const #name : #ty = #expr ;
-                });
-
-                EnumBuilder::ModuleConsts {
-                    module_name,
-                    module_items,
-                    codegen_depth,
-                }
-            }
-        }
-    }
-
-    fn build<'b>(
-        self,
-        ctx: &BindgenContext,
-        rust_ty: proc_macro2::TokenStream,
-        result: &mut CodegenResult<'b>,
-    ) -> proc_macro2::TokenStream {
-        match self {
-            EnumBuilder::Rust {
-                attrs,
-                ident,
-                tokens,
-                emitted_any_variants,
-                ..
-            } => {
-                let variants = if !emitted_any_variants {
-                    quote!(__bindgen_cannot_repr_c_on_empty_enum = 0)
-                } else {
-                    tokens
-                };
-
-                quote! {
-                    #( #attrs )*
-                    pub enum #ident {
-                        #variants
-                    }
-                }
-            }
-            EnumBuilder::NewType {
-                canonical_name,
-                tokens,
-                is_bitfield,
-                ..
-            } => {
-                if !is_bitfield {
-                    return tokens;
-                }
-
-                let rust_ty_name = ctx.rust_ident_raw(canonical_name);
-                let prefix = ctx.trait_prefix();
-
-                result.push(quote! {
-                    impl ::#prefix::ops::BitOr<#rust_ty> for #rust_ty {
-                        type Output = Self;
-
-                        #[inline]
-                        fn bitor(self, other: Self) -> Self {
-                            #rust_ty_name(self.0 | other.0)
-                        }
-                    }
-                });
-
-                result.push(quote! {
-                    impl ::#prefix::ops::BitOrAssign for #rust_ty {
-                        #[inline]
-                        fn bitor_assign(&mut self, rhs: #rust_ty) {
-                            self.0 |= rhs.0;
-                        }
-                    }
-                });
-
-                result.push(quote! {
-                    impl ::#prefix::ops::BitAnd<#rust_ty> for #rust_ty {
-                        type Output = Self;
-
-                        #[inline]
-                        fn bitand(self, other: Self) -> Self {
-                            #rust_ty_name(self.0 & other.0)
-                        }
-                    }
-                });
-
-                result.push(quote! {
-                    impl ::#prefix::ops::BitAndAssign for #rust_ty {
-                        #[inline]
-                        fn bitand_assign(&mut self, rhs: #rust_ty) {
-                            self.0 &= rhs.0;
-                        }
-                    }
-                });
-
-                tokens
-            }
-            EnumBuilder::Consts { variants, .. } => quote! { #( #variants )* },
-            EnumBuilder::ModuleConsts {
-                module_items,
-                module_name,
-                ..
-            } => {
-                let ident = ctx.rust_ident(module_name);
-                quote! {
-                    pub mod #ident {
-                        #( #module_items )*
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl CodeGenerator for Enum {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug!("<Enum as CodeGenerator>::codegen: item = {:?}", item);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        let name = item.canonical_name(ctx);
-        let ident = ctx.rust_ident(&name);
-        let enum_ty = item.expect_type();
-        let layout = enum_ty.layout(ctx);
-        let variation = self.computed_enum_variation(ctx, item);
-
-        let repr_translated;
-        let repr = match self.repr().map(|repr| ctx.resolve_type(repr)) {
-            Some(repr)
-                if !ctx.options().translate_enum_integer_types &&
-                    !variation.is_rust() =>
-            {
-                repr
-            }
-            repr => {
-                // An enum's integer type is translated to a native Rust
-                // integer type in 3 cases:
-                // * the enum is Rustified and we need a translated type for
-                //   the repr attribute
-                // * the representation couldn't be determined from the C source
-                // * it was explicitly requested as a bindgen option
-
-                let kind = match repr {
-                    Some(repr) => match *repr.canonical_type(ctx).kind() {
-                        TypeKind::Int(int_kind) => int_kind,
-                        _ => panic!("Unexpected type as enum repr"),
-                    },
-                    None => {
-                        warn!(
-                            "Guessing type of enum! Forward declarations of enums \
-                             shouldn't be legal!"
-                        );
-                        IntKind::Int
-                    }
-                };
-
-                let signed = kind.is_signed();
-                let size = layout
-                    .map(|l| l.size)
-                    .or_else(|| kind.known_size())
-                    .unwrap_or(0);
-
-                let translated = match (signed, size) {
-                    (true, 1) => IntKind::I8,
-                    (false, 1) => IntKind::U8,
-                    (true, 2) => IntKind::I16,
-                    (false, 2) => IntKind::U16,
-                    (true, 4) => IntKind::I32,
-                    (false, 4) => IntKind::U32,
-                    (true, 8) => IntKind::I64,
-                    (false, 8) => IntKind::U64,
-                    _ => {
-                        warn!(
-                            "invalid enum decl: signed: {}, size: {}",
-                            signed, size
-                        );
-                        IntKind::I32
-                    }
-                };
-
-                repr_translated =
-                    Type::new(None, None, TypeKind::Int(translated), false);
-                &repr_translated
-            }
-        };
-
-        let mut attrs = vec![];
-
-        // TODO(emilio): Delegate this to the builders?
-        match variation {
-            EnumVariation::Rust { non_exhaustive } => {
-                if non_exhaustive &&
-                    ctx.options().rust_features().non_exhaustive
-                {
-                    attrs.push(attributes::non_exhaustive());
-                } else if non_exhaustive &&
-                    !ctx.options().rust_features().non_exhaustive
-                {
-                    panic!("The rust target you're using doesn't seem to support non_exhaustive enums");
-                }
-            }
-            EnumVariation::NewType { .. } => {
-                if ctx.options().rust_features.repr_transparent {
-                    attrs.push(attributes::repr("transparent"));
-                } else {
-                    attrs.push(attributes::repr("C"));
-                }
-            }
-            _ => {}
-        };
-
-        if let Some(comment) = item.comment(ctx) {
-            attrs.push(attributes::doc(comment));
-        }
-
-        if item.must_use(ctx) {
-            attrs.push(attributes::must_use());
-        }
-
-        if !variation.is_const() {
-            let packed = false; // Enums can't be packed in Rust.
-            let mut derives = derives_of_item(item, ctx, packed);
-            // For backwards compat, enums always derive
-            // Clone/Eq/PartialEq/Hash, even if we don't generate those by
-            // default.
-            derives.insert(
-                DerivableTraits::CLONE |
-                    DerivableTraits::HASH |
-                    DerivableTraits::PARTIAL_EQ |
-                    DerivableTraits::EQ,
-            );
-            let mut derives: Vec<_> = derives.into();
-            for derive in item.annotations().derives().iter() {
-                if !derives.contains(&derive.as_str()) {
-                    derives.push(derive);
-                }
-            }
-
-            // The custom derives callback may return a list of derive attributes;
-            // add them to the end of the list.
-            let custom_derives;
-            if let Some(cb) = &ctx.options().parse_callbacks {
-                custom_derives = cb.add_derives(&name);
-                // In most cases this will be a no-op, since custom_derives will be empty.
-                derives.extend(custom_derives.iter().map(|s| s.as_str()));
-            };
-
-            attrs.push(attributes::derives(&derives));
-        }
-
-        fn add_constant<'a>(
-            ctx: &BindgenContext,
-            enum_: &Type,
-            // Only to avoid recomputing every time.
-            enum_canonical_name: &Ident,
-            // May be the same as "variant" if it's because the
-            // enum is unnamed and we still haven't seen the
-            // value.
-            variant_name: &Ident,
-            referenced_name: &Ident,
-            enum_rust_ty: proc_macro2::TokenStream,
-            result: &mut CodegenResult<'a>,
-        ) {
-            let constant_name = if enum_.name().is_some() {
-                if ctx.options().prepend_enum_name {
-                    format!("{}_{}", enum_canonical_name, variant_name)
-                } else {
-                    format!("{}", variant_name)
-                }
-            } else {
-                format!("{}", variant_name)
-            };
-            let constant_name = ctx.rust_ident(constant_name);
-
-            result.push(quote! {
-                pub const #constant_name : #enum_rust_ty =
-                    #enum_canonical_name :: #referenced_name ;
-            });
-        }
-
-        let repr = repr.to_rust_ty_or_opaque(ctx, item);
-
-        let mut builder = EnumBuilder::new(
-            &name,
-            attrs,
-            repr,
-            variation,
-            item.codegen_depth(ctx),
-        );
-
-        // A map where we keep a value -> variant relation.
-        let mut seen_values = HashMap::<_, Ident>::default();
-        let enum_rust_ty = item.to_rust_ty_or_opaque(ctx, &());
-        let is_toplevel = item.is_toplevel(ctx);
-
-        // Used to mangle the constants we generate in the unnamed-enum case.
-        let parent_canonical_name = if is_toplevel {
-            None
-        } else {
-            Some(item.parent_id().canonical_name(ctx))
-        };
-
-        let constant_mangling_prefix = if ctx.options().prepend_enum_name {
-            if enum_ty.name().is_none() {
-                parent_canonical_name.as_deref()
-            } else {
-                Some(&*name)
-            }
-        } else {
-            None
-        };
-
-        // NB: We defer the creation of constified variants, in case we find
-        // another variant with the same value (which is the common thing to
-        // do).
-        let mut constified_variants = VecDeque::new();
-
-        let mut iter = self.variants().iter().peekable();
-        while let Some(variant) =
-            iter.next().or_else(|| constified_variants.pop_front())
-        {
-            if variant.hidden() {
-                continue;
-            }
-
-            if variant.force_constification() && iter.peek().is_some() {
-                constified_variants.push_back(variant);
-                continue;
-            }
-
-            match seen_values.entry(variant.val()) {
-                Entry::Occupied(ref entry) => {
-                    if variation.is_rust() {
-                        let variant_name = ctx.rust_mangle(variant.name());
-                        let mangled_name =
-                            if is_toplevel || enum_ty.name().is_some() {
-                                variant_name
-                            } else {
-                                let parent_name =
-                                    parent_canonical_name.as_ref().unwrap();
-
-                                Cow::Owned(format!(
-                                    "{}_{}",
-                                    parent_name, variant_name
-                                ))
-                            };
-
-                        let existing_variant_name = entry.get();
-                        // Use associated constants for named enums.
-                        if enum_ty.name().is_some() &&
-                            ctx.options().rust_features().associated_const
-                        {
-                            let enum_canonical_name = &ident;
-                            let variant_name =
-                                ctx.rust_ident_raw(&*mangled_name);
-                            result.push(quote! {
-                                impl #enum_rust_ty {
-                                    pub const #variant_name : #enum_rust_ty =
-                                        #enum_canonical_name :: #existing_variant_name ;
-                                }
-                            });
-                        } else {
-                            add_constant(
-                                ctx,
-                                enum_ty,
-                                &ident,
-                                &Ident::new(&mangled_name, Span::call_site()),
-                                existing_variant_name,
-                                enum_rust_ty.clone(),
-                                result,
-                            );
-                        }
-                    } else {
-                        builder = builder.with_variant(
-                            ctx,
-                            variant,
-                            constant_mangling_prefix,
-                            enum_rust_ty.clone(),
-                            result,
-                            enum_ty.name().is_some(),
-                        );
-                    }
-                }
-                Entry::Vacant(entry) => {
-                    builder = builder.with_variant(
-                        ctx,
-                        variant,
-                        constant_mangling_prefix,
-                        enum_rust_ty.clone(),
-                        result,
-                        enum_ty.name().is_some(),
-                    );
-
-                    let variant_name = ctx.rust_ident(variant.name());
-
-                    // If it's an unnamed enum, or constification is enforced,
-                    // we also generate a constant so it can be properly
-                    // accessed.
-                    if (variation.is_rust() && enum_ty.name().is_none()) ||
-                        variant.force_constification()
-                    {
-                        let mangled_name = if is_toplevel {
-                            variant_name.clone()
-                        } else {
-                            let parent_name =
-                                parent_canonical_name.as_ref().unwrap();
-
-                            Ident::new(
-                                &format!("{}_{}", parent_name, variant_name),
-                                Span::call_site(),
-                            )
-                        };
-
-                        add_constant(
-                            ctx,
-                            enum_ty,
-                            &ident,
-                            &mangled_name,
-                            &variant_name,
-                            enum_rust_ty.clone(),
-                            result,
-                        );
-                    }
-
-                    entry.insert(variant_name);
-                }
-            }
-        }
-
-        let item = builder.build(ctx, enum_rust_ty, result);
-        result.push(item);
-    }
-}
-
-/// Enum for the default type of macro constants.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum MacroTypeVariation {
-    /// Use i32 or i64
-    Signed,
-    /// Use u32 or u64
-    Unsigned,
-}
-
-impl MacroTypeVariation {
-    /// Convert a `MacroTypeVariation` to its str representation.
-    pub fn as_str(&self) -> &str {
-        match self {
-            MacroTypeVariation::Signed => "signed",
-            MacroTypeVariation::Unsigned => "unsigned",
-        }
-    }
-}
-
-impl Default for MacroTypeVariation {
-    fn default() -> MacroTypeVariation {
-        MacroTypeVariation::Unsigned
-    }
-}
-
-impl std::str::FromStr for MacroTypeVariation {
-    type Err = std::io::Error;
-
-    /// Create a `MacroTypeVariation` from a string.
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "signed" => Ok(MacroTypeVariation::Signed),
-            "unsigned" => Ok(MacroTypeVariation::Unsigned),
-            _ => Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                concat!(
-                    "Got an invalid MacroTypeVariation. Accepted values ",
-                    "are 'signed' and 'unsigned'"
-                ),
-            )),
-        }
-    }
-}
-
-/// Enum for how aliases should be translated.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum AliasVariation {
-    /// Convert to regular Rust alias
-    TypeAlias,
-    /// Create a new type by wrapping the old type in a struct and using #[repr(transparent)]
-    NewType,
-    /// Same as NewStruct but also impl Deref to be able to use the methods of the wrapped type
-    NewTypeDeref,
-}
-
-impl AliasVariation {
-    /// Convert an `AliasVariation` to its str representation.
-    pub fn as_str(&self) -> &str {
-        match self {
-            AliasVariation::TypeAlias => "type_alias",
-            AliasVariation::NewType => "new_type",
-            AliasVariation::NewTypeDeref => "new_type_deref",
-        }
-    }
-}
-
-impl Default for AliasVariation {
-    fn default() -> AliasVariation {
-        AliasVariation::TypeAlias
-    }
-}
-
-impl std::str::FromStr for AliasVariation {
-    type Err = std::io::Error;
-
-    /// Create an `AliasVariation` from a string.
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "type_alias" => Ok(AliasVariation::TypeAlias),
-            "new_type" => Ok(AliasVariation::NewType),
-            "new_type_deref" => Ok(AliasVariation::NewTypeDeref),
-            _ => Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                concat!(
-                    "Got an invalid AliasVariation. Accepted values ",
-                    "are 'type_alias', 'new_type', and 'new_type_deref'"
-                ),
-            )),
-        }
-    }
-}
-
-/// Enum for how non-Copy unions should be translated.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum NonCopyUnionStyle {
-    /// Wrap members in a type generated by bindgen.
-    BindgenWrapper,
-    /// Wrap members in [`::core::mem::ManuallyDrop`].
-    ///
-    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
-    /// MSRV is lower.
-    ManuallyDrop,
-}
-
-impl NonCopyUnionStyle {
-    /// Convert an `NonCopyUnionStyle` to its str representation.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Self::BindgenWrapper => "bindgen_wrapper",
-            Self::ManuallyDrop => "manually_drop",
-        }
-    }
-}
-
-impl Default for NonCopyUnionStyle {
-    fn default() -> Self {
-        Self::BindgenWrapper
-    }
-}
-
-impl std::str::FromStr for NonCopyUnionStyle {
-    type Err = std::io::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "bindgen_wrapper" => Ok(Self::BindgenWrapper),
-            "manually_drop" => Ok(Self::ManuallyDrop),
-            _ => Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                concat!(
-                    "Got an invalid NonCopyUnionStyle. Accepted values ",
-                    "are 'bindgen_wrapper' and 'manually_drop'"
-                ),
-            )),
-        }
-    }
-}
-
-/// Fallible conversion to an opaque blob.
-///
-/// Implementors of this trait should provide the `try_get_layout` method to
-/// fallibly get this thing's layout, which the provided `try_to_opaque` trait
-/// method will use to convert the `Layout` into an opaque blob Rust type.
-trait TryToOpaque {
-    type Extra;
-
-    /// Get the layout for this thing, if one is available.
-    fn try_get_layout(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> error::Result<Layout>;
-
-    /// Do not override this provided trait method.
-    fn try_to_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> error::Result<proc_macro2::TokenStream> {
-        self.try_get_layout(ctx, extra)
-            .map(|layout| helpers::blob(ctx, layout))
-    }
-}
-
-/// Infallible conversion of an IR thing to an opaque blob.
-///
-/// The resulting layout is best effort, and is unfortunately not guaranteed to
-/// be correct. When all else fails, we fall back to a single byte layout as a
-/// last resort, because C++ does not permit zero-sized types. See the note in
-/// the `ToRustTyOrOpaque` doc comment about fallible versus infallible traits
-/// and when each is appropriate.
-///
-/// Don't implement this directly. Instead implement `TryToOpaque`, and then
-/// leverage the blanket impl for this trait.
-trait ToOpaque: TryToOpaque {
-    fn get_layout(&self, ctx: &BindgenContext, extra: &Self::Extra) -> Layout {
-        self.try_get_layout(ctx, extra)
-            .unwrap_or_else(|_| Layout::for_size(ctx, 1))
-    }
-
-    fn to_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> proc_macro2::TokenStream {
-        let layout = self.get_layout(ctx, extra);
-        helpers::blob(ctx, layout)
-    }
-}
-
-impl<T> ToOpaque for T where T: TryToOpaque {}
-
-/// Fallible conversion from an IR thing to an *equivalent* Rust type.
-///
-/// If the C/C++ construct represented by the IR thing cannot (currently) be
-/// represented in Rust (for example, instantiations of templates with
-/// const-value generic parameters) then the impl should return an `Err`. It
-/// should *not* attempt to return an opaque blob with the correct size and
-/// alignment. That is the responsibility of the `TryToOpaque` trait.
-trait TryToRustTy {
-    type Extra;
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> error::Result<proc_macro2::TokenStream>;
-}
-
-/// Fallible conversion to a Rust type or an opaque blob with the correct size
-/// and alignment.
-///
-/// Don't implement this directly. Instead implement `TryToRustTy` and
-/// `TryToOpaque`, and then leverage the blanket impl for this trait below.
-trait TryToRustTyOrOpaque: TryToRustTy + TryToOpaque {
-    type Extra;
-
-    fn try_to_rust_ty_or_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &<Self as TryToRustTyOrOpaque>::Extra,
-    ) -> error::Result<proc_macro2::TokenStream>;
-}
-
-impl<E, T> TryToRustTyOrOpaque for T
-where
-    T: TryToRustTy<Extra = E> + TryToOpaque<Extra = E>,
-{
-    type Extra = E;
-
-    fn try_to_rust_ty_or_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &E,
-    ) -> error::Result<proc_macro2::TokenStream> {
-        self.try_to_rust_ty(ctx, extra).or_else(|_| {
-            if let Ok(layout) = self.try_get_layout(ctx, extra) {
-                Ok(helpers::blob(ctx, layout))
-            } else {
-                Err(error::Error::NoLayoutForOpaqueBlob)
-            }
-        })
-    }
-}
-
-/// Infallible conversion to a Rust type, or an opaque blob with a best effort
-/// of correct size and alignment.
-///
-/// Don't implement this directly. Instead implement `TryToRustTy` and
-/// `TryToOpaque`, and then leverage the blanket impl for this trait below.
-///
-/// ### Fallible vs. Infallible Conversions to Rust Types
-///
-/// When should one use this infallible `ToRustTyOrOpaque` trait versus the
-/// fallible `TryTo{RustTy, Opaque, RustTyOrOpaque}` triats? All fallible trait
-/// implementations that need to convert another thing into a Rust type or
-/// opaque blob in a nested manner should also use fallible trait methods and
-/// propagate failure up the stack. Only infallible functions and methods like
-/// CodeGenerator implementations should use the infallible
-/// `ToRustTyOrOpaque`. The further out we push error recovery, the more likely
-/// we are to get a usable `Layout` even if we can't generate an equivalent Rust
-/// type for a C++ construct.
-trait ToRustTyOrOpaque: TryToRustTy + ToOpaque {
-    type Extra;
-
-    fn to_rust_ty_or_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &<Self as ToRustTyOrOpaque>::Extra,
-    ) -> proc_macro2::TokenStream;
-}
-
-impl<E, T> ToRustTyOrOpaque for T
-where
-    T: TryToRustTy<Extra = E> + ToOpaque<Extra = E>,
-{
-    type Extra = E;
-
-    fn to_rust_ty_or_opaque(
-        &self,
-        ctx: &BindgenContext,
-        extra: &E,
-    ) -> proc_macro2::TokenStream {
-        self.try_to_rust_ty(ctx, extra)
-            .unwrap_or_else(|_| self.to_opaque(ctx, extra))
-    }
-}
-
-impl<T> TryToOpaque for T
-where
-    T: Copy + Into<ItemId>,
-{
-    type Extra = ();
-
-    fn try_get_layout(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<Layout> {
-        ctx.resolve_item((*self).into()).try_get_layout(ctx, &())
-    }
-}
-
-impl<T> TryToRustTy for T
-where
-    T: Copy + Into<ItemId>,
-{
-    type Extra = ();
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<proc_macro2::TokenStream> {
-        ctx.resolve_item((*self).into()).try_to_rust_ty(ctx, &())
-    }
-}
-
-impl TryToOpaque for Item {
-    type Extra = ();
-
-    fn try_get_layout(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<Layout> {
-        self.kind().expect_type().try_get_layout(ctx, self)
-    }
-}
-
-impl TryToRustTy for Item {
-    type Extra = ();
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<proc_macro2::TokenStream> {
-        self.kind().expect_type().try_to_rust_ty(ctx, self)
-    }
-}
-
-impl TryToOpaque for Type {
-    type Extra = Item;
-
-    fn try_get_layout(
-        &self,
-        ctx: &BindgenContext,
-        _: &Item,
-    ) -> error::Result<Layout> {
-        self.layout(ctx).ok_or(error::Error::NoLayoutForOpaqueBlob)
-    }
-}
-
-impl TryToRustTy for Type {
-    type Extra = Item;
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> error::Result<proc_macro2::TokenStream> {
-        use self::helpers::ast_ty::*;
-
-        match *self.kind() {
-            TypeKind::Void => Ok(c_void(ctx)),
-            // TODO: we should do something smart with nullptr, or maybe *const
-            // c_void is enough?
-            TypeKind::NullPtr => Ok(c_void(ctx).to_ptr(true)),
-            TypeKind::Int(ik) => {
-                match ik {
-                    IntKind::Bool => Ok(quote! { bool }),
-                    IntKind::Char { .. } => Ok(raw_type(ctx, "c_char")),
-                    IntKind::SChar => Ok(raw_type(ctx, "c_schar")),
-                    IntKind::UChar => Ok(raw_type(ctx, "c_uchar")),
-                    IntKind::Short => Ok(raw_type(ctx, "c_short")),
-                    IntKind::UShort => Ok(raw_type(ctx, "c_ushort")),
-                    IntKind::Int => Ok(raw_type(ctx, "c_int")),
-                    IntKind::UInt => Ok(raw_type(ctx, "c_uint")),
-                    IntKind::Long => Ok(raw_type(ctx, "c_long")),
-                    IntKind::ULong => Ok(raw_type(ctx, "c_ulong")),
-                    IntKind::LongLong => Ok(raw_type(ctx, "c_longlong")),
-                    IntKind::ULongLong => Ok(raw_type(ctx, "c_ulonglong")),
-                    IntKind::WChar => {
-                        let layout = self
-                            .layout(ctx)
-                            .expect("Couldn't compute wchar_t's layout?");
-                        let ty = Layout::known_type_for_size(ctx, layout.size)
-                            .expect("Non-representable wchar_t?");
-                        let ident = ctx.rust_ident_raw(ty);
-                        Ok(quote! { #ident })
-                    }
-
-                    IntKind::I8 => Ok(quote! { i8 }),
-                    IntKind::U8 => Ok(quote! { u8 }),
-                    IntKind::I16 => Ok(quote! { i16 }),
-                    IntKind::U16 => Ok(quote! { u16 }),
-                    IntKind::I32 => Ok(quote! { i32 }),
-                    IntKind::U32 => Ok(quote! { u32 }),
-                    IntKind::I64 => Ok(quote! { i64 }),
-                    IntKind::U64 => Ok(quote! { u64 }),
-                    IntKind::Custom { name, .. } => {
-                        Ok(proc_macro2::TokenStream::from_str(name).unwrap())
-                    }
-                    IntKind::U128 => {
-                        Ok(if ctx.options().rust_features.i128_and_u128 {
-                            quote! { u128 }
-                        } else {
-                            // Best effort thing, but wrong alignment
-                            // unfortunately.
-                            quote! { [u64; 2] }
-                        })
-                    }
-                    IntKind::I128 => {
-                        Ok(if ctx.options().rust_features.i128_and_u128 {
-                            quote! { i128 }
-                        } else {
-                            quote! { [u64; 2] }
-                        })
-                    }
-                }
-            }
-            TypeKind::Float(fk) => {
-                Ok(float_kind_rust_type(ctx, fk, self.layout(ctx)))
-            }
-            TypeKind::Complex(fk) => {
-                let float_path =
-                    float_kind_rust_type(ctx, fk, self.layout(ctx));
-
-                ctx.generated_bindgen_complex();
-                Ok(if ctx.options().enable_cxx_namespaces {
-                    quote! {
-                        root::__BindgenComplex<#float_path>
-                    }
-                } else {
-                    quote! {
-                        __BindgenComplex<#float_path>
-                    }
-                })
-            }
-            TypeKind::Function(ref fs) => {
-                // We can't rely on the sizeof(Option<NonZero<_>>) ==
-                // sizeof(NonZero<_>) optimization with opaque blobs (because
-                // they aren't NonZero), so don't *ever* use an or_opaque
-                // variant here.
-                let ty = fs.try_to_rust_ty(ctx, &())?;
-
-                let prefix = ctx.trait_prefix();
-                Ok(quote! {
-                    ::#prefix::option::Option<#ty>
-                })
-            }
-            TypeKind::Array(item, len) | TypeKind::Vector(item, len) => {
-                let ty = item.try_to_rust_ty(ctx, &())?;
-                Ok(quote! {
-                    [ #ty ; #len ]
-                })
-            }
-            TypeKind::Enum(..) => {
-                let path = item.namespace_aware_canonical_path(ctx);
-                let path = proc_macro2::TokenStream::from_str(&path.join("::"))
-                    .unwrap();
-                Ok(quote!(#path))
-            }
-            TypeKind::TemplateInstantiation(ref inst) => {
-                inst.try_to_rust_ty(ctx, item)
-            }
-            TypeKind::ResolvedTypeRef(inner) => inner.try_to_rust_ty(ctx, &()),
-            TypeKind::TemplateAlias(..) |
-            TypeKind::Alias(..) |
-            TypeKind::BlockPointer(..) => {
-                if self.is_block_pointer() && !ctx.options().generate_block {
-                    let void = c_void(ctx);
-                    return Ok(void.to_ptr(/* is_const = */ false));
-                }
-
-                if item.is_opaque(ctx, &()) &&
-                    item.used_template_params(ctx)
-                        .into_iter()
-                        .any(|param| param.is_template_param(ctx, &()))
-                {
-                    self.try_to_opaque(ctx, item)
-                } else if let Some(ty) = self
-                    .name()
-                    .and_then(|name| utils::type_from_named(ctx, name))
-                {
-                    Ok(ty)
-                } else {
-                    utils::build_path(item, ctx)
-                }
-            }
-            TypeKind::Comp(ref info) => {
-                let template_params = item.all_template_params(ctx);
-                if info.has_non_type_template_params() ||
-                    (item.is_opaque(ctx, &()) && !template_params.is_empty())
-                {
-                    return self.try_to_opaque(ctx, item);
-                }
-
-                utils::build_path(item, ctx)
-            }
-            TypeKind::Opaque => self.try_to_opaque(ctx, item),
-            TypeKind::Pointer(inner) | TypeKind::Reference(inner) => {
-                let is_const = ctx.resolve_type(inner).is_const();
-
-                let inner =
-                    inner.into_resolver().through_type_refs().resolve(ctx);
-                let inner_ty = inner.expect_type();
-
-                let is_objc_pointer =
-                    matches!(inner_ty.kind(), TypeKind::ObjCInterface(..));
-
-                // Regardless if we can properly represent the inner type, we
-                // should always generate a proper pointer here, so use
-                // infallible conversion of the inner type.
-                let mut ty = inner.to_rust_ty_or_opaque(ctx, &());
-                ty.append_implicit_template_params(ctx, inner);
-
-                // Avoid the first function pointer level, since it's already
-                // represented in Rust.
-                if inner_ty.canonical_type(ctx).is_function() || is_objc_pointer
-                {
-                    Ok(ty)
-                } else {
-                    Ok(ty.to_ptr(is_const))
-                }
-            }
-            TypeKind::TypeParam => {
-                let name = item.canonical_name(ctx);
-                let ident = ctx.rust_ident(&name);
-                Ok(quote! {
-                    #ident
-                })
-            }
-            TypeKind::ObjCSel => Ok(quote! {
-                objc::runtime::Sel
-            }),
-            TypeKind::ObjCId => Ok(quote! {
-                id
-            }),
-            TypeKind::ObjCInterface(ref interface) => {
-                let name = ctx.rust_ident(interface.name());
-                Ok(quote! {
-                    #name
-                })
-            }
-            ref u @ TypeKind::UnresolvedTypeRef(..) => {
-                unreachable!("Should have been resolved after parsing {:?}!", u)
-            }
-        }
-    }
-}
-
-impl TryToOpaque for TemplateInstantiation {
-    type Extra = Item;
-
-    fn try_get_layout(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> error::Result<Layout> {
-        item.expect_type()
-            .layout(ctx)
-            .ok_or(error::Error::NoLayoutForOpaqueBlob)
-    }
-}
-
-impl TryToRustTy for TemplateInstantiation {
-    type Extra = Item;
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> error::Result<proc_macro2::TokenStream> {
-        if self.is_opaque(ctx, item) {
-            return Err(error::Error::InstantiationOfOpaqueType);
-        }
-
-        let def = self
-            .template_definition()
-            .into_resolver()
-            .through_type_refs()
-            .resolve(ctx);
-
-        let mut ty = quote! {};
-        let def_path = def.namespace_aware_canonical_path(ctx);
-        ty.append_separated(
-            def_path.into_iter().map(|p| ctx.rust_ident(p)),
-            quote!(::),
-        );
-
-        let def_params = def.self_template_params(ctx);
-        if def_params.is_empty() {
-            // This can happen if we generated an opaque type for a partial
-            // template specialization, and we've hit an instantiation of
-            // that partial specialization.
-            extra_assert!(def.is_opaque(ctx, &()));
-            return Err(error::Error::InstantiationOfOpaqueType);
-        }
-
-        // TODO: If the definition type is a template class/struct
-        // definition's member template definition, it could rely on
-        // generic template parameters from its outer template
-        // class/struct. When we emit bindings for it, it could require
-        // *more* type arguments than we have here, and we will need to
-        // reconstruct them somehow. We don't have any means of doing
-        // that reconstruction at this time.
-
-        let template_args = self
-            .template_arguments()
-            .iter()
-            .zip(def_params.iter())
-            // Only pass type arguments for the type parameters that
-            // the def uses.
-            .filter(|&(_, param)| ctx.uses_template_parameter(def.id(), *param))
-            .map(|(arg, _)| {
-                let arg = arg.into_resolver().through_type_refs().resolve(ctx);
-                let mut ty = arg.try_to_rust_ty(ctx, &())?;
-                ty.append_implicit_template_params(ctx, arg);
-                Ok(ty)
-            })
-            .collect::<error::Result<Vec<_>>>()?;
-
-        if template_args.is_empty() {
-            return Ok(ty);
-        }
-
-        Ok(quote! {
-            #ty < #( #template_args ),* >
-        })
-    }
-}
-
-impl TryToRustTy for FunctionSig {
-    type Extra = ();
-
-    fn try_to_rust_ty(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> error::Result<proc_macro2::TokenStream> {
-        // TODO: we might want to consider ignoring the reference return value.
-        let ret = utils::fnsig_return_ty(ctx, self);
-        let arguments = utils::fnsig_arguments(ctx, self);
-        let abi = self.abi();
-
-        match abi {
-            Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => {
-                warn!("Skipping function with thiscall ABI that isn't supported by the configured Rust target");
-                Ok(proc_macro2::TokenStream::new())
-            }
-            Abi::Vectorcall
-                if !ctx.options().rust_features().vectorcall_abi =>
-            {
-                warn!("Skipping function with vectorcall ABI that isn't supported by the configured Rust target");
-                Ok(proc_macro2::TokenStream::new())
-            }
-            _ => Ok(quote! {
-                unsafe extern #abi fn ( #( #arguments ),* ) #ret
-            }),
-        }
-    }
-}
-
-impl CodeGenerator for Function {
-    type Extra = Item;
-
-    /// If we've actually generated the symbol, the number of times we've seen
-    /// it.
-    type Return = Option<u32>;
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) -> Self::Return {
-        debug!("<Function as CodeGenerator>::codegen: item = {:?}", item);
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        // We can't currently do anything with Internal functions so just
-        // avoid generating anything for them.
-        match self.linkage() {
-            Linkage::Internal => return None,
-            Linkage::External => {}
-        }
-
-        // Pure virtual methods have no actual symbol, so we can't generate
-        // something meaningful for them.
-        let is_dynamic_function = match self.kind() {
-            FunctionKind::Method(ref method_kind)
-                if method_kind.is_pure_virtual() =>
-            {
-                return None;
-            }
-            FunctionKind::Function => {
-                ctx.options().dynamic_library_name.is_some()
-            }
-            _ => false,
-        };
-
-        // Similar to static member variables in a class template, we can't
-        // generate bindings to template functions, because the set of
-        // instantiations is open ended and we have no way of knowing which
-        // monomorphizations actually exist.
-        if !item.all_template_params(ctx).is_empty() {
-            return None;
-        }
-
-        let name = self.name();
-        let mut canonical_name = item.canonical_name(ctx);
-        let mangled_name = self.mangled_name();
-
-        {
-            let seen_symbol_name = mangled_name.unwrap_or(&canonical_name);
-
-            // TODO: Maybe warn here if there's a type/argument mismatch, or
-            // something?
-            if result.seen_function(seen_symbol_name) {
-                return None;
-            }
-            result.saw_function(seen_symbol_name);
-        }
-
-        let signature_item = ctx.resolve_item(self.signature());
-        let signature = signature_item.kind().expect_type().canonical_type(ctx);
-        let signature = match *signature.kind() {
-            TypeKind::Function(ref sig) => sig,
-            _ => panic!("Signature kind is not a Function: {:?}", signature),
-        };
-
-        let args = utils::fnsig_arguments(ctx, signature);
-        let ret = utils::fnsig_return_ty(ctx, signature);
-
-        let mut attributes = vec![];
-
-        if ctx.options().rust_features().must_use_function {
-            let must_use = signature.must_use() || {
-                let ret_ty = signature
-                    .return_type()
-                    .into_resolver()
-                    .through_type_refs()
-                    .resolve(ctx);
-                ret_ty.must_use(ctx)
-            };
-
-            if must_use {
-                attributes.push(attributes::must_use());
-            }
-        }
-
-        if let Some(comment) = item.comment(ctx) {
-            attributes.push(attributes::doc(comment));
-        }
-
-        let abi = match signature.abi() {
-            Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => {
-                warn!("Skipping function with thiscall ABI that isn't supported by the configured Rust target");
-                return None;
-            }
-            Abi::Vectorcall
-                if !ctx.options().rust_features().vectorcall_abi =>
-            {
-                warn!("Skipping function with vectorcall ABI that isn't supported by the configured Rust target");
-                return None;
-            }
-            Abi::Win64 if signature.is_variadic() => {
-                warn!("Skipping variadic function with Win64 ABI that isn't supported");
-                return None;
-            }
-            Abi::Unknown(unknown_abi) => {
-                panic!(
-                    "Invalid or unknown abi {:?} for function {:?} ({:?})",
-                    unknown_abi, canonical_name, self
-                );
-            }
-            abi => abi,
-        };
-
-        // Handle overloaded functions by giving each overload its own unique
-        // suffix.
-        let times_seen = result.overload_number(&canonical_name);
-        if times_seen > 0 {
-            write!(&mut canonical_name, "{}", times_seen).unwrap();
-        }
-
-        let link_name = mangled_name.unwrap_or(name);
-        if !is_dynamic_function &&
-            !utils::names_will_be_identical_after_mangling(
-                &canonical_name,
-                link_name,
-                Some(abi),
-            )
-        {
-            attributes.push(attributes::link_name(link_name));
-        }
-
-        // Unfortunately this can't piggyback on the `attributes` list because
-        // the #[link(wasm_import_module)] needs to happen before the `extern
-        // "C"` block. It doesn't get picked up properly otherwise
-        let wasm_link_attribute =
-            ctx.options().wasm_import_module_name.as_ref().map(|name| {
-                quote! { #[link(wasm_import_module = #name)] }
-            });
-
-        let ident = ctx.rust_ident(canonical_name);
-        let tokens = quote! {
-            #wasm_link_attribute
-            extern #abi {
-                #(#attributes)*
-                pub fn #ident ( #( #args ),* ) #ret;
-            }
-        };
-
-        // If we're doing dynamic binding generation, add to the dynamic items.
-        if is_dynamic_function {
-            let args_identifiers =
-                utils::fnsig_argument_identifiers(ctx, signature);
-            let return_item = ctx.resolve_item(signature.return_type());
-            let ret_ty = match *return_item.kind().expect_type().kind() {
-                TypeKind::Void => quote! {()},
-                _ => return_item.to_rust_ty_or_opaque(ctx, &()),
-            };
-            result.dynamic_items().push(
-                ident,
-                abi,
-                signature.is_variadic(),
-                ctx.options().dynamic_link_require_all,
-                args,
-                args_identifiers,
-                ret,
-                ret_ty,
-                attributes,
-            );
-        } else {
-            result.push(tokens);
-        }
-        Some(times_seen)
-    }
-}
-
-fn objc_method_codegen(
-    ctx: &BindgenContext,
-    method: &ObjCMethod,
-    methods: &mut Vec<proc_macro2::TokenStream>,
-    class_name: Option<&str>,
-    rust_class_name: &str,
-    prefix: &str,
-) {
-    // This would ideally resolve the method into an Item, and use
-    // Item::process_before_codegen; however, ObjC methods are not currently
-    // made into function items.
-    let name = format!("{}::{}{}", rust_class_name, prefix, method.rust_name());
-    if ctx.options().blocklisted_items.matches(name) {
-        return;
-    }
-
-    let signature = method.signature();
-    let fn_args = utils::fnsig_arguments(ctx, signature);
-    let fn_ret = utils::fnsig_return_ty(ctx, signature);
-
-    let sig = if method.is_class_method() {
-        let fn_args = fn_args.clone();
-        quote! {
-            ( #( #fn_args ),* ) #fn_ret
-        }
-    } else {
-        let fn_args = fn_args.clone();
-        let args = iter::once(quote! { &self }).chain(fn_args.into_iter());
-        quote! {
-            ( #( #args ),* ) #fn_ret
-        }
-    };
-
-    let methods_and_args = method.format_method_call(&fn_args);
-
-    let body = if method.is_class_method() {
-        let class_name = ctx.rust_ident(
-            class_name.expect("Generating a class method without class name?"),
-        );
-        quote! {
-            msg_send!(class!(#class_name), #methods_and_args)
-        }
-    } else {
-        quote! {
-            msg_send!(*self, #methods_and_args)
-        }
-    };
-
-    let method_name =
-        ctx.rust_ident(format!("{}{}", prefix, method.rust_name()));
-
-    methods.push(quote! {
-        unsafe fn #method_name #sig where <Self as std::ops::Deref>::Target: objc::Message + Sized {
-            #body
-        }
-    });
-}
-
-impl CodeGenerator for ObjCInterface {
-    type Extra = Item;
-    type Return = ();
-
-    fn codegen<'a>(
-        &self,
-        ctx: &BindgenContext,
-        result: &mut CodegenResult<'a>,
-        item: &Item,
-    ) {
-        debug_assert!(item.is_enabled_for_codegen(ctx));
-
-        let mut impl_items = vec![];
-        let rust_class_name = item.path_for_allowlisting(ctx)[1..].join("::");
-
-        for method in self.methods() {
-            objc_method_codegen(
-                ctx,
-                method,
-                &mut impl_items,
-                None,
-                &rust_class_name,
-                "",
-            );
-        }
-
-        for class_method in self.class_methods() {
-            let ambiquity = self
-                .methods()
-                .iter()
-                .map(|m| m.rust_name())
-                .any(|x| x == class_method.rust_name());
-            let prefix = if ambiquity { "class_" } else { "" };
-            objc_method_codegen(
-                ctx,
-                class_method,
-                &mut impl_items,
-                Some(self.name()),
-                &rust_class_name,
-                prefix,
-            );
-        }
-
-        let trait_name = ctx.rust_ident(self.rust_name());
-        let trait_constraints = quote! {
-            Sized + std::ops::Deref
-        };
-        let trait_block = if self.is_template() {
-            let template_names: Vec<Ident> = self
-                .template_names
-                .iter()
-                .map(|g| ctx.rust_ident(g))
-                .collect();
-
-            quote! {
-                pub trait #trait_name <#(#template_names:'static),*> : #trait_constraints {
-                    #( #impl_items )*
-                }
-            }
-        } else {
-            quote! {
-                pub trait #trait_name : #trait_constraints {
-                    #( #impl_items )*
-                }
-            }
-        };
-
-        let class_name = ctx.rust_ident(self.name());
-        if !self.is_category() && !self.is_protocol() {
-            let struct_block = quote! {
-                #[repr(transparent)]
-                #[derive(Debug, Copy, Clone)]
-                pub struct #class_name(pub id);
-                impl std::ops::Deref for #class_name {
-                    type Target = objc::runtime::Object;
-                    fn deref(&self) -> &Self::Target {
-                        unsafe {
-                            &*self.0
-                        }
-                    }
-                }
-                unsafe impl objc::Message for #class_name { }
-                impl #class_name {
-                    pub fn alloc() -> Self {
-                        Self(unsafe {
-                            msg_send!(class!(#class_name), alloc)
-                        })
-                    }
-                }
-            };
-            result.push(struct_block);
-            let mut protocol_set: HashSet<ItemId> = Default::default();
-            for protocol_id in self.conforms_to.iter() {
-                protocol_set.insert(*protocol_id);
-                let protocol_name = ctx.rust_ident(
-                    ctx.resolve_type(protocol_id.expect_type_id(ctx))
-                        .name()
-                        .unwrap(),
-                );
-                let impl_trait = quote! {
-                    impl #protocol_name for #class_name { }
-                };
-                result.push(impl_trait);
-            }
-            let mut parent_class = self.parent_class;
-            while let Some(parent_id) = parent_class {
-                let parent = parent_id
-                    .expect_type_id(ctx)
-                    .into_resolver()
-                    .through_type_refs()
-                    .resolve(ctx)
-                    .expect_type()
-                    .kind();
-
-                let parent = match parent {
-                    TypeKind::ObjCInterface(ref parent) => parent,
-                    _ => break,
-                };
-                parent_class = parent.parent_class;
-
-                let parent_name = ctx.rust_ident(parent.rust_name());
-                let impl_trait = if parent.is_template() {
-                    let template_names: Vec<Ident> = parent
-                        .template_names
-                        .iter()
-                        .map(|g| ctx.rust_ident(g))
-                        .collect();
-                    quote! {
-                        impl <#(#template_names :'static),*> #parent_name <#(#template_names),*> for #class_name {
-                        }
-                    }
-                } else {
-                    quote! {
-                        impl #parent_name for #class_name { }
-                    }
-                };
-                result.push(impl_trait);
-                for protocol_id in parent.conforms_to.iter() {
-                    if protocol_set.insert(*protocol_id) {
-                        let protocol_name = ctx.rust_ident(
-                            ctx.resolve_type(protocol_id.expect_type_id(ctx))
-                                .name()
-                                .unwrap(),
-                        );
-                        let impl_trait = quote! {
-                            impl #protocol_name for #class_name { }
-                        };
-                        result.push(impl_trait);
-                    }
-                }
-                if !parent.is_template() {
-                    let parent_struct_name = parent.name();
-                    let child_struct_name = self.name();
-                    let parent_struct = ctx.rust_ident(parent_struct_name);
-                    let from_block = quote! {
-                        impl From<#class_name> for #parent_struct {
-                            fn from(child: #class_name) -> #parent_struct {
-                                #parent_struct(child.0)
-                            }
-                        }
-                    };
-                    result.push(from_block);
-
-                    let error_msg = format!(
-                        "This {} cannot be downcasted to {}",
-                        parent_struct_name, child_struct_name
-                    );
-                    let try_into_block = quote! {
-                        impl std::convert::TryFrom<#parent_struct> for #class_name {
-                            type Error = &'static str;
-                            fn try_from(parent: #parent_struct) -> Result<#class_name, Self::Error> {
-                                let is_kind_of : bool = unsafe { msg_send!(parent, isKindOfClass:class!(#class_name))};
-                                if is_kind_of {
-                                    Ok(#class_name(parent.0))
-                                } else {
-                                    Err(#error_msg)
-                                }
-                            }
-                        }
-                    };
-                    result.push(try_into_block);
-                }
-            }
-        }
-
-        if !self.is_protocol() {
-            let impl_block = if self.is_template() {
-                let template_names: Vec<Ident> = self
-                    .template_names
-                    .iter()
-                    .map(|g| ctx.rust_ident(g))
-                    .collect();
-                quote! {
-                    impl <#(#template_names :'static),*> #trait_name <#(#template_names),*> for #class_name {
-                    }
-                }
-            } else {
-                quote! {
-                    impl #trait_name for #class_name {
-                    }
-                }
-            };
-            result.push(impl_block);
-        }
-
-        result.push(trait_block);
-        result.saw_objc();
-    }
-}
-
-pub(crate) fn codegen(
-    context: BindgenContext,
-) -> (proc_macro2::TokenStream, BindgenOptions, Vec<String>) {
-    context.gen(|context| {
-        let _t = context.timer("codegen");
-        let counter = Cell::new(0);
-        let mut result = CodegenResult::new(&counter);
-
-        debug!("codegen: {:?}", context.options());
-
-        if context.options().emit_ir {
-            let codegen_items = context.codegen_items();
-            for (id, item) in context.items() {
-                if codegen_items.contains(&id) {
-                    println!("ir: {:?} = {:#?}", id, item);
-                }
-            }
-        }
-
-        if let Some(path) = context.options().emit_ir_graphviz.as_ref() {
-            match dot::write_dot_file(context, path) {
-                Ok(()) => info!(
-                    "Your dot file was generated successfully into: {}",
-                    path
-                ),
-                Err(e) => warn!("{}", e),
-            }
-        }
-
-        if let Some(spec) = context.options().depfile.as_ref() {
-            match spec.write(context.deps()) {
-                Ok(()) => info!(
-                    "Your depfile was generated successfully into: {}",
-                    spec.depfile_path.display()
-                ),
-                Err(e) => warn!("{}", e),
-            }
-        }
-
-        context.resolve_item(context.root_module()).codegen(
-            context,
-            &mut result,
-            &(),
-        );
-
-        if let Some(ref lib_name) = context.options().dynamic_library_name {
-            let lib_ident = context.rust_ident(lib_name);
-            let dynamic_items_tokens =
-                result.dynamic_items().get_tokens(lib_ident);
-            result.push(dynamic_items_tokens);
-        }
-
-        postprocessing::postprocessing(result.items, context.options())
-    })
-}
-
-pub mod utils {
-    use super::{error, ToRustTyOrOpaque};
-    use crate::ir::context::BindgenContext;
-    use crate::ir::function::{Abi, FunctionSig};
-    use crate::ir::item::{Item, ItemCanonicalPath};
-    use crate::ir::ty::TypeKind;
-    use proc_macro2;
-    use std::borrow::Cow;
-    use std::mem;
-    use std::str::FromStr;
-
-    pub fn prepend_bitfield_unit_type(
-        ctx: &BindgenContext,
-        result: &mut Vec<proc_macro2::TokenStream>,
-    ) {
-        let bitfield_unit_src = include_str!("./bitfield_unit.rs");
-        let bitfield_unit_src = if ctx.options().rust_features().min_const_fn {
-            Cow::Borrowed(bitfield_unit_src)
-        } else {
-            Cow::Owned(bitfield_unit_src.replace("const fn ", "fn "))
-        };
-        let bitfield_unit_type =
-            proc_macro2::TokenStream::from_str(&bitfield_unit_src).unwrap();
-        let bitfield_unit_type = quote!(#bitfield_unit_type);
-
-        let items = vec![bitfield_unit_type];
-        let old_items = mem::replace(result, items);
-        result.extend(old_items);
-    }
-
-    pub fn prepend_objc_header(
-        ctx: &BindgenContext,
-        result: &mut Vec<proc_macro2::TokenStream>,
-    ) {
-        let use_objc = if ctx.options().objc_extern_crate {
-            quote! {
-                #[macro_use]
-                extern crate objc;
-            }
-        } else {
-            quote! {
-                use objc::{self, msg_send, sel, sel_impl, class};
-            }
-        };
-
-        let id_type = quote! {
-            #[allow(non_camel_case_types)]
-            pub type id = *mut objc::runtime::Object;
-        };
-
-        let items = vec![use_objc, id_type];
-        let old_items = mem::replace(result, items);
-        result.extend(old_items.into_iter());
-    }
-
-    pub fn prepend_block_header(
-        ctx: &BindgenContext,
-        result: &mut Vec<proc_macro2::TokenStream>,
-    ) {
-        let use_block = if ctx.options().block_extern_crate {
-            quote! {
-                extern crate block;
-            }
-        } else {
-            quote! {
-                use block;
-            }
-        };
-
-        let items = vec![use_block];
-        let old_items = mem::replace(result, items);
-        result.extend(old_items.into_iter());
-    }
-
-    pub fn prepend_union_types(
-        ctx: &BindgenContext,
-        result: &mut Vec<proc_macro2::TokenStream>,
-    ) {
-        let prefix = ctx.trait_prefix();
-
-        // If the target supports `const fn`, declare eligible functions
-        // as `const fn` else just `fn`.
-        let const_fn = if ctx.options().rust_features().min_const_fn {
-            quote! { const fn }
-        } else {
-            quote! { fn }
-        };
-
-        // TODO(emilio): The fmt::Debug impl could be way nicer with
-        // std::intrinsics::type_name, but...
-        let union_field_decl = quote! {
-            #[repr(C)]
-            pub struct __BindgenUnionField<T>(::#prefix::marker::PhantomData<T>);
-        };
-
-        let union_field_impl = quote! {
-            impl<T> __BindgenUnionField<T> {
-                #[inline]
-                pub #const_fn new() -> Self {
-                    __BindgenUnionField(::#prefix::marker::PhantomData)
-                }
-
-                #[inline]
-                pub unsafe fn as_ref(&self) -> &T {
-                    ::#prefix::mem::transmute(self)
-                }
-
-                #[inline]
-                pub unsafe fn as_mut(&mut self) -> &mut T {
-                    ::#prefix::mem::transmute(self)
-                }
-            }
-        };
-
-        let union_field_default_impl = quote! {
-            impl<T> ::#prefix::default::Default for __BindgenUnionField<T> {
-                #[inline]
-                fn default() -> Self {
-                    Self::new()
-                }
-            }
-        };
-
-        let union_field_clone_impl = quote! {
-            impl<T> ::#prefix::clone::Clone for __BindgenUnionField<T> {
-                #[inline]
-                fn clone(&self) -> Self {
-                    Self::new()
-                }
-            }
-        };
-
-        let union_field_copy_impl = quote! {
-            impl<T> ::#prefix::marker::Copy for __BindgenUnionField<T> {}
-        };
-
-        let union_field_debug_impl = quote! {
-            impl<T> ::#prefix::fmt::Debug for __BindgenUnionField<T> {
-                fn fmt(&self, fmt: &mut ::#prefix::fmt::Formatter<'_>)
-                       -> ::#prefix::fmt::Result {
-                    fmt.write_str("__BindgenUnionField")
-                }
-            }
-        };
-
-        // The actual memory of the filed will be hashed, so that's why these
-        // field doesn't do anything with the hash.
-        let union_field_hash_impl = quote! {
-            impl<T> ::#prefix::hash::Hash for __BindgenUnionField<T> {
-                fn hash<H: ::#prefix::hash::Hasher>(&self, _state: &mut H) {
-                }
-            }
-        };
-
-        let union_field_partialeq_impl = quote! {
-            impl<T> ::#prefix::cmp::PartialEq for __BindgenUnionField<T> {
-               fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-                   true
-               }
-           }
-        };
-
-        let union_field_eq_impl = quote! {
-           impl<T> ::#prefix::cmp::Eq for __BindgenUnionField<T> {
-           }
-        };
-
-        let items = vec![
-            union_field_decl,
-            union_field_impl,
-            union_field_default_impl,
-            union_field_clone_impl,
-            union_field_copy_impl,
-            union_field_debug_impl,
-            union_field_hash_impl,
-            union_field_partialeq_impl,
-            union_field_eq_impl,
-        ];
-
-        let old_items = mem::replace(result, items);
-        result.extend(old_items.into_iter());
-    }
-
-    pub fn prepend_incomplete_array_types(
-        ctx: &BindgenContext,
-        result: &mut Vec<proc_macro2::TokenStream>,
-    ) {
-        let prefix = ctx.trait_prefix();
-
-        // If the target supports `const fn`, declare eligible functions
-        // as `const fn` else just `fn`.
-        let const_fn = if ctx.options().rust_features().min_const_fn {
-            quote! { const fn }
-        } else {
-            quote! { fn }
-        };
-
-        let incomplete_array_decl = quote! {
-            #[repr(C)]
-            #[derive(Default)]
-            pub struct __IncompleteArrayField<T>(
-                ::#prefix::marker::PhantomData<T>, [T; 0]);
-        };
-
-        let incomplete_array_impl = quote! {
-            impl<T> __IncompleteArrayField<T> {
-                #[inline]
-                pub #const_fn new() -> Self {
-                    __IncompleteArrayField(::#prefix::marker::PhantomData, [])
-                }
-
-                #[inline]
-                pub fn as_ptr(&self) -> *const T {
-                    self as *const _ as *const T
-                }
-
-                #[inline]
-                pub fn as_mut_ptr(&mut self) -> *mut T {
-                    self as *mut _ as *mut T
-                }
-
-                #[inline]
-                pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-                    ::#prefix::slice::from_raw_parts(self.as_ptr(), len)
-                }
-
-                #[inline]
-                pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-                    ::#prefix::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-                }
-            }
-        };
-
-        let incomplete_array_debug_impl = quote! {
-            impl<T> ::#prefix::fmt::Debug for __IncompleteArrayField<T> {
-                fn fmt(&self, fmt: &mut ::#prefix::fmt::Formatter<'_>)
-                       -> ::#prefix::fmt::Result {
-                    fmt.write_str("__IncompleteArrayField")
-                }
-            }
-        };
-
-        let items = vec![
-            incomplete_array_decl,
-            incomplete_array_impl,
-            incomplete_array_debug_impl,
-        ];
-
-        let old_items = mem::replace(result, items);
-        result.extend(old_items.into_iter());
-    }
-
-    pub fn prepend_complex_type(result: &mut Vec<proc_macro2::TokenStream>) {
-        let complex_type = quote! {
-            #[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
-            #[repr(C)]
-            pub struct __BindgenComplex<T> {
-                pub re: T,
-                pub im: T
-            }
-        };
-
-        let items = vec![complex_type];
-        let old_items = mem::replace(result, items);
-        result.extend(old_items.into_iter());
-    }
-
-    pub fn build_path(
-        item: &Item,
-        ctx: &BindgenContext,
-    ) -> error::Result<proc_macro2::TokenStream> {
-        let path = item.namespace_aware_canonical_path(ctx);
-        let tokens =
-            proc_macro2::TokenStream::from_str(&path.join("::")).unwrap();
-
-        Ok(tokens)
-    }
-
-    fn primitive_ty(
-        ctx: &BindgenContext,
-        name: &str,
-    ) -> proc_macro2::TokenStream {
-        let ident = ctx.rust_ident_raw(name);
-        quote! {
-            #ident
-        }
-    }
-
-    pub fn type_from_named(
-        ctx: &BindgenContext,
-        name: &str,
-    ) -> Option<proc_macro2::TokenStream> {
-        // FIXME: We could use the inner item to check this is really a
-        // primitive type but, who the heck overrides these anyway?
-        Some(match name {
-            "int8_t" => primitive_ty(ctx, "i8"),
-            "uint8_t" => primitive_ty(ctx, "u8"),
-            "int16_t" => primitive_ty(ctx, "i16"),
-            "uint16_t" => primitive_ty(ctx, "u16"),
-            "int32_t" => primitive_ty(ctx, "i32"),
-            "uint32_t" => primitive_ty(ctx, "u32"),
-            "int64_t" => primitive_ty(ctx, "i64"),
-            "uint64_t" => primitive_ty(ctx, "u64"),
-
-            "size_t" if ctx.options().size_t_is_usize => {
-                primitive_ty(ctx, "usize")
-            }
-            "uintptr_t" => primitive_ty(ctx, "usize"),
-
-            "ssize_t" if ctx.options().size_t_is_usize => {
-                primitive_ty(ctx, "isize")
-            }
-            "intptr_t" | "ptrdiff_t" => primitive_ty(ctx, "isize"),
-            _ => return None,
-        })
-    }
-
-    pub fn fnsig_return_ty(
-        ctx: &BindgenContext,
-        sig: &FunctionSig,
-    ) -> proc_macro2::TokenStream {
-        if sig.is_divergent() {
-            return quote! { -> ! };
-        }
-
-        let return_item = ctx.resolve_item(sig.return_type());
-        if let TypeKind::Void = *return_item.kind().expect_type().kind() {
-            quote! {}
-        } else {
-            let ret_ty = return_item.to_rust_ty_or_opaque(ctx, &());
-            quote! {
-                -> #ret_ty
-            }
-        }
-    }
-
-    pub fn fnsig_arguments(
-        ctx: &BindgenContext,
-        sig: &FunctionSig,
-    ) -> Vec<proc_macro2::TokenStream> {
-        use super::ToPtr;
-
-        let mut unnamed_arguments = 0;
-        let mut args = sig
-            .argument_types()
-            .iter()
-            .map(|&(ref name, ty)| {
-                let arg_item = ctx.resolve_item(ty);
-                let arg_ty = arg_item.kind().expect_type();
-
-                // From the C90 standard[1]:
-                //
-                //     A declaration of a parameter as "array of type" shall be
-                //     adjusted to "qualified pointer to type", where the type
-                //     qualifiers (if any) are those specified within the [ and ] of
-                //     the array type derivation.
-                //
-                // [1]: http://c0x.coding-guidelines.com/6.7.5.3.html
-                let arg_ty = match *arg_ty.canonical_type(ctx).kind() {
-                    TypeKind::Array(t, _) => {
-                        let stream =
-                            if ctx.options().array_pointers_in_arguments {
-                                arg_ty.to_rust_ty_or_opaque(ctx, arg_item)
-                            } else {
-                                t.to_rust_ty_or_opaque(ctx, &())
-                            };
-                        stream.to_ptr(ctx.resolve_type(t).is_const())
-                    }
-                    TypeKind::Pointer(inner) => {
-                        let inner = ctx.resolve_item(inner);
-                        let inner_ty = inner.expect_type();
-                        if let TypeKind::ObjCInterface(ref interface) =
-                            *inner_ty.canonical_type(ctx).kind()
-                        {
-                            let name = ctx.rust_ident(interface.name());
-                            quote! {
-                                #name
-                            }
-                        } else {
-                            arg_item.to_rust_ty_or_opaque(ctx, &())
-                        }
-                    }
-                    _ => arg_item.to_rust_ty_or_opaque(ctx, &()),
-                };
-
-                let arg_name = match *name {
-                    Some(ref name) => ctx.rust_mangle(name).into_owned(),
-                    None => {
-                        unnamed_arguments += 1;
-                        format!("arg{}", unnamed_arguments)
-                    }
-                };
-
-                assert!(!arg_name.is_empty());
-                let arg_name = ctx.rust_ident(arg_name);
-
-                quote! {
-                    #arg_name : #arg_ty
-                }
-            })
-            .collect::<Vec<_>>();
-
-        if sig.is_variadic() {
-            args.push(quote! { ... })
-        }
-
-        args
-    }
-
-    pub fn fnsig_argument_identifiers(
-        ctx: &BindgenContext,
-        sig: &FunctionSig,
-    ) -> Vec<proc_macro2::TokenStream> {
-        let mut unnamed_arguments = 0;
-        let args = sig
-            .argument_types()
-            .iter()
-            .map(|&(ref name, _ty)| {
-                let arg_name = match *name {
-                    Some(ref name) => ctx.rust_mangle(name).into_owned(),
-                    None => {
-                        unnamed_arguments += 1;
-                        format!("arg{}", unnamed_arguments)
-                    }
-                };
-
-                assert!(!arg_name.is_empty());
-                let arg_name = ctx.rust_ident(arg_name);
-
-                quote! {
-                    #arg_name
-                }
-            })
-            .collect::<Vec<_>>();
-
-        args
-    }
-
-    pub fn fnsig_block(
-        ctx: &BindgenContext,
-        sig: &FunctionSig,
-    ) -> proc_macro2::TokenStream {
-        let args = sig.argument_types().iter().map(|&(_, ty)| {
-            let arg_item = ctx.resolve_item(ty);
-
-            arg_item.to_rust_ty_or_opaque(ctx, &())
-        });
-
-        let return_item = ctx.resolve_item(sig.return_type());
-        let ret_ty =
-            if let TypeKind::Void = *return_item.kind().expect_type().kind() {
-                quote! { () }
-            } else {
-                return_item.to_rust_ty_or_opaque(ctx, &())
-            };
-
-        quote! {
-            *const ::block::Block<(#(#args,)*), #ret_ty>
-        }
-    }
-
-    // Returns true if `canonical_name` will end up as `mangled_name` at the
-    // machine code level, i.e. after LLVM has applied any target specific
-    // mangling.
-    pub fn names_will_be_identical_after_mangling(
-        canonical_name: &str,
-        mangled_name: &str,
-        call_conv: Option<Abi>,
-    ) -> bool {
-        // If the mangled name and the canonical name are the same then no
-        // mangling can have happened between the two versions.
-        if canonical_name == mangled_name {
-            return true;
-        }
-
-        // Working with &[u8] makes indexing simpler than with &str
-        let canonical_name = canonical_name.as_bytes();
-        let mangled_name = mangled_name.as_bytes();
-
-        let (mangling_prefix, expect_suffix) = match call_conv {
-            Some(Abi::C) |
-            // None is the case for global variables
-            None => {
-                (b'_', false)
-            }
-            Some(Abi::Stdcall) => (b'_', true),
-            Some(Abi::Fastcall) => (b'@', true),
-
-            // This is something we don't recognize, stay on the safe side
-            // by emitting the `#[link_name]` attribute
-            Some(_) => return false,
-        };
-
-        // Check that the mangled name is long enough to at least contain the
-        // canonical name plus the expected prefix.
-        if mangled_name.len() < canonical_name.len() + 1 {
-            return false;
-        }
-
-        // Return if the mangled name does not start with the prefix expected
-        // for the given calling convention.
-        if mangled_name[0] != mangling_prefix {
-            return false;
-        }
-
-        // Check that the mangled name contains the canonical name after the
-        // prefix
-        if &mangled_name[1..canonical_name.len() + 1] != canonical_name {
-            return false;
-        }
-
-        // If the given calling convention also prescribes a suffix, check that
-        // it exists too
-        if expect_suffix {
-            let suffix = &mangled_name[canonical_name.len() + 1..];
-
-            // The shortest suffix is "@0"
-            if suffix.len() < 2 {
-                return false;
-            }
-
-            // Check that the suffix starts with '@' and is all ASCII decimals
-            // after that.
-            if suffix[0] != b'@' || !suffix[1..].iter().all(u8::is_ascii_digit)
-            {
-                return false;
-            }
-        } else if mangled_name.len() != canonical_name.len() + 1 {
-            // If we don't expect a prefix but there is one, we need the
-            // #[link_name] attribute
-            return false;
-        }
-
-        true
-    }
-}
diff --git a/src/codegen/postprocessing/merge_extern_blocks.rs b/src/codegen/postprocessing/merge_extern_blocks.rs
deleted file mode 100644
index 2b761494..00000000
--- a/src/codegen/postprocessing/merge_extern_blocks.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use syn::{Item, ItemForeignMod};
-
-pub(super) fn merge_extern_blocks(items: &mut Vec<Item>) {
-    // Keep all the extern blocks in a different `Vec` for faster search.
-    let mut foreign_mods = Vec::<ItemForeignMod>::new();
-
-    for item in std::mem::take(items) {
-        match item {
-            Item::ForeignMod(ItemForeignMod {
-                attrs,
-                abi,
-                brace_token,
-                items: foreign_items,
-            }) => {
-                let mut exists = false;
-                for foreign_mod in &mut foreign_mods {
-                    // Check if there is a extern block with the same ABI and
-                    // attributes.
-                    if foreign_mod.attrs == attrs && foreign_mod.abi == abi {
-                        // Merge the items of the two blocks.
-                        foreign_mod.items.extend_from_slice(&foreign_items);
-                        exists = true;
-                        break;
-                    }
-                }
-                // If no existing extern block had the same ABI and attributes, store
-                // it.
-                if !exists {
-                    foreign_mods.push(ItemForeignMod {
-                        attrs,
-                        abi,
-                        brace_token,
-                        items: foreign_items,
-                    });
-                }
-            }
-            // If the item is not an extern block, we don't have to do anything.
-            _ => items.push(item),
-        }
-    }
-
-    // Move all the extern blocks alongside the rest of the items.
-    for foreign_mod in foreign_mods {
-        items.push(Item::ForeignMod(foreign_mod));
-    }
-}
diff --git a/src/codegen/postprocessing/mod.rs b/src/codegen/postprocessing/mod.rs
deleted file mode 100644
index c6612f2b..00000000
--- a/src/codegen/postprocessing/mod.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-use syn::Item;
-
-use crate::BindgenOptions;
-
-mod merge_extern_blocks;
-mod sort_semantically;
-
-use merge_extern_blocks::merge_extern_blocks;
-use sort_semantically::sort_semantically;
-
-struct PostProcessingPass {
-    should_run: fn(&BindgenOptions) -> bool,
-    run: fn(&mut Vec<Item>),
-}
-
-// TODO: This can be a const fn when mutable references are allowed in const
-// context.
-macro_rules! pass {
-    ($pass:ident) => {
-        PostProcessingPass {
-            should_run: |options| options.$pass,
-            run: |items| $pass(items),
-        }
-    };
-}
-
-const PASSES: &[PostProcessingPass] =
-    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
-
-pub(crate) fn postprocessing(
-    items: Vec<TokenStream>,
-    options: &BindgenOptions,
-) -> TokenStream {
-    let require_syn = PASSES.iter().any(|pass| (pass.should_run)(options));
-    if !require_syn {
-        return items.into_iter().collect();
-    }
-    let module_wrapped_tokens =
-        quote!(mod wrapper_for_sorting_hack { #( #items )* });
-
-    // This syn business is a hack, for now. This means that we are re-parsing already
-    // generated code using `syn` (as opposed to `quote`) because `syn` provides us more
-    // control over the elements.
-    // One caveat is that some of the items coming from `quote`d output might have
-    // multiple items within them. Hence, we have to wrap the incoming in a `mod`.
-    // The two `unwrap`s here are deliberate because
-    //      The first one won't panic because we build the `mod` and know it is there
-    //      The second one won't panic because we know original output has something in
-    //      it already.
-    let (_, mut items) = syn::parse2::<syn::ItemMod>(module_wrapped_tokens)
-        .unwrap()
-        .content
-        .unwrap();
-
-    for pass in PASSES {
-        if (pass.should_run)(options) {
-            (pass.run)(&mut items);
-        }
-    }
-
-    let synful_items = items.into_iter().map(|item| item.into_token_stream());
-
-    quote! { #( #synful_items )* }
-}
diff --git a/src/codegen/postprocessing/sort_semantically.rs b/src/codegen/postprocessing/sort_semantically.rs
deleted file mode 100644
index 96596cb0..00000000
--- a/src/codegen/postprocessing/sort_semantically.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use syn::Item;
-
-pub(super) fn sort_semantically(items: &mut [Item]) {
-    items.sort_by_key(|item| match item {
-        Item::Type(_) => 0,
-        Item::Struct(_) => 1,
-        Item::Const(_) => 2,
-        Item::Fn(_) => 3,
-        Item::Enum(_) => 4,
-        Item::Union(_) => 5,
-        Item::Static(_) => 6,
-        Item::Trait(_) => 7,
-        Item::TraitAlias(_) => 8,
-        Item::Impl(_) => 9,
-        Item::Mod(_) => 10,
-        Item::Use(_) => 11,
-        Item::Verbatim(_) => 12,
-        Item::ExternCrate(_) => 13,
-        Item::ForeignMod(_) => 14,
-        Item::Macro(_) => 15,
-        Item::Macro2(_) => 16,
-        _ => 18,
-    });
-}
diff --git a/src/codegen/struct_layout.rs b/src/codegen/struct_layout.rs
deleted file mode 100644
index ddac1b0a..00000000
--- a/src/codegen/struct_layout.rs
+++ /dev/null
@@ -1,444 +0,0 @@
-//! Helpers for code generation that need struct layout
-
-use super::helpers;
-
-use crate::ir::comp::CompInfo;
-use crate::ir::context::BindgenContext;
-use crate::ir::layout::Layout;
-use crate::ir::ty::{Type, TypeKind};
-use proc_macro2::{self, Ident, Span};
-use std::cmp;
-
-const MAX_GUARANTEED_ALIGN: usize = 8;
-
-/// Trace the layout of struct.
-#[derive(Debug)]
-pub struct StructLayoutTracker<'a> {
-    name: &'a str,
-    ctx: &'a BindgenContext,
-    comp: &'a CompInfo,
-    is_packed: bool,
-    known_type_layout: Option<Layout>,
-    is_rust_union: bool,
-    can_copy_union_fields: bool,
-    latest_offset: usize,
-    padding_count: usize,
-    latest_field_layout: Option<Layout>,
-    max_field_align: usize,
-    last_field_was_bitfield: bool,
-}
-
-/// Returns a size aligned to a given value.
-pub fn align_to(size: usize, align: usize) -> usize {
-    if align == 0 {
-        return size;
-    }
-
-    let rem = size % align;
-    if rem == 0 {
-        return size;
-    }
-
-    size + align - rem
-}
-
-/// Returns the lower power of two byte count that can hold at most n bits.
-pub fn bytes_from_bits_pow2(mut n: usize) -> usize {
-    if n == 0 {
-        return 0;
-    }
-
-    if n <= 8 {
-        return 1;
-    }
-
-    if !n.is_power_of_two() {
-        n = n.next_power_of_two();
-    }
-
-    n / 8
-}
-
-#[test]
-fn test_align_to() {
-    assert_eq!(align_to(1, 1), 1);
-    assert_eq!(align_to(1, 2), 2);
-    assert_eq!(align_to(1, 4), 4);
-    assert_eq!(align_to(5, 1), 5);
-    assert_eq!(align_to(17, 4), 20);
-}
-
-#[test]
-fn test_bytes_from_bits_pow2() {
-    assert_eq!(bytes_from_bits_pow2(0), 0);
-    for i in 1..9 {
-        assert_eq!(bytes_from_bits_pow2(i), 1);
-    }
-    for i in 9..17 {
-        assert_eq!(bytes_from_bits_pow2(i), 2);
-    }
-    for i in 17..33 {
-        assert_eq!(bytes_from_bits_pow2(i), 4);
-    }
-}
-
-impl<'a> StructLayoutTracker<'a> {
-    pub fn new(
-        ctx: &'a BindgenContext,
-        comp: &'a CompInfo,
-        ty: &'a Type,
-        name: &'a str,
-    ) -> Self {
-        let known_type_layout = ty.layout(ctx);
-        let is_packed = comp.is_packed(ctx, known_type_layout.as_ref());
-        let (is_rust_union, can_copy_union_fields) =
-            comp.is_rust_union(ctx, known_type_layout.as_ref(), name);
-        StructLayoutTracker {
-            name,
-            ctx,
-            comp,
-            is_packed,
-            known_type_layout,
-            is_rust_union,
-            can_copy_union_fields,
-            latest_offset: 0,
-            padding_count: 0,
-            latest_field_layout: None,
-            max_field_align: 0,
-            last_field_was_bitfield: false,
-        }
-    }
-
-    pub fn can_copy_union_fields(&self) -> bool {
-        self.can_copy_union_fields
-    }
-
-    pub fn is_rust_union(&self) -> bool {
-        self.is_rust_union
-    }
-
-    pub fn saw_vtable(&mut self) {
-        debug!("saw vtable for {}", self.name);
-
-        let ptr_size = self.ctx.target_pointer_size();
-        self.latest_offset += ptr_size;
-        self.latest_field_layout = Some(Layout::new(ptr_size, ptr_size));
-        self.max_field_align = ptr_size;
-    }
-
-    pub fn saw_base(&mut self, base_ty: &Type) {
-        debug!("saw base for {}", self.name);
-        if let Some(layout) = base_ty.layout(self.ctx) {
-            self.align_to_latest_field(layout);
-
-            self.latest_offset += self.padding_bytes(layout) + layout.size;
-            self.latest_field_layout = Some(layout);
-            self.max_field_align = cmp::max(self.max_field_align, layout.align);
-        }
-    }
-
-    pub fn saw_bitfield_unit(&mut self, layout: Layout) {
-        debug!("saw bitfield unit for {}: {:?}", self.name, layout);
-
-        self.align_to_latest_field(layout);
-
-        self.latest_offset += layout.size;
-
-        debug!(
-            "Offset: <bitfield>: {} -> {}",
-            self.latest_offset - layout.size,
-            self.latest_offset
-        );
-
-        self.latest_field_layout = Some(layout);
-        self.last_field_was_bitfield = true;
-        // NB: We intentionally don't update the max_field_align here, since our
-        // bitfields code doesn't necessarily guarantee it, so we need to
-        // actually generate the dummy alignment.
-    }
-
-    /// Returns a padding field if necessary for a given new field _before_
-    /// adding that field.
-    pub fn saw_field(
-        &mut self,
-        field_name: &str,
-        field_ty: &Type,
-        field_offset: Option<usize>,
-    ) -> Option<proc_macro2::TokenStream> {
-        let mut field_layout = field_ty.layout(self.ctx)?;
-
-        if let TypeKind::Array(inner, len) =
-            *field_ty.canonical_type(self.ctx).kind()
-        {
-            // FIXME(emilio): As an _ultra_ hack, we correct the layout returned
-            // by arrays of structs that have a bigger alignment than what we
-            // can support.
-            //
-            // This means that the structs in the array are super-unsafe to
-            // access, since they won't be properly aligned, but there's not too
-            // much we can do about it.
-            if let Some(layout) = self.ctx.resolve_type(inner).layout(self.ctx)
-            {
-                if layout.align > MAX_GUARANTEED_ALIGN {
-                    field_layout.size =
-                        align_to(layout.size, layout.align) * len;
-                    field_layout.align = MAX_GUARANTEED_ALIGN;
-                }
-            }
-        }
-        self.saw_field_with_layout(field_name, field_layout, field_offset)
-    }
-
-    pub fn saw_field_with_layout(
-        &mut self,
-        field_name: &str,
-        field_layout: Layout,
-        field_offset: Option<usize>,
-    ) -> Option<proc_macro2::TokenStream> {
-        let will_merge_with_bitfield = self.align_to_latest_field(field_layout);
-
-        let is_union = self.comp.is_union();
-        let padding_bytes = match field_offset {
-            Some(offset) if offset / 8 > self.latest_offset => {
-                offset / 8 - self.latest_offset
-            }
-            _ => {
-                if will_merge_with_bitfield ||
-                    field_layout.align == 0 ||
-                    is_union
-                {
-                    0
-                } else if !self.is_packed {
-                    self.padding_bytes(field_layout)
-                } else if let Some(l) = self.known_type_layout {
-                    self.padding_bytes(l)
-                } else {
-                    0
-                }
-            }
-        };
-
-        self.latest_offset += padding_bytes;
-
-        let padding_layout = if self.is_packed || is_union {
-            None
-        } else {
-            let force_padding = self.ctx.options().force_explicit_padding;
-
-            // Otherwise the padding is useless.
-            let need_padding = force_padding ||
-                padding_bytes >= field_layout.align ||
-                field_layout.align > MAX_GUARANTEED_ALIGN;
-
-            debug!(
-                "Offset: <padding>: {} -> {}",
-                self.latest_offset - padding_bytes,
-                self.latest_offset
-            );
-
-            debug!(
-                "align field {} to {}/{} with {} padding bytes {:?}",
-                field_name,
-                self.latest_offset,
-                field_offset.unwrap_or(0) / 8,
-                padding_bytes,
-                field_layout
-            );
-
-            let padding_align = if force_padding {
-                1
-            } else {
-                cmp::min(field_layout.align, MAX_GUARANTEED_ALIGN)
-            };
-
-            if need_padding && padding_bytes != 0 {
-                Some(Layout::new(padding_bytes, padding_align))
-            } else {
-                None
-            }
-        };
-
-        self.latest_offset += field_layout.size;
-        self.latest_field_layout = Some(field_layout);
-        self.max_field_align =
-            cmp::max(self.max_field_align, field_layout.align);
-        self.last_field_was_bitfield = false;
-
-        debug!(
-            "Offset: {}: {} -> {}",
-            field_name,
-            self.latest_offset - field_layout.size,
-            self.latest_offset
-        );
-
-        padding_layout.map(|layout| self.padding_field(layout))
-    }
-
-    pub fn add_tail_padding(
-        &mut self,
-        comp_name: &str,
-        comp_layout: Layout,
-    ) -> Option<proc_macro2::TokenStream> {
-        // Only emit an padding field at the end of a struct if the
-        // user configures explicit padding.
-        if !self.ctx.options().force_explicit_padding {
-            return None;
-        }
-
-        // Padding doesn't make sense for rust unions.
-        if self.is_rust_union {
-            return None;
-        }
-
-        if self.latest_offset == comp_layout.size {
-            // This struct does not contain tail padding.
-            return None;
-        }
-
-        trace!(
-            "need a tail padding field for {}: offset {} -> size {}",
-            comp_name,
-            self.latest_offset,
-            comp_layout.size
-        );
-        let size = comp_layout.size - self.latest_offset;
-        Some(self.padding_field(Layout::new(size, 0)))
-    }
-
-    pub fn pad_struct(
-        &mut self,
-        layout: Layout,
-    ) -> Option<proc_macro2::TokenStream> {
-        debug!(
-            "pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}",
-            self, layout
-        );
-
-        if layout.size < self.latest_offset {
-            warn!(
-                "Calculated wrong layout for {}, too more {} bytes",
-                self.name,
-                self.latest_offset - layout.size
-            );
-            return None;
-        }
-
-        let padding_bytes = layout.size - self.latest_offset;
-        if padding_bytes == 0 {
-            return None;
-        }
-
-        let repr_align = self.ctx.options().rust_features().repr_align;
-
-        // We always pad to get to the correct size if the struct is one of
-        // those we can't align properly.
-        //
-        // Note that if the last field we saw was a bitfield, we may need to pad
-        // regardless, because bitfields don't respect alignment as strictly as
-        // other fields.
-        if padding_bytes >= layout.align ||
-            (self.last_field_was_bitfield &&
-                padding_bytes >= self.latest_field_layout.unwrap().align) ||
-            (!repr_align && layout.align > MAX_GUARANTEED_ALIGN)
-        {
-            let layout = if self.is_packed {
-                Layout::new(padding_bytes, 1)
-            } else if self.last_field_was_bitfield ||
-                layout.align > MAX_GUARANTEED_ALIGN
-            {
-                // We've already given up on alignment here.
-                Layout::for_size(self.ctx, padding_bytes)
-            } else {
-                Layout::new(padding_bytes, layout.align)
-            };
-
-            debug!("pad bytes to struct {}, {:?}", self.name, layout);
-
-            Some(self.padding_field(layout))
-        } else {
-            None
-        }
-    }
-
-    pub fn requires_explicit_align(&self, layout: Layout) -> bool {
-        let repr_align = self.ctx.options().rust_features().repr_align;
-
-        // Always force explicit repr(align) for stuff more than 16-byte aligned
-        // to work-around https://github.com/rust-lang/rust/issues/54341.
-        //
-        // Worst-case this just generates redundant alignment attributes.
-        if repr_align && self.max_field_align >= 16 {
-            return true;
-        }
-
-        if self.max_field_align >= layout.align {
-            return false;
-        }
-
-        // We can only generate up-to a 8-bytes of alignment unless we support
-        // repr(align).
-        repr_align || layout.align <= MAX_GUARANTEED_ALIGN
-    }
-
-    fn padding_bytes(&self, layout: Layout) -> usize {
-        align_to(self.latest_offset, layout.align) - self.latest_offset
-    }
-
-    fn padding_field(&mut self, layout: Layout) -> proc_macro2::TokenStream {
-        let ty = helpers::blob(self.ctx, layout);
-        let padding_count = self.padding_count;
-
-        self.padding_count += 1;
-
-        let padding_field_name = Ident::new(
-            &format!("__bindgen_padding_{}", padding_count),
-            Span::call_site(),
-        );
-
-        self.max_field_align = cmp::max(self.max_field_align, layout.align);
-
-        quote! {
-            pub #padding_field_name : #ty ,
-        }
-    }
-
-    /// Returns whether the new field is known to merge with a bitfield.
-    ///
-    /// This is just to avoid doing the same check also in pad_field.
-    fn align_to_latest_field(&mut self, new_field_layout: Layout) -> bool {
-        if self.is_packed {
-            // Skip to align fields when packed.
-            return false;
-        }
-
-        let layout = match self.latest_field_layout {
-            Some(l) => l,
-            None => return false,
-        };
-
-        // If it was, we may or may not need to align, depending on what the
-        // current field alignment and the bitfield size and alignment are.
-        debug!(
-            "align_to_bitfield? {}: {:?} {:?}",
-            self.last_field_was_bitfield, layout, new_field_layout
-        );
-
-        // Avoid divide-by-zero errors if align is 0.
-        let align = cmp::max(1, layout.align);
-
-        if self.last_field_was_bitfield &&
-            new_field_layout.align <= layout.size % align &&
-            new_field_layout.size <= layout.size % align
-        {
-            // The new field will be coalesced into some of the remaining bits.
-            //
-            // FIXME(emilio): I think this may not catch everything?
-            debug!("Will merge with bitfield");
-            return true;
-        }
-
-        // Else, just align the obvious way.
-        self.latest_offset += self.padding_bytes(layout);
-        false
-    }
-}
diff --git a/src/deps.rs b/src/deps.rs
deleted file mode 100644
index 987225b2..00000000
--- a/src/deps.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-/// Generating build depfiles from parsed bindings.
-use std::{collections::BTreeSet, path::PathBuf};
-
-#[derive(Clone, Debug)]
-pub(crate) struct DepfileSpec {
-    pub output_module: String,
-    pub depfile_path: PathBuf,
-}
-
-impl DepfileSpec {
-    pub fn write(&self, deps: &BTreeSet<String>) -> std::io::Result<()> {
-        let mut buf = format!("{}:", self.output_module);
-
-        for file in deps {
-            buf = format!("{} {}", buf, file);
-        }
-
-        std::fs::write(&self.depfile_path, &buf)
-    }
-}
diff --git a/src/extra_assertions.rs b/src/extra_assertions.rs
deleted file mode 100644
index 0888bf39..00000000
--- a/src/extra_assertions.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! Macros for defining extra assertions that should only be checked in testing
-//! and/or CI when the `testing_only_extra_assertions` feature is enabled.
-
-/// Simple macro that forwards to assert! when using
-/// testing_only_extra_assertions.
-#[macro_export]
-macro_rules! extra_assert {
-    ( $cond:expr ) => {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            assert!($cond);
-        }
-    };
-    ( $cond:expr , $( $arg:tt )+ ) => {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            assert!($cond, $( $arg )* )
-        }
-    };
-}
-
-/// Simple macro that forwards to assert_eq! when using
-/// testing_only_extra_assertions.
-#[macro_export]
-macro_rules! extra_assert_eq {
-    ( $lhs:expr , $rhs:expr ) => {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            assert_eq!($lhs, $rhs);
-        }
-    };
-    ( $lhs:expr , $rhs:expr , $( $arg:tt )+ ) => {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            assert!($lhs, $rhs, $( $arg )* );
-        }
-    };
-}
diff --git a/src/features.rs b/src/features.rs
deleted file mode 100644
index 4f05b9eb..00000000
--- a/src/features.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-//! Contains code for selecting features
-
-#![deny(missing_docs)]
-#![deny(unused_extern_crates)]
-
-use std::io;
-use std::str::FromStr;
-
-/// Define RustTarget struct definition, Default impl, and conversions
-/// between RustTarget and String.
-macro_rules! rust_target_def {
-    ( $( $( #[$attr:meta] )* => $release:ident => $value:expr; )* ) => {
-        /// Represents the version of the Rust language to target.
-        ///
-        /// To support a beta release, use the corresponding stable release.
-        ///
-        /// This enum will have more variants added as necessary.
-        #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Hash)]
-        #[allow(non_camel_case_types)]
-        pub enum RustTarget {
-            $(
-                $(
-                    #[$attr]
-                )*
-                $release,
-            )*
-        }
-
-        impl Default for RustTarget {
-            /// Gives the latest stable Rust version
-            fn default() -> RustTarget {
-                LATEST_STABLE_RUST
-            }
-        }
-
-        impl FromStr for RustTarget {
-            type Err = io::Error;
-
-            /// Create a `RustTarget` from a string.
-            ///
-            /// * The stable/beta versions of Rust are of the form "1.0",
-            /// "1.19", etc.
-            /// * The nightly version should be specified with "nightly".
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                match s.as_ref() {
-                    $(
-                        stringify!($value) => Ok(RustTarget::$release),
-                    )*
-                    _ => Err(
-                        io::Error::new(
-                            io::ErrorKind::InvalidInput,
-                            concat!(
-                                "Got an invalid rust target. Accepted values ",
-                                "are of the form ",
-                                "\"1.0\" or \"nightly\"."))),
-                }
-            }
-        }
-
-        impl From<RustTarget> for String {
-            fn from(target: RustTarget) -> Self {
-                match target {
-                    $(
-                        RustTarget::$release => stringify!($value),
-                    )*
-                }.into()
-            }
-        }
-    }
-}
-
-/// Defines an array slice with all RustTarget values
-macro_rules! rust_target_values_def {
-    ( $( $( #[$attr:meta] )* => $release:ident => $value:expr; )* ) => {
-        /// Strings of allowed `RustTarget` values
-        pub static RUST_TARGET_STRINGS: &'static [&str] = &[
-            $(
-                stringify!($value),
-            )*
-        ];
-    }
-}
-
-/// Defines macro which takes a macro
-macro_rules! rust_target_base {
-    ( $x_macro:ident ) => {
-        $x_macro!(
-            /// Rust stable 1.0
-            => Stable_1_0 => 1.0;
-            /// Rust stable 1.17
-            ///  * Static lifetime elision ([RFC 1623](https://github.com/rust-lang/rfcs/blob/master/text/1623-static.md))
-            => Stable_1_17 => 1.17;
-            /// Rust stable 1.19
-            ///  * Untagged unions ([RFC 1444](https://github.com/rust-lang/rfcs/blob/master/text/1444-union.md))
-            => Stable_1_19 => 1.19;
-            /// Rust stable 1.20
-            ///  * Associated constants ([PR](https://github.com/rust-lang/rust/pull/42809))
-            => Stable_1_20 => 1.20;
-            /// Rust stable 1.21
-            ///  * Builtin impls for `Clone` ([PR](https://github.com/rust-lang/rust/pull/43690))
-            => Stable_1_21 => 1.21;
-            /// Rust stable 1.25
-            ///  * `repr(align)` ([PR](https://github.com/rust-lang/rust/pull/47006))
-            => Stable_1_25 => 1.25;
-            /// Rust stable 1.26
-            ///  * [i128 / u128 support](https://doc.rust-lang.org/std/primitive.i128.html)
-            => Stable_1_26 => 1.26;
-            /// Rust stable 1.27
-            ///  * `must_use` attribute on functions ([PR](https://github.com/rust-lang/rust/pull/48925))
-            => Stable_1_27 => 1.27;
-            /// Rust stable 1.28
-            ///  * `repr(transparent)` ([PR](https://github.com/rust-lang/rust/pull/51562))
-            => Stable_1_28 => 1.28;
-            /// Rust stable 1.30
-            ///  * `const fn` support for limited cases ([PR](https://github.com/rust-lang/rust/pull/54835/)
-            /// *  [c_void available in core](https://doc.rust-lang.org/core/ffi/enum.c_void.html)
-            => Stable_1_30 => 1.30;
-            /// Rust stable 1.33
-            ///  * repr(packed(N)) ([PR](https://github.com/rust-lang/rust/pull/57049))
-            => Stable_1_33 => 1.33;
-            /// Rust stable 1.36
-            ///  * `MaybeUninit` instead of `mem::uninitialized()` ([PR](https://github.com/rust-lang/rust/pull/60445))
-            => Stable_1_36 => 1.36;
-            /// Rust stable 1.40
-            /// * `non_exhaustive` enums/structs ([Tracking issue](https://github.com/rust-lang/rust/issues/44109))
-            => Stable_1_40 => 1.40;
-            /// Rust stable 1.47
-            /// * `larger_arrays` ([Tracking issue](https://github.com/rust-lang/rust/pull/74060))
-            => Stable_1_47 => 1.47;
-            /// Rust stable 1.64
-            ///  * `core_ffi_c` ([Tracking issue](https://github.com/rust-lang/rust/issues/94501))
-            => Stable_1_64 => 1.64;
-            /// Nightly rust
-            ///  * `thiscall` calling convention ([Tracking issue](https://github.com/rust-lang/rust/issues/42202))
-            ///  * `vectorcall` calling convention (no tracking issue)
-            => Nightly => nightly;
-        );
-    }
-}
-
-rust_target_base!(rust_target_def);
-rust_target_base!(rust_target_values_def);
-
-/// Latest stable release of Rust
-pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_64;
-
-/// Create RustFeatures struct definition, new(), and a getter for each field
-macro_rules! rust_feature_def {
-    (
-        $( $rust_target:ident {
-            $( $( #[$attr:meta] )* => $feature:ident; )*
-        } )*
-    ) => {
-        /// Features supported by a rust target
-        #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-        #[allow(missing_docs)] // Documentation should go into the relevant variants.
-        pub(crate) struct RustFeatures {
-            $( $(
-                $(
-                    #[$attr]
-                )*
-                pub $feature: bool,
-            )* )*
-        }
-
-        impl RustFeatures {
-            /// Gives a RustFeatures struct with all features disabled
-            fn new() -> Self {
-                RustFeatures {
-                    $( $(
-                        $feature: false,
-                    )* )*
-                }
-            }
-        }
-
-        impl From<RustTarget> for RustFeatures {
-            fn from(rust_target: RustTarget) -> Self {
-                let mut features = RustFeatures::new();
-
-                $(
-                if rust_target >= RustTarget::$rust_target {
-                    $(
-                    features.$feature = true;
-                    )*
-                }
-                )*
-
-                features
-            }
-        }
-    }
-}
-
-// NOTE(emilio): When adding or removing features here, make sure to update the
-// documentation for the relevant variant in the rust_target_base macro
-// definition.
-rust_feature_def!(
-    Stable_1_17 {
-        => static_lifetime_elision;
-    }
-    Stable_1_19 {
-        => untagged_union;
-    }
-    Stable_1_20 {
-        => associated_const;
-    }
-    Stable_1_21 {
-        => builtin_clone_impls;
-    }
-    Stable_1_25 {
-        => repr_align;
-    }
-    Stable_1_26 {
-        => i128_and_u128;
-    }
-    Stable_1_27 {
-        => must_use_function;
-    }
-    Stable_1_28 {
-        => repr_transparent;
-    }
-    Stable_1_30 {
-        => min_const_fn;
-        => core_ffi_c_void;
-    }
-    Stable_1_33 {
-        => repr_packed_n;
-    }
-    Stable_1_36 {
-        => maybe_uninit;
-    }
-    Stable_1_40 {
-        => non_exhaustive;
-    }
-    Stable_1_47 {
-        => larger_arrays;
-    }
-    Stable_1_64 {
-        => core_ffi_c;
-    }
-    Nightly {
-        => thiscall_abi;
-        => vectorcall_abi;
-    }
-);
-
-impl Default for RustFeatures {
-    fn default() -> Self {
-        let default_rust_target: RustTarget = Default::default();
-        Self::from(default_rust_target)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #![allow(unused_imports)]
-    use super::*;
-
-    #[test]
-    fn target_features() {
-        let f_1_0 = RustFeatures::from(RustTarget::Stable_1_0);
-        assert!(
-            !f_1_0.static_lifetime_elision &&
-                !f_1_0.core_ffi_c_void &&
-                !f_1_0.untagged_union &&
-                !f_1_0.associated_const &&
-                !f_1_0.builtin_clone_impls &&
-                !f_1_0.repr_align &&
-                !f_1_0.thiscall_abi &&
-                !f_1_0.vectorcall_abi
-        );
-        let f_1_21 = RustFeatures::from(RustTarget::Stable_1_21);
-        assert!(
-            f_1_21.static_lifetime_elision &&
-                !f_1_21.core_ffi_c_void &&
-                f_1_21.untagged_union &&
-                f_1_21.associated_const &&
-                f_1_21.builtin_clone_impls &&
-                !f_1_21.repr_align &&
-                !f_1_21.thiscall_abi &&
-                !f_1_21.vectorcall_abi
-        );
-        let f_nightly = RustFeatures::from(RustTarget::Nightly);
-        assert!(
-            f_nightly.static_lifetime_elision &&
-                f_nightly.core_ffi_c_void &&
-                f_nightly.untagged_union &&
-                f_nightly.associated_const &&
-                f_nightly.builtin_clone_impls &&
-                f_nightly.maybe_uninit &&
-                f_nightly.repr_align &&
-                f_nightly.thiscall_abi &&
-                f_nightly.vectorcall_abi
-        );
-    }
-
-    fn test_target(target_str: &str, target: RustTarget) {
-        let target_string: String = target.into();
-        assert_eq!(target_str, target_string);
-        assert_eq!(target, RustTarget::from_str(target_str).unwrap());
-    }
-
-    #[test]
-    fn str_to_target() {
-        test_target("1.0", RustTarget::Stable_1_0);
-        test_target("1.17", RustTarget::Stable_1_17);
-        test_target("1.19", RustTarget::Stable_1_19);
-        test_target("1.21", RustTarget::Stable_1_21);
-        test_target("1.25", RustTarget::Stable_1_25);
-        test_target("nightly", RustTarget::Nightly);
-    }
-}
diff --git a/src/ir/analysis/derive.rs b/src/ir/analysis/derive.rs
deleted file mode 100644
index d888cd55..00000000
--- a/src/ir/analysis/derive.rs
+++ /dev/null
@@ -1,732 +0,0 @@
-//! Determining which types for which we cannot emit `#[derive(Trait)]`.
-
-use std::fmt;
-
-use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
-use crate::ir::analysis::has_vtable::HasVtable;
-use crate::ir::comp::CompKind;
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::derive::CanDerive;
-use crate::ir::function::FunctionSig;
-use crate::ir::item::{IsOpaque, Item};
-use crate::ir::layout::Layout;
-use crate::ir::template::TemplateParameters;
-use crate::ir::traversal::{EdgeKind, Trace};
-use crate::ir::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
-use crate::ir::ty::{Type, TypeKind};
-use crate::{Entry, HashMap, HashSet};
-
-/// Which trait to consider when doing the `CannotDerive` analysis.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum DeriveTrait {
-    /// The `Copy` trait.
-    Copy,
-    /// The `Debug` trait.
-    Debug,
-    /// The `Default` trait.
-    Default,
-    /// The `Hash` trait.
-    Hash,
-    /// The `PartialEq` and `PartialOrd` traits.
-    PartialEqOrPartialOrd,
-}
-
-/// An analysis that finds for each IR item whether a trait cannot be derived.
-///
-/// We use the monotone constraint function `cannot_derive`, defined as follows
-/// for type T:
-///
-/// * If T is Opaque and the layout of the type is known, get this layout as an
-///   opaquetype and check whether it can derive using trivial checks.
-///
-/// * If T is Array, a trait cannot be derived if the array is incomplete,
-///   if the length of the array is larger than the limit (unless the trait
-///   allows it), or the trait cannot be derived for the type of data the array
-///   contains.
-///
-/// * If T is Vector, a trait cannot be derived if the trait cannot be derived
-///   for the type of data the vector contains.
-///
-/// * If T is a type alias, a templated alias or an indirection to another type,
-///   the trait cannot be derived if the trait cannot be derived for type T
-///   refers to.
-///
-/// * If T is a compound type, the trait cannot be derived if the trait cannot
-///   be derived for any of its base members or fields.
-///
-/// * If T is an instantiation of an abstract template definition, the trait
-///   cannot be derived if any of the template arguments or template definition
-///   cannot derive the trait.
-///
-/// * For all other (simple) types, compiler and standard library limitations
-///   dictate whether the trait is implemented.
-#[derive(Debug, Clone)]
-pub struct CannotDerive<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    derive_trait: DeriveTrait,
-
-    // The incremental result of this analysis's computation.
-    // Contains information whether particular item can derive `derive_trait`
-    can_derive: HashMap<ItemId, CanDerive>,
-
-    // Dependencies saying that if a key ItemId has been inserted into the
-    // `cannot_derive_partialeq_or_partialord` set, then each of the ids
-    // in Vec<ItemId> need to be considered again.
-    //
-    // This is a subset of the natural IR graph with reversed edges, where we
-    // only include the edges from the IR graph that can affect whether a type
-    // can derive `derive_trait`.
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-}
-
-type EdgePredicate = fn(EdgeKind) -> bool;
-
-fn consider_edge_default(kind: EdgeKind) -> bool {
-    match kind {
-        // These are the only edges that can affect whether a type can derive
-        EdgeKind::BaseMember |
-        EdgeKind::Field |
-        EdgeKind::TypeReference |
-        EdgeKind::VarType |
-        EdgeKind::TemplateArgument |
-        EdgeKind::TemplateDeclaration |
-        EdgeKind::TemplateParameterDefinition => true,
-
-        EdgeKind::Constructor |
-        EdgeKind::Destructor |
-        EdgeKind::FunctionReturn |
-        EdgeKind::FunctionParameter |
-        EdgeKind::InnerType |
-        EdgeKind::InnerVar |
-        EdgeKind::Method |
-        EdgeKind::Generic => false,
-    }
-}
-
-impl<'ctx> CannotDerive<'ctx> {
-    fn insert<Id: Into<ItemId>>(
-        &mut self,
-        id: Id,
-        can_derive: CanDerive,
-    ) -> ConstrainResult {
-        let id = id.into();
-        trace!(
-            "inserting {:?} can_derive<{}>={:?}",
-            id,
-            self.derive_trait,
-            can_derive
-        );
-
-        if let CanDerive::Yes = can_derive {
-            return ConstrainResult::Same;
-        }
-
-        match self.can_derive.entry(id) {
-            Entry::Occupied(mut entry) => {
-                if *entry.get() < can_derive {
-                    entry.insert(can_derive);
-                    ConstrainResult::Changed
-                } else {
-                    ConstrainResult::Same
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(can_derive);
-                ConstrainResult::Changed
-            }
-        }
-    }
-
-    fn constrain_type(&mut self, item: &Item, ty: &Type) -> CanDerive {
-        if !self.ctx.allowlisted_items().contains(&item.id()) {
-            let can_derive = self
-                .ctx
-                .blocklisted_type_implements_trait(item, self.derive_trait);
-            match can_derive {
-                CanDerive::Yes => trace!(
-                    "    blocklisted type explicitly implements {}",
-                    self.derive_trait
-                ),
-                CanDerive::Manually => trace!(
-                    "    blocklisted type requires manual implementation of {}",
-                    self.derive_trait
-                ),
-                CanDerive::No => trace!(
-                    "    cannot derive {} for blocklisted type",
-                    self.derive_trait
-                ),
-            }
-            return can_derive;
-        }
-
-        if self.derive_trait.not_by_name(self.ctx, item) {
-            trace!(
-                "    cannot derive {} for explicitly excluded type",
-                self.derive_trait
-            );
-            return CanDerive::No;
-        }
-
-        trace!("ty: {:?}", ty);
-        if item.is_opaque(self.ctx, &()) {
-            if !self.derive_trait.can_derive_union() &&
-                ty.is_union() &&
-                self.ctx.options().rust_features().untagged_union
-            {
-                trace!(
-                    "    cannot derive {} for Rust unions",
-                    self.derive_trait
-                );
-                return CanDerive::No;
-            }
-
-            let layout_can_derive =
-                ty.layout(self.ctx).map_or(CanDerive::Yes, |l| {
-                    l.opaque().array_size_within_derive_limit(self.ctx)
-                });
-
-            match layout_can_derive {
-                CanDerive::Yes => {
-                    trace!(
-                        "    we can trivially derive {} for the layout",
-                        self.derive_trait
-                    );
-                }
-                _ => {
-                    trace!(
-                        "    we cannot derive {} for the layout",
-                        self.derive_trait
-                    );
-                }
-            };
-            return layout_can_derive;
-        }
-
-        match *ty.kind() {
-            // Handle the simple cases. These can derive traits without further
-            // information.
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Float(..) |
-            TypeKind::Enum(..) |
-            TypeKind::TypeParam |
-            TypeKind::UnresolvedTypeRef(..) |
-            TypeKind::Reference(..) |
-            TypeKind::ObjCInterface(..) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel => {
-                return self.derive_trait.can_derive_simple(ty.kind());
-            }
-            TypeKind::Pointer(inner) => {
-                let inner_type =
-                    self.ctx.resolve_type(inner).canonical_type(self.ctx);
-                if let TypeKind::Function(ref sig) = *inner_type.kind() {
-                    self.derive_trait.can_derive_fnptr(sig)
-                } else {
-                    self.derive_trait.can_derive_pointer()
-                }
-            }
-            TypeKind::Function(ref sig) => {
-                self.derive_trait.can_derive_fnptr(sig)
-            }
-
-            // Complex cases need more information
-            TypeKind::Array(t, len) => {
-                let inner_type =
-                    self.can_derive.get(&t.into()).cloned().unwrap_or_default();
-                if inner_type != CanDerive::Yes {
-                    trace!(
-                        "    arrays of T for which we cannot derive {} \
-                         also cannot derive {}",
-                        self.derive_trait,
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                if len == 0 && !self.derive_trait.can_derive_incomplete_array()
-                {
-                    trace!(
-                        "    cannot derive {} for incomplete arrays",
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                if self.derive_trait.can_derive_large_array(self.ctx) {
-                    trace!("    array can derive {}", self.derive_trait);
-                    return CanDerive::Yes;
-                }
-
-                if len > RUST_DERIVE_IN_ARRAY_LIMIT {
-                    trace!(
-                        "    array is too large to derive {}, but it may be implemented", self.derive_trait
-                    );
-                    return CanDerive::Manually;
-                }
-                trace!(
-                    "    array is small enough to derive {}",
-                    self.derive_trait
-                );
-                CanDerive::Yes
-            }
-            TypeKind::Vector(t, len) => {
-                let inner_type =
-                    self.can_derive.get(&t.into()).cloned().unwrap_or_default();
-                if inner_type != CanDerive::Yes {
-                    trace!(
-                        "    vectors of T for which we cannot derive {} \
-                         also cannot derive {}",
-                        self.derive_trait,
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-                assert_ne!(len, 0, "vectors cannot have zero length");
-                self.derive_trait.can_derive_vector()
-            }
-
-            TypeKind::Comp(ref info) => {
-                assert!(
-                    !info.has_non_type_template_params(),
-                    "The early ty.is_opaque check should have handled this case"
-                );
-
-                if !self.derive_trait.can_derive_compound_forward_decl() &&
-                    info.is_forward_declaration()
-                {
-                    trace!(
-                        "    cannot derive {} for forward decls",
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                // NOTE: Take into account that while unions in C and C++ are copied by
-                // default, the may have an explicit destructor in C++, so we can't
-                // defer this check just for the union case.
-                if !self.derive_trait.can_derive_compound_with_destructor() &&
-                    self.ctx.lookup_has_destructor(
-                        item.id().expect_type_id(self.ctx),
-                    )
-                {
-                    trace!(
-                        "    comp has destructor which cannot derive {}",
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                if info.kind() == CompKind::Union {
-                    if self.derive_trait.can_derive_union() {
-                        if self.ctx.options().rust_features().untagged_union &&
-                           // https://github.com/rust-lang/rust/issues/36640
-                           (!info.self_template_params(self.ctx).is_empty() ||
-                            !item.all_template_params(self.ctx).is_empty())
-                        {
-                            trace!(
-                                "    cannot derive {} for Rust union because issue 36640", self.derive_trait
-                            );
-                            return CanDerive::No;
-                        }
-                    // fall through to be same as non-union handling
-                    } else {
-                        if self.ctx.options().rust_features().untagged_union {
-                            trace!(
-                                "    cannot derive {} for Rust unions",
-                                self.derive_trait
-                            );
-                            return CanDerive::No;
-                        }
-
-                        let layout_can_derive =
-                            ty.layout(self.ctx).map_or(CanDerive::Yes, |l| {
-                                l.opaque()
-                                    .array_size_within_derive_limit(self.ctx)
-                            });
-                        match layout_can_derive {
-                            CanDerive::Yes => {
-                                trace!(
-                                    "    union layout can trivially derive {}",
-                                    self.derive_trait
-                                );
-                            }
-                            _ => {
-                                trace!(
-                                    "    union layout cannot derive {}",
-                                    self.derive_trait
-                                );
-                            }
-                        };
-                        return layout_can_derive;
-                    }
-                }
-
-                if !self.derive_trait.can_derive_compound_with_vtable() &&
-                    item.has_vtable(self.ctx)
-                {
-                    trace!(
-                        "    cannot derive {} for comp with vtable",
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                // Bitfield units are always represented as arrays of u8, but
-                // they're not traced as arrays, so we need to check here
-                // instead.
-                if !self.derive_trait.can_derive_large_array(self.ctx) &&
-                    info.has_too_large_bitfield_unit() &&
-                    !item.is_opaque(self.ctx, &())
-                {
-                    trace!(
-                        "    cannot derive {} for comp with too large bitfield unit",
-                        self.derive_trait
-                    );
-                    return CanDerive::No;
-                }
-
-                let pred = self.derive_trait.consider_edge_comp();
-                self.constrain_join(item, pred)
-            }
-
-            TypeKind::ResolvedTypeRef(..) |
-            TypeKind::TemplateAlias(..) |
-            TypeKind::Alias(..) |
-            TypeKind::BlockPointer(..) => {
-                let pred = self.derive_trait.consider_edge_typeref();
-                self.constrain_join(item, pred)
-            }
-
-            TypeKind::TemplateInstantiation(..) => {
-                let pred = self.derive_trait.consider_edge_tmpl_inst();
-                self.constrain_join(item, pred)
-            }
-
-            TypeKind::Opaque => unreachable!(
-                "The early ty.is_opaque check should have handled this case"
-            ),
-        }
-    }
-
-    fn constrain_join(
-        &mut self,
-        item: &Item,
-        consider_edge: EdgePredicate,
-    ) -> CanDerive {
-        let mut candidate = None;
-
-        item.trace(
-            self.ctx,
-            &mut |sub_id, edge_kind| {
-                // Ignore ourselves, since union with ourself is a
-                // no-op. Ignore edges that aren't relevant to the
-                // analysis.
-                if sub_id == item.id() || !consider_edge(edge_kind) {
-                    return;
-                }
-
-                let can_derive = self.can_derive
-                    .get(&sub_id)
-                    .cloned()
-                    .unwrap_or_default();
-
-                match can_derive {
-                    CanDerive::Yes => trace!("    member {:?} can derive {}", sub_id, self.derive_trait),
-                    CanDerive::Manually => trace!("    member {:?} cannot derive {}, but it may be implemented", sub_id, self.derive_trait),
-                    CanDerive::No => trace!("    member {:?} cannot derive {}", sub_id, self.derive_trait),
-                }
-
-                *candidate.get_or_insert(CanDerive::Yes) |= can_derive;
-            },
-            &(),
-        );
-
-        if candidate.is_none() {
-            trace!(
-                "    can derive {} because there are no members",
-                self.derive_trait
-            );
-        }
-        candidate.unwrap_or_default()
-    }
-}
-
-impl DeriveTrait {
-    fn not_by_name(&self, ctx: &BindgenContext, item: &Item) -> bool {
-        match self {
-            DeriveTrait::Copy => ctx.no_copy_by_name(item),
-            DeriveTrait::Debug => ctx.no_debug_by_name(item),
-            DeriveTrait::Default => ctx.no_default_by_name(item),
-            DeriveTrait::Hash => ctx.no_hash_by_name(item),
-            DeriveTrait::PartialEqOrPartialOrd => {
-                ctx.no_partialeq_by_name(item)
-            }
-        }
-    }
-
-    fn consider_edge_comp(&self) -> EdgePredicate {
-        match self {
-            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
-            _ => |kind| matches!(kind, EdgeKind::BaseMember | EdgeKind::Field),
-        }
-    }
-
-    fn consider_edge_typeref(&self) -> EdgePredicate {
-        match self {
-            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
-            _ => |kind| kind == EdgeKind::TypeReference,
-        }
-    }
-
-    fn consider_edge_tmpl_inst(&self) -> EdgePredicate {
-        match self {
-            DeriveTrait::PartialEqOrPartialOrd => consider_edge_default,
-            _ => |kind| {
-                matches!(
-                    kind,
-                    EdgeKind::TemplateArgument | EdgeKind::TemplateDeclaration
-                )
-            },
-        }
-    }
-
-    fn can_derive_large_array(&self, ctx: &BindgenContext) -> bool {
-        if ctx.options().rust_features().larger_arrays {
-            !matches!(self, DeriveTrait::Default)
-        } else {
-            matches!(self, DeriveTrait::Copy)
-        }
-    }
-
-    fn can_derive_union(&self) -> bool {
-        matches!(self, DeriveTrait::Copy)
-    }
-
-    fn can_derive_compound_with_destructor(&self) -> bool {
-        !matches!(self, DeriveTrait::Copy)
-    }
-
-    fn can_derive_compound_with_vtable(&self) -> bool {
-        !matches!(self, DeriveTrait::Default)
-    }
-
-    fn can_derive_compound_forward_decl(&self) -> bool {
-        matches!(self, DeriveTrait::Copy | DeriveTrait::Debug)
-    }
-
-    fn can_derive_incomplete_array(&self) -> bool {
-        !matches!(
-            self,
-            DeriveTrait::Copy |
-                DeriveTrait::Hash |
-                DeriveTrait::PartialEqOrPartialOrd
-        )
-    }
-
-    fn can_derive_fnptr(&self, f: &FunctionSig) -> CanDerive {
-        match (self, f.function_pointers_can_derive()) {
-            (DeriveTrait::Copy, _) | (DeriveTrait::Default, _) | (_, true) => {
-                trace!("    function pointer can derive {}", self);
-                CanDerive::Yes
-            }
-            (DeriveTrait::Debug, false) => {
-                trace!("    function pointer cannot derive {}, but it may be implemented", self);
-                CanDerive::Manually
-            }
-            (_, false) => {
-                trace!("    function pointer cannot derive {}", self);
-                CanDerive::No
-            }
-        }
-    }
-
-    fn can_derive_vector(&self) -> CanDerive {
-        match self {
-            DeriveTrait::PartialEqOrPartialOrd => {
-                // FIXME: vectors always can derive PartialEq, but they should
-                // not derive PartialOrd:
-                // https://github.com/rust-lang-nursery/packed_simd/issues/48
-                trace!("    vectors cannot derive PartialOrd");
-                CanDerive::No
-            }
-            _ => {
-                trace!("    vector can derive {}", self);
-                CanDerive::Yes
-            }
-        }
-    }
-
-    fn can_derive_pointer(&self) -> CanDerive {
-        match self {
-            DeriveTrait::Default => {
-                trace!("    pointer cannot derive Default");
-                CanDerive::No
-            }
-            _ => {
-                trace!("    pointer can derive {}", self);
-                CanDerive::Yes
-            }
-        }
-    }
-
-    fn can_derive_simple(&self, kind: &TypeKind) -> CanDerive {
-        match (self, kind) {
-            // === Default ===
-            (DeriveTrait::Default, TypeKind::Void) |
-            (DeriveTrait::Default, TypeKind::NullPtr) |
-            (DeriveTrait::Default, TypeKind::Enum(..)) |
-            (DeriveTrait::Default, TypeKind::Reference(..)) |
-            (DeriveTrait::Default, TypeKind::TypeParam) |
-            (DeriveTrait::Default, TypeKind::ObjCInterface(..)) |
-            (DeriveTrait::Default, TypeKind::ObjCId) |
-            (DeriveTrait::Default, TypeKind::ObjCSel) => {
-                trace!("    types that always cannot derive Default");
-                CanDerive::No
-            }
-            (DeriveTrait::Default, TypeKind::UnresolvedTypeRef(..)) => {
-                unreachable!(
-                    "Type with unresolved type ref can't reach derive default"
-                )
-            }
-            // === Hash ===
-            (DeriveTrait::Hash, TypeKind::Float(..)) |
-            (DeriveTrait::Hash, TypeKind::Complex(..)) => {
-                trace!("    float cannot derive Hash");
-                CanDerive::No
-            }
-            // === others ===
-            _ => {
-                trace!("    simple type that can always derive {}", self);
-                CanDerive::Yes
-            }
-        }
-    }
-}
-
-impl fmt::Display for DeriveTrait {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let s = match self {
-            DeriveTrait::Copy => "Copy",
-            DeriveTrait::Debug => "Debug",
-            DeriveTrait::Default => "Default",
-            DeriveTrait::Hash => "Hash",
-            DeriveTrait::PartialEqOrPartialOrd => "PartialEq/PartialOrd",
-        };
-        s.fmt(f)
-    }
-}
-
-impl<'ctx> MonotoneFramework for CannotDerive<'ctx> {
-    type Node = ItemId;
-    type Extra = (&'ctx BindgenContext, DeriveTrait);
-    type Output = HashMap<ItemId, CanDerive>;
-
-    fn new(
-        (ctx, derive_trait): (&'ctx BindgenContext, DeriveTrait),
-    ) -> CannotDerive<'ctx> {
-        let can_derive = HashMap::default();
-        let dependencies = generate_dependencies(ctx, consider_edge_default);
-
-        CannotDerive {
-            ctx,
-            derive_trait,
-            can_derive,
-            dependencies,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        // The transitive closure of all allowlisted items, including explicitly
-        // blocklisted items.
-        self.ctx
-            .allowlisted_items()
-            .iter()
-            .cloned()
-            .flat_map(|i| {
-                let mut reachable = vec![i];
-                i.trace(
-                    self.ctx,
-                    &mut |s, _| {
-                        reachable.push(s);
-                    },
-                    &(),
-                );
-                reachable
-            })
-            .collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        trace!("constrain: {:?}", id);
-
-        if let Some(CanDerive::No) = self.can_derive.get(&id).cloned() {
-            trace!("    already know it cannot derive {}", self.derive_trait);
-            return ConstrainResult::Same;
-        }
-
-        let item = self.ctx.resolve_item(id);
-        let can_derive = match item.as_type() {
-            Some(ty) => {
-                let mut can_derive = self.constrain_type(item, ty);
-                if let CanDerive::Yes = can_derive {
-                    let is_reached_limit =
-                        |l: Layout| l.align > RUST_DERIVE_IN_ARRAY_LIMIT;
-                    if !self.derive_trait.can_derive_large_array(self.ctx) &&
-                        ty.layout(self.ctx).map_or(false, is_reached_limit)
-                    {
-                        // We have to be conservative: the struct *could* have enough
-                        // padding that we emit an array that is longer than
-                        // `RUST_DERIVE_IN_ARRAY_LIMIT`. If we moved padding calculations
-                        // into the IR and computed them before this analysis, then we could
-                        // be precise rather than conservative here.
-                        can_derive = CanDerive::Manually;
-                    }
-                }
-                can_derive
-            }
-            None => self.constrain_join(item, consider_edge_default),
-        };
-
-        self.insert(id, can_derive)
-    }
-
-    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<CannotDerive<'ctx>> for HashMap<ItemId, CanDerive> {
-    fn from(analysis: CannotDerive<'ctx>) -> Self {
-        extra_assert!(analysis
-            .can_derive
-            .values()
-            .all(|v| *v != CanDerive::Yes));
-
-        analysis.can_derive
-    }
-}
-
-/// Convert a `HashMap<ItemId, CanDerive>` into a `HashSet<ItemId>`.
-///
-/// Elements that are not `CanDerive::Yes` are kept in the set, so that it
-/// represents all items that cannot derive.
-pub fn as_cannot_derive_set(
-    can_derive: HashMap<ItemId, CanDerive>,
-) -> HashSet<ItemId> {
-    can_derive
-        .into_iter()
-        .filter_map(|(k, v)| if v != CanDerive::Yes { Some(k) } else { None })
-        .collect()
-}
diff --git a/src/ir/analysis/has_destructor.rs b/src/ir/analysis/has_destructor.rs
deleted file mode 100644
index 74fd73d1..00000000
--- a/src/ir/analysis/has_destructor.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-//! Determining which types have destructors
-
-use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
-use crate::ir::comp::{CompKind, Field, FieldMethods};
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::traversal::EdgeKind;
-use crate::ir::ty::TypeKind;
-use crate::{HashMap, HashSet};
-
-/// An analysis that finds for each IR item whether it has a destructor or not
-///
-/// We use the monotone function `has destructor`, defined as follows:
-///
-/// * If T is a type alias, a templated alias, or an indirection to another type,
-///   T has a destructor if the type T refers to has a destructor.
-/// * If T is a compound type, T has a destructor if we saw a destructor when parsing it,
-///   or if it's a struct, T has a destructor if any of its base members has a destructor,
-///   or if any of its fields have a destructor.
-/// * If T is an instantiation of an abstract template definition, T has
-///   a destructor if its template definition has a destructor,
-///   or if any of the template arguments has a destructor.
-/// * If T is the type of a field, that field has a destructor if it's not a bitfield,
-///   and if T has a destructor.
-#[derive(Debug, Clone)]
-pub struct HasDestructorAnalysis<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    // The incremental result of this analysis's computation. Everything in this
-    // set definitely has a destructor.
-    have_destructor: HashSet<ItemId>,
-
-    // Dependencies saying that if a key ItemId has been inserted into the
-    // `have_destructor` set, then each of the ids in Vec<ItemId> need to be
-    // considered again.
-    //
-    // This is a subset of the natural IR graph with reversed edges, where we
-    // only include the edges from the IR graph that can affect whether a type
-    // has a destructor or not.
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-}
-
-impl<'ctx> HasDestructorAnalysis<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        // These are the only edges that can affect whether a type has a
-        // destructor or not.
-        matches!(
-            kind,
-            EdgeKind::TypeReference |
-                EdgeKind::BaseMember |
-                EdgeKind::Field |
-                EdgeKind::TemplateArgument |
-                EdgeKind::TemplateDeclaration
-        )
-    }
-
-    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
-        let id = id.into();
-        let was_not_already_in_set = self.have_destructor.insert(id);
-        assert!(
-            was_not_already_in_set,
-            "We shouldn't try and insert {:?} twice because if it was \
-             already in the set, `constrain` should have exited early.",
-            id
-        );
-        ConstrainResult::Changed
-    }
-}
-
-impl<'ctx> MonotoneFramework for HasDestructorAnalysis<'ctx> {
-    type Node = ItemId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashSet<ItemId>;
-
-    fn new(ctx: &'ctx BindgenContext) -> Self {
-        let have_destructor = HashSet::default();
-        let dependencies = generate_dependencies(ctx, Self::consider_edge);
-
-        HasDestructorAnalysis {
-            ctx,
-            have_destructor,
-            dependencies,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        self.ctx.allowlisted_items().iter().cloned().collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        if self.have_destructor.contains(&id) {
-            // We've already computed that this type has a destructor and that can't
-            // change.
-            return ConstrainResult::Same;
-        }
-
-        let item = self.ctx.resolve_item(id);
-        let ty = match item.as_type() {
-            None => return ConstrainResult::Same,
-            Some(ty) => ty,
-        };
-
-        match *ty.kind() {
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::ResolvedTypeRef(t) => {
-                if self.have_destructor.contains(&t.into()) {
-                    self.insert(id)
-                } else {
-                    ConstrainResult::Same
-                }
-            }
-
-            TypeKind::Comp(ref info) => {
-                if info.has_own_destructor() {
-                    return self.insert(id);
-                }
-
-                match info.kind() {
-                    CompKind::Union => ConstrainResult::Same,
-                    CompKind::Struct => {
-                        let base_or_field_destructor =
-                            info.base_members().iter().any(|base| {
-                                self.have_destructor.contains(&base.ty.into())
-                            }) || info.fields().iter().any(
-                                |field| match *field {
-                                    Field::DataMember(ref data) => self
-                                        .have_destructor
-                                        .contains(&data.ty().into()),
-                                    Field::Bitfields(_) => false,
-                                },
-                            );
-                        if base_or_field_destructor {
-                            self.insert(id)
-                        } else {
-                            ConstrainResult::Same
-                        }
-                    }
-                }
-            }
-
-            TypeKind::TemplateInstantiation(ref inst) => {
-                let definition_or_arg_destructor = self
-                    .have_destructor
-                    .contains(&inst.template_definition().into()) ||
-                    inst.template_arguments().iter().any(|arg| {
-                        self.have_destructor.contains(&arg.into())
-                    });
-                if definition_or_arg_destructor {
-                    self.insert(id)
-                } else {
-                    ConstrainResult::Same
-                }
-            }
-
-            _ => ConstrainResult::Same,
-        }
-    }
-
-    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<HasDestructorAnalysis<'ctx>> for HashSet<ItemId> {
-    fn from(analysis: HasDestructorAnalysis<'ctx>) -> Self {
-        analysis.have_destructor
-    }
-}
diff --git a/src/ir/analysis/has_float.rs b/src/ir/analysis/has_float.rs
deleted file mode 100644
index bbf2126f..00000000
--- a/src/ir/analysis/has_float.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-//! Determining which types has float.
-
-use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
-use crate::ir::comp::Field;
-use crate::ir::comp::FieldMethods;
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::traversal::EdgeKind;
-use crate::ir::ty::TypeKind;
-use crate::{HashMap, HashSet};
-
-/// An analysis that finds for each IR item whether it has float or not.
-///
-/// We use the monotone constraint function `has_float`,
-/// defined as follows:
-///
-/// * If T is float or complex float, T trivially has.
-/// * If T is a type alias, a templated alias or an indirection to another type,
-///   it has float if the type T refers to has.
-/// * If T is a compound type, it has float if any of base memter or field
-///   has.
-/// * If T is an instantiation of an abstract template definition, T has
-///   float if any of the template arguments or template definition
-///   has.
-#[derive(Debug, Clone)]
-pub struct HasFloat<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    // The incremental result of this analysis's computation. Everything in this
-    // set has float.
-    has_float: HashSet<ItemId>,
-
-    // Dependencies saying that if a key ItemId has been inserted into the
-    // `has_float` set, then each of the ids in Vec<ItemId> need to be
-    // considered again.
-    //
-    // This is a subset of the natural IR graph with reversed edges, where we
-    // only include the edges from the IR graph that can affect whether a type
-    // has float or not.
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-}
-
-impl<'ctx> HasFloat<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        match kind {
-            EdgeKind::BaseMember |
-            EdgeKind::Field |
-            EdgeKind::TypeReference |
-            EdgeKind::VarType |
-            EdgeKind::TemplateArgument |
-            EdgeKind::TemplateDeclaration |
-            EdgeKind::TemplateParameterDefinition => true,
-
-            EdgeKind::Constructor |
-            EdgeKind::Destructor |
-            EdgeKind::FunctionReturn |
-            EdgeKind::FunctionParameter |
-            EdgeKind::InnerType |
-            EdgeKind::InnerVar |
-            EdgeKind::Method => false,
-            EdgeKind::Generic => false,
-        }
-    }
-
-    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
-        let id = id.into();
-        trace!("inserting {:?} into the has_float set", id);
-
-        let was_not_already_in_set = self.has_float.insert(id);
-        assert!(
-            was_not_already_in_set,
-            "We shouldn't try and insert {:?} twice because if it was \
-             already in the set, `constrain` should have exited early.",
-            id
-        );
-
-        ConstrainResult::Changed
-    }
-}
-
-impl<'ctx> MonotoneFramework for HasFloat<'ctx> {
-    type Node = ItemId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashSet<ItemId>;
-
-    fn new(ctx: &'ctx BindgenContext) -> HasFloat<'ctx> {
-        let has_float = HashSet::default();
-        let dependencies = generate_dependencies(ctx, Self::consider_edge);
-
-        HasFloat {
-            ctx,
-            has_float,
-            dependencies,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        self.ctx.allowlisted_items().iter().cloned().collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        trace!("constrain: {:?}", id);
-
-        if self.has_float.contains(&id) {
-            trace!("    already know it do not have float");
-            return ConstrainResult::Same;
-        }
-
-        let item = self.ctx.resolve_item(id);
-        let ty = match item.as_type() {
-            Some(ty) => ty,
-            None => {
-                trace!("    not a type; ignoring");
-                return ConstrainResult::Same;
-            }
-        };
-
-        match *ty.kind() {
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(..) |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::Reference(..) |
-            TypeKind::TypeParam |
-            TypeKind::Opaque |
-            TypeKind::Pointer(..) |
-            TypeKind::UnresolvedTypeRef(..) |
-            TypeKind::ObjCInterface(..) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel => {
-                trace!("    simple type that do not have float");
-                ConstrainResult::Same
-            }
-
-            TypeKind::Float(..) | TypeKind::Complex(..) => {
-                trace!("    float type has float");
-                self.insert(id)
-            }
-
-            TypeKind::Array(t, _) => {
-                if self.has_float.contains(&t.into()) {
-                    trace!(
-                        "    Array with type T that has float also has float"
-                    );
-                    return self.insert(id);
-                }
-                trace!("    Array with type T that do not have float also do not have float");
-                ConstrainResult::Same
-            }
-            TypeKind::Vector(t, _) => {
-                if self.has_float.contains(&t.into()) {
-                    trace!(
-                        "    Vector with type T that has float also has float"
-                    );
-                    return self.insert(id);
-                }
-                trace!("    Vector with type T that do not have float also do not have float");
-                ConstrainResult::Same
-            }
-
-            TypeKind::ResolvedTypeRef(t) |
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::BlockPointer(t) => {
-                if self.has_float.contains(&t.into()) {
-                    trace!(
-                        "    aliases and type refs to T which have float \
-                         also have float"
-                    );
-                    self.insert(id)
-                } else {
-                    trace!("    aliases and type refs to T which do not have float \
-                            also do not have floaarrayt");
-                    ConstrainResult::Same
-                }
-            }
-
-            TypeKind::Comp(ref info) => {
-                let bases_have = info
-                    .base_members()
-                    .iter()
-                    .any(|base| self.has_float.contains(&base.ty.into()));
-                if bases_have {
-                    trace!("    bases have float, so we also have");
-                    return self.insert(id);
-                }
-                let fields_have = info.fields().iter().any(|f| match *f {
-                    Field::DataMember(ref data) => {
-                        self.has_float.contains(&data.ty().into())
-                    }
-                    Field::Bitfields(ref bfu) => bfu
-                        .bitfields()
-                        .iter()
-                        .any(|b| self.has_float.contains(&b.ty().into())),
-                });
-                if fields_have {
-                    trace!("    fields have float, so we also have");
-                    return self.insert(id);
-                }
-
-                trace!("    comp doesn't have float");
-                ConstrainResult::Same
-            }
-
-            TypeKind::TemplateInstantiation(ref template) => {
-                let args_have = template
-                    .template_arguments()
-                    .iter()
-                    .any(|arg| self.has_float.contains(&arg.into()));
-                if args_have {
-                    trace!(
-                        "    template args have float, so \
-                         insantiation also has float"
-                    );
-                    return self.insert(id);
-                }
-
-                let def_has = self
-                    .has_float
-                    .contains(&template.template_definition().into());
-                if def_has {
-                    trace!(
-                        "    template definition has float, so \
-                         insantiation also has"
-                    );
-                    return self.insert(id);
-                }
-
-                trace!("    template instantiation do not have float");
-                ConstrainResult::Same
-            }
-        }
-    }
-
-    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<HasFloat<'ctx>> for HashSet<ItemId> {
-    fn from(analysis: HasFloat<'ctx>) -> Self {
-        analysis.has_float
-    }
-}
diff --git a/src/ir/analysis/has_type_param_in_array.rs b/src/ir/analysis/has_type_param_in_array.rs
deleted file mode 100644
index aa523047..00000000
--- a/src/ir/analysis/has_type_param_in_array.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-//! Determining which types has typed parameters in array.
-
-use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
-use crate::ir::comp::Field;
-use crate::ir::comp::FieldMethods;
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::traversal::EdgeKind;
-use crate::ir::ty::TypeKind;
-use crate::{HashMap, HashSet};
-
-/// An analysis that finds for each IR item whether it has array or not.
-///
-/// We use the monotone constraint function `has_type_parameter_in_array`,
-/// defined as follows:
-///
-/// * If T is Array type with type parameter, T trivially has.
-/// * If T is a type alias, a templated alias or an indirection to another type,
-///   it has type parameter in array if the type T refers to has.
-/// * If T is a compound type, it has array if any of base memter or field
-///   has type paramter in array.
-/// * If T is an instantiation of an abstract template definition, T has
-///   type parameter in array if any of the template arguments or template definition
-///   has.
-#[derive(Debug, Clone)]
-pub struct HasTypeParameterInArray<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    // The incremental result of this analysis's computation. Everything in this
-    // set has array.
-    has_type_parameter_in_array: HashSet<ItemId>,
-
-    // Dependencies saying that if a key ItemId has been inserted into the
-    // `has_type_parameter_in_array` set, then each of the ids in Vec<ItemId> need to be
-    // considered again.
-    //
-    // This is a subset of the natural IR graph with reversed edges, where we
-    // only include the edges from the IR graph that can affect whether a type
-    // has array or not.
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-}
-
-impl<'ctx> HasTypeParameterInArray<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        match kind {
-            // These are the only edges that can affect whether a type has type parameter
-            // in array or not.
-            EdgeKind::BaseMember |
-            EdgeKind::Field |
-            EdgeKind::TypeReference |
-            EdgeKind::VarType |
-            EdgeKind::TemplateArgument |
-            EdgeKind::TemplateDeclaration |
-            EdgeKind::TemplateParameterDefinition => true,
-
-            EdgeKind::Constructor |
-            EdgeKind::Destructor |
-            EdgeKind::FunctionReturn |
-            EdgeKind::FunctionParameter |
-            EdgeKind::InnerType |
-            EdgeKind::InnerVar |
-            EdgeKind::Method => false,
-            EdgeKind::Generic => false,
-        }
-    }
-
-    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
-        let id = id.into();
-        trace!(
-            "inserting {:?} into the has_type_parameter_in_array set",
-            id
-        );
-
-        let was_not_already_in_set =
-            self.has_type_parameter_in_array.insert(id);
-        assert!(
-            was_not_already_in_set,
-            "We shouldn't try and insert {:?} twice because if it was \
-             already in the set, `constrain` should have exited early.",
-            id
-        );
-
-        ConstrainResult::Changed
-    }
-}
-
-impl<'ctx> MonotoneFramework for HasTypeParameterInArray<'ctx> {
-    type Node = ItemId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashSet<ItemId>;
-
-    fn new(ctx: &'ctx BindgenContext) -> HasTypeParameterInArray<'ctx> {
-        let has_type_parameter_in_array = HashSet::default();
-        let dependencies = generate_dependencies(ctx, Self::consider_edge);
-
-        HasTypeParameterInArray {
-            ctx,
-            has_type_parameter_in_array,
-            dependencies,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        self.ctx.allowlisted_items().iter().cloned().collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        trace!("constrain: {:?}", id);
-
-        if self.has_type_parameter_in_array.contains(&id) {
-            trace!("    already know it do not have array");
-            return ConstrainResult::Same;
-        }
-
-        let item = self.ctx.resolve_item(id);
-        let ty = match item.as_type() {
-            Some(ty) => ty,
-            None => {
-                trace!("    not a type; ignoring");
-                return ConstrainResult::Same;
-            }
-        };
-
-        match *ty.kind() {
-            // Handle the simple cases. These cannot have array in type parameter
-            // without further information.
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Vector(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::Reference(..) |
-            TypeKind::TypeParam |
-            TypeKind::Opaque |
-            TypeKind::Pointer(..) |
-            TypeKind::UnresolvedTypeRef(..) |
-            TypeKind::ObjCInterface(..) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel => {
-                trace!("    simple type that do not have array");
-                ConstrainResult::Same
-            }
-
-            TypeKind::Array(t, _) => {
-                let inner_ty =
-                    self.ctx.resolve_type(t).canonical_type(self.ctx);
-                match *inner_ty.kind() {
-                    TypeKind::TypeParam => {
-                        trace!("    Array with Named type has type parameter");
-                        self.insert(id)
-                    }
-                    _ => {
-                        trace!(
-                            "    Array without Named type does have type parameter"
-                        );
-                        ConstrainResult::Same
-                    }
-                }
-            }
-
-            TypeKind::ResolvedTypeRef(t) |
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::BlockPointer(t) => {
-                if self.has_type_parameter_in_array.contains(&t.into()) {
-                    trace!(
-                        "    aliases and type refs to T which have array \
-                         also have array"
-                    );
-                    self.insert(id)
-                } else {
-                    trace!(
-                        "    aliases and type refs to T which do not have array \
-                            also do not have array"
-                    );
-                    ConstrainResult::Same
-                }
-            }
-
-            TypeKind::Comp(ref info) => {
-                let bases_have = info.base_members().iter().any(|base| {
-                    self.has_type_parameter_in_array.contains(&base.ty.into())
-                });
-                if bases_have {
-                    trace!("    bases have array, so we also have");
-                    return self.insert(id);
-                }
-                let fields_have = info.fields().iter().any(|f| match *f {
-                    Field::DataMember(ref data) => self
-                        .has_type_parameter_in_array
-                        .contains(&data.ty().into()),
-                    Field::Bitfields(..) => false,
-                });
-                if fields_have {
-                    trace!("    fields have array, so we also have");
-                    return self.insert(id);
-                }
-
-                trace!("    comp doesn't have array");
-                ConstrainResult::Same
-            }
-
-            TypeKind::TemplateInstantiation(ref template) => {
-                let args_have =
-                    template.template_arguments().iter().any(|arg| {
-                        self.has_type_parameter_in_array.contains(&arg.into())
-                    });
-                if args_have {
-                    trace!(
-                        "    template args have array, so \
-                         insantiation also has array"
-                    );
-                    return self.insert(id);
-                }
-
-                let def_has = self
-                    .has_type_parameter_in_array
-                    .contains(&template.template_definition().into());
-                if def_has {
-                    trace!(
-                        "    template definition has array, so \
-                         insantiation also has"
-                    );
-                    return self.insert(id);
-                }
-
-                trace!("    template instantiation do not have array");
-                ConstrainResult::Same
-            }
-        }
-    }
-
-    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<HasTypeParameterInArray<'ctx>> for HashSet<ItemId> {
-    fn from(analysis: HasTypeParameterInArray<'ctx>) -> Self {
-        analysis.has_type_parameter_in_array
-    }
-}
diff --git a/src/ir/analysis/has_vtable.rs b/src/ir/analysis/has_vtable.rs
deleted file mode 100644
index 8ac47a65..00000000
--- a/src/ir/analysis/has_vtable.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-//! Determining which types has vtable
-
-use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::traversal::EdgeKind;
-use crate::ir::ty::TypeKind;
-use crate::{Entry, HashMap};
-use std::cmp;
-use std::ops;
-
-/// The result of the `HasVtableAnalysis` for an individual item.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum HasVtableResult {
-    /// The item does not have a vtable pointer.
-    No,
-
-    /// The item has a vtable and the actual vtable pointer is within this item.
-    SelfHasVtable,
-
-    /// The item has a vtable, but the actual vtable pointer is in a base
-    /// member.
-    BaseHasVtable,
-}
-
-impl Default for HasVtableResult {
-    fn default() -> Self {
-        HasVtableResult::No
-    }
-}
-
-impl HasVtableResult {
-    /// Take the least upper bound of `self` and `rhs`.
-    pub fn join(self, rhs: Self) -> Self {
-        cmp::max(self, rhs)
-    }
-}
-
-impl ops::BitOr for HasVtableResult {
-    type Output = Self;
-
-    fn bitor(self, rhs: HasVtableResult) -> Self::Output {
-        self.join(rhs)
-    }
-}
-
-impl ops::BitOrAssign for HasVtableResult {
-    fn bitor_assign(&mut self, rhs: HasVtableResult) {
-        *self = self.join(rhs)
-    }
-}
-
-/// An analysis that finds for each IR item whether it has vtable or not
-///
-/// We use the monotone function `has vtable`, defined as follows:
-///
-/// * If T is a type alias, a templated alias, an indirection to another type,
-///   or a reference of a type, T has vtable if the type T refers to has vtable.
-/// * If T is a compound type, T has vtable if we saw a virtual function when
-///   parsing it or any of its base member has vtable.
-/// * If T is an instantiation of an abstract template definition, T has
-///   vtable if template definition has vtable
-#[derive(Debug, Clone)]
-pub struct HasVtableAnalysis<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    // The incremental result of this analysis's computation. Everything in this
-    // set definitely has a vtable.
-    have_vtable: HashMap<ItemId, HasVtableResult>,
-
-    // Dependencies saying that if a key ItemId has been inserted into the
-    // `have_vtable` set, then each of the ids in Vec<ItemId> need to be
-    // considered again.
-    //
-    // This is a subset of the natural IR graph with reversed edges, where we
-    // only include the edges from the IR graph that can affect whether a type
-    // has a vtable or not.
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-}
-
-impl<'ctx> HasVtableAnalysis<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        // These are the only edges that can affect whether a type has a
-        // vtable or not.
-        matches!(
-            kind,
-            EdgeKind::TypeReference |
-                EdgeKind::BaseMember |
-                EdgeKind::TemplateDeclaration
-        )
-    }
-
-    fn insert<Id: Into<ItemId>>(
-        &mut self,
-        id: Id,
-        result: HasVtableResult,
-    ) -> ConstrainResult {
-        if let HasVtableResult::No = result {
-            return ConstrainResult::Same;
-        }
-
-        let id = id.into();
-        match self.have_vtable.entry(id) {
-            Entry::Occupied(mut entry) => {
-                if *entry.get() < result {
-                    entry.insert(result);
-                    ConstrainResult::Changed
-                } else {
-                    ConstrainResult::Same
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(result);
-                ConstrainResult::Changed
-            }
-        }
-    }
-
-    fn forward<Id1, Id2>(&mut self, from: Id1, to: Id2) -> ConstrainResult
-    where
-        Id1: Into<ItemId>,
-        Id2: Into<ItemId>,
-    {
-        let from = from.into();
-        let to = to.into();
-
-        match self.have_vtable.get(&from).cloned() {
-            None => ConstrainResult::Same,
-            Some(r) => self.insert(to, r),
-        }
-    }
-}
-
-impl<'ctx> MonotoneFramework for HasVtableAnalysis<'ctx> {
-    type Node = ItemId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashMap<ItemId, HasVtableResult>;
-
-    fn new(ctx: &'ctx BindgenContext) -> HasVtableAnalysis<'ctx> {
-        let have_vtable = HashMap::default();
-        let dependencies = generate_dependencies(ctx, Self::consider_edge);
-
-        HasVtableAnalysis {
-            ctx,
-            have_vtable,
-            dependencies,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        self.ctx.allowlisted_items().iter().cloned().collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        trace!("constrain {:?}", id);
-
-        let item = self.ctx.resolve_item(id);
-        let ty = match item.as_type() {
-            None => return ConstrainResult::Same,
-            Some(ty) => ty,
-        };
-
-        // TODO #851: figure out a way to handle deriving from template type parameters.
-        match *ty.kind() {
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::ResolvedTypeRef(t) |
-            TypeKind::Reference(t) => {
-                trace!(
-                    "    aliases and references forward to their inner type"
-                );
-                self.forward(t, id)
-            }
-
-            TypeKind::Comp(ref info) => {
-                trace!("    comp considers its own methods and bases");
-                let mut result = HasVtableResult::No;
-
-                if info.has_own_virtual_method() {
-                    trace!("    comp has its own virtual method");
-                    result |= HasVtableResult::SelfHasVtable;
-                }
-
-                let bases_has_vtable = info.base_members().iter().any(|base| {
-                    trace!("    comp has a base with a vtable: {:?}", base);
-                    self.have_vtable.contains_key(&base.ty.into())
-                });
-                if bases_has_vtable {
-                    result |= HasVtableResult::BaseHasVtable;
-                }
-
-                self.insert(id, result)
-            }
-
-            TypeKind::TemplateInstantiation(ref inst) => {
-                self.forward(inst.template_definition(), id)
-            }
-
-            _ => ConstrainResult::Same,
-        }
-    }
-
-    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<HasVtableAnalysis<'ctx>> for HashMap<ItemId, HasVtableResult> {
-    fn from(analysis: HasVtableAnalysis<'ctx>) -> Self {
-        // We let the lack of an entry mean "No" to save space.
-        extra_assert!(analysis
-            .have_vtable
-            .values()
-            .all(|v| { *v != HasVtableResult::No }));
-
-        analysis.have_vtable
-    }
-}
-
-/// A convenience trait for the things for which we might wonder if they have a
-/// vtable during codegen.
-///
-/// This is not for _computing_ whether the thing has a vtable, it is for
-/// looking up the results of the HasVtableAnalysis's computations for a
-/// specific thing.
-pub trait HasVtable {
-    /// Return `true` if this thing has vtable, `false` otherwise.
-    fn has_vtable(&self, ctx: &BindgenContext) -> bool;
-
-    /// Return `true` if this thing has an actual vtable pointer in itself, as
-    /// opposed to transitively in a base member.
-    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool;
-}
diff --git a/src/ir/analysis/mod.rs b/src/ir/analysis/mod.rs
deleted file mode 100644
index 40dfc6d6..00000000
--- a/src/ir/analysis/mod.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-//! Fix-point analyses on the IR using the "monotone framework".
-//!
-//! A lattice is a set with a partial ordering between elements, where there is
-//! a single least upper bound and a single greatest least bound for every
-//! subset. We are dealing with finite lattices, which means that it has a
-//! finite number of elements, and it follows that there exists a single top and
-//! a single bottom member of the lattice. For example, the power set of a
-//! finite set forms a finite lattice where partial ordering is defined by set
-//! inclusion, that is `a <= b` if `a` is a subset of `b`. Here is the finite
-//! lattice constructed from the set {0,1,2}:
-//!
-//! ```text
-//!                    .----- Top = {0,1,2} -----.
-//!                   /            |              \
-//!                  /             |               \
-//!                 /              |                \
-//!              {0,1} -------.  {0,2}  .--------- {1,2}
-//!                |           \ /   \ /             |
-//!                |            /     \              |
-//!                |           / \   / \             |
-//!               {0} --------'   {1}   `---------- {2}
-//!                 \              |                /
-//!                  \             |               /
-//!                   \            |              /
-//!                    `------ Bottom = {} ------'
-//! ```
-//!
-//! A monotone function `f` is a function where if `x <= y`, then it holds that
-//! `f(x) <= f(y)`. It should be clear that running a monotone function to a
-//! fix-point on a finite lattice will always terminate: `f` can only "move"
-//! along the lattice in a single direction, and therefore can only either find
-//! a fix-point in the middle of the lattice or continue to the top or bottom
-//! depending if it is ascending or descending the lattice respectively.
-//!
-//! For a deeper introduction to the general form of this kind of analysis, see
-//! [Static Program Analysis by Anders Møller and Michael I. Schwartzbach][spa].
-//!
-//! [spa]: https://cs.au.dk/~amoeller/spa/spa.pdf
-
-// Re-export individual analyses.
-mod template_params;
-pub use self::template_params::UsedTemplateParameters;
-mod derive;
-pub use self::derive::{as_cannot_derive_set, CannotDerive, DeriveTrait};
-mod has_vtable;
-pub use self::has_vtable::{HasVtable, HasVtableAnalysis, HasVtableResult};
-mod has_destructor;
-pub use self::has_destructor::HasDestructorAnalysis;
-mod has_type_param_in_array;
-pub use self::has_type_param_in_array::HasTypeParameterInArray;
-mod has_float;
-pub use self::has_float::HasFloat;
-mod sizedness;
-pub use self::sizedness::{Sizedness, SizednessAnalysis, SizednessResult};
-
-use crate::ir::context::{BindgenContext, ItemId};
-
-use crate::ir::traversal::{EdgeKind, Trace};
-use crate::HashMap;
-use std::fmt;
-use std::ops;
-
-/// An analysis in the monotone framework.
-///
-/// Implementors of this trait must maintain the following two invariants:
-///
-/// 1. The concrete data must be a member of a finite-height lattice.
-/// 2. The concrete `constrain` method must be monotone: that is,
-///    if `x <= y`, then `constrain(x) <= constrain(y)`.
-///
-/// If these invariants do not hold, iteration to a fix-point might never
-/// complete.
-///
-/// For a simple example analysis, see the `ReachableFrom` type in the `tests`
-/// module below.
-pub trait MonotoneFramework: Sized + fmt::Debug {
-    /// The type of node in our dependency graph.
-    ///
-    /// This is just generic (and not `ItemId`) so that we can easily unit test
-    /// without constructing real `Item`s and their `ItemId`s.
-    type Node: Copy;
-
-    /// Any extra data that is needed during computation.
-    ///
-    /// Again, this is just generic (and not `&BindgenContext`) so that we can
-    /// easily unit test without constructing real `BindgenContext`s full of
-    /// real `Item`s and real `ItemId`s.
-    type Extra: Sized;
-
-    /// The final output of this analysis. Once we have reached a fix-point, we
-    /// convert `self` into this type, and return it as the final result of the
-    /// analysis.
-    type Output: From<Self> + fmt::Debug;
-
-    /// Construct a new instance of this analysis.
-    fn new(extra: Self::Extra) -> Self;
-
-    /// Get the initial set of nodes from which to start the analysis. Unless
-    /// you are sure of some domain-specific knowledge, this should be the
-    /// complete set of nodes.
-    fn initial_worklist(&self) -> Vec<Self::Node>;
-
-    /// Update the analysis for the given node.
-    ///
-    /// If this results in changing our internal state (ie, we discovered that
-    /// we have not reached a fix-point and iteration should continue), return
-    /// `ConstrainResult::Changed`. Otherwise, return `ConstrainResult::Same`.
-    /// When `constrain` returns `ConstrainResult::Same` for all nodes in the
-    /// set, we have reached a fix-point and the analysis is complete.
-    fn constrain(&mut self, node: Self::Node) -> ConstrainResult;
-
-    /// For each node `d` that depends on the given `node`'s current answer when
-    /// running `constrain(d)`, call `f(d)`. This informs us which new nodes to
-    /// queue up in the worklist when `constrain(node)` reports updated
-    /// information.
-    fn each_depending_on<F>(&self, node: Self::Node, f: F)
-    where
-        F: FnMut(Self::Node);
-}
-
-/// Whether an analysis's `constrain` function modified the incremental results
-/// or not.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ConstrainResult {
-    /// The incremental results were updated, and the fix-point computation
-    /// should continue.
-    Changed,
-
-    /// The incremental results were not updated.
-    Same,
-}
-
-impl Default for ConstrainResult {
-    fn default() -> Self {
-        ConstrainResult::Same
-    }
-}
-
-impl ops::BitOr for ConstrainResult {
-    type Output = Self;
-
-    fn bitor(self, rhs: ConstrainResult) -> Self::Output {
-        if self == ConstrainResult::Changed || rhs == ConstrainResult::Changed {
-            ConstrainResult::Changed
-        } else {
-            ConstrainResult::Same
-        }
-    }
-}
-
-impl ops::BitOrAssign for ConstrainResult {
-    fn bitor_assign(&mut self, rhs: ConstrainResult) {
-        *self = *self | rhs;
-    }
-}
-
-/// Run an analysis in the monotone framework.
-pub fn analyze<Analysis>(extra: Analysis::Extra) -> Analysis::Output
-where
-    Analysis: MonotoneFramework,
-{
-    let mut analysis = Analysis::new(extra);
-    let mut worklist = analysis.initial_worklist();
-
-    while let Some(node) = worklist.pop() {
-        if let ConstrainResult::Changed = analysis.constrain(node) {
-            analysis.each_depending_on(node, |needs_work| {
-                worklist.push(needs_work);
-            });
-        }
-    }
-
-    analysis.into()
-}
-
-/// Generate the dependency map for analysis
-pub fn generate_dependencies<F>(
-    ctx: &BindgenContext,
-    consider_edge: F,
-) -> HashMap<ItemId, Vec<ItemId>>
-where
-    F: Fn(EdgeKind) -> bool,
-{
-    let mut dependencies = HashMap::default();
-
-    for &item in ctx.allowlisted_items() {
-        dependencies.entry(item).or_insert_with(Vec::new);
-
-        {
-            // We reverse our natural IR graph edges to find dependencies
-            // between nodes.
-            item.trace(
-                ctx,
-                &mut |sub_item: ItemId, edge_kind| {
-                    if ctx.allowlisted_items().contains(&sub_item) &&
-                        consider_edge(edge_kind)
-                    {
-                        dependencies
-                            .entry(sub_item)
-                            .or_insert_with(Vec::new)
-                            .push(item);
-                    }
-                },
-                &(),
-            );
-        }
-    }
-    dependencies
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{HashMap, HashSet};
-
-    // Here we find the set of nodes that are reachable from any given
-    // node. This is a lattice mapping nodes to subsets of all nodes. Our join
-    // function is set union.
-    //
-    // This is our test graph:
-    //
-    //     +---+                    +---+
-    //     |   |                    |   |
-    //     | 1 |               .----| 2 |
-    //     |   |               |    |   |
-    //     +---+               |    +---+
-    //       |                 |      ^
-    //       |                 |      |
-    //       |      +---+      '------'
-    //       '----->|   |
-    //              | 3 |
-    //       .------|   |------.
-    //       |      +---+      |
-    //       |        ^        |
-    //       v        |        v
-    //     +---+      |      +---+    +---+
-    //     |   |      |      |   |    |   |
-    //     | 4 |      |      | 5 |--->| 6 |
-    //     |   |      |      |   |    |   |
-    //     +---+      |      +---+    +---+
-    //       |        |        |        |
-    //       |        |        |        v
-    //       |      +---+      |      +---+
-    //       |      |   |      |      |   |
-    //       '----->| 7 |<-----'      | 8 |
-    //              |   |             |   |
-    //              +---+             +---+
-    //
-    // And here is the mapping from a node to the set of nodes that are
-    // reachable from it within the test graph:
-    //
-    //     1: {3,4,5,6,7,8}
-    //     2: {2}
-    //     3: {3,4,5,6,7,8}
-    //     4: {3,4,5,6,7,8}
-    //     5: {3,4,5,6,7,8}
-    //     6: {8}
-    //     7: {3,4,5,6,7,8}
-    //     8: {}
-
-    #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-    struct Node(usize);
-
-    #[derive(Clone, Debug, Default, PartialEq, Eq)]
-    struct Graph(HashMap<Node, Vec<Node>>);
-
-    impl Graph {
-        fn make_test_graph() -> Graph {
-            let mut g = Graph::default();
-            g.0.insert(Node(1), vec![Node(3)]);
-            g.0.insert(Node(2), vec![Node(2)]);
-            g.0.insert(Node(3), vec![Node(4), Node(5)]);
-            g.0.insert(Node(4), vec![Node(7)]);
-            g.0.insert(Node(5), vec![Node(6), Node(7)]);
-            g.0.insert(Node(6), vec![Node(8)]);
-            g.0.insert(Node(7), vec![Node(3)]);
-            g.0.insert(Node(8), vec![]);
-            g
-        }
-
-        fn reverse(&self) -> Graph {
-            let mut reversed = Graph::default();
-            for (node, edges) in self.0.iter() {
-                reversed.0.entry(*node).or_insert_with(Vec::new);
-                for referent in edges.iter() {
-                    reversed
-                        .0
-                        .entry(*referent)
-                        .or_insert_with(Vec::new)
-                        .push(*node);
-                }
-            }
-            reversed
-        }
-    }
-
-    #[derive(Clone, Debug, PartialEq, Eq)]
-    struct ReachableFrom<'a> {
-        reachable: HashMap<Node, HashSet<Node>>,
-        graph: &'a Graph,
-        reversed: Graph,
-    }
-
-    impl<'a> MonotoneFramework for ReachableFrom<'a> {
-        type Node = Node;
-        type Extra = &'a Graph;
-        type Output = HashMap<Node, HashSet<Node>>;
-
-        fn new(graph: &'a Graph) -> ReachableFrom {
-            let reversed = graph.reverse();
-            ReachableFrom {
-                reachable: Default::default(),
-                graph,
-                reversed,
-            }
-        }
-
-        fn initial_worklist(&self) -> Vec<Node> {
-            self.graph.0.keys().cloned().collect()
-        }
-
-        fn constrain(&mut self, node: Node) -> ConstrainResult {
-            // The set of nodes reachable from a node `x` is
-            //
-            //     reachable(x) = s_0 U s_1 U ... U reachable(s_0) U reachable(s_1) U ...
-            //
-            // where there exist edges from `x` to each of `s_0, s_1, ...`.
-            //
-            // Yes, what follows is a **terribly** inefficient set union
-            // implementation. Don't copy this code outside of this test!
-
-            let original_size = self
-                .reachable
-                .entry(node)
-                .or_insert_with(HashSet::default)
-                .len();
-
-            for sub_node in self.graph.0[&node].iter() {
-                self.reachable.get_mut(&node).unwrap().insert(*sub_node);
-
-                let sub_reachable = self
-                    .reachable
-                    .entry(*sub_node)
-                    .or_insert_with(HashSet::default)
-                    .clone();
-
-                for transitive in sub_reachable {
-                    self.reachable.get_mut(&node).unwrap().insert(transitive);
-                }
-            }
-
-            let new_size = self.reachable[&node].len();
-            if original_size != new_size {
-                ConstrainResult::Changed
-            } else {
-                ConstrainResult::Same
-            }
-        }
-
-        fn each_depending_on<F>(&self, node: Node, mut f: F)
-        where
-            F: FnMut(Node),
-        {
-            for dep in self.reversed.0[&node].iter() {
-                f(*dep);
-            }
-        }
-    }
-
-    impl<'a> From<ReachableFrom<'a>> for HashMap<Node, HashSet<Node>> {
-        fn from(reachable: ReachableFrom<'a>) -> Self {
-            reachable.reachable
-        }
-    }
-
-    #[test]
-    fn monotone() {
-        let g = Graph::make_test_graph();
-        let reachable = analyze::<ReachableFrom>(&g);
-        println!("reachable = {:#?}", reachable);
-
-        fn nodes<A>(nodes: A) -> HashSet<Node>
-        where
-            A: AsRef<[usize]>,
-        {
-            nodes.as_ref().iter().cloned().map(Node).collect()
-        }
-
-        let mut expected = HashMap::default();
-        expected.insert(Node(1), nodes([3, 4, 5, 6, 7, 8]));
-        expected.insert(Node(2), nodes([2]));
-        expected.insert(Node(3), nodes([3, 4, 5, 6, 7, 8]));
-        expected.insert(Node(4), nodes([3, 4, 5, 6, 7, 8]));
-        expected.insert(Node(5), nodes([3, 4, 5, 6, 7, 8]));
-        expected.insert(Node(6), nodes([8]));
-        expected.insert(Node(7), nodes([3, 4, 5, 6, 7, 8]));
-        expected.insert(Node(8), nodes([]));
-        println!("expected = {:#?}", expected);
-
-        assert_eq!(reachable, expected);
-    }
-}
diff --git a/src/ir/analysis/sizedness.rs b/src/ir/analysis/sizedness.rs
deleted file mode 100644
index 251c3747..00000000
--- a/src/ir/analysis/sizedness.rs
+++ /dev/null
@@ -1,361 +0,0 @@
-//! Determining the sizedness of types (as base classes and otherwise).
-
-use super::{
-    generate_dependencies, ConstrainResult, HasVtable, MonotoneFramework,
-};
-use crate::ir::context::{BindgenContext, TypeId};
-use crate::ir::item::IsOpaque;
-use crate::ir::traversal::EdgeKind;
-use crate::ir::ty::TypeKind;
-use crate::{Entry, HashMap};
-use std::{cmp, ops};
-
-/// The result of the `Sizedness` analysis for an individual item.
-///
-/// This is a chain lattice of the form:
-///
-/// ```ignore
-///                   NonZeroSized
-///                        |
-///                DependsOnTypeParam
-///                        |
-///                     ZeroSized
-/// ```
-///
-/// We initially assume that all types are `ZeroSized` and then update our
-/// understanding as we learn more about each type.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum SizednessResult {
-    /// The type is zero-sized.
-    ///
-    /// This means that if it is a C++ type, and is not being used as a base
-    /// member, then we must add an `_address` byte to enforce the
-    /// unique-address-per-distinct-object-instance rule.
-    ZeroSized,
-
-    /// Whether this type is zero-sized or not depends on whether a type
-    /// parameter is zero-sized or not.
-    ///
-    /// For example, given these definitions:
-    ///
-    /// ```c++
-    /// template<class T>
-    /// class Flongo : public T {};
-    ///
-    /// class Empty {};
-    ///
-    /// class NonEmpty { int x; };
-    /// ```
-    ///
-    /// Then `Flongo<Empty>` is zero-sized, and needs an `_address` byte
-    /// inserted, while `Flongo<NonEmpty>` is *not* zero-sized, and should *not*
-    /// have an `_address` byte inserted.
-    ///
-    /// We don't properly handle this situation correctly right now:
-    /// https://github.com/rust-lang/rust-bindgen/issues/586
-    DependsOnTypeParam,
-
-    /// Has some size that is known to be greater than zero. That doesn't mean
-    /// it has a static size, but it is not zero sized for sure. In other words,
-    /// it might contain an incomplete array or some other dynamically sized
-    /// type.
-    NonZeroSized,
-}
-
-impl Default for SizednessResult {
-    fn default() -> Self {
-        SizednessResult::ZeroSized
-    }
-}
-
-impl SizednessResult {
-    /// Take the least upper bound of `self` and `rhs`.
-    pub fn join(self, rhs: Self) -> Self {
-        cmp::max(self, rhs)
-    }
-}
-
-impl ops::BitOr for SizednessResult {
-    type Output = Self;
-
-    fn bitor(self, rhs: SizednessResult) -> Self::Output {
-        self.join(rhs)
-    }
-}
-
-impl ops::BitOrAssign for SizednessResult {
-    fn bitor_assign(&mut self, rhs: SizednessResult) {
-        *self = self.join(rhs)
-    }
-}
-
-/// An analysis that computes the sizedness of all types.
-///
-/// * For types with known sizes -- for example pointers, scalars, etc... --
-/// they are assigned `NonZeroSized`.
-///
-/// * For compound structure types with one or more fields, they are assigned
-/// `NonZeroSized`.
-///
-/// * For compound structure types without any fields, the results of the bases
-/// are `join`ed.
-///
-/// * For type parameters, `DependsOnTypeParam` is assigned.
-#[derive(Debug)]
-pub struct SizednessAnalysis<'ctx> {
-    ctx: &'ctx BindgenContext,
-    dependencies: HashMap<TypeId, Vec<TypeId>>,
-    // Incremental results of the analysis. Missing entries are implicitly
-    // considered `ZeroSized`.
-    sized: HashMap<TypeId, SizednessResult>,
-}
-
-impl<'ctx> SizednessAnalysis<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        // These are the only edges that can affect whether a type is
-        // zero-sized or not.
-        matches!(
-            kind,
-            EdgeKind::TemplateArgument |
-                EdgeKind::TemplateParameterDefinition |
-                EdgeKind::TemplateDeclaration |
-                EdgeKind::TypeReference |
-                EdgeKind::BaseMember |
-                EdgeKind::Field
-        )
-    }
-
-    /// Insert an incremental result, and return whether this updated our
-    /// knowledge of types and we should continue the analysis.
-    fn insert(
-        &mut self,
-        id: TypeId,
-        result: SizednessResult,
-    ) -> ConstrainResult {
-        trace!("inserting {:?} for {:?}", result, id);
-
-        if let SizednessResult::ZeroSized = result {
-            return ConstrainResult::Same;
-        }
-
-        match self.sized.entry(id) {
-            Entry::Occupied(mut entry) => {
-                if *entry.get() < result {
-                    entry.insert(result);
-                    ConstrainResult::Changed
-                } else {
-                    ConstrainResult::Same
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(result);
-                ConstrainResult::Changed
-            }
-        }
-    }
-
-    fn forward(&mut self, from: TypeId, to: TypeId) -> ConstrainResult {
-        match self.sized.get(&from).cloned() {
-            None => ConstrainResult::Same,
-            Some(r) => self.insert(to, r),
-        }
-    }
-}
-
-impl<'ctx> MonotoneFramework for SizednessAnalysis<'ctx> {
-    type Node = TypeId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashMap<TypeId, SizednessResult>;
-
-    fn new(ctx: &'ctx BindgenContext) -> SizednessAnalysis<'ctx> {
-        let dependencies = generate_dependencies(ctx, Self::consider_edge)
-            .into_iter()
-            .filter_map(|(id, sub_ids)| {
-                id.as_type_id(ctx).map(|id| {
-                    (
-                        id,
-                        sub_ids
-                            .into_iter()
-                            .filter_map(|s| s.as_type_id(ctx))
-                            .collect::<Vec<_>>(),
-                    )
-                })
-            })
-            .collect();
-
-        let sized = HashMap::default();
-
-        SizednessAnalysis {
-            ctx,
-            dependencies,
-            sized,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<TypeId> {
-        self.ctx
-            .allowlisted_items()
-            .iter()
-            .cloned()
-            .filter_map(|id| id.as_type_id(self.ctx))
-            .collect()
-    }
-
-    fn constrain(&mut self, id: TypeId) -> ConstrainResult {
-        trace!("constrain {:?}", id);
-
-        if let Some(SizednessResult::NonZeroSized) =
-            self.sized.get(&id).cloned()
-        {
-            trace!("    already know it is not zero-sized");
-            return ConstrainResult::Same;
-        }
-
-        if id.has_vtable_ptr(self.ctx) {
-            trace!("    has an explicit vtable pointer, therefore is not zero-sized");
-            return self.insert(id, SizednessResult::NonZeroSized);
-        }
-
-        let ty = self.ctx.resolve_type(id);
-
-        if id.is_opaque(self.ctx, &()) {
-            trace!("    type is opaque; checking layout...");
-            let result =
-                ty.layout(self.ctx).map_or(SizednessResult::ZeroSized, |l| {
-                    if l.size == 0 {
-                        trace!("    ...layout has size == 0");
-                        SizednessResult::ZeroSized
-                    } else {
-                        trace!("    ...layout has size > 0");
-                        SizednessResult::NonZeroSized
-                    }
-                });
-            return self.insert(id, result);
-        }
-
-        match *ty.kind() {
-            TypeKind::Void => {
-                trace!("    void is zero-sized");
-                self.insert(id, SizednessResult::ZeroSized)
-            }
-
-            TypeKind::TypeParam => {
-                trace!(
-                    "    type params sizedness depends on what they're \
-                     instantiated as"
-                );
-                self.insert(id, SizednessResult::DependsOnTypeParam)
-            }
-
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::Reference(..) |
-            TypeKind::NullPtr |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel |
-            TypeKind::Pointer(..) => {
-                trace!("    {:?} is known not to be zero-sized", ty.kind());
-                self.insert(id, SizednessResult::NonZeroSized)
-            }
-
-            TypeKind::ObjCInterface(..) => {
-                trace!("    obj-c interfaces always have at least the `isa` pointer");
-                self.insert(id, SizednessResult::NonZeroSized)
-            }
-
-            TypeKind::TemplateAlias(t, _) |
-            TypeKind::Alias(t) |
-            TypeKind::BlockPointer(t) |
-            TypeKind::ResolvedTypeRef(t) => {
-                trace!("    aliases and type refs forward to their inner type");
-                self.forward(t, id)
-            }
-
-            TypeKind::TemplateInstantiation(ref inst) => {
-                trace!(
-                    "    template instantiations are zero-sized if their \
-                     definition is zero-sized"
-                );
-                self.forward(inst.template_definition(), id)
-            }
-
-            TypeKind::Array(_, 0) => {
-                trace!("    arrays of zero elements are zero-sized");
-                self.insert(id, SizednessResult::ZeroSized)
-            }
-            TypeKind::Array(..) => {
-                trace!("    arrays of > 0 elements are not zero-sized");
-                self.insert(id, SizednessResult::NonZeroSized)
-            }
-            TypeKind::Vector(..) => {
-                trace!("    vectors are not zero-sized");
-                self.insert(id, SizednessResult::NonZeroSized)
-            }
-
-            TypeKind::Comp(ref info) => {
-                trace!("    comp considers its own fields and bases");
-
-                if !info.fields().is_empty() {
-                    return self.insert(id, SizednessResult::NonZeroSized);
-                }
-
-                let result = info
-                    .base_members()
-                    .iter()
-                    .filter_map(|base| self.sized.get(&base.ty))
-                    .fold(SizednessResult::ZeroSized, |a, b| a.join(*b));
-
-                self.insert(id, result)
-            }
-
-            TypeKind::Opaque => {
-                unreachable!("covered by the .is_opaque() check above")
-            }
-
-            TypeKind::UnresolvedTypeRef(..) => {
-                unreachable!("Should have been resolved after parsing!");
-            }
-        }
-    }
-
-    fn each_depending_on<F>(&self, id: TypeId, mut f: F)
-    where
-        F: FnMut(TypeId),
-    {
-        if let Some(edges) = self.dependencies.get(&id) {
-            for ty in edges {
-                trace!("enqueue {:?} into worklist", ty);
-                f(*ty);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<SizednessAnalysis<'ctx>> for HashMap<TypeId, SizednessResult> {
-    fn from(analysis: SizednessAnalysis<'ctx>) -> Self {
-        // We let the lack of an entry mean "ZeroSized" to save space.
-        extra_assert!(analysis
-            .sized
-            .values()
-            .all(|v| { *v != SizednessResult::ZeroSized }));
-
-        analysis.sized
-    }
-}
-
-/// A convenience trait for querying whether some type or id is sized.
-///
-/// This is not for _computing_ whether the thing is sized, it is for looking up
-/// the results of the `Sizedness` analysis's computations for a specific thing.
-pub trait Sizedness {
-    /// Get the sizedness of this type.
-    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult;
-
-    /// Is the sizedness for this type `SizednessResult::ZeroSized`?
-    fn is_zero_sized(&self, ctx: &BindgenContext) -> bool {
-        self.sizedness(ctx) == SizednessResult::ZeroSized
-    }
-}
diff --git a/src/ir/analysis/template_params.rs b/src/ir/analysis/template_params.rs
deleted file mode 100644
index e88b774d..00000000
--- a/src/ir/analysis/template_params.rs
+++ /dev/null
@@ -1,608 +0,0 @@
-//! Discover which template type parameters are actually used.
-//!
-//! ### Why do we care?
-//!
-//! C++ allows ignoring template parameters, while Rust does not. Usually we can
-//! blindly stick a `PhantomData<T>` inside a generic Rust struct to make up for
-//! this. That doesn't work for templated type aliases, however:
-//!
-//! ```C++
-//! template <typename T>
-//! using Fml = int;
-//! ```
-//!
-//! If we generate the naive Rust code for this alias, we get:
-//!
-//! ```ignore
-//! pub type Fml<T> = ::std::os::raw::int;
-//! ```
-//!
-//! And this is rejected by `rustc` due to the unused type parameter.
-//!
-//! (Aside: in these simple cases, `libclang` will often just give us the
-//! aliased type directly, and we will never even know we were dealing with
-//! aliases, let alone templated aliases. It's the more convoluted scenarios
-//! where we get to have some fun...)
-//!
-//! For such problematic template aliases, we could generate a tuple whose
-//! second member is a `PhantomData<T>`. Or, if we wanted to go the extra mile,
-//! we could even generate some smarter wrapper that implements `Deref`,
-//! `DerefMut`, `From`, `Into`, `AsRef`, and `AsMut` to the actually aliased
-//! type. However, this is still lackluster:
-//!
-//! 1. Even with a billion conversion-trait implementations, using the generated
-//!    bindings is rather un-ergonomic.
-//! 2. With either of these solutions, we need to keep track of which aliases
-//!    we've transformed like this in order to generate correct uses of the
-//!    wrapped type.
-//!
-//! Given that we have to properly track which template parameters ended up used
-//! for (2), we might as well leverage that information to make ergonomic
-//! bindings that don't contain any unused type parameters at all, and
-//! completely avoid the pain of (1).
-//!
-//! ### How do we determine which template parameters are used?
-//!
-//! Determining which template parameters are actually used is a trickier
-//! problem than it might seem at a glance. On the one hand, trivial uses are
-//! easy to detect:
-//!
-//! ```C++
-//! template <typename T>
-//! class Foo {
-//!     T trivial_use_of_t;
-//! };
-//! ```
-//!
-//! It gets harder when determining if one template parameter is used depends on
-//! determining if another template parameter is used. In this example, whether
-//! `U` is used depends on whether `T` is used.
-//!
-//! ```C++
-//! template <typename T>
-//! class DoesntUseT {
-//!     int x;
-//! };
-//!
-//! template <typename U>
-//! class Fml {
-//!     DoesntUseT<U> lololol;
-//! };
-//! ```
-//!
-//! We can express the set of used template parameters as a constraint solving
-//! problem (where the set of template parameters used by a given IR item is the
-//! union of its sub-item's used template parameters) and iterate to a
-//! fixed-point.
-//!
-//! We use the `ir::analysis::MonotoneFramework` infrastructure for this
-//! fix-point analysis, where our lattice is the mapping from each IR item to
-//! the powerset of the template parameters that appear in the input C++ header,
-//! our join function is set union. The set of template parameters appearing in
-//! the program is finite, as is the number of IR items. We start at our
-//! lattice's bottom element: every item mapping to an empty set of template
-//! parameters. Our analysis only adds members to each item's set of used
-//! template parameters, never removes them, so it is monotone. Because our
-//! lattice is finite and our constraint function is monotone, iteration to a
-//! fix-point will terminate.
-//!
-//! See `src/ir/analysis.rs` for more.
-
-use super::{ConstrainResult, MonotoneFramework};
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::item::{Item, ItemSet};
-use crate::ir::template::{TemplateInstantiation, TemplateParameters};
-use crate::ir::traversal::{EdgeKind, Trace};
-use crate::ir::ty::TypeKind;
-use crate::{HashMap, HashSet};
-
-/// An analysis that finds for each IR item its set of template parameters that
-/// it uses.
-///
-/// We use the monotone constraint function `template_param_usage`, defined as
-/// follows:
-///
-/// * If `T` is a named template type parameter, it trivially uses itself:
-///
-/// ```ignore
-/// template_param_usage(T) = { T }
-/// ```
-///
-/// * If `inst` is a template instantiation, `inst.args` are the template
-///   instantiation's template arguments, `inst.def` is the template definition
-///   being instantiated, and `inst.def.params` is the template definition's
-///   template parameters, then the instantiation's usage is the union of each
-///   of its arguments' usages *if* the corresponding template parameter is in
-///   turn used by the template definition:
-///
-/// ```ignore
-/// template_param_usage(inst) = union(
-///     template_param_usage(inst.args[i])
-///         for i in 0..length(inst.args.length)
-///             if inst.def.params[i] in template_param_usage(inst.def)
-/// )
-/// ```
-///
-/// * Finally, for all other IR item kinds, we use our lattice's `join`
-/// operation: set union with each successor of the given item's template
-/// parameter usage:
-///
-/// ```ignore
-/// template_param_usage(v) =
-///     union(template_param_usage(w) for w in successors(v))
-/// ```
-///
-/// Note that we ignore certain edges in the graph, such as edges from a
-/// template declaration to its template parameters' definitions for this
-/// analysis. If we didn't, then we would mistakenly determine that ever
-/// template parameter is always used.
-///
-/// The final wrinkle is handling of blocklisted types. Normally, we say that
-/// the set of allowlisted items is the transitive closure of items explicitly
-/// called out for allowlisting, *without* any items explicitly called out as
-/// blocklisted. However, for the purposes of this analysis's correctness, we
-/// simplify and consider run the analysis on the full transitive closure of
-/// allowlisted items. We do, however, treat instantiations of blocklisted items
-/// specially; see `constrain_instantiation_of_blocklisted_template` and its
-/// documentation for details.
-#[derive(Debug, Clone)]
-pub struct UsedTemplateParameters<'ctx> {
-    ctx: &'ctx BindgenContext,
-
-    // The Option is only there for temporary moves out of the hash map. See the
-    // comments in `UsedTemplateParameters::constrain` below.
-    used: HashMap<ItemId, Option<ItemSet>>,
-
-    dependencies: HashMap<ItemId, Vec<ItemId>>,
-
-    // The set of allowlisted items, without any blocklisted items reachable
-    // from the allowlisted items which would otherwise be considered
-    // allowlisted as well.
-    allowlisted_items: HashSet<ItemId>,
-}
-
-impl<'ctx> UsedTemplateParameters<'ctx> {
-    fn consider_edge(kind: EdgeKind) -> bool {
-        match kind {
-            // For each of these kinds of edges, if the referent uses a template
-            // parameter, then it should be considered that the origin of the
-            // edge also uses the template parameter.
-            EdgeKind::TemplateArgument |
-            EdgeKind::BaseMember |
-            EdgeKind::Field |
-            EdgeKind::Constructor |
-            EdgeKind::Destructor |
-            EdgeKind::VarType |
-            EdgeKind::FunctionReturn |
-            EdgeKind::FunctionParameter |
-            EdgeKind::TypeReference => true,
-
-            // An inner var or type using a template parameter is orthogonal
-            // from whether we use it. See template-param-usage-{6,11}.hpp.
-            EdgeKind::InnerVar | EdgeKind::InnerType => false,
-
-            // We can't emit machine code for new monomorphizations of class
-            // templates' methods (and don't detect explicit instantiations) so
-            // we must ignore template parameters that are only used by
-            // methods. This doesn't apply to a function type's return or
-            // parameter types, however, because of type aliases of function
-            // pointers that use template parameters, eg
-            // tests/headers/struct_with_typedef_template_arg.hpp
-            EdgeKind::Method => false,
-
-            // If we considered these edges, we would end up mistakenly claiming
-            // that every template parameter always used.
-            EdgeKind::TemplateDeclaration |
-            EdgeKind::TemplateParameterDefinition => false,
-
-            // Since we have to be careful about which edges we consider for
-            // this analysis to be correct, we ignore generic edges. We also
-            // avoid a `_` wild card to force authors of new edge kinds to
-            // determine whether they need to be considered by this analysis.
-            EdgeKind::Generic => false,
-        }
-    }
-
-    fn take_this_id_usage_set<Id: Into<ItemId>>(
-        &mut self,
-        this_id: Id,
-    ) -> ItemSet {
-        let this_id = this_id.into();
-        self.used
-            .get_mut(&this_id)
-            .expect(
-                "Should have a set of used template params for every item \
-                 id",
-            )
-            .take()
-            .expect(
-                "Should maintain the invariant that all used template param \
-                 sets are `Some` upon entry of `constrain`",
-            )
-    }
-
-    /// We say that blocklisted items use all of their template parameters. The
-    /// blocklisted type is most likely implemented explicitly by the user,
-    /// since it won't be in the generated bindings, and we don't know exactly
-    /// what they'll to with template parameters, but we can push the issue down
-    /// the line to them.
-    fn constrain_instantiation_of_blocklisted_template(
-        &self,
-        this_id: ItemId,
-        used_by_this_id: &mut ItemSet,
-        instantiation: &TemplateInstantiation,
-    ) {
-        trace!(
-            "    instantiation of blocklisted template, uses all template \
-             arguments"
-        );
-
-        let args = instantiation
-            .template_arguments()
-            .iter()
-            .map(|a| {
-                a.into_resolver()
-                    .through_type_refs()
-                    .through_type_aliases()
-                    .resolve(self.ctx)
-                    .id()
-            })
-            .filter(|a| *a != this_id)
-            .flat_map(|a| {
-                self.used
-                    .get(&a)
-                    .expect("Should have a used entry for the template arg")
-                    .as_ref()
-                    .expect(
-                        "Because a != this_id, and all used template \
-                         param sets other than this_id's are `Some`, \
-                         a's used template param set should be `Some`",
-                    )
-                    .iter()
-                    .cloned()
-            });
-
-        used_by_this_id.extend(args);
-    }
-
-    /// A template instantiation's concrete template argument is only used if
-    /// the template definition uses the corresponding template parameter.
-    fn constrain_instantiation(
-        &self,
-        this_id: ItemId,
-        used_by_this_id: &mut ItemSet,
-        instantiation: &TemplateInstantiation,
-    ) {
-        trace!("    template instantiation");
-
-        let decl = self.ctx.resolve_type(instantiation.template_definition());
-        let args = instantiation.template_arguments();
-
-        let params = decl.self_template_params(self.ctx);
-
-        debug_assert!(this_id != instantiation.template_definition());
-        let used_by_def = self.used
-            .get(&instantiation.template_definition().into())
-            .expect("Should have a used entry for instantiation's template definition")
-            .as_ref()
-            .expect("And it should be Some because only this_id's set is None, and an \
-                     instantiation's template definition should never be the \
-                     instantiation itself");
-
-        for (arg, param) in args.iter().zip(params.iter()) {
-            trace!(
-                "      instantiation's argument {:?} is used if definition's \
-                 parameter {:?} is used",
-                arg,
-                param
-            );
-
-            if used_by_def.contains(&param.into()) {
-                trace!("        param is used by template definition");
-
-                let arg = arg
-                    .into_resolver()
-                    .through_type_refs()
-                    .through_type_aliases()
-                    .resolve(self.ctx)
-                    .id();
-
-                if arg == this_id {
-                    continue;
-                }
-
-                let used_by_arg = self
-                    .used
-                    .get(&arg)
-                    .expect("Should have a used entry for the template arg")
-                    .as_ref()
-                    .expect(
-                        "Because arg != this_id, and all used template \
-                         param sets other than this_id's are `Some`, \
-                         arg's used template param set should be \
-                         `Some`",
-                    )
-                    .iter()
-                    .cloned();
-                used_by_this_id.extend(used_by_arg);
-            }
-        }
-    }
-
-    /// The join operation on our lattice: the set union of all of this id's
-    /// successors.
-    fn constrain_join(&self, used_by_this_id: &mut ItemSet, item: &Item) {
-        trace!("    other item: join with successors' usage");
-
-        item.trace(
-            self.ctx,
-            &mut |sub_id, edge_kind| {
-                // Ignore ourselves, since union with ourself is a
-                // no-op. Ignore edges that aren't relevant to the
-                // analysis.
-                if sub_id == item.id() || !Self::consider_edge(edge_kind) {
-                    return;
-                }
-
-                let used_by_sub_id = self
-                    .used
-                    .get(&sub_id)
-                    .expect("Should have a used set for the sub_id successor")
-                    .as_ref()
-                    .expect(
-                        "Because sub_id != id, and all used template \
-                         param sets other than id's are `Some`, \
-                         sub_id's used template param set should be \
-                         `Some`",
-                    )
-                    .iter()
-                    .cloned();
-
-                trace!(
-                    "      union with {:?}'s usage: {:?}",
-                    sub_id,
-                    used_by_sub_id.clone().collect::<Vec<_>>()
-                );
-
-                used_by_this_id.extend(used_by_sub_id);
-            },
-            &(),
-        );
-    }
-}
-
-impl<'ctx> MonotoneFramework for UsedTemplateParameters<'ctx> {
-    type Node = ItemId;
-    type Extra = &'ctx BindgenContext;
-    type Output = HashMap<ItemId, ItemSet>;
-
-    fn new(ctx: &'ctx BindgenContext) -> UsedTemplateParameters<'ctx> {
-        let mut used = HashMap::default();
-        let mut dependencies = HashMap::default();
-        let allowlisted_items: HashSet<_> =
-            ctx.allowlisted_items().iter().cloned().collect();
-
-        let allowlisted_and_blocklisted_items: ItemSet = allowlisted_items
-            .iter()
-            .cloned()
-            .flat_map(|i| {
-                let mut reachable = vec![i];
-                i.trace(
-                    ctx,
-                    &mut |s, _| {
-                        reachable.push(s);
-                    },
-                    &(),
-                );
-                reachable
-            })
-            .collect();
-
-        for item in allowlisted_and_blocklisted_items {
-            dependencies.entry(item).or_insert_with(Vec::new);
-            used.entry(item).or_insert_with(|| Some(ItemSet::new()));
-
-            {
-                // We reverse our natural IR graph edges to find dependencies
-                // between nodes.
-                item.trace(
-                    ctx,
-                    &mut |sub_item: ItemId, _| {
-                        used.entry(sub_item)
-                            .or_insert_with(|| Some(ItemSet::new()));
-                        dependencies
-                            .entry(sub_item)
-                            .or_insert_with(Vec::new)
-                            .push(item);
-                    },
-                    &(),
-                );
-            }
-
-            // Additionally, whether a template instantiation's template
-            // arguments are used depends on whether the template declaration's
-            // generic template parameters are used.
-            let item_kind =
-                ctx.resolve_item(item).as_type().map(|ty| ty.kind());
-            if let Some(&TypeKind::TemplateInstantiation(ref inst)) = item_kind
-            {
-                let decl = ctx.resolve_type(inst.template_definition());
-                let args = inst.template_arguments();
-
-                // Although template definitions should always have
-                // template parameters, there is a single exception:
-                // opaque templates. Hence the unwrap_or.
-                let params = decl.self_template_params(ctx);
-
-                for (arg, param) in args.iter().zip(params.iter()) {
-                    let arg = arg
-                        .into_resolver()
-                        .through_type_aliases()
-                        .through_type_refs()
-                        .resolve(ctx)
-                        .id();
-
-                    let param = param
-                        .into_resolver()
-                        .through_type_aliases()
-                        .through_type_refs()
-                        .resolve(ctx)
-                        .id();
-
-                    used.entry(arg).or_insert_with(|| Some(ItemSet::new()));
-                    used.entry(param).or_insert_with(|| Some(ItemSet::new()));
-
-                    dependencies
-                        .entry(arg)
-                        .or_insert_with(Vec::new)
-                        .push(param);
-                }
-            }
-        }
-
-        if cfg!(feature = "testing_only_extra_assertions") {
-            // Invariant: The `used` map has an entry for every allowlisted
-            // item, as well as all explicitly blocklisted items that are
-            // reachable from allowlisted items.
-            //
-            // Invariant: the `dependencies` map has an entry for every
-            // allowlisted item.
-            //
-            // (This is so that every item we call `constrain` on is guaranteed
-            // to have a set of template parameters, and we can allow
-            // blocklisted templates to use all of their parameters).
-            for item in allowlisted_items.iter() {
-                extra_assert!(used.contains_key(item));
-                extra_assert!(dependencies.contains_key(item));
-                item.trace(
-                    ctx,
-                    &mut |sub_item, _| {
-                        extra_assert!(used.contains_key(&sub_item));
-                        extra_assert!(dependencies.contains_key(&sub_item));
-                    },
-                    &(),
-                )
-            }
-        }
-
-        UsedTemplateParameters {
-            ctx,
-            used,
-            dependencies,
-            allowlisted_items,
-        }
-    }
-
-    fn initial_worklist(&self) -> Vec<ItemId> {
-        // The transitive closure of all allowlisted items, including explicitly
-        // blocklisted items.
-        self.ctx
-            .allowlisted_items()
-            .iter()
-            .cloned()
-            .flat_map(|i| {
-                let mut reachable = vec![i];
-                i.trace(
-                    self.ctx,
-                    &mut |s, _| {
-                        reachable.push(s);
-                    },
-                    &(),
-                );
-                reachable
-            })
-            .collect()
-    }
-
-    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
-        // Invariant: all hash map entries' values are `Some` upon entering and
-        // exiting this method.
-        extra_assert!(self.used.values().all(|v| v.is_some()));
-
-        // Take the set for this id out of the hash map while we mutate it based
-        // on other hash map entries. We *must* put it back into the hash map at
-        // the end of this method. This allows us to side-step HashMap's lack of
-        // an analog to slice::split_at_mut.
-        let mut used_by_this_id = self.take_this_id_usage_set(id);
-
-        trace!("constrain {:?}", id);
-        trace!("  initially, used set is {:?}", used_by_this_id);
-
-        let original_len = used_by_this_id.len();
-
-        let item = self.ctx.resolve_item(id);
-        let ty_kind = item.as_type().map(|ty| ty.kind());
-        match ty_kind {
-            // Named template type parameters trivially use themselves.
-            Some(&TypeKind::TypeParam) => {
-                trace!("    named type, trivially uses itself");
-                used_by_this_id.insert(id);
-            }
-            // Template instantiations only use their template arguments if the
-            // template definition uses the corresponding template parameter.
-            Some(&TypeKind::TemplateInstantiation(ref inst)) => {
-                if self
-                    .allowlisted_items
-                    .contains(&inst.template_definition().into())
-                {
-                    self.constrain_instantiation(
-                        id,
-                        &mut used_by_this_id,
-                        inst,
-                    );
-                } else {
-                    self.constrain_instantiation_of_blocklisted_template(
-                        id,
-                        &mut used_by_this_id,
-                        inst,
-                    );
-                }
-            }
-            // Otherwise, add the union of each of its referent item's template
-            // parameter usage.
-            _ => self.constrain_join(&mut used_by_this_id, item),
-        }
-
-        trace!("  finally, used set is {:?}", used_by_this_id);
-
-        let new_len = used_by_this_id.len();
-        assert!(
-            new_len >= original_len,
-            "This is the property that ensures this function is monotone -- \
-             if it doesn't hold, the analysis might never terminate!"
-        );
-
-        // Put the set back in the hash map and restore our invariant.
-        debug_assert!(self.used[&id].is_none());
-        self.used.insert(id, Some(used_by_this_id));
-        extra_assert!(self.used.values().all(|v| v.is_some()));
-
-        if new_len != original_len {
-            ConstrainResult::Changed
-        } else {
-            ConstrainResult::Same
-        }
-    }
-
-    fn each_depending_on<F>(&self, item: ItemId, mut f: F)
-    where
-        F: FnMut(ItemId),
-    {
-        if let Some(edges) = self.dependencies.get(&item) {
-            for item in edges {
-                trace!("enqueue {:?} into worklist", item);
-                f(*item);
-            }
-        }
-    }
-}
-
-impl<'ctx> From<UsedTemplateParameters<'ctx>> for HashMap<ItemId, ItemSet> {
-    fn from(used_templ_params: UsedTemplateParameters<'ctx>) -> Self {
-        used_templ_params
-            .used
-            .into_iter()
-            .map(|(k, v)| (k, v.unwrap()))
-            .collect()
-    }
-}
diff --git a/src/ir/annotations.rs b/src/ir/annotations.rs
deleted file mode 100644
index 288c11eb..00000000
--- a/src/ir/annotations.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-//! Types and functions related to bindgen annotation comments.
-//!
-//! Users can add annotations in doc comments to types that they would like to
-//! replace other types with, mark as opaque, etc. This module deals with all of
-//! that stuff.
-
-use crate::clang;
-
-/// What kind of accessor should we provide for a field?
-#[derive(Copy, PartialEq, Eq, Clone, Debug)]
-pub enum FieldAccessorKind {
-    /// No accessor.
-    None,
-    /// Plain accessor.
-    Regular,
-    /// Unsafe accessor.
-    Unsafe,
-    /// Immutable accessor.
-    Immutable,
-}
-
-/// Annotations for a given item, or a field.
-///
-/// You can see the kind of comments that are accepted in the Doxygen
-/// documentation:
-///
-/// http://www.stack.nl/~dimitri/doxygen/manual/docblocks.html
-#[derive(Default, Clone, PartialEq, Eq, Debug)]
-pub struct Annotations {
-    /// Whether this item is marked as opaque. Only applies to types.
-    opaque: bool,
-    /// Whether this item should be hidden from the output. Only applies to
-    /// types, or enum variants.
-    hide: bool,
-    /// Whether this type should be replaced by another. The name is a
-    /// namespace-aware path.
-    use_instead_of: Option<Vec<String>>,
-    /// Manually disable deriving copy/clone on this type. Only applies to
-    /// struct or union types.
-    disallow_copy: bool,
-    /// Manually disable deriving debug on this type.
-    disallow_debug: bool,
-    /// Manually disable deriving/implement default on this type.
-    disallow_default: bool,
-    /// Whether to add a #[must_use] annotation to this type.
-    must_use_type: bool,
-    /// Whether fields should be marked as private or not. You can set this on
-    /// structs (it will apply to all the fields), or individual fields.
-    private_fields: Option<bool>,
-    /// The kind of accessor this field will have. Also can be applied to
-    /// structs so all the fields inside share it by default.
-    accessor_kind: Option<FieldAccessorKind>,
-    /// Whether this enum variant should be constified.
-    ///
-    /// This is controlled by the `constant` attribute, this way:
-    ///
-    /// ```cpp
-    /// enum Foo {
-    ///     Bar = 0, /**< <div rustbindgen constant></div> */
-    ///     Baz = 0,
-    /// };
-    /// ```
-    ///
-    /// In that case, bindgen will generate a constant for `Bar` instead of
-    /// `Baz`.
-    constify_enum_variant: bool,
-    /// List of explicit derives for this type.
-    derives: Vec<String>,
-}
-
-fn parse_accessor(s: &str) -> FieldAccessorKind {
-    match s {
-        "false" => FieldAccessorKind::None,
-        "unsafe" => FieldAccessorKind::Unsafe,
-        "immutable" => FieldAccessorKind::Immutable,
-        _ => FieldAccessorKind::Regular,
-    }
-}
-
-impl Annotations {
-    /// Construct new annotations for the given cursor and its bindgen comments
-    /// (if any).
-    pub fn new(cursor: &clang::Cursor) -> Option<Annotations> {
-        let mut anno = Annotations::default();
-        let mut matched_one = false;
-        anno.parse(&cursor.comment(), &mut matched_one);
-
-        if matched_one {
-            Some(anno)
-        } else {
-            None
-        }
-    }
-
-    /// Should this type be hidden?
-    pub fn hide(&self) -> bool {
-        self.hide
-    }
-
-    /// Should this type be opaque?
-    pub fn opaque(&self) -> bool {
-        self.opaque
-    }
-
-    /// For a given type, indicates the type it should replace.
-    ///
-    /// For example, in the following code:
-    ///
-    /// ```cpp
-    ///
-    /// /** <div rustbindgen replaces="Bar"></div> */
-    /// struct Foo { int x; };
-    ///
-    /// struct Bar { char foo; };
-    /// ```
-    ///
-    /// the generated code would look something like:
-    ///
-    /// ```
-    /// /** <div rustbindgen replaces="Bar"></div> */
-    /// struct Bar {
-    ///     x: ::std::os::raw::c_int,
-    /// };
-    /// ```
-    ///
-    /// That is, code for `Foo` is used to generate `Bar`.
-    pub fn use_instead_of(&self) -> Option<&[String]> {
-        self.use_instead_of.as_deref()
-    }
-
-    /// The list of derives that have been specified in this annotation.
-    pub fn derives(&self) -> &[String] {
-        &self.derives
-    }
-
-    /// Should we avoid implementing the `Copy` trait?
-    pub fn disallow_copy(&self) -> bool {
-        self.disallow_copy
-    }
-
-    /// Should we avoid implementing the `Debug` trait?
-    pub fn disallow_debug(&self) -> bool {
-        self.disallow_debug
-    }
-
-    /// Should we avoid implementing the `Default` trait?
-    pub fn disallow_default(&self) -> bool {
-        self.disallow_default
-    }
-
-    /// Should this type get a `#[must_use]` annotation?
-    pub fn must_use_type(&self) -> bool {
-        self.must_use_type
-    }
-
-    /// Should the fields be private?
-    pub fn private_fields(&self) -> Option<bool> {
-        self.private_fields
-    }
-
-    /// What kind of accessors should we provide for this type's fields?
-    pub fn accessor_kind(&self) -> Option<FieldAccessorKind> {
-        self.accessor_kind
-    }
-
-    fn parse(&mut self, comment: &clang::Comment, matched: &mut bool) {
-        use clang_sys::CXComment_HTMLStartTag;
-        if comment.kind() == CXComment_HTMLStartTag &&
-            comment.get_tag_name() == "div" &&
-            comment
-                .get_tag_attrs()
-                .next()
-                .map_or(false, |attr| attr.name == "rustbindgen")
-        {
-            *matched = true;
-            for attr in comment.get_tag_attrs() {
-                match attr.name.as_str() {
-                    "opaque" => self.opaque = true,
-                    "hide" => self.hide = true,
-                    "nocopy" => self.disallow_copy = true,
-                    "nodebug" => self.disallow_debug = true,
-                    "nodefault" => self.disallow_default = true,
-                    "mustusetype" => self.must_use_type = true,
-                    "replaces" => {
-                        self.use_instead_of = Some(
-                            attr.value.split("::").map(Into::into).collect(),
-                        )
-                    }
-                    "derive" => self.derives.push(attr.value),
-                    "private" => {
-                        self.private_fields = Some(attr.value != "false")
-                    }
-                    "accessor" => {
-                        self.accessor_kind = Some(parse_accessor(&attr.value))
-                    }
-                    "constant" => self.constify_enum_variant = true,
-                    _ => {}
-                }
-            }
-        }
-
-        for child in comment.get_children() {
-            self.parse(&child, matched);
-        }
-    }
-
-    /// Returns whether we've parsed a "constant" attribute.
-    pub fn constify_enum_variant(&self) -> bool {
-        self.constify_enum_variant
-    }
-}
diff --git a/src/ir/comment.rs b/src/ir/comment.rs
deleted file mode 100644
index c96e3ebb..00000000
--- a/src/ir/comment.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-//! Utilities for manipulating C/C++ comments.
-
-/// The type of a comment.
-#[derive(Debug, PartialEq, Eq)]
-enum Kind {
-    /// A `///` comment, or something of the like.
-    /// All lines in a comment should start with the same symbol.
-    SingleLines,
-    /// A `/**` comment, where each other line can start with `*` and the
-    /// entire block ends with `*/`.
-    MultiLine,
-}
-
-/// Preprocesses a C/C++ comment so that it is a valid Rust comment.
-pub fn preprocess(comment: &str, indent: usize) -> String {
-    match self::kind(comment) {
-        Some(Kind::SingleLines) => preprocess_single_lines(comment, indent),
-        Some(Kind::MultiLine) => preprocess_multi_line(comment, indent),
-        None => comment.to_owned(),
-    }
-}
-
-/// Gets the kind of the doc comment, if it is one.
-fn kind(comment: &str) -> Option<Kind> {
-    if comment.starts_with("/*") {
-        Some(Kind::MultiLine)
-    } else if comment.starts_with("//") {
-        Some(Kind::SingleLines)
-    } else {
-        None
-    }
-}
-
-fn make_indent(indent: usize) -> String {
-    const RUST_INDENTATION: usize = 4;
-    " ".repeat(indent * RUST_INDENTATION)
-}
-
-/// Preprocesses multiple single line comments.
-///
-/// Handles lines starting with both `//` and `///`.
-fn preprocess_single_lines(comment: &str, indent: usize) -> String {
-    debug_assert!(comment.starts_with("//"), "comment is not single line");
-
-    let indent = make_indent(indent);
-    let mut is_first = true;
-    let lines: Vec<_> = comment
-        .lines()
-        .map(|l| l.trim().trim_start_matches('/'))
-        .map(|l| {
-            let indent = if is_first { "" } else { &*indent };
-            is_first = false;
-            format!("{}///{}", indent, l)
-        })
-        .collect();
-    lines.join("\n")
-}
-
-fn preprocess_multi_line(comment: &str, indent: usize) -> String {
-    let comment = comment
-        .trim_start_matches('/')
-        .trim_end_matches('/')
-        .trim_end_matches('*');
-
-    let indent = make_indent(indent);
-    // Strip any potential `*` characters preceding each line.
-    let mut is_first = true;
-    let mut lines: Vec<_> = comment
-        .lines()
-        .map(|line| line.trim().trim_start_matches('*').trim_start_matches('!'))
-        .skip_while(|line| line.trim().is_empty()) // Skip the first empty lines.
-        .map(|line| {
-            let indent = if is_first { "" } else { &*indent };
-            is_first = false;
-            format!("{}///{}", indent, line)
-        })
-        .collect();
-
-    // Remove the trailing line corresponding to the `*/`.
-    if lines
-        .last()
-        .map_or(false, |l| l.trim().is_empty() || l.trim() == "///")
-    {
-        lines.pop();
-    }
-
-    lines.join("\n")
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn picks_up_single_and_multi_line_doc_comments() {
-        assert_eq!(kind("/// hello"), Some(Kind::SingleLines));
-        assert_eq!(kind("/** world */"), Some(Kind::MultiLine));
-    }
-
-    #[test]
-    fn processes_single_lines_correctly() {
-        assert_eq!(preprocess("/// hello", 0), "/// hello");
-        assert_eq!(preprocess("// hello", 0), "/// hello");
-        assert_eq!(preprocess("//    hello", 0), "///    hello");
-    }
-
-    #[test]
-    fn processes_multi_lines_correctly() {
-        assert_eq!(
-            preprocess("/** hello \n * world \n * foo \n */", 0),
-            "/// hello\n/// world\n/// foo"
-        );
-
-        assert_eq!(
-            preprocess("/**\nhello\n*world\n*foo\n*/", 0),
-            "///hello\n///world\n///foo"
-        );
-    }
-}
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
deleted file mode 100644
index f44c5d67..00000000
--- a/src/ir/comp.rs
+++ /dev/null
@@ -1,1891 +0,0 @@
-//! Compound types (unions and structs) in our intermediate representation.
-
-use super::analysis::Sizedness;
-use super::annotations::Annotations;
-use super::context::{BindgenContext, FunctionId, ItemId, TypeId, VarId};
-use super::dot::DotAttributes;
-use super::item::{IsOpaque, Item};
-use super::layout::Layout;
-use super::template::TemplateParameters;
-use super::traversal::{EdgeKind, Trace, Tracer};
-use super::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
-use crate::clang;
-use crate::codegen::struct_layout::{align_to, bytes_from_bits_pow2};
-use crate::ir::derive::CanDeriveCopy;
-use crate::parse::{ClangItemParser, ParseError};
-use crate::HashMap;
-use crate::NonCopyUnionStyle;
-use peeking_take_while::PeekableExt;
-use std::cmp;
-use std::io;
-use std::mem;
-
-/// The kind of compound type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum CompKind {
-    /// A struct.
-    Struct,
-    /// A union.
-    Union,
-}
-
-/// The kind of C++ method.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum MethodKind {
-    /// A constructor. We represent it as method for convenience, to avoid code
-    /// duplication.
-    Constructor,
-    /// A destructor.
-    Destructor,
-    /// A virtual destructor.
-    VirtualDestructor {
-        /// Whether it's pure virtual.
-        pure_virtual: bool,
-    },
-    /// A static method.
-    Static,
-    /// A normal method.
-    Normal,
-    /// A virtual method.
-    Virtual {
-        /// Whether it's pure virtual.
-        pure_virtual: bool,
-    },
-}
-
-impl MethodKind {
-    /// Is this a destructor method?
-    pub fn is_destructor(&self) -> bool {
-        matches!(
-            *self,
-            MethodKind::Destructor | MethodKind::VirtualDestructor { .. }
-        )
-    }
-
-    /// Is this a pure virtual method?
-    pub fn is_pure_virtual(&self) -> bool {
-        match *self {
-            MethodKind::Virtual { pure_virtual } |
-            MethodKind::VirtualDestructor { pure_virtual } => pure_virtual,
-            _ => false,
-        }
-    }
-}
-
-/// A struct representing a C++ method, either static, normal, or virtual.
-#[derive(Debug)]
-pub struct Method {
-    kind: MethodKind,
-    /// The signature of the method. Take into account this is not a `Type`
-    /// item, but a `Function` one.
-    ///
-    /// This is tricky and probably this field should be renamed.
-    signature: FunctionId,
-    is_const: bool,
-}
-
-impl Method {
-    /// Construct a new `Method`.
-    pub fn new(
-        kind: MethodKind,
-        signature: FunctionId,
-        is_const: bool,
-    ) -> Self {
-        Method {
-            kind,
-            signature,
-            is_const,
-        }
-    }
-
-    /// What kind of method is this?
-    pub fn kind(&self) -> MethodKind {
-        self.kind
-    }
-
-    /// Is this a constructor?
-    pub fn is_constructor(&self) -> bool {
-        self.kind == MethodKind::Constructor
-    }
-
-    /// Is this a virtual method?
-    pub fn is_virtual(&self) -> bool {
-        matches!(
-            self.kind,
-            MethodKind::Virtual { .. } | MethodKind::VirtualDestructor { .. }
-        )
-    }
-
-    /// Is this a static method?
-    pub fn is_static(&self) -> bool {
-        self.kind == MethodKind::Static
-    }
-
-    /// Get the id for the `Function` signature for this method.
-    pub fn signature(&self) -> FunctionId {
-        self.signature
-    }
-
-    /// Is this a const qualified method?
-    pub fn is_const(&self) -> bool {
-        self.is_const
-    }
-}
-
-/// Methods common to the various field types.
-pub trait FieldMethods {
-    /// Get the name of this field.
-    fn name(&self) -> Option<&str>;
-
-    /// Get the type of this field.
-    fn ty(&self) -> TypeId;
-
-    /// Get the comment for this field.
-    fn comment(&self) -> Option<&str>;
-
-    /// If this is a bitfield, how many bits does it need?
-    fn bitfield_width(&self) -> Option<u32>;
-
-    /// Is this feild declared public?
-    fn is_public(&self) -> bool;
-
-    /// Get the annotations for this field.
-    fn annotations(&self) -> &Annotations;
-
-    /// The offset of the field (in bits)
-    fn offset(&self) -> Option<usize>;
-}
-
-/// A contiguous set of logical bitfields that live within the same physical
-/// allocation unit. See 9.2.4 [class.bit] in the C++ standard and [section
-/// 2.4.II.1 in the Itanium C++
-/// ABI](http://itanium-cxx-abi.github.io/cxx-abi/abi.html#class-types).
-#[derive(Debug)]
-pub struct BitfieldUnit {
-    nth: usize,
-    layout: Layout,
-    bitfields: Vec<Bitfield>,
-}
-
-impl BitfieldUnit {
-    /// Get the 1-based index of this bitfield unit within its containing
-    /// struct. Useful for generating a Rust struct's field name for this unit
-    /// of bitfields.
-    pub fn nth(&self) -> usize {
-        self.nth
-    }
-
-    /// Get the layout within which these bitfields reside.
-    pub fn layout(&self) -> Layout {
-        self.layout
-    }
-
-    /// Get the bitfields within this unit.
-    pub fn bitfields(&self) -> &[Bitfield] {
-        &self.bitfields
-    }
-}
-
-/// A struct representing a C++ field.
-#[derive(Debug)]
-pub enum Field {
-    /// A normal data member.
-    DataMember(FieldData),
-
-    /// A physical allocation unit containing many logical bitfields.
-    Bitfields(BitfieldUnit),
-}
-
-impl Field {
-    /// Get this field's layout.
-    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        match *self {
-            Field::Bitfields(BitfieldUnit { layout, .. }) => Some(layout),
-            Field::DataMember(ref data) => {
-                ctx.resolve_type(data.ty).layout(ctx)
-            }
-        }
-    }
-}
-
-impl Trace for Field {
-    type Extra = ();
-
-    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        match *self {
-            Field::DataMember(ref data) => {
-                tracer.visit_kind(data.ty.into(), EdgeKind::Field);
-            }
-            Field::Bitfields(BitfieldUnit { ref bitfields, .. }) => {
-                for bf in bitfields {
-                    tracer.visit_kind(bf.ty().into(), EdgeKind::Field);
-                }
-            }
-        }
-    }
-}
-
-impl DotAttributes for Field {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        match *self {
-            Field::DataMember(ref data) => data.dot_attributes(ctx, out),
-            Field::Bitfields(BitfieldUnit {
-                layout,
-                ref bitfields,
-                ..
-            }) => {
-                writeln!(
-                    out,
-                    r#"<tr>
-                              <td>bitfield unit</td>
-                              <td>
-                                <table border="0">
-                                  <tr>
-                                    <td>unit.size</td><td>{}</td>
-                                  </tr>
-                                  <tr>
-                                    <td>unit.align</td><td>{}</td>
-                                  </tr>
-                         "#,
-                    layout.size, layout.align
-                )?;
-                for bf in bitfields {
-                    bf.dot_attributes(ctx, out)?;
-                }
-                writeln!(out, "</table></td></tr>")
-            }
-        }
-    }
-}
-
-impl DotAttributes for FieldData {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>{}</td><td>{:?}</td></tr>",
-            self.name().unwrap_or("(anonymous)"),
-            self.ty()
-        )
-    }
-}
-
-impl DotAttributes for Bitfield {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>{} : {}</td><td>{:?}</td></tr>",
-            self.name().unwrap_or("(anonymous)"),
-            self.width(),
-            self.ty()
-        )
-    }
-}
-
-/// A logical bitfield within some physical bitfield allocation unit.
-#[derive(Debug)]
-pub struct Bitfield {
-    /// Index of the bit within this bitfield's allocation unit where this
-    /// bitfield's bits begin.
-    offset_into_unit: usize,
-
-    /// The field data for this bitfield.
-    data: FieldData,
-
-    /// Name of the generated Rust getter for this bitfield.
-    ///
-    /// Should be assigned before codegen.
-    getter_name: Option<String>,
-
-    /// Name of the generated Rust setter for this bitfield.
-    ///
-    /// Should be assigned before codegen.
-    setter_name: Option<String>,
-}
-
-impl Bitfield {
-    /// Construct a new bitfield.
-    fn new(offset_into_unit: usize, raw: RawField) -> Bitfield {
-        assert!(raw.bitfield_width().is_some());
-
-        Bitfield {
-            offset_into_unit,
-            data: raw.0,
-            getter_name: None,
-            setter_name: None,
-        }
-    }
-
-    /// Get the index of the bit within this bitfield's allocation unit where
-    /// this bitfield begins.
-    pub fn offset_into_unit(&self) -> usize {
-        self.offset_into_unit
-    }
-
-    /// Get the mask value that when &'ed with this bitfield's allocation unit
-    /// produces this bitfield's value.
-    pub fn mask(&self) -> u64 {
-        use std::u64;
-
-        let unoffseted_mask =
-            if self.width() as u64 == mem::size_of::<u64>() as u64 * 8 {
-                u64::MAX
-            } else {
-                (1u64 << self.width()) - 1u64
-            };
-
-        unoffseted_mask << self.offset_into_unit()
-    }
-
-    /// Get the bit width of this bitfield.
-    pub fn width(&self) -> u32 {
-        self.data.bitfield_width().unwrap()
-    }
-
-    /// Name of the generated Rust getter for this bitfield.
-    ///
-    /// Panics if called before assigning bitfield accessor names or if
-    /// this bitfield have no name.
-    pub fn getter_name(&self) -> &str {
-        assert!(
-            self.name().is_some(),
-            "`Bitfield::getter_name` called on anonymous field"
-        );
-        self.getter_name.as_ref().expect(
-            "`Bitfield::getter_name` should only be called after\
-             assigning bitfield accessor names",
-        )
-    }
-
-    /// Name of the generated Rust setter for this bitfield.
-    ///
-    /// Panics if called before assigning bitfield accessor names or if
-    /// this bitfield have no name.
-    pub fn setter_name(&self) -> &str {
-        assert!(
-            self.name().is_some(),
-            "`Bitfield::setter_name` called on anonymous field"
-        );
-        self.setter_name.as_ref().expect(
-            "`Bitfield::setter_name` should only be called\
-             after assigning bitfield accessor names",
-        )
-    }
-}
-
-impl FieldMethods for Bitfield {
-    fn name(&self) -> Option<&str> {
-        self.data.name()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.data.ty()
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.data.comment()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.data.bitfield_width()
-    }
-
-    fn is_public(&self) -> bool {
-        self.data.is_public()
-    }
-
-    fn annotations(&self) -> &Annotations {
-        self.data.annotations()
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.data.offset()
-    }
-}
-
-/// A raw field might be either of a plain data member or a bitfield within a
-/// bitfield allocation unit, but we haven't processed it and determined which
-/// yet (which would involve allocating it into a bitfield unit if it is a
-/// bitfield).
-#[derive(Debug)]
-struct RawField(FieldData);
-
-impl RawField {
-    /// Construct a new `RawField`.
-    fn new(
-        name: Option<String>,
-        ty: TypeId,
-        comment: Option<String>,
-        annotations: Option<Annotations>,
-        bitfield_width: Option<u32>,
-        public: bool,
-        offset: Option<usize>,
-    ) -> RawField {
-        RawField(FieldData {
-            name,
-            ty,
-            comment,
-            annotations: annotations.unwrap_or_default(),
-            bitfield_width,
-            public,
-            offset,
-        })
-    }
-}
-
-impl FieldMethods for RawField {
-    fn name(&self) -> Option<&str> {
-        self.0.name()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.0.ty()
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.0.comment()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.0.bitfield_width()
-    }
-
-    fn is_public(&self) -> bool {
-        self.0.is_public()
-    }
-
-    fn annotations(&self) -> &Annotations {
-        self.0.annotations()
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.0.offset()
-    }
-}
-
-/// Convert the given ordered set of raw fields into a list of either plain data
-/// members, and/or bitfield units containing multiple bitfields.
-///
-/// If we do not have the layout for a bitfield's type, then we can't reliably
-/// compute its allocation unit. In such cases, we return an error.
-fn raw_fields_to_fields_and_bitfield_units<I>(
-    ctx: &BindgenContext,
-    raw_fields: I,
-    packed: bool,
-) -> Result<(Vec<Field>, bool), ()>
-where
-    I: IntoIterator<Item = RawField>,
-{
-    let mut raw_fields = raw_fields.into_iter().fuse().peekable();
-    let mut fields = vec![];
-    let mut bitfield_unit_count = 0;
-
-    loop {
-        // While we have plain old data members, just keep adding them to our
-        // resulting fields. We introduce a scope here so that we can use
-        // `raw_fields` again after the `by_ref` iterator adaptor is dropped.
-        {
-            let non_bitfields = raw_fields
-                .by_ref()
-                .peeking_take_while(|f| f.bitfield_width().is_none())
-                .map(|f| Field::DataMember(f.0));
-            fields.extend(non_bitfields);
-        }
-
-        // Now gather all the consecutive bitfields. Only consecutive bitfields
-        // may potentially share a bitfield allocation unit with each other in
-        // the Itanium C++ ABI.
-        let mut bitfields = raw_fields
-            .by_ref()
-            .peeking_take_while(|f| f.bitfield_width().is_some())
-            .peekable();
-
-        if bitfields.peek().is_none() {
-            break;
-        }
-
-        bitfields_to_allocation_units(
-            ctx,
-            &mut bitfield_unit_count,
-            &mut fields,
-            bitfields,
-            packed,
-        )?;
-    }
-
-    assert!(
-        raw_fields.next().is_none(),
-        "The above loop should consume all items in `raw_fields`"
-    );
-
-    Ok((fields, bitfield_unit_count != 0))
-}
-
-/// Given a set of contiguous raw bitfields, group and allocate them into
-/// (potentially multiple) bitfield units.
-fn bitfields_to_allocation_units<E, I>(
-    ctx: &BindgenContext,
-    bitfield_unit_count: &mut usize,
-    fields: &mut E,
-    raw_bitfields: I,
-    packed: bool,
-) -> Result<(), ()>
-where
-    E: Extend<Field>,
-    I: IntoIterator<Item = RawField>,
-{
-    assert!(ctx.collected_typerefs());
-
-    // NOTE: What follows is reverse-engineered from LLVM's
-    // lib/AST/RecordLayoutBuilder.cpp
-    //
-    // FIXME(emilio): There are some differences between Microsoft and the
-    // Itanium ABI, but we'll ignore those and stick to Itanium for now.
-    //
-    // Also, we need to handle packed bitfields and stuff.
-    //
-    // TODO(emilio): Take into account C++'s wide bitfields, and
-    // packing, sigh.
-
-    fn flush_allocation_unit<E>(
-        fields: &mut E,
-        bitfield_unit_count: &mut usize,
-        unit_size_in_bits: usize,
-        unit_align_in_bits: usize,
-        bitfields: Vec<Bitfield>,
-        packed: bool,
-    ) where
-        E: Extend<Field>,
-    {
-        *bitfield_unit_count += 1;
-        let align = if packed {
-            1
-        } else {
-            bytes_from_bits_pow2(unit_align_in_bits)
-        };
-        let size = align_to(unit_size_in_bits, 8) / 8;
-        let layout = Layout::new(size, align);
-        fields.extend(Some(Field::Bitfields(BitfieldUnit {
-            nth: *bitfield_unit_count,
-            layout,
-            bitfields,
-        })));
-    }
-
-    let mut max_align = 0;
-    let mut unfilled_bits_in_unit = 0;
-    let mut unit_size_in_bits = 0;
-    let mut unit_align = 0;
-    let mut bitfields_in_unit = vec![];
-
-    // TODO(emilio): Determine this from attributes or pragma ms_struct
-    // directives. Also, perhaps we should check if the target is MSVC?
-    const is_ms_struct: bool = false;
-
-    for bitfield in raw_bitfields {
-        let bitfield_width = bitfield.bitfield_width().unwrap() as usize;
-        let bitfield_layout =
-            ctx.resolve_type(bitfield.ty()).layout(ctx).ok_or(())?;
-        let bitfield_size = bitfield_layout.size;
-        let bitfield_align = bitfield_layout.align;
-
-        let mut offset = unit_size_in_bits;
-        if !packed {
-            if is_ms_struct {
-                if unit_size_in_bits != 0 &&
-                    (bitfield_width == 0 ||
-                        bitfield_width > unfilled_bits_in_unit)
-                {
-                    // We've reached the end of this allocation unit, so flush it
-                    // and its bitfields.
-                    unit_size_in_bits =
-                        align_to(unit_size_in_bits, unit_align * 8);
-                    flush_allocation_unit(
-                        fields,
-                        bitfield_unit_count,
-                        unit_size_in_bits,
-                        unit_align,
-                        mem::take(&mut bitfields_in_unit),
-                        packed,
-                    );
-
-                    // Now we're working on a fresh bitfield allocation unit, so reset
-                    // the current unit size and alignment.
-                    offset = 0;
-                    unit_align = 0;
-                }
-            } else if offset != 0 &&
-                (bitfield_width == 0 ||
-                    (offset & (bitfield_align * 8 - 1)) + bitfield_width >
-                        bitfield_size * 8)
-            {
-                offset = align_to(offset, bitfield_align * 8);
-            }
-        }
-
-        // According to the x86[-64] ABI spec: "Unnamed bit-fields’ types do not
-        // affect the alignment of a structure or union". This makes sense: such
-        // bit-fields are only used for padding, and we can't perform an
-        // un-aligned read of something we can't read because we can't even name
-        // it.
-        if bitfield.name().is_some() {
-            max_align = cmp::max(max_align, bitfield_align);
-
-            // NB: The `bitfield_width` here is completely, absolutely
-            // intentional.  Alignment of the allocation unit is based on the
-            // maximum bitfield width, not (directly) on the bitfields' types'
-            // alignment.
-            unit_align = cmp::max(unit_align, bitfield_width);
-        }
-
-        // Always keep all bitfields around. While unnamed bitifields are used
-        // for padding (and usually not needed hereafter), large unnamed
-        // bitfields over their types size cause weird allocation size behavior from clang.
-        // Therefore, all bitfields needed to be kept around in order to check for this
-        // and make the struct opaque in this case
-        bitfields_in_unit.push(Bitfield::new(offset, bitfield));
-
-        unit_size_in_bits = offset + bitfield_width;
-
-        // Compute what the physical unit's final size would be given what we
-        // have seen so far, and use that to compute how many bits are still
-        // available in the unit.
-        let data_size = align_to(unit_size_in_bits, bitfield_align * 8);
-        unfilled_bits_in_unit = data_size - unit_size_in_bits;
-    }
-
-    if unit_size_in_bits != 0 {
-        // Flush the last allocation unit and its bitfields.
-        flush_allocation_unit(
-            fields,
-            bitfield_unit_count,
-            unit_size_in_bits,
-            unit_align,
-            bitfields_in_unit,
-            packed,
-        );
-    }
-
-    Ok(())
-}
-
-/// A compound structure's fields are initially raw, and have bitfields that
-/// have not been grouped into allocation units. During this time, the fields
-/// are mutable and we build them up during parsing.
-///
-/// Then, once resolving typerefs is completed, we compute all structs' fields'
-/// bitfield allocation units, and they remain frozen and immutable forever
-/// after.
-#[derive(Debug)]
-enum CompFields {
-    Before(Vec<RawField>),
-    After {
-        fields: Vec<Field>,
-        has_bitfield_units: bool,
-    },
-    Error,
-}
-
-impl Default for CompFields {
-    fn default() -> CompFields {
-        CompFields::Before(vec![])
-    }
-}
-
-impl CompFields {
-    fn append_raw_field(&mut self, raw: RawField) {
-        match *self {
-            CompFields::Before(ref mut raws) => {
-                raws.push(raw);
-            }
-            _ => {
-                panic!(
-                    "Must not append new fields after computing bitfield allocation units"
-                );
-            }
-        }
-    }
-
-    fn compute_bitfield_units(&mut self, ctx: &BindgenContext, packed: bool) {
-        let raws = match *self {
-            CompFields::Before(ref mut raws) => mem::take(raws),
-            _ => {
-                panic!("Already computed bitfield units");
-            }
-        };
-
-        let result = raw_fields_to_fields_and_bitfield_units(ctx, raws, packed);
-
-        match result {
-            Ok((fields, has_bitfield_units)) => {
-                *self = CompFields::After {
-                    fields,
-                    has_bitfield_units,
-                };
-            }
-            Err(()) => {
-                *self = CompFields::Error;
-            }
-        }
-    }
-
-    fn deanonymize_fields(&mut self, ctx: &BindgenContext, methods: &[Method]) {
-        let fields = match *self {
-            CompFields::After { ref mut fields, .. } => fields,
-            // Nothing to do here.
-            CompFields::Error => return,
-            CompFields::Before(_) => {
-                panic!("Not yet computed bitfield units.");
-            }
-        };
-
-        fn has_method(
-            methods: &[Method],
-            ctx: &BindgenContext,
-            name: &str,
-        ) -> bool {
-            methods.iter().any(|method| {
-                let method_name = ctx.resolve_func(method.signature()).name();
-                method_name == name || ctx.rust_mangle(method_name) == name
-            })
-        }
-
-        struct AccessorNamesPair {
-            getter: String,
-            setter: String,
-        }
-
-        let mut accessor_names: HashMap<String, AccessorNamesPair> = fields
-            .iter()
-            .flat_map(|field| match *field {
-                Field::Bitfields(ref bu) => &*bu.bitfields,
-                Field::DataMember(_) => &[],
-            })
-            .filter_map(|bitfield| bitfield.name())
-            .map(|bitfield_name| {
-                let bitfield_name = bitfield_name.to_string();
-                let getter = {
-                    let mut getter =
-                        ctx.rust_mangle(&bitfield_name).to_string();
-                    if has_method(methods, ctx, &getter) {
-                        getter.push_str("_bindgen_bitfield");
-                    }
-                    getter
-                };
-                let setter = {
-                    let setter = format!("set_{}", bitfield_name);
-                    let mut setter = ctx.rust_mangle(&setter).to_string();
-                    if has_method(methods, ctx, &setter) {
-                        setter.push_str("_bindgen_bitfield");
-                    }
-                    setter
-                };
-                (bitfield_name, AccessorNamesPair { getter, setter })
-            })
-            .collect();
-
-        let mut anon_field_counter = 0;
-        for field in fields.iter_mut() {
-            match *field {
-                Field::DataMember(FieldData { ref mut name, .. }) => {
-                    if name.is_some() {
-                        continue;
-                    }
-
-                    anon_field_counter += 1;
-                    *name = Some(format!(
-                        "{}{}",
-                        ctx.options().anon_fields_prefix,
-                        anon_field_counter
-                    ));
-                }
-                Field::Bitfields(ref mut bu) => {
-                    for bitfield in &mut bu.bitfields {
-                        if bitfield.name().is_none() {
-                            continue;
-                        }
-
-                        if let Some(AccessorNamesPair { getter, setter }) =
-                            accessor_names.remove(bitfield.name().unwrap())
-                        {
-                            bitfield.getter_name = Some(getter);
-                            bitfield.setter_name = Some(setter);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl Trace for CompFields {
-    type Extra = ();
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        match *self {
-            CompFields::Error => {}
-            CompFields::Before(ref fields) => {
-                for f in fields {
-                    tracer.visit_kind(f.ty().into(), EdgeKind::Field);
-                }
-            }
-            CompFields::After { ref fields, .. } => {
-                for f in fields {
-                    f.trace(context, tracer, &());
-                }
-            }
-        }
-    }
-}
-
-/// Common data shared across different field types.
-#[derive(Clone, Debug)]
-pub struct FieldData {
-    /// The name of the field, empty if it's an unnamed bitfield width.
-    name: Option<String>,
-
-    /// The inner type.
-    ty: TypeId,
-
-    /// The doc comment on the field if any.
-    comment: Option<String>,
-
-    /// Annotations for this field, or the default.
-    annotations: Annotations,
-
-    /// If this field is a bitfield, and how many bits does it contain if it is.
-    bitfield_width: Option<u32>,
-
-    /// If the C++ field is declared `public`
-    public: bool,
-
-    /// The offset of the field (in bits)
-    offset: Option<usize>,
-}
-
-impl FieldMethods for FieldData {
-    fn name(&self) -> Option<&str> {
-        self.name.as_deref()
-    }
-
-    fn ty(&self) -> TypeId {
-        self.ty
-    }
-
-    fn comment(&self) -> Option<&str> {
-        self.comment.as_deref()
-    }
-
-    fn bitfield_width(&self) -> Option<u32> {
-        self.bitfield_width
-    }
-
-    fn is_public(&self) -> bool {
-        self.public
-    }
-
-    fn annotations(&self) -> &Annotations {
-        &self.annotations
-    }
-
-    fn offset(&self) -> Option<usize> {
-        self.offset
-    }
-}
-
-/// The kind of inheritance a base class is using.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum BaseKind {
-    /// Normal inheritance, like:
-    ///
-    /// ```cpp
-    /// class A : public B {};
-    /// ```
-    Normal,
-    /// Virtual inheritance, like:
-    ///
-    /// ```cpp
-    /// class A: public virtual B {};
-    /// ```
-    Virtual,
-}
-
-/// A base class.
-#[derive(Clone, Debug)]
-pub struct Base {
-    /// The type of this base class.
-    pub ty: TypeId,
-    /// The kind of inheritance we're doing.
-    pub kind: BaseKind,
-    /// Name of the field in which this base should be stored.
-    pub field_name: String,
-    /// Whether this base is inherited from publically.
-    pub is_pub: bool,
-}
-
-impl Base {
-    /// Whether this base class is inheriting virtually.
-    pub fn is_virtual(&self) -> bool {
-        self.kind == BaseKind::Virtual
-    }
-
-    /// Whether this base class should have it's own field for storage.
-    pub fn requires_storage(&self, ctx: &BindgenContext) -> bool {
-        // Virtual bases are already taken into account by the vtable
-        // pointer.
-        //
-        // FIXME(emilio): Is this always right?
-        if self.is_virtual() {
-            return false;
-        }
-
-        // NB: We won't include zero-sized types in our base chain because they
-        // would contribute to our size given the dummy field we insert for
-        // zero-sized types.
-        if self.ty.is_zero_sized(ctx) {
-            return false;
-        }
-
-        true
-    }
-
-    /// Whether this base is inherited from publically.
-    pub fn is_public(&self) -> bool {
-        self.is_pub
-    }
-}
-
-/// A compound type.
-///
-/// Either a struct or union, a compound type is built up from the combination
-/// of fields which also are associated with their own (potentially compound)
-/// type.
-#[derive(Debug)]
-pub struct CompInfo {
-    /// Whether this is a struct or a union.
-    kind: CompKind,
-
-    /// The members of this struct or union.
-    fields: CompFields,
-
-    /// The abstract template parameters of this class. Note that these are NOT
-    /// concrete template arguments, and should always be a
-    /// `Type(TypeKind::TypeParam(name))`. For concrete template arguments, see
-    /// `TypeKind::TemplateInstantiation`.
-    template_params: Vec<TypeId>,
-
-    /// The method declarations inside this class, if in C++ mode.
-    methods: Vec<Method>,
-
-    /// The different constructors this struct or class contains.
-    constructors: Vec<FunctionId>,
-
-    /// The destructor of this type. The bool represents whether this destructor
-    /// is virtual.
-    destructor: Option<(MethodKind, FunctionId)>,
-
-    /// Vector of classes this one inherits from.
-    base_members: Vec<Base>,
-
-    /// The inner types that were declared inside this class, in something like:
-    ///
-    /// class Foo {
-    ///     typedef int FooTy;
-    ///     struct Bar {
-    ///         int baz;
-    ///     };
-    /// }
-    ///
-    /// static Foo::Bar const = {3};
-    inner_types: Vec<TypeId>,
-
-    /// Set of static constants declared inside this class.
-    inner_vars: Vec<VarId>,
-
-    /// Whether this type should generate an vtable (TODO: Should be able to
-    /// look at the virtual methods and ditch this field).
-    has_own_virtual_method: bool,
-
-    /// Whether this type has destructor.
-    has_destructor: bool,
-
-    /// Whether this type has a base type with more than one member.
-    ///
-    /// TODO: We should be able to compute this.
-    has_nonempty_base: bool,
-
-    /// If this type has a template parameter which is not a type (e.g.: a
-    /// size_t)
-    has_non_type_template_params: bool,
-
-    /// Whether this type has a bit field member whose width couldn't be
-    /// evaluated (e.g. if it depends on a template parameter). We generate an
-    /// opaque type in this case.
-    has_unevaluable_bit_field_width: bool,
-
-    /// Whether we saw `__attribute__((packed))` on or within this type.
-    packed_attr: bool,
-
-    /// Used to know if we've found an opaque attribute that could cause us to
-    /// generate a type with invalid layout. This is explicitly used to avoid us
-    /// generating bad alignments when parsing types like max_align_t.
-    ///
-    /// It's not clear what the behavior should be here, if generating the item
-    /// and pray, or behave as an opaque type.
-    found_unknown_attr: bool,
-
-    /// Used to indicate when a struct has been forward declared. Usually used
-    /// in headers so that APIs can't modify them directly.
-    is_forward_declaration: bool,
-}
-
-impl CompInfo {
-    /// Construct a new compound type.
-    pub fn new(kind: CompKind) -> Self {
-        CompInfo {
-            kind,
-            fields: CompFields::default(),
-            template_params: vec![],
-            methods: vec![],
-            constructors: vec![],
-            destructor: None,
-            base_members: vec![],
-            inner_types: vec![],
-            inner_vars: vec![],
-            has_own_virtual_method: false,
-            has_destructor: false,
-            has_nonempty_base: false,
-            has_non_type_template_params: false,
-            has_unevaluable_bit_field_width: false,
-            packed_attr: false,
-            found_unknown_attr: false,
-            is_forward_declaration: false,
-        }
-    }
-
-    /// Compute the layout of this type.
-    ///
-    /// This is called as a fallback under some circumstances where LLVM doesn't
-    /// give us the correct layout.
-    ///
-    /// If we're a union without known layout, we try to compute it from our
-    /// members. This is not ideal, but clang fails to report the size for these
-    /// kind of unions, see test/headers/template_union.hpp
-    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        // We can't do better than clang here, sorry.
-        if self.kind == CompKind::Struct {
-            return None;
-        }
-
-        // By definition, we don't have the right layout information here if
-        // we're a forward declaration.
-        if self.is_forward_declaration() {
-            return None;
-        }
-
-        // empty union case
-        if !self.has_fields() {
-            return None;
-        }
-
-        let mut max_size = 0;
-        // Don't allow align(0)
-        let mut max_align = 1;
-        self.each_known_field_layout(ctx, |layout| {
-            max_size = cmp::max(max_size, layout.size);
-            max_align = cmp::max(max_align, layout.align);
-        });
-
-        Some(Layout::new(max_size, max_align))
-    }
-
-    /// Get this type's set of fields.
-    pub fn fields(&self) -> &[Field] {
-        match self.fields {
-            CompFields::Error => &[],
-            CompFields::After { ref fields, .. } => fields,
-            CompFields::Before(..) => {
-                panic!("Should always have computed bitfield units first");
-            }
-        }
-    }
-
-    fn has_fields(&self) -> bool {
-        match self.fields {
-            CompFields::Error => false,
-            CompFields::After { ref fields, .. } => !fields.is_empty(),
-            CompFields::Before(ref raw_fields) => !raw_fields.is_empty(),
-        }
-    }
-
-    fn each_known_field_layout(
-        &self,
-        ctx: &BindgenContext,
-        mut callback: impl FnMut(Layout),
-    ) {
-        match self.fields {
-            CompFields::Error => {}
-            CompFields::After { ref fields, .. } => {
-                for field in fields.iter() {
-                    if let Some(layout) = field.layout(ctx) {
-                        callback(layout);
-                    }
-                }
-            }
-            CompFields::Before(ref raw_fields) => {
-                for field in raw_fields.iter() {
-                    let field_ty = ctx.resolve_type(field.0.ty);
-                    if let Some(layout) = field_ty.layout(ctx) {
-                        callback(layout);
-                    }
-                }
-            }
-        }
-    }
-
-    fn has_bitfields(&self) -> bool {
-        match self.fields {
-            CompFields::Error => false,
-            CompFields::After {
-                has_bitfield_units, ..
-            } => has_bitfield_units,
-            CompFields::Before(_) => {
-                panic!("Should always have computed bitfield units first");
-            }
-        }
-    }
-
-    /// Returns whether we have a too large bitfield unit, in which case we may
-    /// not be able to derive some of the things we should be able to normally
-    /// derive.
-    pub fn has_too_large_bitfield_unit(&self) -> bool {
-        if !self.has_bitfields() {
-            return false;
-        }
-        self.fields().iter().any(|field| match *field {
-            Field::DataMember(..) => false,
-            Field::Bitfields(ref unit) => {
-                unit.layout.size > RUST_DERIVE_IN_ARRAY_LIMIT
-            }
-        })
-    }
-
-    /// Does this type have any template parameters that aren't types
-    /// (e.g. int)?
-    pub fn has_non_type_template_params(&self) -> bool {
-        self.has_non_type_template_params
-    }
-
-    /// Do we see a virtual function during parsing?
-    /// Get the has_own_virtual_method boolean.
-    pub fn has_own_virtual_method(&self) -> bool {
-        self.has_own_virtual_method
-    }
-
-    /// Did we see a destructor when parsing this type?
-    pub fn has_own_destructor(&self) -> bool {
-        self.has_destructor
-    }
-
-    /// Get this type's set of methods.
-    pub fn methods(&self) -> &[Method] {
-        &self.methods
-    }
-
-    /// Get this type's set of constructors.
-    pub fn constructors(&self) -> &[FunctionId] {
-        &self.constructors
-    }
-
-    /// Get this type's destructor.
-    pub fn destructor(&self) -> Option<(MethodKind, FunctionId)> {
-        self.destructor
-    }
-
-    /// What kind of compound type is this?
-    pub fn kind(&self) -> CompKind {
-        self.kind
-    }
-
-    /// Is this a union?
-    pub fn is_union(&self) -> bool {
-        self.kind() == CompKind::Union
-    }
-
-    /// The set of types that this one inherits from.
-    pub fn base_members(&self) -> &[Base] {
-        &self.base_members
-    }
-
-    /// Construct a new compound type from a Clang type.
-    pub fn from_ty(
-        potential_id: ItemId,
-        ty: &clang::Type,
-        location: Option<clang::Cursor>,
-        ctx: &mut BindgenContext,
-    ) -> Result<Self, ParseError> {
-        use clang_sys::*;
-        assert!(
-            ty.template_args().is_none(),
-            "We handle template instantiations elsewhere"
-        );
-
-        let mut cursor = ty.declaration();
-        let mut kind = Self::kind_from_cursor(&cursor);
-        if kind.is_err() {
-            if let Some(location) = location {
-                kind = Self::kind_from_cursor(&location);
-                cursor = location;
-            }
-        }
-
-        let kind = kind?;
-
-        debug!("CompInfo::from_ty({:?}, {:?})", kind, cursor);
-
-        let mut ci = CompInfo::new(kind);
-        ci.is_forward_declaration =
-            location.map_or(true, |cur| match cur.kind() {
-                CXCursor_ParmDecl => true,
-                CXCursor_StructDecl | CXCursor_UnionDecl |
-                CXCursor_ClassDecl => !cur.is_definition(),
-                _ => false,
-            });
-
-        let mut maybe_anonymous_struct_field = None;
-        cursor.visit(|cur| {
-            if cur.kind() != CXCursor_FieldDecl {
-                if let Some((ty, clang_ty, public, offset)) =
-                    maybe_anonymous_struct_field.take()
-                {
-                    if cur.kind() == CXCursor_TypedefDecl &&
-                        cur.typedef_type().unwrap().canonical_type() ==
-                            clang_ty
-                    {
-                        // Typedefs of anonymous structs appear later in the ast
-                        // than the struct itself, that would otherwise be an
-                        // anonymous field. Detect that case here, and do
-                        // nothing.
-                    } else {
-                        let field = RawField::new(
-                            None, ty, None, None, None, public, offset,
-                        );
-                        ci.fields.append_raw_field(field);
-                    }
-                }
-            }
-
-            match cur.kind() {
-                CXCursor_FieldDecl => {
-                    if let Some((ty, clang_ty, public, offset)) =
-                        maybe_anonymous_struct_field.take()
-                    {
-                        let mut used = false;
-                        cur.visit(|child| {
-                            if child.cur_type() == clang_ty {
-                                used = true;
-                            }
-                            CXChildVisit_Continue
-                        });
-
-                        if !used {
-                            let field = RawField::new(
-                                None, ty, None, None, None, public, offset,
-                            );
-                            ci.fields.append_raw_field(field);
-                        }
-                    }
-
-                    let bit_width = if cur.is_bit_field() {
-                        let width = cur.bit_width();
-
-                        // Make opaque type if the bit width couldn't be
-                        // evaluated.
-                        if width.is_none() {
-                            ci.has_unevaluable_bit_field_width = true;
-                            return CXChildVisit_Break;
-                        }
-
-                        width
-                    } else {
-                        None
-                    };
-
-                    let field_type = Item::from_ty_or_ref(
-                        cur.cur_type(),
-                        cur,
-                        Some(potential_id),
-                        ctx,
-                    );
-
-                    let comment = cur.raw_comment();
-                    let annotations = Annotations::new(&cur);
-                    let name = cur.spelling();
-                    let is_public = cur.public_accessible();
-                    let offset = cur.offset_of_field().ok();
-
-                    // Name can be empty if there are bitfields, for example,
-                    // see tests/headers/struct_with_bitfields.h
-                    assert!(
-                        !name.is_empty() || bit_width.is_some(),
-                        "Empty field name?"
-                    );
-
-                    let name = if name.is_empty() { None } else { Some(name) };
-
-                    let field = RawField::new(
-                        name,
-                        field_type,
-                        comment,
-                        annotations,
-                        bit_width,
-                        is_public,
-                        offset,
-                    );
-                    ci.fields.append_raw_field(field);
-
-                    // No we look for things like attributes and stuff.
-                    cur.visit(|cur| {
-                        if cur.kind() == CXCursor_UnexposedAttr {
-                            ci.found_unknown_attr = true;
-                        }
-                        CXChildVisit_Continue
-                    });
-                }
-                CXCursor_UnexposedAttr => {
-                    ci.found_unknown_attr = true;
-                }
-                CXCursor_EnumDecl |
-                CXCursor_TypeAliasDecl |
-                CXCursor_TypeAliasTemplateDecl |
-                CXCursor_TypedefDecl |
-                CXCursor_StructDecl |
-                CXCursor_UnionDecl |
-                CXCursor_ClassTemplate |
-                CXCursor_ClassDecl => {
-                    // We can find non-semantic children here, clang uses a
-                    // StructDecl to note incomplete structs that haven't been
-                    // forward-declared before, see [1].
-                    //
-                    // Also, clang seems to scope struct definitions inside
-                    // unions, and other named struct definitions inside other
-                    // structs to the whole translation unit.
-                    //
-                    // Let's just assume that if the cursor we've found is a
-                    // definition, it's a valid inner type.
-                    //
-                    // [1]: https://github.com/rust-lang/rust-bindgen/issues/482
-                    let is_inner_struct =
-                        cur.semantic_parent() == cursor || cur.is_definition();
-                    if !is_inner_struct {
-                        return CXChildVisit_Continue;
-                    }
-
-                    // Even if this is a definition, we may not be the semantic
-                    // parent, see #1281.
-                    let inner = Item::parse(cur, Some(potential_id), ctx)
-                        .expect("Inner ClassDecl");
-
-                    // If we avoided recursion parsing this type (in
-                    // `Item::from_ty_with_id()`), then this might not be a
-                    // valid type ID, so check and gracefully handle this.
-                    if ctx.resolve_item_fallible(inner).is_some() {
-                        let inner = inner.expect_type_id(ctx);
-
-                        ci.inner_types.push(inner);
-
-                        // A declaration of an union or a struct without name
-                        // could also be an unnamed field, unfortunately.
-                        if cur.spelling().is_empty() &&
-                            cur.kind() != CXCursor_EnumDecl
-                        {
-                            let ty = cur.cur_type();
-                            let public = cur.public_accessible();
-                            let offset = cur.offset_of_field().ok();
-
-                            maybe_anonymous_struct_field =
-                                Some((inner, ty, public, offset));
-                        }
-                    }
-                }
-                CXCursor_PackedAttr => {
-                    ci.packed_attr = true;
-                }
-                CXCursor_TemplateTypeParameter => {
-                    let param = Item::type_param(None, cur, ctx).expect(
-                        "Item::type_param should't fail when pointing \
-                         at a TemplateTypeParameter",
-                    );
-                    ci.template_params.push(param);
-                }
-                CXCursor_CXXBaseSpecifier => {
-                    let is_virtual_base = cur.is_virtual_base();
-                    ci.has_own_virtual_method |= is_virtual_base;
-
-                    let kind = if is_virtual_base {
-                        BaseKind::Virtual
-                    } else {
-                        BaseKind::Normal
-                    };
-
-                    let field_name = match ci.base_members.len() {
-                        0 => "_base".into(),
-                        n => format!("_base_{}", n),
-                    };
-                    let type_id =
-                        Item::from_ty_or_ref(cur.cur_type(), cur, None, ctx);
-                    ci.base_members.push(Base {
-                        ty: type_id,
-                        kind,
-                        field_name,
-                        is_pub: cur.access_specifier() ==
-                            clang_sys::CX_CXXPublic,
-                    });
-                }
-                CXCursor_Constructor | CXCursor_Destructor |
-                CXCursor_CXXMethod => {
-                    let is_virtual = cur.method_is_virtual();
-                    let is_static = cur.method_is_static();
-                    debug_assert!(!(is_static && is_virtual), "How?");
-
-                    ci.has_destructor |= cur.kind() == CXCursor_Destructor;
-                    ci.has_own_virtual_method |= is_virtual;
-
-                    // This used to not be here, but then I tried generating
-                    // stylo bindings with this (without path filters), and
-                    // cried a lot with a method in gfx/Point.h
-                    // (ToUnknownPoint), that somehow was causing the same type
-                    // to be inserted in the map two times.
-                    //
-                    // I couldn't make a reduced test case, but anyway...
-                    // Methods of template functions not only used to be inlined,
-                    // but also instantiated, and we wouldn't be able to call
-                    // them, so just bail out.
-                    if !ci.template_params.is_empty() {
-                        return CXChildVisit_Continue;
-                    }
-
-                    // NB: This gets us an owned `Function`, not a
-                    // `FunctionSig`.
-                    let signature =
-                        match Item::parse(cur, Some(potential_id), ctx) {
-                            Ok(item)
-                                if ctx
-                                    .resolve_item(item)
-                                    .kind()
-                                    .is_function() =>
-                            {
-                                item
-                            }
-                            _ => return CXChildVisit_Continue,
-                        };
-
-                    let signature = signature.expect_function_id(ctx);
-
-                    match cur.kind() {
-                        CXCursor_Constructor => {
-                            ci.constructors.push(signature);
-                        }
-                        CXCursor_Destructor => {
-                            let kind = if is_virtual {
-                                MethodKind::VirtualDestructor {
-                                    pure_virtual: cur.method_is_pure_virtual(),
-                                }
-                            } else {
-                                MethodKind::Destructor
-                            };
-                            ci.destructor = Some((kind, signature));
-                        }
-                        CXCursor_CXXMethod => {
-                            let is_const = cur.method_is_const();
-                            let method_kind = if is_static {
-                                MethodKind::Static
-                            } else if is_virtual {
-                                MethodKind::Virtual {
-                                    pure_virtual: cur.method_is_pure_virtual(),
-                                }
-                            } else {
-                                MethodKind::Normal
-                            };
-
-                            let method =
-                                Method::new(method_kind, signature, is_const);
-
-                            ci.methods.push(method);
-                        }
-                        _ => unreachable!("How can we see this here?"),
-                    }
-                }
-                CXCursor_NonTypeTemplateParameter => {
-                    ci.has_non_type_template_params = true;
-                }
-                CXCursor_VarDecl => {
-                    let linkage = cur.linkage();
-                    if linkage != CXLinkage_External &&
-                        linkage != CXLinkage_UniqueExternal
-                    {
-                        return CXChildVisit_Continue;
-                    }
-
-                    let visibility = cur.visibility();
-                    if visibility != CXVisibility_Default {
-                        return CXChildVisit_Continue;
-                    }
-
-                    if let Ok(item) = Item::parse(cur, Some(potential_id), ctx)
-                    {
-                        ci.inner_vars.push(item.as_var_id_unchecked());
-                    }
-                }
-                // Intentionally not handled
-                CXCursor_CXXAccessSpecifier |
-                CXCursor_CXXFinalAttr |
-                CXCursor_FunctionTemplate |
-                CXCursor_ConversionFunction => {}
-                _ => {
-                    warn!(
-                        "unhandled comp member `{}` (kind {:?}) in `{}` ({})",
-                        cur.spelling(),
-                        clang::kind_to_str(cur.kind()),
-                        cursor.spelling(),
-                        cur.location()
-                    );
-                }
-            }
-            CXChildVisit_Continue
-        });
-
-        if let Some((ty, _, public, offset)) = maybe_anonymous_struct_field {
-            let field =
-                RawField::new(None, ty, None, None, None, public, offset);
-            ci.fields.append_raw_field(field);
-        }
-
-        Ok(ci)
-    }
-
-    fn kind_from_cursor(
-        cursor: &clang::Cursor,
-    ) -> Result<CompKind, ParseError> {
-        use clang_sys::*;
-        Ok(match cursor.kind() {
-            CXCursor_UnionDecl => CompKind::Union,
-            CXCursor_ClassDecl | CXCursor_StructDecl => CompKind::Struct,
-            CXCursor_CXXBaseSpecifier |
-            CXCursor_ClassTemplatePartialSpecialization |
-            CXCursor_ClassTemplate => match cursor.template_kind() {
-                CXCursor_UnionDecl => CompKind::Union,
-                _ => CompKind::Struct,
-            },
-            _ => {
-                warn!("Unknown kind for comp type: {:?}", cursor);
-                return Err(ParseError::Continue);
-            }
-        })
-    }
-
-    /// Get the set of types that were declared within this compound type
-    /// (e.g. nested class definitions).
-    pub fn inner_types(&self) -> &[TypeId] {
-        &self.inner_types
-    }
-
-    /// Get the set of static variables declared within this compound type.
-    pub fn inner_vars(&self) -> &[VarId] {
-        &self.inner_vars
-    }
-
-    /// Have we found a field with an opaque type that could potentially mess up
-    /// the layout of this compound type?
-    pub fn found_unknown_attr(&self) -> bool {
-        self.found_unknown_attr
-    }
-
-    /// Is this compound type packed?
-    pub fn is_packed(
-        &self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-    ) -> bool {
-        if self.packed_attr {
-            return true;
-        }
-
-        // Even though `libclang` doesn't expose `#pragma packed(...)`, we can
-        // detect it through its effects.
-        if let Some(parent_layout) = layout {
-            let mut packed = false;
-            self.each_known_field_layout(ctx, |layout| {
-                packed = packed || layout.align > parent_layout.align;
-            });
-            if packed {
-                info!("Found a struct that was defined within `#pragma packed(...)`");
-                return true;
-            }
-
-            if self.has_own_virtual_method && parent_layout.align == 1 {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    /// Returns true if compound type has been forward declared
-    pub fn is_forward_declaration(&self) -> bool {
-        self.is_forward_declaration
-    }
-
-    /// Compute this compound structure's bitfield allocation units.
-    pub fn compute_bitfield_units(
-        &mut self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-    ) {
-        let packed = self.is_packed(ctx, layout);
-        self.fields.compute_bitfield_units(ctx, packed)
-    }
-
-    /// Assign for each anonymous field a generated name.
-    pub fn deanonymize_fields(&mut self, ctx: &BindgenContext) {
-        self.fields.deanonymize_fields(ctx, &self.methods);
-    }
-
-    /// Returns whether the current union can be represented as a Rust `union`
-    ///
-    /// Requirements:
-    ///     1. Current RustTarget allows for `untagged_union`
-    ///     2. Each field can derive `Copy` or we use ManuallyDrop.
-    ///     3. It's not zero-sized.
-    ///
-    /// Second boolean returns whether all fields can be copied (and thus
-    /// ManuallyDrop is not needed).
-    pub fn is_rust_union(
-        &self,
-        ctx: &BindgenContext,
-        layout: Option<&Layout>,
-        name: &str,
-    ) -> (bool, bool) {
-        if !self.is_union() {
-            return (false, false);
-        }
-
-        if !ctx.options().rust_features().untagged_union {
-            return (false, false);
-        }
-
-        if self.is_forward_declaration() {
-            return (false, false);
-        }
-
-        let union_style = if ctx.options().bindgen_wrapper_union.matches(name) {
-            NonCopyUnionStyle::BindgenWrapper
-        } else if ctx.options().manually_drop_union.matches(name) {
-            NonCopyUnionStyle::ManuallyDrop
-        } else {
-            ctx.options().default_non_copy_union_style
-        };
-
-        let all_can_copy = self.fields().iter().all(|f| match *f {
-            Field::DataMember(ref field_data) => {
-                field_data.ty().can_derive_copy(ctx)
-            }
-            Field::Bitfields(_) => true,
-        });
-
-        if !all_can_copy && union_style == NonCopyUnionStyle::BindgenWrapper {
-            return (false, false);
-        }
-
-        if layout.map_or(false, |l| l.size == 0) {
-            return (false, false);
-        }
-
-        (true, all_can_copy)
-    }
-}
-
-impl DotAttributes for CompInfo {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(out, "<tr><td>CompKind</td><td>{:?}</td></tr>", self.kind)?;
-
-        if self.has_own_virtual_method {
-            writeln!(out, "<tr><td>has_vtable</td><td>true</td></tr>")?;
-        }
-
-        if self.has_destructor {
-            writeln!(out, "<tr><td>has_destructor</td><td>true</td></tr>")?;
-        }
-
-        if self.has_nonempty_base {
-            writeln!(out, "<tr><td>has_nonempty_base</td><td>true</td></tr>")?;
-        }
-
-        if self.has_non_type_template_params {
-            writeln!(
-                out,
-                "<tr><td>has_non_type_template_params</td><td>true</td></tr>"
-            )?;
-        }
-
-        if self.packed_attr {
-            writeln!(out, "<tr><td>packed_attr</td><td>true</td></tr>")?;
-        }
-
-        if self.is_forward_declaration {
-            writeln!(
-                out,
-                "<tr><td>is_forward_declaration</td><td>true</td></tr>"
-            )?;
-        }
-
-        if !self.fields().is_empty() {
-            writeln!(out, r#"<tr><td>fields</td><td><table border="0">"#)?;
-            for field in self.fields() {
-                field.dot_attributes(ctx, out)?;
-            }
-            writeln!(out, "</table></td></tr>")?;
-        }
-
-        Ok(())
-    }
-}
-
-impl IsOpaque for CompInfo {
-    type Extra = Option<Layout>;
-
-    fn is_opaque(&self, ctx: &BindgenContext, layout: &Option<Layout>) -> bool {
-        if self.has_non_type_template_params ||
-            self.has_unevaluable_bit_field_width
-        {
-            return true;
-        }
-
-        // When we do not have the layout for a bitfield's type (for example, it
-        // is a type parameter), then we can't compute bitfield units. We are
-        // left with no choice but to make the whole struct opaque, or else we
-        // might generate structs with incorrect sizes and alignments.
-        if let CompFields::Error = self.fields {
-            return true;
-        }
-
-        // Bitfields with a width that is larger than their unit's width have
-        // some strange things going on, and the best we can do is make the
-        // whole struct opaque.
-        if self.fields().iter().any(|f| match *f {
-            Field::DataMember(_) => false,
-            Field::Bitfields(ref unit) => unit.bitfields().iter().any(|bf| {
-                let bitfield_layout = ctx
-                    .resolve_type(bf.ty())
-                    .layout(ctx)
-                    .expect("Bitfield without layout? Gah!");
-                bf.width() / 8 > bitfield_layout.size as u32
-            }),
-        }) {
-            return true;
-        }
-
-        if !ctx.options().rust_features().repr_packed_n {
-            // If we don't have `#[repr(packed(N)]`, the best we can
-            // do is make this struct opaque.
-            //
-            // See https://github.com/rust-lang/rust-bindgen/issues/537 and
-            // https://github.com/rust-lang/rust/issues/33158
-            if self.is_packed(ctx, layout.as_ref()) &&
-                layout.map_or(false, |l| l.align > 1)
-            {
-                warn!("Found a type that is both packed and aligned to greater than \
-                       1; Rust before version 1.33 doesn't have `#[repr(packed(N))]`, so we \
-                       are treating it as opaque. You may wish to set bindgen's rust target \
-                       version to 1.33 or later to enable `#[repr(packed(N))]` support.");
-                return true;
-            }
-        }
-
-        false
-    }
-}
-
-impl TemplateParameters for CompInfo {
-    fn self_template_params(&self, _ctx: &BindgenContext) -> Vec<TypeId> {
-        self.template_params.clone()
-    }
-}
-
-impl Trace for CompInfo {
-    type Extra = Item;
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
-    where
-        T: Tracer,
-    {
-        for p in item.all_template_params(context) {
-            tracer.visit_kind(p.into(), EdgeKind::TemplateParameterDefinition);
-        }
-
-        for ty in self.inner_types() {
-            tracer.visit_kind(ty.into(), EdgeKind::InnerType);
-        }
-
-        for &var in self.inner_vars() {
-            tracer.visit_kind(var.into(), EdgeKind::InnerVar);
-        }
-
-        for method in self.methods() {
-            tracer.visit_kind(method.signature.into(), EdgeKind::Method);
-        }
-
-        if let Some((_kind, signature)) = self.destructor() {
-            tracer.visit_kind(signature.into(), EdgeKind::Destructor);
-        }
-
-        for ctor in self.constructors() {
-            tracer.visit_kind(ctor.into(), EdgeKind::Constructor);
-        }
-
-        // Base members and fields are not generated for opaque types (but all
-        // of the above things are) so stop here.
-        if item.is_opaque(context, &()) {
-            return;
-        }
-
-        for base in self.base_members() {
-            tracer.visit_kind(base.ty.into(), EdgeKind::BaseMember);
-        }
-
-        self.fields.trace(context, tracer, &());
-    }
-}
diff --git a/src/ir/context.rs b/src/ir/context.rs
deleted file mode 100644
index 12373952..00000000
--- a/src/ir/context.rs
+++ /dev/null
@@ -1,2855 +0,0 @@
-//! Common context that is passed around during parsing and codegen.
-
-use super::super::time::Timer;
-use super::analysis::{
-    analyze, as_cannot_derive_set, CannotDerive, DeriveTrait,
-    HasDestructorAnalysis, HasFloat, HasTypeParameterInArray,
-    HasVtableAnalysis, HasVtableResult, SizednessAnalysis, SizednessResult,
-    UsedTemplateParameters,
-};
-use super::derive::{
-    CanDerive, CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
-    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
-};
-use super::function::Function;
-use super::int::IntKind;
-use super::item::{IsOpaque, Item, ItemAncestors, ItemSet};
-use super::item_kind::ItemKind;
-use super::module::{Module, ModuleKind};
-use super::template::{TemplateInstantiation, TemplateParameters};
-use super::traversal::{self, Edge, ItemTraversal};
-use super::ty::{FloatKind, Type, TypeKind};
-use crate::callbacks::ParseCallbacks;
-use crate::clang::{self, Cursor};
-use crate::parse::ClangItemParser;
-use crate::BindgenOptions;
-use crate::{Entry, HashMap, HashSet};
-use cexpr;
-use clang_sys;
-use proc_macro2::{Ident, Span};
-use std::borrow::Cow;
-use std::cell::{Cell, RefCell};
-use std::collections::{BTreeSet, HashMap as StdHashMap};
-use std::iter::IntoIterator;
-use std::mem;
-
-/// An identifier for some kind of IR item.
-#[derive(Debug, Copy, Clone, Eq, PartialOrd, Ord, Hash)]
-pub struct ItemId(usize);
-
-macro_rules! item_id_newtype {
-    (
-        $( #[$attr:meta] )*
-        pub struct $name:ident(ItemId)
-        where
-            $( #[$checked_attr:meta] )*
-            checked = $checked:ident with $check_method:ident,
-            $( #[$expected_attr:meta] )*
-            expected = $expected:ident,
-            $( #[$unchecked_attr:meta] )*
-            unchecked = $unchecked:ident;
-    ) => {
-        $( #[$attr] )*
-        #[derive(Debug, Copy, Clone, Eq, PartialOrd, Ord, Hash)]
-        pub struct $name(ItemId);
-
-        impl $name {
-            /// Create an `ItemResolver` from this id.
-            pub fn into_resolver(self) -> ItemResolver {
-                let id: ItemId = self.into();
-                id.into()
-            }
-        }
-
-        impl<T> ::std::cmp::PartialEq<T> for $name
-        where
-            T: Copy + Into<ItemId>
-        {
-            fn eq(&self, rhs: &T) -> bool {
-                let rhs: ItemId = (*rhs).into();
-                self.0 == rhs
-            }
-        }
-
-        impl From<$name> for ItemId {
-            fn from(id: $name) -> ItemId {
-                id.0
-            }
-        }
-
-        impl<'a> From<&'a $name> for ItemId {
-            fn from(id: &'a $name) -> ItemId {
-                id.0
-            }
-        }
-
-        impl ItemId {
-            $( #[$checked_attr] )*
-            pub fn $checked(&self, ctx: &BindgenContext) -> Option<$name> {
-                if ctx.resolve_item(*self).kind().$check_method() {
-                    Some($name(*self))
-                } else {
-                    None
-                }
-            }
-
-            $( #[$expected_attr] )*
-            pub fn $expected(&self, ctx: &BindgenContext) -> $name {
-                self.$checked(ctx)
-                    .expect(concat!(
-                        stringify!($expected),
-                        " called with ItemId that points to the wrong ItemKind"
-                    ))
-            }
-
-            $( #[$unchecked_attr] )*
-            pub fn $unchecked(&self) -> $name {
-                $name(*self)
-            }
-        }
-    }
-}
-
-item_id_newtype! {
-    /// An identifier for an `Item` whose `ItemKind` is known to be
-    /// `ItemKind::Type`.
-    pub struct TypeId(ItemId)
-    where
-        /// Convert this `ItemId` into a `TypeId` if its associated item is a type,
-        /// otherwise return `None`.
-        checked = as_type_id with is_type,
-
-        /// Convert this `ItemId` into a `TypeId`.
-        ///
-        /// If this `ItemId` does not point to a type, then panic.
-        expected = expect_type_id,
-
-        /// Convert this `ItemId` into a `TypeId` without actually checking whether
-        /// this id actually points to a `Type`.
-        unchecked = as_type_id_unchecked;
-}
-
-item_id_newtype! {
-    /// An identifier for an `Item` whose `ItemKind` is known to be
-    /// `ItemKind::Module`.
-    pub struct ModuleId(ItemId)
-    where
-        /// Convert this `ItemId` into a `ModuleId` if its associated item is a
-        /// module, otherwise return `None`.
-        checked = as_module_id with is_module,
-
-        /// Convert this `ItemId` into a `ModuleId`.
-        ///
-        /// If this `ItemId` does not point to a module, then panic.
-        expected = expect_module_id,
-
-        /// Convert this `ItemId` into a `ModuleId` without actually checking
-        /// whether this id actually points to a `Module`.
-        unchecked = as_module_id_unchecked;
-}
-
-item_id_newtype! {
-    /// An identifier for an `Item` whose `ItemKind` is known to be
-    /// `ItemKind::Var`.
-    pub struct VarId(ItemId)
-    where
-        /// Convert this `ItemId` into a `VarId` if its associated item is a var,
-        /// otherwise return `None`.
-        checked = as_var_id with is_var,
-
-        /// Convert this `ItemId` into a `VarId`.
-        ///
-        /// If this `ItemId` does not point to a var, then panic.
-        expected = expect_var_id,
-
-        /// Convert this `ItemId` into a `VarId` without actually checking whether
-        /// this id actually points to a `Var`.
-        unchecked = as_var_id_unchecked;
-}
-
-item_id_newtype! {
-    /// An identifier for an `Item` whose `ItemKind` is known to be
-    /// `ItemKind::Function`.
-    pub struct FunctionId(ItemId)
-    where
-        /// Convert this `ItemId` into a `FunctionId` if its associated item is a function,
-        /// otherwise return `None`.
-        checked = as_function_id with is_function,
-
-        /// Convert this `ItemId` into a `FunctionId`.
-        ///
-        /// If this `ItemId` does not point to a function, then panic.
-        expected = expect_function_id,
-
-        /// Convert this `ItemId` into a `FunctionId` without actually checking whether
-        /// this id actually points to a `Function`.
-        unchecked = as_function_id_unchecked;
-}
-
-impl From<ItemId> for usize {
-    fn from(id: ItemId) -> usize {
-        id.0
-    }
-}
-
-impl ItemId {
-    /// Get a numeric representation of this id.
-    pub fn as_usize(&self) -> usize {
-        (*self).into()
-    }
-}
-
-impl<T> ::std::cmp::PartialEq<T> for ItemId
-where
-    T: Copy + Into<ItemId>,
-{
-    fn eq(&self, rhs: &T) -> bool {
-        let rhs: ItemId = (*rhs).into();
-        self.0 == rhs.0
-    }
-}
-
-impl<T> CanDeriveDebug for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_debug && ctx.lookup_can_derive_debug(*self)
-    }
-}
-
-impl<T> CanDeriveDefault for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_default(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_default && ctx.lookup_can_derive_default(*self)
-    }
-}
-
-impl<T> CanDeriveCopy for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_copy && ctx.lookup_can_derive_copy(*self)
-    }
-}
-
-impl<T> CanDeriveHash for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_hash && ctx.lookup_can_derive_hash(*self)
-    }
-}
-
-impl<T> CanDerivePartialOrd for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_partialord &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes
-    }
-}
-
-impl<T> CanDerivePartialEq for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_partialeq &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes
-    }
-}
-
-impl<T> CanDeriveEq for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_eq &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes &&
-            !ctx.lookup_has_float(*self)
-    }
-}
-
-impl<T> CanDeriveOrd for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_ord &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes &&
-            !ctx.lookup_has_float(*self)
-    }
-}
-
-/// A key used to index a resolved type, so we only process it once.
-///
-/// This is almost always a USR string (an unique identifier generated by
-/// clang), but it can also be the canonical declaration if the type is unnamed,
-/// in which case clang may generate the same USR for multiple nested unnamed
-/// types.
-#[derive(Eq, PartialEq, Hash, Debug)]
-enum TypeKey {
-    Usr(String),
-    Declaration(Cursor),
-}
-
-/// A context used during parsing and generation of structs.
-#[derive(Debug)]
-pub struct BindgenContext {
-    /// The map of all the items parsed so far, keyed off ItemId.
-    items: Vec<Option<Item>>,
-
-    /// Clang USR to type map. This is needed to be able to associate types with
-    /// item ids during parsing.
-    types: HashMap<TypeKey, TypeId>,
-
-    /// Maps from a cursor to the item id of the named template type parameter
-    /// for that cursor.
-    type_params: HashMap<clang::Cursor, TypeId>,
-
-    /// A cursor to module map. Similar reason than above.
-    modules: HashMap<Cursor, ModuleId>,
-
-    /// The root module, this is guaranteed to be an item of kind Module.
-    root_module: ModuleId,
-
-    /// Current module being traversed.
-    current_module: ModuleId,
-
-    /// A HashMap keyed on a type definition, and whose value is the parent id
-    /// of the declaration.
-    ///
-    /// This is used to handle the cases where the semantic and the lexical
-    /// parents of the cursor differ, like when a nested class is defined
-    /// outside of the parent class.
-    semantic_parents: HashMap<clang::Cursor, ItemId>,
-
-    /// A stack with the current type declarations and types we're parsing. This
-    /// is needed to avoid infinite recursion when parsing a type like:
-    ///
-    /// struct c { struct c* next; };
-    ///
-    /// This means effectively, that a type has a potential ID before knowing if
-    /// it's a correct type. But that's not important in practice.
-    ///
-    /// We could also use the `types` HashMap, but my intention with it is that
-    /// only valid types and declarations end up there, and this could
-    /// potentially break that assumption.
-    currently_parsed_types: Vec<PartialType>,
-
-    /// A map with all the already parsed macro names. This is done to avoid
-    /// hard errors while parsing duplicated macros, as well to allow macro
-    /// expression parsing.
-    ///
-    /// This needs to be an std::HashMap because the cexpr API requires it.
-    parsed_macros: StdHashMap<Vec<u8>, cexpr::expr::EvalResult>,
-
-    /// A set of all the included filenames.
-    deps: BTreeSet<String>,
-
-    /// The active replacements collected from replaces="xxx" annotations.
-    replacements: HashMap<Vec<String>, ItemId>,
-
-    collected_typerefs: bool,
-
-    in_codegen: bool,
-
-    /// The translation unit for parsing.
-    translation_unit: clang::TranslationUnit,
-
-    /// Target information that can be useful for some stuff.
-    target_info: clang::TargetInfo,
-
-    /// The options given by the user via cli or other medium.
-    options: BindgenOptions,
-
-    /// Whether a bindgen complex was generated
-    generated_bindgen_complex: Cell<bool>,
-
-    /// The set of `ItemId`s that are allowlisted. This the very first thing
-    /// computed after parsing our IR, and before running any of our analyses.
-    allowlisted: Option<ItemSet>,
-
-    /// Cache for calls to `ParseCallbacks::blocklisted_type_implements_trait`
-    blocklisted_types_implement_traits:
-        RefCell<HashMap<DeriveTrait, HashMap<ItemId, CanDerive>>>,
-
-    /// The set of `ItemId`s that are allowlisted for code generation _and_ that
-    /// we should generate accounting for the codegen options.
-    ///
-    /// It's computed right after computing the allowlisted items.
-    codegen_items: Option<ItemSet>,
-
-    /// Map from an item's id to the set of template parameter items that it
-    /// uses. See `ir::named` for more details. Always `Some` during the codegen
-    /// phase.
-    used_template_parameters: Option<HashMap<ItemId, ItemSet>>,
-
-    /// The set of `TypeKind::Comp` items found during parsing that need their
-    /// bitfield allocation units computed. Drained in `compute_bitfield_units`.
-    need_bitfield_allocation: Vec<ItemId>,
-
-    /// The set of (`ItemId`s of) types that can't derive debug.
-    ///
-    /// This is populated when we enter codegen by `compute_cannot_derive_debug`
-    /// and is always `None` before that and `Some` after.
-    cannot_derive_debug: Option<HashSet<ItemId>>,
-
-    /// The set of (`ItemId`s of) types that can't derive default.
-    ///
-    /// This is populated when we enter codegen by `compute_cannot_derive_default`
-    /// and is always `None` before that and `Some` after.
-    cannot_derive_default: Option<HashSet<ItemId>>,
-
-    /// The set of (`ItemId`s of) types that can't derive copy.
-    ///
-    /// This is populated when we enter codegen by `compute_cannot_derive_copy`
-    /// and is always `None` before that and `Some` after.
-    cannot_derive_copy: Option<HashSet<ItemId>>,
-
-    /// The set of (`ItemId`s of) types that can't derive hash.
-    ///
-    /// This is populated when we enter codegen by `compute_can_derive_hash`
-    /// and is always `None` before that and `Some` after.
-    cannot_derive_hash: Option<HashSet<ItemId>>,
-
-    /// The map why specified `ItemId`s of) types that can't derive hash.
-    ///
-    /// This is populated when we enter codegen by
-    /// `compute_cannot_derive_partialord_partialeq_or_eq` and is always `None`
-    /// before that and `Some` after.
-    cannot_derive_partialeq_or_partialord: Option<HashMap<ItemId, CanDerive>>,
-
-    /// The sizedness of types.
-    ///
-    /// This is populated by `compute_sizedness` and is always `None` before
-    /// that function is invoked and `Some` afterwards.
-    sizedness: Option<HashMap<TypeId, SizednessResult>>,
-
-    /// The set of (`ItemId's of`) types that has vtable.
-    ///
-    /// Populated when we enter codegen by `compute_has_vtable`; always `None`
-    /// before that and `Some` after.
-    have_vtable: Option<HashMap<ItemId, HasVtableResult>>,
-
-    /// The set of (`ItemId's of`) types that has destructor.
-    ///
-    /// Populated when we enter codegen by `compute_has_destructor`; always `None`
-    /// before that and `Some` after.
-    have_destructor: Option<HashSet<ItemId>>,
-
-    /// The set of (`ItemId's of`) types that has array.
-    ///
-    /// Populated when we enter codegen by `compute_has_type_param_in_array`; always `None`
-    /// before that and `Some` after.
-    has_type_param_in_array: Option<HashSet<ItemId>>,
-
-    /// The set of (`ItemId's of`) types that has float.
-    ///
-    /// Populated when we enter codegen by `compute_has_float`; always `None`
-    /// before that and `Some` after.
-    has_float: Option<HashSet<ItemId>>,
-
-    /// The set of warnings raised during binding generation.
-    warnings: Vec<String>,
-}
-
-/// A traversal of allowlisted items.
-struct AllowlistedItemsTraversal<'ctx> {
-    ctx: &'ctx BindgenContext,
-    traversal: ItemTraversal<'ctx, ItemSet, Vec<ItemId>>,
-}
-
-impl<'ctx> Iterator for AllowlistedItemsTraversal<'ctx> {
-    type Item = ItemId;
-
-    fn next(&mut self) -> Option<ItemId> {
-        loop {
-            let id = self.traversal.next()?;
-
-            if self.ctx.resolve_item(id).is_blocklisted(self.ctx) {
-                continue;
-            }
-
-            return Some(id);
-        }
-    }
-}
-
-impl<'ctx> AllowlistedItemsTraversal<'ctx> {
-    /// Construct a new allowlisted items traversal.
-    pub fn new<R>(
-        ctx: &'ctx BindgenContext,
-        roots: R,
-        predicate: for<'a> fn(&'a BindgenContext, Edge) -> bool,
-    ) -> Self
-    where
-        R: IntoIterator<Item = ItemId>,
-    {
-        AllowlistedItemsTraversal {
-            ctx,
-            traversal: ItemTraversal::new(ctx, roots, predicate),
-        }
-    }
-}
-
-impl BindgenContext {
-    /// Construct the context for the given `options`.
-    pub(crate) fn new(
-        options: BindgenOptions,
-        input_unsaved_files: &[clang::UnsavedFile],
-    ) -> Self {
-        // TODO(emilio): Use the CXTargetInfo here when available.
-        //
-        // see: https://reviews.llvm.org/D32389
-        let index = clang::Index::new(false, true);
-
-        let parse_options =
-            clang_sys::CXTranslationUnit_DetailedPreprocessingRecord;
-
-        let translation_unit = {
-            let _t =
-                Timer::new("translation_unit").with_output(options.time_phases);
-
-            clang::TranslationUnit::parse(
-                &index,
-                "",
-                &options.clang_args,
-                input_unsaved_files,
-                parse_options,
-            ).expect("libclang error; possible causes include:
-- Invalid flag syntax
-- Unrecognized flags
-- Invalid flag arguments
-- File I/O errors
-- Host vs. target architecture mismatch
-If you encounter an error missing from this list, please file an issue or a PR!")
-        };
-
-        let target_info = clang::TargetInfo::new(&translation_unit);
-        let root_module = Self::build_root_module(ItemId(0));
-        let root_module_id = root_module.id().as_module_id_unchecked();
-
-        // depfiles need to include the explicitly listed headers too
-        let mut deps = BTreeSet::default();
-        if let Some(filename) = &options.input_header {
-            deps.insert(filename.clone());
-        }
-        deps.extend(options.extra_input_headers.iter().cloned());
-
-        BindgenContext {
-            items: vec![Some(root_module)],
-            deps,
-            types: Default::default(),
-            type_params: Default::default(),
-            modules: Default::default(),
-            root_module: root_module_id,
-            current_module: root_module_id,
-            semantic_parents: Default::default(),
-            currently_parsed_types: vec![],
-            parsed_macros: Default::default(),
-            replacements: Default::default(),
-            collected_typerefs: false,
-            in_codegen: false,
-            translation_unit,
-            target_info,
-            options,
-            generated_bindgen_complex: Cell::new(false),
-            allowlisted: None,
-            blocklisted_types_implement_traits: Default::default(),
-            codegen_items: None,
-            used_template_parameters: None,
-            need_bitfield_allocation: Default::default(),
-            cannot_derive_debug: None,
-            cannot_derive_default: None,
-            cannot_derive_copy: None,
-            cannot_derive_hash: None,
-            cannot_derive_partialeq_or_partialord: None,
-            sizedness: None,
-            have_vtable: None,
-            have_destructor: None,
-            has_type_param_in_array: None,
-            has_float: None,
-            warnings: Vec::new(),
-        }
-    }
-
-    /// Returns `true` if the target architecture is wasm32
-    pub fn is_target_wasm32(&self) -> bool {
-        self.target_info.triple.starts_with("wasm32-")
-    }
-
-    /// Creates a timer for the current bindgen phase. If time_phases is `true`,
-    /// the timer will print to stderr when it is dropped, otherwise it will do
-    /// nothing.
-    pub fn timer<'a>(&self, name: &'a str) -> Timer<'a> {
-        Timer::new(name).with_output(self.options.time_phases)
-    }
-
-    /// Returns the pointer width to use for the target for the current
-    /// translation.
-    pub fn target_pointer_size(&self) -> usize {
-        self.target_info.pointer_width / 8
-    }
-
-    /// Get the stack of partially parsed types that we are in the middle of
-    /// parsing.
-    pub fn currently_parsed_types(&self) -> &[PartialType] {
-        &self.currently_parsed_types[..]
-    }
-
-    /// Begin parsing the given partial type, and push it onto the
-    /// `currently_parsed_types` stack so that we won't infinite recurse if we
-    /// run into a reference to it while parsing it.
-    pub fn begin_parsing(&mut self, partial_ty: PartialType) {
-        self.currently_parsed_types.push(partial_ty);
-    }
-
-    /// Finish parsing the current partial type, pop it off the
-    /// `currently_parsed_types` stack, and return it.
-    pub fn finish_parsing(&mut self) -> PartialType {
-        self.currently_parsed_types.pop().expect(
-            "should have been parsing a type, if we finished parsing a type",
-        )
-    }
-
-    /// Get the user-provided callbacks by reference, if any.
-    pub fn parse_callbacks(&self) -> Option<&dyn ParseCallbacks> {
-        self.options().parse_callbacks.as_deref()
-    }
-
-    /// Add another path to the set of included files.
-    pub fn include_file(&mut self, filename: String) {
-        if let Some(cbs) = self.parse_callbacks() {
-            cbs.include_file(&filename);
-        }
-        self.deps.insert(filename);
-    }
-
-    /// Get any included files.
-    pub fn deps(&self) -> &BTreeSet<String> {
-        &self.deps
-    }
-
-    /// Define a new item.
-    ///
-    /// This inserts it into the internal items set, and its type into the
-    /// internal types set.
-    pub fn add_item(
-        &mut self,
-        item: Item,
-        declaration: Option<Cursor>,
-        location: Option<Cursor>,
-    ) {
-        debug!(
-            "BindgenContext::add_item({:?}, declaration: {:?}, loc: {:?}",
-            item, declaration, location
-        );
-        debug_assert!(
-            declaration.is_some() ||
-                !item.kind().is_type() ||
-                item.kind().expect_type().is_builtin_or_type_param() ||
-                item.kind().expect_type().is_opaque(self, &item) ||
-                item.kind().expect_type().is_unresolved_ref(),
-            "Adding a type without declaration?"
-        );
-
-        let id = item.id();
-        let is_type = item.kind().is_type();
-        let is_unnamed = is_type && item.expect_type().name().is_none();
-        let is_template_instantiation =
-            is_type && item.expect_type().is_template_instantiation();
-
-        if item.id() != self.root_module {
-            self.add_item_to_module(&item);
-        }
-
-        if is_type && item.expect_type().is_comp() {
-            self.need_bitfield_allocation.push(id);
-        }
-
-        let old_item = mem::replace(&mut self.items[id.0], Some(item));
-        assert!(
-            old_item.is_none(),
-            "should not have already associated an item with the given id"
-        );
-
-        // Unnamed items can have an USR, but they can't be referenced from
-        // other sites explicitly and the USR can match if the unnamed items are
-        // nested, so don't bother tracking them.
-        if !is_type || is_template_instantiation {
-            return;
-        }
-        if let Some(mut declaration) = declaration {
-            if !declaration.is_valid() {
-                if let Some(location) = location {
-                    if location.is_template_like() {
-                        declaration = location;
-                    }
-                }
-            }
-            declaration = declaration.canonical();
-            if !declaration.is_valid() {
-                // This could happen, for example, with types like `int*` or
-                // similar.
-                //
-                // Fortunately, we don't care about those types being
-                // duplicated, so we can just ignore them.
-                debug!(
-                    "Invalid declaration {:?} found for type {:?}",
-                    declaration,
-                    self.resolve_item_fallible(id)
-                        .unwrap()
-                        .kind()
-                        .expect_type()
-                );
-                return;
-            }
-
-            let key = if is_unnamed {
-                TypeKey::Declaration(declaration)
-            } else if let Some(usr) = declaration.usr() {
-                TypeKey::Usr(usr)
-            } else {
-                warn!(
-                    "Valid declaration with no USR: {:?}, {:?}",
-                    declaration, location
-                );
-                TypeKey::Declaration(declaration)
-            };
-
-            let old = self.types.insert(key, id.as_type_id_unchecked());
-            debug_assert_eq!(old, None);
-        }
-    }
-
-    /// Ensure that every item (other than the root module) is in a module's
-    /// children list. This is to make sure that every allowlisted item get's
-    /// codegen'd, even if its parent is not allowlisted. See issue #769 for
-    /// details.
-    fn add_item_to_module(&mut self, item: &Item) {
-        assert!(item.id() != self.root_module);
-        assert!(self.resolve_item_fallible(item.id()).is_none());
-
-        if let Some(ref mut parent) = self.items[item.parent_id().0] {
-            if let Some(module) = parent.as_module_mut() {
-                debug!(
-                    "add_item_to_module: adding {:?} as child of parent module {:?}",
-                    item.id(),
-                    item.parent_id()
-                );
-
-                module.children_mut().insert(item.id());
-                return;
-            }
-        }
-
-        debug!(
-            "add_item_to_module: adding {:?} as child of current module {:?}",
-            item.id(),
-            self.current_module
-        );
-
-        self.items[(self.current_module.0).0]
-            .as_mut()
-            .expect("Should always have an item for self.current_module")
-            .as_module_mut()
-            .expect("self.current_module should always be a module")
-            .children_mut()
-            .insert(item.id());
-    }
-
-    /// Add a new named template type parameter to this context's item set.
-    pub fn add_type_param(&mut self, item: Item, definition: clang::Cursor) {
-        debug!(
-            "BindgenContext::add_type_param: item = {:?}; definition = {:?}",
-            item, definition
-        );
-
-        assert!(
-            item.expect_type().is_type_param(),
-            "Should directly be a named type, not a resolved reference or anything"
-        );
-        assert_eq!(
-            definition.kind(),
-            clang_sys::CXCursor_TemplateTypeParameter
-        );
-
-        self.add_item_to_module(&item);
-
-        let id = item.id();
-        let old_item = mem::replace(&mut self.items[id.0], Some(item));
-        assert!(
-            old_item.is_none(),
-            "should not have already associated an item with the given id"
-        );
-
-        let old_named_ty = self
-            .type_params
-            .insert(definition, id.as_type_id_unchecked());
-        assert!(
-            old_named_ty.is_none(),
-            "should not have already associated a named type with this id"
-        );
-    }
-
-    /// Get the named type defined at the given cursor location, if we've
-    /// already added one.
-    pub fn get_type_param(&self, definition: &clang::Cursor) -> Option<TypeId> {
-        assert_eq!(
-            definition.kind(),
-            clang_sys::CXCursor_TemplateTypeParameter
-        );
-        self.type_params.get(definition).cloned()
-    }
-
-    // TODO: Move all this syntax crap to other part of the code.
-
-    /// Mangles a name so it doesn't conflict with any keyword.
-    #[rustfmt::skip]
-    pub fn rust_mangle<'a>(&self, name: &'a str) -> Cow<'a, str> {
-        if name.contains('@') ||
-            name.contains('?') ||
-            name.contains('$') ||
-            matches!(
-                name,
-                "abstract" | "alignof" | "as" | "async" | "await" | "become" |
-                    "box" | "break" | "const" | "continue" | "crate" | "do" |
-                    "dyn" | "else" | "enum" | "extern" | "false" | "final" |
-                    "fn" | "for" | "if" | "impl" | "in" | "let" | "loop" |
-                    "macro" | "match" | "mod" | "move" | "mut" | "offsetof" |
-                    "override" | "priv" | "proc" | "pub" | "pure" | "ref" |
-                    "return" | "Self" | "self" | "sizeof" | "static" |
-                    "struct" | "super" | "trait" | "true" | "try" | "type" | "typeof" |
-                    "unsafe" | "unsized" | "use" | "virtual" | "where" |
-                    "while" | "yield" | "str" | "bool" | "f32" | "f64" |
-                    "usize" | "isize" | "u128" | "i128" | "u64" | "i64" |
-                    "u32" | "i32" | "u16" | "i16" | "u8" | "i8" | "_"
-            )
-        {
-            let mut s = name.to_owned();
-            s = s.replace('@', "_");
-            s = s.replace('?', "_");
-            s = s.replace('$', "_");
-            s.push('_');
-            return Cow::Owned(s);
-        }
-        Cow::Borrowed(name)
-    }
-
-    /// Returns a mangled name as a rust identifier.
-    pub fn rust_ident<S>(&self, name: S) -> Ident
-    where
-        S: AsRef<str>,
-    {
-        self.rust_ident_raw(self.rust_mangle(name.as_ref()))
-    }
-
-    /// Returns a mangled name as a rust identifier.
-    pub fn rust_ident_raw<T>(&self, name: T) -> Ident
-    where
-        T: AsRef<str>,
-    {
-        Ident::new(name.as_ref(), Span::call_site())
-    }
-
-    /// Iterate over all items that have been defined.
-    pub fn items(&self) -> impl Iterator<Item = (ItemId, &Item)> {
-        self.items.iter().enumerate().filter_map(|(index, item)| {
-            let item = item.as_ref()?;
-            Some((ItemId(index), item))
-        })
-    }
-
-    /// Have we collected all unresolved type references yet?
-    pub fn collected_typerefs(&self) -> bool {
-        self.collected_typerefs
-    }
-
-    /// Gather all the unresolved type references.
-    fn collect_typerefs(
-        &mut self,
-    ) -> Vec<(ItemId, clang::Type, clang::Cursor, Option<ItemId>)> {
-        debug_assert!(!self.collected_typerefs);
-        self.collected_typerefs = true;
-        let mut typerefs = vec![];
-
-        for (id, item) in self.items() {
-            let kind = item.kind();
-            let ty = match kind.as_type() {
-                Some(ty) => ty,
-                None => continue,
-            };
-
-            if let TypeKind::UnresolvedTypeRef(ref ty, loc, parent_id) =
-                *ty.kind()
-            {
-                typerefs.push((id, *ty, loc, parent_id));
-            };
-        }
-        typerefs
-    }
-
-    /// Collect all of our unresolved type references and resolve them.
-    fn resolve_typerefs(&mut self) {
-        let _t = self.timer("resolve_typerefs");
-
-        let typerefs = self.collect_typerefs();
-
-        for (id, ty, loc, parent_id) in typerefs {
-            let _resolved =
-                {
-                    let resolved = Item::from_ty(&ty, loc, parent_id, self)
-                    .unwrap_or_else(|_| {
-                        warn!("Could not resolve type reference, falling back \
-                               to opaque blob");
-                        Item::new_opaque_type(self.next_item_id(), &ty, self)
-                    });
-
-                    let item = self.items[id.0].as_mut().unwrap();
-                    *item.kind_mut().as_type_mut().unwrap().kind_mut() =
-                        TypeKind::ResolvedTypeRef(resolved);
-                    resolved
-                };
-
-            // Something in the STL is trolling me. I don't need this assertion
-            // right now, but worth investigating properly once this lands.
-            //
-            // debug_assert!(self.items.get(&resolved).is_some(), "How?");
-            //
-            // if let Some(parent_id) = parent_id {
-            //     assert_eq!(self.items[&resolved].parent_id(), parent_id);
-            // }
-        }
-    }
-
-    /// Temporarily loan `Item` with the given `ItemId`. This provides means to
-    /// mutably borrow `Item` while having a reference to `BindgenContext`.
-    ///
-    /// `Item` with the given `ItemId` is removed from the context, given
-    /// closure is executed and then `Item` is placed back.
-    ///
-    /// # Panics
-    ///
-    /// Panics if attempt to resolve given `ItemId` inside the given
-    /// closure is made.
-    fn with_loaned_item<F, T>(&mut self, id: ItemId, f: F) -> T
-    where
-        F: (FnOnce(&BindgenContext, &mut Item) -> T),
-    {
-        let mut item = self.items[id.0].take().unwrap();
-
-        let result = f(self, &mut item);
-
-        let existing = mem::replace(&mut self.items[id.0], Some(item));
-        assert!(existing.is_none());
-
-        result
-    }
-
-    /// Compute the bitfield allocation units for all `TypeKind::Comp` items we
-    /// parsed.
-    fn compute_bitfield_units(&mut self) {
-        let _t = self.timer("compute_bitfield_units");
-
-        assert!(self.collected_typerefs());
-
-        let need_bitfield_allocation =
-            mem::take(&mut self.need_bitfield_allocation);
-        for id in need_bitfield_allocation {
-            self.with_loaned_item(id, |ctx, item| {
-                let ty = item.kind_mut().as_type_mut().unwrap();
-                let layout = ty.layout(ctx);
-                ty.as_comp_mut()
-                    .unwrap()
-                    .compute_bitfield_units(ctx, layout.as_ref());
-            });
-        }
-    }
-
-    /// Assign a new generated name for each anonymous field.
-    fn deanonymize_fields(&mut self) {
-        let _t = self.timer("deanonymize_fields");
-
-        let comp_item_ids: Vec<ItemId> = self
-            .items()
-            .filter_map(|(id, item)| {
-                if item.kind().as_type()?.is_comp() {
-                    return Some(id);
-                }
-                None
-            })
-            .collect();
-
-        for id in comp_item_ids {
-            self.with_loaned_item(id, |ctx, item| {
-                item.kind_mut()
-                    .as_type_mut()
-                    .unwrap()
-                    .as_comp_mut()
-                    .unwrap()
-                    .deanonymize_fields(ctx);
-            });
-        }
-    }
-
-    /// Iterate over all items and replace any item that has been named in a
-    /// `replaces="SomeType"` annotation with the replacement type.
-    fn process_replacements(&mut self) {
-        let _t = self.timer("process_replacements");
-        if self.replacements.is_empty() {
-            debug!("No replacements to process");
-            return;
-        }
-
-        // FIXME: This is linear, but the replaces="xxx" annotation was already
-        // there, and for better or worse it's useful, sigh...
-        //
-        // We leverage the ResolvedTypeRef thing, though, which is cool :P.
-
-        let mut replacements = vec![];
-
-        for (id, item) in self.items() {
-            if item.annotations().use_instead_of().is_some() {
-                continue;
-            }
-
-            // Calls to `canonical_name` are expensive, so eagerly filter out
-            // items that cannot be replaced.
-            let ty = match item.kind().as_type() {
-                Some(ty) => ty,
-                None => continue,
-            };
-
-            match *ty.kind() {
-                TypeKind::Comp(..) |
-                TypeKind::TemplateAlias(..) |
-                TypeKind::Enum(..) |
-                TypeKind::Alias(..) => {}
-                _ => continue,
-            }
-
-            let path = item.path_for_allowlisting(self);
-            let replacement = self.replacements.get(&path[1..]);
-
-            if let Some(replacement) = replacement {
-                if *replacement != id {
-                    // We set this just after parsing the annotation. It's
-                    // very unlikely, but this can happen.
-                    if self.resolve_item_fallible(*replacement).is_some() {
-                        replacements.push((
-                            id.expect_type_id(self),
-                            replacement.expect_type_id(self),
-                        ));
-                    }
-                }
-            }
-        }
-
-        for (id, replacement_id) in replacements {
-            debug!("Replacing {:?} with {:?}", id, replacement_id);
-            let new_parent = {
-                let item_id: ItemId = id.into();
-                let item = self.items[item_id.0].as_mut().unwrap();
-                *item.kind_mut().as_type_mut().unwrap().kind_mut() =
-                    TypeKind::ResolvedTypeRef(replacement_id);
-                item.parent_id()
-            };
-
-            // Relocate the replacement item from where it was declared, to
-            // where the thing it is replacing was declared.
-            //
-            // First, we'll make sure that its parent id is correct.
-
-            let old_parent = self.resolve_item(replacement_id).parent_id();
-            if new_parent == old_parent {
-                // Same parent and therefore also same containing
-                // module. Nothing to do here.
-                continue;
-            }
-
-            let replacement_item_id: ItemId = replacement_id.into();
-            self.items[replacement_item_id.0]
-                .as_mut()
-                .unwrap()
-                .set_parent_for_replacement(new_parent);
-
-            // Second, make sure that it is in the correct module's children
-            // set.
-
-            let old_module = {
-                let immut_self = &*self;
-                old_parent
-                    .ancestors(immut_self)
-                    .chain(Some(immut_self.root_module.into()))
-                    .find(|id| {
-                        let item = immut_self.resolve_item(*id);
-                        item.as_module().map_or(false, |m| {
-                            m.children().contains(&replacement_id.into())
-                        })
-                    })
-            };
-            let old_module = old_module
-                .expect("Every replacement item should be in a module");
-
-            let new_module = {
-                let immut_self = &*self;
-                new_parent
-                    .ancestors(immut_self)
-                    .find(|id| immut_self.resolve_item(*id).is_module())
-            };
-            let new_module =
-                new_module.unwrap_or_else(|| self.root_module.into());
-
-            if new_module == old_module {
-                // Already in the correct module.
-                continue;
-            }
-
-            self.items[old_module.0]
-                .as_mut()
-                .unwrap()
-                .as_module_mut()
-                .unwrap()
-                .children_mut()
-                .remove(&replacement_id.into());
-
-            self.items[new_module.0]
-                .as_mut()
-                .unwrap()
-                .as_module_mut()
-                .unwrap()
-                .children_mut()
-                .insert(replacement_id.into());
-        }
-    }
-
-    /// Enter the code generation phase, invoke the given callback `cb`, and
-    /// leave the code generation phase.
-    pub(crate) fn gen<F, Out>(
-        mut self,
-        cb: F,
-    ) -> (Out, BindgenOptions, Vec<String>)
-    where
-        F: FnOnce(&Self) -> Out,
-    {
-        self.in_codegen = true;
-
-        self.resolve_typerefs();
-        self.compute_bitfield_units();
-        self.process_replacements();
-
-        self.deanonymize_fields();
-
-        self.assert_no_dangling_references();
-
-        // Compute the allowlisted set after processing replacements and
-        // resolving type refs, as those are the final mutations of the IR
-        // graph, and their completion means that the IR graph is now frozen.
-        self.compute_allowlisted_and_codegen_items();
-
-        // Make sure to do this after processing replacements, since that messes
-        // with the parentage and module children, and we want to assert that it
-        // messes with them correctly.
-        self.assert_every_item_in_a_module();
-
-        self.compute_has_vtable();
-        self.compute_sizedness();
-        self.compute_has_destructor();
-        self.find_used_template_parameters();
-        self.compute_cannot_derive_debug();
-        self.compute_cannot_derive_default();
-        self.compute_cannot_derive_copy();
-        self.compute_has_type_param_in_array();
-        self.compute_has_float();
-        self.compute_cannot_derive_hash();
-        self.compute_cannot_derive_partialord_partialeq_or_eq();
-
-        let ret = cb(&self);
-        (ret, self.options, self.warnings)
-    }
-
-    /// When the `testing_only_extra_assertions` feature is enabled, this
-    /// function walks the IR graph and asserts that we do not have any edges
-    /// referencing an ItemId for which we do not have an associated IR item.
-    fn assert_no_dangling_references(&self) {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            for _ in self.assert_no_dangling_item_traversal() {
-                // The iterator's next method does the asserting for us.
-            }
-        }
-    }
-
-    fn assert_no_dangling_item_traversal(
-        &self,
-    ) -> traversal::AssertNoDanglingItemsTraversal {
-        assert!(self.in_codegen_phase());
-        assert!(self.current_module == self.root_module);
-
-        let roots = self.items().map(|(id, _)| id);
-        traversal::AssertNoDanglingItemsTraversal::new(
-            self,
-            roots,
-            traversal::all_edges,
-        )
-    }
-
-    /// When the `testing_only_extra_assertions` feature is enabled, walk over
-    /// every item and ensure that it is in the children set of one of its
-    /// module ancestors.
-    fn assert_every_item_in_a_module(&self) {
-        if cfg!(feature = "testing_only_extra_assertions") {
-            assert!(self.in_codegen_phase());
-            assert!(self.current_module == self.root_module);
-
-            for (id, _item) in self.items() {
-                if id == self.root_module {
-                    continue;
-                }
-
-                assert!(
-                    {
-                        let id = id
-                            .into_resolver()
-                            .through_type_refs()
-                            .through_type_aliases()
-                            .resolve(self)
-                            .id();
-                        id.ancestors(self)
-                            .chain(Some(self.root_module.into()))
-                            .any(|ancestor| {
-                                debug!(
-                                    "Checking if {:?} is a child of {:?}",
-                                    id, ancestor
-                                );
-                                self.resolve_item(ancestor)
-                                    .as_module()
-                                    .map_or(false, |m| {
-                                        m.children().contains(&id)
-                                    })
-                            })
-                    },
-                    "{:?} should be in some ancestor module's children set",
-                    id
-                );
-            }
-        }
-    }
-
-    /// Compute for every type whether it is sized or not, and whether it is
-    /// sized or not as a base class.
-    fn compute_sizedness(&mut self) {
-        let _t = self.timer("compute_sizedness");
-        assert!(self.sizedness.is_none());
-        self.sizedness = Some(analyze::<SizednessAnalysis>(self));
-    }
-
-    /// Look up whether the type with the given id is sized or not.
-    pub fn lookup_sizedness(&self, id: TypeId) -> SizednessResult {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute sizedness after we've entered codegen"
-        );
-
-        self.sizedness
-            .as_ref()
-            .unwrap()
-            .get(&id)
-            .cloned()
-            .unwrap_or(SizednessResult::ZeroSized)
-    }
-
-    /// Compute whether the type has vtable.
-    fn compute_has_vtable(&mut self) {
-        let _t = self.timer("compute_has_vtable");
-        assert!(self.have_vtable.is_none());
-        self.have_vtable = Some(analyze::<HasVtableAnalysis>(self));
-    }
-
-    /// Look up whether the item with `id` has vtable or not.
-    pub fn lookup_has_vtable(&self, id: TypeId) -> HasVtableResult {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute vtables when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` has a
-        // vtable or not.
-        self.have_vtable
-            .as_ref()
-            .unwrap()
-            .get(&id.into())
-            .cloned()
-            .unwrap_or(HasVtableResult::No)
-    }
-
-    /// Compute whether the type has a destructor.
-    fn compute_has_destructor(&mut self) {
-        let _t = self.timer("compute_has_destructor");
-        assert!(self.have_destructor.is_none());
-        self.have_destructor = Some(analyze::<HasDestructorAnalysis>(self));
-    }
-
-    /// Look up whether the item with `id` has a destructor.
-    pub fn lookup_has_destructor(&self, id: TypeId) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute destructors when we enter codegen"
-        );
-
-        self.have_destructor.as_ref().unwrap().contains(&id.into())
-    }
-
-    fn find_used_template_parameters(&mut self) {
-        let _t = self.timer("find_used_template_parameters");
-        if self.options.allowlist_recursively {
-            let used_params = analyze::<UsedTemplateParameters>(self);
-            self.used_template_parameters = Some(used_params);
-        } else {
-            // If you aren't recursively allowlisting, then we can't really make
-            // any sense of template parameter usage, and you're on your own.
-            let mut used_params = HashMap::default();
-            for &id in self.allowlisted_items() {
-                used_params.entry(id).or_insert_with(|| {
-                    id.self_template_params(self)
-                        .into_iter()
-                        .map(|p| p.into())
-                        .collect()
-                });
-            }
-            self.used_template_parameters = Some(used_params);
-        }
-    }
-
-    /// Return `true` if `item` uses the given `template_param`, `false`
-    /// otherwise.
-    ///
-    /// This method may only be called during the codegen phase, because the
-    /// template usage information is only computed as we enter the codegen
-    /// phase.
-    ///
-    /// If the item is blocklisted, then we say that it always uses the template
-    /// parameter. This is a little subtle. The template parameter usage
-    /// analysis only considers allowlisted items, and if any blocklisted item
-    /// shows up in the generated bindings, it is the user's responsibility to
-    /// manually provide a definition for them. To give them the most
-    /// flexibility when doing that, we assume that they use every template
-    /// parameter and always pass template arguments through in instantiations.
-    pub fn uses_template_parameter(
-        &self,
-        item: ItemId,
-        template_param: TypeId,
-    ) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute template parameter usage as we enter codegen"
-        );
-
-        if self.resolve_item(item).is_blocklisted(self) {
-            return true;
-        }
-
-        let template_param = template_param
-            .into_resolver()
-            .through_type_refs()
-            .through_type_aliases()
-            .resolve(self)
-            .id();
-
-        self.used_template_parameters
-            .as_ref()
-            .expect("should have found template parameter usage if we're in codegen")
-            .get(&item)
-            .map_or(false, |items_used_params| items_used_params.contains(&template_param))
-    }
-
-    /// Return `true` if `item` uses any unbound, generic template parameters,
-    /// `false` otherwise.
-    ///
-    /// Has the same restrictions that `uses_template_parameter` has.
-    pub fn uses_any_template_parameters(&self, item: ItemId) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute template parameter usage as we enter codegen"
-        );
-
-        self.used_template_parameters
-            .as_ref()
-            .expect(
-                "should have template parameter usage info in codegen phase",
-            )
-            .get(&item)
-            .map_or(false, |used| !used.is_empty())
-    }
-
-    // This deserves a comment. Builtin types don't get a valid declaration, so
-    // we can't add it to the cursor->type map.
-    //
-    // That being said, they're not generated anyway, and are few, so the
-    // duplication and special-casing is fine.
-    //
-    // If at some point we care about the memory here, probably a map TypeKind
-    // -> builtin type ItemId would be the best to improve that.
-    fn add_builtin_item(&mut self, item: Item) {
-        debug!("add_builtin_item: item = {:?}", item);
-        debug_assert!(item.kind().is_type());
-        self.add_item_to_module(&item);
-        let id = item.id();
-        let old_item = mem::replace(&mut self.items[id.0], Some(item));
-        assert!(old_item.is_none(), "Inserted type twice?");
-    }
-
-    fn build_root_module(id: ItemId) -> Item {
-        let module = Module::new(Some("root".into()), ModuleKind::Normal);
-        Item::new(id, None, None, id, ItemKind::Module(module), None)
-    }
-
-    /// Get the root module.
-    pub fn root_module(&self) -> ModuleId {
-        self.root_module
-    }
-
-    /// Resolve a type with the given id.
-    ///
-    /// Panics if there is no item for the given `TypeId` or if the resolved
-    /// item is not a `Type`.
-    pub fn resolve_type(&self, type_id: TypeId) -> &Type {
-        self.resolve_item(type_id).kind().expect_type()
-    }
-
-    /// Resolve a function with the given id.
-    ///
-    /// Panics if there is no item for the given `FunctionId` or if the resolved
-    /// item is not a `Function`.
-    pub fn resolve_func(&self, func_id: FunctionId) -> &Function {
-        self.resolve_item(func_id).kind().expect_function()
-    }
-
-    /// Resolve the given `ItemId` as a type, or `None` if there is no item with
-    /// the given id.
-    ///
-    /// Panics if the id resolves to an item that is not a type.
-    pub fn safe_resolve_type(&self, type_id: TypeId) -> Option<&Type> {
-        self.resolve_item_fallible(type_id)
-            .map(|t| t.kind().expect_type())
-    }
-
-    /// Resolve the given `ItemId` into an `Item`, or `None` if no such item
-    /// exists.
-    pub fn resolve_item_fallible<Id: Into<ItemId>>(
-        &self,
-        id: Id,
-    ) -> Option<&Item> {
-        self.items.get(id.into().0)?.as_ref()
-    }
-
-    /// Resolve the given `ItemId` into an `Item`.
-    ///
-    /// Panics if the given id does not resolve to any item.
-    pub fn resolve_item<Id: Into<ItemId>>(&self, item_id: Id) -> &Item {
-        let item_id = item_id.into();
-        match self.resolve_item_fallible(item_id) {
-            Some(item) => item,
-            None => panic!("Not an item: {:?}", item_id),
-        }
-    }
-
-    /// Get the current module.
-    pub fn current_module(&self) -> ModuleId {
-        self.current_module
-    }
-
-    /// Add a semantic parent for a given type definition.
-    ///
-    /// We do this from the type declaration, in order to be able to find the
-    /// correct type definition afterwards.
-    ///
-    /// TODO(emilio): We could consider doing this only when
-    /// declaration.lexical_parent() != definition.lexical_parent(), but it's
-    /// not sure it's worth it.
-    pub fn add_semantic_parent(
-        &mut self,
-        definition: clang::Cursor,
-        parent_id: ItemId,
-    ) {
-        self.semantic_parents.insert(definition, parent_id);
-    }
-
-    /// Returns a known semantic parent for a given definition.
-    pub fn known_semantic_parent(
-        &self,
-        definition: clang::Cursor,
-    ) -> Option<ItemId> {
-        self.semantic_parents.get(&definition).cloned()
-    }
-
-    /// Given a cursor pointing to the location of a template instantiation,
-    /// return a tuple of the form `(declaration_cursor, declaration_id,
-    /// num_expected_template_args)`.
-    ///
-    /// Note that `declaration_id` is not guaranteed to be in the context's item
-    /// set! It is possible that it is a partial type that we are still in the
-    /// middle of parsing.
-    fn get_declaration_info_for_template_instantiation(
-        &self,
-        instantiation: &Cursor,
-    ) -> Option<(Cursor, ItemId, usize)> {
-        instantiation
-            .cur_type()
-            .canonical_declaration(Some(instantiation))
-            .and_then(|canon_decl| {
-                self.get_resolved_type(&canon_decl).and_then(
-                    |template_decl_id| {
-                        let num_params =
-                            template_decl_id.num_self_template_params(self);
-                        if num_params == 0 {
-                            None
-                        } else {
-                            Some((
-                                *canon_decl.cursor(),
-                                template_decl_id.into(),
-                                num_params,
-                            ))
-                        }
-                    },
-                )
-            })
-            .or_else(|| {
-                // If we haven't already parsed the declaration of
-                // the template being instantiated, then it *must*
-                // be on the stack of types we are currently
-                // parsing. If it wasn't then clang would have
-                // already errored out before we started
-                // constructing our IR because you can't instantiate
-                // a template until it is fully defined.
-                instantiation
-                    .referenced()
-                    .and_then(|referenced| {
-                        self.currently_parsed_types()
-                            .iter()
-                            .find(|partial_ty| *partial_ty.decl() == referenced)
-                            .cloned()
-                    })
-                    .and_then(|template_decl| {
-                        let num_template_params =
-                            template_decl.num_self_template_params(self);
-                        if num_template_params == 0 {
-                            None
-                        } else {
-                            Some((
-                                *template_decl.decl(),
-                                template_decl.id(),
-                                num_template_params,
-                            ))
-                        }
-                    })
-            })
-    }
-
-    /// Parse a template instantiation, eg `Foo<int>`.
-    ///
-    /// This is surprisingly difficult to do with libclang, due to the fact that
-    /// it doesn't provide explicit template argument information, except for
-    /// function template declarations(!?!??!).
-    ///
-    /// The only way to do this is manually inspecting the AST and looking for
-    /// TypeRefs and TemplateRefs inside. This, unfortunately, doesn't work for
-    /// more complex cases, see the comment on the assertion below.
-    ///
-    /// To add insult to injury, the AST itself has structure that doesn't make
-    /// sense. Sometimes `Foo<Bar<int>>` has an AST with nesting like you might
-    /// expect: `(Foo (Bar (int)))`. Other times, the AST we get is completely
-    /// flat: `(Foo Bar int)`.
-    ///
-    /// To see an example of what this method handles:
-    ///
-    /// ```c++
-    /// template<typename T>
-    /// class Incomplete {
-    ///   T p;
-    /// };
-    ///
-    /// template<typename U>
-    /// class Foo {
-    ///   Incomplete<U> bar;
-    /// };
-    /// ```
-    ///
-    /// Finally, template instantiations are always children of the current
-    /// module. They use their template's definition for their name, so the
-    /// parent is only useful for ensuring that their layout tests get
-    /// codegen'd.
-    fn instantiate_template(
-        &mut self,
-        with_id: ItemId,
-        template: TypeId,
-        ty: &clang::Type,
-        location: clang::Cursor,
-    ) -> Option<TypeId> {
-        let num_expected_args =
-            self.resolve_type(template).num_self_template_params(self);
-        if num_expected_args == 0 {
-            warn!(
-                "Tried to instantiate a template for which we could not \
-                 determine any template parameters"
-            );
-            return None;
-        }
-
-        let mut args = vec![];
-        let mut found_const_arg = false;
-        let mut children = location.collect_children();
-
-        if children.iter().all(|c| !c.has_children()) {
-            // This is insanity... If clang isn't giving us a properly nested
-            // AST for which template arguments belong to which template we are
-            // instantiating, we'll need to construct it ourselves. However,
-            // there is an extra `NamespaceRef, NamespaceRef, ..., TemplateRef`
-            // representing a reference to the outermost template declaration
-            // that we need to filter out of the children. We need to do this
-            // filtering because we already know which template declaration is
-            // being specialized via the `location`'s type, and if we do not
-            // filter it out, we'll add an extra layer of template instantiation
-            // on accident.
-            let idx = children
-                .iter()
-                .position(|c| c.kind() == clang_sys::CXCursor_TemplateRef);
-            if let Some(idx) = idx {
-                if children
-                    .iter()
-                    .take(idx)
-                    .all(|c| c.kind() == clang_sys::CXCursor_NamespaceRef)
-                {
-                    children = children.into_iter().skip(idx + 1).collect();
-                }
-            }
-        }
-
-        for child in children.iter().rev() {
-            match child.kind() {
-                clang_sys::CXCursor_TypeRef |
-                clang_sys::CXCursor_TypedefDecl |
-                clang_sys::CXCursor_TypeAliasDecl => {
-                    // The `with_id` id will potentially end up unused if we give up
-                    // on this type (for example, because it has const value
-                    // template args), so if we pass `with_id` as the parent, it is
-                    // potentially a dangling reference. Instead, use the canonical
-                    // template declaration as the parent. It is already parsed and
-                    // has a known-resolvable `ItemId`.
-                    let ty = Item::from_ty_or_ref(
-                        child.cur_type(),
-                        *child,
-                        Some(template.into()),
-                        self,
-                    );
-                    args.push(ty);
-                }
-                clang_sys::CXCursor_TemplateRef => {
-                    let (
-                        template_decl_cursor,
-                        template_decl_id,
-                        num_expected_template_args,
-                    ) = self.get_declaration_info_for_template_instantiation(
-                        child,
-                    )?;
-
-                    if num_expected_template_args == 0 ||
-                        child.has_at_least_num_children(
-                            num_expected_template_args,
-                        )
-                    {
-                        // Do a happy little parse. See comment in the TypeRef
-                        // match arm about parent IDs.
-                        let ty = Item::from_ty_or_ref(
-                            child.cur_type(),
-                            *child,
-                            Some(template.into()),
-                            self,
-                        );
-                        args.push(ty);
-                    } else {
-                        // This is the case mentioned in the doc comment where
-                        // clang gives us a flattened AST and we have to
-                        // reconstruct which template arguments go to which
-                        // instantiation :(
-                        let args_len = args.len();
-                        if args_len < num_expected_template_args {
-                            warn!(
-                                "Found a template instantiation without \
-                                 enough template arguments"
-                            );
-                            return None;
-                        }
-
-                        let mut sub_args: Vec<_> = args
-                            .drain(args_len - num_expected_template_args..)
-                            .collect();
-                        sub_args.reverse();
-
-                        let sub_name = Some(template_decl_cursor.spelling());
-                        let sub_inst = TemplateInstantiation::new(
-                            // This isn't guaranteed to be a type that we've
-                            // already finished parsing yet.
-                            template_decl_id.as_type_id_unchecked(),
-                            sub_args,
-                        );
-                        let sub_kind =
-                            TypeKind::TemplateInstantiation(sub_inst);
-                        let sub_ty = Type::new(
-                            sub_name,
-                            template_decl_cursor
-                                .cur_type()
-                                .fallible_layout(self)
-                                .ok(),
-                            sub_kind,
-                            false,
-                        );
-                        let sub_id = self.next_item_id();
-                        let sub_item = Item::new(
-                            sub_id,
-                            None,
-                            None,
-                            self.current_module.into(),
-                            ItemKind::Type(sub_ty),
-                            Some(child.location()),
-                        );
-
-                        // Bypass all the validations in add_item explicitly.
-                        debug!(
-                            "instantiate_template: inserting nested \
-                             instantiation item: {:?}",
-                            sub_item
-                        );
-                        self.add_item_to_module(&sub_item);
-                        debug_assert_eq!(sub_id, sub_item.id());
-                        self.items[sub_id.0] = Some(sub_item);
-                        args.push(sub_id.as_type_id_unchecked());
-                    }
-                }
-                _ => {
-                    warn!(
-                        "Found template arg cursor we can't handle: {:?}",
-                        child
-                    );
-                    found_const_arg = true;
-                }
-            }
-        }
-
-        if found_const_arg {
-            // This is a dependently typed template instantiation. That is, an
-            // instantiation of a template with one or more const values as
-            // template arguments, rather than only types as template
-            // arguments. For example, `Foo<true, 5>` versus `Bar<bool, int>`.
-            // We can't handle these instantiations, so just punt in this
-            // situation...
-            warn!(
-                "Found template instantiated with a const value; \
-                 bindgen can't handle this kind of template instantiation!"
-            );
-            return None;
-        }
-
-        if args.len() != num_expected_args {
-            warn!(
-                "Found a template with an unexpected number of template \
-                 arguments"
-            );
-            return None;
-        }
-
-        args.reverse();
-        let type_kind = TypeKind::TemplateInstantiation(
-            TemplateInstantiation::new(template, args),
-        );
-        let name = ty.spelling();
-        let name = if name.is_empty() { None } else { Some(name) };
-        let ty = Type::new(
-            name,
-            ty.fallible_layout(self).ok(),
-            type_kind,
-            ty.is_const(),
-        );
-        let item = Item::new(
-            with_id,
-            None,
-            None,
-            self.current_module.into(),
-            ItemKind::Type(ty),
-            Some(location.location()),
-        );
-
-        // Bypass all the validations in add_item explicitly.
-        debug!("instantiate_template: inserting item: {:?}", item);
-        self.add_item_to_module(&item);
-        debug_assert_eq!(with_id, item.id());
-        self.items[with_id.0] = Some(item);
-        Some(with_id.as_type_id_unchecked())
-    }
-
-    /// If we have already resolved the type for the given type declaration,
-    /// return its `ItemId`. Otherwise, return `None`.
-    pub fn get_resolved_type(
-        &self,
-        decl: &clang::CanonicalTypeDeclaration,
-    ) -> Option<TypeId> {
-        self.types
-            .get(&TypeKey::Declaration(*decl.cursor()))
-            .or_else(|| {
-                decl.cursor()
-                    .usr()
-                    .and_then(|usr| self.types.get(&TypeKey::Usr(usr)))
-            })
-            .cloned()
-    }
-
-    /// Looks up for an already resolved type, either because it's builtin, or
-    /// because we already have it in the map.
-    pub fn builtin_or_resolved_ty(
-        &mut self,
-        with_id: ItemId,
-        parent_id: Option<ItemId>,
-        ty: &clang::Type,
-        location: Option<clang::Cursor>,
-    ) -> Option<TypeId> {
-        use clang_sys::{CXCursor_TypeAliasTemplateDecl, CXCursor_TypeRef};
-        debug!(
-            "builtin_or_resolved_ty: {:?}, {:?}, {:?}, {:?}",
-            ty, location, with_id, parent_id
-        );
-
-        if let Some(decl) = ty.canonical_declaration(location.as_ref()) {
-            if let Some(id) = self.get_resolved_type(&decl) {
-                debug!(
-                    "Already resolved ty {:?}, {:?}, {:?} {:?}",
-                    id, decl, ty, location
-                );
-                // If the declaration already exists, then either:
-                //
-                //   * the declaration is a template declaration of some sort,
-                //     and we are looking at an instantiation or specialization
-                //     of it, or
-                //   * we have already parsed and resolved this type, and
-                //     there's nothing left to do.
-                if let Some(location) = location {
-                    if decl.cursor().is_template_like() &&
-                        *ty != decl.cursor().cur_type()
-                    {
-                        // For specialized type aliases, there's no way to get the
-                        // template parameters as of this writing (for a struct
-                        // specialization we wouldn't be in this branch anyway).
-                        //
-                        // Explicitly return `None` if there aren't any
-                        // unspecialized parameters (contains any `TypeRef`) so we
-                        // resolve the canonical type if there is one and it's
-                        // exposed.
-                        //
-                        // This is _tricky_, I know :(
-                        if decl.cursor().kind() ==
-                            CXCursor_TypeAliasTemplateDecl &&
-                            !location.contains_cursor(CXCursor_TypeRef) &&
-                            ty.canonical_type().is_valid_and_exposed()
-                        {
-                            return None;
-                        }
-
-                        return self
-                            .instantiate_template(with_id, id, ty, location)
-                            .or(Some(id));
-                    }
-                }
-
-                return Some(self.build_ty_wrapper(with_id, id, parent_id, ty));
-            }
-        }
-
-        debug!("Not resolved, maybe builtin?");
-        self.build_builtin_ty(ty)
-    }
-
-    /// Make a new item that is a resolved type reference to the `wrapped_id`.
-    ///
-    /// This is unfortunately a lot of bloat, but is needed to properly track
-    /// constness et al.
-    ///
-    /// We should probably make the constness tracking separate, so it doesn't
-    /// bloat that much, but hey, we already bloat the heck out of builtin
-    /// types.
-    pub fn build_ty_wrapper(
-        &mut self,
-        with_id: ItemId,
-        wrapped_id: TypeId,
-        parent_id: Option<ItemId>,
-        ty: &clang::Type,
-    ) -> TypeId {
-        self.build_wrapper(with_id, wrapped_id, parent_id, ty, ty.is_const())
-    }
-
-    /// A wrapper over a type that adds a const qualifier explicitly.
-    ///
-    /// Needed to handle const methods in C++, wrapping the type .
-    pub fn build_const_wrapper(
-        &mut self,
-        with_id: ItemId,
-        wrapped_id: TypeId,
-        parent_id: Option<ItemId>,
-        ty: &clang::Type,
-    ) -> TypeId {
-        self.build_wrapper(
-            with_id, wrapped_id, parent_id, ty, /* is_const = */ true,
-        )
-    }
-
-    fn build_wrapper(
-        &mut self,
-        with_id: ItemId,
-        wrapped_id: TypeId,
-        parent_id: Option<ItemId>,
-        ty: &clang::Type,
-        is_const: bool,
-    ) -> TypeId {
-        let spelling = ty.spelling();
-        let layout = ty.fallible_layout(self).ok();
-        let location = ty.declaration().location();
-        let type_kind = TypeKind::ResolvedTypeRef(wrapped_id);
-        let ty = Type::new(Some(spelling), layout, type_kind, is_const);
-        let item = Item::new(
-            with_id,
-            None,
-            None,
-            parent_id.unwrap_or_else(|| self.current_module.into()),
-            ItemKind::Type(ty),
-            Some(location),
-        );
-        self.add_builtin_item(item);
-        with_id.as_type_id_unchecked()
-    }
-
-    /// Returns the next item id to be used for an item.
-    pub fn next_item_id(&mut self) -> ItemId {
-        let ret = ItemId(self.items.len());
-        self.items.push(None);
-        ret
-    }
-
-    fn build_builtin_ty(&mut self, ty: &clang::Type) -> Option<TypeId> {
-        use clang_sys::*;
-        let type_kind = match ty.kind() {
-            CXType_NullPtr => TypeKind::NullPtr,
-            CXType_Void => TypeKind::Void,
-            CXType_Bool => TypeKind::Int(IntKind::Bool),
-            CXType_Int => TypeKind::Int(IntKind::Int),
-            CXType_UInt => TypeKind::Int(IntKind::UInt),
-            CXType_Char_S => TypeKind::Int(IntKind::Char { is_signed: true }),
-            CXType_Char_U => TypeKind::Int(IntKind::Char { is_signed: false }),
-            CXType_SChar => TypeKind::Int(IntKind::SChar),
-            CXType_UChar => TypeKind::Int(IntKind::UChar),
-            CXType_Short => TypeKind::Int(IntKind::Short),
-            CXType_UShort => TypeKind::Int(IntKind::UShort),
-            CXType_WChar => TypeKind::Int(IntKind::WChar),
-            CXType_Char16 => TypeKind::Int(IntKind::U16),
-            CXType_Char32 => TypeKind::Int(IntKind::U32),
-            CXType_Long => TypeKind::Int(IntKind::Long),
-            CXType_ULong => TypeKind::Int(IntKind::ULong),
-            CXType_LongLong => TypeKind::Int(IntKind::LongLong),
-            CXType_ULongLong => TypeKind::Int(IntKind::ULongLong),
-            CXType_Int128 => TypeKind::Int(IntKind::I128),
-            CXType_UInt128 => TypeKind::Int(IntKind::U128),
-            CXType_Float => TypeKind::Float(FloatKind::Float),
-            CXType_Double => TypeKind::Float(FloatKind::Double),
-            CXType_LongDouble => TypeKind::Float(FloatKind::LongDouble),
-            CXType_Float128 => TypeKind::Float(FloatKind::Float128),
-            CXType_Complex => {
-                let float_type =
-                    ty.elem_type().expect("Not able to resolve complex type?");
-                let float_kind = match float_type.kind() {
-                    CXType_Float => FloatKind::Float,
-                    CXType_Double => FloatKind::Double,
-                    CXType_LongDouble => FloatKind::LongDouble,
-                    CXType_Float128 => FloatKind::Float128,
-                    _ => panic!(
-                        "Non floating-type complex? {:?}, {:?}",
-                        ty, float_type,
-                    ),
-                };
-                TypeKind::Complex(float_kind)
-            }
-            _ => return None,
-        };
-
-        let spelling = ty.spelling();
-        let is_const = ty.is_const();
-        let layout = ty.fallible_layout(self).ok();
-        let location = ty.declaration().location();
-        let ty = Type::new(Some(spelling), layout, type_kind, is_const);
-        let id = self.next_item_id();
-        let item = Item::new(
-            id,
-            None,
-            None,
-            self.root_module.into(),
-            ItemKind::Type(ty),
-            Some(location),
-        );
-        self.add_builtin_item(item);
-        Some(id.as_type_id_unchecked())
-    }
-
-    /// Get the current Clang translation unit that is being processed.
-    pub fn translation_unit(&self) -> &clang::TranslationUnit {
-        &self.translation_unit
-    }
-
-    /// Have we parsed the macro named `macro_name` already?
-    pub fn parsed_macro(&self, macro_name: &[u8]) -> bool {
-        self.parsed_macros.contains_key(macro_name)
-    }
-
-    /// Get the currently parsed macros.
-    pub fn parsed_macros(
-        &self,
-    ) -> &StdHashMap<Vec<u8>, cexpr::expr::EvalResult> {
-        debug_assert!(!self.in_codegen_phase());
-        &self.parsed_macros
-    }
-
-    /// Mark the macro named `macro_name` as parsed.
-    pub fn note_parsed_macro(
-        &mut self,
-        id: Vec<u8>,
-        value: cexpr::expr::EvalResult,
-    ) {
-        self.parsed_macros.insert(id, value);
-    }
-
-    /// Are we in the codegen phase?
-    pub fn in_codegen_phase(&self) -> bool {
-        self.in_codegen
-    }
-
-    /// Mark the type with the given `name` as replaced by the type with id
-    /// `potential_ty`.
-    ///
-    /// Replacement types are declared using the `replaces="xxx"` annotation,
-    /// and implies that the original type is hidden.
-    pub fn replace(&mut self, name: &[String], potential_ty: ItemId) {
-        match self.replacements.entry(name.into()) {
-            Entry::Vacant(entry) => {
-                debug!(
-                    "Defining replacement for {:?} as {:?}",
-                    name, potential_ty
-                );
-                entry.insert(potential_ty);
-            }
-            Entry::Occupied(occupied) => {
-                warn!(
-                    "Replacement for {:?} already defined as {:?}; \
-                     ignoring duplicate replacement definition as {:?}",
-                    name,
-                    occupied.get(),
-                    potential_ty
-                );
-            }
-        }
-    }
-
-    /// Has the item with the given `name` and `id` been replaced by another
-    /// type?
-    pub fn is_replaced_type<Id: Into<ItemId>>(
-        &self,
-        path: &[String],
-        id: Id,
-    ) -> bool {
-        let id = id.into();
-        matches!(self.replacements.get(path), Some(replaced_by) if *replaced_by != id)
-    }
-
-    /// Is the type with the given `name` marked as opaque?
-    pub fn opaque_by_name(&self, path: &[String]) -> bool {
-        debug_assert!(
-            self.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        self.options.opaque_types.matches(&path[1..].join("::"))
-    }
-
-    /// Get the options used to configure this bindgen context.
-    pub(crate) fn options(&self) -> &BindgenOptions {
-        &self.options
-    }
-
-    /// Tokenizes a namespace cursor in order to get the name and kind of the
-    /// namespace.
-    fn tokenize_namespace(
-        &self,
-        cursor: &clang::Cursor,
-    ) -> (Option<String>, ModuleKind) {
-        assert_eq!(
-            cursor.kind(),
-            ::clang_sys::CXCursor_Namespace,
-            "Be a nice person"
-        );
-
-        let mut module_name = None;
-        let spelling = cursor.spelling();
-        if !spelling.is_empty() {
-            module_name = Some(spelling)
-        }
-
-        let mut kind = ModuleKind::Normal;
-        let mut found_namespace_keyword = false;
-        for token in cursor.tokens().iter() {
-            match token.spelling() {
-                b"inline" => {
-                    assert!(!found_namespace_keyword);
-                    assert!(kind != ModuleKind::Inline);
-                    kind = ModuleKind::Inline;
-                }
-                // The double colon allows us to handle nested namespaces like
-                // namespace foo::bar { }
-                //
-                // libclang still gives us two namespace cursors, which is cool,
-                // but the tokenization of the second begins with the double
-                // colon. That's ok, so we only need to handle the weird
-                // tokenization here.
-                //
-                // Fortunately enough, inline nested namespace specifiers aren't
-                // a thing, and are invalid C++ :)
-                b"namespace" | b"::" => {
-                    found_namespace_keyword = true;
-                }
-                b"{" => {
-                    assert!(found_namespace_keyword);
-                    break;
-                }
-                name if found_namespace_keyword => {
-                    if module_name.is_none() {
-                        module_name =
-                            Some(String::from_utf8_lossy(name).into_owned());
-                    }
-                    break;
-                }
-                spelling if !found_namespace_keyword => {
-                    // This is _likely_, but not certainly, a macro that's been placed just before
-                    // the namespace keyword. Unfortunately, clang tokens don't let us easily see
-                    // through the ifdef tokens, so we don't know what this token should really be.
-                    // Instead of panicking though, we warn the user that we assumed the token was
-                    // blank, and then move on.
-                    //
-                    // See also https://github.com/rust-lang/rust-bindgen/issues/1676.
-                    warn!(
-                        "Ignored unknown namespace prefix '{}' at {:?} in {:?}",
-                        String::from_utf8_lossy(spelling),
-                        token,
-                        cursor
-                    );
-                }
-                spelling => {
-                    panic!(
-                        "Unknown token '{}' while processing namespace at {:?} in {:?}",
-                        String::from_utf8_lossy(spelling),
-                        token,
-                        cursor
-                    );
-                }
-            }
-        }
-
-        (module_name, kind)
-    }
-
-    /// Given a CXCursor_Namespace cursor, return the item id of the
-    /// corresponding module, or create one on the fly.
-    pub fn module(&mut self, cursor: clang::Cursor) -> ModuleId {
-        use clang_sys::*;
-        assert_eq!(cursor.kind(), CXCursor_Namespace, "Be a nice person");
-        let cursor = cursor.canonical();
-        if let Some(id) = self.modules.get(&cursor) {
-            return *id;
-        }
-
-        let (module_name, kind) = self.tokenize_namespace(&cursor);
-
-        let module_id = self.next_item_id();
-        let module = Module::new(module_name, kind);
-        let module = Item::new(
-            module_id,
-            None,
-            None,
-            self.current_module.into(),
-            ItemKind::Module(module),
-            Some(cursor.location()),
-        );
-
-        let module_id = module.id().as_module_id_unchecked();
-        self.modules.insert(cursor, module_id);
-
-        self.add_item(module, None, None);
-
-        module_id
-    }
-
-    /// Start traversing the module with the given `module_id`, invoke the
-    /// callback `cb`, and then return to traversing the original module.
-    pub fn with_module<F>(&mut self, module_id: ModuleId, cb: F)
-    where
-        F: FnOnce(&mut Self),
-    {
-        debug_assert!(self.resolve_item(module_id).kind().is_module(), "Wat");
-
-        let previous_id = self.current_module;
-        self.current_module = module_id;
-
-        cb(self);
-
-        self.current_module = previous_id;
-    }
-
-    /// Iterate over all (explicitly or transitively) allowlisted items.
-    ///
-    /// If no items are explicitly allowlisted, then all items are considered
-    /// allowlisted.
-    pub fn allowlisted_items(&self) -> &ItemSet {
-        assert!(self.in_codegen_phase());
-        assert!(self.current_module == self.root_module);
-
-        self.allowlisted.as_ref().unwrap()
-    }
-
-    /// Check whether a particular blocklisted type implements a trait or not.
-    /// Results may be cached.
-    pub fn blocklisted_type_implements_trait(
-        &self,
-        item: &Item,
-        derive_trait: DeriveTrait,
-    ) -> CanDerive {
-        assert!(self.in_codegen_phase());
-        assert!(self.current_module == self.root_module);
-
-        *self
-            .blocklisted_types_implement_traits
-            .borrow_mut()
-            .entry(derive_trait)
-            .or_default()
-            .entry(item.id())
-            .or_insert_with(|| {
-                item.expect_type()
-                    .name()
-                    .and_then(|name| match self.options.parse_callbacks {
-                        Some(ref cb) => cb.blocklisted_type_implements_trait(
-                            name,
-                            derive_trait,
-                        ),
-                        // Sized integer types from <stdint.h> get mapped to Rust primitive
-                        // types regardless of whether they are blocklisted, so ensure that
-                        // standard traits are considered derivable for them too.
-                        None => Some(if self.is_stdint_type(name) {
-                            CanDerive::Yes
-                        } else {
-                            CanDerive::No
-                        }),
-                    })
-                    .unwrap_or(CanDerive::No)
-            })
-    }
-
-    /// Is the given type a type from <stdint.h> that corresponds to a Rust primitive type?
-    pub fn is_stdint_type(&self, name: &str) -> bool {
-        match name {
-            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" | "int32_t" |
-            "uint32_t" | "int64_t" | "uint64_t" | "uintptr_t" |
-            "intptr_t" | "ptrdiff_t" => true,
-            "size_t" | "ssize_t" => self.options.size_t_is_usize,
-            _ => false,
-        }
-    }
-
-    /// Get a reference to the set of items we should generate.
-    pub fn codegen_items(&self) -> &ItemSet {
-        assert!(self.in_codegen_phase());
-        assert!(self.current_module == self.root_module);
-        self.codegen_items.as_ref().unwrap()
-    }
-
-    /// Compute the allowlisted items set and populate `self.allowlisted`.
-    fn compute_allowlisted_and_codegen_items(&mut self) {
-        assert!(self.in_codegen_phase());
-        assert!(self.current_module == self.root_module);
-        assert!(self.allowlisted.is_none());
-        let _t = self.timer("compute_allowlisted_and_codegen_items");
-
-        let roots = {
-            let mut roots = self
-                .items()
-                // Only consider roots that are enabled for codegen.
-                .filter(|&(_, item)| item.is_enabled_for_codegen(self))
-                .filter(|&(_, item)| {
-                    // If nothing is explicitly allowlisted, then everything is fair
-                    // game.
-                    if self.options().allowlisted_types.is_empty() &&
-                        self.options().allowlisted_functions.is_empty() &&
-                        self.options().allowlisted_vars.is_empty() &&
-                        self.options().allowlisted_files.is_empty()
-                    {
-                        return true;
-                    }
-
-                    // If this is a type that explicitly replaces another, we assume
-                    // you know what you're doing.
-                    if item.annotations().use_instead_of().is_some() {
-                        return true;
-                    }
-
-                    // Items with a source location in an explicitly allowlisted file
-                    // are always included.
-                    if !self.options().allowlisted_files.is_empty() {
-                        if let Some(location) = item.location() {
-                            let (file, _, _, _) = location.location();
-                            if let Some(filename) = file.name() {
-                                if self
-                                    .options()
-                                    .allowlisted_files
-                                    .matches(&filename)
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-
-                    let name = item.path_for_allowlisting(self)[1..].join("::");
-                    debug!("allowlisted_items: testing {:?}", name);
-                    match *item.kind() {
-                        ItemKind::Module(..) => true,
-                        ItemKind::Function(_) => {
-                            self.options().allowlisted_functions.matches(&name)
-                        }
-                        ItemKind::Var(_) => {
-                            self.options().allowlisted_vars.matches(&name)
-                        }
-                        ItemKind::Type(ref ty) => {
-                            if self.options().allowlisted_types.matches(&name) {
-                                return true;
-                            }
-
-                            // Auto-allowlist types that don't need code
-                            // generation if not allowlisting recursively, to
-                            // make the #[derive] analysis not be lame.
-                            if !self.options().allowlist_recursively {
-                                match *ty.kind() {
-                                    TypeKind::Void |
-                                    TypeKind::NullPtr |
-                                    TypeKind::Int(..) |
-                                    TypeKind::Float(..) |
-                                    TypeKind::Complex(..) |
-                                    TypeKind::Array(..) |
-                                    TypeKind::Vector(..) |
-                                    TypeKind::Pointer(..) |
-                                    TypeKind::Reference(..) |
-                                    TypeKind::Function(..) |
-                                    TypeKind::ResolvedTypeRef(..) |
-                                    TypeKind::Opaque |
-                                    TypeKind::TypeParam => return true,
-                                    _ => {}
-                                }
-                                if self.is_stdint_type(&name) {
-                                    return true;
-                                }
-                            }
-
-                            // Unnamed top-level enums are special and we
-                            // allowlist them via the `allowlisted_vars` filter,
-                            // since they're effectively top-level constants,
-                            // and there's no way for them to be referenced
-                            // consistently.
-                            let parent = self.resolve_item(item.parent_id());
-                            if !parent.is_module() {
-                                return false;
-                            }
-
-                            let enum_ = match *ty.kind() {
-                                TypeKind::Enum(ref e) => e,
-                                _ => return false,
-                            };
-
-                            if ty.name().is_some() {
-                                return false;
-                            }
-
-                            let mut prefix_path =
-                                parent.path_for_allowlisting(self).clone();
-                            enum_.variants().iter().any(|variant| {
-                                prefix_path.push(
-                                    variant.name_for_allowlisting().into(),
-                                );
-                                let name = prefix_path[1..].join("::");
-                                prefix_path.pop().unwrap();
-                                self.options().allowlisted_vars.matches(&name)
-                            })
-                        }
-                    }
-                })
-                .map(|(id, _)| id)
-                .collect::<Vec<_>>();
-
-            // The reversal preserves the expected ordering of traversal,
-            // resulting in more stable-ish bindgen-generated names for
-            // anonymous types (like unions).
-            roots.reverse();
-            roots
-        };
-
-        let allowlisted_items_predicate =
-            if self.options().allowlist_recursively {
-                traversal::all_edges
-            } else {
-                // Only follow InnerType edges from the allowlisted roots.
-                // Such inner types (e.g. anonymous structs/unions) are
-                // always emitted by codegen, and they need to be allowlisted
-                // to make sure they are processed by e.g. the derive analysis.
-                traversal::only_inner_type_edges
-            };
-
-        let allowlisted = AllowlistedItemsTraversal::new(
-            self,
-            roots.clone(),
-            allowlisted_items_predicate,
-        )
-        .collect::<ItemSet>();
-
-        let codegen_items = if self.options().allowlist_recursively {
-            AllowlistedItemsTraversal::new(
-                self,
-                roots,
-                traversal::codegen_edges,
-            )
-            .collect::<ItemSet>()
-        } else {
-            allowlisted.clone()
-        };
-
-        self.allowlisted = Some(allowlisted);
-        self.codegen_items = Some(codegen_items);
-
-        let mut warnings = Vec::new();
-
-        for item in self.options().allowlisted_functions.unmatched_items() {
-            warnings
-                .push(format!("unused option: --allowlist-function {}", item));
-        }
-
-        for item in self.options().allowlisted_vars.unmatched_items() {
-            warnings.push(format!("unused option: --allowlist-var {}", item));
-        }
-
-        for item in self.options().allowlisted_types.unmatched_items() {
-            warnings.push(format!("unused option: --allowlist-type {}", item));
-        }
-
-        for msg in warnings {
-            warn!("{}", msg);
-            self.warnings.push(msg);
-        }
-    }
-
-    /// Convenient method for getting the prefix to use for most traits in
-    /// codegen depending on the `use_core` option.
-    pub fn trait_prefix(&self) -> Ident {
-        if self.options().use_core {
-            self.rust_ident_raw("core")
-        } else {
-            self.rust_ident_raw("std")
-        }
-    }
-
-    /// Call if a bindgen complex is generated
-    pub fn generated_bindgen_complex(&self) {
-        self.generated_bindgen_complex.set(true)
-    }
-
-    /// Whether we need to generate the bindgen complex type
-    pub fn need_bindgen_complex_type(&self) -> bool {
-        self.generated_bindgen_complex.get()
-    }
-
-    /// Compute whether we can derive debug.
-    fn compute_cannot_derive_debug(&mut self) {
-        let _t = self.timer("compute_cannot_derive_debug");
-        assert!(self.cannot_derive_debug.is_none());
-        if self.options.derive_debug {
-            self.cannot_derive_debug =
-                Some(as_cannot_derive_set(analyze::<CannotDerive>((
-                    self,
-                    DeriveTrait::Debug,
-                ))));
-        }
-    }
-
-    /// Look up whether the item with `id` can
-    /// derive debug or not.
-    pub fn lookup_can_derive_debug<Id: Into<ItemId>>(&self, id: Id) -> bool {
-        let id = id.into();
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute can_derive_debug when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` can
-        // derive debug or not.
-        !self.cannot_derive_debug.as_ref().unwrap().contains(&id)
-    }
-
-    /// Compute whether we can derive default.
-    fn compute_cannot_derive_default(&mut self) {
-        let _t = self.timer("compute_cannot_derive_default");
-        assert!(self.cannot_derive_default.is_none());
-        if self.options.derive_default {
-            self.cannot_derive_default =
-                Some(as_cannot_derive_set(analyze::<CannotDerive>((
-                    self,
-                    DeriveTrait::Default,
-                ))));
-        }
-    }
-
-    /// Look up whether the item with `id` can
-    /// derive default or not.
-    pub fn lookup_can_derive_default<Id: Into<ItemId>>(&self, id: Id) -> bool {
-        let id = id.into();
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute can_derive_default when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` can
-        // derive default or not.
-        !self.cannot_derive_default.as_ref().unwrap().contains(&id)
-    }
-
-    /// Compute whether we can derive copy.
-    fn compute_cannot_derive_copy(&mut self) {
-        let _t = self.timer("compute_cannot_derive_copy");
-        assert!(self.cannot_derive_copy.is_none());
-        self.cannot_derive_copy =
-            Some(as_cannot_derive_set(analyze::<CannotDerive>((
-                self,
-                DeriveTrait::Copy,
-            ))));
-    }
-
-    /// Compute whether we can derive hash.
-    fn compute_cannot_derive_hash(&mut self) {
-        let _t = self.timer("compute_cannot_derive_hash");
-        assert!(self.cannot_derive_hash.is_none());
-        if self.options.derive_hash {
-            self.cannot_derive_hash =
-                Some(as_cannot_derive_set(analyze::<CannotDerive>((
-                    self,
-                    DeriveTrait::Hash,
-                ))));
-        }
-    }
-
-    /// Look up whether the item with `id` can
-    /// derive hash or not.
-    pub fn lookup_can_derive_hash<Id: Into<ItemId>>(&self, id: Id) -> bool {
-        let id = id.into();
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute can_derive_debug when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` can
-        // derive hash or not.
-        !self.cannot_derive_hash.as_ref().unwrap().contains(&id)
-    }
-
-    /// Compute whether we can derive PartialOrd, PartialEq or Eq.
-    fn compute_cannot_derive_partialord_partialeq_or_eq(&mut self) {
-        let _t = self.timer("compute_cannot_derive_partialord_partialeq_or_eq");
-        assert!(self.cannot_derive_partialeq_or_partialord.is_none());
-        if self.options.derive_partialord ||
-            self.options.derive_partialeq ||
-            self.options.derive_eq
-        {
-            self.cannot_derive_partialeq_or_partialord =
-                Some(analyze::<CannotDerive>((
-                    self,
-                    DeriveTrait::PartialEqOrPartialOrd,
-                )));
-        }
-    }
-
-    /// Look up whether the item with `id` can derive `Partial{Eq,Ord}`.
-    pub fn lookup_can_derive_partialeq_or_partialord<Id: Into<ItemId>>(
-        &self,
-        id: Id,
-    ) -> CanDerive {
-        let id = id.into();
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute can_derive_partialeq_or_partialord when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` can
-        // derive partialeq or not.
-        self.cannot_derive_partialeq_or_partialord
-            .as_ref()
-            .unwrap()
-            .get(&id)
-            .cloned()
-            .unwrap_or(CanDerive::Yes)
-    }
-
-    /// Look up whether the item with `id` can derive `Copy` or not.
-    pub fn lookup_can_derive_copy<Id: Into<ItemId>>(&self, id: Id) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute can_derive_debug when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` can
-        // derive `Copy` or not.
-        let id = id.into();
-
-        !self.lookup_has_type_param_in_array(id) &&
-            !self.cannot_derive_copy.as_ref().unwrap().contains(&id)
-    }
-
-    /// Compute whether the type has type parameter in array.
-    fn compute_has_type_param_in_array(&mut self) {
-        let _t = self.timer("compute_has_type_param_in_array");
-        assert!(self.has_type_param_in_array.is_none());
-        self.has_type_param_in_array =
-            Some(analyze::<HasTypeParameterInArray>(self));
-    }
-
-    /// Look up whether the item with `id` has type parameter in array or not.
-    pub fn lookup_has_type_param_in_array<Id: Into<ItemId>>(
-        &self,
-        id: Id,
-    ) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute has array when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` has
-        // type parameter in array or not.
-        self.has_type_param_in_array
-            .as_ref()
-            .unwrap()
-            .contains(&id.into())
-    }
-
-    /// Compute whether the type has float.
-    fn compute_has_float(&mut self) {
-        let _t = self.timer("compute_has_float");
-        assert!(self.has_float.is_none());
-        if self.options.derive_eq || self.options.derive_ord {
-            self.has_float = Some(analyze::<HasFloat>(self));
-        }
-    }
-
-    /// Look up whether the item with `id` has array or not.
-    pub fn lookup_has_float<Id: Into<ItemId>>(&self, id: Id) -> bool {
-        assert!(
-            self.in_codegen_phase(),
-            "We only compute has float when we enter codegen"
-        );
-
-        // Look up the computed value for whether the item with `id` has
-        // float or not.
-        self.has_float.as_ref().unwrap().contains(&id.into())
-    }
-
-    /// Check if `--no-partialeq` flag is enabled for this item.
-    pub fn no_partialeq_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().no_partialeq_types.matches(&name)
-    }
-
-    /// Check if `--no-copy` flag is enabled for this item.
-    pub fn no_copy_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().no_copy_types.matches(&name)
-    }
-
-    /// Check if `--no-debug` flag is enabled for this item.
-    pub fn no_debug_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().no_debug_types.matches(&name)
-    }
-
-    /// Check if `--no-default` flag is enabled for this item.
-    pub fn no_default_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().no_default_types.matches(&name)
-    }
-
-    /// Check if `--no-hash` flag is enabled for this item.
-    pub fn no_hash_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().no_hash_types.matches(&name)
-    }
-
-    /// Check if `--must-use-type` flag is enabled for this item.
-    pub fn must_use_type_by_name(&self, item: &Item) -> bool {
-        let name = item.path_for_allowlisting(self)[1..].join("::");
-        self.options().must_use_types.matches(&name)
-    }
-}
-
-/// A builder struct for configuring item resolution options.
-#[derive(Debug, Copy, Clone)]
-pub struct ItemResolver {
-    id: ItemId,
-    through_type_refs: bool,
-    through_type_aliases: bool,
-}
-
-impl ItemId {
-    /// Create an `ItemResolver` from this item id.
-    pub fn into_resolver(self) -> ItemResolver {
-        self.into()
-    }
-}
-
-impl<T> From<T> for ItemResolver
-where
-    T: Into<ItemId>,
-{
-    fn from(id: T) -> ItemResolver {
-        ItemResolver::new(id)
-    }
-}
-
-impl ItemResolver {
-    /// Construct a new `ItemResolver` from the given id.
-    pub fn new<Id: Into<ItemId>>(id: Id) -> ItemResolver {
-        let id = id.into();
-        ItemResolver {
-            id,
-            through_type_refs: false,
-            through_type_aliases: false,
-        }
-    }
-
-    /// Keep resolving through `Type::TypeRef` items.
-    pub fn through_type_refs(mut self) -> ItemResolver {
-        self.through_type_refs = true;
-        self
-    }
-
-    /// Keep resolving through `Type::Alias` items.
-    pub fn through_type_aliases(mut self) -> ItemResolver {
-        self.through_type_aliases = true;
-        self
-    }
-
-    /// Finish configuring and perform the actual item resolution.
-    pub fn resolve(self, ctx: &BindgenContext) -> &Item {
-        assert!(ctx.collected_typerefs());
-
-        let mut id = self.id;
-        let mut seen_ids = HashSet::default();
-        loop {
-            let item = ctx.resolve_item(id);
-
-            // Detect cycles and bail out. These can happen in certain cases
-            // involving incomplete qualified dependent types (#2085).
-            if !seen_ids.insert(id) {
-                return item;
-            }
-
-            let ty_kind = item.as_type().map(|t| t.kind());
-            match ty_kind {
-                Some(&TypeKind::ResolvedTypeRef(next_id))
-                    if self.through_type_refs =>
-                {
-                    id = next_id.into();
-                }
-                // We intentionally ignore template aliases here, as they are
-                // more complicated, and don't represent a simple renaming of
-                // some type.
-                Some(&TypeKind::Alias(next_id))
-                    if self.through_type_aliases =>
-                {
-                    id = next_id.into();
-                }
-                _ => return item,
-            }
-        }
-    }
-}
-
-/// A type that we are in the middle of parsing.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PartialType {
-    decl: Cursor,
-    // Just an ItemId, and not a TypeId, because we haven't finished this type
-    // yet, so there's still time for things to go wrong.
-    id: ItemId,
-}
-
-impl PartialType {
-    /// Construct a new `PartialType`.
-    pub fn new(decl: Cursor, id: ItemId) -> PartialType {
-        // assert!(decl == decl.canonical());
-        PartialType { decl, id }
-    }
-
-    /// The cursor pointing to this partial type's declaration location.
-    pub fn decl(&self) -> &Cursor {
-        &self.decl
-    }
-
-    /// The item ID allocated for this type. This is *NOT* a key for an entry in
-    /// the context's item set yet!
-    pub fn id(&self) -> ItemId {
-        self.id
-    }
-}
-
-impl TemplateParameters for PartialType {
-    fn self_template_params(&self, _ctx: &BindgenContext) -> Vec<TypeId> {
-        // Maybe at some point we will eagerly parse named types, but for now we
-        // don't and this information is unavailable.
-        vec![]
-    }
-
-    fn num_self_template_params(&self, _ctx: &BindgenContext) -> usize {
-        // Wouldn't it be nice if libclang would reliably give us this
-        // information‽
-        match self.decl().kind() {
-            clang_sys::CXCursor_ClassTemplate |
-            clang_sys::CXCursor_FunctionTemplate |
-            clang_sys::CXCursor_TypeAliasTemplateDecl => {
-                let mut num_params = 0;
-                self.decl().visit(|c| {
-                    match c.kind() {
-                        clang_sys::CXCursor_TemplateTypeParameter |
-                        clang_sys::CXCursor_TemplateTemplateParameter |
-                        clang_sys::CXCursor_NonTypeTemplateParameter => {
-                            num_params += 1;
-                        }
-                        _ => {}
-                    };
-                    clang_sys::CXChildVisit_Continue
-                });
-                num_params
-            }
-            _ => 0,
-        }
-    }
-}
diff --git a/src/ir/derive.rs b/src/ir/derive.rs
deleted file mode 100644
index 594ce2ab..00000000
--- a/src/ir/derive.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-//! Traits for determining whether we can derive traits for a thing or not.
-//!
-//! These traits tend to come in pairs:
-//!
-//! 1. A "trivial" version, whose implementations aren't allowed to recursively
-//! look at other types or the results of fix point analyses.
-//!
-//! 2. A "normal" version, whose implementations simply query the results of a
-//! fix point analysis.
-//!
-//! The former is used by the analyses when creating the results queried by the
-//! second.
-
-use super::context::BindgenContext;
-
-use std::cmp;
-use std::ops;
-
-/// A trait that encapsulates the logic for whether or not we can derive `Debug`
-/// for a given thing.
-pub trait CanDeriveDebug {
-    /// Return `true` if `Debug` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive `Copy`
-/// for a given thing.
-pub trait CanDeriveCopy {
-    /// Return `true` if `Copy` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive
-/// `Default` for a given thing.
-pub trait CanDeriveDefault {
-    /// Return `true` if `Default` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_default(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive `Hash`
-/// for a given thing.
-pub trait CanDeriveHash {
-    /// Return `true` if `Hash` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive
-/// `PartialEq` for a given thing.
-pub trait CanDerivePartialEq {
-    /// Return `true` if `PartialEq` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive
-/// `PartialOrd` for a given thing.
-pub trait CanDerivePartialOrd {
-    /// Return `true` if `PartialOrd` can be derived for this thing, `false`
-    /// otherwise.
-    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive `Eq`
-/// for a given thing.
-pub trait CanDeriveEq {
-    /// Return `true` if `Eq` can be derived for this thing, `false` otherwise.
-    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait that encapsulates the logic for whether or not we can derive `Ord`
-/// for a given thing.
-pub trait CanDeriveOrd {
-    /// Return `true` if `Ord` can be derived for this thing, `false` otherwise.
-    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// Whether it is possible or not to automatically derive trait for an item.
-///
-/// ```ignore
-///         No
-///          ^
-///          |
-///      Manually
-///          ^
-///          |
-///         Yes
-/// ```
-///
-/// Initially we assume that we can derive trait for all types and then
-/// update our understanding as we learn more about each type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum CanDerive {
-    /// Yes, we can derive automatically.
-    Yes,
-
-    /// The only thing that stops us from automatically deriving is that
-    /// array with more than maximum number of elements is used.
-    ///
-    /// This means we probably can "manually" implement such trait.
-    Manually,
-
-    /// No, we cannot.
-    No,
-}
-
-impl Default for CanDerive {
-    fn default() -> CanDerive {
-        CanDerive::Yes
-    }
-}
-
-impl CanDerive {
-    /// Take the least upper bound of `self` and `rhs`.
-    pub fn join(self, rhs: Self) -> Self {
-        cmp::max(self, rhs)
-    }
-}
-
-impl ops::BitOr for CanDerive {
-    type Output = Self;
-
-    fn bitor(self, rhs: Self) -> Self::Output {
-        self.join(rhs)
-    }
-}
-
-impl ops::BitOrAssign for CanDerive {
-    fn bitor_assign(&mut self, rhs: Self) {
-        *self = self.join(rhs)
-    }
-}
diff --git a/src/ir/dot.rs b/src/ir/dot.rs
deleted file mode 100644
index f7d07f19..00000000
--- a/src/ir/dot.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-//! Generating Graphviz `dot` files from our IR.
-
-use super::context::{BindgenContext, ItemId};
-use super::traversal::Trace;
-use std::fs::File;
-use std::io::{self, Write};
-use std::path::Path;
-
-/// A trait for anything that can write attributes as `<table>` rows to a dot
-/// file.
-pub trait DotAttributes {
-    /// Write this thing's attributes to the given output. Each attribute must
-    /// be its own `<tr>...</tr>`.
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write;
-}
-
-/// Write a graphviz dot file containing our IR.
-pub fn write_dot_file<P>(ctx: &BindgenContext, path: P) -> io::Result<()>
-where
-    P: AsRef<Path>,
-{
-    let file = File::create(path)?;
-    let mut dot_file = io::BufWriter::new(file);
-    writeln!(&mut dot_file, "digraph {{")?;
-
-    let mut err: Option<io::Result<_>> = None;
-
-    for (id, item) in ctx.items() {
-        let is_allowlisted = ctx.allowlisted_items().contains(&id);
-
-        writeln!(
-            &mut dot_file,
-            r#"{} [fontname="courier", color={}, label=< <table border="0" align="left">"#,
-            id.as_usize(),
-            if is_allowlisted { "black" } else { "gray" }
-        )?;
-        item.dot_attributes(ctx, &mut dot_file)?;
-        writeln!(&mut dot_file, r#"</table> >];"#)?;
-
-        item.trace(
-            ctx,
-            &mut |sub_id: ItemId, edge_kind| {
-                if err.is_some() {
-                    return;
-                }
-
-                match writeln!(
-                    &mut dot_file,
-                    "{} -> {} [label={:?}, color={}];",
-                    id.as_usize(),
-                    sub_id.as_usize(),
-                    edge_kind,
-                    if is_allowlisted { "black" } else { "gray" }
-                ) {
-                    Ok(_) => {}
-                    Err(e) => err = Some(Err(e)),
-                }
-            },
-            &(),
-        );
-
-        if let Some(err) = err {
-            return err;
-        }
-
-        if let Some(module) = item.as_module() {
-            for child in module.children() {
-                writeln!(
-                    &mut dot_file,
-                    "{} -> {} [style=dotted, color=gray]",
-                    item.id().as_usize(),
-                    child.as_usize()
-                )?;
-            }
-        }
-    }
-
-    writeln!(&mut dot_file, "}}")?;
-    Ok(())
-}
diff --git a/src/ir/enum_ty.rs b/src/ir/enum_ty.rs
deleted file mode 100644
index 123d1d79..00000000
--- a/src/ir/enum_ty.rs
+++ /dev/null
@@ -1,320 +0,0 @@
-//! Intermediate representation for C/C++ enumerations.
-
-use super::super::codegen::EnumVariation;
-use super::context::{BindgenContext, TypeId};
-use super::item::Item;
-use super::ty::{Type, TypeKind};
-use crate::clang;
-use crate::ir::annotations::Annotations;
-use crate::parse::{ClangItemParser, ParseError};
-use crate::regex_set::RegexSet;
-
-/// An enum representing custom handling that can be given to a variant.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum EnumVariantCustomBehavior {
-    /// This variant will be a module containing constants.
-    ModuleConstify,
-    /// This variant will be constified, that is, forced to generate a constant.
-    Constify,
-    /// This variant will be hidden entirely from the resulting enum.
-    Hide,
-}
-
-/// A C/C++ enumeration.
-#[derive(Debug)]
-pub struct Enum {
-    /// The representation used for this enum; it should be an `IntKind` type or
-    /// an alias to one.
-    ///
-    /// It's `None` if the enum is a forward declaration and isn't defined
-    /// anywhere else, see `tests/headers/func_ptr_in_struct.h`.
-    repr: Option<TypeId>,
-
-    /// The different variants, with explicit values.
-    variants: Vec<EnumVariant>,
-}
-
-impl Enum {
-    /// Construct a new `Enum` with the given representation and variants.
-    pub fn new(repr: Option<TypeId>, variants: Vec<EnumVariant>) -> Self {
-        Enum { repr, variants }
-    }
-
-    /// Get this enumeration's representation.
-    pub fn repr(&self) -> Option<TypeId> {
-        self.repr
-    }
-
-    /// Get this enumeration's variants.
-    pub fn variants(&self) -> &[EnumVariant] {
-        &self.variants
-    }
-
-    /// Construct an enumeration from the given Clang type.
-    pub fn from_ty(
-        ty: &clang::Type,
-        ctx: &mut BindgenContext,
-    ) -> Result<Self, ParseError> {
-        use clang_sys::*;
-        debug!("Enum::from_ty {:?}", ty);
-
-        if ty.kind() != CXType_Enum {
-            return Err(ParseError::Continue);
-        }
-
-        let declaration = ty.declaration().canonical();
-        let repr = declaration
-            .enum_type()
-            .and_then(|et| Item::from_ty(&et, declaration, None, ctx).ok());
-        let mut variants = vec![];
-
-        let variant_ty =
-            repr.and_then(|r| ctx.resolve_type(r).safe_canonical_type(ctx));
-        let is_bool = variant_ty.map_or(false, Type::is_bool);
-
-        // Assume signedness since the default type by the C standard is an int.
-        let is_signed = variant_ty.map_or(true, |ty| match *ty.kind() {
-            TypeKind::Int(ref int_kind) => int_kind.is_signed(),
-            ref other => {
-                panic!("Since when enums can be non-integers? {:?}", other)
-            }
-        });
-
-        let type_name = ty.spelling();
-        let type_name = if type_name.is_empty() {
-            None
-        } else {
-            Some(type_name)
-        };
-        let type_name = type_name.as_deref();
-
-        let definition = declaration.definition().unwrap_or(declaration);
-        definition.visit(|cursor| {
-            if cursor.kind() == CXCursor_EnumConstantDecl {
-                let value = if is_bool {
-                    cursor.enum_val_boolean().map(EnumVariantValue::Boolean)
-                } else if is_signed {
-                    cursor.enum_val_signed().map(EnumVariantValue::Signed)
-                } else {
-                    cursor.enum_val_unsigned().map(EnumVariantValue::Unsigned)
-                };
-                if let Some(val) = value {
-                    let name = cursor.spelling();
-                    let annotations = Annotations::new(&cursor);
-                    let custom_behavior = ctx
-                        .parse_callbacks()
-                        .and_then(|callbacks| {
-                            callbacks
-                                .enum_variant_behavior(type_name, &name, val)
-                        })
-                        .or_else(|| {
-                            let annotations = annotations.as_ref()?;
-                            if annotations.hide() {
-                                Some(EnumVariantCustomBehavior::Hide)
-                            } else if annotations.constify_enum_variant() {
-                                Some(EnumVariantCustomBehavior::Constify)
-                            } else {
-                                None
-                            }
-                        });
-
-                    let new_name = ctx
-                        .parse_callbacks()
-                        .and_then(|callbacks| {
-                            callbacks.enum_variant_name(type_name, &name, val)
-                        })
-                        .or_else(|| {
-                            annotations
-                                .as_ref()?
-                                .use_instead_of()?
-                                .last()
-                                .cloned()
-                        })
-                        .unwrap_or_else(|| name.clone());
-
-                    let comment = cursor.raw_comment();
-                    variants.push(EnumVariant::new(
-                        new_name,
-                        name,
-                        comment,
-                        val,
-                        custom_behavior,
-                    ));
-                }
-            }
-            CXChildVisit_Continue
-        });
-        Ok(Enum::new(repr, variants))
-    }
-
-    fn is_matching_enum(
-        &self,
-        ctx: &BindgenContext,
-        enums: &RegexSet,
-        item: &Item,
-    ) -> bool {
-        let path = item.path_for_allowlisting(ctx);
-        let enum_ty = item.expect_type();
-
-        if enums.matches(&path[1..].join("::")) {
-            return true;
-        }
-
-        // Test the variants if the enum is anonymous.
-        if enum_ty.name().is_some() {
-            return false;
-        }
-
-        self.variants().iter().any(|v| enums.matches(v.name()))
-    }
-
-    /// Returns the final representation of the enum.
-    pub fn computed_enum_variation(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> EnumVariation {
-        // ModuleConsts has higher precedence before Rust in order to avoid
-        // problems with overlapping match patterns.
-        if self.is_matching_enum(
-            ctx,
-            &ctx.options().constified_enum_modules,
-            item,
-        ) {
-            EnumVariation::ModuleConsts
-        } else if self.is_matching_enum(
-            ctx,
-            &ctx.options().bitfield_enums,
-            item,
-        ) {
-            EnumVariation::NewType {
-                is_bitfield: true,
-                is_global: false,
-            }
-        } else if self.is_matching_enum(ctx, &ctx.options().newtype_enums, item)
-        {
-            EnumVariation::NewType {
-                is_bitfield: false,
-                is_global: false,
-            }
-        } else if self.is_matching_enum(
-            ctx,
-            &ctx.options().newtype_global_enums,
-            item,
-        ) {
-            EnumVariation::NewType {
-                is_bitfield: false,
-                is_global: true,
-            }
-        } else if self.is_matching_enum(
-            ctx,
-            &ctx.options().rustified_enums,
-            item,
-        ) {
-            EnumVariation::Rust {
-                non_exhaustive: false,
-            }
-        } else if self.is_matching_enum(
-            ctx,
-            &ctx.options().rustified_non_exhaustive_enums,
-            item,
-        ) {
-            EnumVariation::Rust {
-                non_exhaustive: true,
-            }
-        } else if self.is_matching_enum(
-            ctx,
-            &ctx.options().constified_enums,
-            item,
-        ) {
-            EnumVariation::Consts
-        } else {
-            ctx.options().default_enum_style
-        }
-    }
-}
-
-/// A single enum variant, to be contained only in an enum.
-#[derive(Debug)]
-pub struct EnumVariant {
-    /// The name of the variant.
-    name: String,
-
-    /// The original name of the variant (without user mangling)
-    name_for_allowlisting: String,
-
-    /// An optional doc comment.
-    comment: Option<String>,
-
-    /// The integer value of the variant.
-    val: EnumVariantValue,
-
-    /// The custom behavior this variant may have, if any.
-    custom_behavior: Option<EnumVariantCustomBehavior>,
-}
-
-/// A constant value assigned to an enumeration variant.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum EnumVariantValue {
-    /// A boolean constant.
-    Boolean(bool),
-
-    /// A signed constant.
-    Signed(i64),
-
-    /// An unsigned constant.
-    Unsigned(u64),
-}
-
-impl EnumVariant {
-    /// Construct a new enumeration variant from the given parts.
-    pub fn new(
-        name: String,
-        name_for_allowlisting: String,
-        comment: Option<String>,
-        val: EnumVariantValue,
-        custom_behavior: Option<EnumVariantCustomBehavior>,
-    ) -> Self {
-        EnumVariant {
-            name,
-            name_for_allowlisting,
-            comment,
-            val,
-            custom_behavior,
-        }
-    }
-
-    /// Get this variant's name.
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    /// Get this variant's name.
-    pub fn name_for_allowlisting(&self) -> &str {
-        &self.name_for_allowlisting
-    }
-
-    /// Get this variant's value.
-    pub fn val(&self) -> EnumVariantValue {
-        self.val
-    }
-
-    /// Get this variant's documentation.
-    pub fn comment(&self) -> Option<&str> {
-        self.comment.as_deref()
-    }
-
-    /// Returns whether this variant should be enforced to be a constant by code
-    /// generation.
-    pub fn force_constification(&self) -> bool {
-        self.custom_behavior
-            .map_or(false, |b| b == EnumVariantCustomBehavior::Constify)
-    }
-
-    /// Returns whether the current variant should be hidden completely from the
-    /// resulting rust enum.
-    pub fn hidden(&self) -> bool {
-        self.custom_behavior
-            .map_or(false, |b| b == EnumVariantCustomBehavior::Hide)
-    }
-}
diff --git a/src/ir/function.rs b/src/ir/function.rs
deleted file mode 100644
index 928b5aad..00000000
--- a/src/ir/function.rs
+++ /dev/null
@@ -1,690 +0,0 @@
-//! Intermediate representation for C/C++ functions and methods.
-
-use super::comp::MethodKind;
-use super::context::{BindgenContext, TypeId};
-use super::dot::DotAttributes;
-use super::item::Item;
-use super::traversal::{EdgeKind, Trace, Tracer};
-use super::ty::TypeKind;
-use crate::clang::{self, Attribute};
-use crate::parse::{
-    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
-};
-use clang_sys::{self, CXCallingConv};
-use proc_macro2;
-use quote;
-use quote::TokenStreamExt;
-use std::io;
-
-const RUST_DERIVE_FUNPTR_LIMIT: usize = 12;
-
-/// What kind of a function are we looking at?
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum FunctionKind {
-    /// A plain, free function.
-    Function,
-    /// A method of some kind.
-    Method(MethodKind),
-}
-
-impl FunctionKind {
-    /// Given a clang cursor, return the kind of function it represents, or
-    /// `None` otherwise.
-    pub fn from_cursor(cursor: &clang::Cursor) -> Option<FunctionKind> {
-        // FIXME(emilio): Deduplicate logic with `ir::comp`.
-        Some(match cursor.kind() {
-            clang_sys::CXCursor_FunctionDecl => FunctionKind::Function,
-            clang_sys::CXCursor_Constructor => {
-                FunctionKind::Method(MethodKind::Constructor)
-            }
-            clang_sys::CXCursor_Destructor => {
-                FunctionKind::Method(if cursor.method_is_virtual() {
-                    MethodKind::VirtualDestructor {
-                        pure_virtual: cursor.method_is_pure_virtual(),
-                    }
-                } else {
-                    MethodKind::Destructor
-                })
-            }
-            clang_sys::CXCursor_CXXMethod => {
-                if cursor.method_is_virtual() {
-                    FunctionKind::Method(MethodKind::Virtual {
-                        pure_virtual: cursor.method_is_pure_virtual(),
-                    })
-                } else if cursor.method_is_static() {
-                    FunctionKind::Method(MethodKind::Static)
-                } else {
-                    FunctionKind::Method(MethodKind::Normal)
-                }
-            }
-            _ => return None,
-        })
-    }
-}
-
-/// The style of linkage
-#[derive(Debug, Clone, Copy)]
-pub enum Linkage {
-    /// Externally visible and can be linked against
-    External,
-    /// Not exposed externally. 'static inline' functions will have this kind of linkage
-    Internal,
-}
-
-/// A function declaration, with a signature, arguments, and argument names.
-///
-/// The argument names vector must be the same length as the ones in the
-/// signature.
-#[derive(Debug)]
-pub struct Function {
-    /// The name of this function.
-    name: String,
-
-    /// The mangled name, that is, the symbol.
-    mangled_name: Option<String>,
-
-    /// The id pointing to the current function signature.
-    signature: TypeId,
-
-    /// The doc comment on the function, if any.
-    comment: Option<String>,
-
-    /// The kind of function this is.
-    kind: FunctionKind,
-
-    /// The linkage of the function.
-    linkage: Linkage,
-}
-
-impl Function {
-    /// Construct a new function.
-    pub fn new(
-        name: String,
-        mangled_name: Option<String>,
-        signature: TypeId,
-        comment: Option<String>,
-        kind: FunctionKind,
-        linkage: Linkage,
-    ) -> Self {
-        Function {
-            name,
-            mangled_name,
-            signature,
-            comment,
-            kind,
-            linkage,
-        }
-    }
-
-    /// Get this function's name.
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    /// Get this function's name.
-    pub fn mangled_name(&self) -> Option<&str> {
-        self.mangled_name.as_deref()
-    }
-
-    /// Get this function's signature type.
-    pub fn signature(&self) -> TypeId {
-        self.signature
-    }
-
-    /// Get this function's comment.
-    pub fn comment(&self) -> Option<&str> {
-        self.comment.as_deref()
-    }
-
-    /// Get this function's kind.
-    pub fn kind(&self) -> FunctionKind {
-        self.kind
-    }
-
-    /// Get this function's linkage.
-    pub fn linkage(&self) -> Linkage {
-        self.linkage
-    }
-}
-
-impl DotAttributes for Function {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        if let Some(ref mangled) = self.mangled_name {
-            let mangled: String =
-                mangled.chars().flat_map(|c| c.escape_default()).collect();
-            writeln!(
-                out,
-                "<tr><td>mangled name</td><td>{}</td></tr>",
-                mangled
-            )?;
-        }
-
-        Ok(())
-    }
-}
-
-/// An ABI extracted from a clang cursor.
-#[derive(Debug, Copy, Clone)]
-pub enum Abi {
-    /// The default C ABI.
-    C,
-    /// The "stdcall" ABI.
-    Stdcall,
-    /// The "fastcall" ABI.
-    Fastcall,
-    /// The "thiscall" ABI.
-    ThisCall,
-    /// The "vectorcall" ABI.
-    Vectorcall,
-    /// The "aapcs" ABI.
-    Aapcs,
-    /// The "win64" ABI.
-    Win64,
-    /// An unknown or invalid ABI.
-    Unknown(CXCallingConv),
-}
-
-impl Abi {
-    /// Returns whether this Abi is known or not.
-    fn is_unknown(&self) -> bool {
-        matches!(*self, Abi::Unknown(..))
-    }
-}
-
-impl quote::ToTokens for Abi {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        tokens.append_all(match *self {
-            Abi::C => quote! { "C" },
-            Abi::Stdcall => quote! { "stdcall" },
-            Abi::Fastcall => quote! { "fastcall" },
-            Abi::ThisCall => quote! { "thiscall" },
-            Abi::Vectorcall => quote! { "vectorcall" },
-            Abi::Aapcs => quote! { "aapcs" },
-            Abi::Win64 => quote! { "win64" },
-            Abi::Unknown(cc) => panic!(
-                "Cannot turn unknown calling convention to tokens: {:?}",
-                cc
-            ),
-        });
-    }
-}
-
-/// A function signature.
-#[derive(Debug)]
-pub struct FunctionSig {
-    /// The return type of the function.
-    return_type: TypeId,
-
-    /// The type of the arguments, optionally with the name of the argument when
-    /// declared.
-    argument_types: Vec<(Option<String>, TypeId)>,
-
-    /// Whether this function is variadic.
-    is_variadic: bool,
-    is_divergent: bool,
-
-    /// Whether this function's return value must be used.
-    must_use: bool,
-
-    /// The ABI of this function.
-    abi: Abi,
-}
-
-fn get_abi(cc: CXCallingConv) -> Abi {
-    use clang_sys::*;
-    match cc {
-        CXCallingConv_Default => Abi::C,
-        CXCallingConv_C => Abi::C,
-        CXCallingConv_X86StdCall => Abi::Stdcall,
-        CXCallingConv_X86FastCall => Abi::Fastcall,
-        CXCallingConv_X86ThisCall => Abi::ThisCall,
-        CXCallingConv_X86VectorCall => Abi::Vectorcall,
-        CXCallingConv_AAPCS => Abi::Aapcs,
-        CXCallingConv_X86_64Win64 => Abi::Win64,
-        other => Abi::Unknown(other),
-    }
-}
-
-/// Get the mangled name for the cursor's referent.
-pub fn cursor_mangling(
-    ctx: &BindgenContext,
-    cursor: &clang::Cursor,
-) -> Option<String> {
-    if !ctx.options().enable_mangling {
-        return None;
-    }
-
-    // We early return here because libclang may crash in some case
-    // if we pass in a variable inside a partial specialized template.
-    // See rust-lang/rust-bindgen#67, and rust-lang/rust-bindgen#462.
-    if cursor.is_in_non_fully_specialized_template() {
-        return None;
-    }
-
-    let is_destructor = cursor.kind() == clang_sys::CXCursor_Destructor;
-    if let Ok(mut manglings) = cursor.cxx_manglings() {
-        while let Some(m) = manglings.pop() {
-            // Only generate the destructor group 1, see below.
-            if is_destructor && !m.ends_with("D1Ev") {
-                continue;
-            }
-
-            return Some(m);
-        }
-    }
-
-    let mut mangling = cursor.mangling();
-    if mangling.is_empty() {
-        return None;
-    }
-
-    if is_destructor {
-        // With old (3.8-) libclang versions, and the Itanium ABI, clang returns
-        // the "destructor group 0" symbol, which means that it'll try to free
-        // memory, which definitely isn't what we want.
-        //
-        // Explicitly force the destructor group 1 symbol.
-        //
-        // See http://refspecs.linuxbase.org/cxxabi-1.83.html#mangling-special
-        // for the reference, and http://stackoverflow.com/a/6614369/1091587 for
-        // a more friendly explanation.
-        //
-        // We don't need to do this for constructors since clang seems to always
-        // have returned the C1 constructor.
-        //
-        // FIXME(emilio): Can a legit symbol in other ABIs end with this string?
-        // I don't think so, but if it can this would become a linker error
-        // anyway, not an invalid free at runtime.
-        //
-        // TODO(emilio, #611): Use cpp_demangle if this becomes nastier with
-        // time.
-        if mangling.ends_with("D0Ev") {
-            let new_len = mangling.len() - 4;
-            mangling.truncate(new_len);
-            mangling.push_str("D1Ev");
-        }
-    }
-
-    Some(mangling)
-}
-
-fn args_from_ty_and_cursor(
-    ty: &clang::Type,
-    cursor: &clang::Cursor,
-    ctx: &mut BindgenContext,
-) -> Vec<(Option<String>, TypeId)> {
-    let cursor_args = cursor.args().unwrap_or_default().into_iter();
-    let type_args = ty.args().unwrap_or_default().into_iter();
-
-    // Argument types can be found in either the cursor or the type, but argument names may only be
-    // found on the cursor. We often have access to both a type and a cursor for each argument, but
-    // in some cases we may only have one.
-    //
-    // Prefer using the type as the source of truth for the argument's type, but fall back to
-    // inspecting the cursor (this happens for Objective C interfaces).
-    //
-    // Prefer using the cursor for the argument's type, but fall back to using the parent's cursor
-    // (this happens for function pointer return types).
-    cursor_args
-        .map(Some)
-        .chain(std::iter::repeat(None))
-        .zip(type_args.map(Some).chain(std::iter::repeat(None)))
-        .take_while(|(cur, ty)| cur.is_some() || ty.is_some())
-        .map(|(arg_cur, arg_ty)| {
-            let name = arg_cur.map(|a| a.spelling()).and_then(|name| {
-                if name.is_empty() {
-                    None
-                } else {
-                    Some(name)
-                }
-            });
-
-            let cursor = arg_cur.unwrap_or(*cursor);
-            let ty = arg_ty.unwrap_or_else(|| cursor.cur_type());
-            (name, Item::from_ty_or_ref(ty, cursor, None, ctx))
-        })
-        .collect()
-}
-
-impl FunctionSig {
-    /// Construct a new function signature.
-    pub fn new(
-        return_type: TypeId,
-        argument_types: Vec<(Option<String>, TypeId)>,
-        is_variadic: bool,
-        is_divergent: bool,
-        must_use: bool,
-        abi: Abi,
-    ) -> Self {
-        FunctionSig {
-            return_type,
-            argument_types,
-            is_variadic,
-            is_divergent,
-            must_use,
-            abi,
-        }
-    }
-
-    /// Construct a new function signature from the given Clang type.
-    pub fn from_ty(
-        ty: &clang::Type,
-        cursor: &clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Result<Self, ParseError> {
-        use clang_sys::*;
-        debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
-
-        // Skip function templates
-        let kind = cursor.kind();
-        if kind == CXCursor_FunctionTemplate {
-            return Err(ParseError::Continue);
-        }
-
-        let spelling = cursor.spelling();
-
-        // Don't parse operatorxx functions in C++
-        let is_operator = |spelling: &str| {
-            spelling.starts_with("operator") &&
-                !clang::is_valid_identifier(spelling)
-        };
-        if is_operator(&spelling) {
-            return Err(ParseError::Continue);
-        }
-
-        // Constructors of non-type template parameter classes for some reason
-        // include the template parameter in their name. Just skip them, since
-        // we don't handle well non-type template parameters anyway.
-        if (kind == CXCursor_Constructor || kind == CXCursor_Destructor) &&
-            spelling.contains('<')
-        {
-            return Err(ParseError::Continue);
-        }
-
-        let cursor = if cursor.is_valid() {
-            *cursor
-        } else {
-            ty.declaration()
-        };
-
-        let mut args = match kind {
-            CXCursor_FunctionDecl |
-            CXCursor_Constructor |
-            CXCursor_CXXMethod |
-            CXCursor_ObjCInstanceMethodDecl |
-            CXCursor_ObjCClassMethodDecl => {
-                args_from_ty_and_cursor(ty, &cursor, ctx)
-            }
-            _ => {
-                // For non-CXCursor_FunctionDecl, visiting the cursor's children
-                // is the only reliable way to get parameter names.
-                let mut args = vec![];
-                cursor.visit(|c| {
-                    if c.kind() == CXCursor_ParmDecl {
-                        let ty =
-                            Item::from_ty_or_ref(c.cur_type(), c, None, ctx);
-                        let name = c.spelling();
-                        let name =
-                            if name.is_empty() { None } else { Some(name) };
-                        args.push((name, ty));
-                    }
-                    CXChildVisit_Continue
-                });
-
-                if args.is_empty() {
-                    // FIXME(emilio): Sometimes libclang doesn't expose the
-                    // right AST for functions tagged as stdcall and such...
-                    //
-                    // https://bugs.llvm.org/show_bug.cgi?id=45919
-                    args_from_ty_and_cursor(ty, &cursor, ctx)
-                } else {
-                    args
-                }
-            }
-        };
-
-        let (must_use, mut is_divergent) =
-            if ctx.options().enable_function_attribute_detection {
-                let [must_use, no_return, no_return_cpp] = cursor.has_attrs(&[
-                    Attribute::MUST_USE,
-                    Attribute::NO_RETURN,
-                    Attribute::NO_RETURN_CPP,
-                ]);
-                (must_use, no_return || no_return_cpp)
-            } else {
-                Default::default()
-            };
-
-        // This looks easy to break but the clang parser keeps the type spelling clean even if
-        // other attributes are added.
-        is_divergent =
-            is_divergent || ty.spelling().contains("__attribute__((noreturn))");
-
-        let is_method = kind == CXCursor_CXXMethod;
-        let is_constructor = kind == CXCursor_Constructor;
-        let is_destructor = kind == CXCursor_Destructor;
-        if (is_constructor || is_destructor || is_method) &&
-            cursor.lexical_parent() != cursor.semantic_parent()
-        {
-            // Only parse constructors once.
-            return Err(ParseError::Continue);
-        }
-
-        if is_method || is_constructor || is_destructor {
-            let is_const = is_method && cursor.method_is_const();
-            let is_virtual = is_method && cursor.method_is_virtual();
-            let is_static = is_method && cursor.method_is_static();
-            if !is_static && !is_virtual {
-                let parent = cursor.semantic_parent();
-                let class = Item::parse(parent, None, ctx)
-                    .expect("Expected to parse the class");
-                // The `class` most likely is not finished parsing yet, so use
-                // the unchecked variant.
-                let class = class.as_type_id_unchecked();
-
-                let class = if is_const {
-                    let const_class_id = ctx.next_item_id();
-                    ctx.build_const_wrapper(
-                        const_class_id,
-                        class,
-                        None,
-                        &parent.cur_type(),
-                    )
-                } else {
-                    class
-                };
-
-                let ptr =
-                    Item::builtin_type(TypeKind::Pointer(class), false, ctx);
-                args.insert(0, (Some("this".into()), ptr));
-            } else if is_virtual {
-                let void = Item::builtin_type(TypeKind::Void, false, ctx);
-                let ptr =
-                    Item::builtin_type(TypeKind::Pointer(void), false, ctx);
-                args.insert(0, (Some("this".into()), ptr));
-            }
-        }
-
-        let ty_ret_type = if kind == CXCursor_ObjCInstanceMethodDecl ||
-            kind == CXCursor_ObjCClassMethodDecl
-        {
-            ty.ret_type()
-                .or_else(|| cursor.ret_type())
-                .ok_or(ParseError::Continue)?
-        } else {
-            ty.ret_type().ok_or(ParseError::Continue)?
-        };
-
-        let ret = if is_constructor && ctx.is_target_wasm32() {
-            // Constructors in Clang wasm32 target return a pointer to the object
-            // being constructed.
-            let void = Item::builtin_type(TypeKind::Void, false, ctx);
-            Item::builtin_type(TypeKind::Pointer(void), false, ctx)
-        } else {
-            Item::from_ty_or_ref(ty_ret_type, cursor, None, ctx)
-        };
-
-        // Clang plays with us at "find the calling convention", see #549 and
-        // co. This seems to be a better fix than that commit.
-        let mut call_conv = ty.call_conv();
-        if let Some(ty) = cursor.cur_type().canonical_type().pointee_type() {
-            let cursor_call_conv = ty.call_conv();
-            if cursor_call_conv != CXCallingConv_Invalid {
-                call_conv = cursor_call_conv;
-            }
-        }
-        let abi = get_abi(call_conv);
-
-        if abi.is_unknown() {
-            warn!("Unknown calling convention: {:?}", call_conv);
-        }
-
-        Ok(Self::new(
-            ret,
-            args,
-            ty.is_variadic(),
-            is_divergent,
-            must_use,
-            abi,
-        ))
-    }
-
-    /// Get this function signature's return type.
-    pub fn return_type(&self) -> TypeId {
-        self.return_type
-    }
-
-    /// Get this function signature's argument (name, type) pairs.
-    pub fn argument_types(&self) -> &[(Option<String>, TypeId)] {
-        &self.argument_types
-    }
-
-    /// Get this function signature's ABI.
-    pub fn abi(&self) -> Abi {
-        self.abi
-    }
-
-    /// Is this function signature variadic?
-    pub fn is_variadic(&self) -> bool {
-        // Clang reports some functions as variadic when they *might* be
-        // variadic. We do the argument check because rust doesn't codegen well
-        // variadic functions without an initial argument.
-        self.is_variadic && !self.argument_types.is_empty()
-    }
-
-    /// Must this function's return value be used?
-    pub fn must_use(&self) -> bool {
-        self.must_use
-    }
-
-    /// Are function pointers with this signature able to derive Rust traits?
-    /// Rust only supports deriving traits for function pointers with a limited
-    /// number of parameters and a couple ABIs.
-    ///
-    /// For more details, see:
-    ///
-    /// * https://github.com/rust-lang/rust-bindgen/issues/547,
-    /// * https://github.com/rust-lang/rust/issues/38848,
-    /// * and https://github.com/rust-lang/rust/issues/40158
-    pub fn function_pointers_can_derive(&self) -> bool {
-        if self.argument_types.len() > RUST_DERIVE_FUNPTR_LIMIT {
-            return false;
-        }
-
-        matches!(self.abi, Abi::C | Abi::Unknown(..))
-    }
-
-    pub(crate) fn is_divergent(&self) -> bool {
-        self.is_divergent
-    }
-}
-
-impl ClangSubItemParser for Function {
-    fn parse(
-        cursor: clang::Cursor,
-        context: &mut BindgenContext,
-    ) -> Result<ParseResult<Self>, ParseError> {
-        use clang_sys::*;
-
-        let kind = match FunctionKind::from_cursor(&cursor) {
-            None => return Err(ParseError::Continue),
-            Some(k) => k,
-        };
-
-        debug!("Function::parse({:?}, {:?})", cursor, cursor.cur_type());
-
-        let visibility = cursor.visibility();
-        if visibility != CXVisibility_Default {
-            return Err(ParseError::Continue);
-        }
-
-        if cursor.access_specifier() == CX_CXXPrivate {
-            return Err(ParseError::Continue);
-        }
-
-        if cursor.is_inlined_function() {
-            if !context.options().generate_inline_functions {
-                return Err(ParseError::Continue);
-            }
-            if cursor.is_deleted_function() {
-                return Err(ParseError::Continue);
-            }
-        }
-
-        let linkage = cursor.linkage();
-        let linkage = match linkage {
-            CXLinkage_External | CXLinkage_UniqueExternal => Linkage::External,
-            CXLinkage_Internal => Linkage::Internal,
-            _ => return Err(ParseError::Continue),
-        };
-
-        // Grab the signature using Item::from_ty.
-        let sig = Item::from_ty(&cursor.cur_type(), cursor, None, context)?;
-
-        let mut name = cursor.spelling();
-        assert!(!name.is_empty(), "Empty function name?");
-
-        if cursor.kind() == CXCursor_Destructor {
-            // Remove the leading `~`. The alternative to this is special-casing
-            // code-generation for destructor functions, which seems less than
-            // ideal.
-            if name.starts_with('~') {
-                name.remove(0);
-            }
-
-            // Add a suffix to avoid colliding with constructors. This would be
-            // technically fine (since we handle duplicated functions/methods),
-            // but seems easy enough to handle it here.
-            name.push_str("_destructor");
-        }
-
-        let mangled_name = cursor_mangling(context, &cursor);
-        let comment = cursor.raw_comment();
-
-        let function =
-            Self::new(name, mangled_name, sig, comment, kind, linkage);
-        Ok(ParseResult::New(function, Some(cursor)))
-    }
-}
-
-impl Trace for FunctionSig {
-    type Extra = ();
-
-    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        tracer.visit_kind(self.return_type().into(), EdgeKind::FunctionReturn);
-
-        for &(_, ty) in self.argument_types() {
-            tracer.visit_kind(ty.into(), EdgeKind::FunctionParameter);
-        }
-    }
-}
diff --git a/src/ir/int.rs b/src/ir/int.rs
deleted file mode 100644
index 22838e89..00000000
--- a/src/ir/int.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-//! Intermediate representation for integral types.
-
-/// Which integral type are we dealing with?
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum IntKind {
-    /// A `bool`.
-    Bool,
-
-    /// A `signed char`.
-    SChar,
-
-    /// An `unsigned char`.
-    UChar,
-
-    /// An `wchar_t`.
-    WChar,
-
-    /// A platform-dependent `char` type, with the signedness support.
-    Char {
-        /// Whether the char is signed for the target platform.
-        is_signed: bool,
-    },
-
-    /// A `short`.
-    Short,
-
-    /// An `unsigned short`.
-    UShort,
-
-    /// An `int`.
-    Int,
-
-    /// An `unsigned int`.
-    UInt,
-
-    /// A `long`.
-    Long,
-
-    /// An `unsigned long`.
-    ULong,
-
-    /// A `long long`.
-    LongLong,
-
-    /// An `unsigned long long`.
-    ULongLong,
-
-    /// A 8-bit signed integer.
-    I8,
-
-    /// A 8-bit unsigned integer.
-    U8,
-
-    /// A 16-bit signed integer.
-    I16,
-
-    /// Either a `char16_t` or a `wchar_t`.
-    U16,
-
-    /// A 32-bit signed integer.
-    I32,
-
-    /// A 32-bit unsigned integer.
-    U32,
-
-    /// A 64-bit signed integer.
-    I64,
-
-    /// A 64-bit unsigned integer.
-    U64,
-
-    /// An `int128_t`
-    I128,
-
-    /// A `uint128_t`.
-    U128,
-
-    /// A custom integer type, used to allow custom macro types depending on
-    /// range.
-    Custom {
-        /// The name of the type, which would be used without modification.
-        name: &'static str,
-        /// Whether the type is signed or not.
-        is_signed: bool,
-    },
-}
-
-impl IntKind {
-    /// Is this integral type signed?
-    pub fn is_signed(&self) -> bool {
-        use self::IntKind::*;
-        match *self {
-            // TODO(emilio): wchar_t can in theory be signed, but we have no way
-            // to know whether it is or not right now (unlike char, there's no
-            // WChar_S / WChar_U).
-            Bool | UChar | UShort | UInt | ULong | ULongLong | U8 | U16 |
-            WChar | U32 | U64 | U128 => false,
-
-            SChar | Short | Int | Long | LongLong | I8 | I16 | I32 | I64 |
-            I128 => true,
-
-            Char { is_signed } => is_signed,
-
-            Custom { is_signed, .. } => is_signed,
-        }
-    }
-
-    /// If this type has a known size, return it (in bytes). This is to
-    /// alleviate libclang sometimes not giving us a layout (like in the case
-    /// when an enum is defined inside a class with template parameters).
-    pub fn known_size(&self) -> Option<usize> {
-        use self::IntKind::*;
-        Some(match *self {
-            Bool | UChar | SChar | U8 | I8 | Char { .. } => 1,
-            U16 | I16 => 2,
-            U32 | I32 => 4,
-            U64 | I64 => 8,
-            I128 | U128 => 16,
-            _ => return None,
-        })
-    }
-
-    /// Whether this type's signedness matches the value.
-    pub fn signedness_matches(&self, val: i64) -> bool {
-        val >= 0 || self.is_signed()
-    }
-}
diff --git a/src/ir/item.rs b/src/ir/item.rs
deleted file mode 100644
index 3b15cd6e..00000000
--- a/src/ir/item.rs
+++ /dev/null
@@ -1,2018 +0,0 @@
-//! Bindgen's core intermediate representation type.
-
-use super::super::codegen::{EnumVariation, CONSTIFIED_ENUM_MODULE_REPR_NAME};
-use super::analysis::{HasVtable, HasVtableResult, Sizedness, SizednessResult};
-use super::annotations::Annotations;
-use super::comment;
-use super::comp::{CompKind, MethodKind};
-use super::context::{BindgenContext, ItemId, PartialType, TypeId};
-use super::derive::{
-    CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq,
-    CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd,
-};
-use super::dot::DotAttributes;
-use super::function::{Function, FunctionKind};
-use super::item_kind::ItemKind;
-use super::layout::Opaque;
-use super::module::Module;
-use super::template::{AsTemplateParam, TemplateParameters};
-use super::traversal::{EdgeKind, Trace, Tracer};
-use super::ty::{Type, TypeKind};
-use crate::clang;
-use crate::parse::{
-    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
-};
-use clang_sys;
-use lazycell::LazyCell;
-use regex;
-use std::cell::Cell;
-use std::collections::BTreeSet;
-use std::fmt::Write;
-use std::io;
-use std::iter;
-
-/// A trait to get the canonical name from an item.
-///
-/// This is the trait that will eventually isolate all the logic related to name
-/// mangling and that kind of stuff.
-///
-/// This assumes no nested paths, at some point I'll have to make it a more
-/// complex thing.
-///
-/// This name is required to be safe for Rust, that is, is not expected to
-/// return any rust keyword from here.
-pub trait ItemCanonicalName {
-    /// Get the canonical name for this item.
-    fn canonical_name(&self, ctx: &BindgenContext) -> String;
-}
-
-/// The same, but specifies the path that needs to be followed to reach an item.
-///
-/// To contrast with canonical_name, here's an example:
-///
-/// ```c++
-/// namespace foo {
-///     const BAR = 3;
-/// }
-/// ```
-///
-/// For bar, the canonical path is `vec!["foo", "BAR"]`, while the canonical
-/// name is just `"BAR"`.
-pub trait ItemCanonicalPath {
-    /// Get the namespace-aware canonical path for this item. This means that if
-    /// namespaces are disabled, you'll get a single item, and otherwise you get
-    /// the whole path.
-    fn namespace_aware_canonical_path(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Vec<String>;
-
-    /// Get the canonical path for this item.
-    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String>;
-}
-
-/// A trait for determining if some IR thing is opaque or not.
-pub trait IsOpaque {
-    /// Extra context the IR thing needs to determine if it is opaque or not.
-    type Extra;
-
-    /// Returns `true` if the thing is opaque, and `false` otherwise.
-    ///
-    /// May only be called when `ctx` is in the codegen phase.
-    fn is_opaque(&self, ctx: &BindgenContext, extra: &Self::Extra) -> bool;
-}
-
-/// A trait for determining if some IR thing has type parameter in array or not.
-pub trait HasTypeParamInArray {
-    /// Returns `true` if the thing has Array, and `false` otherwise.
-    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait for determining if some IR thing has float or not.
-pub trait HasFloat {
-    /// Returns `true` if the thing has float, and `false` otherwise.
-    fn has_float(&self, ctx: &BindgenContext) -> bool;
-}
-
-/// A trait for iterating over an item and its parents and up its ancestor chain
-/// up to (but not including) the implicit root module.
-pub trait ItemAncestors {
-    /// Get an iterable over this item's ancestors.
-    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a>;
-}
-
-#[cfg(testing_only_extra_assertions)]
-type DebugOnlyItemSet = ItemSet;
-
-#[cfg(not(testing_only_extra_assertions))]
-struct DebugOnlyItemSet;
-
-#[cfg(not(testing_only_extra_assertions))]
-impl DebugOnlyItemSet {
-    fn new() -> Self {
-        DebugOnlyItemSet
-    }
-
-    fn contains(&self, _id: &ItemId) -> bool {
-        false
-    }
-
-    fn insert(&mut self, _id: ItemId) {}
-}
-
-/// An iterator over an item and its ancestors.
-pub struct ItemAncestorsIter<'a> {
-    item: ItemId,
-    ctx: &'a BindgenContext,
-    seen: DebugOnlyItemSet,
-}
-
-impl<'a> ItemAncestorsIter<'a> {
-    fn new<Id: Into<ItemId>>(ctx: &'a BindgenContext, id: Id) -> Self {
-        ItemAncestorsIter {
-            item: id.into(),
-            ctx,
-            seen: DebugOnlyItemSet::new(),
-        }
-    }
-}
-
-impl<'a> Iterator for ItemAncestorsIter<'a> {
-    type Item = ItemId;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let item = self.ctx.resolve_item(self.item);
-
-        if item.parent_id() == self.item {
-            None
-        } else {
-            self.item = item.parent_id();
-
-            extra_assert!(!self.seen.contains(&item.id()));
-            self.seen.insert(item.id());
-
-            Some(item.id())
-        }
-    }
-}
-
-impl<T> AsTemplateParam for T
-where
-    T: Copy + Into<ItemId>,
-{
-    type Extra = ();
-
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> Option<TypeId> {
-        ctx.resolve_item((*self).into()).as_template_param(ctx, &())
-    }
-}
-
-impl AsTemplateParam for Item {
-    type Extra = ();
-
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        _: &(),
-    ) -> Option<TypeId> {
-        self.kind.as_template_param(ctx, self)
-    }
-}
-
-impl AsTemplateParam for ItemKind {
-    type Extra = Item;
-
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> Option<TypeId> {
-        match *self {
-            ItemKind::Type(ref ty) => ty.as_template_param(ctx, item),
-            ItemKind::Module(..) |
-            ItemKind::Function(..) |
-            ItemKind::Var(..) => None,
-        }
-    }
-}
-
-impl<T> ItemCanonicalName for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn canonical_name(&self, ctx: &BindgenContext) -> String {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.resolve_item(*self).canonical_name(ctx)
-    }
-}
-
-impl<T> ItemCanonicalPath for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn namespace_aware_canonical_path(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Vec<String> {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.resolve_item(*self).namespace_aware_canonical_path(ctx)
-    }
-
-    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.resolve_item(*self).canonical_path(ctx)
-    }
-}
-
-impl<T> ItemAncestors for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a> {
-        ItemAncestorsIter::new(ctx, *self)
-    }
-}
-
-impl ItemAncestors for Item {
-    fn ancestors<'a>(&self, ctx: &'a BindgenContext) -> ItemAncestorsIter<'a> {
-        self.id().ancestors(ctx)
-    }
-}
-
-impl<Id> Trace for Id
-where
-    Id: Copy + Into<ItemId>,
-{
-    type Extra = ();
-
-    fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, extra: &())
-    where
-        T: Tracer,
-    {
-        ctx.resolve_item(*self).trace(ctx, tracer, extra);
-    }
-}
-
-impl Trace for Item {
-    type Extra = ();
-
-    fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, _extra: &())
-    where
-        T: Tracer,
-    {
-        // Even if this item is blocklisted/hidden, we want to trace it. It is
-        // traversal iterators' consumers' responsibility to filter items as
-        // needed. Generally, this filtering happens in the implementation of
-        // `Iterator` for `allowlistedItems`. Fully tracing blocklisted items is
-        // necessary for things like the template parameter usage analysis to
-        // function correctly.
-
-        match *self.kind() {
-            ItemKind::Type(ref ty) => {
-                // There are some types, like resolved type references, where we
-                // don't want to stop collecting types even though they may be
-                // opaque.
-                if ty.should_be_traced_unconditionally() ||
-                    !self.is_opaque(ctx, &())
-                {
-                    ty.trace(ctx, tracer, self);
-                }
-            }
-            ItemKind::Function(ref fun) => {
-                // Just the same way, it has not real meaning for a function to
-                // be opaque, so we trace across it.
-                tracer.visit(fun.signature().into());
-            }
-            ItemKind::Var(ref var) => {
-                tracer.visit_kind(var.ty().into(), EdgeKind::VarType);
-            }
-            ItemKind::Module(_) => {
-                // Module -> children edges are "weak", and we do not want to
-                // trace them. If we did, then allowlisting wouldn't work as
-                // expected: everything in every module would end up
-                // allowlisted.
-                //
-                // TODO: make a new edge kind for module -> children edges and
-                // filter them during allowlisting traversals.
-            }
-        }
-    }
-}
-
-impl CanDeriveDebug for Item {
-    fn can_derive_debug(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_debug(ctx)
-    }
-}
-
-impl CanDeriveDefault for Item {
-    fn can_derive_default(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_default(ctx)
-    }
-}
-
-impl CanDeriveCopy for Item {
-    fn can_derive_copy(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_copy(ctx)
-    }
-}
-
-impl CanDeriveHash for Item {
-    fn can_derive_hash(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_hash(ctx)
-    }
-}
-
-impl CanDerivePartialOrd for Item {
-    fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_partialord(ctx)
-    }
-}
-
-impl CanDerivePartialEq for Item {
-    fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_partialeq(ctx)
-    }
-}
-
-impl CanDeriveEq for Item {
-    fn can_derive_eq(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_eq(ctx)
-    }
-}
-
-impl CanDeriveOrd for Item {
-    fn can_derive_ord(&self, ctx: &BindgenContext) -> bool {
-        self.id().can_derive_ord(ctx)
-    }
-}
-
-/// An item is the base of the bindgen representation, it can be either a
-/// module, a type, a function, or a variable (see `ItemKind` for more
-/// information).
-///
-/// Items refer to each other by `ItemId`. Every item has its parent's
-/// id. Depending on the kind of item this is, it may also refer to other items,
-/// such as a compound type item referring to other types. Collectively, these
-/// references form a graph.
-///
-/// The entry-point to this graph is the "root module": a meta-item used to hold
-/// all top-level items.
-///
-/// An item may have a comment, and annotations (see the `annotations` module).
-///
-/// Note that even though we parse all the types of annotations in comments, not
-/// all of them apply to every item. Those rules are described in the
-/// `annotations` module.
-#[derive(Debug)]
-pub struct Item {
-    /// This item's id.
-    id: ItemId,
-
-    /// The item's local id, unique only amongst its siblings. Only used for
-    /// anonymous items.
-    ///
-    /// Lazily initialized in local_id().
-    ///
-    /// Note that only structs, unions, and enums get a local type id. In any
-    /// case this is an implementation detail.
-    local_id: LazyCell<usize>,
-
-    /// The next local id to use for a child or template instantiation.
-    next_child_local_id: Cell<usize>,
-
-    /// A cached copy of the canonical name, as returned by `canonical_name`.
-    ///
-    /// This is a fairly used operation during codegen so this makes bindgen
-    /// considerably faster in those cases.
-    canonical_name: LazyCell<String>,
-
-    /// The path to use for allowlisting and other name-based checks, as
-    /// returned by `path_for_allowlisting`, lazily constructed.
-    path_for_allowlisting: LazyCell<Vec<String>>,
-
-    /// A doc comment over the item, if any.
-    comment: Option<String>,
-    /// Annotations extracted from the doc comment, or the default ones
-    /// otherwise.
-    annotations: Annotations,
-    /// An item's parent id. This will most likely be a class where this item
-    /// was declared, or a module, etc.
-    ///
-    /// All the items have a parent, except the root module, in which case the
-    /// parent id is its own id.
-    parent_id: ItemId,
-    /// The item kind.
-    kind: ItemKind,
-    /// The source location of the item.
-    location: Option<clang::SourceLocation>,
-}
-
-impl AsRef<ItemId> for Item {
-    fn as_ref(&self) -> &ItemId {
-        &self.id
-    }
-}
-
-impl Item {
-    /// Construct a new `Item`.
-    pub fn new(
-        id: ItemId,
-        comment: Option<String>,
-        annotations: Option<Annotations>,
-        parent_id: ItemId,
-        kind: ItemKind,
-        location: Option<clang::SourceLocation>,
-    ) -> Self {
-        debug_assert!(id != parent_id || kind.is_module());
-        Item {
-            id,
-            local_id: LazyCell::new(),
-            next_child_local_id: Cell::new(1),
-            canonical_name: LazyCell::new(),
-            path_for_allowlisting: LazyCell::new(),
-            parent_id,
-            comment,
-            annotations: annotations.unwrap_or_default(),
-            kind,
-            location,
-        }
-    }
-
-    /// Construct a new opaque item type.
-    pub fn new_opaque_type(
-        with_id: ItemId,
-        ty: &clang::Type,
-        ctx: &mut BindgenContext,
-    ) -> TypeId {
-        let location = ty.declaration().location();
-        let ty = Opaque::from_clang_ty(ty, ctx);
-        let kind = ItemKind::Type(ty);
-        let parent = ctx.root_module().into();
-        ctx.add_item(
-            Item::new(with_id, None, None, parent, kind, Some(location)),
-            None,
-            None,
-        );
-        with_id.as_type_id_unchecked()
-    }
-
-    /// Get this `Item`'s identifier.
-    pub fn id(&self) -> ItemId {
-        self.id
-    }
-
-    /// Get this `Item`'s parent's identifier.
-    ///
-    /// For the root module, the parent's ID is its own ID.
-    pub fn parent_id(&self) -> ItemId {
-        self.parent_id
-    }
-
-    /// Set this item's parent id.
-    ///
-    /// This is only used so replacements get generated in the proper module.
-    pub fn set_parent_for_replacement<Id: Into<ItemId>>(&mut self, id: Id) {
-        self.parent_id = id.into();
-    }
-
-    /// Returns the depth this item is indented to.
-    ///
-    /// FIXME(emilio): This may need fixes for the enums within modules stuff.
-    pub fn codegen_depth(&self, ctx: &BindgenContext) -> usize {
-        if !ctx.options().enable_cxx_namespaces {
-            return 0;
-        }
-
-        self.ancestors(ctx)
-            .filter(|id| {
-                ctx.resolve_item(*id).as_module().map_or(false, |module| {
-                    !module.is_inline() ||
-                        ctx.options().conservative_inline_namespaces
-                })
-            })
-            .count() +
-            1
-    }
-
-    /// Get this `Item`'s comment, if it has any, already preprocessed and with
-    /// the right indentation.
-    pub fn comment(&self, ctx: &BindgenContext) -> Option<String> {
-        if !ctx.options().generate_comments {
-            return None;
-        }
-
-        self.comment.as_ref().map(|comment| {
-            comment::preprocess(comment, self.codegen_depth(ctx))
-        })
-    }
-
-    /// What kind of item is this?
-    pub fn kind(&self) -> &ItemKind {
-        &self.kind
-    }
-
-    /// Get a mutable reference to this item's kind.
-    pub fn kind_mut(&mut self) -> &mut ItemKind {
-        &mut self.kind
-    }
-
-    /// Where in the source is this item located?
-    pub fn location(&self) -> Option<&clang::SourceLocation> {
-        self.location.as_ref()
-    }
-
-    /// Get an identifier that differentiates this item from its siblings.
-    ///
-    /// This should stay relatively stable in the face of code motion outside or
-    /// below this item's lexical scope, meaning that this can be useful for
-    /// generating relatively stable identifiers within a scope.
-    pub fn local_id(&self, ctx: &BindgenContext) -> usize {
-        *self.local_id.borrow_with(|| {
-            let parent = ctx.resolve_item(self.parent_id);
-            parent.next_child_local_id()
-        })
-    }
-
-    /// Get an identifier that differentiates a child of this item of other
-    /// related items.
-    ///
-    /// This is currently used for anonymous items, and template instantiation
-    /// tests, in both cases in order to reduce noise when system headers are at
-    /// place.
-    pub fn next_child_local_id(&self) -> usize {
-        let local_id = self.next_child_local_id.get();
-        self.next_child_local_id.set(local_id + 1);
-        local_id
-    }
-
-    /// Returns whether this item is a top-level item, from the point of view of
-    /// bindgen.
-    ///
-    /// This point of view changes depending on whether namespaces are enabled
-    /// or not. That way, in the following example:
-    ///
-    /// ```c++
-    /// namespace foo {
-    ///     static int var;
-    /// }
-    /// ```
-    ///
-    /// `var` would be a toplevel item if namespaces are disabled, but won't if
-    /// they aren't.
-    ///
-    /// This function is used to determine when the codegen phase should call
-    /// `codegen` on an item, since any item that is not top-level will be
-    /// generated by its parent.
-    pub fn is_toplevel(&self, ctx: &BindgenContext) -> bool {
-        // FIXME: Workaround for some types falling behind when parsing weird
-        // stl classes, for example.
-        if ctx.options().enable_cxx_namespaces &&
-            self.kind().is_module() &&
-            self.id() != ctx.root_module()
-        {
-            return false;
-        }
-
-        let mut parent = self.parent_id;
-        loop {
-            let parent_item = match ctx.resolve_item_fallible(parent) {
-                Some(item) => item,
-                None => return false,
-            };
-
-            if parent_item.id() == ctx.root_module() {
-                return true;
-            } else if ctx.options().enable_cxx_namespaces ||
-                !parent_item.kind().is_module()
-            {
-                return false;
-            }
-
-            parent = parent_item.parent_id();
-        }
-    }
-
-    /// Get a reference to this item's underlying `Type`. Panic if this is some
-    /// other kind of item.
-    pub fn expect_type(&self) -> &Type {
-        self.kind().expect_type()
-    }
-
-    /// Get a reference to this item's underlying `Type`, or `None` if this is
-    /// some other kind of item.
-    pub fn as_type(&self) -> Option<&Type> {
-        self.kind().as_type()
-    }
-
-    /// Get a reference to this item's underlying `Function`. Panic if this is
-    /// some other kind of item.
-    pub fn expect_function(&self) -> &Function {
-        self.kind().expect_function()
-    }
-
-    /// Is this item a module?
-    pub fn is_module(&self) -> bool {
-        matches!(self.kind, ItemKind::Module(..))
-    }
-
-    /// Get this item's annotations.
-    pub fn annotations(&self) -> &Annotations {
-        &self.annotations
-    }
-
-    /// Whether this item should be blocklisted.
-    ///
-    /// This may be due to either annotations or to other kind of configuration.
-    pub fn is_blocklisted(&self, ctx: &BindgenContext) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        if self.annotations.hide() {
-            return true;
-        }
-
-        if !ctx.options().blocklisted_files.is_empty() {
-            if let Some(location) = &self.location {
-                let (file, _, _, _) = location.location();
-                if let Some(filename) = file.name() {
-                    if ctx.options().blocklisted_files.matches(&filename) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        let path = self.path_for_allowlisting(ctx);
-        let name = path[1..].join("::");
-        ctx.options().blocklisted_items.matches(&name) ||
-            match self.kind {
-                ItemKind::Type(..) => {
-                    ctx.options().blocklisted_types.matches(&name) ||
-                        ctx.is_replaced_type(path, self.id)
-                }
-                ItemKind::Function(..) => {
-                    ctx.options().blocklisted_functions.matches(&name)
-                }
-                // TODO: Add constant / namespace blocklisting?
-                ItemKind::Var(..) | ItemKind::Module(..) => false,
-            }
-    }
-
-    /// Is this a reference to another type?
-    pub fn is_type_ref(&self) -> bool {
-        self.as_type().map_or(false, |ty| ty.is_type_ref())
-    }
-
-    /// Is this item a var type?
-    pub fn is_var(&self) -> bool {
-        matches!(*self.kind(), ItemKind::Var(..))
-    }
-
-    /// Take out item NameOptions
-    pub fn name<'a>(&'a self, ctx: &'a BindgenContext) -> NameOptions<'a> {
-        NameOptions::new(self, ctx)
-    }
-
-    /// Get the target item id for name generation.
-    fn name_target(&self, ctx: &BindgenContext) -> ItemId {
-        let mut targets_seen = DebugOnlyItemSet::new();
-        let mut item = self;
-
-        loop {
-            extra_assert!(!targets_seen.contains(&item.id()));
-            targets_seen.insert(item.id());
-
-            if self.annotations().use_instead_of().is_some() {
-                return self.id();
-            }
-
-            match *item.kind() {
-                ItemKind::Type(ref ty) => match *ty.kind() {
-                    TypeKind::ResolvedTypeRef(inner) => {
-                        item = ctx.resolve_item(inner);
-                    }
-                    TypeKind::TemplateInstantiation(ref inst) => {
-                        item = ctx.resolve_item(inst.template_definition());
-                    }
-                    _ => return item.id(),
-                },
-                _ => return item.id(),
-            }
-        }
-    }
-
-    /// Create a fully disambiguated name for an item, including template
-    /// parameters if it is a type
-    pub fn full_disambiguated_name(&self, ctx: &BindgenContext) -> String {
-        let mut s = String::new();
-        let level = 0;
-        self.push_disambiguated_name(ctx, &mut s, level);
-        s
-    }
-
-    /// Helper function for full_disambiguated_name
-    fn push_disambiguated_name(
-        &self,
-        ctx: &BindgenContext,
-        to: &mut String,
-        level: u8,
-    ) {
-        to.push_str(&self.canonical_name(ctx));
-        if let ItemKind::Type(ref ty) = *self.kind() {
-            if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() {
-                to.push_str(&format!("_open{}_", level));
-                for arg in inst.template_arguments() {
-                    arg.into_resolver()
-                        .through_type_refs()
-                        .resolve(ctx)
-                        .push_disambiguated_name(ctx, to, level + 1);
-                    to.push('_');
-                }
-                to.push_str(&format!("close{}", level));
-            }
-        }
-    }
-
-    /// Get this function item's name, or `None` if this item is not a function.
-    fn func_name(&self) -> Option<&str> {
-        match *self.kind() {
-            ItemKind::Function(ref func) => Some(func.name()),
-            _ => None,
-        }
-    }
-
-    /// Get the overload index for this method. If this is not a method, return
-    /// `None`.
-    fn overload_index(&self, ctx: &BindgenContext) -> Option<usize> {
-        self.func_name().and_then(|func_name| {
-            let parent = ctx.resolve_item(self.parent_id());
-            if let ItemKind::Type(ref ty) = *parent.kind() {
-                if let TypeKind::Comp(ref ci) = *ty.kind() {
-                    // All the constructors have the same name, so no need to
-                    // resolve and check.
-                    return ci
-                        .constructors()
-                        .iter()
-                        .position(|c| *c == self.id())
-                        .or_else(|| {
-                            ci.methods()
-                                .iter()
-                                .filter(|m| {
-                                    let item = ctx.resolve_item(m.signature());
-                                    let func = item.expect_function();
-                                    func.name() == func_name
-                                })
-                                .position(|m| m.signature() == self.id())
-                        });
-                }
-            }
-
-            None
-        })
-    }
-
-    /// Get this item's base name (aka non-namespaced name).
-    fn base_name(&self, ctx: &BindgenContext) -> String {
-        if let Some(path) = self.annotations().use_instead_of() {
-            return path.last().unwrap().clone();
-        }
-
-        match *self.kind() {
-            ItemKind::Var(ref var) => var.name().to_owned(),
-            ItemKind::Module(ref module) => {
-                module.name().map(ToOwned::to_owned).unwrap_or_else(|| {
-                    format!("_bindgen_mod_{}", self.exposed_id(ctx))
-                })
-            }
-            ItemKind::Type(ref ty) => {
-                ty.sanitized_name(ctx).map(Into::into).unwrap_or_else(|| {
-                    format!("_bindgen_ty_{}", self.exposed_id(ctx))
-                })
-            }
-            ItemKind::Function(ref fun) => {
-                let mut name = fun.name().to_owned();
-
-                if let Some(idx) = self.overload_index(ctx) {
-                    if idx > 0 {
-                        write!(&mut name, "{}", idx).unwrap();
-                    }
-                }
-
-                name
-            }
-        }
-    }
-
-    fn is_anon(&self) -> bool {
-        match self.kind() {
-            ItemKind::Module(module) => module.name().is_none(),
-            ItemKind::Type(ty) => ty.name().is_none(),
-            ItemKind::Function(_) => false,
-            ItemKind::Var(_) => false,
-        }
-    }
-
-    /// Get the canonical name without taking into account the replaces
-    /// annotation.
-    ///
-    /// This is the base logic used to implement hiding and replacing via
-    /// annotations, and also to implement proper name mangling.
-    ///
-    /// The idea is that each generated type in the same "level" (read: module
-    /// or namespace) has a unique canonical name.
-    ///
-    /// This name should be derived from the immutable state contained in the
-    /// type and the parent chain, since it should be consistent.
-    ///
-    /// If `BindgenOptions::disable_nested_struct_naming` is true then returned
-    /// name is the inner most non-anonymous name plus all the anonymous base names
-    /// that follows.
-    pub fn real_canonical_name(
-        &self,
-        ctx: &BindgenContext,
-        opt: &NameOptions,
-    ) -> String {
-        let target = ctx.resolve_item(self.name_target(ctx));
-
-        // Short-circuit if the target has an override, and just use that.
-        if let Some(path) = target.annotations.use_instead_of() {
-            if ctx.options().enable_cxx_namespaces {
-                return path.last().unwrap().clone();
-            }
-            return path.join("_");
-        }
-
-        let base_name = target.base_name(ctx);
-
-        // Named template type arguments are never namespaced, and never
-        // mangled.
-        if target.is_template_param(ctx, &()) {
-            return base_name;
-        }
-
-        // Ancestors' id iter
-        let mut ids_iter = target
-            .parent_id()
-            .ancestors(ctx)
-            .filter(|id| *id != ctx.root_module())
-            .take_while(|id| {
-                // Stop iterating ancestors once we reach a non-inline namespace
-                // when opt.within_namespaces is set.
-                !opt.within_namespaces || !ctx.resolve_item(*id).is_module()
-            })
-            .filter(|id| {
-                if !ctx.options().conservative_inline_namespaces {
-                    if let ItemKind::Module(ref module) =
-                        *ctx.resolve_item(*id).kind()
-                    {
-                        return !module.is_inline();
-                    }
-                }
-
-                true
-            });
-
-        let ids: Vec<_> = if ctx.options().disable_nested_struct_naming {
-            let mut ids = Vec::new();
-
-            // If target is anonymous we need find its first named ancestor.
-            if target.is_anon() {
-                for id in ids_iter.by_ref() {
-                    ids.push(id);
-
-                    if !ctx.resolve_item(id).is_anon() {
-                        break;
-                    }
-                }
-            }
-
-            ids
-        } else {
-            ids_iter.collect()
-        };
-
-        // Concatenate this item's ancestors' names together.
-        let mut names: Vec<_> = ids
-            .into_iter()
-            .map(|id| {
-                let item = ctx.resolve_item(id);
-                let target = ctx.resolve_item(item.name_target(ctx));
-                target.base_name(ctx)
-            })
-            .filter(|name| !name.is_empty())
-            .collect();
-
-        names.reverse();
-
-        if !base_name.is_empty() {
-            names.push(base_name);
-        }
-
-        if ctx.options().c_naming {
-            if let Some(prefix) = self.c_naming_prefix() {
-                names.insert(0, prefix.to_string());
-            }
-        }
-
-        let name = names.join("_");
-
-        let name = if opt.user_mangled == UserMangled::Yes {
-            ctx.parse_callbacks()
-                .and_then(|callbacks| callbacks.item_name(&name))
-                .unwrap_or(name)
-        } else {
-            name
-        };
-
-        ctx.rust_mangle(&name).into_owned()
-    }
-
-    /// The exposed id that represents an unique id among the siblings of a
-    /// given item.
-    pub fn exposed_id(&self, ctx: &BindgenContext) -> String {
-        // Only use local ids for enums, classes, structs and union types.  All
-        // other items use their global id.
-        let ty_kind = self.kind().as_type().map(|t| t.kind());
-        if let Some(ty_kind) = ty_kind {
-            match *ty_kind {
-                TypeKind::Comp(..) |
-                TypeKind::TemplateInstantiation(..) |
-                TypeKind::Enum(..) => return self.local_id(ctx).to_string(),
-                _ => {}
-            }
-        }
-
-        // Note that this `id_` prefix prevents (really unlikely) collisions
-        // between the global id and the local id of an item with the same
-        // parent.
-        format!("id_{}", self.id().as_usize())
-    }
-
-    /// Get a reference to this item's `Module`, or `None` if this is not a
-    /// `Module` item.
-    pub fn as_module(&self) -> Option<&Module> {
-        match self.kind {
-            ItemKind::Module(ref module) => Some(module),
-            _ => None,
-        }
-    }
-
-    /// Get a mutable reference to this item's `Module`, or `None` if this is
-    /// not a `Module` item.
-    pub fn as_module_mut(&mut self) -> Option<&mut Module> {
-        match self.kind {
-            ItemKind::Module(ref mut module) => Some(module),
-            _ => None,
-        }
-    }
-
-    /// Returns whether the item is a constified module enum
-    fn is_constified_enum_module(&self, ctx: &BindgenContext) -> bool {
-        // Do not jump through aliases, except for aliases that point to a type
-        // with the same name, since we dont generate coe for them.
-        let item = self.id.into_resolver().through_type_refs().resolve(ctx);
-        let type_ = match *item.kind() {
-            ItemKind::Type(ref type_) => type_,
-            _ => return false,
-        };
-
-        match *type_.kind() {
-            TypeKind::Enum(ref enum_) => {
-                enum_.computed_enum_variation(ctx, self) ==
-                    EnumVariation::ModuleConsts
-            }
-            TypeKind::Alias(inner_id) => {
-                // TODO(emilio): Make this "hop through type aliases that aren't
-                // really generated" an option in `ItemResolver`?
-                let inner_item = ctx.resolve_item(inner_id);
-                let name = item.canonical_name(ctx);
-
-                if inner_item.canonical_name(ctx) == name {
-                    inner_item.is_constified_enum_module(ctx)
-                } else {
-                    false
-                }
-            }
-            _ => false,
-        }
-    }
-
-    /// Is this item of a kind that is enabled for code generation?
-    pub fn is_enabled_for_codegen(&self, ctx: &BindgenContext) -> bool {
-        let cc = &ctx.options().codegen_config;
-        match *self.kind() {
-            ItemKind::Module(..) => true,
-            ItemKind::Var(_) => cc.vars(),
-            ItemKind::Type(_) => cc.types(),
-            ItemKind::Function(ref f) => match f.kind() {
-                FunctionKind::Function => cc.functions(),
-                FunctionKind::Method(MethodKind::Constructor) => {
-                    cc.constructors()
-                }
-                FunctionKind::Method(MethodKind::Destructor) |
-                FunctionKind::Method(MethodKind::VirtualDestructor {
-                    ..
-                }) => cc.destructors(),
-                FunctionKind::Method(MethodKind::Static) |
-                FunctionKind::Method(MethodKind::Normal) |
-                FunctionKind::Method(MethodKind::Virtual { .. }) => {
-                    cc.methods()
-                }
-            },
-        }
-    }
-
-    /// Returns the path we should use for allowlisting / blocklisting, which
-    /// doesn't include user-mangling.
-    pub fn path_for_allowlisting(&self, ctx: &BindgenContext) -> &Vec<String> {
-        self.path_for_allowlisting
-            .borrow_with(|| self.compute_path(ctx, UserMangled::No))
-    }
-
-    fn compute_path(
-        &self,
-        ctx: &BindgenContext,
-        mangled: UserMangled,
-    ) -> Vec<String> {
-        if let Some(path) = self.annotations().use_instead_of() {
-            let mut ret =
-                vec![ctx.resolve_item(ctx.root_module()).name(ctx).get()];
-            ret.extend_from_slice(path);
-            return ret;
-        }
-
-        let target = ctx.resolve_item(self.name_target(ctx));
-        let mut path: Vec<_> = target
-            .ancestors(ctx)
-            .chain(iter::once(ctx.root_module().into()))
-            .map(|id| ctx.resolve_item(id))
-            .filter(|item| {
-                item.id() == target.id() ||
-                    item.as_module().map_or(false, |module| {
-                        !module.is_inline() ||
-                            ctx.options().conservative_inline_namespaces
-                    })
-            })
-            .map(|item| {
-                ctx.resolve_item(item.name_target(ctx))
-                    .name(ctx)
-                    .within_namespaces()
-                    .user_mangled(mangled)
-                    .get()
-            })
-            .collect();
-        path.reverse();
-        path
-    }
-
-    /// Returns a prefix for the canonical name when C naming is enabled.
-    fn c_naming_prefix(&self) -> Option<&str> {
-        let ty = match self.kind {
-            ItemKind::Type(ref ty) => ty,
-            _ => return None,
-        };
-
-        Some(match ty.kind() {
-            TypeKind::Comp(ref ci) => match ci.kind() {
-                CompKind::Struct => "struct",
-                CompKind::Union => "union",
-            },
-            TypeKind::Enum(..) => "enum",
-            _ => return None,
-        })
-    }
-
-    /// Whether this is a #[must_use] type.
-    pub fn must_use(&self, ctx: &BindgenContext) -> bool {
-        self.annotations().must_use_type() || ctx.must_use_type_by_name(self)
-    }
-}
-
-impl<T> IsOpaque for T
-where
-    T: Copy + Into<ItemId>,
-{
-    type Extra = ();
-
-    fn is_opaque(&self, ctx: &BindgenContext, _: &()) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.resolve_item((*self).into()).is_opaque(ctx, &())
-    }
-}
-
-impl IsOpaque for Item {
-    type Extra = ();
-
-    fn is_opaque(&self, ctx: &BindgenContext, _: &()) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        self.annotations.opaque() ||
-            self.as_type().map_or(false, |ty| ty.is_opaque(ctx, self)) ||
-            ctx.opaque_by_name(self.path_for_allowlisting(ctx))
-    }
-}
-
-impl<T> HasVtable for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn has_vtable(&self, ctx: &BindgenContext) -> bool {
-        let id: ItemId = (*self).into();
-        id.as_type_id(ctx).map_or(false, |id| {
-            !matches!(ctx.lookup_has_vtable(id), HasVtableResult::No)
-        })
-    }
-
-    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool {
-        let id: ItemId = (*self).into();
-        id.as_type_id(ctx).map_or(false, |id| {
-            matches!(ctx.lookup_has_vtable(id), HasVtableResult::SelfHasVtable)
-        })
-    }
-}
-
-impl HasVtable for Item {
-    fn has_vtable(&self, ctx: &BindgenContext) -> bool {
-        self.id().has_vtable(ctx)
-    }
-
-    fn has_vtable_ptr(&self, ctx: &BindgenContext) -> bool {
-        self.id().has_vtable_ptr(ctx)
-    }
-}
-
-impl<T> Sizedness for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult {
-        let id: ItemId = (*self).into();
-        id.as_type_id(ctx)
-            .map_or(SizednessResult::default(), |id| ctx.lookup_sizedness(id))
-    }
-}
-
-impl Sizedness for Item {
-    fn sizedness(&self, ctx: &BindgenContext) -> SizednessResult {
-        self.id().sizedness(ctx)
-    }
-}
-
-impl<T> HasTypeParamInArray for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.lookup_has_type_param_in_array(*self)
-    }
-}
-
-impl HasTypeParamInArray for Item {
-    fn has_type_param_in_array(&self, ctx: &BindgenContext) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.lookup_has_type_param_in_array(self.id())
-    }
-}
-
-impl<T> HasFloat for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn has_float(&self, ctx: &BindgenContext) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.lookup_has_float(*self)
-    }
-}
-
-impl HasFloat for Item {
-    fn has_float(&self, ctx: &BindgenContext) -> bool {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        ctx.lookup_has_float(self.id())
-    }
-}
-
-/// A set of items.
-pub type ItemSet = BTreeSet<ItemId>;
-
-impl DotAttributes for Item {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>{:?}</td></tr>
-                       <tr><td>name</td><td>{}</td></tr>",
-            self.id,
-            self.name(ctx).get()
-        )?;
-
-        if self.is_opaque(ctx, &()) {
-            writeln!(out, "<tr><td>opaque</td><td>true</td></tr>")?;
-        }
-
-        self.kind.dot_attributes(ctx, out)
-    }
-}
-
-impl<T> TemplateParameters for T
-where
-    T: Copy + Into<ItemId>,
-{
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
-        ctx.resolve_item_fallible(*self)
-            .map_or(vec![], |item| item.self_template_params(ctx))
-    }
-}
-
-impl TemplateParameters for Item {
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
-        self.kind.self_template_params(ctx)
-    }
-}
-
-impl TemplateParameters for ItemKind {
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
-        match *self {
-            ItemKind::Type(ref ty) => ty.self_template_params(ctx),
-            // If we start emitting bindings to explicitly instantiated
-            // functions, then we'll need to check ItemKind::Function for
-            // template params.
-            ItemKind::Function(_) | ItemKind::Module(_) | ItemKind::Var(_) => {
-                vec![]
-            }
-        }
-    }
-}
-
-// An utility function to handle recursing inside nested types.
-fn visit_child(
-    cur: clang::Cursor,
-    id: ItemId,
-    ty: &clang::Type,
-    parent_id: Option<ItemId>,
-    ctx: &mut BindgenContext,
-    result: &mut Result<TypeId, ParseError>,
-) -> clang_sys::CXChildVisitResult {
-    use clang_sys::*;
-    if result.is_ok() {
-        return CXChildVisit_Break;
-    }
-
-    *result = Item::from_ty_with_id(id, ty, cur, parent_id, ctx);
-
-    match *result {
-        Ok(..) => CXChildVisit_Break,
-        Err(ParseError::Recurse) => {
-            cur.visit(|c| visit_child(c, id, ty, parent_id, ctx, result));
-            CXChildVisit_Continue
-        }
-        Err(ParseError::Continue) => CXChildVisit_Continue,
-    }
-}
-
-impl ClangItemParser for Item {
-    fn builtin_type(
-        kind: TypeKind,
-        is_const: bool,
-        ctx: &mut BindgenContext,
-    ) -> TypeId {
-        // Feel free to add more here, I'm just lazy.
-        match kind {
-            TypeKind::Void |
-            TypeKind::Int(..) |
-            TypeKind::Pointer(..) |
-            TypeKind::Float(..) => {}
-            _ => panic!("Unsupported builtin type"),
-        }
-
-        let ty = Type::new(None, None, kind, is_const);
-        let id = ctx.next_item_id();
-        let module = ctx.root_module().into();
-        ctx.add_item(
-            Item::new(id, None, None, module, ItemKind::Type(ty), None),
-            None,
-            None,
-        );
-        id.as_type_id_unchecked()
-    }
-
-    fn parse(
-        cursor: clang::Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<ItemId, ParseError> {
-        use crate::ir::var::Var;
-        use clang_sys::*;
-
-        if !cursor.is_valid() {
-            return Err(ParseError::Continue);
-        }
-
-        let comment = cursor.raw_comment();
-        let annotations = Annotations::new(&cursor);
-
-        let current_module = ctx.current_module().into();
-        let relevant_parent_id = parent_id.unwrap_or(current_module);
-
-        macro_rules! try_parse {
-            ($what:ident) => {
-                match $what::parse(cursor, ctx) {
-                    Ok(ParseResult::New(item, declaration)) => {
-                        let id = ctx.next_item_id();
-
-                        ctx.add_item(
-                            Item::new(
-                                id,
-                                comment,
-                                annotations,
-                                relevant_parent_id,
-                                ItemKind::$what(item),
-                                Some(cursor.location()),
-                            ),
-                            declaration,
-                            Some(cursor),
-                        );
-                        return Ok(id);
-                    }
-                    Ok(ParseResult::AlreadyResolved(id)) => {
-                        return Ok(id);
-                    }
-                    Err(ParseError::Recurse) => return Err(ParseError::Recurse),
-                    Err(ParseError::Continue) => {}
-                }
-            };
-        }
-
-        try_parse!(Module);
-
-        // NOTE: Is extremely important to parse functions and vars **before**
-        // types.  Otherwise we can parse a function declaration as a type
-        // (which is legal), and lose functions to generate.
-        //
-        // In general, I'm not totally confident this split between
-        // ItemKind::Function and TypeKind::FunctionSig is totally worth it, but
-        // I guess we can try.
-        try_parse!(Function);
-        try_parse!(Var);
-
-        // Types are sort of special, so to avoid parsing template classes
-        // twice, handle them separately.
-        {
-            let definition = cursor.definition();
-            let applicable_cursor = definition.unwrap_or(cursor);
-
-            let relevant_parent_id = match definition {
-                Some(definition) => {
-                    if definition != cursor {
-                        ctx.add_semantic_parent(definition, relevant_parent_id);
-                        return Ok(Item::from_ty_or_ref(
-                            applicable_cursor.cur_type(),
-                            cursor,
-                            parent_id,
-                            ctx,
-                        )
-                        .into());
-                    }
-                    ctx.known_semantic_parent(definition)
-                        .or(parent_id)
-                        .unwrap_or_else(|| ctx.current_module().into())
-                }
-                None => relevant_parent_id,
-            };
-
-            match Item::from_ty(
-                &applicable_cursor.cur_type(),
-                applicable_cursor,
-                Some(relevant_parent_id),
-                ctx,
-            ) {
-                Ok(ty) => return Ok(ty.into()),
-                Err(ParseError::Recurse) => return Err(ParseError::Recurse),
-                Err(ParseError::Continue) => {}
-            }
-        }
-
-        // Guess how does clang treat extern "C" blocks?
-        if cursor.kind() == CXCursor_UnexposedDecl {
-            Err(ParseError::Recurse)
-        } else {
-            // We allowlist cursors here known to be unhandled, to prevent being
-            // too noisy about this.
-            match cursor.kind() {
-                CXCursor_MacroDefinition |
-                CXCursor_MacroExpansion |
-                CXCursor_UsingDeclaration |
-                CXCursor_UsingDirective |
-                CXCursor_StaticAssert |
-                CXCursor_FunctionTemplate => {
-                    debug!(
-                        "Unhandled cursor kind {:?}: {:?}",
-                        cursor.kind(),
-                        cursor
-                    );
-                }
-                CXCursor_InclusionDirective => {
-                    let file = cursor.get_included_file_name();
-                    match file {
-                        None => {
-                            warn!(
-                                "Inclusion of a nameless file in {:?}",
-                                cursor
-                            );
-                        }
-                        Some(filename) => {
-                            ctx.include_file(filename);
-                        }
-                    }
-                }
-                _ => {
-                    // ignore toplevel operator overloads
-                    let spelling = cursor.spelling();
-                    if !spelling.starts_with("operator") {
-                        warn!(
-                            "Unhandled cursor kind {:?}: {:?}",
-                            cursor.kind(),
-                            cursor
-                        );
-                    }
-                }
-            }
-
-            Err(ParseError::Continue)
-        }
-    }
-
-    fn from_ty_or_ref(
-        ty: clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> TypeId {
-        let id = ctx.next_item_id();
-        Self::from_ty_or_ref_with_id(id, ty, location, parent_id, ctx)
-    }
-
-    /// Parse a C++ type. If we find a reference to a type that has not been
-    /// defined yet, use `UnresolvedTypeRef` as a placeholder.
-    ///
-    /// This logic is needed to avoid parsing items with the incorrect parent
-    /// and it's sort of complex to explain, so I'll just point to
-    /// `tests/headers/typeref.hpp` to see the kind of constructs that forced
-    /// this.
-    ///
-    /// Typerefs are resolved once parsing is completely done, see
-    /// `BindgenContext::resolve_typerefs`.
-    fn from_ty_or_ref_with_id(
-        potential_id: ItemId,
-        ty: clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> TypeId {
-        debug!(
-            "from_ty_or_ref_with_id: {:?} {:?}, {:?}, {:?}",
-            potential_id, ty, location, parent_id
-        );
-
-        if ctx.collected_typerefs() {
-            debug!("refs already collected, resolving directly");
-            return Item::from_ty_with_id(
-                potential_id,
-                &ty,
-                location,
-                parent_id,
-                ctx,
-            )
-            .unwrap_or_else(|_| Item::new_opaque_type(potential_id, &ty, ctx));
-        }
-
-        if let Some(ty) = ctx.builtin_or_resolved_ty(
-            potential_id,
-            parent_id,
-            &ty,
-            Some(location),
-        ) {
-            debug!("{:?} already resolved: {:?}", ty, location);
-            return ty;
-        }
-
-        debug!("New unresolved type reference: {:?}, {:?}", ty, location);
-
-        let is_const = ty.is_const();
-        let kind = TypeKind::UnresolvedTypeRef(ty, location, parent_id);
-        let current_module = ctx.current_module();
-
-        ctx.add_item(
-            Item::new(
-                potential_id,
-                None,
-                None,
-                parent_id.unwrap_or_else(|| current_module.into()),
-                ItemKind::Type(Type::new(None, None, kind, is_const)),
-                Some(location.location()),
-            ),
-            None,
-            None,
-        );
-        potential_id.as_type_id_unchecked()
-    }
-
-    fn from_ty(
-        ty: &clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<TypeId, ParseError> {
-        let id = ctx.next_item_id();
-        Item::from_ty_with_id(id, ty, location, parent_id, ctx)
-    }
-
-    /// This is one of the trickiest methods you'll find (probably along with
-    /// some of the ones that handle templates in `BindgenContext`).
-    ///
-    /// This method parses a type, given the potential id of that type (if
-    /// parsing it was correct), an optional location we're scanning, which is
-    /// critical some times to obtain information, an optional parent item id,
-    /// that will, if it's `None`, become the current module id, and the
-    /// context.
-    fn from_ty_with_id(
-        id: ItemId,
-        ty: &clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<TypeId, ParseError> {
-        use clang_sys::*;
-
-        debug!(
-            "Item::from_ty_with_id: {:?}\n\
-             \tty = {:?},\n\
-             \tlocation = {:?}",
-            id, ty, location
-        );
-
-        if ty.kind() == clang_sys::CXType_Unexposed ||
-            location.cur_type().kind() == clang_sys::CXType_Unexposed
-        {
-            if ty.is_associated_type() ||
-                location.cur_type().is_associated_type()
-            {
-                return Ok(Item::new_opaque_type(id, ty, ctx));
-            }
-
-            if let Some(param_id) = Item::type_param(None, location, ctx) {
-                return Ok(ctx.build_ty_wrapper(id, param_id, None, ty));
-            }
-        }
-
-        // Treat all types that are declared inside functions as opaque. The Rust binding
-        // won't be able to do anything with them anyway.
-        //
-        // (If we don't do this check here, we can have subtle logic bugs because we generally
-        // ignore function bodies. See issue #2036.)
-        if let Some(ref parent) = ty.declaration().fallible_semantic_parent() {
-            if FunctionKind::from_cursor(parent).is_some() {
-                debug!("Skipping type declared inside function: {:?}", ty);
-                return Ok(Item::new_opaque_type(id, ty, ctx));
-            }
-        }
-
-        let decl = {
-            let canonical_def = ty.canonical_type().declaration().definition();
-            canonical_def.unwrap_or_else(|| ty.declaration())
-        };
-
-        let comment = decl.raw_comment().or_else(|| location.raw_comment());
-        let annotations =
-            Annotations::new(&decl).or_else(|| Annotations::new(&location));
-
-        if let Some(ref annotations) = annotations {
-            if let Some(replaced) = annotations.use_instead_of() {
-                ctx.replace(replaced, id);
-            }
-        }
-
-        if let Some(ty) =
-            ctx.builtin_or_resolved_ty(id, parent_id, ty, Some(location))
-        {
-            return Ok(ty);
-        }
-
-        // First, check we're not recursing.
-        let mut valid_decl = decl.kind() != CXCursor_NoDeclFound;
-        let declaration_to_look_for = if valid_decl {
-            decl.canonical()
-        } else if location.kind() == CXCursor_ClassTemplate {
-            valid_decl = true;
-            location
-        } else {
-            decl
-        };
-
-        if valid_decl {
-            if let Some(partial) = ctx
-                .currently_parsed_types()
-                .iter()
-                .find(|ty| *ty.decl() == declaration_to_look_for)
-            {
-                debug!("Avoiding recursion parsing type: {:?}", ty);
-                // Unchecked because we haven't finished this type yet.
-                return Ok(partial.id().as_type_id_unchecked());
-            }
-        }
-
-        let current_module = ctx.current_module().into();
-        let partial_ty = PartialType::new(declaration_to_look_for, id);
-        if valid_decl {
-            ctx.begin_parsing(partial_ty);
-        }
-
-        let result = Type::from_clang_ty(id, ty, location, parent_id, ctx);
-        let relevant_parent_id = parent_id.unwrap_or(current_module);
-        let ret = match result {
-            Ok(ParseResult::AlreadyResolved(ty)) => {
-                Ok(ty.as_type_id_unchecked())
-            }
-            Ok(ParseResult::New(item, declaration)) => {
-                ctx.add_item(
-                    Item::new(
-                        id,
-                        comment,
-                        annotations,
-                        relevant_parent_id,
-                        ItemKind::Type(item),
-                        Some(location.location()),
-                    ),
-                    declaration,
-                    Some(location),
-                );
-                Ok(id.as_type_id_unchecked())
-            }
-            Err(ParseError::Continue) => Err(ParseError::Continue),
-            Err(ParseError::Recurse) => {
-                debug!("Item::from_ty recursing in the ast");
-                let mut result = Err(ParseError::Recurse);
-
-                // Need to pop here, otherwise we'll get stuck.
-                //
-                // TODO: Find a nicer interface, really. Also, the
-                // declaration_to_look_for suspiciously shares a lot of
-                // logic with ir::context, so we should refactor that.
-                if valid_decl {
-                    let finished = ctx.finish_parsing();
-                    assert_eq!(*finished.decl(), declaration_to_look_for);
-                }
-
-                location.visit(|cur| {
-                    visit_child(cur, id, ty, parent_id, ctx, &mut result)
-                });
-
-                if valid_decl {
-                    let partial_ty =
-                        PartialType::new(declaration_to_look_for, id);
-                    ctx.begin_parsing(partial_ty);
-                }
-
-                // If we have recursed into the AST all we know, and we still
-                // haven't found what we've got, let's just try and make a named
-                // type.
-                //
-                // This is what happens with some template members, for example.
-                if let Err(ParseError::Recurse) = result {
-                    warn!(
-                        "Unknown type, assuming named template type: \
-                         id = {:?}; spelling = {}",
-                        id,
-                        ty.spelling()
-                    );
-                    Item::type_param(Some(id), location, ctx)
-                        .map(Ok)
-                        .unwrap_or(Err(ParseError::Recurse))
-                } else {
-                    result
-                }
-            }
-        };
-
-        if valid_decl {
-            let partial_ty = ctx.finish_parsing();
-            assert_eq!(*partial_ty.decl(), declaration_to_look_for);
-        }
-
-        ret
-    }
-
-    /// A named type is a template parameter, e.g., the "T" in Foo<T>. They're
-    /// always local so it's the only exception when there's no declaration for
-    /// a type.
-    fn type_param(
-        with_id: Option<ItemId>,
-        location: clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Option<TypeId> {
-        let ty = location.cur_type();
-
-        debug!(
-            "Item::type_param:\n\
-             \twith_id = {:?},\n\
-             \tty = {} {:?},\n\
-             \tlocation: {:?}",
-            with_id,
-            ty.spelling(),
-            ty,
-            location
-        );
-
-        if ty.kind() != clang_sys::CXType_Unexposed {
-            // If the given cursor's type's kind is not Unexposed, then we
-            // aren't looking at a template parameter. This check may need to be
-            // updated in the future if they start properly exposing template
-            // type parameters.
-            return None;
-        }
-
-        let ty_spelling = ty.spelling();
-
-        // Clang does not expose any information about template type parameters
-        // via their clang::Type, nor does it give us their canonical cursors
-        // the straightforward way. However, there are three situations from
-        // which we can find the definition of the template type parameter, if
-        // the cursor is indeed looking at some kind of a template type
-        // parameter or use of one:
-        //
-        // 1. The cursor is pointing at the template type parameter's
-        // definition. This is the trivial case.
-        //
-        //     (kind = TemplateTypeParameter, ...)
-        //
-        // 2. The cursor is pointing at a TypeRef whose referenced() cursor is
-        // situation (1).
-        //
-        //     (kind = TypeRef,
-        //      referenced = (kind = TemplateTypeParameter, ...),
-        //      ...)
-        //
-        // 3. The cursor is pointing at some use of a template type parameter
-        // (for example, in a FieldDecl), and this cursor has a child cursor
-        // whose spelling is the same as the parent's type's spelling, and whose
-        // kind is a TypeRef of the situation (2) variety.
-        //
-        //    (kind = FieldDecl,
-        //     type = (kind = Unexposed,
-        //             spelling = "T",
-        //             ...),
-        //     children =
-        //        (kind = TypeRef,
-        //         spelling = "T",
-        //         referenced = (kind = TemplateTypeParameter,
-        //                       spelling = "T",
-        //                       ...),
-        //         ...)
-        //     ...)
-        //
-        // TODO: The alternative to this hacky pattern matching would be to
-        // maintain proper scopes of template parameters while parsing and use
-        // de Brujin indices to access template parameters, which clang exposes
-        // in the cursor's type's canonical type's spelling:
-        // "type-parameter-x-y". That is probably a better approach long-term,
-        // but maintaining these scopes properly would require more changes to
-        // the whole libclang -> IR parsing code.
-
-        fn is_template_with_spelling(
-            refd: &clang::Cursor,
-            spelling: &str,
-        ) -> bool {
-            lazy_static! {
-                static ref ANON_TYPE_PARAM_RE: regex::Regex =
-                    regex::Regex::new(r"^type\-parameter\-\d+\-\d+$").unwrap();
-            }
-
-            if refd.kind() != clang_sys::CXCursor_TemplateTypeParameter {
-                return false;
-            }
-
-            let refd_spelling = refd.spelling();
-            refd_spelling == spelling ||
-                // Allow for anonymous template parameters.
-                (refd_spelling.is_empty() && ANON_TYPE_PARAM_RE.is_match(spelling.as_ref()))
-        }
-
-        let definition = if is_template_with_spelling(&location, &ty_spelling) {
-            // Situation (1)
-            location
-        } else if location.kind() == clang_sys::CXCursor_TypeRef {
-            // Situation (2)
-            match location.referenced() {
-                Some(refd)
-                    if is_template_with_spelling(&refd, &ty_spelling) =>
-                {
-                    refd
-                }
-                _ => return None,
-            }
-        } else {
-            // Situation (3)
-            let mut definition = None;
-
-            location.visit(|child| {
-                let child_ty = child.cur_type();
-                if child_ty.kind() == clang_sys::CXCursor_TypeRef &&
-                    child_ty.spelling() == ty_spelling
-                {
-                    match child.referenced() {
-                        Some(refd)
-                            if is_template_with_spelling(
-                                &refd,
-                                &ty_spelling,
-                            ) =>
-                        {
-                            definition = Some(refd);
-                            return clang_sys::CXChildVisit_Break;
-                        }
-                        _ => {}
-                    }
-                }
-
-                clang_sys::CXChildVisit_Continue
-            });
-
-            definition?
-        };
-        assert!(is_template_with_spelling(&definition, &ty_spelling));
-
-        // Named types are always parented to the root module. They are never
-        // referenced with namespace prefixes, and they can't inherit anything
-        // from their parent either, so it is simplest to just hang them off
-        // something we know will always exist.
-        let parent = ctx.root_module().into();
-
-        if let Some(id) = ctx.get_type_param(&definition) {
-            if let Some(with_id) = with_id {
-                return Some(ctx.build_ty_wrapper(
-                    with_id,
-                    id,
-                    Some(parent),
-                    &ty,
-                ));
-            } else {
-                return Some(id);
-            }
-        }
-
-        // See tests/headers/const_tparam.hpp and
-        // tests/headers/variadic_tname.hpp.
-        let name = ty_spelling.replace("const ", "").replace('.', "");
-
-        let id = with_id.unwrap_or_else(|| ctx.next_item_id());
-        let item = Item::new(
-            id,
-            None,
-            None,
-            parent,
-            ItemKind::Type(Type::named(name)),
-            Some(location.location()),
-        );
-        ctx.add_type_param(item, definition);
-        Some(id.as_type_id_unchecked())
-    }
-}
-
-impl ItemCanonicalName for Item {
-    fn canonical_name(&self, ctx: &BindgenContext) -> String {
-        debug_assert!(
-            ctx.in_codegen_phase(),
-            "You're not supposed to call this yet"
-        );
-        self.canonical_name
-            .borrow_with(|| {
-                let in_namespace = ctx.options().enable_cxx_namespaces ||
-                    ctx.options().disable_name_namespacing;
-
-                if in_namespace {
-                    self.name(ctx).within_namespaces().get()
-                } else {
-                    self.name(ctx).get()
-                }
-            })
-            .clone()
-    }
-}
-
-impl ItemCanonicalPath for Item {
-    fn namespace_aware_canonical_path(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Vec<String> {
-        let mut path = self.canonical_path(ctx);
-
-        // ASSUMPTION: (disable_name_namespacing && cxx_namespaces)
-        // is equivalent to
-        // disable_name_namespacing
-        if ctx.options().disable_name_namespacing {
-            // Only keep the last item in path
-            let split_idx = path.len() - 1;
-            path = path.split_off(split_idx);
-        } else if !ctx.options().enable_cxx_namespaces {
-            // Ignore first item "root"
-            path = vec![path[1..].join("_")];
-        }
-
-        if self.is_constified_enum_module(ctx) {
-            path.push(CONSTIFIED_ENUM_MODULE_REPR_NAME.into());
-        }
-
-        path
-    }
-
-    fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
-        self.compute_path(ctx, UserMangled::Yes)
-    }
-}
-
-/// Whether to use the user-mangled name (mangled by the `item_name` callback or
-/// not.
-///
-/// Most of the callers probably want just yes, but the ones dealing with
-/// allowlisting and blocklisting don't.
-#[derive(Copy, Clone, Debug, PartialEq)]
-enum UserMangled {
-    No,
-    Yes,
-}
-
-/// Builder struct for naming variations, which hold inside different
-/// flags for naming options.
-#[derive(Debug)]
-pub struct NameOptions<'a> {
-    item: &'a Item,
-    ctx: &'a BindgenContext,
-    within_namespaces: bool,
-    user_mangled: UserMangled,
-}
-
-impl<'a> NameOptions<'a> {
-    /// Construct a new `NameOptions`
-    pub fn new(item: &'a Item, ctx: &'a BindgenContext) -> Self {
-        NameOptions {
-            item,
-            ctx,
-            within_namespaces: false,
-            user_mangled: UserMangled::Yes,
-        }
-    }
-
-    /// Construct the name without the item's containing C++ namespaces mangled
-    /// into it. In other words, the item's name within the item's namespace.
-    pub fn within_namespaces(&mut self) -> &mut Self {
-        self.within_namespaces = true;
-        self
-    }
-
-    fn user_mangled(&mut self, user_mangled: UserMangled) -> &mut Self {
-        self.user_mangled = user_mangled;
-        self
-    }
-
-    /// Construct a name `String`
-    pub fn get(&self) -> String {
-        self.item.real_canonical_name(self.ctx, self)
-    }
-}
diff --git a/src/ir/item_kind.rs b/src/ir/item_kind.rs
deleted file mode 100644
index 4a12fef4..00000000
--- a/src/ir/item_kind.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-//! Different variants of an `Item` in our intermediate representation.
-
-use super::context::BindgenContext;
-use super::dot::DotAttributes;
-use super::function::Function;
-use super::module::Module;
-use super::ty::Type;
-use super::var::Var;
-use std::io;
-
-/// A item we parse and translate.
-#[derive(Debug)]
-pub enum ItemKind {
-    /// A module, created implicitly once (the root module), or via C++
-    /// namespaces.
-    Module(Module),
-
-    /// A type declared in any of the multiple ways it can be declared.
-    Type(Type),
-
-    /// A function or method declaration.
-    Function(Function),
-
-    /// A variable declaration, most likely a static.
-    Var(Var),
-}
-
-impl ItemKind {
-    /// Get a reference to this `ItemKind`'s underying `Module`, or `None` if it
-    /// is some other kind.
-    pub fn as_module(&self) -> Option<&Module> {
-        match *self {
-            ItemKind::Module(ref module) => Some(module),
-            _ => None,
-        }
-    }
-
-    /// Transform our `ItemKind` into a string.
-    pub fn kind_name(&self) -> &'static str {
-        match *self {
-            ItemKind::Module(..) => "Module",
-            ItemKind::Type(..) => "Type",
-            ItemKind::Function(..) => "Function",
-            ItemKind::Var(..) => "Var",
-        }
-    }
-
-    /// Is this a module?
-    pub fn is_module(&self) -> bool {
-        self.as_module().is_some()
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Module`, or panic if it
-    /// is some other kind.
-    pub fn expect_module(&self) -> &Module {
-        self.as_module().expect("Not a module")
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Function`, or `None` if
-    /// it is some other kind.
-    pub fn as_function(&self) -> Option<&Function> {
-        match *self {
-            ItemKind::Function(ref func) => Some(func),
-            _ => None,
-        }
-    }
-
-    /// Is this a function?
-    pub fn is_function(&self) -> bool {
-        self.as_function().is_some()
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Function`, or panic if
-    /// it is some other kind.
-    pub fn expect_function(&self) -> &Function {
-        self.as_function().expect("Not a function")
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Type`, or `None` if
-    /// it is some other kind.
-    pub fn as_type(&self) -> Option<&Type> {
-        match *self {
-            ItemKind::Type(ref ty) => Some(ty),
-            _ => None,
-        }
-    }
-
-    /// Get a mutable reference to this `ItemKind`'s underying `Type`, or `None`
-    /// if it is some other kind.
-    pub fn as_type_mut(&mut self) -> Option<&mut Type> {
-        match *self {
-            ItemKind::Type(ref mut ty) => Some(ty),
-            _ => None,
-        }
-    }
-
-    /// Is this a type?
-    pub fn is_type(&self) -> bool {
-        self.as_type().is_some()
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Type`, or panic if it is
-    /// some other kind.
-    pub fn expect_type(&self) -> &Type {
-        self.as_type().expect("Not a type")
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Var`, or `None` if it is
-    /// some other kind.
-    pub fn as_var(&self) -> Option<&Var> {
-        match *self {
-            ItemKind::Var(ref v) => Some(v),
-            _ => None,
-        }
-    }
-
-    /// Is this a variable?
-    pub fn is_var(&self) -> bool {
-        self.as_var().is_some()
-    }
-
-    /// Get a reference to this `ItemKind`'s underying `Var`, or panic if it is
-    /// some other kind.
-    pub fn expect_var(&self) -> &Var {
-        self.as_var().expect("Not a var")
-    }
-}
-
-impl DotAttributes for ItemKind {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(out, "<tr><td>kind</td><td>{}</td></tr>", self.kind_name())?;
-
-        match *self {
-            ItemKind::Module(ref module) => module.dot_attributes(ctx, out),
-            ItemKind::Type(ref ty) => ty.dot_attributes(ctx, out),
-            ItemKind::Function(ref func) => func.dot_attributes(ctx, out),
-            ItemKind::Var(ref var) => var.dot_attributes(ctx, out),
-        }
-    }
-}
diff --git a/src/ir/layout.rs b/src/ir/layout.rs
deleted file mode 100644
index 6f450307..00000000
--- a/src/ir/layout.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//! Intermediate representation for the physical layout of some type.
-
-use super::derive::CanDerive;
-use super::ty::{Type, TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
-use crate::clang;
-use crate::ir::context::BindgenContext;
-use std::cmp;
-
-/// A type that represents the struct layout of a type.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Layout {
-    /// The size (in bytes) of this layout.
-    pub size: usize,
-    /// The alignment (in bytes) of this layout.
-    pub align: usize,
-    /// Whether this layout's members are packed or not.
-    pub packed: bool,
-}
-
-#[test]
-fn test_layout_for_size() {
-    use std::mem;
-
-    let ptr_size = mem::size_of::<*mut ()>();
-    assert_eq!(
-        Layout::for_size_internal(ptr_size, ptr_size),
-        Layout::new(ptr_size, ptr_size)
-    );
-    assert_eq!(
-        Layout::for_size_internal(ptr_size, 3 * ptr_size),
-        Layout::new(3 * ptr_size, ptr_size)
-    );
-}
-
-impl Layout {
-    /// Gets the integer type name for a given known size.
-    pub fn known_type_for_size(
-        ctx: &BindgenContext,
-        size: usize,
-    ) -> Option<&'static str> {
-        Some(match size {
-            16 if ctx.options().rust_features.i128_and_u128 => "u128",
-            8 => "u64",
-            4 => "u32",
-            2 => "u16",
-            1 => "u8",
-            _ => return None,
-        })
-    }
-
-    /// Construct a new `Layout` with the given `size` and `align`. It is not
-    /// packed.
-    pub fn new(size: usize, align: usize) -> Self {
-        Layout {
-            size,
-            align,
-            packed: false,
-        }
-    }
-
-    fn for_size_internal(ptr_size: usize, size: usize) -> Self {
-        let mut next_align = 2;
-        while size % next_align == 0 && next_align <= ptr_size {
-            next_align *= 2;
-        }
-        Layout {
-            size,
-            align: next_align / 2,
-            packed: false,
-        }
-    }
-
-    /// Creates a non-packed layout for a given size, trying to use the maximum
-    /// alignment possible.
-    pub fn for_size(ctx: &BindgenContext, size: usize) -> Self {
-        Self::for_size_internal(ctx.target_pointer_size(), size)
-    }
-
-    /// Is this a zero-sized layout?
-    pub fn is_zero(&self) -> bool {
-        self.size == 0 && self.align == 0
-    }
-
-    /// Construct a zero-sized layout.
-    pub fn zero() -> Self {
-        Self::new(0, 0)
-    }
-
-    /// Get this layout as an opaque type.
-    pub fn opaque(&self) -> Opaque {
-        Opaque(*self)
-    }
-}
-
-/// When we are treating a type as opaque, it is just a blob with a `Layout`.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Opaque(pub Layout);
-
-impl Opaque {
-    /// Construct a new opaque type from the given clang type.
-    pub fn from_clang_ty(ty: &clang::Type, ctx: &BindgenContext) -> Type {
-        let layout = Layout::new(ty.size(ctx), ty.align(ctx));
-        let ty_kind = TypeKind::Opaque;
-        let is_const = ty.is_const();
-        Type::new(None, Some(layout), ty_kind, is_const)
-    }
-
-    /// Return the known rust type we should use to create a correctly-aligned
-    /// field with this layout.
-    pub fn known_rust_type_for_array(
-        &self,
-        ctx: &BindgenContext,
-    ) -> Option<&'static str> {
-        Layout::known_type_for_size(ctx, self.0.align)
-    }
-
-    /// Return the array size that an opaque type for this layout should have if
-    /// we know the correct type for it, or `None` otherwise.
-    pub fn array_size(&self, ctx: &BindgenContext) -> Option<usize> {
-        if self.known_rust_type_for_array(ctx).is_some() {
-            Some(self.0.size / cmp::max(self.0.align, 1))
-        } else {
-            None
-        }
-    }
-
-    /// Return `true` if this opaque layout's array size will fit within the
-    /// maximum number of array elements that Rust allows deriving traits
-    /// with. Return `false` otherwise.
-    pub fn array_size_within_derive_limit(
-        &self,
-        ctx: &BindgenContext,
-    ) -> CanDerive {
-        if self
-            .array_size(ctx)
-            .map_or(false, |size| size <= RUST_DERIVE_IN_ARRAY_LIMIT)
-        {
-            CanDerive::Yes
-        } else {
-            CanDerive::Manually
-        }
-    }
-}
diff --git a/src/ir/mod.rs b/src/ir/mod.rs
deleted file mode 100644
index 8f6a2dac..00000000
--- a/src/ir/mod.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//! The ir module defines bindgen's intermediate representation.
-//!
-//! Parsing C/C++ generates the IR, while code generation outputs Rust code from
-//! the IR.
-
-pub mod analysis;
-pub mod annotations;
-pub mod comment;
-pub mod comp;
-pub mod context;
-pub mod derive;
-pub mod dot;
-pub mod enum_ty;
-pub mod function;
-pub mod int;
-pub mod item;
-pub mod item_kind;
-pub mod layout;
-pub mod module;
-pub mod objc;
-pub mod template;
-pub mod traversal;
-pub mod ty;
-pub mod var;
diff --git a/src/ir/module.rs b/src/ir/module.rs
deleted file mode 100644
index d5aca94a..00000000
--- a/src/ir/module.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-//! Intermediate representation for modules (AKA C++ namespaces).
-
-use super::context::BindgenContext;
-use super::dot::DotAttributes;
-use super::item::ItemSet;
-use crate::clang;
-use crate::parse::{ClangSubItemParser, ParseError, ParseResult};
-use crate::parse_one;
-use std::io;
-
-/// Whether this module is inline or not.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ModuleKind {
-    /// This module is not inline.
-    Normal,
-    /// This module is inline, as in `inline namespace foo {}`.
-    Inline,
-}
-
-/// A module, as in, a C++ namespace.
-#[derive(Clone, Debug)]
-pub struct Module {
-    /// The name of the module, or none if it's anonymous.
-    name: Option<String>,
-    /// The kind of module this is.
-    kind: ModuleKind,
-    /// The children of this module, just here for convenience.
-    children: ItemSet,
-}
-
-impl Module {
-    /// Construct a new `Module`.
-    pub fn new(name: Option<String>, kind: ModuleKind) -> Self {
-        Module {
-            name,
-            kind,
-            children: ItemSet::new(),
-        }
-    }
-
-    /// Get this module's name.
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_deref()
-    }
-
-    /// Get a mutable reference to this module's children.
-    pub fn children_mut(&mut self) -> &mut ItemSet {
-        &mut self.children
-    }
-
-    /// Get this module's children.
-    pub fn children(&self) -> &ItemSet {
-        &self.children
-    }
-
-    /// Whether this namespace is inline.
-    pub fn is_inline(&self) -> bool {
-        self.kind == ModuleKind::Inline
-    }
-}
-
-impl DotAttributes for Module {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(out, "<tr><td>ModuleKind</td><td>{:?}</td></tr>", self.kind)
-    }
-}
-
-impl ClangSubItemParser for Module {
-    fn parse(
-        cursor: clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Result<ParseResult<Self>, ParseError> {
-        use clang_sys::*;
-        match cursor.kind() {
-            CXCursor_Namespace => {
-                let module_id = ctx.module(cursor);
-                ctx.with_module(module_id, |ctx| {
-                    cursor.visit(|cursor| {
-                        parse_one(ctx, cursor, Some(module_id.into()))
-                    })
-                });
-
-                Ok(ParseResult::AlreadyResolved(module_id.into()))
-            }
-            _ => Err(ParseError::Continue),
-        }
-    }
-}
diff --git a/src/ir/objc.rs b/src/ir/objc.rs
deleted file mode 100644
index 0845ad0f..00000000
--- a/src/ir/objc.rs
+++ /dev/null
@@ -1,329 +0,0 @@
-//! Objective C types
-
-use super::context::{BindgenContext, ItemId};
-use super::function::FunctionSig;
-use super::item::Item;
-use super::traversal::{Trace, Tracer};
-use super::ty::TypeKind;
-use crate::clang;
-use crate::parse::ClangItemParser;
-use clang_sys::CXChildVisit_Continue;
-use clang_sys::CXCursor_ObjCCategoryDecl;
-use clang_sys::CXCursor_ObjCClassMethodDecl;
-use clang_sys::CXCursor_ObjCClassRef;
-use clang_sys::CXCursor_ObjCInstanceMethodDecl;
-use clang_sys::CXCursor_ObjCProtocolDecl;
-use clang_sys::CXCursor_ObjCProtocolRef;
-use clang_sys::CXCursor_ObjCSuperClassRef;
-use clang_sys::CXCursor_TemplateTypeParameter;
-use proc_macro2::{Ident, Span, TokenStream};
-
-/// Objective C interface as used in TypeKind
-///
-/// Also protocols and categories are parsed as this type
-#[derive(Debug)]
-pub struct ObjCInterface {
-    /// The name
-    /// like, NSObject
-    name: String,
-
-    category: Option<String>,
-
-    is_protocol: bool,
-
-    /// The list of template names almost always, ObjectType or KeyType
-    pub template_names: Vec<String>,
-
-    /// The list of protocols that this interface conforms to.
-    pub conforms_to: Vec<ItemId>,
-
-    /// The direct parent for this interface.
-    pub parent_class: Option<ItemId>,
-
-    /// List of the methods defined in this interfae
-    methods: Vec<ObjCMethod>,
-
-    class_methods: Vec<ObjCMethod>,
-}
-
-/// The objective c methods
-#[derive(Debug)]
-pub struct ObjCMethod {
-    /// The original method selector name
-    /// like, dataWithBytes:length:
-    name: String,
-
-    /// Method name as converted to rust
-    /// like, dataWithBytes_length_
-    rust_name: String,
-
-    signature: FunctionSig,
-
-    /// Is class method?
-    is_class_method: bool,
-}
-
-impl ObjCInterface {
-    fn new(name: &str) -> ObjCInterface {
-        ObjCInterface {
-            name: name.to_owned(),
-            category: None,
-            is_protocol: false,
-            template_names: Vec::new(),
-            parent_class: None,
-            conforms_to: Vec::new(),
-            methods: Vec::new(),
-            class_methods: Vec::new(),
-        }
-    }
-
-    /// The name
-    /// like, NSObject
-    pub fn name(&self) -> &str {
-        self.name.as_ref()
-    }
-
-    /// Formats the name for rust
-    /// Can be like NSObject, but with categories might be like NSObject_NSCoderMethods
-    /// and protocols are like PNSObject
-    pub fn rust_name(&self) -> String {
-        if let Some(ref cat) = self.category {
-            format!("{}_{}", self.name(), cat)
-        } else if self.is_protocol {
-            format!("P{}", self.name())
-        } else {
-            format!("I{}", self.name().to_owned())
-        }
-    }
-
-    /// Is this a template interface?
-    pub fn is_template(&self) -> bool {
-        !self.template_names.is_empty()
-    }
-
-    /// List of the methods defined in this interface
-    pub fn methods(&self) -> &Vec<ObjCMethod> {
-        &self.methods
-    }
-
-    /// Is this a protocol?
-    pub fn is_protocol(&self) -> bool {
-        self.is_protocol
-    }
-
-    /// Is this a category?
-    pub fn is_category(&self) -> bool {
-        self.category.is_some()
-    }
-
-    /// List of the class methods defined in this interface
-    pub fn class_methods(&self) -> &Vec<ObjCMethod> {
-        &self.class_methods
-    }
-
-    /// Parses the Objective C interface from the cursor
-    pub fn from_ty(
-        cursor: &clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Option<Self> {
-        let name = cursor.spelling();
-        let mut interface = Self::new(&name);
-
-        if cursor.kind() == CXCursor_ObjCProtocolDecl {
-            interface.is_protocol = true;
-        }
-
-        cursor.visit(|c| {
-            match c.kind() {
-                CXCursor_ObjCClassRef => {
-                    if cursor.kind() == CXCursor_ObjCCategoryDecl {
-                        // We are actually a category extension, and we found the reference
-                        // to the original interface, so name this interface approriately
-                        interface.name = c.spelling();
-                        interface.category = Some(cursor.spelling());
-                    }
-                }
-                CXCursor_ObjCProtocolRef => {
-                    // Gather protocols this interface conforms to
-                    let needle = format!("P{}", c.spelling());
-                    let items_map = ctx.items();
-                    debug!(
-                        "Interface {} conforms to {}, find the item",
-                        interface.name, needle
-                    );
-
-                    for (id, item) in items_map {
-                        if let Some(ty) = item.as_type() {
-                            if let TypeKind::ObjCInterface(ref protocol) =
-                                *ty.kind()
-                            {
-                                if protocol.is_protocol {
-                                    debug!(
-                                        "Checking protocol {}, ty.name {:?}",
-                                        protocol.name,
-                                        ty.name()
-                                    );
-                                    if Some(needle.as_ref()) == ty.name() {
-                                        debug!(
-                                            "Found conforming protocol {:?}",
-                                            item
-                                        );
-                                        interface.conforms_to.push(id);
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                CXCursor_ObjCInstanceMethodDecl |
-                CXCursor_ObjCClassMethodDecl => {
-                    let name = c.spelling();
-                    let signature =
-                        FunctionSig::from_ty(&c.cur_type(), &c, ctx)
-                            .expect("Invalid function sig");
-                    let is_class_method =
-                        c.kind() == CXCursor_ObjCClassMethodDecl;
-                    let method =
-                        ObjCMethod::new(&name, signature, is_class_method);
-                    interface.add_method(method);
-                }
-                CXCursor_TemplateTypeParameter => {
-                    let name = c.spelling();
-                    interface.template_names.push(name);
-                }
-                CXCursor_ObjCSuperClassRef => {
-                    let item = Item::from_ty_or_ref(c.cur_type(), c, None, ctx);
-                    interface.parent_class = Some(item.into());
-                }
-                _ => {}
-            }
-            CXChildVisit_Continue
-        });
-        Some(interface)
-    }
-
-    fn add_method(&mut self, method: ObjCMethod) {
-        if method.is_class_method {
-            self.class_methods.push(method);
-        } else {
-            self.methods.push(method);
-        }
-    }
-}
-
-impl ObjCMethod {
-    fn new(
-        name: &str,
-        signature: FunctionSig,
-        is_class_method: bool,
-    ) -> ObjCMethod {
-        let split_name: Vec<&str> = name.split(':').collect();
-
-        let rust_name = split_name.join("_");
-
-        ObjCMethod {
-            name: name.to_owned(),
-            rust_name,
-            signature,
-            is_class_method,
-        }
-    }
-
-    /// The original method selector name
-    /// like, dataWithBytes:length:
-    pub fn name(&self) -> &str {
-        self.name.as_ref()
-    }
-
-    /// Method name as converted to rust
-    /// like, dataWithBytes_length_
-    pub fn rust_name(&self) -> &str {
-        self.rust_name.as_ref()
-    }
-
-    /// Returns the methods signature as FunctionSig
-    pub fn signature(&self) -> &FunctionSig {
-        &self.signature
-    }
-
-    /// Is this a class method?
-    pub fn is_class_method(&self) -> bool {
-        self.is_class_method
-    }
-
-    /// Formats the method call
-    pub fn format_method_call(&self, args: &[TokenStream]) -> TokenStream {
-        let split_name: Vec<Option<Ident>> = self
-            .name
-            .split(':')
-            .map(|name| {
-                if name.is_empty() {
-                    None
-                } else {
-                    Some(Ident::new(name, Span::call_site()))
-                }
-            })
-            .collect();
-
-        // No arguments
-        if args.is_empty() && split_name.len() == 1 {
-            let name = &split_name[0];
-            return quote! {
-                #name
-            };
-        }
-
-        // Check right amount of arguments
-        assert!(
-            args.len() == split_name.len() - 1,
-            "Incorrect method name or arguments for objc method, {:?} vs {:?}",
-            args,
-            split_name
-        );
-
-        // Get arguments without type signatures to pass to `msg_send!`
-        let mut args_without_types = vec![];
-        for arg in args.iter() {
-            let arg = arg.to_string();
-            let name_and_sig: Vec<&str> = arg.split(' ').collect();
-            let name = name_and_sig[0];
-            args_without_types.push(Ident::new(name, Span::call_site()))
-        }
-
-        let args = split_name.into_iter().zip(args_without_types).map(
-            |(arg, arg_val)| {
-                if let Some(arg) = arg {
-                    quote! { #arg: #arg_val }
-                } else {
-                    quote! { #arg_val: #arg_val }
-                }
-            },
-        );
-
-        quote! {
-            #( #args )*
-        }
-    }
-}
-
-impl Trace for ObjCInterface {
-    type Extra = ();
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        for method in &self.methods {
-            method.signature.trace(context, tracer, &());
-        }
-
-        for class_method in &self.class_methods {
-            class_method.signature.trace(context, tracer, &());
-        }
-
-        for protocol in &self.conforms_to {
-            tracer.visit(*protocol);
-        }
-    }
-}
diff --git a/src/ir/template.rs b/src/ir/template.rs
deleted file mode 100644
index 8b06748e..00000000
--- a/src/ir/template.rs
+++ /dev/null
@@ -1,343 +0,0 @@
-//! Template declaration and instantiation related things.
-//!
-//! The nomenclature surrounding templates is often confusing, so here are a few
-//! brief definitions:
-//!
-//! * "Template definition": a class/struct/alias/function definition that takes
-//! generic template parameters. For example:
-//!
-//! ```c++
-//! template<typename T>
-//! class List<T> {
-//!     // ...
-//! };
-//! ```
-//!
-//! * "Template instantiation": an instantiation is a use of a template with
-//! concrete template arguments. For example, `List<int>`.
-//!
-//! * "Template specialization": an alternative template definition providing a
-//! custom definition for instantiations with the matching template
-//! arguments. This C++ feature is unsupported by bindgen. For example:
-//!
-//! ```c++
-//! template<>
-//! class List<int> {
-//!     // Special layout for int lists...
-//! };
-//! ```
-
-use super::context::{BindgenContext, ItemId, TypeId};
-use super::item::{IsOpaque, Item, ItemAncestors};
-use super::traversal::{EdgeKind, Trace, Tracer};
-use crate::clang;
-use crate::parse::ClangItemParser;
-
-/// Template declaration (and such declaration's template parameters) related
-/// methods.
-///
-/// This trait's methods distinguish between `None` and `Some([])` for
-/// declarations that are not templates and template declarations with zero
-/// parameters, in general.
-///
-/// Consider this example:
-///
-/// ```c++
-/// template <typename T, typename U>
-/// class Foo {
-///     T use_of_t;
-///     U use_of_u;
-///
-///     template <typename V>
-///     using Bar = V*;
-///
-///     class Inner {
-///         T        x;
-///         U        y;
-///         Bar<int> z;
-///     };
-///
-///     template <typename W>
-///     class Lol {
-///         // No use of W, but here's a use of T.
-///         T t;
-///     };
-///
-///     template <typename X>
-///     class Wtf {
-///         // X is not used because W is not used.
-///         Lol<X> lololol;
-///     };
-/// };
-///
-/// class Qux {
-///     int y;
-/// };
-/// ```
-///
-/// The following table depicts the results of each trait method when invoked on
-/// each of the declarations above:
-///
-/// +------+----------------------+--------------------------+------------------------+----
-/// |Decl. | self_template_params | num_self_template_params | all_template_parameters| ...
-/// +------+----------------------+--------------------------+------------------------+----
-/// |Foo   | [T, U]               | 2                        | [T, U]                 | ...
-/// |Bar   | [V]                  | 1                        | [T, U, V]              | ...
-/// |Inner | []                   | 0                        | [T, U]                 | ...
-/// |Lol   | [W]                  | 1                        | [T, U, W]              | ...
-/// |Wtf   | [X]                  | 1                        | [T, U, X]              | ...
-/// |Qux   | []                   | 0                        | []                     | ...
-/// +------+----------------------+--------------------------+------------------------+----
-///
-/// ----+------+-----+----------------------+
-/// ... |Decl. | ... | used_template_params |
-/// ----+------+-----+----------------------+
-/// ... |Foo   | ... | [T, U]               |
-/// ... |Bar   | ... | [V]                  |
-/// ... |Inner | ... | []                   |
-/// ... |Lol   | ... | [T]                  |
-/// ... |Wtf   | ... | [T]                  |
-/// ... |Qux   | ... | []                   |
-/// ----+------+-----+----------------------+
-pub trait TemplateParameters: Sized {
-    /// Get the set of `ItemId`s that make up this template declaration's free
-    /// template parameters.
-    ///
-    /// Note that these might *not* all be named types: C++ allows
-    /// constant-value template parameters as well as template-template
-    /// parameters. Of course, Rust does not allow generic parameters to be
-    /// anything but types, so we must treat them as opaque, and avoid
-    /// instantiating them.
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>;
-
-    /// Get the number of free template parameters this template declaration
-    /// has.
-    fn num_self_template_params(&self, ctx: &BindgenContext) -> usize {
-        self.self_template_params(ctx).len()
-    }
-
-    /// Get the complete set of template parameters that can affect this
-    /// declaration.
-    ///
-    /// Note that this item doesn't need to be a template declaration itself for
-    /// `Some` to be returned here (in contrast to `self_template_params`). If
-    /// this item is a member of a template declaration, then the parent's
-    /// template parameters are included here.
-    ///
-    /// In the example above, `Inner` depends on both of the `T` and `U` type
-    /// parameters, even though it is not itself a template declaration and
-    /// therefore has no type parameters itself. Perhaps it helps to think about
-    /// how we would fully reference such a member type in C++:
-    /// `Foo<int,char>::Inner`. `Foo` *must* be instantiated with template
-    /// arguments before we can gain access to the `Inner` member type.
-    fn all_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
-    where
-        Self: ItemAncestors,
-    {
-        let mut ancestors: Vec<_> = self.ancestors(ctx).collect();
-        ancestors.reverse();
-        ancestors
-            .into_iter()
-            .flat_map(|id| id.self_template_params(ctx).into_iter())
-            .collect()
-    }
-
-    /// Get only the set of template parameters that this item uses. This is a
-    /// subset of `all_template_params` and does not necessarily contain any of
-    /// `self_template_params`.
-    fn used_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId>
-    where
-        Self: AsRef<ItemId>,
-    {
-        assert!(
-            ctx.in_codegen_phase(),
-            "template parameter usage is not computed until codegen"
-        );
-
-        let id = *self.as_ref();
-        ctx.resolve_item(id)
-            .all_template_params(ctx)
-            .into_iter()
-            .filter(|p| ctx.uses_template_parameter(id, *p))
-            .collect()
-    }
-}
-
-/// A trait for things which may or may not be a named template type parameter.
-pub trait AsTemplateParam {
-    /// Any extra information the implementor might need to make this decision.
-    type Extra;
-
-    /// Convert this thing to the item id of a named template type parameter.
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> Option<TypeId>;
-
-    /// Is this a named template type parameter?
-    fn is_template_param(
-        &self,
-        ctx: &BindgenContext,
-        extra: &Self::Extra,
-    ) -> bool {
-        self.as_template_param(ctx, extra).is_some()
-    }
-}
-
-/// A concrete instantiation of a generic template.
-#[derive(Clone, Debug)]
-pub struct TemplateInstantiation {
-    /// The template definition which this is instantiating.
-    definition: TypeId,
-    /// The concrete template arguments, which will be substituted in the
-    /// definition for the generic template parameters.
-    args: Vec<TypeId>,
-}
-
-impl TemplateInstantiation {
-    /// Construct a new template instantiation from the given parts.
-    pub fn new<I>(definition: TypeId, args: I) -> TemplateInstantiation
-    where
-        I: IntoIterator<Item = TypeId>,
-    {
-        TemplateInstantiation {
-            definition,
-            args: args.into_iter().collect(),
-        }
-    }
-
-    /// Get the template definition for this instantiation.
-    pub fn template_definition(&self) -> TypeId {
-        self.definition
-    }
-
-    /// Get the concrete template arguments used in this instantiation.
-    pub fn template_arguments(&self) -> &[TypeId] {
-        &self.args[..]
-    }
-
-    /// Parse a `TemplateInstantiation` from a clang `Type`.
-    pub fn from_ty(
-        ty: &clang::Type,
-        ctx: &mut BindgenContext,
-    ) -> Option<TemplateInstantiation> {
-        use clang_sys::*;
-
-        let template_args = ty.template_args().map_or(vec![], |args| match ty
-            .canonical_type()
-            .template_args()
-        {
-            Some(canonical_args) => {
-                let arg_count = args.len();
-                args.chain(canonical_args.skip(arg_count))
-                    .filter(|t| t.kind() != CXType_Invalid)
-                    .map(|t| {
-                        Item::from_ty_or_ref(t, t.declaration(), None, ctx)
-                    })
-                    .collect()
-            }
-            None => args
-                .filter(|t| t.kind() != CXType_Invalid)
-                .map(|t| Item::from_ty_or_ref(t, t.declaration(), None, ctx))
-                .collect(),
-        });
-
-        let declaration = ty.declaration();
-        let definition = if declaration.kind() == CXCursor_TypeAliasTemplateDecl
-        {
-            Some(declaration)
-        } else {
-            declaration.specialized().or_else(|| {
-                let mut template_ref = None;
-                ty.declaration().visit(|child| {
-                    if child.kind() == CXCursor_TemplateRef {
-                        template_ref = Some(child);
-                        return CXVisit_Break;
-                    }
-
-                    // Instantiations of template aliases might have the
-                    // TemplateRef to the template alias definition arbitrarily
-                    // deep, so we need to recurse here and not only visit
-                    // direct children.
-                    CXChildVisit_Recurse
-                });
-
-                template_ref.and_then(|cur| cur.referenced())
-            })
-        };
-
-        let definition = match definition {
-            Some(def) => def,
-            None => {
-                if !ty.declaration().is_builtin() {
-                    warn!(
-                        "Could not find template definition for template \
-                         instantiation"
-                    );
-                }
-                return None;
-            }
-        };
-
-        let template_definition =
-            Item::from_ty_or_ref(definition.cur_type(), definition, None, ctx);
-
-        Some(TemplateInstantiation::new(
-            template_definition,
-            template_args,
-        ))
-    }
-}
-
-impl IsOpaque for TemplateInstantiation {
-    type Extra = Item;
-
-    /// Is this an opaque template instantiation?
-    fn is_opaque(&self, ctx: &BindgenContext, item: &Item) -> bool {
-        if self.template_definition().is_opaque(ctx, &()) {
-            return true;
-        }
-
-        // TODO(#774): This doesn't properly handle opaque instantiations where
-        // an argument is itself an instantiation because `canonical_name` does
-        // not insert the template arguments into the name, ie it for nested
-        // template arguments it creates "Foo" instead of "Foo<int>". The fully
-        // correct fix is to make `canonical_{name,path}` include template
-        // arguments properly.
-
-        let mut path = item.path_for_allowlisting(ctx).clone();
-        let args: Vec<_> = self
-            .template_arguments()
-            .iter()
-            .map(|arg| {
-                let arg_path =
-                    ctx.resolve_item(*arg).path_for_allowlisting(ctx);
-                arg_path[1..].join("::")
-            })
-            .collect();
-        {
-            let last = path.last_mut().unwrap();
-            last.push('<');
-            last.push_str(&args.join(", "));
-            last.push('>');
-        }
-
-        ctx.opaque_by_name(&path)
-    }
-}
-
-impl Trace for TemplateInstantiation {
-    type Extra = ();
-
-    fn trace<T>(&self, _ctx: &BindgenContext, tracer: &mut T, _: &())
-    where
-        T: Tracer,
-    {
-        tracer
-            .visit_kind(self.definition.into(), EdgeKind::TemplateDeclaration);
-        for arg in self.template_arguments() {
-            tracer.visit_kind(arg.into(), EdgeKind::TemplateArgument);
-        }
-    }
-}
diff --git a/src/ir/traversal.rs b/src/ir/traversal.rs
deleted file mode 100644
index f14483f2..00000000
--- a/src/ir/traversal.rs
+++ /dev/null
@@ -1,478 +0,0 @@
-//! Traversal of the graph of IR items and types.
-
-use super::context::{BindgenContext, ItemId};
-use super::item::ItemSet;
-use std::collections::{BTreeMap, VecDeque};
-
-/// An outgoing edge in the IR graph is a reference from some item to another
-/// item:
-///
-///   from --> to
-///
-/// The `from` is left implicit: it is the concrete `Trace` implementer which
-/// yielded this outgoing edge.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Edge {
-    to: ItemId,
-    kind: EdgeKind,
-}
-
-impl Edge {
-    /// Construct a new edge whose referent is `to` and is of the given `kind`.
-    pub fn new(to: ItemId, kind: EdgeKind) -> Edge {
-        Edge { to, kind }
-    }
-}
-
-impl From<Edge> for ItemId {
-    fn from(val: Edge) -> Self {
-        val.to
-    }
-}
-
-/// The kind of edge reference. This is useful when we wish to only consider
-/// certain kinds of edges for a particular traversal or analysis.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum EdgeKind {
-    /// A generic, catch-all edge.
-    Generic,
-
-    /// An edge from a template declaration, to the definition of a named type
-    /// parameter. For example, the edge from `Foo<T>` to `T` in the following
-    /// snippet:
-    ///
-    /// ```C++
-    /// template<typename T>
-    /// class Foo { };
-    /// ```
-    TemplateParameterDefinition,
-
-    /// An edge from a template instantiation to the template declaration that
-    /// is being instantiated. For example, the edge from `Foo<int>` to
-    /// to `Foo<T>`:
-    ///
-    /// ```C++
-    /// template<typename T>
-    /// class Foo { };
-    ///
-    /// using Bar = Foo<ant>;
-    /// ```
-    TemplateDeclaration,
-
-    /// An edge from a template instantiation to its template argument. For
-    /// example, `Foo<Bar>` to `Bar`:
-    ///
-    /// ```C++
-    /// template<typename T>
-    /// class Foo { };
-    ///
-    /// class Bar { };
-    ///
-    /// using FooBar = Foo<Bar>;
-    /// ```
-    TemplateArgument,
-
-    /// An edge from a compound type to one of its base member types. For
-    /// example, the edge from `Bar` to `Foo`:
-    ///
-    /// ```C++
-    /// class Foo { };
-    ///
-    /// class Bar : public Foo { };
-    /// ```
-    BaseMember,
-
-    /// An edge from a compound type to the types of one of its fields. For
-    /// example, the edge from `Foo` to `int`:
-    ///
-    /// ```C++
-    /// class Foo {
-    ///     int x;
-    /// };
-    /// ```
-    Field,
-
-    /// An edge from an class or struct type to an inner type member. For
-    /// example, the edge from `Foo` to `Foo::Bar` here:
-    ///
-    /// ```C++
-    /// class Foo {
-    ///     struct Bar { };
-    /// };
-    /// ```
-    InnerType,
-
-    /// An edge from an class or struct type to an inner static variable. For
-    /// example, the edge from `Foo` to `Foo::BAR` here:
-    ///
-    /// ```C++
-    /// class Foo {
-    ///     static const char* BAR;
-    /// };
-    /// ```
-    InnerVar,
-
-    /// An edge from a class or struct type to one of its method functions. For
-    /// example, the edge from `Foo` to `Foo::bar`:
-    ///
-    /// ```C++
-    /// class Foo {
-    ///     bool bar(int x, int y);
-    /// };
-    /// ```
-    Method,
-
-    /// An edge from a class or struct type to one of its constructor
-    /// functions. For example, the edge from `Foo` to `Foo::Foo(int x, int y)`:
-    ///
-    /// ```C++
-    /// class Foo {
-    ///     int my_x;
-    ///     int my_y;
-    ///
-    ///   public:
-    ///     Foo(int x, int y);
-    /// };
-    /// ```
-    Constructor,
-
-    /// An edge from a class or struct type to its destructor function. For
-    /// example, the edge from `Doggo` to `Doggo::~Doggo()`:
-    ///
-    /// ```C++
-    /// struct Doggo {
-    ///     char* wow;
-    ///
-    ///   public:
-    ///     ~Doggo();
-    /// };
-    /// ```
-    Destructor,
-
-    /// An edge from a function declaration to its return type. For example, the
-    /// edge from `foo` to `int`:
-    ///
-    /// ```C++
-    /// int foo(char* string);
-    /// ```
-    FunctionReturn,
-
-    /// An edge from a function declaration to one of its parameter types. For
-    /// example, the edge from `foo` to `char*`:
-    ///
-    /// ```C++
-    /// int foo(char* string);
-    /// ```
-    FunctionParameter,
-
-    /// An edge from a static variable to its type. For example, the edge from
-    /// `FOO` to `const char*`:
-    ///
-    /// ```C++
-    /// static const char* FOO;
-    /// ```
-    VarType,
-
-    /// An edge from a non-templated alias or typedef to the referenced type.
-    TypeReference,
-}
-
-/// A predicate to allow visiting only sub-sets of the whole IR graph by
-/// excluding certain edges from being followed by the traversal.
-///
-/// The predicate must return true if the traversal should follow this edge
-/// and visit everything that is reachable through it.
-pub type TraversalPredicate = for<'a> fn(&'a BindgenContext, Edge) -> bool;
-
-/// A `TraversalPredicate` implementation that follows all edges, and therefore
-/// traversals using this predicate will see the whole IR graph reachable from
-/// the traversal's roots.
-pub fn all_edges(_: &BindgenContext, _: Edge) -> bool {
-    true
-}
-
-/// A `TraversalPredicate` implementation that only follows
-/// `EdgeKind::InnerType` edges, and therefore traversals using this predicate
-/// will only visit the traversal's roots and their inner types. This is used
-/// in no-recursive-allowlist mode, where inner types such as anonymous
-/// structs/unions still need to be processed.
-pub fn only_inner_type_edges(_: &BindgenContext, edge: Edge) -> bool {
-    edge.kind == EdgeKind::InnerType
-}
-
-/// A `TraversalPredicate` implementation that only follows edges to items that
-/// are enabled for code generation. This lets us skip considering items for
-/// which are not reachable from code generation.
-pub fn codegen_edges(ctx: &BindgenContext, edge: Edge) -> bool {
-    let cc = &ctx.options().codegen_config;
-    match edge.kind {
-        EdgeKind::Generic => {
-            ctx.resolve_item(edge.to).is_enabled_for_codegen(ctx)
-        }
-
-        // We statically know the kind of item that non-generic edges can point
-        // to, so we don't need to actually resolve the item and check
-        // `Item::is_enabled_for_codegen`.
-        EdgeKind::TemplateParameterDefinition |
-        EdgeKind::TemplateArgument |
-        EdgeKind::TemplateDeclaration |
-        EdgeKind::BaseMember |
-        EdgeKind::Field |
-        EdgeKind::InnerType |
-        EdgeKind::FunctionReturn |
-        EdgeKind::FunctionParameter |
-        EdgeKind::VarType |
-        EdgeKind::TypeReference => cc.types(),
-        EdgeKind::InnerVar => cc.vars(),
-        EdgeKind::Method => cc.methods(),
-        EdgeKind::Constructor => cc.constructors(),
-        EdgeKind::Destructor => cc.destructors(),
-    }
-}
-
-/// The storage for the set of items that have been seen (although their
-/// outgoing edges might not have been fully traversed yet) in an active
-/// traversal.
-pub trait TraversalStorage<'ctx> {
-    /// Construct a new instance of this TraversalStorage, for a new traversal.
-    fn new(ctx: &'ctx BindgenContext) -> Self;
-
-    /// Add the given item to the storage. If the item has never been seen
-    /// before, return `true`. Otherwise, return `false`.
-    ///
-    /// The `from` item is the item from which we discovered this item, or is
-    /// `None` if this item is a root.
-    fn add(&mut self, from: Option<ItemId>, item: ItemId) -> bool;
-}
-
-impl<'ctx> TraversalStorage<'ctx> for ItemSet {
-    fn new(_: &'ctx BindgenContext) -> Self {
-        ItemSet::new()
-    }
-
-    fn add(&mut self, _: Option<ItemId>, item: ItemId) -> bool {
-        self.insert(item)
-    }
-}
-
-/// A `TraversalStorage` implementation that keeps track of how we first reached
-/// each item. This is useful for providing debug assertions with meaningful
-/// diagnostic messages about dangling items.
-#[derive(Debug)]
-pub struct Paths<'ctx>(BTreeMap<ItemId, ItemId>, &'ctx BindgenContext);
-
-impl<'ctx> TraversalStorage<'ctx> for Paths<'ctx> {
-    fn new(ctx: &'ctx BindgenContext) -> Self {
-        Paths(BTreeMap::new(), ctx)
-    }
-
-    fn add(&mut self, from: Option<ItemId>, item: ItemId) -> bool {
-        let newly_discovered =
-            self.0.insert(item, from.unwrap_or(item)).is_none();
-
-        if self.1.resolve_item_fallible(item).is_none() {
-            let mut path = vec![];
-            let mut current = item;
-            loop {
-                let predecessor = *self.0.get(&current).expect(
-                    "We know we found this item id, so it must have a \
-                     predecessor",
-                );
-                if predecessor == current {
-                    break;
-                }
-                path.push(predecessor);
-                current = predecessor;
-            }
-            path.reverse();
-            panic!(
-                "Found reference to dangling id = {:?}\nvia path = {:?}",
-                item, path
-            );
-        }
-
-        newly_discovered
-    }
-}
-
-/// The queue of seen-but-not-yet-traversed items.
-///
-/// Using a FIFO queue with a traversal will yield a breadth-first traversal,
-/// while using a LIFO queue will result in a depth-first traversal of the IR
-/// graph.
-pub trait TraversalQueue: Default {
-    /// Add a newly discovered item to the queue.
-    fn push(&mut self, item: ItemId);
-
-    /// Pop the next item to traverse, if any.
-    fn next(&mut self) -> Option<ItemId>;
-}
-
-impl TraversalQueue for Vec<ItemId> {
-    fn push(&mut self, item: ItemId) {
-        self.push(item);
-    }
-
-    fn next(&mut self) -> Option<ItemId> {
-        self.pop()
-    }
-}
-
-impl TraversalQueue for VecDeque<ItemId> {
-    fn push(&mut self, item: ItemId) {
-        self.push_back(item);
-    }
-
-    fn next(&mut self) -> Option<ItemId> {
-        self.pop_front()
-    }
-}
-
-/// Something that can receive edges from a `Trace` implementation.
-pub trait Tracer {
-    /// Note an edge between items. Called from within a `Trace` implementation.
-    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind);
-
-    /// A synonym for `tracer.visit_kind(item, EdgeKind::Generic)`.
-    fn visit(&mut self, item: ItemId) {
-        self.visit_kind(item, EdgeKind::Generic);
-    }
-}
-
-impl<F> Tracer for F
-where
-    F: FnMut(ItemId, EdgeKind),
-{
-    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind) {
-        (*self)(item, kind)
-    }
-}
-
-/// Trace all of the outgoing edges to other items. Implementations should call
-/// one of `tracer.visit(edge)` or `tracer.visit_kind(edge, EdgeKind::Whatever)`
-/// for each of their outgoing edges.
-pub trait Trace {
-    /// If a particular type needs extra information beyond what it has in
-    /// `self` and `context` to find its referenced items, its implementation
-    /// can define this associated type, forcing callers to pass the needed
-    /// information through.
-    type Extra;
-
-    /// Trace all of this item's outgoing edges to other items.
-    fn trace<T>(
-        &self,
-        context: &BindgenContext,
-        tracer: &mut T,
-        extra: &Self::Extra,
-    ) where
-        T: Tracer;
-}
-
-/// An graph traversal of the transitive closure of references between items.
-///
-/// See `BindgenContext::allowlisted_items` for more information.
-pub struct ItemTraversal<'ctx, Storage, Queue>
-where
-    Storage: TraversalStorage<'ctx>,
-    Queue: TraversalQueue,
-{
-    ctx: &'ctx BindgenContext,
-
-    /// The set of items we have seen thus far in this traversal.
-    seen: Storage,
-
-    /// The set of items that we have seen, but have yet to traverse.
-    queue: Queue,
-
-    /// The predicate that determines which edges this traversal will follow.
-    predicate: TraversalPredicate,
-
-    /// The item we are currently traversing.
-    currently_traversing: Option<ItemId>,
-}
-
-impl<'ctx, Storage, Queue> ItemTraversal<'ctx, Storage, Queue>
-where
-    Storage: TraversalStorage<'ctx>,
-    Queue: TraversalQueue,
-{
-    /// Begin a new traversal, starting from the given roots.
-    pub fn new<R>(
-        ctx: &'ctx BindgenContext,
-        roots: R,
-        predicate: TraversalPredicate,
-    ) -> ItemTraversal<'ctx, Storage, Queue>
-    where
-        R: IntoIterator<Item = ItemId>,
-    {
-        let mut seen = Storage::new(ctx);
-        let mut queue = Queue::default();
-
-        for id in roots {
-            seen.add(None, id);
-            queue.push(id);
-        }
-
-        ItemTraversal {
-            ctx,
-            seen,
-            queue,
-            predicate,
-            currently_traversing: None,
-        }
-    }
-}
-
-impl<'ctx, Storage, Queue> Tracer for ItemTraversal<'ctx, Storage, Queue>
-where
-    Storage: TraversalStorage<'ctx>,
-    Queue: TraversalQueue,
-{
-    fn visit_kind(&mut self, item: ItemId, kind: EdgeKind) {
-        let edge = Edge::new(item, kind);
-        if !(self.predicate)(self.ctx, edge) {
-            return;
-        }
-
-        let is_newly_discovered =
-            self.seen.add(self.currently_traversing, item);
-        if is_newly_discovered {
-            self.queue.push(item)
-        }
-    }
-}
-
-impl<'ctx, Storage, Queue> Iterator for ItemTraversal<'ctx, Storage, Queue>
-where
-    Storage: TraversalStorage<'ctx>,
-    Queue: TraversalQueue,
-{
-    type Item = ItemId;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let id = self.queue.next()?;
-
-        let newly_discovered = self.seen.add(None, id);
-        debug_assert!(
-            !newly_discovered,
-            "should have already seen anything we get out of our queue"
-        );
-        debug_assert!(
-            self.ctx.resolve_item_fallible(id).is_some(),
-            "should only get IDs of actual items in our context during traversal"
-        );
-
-        self.currently_traversing = Some(id);
-        id.trace(self.ctx, self, &());
-        self.currently_traversing = None;
-
-        Some(id)
-    }
-}
-
-/// An iterator to find any dangling items.
-///
-/// See `BindgenContext::assert_no_dangling_item_traversal` for more
-/// information.
-pub type AssertNoDanglingItemsTraversal<'ctx> =
-    ItemTraversal<'ctx, Paths<'ctx>, VecDeque<ItemId>>;
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
deleted file mode 100644
index 6a3fd0e8..00000000
--- a/src/ir/ty.rs
+++ /dev/null
@@ -1,1266 +0,0 @@
-//! Everything related to types in our intermediate representation.
-
-use super::comp::CompInfo;
-use super::context::{BindgenContext, ItemId, TypeId};
-use super::dot::DotAttributes;
-use super::enum_ty::Enum;
-use super::function::FunctionSig;
-use super::int::IntKind;
-use super::item::{IsOpaque, Item};
-use super::layout::{Layout, Opaque};
-use super::objc::ObjCInterface;
-use super::template::{
-    AsTemplateParam, TemplateInstantiation, TemplateParameters,
-};
-use super::traversal::{EdgeKind, Trace, Tracer};
-use crate::clang::{self, Cursor};
-use crate::parse::{ClangItemParser, ParseError, ParseResult};
-use std::borrow::Cow;
-use std::io;
-
-/// The base representation of a type in bindgen.
-///
-/// A type has an optional name, which if present cannot be empty, a `layout`
-/// (size, alignment and packedness) if known, a `Kind`, which determines which
-/// kind of type it is, and whether the type is const.
-#[derive(Debug)]
-pub struct Type {
-    /// The name of the type, or None if it was an unnamed struct or union.
-    name: Option<String>,
-    /// The layout of the type, if known.
-    layout: Option<Layout>,
-    /// The inner kind of the type
-    kind: TypeKind,
-    /// Whether this type is const-qualified.
-    is_const: bool,
-}
-
-/// The maximum number of items in an array for which Rust implements common
-/// traits, and so if we have a type containing an array with more than this
-/// many items, we won't be able to derive common traits on that type.
-///
-pub const RUST_DERIVE_IN_ARRAY_LIMIT: usize = 32;
-
-impl Type {
-    /// Get the underlying `CompInfo` for this type, or `None` if this is some
-    /// other kind of type.
-    pub fn as_comp(&self) -> Option<&CompInfo> {
-        match self.kind {
-            TypeKind::Comp(ref ci) => Some(ci),
-            _ => None,
-        }
-    }
-
-    /// Get the underlying `CompInfo` for this type as a mutable reference, or
-    /// `None` if this is some other kind of type.
-    pub fn as_comp_mut(&mut self) -> Option<&mut CompInfo> {
-        match self.kind {
-            TypeKind::Comp(ref mut ci) => Some(ci),
-            _ => None,
-        }
-    }
-
-    /// Construct a new `Type`.
-    pub fn new(
-        name: Option<String>,
-        layout: Option<Layout>,
-        kind: TypeKind,
-        is_const: bool,
-    ) -> Self {
-        Type {
-            name,
-            layout,
-            kind,
-            is_const,
-        }
-    }
-
-    /// Which kind of type is this?
-    pub fn kind(&self) -> &TypeKind {
-        &self.kind
-    }
-
-    /// Get a mutable reference to this type's kind.
-    pub fn kind_mut(&mut self) -> &mut TypeKind {
-        &mut self.kind
-    }
-
-    /// Get this type's name.
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_deref()
-    }
-
-    /// Whether this is a block pointer type.
-    pub fn is_block_pointer(&self) -> bool {
-        matches!(self.kind, TypeKind::BlockPointer(..))
-    }
-
-    /// Is this a compound type?
-    pub fn is_comp(&self) -> bool {
-        matches!(self.kind, TypeKind::Comp(..))
-    }
-
-    /// Is this a union?
-    pub fn is_union(&self) -> bool {
-        match self.kind {
-            TypeKind::Comp(ref comp) => comp.is_union(),
-            _ => false,
-        }
-    }
-
-    /// Is this type of kind `TypeKind::TypeParam`?
-    pub fn is_type_param(&self) -> bool {
-        matches!(self.kind, TypeKind::TypeParam)
-    }
-
-    /// Is this a template instantiation type?
-    pub fn is_template_instantiation(&self) -> bool {
-        matches!(self.kind, TypeKind::TemplateInstantiation(..))
-    }
-
-    /// Is this a template alias type?
-    pub fn is_template_alias(&self) -> bool {
-        matches!(self.kind, TypeKind::TemplateAlias(..))
-    }
-
-    /// Is this a function type?
-    pub fn is_function(&self) -> bool {
-        matches!(self.kind, TypeKind::Function(..))
-    }
-
-    /// Is this an enum type?
-    pub fn is_enum(&self) -> bool {
-        matches!(self.kind, TypeKind::Enum(..))
-    }
-
-    /// Is this either a builtin or named type?
-    pub fn is_builtin_or_type_param(&self) -> bool {
-        matches!(
-            self.kind,
-            TypeKind::Void |
-                TypeKind::NullPtr |
-                TypeKind::Function(..) |
-                TypeKind::Array(..) |
-                TypeKind::Reference(..) |
-                TypeKind::Pointer(..) |
-                TypeKind::Int(..) |
-                TypeKind::Float(..) |
-                TypeKind::TypeParam
-        )
-    }
-
-    /// Creates a new named type, with name `name`.
-    pub fn named(name: String) -> Self {
-        let name = if name.is_empty() { None } else { Some(name) };
-        Self::new(name, None, TypeKind::TypeParam, false)
-    }
-
-    /// Is this a floating point type?
-    pub fn is_float(&self) -> bool {
-        matches!(self.kind, TypeKind::Float(..))
-    }
-
-    /// Is this a boolean type?
-    pub fn is_bool(&self) -> bool {
-        matches!(self.kind, TypeKind::Int(IntKind::Bool))
-    }
-
-    /// Is this an integer type?
-    pub fn is_integer(&self) -> bool {
-        matches!(self.kind, TypeKind::Int(..))
-    }
-
-    /// Cast this type to an integer kind, or `None` if it is not an integer
-    /// type.
-    pub fn as_integer(&self) -> Option<IntKind> {
-        match self.kind {
-            TypeKind::Int(int_kind) => Some(int_kind),
-            _ => None,
-        }
-    }
-
-    /// Is this a `const` qualified type?
-    pub fn is_const(&self) -> bool {
-        self.is_const
-    }
-
-    /// Is this a reference to another type?
-    pub fn is_type_ref(&self) -> bool {
-        matches!(
-            self.kind,
-            TypeKind::ResolvedTypeRef(_) | TypeKind::UnresolvedTypeRef(_, _, _)
-        )
-    }
-
-    /// Is this an unresolved reference?
-    pub fn is_unresolved_ref(&self) -> bool {
-        matches!(self.kind, TypeKind::UnresolvedTypeRef(_, _, _))
-    }
-
-    /// Is this a incomplete array type?
-    pub fn is_incomplete_array(&self, ctx: &BindgenContext) -> Option<ItemId> {
-        match self.kind {
-            TypeKind::Array(item, len) => {
-                if len == 0 {
-                    Some(item.into())
-                } else {
-                    None
-                }
-            }
-            TypeKind::ResolvedTypeRef(inner) => {
-                ctx.resolve_type(inner).is_incomplete_array(ctx)
-            }
-            _ => None,
-        }
-    }
-
-    /// What is the layout of this type?
-    pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        self.layout.or_else(|| {
-            match self.kind {
-                TypeKind::Comp(ref ci) => ci.layout(ctx),
-                TypeKind::Array(inner, length) if length == 0 => Some(
-                    Layout::new(0, ctx.resolve_type(inner).layout(ctx)?.align),
-                ),
-                // FIXME(emilio): This is a hack for anonymous union templates.
-                // Use the actual pointer size!
-                TypeKind::Pointer(..) => Some(Layout::new(
-                    ctx.target_pointer_size(),
-                    ctx.target_pointer_size(),
-                )),
-                TypeKind::ResolvedTypeRef(inner) => {
-                    ctx.resolve_type(inner).layout(ctx)
-                }
-                _ => None,
-            }
-        })
-    }
-
-    /// Whether this named type is an invalid C++ identifier. This is done to
-    /// avoid generating invalid code with some cases we can't handle, see:
-    ///
-    /// tests/headers/381-decltype-alias.hpp
-    pub fn is_invalid_type_param(&self) -> bool {
-        match self.kind {
-            TypeKind::TypeParam => {
-                let name = self.name().expect("Unnamed named type?");
-                !clang::is_valid_identifier(name)
-            }
-            _ => false,
-        }
-    }
-
-    /// Takes `name`, and returns a suitable identifier representation for it.
-    fn sanitize_name(name: &str) -> Cow<str> {
-        if clang::is_valid_identifier(name) {
-            return Cow::Borrowed(name);
-        }
-
-        let name = name.replace(|c| c == ' ' || c == ':' || c == '.', "_");
-        Cow::Owned(name)
-    }
-
-    /// Get this type's santizied name.
-    pub fn sanitized_name<'a>(
-        &'a self,
-        ctx: &BindgenContext,
-    ) -> Option<Cow<'a, str>> {
-        let name_info = match *self.kind() {
-            TypeKind::Pointer(inner) => Some((inner, Cow::Borrowed("ptr"))),
-            TypeKind::Reference(inner) => Some((inner, Cow::Borrowed("ref"))),
-            TypeKind::Array(inner, length) => {
-                Some((inner, format!("array{}", length).into()))
-            }
-            _ => None,
-        };
-        if let Some((inner, prefix)) = name_info {
-            ctx.resolve_item(inner)
-                .expect_type()
-                .sanitized_name(ctx)
-                .map(|name| format!("{}_{}", prefix, name).into())
-        } else {
-            self.name().map(Self::sanitize_name)
-        }
-    }
-
-    /// See safe_canonical_type.
-    pub fn canonical_type<'tr>(
-        &'tr self,
-        ctx: &'tr BindgenContext,
-    ) -> &'tr Type {
-        self.safe_canonical_type(ctx)
-            .expect("Should have been resolved after parsing!")
-    }
-
-    /// Returns the canonical type of this type, that is, the "inner type".
-    ///
-    /// For example, for a `typedef`, the canonical type would be the
-    /// `typedef`ed type, for a template instantiation, would be the template
-    /// its specializing, and so on. Return None if the type is unresolved.
-    pub fn safe_canonical_type<'tr>(
-        &'tr self,
-        ctx: &'tr BindgenContext,
-    ) -> Option<&'tr Type> {
-        match self.kind {
-            TypeKind::TypeParam |
-            TypeKind::Array(..) |
-            TypeKind::Vector(..) |
-            TypeKind::Comp(..) |
-            TypeKind::Opaque |
-            TypeKind::Int(..) |
-            TypeKind::Float(..) |
-            TypeKind::Complex(..) |
-            TypeKind::Function(..) |
-            TypeKind::Enum(..) |
-            TypeKind::Reference(..) |
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Pointer(..) |
-            TypeKind::BlockPointer(..) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel |
-            TypeKind::ObjCInterface(..) => Some(self),
-
-            TypeKind::ResolvedTypeRef(inner) |
-            TypeKind::Alias(inner) |
-            TypeKind::TemplateAlias(inner, _) => {
-                ctx.resolve_type(inner).safe_canonical_type(ctx)
-            }
-            TypeKind::TemplateInstantiation(ref inst) => ctx
-                .resolve_type(inst.template_definition())
-                .safe_canonical_type(ctx),
-
-            TypeKind::UnresolvedTypeRef(..) => None,
-        }
-    }
-
-    /// There are some types we don't want to stop at when finding an opaque
-    /// item, so we can arrive to the proper item that needs to be generated.
-    pub fn should_be_traced_unconditionally(&self) -> bool {
-        matches!(
-            self.kind,
-            TypeKind::Comp(..) |
-                TypeKind::Function(..) |
-                TypeKind::Pointer(..) |
-                TypeKind::Array(..) |
-                TypeKind::Reference(..) |
-                TypeKind::TemplateInstantiation(..) |
-                TypeKind::ResolvedTypeRef(..)
-        )
-    }
-}
-
-impl IsOpaque for Type {
-    type Extra = Item;
-
-    fn is_opaque(&self, ctx: &BindgenContext, item: &Item) -> bool {
-        match self.kind {
-            TypeKind::Opaque => true,
-            TypeKind::TemplateInstantiation(ref inst) => {
-                inst.is_opaque(ctx, item)
-            }
-            TypeKind::Comp(ref comp) => comp.is_opaque(ctx, &self.layout),
-            TypeKind::ResolvedTypeRef(to) => to.is_opaque(ctx, &()),
-            _ => false,
-        }
-    }
-}
-
-impl AsTemplateParam for Type {
-    type Extra = Item;
-
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> Option<TypeId> {
-        self.kind.as_template_param(ctx, item)
-    }
-}
-
-impl AsTemplateParam for TypeKind {
-    type Extra = Item;
-
-    fn as_template_param(
-        &self,
-        ctx: &BindgenContext,
-        item: &Item,
-    ) -> Option<TypeId> {
-        match *self {
-            TypeKind::TypeParam => Some(item.id().expect_type_id(ctx)),
-            TypeKind::ResolvedTypeRef(id) => id.as_template_param(ctx, &()),
-            _ => None,
-        }
-    }
-}
-
-impl DotAttributes for Type {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        if let Some(ref layout) = self.layout {
-            writeln!(
-                out,
-                "<tr><td>size</td><td>{}</td></tr>
-                           <tr><td>align</td><td>{}</td></tr>",
-                layout.size, layout.align
-            )?;
-            if layout.packed {
-                writeln!(out, "<tr><td>packed</td><td>true</td></tr>")?;
-            }
-        }
-
-        if self.is_const {
-            writeln!(out, "<tr><td>const</td><td>true</td></tr>")?;
-        }
-
-        self.kind.dot_attributes(ctx, out)
-    }
-}
-
-impl DotAttributes for TypeKind {
-    fn dot_attributes<W>(
-        &self,
-        ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        writeln!(
-            out,
-            "<tr><td>type kind</td><td>{}</td></tr>",
-            self.kind_name()
-        )?;
-
-        if let TypeKind::Comp(ref comp) = *self {
-            comp.dot_attributes(ctx, out)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl TypeKind {
-    fn kind_name(&self) -> &'static str {
-        match *self {
-            TypeKind::Void => "Void",
-            TypeKind::NullPtr => "NullPtr",
-            TypeKind::Comp(..) => "Comp",
-            TypeKind::Opaque => "Opaque",
-            TypeKind::Int(..) => "Int",
-            TypeKind::Float(..) => "Float",
-            TypeKind::Complex(..) => "Complex",
-            TypeKind::Alias(..) => "Alias",
-            TypeKind::TemplateAlias(..) => "TemplateAlias",
-            TypeKind::Array(..) => "Array",
-            TypeKind::Vector(..) => "Vector",
-            TypeKind::Function(..) => "Function",
-            TypeKind::Enum(..) => "Enum",
-            TypeKind::Pointer(..) => "Pointer",
-            TypeKind::BlockPointer(..) => "BlockPointer",
-            TypeKind::Reference(..) => "Reference",
-            TypeKind::TemplateInstantiation(..) => "TemplateInstantiation",
-            TypeKind::UnresolvedTypeRef(..) => "UnresolvedTypeRef",
-            TypeKind::ResolvedTypeRef(..) => "ResolvedTypeRef",
-            TypeKind::TypeParam => "TypeParam",
-            TypeKind::ObjCInterface(..) => "ObjCInterface",
-            TypeKind::ObjCId => "ObjCId",
-            TypeKind::ObjCSel => "ObjCSel",
-        }
-    }
-}
-
-#[test]
-fn is_invalid_type_param_valid() {
-    let ty = Type::new(Some("foo".into()), None, TypeKind::TypeParam, false);
-    assert!(!ty.is_invalid_type_param())
-}
-
-#[test]
-fn is_invalid_type_param_valid_underscore_and_numbers() {
-    let ty = Type::new(
-        Some("_foo123456789_".into()),
-        None,
-        TypeKind::TypeParam,
-        false,
-    );
-    assert!(!ty.is_invalid_type_param())
-}
-
-#[test]
-fn is_invalid_type_param_valid_unnamed_kind() {
-    let ty = Type::new(Some("foo".into()), None, TypeKind::Void, false);
-    assert!(!ty.is_invalid_type_param())
-}
-
-#[test]
-fn is_invalid_type_param_invalid_start() {
-    let ty = Type::new(Some("1foo".into()), None, TypeKind::TypeParam, false);
-    assert!(ty.is_invalid_type_param())
-}
-
-#[test]
-fn is_invalid_type_param_invalid_remaing() {
-    let ty = Type::new(Some("foo-".into()), None, TypeKind::TypeParam, false);
-    assert!(ty.is_invalid_type_param())
-}
-
-#[test]
-#[should_panic]
-fn is_invalid_type_param_unnamed() {
-    let ty = Type::new(None, None, TypeKind::TypeParam, false);
-    assert!(ty.is_invalid_type_param())
-}
-
-#[test]
-fn is_invalid_type_param_empty_name() {
-    let ty = Type::new(Some("".into()), None, TypeKind::TypeParam, false);
-    assert!(ty.is_invalid_type_param())
-}
-
-impl TemplateParameters for Type {
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
-        self.kind.self_template_params(ctx)
-    }
-}
-
-impl TemplateParameters for TypeKind {
-    fn self_template_params(&self, ctx: &BindgenContext) -> Vec<TypeId> {
-        match *self {
-            TypeKind::ResolvedTypeRef(id) => {
-                ctx.resolve_type(id).self_template_params(ctx)
-            }
-            TypeKind::Comp(ref comp) => comp.self_template_params(ctx),
-            TypeKind::TemplateAlias(_, ref args) => args.clone(),
-
-            TypeKind::Opaque |
-            TypeKind::TemplateInstantiation(..) |
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(_) |
-            TypeKind::Float(_) |
-            TypeKind::Complex(_) |
-            TypeKind::Array(..) |
-            TypeKind::Vector(..) |
-            TypeKind::Function(_) |
-            TypeKind::Enum(_) |
-            TypeKind::Pointer(_) |
-            TypeKind::BlockPointer(_) |
-            TypeKind::Reference(_) |
-            TypeKind::UnresolvedTypeRef(..) |
-            TypeKind::TypeParam |
-            TypeKind::Alias(_) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel |
-            TypeKind::ObjCInterface(_) => vec![],
-        }
-    }
-}
-
-/// The kind of float this type represents.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum FloatKind {
-    /// A `float`.
-    Float,
-    /// A `double`.
-    Double,
-    /// A `long double`.
-    LongDouble,
-    /// A `__float128`.
-    Float128,
-}
-
-/// The different kinds of types that we can parse.
-#[derive(Debug)]
-pub enum TypeKind {
-    /// The void type.
-    Void,
-
-    /// The `nullptr_t` type.
-    NullPtr,
-
-    /// A compound type, that is, a class, struct, or union.
-    Comp(CompInfo),
-
-    /// An opaque type that we just don't understand. All usage of this shoulf
-    /// result in an opaque blob of bytes generated from the containing type's
-    /// layout.
-    Opaque,
-
-    /// An integer type, of a given kind. `bool` and `char` are also considered
-    /// integers.
-    Int(IntKind),
-
-    /// A floating point type.
-    Float(FloatKind),
-
-    /// A complex floating point type.
-    Complex(FloatKind),
-
-    /// A type alias, with a name, that points to another type.
-    Alias(TypeId),
-
-    /// A templated alias, pointing to an inner type, just as `Alias`, but with
-    /// template parameters.
-    TemplateAlias(TypeId, Vec<TypeId>),
-
-    /// A packed vector type: element type, number of elements
-    Vector(TypeId, usize),
-
-    /// An array of a type and a length.
-    Array(TypeId, usize),
-
-    /// A function type, with a given signature.
-    Function(FunctionSig),
-
-    /// An `enum` type.
-    Enum(Enum),
-
-    /// A pointer to a type. The bool field represents whether it's const or
-    /// not.
-    Pointer(TypeId),
-
-    /// A pointer to an Apple block.
-    BlockPointer(TypeId),
-
-    /// A reference to a type, as in: int& foo().
-    Reference(TypeId),
-
-    /// An instantiation of an abstract template definition with a set of
-    /// concrete template arguments.
-    TemplateInstantiation(TemplateInstantiation),
-
-    /// A reference to a yet-to-resolve type. This stores the clang cursor
-    /// itself, and postpones its resolution.
-    ///
-    /// These are gone in a phase after parsing where these are mapped to
-    /// already known types, and are converted to ResolvedTypeRef.
-    ///
-    /// see tests/headers/typeref.hpp to see somewhere where this is a problem.
-    UnresolvedTypeRef(
-        clang::Type,
-        clang::Cursor,
-        /* parent_id */
-        Option<ItemId>,
-    ),
-
-    /// An indirection to another type.
-    ///
-    /// These are generated after we resolve a forward declaration, or when we
-    /// replace one type with another.
-    ResolvedTypeRef(TypeId),
-
-    /// A named type, that is, a template parameter.
-    TypeParam,
-
-    /// Objective C interface. Always referenced through a pointer
-    ObjCInterface(ObjCInterface),
-
-    /// Objective C 'id' type, points to any object
-    ObjCId,
-
-    /// Objective C selector type
-    ObjCSel,
-}
-
-impl Type {
-    /// This is another of the nasty methods. This one is the one that takes
-    /// care of the core logic of converting a clang type to a `Type`.
-    ///
-    /// It's sort of nasty and full of special-casing, but hopefully the
-    /// comments in every special case justify why they're there.
-    pub fn from_clang_ty(
-        potential_id: ItemId,
-        ty: &clang::Type,
-        location: Cursor,
-        parent_id: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<ParseResult<Self>, ParseError> {
-        use clang_sys::*;
-        {
-            let already_resolved = ctx.builtin_or_resolved_ty(
-                potential_id,
-                parent_id,
-                ty,
-                Some(location),
-            );
-            if let Some(ty) = already_resolved {
-                debug!("{:?} already resolved: {:?}", ty, location);
-                return Ok(ParseResult::AlreadyResolved(ty.into()));
-            }
-        }
-
-        let layout = ty.fallible_layout(ctx).ok();
-        let cursor = ty.declaration();
-        let mut name = cursor.spelling();
-
-        debug!(
-            "from_clang_ty: {:?}, ty: {:?}, loc: {:?}",
-            potential_id, ty, location
-        );
-        debug!("currently_parsed_types: {:?}", ctx.currently_parsed_types());
-
-        let canonical_ty = ty.canonical_type();
-
-        // Parse objc protocols as if they were interfaces
-        let mut ty_kind = ty.kind();
-        match location.kind() {
-            CXCursor_ObjCProtocolDecl | CXCursor_ObjCCategoryDecl => {
-                ty_kind = CXType_ObjCInterface
-            }
-            _ => {}
-        }
-
-        // Objective C template type parameter
-        // FIXME: This is probably wrong, we are attempting to find the
-        //        objc template params, which seem to manifest as a typedef.
-        //        We are rewriting them as id to suppress multiple conflicting
-        //        typedefs at root level
-        if ty_kind == CXType_Typedef {
-            let is_template_type_param =
-                ty.declaration().kind() == CXCursor_TemplateTypeParameter;
-            let is_canonical_objcpointer =
-                canonical_ty.kind() == CXType_ObjCObjectPointer;
-
-            // We have found a template type for objc interface
-            if is_canonical_objcpointer && is_template_type_param {
-                // Objective-C generics are just ids with fancy name.
-                // To keep it simple, just name them ids
-                name = "id".to_owned();
-            }
-        }
-
-        if location.kind() == CXCursor_ClassTemplatePartialSpecialization {
-            // Sorry! (Not sorry)
-            warn!(
-                "Found a partial template specialization; bindgen does not \
-                 support partial template specialization! Constructing \
-                 opaque type instead."
-            );
-            return Ok(ParseResult::New(
-                Opaque::from_clang_ty(&canonical_ty, ctx),
-                None,
-            ));
-        }
-
-        let kind = if location.kind() == CXCursor_TemplateRef ||
-            (ty.template_args().is_some() && ty_kind != CXType_Typedef)
-        {
-            // This is a template instantiation.
-            match TemplateInstantiation::from_ty(ty, ctx) {
-                Some(inst) => TypeKind::TemplateInstantiation(inst),
-                None => TypeKind::Opaque,
-            }
-        } else {
-            match ty_kind {
-                CXType_Unexposed
-                    if *ty != canonical_ty &&
-                                    canonical_ty.kind() != CXType_Invalid &&
-                                    ty.ret_type().is_none() &&
-                                    // Sometime clang desugars some types more than
-                                    // what we need, specially with function
-                                    // pointers.
-                                    //
-                                    // We should also try the solution of inverting
-                                    // those checks instead of doing this, that is,
-                                    // something like:
-                                    //
-                                    // CXType_Unexposed if ty.ret_type().is_some()
-                                    //   => { ... }
-                                    //
-                                    // etc.
-                                    !canonical_ty.spelling().contains("type-parameter") =>
-                {
-                    debug!("Looking for canonical type: {:?}", canonical_ty);
-                    return Self::from_clang_ty(
-                        potential_id,
-                        &canonical_ty,
-                        location,
-                        parent_id,
-                        ctx,
-                    );
-                }
-                CXType_Unexposed | CXType_Invalid => {
-                    // For some reason Clang doesn't give us any hint in some
-                    // situations where we should generate a function pointer (see
-                    // tests/headers/func_ptr_in_struct.h), so we do a guess here
-                    // trying to see if it has a valid return type.
-                    if ty.ret_type().is_some() {
-                        let signature =
-                            FunctionSig::from_ty(ty, &location, ctx)?;
-                        TypeKind::Function(signature)
-                    // Same here, with template specialisations we can safely
-                    // assume this is a Comp(..)
-                    } else if ty.is_fully_instantiated_template() {
-                        debug!(
-                            "Template specialization: {:?}, {:?} {:?}",
-                            ty, location, canonical_ty
-                        );
-                        let complex = CompInfo::from_ty(
-                            potential_id,
-                            ty,
-                            Some(location),
-                            ctx,
-                        )
-                        .expect("C'mon");
-                        TypeKind::Comp(complex)
-                    } else {
-                        match location.kind() {
-                            CXCursor_CXXBaseSpecifier |
-                            CXCursor_ClassTemplate => {
-                                if location.kind() == CXCursor_CXXBaseSpecifier
-                                {
-                                    // In the case we're parsing a base specifier
-                                    // inside an unexposed or invalid type, it means
-                                    // that we're parsing one of two things:
-                                    //
-                                    //  * A template parameter.
-                                    //  * A complex class that isn't exposed.
-                                    //
-                                    // This means, unfortunately, that there's no
-                                    // good way to differentiate between them.
-                                    //
-                                    // Probably we could try to look at the
-                                    // declaration and complicate more this logic,
-                                    // but we'll keep it simple... if it's a valid
-                                    // C++ identifier, we'll consider it as a
-                                    // template parameter.
-                                    //
-                                    // This is because:
-                                    //
-                                    //  * We expect every other base that is a
-                                    //    proper identifier (that is, a simple
-                                    //    struct/union declaration), to be exposed,
-                                    //    so this path can't be reached in that
-                                    //    case.
-                                    //
-                                    //  * Quite conveniently, complex base
-                                    //    specifiers preserve their full names (that
-                                    //    is: Foo<T> instead of Foo). We can take
-                                    //    advantage of this.
-                                    //
-                                    // If we find some edge case where this doesn't
-                                    // work (which I guess is unlikely, see the
-                                    // different test cases[1][2][3][4]), we'd need
-                                    // to find more creative ways of differentiating
-                                    // these two cases.
-                                    //
-                                    // [1]: inherit_named.hpp
-                                    // [2]: forward-inherit-struct-with-fields.hpp
-                                    // [3]: forward-inherit-struct.hpp
-                                    // [4]: inherit-namespaced.hpp
-                                    if location.spelling().chars().all(|c| {
-                                        c.is_alphanumeric() || c == '_'
-                                    }) {
-                                        return Err(ParseError::Recurse);
-                                    }
-                                } else {
-                                    name = location.spelling();
-                                }
-
-                                let complex = CompInfo::from_ty(
-                                    potential_id,
-                                    ty,
-                                    Some(location),
-                                    ctx,
-                                );
-                                match complex {
-                                    Ok(complex) => TypeKind::Comp(complex),
-                                    Err(_) => {
-                                        warn!(
-                                            "Could not create complex type \
-                                             from class template or base \
-                                             specifier, using opaque blob"
-                                        );
-                                        let opaque =
-                                            Opaque::from_clang_ty(ty, ctx);
-                                        return Ok(ParseResult::New(
-                                            opaque, None,
-                                        ));
-                                    }
-                                }
-                            }
-                            CXCursor_TypeAliasTemplateDecl => {
-                                debug!("TypeAliasTemplateDecl");
-
-                                // We need to manually unwind this one.
-                                let mut inner = Err(ParseError::Continue);
-                                let mut args = vec![];
-
-                                location.visit(|cur| {
-                                    match cur.kind() {
-                                        CXCursor_TypeAliasDecl => {
-                                            let current = cur.cur_type();
-
-                                            debug_assert_eq!(
-                                                current.kind(),
-                                                CXType_Typedef
-                                            );
-
-                                            name = current.spelling();
-
-                                            let inner_ty = cur
-                                                .typedef_type()
-                                                .expect("Not valid Type?");
-                                            inner = Ok(Item::from_ty_or_ref(
-                                                inner_ty,
-                                                cur,
-                                                Some(potential_id),
-                                                ctx,
-                                            ));
-                                        }
-                                        CXCursor_TemplateTypeParameter => {
-                                            let param = Item::type_param(
-                                                None, cur, ctx,
-                                            )
-                                            .expect(
-                                                "Item::type_param shouldn't \
-                                                 ever fail if we are looking \
-                                                 at a TemplateTypeParameter",
-                                            );
-                                            args.push(param);
-                                        }
-                                        _ => {}
-                                    }
-                                    CXChildVisit_Continue
-                                });
-
-                                let inner_type = match inner {
-                                    Ok(inner) => inner,
-                                    Err(..) => {
-                                        warn!(
-                                            "Failed to parse template alias \
-                                             {:?}",
-                                            location
-                                        );
-                                        return Err(ParseError::Continue);
-                                    }
-                                };
-
-                                TypeKind::TemplateAlias(inner_type, args)
-                            }
-                            CXCursor_TemplateRef => {
-                                let referenced = location.referenced().unwrap();
-                                let referenced_ty = referenced.cur_type();
-
-                                debug!(
-                                    "TemplateRef: location = {:?}; referenced = \
-                                        {:?}; referenced_ty = {:?}",
-                                    location,
-                                    referenced,
-                                    referenced_ty
-                                );
-
-                                return Self::from_clang_ty(
-                                    potential_id,
-                                    &referenced_ty,
-                                    referenced,
-                                    parent_id,
-                                    ctx,
-                                );
-                            }
-                            CXCursor_TypeRef => {
-                                let referenced = location.referenced().unwrap();
-                                let referenced_ty = referenced.cur_type();
-                                let declaration = referenced_ty.declaration();
-
-                                debug!(
-                                    "TypeRef: location = {:?}; referenced = \
-                                     {:?}; referenced_ty = {:?}",
-                                    location, referenced, referenced_ty
-                                );
-
-                                let id = Item::from_ty_or_ref_with_id(
-                                    potential_id,
-                                    referenced_ty,
-                                    declaration,
-                                    parent_id,
-                                    ctx,
-                                );
-                                return Ok(ParseResult::AlreadyResolved(
-                                    id.into(),
-                                ));
-                            }
-                            CXCursor_NamespaceRef => {
-                                return Err(ParseError::Continue);
-                            }
-                            _ => {
-                                if ty.kind() == CXType_Unexposed {
-                                    warn!(
-                                        "Unexposed type {:?}, recursing inside, \
-                                          loc: {:?}",
-                                        ty,
-                                        location
-                                    );
-                                    return Err(ParseError::Recurse);
-                                }
-
-                                warn!("invalid type {:?}", ty);
-                                return Err(ParseError::Continue);
-                            }
-                        }
-                    }
-                }
-                CXType_Auto => {
-                    if canonical_ty == *ty {
-                        debug!("Couldn't find deduced type: {:?}", ty);
-                        return Err(ParseError::Continue);
-                    }
-
-                    return Self::from_clang_ty(
-                        potential_id,
-                        &canonical_ty,
-                        location,
-                        parent_id,
-                        ctx,
-                    );
-                }
-                // NOTE: We don't resolve pointers eagerly because the pointee type
-                // might not have been parsed, and if it contains templates or
-                // something else we might get confused, see the comment inside
-                // TypeRef.
-                //
-                // We might need to, though, if the context is already in the
-                // process of resolving them.
-                CXType_ObjCObjectPointer |
-                CXType_MemberPointer |
-                CXType_Pointer => {
-                    let mut pointee = ty.pointee_type().unwrap();
-                    if *ty != canonical_ty {
-                        let canonical_pointee =
-                            canonical_ty.pointee_type().unwrap();
-                        // clang sometimes loses pointee constness here, see
-                        // #2244.
-                        if canonical_pointee.is_const() != pointee.is_const() {
-                            pointee = canonical_pointee;
-                        }
-                    }
-                    let inner =
-                        Item::from_ty_or_ref(pointee, location, None, ctx);
-                    TypeKind::Pointer(inner)
-                }
-                CXType_BlockPointer => {
-                    let pointee = ty.pointee_type().expect("Not valid Type?");
-                    let inner =
-                        Item::from_ty_or_ref(pointee, location, None, ctx);
-                    TypeKind::BlockPointer(inner)
-                }
-                // XXX: RValueReference is most likely wrong, but I don't think we
-                // can even add bindings for that, so huh.
-                CXType_RValueReference | CXType_LValueReference => {
-                    let inner = Item::from_ty_or_ref(
-                        ty.pointee_type().unwrap(),
-                        location,
-                        None,
-                        ctx,
-                    );
-                    TypeKind::Reference(inner)
-                }
-                // XXX DependentSizedArray is wrong
-                CXType_VariableArray | CXType_DependentSizedArray => {
-                    let inner = Item::from_ty(
-                        ty.elem_type().as_ref().unwrap(),
-                        location,
-                        None,
-                        ctx,
-                    )
-                    .expect("Not able to resolve array element?");
-                    TypeKind::Pointer(inner)
-                }
-                CXType_IncompleteArray => {
-                    let inner = Item::from_ty(
-                        ty.elem_type().as_ref().unwrap(),
-                        location,
-                        None,
-                        ctx,
-                    )
-                    .expect("Not able to resolve array element?");
-                    TypeKind::Array(inner, 0)
-                }
-                CXType_FunctionNoProto | CXType_FunctionProto => {
-                    let signature = FunctionSig::from_ty(ty, &location, ctx)?;
-                    TypeKind::Function(signature)
-                }
-                CXType_Typedef => {
-                    let inner = cursor.typedef_type().expect("Not valid Type?");
-                    let inner =
-                        Item::from_ty_or_ref(inner, location, None, ctx);
-                    if inner == potential_id {
-                        warn!(
-                            "Generating oqaque type instead of self-referential \
-                            typedef");
-                        // This can happen if we bail out of recursive situations
-                        // within the clang parsing.
-                        TypeKind::Opaque
-                    } else {
-                        TypeKind::Alias(inner)
-                    }
-                }
-                CXType_Enum => {
-                    let enum_ = Enum::from_ty(ty, ctx).expect("Not an enum?");
-
-                    if name.is_empty() {
-                        let pretty_name = ty.spelling();
-                        if clang::is_valid_identifier(&pretty_name) {
-                            name = pretty_name;
-                        }
-                    }
-
-                    TypeKind::Enum(enum_)
-                }
-                CXType_Record => {
-                    let complex = CompInfo::from_ty(
-                        potential_id,
-                        ty,
-                        Some(location),
-                        ctx,
-                    )
-                    .expect("Not a complex type?");
-
-                    if name.is_empty() {
-                        // The pretty-printed name may contain typedefed name,
-                        // but may also be "struct (anonymous at .h:1)"
-                        let pretty_name = ty.spelling();
-                        if clang::is_valid_identifier(&pretty_name) {
-                            name = pretty_name;
-                        }
-                    }
-
-                    TypeKind::Comp(complex)
-                }
-                CXType_Vector => {
-                    let inner = Item::from_ty(
-                        ty.elem_type().as_ref().unwrap(),
-                        location,
-                        None,
-                        ctx,
-                    )
-                    .expect("Not able to resolve vector element?");
-                    TypeKind::Vector(inner, ty.num_elements().unwrap())
-                }
-                CXType_ConstantArray => {
-                    let inner = Item::from_ty(
-                        ty.elem_type().as_ref().unwrap(),
-                        location,
-                        None,
-                        ctx,
-                    )
-                    .expect("Not able to resolve array element?");
-                    TypeKind::Array(inner, ty.num_elements().unwrap())
-                }
-                CXType_Elaborated => {
-                    return Self::from_clang_ty(
-                        potential_id,
-                        &ty.named(),
-                        location,
-                        parent_id,
-                        ctx,
-                    );
-                }
-                CXType_ObjCId => TypeKind::ObjCId,
-                CXType_ObjCSel => TypeKind::ObjCSel,
-                CXType_ObjCClass | CXType_ObjCInterface => {
-                    let interface = ObjCInterface::from_ty(&location, ctx)
-                        .expect("Not a valid objc interface?");
-                    name = interface.rust_name();
-                    TypeKind::ObjCInterface(interface)
-                }
-                CXType_Dependent => {
-                    return Err(ParseError::Continue);
-                }
-                _ => {
-                    warn!(
-                        "unsupported type: kind = {:?}; ty = {:?}; at {:?}",
-                        ty.kind(),
-                        ty,
-                        location
-                    );
-                    return Err(ParseError::Continue);
-                }
-            }
-        };
-
-        let name = if name.is_empty() { None } else { Some(name) };
-
-        let is_const = ty.is_const() ||
-            (ty.kind() == CXType_ConstantArray &&
-                ty.elem_type()
-                    .map_or(false, |element| element.is_const()));
-
-        let ty = Type::new(name, layout, kind, is_const);
-        // TODO: maybe declaration.canonical()?
-        Ok(ParseResult::New(ty, Some(cursor.canonical())))
-    }
-}
-
-impl Trace for Type {
-    type Extra = Item;
-
-    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
-    where
-        T: Tracer,
-    {
-        if self
-            .name()
-            .map_or(false, |name| context.is_stdint_type(name))
-        {
-            // These types are special-cased in codegen and don't need to be traversed.
-            return;
-        }
-        match *self.kind() {
-            TypeKind::Pointer(inner) |
-            TypeKind::Reference(inner) |
-            TypeKind::Array(inner, _) |
-            TypeKind::Vector(inner, _) |
-            TypeKind::BlockPointer(inner) |
-            TypeKind::Alias(inner) |
-            TypeKind::ResolvedTypeRef(inner) => {
-                tracer.visit_kind(inner.into(), EdgeKind::TypeReference);
-            }
-            TypeKind::TemplateAlias(inner, ref template_params) => {
-                tracer.visit_kind(inner.into(), EdgeKind::TypeReference);
-                for param in template_params {
-                    tracer.visit_kind(
-                        param.into(),
-                        EdgeKind::TemplateParameterDefinition,
-                    );
-                }
-            }
-            TypeKind::TemplateInstantiation(ref inst) => {
-                inst.trace(context, tracer, &());
-            }
-            TypeKind::Comp(ref ci) => ci.trace(context, tracer, item),
-            TypeKind::Function(ref sig) => sig.trace(context, tracer, &()),
-            TypeKind::Enum(ref en) => {
-                if let Some(repr) = en.repr() {
-                    tracer.visit(repr.into());
-                }
-            }
-            TypeKind::UnresolvedTypeRef(_, _, Some(id)) => {
-                tracer.visit(id);
-            }
-
-            TypeKind::ObjCInterface(ref interface) => {
-                interface.trace(context, tracer, &());
-            }
-
-            // None of these variants have edges to other items and types.
-            TypeKind::Opaque |
-            TypeKind::UnresolvedTypeRef(_, _, None) |
-            TypeKind::TypeParam |
-            TypeKind::Void |
-            TypeKind::NullPtr |
-            TypeKind::Int(_) |
-            TypeKind::Float(_) |
-            TypeKind::Complex(_) |
-            TypeKind::ObjCId |
-            TypeKind::ObjCSel => {}
-        }
-    }
-}
diff --git a/src/ir/var.rs b/src/ir/var.rs
deleted file mode 100644
index eecca4df..00000000
--- a/src/ir/var.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-//! Intermediate representation of variables.
-
-use super::super::codegen::MacroTypeVariation;
-use super::context::{BindgenContext, TypeId};
-use super::dot::DotAttributes;
-use super::function::cursor_mangling;
-use super::int::IntKind;
-use super::item::Item;
-use super::ty::{FloatKind, TypeKind};
-use crate::callbacks::MacroParsingBehavior;
-use crate::clang;
-use crate::clang::ClangToken;
-use crate::parse::{
-    ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
-};
-use cexpr;
-use std::io;
-use std::num::Wrapping;
-
-/// The type for a constant variable.
-#[derive(Debug)]
-pub enum VarType {
-    /// A boolean.
-    Bool(bool),
-    /// An integer.
-    Int(i64),
-    /// A floating point number.
-    Float(f64),
-    /// A character.
-    Char(u8),
-    /// A string, not necessarily well-formed utf-8.
-    String(Vec<u8>),
-}
-
-/// A `Var` is our intermediate representation of a variable.
-#[derive(Debug)]
-pub struct Var {
-    /// The name of the variable.
-    name: String,
-    /// The mangled name of the variable.
-    mangled_name: Option<String>,
-    /// The type of the variable.
-    ty: TypeId,
-    /// The value of the variable, that needs to be suitable for `ty`.
-    val: Option<VarType>,
-    /// Whether this variable is const.
-    is_const: bool,
-}
-
-impl Var {
-    /// Construct a new `Var`.
-    pub fn new(
-        name: String,
-        mangled_name: Option<String>,
-        ty: TypeId,
-        val: Option<VarType>,
-        is_const: bool,
-    ) -> Var {
-        assert!(!name.is_empty());
-        Var {
-            name,
-            mangled_name,
-            ty,
-            val,
-            is_const,
-        }
-    }
-
-    /// Is this variable `const` qualified?
-    pub fn is_const(&self) -> bool {
-        self.is_const
-    }
-
-    /// The value of this constant variable, if any.
-    pub fn val(&self) -> Option<&VarType> {
-        self.val.as_ref()
-    }
-
-    /// Get this variable's type.
-    pub fn ty(&self) -> TypeId {
-        self.ty
-    }
-
-    /// Get this variable's name.
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    /// Get this variable's mangled name.
-    pub fn mangled_name(&self) -> Option<&str> {
-        self.mangled_name.as_deref()
-    }
-}
-
-impl DotAttributes for Var {
-    fn dot_attributes<W>(
-        &self,
-        _ctx: &BindgenContext,
-        out: &mut W,
-    ) -> io::Result<()>
-    where
-        W: io::Write,
-    {
-        if self.is_const {
-            writeln!(out, "<tr><td>const</td><td>true</td></tr>")?;
-        }
-
-        if let Some(ref mangled) = self.mangled_name {
-            writeln!(
-                out,
-                "<tr><td>mangled name</td><td>{}</td></tr>",
-                mangled
-            )?;
-        }
-
-        Ok(())
-    }
-}
-
-fn default_macro_constant_type(ctx: &BindgenContext, value: i64) -> IntKind {
-    if value < 0 ||
-        ctx.options().default_macro_constant_type ==
-            MacroTypeVariation::Signed
-    {
-        if value < i32::min_value() as i64 || value > i32::max_value() as i64 {
-            IntKind::I64
-        } else if !ctx.options().fit_macro_constants ||
-            value < i16::min_value() as i64 ||
-            value > i16::max_value() as i64
-        {
-            IntKind::I32
-        } else if value < i8::min_value() as i64 ||
-            value > i8::max_value() as i64
-        {
-            IntKind::I16
-        } else {
-            IntKind::I8
-        }
-    } else if value > u32::max_value() as i64 {
-        IntKind::U64
-    } else if !ctx.options().fit_macro_constants ||
-        value > u16::max_value() as i64
-    {
-        IntKind::U32
-    } else if value > u8::max_value() as i64 {
-        IntKind::U16
-    } else {
-        IntKind::U8
-    }
-}
-
-/// Parses tokens from a CXCursor_MacroDefinition pointing into a function-like
-/// macro, and calls the func_macro callback.
-fn handle_function_macro(
-    cursor: &clang::Cursor,
-    callbacks: &dyn crate::callbacks::ParseCallbacks,
-) {
-    let is_closing_paren = |t: &ClangToken| {
-        // Test cheap token kind before comparing exact spellings.
-        t.kind == clang_sys::CXToken_Punctuation && t.spelling() == b")"
-    };
-    let tokens: Vec<_> = cursor.tokens().iter().collect();
-    if let Some(boundary) = tokens.iter().position(is_closing_paren) {
-        let mut spelled = tokens.iter().map(ClangToken::spelling);
-        // Add 1, to convert index to length.
-        let left = spelled.by_ref().take(boundary + 1);
-        let left = left.collect::<Vec<_>>().concat();
-        if let Ok(left) = String::from_utf8(left) {
-            let right: Vec<_> = spelled.collect();
-            callbacks.func_macro(&left, &right);
-        }
-    }
-}
-
-impl ClangSubItemParser for Var {
-    fn parse(
-        cursor: clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Result<ParseResult<Self>, ParseError> {
-        use cexpr::expr::EvalResult;
-        use cexpr::literal::CChar;
-        use clang_sys::*;
-        match cursor.kind() {
-            CXCursor_MacroDefinition => {
-                if let Some(callbacks) = ctx.parse_callbacks() {
-                    match callbacks.will_parse_macro(&cursor.spelling()) {
-                        MacroParsingBehavior::Ignore => {
-                            return Err(ParseError::Continue);
-                        }
-                        MacroParsingBehavior::Default => {}
-                    }
-
-                    if cursor.is_macro_function_like() {
-                        handle_function_macro(&cursor, callbacks);
-                        // We handled the macro, skip macro processing below.
-                        return Err(ParseError::Continue);
-                    }
-                }
-
-                let value = parse_macro(ctx, &cursor);
-
-                let (id, value) = match value {
-                    Some(v) => v,
-                    None => return Err(ParseError::Continue),
-                };
-
-                assert!(!id.is_empty(), "Empty macro name?");
-
-                let previously_defined = ctx.parsed_macro(&id);
-
-                // NB: It's important to "note" the macro even if the result is
-                // not an integer, otherwise we might loose other kind of
-                // derived macros.
-                ctx.note_parsed_macro(id.clone(), value.clone());
-
-                if previously_defined {
-                    let name = String::from_utf8(id).unwrap();
-                    warn!("Duplicated macro definition: {}", name);
-                    return Err(ParseError::Continue);
-                }
-
-                // NOTE: Unwrapping, here and above, is safe, because the
-                // identifier of a token comes straight from clang, and we
-                // enforce utf8 there, so we should have already panicked at
-                // this point.
-                let name = String::from_utf8(id).unwrap();
-                let (type_kind, val) = match value {
-                    EvalResult::Invalid => return Err(ParseError::Continue),
-                    EvalResult::Float(f) => {
-                        (TypeKind::Float(FloatKind::Double), VarType::Float(f))
-                    }
-                    EvalResult::Char(c) => {
-                        let c = match c {
-                            CChar::Char(c) => {
-                                assert_eq!(c.len_utf8(), 1);
-                                c as u8
-                            }
-                            CChar::Raw(c) => {
-                                assert!(c <= ::std::u8::MAX as u64);
-                                c as u8
-                            }
-                        };
-
-                        (TypeKind::Int(IntKind::U8), VarType::Char(c))
-                    }
-                    EvalResult::Str(val) => {
-                        let char_ty = Item::builtin_type(
-                            TypeKind::Int(IntKind::U8),
-                            true,
-                            ctx,
-                        );
-                        if let Some(callbacks) = ctx.parse_callbacks() {
-                            callbacks.str_macro(&name, &val);
-                        }
-                        (TypeKind::Pointer(char_ty), VarType::String(val))
-                    }
-                    EvalResult::Int(Wrapping(value)) => {
-                        let kind = ctx
-                            .parse_callbacks()
-                            .and_then(|c| c.int_macro(&name, value))
-                            .unwrap_or_else(|| {
-                                default_macro_constant_type(ctx, value)
-                            });
-
-                        (TypeKind::Int(kind), VarType::Int(value))
-                    }
-                };
-
-                let ty = Item::builtin_type(type_kind, true, ctx);
-
-                Ok(ParseResult::New(
-                    Var::new(name, None, ty, Some(val), true),
-                    Some(cursor),
-                ))
-            }
-            CXCursor_VarDecl => {
-                let name = cursor.spelling();
-                if name.is_empty() {
-                    warn!("Empty constant name?");
-                    return Err(ParseError::Continue);
-                }
-
-                let ty = cursor.cur_type();
-
-                // TODO(emilio): do we have to special-case constant arrays in
-                // some other places?
-                let is_const = ty.is_const() ||
-                    (ty.kind() == CXType_ConstantArray &&
-                        ty.elem_type()
-                            .map_or(false, |element| element.is_const()));
-
-                let ty = match Item::from_ty(&ty, cursor, None, ctx) {
-                    Ok(ty) => ty,
-                    Err(e) => {
-                        assert_eq!(
-                            ty.kind(),
-                            CXType_Auto,
-                            "Couldn't resolve constant type, and it \
-                             wasn't an nondeductible auto type!"
-                        );
-                        return Err(e);
-                    }
-                };
-
-                // Note: Ty might not be totally resolved yet, see
-                // tests/headers/inner_const.hpp
-                //
-                // That's fine because in that case we know it's not a literal.
-                let canonical_ty = ctx
-                    .safe_resolve_type(ty)
-                    .and_then(|t| t.safe_canonical_type(ctx));
-
-                let is_integer = canonical_ty.map_or(false, |t| t.is_integer());
-                let is_float = canonical_ty.map_or(false, |t| t.is_float());
-
-                // TODO: We could handle `char` more gracefully.
-                // TODO: Strings, though the lookup is a bit more hard (we need
-                // to look at the canonical type of the pointee too, and check
-                // is char, u8, or i8 I guess).
-                let value = if is_integer {
-                    let kind = match *canonical_ty.unwrap().kind() {
-                        TypeKind::Int(kind) => kind,
-                        _ => unreachable!(),
-                    };
-
-                    let mut val = cursor.evaluate().and_then(|v| v.as_int());
-                    if val.is_none() || !kind.signedness_matches(val.unwrap()) {
-                        val = get_integer_literal_from_cursor(&cursor);
-                    }
-
-                    val.map(|val| {
-                        if kind == IntKind::Bool {
-                            VarType::Bool(val != 0)
-                        } else {
-                            VarType::Int(val)
-                        }
-                    })
-                } else if is_float {
-                    cursor
-                        .evaluate()
-                        .and_then(|v| v.as_double())
-                        .map(VarType::Float)
-                } else {
-                    cursor
-                        .evaluate()
-                        .and_then(|v| v.as_literal_string())
-                        .map(VarType::String)
-                };
-
-                let mangling = cursor_mangling(ctx, &cursor);
-                let var = Var::new(name, mangling, ty, value, is_const);
-
-                Ok(ParseResult::New(var, Some(cursor)))
-            }
-            _ => {
-                /* TODO */
-                Err(ParseError::Continue)
-            }
-        }
-    }
-}
-
-/// Try and parse a macro using all the macros parsed until now.
-fn parse_macro(
-    ctx: &BindgenContext,
-    cursor: &clang::Cursor,
-) -> Option<(Vec<u8>, cexpr::expr::EvalResult)> {
-    use cexpr::expr;
-
-    let cexpr_tokens = cursor.cexpr_tokens();
-
-    let parser = expr::IdentifierParser::new(ctx.parsed_macros());
-
-    match parser.macro_definition(&cexpr_tokens) {
-        Ok((_, (id, val))) => Some((id.into(), val)),
-        _ => None,
-    }
-}
-
-fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option<i64> {
-    use cexpr::expr;
-    use cexpr::expr::EvalResult;
-
-    let cexpr_tokens = cursor.cexpr_tokens();
-
-    // TODO(emilio): We can try to parse other kinds of literals.
-    match expr::expr(&cexpr_tokens) {
-        Ok((_, EvalResult::Int(Wrapping(val)))) => Some(val),
-        _ => None,
-    }
-}
-
-fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option<i64> {
-    use clang_sys::*;
-    let mut value = None;
-    cursor.visit(|c| {
-        match c.kind() {
-            CXCursor_IntegerLiteral | CXCursor_UnaryOperator => {
-                value = parse_int_literal_tokens(&c);
-            }
-            CXCursor_UnexposedExpr => {
-                value = get_integer_literal_from_cursor(&c);
-            }
-            _ => (),
-        }
-        if value.is_some() {
-            CXChildVisit_Break
-        } else {
-            CXChildVisit_Continue
-        }
-    });
-    value
-}
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index 6e6fa225..00000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,2928 +0,0 @@
-//! Generate Rust bindings for C and C++ libraries.
-//!
-//! Provide a C/C++ header file, receive Rust FFI code to call into C/C++
-//! functions and use types defined in the header.
-//!
-//! See the [`Builder`](./struct.Builder.html) struct for usage.
-//!
-//! See the [Users Guide](https://rust-lang.github.io/rust-bindgen/) for
-//! additional documentation.
-#![deny(missing_docs)]
-#![deny(unused_extern_crates)]
-// To avoid rather annoying warnings when matching with CXCursor_xxx as a
-// constant.
-#![allow(non_upper_case_globals)]
-// `quote!` nests quite deeply.
-#![recursion_limit = "128"]
-
-#[macro_use]
-extern crate bitflags;
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
-extern crate quote;
-
-#[cfg(feature = "logging")]
-#[macro_use]
-extern crate log;
-
-#[cfg(not(feature = "logging"))]
-#[macro_use]
-mod log_stubs;
-
-#[macro_use]
-mod extra_assertions;
-
-// A macro to declare an internal module for which we *must* provide
-// documentation for. If we are building with the "testing_only_docs" feature,
-// then the module is declared public, and our `#![deny(missing_docs)]` pragma
-// applies to it. This feature is used in CI, so we won't let anything slip by
-// undocumented. Normal builds, however, will leave the module private, so that
-// we don't expose internals to library consumers.
-macro_rules! doc_mod {
-    ($m:ident, $doc_mod_name:ident) => {
-        #[cfg(feature = "testing_only_docs")]
-        pub mod $doc_mod_name {
-            //! Autogenerated documentation module.
-            pub use super::$m::*;
-        }
-    };
-}
-
-mod clang;
-mod codegen;
-mod deps;
-mod features;
-mod ir;
-mod parse;
-mod regex_set;
-mod time;
-
-pub mod callbacks;
-
-doc_mod!(clang, clang_docs);
-doc_mod!(features, features_docs);
-doc_mod!(ir, ir_docs);
-doc_mod!(parse, parse_docs);
-doc_mod!(regex_set, regex_set_docs);
-
-pub use crate::codegen::{
-    AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
-};
-use crate::features::RustFeatures;
-pub use crate::features::{
-    RustTarget, LATEST_STABLE_RUST, RUST_TARGET_STRINGS,
-};
-use crate::ir::context::{BindgenContext, ItemId};
-use crate::ir::item::Item;
-use crate::parse::{ClangItemParser, ParseError};
-use crate::regex_set::RegexSet;
-
-use std::borrow::Cow;
-use std::fs::{File, OpenOptions};
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-use std::rc::Rc;
-use std::{env, iter};
-
-// Some convenient typedefs for a fast hash map and hash set.
-type HashMap<K, V> = ::rustc_hash::FxHashMap<K, V>;
-type HashSet<K> = ::rustc_hash::FxHashSet<K>;
-pub(crate) use std::collections::hash_map::Entry;
-
-/// Default prefix for the anon fields.
-pub const DEFAULT_ANON_FIELDS_PREFIX: &str = "__bindgen_anon_";
-
-fn file_is_cpp(name_file: &str) -> bool {
-    name_file.ends_with(".hpp") ||
-        name_file.ends_with(".hxx") ||
-        name_file.ends_with(".hh") ||
-        name_file.ends_with(".h++")
-}
-
-fn args_are_cpp(clang_args: &[String]) -> bool {
-    for w in clang_args.windows(2) {
-        if w[0] == "-xc++" || w[1] == "-xc++" {
-            return true;
-        }
-        if w[0] == "-x" && w[1] == "c++" {
-            return true;
-        }
-        if w[0] == "-include" && file_is_cpp(&w[1]) {
-            return true;
-        }
-    }
-    false
-}
-
-bitflags! {
-    /// A type used to indicate which kind of items we have to generate.
-    pub struct CodegenConfig: u32 {
-        /// Whether to generate functions.
-        const FUNCTIONS = 1 << 0;
-        /// Whether to generate types.
-        const TYPES = 1 << 1;
-        /// Whether to generate constants.
-        const VARS = 1 << 2;
-        /// Whether to generate methods.
-        const METHODS = 1 << 3;
-        /// Whether to generate constructors
-        const CONSTRUCTORS = 1 << 4;
-        /// Whether to generate destructors.
-        const DESTRUCTORS = 1 << 5;
-    }
-}
-
-impl CodegenConfig {
-    /// Returns true if functions should be generated.
-    pub fn functions(self) -> bool {
-        self.contains(CodegenConfig::FUNCTIONS)
-    }
-
-    /// Returns true if types should be generated.
-    pub fn types(self) -> bool {
-        self.contains(CodegenConfig::TYPES)
-    }
-
-    /// Returns true if constants should be generated.
-    pub fn vars(self) -> bool {
-        self.contains(CodegenConfig::VARS)
-    }
-
-    /// Returns true if methds should be generated.
-    pub fn methods(self) -> bool {
-        self.contains(CodegenConfig::METHODS)
-    }
-
-    /// Returns true if constructors should be generated.
-    pub fn constructors(self) -> bool {
-        self.contains(CodegenConfig::CONSTRUCTORS)
-    }
-
-    /// Returns true if destructors should be generated.
-    pub fn destructors(self) -> bool {
-        self.contains(CodegenConfig::DESTRUCTORS)
-    }
-}
-
-impl Default for CodegenConfig {
-    fn default() -> Self {
-        CodegenConfig::all()
-    }
-}
-
-/// Configure and generate Rust bindings for a C/C++ header.
-///
-/// This is the main entry point to the library.
-///
-/// ```ignore
-/// use bindgen::builder;
-///
-/// // Configure and generate bindings.
-/// let bindings = builder().header("path/to/input/header")
-///     .allowlist_type("SomeCoolClass")
-///     .allowlist_function("do_some_cool_thing")
-///     .generate()?;
-///
-/// // Write the generated bindings to an output file.
-/// bindings.write_to_file("path/to/output.rs")?;
-/// ```
-///
-/// # Enums
-///
-/// Bindgen can map C/C++ enums into Rust in different ways. The way bindgen maps enums depends on
-/// the pattern passed to several methods:
-///
-/// 1. [`constified_enum_module()`](#method.constified_enum_module)
-/// 2. [`bitfield_enum()`](#method.bitfield_enum)
-/// 3. [`newtype_enum()`](#method.newtype_enum)
-/// 4. [`rustified_enum()`](#method.rustified_enum)
-///
-/// For each C enum, bindgen tries to match the pattern in the following order:
-///
-/// 1. Constified enum module
-/// 2. Bitfield enum
-/// 3. Newtype enum
-/// 4. Rustified enum
-///
-/// If none of the above patterns match, then bindgen will generate a set of Rust constants.
-///
-/// # Clang arguments
-///
-/// Extra arguments can be passed to with clang:
-/// 1. [`clang_arg()`](#method.clang_arg): takes a single argument
-/// 2. [`clang_args()`](#method.clang_args): takes an iterator of arguments
-/// 3. `BINDGEN_EXTRA_CLANG_ARGS` environment variable: whitespace separate
-///    environment variable of arguments
-///
-/// Clang arguments specific to your crate should be added via the
-/// `clang_arg()`/`clang_args()` methods.
-///
-/// End-users of the crate may need to set the `BINDGEN_EXTRA_CLANG_ARGS` environment variable to
-/// add additional arguments. For example, to build against a different sysroot a user could set
-/// `BINDGEN_EXTRA_CLANG_ARGS` to `--sysroot=/path/to/sysroot`.
-#[derive(Debug, Default)]
-pub struct Builder {
-    options: BindgenOptions,
-    input_headers: Vec<String>,
-    // Tuples of unsaved file contents of the form (name, contents).
-    input_header_contents: Vec<(String, String)>,
-}
-
-/// Construct a new [`Builder`](./struct.Builder.html).
-pub fn builder() -> Builder {
-    Default::default()
-}
-
-fn get_extra_clang_args() -> Vec<String> {
-    // Add any extra arguments from the environment to the clang command line.
-    let extra_clang_args =
-        match get_target_dependent_env_var("BINDGEN_EXTRA_CLANG_ARGS") {
-            None => return vec![],
-            Some(s) => s,
-        };
-    // Try to parse it with shell quoting. If we fail, make it one single big argument.
-    if let Some(strings) = shlex::split(&extra_clang_args) {
-        return strings;
-    }
-    vec![extra_clang_args]
-}
-
-impl Builder {
-    /// Generates the command line flags use for creating `Builder`.
-    pub fn command_line_flags(&self) -> Vec<String> {
-        let mut output_vector: Vec<String> = Vec::new();
-
-        if let Some(header) = self.input_headers.last().cloned() {
-            // Positional argument 'header'
-            output_vector.push(header);
-        }
-
-        output_vector.push("--rust-target".into());
-        output_vector.push(self.options.rust_target.into());
-
-        // FIXME(emilio): This is a bit hacky, maybe we should stop re-using the
-        // RustFeatures to store the "disable_untagged_union" call, and make it
-        // a different flag that we check elsewhere / in generate().
-        if !self.options.rust_features.untagged_union &&
-            RustFeatures::from(self.options.rust_target).untagged_union
-        {
-            output_vector.push("--disable-untagged-union".into());
-        }
-
-        if self.options.default_enum_style != Default::default() {
-            output_vector.push("--default-enum-style".into());
-            output_vector.push(
-                match self.options.default_enum_style {
-                    codegen::EnumVariation::Rust {
-                        non_exhaustive: false,
-                    } => "rust",
-                    codegen::EnumVariation::Rust {
-                        non_exhaustive: true,
-                    } => "rust_non_exhaustive",
-                    codegen::EnumVariation::NewType {
-                        is_bitfield: true,
-                        ..
-                    } => "bitfield",
-                    codegen::EnumVariation::NewType {
-                        is_bitfield: false,
-                        is_global,
-                    } => {
-                        if is_global {
-                            "newtype_global"
-                        } else {
-                            "newtype"
-                        }
-                    }
-                    codegen::EnumVariation::Consts => "consts",
-                    codegen::EnumVariation::ModuleConsts => "moduleconsts",
-                }
-                .into(),
-            )
-        }
-
-        if self.options.default_macro_constant_type != Default::default() {
-            output_vector.push("--default-macro-constant-type".into());
-            output_vector
-                .push(self.options.default_macro_constant_type.as_str().into());
-        }
-
-        if self.options.default_alias_style != Default::default() {
-            output_vector.push("--default-alias-style".into());
-            output_vector
-                .push(self.options.default_alias_style.as_str().into());
-        }
-
-        if self.options.default_non_copy_union_style != Default::default() {
-            output_vector.push("--default-non-copy-union-style".into());
-            output_vector.push(
-                self.options.default_non_copy_union_style.as_str().into(),
-            );
-        }
-
-        let regex_sets = &[
-            (&self.options.bitfield_enums, "--bitfield-enum"),
-            (&self.options.newtype_enums, "--newtype-enum"),
-            (&self.options.newtype_global_enums, "--newtype-global-enum"),
-            (&self.options.rustified_enums, "--rustified-enum"),
-            (
-                &self.options.rustified_non_exhaustive_enums,
-                "--rustified-enum-non-exhaustive",
-            ),
-            (
-                &self.options.constified_enum_modules,
-                "--constified-enum-module",
-            ),
-            (&self.options.constified_enums, "--constified-enum"),
-            (&self.options.type_alias, "--type-alias"),
-            (&self.options.new_type_alias, "--new-type-alias"),
-            (&self.options.new_type_alias_deref, "--new-type-alias-deref"),
-            (
-                &self.options.bindgen_wrapper_union,
-                "--bindgen-wrapper-union",
-            ),
-            (&self.options.manually_drop_union, "--manually-drop-union"),
-            (&self.options.blocklisted_types, "--blocklist-type"),
-            (&self.options.blocklisted_functions, "--blocklist-function"),
-            (&self.options.blocklisted_items, "--blocklist-item"),
-            (&self.options.blocklisted_files, "--blocklist-file"),
-            (&self.options.opaque_types, "--opaque-type"),
-            (&self.options.allowlisted_functions, "--allowlist-function"),
-            (&self.options.allowlisted_types, "--allowlist-type"),
-            (&self.options.allowlisted_vars, "--allowlist-var"),
-            (&self.options.allowlisted_files, "--allowlist-file"),
-            (&self.options.no_partialeq_types, "--no-partialeq"),
-            (&self.options.no_copy_types, "--no-copy"),
-            (&self.options.no_debug_types, "--no-debug"),
-            (&self.options.no_default_types, "--no-default"),
-            (&self.options.no_hash_types, "--no-hash"),
-            (&self.options.must_use_types, "--must-use-type"),
-        ];
-
-        for (set, flag) in regex_sets {
-            for item in set.get_items() {
-                output_vector.push((*flag).to_owned());
-                output_vector.push(item.to_owned());
-            }
-        }
-
-        if !self.options.layout_tests {
-            output_vector.push("--no-layout-tests".into());
-        }
-
-        if self.options.impl_debug {
-            output_vector.push("--impl-debug".into());
-        }
-
-        if self.options.impl_partialeq {
-            output_vector.push("--impl-partialeq".into());
-        }
-
-        if !self.options.derive_copy {
-            output_vector.push("--no-derive-copy".into());
-        }
-
-        if !self.options.derive_debug {
-            output_vector.push("--no-derive-debug".into());
-        }
-
-        if !self.options.derive_default {
-            output_vector.push("--no-derive-default".into());
-        } else {
-            output_vector.push("--with-derive-default".into());
-        }
-
-        if self.options.derive_hash {
-            output_vector.push("--with-derive-hash".into());
-        }
-
-        if self.options.derive_partialord {
-            output_vector.push("--with-derive-partialord".into());
-        }
-
-        if self.options.derive_ord {
-            output_vector.push("--with-derive-ord".into());
-        }
-
-        if self.options.derive_partialeq {
-            output_vector.push("--with-derive-partialeq".into());
-        }
-
-        if self.options.derive_eq {
-            output_vector.push("--with-derive-eq".into());
-        }
-
-        if self.options.time_phases {
-            output_vector.push("--time-phases".into());
-        }
-
-        if !self.options.generate_comments {
-            output_vector.push("--no-doc-comments".into());
-        }
-
-        if !self.options.allowlist_recursively {
-            output_vector.push("--no-recursive-allowlist".into());
-        }
-
-        if self.options.objc_extern_crate {
-            output_vector.push("--objc-extern-crate".into());
-        }
-
-        if self.options.generate_block {
-            output_vector.push("--generate-block".into());
-        }
-
-        if self.options.block_extern_crate {
-            output_vector.push("--block-extern-crate".into());
-        }
-
-        if self.options.builtins {
-            output_vector.push("--builtins".into());
-        }
-
-        if let Some(ref prefix) = self.options.ctypes_prefix {
-            output_vector.push("--ctypes-prefix".into());
-            output_vector.push(prefix.clone());
-        }
-
-        if self.options.anon_fields_prefix != DEFAULT_ANON_FIELDS_PREFIX {
-            output_vector.push("--anon-fields-prefix".into());
-            output_vector.push(self.options.anon_fields_prefix.clone());
-        }
-
-        if self.options.emit_ast {
-            output_vector.push("--emit-clang-ast".into());
-        }
-
-        if self.options.emit_ir {
-            output_vector.push("--emit-ir".into());
-        }
-        if let Some(ref graph) = self.options.emit_ir_graphviz {
-            output_vector.push("--emit-ir-graphviz".into());
-            output_vector.push(graph.clone())
-        }
-        if self.options.enable_cxx_namespaces {
-            output_vector.push("--enable-cxx-namespaces".into());
-        }
-        if self.options.enable_function_attribute_detection {
-            output_vector.push("--enable-function-attribute-detection".into());
-        }
-        if self.options.disable_name_namespacing {
-            output_vector.push("--disable-name-namespacing".into());
-        }
-        if self.options.disable_nested_struct_naming {
-            output_vector.push("--disable-nested-struct-naming".into());
-        }
-
-        if self.options.disable_header_comment {
-            output_vector.push("--disable-header-comment".into());
-        }
-
-        if !self.options.codegen_config.functions() {
-            output_vector.push("--ignore-functions".into());
-        }
-
-        output_vector.push("--generate".into());
-
-        //Temporary placeholder for below 4 options
-        let mut options: Vec<String> = Vec::new();
-        if self.options.codegen_config.functions() {
-            options.push("functions".into());
-        }
-        if self.options.codegen_config.types() {
-            options.push("types".into());
-        }
-        if self.options.codegen_config.vars() {
-            options.push("vars".into());
-        }
-        if self.options.codegen_config.methods() {
-            options.push("methods".into());
-        }
-        if self.options.codegen_config.constructors() {
-            options.push("constructors".into());
-        }
-        if self.options.codegen_config.destructors() {
-            options.push("destructors".into());
-        }
-
-        output_vector.push(options.join(","));
-
-        if !self.options.codegen_config.methods() {
-            output_vector.push("--ignore-methods".into());
-        }
-
-        if !self.options.convert_floats {
-            output_vector.push("--no-convert-floats".into());
-        }
-
-        if !self.options.prepend_enum_name {
-            output_vector.push("--no-prepend-enum-name".into());
-        }
-
-        if self.options.fit_macro_constants {
-            output_vector.push("--fit-macro-constant-types".into());
-        }
-
-        if self.options.array_pointers_in_arguments {
-            output_vector.push("--use-array-pointers-in-arguments".into());
-        }
-
-        if let Some(ref wasm_import_module_name) =
-            self.options.wasm_import_module_name
-        {
-            output_vector.push("--wasm-import-module-name".into());
-            output_vector.push(wasm_import_module_name.clone());
-        }
-
-        for line in &self.options.raw_lines {
-            output_vector.push("--raw-line".into());
-            output_vector.push(line.clone());
-        }
-
-        for (module, lines) in &self.options.module_lines {
-            for line in lines.iter() {
-                output_vector.push("--module-raw-line".into());
-                output_vector.push(module.clone());
-                output_vector.push(line.clone());
-            }
-        }
-
-        if self.options.use_core {
-            output_vector.push("--use-core".into());
-        }
-
-        if self.options.conservative_inline_namespaces {
-            output_vector.push("--conservative-inline-namespaces".into());
-        }
-
-        if self.options.generate_inline_functions {
-            output_vector.push("--generate-inline-functions".into());
-        }
-
-        if !self.options.record_matches {
-            output_vector.push("--no-record-matches".into());
-        }
-
-        if !self.options.size_t_is_usize {
-            output_vector.push("--no-size_t-is-usize".into());
-        }
-
-        if !self.options.rustfmt_bindings {
-            output_vector.push("--no-rustfmt-bindings".into());
-        }
-
-        if let Some(path) = self
-            .options
-            .rustfmt_configuration_file
-            .as_ref()
-            .and_then(|f| f.to_str())
-        {
-            output_vector.push("--rustfmt-configuration-file".into());
-            output_vector.push(path.into());
-        }
-
-        if let Some(ref name) = self.options.dynamic_library_name {
-            output_vector.push("--dynamic-loading".into());
-            output_vector.push(name.clone());
-        }
-
-        if self.options.dynamic_link_require_all {
-            output_vector.push("--dynamic-link-require-all".into());
-        }
-
-        if self.options.respect_cxx_access_specs {
-            output_vector.push("--respect-cxx-access-specs".into());
-        }
-
-        if self.options.translate_enum_integer_types {
-            output_vector.push("--translate-enum-integer-types".into());
-        }
-
-        if self.options.c_naming {
-            output_vector.push("--c-naming".into());
-        }
-
-        if self.options.force_explicit_padding {
-            output_vector.push("--explicit-padding".into());
-        }
-
-        if self.options.vtable_generation {
-            output_vector.push("--vtable-generation".into());
-        }
-
-        if self.options.sort_semantically {
-            output_vector.push("--sort-semantically".into());
-        }
-
-        if self.options.merge_extern_blocks {
-            output_vector.push("--merge-extern-blocks".into());
-        }
-
-        // Add clang arguments
-
-        output_vector.push("--".into());
-
-        if !self.options.clang_args.is_empty() {
-            output_vector.extend(self.options.clang_args.iter().cloned());
-        }
-
-        if self.input_headers.len() > 1 {
-            // To pass more than one header, we need to pass all but the last
-            // header via the `-include` clang arg
-            for header in &self.input_headers[..self.input_headers.len() - 1] {
-                output_vector.push("-include".to_string());
-                output_vector.push(header.clone());
-            }
-        }
-
-        output_vector
-    }
-
-    /// Add an input C/C++ header to generate bindings for.
-    ///
-    /// This can be used to generate bindings to a single header:
-    ///
-    /// ```ignore
-    /// let bindings = bindgen::Builder::default()
-    ///     .header("input.h")
-    ///     .generate()
-    ///     .unwrap();
-    /// ```
-    ///
-    /// Or you can invoke it multiple times to generate bindings to multiple
-    /// headers:
-    ///
-    /// ```ignore
-    /// let bindings = bindgen::Builder::default()
-    ///     .header("first.h")
-    ///     .header("second.h")
-    ///     .header("third.h")
-    ///     .generate()
-    ///     .unwrap();
-    /// ```
-    pub fn header<T: Into<String>>(mut self, header: T) -> Builder {
-        self.input_headers.push(header.into());
-        self
-    }
-
-    /// Add a depfile output which will be written alongside the generated bindings.
-    pub fn depfile<H: Into<String>, D: Into<PathBuf>>(
-        mut self,
-        output_module: H,
-        depfile: D,
-    ) -> Builder {
-        self.options.depfile = Some(deps::DepfileSpec {
-            output_module: output_module.into(),
-            depfile_path: depfile.into(),
-        });
-        self
-    }
-
-    /// Add `contents` as an input C/C++ header named `name`.
-    ///
-    /// The file `name` will be added to the clang arguments.
-    pub fn header_contents(mut self, name: &str, contents: &str) -> Builder {
-        // Apparently clang relies on having virtual FS correspondent to
-        // the real one, so we need absolute paths here
-        let absolute_path = env::current_dir()
-            .expect("Cannot retrieve current directory")
-            .join(name)
-            .to_str()
-            .expect("Cannot convert current directory name to string")
-            .to_owned();
-        self.input_header_contents
-            .push((absolute_path, contents.into()));
-        self
-    }
-
-    /// Specify the rust target
-    ///
-    /// The default is the latest stable Rust version
-    pub fn rust_target(mut self, rust_target: RustTarget) -> Self {
-        self.options.set_rust_target(rust_target);
-        self
-    }
-
-    /// Disable support for native Rust unions, if supported.
-    pub fn disable_untagged_union(mut self) -> Self {
-        self.options.rust_features.untagged_union = false;
-        self
-    }
-
-    /// Disable insertion of bindgen's version identifier into generated
-    /// bindings.
-    pub fn disable_header_comment(mut self) -> Self {
-        self.options.disable_header_comment = true;
-        self
-    }
-
-    /// Set the output graphviz file.
-    pub fn emit_ir_graphviz<T: Into<String>>(mut self, path: T) -> Builder {
-        let path = path.into();
-        self.options.emit_ir_graphviz = Some(path);
-        self
-    }
-
-    /// Whether the generated bindings should contain documentation comments
-    /// (docstrings) or not. This is set to true by default.
-    ///
-    /// Note that clang by default excludes comments from system headers, pass
-    /// `-fretain-comments-from-system-headers` as
-    /// [`clang_arg`][Builder::clang_arg] to include them. It can also be told
-    /// to process all comments (not just documentation ones) using the
-    /// `-fparse-all-comments` flag. See [slides on clang comment parsing](
-    /// https://llvm.org/devmtg/2012-11/Gribenko_CommentParsing.pdf) for
-    /// background and examples.
-    pub fn generate_comments(mut self, doit: bool) -> Self {
-        self.options.generate_comments = doit;
-        self
-    }
-
-    /// Whether to allowlist recursively or not. Defaults to true.
-    ///
-    /// Given that we have explicitly allowlisted the "initiate_dance_party"
-    /// function in this C header:
-    ///
-    /// ```c
-    /// typedef struct MoonBoots {
-    ///     int bouncy_level;
-    /// } MoonBoots;
-    ///
-    /// void initiate_dance_party(MoonBoots* boots);
-    /// ```
-    ///
-    /// We would normally generate bindings to both the `initiate_dance_party`
-    /// function and the `MoonBoots` struct that it transitively references. By
-    /// configuring with `allowlist_recursively(false)`, `bindgen` will not emit
-    /// bindings for anything except the explicitly allowlisted items, and there
-    /// would be no emitted struct definition for `MoonBoots`. However, the
-    /// `initiate_dance_party` function would still reference `MoonBoots`!
-    ///
-    /// **Disabling this feature will almost certainly cause `bindgen` to emit
-    /// bindings that will not compile!** If you disable this feature, then it
-    /// is *your* responsibility to provide definitions for every type that is
-    /// referenced from an explicitly allowlisted item. One way to provide the
-    /// definitions is by using the [`Builder::raw_line`](#method.raw_line)
-    /// method, another would be to define them in Rust and then `include!(...)`
-    /// the bindings immediately afterwards.
-    pub fn allowlist_recursively(mut self, doit: bool) -> Self {
-        self.options.allowlist_recursively = doit;
-        self
-    }
-
-    /// Deprecated alias for allowlist_recursively.
-    #[deprecated(note = "Use allowlist_recursively instead")]
-    pub fn whitelist_recursively(self, doit: bool) -> Self {
-        self.allowlist_recursively(doit)
-    }
-
-    /// Generate `#[macro_use] extern crate objc;` instead of `use objc;`
-    /// in the prologue of the files generated from objective-c files
-    pub fn objc_extern_crate(mut self, doit: bool) -> Self {
-        self.options.objc_extern_crate = doit;
-        self
-    }
-
-    /// Generate proper block signatures instead of void pointers.
-    pub fn generate_block(mut self, doit: bool) -> Self {
-        self.options.generate_block = doit;
-        self
-    }
-
-    /// Generate `#[macro_use] extern crate block;` instead of `use block;`
-    /// in the prologue of the files generated from apple block files
-    pub fn block_extern_crate(mut self, doit: bool) -> Self {
-        self.options.block_extern_crate = doit;
-        self
-    }
-
-    /// Whether to use the clang-provided name mangling. This is true by default
-    /// and probably needed for C++ features.
-    ///
-    /// However, some old libclang versions seem to return incorrect results in
-    /// some cases for non-mangled functions, see [1], so we allow disabling it.
-    ///
-    /// [1]: https://github.com/rust-lang/rust-bindgen/issues/528
-    pub fn trust_clang_mangling(mut self, doit: bool) -> Self {
-        self.options.enable_mangling = doit;
-        self
-    }
-
-    /// Hide the given type from the generated bindings. Regular expressions are
-    /// supported.
-    #[deprecated(note = "Use blocklist_type instead")]
-    pub fn hide_type<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.blocklist_type(arg)
-    }
-
-    /// Hide the given type from the generated bindings. Regular expressions are
-    /// supported.
-    #[deprecated(note = "Use blocklist_type instead")]
-    pub fn blacklist_type<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.blocklist_type(arg)
-    }
-
-    /// Hide the given type from the generated bindings. Regular expressions are
-    /// supported.
-    ///
-    /// To blocklist types prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn blocklist_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.blocklisted_types.insert(arg);
-        self
-    }
-
-    /// Hide the given function from the generated bindings. Regular expressions
-    /// are supported.
-    #[deprecated(note = "Use blocklist_function instead")]
-    pub fn blacklist_function<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.blocklist_function(arg)
-    }
-
-    /// Hide the given function from the generated bindings. Regular expressions
-    /// are supported.
-    ///
-    /// To blocklist functions prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn blocklist_function<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.blocklisted_functions.insert(arg);
-        self
-    }
-
-    /// Hide the given item from the generated bindings, regardless of
-    /// whether it's a type, function, module, etc. Regular
-    /// expressions are supported.
-    #[deprecated(note = "Use blocklist_item instead")]
-    pub fn blacklist_item<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.blocklisted_items.insert(arg);
-        self
-    }
-
-    /// Hide the given item from the generated bindings, regardless of
-    /// whether it's a type, function, module, etc. Regular
-    /// expressions are supported.
-    ///
-    /// To blocklist items prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn blocklist_item<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.blocklisted_items.insert(arg);
-        self
-    }
-
-    /// Hide any contents of the given file from the generated bindings,
-    /// regardless of whether it's a type, function, module etc.
-    pub fn blocklist_file<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.blocklisted_files.insert(arg);
-        self
-    }
-
-    /// Treat the given type as opaque in the generated bindings. Regular
-    /// expressions are supported.
-    ///
-    /// To change types prefixed with "mylib" into opaque, use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn opaque_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.opaque_types.insert(arg);
-        self
-    }
-
-    /// Allowlist the given type so that it (and all types that it transitively
-    /// refers to) appears in the generated bindings. Regular expressions are
-    /// supported.
-    #[deprecated(note = "use allowlist_type instead")]
-    pub fn whitelisted_type<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_type(arg)
-    }
-
-    /// Allowlist the given type so that it (and all types that it transitively
-    /// refers to) appears in the generated bindings. Regular expressions are
-    /// supported.
-    #[deprecated(note = "use allowlist_type instead")]
-    pub fn whitelist_type<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_type(arg)
-    }
-
-    /// Allowlist the given type so that it (and all types that it transitively
-    /// refers to) appears in the generated bindings. Regular expressions are
-    /// supported.
-    ///
-    /// To allowlist types prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn allowlist_type<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.allowlisted_types.insert(arg);
-        self
-    }
-
-    /// Allowlist the given function so that it (and all types that it
-    /// transitively refers to) appears in the generated bindings. Regular
-    /// expressions are supported.
-    ///
-    /// To allowlist functions prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn allowlist_function<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.allowlisted_functions.insert(arg);
-        self
-    }
-
-    /// Allowlist the given function.
-    ///
-    /// Deprecated: use allowlist_function instead.
-    #[deprecated(note = "use allowlist_function instead")]
-    pub fn whitelist_function<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_function(arg)
-    }
-
-    /// Allowlist the given function.
-    ///
-    /// Deprecated: use allowlist_function instead.
-    #[deprecated(note = "use allowlist_function instead")]
-    pub fn whitelisted_function<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_function(arg)
-    }
-
-    /// Allowlist the given variable so that it (and all types that it
-    /// transitively refers to) appears in the generated bindings. Regular
-    /// expressions are supported.
-    ///
-    /// To allowlist variables prefixed with "mylib" use `"mylib_.*"`.
-    /// For more complicated expressions check
-    /// [regex](https://docs.rs/regex/*/regex/) docs
-    pub fn allowlist_var<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.allowlisted_vars.insert(arg);
-        self
-    }
-
-    /// Allowlist the given file so that its contents appear in the generated bindings.
-    pub fn allowlist_file<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.allowlisted_files.insert(arg);
-        self
-    }
-
-    /// Deprecated: use allowlist_var instead.
-    #[deprecated(note = "use allowlist_var instead")]
-    pub fn whitelist_var<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_var(arg)
-    }
-
-    /// Allowlist the given variable.
-    ///
-    /// Deprecated: use allowlist_var instead.
-    #[deprecated(note = "use allowlist_var instead")]
-    pub fn whitelisted_var<T: AsRef<str>>(self, arg: T) -> Builder {
-        self.allowlist_var(arg)
-    }
-
-    /// Set the default style of code to generate for enums
-    pub fn default_enum_style(
-        mut self,
-        arg: codegen::EnumVariation,
-    ) -> Builder {
-        self.options.default_enum_style = arg;
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as being
-    /// bitfield-like. Regular expressions are supported.
-    ///
-    /// This makes bindgen generate a type that isn't a rust `enum`. Regular
-    /// expressions are supported.
-    ///
-    /// This is similar to the newtype enum style, but with the bitwise
-    /// operators implemented.
-    pub fn bitfield_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.bitfield_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a newtype.
-    /// Regular expressions are supported.
-    ///
-    /// This makes bindgen generate a type that isn't a Rust `enum`. Regular
-    /// expressions are supported.
-    pub fn newtype_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.newtype_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a newtype
-    /// whose variants are exposed as global constants.
-    ///
-    /// Regular expressions are supported.
-    ///
-    /// This makes bindgen generate a type that isn't a Rust `enum`. Regular
-    /// expressions are supported.
-    pub fn newtype_global_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.newtype_global_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a Rust
-    /// enum.
-    ///
-    /// This makes bindgen generate enums instead of constants. Regular
-    /// expressions are supported.
-    ///
-    /// **Use this with caution**, creating this in unsafe code
-    /// (including FFI) with an invalid value will invoke undefined behaviour.
-    /// You may want to use the newtype enum style instead.
-    pub fn rustified_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.rustified_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a Rust
-    /// enum with the `#[non_exhaustive]` attribute.
-    ///
-    /// This makes bindgen generate enums instead of constants. Regular
-    /// expressions are supported.
-    ///
-    /// **Use this with caution**, creating this in unsafe code
-    /// (including FFI) with an invalid value will invoke undefined behaviour.
-    /// You may want to use the newtype enum style instead.
-    pub fn rustified_non_exhaustive_enum<T: AsRef<str>>(
-        mut self,
-        arg: T,
-    ) -> Builder {
-        self.options.rustified_non_exhaustive_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a set of
-    /// constants that are not to be put into a module.
-    pub fn constified_enum<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.constified_enums.insert(arg);
-        self
-    }
-
-    /// Mark the given enum (or set of enums, if using a pattern) as a set of
-    /// constants that should be put into a module.
-    ///
-    /// This makes bindgen generate modules containing constants instead of
-    /// just constants. Regular expressions are supported.
-    pub fn constified_enum_module<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.constified_enum_modules.insert(arg);
-        self
-    }
-
-    /// Set the default type for macro constants
-    pub fn default_macro_constant_type(
-        mut self,
-        arg: codegen::MacroTypeVariation,
-    ) -> Builder {
-        self.options.default_macro_constant_type = arg;
-        self
-    }
-
-    /// Set the default style of code to generate for typedefs
-    pub fn default_alias_style(
-        mut self,
-        arg: codegen::AliasVariation,
-    ) -> Builder {
-        self.options.default_alias_style = arg;
-        self
-    }
-
-    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
-    /// use regular Rust type aliasing.
-    ///
-    /// This is the default behavior and should be used if `default_alias_style`
-    /// was set to NewType or NewTypeDeref and you want to override it for a
-    /// set of typedefs.
-    pub fn type_alias<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.type_alias.insert(arg);
-        self
-    }
-
-    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
-    /// be generated as a new type by having the aliased type be wrapped in a
-    /// #[repr(transparent)] struct.
-    ///
-    /// Used to enforce stricter type checking.
-    pub fn new_type_alias<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.new_type_alias.insert(arg);
-        self
-    }
-
-    /// Mark the given typedef alias (or set of aliases, if using a pattern) to
-    /// be generated as a new type by having the aliased type be wrapped in a
-    /// #[repr(transparent)] struct and also have an automatically generated
-    /// impl's of `Deref` and `DerefMut` to their aliased type.
-    pub fn new_type_alias_deref<T: AsRef<str>>(mut self, arg: T) -> Builder {
-        self.options.new_type_alias_deref.insert(arg);
-        self
-    }
-
-    /// Set the default style of code to generate for unions with a non-Copy member.
-    pub fn default_non_copy_union_style(
-        mut self,
-        arg: codegen::NonCopyUnionStyle,
-    ) -> Self {
-        self.options.default_non_copy_union_style = arg;
-        self
-    }
-
-    /// Mark the given union (or set of union, if using a pattern) to use
-    /// a bindgen-generated wrapper for its members if at least one is non-Copy.
-    pub fn bindgen_wrapper_union<T: AsRef<str>>(mut self, arg: T) -> Self {
-        self.options.bindgen_wrapper_union.insert(arg);
-        self
-    }
-
-    /// Mark the given union (or set of union, if using a pattern) to use
-    /// [`::core::mem::ManuallyDrop`] for its members if at least one is non-Copy.
-    ///
-    /// Note: `ManuallyDrop` was stabilized in Rust 1.20.0, do not use it if your
-    /// MSRV is lower.
-    pub fn manually_drop_union<T: AsRef<str>>(mut self, arg: T) -> Self {
-        self.options.manually_drop_union.insert(arg);
-        self
-    }
-
-    /// Add a string to prepend to the generated bindings. The string is passed
-    /// through without any modification.
-    pub fn raw_line<T: Into<String>>(mut self, arg: T) -> Self {
-        self.options.raw_lines.push(arg.into());
-        self
-    }
-
-    /// Add a given line to the beginning of module `mod`.
-    pub fn module_raw_line<T, U>(mut self, mod_: T, line: U) -> Self
-    where
-        T: Into<String>,
-        U: Into<String>,
-    {
-        self.options
-            .module_lines
-            .entry(mod_.into())
-            .or_insert_with(Vec::new)
-            .push(line.into());
-        self
-    }
-
-    /// Add a given set of lines to the beginning of module `mod`.
-    pub fn module_raw_lines<T, I>(mut self, mod_: T, lines: I) -> Self
-    where
-        T: Into<String>,
-        I: IntoIterator,
-        I::Item: Into<String>,
-    {
-        self.options
-            .module_lines
-            .entry(mod_.into())
-            .or_insert_with(Vec::new)
-            .extend(lines.into_iter().map(Into::into));
-        self
-    }
-
-    /// Add an argument to be passed straight through to clang.
-    pub fn clang_arg<T: Into<String>>(mut self, arg: T) -> Builder {
-        self.options.clang_args.push(arg.into());
-        self
-    }
-
-    /// Add arguments to be passed straight through to clang.
-    pub fn clang_args<I>(mut self, iter: I) -> Builder
-    where
-        I: IntoIterator,
-        I::Item: AsRef<str>,
-    {
-        for arg in iter {
-            self = self.clang_arg(arg.as_ref())
-        }
-        self
-    }
-
-    /// Emit bindings for builtin definitions (for example `__builtin_va_list`)
-    /// in the generated Rust.
-    pub fn emit_builtins(mut self) -> Builder {
-        self.options.builtins = true;
-        self
-    }
-
-    /// Avoid converting floats to `f32`/`f64` by default.
-    pub fn no_convert_floats(mut self) -> Self {
-        self.options.convert_floats = false;
-        self
-    }
-
-    /// Set whether layout tests should be generated.
-    pub fn layout_tests(mut self, doit: bool) -> Self {
-        self.options.layout_tests = doit;
-        self
-    }
-
-    /// Set whether `Debug` should be implemented, if it can not be derived automatically.
-    pub fn impl_debug(mut self, doit: bool) -> Self {
-        self.options.impl_debug = doit;
-        self
-    }
-
-    /// Set whether `PartialEq` should be implemented, if it can not be derived automatically.
-    pub fn impl_partialeq(mut self, doit: bool) -> Self {
-        self.options.impl_partialeq = doit;
-        self
-    }
-
-    /// Set whether `Copy` should be derived by default.
-    pub fn derive_copy(mut self, doit: bool) -> Self {
-        self.options.derive_copy = doit;
-        self
-    }
-
-    /// Set whether `Debug` should be derived by default.
-    pub fn derive_debug(mut self, doit: bool) -> Self {
-        self.options.derive_debug = doit;
-        self
-    }
-
-    /// Set whether `Default` should be derived by default.
-    pub fn derive_default(mut self, doit: bool) -> Self {
-        self.options.derive_default = doit;
-        self
-    }
-
-    /// Set whether `Hash` should be derived by default.
-    pub fn derive_hash(mut self, doit: bool) -> Self {
-        self.options.derive_hash = doit;
-        self
-    }
-
-    /// Set whether `PartialOrd` should be derived by default.
-    /// If we don't compute partialord, we also cannot compute
-    /// ord. Set the derive_ord to `false` when doit is `false`.
-    pub fn derive_partialord(mut self, doit: bool) -> Self {
-        self.options.derive_partialord = doit;
-        if !doit {
-            self.options.derive_ord = false;
-        }
-        self
-    }
-
-    /// Set whether `Ord` should be derived by default.
-    /// We can't compute `Ord` without computing `PartialOrd`,
-    /// so we set the same option to derive_partialord.
-    pub fn derive_ord(mut self, doit: bool) -> Self {
-        self.options.derive_ord = doit;
-        self.options.derive_partialord = doit;
-        self
-    }
-
-    /// Set whether `PartialEq` should be derived by default.
-    ///
-    /// If we don't derive `PartialEq`, we also cannot derive `Eq`, so deriving
-    /// `Eq` is also disabled when `doit` is `false`.
-    pub fn derive_partialeq(mut self, doit: bool) -> Self {
-        self.options.derive_partialeq = doit;
-        if !doit {
-            self.options.derive_eq = false;
-        }
-        self
-    }
-
-    /// Set whether `Eq` should be derived by default.
-    ///
-    /// We can't derive `Eq` without also deriving `PartialEq`, so we also
-    /// enable deriving `PartialEq` when `doit` is `true`.
-    pub fn derive_eq(mut self, doit: bool) -> Self {
-        self.options.derive_eq = doit;
-        if doit {
-            self.options.derive_partialeq = doit;
-        }
-        self
-    }
-
-    /// Set whether or not to time bindgen phases, and print information to
-    /// stderr.
-    pub fn time_phases(mut self, doit: bool) -> Self {
-        self.options.time_phases = doit;
-        self
-    }
-
-    /// Emit Clang AST.
-    pub fn emit_clang_ast(mut self) -> Builder {
-        self.options.emit_ast = true;
-        self
-    }
-
-    /// Emit IR.
-    pub fn emit_ir(mut self) -> Builder {
-        self.options.emit_ir = true;
-        self
-    }
-
-    /// Enable C++ namespaces.
-    pub fn enable_cxx_namespaces(mut self) -> Builder {
-        self.options.enable_cxx_namespaces = true;
-        self
-    }
-
-    /// Enable detecting must_use attributes on C functions.
-    ///
-    /// This is quite slow in some cases (see #1465), so it's disabled by
-    /// default.
-    ///
-    /// Note that for this to do something meaningful for now at least, the rust
-    /// target version has to have support for `#[must_use]`.
-    pub fn enable_function_attribute_detection(mut self) -> Self {
-        self.options.enable_function_attribute_detection = true;
-        self
-    }
-
-    /// Disable name auto-namespacing.
-    ///
-    /// By default, bindgen mangles names like `foo::bar::Baz` to look like
-    /// `foo_bar_Baz` instead of just `Baz`.
-    ///
-    /// This method disables that behavior.
-    ///
-    /// Note that this intentionally does not change the names used for
-    /// allowlisting and blocklisting, which should still be mangled with the
-    /// namespaces.
-    ///
-    /// Note, also, that this option may cause bindgen to generate duplicate
-    /// names.
-    pub fn disable_name_namespacing(mut self) -> Builder {
-        self.options.disable_name_namespacing = true;
-        self
-    }
-
-    /// Disable nested struct naming.
-    ///
-    /// The following structs have different names for C and C++. In case of C
-    /// they are visible as `foo` and `bar`. In case of C++ they are visible as
-    /// `foo` and `foo::bar`.
-    ///
-    /// ```c
-    /// struct foo {
-    ///     struct bar {
-    ///     } b;
-    /// };
-    /// ```
-    ///
-    /// Bindgen wants to avoid duplicate names by default so it follows C++ naming
-    /// and it generates `foo`/`foo_bar` instead of just `foo`/`bar`.
-    ///
-    /// This method disables this behavior and it is indented to be used only
-    /// for headers that were written for C.
-    pub fn disable_nested_struct_naming(mut self) -> Builder {
-        self.options.disable_nested_struct_naming = true;
-        self
-    }
-
-    /// Treat inline namespaces conservatively.
-    ///
-    /// This is tricky, because in C++ is technically legal to override an item
-    /// defined in an inline namespace:
-    ///
-    /// ```cpp
-    /// inline namespace foo {
-    ///     using Bar = int;
-    /// }
-    /// using Bar = long;
-    /// ```
-    ///
-    /// Even though referencing `Bar` is a compiler error.
-    ///
-    /// We want to support this (arguably esoteric) use case, but we don't want
-    /// to make the rest of bindgen users pay an usability penalty for that.
-    ///
-    /// To support this, we need to keep all the inline namespaces around, but
-    /// then bindgen usage is a bit more difficult, because you cannot
-    /// reference, e.g., `std::string` (you'd need to use the proper inline
-    /// namespace).
-    ///
-    /// We could complicate a lot of the logic to detect name collisions, and if
-    /// not detected generate a `pub use inline_ns::*` or something like that.
-    ///
-    /// That's probably something we can do if we see this option is needed in a
-    /// lot of cases, to improve it's usability, but my guess is that this is
-    /// not going to be too useful.
-    pub fn conservative_inline_namespaces(mut self) -> Builder {
-        self.options.conservative_inline_namespaces = true;
-        self
-    }
-
-    /// Whether inline functions should be generated or not.
-    ///
-    /// Note that they will usually not work. However you can use
-    /// `-fkeep-inline-functions` or `-fno-inline-functions` if you are
-    /// responsible of compiling the library to make them callable.
-    pub fn generate_inline_functions(mut self, doit: bool) -> Self {
-        self.options.generate_inline_functions = doit;
-        self
-    }
-
-    /// Ignore functions.
-    pub fn ignore_functions(mut self) -> Builder {
-        self.options.codegen_config.remove(CodegenConfig::FUNCTIONS);
-        self
-    }
-
-    /// Ignore methods.
-    pub fn ignore_methods(mut self) -> Builder {
-        self.options.codegen_config.remove(CodegenConfig::METHODS);
-        self
-    }
-
-    /// Avoid generating any unstable Rust, such as Rust unions, in the generated bindings.
-    #[deprecated(note = "please use `rust_target` instead")]
-    pub fn unstable_rust(self, doit: bool) -> Self {
-        let rust_target = if doit {
-            RustTarget::Nightly
-        } else {
-            LATEST_STABLE_RUST
-        };
-        self.rust_target(rust_target)
-    }
-
-    /// Use core instead of libstd in the generated bindings.
-    pub fn use_core(mut self) -> Builder {
-        self.options.use_core = true;
-        self
-    }
-
-    /// Use the given prefix for the raw types instead of `::std::os::raw`.
-    pub fn ctypes_prefix<T: Into<String>>(mut self, prefix: T) -> Builder {
-        self.options.ctypes_prefix = Some(prefix.into());
-        self
-    }
-
-    /// Use the given prefix for the anon fields.
-    pub fn anon_fields_prefix<T: Into<String>>(mut self, prefix: T) -> Builder {
-        self.options.anon_fields_prefix = prefix.into();
-        self
-    }
-
-    /// Allows configuring types in different situations, see the
-    /// [`ParseCallbacks`](./callbacks/trait.ParseCallbacks.html) documentation.
-    pub fn parse_callbacks(
-        mut self,
-        cb: Box<dyn callbacks::ParseCallbacks>,
-    ) -> Self {
-        self.options.parse_callbacks = Some(Rc::from(cb));
-        self
-    }
-
-    /// Choose what to generate using a
-    /// [`CodegenConfig`](./struct.CodegenConfig.html).
-    pub fn with_codegen_config(mut self, config: CodegenConfig) -> Self {
-        self.options.codegen_config = config;
-        self
-    }
-
-    /// Whether to detect include paths using clang_sys.
-    pub fn detect_include_paths(mut self, doit: bool) -> Self {
-        self.options.detect_include_paths = doit;
-        self
-    }
-
-    /// Whether to try to fit macro constants to types smaller than u32/i32
-    pub fn fit_macro_constants(mut self, doit: bool) -> Self {
-        self.options.fit_macro_constants = doit;
-        self
-    }
-
-    /// Prepend the enum name to constant or newtype variants.
-    pub fn prepend_enum_name(mut self, doit: bool) -> Self {
-        self.options.prepend_enum_name = doit;
-        self
-    }
-
-    /// Set whether `size_t` should be translated to `usize` automatically.
-    pub fn size_t_is_usize(mut self, is: bool) -> Self {
-        self.options.size_t_is_usize = is;
-        self
-    }
-
-    /// Set whether rustfmt should format the generated bindings.
-    pub fn rustfmt_bindings(mut self, doit: bool) -> Self {
-        self.options.rustfmt_bindings = doit;
-        self
-    }
-
-    /// Set whether we should record matched items in our regex sets.
-    pub fn record_matches(mut self, doit: bool) -> Self {
-        self.options.record_matches = doit;
-        self
-    }
-
-    /// Set the absolute path to the rustfmt configuration file, if None, the standard rustfmt
-    /// options are used.
-    pub fn rustfmt_configuration_file(mut self, path: Option<PathBuf>) -> Self {
-        self = self.rustfmt_bindings(true);
-        self.options.rustfmt_configuration_file = path;
-        self
-    }
-
-    /// Sets an explicit path to rustfmt, to be used when rustfmt is enabled.
-    pub fn with_rustfmt<P: Into<PathBuf>>(mut self, path: P) -> Self {
-        self.options.rustfmt_path = Some(path.into());
-        self
-    }
-
-    /// If true, always emit explicit padding fields.
-    ///
-    /// If a struct needs to be serialized in its native format (padding bytes
-    /// and all), for example writing it to a file or sending it on the network,
-    /// then this should be enabled, as anything reading the padding bytes of
-    /// a struct may lead to Undefined Behavior.
-    pub fn explicit_padding(mut self, doit: bool) -> Self {
-        self.options.force_explicit_padding = doit;
-        self
-    }
-
-    /// If true, enables experimental support to generate vtable functions.
-    ///
-    /// Should mostly work, though some edge cases are likely to be broken.
-    pub fn vtable_generation(mut self, doit: bool) -> Self {
-        self.options.vtable_generation = doit;
-        self
-    }
-
-    /// If true, enables the sorting of the output in a predefined manner.
-    ///
-    /// TODO: Perhaps move the sorting order out into a config
-    pub fn sort_semantically(mut self, doit: bool) -> Self {
-        self.options.sort_semantically = doit;
-        self
-    }
-
-    /// If true, merges extern blocks.
-    pub fn merge_extern_blocks(mut self, doit: bool) -> Self {
-        self.options.merge_extern_blocks = doit;
-        self
-    }
-
-    /// Generate the Rust bindings using the options built up thus far.
-    pub fn generate(mut self) -> Result<Bindings, BindgenError> {
-        // Add any extra arguments from the environment to the clang command line.
-        self.options.clang_args.extend(get_extra_clang_args());
-
-        // Transform input headers to arguments on the clang command line.
-        self.options.input_header = self.input_headers.pop();
-        self.options.extra_input_headers = self.input_headers;
-        self.options.clang_args.extend(
-            self.options.extra_input_headers.iter().flat_map(|header| {
-                iter::once("-include".into())
-                    .chain(iter::once(header.to_string()))
-            }),
-        );
-
-        let input_unsaved_files = self
-            .input_header_contents
-            .into_iter()
-            .map(|(name, contents)| clang::UnsavedFile::new(&name, &contents))
-            .collect::<Vec<_>>();
-
-        Bindings::generate(self.options, input_unsaved_files)
-    }
-
-    /// Preprocess and dump the input header files to disk.
-    ///
-    /// This is useful when debugging bindgen, using C-Reduce, or when filing
-    /// issues. The resulting file will be named something like `__bindgen.i` or
-    /// `__bindgen.ii`
-    pub fn dump_preprocessed_input(&self) -> io::Result<()> {
-        let clang =
-            clang_sys::support::Clang::find(None, &[]).ok_or_else(|| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    "Cannot find clang executable",
-                )
-            })?;
-
-        // The contents of a wrapper file that includes all the input header
-        // files.
-        let mut wrapper_contents = String::new();
-
-        // Whether we are working with C or C++ inputs.
-        let mut is_cpp = args_are_cpp(&self.options.clang_args);
-
-        // For each input header, add `#include "$header"`.
-        for header in &self.input_headers {
-            is_cpp |= file_is_cpp(header);
-
-            wrapper_contents.push_str("#include \"");
-            wrapper_contents.push_str(header);
-            wrapper_contents.push_str("\"\n");
-        }
-
-        // For each input header content, add a prefix line of `#line 0 "$name"`
-        // followed by the contents.
-        for &(ref name, ref contents) in &self.input_header_contents {
-            is_cpp |= file_is_cpp(name);
-
-            wrapper_contents.push_str("#line 0 \"");
-            wrapper_contents.push_str(name);
-            wrapper_contents.push_str("\"\n");
-            wrapper_contents.push_str(contents);
-        }
-
-        let wrapper_path = PathBuf::from(if is_cpp {
-            "__bindgen.cpp"
-        } else {
-            "__bindgen.c"
-        });
-
-        {
-            let mut wrapper_file = File::create(&wrapper_path)?;
-            wrapper_file.write_all(wrapper_contents.as_bytes())?;
-        }
-
-        let mut cmd = Command::new(&clang.path);
-        cmd.arg("-save-temps")
-            .arg("-E")
-            .arg("-C")
-            .arg("-c")
-            .arg(&wrapper_path)
-            .stdout(Stdio::piped());
-
-        for a in &self.options.clang_args {
-            cmd.arg(a);
-        }
-
-        for a in get_extra_clang_args() {
-            cmd.arg(a);
-        }
-
-        let mut child = cmd.spawn()?;
-
-        let mut preprocessed = child.stdout.take().unwrap();
-        let mut file = File::create(if is_cpp {
-            "__bindgen.ii"
-        } else {
-            "__bindgen.i"
-        })?;
-        io::copy(&mut preprocessed, &mut file)?;
-
-        if child.wait()?.success() {
-            Ok(())
-        } else {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                "clang exited with non-zero status",
-            ))
-        }
-    }
-
-    /// Don't derive `PartialEq` for a given type. Regular
-    /// expressions are supported.
-    pub fn no_partialeq<T: Into<String>>(mut self, arg: T) -> Builder {
-        self.options.no_partialeq_types.insert(arg.into());
-        self
-    }
-
-    /// Don't derive `Copy` for a given type. Regular
-    /// expressions are supported.
-    pub fn no_copy<T: Into<String>>(mut self, arg: T) -> Self {
-        self.options.no_copy_types.insert(arg.into());
-        self
-    }
-
-    /// Don't derive `Debug` for a given type. Regular
-    /// expressions are supported.
-    pub fn no_debug<T: Into<String>>(mut self, arg: T) -> Self {
-        self.options.no_debug_types.insert(arg.into());
-        self
-    }
-
-    /// Don't derive/impl `Default` for a given type. Regular
-    /// expressions are supported.
-    pub fn no_default<T: Into<String>>(mut self, arg: T) -> Self {
-        self.options.no_default_types.insert(arg.into());
-        self
-    }
-
-    /// Don't derive `Hash` for a given type. Regular
-    /// expressions are supported.
-    pub fn no_hash<T: Into<String>>(mut self, arg: T) -> Builder {
-        self.options.no_hash_types.insert(arg.into());
-        self
-    }
-
-    /// Add `#[must_use]` for the given type. Regular
-    /// expressions are supported.
-    pub fn must_use_type<T: Into<String>>(mut self, arg: T) -> Builder {
-        self.options.must_use_types.insert(arg.into());
-        self
-    }
-
-    /// Set whether `arr[size]` should be treated as `*mut T` or `*mut [T; size]` (same for mut)
-    pub fn array_pointers_in_arguments(mut self, doit: bool) -> Self {
-        self.options.array_pointers_in_arguments = doit;
-        self
-    }
-
-    /// Set the wasm import module name
-    pub fn wasm_import_module_name<T: Into<String>>(
-        mut self,
-        import_name: T,
-    ) -> Self {
-        self.options.wasm_import_module_name = Some(import_name.into());
-        self
-    }
-
-    /// Specify the dynamic library name if we are generating bindings for a shared library.
-    pub fn dynamic_library_name<T: Into<String>>(
-        mut self,
-        dynamic_library_name: T,
-    ) -> Self {
-        self.options.dynamic_library_name = Some(dynamic_library_name.into());
-        self
-    }
-
-    /// Require successful linkage for all routines in a shared library.
-    /// This allows us to optimize function calls by being able to safely assume function pointers
-    /// are valid.
-    pub fn dynamic_link_require_all(mut self, req: bool) -> Self {
-        self.options.dynamic_link_require_all = req;
-        self
-    }
-
-    /// Generate bindings as `pub` only if the bound item is publically accessible by C++.
-    pub fn respect_cxx_access_specs(mut self, doit: bool) -> Self {
-        self.options.respect_cxx_access_specs = doit;
-        self
-    }
-
-    /// Always translate enum integer types to native Rust integer types.
-    ///
-    /// This will result in enums having types such as `u32` and `i16` instead
-    /// of `c_uint` and `c_short`. Types for Rustified enums are always
-    /// translated.
-    pub fn translate_enum_integer_types(mut self, doit: bool) -> Self {
-        self.options.translate_enum_integer_types = doit;
-        self
-    }
-
-    /// Generate types with C style naming.
-    ///
-    /// This will add prefixes to the generated type names. For example instead of a struct `A` we
-    /// will generate struct `struct_A`. Currently applies to structs, unions, and enums.
-    pub fn c_naming(mut self, doit: bool) -> Self {
-        self.options.c_naming = doit;
-        self
-    }
-}
-
-/// Configuration options for generated bindings.
-#[derive(Clone, Debug)]
-struct BindgenOptions {
-    /// The set of types that have been blocklisted and should not appear
-    /// anywhere in the generated code.
-    blocklisted_types: RegexSet,
-
-    /// The set of functions that have been blocklisted and should not appear
-    /// in the generated code.
-    blocklisted_functions: RegexSet,
-
-    /// The set of items, regardless of item-type, that have been
-    /// blocklisted and should not appear in the generated code.
-    blocklisted_items: RegexSet,
-
-    /// The set of files whose contents should be blocklisted and should not
-    /// appear in the generated code.
-    blocklisted_files: RegexSet,
-
-    /// The set of types that should be treated as opaque structures in the
-    /// generated code.
-    opaque_types: RegexSet,
-
-    /// The explicit rustfmt path.
-    rustfmt_path: Option<PathBuf>,
-
-    /// The path to which we should write a Makefile-syntax depfile (if any).
-    depfile: Option<deps::DepfileSpec>,
-
-    /// The set of types that we should have bindings for in the generated
-    /// code.
-    ///
-    /// This includes all types transitively reachable from any type in this
-    /// set. One might think of allowlisted types/vars/functions as GC roots,
-    /// and the generated Rust code as including everything that gets marked.
-    allowlisted_types: RegexSet,
-
-    /// Allowlisted functions. See docs for `allowlisted_types` for more.
-    allowlisted_functions: RegexSet,
-
-    /// Allowlisted variables. See docs for `allowlisted_types` for more.
-    allowlisted_vars: RegexSet,
-
-    /// The set of files whose contents should be allowlisted.
-    allowlisted_files: RegexSet,
-
-    /// The default style of code to generate for enums
-    default_enum_style: codegen::EnumVariation,
-
-    /// The enum patterns to mark an enum as a bitfield
-    /// (newtype with bitwise operations).
-    bitfield_enums: RegexSet,
-
-    /// The enum patterns to mark an enum as a newtype.
-    newtype_enums: RegexSet,
-
-    /// The enum patterns to mark an enum as a global newtype.
-    newtype_global_enums: RegexSet,
-
-    /// The enum patterns to mark an enum as a Rust enum.
-    rustified_enums: RegexSet,
-
-    /// The enum patterns to mark an enum as a non-exhaustive Rust enum.
-    rustified_non_exhaustive_enums: RegexSet,
-
-    /// The enum patterns to mark an enum as a module of constants.
-    constified_enum_modules: RegexSet,
-
-    /// The enum patterns to mark an enum as a set of constants.
-    constified_enums: RegexSet,
-
-    /// The default type for C macro constants.
-    default_macro_constant_type: codegen::MacroTypeVariation,
-
-    /// The default style of code to generate for typedefs.
-    default_alias_style: codegen::AliasVariation,
-
-    /// Typedef patterns that will use regular type aliasing.
-    type_alias: RegexSet,
-
-    /// Typedef patterns that will be aliased by creating a new struct.
-    new_type_alias: RegexSet,
-
-    /// Typedef patterns that will be wrapped in a new struct and have
-    /// Deref and Deref to their aliased type.
-    new_type_alias_deref: RegexSet,
-
-    /// The default style of code to generate for union containing non-Copy
-    /// members.
-    default_non_copy_union_style: codegen::NonCopyUnionStyle,
-
-    /// The union patterns to mark an non-Copy union as using the bindgen
-    /// generated wrapper.
-    bindgen_wrapper_union: RegexSet,
-
-    /// The union patterns to mark an non-Copy union as using the
-    /// `::core::mem::ManuallyDrop` wrapper.
-    manually_drop_union: RegexSet,
-
-    /// Whether we should generate builtins or not.
-    builtins: bool,
-
-    /// True if we should dump the Clang AST for debugging purposes.
-    emit_ast: bool,
-
-    /// True if we should dump our internal IR for debugging purposes.
-    emit_ir: bool,
-
-    /// Output graphviz dot file.
-    emit_ir_graphviz: Option<String>,
-
-    /// True if we should emulate C++ namespaces with Rust modules in the
-    /// generated bindings.
-    enable_cxx_namespaces: bool,
-
-    /// True if we should try to find unexposed attributes in functions, in
-    /// order to be able to generate #[must_use] attributes in Rust.
-    enable_function_attribute_detection: bool,
-
-    /// True if we should avoid mangling names with namespaces.
-    disable_name_namespacing: bool,
-
-    /// True if we should avoid generating nested struct names.
-    disable_nested_struct_naming: bool,
-
-    /// True if we should avoid embedding version identifiers into source code.
-    disable_header_comment: bool,
-
-    /// True if we should generate layout tests for generated structures.
-    layout_tests: bool,
-
-    /// True if we should implement the Debug trait for C/C++ structures and types
-    /// that do not support automatically deriving Debug.
-    impl_debug: bool,
-
-    /// True if we should implement the PartialEq trait for C/C++ structures and types
-    /// that do not support automatically deriving PartialEq.
-    impl_partialeq: bool,
-
-    /// True if we should derive Copy trait implementations for C/C++ structures
-    /// and types.
-    derive_copy: bool,
-
-    /// True if we should derive Debug trait implementations for C/C++ structures
-    /// and types.
-    derive_debug: bool,
-
-    /// True if we should derive Default trait implementations for C/C++ structures
-    /// and types.
-    derive_default: bool,
-
-    /// True if we should derive Hash trait implementations for C/C++ structures
-    /// and types.
-    derive_hash: bool,
-
-    /// True if we should derive PartialOrd trait implementations for C/C++ structures
-    /// and types.
-    derive_partialord: bool,
-
-    /// True if we should derive Ord trait implementations for C/C++ structures
-    /// and types.
-    derive_ord: bool,
-
-    /// True if we should derive PartialEq trait implementations for C/C++ structures
-    /// and types.
-    derive_partialeq: bool,
-
-    /// True if we should derive Eq trait implementations for C/C++ structures
-    /// and types.
-    derive_eq: bool,
-
-    /// True if we should avoid using libstd to use libcore instead.
-    use_core: bool,
-
-    /// An optional prefix for the "raw" types, like `c_int`, `c_void`...
-    ctypes_prefix: Option<String>,
-
-    /// The prefix for the anon fields.
-    anon_fields_prefix: String,
-
-    /// Whether to time the bindgen phases.
-    time_phases: bool,
-
-    /// Whether we should convert float types to f32/f64 types.
-    convert_floats: bool,
-
-    /// The set of raw lines to prepend to the top-level module of generated
-    /// Rust code.
-    raw_lines: Vec<String>,
-
-    /// The set of raw lines to prepend to each of the modules.
-    ///
-    /// This only makes sense if the `enable_cxx_namespaces` option is set.
-    module_lines: HashMap<String, Vec<String>>,
-
-    /// The set of arguments to pass straight through to Clang.
-    clang_args: Vec<String>,
-
-    /// The input header file.
-    input_header: Option<String>,
-
-    /// Any additional input header files.
-    extra_input_headers: Vec<String>,
-
-    /// A user-provided visitor to allow customizing different kinds of
-    /// situations.
-    parse_callbacks: Option<Rc<dyn callbacks::ParseCallbacks>>,
-
-    /// Which kind of items should we generate? By default, we'll generate all
-    /// of them.
-    codegen_config: CodegenConfig,
-
-    /// Whether to treat inline namespaces conservatively.
-    ///
-    /// See the builder method description for more details.
-    conservative_inline_namespaces: bool,
-
-    /// Whether to keep documentation comments in the generated output. See the
-    /// documentation for more details. Defaults to true.
-    generate_comments: bool,
-
-    /// Whether to generate inline functions. Defaults to false.
-    generate_inline_functions: bool,
-
-    /// Whether to allowlist types recursively. Defaults to true.
-    allowlist_recursively: bool,
-
-    /// Instead of emitting 'use objc;' to files generated from objective c files,
-    /// generate '#[macro_use] extern crate objc;'
-    objc_extern_crate: bool,
-
-    /// Instead of emitting 'use block;' to files generated from objective c files,
-    /// generate '#[macro_use] extern crate block;'
-    generate_block: bool,
-
-    /// Instead of emitting 'use block;' to files generated from objective c files,
-    /// generate '#[macro_use] extern crate block;'
-    block_extern_crate: bool,
-
-    /// Whether to use the clang-provided name mangling. This is true and
-    /// probably needed for C++ features.
-    ///
-    /// However, some old libclang versions seem to return incorrect results in
-    /// some cases for non-mangled functions, see [1], so we allow disabling it.
-    ///
-    /// [1]: https://github.com/rust-lang/rust-bindgen/issues/528
-    enable_mangling: bool,
-
-    /// Whether to detect include paths using clang_sys.
-    detect_include_paths: bool,
-
-    /// Whether to try to fit macro constants into types smaller than u32/i32
-    fit_macro_constants: bool,
-
-    /// Whether to prepend the enum name to constant or newtype variants.
-    prepend_enum_name: bool,
-
-    /// Version of the Rust compiler to target
-    rust_target: RustTarget,
-
-    /// Features to enable, derived from `rust_target`
-    rust_features: RustFeatures,
-
-    /// Whether we should record which items in the regex sets ever matched.
-    ///
-    /// This may be a bit slower, but will enable reporting of unused allowlist
-    /// items via the `error!` log.
-    record_matches: bool,
-
-    /// Whether `size_t` should be translated to `usize` automatically.
-    size_t_is_usize: bool,
-
-    /// Whether rustfmt should format the generated bindings.
-    rustfmt_bindings: bool,
-
-    /// The absolute path to the rustfmt configuration file, if None, the standard rustfmt
-    /// options are used.
-    rustfmt_configuration_file: Option<PathBuf>,
-
-    /// The set of types that we should not derive `PartialEq` for.
-    no_partialeq_types: RegexSet,
-
-    /// The set of types that we should not derive `Copy` for.
-    no_copy_types: RegexSet,
-
-    /// The set of types that we should not derive `Debug` for.
-    no_debug_types: RegexSet,
-
-    /// The set of types that we should not derive/impl `Default` for.
-    no_default_types: RegexSet,
-
-    /// The set of types that we should not derive `Hash` for.
-    no_hash_types: RegexSet,
-
-    /// The set of types that we should be annotated with `#[must_use]`.
-    must_use_types: RegexSet,
-
-    /// Decide if C arrays should be regular pointers in rust or array pointers
-    array_pointers_in_arguments: bool,
-
-    /// Wasm import module name.
-    wasm_import_module_name: Option<String>,
-
-    /// The name of the dynamic library (if we are generating bindings for a shared library). If
-    /// this is None, no dynamic bindings are created.
-    dynamic_library_name: Option<String>,
-
-    /// Require successful linkage for all routines in a shared library.
-    /// This allows us to optimize function calls by being able to safely assume function pointers
-    /// are valid. No effect if `dynamic_library_name` is None.
-    dynamic_link_require_all: bool,
-
-    /// Only make generated bindings `pub` if the items would be publically accessible
-    /// by C++.
-    respect_cxx_access_specs: bool,
-
-    /// Always translate enum integer types to native Rust integer types.
-    translate_enum_integer_types: bool,
-
-    /// Generate types with C style naming.
-    c_naming: bool,
-
-    /// Always output explicit padding fields
-    force_explicit_padding: bool,
-
-    /// Emit vtable functions.
-    vtable_generation: bool,
-
-    /// Sort the code generation.
-    sort_semantically: bool,
-
-    /// Deduplicate `extern` blocks.
-    merge_extern_blocks: bool,
-}
-
-/// TODO(emilio): This is sort of a lie (see the error message that results from
-/// removing this), but since we don't share references across panic boundaries
-/// it's ok.
-impl ::std::panic::UnwindSafe for BindgenOptions {}
-
-impl BindgenOptions {
-    fn build(&mut self) {
-        let mut regex_sets = [
-            &mut self.allowlisted_vars,
-            &mut self.allowlisted_types,
-            &mut self.allowlisted_functions,
-            &mut self.allowlisted_files,
-            &mut self.blocklisted_types,
-            &mut self.blocklisted_functions,
-            &mut self.blocklisted_items,
-            &mut self.blocklisted_files,
-            &mut self.opaque_types,
-            &mut self.bitfield_enums,
-            &mut self.constified_enums,
-            &mut self.constified_enum_modules,
-            &mut self.newtype_enums,
-            &mut self.newtype_global_enums,
-            &mut self.rustified_enums,
-            &mut self.rustified_non_exhaustive_enums,
-            &mut self.type_alias,
-            &mut self.new_type_alias,
-            &mut self.new_type_alias_deref,
-            &mut self.bindgen_wrapper_union,
-            &mut self.manually_drop_union,
-            &mut self.no_partialeq_types,
-            &mut self.no_copy_types,
-            &mut self.no_debug_types,
-            &mut self.no_default_types,
-            &mut self.no_hash_types,
-            &mut self.must_use_types,
-        ];
-        let record_matches = self.record_matches;
-        for regex_set in &mut regex_sets {
-            regex_set.build(record_matches);
-        }
-    }
-
-    /// Update rust target version
-    pub fn set_rust_target(&mut self, rust_target: RustTarget) {
-        self.rust_target = rust_target;
-
-        // Keep rust_features synced with rust_target
-        self.rust_features = rust_target.into();
-    }
-
-    /// Get features supported by target Rust version
-    pub fn rust_features(&self) -> RustFeatures {
-        self.rust_features
-    }
-}
-
-impl Default for BindgenOptions {
-    fn default() -> BindgenOptions {
-        let rust_target = RustTarget::default();
-
-        BindgenOptions {
-            rust_target,
-            rust_features: rust_target.into(),
-            blocklisted_types: Default::default(),
-            blocklisted_functions: Default::default(),
-            blocklisted_items: Default::default(),
-            blocklisted_files: Default::default(),
-            opaque_types: Default::default(),
-            rustfmt_path: Default::default(),
-            depfile: Default::default(),
-            allowlisted_types: Default::default(),
-            allowlisted_functions: Default::default(),
-            allowlisted_vars: Default::default(),
-            allowlisted_files: Default::default(),
-            default_enum_style: Default::default(),
-            bitfield_enums: Default::default(),
-            newtype_enums: Default::default(),
-            newtype_global_enums: Default::default(),
-            rustified_enums: Default::default(),
-            rustified_non_exhaustive_enums: Default::default(),
-            constified_enums: Default::default(),
-            constified_enum_modules: Default::default(),
-            default_macro_constant_type: Default::default(),
-            default_alias_style: Default::default(),
-            type_alias: Default::default(),
-            new_type_alias: Default::default(),
-            new_type_alias_deref: Default::default(),
-            default_non_copy_union_style: Default::default(),
-            bindgen_wrapper_union: Default::default(),
-            manually_drop_union: Default::default(),
-            builtins: false,
-            emit_ast: false,
-            emit_ir: false,
-            emit_ir_graphviz: None,
-            layout_tests: true,
-            impl_debug: false,
-            impl_partialeq: false,
-            derive_copy: true,
-            derive_debug: true,
-            derive_default: false,
-            derive_hash: false,
-            derive_partialord: false,
-            derive_ord: false,
-            derive_partialeq: false,
-            derive_eq: false,
-            enable_cxx_namespaces: false,
-            enable_function_attribute_detection: false,
-            disable_name_namespacing: false,
-            disable_nested_struct_naming: false,
-            disable_header_comment: false,
-            use_core: false,
-            ctypes_prefix: None,
-            anon_fields_prefix: DEFAULT_ANON_FIELDS_PREFIX.into(),
-            convert_floats: true,
-            raw_lines: vec![],
-            module_lines: HashMap::default(),
-            clang_args: vec![],
-            input_header: None,
-            extra_input_headers: vec![],
-            parse_callbacks: None,
-            codegen_config: CodegenConfig::all(),
-            conservative_inline_namespaces: false,
-            generate_comments: true,
-            generate_inline_functions: false,
-            allowlist_recursively: true,
-            generate_block: false,
-            objc_extern_crate: false,
-            block_extern_crate: false,
-            enable_mangling: true,
-            detect_include_paths: true,
-            fit_macro_constants: false,
-            prepend_enum_name: true,
-            time_phases: false,
-            record_matches: true,
-            rustfmt_bindings: true,
-            size_t_is_usize: true,
-            rustfmt_configuration_file: None,
-            no_partialeq_types: Default::default(),
-            no_copy_types: Default::default(),
-            no_debug_types: Default::default(),
-            no_default_types: Default::default(),
-            no_hash_types: Default::default(),
-            must_use_types: Default::default(),
-            array_pointers_in_arguments: false,
-            wasm_import_module_name: None,
-            dynamic_library_name: None,
-            dynamic_link_require_all: false,
-            respect_cxx_access_specs: false,
-            translate_enum_integer_types: false,
-            c_naming: false,
-            force_explicit_padding: false,
-            vtable_generation: false,
-            sort_semantically: false,
-            merge_extern_blocks: false,
-        }
-    }
-}
-
-#[cfg(feature = "runtime")]
-fn ensure_libclang_is_loaded() {
-    if clang_sys::is_loaded() {
-        return;
-    }
-
-    // XXX (issue #350): Ensure that our dynamically loaded `libclang`
-    // doesn't get dropped prematurely, nor is loaded multiple times
-    // across different threads.
-
-    lazy_static! {
-        static ref LIBCLANG: std::sync::Arc<clang_sys::SharedLibrary> = {
-            clang_sys::load().expect("Unable to find libclang");
-            clang_sys::get_library().expect(
-                "We just loaded libclang and it had better still be \
-                 here!",
-            )
-        };
-    }
-
-    clang_sys::set_library(Some(LIBCLANG.clone()));
-}
-
-#[cfg(not(feature = "runtime"))]
-fn ensure_libclang_is_loaded() {}
-
-/// Error type for rust-bindgen.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[non_exhaustive]
-pub enum BindgenError {
-    /// The header was a folder.
-    FolderAsHeader(PathBuf),
-    /// Permissions to read the header is insufficient.
-    InsufficientPermissions(PathBuf),
-    /// The header does not exist.
-    NotExist(PathBuf),
-    /// Clang diagnosed an error.
-    ClangDiagnostic(String),
-}
-
-impl std::fmt::Display for BindgenError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BindgenError::FolderAsHeader(h) => {
-                write!(f, "'{}' is a folder", h.display())
-            }
-            BindgenError::InsufficientPermissions(h) => {
-                write!(f, "insufficient permissions to read '{}'", h.display())
-            }
-            BindgenError::NotExist(h) => {
-                write!(f, "header '{}' does not exist.", h.display())
-            }
-            BindgenError::ClangDiagnostic(message) => {
-                write!(f, "clang diagnosed error: {}", message)
-            }
-        }
-    }
-}
-
-impl std::error::Error for BindgenError {}
-
-/// Generated Rust bindings.
-#[derive(Debug)]
-pub struct Bindings {
-    options: BindgenOptions,
-    warnings: Vec<String>,
-    module: proc_macro2::TokenStream,
-}
-
-pub(crate) const HOST_TARGET: &str =
-    include_str!(concat!(env!("OUT_DIR"), "/host-target.txt"));
-
-// Some architecture triplets are different between rust and libclang, see #1211
-// and duplicates.
-fn rust_to_clang_target(rust_target: &str) -> String {
-    if rust_target.starts_with("aarch64-apple-") {
-        let mut clang_target = "arm64-apple-".to_owned();
-        clang_target
-            .push_str(rust_target.strip_prefix("aarch64-apple-").unwrap());
-        return clang_target;
-    } else if rust_target.starts_with("riscv64gc-") {
-        let mut clang_target = "riscv64-".to_owned();
-        clang_target.push_str(rust_target.strip_prefix("riscv64gc-").unwrap());
-        return clang_target;
-    }
-    rust_target.to_owned()
-}
-
-/// Returns the effective target, and whether it was explicitly specified on the
-/// clang flags.
-fn find_effective_target(clang_args: &[String]) -> (String, bool) {
-    let mut args = clang_args.iter();
-    while let Some(opt) = args.next() {
-        if opt.starts_with("--target=") {
-            let mut split = opt.split('=');
-            split.next();
-            return (split.next().unwrap().to_owned(), true);
-        }
-
-        if opt == "-target" {
-            if let Some(target) = args.next() {
-                return (target.clone(), true);
-            }
-        }
-    }
-
-    // If we're running from a build script, try to find the cargo target.
-    if let Ok(t) = env::var("TARGET") {
-        return (rust_to_clang_target(&t), false);
-    }
-
-    (rust_to_clang_target(HOST_TARGET), false)
-}
-
-impl Bindings {
-    /// Generate bindings for the given options.
-    pub(crate) fn generate(
-        mut options: BindgenOptions,
-        input_unsaved_files: Vec<clang::UnsavedFile>,
-    ) -> Result<Bindings, BindgenError> {
-        ensure_libclang_is_loaded();
-
-        #[cfg(feature = "runtime")]
-        debug!(
-            "Generating bindings, libclang at {}",
-            clang_sys::get_library().unwrap().path().display()
-        );
-        #[cfg(not(feature = "runtime"))]
-        debug!("Generating bindings, libclang linked");
-
-        options.build();
-
-        let (effective_target, explicit_target) =
-            find_effective_target(&options.clang_args);
-
-        let is_host_build =
-            rust_to_clang_target(HOST_TARGET) == effective_target;
-
-        // NOTE: The is_host_build check wouldn't be sound normally in some
-        // cases if we were to call a binary (if you have a 32-bit clang and are
-        // building on a 64-bit system for example).  But since we rely on
-        // opening libclang.so, it has to be the same architecture and thus the
-        // check is fine.
-        if !explicit_target && !is_host_build {
-            options
-                .clang_args
-                .insert(0, format!("--target={}", effective_target));
-        };
-
-        fn detect_include_paths(options: &mut BindgenOptions) {
-            if !options.detect_include_paths {
-                return;
-            }
-
-            // Filter out include paths and similar stuff, so we don't incorrectly
-            // promote them to `-isystem`.
-            let clang_args_for_clang_sys = {
-                let mut last_was_include_prefix = false;
-                options
-                    .clang_args
-                    .iter()
-                    .filter(|arg| {
-                        if last_was_include_prefix {
-                            last_was_include_prefix = false;
-                            return false;
-                        }
-
-                        let arg = &**arg;
-
-                        // https://clang.llvm.org/docs/ClangCommandLineReference.html
-                        // -isystem and -isystem-after are harmless.
-                        if arg == "-I" || arg == "--include-directory" {
-                            last_was_include_prefix = true;
-                            return false;
-                        }
-
-                        if arg.starts_with("-I") ||
-                            arg.starts_with("--include-directory=")
-                        {
-                            return false;
-                        }
-
-                        true
-                    })
-                    .cloned()
-                    .collect::<Vec<_>>()
-            };
-
-            debug!(
-                "Trying to find clang with flags: {:?}",
-                clang_args_for_clang_sys
-            );
-
-            let clang = match clang_sys::support::Clang::find(
-                None,
-                &clang_args_for_clang_sys,
-            ) {
-                None => return,
-                Some(clang) => clang,
-            };
-
-            debug!("Found clang: {:?}", clang);
-
-            // Whether we are working with C or C++ inputs.
-            let is_cpp = args_are_cpp(&options.clang_args) ||
-                options.input_header.as_deref().map_or(false, file_is_cpp);
-
-            let search_paths = if is_cpp {
-                clang.cpp_search_paths
-            } else {
-                clang.c_search_paths
-            };
-
-            if let Some(search_paths) = search_paths {
-                for path in search_paths.into_iter() {
-                    if let Ok(path) = path.into_os_string().into_string() {
-                        options.clang_args.push("-isystem".to_owned());
-                        options.clang_args.push(path);
-                    }
-                }
-            }
-        }
-
-        detect_include_paths(&mut options);
-
-        #[cfg(unix)]
-        fn can_read(perms: &std::fs::Permissions) -> bool {
-            use std::os::unix::fs::PermissionsExt;
-            perms.mode() & 0o444 > 0
-        }
-
-        #[cfg(not(unix))]
-        fn can_read(_: &std::fs::Permissions) -> bool {
-            true
-        }
-
-        if let Some(h) = options.input_header.as_ref() {
-            let path = Path::new(h);
-            if let Ok(md) = std::fs::metadata(path) {
-                if md.is_dir() {
-                    return Err(BindgenError::FolderAsHeader(path.into()));
-                }
-                if !can_read(&md.permissions()) {
-                    return Err(BindgenError::InsufficientPermissions(
-                        path.into(),
-                    ));
-                }
-                options.clang_args.push(h.clone())
-            } else {
-                return Err(BindgenError::NotExist(path.into()));
-            }
-        }
-
-        for (idx, f) in input_unsaved_files.iter().enumerate() {
-            if idx != 0 || options.input_header.is_some() {
-                options.clang_args.push("-include".to_owned());
-            }
-            options.clang_args.push(f.name.to_str().unwrap().to_owned())
-        }
-
-        debug!("Fixed-up options: {:?}", options);
-
-        let time_phases = options.time_phases;
-        let mut context = BindgenContext::new(options, &input_unsaved_files);
-
-        if is_host_build {
-            debug_assert_eq!(
-                context.target_pointer_size(),
-                std::mem::size_of::<*mut ()>(),
-                "{:?} {:?}",
-                effective_target,
-                HOST_TARGET
-            );
-        }
-
-        {
-            let _t = time::Timer::new("parse").with_output(time_phases);
-            parse(&mut context)?;
-        }
-
-        let (module, options, warnings) = codegen::codegen(context);
-
-        Ok(Bindings {
-            options,
-            warnings,
-            module,
-        })
-    }
-
-    /// Write these bindings as source text to a file.
-    pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
-        let file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .create(true)
-            .open(path.as_ref())?;
-        self.write(Box::new(file))?;
-        Ok(())
-    }
-
-    /// Write these bindings as source text to the given `Write`able.
-    pub fn write<'a>(&self, mut writer: Box<dyn Write + 'a>) -> io::Result<()> {
-        if !self.options.disable_header_comment {
-            let version = option_env!("CARGO_PKG_VERSION");
-            let header = format!(
-                "/* automatically generated by rust-bindgen {} */\n\n",
-                version.unwrap_or("(unknown version)")
-            );
-            writer.write_all(header.as_bytes())?;
-        }
-
-        for line in self.options.raw_lines.iter() {
-            writer.write_all(line.as_bytes())?;
-            writer.write_all("\n".as_bytes())?;
-        }
-
-        if !self.options.raw_lines.is_empty() {
-            writer.write_all("\n".as_bytes())?;
-        }
-
-        let bindings = self.module.to_string();
-
-        match self.rustfmt_generated_string(&bindings) {
-            Ok(rustfmt_bindings) => {
-                writer.write_all(rustfmt_bindings.as_bytes())?;
-            }
-            Err(err) => {
-                eprintln!(
-                    "Failed to run rustfmt: {} (non-fatal, continuing)",
-                    err
-                );
-                writer.write_all(bindings.as_bytes())?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Gets the rustfmt path to rustfmt the generated bindings.
-    fn rustfmt_path(&self) -> io::Result<Cow<PathBuf>> {
-        debug_assert!(self.options.rustfmt_bindings);
-        if let Some(ref p) = self.options.rustfmt_path {
-            return Ok(Cow::Borrowed(p));
-        }
-        if let Ok(rustfmt) = env::var("RUSTFMT") {
-            return Ok(Cow::Owned(rustfmt.into()));
-        }
-        #[cfg(feature = "which-rustfmt")]
-        match which::which("rustfmt") {
-            Ok(p) => Ok(Cow::Owned(p)),
-            Err(e) => {
-                Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)))
-            }
-        }
-        #[cfg(not(feature = "which-rustfmt"))]
-        // No rustfmt binary was specified, so assume that the binary is called
-        // "rustfmt" and that it is in the user's PATH.
-        Ok(Cow::Owned("rustfmt".into()))
-    }
-
-    /// Checks if rustfmt_bindings is set and runs rustfmt on the string
-    fn rustfmt_generated_string<'a>(
-        &self,
-        source: &'a str,
-    ) -> io::Result<Cow<'a, str>> {
-        let _t = time::Timer::new("rustfmt_generated_string")
-            .with_output(self.options.time_phases);
-
-        if !self.options.rustfmt_bindings {
-            return Ok(Cow::Borrowed(source));
-        }
-
-        let rustfmt = self.rustfmt_path()?;
-        let mut cmd = Command::new(&*rustfmt);
-
-        cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
-
-        if let Some(path) = self
-            .options
-            .rustfmt_configuration_file
-            .as_ref()
-            .and_then(|f| f.to_str())
-        {
-            cmd.args(["--config-path", path]);
-        }
-
-        let mut child = cmd.spawn()?;
-        let mut child_stdin = child.stdin.take().unwrap();
-        let mut child_stdout = child.stdout.take().unwrap();
-
-        let source = source.to_owned();
-
-        // Write to stdin in a new thread, so that we can read from stdout on this
-        // thread. This keeps the child from blocking on writing to its stdout which
-        // might block us from writing to its stdin.
-        let stdin_handle = ::std::thread::spawn(move || {
-            let _ = child_stdin.write_all(source.as_bytes());
-            source
-        });
-
-        let mut output = vec![];
-        io::copy(&mut child_stdout, &mut output)?;
-
-        let status = child.wait()?;
-        let source = stdin_handle.join().expect(
-            "The thread writing to rustfmt's stdin doesn't do \
-             anything that could panic",
-        );
-
-        match String::from_utf8(output) {
-            Ok(bindings) => match status.code() {
-                Some(0) => Ok(Cow::Owned(bindings)),
-                Some(2) => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Rustfmt parsing errors.".to_string(),
-                )),
-                Some(3) => {
-                    warn!("Rustfmt could not format some lines.");
-                    Ok(Cow::Owned(bindings))
-                }
-                _ => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Internal rustfmt error".to_string(),
-                )),
-            },
-            _ => Ok(Cow::Owned(source)),
-        }
-    }
-
-    /// Emit all the warning messages raised while generating the bindings in a build script.
-    ///
-    /// If you are using `bindgen` outside of a build script you should use [`Bindings::warnings`]
-    /// and handle the messages accordingly instead.
-    #[inline]
-    pub fn emit_warnings(&self) {
-        for message in &self.warnings {
-            println!("cargo:warning={}", message);
-        }
-    }
-
-    /// Return all the warning messages raised while generating the bindings.
-    #[inline]
-    pub fn warnings(&self) -> &[String] {
-        &self.warnings
-    }
-}
-
-impl std::fmt::Display for Bindings {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut bytes = vec![];
-        self.write(Box::new(&mut bytes) as Box<dyn Write>)
-            .expect("writing to a vec cannot fail");
-        f.write_str(
-            std::str::from_utf8(&bytes)
-                .expect("we should only write bindings that are valid utf-8"),
-        )
-    }
-}
-
-/// Determines whether the given cursor is in any of the files matched by the
-/// options.
-fn filter_builtins(ctx: &BindgenContext, cursor: &clang::Cursor) -> bool {
-    ctx.options().builtins || !cursor.is_builtin()
-}
-
-/// Parse one `Item` from the Clang cursor.
-fn parse_one(
-    ctx: &mut BindgenContext,
-    cursor: clang::Cursor,
-    parent: Option<ItemId>,
-) -> clang_sys::CXChildVisitResult {
-    if !filter_builtins(ctx, &cursor) {
-        return CXChildVisit_Continue;
-    }
-
-    use clang_sys::CXChildVisit_Continue;
-    match Item::parse(cursor, parent, ctx) {
-        Ok(..) => {}
-        Err(ParseError::Continue) => {}
-        Err(ParseError::Recurse) => {
-            cursor.visit(|child| parse_one(ctx, child, parent));
-        }
-    }
-    CXChildVisit_Continue
-}
-
-/// Parse the Clang AST into our `Item` internal representation.
-fn parse(context: &mut BindgenContext) -> Result<(), BindgenError> {
-    use clang_sys::*;
-
-    let mut error = None;
-    for d in context.translation_unit().diags().iter() {
-        let msg = d.format();
-        let is_err = d.severity() >= CXDiagnostic_Error;
-        if is_err {
-            let error = error.get_or_insert_with(String::new);
-            error.push_str(&msg);
-            error.push('\n');
-        } else {
-            eprintln!("clang diag: {}", msg);
-        }
-    }
-
-    if let Some(message) = error {
-        return Err(BindgenError::ClangDiagnostic(message));
-    }
-
-    let cursor = context.translation_unit().cursor();
-
-    if context.options().emit_ast {
-        fn dump_if_not_builtin(cur: &clang::Cursor) -> CXChildVisitResult {
-            if !cur.is_builtin() {
-                clang::ast_dump(cur, 0)
-            } else {
-                CXChildVisit_Continue
-            }
-        }
-        cursor.visit(|cur| dump_if_not_builtin(&cur));
-    }
-
-    let root = context.root_module();
-    context.with_module(root, |context| {
-        cursor.visit(|cursor| parse_one(context, cursor, None))
-    });
-
-    assert!(
-        context.current_module() == context.root_module(),
-        "How did this happen?"
-    );
-    Ok(())
-}
-
-/// Extracted Clang version data
-#[derive(Debug)]
-pub struct ClangVersion {
-    /// Major and minor semver, if parsing was successful
-    pub parsed: Option<(u32, u32)>,
-    /// full version string
-    pub full: String,
-}
-
-/// Get the major and the minor semver numbers of Clang's version
-pub fn clang_version() -> ClangVersion {
-    ensure_libclang_is_loaded();
-
-    //Debian clang version 11.0.1-2
-    let raw_v: String = clang::extract_clang_version();
-    let split_v: Option<Vec<&str>> = raw_v
-        .split_whitespace()
-        .find(|t| t.chars().next().map_or(false, |v| v.is_ascii_digit()))
-        .map(|v| v.split('.').collect());
-    if let Some(v) = split_v {
-        if v.len() >= 2 {
-            let maybe_major = v[0].parse::<u32>();
-            let maybe_minor = v[1].parse::<u32>();
-            if let (Ok(major), Ok(minor)) = (maybe_major, maybe_minor) {
-                return ClangVersion {
-                    parsed: Some((major, minor)),
-                    full: raw_v.clone(),
-                };
-            }
-        }
-    };
-    ClangVersion {
-        parsed: None,
-        full: raw_v.clone(),
-    }
-}
-
-/// Looks for the env var `var_${TARGET}`, and falls back to just `var` when it is not found.
-fn get_target_dependent_env_var(var: &str) -> Option<String> {
-    if let Ok(target) = env::var("TARGET") {
-        if let Ok(v) = env::var(&format!("{}_{}", var, target)) {
-            return Some(v);
-        }
-        if let Ok(v) =
-            env::var(&format!("{}_{}", var, target.replace('-', "_")))
-        {
-            return Some(v);
-        }
-    }
-    env::var(var).ok()
-}
-
-/// A ParseCallbacks implementation that will act on file includes by echoing a rerun-if-changed
-/// line
-///
-/// When running inside a `build.rs` script, this can be used to make cargo invalidate the
-/// generated bindings whenever any of the files included from the header change:
-/// ```
-/// use bindgen::builder;
-/// let bindings = builder()
-///     .header("path/to/input/header")
-///     .parse_callbacks(Box::new(bindgen::CargoCallbacks))
-///     .generate();
-/// ```
-#[derive(Debug)]
-pub struct CargoCallbacks;
-
-impl callbacks::ParseCallbacks for CargoCallbacks {
-    fn include_file(&self, filename: &str) {
-        println!("cargo:rerun-if-changed={}", filename);
-    }
-}
-
-/// Test command_line_flag function.
-#[test]
-fn commandline_flag_unit_test_function() {
-    //Test 1
-    let bindings = crate::builder();
-    let command_line_flags = bindings.command_line_flags();
-
-    let test_cases = vec![
-        "--rust-target",
-        "--no-derive-default",
-        "--generate",
-        "functions,types,vars,methods,constructors,destructors",
-    ]
-    .iter()
-    .map(|&x| x.into())
-    .collect::<Vec<String>>();
-
-    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
-
-    //Test 2
-    let bindings = crate::builder()
-        .header("input_header")
-        .allowlist_type("Distinct_Type")
-        .allowlist_function("safe_function");
-
-    let command_line_flags = bindings.command_line_flags();
-    let test_cases = vec![
-        "--rust-target",
-        "input_header",
-        "--no-derive-default",
-        "--generate",
-        "functions,types,vars,methods,constructors,destructors",
-        "--allowlist-type",
-        "Distinct_Type",
-        "--allowlist-function",
-        "safe_function",
-    ]
-    .iter()
-    .map(|&x| x.into())
-    .collect::<Vec<String>>();
-    println!("{:?}", command_line_flags);
-
-    assert!(test_cases.iter().all(|x| command_line_flags.contains(x)));
-}
-
-#[test]
-fn test_rust_to_clang_target() {
-    assert_eq!(rust_to_clang_target("aarch64-apple-ios"), "arm64-apple-ios");
-}
-
-#[test]
-fn test_rust_to_clang_target_riscv() {
-    assert_eq!(
-        rust_to_clang_target("riscv64gc-unknown-linux-gnu"),
-        "riscv64-unknown-linux-gnu"
-    )
-}
diff --git a/src/log_stubs.rs b/src/log_stubs.rs
deleted file mode 100644
index 83159831..00000000
--- a/src/log_stubs.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(unused)]
-
-macro_rules! log {
-    (target: $target:expr, $lvl:expr, $($arg:tt)+) => {{
-        let _ = $target;
-        let _ = log!($lvl, $($arg)+);
-    }};
-    ($lvl:expr, $($arg:tt)+) => {{
-        let _ = $lvl;
-        let _ = format_args!($($arg)+);
-    }};
-}
-macro_rules! error {
-    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
-    ($($arg:tt)+) => { log!("", $($arg)+) };
-}
-macro_rules! warn {
-    (target: $target:expr, $($arg:tt)*) => { log!(target: $target, "", $($arg)*) };
-    ($($arg:tt)*) => { log!("", $($arg)*) };
-}
-macro_rules! info {
-    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
-    ($($arg:tt)+) => { log!("", $($arg)+) };
-}
-macro_rules! debug {
-    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
-    ($($arg:tt)+) => { log!("", $($arg)+) };
-}
-macro_rules! trace {
-    (target: $target:expr, $($arg:tt)+) => { log!(target: $target, "", $($arg)+) };
-    ($($arg:tt)+) => { log!("", $($arg)+) };
-}
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 50f3e714..00000000
--- a/src/main.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-extern crate bindgen;
-#[cfg(feature = "logging")]
-extern crate env_logger;
-#[macro_use]
-#[cfg(feature = "logging")]
-extern crate log;
-extern crate clap;
-
-use bindgen::clang_version;
-use std::env;
-use std::panic;
-
-#[macro_use]
-#[cfg(not(feature = "logging"))]
-mod log_stubs;
-
-mod options;
-use crate::options::builder_from_flags;
-
-fn clang_version_check() {
-    let version = clang_version();
-    let expected_version = if cfg!(feature = "testing_only_libclang_9") {
-        Some((9, 0))
-    } else if cfg!(feature = "testing_only_libclang_5") {
-        Some((5, 0))
-    } else {
-        None
-    };
-
-    info!(
-        "Clang Version: {}, parsed: {:?}",
-        version.full, version.parsed
-    );
-
-    if expected_version.is_some() {
-        // assert_eq!(version.parsed, version.parsed);
-    }
-}
-
-pub fn main() {
-    #[cfg(feature = "logging")]
-    env_logger::init();
-
-    match builder_from_flags(env::args()) {
-        Ok((builder, output, verbose)) => {
-            clang_version_check();
-            let builder_result = panic::catch_unwind(|| {
-                builder.generate().expect("Unable to generate bindings")
-            });
-
-            if builder_result.is_err() {
-                if verbose {
-                    print_verbose_err();
-                }
-                std::process::exit(1);
-            }
-
-            let bindings = builder_result.unwrap();
-            bindings.write(output).expect("Unable to write output");
-        }
-        Err(error) => {
-            println!("{}", error);
-            std::process::exit(1);
-        }
-    };
-}
-
-fn print_verbose_err() {
-    println!("Bindgen unexpectedly panicked");
-    println!(
-        "This may be caused by one of the known-unsupported \
-         things (https://rust-lang.github.io/rust-bindgen/cpp.html), \
-         please modify the bindgen flags to work around it as \
-         described in https://rust-lang.github.io/rust-bindgen/cpp.html"
-    );
-    println!(
-        "Otherwise, please file an issue at \
-         https://github.com/rust-lang/rust-bindgen/issues/new"
-    );
-}
-
-#[cfg(test)]
-mod test {
-    fn build_flags_output_helper(builder: &bindgen::Builder) {
-        let mut command_line_flags = builder.command_line_flags();
-        command_line_flags.insert(0, "bindgen".to_string());
-
-        let flags_quoted: Vec<String> = command_line_flags
-            .iter()
-            .map(|x| format!("{}", shlex::quote(x)))
-            .collect();
-        let flags_str = flags_quoted.join(" ");
-        println!("{}", flags_str);
-
-        let (builder, _output, _verbose) =
-            crate::options::builder_from_flags(command_line_flags.into_iter())
-                .unwrap();
-        builder.generate().expect("failed to generate bindings");
-    }
-
-    #[test]
-    fn commandline_multiple_headers() {
-        let bindings = bindgen::Builder::default()
-            .header("tests/headers/char.h")
-            .header("tests/headers/func_ptr.h")
-            .header("tests/headers/16-byte-alignment.h");
-        build_flags_output_helper(&bindings);
-    }
-}
diff --git a/src/options.rs b/src/options.rs
deleted file mode 100644
index 1025a36d..00000000
--- a/src/options.rs
+++ /dev/null
@@ -1,1092 +0,0 @@
-use bindgen::{
-    builder, AliasVariation, Builder, CodegenConfig, EnumVariation,
-    MacroTypeVariation, NonCopyUnionStyle, RustTarget,
-    DEFAULT_ANON_FIELDS_PREFIX, RUST_TARGET_STRINGS,
-};
-use clap::{App, Arg};
-use std::fs::File;
-use std::io::{self, stderr, Error, ErrorKind, Write};
-use std::path::PathBuf;
-use std::str::FromStr;
-
-/// Construct a new [`Builder`](./struct.Builder.html) from command line flags.
-pub fn builder_from_flags<I>(
-    args: I,
-) -> Result<(Builder, Box<dyn io::Write>, bool), io::Error>
-where
-    I: Iterator<Item = String>,
-{
-    let rust_target_help = format!(
-        "Version of the Rust compiler to target. Valid options are: {:?}. Defaults to {:?}.",
-        RUST_TARGET_STRINGS,
-        String::from(RustTarget::default())
-    );
-
-    let matches = App::new("bindgen")
-        .about("Generates Rust bindings from C/C++ headers.")
-        .setting(clap::AppSettings::NoAutoVersion)
-        .override_usage("bindgen [FLAGS] [OPTIONS] <header> -- <clang-args>...")
-        .args(&[
-            Arg::new("header")
-                .help("C or C++ header file")
-                .required_unless_present("V"),
-            Arg::new("depfile")
-                .long("depfile")
-                .takes_value(true)
-                .help("Path to write depfile to"),
-            Arg::new("default-enum-style")
-                .long("default-enum-style")
-                .help("The default style of code used to generate enums.")
-                .value_name("variant")
-                .default_value("consts")
-                .possible_values([
-                    "consts",
-                    "moduleconsts",
-                    "bitfield",
-                    "newtype",
-                    "rust",
-                    "rust_non_exhaustive",
-                ])
-                .multiple_occurrences(false),
-            Arg::new("bitfield-enum")
-                .long("bitfield-enum")
-                .help(
-                    "Mark any enum whose name matches <regex> as a set of \
-                     bitfield flags.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("newtype-enum")
-                .long("newtype-enum")
-                .help("Mark any enum whose name matches <regex> as a newtype.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("newtype-global-enum")
-                .long("newtype-global-enum")
-                .help("Mark any enum whose name matches <regex> as a global newtype.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("rustified-enum")
-                .long("rustified-enum")
-                .help("Mark any enum whose name matches <regex> as a Rust enum.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("constified-enum")
-                .long("constified-enum")
-                .help(
-                    "Mark any enum whose name matches <regex> as a series of \
-                     constants.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("constified-enum-module")
-                .long("constified-enum-module")
-                .help(
-                    "Mark any enum whose name matches <regex> as a module of \
-                     constants.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("default-macro-constant-type")
-                .long("default-macro-constant-type")
-                .help("The default signed/unsigned type for C macro constants.")
-                .value_name("variant")
-                .default_value("unsigned")
-                .possible_values(["signed", "unsigned"])
-                .multiple_occurrences(false),
-            Arg::new("default-alias-style")
-                .long("default-alias-style")
-                .help("The default style of code used to generate typedefs.")
-                .value_name("variant")
-                .default_value("type_alias")
-                .possible_values([
-                    "type_alias",
-                    "new_type",
-                    "new_type_deref",
-                ])
-                .multiple_occurrences(false),
-            Arg::new("normal-alias")
-                .long("normal-alias")
-                .help(
-                    "Mark any typedef alias whose name matches <regex> to use \
-                     normal type aliasing.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-             Arg::new("new-type-alias")
-                .long("new-type-alias")
-                .help(
-                    "Mark any typedef alias whose name matches <regex> to have \
-                     a new type generated for it.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-             Arg::new("new-type-alias-deref")
-                .long("new-type-alias-deref")
-                .help(
-                    "Mark any typedef alias whose name matches <regex> to have \
-                     a new type with Deref and DerefMut to the inner type.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("default-non-copy-union-style")
-                .long("default-non-copy-union-style")
-                .help(
-                    "The default style of code used to generate unions with \
-                     non-Copy members. Note that ManuallyDrop was first \
-                     stabilized in Rust 1.20.0.",
-                )
-                .value_name("style")
-                .default_value("bindgen_wrapper")
-                .possible_values([
-                    "bindgen_wrapper",
-                    "manually_drop",
-                ])
-                .multiple_occurrences(false),
-            Arg::new("bindgen-wrapper-union")
-                .long("bindgen-wrapper-union")
-                .help(
-                    "Mark any union whose name matches <regex> and who has a \
-                     non-Copy member to use a bindgen-generated wrapper for \
-                     fields.",
-                )
-                .value_name("regex")
-                .takes_value(true)
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("manually-drop-union")
-                .long("manually-drop-union")
-                .help(
-                    "Mark any union whose name matches <regex> and who has a \
-                     non-Copy member to use ManuallyDrop (stabilized in Rust \
-                     1.20.0) for fields.",
-                )
-                .value_name("regex")
-                .takes_value(true)
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("blocklist-type")
-                .alias("blacklist-type")
-                .long("blocklist-type")
-                .help("Mark <type> as hidden.")
-                .value_name("type")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("blocklist-function")
-                .alias("blacklist-function")
-                .long("blocklist-function")
-                .help("Mark <function> as hidden.")
-                .value_name("function")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("blocklist-item")
-                .alias("blacklist-item")
-                .long("blocklist-item")
-                .help("Mark <item> as hidden.")
-                .value_name("item")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("blocklist-file")
-                .alias("blacklist-file")
-                .long("blocklist-file")
-                .help("Mark all contents of <path> as hidden.")
-                .value_name("path")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("no-layout-tests")
-                .long("no-layout-tests")
-                .help("Avoid generating layout tests for any type."),
-            Arg::new("no-derive-copy")
-                .long("no-derive-copy")
-                .help("Avoid deriving Copy on any type."),
-            Arg::new("no-derive-debug")
-                .long("no-derive-debug")
-                .help("Avoid deriving Debug on any type."),
-            Arg::new("no-derive-default")
-                .long("no-derive-default")
-                .hide(true)
-                .help("Avoid deriving Default on any type."),
-            Arg::new("impl-debug").long("impl-debug").help(
-                "Create Debug implementation, if it can not be derived \
-                 automatically.",
-            ),
-            Arg::new("impl-partialeq")
-                .long("impl-partialeq")
-                .help(
-                    "Create PartialEq implementation, if it can not be derived \
-                     automatically.",
-                ),
-            Arg::new("with-derive-default")
-                .long("with-derive-default")
-                .help("Derive Default on any type."),
-            Arg::new("with-derive-hash")
-                .long("with-derive-hash")
-                .help("Derive hash on any type."),
-            Arg::new("with-derive-partialeq")
-                .long("with-derive-partialeq")
-                .help("Derive partialeq on any type."),
-            Arg::new("with-derive-partialord")
-                .long("with-derive-partialord")
-                .help("Derive partialord on any type."),
-            Arg::new("with-derive-eq")
-                .long("with-derive-eq")
-                .help(
-                    "Derive eq on any type. Enable this option also \
-                     enables --with-derive-partialeq",
-                ),
-            Arg::new("with-derive-ord")
-                .long("with-derive-ord")
-                .help(
-                    "Derive ord on any type. Enable this option also \
-                     enables --with-derive-partialord",
-                ),
-            Arg::new("no-doc-comments")
-                .long("no-doc-comments")
-                .help(
-                    "Avoid including doc comments in the output, see: \
-                     https://github.com/rust-lang/rust-bindgen/issues/426",
-                ),
-            Arg::new("no-recursive-allowlist")
-                .long("no-recursive-allowlist")
-                .alias("no-recursive-whitelist")
-                .help(
-                    "Disable allowlisting types recursively. This will cause \
-                     bindgen to emit Rust code that won't compile! See the \
-                     `bindgen::Builder::allowlist_recursively` method's \
-                     documentation for details.",
-                ),
-            Arg::new("objc-extern-crate")
-                .long("objc-extern-crate")
-                .help("Use extern crate instead of use for objc."),
-            Arg::new("generate-block")
-                .long("generate-block")
-                .help("Generate block signatures instead of void pointers."),
-            Arg::new("block-extern-crate")
-                .long("block-extern-crate")
-                .help("Use extern crate instead of use for block."),
-            Arg::new("distrust-clang-mangling")
-                .long("distrust-clang-mangling")
-                .help("Do not trust the libclang-provided mangling"),
-            Arg::new("builtins").long("builtins").help(
-                "Output bindings for builtin definitions, e.g. \
-                 __builtin_va_list.",
-            ),
-            Arg::new("ctypes-prefix")
-                .long("ctypes-prefix")
-                .help(
-                    "Use the given prefix before raw types instead of \
-                     ::std::os::raw.",
-                )
-                .value_name("prefix"),
-            Arg::new("anon-fields-prefix")
-                .long("anon-fields-prefix")
-                .help("Use the given prefix for the anon fields.")
-                .value_name("prefix")
-                .default_value(DEFAULT_ANON_FIELDS_PREFIX),
-            Arg::new("time-phases")
-                .long("time-phases")
-                .help("Time the different bindgen phases and print to stderr"),
-            // All positional arguments after the end of options marker, `--`
-            Arg::new("clang-args").last(true).multiple_occurrences(true),
-            Arg::new("emit-clang-ast")
-                .long("emit-clang-ast")
-                .help("Output the Clang AST for debugging purposes."),
-            Arg::new("emit-ir")
-                .long("emit-ir")
-                .help("Output our internal IR for debugging purposes."),
-            Arg::new("emit-ir-graphviz")
-                .long("emit-ir-graphviz")
-                .help("Dump graphviz dot file.")
-                .value_name("path"),
-            Arg::new("enable-cxx-namespaces")
-                .long("enable-cxx-namespaces")
-                .help("Enable support for C++ namespaces."),
-            Arg::new("disable-name-namespacing")
-                .long("disable-name-namespacing")
-                .help(
-                    "Disable namespacing via mangling, causing bindgen to \
-                     generate names like \"Baz\" instead of \"foo_bar_Baz\" \
-                     for an input name \"foo::bar::Baz\".",
-                ),
-            Arg::new("disable-nested-struct-naming")
-                .long("disable-nested-struct-naming")
-                .help(
-                    "Disable nested struct naming, causing bindgen to generate \
-                     names like \"bar\" instead of \"foo_bar\" for a nested \
-                     definition \"struct foo { struct bar { } b; };\"."
-                ),
-            Arg::new("disable-untagged-union")
-                .long("disable-untagged-union")
-                .help(
-                    "Disable support for native Rust unions.",
-                ),
-            Arg::new("disable-header-comment")
-                .long("disable-header-comment")
-                .help("Suppress insertion of bindgen's version identifier into generated bindings.")
-                .multiple_occurrences(true),
-            Arg::new("ignore-functions")
-                .long("ignore-functions")
-                .help(
-                    "Do not generate bindings for functions or methods. This \
-                     is useful when you only care about struct layouts.",
-                ),
-            Arg::new("generate")
-                .long("generate")
-                .help(
-                    "Generate only given items, split by commas. \
-                     Valid values are \"functions\",\"types\", \"vars\", \
-                     \"methods\", \"constructors\" and \"destructors\".",
-                )
-                .takes_value(true),
-            Arg::new("ignore-methods")
-                .long("ignore-methods")
-                .help("Do not generate bindings for methods."),
-            Arg::new("no-convert-floats")
-                .long("no-convert-floats")
-                .help("Do not automatically convert floats to f32/f64."),
-            Arg::new("no-prepend-enum-name")
-                .long("no-prepend-enum-name")
-                .help("Do not prepend the enum name to constant or newtype variants."),
-            Arg::new("no-include-path-detection")
-                .long("no-include-path-detection")
-                .help("Do not try to detect default include paths"),
-            Arg::new("fit-macro-constant-types")
-                .long("fit-macro-constant-types")
-                .help("Try to fit macro constants into types smaller than u32/i32"),
-            Arg::new("unstable-rust")
-                .long("unstable-rust")
-                .help("Generate unstable Rust code (deprecated; use --rust-target instead).")
-                .multiple_occurrences(true), // FIXME: Pass legacy test suite
-            Arg::new("opaque-type")
-                .long("opaque-type")
-                .help("Mark <type> as opaque.")
-                .value_name("type")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("output")
-                .short('o')
-                .long("output")
-                .help("Write Rust bindings to <output>.")
-                .takes_value(true),
-            Arg::new("raw-line")
-                .long("raw-line")
-                .help("Add a raw line of Rust code at the beginning of output.")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("module-raw-line")
-                .long("module-raw-line")
-                .help("Add a raw line of Rust code to a given module.")
-                .multiple_occurrences(true)
-                .number_of_values(2)
-                .value_names(&["module-name", "raw-line"]),
-            Arg::new("rust-target")
-                .long("rust-target")
-                .help(rust_target_help.as_ref())
-                .takes_value(true),
-            Arg::new("use-core")
-                .long("use-core")
-                .help("Use types from Rust core instead of std."),
-            Arg::new("conservative-inline-namespaces")
-                .long("conservative-inline-namespaces")
-                .help(
-                    "Conservatively generate inline namespaces to avoid name \
-                     conflicts.",
-                ),
-            Arg::new("use-msvc-mangling")
-                .long("use-msvc-mangling")
-                .help("MSVC C++ ABI mangling. DEPRECATED: Has no effect."),
-            Arg::new("allowlist-function")
-                .long("allowlist-function")
-                .alias("whitelist-function")
-                .help(
-                    "Allowlist all the free-standing functions matching \
-                     <regex>. Other non-allowlisted functions will not be \
-                     generated.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("generate-inline-functions")
-                .long("generate-inline-functions")
-                .help("Generate inline functions."),
-            Arg::new("allowlist-type")
-                .long("allowlist-type")
-                .alias("whitelist-type")
-                .help(
-                    "Only generate types matching <regex>. Other non-allowlisted types will \
-                     not be generated.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("allowlist-var")
-                .long("allowlist-var")
-                .alias("whitelist-var")
-                .help(
-                    "Allowlist all the free-standing variables matching \
-                     <regex>. Other non-allowlisted variables will not be \
-                     generated.",
-                )
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("allowlist-file")
-                .alias("allowlist-file")
-                .long("allowlist-file")
-                .help("Allowlist all contents of <path>.")
-                .value_name("path")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("verbose")
-                .long("verbose")
-                .help("Print verbose error messages."),
-            Arg::new("dump-preprocessed-input")
-                .long("dump-preprocessed-input")
-                .help(
-                    "Preprocess and dump the input header files to disk. \
-                     Useful when debugging bindgen, using C-Reduce, or when \
-                     filing issues. The resulting file will be named \
-                     something like `__bindgen.i` or `__bindgen.ii`.",
-                ),
-            Arg::new("no-record-matches")
-                .long("no-record-matches")
-                .help(
-                    "Do not record matching items in the regex sets. \
-                     This disables reporting of unused items.",
-                ),
-            Arg::new("size_t-is-usize")
-                .long("size_t-is-usize")
-                .help("Ignored - this is enabled by default.")
-                .hidden(true),
-            Arg::with_name("no-size_t-is-usize")
-                .long("no-size_t-is-usize")
-                .help("Do not bind size_t as usize (useful on platforms \
-                       where those types are incompatible)."),
-            Arg::new("no-rustfmt-bindings")
-                .long("no-rustfmt-bindings")
-                .help("Do not format the generated bindings with rustfmt."),
-            Arg::new("rustfmt-bindings")
-                .long("rustfmt-bindings")
-                .help(
-                    "Format the generated bindings with rustfmt. DEPRECATED: \
-                     --rustfmt-bindings is now enabled by default. Disable \
-                     with --no-rustfmt-bindings.",
-                ),
-            Arg::new("rustfmt-configuration-file")
-                .long("rustfmt-configuration-file")
-                .help(
-                    "The absolute path to the rustfmt configuration file. \
-                     The configuration file will be used for formatting the bindings. \
-                     This parameter is incompatible with --no-rustfmt-bindings.",
-                )
-                .value_name("path")
-                .multiple_occurrences(false)
-                .number_of_values(1),
-            Arg::new("no-partialeq")
-                .long("no-partialeq")
-                .help("Avoid deriving PartialEq for types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("no-copy")
-                .long("no-copy")
-                .help("Avoid deriving Copy for types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("no-debug")
-                .long("no-debug")
-                .help("Avoid deriving Debug for types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("no-default")
-                .long("no-default")
-                .help("Avoid deriving/implement Default for types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("no-hash")
-                .long("no-hash")
-                .help("Avoid deriving Hash for types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("must-use-type")
-                .long("must-use-type")
-                .help("Add #[must_use] annotation to types matching <regex>.")
-                .value_name("regex")
-                .multiple_occurrences(true)
-                .number_of_values(1),
-            Arg::new("enable-function-attribute-detection")
-                .long("enable-function-attribute-detection")
-                .help(
-                    "Enables detecting unexposed attributes in functions (slow).
-                       Used to generate #[must_use] annotations.",
-                ),
-            Arg::new("use-array-pointers-in-arguments")
-                .long("use-array-pointers-in-arguments")
-                .help("Use `*const [T; size]` instead of `*const T` for C arrays"),
-            Arg::new("wasm-import-module-name")
-                .long("wasm-import-module-name")
-                .value_name("name")
-                .help("The name to be used in a #[link(wasm_import_module = ...)] statement"),
-            Arg::new("dynamic-loading")
-                .long("dynamic-loading")
-                .takes_value(true)
-                .help("Use dynamic loading mode with the given library name."),
-            Arg::new("dynamic-link-require-all")
-                .long("dynamic-link-require-all")
-                .help("Require successful linkage to all functions in the library."),
-            Arg::new("respect-cxx-access-specs")
-                .long("respect-cxx-access-specs")
-                .help("Makes generated bindings `pub` only for items if the items are publically accessible in C++."),
-            Arg::new("translate-enum-integer-types")
-                .long("translate-enum-integer-types")
-                .help("Always translate enum integer types to native Rust integer types."),
-            Arg::new("c-naming")
-                .long("c-naming")
-                .help("Generate types with C style naming."),
-            Arg::new("explicit-padding")
-                .long("explicit-padding")
-                .help("Always output explicit padding fields."),
-            Arg::new("vtable-generation")
-                .long("vtable-generation")
-                .help("Enables generation of vtable functions."),
-            Arg::new("sort-semantically")
-                .long("sort-semantically")
-                .help("Enables sorting of code generation in a predefined manner."),
-            Arg::new("merge-extern-blocks")
-                .long("merge-extern-blocks")
-                .help("Deduplicates extern blocks."),
-            Arg::new("V")
-                .long("version")
-                .help("Prints the version, and exits"),
-        ]) // .args()
-        .get_matches_from(args);
-
-    let verbose = matches.is_present("verbose");
-    if matches.is_present("V") {
-        println!(
-            "bindgen {}",
-            option_env!("CARGO_PKG_VERSION").unwrap_or("unknown")
-        );
-        if verbose {
-            println!("Clang: {}", crate::clang_version().full);
-        }
-        std::process::exit(0);
-    }
-
-    let mut builder = builder();
-
-    if let Some(header) = matches.value_of("header") {
-        builder = builder.header(header);
-    } else {
-        return Err(Error::new(ErrorKind::Other, "Header not found"));
-    }
-
-    if matches.is_present("unstable-rust") {
-        builder = builder.rust_target(RustTarget::Nightly);
-        writeln!(
-            &mut stderr(),
-            "warning: the `--unstable-rust` option is deprecated"
-        )
-        .expect("Unable to write error message");
-    }
-
-    if let Some(rust_target) = matches.value_of("rust-target") {
-        builder = builder.rust_target(RustTarget::from_str(rust_target)?);
-    }
-
-    if let Some(variant) = matches.value_of("default-enum-style") {
-        builder = builder.default_enum_style(EnumVariation::from_str(variant)?)
-    }
-
-    if let Some(bitfields) = matches.values_of("bitfield-enum") {
-        for regex in bitfields {
-            builder = builder.bitfield_enum(regex);
-        }
-    }
-
-    if let Some(newtypes) = matches.values_of("newtype-enum") {
-        for regex in newtypes {
-            builder = builder.newtype_enum(regex);
-        }
-    }
-
-    if let Some(newtypes) = matches.values_of("newtype-global-enum") {
-        for regex in newtypes {
-            builder = builder.newtype_global_enum(regex);
-        }
-    }
-
-    if let Some(rustifieds) = matches.values_of("rustified-enum") {
-        for regex in rustifieds {
-            builder = builder.rustified_enum(regex);
-        }
-    }
-
-    if let Some(const_enums) = matches.values_of("constified-enum") {
-        for regex in const_enums {
-            builder = builder.constified_enum(regex);
-        }
-    }
-
-    if let Some(constified_mods) = matches.values_of("constified-enum-module") {
-        for regex in constified_mods {
-            builder = builder.constified_enum_module(regex);
-        }
-    }
-
-    if let Some(variant) = matches.value_of("default-macro-constant-type") {
-        builder = builder
-            .default_macro_constant_type(MacroTypeVariation::from_str(variant)?)
-    }
-
-    if let Some(variant) = matches.value_of("default-alias-style") {
-        builder =
-            builder.default_alias_style(AliasVariation::from_str(variant)?);
-    }
-
-    if let Some(type_alias) = matches.values_of("normal-alias") {
-        for regex in type_alias {
-            builder = builder.type_alias(regex);
-        }
-    }
-
-    if let Some(new_type) = matches.values_of("new-type-alias") {
-        for regex in new_type {
-            builder = builder.new_type_alias(regex);
-        }
-    }
-
-    if let Some(new_type_deref) = matches.values_of("new-type-alias-deref") {
-        for regex in new_type_deref {
-            builder = builder.new_type_alias_deref(regex);
-        }
-    }
-
-    if let Some(variant) = matches.value_of("default-non-copy-union-style") {
-        builder = builder.default_non_copy_union_style(
-            NonCopyUnionStyle::from_str(variant)?,
-        );
-    }
-
-    if let Some(bindgen_wrapper_union) =
-        matches.values_of("bindgen-wrapper-union")
-    {
-        for regex in bindgen_wrapper_union {
-            builder = builder.bindgen_wrapper_union(regex);
-        }
-    }
-
-    if let Some(manually_drop_union) = matches.values_of("manually-drop-union")
-    {
-        for regex in manually_drop_union {
-            builder = builder.manually_drop_union(regex);
-        }
-    }
-
-    if let Some(hidden_types) = matches.values_of("blocklist-type") {
-        for ty in hidden_types {
-            builder = builder.blocklist_type(ty);
-        }
-    }
-
-    if let Some(hidden_functions) = matches.values_of("blocklist-function") {
-        for fun in hidden_functions {
-            builder = builder.blocklist_function(fun);
-        }
-    }
-
-    if let Some(hidden_identifiers) = matches.values_of("blocklist-item") {
-        for id in hidden_identifiers {
-            builder = builder.blocklist_item(id);
-        }
-    }
-
-    if let Some(hidden_files) = matches.values_of("blocklist-file") {
-        for file in hidden_files {
-            builder = builder.blocklist_file(file);
-        }
-    }
-
-    if matches.is_present("builtins") {
-        builder = builder.emit_builtins();
-    }
-
-    if matches.is_present("no-layout-tests") {
-        builder = builder.layout_tests(false);
-    }
-
-    if matches.is_present("no-derive-copy") {
-        builder = builder.derive_copy(false);
-    }
-
-    if matches.is_present("no-derive-debug") {
-        builder = builder.derive_debug(false);
-    }
-
-    if matches.is_present("impl-debug") {
-        builder = builder.impl_debug(true);
-    }
-
-    if matches.is_present("impl-partialeq") {
-        builder = builder.impl_partialeq(true);
-    }
-
-    if matches.is_present("with-derive-default") {
-        builder = builder.derive_default(true);
-    }
-
-    if matches.is_present("with-derive-hash") {
-        builder = builder.derive_hash(true);
-    }
-
-    if matches.is_present("with-derive-partialeq") {
-        builder = builder.derive_partialeq(true);
-    }
-
-    if matches.is_present("with-derive-partialord") {
-        builder = builder.derive_partialord(true);
-    }
-
-    if matches.is_present("with-derive-eq") {
-        builder = builder.derive_eq(true);
-    }
-
-    if matches.is_present("with-derive-ord") {
-        builder = builder.derive_ord(true);
-    }
-
-    if matches.is_present("no-derive-default") {
-        builder = builder.derive_default(false);
-    }
-
-    if matches.is_present("no-prepend-enum-name") {
-        builder = builder.prepend_enum_name(false);
-    }
-
-    if matches.is_present("no-include-path-detection") {
-        builder = builder.detect_include_paths(false);
-    }
-
-    if matches.is_present("fit-macro-constant-types") {
-        builder = builder.fit_macro_constants(true);
-    }
-
-    if matches.is_present("time-phases") {
-        builder = builder.time_phases(true);
-    }
-
-    if matches.is_present("use-array-pointers-in-arguments") {
-        builder = builder.array_pointers_in_arguments(true);
-    }
-
-    if let Some(wasm_import_name) = matches.value_of("wasm-import-module-name")
-    {
-        builder = builder.wasm_import_module_name(wasm_import_name);
-    }
-
-    if let Some(prefix) = matches.value_of("ctypes-prefix") {
-        builder = builder.ctypes_prefix(prefix);
-    }
-
-    if let Some(prefix) = matches.value_of("anon-fields-prefix") {
-        builder = builder.anon_fields_prefix(prefix);
-    }
-
-    if let Some(what_to_generate) = matches.value_of("generate") {
-        let mut config = CodegenConfig::empty();
-        for what in what_to_generate.split(',') {
-            match what {
-                "functions" => config.insert(CodegenConfig::FUNCTIONS),
-                "types" => config.insert(CodegenConfig::TYPES),
-                "vars" => config.insert(CodegenConfig::VARS),
-                "methods" => config.insert(CodegenConfig::METHODS),
-                "constructors" => config.insert(CodegenConfig::CONSTRUCTORS),
-                "destructors" => config.insert(CodegenConfig::DESTRUCTORS),
-                otherwise => {
-                    return Err(Error::new(
-                        ErrorKind::Other,
-                        format!("Unknown generate item: {}", otherwise),
-                    ));
-                }
-            }
-        }
-        builder = builder.with_codegen_config(config);
-    }
-
-    if matches.is_present("emit-clang-ast") {
-        builder = builder.emit_clang_ast();
-    }
-
-    if matches.is_present("emit-ir") {
-        builder = builder.emit_ir();
-    }
-
-    if let Some(path) = matches.value_of("emit-ir-graphviz") {
-        builder = builder.emit_ir_graphviz(path);
-    }
-
-    if matches.is_present("enable-cxx-namespaces") {
-        builder = builder.enable_cxx_namespaces();
-    }
-
-    if matches.is_present("enable-function-attribute-detection") {
-        builder = builder.enable_function_attribute_detection();
-    }
-
-    if matches.is_present("disable-name-namespacing") {
-        builder = builder.disable_name_namespacing();
-    }
-
-    if matches.is_present("disable-nested-struct-naming") {
-        builder = builder.disable_nested_struct_naming();
-    }
-
-    if matches.is_present("disable-untagged-union") {
-        builder = builder.disable_untagged_union();
-    }
-
-    if matches.is_present("disable-header-comment") {
-        builder = builder.disable_header_comment();
-    }
-
-    if matches.is_present("ignore-functions") {
-        builder = builder.ignore_functions();
-    }
-
-    if matches.is_present("ignore-methods") {
-        builder = builder.ignore_methods();
-    }
-
-    if matches.is_present("no-convert-floats") {
-        builder = builder.no_convert_floats();
-    }
-
-    if matches.is_present("no-doc-comments") {
-        builder = builder.generate_comments(false);
-    }
-
-    if matches.is_present("no-recursive-allowlist") {
-        builder = builder.allowlist_recursively(false);
-    }
-
-    if matches.is_present("objc-extern-crate") {
-        builder = builder.objc_extern_crate(true);
-    }
-
-    if matches.is_present("generate-block") {
-        builder = builder.generate_block(true);
-    }
-
-    if matches.is_present("block-extern-crate") {
-        builder = builder.block_extern_crate(true);
-    }
-
-    if let Some(opaque_types) = matches.values_of("opaque-type") {
-        for ty in opaque_types {
-            builder = builder.opaque_type(ty);
-        }
-    }
-
-    if let Some(lines) = matches.values_of("raw-line") {
-        for line in lines {
-            builder = builder.raw_line(line);
-        }
-    }
-
-    if let Some(mut values) = matches.values_of("module-raw-line") {
-        while let Some(module) = values.next() {
-            let line = values.next().unwrap();
-            builder = builder.module_raw_line(module, line);
-        }
-    }
-
-    if matches.is_present("use-core") {
-        builder = builder.use_core();
-    }
-
-    if matches.is_present("distrust-clang-mangling") {
-        builder = builder.trust_clang_mangling(false);
-    }
-
-    if matches.is_present("conservative-inline-namespaces") {
-        builder = builder.conservative_inline_namespaces();
-    }
-
-    if matches.is_present("generate-inline-functions") {
-        builder = builder.generate_inline_functions(true);
-    }
-
-    if let Some(allowlist) = matches.values_of("allowlist-function") {
-        for regex in allowlist {
-            builder = builder.allowlist_function(regex);
-        }
-    }
-
-    if let Some(allowlist) = matches.values_of("allowlist-type") {
-        for regex in allowlist {
-            builder = builder.allowlist_type(regex);
-        }
-    }
-
-    if let Some(allowlist) = matches.values_of("allowlist-var") {
-        for regex in allowlist {
-            builder = builder.allowlist_var(regex);
-        }
-    }
-
-    if let Some(hidden_files) = matches.values_of("allowlist-file") {
-        for file in hidden_files {
-            builder = builder.allowlist_file(file);
-        }
-    }
-
-    if let Some(args) = matches.values_of("clang-args") {
-        for arg in args {
-            builder = builder.clang_arg(arg);
-        }
-    }
-
-    let output = if let Some(path) = matches.value_of("output") {
-        let file = File::create(path)?;
-        if let Some(depfile) = matches.value_of("depfile") {
-            builder = builder.depfile(path, depfile);
-        }
-        Box::new(io::BufWriter::new(file)) as Box<dyn io::Write>
-    } else {
-        if let Some(depfile) = matches.value_of("depfile") {
-            builder = builder.depfile("-", depfile);
-        }
-        Box::new(io::BufWriter::new(io::stdout())) as Box<dyn io::Write>
-    };
-
-    if matches.is_present("dump-preprocessed-input") {
-        builder.dump_preprocessed_input()?;
-    }
-
-    if matches.is_present("no-record-matches") {
-        builder = builder.record_matches(false);
-    }
-
-    if matches.is_present("no-size_t-is-usize") {
-        builder = builder.size_t_is_usize(false);
-    }
-
-    let no_rustfmt_bindings = matches.is_present("no-rustfmt-bindings");
-    if no_rustfmt_bindings {
-        builder = builder.rustfmt_bindings(false);
-    }
-
-    if let Some(path_str) = matches.value_of("rustfmt-configuration-file") {
-        let path = PathBuf::from(path_str);
-
-        if no_rustfmt_bindings {
-            return Err(Error::new(
-                ErrorKind::Other,
-                "Cannot supply both --rustfmt-configuration-file and --no-rustfmt-bindings",
-            ));
-        }
-
-        if !path.is_absolute() {
-            return Err(Error::new(
-                ErrorKind::Other,
-                "--rustfmt-configuration--file needs to be an absolute path!",
-            ));
-        }
-
-        if path.to_str().is_none() {
-            return Err(Error::new(
-                ErrorKind::Other,
-                "--rustfmt-configuration-file contains non-valid UTF8 characters.",
-            ));
-        }
-
-        builder = builder.rustfmt_configuration_file(Some(path));
-    }
-
-    if let Some(no_partialeq) = matches.values_of("no-partialeq") {
-        for regex in no_partialeq {
-            builder = builder.no_partialeq(regex);
-        }
-    }
-
-    if let Some(no_copy) = matches.values_of("no-copy") {
-        for regex in no_copy {
-            builder = builder.no_copy(regex);
-        }
-    }
-
-    if let Some(no_debug) = matches.values_of("no-debug") {
-        for regex in no_debug {
-            builder = builder.no_debug(regex);
-        }
-    }
-
-    if let Some(no_default) = matches.values_of("no-default") {
-        for regex in no_default {
-            builder = builder.no_default(regex);
-        }
-    }
-
-    if let Some(no_hash) = matches.values_of("no-hash") {
-        for regex in no_hash {
-            builder = builder.no_hash(regex);
-        }
-    }
-
-    if let Some(must_use_type) = matches.values_of("must-use-type") {
-        for regex in must_use_type {
-            builder = builder.must_use_type(regex);
-        }
-    }
-
-    if let Some(dynamic_library_name) = matches.value_of("dynamic-loading") {
-        builder = builder.dynamic_library_name(dynamic_library_name);
-    }
-
-    if matches.is_present("dynamic-link-require-all") {
-        builder = builder.dynamic_link_require_all(true);
-    }
-
-    if matches.is_present("respect-cxx-access-specs") {
-        builder = builder.respect_cxx_access_specs(true);
-    }
-
-    if matches.is_present("translate-enum-integer-types") {
-        builder = builder.translate_enum_integer_types(true);
-    }
-
-    if matches.is_present("c-naming") {
-        builder = builder.c_naming(true);
-    }
-
-    if matches.is_present("explicit-padding") {
-        builder = builder.explicit_padding(true);
-    }
-
-    if matches.is_present("vtable-generation") {
-        builder = builder.vtable_generation(true);
-    }
-
-    if matches.is_present("sort-semantically") {
-        builder = builder.sort_semantically(true);
-    }
-
-    if matches.is_present("merge-extern-blocks") {
-        builder = builder.merge_extern_blocks(true);
-    }
-
-    Ok((builder, output, verbose))
-}
diff --git a/src/parse.rs b/src/parse.rs
deleted file mode 100644
index f60de431..00000000
--- a/src/parse.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-//! Common traits and types related to parsing our IR from Clang cursors.
-
-use crate::clang;
-use crate::ir::context::{BindgenContext, ItemId, TypeId};
-use crate::ir::ty::TypeKind;
-
-/// Not so much an error in the traditional sense, but a control flow message
-/// when walking over Clang's AST with a cursor.
-#[derive(Debug)]
-pub enum ParseError {
-    /// Recurse down the current AST node's children.
-    Recurse,
-    /// Continue on to the next sibling AST node, or back up to the parent's
-    /// siblings if we've exhausted all of this node's siblings (and so on).
-    Continue,
-}
-
-/// The result of parsing a Clang AST node.
-#[derive(Debug)]
-pub enum ParseResult<T> {
-    /// We've already resolved this item before, here is the extant `ItemId` for
-    /// it.
-    AlreadyResolved(ItemId),
-
-    /// This is a newly parsed item. If the cursor is `Some`, it points to the
-    /// AST node where the new `T` was declared.
-    New(T, Option<clang::Cursor>),
-}
-
-/// An intermediate representation "sub-item" (i.e. one of the types contained
-/// inside an `ItemKind` variant) that can be parsed from a Clang cursor.
-pub trait ClangSubItemParser: Sized {
-    /// Attempt to parse this type from the given cursor.
-    ///
-    /// The fact that is a reference guarantees it's held by the context, and
-    /// allow returning already existing types.
-    fn parse(
-        cursor: clang::Cursor,
-        context: &mut BindgenContext,
-    ) -> Result<ParseResult<Self>, ParseError>;
-}
-
-/// An intermediate representation item that can be parsed from a Clang cursor.
-pub trait ClangItemParser: Sized {
-    /// Parse this item from the given Clang cursor.
-    fn parse(
-        cursor: clang::Cursor,
-        parent: Option<ItemId>,
-        context: &mut BindgenContext,
-    ) -> Result<ItemId, ParseError>;
-
-    /// Parse this item from the given Clang type.
-    fn from_ty(
-        ty: &clang::Type,
-        location: clang::Cursor,
-        parent: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<TypeId, ParseError>;
-
-    /// Identical to `from_ty`, but use the given `id` as the `ItemId` for the
-    /// newly parsed item.
-    fn from_ty_with_id(
-        id: ItemId,
-        ty: &clang::Type,
-        location: clang::Cursor,
-        parent: Option<ItemId>,
-        ctx: &mut BindgenContext,
-    ) -> Result<TypeId, ParseError>;
-
-    /// Parse this item from the given Clang type, or if we haven't resolved all
-    /// the other items this one depends on, an unresolved reference.
-    fn from_ty_or_ref(
-        ty: clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        context: &mut BindgenContext,
-    ) -> TypeId;
-
-    /// Identical to `from_ty_or_ref`, but use the given `potential_id` as the
-    /// `ItemId` for the newly parsed item.
-    fn from_ty_or_ref_with_id(
-        potential_id: ItemId,
-        ty: clang::Type,
-        location: clang::Cursor,
-        parent_id: Option<ItemId>,
-        context: &mut BindgenContext,
-    ) -> TypeId;
-
-    /// Create a named template type.
-    fn type_param(
-        with_id: Option<ItemId>,
-        location: clang::Cursor,
-        ctx: &mut BindgenContext,
-    ) -> Option<TypeId>;
-
-    /// Create a builtin type.
-    fn builtin_type(
-        kind: TypeKind,
-        is_const: bool,
-        context: &mut BindgenContext,
-    ) -> TypeId;
-}
diff --git a/src/regex_set.rs b/src/regex_set.rs
deleted file mode 100644
index 9262c4ee..00000000
--- a/src/regex_set.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-//! A type that represents the union of a set of regular expressions.
-
-use regex::RegexSet as RxSet;
-use std::cell::Cell;
-
-/// A dynamic set of regular expressions.
-#[derive(Clone, Debug, Default)]
-pub struct RegexSet {
-    items: Vec<String>,
-    /// Whether any of the items in the set was ever matched. The length of this
-    /// vector is exactly the length of `items`.
-    matched: Vec<Cell<bool>>,
-    set: Option<RxSet>,
-    /// Whether we should record matching items in the `matched` vector or not.
-    record_matches: bool,
-}
-
-impl RegexSet {
-    /// Is this set empty?
-    pub fn is_empty(&self) -> bool {
-        self.items.is_empty()
-    }
-
-    /// Insert a new regex into this set.
-    pub fn insert<S>(&mut self, string: S)
-    where
-        S: AsRef<str>,
-    {
-        self.items.push(string.as_ref().to_owned());
-        self.matched.push(Cell::new(false));
-        self.set = None;
-    }
-
-    /// Returns slice of String from its field 'items'
-    pub fn get_items(&self) -> &[String] {
-        &self.items[..]
-    }
-
-    /// Returns an iterator over regexes in the set which didn't match any
-    /// strings yet.
-    pub fn unmatched_items(&self) -> impl Iterator<Item = &String> {
-        self.items.iter().enumerate().filter_map(move |(i, item)| {
-            if !self.record_matches || self.matched[i].get() {
-                return None;
-            }
-
-            Some(item)
-        })
-    }
-
-    /// Construct a RegexSet from the set of entries we've accumulated.
-    ///
-    /// Must be called before calling `matches()`, or it will always return
-    /// false.
-    pub fn build(&mut self, record_matches: bool) {
-        let items = self.items.iter().map(|item| format!("^{}$", item));
-        self.record_matches = record_matches;
-        self.set = match RxSet::new(items) {
-            Ok(x) => Some(x),
-            Err(e) => {
-                warn!("Invalid regex in {:?}: {:?}", self.items, e);
-                None
-            }
-        }
-    }
-
-    /// Does the given `string` match any of the regexes in this set?
-    pub fn matches<S>(&self, string: S) -> bool
-    where
-        S: AsRef<str>,
-    {
-        let s = string.as_ref();
-        let set = match self.set {
-            Some(ref set) => set,
-            None => return false,
-        };
-
-        if !self.record_matches {
-            return set.is_match(s);
-        }
-
-        let matches = set.matches(s);
-        if !matches.matched_any() {
-            return false;
-        }
-        for i in matches.iter() {
-            self.matched[i].set(true);
-        }
-
-        true
-    }
-}
diff --git a/src/time.rs b/src/time.rs
deleted file mode 100644
index c13a640c..00000000
--- a/src/time.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use std::io::{self, Write};
-use std::time::{Duration, Instant};
-
-/// RAII timer to measure how long phases take.
-#[derive(Debug)]
-pub struct Timer<'a> {
-    output: bool,
-    name: &'a str,
-    start: Instant,
-}
-
-impl<'a> Timer<'a> {
-    /// Creates a Timer with the given name, and starts it. By default,
-    /// will print to stderr when it is `drop`'d
-    pub fn new(name: &'a str) -> Self {
-        Timer {
-            output: true,
-            name,
-            start: Instant::now(),
-        }
-    }
-
-    /// Sets whether or not the Timer will print a message
-    /// when it is dropped.
-    pub fn with_output(mut self, output: bool) -> Self {
-        self.output = output;
-        self
-    }
-
-    /// Returns the time elapsed since the timer's creation
-    pub fn elapsed(&self) -> Duration {
-        Instant::now() - self.start
-    }
-
-    fn print_elapsed(&mut self) {
-        if self.output {
-            let elapsed = self.elapsed();
-            let time = (elapsed.as_secs() as f64) * 1e3 +
-                (elapsed.subsec_nanos() as f64) / 1e6;
-            let stderr = io::stderr();
-            // Arbitrary output format, subject to change.
-            writeln!(stderr.lock(), "  time: {:>9.3} ms.\t{}", time, self.name)
-                .expect("timer write should not fail");
-        }
-    }
-}
-
-impl<'a> Drop for Timer<'a> {
-    fn drop(&mut self) {
-        self.print_elapsed();
-    }
-}
diff --git a/tests/.gitattributes b/tests/.gitattributes
deleted file mode 100644
index 96122eb1..00000000
--- a/tests/.gitattributes
+++ /dev/null
@@ -1,4 +0,0 @@
-# Tell Github Linguist to avoid counting these C and C++ test inputs toward
-# statistics.
-*.h -linguist-detectable
-*.hpp -linguist-detectable
diff --git a/tests/expectations/Cargo.toml b/tests/expectations/Cargo.toml
deleted file mode 100644
index f8006afe..00000000
--- a/tests/expectations/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "tests_expectations"
-description = "bindgen results when ran on ../headers/*"
-version = "0.1.0"
-authors = [
-  "Jyun-Yan You <jyyou.tw@gmail.com>",
-  "Emilio Cobos Álvarez <emilio@crisal.io>",
-  "The Servo project developers",
-]
-edition = "2018"
-
-[dependencies]
-objc = "0.2"
-block = "0.1"
-libloading = "0.6.2"
diff --git a/tests/expectations/build.rs b/tests/expectations/build.rs
deleted file mode 100644
index e44bcc85..00000000
--- a/tests/expectations/build.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-//! Generate a module with a custom `#[path=...]` for each of the files in our
-//! libclang version-specific test expectations so that they get their layout
-//! tests run. We need to do this because cargo doesn't automatically detect
-//! tests subdirectories.
-
-use std::env;
-use std::fs;
-use std::io::Write;
-use std::path::Path;
-
-const LIBCLANG_VERSION_DIRS: &'static [&'static str] = &[
-    "libclang-5",
-    "libclang-9",
-];
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    let mut test_string = String::new();
-
-    for dir in LIBCLANG_VERSION_DIRS {
-        let dir = Path::new(&env::var_os("CARGO_MANIFEST_DIR").unwrap())
-            .join("tests")
-            .join(dir);
-
-        println!("cargo:rerun-if-changed={}", dir.display());
-
-        for entry in fs::read_dir(dir).unwrap() {
-            let entry = entry.unwrap();
-            let path = entry.path();
-            let path = path.canonicalize().unwrap_or_else(|_| path.into());
-            if path.extension().map(|e| e.to_string_lossy()) !=
-                Some("rs".into())
-            {
-                continue;
-            }
-
-            println!("cargo:rerun-if-changed={}", path.display());
-
-            let module_name: String = path
-                .display()
-                .to_string()
-                .chars()
-                .map(|c| match c {
-                    'a'..='z' | 'A'..='Z' | '0'..='9' => c,
-                    _ => '_',
-                })
-                .collect();
-
-            test_string.push_str(&format!(
-                r###"
-#[path = "{}"]
-mod {};
-"###,
-                path.display().to_string().replace('\\', "\\\\"),
-                module_name,
-            ));
-        }
-    }
-
-    let out_path = Path::new(&env::var_os("OUT_DIR").unwrap())
-        .join("libclang_version_specific_generated_tests.rs");
-    let mut test_file = fs::File::create(out_path).unwrap();
-    test_file.write_all(test_string.as_bytes()).unwrap();
-}
diff --git a/tests/expectations/lib.rs b/tests/expectations/lib.rs
deleted file mode 100755
index 562dc554..00000000
--- a/tests/expectations/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-#![allow(non_upper_case_globals)]
diff --git a/tests/expectations/src/lib.rs b/tests/expectations/src/lib.rs
deleted file mode 100644
index 8b137891..00000000
--- a/tests/expectations/src/lib.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tests/expectations/struct_with_anon_struct_array_float.rs b/tests/expectations/struct_with_anon_struct_array_float.rs
deleted file mode 100644
index 8b137891..00000000
--- a/tests/expectations/struct_with_anon_struct_array_float.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tests/expectations/tests/.gitattributes b/tests/expectations/tests/.gitattributes
deleted file mode 100644
index 9699dfa0..00000000
--- a/tests/expectations/tests/.gitattributes
+++ /dev/null
@@ -1,2 +0,0 @@
-# Prevent Github Linguist from counting generated files in statistics.
-*.rs linguist-generated
diff --git a/tests/expectations/tests/16-byte-alignment.rs b/tests/expectations/tests/16-byte-alignment.rs
deleted file mode 100644
index a60a63aa..00000000
--- a/tests/expectations/tests/16-byte-alignment.rs
+++ /dev/null
@@ -1,355 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_ipv4_tuple {
-    pub src_addr: u32,
-    pub dst_addr: u32,
-    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_ipv4_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
-    pub sctp_tag: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
-    pub dport: u16,
-    pub sport: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(dport)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(sport)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
-}
-impl Default for rte_ipv4_tuple__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_ipv4_tuple))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv4_tuple))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple),
-            "::",
-            stringify!(src_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple),
-            "::",
-            stringify!(dst_addr)
-        )
-    );
-}
-impl Default for rte_ipv4_tuple {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_ipv6_tuple {
-    pub src_addr: [u8; 16usize],
-    pub dst_addr: [u8; 16usize],
-    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_ipv6_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
-    pub sctp_tag: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
-    pub dport: u16,
-    pub sport: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(dport)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(sport)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
-}
-impl Default for rte_ipv6_tuple__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_ipv6_tuple))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv6_tuple))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple),
-            "::",
-            stringify!(src_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple),
-            "::",
-            stringify!(dst_addr)
-        )
-    );
-}
-impl Default for rte_ipv6_tuple {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Copy, Clone)]
-pub union rte_thash_tuple {
-    pub v4: rte_ipv4_tuple,
-    pub v6: rte_ipv6_tuple,
-}
-#[test]
-fn bindgen_test_layout_rte_thash_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_thash_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_thash_tuple>(),
-        48usize,
-        concat!("Size of: ", stringify!(rte_thash_tuple))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_thash_tuple>(),
-        16usize,
-        concat!("Alignment of ", stringify!(rte_thash_tuple))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v4) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v4)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v6) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v6)
-        )
-    );
-}
-impl Default for rte_thash_tuple {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/16-byte-alignment_1_0.rs b/tests/expectations/tests/16-byte-alignment_1_0.rs
deleted file mode 100644
index 369e2c75..00000000
--- a/tests/expectations/tests/16-byte-alignment_1_0.rs
+++ /dev/null
@@ -1,396 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv4_tuple {
-    pub src_addr: u32,
-    pub dst_addr: u32,
-    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv4_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1:
-        __BindgenUnionField<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>,
-    pub sctp_tag: __BindgenUnionField<u32>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
-    pub dport: u16,
-    pub sport: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(dport)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(sport)
-        )
-    );
-}
-impl Clone for rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
-}
-impl Clone for rte_ipv4_tuple__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv4_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv4_tuple>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_ipv4_tuple))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv4_tuple>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv4_tuple))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple),
-            "::",
-            stringify!(src_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple),
-            "::",
-            stringify!(dst_addr)
-        )
-    );
-}
-impl Clone for rte_ipv4_tuple {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv6_tuple {
-    pub src_addr: [u8; 16usize],
-    pub dst_addr: [u8; 16usize],
-    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv6_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1:
-        __BindgenUnionField<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>,
-    pub sctp_tag: __BindgenUnionField<u32>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
-    pub dport: u16,
-    pub sport: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(dport)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(sport)
-        )
-    );
-}
-impl Clone for rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
-}
-impl Clone for rte_ipv6_tuple__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_ipv6_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ipv6_tuple>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_ipv6_tuple))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ipv6_tuple>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ipv6_tuple))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple),
-            "::",
-            stringify!(src_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple),
-            "::",
-            stringify!(dst_addr)
-        )
-    );
-}
-impl Clone for rte_ipv6_tuple {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Copy)]
-pub struct rte_thash_tuple {
-    pub v4: __BindgenUnionField<rte_ipv4_tuple>,
-    pub v6: __BindgenUnionField<rte_ipv6_tuple>,
-    pub bindgen_union_field: [u8; 48usize],
-}
-#[test]
-fn bindgen_test_layout_rte_thash_tuple() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_thash_tuple> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_thash_tuple>(),
-        48usize,
-        concat!("Size of: ", stringify!(rte_thash_tuple))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v4) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v4)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v6) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v6)
-        )
-    );
-}
-impl Clone for rte_thash_tuple {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_thash_tuple {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/381-decltype-alias.rs b/tests/expectations/tests/381-decltype-alias.rs
deleted file mode 100644
index f4312a11..00000000
--- a/tests/expectations/tests/381-decltype-alias.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct std_allocator_traits {
-    pub _address: u8,
-}
-pub type std_allocator_traits___size_type<_Alloc> = _Alloc;
diff --git a/tests/expectations/tests/accessors.rs b/tests/expectations/tests/accessors.rs
deleted file mode 100644
index 05fdaf4c..00000000
--- a/tests/expectations/tests/accessors.rs
+++ /dev/null
@@ -1,434 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct SomeAccessors {
-    pub mNoAccessor: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor></div>
-    pub mBothAccessors: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor="unsafe"></div>
-    pub mUnsafeAccessors: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor="immutable"></div>
-    pub mImmutableAccessor: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_SomeAccessors() {
-    const UNINIT: ::std::mem::MaybeUninit<SomeAccessors> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<SomeAccessors>(),
-        16usize,
-        concat!("Size of: ", stringify!(SomeAccessors))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<SomeAccessors>(),
-        4usize,
-        concat!("Alignment of ", stringify!(SomeAccessors))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mNoAccessor) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SomeAccessors),
-            "::",
-            stringify!(mNoAccessor)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SomeAccessors),
-            "::",
-            stringify!(mBothAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mUnsafeAccessors) as usize -
-                ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SomeAccessors),
-            "::",
-            stringify!(mUnsafeAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mImmutableAccessor) as usize -
-                ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SomeAccessors),
-            "::",
-            stringify!(mImmutableAccessor)
-        )
-    );
-}
-impl SomeAccessors {
-    #[inline]
-    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mBothAccessors
-    }
-    #[inline]
-    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
-        &mut self.mBothAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mUnsafeAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mUnsafeAccessors_mut(
-        &mut self,
-    ) -> &mut ::std::os::raw::c_int {
-        &mut self.mUnsafeAccessors
-    }
-    #[inline]
-    pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int {
-        &self.mImmutableAccessor
-    }
-}
-/// <div rustbindgen accessor></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AllAccessors {
-    pub mBothAccessors: ::std::os::raw::c_int,
-    pub mAlsoBothAccessors: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AllAccessors() {
-    const UNINIT: ::std::mem::MaybeUninit<AllAccessors> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllAccessors>(),
-        8usize,
-        concat!("Size of: ", stringify!(AllAccessors))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllAccessors>(),
-        4usize,
-        concat!("Alignment of ", stringify!(AllAccessors))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllAccessors),
-            "::",
-            stringify!(mBothAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mAlsoBothAccessors) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllAccessors),
-            "::",
-            stringify!(mAlsoBothAccessors)
-        )
-    );
-}
-impl AllAccessors {
-    #[inline]
-    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mBothAccessors
-    }
-    #[inline]
-    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
-        &mut self.mBothAccessors
-    }
-    #[inline]
-    pub fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mAlsoBothAccessors
-    }
-    #[inline]
-    pub fn get_mAlsoBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
-        &mut self.mAlsoBothAccessors
-    }
-}
-/// <div rustbindgen accessor="unsafe"></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AllUnsafeAccessors {
-    pub mBothAccessors: ::std::os::raw::c_int,
-    pub mAlsoBothAccessors: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AllUnsafeAccessors() {
-    const UNINIT: ::std::mem::MaybeUninit<AllUnsafeAccessors> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllUnsafeAccessors>(),
-        8usize,
-        concat!("Size of: ", stringify!(AllUnsafeAccessors))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllUnsafeAccessors>(),
-        4usize,
-        concat!("Alignment of ", stringify!(AllUnsafeAccessors))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllUnsafeAccessors),
-            "::",
-            stringify!(mBothAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mAlsoBothAccessors) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllUnsafeAccessors),
-            "::",
-            stringify!(mAlsoBothAccessors)
-        )
-    );
-}
-impl AllUnsafeAccessors {
-    #[inline]
-    pub unsafe fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mBothAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mBothAccessors_mut(
-        &mut self,
-    ) -> &mut ::std::os::raw::c_int {
-        &mut self.mBothAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mAlsoBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mAlsoBothAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mAlsoBothAccessors_mut(
-        &mut self,
-    ) -> &mut ::std::os::raw::c_int {
-        &mut self.mAlsoBothAccessors
-    }
-}
-/// <div rustbindgen accessor></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ContradictAccessors {
-    pub mBothAccessors: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor="false"></div>
-    pub mNoAccessors: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor="unsafe"></div>
-    pub mUnsafeAccessors: ::std::os::raw::c_int,
-    /// <div rustbindgen accessor="immutable"></div>
-    pub mImmutableAccessor: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ContradictAccessors() {
-    const UNINIT: ::std::mem::MaybeUninit<ContradictAccessors> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContradictAccessors>(),
-        16usize,
-        concat!("Size of: ", stringify!(ContradictAccessors))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContradictAccessors>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ContradictAccessors))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBothAccessors) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictAccessors),
-            "::",
-            stringify!(mBothAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mNoAccessors) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictAccessors),
-            "::",
-            stringify!(mNoAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mUnsafeAccessors) as usize -
-                ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictAccessors),
-            "::",
-            stringify!(mUnsafeAccessors)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mImmutableAccessor) as usize -
-                ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictAccessors),
-            "::",
-            stringify!(mImmutableAccessor)
-        )
-    );
-}
-impl ContradictAccessors {
-    #[inline]
-    pub fn get_mBothAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mBothAccessors
-    }
-    #[inline]
-    pub fn get_mBothAccessors_mut(&mut self) -> &mut ::std::os::raw::c_int {
-        &mut self.mBothAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mUnsafeAccessors(&self) -> &::std::os::raw::c_int {
-        &self.mUnsafeAccessors
-    }
-    #[inline]
-    pub unsafe fn get_mUnsafeAccessors_mut(
-        &mut self,
-    ) -> &mut ::std::os::raw::c_int {
-        &mut self.mUnsafeAccessors
-    }
-    #[inline]
-    pub fn get_mImmutableAccessor(&self) -> &::std::os::raw::c_int {
-        &self.mImmutableAccessor
-    }
-}
-/// <div rustbindgen accessor replaces="Replaced"></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Replaced {
-    pub mAccessor: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Replaced() {
-    const UNINIT: ::std::mem::MaybeUninit<Replaced> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Replaced>(),
-        4usize,
-        concat!("Size of: ", stringify!(Replaced))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Replaced>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Replaced))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mAccessor) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Replaced),
-            "::",
-            stringify!(mAccessor)
-        )
-    );
-}
-impl Replaced {
-    #[inline]
-    pub fn get_mAccessor(&self) -> &::std::os::raw::c_int {
-        &self.mAccessor
-    }
-    #[inline]
-    pub fn get_mAccessor_mut(&mut self) -> &mut ::std::os::raw::c_int {
-        &mut self.mAccessor
-    }
-}
-/// <div rustbindgen accessor></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Wrapper {
-    pub mReplaced: Replaced,
-}
-#[test]
-fn bindgen_test_layout_Wrapper() {
-    const UNINIT: ::std::mem::MaybeUninit<Wrapper> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Wrapper>(),
-        4usize,
-        concat!("Size of: ", stringify!(Wrapper))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Wrapper>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Wrapper))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mReplaced) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Wrapper),
-            "::",
-            stringify!(mReplaced)
-        )
-    );
-}
-impl Wrapper {
-    #[inline]
-    pub fn get_mReplaced(&self) -> &Replaced {
-        &self.mReplaced
-    }
-    #[inline]
-    pub fn get_mReplaced_mut(&mut self) -> &mut Replaced {
-        &mut self.mReplaced
-    }
-}
diff --git a/tests/expectations/tests/allowlist-file.rs b/tests/expectations/tests/allowlist-file.rs
deleted file mode 100644
index 3b72fb75..00000000
--- a/tests/expectations/tests/allowlist-file.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const SOME_DEFUN: u32 = 123;
-extern "C" {
-    #[link_name = "\u{1}_Z12SomeFunctionv"]
-    pub fn SomeFunction();
-}
-extern "C" {
-    pub static mut someVar: ::std::os::raw::c_int;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct someClass {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_someClass() {
-    assert_eq!(
-        ::std::mem::size_of::<someClass>(),
-        1usize,
-        concat!("Size of: ", stringify!(someClass))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<someClass>(),
-        1usize,
-        concat!("Alignment of ", stringify!(someClass))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN9someClass16somePublicMethodEi"]
-    pub fn someClass_somePublicMethod(
-        this: *mut someClass,
-        foo: ::std::os::raw::c_int,
-    );
-}
-impl someClass {
-    #[inline]
-    pub unsafe fn somePublicMethod(&mut self, foo: ::std::os::raw::c_int) {
-        someClass_somePublicMethod(self, foo)
-    }
-}
-extern "C" {
-    pub fn ExternFunction();
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3foo18NamespacedFunctionEv"]
-    pub fn foo_NamespacedFunction();
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StructWithAllowlistedDefinition {
-    pub other: *mut StructWithAllowlistedFwdDecl,
-}
-#[test]
-fn bindgen_test_layout_StructWithAllowlistedDefinition() {
-    const UNINIT: ::std::mem::MaybeUninit<StructWithAllowlistedDefinition> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<StructWithAllowlistedDefinition>(),
-        8usize,
-        concat!("Size of: ", stringify!(StructWithAllowlistedDefinition))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StructWithAllowlistedDefinition>(),
-        8usize,
-        concat!("Alignment of ", stringify!(StructWithAllowlistedDefinition))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).other) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StructWithAllowlistedDefinition),
-            "::",
-            stringify!(other)
-        )
-    );
-}
-impl Default for StructWithAllowlistedDefinition {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct StructWithAllowlistedFwdDecl {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_StructWithAllowlistedFwdDecl() {
-    const UNINIT: ::std::mem::MaybeUninit<StructWithAllowlistedFwdDecl> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<StructWithAllowlistedFwdDecl>(),
-        4usize,
-        concat!("Size of: ", stringify!(StructWithAllowlistedFwdDecl))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StructWithAllowlistedFwdDecl>(),
-        4usize,
-        concat!("Alignment of ", stringify!(StructWithAllowlistedFwdDecl))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StructWithAllowlistedFwdDecl),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AllowlistMe {
-    pub foo: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AllowlistMe() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistMe>(),
-        4usize,
-        concat!("Size of: ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistMe>(),
-        4usize,
-        concat!("Alignment of ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistMe),
-            "::",
-            stringify!(foo)
-        )
-    );
-}
diff --git a/tests/expectations/tests/allowlist-namespaces-basic.rs b/tests/expectations/tests/allowlist-namespaces-basic.rs
deleted file mode 100644
index 36d03fef..00000000
--- a/tests/expectations/tests/allowlist-namespaces-basic.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod outer {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod inner {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            #[repr(C)]
-            #[derive(Debug, Default, Copy, Clone)]
-            pub struct Helper {
-                pub _address: u8,
-            }
-            #[test]
-            fn bindgen_test_layout_Helper() {
-                assert_eq!(
-                    ::std::mem::size_of::<Helper>(),
-                    1usize,
-                    concat!("Size of: ", stringify!(Helper))
-                );
-                assert_eq!(
-                    ::std::mem::align_of::<Helper>(),
-                    1usize,
-                    concat!("Alignment of ", stringify!(Helper))
-                );
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/allowlist-namespaces.rs b/tests/expectations/tests/allowlist-namespaces.rs
deleted file mode 100644
index ee9fe428..00000000
--- a/tests/expectations/tests/allowlist-namespaces.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod outer {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod inner {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            #[repr(C)]
-            #[derive(Debug, Default, Copy, Clone)]
-            pub struct Helper {
-                pub _address: u8,
-            }
-            #[test]
-            fn bindgen_test_layout_Helper() {
-                assert_eq!(
-                    ::std::mem::size_of::<Helper>(),
-                    1usize,
-                    concat!("Size of: ", stringify!(Helper))
-                );
-                assert_eq!(
-                    ::std::mem::align_of::<Helper>(),
-                    1usize,
-                    concat!("Alignment of ", stringify!(Helper))
-                );
-            }
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Test {
-            pub helper: root::outer::inner::Helper,
-        }
-        #[test]
-        fn bindgen_test_layout_Test() {
-            const UNINIT: ::std::mem::MaybeUninit<Test> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Test>(),
-                1usize,
-                concat!("Size of: ", stringify!(Test))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Test>(),
-                1usize,
-                concat!("Alignment of ", stringify!(Test))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).helper) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Test),
-                    "::",
-                    stringify!(helper)
-                )
-            );
-        }
-    }
-}
diff --git a/tests/expectations/tests/allowlist_basic.rs b/tests/expectations/tests/allowlist_basic.rs
deleted file mode 100644
index 5bfe42e8..00000000
--- a/tests/expectations/tests/allowlist_basic.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct AllowlistMe<T> {
-    pub foo: ::std::os::raw::c_int,
-    pub bar: AllowlistMe_Inner<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct AllowlistMe_Inner<T> {
-    pub bar: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for AllowlistMe_Inner<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> Default for AllowlistMe<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/allowlist_fix.rs b/tests/expectations/tests/allowlist_fix.rs
deleted file mode 100644
index 9cff795b..00000000
--- a/tests/expectations/tests/allowlist_fix.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub enum Test {}
-
-extern "C" {
-    pub fn Servo_Test(a: *mut Test);
-}
diff --git a/tests/expectations/tests/allowlist_vars.rs b/tests/expectations/tests/allowlist_vars.rs
deleted file mode 100644
index 590cbafc..00000000
--- a/tests/expectations/tests/allowlist_vars.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const NONE: u32 = 0;
-pub const FOO: u32 = 5;
-pub const FOOB: i32 = -2;
-pub const FOOBAR: i32 = -10;
diff --git a/tests/expectations/tests/allowlist_warnings.rs b/tests/expectations/tests/allowlist_warnings.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/allowlist_warnings.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/allowlisted-item-references-no-hash.rs b/tests/expectations/tests/allowlisted-item-references-no-hash.rs
deleted file mode 100644
index 56dc5bce..00000000
--- a/tests/expectations/tests/allowlisted-item-references-no-hash.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoHash {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_NoHash() {
-    assert_eq!(
-        ::std::mem::size_of::<NoHash>(),
-        1usize,
-        concat!("Size of: ", stringify!(NoHash))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoHash>(),
-        1usize,
-        concat!("Alignment of ", stringify!(NoHash))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AllowlistMe {
-    pub a: NoHash,
-}
-#[test]
-fn bindgen_test_layout_AllowlistMe() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistMe>(),
-        1usize,
-        concat!("Size of: ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistMe>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistMe),
-            "::",
-            stringify!(a)
-        )
-    );
-}
diff --git a/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs b/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
deleted file mode 100644
index 36cdda0e..00000000
--- a/tests/expectations/tests/allowlisted-item-references-no-partialeq.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoPartialEq {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_NoPartialEq() {
-    assert_eq!(
-        ::std::mem::size_of::<NoPartialEq>(),
-        1usize,
-        concat!("Size of: ", stringify!(NoPartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoPartialEq>(),
-        1usize,
-        concat!("Alignment of ", stringify!(NoPartialEq))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AllowlistMe {
-    pub a: NoPartialEq,
-}
-#[test]
-fn bindgen_test_layout_AllowlistMe() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistMe>(),
-        1usize,
-        concat!("Size of: ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistMe>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistMe),
-            "::",
-            stringify!(a)
-        )
-    );
-}
diff --git a/tests/expectations/tests/allowlisted_item_references_no_copy.rs b/tests/expectations/tests/allowlisted_item_references_no_copy.rs
deleted file mode 100644
index 625e0ce6..00000000
--- a/tests/expectations/tests/allowlisted_item_references_no_copy.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct NoCopy {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_NoCopy() {
-    assert_eq!(
-        ::std::mem::size_of::<NoCopy>(),
-        1usize,
-        concat!("Size of: ", stringify!(NoCopy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoCopy>(),
-        1usize,
-        concat!("Alignment of ", stringify!(NoCopy))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct AllowlistMe {
-    pub a: NoCopy,
-}
-#[test]
-fn bindgen_test_layout_AllowlistMe() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistMe> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistMe>(),
-        1usize,
-        concat!("Size of: ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistMe>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AllowlistMe))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistMe),
-            "::",
-            stringify!(a)
-        )
-    );
-}
diff --git a/tests/expectations/tests/annotation_hide.rs b/tests/expectations/tests/annotation_hide.rs
deleted file mode 100644
index a90c4261..00000000
--- a/tests/expectations/tests/annotation_hide.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen opaque></div>
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct D {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_D() {
-    assert_eq!(
-        ::std::mem::size_of::<D>(),
-        4usize,
-        concat!("Size of: ", stringify!(D))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<D>(),
-        4usize,
-        concat!("Alignment of ", stringify!(D))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NotAnnotated {
-    pub f: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NotAnnotated() {
-    const UNINIT: ::std::mem::MaybeUninit<NotAnnotated> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NotAnnotated>(),
-        4usize,
-        concat!("Size of: ", stringify!(NotAnnotated))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NotAnnotated>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NotAnnotated))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NotAnnotated),
-            "::",
-            stringify!(f)
-        )
-    );
-}
diff --git a/tests/expectations/tests/anon-fields-prefix.rs b/tests/expectations/tests/anon-fields-prefix.rs
deleted file mode 100644
index d09cab40..00000000
--- a/tests/expectations/tests/anon-fields-prefix.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union color {
-    pub u1: color__bindgen_ty_1,
-    pub u2: color__bindgen_ty_2,
-    pub v3: [::std::os::raw::c_uchar; 3usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct color__bindgen_ty_1 {
-    pub r: ::std::os::raw::c_uchar,
-    pub g: ::std::os::raw::c_uchar,
-    pub b: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_color__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<color__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<color__bindgen_ty_1>(),
-        3usize,
-        concat!("Size of: ", stringify!(color__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<color__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(color__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_1),
-            "::",
-            stringify!(r)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_1),
-            "::",
-            stringify!(g)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct color__bindgen_ty_2 {
-    pub y: ::std::os::raw::c_uchar,
-    pub u: ::std::os::raw::c_uchar,
-    pub v: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_color__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<color__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<color__bindgen_ty_2>(),
-        3usize,
-        concat!("Size of: ", stringify!(color__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<color__bindgen_ty_2>(),
-        1usize,
-        concat!("Alignment of ", stringify!(color__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_2),
-            "::",
-            stringify!(y)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_2),
-            "::",
-            stringify!(u)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(color__bindgen_ty_2),
-            "::",
-            stringify!(v)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_color() {
-    const UNINIT: ::std::mem::MaybeUninit<color> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<color>(),
-        3usize,
-        concat!("Size of: ", stringify!(color))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<color>(),
-        1usize,
-        concat!("Alignment of ", stringify!(color))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v3) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(color), "::", stringify!(v3))
-    );
-}
-impl Default for color {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/anon_enum.rs b/tests/expectations/tests/anon_enum.rs
deleted file mode 100644
index 429f94ce..00000000
--- a/tests/expectations/tests/anon_enum.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub struct Test {
-    pub foo: ::std::os::raw::c_int,
-    pub bar: f32,
-}
-pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Test__bindgen_ty_1 {
-    T_NONE = 0,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        8usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(bar))
-    );
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Baz {
-    Foo = 0,
-    Bar = 1,
-}
diff --git a/tests/expectations/tests/anon_enum_allowlist.rs b/tests/expectations/tests/anon_enum_allowlist.rs
deleted file mode 100644
index f0c06c56..00000000
--- a/tests/expectations/tests/anon_enum_allowlist.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const NODE_FLAG_FOO: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_FOO;
-pub const NODE_FLAG_BAR: _bindgen_ty_1 = _bindgen_ty_1::NODE_FLAG_BAR;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    NODE_FLAG_FOO = 0,
-    NODE_FLAG_BAR = 1,
-}
diff --git a/tests/expectations/tests/anon_enum_trait.rs b/tests/expectations/tests/anon_enum_trait.rs
deleted file mode 100644
index 9d6b8f57..00000000
--- a/tests/expectations/tests/anon_enum_trait.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct DataType {
-    pub _address: u8,
-}
-pub type DataType_value_type<_Tp> = _Tp;
-pub type DataType_work_type<_Tp> = DataType_value_type<_Tp>;
-pub type DataType_channel_type<_Tp> = DataType_value_type<_Tp>;
-pub type DataType_vec_type<_Tp> = DataType_value_type<_Tp>;
-pub const DataType_generic_type: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_depth: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_channels: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_fmt: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_type_: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum DataType__bindgen_ty_1 {
-    generic_type = 0,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
-pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo__bindgen_ty_1 {
-    Bar = 0,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/anon_struct_in_union.rs b/tests/expectations/tests/anon_struct_in_union.rs
deleted file mode 100644
index f32b057b..00000000
--- a/tests/expectations/tests/anon_struct_in_union.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct s {
-    pub u: s__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union s__bindgen_ty_1 {
-    pub field: s__bindgen_ty_1_inner,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct s__bindgen_ty_1_inner {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_s__bindgen_ty_1_inner() {
-    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1_inner> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s__bindgen_ty_1_inner>(),
-        4usize,
-        concat!("Size of: ", stringify!(s__bindgen_ty_1_inner))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s__bindgen_ty_1_inner>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s__bindgen_ty_1_inner))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(s__bindgen_ty_1_inner),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_s__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(s__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(s__bindgen_ty_1),
-            "::",
-            stringify!(field)
-        )
-    );
-}
-impl Default for s__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_s() {
-    const UNINIT: ::std::mem::MaybeUninit<s> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s>(),
-        4usize,
-        concat!("Size of: ", stringify!(s))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(s), "::", stringify!(u))
-    );
-}
-impl Default for s {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/anon_struct_in_union_1_0.rs b/tests/expectations/tests/anon_struct_in_union_1_0.rs
deleted file mode 100644
index cbc5ac9b..00000000
--- a/tests/expectations/tests/anon_struct_in_union_1_0.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct s {
-    pub u: s__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct s__bindgen_ty_1 {
-    pub field: __BindgenUnionField<s__bindgen_ty_1_inner>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct s__bindgen_ty_1_inner {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_s__bindgen_ty_1_inner() {
-    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1_inner> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s__bindgen_ty_1_inner>(),
-        4usize,
-        concat!("Size of: ", stringify!(s__bindgen_ty_1_inner))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s__bindgen_ty_1_inner>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s__bindgen_ty_1_inner))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(s__bindgen_ty_1_inner),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for s__bindgen_ty_1_inner {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_s__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<s__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(s__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(s__bindgen_ty_1),
-            "::",
-            stringify!(field)
-        )
-    );
-}
-impl Clone for s__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_s() {
-    const UNINIT: ::std::mem::MaybeUninit<s> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<s>(),
-        4usize,
-        concat!("Size of: ", stringify!(s))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<s>(),
-        4usize,
-        concat!("Alignment of ", stringify!(s))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(s), "::", stringify!(u))
-    );
-}
-impl Clone for s {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/anon_union.rs b/tests/expectations/tests/anon_union.rs
deleted file mode 100644
index 8caf7d11..00000000
--- a/tests/expectations/tests/anon_union.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct TErrorResult {
-    pub mResult: ::std::os::raw::c_int,
-    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
-    pub mMightHaveUnreported: bool,
-    pub mUnionState: TErrorResult_UnionState,
-}
-impl TErrorResult_UnionState {
-    pub const HasException: TErrorResult_UnionState =
-        TErrorResult_UnionState::HasMessage;
-}
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum TErrorResult_UnionState {
-    HasMessage = 0,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct TErrorResult_Message {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct TErrorResult_DOMExceptionInfo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-pub union TErrorResult__bindgen_ty_1 {
-    pub mMessage: *mut TErrorResult_Message,
-    pub mDOMExceptionInfo: *mut TErrorResult_DOMExceptionInfo,
-}
-impl Default for TErrorResult__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for TErrorResult {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct ErrorResult {
-    pub _base: TErrorResult,
-}
-#[test]
-fn bindgen_test_layout_ErrorResult() {
-    assert_eq!(
-        ::std::mem::size_of::<ErrorResult>(),
-        24usize,
-        concat!("Size of: ", stringify!(ErrorResult))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ErrorResult>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ErrorResult))
-    );
-}
-impl Default for ErrorResult {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<TErrorResult>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(TErrorResult)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TErrorResult>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(TErrorResult)
-        )
-    );
-}
diff --git a/tests/expectations/tests/anon_union_1_0.rs b/tests/expectations/tests/anon_union_1_0.rs
deleted file mode 100644
index 63273e60..00000000
--- a/tests/expectations/tests/anon_union_1_0.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct TErrorResult {
-    pub mResult: ::std::os::raw::c_int,
-    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
-    pub mMightHaveUnreported: bool,
-    pub mUnionState: TErrorResult_UnionState,
-}
-pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
-    TErrorResult_UnionState::HasMessage;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum TErrorResult_UnionState {
-    HasMessage = 0,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct TErrorResult_Message {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct TErrorResult_DOMExceptionInfo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct TErrorResult__bindgen_ty_1 {
-    pub mMessage: __BindgenUnionField<*mut TErrorResult_Message>,
-    pub mDOMExceptionInfo:
-        __BindgenUnionField<*mut TErrorResult_DOMExceptionInfo>,
-    pub bindgen_union_field: u64,
-}
-impl Default for TErrorResult {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct ErrorResult {
-    pub _base: TErrorResult,
-}
-#[test]
-fn bindgen_test_layout_ErrorResult() {
-    assert_eq!(
-        ::std::mem::size_of::<ErrorResult>(),
-        24usize,
-        concat!("Size of: ", stringify!(ErrorResult))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ErrorResult>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ErrorResult))
-    );
-}
-impl Clone for ErrorResult {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for ErrorResult {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<TErrorResult>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(TErrorResult)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TErrorResult>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(TErrorResult)
-        )
-    );
-}
diff --git a/tests/expectations/tests/anonymous-template-types.rs b/tests/expectations/tests/anonymous-template-types.rs
deleted file mode 100644
index 14afd6b3..00000000
--- a/tests/expectations/tests/anonymous-template-types.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo<T> {
-    pub t_member: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Foo<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Bar {
-    pub member: ::std::os::raw::c_char,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Quux<V> {
-    pub v_member: V,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
-}
-impl<V> Default for Quux<V> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Lobo {
-    pub also_member: ::std::os::raw::c_char,
-}
-pub type AliasWithAnonType = ::std::os::raw::c_char;
diff --git a/tests/expectations/tests/arg_keyword.rs b/tests/expectations/tests/arg_keyword.rs
deleted file mode 100644
index 43ff5831..00000000
--- a/tests/expectations/tests/arg_keyword.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z3fooPKc"]
-    pub fn foo(type_: *const ::std::os::raw::c_char);
-}
diff --git a/tests/expectations/tests/array-of-zero-sized-types.rs b/tests/expectations/tests/array-of-zero-sized-types.rs
deleted file mode 100644
index ad1f22ed..00000000
--- a/tests/expectations/tests/array-of-zero-sized-types.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This should get an `_address` byte.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Empty {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Empty() {
-    assert_eq!(
-        ::std::mem::size_of::<Empty>(),
-        1usize,
-        concat!("Size of: ", stringify!(Empty))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Empty>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Empty))
-    );
-}
-/// This should not get an `_address` byte, since each `Empty` gets one, meaning
-/// that this object is addressable.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct HasArrayOfEmpty {
-    pub empties: [Empty; 10usize],
-}
-#[test]
-fn bindgen_test_layout_HasArrayOfEmpty() {
-    const UNINIT: ::std::mem::MaybeUninit<HasArrayOfEmpty> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<HasArrayOfEmpty>(),
-        10usize,
-        concat!("Size of: ", stringify!(HasArrayOfEmpty))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<HasArrayOfEmpty>(),
-        1usize,
-        concat!("Alignment of ", stringify!(HasArrayOfEmpty))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).empties) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(HasArrayOfEmpty),
-            "::",
-            stringify!(empties)
-        )
-    );
-}
diff --git a/tests/expectations/tests/attribute_warn_unused_result.rs b/tests/expectations/tests/attribute_warn_unused_result.rs
deleted file mode 100644
index 12d5eab0..00000000
--- a/tests/expectations/tests/attribute_warn_unused_result.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[must_use]
-    #[link_name = "\u{1}_ZN3Foo3fooEi"]
-    pub fn Foo_foo(
-        this: *mut Foo,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    #[must_use]
-    pub unsafe fn foo(
-        &mut self,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        Foo_foo(self, arg1)
-    }
-}
-extern "C" {
-    #[must_use]
-    #[link_name = "\u{1}_Z3fooi"]
-    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs b/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
deleted file mode 100644
index d860acd1..00000000
--- a/tests/expectations/tests/attribute_warn_unused_result_no_attribute_detection.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo3fooEi"]
-    pub fn Foo_foo(
-        this: *mut Foo,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn foo(
-        &mut self,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        Foo_foo(self, arg1)
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3fooi"]
-    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs b/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
deleted file mode 100644
index d860acd1..00000000
--- a/tests/expectations/tests/attribute_warn_unused_result_pre_1_27.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo3fooEi"]
-    pub fn Foo_foo(
-        this: *mut Foo,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn foo(
-        &mut self,
-        arg1: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        Foo_foo(self, arg1)
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3fooi"]
-    pub fn foo(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs b/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
deleted file mode 100644
index 4d0d6bcd..00000000
--- a/tests/expectations/tests/bad-namespace-parenthood-inheritance.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct std_char_traits {
-    pub _address: u8,
-}
-impl Default for std_char_traits {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct __gnu_cxx_char_traits {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/base-to-derived.rs b/tests/expectations/tests/base-to-derived.rs
deleted file mode 100644
index 97830cd4..00000000
--- a/tests/expectations/tests/base-to-derived.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct false_type {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_false_type() {
-    assert_eq!(
-        ::std::mem::size_of::<false_type>(),
-        1usize,
-        concat!("Size of: ", stringify!(false_type))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<false_type>(),
-        1usize,
-        concat!("Alignment of ", stringify!(false_type))
-    );
-}
diff --git a/tests/expectations/tests/bindgen-union-inside-namespace.rs b/tests/expectations/tests/bindgen-union-inside-namespace.rs
deleted file mode 100644
index 8a091cb5..00000000
--- a/tests/expectations/tests/bindgen-union-inside-namespace.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[repr(C)]
-    pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-    impl<T> __BindgenUnionField<T> {
-        #[inline]
-        pub fn new() -> Self {
-            __BindgenUnionField(::std::marker::PhantomData)
-        }
-        #[inline]
-        pub unsafe fn as_ref(&self) -> &T {
-            ::std::mem::transmute(self)
-        }
-        #[inline]
-        pub unsafe fn as_mut(&mut self) -> &mut T {
-            ::std::mem::transmute(self)
-        }
-    }
-    impl<T> ::std::default::Default for __BindgenUnionField<T> {
-        #[inline]
-        fn default() -> Self {
-            Self::new()
-        }
-    }
-    impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-        #[inline]
-        fn clone(&self) -> Self {
-            Self::new()
-        }
-    }
-    impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-    impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-        fn fmt(
-            &self,
-            fmt: &mut ::std::fmt::Formatter<'_>,
-        ) -> ::std::fmt::Result {
-            fmt.write_str("__BindgenUnionField")
-        }
-    }
-    impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-        fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-    }
-    impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-        fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-            true
-        }
-    }
-    impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy)]
-        pub struct Bar {
-            pub foo: root::__BindgenUnionField<::std::os::raw::c_int>,
-            pub bar: root::__BindgenUnionField<::std::os::raw::c_int>,
-            pub bindgen_union_field: u32,
-        }
-        #[test]
-        fn bindgen_test_layout_Bar() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar>(),
-                4usize,
-                concat!("Size of: ", stringify!(Bar))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(bar)
-                )
-            );
-        }
-        impl Clone for Bar {
-            fn clone(&self) -> Self {
-                *self
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs
deleted file mode 100644
index 680b25d8..00000000
--- a/tests/expectations/tests/bitfield-32bit-overflow.rs
+++ /dev/null
@@ -1,715 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct MuchBitfield {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize]>,
-}
-#[test]
-fn bindgen_test_layout_MuchBitfield() {
-    assert_eq!(
-        ::std::mem::size_of::<MuchBitfield>(),
-        5usize,
-        concat!("Size of: ", stringify!(MuchBitfield))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MuchBitfield>(),
-        1usize,
-        concat!("Alignment of ", stringify!(MuchBitfield))
-    );
-}
-impl MuchBitfield {
-    #[inline]
-    pub fn m0(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m0(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m1(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m1(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m2(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m2(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m3(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m3(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m4(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m4(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m5(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m5(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m6(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m6(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m7(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m7(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m8(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m8(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m9(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m9(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m10(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m10(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(10usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m11(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m11(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(11usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m12(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m12(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m13(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m13(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(13usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m14(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m14(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(14usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m15(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m15(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(15usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m16(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m16(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m17(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m17(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(17usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m18(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m18(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(18usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m19(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m19(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(19usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m20(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m20(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(20usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m21(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m21(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(21usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m22(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m22(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(22usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m23(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m23(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(23usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m24(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m24(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m25(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m25(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(25usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m26(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m26(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(26usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m27(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m27(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(27usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m28(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m28(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(28usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m29(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m29(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(29usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m30(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m30(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(30usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m31(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m31(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(31usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m32(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_m32(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(32usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        m0: ::std::os::raw::c_char,
-        m1: ::std::os::raw::c_char,
-        m2: ::std::os::raw::c_char,
-        m3: ::std::os::raw::c_char,
-        m4: ::std::os::raw::c_char,
-        m5: ::std::os::raw::c_char,
-        m6: ::std::os::raw::c_char,
-        m7: ::std::os::raw::c_char,
-        m8: ::std::os::raw::c_char,
-        m9: ::std::os::raw::c_char,
-        m10: ::std::os::raw::c_char,
-        m11: ::std::os::raw::c_char,
-        m12: ::std::os::raw::c_char,
-        m13: ::std::os::raw::c_char,
-        m14: ::std::os::raw::c_char,
-        m15: ::std::os::raw::c_char,
-        m16: ::std::os::raw::c_char,
-        m17: ::std::os::raw::c_char,
-        m18: ::std::os::raw::c_char,
-        m19: ::std::os::raw::c_char,
-        m20: ::std::os::raw::c_char,
-        m21: ::std::os::raw::c_char,
-        m22: ::std::os::raw::c_char,
-        m23: ::std::os::raw::c_char,
-        m24: ::std::os::raw::c_char,
-        m25: ::std::os::raw::c_char,
-        m26: ::std::os::raw::c_char,
-        m27: ::std::os::raw::c_char,
-        m28: ::std::os::raw::c_char,
-        m29: ::std::os::raw::c_char,
-        m30: ::std::os::raw::c_char,
-        m31: ::std::os::raw::c_char,
-        m32: ::std::os::raw::c_char,
-    ) -> __BindgenBitfieldUnit<[u8; 5usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let m0: u8 = unsafe { ::std::mem::transmute(m0) };
-            m0 as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let m1: u8 = unsafe { ::std::mem::transmute(m1) };
-            m1 as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let m2: u8 = unsafe { ::std::mem::transmute(m2) };
-            m2 as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let m3: u8 = unsafe { ::std::mem::transmute(m3) };
-            m3 as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let m4: u8 = unsafe { ::std::mem::transmute(m4) };
-            m4 as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let m5: u8 = unsafe { ::std::mem::transmute(m5) };
-            m5 as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let m6: u8 = unsafe { ::std::mem::transmute(m6) };
-            m6 as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let m7: u8 = unsafe { ::std::mem::transmute(m7) };
-            m7 as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let m8: u8 = unsafe { ::std::mem::transmute(m8) };
-            m8 as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 1u8, {
-            let m9: u8 = unsafe { ::std::mem::transmute(m9) };
-            m9 as u64
-        });
-        __bindgen_bitfield_unit.set(10usize, 1u8, {
-            let m10: u8 = unsafe { ::std::mem::transmute(m10) };
-            m10 as u64
-        });
-        __bindgen_bitfield_unit.set(11usize, 1u8, {
-            let m11: u8 = unsafe { ::std::mem::transmute(m11) };
-            m11 as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 1u8, {
-            let m12: u8 = unsafe { ::std::mem::transmute(m12) };
-            m12 as u64
-        });
-        __bindgen_bitfield_unit.set(13usize, 1u8, {
-            let m13: u8 = unsafe { ::std::mem::transmute(m13) };
-            m13 as u64
-        });
-        __bindgen_bitfield_unit.set(14usize, 1u8, {
-            let m14: u8 = unsafe { ::std::mem::transmute(m14) };
-            m14 as u64
-        });
-        __bindgen_bitfield_unit.set(15usize, 1u8, {
-            let m15: u8 = unsafe { ::std::mem::transmute(m15) };
-            m15 as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 1u8, {
-            let m16: u8 = unsafe { ::std::mem::transmute(m16) };
-            m16 as u64
-        });
-        __bindgen_bitfield_unit.set(17usize, 1u8, {
-            let m17: u8 = unsafe { ::std::mem::transmute(m17) };
-            m17 as u64
-        });
-        __bindgen_bitfield_unit.set(18usize, 1u8, {
-            let m18: u8 = unsafe { ::std::mem::transmute(m18) };
-            m18 as u64
-        });
-        __bindgen_bitfield_unit.set(19usize, 1u8, {
-            let m19: u8 = unsafe { ::std::mem::transmute(m19) };
-            m19 as u64
-        });
-        __bindgen_bitfield_unit.set(20usize, 1u8, {
-            let m20: u8 = unsafe { ::std::mem::transmute(m20) };
-            m20 as u64
-        });
-        __bindgen_bitfield_unit.set(21usize, 1u8, {
-            let m21: u8 = unsafe { ::std::mem::transmute(m21) };
-            m21 as u64
-        });
-        __bindgen_bitfield_unit.set(22usize, 1u8, {
-            let m22: u8 = unsafe { ::std::mem::transmute(m22) };
-            m22 as u64
-        });
-        __bindgen_bitfield_unit.set(23usize, 1u8, {
-            let m23: u8 = unsafe { ::std::mem::transmute(m23) };
-            m23 as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 1u8, {
-            let m24: u8 = unsafe { ::std::mem::transmute(m24) };
-            m24 as u64
-        });
-        __bindgen_bitfield_unit.set(25usize, 1u8, {
-            let m25: u8 = unsafe { ::std::mem::transmute(m25) };
-            m25 as u64
-        });
-        __bindgen_bitfield_unit.set(26usize, 1u8, {
-            let m26: u8 = unsafe { ::std::mem::transmute(m26) };
-            m26 as u64
-        });
-        __bindgen_bitfield_unit.set(27usize, 1u8, {
-            let m27: u8 = unsafe { ::std::mem::transmute(m27) };
-            m27 as u64
-        });
-        __bindgen_bitfield_unit.set(28usize, 1u8, {
-            let m28: u8 = unsafe { ::std::mem::transmute(m28) };
-            m28 as u64
-        });
-        __bindgen_bitfield_unit.set(29usize, 1u8, {
-            let m29: u8 = unsafe { ::std::mem::transmute(m29) };
-            m29 as u64
-        });
-        __bindgen_bitfield_unit.set(30usize, 1u8, {
-            let m30: u8 = unsafe { ::std::mem::transmute(m30) };
-            m30 as u64
-        });
-        __bindgen_bitfield_unit.set(31usize, 1u8, {
-            let m31: u8 = unsafe { ::std::mem::transmute(m31) };
-            m31 as u64
-        });
-        __bindgen_bitfield_unit.set(32usize, 1u8, {
-            let m32: u8 = unsafe { ::std::mem::transmute(m32) };
-            m32 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield-enum-basic.rs b/tests/expectations/tests/bitfield-enum-basic.rs
deleted file mode 100644
index b6c25870..00000000
--- a/tests/expectations/tests/bitfield-enum-basic.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl Foo {
-    pub const Bar: Foo = Foo(2);
-}
-impl Foo {
-    pub const Baz: Foo = Foo(4);
-}
-impl Foo {
-    pub const Duplicated: Foo = Foo(4);
-}
-impl Foo {
-    pub const Negative: Foo = Foo(-3);
-}
-impl ::std::ops::BitOr<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Foo(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Foo {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Foo) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Foo(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Foo {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Foo) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_int);
-impl Buz {
-    pub const Bar: Buz = Buz(2);
-}
-impl Buz {
-    pub const Baz: Buz = Buz(4);
-}
-impl Buz {
-    pub const Duplicated: Buz = Buz(4);
-}
-impl Buz {
-    pub const Negative: Buz = Buz(-3);
-}
-impl ::std::ops::BitOr<Buz> for Buz {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Buz(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Buz {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Buz) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Buz> for Buz {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Buz(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Buz {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Buz) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Buz(pub ::std::os::raw::c_schar);
-pub const NS_FOO: _bindgen_ty_1 = _bindgen_ty_1(1);
-pub const NS_BAR: _bindgen_ty_1 = _bindgen_ty_1(2);
-impl ::std::ops::BitOr<_bindgen_ty_1> for _bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        _bindgen_ty_1(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for _bindgen_ty_1 {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: _bindgen_ty_1) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<_bindgen_ty_1> for _bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        _bindgen_ty_1(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for _bindgen_ty_1 {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: _bindgen_ty_1) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Dummy {
-    pub _address: u8,
-}
-pub const Dummy_DUMMY_FOO: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(1);
-pub const Dummy_DUMMY_BAR: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(2);
-impl ::std::ops::BitOr<Dummy__bindgen_ty_1> for Dummy__bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Dummy__bindgen_ty_1(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Dummy__bindgen_ty_1 {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Dummy__bindgen_ty_1) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Dummy__bindgen_ty_1> for Dummy__bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Dummy__bindgen_ty_1(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Dummy__bindgen_ty_1 {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Dummy__bindgen_ty_1) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Dummy__bindgen_ty_1(pub ::std::os::raw::c_uint);
-#[test]
-fn bindgen_test_layout_Dummy() {
-    assert_eq!(
-        ::std::mem::size_of::<Dummy>(),
-        1usize,
-        concat!("Size of: ", stringify!(Dummy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Dummy>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Dummy))
-    );
-}
diff --git a/tests/expectations/tests/bitfield-enum-repr-c.rs b/tests/expectations/tests/bitfield-enum-repr-c.rs
deleted file mode 100644
index 1f0228e8..00000000
--- a/tests/expectations/tests/bitfield-enum-repr-c.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl Foo {
-    pub const Bar: Foo = Foo(2);
-}
-impl Foo {
-    pub const Baz: Foo = Foo(4);
-}
-impl Foo {
-    pub const Duplicated: Foo = Foo(4);
-}
-impl Foo {
-    pub const Negative: Foo = Foo(-3);
-}
-impl ::std::ops::BitOr<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Foo(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Foo {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Foo) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Foo(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Foo {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Foo) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/tests/expectations/tests/bitfield-enum-repr-transparent.rs b/tests/expectations/tests/bitfield-enum-repr-transparent.rs
deleted file mode 100644
index 53e113ed..00000000
--- a/tests/expectations/tests/bitfield-enum-repr-transparent.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl Foo {
-    pub const Bar: Foo = Foo(2);
-}
-impl Foo {
-    pub const Baz: Foo = Foo(4);
-}
-impl Foo {
-    pub const Duplicated: Foo = Foo(4);
-}
-impl Foo {
-    pub const Negative: Foo = Foo(-3);
-}
-impl ::std::ops::BitOr<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Foo(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Foo {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Foo) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Foo(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Foo {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Foo) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/tests/expectations/tests/bitfield-large.rs b/tests/expectations/tests/bitfield-large.rs
deleted file mode 100644
index b2c353a2..00000000
--- a/tests/expectations/tests/bitfield-large.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct HasBigBitfield {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
-}
-#[test]
-fn bindgen_test_layout_HasBigBitfield() {
-    assert_eq!(
-        ::std::mem::size_of::<HasBigBitfield>(),
-        16usize,
-        concat!("Size of: ", stringify!(HasBigBitfield))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<HasBigBitfield>(),
-        16usize,
-        concat!("Alignment of ", stringify!(HasBigBitfield))
-    );
-}
-impl HasBigBitfield {
-    #[inline]
-    pub fn x(&self) -> i128 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 128u8) as u128)
-        }
-    }
-    #[inline]
-    pub fn set_x(&mut self, val: i128) {
-        unsafe {
-            let val: u128 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 128u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(x: i128) -> __BindgenBitfieldUnit<[u8; 16usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 128u8, {
-            let x: u128 = unsafe { ::std::mem::transmute(x) };
-            x as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct HasTwoBigBitfields {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
-}
-#[test]
-fn bindgen_test_layout_HasTwoBigBitfields() {
-    assert_eq!(
-        ::std::mem::size_of::<HasTwoBigBitfields>(),
-        16usize,
-        concat!("Size of: ", stringify!(HasTwoBigBitfields))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<HasTwoBigBitfields>(),
-        16usize,
-        concat!("Alignment of ", stringify!(HasTwoBigBitfields))
-    );
-}
-impl HasTwoBigBitfields {
-    #[inline]
-    pub fn x(&self) -> i128 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 80u8) as u128)
-        }
-    }
-    #[inline]
-    pub fn set_x(&mut self, val: i128) {
-        unsafe {
-            let val: u128 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 80u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn y(&self) -> i128 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(80usize, 48u8) as u128)
-        }
-    }
-    #[inline]
-    pub fn set_y(&mut self, val: i128) {
-        unsafe {
-            let val: u128 = ::std::mem::transmute(val);
-            self._bitfield_1.set(80usize, 48u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        x: i128,
-        y: i128,
-    ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 80u8, {
-            let x: u128 = unsafe { ::std::mem::transmute(x) };
-            x as u64
-        });
-        __bindgen_bitfield_unit.set(80usize, 48u8, {
-            let y: u128 = unsafe { ::std::mem::transmute(y) };
-            y as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield-linux-32.rs b/tests/expectations/tests/bitfield-linux-32.rs
deleted file mode 100644
index 44c68626..00000000
--- a/tests/expectations/tests/bitfield-linux-32.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test {
-    pub foo: u64,
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        16usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(foo))
-    );
-}
-impl Test {
-    #[inline]
-    pub fn x(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 56u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_x(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 56u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn y(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_y(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(56usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        x: u64,
-        y: u64,
-    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 56u8, {
-            let x: u64 = unsafe { ::std::mem::transmute(x) };
-            x as u64
-        });
-        __bindgen_bitfield_unit.set(56usize, 8u8, {
-            let y: u64 = unsafe { ::std::mem::transmute(y) };
-            y as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs
deleted file mode 100644
index e9c1a76d..00000000
--- a/tests/expectations/tests/bitfield-method-same-name.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo4typeEv"]
-    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo9set_type_Ec"]
-    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo8set_typeEc"]
-    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
-}
-impl Foo {
-    #[inline]
-    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        type__bindgen_bitfield: ::std::os::raw::c_char,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let type__bindgen_bitfield: u8 =
-                unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
-            type__bindgen_bitfield as u64
-        });
-        __bindgen_bitfield_unit
-    }
-    #[inline]
-    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
-        Foo_type(self)
-    }
-    #[inline]
-    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) {
-        Foo_set_type_(self, c)
-    }
-    #[inline]
-    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) {
-        Foo_set_type(self, c)
-    }
-}
diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs
deleted file mode 100644
index 4baca112..00000000
--- a/tests/expectations/tests/bitfield_align.rs
+++ /dev/null
@@ -1,797 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub x: ::std::os::raw::c_uchar,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-    pub y: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        4usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(x))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        3usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(y))
-    );
-}
-impl A {
-    #[inline]
-    pub fn b1(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b2(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b3(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b4(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b5(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b6(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b7(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b8(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b9(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b10(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        b1: ::std::os::raw::c_uint,
-        b2: ::std::os::raw::c_uint,
-        b3: ::std::os::raw::c_uint,
-        b4: ::std::os::raw::c_uint,
-        b5: ::std::os::raw::c_uint,
-        b6: ::std::os::raw::c_uint,
-        b7: ::std::os::raw::c_uint,
-        b8: ::std::os::raw::c_uint,
-        b9: ::std::os::raw::c_uint,
-        b10: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let b1: u32 = unsafe { ::std::mem::transmute(b1) };
-            b1 as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let b2: u32 = unsafe { ::std::mem::transmute(b2) };
-            b2 as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let b3: u32 = unsafe { ::std::mem::transmute(b3) };
-            b3 as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let b4: u32 = unsafe { ::std::mem::transmute(b4) };
-            b4 as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let b5: u32 = unsafe { ::std::mem::transmute(b5) };
-            b5 as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let b6: u32 = unsafe { ::std::mem::transmute(b6) };
-            b6 as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let b7: u32 = unsafe { ::std::mem::transmute(b7) };
-            b7 as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let b8: u32 = unsafe { ::std::mem::transmute(b8) };
-            b8 as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let b9: u32 = unsafe { ::std::mem::transmute(b9) };
-            b9 as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 1u8, {
-            let b10: u32 = unsafe { ::std::mem::transmute(b10) };
-            b10 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct B {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-}
-impl B {
-    #[inline]
-    pub fn foo(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 31u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bar(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(31usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        foo: ::std::os::raw::c_uint,
-        bar: ::std::os::raw::c_uchar,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 31u8, {
-            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
-            foo as u64
-        });
-        __bindgen_bitfield_unit.set(31usize, 1u8, {
-            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
-            bar as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub x: ::std::os::raw::c_uchar,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub baz: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        8usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(x))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(baz))
-    );
-}
-impl C {
-    #[inline]
-    pub fn b1(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b2(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        b1: ::std::os::raw::c_uint,
-        b2: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let b1: u32 = unsafe { ::std::mem::transmute(b1) };
-            b1 as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let b2: u32 = unsafe { ::std::mem::transmute(b2) };
-            b2 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Date1 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-    pub __bindgen_padding_0: u8,
-}
-#[test]
-fn bindgen_test_layout_Date1() {
-    assert_eq!(
-        ::std::mem::size_of::<Date1>(),
-        4usize,
-        concat!("Size of: ", stringify!(Date1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Date1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(Date1))
-    );
-}
-impl Date1 {
-    #[inline]
-    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 6u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 5u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        nWeekDay: ::std::os::raw::c_ushort,
-        nMonthDay: ::std::os::raw::c_ushort,
-        nMonth: ::std::os::raw::c_ushort,
-        nYear: ::std::os::raw::c_ushort,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
-            nWeekDay as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 6u8, {
-            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
-            nMonthDay as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 5u8, {
-            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
-            nMonth as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 8u8, {
-            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
-            nYear as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Date2 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_Date2() {
-    assert_eq!(
-        ::std::mem::size_of::<Date2>(),
-        4usize,
-        concat!("Size of: ", stringify!(Date2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Date2>(),
-        2usize,
-        concat!("Alignment of ", stringify!(Date2))
-    );
-}
-impl Date2 {
-    #[inline]
-    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 6u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 5u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn byte(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        nWeekDay: ::std::os::raw::c_ushort,
-        nMonthDay: ::std::os::raw::c_ushort,
-        nMonth: ::std::os::raw::c_ushort,
-        nYear: ::std::os::raw::c_ushort,
-        byte: ::std::os::raw::c_uchar,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
-            nWeekDay as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 6u8, {
-            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
-            nMonthDay as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 5u8, {
-            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
-            nMonth as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 8u8, {
-            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
-            nYear as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 8u8, {
-            let byte: u8 = unsafe { ::std::mem::transmute(byte) };
-            byte as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Date3 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-    pub byte: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_Date3() {
-    const UNINIT: ::std::mem::MaybeUninit<Date3> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Date3>(),
-        4usize,
-        concat!("Size of: ", stringify!(Date3))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Date3>(),
-        2usize,
-        concat!("Alignment of ", stringify!(Date3))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).byte) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Date3),
-            "::",
-            stringify!(byte)
-        )
-    );
-}
-impl Date3 {
-    #[inline]
-    pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 6u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 5u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn nYear(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        nWeekDay: ::std::os::raw::c_ushort,
-        nMonthDay: ::std::os::raw::c_ushort,
-        nMonth: ::std::os::raw::c_ushort,
-        nYear: ::std::os::raw::c_ushort,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
-            nWeekDay as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 6u8, {
-            let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
-            nMonthDay as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 5u8, {
-            let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
-            nMonth as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 8u8, {
-            let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
-            nYear as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs
deleted file mode 100644
index aa11f80c..00000000
--- a/tests/expectations/tests/bitfield_align_2.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(target_os = "windows"))]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MyEnum {
-    ONE = 0,
-    TWO = 1,
-    THREE = 2,
-    FOUR = 3,
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Copy, Clone)]
-pub struct TaggedPtr {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
-}
-#[test]
-fn bindgen_test_layout_TaggedPtr() {
-    assert_eq!(
-        ::std::mem::size_of::<TaggedPtr>(),
-        8usize,
-        concat!("Size of: ", stringify!(TaggedPtr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TaggedPtr>(),
-        8usize,
-        concat!("Alignment of ", stringify!(TaggedPtr))
-    );
-}
-impl Default for TaggedPtr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl TaggedPtr {
-    #[inline]
-    pub fn tag(&self) -> MyEnum {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tag(&mut self, val: MyEnum) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn ptr(&self) -> ::std::os::raw::c_long {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 62u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        tag: MyEnum,
-        ptr: ::std::os::raw::c_long,
-    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 2u8, {
-            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
-            tag as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 62u8, {
-            let ptr: u64 = unsafe { ::std::mem::transmute(ptr) };
-            ptr as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield_large_overflow.rs b/tests/expectations/tests/bitfield_large_overflow.rs
deleted file mode 100644
index 4ee1f598..00000000
--- a/tests/expectations/tests/bitfield_large_overflow.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct _bindgen_ty_1 {
-    pub _bindgen_opaque_blob: [u64; 10usize],
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<_bindgen_ty_1>(),
-        80usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-}
-extern "C" {
-    pub static mut a: _bindgen_ty_1;
-}
diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs
deleted file mode 100644
index 42fa3c4c..00000000
--- a/tests/expectations/tests/bitfield_method_mangling.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct mach_msg_type_descriptor_t {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_mach_msg_type_descriptor_t() {
-    assert_eq!(
-        ::std::mem::size_of::<mach_msg_type_descriptor_t>(),
-        4usize,
-        concat!("Size of: ", stringify!(mach_msg_type_descriptor_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mach_msg_type_descriptor_t>(),
-        4usize,
-        concat!("Alignment of ", stringify!(mach_msg_type_descriptor_t))
-    );
-}
-impl mach_msg_type_descriptor_t {
-    #[inline]
-    pub fn pad3(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 24u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn type_(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_type(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        pad3: ::std::os::raw::c_uint,
-        type_: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 24u8, {
-            let pad3: u32 = unsafe { ::std::mem::transmute(pad3) };
-            pad3 as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 8u8, {
-            let type_: u32 = unsafe { ::std::mem::transmute(type_) };
-            type_ as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/bitfield_pragma_packed.rs b/tests/expectations/tests/bitfield_pragma_packed.rs
deleted file mode 100644
index 27cd90f1..00000000
--- a/tests/expectations/tests/bitfield_pragma_packed.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Struct {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_Struct() {
-    assert_eq!(
-        ::std::mem::size_of::<Struct>(),
-        4usize,
-        concat!("Size of: ", stringify!(Struct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Struct>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Struct))
-    );
-}
-impl Struct {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 6u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn d(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 16u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 16u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn e(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_e(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: ::std::os::raw::c_uchar,
-        b: ::std::os::raw::c_uchar,
-        c: ::std::os::raw::c_uchar,
-        d: ::std::os::raw::c_ushort,
-        e: ::std::os::raw::c_uchar,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let b: u8 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 6u8, {
-            let c: u8 = unsafe { ::std::mem::transmute(c) };
-            c as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 16u8, {
-            let d: u16 = unsafe { ::std::mem::transmute(d) };
-            d as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 8u8, {
-            let e: u8 = unsafe { ::std::mem::transmute(e) };
-            e as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/block_return_type.rs b/tests/expectations/tests/block_return_type.rs
deleted file mode 100644
index bc434733..00000000
--- a/tests/expectations/tests/block_return_type.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-extern crate block;
-extern "C" {
-    pub fn func() -> _bindgen_ty_id_4;
-}
-pub type _bindgen_ty_id_4 = *const ::block::Block<
-    (::std::os::raw::c_int, ::std::os::raw::c_int),
-    ::std::os::raw::c_int,
->;
diff --git a/tests/expectations/tests/blocklist-and-impl-debug.rs b/tests/expectations/tests/blocklist-and-impl-debug.rs
deleted file mode 100644
index 788cb30c..00000000
--- a/tests/expectations/tests/blocklist-and-impl-debug.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub struct BlocklistMe(u8);
-
-/// Because this type contains a blocklisted type, it should not derive Debug.
-#[repr(C)]
-pub struct ShouldManuallyImplDebug {
-    pub a: BlocklistMe,
-}
-#[test]
-fn bindgen_test_layout_ShouldManuallyImplDebug() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldManuallyImplDebug> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldManuallyImplDebug>(),
-        1usize,
-        concat!("Size of: ", stringify!(ShouldManuallyImplDebug))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldManuallyImplDebug>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ShouldManuallyImplDebug))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldManuallyImplDebug),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for ShouldManuallyImplDebug {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for ShouldManuallyImplDebug {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "ShouldManuallyImplDebug {{  }}")
-    }
-}
diff --git a/tests/expectations/tests/blocklist-file.rs b/tests/expectations/tests/blocklist-file.rs
deleted file mode 100644
index 4d2b6712..00000000
--- a/tests/expectations/tests/blocklist-file.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct SizedIntegers {
-    pub x: u8,
-    pub y: u16,
-    pub z: u32,
-}
-#[test]
-fn bindgen_test_layout_SizedIntegers() {
-    const UNINIT: ::std::mem::MaybeUninit<SizedIntegers> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<SizedIntegers>(),
-        8usize,
-        concat!("Size of: ", stringify!(SizedIntegers))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<SizedIntegers>(),
-        4usize,
-        concat!("Alignment of ", stringify!(SizedIntegers))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SizedIntegers),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SizedIntegers),
-            "::",
-            stringify!(y)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(SizedIntegers),
-            "::",
-            stringify!(z)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct StructWithBlocklistedFwdDecl {
-    pub b: u8,
-}
-#[test]
-fn bindgen_test_layout_StructWithBlocklistedFwdDecl() {
-    const UNINIT: ::std::mem::MaybeUninit<StructWithBlocklistedFwdDecl> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<StructWithBlocklistedFwdDecl>(),
-        1usize,
-        concat!("Size of: ", stringify!(StructWithBlocklistedFwdDecl))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StructWithBlocklistedFwdDecl>(),
-        1usize,
-        concat!("Alignment of ", stringify!(StructWithBlocklistedFwdDecl))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StructWithBlocklistedFwdDecl),
-            "::",
-            stringify!(b)
-        )
-    );
-}
diff --git a/tests/expectations/tests/blocklist-function.rs b/tests/expectations/tests/blocklist-function.rs
deleted file mode 100644
index 5299b151..00000000
--- a/tests/expectations/tests/blocklist-function.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-    }
-    pub mod bar {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        extern "C" {
-            #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"]
-            pub fn NamespacedFunction();
-        }
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct C {
-        pub _address: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_C() {
-        assert_eq!(
-            ::std::mem::size_of::<C>(),
-            1usize,
-            concat!("Size of: ", stringify!(C))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<C>(),
-            1usize,
-            concat!("Alignment of ", stringify!(C))
-        );
-    }
-}
diff --git a/tests/expectations/tests/blocklist-item.rs b/tests/expectations/tests/blocklist-item.rs
deleted file mode 100644
index 0edee9ec..00000000
--- a/tests/expectations/tests/blocklist-item.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-    }
-    pub mod bar {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        extern "C" {
-            #[link_name = "\u{1}_ZN3bar18NamespacedFunctionEv"]
-            pub fn NamespacedFunction();
-        }
-    }
-}
diff --git a/tests/expectations/tests/blocks-signature.rs b/tests/expectations/tests/blocks-signature.rs
deleted file mode 100644
index ff7114a7..00000000
--- a/tests/expectations/tests/blocks-signature.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-extern crate block;
-extern "C" {
-    #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
-    pub fn atexit_b(arg1: _bindgen_ty_id_33);
-}
-pub type dispatch_data_t = *mut ::std::os::raw::c_void;
-pub type dispatch_data_applier_t = _bindgen_ty_id_40;
-extern "C" {
-    #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"]
-    pub fn dispatch_data_apply(
-        data: dispatch_data_t,
-        applier: dispatch_data_applier_t,
-    ) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"]
-    pub fn foo(arg1: _bindgen_ty_id_50) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"]
-    pub fn foo_ptr(arg1: *mut _bindgen_ty_id_56) -> bool;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct contains_block_pointers {
-    pub val: contains_block_pointers__bindgen_ty_id_61,
-    pub ptr_val: *mut _bindgen_ty_id_68,
-}
-#[test]
-fn bindgen_test_layout_contains_block_pointers() {
-    const UNINIT: ::std::mem::MaybeUninit<contains_block_pointers> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<contains_block_pointers>(),
-        16usize,
-        concat!("Size of: ", stringify!(contains_block_pointers))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<contains_block_pointers>(),
-        8usize,
-        concat!("Alignment of ", stringify!(contains_block_pointers))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(contains_block_pointers),
-            "::",
-            stringify!(val)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr_val) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(contains_block_pointers),
-            "::",
-            stringify!(ptr_val)
-        )
-    );
-}
-impl Default for contains_block_pointers {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type _bindgen_ty_id_33 = *const ::block::Block<(), ()>;
-pub type _bindgen_ty_id_40 = *const ::block::Block<
-    (dispatch_data_t, usize, *const ::std::os::raw::c_void, usize),
-    bool,
->;
-pub type _bindgen_ty_id_50 = *const ::block::Block<(usize,), ()>;
-pub type _bindgen_ty_id_56 = *const ::block::Block<(usize,), ()>;
-pub type contains_block_pointers__bindgen_ty_id_61 =
-    *const ::block::Block<(::std::os::raw::c_int,), ()>;
-pub type _bindgen_ty_id_68 =
-    *const ::block::Block<(::std::os::raw::c_int,), ()>;
diff --git a/tests/expectations/tests/blocks.rs b/tests/expectations/tests/blocks.rs
deleted file mode 100644
index 6f242989..00000000
--- a/tests/expectations/tests/blocks.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-extern "C" {
-    #[link_name = "\u{1}_Z8atexit_bU13block_pointerFvvE"]
-    pub fn atexit_b(arg1: *mut ::std::os::raw::c_void);
-}
-pub type dispatch_data_t = *mut ::std::os::raw::c_void;
-pub type dispatch_data_applier_t = *mut ::std::os::raw::c_void;
-extern "C" {
-    #[link_name = "\u{1}_Z19dispatch_data_applyPvU13block_pointerFbS_yPKvyE"]
-    pub fn dispatch_data_apply(
-        data: dispatch_data_t,
-        applier: dispatch_data_applier_t,
-    ) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3fooU13block_pointerFvyE"]
-    pub fn foo(arg1: *mut ::std::os::raw::c_void) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z7foo_ptrPU13block_pointerFvyE"]
-    pub fn foo_ptr(arg1: *mut *mut ::std::os::raw::c_void) -> bool;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct contains_block_pointers {
-    pub val: *mut ::std::os::raw::c_void,
-    pub ptr_val: *mut *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout_contains_block_pointers() {
-    const UNINIT: ::std::mem::MaybeUninit<contains_block_pointers> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<contains_block_pointers>(),
-        16usize,
-        concat!("Size of: ", stringify!(contains_block_pointers))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<contains_block_pointers>(),
-        8usize,
-        concat!("Alignment of ", stringify!(contains_block_pointers))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(contains_block_pointers),
-            "::",
-            stringify!(val)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr_val) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(contains_block_pointers),
-            "::",
-            stringify!(ptr_val)
-        )
-    );
-}
-impl Default for contains_block_pointers {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/bug-1529681.rs b/tests/expectations/tests/bug-1529681.rs
deleted file mode 100644
index 6a0f5e13..00000000
--- a/tests/expectations/tests/bug-1529681.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct BrowsingContext {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_BrowsingContext() {
-    assert_eq!(
-        ::std::mem::size_of::<BrowsingContext>(),
-        1usize,
-        concat!("Size of: ", stringify!(BrowsingContext))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BrowsingContext>(),
-        1usize,
-        concat!("Alignment of ", stringify!(BrowsingContext))
-    );
-}
diff --git a/tests/expectations/tests/builtin-template.rs b/tests/expectations/tests/builtin-template.rs
deleted file mode 100644
index 112b7670..00000000
--- a/tests/expectations/tests/builtin-template.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type std_make_integer_sequence = u8;
diff --git a/tests/expectations/tests/c-empty-layout.rs b/tests/expectations/tests/c-empty-layout.rs
deleted file mode 100644
index ebef2b6d..00000000
--- a/tests/expectations/tests/c-empty-layout.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        0usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/c_naming.rs b/tests/expectations/tests/c_naming.rs
deleted file mode 100644
index 3e56b1d6..00000000
--- a/tests/expectations/tests/c_naming.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct struct_a {
-    pub a: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_struct_a() {
-    const UNINIT: ::std::mem::MaybeUninit<struct_a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<struct_a>(),
-        4usize,
-        concat!("Size of: ", stringify!(struct_a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<struct_a>(),
-        4usize,
-        concat!("Alignment of ", stringify!(struct_a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(struct_a),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-pub type a = *const struct_a;
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union union_b {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_union_b() {
-    const UNINIT: ::std::mem::MaybeUninit<union_b> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<union_b>(),
-        4usize,
-        concat!("Size of: ", stringify!(union_b))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<union_b>(),
-        4usize,
-        concat!("Alignment of ", stringify!(union_b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(union_b),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(union_b),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for union_b {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type b = union_b;
-pub const enum_c_A: enum_c = 0;
-pub type enum_c = ::std::os::raw::c_uint;
-extern "C" {
-    pub fn takes_a(arg: a);
-}
-extern "C" {
-    pub fn takes_b(arg: b);
-}
-extern "C" {
-    pub fn takes_c(arg: enum_c);
-}
diff --git a/tests/expectations/tests/call-conv-typedef.rs b/tests/expectations/tests/call-conv-typedef.rs
deleted file mode 100644
index 6eabb1f6..00000000
--- a/tests/expectations/tests/call-conv-typedef.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(test))]
-
-pub type void_fn = ::std::option::Option<unsafe extern "stdcall" fn()>;
-pub type fn_ = ::std::option::Option<
-    unsafe extern "stdcall" fn(id: ::std::os::raw::c_int) -> void_fn,
->;
diff --git a/tests/expectations/tests/canonical-types.rs b/tests/expectations/tests/canonical-types.rs
deleted file mode 100644
index a68e1424..00000000
--- a/tests/expectations/tests/canonical-types.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ClassA {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassA_ClassAInner<T> {
-    pub x: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ClassA_ClassAInner<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ClassB {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ClassC {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassC_ClassCInnerB {
-    pub cache: *mut ClassC_ClassCInnerA,
-}
-impl Default for ClassC_ClassCInnerB {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassC_ClassCInnerA {
-    pub member: *mut ClassC_ClassCInnerB,
-}
-impl Default for ClassC_ClassCInnerA {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassC_ClassCInnerCRTP {
-    pub _address: u8,
-}
-impl Default for ClassC_ClassCInnerCRTP {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassD {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_ClassD() {
-    assert_eq!(
-        ::std::mem::size_of::<ClassD>(),
-        1usize,
-        concat!("Size of: ", stringify!(ClassD))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassD>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ClassD))
-    );
-}
-impl Default for ClassD {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_ClassB_open0_ClassD_ClassCInnerCRTP_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<ClassB>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(ClassB))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassB>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(ClassB))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassCInnerCRTP {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_ClassCInnerCRTP() {
-    assert_eq!(
-        ::std::mem::size_of::<ClassCInnerCRTP>(),
-        1usize,
-        concat!("Size of: ", stringify!(ClassCInnerCRTP))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassCInnerCRTP>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ClassCInnerCRTP))
-    );
-}
-impl Default for ClassCInnerCRTP {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_ClassB_open0_ClassCInnerCRTP_ClassAInner_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<ClassB>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(ClassB))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassB>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(ClassB))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassAInner {
-    pub x: *mut ClassCInnerA,
-}
-#[test]
-fn bindgen_test_layout_ClassAInner() {
-    const UNINIT: ::std::mem::MaybeUninit<ClassAInner> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ClassAInner>(),
-        8usize,
-        concat!("Size of: ", stringify!(ClassAInner))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassAInner>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ClassAInner))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ClassAInner),
-            "::",
-            stringify!(x)
-        )
-    );
-}
-impl Default for ClassAInner {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassCInnerA {
-    pub member: *mut ClassCInnerB,
-}
-#[test]
-fn bindgen_test_layout_ClassCInnerA() {
-    const UNINIT: ::std::mem::MaybeUninit<ClassCInnerA> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ClassCInnerA>(),
-        8usize,
-        concat!("Size of: ", stringify!(ClassCInnerA))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassCInnerA>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ClassCInnerA))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ClassCInnerA),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for ClassCInnerA {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ClassCInnerB {
-    pub cache: *mut ClassCInnerA,
-}
-#[test]
-fn bindgen_test_layout_ClassCInnerB() {
-    const UNINIT: ::std::mem::MaybeUninit<ClassCInnerB> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ClassCInnerB>(),
-        8usize,
-        concat!("Size of: ", stringify!(ClassCInnerB))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ClassCInnerB>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ClassCInnerB))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cache) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ClassCInnerB),
-            "::",
-            stringify!(cache)
-        )
-    );
-}
-impl Default for ClassCInnerB {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/canonical_path_without_namespacing.rs b/tests/expectations/tests/canonical_path_without_namespacing.rs
deleted file mode 100644
index 12f10a88..00000000
--- a/tests/expectations/tests/canonical_path_without_namespacing.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3bazPN3foo3BarE"]
-    pub fn baz(arg1: *mut Bar);
-}
diff --git a/tests/expectations/tests/char.rs b/tests/expectations/tests/char.rs
deleted file mode 100644
index 960a681f..00000000
--- a/tests/expectations/tests/char.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type Char = ::std::os::raw::c_char;
-pub type SChar = ::std::os::raw::c_schar;
-pub type UChar = ::std::os::raw::c_uchar;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Test {
-    pub ch: ::std::os::raw::c_char,
-    pub u: ::std::os::raw::c_uchar,
-    pub d: ::std::os::raw::c_schar,
-    pub cch: ::std::os::raw::c_char,
-    pub cu: ::std::os::raw::c_uchar,
-    pub cd: ::std::os::raw::c_schar,
-    pub Cch: Char,
-    pub Cu: UChar,
-    pub Cd: SChar,
-    pub Ccch: Char,
-    pub Ccu: UChar,
-    pub Ccd: SChar,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        12usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        1usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        2usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
-        3usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
-        5usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
-        6usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
-        7usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Test),
-            "::",
-            stringify!(Ccch)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
-        10usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
-        11usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
-    );
-}
diff --git a/tests/expectations/tests/class.rs b/tests/expectations/tests/class.rs
deleted file mode 100644
index 8542135b..00000000
--- a/tests/expectations/tests/class.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        40usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(big_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct C_with_zero_length_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array))
-    );
-}
-impl Default for C_with_incomplete_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array_2() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
-    );
-}
-#[repr(C)]
-pub struct C_with_zero_length_array_and_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
-        40usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array_and_incomplete_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_and_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct WithDtor {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithDtor>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDtor>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDtor),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-pub struct IncompleteArrayNonCopiable {
-    pub whatever: *mut ::std::os::raw::c_void,
-    pub incomplete_array: __IncompleteArrayField<C>,
-}
-#[test]
-fn bindgen_test_layout_IncompleteArrayNonCopiable() {
-    assert_eq!(
-        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
-    );
-}
-impl Default for IncompleteArrayNonCopiable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union Union {
-    pub d: f32,
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Union() {
-    const UNINIT: ::std::mem::MaybeUninit<Union> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Union>(),
-        4usize,
-        concat!("Size of: ", stringify!(Union))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Union>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Union))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
-    );
-}
-impl Default for Union {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct WithUnion {
-    pub data: Union,
-}
-#[test]
-fn bindgen_test_layout_WithUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithUnion>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithUnion>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithUnion),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Default for WithUnion {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct RealAbstractionWithTonsOfMethods {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!(
-            "Alignment of ",
-            stringify!(RealAbstractionWithTonsOfMethods)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar(
-        this: *const RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar1(
-        this: *mut RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
-    pub fn RealAbstractionWithTonsOfMethods_bar2(
-        this: *mut RealAbstractionWithTonsOfMethods,
-        foo: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
-    pub fn RealAbstractionWithTonsOfMethods_sta();
-}
-impl RealAbstractionWithTonsOfMethods {
-    #[inline]
-    pub unsafe fn bar(&self) {
-        RealAbstractionWithTonsOfMethods_bar(self)
-    }
-    #[inline]
-    pub unsafe fn bar1(&mut self) {
-        RealAbstractionWithTonsOfMethods_bar1(self)
-    }
-    #[inline]
-    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
-        RealAbstractionWithTonsOfMethods_bar2(self, foo)
-    }
-    #[inline]
-    pub unsafe fn sta() {
-        RealAbstractionWithTonsOfMethods_sta()
-    }
-}
diff --git a/tests/expectations/tests/class_1_0.rs b/tests/expectations/tests/class_1_0.rs
deleted file mode 100644
index f6c3021e..00000000
--- a/tests/expectations/tests/class_1_0.rs
+++ /dev/null
@@ -1,558 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Copy)]
-pub struct C {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        40usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(big_array)
-        )
-    );
-}
-impl Clone for C {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for C {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl ::std::cmp::PartialEq for C {
-    fn eq(&self, other: &C) -> bool {
-        self.a == other.a && &self.big_array[..] == &other.big_array[..]
-    }
-}
-#[repr(C)]
-pub struct C_with_zero_length_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array))
-    );
-}
-impl Default for C_with_incomplete_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array_2() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
-    );
-}
-#[repr(C)]
-pub struct C_with_zero_length_array_and_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
-        40usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array_and_incomplete_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_and_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Hash, PartialEq, Eq)]
-pub struct WithDtor {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithDtor>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDtor>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDtor),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-pub struct IncompleteArrayNonCopiable {
-    pub whatever: *mut ::std::os::raw::c_void,
-    pub incomplete_array: __IncompleteArrayField<C>,
-}
-#[test]
-fn bindgen_test_layout_IncompleteArrayNonCopiable() {
-    assert_eq!(
-        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
-    );
-}
-impl Default for IncompleteArrayNonCopiable {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct Union {
-    pub d: __BindgenUnionField<f32>,
-    pub i: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_Union() {
-    const UNINIT: ::std::mem::MaybeUninit<Union> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Union>(),
-        4usize,
-        concat!("Size of: ", stringify!(Union))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Union>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Union))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
-    );
-}
-impl Clone for Union {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct WithUnion {
-    pub data: Union,
-}
-#[test]
-fn bindgen_test_layout_WithUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithUnion>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithUnion>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithUnion),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Clone for WithUnion {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct RealAbstractionWithTonsOfMethods {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!(
-            "Alignment of ",
-            stringify!(RealAbstractionWithTonsOfMethods)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar(
-        this: *const RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar1(
-        this: *mut RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
-    pub fn RealAbstractionWithTonsOfMethods_bar2(
-        this: *mut RealAbstractionWithTonsOfMethods,
-        foo: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
-    pub fn RealAbstractionWithTonsOfMethods_sta();
-}
-impl Clone for RealAbstractionWithTonsOfMethods {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl RealAbstractionWithTonsOfMethods {
-    #[inline]
-    pub unsafe fn bar(&self) {
-        RealAbstractionWithTonsOfMethods_bar(self)
-    }
-    #[inline]
-    pub unsafe fn bar1(&mut self) {
-        RealAbstractionWithTonsOfMethods_bar1(self)
-    }
-    #[inline]
-    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
-        RealAbstractionWithTonsOfMethods_bar2(self, foo)
-    }
-    #[inline]
-    pub unsafe fn sta() {
-        RealAbstractionWithTonsOfMethods_sta()
-    }
-}
diff --git a/tests/expectations/tests/class_nested.rs b/tests/expectations/tests/class_nested.rs
deleted file mode 100644
index f2cc8326..00000000
--- a/tests/expectations/tests/class_nested.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A {
-    pub member_a: ::std::os::raw::c_int,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A_B {
-    pub member_b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A_B() {
-    const UNINIT: ::std::mem::MaybeUninit<A_B> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A_B>(),
-        4usize,
-        concat!("Size of: ", stringify!(A_B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A_B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A_B))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).member_b) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A_B),
-            "::",
-            stringify!(member_b)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A_D<T> {
-    pub foo: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for A_D<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        4usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).member_a) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A),
-            "::",
-            stringify!(member_a)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A_C {
-    pub baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A_C() {
-    const UNINIT: ::std::mem::MaybeUninit<A_C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A_C>(),
-        4usize,
-        concat!("Size of: ", stringify!(A_C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A_C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A_C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A_C), "::", stringify!(baz))
-    );
-}
-extern "C" {
-    pub static mut var: A_B;
-}
-#[test]
-fn __bindgen_test_layout_A_D_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<A_D<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(A_D<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A_D<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(A_D<::std::os::raw::c_int>)
-        )
-    );
-}
-extern "C" {
-    pub static mut baz: A_D<::std::os::raw::c_int>;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct D {
-    pub member: A_B,
-}
-#[test]
-fn bindgen_test_layout_D() {
-    const UNINIT: ::std::mem::MaybeUninit<D> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<D>(),
-        4usize,
-        concat!("Size of: ", stringify!(D))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<D>(),
-        4usize,
-        concat!("Alignment of ", stringify!(D))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(D), "::", stringify!(member))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Templated<T> {
-    pub member: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Templated_Templated_inner<T> {
-    pub member_ptr: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Templated_Templated_inner<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> Default for Templated<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/class_no_members.rs b/tests/expectations/tests/class_no_members.rs
deleted file mode 100644
index 676590c8..00000000
--- a/tests/expectations/tests/class_no_members.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct whatever {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_whatever() {
-    assert_eq!(
-        ::std::mem::size_of::<whatever>(),
-        1usize,
-        concat!("Size of: ", stringify!(whatever))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<whatever>(),
-        1usize,
-        concat!("Alignment of ", stringify!(whatever))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct whatever_child {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_whatever_child() {
-    assert_eq!(
-        ::std::mem::size_of::<whatever_child>(),
-        1usize,
-        concat!("Size of: ", stringify!(whatever_child))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<whatever_child>(),
-        1usize,
-        concat!("Alignment of ", stringify!(whatever_child))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct whatever_child_with_member {
-    pub m_member: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_whatever_child_with_member() {
-    const UNINIT: ::std::mem::MaybeUninit<whatever_child_with_member> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<whatever_child_with_member>(),
-        4usize,
-        concat!("Size of: ", stringify!(whatever_child_with_member))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<whatever_child_with_member>(),
-        4usize,
-        concat!("Alignment of ", stringify!(whatever_child_with_member))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(whatever_child_with_member),
-            "::",
-            stringify!(m_member)
-        )
-    );
-}
diff --git a/tests/expectations/tests/class_static.rs b/tests/expectations/tests/class_static.rs
deleted file mode 100644
index 2388f3b3..00000000
--- a/tests/expectations/tests/class_static.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct MyClass {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN7MyClass7exampleE"]
-    pub static mut MyClass_example: *const ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN7MyClass26example_check_no_collisionE"]
-    pub static mut MyClass_example_check_no_collision:
-        *const ::std::os::raw::c_int;
-}
-#[test]
-fn bindgen_test_layout_MyClass() {
-    assert_eq!(
-        ::std::mem::size_of::<MyClass>(),
-        1usize,
-        concat!("Size of: ", stringify!(MyClass))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MyClass>(),
-        1usize,
-        concat!("Alignment of ", stringify!(MyClass))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZL26example_check_no_collision"]
-    pub static mut example_check_no_collision: *const ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/class_static_const.rs b/tests/expectations/tests/class_static_const.rs
deleted file mode 100644
index 812d78e1..00000000
--- a/tests/expectations/tests/class_static_const.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A {
-    pub _address: u8,
-}
-pub const A_a: ::std::os::raw::c_int = 0;
-pub const A_b: i32 = 63;
-pub const A_c: u32 = 255;
-#[test]
-fn bindgen_test_layout_A() {
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-}
diff --git a/tests/expectations/tests/class_use_as.rs b/tests/expectations/tests/class_use_as.rs
deleted file mode 100644
index ef130c16..00000000
--- a/tests/expectations/tests/class_use_as.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen="true" replaces="whatever"></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct whatever {
-    pub replacement: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_whatever() {
-    const UNINIT: ::std::mem::MaybeUninit<whatever> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<whatever>(),
-        4usize,
-        concat!("Size of: ", stringify!(whatever))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<whatever>(),
-        4usize,
-        concat!("Alignment of ", stringify!(whatever))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).replacement) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(whatever),
-            "::",
-            stringify!(replacement)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct container {
-    pub c: whatever,
-}
-#[test]
-fn bindgen_test_layout_container() {
-    const UNINIT: ::std::mem::MaybeUninit<container> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<container>(),
-        4usize,
-        concat!("Size of: ", stringify!(container))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<container>(),
-        4usize,
-        concat!("Alignment of ", stringify!(container))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(container),
-            "::",
-            stringify!(c)
-        )
-    );
-}
diff --git a/tests/expectations/tests/class_with_dtor.rs b/tests/expectations/tests/class_with_dtor.rs
deleted file mode 100644
index 86d2a576..00000000
--- a/tests/expectations/tests/class_with_dtor.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct HandleWithDtor<T> {
-    pub ptr: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for HandleWithDtor<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type HandleValue = HandleWithDtor<::std::os::raw::c_int>;
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct WithoutDtor {
-    pub shouldBeWithDtor: HandleValue,
-}
-#[test]
-fn bindgen_test_layout_WithoutDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<WithoutDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithoutDtor>(),
-        8usize,
-        concat!("Size of: ", stringify!(WithoutDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithoutDtor>(),
-        8usize,
-        concat!("Alignment of ", stringify!(WithoutDtor))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).shouldBeWithDtor) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithoutDtor),
-            "::",
-            stringify!(shouldBeWithDtor)
-        )
-    );
-}
-impl Default for WithoutDtor {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_HandleWithDtor_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(HandleWithDtor<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<HandleWithDtor<::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(HandleWithDtor<::std::os::raw::c_int>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/class_with_inner_struct.rs b/tests/expectations/tests/class_with_inner_struct.rs
deleted file mode 100644
index eab9d598..00000000
--- a/tests/expectations/tests/class_with_inner_struct.rs
+++ /dev/null
@@ -1,490 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct A {
-    pub c: ::std::os::raw::c_uint,
-    pub named_union: A__bindgen_ty_1,
-    pub __bindgen_anon_1: A__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct A_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<A_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(A_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union A__bindgen_ty_1 {
-    pub f: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(A__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A__bindgen_ty_1),
-            "::",
-            stringify!(f)
-        )
-    );
-}
-impl Default for A__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union A__bindgen_ty_2 {
-    pub d: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(A__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A__bindgen_ty_2),
-            "::",
-            stringify!(d)
-        )
-    );
-}
-impl Default for A__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        12usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(c))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).named_union) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A),
-            "::",
-            stringify!(named_union)
-        )
-    );
-}
-impl Default for A {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct B {
-    pub d: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct B_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_B_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<B_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(B_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(B_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(B_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_B() {
-    const UNINIT: ::std::mem::MaybeUninit<B> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(B), "::", stringify!(d))
-    );
-}
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum StepSyntax {
-    Keyword = 0,
-    FunctionalWithoutKeyword = 1,
-    FunctionalWithStartKeyword = 2,
-    FunctionalWithEndKeyword = 3,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub d: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: C__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union C__bindgen_ty_1 {
-    pub mFunc: C__bindgen_ty_1__bindgen_ty_1,
-    pub __bindgen_anon_1: C__bindgen_ty_1__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub struct C__bindgen_ty_1__bindgen_ty_1 {
-    pub mX1: f32,
-    pub mY1: f32,
-    pub mX2: f32,
-    pub mY2: f32,
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mX1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mX1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mY1) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mY1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mX2) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mX2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mY2) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mY2)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct C__bindgen_ty_1__bindgen_ty_2 {
-    pub mStepSyntax: StepSyntax,
-    pub mSteps: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_2>(),
-        8usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mStepSyntax) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(mStepSyntax)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mSteps) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(mSteps)
-        )
-    );
-}
-impl Default for C__bindgen_ty_1__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFunc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1),
-            "::",
-            stringify!(mFunc)
-        )
-    );
-}
-impl Default for C__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct C_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_C_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<C_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(C_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        20usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/class_with_inner_struct_1_0.rs b/tests/expectations/tests/class_with_inner_struct_1_0.rs
deleted file mode 100644
index 42656079..00000000
--- a/tests/expectations/tests/class_with_inner_struct_1_0.rs
+++ /dev/null
@@ -1,546 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct A {
-    pub c: ::std::os::raw::c_uint,
-    pub named_union: A__bindgen_ty_1,
-    pub __bindgen_anon_1: A__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct A_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<A_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(A_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-impl Clone for A_Segment {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct A__bindgen_ty_1 {
-    pub f: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_A__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(A__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A__bindgen_ty_1),
-            "::",
-            stringify!(f)
-        )
-    );
-}
-impl Clone for A__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct A__bindgen_ty_2 {
-    pub d: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_A__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<A__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(A__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A__bindgen_ty_2),
-            "::",
-            stringify!(d)
-        )
-    );
-}
-impl Clone for A__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        12usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(c))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).named_union) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(A),
-            "::",
-            stringify!(named_union)
-        )
-    );
-}
-impl Clone for A {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct B {
-    pub d: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct B_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_B_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<B_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(B_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(B_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(B_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-impl Clone for B_Segment {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_B() {
-    const UNINIT: ::std::mem::MaybeUninit<B> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(B), "::", stringify!(d))
-    );
-}
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum StepSyntax {
-    Keyword = 0,
-    FunctionalWithoutKeyword = 1,
-    FunctionalWithStartKeyword = 2,
-    FunctionalWithEndKeyword = 3,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct C {
-    pub d: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: C__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct C__bindgen_ty_1 {
-    pub mFunc: __BindgenUnionField<C__bindgen_ty_1__bindgen_ty_1>,
-    pub __bindgen_anon_1: __BindgenUnionField<C__bindgen_ty_1__bindgen_ty_2>,
-    pub bindgen_union_field: [u32; 4usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, PartialEq)]
-pub struct C__bindgen_ty_1__bindgen_ty_1 {
-    pub mX1: f32,
-    pub mY1: f32,
-    pub mX2: f32,
-    pub mY2: f32,
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mX1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mX1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mY1) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mY1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mX2) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mX2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mY2) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(mY2)
-        )
-    );
-}
-impl Clone for C__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct C__bindgen_ty_1__bindgen_ty_2 {
-    pub mStepSyntax: StepSyntax,
-    pub mSteps: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1__bindgen_ty_2>(),
-        8usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mStepSyntax) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(mStepSyntax)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mSteps) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(mSteps)
-        )
-    );
-}
-impl Clone for C__bindgen_ty_1__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for C__bindgen_ty_1__bindgen_ty_2 {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_C__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<C__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(C__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFunc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C__bindgen_ty_1),
-            "::",
-            stringify!(mFunc)
-        )
-    );
-}
-impl Clone for C__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct C_Segment {
-    pub begin: ::std::os::raw::c_int,
-    pub end: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_C_Segment() {
-    const UNINIT: ::std::mem::MaybeUninit<C_Segment> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_Segment>(),
-        8usize,
-        concat!("Size of: ", stringify!(C_Segment))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_Segment>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_Segment))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).begin) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_Segment),
-            "::",
-            stringify!(begin)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_Segment),
-            "::",
-            stringify!(end)
-        )
-    );
-}
-impl Clone for C_Segment {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        20usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
-    );
-}
-impl Clone for C {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/class_with_typedef.rs b/tests/expectations/tests/class_with_typedef.rs
deleted file mode 100644
index 65e86b27..00000000
--- a/tests/expectations/tests/class_with_typedef.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type AnotherInt = ::std::os::raw::c_int;
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct C {
-    pub c: C_MyInt,
-    pub ptr: *mut C_MyInt,
-    pub arr: [C_MyInt; 10usize],
-    pub d: AnotherInt,
-    pub other_ptr: *mut AnotherInt,
-}
-pub type C_MyInt = ::std::os::raw::c_int;
-pub type C_Lookup = *const ::std::os::raw::c_char;
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        72usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        8usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(c))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(ptr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
-        16usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(arr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        56usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).other_ptr) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(other_ptr)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C6methodEi"]
-    pub fn C_method(this: *mut C, c: C_MyInt);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C9methodRefERi"]
-    pub fn C_methodRef(this: *mut C, c: *mut C_MyInt);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C16complexMethodRefERPKc"]
-    pub fn C_complexMethodRef(this: *mut C, c: *mut C_Lookup);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C13anotherMethodEi"]
-    pub fn C_anotherMethod(this: *mut C, c: AnotherInt);
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl C {
-    #[inline]
-    pub unsafe fn method(&mut self, c: C_MyInt) {
-        C_method(self, c)
-    }
-    #[inline]
-    pub unsafe fn methodRef(&mut self, c: *mut C_MyInt) {
-        C_methodRef(self, c)
-    }
-    #[inline]
-    pub unsafe fn complexMethodRef(&mut self, c: *mut C_Lookup) {
-        C_complexMethodRef(self, c)
-    }
-    #[inline]
-    pub unsafe fn anotherMethod(&mut self, c: AnotherInt) {
-        C_anotherMethod(self, c)
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct D {
-    pub _base: C,
-    pub ptr: *mut C_MyInt,
-}
-#[test]
-fn bindgen_test_layout_D() {
-    const UNINIT: ::std::mem::MaybeUninit<D> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<D>(),
-        80usize,
-        concat!("Size of: ", stringify!(D))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<D>(),
-        8usize,
-        concat!("Alignment of ", stringify!(D))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
-        72usize,
-        concat!("Offset of field: ", stringify!(D), "::", stringify!(ptr))
-    );
-}
-impl Default for D {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/comment-indent.rs b/tests/expectations/tests/comment-indent.rs
deleted file mode 100644
index 3ad221aa..00000000
--- a/tests/expectations/tests/comment-indent.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    /// This is a multi-line doc comment.
-    ///
-    /// This class is really really interesting, look!
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct Foo {
-        pub _address: u8,
-    }
-    /// This nested class is also a multi-line doc comment.
-    ///
-    /// This class is not so interesting, but worth a bit of docs too!
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct Foo_Bar {
-        pub _address: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_Foo_Bar() {
-        assert_eq!(
-            ::std::mem::size_of::<Foo_Bar>(),
-            1usize,
-            concat!("Size of: ", stringify!(Foo_Bar))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<Foo_Bar>(),
-            1usize,
-            concat!("Alignment of ", stringify!(Foo_Bar))
-        );
-    }
-    #[test]
-    fn bindgen_test_layout_Foo() {
-        assert_eq!(
-            ::std::mem::size_of::<Foo>(),
-            1usize,
-            concat!("Size of: ", stringify!(Foo))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<Foo>(),
-            1usize,
-            concat!("Alignment of ", stringify!(Foo))
-        );
-    }
-    pub mod test {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        /// I'm in a namespace, and thus I may be on a rust module, most of the time.
-        /// My documentation is pretty extensive, I guess.
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Baz {
-            /// This member is plain awesome, just amazing.
-            ///
-            /// It also has super-extensive docs, with even a nice ascii-art diagram.
-            ///
-            /// +------+          +-------+
-            /// | foo  |   ---->  | bar   |
-            /// +------+          +-------+
-            pub member: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_Baz() {
-            const UNINIT: ::std::mem::MaybeUninit<Baz> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Baz>(),
-                4usize,
-                concat!("Size of: ", stringify!(Baz))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Baz>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Baz))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Baz),
-                    "::",
-                    stringify!(member)
-                )
-            );
-        }
-        /// I'm in an inline namespace, and as such I shouldn't get generated inside
-        /// a rust module, except when the relevant option is specified. Also, this
-        /// comment shouldn't be misaligned.
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct InInlineNS {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_InInlineNS() {
-            assert_eq!(
-                ::std::mem::size_of::<InInlineNS>(),
-                1usize,
-                concat!("Size of: ", stringify!(InInlineNS))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<InInlineNS>(),
-                1usize,
-                concat!("Alignment of ", stringify!(InInlineNS))
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Bazz {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_Bazz() {
-            assert_eq!(
-                ::std::mem::size_of::<Bazz>(),
-                1usize,
-                concat!("Size of: ", stringify!(Bazz))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bazz>(),
-                1usize,
-                concat!("Alignment of ", stringify!(Bazz))
-            );
-        }
-    }
-}
diff --git a/tests/expectations/tests/complex.rs b/tests/expectations/tests/complex.rs
deleted file mode 100644
index e9c4be9d..00000000
--- a/tests/expectations/tests/complex.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
-#[repr(C)]
-pub struct __BindgenComplex<T> {
-    pub re: T,
-    pub im: T,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub struct TestDouble {
-    pub mMember: __BindgenComplex<f64>,
-}
-#[test]
-fn bindgen_test_layout_TestDouble() {
-    const UNINIT: ::std::mem::MaybeUninit<TestDouble> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<TestDouble>(),
-        16usize,
-        concat!("Size of: ", stringify!(TestDouble))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestDouble>(),
-        8usize,
-        concat!("Alignment of ", stringify!(TestDouble))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(TestDouble),
-            "::",
-            stringify!(mMember)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct TestDoublePtr {
-    pub mMember: *mut __BindgenComplex<f64>,
-}
-#[test]
-fn bindgen_test_layout_TestDoublePtr() {
-    const UNINIT: ::std::mem::MaybeUninit<TestDoublePtr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<TestDoublePtr>(),
-        8usize,
-        concat!("Size of: ", stringify!(TestDoublePtr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestDoublePtr>(),
-        8usize,
-        concat!("Alignment of ", stringify!(TestDoublePtr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(TestDoublePtr),
-            "::",
-            stringify!(mMember)
-        )
-    );
-}
-impl Default for TestDoublePtr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub struct TestFloat {
-    pub mMember: __BindgenComplex<f32>,
-}
-#[test]
-fn bindgen_test_layout_TestFloat() {
-    const UNINIT: ::std::mem::MaybeUninit<TestFloat> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<TestFloat>(),
-        8usize,
-        concat!("Size of: ", stringify!(TestFloat))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestFloat>(),
-        4usize,
-        concat!("Alignment of ", stringify!(TestFloat))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(TestFloat),
-            "::",
-            stringify!(mMember)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct TestFloatPtr {
-    pub mMember: *mut __BindgenComplex<f32>,
-}
-#[test]
-fn bindgen_test_layout_TestFloatPtr() {
-    const UNINIT: ::std::mem::MaybeUninit<TestFloatPtr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<TestFloatPtr>(),
-        8usize,
-        concat!("Size of: ", stringify!(TestFloatPtr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestFloatPtr>(),
-        8usize,
-        concat!("Alignment of ", stringify!(TestFloatPtr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(TestFloatPtr),
-            "::",
-            stringify!(mMember)
-        )
-    );
-}
-impl Default for TestFloatPtr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/complex_global.rs b/tests/expectations/tests/complex_global.rs
deleted file mode 100644
index f21735da..00000000
--- a/tests/expectations/tests/complex_global.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
-#[repr(C)]
-pub struct __BindgenComplex<T> {
-    pub re: T,
-    pub im: T,
-}
-extern "C" {
-    pub static mut globalValueFloat: __BindgenComplex<f32>;
-}
-extern "C" {
-    pub static mut globalValueDouble: __BindgenComplex<f64>;
-}
-extern "C" {
-    pub static mut globalValueLongDouble: __BindgenComplex<f64>;
-}
diff --git a/tests/expectations/tests/const-const-mut-ptr.rs b/tests/expectations/tests/const-const-mut-ptr.rs
deleted file mode 100644
index e8f13dff..00000000
--- a/tests/expectations/tests/const-const-mut-ptr.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub bar: *const *const *mut *const ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/const_array.rs b/tests/expectations/tests/const_array.rs
deleted file mode 100644
index 191bac9c..00000000
--- a/tests/expectations/tests/const_array.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub static foo: [::std::os::raw::c_int; 1usize];
-}
-extern "C" {
-    pub static mut bar: [::std::os::raw::c_int; 1usize];
-}
diff --git a/tests/expectations/tests/const_array_fn_arg.rs b/tests/expectations/tests/const_array_fn_arg.rs
deleted file mode 100644
index 3286dce1..00000000
--- a/tests/expectations/tests/const_array_fn_arg.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn f(a: *const ::std::os::raw::c_int);
-}
diff --git a/tests/expectations/tests/const_enum_unnamed.rs b/tests/expectations/tests/const_enum_unnamed.rs
deleted file mode 100644
index da0ec2b8..00000000
--- a/tests/expectations/tests/const_enum_unnamed.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const FOO_BAR: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAR;
-pub const FOO_BAZ: _bindgen_ty_1 = _bindgen_ty_1::FOO_BAZ;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    FOO_BAR = 0,
-    FOO_BAZ = 1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub const Foo_FOO_BAR: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::FOO_BAR;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo__bindgen_ty_1 {
-    FOO_BAR = 10,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/const_multidim_array_fn_arg.rs b/tests/expectations/tests/const_multidim_array_fn_arg.rs
deleted file mode 100644
index 11ae184d..00000000
--- a/tests/expectations/tests/const_multidim_array_fn_arg.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn f(a: *const [::std::os::raw::c_int; 1usize]);
-}
diff --git a/tests/expectations/tests/const_ptr.rs b/tests/expectations/tests/const_ptr.rs
deleted file mode 100644
index 0087aa99..00000000
--- a/tests/expectations/tests/const_ptr.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo(bar: *const ::std::os::raw::c_void);
-}
diff --git a/tests/expectations/tests/const_resolved_ty.rs b/tests/expectations/tests/const_resolved_ty.rs
deleted file mode 100644
index 66939ef9..00000000
--- a/tests/expectations/tests/const_resolved_ty.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo(foo: *const u8);
-}
diff --git a/tests/expectations/tests/const_tparam.rs b/tests/expectations/tests/const_tparam.rs
deleted file mode 100644
index ec256872..00000000
--- a/tests/expectations/tests/const_tparam.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct C<T> {
-    pub foo: *const T,
-    pub bar: *const T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for C<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/constant-non-specialized-tp.rs b/tests/expectations/tests/constant-non-specialized-tp.rs
deleted file mode 100644
index 6c1e3d38..00000000
--- a/tests/expectations/tests/constant-non-specialized-tp.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Outer {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Outer_Inner {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/constified-enum-module-overflow.rs b/tests/expectations/tests/constified-enum-module-overflow.rs
deleted file mode 100644
index d47338f1..00000000
--- a/tests/expectations/tests/constified-enum-module-overflow.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct B {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub _address: u8,
-}
-pub type C_U = B;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub u: u8,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(u))
-    );
-}
-#[test]
-fn __bindgen_test_layout_C_open0_A_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(C))
-    );
-}
diff --git a/tests/expectations/tests/constify-all-enums.rs b/tests/expectations/tests/constify-all-enums.rs
deleted file mode 100644
index e3c82156..00000000
--- a/tests/expectations/tests/constify-all-enums.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const foo_THIS: foo = 0;
-pub const foo_SHOULD_BE: foo = 1;
-pub const foo_A_CONSTANT: foo = 2;
-pub type foo = ::std::os::raw::c_uint;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct bar {
-    pub this_should_work: foo,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(this_should_work)
-        )
-    );
-}
-impl Default for bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/constify-enum.rs b/tests/expectations/tests/constify-enum.rs
deleted file mode 100644
index 091743e9..00000000
--- a/tests/expectations/tests/constify-enum.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const nsCSSPropertyID_eCSSProperty_COUNT_unexistingVariantValue:
-    nsCSSPropertyID =
-    nsCSSPropertyID::eCSSProperty_COUNT_unexistingVariantValue;
-impl nsCSSPropertyID {
-    pub const eCSSProperty_COUNT: nsCSSPropertyID =
-        nsCSSPropertyID::eCSSPropertyAlias_aa;
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum nsCSSPropertyID {
-    eCSSProperty_a = 0,
-    eCSSProperty_b = 1,
-    eCSSPropertyAlias_aa = 2,
-    eCSSPropertyAlias_bb = 3,
-    ///< <div rustbindgen constant></div>
-    eCSSProperty_COUNT_unexistingVariantValue = 4,
-}
diff --git a/tests/expectations/tests/constify-module-enums-basic.rs b/tests/expectations/tests/constify-module-enums-basic.rs
deleted file mode 100644
index c5c32983..00000000
--- a/tests/expectations/tests/constify-module-enums-basic.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const THIS: Type = 0;
-    pub const SHOULD_BE: Type = 1;
-    pub const A_CONSTANT: Type = 2;
-}
-pub use self::foo::Type as foo_alias1;
-pub use self::foo_alias1 as foo_alias2;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct bar {
-    pub this_should_work: foo::Type,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(this_should_work)
-        )
-    );
-}
-impl Default for bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    pub fn func1(
-        arg1: foo::Type,
-        arg2: *mut foo::Type,
-        arg3: *mut *mut foo::Type,
-    ) -> *mut foo::Type;
-}
-extern "C" {
-    pub fn func2(
-        arg1: foo_alias1,
-        arg2: *mut foo_alias1,
-        arg3: *mut *mut foo_alias1,
-    ) -> *mut foo_alias1;
-}
diff --git a/tests/expectations/tests/constify-module-enums-namespace.rs b/tests/expectations/tests/constify-module-enums-namespace.rs
deleted file mode 100644
index 0b8eec1e..00000000
--- a/tests/expectations/tests/constify-module-enums-namespace.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod ns1 {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod ns2 {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            pub mod foo {
-                pub type Type = ::std::os::raw::c_uint;
-                pub const THIS: Type = 0;
-                pub const SHOULD_BE: Type = 1;
-                pub const A_CONSTANT: Type = 2;
-            }
-        }
-        pub mod ns3 {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            #[repr(C)]
-            #[derive(Debug, Copy, Clone)]
-            pub struct bar {
-                pub this_should_work: root::ns1::ns2::foo::Type,
-            }
-            #[test]
-            fn bindgen_test_layout_bar() {
-                const UNINIT: ::std::mem::MaybeUninit<bar> =
-                    ::std::mem::MaybeUninit::uninit();
-                let ptr = UNINIT.as_ptr();
-                assert_eq!(
-                    ::std::mem::size_of::<bar>(),
-                    4usize,
-                    concat!("Size of: ", stringify!(bar))
-                );
-                assert_eq!(
-                    ::std::mem::align_of::<bar>(),
-                    4usize,
-                    concat!("Alignment of ", stringify!(bar))
-                );
-                assert_eq!(
-                    unsafe {
-                        ::std::ptr::addr_of!((*ptr).this_should_work) as usize -
-                            ptr as usize
-                    },
-                    0usize,
-                    concat!(
-                        "Offset of field: ",
-                        stringify!(bar),
-                        "::",
-                        stringify!(this_should_work)
-                    )
-                );
-            }
-            impl Default for bar {
-                fn default() -> Self {
-                    let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                    unsafe {
-                        ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                        s.assume_init()
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/constify-module-enums-shadow-name.rs b/tests/expectations/tests/constify-module-enums-shadow-name.rs
deleted file mode 100644
index 44643d0f..00000000
--- a/tests/expectations/tests/constify-module-enums-shadow-name.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const Type: Type = 0;
-    pub const Type_: Type = 1;
-    pub const Type1: Type = 2;
-    pub const Type__: Type = 3;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct bar {
-    pub member: foo::Type,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/constify-module-enums-simple-alias.rs b/tests/expectations/tests/constify-module-enums-simple-alias.rs
deleted file mode 100644
index 0262b128..00000000
--- a/tests/expectations/tests/constify-module-enums-simple-alias.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod Foo {
-    pub type Type = ::std::os::raw::c_int;
-    pub const Variant1: Type = 0;
-    pub const Variant2: Type = 1;
-    pub const Variant3: Type = 2;
-}
-pub use self::Foo::Type as Foo_alias1;
-pub use self::Foo_alias1 as Foo_alias2;
-pub use self::Foo_alias2 as Foo_alias3;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub baz1: Foo::Type,
-    pub baz2: Foo_alias1,
-    pub baz3: Foo_alias2,
-    pub baz4: Foo_alias3,
-    pub baz_ptr1: *mut Foo::Type,
-    pub baz_ptr2: *mut Foo_alias1,
-    pub baz_ptr3: *mut Foo_alias2,
-    pub baz_ptr4: *mut Foo_alias3,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        48usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz1) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz2) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz3) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz3))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz4) as usize - ptr as usize },
-        12usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz4))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).baz_ptr1) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(baz_ptr1)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).baz_ptr2) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(baz_ptr2)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).baz_ptr3) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(baz_ptr3)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).baz_ptr4) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(baz_ptr4)
-        )
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs b/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
deleted file mode 100644
index 75ebf48a..00000000
--- a/tests/expectations/tests/constify-module-enums-simple-nonamespace.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod one_Foo {
-    pub type Type = ::std::os::raw::c_int;
-    pub const Variant1: Type = 0;
-    pub const Variant2: Type = 1;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub baz1: one_Foo::Type,
-    pub baz2: *mut one_Foo::Type,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        16usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz1) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz2) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz2))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/constify-module-enums-types.rs b/tests/expectations/tests/constify-module-enums-types.rs
deleted file mode 100644
index c3c6d3ca..00000000
--- a/tests/expectations/tests/constify-module-enums-types.rs
+++ /dev/null
@@ -1,299 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const THIS: Type = 0;
-    pub const SHOULD_BE: Type = 1;
-    pub const A_CONSTANT: Type = 2;
-    pub const ALSO_THIS: Type = 42;
-    pub const AND_ALSO_THIS: Type = 42;
-}
-pub mod anon_enum {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const Variant1: Type = 0;
-    pub const Variant2: Type = 1;
-    pub const Variant3: Type = 2;
-}
-pub mod ns1_foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const THIS: Type = 0;
-    pub const SHOULD_BE: Type = 1;
-    pub const A_CONSTANT: Type = 2;
-    pub const ALSO_THIS: Type = 42;
-}
-pub mod ns2_Foo {
-    pub type Type = ::std::os::raw::c_int;
-    pub const Variant1: Type = 0;
-    pub const Variant2: Type = 1;
-}
-pub use self::anon_enum::Type as anon_enum_alias1;
-pub use self::anon_enum_alias1 as anon_enum_alias2;
-pub use self::anon_enum_alias2 as anon_enum_alias3;
-pub use self::foo::Type as foo_alias1;
-pub use self::foo_alias1 as foo_alias2;
-pub use self::foo_alias2 as foo_alias3;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct bar {
-    pub member1: foo::Type,
-    pub member2: foo_alias1,
-    pub member3: foo_alias2,
-    pub member4: foo_alias3,
-    pub member5: ns1_foo::Type,
-    pub member6: *mut ns2_Foo::Type,
-    pub member7: anon_enum::Type,
-    pub member8: anon_enum_alias1,
-    pub member9: anon_enum_alias2,
-    pub member10: anon_enum_alias3,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        48usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member2) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member3) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member3)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member4) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member4)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member5) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member5)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member6) as usize - ptr as usize },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member6)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member7) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member7)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member8) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member8)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member9) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member9)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).member10) as usize - ptr as usize
-        },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar),
-            "::",
-            stringify!(member10)
-        )
-    );
-}
-impl Default for bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Baz {
-    pub member1: ns2_Foo::Type,
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    const UNINIT: ::std::mem::MaybeUninit<Baz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        4usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Baz),
-            "::",
-            stringify!(member1)
-        )
-    );
-}
-impl Default for Baz {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub mod one_Foo {
-    pub type Type = ::std::os::raw::c_int;
-    pub const Variant1: Type = 0;
-    pub const Variant2: Type = 1;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub baz: *mut one_Foo::Type,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5func13fooPS_PS0_"]
-    pub fn func1(
-        arg1: foo::Type,
-        arg2: *mut foo::Type,
-        arg3: *mut *mut foo::Type,
-    ) -> *mut foo::Type;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5func23fooPS_PS0_"]
-    pub fn func2(
-        arg1: foo_alias1,
-        arg2: *mut foo_alias1,
-        arg3: *mut *mut foo_alias1,
-    ) -> *mut foo_alias1;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Thing<T> {
-    pub thing: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Thing<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5func35ThingI3fooE"]
-    pub fn func3(arg1: Thing<foo::Type>) -> foo::Type;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5func45ThingIS_I3fooEE"]
-    pub fn func4(arg1: Thing<Thing<foo::Type>>) -> foo::Type;
-}
diff --git a/tests/expectations/tests/constructor-tp.rs b/tests/expectations/tests/constructor-tp.rs
deleted file mode 100644
index 4b339dc3..00000000
--- a/tests/expectations/tests/constructor-tp.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3BarC1Ev"]
-    pub fn Bar_Bar(this: *mut Bar);
-}
-impl Bar {
-    #[inline]
-    pub unsafe fn new() -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        Bar_Bar(__bindgen_tmp.as_mut_ptr());
-        __bindgen_tmp.assume_init()
-    }
-}
diff --git a/tests/expectations/tests/constructors.rs b/tests/expectations/tests/constructors.rs
deleted file mode 100644
index 2f13effb..00000000
--- a/tests/expectations/tests/constructors.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TestOverload {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_TestOverload() {
-    assert_eq!(
-        ::std::mem::size_of::<TestOverload>(),
-        1usize,
-        concat!("Size of: ", stringify!(TestOverload))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestOverload>(),
-        1usize,
-        concat!("Alignment of ", stringify!(TestOverload))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN12TestOverloadC1Ei"]
-    pub fn TestOverload_TestOverload(
-        this: *mut TestOverload,
-        arg1: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN12TestOverloadC1Ed"]
-    pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64);
-}
-impl TestOverload {
-    #[inline]
-    pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        TestOverload_TestOverload(__bindgen_tmp.as_mut_ptr(), arg1);
-        __bindgen_tmp.assume_init()
-    }
-    #[inline]
-    pub unsafe fn new1(arg1: f64) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        TestOverload_TestOverload1(__bindgen_tmp.as_mut_ptr(), arg1);
-        __bindgen_tmp.assume_init()
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TestPublicNoArgs {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_TestPublicNoArgs() {
-    assert_eq!(
-        ::std::mem::size_of::<TestPublicNoArgs>(),
-        1usize,
-        concat!("Size of: ", stringify!(TestPublicNoArgs))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestPublicNoArgs>(),
-        1usize,
-        concat!("Alignment of ", stringify!(TestPublicNoArgs))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"]
-    pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs);
-}
-impl TestPublicNoArgs {
-    #[inline]
-    pub unsafe fn new() -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        TestPublicNoArgs_TestPublicNoArgs(__bindgen_tmp.as_mut_ptr());
-        __bindgen_tmp.assume_init()
-    }
-}
diff --git a/tests/expectations/tests/constructors_1_33.rs b/tests/expectations/tests/constructors_1_33.rs
deleted file mode 100644
index b5d33332..00000000
--- a/tests/expectations/tests/constructors_1_33.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TestOverload {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_TestOverload() {
-    assert_eq!(
-        ::std::mem::size_of::<TestOverload>(),
-        1usize,
-        concat!("Size of: ", stringify!(TestOverload))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestOverload>(),
-        1usize,
-        concat!("Alignment of ", stringify!(TestOverload))
-    );
-}
-extern "C" {
-    /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
-    #[link_name = "\u{1}_ZN12TestOverloadC1Ei"]
-    pub fn TestOverload_TestOverload(
-        this: *mut TestOverload,
-        arg1: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
-    #[link_name = "\u{1}_ZN12TestOverloadC1Ed"]
-    pub fn TestOverload_TestOverload1(this: *mut TestOverload, arg1: f64);
-}
-impl TestOverload {
-    #[inline]
-    pub unsafe fn new(arg1: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::uninitialized();
-        TestOverload_TestOverload(&mut __bindgen_tmp, arg1);
-        __bindgen_tmp
-    }
-    #[inline]
-    pub unsafe fn new1(arg1: f64) -> Self {
-        let mut __bindgen_tmp = ::std::mem::uninitialized();
-        TestOverload_TestOverload1(&mut __bindgen_tmp, arg1);
-        __bindgen_tmp
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TestPublicNoArgs {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_TestPublicNoArgs() {
-    assert_eq!(
-        ::std::mem::size_of::<TestPublicNoArgs>(),
-        1usize,
-        concat!("Size of: ", stringify!(TestPublicNoArgs))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<TestPublicNoArgs>(),
-        1usize,
-        concat!("Alignment of ", stringify!(TestPublicNoArgs))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN16TestPublicNoArgsC1Ev"]
-    pub fn TestPublicNoArgs_TestPublicNoArgs(this: *mut TestPublicNoArgs);
-}
-impl TestPublicNoArgs {
-    #[inline]
-    pub unsafe fn new() -> Self {
-        let mut __bindgen_tmp = ::std::mem::uninitialized();
-        TestPublicNoArgs_TestPublicNoArgs(&mut __bindgen_tmp);
-        __bindgen_tmp
-    }
-}
diff --git a/tests/expectations/tests/contains-vs-inherits-zero-sized.rs b/tests/expectations/tests/contains-vs-inherits-zero-sized.rs
deleted file mode 100644
index 62fc3749..00000000
--- a/tests/expectations/tests/contains-vs-inherits-zero-sized.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This should get an `_address` byte.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Empty {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Empty() {
-    assert_eq!(
-        ::std::mem::size_of::<Empty>(),
-        1usize,
-        concat!("Size of: ", stringify!(Empty))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Empty>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Empty))
-    );
-}
-/// This should not get an `_address` byte, so `sizeof(Inherits)` should be
-/// `1`.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Inherits {
-    pub b: bool,
-}
-#[test]
-fn bindgen_test_layout_Inherits() {
-    const UNINIT: ::std::mem::MaybeUninit<Inherits> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Inherits>(),
-        1usize,
-        concat!("Size of: ", stringify!(Inherits))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Inherits>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Inherits))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Inherits),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-/// This should not get an `_address` byte, but contains `Empty` which *does* get
-/// one, so `sizeof(Contains)` should be `1 + 1`.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Contains {
-    pub empty: Empty,
-    pub b: bool,
-}
-#[test]
-fn bindgen_test_layout_Contains() {
-    const UNINIT: ::std::mem::MaybeUninit<Contains> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Contains>(),
-        2usize,
-        concat!("Size of: ", stringify!(Contains))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Contains>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Contains))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).empty) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Contains),
-            "::",
-            stringify!(empty)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Contains),
-            "::",
-            stringify!(b)
-        )
-    );
-}
diff --git a/tests/expectations/tests/convert-cpp-comment-to-rust.rs b/tests/expectations/tests/convert-cpp-comment-to-rust.rs
deleted file mode 100644
index 09a22c4f..00000000
--- a/tests/expectations/tests/convert-cpp-comment-to-rust.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type mbedtls_mpi_uint = ::std::os::raw::c_uint;
-/// \brief          MPI structure
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct mbedtls_mpi {
-    ///<  integer sign
-    pub s: ::std::os::raw::c_int,
-    ///<  total # of limbs
-    pub n: ::std::os::raw::c_ulong,
-    ///<  pointer to limbs
-    pub p: *mut mbedtls_mpi_uint,
-}
-impl Default for mbedtls_mpi {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/convert-floats.rs b/tests/expectations/tests/convert-floats.rs
deleted file mode 100644
index e710a442..00000000
--- a/tests/expectations/tests/convert-floats.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
-#[repr(C)]
-pub struct __BindgenComplex<T> {
-    pub re: T,
-    pub im: T,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub bar: ::std::os::raw::c_float,
-    pub baz: ::std::os::raw::c_float,
-    pub bazz: ::std::os::raw::c_double,
-    pub bazzz: *mut u128,
-    pub complexFloat: __BindgenComplex<::std::os::raw::c_float>,
-    pub complexDouble: __BindgenComplex<::std::os::raw::c_double>,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        48usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bazz) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bazz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bazzz) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(bazzz)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).complexFloat) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(complexFloat)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).complexDouble) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(complexDouble)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/core_ffi_c.rs b/tests/expectations/tests/core_ffi_c.rs
deleted file mode 100644
index 7e138a89..00000000
--- a/tests/expectations/tests/core_ffi_c.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type c_char = ::core::ffi::c_char;
-pub type c_double = ::core::ffi::c_double;
-pub type c_float = ::core::ffi::c_float;
-pub type c_int = ::core::ffi::c_int;
-pub type c_long = ::core::ffi::c_long;
-pub type c_longlong = ::core::ffi::c_longlong;
-pub type c_schar = ::core::ffi::c_schar;
-pub type c_short = ::core::ffi::c_short;
-pub type c_uchar = ::core::ffi::c_uchar;
-pub type c_uint = ::core::ffi::c_uint;
-pub type c_ulong = ::core::ffi::c_ulong;
-pub type c_ulonglong = ::core::ffi::c_ulonglong;
-pub type c_ushort = ::core::ffi::c_ushort;
diff --git a/tests/expectations/tests/cpp-empty-layout.rs b/tests/expectations/tests/cpp-empty-layout.rs
deleted file mode 100644
index f5ba025a..00000000
--- a/tests/expectations/tests/cpp-empty-layout.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/crtp.rs b/tests/expectations/tests/crtp.rs
deleted file mode 100644
index 2372e211..00000000
--- a/tests/expectations/tests/crtp.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Base {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Derived {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Derived() {
-    assert_eq!(
-        ::std::mem::size_of::<Derived>(),
-        1usize,
-        concat!("Size of: ", stringify!(Derived))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Derived>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Derived))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct BaseWithDestructor {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct DerivedFromBaseWithDestructor {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_DerivedFromBaseWithDestructor() {
-    assert_eq!(
-        ::std::mem::size_of::<DerivedFromBaseWithDestructor>(),
-        1usize,
-        concat!("Size of: ", stringify!(DerivedFromBaseWithDestructor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DerivedFromBaseWithDestructor>(),
-        1usize,
-        concat!("Alignment of ", stringify!(DerivedFromBaseWithDestructor))
-    );
-}
-#[test]
-fn __bindgen_test_layout_Base_open0_Derived_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Base>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(Base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Base>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(Base))
-    );
-}
-#[test]
-fn __bindgen_test_layout_BaseWithDestructor_open0_DerivedFromBaseWithDestructor_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<BaseWithDestructor>(),
-        1usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(BaseWithDestructor)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BaseWithDestructor>(),
-        1usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(BaseWithDestructor)
-        )
-    );
-}
diff --git a/tests/expectations/tests/ctypes-prefix-path.rs b/tests/expectations/tests/ctypes-prefix-path.rs
deleted file mode 100644
index 5b3d186a..00000000
--- a/tests/expectations/tests/ctypes-prefix-path.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![no_std]
-mod libc {
-    pub mod foo {
-        pub type c_int = i32;
-        pub enum c_void {}
-    }
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub a: libc::foo::c_int,
-    pub b: libc::foo::c_int,
-    pub bar: *mut libc::foo::c_void,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::core::mem::MaybeUninit<foo> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/dash_language.rs b/tests/expectations/tests/dash_language.rs
deleted file mode 100644
index eb2bbc76..00000000
--- a/tests/expectations/tests/dash_language.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub bar: ::std::os::raw::c_int,
-}
diff --git a/tests/expectations/tests/decl_extern_int_twice.rs b/tests/expectations/tests/decl_extern_int_twice.rs
deleted file mode 100644
index d812b032..00000000
--- a/tests/expectations/tests/decl_extern_int_twice.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub static mut foo: ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/decl_ptr_to_array.rs b/tests/expectations/tests/decl_ptr_to_array.rs
deleted file mode 100644
index b520f1e0..00000000
--- a/tests/expectations/tests/decl_ptr_to_array.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub static mut foo: *mut [::std::os::raw::c_int; 1usize];
-}
diff --git a/tests/expectations/tests/default-enum-style-constified-module.rs b/tests/expectations/tests/default-enum-style-constified-module.rs
deleted file mode 100644
index 5e225e3d..00000000
--- a/tests/expectations/tests/default-enum-style-constified-module.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod Foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const bar: Type = 0;
-    pub const baz: Type = 1;
-    pub const blap: Type = 2;
-}
-extern "C" {
-    pub fn func(x: Foo::Type);
-}
diff --git a/tests/expectations/tests/default-macro-constant-type-signed.rs b/tests/expectations/tests/default-macro-constant-type-signed.rs
deleted file mode 100644
index 38ebc531..00000000
--- a/tests/expectations/tests/default-macro-constant-type-signed.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const N0: i32 = 0;
-pub const N1: i32 = 1;
-pub const N2: i32 = 2;
-pub const N_1: i32 = -1;
-pub const N_2: i32 = -2;
-pub const MAX_U16: i32 = 65535;
-pub const MAX_I16: i32 = 32767;
-pub const MAX_I16_Plus1: i32 = 32768;
-pub const MAX_U16_Plus1: i32 = 65536;
-pub const MAX_I16_Minus1: i32 = 32766;
-pub const MAX_U16_Minus1: i32 = 65534;
-pub const MIN_U16: i32 = 0;
-pub const MIN_I16: i32 = -32768;
-pub const MIN_U16_Plus1: i32 = 1;
-pub const MIN_I16_Plus1: i32 = -32767;
-pub const MIN_U16_Minus1: i32 = -1;
-pub const MIN_I16_Minus1: i32 = -32769;
-pub const MAX_U32: i64 = 4294967295;
-pub const MAX_I32: i32 = 2147483647;
-pub const MAX_I32_Plus1: i64 = 2147483648;
-pub const MAX_U32_Plus1: i64 = 4294967296;
-pub const MAX_I32_Minus1: i32 = 2147483646;
-pub const MAX_U32_Minus1: i64 = 4294967294;
-pub const MIN_U32: i32 = 0;
-pub const MIN_I32: i32 = -2147483648;
-pub const MIN_U32_Plus1: i32 = 1;
-pub const MIN_I32_Plus1: i32 = -2147483647;
-pub const MIN_U32_Minus1: i32 = -1;
-pub const MIN_I32_Minus1: i64 = -2147483649;
-pub const LONG12: i64 = 123456789012;
-pub const LONG_12: i64 = -123456789012;
-extern "C" {
-    pub fn foo(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_uint,
-        arg4: ::std::os::raw::c_char,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: ::std::os::raw::c_schar,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(
-        arg1: ::std::os::raw::c_long,
-        arg2: ::std::os::raw::c_longlong,
-    ) -> ::std::os::raw::c_long;
-}
diff --git a/tests/expectations/tests/default-macro-constant-type-unsigned.rs b/tests/expectations/tests/default-macro-constant-type-unsigned.rs
deleted file mode 100644
index 5571563b..00000000
--- a/tests/expectations/tests/default-macro-constant-type-unsigned.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const N0: u32 = 0;
-pub const N1: u32 = 1;
-pub const N2: u32 = 2;
-pub const N_1: i32 = -1;
-pub const N_2: i32 = -2;
-pub const MAX_U16: u32 = 65535;
-pub const MAX_I16: u32 = 32767;
-pub const MAX_I16_Plus1: u32 = 32768;
-pub const MAX_U16_Plus1: u32 = 65536;
-pub const MAX_I16_Minus1: u32 = 32766;
-pub const MAX_U16_Minus1: u32 = 65534;
-pub const MIN_U16: u32 = 0;
-pub const MIN_I16: i32 = -32768;
-pub const MIN_U16_Plus1: u32 = 1;
-pub const MIN_I16_Plus1: i32 = -32767;
-pub const MIN_U16_Minus1: i32 = -1;
-pub const MIN_I16_Minus1: i32 = -32769;
-pub const MAX_U32: u32 = 4294967295;
-pub const MAX_I32: u32 = 2147483647;
-pub const MAX_I32_Plus1: u32 = 2147483648;
-pub const MAX_U32_Plus1: u64 = 4294967296;
-pub const MAX_I32_Minus1: u32 = 2147483646;
-pub const MAX_U32_Minus1: u32 = 4294967294;
-pub const MIN_U32: u32 = 0;
-pub const MIN_I32: i32 = -2147483648;
-pub const MIN_U32_Plus1: u32 = 1;
-pub const MIN_I32_Plus1: i32 = -2147483647;
-pub const MIN_U32_Minus1: i32 = -1;
-pub const MIN_I32_Minus1: i64 = -2147483649;
-pub const LONG12: u64 = 123456789012;
-pub const LONG_12: i64 = -123456789012;
-extern "C" {
-    pub fn foo(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_uint,
-        arg4: ::std::os::raw::c_char,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: ::std::os::raw::c_schar,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(
-        arg1: ::std::os::raw::c_long,
-        arg2: ::std::os::raw::c_longlong,
-    ) -> ::std::os::raw::c_long;
-}
diff --git a/tests/expectations/tests/default-macro-constant-type.rs b/tests/expectations/tests/default-macro-constant-type.rs
deleted file mode 100644
index 5571563b..00000000
--- a/tests/expectations/tests/default-macro-constant-type.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const N0: u32 = 0;
-pub const N1: u32 = 1;
-pub const N2: u32 = 2;
-pub const N_1: i32 = -1;
-pub const N_2: i32 = -2;
-pub const MAX_U16: u32 = 65535;
-pub const MAX_I16: u32 = 32767;
-pub const MAX_I16_Plus1: u32 = 32768;
-pub const MAX_U16_Plus1: u32 = 65536;
-pub const MAX_I16_Minus1: u32 = 32766;
-pub const MAX_U16_Minus1: u32 = 65534;
-pub const MIN_U16: u32 = 0;
-pub const MIN_I16: i32 = -32768;
-pub const MIN_U16_Plus1: u32 = 1;
-pub const MIN_I16_Plus1: i32 = -32767;
-pub const MIN_U16_Minus1: i32 = -1;
-pub const MIN_I16_Minus1: i32 = -32769;
-pub const MAX_U32: u32 = 4294967295;
-pub const MAX_I32: u32 = 2147483647;
-pub const MAX_I32_Plus1: u32 = 2147483648;
-pub const MAX_U32_Plus1: u64 = 4294967296;
-pub const MAX_I32_Minus1: u32 = 2147483646;
-pub const MAX_U32_Minus1: u32 = 4294967294;
-pub const MIN_U32: u32 = 0;
-pub const MIN_I32: i32 = -2147483648;
-pub const MIN_U32_Plus1: u32 = 1;
-pub const MIN_I32_Plus1: i32 = -2147483647;
-pub const MIN_U32_Minus1: i32 = -1;
-pub const MIN_I32_Minus1: i64 = -2147483649;
-pub const LONG12: u64 = 123456789012;
-pub const LONG_12: i64 = -123456789012;
-extern "C" {
-    pub fn foo(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_uint,
-        arg4: ::std::os::raw::c_char,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: ::std::os::raw::c_schar,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(
-        arg1: ::std::os::raw::c_long,
-        arg2: ::std::os::raw::c_longlong,
-    ) -> ::std::os::raw::c_long;
-}
diff --git a/tests/expectations/tests/default-template-parameter.rs b/tests/expectations/tests/default-template-parameter.rs
deleted file mode 100644
index 2cbe463c..00000000
--- a/tests/expectations/tests/default-template-parameter.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo<T, U> {
-    pub t: T,
-    pub u: U,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<T, U> Default for Foo<T, U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_Foo_open0_bool__int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo<bool, ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify ! (Foo < bool , :: std :: os :: raw :: c_int >)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo<bool, ::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify ! (Foo < bool , :: std :: os :: raw :: c_int >)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZL3bar"]
-    pub static mut bar: Foo<bool, ::std::os::raw::c_int>;
-}
diff --git a/tests/expectations/tests/deleted-function.rs b/tests/expectations/tests/deleted-function.rs
deleted file mode 100644
index 96967bb4..00000000
--- a/tests/expectations/tests/deleted-function.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1A17inline_definitionEv"]
-    pub fn A_inline_definition(this: *mut A);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1A22out_of_line_definitionEv"]
-    pub fn A_out_of_line_definition(this: *mut A);
-}
-impl A {
-    #[inline]
-    pub unsafe fn inline_definition(&mut self) {
-        A_inline_definition(self)
-    }
-    #[inline]
-    pub unsafe fn out_of_line_definition(&mut self) {
-        A_out_of_line_definition(self)
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct B {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        1usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        1usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        1usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        1usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1CC1ERS_"]
-    pub fn C_C(this: *mut C, arg1: *mut C);
-}
-impl C {
-    #[inline]
-    pub unsafe fn new(arg1: *mut C) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        C_C(__bindgen_tmp.as_mut_ptr(), arg1);
-        __bindgen_tmp.assume_init()
-    }
-}
diff --git a/tests/expectations/tests/derive-bitfield-method-same-name.rs b/tests/expectations/tests/derive-bitfield-method-same-name.rs
deleted file mode 100644
index ea6621dd..00000000
--- a/tests/expectations/tests/derive-bitfield-method-same-name.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-/// Because this struct have array larger than 32 items
-/// and --with-derive-partialeq --impl-partialeq --impl-debug is provided,
-/// this struct should manually implement `Debug` and `PartialEq`.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Foo {
-    pub large: [::std::os::raw::c_int; 33usize],
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-    pub __bindgen_padding_0: u16,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        136usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(large)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo4typeEv"]
-    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo9set_type_Ec"]
-    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo8set_typeEc"]
-    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
-}
-impl Default for Foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for Foo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(
-            f,
-            "Foo {{ large: [{}], type_ : {:?},  }}",
-            self.large
-                .iter()
-                .enumerate()
-                .map(|(i, v)| format!(
-                    "{}{:?}",
-                    if i > 0 { ", " } else { "" },
-                    v
-                ))
-                .collect::<String>(),
-            self.type__bindgen_bitfield()
-        )
-    }
-}
-impl ::std::cmp::PartialEq for Foo {
-    fn eq(&self, other: &Foo) -> bool {
-        &self.large[..] == &other.large[..] &&
-            self.type__bindgen_bitfield() == other.type__bindgen_bitfield()
-    }
-}
-impl Foo {
-    #[inline]
-    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        type__bindgen_bitfield: ::std::os::raw::c_char,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let type__bindgen_bitfield: u8 =
-                unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
-            type__bindgen_bitfield as u64
-        });
-        __bindgen_bitfield_unit
-    }
-    #[inline]
-    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
-        Foo_type(self)
-    }
-    #[inline]
-    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) {
-        Foo_set_type_(self, c)
-    }
-    #[inline]
-    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) {
-        Foo_set_type(self, c)
-    }
-}
diff --git a/tests/expectations/tests/derive-clone.rs b/tests/expectations/tests/derive-clone.rs
deleted file mode 100644
index 19c28b69..00000000
--- a/tests/expectations/tests/derive-clone.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This struct should derive `Clone`.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ShouldDeriveClone {
-    pub large: [::std::os::raw::c_int; 33usize],
-}
-#[test]
-fn bindgen_test_layout_ShouldDeriveClone() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldDeriveClone> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldDeriveClone>(),
-        132usize,
-        concat!("Size of: ", stringify!(ShouldDeriveClone))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldDeriveClone>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ShouldDeriveClone))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldDeriveClone),
-            "::",
-            stringify!(large)
-        )
-    );
-}
-impl Default for ShouldDeriveClone {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-clone_1_0.rs b/tests/expectations/tests/derive-clone_1_0.rs
deleted file mode 100644
index 3d72db2f..00000000
--- a/tests/expectations/tests/derive-clone_1_0.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Since builtin `Clone` impls were introduced in Rust 1.21 this struct
-/// should impl `Clone` "manually".
-#[repr(C)]
-#[derive(Copy)]
-pub struct ShouldImplClone {
-    pub large: [::std::os::raw::c_int; 33usize],
-}
-#[test]
-fn bindgen_test_layout_ShouldImplClone() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldImplClone> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldImplClone>(),
-        132usize,
-        concat!("Size of: ", stringify!(ShouldImplClone))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldImplClone>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ShouldImplClone))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldImplClone),
-            "::",
-            stringify!(large)
-        )
-    );
-}
-impl Clone for ShouldImplClone {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for ShouldImplClone {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-custom.rs b/tests/expectations/tests/derive-custom.rs
deleted file mode 100644
index 542b6bb2..00000000
--- a/tests/expectations/tests/derive-custom.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen derive="Debug"></div>
-#[repr(C)]
-#[derive(Default, Debug)]
-pub struct my_type {
-    pub a: ::std::os::raw::c_int,
-}
-/// <div rustbindgen derive="Debug"></div>
-/// <div rustbindgen derive="Clone"></div>
-#[repr(C)]
-#[derive(Default, Debug, Clone)]
-pub struct my_type2 {
-    pub a: ::std::os::raw::c_uint,
-}
-/// <div rustbindgen derive="Debug" derive="Clone"></div>
-#[repr(C)]
-#[derive(Default, Debug, Clone)]
-pub struct my_type3 {
-    pub a: ::std::os::raw::c_ulong,
-}
diff --git a/tests/expectations/tests/derive-debug-bitfield-core.rs b/tests/expectations/tests/derive-debug-bitfield-core.rs
deleted file mode 100644
index 2a78e930..00000000
--- a/tests/expectations/tests/derive-debug-bitfield-core.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate core;
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub large_array: [::std::os::raw::c_int; 50usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::core::mem::MaybeUninit<C> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<C>(),
-        204usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe {
-            ::core::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::core::fmt::Debug for C {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-        write!(
-            f,
-            "C {{ a : {:?}, b : {:?}, large_array: [...] }}",
-            self.a(),
-            self.b()
-        )
-    }
-}
-impl C {
-    #[inline]
-    pub fn a(&self) -> bool {
-        unsafe {
-            ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::core::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> bool {
-        unsafe {
-            ::core::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::core::mem::transmute(val);
-            self._bitfield_1.set(1usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: bool,
-        b: bool,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::core::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 7u8, {
-            let b: u8 = unsafe { ::core::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-bitfield.rs b/tests/expectations/tests/derive-debug-bitfield.rs
deleted file mode 100644
index 0ae8f329..00000000
--- a/tests/expectations/tests/derive-debug-bitfield.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub large_array: [::std::os::raw::c_int; 50usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        204usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for C {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(
-            f,
-            "C {{ a : {:?}, b : {:?}, large_array: [{}] }}",
-            self.a(),
-            self.b(),
-            self.large_array
-                .iter()
-                .enumerate()
-                .map(|(i, v)| format!(
-                    "{}{:?}",
-                    if i > 0 { ", " } else { "" },
-                    v
-                ))
-                .collect::<String>()
-        )
-    }
-}
-impl C {
-    #[inline]
-    pub fn a(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: bool,
-        b: bool,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 7u8, {
-            let b: u8 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-function-pointer.rs b/tests/expectations/tests/derive-debug-function-pointer.rs
deleted file mode 100644
index 16b127bf..00000000
--- a/tests/expectations/tests/derive-debug-function-pointer.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Nice {
-    pub pointer: Nice_Function,
-    pub large_array: [::std::os::raw::c_int; 34usize],
-}
-pub type Nice_Function =
-    ::std::option::Option<unsafe extern "C" fn(data: ::std::os::raw::c_int)>;
-#[test]
-fn bindgen_test_layout_Nice() {
-    const UNINIT: ::std::mem::MaybeUninit<Nice> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Nice>(),
-        144usize,
-        concat!("Size of: ", stringify!(Nice))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Nice>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Nice))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pointer) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Nice),
-            "::",
-            stringify!(pointer)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Nice),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for Nice {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for Nice {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(
-            f,
-            "Nice {{ pointer: {:?}, large_array: [{}] }}",
-            self.pointer,
-            self.large_array
-                .iter()
-                .enumerate()
-                .map(|(i, v)| format!(
-                    "{}{:?}",
-                    if i > 0 { ", " } else { "" },
-                    v
-                ))
-                .collect::<String>()
-        )
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-generic.rs b/tests/expectations/tests/derive-debug-generic.rs
deleted file mode 100644
index 49d4e9b8..00000000
--- a/tests/expectations/tests/derive-debug-generic.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Generic<T> {
-    pub t: [T; 40usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Generic<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> ::std::fmt::Debug for Generic<T> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "Generic {{ t: Array with length 40 }}")
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-mangle-name.rs b/tests/expectations/tests/derive-debug-mangle-name.rs
deleted file mode 100644
index a757d679..00000000
--- a/tests/expectations/tests/derive-debug-mangle-name.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct perf_event_attr {
-    pub type_: ::std::os::raw::c_uint,
-    pub a: f32,
-    pub __bindgen_anon_1: perf_event_attr__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union perf_event_attr__bindgen_ty_1 {
-    pub b: ::std::os::raw::c_int,
-    pub c: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_perf_event_attr__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<perf_event_attr__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<perf_event_attr__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(perf_event_attr__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<perf_event_attr__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(perf_event_attr__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(perf_event_attr__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(perf_event_attr__bindgen_ty_1),
-            "::",
-            stringify!(c)
-        )
-    );
-}
-impl Default for perf_event_attr__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_1 {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "perf_event_attr__bindgen_ty_1 {{ union }}")
-    }
-}
-#[test]
-fn bindgen_test_layout_perf_event_attr() {
-    const UNINIT: ::std::mem::MaybeUninit<perf_event_attr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<perf_event_attr>(),
-        12usize,
-        concat!("Size of: ", stringify!(perf_event_attr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<perf_event_attr>(),
-        4usize,
-        concat!("Alignment of ", stringify!(perf_event_attr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(perf_event_attr),
-            "::",
-            stringify!(type_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(perf_event_attr),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for perf_event_attr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for perf_event_attr {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(
-            f,
-            "perf_event_attr {{ type: {:?}, a: {:?}, __bindgen_anon_1: {:?} }}",
-            self.type_, self.a, self.__bindgen_anon_1
-        )
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs b/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
deleted file mode 100644
index a0cc87ff..00000000
--- a/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Instance {
-    pub val: [u32; 50usize],
-}
-#[test]
-fn bindgen_test_layout_Instance() {
-    const UNINIT: ::std::mem::MaybeUninit<Instance> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Instance>(),
-        200usize,
-        concat!("Size of: ", stringify!(Instance))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Instance>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Instance))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Instance),
-            "::",
-            stringify!(val)
-        )
-    );
-}
-impl Default for Instance {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for Instance {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "Instance {{ val: opaque }}")
-    }
-}
diff --git a/tests/expectations/tests/derive-debug-opaque.rs b/tests/expectations/tests/derive-debug-opaque.rs
deleted file mode 100644
index 5cebc9b8..00000000
--- a/tests/expectations/tests/derive-debug-opaque.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-pub struct Opaque {
-    pub _bindgen_opaque_blob: [u32; 41usize],
-}
-#[test]
-fn bindgen_test_layout_Opaque() {
-    assert_eq!(
-        ::std::mem::size_of::<Opaque>(),
-        164usize,
-        concat!("Size of: ", stringify!(Opaque))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Opaque>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Opaque))
-    );
-}
-impl Default for Opaque {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for Opaque {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "Opaque {{ opaque }}")
-    }
-}
-#[repr(C)]
-pub struct OpaqueUser {
-    pub opaque: Opaque,
-}
-#[test]
-fn bindgen_test_layout_OpaqueUser() {
-    const UNINIT: ::std::mem::MaybeUninit<OpaqueUser> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<OpaqueUser>(),
-        164usize,
-        concat!("Size of: ", stringify!(OpaqueUser))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<OpaqueUser>(),
-        4usize,
-        concat!("Alignment of ", stringify!(OpaqueUser))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(OpaqueUser),
-            "::",
-            stringify!(opaque)
-        )
-    );
-}
-impl Default for OpaqueUser {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::fmt::Debug for OpaqueUser {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "OpaqueUser {{ opaque: {:?} }}", self.opaque)
-    }
-}
diff --git a/tests/expectations/tests/derive-default-and-blocklist.rs b/tests/expectations/tests/derive-default-and-blocklist.rs
deleted file mode 100644
index fe3790c2..00000000
--- a/tests/expectations/tests/derive-default-and-blocklist.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub struct BlocklistMe(u8);
-
-/// Because this type contains a blocklisted type, it should not derive
-/// Default. Instead, we should emit a `mem::zeroed` implementation.
-#[repr(C)]
-pub struct ShouldNotDeriveDefault {
-    pub a: BlocklistMe,
-}
-#[test]
-fn bindgen_test_layout_ShouldNotDeriveDefault() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDeriveDefault> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldNotDeriveDefault>(),
-        1usize,
-        concat!("Size of: ", stringify!(ShouldNotDeriveDefault))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldNotDeriveDefault>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ShouldNotDeriveDefault))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotDeriveDefault),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for ShouldNotDeriveDefault {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-fn-ptr.rs b/tests/expectations/tests/derive-fn-ptr.rs
deleted file mode 100644
index 9da0a40a..00000000
--- a/tests/expectations/tests/derive-fn-ptr.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type my_fun_t = ::std::option::Option<
-    unsafe extern "C" fn(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-        arg4: ::std::os::raw::c_int,
-        arg5: ::std::os::raw::c_int,
-        arg6: ::std::os::raw::c_int,
-        arg7: ::std::os::raw::c_int,
-        arg8: ::std::os::raw::c_int,
-        arg9: ::std::os::raw::c_int,
-        arg10: ::std::os::raw::c_int,
-        arg11: ::std::os::raw::c_int,
-        arg12: ::std::os::raw::c_int,
-        arg13: ::std::os::raw::c_int,
-        arg14: ::std::os::raw::c_int,
-        arg15: ::std::os::raw::c_int,
-        arg16: ::std::os::raw::c_int,
-    ),
->;
-#[repr(C)]
-#[derive(Default, Copy, Clone)]
-pub struct Foo {
-    pub callback: my_fun_t,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(callback)
-        )
-    );
-}
-pub type my_fun2_t = ::std::option::Option<
-    unsafe extern "C" fn(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-        arg4: ::std::os::raw::c_int,
-        arg5: ::std::os::raw::c_int,
-        arg6: ::std::os::raw::c_int,
-        arg7: ::std::os::raw::c_int,
-        arg8: ::std::os::raw::c_int,
-        arg9: ::std::os::raw::c_int,
-        arg10: ::std::os::raw::c_int,
-        arg11: ::std::os::raw::c_int,
-        arg12: ::std::os::raw::c_int,
-    ),
->;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Bar {
-    pub callback: my_fun2_t,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(callback)
-        )
-    );
-}
diff --git a/tests/expectations/tests/derive-hash-and-blocklist.rs b/tests/expectations/tests/derive-hash-and-blocklist.rs
deleted file mode 100644
index c677b15e..00000000
--- a/tests/expectations/tests/derive-hash-and-blocklist.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub struct BlocklistMe(u8);
-
-/// Because this type contains a blocklisted type, it should not derive Hash.
-#[repr(C)]
-pub struct ShouldNotDeriveHash {
-    pub a: BlocklistMe,
-}
-#[test]
-fn bindgen_test_layout_ShouldNotDeriveHash() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDeriveHash> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldNotDeriveHash>(),
-        1usize,
-        concat!("Size of: ", stringify!(ShouldNotDeriveHash))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldNotDeriveHash>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ShouldNotDeriveHash))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotDeriveHash),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for ShouldNotDeriveHash {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-hash-blocklisting.rs b/tests/expectations/tests/derive-hash-blocklisting.rs
deleted file mode 100644
index 868bf9f2..00000000
--- a/tests/expectations/tests/derive-hash-blocklisting.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
-pub struct Blocklisted<T> {
-    t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-
-/// This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type,
-/// causing us to conservatively avoid deriving hash/Eq/PartialEq for it.
-#[repr(C)]
-pub struct AllowlistedOne {
-    pub a: Blocklisted<::std::os::raw::c_int>,
-}
-#[test]
-fn bindgen_test_layout_AllowlistedOne() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistedOne> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistedOne>(),
-        4usize,
-        concat!("Size of: ", stringify!(AllowlistedOne))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistedOne>(),
-        4usize,
-        concat!("Alignment of ", stringify!(AllowlistedOne))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistedOne),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for AllowlistedOne {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type.
-#[repr(C)]
-pub struct AllowlistedTwo {
-    pub b: Blocklisted<f32>,
-}
-#[test]
-fn bindgen_test_layout_AllowlistedTwo() {
-    const UNINIT: ::std::mem::MaybeUninit<AllowlistedTwo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AllowlistedTwo>(),
-        4usize,
-        concat!("Size of: ", stringify!(AllowlistedTwo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AllowlistedTwo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(AllowlistedTwo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AllowlistedTwo),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for AllowlistedTwo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs b/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
deleted file mode 100644
index 78c8449b..00000000
--- a/tests/expectations/tests/derive-hash-struct-with-anon-struct-float.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: f32,
-    pub b: f32,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/derive-hash-struct-with-float-array.rs b/tests/expectations/tests/derive-hash-struct-with-float-array.rs
deleted file mode 100644
index a3f6013b..00000000
--- a/tests/expectations/tests/derive-hash-struct-with-float-array.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
-pub struct foo {
-    pub bar: [f32; 3usize],
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        12usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs b/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
deleted file mode 100644
index 06c8da1b..00000000
--- a/tests/expectations/tests/derive-hash-struct-with-incomplete-array.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test() {
-    const UNINIT: ::std::mem::MaybeUninit<test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<test>(),
-        4usize,
-        concat!("Size of: ", stringify!(test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(test), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(test),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test2() {
-    assert_eq!(
-        ::std::mem::size_of::<test2>(),
-        4usize,
-        concat!("Size of: ", stringify!(test2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test2))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test3 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test3() {
-    assert_eq!(
-        ::std::mem::size_of::<test3>(),
-        4usize,
-        concat!("Size of: ", stringify!(test3))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test3>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test3))
-    );
-}
diff --git a/tests/expectations/tests/derive-hash-struct-with-pointer.rs b/tests/expectations/tests/derive-hash-struct-with-pointer.rs
deleted file mode 100644
index 3efd55c9..00000000
--- a/tests/expectations/tests/derive-hash-struct-with-pointer.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct ConstPtrMutObj {
-    pub bar: *mut ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ConstPtrMutObj() {
-    const UNINIT: ::std::mem::MaybeUninit<ConstPtrMutObj> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ConstPtrMutObj>(),
-        8usize,
-        concat!("Size of: ", stringify!(ConstPtrMutObj))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ConstPtrMutObj>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ConstPtrMutObj))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ConstPtrMutObj),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for ConstPtrMutObj {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct MutPtrMutObj {
-    pub bar: *mut ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_MutPtrMutObj() {
-    const UNINIT: ::std::mem::MaybeUninit<MutPtrMutObj> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<MutPtrMutObj>(),
-        8usize,
-        concat!("Size of: ", stringify!(MutPtrMutObj))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MutPtrMutObj>(),
-        8usize,
-        concat!("Alignment of ", stringify!(MutPtrMutObj))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(MutPtrMutObj),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for MutPtrMutObj {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct MutPtrConstObj {
-    pub bar: *const ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_MutPtrConstObj() {
-    const UNINIT: ::std::mem::MaybeUninit<MutPtrConstObj> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<MutPtrConstObj>(),
-        8usize,
-        concat!("Size of: ", stringify!(MutPtrConstObj))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MutPtrConstObj>(),
-        8usize,
-        concat!("Alignment of ", stringify!(MutPtrConstObj))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(MutPtrConstObj),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for MutPtrConstObj {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct ConstPtrConstObj {
-    pub bar: *const ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ConstPtrConstObj() {
-    const UNINIT: ::std::mem::MaybeUninit<ConstPtrConstObj> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ConstPtrConstObj>(),
-        8usize,
-        concat!("Size of: ", stringify!(ConstPtrConstObj))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ConstPtrConstObj>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ConstPtrConstObj))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ConstPtrConstObj),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for ConstPtrConstObj {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-hash-template-def-float.rs b/tests/expectations/tests/derive-hash-template-def-float.rs
deleted file mode 100644
index 5e07a611..00000000
--- a/tests/expectations/tests/derive-hash-template-def-float.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
-pub struct foo<T> {
-    pub data: T,
-    pub b: f32,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for foo<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-hash-template-inst-float.rs b/tests/expectations/tests/derive-hash-template-inst-float.rs
deleted file mode 100644
index b2e2d8d0..00000000
--- a/tests/expectations/tests/derive-hash-template-inst-float.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct foo<T> {
-    pub data: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for foo<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct IntStr {
-    pub a: foo<::std::os::raw::c_int>,
-}
-#[test]
-fn bindgen_test_layout_IntStr() {
-    const UNINIT: ::std::mem::MaybeUninit<IntStr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<IntStr>(),
-        4usize,
-        concat!("Size of: ", stringify!(IntStr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<IntStr>(),
-        4usize,
-        concat!("Alignment of ", stringify!(IntStr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(IntStr), "::", stringify!(a))
-    );
-}
-impl Default for IntStr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd
-#[repr(C)]
-#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
-pub struct FloatStr {
-    pub a: foo<f32>,
-}
-#[test]
-fn bindgen_test_layout_FloatStr() {
-    const UNINIT: ::std::mem::MaybeUninit<FloatStr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<FloatStr>(),
-        4usize,
-        concat!("Size of: ", stringify!(FloatStr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<FloatStr>(),
-        4usize,
-        concat!("Alignment of ", stringify!(FloatStr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(FloatStr),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for FloatStr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_foo_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<foo<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(foo<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(foo<::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_foo_open0_float_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<foo<f32>>(),
-        4usize,
-        concat!("Size of template specialization: ", stringify!(foo<f32>))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo<f32>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(foo<f32>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/derive-partialeq-and-blocklist.rs b/tests/expectations/tests/derive-partialeq-and-blocklist.rs
deleted file mode 100644
index c772c0b9..00000000
--- a/tests/expectations/tests/derive-partialeq-and-blocklist.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub struct BlocklistMe(u8);
-
-/// Because this type contains a blocklisted type, it should not derive
-/// PartialEq.
-#[repr(C)]
-pub struct ShouldNotDerivePartialEq {
-    pub a: BlocklistMe,
-}
-#[test]
-fn bindgen_test_layout_ShouldNotDerivePartialEq() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDerivePartialEq> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldNotDerivePartialEq>(),
-        1usize,
-        concat!("Size of: ", stringify!(ShouldNotDerivePartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldNotDerivePartialEq>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ShouldNotDerivePartialEq))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotDerivePartialEq),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for ShouldNotDerivePartialEq {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-anonfield.rs b/tests/expectations/tests/derive-partialeq-anonfield.rs
deleted file mode 100644
index 16d4381f..00000000
--- a/tests/expectations/tests/derive-partialeq-anonfield.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct rte_mbuf {
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
-}
-#[repr(C)]
-#[repr(align(1))]
-#[derive(Copy, Clone)]
-pub struct rte_mbuf__bindgen_ty_1 {
-    pub bindgen_union_field: [u8; 0usize],
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
-        0usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf>(),
-        0usize,
-        concat!("Size of: ", stringify!(rte_mbuf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_mbuf))
-    );
-}
-impl Default for rte_mbuf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-base.rs b/tests/expectations/tests/derive-partialeq-base.rs
deleted file mode 100644
index 840720f2..00000000
--- a/tests/expectations/tests/derive-partialeq-base.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Base {
-    pub large: [::std::os::raw::c_int; 33usize],
-}
-#[test]
-fn bindgen_test_layout_Base() {
-    const UNINIT: ::std::mem::MaybeUninit<Base> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Base>(),
-        132usize,
-        concat!("Size of: ", stringify!(Base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Base>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Base))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).large) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Base),
-            "::",
-            stringify!(large)
-        )
-    );
-}
-impl Default for Base {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for Base {
-    fn eq(&self, other: &Base) -> bool {
-        &self.large[..] == &other.large[..]
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ShouldDerivePartialEq {
-    pub _base: Base,
-}
-#[test]
-fn bindgen_test_layout_ShouldDerivePartialEq() {
-    assert_eq!(
-        ::std::mem::size_of::<ShouldDerivePartialEq>(),
-        132usize,
-        concat!("Size of: ", stringify!(ShouldDerivePartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldDerivePartialEq>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ShouldDerivePartialEq))
-    );
-}
-impl Default for ShouldDerivePartialEq {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for ShouldDerivePartialEq {
-    fn eq(&self, other: &ShouldDerivePartialEq) -> bool {
-        self._base == other._base
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-bitfield.rs b/tests/expectations/tests/derive-partialeq-bitfield.rs
deleted file mode 100644
index cb9781de..00000000
--- a/tests/expectations/tests/derive-partialeq-bitfield.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub large_array: [::std::os::raw::c_int; 50usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        204usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for C {
-    fn eq(&self, other: &C) -> bool {
-        self.a() == other.a() &&
-            self.b() == other.b() &&
-            &self.large_array[..] == &other.large_array[..]
-    }
-}
-impl C {
-    #[inline]
-    pub fn a(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: bool,
-        b: bool,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 7u8, {
-            let b: u8 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-core.rs b/tests/expectations/tests/derive-partialeq-core.rs
deleted file mode 100644
index 620b40fa..00000000
--- a/tests/expectations/tests/derive-partialeq-core.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate core;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub large_array: [::std::os::raw::c_int; 420usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::core::mem::MaybeUninit<C> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<C>(),
-        1680usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe {
-            ::core::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::core::cmp::PartialEq for C {
-    fn eq(&self, other: &C) -> bool {
-        &self.large_array[..] == &other.large_array[..]
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-pointer.rs b/tests/expectations/tests/derive-partialeq-pointer.rs
deleted file mode 100644
index e0d3c062..00000000
--- a/tests/expectations/tests/derive-partialeq-pointer.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Bar {
-    pub b: *mut a,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(b))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct c {
-    pub __bindgen_anon_1: c__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union c__bindgen_ty_1 {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_c__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<c__bindgen_ty_1>(),
-        1usize,
-        concat!("Size of: ", stringify!(c__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<c__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(c__bindgen_ty_1))
-    );
-}
-impl Default for c__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_c() {
-    assert_eq!(
-        ::std::mem::size_of::<c>(),
-        1usize,
-        concat!("Size of: ", stringify!(c))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<c>(),
-        1usize,
-        concat!("Alignment of ", stringify!(c))
-    );
-}
-impl Default for c {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct a {
-    pub d: c,
-}
-#[test]
-fn bindgen_test_layout_a() {
-    const UNINIT: ::std::mem::MaybeUninit<a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        1usize,
-        concat!("Size of: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        1usize,
-        concat!("Alignment of ", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(d))
-    );
-}
-impl Default for a {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-union.rs b/tests/expectations/tests/derive-partialeq-union.rs
deleted file mode 100644
index 5ffd0bcd..00000000
--- a/tests/expectations/tests/derive-partialeq-union.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Deriving PartialEq for rust unions is not supported.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ShouldNotDerivePartialEq {
-    pub a: ::std::os::raw::c_char,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ShouldNotDerivePartialEq() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldNotDerivePartialEq> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldNotDerivePartialEq>(),
-        4usize,
-        concat!("Size of: ", stringify!(ShouldNotDerivePartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldNotDerivePartialEq>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ShouldNotDerivePartialEq))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotDerivePartialEq),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotDerivePartialEq),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for ShouldNotDerivePartialEq {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/derive-partialeq-union_1_0.rs b/tests/expectations/tests/derive-partialeq-union_1_0.rs
deleted file mode 100644
index a53b9ba8..00000000
--- a/tests/expectations/tests/derive-partialeq-union_1_0.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-/// This should manually derive PartialEq.
-#[repr(C)]
-#[derive(Copy)]
-pub struct ShouldDerivePartialEq {
-    pub a: __BindgenUnionField<[::std::os::raw::c_char; 150usize]>,
-    pub b: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: [u32; 38usize],
-}
-#[test]
-fn bindgen_test_layout_ShouldDerivePartialEq() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldDerivePartialEq> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldDerivePartialEq>(),
-        152usize,
-        concat!("Size of: ", stringify!(ShouldDerivePartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldDerivePartialEq>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ShouldDerivePartialEq))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldDerivePartialEq),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldDerivePartialEq),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for ShouldDerivePartialEq {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for ShouldDerivePartialEq {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl ::std::cmp::PartialEq for ShouldDerivePartialEq {
-    fn eq(&self, other: &ShouldDerivePartialEq) -> bool {
-        &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
-    }
-}
diff --git a/tests/expectations/tests/disable-namespacing.rs b/tests/expectations/tests/disable-namespacing.rs
deleted file mode 100644
index 626bb060..00000000
--- a/tests/expectations/tests/disable-namespacing.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type Baz = ::std::os::raw::c_int;
diff --git a/tests/expectations/tests/disable-nested-struct-naming.rs b/tests/expectations/tests/disable-nested-struct-naming.rs
deleted file mode 100644
index ce8a01ad..00000000
--- a/tests/expectations/tests/disable-nested-struct-naming.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {
-    pub b1: bar1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct bar1 {
-    pub x1: ::std::os::raw::c_int,
-    pub b2: bar1__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct bar1__bindgen_ty_1 {
-    pub x2: ::std::os::raw::c_int,
-    pub b3: bar1__bindgen_ty_1__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct bar1__bindgen_ty_1__bindgen_ty_1 {
-    pub x3: ::std::os::raw::c_int,
-    pub b4: bar4,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct bar4 {
-    pub x4: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_bar4() {
-    const UNINIT: ::std::mem::MaybeUninit<bar4> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar4>(),
-        4usize,
-        concat!("Size of: ", stringify!(bar4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar4>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar4))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x4) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(bar4), "::", stringify!(x4))
-    );
-}
-#[test]
-fn bindgen_test_layout_bar1__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<bar1__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar1__bindgen_ty_1__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(bar1__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar1__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(bar1__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x3) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar1__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(x3)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b4) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar1__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b4)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_bar1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<bar1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar1__bindgen_ty_1>(),
-        12usize,
-        concat!("Size of: ", stringify!(bar1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar1__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar1__bindgen_ty_1),
-            "::",
-            stringify!(x2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b3) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bar1__bindgen_ty_1),
-            "::",
-            stringify!(b3)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_bar1() {
-    const UNINIT: ::std::mem::MaybeUninit<bar1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar1>(),
-        16usize,
-        concat!("Size of: ", stringify!(bar1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x1) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(bar1), "::", stringify!(x1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(bar1), "::", stringify!(b2))
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b1))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct _bindgen_ty_1 {
-    pub anon2: _bindgen_ty_1__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct _bindgen_ty_1__bindgen_ty_1 {
-    pub b: baz,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct baz {
-    pub x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_baz() {
-    const UNINIT: ::std::mem::MaybeUninit<baz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<baz>(),
-        4usize,
-        concat!("Size of: ", stringify!(baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<baz>(),
-        4usize,
-        concat!("Alignment of ", stringify!(baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(baz), "::", stringify!(x))
-    );
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<_bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<_bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<_bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<_bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).anon2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(anon2)
-        )
-    );
-}
-extern "C" {
-    pub static mut anon1: _bindgen_ty_1;
-}
diff --git a/tests/expectations/tests/disable-untagged-union.rs b/tests/expectations/tests/disable-untagged-union.rs
deleted file mode 100644
index 515f496b..00000000
--- a/tests/expectations/tests/disable-untagged-union.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
-    pub baz: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(baz))
-    );
-}
diff --git a/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
deleted file mode 100644
index 721d71e2..00000000
--- a/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithBitfield {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub a: ::std::os::raw::c_uint,
-}
-impl WithBitfield {
-    #[inline]
-    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithBitfieldAndAttrPacked {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub a: ::std::os::raw::c_uint,
-}
-impl WithBitfieldAndAttrPacked {
-    #[inline]
-    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithBitfieldAndPacked {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub a: ::std::os::raw::c_uint,
-}
-impl WithBitfieldAndPacked {
-    #[inline]
-    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/do-not-derive-copy.rs b/tests/expectations/tests/do-not-derive-copy.rs
deleted file mode 100644
index 4f9081ad..00000000
--- a/tests/expectations/tests/do-not-derive-copy.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct WouldBeCopyButWeAreNotDerivingCopy {
-    pub x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WouldBeCopyButWeAreNotDerivingCopy() {
-    const UNINIT: ::std::mem::MaybeUninit<WouldBeCopyButWeAreNotDerivingCopy> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WouldBeCopyButWeAreNotDerivingCopy>(),
-        4usize,
-        concat!("Size of: ", stringify!(WouldBeCopyButWeAreNotDerivingCopy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WouldBeCopyButWeAreNotDerivingCopy>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(WouldBeCopyButWeAreNotDerivingCopy)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WouldBeCopyButWeAreNotDerivingCopy),
-            "::",
-            stringify!(x)
-        )
-    );
-}
diff --git a/tests/expectations/tests/doggo-or-null.rs b/tests/expectations/tests/doggo-or-null.rs
deleted file mode 100644
index 90287159..00000000
--- a/tests/expectations/tests/doggo-or-null.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)]
-pub struct Doggo {
-    pub x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Doggo() {
-    const UNINIT: ::std::mem::MaybeUninit<Doggo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Doggo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Doggo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Doggo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Doggo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Doggo), "::", stringify!(x))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq)]
-pub struct Null {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Null() {
-    assert_eq!(
-        ::std::mem::size_of::<Null>(),
-        1usize,
-        concat!("Size of: ", stringify!(Null))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Null>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Null))
-    );
-}
-/// This type is an opaque union. Unions can't derive anything interesting like
-/// Debug or Default, even if their layout can, because it would require knowing
-/// which variant is in use. Opaque unions still end up as a `union` in the Rust
-/// bindings, but they just have one variant. Even so, can't derive. We should
-/// probably emit an opaque struct for opaque unions... but until then, we have
-/// this test to make sure that opaque unions don't derive and still compile.
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Copy, Clone)]
-pub union DoggoOrNull {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_DoggoOrNull() {
-    assert_eq!(
-        ::std::mem::size_of::<DoggoOrNull>(),
-        4usize,
-        concat!("Size of: ", stringify!(DoggoOrNull))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DoggoOrNull>(),
-        4usize,
-        concat!("Alignment of ", stringify!(DoggoOrNull))
-    );
-}
-impl Default for DoggoOrNull {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/dupe-enum-variant-in-namespace.rs b/tests/expectations/tests/dupe-enum-variant-in-namespace.rs
deleted file mode 100644
index 85e45392..00000000
--- a/tests/expectations/tests/dupe-enum-variant-in-namespace.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        impl root::foo::Bar {
-            pub const Foo1: root::foo::Bar = Bar::Foo;
-        }
-        impl root::foo::Bar {
-            pub const Foo3: root::foo::Bar = Bar::Foo2;
-        }
-        #[repr(u32)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub enum Bar {
-            Foo = 0,
-            Foo2 = 1,
-        }
-    }
-}
diff --git a/tests/expectations/tests/duplicated-namespaces-definitions.rs b/tests/expectations/tests/duplicated-namespaces-definitions.rs
deleted file mode 100644
index 8e7c895b..00000000
--- a/tests/expectations/tests/duplicated-namespaces-definitions.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Bar {
-            pub foo: ::std::os::raw::c_int,
-            pub baz: bool,
-        }
-        #[test]
-        fn bindgen_test_layout_Bar() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar>(),
-                8usize,
-                concat!("Size of: ", stringify!(Bar))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize
-                },
-                4usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(baz)
-                )
-            );
-        }
-    }
-    pub mod bar {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct Foo {
-            pub ptr: *mut root::foo::Bar,
-        }
-        #[test]
-        fn bindgen_test_layout_Foo() {
-            const UNINIT: ::std::mem::MaybeUninit<Foo> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Foo>(),
-                8usize,
-                concat!("Size of: ", stringify!(Foo))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Foo>(),
-                8usize,
-                concat!("Alignment of ", stringify!(Foo))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Foo),
-                    "::",
-                    stringify!(ptr)
-                )
-            );
-        }
-        impl Default for Foo {
-            fn default() -> Self {
-                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                unsafe {
-                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                    s.assume_init()
-                }
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/duplicated-namespaces.rs b/tests/expectations/tests/duplicated-namespaces.rs
deleted file mode 100644
index 0bbceac8..00000000
--- a/tests/expectations/tests/duplicated-namespaces.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-}
diff --git a/tests/expectations/tests/duplicated_constants_in_ns.rs b/tests/expectations/tests/duplicated_constants_in_ns.rs
deleted file mode 100644
index 3b3405db..00000000
--- a/tests/expectations/tests/duplicated_constants_in_ns.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub const FOO: ::std::os::raw::c_int = 4;
-    }
-    pub mod bar {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub const FOO: ::std::os::raw::c_int = 5;
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_attributes.rs b/tests/expectations/tests/dynamic_loading_attributes.rs
deleted file mode 100644
index b50fbd08..00000000
--- a/tests/expectations/tests/dynamic_loading_attributes.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: unsafe extern "C" fn(
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int,
-    pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym)?;
-        let baz = __library.get(b"baz\0").map(|sym| *sym)?;
-        Ok(TestLib {
-            __library,
-            foo,
-            baz,
-        })
-    }
-    #[must_use]
-    #[doc = " @brief A function"]
-    #[doc = ""]
-    #[doc = " @param x"]
-    #[doc = " @param y"]
-    #[doc = " @return int"]
-    pub unsafe fn foo(
-        &self,
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        (self.foo)(x, y)
-    }
-    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
-        (self.baz)()
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_required.rs b/tests/expectations/tests/dynamic_loading_required.rs
deleted file mode 100644
index e46ffd49..00000000
--- a/tests/expectations/tests/dynamic_loading_required.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: unsafe extern "C" fn(
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int,
-    pub bar: unsafe extern "C" fn(
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int,
-    pub baz: unsafe extern "C" fn() -> ::std::os::raw::c_int,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym)?;
-        let bar = __library.get(b"bar\0").map(|sym| *sym)?;
-        let baz = __library.get(b"baz\0").map(|sym| *sym)?;
-        Ok(TestLib {
-            __library,
-            foo,
-            bar,
-            baz,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        (self.foo)(x, y)
-    }
-    pub unsafe fn bar(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.bar)(x)
-    }
-    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
-        (self.baz)()
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_simple.rs b/tests/expectations/tests/dynamic_loading_simple.rs
deleted file mode 100644
index cae5bd69..00000000
--- a/tests/expectations/tests/dynamic_loading_simple.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: Result<
-        unsafe extern "C" fn(
-            x: ::std::os::raw::c_int,
-            y: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub bar: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub baz: Result<
-        unsafe extern "C" fn() -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym);
-        let bar = __library.get(b"bar\0").map(|sym| *sym);
-        let baz = __library.get(b"baz\0").map(|sym| *sym);
-        Ok(TestLib {
-            __library,
-            foo,
-            bar,
-            baz,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        (self.foo.as_ref().expect("Expected function, got error."))(x, y)
-    }
-    pub unsafe fn bar(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.bar.as_ref().expect("Expected function, got error."))(x)
-    }
-    pub unsafe fn baz(&self) -> ::std::os::raw::c_int {
-        (self.baz.as_ref().expect("Expected function, got error."))()
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_template.rs b/tests/expectations/tests/dynamic_loading_template.rs
deleted file mode 100644
index 06e67ed7..00000000
--- a/tests/expectations/tests/dynamic_loading_template.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: Result<
-        unsafe extern "C" fn(x: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub foo1: Result<unsafe extern "C" fn(x: f32) -> f32, ::libloading::Error>,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym);
-        let foo1 = __library.get(b"foo1\0").map(|sym| *sym);
-        Ok(TestLib {
-            __library,
-            foo,
-            foo1,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        (self.foo.as_ref().expect("Expected function, got error."))(x)
-    }
-    pub unsafe fn foo1(&self, x: f32) -> f32 {
-        (self.foo1.as_ref().expect("Expected function, got error."))(x)
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_with_allowlist.rs b/tests/expectations/tests/dynamic_loading_with_allowlist.rs
deleted file mode 100644
index 97bb67ab..00000000
--- a/tests/expectations/tests/dynamic_loading_with_allowlist.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub baz: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub bazz: Result<
-        unsafe extern "C" fn(
-            arg1: ::std::os::raw::c_int,
-            ...
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym);
-        let baz = __library.get(b"baz\0").map(|sym| *sym);
-        let bazz = __library.get(b"bazz\0").map(|sym| *sym);
-        Ok(TestLib {
-            __library,
-            foo,
-            baz,
-            bazz,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.foo.as_ref().expect("Expected function, got error."))(x)
-    }
-    pub unsafe fn baz(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.baz.as_ref().expect("Expected function, got error."))(x)
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_with_blocklist.rs b/tests/expectations/tests/dynamic_loading_with_blocklist.rs
deleted file mode 100644
index af482ad9..00000000
--- a/tests/expectations/tests/dynamic_loading_with_blocklist.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct X {
-    pub _x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_X() {
-    const UNINIT: ::std::mem::MaybeUninit<X> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<X>(),
-        4usize,
-        concat!("Size of: ", stringify!(X))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<X>(),
-        4usize,
-        concat!("Alignment of ", stringify!(X))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr)._x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(X), "::", stringify!(_x))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1X13some_functionEv"]
-    pub fn X_some_function(this: *mut X);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1X19some_other_functionEv"]
-    pub fn X_some_other_function(this: *mut X);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1XC1Ei"]
-    pub fn X_X(this: *mut X, x: ::std::os::raw::c_int);
-}
-impl X {
-    #[inline]
-    pub unsafe fn some_function(&mut self) {
-        X_some_function(self)
-    }
-    #[inline]
-    pub unsafe fn some_other_function(&mut self) {
-        X_some_other_function(self)
-    }
-    #[inline]
-    pub unsafe fn new(x: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        X_X(__bindgen_tmp.as_mut_ptr(), x);
-        __bindgen_tmp.assume_init()
-    }
-}
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub bar: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym);
-        let bar = __library.get(b"bar\0").map(|sym| *sym);
-        Ok(TestLib {
-            __library,
-            foo,
-            bar,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.foo.as_ref().expect("Expected function, got error."))(x)
-    }
-    pub unsafe fn bar(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.bar.as_ref().expect("Expected function, got error."))(x)
-    }
-}
diff --git a/tests/expectations/tests/dynamic_loading_with_class.rs b/tests/expectations/tests/dynamic_loading_with_class.rs
deleted file mode 100644
index 514cff73..00000000
--- a/tests/expectations/tests/dynamic_loading_with_class.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub _x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        4usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr)._x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(_x))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1A13some_functionEv"]
-    pub fn A_some_function(this: *mut A);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1A19some_other_functionEv"]
-    pub fn A_some_other_function(this: *mut A);
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1AC1Ei"]
-    pub fn A_A(this: *mut A, x: ::std::os::raw::c_int);
-}
-impl A {
-    #[inline]
-    pub unsafe fn some_function(&mut self) {
-        A_some_function(self)
-    }
-    #[inline]
-    pub unsafe fn some_other_function(&mut self) {
-        A_some_other_function(self)
-    }
-    #[inline]
-    pub unsafe fn new(x: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        A_A(__bindgen_tmp.as_mut_ptr(), x);
-        __bindgen_tmp.assume_init()
-    }
-}
-extern crate libloading;
-pub struct TestLib {
-    __library: ::libloading::Library,
-    pub foo: Result<
-        unsafe extern "C" fn(
-            x: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-        ::libloading::Error,
-    >,
-    pub bar: Result<unsafe extern "C" fn(), ::libloading::Error>,
-}
-impl TestLib {
-    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
-    where
-        P: AsRef<::std::ffi::OsStr>,
-    {
-        let library = ::libloading::Library::new(path)?;
-        Self::from_library(library)
-    }
-    pub unsafe fn from_library<L>(
-        library: L,
-    ) -> Result<Self, ::libloading::Error>
-    where
-        L: Into<::libloading::Library>,
-    {
-        let __library = library.into();
-        let foo = __library.get(b"foo\0").map(|sym| *sym);
-        let bar = __library.get(b"bar\0").map(|sym| *sym);
-        Ok(TestLib {
-            __library,
-            foo,
-            bar,
-        })
-    }
-    pub unsafe fn foo(
-        &self,
-        x: *mut ::std::os::raw::c_void,
-    ) -> ::std::os::raw::c_int {
-        (self.foo.as_ref().expect("Expected function, got error."))(x)
-    }
-    pub unsafe fn bar(&self) -> () {
-        (self.bar.as_ref().expect("Expected function, got error."))()
-    }
-}
diff --git a/tests/expectations/tests/elaborated.rs b/tests/expectations/tests/elaborated.rs
deleted file mode 100644
index 47416016..00000000
--- a/tests/expectations/tests/elaborated.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type whatever_whatever_t = ::std::os::raw::c_int;
-extern "C" {
-    #[link_name = "\u{1}_Z9somethingPKi"]
-    pub fn something(wat: *const whatever_whatever_t);
-}
diff --git a/tests/expectations/tests/empty-enum.rs b/tests/expectations/tests/empty-enum.rs
deleted file mode 100644
index fe188b3e..00000000
--- a/tests/expectations/tests/empty-enum.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type EmptyConstified = ::std::os::raw::c_uint;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum EmptyRustified {
-    __bindgen_cannot_repr_c_on_empty_enum = 0,
-}
-pub mod EmptyModule {
-    pub type Type = ::std::os::raw::c_uint;
-}
-#[repr(i8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum EmptyClassRustified {
-    __bindgen_cannot_repr_c_on_empty_enum = 0,
-}
-pub type EmptyClassConstified = ::std::os::raw::c_char;
-pub mod EmptyClassModule {
-    pub type Type = ::std::os::raw::c_char;
-}
-#[repr(i8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum ForwardClassRustified {
-    __bindgen_cannot_repr_c_on_empty_enum = 0,
-}
-pub type ForwardClassConstified = ::std::os::raw::c_char;
-pub mod ForwardClassModule {
-    pub type Type = ::std::os::raw::c_char;
-}
diff --git a/tests/expectations/tests/empty-union.rs b/tests/expectations/tests/empty-union.rs
deleted file mode 100644
index c21ae2f0..00000000
--- a/tests/expectations/tests/empty-union.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union a__bindgen_ty_1 {
-    pub _address: u8,
-}
-impl Default for a__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/empty_template_param_name.rs b/tests/expectations/tests/empty_template_param_name.rs
deleted file mode 100644
index aa751f77..00000000
--- a/tests/expectations/tests/empty_template_param_name.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type __void_t = ::std::os::raw::c_void;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct __iterator_traits {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/enum-default-bitfield.rs b/tests/expectations/tests/enum-default-bitfield.rs
deleted file mode 100644
index 4c075766..00000000
--- a/tests/expectations/tests/enum-default-bitfield.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1,
-}
-pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1(0);
-pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1(1);
-impl ::std::ops::BitOr<foo__bindgen_ty_1> for foo__bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        foo__bindgen_ty_1(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for foo__bindgen_ty_1 {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: foo__bindgen_ty_1) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<foo__bindgen_ty_1> for foo__bindgen_ty_1 {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        foo__bindgen_ty_1(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for foo__bindgen_ty_1 {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: foo__bindgen_ty_1) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1(pub ::std::os::raw::c_uint);
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Foo {
-    pub const Bar: Foo = Foo(0);
-}
-impl Foo {
-    pub const Qux: Foo = Foo(1);
-}
-impl ::std::ops::BitOr<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Foo(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Foo {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Foo) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Foo> for Foo {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Foo(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Foo {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Foo) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_uint);
-pub mod Neg {
-    pub type Type = ::std::os::raw::c_int;
-    pub const MinusOne: Type = -1;
-    pub const One: Type = 1;
-}
-impl NoDebug {
-    pub const NoDebug1: NoDebug = NoDebug(0);
-}
-impl NoDebug {
-    pub const NoDebug2: NoDebug = NoDebug(1);
-}
-impl ::std::ops::BitOr<NoDebug> for NoDebug {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        NoDebug(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for NoDebug {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: NoDebug) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<NoDebug> for NoDebug {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        NoDebug(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for NoDebug {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: NoDebug) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-/// <div rustbindgen nodebug></div>
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NoDebug(pub ::std::os::raw::c_uint);
-impl Debug {
-    pub const Debug1: Debug = Debug(0);
-}
-impl Debug {
-    pub const Debug2: Debug = Debug(1);
-}
-impl ::std::ops::BitOr<Debug> for Debug {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        Debug(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for Debug {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: Debug) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<Debug> for Debug {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        Debug(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for Debug {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: Debug) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-/// <div rustbindgen derive="Debug"></div>
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Debug(pub ::std::os::raw::c_uint);
diff --git a/tests/expectations/tests/enum-default-consts.rs b/tests/expectations/tests/enum-default-consts.rs
deleted file mode 100644
index ddce26c2..00000000
--- a/tests/expectations/tests/enum-default-consts.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1,
-}
-pub const foo_FOO_A: foo__bindgen_ty_1 = 0;
-pub const foo_FOO_B: foo__bindgen_ty_1 = 1;
-pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint;
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub const Foo_Bar: Foo = 0;
-pub const Foo_Qux: Foo = 1;
-pub type Foo = ::std::os::raw::c_uint;
-pub mod Neg {
-    pub type Type = ::std::os::raw::c_int;
-    pub const MinusOne: Type = -1;
-    pub const One: Type = 1;
-}
-pub const NoDebug_NoDebug1: NoDebug = 0;
-pub const NoDebug_NoDebug2: NoDebug = 1;
-/// <div rustbindgen nodebug></div>
-pub type NoDebug = ::std::os::raw::c_uint;
-pub const Debug_Debug1: Debug = 0;
-pub const Debug_Debug2: Debug = 1;
-/// <div rustbindgen derive="Debug"></div>
-pub type Debug = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/enum-default-module.rs b/tests/expectations/tests/enum-default-module.rs
deleted file mode 100644
index ae026d8b..00000000
--- a/tests/expectations/tests/enum-default-module.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1::Type,
-}
-pub mod foo__bindgen_ty_1 {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const FOO_A: Type = 0;
-    pub const FOO_B: Type = 1;
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub mod Foo {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const Bar: Type = 0;
-    pub const Qux: Type = 1;
-}
-pub mod Neg {
-    pub type Type = ::std::os::raw::c_int;
-    pub const MinusOne: Type = -1;
-    pub const One: Type = 1;
-}
-pub mod NoDebug {
-    /// <div rustbindgen nodebug></div>
-    pub type Type = ::std::os::raw::c_uint;
-    pub const NoDebug1: Type = 0;
-    pub const NoDebug2: Type = 1;
-}
-pub mod Debug {
-    /// <div rustbindgen derive="Debug"></div>
-    pub type Type = ::std::os::raw::c_uint;
-    pub const Debug1: Type = 0;
-    pub const Debug2: Type = 1;
-}
diff --git a/tests/expectations/tests/enum-default-rust.d b/tests/expectations/tests/enum-default-rust.d
deleted file mode 100644
index a6540005..00000000
--- a/tests/expectations/tests/enum-default-rust.d
+++ /dev/null
@@ -1 +0,0 @@
-tests/expectations/tests/enum-default-rust.rs: tests/headers/enum-default-rust.h tests/headers/enum.h
diff --git a/tests/expectations/tests/enum-default-rust.rs b/tests/expectations/tests/enum-default-rust.rs
deleted file mode 100644
index c3b728f8..00000000
--- a/tests/expectations/tests/enum-default-rust.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1,
-}
-pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A;
-pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum foo__bindgen_ty_1 {
-    FOO_A = 0,
-    FOO_B = 1,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 0,
-    Qux = 1,
-}
-pub mod Neg {
-    pub type Type = ::std::os::raw::c_int;
-    pub const MinusOne: Type = -1;
-    pub const One: Type = 1;
-}
-#[repr(u32)]
-/// <div rustbindgen nodebug></div>
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub enum NoDebug {
-    NoDebug1 = 0,
-    NoDebug2 = 1,
-}
-#[repr(u32)]
-/// <div rustbindgen derive="Debug"></div>
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Debug {
-    Debug1 = 0,
-    Debug2 = 1,
-}
diff --git a/tests/expectations/tests/enum-doc-bitfield.rs b/tests/expectations/tests/enum-doc-bitfield.rs
deleted file mode 100644
index 3be0438e..00000000
--- a/tests/expectations/tests/enum-doc-bitfield.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl B {
-    /// Document field with three slashes
-    pub const VAR_A: B = B(0);
-}
-impl B {
-    /// Document field with preceeding star
-    pub const VAR_B: B = B(1);
-}
-impl B {
-    /// Document field with preceeding exclamation
-    pub const VAR_C: B = B(2);
-}
-impl B {
-    ///< Document field with following star
-    pub const VAR_D: B = B(3);
-}
-impl B {
-    ///< Document field with following exclamation
-    pub const VAR_E: B = B(4);
-}
-impl B {
-    /// Document field with preceeding star, with a loong long multiline
-    /// comment.
-    ///
-    /// Very interesting documentation, definitely.
-    pub const VAR_F: B = B(5);
-}
-impl ::std::ops::BitOr<B> for B {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        B(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for B {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: B) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<B> for B {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        B(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for B {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: B) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-/// Document enum
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct B(pub ::std::os::raw::c_uint);
diff --git a/tests/expectations/tests/enum-doc-mod.rs b/tests/expectations/tests/enum-doc-mod.rs
deleted file mode 100644
index 60d6b9f4..00000000
--- a/tests/expectations/tests/enum-doc-mod.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod B {
-    /// Document enum
-    pub type Type = ::std::os::raw::c_uint;
-    /// Document field with three slashes
-    pub const VAR_A: Type = 0;
-    /// Document field with preceeding star
-    pub const VAR_B: Type = 1;
-    /// Document field with preceeding exclamation
-    pub const VAR_C: Type = 2;
-    ///< Document field with following star
-    pub const VAR_D: Type = 3;
-    ///< Document field with following exclamation
-    pub const VAR_E: Type = 4;
-    /// Document field with preceeding star, with a loong long multiline
-    /// comment.
-    ///
-    /// Very interesting documentation, definitely.
-    pub const VAR_F: Type = 5;
-}
diff --git a/tests/expectations/tests/enum-doc-rusty.rs b/tests/expectations/tests/enum-doc-rusty.rs
deleted file mode 100644
index e7208a9d..00000000
--- a/tests/expectations/tests/enum-doc-rusty.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u32)]
-/// Document enum
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum B {
-    /// Document field with three slashes
-    VAR_A = 0,
-    /// Document field with preceeding star
-    VAR_B = 1,
-    /// Document field with preceeding exclamation
-    VAR_C = 2,
-    ///< Document field with following star
-    VAR_D = 3,
-    ///< Document field with following exclamation
-    VAR_E = 4,
-    /// Document field with preceeding star, with a loong long multiline
-    /// comment.
-    ///
-    /// Very interesting documentation, definitely.
-    VAR_F = 5,
-}
diff --git a/tests/expectations/tests/enum-doc.rs b/tests/expectations/tests/enum-doc.rs
deleted file mode 100644
index b5d14b3c..00000000
--- a/tests/expectations/tests/enum-doc.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Document field with three slashes
-pub const B_VAR_A: B = 0;
-/// Document field with preceeding star
-pub const B_VAR_B: B = 1;
-/// Document field with preceeding exclamation
-pub const B_VAR_C: B = 2;
-///< Document field with following star
-pub const B_VAR_D: B = 3;
-///< Document field with following exclamation
-pub const B_VAR_E: B = 4;
-/// Document field with preceeding star, with a loong long multiline
-/// comment.
-///
-/// Very interesting documentation, definitely.
-pub const B_VAR_F: B = 5;
-/// Document enum
-pub type B = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/enum-no-debug-rust.rs b/tests/expectations/tests/enum-no-debug-rust.rs
deleted file mode 100644
index 33c7b5c7..00000000
--- a/tests/expectations/tests/enum-no-debug-rust.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1,
-}
-pub const foo_FOO_A: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_A;
-pub const foo_FOO_B: foo__bindgen_ty_1 = foo__bindgen_ty_1::FOO_B;
-#[repr(u32)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub enum foo__bindgen_ty_1 {
-    FOO_A = 0,
-    FOO_B = 1,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(u32)]
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 0,
-    Qux = 1,
-}
-pub mod Neg {
-    pub type Type = ::std::os::raw::c_int;
-    pub const MinusOne: Type = -1;
-    pub const One: Type = 1;
-}
-#[repr(u32)]
-/// <div rustbindgen nodebug></div>
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub enum NoDebug {
-    NoDebug1 = 0,
-    NoDebug2 = 1,
-}
-#[repr(u32)]
-/// <div rustbindgen derive="Debug"></div>
-#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)]
-pub enum Debug {
-    Debug1 = 0,
-    Debug2 = 1,
-}
diff --git a/tests/expectations/tests/enum-translate-type.rs b/tests/expectations/tests/enum-translate-type.rs
deleted file mode 100644
index 89e6003e..00000000
--- a/tests/expectations/tests/enum-translate-type.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const my_enum1_A: my_enum1 = 0;
-pub type my_enum1 = u32;
-pub const my_enum2_B: my_enum2 = -1;
-pub type my_enum2 = i32;
-pub const my_enum3_C: my_enum3 = 0;
-pub type my_enum3 = i16;
-pub const my_enum4_D: my_enum4 = 255;
-pub type my_enum4 = u8;
diff --git a/tests/expectations/tests/enum-undefault.rs b/tests/expectations/tests/enum-undefault.rs
deleted file mode 100644
index e5618b91..00000000
--- a/tests/expectations/tests/enum-undefault.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 0,
-    Qux = 1,
-}
-pub const Neg_MinusOne: Neg = -1;
-pub const Neg_One: Neg = 1;
-pub type Neg = ::std::os::raw::c_int;
diff --git a/tests/expectations/tests/enum-variant-replaces.rs b/tests/expectations/tests/enum-variant-replaces.rs
deleted file mode 100644
index d9276574..00000000
--- a/tests/expectations/tests/enum-variant-replaces.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen replaces="PASS"></div>
-///
-/// Should see PASS below.
-pub const OGRErr_PASS: OGRErr = 0;
-/// <div rustbindgen replaces="OGRERR_NONE"></div>
-///
-/// Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below.
-pub const OGRErr_OGRERR_NONE: OGRErr = 1;
-/// <div rustbindgen replaces="OGRErr"></div>
-pub type OGRErr = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/enum.rs b/tests/expectations/tests/enum.rs
deleted file mode 100644
index 65b734a3..00000000
--- a/tests/expectations/tests/enum.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub member: foo__bindgen_ty_1,
-}
-pub const foo_FOO_A: foo__bindgen_ty_1 = 0;
-pub const foo_FOO_B: foo__bindgen_ty_1 = 1;
-pub type foo__bindgen_ty_1 = ::std::os::raw::c_uint;
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub const Foo_Bar: Foo = 0;
-pub const Foo_Qux: Foo = 1;
-pub type Foo = ::std::os::raw::c_uint;
-pub const Neg_MinusOne: Neg = -1;
-pub const Neg_One: Neg = 1;
-pub type Neg = ::std::os::raw::c_int;
-pub const NoDebug_NoDebug1: NoDebug = 0;
-pub const NoDebug_NoDebug2: NoDebug = 1;
-/// <div rustbindgen nodebug></div>
-pub type NoDebug = ::std::os::raw::c_uint;
-pub const Debug_Debug1: Debug = 0;
-pub const Debug_Debug2: Debug = 1;
-/// <div rustbindgen derive="Debug"></div>
-pub type Debug = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/enum_alias.rs b/tests/expectations/tests/enum_alias.rs
deleted file mode 100644
index ad62d16f..00000000
--- a/tests/expectations/tests/enum_alias.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Bar {
-    VAL = 0,
-}
diff --git a/tests/expectations/tests/enum_and_vtable_mangling.rs b/tests/expectations/tests/enum_and_vtable_mangling.rs
deleted file mode 100644
index f414812b..00000000
--- a/tests/expectations/tests/enum_and_vtable_mangling.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const match_: _bindgen_ty_1 = _bindgen_ty_1::match_;
-pub const whatever_else: _bindgen_ty_1 = _bindgen_ty_1::whatever_else;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    match_ = 0,
-    whatever_else = 1,
-}
-#[repr(C)]
-pub struct C__bindgen_vtable {
-    pub C_match: unsafe extern "C" fn(this: *mut C),
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct C {
-    pub vtable_: *const C__bindgen_vtable,
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        16usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        8usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(i))
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C5matchEv"]
-    pub fn C_match(this: *mut ::std::os::raw::c_void);
-}
diff --git a/tests/expectations/tests/enum_dupe.rs b/tests/expectations/tests/enum_dupe.rs
deleted file mode 100644
index 869375bb..00000000
--- a/tests/expectations/tests/enum_dupe.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl Foo {
-    pub const Dupe: Foo = Foo::Bar;
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 1,
-}
diff --git a/tests/expectations/tests/enum_explicit_type.rs b/tests/expectations/tests/enum_explicit_type.rs
deleted file mode 100644
index 29bc5d8c..00000000
--- a/tests/expectations/tests/enum_explicit_type.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 0,
-    Qux = 1,
-}
-#[repr(i8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Neg {
-    MinusOne = -1,
-    One = 1,
-}
-#[repr(u16)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Bigger {
-    Much = 255,
-    Larger = 256,
-}
-#[repr(i64)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MuchLong {
-    MuchLow = -4294967296,
-}
-#[repr(i64)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MuchLongLong {
-    I64_MIN = -9223372036854775808,
-}
-#[repr(u64)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MuchULongLong {
-    MuchHigh = 4294967296,
-}
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum BoolEnumsAreFun {
-    Value = 1,
-}
-pub type MyType = bool;
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum BoolEnumsAreFun2 {
-    Value2 = 1,
-}
-pub const AnonymousVariantOne: _bindgen_ty_1 =
-    _bindgen_ty_1::AnonymousVariantOne;
-pub const AnonymousVariantTwo: _bindgen_ty_1 =
-    _bindgen_ty_1::AnonymousVariantTwo;
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    AnonymousVariantOne = 0,
-    AnonymousVariantTwo = 1,
-}
diff --git a/tests/expectations/tests/enum_explicit_type_constants.rs b/tests/expectations/tests/enum_explicit_type_constants.rs
deleted file mode 100644
index 0c833b66..00000000
--- a/tests/expectations/tests/enum_explicit_type_constants.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(target_os = "windows"))]
-
-pub const Foo_Bar: Foo = 0;
-pub const Foo_Qux: Foo = 1;
-pub type Foo = ::std::os::raw::c_uchar;
-pub const Neg_MinusOne: Neg = -1;
-pub const Neg_One: Neg = 1;
-pub type Neg = ::std::os::raw::c_schar;
-pub const Bigger_Much: Bigger = 255;
-pub const Bigger_Larger: Bigger = 256;
-pub type Bigger = ::std::os::raw::c_ushort;
-pub const MuchLong_MuchLow: MuchLong = -4294967296;
-pub type MuchLong = ::std::os::raw::c_long;
-pub const MuchLongLong_I64_MIN: MuchLongLong = -9223372036854775808;
-pub type MuchLongLong = ::std::os::raw::c_longlong;
-pub const MuchULongLong_MuchHigh: MuchULongLong = 4294967296;
-pub type MuchULongLong = ::std::os::raw::c_ulonglong;
-pub const BoolEnumsAreFun_Value: BoolEnumsAreFun = true;
-pub type BoolEnumsAreFun = bool;
-pub type MyType = bool;
-pub const BoolEnumsAreFun2_Value2: BoolEnumsAreFun2 = true;
-pub type BoolEnumsAreFun2 = MyType;
-pub const AnonymousVariantOne: _bindgen_ty_1 = 0;
-pub const AnonymousVariantTwo: _bindgen_ty_1 = 1;
-pub type _bindgen_ty_1 = ::std::os::raw::c_uchar;
diff --git a/tests/expectations/tests/enum_in_template.rs b/tests/expectations/tests/enum_in_template.rs
deleted file mode 100644
index c4c06a37..00000000
--- a/tests/expectations/tests/enum_in_template.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub const Foo_Bar_A: Foo_Bar = 0;
-pub const Foo_Bar_B: Foo_Bar = 0;
-pub type Foo_Bar = i32;
diff --git a/tests/expectations/tests/enum_in_template_with_typedef.rs b/tests/expectations/tests/enum_in_template_with_typedef.rs
deleted file mode 100644
index 75dce30c..00000000
--- a/tests/expectations/tests/enum_in_template_with_typedef.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct std_fbstring_core {
-    pub _address: u8,
-}
-pub type std_fbstring_core_category_type = u8;
-impl std_fbstring_core_Category {
-    pub const Bar: std_fbstring_core_Category = std_fbstring_core_Category::Foo;
-}
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum std_fbstring_core_Category {
-    Foo = 0,
-}
diff --git a/tests/expectations/tests/enum_negative.rs b/tests/expectations/tests/enum_negative.rs
deleted file mode 100644
index 02b4baed..00000000
--- a/tests/expectations/tests/enum_negative.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = -2,
-    Qux = 1,
-}
diff --git a/tests/expectations/tests/enum_packed.rs b/tests/expectations/tests/enum_packed.rs
deleted file mode 100644
index 89b0da46..00000000
--- a/tests/expectations/tests/enum_packed.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    Bar = 0,
-    Qux = 1,
-}
-#[repr(i8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Neg {
-    MinusOne = -1,
-    One = 1,
-}
-#[repr(u16)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Bigger {
-    Much = 255,
-    Larger = 256,
-}
diff --git a/tests/expectations/tests/eval-value-dependent.rs b/tests/expectations/tests/eval-value-dependent.rs
deleted file mode 100644
index 3376bfc6..00000000
--- a/tests/expectations/tests/eval-value-dependent.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct e {
-    pub _address: u8,
-}
-pub type e_f<d> = d;
diff --git a/tests/expectations/tests/eval-variadic-template-parameter.rs b/tests/expectations/tests/eval-variadic-template-parameter.rs
deleted file mode 100644
index 576bb721..00000000
--- a/tests/expectations/tests/eval-variadic-template-parameter.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct B {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/explicit-padding.rs b/tests/expectations/tests/explicit-padding.rs
deleted file mode 100644
index a6ea7671..00000000
--- a/tests/expectations/tests/explicit-padding.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct pad_me {
-    pub first: u8,
-    pub __bindgen_padding_0: [u8; 3usize],
-    pub second: u32,
-    pub third: u16,
-    pub __bindgen_padding_1: [u8; 2usize],
-}
-#[test]
-fn bindgen_test_layout_pad_me() {
-    const UNINIT: ::std::mem::MaybeUninit<pad_me> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<pad_me>(),
-        12usize,
-        concat!("Size of: ", stringify!(pad_me))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<pad_me>(),
-        4usize,
-        concat!("Alignment of ", stringify!(pad_me))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pad_me),
-            "::",
-            stringify!(first)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pad_me),
-            "::",
-            stringify!(second)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).third) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pad_me),
-            "::",
-            stringify!(third)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union dont_pad_me {
-    pub first: u8,
-    pub second: u32,
-    pub third: u16,
-}
-#[test]
-fn bindgen_test_layout_dont_pad_me() {
-    const UNINIT: ::std::mem::MaybeUninit<dont_pad_me> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<dont_pad_me>(),
-        4usize,
-        concat!("Size of: ", stringify!(dont_pad_me))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<dont_pad_me>(),
-        4usize,
-        concat!("Alignment of ", stringify!(dont_pad_me))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dont_pad_me),
-            "::",
-            stringify!(first)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dont_pad_me),
-            "::",
-            stringify!(second)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).third) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dont_pad_me),
-            "::",
-            stringify!(third)
-        )
-    );
-}
-impl Default for dont_pad_me {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/extern-const-struct.rs b/tests/expectations/tests/extern-const-struct.rs
deleted file mode 100644
index 8060316a..00000000
--- a/tests/expectations/tests/extern-const-struct.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct nsFoo {
-    pub details: [f32; 400usize],
-}
-#[test]
-fn bindgen_test_layout_nsFoo() {
-    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsFoo>(),
-        1600usize,
-        concat!("Size of: ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsFoo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).details) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsFoo),
-            "::",
-            stringify!(details)
-        )
-    );
-}
-impl Default for nsFoo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    pub static gDetails: nsFoo;
-}
diff --git a/tests/expectations/tests/extern.rs b/tests/expectations/tests/extern.rs
deleted file mode 100644
index 7ded13f1..00000000
--- a/tests/expectations/tests/extern.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type foo = ::std::option::Option<
-    unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
->;
diff --git a/tests/expectations/tests/fit-macro-constant-types-signed.rs b/tests/expectations/tests/fit-macro-constant-types-signed.rs
deleted file mode 100644
index ccb76b85..00000000
--- a/tests/expectations/tests/fit-macro-constant-types-signed.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const N0: i8 = 0;
-pub const N1: i8 = 1;
-pub const N2: i8 = 2;
-pub const N_1: i8 = -1;
-pub const N_2: i8 = -2;
-pub const MAX_U16: i32 = 65535;
-pub const MAX_I16: i16 = 32767;
-pub const MAX_I16_Plus1: i32 = 32768;
-pub const MAX_U16_Plus1: i32 = 65536;
-pub const MAX_I16_Minus1: i16 = 32766;
-pub const MAX_U16_Minus1: i32 = 65534;
-pub const MIN_U16: i8 = 0;
-pub const MIN_I16: i16 = -32768;
-pub const MIN_U16_Plus1: i8 = 1;
-pub const MIN_I16_Plus1: i16 = -32767;
-pub const MIN_U16_Minus1: i8 = -1;
-pub const MIN_I16_Minus1: i32 = -32769;
-pub const MAX_U32: i64 = 4294967295;
-pub const MAX_I32: i32 = 2147483647;
-pub const MAX_I32_Plus1: i64 = 2147483648;
-pub const MAX_U32_Plus1: i64 = 4294967296;
-pub const MAX_I32_Minus1: i32 = 2147483646;
-pub const MAX_U32_Minus1: i64 = 4294967294;
-pub const MIN_U32: i8 = 0;
-pub const MIN_I32: i32 = -2147483648;
-pub const MIN_U32_Plus1: i8 = 1;
-pub const MIN_I32_Plus1: i32 = -2147483647;
-pub const MIN_U32_Minus1: i8 = -1;
-pub const MIN_I32_Minus1: i64 = -2147483649;
-pub const LONG12: i64 = 123456789012;
-pub const LONG_12: i64 = -123456789012;
-extern "C" {
-    pub fn foo(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_uint,
-        arg4: ::std::os::raw::c_char,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: ::std::os::raw::c_schar,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(
-        arg1: ::std::os::raw::c_long,
-        arg2: ::std::os::raw::c_longlong,
-    ) -> ::std::os::raw::c_long;
-}
diff --git a/tests/expectations/tests/fit-macro-constant-types.rs b/tests/expectations/tests/fit-macro-constant-types.rs
deleted file mode 100644
index d8d3f207..00000000
--- a/tests/expectations/tests/fit-macro-constant-types.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const N0: u8 = 0;
-pub const N1: u8 = 1;
-pub const N2: u8 = 2;
-pub const N_1: i8 = -1;
-pub const N_2: i8 = -2;
-pub const MAX_U16: u16 = 65535;
-pub const MAX_I16: u16 = 32767;
-pub const MAX_I16_Plus1: u16 = 32768;
-pub const MAX_U16_Plus1: u32 = 65536;
-pub const MAX_I16_Minus1: u16 = 32766;
-pub const MAX_U16_Minus1: u16 = 65534;
-pub const MIN_U16: u8 = 0;
-pub const MIN_I16: i16 = -32768;
-pub const MIN_U16_Plus1: u8 = 1;
-pub const MIN_I16_Plus1: i16 = -32767;
-pub const MIN_U16_Minus1: i8 = -1;
-pub const MIN_I16_Minus1: i32 = -32769;
-pub const MAX_U32: u32 = 4294967295;
-pub const MAX_I32: u32 = 2147483647;
-pub const MAX_I32_Plus1: u32 = 2147483648;
-pub const MAX_U32_Plus1: u64 = 4294967296;
-pub const MAX_I32_Minus1: u32 = 2147483646;
-pub const MAX_U32_Minus1: u32 = 4294967294;
-pub const MIN_U32: u8 = 0;
-pub const MIN_I32: i32 = -2147483648;
-pub const MIN_U32_Plus1: u8 = 1;
-pub const MIN_I32_Plus1: i32 = -2147483647;
-pub const MIN_U32_Minus1: i8 = -1;
-pub const MIN_I32_Minus1: i64 = -2147483649;
-pub const LONG12: u64 = 123456789012;
-pub const LONG_12: i64 = -123456789012;
-extern "C" {
-    pub fn foo(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_uint,
-        arg4: ::std::os::raw::c_char,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: ::std::os::raw::c_schar,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(
-        arg1: ::std::os::raw::c_long,
-        arg2: ::std::os::raw::c_longlong,
-    ) -> ::std::os::raw::c_long;
-}
diff --git a/tests/expectations/tests/float128.rs b/tests/expectations/tests/float128.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/float128.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/forward-declaration-autoptr.rs b/tests/expectations/tests/forward-declaration-autoptr.rs
deleted file mode 100644
index 9f4fdca0..00000000
--- a/tests/expectations/tests/forward-declaration-autoptr.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct RefPtr<T> {
-    pub m_inner: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for RefPtr<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub m_member: RefPtr<Foo>,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(m_member)
-        )
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_RefPtr_open0_Foo_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<RefPtr<Foo>>(),
-        8usize,
-        concat!("Size of template specialization: ", stringify!(RefPtr<Foo>))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RefPtr<Foo>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(RefPtr<Foo>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/forward-enum-decl.rs b/tests/expectations/tests/forward-enum-decl.rs
deleted file mode 100644
index 0ac550bc..00000000
--- a/tests/expectations/tests/forward-enum-decl.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum CSSPseudoClassType {
-    empty = 0,
-    link = 1,
-}
diff --git a/tests/expectations/tests/forward-inherit-struct-with-fields.rs b/tests/expectations/tests/forward-inherit-struct-with-fields.rs
deleted file mode 100644
index 330d766b..00000000
--- a/tests/expectations/tests/forward-inherit-struct-with-fields.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct js_RootedBase<T> {
-    pub foo: *mut T,
-    pub next: *mut Rooted<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for js_RootedBase<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted<T> {
-    pub _base: js_RootedBase<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/forward-inherit-struct.rs b/tests/expectations/tests/forward-inherit-struct.rs
deleted file mode 100644
index 2c4546eb..00000000
--- a/tests/expectations/tests/forward-inherit-struct.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct js_RootedBase {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted {
-    pub _address: u8,
-}
-impl Default for Rooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/forward_declared_complex_types.rs b/tests/expectations/tests/forward_declared_complex_types.rs
deleted file mode 100644
index c1b1f23d..00000000
--- a/tests/expectations/tests/forward_declared_complex_types.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo_empty {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo_empty() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo_empty>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo_empty))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo_empty>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo_empty))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub f: *mut Foo,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z10baz_structP3Foo"]
-    pub fn baz_struct(f: *mut Foo);
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Union {
-    _unused: [u8; 0],
-}
-extern "C" {
-    #[link_name = "\u{1}_Z9baz_unionP5Union"]
-    pub fn baz_union(u: *mut Union);
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Quux {
-    _unused: [u8; 0],
-}
-extern "C" {
-    #[link_name = "\u{1}_Z9baz_classP4Quux"]
-    pub fn baz_class(q: *mut Quux);
-}
diff --git a/tests/expectations/tests/forward_declared_complex_types_1_0.rs b/tests/expectations/tests/forward_declared_complex_types_1_0.rs
deleted file mode 100644
index ecdbe49d..00000000
--- a/tests/expectations/tests/forward_declared_complex_types_1_0.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct Foo_empty {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo_empty() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo_empty>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo_empty))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo_empty>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo_empty))
-    );
-}
-impl Clone for Foo_empty {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct Foo {
-    _unused: [u8; 0],
-}
-impl Clone for Foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct Bar {
-    pub f: *mut Foo,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
-    );
-}
-impl Clone for Bar {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for Bar {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z10baz_structP3Foo"]
-    pub fn baz_struct(f: *mut Foo);
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct Union {
-    _unused: [u8; 0],
-}
-impl Clone for Union {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z9baz_unionP5Union"]
-    pub fn baz_union(u: *mut Union);
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct Quux {
-    _unused: [u8; 0],
-}
-impl Clone for Quux {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z9baz_classP4Quux"]
-    pub fn baz_class(q: *mut Quux);
-}
diff --git a/tests/expectations/tests/forward_declared_opaque.rs b/tests/expectations/tests/forward_declared_opaque.rs
deleted file mode 100644
index 58c02b44..00000000
--- a/tests/expectations/tests/forward_declared_opaque.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct a {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct b {
-    _unused: [u8; 0],
-}
diff --git a/tests/expectations/tests/forward_declared_struct.rs b/tests/expectations/tests/forward_declared_struct.rs
deleted file mode 100644
index f877666a..00000000
--- a/tests/expectations/tests/forward_declared_struct.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct a {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_a() {
-    const UNINIT: ::std::mem::MaybeUninit<a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        4usize,
-        concat!("Size of: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        4usize,
-        concat!("Alignment of ", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct c {
-    pub d: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_c() {
-    const UNINIT: ::std::mem::MaybeUninit<c> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<c>(),
-        4usize,
-        concat!("Size of: ", stringify!(c))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<c>(),
-        4usize,
-        concat!("Alignment of ", stringify!(c))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(c), "::", stringify!(d))
-    );
-}
diff --git a/tests/expectations/tests/func_proto.rs b/tests/expectations/tests/func_proto.rs
deleted file mode 100644
index 7ded13f1..00000000
--- a/tests/expectations/tests/func_proto.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type foo = ::std::option::Option<
-    unsafe extern "C" fn(bar: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
->;
diff --git a/tests/expectations/tests/func_ptr.rs b/tests/expectations/tests/func_ptr.rs
deleted file mode 100644
index 9c718f03..00000000
--- a/tests/expectations/tests/func_ptr.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub static mut foo: ::std::option::Option<
-        unsafe extern "C" fn(
-            x: ::std::os::raw::c_int,
-            y: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-    >;
-}
diff --git a/tests/expectations/tests/func_ptr_in_struct.rs b/tests/expectations/tests/func_ptr_in_struct.rs
deleted file mode 100644
index 745720d9..00000000
--- a/tests/expectations/tests/func_ptr_in_struct.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum baz {
-    __bindgen_cannot_repr_c_on_empty_enum = 0,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo {
-    pub bar: ::std::option::Option<
-        unsafe extern "C" fn(
-            x: ::std::os::raw::c_int,
-            y: ::std::os::raw::c_int,
-        ) -> baz,
-    >,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/func_ptr_return_type.rs b/tests/expectations/tests/func_ptr_return_type.rs
deleted file mode 100644
index 8f2da8ef..00000000
--- a/tests/expectations/tests/func_ptr_return_type.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn func() -> ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: ::std::os::raw::c_int,
-            arg2: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-    >;
-}
diff --git a/tests/expectations/tests/func_return_must_use.rs b/tests/expectations/tests/func_return_must_use.rs
deleted file mode 100644
index 6ea6c704..00000000
--- a/tests/expectations/tests/func_return_must_use.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type MustUseInt = ::std::os::raw::c_int;
-extern "C" {
-    #[must_use]
-    pub fn return_int() -> MustUseInt;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-#[must_use]
-pub struct MustUseStruct {
-    _unused: [u8; 0],
-}
-extern "C" {
-    #[must_use]
-    pub fn return_struct() -> MustUseStruct;
-}
-/// <div rustbindgen mustusetype></div>
-pub type AnnotatedInt = ::std::os::raw::c_int;
-extern "C" {
-    #[must_use]
-    pub fn return_annotated_int() -> AnnotatedInt;
-}
-extern "C" {
-    pub fn return_plain_int() -> ::std::os::raw::c_int;
-}
-/// <div rustbindgen mustusetype></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-#[must_use]
-pub struct AnnotatedStruct {}
-#[test]
-fn bindgen_test_layout_AnnotatedStruct() {
-    assert_eq!(
-        ::std::mem::size_of::<AnnotatedStruct>(),
-        0usize,
-        concat!("Size of: ", stringify!(AnnotatedStruct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AnnotatedStruct>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AnnotatedStruct))
-    );
-}
-extern "C" {
-    #[must_use]
-    pub fn return_annotated_struct() -> AnnotatedStruct;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PlainStruct {}
-#[test]
-fn bindgen_test_layout_PlainStruct() {
-    assert_eq!(
-        ::std::mem::size_of::<PlainStruct>(),
-        0usize,
-        concat!("Size of: ", stringify!(PlainStruct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PlainStruct>(),
-        1usize,
-        concat!("Alignment of ", stringify!(PlainStruct))
-    );
-}
-/// <div rustbindgen mustusetype></div>
-pub type TypedefPlainStruct = PlainStruct;
-extern "C" {
-    pub fn return_plain_struct() -> PlainStruct;
-}
-extern "C" {
-    #[must_use]
-    pub fn return_typedef_struct() -> TypedefPlainStruct;
-}
diff --git a/tests/expectations/tests/func_with_array_arg.rs b/tests/expectations/tests/func_with_array_arg.rs
deleted file mode 100644
index f98192f8..00000000
--- a/tests/expectations/tests/func_with_array_arg.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn f(x: *mut ::std::os::raw::c_int);
-}
diff --git a/tests/expectations/tests/func_with_func_ptr_arg.rs b/tests/expectations/tests/func_with_func_ptr_arg.rs
deleted file mode 100644
index fb06b88e..00000000
--- a/tests/expectations/tests/func_with_func_ptr_arg.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo(bar: ::std::option::Option<unsafe extern "C" fn()>);
-}
-extern "C" {
-    pub fn bar(
-        one: ::std::option::Option<
-            unsafe extern "C" fn(
-                a: ::std::os::raw::c_int,
-                b: ::std::os::raw::c_int,
-            ),
-        >,
-        two: ::std::option::Option<
-            unsafe extern "C" fn(
-                c: ::std::os::raw::c_int,
-                d: ::std::os::raw::c_int,
-            ),
-        >,
-    );
-}
diff --git a/tests/expectations/tests/function-typedef-stdcall.rs b/tests/expectations/tests/function-typedef-stdcall.rs
deleted file mode 100644
index 11c9ef20..00000000
--- a/tests/expectations/tests/function-typedef-stdcall.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type PFN_VIGEM_X360_NOTIFICATION = ::std::option::Option<
-    unsafe extern "C" fn(
-        arg1: *mut ::std::os::raw::c_void,
-        arg2: *mut ::std::os::raw::c_void,
-        arg3: ::std::os::raw::c_uchar,
-        arg4: ::std::os::raw::c_uchar,
-        arg5: ::std::os::raw::c_uchar,
-        arg6: *mut ::std::os::raw::c_void,
-    ),
->;
diff --git a/tests/expectations/tests/gen-constructors-neg.rs b/tests/expectations/tests/gen-constructors-neg.rs
deleted file mode 100644
index f5ba025a..00000000
--- a/tests/expectations/tests/gen-constructors-neg.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/gen-constructors.rs b/tests/expectations/tests/gen-constructors.rs
deleted file mode 100644
index 89b86379..00000000
--- a/tests/expectations/tests/gen-constructors.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3FooC1Ei"]
-    pub fn Foo_Foo(this: *mut Foo, a: ::std::os::raw::c_int);
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn new(a: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        Foo_Foo(__bindgen_tmp.as_mut_ptr(), a);
-        __bindgen_tmp.assume_init()
-    }
-}
diff --git a/tests/expectations/tests/gen-destructors-neg.rs b/tests/expectations/tests/gen-destructors-neg.rs
deleted file mode 100644
index b87eb1d4..00000000
--- a/tests/expectations/tests/gen-destructors-neg.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct Foo {
-    pub bar: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/gen-destructors.rs b/tests/expectations/tests/gen-destructors.rs
deleted file mode 100644
index 1711f76d..00000000
--- a/tests/expectations/tests/gen-destructors.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct Foo {
-    pub bar: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3FooD1Ev"]
-    pub fn Foo_Foo_destructor(this: *mut Foo);
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn destruct(&mut self) {
-        Foo_Foo_destructor(self)
-    }
-}
diff --git a/tests/expectations/tests/generate-inline.rs b/tests/expectations/tests/generate-inline.rs
deleted file mode 100644
index 3cb865a4..00000000
--- a/tests/expectations/tests/generate-inline.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo3barEv"]
-    pub fn Foo_bar() -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn bar() -> ::std::os::raw::c_int {
-        Foo_bar()
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3foov"]
-    pub fn foo() -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/i128.rs b/tests/expectations/tests/i128.rs
deleted file mode 100644
index dee57a6d..00000000
--- a/tests/expectations/tests/i128.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {
-    pub my_signed: i128,
-    pub my_unsigned: u128,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        32usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        16usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).my_signed) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(my_signed)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).my_unsigned) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(my_unsigned)
-        )
-    );
-}
diff --git a/tests/expectations/tests/in_class_typedef.rs b/tests/expectations/tests/in_class_typedef.rs
deleted file mode 100644
index 7bb7d391..00000000
--- a/tests/expectations/tests/in_class_typedef.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub type Foo_elem_type<T> = T;
-pub type Foo_ptr_type<T> = *mut T;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo_Bar {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
diff --git a/tests/expectations/tests/incomplete-array-padding.rs b/tests/expectations/tests/incomplete-array-padding.rs
deleted file mode 100644
index 18061ea1..00000000
--- a/tests/expectations/tests/incomplete-array-padding.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct foo {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl foo {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: ::std::os::raw::c_char,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/infinite-macro.rs b/tests/expectations/tests/infinite-macro.rs
deleted file mode 100644
index 081a0c29..00000000
--- a/tests/expectations/tests/infinite-macro.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const INFINITY: f64 = ::std::f64::INFINITY;
-pub const NAN: f64 = ::std::f64::NAN;
diff --git a/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs b/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
deleted file mode 100644
index 0876878e..00000000
--- a/tests/expectations/tests/inherit-from-template-instantiation-with-vtable.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct BaseWithVtable__bindgen_vtable {}
-/// This should have an explicit vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct BaseWithVtable<T> {
-    pub vtable_: *const BaseWithVtable__bindgen_vtable,
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for BaseWithVtable<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// This should not have an explicit vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DerivedWithNoVirtualMethods {
-    pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DerivedWithNoVirtualMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<DerivedWithNoVirtualMethods>(),
-        16usize,
-        concat!("Size of: ", stringify!(DerivedWithNoVirtualMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DerivedWithNoVirtualMethods>(),
-        8usize,
-        concat!("Alignment of ", stringify!(DerivedWithNoVirtualMethods))
-    );
-}
-impl Default for DerivedWithNoVirtualMethods {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// This should not have an explicit vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DerivedWithVirtualMethods {
-    pub _base: BaseWithVtable<*mut ::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DerivedWithVirtualMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<DerivedWithVirtualMethods>(),
-        16usize,
-        concat!("Size of: ", stringify!(DerivedWithVirtualMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DerivedWithVirtualMethods>(),
-        8usize,
-        concat!("Alignment of ", stringify!(DerivedWithVirtualMethods))
-    );
-}
-impl Default for DerivedWithVirtualMethods {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// This should not have any vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct BaseWithoutVtable<U> {
-    pub u: U,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<U> Default for BaseWithoutVtable<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct DerivedWithVtable__bindgen_vtable(::std::os::raw::c_void);
-/// This should have an explicit vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DerivedWithVtable {
-    pub vtable_: *const DerivedWithVtable__bindgen_vtable,
-    pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DerivedWithVtable() {
-    assert_eq!(
-        ::std::mem::size_of::<DerivedWithVtable>(),
-        16usize,
-        concat!("Size of: ", stringify!(DerivedWithVtable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DerivedWithVtable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(DerivedWithVtable))
-    );
-}
-impl Default for DerivedWithVtable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// This should not have any vtable.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DerivedWithoutVtable {
-    pub _base: BaseWithoutVtable<*mut ::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DerivedWithoutVtable() {
-    assert_eq!(
-        ::std::mem::size_of::<DerivedWithoutVtable>(),
-        8usize,
-        concat!("Size of: ", stringify!(DerivedWithoutVtable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DerivedWithoutVtable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(DerivedWithoutVtable))
-    );
-}
-impl Default for DerivedWithoutVtable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_BaseWithVtable_open0_ptr_char_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
-        16usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_BaseWithVtable_open0_ptr_char_close0_instantiation_1()
-{
-    assert_eq!(
-        ::std::mem::size_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
-        16usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BaseWithVtable<*mut ::std::os::raw::c_char>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(BaseWithVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_BaseWithoutVtable_open0_ptr_char_close0_instantiation()
-{
-    assert_eq!(
-        ::std::mem::size_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(
-        ),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_BaseWithoutVtable_open0_ptr_char_close0_instantiation_1(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BaseWithoutVtable<*mut ::std::os::raw::c_char>>(
-        ),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(BaseWithoutVtable<*mut ::std::os::raw::c_char>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/inherit-namespaced.rs b/tests/expectations/tests/inherit-namespaced.rs
deleted file mode 100644
index 2c4546eb..00000000
--- a/tests/expectations/tests/inherit-namespaced.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct js_RootedBase {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted {
-    pub _address: u8,
-}
-impl Default for Rooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/inherit_named.rs b/tests/expectations/tests/inherit_named.rs
deleted file mode 100644
index a8eee207..00000000
--- a/tests/expectations/tests/inherit_named.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Wohoo {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Weeee<T> {
-    pub _base: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Weeee<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/inherit_typedef.rs b/tests/expectations/tests/inherit_typedef.rs
deleted file mode 100644
index 285dd44f..00000000
--- a/tests/expectations/tests/inherit_typedef.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-pub type TypedefedFoo = Foo;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
diff --git a/tests/expectations/tests/inline-function.rs b/tests/expectations/tests/inline-function.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/inline-function.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/inline_namespace.rs b/tests/expectations/tests/inline_namespace.rs
deleted file mode 100644
index c569bba6..00000000
--- a/tests/expectations/tests/inline_namespace.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub type Ty = ::std::os::raw::c_int;
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct Bar {
-        pub baz: root::foo::Ty,
-    }
-    #[test]
-    fn bindgen_test_layout_Bar() {
-        const UNINIT: ::std::mem::MaybeUninit<Bar> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<Bar>(),
-            4usize,
-            concat!("Size of: ", stringify!(Bar))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<Bar>(),
-            4usize,
-            concat!("Alignment of ", stringify!(Bar))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(Bar),
-                "::",
-                stringify!(baz)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/inline_namespace_allowlist.rs b/tests/expectations/tests/inline_namespace_allowlist.rs
deleted file mode 100644
index 1f4bc686..00000000
--- a/tests/expectations/tests/inline_namespace_allowlist.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod std {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub type string = *const ::std::os::raw::c_char;
-    }
-}
diff --git a/tests/expectations/tests/inline_namespace_conservative.rs b/tests/expectations/tests/inline_namespace_conservative.rs
deleted file mode 100644
index 4ffafd46..00000000
--- a/tests/expectations/tests/inline_namespace_conservative.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod bar {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            pub type Ty = ::std::os::raw::c_int;
-        }
-        pub type Ty = ::std::os::raw::c_longlong;
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct Bar {
-        pub baz: root::foo::bar::Ty,
-    }
-    #[test]
-    fn bindgen_test_layout_Bar() {
-        const UNINIT: ::std::mem::MaybeUninit<Bar> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<Bar>(),
-            4usize,
-            concat!("Size of: ", stringify!(Bar))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<Bar>(),
-            4usize,
-            concat!("Alignment of ", stringify!(Bar))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(Bar),
-                "::",
-                stringify!(baz)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/inline_namespace_no_ns_enabled.rs b/tests/expectations/tests/inline_namespace_no_ns_enabled.rs
deleted file mode 100644
index 7a0c9935..00000000
--- a/tests/expectations/tests/inline_namespace_no_ns_enabled.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug)]
-pub struct std_basic_string<CharT> {
-    pub hider: std_basic_string_Alloc_hider,
-    pub length: ::std::os::raw::c_ulong,
-    pub __bindgen_anon_1: std_basic_string__bindgen_ty_1<CharT>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<CharT>>,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct std_basic_string_Alloc_hider {
-    pub storage: *mut ::std::os::raw::c_void,
-}
-impl Default for std_basic_string_Alloc_hider {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct std_basic_string__bindgen_ty_1<CharT> {
-    pub inline_storage: [CharT; 4usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<CharT>>,
-}
-impl<CharT> Default for std_basic_string__bindgen_ty_1<CharT> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<CharT> Default for std_basic_string<CharT> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/inner-typedef-gh422.rs b/tests/expectations/tests/inner-typedef-gh422.rs
deleted file mode 100644
index 1cfa549c..00000000
--- a/tests/expectations/tests/inner-typedef-gh422.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo_InnerType<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Foo_InnerType<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type Bar = InnerType;
-extern "C" {
-    #[link_name = "\u{1}_Z4funcv"]
-    pub fn func() -> Bar;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct InnerType {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/inner_const.rs b/tests/expectations/tests/inner_const.rs
deleted file mode 100644
index 69a7c39a..00000000
--- a/tests/expectations/tests/inner_const.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub bar: ::std::os::raw::c_int,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo3BOOE"]
-    pub static mut Foo_BOO: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo8whateverE"]
-    pub static mut Foo_whatever: Foo;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/inner_template_self.rs b/tests/expectations/tests/inner_template_self.rs
deleted file mode 100644
index 13d9ac14..00000000
--- a/tests/expectations/tests/inner_template_self.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct LinkedList {
-    pub next: *mut LinkedList,
-    pub prev: *mut LinkedList,
-}
-impl Default for LinkedList {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct InstantiateIt {
-    pub m_list: LinkedList,
-}
-#[test]
-fn bindgen_test_layout_InstantiateIt() {
-    const UNINIT: ::std::mem::MaybeUninit<InstantiateIt> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<InstantiateIt>(),
-        16usize,
-        concat!("Size of: ", stringify!(InstantiateIt))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InstantiateIt>(),
-        8usize,
-        concat!("Alignment of ", stringify!(InstantiateIt))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m_list) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(InstantiateIt),
-            "::",
-            stringify!(m_list)
-        )
-    );
-}
-impl Default for InstantiateIt {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_LinkedList_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<LinkedList>(),
-        16usize,
-        concat!("Size of template specialization: ", stringify!(LinkedList))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<LinkedList>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(LinkedList)
-        )
-    );
-}
diff --git a/tests/expectations/tests/int128_t.rs b/tests/expectations/tests/int128_t.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/int128_t.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/issue-1025-unknown-enum-repr.rs b/tests/expectations/tests/issue-1025-unknown-enum-repr.rs
deleted file mode 100644
index c42e167f..00000000
--- a/tests/expectations/tests/issue-1025-unknown-enum-repr.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct a {
-    pub _address: u8,
-}
-pub type a__bindgen_ty_1 = i32;
diff --git a/tests/expectations/tests/issue-1034.rs b/tests/expectations/tests/issue-1034.rs
deleted file mode 100644
index 32f4310e..00000000
--- a/tests/expectations/tests/issue-1034.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct S2 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-}
-#[test]
-fn bindgen_test_layout_S2() {
-    assert_eq!(
-        ::std::mem::size_of::<S2>(),
-        2usize,
-        concat!("Size of: ", stringify!(S2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<S2>(),
-        1usize,
-        concat!("Alignment of ", stringify!(S2))
-    );
-}
-impl S2 {
-    #[inline]
-    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/issue-1040.rs b/tests/expectations/tests/issue-1040.rs
deleted file mode 100644
index 8503e8d2..00000000
--- a/tests/expectations/tests/issue-1040.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const g_107: ::std::os::raw::c_ulonglong = 18446744073709551615;
diff --git a/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
deleted file mode 100644
index d91dd8fa..00000000
--- a/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct S1 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-}
-#[test]
-fn bindgen_test_layout_S1() {
-    assert_eq!(
-        ::std::mem::size_of::<S1>(),
-        3usize,
-        concat!("Size of: ", stringify!(S1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<S1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(S1))
-    );
-}
-impl S1 {
-    #[inline]
-    pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
-            Default::default();
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/issue-1113-template-references.rs b/tests/expectations/tests/issue-1113-template-references.rs
deleted file mode 100644
index c1465835..00000000
--- a/tests/expectations/tests/issue-1113-template-references.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Entry<K, V> {
-    pub _base: K,
-    pub mData: V,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
-}
-impl<K, V> Default for Entry<K, V> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct nsBaseHashtable {
-    pub _address: u8,
-}
-pub type nsBaseHashtable_EntryType<K, V> = Entry<K, V>;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsBaseHashtable_EntryPtr<K, V> {
-    pub mEntry: *mut nsBaseHashtable_EntryType<K, V>,
-    pub mExistingEntry: bool,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<K>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
-}
-impl<K, V> Default for nsBaseHashtable_EntryPtr<K, V> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1118-using-forward-decl.rs b/tests/expectations/tests/issue-1118-using-forward-decl.rs
deleted file mode 100644
index e881c8c4..00000000
--- a/tests/expectations/tests/issue-1118-using-forward-decl.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type c = nsTArray;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsTArray_base {
-    pub d: *mut ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_nsTArray_base() {
-    const UNINIT: ::std::mem::MaybeUninit<nsTArray_base> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsTArray_base>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsTArray_base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsTArray_base>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsTArray_base))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsTArray_base),
-            "::",
-            stringify!(d)
-        )
-    );
-}
-impl Default for nsTArray_base {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsTArray {
-    pub _base: nsTArray_base,
-}
-impl Default for nsTArray {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsIContent {
-    pub foo: nsTArray,
-}
-#[test]
-fn bindgen_test_layout_nsIContent() {
-    const UNINIT: ::std::mem::MaybeUninit<nsIContent> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsIContent>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsIContent))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsIContent>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsIContent))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsIContent),
-            "::",
-            stringify!(foo)
-        )
-    );
-}
-impl Default for nsIContent {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z35Gecko_GetAnonymousContentForElementv"]
-    pub fn Gecko_GetAnonymousContentForElement() -> *mut nsTArray;
-}
-#[test]
-fn __bindgen_test_layout_nsTArray_open0_ptr_nsIContent_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<nsTArray>(),
-        8usize,
-        concat!("Size of template specialization: ", stringify!(nsTArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsTArray>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(nsTArray)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_nsTArray_open0_ptr_nsIContent_close0_instantiation_1()
-{
-    assert_eq!(
-        ::std::mem::size_of::<nsTArray>(),
-        8usize,
-        concat!("Size of template specialization: ", stringify!(nsTArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsTArray>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(nsTArray)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs b/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
deleted file mode 100644
index fd023363..00000000
--- a/tests/expectations/tests/issue-1197-pure-virtual-stuff.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Foo__bindgen_vtable(::std::os::raw::c_void);
-#[repr(C)]
-#[derive(Debug)]
-pub struct Foo {
-    pub vtable_: *const Foo__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-impl Default for Foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs b/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
deleted file mode 100644
index ed9f7c9b..00000000
--- a/tests/expectations/tests/issue-1198-alias-rust-bitfield-enum.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl MyDupeEnum {
-    pub const A: MyDupeEnum = MyDupeEnum(0);
-}
-impl MyDupeEnum {
-    pub const A_alias: MyDupeEnum = MyDupeEnum(0);
-}
-impl MyDupeEnum {
-    pub const B: MyDupeEnum = MyDupeEnum(1);
-}
-impl ::std::ops::BitOr<MyDupeEnum> for MyDupeEnum {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        MyDupeEnum(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for MyDupeEnum {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: MyDupeEnum) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<MyDupeEnum> for MyDupeEnum {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        MyDupeEnum(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for MyDupeEnum {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: MyDupeEnum) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct MyDupeEnum(pub ::std::os::raw::c_uint);
-impl MyOtherDupeEnum {
-    pub const C: MyOtherDupeEnum = MyOtherDupeEnum(0);
-}
-impl MyOtherDupeEnum {
-    pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum(0);
-}
-impl MyOtherDupeEnum {
-    pub const D: MyOtherDupeEnum = MyOtherDupeEnum(1);
-}
-impl ::std::ops::BitOr<MyOtherDupeEnum> for MyOtherDupeEnum {
-    type Output = Self;
-    #[inline]
-    fn bitor(self, other: Self) -> Self {
-        MyOtherDupeEnum(self.0 | other.0)
-    }
-}
-impl ::std::ops::BitOrAssign for MyOtherDupeEnum {
-    #[inline]
-    fn bitor_assign(&mut self, rhs: MyOtherDupeEnum) {
-        self.0 |= rhs.0;
-    }
-}
-impl ::std::ops::BitAnd<MyOtherDupeEnum> for MyOtherDupeEnum {
-    type Output = Self;
-    #[inline]
-    fn bitand(self, other: Self) -> Self {
-        MyOtherDupeEnum(self.0 & other.0)
-    }
-}
-impl ::std::ops::BitAndAssign for MyOtherDupeEnum {
-    #[inline]
-    fn bitand_assign(&mut self, rhs: MyOtherDupeEnum) {
-        self.0 &= rhs.0;
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct MyOtherDupeEnum(pub ::std::os::raw::c_uint);
diff --git a/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs b/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
deleted file mode 100644
index 81c74abb..00000000
--- a/tests/expectations/tests/issue-1198-alias-rust-const-mod-bitfield-enum.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod MyDupeEnum {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const A: Type = 0;
-    pub const A_alias: Type = 0;
-    pub const B: Type = 1;
-}
-pub mod MyOtherDupeEnum {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const C: Type = 0;
-    pub const C_alias: Type = 0;
-    pub const D: Type = 1;
-}
diff --git a/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs b/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
deleted file mode 100644
index 81c74abb..00000000
--- a/tests/expectations/tests/issue-1198-alias-rust-const-mod-enum.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub mod MyDupeEnum {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const A: Type = 0;
-    pub const A_alias: Type = 0;
-    pub const B: Type = 1;
-}
-pub mod MyOtherDupeEnum {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const C: Type = 0;
-    pub const C_alias: Type = 0;
-    pub const D: Type = 1;
-}
diff --git a/tests/expectations/tests/issue-1198-alias-rust-enum.rs b/tests/expectations/tests/issue-1198-alias-rust-enum.rs
deleted file mode 100644
index fda73a02..00000000
--- a/tests/expectations/tests/issue-1198-alias-rust-enum.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl MyDupeEnum {
-    pub const A_alias: MyDupeEnum = MyDupeEnum::A;
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MyDupeEnum {
-    A = 0,
-    B = 1,
-}
-impl MyOtherDupeEnum {
-    pub const C_alias: MyOtherDupeEnum = MyOtherDupeEnum::C;
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum MyOtherDupeEnum {
-    C = 0,
-    D = 1,
-}
diff --git a/tests/expectations/tests/issue-1216-variadic-member.rs b/tests/expectations/tests/issue-1216-variadic-member.rs
deleted file mode 100644
index bb57c856..00000000
--- a/tests/expectations/tests/issue-1216-variadic-member.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn f(a: ::std::os::raw::c_int, ...);
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub f: ::std::option::Option<
-        unsafe extern "C" fn(
-            p: *mut ::std::os::raw::c_void,
-            obj: *mut ::std::os::raw::c_void,
-            a: ::std::os::raw::c_int,
-            ...
-        ),
-    >,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f))
-    );
-}
diff --git a/tests/expectations/tests/issue-1238-fwd-no-copy.rs b/tests/expectations/tests/issue-1238-fwd-no-copy.rs
deleted file mode 100644
index 006900cb..00000000
--- a/tests/expectations/tests/issue-1238-fwd-no-copy.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug)]
-pub struct MyType {
-    _unused: [u8; 0],
-}
-pub type MyTypeT = MyType;
diff --git a/tests/expectations/tests/issue-1281.rs b/tests/expectations/tests/issue-1281.rs
deleted file mode 100644
index db99cbce..00000000
--- a/tests/expectations/tests/issue-1281.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct bar {
-    pub u: foo,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {
-    pub foo: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(foo))
-    );
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(bar), "::", stringify!(u))
-    );
-}
-pub type bar_t = bar;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct baz {
-    pub f: foo,
-}
-#[test]
-fn bindgen_test_layout_baz() {
-    const UNINIT: ::std::mem::MaybeUninit<baz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<baz>(),
-        4usize,
-        concat!("Size of: ", stringify!(baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<baz>(),
-        4usize,
-        concat!("Alignment of ", stringify!(baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(baz), "::", stringify!(f))
-    );
-}
diff --git a/tests/expectations/tests/issue-1285.rs b/tests/expectations/tests/issue-1285.rs
deleted file mode 100644
index 08aab0a9..00000000
--- a/tests/expectations/tests/issue-1285.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1291.rs b/tests/expectations/tests/issue-1291.rs
deleted file mode 100644
index 25f4f105..00000000
--- a/tests/expectations/tests/issue-1291.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct RTCRay {
-    pub org: [f32; 3usize],
-    pub align0: f32,
-    pub dir: [f32; 3usize],
-    pub align1: f32,
-    pub tnear: f32,
-    pub tfar: f32,
-    pub time: f32,
-    pub mask: ::std::os::raw::c_uint,
-    pub Ng: [f32; 3usize],
-    pub align2: f32,
-    pub u: f32,
-    pub v: f32,
-    pub geomID: ::std::os::raw::c_uint,
-    pub primID: ::std::os::raw::c_uint,
-    pub instID: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_RTCRay() {
-    const UNINIT: ::std::mem::MaybeUninit<RTCRay> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<RTCRay>(),
-        96usize,
-        concat!("Size of: ", stringify!(RTCRay))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RTCRay>(),
-        16usize,
-        concat!("Alignment of ", stringify!(RTCRay))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).org) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(org)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).align0) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(align0)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dir) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(dir)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).align1) as usize - ptr as usize },
-        28usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(align1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(tnear)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(tfar)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(time)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(mask)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ng) as usize - ptr as usize },
-        48usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(Ng)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).align2) as usize - ptr as usize },
-        60usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(align2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        64usize,
-        concat!("Offset of field: ", stringify!(RTCRay), "::", stringify!(u))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
-        68usize,
-        concat!("Offset of field: ", stringify!(RTCRay), "::", stringify!(v))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(geomID)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
-        76usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(primID)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RTCRay),
-            "::",
-            stringify!(instID)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-1350-attribute-overloadable.rs b/tests/expectations/tests/issue-1350-attribute-overloadable.rs
deleted file mode 100644
index 4deed060..00000000
--- a/tests/expectations/tests/issue-1350-attribute-overloadable.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z11my_functioni"]
-    pub fn my_function(a: ::std::os::raw::c_int);
-}
-extern "C" {
-    #[link_name = "\u{1}_Z11my_functionPKc"]
-    pub fn my_function1(a: *const ::std::os::raw::c_char);
-}
diff --git a/tests/expectations/tests/issue-1382-rust-primitive-types.rs b/tests/expectations/tests/issue-1382-rust-primitive-types.rs
deleted file mode 100644
index b767d5e4..00000000
--- a/tests/expectations/tests/issue-1382-rust-primitive-types.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type i8_ = i8;
-pub type u8_ = u8;
-pub type i16_ = i16;
-pub type u16_ = u16;
-pub type i32_ = i32;
-pub type u32_ = u32;
-pub type i64_ = i64;
-pub type u64_ = u64;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub i8_: ::std::os::raw::c_int,
-    pub u8_: ::std::os::raw::c_int,
-    pub i16_: ::std::os::raw::c_int,
-    pub u16_: ::std::os::raw::c_int,
-    pub i32_: ::std::os::raw::c_int,
-    pub u32_: ::std::os::raw::c_int,
-    pub i64_: ::std::os::raw::c_int,
-    pub u64_: ::std::os::raw::c_int,
-    pub i128_: ::std::os::raw::c_int,
-    pub u128_: ::std::os::raw::c_int,
-    pub isize_: ::std::os::raw::c_int,
-    pub usize_: ::std::os::raw::c_int,
-    pub f32_: ::std::os::raw::c_int,
-    pub f64_: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        56usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i8_) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i8_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u8_) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u8_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i16_) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i16_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u16_) as usize - ptr as usize },
-        12usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u16_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
-        16usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i32_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
-        20usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u32_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize },
-        24usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(i64_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u64_) as usize - ptr as usize },
-        28usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(u64_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i128_) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(i128_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u128_) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(u128_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).isize_) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(isize_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).usize_) as usize - ptr as usize },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo),
-            "::",
-            stringify!(usize_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f32_) as usize - ptr as usize },
-        48usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f32_))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize },
-        52usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(f64_))
-    );
-}
diff --git a/tests/expectations/tests/issue-1435.rs b/tests/expectations/tests/issue-1435.rs
deleted file mode 100644
index 79ed7b29..00000000
--- a/tests/expectations/tests/issue-1435.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod ns {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub const AB_A: root::ns::AB = 0;
-        pub const AB_B: root::ns::AB = 1;
-        pub type AB = ::std::os::raw::c_int;
-    }
-    pub use self::super::root::ns::AB;
-    extern "C" {
-        #[link_name = "\u{1}_ZL2kA"]
-        pub static kA: root::AB;
-    }
-}
diff --git a/tests/expectations/tests/issue-1443.rs b/tests/expectations/tests/issue-1443.rs
deleted file mode 100644
index 48cae79f..00000000
--- a/tests/expectations/tests/issue-1443.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar {
-    pub f: *const Foo,
-    pub m: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        16usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(m))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Baz {
-    pub f: *mut Foo,
-    pub m: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    const UNINIT: ::std::mem::MaybeUninit<Baz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        16usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(f))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(m))
-    );
-}
-impl Default for Baz {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Tar {
-    pub f: *const Foo,
-    pub m: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_Tar() {
-    const UNINIT: ::std::mem::MaybeUninit<Tar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Tar>(),
-        16usize,
-        concat!("Size of: ", stringify!(Tar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Tar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Tar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(f))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(m))
-    );
-}
-impl Default for Tar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Taz {
-    pub f: *mut Foo,
-    pub m: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_Taz() {
-    const UNINIT: ::std::mem::MaybeUninit<Taz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Taz>(),
-        16usize,
-        concat!("Size of: ", stringify!(Taz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Taz>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Taz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(f))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(m))
-    );
-}
-impl Default for Taz {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1454.rs b/tests/expectations/tests/issue-1454.rs
deleted file mode 100644
index 8da43cb0..00000000
--- a/tests/expectations/tests/issue-1454.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug)]
-pub struct extern_type;
-
-#[repr(C)]
-#[derive(Debug)]
-pub struct local_type {
-    pub inner: extern_type,
-}
-#[test]
-fn bindgen_test_layout_local_type() {
-    const UNINIT: ::std::mem::MaybeUninit<local_type> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<local_type>(),
-        0usize,
-        concat!("Size of: ", stringify!(local_type))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<local_type>(),
-        1usize,
-        concat!("Alignment of ", stringify!(local_type))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).inner) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(local_type),
-            "::",
-            stringify!(inner)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-1464.rs b/tests/expectations/tests/issue-1464.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/issue-1464.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/issue-1488-enum-new-type.rs b/tests/expectations/tests/issue-1488-enum-new-type.rs
deleted file mode 100644
index b762659a..00000000
--- a/tests/expectations/tests/issue-1488-enum-new-type.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const Foo_A: Foo = 0;
-pub const Foo_B: Foo = 1;
-pub type Foo = ::std::os::raw::c_uint;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct FooAlias(pub Foo);
-pub mod Bar {
-    pub type Type = ::std::os::raw::c_uint;
-    pub const C: Type = 0;
-    pub const D: Type = 1;
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct BarAlias(pub Bar::Type);
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Qux {
-    E = 0,
-    F = 1,
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct QuxAlias(pub Qux);
-pub const Baz_G: Baz = 0;
-pub const Baz_H: Baz = 1;
-pub type Baz = ::std::os::raw::c_uint;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct BazAlias(pub Baz);
-impl ::std::ops::Deref for BazAlias {
-    type Target = Baz;
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl ::std::ops::DerefMut for BazAlias {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
diff --git a/tests/expectations/tests/issue-1488-options.rs b/tests/expectations/tests/issue-1488-options.rs
deleted file mode 100644
index cf13b562..00000000
--- a/tests/expectations/tests/issue-1488-options.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type OSStatus = ::std::os::raw::c_int;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct SomePtr(pub *mut ::std::os::raw::c_void);
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct AnotherPtr(pub *mut ::std::os::raw::c_void);
-impl ::std::ops::Deref for AnotherPtr {
-    type Target = *mut ::std::os::raw::c_void;
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl ::std::ops::DerefMut for AnotherPtr {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
diff --git a/tests/expectations/tests/issue-1488-template-alias-new-type.rs b/tests/expectations/tests/issue-1488-template-alias-new-type.rs
deleted file mode 100644
index 1af0c575..00000000
--- a/tests/expectations/tests/issue-1488-template-alias-new-type.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Wrapped<T>(pub T);
diff --git a/tests/expectations/tests/issue-1498.rs b/tests/expectations/tests/issue-1498.rs
deleted file mode 100644
index eb5e2804..00000000
--- a/tests/expectations/tests/issue-1498.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C, packed)]
-#[derive(Copy, Clone)]
-pub struct rte_memseg {
-    ///< Start physical address.
-    pub phys_addr: u64,
-    pub __bindgen_anon_1: rte_memseg__bindgen_ty_1,
-    ///< Length of the segment.
-    pub len: usize,
-    ///< The pagesize of underlying memory
-    pub hugepage_sz: u64,
-    ///< NUMA socket ID.
-    pub socket_id: i32,
-    ///< Number of channels.
-    pub nchannel: u32,
-    ///< Number of ranks.
-    pub nrank: u32,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_memseg__bindgen_ty_1 {
-    ///< Start virtual address.
-    pub addr: *mut ::std::os::raw::c_void,
-    ///< Makes sure addr is always 64 bits
-    pub addr_64: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_memseg__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_memseg__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_memseg__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_memseg__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_memseg__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_memseg__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg__bindgen_ty_1),
-            "::",
-            stringify!(addr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).addr_64) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg__bindgen_ty_1),
-            "::",
-            stringify!(addr_64)
-        )
-    );
-}
-impl Default for rte_memseg__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_memseg() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_memseg> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_memseg>(),
-        44usize,
-        concat!("Size of: ", stringify!(rte_memseg))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_memseg>(),
-        1usize,
-        concat!("Alignment of ", stringify!(rte_memseg))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).phys_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(phys_addr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).hugepage_sz) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(hugepage_sz)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).socket_id) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(socket_id)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nchannel) as usize - ptr as usize
-        },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(nchannel)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nrank) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_memseg),
-            "::",
-            stringify!(nrank)
-        )
-    );
-}
-impl Default for rte_memseg {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1514.rs b/tests/expectations/tests/issue-1514.rs
deleted file mode 100644
index 31939ca5..00000000
--- a/tests/expectations/tests/issue-1514.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Thing {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Thing_Inner<T> {
-    pub ptr: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Thing_Inner<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Thing_AnotherInner<T> {
-    pub _base: Thing_Inner<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Thing_AnotherInner<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1554.rs b/tests/expectations/tests/issue-1554.rs
deleted file mode 100644
index 7e7cddd6..00000000
--- a/tests/expectations/tests/issue-1554.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-#![feature(non_exhaustive)]
-
-#[repr(u32)]
-#[non_exhaustive]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Planet {
-    earth = 0,
-    mars = 1,
-}
diff --git a/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs b/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
deleted file mode 100644
index eacb3411..00000000
--- a/tests/expectations/tests/issue-1599-opaque-typedef-to-enum.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const a_b: a = 0;
-pub const a_c: a = 1;
-pub type a = ::std::os::raw::c_uint;
-pub type d = u32;
diff --git a/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs b/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/issue-1676-macro-namespace-prefix.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/issue-1947.rs b/tests/expectations/tests/issue-1947.rs
deleted file mode 100644
index e133ed85..00000000
--- a/tests/expectations/tests/issue-1947.rs
+++ /dev/null
@@ -1,349 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-pub type U8 = ::std::os::raw::c_uchar;
-pub type U16 = ::std::os::raw::c_ushort;
-#[repr(C)]
-#[repr(align(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct V56AMDY {
-    pub _bitfield_align_1: [u16; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-    pub MADK: U8,
-    pub MABR: U8,
-    pub _bitfield_align_2: [u16; 0],
-    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 3usize]>,
-    pub _rB_: U8,
-}
-#[test]
-fn bindgen_test_layout_V56AMDY() {
-    const UNINIT: ::std::mem::MaybeUninit<V56AMDY> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<V56AMDY>(),
-        8usize,
-        concat!("Size of: ", stringify!(V56AMDY))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<V56AMDY>(),
-        2usize,
-        concat!("Alignment of ", stringify!(V56AMDY))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).MADK) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(V56AMDY),
-            "::",
-            stringify!(MADK)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).MABR) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(V56AMDY),
-            "::",
-            stringify!(MABR)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr)._rB_) as usize - ptr as usize },
-        7usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(V56AMDY),
-            "::",
-            stringify!(_rB_)
-        )
-    );
-}
-impl V56AMDY {
-    #[inline]
-    pub fn MADZ(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MADZ(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 10u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MAI0(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MAI0(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(10usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MAI1(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MAI1(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MAI2(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MAI2(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(14usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        MADZ: U16,
-        MAI0: U16,
-        MAI1: U16,
-        MAI2: U16,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 10u8, {
-            let MADZ: u16 = unsafe { ::std::mem::transmute(MADZ) };
-            MADZ as u64
-        });
-        __bindgen_bitfield_unit.set(10usize, 2u8, {
-            let MAI0: u16 = unsafe { ::std::mem::transmute(MAI0) };
-            MAI0 as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 2u8, {
-            let MAI1: u16 = unsafe { ::std::mem::transmute(MAI1) };
-            MAI1 as u64
-        });
-        __bindgen_bitfield_unit.set(14usize, 2u8, {
-            let MAI2: u16 = unsafe { ::std::mem::transmute(MAI2) };
-            MAI2 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-    #[inline]
-    pub fn MATH(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(0usize, 10u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MATH(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_2.set(0usize, 10u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MATE(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(10usize, 4u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MATE(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_2.set(10usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MATW(&self) -> U16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(14usize, 2u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_MATW(&mut self, val: U16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_2.set(14usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MASW(&self) -> U8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(16usize, 4u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_MASW(&mut self, val: U8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(16usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MABW(&self) -> U8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(20usize, 3u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_MABW(&mut self, val: U8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(20usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn MAXN(&self) -> U8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(23usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_MAXN(&mut self, val: U8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(23usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_2(
-        MATH: U16,
-        MATE: U16,
-        MATW: U16,
-        MASW: U8,
-        MABW: U8,
-        MAXN: U8,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 10u8, {
-            let MATH: u16 = unsafe { ::std::mem::transmute(MATH) };
-            MATH as u64
-        });
-        __bindgen_bitfield_unit.set(10usize, 4u8, {
-            let MATE: u16 = unsafe { ::std::mem::transmute(MATE) };
-            MATE as u64
-        });
-        __bindgen_bitfield_unit.set(14usize, 2u8, {
-            let MATW: u16 = unsafe { ::std::mem::transmute(MATW) };
-            MATW as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 4u8, {
-            let MASW: u8 = unsafe { ::std::mem::transmute(MASW) };
-            MASW as u64
-        });
-        __bindgen_bitfield_unit.set(20usize, 3u8, {
-            let MABW: u8 = unsafe { ::std::mem::transmute(MABW) };
-            MABW as u64
-        });
-        __bindgen_bitfield_unit.set(23usize, 1u8, {
-            let MAXN: u8 = unsafe { ::std::mem::transmute(MAXN) };
-            MAXN as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/issue-1977-larger-arrays.rs b/tests/expectations/tests/issue-1977-larger-arrays.rs
deleted file mode 100644
index 6375ea7e..00000000
--- a/tests/expectations/tests/issue-1977-larger-arrays.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct S {
-    pub large_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_S() {
-    const UNINIT: ::std::mem::MaybeUninit<S> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<S>(),
-        33usize,
-        concat!("Size of: ", stringify!(S))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<S>(),
-        1usize,
-        concat!("Alignment of ", stringify!(S))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(S),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for S {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ST<T> {
-    pub large_array: [T; 33usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ST<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-1995.rs b/tests/expectations/tests/issue-1995.rs
deleted file mode 100644
index 890479b5..00000000
--- a/tests/expectations/tests/issue-1995.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This is a constant that has a docstring
-///
-/// And expected to be found in generated bindings code too.
-pub const FOO: ::std::os::raw::c_int = 1;
-/// This is a constant that has a docstring
-///
-/// And expected to be found in generated bindings code too.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(baz))
-    );
-}
diff --git a/tests/expectations/tests/issue-2019.rs b/tests/expectations/tests/issue-2019.rs
deleted file mode 100644
index 294e9f0e..00000000
--- a/tests/expectations/tests/issue-2019.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub a: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        4usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(a))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1A4makeEv"]
-    pub fn make() -> A;
-}
-impl A {
-    #[inline]
-    pub unsafe fn make() -> A {
-        make()
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct B {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    const UNINIT: ::std::mem::MaybeUninit<B> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(B), "::", stringify!(b))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1B4makeEv"]
-    pub fn make1() -> B;
-}
-impl B {
-    #[inline]
-    pub unsafe fn make() -> B {
-        make1()
-    }
-}
diff --git a/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs b/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
deleted file mode 100644
index 75ec9e43..00000000
--- a/tests/expectations/tests/issue-2239-template-dependent-bit-width.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct b {
-    pub _address: u8,
-}
-pub type b_td<a> = a;
-pub type b_ta<a> = a;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct b_foo {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/issue-358.rs b/tests/expectations/tests/issue-358.rs
deleted file mode 100644
index e9ee0f50..00000000
--- a/tests/expectations/tests/issue-358.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct JS_PersistentRooted {
-    pub _base: a,
-}
-impl Default for JS_PersistentRooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct a {
-    pub b: *mut a,
-}
-impl Default for a {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-372.rs b/tests/expectations/tests/issue-372.rs
deleted file mode 100644
index e87fb4d1..00000000
--- a/tests/expectations/tests/issue-372.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct i {
-        pub j: *mut root::i,
-        pub k: *mut root::i,
-        pub l: bool,
-    }
-    #[test]
-    fn bindgen_test_layout_i() {
-        const UNINIT: ::std::mem::MaybeUninit<i> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<i>(),
-            24usize,
-            concat!("Size of: ", stringify!(i))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<i>(),
-            8usize,
-            concat!("Alignment of ", stringify!(i))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).j) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(i), "::", stringify!(j))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize },
-            8usize,
-            concat!("Offset of field: ", stringify!(i), "::", stringify!(k))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).l) as usize - ptr as usize },
-            16usize,
-            concat!("Offset of field: ", stringify!(i), "::", stringify!(l))
-        );
-    }
-    impl Default for i {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct d {
-        pub m: root::i,
-    }
-    #[test]
-    fn bindgen_test_layout_d() {
-        const UNINIT: ::std::mem::MaybeUninit<d> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<d>(),
-            24usize,
-            concat!("Size of: ", stringify!(d))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<d>(),
-            8usize,
-            concat!("Alignment of ", stringify!(d))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(d), "::", stringify!(m))
-        );
-    }
-    impl Default for d {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-    pub enum n {
-        o = 0,
-        p = 1,
-        q = 2,
-        r = 3,
-        s = 4,
-        t = 5,
-        b = 6,
-        ae = 7,
-        e = 8,
-        ag = 9,
-        ah = 10,
-        ai = 11,
-    }
-    #[repr(C)]
-    pub struct F {
-        pub w: [u64; 33usize],
-    }
-    #[test]
-    fn bindgen_test_layout_F() {
-        const UNINIT: ::std::mem::MaybeUninit<F> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<F>(),
-            264usize,
-            concat!("Size of: ", stringify!(F))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<F>(),
-            8usize,
-            concat!("Alignment of ", stringify!(F))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(F), "::", stringify!(w))
-        );
-    }
-    impl Default for F {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-410.rs b/tests/expectations/tests/issue-410.rs
deleted file mode 100644
index ad7463c2..00000000
--- a/tests/expectations/tests/issue-410.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod JS {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Value {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_Value() {
-            assert_eq!(
-                ::std::mem::size_of::<Value>(),
-                1usize,
-                concat!("Size of: ", stringify!(Value))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Value>(),
-                1usize,
-                concat!("Alignment of ", stringify!(Value))
-            );
-        }
-        extern "C" {
-            #[link_name = "\u{1}_ZN2JS5Value1aE10JSWhyMagic"]
-            pub fn Value_a(this: *mut root::JS::Value, arg1: root::JSWhyMagic);
-        }
-        impl Value {
-            #[inline]
-            pub unsafe fn a(&mut self, arg1: root::JSWhyMagic) {
-                Value_a(self, arg1)
-            }
-        }
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-    pub enum JSWhyMagic {
-        __bindgen_cannot_repr_c_on_empty_enum = 0,
-    }
-}
diff --git a/tests/expectations/tests/issue-446.rs b/tests/expectations/tests/issue-446.rs
deleted file mode 100644
index db69f159..00000000
--- a/tests/expectations/tests/issue-446.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct List {
-    pub next: *mut List,
-}
-impl Default for List {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct PersistentRooted {
-    pub root_list: List,
-}
-impl Default for PersistentRooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-447.rs b/tests/expectations/tests/issue-447.rs
deleted file mode 100644
index 949db73b..00000000
--- a/tests/expectations/tests/issue-447.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod mozilla {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod detail {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            #[repr(C)]
-            #[derive(Debug, Default, Copy, Clone)]
-            pub struct GuardObjectNotifier {
-                pub _address: u8,
-            }
-            #[test]
-            fn bindgen_test_layout_GuardObjectNotifier() {
-                assert_eq!(
-                    ::std::mem::size_of::<GuardObjectNotifier>(),
-                    1usize,
-                    concat!("Size of: ", stringify!(GuardObjectNotifier))
-                );
-                assert_eq!(
-                    ::std::mem::align_of::<GuardObjectNotifier>(),
-                    1usize,
-                    concat!("Alignment of ", stringify!(GuardObjectNotifier))
-                );
-            }
-        }
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct JSAutoCompartment {
-        pub _address: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_JSAutoCompartment() {
-        assert_eq!(
-            ::std::mem::size_of::<JSAutoCompartment>(),
-            1usize,
-            concat!("Size of: ", stringify!(JSAutoCompartment))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<JSAutoCompartment>(),
-            1usize,
-            concat!("Alignment of ", stringify!(JSAutoCompartment))
-        );
-    }
-    extern "C" {
-        #[link_name = "\u{1}_ZN17JSAutoCompartmentC1EN7mozilla6detail19GuardObjectNotifierE"]
-        pub fn JSAutoCompartment_JSAutoCompartment(
-            this: *mut root::JSAutoCompartment,
-            arg1: root::mozilla::detail::GuardObjectNotifier,
-        );
-    }
-    impl JSAutoCompartment {
-        #[inline]
-        pub unsafe fn new(
-            arg1: root::mozilla::detail::GuardObjectNotifier,
-        ) -> Self {
-            let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-            JSAutoCompartment_JSAutoCompartment(
-                __bindgen_tmp.as_mut_ptr(),
-                arg1,
-            );
-            __bindgen_tmp.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-493.rs b/tests/expectations/tests/issue-493.rs
deleted file mode 100644
index 61c7f792..00000000
--- a/tests/expectations/tests/issue-493.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string {
-    pub _address: u8,
-}
-pub type basic_string_size_type = ::std::os::raw::c_ulonglong;
-pub type basic_string_value_type = ::std::os::raw::c_char;
-pub type basic_string_pointer = *mut basic_string_value_type;
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___long {
-    pub __cap_: basic_string_size_type,
-    pub __size_: basic_string_size_type,
-    pub __data_: basic_string_pointer,
-}
-impl Default for basic_string___long {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub const basic_string___min_cap: basic_string__bindgen_ty_1 =
-    basic_string__bindgen_ty_1::__min_cap;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum basic_string__bindgen_ty_1 {
-    __min_cap = 0,
-}
-#[repr(C)]
-pub struct basic_string___short {
-    pub __bindgen_anon_1: basic_string___short__bindgen_ty_1,
-    pub __data_: *mut basic_string_value_type,
-}
-#[repr(C)]
-pub union basic_string___short__bindgen_ty_1 {
-    pub __size_: ::std::os::raw::c_uchar,
-    pub __lx: basic_string_value_type,
-}
-impl Default for basic_string___short__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for basic_string___short {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(1))]
-pub struct basic_string___ulx {
-    pub __lx: __BindgenUnionField<basic_string___long>,
-    pub __lxx: __BindgenUnionField<basic_string___short>,
-    pub bindgen_union_field: [u8; 0usize],
-}
-impl Default for basic_string___ulx {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub const basic_string___n_words: basic_string__bindgen_ty_2 =
-    basic_string__bindgen_ty_2::__n_words;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum basic_string__bindgen_ty_2 {
-    __n_words = 0,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___raw {
-    pub __words: *mut basic_string_size_type,
-}
-impl Default for basic_string___raw {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct basic_string___rep {
-    pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1,
-}
-#[repr(C)]
-#[repr(align(1))]
-pub struct basic_string___rep__bindgen_ty_1 {
-    pub __l: __BindgenUnionField<basic_string___long>,
-    pub __s: __BindgenUnionField<basic_string___short>,
-    pub __r: __BindgenUnionField<basic_string___raw>,
-    pub bindgen_union_field: [u8; 0usize],
-}
-impl Default for basic_string___rep__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for basic_string___rep {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-493_1_0.rs b/tests/expectations/tests/issue-493_1_0.rs
deleted file mode 100644
index 1a0131c3..00000000
--- a/tests/expectations/tests/issue-493_1_0.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string {
-    pub _address: u8,
-}
-pub type basic_string_size_type = ::std::os::raw::c_ulonglong;
-pub type basic_string_value_type = ::std::os::raw::c_char;
-pub type basic_string_pointer = *mut basic_string_value_type;
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___long {
-    pub __cap_: basic_string_size_type,
-    pub __size_: basic_string_size_type,
-    pub __data_: basic_string_pointer,
-}
-impl Default for basic_string___long {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-pub const basic_string___min_cap: basic_string__bindgen_ty_1 =
-    basic_string__bindgen_ty_1::__min_cap;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum basic_string__bindgen_ty_1 {
-    __min_cap = 0,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___short {
-    pub __bindgen_anon_1: basic_string___short__bindgen_ty_1,
-    pub __data_: *mut basic_string_value_type,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___short__bindgen_ty_1 {
-    pub __size_: __BindgenUnionField<::std::os::raw::c_uchar>,
-    pub __lx: __BindgenUnionField<basic_string_value_type>,
-    pub bindgen_union_field: u8,
-}
-impl Default for basic_string___short {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___ulx {
-    pub __lx: __BindgenUnionField<basic_string___long>,
-    pub __lxx: __BindgenUnionField<basic_string___short>,
-    pub bindgen_union_field: [u8; 0usize],
-}
-pub const basic_string___n_words: basic_string__bindgen_ty_2 =
-    basic_string__bindgen_ty_2::__n_words;
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum basic_string__bindgen_ty_2 {
-    __n_words = 0,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___raw {
-    pub __words: *mut basic_string_size_type,
-}
-impl Default for basic_string___raw {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___rep {
-    pub __bindgen_anon_1: basic_string___rep__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct basic_string___rep__bindgen_ty_1 {
-    pub __l: __BindgenUnionField<basic_string___long>,
-    pub __s: __BindgenUnionField<basic_string___short>,
-    pub __r: __BindgenUnionField<basic_string___raw>,
-    pub bindgen_union_field: [u8; 0usize],
-}
diff --git a/tests/expectations/tests/issue-511.rs b/tests/expectations/tests/issue-511.rs
deleted file mode 100644
index b7705ef2..00000000
--- a/tests/expectations/tests/issue-511.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub static mut a: *mut ::std::os::raw::c_char;
-}
-extern "C" {
-    pub static mut b: *const ::std::os::raw::c_char;
-}
-extern "C" {
-    pub static c: *mut ::std::os::raw::c_char;
-}
-extern "C" {
-    pub static d: *const ::std::os::raw::c_char;
-}
diff --git a/tests/expectations/tests/issue-537-repr-packed-n.rs b/tests/expectations/tests/issue-537-repr-packed-n.rs
deleted file mode 100644
index b1e42ca7..00000000
--- a/tests/expectations/tests/issue-537-repr-packed-n.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-
-/// This should not be opaque; we can see the attributes and can pack the
-/// struct.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AlignedToOne {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AlignedToOne() {
-    const UNINIT: ::std::mem::MaybeUninit<AlignedToOne> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AlignedToOne>(),
-        4usize,
-        concat!("Size of: ", stringify!(AlignedToOne))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AlignedToOne>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AlignedToOne))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AlignedToOne),
-            "::",
-            stringify!(i)
-        )
-    );
-}
-/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
-#[repr(C, packed(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AlignedToTwo {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AlignedToTwo() {
-    const UNINIT: ::std::mem::MaybeUninit<AlignedToTwo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AlignedToTwo>(),
-        4usize,
-        concat!("Size of: ", stringify!(AlignedToTwo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AlignedToTwo>(),
-        2usize,
-        concat!("Alignment of ", stringify!(AlignedToTwo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AlignedToTwo),
-            "::",
-            stringify!(i)
-        )
-    );
-}
-/// This should not be opaque because although `libclang` doesn't give us the
-/// `#pragma pack(1)`, we can detect that alignment is 1 and add
-/// `#[repr(packed)]` to the struct ourselves.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PackedToOne {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_PackedToOne() {
-    const UNINIT: ::std::mem::MaybeUninit<PackedToOne> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PackedToOne>(),
-        8usize,
-        concat!("Size of: ", stringify!(PackedToOne))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PackedToOne>(),
-        1usize,
-        concat!("Alignment of ", stringify!(PackedToOne))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToOne),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToOne),
-            "::",
-            stringify!(y)
-        )
-    );
-}
-/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
-#[repr(C, packed(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PackedToTwo {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_PackedToTwo() {
-    const UNINIT: ::std::mem::MaybeUninit<PackedToTwo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PackedToTwo>(),
-        8usize,
-        concat!("Size of: ", stringify!(PackedToTwo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PackedToTwo>(),
-        2usize,
-        concat!("Alignment of ", stringify!(PackedToTwo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToTwo),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToTwo),
-            "::",
-            stringify!(y)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-537.rs b/tests/expectations/tests/issue-537.rs
deleted file mode 100644
index e2be9d63..00000000
--- a/tests/expectations/tests/issue-537.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This should not be opaque; we can see the attributes and can pack the
-/// struct.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AlignedToOne {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AlignedToOne() {
-    const UNINIT: ::std::mem::MaybeUninit<AlignedToOne> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AlignedToOne>(),
-        4usize,
-        concat!("Size of: ", stringify!(AlignedToOne))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AlignedToOne>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AlignedToOne))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AlignedToOne),
-            "::",
-            stringify!(i)
-        )
-    );
-}
-/// This should be opaque because although we can see the attributes, Rust before
-/// 1.33 doesn't have `#[repr(packed(N))]`.
-#[repr(C, packed(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AlignedToTwo {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_AlignedToTwo() {
-    const UNINIT: ::std::mem::MaybeUninit<AlignedToTwo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AlignedToTwo>(),
-        4usize,
-        concat!("Size of: ", stringify!(AlignedToTwo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AlignedToTwo>(),
-        2usize,
-        concat!("Alignment of ", stringify!(AlignedToTwo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AlignedToTwo),
-            "::",
-            stringify!(i)
-        )
-    );
-}
-/// This should not be opaque because although `libclang` doesn't give us the
-/// `#pragma pack(1)`, we can detect that alignment is 1 and add
-/// `#[repr(packed)]` to the struct ourselves.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PackedToOne {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_PackedToOne() {
-    const UNINIT: ::std::mem::MaybeUninit<PackedToOne> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PackedToOne>(),
-        8usize,
-        concat!("Size of: ", stringify!(PackedToOne))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PackedToOne>(),
-        1usize,
-        concat!("Alignment of ", stringify!(PackedToOne))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToOne),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToOne),
-            "::",
-            stringify!(y)
-        )
-    );
-}
-/// In this case, even if we can detect the weird alignment triggered by
-/// `#pragma pack(2)`, we can't do anything about it because Rust before 1.33
-/// doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque.
-#[repr(C, packed(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PackedToTwo {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_PackedToTwo() {
-    const UNINIT: ::std::mem::MaybeUninit<PackedToTwo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PackedToTwo>(),
-        8usize,
-        concat!("Size of: ", stringify!(PackedToTwo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PackedToTwo>(),
-        2usize,
-        concat!("Alignment of ", stringify!(PackedToTwo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToTwo),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PackedToTwo),
-            "::",
-            stringify!(y)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-544-stylo-creduce-2.rs b/tests/expectations/tests/issue-544-stylo-creduce-2.rs
deleted file mode 100644
index 6165419d..00000000
--- a/tests/expectations/tests/issue-544-stylo-creduce-2.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Foo {
-    pub member: Foo_SecondAlias,
-}
-pub type Foo_FirstAlias = [u8; 0usize];
-pub type Foo_SecondAlias = [u8; 0usize];
-impl Default for Foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-544-stylo-creduce.rs b/tests/expectations/tests/issue-544-stylo-creduce.rs
deleted file mode 100644
index 1516c0a9..00000000
--- a/tests/expectations/tests/issue-544-stylo-creduce.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct a {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs b/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
deleted file mode 100644
index 997a7311..00000000
--- a/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const ENUM_VARIANT_1: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_1;
-pub const ENUM_VARIANT_2: _bindgen_ty_1 = _bindgen_ty_1::ENUM_VARIANT_2;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    ENUM_VARIANT_1 = 0,
-    ENUM_VARIANT_2 = 1,
-}
-pub type JS_Alias = u8;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct JS_Base {
-    pub f: JS_Alias,
-}
-impl Default for JS_Base {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct JS_AutoIdVector {
-    pub _base: JS_Base,
-}
-#[test]
-fn bindgen_test_layout_JS_AutoIdVector() {
-    assert_eq!(
-        ::std::mem::size_of::<JS_AutoIdVector>(),
-        1usize,
-        concat!("Size of: ", stringify!(JS_AutoIdVector))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<JS_AutoIdVector>(),
-        1usize,
-        concat!("Alignment of ", stringify!(JS_AutoIdVector))
-    );
-}
-impl Default for JS_AutoIdVector {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_JS_Base_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<JS_Base>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(JS_Base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<JS_Base>(),
-        1usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(JS_Base)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-573-layout-test-failures.rs b/tests/expectations/tests/issue-573-layout-test-failures.rs
deleted file mode 100644
index fbff1362..00000000
--- a/tests/expectations/tests/issue-573-layout-test-failures.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Outer {
-    pub i: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct AutoIdVector {
-    pub ar: Outer,
-}
-#[test]
-fn bindgen_test_layout_AutoIdVector() {
-    const UNINIT: ::std::mem::MaybeUninit<AutoIdVector> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<AutoIdVector>(),
-        1usize,
-        concat!("Size of: ", stringify!(AutoIdVector))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AutoIdVector>(),
-        1usize,
-        concat!("Alignment of ", stringify!(AutoIdVector))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(AutoIdVector),
-            "::",
-            stringify!(ar)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_Outer_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Outer>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(Outer))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Outer>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(Outer))
-    );
-}
diff --git a/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs b/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
deleted file mode 100644
index 22aa9d16..00000000
--- a/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct a {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct _bindgen_ty_1 {
-    pub ar: a,
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<_bindgen_ty_1>(),
-        1usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<_bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(ar)
-        )
-    );
-}
-extern "C" {
-    pub static mut AutoIdVector: _bindgen_ty_1;
-}
-#[test]
-fn __bindgen_test_layout_a_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(a))
-    );
-}
diff --git a/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs b/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
deleted file mode 100644
index 3765315c..00000000
--- a/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type RefPtr<T> = T;
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub _address: u8,
-}
-pub type A_a = b;
-#[test]
-fn bindgen_test_layout_A() {
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-}
-#[repr(C)]
-pub struct e<c> {
-    pub d: RefPtr<c>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<c>>,
-}
-impl<c> Default for e<c> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct f {
-    pub _address: u8,
-}
-#[repr(C)]
-pub struct g {
-    pub h: f,
-}
-#[test]
-fn bindgen_test_layout_g() {
-    const UNINIT: ::std::mem::MaybeUninit<g> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<g>(),
-        1usize,
-        concat!("Size of: ", stringify!(g))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<g>(),
-        1usize,
-        concat!("Alignment of ", stringify!(g))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(g), "::", stringify!(h))
-    );
-}
-impl Default for g {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct b {
-    pub _base: g,
-}
-#[test]
-fn bindgen_test_layout_b() {
-    assert_eq!(
-        ::std::mem::size_of::<b>(),
-        1usize,
-        concat!("Size of: ", stringify!(b))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<b>(),
-        1usize,
-        concat!("Alignment of ", stringify!(b))
-    );
-}
-impl Default for b {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z25Servo_Element_GetSnapshotv"]
-    pub fn Servo_Element_GetSnapshot() -> A;
-}
-#[test]
-fn __bindgen_test_layout_f_open0_e_open1_int_close1_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<f>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(f))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<f>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(f))
-    );
-}
diff --git a/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs b/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
deleted file mode 100644
index ba886f36..00000000
--- a/tests/expectations/tests/issue-638-stylo-cannot-find-T-in-this-scope.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct RefPtr<T> {
-    pub use_of_t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for RefPtr<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesRefPtrWithAliasedTypeParam<U> {
-    pub member: RefPtr<UsesRefPtrWithAliasedTypeParam_V<U>>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-pub type UsesRefPtrWithAliasedTypeParam_V<U> = U;
-impl<U> Default for UsesRefPtrWithAliasedTypeParam<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-639-typedef-anon-field.rs b/tests/expectations/tests/issue-639-typedef-anon-field.rs
deleted file mode 100644
index bac8a04c..00000000
--- a/tests/expectations/tests/issue-639-typedef-anon-field.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub bar: Foo_Bar,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo_Bar {
-    pub abc: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Foo_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo_Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo_Bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo_Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo_Bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo_Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).abc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Foo_Bar),
-            "::",
-            stringify!(abc)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(bar))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Baz {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Baz_Bar {
-    pub abc: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Baz_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Baz_Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Baz_Bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(Baz_Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz_Bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Baz_Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).abc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Baz_Bar),
-            "::",
-            stringify!(abc)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        1usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-}
diff --git a/tests/expectations/tests/issue-643-inner-struct.rs b/tests/expectations/tests/issue-643-inner-struct.rs
deleted file mode 100644
index b69aa16e..00000000
--- a/tests/expectations/tests/issue-643-inner-struct.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct rte_ring {
-    pub memzone: *mut rte_memzone,
-    pub prod: rte_ring_prod,
-    pub cons: rte_ring_cons,
-    pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_ring_prod {
-    pub watermark: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_rte_ring_prod() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ring_prod> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring_prod>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ring_prod))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring_prod>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ring_prod))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).watermark) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring_prod),
-            "::",
-            stringify!(watermark)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_ring_cons {
-    pub sc_dequeue: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_rte_ring_cons() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ring_cons> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring_cons>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ring_cons))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring_cons>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ring_cons))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sc_dequeue) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring_cons),
-            "::",
-            stringify!(sc_dequeue)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_ring() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_ring))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_ring))
-    );
-}
-impl Default for rte_ring {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_memzone {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs b/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
deleted file mode 100644
index 75d6581e..00000000
--- a/tests/expectations/tests/issue-645-cannot-find-type-T-in-this-scope.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[derive(Clone, Copy, Debug)]
-pub struct RefPtr<T>(T);
-
-#[repr(C)]
-pub struct HasRefPtr<T> {
-    pub refptr_member: RefPtr<HasRefPtr_TypedefOfT<T>>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-pub type HasRefPtr_TypedefOfT<T> = T;
-impl<T> Default for HasRefPtr<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-648-derive-debug-with-padding.rs b/tests/expectations/tests/issue-648-derive-debug-with-padding.rs
deleted file mode 100644
index 13cdf0c9..00000000
--- a/tests/expectations/tests/issue-648-derive-debug-with-padding.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// We emit a `[u8; 63usize]` padding field for this struct, which cannot derive
-/// Debug/Hash because 63 is over the hard coded limit.
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct NoDebug {
-    pub c: ::std::os::raw::c_char,
-}
-#[test]
-fn bindgen_test_layout_NoDebug() {
-    const UNINIT: ::std::mem::MaybeUninit<NoDebug> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoDebug>(),
-        64usize,
-        concat!("Size of: ", stringify!(NoDebug))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoDebug>(),
-        64usize,
-        concat!("Alignment of ", stringify!(NoDebug))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NoDebug),
-            "::",
-            stringify!(c)
-        )
-    );
-}
-impl Default for NoDebug {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for NoDebug {
-    fn eq(&self, other: &NoDebug) -> bool {
-        self.c == other.c
-    }
-}
-/// This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive
-/// Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because
-/// we determine Debug derive-ability before we compute padding, which happens at
-/// codegen.
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct ShouldDeriveDebugButDoesNot {
-    pub c: [::std::os::raw::c_char; 32usize],
-    pub d: ::std::os::raw::c_char,
-}
-#[test]
-fn bindgen_test_layout_ShouldDeriveDebugButDoesNot() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldDeriveDebugButDoesNot> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldDeriveDebugButDoesNot>(),
-        64usize,
-        concat!("Size of: ", stringify!(ShouldDeriveDebugButDoesNot))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldDeriveDebugButDoesNot>(),
-        64usize,
-        concat!("Alignment of ", stringify!(ShouldDeriveDebugButDoesNot))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldDeriveDebugButDoesNot),
-            "::",
-            stringify!(c)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldDeriveDebugButDoesNot),
-            "::",
-            stringify!(d)
-        )
-    );
-}
-impl Default for ShouldDeriveDebugButDoesNot {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for ShouldDeriveDebugButDoesNot {
-    fn eq(&self, other: &ShouldDeriveDebugButDoesNot) -> bool {
-        self.c == other.c && self.d == other.d
-    }
-}
diff --git a/tests/expectations/tests/issue-654-struct-fn-collision.rs b/tests/expectations/tests/issue-654-struct-fn-collision.rs
deleted file mode 100644
index 65d3a516..00000000
--- a/tests/expectations/tests/issue-654-struct-fn-collision.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    _unused: [u8; 0],
-}
-extern "C" {
-    pub fn foo() -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs b/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
deleted file mode 100644
index 5636a977..00000000
--- a/tests/expectations/tests/issue-662-cannot-find-T-in-this-scope.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct RefPtr<T> {
-    pub a: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for RefPtr<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsMainThreadPtrHolder<T> {
-    pub a: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for nsMainThreadPtrHolder<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsMainThreadPtrHandle<T> {
-    pub mPtr: RefPtr<nsMainThreadPtrHolder<T>>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for nsMainThreadPtrHandle<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-662-part-2.rs b/tests/expectations/tests/issue-662-part-2.rs
deleted file mode 100644
index e8d14bfe..00000000
--- a/tests/expectations/tests/issue-662-part-2.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[derive(Clone, Copy, Debug)]
-pub struct RefPtr<T>(T);
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsMainThreadPtrHolder<T> {
-    pub a: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for nsMainThreadPtrHolder<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct nsMainThreadPtrHandle<U> {
-    pub mPtr: RefPtr<nsMainThreadPtrHolder<U>>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<U> Default for nsMainThreadPtrHandle<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-674-1.rs b/tests/expectations/tests/issue-674-1.rs
deleted file mode 100644
index b37d7a27..00000000
--- a/tests/expectations/tests/issue-674-1.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod mozilla {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Maybe {
-            pub _address: u8,
-        }
-        pub type Maybe_ValueType<T> = T;
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct CapturingContentInfo {
-        pub a: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_CapturingContentInfo() {
-        const UNINIT: ::std::mem::MaybeUninit<CapturingContentInfo> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<CapturingContentInfo>(),
-            1usize,
-            concat!("Size of: ", stringify!(CapturingContentInfo))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<CapturingContentInfo>(),
-            1usize,
-            concat!("Alignment of ", stringify!(CapturingContentInfo))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(CapturingContentInfo),
-                "::",
-                stringify!(a)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/issue-674-2.rs b/tests/expectations/tests/issue-674-2.rs
deleted file mode 100644
index 12b2aa20..00000000
--- a/tests/expectations/tests/issue-674-2.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod JS {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Rooted {
-            pub _address: u8,
-        }
-        pub type Rooted_ElementType<T> = T;
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct c {
-        pub b: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_c() {
-        const UNINIT: ::std::mem::MaybeUninit<c> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<c>(),
-            1usize,
-            concat!("Size of: ", stringify!(c))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<c>(),
-            1usize,
-            concat!("Alignment of ", stringify!(c))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(c), "::", stringify!(b))
-        );
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct B {
-        pub a: root::c,
-    }
-    #[test]
-    fn bindgen_test_layout_B() {
-        const UNINIT: ::std::mem::MaybeUninit<B> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<B>(),
-            1usize,
-            concat!("Size of: ", stringify!(B))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<B>(),
-            1usize,
-            concat!("Alignment of ", stringify!(B))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(B), "::", stringify!(a))
-        );
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct StaticRefPtr {
-        pub _address: u8,
-    }
-    #[test]
-    fn __bindgen_test_layout_StaticRefPtr_open0_B_close0_instantiation() {
-        assert_eq!(
-            ::std::mem::size_of::<root::StaticRefPtr>(),
-            1usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::StaticRefPtr)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::StaticRefPtr>(),
-            1usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::StaticRefPtr)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/issue-674-3.rs b/tests/expectations/tests/issue-674-3.rs
deleted file mode 100644
index e7af6b8d..00000000
--- a/tests/expectations/tests/issue-674-3.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct nsRefPtrHashtable {
-        pub _address: u8,
-    }
-    pub type nsRefPtrHashtable_UserDataType<PtrType> = *mut PtrType;
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct a {
-        pub b: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_a() {
-        const UNINIT: ::std::mem::MaybeUninit<a> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<a>(),
-            1usize,
-            concat!("Size of: ", stringify!(a))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<a>(),
-            1usize,
-            concat!("Alignment of ", stringify!(a))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-            0usize,
-            concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
-        );
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct nsCSSValue {
-        pub c: root::a,
-    }
-    #[test]
-    fn bindgen_test_layout_nsCSSValue() {
-        const UNINIT: ::std::mem::MaybeUninit<nsCSSValue> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<nsCSSValue>(),
-            1usize,
-            concat!("Size of: ", stringify!(nsCSSValue))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<nsCSSValue>(),
-            1usize,
-            concat!("Alignment of ", stringify!(nsCSSValue))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(nsCSSValue),
-                "::",
-                stringify!(c)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/issue-677-nested-ns-specifier.rs b/tests/expectations/tests/issue-677-nested-ns-specifier.rs
deleted file mode 100644
index 800f0dc8..00000000
--- a/tests/expectations/tests/issue-677-nested-ns-specifier.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod bar {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            pub type bar = ::std::os::raw::c_int;
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-691-template-parameter-virtual.rs b/tests/expectations/tests/issue-691-template-parameter-virtual.rs
deleted file mode 100644
index e71b2aae..00000000
--- a/tests/expectations/tests/issue-691-template-parameter-virtual.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct VirtualMethods__bindgen_vtable {}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct VirtualMethods {
-    pub vtable_: *const VirtualMethods__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_VirtualMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<VirtualMethods>(),
-        8usize,
-        concat!("Size of: ", stringify!(VirtualMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<VirtualMethods>(),
-        8usize,
-        concat!("Alignment of ", stringify!(VirtualMethods))
-    );
-}
-impl Default for VirtualMethods {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Set {
-    pub bar: ::std::os::raw::c_int,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ServoElementSnapshotTable {
-    pub _base: Set,
-}
-#[test]
-fn bindgen_test_layout_ServoElementSnapshotTable() {
-    assert_eq!(
-        ::std::mem::size_of::<ServoElementSnapshotTable>(),
-        4usize,
-        concat!("Size of: ", stringify!(ServoElementSnapshotTable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ServoElementSnapshotTable>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ServoElementSnapshotTable))
-    );
-}
-impl Default for ServoElementSnapshotTable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_Set_open0_VirtualMethods_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Set>(),
-        4usize,
-        concat!("Size of template specialization: ", stringify!(Set))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Set>(),
-        4usize,
-        concat!("Alignment of template specialization: ", stringify!(Set))
-    );
-}
diff --git a/tests/expectations/tests/issue-710-must-use-type.rs b/tests/expectations/tests/issue-710-must-use-type.rs
deleted file mode 100644
index 1d598241..00000000
--- a/tests/expectations/tests/issue-710-must-use-type.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-#[must_use]
-pub struct A {
-    _unused: [u8; 0],
-}
-/// <div rustbindgen mustusetype></div>
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-#[must_use]
-pub struct B {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct C {
-    _unused: [u8; 0],
-}
diff --git a/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
deleted file mode 100644
index 1a633844..00000000
--- a/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(target_os = "windows"))]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 32usize]>,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        32usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-impl Foo {
-    #[inline]
-    pub fn m_bitfield(&self) -> ::std::os::raw::c_ulong {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 64u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_m_bitfield(&mut self, val: ::std::os::raw::c_ulong) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 64u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn m_bar(&self) -> ::std::os::raw::c_ulong {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(64usize, 64u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_m_bar(&mut self, val: ::std::os::raw::c_ulong) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(64usize, 64u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn foo(&self) -> ::std::os::raw::c_ulong {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(128usize, 1u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_foo(&mut self, val: ::std::os::raw::c_ulong) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(128usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bar(&self) -> ::std::os::raw::c_ulong {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(192usize, 64u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_bar(&mut self, val: ::std::os::raw::c_ulong) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(192usize, 64u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        m_bitfield: ::std::os::raw::c_ulong,
-        m_bar: ::std::os::raw::c_ulong,
-        foo: ::std::os::raw::c_ulong,
-        bar: ::std::os::raw::c_ulong,
-    ) -> __BindgenBitfieldUnit<[u8; 32usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 32usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 64u8, {
-            let m_bitfield: u64 = unsafe { ::std::mem::transmute(m_bitfield) };
-            m_bitfield as u64
-        });
-        __bindgen_bitfield_unit.set(64usize, 64u8, {
-            let m_bar: u64 = unsafe { ::std::mem::transmute(m_bar) };
-            m_bar as u64
-        });
-        __bindgen_bitfield_unit.set(128usize, 1u8, {
-            let foo: u64 = unsafe { ::std::mem::transmute(foo) };
-            foo as u64
-        });
-        __bindgen_bitfield_unit.set(192usize, 64u8, {
-            let bar: u64 = unsafe { ::std::mem::transmute(bar) };
-            bar as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/issue-801-opaque-sloppiness.rs b/tests/expectations/tests/issue-801-opaque-sloppiness.rs
deleted file mode 100644
index b3192b72..00000000
--- a/tests/expectations/tests/issue-801-opaque-sloppiness.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct A {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[repr(align(1))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct B {
-    pub _bindgen_opaque_blob: u8,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        1usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        1usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1B1aE"]
-    pub static mut B_a: A;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct C {
-    pub b: B,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        1usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        1usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(b))
-    );
-}
diff --git a/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs b/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
deleted file mode 100644
index f8869528..00000000
--- a/tests/expectations/tests/issue-807-opaque-types-methods-being-generated.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Pupper {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Pupper() {
-    assert_eq!(
-        ::std::mem::size_of::<Pupper>(),
-        1usize,
-        concat!("Size of: ", stringify!(Pupper))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Pupper>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Pupper))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Doggo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Doggo() {
-    assert_eq!(
-        ::std::mem::size_of::<Doggo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Doggo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Doggo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Doggo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct SuchWow {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_SuchWow() {
-    assert_eq!(
-        ::std::mem::size_of::<SuchWow>(),
-        1usize,
-        concat!("Size of: ", stringify!(SuchWow))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<SuchWow>(),
-        1usize,
-        concat!("Alignment of ", stringify!(SuchWow))
-    );
-}
-#[repr(C)]
-#[repr(align(1))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Opaque {
-    pub _bindgen_opaque_blob: u8,
-}
-#[test]
-fn bindgen_test_layout_Opaque() {
-    assert_eq!(
-        ::std::mem::size_of::<Opaque>(),
-        1usize,
-        concat!("Size of: ", stringify!(Opaque))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Opaque>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Opaque))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN6Opaque17eleven_out_of_tenEv"]
-    pub fn Opaque_eleven_out_of_ten(this: *mut Opaque) -> SuchWow;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN6OpaqueC1E6Pupper"]
-    pub fn Opaque_Opaque(this: *mut Opaque, pup: Pupper);
-}
-impl Opaque {
-    #[inline]
-    pub unsafe fn eleven_out_of_ten(&mut self) -> SuchWow {
-        Opaque_eleven_out_of_ten(self)
-    }
-    #[inline]
-    pub unsafe fn new(pup: Pupper) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        Opaque_Opaque(__bindgen_tmp.as_mut_ptr(), pup);
-        __bindgen_tmp.assume_init()
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN6Opaque11MAJESTIC_AFE"]
-    pub static mut Opaque_MAJESTIC_AF: Doggo;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Allowlisted {
-    pub some_member: Opaque,
-}
-#[test]
-fn bindgen_test_layout_Allowlisted() {
-    const UNINIT: ::std::mem::MaybeUninit<Allowlisted> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Allowlisted>(),
-        1usize,
-        concat!("Size of: ", stringify!(Allowlisted))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Allowlisted>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Allowlisted))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).some_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Allowlisted),
-            "::",
-            stringify!(some_member)
-        )
-    );
-}
diff --git a/tests/expectations/tests/issue-816.rs b/tests/expectations/tests/issue-816.rs
deleted file mode 100644
index c7f94106..00000000
--- a/tests/expectations/tests/issue-816.rs
+++ /dev/null
@@ -1,860 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct capabilities {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
-}
-#[test]
-fn bindgen_test_layout_capabilities() {
-    assert_eq!(
-        ::std::mem::size_of::<capabilities>(),
-        16usize,
-        concat!("Size of: ", stringify!(capabilities))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<capabilities>(),
-        4usize,
-        concat!("Alignment of ", stringify!(capabilities))
-    );
-}
-impl capabilities {
-    #[inline]
-    pub fn bit_1(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_1(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_2(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_2(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_3(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_3(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_4(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_4(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_5(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_5(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_6(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_6(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_7(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_7(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_8(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_8(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_9(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_9(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_10(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_10(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_11(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_11(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(10usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_12(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_12(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(11usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_13(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_13(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_14(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_14(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(13usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_15(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_15(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(14usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_16(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_16(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(15usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_17(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_17(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_18(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_18(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(17usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_19(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_19(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(18usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_20(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_20(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(19usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_21(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_21(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(20usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_22(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_22(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(21usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_23(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_23(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(22usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_24(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_24(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(23usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_25(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_25(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_26(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_26(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(25usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_27(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_27(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(26usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_28(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_28(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(27usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_29(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_29(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(28usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_30(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_30(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(29usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_31(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_31(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(30usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_32(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_32(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(31usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_33(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_33(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(32usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_34(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_34(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(33usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_35(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_35(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(34usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_36(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_36(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(35usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_37(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_37(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(36usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_38(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_38(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(37usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_39(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_39(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(38usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_40(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_40(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(39usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bit_41(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bit_41(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(40usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        bit_1: ::std::os::raw::c_uint,
-        bit_2: ::std::os::raw::c_uint,
-        bit_3: ::std::os::raw::c_uint,
-        bit_4: ::std::os::raw::c_uint,
-        bit_5: ::std::os::raw::c_uint,
-        bit_6: ::std::os::raw::c_uint,
-        bit_7: ::std::os::raw::c_uint,
-        bit_8: ::std::os::raw::c_uint,
-        bit_9: ::std::os::raw::c_uint,
-        bit_10: ::std::os::raw::c_uint,
-        bit_11: ::std::os::raw::c_uint,
-        bit_12: ::std::os::raw::c_uint,
-        bit_13: ::std::os::raw::c_uint,
-        bit_14: ::std::os::raw::c_uint,
-        bit_15: ::std::os::raw::c_uint,
-        bit_16: ::std::os::raw::c_uint,
-        bit_17: ::std::os::raw::c_uint,
-        bit_18: ::std::os::raw::c_uint,
-        bit_19: ::std::os::raw::c_uint,
-        bit_20: ::std::os::raw::c_uint,
-        bit_21: ::std::os::raw::c_uint,
-        bit_22: ::std::os::raw::c_uint,
-        bit_23: ::std::os::raw::c_uint,
-        bit_24: ::std::os::raw::c_uint,
-        bit_25: ::std::os::raw::c_uint,
-        bit_26: ::std::os::raw::c_uint,
-        bit_27: ::std::os::raw::c_uint,
-        bit_28: ::std::os::raw::c_uint,
-        bit_29: ::std::os::raw::c_uint,
-        bit_30: ::std::os::raw::c_uint,
-        bit_31: ::std::os::raw::c_uint,
-        bit_32: ::std::os::raw::c_uint,
-        bit_33: ::std::os::raw::c_uint,
-        bit_34: ::std::os::raw::c_uint,
-        bit_35: ::std::os::raw::c_uint,
-        bit_36: ::std::os::raw::c_uint,
-        bit_37: ::std::os::raw::c_uint,
-        bit_38: ::std::os::raw::c_uint,
-        bit_39: ::std::os::raw::c_uint,
-        bit_40: ::std::os::raw::c_uint,
-        bit_41: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let bit_1: u32 = unsafe { ::std::mem::transmute(bit_1) };
-            bit_1 as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let bit_2: u32 = unsafe { ::std::mem::transmute(bit_2) };
-            bit_2 as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let bit_3: u32 = unsafe { ::std::mem::transmute(bit_3) };
-            bit_3 as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let bit_4: u32 = unsafe { ::std::mem::transmute(bit_4) };
-            bit_4 as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let bit_5: u32 = unsafe { ::std::mem::transmute(bit_5) };
-            bit_5 as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let bit_6: u32 = unsafe { ::std::mem::transmute(bit_6) };
-            bit_6 as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let bit_7: u32 = unsafe { ::std::mem::transmute(bit_7) };
-            bit_7 as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let bit_8: u32 = unsafe { ::std::mem::transmute(bit_8) };
-            bit_8 as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let bit_9: u32 = unsafe { ::std::mem::transmute(bit_9) };
-            bit_9 as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 1u8, {
-            let bit_10: u32 = unsafe { ::std::mem::transmute(bit_10) };
-            bit_10 as u64
-        });
-        __bindgen_bitfield_unit.set(10usize, 1u8, {
-            let bit_11: u32 = unsafe { ::std::mem::transmute(bit_11) };
-            bit_11 as u64
-        });
-        __bindgen_bitfield_unit.set(11usize, 1u8, {
-            let bit_12: u32 = unsafe { ::std::mem::transmute(bit_12) };
-            bit_12 as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 1u8, {
-            let bit_13: u32 = unsafe { ::std::mem::transmute(bit_13) };
-            bit_13 as u64
-        });
-        __bindgen_bitfield_unit.set(13usize, 1u8, {
-            let bit_14: u32 = unsafe { ::std::mem::transmute(bit_14) };
-            bit_14 as u64
-        });
-        __bindgen_bitfield_unit.set(14usize, 1u8, {
-            let bit_15: u32 = unsafe { ::std::mem::transmute(bit_15) };
-            bit_15 as u64
-        });
-        __bindgen_bitfield_unit.set(15usize, 1u8, {
-            let bit_16: u32 = unsafe { ::std::mem::transmute(bit_16) };
-            bit_16 as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 1u8, {
-            let bit_17: u32 = unsafe { ::std::mem::transmute(bit_17) };
-            bit_17 as u64
-        });
-        __bindgen_bitfield_unit.set(17usize, 1u8, {
-            let bit_18: u32 = unsafe { ::std::mem::transmute(bit_18) };
-            bit_18 as u64
-        });
-        __bindgen_bitfield_unit.set(18usize, 1u8, {
-            let bit_19: u32 = unsafe { ::std::mem::transmute(bit_19) };
-            bit_19 as u64
-        });
-        __bindgen_bitfield_unit.set(19usize, 1u8, {
-            let bit_20: u32 = unsafe { ::std::mem::transmute(bit_20) };
-            bit_20 as u64
-        });
-        __bindgen_bitfield_unit.set(20usize, 1u8, {
-            let bit_21: u32 = unsafe { ::std::mem::transmute(bit_21) };
-            bit_21 as u64
-        });
-        __bindgen_bitfield_unit.set(21usize, 1u8, {
-            let bit_22: u32 = unsafe { ::std::mem::transmute(bit_22) };
-            bit_22 as u64
-        });
-        __bindgen_bitfield_unit.set(22usize, 1u8, {
-            let bit_23: u32 = unsafe { ::std::mem::transmute(bit_23) };
-            bit_23 as u64
-        });
-        __bindgen_bitfield_unit.set(23usize, 1u8, {
-            let bit_24: u32 = unsafe { ::std::mem::transmute(bit_24) };
-            bit_24 as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 1u8, {
-            let bit_25: u32 = unsafe { ::std::mem::transmute(bit_25) };
-            bit_25 as u64
-        });
-        __bindgen_bitfield_unit.set(25usize, 1u8, {
-            let bit_26: u32 = unsafe { ::std::mem::transmute(bit_26) };
-            bit_26 as u64
-        });
-        __bindgen_bitfield_unit.set(26usize, 1u8, {
-            let bit_27: u32 = unsafe { ::std::mem::transmute(bit_27) };
-            bit_27 as u64
-        });
-        __bindgen_bitfield_unit.set(27usize, 1u8, {
-            let bit_28: u32 = unsafe { ::std::mem::transmute(bit_28) };
-            bit_28 as u64
-        });
-        __bindgen_bitfield_unit.set(28usize, 1u8, {
-            let bit_29: u32 = unsafe { ::std::mem::transmute(bit_29) };
-            bit_29 as u64
-        });
-        __bindgen_bitfield_unit.set(29usize, 1u8, {
-            let bit_30: u32 = unsafe { ::std::mem::transmute(bit_30) };
-            bit_30 as u64
-        });
-        __bindgen_bitfield_unit.set(30usize, 1u8, {
-            let bit_31: u32 = unsafe { ::std::mem::transmute(bit_31) };
-            bit_31 as u64
-        });
-        __bindgen_bitfield_unit.set(31usize, 1u8, {
-            let bit_32: u32 = unsafe { ::std::mem::transmute(bit_32) };
-            bit_32 as u64
-        });
-        __bindgen_bitfield_unit.set(32usize, 1u8, {
-            let bit_33: u32 = unsafe { ::std::mem::transmute(bit_33) };
-            bit_33 as u64
-        });
-        __bindgen_bitfield_unit.set(33usize, 1u8, {
-            let bit_34: u32 = unsafe { ::std::mem::transmute(bit_34) };
-            bit_34 as u64
-        });
-        __bindgen_bitfield_unit.set(34usize, 1u8, {
-            let bit_35: u32 = unsafe { ::std::mem::transmute(bit_35) };
-            bit_35 as u64
-        });
-        __bindgen_bitfield_unit.set(35usize, 1u8, {
-            let bit_36: u32 = unsafe { ::std::mem::transmute(bit_36) };
-            bit_36 as u64
-        });
-        __bindgen_bitfield_unit.set(36usize, 1u8, {
-            let bit_37: u32 = unsafe { ::std::mem::transmute(bit_37) };
-            bit_37 as u64
-        });
-        __bindgen_bitfield_unit.set(37usize, 1u8, {
-            let bit_38: u32 = unsafe { ::std::mem::transmute(bit_38) };
-            bit_38 as u64
-        });
-        __bindgen_bitfield_unit.set(38usize, 1u8, {
-            let bit_39: u32 = unsafe { ::std::mem::transmute(bit_39) };
-            bit_39 as u64
-        });
-        __bindgen_bitfield_unit.set(39usize, 1u8, {
-            let bit_40: u32 = unsafe { ::std::mem::transmute(bit_40) };
-            bit_40 as u64
-        });
-        __bindgen_bitfield_unit.set(40usize, 1u8, {
-            let bit_41: u32 = unsafe { ::std::mem::transmute(bit_41) };
-            bit_41 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs b/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
deleted file mode 100644
index cfe00784..00000000
--- a/tests/expectations/tests/issue-820-unused-template-param-in-alias.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type Foo_self_type = u8;
diff --git a/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs b/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
deleted file mode 100644
index f5ba025a..00000000
--- a/tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/issue-833-1.rs b/tests/expectations/tests/issue-833-1.rs
deleted file mode 100644
index f91266f6..00000000
--- a/tests/expectations/tests/issue-833-1.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct nsTArray {
-    pub hdr: *const (),
-}
-
-extern "C" {
-    pub fn func() -> *mut nsTArray;
-}
diff --git a/tests/expectations/tests/issue-833-2.rs b/tests/expectations/tests/issue-833-2.rs
deleted file mode 100644
index 1dfe1abd..00000000
--- a/tests/expectations/tests/issue-833-2.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-// If the output of this changes, please ensure issue-833-1.hpp changes too
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct nsTArray {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/issue-833.rs b/tests/expectations/tests/issue-833.rs
deleted file mode 100644
index a092fb71..00000000
--- a/tests/expectations/tests/issue-833.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct nsTArray<T> {
-    pub hdr: *const T,
-}
-
-extern "C" {
-    pub fn func() -> *mut nsTArray<::std::os::raw::c_int>;
-}
diff --git a/tests/expectations/tests/issue-834.rs b/tests/expectations/tests/issue-834.rs
deleted file mode 100644
index 465341fb..00000000
--- a/tests/expectations/tests/issue-834.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct U {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_U() {
-    assert_eq!(
-        ::std::mem::size_of::<U>(),
-        1usize,
-        concat!("Size of: ", stringify!(U))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<U>(),
-        1usize,
-        concat!("Alignment of ", stringify!(U))
-    );
-}
diff --git a/tests/expectations/tests/issue-848-replacement-system-include.rs b/tests/expectations/tests/issue-848-replacement-system-include.rs
deleted file mode 100644
index 294df575..00000000
--- a/tests/expectations/tests/issue-848-replacement-system-include.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This is intended to replace another type, but won't if we treat this include
-/// as a system include, because clang doesn't parse comments there.
-///
-/// See #848.
-///
-/// <div rustbindgen replaces="nsTArray"></div>
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsTArray<T> {
-    pub m: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for nsTArray<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    pub fn func() -> *mut nsTArray<::std::os::raw::c_int>;
-}
diff --git a/tests/expectations/tests/issue-888-enum-var-decl-jump.rs b/tests/expectations/tests/issue-888-enum-var-decl-jump.rs
deleted file mode 100644
index 6ac308a7..00000000
--- a/tests/expectations/tests/issue-888-enum-var-decl-jump.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod Halide {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Type {
-            pub _address: u8,
-        }
-        extern "C" {
-            #[link_name = "\u{1}_ZN6Halide4Type1bE"]
-            pub static mut Type_b: root::a;
-        }
-        #[test]
-        fn bindgen_test_layout_Type() {
-            assert_eq!(
-                ::std::mem::size_of::<Type>(),
-                1usize,
-                concat!("Size of: ", stringify!(Type))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Type>(),
-                1usize,
-                concat!("Alignment of ", stringify!(Type))
-            );
-        }
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-    pub enum a {
-        __bindgen_cannot_repr_c_on_empty_enum = 0,
-    }
-}
diff --git a/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs b/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
deleted file mode 100644
index d9c365d8..00000000
--- a/tests/expectations/tests/issue-944-derive-copy-and-blocklisting.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub struct BlocklistMe(u8);
-
-/// Because this type contains a blocklisted type, it should not derive Copy.
-#[repr(C)]
-pub struct ShouldNotBeCopy {
-    pub a: BlocklistMe,
-}
-#[test]
-fn bindgen_test_layout_ShouldNotBeCopy() {
-    const UNINIT: ::std::mem::MaybeUninit<ShouldNotBeCopy> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ShouldNotBeCopy>(),
-        1usize,
-        concat!("Size of: ", stringify!(ShouldNotBeCopy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ShouldNotBeCopy>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ShouldNotBeCopy))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ShouldNotBeCopy),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for ShouldNotBeCopy {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/issue-946.rs b/tests/expectations/tests/issue-946.rs
deleted file mode 100644
index 897700b3..00000000
--- a/tests/expectations/tests/issue-946.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {}
-#[test]
-fn bindgen_test_layout_foo() {
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        0usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-}
-pub type bar = foo;
diff --git a/tests/expectations/tests/issue_311.rs b/tests/expectations/tests/issue_311.rs
deleted file mode 100644
index 49e30d84..00000000
--- a/tests/expectations/tests/issue_311.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct jsval_layout {
-        pub __bindgen_anon_1: root::jsval_layout__bindgen_ty_1,
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct jsval_layout__bindgen_ty_1 {
-        pub _address: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
-        assert_eq!(
-            ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
-            1usize,
-            concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
-            1usize,
-            concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
-        );
-    }
-    #[test]
-    fn bindgen_test_layout_jsval_layout() {
-        assert_eq!(
-            ::std::mem::size_of::<jsval_layout>(),
-            1usize,
-            concat!("Size of: ", stringify!(jsval_layout))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<jsval_layout>(),
-            1usize,
-            concat!("Alignment of ", stringify!(jsval_layout))
-        );
-    }
-}
diff --git a/tests/expectations/tests/issue_315.rs b/tests/expectations/tests/issue_315.rs
deleted file mode 100644
index 71ae1f27..00000000
--- a/tests/expectations/tests/issue_315.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen replaces="c"></div>
-pub type c<a> = a;
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
deleted file mode 100644
index a812e905..00000000
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ /dev/null
@@ -1,514 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-pub const JSVAL_TAG_SHIFT: u32 = 47;
-pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
-pub const JSVAL_TAG_MASK: i64 = -140737488355328;
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueType {
-    JSVAL_TYPE_DOUBLE = 0,
-    JSVAL_TYPE_INT32 = 1,
-    JSVAL_TYPE_UNDEFINED = 2,
-    JSVAL_TYPE_BOOLEAN = 3,
-    JSVAL_TYPE_MAGIC = 4,
-    JSVAL_TYPE_STRING = 5,
-    JSVAL_TYPE_SYMBOL = 6,
-    JSVAL_TYPE_NULL = 7,
-    JSVAL_TYPE_OBJECT = 8,
-    JSVAL_TYPE_UNKNOWN = 32,
-    JSVAL_TYPE_MISSING = 33,
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueTag {
-    JSVAL_TAG_MAX_DOUBLE = 131056,
-    JSVAL_TAG_INT32 = 131057,
-    JSVAL_TAG_UNDEFINED = 131058,
-    JSVAL_TAG_STRING = 131061,
-    JSVAL_TAG_SYMBOL = 131062,
-    JSVAL_TAG_BOOLEAN = 131059,
-    JSVAL_TAG_MAGIC = 131060,
-    JSVAL_TAG_NULL = 131063,
-    JSVAL_TAG_OBJECT = 131064,
-}
-#[repr(u64)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueShiftedTag {
-    JSVAL_SHIFTED_TAG_MAX_DOUBLE = 18444492278190833663,
-    JSVAL_SHIFTED_TAG_INT32 = 18444633011384221696,
-    JSVAL_SHIFTED_TAG_UNDEFINED = 18444773748872577024,
-    JSVAL_SHIFTED_TAG_STRING = 18445195961337643008,
-    JSVAL_SHIFTED_TAG_SYMBOL = 18445336698825998336,
-    JSVAL_SHIFTED_TAG_BOOLEAN = 18444914486360932352,
-    JSVAL_SHIFTED_TAG_MAGIC = 18445055223849287680,
-    JSVAL_SHIFTED_TAG_NULL = 18445477436314353664,
-    JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992,
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSWhyMagic {
-    /// a hole in a native object's elements
-    JS_ELEMENTS_HOLE = 0,
-    /// there is not a pending iterator value
-    JS_NO_ITER_VALUE = 1,
-    /// exception value thrown when closing a generator
-    JS_GENERATOR_CLOSING = 2,
-    /// compiler sentinel value
-    JS_NO_CONSTANT = 3,
-    /// used in debug builds to catch tracing errors
-    JS_THIS_POISON = 4,
-    /// used in debug builds to catch tracing errors
-    JS_ARG_POISON = 5,
-    /// an empty subnode in the AST serializer
-    JS_SERIALIZE_NO_NODE = 6,
-    /// lazy arguments value on the stack
-    JS_LAZY_ARGUMENTS = 7,
-    /// optimized-away 'arguments' value
-    JS_OPTIMIZED_ARGUMENTS = 8,
-    /// magic value passed to natives to indicate construction
-    JS_IS_CONSTRUCTING = 9,
-    /// arguments.callee has been overwritten
-    JS_OVERWRITTEN_CALLEE = 10,
-    /// value of static block object slot
-    JS_BLOCK_NEEDS_CLONE = 11,
-    /// see class js::HashableValue
-    JS_HASH_KEY_EMPTY = 12,
-    /// error while running Ion code
-    JS_ION_ERROR = 13,
-    /// missing recover instruction result
-    JS_ION_BAILOUT = 14,
-    /// optimized out slot
-    JS_OPTIMIZED_OUT = 15,
-    /// uninitialized lexical bindings that produce ReferenceError on touch.
-    JS_UNINITIALIZED_LEXICAL = 16,
-    /// for local use
-    JS_GENERIC_MAGIC = 17,
-    /// for local use
-    JS_WHY_MAGIC_COUNT = 18,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union jsval_layout {
-    pub asBits: u64,
-    pub debugView: jsval_layout__bindgen_ty_1,
-    pub s: jsval_layout__bindgen_ty_2,
-    pub asDouble: f64,
-    pub asPtr: *mut ::std::os::raw::c_void,
-    pub asWord: usize,
-    pub asUIntPtr: usize,
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct jsval_layout__bindgen_ty_1 {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
-    );
-}
-impl Default for jsval_layout__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl jsval_layout__bindgen_ty_1 {
-    #[inline]
-    pub fn payload47(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 47u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_payload47(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 47u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tag(&self) -> JSValueTag {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(47usize, 17u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tag(&mut self, val: JSValueTag) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(47usize, 17u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        payload47: u64,
-        tag: JSValueTag,
-    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 47u8, {
-            let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
-            payload47 as u64
-        });
-        __bindgen_bitfield_unit.set(47usize, 17u8, {
-            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
-            tag as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct jsval_layout__bindgen_ty_2 {
-    pub payload: jsval_layout__bindgen_ty_2__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union jsval_layout__bindgen_ty_2__bindgen_ty_1 {
-    pub i32_: i32,
-    pub u32_: u32,
-    pub why: JSWhyMagic,
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_2__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        jsval_layout__bindgen_ty_2__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(i32_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(u32_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).why) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(why)
-        )
-    );
-}
-impl Default for jsval_layout__bindgen_ty_2__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<jsval_layout__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2),
-            "::",
-            stringify!(payload)
-        )
-    );
-}
-impl Default for jsval_layout__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_jsval_layout() {
-    const UNINIT: ::std::mem::MaybeUninit<jsval_layout> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout>(),
-        8usize,
-        concat!("Size of: ", stringify!(jsval_layout))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout>(),
-        8usize,
-        concat!("Alignment of ", stringify!(jsval_layout))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asBits) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asBits)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).debugView) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(debugView)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(s)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asDouble)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asPtr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asPtr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asWord) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asWord)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).asUIntPtr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asUIntPtr)
-        )
-    );
-}
-impl Default for jsval_layout {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Value {
-    pub data: jsval_layout,
-}
-#[test]
-fn bindgen_test_layout_Value() {
-    const UNINIT: ::std::mem::MaybeUninit<Value> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Value>(),
-        8usize,
-        concat!("Size of: ", stringify!(Value))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Value>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Value))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Value),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Default for Value {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/tests/expectations/tests/jsval_layout_opaque_1_0.rs
deleted file mode 100644
index b4394993..00000000
--- a/tests/expectations/tests/jsval_layout_opaque_1_0.rs
+++ /dev/null
@@ -1,548 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-pub const JSVAL_TAG_SHIFT: u32 = 47;
-pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327;
-pub const JSVAL_TAG_MASK: i64 = -140737488355328;
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueType {
-    JSVAL_TYPE_DOUBLE = 0,
-    JSVAL_TYPE_INT32 = 1,
-    JSVAL_TYPE_UNDEFINED = 2,
-    JSVAL_TYPE_BOOLEAN = 3,
-    JSVAL_TYPE_MAGIC = 4,
-    JSVAL_TYPE_STRING = 5,
-    JSVAL_TYPE_SYMBOL = 6,
-    JSVAL_TYPE_NULL = 7,
-    JSVAL_TYPE_OBJECT = 8,
-    JSVAL_TYPE_UNKNOWN = 32,
-    JSVAL_TYPE_MISSING = 33,
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueTag {
-    JSVAL_TAG_MAX_DOUBLE = 131056,
-    JSVAL_TAG_INT32 = 131057,
-    JSVAL_TAG_UNDEFINED = 131058,
-    JSVAL_TAG_STRING = 131061,
-    JSVAL_TAG_SYMBOL = 131062,
-    JSVAL_TAG_BOOLEAN = 131059,
-    JSVAL_TAG_MAGIC = 131060,
-    JSVAL_TAG_NULL = 131063,
-    JSVAL_TAG_OBJECT = 131064,
-}
-#[repr(u64)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSValueShiftedTag {
-    JSVAL_SHIFTED_TAG_MAX_DOUBLE = 18444492278190833663,
-    JSVAL_SHIFTED_TAG_INT32 = 18444633011384221696,
-    JSVAL_SHIFTED_TAG_UNDEFINED = 18444773748872577024,
-    JSVAL_SHIFTED_TAG_STRING = 18445195961337643008,
-    JSVAL_SHIFTED_TAG_SYMBOL = 18445336698825998336,
-    JSVAL_SHIFTED_TAG_BOOLEAN = 18444914486360932352,
-    JSVAL_SHIFTED_TAG_MAGIC = 18445055223849287680,
-    JSVAL_SHIFTED_TAG_NULL = 18445477436314353664,
-    JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992,
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum JSWhyMagic {
-    /// a hole in a native object's elements
-    JS_ELEMENTS_HOLE = 0,
-    /// there is not a pending iterator value
-    JS_NO_ITER_VALUE = 1,
-    /// exception value thrown when closing a generator
-    JS_GENERATOR_CLOSING = 2,
-    /// compiler sentinel value
-    JS_NO_CONSTANT = 3,
-    /// used in debug builds to catch tracing errors
-    JS_THIS_POISON = 4,
-    /// used in debug builds to catch tracing errors
-    JS_ARG_POISON = 5,
-    /// an empty subnode in the AST serializer
-    JS_SERIALIZE_NO_NODE = 6,
-    /// lazy arguments value on the stack
-    JS_LAZY_ARGUMENTS = 7,
-    /// optimized-away 'arguments' value
-    JS_OPTIMIZED_ARGUMENTS = 8,
-    /// magic value passed to natives to indicate construction
-    JS_IS_CONSTRUCTING = 9,
-    /// arguments.callee has been overwritten
-    JS_OVERWRITTEN_CALLEE = 10,
-    /// value of static block object slot
-    JS_BLOCK_NEEDS_CLONE = 11,
-    /// see class js::HashableValue
-    JS_HASH_KEY_EMPTY = 12,
-    /// error while running Ion code
-    JS_ION_ERROR = 13,
-    /// missing recover instruction result
-    JS_ION_BAILOUT = 14,
-    /// optimized out slot
-    JS_OPTIMIZED_OUT = 15,
-    /// uninitialized lexical bindings that produce ReferenceError on touch.
-    JS_UNINITIALIZED_LEXICAL = 16,
-    /// for local use
-    JS_GENERIC_MAGIC = 17,
-    /// for local use
-    JS_WHY_MAGIC_COUNT = 18,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct jsval_layout {
-    pub asBits: __BindgenUnionField<u64>,
-    pub debugView: __BindgenUnionField<jsval_layout__bindgen_ty_1>,
-    pub s: __BindgenUnionField<jsval_layout__bindgen_ty_2>,
-    pub asDouble: __BindgenUnionField<f64>,
-    pub asPtr: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub asWord: __BindgenUnionField<usize>,
-    pub asUIntPtr: __BindgenUnionField<usize>,
-    pub bindgen_union_field: u64,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct jsval_layout__bindgen_ty_1 {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
-    pub __bindgen_align: [u64; 0usize],
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_1))
-    );
-}
-impl Clone for jsval_layout__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for jsval_layout__bindgen_ty_1 {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl jsval_layout__bindgen_ty_1 {
-    #[inline]
-    pub fn payload47(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 47u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_payload47(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 47u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tag(&self) -> JSValueTag {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(47usize, 17u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tag(&mut self, val: JSValueTag) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(47usize, 17u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        payload47: u64,
-        tag: JSValueTag,
-    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 47u8, {
-            let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
-            payload47 as u64
-        });
-        __bindgen_bitfield_unit.set(47usize, 17u8, {
-            let tag: u32 = unsafe { ::std::mem::transmute(tag) };
-            tag as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct jsval_layout__bindgen_ty_2 {
-    pub payload: jsval_layout__bindgen_ty_2__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct jsval_layout__bindgen_ty_2__bindgen_ty_1 {
-    pub i32_: __BindgenUnionField<i32>,
-    pub u32_: __BindgenUnionField<u32>,
-    pub why: __BindgenUnionField<JSWhyMagic>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_2__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        jsval_layout__bindgen_ty_2__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(i32_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u32_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(u32_)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).why) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2__bindgen_ty_1),
-            "::",
-            stringify!(why)
-        )
-    );
-}
-impl Clone for jsval_layout__bindgen_ty_2__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_jsval_layout__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<jsval_layout__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(jsval_layout__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(jsval_layout__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout__bindgen_ty_2),
-            "::",
-            stringify!(payload)
-        )
-    );
-}
-impl Clone for jsval_layout__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_jsval_layout() {
-    const UNINIT: ::std::mem::MaybeUninit<jsval_layout> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<jsval_layout>(),
-        8usize,
-        concat!("Size of: ", stringify!(jsval_layout))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<jsval_layout>(),
-        8usize,
-        concat!("Alignment of ", stringify!(jsval_layout))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asBits) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asBits)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).debugView) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(debugView)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(s)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asDouble)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asPtr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asPtr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).asWord) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asWord)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).asUIntPtr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(jsval_layout),
-            "::",
-            stringify!(asUIntPtr)
-        )
-    );
-}
-impl Clone for jsval_layout {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct Value {
-    pub data: jsval_layout,
-}
-#[test]
-fn bindgen_test_layout_Value() {
-    const UNINIT: ::std::mem::MaybeUninit<Value> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Value>(),
-        8usize,
-        concat!("Size of: ", stringify!(Value))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Value>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Value))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Value),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Clone for Value {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/keywords.rs b/tests/expectations/tests/keywords.rs
deleted file mode 100644
index a1e7f877..00000000
--- a/tests/expectations/tests/keywords.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}u8"]
-    pub static mut u8_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}u16"]
-    pub static mut u16_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}u32"]
-    pub static mut u32_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}u64"]
-    pub static mut u64_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}i8"]
-    pub static mut i8_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}i16"]
-    pub static mut i16_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}i32"]
-    pub static mut i32_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}i64"]
-    pub static mut i64_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}f32"]
-    pub static mut f32_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}f64"]
-    pub static mut f64_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}usize"]
-    pub static mut usize_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}isize"]
-    pub static mut isize_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}bool"]
-    pub static mut bool_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}str"]
-    pub static mut str_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}dyn"]
-    pub static mut dyn_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}as"]
-    pub static mut as_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}async"]
-    pub static mut async_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}await"]
-    pub static mut await_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}box"]
-    pub static mut box_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}crate"]
-    pub static mut crate_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}false"]
-    pub static mut false_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}fn"]
-    pub static mut fn_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}impl"]
-    pub static mut impl_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}in"]
-    pub static mut in_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}let"]
-    pub static mut let_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}loop"]
-    pub static mut loop_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}match"]
-    pub static mut match_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}mod"]
-    pub static mut mod_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}move"]
-    pub static mut move_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}mut"]
-    pub static mut mut_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}pub"]
-    pub static mut pub_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}ref"]
-    pub static mut ref_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}self"]
-    pub static mut self_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}Self"]
-    pub static mut Self_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}super"]
-    pub static mut super_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}trait"]
-    pub static mut trait_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}true"]
-    pub static mut true_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}try"]
-    pub static mut try_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}type"]
-    pub static mut type_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}unsafe"]
-    pub static mut unsafe_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}use"]
-    pub static mut use_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}where"]
-    pub static mut where_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}abstract"]
-    pub static mut abstract_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}alignof"]
-    pub static mut alignof_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}become"]
-    pub static mut become_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}final"]
-    pub static mut final_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}macro"]
-    pub static mut macro_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}offsetof"]
-    pub static mut offsetof_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}override"]
-    pub static mut override_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}priv"]
-    pub static mut priv_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}proc"]
-    pub static mut proc_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}pure"]
-    pub static mut pure_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}unsized"]
-    pub static mut unsized_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}virtual"]
-    pub static mut virtual_: ::std::os::raw::c_int;
-}
-extern "C" {
-    #[link_name = "\u{1}yield"]
-    pub static mut yield_: ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/layout.rs b/tests/expectations/tests/layout.rs
deleted file mode 100644
index ae417259..00000000
--- a/tests/expectations/tests/layout.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct header {
-    pub _bindgen_opaque_blob: [u8; 16usize],
-}
-#[test]
-fn bindgen_test_layout_header() {
-    assert_eq!(
-        ::std::mem::size_of::<header>(),
-        16usize,
-        concat!("Size of: ", stringify!(header))
-    );
-}
-impl Default for header {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs
deleted file mode 100644
index 466e7686..00000000
--- a/tests/expectations/tests/layout_align.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct rte_kni_fifo {
-    ///< Next position to be written
-    pub write: ::std::os::raw::c_uint,
-    ///< Next position to be read
-    pub read: ::std::os::raw::c_uint,
-    ///< Circular buffer length
-    pub len: ::std::os::raw::c_uint,
-    ///< Pointer size - for 32/64 bit OS
-    pub elem_size: ::std::os::raw::c_uint,
-    ///< The buffer contains mbuf pointers
-    pub buffer: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[test]
-fn bindgen_test_layout_rte_kni_fifo() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_kni_fifo>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_kni_fifo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_kni_fifo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_kni_fifo))
-    );
-}
-impl Default for rte_kni_fifo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_eth_link {
-    ///< ETH_SPEED_NUM_
-    pub link_speed: u32,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_link() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_link> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_link>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_eth_link))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_link>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_link))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).link_speed) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_link),
-            "::",
-            stringify!(link_speed)
-        )
-    );
-}
-impl rte_eth_link {
-    #[inline]
-    pub fn link_duplex(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_duplex(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn link_autoneg(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_autoneg(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn link_status(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_status(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        link_duplex: u16,
-        link_autoneg: u16,
-        link_status: u16,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let link_duplex: u16 =
-                unsafe { ::std::mem::transmute(link_duplex) };
-            link_duplex as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let link_autoneg: u16 =
-                unsafe { ::std::mem::transmute(link_autoneg) };
-            link_autoneg as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let link_status: u16 =
-                unsafe { ::std::mem::transmute(link_status) };
-            link_status as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/layout_arp.rs b/tests/expectations/tests/layout_arp.rs
deleted file mode 100644
index 6852c236..00000000
--- a/tests/expectations/tests/layout_arp.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const ETHER_ADDR_LEN: u32 = 6;
-pub const ARP_HRD_ETHER: u32 = 1;
-pub const ARP_OP_REQUEST: u32 = 1;
-pub const ARP_OP_REPLY: u32 = 2;
-pub const ARP_OP_REVREQUEST: u32 = 3;
-pub const ARP_OP_REVREPLY: u32 = 4;
-pub const ARP_OP_INVREQUEST: u32 = 8;
-pub const ARP_OP_INVREPLY: u32 = 9;
-/// Ethernet address:
-/// A universally administered address is uniquely assigned to a device by its
-/// manufacturer. The first three octets (in transmission order) contain the
-/// Organizationally Unique Identifier (OUI). The following three (MAC-48 and
-/// EUI-48) octets are assigned by that organization with the only constraint
-/// of uniqueness.
-/// A locally administered address is assigned to a device by a network
-/// administrator and does not contain OUIs.
-/// See http://standards.ieee.org/regauth/groupmac/tutorial.html
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ether_addr {
-    ///< Addr bytes in tx order
-    pub addr_bytes: [u8; 6usize],
-}
-#[test]
-fn bindgen_test_layout_ether_addr() {
-    const UNINIT: ::std::mem::MaybeUninit<ether_addr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ether_addr>(),
-        6usize,
-        concat!("Size of: ", stringify!(ether_addr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ether_addr>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ether_addr))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).addr_bytes) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ether_addr),
-            "::",
-            stringify!(addr_bytes)
-        )
-    );
-}
-/// ARP header IPv4 payload.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct arp_ipv4 {
-    ///< sender hardware address
-    pub arp_sha: ether_addr,
-    ///< sender IP address
-    pub arp_sip: u32,
-    ///< target hardware address
-    pub arp_tha: ether_addr,
-    ///< target IP address
-    pub arp_tip: u32,
-}
-#[test]
-fn bindgen_test_layout_arp_ipv4() {
-    const UNINIT: ::std::mem::MaybeUninit<arp_ipv4> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<arp_ipv4>(),
-        20usize,
-        concat!("Size of: ", stringify!(arp_ipv4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<arp_ipv4>(),
-        1usize,
-        concat!("Alignment of ", stringify!(arp_ipv4))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_sha) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_ipv4),
-            "::",
-            stringify!(arp_sha)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_sip) as usize - ptr as usize },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_ipv4),
-            "::",
-            stringify!(arp_sip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_tha) as usize - ptr as usize },
-        10usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_ipv4),
-            "::",
-            stringify!(arp_tha)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_tip) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_ipv4),
-            "::",
-            stringify!(arp_tip)
-        )
-    );
-}
-/// ARP header.
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct arp_hdr {
-    pub arp_hrd: u16,
-    pub arp_pro: u16,
-    pub arp_hln: u8,
-    pub arp_pln: u8,
-    pub arp_op: u16,
-    pub arp_data: arp_ipv4,
-}
-#[test]
-fn bindgen_test_layout_arp_hdr() {
-    const UNINIT: ::std::mem::MaybeUninit<arp_hdr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<arp_hdr>(),
-        28usize,
-        concat!("Size of: ", stringify!(arp_hdr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<arp_hdr>(),
-        1usize,
-        concat!("Alignment of ", stringify!(arp_hdr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_hrd) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_hrd)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_pro) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_pro)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_hln) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_hln)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_pln) as usize - ptr as usize },
-        5usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_pln)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arp_op) as usize - ptr as usize },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_op)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).arp_data) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(arp_hdr),
-            "::",
-            stringify!(arp_data)
-        )
-    );
-}
diff --git a/tests/expectations/tests/layout_array.rs b/tests/expectations/tests/layout_array.rs
deleted file mode 100644
index daf0ad06..00000000
--- a/tests/expectations/tests/layout_array.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-pub const RTE_MEMPOOL_OPS_NAMESIZE: u32 = 32;
-pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16;
-pub const RTE_HEAP_NUM_FREELISTS: u32 = 13;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct rte_mempool {
-    _unused: [u8; 0],
-}
-/// Prototype for implementation specific data provisioning function.
-///
-/// The function should provide the implementation specific memory for
-/// for use by the other mempool ops functions in a given mempool ops struct.
-/// E.g. the default ops provides an instance of the rte_ring for this purpose.
-/// it will most likely point to a different type of data structure, and
-/// will be transparent to the application programmer.
-/// This function should set mp->pool_data.
-pub type rte_mempool_alloc_t = ::std::option::Option<
-    unsafe extern "C" fn(mp: *mut rte_mempool) -> ::std::os::raw::c_int,
->;
-/// Free the opaque private data pointed to by mp->pool_data pointer.
-pub type rte_mempool_free_t =
-    ::std::option::Option<unsafe extern "C" fn(mp: *mut rte_mempool)>;
-/// Enqueue an object into the external pool.
-pub type rte_mempool_enqueue_t = ::std::option::Option<
-    unsafe extern "C" fn(
-        mp: *mut rte_mempool,
-        obj_table: *const *mut ::std::os::raw::c_void,
-        n: ::std::os::raw::c_uint,
-    ) -> ::std::os::raw::c_int,
->;
-/// Dequeue an object from the external pool.
-pub type rte_mempool_dequeue_t = ::std::option::Option<
-    unsafe extern "C" fn(
-        mp: *mut rte_mempool,
-        obj_table: *mut *mut ::std::os::raw::c_void,
-        n: ::std::os::raw::c_uint,
-    ) -> ::std::os::raw::c_int,
->;
-/// Return the number of available objects in the external pool.
-pub type rte_mempool_get_count = ::std::option::Option<
-    unsafe extern "C" fn(mp: *const rte_mempool) -> ::std::os::raw::c_uint,
->;
-/// Structure defining mempool operations structure
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct rte_mempool_ops {
-    ///< Name of mempool ops struct.
-    pub name: [::std::os::raw::c_char; 32usize],
-    ///< Allocate private data.
-    pub alloc: rte_mempool_alloc_t,
-    ///< Free the external pool.
-    pub free: rte_mempool_free_t,
-    ///< Enqueue an object.
-    pub enqueue: rte_mempool_enqueue_t,
-    ///< Dequeue an object.
-    pub dequeue: rte_mempool_dequeue_t,
-    ///< Get qty of available objs.
-    pub get_count: rte_mempool_get_count,
-}
-#[test]
-fn bindgen_test_layout_rte_mempool_ops() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mempool_ops> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mempool_ops>(),
-        128usize,
-        concat!("Size of: ", stringify!(rte_mempool_ops))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mempool_ops>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_mempool_ops))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(name)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(alloc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(free)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).enqueue) as usize - ptr as usize },
-        48usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(enqueue)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dequeue) as usize - ptr as usize },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(dequeue)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).get_count) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops),
-            "::",
-            stringify!(get_count)
-        )
-    );
-}
-impl Default for rte_mempool_ops {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for rte_mempool_ops {
-    fn eq(&self, other: &rte_mempool_ops) -> bool {
-        self.name == other.name &&
-            self.alloc == other.alloc &&
-            self.free == other.free &&
-            self.enqueue == other.enqueue &&
-            self.dequeue == other.dequeue &&
-            self.get_count == other.get_count
-    }
-}
-/// The rte_spinlock_t type.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_spinlock_t {
-    ///< lock status 0 = unlocked, 1 = locked
-    pub locked: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_rte_spinlock_t() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_spinlock_t> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_spinlock_t>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_spinlock_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_spinlock_t>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_spinlock_t))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).locked) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_spinlock_t),
-            "::",
-            stringify!(locked)
-        )
-    );
-}
-/// Structure storing the table of registered ops structs, each of which contain
-/// the function pointers for the mempool ops functions.
-/// Each process has its own storage for this ops struct array so that
-/// the mempools can be shared across primary and secondary processes.
-/// The indices used to access the array are valid across processes, whereas
-/// any function pointers stored directly in the mempool struct would not be.
-/// This results in us simply having "ops_index" in the mempool struct.
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct rte_mempool_ops_table {
-    ///< Spinlock for add/delete.
-    pub sl: rte_spinlock_t,
-    ///< Number of used ops structs in the table.
-    pub num_ops: u32,
-    pub __bindgen_padding_0: [u64; 7usize],
-    /// Storage for all possible ops structs.
-    pub ops: [rte_mempool_ops; 16usize],
-}
-#[test]
-fn bindgen_test_layout_rte_mempool_ops_table() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mempool_ops_table> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mempool_ops_table>(),
-        2112usize,
-        concat!("Size of: ", stringify!(rte_mempool_ops_table))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mempool_ops_table>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_mempool_ops_table))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sl) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops_table),
-            "::",
-            stringify!(sl)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).num_ops) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops_table),
-            "::",
-            stringify!(num_ops)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mempool_ops_table),
-            "::",
-            stringify!(ops)
-        )
-    );
-}
-impl Default for rte_mempool_ops_table {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// Structure to hold malloc heap
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct malloc_heap {
-    pub lock: rte_spinlock_t,
-    pub free_head: [malloc_heap__bindgen_ty_1; 13usize],
-    pub alloc_count: ::std::os::raw::c_uint,
-    pub total_size: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct malloc_heap__bindgen_ty_1 {
-    pub lh_first: *mut malloc_elem,
-}
-#[test]
-fn bindgen_test_layout_malloc_heap__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<malloc_heap__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<malloc_heap__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(malloc_heap__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<malloc_heap__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(malloc_heap__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).lh_first) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(malloc_heap__bindgen_ty_1),
-            "::",
-            stringify!(lh_first)
-        )
-    );
-}
-impl Default for malloc_heap__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_malloc_heap() {
-    const UNINIT: ::std::mem::MaybeUninit<malloc_heap> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<malloc_heap>(),
-        128usize,
-        concat!("Size of: ", stringify!(malloc_heap))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<malloc_heap>(),
-        64usize,
-        concat!("Alignment of ", stringify!(malloc_heap))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lock) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(malloc_heap),
-            "::",
-            stringify!(lock)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).free_head) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(malloc_heap),
-            "::",
-            stringify!(free_head)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).alloc_count) as usize - ptr as usize
-        },
-        112usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(malloc_heap),
-            "::",
-            stringify!(alloc_count)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
-        },
-        120usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(malloc_heap),
-            "::",
-            stringify!(total_size)
-        )
-    );
-}
-impl Default for malloc_heap {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for malloc_heap {
-    fn eq(&self, other: &malloc_heap) -> bool {
-        self.lock == other.lock &&
-            self.free_head == other.free_head &&
-            self.alloc_count == other.alloc_count &&
-            self.total_size == other.total_size
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct malloc_elem {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/layout_array_too_long.rs b/tests/expectations/tests/layout_array_too_long.rs
deleted file mode 100644
index 56b3c021..00000000
--- a/tests/expectations/tests/layout_array_too_long.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4;
-pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX;
-pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX;
-pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM;
-pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    ///< index of last fragment
-    IP_LAST_FRAG_IDX = 0,
-    ///< index of first fragment
-    IP_FIRST_FRAG_IDX = 1,
-    ///< minimum number of fragments
-    IP_MIN_FRAG_NUM = 2,
-    IP_MAX_FRAG_NUM = 4,
-}
-/// @internal fragmented mbuf
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ip_frag {
-    ///< offset into the packet
-    pub ofs: u16,
-    ///< length of fragment
-    pub len: u16,
-    ///< fragment mbuf
-    pub mb: *mut rte_mbuf,
-}
-#[test]
-fn bindgen_test_layout_ip_frag() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag>(),
-        16usize,
-        concat!("Size of: ", stringify!(ip_frag))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ofs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(ofs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(len)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mb) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(mb)
-        )
-    );
-}
-impl Default for ip_frag {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ip_frag_key {
-    ///< src address, first 8 bytes used for IPv4
-    pub src_dst: [u64; 4usize],
-    ///< dst address
-    pub id: u32,
-    ///< src/dst key length
-    pub key_len: u32,
-}
-#[test]
-fn bindgen_test_layout_ip_frag_key() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_key> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_key>(),
-        40usize,
-        concat!("Size of: ", stringify!(ip_frag_key))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_key>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag_key))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_dst) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(src_dst)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).key_len) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(key_len)
-        )
-    );
-}
-/// @internal Fragmented packet to reassemble.
-/// First two entries in the frags[] array are for the last and first fragments.
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct ip_frag_pkt {
-    ///< LRU list
-    pub lru: ip_frag_pkt__bindgen_ty_1,
-    ///< fragmentation key
-    pub key: ip_frag_key,
-    ///< creation timestamp
-    pub start: u64,
-    ///< expected reassembled size
-    pub total_size: u32,
-    ///< size of fragments received
-    pub frag_size: u32,
-    ///< index of next entry to fill
-    pub last_idx: u32,
-    ///< fragments
-    pub frags: [ip_frag; 4usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ip_frag_pkt__bindgen_ty_1 {
-    pub tqe_next: *mut ip_frag_pkt,
-    pub tqe_prev: *mut *mut ip_frag_pkt,
-}
-#[test]
-fn bindgen_test_layout_ip_frag_pkt__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(ip_frag_pkt__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag_pkt__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqe_next) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt__bindgen_ty_1),
-            "::",
-            stringify!(tqe_next)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqe_prev) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt__bindgen_ty_1),
-            "::",
-            stringify!(tqe_prev)
-        )
-    );
-}
-impl Default for ip_frag_pkt__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_ip_frag_pkt() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_pkt>(),
-        192usize,
-        concat!("Size of: ", stringify!(ip_frag_pkt))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_pkt>(),
-        64usize,
-        concat!("Alignment of ", stringify!(ip_frag_pkt))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(lru)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(key)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(start)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(total_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).frag_size) as usize - ptr as usize
-        },
-        68usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(frag_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).last_idx) as usize - ptr as usize
-        },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(last_idx)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).frags) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(frags)
-        )
-    );
-}
-impl Default for ip_frag_pkt {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for ip_frag_pkt {
-    fn eq(&self, other: &ip_frag_pkt) -> bool {
-        self.lru == other.lru &&
-            self.key == other.key &&
-            self.start == other.start &&
-            self.total_size == other.total_size &&
-            self.frag_size == other.frag_size &&
-            self.last_idx == other.last_idx &&
-            self.frags == other.frags
-    }
-}
-///< fragment mbuf
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mbuf {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/layout_cmdline_token.rs b/tests/expectations/tests/layout_cmdline_token.rs
deleted file mode 100644
index 899703bd..00000000
--- a/tests/expectations/tests/layout_cmdline_token.rs
+++ /dev/null
@@ -1,285 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// Stores a pointer to the ops struct, and the offset: the place to
-/// write the parsed result in the destination structure.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct cmdline_token_hdr {
-    pub ops: *mut cmdline_token_ops,
-    pub offset: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_cmdline_token_hdr() {
-    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_hdr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<cmdline_token_hdr>(),
-        16usize,
-        concat!("Size of: ", stringify!(cmdline_token_hdr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<cmdline_token_hdr>(),
-        8usize,
-        concat!("Alignment of ", stringify!(cmdline_token_hdr))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_hdr),
-            "::",
-            stringify!(ops)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_hdr),
-            "::",
-            stringify!(offset)
-        )
-    );
-}
-impl Default for cmdline_token_hdr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// Stores a pointer to the ops struct, and the offset: the place to
-/// write the parsed result in the destination structure.
-pub type cmdline_parse_token_hdr_t = cmdline_token_hdr;
-/// A token is defined by this structure.
-///
-/// parse() takes the token as first argument, then the source buffer
-/// starting at the token we want to parse. The 3rd arg is a pointer
-/// where we store the parsed data (as binary). It returns the number of
-/// parsed chars on success and a negative value on error.
-///
-/// complete_get_nb() returns the number of possible values for this
-/// token if completion is possible. If it is NULL or if it returns 0,
-/// no completion is possible.
-///
-/// complete_get_elt() copy in dstbuf (the size is specified in the
-/// parameter) the i-th possible completion for this token.  returns 0
-/// on success or and a negative value on error.
-///
-/// get_help() fills the dstbuf with the help for the token. It returns
-/// -1 on error and 0 on success.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct cmdline_token_ops {
-    /// parse(token ptr, buf, res pts, buf len)
-    pub parse: ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: *mut cmdline_parse_token_hdr_t,
-            arg2: *const ::std::os::raw::c_char,
-            arg3: *mut ::std::os::raw::c_void,
-            arg4: ::std::os::raw::c_uint,
-        ) -> ::std::os::raw::c_int,
-    >,
-    /// return the num of possible choices for this token
-    pub complete_get_nb: ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: *mut cmdline_parse_token_hdr_t,
-        ) -> ::std::os::raw::c_int,
-    >,
-    /// return the elt x for this token (token, idx, dstbuf, size)
-    pub complete_get_elt: ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: *mut cmdline_parse_token_hdr_t,
-            arg2: ::std::os::raw::c_int,
-            arg3: *mut ::std::os::raw::c_char,
-            arg4: ::std::os::raw::c_uint,
-        ) -> ::std::os::raw::c_int,
-    >,
-    /// get help for this token (token, dstbuf, size)
-    pub get_help: ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: *mut cmdline_parse_token_hdr_t,
-            arg2: *mut ::std::os::raw::c_char,
-            arg3: ::std::os::raw::c_uint,
-        ) -> ::std::os::raw::c_int,
-    >,
-}
-#[test]
-fn bindgen_test_layout_cmdline_token_ops() {
-    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_ops> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<cmdline_token_ops>(),
-        32usize,
-        concat!("Size of: ", stringify!(cmdline_token_ops))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<cmdline_token_ops>(),
-        8usize,
-        concat!("Alignment of ", stringify!(cmdline_token_ops))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).parse) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_ops),
-            "::",
-            stringify!(parse)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).complete_get_nb) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_ops),
-            "::",
-            stringify!(complete_get_nb)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).complete_get_elt) as usize -
-                ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_ops),
-            "::",
-            stringify!(complete_get_elt)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).get_help) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_ops),
-            "::",
-            stringify!(get_help)
-        )
-    );
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum cmdline_numtype {
-    UINT8 = 0,
-    UINT16 = 1,
-    UINT32 = 2,
-    UINT64 = 3,
-    INT8 = 4,
-    INT16 = 5,
-    INT32 = 6,
-    INT64 = 7,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct cmdline_token_num_data {
-    pub type_: cmdline_numtype,
-}
-#[test]
-fn bindgen_test_layout_cmdline_token_num_data() {
-    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_num_data> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<cmdline_token_num_data>(),
-        4usize,
-        concat!("Size of: ", stringify!(cmdline_token_num_data))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<cmdline_token_num_data>(),
-        4usize,
-        concat!("Alignment of ", stringify!(cmdline_token_num_data))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_num_data),
-            "::",
-            stringify!(type_)
-        )
-    );
-}
-impl Default for cmdline_token_num_data {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct cmdline_token_num {
-    pub hdr: cmdline_token_hdr,
-    pub num_data: cmdline_token_num_data,
-}
-#[test]
-fn bindgen_test_layout_cmdline_token_num() {
-    const UNINIT: ::std::mem::MaybeUninit<cmdline_token_num> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<cmdline_token_num>(),
-        24usize,
-        concat!("Size of: ", stringify!(cmdline_token_num))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<cmdline_token_num>(),
-        8usize,
-        concat!("Alignment of ", stringify!(cmdline_token_num))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_num),
-            "::",
-            stringify!(hdr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).num_data) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(cmdline_token_num),
-            "::",
-            stringify!(num_data)
-        )
-    );
-}
-impl Default for cmdline_token_num {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type cmdline_parse_token_num_t = cmdline_token_num;
diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs
deleted file mode 100644
index 62b99e90..00000000
--- a/tests/expectations/tests/layout_eth_conf.rs
+++ /dev/null
@@ -1,2192 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-pub const ETH_MQ_RX_RSS_FLAG: u32 = 1;
-pub const ETH_MQ_RX_DCB_FLAG: u32 = 2;
-pub const ETH_MQ_RX_VMDQ_FLAG: u32 = 4;
-pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64;
-pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8;
-pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128;
-pub const ETH_DCB_NUM_QUEUES: u32 = 128;
-pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16;
-pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128;
-pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0;
-pub const RTE_ETH_FLOW_RAW: u32 = 1;
-pub const RTE_ETH_FLOW_IPV4: u32 = 2;
-pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7;
-pub const RTE_ETH_FLOW_IPV6: u32 = 8;
-pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13;
-pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14;
-pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15;
-pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16;
-pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17;
-pub const RTE_ETH_FLOW_PORT: u32 = 18;
-pub const RTE_ETH_FLOW_VXLAN: u32 = 19;
-pub const RTE_ETH_FLOW_GENEVE: u32 = 20;
-pub const RTE_ETH_FLOW_NVGRE: u32 = 21;
-pub const RTE_ETH_FLOW_MAX: u32 = 22;
-#[repr(u32)]
-///  A set of values to identify what method is to be used to route
-///  packets to multiple queues.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_rx_mq_mode {
-    /// None of DCB,RSS or VMDQ mode
-    ETH_MQ_RX_NONE = 0,
-    /// For RX side, only RSS is on
-    ETH_MQ_RX_RSS = 1,
-    /// For RX side,only DCB is on.
-    ETH_MQ_RX_DCB = 2,
-    /// Both DCB and RSS enable
-    ETH_MQ_RX_DCB_RSS = 3,
-    /// Only VMDQ, no RSS nor DCB
-    ETH_MQ_RX_VMDQ_ONLY = 4,
-    /// RSS mode with VMDQ
-    ETH_MQ_RX_VMDQ_RSS = 5,
-    /// Use VMDQ+DCB to route traffic to queues
-    ETH_MQ_RX_VMDQ_DCB = 6,
-    /// Enable both VMDQ and DCB in VMDq
-    ETH_MQ_RX_VMDQ_DCB_RSS = 7,
-}
-/// A structure used to configure the RX features of an Ethernet port.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_rxmode {
-    /// The multi-queue packet distribution mode to be used, e.g. RSS.
-    pub mq_mode: rte_eth_rx_mq_mode,
-    ///< Only used if jumbo_frame enabled.
-    pub max_rx_pkt_len: u32,
-    ///< hdr buf size (header_split enabled).
-    pub split_hdr_size: u16,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_rxmode() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rxmode> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_rxmode>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_rxmode))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_rxmode>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_rxmode))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(mq_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).max_rx_pkt_len) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(max_rx_pkt_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).split_hdr_size) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(split_hdr_size)
-        )
-    );
-}
-impl Default for rte_eth_rxmode {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl rte_eth_rxmode {
-    #[inline]
-    pub fn header_split(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_header_split(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_ip_checksum(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_ip_checksum(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_filter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_filter(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_strip(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_strip(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_extend(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_extend(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn jumbo_frame(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_jumbo_frame(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_strip_crc(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_strip_crc(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn enable_scatter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_scatter(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn enable_lro(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_lro(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        header_split: u16,
-        hw_ip_checksum: u16,
-        hw_vlan_filter: u16,
-        hw_vlan_strip: u16,
-        hw_vlan_extend: u16,
-        jumbo_frame: u16,
-        hw_strip_crc: u16,
-        enable_scatter: u16,
-        enable_lro: u16,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let header_split: u16 =
-                unsafe { ::std::mem::transmute(header_split) };
-            header_split as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let hw_ip_checksum: u16 =
-                unsafe { ::std::mem::transmute(hw_ip_checksum) };
-            hw_ip_checksum as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let hw_vlan_filter: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_filter) };
-            hw_vlan_filter as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let hw_vlan_strip: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_strip) };
-            hw_vlan_strip as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let hw_vlan_extend: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_extend) };
-            hw_vlan_extend as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let jumbo_frame: u16 =
-                unsafe { ::std::mem::transmute(jumbo_frame) };
-            jumbo_frame as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let hw_strip_crc: u16 =
-                unsafe { ::std::mem::transmute(hw_strip_crc) };
-            hw_strip_crc as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let enable_scatter: u16 =
-                unsafe { ::std::mem::transmute(enable_scatter) };
-            enable_scatter as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let enable_lro: u16 = unsafe { ::std::mem::transmute(enable_lro) };
-            enable_lro as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(u32)]
-/// A set of values to identify what method is to be used to transmit
-/// packets using multi-TCs.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_tx_mq_mode {
-    ///< It is in neither DCB nor VT mode.
-    ETH_MQ_TX_NONE = 0,
-    ///< For TX side,only DCB is on.
-    ETH_MQ_TX_DCB = 1,
-    ///< For TX side,both DCB and VT is on.
-    ETH_MQ_TX_VMDQ_DCB = 2,
-    ///< Only VT on, no DCB
-    ETH_MQ_TX_VMDQ_ONLY = 3,
-}
-/// A structure used to configure the TX features of an Ethernet port.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_txmode {
-    ///< TX multi-queues mode.
-    pub mq_mode: rte_eth_tx_mq_mode,
-    pub pvid: u16,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_txmode() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_txmode> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_txmode>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_eth_txmode))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_txmode>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_txmode))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_txmode),
-            "::",
-            stringify!(mq_mode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pvid) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_txmode),
-            "::",
-            stringify!(pvid)
-        )
-    );
-}
-impl Default for rte_eth_txmode {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl rte_eth_txmode {
-    #[inline]
-    pub fn hw_vlan_reject_tagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_reject_untagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_insert_pvid(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        hw_vlan_reject_tagged: u8,
-        hw_vlan_reject_untagged: u8,
-        hw_vlan_insert_pvid: u8,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let hw_vlan_reject_tagged: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
-            hw_vlan_reject_tagged as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let hw_vlan_reject_untagged: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_reject_untagged) };
-            hw_vlan_reject_untagged as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let hw_vlan_insert_pvid: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_insert_pvid) };
-            hw_vlan_insert_pvid as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-/// A structure used to configure the Receive Side Scaling (RSS) feature
-/// of an Ethernet port.
-/// If not NULL, the *rss_key* pointer of the *rss_conf* structure points
-/// to an array holding the RSS key to use for hashing specific header
-/// fields of received packets. The length of this array should be indicated
-/// by *rss_key_len* below. Otherwise, a default random hash key is used by
-/// the device driver.
-///
-/// The *rss_key_len* field of the *rss_conf* structure indicates the length
-/// in bytes of the array pointed by *rss_key*. To be compatible, this length
-/// will be checked in i40e only. Others assume 40 bytes to be used as before.
-///
-/// The *rss_hf* field of the *rss_conf* structure indicates the different
-/// types of IPv4/IPv6 packets to which the RSS hashing must be applied.
-/// Supplying an *rss_hf* equal to zero disables the RSS feature.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_rss_conf {
-    ///< If not NULL, 40-byte hash key.
-    pub rss_key: *mut u8,
-    ///< hash key length in bytes.
-    pub rss_key_len: u8,
-    ///< Hash functions to apply - see below.
-    pub rss_hf: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_rss_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rss_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_rss_conf>(),
-        24usize,
-        concat!("Size of: ", stringify!(rte_eth_rss_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_rss_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_rss_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss_key) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_key)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rss_key_len) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_key_len)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss_hf) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_hf)
-        )
-    );
-}
-impl Default for rte_eth_rss_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(u32)]
-/// This enum indicates the possible number of traffic classes
-/// in DCB configratioins
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_nb_tcs {
-    ///< 4 TCs with DCB.
-    ETH_4_TCS = 4,
-    ///< 8 TCs with DCB.
-    ETH_8_TCS = 8,
-}
-#[repr(u32)]
-/// This enum indicates the possible number of queue pools
-/// in VMDQ configurations.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_nb_pools {
-    ///< 8 VMDq pools.
-    ETH_8_POOLS = 8,
-    ///< 16 VMDq pools.
-    ETH_16_POOLS = 16,
-    ///< 32 VMDq pools.
-    ETH_32_POOLS = 32,
-    ///< 64 VMDq pools.
-    ETH_64_POOLS = 64,
-}
-/// A structure used to configure the VMDQ+DCB feature
-/// of an Ethernet port.
-///
-/// Using this feature, packets are routed to a pool of queues, based
-/// on the vlan id in the vlan tag, and then to a specific queue within
-/// that pool, using the user priority vlan tag field.
-///
-/// A default pool may be used, if desired, to route all traffic which
-/// does not match the vlan filter rules.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_eth_vmdq_dcb_conf {
-    ///< With DCB, 16 or 32 pools
-    pub nb_queue_pools: rte_eth_nb_pools,
-    ///< If non-zero, use a default pool
-    pub enable_default_pool: u8,
-    ///< The default pool, if applicable
-    pub default_pool: u8,
-    ///< We can have up to 64 filters/mappings
-    pub nb_pool_maps: u8,
-    ///< VMDq vlan pool maps.
-    pub pool_map: [rte_eth_vmdq_dcb_conf__bindgen_ty_1; 64usize],
-    pub dcb_tc: [u8; 8usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
-    ///< The vlan id of the received frame
-    pub vlan_id: u16,
-    ///< Bitmask of pools for packet rx
-    pub pools: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
-            "::",
-            stringify!(vlan_id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
-            "::",
-            stringify!(pools)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf>(),
-        1040usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(enable_default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
-        },
-        5usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
-        },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(nb_pool_maps)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(pool_map)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        1032usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Default for rte_eth_vmdq_dcb_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_dcb_rx_conf {
-    ///< Possible DCB TCs, 4 or 8 TCs
-    pub nb_tcs: rte_eth_nb_tcs,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_dcb_rx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_rx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_dcb_rx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_dcb_rx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_dcb_rx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_dcb_rx_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_rx_conf),
-            "::",
-            stringify!(nb_tcs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_rx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Default for rte_eth_dcb_rx_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_dcb_tx_conf {
-    ///< With DCB, 16 or 32 pools.
-    pub nb_queue_pools: rte_eth_nb_pools,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_tx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_tx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_tx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_tx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Default for rte_eth_vmdq_dcb_tx_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_dcb_tx_conf {
-    ///< Possible DCB TCs, 4 or 8 TCs.
-    pub nb_tcs: rte_eth_nb_tcs,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_dcb_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_dcb_tx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_dcb_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_dcb_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_dcb_tx_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_tx_conf),
-            "::",
-            stringify!(nb_tcs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_tx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Default for rte_eth_dcb_tx_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_tx_conf {
-    ///< VMDq mode, 64 pools.
-    pub nb_queue_pools: rte_eth_nb_pools,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_tx_conf>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_tx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_tx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-}
-impl Default for rte_eth_vmdq_tx_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_eth_vmdq_rx_conf {
-    ///< VMDq only mode, 8 or 64 pools
-    pub nb_queue_pools: rte_eth_nb_pools,
-    ///< If non-zero, use a default pool
-    pub enable_default_pool: u8,
-    ///< The default pool, if applicable
-    pub default_pool: u8,
-    ///< Enable VT loop back
-    pub enable_loop_back: u8,
-    ///< We can have up to 64 filters/mappings
-    pub nb_pool_maps: u8,
-    ///< Flags from ETH_VMDQ_ACCEPT_*
-    pub rx_mode: u32,
-    ///< VMDq vlan pool maps.
-    pub pool_map: [rte_eth_vmdq_rx_conf__bindgen_ty_1; 64usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_rx_conf__bindgen_ty_1 {
-    ///< The vlan id of the received frame
-    pub vlan_id: u16,
-    ///< Bitmask of pools for packet rx
-    pub pools: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_rx_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
-            "::",
-            stringify!(vlan_id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
-            "::",
-            stringify!(pools)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_rx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_rx_conf>(),
-        1040usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_rx_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_rx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(enable_default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
-        },
-        5usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_loop_back) as usize -
-                ptr as usize
-        },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(enable_loop_back)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
-        },
-        7usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(nb_pool_maps)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rx_mode) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(rx_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(pool_map)
-        )
-    );
-}
-impl Default for rte_eth_vmdq_rx_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(u32)]
-///  Flow Director setting modes: none, signature or perfect.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_mode {
-    ///< Disable FDIR support.
-    RTE_FDIR_MODE_NONE = 0,
-    ///< Enable FDIR signature filter mode.
-    RTE_FDIR_MODE_SIGNATURE = 1,
-    ///< Enable FDIR perfect filter mode.
-    RTE_FDIR_MODE_PERFECT = 2,
-    ///< Enable FDIR filter mode - MAC VLAN.
-    RTE_FDIR_MODE_PERFECT_MAC_VLAN = 3,
-    ///< Enable FDIR filter mode - tunnel.
-    RTE_FDIR_MODE_PERFECT_TUNNEL = 4,
-}
-#[repr(u32)]
-///  Memory space that can be configured to store Flow Director filters
-///  in the board memory.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_pballoc_type {
-    ///< 64k.
-    RTE_FDIR_PBALLOC_64K = 0,
-    ///< 128k.
-    RTE_FDIR_PBALLOC_128K = 1,
-    ///< 256k.
-    RTE_FDIR_PBALLOC_256K = 2,
-}
-#[repr(u32)]
-///  Select report mode of FDIR hash information in RX descriptors.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_status_mode {
-    ///< Never report FDIR hash.
-    RTE_FDIR_NO_REPORT_STATUS = 0,
-    ///< Only report FDIR hash for matching pkts.
-    RTE_FDIR_REPORT_STATUS = 1,
-    ///< Always report FDIR hash.
-    RTE_FDIR_REPORT_STATUS_ALWAYS = 2,
-}
-/// A structure used to define the input for IPV4 flow
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_ipv4_flow {
-    ///< IPv4 source address in big endian.
-    pub src_ip: u32,
-    ///< IPv4 destination address in big endian.
-    pub dst_ip: u32,
-    ///< Type of service to match.
-    pub tos: u8,
-    ///< Time to live to match.
-    pub ttl: u8,
-    ///< Protocol, next header in big endian.
-    pub proto: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_ipv4_flow() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv4_flow> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_ipv4_flow>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_ipv4_flow))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_ipv4_flow>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_ipv4_flow))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(src_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(dst_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tos) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(tos)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ttl) as usize - ptr as usize },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(ttl)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
-        10usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(proto)
-        )
-    );
-}
-/// A structure used to define the input for IPV6 flow
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_ipv6_flow {
-    ///< IPv6 source address in big endian.
-    pub src_ip: [u32; 4usize],
-    ///< IPv6 destination address in big endian.
-    pub dst_ip: [u32; 4usize],
-    ///< Traffic class to match.
-    pub tc: u8,
-    ///< Protocol, next header to match.
-    pub proto: u8,
-    ///< Hop limits to match.
-    pub hop_limits: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_ipv6_flow() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv6_flow> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_ipv6_flow>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_eth_ipv6_flow))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_ipv6_flow>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_ipv6_flow))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(src_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(dst_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tc) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(tc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
-        33usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(proto)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).hop_limits) as usize - ptr as usize
-        },
-        34usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(hop_limits)
-        )
-    );
-}
-///  A structure used to configure FDIR masks that are used by the device
-///  to match the various fields of RX packet headers.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_masks {
-    ///< Bit mask for vlan_tci in big endian
-    pub vlan_tci_mask: u16,
-    /// Bit mask for ipv4 flow in big endian.
-    pub ipv4_mask: rte_eth_ipv4_flow,
-    /// Bit maks for ipv6 flow in big endian.
-    pub ipv6_mask: rte_eth_ipv6_flow,
-    /// Bit mask for L4 source port in big endian.
-    pub src_port_mask: u16,
-    /// Bit mask for L4 destination port in big endian.
-    pub dst_port_mask: u16,
-    /// 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
-    ///first byte on the wire
-    pub mac_addr_byte_mask: u8,
-    /// Bit mask for tunnel ID in big endian.
-    pub tunnel_id_mask: u32,
-    ///< 1 - Match tunnel type,
-    ///0 - Ignore tunnel type.
-    pub tunnel_type_mask: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_masks() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_masks> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_masks>(),
-        68usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_masks))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_masks>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_masks))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci_mask) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(vlan_tci_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ipv4_mask) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(ipv4_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ipv6_mask) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(ipv6_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_port_mask) as usize - ptr as usize
-        },
-        52usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(src_port_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_port_mask) as usize - ptr as usize
-        },
-        54usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(dst_port_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mac_addr_byte_mask) as usize -
-                ptr as usize
-        },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(mac_addr_byte_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tunnel_id_mask) as usize - ptr as usize
-        },
-        60usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(tunnel_id_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tunnel_type_mask) as usize -
-                ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(tunnel_type_mask)
-        )
-    );
-}
-#[repr(u32)]
-/// Payload type
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_payload_type {
-    RTE_ETH_PAYLOAD_UNKNOWN = 0,
-    RTE_ETH_RAW_PAYLOAD = 1,
-    RTE_ETH_L2_PAYLOAD = 2,
-    RTE_ETH_L3_PAYLOAD = 3,
-    RTE_ETH_L4_PAYLOAD = 4,
-    RTE_ETH_PAYLOAD_MAX = 8,
-}
-/// A structure used to select bytes extracted from the protocol layers to
-/// flexible payload for filter
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_flex_payload_cfg {
-    ///< Payload type
-    pub type_: rte_eth_payload_type,
-    pub src_offset: [u16; 16usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_flex_payload_cfg() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_flex_payload_cfg> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_flex_payload_cfg>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_eth_flex_payload_cfg))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_flex_payload_cfg>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_flex_payload_cfg))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_flex_payload_cfg),
-            "::",
-            stringify!(type_)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_offset) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_flex_payload_cfg),
-            "::",
-            stringify!(src_offset)
-        )
-    );
-}
-impl Default for rte_eth_flex_payload_cfg {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// A structure used to define FDIR masks for flexible payload
-/// for each flow type
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_flex_mask {
-    pub flow_type: u16,
-    pub mask: [u8; 16usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_flex_mask() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_mask> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_flex_mask>(),
-        18usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_flex_mask))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_flex_mask>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_mask))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flow_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_mask),
-            "::",
-            stringify!(flow_type)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_mask),
-            "::",
-            stringify!(mask)
-        )
-    );
-}
-/// A structure used to define all flexible payload related setting
-/// include flex payload and flex mask
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_flex_conf {
-    ///< The number of following payload cfg
-    pub nb_payloads: u16,
-    ///< The number of following mask
-    pub nb_flexmasks: u16,
-    pub flex_set: [rte_eth_flex_payload_cfg; 8usize],
-    pub flex_mask: [rte_eth_fdir_flex_mask; 22usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_flex_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_flex_conf>(),
-        688usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_flex_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_flex_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_payloads) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(nb_payloads)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_flexmasks) as usize - ptr as usize
-        },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(nb_flexmasks)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_set) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(flex_set)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_mask) as usize - ptr as usize
-        },
-        292usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(flex_mask)
-        )
-    );
-}
-impl Default for rte_eth_fdir_flex_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// A structure used to configure the Flow Director (FDIR) feature
-/// of an Ethernet port.
-///
-/// If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_fdir_conf {
-    ///< Flow Director mode.
-    pub mode: rte_fdir_mode,
-    ///< Space for FDIR filters.
-    pub pballoc: rte_fdir_pballoc_type,
-    ///< How to report FDIR hash.
-    pub status: rte_fdir_status_mode,
-    /// RX queue of packets matching a "drop" filter in perfect mode.
-    pub drop_queue: u8,
-    pub mask: rte_eth_fdir_masks,
-    pub flex_conf: rte_eth_fdir_flex_conf,
-}
-#[test]
-fn bindgen_test_layout_rte_fdir_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_fdir_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_fdir_conf>(),
-        772usize,
-        concat!("Size of: ", stringify!(rte_fdir_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_fdir_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_fdir_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(mode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pballoc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(pballoc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(status)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).drop_queue) as usize - ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(drop_queue)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_conf) as usize - ptr as usize
-        },
-        84usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(flex_conf)
-        )
-    );
-}
-impl Default for rte_fdir_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// A structure used to enable/disable specific device interrupts.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_intr_conf {
-    /// enable/disable lsc interrupt. 0 (default) - disable, 1 enable
-    pub lsc: u16,
-    /// enable/disable rxq interrupt. 0 (default) - disable, 1 enable
-    pub rxq: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_intr_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_intr_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_intr_conf>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_intr_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_intr_conf>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_intr_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lsc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_intr_conf),
-            "::",
-            stringify!(lsc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rxq) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_intr_conf),
-            "::",
-            stringify!(rxq)
-        )
-    );
-}
-/// A structure used to configure an Ethernet port.
-/// Depending upon the RX multi-queue mode, extra advanced
-/// configuration settings may be needed.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_eth_conf {
-    ///< bitmap of ETH_LINK_SPEED_XXX of speeds to be
-    ///used. ETH_LINK_SPEED_FIXED disables link
-    ///autonegotiation, and a unique speed shall be
-    ///set. Otherwise, the bitmap defines the set of
-    ///speeds to be advertised. If the special value
-    ///ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
-    ///supported are advertised.
-    pub link_speeds: u32,
-    ///< Port RX configuration.
-    pub rxmode: rte_eth_rxmode,
-    ///< Port TX configuration.
-    pub txmode: rte_eth_txmode,
-    ///< Loopback operation mode. By default the value
-    ///is 0, meaning the loopback mode is disabled.
-    ///Read the datasheet of given ethernet controller
-    ///for details. The possible values of this field
-    ///are defined in implementation of each driver.
-    pub lpbk_mode: u32,
-    ///< Port RX filtering configuration (union).
-    pub rx_adv_conf: rte_eth_conf__bindgen_ty_1,
-    ///< Port TX DCB configuration (union).
-    pub tx_adv_conf: rte_eth_conf__bindgen_ty_2,
-    /// Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
-    ///is needed,and the variable must be set ETH_DCB_PFC_SUPPORT.
-    pub dcb_capability_en: u32,
-    ///< FDIR configuration.
-    pub fdir_conf: rte_fdir_conf,
-    ///< Interrupt mode configuration.
-    pub intr_conf: rte_intr_conf,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_eth_conf__bindgen_ty_1 {
-    ///< Port RSS configuration
-    pub rss_conf: rte_eth_rss_conf,
-    pub vmdq_dcb_conf: rte_eth_vmdq_dcb_conf,
-    pub dcb_rx_conf: rte_eth_dcb_rx_conf,
-    pub vmdq_rx_conf: rte_eth_vmdq_rx_conf,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_1>(),
-        2120usize,
-        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rss_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(rss_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_dcb_conf) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(vmdq_dcb_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_rx_conf) as usize - ptr as usize
-        },
-        1064usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(dcb_rx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_rx_conf) as usize - ptr as usize
-        },
-        1080usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(vmdq_rx_conf)
-        )
-    );
-}
-impl Default for rte_eth_conf__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_eth_conf__bindgen_ty_2 {
-    pub vmdq_dcb_tx_conf: rte_eth_vmdq_dcb_tx_conf,
-    pub dcb_tx_conf: rte_eth_dcb_tx_conf,
-    pub vmdq_tx_conf: rte_eth_vmdq_tx_conf,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_2>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_dcb_tx_conf) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(vmdq_dcb_tx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_tx_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(dcb_tx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_tx_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(vmdq_tx_conf)
-        )
-    );
-}
-impl Default for rte_eth_conf__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf>(),
-        2944usize,
-        concat!("Size of: ", stringify!(rte_eth_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).link_speeds) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(link_speeds)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rxmode) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(rxmode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).txmode) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(txmode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).lpbk_mode) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(lpbk_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rx_adv_conf) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(rx_adv_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tx_adv_conf) as usize - ptr as usize
-        },
-        2152usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(tx_adv_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_capability_en) as usize -
-                ptr as usize
-        },
-        2164usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(dcb_capability_en)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).fdir_conf) as usize - ptr as usize
-        },
-        2168usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(fdir_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).intr_conf) as usize - ptr as usize
-        },
-        2940usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(intr_conf)
-        )
-    );
-}
-impl Default for rte_eth_conf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/layout_eth_conf_1_0.rs b/tests/expectations/tests/layout_eth_conf_1_0.rs
deleted file mode 100644
index d7fa0a63..00000000
--- a/tests/expectations/tests/layout_eth_conf_1_0.rs
+++ /dev/null
@@ -1,2337 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-pub const ETH_MQ_RX_RSS_FLAG: u32 = 1;
-pub const ETH_MQ_RX_DCB_FLAG: u32 = 2;
-pub const ETH_MQ_RX_VMDQ_FLAG: u32 = 4;
-pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64;
-pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8;
-pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128;
-pub const ETH_DCB_NUM_QUEUES: u32 = 128;
-pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16;
-pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128;
-pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0;
-pub const RTE_ETH_FLOW_RAW: u32 = 1;
-pub const RTE_ETH_FLOW_IPV4: u32 = 2;
-pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6;
-pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7;
-pub const RTE_ETH_FLOW_IPV6: u32 = 8;
-pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12;
-pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13;
-pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14;
-pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15;
-pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16;
-pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17;
-pub const RTE_ETH_FLOW_PORT: u32 = 18;
-pub const RTE_ETH_FLOW_VXLAN: u32 = 19;
-pub const RTE_ETH_FLOW_GENEVE: u32 = 20;
-pub const RTE_ETH_FLOW_NVGRE: u32 = 21;
-pub const RTE_ETH_FLOW_MAX: u32 = 22;
-#[repr(u32)]
-///  A set of values to identify what method is to be used to route
-///  packets to multiple queues.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_rx_mq_mode {
-    /// None of DCB,RSS or VMDQ mode
-    ETH_MQ_RX_NONE = 0,
-    /// For RX side, only RSS is on
-    ETH_MQ_RX_RSS = 1,
-    /// For RX side,only DCB is on.
-    ETH_MQ_RX_DCB = 2,
-    /// Both DCB and RSS enable
-    ETH_MQ_RX_DCB_RSS = 3,
-    /// Only VMDQ, no RSS nor DCB
-    ETH_MQ_RX_VMDQ_ONLY = 4,
-    /// RSS mode with VMDQ
-    ETH_MQ_RX_VMDQ_RSS = 5,
-    /// Use VMDQ+DCB to route traffic to queues
-    ETH_MQ_RX_VMDQ_DCB = 6,
-    /// Enable both VMDQ and DCB in VMDq
-    ETH_MQ_RX_VMDQ_DCB_RSS = 7,
-}
-/// A structure used to configure the RX features of an Ethernet port.
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_rxmode {
-    /// The multi-queue packet distribution mode to be used, e.g. RSS.
-    pub mq_mode: rte_eth_rx_mq_mode,
-    ///< Only used if jumbo_frame enabled.
-    pub max_rx_pkt_len: u32,
-    ///< hdr buf size (header_split enabled).
-    pub split_hdr_size: u16,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_rxmode() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rxmode> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_rxmode>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_rxmode))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_rxmode>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_rxmode))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(mq_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).max_rx_pkt_len) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(max_rx_pkt_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).split_hdr_size) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rxmode),
-            "::",
-            stringify!(split_hdr_size)
-        )
-    );
-}
-impl Clone for rte_eth_rxmode {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_rxmode {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl rte_eth_rxmode {
-    #[inline]
-    pub fn header_split(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_header_split(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_ip_checksum(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_ip_checksum(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_filter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_filter(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_strip(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_strip(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_extend(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_extend(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn jumbo_frame(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_jumbo_frame(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_strip_crc(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_strip_crc(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn enable_scatter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_scatter(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn enable_lro(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_lro(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        header_split: u16,
-        hw_ip_checksum: u16,
-        hw_vlan_filter: u16,
-        hw_vlan_strip: u16,
-        hw_vlan_extend: u16,
-        jumbo_frame: u16,
-        hw_strip_crc: u16,
-        enable_scatter: u16,
-        enable_lro: u16,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let header_split: u16 =
-                unsafe { ::std::mem::transmute(header_split) };
-            header_split as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let hw_ip_checksum: u16 =
-                unsafe { ::std::mem::transmute(hw_ip_checksum) };
-            hw_ip_checksum as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let hw_vlan_filter: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_filter) };
-            hw_vlan_filter as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let hw_vlan_strip: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_strip) };
-            hw_vlan_strip as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let hw_vlan_extend: u16 =
-                unsafe { ::std::mem::transmute(hw_vlan_extend) };
-            hw_vlan_extend as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let jumbo_frame: u16 =
-                unsafe { ::std::mem::transmute(jumbo_frame) };
-            jumbo_frame as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let hw_strip_crc: u16 =
-                unsafe { ::std::mem::transmute(hw_strip_crc) };
-            hw_strip_crc as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let enable_scatter: u16 =
-                unsafe { ::std::mem::transmute(enable_scatter) };
-            enable_scatter as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let enable_lro: u16 = unsafe { ::std::mem::transmute(enable_lro) };
-            enable_lro as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(u32)]
-/// A set of values to identify what method is to be used to transmit
-/// packets using multi-TCs.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_tx_mq_mode {
-    ///< It is in neither DCB nor VT mode.
-    ETH_MQ_TX_NONE = 0,
-    ///< For TX side,only DCB is on.
-    ETH_MQ_TX_DCB = 1,
-    ///< For TX side,both DCB and VT is on.
-    ETH_MQ_TX_VMDQ_DCB = 2,
-    ///< Only VT on, no DCB
-    ETH_MQ_TX_VMDQ_ONLY = 3,
-}
-/// A structure used to configure the TX features of an Ethernet port.
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_txmode {
-    ///< TX multi-queues mode.
-    pub mq_mode: rte_eth_tx_mq_mode,
-    pub pvid: u16,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_txmode() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_txmode> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_txmode>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_eth_txmode))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_txmode>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_txmode))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mq_mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_txmode),
-            "::",
-            stringify!(mq_mode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pvid) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_txmode),
-            "::",
-            stringify!(pvid)
-        )
-    );
-}
-impl Clone for rte_eth_txmode {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_txmode {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl rte_eth_txmode {
-    #[inline]
-    pub fn hw_vlan_reject_tagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_reject_untagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hw_vlan_insert_pvid(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        hw_vlan_reject_tagged: u8,
-        hw_vlan_reject_untagged: u8,
-        hw_vlan_insert_pvid: u8,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let hw_vlan_reject_tagged: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
-            hw_vlan_reject_tagged as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let hw_vlan_reject_untagged: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_reject_untagged) };
-            hw_vlan_reject_untagged as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let hw_vlan_insert_pvid: u8 =
-                unsafe { ::std::mem::transmute(hw_vlan_insert_pvid) };
-            hw_vlan_insert_pvid as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-/// A structure used to configure the Receive Side Scaling (RSS) feature
-/// of an Ethernet port.
-/// If not NULL, the *rss_key* pointer of the *rss_conf* structure points
-/// to an array holding the RSS key to use for hashing specific header
-/// fields of received packets. The length of this array should be indicated
-/// by *rss_key_len* below. Otherwise, a default random hash key is used by
-/// the device driver.
-///
-/// The *rss_key_len* field of the *rss_conf* structure indicates the length
-/// in bytes of the array pointed by *rss_key*. To be compatible, this length
-/// will be checked in i40e only. Others assume 40 bytes to be used as before.
-///
-/// The *rss_hf* field of the *rss_conf* structure indicates the different
-/// types of IPv4/IPv6 packets to which the RSS hashing must be applied.
-/// Supplying an *rss_hf* equal to zero disables the RSS feature.
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_rss_conf {
-    ///< If not NULL, 40-byte hash key.
-    pub rss_key: *mut u8,
-    ///< hash key length in bytes.
-    pub rss_key_len: u8,
-    ///< Hash functions to apply - see below.
-    pub rss_hf: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_rss_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_rss_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_rss_conf>(),
-        24usize,
-        concat!("Size of: ", stringify!(rte_eth_rss_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_rss_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_rss_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss_key) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_key)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rss_key_len) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_key_len)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss_hf) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_rss_conf),
-            "::",
-            stringify!(rss_hf)
-        )
-    );
-}
-impl Clone for rte_eth_rss_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_rss_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(u32)]
-/// This enum indicates the possible number of traffic classes
-/// in DCB configratioins
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_nb_tcs {
-    ///< 4 TCs with DCB.
-    ETH_4_TCS = 4,
-    ///< 8 TCs with DCB.
-    ETH_8_TCS = 8,
-}
-#[repr(u32)]
-/// This enum indicates the possible number of queue pools
-/// in VMDQ configurations.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_nb_pools {
-    ///< 8 VMDq pools.
-    ETH_8_POOLS = 8,
-    ///< 16 VMDq pools.
-    ETH_16_POOLS = 16,
-    ///< 32 VMDq pools.
-    ETH_32_POOLS = 32,
-    ///< 64 VMDq pools.
-    ETH_64_POOLS = 64,
-}
-/// A structure used to configure the VMDQ+DCB feature
-/// of an Ethernet port.
-///
-/// Using this feature, packets are routed to a pool of queues, based
-/// on the vlan id in the vlan tag, and then to a specific queue within
-/// that pool, using the user priority vlan tag field.
-///
-/// A default pool may be used, if desired, to route all traffic which
-/// does not match the vlan filter rules.
-#[repr(C)]
-#[derive(Copy)]
-pub struct rte_eth_vmdq_dcb_conf {
-    ///< With DCB, 16 or 32 pools
-    pub nb_queue_pools: rte_eth_nb_pools,
-    ///< If non-zero, use a default pool
-    pub enable_default_pool: u8,
-    ///< The default pool, if applicable
-    pub default_pool: u8,
-    ///< We can have up to 64 filters/mappings
-    pub nb_pool_maps: u8,
-    ///< VMDq vlan pool maps.
-    pub pool_map: [rte_eth_vmdq_dcb_conf__bindgen_ty_1; 64usize],
-    pub dcb_tc: [u8; 8usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
-    ///< The vlan id of the received frame
-    pub vlan_id: u16,
-    ///< Bitmask of pools for packet rx
-    pub pools: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
-            "::",
-            stringify!(vlan_id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf__bindgen_ty_1),
-            "::",
-            stringify!(pools)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_dcb_conf__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_conf>(),
-        1040usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(enable_default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
-        },
-        5usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
-        },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(nb_pool_maps)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(pool_map)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        1032usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_dcb_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_vmdq_dcb_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_dcb_rx_conf {
-    ///< Possible DCB TCs, 4 or 8 TCs
-    pub nb_tcs: rte_eth_nb_tcs,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_dcb_rx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_rx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_dcb_rx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_dcb_rx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_dcb_rx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_dcb_rx_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_rx_conf),
-            "::",
-            stringify!(nb_tcs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_rx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Clone for rte_eth_dcb_rx_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_dcb_rx_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_dcb_tx_conf {
-    ///< With DCB, 16 or 32 pools.
-    pub nb_queue_pools: rte_eth_nb_pools,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_dcb_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_dcb_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_dcb_tx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_dcb_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_dcb_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_dcb_tx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_tx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_dcb_tx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_dcb_tx_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_vmdq_dcb_tx_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_dcb_tx_conf {
-    ///< Possible DCB TCs, 4 or 8 TCs.
-    pub nb_tcs: rte_eth_nb_tcs,
-    /// Traffic class each UP mapped to.
-    pub dcb_tc: [u8; 8usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_dcb_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_dcb_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_dcb_tx_conf>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_dcb_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_dcb_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_dcb_tx_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_tcs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_tx_conf),
-            "::",
-            stringify!(nb_tcs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dcb_tc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_dcb_tx_conf),
-            "::",
-            stringify!(dcb_tc)
-        )
-    );
-}
-impl Clone for rte_eth_dcb_tx_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_dcb_tx_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_tx_conf {
-    ///< VMDq mode, 64 pools.
-    pub nb_queue_pools: rte_eth_nb_pools,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_tx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_tx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_tx_conf>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_tx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_tx_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_tx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_tx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_tx_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_vmdq_tx_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy)]
-pub struct rte_eth_vmdq_rx_conf {
-    ///< VMDq only mode, 8 or 64 pools
-    pub nb_queue_pools: rte_eth_nb_pools,
-    ///< If non-zero, use a default pool
-    pub enable_default_pool: u8,
-    ///< The default pool, if applicable
-    pub default_pool: u8,
-    ///< Enable VT loop back
-    pub enable_loop_back: u8,
-    ///< We can have up to 64 filters/mappings
-    pub nb_pool_maps: u8,
-    ///< Flags from ETH_VMDQ_ACCEPT_*
-    pub rx_mode: u32,
-    ///< VMDq vlan pool maps.
-    pub pool_map: [rte_eth_vmdq_rx_conf__bindgen_ty_1; 64usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_vmdq_rx_conf__bindgen_ty_1 {
-    ///< The vlan id of the received frame
-    pub vlan_id: u16,
-    ///< Bitmask of pools for packet rx
-    pub pools: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_rx_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_rx_conf__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).vlan_id) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
-            "::",
-            stringify!(vlan_id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pools) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf__bindgen_ty_1),
-            "::",
-            stringify!(pools)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_rx_conf__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_eth_vmdq_rx_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_vmdq_rx_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_vmdq_rx_conf>(),
-        1040usize,
-        concat!("Size of: ", stringify!(rte_eth_vmdq_rx_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_vmdq_rx_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_vmdq_rx_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_queue_pools) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(nb_queue_pools)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_default_pool) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(enable_default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).default_pool) as usize - ptr as usize
-        },
-        5usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(default_pool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).enable_loop_back) as usize -
-                ptr as usize
-        },
-        6usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(enable_loop_back)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_pool_maps) as usize - ptr as usize
-        },
-        7usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(nb_pool_maps)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rx_mode) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(rx_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).pool_map) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_vmdq_rx_conf),
-            "::",
-            stringify!(pool_map)
-        )
-    );
-}
-impl Clone for rte_eth_vmdq_rx_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_vmdq_rx_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(u32)]
-///  Flow Director setting modes: none, signature or perfect.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_mode {
-    ///< Disable FDIR support.
-    RTE_FDIR_MODE_NONE = 0,
-    ///< Enable FDIR signature filter mode.
-    RTE_FDIR_MODE_SIGNATURE = 1,
-    ///< Enable FDIR perfect filter mode.
-    RTE_FDIR_MODE_PERFECT = 2,
-    ///< Enable FDIR filter mode - MAC VLAN.
-    RTE_FDIR_MODE_PERFECT_MAC_VLAN = 3,
-    ///< Enable FDIR filter mode - tunnel.
-    RTE_FDIR_MODE_PERFECT_TUNNEL = 4,
-}
-#[repr(u32)]
-///  Memory space that can be configured to store Flow Director filters
-///  in the board memory.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_pballoc_type {
-    ///< 64k.
-    RTE_FDIR_PBALLOC_64K = 0,
-    ///< 128k.
-    RTE_FDIR_PBALLOC_128K = 1,
-    ///< 256k.
-    RTE_FDIR_PBALLOC_256K = 2,
-}
-#[repr(u32)]
-///  Select report mode of FDIR hash information in RX descriptors.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_fdir_status_mode {
-    ///< Never report FDIR hash.
-    RTE_FDIR_NO_REPORT_STATUS = 0,
-    ///< Only report FDIR hash for matching pkts.
-    RTE_FDIR_REPORT_STATUS = 1,
-    ///< Always report FDIR hash.
-    RTE_FDIR_REPORT_STATUS_ALWAYS = 2,
-}
-/// A structure used to define the input for IPV4 flow
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_ipv4_flow {
-    ///< IPv4 source address in big endian.
-    pub src_ip: u32,
-    ///< IPv4 destination address in big endian.
-    pub dst_ip: u32,
-    ///< Type of service to match.
-    pub tos: u8,
-    ///< Time to live to match.
-    pub ttl: u8,
-    ///< Protocol, next header in big endian.
-    pub proto: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_ipv4_flow() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv4_flow> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_ipv4_flow>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_ipv4_flow))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_ipv4_flow>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_ipv4_flow))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(src_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(dst_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tos) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(tos)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ttl) as usize - ptr as usize },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(ttl)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
-        10usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv4_flow),
-            "::",
-            stringify!(proto)
-        )
-    );
-}
-impl Clone for rte_eth_ipv4_flow {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-/// A structure used to define the input for IPV6 flow
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_ipv6_flow {
-    ///< IPv6 source address in big endian.
-    pub src_ip: [u32; 4usize],
-    ///< IPv6 destination address in big endian.
-    pub dst_ip: [u32; 4usize],
-    ///< Traffic class to match.
-    pub tc: u8,
-    ///< Protocol, next header to match.
-    pub proto: u8,
-    ///< Hop limits to match.
-    pub hop_limits: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_ipv6_flow() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_ipv6_flow> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_ipv6_flow>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_eth_ipv6_flow))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_ipv6_flow>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_ipv6_flow))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(src_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(dst_ip)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tc) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(tc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
-        33usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(proto)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).hop_limits) as usize - ptr as usize
-        },
-        34usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_ipv6_flow),
-            "::",
-            stringify!(hop_limits)
-        )
-    );
-}
-impl Clone for rte_eth_ipv6_flow {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-///  A structure used to configure FDIR masks that are used by the device
-///  to match the various fields of RX packet headers.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_masks {
-    ///< Bit mask for vlan_tci in big endian
-    pub vlan_tci_mask: u16,
-    /// Bit mask for ipv4 flow in big endian.
-    pub ipv4_mask: rte_eth_ipv4_flow,
-    /// Bit maks for ipv6 flow in big endian.
-    pub ipv6_mask: rte_eth_ipv6_flow,
-    /// Bit mask for L4 source port in big endian.
-    pub src_port_mask: u16,
-    /// Bit mask for L4 destination port in big endian.
-    pub dst_port_mask: u16,
-    /// 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
-    ///first byte on the wire
-    pub mac_addr_byte_mask: u8,
-    /// Bit mask for tunnel ID in big endian.
-    pub tunnel_id_mask: u32,
-    ///< 1 - Match tunnel type,
-    ///0 - Ignore tunnel type.
-    pub tunnel_type_mask: u8,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_masks() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_masks> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_masks>(),
-        68usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_masks))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_masks>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_masks))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci_mask) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(vlan_tci_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ipv4_mask) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(ipv4_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ipv6_mask) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(ipv6_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_port_mask) as usize - ptr as usize
-        },
-        52usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(src_port_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dst_port_mask) as usize - ptr as usize
-        },
-        54usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(dst_port_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mac_addr_byte_mask) as usize -
-                ptr as usize
-        },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(mac_addr_byte_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tunnel_id_mask) as usize - ptr as usize
-        },
-        60usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(tunnel_id_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tunnel_type_mask) as usize -
-                ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_masks),
-            "::",
-            stringify!(tunnel_type_mask)
-        )
-    );
-}
-impl Clone for rte_eth_fdir_masks {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(u32)]
-/// Payload type
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum rte_eth_payload_type {
-    RTE_ETH_PAYLOAD_UNKNOWN = 0,
-    RTE_ETH_RAW_PAYLOAD = 1,
-    RTE_ETH_L2_PAYLOAD = 2,
-    RTE_ETH_L3_PAYLOAD = 3,
-    RTE_ETH_L4_PAYLOAD = 4,
-    RTE_ETH_PAYLOAD_MAX = 8,
-}
-/// A structure used to select bytes extracted from the protocol layers to
-/// flexible payload for filter
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_flex_payload_cfg {
-    ///< Payload type
-    pub type_: rte_eth_payload_type,
-    pub src_offset: [u16; 16usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_flex_payload_cfg() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_flex_payload_cfg> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_flex_payload_cfg>(),
-        36usize,
-        concat!("Size of: ", stringify!(rte_eth_flex_payload_cfg))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_flex_payload_cfg>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_flex_payload_cfg))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_flex_payload_cfg),
-            "::",
-            stringify!(type_)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).src_offset) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_flex_payload_cfg),
-            "::",
-            stringify!(src_offset)
-        )
-    );
-}
-impl Clone for rte_eth_flex_payload_cfg {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_flex_payload_cfg {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-/// A structure used to define FDIR masks for flexible payload
-/// for each flow type
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_flex_mask {
-    pub flow_type: u16,
-    pub mask: [u8; 16usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_flex_mask() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_mask> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_flex_mask>(),
-        18usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_flex_mask))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_flex_mask>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_mask))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flow_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_mask),
-            "::",
-            stringify!(flow_type)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_mask),
-            "::",
-            stringify!(mask)
-        )
-    );
-}
-impl Clone for rte_eth_fdir_flex_mask {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-/// A structure used to define all flexible payload related setting
-/// include flex payload and flex mask
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_fdir_flex_conf {
-    ///< The number of following payload cfg
-    pub nb_payloads: u16,
-    ///< The number of following mask
-    pub nb_flexmasks: u16,
-    pub flex_set: [rte_eth_flex_payload_cfg; 8usize],
-    pub flex_mask: [rte_eth_fdir_flex_mask; 22usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_fdir_flex_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_fdir_flex_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_fdir_flex_conf>(),
-        688usize,
-        concat!("Size of: ", stringify!(rte_eth_fdir_flex_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_fdir_flex_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_fdir_flex_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_payloads) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(nb_payloads)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_flexmasks) as usize - ptr as usize
-        },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(nb_flexmasks)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_set) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(flex_set)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_mask) as usize - ptr as usize
-        },
-        292usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_fdir_flex_conf),
-            "::",
-            stringify!(flex_mask)
-        )
-    );
-}
-impl Clone for rte_eth_fdir_flex_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_fdir_flex_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-/// A structure used to configure the Flow Director (FDIR) feature
-/// of an Ethernet port.
-///
-/// If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct rte_fdir_conf {
-    ///< Flow Director mode.
-    pub mode: rte_fdir_mode,
-    ///< Space for FDIR filters.
-    pub pballoc: rte_fdir_pballoc_type,
-    ///< How to report FDIR hash.
-    pub status: rte_fdir_status_mode,
-    /// RX queue of packets matching a "drop" filter in perfect mode.
-    pub drop_queue: u8,
-    pub mask: rte_eth_fdir_masks,
-    pub flex_conf: rte_eth_fdir_flex_conf,
-}
-#[test]
-fn bindgen_test_layout_rte_fdir_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_fdir_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_fdir_conf>(),
-        772usize,
-        concat!("Size of: ", stringify!(rte_fdir_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_fdir_conf>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_fdir_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(mode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pballoc) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(pballoc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(status)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).drop_queue) as usize - ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(drop_queue)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).flex_conf) as usize - ptr as usize
-        },
-        84usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_fdir_conf),
-            "::",
-            stringify!(flex_conf)
-        )
-    );
-}
-impl Clone for rte_fdir_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_fdir_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-/// A structure used to enable/disable specific device interrupts.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_intr_conf {
-    /// enable/disable lsc interrupt. 0 (default) - disable, 1 enable
-    pub lsc: u16,
-    /// enable/disable rxq interrupt. 0 (default) - disable, 1 enable
-    pub rxq: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_intr_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_intr_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_intr_conf>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_intr_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_intr_conf>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_intr_conf))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lsc) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_intr_conf),
-            "::",
-            stringify!(lsc)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rxq) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_intr_conf),
-            "::",
-            stringify!(rxq)
-        )
-    );
-}
-impl Clone for rte_intr_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-/// A structure used to configure an Ethernet port.
-/// Depending upon the RX multi-queue mode, extra advanced
-/// configuration settings may be needed.
-#[repr(C)]
-#[derive(Copy)]
-pub struct rte_eth_conf {
-    ///< bitmap of ETH_LINK_SPEED_XXX of speeds to be
-    ///used. ETH_LINK_SPEED_FIXED disables link
-    ///autonegotiation, and a unique speed shall be
-    ///set. Otherwise, the bitmap defines the set of
-    ///speeds to be advertised. If the special value
-    ///ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
-    ///supported are advertised.
-    pub link_speeds: u32,
-    ///< Port RX configuration.
-    pub rxmode: rte_eth_rxmode,
-    ///< Port TX configuration.
-    pub txmode: rte_eth_txmode,
-    ///< Loopback operation mode. By default the value
-    ///is 0, meaning the loopback mode is disabled.
-    ///Read the datasheet of given ethernet controller
-    ///for details. The possible values of this field
-    ///are defined in implementation of each driver.
-    pub lpbk_mode: u32,
-    ///< Port RX filtering configuration (union).
-    pub rx_adv_conf: rte_eth_conf__bindgen_ty_1,
-    ///< Port TX DCB configuration (union).
-    pub tx_adv_conf: rte_eth_conf__bindgen_ty_2,
-    /// Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
-    ///is needed,and the variable must be set ETH_DCB_PFC_SUPPORT.
-    pub dcb_capability_en: u32,
-    ///< FDIR configuration.
-    pub fdir_conf: rte_fdir_conf,
-    ///< Interrupt mode configuration.
-    pub intr_conf: rte_intr_conf,
-}
-#[repr(C)]
-#[derive(Copy)]
-pub struct rte_eth_conf__bindgen_ty_1 {
-    ///< Port RSS configuration
-    pub rss_conf: rte_eth_rss_conf,
-    pub vmdq_dcb_conf: rte_eth_vmdq_dcb_conf,
-    pub dcb_rx_conf: rte_eth_dcb_rx_conf,
-    pub vmdq_rx_conf: rte_eth_vmdq_rx_conf,
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_1>(),
-        2120usize,
-        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rss_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(rss_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_dcb_conf) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(vmdq_dcb_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_rx_conf) as usize - ptr as usize
-        },
-        1064usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(dcb_rx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_rx_conf) as usize - ptr as usize
-        },
-        1080usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_1),
-            "::",
-            stringify!(vmdq_rx_conf)
-        )
-    );
-}
-impl Clone for rte_eth_conf__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_conf__bindgen_ty_1 {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_eth_conf__bindgen_ty_2 {
-    pub vmdq_dcb_tx_conf: __BindgenUnionField<rte_eth_vmdq_dcb_tx_conf>,
-    pub dcb_tx_conf: __BindgenUnionField<rte_eth_dcb_tx_conf>,
-    pub vmdq_tx_conf: __BindgenUnionField<rte_eth_vmdq_tx_conf>,
-    pub bindgen_union_field: [u32; 3usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf__bindgen_ty_2>(),
-        12usize,
-        concat!("Size of: ", stringify!(rte_eth_conf__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_dcb_tx_conf) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(vmdq_dcb_tx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_tx_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(dcb_tx_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vmdq_tx_conf) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf__bindgen_ty_2),
-            "::",
-            stringify!(vmdq_tx_conf)
-        )
-    );
-}
-impl Clone for rte_eth_conf__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_eth_conf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_conf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_conf>(),
-        2944usize,
-        concat!("Size of: ", stringify!(rte_eth_conf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_conf>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_conf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).link_speeds) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(link_speeds)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rxmode) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(rxmode)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).txmode) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(txmode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).lpbk_mode) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(lpbk_mode)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rx_adv_conf) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(rx_adv_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tx_adv_conf) as usize - ptr as usize
-        },
-        2152usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(tx_adv_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).dcb_capability_en) as usize -
-                ptr as usize
-        },
-        2164usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(dcb_capability_en)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).fdir_conf) as usize - ptr as usize
-        },
-        2168usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(fdir_conf)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).intr_conf) as usize - ptr as usize
-        },
-        2940usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_conf),
-            "::",
-            stringify!(intr_conf)
-        )
-    );
-}
-impl Clone for rte_eth_conf {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for rte_eth_conf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/layout_kni_mbuf.rs b/tests/expectations/tests/layout_kni_mbuf.rs
deleted file mode 100644
index be88d20f..00000000
--- a/tests/expectations/tests/layout_kni_mbuf.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct rte_kni_mbuf {
-    pub buf_addr: *mut ::std::os::raw::c_void,
-    pub buf_physaddr: u64,
-    pub pad0: [::std::os::raw::c_char; 2usize],
-    ///< Start address of data in segment buffer.
-    pub data_off: u16,
-    pub pad1: [::std::os::raw::c_char; 2usize],
-    ///< Number of segments.
-    pub nb_segs: u8,
-    pub pad4: [::std::os::raw::c_char; 1usize],
-    ///< Offload features.
-    pub ol_flags: u64,
-    pub pad2: [::std::os::raw::c_char; 4usize],
-    ///< Total pkt len: sum of all segment data_len.
-    pub pkt_len: u32,
-    ///< Amount of data in segment buffer.
-    pub data_len: u16,
-    pub __bindgen_padding_0: [u8; 22usize],
-    pub pad3: [::std::os::raw::c_char; 8usize],
-    pub pool: *mut ::std::os::raw::c_void,
-    pub next: *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout_rte_kni_mbuf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_kni_mbuf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_kni_mbuf>(),
-        128usize,
-        concat!("Size of: ", stringify!(rte_kni_mbuf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_kni_mbuf>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_kni_mbuf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(buf_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(buf_physaddr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pad0) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pad0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(data_off)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pad1) as usize - ptr as usize },
-        20usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pad1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
-        22usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(nb_segs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pad4) as usize - ptr as usize },
-        23usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pad4)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(ol_flags)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pad2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pkt_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(data_len)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pad3) as usize - ptr as usize },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pad3)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(pool)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_mbuf),
-            "::",
-            stringify!(next)
-        )
-    );
-}
-impl Default for rte_kni_mbuf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/layout_large_align_field.rs b/tests/expectations/tests/layout_large_align_field.rs
deleted file mode 100644
index 075ef46a..00000000
--- a/tests/expectations/tests/layout_large_align_field.rs
+++ /dev/null
@@ -1,703 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4;
-pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX;
-pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX;
-pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM;
-pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    ///< index of last fragment
-    IP_LAST_FRAG_IDX = 0,
-    ///< index of first fragment
-    IP_FIRST_FRAG_IDX = 1,
-    ///< minimum number of fragments
-    IP_MIN_FRAG_NUM = 2,
-    IP_MAX_FRAG_NUM = 4,
-}
-/// @internal fragmented mbuf
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ip_frag {
-    ///< offset into the packet
-    pub ofs: u16,
-    ///< length of fragment
-    pub len: u16,
-    ///< fragment mbuf
-    pub mb: *mut rte_mbuf,
-}
-#[test]
-fn bindgen_test_layout_ip_frag() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag>(),
-        16usize,
-        concat!("Size of: ", stringify!(ip_frag))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ofs) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(ofs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(len)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mb) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag),
-            "::",
-            stringify!(mb)
-        )
-    );
-}
-impl Default for ip_frag {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ip_frag_key {
-    ///< src address, first 8 bytes used for IPv4
-    pub src_dst: [u64; 4usize],
-    ///< dst address
-    pub id: u32,
-    ///< src/dst key length
-    pub key_len: u32,
-}
-#[test]
-fn bindgen_test_layout_ip_frag_key() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_key> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_key>(),
-        40usize,
-        concat!("Size of: ", stringify!(ip_frag_key))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_key>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag_key))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).src_dst) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(src_dst)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(id)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).key_len) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_key),
-            "::",
-            stringify!(key_len)
-        )
-    );
-}
-/// @internal Fragmented packet to reassemble.
-/// First two entries in the frags[] array are for the last and first fragments.
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct ip_frag_pkt {
-    ///< LRU list
-    pub lru: ip_frag_pkt__bindgen_ty_1,
-    ///< fragmentation key
-    pub key: ip_frag_key,
-    ///< creation timestamp
-    pub start: u64,
-    ///< expected reassembled size
-    pub total_size: u32,
-    ///< size of fragments received
-    pub frag_size: u32,
-    ///< index of next entry to fill
-    pub last_idx: u32,
-    ///< fragments
-    pub frags: [ip_frag; 4usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ip_frag_pkt__bindgen_ty_1 {
-    pub tqe_next: *mut ip_frag_pkt,
-    pub tqe_prev: *mut *mut ip_frag_pkt,
-}
-#[test]
-fn bindgen_test_layout_ip_frag_pkt__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>(),
-        16usize,
-        concat!("Size of: ", stringify!(ip_frag_pkt__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_frag_pkt__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqe_next) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt__bindgen_ty_1),
-            "::",
-            stringify!(tqe_next)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqe_prev) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt__bindgen_ty_1),
-            "::",
-            stringify!(tqe_prev)
-        )
-    );
-}
-impl Default for ip_frag_pkt__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_ip_frag_pkt() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_pkt> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_pkt>(),
-        192usize,
-        concat!("Size of: ", stringify!(ip_frag_pkt))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_pkt>(),
-        64usize,
-        concat!("Alignment of ", stringify!(ip_frag_pkt))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(lru)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(key)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(start)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(total_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).frag_size) as usize - ptr as usize
-        },
-        68usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(frag_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).last_idx) as usize - ptr as usize
-        },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(last_idx)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).frags) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_pkt),
-            "::",
-            stringify!(frags)
-        )
-    );
-}
-impl Default for ip_frag_pkt {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ip_pkt_list {
-    pub tqh_first: *mut ip_frag_pkt,
-    pub tqh_last: *mut *mut ip_frag_pkt,
-}
-#[test]
-fn bindgen_test_layout_ip_pkt_list() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_pkt_list> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_pkt_list>(),
-        16usize,
-        concat!("Size of: ", stringify!(ip_pkt_list))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_pkt_list>(),
-        8usize,
-        concat!("Alignment of ", stringify!(ip_pkt_list))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqh_first) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_pkt_list),
-            "::",
-            stringify!(tqh_first)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tqh_last) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_pkt_list),
-            "::",
-            stringify!(tqh_last)
-        )
-    );
-}
-impl Default for ip_pkt_list {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// fragmentation table statistics
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct ip_frag_tbl_stat {
-    ///< total # of find/insert attempts.
-    pub find_num: u64,
-    ///< # of add ops.
-    pub add_num: u64,
-    ///< # of del ops.
-    pub del_num: u64,
-    ///< # of reuse (del/add) ops.
-    pub reuse_num: u64,
-    ///< total # of add failures.
-    pub fail_total: u64,
-    ///< # of 'no space' add failures.
-    pub fail_nospace: u64,
-}
-#[test]
-fn bindgen_test_layout_ip_frag_tbl_stat() {
-    const UNINIT: ::std::mem::MaybeUninit<ip_frag_tbl_stat> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ip_frag_tbl_stat>(),
-        64usize,
-        concat!("Size of: ", stringify!(ip_frag_tbl_stat))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ip_frag_tbl_stat>(),
-        64usize,
-        concat!("Alignment of ", stringify!(ip_frag_tbl_stat))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).find_num) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(find_num)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).add_num) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(add_num)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).del_num) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(del_num)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).reuse_num) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(reuse_num)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).fail_total) as usize - ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(fail_total)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).fail_nospace) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ip_frag_tbl_stat),
-            "::",
-            stringify!(fail_nospace)
-        )
-    );
-}
-impl Default for ip_frag_tbl_stat {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// fragmentation table
-#[repr(C)]
-#[repr(align(64))]
-pub struct rte_ip_frag_tbl {
-    ///< ttl for table entries.
-    pub max_cycles: u64,
-    ///< hash value mask.
-    pub entry_mask: u32,
-    ///< max entries allowed.
-    pub max_entries: u32,
-    ///< entries in use.
-    pub use_entries: u32,
-    ///< hash assocaitivity.
-    pub bucket_entries: u32,
-    ///< total size of the table.
-    pub nb_entries: u32,
-    ///< num of associativity lines.
-    pub nb_buckets: u32,
-    ///< last used entry.
-    pub last: *mut ip_frag_pkt,
-    ///< LRU list for table entries.
-    pub lru: ip_pkt_list,
-    pub __bindgen_padding_0: u64,
-    ///< statistics counters.
-    pub stat: ip_frag_tbl_stat,
-    ///< hash table.
-    pub pkt: __IncompleteArrayField<ip_frag_pkt>,
-}
-#[test]
-fn bindgen_test_layout_rte_ip_frag_tbl() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ip_frag_tbl> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ip_frag_tbl>(),
-        128usize,
-        concat!("Size of: ", stringify!(rte_ip_frag_tbl))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ip_frag_tbl>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_ip_frag_tbl))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).max_cycles) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(max_cycles)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).entry_mask) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(entry_mask)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).max_entries) as usize - ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(max_entries)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).use_entries) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(use_entries)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).bucket_entries) as usize - ptr as usize
-        },
-        20usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(bucket_entries)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_entries) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(nb_entries)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).nb_buckets) as usize - ptr as usize
-        },
-        28usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(nb_buckets)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(last)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lru) as usize - ptr as usize },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(lru)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).stat) as usize - ptr as usize },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(stat)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pkt) as usize - ptr as usize },
-        128usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ip_frag_tbl),
-            "::",
-            stringify!(pkt)
-        )
-    );
-}
-impl Default for rte_ip_frag_tbl {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-///< fragment mbuf
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_mbuf {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs
deleted file mode 100644
index 800a303b..00000000
--- a/tests/expectations/tests/layout_mbuf.rs
+++ /dev/null
@@ -1,1204 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-pub type phys_addr_t = u64;
-pub type MARKER = [*mut ::std::os::raw::c_void; 0usize];
-pub type MARKER8 = [u8; 0usize];
-pub type MARKER64 = [u64; 0usize];
-/// The atomic counter structure.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_atomic16_t {
-    ///< An internal counter value.
-    pub cnt: i16,
-}
-#[test]
-fn bindgen_test_layout_rte_atomic16_t() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_atomic16_t> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_atomic16_t>(),
-        2usize,
-        concat!("Size of: ", stringify!(rte_atomic16_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_atomic16_t>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_atomic16_t))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cnt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_atomic16_t),
-            "::",
-            stringify!(cnt)
-        )
-    );
-}
-/// The generic rte_mbuf, containing a packet mbuf.
-#[repr(C)]
-#[repr(align(64))]
-pub struct rte_mbuf {
-    pub cacheline0: MARKER,
-    ///< Virtual address of segment buffer.
-    pub buf_addr: *mut ::std::os::raw::c_void,
-    ///< Physical address of segment buffer.
-    pub buf_physaddr: phys_addr_t,
-    ///< Length of segment buffer.
-    pub buf_len: u16,
-    pub rearm_data: MARKER8,
-    pub data_off: u16,
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
-    ///< Number of segments.
-    pub nb_segs: u8,
-    ///< Input port.
-    pub port: u8,
-    ///< Offload features.
-    pub ol_flags: u64,
-    pub rx_descriptor_fields1: MARKER,
-    pub __bindgen_anon_2: rte_mbuf__bindgen_ty_2,
-    ///< Total pkt len: sum of all segments.
-    pub pkt_len: u32,
-    ///< Amount of data in segment buffer.
-    pub data_len: u16,
-    /// VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set.
-    pub vlan_tci: u16,
-    ///< hash information
-    pub hash: rte_mbuf__bindgen_ty_3,
-    ///< Sequence number. See also rte_reorder_insert()
-    pub seqn: u32,
-    /// Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set.
-    pub vlan_tci_outer: u16,
-    pub cacheline1: MARKER,
-    pub __bindgen_anon_3: rte_mbuf__bindgen_ty_4,
-    ///< Pool from which mbuf was allocated.
-    pub pool: *mut rte_mempool,
-    ///< Next segment of scattered packet.
-    pub next: *mut rte_mbuf,
-    pub __bindgen_anon_4: rte_mbuf__bindgen_ty_5,
-    /// Size of the application private data. In case of an indirect
-    /// mbuf, it stores the direct mbuf private data size.
-    pub priv_size: u16,
-    /// Timesync flags for use with IEEE1588.
-    pub timesync: u16,
-}
-/// 16-bit Reference counter.
-/// It should only be accessed using the following functions:
-/// rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
-/// rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
-/// or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
-/// config option.
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_1 {
-    ///< Atomically accessed refcnt
-    pub refcnt_atomic: rte_atomic16_t,
-    ///< Non-atomically accessed refcnt
-    pub refcnt: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).refcnt_atomic) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_1),
-            "::",
-            stringify!(refcnt_atomic)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).refcnt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_1),
-            "::",
-            stringify!(refcnt)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_2 {
-    ///< L2/L3/L4 and tunnel information.
-    pub packet_type: u32,
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_2__bindgen_ty_1,
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-}
-impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l2_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l3_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l4_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tun_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tun_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l2_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l3_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(20usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l4_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        l2_type: u32,
-        l3_type: u32,
-        l4_type: u32,
-        tun_type: u32,
-        inner_l2_type: u32,
-        inner_l3_type: u32,
-        inner_l4_type: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 4u8, {
-            let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
-            l2_type as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 4u8, {
-            let l3_type: u32 = unsafe { ::std::mem::transmute(l3_type) };
-            l3_type as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 4u8, {
-            let l4_type: u32 = unsafe { ::std::mem::transmute(l4_type) };
-            l4_type as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 4u8, {
-            let tun_type: u32 = unsafe { ::std::mem::transmute(tun_type) };
-            tun_type as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 4u8, {
-            let inner_l2_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l2_type) };
-            inner_l2_type as u64
-        });
-        __bindgen_bitfield_unit.set(20usize, 4u8, {
-            let inner_l3_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l3_type) };
-            inner_l3_type as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 4u8, {
-            let inner_l4_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l4_type) };
-            inner_l4_type as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).packet_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_2),
-            "::",
-            stringify!(packet_type)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_3 {
-    ///< RSS hash result if RSS enabled
-    pub rss: u32,
-    ///< Filter identifier if FDIR enabled
-    pub fdir: rte_mbuf__bindgen_ty_3__bindgen_ty_1,
-    ///< Hierarchical scheduler
-    pub sched: rte_mbuf__bindgen_ty_3__bindgen_ty_2,
-    ///< User defined tags. See rte_distributor_process()
-    pub usr: u32,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-    pub hi: u32,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
-    pub __bindgen_anon_1:
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
-    pub lo: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
-    pub hash: u16,
-    pub id: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
-) {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq ! (:: std :: mem :: size_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 4usize , concat ! ("Size of: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
-    assert_eq ! (:: std :: mem :: align_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 2usize , concat ! ("Alignment of " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
-    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hash) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (hash)));
-    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . id) as usize - ptr as usize } , 2usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (id)));
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<
-            rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-        >(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(lo)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1),
-            "::",
-            stringify!(hi)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
-    pub lo: u32,
-    pub hi: u32,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_2,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
-            "::",
-            stringify!(lo)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
-            "::",
-            stringify!(hi)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_3> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_3))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_3))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(rss)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).fdir) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(fdir)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sched) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(sched)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).usr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(usr)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_3 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_4 {
-    ///< Can be used for external metadata
-    pub userdata: *mut ::std::os::raw::c_void,
-    ///< Allow 8-byte userdata on 32-bit
-    pub udata64: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_4() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_4> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_4>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_4>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_4))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_4),
-            "::",
-            stringify!(userdata)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).udata64) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_4),
-            "::",
-            stringify!(udata64)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_4 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union rte_mbuf__bindgen_ty_5 {
-    ///< combined for easy fetch
-    pub tx_offload: u64,
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_5__bindgen_ty_1,
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    pub _bitfield_align_1: [u16; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
-        )
-    );
-}
-impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l2_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l3_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 9u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l4_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l4_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tso_segsz(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 16u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_tso_segsz(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 16u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn outer_l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(40usize, 9u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l3_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(40usize, 9u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn outer_l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(49usize, 7u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l2_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(49usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        l2_len: u64,
-        l3_len: u64,
-        l4_len: u64,
-        tso_segsz: u64,
-        outer_l3_len: u64,
-        outer_l2_len: u64,
-    ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 7u8, {
-            let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
-            l2_len as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 9u8, {
-            let l3_len: u64 = unsafe { ::std::mem::transmute(l3_len) };
-            l3_len as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 8u8, {
-            let l4_len: u64 = unsafe { ::std::mem::transmute(l4_len) };
-            l4_len as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 16u8, {
-            let tso_segsz: u64 = unsafe { ::std::mem::transmute(tso_segsz) };
-            tso_segsz as u64
-        });
-        __bindgen_bitfield_unit.set(40usize, 9u8, {
-            let outer_l3_len: u64 =
-                unsafe { ::std::mem::transmute(outer_l3_len) };
-            outer_l3_len as u64
-        });
-        __bindgen_bitfield_unit.set(49usize, 7u8, {
-            let outer_l2_len: u64 =
-                unsafe { ::std::mem::transmute(outer_l2_len) };
-            outer_l2_len as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_5() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_5> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_5))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_5))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tx_offload) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_5),
-            "::",
-            stringify!(tx_offload)
-        )
-    );
-}
-impl Default for rte_mbuf__bindgen_ty_5 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf>(),
-        128usize,
-        concat!("Size of: ", stringify!(rte_mbuf))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf>(),
-        64usize,
-        concat!("Alignment of ", stringify!(rte_mbuf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).cacheline0) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(cacheline0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_physaddr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).buf_len) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rearm_data) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(rearm_data)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(data_off)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
-        22usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(nb_segs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
-        23usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(port)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(ol_flags)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rx_descriptor_fields1) as usize -
-                ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(rx_descriptor_fields1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(pkt_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(data_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci) as usize - ptr as usize
-        },
-        42usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(vlan_tci)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(hash)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).seqn) as usize - ptr as usize },
-        52usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(seqn)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci_outer) as usize - ptr as usize
-        },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(vlan_tci_outer)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).cacheline1) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(cacheline1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(pool)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(next)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).priv_size) as usize - ptr as usize
-        },
-        96usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(priv_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).timesync) as usize - ptr as usize
-        },
-        98usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(timesync)
-        )
-    );
-}
-impl Default for rte_mbuf {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-///< Pool from which mbuf was allocated.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct rte_mempool {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/layout_mbuf_1_0.rs b/tests/expectations/tests/layout_mbuf_1_0.rs
deleted file mode 100644
index 90f7ed09..00000000
--- a/tests/expectations/tests/layout_mbuf_1_0.rs
+++ /dev/null
@@ -1,1255 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-pub const RTE_CACHE_LINE_MIN_SIZE: u32 = 64;
-pub const RTE_CACHE_LINE_SIZE: u32 = 64;
-pub type phys_addr_t = u64;
-pub type MARKER = [*mut ::std::os::raw::c_void; 0usize];
-pub type MARKER8 = [u8; 0usize];
-pub type MARKER64 = [u64; 0usize];
-/// The atomic counter structure.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_atomic16_t {
-    ///< An internal counter value.
-    pub cnt: i16,
-}
-#[test]
-fn bindgen_test_layout_rte_atomic16_t() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_atomic16_t> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_atomic16_t>(),
-        2usize,
-        concat!("Size of: ", stringify!(rte_atomic16_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_atomic16_t>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_atomic16_t))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cnt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_atomic16_t),
-            "::",
-            stringify!(cnt)
-        )
-    );
-}
-impl Clone for rte_atomic16_t {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-/// The generic rte_mbuf, containing a packet mbuf.
-#[repr(C)]
-pub struct rte_mbuf {
-    pub cacheline0: MARKER,
-    ///< Virtual address of segment buffer.
-    pub buf_addr: *mut ::std::os::raw::c_void,
-    ///< Physical address of segment buffer.
-    pub buf_physaddr: phys_addr_t,
-    ///< Length of segment buffer.
-    pub buf_len: u16,
-    pub rearm_data: MARKER8,
-    pub data_off: u16,
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_1,
-    ///< Number of segments.
-    pub nb_segs: u8,
-    ///< Input port.
-    pub port: u8,
-    ///< Offload features.
-    pub ol_flags: u64,
-    pub rx_descriptor_fields1: MARKER,
-    pub __bindgen_anon_2: rte_mbuf__bindgen_ty_2,
-    ///< Total pkt len: sum of all segments.
-    pub pkt_len: u32,
-    ///< Amount of data in segment buffer.
-    pub data_len: u16,
-    /// VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set.
-    pub vlan_tci: u16,
-    ///< hash information
-    pub hash: rte_mbuf__bindgen_ty_3,
-    ///< Sequence number. See also rte_reorder_insert()
-    pub seqn: u32,
-    /// Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set.
-    pub vlan_tci_outer: u16,
-    pub cacheline1: MARKER,
-    pub __bindgen_anon_3: rte_mbuf__bindgen_ty_4,
-    ///< Pool from which mbuf was allocated.
-    pub pool: *mut rte_mempool,
-    ///< Next segment of scattered packet.
-    pub next: *mut rte_mbuf,
-    pub __bindgen_anon_4: rte_mbuf__bindgen_ty_5,
-    /// Size of the application private data. In case of an indirect
-    /// mbuf, it stores the direct mbuf private data size.
-    pub priv_size: u16,
-    /// Timesync flags for use with IEEE1588.
-    pub timesync: u16,
-    pub __bindgen_padding_0: [u32; 7usize],
-}
-/// 16-bit Reference counter.
-/// It should only be accessed using the following functions:
-/// rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
-/// rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
-/// or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
-/// config option.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_1 {
-    ///< Atomically accessed refcnt
-    pub refcnt_atomic: __BindgenUnionField<rte_atomic16_t>,
-    ///< Non-atomically accessed refcnt
-    pub refcnt: __BindgenUnionField<u16>,
-    pub bindgen_union_field: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).refcnt_atomic) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_1),
-            "::",
-            stringify!(refcnt_atomic)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).refcnt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_1),
-            "::",
-            stringify!(refcnt)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_2 {
-    ///< L2/L3/L4 and tunnel information.
-    pub packet_type: __BindgenUnionField<u32>,
-    pub __bindgen_anon_1:
-        __BindgenUnionField<rte_mbuf__bindgen_ty_2__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-    pub __bindgen_align: [u32; 0usize],
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_2__bindgen_ty_1)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l2_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l3_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l4_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tun_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tun_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l2_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l3_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(20usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inner_l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l4_type(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        l2_type: u32,
-        l3_type: u32,
-        l4_type: u32,
-        tun_type: u32,
-        inner_l2_type: u32,
-        inner_l3_type: u32,
-        inner_l4_type: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 4u8, {
-            let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
-            l2_type as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 4u8, {
-            let l3_type: u32 = unsafe { ::std::mem::transmute(l3_type) };
-            l3_type as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 4u8, {
-            let l4_type: u32 = unsafe { ::std::mem::transmute(l4_type) };
-            l4_type as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 4u8, {
-            let tun_type: u32 = unsafe { ::std::mem::transmute(tun_type) };
-            tun_type as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 4u8, {
-            let inner_l2_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l2_type) };
-            inner_l2_type as u64
-        });
-        __bindgen_bitfield_unit.set(20usize, 4u8, {
-            let inner_l3_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l3_type) };
-            inner_l3_type as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 4u8, {
-            let inner_l4_type: u32 =
-                unsafe { ::std::mem::transmute(inner_l4_type) };
-            inner_l4_type as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).packet_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_2),
-            "::",
-            stringify!(packet_type)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3 {
-    ///< RSS hash result if RSS enabled
-    pub rss: __BindgenUnionField<u32>,
-    ///< Filter identifier if FDIR enabled
-    pub fdir: __BindgenUnionField<rte_mbuf__bindgen_ty_3__bindgen_ty_1>,
-    ///< Hierarchical scheduler
-    pub sched: __BindgenUnionField<rte_mbuf__bindgen_ty_3__bindgen_ty_2>,
-    ///< User defined tags. See rte_distributor_process()
-    pub usr: __BindgenUnionField<u32>,
-    pub bindgen_union_field: [u32; 2usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
-    pub __bindgen_anon_1: rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-    pub hi: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
-    pub __bindgen_anon_1: __BindgenUnionField<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
-    >,
-    pub lo: __BindgenUnionField<u32>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
-    pub hash: u16,
-    pub id: u16,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
-) {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq ! (:: std :: mem :: size_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 4usize , concat ! ("Size of: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
-    assert_eq ! (:: std :: mem :: align_of :: < rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 2usize , concat ! ("Alignment of " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)));
-    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hash) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (hash)));
-    assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . id) as usize - ptr as usize } , 2usize , concat ! ("Offset of field: " , stringify ! (rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (id)));
-}
-impl Clone
-    for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
-{
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<
-            rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1,
-        >(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(lo)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_1,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_1>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_1),
-            "::",
-            stringify!(hi)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
-    pub lo: u32,
-    pub hi: u32,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        rte_mbuf__bindgen_ty_3__bindgen_ty_2,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3__bindgen_ty_2>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
-            "::",
-            stringify!(lo)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3__bindgen_ty_2),
-            "::",
-            stringify!(hi)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_3__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_3() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_3> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_3>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_3))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_3>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_3))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rss) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(rss)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).fdir) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(fdir)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).sched) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(sched)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).usr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_3),
-            "::",
-            stringify!(usr)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_3 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_4 {
-    ///< Can be used for external metadata
-    pub userdata: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    ///< Allow 8-byte userdata on 32-bit
-    pub udata64: __BindgenUnionField<u64>,
-    pub bindgen_union_field: u64,
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_4() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_4> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_4>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_4>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_4))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_4),
-            "::",
-            stringify!(userdata)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).udata64) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_4),
-            "::",
-            stringify!(udata64)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_4 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_5 {
-    ///< combined for easy fetch
-    pub tx_offload: __BindgenUnionField<u64>,
-    pub __bindgen_anon_1:
-        __BindgenUnionField<rte_mbuf__bindgen_ty_5__bindgen_ty_1>,
-    pub bindgen_union_field: u64,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    pub _bitfield_align_1: [u16; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
-    pub __bindgen_align: [u64; 0usize],
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Size of: ",
-            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5__bindgen_ty_1>(),
-        8usize,
-        concat!(
-            "Alignment of ",
-            stringify!(rte_mbuf__bindgen_ty_5__bindgen_ty_1)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l2_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l3_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 9u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn l4_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l4_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 8u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn tso_segsz(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(24usize, 16u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_tso_segsz(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(24usize, 16u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn outer_l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(40usize, 9u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l3_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(40usize, 9u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn outer_l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(49usize, 7u8) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l2_len(&mut self, val: u64) {
-        unsafe {
-            let val: u64 = ::std::mem::transmute(val);
-            self._bitfield_1.set(49usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        l2_len: u64,
-        l3_len: u64,
-        l4_len: u64,
-        tso_segsz: u64,
-        outer_l3_len: u64,
-        outer_l2_len: u64,
-    ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 7u8, {
-            let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
-            l2_len as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 9u8, {
-            let l3_len: u64 = unsafe { ::std::mem::transmute(l3_len) };
-            l3_len as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 8u8, {
-            let l4_len: u64 = unsafe { ::std::mem::transmute(l4_len) };
-            l4_len as u64
-        });
-        __bindgen_bitfield_unit.set(24usize, 16u8, {
-            let tso_segsz: u64 = unsafe { ::std::mem::transmute(tso_segsz) };
-            tso_segsz as u64
-        });
-        __bindgen_bitfield_unit.set(40usize, 9u8, {
-            let outer_l3_len: u64 =
-                unsafe { ::std::mem::transmute(outer_l3_len) };
-            outer_l3_len as u64
-        });
-        __bindgen_bitfield_unit.set(49usize, 7u8, {
-            let outer_l2_len: u64 =
-                unsafe { ::std::mem::transmute(outer_l2_len) };
-            outer_l2_len as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf__bindgen_ty_5() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf__bindgen_ty_5> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf__bindgen_ty_5>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_mbuf__bindgen_ty_5))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_mbuf__bindgen_ty_5>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_mbuf__bindgen_ty_5))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).tx_offload) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf__bindgen_ty_5),
-            "::",
-            stringify!(tx_offload)
-        )
-    );
-}
-impl Clone for rte_mbuf__bindgen_ty_5 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_rte_mbuf() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_mbuf> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_mbuf>(),
-        128usize,
-        concat!("Size of: ", stringify!(rte_mbuf))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).cacheline0) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(cacheline0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_addr) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_addr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).buf_physaddr) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_physaddr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).buf_len) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(buf_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rearm_data) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(rearm_data)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_off) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(data_off)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).nb_segs) as usize - ptr as usize },
-        22usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(nb_segs)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
-        23usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(port)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).ol_flags) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(ol_flags)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).rx_descriptor_fields1) as usize -
-                ptr as usize
-        },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(rx_descriptor_fields1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pkt_len) as usize - ptr as usize },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(pkt_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(data_len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci) as usize - ptr as usize
-        },
-        42usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(vlan_tci)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(hash)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).seqn) as usize - ptr as usize },
-        52usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(seqn)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).vlan_tci_outer) as usize - ptr as usize
-        },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(vlan_tci_outer)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).cacheline1) as usize - ptr as usize
-        },
-        64usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(cacheline1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(pool)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(next)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).priv_size) as usize - ptr as usize
-        },
-        96usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(priv_size)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).timesync) as usize - ptr as usize
-        },
-        98usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_mbuf),
-            "::",
-            stringify!(timesync)
-        )
-    );
-}
-impl Default for rte_mbuf {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-///< Pool from which mbuf was allocated.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct rte_mempool {
-    pub _address: u8,
-}
-impl Clone for rte_mempool {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/libclang-5/abi_variadic_function.rs b/tests/expectations/tests/libclang-5/abi_variadic_function.rs
deleted file mode 100644
index 6aeb16f2..00000000
--- a/tests/expectations/tests/libclang-5/abi_variadic_function.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z1bcz"]
-    pub fn b(arg1: ::std::os::raw::c_char, ...) -> ::std::os::raw::c_char;
-}
diff --git a/tests/expectations/tests/libclang-5/auto.rs b/tests/expectations/tests/libclang-5/auto.rs
deleted file mode 100644
index 0b20b39e..00000000
--- a/tests/expectations/tests/libclang-5/auto.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub const Foo_kFoo: bool = true;
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5Test2v"]
-    pub fn Test2() -> ::std::os::raw::c_uint;
-}
diff --git a/tests/expectations/tests/libclang-5/call-conv-field.rs b/tests/expectations/tests/libclang-5/call-conv-field.rs
deleted file mode 100644
index 62b5ace2..00000000
--- a/tests/expectations/tests/libclang-5/call-conv-field.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(test))]
-
-#[repr(C)]
-#[derive(Default, Copy, Clone)]
-pub struct JNINativeInterface_ {
-    pub GetVersion: ::std::option::Option<
-        unsafe extern "stdcall" fn(
-            env: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-    >,
-    pub __hack: ::std::os::raw::c_ulonglong,
-}
-#[test]
-fn bindgen_test_layout_JNINativeInterface_() {
-    const UNINIT: ::std::mem::MaybeUninit<JNINativeInterface_> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<JNINativeInterface_>(),
-        16usize,
-        concat!("Size of: ", stringify!(JNINativeInterface_))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<JNINativeInterface_>(),
-        8usize,
-        concat!("Alignment of ", stringify!(JNINativeInterface_))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).GetVersion) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JNINativeInterface_),
-            "::",
-            stringify!(GetVersion)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).__hack) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JNINativeInterface_),
-            "::",
-            stringify!(__hack)
-        )
-    );
-}
-extern "stdcall" {
-    pub fn bar();
-}
diff --git a/tests/expectations/tests/libclang-5/const_bool.rs b/tests/expectations/tests/libclang-5/const_bool.rs
deleted file mode 100644
index 97e1d8dd..00000000
--- a/tests/expectations/tests/libclang-5/const_bool.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const k: bool = true;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub _address: u8,
-}
-pub const A_k: bool = false;
-#[test]
-fn bindgen_test_layout_A() {
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-}
-pub type foo = bool;
-pub const k2: foo = true;
diff --git a/tests/expectations/tests/libclang-5/constant-evaluate.rs b/tests/expectations/tests/libclang-5/constant-evaluate.rs
deleted file mode 100644
index 9debe39d..00000000
--- a/tests/expectations/tests/libclang-5/constant-evaluate.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo;
-pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    foo = 4,
-    bar = 8,
-}
-pub type EasyToOverflow = ::std::os::raw::c_ulonglong;
-pub const k: EasyToOverflow = 2147483648;
-pub const k_expr: EasyToOverflow = 1152921504606846976;
-pub const wow: EasyToOverflow = 2147483648;
-pub const BAZ: ::std::os::raw::c_longlong = 24;
-pub const fuzz: f64 = 51.0;
-pub const BAZZ: ::std::os::raw::c_char = 53;
-pub const WAT: ::std::os::raw::c_char = 0;
-pub const bytestring: &[u8; 4usize] = b"Foo\0";
-pub const NOT_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs b/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
deleted file mode 100644
index 57878592..00000000
--- a/tests/expectations/tests/libclang-5/error-E0600-cannot-apply-unary-negation-to-u32.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![allow(overflowing_literals)]
-
-pub const a: u32 = 4294967291;
diff --git a/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs b/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
deleted file mode 100644
index 60857966..00000000
--- a/tests/expectations/tests/libclang-5/issue-769-bad-instantiation-test.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct Rooted<T> {
-        pub member: T,
-        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    }
-    impl<T> Default for Rooted<T> {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-    pub type AutoValueVector_Alias = ::std::os::raw::c_int;
-    #[test]
-    fn __bindgen_test_layout_Rooted_open0_int_close0_instantiation() {
-        assert_eq!(
-            ::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>(),
-            4usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::Rooted<::std::os::raw::c_int>)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>(),
-            4usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::Rooted<::std::os::raw::c_int>)
-            )
-        );
-    }
-    #[test]
-    fn __bindgen_test_layout_Rooted_open0_AutoValueVector_Alias_close0_instantiation(
-    ) {
-        assert_eq!(
-            ::std::mem::size_of::<root::Rooted<root::AutoValueVector_Alias>>(),
-            4usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::Rooted<root::AutoValueVector_Alias>)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::Rooted<root::AutoValueVector_Alias>>(),
-            4usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::Rooted<root::AutoValueVector_Alias>)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/libclang-5/mangling-win32.rs b/tests/expectations/tests/libclang-5/mangling-win32.rs
deleted file mode 100644
index 0aee3274..00000000
--- a/tests/expectations/tests/libclang-5/mangling-win32.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "fastcall" {
-    pub fn fast_call_func_no_args() -> ::std::os::raw::c_int;
-}
-extern "fastcall" {
-    pub fn fast_call_func_many_args(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-extern "stdcall" {
-    pub fn std_call_func_no_args() -> ::std::os::raw::c_int;
-}
-extern "stdcall" {
-    pub fn std_call_func_many_args(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/libclang-5/objc_inheritance.rs b/tests/expectations/tests/libclang-5/objc_inheritance.rs
deleted file mode 100644
index f1c2a88c..00000000
--- a/tests/expectations/tests/libclang-5/objc_inheritance.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar(pub id);
-impl std::ops::Deref for Bar {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Bar {}
-impl Bar {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Bar), alloc) })
-    }
-}
-impl IFoo for Bar {}
-impl From<Bar> for Foo {
-    fn from(child: Bar) -> Foo {
-        Foo(child.0)
-    }
-}
-impl std::convert::TryFrom<Foo> for Bar {
-    type Error = &'static str;
-    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
-        if is_kind_of {
-            Ok(Bar(parent.0))
-        } else {
-            Err("This Foo cannot be downcasted to Bar")
-        }
-    }
-}
-impl IBar for Bar {}
-pub trait IBar: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Baz(pub id);
-impl std::ops::Deref for Baz {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Baz {}
-impl Baz {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Baz), alloc) })
-    }
-}
-impl IBar for Baz {}
-impl From<Baz> for Bar {
-    fn from(child: Baz) -> Bar {
-        Bar(child.0)
-    }
-}
-impl std::convert::TryFrom<Bar> for Baz {
-    type Error = &'static str;
-    fn try_from(parent: Bar) -> Result<Baz, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
-        if is_kind_of {
-            Ok(Baz(parent.0))
-        } else {
-            Err("This Bar cannot be downcasted to Baz")
-        }
-    }
-}
-impl IFoo for Baz {}
-impl From<Baz> for Foo {
-    fn from(child: Baz) -> Foo {
-        Foo(child.0)
-    }
-}
-impl std::convert::TryFrom<Foo> for Baz {
-    type Error = &'static str;
-    fn try_from(parent: Foo) -> Result<Baz, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
-        if is_kind_of {
-            Ok(Baz(parent.0))
-        } else {
-            Err("This Foo cannot be downcasted to Baz")
-        }
-    }
-}
-impl IBaz for Baz {}
-pub trait IBaz: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/libclang-5/objc_template.rs b/tests/expectations/tests/libclang-5/objc_template.rs
deleted file mode 100644
index 53caa661..00000000
--- a/tests/expectations/tests/libclang-5/objc_template.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
-pub trait IFoo<ObjectType: 'static>: Sized + std::ops::Deref {
-    unsafe fn get(&self) -> *mut ObjectType
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, get)
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct FooMultiGeneric(pub id);
-impl std::ops::Deref for FooMultiGeneric {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for FooMultiGeneric {}
-impl FooMultiGeneric {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(FooMultiGeneric), alloc) })
-    }
-}
-impl<KeyType: 'static, ObjectType: 'static>
-    IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric
-{
-}
-pub trait IFooMultiGeneric<KeyType: 'static, ObjectType: 'static>:
-    Sized + std::ops::Deref
-{
-    unsafe fn objectForKey_(&self, key: *mut KeyType) -> *mut ObjectType
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, objectForKey: key)
-    }
-}
diff --git a/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs b/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
deleted file mode 100644
index e62ea681..00000000
--- a/tests/expectations/tests/libclang-5/partial-specialization-and-inheritance.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Base {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Derived {
-    pub b: bool,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Usage {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN5Usage13static_memberE"]
-    pub static mut Usage_static_member: [u32; 2usize];
-}
-#[test]
-fn bindgen_test_layout_Usage() {
-    assert_eq!(
-        ::std::mem::size_of::<Usage>(),
-        1usize,
-        concat!("Size of: ", stringify!(Usage))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Usage>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Usage))
-    );
-}
diff --git a/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs b/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
deleted file mode 100644
index 19f8881d..00000000
--- a/tests/expectations/tests/libclang-5/type_alias_template_specialized.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted {
-    pub ptr: MaybeWrapped<::std::os::raw::c_int>,
-}
-#[test]
-fn bindgen_test_layout_Rooted() {
-    const UNINIT: ::std::mem::MaybeUninit<Rooted> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Rooted>(),
-        4usize,
-        concat!("Size of: ", stringify!(Rooted))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Rooted>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Rooted))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Rooted),
-            "::",
-            stringify!(ptr)
-        )
-    );
-}
-impl Default for Rooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// <div rustbindgen replaces="MaybeWrapped"></div>
-pub type MaybeWrapped<a> = a;
-#[test]
-fn __bindgen_test_layout_MaybeWrapped_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<MaybeWrapped<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(MaybeWrapped<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MaybeWrapped<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(MaybeWrapped<::std::os::raw::c_int>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/libclang-9/abi_variadic_function.rs b/tests/expectations/tests/libclang-9/abi_variadic_function.rs
deleted file mode 100644
index 6aeb16f2..00000000
--- a/tests/expectations/tests/libclang-9/abi_variadic_function.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z1bcz"]
-    pub fn b(arg1: ::std::os::raw::c_char, ...) -> ::std::os::raw::c_char;
-}
diff --git a/tests/expectations/tests/libclang-9/auto.rs b/tests/expectations/tests/libclang-9/auto.rs
deleted file mode 100644
index 0b20b39e..00000000
--- a/tests/expectations/tests/libclang-9/auto.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub const Foo_kFoo: bool = true;
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_Z5Test2v"]
-    pub fn Test2() -> ::std::os::raw::c_uint;
-}
diff --git a/tests/expectations/tests/libclang-9/call-conv-field.rs b/tests/expectations/tests/libclang-9/call-conv-field.rs
deleted file mode 100644
index 62b5ace2..00000000
--- a/tests/expectations/tests/libclang-9/call-conv-field.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(test))]
-
-#[repr(C)]
-#[derive(Default, Copy, Clone)]
-pub struct JNINativeInterface_ {
-    pub GetVersion: ::std::option::Option<
-        unsafe extern "stdcall" fn(
-            env: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int,
-    >,
-    pub __hack: ::std::os::raw::c_ulonglong,
-}
-#[test]
-fn bindgen_test_layout_JNINativeInterface_() {
-    const UNINIT: ::std::mem::MaybeUninit<JNINativeInterface_> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<JNINativeInterface_>(),
-        16usize,
-        concat!("Size of: ", stringify!(JNINativeInterface_))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<JNINativeInterface_>(),
-        8usize,
-        concat!("Alignment of ", stringify!(JNINativeInterface_))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).GetVersion) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JNINativeInterface_),
-            "::",
-            stringify!(GetVersion)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).__hack) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JNINativeInterface_),
-            "::",
-            stringify!(__hack)
-        )
-    );
-}
-extern "stdcall" {
-    pub fn bar();
-}
diff --git a/tests/expectations/tests/libclang-9/class.rs b/tests/expectations/tests/libclang-9/class.rs
deleted file mode 100644
index 0d64a9ff..00000000
--- a/tests/expectations/tests/libclang-9/class.rs
+++ /dev/null
@@ -1,691 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct C {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        40usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(big_array)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct C_with_zero_length_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for C_with_incomplete_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array_2),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_zero_length_array_and_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        C_with_zero_length_array_and_incomplete_array,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
-        40usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array_and_incomplete_array {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_and_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        C_with_zero_length_array_and_incomplete_array_2,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct WithDtor {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithDtor>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDtor>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDtor),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-pub struct IncompleteArrayNonCopiable {
-    pub whatever: *mut ::std::os::raw::c_void,
-    pub incomplete_array: __IncompleteArrayField<C>,
-}
-#[test]
-fn bindgen_test_layout_IncompleteArrayNonCopiable() {
-    const UNINIT: ::std::mem::MaybeUninit<IncompleteArrayNonCopiable> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(IncompleteArrayNonCopiable),
-            "::",
-            stringify!(whatever)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(IncompleteArrayNonCopiable),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for IncompleteArrayNonCopiable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union Union {
-    pub d: f32,
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Union() {
-    const UNINIT: ::std::mem::MaybeUninit<Union> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Union>(),
-        4usize,
-        concat!("Size of: ", stringify!(Union))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Union>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Union))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
-    );
-}
-impl Default for Union {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct WithUnion {
-    pub data: Union,
-}
-#[test]
-fn bindgen_test_layout_WithUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithUnion>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithUnion>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithUnion),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Default for WithUnion {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct RealAbstractionWithTonsOfMethods {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!(
-            "Alignment of ",
-            stringify!(RealAbstractionWithTonsOfMethods)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar(
-        this: *const RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar1(
-        this: *mut RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
-    pub fn RealAbstractionWithTonsOfMethods_bar2(
-        this: *mut RealAbstractionWithTonsOfMethods,
-        foo: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
-    pub fn RealAbstractionWithTonsOfMethods_sta();
-}
-impl RealAbstractionWithTonsOfMethods {
-    #[inline]
-    pub unsafe fn bar(&self) {
-        RealAbstractionWithTonsOfMethods_bar(self)
-    }
-    #[inline]
-    pub unsafe fn bar1(&mut self) {
-        RealAbstractionWithTonsOfMethods_bar1(self)
-    }
-    #[inline]
-    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
-        RealAbstractionWithTonsOfMethods_bar2(self, foo)
-    }
-    #[inline]
-    pub unsafe fn sta() {
-        RealAbstractionWithTonsOfMethods_sta()
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/class_1_0.rs b/tests/expectations/tests/libclang-9/class_1_0.rs
deleted file mode 100644
index e8c2e077..00000000
--- a/tests/expectations/tests/libclang-9/class_1_0.rs
+++ /dev/null
@@ -1,742 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Copy)]
-pub struct C {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        40usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(big_array)
-        )
-    );
-}
-impl Clone for C {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for C {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl ::std::cmp::PartialEq for C {
-    fn eq(&self, other: &C) -> bool {
-        self.a == other.a && &self.big_array[..] == &other.big_array[..]
-    }
-}
-#[repr(C)]
-pub struct C_with_zero_length_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_zero_length_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_zero_length_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array>(),
-        40usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for C_with_incomplete_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_incomplete_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<C_with_incomplete_array_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_incomplete_array_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C_with_incomplete_array_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_incomplete_array_2),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-#[repr(C)]
-pub struct C_with_zero_length_array_and_incomplete_array {
-    pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_char; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        C_with_zero_length_array_and_incomplete_array,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array>(),
-        40usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).big_array) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(big_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        37usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for C_with_zero_length_array_and_incomplete_array {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct C_with_zero_length_array_and_incomplete_array_2 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array_2() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        C_with_zero_length_array_and_incomplete_array_2,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C_with_zero_length_array_and_incomplete_array_2>(
-        ),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C_with_zero_length_array_and_incomplete_array_2),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Hash, PartialEq, Eq)]
-pub struct WithDtor {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<WithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithDtor>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDtor>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDtor),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-pub struct IncompleteArrayNonCopiable {
-    pub whatever: *mut ::std::os::raw::c_void,
-    pub incomplete_array: __IncompleteArrayField<C>,
-}
-#[test]
-fn bindgen_test_layout_IncompleteArrayNonCopiable() {
-    const UNINIT: ::std::mem::MaybeUninit<IncompleteArrayNonCopiable> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Size of: ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<IncompleteArrayNonCopiable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(IncompleteArrayNonCopiable))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(IncompleteArrayNonCopiable),
-            "::",
-            stringify!(whatever)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(IncompleteArrayNonCopiable),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-impl Default for IncompleteArrayNonCopiable {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct Union {
-    pub d: __BindgenUnionField<f32>,
-    pub i: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_Union() {
-    const UNINIT: ::std::mem::MaybeUninit<Union> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Union>(),
-        4usize,
-        concat!("Size of: ", stringify!(Union))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Union>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Union))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Union), "::", stringify!(i))
-    );
-}
-impl Clone for Union {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct WithUnion {
-    pub data: Union,
-}
-#[test]
-fn bindgen_test_layout_WithUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<WithUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithUnion>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithUnion>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithUnion),
-            "::",
-            stringify!(data)
-        )
-    );
-}
-impl Clone for WithUnion {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct RealAbstractionWithTonsOfMethods {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_RealAbstractionWithTonsOfMethods() {
-    assert_eq!(
-        ::std::mem::size_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!("Size of: ", stringify!(RealAbstractionWithTonsOfMethods))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RealAbstractionWithTonsOfMethods>(),
-        1usize,
-        concat!(
-            "Alignment of ",
-            stringify!(RealAbstractionWithTonsOfMethods)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZNK32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar(
-        this: *const RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEv"]
-    pub fn RealAbstractionWithTonsOfMethods_bar1(
-        this: *mut RealAbstractionWithTonsOfMethods,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3barEi"]
-    pub fn RealAbstractionWithTonsOfMethods_bar2(
-        this: *mut RealAbstractionWithTonsOfMethods,
-        foo: ::std::os::raw::c_int,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN32RealAbstractionWithTonsOfMethods3staEv"]
-    pub fn RealAbstractionWithTonsOfMethods_sta();
-}
-impl Clone for RealAbstractionWithTonsOfMethods {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl RealAbstractionWithTonsOfMethods {
-    #[inline]
-    pub unsafe fn bar(&self) {
-        RealAbstractionWithTonsOfMethods_bar(self)
-    }
-    #[inline]
-    pub unsafe fn bar1(&mut self) {
-        RealAbstractionWithTonsOfMethods_bar1(self)
-    }
-    #[inline]
-    pub unsafe fn bar2(&mut self, foo: ::std::os::raw::c_int) {
-        RealAbstractionWithTonsOfMethods_bar2(self, foo)
-    }
-    #[inline]
-    pub unsafe fn sta() {
-        RealAbstractionWithTonsOfMethods_sta()
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/const_bool.rs b/tests/expectations/tests/libclang-9/const_bool.rs
deleted file mode 100644
index 97e1d8dd..00000000
--- a/tests/expectations/tests/libclang-9/const_bool.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const k: bool = true;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub _address: u8,
-}
-pub const A_k: bool = false;
-#[test]
-fn bindgen_test_layout_A() {
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        1usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        1usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-}
-pub type foo = bool;
-pub const k2: foo = true;
diff --git a/tests/expectations/tests/libclang-9/constant-evaluate.rs b/tests/expectations/tests/libclang-9/constant-evaluate.rs
deleted file mode 100644
index 9debe39d..00000000
--- a/tests/expectations/tests/libclang-9/constant-evaluate.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const foo: _bindgen_ty_1 = _bindgen_ty_1::foo;
-pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_1 {
-    foo = 4,
-    bar = 8,
-}
-pub type EasyToOverflow = ::std::os::raw::c_ulonglong;
-pub const k: EasyToOverflow = 2147483648;
-pub const k_expr: EasyToOverflow = 1152921504606846976;
-pub const wow: EasyToOverflow = 2147483648;
-pub const BAZ: ::std::os::raw::c_longlong = 24;
-pub const fuzz: f64 = 51.0;
-pub const BAZZ: ::std::os::raw::c_char = 53;
-pub const WAT: ::std::os::raw::c_char = 0;
-pub const bytestring: &[u8; 4usize] = b"Foo\0";
-pub const NOT_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs b/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
deleted file mode 100644
index 2af22cc4..00000000
--- a/tests/expectations/tests/libclang-9/derive-hash-struct-with-incomplete-array.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test() {
-    const UNINIT: ::std::mem::MaybeUninit<test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<test>(),
-        4usize,
-        concat!("Size of: ", stringify!(test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(test), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(test),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test2 {
-    pub a: ::std::os::raw::c_int,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test2() {
-    const UNINIT: ::std::mem::MaybeUninit<test2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<test2>(),
-        4usize,
-        concat!("Size of: ", stringify!(test2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(test2), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(test2),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct test3 {
-    pub a: ::std::os::raw::c_int,
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_test3() {
-    const UNINIT: ::std::mem::MaybeUninit<test3> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<test3>(),
-        4usize,
-        concat!("Size of: ", stringify!(test3))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<test3>(),
-        4usize,
-        concat!("Alignment of ", stringify!(test3))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(test3), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).zero_length_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(test3),
-            "::",
-            stringify!(zero_length_array)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).incomplete_array) as usize -
-                ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(test3),
-            "::",
-            stringify!(incomplete_array)
-        )
-    );
-}
diff --git a/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs b/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
deleted file mode 100644
index 57878592..00000000
--- a/tests/expectations/tests/libclang-9/error-E0600-cannot-apply-unary-negation-to-u32.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![allow(overflowing_literals)]
-
-pub const a: u32 = 4294967291;
diff --git a/tests/expectations/tests/libclang-9/incomplete-array-padding.rs b/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
deleted file mode 100644
index 1de963bf..00000000
--- a/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct foo {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl foo {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_char {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_char) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: ::std::os::raw::c_char,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs b/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
deleted file mode 100644
index ab402cfb..00000000
--- a/tests/expectations/tests/libclang-9/issue-643-inner-struct.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct rte_ring {
-    pub memzone: *mut rte_memzone,
-    pub prod: rte_ring_prod,
-    pub cons: rte_ring_cons,
-    pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_ring_prod {
-    pub watermark: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_rte_ring_prod() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ring_prod> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring_prod>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ring_prod))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring_prod>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ring_prod))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).watermark) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring_prod),
-            "::",
-            stringify!(watermark)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_ring_cons {
-    pub sc_dequeue: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_rte_ring_cons() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ring_cons> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring_cons>(),
-        4usize,
-        concat!("Size of: ", stringify!(rte_ring_cons))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring_cons>(),
-        4usize,
-        concat!("Alignment of ", stringify!(rte_ring_cons))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).sc_dequeue) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring_cons),
-            "::",
-            stringify!(sc_dequeue)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_rte_ring() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_ring> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_ring>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_ring))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_ring>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_ring))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).memzone) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring),
-            "::",
-            stringify!(memzone)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).prod) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring),
-            "::",
-            stringify!(prod)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cons) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring),
-            "::",
-            stringify!(cons)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ring) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ring),
-            "::",
-            stringify!(ring)
-        )
-    );
-}
-impl Default for rte_ring {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_memzone {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs b/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
deleted file mode 100644
index 60857966..00000000
--- a/tests/expectations/tests/libclang-9/issue-769-bad-instantiation-test.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct Rooted<T> {
-        pub member: T,
-        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    }
-    impl<T> Default for Rooted<T> {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-    pub type AutoValueVector_Alias = ::std::os::raw::c_int;
-    #[test]
-    fn __bindgen_test_layout_Rooted_open0_int_close0_instantiation() {
-        assert_eq!(
-            ::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>(),
-            4usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::Rooted<::std::os::raw::c_int>)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>(),
-            4usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::Rooted<::std::os::raw::c_int>)
-            )
-        );
-    }
-    #[test]
-    fn __bindgen_test_layout_Rooted_open0_AutoValueVector_Alias_close0_instantiation(
-    ) {
-        assert_eq!(
-            ::std::mem::size_of::<root::Rooted<root::AutoValueVector_Alias>>(),
-            4usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::Rooted<root::AutoValueVector_Alias>)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::Rooted<root::AutoValueVector_Alias>>(),
-            4usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::Rooted<root::AutoValueVector_Alias>)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/layout_align.rs b/tests/expectations/tests/libclang-9/layout_align.rs
deleted file mode 100644
index f6a32704..00000000
--- a/tests/expectations/tests/libclang-9/layout_align.rs
+++ /dev/null
@@ -1,318 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct rte_kni_fifo {
-    ///< Next position to be written
-    pub write: ::std::os::raw::c_uint,
-    ///< Next position to be read
-    pub read: ::std::os::raw::c_uint,
-    ///< Circular buffer length
-    pub len: ::std::os::raw::c_uint,
-    ///< Pointer size - for 32/64 bit OS
-    pub elem_size: ::std::os::raw::c_uint,
-    ///< The buffer contains mbuf pointers
-    pub buffer: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
-}
-#[test]
-fn bindgen_test_layout_rte_kni_fifo() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_kni_fifo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_kni_fifo>(),
-        16usize,
-        concat!("Size of: ", stringify!(rte_kni_fifo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_kni_fifo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_kni_fifo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_fifo),
-            "::",
-            stringify!(write)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_fifo),
-            "::",
-            stringify!(read)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_fifo),
-            "::",
-            stringify!(len)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).elem_size) as usize - ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_fifo),
-            "::",
-            stringify!(elem_size)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_kni_fifo),
-            "::",
-            stringify!(buffer)
-        )
-    );
-}
-impl Default for rte_kni_fifo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct rte_eth_link {
-    ///< ETH_SPEED_NUM_
-    pub link_speed: u32,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_rte_eth_link() {
-    const UNINIT: ::std::mem::MaybeUninit<rte_eth_link> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<rte_eth_link>(),
-        8usize,
-        concat!("Size of: ", stringify!(rte_eth_link))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<rte_eth_link>(),
-        8usize,
-        concat!("Alignment of ", stringify!(rte_eth_link))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).link_speed) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_eth_link),
-            "::",
-            stringify!(link_speed)
-        )
-    );
-}
-impl rte_eth_link {
-    #[inline]
-    pub fn link_duplex(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_duplex(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn link_autoneg(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_autoneg(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn link_status(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_status(&mut self, val: u16) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        link_duplex: u16,
-        link_autoneg: u16,
-        link_status: u16,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let link_duplex: u16 =
-                unsafe { ::std::mem::transmute(link_duplex) };
-            link_duplex as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let link_autoneg: u16 =
-                unsafe { ::std::mem::transmute(link_autoneg) };
-            link_autoneg as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let link_status: u16 =
-                unsafe { ::std::mem::transmute(link_status) };
-            link_status as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/mangling-win32.rs b/tests/expectations/tests/libclang-9/mangling-win32.rs
deleted file mode 100644
index 0aee3274..00000000
--- a/tests/expectations/tests/libclang-9/mangling-win32.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "fastcall" {
-    pub fn fast_call_func_no_args() -> ::std::os::raw::c_int;
-}
-extern "fastcall" {
-    pub fn fast_call_func_many_args(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-extern "stdcall" {
-    pub fn std_call_func_no_args() -> ::std::os::raw::c_int;
-}
-extern "stdcall" {
-    pub fn std_call_func_many_args(
-        arg1: ::std::os::raw::c_int,
-        arg2: ::std::os::raw::c_int,
-        arg3: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/libclang-9/objc_inheritance.rs b/tests/expectations/tests/libclang-9/objc_inheritance.rs
deleted file mode 100644
index f1c2a88c..00000000
--- a/tests/expectations/tests/libclang-9/objc_inheritance.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar(pub id);
-impl std::ops::Deref for Bar {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Bar {}
-impl Bar {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Bar), alloc) })
-    }
-}
-impl IFoo for Bar {}
-impl From<Bar> for Foo {
-    fn from(child: Bar) -> Foo {
-        Foo(child.0)
-    }
-}
-impl std::convert::TryFrom<Foo> for Bar {
-    type Error = &'static str;
-    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
-        if is_kind_of {
-            Ok(Bar(parent.0))
-        } else {
-            Err("This Foo cannot be downcasted to Bar")
-        }
-    }
-}
-impl IBar for Bar {}
-pub trait IBar: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Baz(pub id);
-impl std::ops::Deref for Baz {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Baz {}
-impl Baz {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Baz), alloc) })
-    }
-}
-impl IBar for Baz {}
-impl From<Baz> for Bar {
-    fn from(child: Baz) -> Bar {
-        Bar(child.0)
-    }
-}
-impl std::convert::TryFrom<Bar> for Baz {
-    type Error = &'static str;
-    fn try_from(parent: Bar) -> Result<Baz, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
-        if is_kind_of {
-            Ok(Baz(parent.0))
-        } else {
-            Err("This Bar cannot be downcasted to Baz")
-        }
-    }
-}
-impl IFoo for Baz {}
-impl From<Baz> for Foo {
-    fn from(child: Baz) -> Foo {
-        Foo(child.0)
-    }
-}
-impl std::convert::TryFrom<Foo> for Baz {
-    type Error = &'static str;
-    fn try_from(parent: Foo) -> Result<Baz, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Baz)) };
-        if is_kind_of {
-            Ok(Baz(parent.0))
-        } else {
-            Err("This Foo cannot be downcasted to Baz")
-        }
-    }
-}
-impl IBaz for Baz {}
-pub trait IBaz: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/libclang-9/objc_template.rs b/tests/expectations/tests/libclang-9/objc_template.rs
deleted file mode 100644
index 3c615035..00000000
--- a/tests/expectations/tests/libclang-9/objc_template.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl<ObjectType: 'static> IFoo<ObjectType> for Foo {}
-pub trait IFoo<ObjectType: 'static>: Sized + std::ops::Deref {
-    unsafe fn get(&self) -> u64
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, get)
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct FooMultiGeneric(pub id);
-impl std::ops::Deref for FooMultiGeneric {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for FooMultiGeneric {}
-impl FooMultiGeneric {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(FooMultiGeneric), alloc) })
-    }
-}
-impl<KeyType: 'static, ObjectType: 'static>
-    IFooMultiGeneric<KeyType, ObjectType> for FooMultiGeneric
-{
-}
-pub trait IFooMultiGeneric<KeyType: 'static, ObjectType: 'static>:
-    Sized + std::ops::Deref
-{
-    unsafe fn objectForKey_(&self, key: u64) -> u64
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, objectForKey: key)
-    }
-}
diff --git a/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs b/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
deleted file mode 100644
index e62ea681..00000000
--- a/tests/expectations/tests/libclang-9/partial-specialization-and-inheritance.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Base {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Derived {
-    pub b: bool,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Usage {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN5Usage13static_memberE"]
-    pub static mut Usage_static_member: [u32; 2usize];
-}
-#[test]
-fn bindgen_test_layout_Usage() {
-    assert_eq!(
-        ::std::mem::size_of::<Usage>(),
-        1usize,
-        concat!("Size of: ", stringify!(Usage))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Usage>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Usage))
-    );
-}
diff --git a/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs b/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
deleted file mode 100644
index 19f8881d..00000000
--- a/tests/expectations/tests/libclang-9/type_alias_template_specialized.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted {
-    pub ptr: MaybeWrapped<::std::os::raw::c_int>,
-}
-#[test]
-fn bindgen_test_layout_Rooted() {
-    const UNINIT: ::std::mem::MaybeUninit<Rooted> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Rooted>(),
-        4usize,
-        concat!("Size of: ", stringify!(Rooted))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Rooted>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Rooted))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Rooted),
-            "::",
-            stringify!(ptr)
-        )
-    );
-}
-impl Default for Rooted {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// <div rustbindgen replaces="MaybeWrapped"></div>
-pub type MaybeWrapped<a> = a;
-#[test]
-fn __bindgen_test_layout_MaybeWrapped_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<MaybeWrapped<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(MaybeWrapped<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MaybeWrapped<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(MaybeWrapped<::std::os::raw::c_int>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/libclang-9/zero-sized-array.rs b/tests/expectations/tests/libclang-9/zero-sized-array.rs
deleted file mode 100644
index 3066fac4..00000000
--- a/tests/expectations/tests/libclang-9/zero-sized-array.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-/// Bizarrely enough, this should *not* get an `_address` field.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ZeroSizedArray {
-    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_ZeroSizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<ZeroSizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ZeroSizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ZeroSizedArray),
-            "::",
-            stringify!(arr)
-        )
-    );
-}
-/// And nor should this get an `_address` field.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ContainsZeroSizedArray {
-    pub zsa: ZeroSizedArray,
-}
-#[test]
-fn bindgen_test_layout_ContainsZeroSizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsZeroSizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ContainsZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ContainsZeroSizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).zsa) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsZeroSizedArray),
-            "::",
-            stringify!(zsa)
-        )
-    );
-}
-/// Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
-/// either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct InheritsZeroSizedArray {
-    pub _base: ZeroSizedArray,
-}
-#[test]
-fn bindgen_test_layout_InheritsZeroSizedArray() {
-    assert_eq!(
-        ::std::mem::size_of::<InheritsZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(InheritsZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(InheritsZeroSizedArray))
-    );
-}
-/// And this should not get an `_address` field either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct DynamicallySizedArray {
-    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DynamicallySizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<DynamicallySizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<DynamicallySizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(DynamicallySizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DynamicallySizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(DynamicallySizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(DynamicallySizedArray),
-            "::",
-            stringify!(arr)
-        )
-    );
-}
-/// No `_address` field here either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ContainsDynamicallySizedArray {
-    pub dsa: DynamicallySizedArray,
-}
-#[test]
-fn bindgen_test_layout_ContainsDynamicallySizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsDynamicallySizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsDynamicallySizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ContainsDynamicallySizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsDynamicallySizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ContainsDynamicallySizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).dsa) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsDynamicallySizedArray),
-            "::",
-            stringify!(dsa)
-        )
-    );
-}
diff --git a/tests/expectations/tests/libclang_version_specific_generated_tests.rs b/tests/expectations/tests/libclang_version_specific_generated_tests.rs
deleted file mode 100644
index 2643709c..00000000
--- a/tests/expectations/tests/libclang_version_specific_generated_tests.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-include!(concat!(
-    env!("OUT_DIR"),
-    "/libclang_version_specific_generated_tests.rs"
-));
diff --git a/tests/expectations/tests/long_double.rs b/tests/expectations/tests/long_double.rs
deleted file mode 100644
index 2c3b6c93..00000000
--- a/tests/expectations/tests/long_double.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {
-    pub bar: u128,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        16usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/macro-expr-basic.rs b/tests/expectations/tests/macro-expr-basic.rs
deleted file mode 100644
index 4eeb310c..00000000
--- a/tests/expectations/tests/macro-expr-basic.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const FOO: u32 = 1;
-pub const BAR: u32 = 4;
-pub const BAZ: u32 = 5;
-pub const MIN: i64 = -9223372036854775808;
-pub const BARR: u32 = 1;
-pub const BAZZ: u32 = 7;
-pub const I_RAN_OUT_OF_DUMB_NAMES: u32 = 7;
-pub const HAZ_A_COMMENT: u32 = 1;
-pub const HAZ_A_COMMENT_INSIDE: u32 = 2;
diff --git a/tests/expectations/tests/macro-expr-uncommon-token.rs b/tests/expectations/tests/macro-expr-uncommon-token.rs
deleted file mode 100644
index b2f2ebd2..00000000
--- a/tests/expectations/tests/macro-expr-uncommon-token.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const MODBUS_WOOT: u32 = 3;
-extern "C" {
-    pub fn foo();
-}
diff --git a/tests/expectations/tests/macro-redef.rs b/tests/expectations/tests/macro-redef.rs
deleted file mode 100644
index ff5654f4..00000000
--- a/tests/expectations/tests/macro-redef.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const FOO: u32 = 4;
-pub const BAR: u32 = 5;
-pub const BAZ: u32 = 6;
diff --git a/tests/expectations/tests/macro_const.rs b/tests/expectations/tests/macro_const.rs
deleted file mode 100644
index de423a2a..00000000
--- a/tests/expectations/tests/macro_const.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const foo: &[u8; 4usize] = b"bar\0";
-pub const CHAR: u8 = 98u8;
-pub const CHARR: u8 = 0u8;
-pub const FLOAT: f64 = 5.09;
-pub const FLOAT_EXPR: f64 = 0.005;
-pub const LONG: u32 = 3;
-pub const INVALID_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/tests/expectations/tests/macro_const_1_0.rs b/tests/expectations/tests/macro_const_1_0.rs
deleted file mode 100644
index e1356611..00000000
--- a/tests/expectations/tests/macro_const_1_0.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const foo: &'static [u8; 4usize] = b"bar\0";
-pub const CHAR: u8 = 98u8;
-pub const CHARR: u8 = 0u8;
-pub const FLOAT: f64 = 5.09;
-pub const FLOAT_EXPR: f64 = 0.005;
-pub const LONG: u32 = 3;
-pub const INVALID_UTF8: [u8; 5usize] = [240u8, 40u8, 140u8, 40u8, 0u8];
diff --git a/tests/expectations/tests/maddness-is-avoidable.rs b/tests/expectations/tests/maddness-is-avoidable.rs
deleted file mode 100644
index 12157f4b..00000000
--- a/tests/expectations/tests/maddness-is-avoidable.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct RefPtr {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct RefPtr_Proxy {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/mangling-ios.rs b/tests/expectations/tests/mangling-ios.rs
deleted file mode 100644
index 8a4ff657..00000000
--- a/tests/expectations/tests/mangling-ios.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
diff --git a/tests/expectations/tests/mangling-linux32.rs b/tests/expectations/tests/mangling-linux32.rs
deleted file mode 100644
index bddd7617..00000000
--- a/tests/expectations/tests/mangling-linux32.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo4sBarE"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/mangling-linux64.rs b/tests/expectations/tests/mangling-linux64.rs
deleted file mode 100644
index bddd7617..00000000
--- a/tests/expectations/tests/mangling-linux64.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo4sBarE"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/mangling-macos.rs b/tests/expectations/tests/mangling-macos.rs
deleted file mode 100644
index 9af36259..00000000
--- a/tests/expectations/tests/mangling-macos.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}__ZN3Foo4sBarE"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/mangling-win64.rs b/tests/expectations/tests/mangling-win64.rs
deleted file mode 100644
index cb5f7103..00000000
--- a/tests/expectations/tests/mangling-win64.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}?sBar@Foo@@2_NA"]
-    pub static mut Foo_sBar: bool;
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
diff --git a/tests/expectations/tests/merge-extern-blocks.rs b/tests/expectations/tests/merge-extern-blocks.rs
deleted file mode 100644
index 66ceeff0..00000000
--- a/tests/expectations/tests/merge-extern-blocks.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Point {
-    pub x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Point() {
-    const UNINIT: ::std::mem::MaybeUninit<Point> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Point>(),
-        4usize,
-        concat!("Size of: ", stringify!(Point))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Point>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Point))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
-    );
-}
-extern "C" {
-    pub fn foo() -> ::std::os::raw::c_int;
-    pub fn bar() -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/method-mangling.rs b/tests/expectations/tests/method-mangling.rs
deleted file mode 100644
index e4627ac8..00000000
--- a/tests/expectations/tests/method-mangling.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Foo4typeEv"]
-    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_int {
-        Foo_type(self)
-    }
-}
diff --git a/tests/expectations/tests/module-allowlisted.rs b/tests/expectations/tests/module-allowlisted.rs
deleted file mode 100644
index 30cdb358..00000000
--- a/tests/expectations/tests/module-allowlisted.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct Test {
-        pub _address: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_Test() {
-        assert_eq!(
-            ::std::mem::size_of::<Test>(),
-            1usize,
-            concat!("Size of: ", stringify!(Test))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<Test>(),
-            1usize,
-            concat!("Alignment of ", stringify!(Test))
-        );
-    }
-}
diff --git a/tests/expectations/tests/msvc-no-usr.rs b/tests/expectations/tests/msvc-no-usr.rs
deleted file mode 100644
index 64db43a6..00000000
--- a/tests/expectations/tests/msvc-no-usr.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub foo: usize,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        8usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        8usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(foo))
-    );
-}
diff --git a/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs b/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
deleted file mode 100644
index 55b3d1e3..00000000
--- a/tests/expectations/tests/multiple-inherit-empty-correct-layout.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Baz {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        1usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-}
diff --git a/tests/expectations/tests/mutable.rs b/tests/expectations/tests/mutable.rs
deleted file mode 100644
index 94c70326..00000000
--- a/tests/expectations/tests/mutable.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub m_member: ::std::os::raw::c_int,
-    pub m_other: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        8usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(m_member)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m_other) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(m_other)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct NonCopiable {
-    pub m_member: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NonCopiable() {
-    const UNINIT: ::std::mem::MaybeUninit<NonCopiable> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NonCopiable>(),
-        4usize,
-        concat!("Size of: ", stringify!(NonCopiable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NonCopiable>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NonCopiable))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NonCopiable),
-            "::",
-            stringify!(m_member)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct NonCopiableWithNonCopiableMutableMember {
-    pub m_member: NonCopiable,
-}
-#[test]
-fn bindgen_test_layout_NonCopiableWithNonCopiableMutableMember() {
-    const UNINIT: ::std::mem::MaybeUninit<
-        NonCopiableWithNonCopiableMutableMember,
-    > = ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NonCopiableWithNonCopiableMutableMember>(),
-        4usize,
-        concat!(
-            "Size of: ",
-            stringify!(NonCopiableWithNonCopiableMutableMember)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NonCopiableWithNonCopiableMutableMember>(),
-        4usize,
-        concat!(
-            "Alignment of ",
-            stringify!(NonCopiableWithNonCopiableMutableMember)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).m_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NonCopiableWithNonCopiableMutableMember),
-            "::",
-            stringify!(m_member)
-        )
-    );
-}
diff --git a/tests/expectations/tests/namespace.rs b/tests/expectations/tests/namespace.rs
deleted file mode 100644
index 49c8a7ef..00000000
--- a/tests/expectations/tests/namespace.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    extern "C" {
-        #[link_name = "\u{1}_Z9top_levelv"]
-        pub fn top_level();
-    }
-    pub mod whatever {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub type whatever_other_thing_t = whatever_int_t;
-        pub type whatever_int_t = ::std::os::raw::c_int;
-        extern "C" {
-            #[link_name = "\u{1}_ZN8whatever11in_whateverEv"]
-            pub fn in_whatever();
-        }
-    }
-    pub mod _bindgen_mod_id_17 {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct A {
-            pub b: root::whatever::whatever_int_t,
-        }
-        #[test]
-        fn bindgen_test_layout_A() {
-            const UNINIT: ::std::mem::MaybeUninit<A> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<A>(),
-                4usize,
-                concat!("Size of: ", stringify!(A))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<A>(),
-                4usize,
-                concat!("Alignment of ", stringify!(A))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(A),
-                    "::",
-                    stringify!(b)
-                )
-            );
-        }
-    }
-    #[repr(C)]
-    #[derive(Debug)]
-    pub struct C<T> {
-        pub _base: root::_bindgen_mod_id_17::A,
-        pub m_c: T,
-        pub m_c_ptr: *mut T,
-        pub m_c_arr: [T; 10usize],
-        pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    }
-    impl<T> Default for C<T> {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-    pub mod w {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub type whatever_int_t = ::std::os::raw::c_uint;
-        #[repr(C)]
-        #[derive(Debug)]
-        pub struct D<T> {
-            pub m_c: root::C<T>,
-            pub _phantom_0:
-                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-        }
-        impl<T> Default for D<T> {
-            fn default() -> Self {
-                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                unsafe {
-                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                    s.assume_init()
-                }
-            }
-        }
-        extern "C" {
-            #[link_name = "\u{1}_ZN1w3hehEv"]
-            pub fn heh() -> root::w::whatever_int_t;
-        }
-        extern "C" {
-            #[link_name = "\u{1}_ZN1w3fooEv"]
-            pub fn foo() -> root::C<::std::os::raw::c_int>;
-        }
-        extern "C" {
-            #[link_name = "\u{1}_ZN1w4barrEv"]
-            pub fn barr() -> root::C<f32>;
-        }
-    }
-    pub mod foobar {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        extern "C" {
-            #[link_name = "\u{1}_ZN6foobar3fooEv"]
-            pub fn foo();
-        }
-    }
-    pub mod faraway {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        extern "C" {
-            #[link_name = "\u{1}_ZN7faraway3barEv"]
-            pub fn bar();
-        }
-    }
-}
diff --git a/tests/expectations/tests/nested-template-typedef.rs b/tests/expectations/tests/nested-template-typedef.rs
deleted file mode 100644
index ab761d28..00000000
--- a/tests/expectations/tests/nested-template-typedef.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo_Bar {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/nested.rs b/tests/expectations/tests/nested.rs
deleted file mode 100644
index 415a7405..00000000
--- a/tests/expectations/tests/nested.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Calc {
-    pub w: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Calc() {
-    const UNINIT: ::std::mem::MaybeUninit<Calc> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Calc>(),
-        4usize,
-        concat!("Size of: ", stringify!(Calc))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Calc>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Calc))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Calc), "::", stringify!(w))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test_Size {
-    pub mWidth: Test_Size_Dimension,
-    pub mHeight: Test_Size_Dimension,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test_Size_Dimension {
-    pub _base: Calc,
-}
-#[test]
-fn bindgen_test_layout_Test_Size_Dimension() {
-    assert_eq!(
-        ::std::mem::size_of::<Test_Size_Dimension>(),
-        4usize,
-        concat!("Size of: ", stringify!(Test_Size_Dimension))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test_Size_Dimension>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Test_Size_Dimension))
-    );
-}
-#[test]
-fn bindgen_test_layout_Test_Size() {
-    const UNINIT: ::std::mem::MaybeUninit<Test_Size> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test_Size>(),
-        8usize,
-        concat!("Size of: ", stringify!(Test_Size))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test_Size>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Test_Size))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mWidth) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Test_Size),
-            "::",
-            stringify!(mWidth)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mHeight) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Test_Size),
-            "::",
-            stringify!(mHeight)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        1usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-}
diff --git a/tests/expectations/tests/nested_vtable.rs b/tests/expectations/tests/nested_vtable.rs
deleted file mode 100644
index 7ee48304..00000000
--- a/tests/expectations/tests/nested_vtable.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct nsISupports__bindgen_vtable {
-    pub nsISupports_QueryInterface:
-        unsafe extern "C" fn(this: *mut nsISupports) -> *mut nsISupports,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsISupports {
-    pub vtable_: *const nsISupports__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_nsISupports() {
-    assert_eq!(
-        ::std::mem::size_of::<nsISupports>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsISupports))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsISupports>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsISupports))
-    );
-}
-impl Default for nsISupports {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN11nsISupports14QueryInterfaceEv"]
-    pub fn nsISupports_QueryInterface(
-        this: *mut ::std::os::raw::c_void,
-    ) -> *mut nsISupports;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsIRunnable {
-    pub _base: nsISupports,
-}
-#[test]
-fn bindgen_test_layout_nsIRunnable() {
-    assert_eq!(
-        ::std::mem::size_of::<nsIRunnable>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsIRunnable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsIRunnable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsIRunnable))
-    );
-}
-impl Default for nsIRunnable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Runnable {
-    pub _base: nsIRunnable,
-}
-#[test]
-fn bindgen_test_layout_Runnable() {
-    assert_eq!(
-        ::std::mem::size_of::<Runnable>(),
-        8usize,
-        concat!("Size of: ", stringify!(Runnable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Runnable>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Runnable))
-    );
-}
-impl Default for Runnable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/nested_within_namespace.rs b/tests/expectations/tests/nested_within_namespace.rs
deleted file mode 100644
index 629c449a..00000000
--- a/tests/expectations/tests/nested_within_namespace.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Bar {
-            pub foo: ::std::os::raw::c_int,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Bar_Baz {
-            pub foo: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_Bar_Baz() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar_Baz> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar_Baz>(),
-                4usize,
-                concat!("Size of: ", stringify!(Bar_Baz))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar_Baz>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar_Baz))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar_Baz),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-        }
-        #[test]
-        fn bindgen_test_layout_Bar() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar>(),
-                4usize,
-                concat!("Size of: ", stringify!(Bar))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Baz {
-            pub baz: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_Baz() {
-            const UNINIT: ::std::mem::MaybeUninit<Baz> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Baz>(),
-                4usize,
-                concat!("Size of: ", stringify!(Baz))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Baz>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Baz))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Baz),
-                    "::",
-                    stringify!(baz)
-                )
-            );
-        }
-    }
-}
diff --git a/tests/expectations/tests/newtype-enum.rs b/tests/expectations/tests/newtype-enum.rs
deleted file mode 100644
index 26a4eb1f..00000000
--- a/tests/expectations/tests/newtype-enum.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl Foo {
-    pub const Bar: Foo = Foo(2);
-}
-impl Foo {
-    pub const Baz: Foo = Foo(4);
-}
-impl Foo {
-    pub const Duplicated: Foo = Foo(4);
-}
-impl Foo {
-    pub const Negative: Foo = Foo(-3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/tests/expectations/tests/newtype-global-enum.rs b/tests/expectations/tests/newtype-global-enum.rs
deleted file mode 100644
index cf23cca6..00000000
--- a/tests/expectations/tests/newtype-global-enum.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const Foo_Bar: Foo = Foo(2);
-pub const Foo_Baz: Foo = Foo(4);
-pub const Foo_Duplicated: Foo = Foo(4);
-pub const Foo_Negative: Foo = Foo(-3);
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo(pub ::std::os::raw::c_int);
diff --git a/tests/expectations/tests/no-comments.rs b/tests/expectations/tests/no-comments.rs
deleted file mode 100644
index a375d8ea..00000000
--- a/tests/expectations/tests/no-comments.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub s: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(s))
-    );
-}
diff --git a/tests/expectations/tests/no-derive-debug.rs b/tests/expectations/tests/no-derive-debug.rs
deleted file mode 100644
index c7a6d184..00000000
--- a/tests/expectations/tests/no-derive-debug.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Default)]
-pub struct foo {
-    bar: ::std::os::raw::c_int,
-}
-
-/// bar should compile. It will normally derive debug, but our blocklist of foo
-/// and replacement for another type that doesn't implement it would prevent it
-/// from building if --no-derive-debug didn't work.
-#[repr(C)]
-pub struct bar {
-    pub foo: foo,
-    pub baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(bar), "::", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(bar), "::", stringify!(baz))
-    );
-}
-impl Default for bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/no-derive-default.rs b/tests/expectations/tests/no-derive-default.rs
deleted file mode 100644
index 46b2cb4e..00000000
--- a/tests/expectations/tests/no-derive-default.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct foo {
-    bar: ::std::os::raw::c_int,
-}
-
-/// bar should compile. It will normally derive default, but our blocklist of foo
-/// and replacement for another type that doesn't implement it would prevent it
-/// from building if --no-derive-default didn't work.
-#[repr(C)]
-pub struct bar {
-    pub foo: foo,
-    pub baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_bar() {
-    const UNINIT: ::std::mem::MaybeUninit<bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(bar), "::", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(bar), "::", stringify!(baz))
-    );
-}
diff --git a/tests/expectations/tests/no-hash-allowlisted.rs b/tests/expectations/tests/no-hash-allowlisted.rs
deleted file mode 100644
index 549b72b5..00000000
--- a/tests/expectations/tests/no-hash-allowlisted.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoHash {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NoHash() {
-    const UNINIT: ::std::mem::MaybeUninit<NoHash> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoHash>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoHash))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoHash>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoHash))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(NoHash), "::", stringify!(i))
-    );
-}
diff --git a/tests/expectations/tests/no-hash-opaque.rs b/tests/expectations/tests/no-hash-opaque.rs
deleted file mode 100644
index 49ff4daa..00000000
--- a/tests/expectations/tests/no-hash-opaque.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoHash {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_NoHash() {
-    assert_eq!(
-        ::std::mem::size_of::<NoHash>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoHash))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoHash>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoHash))
-    );
-}
diff --git a/tests/expectations/tests/no-partialeq-allowlisted.rs b/tests/expectations/tests/no-partialeq-allowlisted.rs
deleted file mode 100644
index c7895fe6..00000000
--- a/tests/expectations/tests/no-partialeq-allowlisted.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoPartialEq {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NoPartialEq() {
-    const UNINIT: ::std::mem::MaybeUninit<NoPartialEq> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoPartialEq>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoPartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoPartialEq>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoPartialEq))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NoPartialEq),
-            "::",
-            stringify!(i)
-        )
-    );
-}
diff --git a/tests/expectations/tests/no-partialeq-opaque.rs b/tests/expectations/tests/no-partialeq-opaque.rs
deleted file mode 100644
index 423799a6..00000000
--- a/tests/expectations/tests/no-partialeq-opaque.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct NoPartialEq {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_NoPartialEq() {
-    assert_eq!(
-        ::std::mem::size_of::<NoPartialEq>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoPartialEq))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoPartialEq>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoPartialEq))
-    );
-}
diff --git a/tests/expectations/tests/no-recursive-allowlisting.rs b/tests/expectations/tests/no-recursive-allowlisting.rs
deleted file mode 100644
index 6f1e19ba..00000000
--- a/tests/expectations/tests/no-recursive-allowlisting.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub enum Bar {}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo {
-    pub baz: *mut Bar,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    const UNINIT: ::std::mem::MaybeUninit<Foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Foo), "::", stringify!(baz))
-    );
-}
-impl Default for Foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/no-std.rs b/tests/expectations/tests/no-std.rs
deleted file mode 100644
index 457242c2..00000000
--- a/tests/expectations/tests/no-std.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![no_std]
-mod libc {
-    pub type c_int = i32;
-    pub enum c_void {}
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct foo {
-    pub a: libc::c_int,
-    pub b: libc::c_int,
-    pub bar: *mut libc::c_void,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::core::mem::MaybeUninit<foo> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/no_copy.rs b/tests/expectations/tests/no_copy.rs
deleted file mode 100644
index daccf757..00000000
--- a/tests/expectations/tests/no_copy.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen nocopy></div>
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct CopiableButWait {
-    pub whatever: ::std::os::raw::c_int,
-}
diff --git a/tests/expectations/tests/no_copy_allowlisted.rs b/tests/expectations/tests/no_copy_allowlisted.rs
deleted file mode 100644
index 1c46de75..00000000
--- a/tests/expectations/tests/no_copy_allowlisted.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct NoCopy {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NoCopy() {
-    const UNINIT: ::std::mem::MaybeUninit<NoCopy> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoCopy>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoCopy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoCopy>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoCopy))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(NoCopy), "::", stringify!(i))
-    );
-}
diff --git a/tests/expectations/tests/no_copy_opaque.rs b/tests/expectations/tests/no_copy_opaque.rs
deleted file mode 100644
index 7fc3529f..00000000
--- a/tests/expectations/tests/no_copy_opaque.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default)]
-pub struct NoCopy {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_NoCopy() {
-    assert_eq!(
-        ::std::mem::size_of::<NoCopy>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoCopy))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoCopy>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoCopy))
-    );
-}
diff --git a/tests/expectations/tests/no_debug.rs b/tests/expectations/tests/no_debug.rs
deleted file mode 100644
index 21850ecb..00000000
--- a/tests/expectations/tests/no_debug.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen nodebug></div>
-#[repr(C)]
-#[derive(Default, Copy, Clone)]
-pub struct DebugButWait {
-    pub whatever: ::std::os::raw::c_int,
-}
diff --git a/tests/expectations/tests/no_debug_allowlisted.rs b/tests/expectations/tests/no_debug_allowlisted.rs
deleted file mode 100644
index 859dad8c..00000000
--- a/tests/expectations/tests/no_debug_allowlisted.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default, Copy, Clone)]
-pub struct NoDebug {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NoDebug() {
-    const UNINIT: ::std::mem::MaybeUninit<NoDebug> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoDebug>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoDebug))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoDebug>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoDebug))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NoDebug),
-            "::",
-            stringify!(i)
-        )
-    );
-}
diff --git a/tests/expectations/tests/no_debug_bypass_impl_debug.rs b/tests/expectations/tests/no_debug_bypass_impl_debug.rs
deleted file mode 100644
index 334f39dd..00000000
--- a/tests/expectations/tests/no_debug_bypass_impl_debug.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Generic<T> {
-    pub t: [T; 40usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Generic<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> ::std::fmt::Debug for Generic<T> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        write!(f, "Generic {{ t: Array with length 40 }}")
-    }
-}
-#[repr(C)]
-pub struct NoDebug<T> {
-    pub t: [T; 40usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for NoDebug<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/no_debug_opaque.rs b/tests/expectations/tests/no_debug_opaque.rs
deleted file mode 100644
index 4b657481..00000000
--- a/tests/expectations/tests/no_debug_opaque.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Default, Copy, Clone)]
-pub struct NoDebug {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_NoDebug() {
-    assert_eq!(
-        ::std::mem::size_of::<NoDebug>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoDebug))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoDebug>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoDebug))
-    );
-}
diff --git a/tests/expectations/tests/no_default.rs b/tests/expectations/tests/no_default.rs
deleted file mode 100644
index 22fdbf36..00000000
--- a/tests/expectations/tests/no_default.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen nodefault></div>
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DefaultButWait {
-    pub whatever: ::std::os::raw::c_int,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DefaultButWaitDerived {
-    pub whatever: DefaultButWait,
-}
-impl Default for DefaultButWaitDerived {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/no_default_allowlisted.rs b/tests/expectations/tests/no_default_allowlisted.rs
deleted file mode 100644
index c4deceb4..00000000
--- a/tests/expectations/tests/no_default_allowlisted.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct NoDefault {
-    pub i: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NoDefault() {
-    const UNINIT: ::std::mem::MaybeUninit<NoDefault> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NoDefault>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoDefault))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoDefault>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoDefault))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NoDefault),
-            "::",
-            stringify!(i)
-        )
-    );
-}
diff --git a/tests/expectations/tests/no_default_bypass_derive_default.rs b/tests/expectations/tests/no_default_bypass_derive_default.rs
deleted file mode 100644
index 6c44a9dd..00000000
--- a/tests/expectations/tests/no_default_bypass_derive_default.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Generic<T> {
-    pub t: [T; 40usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Generic<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct NoDefault<T> {
-    pub t: [T; 40usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
diff --git a/tests/expectations/tests/no_default_opaque.rs b/tests/expectations/tests/no_default_opaque.rs
deleted file mode 100644
index 3c928551..00000000
--- a/tests/expectations/tests/no_default_opaque.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Copy, Clone)]
-pub struct NoDefault {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_NoDefault() {
-    assert_eq!(
-        ::std::mem::size_of::<NoDefault>(),
-        4usize,
-        concat!("Size of: ", stringify!(NoDefault))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NoDefault>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NoDefault))
-    );
-}
diff --git a/tests/expectations/tests/no_size_t_is_usize.rs b/tests/expectations/tests/no_size_t_is_usize.rs
deleted file mode 100644
index f399a667..00000000
--- a/tests/expectations/tests/no_size_t_is_usize.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type size_t = ::std::os::raw::c_ulong;
-pub type ssize_t = ::std::os::raw::c_long;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct A {
-    pub len: size_t,
-    pub offset: ssize_t,
-    pub next: *mut A,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        24usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        8usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(len))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(offset))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
-        16usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(next))
-    );
-}
-impl Default for A {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/non-type-params.rs b/tests/expectations/tests/non-type-params.rs
deleted file mode 100644
index 2b38e216..00000000
--- a/tests/expectations/tests/non-type-params.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type Array16 = u8;
-pub type ArrayInt4 = [u32; 4usize];
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct UsesArray {
-    pub array_char_16: [u8; 16usize],
-    pub array_bool_8: [u8; 8usize],
-    pub array_int_4: ArrayInt4,
-}
-#[test]
-fn bindgen_test_layout_UsesArray() {
-    const UNINIT: ::std::mem::MaybeUninit<UsesArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<UsesArray>(),
-        40usize,
-        concat!("Size of: ", stringify!(UsesArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<UsesArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(UsesArray))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).array_char_16) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UsesArray),
-            "::",
-            stringify!(array_char_16)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).array_bool_8) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UsesArray),
-            "::",
-            stringify!(array_bool_8)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).array_int_4) as usize - ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UsesArray),
-            "::",
-            stringify!(array_int_4)
-        )
-    );
-}
diff --git a/tests/expectations/tests/noreturn.rs b/tests/expectations/tests/noreturn.rs
deleted file mode 100644
index 19457495..00000000
--- a/tests/expectations/tests/noreturn.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z1fv"]
-     pub fn f() -> !;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z1gv"]
-     pub fn g() -> !;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z1hv"]
-    pub fn h() -> !;
-}
diff --git a/tests/expectations/tests/nsBaseHashtable.rs b/tests/expectations/tests/nsBaseHashtable.rs
deleted file mode 100644
index 26179b76..00000000
--- a/tests/expectations/tests/nsBaseHashtable.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct nsBaseHashtableET {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct nsTHashtable {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsBaseHashtable {
-    pub _address: u8,
-}
-pub type nsBaseHashtable_KeyType = [u8; 0usize];
-pub type nsBaseHashtable_EntryType = nsBaseHashtableET;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsBaseHashtable_LookupResult {
-    pub mEntry: *mut nsBaseHashtable_EntryType,
-    pub mTable: *mut nsBaseHashtable,
-}
-impl Default for nsBaseHashtable_LookupResult {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug)]
-pub struct nsBaseHashtable_EntryPtr {
-    pub mEntry: *mut nsBaseHashtable_EntryType,
-    pub mExistingEntry: bool,
-}
-impl Default for nsBaseHashtable_EntryPtr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for nsBaseHashtable {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/nsStyleAutoArray.rs b/tests/expectations/tests/nsStyleAutoArray.rs
deleted file mode 100644
index fab18c1c..00000000
--- a/tests/expectations/tests/nsStyleAutoArray.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsTArray<T> {
-    pub mBuff: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for nsTArray<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsStyleAutoArray<T> {
-    pub mFirstElement: T,
-    pub mOtherElements: nsTArray<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum nsStyleAutoArray_WithSingleInitialElement {
-    WITH_SINGLE_INITIAL_ELEMENT = 0,
-}
-impl<T> Default for nsStyleAutoArray<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/objc_allowlist.rs b/tests/expectations/tests/objc_allowlist.rs
deleted file mode 100644
index 370cab93..00000000
--- a/tests/expectations/tests/objc_allowlist.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-pub trait PSomeProtocol: Sized + std::ops::Deref {
-    unsafe fn protocolMethod(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, protocolMethod)
-    }
-    unsafe fn protocolClassMethod()
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(SomeProtocol), protocolClassMethod)
-    }
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct AllowlistMe(pub id);
-impl std::ops::Deref for AllowlistMe {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for AllowlistMe {}
-impl AllowlistMe {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(AllowlistMe), alloc) })
-    }
-}
-impl PSomeProtocol for AllowlistMe {}
-impl IAllowlistMe for AllowlistMe {}
-pub trait IAllowlistMe: Sized + std::ops::Deref {
-    unsafe fn method(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, method)
-    }
-    unsafe fn classMethod()
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(AllowlistMe), classMethod)
-    }
-}
-impl AllowlistMe_InterestingCategory for AllowlistMe {}
-pub trait AllowlistMe_InterestingCategory: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/objc_blocklist.rs b/tests/expectations/tests/objc_blocklist.rs
deleted file mode 100644
index 7d5d19b0..00000000
--- a/tests/expectations/tests/objc_blocklist.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-#[macro_use]
-extern crate objc;
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct SomeClass(pub id);
-impl std::ops::Deref for SomeClass {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for SomeClass {}
-impl SomeClass {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(SomeClass), alloc) })
-    }
-}
-impl ISomeClass for SomeClass {}
-pub trait ISomeClass: Sized + std::ops::Deref {
-    unsafe fn ambiguouslyBlockedMethod(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, ambiguouslyBlockedMethod)
-    }
-    unsafe fn instanceMethod(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, instanceMethod)
-    }
-}
diff --git a/tests/expectations/tests/objc_category.rs b/tests/expectations/tests/objc_category.rs
deleted file mode 100644
index 9d60233b..00000000
--- a/tests/expectations/tests/objc_category.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, method)
-    }
-}
-impl Foo_BarCategory for Foo {}
-pub trait Foo_BarCategory: Sized + std::ops::Deref {
-    unsafe fn categoryMethod(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, categoryMethod)
-    }
-}
diff --git a/tests/expectations/tests/objc_class.rs b/tests/expectations/tests/objc_class.rs
deleted file mode 100644
index b322bddc..00000000
--- a/tests/expectations/tests/objc_class.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-extern "C" {
-    pub static mut fooVar: Foo;
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, method)
-    }
-}
diff --git a/tests/expectations/tests/objc_class_method.rs b/tests/expectations/tests/objc_class_method.rs
deleted file mode 100644
index 29e70256..00000000
--- a/tests/expectations/tests/objc_class_method.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method()
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), method)
-    }
-    unsafe fn methodWithInt_(foo: ::std::os::raw::c_int)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), methodWithInt: foo)
-    }
-    unsafe fn methodWithFoo_(foo: Foo)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), methodWithFoo: foo)
-    }
-    unsafe fn methodReturningInt() -> ::std::os::raw::c_int
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), methodReturningInt)
-    }
-    unsafe fn methodReturningFoo() -> Foo
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), methodReturningFoo)
-    }
-    unsafe fn methodWithArg1_andArg2_andArg3_(
-        intvalue: ::std::os::raw::c_int,
-        ptr: *mut ::std::os::raw::c_char,
-        floatvalue: f32,
-    ) where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send ! (class ! (Foo) , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue)
-    }
-}
diff --git a/tests/expectations/tests/objc_interface.rs b/tests/expectations/tests/objc_interface.rs
deleted file mode 100644
index 89e64d86..00000000
--- a/tests/expectations/tests/objc_interface.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
-pub trait Pbar: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/objc_interface_type.rs b/tests/expectations/tests/objc_interface_type.rs
deleted file mode 100644
index 423ba910..00000000
--- a/tests/expectations/tests/objc_interface_type.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct FooStruct {
-    pub foo: Foo,
-}
-#[test]
-fn bindgen_test_layout_FooStruct() {
-    const UNINIT: ::std::mem::MaybeUninit<FooStruct> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<FooStruct>(),
-        8usize,
-        concat!("Size of: ", stringify!(FooStruct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<FooStruct>(),
-        8usize,
-        concat!("Alignment of ", stringify!(FooStruct))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(FooStruct),
-            "::",
-            stringify!(foo)
-        )
-    );
-}
-impl Default for FooStruct {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    pub fn fooFunc(foo: Foo);
-}
-extern "C" {
-    pub static mut kFoo: Foo;
-}
diff --git a/tests/expectations/tests/objc_method.rs b/tests/expectations/tests/objc_method.rs
deleted file mode 100644
index 593fd277..00000000
--- a/tests/expectations/tests/objc_method.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn method(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, method)
-    }
-    unsafe fn methodWithInt_(&self, foo: ::std::os::raw::c_int)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, methodWithInt: foo)
-    }
-    unsafe fn methodWithFoo_(&self, foo: Foo)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, methodWithFoo: foo)
-    }
-    unsafe fn methodReturningInt(&self) -> ::std::os::raw::c_int
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, methodReturningInt)
-    }
-    unsafe fn methodReturningFoo(&self) -> Foo
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, methodReturningFoo)
-    }
-    unsafe fn methodWithArg1_andArg2_andArg3_(
-        &self,
-        intvalue: ::std::os::raw::c_int,
-        ptr: *mut ::std::os::raw::c_char,
-        floatvalue: f32,
-    ) where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send ! (* self , methodWithArg1 : intvalue andArg2 : ptr andArg3 : floatvalue)
-    }
-    unsafe fn methodWithAndWithoutKeywords_arg2Name__arg4Name_(
-        &self,
-        arg1: ::std::os::raw::c_int,
-        arg2: f32,
-        arg3: f32,
-        arg4: ::std::os::raw::c_int,
-    ) -> instancetype
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send ! (* self , methodWithAndWithoutKeywords : arg1 arg2Name : arg2 arg3 : arg3 arg4Name : arg4)
-    }
-}
-pub type instancetype = id;
diff --git a/tests/expectations/tests/objc_method_clash.rs b/tests/expectations/tests/objc_method_clash.rs
deleted file mode 100644
index ac77cc19..00000000
--- a/tests/expectations/tests/objc_method_clash.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn foo(&self)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, foo)
-    }
-    unsafe fn class_foo()
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), foo)
-    }
-}
diff --git a/tests/expectations/tests/objc_pointer_return_types.rs b/tests/expectations/tests/objc_pointer_return_types.rs
deleted file mode 100644
index 1ec8494d..00000000
--- a/tests/expectations/tests/objc_pointer_return_types.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar(pub id);
-impl std::ops::Deref for Bar {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Bar {}
-impl Bar {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Bar), alloc) })
-    }
-}
-impl IBar for Bar {}
-pub trait IBar: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn methodUsingBar_(&self, my_bar: Bar)
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, methodUsingBar: my_bar)
-    }
-    unsafe fn methodReturningBar() -> Bar
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(class!(Foo), methodReturningBar)
-    }
-}
diff --git a/tests/expectations/tests/objc_property_fnptr.rs b/tests/expectations/tests/objc_property_fnptr.rs
deleted file mode 100644
index 9f3fabd2..00000000
--- a/tests/expectations/tests/objc_property_fnptr.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {
-    unsafe fn func(
-        &self,
-    ) -> ::std::option::Option<
-        unsafe extern "C" fn(
-            arg1: ::std::os::raw::c_char,
-            arg2: ::std::os::raw::c_short,
-            arg3: f32,
-        ) -> ::std::os::raw::c_int,
-    >
-    where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, func)
-    }
-    unsafe fn setFunc_(
-        &self,
-        func: ::std::option::Option<
-            unsafe extern "C" fn(
-                arg1: ::std::os::raw::c_char,
-                arg2: ::std::os::raw::c_short,
-                arg3: f32,
-            ) -> ::std::os::raw::c_int,
-        >,
-    ) where
-        <Self as std::ops::Deref>::Target: objc::Message + Sized,
-    {
-        msg_send!(*self, setFunc: func)
-    }
-}
diff --git a/tests/expectations/tests/objc_protocol.rs b/tests/expectations/tests/objc_protocol.rs
deleted file mode 100644
index 5bd7d433..00000000
--- a/tests/expectations/tests/objc_protocol.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-pub trait PFoo: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl PFoo for Foo {}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/objc_protocol_inheritance.rs b/tests/expectations/tests/objc_protocol_inheritance.rs
deleted file mode 100644
index f5f80e2e..00000000
--- a/tests/expectations/tests/objc_protocol_inheritance.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-pub trait PFoo: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo(pub id);
-impl std::ops::Deref for Foo {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Foo {}
-impl Foo {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Foo), alloc) })
-    }
-}
-impl PFoo for Foo {}
-impl IFoo for Foo {}
-pub trait IFoo: Sized + std::ops::Deref {}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone)]
-pub struct Bar(pub id);
-impl std::ops::Deref for Bar {
-    type Target = objc::runtime::Object;
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*self.0 }
-    }
-}
-unsafe impl objc::Message for Bar {}
-impl Bar {
-    pub fn alloc() -> Self {
-        Self(unsafe { msg_send!(class!(Bar), alloc) })
-    }
-}
-impl IFoo for Bar {}
-impl PFoo for Bar {}
-impl From<Bar> for Foo {
-    fn from(child: Bar) -> Foo {
-        Foo(child.0)
-    }
-}
-impl std::convert::TryFrom<Foo> for Bar {
-    type Error = &'static str;
-    fn try_from(parent: Foo) -> Result<Bar, Self::Error> {
-        let is_kind_of: bool =
-            unsafe { msg_send!(parent, isKindOfClass: class!(Bar)) };
-        if is_kind_of {
-            Ok(Bar(parent.0))
-        } else {
-            Err("This Foo cannot be downcasted to Bar")
-        }
-    }
-}
-impl IBar for Bar {}
-pub trait IBar: Sized + std::ops::Deref {}
diff --git a/tests/expectations/tests/objc_sel_and_id.rs b/tests/expectations/tests/objc_sel_and_id.rs
deleted file mode 100644
index 0017eab0..00000000
--- a/tests/expectations/tests/objc_sel_and_id.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(target_os = "macos")]
-
-use objc::{self, class, msg_send, sel, sel_impl};
-#[allow(non_camel_case_types)]
-pub type id = *mut objc::runtime::Object;
-extern "C" {
-    pub static mut object: id;
-}
-extern "C" {
-    pub static mut selector: objc::runtime::Sel;
-}
-extern "C" {
-    pub fn f(object: id, selector: objc::runtime::Sel);
-}
diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs
deleted file mode 100644
index 2f063b5b..00000000
--- a/tests/expectations/tests/only_bitfields.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        1usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        1usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-}
-impl C {
-    #[inline]
-    pub fn a(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: bool,
-        b: bool,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u8 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 7u8, {
-            let b: u8 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/opaque-template-inst-member-2.rs b/tests/expectations/tests/opaque-template-inst-member-2.rs
deleted file mode 100644
index c28d9356..00000000
--- a/tests/expectations/tests/opaque-template-inst-member-2.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// This is like `opaque-template-inst-member.hpp` except exercising the cases
-/// where we are OK to derive Debug/Hash/PartialEq.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct OpaqueTemplate {
-    pub _address: u8,
-}
-/// Should derive Debug/Hash/PartialEq.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ContainsOpaqueTemplate {
-    pub mBlah: u32,
-    pub mBaz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ContainsOpaqueTemplate() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueTemplate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsOpaqueTemplate>(),
-        8usize,
-        concat!("Size of: ", stringify!(ContainsOpaqueTemplate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsOpaqueTemplate>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ContainsOpaqueTemplate))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBlah) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsOpaqueTemplate),
-            "::",
-            stringify!(mBlah)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBaz) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsOpaqueTemplate),
-            "::",
-            stringify!(mBaz)
-        )
-    );
-}
-/// Should also derive Debug/Hash/PartialEq.
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct InheritsOpaqueTemplate {
-    pub _base: u8,
-    pub wow: *mut ::std::os::raw::c_char,
-}
-#[test]
-fn bindgen_test_layout_InheritsOpaqueTemplate() {
-    const UNINIT: ::std::mem::MaybeUninit<InheritsOpaqueTemplate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<InheritsOpaqueTemplate>(),
-        16usize,
-        concat!("Size of: ", stringify!(InheritsOpaqueTemplate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsOpaqueTemplate>(),
-        8usize,
-        concat!("Alignment of ", stringify!(InheritsOpaqueTemplate))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).wow) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(InheritsOpaqueTemplate),
-            "::",
-            stringify!(wow)
-        )
-    );
-}
-impl Default for InheritsOpaqueTemplate {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/opaque-template-inst-member.rs b/tests/expectations/tests/opaque-template-inst-member.rs
deleted file mode 100644
index 4ba85f66..00000000
--- a/tests/expectations/tests/opaque-template-inst-member.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct OpaqueTemplate {
-    pub _address: u8,
-}
-/// This should not end up deriving Debug/Hash because its `mBlah` field cannot derive
-/// Debug/Hash because the instantiation's definition cannot derive Debug/Hash.
-#[repr(C)]
-pub struct ContainsOpaqueTemplate {
-    pub mBlah: [u32; 101usize],
-    pub mBaz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ContainsOpaqueTemplate() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueTemplate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsOpaqueTemplate>(),
-        408usize,
-        concat!("Size of: ", stringify!(ContainsOpaqueTemplate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsOpaqueTemplate>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ContainsOpaqueTemplate))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBlah) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsOpaqueTemplate),
-            "::",
-            stringify!(mBlah)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBaz) as usize - ptr as usize },
-        404usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsOpaqueTemplate),
-            "::",
-            stringify!(mBaz)
-        )
-    );
-}
-impl Default for ContainsOpaqueTemplate {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for ContainsOpaqueTemplate {
-    fn eq(&self, other: &ContainsOpaqueTemplate) -> bool {
-        &self.mBlah[..] == &other.mBlah[..] && self.mBaz == other.mBaz
-    }
-}
-/// This should not end up deriving Debug/Hash either, for similar reasons, although
-/// we're exercising base member edges now.
-#[repr(C)]
-pub struct InheritsOpaqueTemplate {
-    pub _base: [u8; 401usize],
-    pub wow: *mut ::std::os::raw::c_char,
-}
-#[test]
-fn bindgen_test_layout_InheritsOpaqueTemplate() {
-    const UNINIT: ::std::mem::MaybeUninit<InheritsOpaqueTemplate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<InheritsOpaqueTemplate>(),
-        416usize,
-        concat!("Size of: ", stringify!(InheritsOpaqueTemplate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsOpaqueTemplate>(),
-        8usize,
-        concat!("Alignment of ", stringify!(InheritsOpaqueTemplate))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).wow) as usize - ptr as usize },
-        408usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(InheritsOpaqueTemplate),
-            "::",
-            stringify!(wow)
-        )
-    );
-}
-impl Default for InheritsOpaqueTemplate {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl ::std::cmp::PartialEq for InheritsOpaqueTemplate {
-    fn eq(&self, other: &InheritsOpaqueTemplate) -> bool {
-        &self._base[..] == &other._base[..] && self.wow == other.wow
-    }
-}
diff --git a/tests/expectations/tests/opaque-template-instantiation-namespaced.rs b/tests/expectations/tests/opaque-template-instantiation-namespaced.rs
deleted file mode 100644
index 3575216c..00000000
--- a/tests/expectations/tests/opaque-template-instantiation-namespaced.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod zoidberg {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct Template<T> {
-            pub member: T,
-            pub _phantom_0:
-                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-        }
-        impl<T> Default for Template<T> {
-            fn default() -> Self {
-                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                unsafe {
-                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                    s.assume_init()
-                }
-            }
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct Foo {
-            pub c: ::std::os::raw::c_char,
-        }
-        #[test]
-        fn bindgen_test_layout_Foo() {
-            const UNINIT: ::std::mem::MaybeUninit<Foo> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Foo>(),
-                1usize,
-                concat!("Size of: ", stringify!(Foo))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Foo>(),
-                1usize,
-                concat!("Alignment of ", stringify!(Foo))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Foo),
-                    "::",
-                    stringify!(c)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct Bar {
-            pub i: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_Bar() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar>(),
-                4usize,
-                concat!("Size of: ", stringify!(Bar))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(i)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct ContainsInstantiation {
-            pub not_opaque: root::zoidberg::Template<root::zoidberg::Foo>,
-        }
-        #[test]
-        fn bindgen_test_layout_ContainsInstantiation() {
-            const UNINIT: ::std::mem::MaybeUninit<ContainsInstantiation> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<ContainsInstantiation>(),
-                1usize,
-                concat!("Size of: ", stringify!(ContainsInstantiation))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<ContainsInstantiation>(),
-                1usize,
-                concat!("Alignment of ", stringify!(ContainsInstantiation))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).not_opaque) as usize -
-                        ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(ContainsInstantiation),
-                    "::",
-                    stringify!(not_opaque)
-                )
-            );
-        }
-        impl Default for ContainsInstantiation {
-            fn default() -> Self {
-                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                unsafe {
-                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                    s.assume_init()
-                }
-            }
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct ContainsOpaqueInstantiation {
-            pub opaque: u32,
-        }
-        #[test]
-        fn bindgen_test_layout_ContainsOpaqueInstantiation() {
-            const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueInstantiation> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<ContainsOpaqueInstantiation>(),
-                4usize,
-                concat!("Size of: ", stringify!(ContainsOpaqueInstantiation))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<ContainsOpaqueInstantiation>(),
-                4usize,
-                concat!(
-                    "Alignment of ",
-                    stringify!(ContainsOpaqueInstantiation)
-                )
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(ContainsOpaqueInstantiation),
-                    "::",
-                    stringify!(opaque)
-                )
-            );
-        }
-    }
-    #[test]
-    fn __bindgen_test_layout_Template_open0_Foo_close0_instantiation() {
-        assert_eq!(
-            ::std::mem::size_of::<root::zoidberg::Template<root::zoidberg::Foo>>(
-            ),
-            1usize,
-            concat!(
-                "Size of template specialization: ",
-                stringify!(root::zoidberg::Template<root::zoidberg::Foo>)
-            )
-        );
-        assert_eq!(
-            ::std::mem::align_of::<root::zoidberg::Template<root::zoidberg::Foo>>(
-            ),
-            1usize,
-            concat!(
-                "Alignment of template specialization: ",
-                stringify!(root::zoidberg::Template<root::zoidberg::Foo>)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/opaque-template-instantiation.rs b/tests/expectations/tests/opaque-template-instantiation.rs
deleted file mode 100644
index 910c616f..00000000
--- a/tests/expectations/tests/opaque-template-instantiation.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Template<T> {
-    pub member: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Template<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ContainsInstantiation {
-    pub not_opaque: Template<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_ContainsInstantiation() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsInstantiation> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsInstantiation>(),
-        1usize,
-        concat!("Size of: ", stringify!(ContainsInstantiation))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsInstantiation>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ContainsInstantiation))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).not_opaque) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsInstantiation),
-            "::",
-            stringify!(not_opaque)
-        )
-    );
-}
-impl Default for ContainsInstantiation {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct ContainsOpaqueInstantiation {
-    pub opaque: u32,
-}
-#[test]
-fn bindgen_test_layout_ContainsOpaqueInstantiation() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsOpaqueInstantiation> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsOpaqueInstantiation>(),
-        4usize,
-        concat!("Size of: ", stringify!(ContainsOpaqueInstantiation))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsOpaqueInstantiation>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ContainsOpaqueInstantiation))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsOpaqueInstantiation),
-            "::",
-            stringify!(opaque)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_Template_open0_char_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Template<::std::os::raw::c_char>>(),
-        1usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(Template<::std::os::raw::c_char>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Template<::std::os::raw::c_char>>(),
-        1usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(Template<::std::os::raw::c_char>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/opaque-tracing.rs b/tests/expectations/tests/opaque-tracing.rs
deleted file mode 100644
index 98c54171..00000000
--- a/tests/expectations/tests/opaque-tracing.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z3fooP9Container"]
-    pub fn foo(c: *mut Container);
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Container {
-    pub _bindgen_opaque_blob: [u32; 2usize],
-}
-#[test]
-fn bindgen_test_layout_Container() {
-    assert_eq!(
-        ::std::mem::size_of::<Container>(),
-        8usize,
-        concat!("Size of: ", stringify!(Container))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Container>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Container))
-    );
-}
diff --git a/tests/expectations/tests/opaque_in_struct.rs b/tests/expectations/tests/opaque_in_struct.rs
deleted file mode 100644
index 0d13b121..00000000
--- a/tests/expectations/tests/opaque_in_struct.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen opaque>
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct opaque {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_opaque() {
-    assert_eq!(
-        ::std::mem::size_of::<opaque>(),
-        4usize,
-        concat!("Size of: ", stringify!(opaque))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<opaque>(),
-        4usize,
-        concat!("Alignment of ", stringify!(opaque))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct container {
-    pub contained: opaque,
-}
-#[test]
-fn bindgen_test_layout_container() {
-    const UNINIT: ::std::mem::MaybeUninit<container> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<container>(),
-        4usize,
-        concat!("Size of: ", stringify!(container))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<container>(),
-        4usize,
-        concat!("Alignment of ", stringify!(container))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).contained) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(container),
-            "::",
-            stringify!(contained)
-        )
-    );
-}
diff --git a/tests/expectations/tests/opaque_pointer.rs b/tests/expectations/tests/opaque_pointer.rs
deleted file mode 100644
index 13b8cc36..00000000
--- a/tests/expectations/tests/opaque_pointer.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen opaque></div>
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct OtherOpaque {
-    pub _bindgen_opaque_blob: u32,
-}
-#[test]
-fn bindgen_test_layout_OtherOpaque() {
-    assert_eq!(
-        ::std::mem::size_of::<OtherOpaque>(),
-        4usize,
-        concat!("Size of: ", stringify!(OtherOpaque))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<OtherOpaque>(),
-        4usize,
-        concat!("Alignment of ", stringify!(OtherOpaque))
-    );
-}
-/// <div rustbindgen opaque></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Opaque {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq)]
-pub struct WithOpaquePtr {
-    pub whatever: *mut u8,
-    pub other: u32,
-    pub t: OtherOpaque,
-}
-#[test]
-fn bindgen_test_layout_WithOpaquePtr() {
-    const UNINIT: ::std::mem::MaybeUninit<WithOpaquePtr> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithOpaquePtr>(),
-        16usize,
-        concat!("Size of: ", stringify!(WithOpaquePtr))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithOpaquePtr>(),
-        8usize,
-        concat!("Alignment of ", stringify!(WithOpaquePtr))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).whatever) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithOpaquePtr),
-            "::",
-            stringify!(whatever)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).other) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithOpaquePtr),
-            "::",
-            stringify!(other)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithOpaquePtr),
-            "::",
-            stringify!(t)
-        )
-    );
-}
-impl Default for WithOpaquePtr {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/opaque_typedef.rs b/tests/expectations/tests/opaque_typedef.rs
deleted file mode 100644
index c61a294c..00000000
--- a/tests/expectations/tests/opaque_typedef.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct RandomTemplate {
-    pub _address: u8,
-}
-/// <div rustbindgen opaque></div>
-pub type ShouldBeOpaque = u8;
-pub type ShouldNotBeOpaque = RandomTemplate;
diff --git a/tests/expectations/tests/operator.rs b/tests/expectations/tests/operator.rs
deleted file mode 100644
index 5128226d..00000000
--- a/tests/expectations/tests/operator.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z20operator_informationv"]
-    pub fn operator_information() -> ::std::os::raw::c_int;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Foo {
-    _unused: [u8; 0],
-}
diff --git a/tests/expectations/tests/ord-enum.rs b/tests/expectations/tests/ord-enum.rs
deleted file mode 100644
index a72fef8d..00000000
--- a/tests/expectations/tests/ord-enum.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub enum A {
-    A0 = 0,
-    A1 = 1,
-    A2 = 2,
-    A3 = -1,
-}
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub enum B {
-    B0 = 1,
-    B1 = 4,
-    B2 = 3,
-    B3 = -1,
-}
diff --git a/tests/expectations/tests/overflowed_enum.rs b/tests/expectations/tests/overflowed_enum.rs
deleted file mode 100644
index 94e166ad..00000000
--- a/tests/expectations/tests/overflowed_enum.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Foo {
-    BAP_ARM = 9698489,
-    BAP_X86 = 11960045,
-    BAP_X86_64 = 3128633167,
-}
-#[repr(u16)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Bar {
-    One = 1,
-    Big = 2,
-}
diff --git a/tests/expectations/tests/overloading.rs b/tests/expectations/tests/overloading.rs
deleted file mode 100644
index b43432eb..00000000
--- a/tests/expectations/tests/overloading.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z8Evaluatec"]
-    pub fn Evaluate(r: ::std::os::raw::c_char) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_Z8Evaluateii"]
-    pub fn Evaluate1(
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-    ) -> bool;
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3foo10MyFunctionEv"]
-    pub fn foo_MyFunction();
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3bar10MyFunctionEv"]
-    pub fn bar_MyFunction();
-}
diff --git a/tests/expectations/tests/packed-bitfield.rs b/tests/expectations/tests/packed-bitfield.rs
deleted file mode 100644
index f90edb93..00000000
--- a/tests/expectations/tests/packed-bitfield.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Date {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-}
-#[test]
-fn bindgen_test_layout_Date() {
-    assert_eq!(
-        ::std::mem::size_of::<Date>(),
-        3usize,
-        concat!("Size of: ", stringify!(Date))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Date>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Date))
-    );
-}
-impl Date {
-    #[inline]
-    pub fn day(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_day(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 5u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn month(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_month(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn year(&self) -> ::std::os::raw::c_short {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(9usize, 15u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_year(&mut self, val: ::std::os::raw::c_short) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 15u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        day: ::std::os::raw::c_uchar,
-        month: ::std::os::raw::c_uchar,
-        year: ::std::os::raw::c_short,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 5u8, {
-            let day: u8 = unsafe { ::std::mem::transmute(day) };
-            day as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 4u8, {
-            let month: u8 = unsafe { ::std::mem::transmute(month) };
-            month as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 15u8, {
-            let year: u16 = unsafe { ::std::mem::transmute(year) };
-            year as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/packed-n-with-padding.rs b/tests/expectations/tests/packed-n-with-padding.rs
deleted file mode 100644
index b171b1da..00000000
--- a/tests/expectations/tests/packed-n-with-padding.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C, packed(2))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Packed {
-    pub a: ::std::os::raw::c_char,
-    pub b: ::std::os::raw::c_short,
-    pub c: ::std::os::raw::c_char,
-    pub d: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Packed() {
-    const UNINIT: ::std::mem::MaybeUninit<Packed> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Packed>(),
-        10usize,
-        concat!("Size of: ", stringify!(Packed))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Packed>(),
-        2usize,
-        concat!("Alignment of ", stringify!(Packed))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        2usize,
-        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(c))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        6usize,
-        concat!("Offset of field: ", stringify!(Packed), "::", stringify!(d))
-    );
-}
diff --git a/tests/expectations/tests/packed-vtable.rs b/tests/expectations/tests/packed-vtable.rs
deleted file mode 100644
index 71688151..00000000
--- a/tests/expectations/tests/packed-vtable.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-
-#[repr(C)]
-pub struct PackedVtable__bindgen_vtable(::std::os::raw::c_void);
-#[repr(C, packed)]
-pub struct PackedVtable {
-    pub vtable_: *const PackedVtable__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_PackedVtable() {
-    assert_eq!(
-        ::std::mem::size_of::<PackedVtable>(),
-        8usize,
-        concat!("Size of: ", stringify!(PackedVtable))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PackedVtable>(),
-        1usize,
-        concat!("Alignment of ", stringify!(PackedVtable))
-    );
-}
-impl Default for PackedVtable {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN12PackedVtableD1Ev"]
-    pub fn PackedVtable_PackedVtable_destructor(this: *mut PackedVtable);
-}
diff --git a/tests/expectations/tests/parm-union.rs b/tests/expectations/tests/parm-union.rs
deleted file mode 100644
index 9f7dd20a..00000000
--- a/tests/expectations/tests/parm-union.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Struct {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Struct() {
-    assert_eq!(
-        ::std::mem::size_of::<Struct>(),
-        1usize,
-        concat!("Size of: ", stringify!(Struct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Struct>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Struct))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN6Struct8FunctionER5Union"]
-    pub fn Struct_Function(this: *mut Struct, arg1: *mut Union);
-}
-impl Struct {
-    #[inline]
-    pub unsafe fn Function(&mut self, arg1: *mut Union) {
-        Struct_Function(self, arg1)
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Union {
-    _unused: [u8; 0],
-}
diff --git a/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs b/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
deleted file mode 100644
index 8ead5b8a..00000000
--- a/tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const RENAMED_MyVal: _bindgen_ty_1 = 0;
-pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/pointer-attr.rs b/tests/expectations/tests/pointer-attr.rs
deleted file mode 100644
index 95fe9c5f..00000000
--- a/tests/expectations/tests/pointer-attr.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn a(arg1: *const ::std::os::raw::c_char);
-}
diff --git a/tests/expectations/tests/prepend-enum-constified-variant.rs b/tests/expectations/tests/prepend-enum-constified-variant.rs
deleted file mode 100644
index b2b09444..00000000
--- a/tests/expectations/tests/prepend-enum-constified-variant.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-impl AVCodecID {
-    pub const AV_CODEC_ID_TTF: AVCodecID = AVCodecID::AV_CODEC_ID_FIRST_UNKNOWN;
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum AVCodecID {
-    AV_CODEC_ID_FIRST_UNKNOWN = 98304,
-}
diff --git a/tests/expectations/tests/prepend_enum_name.rs b/tests/expectations/tests/prepend_enum_name.rs
deleted file mode 100644
index 31db4144..00000000
--- a/tests/expectations/tests/prepend_enum_name.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const FOO_BAR: foo = 0;
-pub const FOO_BAZ: foo = 1;
-pub type foo = ::std::os::raw::c_uint;
diff --git a/tests/expectations/tests/private.rs b/tests/expectations/tests/private.rs
deleted file mode 100644
index ab57d37f..00000000
--- a/tests/expectations/tests/private.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct HasPrivate {
-    pub mNotPrivate: ::std::os::raw::c_int,
-    /// <div rustbindgen private></div>
-    mIsPrivate: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_HasPrivate() {
-    const UNINIT: ::std::mem::MaybeUninit<HasPrivate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<HasPrivate>(),
-        8usize,
-        concat!("Size of: ", stringify!(HasPrivate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<HasPrivate>(),
-        4usize,
-        concat!("Alignment of ", stringify!(HasPrivate))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mNotPrivate) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(HasPrivate),
-            "::",
-            stringify!(mNotPrivate)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(HasPrivate),
-            "::",
-            stringify!(mIsPrivate)
-        )
-    );
-}
-/// <div rustbindgen private></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct VeryPrivate {
-    mIsPrivate: ::std::os::raw::c_int,
-    mIsAlsoPrivate: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_VeryPrivate() {
-    const UNINIT: ::std::mem::MaybeUninit<VeryPrivate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<VeryPrivate>(),
-        8usize,
-        concat!("Size of: ", stringify!(VeryPrivate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<VeryPrivate>(),
-        4usize,
-        concat!("Alignment of ", stringify!(VeryPrivate))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(VeryPrivate),
-            "::",
-            stringify!(mIsPrivate)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsAlsoPrivate) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(VeryPrivate),
-            "::",
-            stringify!(mIsAlsoPrivate)
-        )
-    );
-}
-/// <div rustbindgen private></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ContradictPrivate {
-    /// <div rustbindgen private="false"></div>
-    pub mNotPrivate: ::std::os::raw::c_int,
-    mIsPrivate: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_ContradictPrivate() {
-    const UNINIT: ::std::mem::MaybeUninit<ContradictPrivate> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContradictPrivate>(),
-        8usize,
-        concat!("Size of: ", stringify!(ContradictPrivate))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContradictPrivate>(),
-        4usize,
-        concat!("Alignment of ", stringify!(ContradictPrivate))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mNotPrivate) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictPrivate),
-            "::",
-            stringify!(mNotPrivate)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsPrivate) as usize - ptr as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContradictPrivate),
-            "::",
-            stringify!(mIsPrivate)
-        )
-    );
-}
diff --git a/tests/expectations/tests/private_fields.rs b/tests/expectations/tests/private_fields.rs
deleted file mode 100644
index 8db332a5..00000000
--- a/tests/expectations/tests/private_fields.rs
+++ /dev/null
@@ -1,535 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PubPriv {
-    pub x: ::std::os::raw::c_int,
-    y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_PubPriv() {
-    const UNINIT: ::std::mem::MaybeUninit<PubPriv> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PubPriv>(),
-        8usize,
-        concat!("Size of: ", stringify!(PubPriv))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PubPriv>(),
-        4usize,
-        concat!("Alignment of ", stringify!(PubPriv))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PubPriv),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PubPriv),
-            "::",
-            stringify!(y)
-        )
-    );
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PrivateBitFields {
-    pub _bitfield_align_1: [u8; 0],
-    _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_PrivateBitFields() {
-    assert_eq!(
-        ::std::mem::size_of::<PrivateBitFields>(),
-        4usize,
-        concat!("Size of: ", stringify!(PrivateBitFields))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PrivateBitFields>(),
-        4usize,
-        concat!("Alignment of ", stringify!(PrivateBitFields))
-    );
-}
-impl PrivateBitFields {
-    #[inline]
-    fn a(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    fn set_a(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    fn b(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    fn set_b(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    fn new_bitfield_1(
-        a: ::std::os::raw::c_uint,
-        b: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 4u8, {
-            let a: u32 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 4u8, {
-            let b: u32 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct PublicBitFields {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_PublicBitFields() {
-    assert_eq!(
-        ::std::mem::size_of::<PublicBitFields>(),
-        4usize,
-        concat!("Size of: ", stringify!(PublicBitFields))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PublicBitFields>(),
-        4usize,
-        concat!("Alignment of ", stringify!(PublicBitFields))
-    );
-}
-impl PublicBitFields {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: ::std::os::raw::c_uint,
-        b: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 4u8, {
-            let a: u32 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 4u8, {
-            let b: u32 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct MixedBitFields {
-    pub _bitfield_align_1: [u8; 0],
-    _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_MixedBitFields() {
-    assert_eq!(
-        ::std::mem::size_of::<MixedBitFields>(),
-        4usize,
-        concat!("Size of: ", stringify!(MixedBitFields))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<MixedBitFields>(),
-        4usize,
-        concat!("Alignment of ", stringify!(MixedBitFields))
-    );
-}
-impl MixedBitFields {
-    #[inline]
-    fn a(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    fn set_a(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn d(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_d(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 4u8, val as u64)
-        }
-    }
-    #[inline]
-    fn new_bitfield_1(
-        a: ::std::os::raw::c_uint,
-        d: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 4u8, {
-            let a: u32 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 4u8, {
-            let d: u32 = unsafe { ::std::mem::transmute(d) };
-            d as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Base {
-    pub member: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Base() {
-    const UNINIT: ::std::mem::MaybeUninit<Base> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Base>(),
-        4usize,
-        concat!("Size of: ", stringify!(Base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Base>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Base))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Base),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct InheritsPrivately {
-    _base: Base,
-}
-#[test]
-fn bindgen_test_layout_InheritsPrivately() {
-    assert_eq!(
-        ::std::mem::size_of::<InheritsPrivately>(),
-        4usize,
-        concat!("Size of: ", stringify!(InheritsPrivately))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsPrivately>(),
-        4usize,
-        concat!("Alignment of ", stringify!(InheritsPrivately))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct InheritsPublically {
-    pub _base: Base,
-}
-#[test]
-fn bindgen_test_layout_InheritsPublically() {
-    assert_eq!(
-        ::std::mem::size_of::<InheritsPublically>(),
-        4usize,
-        concat!("Size of: ", stringify!(InheritsPublically))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsPublically>(),
-        4usize,
-        concat!("Alignment of ", stringify!(InheritsPublically))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithAnonStruct {
-    __bindgen_anon_1: WithAnonStruct__bindgen_ty_1,
-    pub __bindgen_anon_2: WithAnonStruct__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithAnonStruct__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithAnonStruct__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<WithAnonStruct__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithAnonStruct__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithAnonStruct__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithAnonStruct__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithAnonStruct__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithAnonStruct__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct WithAnonStruct__bindgen_ty_2 {
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_WithAnonStruct__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<WithAnonStruct__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithAnonStruct__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithAnonStruct__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithAnonStruct__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithAnonStruct__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithAnonStruct__bindgen_ty_2),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_WithAnonStruct() {
-    assert_eq!(
-        ::std::mem::size_of::<WithAnonStruct>(),
-        8usize,
-        concat!("Size of: ", stringify!(WithAnonStruct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithAnonStruct>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithAnonStruct))
-    );
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct WithAnonUnion {
-    __bindgen_anon_1: WithAnonUnion__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union WithAnonUnion__bindgen_ty_1 {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_WithAnonUnion__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<WithAnonUnion__bindgen_ty_1>(),
-        1usize,
-        concat!("Size of: ", stringify!(WithAnonUnion__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithAnonUnion__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(WithAnonUnion__bindgen_ty_1))
-    );
-}
-impl Default for WithAnonUnion__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_WithAnonUnion() {
-    assert_eq!(
-        ::std::mem::size_of::<WithAnonUnion>(),
-        1usize,
-        concat!("Size of: ", stringify!(WithAnonUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithAnonUnion>(),
-        1usize,
-        concat!("Alignment of ", stringify!(WithAnonUnion))
-    );
-}
-impl Default for WithAnonUnion {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/public-dtor.rs b/tests/expectations/tests/public-dtor.rs
deleted file mode 100644
index 64a50389..00000000
--- a/tests/expectations/tests/public-dtor.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct cv_String {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_cv_String() {
-    assert_eq!(
-        ::std::mem::size_of::<cv_String>(),
-        1usize,
-        concat!("Size of: ", stringify!(cv_String))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<cv_String>(),
-        1usize,
-        concat!("Alignment of ", stringify!(cv_String))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN2cv6StringD1Ev"]
-    pub fn cv_String_String_destructor(this: *mut cv_String);
-}
-impl cv_String {
-    #[inline]
-    pub unsafe fn destruct(&mut self) {
-        cv_String_String_destructor(self)
-    }
-}
diff --git a/tests/expectations/tests/qualified-dependent-types.rs b/tests/expectations/tests/qualified-dependent-types.rs
deleted file mode 100644
index f1b2c845..00000000
--- a/tests/expectations/tests/qualified-dependent-types.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/redeclaration.rs b/tests/expectations/tests/redeclaration.rs
deleted file mode 100644
index 8a4ff657..00000000
--- a/tests/expectations/tests/redeclaration.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo();
-}
diff --git a/tests/expectations/tests/ref_argument_array.rs b/tests/expectations/tests/ref_argument_array.rs
deleted file mode 100644
index 00a8e0ee..00000000
--- a/tests/expectations/tests/ref_argument_array.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const NSID_LENGTH: u32 = 10;
-#[repr(C)]
-pub struct nsID__bindgen_vtable {
-    pub nsID_ToProvidedString: unsafe extern "C" fn(
-        this: *mut nsID,
-        aDest: *mut [::std::os::raw::c_char; 10usize],
-    ),
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct nsID {
-    pub vtable_: *const nsID__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_nsID() {
-    assert_eq!(
-        ::std::mem::size_of::<nsID>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsID))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsID>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsID))
-    );
-}
-impl Default for nsID {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN4nsID16ToProvidedStringERA10_c"]
-    pub fn nsID_ToProvidedString(
-        this: *mut ::std::os::raw::c_void,
-        aDest: *mut [::std::os::raw::c_char; 10usize],
-    );
-}
diff --git a/tests/expectations/tests/reparented_replacement.rs b/tests/expectations/tests/reparented_replacement.rs
deleted file mode 100644
index d9d13c1a..00000000
--- a/tests/expectations/tests/reparented_replacement.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod foo {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        /// <div rustbindgen replaces="foo::Bar"></div>
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Bar {
-            pub bazz: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_Bar() {
-            const UNINIT: ::std::mem::MaybeUninit<Bar> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<Bar>(),
-                4usize,
-                concat!("Size of: ", stringify!(Bar))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<Bar>(),
-                4usize,
-                concat!("Alignment of ", stringify!(Bar))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).bazz) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(Bar),
-                    "::",
-                    stringify!(bazz)
-                )
-            );
-        }
-    }
-    pub type ReferencesBar = root::foo::Bar;
-}
diff --git a/tests/expectations/tests/replace_template_alias.rs b/tests/expectations/tests/replace_template_alias.rs
deleted file mode 100644
index 4f464129..00000000
--- a/tests/expectations/tests/replace_template_alias.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// But the replacement type does use T!
-///
-/// <div rustbindgen replaces="JS::detail::MaybeWrapped" />
-pub type JS_detail_MaybeWrapped<T> = T;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct JS_Rooted<T> {
-    pub ptr: JS_detail_MaybeWrapped<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for JS_Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/replace_use.rs b/tests/expectations/tests/replace_use.rs
deleted file mode 100644
index d4228e12..00000000
--- a/tests/expectations/tests/replace_use.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// <div rustbindgen replaces="nsTArray"></div>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct nsTArray {
-    pub y: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Test {
-    pub a: nsTArray,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        4usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(a))
-    );
-}
-#[test]
-fn __bindgen_test_layout_nsTArray_open0_long_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<nsTArray>(),
-        4usize,
-        concat!("Size of template specialization: ", stringify!(nsTArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsTArray>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(nsTArray)
-        )
-    );
-}
diff --git a/tests/expectations/tests/replaces_double.rs b/tests/expectations/tests/replaces_double.rs
deleted file mode 100644
index 99de1320..00000000
--- a/tests/expectations/tests/replaces_double.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Wrapper_Wrapped<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Wrapper_Wrapped<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type Wrapper_Type<T> = Wrapper_Wrapped<T>;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted<T> {
-    pub ptr: Rooted_MaybeWrapped<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-/// <div rustbindgen replaces="Rooted_MaybeWrapped"></div>
-pub type Rooted_MaybeWrapped<T> = T;
-impl<T> Default for Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/repr-align.rs b/tests/expectations/tests/repr-align.rs
deleted file mode 100644
index c6fee20d..00000000
--- a/tests/expectations/tests/repr-align.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct a {
-    pub b: ::std::os::raw::c_int,
-    pub c: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_a() {
-    const UNINIT: ::std::mem::MaybeUninit<a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        8usize,
-        concat!("Size of: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        8usize,
-        concat!("Alignment of ", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(c))
-    );
-}
-#[repr(C)]
-#[repr(align(8))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct b {
-    pub b: ::std::os::raw::c_int,
-    pub c: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_b() {
-    const UNINIT: ::std::mem::MaybeUninit<b> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<b>(),
-        8usize,
-        concat!("Size of: ", stringify!(b))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<b>(),
-        8usize,
-        concat!("Alignment of ", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(b), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(b), "::", stringify!(c))
-    );
-}
diff --git a/tests/expectations/tests/resolved_type_def_function.rs b/tests/expectations/tests/resolved_type_def_function.rs
deleted file mode 100644
index 79797679..00000000
--- a/tests/expectations/tests/resolved_type_def_function.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type FuncType = ::std::option::Option<unsafe extern "C" fn()>;
-extern "C" {
-    pub fn Func();
-}
diff --git a/tests/expectations/tests/same_struct_name_in_different_namespaces.rs b/tests/expectations/tests/same_struct_name_in_different_namespaces.rs
deleted file mode 100644
index 80024761..00000000
--- a/tests/expectations/tests/same_struct_name_in_different_namespaces.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct JS_Zone {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct JS_shadow_Zone {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_JS_shadow_Zone() {
-    const UNINIT: ::std::mem::MaybeUninit<JS_shadow_Zone> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<JS_shadow_Zone>(),
-        8usize,
-        concat!("Size of: ", stringify!(JS_shadow_Zone))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<JS_shadow_Zone>(),
-        4usize,
-        concat!("Alignment of ", stringify!(JS_shadow_Zone))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JS_shadow_Zone),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(JS_shadow_Zone),
-            "::",
-            stringify!(y)
-        )
-    );
-}
diff --git a/tests/expectations/tests/sentry-defined-multiple-times.rs b/tests/expectations/tests/sentry-defined-multiple-times.rs
deleted file mode 100644
index 48f8ca81..00000000
--- a/tests/expectations/tests/sentry-defined-multiple-times.rs
+++ /dev/null
@@ -1,385 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod whatever {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Wrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct Wrapper_sentry {
-            pub i_am_wrapper_sentry: ::std::os::raw::c_int,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct sentry {
-            pub i_am_plain_sentry: bool,
-        }
-        #[test]
-        fn bindgen_test_layout_sentry() {
-            const UNINIT: ::std::mem::MaybeUninit<sentry> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<sentry>(),
-                1usize,
-                concat!("Size of: ", stringify!(sentry))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<sentry>(),
-                1usize,
-                concat!("Alignment of ", stringify!(sentry))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).i_am_plain_sentry) as usize -
-                        ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(sentry),
-                    "::",
-                    stringify!(i_am_plain_sentry)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct NotTemplateWrapper {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_NotTemplateWrapper() {
-            assert_eq!(
-                ::std::mem::size_of::<NotTemplateWrapper>(),
-                1usize,
-                concat!("Size of: ", stringify!(NotTemplateWrapper))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<NotTemplateWrapper>(),
-                1usize,
-                concat!("Alignment of ", stringify!(NotTemplateWrapper))
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct NotTemplateWrapper_sentry {
-            pub i_am_not_template_wrapper_sentry: ::std::os::raw::c_char,
-        }
-        #[test]
-        fn bindgen_test_layout_NotTemplateWrapper_sentry() {
-            const UNINIT: ::std::mem::MaybeUninit<NotTemplateWrapper_sentry> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<NotTemplateWrapper_sentry>(),
-                1usize,
-                concat!("Size of: ", stringify!(NotTemplateWrapper_sentry))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<NotTemplateWrapper_sentry>(),
-                1usize,
-                concat!("Alignment of ", stringify!(NotTemplateWrapper_sentry))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!(
-                        (*ptr).i_am_not_template_wrapper_sentry
-                    ) as usize -
-                        ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(NotTemplateWrapper_sentry),
-                    "::",
-                    stringify!(i_am_not_template_wrapper_sentry)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct InlineNotTemplateWrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct InlineNotTemplateWrapper_sentry {
-            pub i_am_inline_not_template_wrapper_sentry: bool,
-        }
-        #[test]
-        fn bindgen_test_layout_InlineNotTemplateWrapper_sentry() {
-            const UNINIT: ::std::mem::MaybeUninit<
-                InlineNotTemplateWrapper_sentry,
-            > = ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<InlineNotTemplateWrapper_sentry>(),
-                1usize,
-                concat!(
-                    "Size of: ",
-                    stringify!(InlineNotTemplateWrapper_sentry)
-                )
-            );
-            assert_eq!(
-                ::std::mem::align_of::<InlineNotTemplateWrapper_sentry>(),
-                1usize,
-                concat!(
-                    "Alignment of ",
-                    stringify!(InlineNotTemplateWrapper_sentry)
-                )
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!(
-                        (*ptr).i_am_inline_not_template_wrapper_sentry
-                    ) as usize -
-                        ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(InlineNotTemplateWrapper_sentry),
-                    "::",
-                    stringify!(i_am_inline_not_template_wrapper_sentry)
-                )
-            );
-        }
-        #[test]
-        fn bindgen_test_layout_InlineNotTemplateWrapper() {
-            assert_eq!(
-                ::std::mem::size_of::<InlineNotTemplateWrapper>(),
-                1usize,
-                concat!("Size of: ", stringify!(InlineNotTemplateWrapper))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<InlineNotTemplateWrapper>(),
-                1usize,
-                concat!("Alignment of ", stringify!(InlineNotTemplateWrapper))
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct InlineTemplateWrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct InlineTemplateWrapper_sentry {
-            pub i_am_inline_template_wrapper_sentry: ::std::os::raw::c_int,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleWrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleWrapper_InnerDoubleWrapper {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper() {
-            assert_eq!(
-                ::std::mem::size_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
-                1usize,
-                concat!(
-                    "Size of: ",
-                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper)
-                )
-            );
-            assert_eq!(
-                ::std::mem::align_of::<OuterDoubleWrapper_InnerDoubleWrapper>(),
-                1usize,
-                concat!(
-                    "Alignment of ",
-                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper)
-                )
-            );
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleWrapper() {
-            assert_eq!(
-                ::std::mem::size_of::<OuterDoubleWrapper>(),
-                1usize,
-                concat!("Size of: ", stringify!(OuterDoubleWrapper))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<OuterDoubleWrapper>(),
-                1usize,
-                concat!("Alignment of ", stringify!(OuterDoubleWrapper))
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleWrapper_InnerDoubleWrapper_sentry {
-            pub i_am_double_wrapper_sentry: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleWrapper_InnerDoubleWrapper_sentry() {
-            const UNINIT: ::std::mem::MaybeUninit<
-                OuterDoubleWrapper_InnerDoubleWrapper_sentry,
-            > = ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<
-                    OuterDoubleWrapper_InnerDoubleWrapper_sentry,
-                >(),
-                4usize,
-                concat!(
-                    "Size of: ",
-                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry)
-                )
-            );
-            assert_eq!(
-                ::std::mem::align_of::<
-                    OuterDoubleWrapper_InnerDoubleWrapper_sentry,
-                >(),
-                4usize,
-                concat!(
-                    "Alignment of ",
-                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry)
-                )
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).i_am_double_wrapper_sentry)
-                        as usize -
-                        ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(OuterDoubleWrapper_InnerDoubleWrapper_sentry),
-                    "::",
-                    stringify!(i_am_double_wrapper_sentry)
-                )
-            );
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleInlineWrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone)]
-        pub struct OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry {
-            pub i_am_double_wrapper_inline_sentry: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry(
-        ) {
-            const UNINIT: ::std::mem::MaybeUninit<
-                OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry,
-            > = ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq ! (:: std :: mem :: size_of :: < OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry > () , 4usize , concat ! ("Size of: " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry)));
-            assert_eq ! (:: std :: mem :: align_of :: < OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry > () , 4usize , concat ! ("Alignment of " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry)));
-            assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . i_am_double_wrapper_inline_sentry) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (OuterDoubleInlineWrapper_InnerDoubleInlineWrapper_sentry) , "::" , stringify ! (i_am_double_wrapper_inline_sentry)));
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleInlineWrapper_InnerDoubleInlineWrapper(
-        ) {
-            assert_eq!(
-                ::std::mem::size_of::<
-                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
-                >(),
-                1usize,
-                concat!(
-                    "Size of: ",
-                    stringify!(
-                        OuterDoubleInlineWrapper_InnerDoubleInlineWrapper
-                    )
-                )
-            );
-            assert_eq!(
-                ::std::mem::align_of::<
-                    OuterDoubleInlineWrapper_InnerDoubleInlineWrapper,
-                >(),
-                1usize,
-                concat!(
-                    "Alignment of ",
-                    stringify!(
-                        OuterDoubleInlineWrapper_InnerDoubleInlineWrapper
-                    )
-                )
-            );
-        }
-        #[test]
-        fn bindgen_test_layout_OuterDoubleInlineWrapper() {
-            assert_eq!(
-                ::std::mem::size_of::<OuterDoubleInlineWrapper>(),
-                1usize,
-                concat!("Size of: ", stringify!(OuterDoubleInlineWrapper))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<OuterDoubleInlineWrapper>(),
-                1usize,
-                concat!("Alignment of ", stringify!(OuterDoubleInlineWrapper))
-            );
-        }
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct OutsideNamespaceWrapper {
-        pub _address: u8,
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct OutsideNamespaceWrapper_sentry {
-        pub i_am_outside_namespace_wrapper_sentry: ::std::os::raw::c_int,
-    }
-    #[repr(C)]
-    #[derive(Debug, Default, Copy, Clone)]
-    pub struct sentry {
-        pub i_am_outside_namespace_sentry: ::std::os::raw::c_int,
-    }
-    #[test]
-    fn bindgen_test_layout_sentry() {
-        const UNINIT: ::std::mem::MaybeUninit<sentry> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<sentry>(),
-            4usize,
-            concat!("Size of: ", stringify!(sentry))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<sentry>(),
-            4usize,
-            concat!("Alignment of ", stringify!(sentry))
-        );
-        assert_eq!(
-            unsafe {
-                ::std::ptr::addr_of!((*ptr).i_am_outside_namespace_sentry)
-                    as usize -
-                    ptr as usize
-            },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(sentry),
-                "::",
-                stringify!(i_am_outside_namespace_sentry)
-            )
-        );
-    }
-}
diff --git a/tests/expectations/tests/short-enums.rs b/tests/expectations/tests/short-enums.rs
deleted file mode 100644
index a8a494ea..00000000
--- a/tests/expectations/tests/short-enums.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(u8)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum one_byte_t {
-    SOME_VALUE = 1,
-}
-#[repr(u16)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum two_byte_t {
-    SOME_OTHER_VALUE = 256,
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum four_byte_t {
-    SOME_BIGGER_VALUE = 16777216,
-}
diff --git a/tests/expectations/tests/size_t_template.rs b/tests/expectations/tests/size_t_template.rs
deleted file mode 100644
index 1aa8b9ac..00000000
--- a/tests/expectations/tests/size_t_template.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct C {
-    pub arr: [u32; 3usize],
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        12usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        4usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(arr))
-    );
-}
diff --git a/tests/expectations/tests/sorted-items.rs b/tests/expectations/tests/sorted-items.rs
deleted file mode 100644
index 7df7c3d7..00000000
--- a/tests/expectations/tests/sorted-items.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type number = ::std::os::raw::c_int;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Point {
-    pub x: number,
-    pub y: number,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Angle {
-    pub a: number,
-    pub b: number,
-}
-pub const NUMBER: number = 42;
-#[test]
-fn bindgen_test_layout_Point() {
-    const UNINIT: ::std::mem::MaybeUninit<Point> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Point>(),
-        8usize,
-        concat!("Size of: ", stringify!(Point))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Point>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Point))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Point), "::", stringify!(y))
-    );
-}
-#[test]
-fn bindgen_test_layout_Angle() {
-    const UNINIT: ::std::mem::MaybeUninit<Angle> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Angle>(),
-        8usize,
-        concat!("Size of: ", stringify!(Angle))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Angle>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Angle))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(b))
-    );
-}
-extern "C" {
-    pub fn foo() -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar(x: number) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn baz(point: Point) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/stdint_typedef.rs b/tests/expectations/tests/stdint_typedef.rs
deleted file mode 100644
index a52db496..00000000
--- a/tests/expectations/tests/stdint_typedef.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn fun() -> u64;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Struct {
-    pub field: u64,
-}
-#[test]
-fn bindgen_test_layout_Struct() {
-    const UNINIT: ::std::mem::MaybeUninit<Struct> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Struct>(),
-        8usize,
-        concat!("Size of: ", stringify!(Struct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Struct>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Struct))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Struct),
-            "::",
-            stringify!(field)
-        )
-    );
-}
diff --git a/tests/expectations/tests/struct_containing_forward_declared_struct.rs b/tests/expectations/tests/struct_containing_forward_declared_struct.rs
deleted file mode 100644
index 8279fe1f..00000000
--- a/tests/expectations/tests/struct_containing_forward_declared_struct.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct a {
-    pub val_a: *mut b,
-}
-#[test]
-fn bindgen_test_layout_a() {
-    const UNINIT: ::std::mem::MaybeUninit<a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        8usize,
-        concat!("Size of: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        8usize,
-        concat!("Alignment of ", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).val_a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(val_a))
-    );
-}
-impl Default for a {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct b {
-    pub val_b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_b() {
-    const UNINIT: ::std::mem::MaybeUninit<b> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<b>(),
-        4usize,
-        concat!("Size of: ", stringify!(b))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<b>(),
-        4usize,
-        concat!("Alignment of ", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).val_b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(b), "::", stringify!(val_b))
-    );
-}
diff --git a/tests/expectations/tests/struct_typedef.rs b/tests/expectations/tests/struct_typedef.rs
deleted file mode 100644
index f9d7fedb..00000000
--- a/tests/expectations/tests/struct_typedef.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct typedef_named_struct {
-    pub has_name: bool,
-}
-#[test]
-fn bindgen_test_layout_typedef_named_struct() {
-    const UNINIT: ::std::mem::MaybeUninit<typedef_named_struct> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<typedef_named_struct>(),
-        1usize,
-        concat!("Size of: ", stringify!(typedef_named_struct))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<typedef_named_struct>(),
-        1usize,
-        concat!("Alignment of ", stringify!(typedef_named_struct))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).has_name) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(typedef_named_struct),
-            "::",
-            stringify!(has_name)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct _bindgen_ty_1 {
-    pub no_name: *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).no_name) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(no_name)
-        )
-    );
-}
-impl Default for _bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type struct_ptr_t = *mut _bindgen_ty_1;
-pub type struct_ptr_ptr_t = *mut *mut _bindgen_ty_1;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum typedef_named_enum {
-    ENUM_HAS_NAME = 1,
-}
-pub const ENUM_IS_ANON: _bindgen_ty_2 = _bindgen_ty_2::ENUM_IS_ANON;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum _bindgen_ty_2 {
-    ENUM_IS_ANON = 0,
-}
-pub type enum_ptr_t = *mut _bindgen_ty_2;
-pub type enum_ptr_ptr_t = *mut *mut _bindgen_ty_2;
diff --git a/tests/expectations/tests/struct_typedef_ns.rs b/tests/expectations/tests/struct_typedef_ns.rs
deleted file mode 100644
index 2bad358a..00000000
--- a/tests/expectations/tests/struct_typedef_ns.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod whatever {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct typedef_struct {
-            pub foo: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout_typedef_struct() {
-            const UNINIT: ::std::mem::MaybeUninit<typedef_struct> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<typedef_struct>(),
-                4usize,
-                concat!("Size of: ", stringify!(typedef_struct))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<typedef_struct>(),
-                4usize,
-                concat!("Alignment of ", stringify!(typedef_struct))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(typedef_struct),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-        }
-        #[repr(u32)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub enum typedef_enum {
-            BAR = 1,
-        }
-    }
-    pub mod _bindgen_mod_id_12 {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        #[repr(C)]
-        #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct _bindgen_ty_1 {
-            pub foo: ::std::os::raw::c_int,
-        }
-        #[test]
-        fn bindgen_test_layout__bindgen_ty_1() {
-            const UNINIT: ::std::mem::MaybeUninit<_bindgen_ty_1> =
-                ::std::mem::MaybeUninit::uninit();
-            let ptr = UNINIT.as_ptr();
-            assert_eq!(
-                ::std::mem::size_of::<_bindgen_ty_1>(),
-                4usize,
-                concat!("Size of: ", stringify!(_bindgen_ty_1))
-            );
-            assert_eq!(
-                ::std::mem::align_of::<_bindgen_ty_1>(),
-                4usize,
-                concat!("Alignment of ", stringify!(_bindgen_ty_1))
-            );
-            assert_eq!(
-                unsafe {
-                    ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize
-                },
-                0usize,
-                concat!(
-                    "Offset of field: ",
-                    stringify!(_bindgen_ty_1),
-                    "::",
-                    stringify!(foo)
-                )
-            );
-        }
-        pub type typedef_struct = root::_bindgen_mod_id_12::_bindgen_ty_1;
-        pub const _bindgen_mod_id_12_BAR:
-            root::_bindgen_mod_id_12::_bindgen_ty_2 = _bindgen_ty_2::BAR;
-        #[repr(u32)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub enum _bindgen_ty_2 {
-            BAR = 1,
-        }
-        pub use self::super::super::root::_bindgen_mod_id_12::_bindgen_ty_2 as typedef_enum;
-    }
-}
diff --git a/tests/expectations/tests/struct_with_anon_struct.rs b/tests/expectations/tests/struct_with_anon_struct.rs
deleted file mode 100644
index 238400a1..00000000
--- a/tests/expectations/tests/struct_with_anon_struct.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/struct_with_anon_struct_array.rs b/tests/expectations/tests/struct_with_anon_struct_array.rs
deleted file mode 100644
index f3af6b60..00000000
--- a/tests/expectations/tests/struct_with_anon_struct_array.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: [foo__bindgen_ty_1; 2usize],
-    pub baz: [[[foo__bindgen_ty_2; 4usize]; 3usize]; 2usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_2 {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_2>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_2),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        208usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        16usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(baz))
-    );
-}
diff --git a/tests/expectations/tests/struct_with_anon_struct_pointer.rs b/tests/expectations/tests/struct_with_anon_struct_pointer.rs
deleted file mode 100644
index 5bb10079..00000000
--- a/tests/expectations/tests/struct_with_anon_struct_pointer.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: *mut foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_anon_union.rs b/tests/expectations/tests/struct_with_anon_union.rs
deleted file mode 100644
index 08aab0a9..00000000
--- a/tests/expectations/tests/struct_with_anon_union.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_anon_union_1_0.rs b/tests/expectations/tests/struct_with_anon_union_1_0.rs
deleted file mode 100644
index 8db33d11..00000000
--- a/tests/expectations/tests/struct_with_anon_union_1_0.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/struct_with_anon_unnamed_struct.rs b/tests/expectations/tests/struct_with_anon_unnamed_struct.rs
deleted file mode 100644
index 56981065..00000000
--- a/tests/expectations/tests/struct_with_anon_unnamed_struct.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-}
diff --git a/tests/expectations/tests/struct_with_anon_unnamed_union.rs b/tests/expectations/tests/struct_with_anon_unnamed_union.rs
deleted file mode 100644
index 499fc7a1..00000000
--- a/tests/expectations/tests/struct_with_anon_unnamed_union.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo {
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs b/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
deleted file mode 100644
index 55432d47..00000000
--- a/tests/expectations/tests/struct_with_anon_unnamed_union_1_0.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs
deleted file mode 100644
index a9be3006..00000000
--- a/tests/expectations/tests/struct_with_bitfields.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct bitfield {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub e: ::std::os::raw::c_int,
-    pub _bitfield_align_2: [u32; 0],
-    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 8usize]>,
-}
-#[test]
-fn bindgen_test_layout_bitfield() {
-    const UNINIT: ::std::mem::MaybeUninit<bitfield> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<bitfield>(),
-        16usize,
-        concat!("Size of: ", stringify!(bitfield))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<bitfield>(),
-        4usize,
-        concat!("Alignment of ", stringify!(bitfield))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).e) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(bitfield),
-            "::",
-            stringify!(e)
-        )
-    );
-}
-impl bitfield {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn d(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
-        unsafe {
-            let val: u16 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        a: ::std::os::raw::c_ushort,
-        b: ::std::os::raw::c_ushort,
-        c: ::std::os::raw::c_ushort,
-        d: ::std::os::raw::c_ushort,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let a: u16 = unsafe { ::std::mem::transmute(a) };
-            a as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let b: u16 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let c: u16 = unsafe { ::std::mem::transmute(c) };
-            c as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 2u8, {
-            let d: u16 = unsafe { ::std::mem::transmute(d) };
-            d as u64
-        });
-        __bindgen_bitfield_unit
-    }
-    #[inline]
-    pub fn f(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(0usize, 2u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_f(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_2.set(0usize, 2u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn g(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(32usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_g(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_2.set(32usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_2(
-        f: ::std::os::raw::c_uint,
-        g: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 2u8, {
-            let f: u32 = unsafe { ::std::mem::transmute(f) };
-            f as u64
-        });
-        __bindgen_bitfield_unit.set(32usize, 32u8, {
-            let g: u32 = unsafe { ::std::mem::transmute(g) };
-            g as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/struct_with_derive_debug.rs b/tests/expectations/tests/struct_with_derive_debug.rs
deleted file mode 100644
index 1bb7c77d..00000000
--- a/tests/expectations/tests/struct_with_derive_debug.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct LittleArray {
-    pub a: [::std::os::raw::c_int; 32usize],
-}
-#[test]
-fn bindgen_test_layout_LittleArray() {
-    const UNINIT: ::std::mem::MaybeUninit<LittleArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<LittleArray>(),
-        128usize,
-        concat!("Size of: ", stringify!(LittleArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<LittleArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(LittleArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(LittleArray),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct BigArray {
-    pub a: [::std::os::raw::c_int; 33usize],
-}
-#[test]
-fn bindgen_test_layout_BigArray() {
-    const UNINIT: ::std::mem::MaybeUninit<BigArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<BigArray>(),
-        132usize,
-        concat!("Size of: ", stringify!(BigArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<BigArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(BigArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(BigArray),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for BigArray {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct WithLittleArray {
-    pub a: LittleArray,
-}
-#[test]
-fn bindgen_test_layout_WithLittleArray() {
-    const UNINIT: ::std::mem::MaybeUninit<WithLittleArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithLittleArray>(),
-        128usize,
-        concat!("Size of: ", stringify!(WithLittleArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithLittleArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithLittleArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithLittleArray),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct WithBigArray {
-    pub a: BigArray,
-}
-#[test]
-fn bindgen_test_layout_WithBigArray() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigArray>(),
-        132usize,
-        concat!("Size of: ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Default for WithBigArray {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_large_array.rs b/tests/expectations/tests/struct_with_large_array.rs
deleted file mode 100644
index 9f2c0ecc..00000000
--- a/tests/expectations/tests/struct_with_large_array.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct S {
-    pub large_array: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_S() {
-    const UNINIT: ::std::mem::MaybeUninit<S> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<S>(),
-        33usize,
-        concat!("Size of: ", stringify!(S))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<S>(),
-        1usize,
-        concat!("Alignment of ", stringify!(S))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).large_array) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(S),
-            "::",
-            stringify!(large_array)
-        )
-    );
-}
-impl Default for S {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct ST<T> {
-    pub large_array: [T; 33usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ST<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_nesting.rs b/tests/expectations/tests/struct_with_nesting.rs
deleted file mode 100644
index ff177ff1..00000000
--- a/tests/expectations/tests/struct_with_nesting.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo {
-    pub a: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub b: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
-    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_1 {
-    pub c1: ::std::os::raw::c_ushort,
-    pub c2: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(c1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(c2)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_2 {
-    pub d1: ::std::os::raw::c_uchar,
-    pub d2: ::std::os::raw::c_uchar,
-    pub d3: ::std::os::raw::c_uchar,
-    pub d4: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        1usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d2) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d3) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d3)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d4) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d4)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/struct_with_nesting_1_0.rs b/tests/expectations/tests/struct_with_nesting_1_0.rs
deleted file mode 100644
index af795b64..00000000
--- a/tests/expectations/tests/struct_with_nesting_1_0.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub b: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1__bindgen_ty_1>,
-    pub __bindgen_anon_2: __BindgenUnionField<foo__bindgen_ty_1__bindgen_ty_2>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_1 {
-    pub c1: ::std::os::raw::c_ushort,
-    pub c2: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(c1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(c2)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_2 {
-    pub d1: ::std::os::raw::c_uchar,
-    pub d2: ::std::os::raw::c_uchar,
-    pub d3: ::std::os::raw::c_uchar,
-    pub d4: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        1usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d2) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d2)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d3) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d3)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d4) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(d4)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/struct_with_packing.rs b/tests/expectations/tests/struct_with_packing.rs
deleted file mode 100644
index b8ea17cd..00000000
--- a/tests/expectations/tests/struct_with_packing.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C, packed)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct a {
-    pub b: ::std::os::raw::c_char,
-    pub c: ::std::os::raw::c_short,
-}
-#[test]
-fn bindgen_test_layout_a() {
-    const UNINIT: ::std::mem::MaybeUninit<a> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<a>(),
-        3usize,
-        concat!("Size of: ", stringify!(a))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<a>(),
-        1usize,
-        concat!("Alignment of ", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        1usize,
-        concat!("Offset of field: ", stringify!(a), "::", stringify!(c))
-    );
-}
diff --git a/tests/expectations/tests/struct_with_struct.rs b/tests/expectations/tests/struct_with_struct.rs
deleted file mode 100644
index b1ee5db4..00000000
--- a/tests/expectations/tests/struct_with_struct.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub x: ::std::os::raw::c_uint,
-    pub y: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(x)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(y)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
diff --git a/tests/expectations/tests/struct_with_typedef_template_arg.rs b/tests/expectations/tests/struct_with_typedef_template_arg.rs
deleted file mode 100644
index 49afe559..00000000
--- a/tests/expectations/tests/struct_with_typedef_template_arg.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Proxy {
-    pub _address: u8,
-}
-pub type Proxy_foo<T> =
-    ::std::option::Option<unsafe extern "C" fn(bar: *mut T)>;
diff --git a/tests/expectations/tests/template-fun-ty.rs b/tests/expectations/tests/template-fun-ty.rs
deleted file mode 100644
index a7132cf0..00000000
--- a/tests/expectations/tests/template-fun-ty.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub type Foo_FunctionPtr<T> =
-    ::std::option::Option<unsafe extern "C" fn() -> T>;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct RefPtr {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct RefPtr_Proxy {
-    pub _address: u8,
-}
-pub type RefPtr_Proxy_member_function<R, Args> =
-    ::std::option::Option<unsafe extern "C" fn(arg1: Args) -> R>;
-pub type Returner<T> = ::std::option::Option<unsafe extern "C" fn() -> T>;
diff --git a/tests/expectations/tests/template-param-usage-0.rs b/tests/expectations/tests/template-param-usage-0.rs
deleted file mode 100644
index 2acfb069..00000000
--- a/tests/expectations/tests/template-param-usage-0.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for UsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-1.rs b/tests/expectations/tests/template-param-usage-1.rs
deleted file mode 100644
index 4fc227c9..00000000
--- a/tests/expectations/tests/template-param-usage-1.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct DoesNotUseTemplateParameter {
-    pub x: ::std::os::raw::c_int,
-}
diff --git a/tests/expectations/tests/template-param-usage-10.rs b/tests/expectations/tests/template-param-usage-10.rs
deleted file mode 100644
index c6034fb8..00000000
--- a/tests/expectations/tests/template-param-usage-10.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DoublyIndirectUsage<T, U> {
-    pub doubly_indirect: DoublyIndirectUsage_IndirectUsage<T, U>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-pub type DoublyIndirectUsage_Aliased<T> = T;
-pub type DoublyIndirectUsage_Typedefed<U> = U;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DoublyIndirectUsage_IndirectUsage<T, U> {
-    pub member: DoublyIndirectUsage_Aliased<T>,
-    pub another: DoublyIndirectUsage_Typedefed<U>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<T, U> Default for DoublyIndirectUsage_IndirectUsage<T, U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T, U> Default for DoublyIndirectUsage<T, U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-11.rs b/tests/expectations/tests/template-param-usage-11.rs
deleted file mode 100644
index 63a31e23..00000000
--- a/tests/expectations/tests/template-param-usage-11.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct DoesNotUseT {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/template-param-usage-12.rs b/tests/expectations/tests/template-param-usage-12.rs
deleted file mode 100644
index 626e451a..00000000
--- a/tests/expectations/tests/template-param-usage-12.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct BaseUsesT<T> {
-    pub t: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for BaseUsesT<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct CrtpUsesU<U> {
-    pub _base: BaseUsesT<CrtpUsesU<U>>,
-    pub usage: U,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<U> Default for CrtpUsesU<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-13.rs b/tests/expectations/tests/template-param-usage-13.rs
deleted file mode 100644
index 70c1778b..00000000
--- a/tests/expectations/tests/template-param-usage-13.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct BaseIgnoresT {
-    pub x: ::std::os::raw::c_int,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct CrtpUsesU<U> {
-    pub _base: BaseIgnoresT,
-    pub usage: U,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<U> Default for CrtpUsesU<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-14.rs b/tests/expectations/tests/template-param-usage-14.rs
deleted file mode 100644
index 0e0fd0c9..00000000
--- a/tests/expectations/tests/template-param-usage-14.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct BaseIgnoresT {
-    pub x: ::std::os::raw::c_int,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct CrtpIgnoresU {
-    pub _base: BaseIgnoresT,
-    pub y: ::std::os::raw::c_int,
-}
-impl Default for CrtpIgnoresU {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-15.rs b/tests/expectations/tests/template-param-usage-15.rs
deleted file mode 100644
index 941c6073..00000000
--- a/tests/expectations/tests/template-param-usage-15.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct BaseUsesT<T> {
-    pub usage: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for BaseUsesT<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct CrtpIgnoresU {
-    pub _base: BaseUsesT<CrtpIgnoresU>,
-    pub y: ::std::os::raw::c_int,
-}
-impl Default for CrtpIgnoresU {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-2.rs b/tests/expectations/tests/template-param-usage-2.rs
deleted file mode 100644
index 0ad5d7bb..00000000
--- a/tests/expectations/tests/template-param-usage-2.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter_AlsoUsesTemplateParameter<T> {
-    pub also: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for UsesTemplateParameter_AlsoUsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> Default for UsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-3.rs b/tests/expectations/tests/template-param-usage-3.rs
deleted file mode 100644
index 414818d9..00000000
--- a/tests/expectations/tests/template-param-usage-3.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter_AlsoUsesTemplateParameterAndMore<T, U> {
-    pub also: T,
-    pub more: U,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<T, U> Default
-    for UsesTemplateParameter_AlsoUsesTemplateParameterAndMore<T, U>
-{
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl<T> Default for UsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-4.rs b/tests/expectations/tests/template-param-usage-4.rs
deleted file mode 100644
index afcba978..00000000
--- a/tests/expectations/tests/template-param-usage-4.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct UsesTemplateParameter<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct UsesTemplateParameter_DoesNotUseTemplateParameters {
-    pub x: ::std::os::raw::c_int,
-}
-impl<T> Default for UsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-5.rs b/tests/expectations/tests/template-param-usage-5.rs
deleted file mode 100644
index 2cc8db6f..00000000
--- a/tests/expectations/tests/template-param-usage-5.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct IndirectlyUsesTemplateParameter<T> {
-    pub aliased: IndirectlyUsesTemplateParameter_Aliased<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-pub type IndirectlyUsesTemplateParameter_Aliased<T> = T;
-impl<T> Default for IndirectlyUsesTemplateParameter<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-6.rs b/tests/expectations/tests/template-param-usage-6.rs
deleted file mode 100644
index 3c0e5152..00000000
--- a/tests/expectations/tests/template-param-usage-6.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct DoesNotUseTemplateParameter {
-    pub x: ::std::os::raw::c_int,
-}
-pub type DoesNotUseTemplateParameter_ButAliasDoesUseIt<T> = T;
diff --git a/tests/expectations/tests/template-param-usage-7.rs b/tests/expectations/tests/template-param-usage-7.rs
deleted file mode 100644
index 3ed7a45d..00000000
--- a/tests/expectations/tests/template-param-usage-7.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DoesNotUseU<T, V> {
-    pub t: T,
-    pub v: V,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<V>>,
-}
-impl<T, V> Default for DoesNotUseU<T, V> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type Alias = DoesNotUseU<::std::os::raw::c_int, ::std::os::raw::c_char>;
diff --git a/tests/expectations/tests/template-param-usage-8.rs b/tests/expectations/tests/template-param-usage-8.rs
deleted file mode 100644
index f8ac6714..00000000
--- a/tests/expectations/tests/template-param-usage-8.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct IndirectUsage<T, U> {
-    pub member1: IndirectUsage_Typedefed<T>,
-    pub member2: IndirectUsage_Aliased<U>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-pub type IndirectUsage_Typedefed<T> = T;
-pub type IndirectUsage_Aliased<U> = U;
-impl<T, U> Default for IndirectUsage<T, U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-param-usage-9.rs b/tests/expectations/tests/template-param-usage-9.rs
deleted file mode 100644
index a50079a2..00000000
--- a/tests/expectations/tests/template-param-usage-9.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct DoesNotUse {
-    pub _address: u8,
-}
-pub type DoesNotUse_Aliased<T> = T;
-pub type DoesNotUse_Typedefed<U> = U;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DoesNotUse_IndirectUsage<T, U> {
-    pub member: DoesNotUse_Aliased<T>,
-    pub another: DoesNotUse_Typedefed<U>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-    pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<T, U> Default for DoesNotUse_IndirectUsage<T, U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template-with-var.rs b/tests/expectations/tests/template-with-var.rs
deleted file mode 100644
index 0476a256..00000000
--- a/tests/expectations/tests/template-with-var.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TemplateWithVar {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/template.rs b/tests/expectations/tests/template.rs
deleted file mode 100644
index 7637295a..00000000
--- a/tests/expectations/tests/template.rs
+++ /dev/null
@@ -1,995 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct Foo<T> {
-    pub m_member: T,
-    pub m_member_ptr: *mut T,
-    pub m_member_arr: [T; 1usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Foo<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct B<T> {
-    pub m_member: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for B<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_Z3bar3FooIiiE"]
-    pub fn bar(foo: Foo<::std::os::raw::c_int>);
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct mozilla_Foo {
-    _unused: [u8; 0],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct C {
-    pub mB: B<::std::os::raw::c_uint>,
-    pub mBConstPtr: B<*const ::std::os::raw::c_int>,
-    pub mBConstStructPtr: B<*const mozilla_Foo>,
-    pub mBConstStructPtrArray: B<[*const mozilla_Foo; 1usize]>,
-    pub mBConst: B<::std::os::raw::c_int>,
-    pub mBVolatile: B<::std::os::raw::c_int>,
-    pub mBConstBool: B<bool>,
-    pub mBConstChar: B<u16>,
-    pub mBArray: B<[::std::os::raw::c_int; 1usize]>,
-    pub mBPtrArray: B<[*mut ::std::os::raw::c_int; 1usize]>,
-    pub mBArrayPtr: B<*mut [::std::os::raw::c_int; 1usize]>,
-    pub mBRef: B<*mut ::std::os::raw::c_int>,
-    pub mBConstRef: B<*const ::std::os::raw::c_int>,
-    pub mPtrRef: B<*mut *mut ::std::os::raw::c_int>,
-    pub mArrayRef: B<*mut [::std::os::raw::c_int; 1usize]>,
-    pub mBConstArray: B<[::std::os::raw::c_int; 1usize]>,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        104usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        8usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mB) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(mB))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstPtr) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstPtr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstStructPtr) as usize -
-                ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstStructPtr)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstStructPtrArray) as usize -
-                ptr as usize
-        },
-        24usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstStructPtrArray)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBConst) as usize - ptr as usize },
-        32usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConst)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBVolatile) as usize - ptr as usize
-        },
-        36usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBVolatile)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstBool) as usize - ptr as usize
-        },
-        40usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstBool)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstChar) as usize - ptr as usize
-        },
-        42usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstChar)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBArray) as usize - ptr as usize },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBArray)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBPtrArray) as usize - ptr as usize
-        },
-        48usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBPtrArray)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBArrayPtr) as usize - ptr as usize
-        },
-        56usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBArrayPtr)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBRef) as usize - ptr as usize },
-        64usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(mBRef))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstRef) as usize - ptr as usize
-        },
-        72usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstRef)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mPtrRef) as usize - ptr as usize },
-        80usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mPtrRef)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mArrayRef) as usize - ptr as usize
-        },
-        88usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mArrayRef)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mBConstArray) as usize - ptr as usize
-        },
-        96usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(C),
-            "::",
-            stringify!(mBConstArray)
-        )
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct D {
-    pub m_foo: D_MyFoo,
-}
-pub type D_MyFoo = Foo<::std::os::raw::c_int>;
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct D_U<Z> {
-    pub m_nested_foo: D_MyFoo,
-    pub m_baz: Z,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<Z>>,
-}
-impl<Z> Default for D_U<Z> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for D {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Rooted<T> {
-    pub prev: *mut T,
-    pub next: *mut Rooted<*mut ::std::os::raw::c_void>,
-    pub ptr: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct RootedContainer {
-    pub root: Rooted<*mut ::std::os::raw::c_void>,
-}
-#[test]
-fn bindgen_test_layout_RootedContainer() {
-    const UNINIT: ::std::mem::MaybeUninit<RootedContainer> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<RootedContainer>(),
-        24usize,
-        concat!("Size of: ", stringify!(RootedContainer))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<RootedContainer>(),
-        8usize,
-        concat!("Alignment of ", stringify!(RootedContainer))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(RootedContainer),
-            "::",
-            stringify!(root)
-        )
-    );
-}
-impl Default for RootedContainer {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type WithDtorIntFwd = WithDtor<::std::os::raw::c_int>;
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct WithDtor<T> {
-    pub member: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for WithDtor<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct PODButContainsDtor {
-    pub member: WithDtorIntFwd,
-}
-#[test]
-fn bindgen_test_layout_PODButContainsDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<PODButContainsDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<PODButContainsDtor>(),
-        4usize,
-        concat!("Size of: ", stringify!(PODButContainsDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PODButContainsDtor>(),
-        4usize,
-        concat!("Alignment of ", stringify!(PODButContainsDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).member) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(PODButContainsDtor),
-            "::",
-            stringify!(member)
-        )
-    );
-}
-impl Default for PODButContainsDtor {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// <div rustbindgen opaque>
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Opaque {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct POD {
-    pub opaque_member: u32,
-}
-#[test]
-fn bindgen_test_layout_POD() {
-    const UNINIT: ::std::mem::MaybeUninit<POD> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<POD>(),
-        4usize,
-        concat!("Size of: ", stringify!(POD))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<POD>(),
-        4usize,
-        concat!("Alignment of ", stringify!(POD))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).opaque_member) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(POD),
-            "::",
-            stringify!(opaque_member)
-        )
-    );
-}
-/// <div rustbindgen replaces="NestedReplaced"></div>
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NestedReplaced<T> {
-    pub buff: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for NestedReplaced<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NestedBase<T> {
-    pub buff: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for NestedBase<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NestedContainer<T> {
-    pub c: T,
-    pub nested: NestedReplaced<T>,
-    pub inc: Incomplete<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for NestedContainer<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Incomplete<T> {
-    pub d: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Incomplete<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Untemplated {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Untemplated() {
-    assert_eq!(
-        ::std::mem::size_of::<Untemplated>(),
-        1usize,
-        concat!("Size of: ", stringify!(Untemplated))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Untemplated>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Untemplated))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Templated {
-    pub m_untemplated: Untemplated,
-}
-/// If the replacement doesn't happen at the parse level the container would be
-/// copy and the replacement wouldn't, so this wouldn't compile.
-///
-/// <div rustbindgen replaces="ReplacedWithoutDestructor"></div>
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ReplacedWithoutDestructor<T> {
-    pub buff: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ReplacedWithoutDestructor<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ShouldNotBeCopiable<T> {
-    pub m_member: ReplacedWithoutDestructor<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ShouldNotBeCopiable<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ShouldNotBeCopiableAsWell<U> {
-    pub m_member: ReplacedWithoutDestructorFwd<U>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<U>>,
-}
-impl<U> Default for ShouldNotBeCopiableAsWell<U> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-/// If the replacement doesn't happen at the parse level the container would be
-/// copy and the replacement wouldn't, so this wouldn't compile.
-///
-/// <div rustbindgen replaces="ReplacedWithoutDestructorFwd"></div>
-#[repr(C)]
-#[derive(Debug, Hash, PartialEq, Eq)]
-pub struct ReplacedWithoutDestructorFwd<T> {
-    pub buff: *mut T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for ReplacedWithoutDestructorFwd<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_Foo_open0_int_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo<::std::os::raw::c_int>>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(Foo<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo<::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(Foo<::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_unsigned_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<::std::os::raw::c_uint>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<::std::os::raw::c_uint>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<::std::os::raw::c_uint>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<::std::os::raw::c_uint>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ptr_const_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*const ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*const ::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*const ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*const ::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ptr_const_mozilla__Foo_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*const mozilla_Foo>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*const mozilla_Foo>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*const mozilla_Foo>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*const mozilla_Foo>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_array1_ptr_const_mozilla__Foo_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<B<[*const mozilla_Foo; 1usize]>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<[*const mozilla_Foo; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<[*const mozilla_Foo; 1usize]>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<[*const mozilla_Foo; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_const_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_volatile_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_const_bool_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<bool>>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(B<bool>))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<bool>>(),
-        1usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<bool>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_const_char16_t_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<u16>>(),
-        2usize,
-        concat!("Size of template specialization: ", stringify!(B<u16>))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<u16>>(),
-        2usize,
-        concat!("Alignment of template specialization: ", stringify!(B<u16>))
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_array1_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<[::std::os::raw::c_int; 1usize]>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<[::std::os::raw::c_int; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<[::std::os::raw::c_int; 1usize]>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<[::std::os::raw::c_int; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_array1_ptr_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<[*mut ::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<[*mut ::std::os::raw::c_int; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<[*mut ::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<[*mut ::std::os::raw::c_int; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ptr_array1_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ref_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*mut ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*mut ::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*mut ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*mut ::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ref_const_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*const ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*const ::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*const ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*const ::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ref_ptr_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*mut *mut ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*mut *mut ::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*mut *mut ::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*mut *mut ::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_ref_array1_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<*mut [::std::os::raw::c_int; 1usize]>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<*mut [::std::os::raw::c_int; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_B_open0_array1_const_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<B<[::std::os::raw::c_int; 1usize]>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(B<[::std::os::raw::c_int; 1usize]>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B<[::std::os::raw::c_int; 1usize]>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(B<[::std::os::raw::c_int; 1usize]>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_Foo_open0_int_int_close0_instantiation_1() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo<::std::os::raw::c_int>>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(Foo<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo<::std::os::raw::c_int>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(Foo<::std::os::raw::c_int>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_Rooted_open0_ptr_void_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(Rooted<*mut ::std::os::raw::c_void>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(Rooted<*mut ::std::os::raw::c_void>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_Rooted_open0_ptr_void_close0_instantiation_1() {
-    assert_eq!(
-        ::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>(),
-        24usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(Rooted<*mut ::std::os::raw::c_void>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(Rooted<*mut ::std::os::raw::c_void>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_WithDtor_open0_int_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<WithDtor<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(WithDtor<::std::os::raw::c_int>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDtor<::std::os::raw::c_int>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(WithDtor<::std::os::raw::c_int>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/template_alias.rs b/tests/expectations/tests/template_alias.rs
deleted file mode 100644
index 7e0af20d..00000000
--- a/tests/expectations/tests/template_alias.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type JS_detail_Wrapped<T> = T;
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct JS_Rooted<T> {
-    pub ptr: JS_detail_Wrapped<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for JS_Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/template_alias_basic.rs b/tests/expectations/tests/template_alias_basic.rs
deleted file mode 100644
index e06ffada..00000000
--- a/tests/expectations/tests/template_alias_basic.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type Wrapped<T> = T;
diff --git a/tests/expectations/tests/template_alias_namespace.rs b/tests/expectations/tests/template_alias_namespace.rs
deleted file mode 100644
index 7196b532..00000000
--- a/tests/expectations/tests/template_alias_namespace.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    pub mod JS {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-        pub mod detail {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-            pub type Wrapped<T> = T;
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        pub struct Rooted<T> {
-            pub ptr: root::JS::detail::Wrapped<T>,
-            pub _phantom_0:
-                ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-        }
-        impl<T> Default for Rooted<T> {
-            fn default() -> Self {
-                let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-                unsafe {
-                    ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                    s.assume_init()
-                }
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/template_fun.rs b/tests/expectations/tests/template_fun.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/template_fun.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/template_instantiation_with_fn_local_type.rs b/tests/expectations/tests/template_instantiation_with_fn_local_type.rs
deleted file mode 100644
index d968e71b..00000000
--- a/tests/expectations/tests/template_instantiation_with_fn_local_type.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_Z1fv"]
-    pub fn f();
-}
-#[test]
-fn __bindgen_test_layout_Foo_open0_Bar_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(Foo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Baz {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        1usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-}
-#[test]
-fn __bindgen_test_layout_Foo_open0_Boo_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of template specialization: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of template specialization: ", stringify!(Foo))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Boo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Boo() {
-    assert_eq!(
-        ::std::mem::size_of::<Boo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Boo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Boo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Boo))
-    );
-}
diff --git a/tests/expectations/tests/template_partial_specification.rs b/tests/expectations/tests/template_partial_specification.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/template_partial_specification.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/template_typedef_transitive_param.rs b/tests/expectations/tests/template_typedef_transitive_param.rs
deleted file mode 100644
index 68ca126a..00000000
--- a/tests/expectations/tests/template_typedef_transitive_param.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Wrapper {
-    pub _address: u8,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Wrapper_Wrapped<T> {
-    pub t: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Wrapper_Wrapped<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type Wrapper_Type<T> = Wrapper_Wrapped<T>;
diff --git a/tests/expectations/tests/template_typedefs.rs b/tests/expectations/tests/template_typedefs.rs
deleted file mode 100644
index 3883879d..00000000
--- a/tests/expectations/tests/template_typedefs.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type foo =
-    ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-pub type Foo_Char<T> = T;
-pub type Foo_FooPtrTypedef<T> = *mut Foo_Char<T>;
-pub type Foo_nsCOMArrayEnumFunc<T> = ::std::option::Option<
-    unsafe extern "C" fn(
-        aElement: *mut T,
-        aData: *mut ::std::os::raw::c_void,
-    ) -> bool,
->;
diff --git a/tests/expectations/tests/templateref_opaque.rs b/tests/expectations/tests/templateref_opaque.rs
deleted file mode 100644
index 70cef867..00000000
--- a/tests/expectations/tests/templateref_opaque.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct detail_PointerType {
-    pub _address: u8,
-}
-pub type detail_PointerType_Type<T> = *mut T;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct UniquePtr {
-    pub _address: u8,
-}
-pub type UniquePtr_Pointer = detail_PointerType;
diff --git a/tests/expectations/tests/templatized-bitfield.rs b/tests/expectations/tests/templatized-bitfield.rs
deleted file mode 100644
index 5657a655..00000000
--- a/tests/expectations/tests/templatized-bitfield.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-/// We don't get a layout for this bitfield, since we don't know what `T` will
-/// be, so we cannot allocate bitfield units. The best thing we can do is make
-/// the struct opaque.
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TemplatizedBitfield {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/test_mixed_header_and_header_contents.rs b/tests/expectations/tests/test_mixed_header_and_header_contents.rs
deleted file mode 100644
index 5f8da2af..00000000
--- a/tests/expectations/tests/test_mixed_header_and_header_contents.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-extern "C" {
-    pub static mut foo: ::std::option::Option<
-        unsafe extern "C" fn(
-            x: ::std::os::raw::c_int,
-            y: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-    >;
-}
-extern "C" {
-    pub fn bar(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn bar2(b: *const ::std::os::raw::c_char) -> f32;
-}
-pub type Char = ::std::os::raw::c_char;
-pub type SChar = ::std::os::raw::c_schar;
-pub type UChar = ::std::os::raw::c_uchar;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Test {
-    pub ch: ::std::os::raw::c_char,
-    pub u: ::std::os::raw::c_uchar,
-    pub d: ::std::os::raw::c_schar,
-    pub cch: ::std::os::raw::c_char,
-    pub cu: ::std::os::raw::c_uchar,
-    pub cd: ::std::os::raw::c_schar,
-    pub Cch: Char,
-    pub Cu: UChar,
-    pub Cd: SChar,
-    pub Ccch: Char,
-    pub Ccu: UChar,
-    pub Ccd: SChar,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        12usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        1usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        2usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
-        3usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
-        5usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
-        6usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
-        7usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Test),
-            "::",
-            stringify!(Ccch)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
-        10usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
-        11usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
-    );
-}
diff --git a/tests/expectations/tests/test_multiple_header_calls_in_builder.rs b/tests/expectations/tests/test_multiple_header_calls_in_builder.rs
deleted file mode 100644
index b594d70c..00000000
--- a/tests/expectations/tests/test_multiple_header_calls_in_builder.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-extern "C" {
-    pub static mut foo: ::std::option::Option<
-        unsafe extern "C" fn(
-            x: ::std::os::raw::c_int,
-            y: ::std::os::raw::c_int,
-        ) -> ::std::os::raw::c_int,
-    >;
-}
-pub type Char = ::std::os::raw::c_char;
-pub type SChar = ::std::os::raw::c_schar;
-pub type UChar = ::std::os::raw::c_uchar;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Test {
-    pub ch: ::std::os::raw::c_char,
-    pub u: ::std::os::raw::c_uchar,
-    pub d: ::std::os::raw::c_schar,
-    pub cch: ::std::os::raw::c_char,
-    pub cu: ::std::os::raw::c_uchar,
-    pub cd: ::std::os::raw::c_schar,
-    pub Cch: Char,
-    pub Cu: UChar,
-    pub Cd: SChar,
-    pub Ccch: Char,
-    pub Ccu: UChar,
-    pub Ccd: SChar,
-}
-#[test]
-fn bindgen_test_layout_Test() {
-    const UNINIT: ::std::mem::MaybeUninit<Test> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Test>(),
-        12usize,
-        concat!("Size of: ", stringify!(Test))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Test>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Test))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(ch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
-        1usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(u))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
-        2usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(d))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cch) as usize - ptr as usize },
-        3usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cu) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).cd) as usize - ptr as usize },
-        5usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cch) as usize - ptr as usize },
-        6usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cch))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cu) as usize - ptr as usize },
-        7usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Cd) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Cd))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccch) as usize - ptr as usize },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Test),
-            "::",
-            stringify!(Ccch)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccu) as usize - ptr as usize },
-        10usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccu))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).Ccd) as usize - ptr as usize },
-        11usize,
-        concat!("Offset of field: ", stringify!(Test), "::", stringify!(Ccd))
-    );
-}
diff --git a/tests/expectations/tests/timex.rs b/tests/expectations/tests/timex.rs
deleted file mode 100644
index dfcebdd2..00000000
--- a/tests/expectations/tests/timex.rs
+++ /dev/null
@@ -1,322 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct timex {
-    pub tai: ::std::os::raw::c_int,
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
-}
-#[test]
-fn bindgen_test_layout_timex() {
-    const UNINIT: ::std::mem::MaybeUninit<timex> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<timex>(),
-        48usize,
-        concat!("Size of: ", stringify!(timex))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<timex>(),
-        4usize,
-        concat!("Alignment of ", stringify!(timex))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tai) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(timex),
-            "::",
-            stringify!(tai)
-        )
-    );
-}
-impl Default for timex {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct timex_named {
-    pub tai: ::std::os::raw::c_int,
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
-}
-#[test]
-fn bindgen_test_layout_timex_named() {
-    const UNINIT: ::std::mem::MaybeUninit<timex_named> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<timex_named>(),
-        48usize,
-        concat!("Size of: ", stringify!(timex_named))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<timex_named>(),
-        4usize,
-        concat!("Alignment of ", stringify!(timex_named))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).tai) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(timex_named),
-            "::",
-            stringify!(tai)
-        )
-    );
-}
-impl Default for timex_named {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl timex_named {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(32usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(64usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(64usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn d(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(96usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_d(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(96usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn e(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(128usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_e(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(128usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn f(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(160usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_f(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(160usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn g(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(192usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_g(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(192usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn h(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(224usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_h(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(224usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn i(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(256usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_i(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(256usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn j(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(288usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_j(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(288usize, 32u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn k(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(320usize, 32u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_k(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(320usize, 32u8, val as u64)
-        }
-    }
-}
diff --git a/tests/expectations/tests/transform-op.rs b/tests/expectations/tests/transform-op.rs
deleted file mode 100644
index 84a94603..00000000
--- a/tests/expectations/tests/transform-op.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StylePoint<T> {
-    pub x: T,
-    pub y: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StylePoint<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct StyleFoo<T> {
-    pub __bindgen_anon_1: __BindgenUnionField<StyleFoo__bindgen_ty_1>,
-    pub foo: __BindgenUnionField<StyleFoo_Foo_Body<T>>,
-    pub bar: __BindgenUnionField<StyleFoo_Bar_Body<T>>,
-    pub baz: __BindgenUnionField<StyleFoo_Baz_Body<T>>,
-    pub bindgen_union_field: [u8; 0usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-pub const StyleFoo_Tag_Foo: StyleFoo_Tag = 0;
-pub const StyleFoo_Tag_Bar: StyleFoo_Tag = 0;
-pub const StyleFoo_Tag_Baz: StyleFoo_Tag = 0;
-pub const StyleFoo_Tag_Bazz: StyleFoo_Tag = 0;
-pub type StyleFoo_Tag = u8;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleFoo_Foo_Body<T> {
-    pub tag: StyleFoo_Tag,
-    pub x: i32,
-    pub y: StylePoint<T>,
-    pub z: StylePoint<f32>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleFoo_Foo_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleFoo_Bar_Body<T> {
-    pub tag: StyleFoo_Tag,
-    pub _0: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleFoo_Bar_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleFoo_Baz_Body<T> {
-    pub tag: StyleFoo_Tag,
-    pub _0: StylePoint<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleFoo_Baz_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleFoo__bindgen_ty_1 {
-    pub tag: StyleFoo_Tag,
-}
-impl Default for StyleFoo__bindgen_ty_1 {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleBar<T> {
-    pub tag: StyleBar_Tag,
-    pub __bindgen_anon_1: StyleBar__bindgen_ty_1<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-pub const StyleBar_Tag_Bar1: StyleBar_Tag = 0;
-pub const StyleBar_Tag_Bar2: StyleBar_Tag = 0;
-pub const StyleBar_Tag_Bar3: StyleBar_Tag = 0;
-pub const StyleBar_Tag_Bar4: StyleBar_Tag = 0;
-pub type StyleBar_Tag = ::std::os::raw::c_int;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleBar_StyleBar1_Body<T> {
-    pub x: i32,
-    pub y: StylePoint<T>,
-    pub z: StylePoint<f32>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleBar_StyleBar1_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleBar_StyleBar2_Body<T> {
-    pub _0: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleBar_StyleBar2_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StyleBar_StyleBar3_Body<T> {
-    pub _0: StylePoint<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleBar_StyleBar3_Body<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct StyleBar__bindgen_ty_1<T> {
-    pub bar1: __BindgenUnionField<StyleBar_StyleBar1_Body<T>>,
-    pub bar2: __BindgenUnionField<StyleBar_StyleBar2_Body<T>>,
-    pub bar3: __BindgenUnionField<StyleBar_StyleBar3_Body<T>>,
-    pub bindgen_union_field: [u8; 0usize],
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for StyleBar<T> {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_StylePoint_open0_float_close0_instantiation() {
-    assert_eq!(
-        ::std::mem::size_of::<StylePoint<f32>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(StylePoint<f32>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StylePoint<f32>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(StylePoint<f32>)
-        )
-    );
-}
-#[test]
-fn __bindgen_test_layout_StylePoint_open0_float_close0_instantiation_1() {
-    assert_eq!(
-        ::std::mem::size_of::<StylePoint<f32>>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(StylePoint<f32>)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StylePoint<f32>>(),
-        4usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(StylePoint<f32>)
-        )
-    );
-}
diff --git a/tests/expectations/tests/type-referenced-by-allowlisted-function.rs b/tests/expectations/tests/type-referenced-by-allowlisted-function.rs
deleted file mode 100644
index 7ae042bc..00000000
--- a/tests/expectations/tests/type-referenced-by-allowlisted-function.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct dl_phdr_info {
-    pub x: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_dl_phdr_info() {
-    const UNINIT: ::std::mem::MaybeUninit<dl_phdr_info> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<dl_phdr_info>(),
-        4usize,
-        concat!("Size of: ", stringify!(dl_phdr_info))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<dl_phdr_info>(),
-        4usize,
-        concat!("Alignment of ", stringify!(dl_phdr_info))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dl_phdr_info),
-            "::",
-            stringify!(x)
-        )
-    );
-}
-extern "C" {
-    pub fn dl_iterate_phdr(arg1: *mut dl_phdr_info) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/type_alias_empty.rs b/tests/expectations/tests/type_alias_empty.rs
deleted file mode 100644
index cb871a33..00000000
--- a/tests/expectations/tests/type_alias_empty.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type bool_constant = u8;
diff --git a/tests/expectations/tests/type_alias_partial_template_especialization.rs b/tests/expectations/tests/type_alias_partial_template_especialization.rs
deleted file mode 100644
index 44449f20..00000000
--- a/tests/expectations/tests/type_alias_partial_template_especialization.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type MaybeWrapped<A> = A;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Rooted<T> {
-    pub ptr: MaybeWrapped<T>,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Rooted<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/typedefd-array-as-function-arg.rs b/tests/expectations/tests/typedefd-array-as-function-arg.rs
deleted file mode 100644
index 330499b8..00000000
--- a/tests/expectations/tests/typedefd-array-as-function-arg.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub type myVector3 = [f32; 3usize];
-extern "C" {
-    pub fn modifyVectorFunc(v: *mut f32);
-}
diff --git a/tests/expectations/tests/typeref.rs b/tests/expectations/tests/typeref.rs
deleted file mode 100644
index a3a31daf..00000000
--- a/tests/expectations/tests/typeref.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct mozilla_FragmentOrURL {
-    pub mIsLocalRef: bool,
-}
-#[test]
-fn bindgen_test_layout_mozilla_FragmentOrURL() {
-    const UNINIT: ::std::mem::MaybeUninit<mozilla_FragmentOrURL> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_FragmentOrURL>(),
-        1usize,
-        concat!("Size of: ", stringify!(mozilla_FragmentOrURL))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_FragmentOrURL>(),
-        1usize,
-        concat!("Alignment of ", stringify!(mozilla_FragmentOrURL))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsLocalRef) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(mozilla_FragmentOrURL),
-            "::",
-            stringify!(mIsLocalRef)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct mozilla_Position {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_mozilla_Position() {
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_Position>(),
-        1usize,
-        concat!("Size of: ", stringify!(mozilla_Position))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_Position>(),
-        1usize,
-        concat!("Alignment of ", stringify!(mozilla_Position))
-    );
-}
-#[repr(C)]
-pub struct mozilla_StyleShapeSource {
-    pub __bindgen_anon_1: mozilla_StyleShapeSource__bindgen_ty_1,
-}
-#[repr(C)]
-pub union mozilla_StyleShapeSource__bindgen_ty_1 {
-    pub mPosition: *mut mozilla_Position,
-    pub mFragmentOrURL: *mut mozilla_FragmentOrURL,
-}
-impl Default for mozilla_StyleShapeSource__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for mozilla_StyleShapeSource {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Bar {
-    pub mFoo: *mut nsFoo,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(mFoo))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct nsFoo {
-    pub mBar: mozilla_StyleShapeSource,
-}
-#[test]
-fn bindgen_test_layout_nsFoo() {
-    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsFoo>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsFoo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsFoo),
-            "::",
-            stringify!(mBar)
-        )
-    );
-}
-impl Default for nsFoo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn __bindgen_test_layout_mozilla_StyleShapeSource_open0_int_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_StyleShapeSource>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(mozilla_StyleShapeSource)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_StyleShapeSource>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(mozilla_StyleShapeSource)
-        )
-    );
-}
diff --git a/tests/expectations/tests/typeref_1_0.rs b/tests/expectations/tests/typeref_1_0.rs
deleted file mode 100644
index 8e4143c0..00000000
--- a/tests/expectations/tests/typeref_1_0.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct mozilla_FragmentOrURL {
-    pub mIsLocalRef: bool,
-}
-#[test]
-fn bindgen_test_layout_mozilla_FragmentOrURL() {
-    const UNINIT: ::std::mem::MaybeUninit<mozilla_FragmentOrURL> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_FragmentOrURL>(),
-        1usize,
-        concat!("Size of: ", stringify!(mozilla_FragmentOrURL))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_FragmentOrURL>(),
-        1usize,
-        concat!("Alignment of ", stringify!(mozilla_FragmentOrURL))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mIsLocalRef) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(mozilla_FragmentOrURL),
-            "::",
-            stringify!(mIsLocalRef)
-        )
-    );
-}
-impl Clone for mozilla_FragmentOrURL {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct mozilla_Position {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_mozilla_Position() {
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_Position>(),
-        1usize,
-        concat!("Size of: ", stringify!(mozilla_Position))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_Position>(),
-        1usize,
-        concat!("Alignment of ", stringify!(mozilla_Position))
-    );
-}
-impl Clone for mozilla_Position {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct mozilla_StyleShapeSource {
-    pub __bindgen_anon_1: mozilla_StyleShapeSource__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct mozilla_StyleShapeSource__bindgen_ty_1 {
-    pub mPosition: __BindgenUnionField<*mut mozilla_Position>,
-    pub mFragmentOrURL: __BindgenUnionField<*mut mozilla_FragmentOrURL>,
-    pub bindgen_union_field: u64,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct Bar {
-    pub mFoo: *mut nsFoo,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        8usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(mFoo))
-    );
-}
-impl Clone for Bar {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for Bar {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct nsFoo {
-    pub mBar: mozilla_StyleShapeSource,
-}
-#[test]
-fn bindgen_test_layout_nsFoo() {
-    const UNINIT: ::std::mem::MaybeUninit<nsFoo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsFoo>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsFoo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsFoo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsFoo),
-            "::",
-            stringify!(mBar)
-        )
-    );
-}
-impl Clone for nsFoo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn __bindgen_test_layout_mozilla_StyleShapeSource_open0_int_close0_instantiation(
-) {
-    assert_eq!(
-        ::std::mem::size_of::<mozilla_StyleShapeSource>(),
-        8usize,
-        concat!(
-            "Size of template specialization: ",
-            stringify!(mozilla_StyleShapeSource)
-        )
-    );
-    assert_eq!(
-        ::std::mem::align_of::<mozilla_StyleShapeSource>(),
-        8usize,
-        concat!(
-            "Alignment of template specialization: ",
-            stringify!(mozilla_StyleShapeSource)
-        )
-    );
-}
diff --git a/tests/expectations/tests/underscore.rs b/tests/expectations/tests/underscore.rs
deleted file mode 100644
index bfc05ac1..00000000
--- a/tests/expectations/tests/underscore.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-pub const __: ::std::os::raw::c_int = 10;
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct ptr_t {
-    pub __: [::std::os::raw::c_uchar; 8usize],
-}
-#[test]
-fn bindgen_test_layout_ptr_t() {
-    const UNINIT: ::std::mem::MaybeUninit<ptr_t> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ptr_t>(),
-        8usize,
-        concat!("Size of: ", stringify!(ptr_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ptr_t>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ptr_t))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).__) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(ptr_t), "::", stringify!(__))
-    );
-}
diff --git a/tests/expectations/tests/union-align.rs b/tests/expectations/tests/union-align.rs
deleted file mode 100644
index 062ea97a..00000000
--- a/tests/expectations/tests/union-align.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Copy, Clone)]
-pub union Bar {
-    pub foo: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        16usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        16usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(foo))
-    );
-}
-impl Default for Bar {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Copy, Clone)]
-pub union Baz {
-    pub bar: Bar,
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    const UNINIT: ::std::mem::MaybeUninit<Baz> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        16usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        16usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(bar))
-    );
-}
-impl Default for Baz {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/union-in-ns.rs b/tests/expectations/tests/union-in-ns.rs
deleted file mode 100644
index 65f3f8f2..00000000
--- a/tests/expectations/tests/union-in-ns.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub union bar {
-        pub baz: ::std::os::raw::c_int,
-    }
-    #[test]
-    fn bindgen_test_layout_bar() {
-        const UNINIT: ::std::mem::MaybeUninit<bar> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<bar>(),
-            4usize,
-            concat!("Size of: ", stringify!(bar))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<bar>(),
-            4usize,
-            concat!("Alignment of ", stringify!(bar))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(bar),
-                "::",
-                stringify!(baz)
-            )
-        );
-    }
-    impl Default for bar {
-        fn default() -> Self {
-            let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-            unsafe {
-                ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-                s.assume_init()
-            }
-        }
-    }
-}
diff --git a/tests/expectations/tests/union-in-ns_1_0.rs b/tests/expectations/tests/union-in-ns_1_0.rs
deleted file mode 100644
index a057cc34..00000000
--- a/tests/expectations/tests/union-in-ns_1_0.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
-pub mod root {
-    #[repr(C)]
-    pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-    impl<T> __BindgenUnionField<T> {
-        #[inline]
-        pub fn new() -> Self {
-            __BindgenUnionField(::std::marker::PhantomData)
-        }
-        #[inline]
-        pub unsafe fn as_ref(&self) -> &T {
-            ::std::mem::transmute(self)
-        }
-        #[inline]
-        pub unsafe fn as_mut(&mut self) -> &mut T {
-            ::std::mem::transmute(self)
-        }
-    }
-    impl<T> ::std::default::Default for __BindgenUnionField<T> {
-        #[inline]
-        fn default() -> Self {
-            Self::new()
-        }
-    }
-    impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-        #[inline]
-        fn clone(&self) -> Self {
-            Self::new()
-        }
-    }
-    impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-    impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-        fn fmt(
-            &self,
-            fmt: &mut ::std::fmt::Formatter<'_>,
-        ) -> ::std::fmt::Result {
-            fmt.write_str("__BindgenUnionField")
-        }
-    }
-    impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-        fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-    }
-    impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-        fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-            true
-        }
-    }
-    impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-    #[allow(unused_imports)]
-    use self::super::root;
-    #[repr(C)]
-    #[derive(Debug, Default, Copy)]
-    pub struct bar {
-        pub baz: root::__BindgenUnionField<::std::os::raw::c_int>,
-        pub bindgen_union_field: u32,
-    }
-    #[test]
-    fn bindgen_test_layout_bar() {
-        const UNINIT: ::std::mem::MaybeUninit<bar> =
-            ::std::mem::MaybeUninit::uninit();
-        let ptr = UNINIT.as_ptr();
-        assert_eq!(
-            ::std::mem::size_of::<bar>(),
-            4usize,
-            concat!("Size of: ", stringify!(bar))
-        );
-        assert_eq!(
-            ::std::mem::align_of::<bar>(),
-            4usize,
-            concat!("Alignment of ", stringify!(bar))
-        );
-        assert_eq!(
-            unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-            0usize,
-            concat!(
-                "Offset of field: ",
-                stringify!(bar),
-                "::",
-                stringify!(baz)
-            )
-        );
-    }
-    impl Clone for bar {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_bitfield.rs b/tests/expectations/tests/union_bitfield.rs
deleted file mode 100644
index 9e07a1df..00000000
--- a/tests/expectations/tests/union_bitfield.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Copy, Clone)]
-pub union U4 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-}
-#[test]
-fn bindgen_test_layout_U4() {
-    assert_eq!(
-        ::std::mem::size_of::<U4>(),
-        4usize,
-        concat!("Size of: ", stringify!(U4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<U4>(),
-        4usize,
-        concat!("Alignment of ", stringify!(U4))
-    );
-}
-impl Default for U4 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl U4 {
-    #[inline]
-    pub fn derp(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_derp(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        derp: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let derp: u32 = unsafe { ::std::mem::transmute(derp) };
-            derp as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Copy, Clone)]
-pub union B {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-}
-impl Default for B {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl B {
-    #[inline]
-    pub fn foo(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 31u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bar(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.set(31usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        foo: ::std::os::raw::c_uint,
-        bar: ::std::os::raw::c_uchar,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 31u8, {
-            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
-            foo as u64
-        });
-        __bindgen_bitfield_unit.set(31usize, 1u8, {
-            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
-            bar as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/union_bitfield_1_0.rs b/tests/expectations/tests/union_bitfield_1_0.rs
deleted file mode 100644
index 22277468..00000000
--- a/tests/expectations/tests/union_bitfield_1_0.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct U4 {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 1usize]>>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_U4() {
-    assert_eq!(
-        ::std::mem::size_of::<U4>(),
-        4usize,
-        concat!("Size of: ", stringify!(U4))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<U4>(),
-        4usize,
-        concat!("Alignment of ", stringify!(U4))
-    );
-}
-impl Clone for U4 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl U4 {
-    #[inline]
-    pub fn derp(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(
-                self._bitfield_1.as_ref().get(0usize, 1u8) as u32
-            )
-        }
-    }
-    #[inline]
-    pub fn set_derp(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.as_mut().set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        derp: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let derp: u32 = unsafe { ::std::mem::transmute(derp) };
-            derp as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct B {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 4usize]>>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        4usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        4usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-}
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl B {
-    #[inline]
-    pub fn foo(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(
-                self._bitfield_1.as_ref().get(0usize, 31u8) as u32
-            )
-        }
-    }
-    #[inline]
-    pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.as_mut().set(0usize, 31u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bar(&self) -> ::std::os::raw::c_uchar {
-        unsafe {
-            ::std::mem::transmute(
-                self._bitfield_1.as_ref().get(31usize, 1u8) as u8
-            )
-        }
-    }
-    #[inline]
-    pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_1.as_mut().set(31usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        foo: ::std::os::raw::c_uint,
-        bar: ::std::os::raw::c_uchar,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 31u8, {
-            let foo: u32 = unsafe { ::std::mem::transmute(foo) };
-            foo as u64
-        });
-        __bindgen_bitfield_unit.set(31usize, 1u8, {
-            let bar: u8 = unsafe { ::std::mem::transmute(bar) };
-            bar as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Copy)]
-pub struct HasBigBitfield {
-    pub _bitfield_align_1: [u64; 0],
-    pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 16usize]>>,
-    pub bindgen_union_field: [u8; 16usize],
-}
-#[test]
-fn bindgen_test_layout_HasBigBitfield() {
-    assert_eq!(
-        ::std::mem::size_of::<HasBigBitfield>(),
-        16usize,
-        concat!("Size of: ", stringify!(HasBigBitfield))
-    );
-}
-impl Clone for HasBigBitfield {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for HasBigBitfield {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-impl ::std::cmp::PartialEq for HasBigBitfield {
-    fn eq(&self, other: &HasBigBitfield) -> bool {
-        &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
-    }
-}
diff --git a/tests/expectations/tests/union_dtor.rs b/tests/expectations/tests/union_dtor.rs
deleted file mode 100644
index 085e5ca3..00000000
--- a/tests/expectations/tests/union_dtor.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub union UnionWithDtor {
-    pub mFoo: ::std::os::raw::c_int,
-    pub mBar: *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout_UnionWithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<UnionWithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<UnionWithDtor>(),
-        8usize,
-        concat!("Size of: ", stringify!(UnionWithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<UnionWithDtor>(),
-        8usize,
-        concat!("Alignment of ", stringify!(UnionWithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UnionWithDtor),
-            "::",
-            stringify!(mFoo)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UnionWithDtor),
-            "::",
-            stringify!(mBar)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN13UnionWithDtorD1Ev"]
-    pub fn UnionWithDtor_UnionWithDtor_destructor(this: *mut UnionWithDtor);
-}
-impl Default for UnionWithDtor {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl UnionWithDtor {
-    #[inline]
-    pub unsafe fn destruct(&mut self) {
-        UnionWithDtor_UnionWithDtor_destructor(self)
-    }
-}
diff --git a/tests/expectations/tests/union_dtor_1_0.rs b/tests/expectations/tests/union_dtor_1_0.rs
deleted file mode 100644
index 67455aa8..00000000
--- a/tests/expectations/tests/union_dtor_1_0.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct UnionWithDtor {
-    pub mFoo: __BindgenUnionField<::std::os::raw::c_int>,
-    pub mBar: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub bindgen_union_field: u64,
-}
-#[test]
-fn bindgen_test_layout_UnionWithDtor() {
-    const UNINIT: ::std::mem::MaybeUninit<UnionWithDtor> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<UnionWithDtor>(),
-        8usize,
-        concat!("Size of: ", stringify!(UnionWithDtor))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<UnionWithDtor>(),
-        8usize,
-        concat!("Alignment of ", stringify!(UnionWithDtor))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFoo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UnionWithDtor),
-            "::",
-            stringify!(mFoo)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mBar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(UnionWithDtor),
-            "::",
-            stringify!(mBar)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN13UnionWithDtorD1Ev"]
-    pub fn UnionWithDtor_UnionWithDtor_destructor(this: *mut UnionWithDtor);
-}
-impl UnionWithDtor {
-    #[inline]
-    pub unsafe fn destruct(&mut self) {
-        UnionWithDtor_UnionWithDtor_destructor(self)
-    }
-}
diff --git a/tests/expectations/tests/union_fields.rs b/tests/expectations/tests/union_fields.rs
deleted file mode 100644
index 9135ca3c..00000000
--- a/tests/expectations/tests/union_fields.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union nsStyleUnion {
-    pub mInt: ::std::os::raw::c_int,
-    pub mFloat: f32,
-    pub mPointer: *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout_nsStyleUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<nsStyleUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsStyleUnion>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsStyleUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsStyleUnion>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsStyleUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mInt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mInt)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFloat) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mFloat)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mPointer) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mPointer)
-        )
-    );
-}
-impl Default for nsStyleUnion {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_fields_1_0.rs b/tests/expectations/tests/union_fields_1_0.rs
deleted file mode 100644
index b5f94bcd..00000000
--- a/tests/expectations/tests/union_fields_1_0.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq)]
-pub struct nsStyleUnion {
-    pub mInt: __BindgenUnionField<::std::os::raw::c_int>,
-    pub mFloat: __BindgenUnionField<f32>,
-    pub mPointer: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub bindgen_union_field: u64,
-}
-#[test]
-fn bindgen_test_layout_nsStyleUnion() {
-    const UNINIT: ::std::mem::MaybeUninit<nsStyleUnion> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<nsStyleUnion>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsStyleUnion))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsStyleUnion>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsStyleUnion))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mInt) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mInt)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mFloat) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mFloat)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mPointer) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(nsStyleUnion),
-            "::",
-            stringify!(mPointer)
-        )
-    );
-}
-impl Clone for nsStyleUnion {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_template.rs b/tests/expectations/tests/union_template.rs
deleted file mode 100644
index 9c3d7a07..00000000
--- a/tests/expectations/tests/union_template.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct NastyStruct {
-    pub mIsSome: bool,
-    pub mStorage: NastyStruct__bindgen_ty_1,
-    pub __bindgen_anon_1: NastyStruct__bindgen_ty_2,
-}
-#[repr(C)]
-pub union NastyStruct__bindgen_ty_1 {
-    pub mFoo: *mut ::std::os::raw::c_void,
-    pub mDummy: ::std::os::raw::c_ulong,
-}
-impl Default for NastyStruct__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub union NastyStruct__bindgen_ty_2 {
-    pub wat: ::std::os::raw::c_short,
-    pub wut: *mut ::std::os::raw::c_int,
-}
-impl Default for NastyStruct__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Default for NastyStruct {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub union Whatever {
-    pub mTPtr: *mut ::std::os::raw::c_void,
-    pub mInt: ::std::os::raw::c_int,
-}
-impl Default for Whatever {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_template_1_0.rs b/tests/expectations/tests/union_template_1_0.rs
deleted file mode 100644
index 487579f7..00000000
--- a/tests/expectations/tests/union_template_1_0.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NastyStruct {
-    pub mIsSome: bool,
-    pub mStorage: NastyStruct__bindgen_ty_1,
-    pub __bindgen_anon_1: NastyStruct__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NastyStruct__bindgen_ty_1 {
-    pub mFoo: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub mDummy: __BindgenUnionField<::std::os::raw::c_ulong>,
-    pub bindgen_union_field: u64,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct NastyStruct__bindgen_ty_2 {
-    pub wat: __BindgenUnionField<::std::os::raw::c_short>,
-    pub wut: __BindgenUnionField<*mut ::std::os::raw::c_int>,
-    pub bindgen_union_field: u64,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Whatever {
-    pub mTPtr: __BindgenUnionField<*mut ::std::os::raw::c_void>,
-    pub mInt: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u64,
-}
diff --git a/tests/expectations/tests/union_with_anon_struct.rs b/tests/expectations/tests/union_with_anon_struct.rs
deleted file mode 100644
index 35b5829b..00000000
--- a/tests/expectations/tests/union_with_anon_struct.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_struct_1_0.rs b/tests/expectations/tests/union_with_anon_struct_1_0.rs
deleted file mode 100644
index 8b11e757..00000000
--- a/tests/expectations/tests/union_with_anon_struct_1_0.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: __BindgenUnionField<foo__bindgen_ty_1>,
-    pub bindgen_union_field: [u32; 2usize],
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_uint,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
deleted file mode 100644
index e81b3bef..00000000
--- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo {
-    pub a: ::std::os::raw::c_int,
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-}
-impl foo__bindgen_ty_1 {
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 25u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        b: ::std::os::raw::c_int,
-        c: ::std::os::raw::c_int,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 7u8, {
-            let b: u32 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 25u8, {
-            let c: u32 = unsafe { ::std::mem::transmute(c) };
-            c as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs b/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
deleted file mode 100644
index 6ce6ed22..00000000
--- a/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: __BindgenUnionField<::std::os::raw::c_int>,
-    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub _bitfield_align_1: [u32; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-    pub __bindgen_align: [u32; 0usize],
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl foo__bindgen_ty_1 {
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 7u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(7usize, 25u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 25u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        b: ::std::os::raw::c_int,
-        c: ::std::os::raw::c_int,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 7u8, {
-            let b: u32 = unsafe { ::std::mem::transmute(b) };
-            b as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 25u8, {
-            let c: u32 = unsafe { ::std::mem::transmute(c) };
-            c as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_union.rs b/tests/expectations/tests/union_with_anon_union.rs
deleted file mode 100644
index 487650bf..00000000
--- a/tests/expectations/tests/union_with_anon_union.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo {
-    pub bar: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub a: ::std::os::raw::c_uint,
-    pub b: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_union_1_0.rs b/tests/expectations/tests/union_with_anon_union_1_0.rs
deleted file mode 100644
index f3e4b840..00000000
--- a/tests/expectations/tests/union_with_anon_union_1_0.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub bar: __BindgenUnionField<foo__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_unnamed_struct.rs b/tests/expectations/tests/union_with_anon_unnamed_struct.rs
deleted file mode 100644
index cff5df04..00000000
--- a/tests/expectations/tests/union_with_anon_unnamed_struct.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union pixel {
-    pub rgba: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: pixel__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct pixel__bindgen_ty_1 {
-    pub r: ::std::os::raw::c_uchar,
-    pub g: ::std::os::raw::c_uchar,
-    pub b: ::std::os::raw::c_uchar,
-    pub a: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_pixel__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<pixel__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<pixel__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(pixel__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<pixel__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(pixel__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(r)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(g)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-#[test]
-fn bindgen_test_layout_pixel() {
-    const UNINIT: ::std::mem::MaybeUninit<pixel> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<pixel>(),
-        4usize,
-        concat!("Size of: ", stringify!(pixel))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<pixel>(),
-        4usize,
-        concat!("Alignment of ", stringify!(pixel))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rgba) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel),
-            "::",
-            stringify!(rgba)
-        )
-    );
-}
-impl Default for pixel {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs b/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
deleted file mode 100644
index 1562a8c9..00000000
--- a/tests/expectations/tests/union_with_anon_unnamed_struct_1_0.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct pixel {
-    pub rgba: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub __bindgen_anon_1: __BindgenUnionField<pixel__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct pixel__bindgen_ty_1 {
-    pub r: ::std::os::raw::c_uchar,
-    pub g: ::std::os::raw::c_uchar,
-    pub b: ::std::os::raw::c_uchar,
-    pub a: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_pixel__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<pixel__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<pixel__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(pixel__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<pixel__bindgen_ty_1>(),
-        1usize,
-        concat!("Alignment of ", stringify!(pixel__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(r)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(g)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel__bindgen_ty_1),
-            "::",
-            stringify!(a)
-        )
-    );
-}
-impl Clone for pixel__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_pixel() {
-    const UNINIT: ::std::mem::MaybeUninit<pixel> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<pixel>(),
-        4usize,
-        concat!("Size of: ", stringify!(pixel))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<pixel>(),
-        4usize,
-        concat!("Alignment of ", stringify!(pixel))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).rgba) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(pixel),
-            "::",
-            stringify!(rgba)
-        )
-    );
-}
-impl Clone for pixel {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_unnamed_union.rs b/tests/expectations/tests/union_with_anon_unnamed_union.rs
deleted file mode 100644
index f1abfc5a..00000000
--- a/tests/expectations/tests/union_with_anon_unnamed_union.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo {
-    pub a: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1 {
-    pub b: ::std::os::raw::c_ushort,
-    pub c: ::std::os::raw::c_uchar,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(c)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs b/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
deleted file mode 100644
index 197a6bbf..00000000
--- a/tests/expectations/tests/union_with_anon_unnamed_union_1_0.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub b: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub c: __BindgenUnionField<::std::os::raw::c_uchar>,
-    pub bindgen_union_field: u16,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(b)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1),
-            "::",
-            stringify!(c)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_big_member.rs b/tests/expectations/tests/union_with_big_member.rs
deleted file mode 100644
index 7110257b..00000000
--- a/tests/expectations/tests/union_with_big_member.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union WithBigArray {
-    pub a: ::std::os::raw::c_int,
-    pub b: [::std::os::raw::c_int; 33usize],
-}
-#[test]
-fn bindgen_test_layout_WithBigArray() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigArray>(),
-        132usize,
-        concat!("Size of: ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for WithBigArray {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union WithBigArray2 {
-    pub a: ::std::os::raw::c_int,
-    pub b: [::std::os::raw::c_char; 33usize],
-}
-#[test]
-fn bindgen_test_layout_WithBigArray2() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigArray2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigArray2>(),
-        36usize,
-        concat!("Size of: ", stringify!(WithBigArray2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigArray2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigArray2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray2),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for WithBigArray2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union WithBigMember {
-    pub a: ::std::os::raw::c_int,
-    pub b: WithBigArray,
-}
-#[test]
-fn bindgen_test_layout_WithBigMember() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigMember> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigMember>(),
-        132usize,
-        concat!("Size of: ", stringify!(WithBigMember))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigMember>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigMember))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigMember),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigMember),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Default for WithBigMember {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_big_member_1_0.rs b/tests/expectations/tests/union_with_big_member_1_0.rs
deleted file mode 100644
index 63b43baa..00000000
--- a/tests/expectations/tests/union_with_big_member_1_0.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Copy)]
-pub struct WithBigArray {
-    pub a: __BindgenUnionField<::std::os::raw::c_int>,
-    pub b: __BindgenUnionField<[::std::os::raw::c_int; 33usize]>,
-    pub bindgen_union_field: [u32; 33usize],
-}
-#[test]
-fn bindgen_test_layout_WithBigArray() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigArray>(),
-        132usize,
-        concat!("Size of: ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigArray>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for WithBigArray {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for WithBigArray {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct WithBigArray2 {
-    pub a: __BindgenUnionField<::std::os::raw::c_int>,
-    pub b: __BindgenUnionField<[::std::os::raw::c_char; 33usize]>,
-    pub bindgen_union_field: [u32; 9usize],
-}
-#[test]
-fn bindgen_test_layout_WithBigArray2() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigArray2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigArray2>(),
-        36usize,
-        concat!("Size of: ", stringify!(WithBigArray2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigArray2>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigArray2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray2),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigArray2),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for WithBigArray2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Copy)]
-pub struct WithBigMember {
-    pub a: __BindgenUnionField<::std::os::raw::c_int>,
-    pub b: __BindgenUnionField<WithBigArray>,
-    pub bindgen_union_field: [u32; 33usize],
-}
-#[test]
-fn bindgen_test_layout_WithBigMember() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBigMember> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBigMember>(),
-        132usize,
-        concat!("Size of: ", stringify!(WithBigMember))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBigMember>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBigMember))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigMember),
-            "::",
-            stringify!(a)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBigMember),
-            "::",
-            stringify!(b)
-        )
-    );
-}
-impl Clone for WithBigMember {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for WithBigMember {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::std::mem::uninitialized();
-            ::std::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_nesting.rs b/tests/expectations/tests/union_with_nesting.rs
deleted file mode 100644
index ec9c1480..00000000
--- a/tests/expectations/tests/union_with_nesting.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo {
-    pub a: ::std::os::raw::c_uint,
-    pub __bindgen_anon_1: foo__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct foo__bindgen_ty_1 {
-    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
-    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1__bindgen_ty_1 {
-    pub b1: ::std::os::raw::c_ushort,
-    pub b2: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b2)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union foo__bindgen_ty_1__bindgen_ty_2 {
-    pub c1: ::std::os::raw::c_ushort,
-    pub c2: ::std::os::raw::c_ushort,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(c1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(c2)
-        )
-    );
-}
-impl Default for foo__bindgen_ty_1__bindgen_ty_2 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-}
-impl Default for foo__bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/union_with_nesting_1_0.rs b/tests/expectations/tests/union_with_nesting_1_0.rs
deleted file mode 100644
index a1e452fe..00000000
--- a/tests/expectations/tests/union_with_nesting_1_0.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1 {
-    pub __bindgen_anon_1: foo__bindgen_ty_1__bindgen_ty_1,
-    pub __bindgen_anon_2: foo__bindgen_ty_1__bindgen_ty_2,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_1 {
-    pub b1: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub b2: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u16,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_1() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_1> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_1),
-            "::",
-            stringify!(b2)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct foo__bindgen_ty_1__bindgen_ty_2 {
-    pub c1: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub c2: __BindgenUnionField<::std::os::raw::c_ushort>,
-    pub bindgen_union_field: u16,
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1__bindgen_ty_2() {
-    const UNINIT: ::std::mem::MaybeUninit<foo__bindgen_ty_1__bindgen_ty_2> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        2usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1__bindgen_ty_2>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1__bindgen_ty_2))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(c1)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo__bindgen_ty_1__bindgen_ty_2),
-            "::",
-            stringify!(c2)
-        )
-    );
-}
-impl Clone for foo__bindgen_ty_1__bindgen_ty_2 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    assert_eq!(
-        ::std::mem::size_of::<foo__bindgen_ty_1>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo__bindgen_ty_1))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo__bindgen_ty_1>(),
-        2usize,
-        concat!("Alignment of ", stringify!(foo__bindgen_ty_1))
-    );
-}
-impl Clone for foo__bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        4usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        4usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/union_with_non_copy_member.rs b/tests/expectations/tests/union_with_non_copy_member.rs
deleted file mode 100644
index 3c500b21..00000000
--- a/tests/expectations/tests/union_with_non_copy_member.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __BindgenUnionField(::std::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::std::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::std::mem::transmute(self)
-    }
-}
-impl<T> ::std::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct NonCopyType {
-    pub foo: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_NonCopyType() {
-    const UNINIT: ::std::mem::MaybeUninit<NonCopyType> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<NonCopyType>(),
-        4usize,
-        concat!("Size of: ", stringify!(NonCopyType))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<NonCopyType>(),
-        4usize,
-        concat!("Alignment of ", stringify!(NonCopyType))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(NonCopyType),
-            "::",
-            stringify!(foo)
-        )
-    );
-}
-#[repr(C)]
-pub struct WithBindgenGeneratedWrapper {
-    pub non_copy_type: __BindgenUnionField<NonCopyType>,
-    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_WithBindgenGeneratedWrapper() {
-    const UNINIT: ::std::mem::MaybeUninit<WithBindgenGeneratedWrapper> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithBindgenGeneratedWrapper>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithBindgenGeneratedWrapper))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithBindgenGeneratedWrapper>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithBindgenGeneratedWrapper))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBindgenGeneratedWrapper),
-            "::",
-            stringify!(non_copy_type)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithBindgenGeneratedWrapper),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for WithBindgenGeneratedWrapper {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub union WithManuallyDrop {
-    pub non_copy_type: ::std::mem::ManuallyDrop<NonCopyType>,
-    pub bar: ::std::mem::ManuallyDrop<::std::os::raw::c_int>,
-}
-#[test]
-fn bindgen_test_layout_WithManuallyDrop() {
-    const UNINIT: ::std::mem::MaybeUninit<WithManuallyDrop> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithManuallyDrop>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithManuallyDrop))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithManuallyDrop>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithManuallyDrop))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithManuallyDrop),
-            "::",
-            stringify!(non_copy_type)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithManuallyDrop),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for WithManuallyDrop {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct WithDefaultWrapper {
-    pub non_copy_type: __BindgenUnionField<NonCopyType>,
-    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
-    pub bindgen_union_field: u32,
-}
-#[test]
-fn bindgen_test_layout_WithDefaultWrapper() {
-    const UNINIT: ::std::mem::MaybeUninit<WithDefaultWrapper> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<WithDefaultWrapper>(),
-        4usize,
-        concat!("Size of: ", stringify!(WithDefaultWrapper))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<WithDefaultWrapper>(),
-        4usize,
-        concat!("Alignment of ", stringify!(WithDefaultWrapper))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).non_copy_type) as usize - ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDefaultWrapper),
-            "::",
-            stringify!(non_copy_type)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(WithDefaultWrapper),
-            "::",
-            stringify!(bar)
-        )
-    );
-}
-impl Default for WithDefaultWrapper {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/unknown_attr.rs b/tests/expectations/tests/unknown_attr.rs
deleted file mode 100644
index c790f009..00000000
--- a/tests/expectations/tests/unknown_attr.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[repr(align(16))]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct max_align_t {
-    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
-    pub __bindgen_padding_0: u64,
-    pub __clang_max_align_nonce2: ::std::os::raw::c_longlong,
-}
-#[test]
-fn bindgen_test_layout_max_align_t() {
-    const UNINIT: ::std::mem::MaybeUninit<max_align_t> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<max_align_t>(),
-        32usize,
-        concat!("Size of: ", stringify!(max_align_t))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<max_align_t>(),
-        16usize,
-        concat!("Alignment of ", stringify!(max_align_t))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(max_align_t),
-            "::",
-            stringify!(__clang_max_align_nonce1)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize -
-                ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(max_align_t),
-            "::",
-            stringify!(__clang_max_align_nonce2)
-        )
-    );
-}
diff --git a/tests/expectations/tests/unsorted-items.rs b/tests/expectations/tests/unsorted-items.rs
deleted file mode 100644
index ce0c5f3f..00000000
--- a/tests/expectations/tests/unsorted-items.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn foo() -> ::std::os::raw::c_int;
-}
-pub type number = ::std::os::raw::c_int;
-extern "C" {
-    pub fn bar(x: number) -> ::std::os::raw::c_int;
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Point {
-    pub x: number,
-    pub y: number,
-}
-#[test]
-fn bindgen_test_layout_Point() {
-    const UNINIT: ::std::mem::MaybeUninit<Point> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Point>(),
-        8usize,
-        concat!("Size of: ", stringify!(Point))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Point>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Point))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Point), "::", stringify!(x))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Point), "::", stringify!(y))
-    );
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Angle {
-    pub a: number,
-    pub b: number,
-}
-#[test]
-fn bindgen_test_layout_Angle() {
-    const UNINIT: ::std::mem::MaybeUninit<Angle> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Angle>(),
-        8usize,
-        concat!("Size of: ", stringify!(Angle))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Angle>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Angle))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(Angle), "::", stringify!(b))
-    );
-}
-extern "C" {
-    pub fn baz(point: Point) -> ::std::os::raw::c_int;
-}
-pub const NUMBER: number = 42;
diff --git a/tests/expectations/tests/use-core.rs b/tests/expectations/tests/use-core.rs
deleted file mode 100644
index 569e8d24..00000000
--- a/tests/expectations/tests/use-core.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(not(target_os = "windows"))]
-extern crate core;
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: ::core::ffi::c_int,
-    pub b: ::core::ffi::c_int,
-    pub bar: *mut ::core::ffi::c_void,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::core::mem::MaybeUninit<foo> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Default for foo {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union _bindgen_ty_1 {
-    pub bar: ::core::ffi::c_int,
-    pub baz: ::core::ffi::c_long,
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    const UNINIT: ::core::mem::MaybeUninit<_bindgen_ty_1> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(bar)
-        )
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(baz)
-        )
-    );
-}
-impl Default for _bindgen_ty_1 {
-    fn default() -> Self {
-        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    pub static mut bazz: _bindgen_ty_1;
-}
-pub type fooFunction =
-    ::core::option::Option<unsafe extern "C" fn(bar: ::core::ffi::c_int)>;
diff --git a/tests/expectations/tests/use-core_1_0.rs b/tests/expectations/tests/use-core_1_0.rs
deleted file mode 100644
index 8c6d0fd2..00000000
--- a/tests/expectations/tests/use-core_1_0.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern crate core;
-
-#[repr(C)]
-pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
-impl<T> __BindgenUnionField<T> {
-    #[inline]
-    pub fn new() -> Self {
-        __BindgenUnionField(::core::marker::PhantomData)
-    }
-    #[inline]
-    pub unsafe fn as_ref(&self) -> &T {
-        ::core::mem::transmute(self)
-    }
-    #[inline]
-    pub unsafe fn as_mut(&mut self) -> &mut T {
-        ::core::mem::transmute(self)
-    }
-}
-impl<T> ::core::default::Default for __BindgenUnionField<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl<T> ::core::clone::Clone for __BindgenUnionField<T> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self::new()
-    }
-}
-impl<T> ::core::marker::Copy for __BindgenUnionField<T> {}
-impl<T> ::core::fmt::Debug for __BindgenUnionField<T> {
-    fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-        fmt.write_str("__BindgenUnionField")
-    }
-}
-impl<T> ::core::hash::Hash for __BindgenUnionField<T> {
-    fn hash<H: ::core::hash::Hasher>(&self, _state: &mut H) {}
-}
-impl<T> ::core::cmp::PartialEq for __BindgenUnionField<T> {
-    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
-        true
-    }
-}
-impl<T> ::core::cmp::Eq for __BindgenUnionField<T> {}
-#[repr(C)]
-#[derive(Debug, Copy, Hash, PartialEq, Eq)]
-pub struct foo {
-    pub a: ::std::os::raw::c_int,
-    pub b: ::std::os::raw::c_int,
-    pub bar: *mut ::std::os::raw::c_void,
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::core::mem::MaybeUninit<foo> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<foo>(),
-        16usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(a))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
-        4usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(b))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(foo), "::", stringify!(bar))
-    );
-}
-impl Clone for foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-impl Default for foo {
-    fn default() -> Self {
-        unsafe {
-            let mut s: Self = ::core::mem::uninitialized();
-            ::core::ptr::write_bytes(&mut s, 0, 1);
-            s
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
-pub struct _bindgen_ty_1 {
-    pub bar: __BindgenUnionField<::std::os::raw::c_int>,
-    pub baz: __BindgenUnionField<::std::os::raw::c_long>,
-    pub bindgen_union_field: u64,
-}
-#[test]
-fn bindgen_test_layout__bindgen_ty_1() {
-    const UNINIT: ::core::mem::MaybeUninit<_bindgen_ty_1> =
-        ::core::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::core::mem::size_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Size of: ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        ::core::mem::align_of::<_bindgen_ty_1>(),
-        8usize,
-        concat!("Alignment of ", stringify!(_bindgen_ty_1))
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(bar)
-        )
-    );
-    assert_eq!(
-        unsafe { ::core::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(_bindgen_ty_1),
-            "::",
-            stringify!(baz)
-        )
-    );
-}
-impl Clone for _bindgen_ty_1 {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-extern "C" {
-    pub static mut bazz: _bindgen_ty_1;
-}
-pub type fooFunction =
-    ::core::option::Option<unsafe extern "C" fn(bar: ::std::os::raw::c_int)>;
diff --git a/tests/expectations/tests/using.rs b/tests/expectations/tests/using.rs
deleted file mode 100644
index 4749ed55..00000000
--- a/tests/expectations/tests/using.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Point<T> {
-    pub x: T,
-    pub y: T,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
-}
-impl<T> Default for Point<T> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type IntPoint2D = Point<::std::os::raw::c_int>;
-pub type IntVec2D = Point<::std::os::raw::c_int>;
diff --git a/tests/expectations/tests/var-tracing.rs b/tests/expectations/tests/var-tracing.rs
deleted file mode 100644
index 4280802e..00000000
--- a/tests/expectations/tests/var-tracing.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub m_baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    const UNINIT: ::std::mem::MaybeUninit<Bar> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        4usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).m_baz) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Bar),
-            "::",
-            stringify!(m_baz)
-        )
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3BarC1Ei"]
-    pub fn Bar_Bar(this: *mut Bar, baz: ::std::os::raw::c_int);
-}
-impl Bar {
-    #[inline]
-    pub unsafe fn new(baz: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        Bar_Bar(__bindgen_tmp.as_mut_ptr(), baz);
-        __bindgen_tmp.assume_init()
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Baz {
-    pub _address: u8,
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Baz3FOOE"]
-    pub static mut Baz_FOO: [Bar; 0usize];
-}
-#[test]
-fn bindgen_test_layout_Baz() {
-    assert_eq!(
-        ::std::mem::size_of::<Baz>(),
-        1usize,
-        concat!("Size of: ", stringify!(Baz))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Baz>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Baz))
-    );
-}
diff --git a/tests/expectations/tests/variadic-method.rs b/tests/expectations/tests/variadic-method.rs
deleted file mode 100644
index be93dda7..00000000
--- a/tests/expectations/tests/variadic-method.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    #[link_name = "\u{1}_Z3fooPKcz"]
-    pub fn foo(fmt: *const ::std::os::raw::c_char, ...);
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Bar {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Bar() {
-    assert_eq!(
-        ::std::mem::size_of::<Bar>(),
-        1usize,
-        concat!("Size of: ", stringify!(Bar))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Bar>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Bar))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3Bar3fooEPKcz"]
-    pub fn Bar_foo(this: *mut Bar, fmt: *const ::std::os::raw::c_char, ...);
-}
diff --git a/tests/expectations/tests/variadic_template_function.rs b/tests/expectations/tests/variadic_template_function.rs
deleted file mode 100644
index 8f67136a..00000000
--- a/tests/expectations/tests/variadic_template_function.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct VariadicFunctionObject {
-    pub _address: u8,
-}
diff --git a/tests/expectations/tests/vector.rs b/tests/expectations/tests/vector.rs
deleted file mode 100644
index 12d2e1b1..00000000
--- a/tests/expectations/tests/vector.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct foo {
-    pub mMember: [::std::os::raw::c_longlong; 1usize],
-}
-#[test]
-fn bindgen_test_layout_foo() {
-    const UNINIT: ::std::mem::MaybeUninit<foo> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<foo>(),
-        8usize,
-        concat!("Size of: ", stringify!(foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<foo>(),
-        8usize,
-        concat!("Alignment of ", stringify!(foo))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).mMember) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(foo),
-            "::",
-            stringify!(mMember)
-        )
-    );
-}
-pub type __m128 = [f32; 4usize];
-pub type __m128d = [f64; 2usize];
-pub type __m128i = [::std::os::raw::c_longlong; 2usize];
-extern "C" {
-    #[link_name = "\u{1}_Z3fooDv2_xDv2_d"]
-    pub fn foo(arg1: __m128i, arg2: __m128d) -> __m128;
-}
diff --git a/tests/expectations/tests/virtual_dtor.rs b/tests/expectations/tests/virtual_dtor.rs
deleted file mode 100644
index c3c66e91..00000000
--- a/tests/expectations/tests/virtual_dtor.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct nsSlots__bindgen_vtable(::std::os::raw::c_void);
-#[repr(C)]
-#[derive(Debug)]
-pub struct nsSlots {
-    pub vtable_: *const nsSlots__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_nsSlots() {
-    assert_eq!(
-        ::std::mem::size_of::<nsSlots>(),
-        8usize,
-        concat!("Size of: ", stringify!(nsSlots))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<nsSlots>(),
-        8usize,
-        concat!("Alignment of ", stringify!(nsSlots))
-    );
-}
-impl Default for nsSlots {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN7nsSlotsD1Ev"]
-    pub fn nsSlots_nsSlots_destructor(this: *mut nsSlots);
-}
diff --git a/tests/expectations/tests/virtual_inheritance.rs b/tests/expectations/tests/virtual_inheritance.rs
deleted file mode 100644
index 2c15b428..00000000
--- a/tests/expectations/tests/virtual_inheritance.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct A {
-    pub foo: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_A() {
-    const UNINIT: ::std::mem::MaybeUninit<A> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<A>(),
-        4usize,
-        concat!("Size of: ", stringify!(A))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<A>(),
-        4usize,
-        concat!("Alignment of ", stringify!(A))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).foo) as usize - ptr as usize },
-        0usize,
-        concat!("Offset of field: ", stringify!(A), "::", stringify!(foo))
-    );
-}
-#[repr(C)]
-pub struct B__bindgen_vtable(::std::os::raw::c_void);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct B {
-    pub vtable_: *const B__bindgen_vtable,
-    pub bar: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_B() {
-    const UNINIT: ::std::mem::MaybeUninit<B> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<B>(),
-        16usize,
-        concat!("Size of: ", stringify!(B))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<B>(),
-        8usize,
-        concat!("Alignment of ", stringify!(B))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(B), "::", stringify!(bar))
-    );
-}
-impl Default for B {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct C__bindgen_vtable(::std::os::raw::c_void);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct C {
-    pub vtable_: *const C__bindgen_vtable,
-    pub baz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    const UNINIT: ::std::mem::MaybeUninit<C> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        16usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        8usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
-        8usize,
-        concat!("Offset of field: ", stringify!(C), "::", stringify!(baz))
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct D {
-    pub _base: C,
-    pub _base_1: B,
-    pub bazz: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_D() {
-    assert_eq!(
-        ::std::mem::size_of::<D>(),
-        40usize,
-        concat!("Size of: ", stringify!(D))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<D>(),
-        8usize,
-        concat!("Alignment of ", stringify!(D))
-    );
-}
-impl Default for D {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/virtual_interface.rs b/tests/expectations/tests/virtual_interface.rs
deleted file mode 100644
index be94f232..00000000
--- a/tests/expectations/tests/virtual_interface.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct PureVirtualIFace__bindgen_vtable {
-    pub PureVirtualIFace_Foo: unsafe extern "C" fn(this: *mut PureVirtualIFace),
-    pub PureVirtualIFace_Bar: unsafe extern "C" fn(
-        this: *mut PureVirtualIFace,
-        arg1: ::std::os::raw::c_uint,
-    ),
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct PureVirtualIFace {
-    pub vtable_: *const PureVirtualIFace__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_PureVirtualIFace() {
-    assert_eq!(
-        ::std::mem::size_of::<PureVirtualIFace>(),
-        8usize,
-        concat!("Size of: ", stringify!(PureVirtualIFace))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<PureVirtualIFace>(),
-        8usize,
-        concat!("Alignment of ", stringify!(PureVirtualIFace))
-    );
-}
-impl Default for PureVirtualIFace {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-pub struct AnotherInterface__bindgen_vtable {
-    pub AnotherInterface_Baz: unsafe extern "C" fn(this: *mut AnotherInterface),
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct AnotherInterface {
-    pub vtable_: *const AnotherInterface__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_AnotherInterface() {
-    assert_eq!(
-        ::std::mem::size_of::<AnotherInterface>(),
-        8usize,
-        concat!("Size of: ", stringify!(AnotherInterface))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<AnotherInterface>(),
-        8usize,
-        concat!("Alignment of ", stringify!(AnotherInterface))
-    );
-}
-impl Default for AnotherInterface {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Implementation {
-    pub _base: PureVirtualIFace,
-}
-#[test]
-fn bindgen_test_layout_Implementation() {
-    assert_eq!(
-        ::std::mem::size_of::<Implementation>(),
-        8usize,
-        concat!("Size of: ", stringify!(Implementation))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Implementation>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Implementation))
-    );
-}
-impl Default for Implementation {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct DoubleImpl {
-    pub _base: PureVirtualIFace,
-    pub _base_1: AnotherInterface,
-}
-#[test]
-fn bindgen_test_layout_DoubleImpl() {
-    assert_eq!(
-        ::std::mem::size_of::<DoubleImpl>(),
-        16usize,
-        concat!("Size of: ", stringify!(DoubleImpl))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DoubleImpl>(),
-        8usize,
-        concat!("Alignment of ", stringify!(DoubleImpl))
-    );
-}
-impl Default for DoubleImpl {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/virtual_overloaded.rs b/tests/expectations/tests/virtual_overloaded.rs
deleted file mode 100644
index c117d9ef..00000000
--- a/tests/expectations/tests/virtual_overloaded.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct C__bindgen_vtable {
-    pub C_do_thing:
-        unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_char),
-    pub C_do_thing1:
-        unsafe extern "C" fn(this: *mut C, arg1: ::std::os::raw::c_int),
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct C {
-    pub vtable_: *const C__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_C() {
-    assert_eq!(
-        ::std::mem::size_of::<C>(),
-        8usize,
-        concat!("Size of: ", stringify!(C))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<C>(),
-        8usize,
-        concat!("Alignment of ", stringify!(C))
-    );
-}
-impl Default for C {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C8do_thingEc"]
-    pub fn C_do_thing(
-        this: *mut ::std::os::raw::c_void,
-        arg1: ::std::os::raw::c_char,
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN1C8do_thingEi"]
-    pub fn C_do_thing1(
-        this: *mut ::std::os::raw::c_void,
-        arg1: ::std::os::raw::c_int,
-    );
-}
diff --git a/tests/expectations/tests/vtable_recursive_sig.rs b/tests/expectations/tests/vtable_recursive_sig.rs
deleted file mode 100644
index 74e1dc79..00000000
--- a/tests/expectations/tests/vtable_recursive_sig.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-pub struct Base__bindgen_vtable {
-    pub Base_AsDerived: unsafe extern "C" fn(this: *mut Base) -> *mut Derived,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Base {
-    pub vtable_: *const Base__bindgen_vtable,
-}
-#[test]
-fn bindgen_test_layout_Base() {
-    assert_eq!(
-        ::std::mem::size_of::<Base>(),
-        8usize,
-        concat!("Size of: ", stringify!(Base))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Base>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Base))
-    );
-}
-impl Default for Base {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN4Base9AsDerivedEv"]
-    pub fn Base_AsDerived(this: *mut ::std::os::raw::c_void) -> *mut Derived;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Derived {
-    pub _base: Base,
-}
-#[test]
-fn bindgen_test_layout_Derived() {
-    assert_eq!(
-        ::std::mem::size_of::<Derived>(),
-        8usize,
-        concat!("Size of: ", stringify!(Derived))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Derived>(),
-        8usize,
-        concat!("Alignment of ", stringify!(Derived))
-    );
-}
-impl Default for Derived {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
diff --git a/tests/expectations/tests/wasm-constructor-returns.rs b/tests/expectations/tests/wasm-constructor-returns.rs
deleted file mode 100644
index 6d15c51f..00000000
--- a/tests/expectations/tests/wasm-constructor-returns.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "C" {
-    #[link_name = "\u{1}_ZN3FooC1Ei"]
-    pub fn Foo_Foo(
-        this: *mut Foo,
-        var: ::std::os::raw::c_int,
-    ) -> *mut ::std::os::raw::c_void;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn new(var: ::std::os::raw::c_int) -> Self {
-        let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
-        Foo_Foo(__bindgen_tmp.as_mut_ptr(), var);
-        __bindgen_tmp.assume_init()
-    }
-}
diff --git a/tests/expectations/tests/wasm-import-module.rs b/tests/expectations/tests/wasm-import-module.rs
deleted file mode 100644
index e334a7b7..00000000
--- a/tests/expectations/tests/wasm-import-module.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[link(wasm_import_module = "test-module")]
-extern "C" {
-    pub fn test_function();
-}
diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs
deleted file mode 100644
index 9383bada..00000000
--- a/tests/expectations/tests/weird_bitfields.rs
+++ /dev/null
@@ -1,440 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!(
-            (bit_offset + (bit_width as usize)) / 8 <=
-                self.storage.as_ref().len()
-        );
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum nsStyleSVGOpacitySource {
-    eStyleSVGOpacitySource_Normal = 0,
-    eStyleSVGOpacitySource_ContextFillOpacity = 1,
-    eStyleSVGOpacitySource_ContextStrokeOpacity = 2,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct Weird {
-    pub mStrokeDasharrayLength: ::std::os::raw::c_uint,
-    pub _bitfield_align_1: [u16; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
-    pub mClipRule: ::std::os::raw::c_uchar,
-    pub mColorInterpolation: ::std::os::raw::c_uchar,
-    pub mColorInterpolationFilters: ::std::os::raw::c_uchar,
-    pub mFillRule: ::std::os::raw::c_uchar,
-    pub mImageRendering: ::std::os::raw::c_uchar,
-    pub mPaintOrder: ::std::os::raw::c_uchar,
-    pub mShapeRendering: ::std::os::raw::c_uchar,
-    pub mStrokeLinecap: ::std::os::raw::c_uchar,
-    pub mStrokeLinejoin: ::std::os::raw::c_uchar,
-    pub mTextAnchor: ::std::os::raw::c_uchar,
-    pub mTextRendering: ::std::os::raw::c_uchar,
-    pub _bitfield_align_2: [u8; 0],
-    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 2usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_Weird() {
-    const UNINIT: ::std::mem::MaybeUninit<Weird> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<Weird>(),
-        24usize,
-        concat!("Size of: ", stringify!(Weird))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Weird>(),
-        4usize,
-        concat!("Alignment of ", stringify!(Weird))
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mStrokeDasharrayLength) as usize -
-                ptr as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mStrokeDasharrayLength)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mClipRule) as usize - ptr as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mClipRule)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mColorInterpolation) as usize -
-                ptr as usize
-        },
-        9usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mColorInterpolation)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mColorInterpolationFilters) as usize -
-                ptr as usize
-        },
-        10usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mColorInterpolationFilters)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mFillRule) as usize - ptr as usize
-        },
-        11usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mFillRule)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mImageRendering) as usize - ptr as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mImageRendering)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mPaintOrder) as usize - ptr as usize
-        },
-        13usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mPaintOrder)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mShapeRendering) as usize - ptr as usize
-        },
-        14usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mShapeRendering)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mStrokeLinecap) as usize - ptr as usize
-        },
-        15usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mStrokeLinecap)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mStrokeLinejoin) as usize - ptr as usize
-        },
-        16usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mStrokeLinejoin)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mTextAnchor) as usize - ptr as usize
-        },
-        17usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mTextAnchor)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            ::std::ptr::addr_of!((*ptr).mTextRendering) as usize - ptr as usize
-        },
-        18usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(Weird),
-            "::",
-            stringify!(mTextRendering)
-        )
-    );
-}
-impl Default for Weird {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-impl Weird {
-    #[inline]
-    pub fn bitTest(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 16u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn bitTest2(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_1.get(16usize, 15u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 15u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        bitTest: ::std::os::raw::c_uint,
-        bitTest2: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 16u8, {
-            let bitTest: u32 = unsafe { ::std::mem::transmute(bitTest) };
-            bitTest as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 15u8, {
-            let bitTest2: u32 = unsafe { ::std::mem::transmute(bitTest2) };
-            bitTest2 as u64
-        });
-        __bindgen_bitfield_unit
-    }
-    #[inline]
-    pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(0usize, 3u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_2.set(0usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(3usize, 3u8) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_2.set(3usize, 3u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn mStrokeDasharrayFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(6usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn mStrokeDashoffsetFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(7usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn mStrokeWidthFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(self._bitfield_2.get(8usize, 1u8) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeWidthFromObject(&mut self, val: bool) {
-        unsafe {
-            let val: u8 = ::std::mem::transmute(val);
-            self._bitfield_2.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_2(
-        mFillOpacitySource: nsStyleSVGOpacitySource,
-        mStrokeOpacitySource: nsStyleSVGOpacitySource,
-        mStrokeDasharrayFromObject: bool,
-        mStrokeDashoffsetFromObject: bool,
-        mStrokeWidthFromObject: bool,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
-            Default::default();
-        __bindgen_bitfield_unit.set(0usize, 3u8, {
-            let mFillOpacitySource: u32 =
-                unsafe { ::std::mem::transmute(mFillOpacitySource) };
-            mFillOpacitySource as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 3u8, {
-            let mStrokeOpacitySource: u32 =
-                unsafe { ::std::mem::transmute(mStrokeOpacitySource) };
-            mStrokeOpacitySource as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let mStrokeDasharrayFromObject: u8 =
-                unsafe { ::std::mem::transmute(mStrokeDasharrayFromObject) };
-            mStrokeDasharrayFromObject as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let mStrokeDashoffsetFromObject: u8 =
-                unsafe { ::std::mem::transmute(mStrokeDashoffsetFromObject) };
-            mStrokeDashoffsetFromObject as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let mStrokeWidthFromObject: u8 =
-                unsafe { ::std::mem::transmute(mStrokeWidthFromObject) };
-            mStrokeWidthFromObject as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
diff --git a/tests/expectations/tests/what_is_going_on.rs b/tests/expectations/tests/what_is_going_on.rs
deleted file mode 100644
index b4f42791..00000000
--- a/tests/expectations/tests/what_is_going_on.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct UnknownUnits {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_UnknownUnits() {
-    assert_eq!(
-        ::std::mem::size_of::<UnknownUnits>(),
-        1usize,
-        concat!("Size of: ", stringify!(UnknownUnits))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<UnknownUnits>(),
-        1usize,
-        concat!("Alignment of ", stringify!(UnknownUnits))
-    );
-}
-pub type Float = f32;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct PointTyped<F> {
-    pub x: F,
-    pub y: F,
-    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<F>>,
-}
-impl<F> Default for PointTyped<F> {
-    fn default() -> Self {
-        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
-        unsafe {
-            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
-            s.assume_init()
-        }
-    }
-}
-pub type IntPoint = PointTyped<f32>;
diff --git a/tests/expectations/tests/win32-thiscall_1_0.rs b/tests/expectations/tests/win32-thiscall_1_0.rs
deleted file mode 100644
index 502e12fe..00000000
--- a/tests/expectations/tests/win32-thiscall_1_0.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-impl Clone for Foo {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
diff --git a/tests/expectations/tests/win32-thiscall_nightly.rs b/tests/expectations/tests/win32-thiscall_nightly.rs
deleted file mode 100644
index 92bb13cc..00000000
--- a/tests/expectations/tests/win32-thiscall_nightly.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-#![feature(abi_thiscall)]
-
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct Foo {
-    pub _address: u8,
-}
-#[test]
-fn bindgen_test_layout_Foo() {
-    assert_eq!(
-        ::std::mem::size_of::<Foo>(),
-        1usize,
-        concat!("Size of: ", stringify!(Foo))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<Foo>(),
-        1usize,
-        concat!("Alignment of ", stringify!(Foo))
-    );
-}
-extern "thiscall" {
-    #[link_name = "\u{1}?test@Foo@@QAEXXZ"]
-    pub fn Foo_test(this: *mut Foo);
-}
-extern "thiscall" {
-    #[link_name = "\u{1}?test2@Foo@@QAEHH@Z"]
-    pub fn Foo_test2(
-        this: *mut Foo,
-        var: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-impl Foo {
-    #[inline]
-    pub unsafe fn test(&mut self) {
-        Foo_test(self)
-    }
-    #[inline]
-    pub unsafe fn test2(
-        &mut self,
-        var: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int {
-        Foo_test2(self, var)
-    }
-}
diff --git a/tests/expectations/tests/win32-vectorcall-1_0.rs b/tests/expectations/tests/win32-vectorcall-1_0.rs
deleted file mode 100644
index 131dbdf3..00000000
--- a/tests/expectations/tests/win32-vectorcall-1_0.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
diff --git a/tests/expectations/tests/win32-vectorcall-nightly.rs b/tests/expectations/tests/win32-vectorcall-nightly.rs
deleted file mode 100644
index 163741df..00000000
--- a/tests/expectations/tests/win32-vectorcall-nightly.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-#![cfg(feature = "nightly")]
-#![feature(abi_vectorcall)]
-
-extern "vectorcall" {
-    #[link_name = "\u{1}test_vectorcall@@16"]
-    pub fn test_vectorcall(
-        a: ::std::os::raw::c_int,
-        b: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
diff --git a/tests/expectations/tests/with_array_pointers_arguments.rs b/tests/expectations/tests/with_array_pointers_arguments.rs
deleted file mode 100644
index 2a7d1802..00000000
--- a/tests/expectations/tests/with_array_pointers_arguments.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn test_fn(
-        a: f32,
-        arr: *mut [::std::os::raw::c_int; 20usize],
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn test_fn2(
-        arr: *const [f32; 20usize],
-        b: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-pub type defArr = [::std::os::raw::c_char; 20usize];
-pub type foo = ::std::option::Option<unsafe extern "C" fn(a: *mut defArr)>;
-extern "C" {
-    pub fn bar(a: *mut defArr);
-}
diff --git a/tests/expectations/tests/without_array_pointers_arguments.rs b/tests/expectations/tests/without_array_pointers_arguments.rs
deleted file mode 100644
index c4acdb3e..00000000
--- a/tests/expectations/tests/without_array_pointers_arguments.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-extern "C" {
-    pub fn test_fn(
-        a: f32,
-        arr: *mut ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-extern "C" {
-    pub fn test_fn2(
-        arr: *const f32,
-        b: ::std::os::raw::c_int,
-    ) -> ::std::os::raw::c_int;
-}
-pub type defArr = [::std::os::raw::c_char; 20usize];
-pub type foo =
-    ::std::option::Option<unsafe extern "C" fn(a: *mut ::std::os::raw::c_char)>;
-extern "C" {
-    pub fn bar(a: *mut ::std::os::raw::c_char);
-}
diff --git a/tests/expectations/tests/zero-size-array-align.rs b/tests/expectations/tests/zero-size-array-align.rs
deleted file mode 100644
index d7d0f661..00000000
--- a/tests/expectations/tests/zero-size-array-align.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct dm_deps {
-    pub count: ::std::os::raw::c_uint,
-    pub filler: ::std::os::raw::c_uint,
-    pub device: __IncompleteArrayField<::std::os::raw::c_ulonglong>,
-}
-#[test]
-fn bindgen_test_layout_dm_deps() {
-    const UNINIT: ::std::mem::MaybeUninit<dm_deps> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<dm_deps>(),
-        8usize,
-        concat!("Size of: ", stringify!(dm_deps))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<dm_deps>(),
-        8usize,
-        concat!("Alignment of ", stringify!(dm_deps))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dm_deps),
-            "::",
-            stringify!(count)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).filler) as usize - ptr as usize },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dm_deps),
-            "::",
-            stringify!(filler)
-        )
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(dm_deps),
-            "::",
-            stringify!(device)
-        )
-    );
-}
diff --git a/tests/expectations/tests/zero-sized-array.rs b/tests/expectations/tests/zero-sized-array.rs
deleted file mode 100644
index 4ba52498..00000000
--- a/tests/expectations/tests/zero-sized-array.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-#![allow(
-    dead_code,
-    non_snake_case,
-    non_camel_case_types,
-    non_upper_case_globals
-)]
-
-#[repr(C)]
-#[derive(Default)]
-pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-impl<T> __IncompleteArrayField<T> {
-    #[inline]
-    pub const fn new() -> Self {
-        __IncompleteArrayField(::std::marker::PhantomData, [])
-    }
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        self as *const _ as *const T
-    }
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        self as *mut _ as *mut T
-    }
-    #[inline]
-    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-        ::std::slice::from_raw_parts(self.as_ptr(), len)
-    }
-    #[inline]
-    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-    }
-}
-impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        fmt.write_str("__IncompleteArrayField")
-    }
-}
-/// Bizarrely enough, this should *not* get an `_address` field.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ZeroSizedArray {
-    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_ZeroSizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<ZeroSizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ZeroSizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).arr) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ZeroSizedArray),
-            "::",
-            stringify!(arr)
-        )
-    );
-}
-/// And nor should this get an `_address` field.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ContainsZeroSizedArray {
-    pub zsa: ZeroSizedArray,
-}
-#[test]
-fn bindgen_test_layout_ContainsZeroSizedArray() {
-    const UNINIT: ::std::mem::MaybeUninit<ContainsZeroSizedArray> =
-        ::std::mem::MaybeUninit::uninit();
-    let ptr = UNINIT.as_ptr();
-    assert_eq!(
-        ::std::mem::size_of::<ContainsZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ContainsZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ContainsZeroSizedArray))
-    );
-    assert_eq!(
-        unsafe { ::std::ptr::addr_of!((*ptr).zsa) as usize - ptr as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(ContainsZeroSizedArray),
-            "::",
-            stringify!(zsa)
-        )
-    );
-}
-/// Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
-/// either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct InheritsZeroSizedArray {
-    pub _base: ZeroSizedArray,
-}
-#[test]
-fn bindgen_test_layout_InheritsZeroSizedArray() {
-    assert_eq!(
-        ::std::mem::size_of::<InheritsZeroSizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(InheritsZeroSizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<InheritsZeroSizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(InheritsZeroSizedArray))
-    );
-}
-/// And this should not get an `_address` field either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct DynamicallySizedArray {
-    pub arr: __IncompleteArrayField<::std::os::raw::c_char>,
-}
-#[test]
-fn bindgen_test_layout_DynamicallySizedArray() {
-    assert_eq!(
-        ::std::mem::size_of::<DynamicallySizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(DynamicallySizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<DynamicallySizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(DynamicallySizedArray))
-    );
-}
-/// No `_address` field here either.
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ContainsDynamicallySizedArray {
-    pub dsa: DynamicallySizedArray,
-}
-#[test]
-fn bindgen_test_layout_ContainsDynamicallySizedArray() {
-    assert_eq!(
-        ::std::mem::size_of::<ContainsDynamicallySizedArray>(),
-        0usize,
-        concat!("Size of: ", stringify!(ContainsDynamicallySizedArray))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<ContainsDynamicallySizedArray>(),
-        1usize,
-        concat!("Alignment of ", stringify!(ContainsDynamicallySizedArray))
-    );
-}
diff --git a/tests/headers/16-byte-alignment.h b/tests/headers/16-byte-alignment.h
deleted file mode 100644
index 235a994a..00000000
--- a/tests/headers/16-byte-alignment.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-
-struct rte_ipv4_tuple {
-        uint32_t        src_addr;
-        uint32_t        dst_addr;
-        union {
-                struct {
-                        uint16_t dport;
-                        uint16_t sport;
-                };
-                uint32_t        sctp_tag;
-        };
-};
-
-struct rte_ipv6_tuple {
-        uint8_t         src_addr[16];
-        uint8_t         dst_addr[16];
-        union {
-                struct {
-                        uint16_t dport;
-                        uint16_t sport;
-                };
-                uint32_t        sctp_tag;
-        };
-};
-
-union rte_thash_tuple {
-        struct rte_ipv4_tuple   v4;
-        struct rte_ipv6_tuple   v6;
-} __attribute__((aligned(16)));
diff --git a/tests/headers/16-byte-alignment_1_0.h b/tests/headers/16-byte-alignment_1_0.h
deleted file mode 100644
index 8a9fd491..00000000
--- a/tests/headers/16-byte-alignment_1_0.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-
-struct rte_ipv4_tuple {
-        uint32_t        src_addr;
-        uint32_t        dst_addr;
-        union {
-                struct {
-                        uint16_t dport;
-                        uint16_t sport;
-                };
-                uint32_t        sctp_tag;
-        };
-};
-
-struct rte_ipv6_tuple {
-        uint8_t         src_addr[16];
-        uint8_t         dst_addr[16];
-        union {
-                struct {
-                        uint16_t dport;
-                        uint16_t sport;
-                };
-                uint32_t        sctp_tag;
-        };
-};
-
-union rte_thash_tuple {
-        struct rte_ipv4_tuple   v4;
-        struct rte_ipv6_tuple   v6;
-} __attribute__((aligned(16)));
diff --git a/tests/headers/381-decltype-alias.hpp b/tests/headers/381-decltype-alias.hpp
deleted file mode 100644
index 0bec2fc7..00000000
--- a/tests/headers/381-decltype-alias.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-namespace std {
-  template<typename _Alloc> struct allocator_traits {
-    typedef decltype ( _S_size_type_helper ( ( _Alloc * ) 0 ) ) __size_type;
-  };
-}
diff --git a/tests/headers/abi_variadic_function.hpp b/tests/headers/abi_variadic_function.hpp
deleted file mode 100644
index 2141535c..00000000
--- a/tests/headers/abi_variadic_function.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-char __attribute__((ms_abi)) a(char, ...);
-char b(char, ...);
diff --git a/tests/headers/accessors.hpp b/tests/headers/accessors.hpp
deleted file mode 100644
index 4c23e35d..00000000
--- a/tests/headers/accessors.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-struct SomeAccessors {
-    int mNoAccessor;
-    /** <div rustbindgen accessor></div> */
-    int mBothAccessors;
-    /** <div rustbindgen accessor="unsafe"></div> */
-    int mUnsafeAccessors;
-    /** <div rustbindgen accessor="immutable"></div> */
-    int mImmutableAccessor;
-};
-
-/** <div rustbindgen accessor></div> */
-struct AllAccessors {
-    int mBothAccessors;
-    int mAlsoBothAccessors;
-};
-
-/** <div rustbindgen accessor="unsafe"></div> */
-struct AllUnsafeAccessors {
-    int mBothAccessors;
-    int mAlsoBothAccessors;
-};
-
-/** <div rustbindgen accessor></div> */
-struct ContradictAccessors {
-    int mBothAccessors;
-    /** <div rustbindgen accessor="false"></div> */
-    int mNoAccessors;
-    /** <div rustbindgen accessor="unsafe"></div> */
-    int mUnsafeAccessors;
-    /** <div rustbindgen accessor="immutable"></div> */
-    int mImmutableAccessor;
-};
-
-/** <div rustbindgen accessor replaces="Replaced"></div> */
-struct Replacing {
-    int mAccessor;
-};
-
-struct Replaced {
-    int noOp;
-};
-
-/** <div rustbindgen accessor></div> */
-struct Wrapper {
-    Replaced mReplaced;
-};
diff --git a/tests/headers/allowlist-file.hpp b/tests/headers/allowlist-file.hpp
deleted file mode 100644
index b0354a04..00000000
--- a/tests/headers/allowlist-file.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --allowlist-file ".*/allowlisted/file.*" --allowlist-type AllowlistMe -- -Itests/headers
-
-
-// Forward declaration of struct that's defined in an allowlisted file.
-struct StructWithAllowlistedDefinition;
-
-#include "allowlisted/file.hpp"
-
-// Actual definition of struct that has a forward declaration in an allowlisted file.
-struct StructWithAllowlistedFwdDecl {
-    int b;
-};
-
-class Ignored {
-    char c;
-};
-
-// Also have an explicitly allowlisted type
-class AllowlistMe {
-    int foo;
-};
diff --git a/tests/headers/allowlist-namespaces-basic.hpp b/tests/headers/allowlist-namespaces-basic.hpp
deleted file mode 100644
index fb4dd1be..00000000
--- a/tests/headers/allowlist-namespaces-basic.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type outer::inner::Helper
-
-namespace outer {
-  namespace inner {
-    struct Helper {};
-  }
-  struct Test {
-    inner::Helper helper;
-  };
-}
diff --git a/tests/headers/allowlist-namespaces.hpp b/tests/headers/allowlist-namespaces.hpp
deleted file mode 100644
index 2cffe9d3..00000000
--- a/tests/headers/allowlist-namespaces.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type '.*'
-
-namespace outer {
-  namespace inner {
-    struct Helper {};
-  }
-  struct Test {
-    inner::Helper helper;
-  };
-}
diff --git a/tests/headers/allowlist_basic.hpp b/tests/headers/allowlist_basic.hpp
deleted file mode 100644
index ef858c95..00000000
--- a/tests/headers/allowlist_basic.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --allowlist-type AllowlistMe
-
-template<typename T>
-class AllowlistMe {
-  class Inner {
-    T bar;
-  };
-
-  int foo;
-  Inner bar;
-};
-
-struct DontAllowlistMe {
-  void* foo;
-  double _Complex noComplexGenerated;
-};
diff --git a/tests/headers/allowlist_fix.hpp b/tests/headers/allowlist_fix.hpp
deleted file mode 100644
index ff810fc6..00000000
--- a/tests/headers/allowlist_fix.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --allowlist-function 'Servo_.*' --blocklist-type Test --raw-line "pub enum Test {}"
-
-struct Test {};
-extern "C" void Servo_Test(Test* a);
diff --git a/tests/headers/allowlist_vars.h b/tests/headers/allowlist_vars.h
deleted file mode 100644
index 07fa2815..00000000
--- a/tests/headers/allowlist_vars.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#define NONE      0
-#define FOO       5
-#define FOOB     -2
-#define FOOBAR  (-10)
diff --git a/tests/headers/allowlist_warnings.h b/tests/headers/allowlist_warnings.h
deleted file mode 100644
index 83c9e259..00000000
--- a/tests/headers/allowlist_warnings.h
+++ /dev/null
@@ -1,2 +0,0 @@
-// bindgen-flags: --allowlist-function "doesnt_match_anything"
-int non_matched_function(int arg);
diff --git a/tests/headers/allowlisted-item-references-no-hash.hpp b/tests/headers/allowlisted-item-references-no-hash.hpp
deleted file mode 100644
index 56c2a39f..00000000
--- a/tests/headers/allowlisted-item-references-no-hash.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --allowlist-type "AllowlistMe" --no-hash "NoHash"
-
-struct NoHash {};
-
-class AllowlistMe {
-  NoHash a;
-};
diff --git a/tests/headers/allowlisted-item-references-no-partialeq.hpp b/tests/headers/allowlisted-item-references-no-partialeq.hpp
deleted file mode 100644
index d85fb6b7..00000000
--- a/tests/headers/allowlisted-item-references-no-partialeq.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --allowlist-type "AllowlistMe" --no-partialeq "NoPartialEq"
-
-struct NoPartialEq {};
-
-class AllowlistMe {
-  NoPartialEq a;
-};
diff --git a/tests/headers/allowlisted/file.hpp b/tests/headers/allowlisted/file.hpp
deleted file mode 100644
index 5f360e5e..00000000
--- a/tests/headers/allowlisted/file.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-void SomeFunction();
-extern int someVar;
-#define SOME_DEFUN 123
-
-class someClass {
-  void somePrivateMethod();
-public:
-  void somePublicMethod(int foo);
-};
-
-extern "C" void ExternFunction();
-
-namespace foo {
-  void NamespacedFunction();
-}
-
-
-struct StructWithAllowlistedFwdDecl;
-
-struct StructWithAllowlistedDefinition {
-    StructWithAllowlistedFwdDecl* other;
-};
diff --git a/tests/headers/allowlisted_item_references_no_copy.hpp b/tests/headers/allowlisted_item_references_no_copy.hpp
deleted file mode 100644
index 9feb3054..00000000
--- a/tests/headers/allowlisted_item_references_no_copy.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --allowlist-type "AllowlistMe" --no-copy "NoCopy"
-
-struct NoCopy {};
-
-class AllowlistMe {
-  NoCopy a;
-};
diff --git a/tests/headers/annotation_hide.hpp b/tests/headers/annotation_hide.hpp
deleted file mode 100644
index 3c82c9a2..00000000
--- a/tests/headers/annotation_hide.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-
-/**
- * <div rustbindgen="true" hide="true"></div>
- */
-struct C;
-
-/**
- * <div rustbindgen opaque></div>
- */
-struct D {
-    int a;
-};
-
-struct NotAnnotated {
-    int f;
-};
diff --git a/tests/headers/anon-fields-prefix.h b/tests/headers/anon-fields-prefix.h
deleted file mode 100644
index 8dcae0c6..00000000
--- a/tests/headers/anon-fields-prefix.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --anon-fields-prefix "u"
-
-union color {
-  struct {
-    unsigned char r;
-    unsigned char g;
-    unsigned char b;
-  };
-  struct {
-    unsigned char y;
-    unsigned char u;
-    unsigned char v;
-  };
-  unsigned char v3[3];
-};
diff --git a/tests/headers/anon_enum.hpp b/tests/headers/anon_enum.hpp
deleted file mode 100644
index bbd52240..00000000
--- a/tests/headers/anon_enum.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-struct Test {
-  int foo;
-  float bar;
-  enum { T_NONE };
-};
-
-typedef enum {
-  Foo,
-  Bar,
-} Baz;
diff --git a/tests/headers/anon_enum_allowlist.h b/tests/headers/anon_enum_allowlist.h
deleted file mode 100644
index 94119a87..00000000
--- a/tests/headers/anon_enum_allowlist.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --allowlist-var "NODE_.*" --rustified-enum ".*"
-
-enum {
-  NODE_FLAG_FOO,
-  NODE_FLAG_BAR,
-};
diff --git a/tests/headers/anon_enum_trait.hpp b/tests/headers/anon_enum_trait.hpp
deleted file mode 100644
index cc0cd389..00000000
--- a/tests/headers/anon_enum_trait.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-
-template<typename _Tp>
-class DataType {
-public:
-    typedef _Tp         value_type;
-    typedef value_type  work_type;
-    typedef value_type  channel_type;
-    typedef value_type  vec_type;
-    enum { generic_type = 1,
-           depth        = -1,
-           channels     = 1,
-           fmt          = 0,
-           type = -1,
-         };
-};
-
-struct Foo {
-  enum {
-    Bar = 0,
-    Baz = 0,
-  };
-};
diff --git a/tests/headers/anon_struct_in_union.h b/tests/headers/anon_struct_in_union.h
deleted file mode 100644
index 2587ede5..00000000
--- a/tests/headers/anon_struct_in_union.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct s {
-  union {
-    struct inner {
-      int b;
-    } field;
-  } u;
-};
diff --git a/tests/headers/anon_struct_in_union_1_0.h b/tests/headers/anon_struct_in_union_1_0.h
deleted file mode 100644
index 6b59723a..00000000
--- a/tests/headers/anon_struct_in_union_1_0.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct s {
-  union {
-    struct inner {
-      int b;
-    } field;
-  } u;
-};
diff --git a/tests/headers/anon_union.hpp b/tests/headers/anon_union.hpp
deleted file mode 100644
index e4be25bc..00000000
--- a/tests/headers/anon_union.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-template<typename T>
-struct TErrorResult {
-  enum UnionState {
-    HasMessage,
-    HasException,
-  };
-  int mResult;
-  struct Message;
-  struct DOMExceptionInfo;
-  union {
-    Message* mMessage;
-    DOMExceptionInfo* mDOMExceptionInfo;
-  };
-
-  bool mMightHaveUnreported;
-  UnionState mUnionState;
-};
-
-struct ErrorResult : public TErrorResult<int> {
-};
diff --git a/tests/headers/anon_union_1_0.hpp b/tests/headers/anon_union_1_0.hpp
deleted file mode 100644
index 3d9ae3dd..00000000
--- a/tests/headers/anon_union_1_0.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-
-template<typename T>
-struct TErrorResult {
-  enum UnionState {
-    HasMessage,
-    HasException,
-  };
-  int mResult;
-  struct Message;
-  struct DOMExceptionInfo;
-  union {
-    Message* mMessage;
-    DOMExceptionInfo* mDOMExceptionInfo;
-  };
-
-  bool mMightHaveUnreported;
-  UnionState mUnionState;
-};
-
-struct ErrorResult : public TErrorResult<int> {
-};
diff --git a/tests/headers/anonymous-template-types.hpp b/tests/headers/anonymous-template-types.hpp
deleted file mode 100644
index d4ad534b..00000000
--- a/tests/headers/anonymous-template-types.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// bindgen-flags:  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
-
-template <typename T, typename>
-struct Foo {
-    T t_member;
-};
-
-template <typename U, typename>
-struct Bar {
-    char member;
-};
-
-template <typename, typename V>
-struct Quux {
-    V v_member;
-};
-
-template <typename, typename W>
-struct Lobo {
-    char also_member;
-};
-
-template <typename>
-using AliasWithAnonType = char;
diff --git a/tests/headers/arg_keyword.hpp b/tests/headers/arg_keyword.hpp
deleted file mode 100644
index 283fcf23..00000000
--- a/tests/headers/arg_keyword.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-// This comment exists to ensure that `--dump-preprocessed-input` doesn't strip
-// comments.
-void foo(const char* type);
diff --git a/tests/headers/array-of-zero-sized-types.hpp b/tests/headers/array-of-zero-sized-types.hpp
deleted file mode 100644
index 87b36d41..00000000
--- a/tests/headers/array-of-zero-sized-types.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * This should get an `_address` byte.
- */
-struct Empty {};
-
-/**
- * This should not get an `_address` byte, since each `Empty` gets one, meaning
- * that this object is addressable.
- */
-struct HasArrayOfEmpty {
-    Empty empties[10];
-};
diff --git a/tests/headers/attribute_warn_unused_result.hpp b/tests/headers/attribute_warn_unused_result.hpp
deleted file mode 100644
index 26fda091..00000000
--- a/tests/headers/attribute_warn_unused_result.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rust-target 1.27 --enable-function-attribute-detection
-
-class Foo {
-public:
-    __attribute__((warn_unused_result))
-    int foo(int);
-};
-
-__attribute__((warn_unused_result))
-int foo(int);
diff --git a/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp b/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
deleted file mode 100644
index 21550307..00000000
--- a/tests/headers/attribute_warn_unused_result_no_attribute_detection.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rust-target 1.27
-
-class Foo {
-public:
-    __attribute__((warn_unused_result))
-    int foo(int);
-};
-
-__attribute__((warn_unused_result))
-int foo(int);
diff --git a/tests/headers/attribute_warn_unused_result_pre_1_27.hpp b/tests/headers/attribute_warn_unused_result_pre_1_27.hpp
deleted file mode 100644
index 25127d9c..00000000
--- a/tests/headers/attribute_warn_unused_result_pre_1_27.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-class Foo {
-public:
-    __attribute__((warn_unused_result))
-    int foo(int);
-};
-
-__attribute__((warn_unused_result))
-int foo(int);
diff --git a/tests/headers/auto.hpp b/tests/headers/auto.hpp
deleted file mode 100644
index b5f6d5f3..00000000
--- a/tests/headers/auto.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: -- -std=c++14
-// bindgen-unstable
-
-class Foo {
-  static constexpr auto kFoo = 2 == 2;
-};
-
-template<typename T>
-class Bar {
-  static const constexpr auto kBar = T(1);
-};
-
-template<typename T> auto Test1() {
-  return T(1);
-}
-
-auto Test2() {
-  return Test1<unsigned int>();
-}
diff --git a/tests/headers/bad-namespace-parenthood-inheritance.hpp b/tests/headers/bad-namespace-parenthood-inheritance.hpp
deleted file mode 100644
index ce21a401..00000000
--- a/tests/headers/bad-namespace-parenthood-inheritance.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace std
-{
-  template < typename > struct char_traits;
-}
-namespace __gnu_cxx
-{
-  template < typename > struct char_traits;
-}
-namespace std
-{
-  template < class _CharT > struct char_traits:__gnu_cxx::char_traits <
-    _CharT >
-  {
-  };
-}
diff --git a/tests/headers/base-to-derived.hpp b/tests/headers/base-to-derived.hpp
deleted file mode 100644
index ea31e0f2..00000000
--- a/tests/headers/base-to-derived.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-struct false_type {};
-
-template<typename _From, typename _To, bool>
-struct __is_base_to_derived_ref;
-
-template<typename _From, typename _To>
-struct __is_base_to_derived_ref<_From, _To, true>
-{
-  typedef _To type;
-
-  static constexpr bool value = type::value;
-};
-
-template<typename _From, typename _To>
-struct __is_base_to_derived_ref<_From, _To, false>
-: public false_type
-{ };
diff --git a/tests/headers/bindgen-union-inside-namespace.hpp b/tests/headers/bindgen-union-inside-namespace.hpp
deleted file mode 100644
index 6a7d3a30..00000000
--- a/tests/headers/bindgen-union-inside-namespace.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --enable-cxx-namespaces
-
-namespace foo {
-  union Bar {
-    int foo;
-    int bar;
-  };
-}
diff --git a/tests/headers/bitfield-32bit-overflow.h b/tests/headers/bitfield-32bit-overflow.h
deleted file mode 100644
index 90796996..00000000
--- a/tests/headers/bitfield-32bit-overflow.h
+++ /dev/null
@@ -1,36 +0,0 @@
-
-struct MuchBitfield {
-  char m0 : 1;
-  char m1 : 1;
-  char m2 : 1;
-  char m3 : 1;
-  char m4 : 1;
-  char m5 : 1;
-  char m6 : 1;
-  char m7 : 1;
-  char m8 : 1;
-  char m9 : 1;
-  char m10 : 1;
-  char m11 : 1;
-  char m12 : 1;
-  char m13 : 1;
-  char m14 : 1;
-  char m15 : 1;
-  char m16 : 1;
-  char m17 : 1;
-  char m18 : 1;
-  char m19 : 1;
-  char m20 : 1;
-  char m21 : 1;
-  char m22 : 1;
-  char m23 : 1;
-  char m24 : 1;
-  char m25 : 1;
-  char m26 : 1;
-  char m27 : 1;
-  char m28 : 1;
-  char m29 : 1;
-  char m30 : 1;
-  char m31 : 1;
-  char m32 : 1;
-};
diff --git a/tests/headers/bitfield-enum-basic.hpp b/tests/headers/bitfield-enum-basic.hpp
deleted file mode 100644
index 339fb4d5..00000000
--- a/tests/headers/bitfield-enum-basic.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// bindgen-flags: --bitfield-enum "Foo|Buz|NS_.*|DUMMY_.*" --rustified-enum ".*" -- -std=c++11
-
-enum Foo {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
-
-enum class Buz : signed char {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
-
-enum {
-  NS_FOO = 1 << 0,
-  NS_BAR = 1 << 1,
-};
-
-class Dummy {
-  enum {
-    DUMMY_FOO = 1 << 0,
-    DUMMY_BAR = 1 << 1,
-  };
-};
diff --git a/tests/headers/bitfield-enum-repr-c.hpp b/tests/headers/bitfield-enum-repr-c.hpp
deleted file mode 100644
index 20a3f9db..00000000
--- a/tests/headers/bitfield-enum-repr-c.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --bitfield-enum "Foo" --rust-target 1.27  -- -std=c++11
-
-enum Foo {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
diff --git a/tests/headers/bitfield-enum-repr-transparent.hpp b/tests/headers/bitfield-enum-repr-transparent.hpp
deleted file mode 100644
index e53bb075..00000000
--- a/tests/headers/bitfield-enum-repr-transparent.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --bitfield-enum "Foo" --rust-target 1.28  -- -std=c++11
-
-enum Foo {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
diff --git a/tests/headers/bitfield-large.hpp b/tests/headers/bitfield-large.hpp
deleted file mode 100644
index 2e349279..00000000
--- a/tests/headers/bitfield-large.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-struct HasBigBitfield {
-  __int128 x : 128;
-};
-
-
-struct HasTwoBigBitfields {
-  __int128 x : 80;
-  __int128 y : 48;
-};
diff --git a/tests/headers/bitfield-linux-32.hpp b/tests/headers/bitfield-linux-32.hpp
deleted file mode 100644
index b9a480df..00000000
--- a/tests/headers/bitfield-linux-32.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: -- --target=i586-unknown-linux
-
-typedef unsigned long long uint64_t;
-
-struct Test {
-  uint64_t foo;
-  uint64_t x : 56;
-  uint64_t y : 8;
-};
diff --git a/tests/headers/bitfield-method-same-name.hpp b/tests/headers/bitfield-method-same-name.hpp
deleted file mode 100644
index d66f16c0..00000000
--- a/tests/headers/bitfield-method-same-name.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-struct Foo {
-    char type_ : 3;
-    char type();
-    void set_type_(char c);
-    void set_type(char c);
-};
diff --git a/tests/headers/bitfield_align.h b/tests/headers/bitfield_align.h
deleted file mode 100644
index 7b9527a2..00000000
--- a/tests/headers/bitfield_align.h
+++ /dev/null
@@ -1,49 +0,0 @@
-struct A {
-  unsigned char x;
-  unsigned b1 : 1;
-  unsigned b2 : 1;
-  unsigned b3 : 1;
-  unsigned b4 : 1;
-  unsigned b5 : 1;
-  unsigned b6 : 1;
-  unsigned b7 : 1;
-  unsigned b8 : 1;
-  unsigned b9 : 1;
-  unsigned b10 : 1;
-  unsigned char y;
-};
-
-struct B {
-  unsigned foo : 31;
-  unsigned char bar : 1;
-};
-
-struct C {
-  unsigned char x;
-  unsigned b1 : 1;
-  unsigned b2 : 1;
-  unsigned baz;
-};
-
-struct Date1 {
-   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
-   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
-   unsigned short nMonth    : 5;    // 0..12  (5 bits)
-   unsigned short nYear     : 8;    // 0..100 (8 bits)
-};
-
-struct Date2 {
-   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
-   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
-   unsigned short nMonth    : 5;    // 0..12  (5 bits)
-   unsigned short nYear     : 8;    // 0..100 (8 bits)
-   unsigned char byte : 8;
-};
-
-struct Date3 {
-   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
-   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
-   unsigned short nMonth    : 5;    // 0..12  (5 bits)
-   unsigned short nYear     : 8;    // 0..100 (8 bits)
-   unsigned char byte;
-};
diff --git a/tests/headers/bitfield_align_2.h b/tests/headers/bitfield_align_2.h
deleted file mode 100644
index cb0f2e20..00000000
--- a/tests/headers/bitfield_align_2.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" --raw-line '#![cfg(not(target_os="windows"))]'
-enum MyEnum {
-    ONE,
-    TWO,
-    THREE,
-    FOUR
-};
-
-struct TaggedPtr {
-    enum MyEnum tag : 2;
-    long   ptr : 62;
-};
diff --git a/tests/headers/bitfield_large_overflow.hpp b/tests/headers/bitfield_large_overflow.hpp
deleted file mode 100644
index 9e040ae3..00000000
--- a/tests/headers/bitfield_large_overflow.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-struct {
-  unsigned : 632;
-} a;
diff --git a/tests/headers/bitfield_method_mangling.h b/tests/headers/bitfield_method_mangling.h
deleted file mode 100644
index 257648ee..00000000
--- a/tests/headers/bitfield_method_mangling.h
+++ /dev/null
@@ -1,5 +0,0 @@
-typedef struct
-{
-  unsigned int pad3: 24;
-  unsigned int type: 8;
-} mach_msg_type_descriptor_t;
diff --git a/tests/headers/bitfield_pragma_packed.h b/tests/headers/bitfield_pragma_packed.h
deleted file mode 100644
index b4011ca8..00000000
--- a/tests/headers/bitfield_pragma_packed.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma pack(push, 1)
-struct Struct {
-    unsigned char a : 1;
-    unsigned char b : 1;
-    unsigned char c : 6;
-    unsigned short int d : 16;
-    unsigned char e : 8;
-};
-#pragma pack(pop)
diff --git a/tests/headers/block_return_type.h b/tests/headers/block_return_type.h
deleted file mode 100644
index be76cb59..00000000
--- a/tests/headers/block_return_type.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --generate-block --block-extern-crate -- -fblocks
-// bindgen-osx-only
-
-int (^func(void))(int, int);
diff --git a/tests/headers/blocklist-and-impl-debug.hpp b/tests/headers/blocklist-and-impl-debug.hpp
deleted file mode 100644
index 14e17537..00000000
--- a/tests/headers/blocklist-and-impl-debug.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --impl-debug --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
-
-struct BlocklistMe {};
-
-/**
- * Because this type contains a blocklisted type, it should not derive Debug.
- */
-struct ShouldManuallyImplDebug {
-    BlocklistMe a;
-};
diff --git a/tests/headers/blocklist-file.hpp b/tests/headers/blocklist-file.hpp
deleted file mode 100644
index ad8bcd66..00000000
--- a/tests/headers/blocklist-file.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: --blocklist-file ".*/blocklisted/file.*" -- -Itests/headers
-
-// Forward declaration of struct that's defined in a blocklisted file.
-struct StructWithBlocklistedDefinition;
-
-#include "blocklisted/file.hpp"
-#include "blocklisted/fake-stdint.h"
-
-struct SizedIntegers {
-    uint8_t x;
-    uint16_t y;
-    uint32_t z;
-};
-
-// Actual definition of struct that has a forward declaration in a blocklisted file.
-struct StructWithBlocklistedFwdDecl {
-    uint8_t b;
-};
diff --git a/tests/headers/blocklist-function.hpp b/tests/headers/blocklist-function.hpp
deleted file mode 100644
index d7c8bb35..00000000
--- a/tests/headers/blocklist-function.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --blocklist-function "ExternFunction" --blocklist-function "foo::NamespacedFunction" --blocklist-function "C_ClassMethod" --enable-cxx-namespaces
-
-extern "C" void ExternFunction();
-
-namespace foo {
-  void NamespacedFunction();
-}
-
-namespace bar {
-  void NamespacedFunction();
-}
-
-class C {
-public:
-  void ClassMethod();
-};
diff --git a/tests/headers/blocklist-item.hpp b/tests/headers/blocklist-item.hpp
deleted file mode 100644
index 2d795d5a..00000000
--- a/tests/headers/blocklist-item.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --blocklist-item "SomeFunction" --blocklist-item "SOME_DEFUN" --blocklist-item "someVar" --blocklist-item "ExternFunction" --blocklist-item "foo::NamespacedFunction" --blocklist-item "someClass.*" --enable-cxx-namespaces
-
-void SomeFunction();
-extern int someVar;
-#define SOME_DEFUN 123
-
-class someClass {
-  void somePrivateMethod();
-public:
-  void somePublicMethod(int foo);
-};
-
-extern "C" void ExternFunction();
-
-namespace foo {
-  void NamespacedFunction();
-}
-
-namespace bar {
-  void NamespacedFunction();
-}
diff --git a/tests/headers/blocklisted/fake-stdint.h b/tests/headers/blocklisted/fake-stdint.h
deleted file mode 100644
index a8cfe010..00000000
--- a/tests/headers/blocklisted/fake-stdint.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// <stdint.h>-like types get special treatment even when blocklisted.
-typedef signed char      int8_t;
-typedef unsigned char    uint8_t;
-typedef signed short     int16_t;
-typedef unsigned short   uint16_t;
-typedef signed int       int32_t;
-typedef unsigned int     uint32_t;
diff --git a/tests/headers/blocklisted/file.hpp b/tests/headers/blocklisted/file.hpp
deleted file mode 100644
index 4bcb589e..00000000
--- a/tests/headers/blocklisted/file.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-void SomeFunction();
-extern int someVar;
-#define SOME_DEFUN 123
-
-class someClass {
-  void somePrivateMethod();
-public:
-  void somePublicMethod(int foo);
-};
-
-extern "C" void ExternFunction();
-
-namespace foo {
-  void NamespacedFunction();
-}
-
-namespace bar {
-  void NamespacedFunction();
-}
-
-
-struct StructWithBlocklistedFwdDecl;
-
-struct StructWithBlocklistedDefinition {
-    StructWithBlocklistedFwdDecl* other;
-};
diff --git a/tests/headers/blocks-signature.hpp b/tests/headers/blocks-signature.hpp
deleted file mode 100644
index eaa72526..00000000
--- a/tests/headers/blocks-signature.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --generate-block --block-extern-crate -- -fblocks
-// bindgen-osx-only
-
-#include "blocks.hpp"
diff --git a/tests/headers/blocks.hpp b/tests/headers/blocks.hpp
deleted file mode 100644
index a68de7e2..00000000
--- a/tests/headers/blocks.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// bindgen-flags: --block-extern-crate -- -fblocks
-// bindgen-osx-only
-
-typedef unsigned long long size_t;
-
-void atexit_b(void (^)(void));
-
-typedef void *dispatch_data_t;
-
-typedef bool (^dispatch_data_applier_t)(dispatch_data_t region,
-                                        size_t offset,
-                                        const void *buffer,
-                                        size_t size);
-
-bool dispatch_data_apply(dispatch_data_t data,
-                         dispatch_data_applier_t applier);
-
-bool foo(void (^)(size_t bar));
-
-bool foo_ptr(void (^*)(size_t bar));
-
-struct contains_block_pointers {
-    void (^val)(int);
-    void (^*ptr_val)(int);
-};
diff --git a/tests/headers/bug-1529681.hpp b/tests/headers/bug-1529681.hpp
deleted file mode 100644
index 17fa849a..00000000
--- a/tests/headers/bug-1529681.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++14
-//
-// https://bugzilla.mozilla.org/show_bug.cgi?id=1529681
-// https://bugs.llvm.org/show_bug.cgi?id=40813
-
-class BrowsingContext {
-  auto Tie(void* aUnused) const;
-};
diff --git a/tests/headers/builtin-template.hpp b/tests/headers/builtin-template.hpp
deleted file mode 100644
index 4e64ebc7..00000000
--- a/tests/headers/builtin-template.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace std {
-template<class T, T... Ints>
-class integer_sequence;
-template<class T, T N>
-using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
-}
diff --git a/tests/headers/c-empty-layout.h b/tests/headers/c-empty-layout.h
deleted file mode 100644
index 1fe02e89..00000000
--- a/tests/headers/c-empty-layout.h
+++ /dev/null
@@ -1 +0,0 @@
-struct Foo {};
diff --git a/tests/headers/c_naming.h b/tests/headers/c_naming.h
deleted file mode 100644
index fd84c271..00000000
--- a/tests/headers/c_naming.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: --c-naming
-
-typedef const struct a {
-    int a;
-} *a;
-
-union b {
-    int a;
-    int b;
-};
-typedef union b b;
-
-enum c {
-    A,
-};
-
-void takes_a(a arg) {}
-void takes_b(b arg) {}
-void takes_c(enum c arg) {}
diff --git a/tests/headers/call-conv-field.h b/tests/headers/call-conv-field.h
deleted file mode 100644
index da45ba1d..00000000
--- a/tests/headers/call-conv-field.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32
-// bindgen-unstable
-//
-// We can only check that this builds, but not that it actually passes, because
-// we have no CI on the target platform.
-
-struct JNINativeInterface_ {
-  int (__stdcall *GetVersion)(void *env);
-  unsigned long long __hack; // A hack so the field alignment is the same than
-                             // for 64-bit, where we run CI.
-};
-
-__stdcall void bar();
diff --git a/tests/headers/call-conv-typedef.h b/tests/headers/call-conv-typedef.h
deleted file mode 100644
index 3b911dda..00000000
--- a/tests/headers/call-conv-typedef.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --raw-line "#![cfg(not(test))]" -- --target=i686-pc-win32
-
-
-typedef void (__stdcall *void_fn)();
-typedef void_fn (__stdcall *fn)(int id);
diff --git a/tests/headers/canonical-types.hpp b/tests/headers/canonical-types.hpp
deleted file mode 100644
index c8eadd7e..00000000
--- a/tests/headers/canonical-types.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-// Issue #2078. To pick up the definition of `ClassCInnerA`,
-// `ty.canonical_type().declaration().definition()` is needed.
-
-template<class T>
-class ClassA {
-public:
-    class ClassAInner {
-    public:
-        T *x;
-    };
-};
-
-template<class D, class I>
-class ClassB {
-public:
-    void foo() {
-        ((D *)0)->quux();
-    }
-};
-
-template<typename T>
-class ClassC {
-    struct ClassCInnerA;
-
-    struct ClassCInnerB {
-        ClassCInnerA *cache;
-    };
-    static_assert(sizeof(ClassCInnerB) > 0, "");
-
-    struct ClassCInnerA {
-        ClassCInnerB *member;
-    };
-
-public:
-    class ClassCInnerCRTP : public ClassB<ClassCInnerCRTP, typename ClassA<ClassCInnerA>::ClassAInner> {
-    public:
-        void quux() {
-            ((typename ClassA<ClassCInnerA>::ClassAInner *)0)->x->member;
-        }
-    };
-};
-
-class ClassD : public ClassB<ClassD, ClassC<int>::ClassCInnerCRTP> {
-public:
-    void bar() {
-        ((ClassC<int>::ClassCInnerCRTP *)0)->foo();
-    }
-};
-
diff --git a/tests/headers/canonical_path_without_namespacing.hpp b/tests/headers/canonical_path_without_namespacing.hpp
deleted file mode 100644
index 92e85842..00000000
--- a/tests/headers/canonical_path_without_namespacing.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --disable-name-namespacing
-
-namespace foo {
-  struct Bar {};
-}
-
-void baz(foo::Bar*);
diff --git a/tests/headers/char.h b/tests/headers/char.h
deleted file mode 100644
index 7cffd865..00000000
--- a/tests/headers/char.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-typedef char Char;
-typedef signed char SChar;
-typedef unsigned char UChar;
-
-struct Test {
-  char ch;
-  unsigned char u;
-  signed char d;
-  const char cch;
-  const unsigned char cu;
-  const signed char cd;
-
-  Char Cch;
-  UChar Cu;
-  SChar Cd;
-  const Char Ccch;
-  const UChar Ccu;
-  const SChar Ccd;
-};
diff --git a/tests/headers/class.hpp b/tests/headers/class.hpp
deleted file mode 100644
index a90e373f..00000000
--- a/tests/headers/class.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord --rust-target 1.40
-//
-class C {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-};
-
-class C_with_zero_length_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char zero_length_array[0];
-};
-
-class C_with_zero_length_array_2 {
-    int a;
-    char zero_length_array[0];
-};
-
-class C_with_incomplete_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char incomplete_array[];
-};
-
-class C_with_incomplete_array_2 {
-    int a;
-    char incomplete_array[];
-};
-
-class C_with_zero_length_array_and_incomplete_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char zero_length_array[0];
-    char incomplete_array[];
-};
-
-class C_with_zero_length_array_and_incomplete_array_2 {
-    int a;
-    char zero_length_array[0];
-    char incomplete_array[];
-};
-
-class WithDtor {
-    int b;
-
-    ~WithDtor() {}
-};
-
-class IncompleteArrayNonCopiable {
-  void* whatever;
-  C incomplete_array[];
-};
-
-union Union {
-    float d;
-    int i;
-};
-
-class WithUnion {
-    Union data;
-};
-
-class RealAbstractionWithTonsOfMethods {
-  void foo();
-public:
-  void bar() const;
-  void bar();
-  void bar(int foo);
-  static void sta();
-};
diff --git a/tests/headers/class_1_0.hpp b/tests/headers/class_1_0.hpp
deleted file mode 100644
index e3735eb6..00000000
--- a/tests/headers/class_1_0.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --impl-partialeq --with-derive-eq
-
-class C {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-};
-
-class C_with_zero_length_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char zero_length_array[0];
-};
-
-class C_with_zero_length_array_2 {
-    int a;
-    char zero_length_array[0];
-};
-
-class C_with_incomplete_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char incomplete_array[];
-};
-
-class C_with_incomplete_array_2 {
-    int a;
-    char incomplete_array[];
-};
-
-
-class C_with_zero_length_array_and_incomplete_array {
-    int a;
-    // More than rust limits (32)
-    char big_array[33];
-    char zero_length_array[0];
-    char incomplete_array[];
-};
-
-class C_with_zero_length_array_and_incomplete_array_2 {
-    int a;
-    char zero_length_array[0];
-    char incomplete_array[];
-};
-
-
-class WithDtor {
-    int b;
-
-    ~WithDtor() {}
-};
-
-class IncompleteArrayNonCopiable {
-  void* whatever;
-  C incomplete_array[];
-};
-
-union Union {
-    float d;
-    int i;
-};
-
-class WithUnion {
-    Union data;
-};
-
-class RealAbstractionWithTonsOfMethods {
-  void foo();
-public:
-  void bar() const;
-  void bar();
-  void bar(int foo);
-  static void sta();
-};
diff --git a/tests/headers/class_nested.hpp b/tests/headers/class_nested.hpp
deleted file mode 100644
index d6ca02c2..00000000
--- a/tests/headers/class_nested.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-class A {
-public:
-    int member_a;
-    class B {
-        int member_b;
-    };
-
-    class C;
-
-    template<typename T>
-    class D {
-      T foo;
-    };
-};
-
-class A::C {
-  int baz;
-};
-
-A::B var;
-A::D<int> baz;
-
-class D {
-    A::B member;
-};
-
-template<typename T>
-class Templated {
-    T member;
-
-    class Templated_inner {
-    public:
-        T* member_ptr;
-        void get();
-    };
-};
diff --git a/tests/headers/class_no_members.hpp b/tests/headers/class_no_members.hpp
deleted file mode 100644
index 6963e372..00000000
--- a/tests/headers/class_no_members.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-// bindgen-flags: -- -std=c++11
-
-class whatever {
-};
-
-class whatever_child: public whatever {
-};
-
-class whatever_child_with_member: public whatever {
-public:
-    int m_member;
-};
-
-static_assert(sizeof(whatever) == 1, "Testing!");
-static_assert(sizeof(whatever_child) == 1, "Testing!");
-static_assert(sizeof(whatever_child_with_member) == 4, "Testing!");
diff --git a/tests/headers/class_static.hpp b/tests/headers/class_static.hpp
deleted file mode 100644
index d8f9be6d..00000000
--- a/tests/headers/class_static.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-class MyClass {
-public:
-    static const int* example;
-    static const int* example_check_no_collision;
-};
-
-static const int* example_check_no_collision;
diff --git a/tests/headers/class_static_const.hpp b/tests/headers/class_static_const.hpp
deleted file mode 100644
index 3e320edc..00000000
--- a/tests/headers/class_static_const.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-using int32_t = int;
-typedef unsigned int uint32_t;
-
-class A {
-    static const int a = 0;
-    static const int32_t b = 077;
-    static const uint32_t c = 0xff;
-};
diff --git a/tests/headers/class_use_as.hpp b/tests/headers/class_use_as.hpp
deleted file mode 100644
index b7eaf29b..00000000
--- a/tests/headers/class_use_as.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-/**
- * <div rustbindgen="true" replaces="whatever"></div>
- */
-struct whatever_replacement {
-    int replacement;
-};
-
-struct whatever {
-    int b;
-};
-
-struct container {
-    whatever c;
-};
diff --git a/tests/headers/class_with_dtor.hpp b/tests/headers/class_with_dtor.hpp
deleted file mode 100644
index f52858a7..00000000
--- a/tests/headers/class_with_dtor.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-
-template <typename T>
-class HandleWithDtor {
-    T* ptr;
-    ~HandleWithDtor() {}
-};
-
-typedef HandleWithDtor<int> HandleValue;
-
-class WithoutDtor {
-    HandleValue shouldBeWithDtor;
-};
diff --git a/tests/headers/class_with_inner_struct.hpp b/tests/headers/class_with_inner_struct.hpp
deleted file mode 100644
index fd195fb7..00000000
--- a/tests/headers/class_with_inner_struct.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-// bindgen-flags: -- -std=c++11
-
-class A {
-    unsigned c;
-    struct Segment { int begin, end; };
-    union {
-        int f;
-    } named_union;
-    union {
-        int d;
-    };
-};
-
-class B {
-    unsigned d;
-    struct Segment { int begin, end; };
-};
-
-
-enum class StepSyntax {
-    Keyword,                     // step-start and step-end
-    FunctionalWithoutKeyword,    // steps(...)
-    FunctionalWithStartKeyword,  // steps(..., start)
-    FunctionalWithEndKeyword,    // steps(..., end)
-};
-
-class C {
-    unsigned d;
-    union {
-        struct {
-            float mX1;
-            float mY1;
-            float mX2;
-            float mY2;
-        } mFunc;
-        struct {
-            StepSyntax mStepSyntax;
-            unsigned int mSteps;
-        };
-    };
-    // To ensure it doesn't collide
-    struct Segment { int begin, end; };
-};
diff --git a/tests/headers/class_with_inner_struct_1_0.hpp b/tests/headers/class_with_inner_struct_1_0.hpp
deleted file mode 100644
index 34ed96e7..00000000
--- a/tests/headers/class_with_inner_struct_1_0.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// bindgen-flags: --rust-target 1.0  --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-// bindgen-flags: -- -std=c++11
-
-class A {
-    unsigned c;
-    struct Segment { int begin, end; };
-    union {
-        int f;
-    } named_union;
-    union {
-        int d;
-    };
-};
-
-class B {
-    unsigned d;
-    struct Segment { int begin, end; };
-};
-
-
-enum class StepSyntax {
-    Keyword,                     // step-start and step-end
-    FunctionalWithoutKeyword,    // steps(...)
-    FunctionalWithStartKeyword,  // steps(..., start)
-    FunctionalWithEndKeyword,    // steps(..., end)
-};
-
-class C {
-    unsigned d;
-    union {
-        struct {
-            float mX1;
-            float mY1;
-            float mX2;
-            float mY2;
-        } mFunc;
-        struct {
-            StepSyntax mStepSyntax;
-            unsigned int mSteps;
-        };
-    };
-    // To ensure it doesn't collide
-    struct Segment { int begin, end; };
-};
diff --git a/tests/headers/class_with_typedef.hpp b/tests/headers/class_with_typedef.hpp
deleted file mode 100644
index 7c3d3c97..00000000
--- a/tests/headers/class_with_typedef.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-typedef int AnotherInt;
-
-class C {
-public:
-    typedef int MyInt;
-    typedef const char* Lookup;
-    MyInt c;
-    MyInt* ptr;
-    MyInt arr[10];
-    AnotherInt d;
-    AnotherInt* other_ptr;
-
-    void method(MyInt c);
-    void methodRef(MyInt& c);
-    void complexMethodRef(Lookup& c);
-    void anotherMethod(AnotherInt c);
-};
-
-class D: public C {
-public:
-    MyInt* ptr;
-};
diff --git a/tests/headers/comment-indent.hpp b/tests/headers/comment-indent.hpp
deleted file mode 100644
index 96c13fcc..00000000
--- a/tests/headers/comment-indent.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-/**
- * This is a multi-line doc comment.
- *
- * This class is really really interesting, look!
- */
-class Foo {
-  /**
-   * This nested class is also a multi-line doc comment.
-   *
-   * This class is not so interesting, but worth a bit of docs too!
-   */
-  class Bar { };
-};
-
-namespace test {
-  /**
-   * I'm in a namespace, and thus I may be on a rust module, most of the time.
-   * My documentation is pretty extensive, I guess.
-   */
-  class Baz {
-    /**
-     * This member is plain awesome, just amazing.
-     *
-     * It also has super-extensive docs, with even a nice ascii-art diagram.
-     *
-     * +------+          +-------+
-     * | foo  |   ---->  | bar   |
-     * +------+          +-------+
-     */
-    int member;
-  };
-
-  inline namespace foobiedoobie {
-    /**
-     * I'm in an inline namespace, and as such I shouldn't get generated inside
-     * a rust module, except when the relevant option is specified. Also, this
-     * comment shouldn't be misaligned.
-     */
-    class InInlineNS {
-    };
-  }
-
-  /**/
-  class Bazz {};
-}
diff --git a/tests/headers/complex.h b/tests/headers/complex.h
deleted file mode 100644
index 2996be1f..00000000
--- a/tests/headers/complex.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-#define COMPLEX_TEST(ty_, name_)  \
-  struct Test##name_ {            \
-    ty_ _Complex mMember;         \
-                                  \
-  };                              \
-  struct Test##name_##Ptr {       \
-    ty_ _Complex* mMember;        \
-  };
-
-COMPLEX_TEST(double, Double)
-COMPLEX_TEST(float, Float)
-
-// FIXME: 128-byte-aligned in some machines
-// which we can't support right now in Rust.
-// COMPLEX_TEST(long double, LongDouble)
diff --git a/tests/headers/complex_global.h b/tests/headers/complex_global.h
deleted file mode 100644
index 6b9ffa53..00000000
--- a/tests/headers/complex_global.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-float _Complex globalValueFloat;
-double _Complex globalValueDouble;
-long double _Complex globalValueLongDouble;
diff --git a/tests/headers/const-const-mut-ptr.h b/tests/headers/const-const-mut-ptr.h
deleted file mode 100644
index cc7daf7c..00000000
--- a/tests/headers/const-const-mut-ptr.h
+++ /dev/null
@@ -1,3 +0,0 @@
-struct foo {
-  const int** const* const* bar;
-};
diff --git a/tests/headers/const_array.h b/tests/headers/const_array.h
deleted file mode 100644
index a337881f..00000000
--- a/tests/headers/const_array.h
+++ /dev/null
@@ -1,2 +0,0 @@
-extern const int foo[1];
-extern int bar[1];
diff --git a/tests/headers/const_array_fn_arg.h b/tests/headers/const_array_fn_arg.h
deleted file mode 100644
index ebe22861..00000000
--- a/tests/headers/const_array_fn_arg.h
+++ /dev/null
@@ -1 +0,0 @@
-void f(const int a[]);
diff --git a/tests/headers/const_bool.hpp b/tests/headers/const_bool.hpp
deleted file mode 100644
index 633a7c90..00000000
--- a/tests/headers/const_bool.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-unstable
-
-const bool k = true;
-struct A {
-  static const bool k = false;
-};
-
-typedef bool foo;
-const foo k2 = true;
diff --git a/tests/headers/const_enum_unnamed.hpp b/tests/headers/const_enum_unnamed.hpp
deleted file mode 100644
index cee87e64..00000000
--- a/tests/headers/const_enum_unnamed.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum {
-  FOO_BAR,
-  FOO_BAZ,
-};
-
-class Foo {
-  enum { FOO_BAR = 10 };
-};
diff --git a/tests/headers/const_multidim_array_fn_arg.h b/tests/headers/const_multidim_array_fn_arg.h
deleted file mode 100644
index 784a51fe..00000000
--- a/tests/headers/const_multidim_array_fn_arg.h
+++ /dev/null
@@ -1 +0,0 @@
-void f(const int a[1][1]);
diff --git a/tests/headers/const_ptr.hpp b/tests/headers/const_ptr.hpp
deleted file mode 100644
index 66744f8b..00000000
--- a/tests/headers/const_ptr.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-extern "C" {
-  void foo(const void* bar);
-}
diff --git a/tests/headers/const_resolved_ty.h b/tests/headers/const_resolved_ty.h
deleted file mode 100644
index 2521e61c..00000000
--- a/tests/headers/const_resolved_ty.h
+++ /dev/null
@@ -1,3 +0,0 @@
-typedef unsigned char uint8_t;
-
-void foo(const uint8_t* foo);
diff --git a/tests/headers/const_tparam.hpp b/tests/headers/const_tparam.hpp
deleted file mode 100644
index 05f26e4a..00000000
--- a/tests/headers/const_tparam.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-template<typename T>
-class C {
-  const T* const foo;
-  const T* bar;
-};
diff --git a/tests/headers/constant-evaluate.h b/tests/headers/constant-evaluate.h
deleted file mode 100644
index 812553ed..00000000
--- a/tests/headers/constant-evaluate.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-unstable
-// bindgen-flags: --rustified-enum ".*"
-
-enum {
-  foo = 4,
-  bar = 8,
-};
-
-typedef unsigned long long EasyToOverflow;
-const EasyToOverflow k = 0x80000000;
-
-const EasyToOverflow k_expr = 1ULL << 60;
-const EasyToOverflow wow = 1ULL << 31;
-
-const long long BAZ = (1 << foo) | bar;
-const double fuzz = (1 + 50.0f);
-const char BAZZ = '5';
-const char WAT = '\0';
-
-const char* bytestring = "Foo";
-const char* NOT_UTF8 = "\xf0\x28\x8c\x28";
diff --git a/tests/headers/constant-non-specialized-tp.hpp b/tests/headers/constant-non-specialized-tp.hpp
deleted file mode 100644
index 539c2887..00000000
--- a/tests/headers/constant-non-specialized-tp.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-// This test ensure we protect ourselves from an LLVM crash.
-
-template <class... Args>
-struct Test {
-  static constexpr bool x[] = {Args::x...};
-};
-
-template<typename... T>
-struct Outer {
-  struct Inner {
-    static constexpr int value[] = { T::value... };
-  };
-};
diff --git a/tests/headers/constified-enum-module-overflow.hpp b/tests/headers/constified-enum-module-overflow.hpp
deleted file mode 100644
index d48f2be1..00000000
--- a/tests/headers/constified-enum-module-overflow.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-template <typename> class B{};
-template <typename c> class C {
-public:
-  using U = B<c>;
-};
-class A : C<A> {
-  U u;
-};
diff --git a/tests/headers/constify-all-enums.h b/tests/headers/constify-all-enums.h
deleted file mode 100644
index 6f4364e3..00000000
--- a/tests/headers/constify-all-enums.h
+++ /dev/null
@@ -1,10 +0,0 @@
-
-enum foo {
-  THIS,
-  SHOULD_BE,
-  A_CONSTANT,
-};
-
-struct bar {
-  enum foo this_should_work;
-};
diff --git a/tests/headers/constify-enum.h b/tests/headers/constify-enum.h
deleted file mode 100644
index b8e0be3e..00000000
--- a/tests/headers/constify-enum.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum nsCSSPropertyID {
-  eCSSProperty_a,
-  eCSSProperty_b,
-
-  eCSSProperty_COUNT, /**< <div rustbindgen constant></div> */
-  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1, /**< <div rustbindgen hide></div> */
-
-  eCSSPropertyAlias_aa,
-  eCSSPropertyAlias_bb,
-
-  eCSSProperty_COUNT_unexistingVariantValue, /**< <div rustbindgen constant></div> */
-};
diff --git a/tests/headers/constify-module-enums-basic.h b/tests/headers/constify-module-enums-basic.h
deleted file mode 100644
index 631e8847..00000000
--- a/tests/headers/constify-module-enums-basic.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --constified-enum-module foo
-
-enum foo {
-  THIS,
-  SHOULD_BE,
-  A_CONSTANT,
-};
-
-typedef enum foo foo_alias1;
-typedef foo_alias1 foo_alias2;
-
-struct bar {
-  enum foo this_should_work;
-};
-
-enum foo *func1(enum foo arg1, enum foo *arg2, enum foo **arg3);
-foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3);
\ No newline at end of file
diff --git a/tests/headers/constify-module-enums-namespace.hpp b/tests/headers/constify-module-enums-namespace.hpp
deleted file mode 100644
index 5d8ea23a..00000000
--- a/tests/headers/constify-module-enums-namespace.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --constified-enum-module ns1::ns2::foo
-
-namespace ns1 {
-  namespace ns2 {
-    enum foo {
-      THIS,
-      SHOULD_BE,
-      A_CONSTANT,
-    };
-  }
-
-  namespace ns3 {
-    struct bar {
-      enum ns2::foo this_should_work;
-    };
-  }
-}
\ No newline at end of file
diff --git a/tests/headers/constify-module-enums-shadow-name.h b/tests/headers/constify-module-enums-shadow-name.h
deleted file mode 100644
index 38b26106..00000000
--- a/tests/headers/constify-module-enums-shadow-name.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --constified-enum-module foo
-
-enum foo {
-  Type,
-  Type_,
-  Type1,
-  Type__,
-};
-
-struct bar {
-  enum foo member;
-};
diff --git a/tests/headers/constify-module-enums-simple-alias.hpp b/tests/headers/constify-module-enums-simple-alias.hpp
deleted file mode 100644
index 35ac4be3..00000000
--- a/tests/headers/constify-module-enums-simple-alias.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --constified-enum-module Foo
-
-enum class Foo {
-  Variant1, Variant2, Variant3,
-};
-
-typedef Foo Foo_alias1;
-typedef Foo_alias1 Foo_alias2;
-typedef Foo_alias2 Foo_alias3;
-
-class Bar {
-  Foo baz1;
-  Foo_alias1 baz2;
-  Foo_alias2 baz3;
-  Foo_alias3 baz4;
-
-  Foo *baz_ptr1;
-  Foo_alias1 *baz_ptr2;
-  Foo_alias2 *baz_ptr3;
-  Foo_alias3 *baz_ptr4;
-};
diff --git a/tests/headers/constify-module-enums-simple-nonamespace.hpp b/tests/headers/constify-module-enums-simple-nonamespace.hpp
deleted file mode 100644
index 5b15f5c8..00000000
--- a/tests/headers/constify-module-enums-simple-nonamespace.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --constified-enum-module one::Foo
-
-namespace one {
-  enum class Foo {
-    Variant1, Variant2,
-  };
-}
-
-class Bar {
-  one::Foo baz1;
-  one::Foo* baz2;
-};
diff --git a/tests/headers/constify-module-enums-types.hpp b/tests/headers/constify-module-enums-types.hpp
deleted file mode 100644
index decf935a..00000000
--- a/tests/headers/constify-module-enums-types.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-// bindgen-flags: --constified-enum-module ".*"
-
-typedef enum foo {
-  THIS,
-  SHOULD_BE,
-  A_CONSTANT,
-  ALSO_THIS = 42,
-  AND_ALSO_THIS = 42,
-} foo;
-
-
-typedef enum {
-  Variant1, Variant2, Variant3,
-} anon_enum;
-
-
-namespace ns1 {
-  typedef enum {
-    THIS,
-    SHOULD_BE,
-    A_CONSTANT,
-    ALSO_THIS = 42,
-  } foo;
-}
-
-namespace ns2 {
-  enum class Foo {
-    Variant1,
-    Variant2,
-  };
-}
-
-typedef foo foo_alias1;
-typedef foo_alias1 foo_alias2;
-typedef foo_alias2 foo_alias3;
-
-typedef anon_enum anon_enum_alias1;
-typedef anon_enum_alias1 anon_enum_alias2;
-typedef anon_enum_alias2 anon_enum_alias3;
-
-typedef struct bar {
-  foo member1;
-  foo_alias1 member2;
-  foo_alias2 member3;
-  foo_alias3 member4;
-  ns1::foo member5;
-  ns2::Foo *member6;
-  anon_enum member7;
-  anon_enum_alias1 member8;
-  anon_enum_alias2 member9;
-  anon_enum_alias3 member10;
-} bar;
-
-class Baz {
-  ns2::Foo member1;
-};
-
-namespace one {
-  enum class Foo {
-    Variant1, Variant2,
-  };
-}
-
-class Bar {
-  one::Foo* baz;
-};
-
-foo *func1(foo arg1, foo *arg2, foo **arg3);
-foo_alias1 *func2(foo_alias1 arg1, foo_alias1 *arg2, foo_alias1 **arg3);
-
-template <class T>
-class Thing {
-  T thing;
-  T& get_thing();
-};
-
-foo func3(Thing<foo> arg1);
-foo func4(Thing< Thing<foo> > arg1);
diff --git a/tests/headers/constructor-tp.hpp b/tests/headers/constructor-tp.hpp
deleted file mode 100644
index 6e55ea78..00000000
--- a/tests/headers/constructor-tp.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-
-template<typename T>
-class Foo {
-public:
-  Foo();
-
-  void doBaz();
-};
-
-template<typename T>
-inline void
-Foo<T>::doBaz() {
-}
-
-class Bar {
-public:
-  Bar();
-};
-
-template<typename T>
-Foo<T>::Foo() {
-}
-
-inline
-Bar::Bar() {
-}
diff --git a/tests/headers/constructors.hpp b/tests/headers/constructors.hpp
deleted file mode 100644
index d4174889..00000000
--- a/tests/headers/constructors.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-
-class TestOverload {
-  // This one shouldnt' be generated.
-  TestOverload();
-public:
-  TestOverload(int);
-  TestOverload(double);
-};
-
-class TestPublicNoArgs {
-public:
-  TestPublicNoArgs();
-};
diff --git a/tests/headers/constructors_1_33.hpp b/tests/headers/constructors_1_33.hpp
deleted file mode 100644
index 7c6262d4..00000000
--- a/tests/headers/constructors_1_33.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --rust-target 1.33
-
-class TestOverload {
-  // This one shouldnt' be generated.
-  TestOverload();
-public:
-  /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
-  TestOverload(int);
-  /// Calling this should use `mem::unintialized()` and not `MaybeUninit()` as only rust 1.36 includes that.
-  TestOverload(double);
-};
-
-class TestPublicNoArgs {
-public:
-  TestPublicNoArgs();
-};
diff --git a/tests/headers/contains-vs-inherits-zero-sized.hpp b/tests/headers/contains-vs-inherits-zero-sized.hpp
deleted file mode 100644
index d354b0a2..00000000
--- a/tests/headers/contains-vs-inherits-zero-sized.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * This should get an `_address` byte.
- */
-struct Empty {};
-
-/**
- * This should not get an `_address` byte, so `sizeof(Inherits)` should be
- * `1`.
- */
-struct Inherits : public Empty {
-    bool b;
-};
-
-/**
- * This should not get an `_address` byte, but contains `Empty` which *does* get
- * one, so `sizeof(Contains)` should be `1 + 1`.
- */
-struct Contains {
-    Empty empty;
-    bool b;
-};
diff --git a/tests/headers/convert-cpp-comment-to-rust.hpp b/tests/headers/convert-cpp-comment-to-rust.hpp
deleted file mode 100644
index f5bbbf58..00000000
--- a/tests/headers/convert-cpp-comment-to-rust.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --no-layout-tests
-typedef unsigned mbedtls_mpi_uint;
-
-/**
- * \brief          MPI structure
- */
-typedef struct
-{
-    int s;                /*!<  integer sign      */
-    unsigned long n;      /*!<  total # of limbs  */
-    mbedtls_mpi_uint *p;  /*!<  pointer to limbs  */
-}
-mbedtls_mpi;
-
diff --git a/tests/headers/convert-floats.h b/tests/headers/convert-floats.h
deleted file mode 100644
index 08d9fe0b..00000000
--- a/tests/headers/convert-floats.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --no-convert-floats
-
-struct foo {
-  float bar, baz;
-  double bazz;
-  long double* bazzz;
-  float _Complex complexFloat;
-  double _Complex complexDouble;
-};
diff --git a/tests/headers/core_ffi_c.h b/tests/headers/core_ffi_c.h
deleted file mode 100644
index 6df1e2f8..00000000
--- a/tests/headers/core_ffi_c.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --use-core --rust-target 1.64 --no-convert-floats
-typedef char c_char;
-typedef double c_double;
-typedef float c_float;
-typedef int c_int;
-typedef long c_long;
-typedef long long c_longlong;
-typedef signed char c_schar;
-typedef short c_short;
-typedef unsigned char c_uchar;
-typedef unsigned int c_uint;
-typedef unsigned long c_ulong;
-typedef unsigned long long c_ulonglong;
-typedef unsigned short c_ushort;
diff --git a/tests/headers/cpp-empty-layout.hpp b/tests/headers/cpp-empty-layout.hpp
deleted file mode 100644
index 1fe02e89..00000000
--- a/tests/headers/cpp-empty-layout.hpp
+++ /dev/null
@@ -1 +0,0 @@
-struct Foo {};
diff --git a/tests/headers/crtp.hpp b/tests/headers/crtp.hpp
deleted file mode 100644
index a5477c54..00000000
--- a/tests/headers/crtp.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-template<class T>
-class Base {};
-
-class Derived : public Base<Derived> {};
-
-template<class T>
-class BaseWithDestructor {
-  ~BaseWithDestructor();
-};
-
-class DerivedFromBaseWithDestructor :
-  public BaseWithDestructor<DerivedFromBaseWithDestructor> {};
diff --git a/tests/headers/ctypes-prefix-path.h b/tests/headers/ctypes-prefix-path.h
deleted file mode 100644
index 10e06f89..00000000
--- a/tests/headers/ctypes-prefix-path.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --ctypes-prefix "libc::foo" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub mod foo { pub type c_int = i32; pub enum c_void {} } }" --rustified-enum ".*"
-struct foo {
-  int a, b;
-  void* bar;
-};
diff --git a/tests/headers/dash_language.h b/tests/headers/dash_language.h
deleted file mode 100644
index 4c8bb58d..00000000
--- a/tests/headers/dash_language.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -x c++ --std=c++11
-
-template<typename T>
-struct Foo {
-  int bar;
-};
diff --git a/tests/headers/decl_extern_int_twice.h b/tests/headers/decl_extern_int_twice.h
deleted file mode 100644
index 06f80e87..00000000
--- a/tests/headers/decl_extern_int_twice.h
+++ /dev/null
@@ -1,2 +0,0 @@
-extern int foo;
-extern int foo;
diff --git a/tests/headers/decl_ptr_to_array.h b/tests/headers/decl_ptr_to_array.h
deleted file mode 100644
index 3222cbd4..00000000
--- a/tests/headers/decl_ptr_to_array.h
+++ /dev/null
@@ -1 +0,0 @@
-int (*foo)[1];
diff --git a/tests/headers/default-enum-style-constified-module.h b/tests/headers/default-enum-style-constified-module.h
deleted file mode 100644
index a5ba6531..00000000
--- a/tests/headers/default-enum-style-constified-module.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --default-enum-style moduleconsts
-
-typedef enum { bar, baz, blap } Foo;
-void func(Foo x);
diff --git a/tests/headers/default-macro-constant-type-signed.h b/tests/headers/default-macro-constant-type-signed.h
deleted file mode 100644
index da3f1344..00000000
--- a/tests/headers/default-macro-constant-type-signed.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-macro-constant-type signed
-// All values are i32 if they fit; otherwise i64.
-#include "default-macro-constant-type.h"
diff --git a/tests/headers/default-macro-constant-type-unsigned.h b/tests/headers/default-macro-constant-type-unsigned.h
deleted file mode 100644
index 1078e852..00000000
--- a/tests/headers/default-macro-constant-type-unsigned.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-macro-constant-type unsigned
-// Negative values are i32 or i64; others are u32 or u64.
-#include "default-macro-constant-type.h"
diff --git a/tests/headers/default-macro-constant-type.h b/tests/headers/default-macro-constant-type.h
deleted file mode 100644
index a863362c..00000000
--- a/tests/headers/default-macro-constant-type.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Test default of --default-macro-constant-type
-// Negative values are i32 or i64; others are u32 or u64.
-
-#define N0 0
-#define N1 1ULL
-#define N2 2ULL
-
-#define N_1 (-1LL)
-#define N_2 (-2LL)
-
-#define MAX_U16  0xFFFFULL
-#define MAX_I16 (0x8000ULL - 1)
-
-#define MAX_I16_Plus1 (MAX_I16 + 1)
-#define MAX_U16_Plus1 (MAX_U16 + 1)
-
-#define MAX_I16_Minus1 (MAX_I16 - 1)
-#define MAX_U16_Minus1 (MAX_U16 - 1)
-
-#define MIN_U16 0
-#define MIN_I16 (- (1ULL<<15))
-
-#define MIN_U16_Plus1 (MIN_U16 + 1)
-#define MIN_I16_Plus1 (MIN_I16 + 1)
-
-#define MIN_U16_Minus1 (MIN_U16 - 1)
-#define MIN_I16_Minus1 (MIN_I16 - 1)
-
-#define MAX_U32  0xFFFFFFFFULL
-#define MAX_I32 (0x80000000ULL - 1)
-
-#define MAX_I32_Plus1 (MAX_I32 + 1)
-#define MAX_U32_Plus1 (MAX_U32 + 1)
-
-#define MAX_I32_Minus1 (MAX_I32 - 1)
-#define MAX_U32_Minus1 (MAX_U32 - 1)
-
-#define MIN_U32 0
-#define MIN_I32 (- (1ULL<<31))
-
-#define MIN_U32_Plus1 (MIN_U32 + 1)
-#define MIN_I32_Plus1 (MIN_I32 + 1)
-
-#define MIN_U32_Minus1 (MIN_U32 - 1)
-#define MIN_I32_Minus1 (MIN_I32 - 1)
-
-#define LONG12    123456789012ULL
-#define LONG_12 (- 123456789012ULL)
-
-// Function parameter and return types are not affected.
-int foo(int, signed, unsigned, char, unsigned char, signed char);
-long bar(long, long long);
diff --git a/tests/headers/default-template-parameter.hpp b/tests/headers/default-template-parameter.hpp
deleted file mode 100644
index 4deed834..00000000
--- a/tests/headers/default-template-parameter.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-template <typename T, typename U = int>
-struct Foo {
-    T t;
-    U u;
-};
-
-static Foo<bool> bar;
diff --git a/tests/headers/deleted-function.hpp b/tests/headers/deleted-function.hpp
deleted file mode 100644
index 61848a0a..00000000
--- a/tests/headers/deleted-function.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// bindgen-flags: --generate-inline-functions -- -std=c++11
-
-class A {
-public:
-      // Deleted function should not get a binding.
-      void deleted() = delete;
-
-      // Inline functions should get bindings, whether they are defined inline
-      // (in the class) or out of line.
-      inline void inline_definition() {}
-      inline void out_of_line_definition();
-
-      // TODO: This is an edge case that we get wrong: An inline function
-      // without a definition in the same translation unit should still get a
-      // binding. We currently can't distinguish this case from a deleted member
-      // function because libclang doesn't provide a direct way to query for
-      // deleted member functions. This seems acceptable, however, as an inline
-      // function without a definition in the same translation unit is unlikely
-      // to be useful in practice.
-      inline void inline_without_definition();
-};
-
-void A::out_of_line_definition() {}
-
-class B {
-public:
-     // Deleted copy constructor should not get a binding.
-     B(B&) = delete;
-};
-
-class C {
-public:
-     // Defaulted copy constructor should get a binding.
-     C(C&) = default;
-};
\ No newline at end of file
diff --git a/tests/headers/derive-bitfield-method-same-name.hpp b/tests/headers/derive-bitfield-method-same-name.hpp
deleted file mode 100644
index ea9d801f..00000000
--- a/tests/headers/derive-bitfield-method-same-name.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq --impl-debug --rust-target 1.40
-
-/// Because this struct have array larger than 32 items 
-/// and --with-derive-partialeq --impl-partialeq --impl-debug is provided, 
-/// this struct should manually implement `Debug` and `PartialEq`.
-struct Foo {
-    int large[33];
-    char type_ : 3;
-    unsigned : 8;
-    char type();
-    void set_type_(char c);
-    void set_type(char c);
-};
diff --git a/tests/headers/derive-clone.h b/tests/headers/derive-clone.h
deleted file mode 100644
index aacbcaf8..00000000
--- a/tests/headers/derive-clone.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.40
-//
-
-/// This struct should derive `Clone`.
-struct ShouldDeriveClone {
-    int large[33];
-};
diff --git a/tests/headers/derive-clone_1_0.h b/tests/headers/derive-clone_1_0.h
deleted file mode 100644
index 34ef40ae..00000000
--- a/tests/headers/derive-clone_1_0.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.0
-
-/// Since builtin `Clone` impls were introduced in Rust 1.21 this struct 
-/// should impl `Clone` "manually".
-struct ShouldImplClone {
-    int large[33];
-};
diff --git a/tests/headers/derive-custom.h b/tests/headers/derive-custom.h
deleted file mode 100644
index 8c57278c..00000000
--- a/tests/headers/derive-custom.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// bindgen-flags: --no-derive-debug --no-derive-copy --default-enum-style rust --no-layout-tests
-
-/** <div rustbindgen derive="Debug"></div> */
-struct my_type;
-
-/** <div rustbindgen derive="Clone"></div> */
-struct my_type;
-
-struct my_type {
-    int a;
-};
-
-/**
- * <div rustbindgen derive="Debug"></div>
- * <div rustbindgen derive="Clone"></div>
- */
-struct my_type2;
-
-struct my_type2 {
-    unsigned a;
-};
-
-/**
- * <div rustbindgen derive="Debug" derive="Clone"></div>
- */
-struct my_type3 {
-    unsigned long a;
-};
diff --git a/tests/headers/derive-debug-bitfield-core.hpp b/tests/headers/derive-debug-bitfield-core.hpp
deleted file mode 100644
index 2073cc2a..00000000
--- a/tests/headers/derive-debug-bitfield-core.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --impl-debug --use-core --raw-line "extern crate core;" --rust-target 1.40
-
-class C {
-  bool a: 1;
-  bool b: 7;
-  int large_array[50];
-};
diff --git a/tests/headers/derive-debug-bitfield.hpp b/tests/headers/derive-debug-bitfield.hpp
deleted file mode 100644
index b6891905..00000000
--- a/tests/headers/derive-debug-bitfield.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --impl-debug --rust-target 1.40
-
-class C {
-  bool a: 1;
-  bool b: 7;
-  int large_array[50];
-};
diff --git a/tests/headers/derive-debug-function-pointer.hpp b/tests/headers/derive-debug-function-pointer.hpp
deleted file mode 100644
index 147097fb..00000000
--- a/tests/headers/derive-debug-function-pointer.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --impl-debug --rust-target 1.40
-
-class Nice {
-  typedef void (*Function) (int data);
-  Function pointer;
-  int large_array[34];
-};
diff --git a/tests/headers/derive-debug-generic.hpp b/tests/headers/derive-debug-generic.hpp
deleted file mode 100644
index 50122faf..00000000
--- a/tests/headers/derive-debug-generic.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --impl-debug --rust-target 1.40
-
-template<typename T>
-class Generic {
-  T t[40];
-};
diff --git a/tests/headers/derive-debug-mangle-name.h b/tests/headers/derive-debug-mangle-name.h
deleted file mode 100644
index 1cd7db63..00000000
--- a/tests/headers/derive-debug-mangle-name.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --impl-debug
-struct perf_event_attr {
-
-    /*
-     * Major type: hardware/software/tracepoint/etc.
-     */
-    unsigned int			type;
-
-    float a;
-    union {
-        int b;
-        int c;
-    };
-};
diff --git a/tests/headers/derive-debug-opaque-template-instantiation.hpp b/tests/headers/derive-debug-opaque-template-instantiation.hpp
deleted file mode 100644
index 0c70fcc5..00000000
--- a/tests/headers/derive-debug-opaque-template-instantiation.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --impl-debug --rust-target 1.40
-
-// This type is opaque because the second template parameter
-// is a non-type template parameter
-template<typename T, int N>
-class Opaque {
-  T array[N];
-};
-
-class Instance {
-  Opaque<int, 50> val;
-};
diff --git a/tests/headers/derive-debug-opaque.hpp b/tests/headers/derive-debug-opaque.hpp
deleted file mode 100644
index 715d3c89..00000000
--- a/tests/headers/derive-debug-opaque.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --opaque-type "Opaque" --impl-debug --rust-target 1.40
-
-class Opaque {
-  int i;
-  int not_debug[40];
-};
-
-class OpaqueUser {
-  Opaque opaque;
-};
diff --git a/tests/headers/derive-default-and-blocklist.hpp b/tests/headers/derive-default-and-blocklist.hpp
deleted file mode 100644
index 20d938cc..00000000
--- a/tests/headers/derive-default-and-blocklist.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
-
-// Note that we do not explicitly provide the `--with-derive-default` flag
-// above, since it is added by the test runner implicitly.
-
-struct BlocklistMe {};
-
-/**
- * Because this type contains a blocklisted type, it should not derive
- * Default. Instead, we should emit a `mem::zeroed` implementation.
- */
-struct ShouldNotDeriveDefault {
-    BlocklistMe a;
-};
diff --git a/tests/headers/derive-fn-ptr.h b/tests/headers/derive-fn-ptr.h
deleted file mode 100644
index 93b980e6..00000000
--- a/tests/headers/derive-fn-ptr.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-typedef void (*my_fun_t)(int, int, int, int,
-                         int, int, int, int,
-                         int, int, int, int,
-                         int, int, int, int);
-
-struct Foo {
-  my_fun_t callback;
-};
-
-typedef void (*my_fun2_t)(int, int, int, int,
-                         int, int, int, int,
-                         int, int, int, int);
-
-struct Bar {
-  my_fun2_t callback;
-};
diff --git a/tests/headers/derive-hash-and-blocklist.hpp b/tests/headers/derive-hash-and-blocklist.hpp
deleted file mode 100644
index 51a3372f..00000000
--- a/tests/headers/derive-hash-and-blocklist.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --with-derive-hash --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
-
-struct BlocklistMe {};
-
-/**
- * Because this type contains a blocklisted type, it should not derive Hash.
- */
-struct ShouldNotDeriveHash {
-    BlocklistMe a;
-};
diff --git a/tests/headers/derive-hash-blocklisting.hpp b/tests/headers/derive-hash-blocklisting.hpp
deleted file mode 100644
index 4e20e392..00000000
--- a/tests/headers/derive-hash-blocklisting.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq --allowlist-type 'Allowlisted.*' --blocklist-type Blocklisted --raw-line "#[repr(C)] #[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)] pub struct Blocklisted<T> {t: T, pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>> }"
-//
-template <class T>
-struct Blocklisted {
-    T t;
-};
-
-/// This would derive(Hash, Eq, PartialEq) if it didn't contain a blocklisted type,
-/// causing us to conservatively avoid deriving hash/Eq/PartialEq for it.
-struct AllowlistedOne {
-    Blocklisted<int> a;
-};
-
-/// This can't derive(Hash/Eq) even if it didn't contain a blocklisted type.
-struct AllowlistedTwo {
-    Blocklisted<float> b;
-};
diff --git a/tests/headers/derive-hash-struct-with-anon-struct-float.h b/tests/headers/derive-hash-struct-with-anon-struct-float.h
deleted file mode 100644
index dc6e7329..00000000
--- a/tests/headers/derive-hash-struct-with-anon-struct-float.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
-//
-/// A struct containing a struct containing a float that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
-struct foo {
-    struct {
-        float a;
-        float b;
-    } bar;
-};
diff --git a/tests/headers/derive-hash-struct-with-float-array.h b/tests/headers/derive-hash-struct-with-float-array.h
deleted file mode 100644
index 2294b1de..00000000
--- a/tests/headers/derive-hash-struct-with-float-array.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
-//
-/// A struct containing an array of floats that cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd
-struct foo {
-    float bar[3];
-};
diff --git a/tests/headers/derive-hash-struct-with-incomplete-array.h b/tests/headers/derive-hash-struct-with-incomplete-array.h
deleted file mode 100644
index 65c009db..00000000
--- a/tests/headers/derive-hash-struct-with-incomplete-array.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord
-// 
-struct test {
-    int a;
-    char zero_length_array[0];
-};
-
-struct test2 {
-    int a;
-    char incomplete_array[];
-};
-
-struct test3 {
-    int a;
-    char zero_length_array[0];
-    char incomplete_array[];
-};
diff --git a/tests/headers/derive-hash-struct-with-pointer.h b/tests/headers/derive-hash-struct-with-pointer.h
deleted file mode 100644
index a3ce9cc5..00000000
--- a/tests/headers/derive-hash-struct-with-pointer.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
-//
-/// Pointers can derive Hash/PartialOrd/Ord/PartialEq/Eq
-struct ConstPtrMutObj {
-    int* const bar;
-};
-
-struct MutPtrMutObj {
-    int* bar;
-};
-
-struct MutPtrConstObj {
-    const int* bar;
-};
-
-struct ConstPtrConstObj {
-    const int* const bar;
-};
diff --git a/tests/headers/derive-hash-template-def-float.hpp b/tests/headers/derive-hash-template-def-float.hpp
deleted file mode 100644
index 253fb9ce..00000000
--- a/tests/headers/derive-hash-template-def-float.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
-//
-/// Template definition containing a float, which cannot derive Hash/Eq/Ord but can derive PartialEq/PartialOrd.
-template <typename T>
-struct foo {
-    T data;
-    float b;
-};
diff --git a/tests/headers/derive-hash-template-inst-float.hpp b/tests/headers/derive-hash-template-inst-float.hpp
deleted file mode 100644
index 0a4fc0c1..00000000
--- a/tests/headers/derive-hash-template-inst-float.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialord --with-derive-ord --with-derive-partialeq --with-derive-eq
-//
-/// Template definition that doesn't contain float can derive Hash/PartialOrd/Ord/PartialEq/Eq
-template <typename T>
-struct foo {
-    T data;
-};
-
-/// Can derive Hash/PartialOrd/Ord/PartialEq/Eq when instantiated with int
-struct IntStr {
-    foo<int> a;
-};
-
-/// Cannot derive Hash/Eq/Ord when instantiated with float but can derive PartialEq/PartialOrd
-struct FloatStr {
-    foo<float> a;
-};
diff --git a/tests/headers/derive-partialeq-and-blocklist.hpp b/tests/headers/derive-partialeq-and-blocklist.hpp
deleted file mode 100644
index 953d0677..00000000
--- a/tests/headers/derive-partialeq-and-blocklist.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
-
-struct BlocklistMe {};
-
-/**
- * Because this type contains a blocklisted type, it should not derive
- * PartialEq.
- */
-struct ShouldNotDerivePartialEq {
-    BlocklistMe a;
-};
diff --git a/tests/headers/derive-partialeq-anonfield.h b/tests/headers/derive-partialeq-anonfield.h
deleted file mode 100644
index 3bbe2bc3..00000000
--- a/tests/headers/derive-partialeq-anonfield.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
-
-struct rte_mbuf {
-    union {};
-} __attribute__((__aligned__(64)));
diff --git a/tests/headers/derive-partialeq-base.hpp b/tests/headers/derive-partialeq-base.hpp
deleted file mode 100644
index 2a57dca4..00000000
--- a/tests/headers/derive-partialeq-base.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq --rust-target 1.40
-
-class Base {
-    int large[33];
-};
-
-class ShouldDerivePartialEq: Base {
-};
diff --git a/tests/headers/derive-partialeq-bitfield.hpp b/tests/headers/derive-partialeq-bitfield.hpp
deleted file mode 100644
index f6dd82e5..00000000
--- a/tests/headers/derive-partialeq-bitfield.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq --rust-target 1.40
-
-class C {
-    bool a: 1;
-    bool b: 7;
-    int large_array[50];
-};
diff --git a/tests/headers/derive-partialeq-core.h b/tests/headers/derive-partialeq-core.h
deleted file mode 100644
index 18eed8b3..00000000
--- a/tests/headers/derive-partialeq-core.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq --use-core --raw-line "extern crate core;" --rust-target 1.40
-
-struct C {
-    int large_array[420];
-};
diff --git a/tests/headers/derive-partialeq-pointer.hpp b/tests/headers/derive-partialeq-pointer.hpp
deleted file mode 100644
index ce971e07..00000000
--- a/tests/headers/derive-partialeq-pointer.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct a;
-class Bar {
-  a *b;
-};
-struct c {
-  union {};
-};
-struct a {
-  c d;
-};
diff --git a/tests/headers/derive-partialeq-union.hpp b/tests/headers/derive-partialeq-union.hpp
deleted file mode 100644
index e2081a01..00000000
--- a/tests/headers/derive-partialeq-union.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq
-
-/// Deriving PartialEq for rust unions is not supported.
-union ShouldNotDerivePartialEq {
-    char a;
-    int b;
-};
diff --git a/tests/headers/derive-partialeq-union_1_0.hpp b/tests/headers/derive-partialeq-union_1_0.hpp
deleted file mode 100644
index d546d77b..00000000
--- a/tests/headers/derive-partialeq-union_1_0.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-partialeq --impl-partialeq
-
-/// This should manually derive PartialEq.
-union ShouldDerivePartialEq {
-    char a[150];
-    int b;
-};
diff --git a/tests/headers/disable-namespacing.hpp b/tests/headers/disable-namespacing.hpp
deleted file mode 100644
index 11191361..00000000
--- a/tests/headers/disable-namespacing.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --disable-name-namespacing
-
-namespace foo {
-namespace bar {
-
-typedef int Baz;
-
-}
-}
diff --git a/tests/headers/disable-nested-struct-naming.h b/tests/headers/disable-nested-struct-naming.h
deleted file mode 100644
index 0e4fccb6..00000000
--- a/tests/headers/disable-nested-struct-naming.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// bindgen-flags: --disable-nested-struct-naming
-
-struct foo {
-    struct bar1 {
-        int x1;
-        struct {
-            int x2;
-            struct {
-                int x3;
-                struct bar4 {
-                    int x4;
-                } b4;
-            } b3;
-        } b2;
-    } b1;
-};
-
-struct {
-    struct {
-        struct baz {
-            int x;
-        } b;
-    } anon2;
-} anon1;
diff --git a/tests/headers/disable-untagged-union.hpp b/tests/headers/disable-untagged-union.hpp
deleted file mode 100644
index 44623181..00000000
--- a/tests/headers/disable-untagged-union.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --disable-untagged-union
-
-union Foo {
-  int bar;
-  unsigned int baz;
-};
diff --git a/tests/headers/divide-by-zero-in-struct-layout.h b/tests/headers/divide-by-zero-in-struct-layout.h
deleted file mode 100644
index 7c500cb0..00000000
--- a/tests/headers/divide-by-zero-in-struct-layout.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// bindgen-flags: --no-layout-tests
-//
-// Unfortunately, we aren't translating the third struct correctly yet. But we
-// definitely shouldn't divide-by-zero when we see it...
-//
-// Once we fix #981 we should remove the `--no-layout-tests`.
-
-struct WithBitfield {
-    unsigned : 7;
-    unsigned a;
-};
-
-struct WithBitfieldAndAttrPacked {
-    unsigned : 7;
-    unsigned a;
-} __attribute__((packed));
-
-#pragma pack(1)
-struct WithBitfieldAndPacked {
-    unsigned : 7;
-    unsigned a;
-};
diff --git a/tests/headers/do-not-derive-copy.hpp b/tests/headers/do-not-derive-copy.hpp
deleted file mode 100644
index 18c26135..00000000
--- a/tests/headers/do-not-derive-copy.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --no-derive-copy
-
-class WouldBeCopyButWeAreNotDerivingCopy {
-    int x;
-};
diff --git a/tests/headers/doggo-or-null.hpp b/tests/headers/doggo-or-null.hpp
deleted file mode 100644
index 9146e189..00000000
--- a/tests/headers/doggo-or-null.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// bindgen-flags: --opaque-type DoggoOrNull --with-derive-partialeq --with-derive-hash -- -std=c++14
-
-class Doggo {
-    int x;
-};
-
-class Null {};
-
-/**
- * This type is an opaque union. Unions can't derive anything interesting like
- * Debug or Default, even if their layout can, because it would require knowing
- * which variant is in use. Opaque unions still end up as a `union` in the Rust
- * bindings, but they just have one variant. Even so, can't derive. We should
- * probably emit an opaque struct for opaque unions... but until then, we have
- * this test to make sure that opaque unions don't derive and still compile.
- */
-union DoggoOrNull {
-    Doggo doggo;
-    Null none;
-};
diff --git a/tests/headers/dupe-enum-variant-in-namespace.h b/tests/headers/dupe-enum-variant-in-namespace.h
deleted file mode 100644
index 2b6fb93a..00000000
--- a/tests/headers/dupe-enum-variant-in-namespace.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" --enable-cxx-namespaces -- -x c++ -std=c++11
-
-namespace foo {
-  enum class Bar : unsigned {
-    Foo = 0,
-    Foo1 = 0,
-    Foo2,
-    Foo3 = Foo2,
-  };
-}
diff --git a/tests/headers/duplicated-namespaces-definitions.hpp b/tests/headers/duplicated-namespaces-definitions.hpp
deleted file mode 100644
index 7c8888de..00000000
--- a/tests/headers/duplicated-namespaces-definitions.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-namespace foo {
-  class Bar;
-}
-
-namespace bar {
-  struct Foo {
-    foo::Bar* ptr;
-  };
-};
-
-namespace foo {
-  class Bar {
-    int foo;
-    bool baz;
-  };
-}
diff --git a/tests/headers/duplicated-namespaces.hpp b/tests/headers/duplicated-namespaces.hpp
deleted file mode 100644
index 10e1933f..00000000
--- a/tests/headers/duplicated-namespaces.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-namespace std {}
-namespace std {}
diff --git a/tests/headers/duplicated_constants_in_ns.hpp b/tests/headers/duplicated_constants_in_ns.hpp
deleted file mode 100644
index bb343641..00000000
--- a/tests/headers/duplicated_constants_in_ns.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-namespace foo {
-    const int FOO = 4;
-}
-namespace bar {
-    const int FOO = 5;
-}
diff --git a/tests/headers/dynamic_loading_attributes.h b/tests/headers/dynamic_loading_attributes.h
deleted file mode 100644
index e2ca62b1..00000000
--- a/tests/headers/dynamic_loading_attributes.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all --enable-function-attribute-detection
-/**
- * @brief A function
- * 
- * @param x 
- * @param y 
- * @return int 
- */
-__attribute__((warn_unused_result))
-int foo(int x, int y);
-int baz() ;
diff --git a/tests/headers/dynamic_loading_required.h b/tests/headers/dynamic_loading_required.h
deleted file mode 100644
index f9861e84..00000000
--- a/tests/headers/dynamic_loading_required.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib --dynamic-link-require-all
-
-int foo(int x, int y);
-int bar(void *x);
-int baz();
diff --git a/tests/headers/dynamic_loading_simple.h b/tests/headers/dynamic_loading_simple.h
deleted file mode 100644
index f418851b..00000000
--- a/tests/headers/dynamic_loading_simple.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib
-
-int foo(int x, int y);
-int bar(void *x);
-int baz();
diff --git a/tests/headers/dynamic_loading_template.hpp b/tests/headers/dynamic_loading_template.hpp
deleted file mode 100644
index 27f04c8e..00000000
--- a/tests/headers/dynamic_loading_template.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib
-
-template<typename T>
-T foo(T x);
-
-template<>
-int foo(int x);
-
-template<>
-float foo(float x);
diff --git a/tests/headers/dynamic_loading_with_allowlist.hpp b/tests/headers/dynamic_loading_with_allowlist.hpp
deleted file mode 100644
index 995fbdd5..00000000
--- a/tests/headers/dynamic_loading_with_allowlist.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib --allowlist-function baz --allowlist-function foo --allowlist-function bazz
-
-class X {
-  int _x;
-
- public:
-  X(int x);
-
-  void some_function();
-  void some_other_function();
-};
-
-int foo(void *x);
-int bar(void *x);
-int baz(void *x);
-int bazz(int, ...);
diff --git a/tests/headers/dynamic_loading_with_blocklist.hpp b/tests/headers/dynamic_loading_with_blocklist.hpp
deleted file mode 100644
index 81266d1f..00000000
--- a/tests/headers/dynamic_loading_with_blocklist.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib --blocklist-function baz
-
-class X {
-  int _x;
-
- public:
-  X(int x);
-
-  void some_function();
-  void some_other_function();
-};
-
-int foo(void *x);
-int bar(void *x);
-int baz(void *x);
diff --git a/tests/headers/dynamic_loading_with_class.hpp b/tests/headers/dynamic_loading_with_class.hpp
deleted file mode 100644
index 632db4d0..00000000
--- a/tests/headers/dynamic_loading_with_class.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --dynamic-loading TestLib
-
-int foo(void *x);
-
-class A {
-  int _x;
-
- public:
-  A(int x);
-
-  void some_function();
-  void some_other_function();
-};
-
-void bar();
diff --git a/tests/headers/elaborated.hpp b/tests/headers/elaborated.hpp
deleted file mode 100644
index 4bfbff23..00000000
--- a/tests/headers/elaborated.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace whatever {
-  typedef int whatever_t;
-}
-
-void something(const whatever::whatever_t *wat);
diff --git a/tests/headers/empty-enum.h b/tests/headers/empty-enum.h
deleted file mode 100644
index 8b7502e6..00000000
--- a/tests/headers/empty-enum.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --rustified-enum '.*Rustified.*' --constified-enum-module '.*Module.*' -- -x c++ --std=c++14
-
-// Constified is default, so no flag for that.
-
-enum EmptyConstified {};
-enum EmptyRustified {};
-enum EmptyModule {};
-
-enum class EmptyClassRustified : char {};
-enum class EmptyClassConstified : char {};
-enum class EmptyClassModule : char {};
-
-enum class ForwardClassRustified : char;
-enum class ForwardClassConstified : char;
-enum class ForwardClassModule : char;
diff --git a/tests/headers/empty-union.hpp b/tests/headers/empty-union.hpp
deleted file mode 100644
index 3b067e39..00000000
--- a/tests/headers/empty-union.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --opaque-type "*"
-
-template <int> class a {
-  union {};
-};
diff --git a/tests/headers/empty_template_param_name.hpp b/tests/headers/empty_template_param_name.hpp
deleted file mode 100644
index ab2aab92..00000000
--- a/tests/headers/empty_template_param_name.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-// bindgen-flags: -- -std=c++11
-
-template<typename...> using __void_t = void;
-
-template<typename _Iterator, typename = __void_t<>>
-  struct __iterator_traits { };
diff --git a/tests/headers/enum-default-bitfield.h b/tests/headers/enum-default-bitfield.h
deleted file mode 100644
index 5f3cb954..00000000
--- a/tests/headers/enum-default-bitfield.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-enum-style=bitfield --constified-enum-module=Neg
-
-#include "enum.h"
diff --git a/tests/headers/enum-default-consts.h b/tests/headers/enum-default-consts.h
deleted file mode 100644
index 233d2718..00000000
--- a/tests/headers/enum-default-consts.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-enum-style=consts --constified-enum-module=Neg
-
-#include "enum.h"
diff --git a/tests/headers/enum-default-module.h b/tests/headers/enum-default-module.h
deleted file mode 100644
index 8c2ec1bc..00000000
--- a/tests/headers/enum-default-module.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-enum-style=moduleconsts --constified-enum-module=Neg
-
-#include "enum.h"
diff --git a/tests/headers/enum-default-rust.h b/tests/headers/enum-default-rust.h
deleted file mode 100644
index 7fd2999f..00000000
--- a/tests/headers/enum-default-rust.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --default-enum-style=rust --constified-enum-module=Neg
-
-#include "enum.h"
diff --git a/tests/headers/enum-doc-bitfield.h b/tests/headers/enum-doc-bitfield.h
deleted file mode 100644
index 5bbd7287..00000000
--- a/tests/headers/enum-doc-bitfield.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --bitfield-enum B
-
-#include "enum-doc.h"
diff --git a/tests/headers/enum-doc-mod.h b/tests/headers/enum-doc-mod.h
deleted file mode 100644
index e5217451..00000000
--- a/tests/headers/enum-doc-mod.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --constified-enum-module B
-
-#include "enum-doc.h"
diff --git a/tests/headers/enum-doc-rusty.h b/tests/headers/enum-doc-rusty.h
deleted file mode 100644
index 35622d2b..00000000
--- a/tests/headers/enum-doc-rusty.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --rustified-enum B
-
-#include "enum-doc.h"
diff --git a/tests/headers/enum-doc.h b/tests/headers/enum-doc.h
deleted file mode 100644
index 58e2c69e..00000000
--- a/tests/headers/enum-doc.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/** Document enum */
-enum B {
-    /// Document field with three slashes
-    VAR_A = 0,
-    /** Document field with preceeding star */
-    VAR_B = 1,
-    /*! Document field with preceeding exclamation */
-    VAR_C = 2,
-    VAR_D = 3, /**< Document field with following star */
-    VAR_E = 4, /*!< Document field with following exclamation */
-    /**
-     * Document field with preceeding star, with a loong long multiline
-     * comment.
-     *
-     * Very interesting documentation, definitely.
-     */
-    VAR_F,
-};
diff --git a/tests/headers/enum-no-debug-rust.h b/tests/headers/enum-no-debug-rust.h
deleted file mode 100644
index 7cb73980..00000000
--- a/tests/headers/enum-no-debug-rust.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --no-derive-debug --default-enum-style=rust --constified-enum-module=Neg
-
-#include "enum.h"
diff --git a/tests/headers/enum-translate-type.hpp b/tests/headers/enum-translate-type.hpp
deleted file mode 100644
index 8d856261..00000000
--- a/tests/headers/enum-translate-type.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --translate-enum-integer-types -- -std=c++11 -Wno-narrowing
-
-enum my_enum1 {
-    A = 0,
-};
-enum my_enum2 {
-    B = -1,
-};
-enum my_enum3: short {
-    C = 0,
-};
-enum my_enum4: unsigned char {
-    D = -1,
-};
diff --git a/tests/headers/enum-undefault.h b/tests/headers/enum-undefault.h
deleted file mode 100644
index 7150be0d..00000000
--- a/tests/headers/enum-undefault.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --default-enum-style=rust --constified-enum=Neg
-
-enum Foo {
-    Bar = 0,
-    Qux
-};
-
-enum Neg {
-    MinusOne = -1,
-    One = 1,
-};
diff --git a/tests/headers/enum-variant-replaces.h b/tests/headers/enum-variant-replaces.h
deleted file mode 100644
index 45eb4d7a..00000000
--- a/tests/headers/enum-variant-replaces.h
+++ /dev/null
@@ -1,34 +0,0 @@
-
-/** Type for a OGR error */
-typedef enum
-{
-    OGRERR_NONE,                       /**< Success */
-    OGRERR_NOT_ENOUGH_DATA,            /**< Not enough data to deserialize */
-    OGRERR_NOT_ENOUGH_MEMORY,          /**< Not enough memory */
-    OGRERR_UNSUPPORTED_GEOMETRY_TYPE,  /**< Unsupported geometry type */
-    OGRERR_UNSUPPORTED_OPERATION,      /**< Unsupported operation */
-    OGRERR_CORRUPT_DATA,               /**< Corrupt data */
-    OGRERR_FAILURE,                    /**< Failure */
-    OGRERR_UNSUPPORTED_SRS,            /**< Unsupported SRS */
-    OGRERR_INVALID_HANDLE,             /**< Invalid handle */
-    OGRERR_NON_EXISTING_FEATURE        /**< Non existing feature. Added in GDAL 2.0 */
-} OGRErr;
-
-/**
- * <div rustbindgen replaces="OGRErr"></div>
- */
-typedef enum
-{
-    /**
-     * <div rustbindgen replaces="PASS"></div>
-     *
-     * Should see PASS below.
-     */
-    FAIL,
-    /**
-     * <div rustbindgen replaces="OGRERR_NONE"></div>
-     *
-     * Should see OGRERR_NONE instead of CUSTOM_OGRERR_NONE below.
-     */
-    CUSTOM_OGRERR_NONE
-} StrictOGRErr;
diff --git a/tests/headers/enum.h b/tests/headers/enum.h
deleted file mode 100644
index 0147433e..00000000
--- a/tests/headers/enum.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// A few tests for enum-related issues that should be tested with all the enum
-// representations.
-
-struct foo {
-  enum {
-    FOO_A,
-    FOO_B,
-  } member;
-};
-
-enum Foo {
-    Bar = 0,
-    Qux
-};
-
-enum Neg {
-    MinusOne = -1,
-    One = 1,
-};
-
-/** <div rustbindgen nodebug></div> */
-enum NoDebug {
-    NoDebug1,
-    NoDebug2,
-};
-
-/** <div rustbindgen derive="Debug"></div> */
-enum Debug {
-    Debug1,
-    Debug2,
-};
\ No newline at end of file
diff --git a/tests/headers/enum_alias.hpp b/tests/headers/enum_alias.hpp
deleted file mode 100644
index 8ddb25c3..00000000
--- a/tests/headers/enum_alias.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11
-
-typedef unsigned char uint8_t;
-
-enum Bar : uint8_t {
-  VAL
-};
diff --git a/tests/headers/enum_and_vtable_mangling.hpp b/tests/headers/enum_and_vtable_mangling.hpp
deleted file mode 100644
index 659a8bd1..00000000
--- a/tests/headers/enum_and_vtable_mangling.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum {
-    match,
-    whatever_else,
-};
-
-class C {
-    int i;
-public:
-    virtual void match();
-};
diff --git a/tests/headers/enum_dupe.h b/tests/headers/enum_dupe.h
deleted file mode 100644
index b8d9689a..00000000
--- a/tests/headers/enum_dupe.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum Foo {
-    Bar = 1,
-    Dupe = 1
-};
diff --git a/tests/headers/enum_explicit_type.hpp b/tests/headers/enum_explicit_type.hpp
deleted file mode 100644
index 38e636e6..00000000
--- a/tests/headers/enum_explicit_type.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11
-
-enum Foo: unsigned char {
-    Bar = 0,
-    Qux
-};
-
-enum Neg: signed char {
-    MinusOne = -1,
-    One = 1,
-};
-
-enum Bigger: unsigned short {
-    Much = 255,
-    Larger
-};
-
-enum MuchLong: long {
-    MuchLow = -4294967296,
-};
-
-enum MuchLongLong: long long {
-    I64_MIN = 1ll << 63,
-};
-
-enum MuchULongLong: unsigned long long {
-    MuchHigh = 4294967296,
-};
-
-enum BoolEnumsAreFun: bool {
-    Value = true,
-};
-
-using MyType = bool;
-enum BoolEnumsAreFun2: MyType {
-    Value2 = true,
-};
-
-enum : unsigned char {
-    AnonymousVariantOne,
-    AnonymousVariantTwo,
-};
diff --git a/tests/headers/enum_explicit_type_constants.hpp b/tests/headers/enum_explicit_type_constants.hpp
deleted file mode 100644
index e1ecf6fa..00000000
--- a/tests/headers/enum_explicit_type_constants.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]' -- -std=c++11 
-//
-// This test is much like enum_explicit_type, but without --rustified-enum.
-
-#include "enum_explicit_type.hpp"
diff --git a/tests/headers/enum_in_template.hpp b/tests/headers/enum_in_template.hpp
deleted file mode 100644
index 41c017c4..00000000
--- a/tests/headers/enum_in_template.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-
-template <class T>
-class Foo
-{
-    enum Bar
-    {
-        A,
-        B
-    };
-};
diff --git a/tests/headers/enum_in_template_with_typedef.hpp b/tests/headers/enum_in_template_with_typedef.hpp
deleted file mode 100644
index 87290ece..00000000
--- a/tests/headers/enum_in_template_with_typedef.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11
-
-namespace std {
-  template <typename Char> class fbstring_core;
-}
-
-typedef unsigned char uint8_t;
-namespace std {
-  template <typename Char> class fbstring_core {
-    typedef uint8_t category_type;
-    enum Category : category_type {
-      Foo = 1,
-      Bar = 4,
-    };
-  };
-}
diff --git a/tests/headers/enum_negative.h b/tests/headers/enum_negative.h
deleted file mode 100644
index 0fa0df97..00000000
--- a/tests/headers/enum_negative.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum Foo {
-    Bar = -2,
-    Qux = 1,
-};
diff --git a/tests/headers/enum_packed.h b/tests/headers/enum_packed.h
deleted file mode 100644
index cc70c816..00000000
--- a/tests/headers/enum_packed.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-enum __attribute__((packed)) Foo {
-    Bar = 0,
-    Qux
-};
-
-enum __attribute__((packed)) Neg {
-    MinusOne = -1,
-    One = 1,
-};
-
-enum __attribute__((packed)) Bigger {
-    Much = 255,
-    Larger
-};
diff --git a/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h b/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
deleted file mode 100644
index 4c342c0e..00000000
--- a/tests/headers/error-E0600-cannot-apply-unary-negation-to-u32.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --raw-line "#![allow(overflowing_literals)]"
-
-typedef unsigned int uint32_t;
-
-uint32_t a = 18446744073709551611;
diff --git a/tests/headers/eval-value-dependent.hpp b/tests/headers/eval-value-dependent.hpp
deleted file mode 100644
index 0f4dc6ab..00000000
--- a/tests/headers/eval-value-dependent.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-template <typename d> class e {
-  using f = d;
-  static const auto g = alignof(f);
-};
diff --git a/tests/headers/eval-variadic-template-parameter.hpp b/tests/headers/eval-variadic-template-parameter.hpp
deleted file mode 100644
index 0a9e51c1..00000000
--- a/tests/headers/eval-variadic-template-parameter.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-template <typename... T>
-struct B {
-    // Can't generate anything meaningful in Rust for this, but we shouldn't
-    // trigger an assertion inside Clang.
-    static const long c = sizeof...(T);
-};
diff --git a/tests/headers/explicit-padding.h b/tests/headers/explicit-padding.h
deleted file mode 100644
index 4abaafba..00000000
--- a/tests/headers/explicit-padding.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --explicit-padding
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-
-struct pad_me {
-        uint8_t first;
-        uint32_t second;
-        uint16_t third;
-};
-
-union dont_pad_me {
-        uint8_t first;
-        uint32_t second;
-        uint16_t third;
-};
diff --git a/tests/headers/extern-const-struct.h b/tests/headers/extern-const-struct.h
deleted file mode 100644
index 10271274..00000000
--- a/tests/headers/extern-const-struct.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.40
-
-struct nsFoo {
-  float details[400];
-};
-
-extern const struct nsFoo gDetails;
diff --git a/tests/headers/extern.hpp b/tests/headers/extern.hpp
deleted file mode 100644
index 0779e038..00000000
--- a/tests/headers/extern.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-extern "C" {
-#include "func_proto.h"
-}
diff --git a/tests/headers/fit-macro-constant-types-signed.h b/tests/headers/fit-macro-constant-types-signed.h
deleted file mode 100644
index dba20937..00000000
--- a/tests/headers/fit-macro-constant-types-signed.h
+++ /dev/null
@@ -1,2 +0,0 @@
-// bindgen-flags: --default-macro-constant-type=signed --fit-macro-constant-types
-#include "default-macro-constant-type.h"
diff --git a/tests/headers/fit-macro-constant-types.h b/tests/headers/fit-macro-constant-types.h
deleted file mode 100644
index b995bfc0..00000000
--- a/tests/headers/fit-macro-constant-types.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --fit-macro-constant-types
-// Test fitting macro constants into smaller integer types
-// Negative values are i8, i16, i32 or i64; others are u8, u16, u32 or u64.
-#include "default-macro-constant-type.h"
\ No newline at end of file
diff --git a/tests/headers/float128.hpp b/tests/headers/float128.hpp
deleted file mode 100644
index f554e88e..00000000
--- a/tests/headers/float128.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// FIXME: libclang < 3.9 does not expose `__float128` in its interface, so this
-// test will fail. Once we remove support for `--features llvm_stable` and
-// require libclang >= 3.9, we can reenable this test.
-//
-// static __float128 global = 1.0;
-
-// FIXME: We have no way to get 128 bit aligned structs in Rust at the moment,
-// and therefore the generated layout tests for this struct will fail. When we
-// can enforce 128 bit alignment, we can re-enable this test.
-//
-// struct A {
-//     __float128 f;
-// };
diff --git a/tests/headers/forward-declaration-autoptr.hpp b/tests/headers/forward-declaration-autoptr.hpp
deleted file mode 100644
index a26c1cd2..00000000
--- a/tests/headers/forward-declaration-autoptr.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-class Foo;
-
-template <typename T>
-struct RefPtr {
-  T* m_inner;
-};
-
-struct Bar {
-  RefPtr<Foo> m_member;
-};
diff --git a/tests/headers/forward-enum-decl.hpp b/tests/headers/forward-enum-decl.hpp
deleted file mode 100644
index 81a0eee7..00000000
--- a/tests/headers/forward-enum-decl.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11
-
-enum class CSSPseudoClassType : int;
-
-enum class CSSPseudoClassType : int {
-  empty,
-  link,
-};
diff --git a/tests/headers/forward-inherit-struct-with-fields.hpp b/tests/headers/forward-inherit-struct-with-fields.hpp
deleted file mode 100644
index 437fff5d..00000000
--- a/tests/headers/forward-inherit-struct-with-fields.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-template <typename> class Rooted;
-namespace js {
-    template <typename T> class RootedBase {
-      T* foo;
-      Rooted<T>* next;
-    };
-}
-template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/tests/headers/forward-inherit-struct.hpp b/tests/headers/forward-inherit-struct.hpp
deleted file mode 100644
index ac7aef5e..00000000
--- a/tests/headers/forward-inherit-struct.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-template <typename> class Rooted;
-namespace js {
-    template <typename T> class RootedBase {};
-}
-template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/tests/headers/forward_declared_complex_types.hpp b/tests/headers/forward_declared_complex_types.hpp
deleted file mode 100644
index ffc779ad..00000000
--- a/tests/headers/forward_declared_complex_types.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-struct Foo_empty {};
-struct Foo;
-
-struct Bar {
-    Foo *f;
-};
-
-void baz_struct(Foo* f);
-
-union Union;
-
-void baz_union(Union* u);
-
-class Quux;
-
-void baz_class(Quux* q);
diff --git a/tests/headers/forward_declared_complex_types_1_0.hpp b/tests/headers/forward_declared_complex_types_1_0.hpp
deleted file mode 100644
index ff6076fc..00000000
--- a/tests/headers/forward_declared_complex_types_1_0.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: --rust-target 1.0
-
-struct Foo_empty {};
-struct Foo;
-
-struct Bar {
-    Foo *f;
-};
-
-void baz_struct(Foo* f);
-
-union Union;
-
-void baz_union(Union* u);
-
-class Quux;
-
-void baz_class(Quux* q);
diff --git a/tests/headers/forward_declared_opaque.h b/tests/headers/forward_declared_opaque.h
deleted file mode 100644
index 1b58edb9..00000000
--- a/tests/headers/forward_declared_opaque.h
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --opaque-type "*"
-
-union a;
-struct b;
\ No newline at end of file
diff --git a/tests/headers/forward_declared_struct.h b/tests/headers/forward_declared_struct.h
deleted file mode 100644
index 2a69450c..00000000
--- a/tests/headers/forward_declared_struct.h
+++ /dev/null
@@ -1,11 +0,0 @@
-struct a;
-
-struct a {
-    int b;
-};
-
-struct c {
-    int d;
-};
-
-struct c;
\ No newline at end of file
diff --git a/tests/headers/func_proto.h b/tests/headers/func_proto.h
deleted file mode 100644
index 51139ca9..00000000
--- a/tests/headers/func_proto.h
+++ /dev/null
@@ -1 +0,0 @@
-typedef int foo(int bar);
diff --git a/tests/headers/func_ptr.h b/tests/headers/func_ptr.h
deleted file mode 100644
index 34dc48d1..00000000
--- a/tests/headers/func_ptr.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-int (*foo) (int x, int y);
diff --git a/tests/headers/func_ptr_in_struct.h b/tests/headers/func_ptr_in_struct.h
deleted file mode 100644
index ef075df7..00000000
--- a/tests/headers/func_ptr_in_struct.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-//
-enum baz;
-
-struct Foo {
-    enum baz (*bar) (int x, int y);
-};
diff --git a/tests/headers/func_ptr_return_type.h b/tests/headers/func_ptr_return_type.h
deleted file mode 100644
index d529edc7..00000000
--- a/tests/headers/func_ptr_return_type.h
+++ /dev/null
@@ -1 +0,0 @@
-int (*func(void))(int, int);
diff --git a/tests/headers/func_return_must_use.h b/tests/headers/func_return_must_use.h
deleted file mode 100644
index f05bd2de..00000000
--- a/tests/headers/func_return_must_use.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// bindgen-flags: --must-use-type 'MustUse.*'
-
-typedef int MustUseInt;
-
-MustUseInt return_int();
-
-struct MustUseStruct;
-
-struct MustUseStruct return_struct();
-
-/**
- * <div rustbindgen mustusetype></div>
- */
-typedef int AnnotatedInt;
-
-AnnotatedInt return_annotated_int();
-
-int return_plain_int();
-
-/**
- * <div rustbindgen mustusetype></div>
- */
-struct AnnotatedStruct {};
-
-struct AnnotatedStruct return_annotated_struct();
-
-struct PlainStruct {};
-
-/**
- * <div rustbindgen mustusetype></div>
- */
-typedef struct PlainStruct TypedefPlainStruct;
-
-struct PlainStruct return_plain_struct();
-
-TypedefPlainStruct return_typedef_struct();
diff --git a/tests/headers/func_with_array_arg.h b/tests/headers/func_with_array_arg.h
deleted file mode 100644
index 1b81702b..00000000
--- a/tests/headers/func_with_array_arg.h
+++ /dev/null
@@ -1 +0,0 @@
-void f(int x[2]);
diff --git a/tests/headers/func_with_func_ptr_arg.h b/tests/headers/func_with_func_ptr_arg.h
deleted file mode 100644
index e9abcae6..00000000
--- a/tests/headers/func_with_func_ptr_arg.h
+++ /dev/null
@@ -1,3 +0,0 @@
-void foo(void (*bar)());
-
-void bar(void (*one)(int a, int b), void (*two)(int c, int d));
diff --git a/tests/headers/function-typedef-stdcall.h b/tests/headers/function-typedef-stdcall.h
deleted file mode 100644
index 05d1e78a..00000000
--- a/tests/headers/function-typedef-stdcall.h
+++ /dev/null
@@ -1,12 +0,0 @@
-typedef
-    void __stdcall
-    EVT_VIGEM_X360_NOTIFICATION(
-        void* Client,
-        void* Target,
-        unsigned char LargeMotor,
-        unsigned char SmallMotor,
-        unsigned char LedNumber,
-        void* UserData
-    );
-
-typedef EVT_VIGEM_X360_NOTIFICATION *PFN_VIGEM_X360_NOTIFICATION;
diff --git a/tests/headers/gen-constructors-neg.hpp b/tests/headers/gen-constructors-neg.hpp
deleted file mode 100644
index 2dd491c4..00000000
--- a/tests/headers/gen-constructors-neg.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --generate types,functions
-
-class Foo {
- public:
-  Foo(int a);
-};
diff --git a/tests/headers/gen-constructors.hpp b/tests/headers/gen-constructors.hpp
deleted file mode 100644
index 809d6ef9..00000000
--- a/tests/headers/gen-constructors.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --generate types,constructors,functions
-
-class Foo {
- public:
-  Foo(int a);
-};
diff --git a/tests/headers/gen-destructors-neg.hpp b/tests/headers/gen-destructors-neg.hpp
deleted file mode 100644
index 5ede3ba3..00000000
--- a/tests/headers/gen-destructors-neg.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --generate types,functions
-//
-// NB: This is intended to _not_ generate destructors.
-
-class Foo {
-  int bar;
- public:
-  ~Foo();
-};
diff --git a/tests/headers/gen-destructors.hpp b/tests/headers/gen-destructors.hpp
deleted file mode 100644
index 719eb248..00000000
--- a/tests/headers/gen-destructors.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --generate types,destructors,functions
-
-class Foo {
-  int bar;
- public:
-  ~Foo();
-};
diff --git a/tests/headers/generate-inline.hpp b/tests/headers/generate-inline.hpp
deleted file mode 100644
index 922ee1ca..00000000
--- a/tests/headers/generate-inline.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --generate-inline-functions
-
-class Foo {
- public:
-  static inline int bar() {
-    return 42;
-  }
-};
-
-inline int foo() {
-  return 42;
-}
diff --git a/tests/headers/i128.h b/tests/headers/i128.h
deleted file mode 100644
index 6ec399c7..00000000
--- a/tests/headers/i128.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --rust-target 1.26
-
-struct foo {
-  __int128 my_signed;
-  unsigned __int128 my_unsigned;
-};
diff --git a/tests/headers/in_class_typedef.hpp b/tests/headers/in_class_typedef.hpp
deleted file mode 100644
index dda7472d..00000000
--- a/tests/headers/in_class_typedef.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-
-template<typename T>
-class Foo {
-  typedef T elem_type;
-  typedef T* ptr_type;
-
-  typedef struct Bar {
-    int x, y;
-  } Bar;
-};
diff --git a/tests/headers/incomplete-array-padding.h b/tests/headers/incomplete-array-padding.h
deleted file mode 100644
index 3fcc4c1a..00000000
--- a/tests/headers/incomplete-array-padding.h
+++ /dev/null
@@ -1,4 +0,0 @@
-struct foo {
-  char a : 1;
-  void *b[];
-};
diff --git a/tests/headers/infinite-macro.h b/tests/headers/infinite-macro.h
deleted file mode 100644
index ab352c57..00000000
--- a/tests/headers/infinite-macro.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#define INFINITY (1.0f/0.0f)
-#define NAN (0.0f/0.0f)
diff --git a/tests/headers/inherit-from-template-instantiation-with-vtable.hpp b/tests/headers/inherit-from-template-instantiation-with-vtable.hpp
deleted file mode 100644
index 562ca0e1..00000000
--- a/tests/headers/inherit-from-template-instantiation-with-vtable.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-// Small test that we handle virtual tables correctly when deriving from a
-// template instantiation. This wasn't previously handled at all. Note that when
-// inheriting from a template parameter, the type that is instantiated might or
-// might not have a virtual table, and we have no way of knowing. We don't
-// handle that yet, so no test for it here.
-
-/// This should have an explicit vtable.
-template<class T>
-class BaseWithVtable {
-    T t;
-
-    virtual void hello();
-};
-
-/// This should not have an explicit vtable.
-class DerivedWithNoVirtualMethods : public BaseWithVtable<char*> {};
-
-/// This should not have an explicit vtable.
-class DerivedWithVirtualMethods : public BaseWithVtable<char*> {
-    virtual void zoidberg();
-};
-
-/// This should not have any vtable.
-template<class U>
-class BaseWithoutVtable {
-    U u;
-};
-
-/// This should have an explicit vtable.
-class DerivedWithVtable : public BaseWithoutVtable<char*> {
-    virtual void leela();
-};
-
-/// This should not have any vtable.
-class DerivedWithoutVtable : public BaseWithoutVtable<char*> {};
diff --git a/tests/headers/inherit-namespaced.hpp b/tests/headers/inherit-namespaced.hpp
deleted file mode 100644
index 61eafd5a..00000000
--- a/tests/headers/inherit-namespaced.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace js {
-    template <typename T> class RootedBase {};
-}
-template <typename T> class Rooted : js::RootedBase<T> {};
diff --git a/tests/headers/inherit_named.hpp b/tests/headers/inherit_named.hpp
deleted file mode 100644
index 9881d1b6..00000000
--- a/tests/headers/inherit_named.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-template<typename T>
-class Wohoo {};
-
-template<typename T>
-class Weeee : public T {};
diff --git a/tests/headers/inherit_typedef.hpp b/tests/headers/inherit_typedef.hpp
deleted file mode 100644
index 8d699e82..00000000
--- a/tests/headers/inherit_typedef.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-struct Foo {};
-
-typedef Foo TypedefedFoo;
-
-struct Bar: public TypedefedFoo {};
diff --git a/tests/headers/inline-function.h b/tests/headers/inline-function.h
deleted file mode 100644
index 02cb7c08..00000000
--- a/tests/headers/inline-function.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-unstable
-
-/** The point of this test is to _not_ generate these functions. */
-
-inline static int myadd(const int x, const int y) { return x + y; }
-static int mysub(const int x, const int y) { return x - y; }
diff --git a/tests/headers/inline_namespace.hpp b/tests/headers/inline_namespace.hpp
deleted file mode 100644
index 2ccf8ab0..00000000
--- a/tests/headers/inline_namespace.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces -- -std=c++11
-
-namespace foo {
-  inline namespace bar {
-    using Ty = int;
-  };
-};
-
-class Bar {
-  foo::Ty baz;
-};
diff --git a/tests/headers/inline_namespace_allowlist.hpp b/tests/headers/inline_namespace_allowlist.hpp
deleted file mode 100644
index 90e46dfb..00000000
--- a/tests/headers/inline_namespace_allowlist.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type=std::string -- -std=c++11
-
-namespace std {
-  inline namespace bar {
-    using string = const char*;
-  };
-};
diff --git a/tests/headers/inline_namespace_conservative.hpp b/tests/headers/inline_namespace_conservative.hpp
deleted file mode 100644
index 50068a2e..00000000
--- a/tests/headers/inline_namespace_conservative.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --conservative-inline-namespaces -- -std=c++11
-
-namespace foo {
-  inline namespace bar {
-    using Ty = int;
-  };
-  using Ty = long long;
-};
-
-class Bar {
-  foo::bar::Ty baz;
-};
diff --git a/tests/headers/inline_namespace_no_ns_enabled.hpp b/tests/headers/inline_namespace_no_ns_enabled.hpp
deleted file mode 100644
index 30cd4e9b..00000000
--- a/tests/headers/inline_namespace_no_ns_enabled.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-namespace std {
-inline namespace __cxx11 {
-
-template<typename CharT>
-class basic_string {
-  struct Alloc_hider {
-    void* storage;
-  } hider;
-  unsigned long length;
-  struct {
-    CharT inline_storage[4];
-  };
-};
-
-}
-}
diff --git a/tests/headers/inner-typedef-gh422.hpp b/tests/headers/inner-typedef-gh422.hpp
deleted file mode 100644
index 301630a5..00000000
--- a/tests/headers/inner-typedef-gh422.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-template <typename T>
-class Foo {
-public:
-    class InnerType {
-        T t;
-    };
-};
-
-typedef Foo<int>::InnerType Bar;
-
-Bar func();
\ No newline at end of file
diff --git a/tests/headers/inner_const.hpp b/tests/headers/inner_const.hpp
deleted file mode 100644
index 25c2e603..00000000
--- a/tests/headers/inner_const.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-class Foo {
-  static int BOO;
-  static Foo whatever;
-  int bar;
-};
diff --git a/tests/headers/inner_template_self.hpp b/tests/headers/inner_template_self.hpp
deleted file mode 100644
index 1ae5af06..00000000
--- a/tests/headers/inner_template_self.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-
-template <typename T>
-class LinkedList {
-    LinkedList<T>* next;
-    LinkedList* prev;
-};
-
-class InstantiateIt {
-    LinkedList<int> m_list;
-};
diff --git a/tests/headers/int128_t.h b/tests/headers/int128_t.h
deleted file mode 100644
index eece252c..00000000
--- a/tests/headers/int128_t.h
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * FIXME: Uncomment this once we can generate the proper alignment for the type,
- * i.e., when we use u128/i128.
-struct Foo {
-  __int128 foo;
-};
- */
diff --git a/tests/headers/issue-1025-unknown-enum-repr.hpp b/tests/headers/issue-1025-unknown-enum-repr.hpp
deleted file mode 100644
index 589b3c25..00000000
--- a/tests/headers/issue-1025-unknown-enum-repr.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-
-template <typename> class a {
-  enum {};
-};
diff --git a/tests/headers/issue-1034.h b/tests/headers/issue-1034.h
deleted file mode 100644
index 8042fec6..00000000
--- a/tests/headers/issue-1034.h
+++ /dev/null
@@ -1,4 +0,0 @@
-
-struct S2 {
-    unsigned : 11
-};
diff --git a/tests/headers/issue-1040.h b/tests/headers/issue-1040.h
deleted file mode 100644
index 1d61d40d..00000000
--- a/tests/headers/issue-1040.h
+++ /dev/null
@@ -1 +0,0 @@
-unsigned long long g_107 = 18446744073709551615UL;
diff --git a/tests/headers/issue-1076-unnamed-bitfield-alignment.h b/tests/headers/issue-1076-unnamed-bitfield-alignment.h
deleted file mode 100644
index 876ec174..00000000
--- a/tests/headers/issue-1076-unnamed-bitfield-alignment.h
+++ /dev/null
@@ -1,4 +0,0 @@
-struct S1 {
-    signed : 15;
-    unsigned : 6
-};
diff --git a/tests/headers/issue-1113-template-references.hpp b/tests/headers/issue-1113-template-references.hpp
deleted file mode 100644
index 46339c5d..00000000
--- a/tests/headers/issue-1113-template-references.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-template<class K, class V>
-class Entry : public K
-{
-  V mData;
-};
-
-template<typename K, typename V>
-class nsBaseHashtable {
-  typedef Entry<K, V> EntryType;
-
-  struct EntryPtr {
-  private:
-    EntryType& mEntry;
-    bool mExistingEntry;
-  };
-};
diff --git a/tests/headers/issue-1118-using-forward-decl.hpp b/tests/headers/issue-1118-using-forward-decl.hpp
deleted file mode 100644
index b6ea63f6..00000000
--- a/tests/headers/issue-1118-using-forward-decl.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-template <class> class nsTArray;
-template <class b> using c = nsTArray<b>;
-class nsTArray_base {
-  int *d;
-};
-template <class> class nsTArray : nsTArray_base {};
-class nsIContent {
-  nsTArray<nsIContent *> foo;
-};
-nsTArray<nsIContent*> *Gecko_GetAnonymousContentForElement();
diff --git a/tests/headers/issue-1197-pure-virtual-stuff.hpp b/tests/headers/issue-1197-pure-virtual-stuff.hpp
deleted file mode 100644
index a0da90c9..00000000
--- a/tests/headers/issue-1197-pure-virtual-stuff.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-class Foo
-{
-public:
-  virtual void Bar() = 0;
-  virtual ~Foo() = 0;
-};
diff --git a/tests/headers/issue-1198-alias-rust-bitfield-enum.h b/tests/headers/issue-1198-alias-rust-bitfield-enum.h
deleted file mode 100644
index 5bccb0d4..00000000
--- a/tests/headers/issue-1198-alias-rust-bitfield-enum.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --rustified-enum '.*' --bitfield-enum '.*'
-
-typedef enum MyDupeEnum {
-	A = 0,
-	A_alias = 0,
-	B,
-} MyDupeEnum;
-
-enum MyOtherDupeEnum {
-	C = 0,
-	C_alias = 0,
-	D,
-};
diff --git a/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h b/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
deleted file mode 100644
index ecdf8c3f..00000000
--- a/tests/headers/issue-1198-alias-rust-const-mod-bitfield-enum.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*' --bitfield-enum '.*'
-
-typedef enum MyDupeEnum {
-	A = 0,
-	A_alias = 0,
-	B,
-} MyDupeEnum;
-
-enum MyOtherDupeEnum {
-	C = 0,
-	C_alias = 0,
-	D,
-};
diff --git a/tests/headers/issue-1198-alias-rust-const-mod-enum.h b/tests/headers/issue-1198-alias-rust-const-mod-enum.h
deleted file mode 100644
index 944fac31..00000000
--- a/tests/headers/issue-1198-alias-rust-const-mod-enum.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --rustified-enum '.*' --constified-enum-module '.*'
-
-typedef enum MyDupeEnum {
-	A = 0,
-	A_alias = 0,
-	B,
-} MyDupeEnum;
-
-enum MyOtherDupeEnum {
-	C = 0,
-	C_alias = 0,
-	D,
-};
\ No newline at end of file
diff --git a/tests/headers/issue-1198-alias-rust-enum.h b/tests/headers/issue-1198-alias-rust-enum.h
deleted file mode 100644
index ede44f0a..00000000
--- a/tests/headers/issue-1198-alias-rust-enum.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --rustified-enum '.*'
-
-
-typedef enum MyDupeEnum {
-	A = 0,
-	A_alias = 0,
-	B,
-} MyDupeEnum;
-
-enum MyOtherDupeEnum {
-	C = 0,
-	C_alias = 0,
-	D,
-};
\ No newline at end of file
diff --git a/tests/headers/issue-1216-variadic-member.h b/tests/headers/issue-1216-variadic-member.h
deleted file mode 100644
index b8bc0b81..00000000
--- a/tests/headers/issue-1216-variadic-member.h
+++ /dev/null
@@ -1,4 +0,0 @@
-void f(int a, ...);
-struct Foo {
-  void (*f)(void *p, void *obj, int a, ...);
-};
diff --git a/tests/headers/issue-1238-fwd-no-copy.h b/tests/headers/issue-1238-fwd-no-copy.h
deleted file mode 100644
index 150bbbeb..00000000
--- a/tests/headers/issue-1238-fwd-no-copy.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --no-copy MyType
-
-typedef struct MyType MyTypeT;
diff --git a/tests/headers/issue-1281.h b/tests/headers/issue-1281.h
deleted file mode 100644
index 4a3aaab0..00000000
--- a/tests/headers/issue-1281.h
+++ /dev/null
@@ -1,11 +0,0 @@
-struct foo;
-
-typedef struct bar {
-  struct foo {
-    int foo;
-  } u;
-} bar_t;
-
-struct baz {
-  struct foo f;
-};
diff --git a/tests/headers/issue-1285.h b/tests/headers/issue-1285.h
deleted file mode 100644
index a2817d84..00000000
--- a/tests/headers/issue-1285.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --no-recursive-allowlist --allowlist-type "foo"
-
-struct foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    } bar;
-};
\ No newline at end of file
diff --git a/tests/headers/issue-1291.hpp b/tests/headers/issue-1291.hpp
deleted file mode 100644
index 4ec524f1..00000000
--- a/tests/headers/issue-1291.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --rust-target 1.25
-// bindgen-unstable
-
-struct __attribute__((aligned(16))) RTCRay
-    {
-  float org[3];
-  float align0;
-  float dir[3];
-  float align1;
-  float tnear;
-  float tfar;
-  float time;
-  unsigned mask;
-  float Ng[3];
-  float align2;
-  float u;
-  float v;
-  unsigned geomID;
-  unsigned primID;
-  unsigned instID;
-};
diff --git a/tests/headers/issue-1350-attribute-overloadable.h b/tests/headers/issue-1350-attribute-overloadable.h
deleted file mode 100644
index 4b0ec2a6..00000000
--- a/tests/headers/issue-1350-attribute-overloadable.h
+++ /dev/null
@@ -1,2 +0,0 @@
-void my_function(int a) __attribute__((overloadable));
-void my_function(const char *a) __attribute__((overloadable));
diff --git a/tests/headers/issue-1382-rust-primitive-types.h b/tests/headers/issue-1382-rust-primitive-types.h
deleted file mode 100644
index 4cf346e6..00000000
--- a/tests/headers/issue-1382-rust-primitive-types.h
+++ /dev/null
@@ -1,34 +0,0 @@
-typedef int int8_t;
-typedef int uint8_t;
-typedef int int16_t;
-typedef int uint16_t;
-typedef int int32_t;
-typedef int uint32_t;
-typedef int int64_t;
-typedef int uint64_t;
-
-typedef int8_t i8;
-typedef uint8_t u8;
-typedef int16_t i16;
-typedef uint16_t u16;
-typedef int32_t i32;
-typedef uint32_t u32;
-typedef int64_t i64;
-typedef uint64_t u64;
-
-struct Foo {
-    int i8;
-    int u8;
-    int i16;
-    int u16;
-    int i32;
-    int u32;
-    int i64;
-    int u64;
-    int i128;
-    int u128;
-    int isize;
-    int usize;
-    int f32;
-    int f64;
-};
diff --git a/tests/headers/issue-1435.hpp b/tests/headers/issue-1435.hpp
deleted file mode 100644
index fbf3c507..00000000
--- a/tests/headers/issue-1435.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-namespace ns {
-enum class AB { A, B };
-}
-using AB = ns::AB;
-static const AB kA = AB::A;
diff --git a/tests/headers/issue-1443.hpp b/tests/headers/issue-1443.hpp
deleted file mode 100644
index 9b637ba7..00000000
--- a/tests/headers/issue-1443.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-struct Foo;
-
-struct Bar {
-  const Foo& f;
-  unsigned m;
-};
-
-struct Baz {
-  Foo& f;
-  unsigned m;
-};
-
-struct Tar {
-  const Foo&& f;
-  unsigned m;
-};
-
-struct Taz {
-  Foo&& f;
-  unsigned m;
-};
diff --git a/tests/headers/issue-1454.h b/tests/headers/issue-1454.h
deleted file mode 100644
index 96645dac..00000000
--- a/tests/headers/issue-1454.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --no-recursive-allowlist --allowlist-type "local_type" --with-derive-hash --no-derive-copy --no-derive-default --raw-line "#[repr(C)] #[derive(Debug)] pub struct extern_type;"
-// bindgen-parse-callbacks: blocklisted-type-implements-trait
-
-struct extern_type {};
-
-typedef struct
-{
-    struct extern_type inner;
-}
-local_type;
diff --git a/tests/headers/issue-1464.hpp b/tests/headers/issue-1464.hpp
deleted file mode 100644
index d34d0fe3..00000000
--- a/tests/headers/issue-1464.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-
-// Should not crash.
-template <int Foo> class Bar {
-public:
-  Bar();
-  ~Bar();
-};
diff --git a/tests/headers/issue-1488-enum-new-type.h b/tests/headers/issue-1488-enum-new-type.h
deleted file mode 100644
index 6855283f..00000000
--- a/tests/headers/issue-1488-enum-new-type.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// bindgen-flags: --default-alias-style=new_type --constified-enum "Foo" --constified-enum-module "Bar" --rustified-enum "Qux" --new-type-alias-deref "BazAlias"
-
-enum Foo {
-    A,
-    B
-};
-
-typedef enum Foo FooAlias;
-
-enum Bar {
-    C,
-    D
-};
-
-typedef enum Bar BarAlias;
-
-enum Qux {
-    E,
-    F
-};
-
-typedef enum Qux QuxAlias;
-
-enum Baz {
-    G,
-    H
-};
-
-typedef enum Baz BazAlias;
\ No newline at end of file
diff --git a/tests/headers/issue-1488-options.h b/tests/headers/issue-1488-options.h
deleted file mode 100644
index fba1c93b..00000000
--- a/tests/headers/issue-1488-options.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --new-type-alias "SomePtr" --new-type-alias-deref "AnotherPtr"
-
-typedef int OSStatus;
-typedef void* SomePtr;
-typedef void* AnotherPtr;
\ No newline at end of file
diff --git a/tests/headers/issue-1488-template-alias-new-type.hpp b/tests/headers/issue-1488-template-alias-new-type.hpp
deleted file mode 100644
index 4374da3d..00000000
--- a/tests/headers/issue-1488-template-alias-new-type.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --default-alias-style=new_type -- -std=c++14
-
-template<typename T>
-using Wrapped = T;
diff --git a/tests/headers/issue-1498.h b/tests/headers/issue-1498.h
deleted file mode 100644
index aceabbd2..00000000
--- a/tests/headers/issue-1498.h
+++ /dev/null
@@ -1,17 +0,0 @@
-typedef unsigned long uint64_t;
-typedef uint64_t size_t;
-typedef unsigned uint32_t;
-typedef int int32_t;
-
-struct rte_memseg {
-    uint64_t phys_addr;      /**< Start physical address. */
-    union {
-        void *addr;         /**< Start virtual address. */
-        uint64_t addr_64;   /**< Makes sure addr is always 64 bits */
-    };
-    size_t len;               /**< Length of the segment. */
-    uint64_t hugepage_sz;       /**< The pagesize of underlying memory */
-    int32_t socket_id;          /**< NUMA socket ID. */
-    uint32_t nchannel;          /**< Number of channels. */
-    uint32_t nrank;             /**< Number of ranks. */
-} __attribute__((__packed__));
diff --git a/tests/headers/issue-1514.hpp b/tests/headers/issue-1514.hpp
deleted file mode 100644
index 2a398898..00000000
--- a/tests/headers/issue-1514.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-template<typename T>
-struct Thing {
-    struct Inner {
-        T *ptr;
-    };
-
-    struct AnotherInner : Inner {
-    };
-};
diff --git a/tests/headers/issue-1554.h b/tests/headers/issue-1554.h
deleted file mode 100644
index 13452923..00000000
--- a/tests/headers/issue-1554.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --default-enum-style rust_non_exhaustive --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(non_exhaustive)]'
-
-enum Planet {
-    earth,
-    mars
-};
diff --git a/tests/headers/issue-1599-opaque-typedef-to-enum.h b/tests/headers/issue-1599-opaque-typedef-to-enum.h
deleted file mode 100644
index 85e845b8..00000000
--- a/tests/headers/issue-1599-opaque-typedef-to-enum.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --opaque-type d
-
-typedef enum a { b, c } d;
diff --git a/tests/headers/issue-1676-macro-namespace-prefix.hpp b/tests/headers/issue-1676-macro-namespace-prefix.hpp
deleted file mode 100644
index 297927b6..00000000
--- a/tests/headers/issue-1676-macro-namespace-prefix.hpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define nssv_inline_ns inline
-nssv_inline_ns namespace literals {}
diff --git a/tests/headers/issue-1947.h b/tests/headers/issue-1947.h
deleted file mode 100644
index e2e9b3e1..00000000
--- a/tests/headers/issue-1947.h
+++ /dev/null
@@ -1,9 +0,0 @@
-typedef unsigned char U8;
-typedef unsigned short U16;
-
-typedef struct {
-    U16 MADZ : 10, MAI0 : 2, MAI1 : 2, MAI2 : 2;
-    U8 MADK, MABR;
-    U16 MATH : 10, MATE : 4, MATW : 2;
-    U8 MASW : 4, MABW : 3, MAXN : 1, _rB_;
-} V56AMDY;
diff --git a/tests/headers/issue-1977-larger-arrays.hpp b/tests/headers/issue-1977-larger-arrays.hpp
deleted file mode 100644
index 58e8e4d1..00000000
--- a/tests/headers/issue-1977-larger-arrays.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct S {
-    char large_array[33];
-};
-
-template<typename T> struct ST {
-    T large_array[33];
-};
diff --git a/tests/headers/issue-1995.h b/tests/headers/issue-1995.h
deleted file mode 100644
index 619f6735..00000000
--- a/tests/headers/issue-1995.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/// This is a constant that has a docstring
-///
-/// And expected to be found in generated bindings code too.
-const int FOO = 1;
-
-/// This is a constant that has a docstring
-///
-/// And expected to be found in generated bindings code too.
-struct Bar
-{
-    int baz;
-};
\ No newline at end of file
diff --git a/tests/headers/issue-2019.hpp b/tests/headers/issue-2019.hpp
deleted file mode 100644
index 2e9a3ffd..00000000
--- a/tests/headers/issue-2019.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --disable-nested-struct-naming
-
-struct A {
-    static A make();
-    int a;
-};
-struct B {
-    static B make();
-    int b;
-};
diff --git a/tests/headers/issue-2239-template-dependent-bit-width.hpp b/tests/headers/issue-2239-template-dependent-bit-width.hpp
deleted file mode 100644
index 4e6feb3f..00000000
--- a/tests/headers/issue-2239-template-dependent-bit-width.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-template <class a> class b {
-    typedef a td;
-    using ta = a;
-    struct foo {
-        a foo : sizeof(a);
-        a : sizeof(a);
-        td : sizeof(td);
-        ta : sizeof(ta);
-    };
-};
diff --git a/tests/headers/issue-358.hpp b/tests/headers/issue-358.hpp
deleted file mode 100644
index b14521b7..00000000
--- a/tests/headers/issue-358.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++11
-namespace JS {
-template <typename> class PersistentRooted;
-}
-template <typename> class a { a *b; };
-namespace JS {
-template <typename c> class PersistentRooted : a<PersistentRooted<c>> {};
-}
diff --git a/tests/headers/issue-372.hpp b/tests/headers/issue-372.hpp
deleted file mode 100644
index a2a5d451..00000000
--- a/tests/headers/issue-372.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*" --rust-target 1.40
-template <typename a, int b> class c { a e[b]; };
-class d;
-template <typename g, g f> class C { c<d, f> h; };
-class i {
-  i *j;
-  i *k;
-  bool l;
-};
-class d {
-  i m;
-};
-enum n { o, p, q, r, s, t, b, ae, e, ag, ah, ai };
-class F {
-  C<n, ai> w;
-};
diff --git a/tests/headers/issue-410.hpp b/tests/headers/issue-410.hpp
deleted file mode 100644
index d4f3de3d..00000000
--- a/tests/headers/issue-410.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type JS::Value --rustified-enum ".*"
-
-namespace JS {
-class Value;
-}
-typedef enum {} JSWhyMagic;
-namespace JS {
-class Value {
-public:
-  void a(JSWhyMagic);
-};
-}
diff --git a/tests/headers/issue-446.hpp b/tests/headers/issue-446.hpp
deleted file mode 100644
index 2e09c274..00000000
--- a/tests/headers/issue-446.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename Elem>
-class List {
-    List<Elem> *next;
-};
-
-template <typename GcThing>
-class PersistentRooted {
-    List<PersistentRooted<GcThing>> root_list;
-};
diff --git a/tests/headers/issue-447.hpp b/tests/headers/issue-447.hpp
deleted file mode 100644
index 43765fa9..00000000
--- a/tests/headers/issue-447.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type JSAutoCompartment -- -std=c++11
-
-namespace mozilla {
-    template <typename> class a {};
-    namespace detail {
-        class GuardObjectNotifier {};
-        struct b;
-    }
-    class c {
-        typedef detail::b d;
-    };
-}
-namespace js {
-    class D {
-        mozilla::a<mozilla::c> e;
-    };
-}
-struct f {
-    js::D g;
-};
-namespace js {
-    struct ContextFriendFields : f {};
-}
-class JSAutoCompartment {
-public:
-    JSAutoCompartment(mozilla::detail::GuardObjectNotifier);
-};
diff --git a/tests/headers/issue-493.hpp b/tests/headers/issue-493.hpp
deleted file mode 100644
index 8b122ceb..00000000
--- a/tests/headers/issue-493.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-template<class _CharT, class _Traits, class _Allocator>
-class basic_string
-{
-public:
-    typedef unsigned long long size_type;
-    typedef char value_type;
-    typedef value_type * pointer;
-
-    struct __long
-    {
-        size_type __cap_;
-        size_type __size_;
-        pointer   __data_;
-    };
-
-    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
-                        (sizeof(__long) - 1)/sizeof(value_type) : 2};
-
-    struct __short
-    {
-        union
-        {
-            unsigned char __size_;
-            value_type __lx;
-        };
-        value_type __data_[__min_cap];
-    };
-
-    union __ulx{__long __lx; __short __lxx;};
-
-    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
-
-    struct __raw
-    {
-        size_type __words[__n_words];
-    };
-
-    struct __rep
-    {
-        union
-        {
-            __long  __l;
-            __short __s;
-            __raw   __r;
-        };
-    };
-};
diff --git a/tests/headers/issue-493_1_0.hpp b/tests/headers/issue-493_1_0.hpp
deleted file mode 100644
index af6fd47c..00000000
--- a/tests/headers/issue-493_1_0.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-
-template<class _CharT, class _Traits, class _Allocator>
-class basic_string
-{
-public:
-    typedef unsigned long long size_type;
-    typedef char value_type;
-    typedef value_type * pointer;
-
-    struct __long
-    {
-        size_type __cap_;
-        size_type __size_;
-        pointer   __data_;
-    };
-
-    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
-                        (sizeof(__long) - 1)/sizeof(value_type) : 2};
-
-    struct __short
-    {
-        union
-        {
-            unsigned char __size_;
-            value_type __lx;
-        };
-        value_type __data_[__min_cap];
-    };
-
-    union __ulx{__long __lx; __short __lxx;};
-
-    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
-
-    struct __raw
-    {
-        size_type __words[__n_words];
-    };
-
-    struct __rep
-    {
-        union
-        {
-            __long  __l;
-            __short __s;
-            __raw   __r;
-        };
-    };
-};
diff --git a/tests/headers/issue-511.h b/tests/headers/issue-511.h
deleted file mode 100644
index da364312..00000000
--- a/tests/headers/issue-511.h
+++ /dev/null
@@ -1,4 +0,0 @@
-char * a;
-const char * b;
-char * const c;
-const char * const d;
\ No newline at end of file
diff --git a/tests/headers/issue-537-repr-packed-n.h b/tests/headers/issue-537-repr-packed-n.h
deleted file mode 100644
index f4c0070a..00000000
--- a/tests/headers/issue-537-repr-packed-n.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.33
-
-/// This should not be opaque; we can see the attributes and can pack the
-/// struct.
-struct AlignedToOne {
-    int i;
-} __attribute__ ((packed,aligned(1)));
-
-/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
-struct AlignedToTwo {
-    int i;
-} __attribute__ ((packed,aligned(2)));
-
-#pragma pack(1)
-
-/// This should not be opaque because although `libclang` doesn't give us the
-/// `#pragma pack(1)`, we can detect that alignment is 1 and add
-/// `#[repr(packed)]` to the struct ourselves.
-struct PackedToOne {
-    int x;
-    int y;
-};
-
-#pragma pack()
-
-#pragma pack(2)
-
-/// This should be be packed because Rust 1.33 has `#[repr(packed(N))]`.
-struct PackedToTwo {
-    int x;
-    int y;
-};
-
-#pragma pack()
diff --git a/tests/headers/issue-537.h b/tests/headers/issue-537.h
deleted file mode 100644
index a773199f..00000000
--- a/tests/headers/issue-537.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/// This should not be opaque; we can see the attributes and can pack the
-/// struct.
-struct AlignedToOne {
-    int i;
-} __attribute__ ((packed,aligned(1)));
-
-/// This should be opaque because although we can see the attributes, Rust before
-/// 1.33 doesn't have `#[repr(packed(N))]`.
-struct AlignedToTwo {
-    int i;
-} __attribute__ ((packed,aligned(2)));
-
-#pragma pack(1)
-
-/// This should not be opaque because although `libclang` doesn't give us the
-/// `#pragma pack(1)`, we can detect that alignment is 1 and add
-/// `#[repr(packed)]` to the struct ourselves.
-struct PackedToOne {
-    int x;
-    int y;
-};
-
-#pragma pack()
-
-#pragma pack(2)
-
-/// In this case, even if we can detect the weird alignment triggered by
-/// `#pragma pack(2)`, we can't do anything about it because Rust before 1.33
-/// doesn't have `#[repr(packed(N))]`. Therefore, we must make it opaque.
-struct PackedToTwo {
-    int x;
-    int y;
-};
-
-#pragma pack()
diff --git a/tests/headers/issue-544-stylo-creduce-2.hpp b/tests/headers/issue-544-stylo-creduce-2.hpp
deleted file mode 100644
index f3467f45..00000000
--- a/tests/headers/issue-544-stylo-creduce-2.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-struct Foo {
-    template <typename> using FirstAlias = typename T::Associated;
-    template <typename U> using SecondAlias = Foo<FirstAlias<U>>;
-    SecondAlias<int> member;
-};
diff --git a/tests/headers/issue-544-stylo-creduce.hpp b/tests/headers/issue-544-stylo-creduce.hpp
deleted file mode 100644
index ba9f8257..00000000
--- a/tests/headers/issue-544-stylo-creduce.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename> class a;
-template <typename b, typename... c> class a<b(c...)> { a(const a &); };
-template <typename b, typename... c> a<b(c...)>::a(const a &) {}
diff --git a/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp b/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
deleted file mode 100644
index 297d1112..00000000
--- a/tests/headers/issue-569-non-type-template-params-causing-layout-test-failures.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++14
-
-// Generated by C-Reduce, cleaned up and given names for readability.
-
-template <int, typename>
-struct HasNonTypeTemplateParam {
-    // But doesn't use the non-type template param nor its type param...
-};
-
-enum {
-    ENUM_VARIANT_1,
-    ENUM_VARIANT_2
-};
-
-namespace JS {
-
-template <typename T>
-using Alias = HasNonTypeTemplateParam<ENUM_VARIANT_1, T>;
-
-template <typename U>
-class Base {
-    Alias<U> f;
-};
-
-class AutoIdVector : Base<int> {};
-
-}
diff --git a/tests/headers/issue-573-layout-test-failures.hpp b/tests/headers/issue-573-layout-test-failures.hpp
deleted file mode 100644
index ac8cbd48..00000000
--- a/tests/headers/issue-573-layout-test-failures.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-template <int>
-struct UnusedIntTemplateParam {};
-
-template <class>
-class Outer {
-    static const long SIZE = 1;
-    UnusedIntTemplateParam<SIZE> i;
-};
-
-class AutoIdVector {
-  Outer<int> ar;
-};
diff --git a/tests/headers/issue-574-assertion-failure-in-codegen.hpp b/tests/headers/issue-574-assertion-failure-in-codegen.hpp
deleted file mode 100644
index b563b4ef..00000000
--- a/tests/headers/issue-574-assertion-failure-in-codegen.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <class> class a {};
-class {
-  a<int> ar;
-} AutoIdVector;
diff --git a/tests/headers/issue-584-stylo-template-analysis-panic.hpp b/tests/headers/issue-584-stylo-template-analysis-panic.hpp
deleted file mode 100644
index 5f11ea3c..00000000
--- a/tests/headers/issue-584-stylo-template-analysis-panic.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --blocklist-type RefPtr --allowlist-function 'Servo_.*' --raw-line 'pub type RefPtr<T> = T;' -- -std=c++14
-template <class> class RefPtr;
-class b;
-class A {
-  typedef b a;
-};
-template <class c> class e { RefPtr<c> d; };
-template <class> class f {};
-class g {
-  f<e<int>> h;
-};
-class b : g {};
-A Servo_Element_GetSnapshot();
diff --git a/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp b/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
deleted file mode 100644
index 13b656e1..00000000
--- a/tests/headers/issue-638-stylo-cannot-find-T-in-this-scope.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <class T>
-class RefPtr {
-    T use_of_t;
-};
-
-template <typename U>
-class UsesRefPtrWithAliasedTypeParam {
-    using V = U;
-    RefPtr<V> member;
-};
diff --git a/tests/headers/issue-639-typedef-anon-field.hpp b/tests/headers/issue-639-typedef-anon-field.hpp
deleted file mode 100644
index efd6c4f4..00000000
--- a/tests/headers/issue-639-typedef-anon-field.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-class Foo {
- public:
-  typedef struct {
-      int abc;
-  } Bar;
-
-  Bar bar;
-};
-
-class Baz {
- public:
-  typedef struct {
-      int abc;
-  } Bar;
-};
diff --git a/tests/headers/issue-643-inner-struct.h b/tests/headers/issue-643-inner-struct.h
deleted file mode 100644
index 25c525b3..00000000
--- a/tests/headers/issue-643-inner-struct.h
+++ /dev/null
@@ -1,13 +0,0 @@
-struct rte_ring {
-  struct rte_memzone *memzone;
-
-  struct prod {
-    unsigned watermark;
-  } prod;
-
-  struct cons {
-    unsigned sc_dequeue;
-  } cons;
-
-  void *ring[];
-};
diff --git a/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp b/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
deleted file mode 100644
index 8e07a8a0..00000000
--- a/tests/headers/issue-645-cannot-find-type-T-in-this-scope.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --blocklist-type RefPtr --raw-line "#[derive(Clone, Copy, Debug)] pub struct RefPtr<T>(T);" --allowlist-type "HasRefPtr" -- -std=c++14
-
-template <class> class RefPtr {};
-
-template <typename T>
-class HasRefPtr {
-  typedef T TypedefOfT;
-  RefPtr<TypedefOfT> refptr_member;
-};
diff --git a/tests/headers/issue-648-derive-debug-with-padding.h b/tests/headers/issue-648-derive-debug-with-padding.h
deleted file mode 100644
index 0860ce95..00000000
--- a/tests/headers/issue-648-derive-debug-with-padding.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rust-target 1.40
-/**
- * We emit a `[u8; 63usize]` padding field for this struct, which cannot derive
- * Debug/Hash because 63 is over the hard coded limit.
- */
-struct NoDebug {
-    char c;
-    // padding of 63 bytes
-} __attribute__((__aligned__(64)));
-
-/**
- * This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive
- * Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because
- * we determine Debug derive-ability before we compute padding, which happens at
- * codegen.
- */
-struct ShouldDeriveDebugButDoesNot {
-    char c[32];
-    char d;
-    // padding of 31 bytes
-} __attribute__((__aligned__(64)));
diff --git a/tests/headers/issue-654-struct-fn-collision.h b/tests/headers/issue-654-struct-fn-collision.h
deleted file mode 100644
index f52a1b20..00000000
--- a/tests/headers/issue-654-struct-fn-collision.h
+++ /dev/null
@@ -1,2 +0,0 @@
-struct foo;
-int foo(void);
diff --git a/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp b/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
deleted file mode 100644
index 6b3f928b..00000000
--- a/tests/headers/issue-662-cannot-find-T-in-this-scope.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- --std=c++14
-
-template <class T> class RefPtr { T a; };
-template <class T> class nsMainThreadPtrHolder { T a; };
-template <class T> class nsMainThreadPtrHandle {
-    RefPtr<nsMainThreadPtrHolder<T>> mPtr;
-};
diff --git a/tests/headers/issue-662-part-2.hpp b/tests/headers/issue-662-part-2.hpp
deleted file mode 100644
index 1330c342..00000000
--- a/tests/headers/issue-662-part-2.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --blocklist-type RefPtr --raw-line '#[derive(Clone, Copy, Debug)] pub struct RefPtr<T>(T);' -- --std=c++14
-
-// This is pretty much the same as the other issue 662 test case, but this time
-// we blocklist RefPtr to exercise the instantiation-of-a-blocklisted-template
-// path in the template analysis.
-
-template <class> class RefPtr {};
-template <class T> class nsMainThreadPtrHolder { T a; };
-template <class U> class nsMainThreadPtrHandle {
-    RefPtr<nsMainThreadPtrHolder<U>> mPtr;
-};
diff --git a/tests/headers/issue-674-1.hpp b/tests/headers/issue-674-1.hpp
deleted file mode 100644
index 7fc781c1..00000000
--- a/tests/headers/issue-674-1.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type CapturingContentInfo --opaque-type 'mozilla::Maybe' -- -std=c++14
-
-namespace mozilla {
-template <class T> class Maybe { using ValueType = T; };
-}
-struct CapturingContentInfo {
-  mozilla::Maybe<float> a;
-};
diff --git a/tests/headers/issue-674-2.hpp b/tests/headers/issue-674-2.hpp
deleted file mode 100644
index 86d2b648..00000000
--- a/tests/headers/issue-674-2.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type StaticRefPtr --opaque-type 'JS::Rooted' -- -std=c++14
-
-namespace JS {
-template <typename T> class Rooted { using ElementType = T; };
-}
-class c {
-  JS::Rooted<int> b;
-};
-class B {
-  c a;
-};
-template <class> class StaticRefPtr {};
-struct {
-  StaticRefPtr<B> d;
-} e;
diff --git a/tests/headers/issue-674-3.hpp b/tests/headers/issue-674-3.hpp
deleted file mode 100644
index 20aa463c..00000000
--- a/tests/headers/issue-674-3.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type nsCSSValue --opaque-type 'nsRefPtrHashtable' -- -std=c++14
-
-template <class PtrType> class nsRefPtrHashtable {
-  typedef PtrType *UserDataType;
-};
-struct a {
-  nsRefPtrHashtable<int> b;
-};
-class nsCSSValue {
-  a c;
-};
diff --git a/tests/headers/issue-677-nested-ns-specifier.hpp b/tests/headers/issue-677-nested-ns-specifier.hpp
deleted file mode 100644
index ef2cea82..00000000
--- a/tests/headers/issue-677-nested-ns-specifier.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces -- -std=c++14
-
-namespace foo::bar {
-  typedef int bar;
-}
diff --git a/tests/headers/issue-691-template-parameter-virtual.hpp b/tests/headers/issue-691-template-parameter-virtual.hpp
deleted file mode 100644
index f80e058d..00000000
--- a/tests/headers/issue-691-template-parameter-virtual.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-class VirtualMethods {
-  virtual void foo();
-};
-
-template<typename K>
-class Set {
-  int bar;
-};
-
-class ServoElementSnapshotTable
-  : public Set<VirtualMethods>
-{};
diff --git a/tests/headers/issue-710-must-use-type.h b/tests/headers/issue-710-must-use-type.h
deleted file mode 100644
index 276f636d..00000000
--- a/tests/headers/issue-710-must-use-type.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --must-use-type A
-
-struct A;
-
-/** <div rustbindgen mustusetype></div> */
-struct B;
-
-struct C;
diff --git a/tests/headers/issue-739-pointer-wide-bitfield.h b/tests/headers/issue-739-pointer-wide-bitfield.h
deleted file mode 100644
index eeb7ae9c..00000000
--- a/tests/headers/issue-739-pointer-wide-bitfield.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --raw-line '#![cfg(not(target_os="windows"))]'
-#define POINTER_WIDTH (sizeof(void*) * 8)
-
-struct Foo {
-  unsigned long m_bitfield: POINTER_WIDTH;
-  unsigned long m_bar: POINTER_WIDTH;
-  unsigned long foo: 1;
-  unsigned long bar: POINTER_WIDTH;
-};
diff --git a/tests/headers/issue-769-bad-instantiation-test.hpp b/tests/headers/issue-769-bad-instantiation-test.hpp
deleted file mode 100644
index 13c6dd1c..00000000
--- a/tests/headers/issue-769-bad-instantiation-test.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --allowlist-type Rooted
-
-template <typename T>
-class Rooted {
-    T member;
-};
-
-class AutoValueVector : Rooted<int> {
-    using Alias = int;
-    using RootedAlias = Rooted<Alias>;
-};
diff --git a/tests/headers/issue-801-opaque-sloppiness.hpp b/tests/headers/issue-801-opaque-sloppiness.hpp
deleted file mode 100644
index 6b707f4e..00000000
--- a/tests/headers/issue-801-opaque-sloppiness.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --opaque-type "B" --allowlist-type "C" --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-class A;
-
-class B {
-  static A a;
-};
-
-class C {
-  B b;
-};
diff --git a/tests/headers/issue-807-opaque-types-methods-being-generated.hpp b/tests/headers/issue-807-opaque-types-methods-being-generated.hpp
deleted file mode 100644
index de98b32a..00000000
--- a/tests/headers/issue-807-opaque-types-methods-being-generated.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// bindgen-flags: --allowlist-type Allowlisted --opaque-type Opaque --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
-
-// These types are not explicitly allowlisted, but are reachable through the
-// opaque type.
-class Pupper {};
-class Doggo {};
-class SuchWow {};
-
-// These types are not allowlisted, and would be reachable through `Opaque` if
-// it were not marked opaque, but since it is, there should be no bindings
-// generated for them.
-class NoBindingsShouldBeGeneratedForMe1 {};
-class NoBindingsShouldBeGeneratedForMe2 {};
-
-// Exercise the different kinds of outgoing edges from an opaque type.
-class Opaque
-  // Base member edge.
-  : public NoBindingsShouldBeGeneratedForMe1 {
-
-protected:
-    // Field edge.
-    NoBindingsShouldBeGeneratedForMe2 field;
-
-    // Constructor edge.
-    Opaque(Pupper pup);
-
-    // Inner static variable edge.
-    static Doggo MAJESTIC_AF;
-
-    // Method edge.
-    SuchWow eleven_out_of_ten();
-};
-
-class Allowlisted {
-    Opaque some_member;
-};
diff --git a/tests/headers/issue-816.h b/tests/headers/issue-816.h
deleted file mode 100644
index 5f16a178..00000000
--- a/tests/headers/issue-816.h
+++ /dev/null
@@ -1,49 +0,0 @@
-typedef struct {
-    unsigned int bit_1 : 1;
-    unsigned int bit_2 : 1;
-    unsigned int bit_3 : 1;
-    unsigned int bit_4 : 1;
-    unsigned int bit_5 : 1;
-    unsigned int bit_6 : 1;
-    unsigned int bit_7 : 1;
-    unsigned int bit_8 : 1;
-    unsigned int bit_9 : 1;
-    unsigned int bit_10 : 1;
-    unsigned int bit_11 : 1;
-    unsigned int bit_12 : 1;
-    unsigned int bit_13 : 1;
-    unsigned int bit_14 : 1;
-    unsigned int bit_15 : 1;
-    unsigned int bit_16 : 1;
-    unsigned int bit_17 : 1;
-    unsigned int bit_18 : 1;
-    unsigned int bit_19 : 1;
-    unsigned int bit_20 : 1;
-    unsigned int bit_21 : 1;
-    unsigned int bit_22 : 1;
-    unsigned int bit_23 : 1;
-    unsigned int bit_24 : 1;
-    unsigned int bit_25 : 1;
-    unsigned int bit_26 : 1;
-    unsigned int bit_27 : 1;
-    unsigned int bit_28 : 1;
-    unsigned int bit_29 : 1;
-    unsigned int bit_30 : 1;
-    unsigned int bit_31 : 1;
-    unsigned int bit_32 : 1;
-    unsigned int bit_33 : 1;
-    unsigned int bit_34 : 1;
-    unsigned int bit_35 : 1;
-    unsigned int bit_36 : 1;
-    unsigned int bit_37 : 1;
-    unsigned int bit_38 : 1;
-    unsigned int bit_39 : 1;
-    unsigned int bit_40 : 1;
-    unsigned int bit_41 : 1;
-    unsigned int : 7;
-    unsigned int : 16;
-    unsigned int : 16;
-    unsigned int : 16;
-    unsigned int : 16;
-    unsigned int : 16;
-} capabilities;
diff --git a/tests/headers/issue-820-unused-template-param-in-alias.hpp b/tests/headers/issue-820-unused-template-param-in-alias.hpp
deleted file mode 100644
index ca5d8b96..00000000
--- a/tests/headers/issue-820-unused-template-param-in-alias.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-template<typename E, int N>
-class Foo {
-    typedef Foo<E, N> self_type;
-    E mBar;
-};
diff --git a/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp b/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
deleted file mode 100644
index f6b2ed30..00000000
--- a/tests/headers/issue-826-generating-methods-when-asked-not-to.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --ignore-methods -- --target=i686-pc-win32
-
-struct Foo {
-    void test();
-};
diff --git a/tests/headers/issue-833-1.hpp b/tests/headers/issue-833-1.hpp
deleted file mode 100644
index d66ee01f..00000000
--- a/tests/headers/issue-833-1.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray { pub hdr: *const () }"
-
-template<typename T>
-class nsTArray {
-  static T* sFoo;
-};
-
-extern "C" nsTArray<int>* func();
diff --git a/tests/headers/issue-833-2.hpp b/tests/headers/issue-833-2.hpp
deleted file mode 100644
index 487c5607..00000000
--- a/tests/headers/issue-833-2.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --raw-line "// If the output of this changes, please ensure issue-833-1.hpp changes too"
-
-template<typename T>
-class nsTArray {
-  static T* sFoo;
-};
diff --git a/tests/headers/issue-833.hpp b/tests/headers/issue-833.hpp
deleted file mode 100644
index f8b708bf..00000000
--- a/tests/headers/issue-833.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --generate functions --allowlist-function func --raw-line "#[repr(C)] pub struct nsTArray<T> { pub hdr: *const T }"
-
-template<typename T>
-class nsTArray {
-  T* mHeader;
-};
-
-extern "C" nsTArray<int>* func();
diff --git a/tests/headers/issue-834.hpp b/tests/headers/issue-834.hpp
deleted file mode 100644
index 64797012..00000000
--- a/tests/headers/issue-834.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --allowlist-type U --generate types
-
-struct T {};
-struct U {
-  void test(T a);
-};
diff --git a/tests/headers/issue-848-replacement-system-include.hpp b/tests/headers/issue-848-replacement-system-include.hpp
deleted file mode 100644
index e95c823f..00000000
--- a/tests/headers/issue-848-replacement-system-include.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- -Itests/headers/issue-848
-
-#include "an-include.h"
-
-extern "C" {
-  nsTArray<int>* func();
-}
diff --git a/tests/headers/issue-848/an-include.h b/tests/headers/issue-848/an-include.h
deleted file mode 100644
index 0421d19f..00000000
--- a/tests/headers/issue-848/an-include.h
+++ /dev/null
@@ -1,17 +0,0 @@
-template<typename T>
-class nsTArray {
-  void* mBuffer;
-};
-
-/**
- * This is intended to replace another type, but won't if we treat this include
- * as a system include, because clang doesn't parse comments there.
- *
- * See #848.
- *
- * <div rustbindgen replaces="nsTArray"></div>
- */
-template<typename T>
-class nsTArray_Simple {
-  T* m;
-};
diff --git a/tests/headers/issue-888-enum-var-decl-jump.hpp b/tests/headers/issue-888-enum-var-decl-jump.hpp
deleted file mode 100644
index fa4ba56b..00000000
--- a/tests/headers/issue-888-enum-var-decl-jump.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --rustified-enum ".*"
-
-namespace Halide {
-struct Type;
-}
-typedef enum {} a;
-namespace Halide {
-struct Type {
-  static a b;
-};
-}
diff --git a/tests/headers/issue-944-derive-copy-and-blocklisting.hpp b/tests/headers/issue-944-derive-copy-and-blocklisting.hpp
deleted file mode 100644
index 5e94dfab..00000000
--- a/tests/headers/issue-944-derive-copy-and-blocklisting.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --blocklist-type BlocklistMe --raw-line 'pub struct BlocklistMe(u8);'
-
-struct BlocklistMe {};
-
-/**
- * Because this type contains a blocklisted type, it should not derive Copy.
- */
-struct ShouldNotBeCopy {
-    BlocklistMe a;
-};
diff --git a/tests/headers/issue-946.h b/tests/headers/issue-946.h
deleted file mode 100644
index 5d145e09..00000000
--- a/tests/headers/issue-946.h
+++ /dev/null
@@ -1,5 +0,0 @@
-struct foo { };
-
-typedef struct foo bar;
-
-typedef bar foo;
diff --git a/tests/headers/issue_311.hpp b/tests/headers/issue_311.hpp
deleted file mode 100644
index a8d7fd99..00000000
--- a/tests/headers/issue_311.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-struct jsval_layout {
-  struct {};
-};
diff --git a/tests/headers/issue_315.hpp b/tests/headers/issue_315.hpp
deleted file mode 100644
index e58cb5e3..00000000
--- a/tests/headers/issue_315.hpp
+++ /dev/null
@@ -1,2 +0,0 @@
-/// <div rustbindgen replaces="c"></div>
-template <typename a> using b = a;
diff --git a/tests/headers/jsval_layout_opaque.hpp b/tests/headers/jsval_layout_opaque.hpp
deleted file mode 100644
index ef13b85b..00000000
--- a/tests/headers/jsval_layout_opaque.hpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-// bindgen-flags: -- -std=c++11
-
-/**
- * These typedefs are hacky, but keep our tests consistent across 64-bit
- * platforms, otherwise the id's change and our CI is unhappy.
- */
-typedef unsigned char uint8_t;
-typedef int int32_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-typedef unsigned long long size_t;
-typedef unsigned long long uintptr_t;
-
-
-#define JS_PUNBOX64
-#define IS_LITTLE_ENDIAN
-
-/*
- * Try to get jsvals 64-bit aligned. We could almost assert that all values are
- * aligned, but MSVC and GCC occasionally break alignment.
- */
-#if defined(__GNUC__) || defined(__xlc__) || defined(__xlC__)
-# define JSVAL_ALIGNMENT        __attribute__((aligned (8)))
-#elif defined(_MSC_VER)
-  /*
-   * Structs can be aligned with MSVC, but not if they are used as parameters,
-   * so we just don't try to align.
-   */
-# define JSVAL_ALIGNMENT
-#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# define JSVAL_ALIGNMENT
-#elif defined(__HP_cc) || defined(__HP_aCC)
-# define JSVAL_ALIGNMENT
-#endif
-
-#if defined(JS_PUNBOX64)
-# define JSVAL_TAG_SHIFT 47
-#endif
-
-/*
- * We try to use enums so that printing a jsval_layout in the debugger shows
- * nice symbolic type tags, however we can only do this when we can force the
- * underlying type of the enum to be the desired size.
- */
-#if !defined(__SUNPRO_CC) && !defined(__xlC__)
-
-#if defined(_MSC_VER)
-# define JS_ENUM_HEADER(id, type)              enum id : type
-# define JS_ENUM_FOOTER(id)
-#else
-# define JS_ENUM_HEADER(id, type)              enum id
-# define JS_ENUM_FOOTER(id)                    __attribute__((packed))
-#endif
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueType, uint8_t)
-{
-    JSVAL_TYPE_DOUBLE              = 0x00,
-    JSVAL_TYPE_INT32               = 0x01,
-    JSVAL_TYPE_UNDEFINED           = 0x02,
-    JSVAL_TYPE_BOOLEAN             = 0x03,
-    JSVAL_TYPE_MAGIC               = 0x04,
-    JSVAL_TYPE_STRING              = 0x05,
-    JSVAL_TYPE_SYMBOL              = 0x06,
-    JSVAL_TYPE_NULL                = 0x07,
-    JSVAL_TYPE_OBJECT              = 0x08,
-
-    /* These never appear in a jsval; they are only provided as an out-of-band value. */
-    JSVAL_TYPE_UNKNOWN             = 0x20,
-    JSVAL_TYPE_MISSING             = 0x21
-} JS_ENUM_FOOTER(JSValueType);
-
-static_assert(sizeof(JSValueType) == 1,
-              "compiler typed enum support is apparently buggy");
-
-#if defined(JS_NUNBOX32)
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueTag, uint32_t)
-{
-    JSVAL_TAG_CLEAR                = 0xFFFFFF80,
-    JSVAL_TAG_INT32                = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
-    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
-    JSVAL_TAG_STRING               = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
-    JSVAL_TAG_SYMBOL               = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
-    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
-    JSVAL_TAG_MAGIC                = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
-    JSVAL_TAG_NULL                 = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
-    JSVAL_TAG_OBJECT               = JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT
-} JS_ENUM_FOOTER(JSValueTag);
-
-static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
-              "compiler typed enum support is apparently buggy");
-
-#elif defined(JS_PUNBOX64)
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueTag, uint32_t)
-{
-    JSVAL_TAG_MAX_DOUBLE           = 0x1FFF0,
-    JSVAL_TAG_INT32                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
-    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
-    JSVAL_TAG_STRING               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
-    JSVAL_TAG_SYMBOL               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
-    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
-    JSVAL_TAG_MAGIC                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
-    JSVAL_TAG_NULL                 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
-    JSVAL_TAG_OBJECT               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
-} JS_ENUM_FOOTER(JSValueTag);
-
-static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
-              "compiler typed enum support is apparently buggy");
-
-JS_ENUM_HEADER(JSValueShiftedTag, uint64_t)
-{
-    JSVAL_SHIFTED_TAG_MAX_DOUBLE   = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
-    JSVAL_SHIFTED_TAG_INT32        = (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_UNDEFINED    = (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_STRING       = (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_SYMBOL       = (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_BOOLEAN      = (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_MAGIC        = (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_NULL         = (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_OBJECT       = (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
-} JS_ENUM_FOOTER(JSValueShiftedTag);
-
-static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
-              "compiler typed enum support is apparently buggy");
-
-#endif
-
-/*
- * All our supported compilers implement C++11 |enum Foo : T| syntax, so don't
- * expose these macros. (This macro exists *only* because gcc bug 51242
- * <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51242> makes bit-fields of
- * typed enums trigger a warning that can't be turned off. Don't expose it
- * beyond this file!)
- */
-#undef JS_ENUM_HEADER
-#undef JS_ENUM_FOOTER
-
-#else  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
-
-typedef uint8_t JSValueType;
-#define JSVAL_TYPE_DOUBLE            ((uint8_t)0x00)
-#define JSVAL_TYPE_INT32             ((uint8_t)0x01)
-#define JSVAL_TYPE_UNDEFINED         ((uint8_t)0x02)
-#define JSVAL_TYPE_BOOLEAN           ((uint8_t)0x03)
-#define JSVAL_TYPE_MAGIC             ((uint8_t)0x04)
-#define JSVAL_TYPE_STRING            ((uint8_t)0x05)
-#define JSVAL_TYPE_SYMBOL            ((uint8_t)0x06)
-#define JSVAL_TYPE_NULL              ((uint8_t)0x07)
-#define JSVAL_TYPE_OBJECT            ((uint8_t)0x08)
-#define JSVAL_TYPE_UNKNOWN           ((uint8_t)0x20)
-
-#if defined(JS_NUNBOX32)
-
-typedef uint32_t JSValueTag;
-#define JSVAL_TAG_CLEAR              ((uint32_t)(0xFFFFFF80))
-#define JSVAL_TAG_INT32              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32))
-#define JSVAL_TAG_UNDEFINED          ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED))
-#define JSVAL_TAG_STRING             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING))
-#define JSVAL_TAG_SYMBOL             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL))
-#define JSVAL_TAG_BOOLEAN            ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN))
-#define JSVAL_TAG_MAGIC              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC))
-#define JSVAL_TAG_NULL               ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL))
-#define JSVAL_TAG_OBJECT             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT))
-
-#elif defined(JS_PUNBOX64)
-
-typedef uint32_t JSValueTag;
-#define JSVAL_TAG_MAX_DOUBLE         ((uint32_t)(0x1FFF0))
-#define JSVAL_TAG_INT32              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32)
-#define JSVAL_TAG_UNDEFINED          (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED)
-#define JSVAL_TAG_STRING             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING)
-#define JSVAL_TAG_SYMBOL             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL)
-#define JSVAL_TAG_BOOLEAN            (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN)
-#define JSVAL_TAG_MAGIC              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC)
-#define JSVAL_TAG_NULL               (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL)
-#define JSVAL_TAG_OBJECT             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT)
-
-typedef uint64_t JSValueShiftedTag;
-#define JSVAL_SHIFTED_TAG_MAX_DOUBLE ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF)
-#define JSVAL_SHIFTED_TAG_INT32      (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_UNDEFINED  (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_STRING     (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_SYMBOL     (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_BOOLEAN    (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_MAGIC      (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_NULL       (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_OBJECT     (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
-
-#endif  /* JS_PUNBOX64 */
-#endif  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
-
-#if defined(JS_NUNBOX32)
-
-#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_CLEAR | (type)))
-
-#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
-#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
-#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
-#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
-
-#elif defined(JS_PUNBOX64)
-
-#define JSVAL_PAYLOAD_MASK           0x00007FFFFFFFFFFFLL
-#define JSVAL_TAG_MASK               0xFFFF800000000000LL
-#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_MAX_DOUBLE | (type)))
-#define JSVAL_TYPE_TO_SHIFTED_TAG(type) (((uint64_t)JSVAL_TYPE_TO_TAG(type)) << JSVAL_TAG_SHIFT)
-
-#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
-#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
-#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
-#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
-
-#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET  JSVAL_SHIFTED_TAG_NULL
-#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET    JSVAL_SHIFTED_TAG_OBJECT
-#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET       JSVAL_SHIFTED_TAG_UNDEFINED
-#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET      JSVAL_SHIFTED_TAG_STRING
-
-#endif /* JS_PUNBOX64 */
-
-typedef enum JSWhyMagic
-{
-    /** a hole in a native object's elements */
-    JS_ELEMENTS_HOLE,
-
-    /** there is not a pending iterator value */
-    JS_NO_ITER_VALUE,
-
-    /** exception value thrown when closing a generator */
-    JS_GENERATOR_CLOSING,
-
-    /** compiler sentinel value */
-    JS_NO_CONSTANT,
-
-    /** used in debug builds to catch tracing errors */
-    JS_THIS_POISON,
-
-    /** used in debug builds to catch tracing errors */
-    JS_ARG_POISON,
-
-    /** an empty subnode in the AST serializer */
-    JS_SERIALIZE_NO_NODE,
-
-    /** lazy arguments value on the stack */
-    JS_LAZY_ARGUMENTS,
-
-    /** optimized-away 'arguments' value */
-    JS_OPTIMIZED_ARGUMENTS,
-
-    /** magic value passed to natives to indicate construction */
-    JS_IS_CONSTRUCTING,
-
-    /** arguments.callee has been overwritten */
-    JS_OVERWRITTEN_CALLEE,
-
-    /** value of static block object slot */
-    JS_BLOCK_NEEDS_CLONE,
-
-    /** see class js::HashableValue */
-    JS_HASH_KEY_EMPTY,
-
-    /** error while running Ion code */
-    JS_ION_ERROR,
-
-    /** missing recover instruction result */
-    JS_ION_BAILOUT,
-
-    /** optimized out slot */
-    JS_OPTIMIZED_OUT,
-
-    /** uninitialized lexical bindings that produce ReferenceError on touch. */
-    JS_UNINITIALIZED_LEXICAL,
-
-    /** for local use */
-    JS_GENERIC_MAGIC,
-
-    JS_WHY_MAGIC_COUNT
-} JSWhyMagic;
-
-#if defined(IS_LITTLE_ENDIAN)
-# if defined(JS_NUNBOX32)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
-            JSString*      str;
-            JS::Symbol*    sym;
-            JSObject*      obj;
-            js::gc::Cell*  cell;
-            void*          ptr;
-            JSWhyMagic     why;
-            size_t         word;
-            uintptr_t      uintptr;
-        } payload;
-        JSValueTag tag;
-    } s;
-    double asDouble;
-    void* asPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# elif defined(JS_PUNBOX64)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-#if !defined(_WIN64)
-    /* MSVC does not pack these correctly :-( */
-    struct {
-        uint64_t           payload47 : 47;
-        JSValueTag         tag : 17;
-    } debugView;
-#endif
-    struct {
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            JSWhyMagic     why;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-    size_t asWord;
-    uintptr_t asUIntPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# endif  /* JS_PUNBOX64 */
-#else   /* defined(IS_LITTLE_ENDIAN) */
-# if defined(JS_NUNBOX32)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        JSValueTag tag;
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
-            JSString*      str;
-            JS::Symbol*    sym;
-            JSObject*      obj;
-            js::gc::Cell*  cell;
-            void*          ptr;
-            JSWhyMagic     why;
-            size_t         word;
-            uintptr_t      uintptr;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# elif defined(JS_PUNBOX64)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        JSValueTag         tag : 17;
-        uint64_t           payload47 : 47;
-    } debugView;
-    struct {
-        uint32_t           padding;
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            JSWhyMagic     why;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-    size_t asWord;
-    uintptr_t asUIntPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# endif /* JS_PUNBOX64 */
-#endif  /* defined(IS_LITTLE_ENDIAN) */
-
-/*
- * For codesize purposes on some platforms, it's important that the
- * compiler know that JS::Values constructed from constant values can be
- * folded to constant bit patterns at compile time, rather than
- * constructed at runtime.  Doing this requires a fair amount of C++11
- * features, which are not supported on all of our compilers.  Set up
- * some defines and helper macros in an attempt to confine the ugliness
- * here, rather than scattering it all about the file.  The important
- * features are:
- *
- * - constexpr;
- * - defaulted functions;
- * - C99-style designated initializers.
- */
-#if defined(__clang__)
-#  if __has_feature(cxx_constexpr) && __has_feature(cxx_defaulted_functions)
-#    define JS_VALUE_IS_CONSTEXPR
-#  endif
-#elif defined(__GNUC__)
-/*
- * We need 4.5 for defaulted functions, 4.6 for constexpr, 4.7 because 4.6
- * doesn't understand |(X) { .field = ... }| syntax, and 4.7.3 because
- * versions prior to that have bugs in the C++ front-end that cause crashes.
- */
-#  if MOZ_GCC_VERSION_AT_LEAST(4, 7, 3)
-#    define JS_VALUE_IS_CONSTEXPR
-#  endif
-#endif
-
-#if defined(JS_VALUE_IS_CONSTEXPR)
-#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
-    return (jsval_layout) { .asBits = (BITS) }
-#  define JS_VALUE_CONSTEXPR MOZ_CONSTEXPR
-#  define JS_VALUE_CONSTEXPR_VAR MOZ_CONSTEXPR_VAR
-#else
-#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
-    jsval_layout l;                        \
-    l.asBits = (BITS);                     \
-    return l;
-#  define JS_VALUE_CONSTEXPR
-#  define JS_VALUE_CONSTEXPR_VAR const
-#endif
-
-struct Value {
-    jsval_layout data;
-};
diff --git a/tests/headers/jsval_layout_opaque_1_0.hpp b/tests/headers/jsval_layout_opaque_1_0.hpp
deleted file mode 100644
index c8e66551..00000000
--- a/tests/headers/jsval_layout_opaque_1_0.hpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-// bindgen-flags: -- -std=c++11
-
-/**
- * These typedefs are hacky, but keep our tests consistent across 64-bit
- * platforms, otherwise the id's change and our CI is unhappy.
- */
-typedef unsigned char uint8_t;
-typedef int int32_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-typedef unsigned long long size_t;
-typedef unsigned long long uintptr_t;
-
-
-#define JS_PUNBOX64
-#define IS_LITTLE_ENDIAN
-
-/*
- * Try to get jsvals 64-bit aligned. We could almost assert that all values are
- * aligned, but MSVC and GCC occasionally break alignment.
- */
-#if defined(__GNUC__) || defined(__xlc__) || defined(__xlC__)
-# define JSVAL_ALIGNMENT        __attribute__((aligned (8)))
-#elif defined(_MSC_VER)
-  /*
-   * Structs can be aligned with MSVC, but not if they are used as parameters,
-   * so we just don't try to align.
-   */
-# define JSVAL_ALIGNMENT
-#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# define JSVAL_ALIGNMENT
-#elif defined(__HP_cc) || defined(__HP_aCC)
-# define JSVAL_ALIGNMENT
-#endif
-
-#if defined(JS_PUNBOX64)
-# define JSVAL_TAG_SHIFT 47
-#endif
-
-/*
- * We try to use enums so that printing a jsval_layout in the debugger shows
- * nice symbolic type tags, however we can only do this when we can force the
- * underlying type of the enum to be the desired size.
- */
-#if !defined(__SUNPRO_CC) && !defined(__xlC__)
-
-#if defined(_MSC_VER)
-# define JS_ENUM_HEADER(id, type)              enum id : type
-# define JS_ENUM_FOOTER(id)
-#else
-# define JS_ENUM_HEADER(id, type)              enum id
-# define JS_ENUM_FOOTER(id)                    __attribute__((packed))
-#endif
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueType, uint8_t)
-{
-    JSVAL_TYPE_DOUBLE              = 0x00,
-    JSVAL_TYPE_INT32               = 0x01,
-    JSVAL_TYPE_UNDEFINED           = 0x02,
-    JSVAL_TYPE_BOOLEAN             = 0x03,
-    JSVAL_TYPE_MAGIC               = 0x04,
-    JSVAL_TYPE_STRING              = 0x05,
-    JSVAL_TYPE_SYMBOL              = 0x06,
-    JSVAL_TYPE_NULL                = 0x07,
-    JSVAL_TYPE_OBJECT              = 0x08,
-
-    /* These never appear in a jsval; they are only provided as an out-of-band value. */
-    JSVAL_TYPE_UNKNOWN             = 0x20,
-    JSVAL_TYPE_MISSING             = 0x21
-} JS_ENUM_FOOTER(JSValueType);
-
-static_assert(sizeof(JSValueType) == 1,
-              "compiler typed enum support is apparently buggy");
-
-#if defined(JS_NUNBOX32)
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueTag, uint32_t)
-{
-    JSVAL_TAG_CLEAR                = 0xFFFFFF80,
-    JSVAL_TAG_INT32                = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
-    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
-    JSVAL_TAG_STRING               = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
-    JSVAL_TAG_SYMBOL               = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
-    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
-    JSVAL_TAG_MAGIC                = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
-    JSVAL_TAG_NULL                 = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
-    JSVAL_TAG_OBJECT               = JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT
-} JS_ENUM_FOOTER(JSValueTag);
-
-static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
-              "compiler typed enum support is apparently buggy");
-
-#elif defined(JS_PUNBOX64)
-
-/* Remember to propagate changes to the C defines below. */
-JS_ENUM_HEADER(JSValueTag, uint32_t)
-{
-    JSVAL_TAG_MAX_DOUBLE           = 0x1FFF0,
-    JSVAL_TAG_INT32                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
-    JSVAL_TAG_UNDEFINED            = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
-    JSVAL_TAG_STRING               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
-    JSVAL_TAG_SYMBOL               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
-    JSVAL_TAG_BOOLEAN              = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
-    JSVAL_TAG_MAGIC                = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
-    JSVAL_TAG_NULL                 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
-    JSVAL_TAG_OBJECT               = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
-} JS_ENUM_FOOTER(JSValueTag);
-
-static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
-              "compiler typed enum support is apparently buggy");
-
-JS_ENUM_HEADER(JSValueShiftedTag, uint64_t)
-{
-    JSVAL_SHIFTED_TAG_MAX_DOUBLE   = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
-    JSVAL_SHIFTED_TAG_INT32        = (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_UNDEFINED    = (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_STRING       = (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_SYMBOL       = (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_BOOLEAN      = (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_MAGIC        = (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_NULL         = (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT),
-    JSVAL_SHIFTED_TAG_OBJECT       = (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
-} JS_ENUM_FOOTER(JSValueShiftedTag);
-
-static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
-              "compiler typed enum support is apparently buggy");
-
-#endif
-
-/*
- * All our supported compilers implement C++11 |enum Foo : T| syntax, so don't
- * expose these macros. (This macro exists *only* because gcc bug 51242
- * <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51242> makes bit-fields of
- * typed enums trigger a warning that can't be turned off. Don't expose it
- * beyond this file!)
- */
-#undef JS_ENUM_HEADER
-#undef JS_ENUM_FOOTER
-
-#else  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
-
-typedef uint8_t JSValueType;
-#define JSVAL_TYPE_DOUBLE            ((uint8_t)0x00)
-#define JSVAL_TYPE_INT32             ((uint8_t)0x01)
-#define JSVAL_TYPE_UNDEFINED         ((uint8_t)0x02)
-#define JSVAL_TYPE_BOOLEAN           ((uint8_t)0x03)
-#define JSVAL_TYPE_MAGIC             ((uint8_t)0x04)
-#define JSVAL_TYPE_STRING            ((uint8_t)0x05)
-#define JSVAL_TYPE_SYMBOL            ((uint8_t)0x06)
-#define JSVAL_TYPE_NULL              ((uint8_t)0x07)
-#define JSVAL_TYPE_OBJECT            ((uint8_t)0x08)
-#define JSVAL_TYPE_UNKNOWN           ((uint8_t)0x20)
-
-#if defined(JS_NUNBOX32)
-
-typedef uint32_t JSValueTag;
-#define JSVAL_TAG_CLEAR              ((uint32_t)(0xFFFFFF80))
-#define JSVAL_TAG_INT32              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32))
-#define JSVAL_TAG_UNDEFINED          ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED))
-#define JSVAL_TAG_STRING             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING))
-#define JSVAL_TAG_SYMBOL             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL))
-#define JSVAL_TAG_BOOLEAN            ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN))
-#define JSVAL_TAG_MAGIC              ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC))
-#define JSVAL_TAG_NULL               ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL))
-#define JSVAL_TAG_OBJECT             ((uint32_t)(JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT))
-
-#elif defined(JS_PUNBOX64)
-
-typedef uint32_t JSValueTag;
-#define JSVAL_TAG_MAX_DOUBLE         ((uint32_t)(0x1FFF0))
-#define JSVAL_TAG_INT32              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32)
-#define JSVAL_TAG_UNDEFINED          (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED)
-#define JSVAL_TAG_STRING             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING)
-#define JSVAL_TAG_SYMBOL             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL)
-#define JSVAL_TAG_BOOLEAN            (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN)
-#define JSVAL_TAG_MAGIC              (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC)
-#define JSVAL_TAG_NULL               (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL)
-#define JSVAL_TAG_OBJECT             (uint32_t)(JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT)
-
-typedef uint64_t JSValueShiftedTag;
-#define JSVAL_SHIFTED_TAG_MAX_DOUBLE ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF)
-#define JSVAL_SHIFTED_TAG_INT32      (((uint64_t)JSVAL_TAG_INT32)      << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_UNDEFINED  (((uint64_t)JSVAL_TAG_UNDEFINED)  << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_STRING     (((uint64_t)JSVAL_TAG_STRING)     << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_SYMBOL     (((uint64_t)JSVAL_TAG_SYMBOL)     << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_BOOLEAN    (((uint64_t)JSVAL_TAG_BOOLEAN)    << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_MAGIC      (((uint64_t)JSVAL_TAG_MAGIC)      << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_NULL       (((uint64_t)JSVAL_TAG_NULL)       << JSVAL_TAG_SHIFT)
-#define JSVAL_SHIFTED_TAG_OBJECT     (((uint64_t)JSVAL_TAG_OBJECT)     << JSVAL_TAG_SHIFT)
-
-#endif  /* JS_PUNBOX64 */
-#endif  /* !defined(__SUNPRO_CC) && !defined(__xlC__) */
-
-#if defined(JS_NUNBOX32)
-
-#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_CLEAR | (type)))
-
-#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
-#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
-#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
-#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
-
-#elif defined(JS_PUNBOX64)
-
-#define JSVAL_PAYLOAD_MASK           0x00007FFFFFFFFFFFLL
-#define JSVAL_TAG_MASK               0xFFFF800000000000LL
-#define JSVAL_TYPE_TO_TAG(type)      ((JSValueTag)(JSVAL_TAG_MAX_DOUBLE | (type)))
-#define JSVAL_TYPE_TO_SHIFTED_TAG(type) (((uint64_t)JSVAL_TYPE_TO_TAG(type)) << JSVAL_TAG_SHIFT)
-
-#define JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET         JSVAL_TAG_NULL
-#define JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET           JSVAL_TAG_OBJECT
-#define JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET              JSVAL_TAG_INT32
-#define JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET             JSVAL_TAG_STRING
-
-#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET  JSVAL_SHIFTED_TAG_NULL
-#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET    JSVAL_SHIFTED_TAG_OBJECT
-#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET       JSVAL_SHIFTED_TAG_UNDEFINED
-#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET      JSVAL_SHIFTED_TAG_STRING
-
-#endif /* JS_PUNBOX64 */
-
-typedef enum JSWhyMagic
-{
-    /** a hole in a native object's elements */
-    JS_ELEMENTS_HOLE,
-
-    /** there is not a pending iterator value */
-    JS_NO_ITER_VALUE,
-
-    /** exception value thrown when closing a generator */
-    JS_GENERATOR_CLOSING,
-
-    /** compiler sentinel value */
-    JS_NO_CONSTANT,
-
-    /** used in debug builds to catch tracing errors */
-    JS_THIS_POISON,
-
-    /** used in debug builds to catch tracing errors */
-    JS_ARG_POISON,
-
-    /** an empty subnode in the AST serializer */
-    JS_SERIALIZE_NO_NODE,
-
-    /** lazy arguments value on the stack */
-    JS_LAZY_ARGUMENTS,
-
-    /** optimized-away 'arguments' value */
-    JS_OPTIMIZED_ARGUMENTS,
-
-    /** magic value passed to natives to indicate construction */
-    JS_IS_CONSTRUCTING,
-
-    /** arguments.callee has been overwritten */
-    JS_OVERWRITTEN_CALLEE,
-
-    /** value of static block object slot */
-    JS_BLOCK_NEEDS_CLONE,
-
-    /** see class js::HashableValue */
-    JS_HASH_KEY_EMPTY,
-
-    /** error while running Ion code */
-    JS_ION_ERROR,
-
-    /** missing recover instruction result */
-    JS_ION_BAILOUT,
-
-    /** optimized out slot */
-    JS_OPTIMIZED_OUT,
-
-    /** uninitialized lexical bindings that produce ReferenceError on touch. */
-    JS_UNINITIALIZED_LEXICAL,
-
-    /** for local use */
-    JS_GENERIC_MAGIC,
-
-    JS_WHY_MAGIC_COUNT
-} JSWhyMagic;
-
-#if defined(IS_LITTLE_ENDIAN)
-# if defined(JS_NUNBOX32)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
-            JSString*      str;
-            JS::Symbol*    sym;
-            JSObject*      obj;
-            js::gc::Cell*  cell;
-            void*          ptr;
-            JSWhyMagic     why;
-            size_t         word;
-            uintptr_t      uintptr;
-        } payload;
-        JSValueTag tag;
-    } s;
-    double asDouble;
-    void* asPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# elif defined(JS_PUNBOX64)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-#if !defined(_WIN64)
-    /* MSVC does not pack these correctly :-( */
-    struct {
-        uint64_t           payload47 : 47;
-        JSValueTag         tag : 17;
-    } debugView;
-#endif
-    struct {
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            JSWhyMagic     why;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-    size_t asWord;
-    uintptr_t asUIntPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# endif  /* JS_PUNBOX64 */
-#else   /* defined(IS_LITTLE_ENDIAN) */
-# if defined(JS_NUNBOX32)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        JSValueTag tag;
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            uint32_t       boo;     // Don't use |bool| -- it must be four bytes.
-            JSString*      str;
-            JS::Symbol*    sym;
-            JSObject*      obj;
-            js::gc::Cell*  cell;
-            void*          ptr;
-            JSWhyMagic     why;
-            size_t         word;
-            uintptr_t      uintptr;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# elif defined(JS_PUNBOX64)
-typedef union jsval_layout
-{
-    uint64_t asBits;
-    struct {
-        JSValueTag         tag : 17;
-        uint64_t           payload47 : 47;
-    } debugView;
-    struct {
-        uint32_t           padding;
-        union {
-            int32_t        i32;
-            uint32_t       u32;
-            JSWhyMagic     why;
-        } payload;
-    } s;
-    double asDouble;
-    void* asPtr;
-    size_t asWord;
-    uintptr_t asUIntPtr;
-} JSVAL_ALIGNMENT jsval_layout;
-# endif /* JS_PUNBOX64 */
-#endif  /* defined(IS_LITTLE_ENDIAN) */
-
-/*
- * For codesize purposes on some platforms, it's important that the
- * compiler know that JS::Values constructed from constant values can be
- * folded to constant bit patterns at compile time, rather than
- * constructed at runtime.  Doing this requires a fair amount of C++11
- * features, which are not supported on all of our compilers.  Set up
- * some defines and helper macros in an attempt to confine the ugliness
- * here, rather than scattering it all about the file.  The important
- * features are:
- *
- * - constexpr;
- * - defaulted functions;
- * - C99-style designated initializers.
- */
-#if defined(__clang__)
-#  if __has_feature(cxx_constexpr) && __has_feature(cxx_defaulted_functions)
-#    define JS_VALUE_IS_CONSTEXPR
-#  endif
-#elif defined(__GNUC__)
-/*
- * We need 4.5 for defaulted functions, 4.6 for constexpr, 4.7 because 4.6
- * doesn't understand |(X) { .field = ... }| syntax, and 4.7.3 because
- * versions prior to that have bugs in the C++ front-end that cause crashes.
- */
-#  if MOZ_GCC_VERSION_AT_LEAST(4, 7, 3)
-#    define JS_VALUE_IS_CONSTEXPR
-#  endif
-#endif
-
-#if defined(JS_VALUE_IS_CONSTEXPR)
-#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
-    return (jsval_layout) { .asBits = (BITS) }
-#  define JS_VALUE_CONSTEXPR MOZ_CONSTEXPR
-#  define JS_VALUE_CONSTEXPR_VAR MOZ_CONSTEXPR_VAR
-#else
-#  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
-    jsval_layout l;                        \
-    l.asBits = (BITS);                     \
-    return l;
-#  define JS_VALUE_CONSTEXPR
-#  define JS_VALUE_CONSTEXPR_VAR const
-#endif
-
-struct Value {
-    jsval_layout data;
-};
diff --git a/tests/headers/keywords.h b/tests/headers/keywords.h
deleted file mode 100644
index 3b3fc497..00000000
--- a/tests/headers/keywords.h
+++ /dev/null
@@ -1,56 +0,0 @@
-int u8;
-int u16;
-int u32;
-int u64;
-int i8;
-int i16;
-int i32;
-int i64;
-int f32;
-int f64;
-int usize;
-int isize;
-int bool;
-int str;
-int dyn;
-
-int as;
-int async;
-int await;
-int box;
-int crate;
-int false;
-int fn;
-int impl;
-int in;
-int let;
-int loop;
-int match;
-int mod;
-int move;
-int mut;
-int pub;
-int ref;
-int self;
-int Self;
-int super;
-int trait;
-int true;
-int try;
-int type;
-int unsafe;
-int use;
-int where;
-int abstract;
-int alignof;
-int become;
-int final;
-int macro;
-int offsetof;
-int override;
-int priv;
-int proc;
-int pure;
-int unsized;
-int virtual;
-int yield;
diff --git a/tests/headers/layout.h b/tests/headers/layout.h
deleted file mode 100644
index b290ee85..00000000
--- a/tests/headers/layout.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rust-target 1.21
-//
-// FIXME: https://github.com/rust-lang/rust-bindgen/issues/1498
-
-struct header
-{
-    char proto;
-    unsigned int size __attribute__ ((packed));
-    unsigned char data[] __attribute__ ((aligned(8)));
-} __attribute__ ((aligned, packed));
diff --git a/tests/headers/layout_align.h b/tests/headers/layout_align.h
deleted file mode 100644
index 0201877e..00000000
--- a/tests/headers/layout_align.h
+++ /dev/null
@@ -1,20 +0,0 @@
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-struct rte_kni_fifo {
-	volatile unsigned write;     /**< Next position to be written*/
-	volatile unsigned read;      /**< Next position to be read */
-	unsigned len;                /**< Circular buffer length */
-	unsigned elem_size;          /**< Pointer size - for 32/64 bit OS */
-	void *volatile buffer[];     /**< The buffer contains mbuf pointers */
-};
-
-__extension__
-struct rte_eth_link {
-	uint32_t link_speed;        /**< ETH_SPEED_NUM_ */
-	uint16_t link_duplex  : 1;  /**< ETH_LINK_[HALF/FULL]_DUPLEX */
-	uint16_t link_autoneg : 1;  /**< ETH_LINK_SPEED_[AUTONEG/FIXED] */
-	uint16_t link_status  : 1;  /**< ETH_LINK_[DOWN/UP] */
-} __attribute__((aligned(8)));      /**< aligned for atomic64 read/write */
\ No newline at end of file
diff --git a/tests/headers/layout_arp.h b/tests/headers/layout_arp.h
deleted file mode 100644
index 8682cbe0..00000000
--- a/tests/headers/layout_arp.h
+++ /dev/null
@@ -1,52 +0,0 @@
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-#define ETHER_ADDR_LEN  6 /**< Length of Ethernet address. */
-
-/**
- * Ethernet address:
- * A universally administered address is uniquely assigned to a device by its
- * manufacturer. The first three octets (in transmission order) contain the
- * Organizationally Unique Identifier (OUI). The following three (MAC-48 and
- * EUI-48) octets are assigned by that organization with the only constraint
- * of uniqueness.
- * A locally administered address is assigned to a device by a network
- * administrator and does not contain OUIs.
- * See http://standards.ieee.org/regauth/groupmac/tutorial.html
- */
-struct ether_addr {
-	uint8_t addr_bytes[ETHER_ADDR_LEN]; /**< Addr bytes in tx order */
-} __attribute__((__packed__));
-
-/**
- * ARP header IPv4 payload.
- */
-struct arp_ipv4 {
-	struct ether_addr arp_sha;  /**< sender hardware address */
-	uint32_t          arp_sip;  /**< sender IP address */
-	struct ether_addr arp_tha;  /**< target hardware address */
-	uint32_t          arp_tip;  /**< target IP address */
-} __attribute__((__packed__));
-
-/**
- * ARP header.
- */
-struct arp_hdr {
-	uint16_t arp_hrd;    /* format of hardware address */
-#define ARP_HRD_ETHER     1  /* ARP Ethernet address format */
-
-	uint16_t arp_pro;    /* format of protocol address */
-	uint8_t  arp_hln;    /* length of hardware address */
-	uint8_t  arp_pln;    /* length of protocol address */
-	uint16_t arp_op;     /* ARP opcode (command) */
-#define	ARP_OP_REQUEST    1 /* request to resolve address */
-#define	ARP_OP_REPLY      2 /* response to previous request */
-#define	ARP_OP_REVREQUEST 3 /* request proto addr given hardware */
-#define	ARP_OP_REVREPLY   4 /* response giving protocol address */
-#define	ARP_OP_INVREQUEST 8 /* request to identify peer */
-#define	ARP_OP_INVREPLY   9 /* response identifying peer */
-
-	struct arp_ipv4 arp_data;
-} __attribute__((__packed__));
\ No newline at end of file
diff --git a/tests/headers/layout_array.h b/tests/headers/layout_array.h
deleted file mode 100644
index e6a57f7c..00000000
--- a/tests/headers/layout_array.h
+++ /dev/null
@@ -1,110 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rust-target 1.40
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-typedef long long size_t;
-
-#define RTE_CACHE_LINE_SIZE 64
-
-/**
- * Force alignment
- */
-#define __rte_aligned(a) __attribute__((__aligned__(a)))
-
-/**
- * Force alignment to cache line.
- */
-#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
-
-#define RTE_MEMPOOL_OPS_NAMESIZE 32 /**< Max length of ops struct name. */
-
-/**
- * Prototype for implementation specific data provisioning function.
- *
- * The function should provide the implementation specific memory for
- * for use by the other mempool ops functions in a given mempool ops struct.
- * E.g. the default ops provides an instance of the rte_ring for this purpose.
- * it will most likely point to a different type of data structure, and
- * will be transparent to the application programmer.
- * This function should set mp->pool_data.
- */
-typedef int (*rte_mempool_alloc_t)(struct rte_mempool *mp);
-
-/**
- * Free the opaque private data pointed to by mp->pool_data pointer.
- */
-typedef void (*rte_mempool_free_t)(struct rte_mempool *mp);
-
-/**
- * Enqueue an object into the external pool.
- */
-typedef int (*rte_mempool_enqueue_t)(struct rte_mempool *mp,
-		void * const *obj_table, unsigned int n);
-
-/**
- * Dequeue an object from the external pool.
- */
-typedef int (*rte_mempool_dequeue_t)(struct rte_mempool *mp,
-		void **obj_table, unsigned int n);
-
-/**
- * Return the number of available objects in the external pool.
- */
-typedef unsigned (*rte_mempool_get_count)(const struct rte_mempool *mp);
-/** Structure defining mempool operations structure */
-struct rte_mempool_ops {
-	char name[RTE_MEMPOOL_OPS_NAMESIZE]; /**< Name of mempool ops struct. */
-	rte_mempool_alloc_t alloc;       /**< Allocate private data. */
-	rte_mempool_free_t free;         /**< Free the external pool. */
-	rte_mempool_enqueue_t enqueue;   /**< Enqueue an object. */
-	rte_mempool_dequeue_t dequeue;   /**< Dequeue an object. */
-	rte_mempool_get_count get_count; /**< Get qty of available objs. */
-} __rte_cache_aligned;
-
-#define RTE_MEMPOOL_MAX_OPS_IDX 16  /**< Max registered ops structs */
-
-/**
- * The rte_spinlock_t type.
- */
-typedef struct {
-	volatile int locked; /**< lock status 0 = unlocked, 1 = locked */
-} rte_spinlock_t;
-
-/**
- * Structure storing the table of registered ops structs, each of which contain
- * the function pointers for the mempool ops functions.
- * Each process has its own storage for this ops struct array so that
- * the mempools can be shared across primary and secondary processes.
- * The indices used to access the array are valid across processes, whereas
- * any function pointers stored directly in the mempool struct would not be.
- * This results in us simply having "ops_index" in the mempool struct.
- */
-struct rte_mempool_ops_table {
-	rte_spinlock_t sl;     /**< Spinlock for add/delete. */
-	uint32_t num_ops;      /**< Number of used ops structs in the table. */
-	/**
-	 * Storage for all possible ops structs.
-	 */
-	struct rte_mempool_ops ops[RTE_MEMPOOL_MAX_OPS_IDX];
-} __rte_cache_aligned;
-
-
-/* Number of free lists per heap, grouped by size. */
-#define RTE_HEAP_NUM_FREELISTS  13
-
-#define LIST_HEAD(name, type)                                           \
-struct name {                                                           \
-		struct type *lh_first;  /* first element */                     \
-}
-
-/**
- * Structure to hold malloc heap
- */
-struct malloc_heap {
-	rte_spinlock_t lock;
-	LIST_HEAD(, malloc_elem) free_head[RTE_HEAP_NUM_FREELISTS];
-	unsigned alloc_count;
-	size_t total_size;
-} __rte_cache_aligned;
diff --git a/tests/headers/layout_array_too_long.h b/tests/headers/layout_array_too_long.h
deleted file mode 100644
index 53e4d8be..00000000
--- a/tests/headers/layout_array_too_long.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq --rustified-enum ".*" --rust-target 1.40
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-#define RTE_CACHE_LINE_SIZE 64
-
-/**
- * Force alignment
- */
-#define __rte_aligned(a) __attribute__((__aligned__(a)))
-
-/**
- * Force alignment to cache line.
- */
-#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
-
-#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4
-
-enum {
-	IP_LAST_FRAG_IDX,    /**< index of last fragment */
-	IP_FIRST_FRAG_IDX,   /**< index of first fragment */
-	IP_MIN_FRAG_NUM,     /**< minimum number of fragments */
-	IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG,
-	/**< maximum number of fragments per packet */
-};
-
-/** @internal fragmented mbuf */
-struct ip_frag {
-	uint16_t ofs;          /**< offset into the packet */
-	uint16_t len;          /**< length of fragment */
-	struct rte_mbuf *mb;   /**< fragment mbuf */
-};
-
-/** @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. */
-struct ip_frag_key {
-	uint64_t src_dst[4];      /**< src address, first 8 bytes used for IPv4 */
-	uint32_t id;           /**< dst address */
-	uint32_t key_len;      /**< src/dst key length */
-};
-
-#define	TAILQ_ENTRY(type)						                    \
-struct {								                            \
-	struct type *tqe_next;	/* next element */			            \
-	struct type **tqe_prev;	/* address of previous next element */	\
-}
-
-/**
- * @internal Fragmented packet to reassemble.
- * First two entries in the frags[] array are for the last and first fragments.
- */
-struct ip_frag_pkt {
-	TAILQ_ENTRY(ip_frag_pkt) lru;   /**< LRU list */
-	struct ip_frag_key key;           /**< fragmentation key */
-	uint64_t             start;       /**< creation timestamp */
-	uint32_t             total_size;  /**< expected reassembled size */
-	uint32_t             frag_size;   /**< size of fragments received */
-	uint32_t             last_idx;    /**< index of next entry to fill */
-	struct ip_frag       frags[IP_MAX_FRAG_NUM]; /**< fragments */
-} __rte_cache_aligned;
diff --git a/tests/headers/layout_cmdline_token.h b/tests/headers/layout_cmdline_token.h
deleted file mode 100644
index da1bfc2e..00000000
--- a/tests/headers/layout_cmdline_token.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-/**
- * Stores a pointer to the ops struct, and the offset: the place to
- * write the parsed result in the destination structure.
- */
-struct cmdline_token_hdr {
-	struct cmdline_token_ops *ops;
-	unsigned int offset;
-};
-typedef struct cmdline_token_hdr cmdline_parse_token_hdr_t;
-
-/**
- * A token is defined by this structure.
- *
- * parse() takes the token as first argument, then the source buffer
- * starting at the token we want to parse. The 3rd arg is a pointer
- * where we store the parsed data (as binary). It returns the number of
- * parsed chars on success and a negative value on error.
- *
- * complete_get_nb() returns the number of possible values for this
- * token if completion is possible. If it is NULL or if it returns 0,
- * no completion is possible.
- *
- * complete_get_elt() copy in dstbuf (the size is specified in the
- * parameter) the i-th possible completion for this token.  returns 0
- * on success or and a negative value on error.
- *
- * get_help() fills the dstbuf with the help for the token. It returns
- * -1 on error and 0 on success.
- */
-struct cmdline_token_ops {
-	/** parse(token ptr, buf, res pts, buf len) */
-	int (*parse)(cmdline_parse_token_hdr_t *, const char *, void *,
-		unsigned int);
-	/** return the num of possible choices for this token */
-	int (*complete_get_nb)(cmdline_parse_token_hdr_t *);
-	/** return the elt x for this token (token, idx, dstbuf, size) */
-	int (*complete_get_elt)(cmdline_parse_token_hdr_t *, int, char *,
-		unsigned int);
-	/** get help for this token (token, dstbuf, size) */
-	int (*get_help)(cmdline_parse_token_hdr_t *, char *, unsigned int);
-};
-
-enum cmdline_numtype {
-	UINT8 = 0,
-	UINT16,
-	UINT32,
-	UINT64,
-	INT8,
-	INT16,
-	INT32,
-	INT64
-};
-
-struct cmdline_token_num_data {
-	enum cmdline_numtype type;
-};
-
-struct cmdline_token_num {
-	struct cmdline_token_hdr hdr;
-	struct cmdline_token_num_data num_data;
-};
-typedef struct cmdline_token_num cmdline_parse_token_num_t;
diff --git a/tests/headers/layout_eth_conf.h b/tests/headers/layout_eth_conf.h
deleted file mode 100644
index 9446bffb..00000000
--- a/tests/headers/layout_eth_conf.h
+++ /dev/null
@@ -1,428 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*" --rust-target 1.40
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-/**
- *  Simple flags are used for rte_eth_conf.rxmode.mq_mode.
- */
-#define ETH_MQ_RX_RSS_FLAG  0x1
-#define ETH_MQ_RX_DCB_FLAG  0x2
-#define ETH_MQ_RX_VMDQ_FLAG 0x4
-
-/* Definitions used for VMDQ and DCB functionality */
-#define ETH_VMDQ_MAX_VLAN_FILTERS   64 /**< Maximum nb. of VMDQ vlan filters. */
-#define ETH_DCB_NUM_USER_PRIORITIES 8  /**< Maximum nb. of DCB priorities. */
-#define ETH_VMDQ_DCB_NUM_QUEUES     128 /**< Maximum nb. of VMDQ DCB queues. */
-#define ETH_DCB_NUM_QUEUES          128 /**< Maximum nb. of DCB queues. */
-
-/**
- *  A set of values to identify what method is to be used to route
- *  packets to multiple queues.
- */
-enum rte_eth_rx_mq_mode {
-	/** None of DCB,RSS or VMDQ mode */
-	ETH_MQ_RX_NONE = 0,
-
-	/** For RX side, only RSS is on */
-	ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG,
-	/** For RX side,only DCB is on. */
-	ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG,
-	/** Both DCB and RSS enable */
-	ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG,
-
-	/** Only VMDQ, no RSS nor DCB */
-	ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG,
-	/** RSS mode with VMDQ */
-	ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG,
-	/** Use VMDQ+DCB to route traffic to queues */
-	ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG,
-	/** Enable both VMDQ and DCB in VMDq */
-	ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG |
-				 ETH_MQ_RX_VMDQ_FLAG,
-};
-
-/**
- * A structure used to configure the RX features of an Ethernet port.
- */
-struct rte_eth_rxmode {
-	/** The multi-queue packet distribution mode to be used, e.g. RSS. */
-	enum rte_eth_rx_mq_mode mq_mode;
-	uint32_t max_rx_pkt_len;  /**< Only used if jumbo_frame enabled. */
-	uint16_t split_hdr_size;  /**< hdr buf size (header_split enabled).*/
-	__extension__
-	uint16_t header_split : 1, /**< Header Split enable. */
-		hw_ip_checksum   : 1, /**< IP/UDP/TCP checksum offload enable. */
-		hw_vlan_filter   : 1, /**< VLAN filter enable. */
-		hw_vlan_strip    : 1, /**< VLAN strip enable. */
-		hw_vlan_extend   : 1, /**< Extended VLAN enable. */
-		jumbo_frame      : 1, /**< Jumbo Frame Receipt enable. */
-		hw_strip_crc     : 1, /**< Enable CRC stripping by hardware. */
-		enable_scatter   : 1, /**< Enable scatter packets rx handler */
-		enable_lro       : 1; /**< Enable LRO */
-};
-
-/**
- * A set of values to identify what method is to be used to transmit
- * packets using multi-TCs.
- */
-enum rte_eth_tx_mq_mode {
-	ETH_MQ_TX_NONE    = 0,  /**< It is in neither DCB nor VT mode. */
-	ETH_MQ_TX_DCB,          /**< For TX side,only DCB is on. */
-	ETH_MQ_TX_VMDQ_DCB,	/**< For TX side,both DCB and VT is on. */
-	ETH_MQ_TX_VMDQ_ONLY,    /**< Only VT on, no DCB */
-};
-
-/**
- * A structure used to configure the TX features of an Ethernet port.
- */
-struct rte_eth_txmode {
-	enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */
-
-	/* For i40e specifically */
-	uint16_t pvid;
-	__extension__
-	uint8_t hw_vlan_reject_tagged : 1,
-		/**< If set, reject sending out tagged pkts */
-		hw_vlan_reject_untagged : 1,
-		/**< If set, reject sending out untagged pkts */
-		hw_vlan_insert_pvid : 1;
-		/**< If set, enable port based VLAN insertion */
-};
-
-/**
- * A structure used to configure the Receive Side Scaling (RSS) feature
- * of an Ethernet port.
- * If not NULL, the *rss_key* pointer of the *rss_conf* structure points
- * to an array holding the RSS key to use for hashing specific header
- * fields of received packets. The length of this array should be indicated
- * by *rss_key_len* below. Otherwise, a default random hash key is used by
- * the device driver.
- *
- * The *rss_key_len* field of the *rss_conf* structure indicates the length
- * in bytes of the array pointed by *rss_key*. To be compatible, this length
- * will be checked in i40e only. Others assume 40 bytes to be used as before.
- *
- * The *rss_hf* field of the *rss_conf* structure indicates the different
- * types of IPv4/IPv6 packets to which the RSS hashing must be applied.
- * Supplying an *rss_hf* equal to zero disables the RSS feature.
- */
-struct rte_eth_rss_conf {
-	uint8_t *rss_key;    /**< If not NULL, 40-byte hash key. */
-	uint8_t rss_key_len; /**< hash key length in bytes. */
-	uint64_t rss_hf;     /**< Hash functions to apply - see below. */
-};
-
-/**
- * This enum indicates the possible number of traffic classes
- * in DCB configratioins
- */
-enum rte_eth_nb_tcs {
-	ETH_4_TCS = 4, /**< 4 TCs with DCB. */
-	ETH_8_TCS = 8  /**< 8 TCs with DCB. */
-};
-
-/**
- * This enum indicates the possible number of queue pools
- * in VMDQ configurations.
- */
-enum rte_eth_nb_pools {
-	ETH_8_POOLS = 8,    /**< 8 VMDq pools. */
-	ETH_16_POOLS = 16,  /**< 16 VMDq pools. */
-	ETH_32_POOLS = 32,  /**< 32 VMDq pools. */
-	ETH_64_POOLS = 64   /**< 64 VMDq pools. */
-};
-
-/**
- * A structure used to configure the VMDQ+DCB feature
- * of an Ethernet port.
- *
- * Using this feature, packets are routed to a pool of queues, based
- * on the vlan id in the vlan tag, and then to a specific queue within
- * that pool, using the user priority vlan tag field.
- *
- * A default pool may be used, if desired, to route all traffic which
- * does not match the vlan filter rules.
- */
-struct rte_eth_vmdq_dcb_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */
-	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
-	uint8_t default_pool; /**< The default pool, if applicable */
-	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
-	struct {
-		uint16_t vlan_id; /**< The vlan id of the received frame */
-		uint64_t pools;   /**< Bitmask of pools for packet rx */
-	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-	/**< Selects a queue in a pool */
-};
-
-/* This structure may be extended in future. */
-struct rte_eth_dcb_rx_conf {
-	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_vmdq_dcb_tx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_dcb_tx_conf {
-	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs. */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_vmdq_tx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq mode, 64 pools. */
-};
-
-struct rte_eth_vmdq_rx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq only mode, 8 or 64 pools */
-	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
-	uint8_t default_pool; /**< The default pool, if applicable */
-	uint8_t enable_loop_back; /**< Enable VT loop back */
-	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
-	uint32_t rx_mode; /**< Flags from ETH_VMDQ_ACCEPT_* */
-	struct {
-		uint16_t vlan_id; /**< The vlan id of the received frame */
-		uint64_t pools;   /**< Bitmask of pools for packet rx */
-	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
-};
-
-/**
- *  Flow Director setting modes: none, signature or perfect.
- */
-enum rte_fdir_mode {
-	RTE_FDIR_MODE_NONE      = 0, /**< Disable FDIR support. */
-	RTE_FDIR_MODE_SIGNATURE,     /**< Enable FDIR signature filter mode. */
-	RTE_FDIR_MODE_PERFECT,       /**< Enable FDIR perfect filter mode. */
-	RTE_FDIR_MODE_PERFECT_MAC_VLAN, /**< Enable FDIR filter mode - MAC VLAN. */
-	RTE_FDIR_MODE_PERFECT_TUNNEL,   /**< Enable FDIR filter mode - tunnel. */
-};
-
-/**
- *  Memory space that can be configured to store Flow Director filters
- *  in the board memory.
- */
-enum rte_fdir_pballoc_type {
-	RTE_FDIR_PBALLOC_64K = 0,  /**< 64k. */
-	RTE_FDIR_PBALLOC_128K,     /**< 128k. */
-	RTE_FDIR_PBALLOC_256K,     /**< 256k. */
-};
-
-/**
- *  Select report mode of FDIR hash information in RX descriptors.
- */
-enum rte_fdir_status_mode {
-	RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */
-	RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */
-	RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */
-};
-
-/**
- * A structure used to define the input for IPV4 flow
- */
-struct rte_eth_ipv4_flow {
-	uint32_t src_ip;      /**< IPv4 source address in big endian. */
-	uint32_t dst_ip;      /**< IPv4 destination address in big endian. */
-	uint8_t  tos;         /**< Type of service to match. */
-	uint8_t  ttl;         /**< Time to live to match. */
-	uint8_t  proto;       /**< Protocol, next header in big endian. */
-};
-
-/**
- * A structure used to define the input for IPV6 flow
- */
-struct rte_eth_ipv6_flow {
-	uint32_t src_ip[4];      /**< IPv6 source address in big endian. */
-	uint32_t dst_ip[4];      /**< IPv6 destination address in big endian. */
-	uint8_t  tc;             /**< Traffic class to match. */
-	uint8_t  proto;          /**< Protocol, next header to match. */
-	uint8_t  hop_limits;     /**< Hop limits to match. */
-};
-
-/**
- *  A structure used to configure FDIR masks that are used by the device
- *  to match the various fields of RX packet headers.
- */
-struct rte_eth_fdir_masks {
-	uint16_t vlan_tci_mask;   /**< Bit mask for vlan_tci in big endian */
-	/** Bit mask for ipv4 flow in big endian. */
-	struct rte_eth_ipv4_flow   ipv4_mask;
-	/** Bit maks for ipv6 flow in big endian. */
-	struct rte_eth_ipv6_flow   ipv6_mask;
-	/** Bit mask for L4 source port in big endian. */
-	uint16_t src_port_mask;
-	/** Bit mask for L4 destination port in big endian. */
-	uint16_t dst_port_mask;
-	/** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
-	    first byte on the wire */
-	uint8_t mac_addr_byte_mask;
-	/** Bit mask for tunnel ID in big endian. */
-	uint32_t tunnel_id_mask;
-	uint8_t tunnel_type_mask; /**< 1 - Match tunnel type,
-				       0 - Ignore tunnel type. */
-};
-
-/**
- * Payload type
- */
-enum rte_eth_payload_type {
-	RTE_ETH_PAYLOAD_UNKNOWN = 0,
-	RTE_ETH_RAW_PAYLOAD,
-	RTE_ETH_L2_PAYLOAD,
-	RTE_ETH_L3_PAYLOAD,
-	RTE_ETH_L4_PAYLOAD,
-	RTE_ETH_PAYLOAD_MAX = 8,
-};
-
-#define RTE_ETH_FDIR_MAX_FLEXLEN 16  /**< Max length of flexbytes. */
-#define RTE_ETH_INSET_SIZE_MAX   128 /**< Max length of input set. */
-
-/**
- * A structure used to select bytes extracted from the protocol layers to
- * flexible payload for filter
- */
-struct rte_eth_flex_payload_cfg {
-	enum rte_eth_payload_type type;  /**< Payload type */
-	uint16_t src_offset[RTE_ETH_FDIR_MAX_FLEXLEN];
-	/**< Offset in bytes from the beginning of packet's payload
-	     src_offset[i] indicates the flexbyte i's offset in original
-	     packet payload. This value should be less than
-	     flex_payload_limit in struct rte_eth_fdir_info.*/
-};
-
-/**
- * A structure used to define FDIR masks for flexible payload
- * for each flow type
- */
-struct rte_eth_fdir_flex_mask {
-	uint16_t flow_type;
-	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
-	/**< Mask for the whole flexible payload */
-};
-
-
-/*
- * A packet can be identified by hardware as different flow types. Different
- * NIC hardwares may support different flow types.
- * Basically, the NIC hardware identifies the flow type as deep protocol as
- * possible, and exclusively. For example, if a packet is identified as
- * 'RTE_ETH_FLOW_NONFRAG_IPV4_TCP', it will not be any of other flow types,
- * though it is an actual IPV4 packet.
- * Note that the flow types are used to define RSS offload types in
- * rte_ethdev.h.
- */
-#define RTE_ETH_FLOW_UNKNOWN             0
-#define RTE_ETH_FLOW_RAW                 1
-#define RTE_ETH_FLOW_IPV4                2
-#define RTE_ETH_FLOW_FRAG_IPV4           3
-#define RTE_ETH_FLOW_NONFRAG_IPV4_TCP    4
-#define RTE_ETH_FLOW_NONFRAG_IPV4_UDP    5
-#define RTE_ETH_FLOW_NONFRAG_IPV4_SCTP   6
-#define RTE_ETH_FLOW_NONFRAG_IPV4_OTHER  7
-#define RTE_ETH_FLOW_IPV6                8
-#define RTE_ETH_FLOW_FRAG_IPV6           9
-#define RTE_ETH_FLOW_NONFRAG_IPV6_TCP   10
-#define RTE_ETH_FLOW_NONFRAG_IPV6_UDP   11
-#define RTE_ETH_FLOW_NONFRAG_IPV6_SCTP  12
-#define RTE_ETH_FLOW_NONFRAG_IPV6_OTHER 13
-#define RTE_ETH_FLOW_L2_PAYLOAD         14
-#define RTE_ETH_FLOW_IPV6_EX            15
-#define RTE_ETH_FLOW_IPV6_TCP_EX        16
-#define RTE_ETH_FLOW_IPV6_UDP_EX        17
-#define RTE_ETH_FLOW_PORT               18
-	/**< Consider device port number as a flow differentiator */
-#define RTE_ETH_FLOW_VXLAN              19 /**< VXLAN protocol based flow */
-#define RTE_ETH_FLOW_GENEVE             20 /**< GENEVE protocol based flow */
-#define RTE_ETH_FLOW_NVGRE              21 /**< NVGRE protocol based flow */
-#define RTE_ETH_FLOW_MAX                22
-
-/**
- * A structure used to define all flexible payload related setting
- * include flex payload and flex mask
- */
-struct rte_eth_fdir_flex_conf {
-	uint16_t nb_payloads;  /**< The number of following payload cfg */
-	uint16_t nb_flexmasks; /**< The number of following mask */
-	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
-	/**< Flex payload configuration for each payload type */
-	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_MAX];
-	/**< Flex mask configuration for each flow type */
-};
-
-/**
- * A structure used to configure the Flow Director (FDIR) feature
- * of an Ethernet port.
- *
- * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
- */
-struct rte_fdir_conf {
-	enum rte_fdir_mode mode; /**< Flow Director mode. */
-	enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */
-	enum rte_fdir_status_mode status;  /**< How to report FDIR hash. */
-	/** RX queue of packets matching a "drop" filter in perfect mode. */
-	uint8_t drop_queue;
-	struct rte_eth_fdir_masks mask;
-	struct rte_eth_fdir_flex_conf flex_conf;
-	/**< Flex payload configuration. */
-};
-
-/**
- * A structure used to enable/disable specific device interrupts.
- */
-struct rte_intr_conf {
-	/** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */
-	uint16_t lsc;
-	/** enable/disable rxq interrupt. 0 (default) - disable, 1 enable */
-	uint16_t rxq;
-};
-
-/**
- * A structure used to configure an Ethernet port.
- * Depending upon the RX multi-queue mode, extra advanced
- * configuration settings may be needed.
- */
-struct rte_eth_conf {
-	uint32_t link_speeds; /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be
-				used. ETH_LINK_SPEED_FIXED disables link
-				autonegotiation, and a unique speed shall be
-				set. Otherwise, the bitmap defines the set of
-				speeds to be advertised. If the special value
-				ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
-				supported are advertised. */
-	struct rte_eth_rxmode rxmode; /**< Port RX configuration. */
-	struct rte_eth_txmode txmode; /**< Port TX configuration. */
-	uint32_t lpbk_mode; /**< Loopback operation mode. By default the value
-			         is 0, meaning the loopback mode is disabled.
-				 Read the datasheet of given ethernet controller
-				 for details. The possible values of this field
-				 are defined in implementation of each driver. */
-	struct {
-		struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */
-		struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
-		/**< Port vmdq+dcb configuration. */
-		struct rte_eth_dcb_rx_conf dcb_rx_conf;
-		/**< Port dcb RX configuration. */
-		struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
-		/**< Port vmdq RX configuration. */
-	} rx_adv_conf; /**< Port RX filtering configuration (union). */
-	union {
-		struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
-		/**< Port vmdq+dcb TX configuration. */
-		struct rte_eth_dcb_tx_conf dcb_tx_conf;
-		/**< Port dcb TX configuration. */
-		struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
-		/**< Port vmdq TX configuration. */
-	} tx_adv_conf; /**< Port TX DCB configuration (union). */
-	/** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
-	    is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */
-	uint32_t dcb_capability_en;
-	struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */
-	struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */
-};
diff --git a/tests/headers/layout_eth_conf_1_0.h b/tests/headers/layout_eth_conf_1_0.h
deleted file mode 100644
index 48ba39ff..00000000
--- a/tests/headers/layout_eth_conf_1_0.h
+++ /dev/null
@@ -1,429 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-/**
- *  Simple flags are used for rte_eth_conf.rxmode.mq_mode.
- */
-#define ETH_MQ_RX_RSS_FLAG  0x1
-#define ETH_MQ_RX_DCB_FLAG  0x2
-#define ETH_MQ_RX_VMDQ_FLAG 0x4
-
-/* Definitions used for VMDQ and DCB functionality */
-#define ETH_VMDQ_MAX_VLAN_FILTERS   64 /**< Maximum nb. of VMDQ vlan filters. */
-#define ETH_DCB_NUM_USER_PRIORITIES 8  /**< Maximum nb. of DCB priorities. */
-#define ETH_VMDQ_DCB_NUM_QUEUES     128 /**< Maximum nb. of VMDQ DCB queues. */
-#define ETH_DCB_NUM_QUEUES          128 /**< Maximum nb. of DCB queues. */
-
-/**
- *  A set of values to identify what method is to be used to route
- *  packets to multiple queues.
- */
-enum rte_eth_rx_mq_mode {
-	/** None of DCB,RSS or VMDQ mode */
-	ETH_MQ_RX_NONE = 0,
-
-	/** For RX side, only RSS is on */
-	ETH_MQ_RX_RSS = ETH_MQ_RX_RSS_FLAG,
-	/** For RX side,only DCB is on. */
-	ETH_MQ_RX_DCB = ETH_MQ_RX_DCB_FLAG,
-	/** Both DCB and RSS enable */
-	ETH_MQ_RX_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG,
-
-	/** Only VMDQ, no RSS nor DCB */
-	ETH_MQ_RX_VMDQ_ONLY = ETH_MQ_RX_VMDQ_FLAG,
-	/** RSS mode with VMDQ */
-	ETH_MQ_RX_VMDQ_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_VMDQ_FLAG,
-	/** Use VMDQ+DCB to route traffic to queues */
-	ETH_MQ_RX_VMDQ_DCB = ETH_MQ_RX_VMDQ_FLAG | ETH_MQ_RX_DCB_FLAG,
-	/** Enable both VMDQ and DCB in VMDq */
-	ETH_MQ_RX_VMDQ_DCB_RSS = ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG |
-				 ETH_MQ_RX_VMDQ_FLAG,
-};
-
-/**
- * A structure used to configure the RX features of an Ethernet port.
- */
-struct rte_eth_rxmode {
-	/** The multi-queue packet distribution mode to be used, e.g. RSS. */
-	enum rte_eth_rx_mq_mode mq_mode;
-	uint32_t max_rx_pkt_len;  /**< Only used if jumbo_frame enabled. */
-	uint16_t split_hdr_size;  /**< hdr buf size (header_split enabled).*/
-	__extension__
-	uint16_t header_split : 1, /**< Header Split enable. */
-		hw_ip_checksum   : 1, /**< IP/UDP/TCP checksum offload enable. */
-		hw_vlan_filter   : 1, /**< VLAN filter enable. */
-		hw_vlan_strip    : 1, /**< VLAN strip enable. */
-		hw_vlan_extend   : 1, /**< Extended VLAN enable. */
-		jumbo_frame      : 1, /**< Jumbo Frame Receipt enable. */
-		hw_strip_crc     : 1, /**< Enable CRC stripping by hardware. */
-		enable_scatter   : 1, /**< Enable scatter packets rx handler */
-		enable_lro       : 1; /**< Enable LRO */
-};
-
-/**
- * A set of values to identify what method is to be used to transmit
- * packets using multi-TCs.
- */
-enum rte_eth_tx_mq_mode {
-	ETH_MQ_TX_NONE    = 0,  /**< It is in neither DCB nor VT mode. */
-	ETH_MQ_TX_DCB,          /**< For TX side,only DCB is on. */
-	ETH_MQ_TX_VMDQ_DCB,	/**< For TX side,both DCB and VT is on. */
-	ETH_MQ_TX_VMDQ_ONLY,    /**< Only VT on, no DCB */
-};
-
-/**
- * A structure used to configure the TX features of an Ethernet port.
- */
-struct rte_eth_txmode {
-	enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */
-
-	/* For i40e specifically */
-	uint16_t pvid;
-	__extension__
-	uint8_t hw_vlan_reject_tagged : 1,
-		/**< If set, reject sending out tagged pkts */
-		hw_vlan_reject_untagged : 1,
-		/**< If set, reject sending out untagged pkts */
-		hw_vlan_insert_pvid : 1;
-		/**< If set, enable port based VLAN insertion */
-};
-
-/**
- * A structure used to configure the Receive Side Scaling (RSS) feature
- * of an Ethernet port.
- * If not NULL, the *rss_key* pointer of the *rss_conf* structure points
- * to an array holding the RSS key to use for hashing specific header
- * fields of received packets. The length of this array should be indicated
- * by *rss_key_len* below. Otherwise, a default random hash key is used by
- * the device driver.
- *
- * The *rss_key_len* field of the *rss_conf* structure indicates the length
- * in bytes of the array pointed by *rss_key*. To be compatible, this length
- * will be checked in i40e only. Others assume 40 bytes to be used as before.
- *
- * The *rss_hf* field of the *rss_conf* structure indicates the different
- * types of IPv4/IPv6 packets to which the RSS hashing must be applied.
- * Supplying an *rss_hf* equal to zero disables the RSS feature.
- */
-struct rte_eth_rss_conf {
-	uint8_t *rss_key;    /**< If not NULL, 40-byte hash key. */
-	uint8_t rss_key_len; /**< hash key length in bytes. */
-	uint64_t rss_hf;     /**< Hash functions to apply - see below. */
-};
-
-/**
- * This enum indicates the possible number of traffic classes
- * in DCB configratioins
- */
-enum rte_eth_nb_tcs {
-	ETH_4_TCS = 4, /**< 4 TCs with DCB. */
-	ETH_8_TCS = 8  /**< 8 TCs with DCB. */
-};
-
-/**
- * This enum indicates the possible number of queue pools
- * in VMDQ configurations.
- */
-enum rte_eth_nb_pools {
-	ETH_8_POOLS = 8,    /**< 8 VMDq pools. */
-	ETH_16_POOLS = 16,  /**< 16 VMDq pools. */
-	ETH_32_POOLS = 32,  /**< 32 VMDq pools. */
-	ETH_64_POOLS = 64   /**< 64 VMDq pools. */
-};
-
-/**
- * A structure used to configure the VMDQ+DCB feature
- * of an Ethernet port.
- *
- * Using this feature, packets are routed to a pool of queues, based
- * on the vlan id in the vlan tag, and then to a specific queue within
- * that pool, using the user priority vlan tag field.
- *
- * A default pool may be used, if desired, to route all traffic which
- * does not match the vlan filter rules.
- */
-struct rte_eth_vmdq_dcb_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */
-	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
-	uint8_t default_pool; /**< The default pool, if applicable */
-	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
-	struct {
-		uint16_t vlan_id; /**< The vlan id of the received frame */
-		uint64_t pools;   /**< Bitmask of pools for packet rx */
-	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-	/**< Selects a queue in a pool */
-};
-
-/* This structure may be extended in future. */
-struct rte_eth_dcb_rx_conf {
-	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_vmdq_dcb_tx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_dcb_tx_conf {
-	enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs. */
-	/** Traffic class each UP mapped to. */
-	uint8_t dcb_tc[ETH_DCB_NUM_USER_PRIORITIES];
-};
-
-struct rte_eth_vmdq_tx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq mode, 64 pools. */
-};
-
-struct rte_eth_vmdq_rx_conf {
-	enum rte_eth_nb_pools nb_queue_pools; /**< VMDq only mode, 8 or 64 pools */
-	uint8_t enable_default_pool; /**< If non-zero, use a default pool */
-	uint8_t default_pool; /**< The default pool, if applicable */
-	uint8_t enable_loop_back; /**< Enable VT loop back */
-	uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
-	uint32_t rx_mode; /**< Flags from ETH_VMDQ_ACCEPT_* */
-	struct {
-		uint16_t vlan_id; /**< The vlan id of the received frame */
-		uint64_t pools;   /**< Bitmask of pools for packet rx */
-	} pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
-};
-
-/**
- *  Flow Director setting modes: none, signature or perfect.
- */
-enum rte_fdir_mode {
-	RTE_FDIR_MODE_NONE      = 0, /**< Disable FDIR support. */
-	RTE_FDIR_MODE_SIGNATURE,     /**< Enable FDIR signature filter mode. */
-	RTE_FDIR_MODE_PERFECT,       /**< Enable FDIR perfect filter mode. */
-	RTE_FDIR_MODE_PERFECT_MAC_VLAN, /**< Enable FDIR filter mode - MAC VLAN. */
-	RTE_FDIR_MODE_PERFECT_TUNNEL,   /**< Enable FDIR filter mode - tunnel. */
-};
-
-/**
- *  Memory space that can be configured to store Flow Director filters
- *  in the board memory.
- */
-enum rte_fdir_pballoc_type {
-	RTE_FDIR_PBALLOC_64K = 0,  /**< 64k. */
-	RTE_FDIR_PBALLOC_128K,     /**< 128k. */
-	RTE_FDIR_PBALLOC_256K,     /**< 256k. */
-};
-
-/**
- *  Select report mode of FDIR hash information in RX descriptors.
- */
-enum rte_fdir_status_mode {
-	RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */
-	RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */
-	RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */
-};
-
-/**
- * A structure used to define the input for IPV4 flow
- */
-struct rte_eth_ipv4_flow {
-	uint32_t src_ip;      /**< IPv4 source address in big endian. */
-	uint32_t dst_ip;      /**< IPv4 destination address in big endian. */
-	uint8_t  tos;         /**< Type of service to match. */
-	uint8_t  ttl;         /**< Time to live to match. */
-	uint8_t  proto;       /**< Protocol, next header in big endian. */
-};
-
-/**
- * A structure used to define the input for IPV6 flow
- */
-struct rte_eth_ipv6_flow {
-	uint32_t src_ip[4];      /**< IPv6 source address in big endian. */
-	uint32_t dst_ip[4];      /**< IPv6 destination address in big endian. */
-	uint8_t  tc;             /**< Traffic class to match. */
-	uint8_t  proto;          /**< Protocol, next header to match. */
-	uint8_t  hop_limits;     /**< Hop limits to match. */
-};
-
-/**
- *  A structure used to configure FDIR masks that are used by the device
- *  to match the various fields of RX packet headers.
- */
-struct rte_eth_fdir_masks {
-	uint16_t vlan_tci_mask;   /**< Bit mask for vlan_tci in big endian */
-	/** Bit mask for ipv4 flow in big endian. */
-	struct rte_eth_ipv4_flow   ipv4_mask;
-	/** Bit maks for ipv6 flow in big endian. */
-	struct rte_eth_ipv6_flow   ipv6_mask;
-	/** Bit mask for L4 source port in big endian. */
-	uint16_t src_port_mask;
-	/** Bit mask for L4 destination port in big endian. */
-	uint16_t dst_port_mask;
-	/** 6 bit mask for proper 6 bytes of Mac address, bit 0 matches the
-	    first byte on the wire */
-	uint8_t mac_addr_byte_mask;
-	/** Bit mask for tunnel ID in big endian. */
-	uint32_t tunnel_id_mask;
-	uint8_t tunnel_type_mask; /**< 1 - Match tunnel type,
-				       0 - Ignore tunnel type. */
-};
-
-/**
- * Payload type
- */
-enum rte_eth_payload_type {
-	RTE_ETH_PAYLOAD_UNKNOWN = 0,
-	RTE_ETH_RAW_PAYLOAD,
-	RTE_ETH_L2_PAYLOAD,
-	RTE_ETH_L3_PAYLOAD,
-	RTE_ETH_L4_PAYLOAD,
-	RTE_ETH_PAYLOAD_MAX = 8,
-};
-
-#define RTE_ETH_FDIR_MAX_FLEXLEN 16  /**< Max length of flexbytes. */
-#define RTE_ETH_INSET_SIZE_MAX   128 /**< Max length of input set. */
-
-/**
- * A structure used to select bytes extracted from the protocol layers to
- * flexible payload for filter
- */
-struct rte_eth_flex_payload_cfg {
-	enum rte_eth_payload_type type;  /**< Payload type */
-	uint16_t src_offset[RTE_ETH_FDIR_MAX_FLEXLEN];
-	/**< Offset in bytes from the beginning of packet's payload
-	     src_offset[i] indicates the flexbyte i's offset in original
-	     packet payload. This value should be less than
-	     flex_payload_limit in struct rte_eth_fdir_info.*/
-};
-
-/**
- * A structure used to define FDIR masks for flexible payload
- * for each flow type
- */
-struct rte_eth_fdir_flex_mask {
-	uint16_t flow_type;
-	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
-	/**< Mask for the whole flexible payload */
-};
-
-
-/*
- * A packet can be identified by hardware as different flow types. Different
- * NIC hardwares may support different flow types.
- * Basically, the NIC hardware identifies the flow type as deep protocol as
- * possible, and exclusively. For example, if a packet is identified as
- * 'RTE_ETH_FLOW_NONFRAG_IPV4_TCP', it will not be any of other flow types,
- * though it is an actual IPV4 packet.
- * Note that the flow types are used to define RSS offload types in
- * rte_ethdev.h.
- */
-#define RTE_ETH_FLOW_UNKNOWN             0
-#define RTE_ETH_FLOW_RAW                 1
-#define RTE_ETH_FLOW_IPV4                2
-#define RTE_ETH_FLOW_FRAG_IPV4           3
-#define RTE_ETH_FLOW_NONFRAG_IPV4_TCP    4
-#define RTE_ETH_FLOW_NONFRAG_IPV4_UDP    5
-#define RTE_ETH_FLOW_NONFRAG_IPV4_SCTP   6
-#define RTE_ETH_FLOW_NONFRAG_IPV4_OTHER  7
-#define RTE_ETH_FLOW_IPV6                8
-#define RTE_ETH_FLOW_FRAG_IPV6           9
-#define RTE_ETH_FLOW_NONFRAG_IPV6_TCP   10
-#define RTE_ETH_FLOW_NONFRAG_IPV6_UDP   11
-#define RTE_ETH_FLOW_NONFRAG_IPV6_SCTP  12
-#define RTE_ETH_FLOW_NONFRAG_IPV6_OTHER 13
-#define RTE_ETH_FLOW_L2_PAYLOAD         14
-#define RTE_ETH_FLOW_IPV6_EX            15
-#define RTE_ETH_FLOW_IPV6_TCP_EX        16
-#define RTE_ETH_FLOW_IPV6_UDP_EX        17
-#define RTE_ETH_FLOW_PORT               18
-	/**< Consider device port number as a flow differentiator */
-#define RTE_ETH_FLOW_VXLAN              19 /**< VXLAN protocol based flow */
-#define RTE_ETH_FLOW_GENEVE             20 /**< GENEVE protocol based flow */
-#define RTE_ETH_FLOW_NVGRE              21 /**< NVGRE protocol based flow */
-#define RTE_ETH_FLOW_MAX                22
-
-/**
- * A structure used to define all flexible payload related setting
- * include flex payload and flex mask
- */
-struct rte_eth_fdir_flex_conf {
-	uint16_t nb_payloads;  /**< The number of following payload cfg */
-	uint16_t nb_flexmasks; /**< The number of following mask */
-	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
-	/**< Flex payload configuration for each payload type */
-	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_MAX];
-	/**< Flex mask configuration for each flow type */
-};
-
-/**
- * A structure used to configure the Flow Director (FDIR) feature
- * of an Ethernet port.
- *
- * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
- */
-struct rte_fdir_conf {
-	enum rte_fdir_mode mode; /**< Flow Director mode. */
-	enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */
-	enum rte_fdir_status_mode status;  /**< How to report FDIR hash. */
-	/** RX queue of packets matching a "drop" filter in perfect mode. */
-	uint8_t drop_queue;
-	struct rte_eth_fdir_masks mask;
-	struct rte_eth_fdir_flex_conf flex_conf;
-	/**< Flex payload configuration. */
-};
-
-/**
- * A structure used to enable/disable specific device interrupts.
- */
-struct rte_intr_conf {
-	/** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */
-	uint16_t lsc;
-	/** enable/disable rxq interrupt. 0 (default) - disable, 1 enable */
-	uint16_t rxq;
-};
-
-/**
- * A structure used to configure an Ethernet port.
- * Depending upon the RX multi-queue mode, extra advanced
- * configuration settings may be needed.
- */
-struct rte_eth_conf {
-	uint32_t link_speeds; /**< bitmap of ETH_LINK_SPEED_XXX of speeds to be
-				used. ETH_LINK_SPEED_FIXED disables link
-				autonegotiation, and a unique speed shall be
-				set. Otherwise, the bitmap defines the set of
-				speeds to be advertised. If the special value
-				ETH_LINK_SPEED_AUTONEG (0) is used, all speeds
-				supported are advertised. */
-	struct rte_eth_rxmode rxmode; /**< Port RX configuration. */
-	struct rte_eth_txmode txmode; /**< Port TX configuration. */
-	uint32_t lpbk_mode; /**< Loopback operation mode. By default the value
-			         is 0, meaning the loopback mode is disabled.
-				 Read the datasheet of given ethernet controller
-				 for details. The possible values of this field
-				 are defined in implementation of each driver. */
-	struct {
-		struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */
-		struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
-		/**< Port vmdq+dcb configuration. */
-		struct rte_eth_dcb_rx_conf dcb_rx_conf;
-		/**< Port dcb RX configuration. */
-		struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
-		/**< Port vmdq RX configuration. */
-	} rx_adv_conf; /**< Port RX filtering configuration (union). */
-	union {
-		struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
-		/**< Port vmdq+dcb TX configuration. */
-		struct rte_eth_dcb_tx_conf dcb_tx_conf;
-		/**< Port dcb TX configuration. */
-		struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
-		/**< Port vmdq TX configuration. */
-	} tx_adv_conf; /**< Port TX DCB configuration (union). */
-	/** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
-	    is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */
-	uint32_t dcb_capability_en;
-	struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */
-	struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */
-};
diff --git a/tests/headers/layout_kni_mbuf.h b/tests/headers/layout_kni_mbuf.h
deleted file mode 100644
index 4d604aa6..00000000
--- a/tests/headers/layout_kni_mbuf.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// bindgen-flags: --rust-target 1.40
-
-#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
-
-#define RTE_CACHE_LINE_SIZE 64
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-/*
- * The kernel image of the rte_mbuf struct, with only the relevant fields.
- * Padding is necessary to assure the offsets of these fields
- */
-struct rte_kni_mbuf {
-	void *buf_addr __attribute__((__aligned__(RTE_CACHE_LINE_SIZE)));
-	uint64_t buf_physaddr;
-	char pad0[2];
-	uint16_t data_off;      /**< Start address of data in segment buffer. */
-	char pad1[2];
-	uint8_t nb_segs;        /**< Number of segments. */
-	char pad4[1];
-	uint64_t ol_flags;      /**< Offload features. */
-	char pad2[4];
-	uint32_t pkt_len;       /**< Total pkt len: sum of all segment data_len. */
-	uint16_t data_len;      /**< Amount of data in segment buffer. */
-
-	/* fields on second cache line */
-	char pad3[8] __attribute__((__aligned__(RTE_CACHE_LINE_MIN_SIZE)));
-	void *pool;
-	void *next;
-};
diff --git a/tests/headers/layout_large_align_field.h b/tests/headers/layout_large_align_field.h
deleted file mode 100644
index 63aea90b..00000000
--- a/tests/headers/layout_large_align_field.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" --rust-target 1.40
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-#define RTE_CACHE_LINE_SIZE 64
-
-/**
- * Force alignment
- */
-#define __rte_aligned(a) __attribute__((__aligned__(a)))
-
-/**
- * Force alignment to cache line.
- */
-#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
-
-#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4
-
-enum {
-	IP_LAST_FRAG_IDX,    /**< index of last fragment */
-	IP_FIRST_FRAG_IDX,   /**< index of first fragment */
-	IP_MIN_FRAG_NUM,     /**< minimum number of fragments */
-	IP_MAX_FRAG_NUM = RTE_LIBRTE_IP_FRAG_MAX_FRAG,
-	/**< maximum number of fragments per packet */
-};
-
-/** @internal fragmented mbuf */
-struct ip_frag {
-	uint16_t ofs;          /**< offset into the packet */
-	uint16_t len;          /**< length of fragment */
-	struct rte_mbuf *mb;   /**< fragment mbuf */
-};
-
-/** @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. */
-struct ip_frag_key {
-	uint64_t src_dst[4];      /**< src address, first 8 bytes used for IPv4 */
-	uint32_t id;           /**< dst address */
-	uint32_t key_len;      /**< src/dst key length */
-};
-
-/*
- * Tail queue declarations.
- */
-#define	TAILQ_HEAD(name, type)						            \
-struct name {								                    \
-	struct type *tqh_first;	/* first element */			        \
-	struct type **tqh_last;	/* addr of last next element */		\
-}
-
-
-#define	TAILQ_ENTRY(type)						                    \
-struct {								                            \
-	struct type *tqe_next;	/* next element */			            \
-	struct type **tqe_prev;	/* address of previous next element */	\
-}
-
-/**
- * @internal Fragmented packet to reassemble.
- * First two entries in the frags[] array are for the last and first fragments.
- */
-struct ip_frag_pkt {
-	TAILQ_ENTRY(ip_frag_pkt) lru;   /**< LRU list */
-	struct ip_frag_key key;           /**< fragmentation key */
-	uint64_t             start;       /**< creation timestamp */
-	uint32_t             total_size;  /**< expected reassembled size */
-	uint32_t             frag_size;   /**< size of fragments received */
-	uint32_t             last_idx;    /**< index of next entry to fill */
-	struct ip_frag       frags[IP_MAX_FRAG_NUM]; /**< fragments */
-} __rte_cache_aligned;
-
-TAILQ_HEAD(ip_pkt_list, ip_frag_pkt); /**< @internal fragments tailq */
-
-/** fragmentation table statistics */
-struct ip_frag_tbl_stat {
-	uint64_t find_num;      /**< total # of find/insert attempts. */
-	uint64_t add_num;       /**< # of add ops. */
-	uint64_t del_num;       /**< # of del ops. */
-	uint64_t reuse_num;     /**< # of reuse (del/add) ops. */
-	uint64_t fail_total;    /**< total # of add failures. */
-	uint64_t fail_nospace;  /**< # of 'no space' add failures. */
-} __rte_cache_aligned;
-
-/** fragmentation table */
-struct rte_ip_frag_tbl {
-	uint64_t             max_cycles;      /**< ttl for table entries. */
-	uint32_t             entry_mask;      /**< hash value mask. */
-	uint32_t             max_entries;     /**< max entries allowed. */
-	uint32_t             use_entries;     /**< entries in use. */
-	uint32_t             bucket_entries;  /**< hash assocaitivity. */
-	uint32_t             nb_entries;      /**< total size of the table. */
-	uint32_t             nb_buckets;      /**< num of associativity lines. */
-	struct ip_frag_pkt *last;         /**< last used entry. */
-	struct ip_pkt_list lru;           /**< LRU list for table entries. */
-	struct ip_frag_tbl_stat stat;     /**< statistics counters. */
-	__extension__ struct ip_frag_pkt pkt[0]; /**< hash table. */
-};
diff --git a/tests/headers/layout_mbuf.h b/tests/headers/layout_mbuf.h
deleted file mode 100644
index 0e342f45..00000000
--- a/tests/headers/layout_mbuf.h
+++ /dev/null
@@ -1,188 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
-
-#define RTE_CACHE_LINE_SIZE 64
-
-typedef char int8_t;
-typedef short int16_t;
-typedef int int32_t;
-typedef long long int64_t;
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-typedef uint64_t phys_addr_t;
-
-/**
- * Force alignment
- */
-#define __rte_aligned(a) __attribute__((__aligned__(a)))
-
-/**
- * Force alignment to cache line.
- */
-#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
-
-/**
- * Force minimum cache line alignment.
- */
-#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE)
-
-/* define a set of marker types that can be used to refer to set points in the
- * mbuf */
-__extension__
-typedef void    *MARKER[0];   /**< generic marker for a point in a structure */
-__extension__
-typedef uint8_t  MARKER8[0];  /**< generic marker with 1B alignment */
-__extension__
-typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes
-                               * with a single assignment */
-
-/** C extension macro for environments lacking C11 features. */
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
-#define RTE_STD_C11 __extension__
-#else
-#define RTE_STD_C11
-#endif
-
-/**
- * The atomic counter structure.
- */
-typedef struct {
-	volatile int16_t cnt; /**< An internal counter value. */
-} rte_atomic16_t;
-
-/**
- * The generic rte_mbuf, containing a packet mbuf.
- */
-struct rte_mbuf {
-	MARKER cacheline0;
-
-	void *buf_addr;           /**< Virtual address of segment buffer. */
-	phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */
-
-	uint16_t buf_len;         /**< Length of segment buffer. */
-
-	/* next 6 bytes are initialised on RX descriptor rearm */
-	MARKER8 rearm_data;
-	uint16_t data_off;
-
-	/**
-	 * 16-bit Reference counter.
-	 * It should only be accessed using the following functions:
-	 * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
-	 * rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
-	 * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
-	 * config option.
-	 */
-	RTE_STD_C11
-	union {
-		rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */
-		uint16_t refcnt;              /**< Non-atomically accessed refcnt */
-	};
-	uint8_t nb_segs;          /**< Number of segments. */
-	uint8_t port;             /**< Input port. */
-
-	uint64_t ol_flags;        /**< Offload features. */
-
-	/* remaining bytes are set on RX when pulling packet from descriptor */
-	MARKER rx_descriptor_fields1;
-
-	/*
-	 * The packet type, which is the combination of outer/inner L2, L3, L4
-	 * and tunnel types. The packet_type is about data really present in the
-	 * mbuf. Example: if vlan stripping is enabled, a received vlan packet
-	 * would have RTE_PTYPE_L2_ETHER and not RTE_PTYPE_L2_VLAN because the
-	 * vlan is stripped from the data.
-	 */
-	RTE_STD_C11
-	union {
-		uint32_t packet_type; /**< L2/L3/L4 and tunnel information. */
-		struct {
-			uint32_t l2_type:4; /**< (Outer) L2 type. */
-			uint32_t l3_type:4; /**< (Outer) L3 type. */
-			uint32_t l4_type:4; /**< (Outer) L4 type. */
-			uint32_t tun_type:4; /**< Tunnel type. */
-			uint32_t inner_l2_type:4; /**< Inner L2 type. */
-			uint32_t inner_l3_type:4; /**< Inner L3 type. */
-			uint32_t inner_l4_type:4; /**< Inner L4 type. */
-		};
-	};
-
-	uint32_t pkt_len;         /**< Total pkt len: sum of all segments. */
-	uint16_t data_len;        /**< Amount of data in segment buffer. */
-	/** VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. */
-	uint16_t vlan_tci;
-
-	union {
-		uint32_t rss;     /**< RSS hash result if RSS enabled */
-		struct {
-			RTE_STD_C11
-			union {
-				struct {
-					uint16_t hash;
-					uint16_t id;
-				};
-				uint32_t lo;
-				/**< Second 4 flexible bytes */
-			};
-			uint32_t hi;
-			/**< First 4 flexible bytes or FD ID, dependent on
-			     PKT_RX_FDIR_* flag in ol_flags. */
-		} fdir;           /**< Filter identifier if FDIR enabled */
-		struct {
-			uint32_t lo;
-			uint32_t hi;
-		} sched;          /**< Hierarchical scheduler */
-		uint32_t usr;	  /**< User defined tags. See rte_distributor_process() */
-	} hash;                   /**< hash information */
-
-	uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */
-
-	/** Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. */
-	uint16_t vlan_tci_outer;
-
-	/* second cache line - fields only used in slow path or on TX */
-	MARKER cacheline1 __rte_cache_min_aligned;
-
-	RTE_STD_C11
-	union {
-		void *userdata;   /**< Can be used for external metadata */
-		uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */
-	};
-
-	struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */
-	struct rte_mbuf *next;    /**< Next segment of scattered packet. */
-
-	/* fields to support TX offloads */
-	RTE_STD_C11
-	union {
-		uint64_t tx_offload;       /**< combined for easy fetch */
-		__extension__
-		struct {
-			uint64_t l2_len:7;
-			/**< L2 (MAC) Header Length for non-tunneling pkt.
-			 * Outer_L4_len + ... + Inner_L2_len for tunneling pkt.
-			 */
-			uint64_t l3_len:9; /**< L3 (IP) Header Length. */
-			uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
-			uint64_t tso_segsz:16; /**< TCP TSO segment size */
-
-			/* fields for TX offloading of tunnels */
-			uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */
-			uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */
-
-			/* uint64_t unused:8; */
-		};
-	};
-
-	/** Size of the application private data. In case of an indirect
-	 * mbuf, it stores the direct mbuf private data size. */
-	uint16_t priv_size;
-
-	/** Timesync flags for use with IEEE1588. */
-	uint16_t timesync;
-} __rte_cache_aligned;
diff --git a/tests/headers/layout_mbuf_1_0.h b/tests/headers/layout_mbuf_1_0.h
deleted file mode 100644
index 2854de50..00000000
--- a/tests/headers/layout_mbuf_1_0.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-
-#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
-
-#define RTE_CACHE_LINE_SIZE 64
-
-typedef char int8_t;
-typedef short int16_t;
-typedef int int32_t;
-typedef long long int64_t;
-
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
-
-typedef uint64_t phys_addr_t;
-
-/**
- * Force alignment
- */
-#define __rte_aligned(a) __attribute__((__aligned__(a)))
-
-/**
- * Force alignment to cache line.
- */
-#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)
-
-/**
- * Force minimum cache line alignment.
- */
-#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE)
-
-/* define a set of marker types that can be used to refer to set points in the
- * mbuf */
-__extension__
-typedef void    *MARKER[0];   /**< generic marker for a point in a structure */
-__extension__
-typedef uint8_t  MARKER8[0];  /**< generic marker with 1B alignment */
-__extension__
-typedef uint64_t MARKER64[0]; /**< marker that allows us to overwrite 8 bytes
-                               * with a single assignment */
-
-/** C extension macro for environments lacking C11 features. */
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
-#define RTE_STD_C11 __extension__
-#else
-#define RTE_STD_C11
-#endif
-
-/**
- * The atomic counter structure.
- */
-typedef struct {
-	volatile int16_t cnt; /**< An internal counter value. */
-} rte_atomic16_t;
-
-/**
- * The generic rte_mbuf, containing a packet mbuf.
- */
-struct rte_mbuf {
-	MARKER cacheline0;
-
-	void *buf_addr;           /**< Virtual address of segment buffer. */
-	phys_addr_t buf_physaddr; /**< Physical address of segment buffer. */
-
-	uint16_t buf_len;         /**< Length of segment buffer. */
-
-	/* next 6 bytes are initialised on RX descriptor rearm */
-	MARKER8 rearm_data;
-	uint16_t data_off;
-
-	/**
-	 * 16-bit Reference counter.
-	 * It should only be accessed using the following functions:
-	 * rte_mbuf_refcnt_update(), rte_mbuf_refcnt_read(), and
-	 * rte_mbuf_refcnt_set(). The functionality of these functions (atomic,
-	 * or non-atomic) is controlled by the CONFIG_RTE_MBUF_REFCNT_ATOMIC
-	 * config option.
-	 */
-	RTE_STD_C11
-	union {
-		rte_atomic16_t refcnt_atomic; /**< Atomically accessed refcnt */
-		uint16_t refcnt;              /**< Non-atomically accessed refcnt */
-	};
-	uint8_t nb_segs;          /**< Number of segments. */
-	uint8_t port;             /**< Input port. */
-
-	uint64_t ol_flags;        /**< Offload features. */
-
-	/* remaining bytes are set on RX when pulling packet from descriptor */
-	MARKER rx_descriptor_fields1;
-
-	/*
-	 * The packet type, which is the combination of outer/inner L2, L3, L4
-	 * and tunnel types. The packet_type is about data really present in the
-	 * mbuf. Example: if vlan stripping is enabled, a received vlan packet
-	 * would have RTE_PTYPE_L2_ETHER and not RTE_PTYPE_L2_VLAN because the
-	 * vlan is stripped from the data.
-	 */
-	RTE_STD_C11
-	union {
-		uint32_t packet_type; /**< L2/L3/L4 and tunnel information. */
-		struct {
-			uint32_t l2_type:4; /**< (Outer) L2 type. */
-			uint32_t l3_type:4; /**< (Outer) L3 type. */
-			uint32_t l4_type:4; /**< (Outer) L4 type. */
-			uint32_t tun_type:4; /**< Tunnel type. */
-			uint32_t inner_l2_type:4; /**< Inner L2 type. */
-			uint32_t inner_l3_type:4; /**< Inner L3 type. */
-			uint32_t inner_l4_type:4; /**< Inner L4 type. */
-		};
-	};
-
-	uint32_t pkt_len;         /**< Total pkt len: sum of all segments. */
-	uint16_t data_len;        /**< Amount of data in segment buffer. */
-	/** VLAN TCI (CPU order), valid if PKT_RX_VLAN_STRIPPED is set. */
-	uint16_t vlan_tci;
-
-	union {
-		uint32_t rss;     /**< RSS hash result if RSS enabled */
-		struct {
-			RTE_STD_C11
-			union {
-				struct {
-					uint16_t hash;
-					uint16_t id;
-				};
-				uint32_t lo;
-				/**< Second 4 flexible bytes */
-			};
-			uint32_t hi;
-			/**< First 4 flexible bytes or FD ID, dependent on
-			     PKT_RX_FDIR_* flag in ol_flags. */
-		} fdir;           /**< Filter identifier if FDIR enabled */
-		struct {
-			uint32_t lo;
-			uint32_t hi;
-		} sched;          /**< Hierarchical scheduler */
-		uint32_t usr;	  /**< User defined tags. See rte_distributor_process() */
-	} hash;                   /**< hash information */
-
-	uint32_t seqn; /**< Sequence number. See also rte_reorder_insert() */
-
-	/** Outer VLAN TCI (CPU order), valid if PKT_RX_QINQ_STRIPPED is set. */
-	uint16_t vlan_tci_outer;
-
-	/* second cache line - fields only used in slow path or on TX */
-	MARKER cacheline1 __rte_cache_min_aligned;
-
-	RTE_STD_C11
-	union {
-		void *userdata;   /**< Can be used for external metadata */
-		uint64_t udata64; /**< Allow 8-byte userdata on 32-bit */
-	};
-
-	struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */
-	struct rte_mbuf *next;    /**< Next segment of scattered packet. */
-
-	/* fields to support TX offloads */
-	RTE_STD_C11
-	union {
-		uint64_t tx_offload;       /**< combined for easy fetch */
-		__extension__
-		struct {
-			uint64_t l2_len:7;
-			/**< L2 (MAC) Header Length for non-tunneling pkt.
-			 * Outer_L4_len + ... + Inner_L2_len for tunneling pkt.
-			 */
-			uint64_t l3_len:9; /**< L3 (IP) Header Length. */
-			uint64_t l4_len:8; /**< L4 (TCP/UDP) Header Length. */
-			uint64_t tso_segsz:16; /**< TCP TSO segment size */
-
-			/* fields for TX offloading of tunnels */
-			uint64_t outer_l3_len:9; /**< Outer L3 (IP) Hdr Length. */
-			uint64_t outer_l2_len:7; /**< Outer L2 (MAC) Hdr Length. */
-
-			/* uint64_t unused:8; */
-		};
-	};
-
-	/** Size of the application private data. In case of an indirect
-	 * mbuf, it stores the direct mbuf private data size. */
-	uint16_t priv_size;
-
-	/** Timesync flags for use with IEEE1588. */
-	uint16_t timesync;
-} __rte_cache_aligned;
diff --git a/tests/headers/long_double.h b/tests/headers/long_double.h
deleted file mode 100644
index 91c4ed6c..00000000
--- a/tests/headers/long_double.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --rust-target 1.26
-
-struct foo {
-  long double bar;
-};
diff --git a/tests/headers/macro-expr-basic.h b/tests/headers/macro-expr-basic.h
deleted file mode 100644
index d2de7fdf..00000000
--- a/tests/headers/macro-expr-basic.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#define FOO 1
-#define BAR 4
-#define BAZ (FOO + BAR)
-
-#define MIN (1 << 63)
-
-#define BARR (1 << 0)
-#define BAZZ ((1 << 1) + BAZ)
-#define I_RAN_OUT_OF_DUMB_NAMES (BARR | BAZZ)
-
-/* I haz a comment */
-#define HAZ_A_COMMENT BARR
-
-#define HAZ_A_COMMENT_INSIDE (/* comment for real */ BARR + FOO)
diff --git a/tests/headers/macro-expr-uncommon-token.h b/tests/headers/macro-expr-uncommon-token.h
deleted file mode 100644
index dd1b4343..00000000
--- a/tests/headers/macro-expr-uncommon-token.h
+++ /dev/null
@@ -1,7 +0,0 @@
-
-// Commenting this out & removing the usage before `foo` results in the correct
-// bindings
-#define MODBUS_API
-#define MODBUS_WOOT 3
-
-MODBUS_API void foo();
diff --git a/tests/headers/macro-redef.h b/tests/headers/macro-redef.h
deleted file mode 100644
index 0180d2ab..00000000
--- a/tests/headers/macro-redef.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#define FOO 4
-#define BAR (1 + FOO)
-#undef FOO
-#define FOO 5
-#define BAZ (1 + FOO)
diff --git a/tests/headers/macro_const.h b/tests/headers/macro_const.h
deleted file mode 100644
index 7c5aa438..00000000
--- a/tests/headers/macro_const.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#define foo "bar"
-#define CHAR 'b'
-#define CHARR '\0'
-#define FLOAT 5.09f
-#define FLOAT_EXPR (5 / 1000.0f)
-#define LONG 3L
-
-#define INVALID_UTF8 "\xf0\x28\x8c\x28"
diff --git a/tests/headers/macro_const_1_0.h b/tests/headers/macro_const_1_0.h
deleted file mode 100644
index 3be86b4f..00000000
--- a/tests/headers/macro_const_1_0.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rust-target 1.0
-
-#define foo "bar"
-#define CHAR 'b'
-#define CHARR '\0'
-#define FLOAT 5.09f
-#define FLOAT_EXPR (5 / 1000.0f)
-#define LONG 3L
-
-#define INVALID_UTF8 "\xf0\x28\x8c\x28"
diff --git a/tests/headers/maddness-is-avoidable.hpp b/tests/headers/maddness-is-avoidable.hpp
deleted file mode 100644
index 47a7ffbf..00000000
--- a/tests/headers/maddness-is-avoidable.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --blocklist-type RefPtr_Proxy_member_function
-
-template<typename T>
-class RefPtr {
-  template<typename R, typename... Args>
-  class Proxy {
-    typedef R (T::*member_function)(Args...);
-  };
-};
diff --git a/tests/headers/mangling-ios.h b/tests/headers/mangling-ios.h
deleted file mode 100644
index d3a0cd78..00000000
--- a/tests/headers/mangling-ios.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: -- --target=x86_64-apple-ios
-
-void foo();
diff --git a/tests/headers/mangling-linux32.hpp b/tests/headers/mangling-linux32.hpp
deleted file mode 100644
index 450c91d7..00000000
--- a/tests/headers/mangling-linux32.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- --target=i586-unknown-linux
-
-extern "C" void foo();
-
-struct Foo {
-  static bool sBar;
-};
diff --git a/tests/headers/mangling-linux64.hpp b/tests/headers/mangling-linux64.hpp
deleted file mode 100644
index 36dda913..00000000
--- a/tests/headers/mangling-linux64.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- --target=x86_64-unknown-linux
-
-extern "C" void foo();
-
-struct Foo {
-  static bool sBar;
-};
diff --git a/tests/headers/mangling-macos.hpp b/tests/headers/mangling-macos.hpp
deleted file mode 100644
index 94b16202..00000000
--- a/tests/headers/mangling-macos.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- --target=x86_64-apple-darwin
-
-extern "C" void foo();
-
-struct Foo {
-  static bool sBar;
-};
diff --git a/tests/headers/mangling-win32.hpp b/tests/headers/mangling-win32.hpp
deleted file mode 100644
index 386df4ab..00000000
--- a/tests/headers/mangling-win32.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// bindgen-flags: -- --target=i686-pc-win32
-
-extern "C" void foo();
-
-struct Foo {
-  static bool sBar;
-};
-
-// Also test some x86 Windows specific calling conventions that have their own
-// special mangling
-extern "C" {
-    int _fastcall fast_call_func_no_args();
-    // This will result in a suffix with more than one character (i.e. `@12`)
-    int _fastcall fast_call_func_many_args(int,int,int);
-    int _stdcall std_call_func_no_args();
-    // This will result in a suffix with more than one character (i.e. `@12`)
-    int _stdcall std_call_func_many_args(int,int,int);
-}
diff --git a/tests/headers/mangling-win64.hpp b/tests/headers/mangling-win64.hpp
deleted file mode 100644
index 8882d7dd..00000000
--- a/tests/headers/mangling-win64.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- --target=x86_64-pc-win32
-
-extern "C" void foo();
-
-struct Foo {
-  static bool sBar;
-};
diff --git a/tests/headers/merge-extern-blocks.h b/tests/headers/merge-extern-blocks.h
deleted file mode 100644
index 1d46b7d4..00000000
--- a/tests/headers/merge-extern-blocks.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --merge-extern-blocks -- --target=x86_64-unknown-linux
-int foo();
-typedef struct Point {
-    int x;
-} Point;
-int bar();
diff --git a/tests/headers/method-mangling.hpp b/tests/headers/method-mangling.hpp
deleted file mode 100644
index 0dac4975..00000000
--- a/tests/headers/method-mangling.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-
-class Foo {
-public:
-  int type();
-};
diff --git a/tests/headers/module-allowlisted.hpp b/tests/headers/module-allowlisted.hpp
deleted file mode 100644
index f41e874e..00000000
--- a/tests/headers/module-allowlisted.hpp
+++ /dev/null
@@ -1,2 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-struct Test {};
diff --git a/tests/headers/msvc-no-usr.hpp b/tests/headers/msvc-no-usr.hpp
deleted file mode 100644
index b15e49f5..00000000
--- a/tests/headers/msvc-no-usr.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-
-typedef unsigned long long size_t;
-
-class A {
-  const size_t foo;
-
-  A() : foo(5) {}
-};
diff --git a/tests/headers/multiple-inherit-empty-correct-layout.hpp b/tests/headers/multiple-inherit-empty-correct-layout.hpp
deleted file mode 100644
index 1e2b133a..00000000
--- a/tests/headers/multiple-inherit-empty-correct-layout.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-struct Foo {};
-struct Bar {};
-struct Baz : public Foo, public Bar {};
diff --git a/tests/headers/mutable.hpp b/tests/headers/mutable.hpp
deleted file mode 100644
index b61a1031..00000000
--- a/tests/headers/mutable.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-class C {
-    mutable int m_member;
-    int m_other;
-};
-
-class NonCopiable {
-    mutable int m_member;
-
-    ~NonCopiable() {};
-};
-
-class NonCopiableWithNonCopiableMutableMember {
-    mutable NonCopiable m_member;
-};
diff --git a/tests/headers/namespace.hpp b/tests/headers/namespace.hpp
deleted file mode 100644
index 7e4197da..00000000
--- a/tests/headers/namespace.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --module-raw-line root::whatever 'pub type whatever_other_thing_t = whatever_int_t;'
-
-void top_level();
-
-namespace whatever {
-    typedef int whatever_int_t;
-
-    void in_whatever();
-}
-
-namespace {
-    namespace empty {}
-
-    struct A {
-        whatever::whatever_int_t b;
-    };
-}
-
-template<typename T>
-class C: public A {
-    T m_c;
-    T* m_c_ptr;
-    T m_c_arr[10];
-};
-
-template<>
-class C<int>;
-
-namespace w {
-    typedef unsigned int whatever_int_t;
-
-    template<typename T>
-    class D {
-        C<T> m_c;
-    };
-
-    whatever_int_t heh(); // this should return w::whatever_int_t, and not whatever::whatever_int_t
-
-    C<int> foo();
-
-    C<float> barr(); // <- This is the problematic one
-}
-
-#define NAMESPACE foobar
-namespace NAMESPACE {
-    void foo();
-}
-
-#include "namespace/nsbegin.h"
-void bar();
-#include "namespace/nsend.h"
diff --git a/tests/headers/namespace/nsbegin.h b/tests/headers/namespace/nsbegin.h
deleted file mode 100644
index 47a51c93..00000000
--- a/tests/headers/namespace/nsbegin.h
+++ /dev/null
@@ -1 +0,0 @@
-namespace faraway {
diff --git a/tests/headers/namespace/nsend.h b/tests/headers/namespace/nsend.h
deleted file mode 100644
index 5c34318c..00000000
--- a/tests/headers/namespace/nsend.h
+++ /dev/null
@@ -1 +0,0 @@
-}
diff --git a/tests/headers/nested-template-typedef.hpp b/tests/headers/nested-template-typedef.hpp
deleted file mode 100644
index 8c83de5b..00000000
--- a/tests/headers/nested-template-typedef.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-template<typename T>
-class Foo {
-public:
-    template<typename U>
-    struct Bar {
-        typedef Foo<U> FooU;
-    };
-};
diff --git a/tests/headers/nested.hpp b/tests/headers/nested.hpp
deleted file mode 100644
index 299e1768..00000000
--- a/tests/headers/nested.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-
-class Calc {
-    int w;
-};
-
-class Test {
-public:
-    struct Size;
-    friend struct Size;
-    struct Size {
-        struct Dimension : public Calc {
-        };
-        Dimension mWidth, mHeight;
-    };
-};
diff --git a/tests/headers/nested_vtable.hpp b/tests/headers/nested_vtable.hpp
deleted file mode 100644
index 87d6ce1f..00000000
--- a/tests/headers/nested_vtable.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-class nsISupports {
-public:
-  virtual nsISupports* QueryInterface();
-};
-
-class nsIRunnable : public nsISupports {};
-
-class Runnable : public nsIRunnable {};
diff --git a/tests/headers/nested_within_namespace.hpp b/tests/headers/nested_within_namespace.hpp
deleted file mode 100644
index a9b7c1ec..00000000
--- a/tests/headers/nested_within_namespace.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-namespace foo {
-  class Bar {
-    int foo;
-
-    class Baz {
-      int foo;
-    };
-  };
-
-  class Baz {
-    int baz;
-  };
-}
diff --git a/tests/headers/newtype-enum.hpp b/tests/headers/newtype-enum.hpp
deleted file mode 100644
index 890683ae..00000000
--- a/tests/headers/newtype-enum.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --newtype-enum "Foo" --rust-target 1.28  -- -std=c++11
-
-enum Foo {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
diff --git a/tests/headers/newtype-global-enum.hpp b/tests/headers/newtype-global-enum.hpp
deleted file mode 100644
index 8021a3cc..00000000
--- a/tests/headers/newtype-global-enum.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --newtype-global-enum "Foo" --rust-target 1.28  -- -std=c++11
-
-enum Foo {
-  Bar = 1 << 1,
-  Baz = 1 << 2,
-  Duplicated = 1 << 2,
-  Negative = -3,
-};
diff --git a/tests/headers/no-comments.h b/tests/headers/no-comments.h
deleted file mode 100644
index 1ddb1a3b..00000000
--- a/tests/headers/no-comments.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --no-doc-comments
-
-struct Foo {
-    int s; /*!< Including this will prevent rustc for compiling it */
-};
diff --git a/tests/headers/no-derive-debug.h b/tests/headers/no-derive-debug.h
deleted file mode 100644
index d11ca0ad..00000000
--- a/tests/headers/no-derive-debug.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --no-derive-debug --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Default)] pub struct foo { bar: ::std::os::raw::c_int, }"
-
-struct foo {
-  int bar;
-};
-
-/**
- * bar should compile. It will normally derive debug, but our blocklist of foo
- * and replacement for another type that doesn't implement it would prevent it
- * from building if --no-derive-debug didn't work.
- */
-struct bar {
-  struct foo foo;
-  int baz;
-};
diff --git a/tests/headers/no-derive-default.h b/tests/headers/no-derive-default.h
deleted file mode 100644
index d184ee3a..00000000
--- a/tests/headers/no-derive-default.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --no-derive-default --blocklist-type foo --raw-line "#[repr(C)] #[derive(Copy, Clone, Debug)] pub struct foo { bar: ::std::os::raw::c_int, }"
-
-struct foo {
-  int bar;
-};
-
-/**
- * bar should compile. It will normally derive default, but our blocklist of foo
- * and replacement for another type that doesn't implement it would prevent it
- * from building if --no-derive-default didn't work.
- */
-struct bar {
-  struct foo foo;
-  int baz;
-};
diff --git a/tests/headers/no-hash-allowlisted.hpp b/tests/headers/no-hash-allowlisted.hpp
deleted file mode 100644
index 0f60817d..00000000
--- a/tests/headers/no-hash-allowlisted.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-hash --allowlist-type "NoHash" --no-hash "NoHash"
-
-class NoHash {
-  int i;
-};
diff --git a/tests/headers/no-hash-opaque.hpp b/tests/headers/no-hash-opaque.hpp
deleted file mode 100644
index c1db2cd1..00000000
--- a/tests/headers/no-hash-opaque.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-hash --opaque-type "NoHash" --no-hash "NoHash"
-
-class NoHash {
-  int i;
-};
diff --git a/tests/headers/no-partialeq-allowlisted.hpp b/tests/headers/no-partialeq-allowlisted.hpp
deleted file mode 100644
index ced1b42a..00000000
--- a/tests/headers/no-partialeq-allowlisted.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --allowlist-type "NoPartialEq" --no-partialeq "NoPartialEq"
-
-class NoPartialEq {
-  int i;
-};
diff --git a/tests/headers/no-partialeq-opaque.hpp b/tests/headers/no-partialeq-opaque.hpp
deleted file mode 100644
index a5a03cd2..00000000
--- a/tests/headers/no-partialeq-opaque.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-partialeq --opaque-type "NoPartialEq" --no-partialeq "NoPartialEq"
-
-class NoPartialEq {
-  int i;
-};
diff --git a/tests/headers/no-recursive-allowlisting.h b/tests/headers/no-recursive-allowlisting.h
deleted file mode 100644
index 1c661711..00000000
--- a/tests/headers/no-recursive-allowlisting.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --no-recursive-allowlist --allowlist-type "Foo" --raw-line "pub enum Bar {}" --rustified-enum ".*"
-
-struct Bar;
-
-struct Foo {
-  struct Bar* baz;
-};
diff --git a/tests/headers/no-std.h b/tests/headers/no-std.h
deleted file mode 100644
index d98abced..00000000
--- a/tests/headers/no-std.h
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --ctypes-prefix "libc" --use-core --raw-line "#![no_std]" --raw-line "mod libc { pub type c_int = i32; pub enum c_void {} }" --rustified-enum ".*"
-struct foo {
-  int a, b;
-  void* bar;
-};
diff --git a/tests/headers/no_copy.hpp b/tests/headers/no_copy.hpp
deleted file mode 100644
index 349e428e..00000000
--- a/tests/headers/no_copy.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-/** <div rustbindgen nocopy></div> */
-template<typename T>
-class CopiableButWait {
-    int whatever;
-};
diff --git a/tests/headers/no_copy_allowlisted.hpp b/tests/headers/no_copy_allowlisted.hpp
deleted file mode 100644
index f3b922ca..00000000
--- a/tests/headers/no_copy_allowlisted.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --allowlist-type "NoCopy" --no-copy "NoCopy"
-
-class NoCopy {
-  int i;
-};
diff --git a/tests/headers/no_copy_opaque.hpp b/tests/headers/no_copy_opaque.hpp
deleted file mode 100644
index c21f213a..00000000
--- a/tests/headers/no_copy_opaque.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --opaque-type "NoCopy" --no-copy "NoCopy"
-
-class NoCopy {
-  int i;
-};
diff --git a/tests/headers/no_debug.hpp b/tests/headers/no_debug.hpp
deleted file mode 100644
index 2017f75d..00000000
--- a/tests/headers/no_debug.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-/** <div rustbindgen nodebug></div> */
-template<typename T>
-class DebugButWait {
-    int whatever;
-};
diff --git a/tests/headers/no_debug_allowlisted.hpp b/tests/headers/no_debug_allowlisted.hpp
deleted file mode 100644
index 3e3633e4..00000000
--- a/tests/headers/no_debug_allowlisted.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --allowlist-type "NoDebug" --no-debug "NoDebug"
-
-class NoDebug {
-  int i;
-};
diff --git a/tests/headers/no_debug_bypass_impl_debug.hpp b/tests/headers/no_debug_bypass_impl_debug.hpp
deleted file mode 100644
index d934d2c7..00000000
--- a/tests/headers/no_debug_bypass_impl_debug.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --no-debug "NoDebug" --impl-debug --rust-target 1.40
-
-template<typename T>
-class Generic {
-  T t[40];
-};
-
-template<typename T>
-class NoDebug {
-  T t[40];
-};
diff --git a/tests/headers/no_debug_opaque.hpp b/tests/headers/no_debug_opaque.hpp
deleted file mode 100644
index d5dc18f7..00000000
--- a/tests/headers/no_debug_opaque.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --opaque-type "NoDebug" --no-debug "NoDebug"
-
-class NoDebug {
-  int i;
-};
diff --git a/tests/headers/no_default.hpp b/tests/headers/no_default.hpp
deleted file mode 100644
index 79d25fbd..00000000
--- a/tests/headers/no_default.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-
-/** <div rustbindgen nodefault></div> */
-template<typename T>
-class DefaultButWait {
-    int whatever;
-};
-
-template<typename T>
-class DefaultButWaitDerived {
-    DefaultButWait<T> whatever;
-};
diff --git a/tests/headers/no_default_allowlisted.hpp b/tests/headers/no_default_allowlisted.hpp
deleted file mode 100644
index 8a604081..00000000
--- a/tests/headers/no_default_allowlisted.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --allowlist-type "NoDefault" --no-default "NoDefault"
-
-class NoDefault {
-  int i;
-};
diff --git a/tests/headers/no_default_bypass_derive_default.hpp b/tests/headers/no_default_bypass_derive_default.hpp
deleted file mode 100644
index ab0fdfae..00000000
--- a/tests/headers/no_default_bypass_derive_default.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --no-default "NoDefault" --rust-target 1.40
-
-template<typename T>
-class Generic {
-  T t[40];
-};
-
-template<typename T>
-class NoDefault {
-  T t[40];
-};
diff --git a/tests/headers/no_default_opaque.hpp b/tests/headers/no_default_opaque.hpp
deleted file mode 100644
index 3245d8f9..00000000
--- a/tests/headers/no_default_opaque.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --opaque-type "NoDefault" --no-default "NoDefault"
-
-class NoDefault {
-  int i;
-};
diff --git a/tests/headers/no_size_t_is_usize.h b/tests/headers/no_size_t_is_usize.h
deleted file mode 100644
index d4370baf..00000000
--- a/tests/headers/no_size_t_is_usize.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --no-size_t-is-usize
-
-typedef unsigned long size_t;
-typedef long ssize_t;
-
-struct A {
-  size_t len;
-  ssize_t offset;
-  struct A* next;
-};
diff --git a/tests/headers/non-type-params.hpp b/tests/headers/non-type-params.hpp
deleted file mode 100644
index 3e2ccf8e..00000000
--- a/tests/headers/non-type-params.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T, unsigned int Capacity>
-struct Array {
-    T elements[Capacity];
-};
-
-template <typename T>
-using Array16 = Array<T, 16>;
-
-using ArrayInt4 = Array<int, 4>;
-
-struct UsesArray {
-    Array16<char>  array_char_16;
-    Array<bool, 8> array_bool_8;
-    ArrayInt4      array_int_4;
-};
diff --git a/tests/headers/noreturn.hpp b/tests/headers/noreturn.hpp
deleted file mode 100644
index 4ce1e11e..00000000
--- a/tests/headers/noreturn.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: --enable-function-attribute-detection -- -std=c++11
-_Noreturn void f(void);
-__attribute__((noreturn)) void g(void);
-[[noreturn]] void h(void);
diff --git a/tests/headers/nsBaseHashtable.hpp b/tests/headers/nsBaseHashtable.hpp
deleted file mode 100644
index 36a480f2..00000000
--- a/tests/headers/nsBaseHashtable.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-using uint32_t = unsigned long;
-using size_t = unsigned long long;
-
-template<class KeyClass, class DataType>
-class nsBaseHashtableET {
-};
-
-template<class Entry>
-class nsTHashtable {
-};
-
-template<class KeyClass, class DataType, class UserDataType>
-class nsBaseHashtable
-  : protected nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>
-{
-
-public:
-  typedef typename KeyClass::KeyType KeyType;
-  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
-
-  using nsTHashtable<EntryType>::Contains;
-  using nsTHashtable<EntryType>::GetGeneration;
-
-  nsBaseHashtable() {}
-  explicit nsBaseHashtable(uint32_t);
-
-  struct LookupResult {
-  private:
-    EntryType* mEntry;
-    nsBaseHashtable& mTable;
-
-  public:
-    LookupResult(EntryType*, nsBaseHashtable&);
-  };
-
-  struct EntryPtr {
-  private:
-    EntryType& mEntry;
-    bool mExistingEntry;
-
-  public:
-    EntryPtr(nsBaseHashtable&, EntryType*, bool);
-    ~EntryPtr();
-  };
-
-};
diff --git a/tests/headers/nsStyleAutoArray.hpp b/tests/headers/nsStyleAutoArray.hpp
deleted file mode 100644
index 3049ea21..00000000
--- a/tests/headers/nsStyleAutoArray.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-template<typename T>
-class nsTArray {
-    T* mBuff;
-};
-
-template<typename T>
-class nsStyleAutoArray
-{
-public:
-  // This constructor places a single element in mFirstElement.
-  enum WithSingleInitialElement { WITH_SINGLE_INITIAL_ELEMENT };
-  explicit nsStyleAutoArray(WithSingleInitialElement) {}
-  nsStyleAutoArray(const nsStyleAutoArray& aOther) { *this = aOther; }
-  nsStyleAutoArray& operator=(const nsStyleAutoArray& aOther) {
-    mFirstElement = aOther.mFirstElement;
-    mOtherElements = aOther.mOtherElements;
-    return *this;
-  }
-
-  bool operator==(const nsStyleAutoArray& aOther) const {
-    return Length() == aOther.Length() &&
-           mFirstElement == aOther.mFirstElement &&
-           mOtherElements == aOther.mOtherElements;
-  }
-  bool operator!=(const nsStyleAutoArray& aOther) const {
-    return !(*this == aOther);
-  }
-
-  unsigned long Length() const {
-    return mOtherElements.Length() + 1;
-  }
-  const T& operator[](unsigned long aIndex) const {
-    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
-  }
-  T& operator[](unsigned long aIndex) {
-    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
-  }
-
-  void EnsureLengthAtLeast(unsigned long aMinLen) {
-    if (aMinLen > 0) {
-      mOtherElements.EnsureLengthAtLeast(aMinLen - 1);
-    }
-  }
-
-  void SetLengthNonZero(unsigned long aNewLen) {
-    mOtherElements.SetLength(aNewLen - 1);
-  }
-
-  void TruncateLengthNonZero(unsigned long aNewLen) {
-    mOtherElements.TruncateLength(aNewLen - 1);
-  }
-
-private:
-  T mFirstElement;
-  nsTArray<T> mOtherElements;
-};
diff --git a/tests/headers/objc_allowlist.h b/tests/headers/objc_allowlist.h
deleted file mode 100644
index b5406d0a..00000000
--- a/tests/headers/objc_allowlist.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// bindgen-flags: --allowlist-type IAllowlistMe --allowlist-type AllowlistMe_InterestingCategory -- -x objective-c
-// bindgen-osx-only
-
-
-// Protocol should be included, since it is used by the AllowlistMe
-@protocol SomeProtocol
--(void)protocolMethod;
-+(void)protocolClassMethod;
-@end
-
-// The allowlisted item
-@interface AllowlistMe <SomeProtocol>
--(void)method;
-+(void)classMethod;
-@end
-
-// This was also explicitly allowlisted
-@interface AllowlistMe (InterestingCategory)
-@end
-
-// This was not automatically allowlisted
-@interface AllowlistMe (IgnoredCategory)
-@end
-
diff --git a/tests/headers/objc_blocklist.h b/tests/headers/objc_blocklist.h
deleted file mode 100644
index 605f2993..00000000
--- a/tests/headers/objc_blocklist.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --objc-extern-crate --blocklist-item ISomeClass::class_ambiguouslyBlockedMethod --blocklist-item ISomeClass::blockedInstanceMethod -- -x objective-c
-// bindgen-osx-only
-
-@interface SomeClass
-+ (void)ambiguouslyBlockedMethod;
-- (void)ambiguouslyBlockedMethod;
-- (void)instanceMethod;
-- (void)blockedInstanceMethod;
-@end
diff --git a/tests/headers/objc_category.h b/tests/headers/objc_category.h
deleted file mode 100644
index b8e60d5f..00000000
--- a/tests/headers/objc_category.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
--(void)method;
-@end
-
-@interface Foo (BarCategory)
--(void)categoryMethod;
-@end
diff --git a/tests/headers/objc_class.h b/tests/headers/objc_class.h
deleted file mode 100644
index f5ec9507..00000000
--- a/tests/headers/objc_class.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@class Foo;
-
-Foo* fooVar;
-
-@interface Foo
--(void)method;
-@end
diff --git a/tests/headers/objc_class_method.h b/tests/headers/objc_class_method.h
deleted file mode 100644
index 1a68ed3e..00000000
--- a/tests/headers/objc_class_method.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-+ (void)method;
-+ (void)methodWithInt:(int)foo;
-+ (void)methodWithFoo:(Foo*)foo;
-+ (int)methodReturningInt;
-+ (Foo*)methodReturningFoo;
-+ (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue;
-@end
diff --git a/tests/headers/objc_inheritance.h b/tests/headers/objc_inheritance.h
deleted file mode 100644
index 985f1597..00000000
--- a/tests/headers/objc_inheritance.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-@end
-
-@interface Bar: Foo
-@end
-
-@interface Baz: Bar
-@end
diff --git a/tests/headers/objc_interface.h b/tests/headers/objc_interface.h
deleted file mode 100644
index df16e921..00000000
--- a/tests/headers/objc_interface.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-@end
-
-@protocol bar
-@end
diff --git a/tests/headers/objc_interface_type.h b/tests/headers/objc_interface_type.h
deleted file mode 100644
index 4667ce2a..00000000
--- a/tests/headers/objc_interface_type.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-@end
-
-struct FooStruct {
-  Foo *foo;
-};
-
-void fooFunc(Foo *foo);
-
-static const Foo *kFoo;
diff --git a/tests/headers/objc_method.h b/tests/headers/objc_method.h
deleted file mode 100644
index b89d1621..00000000
--- a/tests/headers/objc_method.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-- (void)method;
-- (void)methodWithInt:(int)foo;
-- (void)methodWithFoo:(Foo*)foo;
-- (int)methodReturningInt;
-- (Foo*)methodReturningFoo;
-- (void)methodWithArg1:(int)intvalue andArg2:(char*)ptr andArg3:(float)floatvalue;
-- (instancetype)methodWithAndWithoutKeywords:(int)arg1
-                                    arg2Name:(float)arg2
-                                            :(float)arg3
-                                    arg4Name:(int)arg4;
-@end
diff --git a/tests/headers/objc_method_clash.h b/tests/headers/objc_method_clash.h
deleted file mode 100644
index d99d3691..00000000
--- a/tests/headers/objc_method_clash.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-+ (void)foo;
-- (void)foo;
-@end
diff --git a/tests/headers/objc_pointer_return_types.h b/tests/headers/objc_pointer_return_types.h
deleted file mode 100644
index 4d1a6dea..00000000
--- a/tests/headers/objc_pointer_return_types.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Bar
-@end
-
-@interface Foo
-+ (Bar*)methodReturningBar;
-- (void)methodUsingBar:(Bar *)my_bar;
-@end
diff --git a/tests/headers/objc_property_fnptr.h b/tests/headers/objc_property_fnptr.h
deleted file mode 100644
index fe3e7fcc..00000000
--- a/tests/headers/objc_property_fnptr.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo
-@property int (*func)(char, short, float);
-@end
diff --git a/tests/headers/objc_protocol.h b/tests/headers/objc_protocol.h
deleted file mode 100644
index 46978a3b..00000000
--- a/tests/headers/objc_protocol.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@protocol Foo
-@end
-
-@interface Foo <Foo>
-@end
diff --git a/tests/headers/objc_protocol_inheritance.h b/tests/headers/objc_protocol_inheritance.h
deleted file mode 100644
index 13135fdd..00000000
--- a/tests/headers/objc_protocol_inheritance.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@protocol Foo
-@end
-
-@interface Foo <Foo>
-@end
-
-@interface Bar : Foo
-@end
diff --git a/tests/headers/objc_sel_and_id.h b/tests/headers/objc_sel_and_id.h
deleted file mode 100644
index 6491a541..00000000
--- a/tests/headers/objc_sel_and_id.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-id object;
-SEL selector;
-
-void f(id object, SEL selector);
diff --git a/tests/headers/objc_template.h b/tests/headers/objc_template.h
deleted file mode 100644
index b616da01..00000000
--- a/tests/headers/objc_template.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -x objective-c
-// bindgen-osx-only
-
-@interface Foo<__covariant ObjectType>
-- (ObjectType)get;
-@end
-
-@interface FooMultiGeneric<__covariant KeyType, __covariant ObjectType>
-- (nullable ObjectType)objectForKey:(KeyType)key;
-@end
diff --git a/tests/headers/only_bitfields.hpp b/tests/headers/only_bitfields.hpp
deleted file mode 100644
index 793bc66b..00000000
--- a/tests/headers/only_bitfields.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-class C {
-    bool a: 1;
-    bool b: 7;
-};
diff --git a/tests/headers/opaque-template-inst-member-2.hpp b/tests/headers/opaque-template-inst-member-2.hpp
deleted file mode 100644
index 85b648ff..00000000
--- a/tests/headers/opaque-template-inst-member-2.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-/// This is like `opaque-template-inst-member.hpp` except exercising the cases
-/// where we are OK to derive Debug/Hash/PartialEq.
-
-template<typename T>
-class OpaqueTemplate {
-    T mData;
-};
-
-/// Should derive Debug/Hash/PartialEq.
-class ContainsOpaqueTemplate {
-    OpaqueTemplate<int> mBlah;
-    int mBaz;
-};
-
-/// Should also derive Debug/Hash/PartialEq.
-class InheritsOpaqueTemplate : public OpaqueTemplate<bool> {
-    char* wow;
-};
diff --git a/tests/headers/opaque-template-inst-member.hpp b/tests/headers/opaque-template-inst-member.hpp
deleted file mode 100644
index 9b327919..00000000
--- a/tests/headers/opaque-template-inst-member.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// bindgen-flags: --opaque-type 'OpaqueTemplate' --with-derive-hash --with-derive-partialeq --impl-partialeq --with-derive-eq --rust-target 1.40
-
-template<typename T>
-class OpaqueTemplate {
-    T mData;
-    bool mCannotDebug[400];
-};
-
-/// This should not end up deriving Debug/Hash because its `mBlah` field cannot derive
-/// Debug/Hash because the instantiation's definition cannot derive Debug/Hash.
-class ContainsOpaqueTemplate {
-    OpaqueTemplate<int> mBlah;
-    int mBaz;
-};
-
-/// This should not end up deriving Debug/Hash either, for similar reasons, although
-/// we're exercising base member edges now.
-class InheritsOpaqueTemplate : public OpaqueTemplate<bool> {
-    char* wow;
-};
diff --git a/tests/headers/opaque-template-instantiation-namespaced.hpp b/tests/headers/opaque-template-instantiation-namespaced.hpp
deleted file mode 100644
index e1cadcc2..00000000
--- a/tests/headers/opaque-template-instantiation-namespaced.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces --opaque-type 'zoidberg::Template<zoidberg::Bar>'  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
-
-namespace zoidberg {
-
-template <typename T>
-class Template {
-    T member;
-};
-
-struct Foo {
-    char c;
-};
-
-struct Bar {
-    int i;
-};
-
-class ContainsInstantiation {
-    Template<Foo> not_opaque;
-};
-
-class ContainsOpaqueInstantiation {
-    // We should not generate a layout test for this instantiation, and it
-    // should appear as an opaque blob of bytes in
-    // `ContainsOpaqueInstantiation`'s type definition.
-    Template<Bar> opaque;
-};
-
-}
diff --git a/tests/headers/opaque-template-instantiation.hpp b/tests/headers/opaque-template-instantiation.hpp
deleted file mode 100644
index fff49af2..00000000
--- a/tests/headers/opaque-template-instantiation.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --opaque-type 'Template<int>'  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
-
-template <typename T>
-class Template {
-    T member;
-};
-
-class ContainsInstantiation {
-    Template<char> not_opaque;
-};
-
-class ContainsOpaqueInstantiation {
-    // We should not generate a layout test for this instantiation, and it
-    // should appear as an opaque blob of bytes in
-    // `ContainsOpaqueInstantiation`'s type definition.
-    Template<int> opaque;
-};
diff --git a/tests/headers/opaque-tracing.hpp b/tests/headers/opaque-tracing.hpp
deleted file mode 100644
index cf65276a..00000000
--- a/tests/headers/opaque-tracing.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --opaque-type ".*" --allowlist-function=foo  --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-class Container;
-
-// The allowlist tracing should reach the Container type, even though it's
-// marked as opaque.
-void foo(Container* c);
-
-template<typename T>
-class Wat {
-  T foo;
-};
-
-class OtherOpaque {
-  int bar;
-};
-
-class Container {
-  Wat<int> bar;
-  OtherOpaque baz;
-};
diff --git a/tests/headers/opaque_in_struct.hpp b/tests/headers/opaque_in_struct.hpp
deleted file mode 100644
index 12910e1f..00000000
--- a/tests/headers/opaque_in_struct.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-
-/** <div rustbindgen opaque> */
-typedef struct opaque {
-    int waht;
-} opaque;
-
-struct container {
-    opaque contained;
-};
diff --git a/tests/headers/opaque_pointer.hpp b/tests/headers/opaque_pointer.hpp
deleted file mode 100644
index 00868985..00000000
--- a/tests/headers/opaque_pointer.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-/**
- * <div rustbindgen opaque></div>
- */
-struct OtherOpaque {
-    int c;
-};
-
-/**
- * <div rustbindgen opaque></div>
- */
-template <typename T>
-struct Opaque {
-    T whatever;
-};
-
-struct WithOpaquePtr {
-    Opaque<int>* whatever;
-    Opaque<float> other;
-    OtherOpaque t;
-};
-
diff --git a/tests/headers/opaque_typedef.hpp b/tests/headers/opaque_typedef.hpp
deleted file mode 100644
index 878d5bcb..00000000
--- a/tests/headers/opaque_typedef.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags:  --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
-template<typename T>
-class RandomTemplate;
-
-template<int i>
-class Wat;
-
-template<int i>
-class Wat3;
-
-template<>
-class Wat3<3>;
-
-/** <div rustbindgen opaque></div> */
-typedef RandomTemplate<int> ShouldBeOpaque;
-
-typedef RandomTemplate<float> ShouldNotBeOpaque;
diff --git a/tests/headers/operator.hpp b/tests/headers/operator.hpp
deleted file mode 100644
index 186f1fe6..00000000
--- a/tests/headers/operator.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-int operator_information(void);
-
-class Foo;
-int operator<<(const Foo&, int);
-
diff --git a/tests/headers/ord-enum.h b/tests/headers/ord-enum.h
deleted file mode 100644
index 364f711e..00000000
--- a/tests/headers/ord-enum.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// bindgen-flags: --rustified-enum * --with-derive-ord
-
-enum A {
-	A0 = 0,
-	A1 = 1,
-	A2 = 2,
-	A3 = A0 - 1,
-};
-
-enum B {
-	B0 = 1,
-	B1 = B0 + 3,
-	B2 = B0 + 2,
-	B3 = B0 - 2,
-};
\ No newline at end of file
diff --git a/tests/headers/overflowed_enum.hpp b/tests/headers/overflowed_enum.hpp
deleted file mode 100644
index 18d3fe41..00000000
--- a/tests/headers/overflowed_enum.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -Wno-narrowing
-
-enum Foo {
-    BAP_ARM = 0x93fcb9,
-    BAP_X86 = 0xb67eed,
-    BAP_X86_64 = 0xba7b274f,
-};
-
-enum Bar: unsigned short {
-    One = 1,
-    Big = 65538,
-};
diff --git a/tests/headers/overloading.hpp b/tests/headers/overloading.hpp
deleted file mode 100644
index 3c2b0487..00000000
--- a/tests/headers/overloading.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-extern bool Evaluate(char r);
-extern bool Evaluate(int x, int y);
-
-namespace foo {
-    extern void MyFunction();
-}
-namespace bar {
-    extern void MyFunction();
-}
diff --git a/tests/headers/packed-bitfield.h b/tests/headers/packed-bitfield.h
deleted file mode 100644
index ef23bc6a..00000000
--- a/tests/headers/packed-bitfield.h
+++ /dev/null
@@ -1,5 +0,0 @@
-struct Date {
-    unsigned char day: 5;
-    unsigned char month: 4;
-    signed short year: 15;
-} __attribute__((packed));
diff --git a/tests/headers/packed-n-with-padding.h b/tests/headers/packed-n-with-padding.h
deleted file mode 100644
index 8a6233b5..00000000
--- a/tests/headers/packed-n-with-padding.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma pack(push, 2)
-struct Packed {
-    char a;
-    short b;
-    char c;
-    int d;
-};
-#pragma pack(pop)
diff --git a/tests/headers/packed-vtable.h b/tests/headers/packed-vtable.h
deleted file mode 100644
index d2413d45..00000000
--- a/tests/headers/packed-vtable.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.33 -- -x c++ -std=c++11
-
-#pragma pack(1)
-
-// This should be packed.
-struct PackedVtable {
-  virtual ~PackedVtable();
-};
-
-#pragma pack()
diff --git a/tests/headers/parm-union.hpp b/tests/headers/parm-union.hpp
deleted file mode 100644
index e36df691..00000000
--- a/tests/headers/parm-union.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-struct Struct
-{
-    void Function(union Union&);
-};
diff --git a/tests/headers/parsecb-anonymous-enum-variant-rename.h b/tests/headers/parsecb-anonymous-enum-variant-rename.h
deleted file mode 100644
index 9336cf89..00000000
--- a/tests/headers/parsecb-anonymous-enum-variant-rename.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --allowlist-var ^MyVal$
-// bindgen-parse-callbacks: enum-variant-rename
-
-enum {
-    MyVal = 0,
-};
diff --git a/tests/headers/partial-specialization-and-inheritance.hpp b/tests/headers/partial-specialization-and-inheritance.hpp
deleted file mode 100644
index 4eb8f545..00000000
--- a/tests/headers/partial-specialization-and-inheritance.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// bindgen-unstable
-
-// This was originally a test case generated by creducing errors in SpiderMonkey
-// bindings generation. I've tried to make it understandable by giving more
-// meaningful names to everything, and a couple comments.
-//
-// We don't support partial template specialization, but we *should*
-// successfully parse this header, and generate bindings for it, but the usage
-// of the partial template specialization should result in opaque blobs.
-
-// A base class providing a method.
-template <typename T>
-class Base {
-public:
-  void some_method(T, T);
-};
-
-// A template with a default representation.
-template <typename U>
-class Derived {
-    bool b;
-};
-
-// A partial specialization for pointers. Note that this should have a different
-// and larger layout than the template it is specializing.
-template <typename U>
-class Derived<U*> : public Base<U*> {
-    int x;
-    int y;
-};
-
-// A struct that uses the partial specialization and method from the partial
-// specialization's base class.
-struct Usage {
-  Usage() {
-      static_member.some_method(this, this);
-  }
-
-  static Derived<Usage*> static_member;
-};
diff --git a/tests/headers/pointer-attr.h b/tests/headers/pointer-attr.h
deleted file mode 100644
index fe0004b8..00000000
--- a/tests/headers/pointer-attr.h
+++ /dev/null
@@ -1 +0,0 @@
-void a(const char __attribute__((btf_type_tag("a"))) *);
diff --git a/tests/headers/prepend-enum-constified-variant.h b/tests/headers/prepend-enum-constified-variant.h
deleted file mode 100644
index e9ba0e73..00000000
--- a/tests/headers/prepend-enum-constified-variant.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --no-prepend-enum-name --rustified-enum ".*"
-
-enum AVCodecID {
-  AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,
-  AV_CODEC_ID_TTF = 0x18000,
-};
diff --git a/tests/headers/prepend_enum_name.hpp b/tests/headers/prepend_enum_name.hpp
deleted file mode 100644
index e7660369..00000000
--- a/tests/headers/prepend_enum_name.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --no-prepend-enum-name
-
-enum foo {
-	FOO_BAR,
-	FOO_BAZ,
-};
diff --git a/tests/headers/private.hpp b/tests/headers/private.hpp
deleted file mode 100644
index c0f3ce7f..00000000
--- a/tests/headers/private.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-
-struct HasPrivate {
-    int mNotPrivate;
-    /** <div rustbindgen private></div> */
-    int mIsPrivate;
-};
-
-
-/** <div rustbindgen private></div> */
-struct VeryPrivate {
-    int mIsPrivate;
-    int mIsAlsoPrivate;
-};
-
-
-/** <div rustbindgen private></div> */
-struct ContradictPrivate {
-    /** <div rustbindgen private="false"></div> */
-    int mNotPrivate;
-    int mIsPrivate;
-};
diff --git a/tests/headers/private_fields.hpp b/tests/headers/private_fields.hpp
deleted file mode 100644
index 9d55ebca..00000000
--- a/tests/headers/private_fields.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// bindgen-flags: --respect-cxx-access-specs
-class PubPriv {
-  public:
-    int x;
-  private:
-    int y;
-};
-
-class PrivateBitFields {
-  unsigned int a : 4;
-  unsigned int b : 4;
-};
-class PublicBitFields {
- public:
-  unsigned int a : 4;
-  unsigned int b : 4;
-};
-class MixedBitFields {
-  unsigned int a : 4;
- public:
-  unsigned int d : 4;
-};
-
-class Base {
- public:
-  int member;
-};
-
-class InheritsPrivately : Base {};
-class InheritsPublically : public Base {};
-
-class WithAnonStruct {
-  struct {
-     int a;
-  };
- public:
-  struct {
-    int b;
-  };
-};
-
-class WithAnonUnion {
-  union {};
-};
\ No newline at end of file
diff --git a/tests/headers/public-dtor.hpp b/tests/headers/public-dtor.hpp
deleted file mode 100644
index 5d4fb592..00000000
--- a/tests/headers/public-dtor.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-namespace cv {
-class String {
-public:
-  ~String();
-};
-
-
-inline
-String::~String()
-{
-}
-
-}
diff --git a/tests/headers/qualified-dependent-types.hpp b/tests/headers/qualified-dependent-types.hpp
deleted file mode 100644
index fcdfc87c..00000000
--- a/tests/headers/qualified-dependent-types.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// Issue #2085.
-
-template<typename T>
-struct Foo;
-
-template<typename T, typename U>
-struct Bar {};
-
-template<typename T>
-struct Bar<T, void> {
-    using BarDependent = typename Foo<T>::Dependent;
-    void method(const BarDependent &);
-};
-
-template<typename T>
-void Bar<T, void>::method(const BarDependent &) {}
diff --git a/tests/headers/redeclaration.hpp b/tests/headers/redeclaration.hpp
deleted file mode 100644
index d536b158..00000000
--- a/tests/headers/redeclaration.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-extern "C" {
-  void foo();
-}
-
-extern "C" {
-  void foo();
-}
diff --git a/tests/headers/ref_argument_array.hpp b/tests/headers/ref_argument_array.hpp
deleted file mode 100644
index 53f66950..00000000
--- a/tests/headers/ref_argument_array.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-#define NSID_LENGTH 10
-class nsID {
-public:
-  virtual void ToProvidedString(char (&aDest)[NSID_LENGTH]);
-};
diff --git a/tests/headers/reparented_replacement.hpp b/tests/headers/reparented_replacement.hpp
deleted file mode 100644
index 4ac2bf03..00000000
--- a/tests/headers/reparented_replacement.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-namespace foo {
-  struct Bar {
-    int baz;
-  };
-}
-
-namespace bar {
-  /// <div rustbindgen replaces="foo::Bar"></div>
-  struct Bar_Replacement {
-    int bazz;
-  };
-};
-
-typedef foo::Bar ReferencesBar;
diff --git a/tests/headers/replace_template_alias.hpp b/tests/headers/replace_template_alias.hpp
deleted file mode 100644
index c325b5a3..00000000
--- a/tests/headers/replace_template_alias.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// bindgen-flags: -- --std=c++14
-
-namespace JS {
-namespace detail {
-
-/// Notice how this doesn't use T.
-template <typename T>
-using MaybeWrapped = int;
-
-}
-
-template <typename T>
-class Rooted {
-    detail::MaybeWrapped<T> ptr;
-};
-
-}
-
-/// But the replacement type does use T!
-///
-/// <div rustbindgen replaces="JS::detail::MaybeWrapped" />
-template <typename T>
-using replaces_MaybeWrapped = T;
diff --git a/tests/headers/replace_use.hpp b/tests/headers/replace_use.hpp
deleted file mode 100644
index de44eb19..00000000
--- a/tests/headers/replace_use.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-template<typename T>
-struct nsTArray {
-  int x;
-};
-/**
- * <div rustbindgen replaces="nsTArray"></div>
- */
-template<typename T>
-struct nsTArray_Simple {
-  unsigned int y;
-};
-
-struct Test {
-  nsTArray<long> a;
-};
diff --git a/tests/headers/replaces_double.hpp b/tests/headers/replaces_double.hpp
deleted file mode 100644
index ce6a8dbb..00000000
--- a/tests/headers/replaces_double.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// bindgen-flags: --blocklist-type Wrapper -- --std=c++11
-
-template<typename T>
-struct Wrapper {
-    struct Wrapped {
-        T t;
-    };
-    using Type = Wrapped;
-};
-
-template<typename T>
-class Rooted {
-    using MaybeWrapped = typename Wrapper<T>::Type;
-    MaybeWrapped ptr;
-
-    /**
-     * <div rustbindgen replaces="Rooted_MaybeWrapped"></div>
-     */
-    using MaybeWrapped_simple = T;
-};
diff --git a/tests/headers/repr-align.hpp b/tests/headers/repr-align.hpp
deleted file mode 100644
index 3347594b..00000000
--- a/tests/headers/repr-align.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --raw-line '#![cfg(feature = "nightly")]' --rust-target 1.25 -- -std=c++11
-
-struct alignas(8) a {
-  int b;
-  int c;
-};
-
-struct alignas(double) b {
-  int b;
-  int c;
-};
diff --git a/tests/headers/resolved_type_def_function.h b/tests/headers/resolved_type_def_function.h
deleted file mode 100644
index 139b8c3e..00000000
--- a/tests/headers/resolved_type_def_function.h
+++ /dev/null
@@ -1,2 +0,0 @@
-typedef void (FuncType) ();
-extern FuncType Func;
\ No newline at end of file
diff --git a/tests/headers/same_struct_name_in_different_namespaces.hpp b/tests/headers/same_struct_name_in_different_namespaces.hpp
deleted file mode 100644
index fe685845..00000000
--- a/tests/headers/same_struct_name_in_different_namespaces.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace JS {
-
-    struct Zone;
-
-    namespace shadow {
-
-        struct Zone {
-            int x;
-            int y;
-        };
-    }
-}
diff --git a/tests/headers/sentry-defined-multiple-times.hpp b/tests/headers/sentry-defined-multiple-times.hpp
deleted file mode 100644
index d44837d0..00000000
--- a/tests/headers/sentry-defined-multiple-times.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces -- -std=c++11
-
-// `Wrapper::sentry` and `sentry` should be emitted as `Wrapper_sentry` and
-// `sentry` respectively, but instead `Wrapper::sentry` is named just `sentry`
-// which leads to compilation errors.
-//
-// Note: if there is no namespace, then we don't run into problems. Similarly,
-// making the `Wrapper::sentry` definition inline in `Wrapper`, rather than
-// declared inline with an out of line definition, makes the problem go away as
-// well.
-
-namespace whatever {
-    template <typename, typename>
-    class Wrapper {
-        // Declaration of Wrapper::sentry
-        class sentry;
-    };
-
-    // Definition of Wrapper::sentry
-    template <typename f, typename h>
-    class Wrapper<f, h>::sentry {
-        int i_am_wrapper_sentry;
-    };
-
-    class sentry {
-        bool i_am_plain_sentry;
-    };
-
-    // Ok, that was the original bug report. While we're here, let's just try
-    // lots of different things that could go wrong and make sure we handle them
-    // right.
-
-    class NotTemplateWrapper {
-        class sentry;
-    };
-
-    class NotTemplateWrapper::sentry {
-        char i_am_not_template_wrapper_sentry;
-    };
-
-    class InlineNotTemplateWrapper {
-        class sentry {
-            bool i_am_inline_not_template_wrapper_sentry;
-        };
-    };
-
-    template <typename, typename>
-    class InlineTemplateWrapper {
-        class sentry {
-            int i_am_inline_template_wrapper_sentry;
-        };
-    };
-
-    class OuterDoubleWrapper {
-        class InnerDoubleWrapper {
-            class sentry;
-        };
-    };
-
-    class OuterDoubleWrapper::InnerDoubleWrapper::sentry {
-        int i_am_double_wrapper_sentry;
-    };
-
-    class OuterDoubleInlineWrapper {
-        class InnerDoubleInlineWrapper {
-            class sentry {
-                int i_am_double_wrapper_inline_sentry;
-            };
-        };
-    };
-}
-
-template <typename, typename>
-class OutsideNamespaceWrapper {
-    class sentry;
-};
-
-template <typename f, typename h>
-class OutsideNamespaceWrapper<f, h>::sentry {
-    int i_am_outside_namespace_wrapper_sentry;
-};
-
-class sentry {
-    int i_am_outside_namespace_sentry;
-};
diff --git a/tests/headers/short-enums.hpp b/tests/headers/short-enums.hpp
deleted file mode 100644
index 14f833de..00000000
--- a/tests/headers/short-enums.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: --rustified-enum ".*" -- -std=c++11 -fshort-enums
-
-typedef enum {
-    SOME_VALUE = 0x1,
-} one_byte_t;
-
-static_assert(sizeof(one_byte_t) == 1, "Short enums should work");
-
-typedef enum {
-    SOME_OTHER_VALUE = 0x100,
-} two_byte_t;
-
-static_assert(sizeof(two_byte_t) == 2, "");
-
-typedef enum {
-    SOME_BIGGER_VALUE = 0x1000000,
-} four_byte_t;
-
-static_assert(sizeof(four_byte_t) == 4, "");
diff --git a/tests/headers/size_t_template.hpp b/tests/headers/size_t_template.hpp
deleted file mode 100644
index 6045c698..00000000
--- a/tests/headers/size_t_template.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-template<typename T, unsigned long N>
-class Array {
-    T inner[N];
-};
-
-class C {
-    Array<int, 3> arr;
-};
diff --git a/tests/headers/sorted-items.h b/tests/headers/sorted-items.h
deleted file mode 100644
index 11fc2ef4..00000000
--- a/tests/headers/sorted-items.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --sort-semantically -- --target=x86_64-unknown-linux
-
-int foo();
-typedef int number;
-int bar(number x);
-struct Point
-{
-    number x;
-    number y;
-};
-struct Angle
-{
-    number a;
-    number b;
-};
-int baz(struct Point point);
-const number NUMBER = 42;
diff --git a/tests/headers/stdint_typedef.h b/tests/headers/stdint_typedef.h
deleted file mode 100644
index f716a7f1..00000000
--- a/tests/headers/stdint_typedef.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --allowlist-type="Struct" --allowlist-function="fun"
-
-// no typedef should be emitted for `__uint64_t`
-typedef unsigned long long __uint64_t;
-typedef __uint64_t uint64_t;
-
-uint64_t fun();
-struct Struct {
-	uint64_t field;
-};
diff --git a/tests/headers/struct_containing_forward_declared_struct.h b/tests/headers/struct_containing_forward_declared_struct.h
deleted file mode 100644
index cf7cb5c4..00000000
--- a/tests/headers/struct_containing_forward_declared_struct.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct a {
-    struct b* val_a;
-};
-
-struct b {
-    int val_b;
-};
diff --git a/tests/headers/struct_typedef.h b/tests/headers/struct_typedef.h
deleted file mode 100644
index 2ed7aabd..00000000
--- a/tests/headers/struct_typedef.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rustified-enum ".*"
-//
-typedef struct {
-    _Bool has_name;
-} typedef_named_struct;
-
-typedef struct {
-    void *no_name;
-} *struct_ptr_t, **struct_ptr_ptr_t;
-
-typedef enum {
-    ENUM_HAS_NAME=1
-} typedef_named_enum;
-
-typedef enum {
-    ENUM_IS_ANON
-} *enum_ptr_t, **enum_ptr_ptr_t;
diff --git a/tests/headers/struct_typedef_ns.hpp b/tests/headers/struct_typedef_ns.hpp
deleted file mode 100644
index 40a7c680..00000000
--- a/tests/headers/struct_typedef_ns.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces --rustified-enum ".*"
-
-namespace whatever {
-    typedef struct {
-        int foo;
-    } typedef_struct;
-
-    typedef enum {
-        BAR=1
-    } typedef_enum;
-}
-
-namespace {
-    typedef struct {
-        int foo;
-    } typedef_struct;
-
-    typedef enum {
-        BAR=1
-    } typedef_enum;
-}
diff --git a/tests/headers/struct_with_anon_struct.h b/tests/headers/struct_with_anon_struct.h
deleted file mode 100644
index a5e8476d..00000000
--- a/tests/headers/struct_with_anon_struct.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct foo {
-    struct {
-        int a;
-        int b;
-    } bar;
-};
diff --git a/tests/headers/struct_with_anon_struct_array.h b/tests/headers/struct_with_anon_struct_array.h
deleted file mode 100644
index 94a8ea0a..00000000
--- a/tests/headers/struct_with_anon_struct_array.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct foo {
-    struct {
-        int a;
-        int b;
-    } bar[2];
-    struct {
-        int a;
-        int b;
-    } baz[2][3][4];
-};
diff --git a/tests/headers/struct_with_anon_struct_pointer.h b/tests/headers/struct_with_anon_struct_pointer.h
deleted file mode 100644
index d92c8011..00000000
--- a/tests/headers/struct_with_anon_struct_pointer.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct foo {
-    struct {
-        int a;
-        int b;
-    } *bar;
-};
diff --git a/tests/headers/struct_with_anon_union.h b/tests/headers/struct_with_anon_union.h
deleted file mode 100644
index bd75563d..00000000
--- a/tests/headers/struct_with_anon_union.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    } bar;
-};
diff --git a/tests/headers/struct_with_anon_union_1_0.h b/tests/headers/struct_with_anon_union_1_0.h
deleted file mode 100644
index 847c354b..00000000
--- a/tests/headers/struct_with_anon_union_1_0.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    } bar;
-};
diff --git a/tests/headers/struct_with_anon_unnamed_struct.h b/tests/headers/struct_with_anon_unnamed_struct.h
deleted file mode 100644
index 92705238..00000000
--- a/tests/headers/struct_with_anon_unnamed_struct.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct foo {
-    struct {
-        unsigned int a;
-        unsigned int b;
-    };
-};
diff --git a/tests/headers/struct_with_anon_unnamed_union.h b/tests/headers/struct_with_anon_unnamed_union.h
deleted file mode 100644
index 00fa4900..00000000
--- a/tests/headers/struct_with_anon_unnamed_union.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    };
-};
diff --git a/tests/headers/struct_with_anon_unnamed_union_1_0.h b/tests/headers/struct_with_anon_unnamed_union_1_0.h
deleted file mode 100644
index 791a1593..00000000
--- a/tests/headers/struct_with_anon_unnamed_union_1_0.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    };
-};
diff --git a/tests/headers/struct_with_bitfields.h b/tests/headers/struct_with_bitfields.h
deleted file mode 100644
index ba1af26d..00000000
--- a/tests/headers/struct_with_bitfields.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct bitfield {
-    unsigned short
-    a   :1,
-    b   :1,
-    c   :1,
-        :1,
-        :2,
-    d   :2;
-    int e;
-    unsigned int f : 2;
-    unsigned int g : 32;
-};
diff --git a/tests/headers/struct_with_derive_debug.h b/tests/headers/struct_with_derive_debug.h
deleted file mode 100644
index 4dc816b7..00000000
--- a/tests/headers/struct_with_derive_debug.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rust-target 1.40
-//
-struct LittleArray {
-    int a[32];
-};
-
-struct BigArray{
-    int a[33];
-};
-
-struct WithLittleArray {
-    struct LittleArray a;
-};
-
-struct WithBigArray {
-    struct BigArray a;
-};
diff --git a/tests/headers/struct_with_large_array.hpp b/tests/headers/struct_with_large_array.hpp
deleted file mode 100644
index 974ca526..00000000
--- a/tests/headers/struct_with_large_array.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --rust-target 1.40
-//
-struct S {
-    char large_array[33];
-};
-
-template<typename T> struct ST {
-    T large_array[33];
-};
diff --git a/tests/headers/struct_with_nesting.h b/tests/headers/struct_with_nesting.h
deleted file mode 100644
index ac902b44..00000000
--- a/tests/headers/struct_with_nesting.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct foo {
-    unsigned int a;
-    union {
-        unsigned int b;
-        struct {
-            unsigned short c1;
-            unsigned short c2;
-        };
-
-        struct {
-            unsigned char d1;
-            unsigned char d2;
-            unsigned char d3;
-            unsigned char d4;
-        };
-    };
-};
diff --git a/tests/headers/struct_with_nesting_1_0.h b/tests/headers/struct_with_nesting_1_0.h
deleted file mode 100644
index a24ae1db..00000000
--- a/tests/headers/struct_with_nesting_1_0.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct foo {
-    unsigned int a;
-    union {
-        unsigned int b;
-        struct {
-            unsigned short c1;
-            unsigned short c2;
-        };
-
-        struct {
-            unsigned char d1;
-            unsigned char d2;
-            unsigned char d3;
-            unsigned char d4;
-        };
-    };
-};
diff --git a/tests/headers/struct_with_packing.h b/tests/headers/struct_with_packing.h
deleted file mode 100644
index 9ed50317..00000000
--- a/tests/headers/struct_with_packing.h
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct a {
-    char b;
-    short c;
-} __attribute__((packed));
diff --git a/tests/headers/struct_with_struct.h b/tests/headers/struct_with_struct.h
deleted file mode 100644
index 1a178074..00000000
--- a/tests/headers/struct_with_struct.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-struct foo {
-    struct {
-        unsigned int x;
-        unsigned int y;
-    } bar;
-};
diff --git a/tests/headers/struct_with_typedef_template_arg.hpp b/tests/headers/struct_with_typedef_template_arg.hpp
deleted file mode 100644
index ec1b55aa..00000000
--- a/tests/headers/struct_with_typedef_template_arg.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-template<typename T, typename ...Args>
-struct Proxy {
-  typedef void (*foo)(T* bar);
-};
diff --git a/tests/headers/template-fun-ty.hpp b/tests/headers/template-fun-ty.hpp
deleted file mode 100644
index bb9d23cf..00000000
--- a/tests/headers/template-fun-ty.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-template <typename T>
-class Foo
-{
-  typedef T (FunctionPtr)();
-};
-
-template<typename T>
-class RefPtr {
-  template<typename R, typename... Args>
-  class Proxy {
-    typedef R (T::*member_function)(Args...);
-  };
-};
-
-template<typename T>
-using Returner = T(*)();
diff --git a/tests/headers/template-param-usage-0.hpp b/tests/headers/template-param-usage-0.hpp
deleted file mode 100644
index 57c11a10..00000000
--- a/tests/headers/template-param-usage-0.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class UsesTemplateParameter {
-    T t;
-};
diff --git a/tests/headers/template-param-usage-1.hpp b/tests/headers/template-param-usage-1.hpp
deleted file mode 100644
index dba41489..00000000
--- a/tests/headers/template-param-usage-1.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class DoesNotUseTemplateParameter {
-    int x;
-};
diff --git a/tests/headers/template-param-usage-10.hpp b/tests/headers/template-param-usage-10.hpp
deleted file mode 100644
index a6f3ccd8..00000000
--- a/tests/headers/template-param-usage-10.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T, typename U, typename NeverUsed>
-class DoublyIndirectUsage {
-    using Aliased = T;
-    typedef U Typedefed;
-
-    class IndirectUsage {
-        Aliased member;
-        Typedefed another;
-    };
-
-    IndirectUsage doubly_indirect;
-};
diff --git a/tests/headers/template-param-usage-11.hpp b/tests/headers/template-param-usage-11.hpp
deleted file mode 100644
index 8780f5d3..00000000
--- a/tests/headers/template-param-usage-11.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class DoesNotUseT {
-    static T but_static_member_does;
-};
diff --git a/tests/headers/template-param-usage-12.hpp b/tests/headers/template-param-usage-12.hpp
deleted file mode 100644
index 9b4cea19..00000000
--- a/tests/headers/template-param-usage-12.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class BaseUsesT {
-    T* t;
-};
-
-template <typename U>
-class CrtpUsesU : public BaseUsesT<CrtpUsesU<U>> {
-    U usage;
-};
diff --git a/tests/headers/template-param-usage-13.hpp b/tests/headers/template-param-usage-13.hpp
deleted file mode 100644
index 87db1a10..00000000
--- a/tests/headers/template-param-usage-13.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class BaseIgnoresT {
-    int x;
-};
-
-template <typename U>
-class CrtpUsesU : public BaseIgnoresT<CrtpUsesU<U>> {
-    U usage;
-};
diff --git a/tests/headers/template-param-usage-14.hpp b/tests/headers/template-param-usage-14.hpp
deleted file mode 100644
index 19016296..00000000
--- a/tests/headers/template-param-usage-14.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class BaseIgnoresT {
-    int x;
-};
-
-template <typename U>
-class CrtpIgnoresU : public BaseIgnoresT<CrtpIgnoresU<U>> {
-    int y;
-};
diff --git a/tests/headers/template-param-usage-15.hpp b/tests/headers/template-param-usage-15.hpp
deleted file mode 100644
index bac7ada7..00000000
--- a/tests/headers/template-param-usage-15.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class BaseUsesT {
-    T* usage;
-};
-
-template <typename U>
-class CrtpIgnoresU : public BaseUsesT<CrtpIgnoresU<U>> {
-    int y;
-};
diff --git a/tests/headers/template-param-usage-2.hpp b/tests/headers/template-param-usage-2.hpp
deleted file mode 100644
index 302140ab..00000000
--- a/tests/headers/template-param-usage-2.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class UsesTemplateParameter {
-    T t;
-
-    class AlsoUsesTemplateParameter {
-        T also;
-    };
-};
diff --git a/tests/headers/template-param-usage-3.hpp b/tests/headers/template-param-usage-3.hpp
deleted file mode 100644
index 57396a8a..00000000
--- a/tests/headers/template-param-usage-3.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class UsesTemplateParameter {
-    T t;
-
-    template <typename U>
-    class AlsoUsesTemplateParameterAndMore {
-        T also;
-        U more;
-    };
-};
diff --git a/tests/headers/template-param-usage-4.hpp b/tests/headers/template-param-usage-4.hpp
deleted file mode 100644
index 0415d692..00000000
--- a/tests/headers/template-param-usage-4.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class UsesTemplateParameter {
-    T t;
-
-    template <typename U>
-    class DoesNotUseTemplateParameters {
-        int x;
-    };
-};
diff --git a/tests/headers/template-param-usage-5.hpp b/tests/headers/template-param-usage-5.hpp
deleted file mode 100644
index 04b9bf80..00000000
--- a/tests/headers/template-param-usage-5.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class IndirectlyUsesTemplateParameter {
-    using Aliased = T;
-
-    Aliased aliased;
-};
diff --git a/tests/headers/template-param-usage-6.hpp b/tests/headers/template-param-usage-6.hpp
deleted file mode 100644
index ee0519c5..00000000
--- a/tests/headers/template-param-usage-6.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T>
-class DoesNotUseTemplateParameter {
-    using ButAliasDoesUseIt = T;
-
-    int x;
-};
diff --git a/tests/headers/template-param-usage-7.hpp b/tests/headers/template-param-usage-7.hpp
deleted file mode 100644
index 99d4cc71..00000000
--- a/tests/headers/template-param-usage-7.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T, typename U, typename V>
-class DoesNotUseU {
-    T t;
-    V v;
-};
-
-// The bool should go away becuase U is not used.
-using Alias = DoesNotUseU<int, bool, char>;
diff --git a/tests/headers/template-param-usage-8.hpp b/tests/headers/template-param-usage-8.hpp
deleted file mode 100644
index 96eabc06..00000000
--- a/tests/headers/template-param-usage-8.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T, typename U>
-class IndirectUsage {
-    typedef T Typedefed;
-    using Aliased = U;
-
-    Typedefed member1;
-    Aliased member2;
-};
diff --git a/tests/headers/template-param-usage-9.hpp b/tests/headers/template-param-usage-9.hpp
deleted file mode 100644
index b9bd202c..00000000
--- a/tests/headers/template-param-usage-9.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: -- -std=c++14
-
-template <typename T, typename U>
-class DoesNotUse {
-    using Aliased = T;
-    typedef U Typedefed;
-
-    class IndirectUsage {
-        Aliased member;
-        Typedefed another;
-    };
-};
diff --git a/tests/headers/template-with-var.hpp b/tests/headers/template-with-var.hpp
deleted file mode 100644
index 88f60d21..00000000
--- a/tests/headers/template-with-var.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-template<typename T>
-class TemplateWithVar {
-    // We shouldn't generate bindings for this because there are potentially
-    // many instantiations of this variable, but we can't know which ones exist
-    // or don't.
-    static T var = 0;
-};
diff --git a/tests/headers/template.hpp b/tests/headers/template.hpp
deleted file mode 100644
index bc32a357..00000000
--- a/tests/headers/template.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++11
-//
-template<typename T, typename U> class Foo {
-    T m_member;
-    T* m_member_ptr;
-    T m_member_arr[1];
-};
-
-template<typename T> class B {
-    T m_member { 0 };
-};
-
-void bar(Foo<int, int> foo);
-
-namespace mozilla {
-class Foo;
-};
-
-struct C {
-    B<unsigned int> mB;
-    B<const int*> mBConstPtr;
-    B<const mozilla::Foo*> mBConstStructPtr;
-    B<const mozilla::Foo*[1]> mBConstStructPtrArray;
-    B<const int> mBConst;
-    B<volatile int> mBVolatile;
-    B<const bool> mBConstBool;
-    B<const char16_t> mBConstChar;
-    B<int[1]> mBArray;
-    B<int*[1]> mBPtrArray;
-    B<int(*)[1]> mBArrayPtr;
-    B<int&> mBRef;
-    B<const int&> mBConstRef;
-    B<int*&> mPtrRef;
-    B<int(&)[1]> mArrayRef;
-    B<const int[1]> mBConstArray;
-};
-
-template<typename T>
-class D {
-    typedef Foo<int, int> MyFoo;
-
-    MyFoo m_foo;
-
-    template<typename Z>
-    class U {
-        MyFoo m_nested_foo;
-        Z m_baz;
-    };
-};
-
-template<typename T>
-class Rooted {
-    T* prev;
-    Rooted<void*>* next;
-    T ptr;
-};
-
-class RootedContainer {
-    Rooted<void*> root;
-};
-
-template<typename T>
-class WithDtor;
-
-typedef WithDtor<int> WithDtorIntFwd;
-
-template<typename T>
-class WithDtor {
-    T member;
-    ~WithDtor() {}
-};
-
-class PODButContainsDtor {
-    WithDtorIntFwd member;
-};
-
-
-/** <div rustbindgen opaque> */
-template<typename T>
-class Opaque {
-    T member;
-};
-
-class POD {
-    Opaque<int> opaque_member;
-};
-
-/**
- * <div rustbindgen replaces="NestedReplaced"></div>
- */
-template<typename T>
-class Nested {
-    T* buff;
-};
-
-template<typename T, typename U>
-class NestedBase {
-    T* buff;
-};
-
-template<typename T>
-class NestedReplaced: public NestedBase<T, int> {
-};
-
-template<typename T>
-class Incomplete;
-
-template<typename T>
-class NestedContainer {
-    T c;
-private:
-    NestedReplaced<T> nested;
-    Incomplete<T> inc;
-};
-
-template<typename T>
-class Incomplete {
-    T d;
-};
-
-class Untemplated {};
-
-template<typename T>
-class Templated {
-    Untemplated m_untemplated;
-};
-
-/**
- * If the replacement doesn't happen at the parse level the container would be
- * copy and the replacement wouldn't, so this wouldn't compile.
- *
- * <div rustbindgen replaces="ReplacedWithoutDestructor"></div>
- */
-template<typename T>
-class ReplacedWithDestructor {
-    T* buff;
-    ~ReplacedWithDestructor() {};
-};
-
-template<typename T>
-class ReplacedWithoutDestructor {
-    T* buff;
-};
-
-template<typename T>
-class ReplacedWithoutDestructorFwd;
-
-template<typename T>
-class ShouldNotBeCopiable {
-    ReplacedWithoutDestructor<T> m_member;
-};
-
-template<typename U>
-class ShouldNotBeCopiableAsWell {
-    ReplacedWithoutDestructorFwd<U> m_member;
-};
-
-/**
- * If the replacement doesn't happen at the parse level the container would be
- * copy and the replacement wouldn't, so this wouldn't compile.
- *
- * <div rustbindgen replaces="ReplacedWithoutDestructorFwd"></div>
- */
-template<typename T>
-class ReplacedWithDestructorDeclaredAfter {
-    T* buff;
-    ~ReplacedWithDestructorDeclaredAfter() {};
-};
diff --git a/tests/headers/template_alias.hpp b/tests/headers/template_alias.hpp
deleted file mode 100644
index 8b3ea692..00000000
--- a/tests/headers/template_alias.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq -- -std=c++14
-
-namespace JS {
-namespace detail {
-    template <typename T>
-    using Wrapped = T;
-}
-
-template <typename T>
-struct Rooted {
-    detail::Wrapped<T> ptr;
-};
-}
diff --git a/tests/headers/template_alias_basic.hpp b/tests/headers/template_alias_basic.hpp
deleted file mode 100644
index 964f6e27..00000000
--- a/tests/headers/template_alias_basic.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-template<typename T>
-using Wrapped = T;
diff --git a/tests/headers/template_alias_namespace.hpp b/tests/headers/template_alias_namespace.hpp
deleted file mode 100644
index c20bf206..00000000
--- a/tests/headers/template_alias_namespace.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --enable-cxx-namespaces -- -std=c++14
-
-namespace JS {
-namespace detail {
-    template <typename T>
-    using Wrapped = T;
-}
-
-template <typename T>
-struct Rooted {
-    detail::Wrapped<T> ptr;
-};
-}
diff --git a/tests/headers/template_fun.hpp b/tests/headers/template_fun.hpp
deleted file mode 100644
index 17b1383b..00000000
--- a/tests/headers/template_fun.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-// this will be ignored
-template <class T>
-void foo() {}
diff --git a/tests/headers/template_instantiation_with_fn_local_type.hpp b/tests/headers/template_instantiation_with_fn_local_type.hpp
deleted file mode 100644
index b7ff28b0..00000000
--- a/tests/headers/template_instantiation_with_fn_local_type.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// bindgen-flags: -- -std=c++14
-//
-// https://github.com/rust-lang/rust-bindgen/issues/2036
-
-template<typename T>
-struct Foo {};
-template<typename T>
-Foo<T> foo{};
-
-// Struct inside function
-void f() {
-  struct Bar {
-    Bar() {}
-  };
-  foo<Bar>;
-}
-
-// Struct inside method
-class Baz {
-  void f() {
-    struct Boo {
-      Boo() {}
-    };
-    foo<Boo>;
-  }
-};
-
diff --git a/tests/headers/template_partial_specification.hpp b/tests/headers/template_partial_specification.hpp
deleted file mode 100644
index fe1be658..00000000
--- a/tests/headers/template_partial_specification.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: -- --target=x86_64-pc-win32
-
-template<typename Method, bool Cancelable>
-struct nsRunnableMethodTraits;
-
-template<class C, typename R, bool Cancelable, typename... As>
-struct nsRunnableMethodTraits<R(C::*)(As...), Cancelable>
-{
-  static const bool can_cancel = Cancelable;
-};
diff --git a/tests/headers/template_typedef_transitive_param.hpp b/tests/headers/template_typedef_transitive_param.hpp
deleted file mode 100644
index 34a5b92c..00000000
--- a/tests/headers/template_typedef_transitive_param.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-template<typename T>
-struct Wrapper {
-    struct Wrapped {
-        T t;
-    };
-    using Type = Wrapped;
-};
diff --git a/tests/headers/template_typedefs.hpp b/tests/headers/template_typedefs.hpp
deleted file mode 100644
index 5e13dcd8..00000000
--- a/tests/headers/template_typedefs.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-typedef void (*foo)(int);
-
-template<typename T, typename U>
-class Foo {
-  typedef T Char;
-  typedef Char* FooPtrTypedef;
-  typedef bool (*nsCOMArrayEnumFunc)(T* aElement, void* aData);
-};
diff --git a/tests/headers/templateref_opaque.hpp b/tests/headers/templateref_opaque.hpp
deleted file mode 100644
index 2f6a0027..00000000
--- a/tests/headers/templateref_opaque.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-namespace detail {
-template<typename T>
-struct PointerType {
-  typedef T* Type;
-};
-}
-template<typename T>
-class UniquePtr {
-  typedef typename detail::PointerType<T> Pointer;
-};
diff --git a/tests/headers/templatized-bitfield.hpp b/tests/headers/templatized-bitfield.hpp
deleted file mode 100644
index ed4a1540..00000000
--- a/tests/headers/templatized-bitfield.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-/// We don't get a layout for this bitfield, since we don't know what `T` will
-/// be, so we cannot allocate bitfield units. The best thing we can do is make
-/// the struct opaque.
-template <class T>
-class TemplatizedBitfield {
-    T t : 6;
-};
diff --git a/tests/headers/timex.h b/tests/headers/timex.h
deleted file mode 100644
index 1add26ca..00000000
--- a/tests/headers/timex.h
+++ /dev/null
@@ -1,15 +0,0 @@
-struct timex {
-	int tai;
-
-	int  :32; int  :32; int  :32; int  :32;
-	int  :32; int  :32; int  :32; int  :32;
-	int  :32; int  :32; int  :32;
-};
-
-struct timex_named {
-  int tai;
-
-  int a:32; int b:32; int c:32; int d:32;
-  int e:32; int f:32; int g:32; int h:32;
-  int i:32; int j:32; int k:32;
-};
diff --git a/tests/headers/transform-op.hpp b/tests/headers/transform-op.hpp
deleted file mode 100644
index aa6118eb..00000000
--- a/tests/headers/transform-op.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// bindgen-flags: --rust-target 1.0 -- -std=c++11
-
-typedef unsigned char uint8_t;
-typedef int int32_t;
-
-template<typename T>
-struct StylePoint {
-  T x;
-  T y;
-};
-
-template<typename T>
-union StyleFoo {
-  enum class Tag : uint8_t {
-    Foo,
-    Bar,
-    Baz,
-    Bazz,
-  };
-
-  struct Foo_Body {
-    Tag tag;
-    int32_t x;
-    StylePoint<T> y;
-    StylePoint<float> z;
-  };
-
-  struct Bar_Body {
-    Tag tag;
-    T _0;
-  };
-
-  struct Baz_Body {
-    Tag tag;
-    StylePoint<T> _0;
-  };
-
-  struct {
-    Tag tag;
-  };
-  Foo_Body foo;
-  Bar_Body bar;
-  Baz_Body baz;
-};
-
-template<typename T>
-struct StyleBar {
-  enum class Tag {
-    Bar1,
-    Bar2,
-    Bar3,
-    Bar4,
-  };
-
-  struct StyleBar1_Body {
-    int32_t x;
-    StylePoint<T> y;
-    StylePoint<float> z;
-  };
-
-  struct StyleBar2_Body {
-    T _0;
-  };
-
-  struct StyleBar3_Body {
-    StylePoint<T> _0;
-  };
-
-  Tag tag;
-  union {
-    StyleBar1_Body bar1;
-    StyleBar2_Body bar2;
-    StyleBar3_Body bar3;
-  };
-};
diff --git a/tests/headers/type-referenced-by-allowlisted-function.h b/tests/headers/type-referenced-by-allowlisted-function.h
deleted file mode 100644
index bf675bc9..00000000
--- a/tests/headers/type-referenced-by-allowlisted-function.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --allowlist-function dl_iterate_phdr
-
-struct dl_phdr_info {
-    int x;
-};
-
-int dl_iterate_phdr(struct dl_phdr_info *);
diff --git a/tests/headers/type_alias_empty.hpp b/tests/headers/type_alias_empty.hpp
deleted file mode 100644
index bcccc3c8..00000000
--- a/tests/headers/type_alias_empty.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --allowlist-type bool_constant -- -std=c++11
-
-// NB: The --allowlist-type is done to trigger the traversal of the types on
-// codegen in order to trigger #67.
-
-template<typename T, T Val>
-struct integral_constant {};
-
-template<bool B>
-using bool_constant = integral_constant<bool, B>;
diff --git a/tests/headers/type_alias_partial_template_especialization.hpp b/tests/headers/type_alias_partial_template_especialization.hpp
deleted file mode 100644
index dfc36786..00000000
--- a/tests/headers/type_alias_partial_template_especialization.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: -- -std=c++14
-template <typename A> using MaybeWrapped = A;
-
-template<class T>
-class Rooted {
-  MaybeWrapped<T> ptr;
-};
diff --git a/tests/headers/type_alias_template_specialized.hpp b/tests/headers/type_alias_template_specialized.hpp
deleted file mode 100644
index f7403a36..00000000
--- a/tests/headers/type_alias_template_specialized.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --allowlist-type Rooted -- -std=c++14
-
-template <typename a> using MaybeWrapped = a;
-class Rooted {
-  MaybeWrapped<int> ptr;
-};
-
-/// <div rustbindgen replaces="MaybeWrapped"></div>
-template <typename a> using replaces_MaybeWrapped = a;
diff --git a/tests/headers/typedefd-array-as-function-arg.h b/tests/headers/typedefd-array-as-function-arg.h
deleted file mode 100644
index 93790591..00000000
--- a/tests/headers/typedefd-array-as-function-arg.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// foo.h
-typedef float myVector3[3];
-void modifyVectorFunc(myVector3 v);
diff --git a/tests/headers/typeref.hpp b/tests/headers/typeref.hpp
deleted file mode 100644
index bdc1b302..00000000
--- a/tests/headers/typeref.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-struct nsFoo;
-
-namespace mozilla {
-
-struct FragmentOrURL { bool mIsLocalRef; };
-struct Position { };
-
-} // namespace mozilla
-
-class Bar {
-  nsFoo* mFoo;
-};
-
-namespace mozilla {
-
-template<typename ReferenceBox>
-struct StyleShapeSource {
-  union {
-    Position* mPosition;
-    FragmentOrURL* mFragmentOrURL;
-  };
-};
-
-} // namespace mozilla
-
-struct nsFoo {
-  mozilla::StyleShapeSource<int> mBar;
-};
diff --git a/tests/headers/typeref_1_0.hpp b/tests/headers/typeref_1_0.hpp
deleted file mode 100644
index 70dfc11f..00000000
--- a/tests/headers/typeref_1_0.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct nsFoo;
-
-namespace mozilla {
-
-struct FragmentOrURL { bool mIsLocalRef; };
-struct Position { };
-
-} // namespace mozilla
-
-class Bar {
-  nsFoo* mFoo;
-};
-
-namespace mozilla {
-
-template<typename ReferenceBox>
-struct StyleShapeSource {
-  union {
-    Position* mPosition;
-    FragmentOrURL* mFragmentOrURL;
-  };
-};
-
-} // namespace mozilla
-
-struct nsFoo {
-  mozilla::StyleShapeSource<int> mBar;
-};
diff --git a/tests/headers/underscore.hpp b/tests/headers/underscore.hpp
deleted file mode 100644
index 1c9371f1..00000000
--- a/tests/headers/underscore.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-const int _ = 10;
-
-typedef struct { unsigned char _[8]; } ptr_t;
\ No newline at end of file
diff --git a/tests/headers/union-align.h b/tests/headers/union-align.h
deleted file mode 100644
index 9557b279..00000000
--- a/tests/headers/union-align.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --rust-target 1.26
-
-union Bar {
-  unsigned char foo;
-} __attribute__ ((__aligned__ (16)));
-
-
-union Baz {
-  union Bar bar;
-};
diff --git a/tests/headers/union-in-ns.hpp b/tests/headers/union-in-ns.hpp
deleted file mode 100644
index 68b8f72d..00000000
--- a/tests/headers/union-in-ns.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --enable-cxx-namespaces
-
-union bar {
-  int baz;
-};
diff --git a/tests/headers/union-in-ns_1_0.hpp b/tests/headers/union-in-ns_1_0.hpp
deleted file mode 100644
index f3ae2210..00000000
--- a/tests/headers/union-in-ns_1_0.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --enable-cxx-namespaces
-
-union bar {
-  int baz;
-};
diff --git a/tests/headers/union_bitfield.h b/tests/headers/union_bitfield.h
deleted file mode 100644
index 99072957..00000000
--- a/tests/headers/union_bitfield.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
-
-union U4 {
-    unsigned derp : 1;
-};
-
-union B {
-    unsigned foo : 31;
-    unsigned char bar : 1;
-};
diff --git a/tests/headers/union_bitfield_1_0.h b/tests/headers/union_bitfield_1_0.h
deleted file mode 100644
index 06b61ad7..00000000
--- a/tests/headers/union_bitfield_1_0.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq --impl-partialeq
-
-union U4 {
-    unsigned derp : 1;
-};
-
-union B {
-    unsigned foo : 31;
-    unsigned char bar : 1;
-};
-
-union HasBigBitfield {
-    __int128 x : 128;
-};
diff --git a/tests/headers/union_dtor.hpp b/tests/headers/union_dtor.hpp
deleted file mode 100644
index 399dc89d..00000000
--- a/tests/headers/union_dtor.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-union UnionWithDtor {
-  ~UnionWithDtor();
-  int mFoo;
-  void* mBar;
-};
diff --git a/tests/headers/union_dtor_1_0.hpp b/tests/headers/union_dtor_1_0.hpp
deleted file mode 100644
index 01f76366..00000000
--- a/tests/headers/union_dtor_1_0.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.0
-
-union UnionWithDtor {
-  ~UnionWithDtor();
-  int mFoo;
-  void* mBar;
-};
diff --git a/tests/headers/union_fields.hpp b/tests/headers/union_fields.hpp
deleted file mode 100644
index 7bb2a3ce..00000000
--- a/tests/headers/union_fields.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-typedef union {
-  int mInt;
-  float mFloat;
-  void* mPointer;
-} nsStyleUnion;
diff --git a/tests/headers/union_fields_1_0.hpp b/tests/headers/union_fields_1_0.hpp
deleted file mode 100644
index bbb67fbc..00000000
--- a/tests/headers/union_fields_1_0.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-typedef union {
-  int mInt;
-  float mFloat;
-  void* mPointer;
-} nsStyleUnion;
diff --git a/tests/headers/union_template.hpp b/tests/headers/union_template.hpp
deleted file mode 100644
index 8b57f5a0..00000000
--- a/tests/headers/union_template.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-template<typename T>
-struct NastyStruct {
-  bool mIsSome;
-  union {
-    void* mFoo;
-    unsigned long mDummy;
-  } mStorage;
-
-  union {
-    short wat;
-    int* wut;
-  };
-};
-
-template<typename T>
-union Whatever {
-  void* mTPtr;
-  int mInt;
-};
diff --git a/tests/headers/union_template_1_0.hpp b/tests/headers/union_template_1_0.hpp
deleted file mode 100644
index 18e3d74a..00000000
--- a/tests/headers/union_template_1_0.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-template<typename T>
-struct NastyStruct {
-  bool mIsSome;
-  union {
-    void* mFoo;
-    unsigned long mDummy;
-  } mStorage;
-
-  union {
-    short wat;
-    int* wut;
-  };
-};
-
-template<typename T>
-union Whatever {
-  void* mTPtr;
-  int mInt;
-};
diff --git a/tests/headers/union_with_anon_struct.h b/tests/headers/union_with_anon_struct.h
deleted file mode 100644
index b239b2d8..00000000
--- a/tests/headers/union_with_anon_struct.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union foo {
-    struct {
-        unsigned int a;
-        unsigned int b;
-    } bar;
-};
diff --git a/tests/headers/union_with_anon_struct_1_0.h b/tests/headers/union_with_anon_struct_1_0.h
deleted file mode 100644
index 9313299e..00000000
--- a/tests/headers/union_with_anon_struct_1_0.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union foo {
-    struct {
-        unsigned int a;
-        unsigned int b;
-    } bar;
-};
diff --git a/tests/headers/union_with_anon_struct_bitfield.h b/tests/headers/union_with_anon_struct_bitfield.h
deleted file mode 100644
index bbb1ef41..00000000
--- a/tests/headers/union_with_anon_struct_bitfield.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union foo {
-    int a;
-    struct {
-        int b : 7;
-        int c : 25;
-    };
-};
diff --git a/tests/headers/union_with_anon_struct_bitfield_1_0.h b/tests/headers/union_with_anon_struct_bitfield_1_0.h
deleted file mode 100644
index 0b0e3d73..00000000
--- a/tests/headers/union_with_anon_struct_bitfield_1_0.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union foo {
-    int a;
-    struct {
-        int b : 7;
-        int c : 25;
-    };
-};
diff --git a/tests/headers/union_with_anon_union.h b/tests/headers/union_with_anon_union.h
deleted file mode 100644
index 02b09e2e..00000000
--- a/tests/headers/union_with_anon_union.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    } bar;
-};
diff --git a/tests/headers/union_with_anon_union_1_0.h b/tests/headers/union_with_anon_union_1_0.h
deleted file mode 100644
index 28a7231d..00000000
--- a/tests/headers/union_with_anon_union_1_0.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union foo {
-    union {
-        unsigned int a;
-        unsigned short b;
-    } bar;
-};
diff --git a/tests/headers/union_with_anon_unnamed_struct.h b/tests/headers/union_with_anon_unnamed_struct.h
deleted file mode 100644
index 04903318..00000000
--- a/tests/headers/union_with_anon_unnamed_struct.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union pixel {
-    unsigned int rgba;
-    struct {
-        unsigned char r;
-        unsigned char g;
-        unsigned char b;
-        unsigned char a;
-    };
-};
diff --git a/tests/headers/union_with_anon_unnamed_struct_1_0.h b/tests/headers/union_with_anon_unnamed_struct_1_0.h
deleted file mode 100644
index 506a41f6..00000000
--- a/tests/headers/union_with_anon_unnamed_struct_1_0.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union pixel {
-    unsigned int rgba;
-    struct {
-        unsigned char r;
-        unsigned char g;
-        unsigned char b;
-        unsigned char a;
-    };
-};
diff --git a/tests/headers/union_with_anon_unnamed_union.h b/tests/headers/union_with_anon_unnamed_union.h
deleted file mode 100644
index dbccd5b5..00000000
--- a/tests/headers/union_with_anon_unnamed_union.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union foo {
-    unsigned int a;
-    union {
-        unsigned short b;
-        unsigned char c;
-    };
-};
diff --git a/tests/headers/union_with_anon_unnamed_union_1_0.h b/tests/headers/union_with_anon_unnamed_union_1_0.h
deleted file mode 100644
index c556a613..00000000
--- a/tests/headers/union_with_anon_unnamed_union_1_0.h
+++ /dev/null
@@ -1,9 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union foo {
-    unsigned int a;
-    union {
-        unsigned short b;
-        unsigned char c;
-    };
-};
diff --git a/tests/headers/union_with_big_member.h b/tests/headers/union_with_big_member.h
deleted file mode 100644
index e8a3fe0a..00000000
--- a/tests/headers/union_with_big_member.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union WithBigArray {
-  int a;
-  int b[33];
-};
-
-union WithBigArray2 {
-  int a;
-  char b[33];
-};
-
-union WithBigMember {
-  int a;
-  union WithBigArray b;
-};
diff --git a/tests/headers/union_with_big_member_1_0.h b/tests/headers/union_with_big_member_1_0.h
deleted file mode 100644
index 04294354..00000000
--- a/tests/headers/union_with_big_member_1_0.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union WithBigArray {
-  int a;
-  int b[33];
-};
-
-union WithBigArray2 {
-  int a;
-  char b[33];
-};
-
-union WithBigMember {
-  int a;
-  union WithBigArray b;
-};
diff --git a/tests/headers/union_with_nesting.h b/tests/headers/union_with_nesting.h
deleted file mode 100644
index ae25244a..00000000
--- a/tests/headers/union_with_nesting.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq
-//
-union foo {
-    unsigned int a;
-    struct {
-        union {
-            unsigned short b1;
-            unsigned short b2;
-        };
-
-        union {
-            unsigned short c1;
-            unsigned short c2;
-        };
-    };
-};
diff --git a/tests/headers/union_with_nesting_1_0.h b/tests/headers/union_with_nesting_1_0.h
deleted file mode 100644
index 3cdb7238..00000000
--- a/tests/headers/union_with_nesting_1_0.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-union foo {
-    unsigned int a;
-    struct {
-        union {
-            unsigned short b1;
-            unsigned short b2;
-        };
-
-        union {
-            unsigned short c1;
-            unsigned short c2;
-        };
-    };
-};
diff --git a/tests/headers/union_with_non_copy_member.h b/tests/headers/union_with_non_copy_member.h
deleted file mode 100644
index 764820a4..00000000
--- a/tests/headers/union_with_non_copy_member.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// bindgen-flags: --bindgen-wrapper-union 'WithBindgenGeneratedWrapper' --manually-drop-union 'WithManuallyDrop' --no-copy 'NonCopyType'
-
-struct NonCopyType {
-  int foo;
-};
-
-union WithBindgenGeneratedWrapper {
-  struct NonCopyType non_copy_type;
-  int bar;
-};
-
-union WithManuallyDrop {
-  struct NonCopyType non_copy_type;
-  int bar;
-};
-
-union WithDefaultWrapper {
-  struct NonCopyType non_copy_type;
-  int bar;
-};
diff --git a/tests/headers/unknown_attr.h b/tests/headers/unknown_attr.h
deleted file mode 100644
index 1e89fb14..00000000
--- a/tests/headers/unknown_attr.h
+++ /dev/null
@@ -1,6 +0,0 @@
-typedef struct {
-  long long __clang_max_align_nonce1
-      __attribute__((__aligned__(__alignof__(long long))));
-  long long __clang_max_align_nonce2
-      __attribute__((__aligned__(__alignof__(long double))));
-} max_align_t;
diff --git a/tests/headers/unsorted-items.h b/tests/headers/unsorted-items.h
deleted file mode 100644
index 23962d18..00000000
--- a/tests/headers/unsorted-items.h
+++ /dev/null
@@ -1,15 +0,0 @@
-int foo();
-typedef int number;
-int bar(number x);
-struct Point
-{
-    number x;
-    number y;
-};
-struct Angle
-{
-    number a;
-    number b;
-};
-int baz(struct Point point);
-const number NUMBER = 42;
diff --git a/tests/headers/use-core.h b/tests/headers/use-core.h
deleted file mode 100644
index 5ee0ac6f..00000000
--- a/tests/headers/use-core.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --use-core --raw-line '#![cfg(not(target_os="windows"))] extern crate core;' --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct foo {
-  int a, b;
-  void* bar;
-};
-
-union {
-  int bar;
-  long baz;
-} bazz;
-
-typedef void (*fooFunction)(int bar);
diff --git a/tests/headers/use-core_1_0.h b/tests/headers/use-core_1_0.h
deleted file mode 100644
index 40de9d15..00000000
--- a/tests/headers/use-core_1_0.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// bindgen-flags: --rust-target 1.0 --use-core --raw-line "extern crate core;" --with-derive-hash --with-derive-partialeq --with-derive-eq
-
-struct foo {
-  int a, b;
-  void* bar;
-};
-
-union {
-  int bar;
-  long baz;
-} bazz;
-
-typedef void (*fooFunction)(int bar);
diff --git a/tests/headers/using.hpp b/tests/headers/using.hpp
deleted file mode 100644
index ba07b9c8..00000000
--- a/tests/headers/using.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-template<typename T>
-class Point {
-    T x;
-    T y;
-};
-
-typedef Point<int> IntPoint2D;
-
-using IntVec2D = Point<int>;
diff --git a/tests/headers/var-tracing.hpp b/tests/headers/var-tracing.hpp
deleted file mode 100644
index ef002a00..00000000
--- a/tests/headers/var-tracing.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --allowlist-type Baz
-
-struct Bar {
-  const int m_baz;
-  Bar(int baz);
-};
-
-class Baz {
-  static const Bar FOO[];
-};
diff --git a/tests/headers/variadic-method.hpp b/tests/headers/variadic-method.hpp
deleted file mode 100644
index 78a8eb45..00000000
--- a/tests/headers/variadic-method.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-void foo(const char* fmt, ...);
-
-struct Bar {
-  void foo(const char* fmt, ...);
-};
diff --git a/tests/headers/variadic_template_function.hpp b/tests/headers/variadic_template_function.hpp
deleted file mode 100644
index 4942d8f0..00000000
--- a/tests/headers/variadic_template_function.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-
-template <typename T>
-class VariadicFunctionObject {
-public:
-	int add_em_up(T count,...);
-};
diff --git a/tests/headers/vector.hpp b/tests/headers/vector.hpp
deleted file mode 100644
index 173aa022..00000000
--- a/tests/headers/vector.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-struct foo {
-  __attribute__((__vector_size__(1 * sizeof(long long)))) long long mMember;
-};
-
-typedef float __m128 __attribute__ ((__vector_size__ (16)));
-typedef double __m128d __attribute__((__vector_size__(16)));
-typedef long long __m128i __attribute__((__vector_size__(16)));
-
-__m128 foo(__m128i, __m128d);
diff --git a/tests/headers/virtual_dtor.hpp b/tests/headers/virtual_dtor.hpp
deleted file mode 100644
index c35dcab1..00000000
--- a/tests/headers/virtual_dtor.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-struct nsSlots {
-    virtual ~nsSlots();
-};
diff --git a/tests/headers/virtual_inheritance.hpp b/tests/headers/virtual_inheritance.hpp
deleted file mode 100644
index 5198c51e..00000000
--- a/tests/headers/virtual_inheritance.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-
-class A {
-  int foo;
-};
-
-class B: public virtual A {
-  int bar;
-};
-
-class C: public virtual A {
-  int baz;
-};
-
-class D: public C, public B {
-  int bazz;
-};
diff --git a/tests/headers/virtual_interface.hpp b/tests/headers/virtual_interface.hpp
deleted file mode 100644
index 00ab0737..00000000
--- a/tests/headers/virtual_interface.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-class PureVirtualIFace {
-public:
-    virtual void Foo() = 0;
-    virtual void Bar(unsigned int) = 0;
-};
-
-class AnotherInterface {
-public:
-    virtual void Baz() = 0;
-};
-
-class Implementation : public PureVirtualIFace {
-public:
-    void Foo() override {}
-    void Bar(unsigned int) override {}
-};
-
-class DoubleImpl : public PureVirtualIFace, public AnotherInterface {
-public:
-    void Foo() override {}
-    void Bar(unsigned int) override {}
-
-    void Baz() override {}
-};
diff --git a/tests/headers/virtual_overloaded.hpp b/tests/headers/virtual_overloaded.hpp
deleted file mode 100644
index f5ba5ff2..00000000
--- a/tests/headers/virtual_overloaded.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-class C {
-public:
-    virtual void do_thing(char);
-    virtual void do_thing(int);
-};
diff --git a/tests/headers/vtable_recursive_sig.hpp b/tests/headers/vtable_recursive_sig.hpp
deleted file mode 100644
index 8a073864..00000000
--- a/tests/headers/vtable_recursive_sig.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// bindgen-flags: -- -std=c++11
-
-class Derived;
-class Base {
-public:
-  virtual Derived* AsDerived();
-};
-
-class Derived final : public Base {
-  virtual Derived* AsDerived() override;
-};
diff --git a/tests/headers/wasm-constructor-returns.hpp b/tests/headers/wasm-constructor-returns.hpp
deleted file mode 100644
index 9e470327..00000000
--- a/tests/headers/wasm-constructor-returns.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --generate constructors,types -- -fvisibility=default --target=wasm32-unknown-emscripten
-
-class Foo {
-public:
-    Foo(int var);
-};
-
diff --git a/tests/headers/wasm-import-module.h b/tests/headers/wasm-import-module.h
deleted file mode 100644
index db4fe85c..00000000
--- a/tests/headers/wasm-import-module.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --wasm-import-module-name test-module
-
-void test_function();
\ No newline at end of file
diff --git a/tests/headers/weird_bitfields.hpp b/tests/headers/weird_bitfields.hpp
deleted file mode 100644
index b2761a80..00000000
--- a/tests/headers/weird_bitfields.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// bindgen-flags: --rustified-enum ".*"
-
-// You can guess where this is taken from...
-enum nsStyleSVGOpacitySource {
-  eStyleSVGOpacitySource_Normal,
-  eStyleSVGOpacitySource_ContextFillOpacity,
-  eStyleSVGOpacitySource_ContextStrokeOpacity
-};
-
-class Weird {
-  unsigned int         mStrokeDasharrayLength;
-  unsigned int         bitTest: 16;
-  unsigned int         bitTest2: 15;
-  unsigned char          mClipRule;         // [inherited]
-  unsigned char          mColorInterpolation; // [inherited] see nsStyleConsts.h
-  unsigned char          mColorInterpolationFilters; // [inherited] see nsStyleConsts.h
-  unsigned char          mFillRule;         // [inherited] see nsStyleConsts.h
-  unsigned char          mImageRendering;   // [inherited] see nsStyleConsts.h
-  unsigned char          mPaintOrder;       // [inherited] see nsStyleConsts.h
-  unsigned char          mShapeRendering;   // [inherited] see nsStyleConsts.h
-  unsigned char          mStrokeLinecap;    // [inherited] see nsStyleConsts.h
-  unsigned char          mStrokeLinejoin;   // [inherited] see nsStyleConsts.h
-  unsigned char          mTextAnchor;       // [inherited] see nsStyleConsts.h
-  unsigned char          mTextRendering;    // [inherited] see nsStyleConsts.h
-
-  // In SVG glyphs, whether we inherit fill or stroke opacity from the outer
-  // text object.
-  // Use 3 bits to avoid signedness problems in MSVC.
-  nsStyleSVGOpacitySource mFillOpacitySource    : 3;
-  nsStyleSVGOpacitySource mStrokeOpacitySource  : 3;
-
-  // SVG glyph outer object inheritance for other properties
-  bool mStrokeDasharrayFromObject   : 1;
-  bool mStrokeDashoffsetFromObject  : 1;
-  bool mStrokeWidthFromObject       : 1;
-};
diff --git a/tests/headers/what_is_going_on.hpp b/tests/headers/what_is_going_on.hpp
deleted file mode 100644
index 078c1ad5..00000000
--- a/tests/headers/what_is_going_on.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-
-struct UnknownUnits {};
-typedef float Float;
-
-template<class units, class F = Float>
-struct PointTyped {
-  F x;
-  F y;
-
-  static PointTyped<units, F> FromUnknownPoint(const PointTyped<UnknownUnits, F>& aPoint) {
-    return PointTyped<units, F>(aPoint.x, aPoint.y);
-  }
-
-  PointTyped<UnknownUnits, F> ToUnknownPoint() const {
-    return PointTyped<UnknownUnits, F>(this->x, this->y);
-  }
-};
-
-typedef PointTyped<UnknownUnits> IntPoint;
diff --git a/tests/headers/win32-thiscall_1_0.hpp b/tests/headers/win32-thiscall_1_0.hpp
deleted file mode 100644
index 5907c76e..00000000
--- a/tests/headers/win32-thiscall_1_0.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target 1.0 -- --target=i686-pc-windows-msvc
-
-class Foo {
-  public:
-    void test();
-    int test2(int var);
-};
diff --git a/tests/headers/win32-thiscall_nightly.hpp b/tests/headers/win32-thiscall_nightly.hpp
deleted file mode 100644
index 2c9f2f17..00000000
--- a/tests/headers/win32-thiscall_nightly.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_thiscall)]' -- --target=i686-pc-windows-msvc
-
-class Foo {
-  public:
-    void test();
-    int test2(int var);
-};
diff --git a/tests/headers/win32-vectorcall-1_0.h b/tests/headers/win32-vectorcall-1_0.h
deleted file mode 100644
index a1f852b5..00000000
--- a/tests/headers/win32-vectorcall-1_0.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --rust-target 1.0 -- --target=x86_64-pc-windows-msvc
-
-int __vectorcall test_vectorcall(int a, int b);
diff --git a/tests/headers/win32-vectorcall-nightly.h b/tests/headers/win32-vectorcall-nightly.h
deleted file mode 100644
index c099bb59..00000000
--- a/tests/headers/win32-vectorcall-nightly.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// bindgen-flags: --rust-target nightly --raw-line '#![cfg(feature = "nightly")]' --raw-line '#![feature(abi_vectorcall)]' -- --target=x86_64-pc-windows-msvc
-
-int __vectorcall test_vectorcall(int a, int b);
diff --git a/tests/headers/with_array_pointers_arguments.h b/tests/headers/with_array_pointers_arguments.h
deleted file mode 100644
index 565b3cf6..00000000
--- a/tests/headers/with_array_pointers_arguments.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// bindgen-flags: --use-array-pointers-in-arguments
-
-int test_fn(float a, int arr[20]);
-
-int test_fn2(const float arr[20], int b);
-
-typedef char defArr[20];
-typedef void foo(defArr a);
-
-void bar(defArr a);
\ No newline at end of file
diff --git a/tests/headers/without_array_pointers_arguments.h b/tests/headers/without_array_pointers_arguments.h
deleted file mode 100644
index 2f066874..00000000
--- a/tests/headers/without_array_pointers_arguments.h
+++ /dev/null
@@ -1,9 +0,0 @@
-
-int test_fn(float a, int arr[20]);
-
-int test_fn2(const float arr[20], int b);
-
-typedef char defArr[20];
-typedef void foo(defArr a);
-
-void bar(defArr a);
\ No newline at end of file
diff --git a/tests/headers/zero-size-array-align.h b/tests/headers/zero-size-array-align.h
deleted file mode 100644
index 05b11bce..00000000
--- a/tests/headers/zero-size-array-align.h
+++ /dev/null
@@ -1,5 +0,0 @@
-struct dm_deps {
-  unsigned count;
-  unsigned filler;
-  unsigned long long device[0];
-};
diff --git a/tests/headers/zero-sized-array.hpp b/tests/headers/zero-sized-array.hpp
deleted file mode 100644
index ae6d0554..00000000
--- a/tests/headers/zero-sized-array.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// These classes are technically zero-sized, but despite that they still don't
-// get an `_address` field inserted.
-
-/**
- * Bizarrely enough, this should *not* get an `_address` field.
- */
-class ZeroSizedArray {
-    char arr[0];
-};
-
-/**
- * And nor should this get an `_address` field.
- */
-class ContainsZeroSizedArray {
-    ZeroSizedArray zsa;
-};
-
-/**
- * Inheriting from ZeroSizedArray shouldn't cause an `_address` to be inserted
- * either.
- */
-class InheritsZeroSizedArray : ZeroSizedArray {};
-
-// These are dynamically sized, which means that `sizeof` yields `0` but it
-// isn't really true. We shouldn't add an `_address` field to them.
-
-/**
- * And this should not get an `_address` field either.
- */
-class DynamicallySizedArray {
-    char arr[];
-};
-
-/**
- * No `_address` field here either.
- */
-class ContainsDynamicallySizedArray {
-    DynamicallySizedArray dsa;
-};
-
-// Note: this is disallowed:
-//
-//     error: base class 'DynamicallySizedArray' has a flexible array member
-//
-// class InheritsDynamicallySizedArray : DynamicallySizedArray {};
diff --git a/tests/parse_callbacks/mod.rs b/tests/parse_callbacks/mod.rs
deleted file mode 100644
index b94b54de..00000000
--- a/tests/parse_callbacks/mod.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use bindgen::callbacks::*;
-
-#[derive(Debug)]
-struct EnumVariantRename;
-
-impl ParseCallbacks for EnumVariantRename {
-    fn enum_variant_name(
-        &self,
-        _enum_name: Option<&str>,
-        original_variant_name: &str,
-        _variant_value: EnumVariantValue,
-    ) -> Option<String> {
-        Some(format!("RENAMED_{}", original_variant_name))
-    }
-}
-
-#[derive(Debug)]
-struct BlocklistedTypeImplementsTrait;
-
-impl ParseCallbacks for BlocklistedTypeImplementsTrait {
-    fn blocklisted_type_implements_trait(
-        &self,
-        _name: &str,
-        derive_trait: DeriveTrait,
-    ) -> Option<ImplementsTrait> {
-        if derive_trait == DeriveTrait::Hash {
-            Some(ImplementsTrait::No)
-        } else {
-            Some(ImplementsTrait::Yes)
-        }
-    }
-}
-
-pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
-    match cb {
-        "enum-variant-rename" => Box::new(EnumVariantRename),
-        "blocklisted-type-implements-trait" => {
-            Box::new(BlocklistedTypeImplementsTrait)
-        }
-        _ => panic!("Couldn't find name ParseCallbacks: {}", cb),
-    }
-}
diff --git a/tests/quickchecking/.gitignore b/tests/quickchecking/.gitignore
deleted file mode 100644
index 03314f77..00000000
--- a/tests/quickchecking/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-Cargo.lock
diff --git a/tests/quickchecking/Cargo.toml b/tests/quickchecking/Cargo.toml
deleted file mode 100644
index ddefb33d..00000000
--- a/tests/quickchecking/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-name = "quickchecking"
-description = "Bindgen property tests with quickcheck. Generate random valid C code and pass it to the csmith/predicate.py script"
-version = "0.1.0"
-authors = ["Shea Newton <sheanewt@gmail.com>"]
-
-[lib]
-name = "quickchecking"
-path = "src/lib.rs"
-
-[[bin]]
-name = "quickchecking"
-path = "src/bin.rs"
-
-[dependencies]
-clap = "2.28"
-lazy_static = "1.0"
-quickcheck = "0.4"
-rand = "0.3"
-tempdir = "0.3"
-
-[features]
-# No features by default.
-default = []
-
-# Enable the generation of code that allows for zero sized arrays as struct
-# fields. Until issues #684 and #1153 are resolved this can result in failing tests. 
-zero-sized-arrays = [] 
-
-# Enable the generation of code that allows for long double types as struct
-# fields. Until issue #550 is resolved this can result in failing tests.
-long-doubles = []
diff --git a/tests/quickchecking/README.md b/tests/quickchecking/README.md
deleted file mode 100644
index d3cfe170..00000000
--- a/tests/quickchecking/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# Property tests for `bindgen` with `quickchecking`
-
-`quickchecking` generates random C headers to test `bindgen` 
-using the [`quickcheck`][quickcheck] property testing crate. When testing 
-`bindgen` with `quickchecking`, the generated header files are passed to 
-`bindgen`'s `csmith-fuzzing/predicate.py` script. If that script fails, 
-`quickchecking` panics, and you can report an issue containing the test case!
-
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
-
-- [Prerequisites](#prerequisites)
-- [Running](#running)
-
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
-
-## Prerequisites
-
-Requires `python3` to be in `$PATH`.
-
-Many systems have `python3` by default but if your OS doesn't, its package 
-manager may make it available:
-
-```
-$ sudo apt install python3
-$ brew install python3
-$ # Etc...
-```
-
-## Running
-
-Run `quickchecking` binary to generate and test fuzzed C headers with 
-`cargo run`. Additional configuration is exposed through the binary's CLI.
-
-```
-$ cargo run --bin=quickchecking -- -h
-```
-[quickcheck]: https://github.com/BurntSushi/quickcheck
diff --git a/tests/quickchecking/src/bin.rs b/tests/quickchecking/src/bin.rs
deleted file mode 100644
index d2774eb0..00000000
--- a/tests/quickchecking/src/bin.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//! An application to run property tests for `bindgen` with _fuzzed_ C headers
-//! using `quickcheck`
-//!
-//! ## Usage
-//!
-//! Print help
-//! ```bash
-//! $ cargo run --bin=quickchecking -- -h
-//! ```
-//!
-//! Run with default values
-//! ```bash
-//! $ cargo run --bin=quickchecking
-//! ```
-//!
-#![deny(missing_docs)]
-extern crate clap;
-extern crate quickchecking;
-
-use clap::{App, Arg};
-use std::path::Path;
-
-// Validate CLI argument input for generation range.
-fn validate_generate_range(v: String) -> Result<(), String> {
-    match v.parse::<usize>() {
-        Ok(_) => Ok(()),
-        Err(_) => Err(String::from(
-            "Generate range could not be converted to a usize.",
-        )),
-    }
-}
-
-// Validate CLI argument input for tests count.
-fn validate_tests_count(v: String) -> Result<(), String> {
-    match v.parse::<usize>() {
-        Ok(_) => Ok(()),
-        Err(_) => Err(String::from(
-            "Tests count could not be converted to a usize.",
-        )),
-    }
-}
-
-// Validate CLI argument input for fuzzed headers output path.
-fn validate_path(v: String) -> Result<(), String> {
-    match Path::new(&v).is_dir() {
-        true => Ok(()),
-        false => Err(String::from("Provided directory path does not exist.")),
-    }
-}
-
-fn main() {
-    let matches = App::new("quickchecking")
-        .version("0.2.0")
-        .about(
-            "Bindgen property tests with quickcheck. \
-             Generate random valid C code and pass it to the \
-             csmith/predicate.py script",
-        )
-        .arg(
-            Arg::with_name("path")
-                .short("p")
-                .long("path")
-                .value_name("PATH")
-                .help(
-                    "Optional. Preserve generated headers for inspection, \
-                     provide directory path for header output. [default: None] ",
-                )
-                .takes_value(true)
-                .validator(validate_path),
-        )
-        .arg(
-            Arg::with_name("range")
-                .short("r")
-                .long("range")
-                .value_name("RANGE")
-                .help(
-                    "Sets the range quickcheck uses during generation. \
-                     Corresponds to things like arbitrary usize and \
-                     arbitrary vector length. This number doesn't have \
-                     to grow much for execution time to increase \
-                     significantly.",
-                )
-                .takes_value(true)
-                .default_value("32")
-                .validator(validate_generate_range),
-        )
-        .arg(
-            Arg::with_name("count")
-                .short("c")
-                .long("count")
-                .value_name("COUNT")
-                .help(
-                    "Count / number of tests to run. Running a fuzzed \
-                     header through the predicate.py script can take a \
-                     long time, especially if the generation range is \
-                     large. Increase this number if you're willing to \
-                     wait a while.",
-                )
-                .takes_value(true)
-                .default_value("2")
-                .validator(validate_tests_count),
-        )
-        .get_matches();
-
-    let output_path: Option<&str> = matches.value_of("path");
-    let generate_range: usize = matches.value_of("range").unwrap().parse::<usize>().unwrap();
-    let tests: usize = matches.value_of("count").unwrap().parse::<usize>().unwrap();
-
-    quickchecking::test_bindgen(generate_range, tests, output_path)
-}
diff --git a/tests/quickchecking/src/fuzzers.rs b/tests/quickchecking/src/fuzzers.rs
deleted file mode 100644
index 7c764425..00000000
--- a/tests/quickchecking/src/fuzzers.rs
+++ /dev/null
@@ -1,637 +0,0 @@
-use quickcheck::{Arbitrary, Gen, StdGen};
-use std::fmt;
-use rand::thread_rng;
-
-/// BaseTypeC is used in generation of C headers to represent the C language's
-/// primitive types as well as `void*`.
-#[derive(Debug, Clone)]
-pub struct BaseTypeC {
-    /// String representation of C type.
-    pub def: String,
-}
-
-/// TypeQualifierC is used in generation of C headers to represent qualifiers
-/// such as `const`.
-#[derive(Debug, Clone)]
-pub struct TypeQualifierC {
-    /// String representation of C type qualifier.
-    pub def: String,
-}
-
-/// PointerLevelC is used in generation of C headers to represent number of
-/// `*` for pointer types.
-#[derive(Debug, Clone)]
-pub struct PointerLevelC {
-    /// String representation of C declaration's pointer level.
-    pub def: String,
-}
-
-/// ArrayDimensionC is used in generation of C headers to represent number of
-/// `[]` used to define array types.
-#[derive(Debug, Clone)]
-pub struct ArrayDimensionC {
-    /// String representation of C declaration's array dimension.
-    pub def: String,
-}
-
-/// BasicTypeDeclarationC is used in generation of C headers to represent
-/// declarations outside of function pointers that take the form
-/// `BaseTypeC` + `TypeQualifierC` + `PointerLevelC` + `ident_id`.
-#[derive(Debug, Clone)]
-pub struct BasicTypeDeclarationC {
-    /// The declaration's base type, i.e. `int`.
-    pub type_name: BaseTypeC,
-    /// The declaration's type qualifier, i.e. `const`.
-    pub type_qualifier: TypeQualifierC,
-    /// The declaration's pointer level, i.e. `***`.
-    pub pointer_level: PointerLevelC,
-    /// The declaration's array dimension, i.e. [][][].
-    pub array_dimension: ArrayDimensionC,
-    /// The declaration's identifier, i.e. ident_N.
-    pub ident_id: String,
-}
-
-/// StructDeclarationC is used in generation of C headers to represent the
-/// definition of a struct type.
-#[derive(Debug, Clone)]
-pub struct StructDeclarationC {
-    /// The declaration's fields.
-    pub fields: DeclarationListC,
-    /// The declaration's array dimension, i.e. [][][].
-    pub array_dimension: ArrayDimensionC,
-    /// The declaration's identifier, i.e. struct_N.
-    pub ident_id: String,
-}
-
-/// UnionDeclarationC is used in generation of C headers to represent the
-/// definition of a union type.
-#[derive(Debug, Clone)]
-pub struct UnionDeclarationC {
-    /// The declaration's fields.
-    pub fields: DeclarationListC,
-    /// The declaration's array dimension, i.e. [][][].
-    pub array_dimension: ArrayDimensionC,
-    /// The declaration's identifier, i.e. union_N.
-    pub ident_id: String,
-}
-
-/// FunctionPointerDeclarationC is used in generation of C headers to represent
-/// the definition of a function pointer type.
-#[derive(Debug, Clone)]
-pub struct FunctionPointerDeclarationC {
-    /// The function's type qualifier, i.e. `const`.
-    pub type_qualifier: TypeQualifierC,
-    /// The function's return type, i.e. `int`.
-    pub type_name: BaseTypeC,
-    /// The function's pointer level, i.e. `***`.
-    pub pointer_level: PointerLevelC,
-    /// The function's parameters.
-    pub params: ParameterListC,
-    /// The declaration's identifier, i.e. func_ptr_N.
-    pub ident_id: String,
-}
-
-/// FunctionPrototypeC is used in generation of C headers to represent the
-/// definition of a function prototype.
-#[derive(Debug, Clone)]
-pub struct FunctionPrototypeC {
-    /// The function's type qualifier, i.e. `const`.
-    pub type_qualifier: TypeQualifierC,
-    /// The function's return type, i.e. `int`.
-    pub type_name: BaseTypeC,
-    /// The function's pointer level, i.e. `***`.
-    pub pointer_level: PointerLevelC,
-    /// The function's parameters.
-    pub params: ParameterListC,
-    /// The prototype's identifier, i.e. `func_N`.
-    pub ident_id: String,
-}
-
-/// ParameterC is used in generation of C headers to represent the
-/// definition function parameters.
-#[derive(Debug, Clone)]
-pub struct ParameterC {
-    /// The parameter's type qualifier, i.e. `const`.
-    pub type_qualifier: TypeQualifierC,
-    /// The parameter's base type, i.e. `int`.
-    pub type_name: BaseTypeC,
-    /// The parameter's pointer level, i.e. `***`.
-    pub pointer_level: PointerLevelC,
-}
-
-/// ParameterListC is used in generation of C headers to represent a list of
-/// definitions of function parameters.
-#[derive(Debug, Clone)]
-pub struct ParameterListC {
-    /// Parameters that define a C function signature.
-    pub params: Vec<ParameterC>,
-}
-
-/// DeclarationC is used in generation of C headers to represent all supported
-/// C type declarations allowed in the generated header.
-#[derive(Debug, Clone)]
-pub enum DeclarationC {
-    /// Function prototype declaration kind.
-    FunctionDecl(FunctionPrototypeC),
-    /// Function pointer declaration kind.
-    FunctionPtrDecl(FunctionPointerDeclarationC),
-    /// Struct declaration kind.
-    StructDecl(StructDeclarationC),
-    /// Union declaration kind.
-    UnionDecl(UnionDeclarationC),
-    /// Basic type declaration kind.
-    VariableDecl(BasicTypeDeclarationC),
-}
-
-/// DeclarationListC is used in generation of C headers to represent a list of
-/// declarations.
-#[derive(Debug, Clone)]
-pub struct DeclarationListC {
-    /// Grouping of C declarations.
-    pub decls: Vec<DeclarationC>,
-}
-
-/// HeaderC is used in generation of C headers to represent a collection of
-/// declarations.
-#[derive(Clone)]
-pub struct HeaderC {
-    /// The header's declarations.
-    pub def: DeclarationListC,
-}
-
-/// MakeUnique is used in generation of C headers to make declaration
-/// identifiers unique by incorporating the `stamp` parameter into it's name.
-trait MakeUnique {
-    fn make_unique(&mut self, stamp: usize);
-}
-
-/// MakeUnique is used in generation of C headers to make DeclarationC
-/// identifiers unique.
-impl MakeUnique for DeclarationC {
-    fn make_unique(&mut self, stamp: usize) {
-        match *self {
-            DeclarationC::FunctionDecl(ref mut d) => d.make_unique(stamp),
-            DeclarationC::FunctionPtrDecl(ref mut d) => d.make_unique(stamp),
-            DeclarationC::StructDecl(ref mut d) => d.make_unique(stamp),
-            DeclarationC::UnionDecl(ref mut d) => d.make_unique(stamp),
-            DeclarationC::VariableDecl(ref mut d) => d.make_unique(stamp),
-        }
-    }
-}
-
-/// A qucickcheck trait for describing how DeclarationC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for DeclarationC {
-    fn arbitrary<G: Gen>(g: &mut G) -> DeclarationC {
-        match g.gen_range(0, 5) {
-            0 => DeclarationC::FunctionDecl(FunctionPrototypeC::arbitrary(g)),
-            1 => DeclarationC::FunctionPtrDecl(FunctionPointerDeclarationC::arbitrary(g)),
-            2 => DeclarationC::StructDecl(StructDeclarationC::arbitrary(g)),
-            3 => DeclarationC::UnionDecl(UnionDeclarationC::arbitrary(g)),
-            4 => DeclarationC::VariableDecl(BasicTypeDeclarationC::arbitrary(g)),
-            _ => unreachable!(),
-        }
-    }
-}
-
-/// Enables to string and format for DeclarationC types.
-impl fmt::Display for DeclarationC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            DeclarationC::FunctionPtrDecl(ref d) => write!(f, "{}", d),
-            DeclarationC::StructDecl(ref d) => write!(f, "{}", d),
-            DeclarationC::UnionDecl(ref d) => write!(f, "{}", d),
-            DeclarationC::VariableDecl(ref d) => write!(f, "{}", d),
-            DeclarationC::FunctionDecl(ref d) => write!(f, "{}", d),
-        }
-    }
-}
-
-/// A qucickcheck trait for describing how DeclarationListC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for DeclarationListC {
-    fn arbitrary<G: Gen>(g: &mut G) -> DeclarationListC {
-        DeclarationListC {
-            decls: Arbitrary::arbitrary(g),
-        }
-    }
-}
-
-/// Enables to string and format for DeclarationListC types.
-impl fmt::Display for DeclarationListC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
-        for decl in &self.decls {
-            display += &format!("{}", decl);
-        }
-        write!(f, "{}", display)
-    }
-}
-
-/// A qucickcheck trait for describing how BaseTypeC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for BaseTypeC {
-    fn arbitrary<G: Gen>(g: &mut G) -> BaseTypeC {
-        // Special case `long double` until issue #550 is resolved.
-        let base_type = vec![
-            "char",
-            "signed char",
-            "unsigned char",
-            "short",
-            "short int",
-            "signed short",
-            "signed short int",
-            "unsigned short",
-            "unsigned short int",
-            "int",
-            "signed",
-            "signed int",
-            "unsigned",
-            "unsigned int",
-            "long",
-            "long int",
-            "signed long",
-            "signed long int",
-            "unsigned long",
-            "unsigned long int",
-            "long long",
-            "long long int",
-            "signed long long",
-            "signed long long int",
-            "unsigned long long",
-            "unsigned long long int",
-            "float",
-            "double",
-            #[cfg(feature = "long-doubles")]
-            "long double",
-            "void*",
-        ];
-        BaseTypeC {
-            def: String::from(*g.choose(&base_type).unwrap()),
-        }
-    }
-}
-
-/// Enables to string and format for BaseTypeC types,
-impl fmt::Display for BaseTypeC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.def)
-    }
-}
-
-/// A qucickcheck trait for describing how TypeQualifierC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for TypeQualifierC {
-    fn arbitrary<G: Gen>(g: &mut G) -> TypeQualifierC {
-        let qualifier = vec!["const", ""];
-        TypeQualifierC {
-            def: String::from(*g.choose(&qualifier).unwrap()),
-        }
-    }
-}
-
-/// Enables to string and format for TypeQualifierC types.
-impl fmt::Display for TypeQualifierC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.def)
-    }
-}
-
-/// A qucickcheck trait for describing how PointerLevelC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for PointerLevelC {
-    fn arbitrary<G: Gen>(g: &mut G) -> PointerLevelC {
-        PointerLevelC {
-            // 16 is an arbitrary "not too big" number for capping pointer level.
-            def: (0..g.gen_range(0, 16)).map(|_| "*").collect::<String>(),
-        }
-    }
-}
-
-/// Enables to string and format for PointerLevelC types.
-impl fmt::Display for PointerLevelC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.def)
-    }
-}
-
-/// A qucickcheck trait for describing how ArrayDimensionC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for ArrayDimensionC {
-    fn arbitrary<G: Gen>(g: &mut G) -> ArrayDimensionC {
-        // Keep these small, clang complains when they get too big.
-        let dimensions = g.gen_range(0, 5);
-        let mut def = String::new();
-
-        let lower_bound;
-        if cfg!(feature = "zero-sized-arrays") {
-            lower_bound = 0;
-        } else {
-            lower_bound = 1;
-        }
-
-        for _ in 1..dimensions {
-            // 16 is an arbitrary "not too big" number for capping array size.
-            def += &format!("[{}]", g.gen_range(lower_bound, 16));
-        }
-        ArrayDimensionC { def }
-    }
-}
-
-/// Enables to string and format for ArrayDimensionC types.
-impl fmt::Display for ArrayDimensionC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.def)
-    }
-}
-
-/// MakeUnique is used in generation of C headers to make BasicTypeDeclarationC
-/// identifiers unique.
-impl MakeUnique for BasicTypeDeclarationC {
-    fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{}", stamp);
-    }
-}
-
-/// A qucickcheck trait for describing how BasicTypeDeclarationC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for BasicTypeDeclarationC {
-    fn arbitrary<G: Gen>(g: &mut G) -> BasicTypeDeclarationC {
-        BasicTypeDeclarationC {
-            type_qualifier: Arbitrary::arbitrary(g),
-            type_name: Arbitrary::arbitrary(g),
-            pointer_level: Arbitrary::arbitrary(g),
-            array_dimension: Arbitrary::arbitrary(g),
-            ident_id: format!("{}", usize::arbitrary(g)),
-        }
-    }
-}
-
-/// Enables to string and format for BasicTypeDeclarationC types.
-impl fmt::Display for BasicTypeDeclarationC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{} {} {} ident_{}{};",
-            self.type_qualifier,
-            self.type_name,
-            self.pointer_level,
-            self.ident_id,
-            self.array_dimension
-        )
-    }
-}
-
-/// MakeUnique is used in generation of C headers to make StructDeclarationC
-/// identifiers unique.
-impl MakeUnique for StructDeclarationC {
-    fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{}", stamp);
-    }
-}
-
-/// A qucickcheck trait for describing how StructDeclarationC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for StructDeclarationC {
-    fn arbitrary<G: Gen>(g: &mut G) -> StructDeclarationC {
-        // Reduce generator size as a method of putting a bound on recursion.
-        // When size < 1 the empty list is generated.
-        let reduced_size: usize = (g.size() / 2) as usize + 1;
-        let mut decl_list: DeclarationListC =
-            Arbitrary::arbitrary(&mut StdGen::new(thread_rng(), reduced_size));
-        let mut fields: DeclarationListC = DeclarationListC { decls: vec![] };
-
-        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
-            match *decl {
-                DeclarationC::FunctionDecl(_) => {}
-                ref mut decl => {
-                    decl.make_unique(i);
-                    fields.decls.push(decl.clone());
-                }
-            }
-        }
-
-        StructDeclarationC {
-            fields,
-            ident_id: format!("{}", usize::arbitrary(g)),
-            array_dimension: Arbitrary::arbitrary(g),
-        }
-    }
-}
-
-/// Enables to string and format for StructDeclarationC types.
-impl fmt::Display for StructDeclarationC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "struct {{ {} }} struct_{}{};",
-            self.fields,
-            self.ident_id,
-            self.array_dimension
-        )
-    }
-}
-
-/// MakeUnique is used in generation of C headers to make UnionDeclarationC
-/// identifiers unique.
-impl MakeUnique for UnionDeclarationC {
-    fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{}", stamp);
-    }
-}
-
-/// A qucickcheck trait for describing how UnionDeclarationC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for UnionDeclarationC {
-    fn arbitrary<G: Gen>(g: &mut G) -> UnionDeclarationC {
-        // Reduce generator size as a method of putting a bound on recursion.
-        // When size < 1 the empty list is generated.
-        let reduced_size: usize = (g.size() / 2) as usize + 1;
-        let mut decl_list: DeclarationListC =
-            Arbitrary::arbitrary(&mut StdGen::new(thread_rng(), reduced_size));
-        let mut fields: DeclarationListC = DeclarationListC { decls: vec![] };
-
-        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
-            match *decl {
-                DeclarationC::FunctionDecl(_) => {}
-                ref mut decl => {
-                    decl.make_unique(i);
-                    fields.decls.push(decl.clone());
-                }
-            }
-        }
-
-        UnionDeclarationC {
-            fields,
-            ident_id: format!("{}", usize::arbitrary(g)),
-            array_dimension: Arbitrary::arbitrary(g),
-        }
-    }
-}
-
-/// Enables to string and format for UnionDeclarationC types.
-impl fmt::Display for UnionDeclarationC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "union {{ {} }} union_{}{};",
-            self.fields,
-            self.ident_id,
-            self.array_dimension
-        )
-    }
-}
-
-/// MakeUnique is used in generation of C headers to make
-/// FunctionPointerDeclarationC identifiers unique.
-impl MakeUnique for FunctionPointerDeclarationC {
-    fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{}", stamp);
-    }
-}
-
-/// A qucickcheck trait for describing how FunctionPointerDeclarationC types can
-/// be randomly generated and shrunk.
-impl Arbitrary for FunctionPointerDeclarationC {
-    fn arbitrary<G: Gen>(g: &mut G) -> FunctionPointerDeclarationC {
-        FunctionPointerDeclarationC {
-            type_qualifier: Arbitrary::arbitrary(g),
-            type_name: Arbitrary::arbitrary(g),
-            pointer_level: Arbitrary::arbitrary(g),
-            params: Arbitrary::arbitrary(g),
-            ident_id: format!("{}", usize::arbitrary(g)),
-        }
-    }
-}
-
-/// Enables to string and format for FunctionPointerDeclarationC types.
-impl fmt::Display for FunctionPointerDeclarationC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{} {} {} (*func_ptr_{})({});",
-            self.type_qualifier,
-            self.type_name,
-            self.pointer_level,
-            self.ident_id,
-            self.params
-        )
-    }
-}
-
-/// MakeUnique is used in generation of C headers to make FunctionPrototypeC
-/// identifiers unique.
-impl MakeUnique for FunctionPrototypeC {
-    fn make_unique(&mut self, stamp: usize) {
-        self.ident_id += &format!("_{}", stamp);
-    }
-}
-
-/// A qucickcheck trait for describing how FunctionPrototypeC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for FunctionPrototypeC {
-    fn arbitrary<G: Gen>(g: &mut G) -> FunctionPrototypeC {
-        FunctionPrototypeC {
-            type_qualifier: Arbitrary::arbitrary(g),
-            type_name: Arbitrary::arbitrary(g),
-            pointer_level: Arbitrary::arbitrary(g),
-            params: Arbitrary::arbitrary(g),
-            ident_id: format!("{}", usize::arbitrary(g)),
-        }
-    }
-}
-
-/// Enables to string and format for FunctionPrototypeC types.
-impl fmt::Display for FunctionPrototypeC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{} {} {} func_{}({});",
-            self.type_qualifier,
-            self.type_name,
-            self.pointer_level,
-            self.ident_id,
-            self.params
-        )
-    }
-}
-
-/// A qucickcheck trait for describing how ParameterC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for ParameterC {
-    fn arbitrary<G: Gen>(g: &mut G) -> ParameterC {
-        ParameterC {
-            type_qualifier: Arbitrary::arbitrary(g),
-            type_name: Arbitrary::arbitrary(g),
-            pointer_level: Arbitrary::arbitrary(g),
-        }
-    }
-}
-
-/// Enables to string and format for ParameterC types.
-impl fmt::Display for ParameterC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{} {} {}",
-            self.type_qualifier,
-            self.type_name,
-            self.pointer_level
-        )
-    }
-}
-
-/// A qucickcheck trait for describing how ParameterListC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for ParameterListC {
-    fn arbitrary<G: Gen>(g: &mut G) -> ParameterListC {
-        ParameterListC {
-            params: Arbitrary::arbitrary(g),
-        }
-    }
-}
-
-/// Enables to string and format for ParameterListC types.
-impl fmt::Display for ParameterListC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
-        for (i, p) in self.params.iter().enumerate() {
-            match i {
-                0 => display += &format!("{}", p),
-                _ => display += &format!(",{}", p),
-            }
-        }
-        write!(f, "{}", display)
-    }
-}
-
-/// A qucickcheck trait for describing how HeaderC types can be
-/// randomly generated and shrunk.
-impl Arbitrary for HeaderC {
-    fn arbitrary<G: Gen>(g: &mut G) -> HeaderC {
-        let mut decl_list: DeclarationListC = Arbitrary::arbitrary(g);
-        for (i, decl) in decl_list.decls.iter_mut().enumerate() {
-            decl.make_unique(i);
-        }
-        HeaderC { def: decl_list }
-    }
-}
-
-/// Enables to string and format for HeaderC types.
-impl fmt::Display for HeaderC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut display = String::new();
-        for decl in &self.def.decls {
-            display += &format!("{}", decl);
-        }
-        write!(f, "{}", display)
-    }
-}
-
-/// Use Display trait for Debug so that any failing property tests report
-/// generated C code rather than the data structures that contain it.
-impl fmt::Debug for HeaderC {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self)
-    }
-}
diff --git a/tests/quickchecking/src/lib.rs b/tests/quickchecking/src/lib.rs
deleted file mode 100644
index d8633dfb..00000000
--- a/tests/quickchecking/src/lib.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-//! A library to generate __fuzzed__ C headers for use with `quickcheck`
-//!
-//! ## Example
-//!
-//! ```rust
-//! extern crate quickcheck;
-//! extern crate quickchecking;
-//! extern crate rand;
-//! use quickcheck::{Arbitrary, Gen, StdGen};
-//! use quickchecking::fuzzers;
-//! use rand::thread_rng;
-//!
-//! fn main() {
-//!     let generate_range: usize = 10; // Determines things like the length of
-//!                                     // arbitrary vectors generated.
-//!     let header = fuzzers::HeaderC::arbitrary(
-//!        &mut StdGen::new(thread_rng(), generate_range));
-//!     println!("{}", header);
-//! }
-//! ```
-//!
-#![deny(missing_docs)]
-#[macro_use]
-extern crate lazy_static;
-extern crate quickcheck;
-extern crate rand;
-extern crate tempdir;
-
-use std::sync::Mutex;
-use quickcheck::{QuickCheck, StdGen, TestResult};
-use std::fs::File;
-use std::io::Write;
-use tempdir::TempDir;
-use std::process::{Command, Output};
-use std::path::PathBuf;
-use std::error::Error;
-use rand::thread_rng;
-
-/// Contains definitions of and impls for types used to fuzz C declarations.
-pub mod fuzzers;
-
-// Global singleton, manages context across tests. For now that context is
-// only the output_path for inspecting fuzzed headers (if specified).
-struct Context {
-    output_path: Option<String>,
-}
-
-// Initialize global context.
-lazy_static! {
-    static ref CONTEXT: Mutex<Context> = Mutex::new(Context { output_path: None });
-}
-
-// Passes fuzzed header to the `csmith-fuzzing/predicate.py` script, returns
-// output of the associated command.
-fn run_predicate_script(header: fuzzers::HeaderC) -> Result<Output, Box<Error>> {
-    let dir = TempDir::new("bindgen_prop")?;
-    let header_path = dir.path().join("prop_test.h");
-
-    let mut header_file = File::create(&header_path)?;
-    header_file.write_all(header.to_string().as_bytes())?;
-    header_file.sync_all()?;
-
-    let header_path_string;
-    match header_path.into_os_string().into_string() {
-        Ok(s) => header_path_string = s,
-        Err(_) => return Err(From::from("error converting path into String")),
-    }
-
-    let mut predicate_script_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    predicate_script_path.push("../../csmith-fuzzing/predicate.py");
-
-    let predicate_script_path_string;
-    match predicate_script_path.into_os_string().into_string() {
-        Ok(s) => predicate_script_path_string = s,
-        Err(_) => return Err(From::from("error converting path into String")),
-    }
-
-    // Copy generated temp files to output_path directory for inspection.
-    // If `None`, output path not specified, don't copy.
-    match CONTEXT.lock().unwrap().output_path {
-        Some(ref path) => {
-            Command::new("cp")
-                .arg("-a")
-                .arg(&dir.path().to_str().unwrap())
-                .arg(&path)
-                .output()?;
-        }
-        None => {}
-    }
-
-    Ok(Command::new(&predicate_script_path_string)
-        .arg(&header_path_string)
-        .output()?)
-}
-
-// Generatable property. Pass generated headers off to run through the
-// `csmith-fuzzing/predicate.py` script. Success is measured by the success
-// status of that command.
-fn bindgen_prop(header: fuzzers::HeaderC) -> TestResult {
-    match run_predicate_script(header) {
-        Ok(o) => return TestResult::from_bool(o.status.success()),
-        Err(e) => {
-            println!("{:?}", e);
-            return TestResult::from_bool(false);
-        }
-    }
-}
-
-/// Instantiate a Quickcheck object and use it to run property tests using
-/// fuzzed C headers generated with types defined in the `fuzzers` module.
-/// Success/Failure is dictated by the result of passing the fuzzed headers
-/// to the `csmith-fuzzing/predicate.py` script.
-pub fn test_bindgen(generate_range: usize, tests: usize, output_path: Option<&str>) {
-    match output_path {
-        Some(path) => {
-            CONTEXT.lock().unwrap().output_path =
-                Some(String::from(PathBuf::from(path).to_str().unwrap()));
-        }
-        None => {} // Path not specified, don't provide output.
-    }
-
-    QuickCheck::new()
-        .tests(tests)
-        .gen(StdGen::new(thread_rng(), generate_range))
-        .quickcheck(bindgen_prop as fn(fuzzers::HeaderC) -> TestResult)
-}
diff --git a/tests/quickchecking/tests/fuzzed-c-headers.rs b/tests/quickchecking/tests/fuzzed-c-headers.rs
deleted file mode 100644
index 6b58d24b..00000000
--- a/tests/quickchecking/tests/fuzzed-c-headers.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-
-extern crate quickcheck;
-extern crate quickchecking;
-extern crate rand;
-
-use quickchecking::fuzzers::{ArrayDimensionC, BaseTypeC, BasicTypeDeclarationC, DeclarationC,
-                             DeclarationListC, FunctionPointerDeclarationC, FunctionPrototypeC,
-                             HeaderC, ParameterC, ParameterListC, PointerLevelC,
-                             StructDeclarationC, TypeQualifierC, UnionDeclarationC};
-use quickcheck::{Arbitrary, StdGen};
-use rand::thread_rng;
-
-#[test]
-fn test_declaraion_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: DeclarationC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_declaraion_list_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: DeclarationListC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_base_type_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: BaseTypeC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_type_qualifier_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: TypeQualifierC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_pointer_level_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: PointerLevelC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_array_dimension_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: ArrayDimensionC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_basic_type_declaration_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: BasicTypeDeclarationC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_struct_declaration_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: StructDeclarationC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_union_declaration_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: UnionDeclarationC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_function_pointer_declaration_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: FunctionPointerDeclarationC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_function_prototype_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: FunctionPrototypeC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_parameter_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: ParameterC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_parameter_list_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: ParameterListC = Arbitrary::arbitrary(gen);
-}
-
-#[test]
-fn test_header_c_does_not_panic() {
-    let ref mut gen = StdGen::new(thread_rng(), 50);
-    let _: HeaderC = Arbitrary::arbitrary(gen);
-}
diff --git a/tests/rustfmt.toml b/tests/rustfmt.toml
deleted file mode 100644
index 2564ccb5..00000000
--- a/tests/rustfmt.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-normalize_doc_attributes = true
-max_width = 80
-binop_separator = "back"
diff --git a/tests/stylo.hpp b/tests/stylo.hpp
deleted file mode 100644
index 88102903..00000000
--- a/tests/stylo.hpp
+++ /dev/null
@@ -1,177914 +0,0 @@
-# 1 "stylo.cpp"
-# 1 "<built-in>" 1
-# 1 "<built-in>" 3
-# 352 "<built-in>" 3
-# 1 "<command line>" 1
-# 1 "<built-in>" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
-#pragma clang diagnostic push
-
-#pragma clang diagnostic ignored "-Wreserved-id-macro"
-# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
-#pragma clang diagnostic pop
-# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h" 1
-# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Char16.h"
-typedef const char16_t* char16ptr_t;
-
-
-
-static_assert(sizeof(char16_t) == 2, "Is char16_t type 16 bits?");
-static_assert(char16_t(-1) > char16_t(0), "Is char16_t type unsigned?");
-static_assert(sizeof(u'A') == 2, "Is unicode char literal 16 bits?");
-static_assert(sizeof(u""[0]) == 2, "Is unicode string char 16 bits?");
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla-config.h" 2
-# 2 "<built-in>" 2
-# 1 "stylo.cpp" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 1 3
-# 63 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 3
-# 1 "/usr/include/stdint.h" 1 3 4
-# 25 "/usr/include/stdint.h" 3 4
-# 1 "/usr/include/features.h" 1 3 4
-# 346 "/usr/include/features.h" 3 4
-# 1 "/usr/include/stdc-predef.h" 1 3 4
-# 347 "/usr/include/features.h" 2 3 4
-# 368 "/usr/include/features.h" 3 4
-# 1 "/usr/include/sys/cdefs.h" 1 3 4
-# 415 "/usr/include/sys/cdefs.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 416 "/usr/include/sys/cdefs.h" 2 3 4
-# 369 "/usr/include/features.h" 2 3 4
-# 392 "/usr/include/features.h" 3 4
-# 1 "/usr/include/gnu/stubs.h" 1 3 4
-# 10 "/usr/include/gnu/stubs.h" 3 4
-# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
-# 11 "/usr/include/gnu/stubs.h" 2 3 4
-# 393 "/usr/include/features.h" 2 3 4
-# 26 "/usr/include/stdint.h" 2 3 4
-# 1 "/usr/include/bits/wchar.h" 1 3 4
-# 27 "/usr/include/stdint.h" 2 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 28 "/usr/include/stdint.h" 2 3 4
-
-
-
-
-
-
-
-
-typedef signed char int8_t;
-typedef short int int16_t;
-typedef int int32_t;
-
-typedef long int int64_t;
-
-
-
-
-
-
-
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-
-typedef unsigned int uint32_t;
-
-
-
-typedef unsigned long int uint64_t;
-# 65 "/usr/include/stdint.h" 3 4
-typedef signed char int_least8_t;
-typedef short int int_least16_t;
-typedef int int_least32_t;
-
-typedef long int int_least64_t;
-
-
-
-
-
-
-typedef unsigned char uint_least8_t;
-typedef unsigned short int uint_least16_t;
-typedef unsigned int uint_least32_t;
-
-typedef unsigned long int uint_least64_t;
-# 90 "/usr/include/stdint.h" 3 4
-typedef signed char int_fast8_t;
-
-typedef long int int_fast16_t;
-typedef long int int_fast32_t;
-typedef long int int_fast64_t;
-# 103 "/usr/include/stdint.h" 3 4
-typedef unsigned char uint_fast8_t;
-
-typedef unsigned long int uint_fast16_t;
-typedef unsigned long int uint_fast32_t;
-typedef unsigned long int uint_fast64_t;
-# 119 "/usr/include/stdint.h" 3 4
-typedef long int intptr_t;
-
-
-typedef unsigned long int uintptr_t;
-# 134 "/usr/include/stdint.h" 3 4
-typedef long int intmax_t;
-typedef unsigned long int uintmax_t;
-# 64 "/usr/local/bin/../lib/clang/3.9.1/include/stdint.h" 2 3
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 1
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 1 3
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 3
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 1 3
-
-
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 4 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
-# 2106 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
-namespace std
-{
-  typedef long unsigned int size_t;
-  typedef long int ptrdiff_t;
-
-
-  typedef decltype(nullptr) nullptr_t;
-
-}
-# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
-namespace std
-{
-  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
-}
-namespace __gnu_cxx
-{
-  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
-}
-# 2414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/os_defines.h" 1 3
-# 2415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
-# 2418 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++config.h" 2 3
-# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 51 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
-typedef long int ptrdiff_t;
-# 62 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
-typedef long unsigned int size_t;
-# 118 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 1 3
-# 35 "/usr/local/bin/../lib/clang/3.9.1/include/__stddef_max_align_t.h" 3
-typedef struct {
-  long long __clang_max_align_nonce1
-      __attribute__((__aligned__(__alignof__(long long))));
-  long double __clang_max_align_nonce2
-      __attribute__((__aligned__(__alignof__(long double))));
-} max_align_t;
-# 119 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 2 3
-# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstddef" 2 3
-
-
-namespace std
-{
-
-  using ::max_align_t;
-}
-# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Compiler.h" 2
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Attributes.h" 2
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Types.h" 2
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2
-
-
-
-
-
-
-
-# 1 "/usr/include/wchar.h" 1 3 4
-# 36 "/usr/include/wchar.h" 3 4
-# 1 "/usr/include/stdio.h" 1 3 4
-# 44 "/usr/include/stdio.h" 3 4
-struct _IO_FILE;
-
-
-
-typedef struct _IO_FILE FILE;
-# 64 "/usr/include/stdio.h" 3 4
-typedef struct _IO_FILE __FILE;
-# 37 "/usr/include/wchar.h" 2 3 4
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 1 3 4
-# 30 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4
-typedef __builtin_va_list va_list;
-# 50 "/usr/local/bin/../lib/clang/3.9.1/include/stdarg.h" 3 4
-typedef __builtin_va_list __gnuc_va_list;
-# 40 "/usr/include/wchar.h" 2 3 4
-# 51 "/usr/include/wchar.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 132 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 3 4
-typedef unsigned int wint_t;
-# 52 "/usr/include/wchar.h" 2 3 4
-# 82 "/usr/include/wchar.h" 3 4
-typedef struct
-{
-  int __count;
-  union
-  {
-
-    unsigned int __wch;
-
-
-
-    char __wchb[4];
-  } __value;
-} __mbstate_t;
-# 106 "/usr/include/wchar.h" 3 4
-typedef __mbstate_t mbstate_t;
-# 132 "/usr/include/wchar.h" 3 4
-extern "C" {
-
-
-
-
-struct tm;
-# 147 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcscpy (wchar_t *__restrict __dest,
-   const wchar_t *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
-    const wchar_t *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern wchar_t *wcscat (wchar_t *__restrict __dest,
-   const wchar_t *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern wchar_t *wcsncat (wchar_t *__restrict __dest,
-    const wchar_t *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
-
-
-extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
-   size_t __n) throw ();
-
-
-
-
-# 1 "/usr/include/xlocale.h" 1 3 4
-# 27 "/usr/include/xlocale.h" 3 4
-typedef struct __locale_struct
-{
-
-  struct __locale_data *__locales[13];
-
-
-  const unsigned short int *__ctype_b;
-  const int *__ctype_tolower;
-  const int *__ctype_toupper;
-
-
-  const char *__names[13];
-} *__locale_t;
-
-
-typedef __locale_t locale_t;
-# 184 "/usr/include/wchar.h" 2 3 4
-
-extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
-    __locale_t __loc) throw ();
-
-extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
-     size_t __n, __locale_t __loc) throw ();
-
-
-
-
-
-extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
-
-
-
-extern size_t wcsxfrm (wchar_t *__restrict __s1,
-         const wchar_t *__restrict __s2, size_t __n) throw ();
-# 209 "/usr/include/wchar.h" 3 4
-extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
-        __locale_t __loc) throw ();
-
-
-
-
-extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
-    size_t __n, __locale_t __loc) throw ();
-
-
-extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
-# 230 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
-     throw () __attribute__ ((__pure__));
-# 240 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
-     throw () __attribute__ ((__pure__));
-
-
-
-
-
-
-extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
-     throw () __attribute__ ((__pure__));
-
-
-
-
-
-extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
-     throw () __attribute__ ((__pure__));
-
-
-extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
-     throw () __attribute__ ((__pure__));
-# 269 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
-     throw () __attribute__ ((__pure__));
-# 280 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
-     throw () __attribute__ ((__pure__));
-
-
-
-extern wchar_t *wcstok (wchar_t *__restrict __s,
-   const wchar_t *__restrict __delim,
-   wchar_t **__restrict __ptr) throw ();
-
-
-extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
-# 302 "/usr/include/wchar.h" 3 4
-extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
-     throw () __attribute__ ((__pure__));
-
-
-
-
-
-extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
-     throw () __attribute__ ((__pure__));
-# 323 "/usr/include/wchar.h" 3 4
-extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
-     throw () __attribute__ ((__pure__));
-
-
-
-extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
-     throw () __attribute__ ((__pure__));
-
-
-extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
-    const wchar_t *__restrict __s2, size_t __n) throw ();
-
-
-
-extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
-     throw ();
-
-
-extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
-
-
-
-
-
-extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
-     const wchar_t *__restrict __s2, size_t __n)
-     throw ();
-
-
-
-
-
-
-extern wint_t btowc (int __c) throw ();
-
-
-
-extern int wctob (wint_t __c) throw ();
-
-
-
-extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
-
-
-
-extern size_t mbrtowc (wchar_t *__restrict __pwc,
-         const char *__restrict __s, size_t __n,
-         mbstate_t *__restrict __p) throw ();
-
-
-extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
-         mbstate_t *__restrict __ps) throw ();
-
-
-extern size_t __mbrlen (const char *__restrict __s, size_t __n,
-   mbstate_t *__restrict __ps) throw ();
-extern size_t mbrlen (const char *__restrict __s, size_t __n,
-        mbstate_t *__restrict __ps) throw ();
-# 411 "/usr/include/wchar.h" 3 4
-extern size_t mbsrtowcs (wchar_t *__restrict __dst,
-    const char **__restrict __src, size_t __len,
-    mbstate_t *__restrict __ps) throw ();
-
-
-
-extern size_t wcsrtombs (char *__restrict __dst,
-    const wchar_t **__restrict __src, size_t __len,
-    mbstate_t *__restrict __ps) throw ();
-
-
-
-
-
-
-extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
-     const char **__restrict __src, size_t __nmc,
-     size_t __len, mbstate_t *__restrict __ps) throw ();
-
-
-
-extern size_t wcsnrtombs (char *__restrict __dst,
-     const wchar_t **__restrict __src,
-     size_t __nwc, size_t __len,
-     mbstate_t *__restrict __ps) throw ();
-
-
-
-
-
-
-extern int wcwidth (wchar_t __c) throw ();
-
-
-
-extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
-
-
-
-
-
-
-extern double wcstod (const wchar_t *__restrict __nptr,
-        wchar_t **__restrict __endptr) throw ();
-
-
-
-
-
-extern float wcstof (const wchar_t *__restrict __nptr,
-       wchar_t **__restrict __endptr) throw ();
-extern long double wcstold (const wchar_t *__restrict __nptr,
-       wchar_t **__restrict __endptr) throw ();
-
-
-
-
-
-
-
-extern long int wcstol (const wchar_t *__restrict __nptr,
-   wchar_t **__restrict __endptr, int __base) throw ();
-
-
-
-extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
-      wchar_t **__restrict __endptr, int __base)
-     throw ();
-
-
-
-
-
-
-__extension__
-extern long long int wcstoll (const wchar_t *__restrict __nptr,
-         wchar_t **__restrict __endptr, int __base)
-     throw ();
-
-
-
-__extension__
-extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
-     wchar_t **__restrict __endptr,
-     int __base) throw ();
-
-
-
-
-
-
-__extension__
-extern long long int wcstoq (const wchar_t *__restrict __nptr,
-        wchar_t **__restrict __endptr, int __base)
-     throw ();
-
-
-
-__extension__
-extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
-           wchar_t **__restrict __endptr,
-           int __base) throw ();
-# 533 "/usr/include/wchar.h" 3 4
-extern long int wcstol_l (const wchar_t *__restrict __nptr,
-     wchar_t **__restrict __endptr, int __base,
-     __locale_t __loc) throw ();
-
-extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
-        wchar_t **__restrict __endptr,
-        int __base, __locale_t __loc) throw ();
-
-__extension__
-extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
-    wchar_t **__restrict __endptr,
-    int __base, __locale_t __loc) throw ();
-
-__extension__
-extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
-       wchar_t **__restrict __endptr,
-       int __base, __locale_t __loc)
-     throw ();
-
-extern double wcstod_l (const wchar_t *__restrict __nptr,
-   wchar_t **__restrict __endptr, __locale_t __loc)
-     throw ();
-
-extern float wcstof_l (const wchar_t *__restrict __nptr,
-         wchar_t **__restrict __endptr, __locale_t __loc)
-     throw ();
-
-extern long double wcstold_l (const wchar_t *__restrict __nptr,
-         wchar_t **__restrict __endptr,
-         __locale_t __loc) throw ();
-
-
-
-
-
-
-extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
-   const wchar_t *__restrict __src) throw ();
-
-
-
-extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
-    const wchar_t *__restrict __src, size_t __n)
-     throw ();
-
-
-
-
-
-
-extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
-
-
-
-
-
-
-extern int fwide (__FILE *__fp, int __mode) throw ();
-
-
-
-
-
-
-extern int fwprintf (__FILE *__restrict __stream,
-       const wchar_t *__restrict __format, ...)
-                                                           ;
-
-
-
-
-extern int wprintf (const wchar_t *__restrict __format, ...)
-                                                           ;
-
-extern int swprintf (wchar_t *__restrict __s, size_t __n,
-       const wchar_t *__restrict __format, ...)
-     throw () ;
-
-
-
-
-
-extern int vfwprintf (__FILE *__restrict __s,
-        const wchar_t *__restrict __format,
-        __gnuc_va_list __arg)
-                                                           ;
-
-
-
-
-extern int vwprintf (const wchar_t *__restrict __format,
-       __gnuc_va_list __arg)
-                                                           ;
-
-
-extern int vswprintf (wchar_t *__restrict __s, size_t __n,
-        const wchar_t *__restrict __format,
-        __gnuc_va_list __arg)
-     throw () ;
-
-
-
-
-
-
-extern int fwscanf (__FILE *__restrict __stream,
-      const wchar_t *__restrict __format, ...)
-                                                          ;
-
-
-
-
-extern int wscanf (const wchar_t *__restrict __format, ...)
-                                                          ;
-
-extern int swscanf (const wchar_t *__restrict __s,
-      const wchar_t *__restrict __format, ...)
-     throw () ;
-# 692 "/usr/include/wchar.h" 3 4
-extern int vfwscanf (__FILE *__restrict __s,
-       const wchar_t *__restrict __format,
-       __gnuc_va_list __arg)
-                                                          ;
-
-
-
-
-extern int vwscanf (const wchar_t *__restrict __format,
-      __gnuc_va_list __arg)
-                                                          ;
-
-extern int vswscanf (const wchar_t *__restrict __s,
-       const wchar_t *__restrict __format,
-       __gnuc_va_list __arg)
-     throw () ;
-# 748 "/usr/include/wchar.h" 3 4
-extern wint_t fgetwc (__FILE *__stream);
-extern wint_t getwc (__FILE *__stream);
-
-
-
-
-
-extern wint_t getwchar (void);
-
-
-
-
-
-
-extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
-extern wint_t putwc (wchar_t __wc, __FILE *__stream);
-
-
-
-
-
-extern wint_t putwchar (wchar_t __wc);
-
-
-
-
-
-
-
-extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
-   __FILE *__restrict __stream);
-
-
-
-
-
-extern int fputws (const wchar_t *__restrict __ws,
-     __FILE *__restrict __stream);
-
-
-
-
-
-
-extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
-# 804 "/usr/include/wchar.h" 3 4
-extern wint_t getwc_unlocked (__FILE *__stream);
-extern wint_t getwchar_unlocked (void);
-
-
-
-
-
-
-
-extern wint_t fgetwc_unlocked (__FILE *__stream);
-
-
-
-
-
-
-
-extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
-# 830 "/usr/include/wchar.h" 3 4
-extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
-extern wint_t putwchar_unlocked (wchar_t __wc);
-# 840 "/usr/include/wchar.h" 3 4
-extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
-     __FILE *__restrict __stream);
-
-
-
-
-
-
-
-extern int fputws_unlocked (const wchar_t *__restrict __ws,
-       __FILE *__restrict __stream);
-
-
-
-
-
-
-
-extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
-   const wchar_t *__restrict __format,
-   const struct tm *__restrict __tp) throw ();
-
-
-
-
-
-
-
-extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
-     const wchar_t *__restrict __format,
-     const struct tm *__restrict __tp,
-     __locale_t __loc) throw ();
-# 894 "/usr/include/wchar.h" 3 4
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h" 2
-
-namespace mozilla {
-
-
-
-template<typename> struct RemoveCV;
-template<typename> struct AddRvalueReference;
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-typename AddRvalueReference<T>::Type DeclVal();
-
-
-
-
-
-
-
-template<typename T, T Value>
-struct IntegralConstant
-{
-  static constexpr T value = Value;
-  typedef T ValueType;
-  typedef IntegralConstant<T, Value> Type;
-};
-
-
-typedef IntegralConstant<bool, true> TrueType;
-typedef IntegralConstant<bool, false> FalseType;
-
-
-
-
-
-namespace detail {
-
-template<typename T>
-struct IsVoidHelper : FalseType {};
-
-template<>
-struct IsVoidHelper<void> : TrueType {};
-
-}
-# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsVoid : detail::IsVoidHelper<typename RemoveCV<T>::Type> {};
-
-namespace detail {
-
-template <typename T>
-struct IsIntegralHelper : FalseType {};
-
-template<> struct IsIntegralHelper<char> : TrueType {};
-template<> struct IsIntegralHelper<signed char> : TrueType {};
-template<> struct IsIntegralHelper<unsigned char> : TrueType {};
-template<> struct IsIntegralHelper<short> : TrueType {};
-template<> struct IsIntegralHelper<unsigned short> : TrueType {};
-template<> struct IsIntegralHelper<int> : TrueType {};
-template<> struct IsIntegralHelper<unsigned int> : TrueType {};
-template<> struct IsIntegralHelper<long> : TrueType {};
-template<> struct IsIntegralHelper<unsigned long> : TrueType {};
-template<> struct IsIntegralHelper<long long> : TrueType {};
-template<> struct IsIntegralHelper<unsigned long long> : TrueType {};
-template<> struct IsIntegralHelper<bool> : TrueType {};
-template<> struct IsIntegralHelper<wchar_t> : TrueType {};
-template<> struct IsIntegralHelper<char16_t> : TrueType {};
-
-}
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsIntegral : detail::IsIntegralHelper<typename RemoveCV<T>::Type>
-{};
-
-template<typename T, typename U>
-struct IsSame;
-
-namespace detail {
-
-template<typename T>
-struct IsFloatingPointHelper
-  : IntegralConstant<bool,
-                     IsSame<T, float>::value ||
-                     IsSame<T, double>::value ||
-                     IsSame<T, long double>::value>
-{};
-
-}
-# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsFloatingPoint
-  : detail::IsFloatingPointHelper<typename RemoveCV<T>::Type>
-{};
-
-namespace detail {
-
-template<typename T>
-struct IsArrayHelper : FalseType {};
-
-template<typename T, decltype(sizeof(1)) N>
-struct IsArrayHelper<T[N]> : TrueType {};
-
-template<typename T>
-struct IsArrayHelper<T[]> : TrueType {};
-
-}
-# 168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsArray : detail::IsArrayHelper<typename RemoveCV<T>::Type>
-{};
-
-namespace detail {
-
-template<typename T>
-struct IsFunPtr;
-
-template<typename>
-struct IsFunPtr
-  : public FalseType
-{};
-
-template<typename Result, typename... ArgTypes>
-struct IsFunPtr<Result(*)(ArgTypes...)>
-  : public TrueType
-{};
-
-};
-# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsFunction
-  : public detail::IsFunPtr<typename RemoveCV<T>::Type *>
-{};
-
-namespace detail {
-
-template<typename T>
-struct IsPointerHelper : FalseType {};
-
-template<typename T>
-struct IsPointerHelper<T*> : TrueType {};
-
-}
-# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsPointer : detail::IsPointerHelper<typename RemoveCV<T>::Type>
-{};
-# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsLvalueReference : FalseType {};
-
-template<typename T>
-struct IsLvalueReference<T&> : TrueType {};
-# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsRvalueReference : FalseType {};
-
-template<typename T>
-struct IsRvalueReference<T&&> : TrueType {};
-
-namespace detail {
-
-
-template<typename T>
-struct IsEnumHelper
-  : IntegralConstant<bool, __is_enum(T)>
-{};
-
-}
-# 286 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsEnum
-  : detail::IsEnumHelper<typename RemoveCV<T>::Type>
-{};
-
-namespace detail {
-
-
-
-
-
-template<typename T>
-struct IsClassHelper
-  : IntegralConstant<bool, __is_class(T)>
-{};
-
-}
-# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsClass
-  : detail::IsClassHelper<typename RemoveCV<T>::Type>
-{};
-# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsReference
-  : IntegralConstant<bool,
-                     IsLvalueReference<T>::value || IsRvalueReference<T>::value>
-{};
-# 348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsArithmetic
-  : IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>
-{};
-
-namespace detail {
-
-template<typename T>
-struct IsMemberPointerHelper : FalseType {};
-
-template<typename T, typename U>
-struct IsMemberPointerHelper<T U::*> : TrueType {};
-
-}
-# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsMemberPointer
-  : detail::IsMemberPointerHelper<typename RemoveCV<T>::Type>
-{};
-# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsScalar
-  : IntegralConstant<bool, IsArithmetic<T>::value || IsEnum<T>::value ||
-                     IsPointer<T>::value || IsMemberPointer<T>::value>
-{};
-# 397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsConst : FalseType {};
-
-template<typename T>
-struct IsConst<const T> : TrueType {};
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsVolatile : FalseType {};
-
-template<typename T>
-struct IsVolatile<volatile T> : TrueType {};
-# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsPod : public FalseType {};
-
-template<> struct IsPod<char> : TrueType {};
-template<> struct IsPod<signed char> : TrueType {};
-template<> struct IsPod<unsigned char> : TrueType {};
-template<> struct IsPod<short> : TrueType {};
-template<> struct IsPod<unsigned short> : TrueType {};
-template<> struct IsPod<int> : TrueType {};
-template<> struct IsPod<unsigned int> : TrueType {};
-template<> struct IsPod<long> : TrueType {};
-template<> struct IsPod<unsigned long> : TrueType {};
-template<> struct IsPod<long long> : TrueType {};
-template<> struct IsPod<unsigned long long> : TrueType {};
-template<> struct IsPod<bool> : TrueType {};
-template<> struct IsPod<float> : TrueType {};
-template<> struct IsPod<double> : TrueType {};
-template<> struct IsPod<wchar_t> : TrueType {};
-template<> struct IsPod<char16_t> : TrueType {};
-template<typename T> struct IsPod<T*> : TrueType {};
-
-namespace detail {
-
-
-
-
-
-template<typename T>
-struct IsEmptyHelper
-  : IntegralConstant<bool, IsClass<T>::value && __is_empty(T)>
-{};
-
-}
-# 498 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsEmpty : detail::IsEmptyHelper<typename RemoveCV<T>::Type>
-{};
-
-
-namespace detail {
-
-template<typename T,
-         bool = IsFloatingPoint<T>::value,
-         bool = IsIntegral<T>::value,
-         typename NoCV = typename RemoveCV<T>::Type>
-struct IsSignedHelper;
-
-
-template<typename T, typename NoCV>
-struct IsSignedHelper<T, true, false, NoCV> : TrueType {};
-
-
-template<typename T, typename NoCV>
-struct IsSignedHelper<T, false, true, NoCV>
-  : IntegralConstant<bool, bool(NoCV(-1) < NoCV(1))>
-{};
-
-
-template<typename T, typename NoCV>
-struct IsSignedHelper<T, false, false, NoCV> : FalseType {};
-
-}
-# 536 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsSigned : detail::IsSignedHelper<T> {};
-
-namespace detail {
-
-template<typename T,
-         bool = IsFloatingPoint<T>::value,
-         bool = IsIntegral<T>::value,
-         typename NoCV = typename RemoveCV<T>::Type>
-struct IsUnsignedHelper;
-
-
-template<typename T, typename NoCV>
-struct IsUnsignedHelper<T, true, false, NoCV> : FalseType {};
-
-
-template<typename T, typename NoCV>
-struct IsUnsignedHelper<T, false, true, NoCV>
-  : IntegralConstant<bool,
-                     (IsSame<NoCV, bool>::value || bool(NoCV(1) < NoCV(-1)))>
-{};
-
-
-template<typename T, typename NoCV>
-struct IsUnsignedHelper<T, false, false, NoCV> : FalseType {};
-
-}
-# 572 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsUnsigned : detail::IsUnsignedHelper<T> {};
-
-namespace detail {
-
-struct DoIsDefaultConstructibleImpl
-{
-  template<typename T, typename = decltype(T())>
-  static TrueType test(int);
-  template<typename T>
-  static FalseType test(...);
-};
-
-template<typename T>
-struct IsDefaultConstructibleImpl : public DoIsDefaultConstructibleImpl
-{
-  typedef decltype(test<T>(0)) Type;
-};
-
-}
-# 611 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsDefaultConstructible
-  : public detail::IsDefaultConstructibleImpl<T>::Type
-{};
-
-namespace detail {
-
-struct DoIsDestructibleImpl
-{
-  template<typename T, typename = decltype(DeclVal<T&>().~T())>
-  static TrueType test(int);
-  template<typename T>
-  static FalseType test(...);
-};
-
-template<typename T>
-struct IsDestructibleImpl : public DoIsDestructibleImpl
-{
-  typedef decltype(test<T>(0)) Type;
-};
-
-}
-# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct IsDestructible : public detail::IsDestructibleImpl<T>::Type {};
-# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T, typename U>
-struct IsSame : FalseType {};
-
-template<typename T>
-struct IsSame<T, T> : TrueType {};
-
-namespace detail {
-
-
-
-template<class Base, class Derived>
-struct BaseOfTester : IntegralConstant<bool, __is_base_of(Base, Derived)> {};
-# 727 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-}
-# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<class Base, class Derived>
-struct IsBaseOf
-  : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
-{};
-
-namespace detail {
-
-template<typename From, typename To>
-struct ConvertibleTester
-{
-private:
-  template<typename To1>
-  static char test_helper(To1);
-
-  template<typename From1, typename To1>
-  static decltype(test_helper<To1>(DeclVal<From1>())) test(int);
-
-  template<typename From1, typename To1>
-  static int test(...);
-
-public:
-  static const bool value =
-    sizeof(test<From, To>(0)) == sizeof(char);
-};
-
-}
-# 793 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename From, typename To>
-struct IsConvertible
-  : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
-{};
-
-template<typename B>
-struct IsConvertible<void, B>
-  : IntegralConstant<bool, IsVoid<B>::value>
-{};
-
-template<typename A>
-struct IsConvertible<A, void>
-  : IntegralConstant<bool, IsVoid<A>::value>
-{};
-
-template<>
-struct IsConvertible<void, void>
-  : TrueType
-{};
-# 825 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemoveConst
-{
-  typedef T Type;
-};
-
-template<typename T>
-struct RemoveConst<const T>
-{
-  typedef T Type;
-};
-# 845 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemoveVolatile
-{
-  typedef T Type;
-};
-
-template<typename T>
-struct RemoveVolatile<volatile T>
-{
-  typedef T Type;
-};
-# 865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemoveCV
-{
-  typedef typename RemoveConst<typename RemoveVolatile<T>::Type>::Type Type;
-};
-# 881 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemoveReference
-{
-  typedef T Type;
-};
-
-template<typename T>
-struct RemoveReference<T&>
-{
-  typedef T Type;
-};
-
-template<typename T>
-struct RemoveReference<T&&>
-{
-  typedef T Type;
-};
-
-template<bool Condition, typename A, typename B>
-struct Conditional;
-
-namespace detail {
-
-enum Voidness { TIsVoid, TIsNotVoid };
-
-template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
-struct AddLvalueReferenceHelper;
-
-template<typename T>
-struct AddLvalueReferenceHelper<T, TIsVoid>
-{
-  typedef void Type;
-};
-
-template<typename T>
-struct AddLvalueReferenceHelper<T, TIsNotVoid>
-{
-  typedef T& Type;
-};
-
-}
-# 937 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct AddLvalueReference
-  : detail::AddLvalueReferenceHelper<T>
-{};
-
-namespace detail {
-
-template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
-struct AddRvalueReferenceHelper;
-
-template<typename T>
-struct AddRvalueReferenceHelper<T, TIsVoid>
-{
-  typedef void Type;
-};
-
-template<typename T>
-struct AddRvalueReferenceHelper<T, TIsNotVoid>
-{
-  typedef T&& Type;
-};
-
-}
-# 976 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct AddRvalueReference
-  : detail::AddRvalueReferenceHelper<T>
-{};
-
-
-
-template<bool B, typename T = void>
-struct EnableIf;
-
-namespace detail {
-
-template<bool MakeConst, typename T>
-struct WithC : Conditional<MakeConst, const T, T>
-{};
-
-template<bool MakeVolatile, typename T>
-struct WithV : Conditional<MakeVolatile, volatile T, T>
-{};
-
-
-template<bool MakeConst, bool MakeVolatile, typename T>
-struct WithCV : WithC<MakeConst, typename WithV<MakeVolatile, T>::Type>
-{};
-
-template<typename T>
-struct CorrespondingSigned;
-
-template<>
-struct CorrespondingSigned<char> { typedef signed char Type; };
-template<>
-struct CorrespondingSigned<unsigned char> { typedef signed char Type; };
-template<>
-struct CorrespondingSigned<unsigned short> { typedef short Type; };
-template<>
-struct CorrespondingSigned<unsigned int> { typedef int Type; };
-template<>
-struct CorrespondingSigned<unsigned long> { typedef long Type; };
-template<>
-struct CorrespondingSigned<unsigned long long> { typedef long long Type; };
-
-template<typename T,
-         typename CVRemoved = typename RemoveCV<T>::Type,
-         bool IsSignedIntegerType = IsSigned<CVRemoved>::value &&
-                                    !IsSame<char, CVRemoved>::value>
-struct MakeSigned;
-
-template<typename T, typename CVRemoved>
-struct MakeSigned<T, CVRemoved, true>
-{
-  typedef T Type;
-};
-
-template<typename T, typename CVRemoved>
-struct MakeSigned<T, CVRemoved, false>
-  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
-           typename CorrespondingSigned<CVRemoved>::Type>
-{};
-
-}
-# 1059 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct MakeSigned
-  : EnableIf<IsIntegral<T>::value &&
-             !IsSame<bool, typename RemoveCV<T>::Type>::value,
-             typename detail::MakeSigned<T>
-            >::Type
-{};
-
-namespace detail {
-
-template<typename T>
-struct CorrespondingUnsigned;
-
-template<>
-struct CorrespondingUnsigned<char> { typedef unsigned char Type; };
-template<>
-struct CorrespondingUnsigned<signed char> { typedef unsigned char Type; };
-template<>
-struct CorrespondingUnsigned<short> { typedef unsigned short Type; };
-template<>
-struct CorrespondingUnsigned<int> { typedef unsigned int Type; };
-template<>
-struct CorrespondingUnsigned<long> { typedef unsigned long Type; };
-template<>
-struct CorrespondingUnsigned<long long> { typedef unsigned long long Type; };
-
-
-template<typename T,
-         typename CVRemoved = typename RemoveCV<T>::Type,
-         bool IsUnsignedIntegerType = IsUnsigned<CVRemoved>::value &&
-                                      !IsSame<char, CVRemoved>::value>
-struct MakeUnsigned;
-
-template<typename T, typename CVRemoved>
-struct MakeUnsigned<T, CVRemoved, true>
-{
-  typedef T Type;
-};
-
-template<typename T, typename CVRemoved>
-struct MakeUnsigned<T, CVRemoved, false>
-  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
-           typename CorrespondingUnsigned<CVRemoved>::Type>
-{};
-
-}
-# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct MakeUnsigned
-  : EnableIf<IsIntegral<T>::value &&
-             !IsSame<bool, typename RemoveCV<T>::Type>::value,
-             typename detail::MakeUnsigned<T>
-            >::Type
-{};
-# 1147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemoveExtent
-{
-  typedef T Type;
-};
-
-template<typename T>
-struct RemoveExtent<T[]>
-{
-  typedef T Type;
-};
-
-template<typename T, decltype(sizeof(1)) N>
-struct RemoveExtent<T[N]>
-{
-  typedef T Type;
-};
-
-
-
-namespace detail {
-
-template<typename T, typename CVRemoved>
-struct RemovePointerHelper
-{
-  typedef T Type;
-};
-
-template<typename T, typename Pointee>
-struct RemovePointerHelper<T, Pointee*>
-{
-  typedef Pointee Type;
-};
-
-}
-# 1198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct RemovePointer
-  : detail::RemovePointerHelper<T, typename RemoveCV<T>::Type>
-{};
-# 1213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-struct AddPointer
-{
-  typedef typename RemoveReference<T>::Type* Type;
-};
-# 1239 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<bool B, typename T>
-struct EnableIf
-{};
-
-template<typename T>
-struct EnableIf<true, T>
-{
-  typedef T Type;
-};
-
-
-
-
-
-
-
-template<bool Condition, typename A, typename B>
-struct Conditional
-{
-  typedef A Type;
-};
-
-template<class A, class B>
-struct Conditional<false, A, B>
-{
-  typedef B Type;
-};
-
-namespace detail {
-
-template<typename U,
-         bool IsArray = IsArray<U>::value,
-         bool IsFunction = IsFunction<U>::value>
-struct DecaySelector;
-
-template<typename U>
-struct DecaySelector<U, false, false>
-{
-  typedef typename RemoveCV<U>::Type Type;
-};
-
-template<typename U>
-struct DecaySelector<U, true, false>
-{
-  typedef typename RemoveExtent<U>::Type* Type;
-};
-
-template<typename U>
-struct DecaySelector<U, false, true>
-{
-  typedef typename AddPointer<U>::Type Type;
-};
-
-};
-# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypeTraits.h"
-template<typename T>
-class Decay
-  : public detail::DecaySelector<typename RemoveReference<T>::Type>
-{
-};
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerTypeTraits.h" 2
-
-
-namespace mozilla {
-
-namespace detail {
-
-
-
-
-
-
-template<size_t Size, bool Signedness>
-struct StdintTypeForSizeAndSignedness;
-
-template<>
-struct StdintTypeForSizeAndSignedness<1, true>
-{
-  typedef int8_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<1, false>
-{
-  typedef uint8_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<2, true>
-{
-  typedef int16_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<2, false>
-{
-  typedef uint16_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<4, true>
-{
-  typedef int32_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<4, false>
-{
-  typedef uint32_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<8, true>
-{
-  typedef int64_t Type;
-};
-
-template<>
-struct StdintTypeForSizeAndSignedness<8, false>
-{
-  typedef uint64_t Type;
-};
-
-}
-
-template<size_t Size>
-struct UnsignedStdintTypeForSize
-  : detail::StdintTypeForSizeAndSignedness<Size, false>
-{};
-
-template<size_t Size>
-struct SignedStdintTypeForSize
-  : detail::StdintTypeForSizeAndSignedness<Size, true>
-{};
-
-template<typename IntegerType>
-struct PositionOfSignBit
-{
-  static_assert(IsIntegral<IntegerType>::value,
-                "PositionOfSignBit is only for integral types");
-
-  static const size_t value = 8 * sizeof(IntegerType) - 1;
-};
-
-
-
-
-
-
-template<typename IntegerType>
-struct MinValue
-{
-private:
-  static_assert(IsIntegral<IntegerType>::value,
-                "MinValue is only for integral types");
-
-  typedef typename MakeUnsigned<IntegerType>::Type UnsignedIntegerType;
-  static const size_t PosOfSignBit = PositionOfSignBit<IntegerType>::value;
-
-public:
-
-
-
-
-
-
-  static const IntegerType value =
-      IsSigned<IntegerType>::value
-      ? IntegerType(UnsignedIntegerType(1) << PosOfSignBit)
-      : IntegerType(0);
-};
-
-
-
-
-
-
-template<typename IntegerType>
-struct MaxValue
-{
-  static_assert(IsIntegral<IntegerType>::value,
-                "MaxValue is only for integral types");
-
-
-
-
-  static const IntegerType value = ~MinValue<IntegerType>::value;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h" 2
-
-namespace mozilla {
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
-template<typename E>
-class CastableTypedEnumResult
-{
-private:
-  const E mValue;
-
-public:
-  explicit constexpr CastableTypedEnumResult(E aValue)
-    : mValue(aValue)
-  {}
-
-  constexpr operator E() const { return mValue; }
-
-  template<typename DestinationType>
-  explicit constexpr
-  operator DestinationType() const { return DestinationType(mValue); }
-
-  constexpr bool operator !() const { return !bool(mValue); }
-};
-# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
-template<typename E> constexpr CastableTypedEnumResult<E> operator |(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE | E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator |(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) | aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator |(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) | E(aR2)); }
-template<typename E> constexpr CastableTypedEnumResult<E> operator &(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE & E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator &(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) & aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator &(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) & E(aR2)); }
-template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const E& aE, const CastableTypedEnumResult<E>& aR) { return CastableTypedEnumResult<E>(aE ^ E(aR)); } template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const CastableTypedEnumResult<E>& aR, const E& aE) { return CastableTypedEnumResult<E>(E(aR) ^ aE); } template<typename E> constexpr CastableTypedEnumResult<E> operator ^(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return CastableTypedEnumResult<E>(E(aR1) ^ E(aR2)); }
-template<typename E> constexpr bool operator ==(const E& aE, const CastableTypedEnumResult<E>& aR) { return bool(aE == E(aR)); } template<typename E> constexpr bool operator ==(const CastableTypedEnumResult<E>& aR, const E& aE) { return bool(E(aR) == aE); } template<typename E> constexpr bool operator ==(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return bool(E(aR1) == E(aR2)); }
-template<typename E> constexpr bool operator !=(const E& aE, const CastableTypedEnumResult<E>& aR) { return bool(aE != E(aR)); } template<typename E> constexpr bool operator !=(const CastableTypedEnumResult<E>& aR, const E& aE) { return bool(E(aR) != aE); } template<typename E> constexpr bool operator !=(const CastableTypedEnumResult<E>& aR1, const CastableTypedEnumResult<E>& aR2) { return bool(E(aR1) != E(aR2)); }
-
-template <typename E>
-constexpr CastableTypedEnumResult<E>
-operator ~(const CastableTypedEnumResult<E>& aR)
-{
-  return CastableTypedEnumResult<E>(~(E(aR)));
-}
-# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TypedEnumBits.h"
-template<typename E> E& operator &=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 &= E(aR2); }
-template<typename E> E& operator |=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 |= E(aR2); }
-template<typename E> E& operator ^=(E& aR1, const CastableTypedEnumResult<E>& aR2) { return aR1 ^= E(aR2); }
-
-
-
-
-
-namespace detail {
-template<typename E>
-struct UnsignedIntegerTypeForEnum
-  : UnsignedStdintTypeForSize<sizeof(E)>
-{};
-}
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoTypes.h" 2
-
-
-
-
-
-
-struct ServoNodeData;
-namespace mozilla {
-
-
-
-
-
-template<typename T>
-struct ServoUnsafeCell {
-  T value;
-
-
-  ServoUnsafeCell() : value() {};
-};
-
-template<typename T>
-struct ServoCell {
-  ServoUnsafeCell<T> value;
-  T Get() const { return value.value; }
-  void Set(T arg) { value.value = arg; }
-  ServoCell() : value() {};
-};
-
-
-
-
-enum class LazyComputeBehavior {
-  Allow,
-  Assert,
-};
-
-
-
-
-enum class TraversalRootBehavior {
-  Normal,
-  UnstyledChildrenOnly,
-};
-
-
-enum class UpdateAnimationsTasks : uint8_t {
-  CSSAnimations = 1 << 0,
-  CSSTransitions = 1 << 1,
-  EffectProperties = 1 << 2,
-  CascadeResults = 1 << 3,
-};
-
-inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator |(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) | U(b))); } inline UpdateAnimationsTasks& operator |=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator &(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) & U(b))); } inline UpdateAnimationsTasks& operator &=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator ^(UpdateAnimationsTasks a, UpdateAnimationsTasks b) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(U(a) ^ U(b))); } inline UpdateAnimationsTasks& operator ^=(UpdateAnimationsTasks& a, UpdateAnimationsTasks b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> operator~(UpdateAnimationsTasks a) { typedef mozilla::CastableTypedEnumResult<UpdateAnimationsTasks> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<UpdateAnimationsTasks>::Type U; return Result(UpdateAnimationsTasks(~(U(a)))); }
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Likely.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroArgs.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticAnalysisFunctions.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 1
-
-
-
-
-
-
-
-
-# 1 "/usr/include/stdio.h" 1 3 4
-# 29 "/usr/include/stdio.h" 3 4
-extern "C" {
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 34 "/usr/include/stdio.h" 2 3 4
-
-# 1 "/usr/include/bits/types.h" 1 3 4
-# 27 "/usr/include/bits/types.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 28 "/usr/include/bits/types.h" 2 3 4
-
-
-typedef unsigned char __u_char;
-typedef unsigned short int __u_short;
-typedef unsigned int __u_int;
-typedef unsigned long int __u_long;
-
-
-typedef signed char __int8_t;
-typedef unsigned char __uint8_t;
-typedef signed short int __int16_t;
-typedef unsigned short int __uint16_t;
-typedef signed int __int32_t;
-typedef unsigned int __uint32_t;
-
-typedef signed long int __int64_t;
-typedef unsigned long int __uint64_t;
-
-
-
-
-
-
-
-typedef long int __quad_t;
-typedef unsigned long int __u_quad_t;
-# 121 "/usr/include/bits/types.h" 3 4
-# 1 "/usr/include/bits/typesizes.h" 1 3 4
-# 122 "/usr/include/bits/types.h" 2 3 4
-
-
-typedef unsigned long int __dev_t;
-typedef unsigned int __uid_t;
-typedef unsigned int __gid_t;
-typedef unsigned long int __ino_t;
-typedef unsigned long int __ino64_t;
-typedef unsigned int __mode_t;
-typedef unsigned long int __nlink_t;
-typedef long int __off_t;
-typedef long int __off64_t;
-typedef int __pid_t;
-typedef struct { int __val[2]; } __fsid_t;
-typedef long int __clock_t;
-typedef unsigned long int __rlim_t;
-typedef unsigned long int __rlim64_t;
-typedef unsigned int __id_t;
-typedef long int __time_t;
-typedef unsigned int __useconds_t;
-typedef long int __suseconds_t;
-
-typedef int __daddr_t;
-typedef int __key_t;
-
-
-typedef int __clockid_t;
-
-
-typedef void * __timer_t;
-
-
-typedef long int __blksize_t;
-
-
-
-
-typedef long int __blkcnt_t;
-typedef long int __blkcnt64_t;
-
-
-typedef unsigned long int __fsblkcnt_t;
-typedef unsigned long int __fsblkcnt64_t;
-
-
-typedef unsigned long int __fsfilcnt_t;
-typedef unsigned long int __fsfilcnt64_t;
-
-
-typedef long int __fsword_t;
-
-typedef long int __ssize_t;
-
-
-typedef long int __syscall_slong_t;
-
-typedef unsigned long int __syscall_ulong_t;
-
-
-
-typedef __off64_t __loff_t;
-typedef __quad_t *__qaddr_t;
-typedef char *__caddr_t;
-
-
-typedef long int __intptr_t;
-
-
-typedef unsigned int __socklen_t;
-# 36 "/usr/include/stdio.h" 2 3 4
-# 74 "/usr/include/stdio.h" 3 4
-# 1 "/usr/include/libio.h" 1 3 4
-# 31 "/usr/include/libio.h" 3 4
-# 1 "/usr/include/_G_config.h" 1 3 4
-# 15 "/usr/include/_G_config.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 16 "/usr/include/_G_config.h" 2 3 4
-
-
-
-
-# 1 "/usr/include/wchar.h" 1 3 4
-# 21 "/usr/include/_G_config.h" 2 3 4
-typedef struct
-{
-  __off_t __pos;
-  __mbstate_t __state;
-} _G_fpos_t;
-typedef struct
-{
-  __off64_t __pos;
-  __mbstate_t __state;
-} _G_fpos64_t;
-# 32 "/usr/include/libio.h" 2 3 4
-# 144 "/usr/include/libio.h" 3 4
-struct _IO_jump_t; struct _IO_FILE;
-
-
-
-
-
-typedef void _IO_lock_t;
-
-
-
-
-
-struct _IO_marker {
-  struct _IO_marker *_next;
-  struct _IO_FILE *_sbuf;
-
-
-
-  int _pos;
-# 173 "/usr/include/libio.h" 3 4
-};
-
-
-enum __codecvt_result
-{
-  __codecvt_ok,
-  __codecvt_partial,
-  __codecvt_error,
-  __codecvt_noconv
-};
-# 241 "/usr/include/libio.h" 3 4
-struct _IO_FILE {
-  int _flags;
-
-
-
-
-  char* _IO_read_ptr;
-  char* _IO_read_end;
-  char* _IO_read_base;
-  char* _IO_write_base;
-  char* _IO_write_ptr;
-  char* _IO_write_end;
-  char* _IO_buf_base;
-  char* _IO_buf_end;
-
-  char *_IO_save_base;
-  char *_IO_backup_base;
-  char *_IO_save_end;
-
-  struct _IO_marker *_markers;
-
-  struct _IO_FILE *_chain;
-
-  int _fileno;
-
-
-
-  int _flags2;
-
-  __off_t _old_offset;
-
-
-
-  unsigned short _cur_column;
-  signed char _vtable_offset;
-  char _shortbuf[1];
-
-
-
-  _IO_lock_t *_lock;
-# 289 "/usr/include/libio.h" 3 4
-  __off64_t _offset;
-
-
-
-
-
-
-
-  void *__pad1;
-  void *__pad2;
-  void *__pad3;
-  void *__pad4;
-
-  size_t __pad5;
-  int _mode;
-
-  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
-
-};
-
-
-
-
-
-struct _IO_FILE_plus;
-
-extern struct _IO_FILE_plus _IO_2_1_stdin_;
-extern struct _IO_FILE_plus _IO_2_1_stdout_;
-extern struct _IO_FILE_plus _IO_2_1_stderr_;
-# 333 "/usr/include/libio.h" 3 4
-typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
-
-
-
-
-
-
-
-typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
-     size_t __n);
-
-
-
-
-
-
-
-typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
-
-
-typedef int __io_close_fn (void *__cookie);
-
-
-
-
-typedef __io_read_fn cookie_read_function_t;
-typedef __io_write_fn cookie_write_function_t;
-typedef __io_seek_fn cookie_seek_function_t;
-typedef __io_close_fn cookie_close_function_t;
-
-
-typedef struct
-{
-  __io_read_fn *read;
-  __io_write_fn *write;
-  __io_seek_fn *seek;
-  __io_close_fn *close;
-} _IO_cookie_io_functions_t;
-typedef _IO_cookie_io_functions_t cookie_io_functions_t;
-
-struct _IO_cookie_file;
-
-
-extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
-        void *__cookie, _IO_cookie_io_functions_t __fns);
-
-
-
-
-extern "C" {
-
-
-extern int __underflow (_IO_FILE *);
-extern int __uflow (_IO_FILE *);
-extern int __overflow (_IO_FILE *, int);
-# 429 "/usr/include/libio.h" 3 4
-extern int _IO_getc (_IO_FILE *__fp);
-extern int _IO_putc (int __c, _IO_FILE *__fp);
-extern int _IO_feof (_IO_FILE *__fp) throw ();
-extern int _IO_ferror (_IO_FILE *__fp) throw ();
-
-extern int _IO_peekc_locked (_IO_FILE *__fp);
-
-
-
-
-
-extern void _IO_flockfile (_IO_FILE *) throw ();
-extern void _IO_funlockfile (_IO_FILE *) throw ();
-extern int _IO_ftrylockfile (_IO_FILE *) throw ();
-# 459 "/usr/include/libio.h" 3 4
-extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
-   __gnuc_va_list, int *__restrict);
-extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
-    __gnuc_va_list);
-extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
-extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
-
-extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
-extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
-
-extern void _IO_free_backup_area (_IO_FILE *) throw ();
-# 521 "/usr/include/libio.h" 3 4
-}
-# 75 "/usr/include/stdio.h" 2 3 4
-
-
-
-
-typedef __gnuc_va_list va_list;
-# 90 "/usr/include/stdio.h" 3 4
-typedef __off_t off_t;
-
-
-
-
-
-
-typedef __off64_t off64_t;
-
-
-
-
-
-
-typedef __ssize_t ssize_t;
-
-
-
-
-
-
-
-typedef _G_fpos_t fpos_t;
-
-
-
-
-
-typedef _G_fpos64_t fpos64_t;
-# 166 "/usr/include/stdio.h" 3 4
-# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
-# 167 "/usr/include/stdio.h" 2 3 4
-
-
-
-extern struct _IO_FILE *stdin;
-extern struct _IO_FILE *stdout;
-extern struct _IO_FILE *stderr;
-
-
-
-
-
-
-
-extern int remove (const char *__filename) throw ();
-
-extern int rename (const char *__old, const char *__new) throw ();
-
-
-
-
-extern int renameat (int __oldfd, const char *__old, int __newfd,
-       const char *__new) throw ();
-# 197 "/usr/include/stdio.h" 3 4
-extern FILE *tmpfile (void) ;
-# 207 "/usr/include/stdio.h" 3 4
-extern FILE *tmpfile64 (void) ;
-
-
-
-extern char *tmpnam (char *__s) throw () ;
-
-
-
-
-
-extern char *tmpnam_r (char *__s) throw () ;
-# 229 "/usr/include/stdio.h" 3 4
-extern char *tempnam (const char *__dir, const char *__pfx)
-     throw () __attribute__ ((__malloc__)) ;
-# 239 "/usr/include/stdio.h" 3 4
-extern int fclose (FILE *__stream);
-
-
-
-
-extern int fflush (FILE *__stream);
-# 254 "/usr/include/stdio.h" 3 4
-extern int fflush_unlocked (FILE *__stream);
-# 264 "/usr/include/stdio.h" 3 4
-extern int fcloseall (void);
-# 274 "/usr/include/stdio.h" 3 4
-extern FILE *fopen (const char *__restrict __filename,
-      const char *__restrict __modes) ;
-
-
-
-
-extern FILE *freopen (const char *__restrict __filename,
-        const char *__restrict __modes,
-        FILE *__restrict __stream) ;
-# 299 "/usr/include/stdio.h" 3 4
-extern FILE *fopen64 (const char *__restrict __filename,
-        const char *__restrict __modes) ;
-extern FILE *freopen64 (const char *__restrict __filename,
-   const char *__restrict __modes,
-   FILE *__restrict __stream) ;
-
-
-
-
-extern FILE *fdopen (int __fd, const char *__modes) throw () ;
-
-
-
-
-
-extern FILE *fopencookie (void *__restrict __magic_cookie,
-     const char *__restrict __modes,
-     _IO_cookie_io_functions_t __io_funcs) throw () ;
-
-
-
-
-extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
-  throw () ;
-
-
-
-
-extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
-
-
-
-
-
-
-extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
-
-
-
-extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
-      int __modes, size_t __n) throw ();
-
-
-
-
-
-extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
-         size_t __size) throw ();
-
-
-extern void setlinebuf (FILE *__stream) throw ();
-# 358 "/usr/include/stdio.h" 3 4
-extern int fprintf (FILE *__restrict __stream,
-      const char *__restrict __format, ...);
-
-
-
-
-extern int printf (const char *__restrict __format, ...);
-
-extern int sprintf (char *__restrict __s,
-      const char *__restrict __format, ...) throw ();
-
-
-
-
-
-extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
-       __gnuc_va_list __arg);
-
-
-
-
-extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
-
-extern int vsprintf (char *__restrict __s, const char *__restrict __format,
-       __gnuc_va_list __arg) throw ();
-
-
-
-
-
-extern int snprintf (char *__restrict __s, size_t __maxlen,
-       const char *__restrict __format, ...)
-     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
-
-extern int vsnprintf (char *__restrict __s, size_t __maxlen,
-        const char *__restrict __format, __gnuc_va_list __arg)
-     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
-
-
-
-
-
-
-extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
-        __gnuc_va_list __arg)
-     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
-extern int __asprintf (char **__restrict __ptr,
-         const char *__restrict __fmt, ...)
-     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
-extern int asprintf (char **__restrict __ptr,
-       const char *__restrict __fmt, ...)
-     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
-
-
-
-
-extern int vdprintf (int __fd, const char *__restrict __fmt,
-       __gnuc_va_list __arg)
-     __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int dprintf (int __fd, const char *__restrict __fmt, ...)
-     __attribute__ ((__format__ (__printf__, 2, 3)));
-# 427 "/usr/include/stdio.h" 3 4
-extern int fscanf (FILE *__restrict __stream,
-     const char *__restrict __format, ...) ;
-
-
-
-
-extern int scanf (const char *__restrict __format, ...) ;
-
-extern int sscanf (const char *__restrict __s,
-     const char *__restrict __format, ...) throw ();
-# 473 "/usr/include/stdio.h" 3 4
-extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
-      __gnuc_va_list __arg)
-     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
-
-
-
-
-
-extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
-     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
-
-
-extern int vsscanf (const char *__restrict __s,
-      const char *__restrict __format, __gnuc_va_list __arg)
-     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
-# 533 "/usr/include/stdio.h" 3 4
-extern int fgetc (FILE *__stream);
-extern int getc (FILE *__stream);
-
-
-
-
-
-extern int getchar (void);
-# 552 "/usr/include/stdio.h" 3 4
-extern int getc_unlocked (FILE *__stream);
-extern int getchar_unlocked (void);
-# 563 "/usr/include/stdio.h" 3 4
-extern int fgetc_unlocked (FILE *__stream);
-# 575 "/usr/include/stdio.h" 3 4
-extern int fputc (int __c, FILE *__stream);
-extern int putc (int __c, FILE *__stream);
-
-
-
-
-
-extern int putchar (int __c);
-# 596 "/usr/include/stdio.h" 3 4
-extern int fputc_unlocked (int __c, FILE *__stream);
-
-
-
-
-
-
-
-extern int putc_unlocked (int __c, FILE *__stream);
-extern int putchar_unlocked (int __c);
-
-
-
-
-
-
-extern int getw (FILE *__stream);
-
-
-extern int putw (int __w, FILE *__stream);
-# 624 "/usr/include/stdio.h" 3 4
-extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
-          ;
-# 651 "/usr/include/stdio.h" 3 4
-extern char *fgets_unlocked (char *__restrict __s, int __n,
-        FILE *__restrict __stream) ;
-# 667 "/usr/include/stdio.h" 3 4
-extern __ssize_t __getdelim (char **__restrict __lineptr,
-          size_t *__restrict __n, int __delimiter,
-          FILE *__restrict __stream) ;
-extern __ssize_t getdelim (char **__restrict __lineptr,
-        size_t *__restrict __n, int __delimiter,
-        FILE *__restrict __stream) ;
-
-
-
-
-
-
-
-extern __ssize_t getline (char **__restrict __lineptr,
-       size_t *__restrict __n,
-       FILE *__restrict __stream) ;
-# 691 "/usr/include/stdio.h" 3 4
-extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
-
-
-
-
-
-extern int puts (const char *__s);
-
-
-
-
-
-
-extern int ungetc (int __c, FILE *__stream);
-
-
-
-
-
-
-extern size_t fread (void *__restrict __ptr, size_t __size,
-       size_t __n, FILE *__restrict __stream) ;
-
-
-
-
-extern size_t fwrite (const void *__restrict __ptr, size_t __size,
-        size_t __n, FILE *__restrict __s);
-# 728 "/usr/include/stdio.h" 3 4
-extern int fputs_unlocked (const char *__restrict __s,
-      FILE *__restrict __stream);
-# 739 "/usr/include/stdio.h" 3 4
-extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
-         size_t __n, FILE *__restrict __stream) ;
-extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
-          size_t __n, FILE *__restrict __stream);
-# 751 "/usr/include/stdio.h" 3 4
-extern int fseek (FILE *__stream, long int __off, int __whence);
-
-
-
-
-extern long int ftell (FILE *__stream) ;
-
-
-
-
-extern void rewind (FILE *__stream);
-# 775 "/usr/include/stdio.h" 3 4
-extern int fseeko (FILE *__stream, __off_t __off, int __whence);
-
-
-
-
-extern __off_t ftello (FILE *__stream) ;
-# 800 "/usr/include/stdio.h" 3 4
-extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
-
-
-
-
-extern int fsetpos (FILE *__stream, const fpos_t *__pos);
-# 820 "/usr/include/stdio.h" 3 4
-extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
-extern __off64_t ftello64 (FILE *__stream) ;
-extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
-extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
-
-
-
-
-extern void clearerr (FILE *__stream) throw ();
-
-extern int feof (FILE *__stream) throw () ;
-
-extern int ferror (FILE *__stream) throw () ;
-
-
-
-
-extern void clearerr_unlocked (FILE *__stream) throw ();
-extern int feof_unlocked (FILE *__stream) throw () ;
-extern int ferror_unlocked (FILE *__stream) throw () ;
-# 848 "/usr/include/stdio.h" 3 4
-extern void perror (const char *__s);
-
-
-
-
-
-
-
-# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
-# 26 "/usr/include/bits/sys_errlist.h" 3 4
-extern int sys_nerr;
-extern const char *const sys_errlist[];
-
-
-extern int _sys_nerr;
-extern const char *const _sys_errlist[];
-# 856 "/usr/include/stdio.h" 2 3 4
-
-
-
-
-extern int fileno (FILE *__stream) throw () ;
-
-
-
-
-extern int fileno_unlocked (FILE *__stream) throw () ;
-# 874 "/usr/include/stdio.h" 3 4
-extern FILE *popen (const char *__command, const char *__modes) ;
-
-
-
-
-
-extern int pclose (FILE *__stream);
-
-
-
-
-
-extern char *ctermid (char *__s) throw ();
-
-
-
-
-
-extern char *cuserid (char *__s);
-
-
-
-
-struct obstack;
-
-
-extern int obstack_printf (struct obstack *__restrict __obstack,
-      const char *__restrict __format, ...)
-     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
-extern int obstack_vprintf (struct obstack *__restrict __obstack,
-       const char *__restrict __format,
-       __gnuc_va_list __args)
-     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
-
-
-
-
-
-
-
-extern void flockfile (FILE *__stream) throw ();
-
-
-
-extern int ftrylockfile (FILE *__stream) throw () ;
-
-
-extern void funlockfile (FILE *__stream) throw ();
-# 944 "/usr/include/stdio.h" 3 4
-}
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcom-config.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
-
-#pragma GCC visibility push(default)
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_lockfree_defines.h" 3
-# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
-
-extern "C++" {
-
-namespace std
-{
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
-  class exception
-  {
-  public:
-    exception() noexcept { }
-    virtual ~exception() noexcept;
-
-
-
-    virtual const char*
-    what() const noexcept;
-  };
-
-
-
-  class bad_exception : public exception
-  {
-  public:
-    bad_exception() noexcept { }
-
-
-
-    virtual ~bad_exception() noexcept;
-
-
-    virtual const char*
-    what() const noexcept;
-  };
-
-
-  typedef void (*terminate_handler) ();
-
-
-  typedef void (*unexpected_handler) ();
-
-
-  terminate_handler set_terminate(terminate_handler) noexcept;
-
-
-
-  terminate_handler get_terminate() noexcept;
-
-
-
-
-  void terminate() noexcept __attribute__ ((__noreturn__));
-
-
-  unexpected_handler set_unexpected(unexpected_handler) noexcept;
-
-
-
-  unexpected_handler get_unexpected() noexcept;
-
-
-
-
-  void unexpected() __attribute__ ((__noreturn__));
-# 129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
-  bool uncaught_exception() noexcept __attribute__ ((__pure__));
-# 138 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
-}
-
-namespace __gnu_cxx
-{
-# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 3
-  void __verbose_terminate_handler();
-
-
-}
-
-}
-
-#pragma GCC visibility pop
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
-#pragma GCC visibility push(default)
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_defines.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 2 3
-
-
-
-
-
-extern "C++" {
-
-namespace std
-{
-  class type_info;
-
-
-
-
-
-  namespace __exception_ptr
-  {
-    class exception_ptr;
-  }
-
-  using __exception_ptr::exception_ptr;
-
-
-
-
-
-  exception_ptr current_exception() noexcept;
-
-
-  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
-
-  namespace __exception_ptr
-  {
-    using std::rethrow_exception;
-
-
-
-
-
-    class exception_ptr
-    {
-      void* _M_exception_object;
-
-      explicit exception_ptr(void* __e) noexcept;
-
-      void _M_addref() noexcept;
-      void _M_release() noexcept;
-
-      void *_M_get() const noexcept __attribute__ ((__pure__));
-
-      friend exception_ptr std::current_exception() noexcept;
-      friend void std::rethrow_exception(exception_ptr);
-
-    public:
-      exception_ptr() noexcept;
-
-      exception_ptr(const exception_ptr&) noexcept;
-
-
-      exception_ptr(nullptr_t) noexcept
-      : _M_exception_object(0)
-      { }
-
-      exception_ptr(exception_ptr&& __o) noexcept
-      : _M_exception_object(__o._M_exception_object)
-      { __o._M_exception_object = 0; }
-# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
-      exception_ptr&
-      operator=(const exception_ptr&) noexcept;
-
-
-      exception_ptr&
-      operator=(exception_ptr&& __o) noexcept
-      {
-        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
-        return *this;
-      }
-
-
-      ~exception_ptr() noexcept;
-
-      void
-      swap(exception_ptr&) noexcept;
-# 140 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/exception_ptr.h" 3
-      explicit operator bool() const
-      { return _M_exception_object; }
-
-
-      friend bool
-      operator==(const exception_ptr&, const exception_ptr&)
- noexcept __attribute__ ((__pure__));
-
-      const class std::type_info*
-      __cxa_exception_type() const noexcept
- __attribute__ ((__pure__));
-    };
-
-    bool
-    operator==(const exception_ptr&, const exception_ptr&)
-      noexcept __attribute__ ((__pure__));
-
-    bool
-    operator!=(const exception_ptr&, const exception_ptr&)
-      noexcept __attribute__ ((__pure__));
-
-    inline void
-    swap(exception_ptr& __lhs, exception_ptr& __rhs)
-    { __lhs.swap(__rhs); }
-
-  }
-
-
-
-  template<typename _Ex>
-    exception_ptr
-    make_exception_ptr(_Ex __ex) noexcept
-    {
-
-      try
- {
-   throw __ex;
- }
-      catch(...)
- {
-   return current_exception();
- }
-
-
-
-    }
-
-
-
-
-
-  template<typename _Ex>
-    exception_ptr
-    copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));
-
-  template<typename _Ex>
-    exception_ptr
-    copy_exception(_Ex __ex) noexcept
-    { return std::make_exception_ptr<_Ex>(__ex); }
-
-
-}
-
-}
-
-#pragma GCC visibility pop
-# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 3
-#pragma GCC visibility push(default)
-
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/concept_check.h" 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _Tp>
-    inline _Tp*
-    __addressof(_Tp& __r) noexcept
-    {
-      return reinterpret_cast<_Tp*>
- (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
-    }
-
-
-}
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-namespace std
-{
-  typedef unsigned short uint_least16_t;
-  typedef unsigned int uint_least32_t;
-}
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp, _Tp __v>
-    struct integral_constant
-    {
-      static constexpr _Tp value = __v;
-      typedef _Tp value_type;
-      typedef integral_constant<_Tp, __v> type;
-      constexpr operator value_type() const { return value; }
-
-
-
-
-      constexpr value_type operator()() const { return value; }
-
-    };
-
-  template<typename _Tp, _Tp __v>
-    constexpr _Tp integral_constant<_Tp, __v>::value;
-
-
-  typedef integral_constant<bool, true> true_type;
-
-
-  typedef integral_constant<bool, false> false_type;
-
-  template<bool __v>
-    using __bool_constant = integral_constant<bool, __v>;
-# 103 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<bool, typename, typename>
-    struct conditional;
-
-  template<typename...>
-    struct __or_;
-
-  template<>
-    struct __or_<>
-    : public false_type
-    { };
-
-  template<typename _B1>
-    struct __or_<_B1>
-    : public _B1
-    { };
-
-  template<typename _B1, typename _B2>
-    struct __or_<_B1, _B2>
-    : public conditional<_B1::value, _B1, _B2>::type
-    { };
-
-  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
-    struct __or_<_B1, _B2, _B3, _Bn...>
-    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
-    { };
-
-  template<typename...>
-    struct __and_;
-
-  template<>
-    struct __and_<>
-    : public true_type
-    { };
-
-  template<typename _B1>
-    struct __and_<_B1>
-    : public _B1
-    { };
-
-  template<typename _B1, typename _B2>
-    struct __and_<_B1, _B2>
-    : public conditional<_B1::value, _B2, _B1>::type
-    { };
-
-  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
-    struct __and_<_B1, _B2, _B3, _Bn...>
-    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
-    { };
-
-  template<typename _Pp>
-    struct __not_
-    : public integral_constant<bool, !_Pp::value>
-    { };
-
-  struct __nonesuch {
-    __nonesuch() = delete;
-    ~__nonesuch() = delete;
-    __nonesuch(__nonesuch const&) = delete;
-    void operator=(__nonesuch const&) = delete;
-  };
-# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp>
-    struct __success_type
-    { typedef _Tp type; };
-
-  struct __failure_type
-  { };
-
-
-
-  template<typename>
-    struct remove_cv;
-
-  template<typename>
-    struct __is_void_helper
-    : public false_type { };
-
-  template<>
-    struct __is_void_helper<void>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_void
-    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_integral_helper
-    : public false_type { };
-
-  template<>
-    struct __is_integral_helper<bool>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<char>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<signed char>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned char>
-    : public true_type { };
-
-
-  template<>
-    struct __is_integral_helper<wchar_t>
-    : public true_type { };
-
-
-  template<>
-    struct __is_integral_helper<char16_t>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<char32_t>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<short>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned short>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<int>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned int>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<long long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned long long>
-    : public true_type { };
-# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp>
-    struct is_integral
-    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_floating_point_helper
-    : public false_type { };
-
-  template<>
-    struct __is_floating_point_helper<float>
-    : public true_type { };
-
-  template<>
-    struct __is_floating_point_helper<double>
-    : public true_type { };
-
-  template<>
-    struct __is_floating_point_helper<long double>
-    : public true_type { };
-# 349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp>
-    struct is_floating_point
-    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename>
-    struct is_array
-    : public false_type { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct is_array<_Tp[_Size]>
-    : public true_type { };
-
-  template<typename _Tp>
-    struct is_array<_Tp[]>
-    : public true_type { };
-
-  template<typename>
-    struct __is_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_pointer_helper<_Tp*>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_pointer
-    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename>
-    struct is_lvalue_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_lvalue_reference<_Tp&>
-    : public true_type { };
-
-
-  template<typename>
-    struct is_rvalue_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_rvalue_reference<_Tp&&>
-    : public true_type { };
-
-  template<typename>
-    struct is_function;
-
-  template<typename>
-    struct __is_member_object_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_object_pointer_helper<_Tp _Cp::*>
-    : public integral_constant<bool, !is_function<_Tp>::value> { };
-
-
-  template<typename _Tp>
-    struct is_member_object_pointer
-    : public __is_member_object_pointer_helper<
-    typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_member_function_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_function_pointer_helper<_Tp _Cp::*>
-    : public integral_constant<bool, is_function<_Tp>::value> { };
-
-
-  template<typename _Tp>
-    struct is_member_function_pointer
-    : public __is_member_function_pointer_helper<
-    typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_enum
-    : public integral_constant<bool, __is_enum(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_union
-    : public integral_constant<bool, __is_union(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_class
-    : public integral_constant<bool, __is_class(_Tp)>
-    { };
-
-
-  template<typename>
-    struct is_function
-    : public false_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...)>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......)>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) volatile>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) volatile &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) volatile &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) volatile>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) volatile &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) volatile &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const volatile>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const volatile &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes...) const volatile &&>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const volatile>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const volatile &>
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct is_function<_Res(_ArgTypes......) const volatile &&>
-    : public true_type { };
-
-
-
-  template<typename>
-    struct __is_null_pointer_helper
-    : public false_type { };
-
-  template<>
-    struct __is_null_pointer_helper<std::nullptr_t>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_null_pointer
-    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_nullptr_t
-    : public is_null_pointer<_Tp>
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct is_reference
-    : public __or_<is_lvalue_reference<_Tp>,
-                   is_rvalue_reference<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_arithmetic
-    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_fundamental
-    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
-     is_null_pointer<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_object
-    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
-                          is_void<_Tp>>>::type
-    { };
-
-  template<typename>
-    struct is_member_pointer;
-
-
-  template<typename _Tp>
-    struct is_scalar
-    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
-                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_compound
-    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct __is_member_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_pointer_helper<_Tp _Cp::*>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_member_pointer
-    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-
-  template<typename _Tp>
-    struct __is_referenceable
-    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
-    { };
-
-  template<typename _Res, typename... _Args>
-    struct __is_referenceable<_Res(_Args...)>
-    : public true_type
-    { };
-
-  template<typename _Res, typename... _Args>
-    struct __is_referenceable<_Res(_Args......)>
-    : public true_type
-    { };
-
-
-
-
-  template<typename>
-    struct is_const
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_const<_Tp const>
-    : public true_type { };
-
-
-  template<typename>
-    struct is_volatile
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_volatile<_Tp volatile>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_trivial
-    : public integral_constant<bool, __is_trivial(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_copyable
-    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_standard_layout
-    : public integral_constant<bool, __is_standard_layout(_Tp)>
-    { };
-
-
-
-  template<typename _Tp>
-    struct is_pod
-    : public integral_constant<bool, __is_pod(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_literal_type
-    : public integral_constant<bool, __is_literal_type(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_empty
-    : public integral_constant<bool, __is_empty(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_polymorphic
-    : public integral_constant<bool, __is_polymorphic(_Tp)>
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct is_final
-    : public integral_constant<bool, __is_final(_Tp)>
-    { };
-
-
-
-  template<typename _Tp>
-    struct is_abstract
-    : public integral_constant<bool, __is_abstract(_Tp)>
-    { };
-
-  template<typename _Tp,
-    bool = is_arithmetic<_Tp>::value>
-    struct __is_signed_helper
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_signed_helper<_Tp, true>
-    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_signed
-    : public __is_signed_helper<_Tp>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_unsigned
-    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
-    { };
-
-
-
-
-  template<typename>
-    struct add_rvalue_reference;
-
-
-
-
-
-  template<typename _Tp>
-    typename add_rvalue_reference<_Tp>::type declval() noexcept;
-
-  template<typename, unsigned = 0>
-    struct extent;
-
-  template<typename>
-    struct remove_all_extents;
-
-  template<typename _Tp>
-    struct __is_array_known_bounds
-    : public integral_constant<bool, (extent<_Tp>::value > 0)>
-    { };
-
-  template<typename _Tp>
-    struct __is_array_unknown_bounds
-    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
-    { };
-
-
-
-
-
-
-  struct __do_is_destructible_impl
-  {
-    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
-      static true_type __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_destructible_impl
-    : public __do_is_destructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp,
-           bool = __or_<is_void<_Tp>,
-                        __is_array_unknown_bounds<_Tp>,
-                        is_function<_Tp>>::value,
-           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
-    struct __is_destructible_safe;
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, false, false>
-    : public __is_destructible_impl<typename
-               remove_all_extents<_Tp>::type>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, true, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, false, true>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_destructible
-    : public __is_destructible_safe<_Tp>::type
-    { };
-
-
-
-
-
-  struct __do_is_nt_destructible_impl
-  {
-    template<typename _Tp>
-      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
-        __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_impl
-    : public __do_is_nt_destructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp,
-           bool = __or_<is_void<_Tp>,
-                        __is_array_unknown_bounds<_Tp>,
-                        is_function<_Tp>>::value,
-           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
-    struct __is_nt_destructible_safe;
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, false, false>
-    : public __is_nt_destructible_impl<typename
-               remove_all_extents<_Tp>::type>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, true, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, false, true>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_destructible
-    : public __is_nt_destructible_safe<_Tp>::type
-    { };
-
-  struct __do_is_default_constructible_impl
-  {
-    template<typename _Tp, typename = decltype(_Tp())>
-      static true_type __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_default_constructible_impl
-    : public __do_is_default_constructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_default_constructible_atom
-    : public __and_<__not_<is_void<_Tp>>,
-                    __is_default_constructible_impl<_Tp>>
-    { };
-
-  template<typename _Tp, bool = is_array<_Tp>::value>
-    struct __is_default_constructible_safe;
-
-
-
-
-
-
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, true>
-    : public __and_<__is_array_known_bounds<_Tp>,
-      __is_default_constructible_atom<typename
-                      remove_all_extents<_Tp>::type>>
-    { };
-
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, false>
-    : public __is_default_constructible_atom<_Tp>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_default_constructible
-    : public __is_default_constructible_safe<_Tp>::type
-    { };
-# 933 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  struct __do_is_static_castable_impl
-  {
-    template<typename _From, typename _To, typename
-             = decltype(static_cast<_To>(declval<_From>()))>
-      static true_type __test(int);
-
-    template<typename, typename>
-      static false_type __test(...);
-  };
-
-  template<typename _From, typename _To>
-    struct __is_static_castable_impl
-    : public __do_is_static_castable_impl
-    {
-      typedef decltype(__test<_From, _To>(0)) type;
-    };
-
-  template<typename _From, typename _To>
-    struct __is_static_castable_safe
-    : public __is_static_castable_impl<_From, _To>::type
-    { };
-
-
-  template<typename _From, typename _To>
-    struct __is_static_castable
-    : public integral_constant<bool, (__is_static_castable_safe<
-          _From, _To>::value)>
-    { };
-
-
-
-
-
-
-  struct __do_is_direct_constructible_impl
-  {
-    template<typename _Tp, typename _Arg, typename
-      = decltype(::new _Tp(declval<_Arg>()))>
-      static true_type __test(int);
-
-    template<typename, typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_direct_constructible_impl
-    : public __do_is_direct_constructible_impl
-    {
-      typedef decltype(__test<_Tp, _Arg>(0)) type;
-    };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_direct_constructible_new_safe
-    : public __and_<is_destructible<_Tp>,
-                    __is_direct_constructible_impl<_Tp, _Arg>>
-    { };
-
-  template<typename, typename>
-    struct is_same;
-
-  template<typename, typename>
-    struct is_base_of;
-
-  template<typename>
-    struct remove_reference;
-
-  template<typename _From, typename _To, bool
-           = __not_<__or_<is_void<_From>,
-                          is_function<_From>>>::value>
-    struct __is_base_to_derived_ref;
-
-  template<typename _Tp, typename... _Args>
-    struct is_constructible;
-
-
-
-  template<typename _From, typename _To>
-    struct __is_base_to_derived_ref<_From, _To, true>
-    {
-      typedef typename remove_cv<typename remove_reference<_From
-        >::type>::type __src_t;
-      typedef typename remove_cv<typename remove_reference<_To
-        >::type>::type __dst_t;
-      typedef __and_<__not_<is_same<__src_t, __dst_t>>,
-       is_base_of<__src_t, __dst_t>,
-       __not_<is_constructible<__dst_t, _From>>> type;
-      static constexpr bool value = type::value;
-    };
-
-  template<typename _From, typename _To>
-    struct __is_base_to_derived_ref<_From, _To, false>
-    : public false_type
-    { };
-
-  template<typename _From, typename _To, bool
-           = __and_<is_lvalue_reference<_From>,
-                    is_rvalue_reference<_To>>::value>
-    struct __is_lvalue_to_rvalue_ref;
-
-
-
-  template<typename _From, typename _To>
-    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
-    {
-      typedef typename remove_cv<typename remove_reference<
-        _From>::type>::type __src_t;
-      typedef typename remove_cv<typename remove_reference<
-        _To>::type>::type __dst_t;
-      typedef __and_<__not_<is_function<__src_t>>,
-        __or_<is_same<__src_t, __dst_t>,
-      is_base_of<__dst_t, __src_t>>> type;
-      static constexpr bool value = type::value;
-    };
-
-  template<typename _From, typename _To>
-    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
-    : public false_type
-    { };
-
-
-
-
-
-
-
-  template<typename _Tp, typename _Arg>
-    struct __is_direct_constructible_ref_cast
-    : public __and_<__is_static_castable<_Arg, _Tp>,
-                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
-                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
-                   >>>
-    { };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_direct_constructible_new
-    : public conditional<is_reference<_Tp>::value,
-    __is_direct_constructible_ref_cast<_Tp, _Arg>,
-    __is_direct_constructible_new_safe<_Tp, _Arg>
-    >::type
-    { };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_direct_constructible
-    : public __is_direct_constructible_new<_Tp, _Arg>::type
-    { };
-
-
-
-
-
-
-  struct __do_is_nary_constructible_impl
-  {
-    template<typename _Tp, typename... _Args, typename
-             = decltype(_Tp(declval<_Args>()...))>
-      static true_type __test(int);
-
-    template<typename, typename...>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp, typename... _Args>
-    struct __is_nary_constructible_impl
-    : public __do_is_nary_constructible_impl
-    {
-      typedef decltype(__test<_Tp, _Args...>(0)) type;
-    };
-
-  template<typename _Tp, typename... _Args>
-    struct __is_nary_constructible
-    : public __is_nary_constructible_impl<_Tp, _Args...>::type
-    {
-      static_assert(sizeof...(_Args) > 1,
-                    "Only useful for > 1 arguments");
-    };
-
-  template<typename _Tp, typename... _Args>
-    struct __is_constructible_impl
-    : public __is_nary_constructible<_Tp, _Args...>
-    { };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_constructible_impl<_Tp, _Arg>
-    : public __is_direct_constructible<_Tp, _Arg>
-    { };
-
-  template<typename _Tp>
-    struct __is_constructible_impl<_Tp>
-    : public is_default_constructible<_Tp>
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_constructible
-    : public __is_constructible_impl<_Tp, _Args...>::type
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_copy_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_copy_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_copy_constructible_impl<_Tp, true>
-    : public is_constructible<_Tp, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_copy_constructible
-    : public __is_copy_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_move_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_move_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_move_constructible_impl<_Tp, true>
-    : public is_constructible<_Tp, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_move_constructible
-    : public __is_move_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_atom
-    : public integral_constant<bool, noexcept(_Tp())>
-    { };
-
-  template<typename _Tp, bool = is_array<_Tp>::value>
-    struct __is_nt_default_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_impl<_Tp, true>
-    : public __and_<__is_array_known_bounds<_Tp>,
-      __is_nt_default_constructible_atom<typename
-                      remove_all_extents<_Tp>::type>>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_impl<_Tp, false>
-    : public __is_nt_default_constructible_atom<_Tp>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_default_constructible
-    : public __and_<is_default_constructible<_Tp>,
-                    __is_nt_default_constructible_impl<_Tp>>
-    { };
-
-  template<typename _Tp, typename... _Args>
-    struct __is_nt_constructible_impl
-    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
-    { };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_nt_constructible_impl<_Tp, _Arg>
-    : public integral_constant<bool,
-                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_constructible_impl<_Tp>
-    : public is_nothrow_default_constructible<_Tp>
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_nothrow_constructible
-    : public __and_<is_constructible<_Tp, _Args...>,
-      __is_nt_constructible_impl<_Tp, _Args...>>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nothrow_copy_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nothrow_copy_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nothrow_copy_constructible_impl<_Tp, true>
-    : public is_nothrow_constructible<_Tp, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_copy_constructible
-    : public __is_nothrow_copy_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nothrow_move_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nothrow_move_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nothrow_move_constructible_impl<_Tp, true>
-    : public is_nothrow_constructible<_Tp, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_move_constructible
-    : public __is_nothrow_move_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp, typename _Up>
-    class __is_assignable_helper
-    {
-      template<typename _Tp1, typename _Up1,
-        typename = decltype(declval<_Tp1>() = declval<_Up1>())>
- static true_type
- __test(int);
-
-      template<typename, typename>
- static false_type
- __test(...);
-
-    public:
-      typedef decltype(__test<_Tp, _Up>(0)) type;
-    };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_assignable
-      : public __is_assignable_helper<_Tp, _Up>::type
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_copy_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_copy_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_copy_assignable_impl<_Tp, true>
-    : public is_assignable<_Tp&, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_copy_assignable
-    : public __is_copy_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_move_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_move_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_move_assignable_impl<_Tp, true>
-    : public is_assignable<_Tp&, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_move_assignable
-    : public __is_move_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, typename _Up>
-    struct __is_nt_assignable_impl
-    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_nothrow_assignable
-    : public __and_<is_assignable<_Tp, _Up>,
-      __is_nt_assignable_impl<_Tp, _Up>>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nt_copy_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_nt_copy_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_copy_assignable_impl<_Tp, true>
-    : public is_nothrow_assignable<_Tp&, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_copy_assignable
-    : public __is_nt_copy_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nt_move_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_nt_move_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_move_assignable_impl<_Tp, true>
-    : public is_nothrow_assignable<_Tp&, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_move_assignable
-    : public __is_nt_move_assignable_impl<_Tp>
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_trivially_constructible
-    : public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
-   __is_trivially_constructible(_Tp, _Args...)>>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_default_constructible
-    : public is_trivially_constructible<_Tp>::type
-    { };
-
-  struct __do_is_implicitly_default_constructible_impl
-  {
-    template <typename _Tp>
-    static void __helper(const _Tp&);
-
-    template <typename _Tp>
-    static true_type __test(const _Tp&,
-                            decltype(__helper<const _Tp&>({}))* = 0);
-
-    static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_implicitly_default_constructible_impl
-      : public __do_is_implicitly_default_constructible_impl
-  {
-    typedef decltype(__test(declval<_Tp>())) type;
-  };
-
-  template<typename _Tp>
-    struct __is_implicitly_default_constructible_safe
-      : public __is_implicitly_default_constructible_impl<_Tp>::type
-  { };
-
-  template <typename _Tp>
-    struct __is_implicitly_default_constructible
-      : public __and_<is_default_constructible<_Tp>,
-                      __is_implicitly_default_constructible_safe<_Tp>>
-  { };
-
-
-  template<typename _Tp>
-    struct is_trivially_copy_constructible
-    : public __and_<is_copy_constructible<_Tp>,
-      integral_constant<bool,
-   __is_trivially_constructible(_Tp, const _Tp&)>>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_move_constructible
-    : public __and_<is_move_constructible<_Tp>,
-      integral_constant<bool,
-   __is_trivially_constructible(_Tp, _Tp&&)>>
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_trivially_assignable
-    : public __and_<is_assignable<_Tp, _Up>,
-      integral_constant<bool,
-   __is_trivially_assignable(_Tp, _Up)>>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_copy_assignable
-    : public __and_<is_copy_assignable<_Tp>,
-      integral_constant<bool,
-   __is_trivially_assignable(_Tp&, const _Tp&)>>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_move_assignable
-    : public __and_<is_move_assignable<_Tp>,
-      integral_constant<bool,
-   __is_trivially_assignable(_Tp&, _Tp&&)>>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_destructible
-    : public __and_<is_destructible<_Tp>, integral_constant<bool,
-         __has_trivial_destructor(_Tp)>>
-    { };
-
-
-  template<typename _Tp>
-    struct has_trivial_default_constructor
-    : public integral_constant<bool, __has_trivial_constructor(_Tp)>
-    { } __attribute__ ((__deprecated__));
-
-
-  template<typename _Tp>
-    struct has_trivial_copy_constructor
-    : public integral_constant<bool, __has_trivial_copy(_Tp)>
-    { } __attribute__ ((__deprecated__));
-
-
-  template<typename _Tp>
-    struct has_trivial_copy_assign
-    : public integral_constant<bool, __has_trivial_assign(_Tp)>
-    { } __attribute__ ((__deprecated__));
-
-
-  template<typename _Tp>
-    struct has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
-    { };
-
-
-
-
-
-  template<typename _Tp>
-    struct alignment_of
-    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-
-
-  template<typename>
-    struct rank
-    : public integral_constant<std::size_t, 0> { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct rank<_Tp[_Size]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct rank<_Tp[]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-
-  template<typename, unsigned _Uint>
-    struct extent
-    : public integral_constant<std::size_t, 0> { };
-
-  template<typename _Tp, unsigned _Uint, std::size_t _Size>
-    struct extent<_Tp[_Size], _Uint>
-    : public integral_constant<std::size_t,
-          _Uint == 0 ? _Size : extent<_Tp,
-          _Uint - 1>::value>
-    { };
-
-  template<typename _Tp, unsigned _Uint>
-    struct extent<_Tp[], _Uint>
-    : public integral_constant<std::size_t,
-          _Uint == 0 ? 0 : extent<_Tp,
-             _Uint - 1>::value>
-    { };
-
-
-
-
-
-  template<typename, typename>
-    struct is_same
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_same<_Tp, _Tp>
-    : public true_type { };
-
-
-  template<typename _Base, typename _Derived>
-    struct is_base_of
-    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
-    { };
-
-  template<typename _From, typename _To,
-           bool = __or_<is_void<_From>, is_function<_To>,
-                        is_array<_To>>::value>
-    struct __is_convertible_helper
-    { typedef typename is_void<_To>::type type; };
-
-  template<typename _From, typename _To>
-    class __is_convertible_helper<_From, _To, false>
-    {
-       template<typename _To1>
- static void __test_aux(_To1);
-
-      template<typename _From1, typename _To1,
-        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
- static true_type
- __test(int);
-
-      template<typename, typename>
- static false_type
- __test(...);
-
-    public:
-      typedef decltype(__test<_From, _To>(0)) type;
-    };
-
-
-
-  template<typename _From, typename _To>
-    struct is_convertible
-    : public __is_convertible_helper<_From, _To>::type
-    { };
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_const
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_const<_Tp const>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_volatile
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_volatile<_Tp volatile>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_cv
-    {
-      typedef typename
-      remove_const<typename remove_volatile<_Tp>::type>::type type;
-    };
-
-
-  template<typename _Tp>
-    struct add_const
-    { typedef _Tp const type; };
-
-
-  template<typename _Tp>
-    struct add_volatile
-    { typedef _Tp volatile type; };
-
-
-  template<typename _Tp>
-    struct add_cv
-    {
-      typedef typename
-      add_const<typename add_volatile<_Tp>::type>::type type;
-    };
-
-
-
-
-
-
-  template<typename _Tp>
-    using remove_const_t = typename remove_const<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_volatile_t = typename remove_volatile<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_cv_t = typename remove_cv<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_const_t = typename add_const<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_volatile_t = typename add_volatile<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_cv_t = typename add_cv<_Tp>::type;
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_reference
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_reference<_Tp&>
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_reference<_Tp&&>
-    { typedef _Tp type; };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __add_lvalue_reference_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_lvalue_reference_helper<_Tp, true>
-    { typedef _Tp& type; };
-
-
-  template<typename _Tp>
-    struct add_lvalue_reference
-    : public __add_lvalue_reference_helper<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __add_rvalue_reference_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_rvalue_reference_helper<_Tp, true>
-    { typedef _Tp&& type; };
-
-
-  template<typename _Tp>
-    struct add_rvalue_reference
-    : public __add_rvalue_reference_helper<_Tp>
-    { };
-
-
-
-  template<typename _Tp>
-    using remove_reference_t = typename remove_reference<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
-
-
-
-
-
-  template<typename _Unqualified, bool _IsConst, bool _IsVol>
-    struct __cv_selector;
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, false, false>
-    { typedef _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, false, true>
-    { typedef volatile _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, true, false>
-    { typedef const _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, true, true>
-    { typedef const volatile _Unqualified __type; };
-
-  template<typename _Qualified, typename _Unqualified,
-    bool _IsConst = is_const<_Qualified>::value,
-    bool _IsVol = is_volatile<_Qualified>::value>
-    class __match_cv_qualifiers
-    {
-      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
-
-    public:
-      typedef typename __match::__type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __make_unsigned
-    { typedef _Tp __type; };
-
-  template<>
-    struct __make_unsigned<char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __make_unsigned<signed char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __make_unsigned<short>
-    { typedef unsigned short __type; };
-
-  template<>
-    struct __make_unsigned<int>
-    { typedef unsigned int __type; };
-
-  template<>
-    struct __make_unsigned<long>
-    { typedef unsigned long __type; };
-
-  template<>
-    struct __make_unsigned<long long>
-    { typedef unsigned long long __type; };
-
-
-  template<>
-    struct __make_unsigned<wchar_t> : __make_unsigned<int>
-    { };
-# 1785 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp,
-    bool _IsInt = is_integral<_Tp>::value,
-    bool _IsEnum = is_enum<_Tp>::value>
-    class __make_unsigned_selector;
-
-  template<typename _Tp>
-    class __make_unsigned_selector<_Tp, true, false>
-    {
-      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
-      typedef typename __unsignedt::__type __unsigned_type;
-      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
-
-    public:
-      typedef typename __cv_unsigned::__type __type;
-    };
-
-  template<typename _Tp>
-    class __make_unsigned_selector<_Tp, false, true>
-    {
-
-      typedef unsigned char __smallest;
-      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
-      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
-      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
-      static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
-      typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
-      typedef typename __cond3::type __cond3_type;
-      typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
-      typedef typename __cond2::type __cond2_type;
-      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
-      typedef typename __cond1::type __cond1_type;
-
-      typedef typename conditional<__b0, __smallest, __cond1_type>::type
- __unsigned_type;
-      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
-
-    public:
-      typedef typename __cv_unsigned::__type __type;
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct make_unsigned
-    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
-
-
-  template<>
-    struct make_unsigned<bool>;
-
-
-
-  template<typename _Tp>
-    struct __make_signed
-    { typedef _Tp __type; };
-
-  template<>
-    struct __make_signed<char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __make_signed<unsigned char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __make_signed<unsigned short>
-    { typedef signed short __type; };
-
-  template<>
-    struct __make_signed<unsigned int>
-    { typedef signed int __type; };
-
-  template<>
-    struct __make_signed<unsigned long>
-    { typedef signed long __type; };
-
-  template<>
-    struct __make_signed<unsigned long long>
-    { typedef signed long long __type; };
-# 1874 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<>
-    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
-    { };
-  template<>
-    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
-    { };
-# 1904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Tp,
-    bool _IsInt = is_integral<_Tp>::value,
-    bool _IsEnum = is_enum<_Tp>::value>
-    class __make_signed_selector;
-
-  template<typename _Tp>
-    class __make_signed_selector<_Tp, true, false>
-    {
-      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
-      typedef typename __signedt::__type __signed_type;
-      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
-
-    public:
-      typedef typename __cv_signed::__type __type;
-    };
-
-  template<typename _Tp>
-    class __make_signed_selector<_Tp, false, true>
-    {
-      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
-
-    public:
-      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct make_signed
-    { typedef typename __make_signed_selector<_Tp>::__type type; };
-
-
-  template<>
-    struct make_signed<bool>;
-
-
-
-  template<typename _Tp>
-    using make_signed_t = typename make_signed<_Tp>::type;
-
-
-  template<typename _Tp>
-    using make_unsigned_t = typename make_unsigned<_Tp>::type;
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_extent
-    { typedef _Tp type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_extent<_Tp[_Size]>
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_extent<_Tp[]>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_all_extents
-    { typedef _Tp type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_all_extents<_Tp[_Size]>
-    { typedef typename remove_all_extents<_Tp>::type type; };
-
-  template<typename _Tp>
-    struct remove_all_extents<_Tp[]>
-    { typedef typename remove_all_extents<_Tp>::type type; };
-
-
-
-  template<typename _Tp>
-    using remove_extent_t = typename remove_extent<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
-
-
-
-
-  template<typename _Tp, typename>
-    struct __remove_pointer_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp, typename _Up>
-    struct __remove_pointer_helper<_Tp, _Up*>
-    { typedef _Up type; };
-
-
-  template<typename _Tp>
-    struct remove_pointer
-    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
-    { };
-
-
-  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
-          is_void<_Tp>>::value>
-    struct __add_pointer_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_pointer_helper<_Tp, true>
-    { typedef typename remove_reference<_Tp>::type* type; };
-
-  template<typename _Tp>
-    struct add_pointer
-    : public __add_pointer_helper<_Tp>
-    { };
-
-
-
-  template<typename _Tp>
-    using remove_pointer_t = typename remove_pointer<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_pointer_t = typename add_pointer<_Tp>::type;
-
-
-  template<std::size_t _Len>
-    struct __aligned_storage_msa
-    {
-      union __type
-      {
- unsigned char __data[_Len];
- struct __attribute__((__aligned__)) { } __align;
-      };
-    };
-# 2050 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<std::size_t _Len, std::size_t _Align =
-    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
-    struct aligned_storage
-    {
-      union type
-      {
- unsigned char __data[_Len];
- struct __attribute__((__aligned__((_Align)))) { } __align;
-      };
-    };
-
-  template <typename... _Types>
-    struct __strictest_alignment
-    {
-      static const size_t _S_alignment = 0;
-      static const size_t _S_size = 0;
-    };
-
-  template <typename _Tp, typename... _Types>
-    struct __strictest_alignment<_Tp, _Types...>
-    {
-      static const size_t _S_alignment =
-        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
- ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
-      static const size_t _S_size =
-        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
- ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
-    };
-# 2089 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template <size_t _Len, typename... _Types>
-    struct aligned_union
-    {
-    private:
-      static_assert(sizeof...(_Types) != 0, "At least one type is required");
-
-      using __strictest = __strictest_alignment<_Types...>;
-      static const size_t _S_len = _Len > __strictest::_S_size
- ? _Len : __strictest::_S_size;
-    public:
-
-      static const size_t alignment_value = __strictest::_S_alignment;
-
-      typedef typename aligned_storage<_S_len, alignment_value>::type type;
-    };
-
-  template <size_t _Len, typename... _Types>
-    const size_t aligned_union<_Len, _Types...>::alignment_value;
-
-
-
-  template<typename _Up,
-    bool _IsArray = is_array<_Up>::value,
-    bool _IsFunction = is_function<_Up>::value>
-    struct __decay_selector;
-
-
-  template<typename _Up>
-    struct __decay_selector<_Up, false, false>
-    { typedef typename remove_cv<_Up>::type __type; };
-
-  template<typename _Up>
-    struct __decay_selector<_Up, true, false>
-    { typedef typename remove_extent<_Up>::type* __type; };
-
-  template<typename _Up>
-    struct __decay_selector<_Up, false, true>
-    { typedef typename add_pointer<_Up>::type __type; };
-
-
-  template<typename _Tp>
-    class decay
-    {
-      typedef typename remove_reference<_Tp>::type __remove_type;
-
-    public:
-      typedef typename __decay_selector<__remove_type>::__type type;
-    };
-
-  template<typename _Tp>
-    class reference_wrapper;
-
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper
-    {
-      typedef _Tp __type;
-    };
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
-
-  template<typename _Tp>
-    struct __decay_and_strip
-    {
-      typedef typename __strip_reference_wrapper<
- typename decay<_Tp>::type>::__type __type;
-    };
-
-
-
-
-  template<bool, typename _Tp = void>
-    struct enable_if
-    { };
-
-
-  template<typename _Tp>
-    struct enable_if<true, _Tp>
-    { typedef _Tp type; };
-
-  template<typename... _Cond>
-    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
-
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    struct conditional
-    { typedef _Iftrue type; };
-
-
-  template<typename _Iftrue, typename _Iffalse>
-    struct conditional<false, _Iftrue, _Iffalse>
-    { typedef _Iffalse type; };
-
-
-  template<typename... _Tp>
-    struct common_type;
-
-
-
-  struct __do_common_type_impl
-  {
-    template<typename _Tp, typename _Up>
-      static __success_type<typename decay<decltype
-       (true ? std::declval<_Tp>()
-        : std::declval<_Up>())>::type> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Tp, typename _Up>
-    struct __common_type_impl
-    : private __do_common_type_impl
-    {
-      typedef decltype(_S_test<_Tp, _Up>(0)) type;
-    };
-
-  struct __do_member_type_wrapper
-  {
-    template<typename _Tp>
-      static __success_type<typename _Tp::type> _S_test(int);
-
-    template<typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Tp>
-    struct __member_type_wrapper
-    : private __do_member_type_wrapper
-    {
-      typedef decltype(_S_test<_Tp>(0)) type;
-    };
-
-  template<typename _CTp, typename... _Args>
-    struct __expanded_common_type_wrapper
-    {
-      typedef common_type<typename _CTp::type, _Args...> type;
-    };
-
-  template<typename... _Args>
-    struct __expanded_common_type_wrapper<__failure_type, _Args...>
-    { typedef __failure_type type; };
-
-  template<typename _Tp>
-    struct common_type<_Tp>
-    { typedef typename decay<_Tp>::type type; };
-
-  template<typename _Tp, typename _Up>
-    struct common_type<_Tp, _Up>
-    : public __common_type_impl<_Tp, _Up>::type
-    { };
-
-  template<typename _Tp, typename _Up, typename... _Vp>
-    struct common_type<_Tp, _Up, _Vp...>
-    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
-               common_type<_Tp, _Up>>::type, _Vp...>::type
-    { };
-
-
-  template<typename _Tp>
-    struct underlying_type
-    {
-      typedef __underlying_type(_Tp) type;
-    };
-
-  template<typename _Tp>
-    struct __declval_protector
-    {
-      static const bool __stop = false;
-      static typename add_rvalue_reference<_Tp>::type __delegate();
-    };
-
-  template<typename _Tp>
-    inline typename add_rvalue_reference<_Tp>::type
-    declval() noexcept
-    {
-      static_assert(__declval_protector<_Tp>::__stop,
-      "declval() must not be used!");
-      return __declval_protector<_Tp>::__delegate();
-    }
-
-
-  template<typename _Signature>
-    class result_of;
-
-
-
-
-
-  struct __invoke_memfun_ref { };
-  struct __invoke_memfun_deref { };
-  struct __invoke_memobj_ref { };
-  struct __invoke_memobj_deref { };
-  struct __invoke_other { };
-
-
-  template<typename _Tp, typename _Tag>
-    struct __result_of_success : __success_type<_Tp>
-    { using __invoke_type = _Tag; };
-
-
-  struct __result_of_memfun_ref_impl
-  {
-    template<typename _Fp, typename _Tp1, typename... _Args>
-      static __result_of_success<decltype(
-      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
-      ), __invoke_memfun_ref> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun_ref
-    : private __result_of_memfun_ref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
-    };
-
-
-  struct __result_of_memfun_deref_impl
-  {
-    template<typename _Fp, typename _Tp1, typename... _Args>
-      static __result_of_success<decltype(
-      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
-      ), __invoke_memfun_deref> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun_deref
-    : private __result_of_memfun_deref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
-    };
-
-
-  struct __result_of_memobj_ref_impl
-  {
-    template<typename _Fp, typename _Tp1>
-      static __result_of_success<decltype(
-      std::declval<_Tp1>().*std::declval<_Fp>()
-      ), __invoke_memobj_ref> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj_ref
-    : private __result_of_memobj_ref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
-    };
-
-
-  struct __result_of_memobj_deref_impl
-  {
-    template<typename _Fp, typename _Tp1>
-      static __result_of_success<decltype(
-      (*std::declval<_Tp1>()).*std::declval<_Fp>()
-      ), __invoke_memobj_deref> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj_deref
-    : private __result_of_memobj_deref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
-    };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj;
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, _Arg>
-    {
-      typedef typename remove_cv<typename remove_reference<
-        _Arg>::type>::type _Argval;
-      typedef _Res _Class::* _MemPtr;
-      typedef typename conditional<__or_<is_same<_Argval, _Class>,
-        is_base_of<_Class, _Argval>>::value,
-        __result_of_memobj_ref<_MemPtr, _Arg>,
-        __result_of_memobj_deref<_MemPtr, _Arg>
-      >::type::type type;
-    };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun;
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
-    {
-      typedef typename remove_cv<typename remove_reference<
-        _Arg>::type>::type _Argval;
-      typedef _Res _Class::* _MemPtr;
-      typedef typename conditional<__or_<is_same<_Argval, _Class>,
-        is_base_of<_Class, _Argval>>::value,
-        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
-        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
-      >::type::type type;
-    };
-
-
-
-
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
-    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&>
-    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&>
-    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&>
-    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, const reference_wrapper<_Arg>&&>
-    : __result_of_memobj_ref<_Res _Class::*, _Arg&>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
-    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&,
-         _Args...>
-    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&,
-         _Args...>
-    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&&,
-         _Args...>
-    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
-    { };
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, const reference_wrapper<_Arg>&&,
-         _Args...>
-    : __result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>
-    { };
-
-  template<bool, bool, typename _Functor, typename... _ArgTypes>
-    struct __result_of_impl
-    {
-      typedef __failure_type type;
-    };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_impl<true, false, _MemPtr, _Arg>
-    : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
-    { };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
-    : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
-    { };
-
-
-  struct __result_of_other_impl
-  {
-    template<typename _Fn, typename... _Args>
-      static __result_of_success<decltype(
-      std::declval<_Fn>()(std::declval<_Args>()...)
-      ), __invoke_other> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
-    : private __result_of_other_impl
-    {
-      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct result_of<_Functor(_ArgTypes...)>
-    : public __result_of_impl<
-        is_member_object_pointer<
-          typename remove_reference<_Functor>::type
-        >::value,
-        is_member_function_pointer<
-          typename remove_reference<_Functor>::type
-        >::value,
-     _Functor, _ArgTypes...
-      >::type
-    { };
-
-
-
-  template<size_t _Len, size_t _Align =
-     __alignof__(typename __aligned_storage_msa<_Len>::__type)>
-    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
-
-  template <size_t _Len, typename... _Types>
-    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
-
-
-  template<typename _Tp>
-    using decay_t = typename decay<_Tp>::type;
-
-
-  template<bool _Cond, typename _Tp = void>
-    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
-
-
-  template<typename... _Tp>
-    using common_type_t = typename common_type<_Tp...>::type;
-
-
-  template<typename _Tp>
-    using underlying_type_t = typename underlying_type<_Tp>::type;
-
-
-  template<typename _Tp>
-    using result_of_t = typename result_of<_Tp>::type;
-
-
-  template<typename...> using __void_t = void;
-# 2551 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template<typename _Default, typename _AlwaysVoid,
-    template<typename...> class _Op, typename... _Args>
-    struct __detector
-    {
-      using value_t = false_type;
-      using type = _Default;
-    };
-
-
-  template<typename _Default, template<typename...> class _Op,
-     typename... _Args>
-    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
-    {
-      using value_t = true_type;
-      using type = _Op<_Args...>;
-    };
-
-
-  template<typename _Default, template<typename...> class _Op,
-    typename... _Args>
-    using __detected_or = __detector<_Default, void, _Op, _Args...>;
-
-
-  template<typename _Default, template<typename...> class _Op,
-    typename... _Args>
-    using __detected_or_t
-      = typename __detected_or<_Default, _Op, _Args...>::type;
-
-
-  template<template<typename...> class _Default,
-    template<typename...> class _Op, typename... _Args>
-    using __detected_or_t_ =
-      __detected_or_t<_Default<_Args...>, _Op, _Args...>;
-# 2601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/type_traits" 3
-  template <typename _Tp>
-    struct __is_swappable;
-
-  template <typename _Tp>
-    struct __is_nothrow_swappable;
-
-  template<typename _Tp>
-    inline
-    typename enable_if<__and_<is_move_constructible<_Tp>,
-         is_move_assignable<_Tp>>::value>::type
-    swap(_Tp&, _Tp&)
-    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
-             is_nothrow_move_assignable<_Tp>>::value);
-
-  template<typename _Tp, size_t _Nm>
-    inline
-    typename enable_if<__is_swappable<_Tp>::value>::type
-    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
-    noexcept(__is_nothrow_swappable<_Tp>::value);
-
-  namespace __swappable_details {
-    using std::swap;
-
-    struct __do_is_swappable_impl
-    {
-      template<typename _Tp, typename
-               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
-        static true_type __test(int);
-
-      template<typename>
-        static false_type __test(...);
-    };
-
-    struct __do_is_nothrow_swappable_impl
-    {
-      template<typename _Tp>
-        static __bool_constant<
-          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
-        > __test(int);
-
-      template<typename>
-        static false_type __test(...);
-    };
-
-  }
-
-  template<typename _Tp>
-    struct __is_swappable_impl
-    : public __swappable_details::__do_is_swappable_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_nothrow_swappable_impl
-    : public __swappable_details::__do_is_nothrow_swappable_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_swappable
-    : public __is_swappable_impl<_Tp>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_nothrow_swappable
-    : public __is_nothrow_swappable_impl<_Tp>::type
-    { };
-
-
-}
-# 58 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-  template<typename _Tp>
-    constexpr _Tp&&
-    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
-    { return static_cast<_Tp&&>(__t); }
-
-
-
-
-
-
-
-  template<typename _Tp>
-    constexpr _Tp&&
-    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
-    {
-      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
-      " substituting _Tp is an lvalue reference type");
-      return static_cast<_Tp&&>(__t);
-    }
-
-
-
-
-
-
-  template<typename _Tp>
-    constexpr typename std::remove_reference<_Tp>::type&&
-    move(_Tp&& __t) noexcept
-    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
-
-
-  template<typename _Tp>
-    struct __move_if_noexcept_cond
-    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
-                    is_copy_constructible<_Tp>>::type { };
-# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-  template<typename _Tp>
-    constexpr typename
-    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
-    move_if_noexcept(_Tp& __x) noexcept
-    { return std::move(__x); }
-# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-  template<typename _Tp>
-    inline _Tp*
-    addressof(_Tp& __r) noexcept
-    { return std::__addressof(__r); }
-
-
-  template <typename _Tp, typename _Up = _Tp>
-    inline _Tp
-    __exchange(_Tp& __obj, _Up&& __new_val)
-    {
-      _Tp __old_val = std::move(__obj);
-      __obj = std::forward<_Up>(__new_val);
-      return __old_val;
-    }
-
-
-
-}
-# 159 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 174 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/move.h" 3
-  template<typename _Tp>
-    inline
-
-    typename enable_if<__and_<is_move_constructible<_Tp>,
-         is_move_assignable<_Tp>>::value>::type
-    swap(_Tp& __a, _Tp& __b)
-    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
-             is_nothrow_move_assignable<_Tp>>::value)
-
-
-
-
-    {
-
-
-
-      _Tp __tmp = std::move(__a);
-      __a = std::move(__b);
-      __b = std::move(__tmp);
-    }
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline
-
-    typename enable_if<__is_swappable<_Tp>::value>::type
-    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
-    noexcept(__is_nothrow_swappable<_Tp>::value)
-
-
-
-
-    {
-      for (size_t __n = 0; __n < _Nm; ++__n)
- swap(__a[__n], __b[__n]);
-    }
-
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/nested_exception.h" 2 3
-
-
-
-
-
-extern "C++" {
-
-namespace std
-{
-
-
-
-
-
-
-  class nested_exception
-  {
-    exception_ptr _M_ptr;
-
-  public:
-    nested_exception() noexcept : _M_ptr(current_exception()) { }
-
-    nested_exception(const nested_exception&) noexcept = default;
-
-    nested_exception& operator=(const nested_exception&) noexcept = default;
-
-    virtual ~nested_exception() noexcept;
-
-    [[noreturn]]
-    void
-    rethrow_nested() const
-    {
-      if (_M_ptr)
- rethrow_exception(_M_ptr);
-      std::terminate();
-    }
-
-    exception_ptr
-    nested_ptr() const noexcept
-    { return _M_ptr; }
-  };
-
-  template<typename _Except>
-    struct _Nested_exception : public _Except, public nested_exception
-    {
-      explicit _Nested_exception(const _Except& __ex)
-      : _Except(__ex)
-      { }
-
-      explicit _Nested_exception(_Except&& __ex)
-      : _Except(static_cast<_Except&&>(__ex))
-      { }
-    };
-
-
-
-
-  template<typename _Tp>
-    inline void
-    __throw_with_nested_impl(_Tp&& __t, true_type)
-    {
-      using _Up = typename remove_reference<_Tp>::type;
-      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
-    }
-
-  template<typename _Tp>
-    inline void
-    __throw_with_nested_impl(_Tp&& __t, false_type)
-    { throw std::forward<_Tp>(__t); }
-
-
-
-  template<typename _Tp>
-    [[noreturn]]
-    inline void
-    throw_with_nested(_Tp&& __t)
-    {
-      using _Up = typename remove_reference<_Tp>::type;
-      using _CopyConstructible
- = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
-      static_assert(_CopyConstructible::value,
-   "throw_with_nested argument must be CopyConstructible");
-      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
-       __not_<is_base_of<nested_exception, _Up>>>;
-      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
-    }
-
-
-  template<typename _Tp>
-    using __rethrow_if_nested_cond = typename enable_if<
-      __and_<is_polymorphic<_Tp>,
-      __or_<__not_<is_base_of<nested_exception, _Tp>>,
-     is_convertible<_Tp*, nested_exception*>>>::value
-    >::type;
-
-
-  template<typename _Ex>
-    inline __rethrow_if_nested_cond<_Ex>
-    __rethrow_if_nested_impl(const _Ex* __ptr)
-    {
-      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
- __ne_ptr->rethrow_nested();
-    }
-
-
-  inline void
-  __rethrow_if_nested_impl(const void*)
-  { }
-
-
-  template<typename _Ex>
-    inline void
-    rethrow_if_nested(const _Ex& __ex)
-    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
-
-
-}
-
-}
-
-
-
-#pragma GCC visibility pop
-# 172 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/exception" 2 3
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 2 3
-
-#pragma GCC visibility push(default)
-
-extern "C++" {
-
-namespace std
-{
-
-
-
-
-
-
-  class bad_alloc : public exception
-  {
-  public:
-    bad_alloc() throw() { }
-
-
-
-    virtual ~bad_alloc() throw();
-
-
-    virtual const char* what() const throw();
-  };
-
-
-  class bad_array_new_length : public bad_alloc
-  {
-  public:
-    bad_array_new_length() throw() { };
-
-
-
-    virtual ~bad_array_new_length() throw();
-
-
-    virtual const char* what() const throw();
-  };
-
-
-  struct nothrow_t
-  {
-
-    explicit nothrow_t() = default;
-
-  };
-
-  extern const nothrow_t nothrow;
-
-
-
-  typedef void (*new_handler)();
-
-
-
-  new_handler set_new_handler(new_handler) throw();
-
-
-
-  new_handler get_new_handler() noexcept;
-
-}
-# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
-void* operator new(std::size_t)
-  __attribute__((__externally_visible__));
-void* operator new[](std::size_t)
-  __attribute__((__externally_visible__));
-void operator delete(void*) noexcept
-  __attribute__((__externally_visible__));
-void operator delete[](void*) noexcept
-  __attribute__((__externally_visible__));
-
-
-
-
-
-
-void* operator new(std::size_t, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void* operator new[](std::size_t, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void operator delete(void*, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void operator delete[](void*, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/new" 3
-inline void* operator new(std::size_t, void* __p) noexcept
-{ return __p; }
-inline void* operator new[](std::size_t, void* __p) noexcept
-{ return __p; }
-
-
-inline void operator delete (void*, void*) noexcept { }
-inline void operator delete[](void*, void*) noexcept { }
-
-}
-
-#pragma GCC visibility pop
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-# 75 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-# 1 "/usr/include/stdlib.h" 1 3 4
-# 32 "/usr/include/stdlib.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 33 "/usr/include/stdlib.h" 2 3 4
-
-extern "C" {
-
-
-
-
-
-
-
-# 1 "/usr/include/bits/waitflags.h" 1 3 4
-# 42 "/usr/include/stdlib.h" 2 3 4
-# 1 "/usr/include/bits/waitstatus.h" 1 3 4
-# 43 "/usr/include/stdlib.h" 2 3 4
-# 58 "/usr/include/stdlib.h" 3 4
-typedef struct
-  {
-    int quot;
-    int rem;
-  } div_t;
-
-
-
-typedef struct
-  {
-    long int quot;
-    long int rem;
-  } ldiv_t;
-
-
-
-
-
-
-
-__extension__ typedef struct
-  {
-    long long int quot;
-    long long int rem;
-  } lldiv_t;
-# 100 "/usr/include/stdlib.h" 3 4
-extern size_t __ctype_get_mb_cur_max (void) throw () ;
-
-
-
-
-extern double atof (const char *__nptr)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
-
-extern int atoi (const char *__nptr)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
-
-extern long int atol (const char *__nptr)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-
-__extension__ extern long long int atoll (const char *__nptr)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-
-extern double strtod (const char *__restrict __nptr,
-        char **__restrict __endptr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern float strtof (const char *__restrict __nptr,
-       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
-
-extern long double strtold (const char *__restrict __nptr,
-       char **__restrict __endptr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern long int strtol (const char *__restrict __nptr,
-   char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-extern unsigned long int strtoul (const char *__restrict __nptr,
-      char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-__extension__
-extern long long int strtoq (const char *__restrict __nptr,
-        char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-__extension__
-extern unsigned long long int strtouq (const char *__restrict __nptr,
-           char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-__extension__
-extern long long int strtoll (const char *__restrict __nptr,
-         char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-__extension__
-extern unsigned long long int strtoull (const char *__restrict __nptr,
-     char **__restrict __endptr, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 200 "/usr/include/stdlib.h" 3 4
-extern long int strtol_l (const char *__restrict __nptr,
-     char **__restrict __endptr, int __base,
-     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
-
-extern unsigned long int strtoul_l (const char *__restrict __nptr,
-        char **__restrict __endptr,
-        int __base, __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 4)));
-
-__extension__
-extern long long int strtoll_l (const char *__restrict __nptr,
-    char **__restrict __endptr, int __base,
-    __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 4)));
-
-__extension__
-extern unsigned long long int strtoull_l (const char *__restrict __nptr,
-       char **__restrict __endptr,
-       int __base, __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 4)));
-
-extern double strtod_l (const char *__restrict __nptr,
-   char **__restrict __endptr, __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-
-extern float strtof_l (const char *__restrict __nptr,
-         char **__restrict __endptr, __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-
-extern long double strtold_l (const char *__restrict __nptr,
-         char **__restrict __endptr,
-         __locale_t __loc)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-# 266 "/usr/include/stdlib.h" 3 4
-extern char *l64a (long int __n) throw () ;
-
-
-extern long int a64l (const char *__s)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-
-# 1 "/usr/include/sys/types.h" 1 3 4
-# 27 "/usr/include/sys/types.h" 3 4
-extern "C" {
-
-
-
-
-
-typedef __u_char u_char;
-typedef __u_short u_short;
-typedef __u_int u_int;
-typedef __u_long u_long;
-typedef __quad_t quad_t;
-typedef __u_quad_t u_quad_t;
-typedef __fsid_t fsid_t;
-
-
-
-
-typedef __loff_t loff_t;
-
-
-
-typedef __ino_t ino_t;
-
-
-
-
-
-
-typedef __ino64_t ino64_t;
-
-
-
-
-typedef __dev_t dev_t;
-
-
-
-
-typedef __gid_t gid_t;
-
-
-
-
-typedef __mode_t mode_t;
-
-
-
-
-typedef __nlink_t nlink_t;
-
-
-
-
-typedef __uid_t uid_t;
-# 98 "/usr/include/sys/types.h" 3 4
-typedef __pid_t pid_t;
-
-
-
-
-
-typedef __id_t id_t;
-# 115 "/usr/include/sys/types.h" 3 4
-typedef __daddr_t daddr_t;
-typedef __caddr_t caddr_t;
-
-
-
-
-
-typedef __key_t key_t;
-# 132 "/usr/include/sys/types.h" 3 4
-# 1 "/usr/include/time.h" 1 3 4
-# 59 "/usr/include/time.h" 3 4
-typedef __clock_t clock_t;
-# 75 "/usr/include/time.h" 3 4
-typedef __time_t time_t;
-# 91 "/usr/include/time.h" 3 4
-typedef __clockid_t clockid_t;
-# 103 "/usr/include/time.h" 3 4
-typedef __timer_t timer_t;
-# 133 "/usr/include/sys/types.h" 2 3 4
-
-
-
-typedef __useconds_t useconds_t;
-
-
-
-typedef __suseconds_t suseconds_t;
-
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 147 "/usr/include/sys/types.h" 2 3 4
-
-
-
-typedef unsigned long int ulong;
-typedef unsigned short int ushort;
-typedef unsigned int uint;
-# 200 "/usr/include/sys/types.h" 3 4
-typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
-typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
-typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
-typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
-
-typedef int register_t __attribute__ ((__mode__ (__word__)));
-# 216 "/usr/include/sys/types.h" 3 4
-# 1 "/usr/include/endian.h" 1 3 4
-# 36 "/usr/include/endian.h" 3 4
-# 1 "/usr/include/bits/endian.h" 1 3 4
-# 37 "/usr/include/endian.h" 2 3 4
-# 60 "/usr/include/endian.h" 3 4
-# 1 "/usr/include/bits/byteswap.h" 1 3 4
-# 28 "/usr/include/bits/byteswap.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 29 "/usr/include/bits/byteswap.h" 2 3 4
-
-
-
-
-
-
-# 1 "/usr/include/bits/byteswap-16.h" 1 3 4
-# 36 "/usr/include/bits/byteswap.h" 2 3 4
-# 61 "/usr/include/endian.h" 2 3 4
-# 217 "/usr/include/sys/types.h" 2 3 4
-
-
-# 1 "/usr/include/sys/select.h" 1 3 4
-# 30 "/usr/include/sys/select.h" 3 4
-# 1 "/usr/include/bits/select.h" 1 3 4
-# 22 "/usr/include/bits/select.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 23 "/usr/include/bits/select.h" 2 3 4
-# 31 "/usr/include/sys/select.h" 2 3 4
-
-
-# 1 "/usr/include/bits/sigset.h" 1 3 4
-# 22 "/usr/include/bits/sigset.h" 3 4
-typedef int __sig_atomic_t;
-
-
-
-
-typedef struct
-  {
-    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
-  } __sigset_t;
-# 34 "/usr/include/sys/select.h" 2 3 4
-
-
-
-typedef __sigset_t sigset_t;
-
-
-
-
-
-
-
-
-# 1 "/usr/include/time.h" 1 3 4
-# 120 "/usr/include/time.h" 3 4
-struct timespec
-  {
-    __time_t tv_sec;
-    __syscall_slong_t tv_nsec;
-  };
-# 46 "/usr/include/sys/select.h" 2 3 4
-
-# 1 "/usr/include/bits/time.h" 1 3 4
-# 30 "/usr/include/bits/time.h" 3 4
-struct timeval
-  {
-    __time_t tv_sec;
-    __suseconds_t tv_usec;
-  };
-# 48 "/usr/include/sys/select.h" 2 3 4
-
-
-
-
-
-
-
-
-typedef long int __fd_mask;
-# 66 "/usr/include/sys/select.h" 3 4
-typedef struct
-  {
-
-
-
-    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
-
-
-
-
-
-  } fd_set;
-
-
-
-
-
-
-typedef __fd_mask fd_mask;
-# 98 "/usr/include/sys/select.h" 3 4
-extern "C" {
-# 108 "/usr/include/sys/select.h" 3 4
-extern int select (int __nfds, fd_set *__restrict __readfds,
-     fd_set *__restrict __writefds,
-     fd_set *__restrict __exceptfds,
-     struct timeval *__restrict __timeout);
-# 120 "/usr/include/sys/select.h" 3 4
-extern int pselect (int __nfds, fd_set *__restrict __readfds,
-      fd_set *__restrict __writefds,
-      fd_set *__restrict __exceptfds,
-      const struct timespec *__restrict __timeout,
-      const __sigset_t *__restrict __sigmask);
-# 133 "/usr/include/sys/select.h" 3 4
-}
-# 220 "/usr/include/sys/types.h" 2 3 4
-
-
-# 1 "/usr/include/sys/sysmacros.h" 1 3 4
-# 24 "/usr/include/sys/sysmacros.h" 3 4
-extern "C" {
-
-__extension__
-extern unsigned int gnu_dev_major (unsigned long long int __dev)
-     throw () __attribute__ ((__const__));
-__extension__
-extern unsigned int gnu_dev_minor (unsigned long long int __dev)
-     throw () __attribute__ ((__const__));
-__extension__
-extern unsigned long long int gnu_dev_makedev (unsigned int __major,
-            unsigned int __minor)
-     throw () __attribute__ ((__const__));
-# 58 "/usr/include/sys/sysmacros.h" 3 4
-}
-# 223 "/usr/include/sys/types.h" 2 3 4
-
-
-
-
-
-typedef __blksize_t blksize_t;
-
-
-
-
-
-
-typedef __blkcnt_t blkcnt_t;
-
-
-
-typedef __fsblkcnt_t fsblkcnt_t;
-
-
-
-typedef __fsfilcnt_t fsfilcnt_t;
-# 262 "/usr/include/sys/types.h" 3 4
-typedef __blkcnt64_t blkcnt64_t;
-typedef __fsblkcnt64_t fsblkcnt64_t;
-typedef __fsfilcnt64_t fsfilcnt64_t;
-
-
-
-
-
-
-# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
-# 21 "/usr/include/bits/pthreadtypes.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
-# 60 "/usr/include/bits/pthreadtypes.h" 3 4
-typedef unsigned long int pthread_t;
-
-
-union pthread_attr_t
-{
-  char __size[56];
-  long int __align;
-};
-
-typedef union pthread_attr_t pthread_attr_t;
-
-
-
-
-
-typedef struct __pthread_internal_list
-{
-  struct __pthread_internal_list *__prev;
-  struct __pthread_internal_list *__next;
-} __pthread_list_t;
-# 90 "/usr/include/bits/pthreadtypes.h" 3 4
-typedef union
-{
-  struct __pthread_mutex_s
-  {
-    int __lock;
-    unsigned int __count;
-    int __owner;
-
-    unsigned int __nusers;
-
-
-
-    int __kind;
-
-    short __spins;
-    short __elision;
-    __pthread_list_t __list;
-# 125 "/usr/include/bits/pthreadtypes.h" 3 4
-  } __data;
-  char __size[40];
-  long int __align;
-} pthread_mutex_t;
-
-typedef union
-{
-  char __size[4];
-  int __align;
-} pthread_mutexattr_t;
-
-
-
-
-typedef union
-{
-  struct
-  {
-    int __lock;
-    unsigned int __futex;
-    __extension__ unsigned long long int __total_seq;
-    __extension__ unsigned long long int __wakeup_seq;
-    __extension__ unsigned long long int __woken_seq;
-    void *__mutex;
-    unsigned int __nwaiters;
-    unsigned int __broadcast_seq;
-  } __data;
-  char __size[48];
-  __extension__ long long int __align;
-} pthread_cond_t;
-
-typedef union
-{
-  char __size[4];
-  int __align;
-} pthread_condattr_t;
-
-
-
-typedef unsigned int pthread_key_t;
-
-
-
-typedef int pthread_once_t;
-
-
-
-
-
-typedef union
-{
-
-  struct
-  {
-    int __lock;
-    unsigned int __nr_readers;
-    unsigned int __readers_wakeup;
-    unsigned int __writer_wakeup;
-    unsigned int __nr_readers_queued;
-    unsigned int __nr_writers_queued;
-    int __writer;
-    int __shared;
-    signed char __rwelision;
-
-
-
-
-    unsigned char __pad1[7];
-
-
-    unsigned long int __pad2;
-
-
-    unsigned int __flags;
-
-  } __data;
-# 220 "/usr/include/bits/pthreadtypes.h" 3 4
-  char __size[56];
-  long int __align;
-} pthread_rwlock_t;
-
-typedef union
-{
-  char __size[8];
-  long int __align;
-} pthread_rwlockattr_t;
-
-
-
-
-
-typedef volatile int pthread_spinlock_t;
-
-
-
-
-typedef union
-{
-  char __size[32];
-  long int __align;
-} pthread_barrier_t;
-
-typedef union
-{
-  char __size[4];
-  int __align;
-} pthread_barrierattr_t;
-# 271 "/usr/include/sys/types.h" 2 3 4
-
-
-}
-# 276 "/usr/include/stdlib.h" 2 3 4
-
-
-
-
-
-
-extern long int random (void) throw ();
-
-
-extern void srandom (unsigned int __seed) throw ();
-
-
-
-
-
-extern char *initstate (unsigned int __seed, char *__statebuf,
-   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-
-struct random_data
-  {
-    int32_t *fptr;
-    int32_t *rptr;
-    int32_t *state;
-    int rand_type;
-    int rand_deg;
-    int rand_sep;
-    int32_t *end_ptr;
-  };
-
-extern int random_r (struct random_data *__restrict __buf,
-       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern int srandom_r (unsigned int __seed, struct random_data *__buf)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
-   size_t __statelen,
-   struct random_data *__restrict __buf)
-     throw () __attribute__ ((__nonnull__ (2, 4)));
-
-extern int setstate_r (char *__restrict __statebuf,
-         struct random_data *__restrict __buf)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-
-extern int rand (void) throw ();
-
-extern void srand (unsigned int __seed) throw ();
-
-
-
-
-extern int rand_r (unsigned int *__seed) throw ();
-
-
-
-
-
-
-
-extern double drand48 (void) throw ();
-extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern long int lrand48 (void) throw ();
-extern long int nrand48 (unsigned short int __xsubi[3])
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern long int mrand48 (void) throw ();
-extern long int jrand48 (unsigned short int __xsubi[3])
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern void srand48 (long int __seedval) throw ();
-extern unsigned short int *seed48 (unsigned short int __seed16v[3])
-     throw () __attribute__ ((__nonnull__ (1)));
-extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-struct drand48_data
-  {
-    unsigned short int __x[3];
-    unsigned short int __old_x[3];
-    unsigned short int __c;
-    unsigned short int __init;
-    __extension__ unsigned long long int __a;
-
-  };
-
-
-extern int drand48_r (struct drand48_data *__restrict __buffer,
-        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
-extern int erand48_r (unsigned short int __xsubi[3],
-        struct drand48_data *__restrict __buffer,
-        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int lrand48_r (struct drand48_data *__restrict __buffer,
-        long int *__restrict __result)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-extern int nrand48_r (unsigned short int __xsubi[3],
-        struct drand48_data *__restrict __buffer,
-        long int *__restrict __result)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int mrand48_r (struct drand48_data *__restrict __buffer,
-        long int *__restrict __result)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-extern int jrand48_r (unsigned short int __xsubi[3],
-        struct drand48_data *__restrict __buffer,
-        long int *__restrict __result)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-extern int seed48_r (unsigned short int __seed16v[3],
-       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern int lcong48_r (unsigned short int __param[7],
-        struct drand48_data *__buffer)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-# 427 "/usr/include/stdlib.h" 3 4
-extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
-
-extern void *calloc (size_t __nmemb, size_t __size)
-     throw () __attribute__ ((__malloc__)) ;
-# 441 "/usr/include/stdlib.h" 3 4
-extern void *realloc (void *__ptr, size_t __size)
-     throw () __attribute__ ((__warn_unused_result__));
-
-extern void free (void *__ptr) throw ();
-
-
-
-
-extern void cfree (void *__ptr) throw ();
-
-
-
-
-# 1 "/usr/include/alloca.h" 1 3 4
-# 24 "/usr/include/alloca.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 25 "/usr/include/alloca.h" 2 3 4
-
-extern "C" {
-
-
-
-
-
-extern void *alloca (size_t __size) throw ();
-
-
-
-
-
-}
-# 454 "/usr/include/stdlib.h" 2 3 4
-
-
-
-
-
-extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
-
-
-
-
-extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
-     throw () __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-extern void *aligned_alloc (size_t __alignment, size_t __size)
-     throw () __attribute__ ((__malloc__)) ;
-
-
-
-
-extern void abort (void) throw () __attribute__ ((__noreturn__));
-
-
-
-extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-extern "C++" int at_quick_exit (void (*__func) (void))
-     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
-# 496 "/usr/include/stdlib.h" 3 4
-extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern void exit (int __status) throw () __attribute__ ((__noreturn__));
-
-
-
-
-
-extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
-
-
-
-
-
-
-
-extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
-
-
-
-
-
-
-extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-
-extern char *secure_getenv (const char *__name)
-     throw () __attribute__ ((__nonnull__ (1))) ;
-
-
-
-
-
-
-extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern int setenv (const char *__name, const char *__value, int __replace)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern int clearenv (void) throw ();
-# 567 "/usr/include/stdlib.h" 3 4
-extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
-# 580 "/usr/include/stdlib.h" 3 4
-extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
-# 590 "/usr/include/stdlib.h" 3 4
-extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
-# 602 "/usr/include/stdlib.h" 3 4
-extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
-# 612 "/usr/include/stdlib.h" 3 4
-extern int mkstemps64 (char *__template, int __suffixlen)
-     __attribute__ ((__nonnull__ (1))) ;
-# 623 "/usr/include/stdlib.h" 3 4
-extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
-# 634 "/usr/include/stdlib.h" 3 4
-extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
-# 644 "/usr/include/stdlib.h" 3 4
-extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
-# 654 "/usr/include/stdlib.h" 3 4
-extern int mkostemps (char *__template, int __suffixlen, int __flags)
-     __attribute__ ((__nonnull__ (1))) ;
-# 666 "/usr/include/stdlib.h" 3 4
-extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
-     __attribute__ ((__nonnull__ (1))) ;
-# 677 "/usr/include/stdlib.h" 3 4
-extern int system (const char *__command) ;
-
-
-
-
-
-
-extern char *canonicalize_file_name (const char *__name)
-     throw () __attribute__ ((__nonnull__ (1))) ;
-# 694 "/usr/include/stdlib.h" 3 4
-extern char *realpath (const char *__restrict __name,
-         char *__restrict __resolved) throw () ;
-
-
-
-
-
-
-typedef int (*__compar_fn_t) (const void *, const void *);
-
-
-typedef __compar_fn_t comparison_fn_t;
-
-
-
-typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
-
-
-
-
-
-extern void *bsearch (const void *__key, const void *__base,
-        size_t __nmemb, size_t __size, __compar_fn_t __compar)
-     __attribute__ ((__nonnull__ (1, 2, 5))) ;
-
-
-
-
-
-
-
-extern void qsort (void *__base, size_t __nmemb, size_t __size,
-     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
-
-extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
-       __compar_d_fn_t __compar, void *__arg)
-  __attribute__ ((__nonnull__ (1, 4)));
-
-
-
-
-extern int abs (int __x) throw () __attribute__ ((__const__)) ;
-extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
-
-
-
-__extension__ extern long long int llabs (long long int __x)
-     throw () __attribute__ ((__const__)) ;
-
-
-
-
-
-
-
-extern div_t div (int __numer, int __denom)
-     throw () __attribute__ ((__const__)) ;
-extern ldiv_t ldiv (long int __numer, long int __denom)
-     throw () __attribute__ ((__const__)) ;
-
-
-
-
-__extension__ extern lldiv_t lldiv (long long int __numer,
-        long long int __denom)
-     throw () __attribute__ ((__const__)) ;
-# 772 "/usr/include/stdlib.h" 3 4
-extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
-     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
-
-
-
-
-extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
-     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
-
-
-
-
-extern char *gcvt (double __value, int __ndigit, char *__buf)
-     throw () __attribute__ ((__nonnull__ (3))) ;
-
-
-
-
-extern char *qecvt (long double __value, int __ndigit,
-      int *__restrict __decpt, int *__restrict __sign)
-     throw () __attribute__ ((__nonnull__ (3, 4))) ;
-extern char *qfcvt (long double __value, int __ndigit,
-      int *__restrict __decpt, int *__restrict __sign)
-     throw () __attribute__ ((__nonnull__ (3, 4))) ;
-extern char *qgcvt (long double __value, int __ndigit, char *__buf)
-     throw () __attribute__ ((__nonnull__ (3))) ;
-
-
-
-
-extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
-     int *__restrict __sign, char *__restrict __buf,
-     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
-extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
-     int *__restrict __sign, char *__restrict __buf,
-     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
-
-extern int qecvt_r (long double __value, int __ndigit,
-      int *__restrict __decpt, int *__restrict __sign,
-      char *__restrict __buf, size_t __len)
-     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
-extern int qfcvt_r (long double __value, int __ndigit,
-      int *__restrict __decpt, int *__restrict __sign,
-      char *__restrict __buf, size_t __len)
-     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
-
-
-
-
-
-
-extern int mblen (const char *__s, size_t __n) throw ();
-
-
-extern int mbtowc (wchar_t *__restrict __pwc,
-     const char *__restrict __s, size_t __n) throw ();
-
-
-extern int wctomb (char *__s, wchar_t __wchar) throw ();
-
-
-
-extern size_t mbstowcs (wchar_t *__restrict __pwcs,
-   const char *__restrict __s, size_t __n) throw ();
-
-extern size_t wcstombs (char *__restrict __s,
-   const wchar_t *__restrict __pwcs, size_t __n)
-     throw ();
-# 848 "/usr/include/stdlib.h" 3 4
-extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
-# 859 "/usr/include/stdlib.h" 3 4
-extern int getsubopt (char **__restrict __optionp,
-        char *const *__restrict __tokens,
-        char **__restrict __valuep)
-     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
-
-
-
-
-
-extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-
-extern int posix_openpt (int __oflag) ;
-
-
-
-
-
-
-
-extern int grantpt (int __fd) throw ();
-
-
-
-extern int unlockpt (int __fd) throw ();
-
-
-
-
-extern char *ptsname (int __fd) throw () ;
-
-
-
-
-
-
-extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-extern int getpt (void);
-
-
-
-
-
-
-extern int getloadavg (double __loadavg[], int __nelem)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 921 "/usr/include/stdlib.h" 3 4
-# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
-# 922 "/usr/include/stdlib.h" 2 3 4
-# 934 "/usr/include/stdlib.h" 3 4
-}
-# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 2 3
-# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-extern "C++"
-{
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  using ::div_t;
-  using ::ldiv_t;
-
-  using ::abort;
-  using ::abs;
-  using ::atexit;
-
-
-  using ::at_quick_exit;
-
-
-  using ::atof;
-  using ::atoi;
-  using ::atol;
-  using ::bsearch;
-  using ::calloc;
-  using ::div;
-  using ::exit;
-  using ::free;
-  using ::getenv;
-  using ::labs;
-  using ::ldiv;
-  using ::malloc;
-
-  using ::mblen;
-  using ::mbstowcs;
-  using ::mbtowc;
-
-  using ::qsort;
-
-
-  using ::quick_exit;
-
-
-  using ::rand;
-  using ::realloc;
-  using ::srand;
-  using ::strtod;
-  using ::strtol;
-  using ::strtoul;
-  using ::system;
-
-  using ::wcstombs;
-  using ::wctomb;
-
-
-
-  inline long
-  abs(long __i) { return __builtin_labs(__i); }
-
-  inline ldiv_t
-  div(long __i, long __j) { return ldiv(__i, __j); }
-
-
-
-  inline long long
-  abs(long long __x) { return __builtin_llabs (__x); }
-# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-}
-# 215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  using ::lldiv_t;
-
-
-
-
-
-  using ::_Exit;
-
-
-
-  using ::llabs;
-
-  inline lldiv_t
-  div(long long __n, long long __d)
-  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
-
-  using ::lldiv;
-# 247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-  using ::atoll;
-  using ::strtoll;
-  using ::strtoull;
-
-  using ::strtof;
-  using ::strtold;
-
-
-}
-
-namespace std
-{
-
-  using ::__gnu_cxx::lldiv_t;
-
-  using ::__gnu_cxx::_Exit;
-
-  using ::__gnu_cxx::llabs;
-  using ::__gnu_cxx::div;
-  using ::__gnu_cxx::lldiv;
-
-  using ::__gnu_cxx::atoll;
-  using ::__gnu_cxx::strtof;
-  using ::__gnu_cxx::strtoll;
-  using ::__gnu_cxx::strtoull;
-  using ::__gnu_cxx::strtold;
-}
-
-
-
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
-
-
-# 1 "/usr/include/string.h" 1 3 4
-# 27 "/usr/include/string.h" 3 4
-extern "C" {
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 33 "/usr/include/string.h" 2 3 4
-# 42 "/usr/include/string.h" 3 4
-extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
-       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern void *memmove (void *__dest, const void *__src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-
-extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
-        int __c, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int memcmp (const void *__s1, const void *__s2, size_t __n)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-# 92 "/usr/include/string.h" 3 4
-extern void *memchr (const void *__s, int __c, size_t __n)
-      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-# 106 "/usr/include/string.h" 3 4
-extern void *rawmemchr (const void *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-# 117 "/usr/include/string.h" 3 4
-extern void *memrchr (const void *__s, int __c, size_t __n)
-      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern char *strncpy (char *__restrict __dest,
-        const char *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern char *strcat (char *__restrict __dest, const char *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern char *strncat (char *__restrict __dest, const char *__restrict __src,
-        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int strcmp (const char *__s1, const char *__s2)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-extern int strncmp (const char *__s1, const char *__s2, size_t __n)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int strcoll (const char *__s1, const char *__s2)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-extern size_t strxfrm (char *__restrict __dest,
-         const char *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (2)));
-# 162 "/usr/include/string.h" 3 4
-extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
-
-extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
-    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
-
-
-
-
-extern char *strdup (const char *__s)
-     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern char *strndup (const char *__string, size_t __n)
-     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
-# 231 "/usr/include/string.h" 3 4
-extern char *strchr (const char *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-# 258 "/usr/include/string.h" 3 4
-extern char *strrchr (const char *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-# 272 "/usr/include/string.h" 3 4
-extern char *strchrnul (const char *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern size_t strcspn (const char *__s, const char *__reject)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern size_t strspn (const char *__s, const char *__accept)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-# 310 "/usr/include/string.h" 3 4
-extern char *strpbrk (const char *__s, const char *__accept)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-# 337 "/usr/include/string.h" 3 4
-extern char *strstr (const char *__haystack, const char *__needle)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern char *strtok (char *__restrict __s, const char *__restrict __delim)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-extern char *__strtok_r (char *__restrict __s,
-    const char *__restrict __delim,
-    char **__restrict __save_ptr)
-     throw () __attribute__ ((__nonnull__ (2, 3)));
-
-extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
-         char **__restrict __save_ptr)
-     throw () __attribute__ ((__nonnull__ (2, 3)));
-# 368 "/usr/include/string.h" 3 4
-extern char *strcasestr (const char *__haystack, const char *__needle)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-
-
-extern void *memmem (const void *__haystack, size_t __haystacklen,
-       const void *__needle, size_t __needlelen)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
-
-
-
-extern void *__mempcpy (void *__restrict __dest,
-   const void *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-extern void *mempcpy (void *__restrict __dest,
-        const void *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-extern size_t strlen (const char *__s)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern size_t strnlen (const char *__string, size_t __maxlen)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern char *strerror (int __errnum) throw ();
-# 433 "/usr/include/string.h" 3 4
-extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
-     throw () __attribute__ ((__nonnull__ (2))) ;
-
-
-
-
-
-extern char *strerror_l (int __errnum, __locale_t __l) throw ();
-
-
-
-
-
-extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern void bcopy (const void *__src, void *__dest, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int bcmp (const void *__s1, const void *__s2, size_t __n)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-# 484 "/usr/include/string.h" 3 4
-extern char *index (const char *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-# 512 "/usr/include/string.h" 3 4
-extern char *rindex (const char *__s, int __c)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-extern int ffs (int __i) throw () __attribute__ ((__const__));
-
-
-
-
-extern int ffsl (long int __l) throw () __attribute__ ((__const__));
-__extension__ extern int ffsll (long long int __ll)
-     throw () __attribute__ ((__const__));
-
-
-
-extern int strcasecmp (const char *__s1, const char *__s2)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-extern int strcasecmp_l (const char *__s1, const char *__s2,
-    __locale_t __loc)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
-
-extern int strncasecmp_l (const char *__s1, const char *__s2,
-     size_t __n, __locale_t __loc)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
-
-
-
-
-
-extern char *strsep (char **__restrict __stringp,
-       const char *__restrict __delim)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern char *strsignal (int __sig) throw ();
-
-
-extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern char *__stpncpy (char *__restrict __dest,
-   const char *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-extern char *stpncpy (char *__restrict __dest,
-        const char *__restrict __src, size_t __n)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern int strverscmp (const char *__s1, const char *__s2)
-     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
-# 599 "/usr/include/string.h" 3 4
-extern char *basename (const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
-# 656 "/usr/include/string.h" 3 4
-}
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 2 3
-# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  using ::memchr;
-  using ::memcmp;
-  using ::memcpy;
-  using ::memmove;
-  using ::memset;
-  using ::strcat;
-  using ::strcmp;
-  using ::strcoll;
-  using ::strcpy;
-  using ::strcspn;
-  using ::strerror;
-  using ::strlen;
-  using ::strncat;
-  using ::strncmp;
-  using ::strncpy;
-  using ::strspn;
-  using ::strtok;
-  using ::strxfrm;
-  using ::strchr;
-  using ::strpbrk;
-  using ::strrchr;
-  using ::strstr;
-
-
-  inline void*
-  memchr(void* __s, int __c, size_t __n)
-  { return __builtin_memchr(__s, __c, __n); }
-
-  inline char*
-  strchr(char* __s, int __n)
-  { return __builtin_strchr(__s, __n); }
-
-  inline char*
-  strpbrk(char* __s1, const char* __s2)
-  { return __builtin_strpbrk(__s1, __s2); }
-
-  inline char*
-  strrchr(char* __s, int __n)
-  { return __builtin_strrchr(__s, __n); }
-
-  inline char*
-  strstr(char* __s1, const char* __s2)
-  { return __builtin_strstr(__s1, __s2); }
-
-
-
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h" 1
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h"
-namespace mozilla {
-
-struct fallible_t { };
-# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/fallible.h"
-extern const fallible_t fallible;
-
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc_abort.h"
-__attribute__((weak)) __attribute__((visibility("default")))
-
-  __attribute__((noreturn))
-
-  void mozalloc_abort(const char* const msg);
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 1 3
-# 37 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 3
-# 1 "/usr/include/limits.h" 1 3 4
-# 143 "/usr/include/limits.h" 3 4
-# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
-# 160 "/usr/include/bits/posix1_lim.h" 3 4
-# 1 "/usr/include/bits/local_lim.h" 1 3 4
-# 38 "/usr/include/bits/local_lim.h" 3 4
-# 1 "/usr/include/linux/limits.h" 1 3 4
-# 39 "/usr/include/bits/local_lim.h" 2 3 4
-# 161 "/usr/include/bits/posix1_lim.h" 2 3 4
-# 144 "/usr/include/limits.h" 2 3 4
-
-
-
-# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
-# 148 "/usr/include/limits.h" 2 3 4
-
-
-
-# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
-# 33 "/usr/include/bits/xopen_lim.h" 3 4
-# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
-# 34 "/usr/include/bits/xopen_lim.h" 2 3 4
-# 152 "/usr/include/limits.h" 2 3 4
-# 38 "/usr/local/bin/../lib/clang/3.9.1/include/limits.h" 2 3
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h" 2
-
-
-
-namespace mozilla {
-
-namespace tl {
-
-
-template<size_t Size, size_t... Rest>
-struct Min
-{
-  static constexpr size_t value =
-    Size < Min<Rest...>::value
-    ? Size
-    : Min<Rest...>::value;
-};
-
-template<size_t Size>
-struct Min<Size>
-{
-  static constexpr size_t value = Size;
-};
-
-template<size_t Size, size_t... Rest>
-struct Max
-{
-  static constexpr size_t value =
-    Size > Max<Rest...>::value
-    ? Size
-    : Max<Rest...>::value;
-};
-
-template<size_t Size>
-struct Max<Size>
-{
-  static constexpr size_t value = Size;
-};
-
-
-template<size_t I>
-struct FloorLog2
-{
-  static const size_t value = 1 + FloorLog2<I / 2>::value;
-};
-template<> struct FloorLog2<0> { };
-template<> struct FloorLog2<1> { static const size_t value = 0; };
-
-
-template<size_t I>
-struct CeilingLog2
-{
-  static const size_t value = FloorLog2<2 * I - 1>::value;
-};
-
-
-template<size_t I>
-struct RoundUpPow2
-{
-  static const size_t value = size_t(1) << CeilingLog2<I>::value;
-};
-template<>
-struct RoundUpPow2<0>
-{
-  static const size_t value = 1;
-};
-
-
-template<typename T>
-struct BitSize
-{
-  static const size_t value = sizeof(T) * 8;
-};
-
-
-
-
-
-template<size_t N>
-struct NBitMask
-{
-
-
-
-
-  static const size_t checkPrecondition =
-    0 / size_t(N < BitSize<size_t>::value);
-  static const size_t value = (size_t(1) << N) - 1 + checkPrecondition;
-};
-template<>
-struct NBitMask<BitSize<size_t>::value>
-{
-  static const size_t value = size_t(-1);
-};
-
-
-
-
-
-template<size_t N>
-struct MulOverflowMask
-{
-  static const size_t value =
-    ~NBitMask<BitSize<size_t>::value - CeilingLog2<N>::value>::value;
-};
-template<> struct MulOverflowMask<0> { };
-template<> struct MulOverflowMask<1> { static const size_t value = 0; };
-# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TemplateLib.h"
-template<bool...>
-struct And;
-
-template<>
-struct And<> : public TrueType { };
-
-template<bool C1, bool... Cn>
-struct And<C1, Cn...>
-  : public Conditional<C1, And<Cn...>, FalseType>::Type { };
-
-}
-
-}
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h" 2
-# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
-extern "C" {
-# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
-__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmalloc(size_t size)
-    __attribute__ ((malloc, warn_unused_result));
-
-__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xcalloc(size_t nmemb, size_t size)
-    __attribute__ ((malloc, warn_unused_result));
-
-__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xrealloc(void* ptr, size_t size)
-    __attribute__ ((malloc, warn_unused_result));
-
-__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrdup(const char* str)
-    __attribute__ ((malloc, warn_unused_result));
-
-__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_usable_size(void *ptr);
-
-__attribute__((weak)) __attribute__((visibility("default"))) size_t moz_malloc_size_of(const void *ptr);
-
-
-__attribute__((weak)) __attribute__((visibility("default"))) char* moz_xstrndup(const char* str, size_t strsize)
-    __attribute__ ((malloc, warn_unused_result));
-
-
-
-
-__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result))
-int moz_xposix_memalign(void **ptr, size_t alignment, size_t size);
-
-__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((warn_unused_result))
-int moz_posix_memalign(void **ptr, size_t alignment, size_t size);
-
-
-
-
-__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xmemalign(size_t boundary, size_t size)
-    __attribute__ ((malloc, warn_unused_result));
-
-
-
-
-__attribute__((weak)) __attribute__((visibility("default"))) void* moz_xvalloc(size_t size)
-    __attribute__ ((malloc, warn_unused_result));
-
-
-
-
-}
-# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
-__attribute__((always_inline)) inline
-
-void* operator new(size_t size) throw(std::bad_alloc)
-{
-    return moz_xmalloc(size);
-}
-
-                    __attribute__((always_inline)) inline
-void* operator new(size_t size, const std::nothrow_t&) throw()
-{
-    return malloc(size);
-}
-
-                    __attribute__((always_inline)) inline
-void* operator new[](size_t size) throw(std::bad_alloc)
-{
-    return moz_xmalloc(size);
-}
-
-                    __attribute__((always_inline)) inline
-void* operator new[](size_t size, const std::nothrow_t&) throw()
-{
-    return malloc(size);
-}
-
-                    __attribute__((always_inline)) inline
-void operator delete(void* ptr) throw()
-{
-    return free(ptr);
-}
-
-                    __attribute__((always_inline)) inline
-void operator delete(void* ptr, const std::nothrow_t&) throw()
-{
-    return free(ptr);
-}
-
-                    __attribute__((always_inline)) inline
-void operator delete[](void* ptr) throw()
-{
-    return free(ptr);
-}
-
-                    __attribute__((always_inline)) inline
-void operator delete[](void* ptr, const std::nothrow_t&) throw()
-{
-    return free(ptr);
-}
-# 259 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/mozalloc.h"
-__attribute__((always_inline)) inline
-void* operator new(size_t size, const mozilla::fallible_t&) throw()
-{
-    return malloc(size);
-}
-
-__attribute__((always_inline)) inline
-void* operator new[](size_t size, const mozilla::fallible_t&) throw()
-{
-    return malloc(size);
-}
-
-__attribute__((always_inline)) inline
-void operator delete(void* ptr, const mozilla::fallible_t&) throw()
-{
-    free(ptr);
-}
-
-__attribute__((always_inline)) inline
-void operator delete[](void* ptr, const mozilla::fallible_t&) throw()
-{
-    free(ptr);
-}
-
-
-
-
-
-
-
-class InfallibleAllocPolicy
-{
-public:
-    template <typename T>
-    T* maybe_pod_malloc(size_t aNumElems)
-    {
-        return pod_malloc<T>(aNumElems);
-    }
-
-    template <typename T>
-    T* maybe_pod_calloc(size_t aNumElems)
-    {
-        return pod_calloc<T>(aNumElems);
-    }
-
-    template <typename T>
-    T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
-    {
-        return pod_realloc<T>(aPtr, aOldSize, aNewSize);
-    }
-
-    template <typename T>
-    T* pod_malloc(size_t aNumElems)
-    {
-        if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
-            reportAllocOverflow();
-        }
-        return static_cast<T*>(moz_xmalloc(aNumElems * sizeof(T)));
-    }
-
-    template <typename T>
-    T* pod_calloc(size_t aNumElems)
-    {
-        return static_cast<T*>(moz_xcalloc(aNumElems, sizeof(T)));
-    }
-
-    template <typename T>
-    T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
-    {
-        if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
-            reportAllocOverflow();
-        }
-        return static_cast<T*>(moz_xrealloc(aPtr, aNewSize * sizeof(T)));
-    }
-
-    void free_(void* aPtr)
-    {
-        free(aPtr);
-    }
-
-    void reportAllocOverflow() const
-    {
-        mozalloc_abort("alloc overflow");
-    }
-
-    bool checkSimulatedOOM() const
-    {
-        return true;
-    }
-};
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h"
-typedef uintptr_t MozRefCountType;
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCountType.h"
-typedef uint32_t MozExternalRefCountType;
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
-# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 1
-# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
-enum class nsresult : uint32_t
-{
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1
-
-
-
-  NS_OK = 0,
-
-
-
-
-  NS_ERROR_BASE = 0xC1F30000,
-
-  NS_ERROR_NOT_INITIALIZED = NS_ERROR_BASE + 1,
-
-  NS_ERROR_ALREADY_INITIALIZED = NS_ERROR_BASE + 2,
-
-  NS_ERROR_NOT_IMPLEMENTED = 0x80004001,
-
-  NS_NOINTERFACE = 0x80004002,
-  NS_ERROR_NO_INTERFACE = NS_NOINTERFACE,
-
-  NS_ERROR_ABORT = 0x80004004,
-
-  NS_ERROR_FAILURE = 0x80004005,
-
-  NS_ERROR_UNEXPECTED = 0x8000ffff,
-
-  NS_ERROR_OUT_OF_MEMORY = 0x8007000e,
-
-  NS_ERROR_ILLEGAL_VALUE = 0x80070057,
-  NS_ERROR_INVALID_ARG = NS_ERROR_ILLEGAL_VALUE,
-  NS_ERROR_INVALID_POINTER = NS_ERROR_INVALID_ARG,
-  NS_ERROR_NULL_POINTER = NS_ERROR_INVALID_ARG,
-
-  NS_ERROR_NO_AGGREGATION = 0x80040110,
-
-  NS_ERROR_NOT_AVAILABLE = 0x80040111,
-
-  NS_ERROR_FACTORY_NOT_REGISTERED = 0x80040154,
-
-  NS_ERROR_FACTORY_REGISTER_AGAIN = 0x80040155,
-
-  NS_ERROR_FACTORY_NOT_LOADED = 0x800401f8,
-
-  NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = NS_ERROR_BASE + 0x101,
-
-  NS_ERROR_FACTORY_EXISTS = NS_ERROR_BASE + 0x100,
-
-
-
-
-
-
-
-  NS_ERROR_CANNOT_CONVERT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_OBJECT_IS_IMMUTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_ERROR_NOT_SAME_THREAD = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(4),
-
-
-  NS_ERROR_ILLEGAL_DURING_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(30),
-  NS_ERROR_SERVICE_NOT_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22),
-
-  NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_SUCCESS_INTERRUPTED_TRAVERSE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(2),
-
-  NS_ERROR_SERVICE_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(22),
-
-  NS_ERROR_SERVICE_IN_USE = ((uint32_t)(0) << 31) | ((uint32_t)(1 + 0x45) << 16) | (uint32_t)(23),
-# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_BASE_STREAM_CLOSED = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(2),
-
-  NS_BASE_STREAM_OSERROR = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_BASE_STREAM_ILLEGAL_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(4),
-
-  NS_BASE_STREAM_NO_CONVERTER = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(5),
-
-  NS_BASE_STREAM_BAD_CONVERSION = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(6),
-  NS_BASE_STREAM_WOULD_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(2 + 0x45) << 16) | (uint32_t)(7),
-# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(2),
-
-  NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_ERROR_GFX_PRINTER_STARTDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(4),
-
-  NS_ERROR_GFX_PRINTER_ENDDOC = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(5),
-
-  NS_ERROR_GFX_PRINTER_STARTPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(6),
-
-  NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(7),
-
-
-  NS_ERROR_GFX_CMAP_MALFORMED = ((uint32_t)(1) << 31) | ((uint32_t)(3 + 0x45) << 16) | (uint32_t)(51),
-# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_SUCCESS_EVENT_CONSUMED = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-
-  NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = ((uint32_t)(0) << 31) | ((uint32_t)(4 + 0x45) << 16) | (uint32_t)(2),
-# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_BINDING_SUCCEEDED = NS_OK,
-
-
-  NS_BINDING_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_BINDING_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(2),
-
-
-
-
-
-  NS_BINDING_REDIRECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3),
-
-
-
-
-
-  NS_BINDING_RETARGETED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4),
-
-
-
-
-
-  NS_ERROR_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10),
-
-
-
-  NS_ERROR_IN_PROGRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(15),
-
-
-
-
-  NS_ERROR_NO_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(17),
-
-  NS_ERROR_UNKNOWN_PROTOCOL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(18),
-
-
-  NS_ERROR_INVALID_CONTENT_ENCODING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27),
-
-
-
-  NS_ERROR_CORRUPTED_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(29),
-
-
-
-  NS_ERROR_INVALID_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(58),
-
-
-
-  NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(34),
-
-
-  NS_ERROR_ALREADY_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(73),
-
-
-
-
-  NS_ERROR_ALREADY_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11),
-
-  NS_ERROR_NOT_CONNECTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12),
-
-
-  NS_ERROR_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13),
-
-  NS_ERROR_NET_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(14),
-
-
-  NS_ERROR_OFFLINE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(16),
-
-
-
-  NS_ERROR_PORT_ACCESS_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(19),
-
-  NS_ERROR_NET_RESET = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(20),
-
-  NS_ERROR_NET_INTERRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(71),
-
-  NS_ERROR_PROXY_CONNECTION_REFUSED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(72),
-
-  NS_ERROR_NET_PARTIAL_TRANSFER = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(76),
-
-  NS_ERROR_NET_INADEQUATE_SECURITY = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(82),
-
-
-
-
-
-  NS_ERROR_NOT_RESUMABLE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(25),
-
-  NS_ERROR_REDIRECT_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(31),
-
-
-  NS_ERROR_ENTITY_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(32),
-
-
-
-  NS_ERROR_UNSAFE_CONTENT_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(74),
-
-
-  NS_ERROR_REMOTE_XUL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(75),
-
-  NS_ERROR_LOAD_SHOWED_ERRORPAGE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(77),
-
-
-  NS_ERROR_DOCSHELL_DYING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(78),
-
-
-
-
-  NS_ERROR_FTP_LOGIN = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(21),
-  NS_ERROR_FTP_CWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(22),
-  NS_ERROR_FTP_PASV = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(23),
-  NS_ERROR_FTP_PWD = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(24),
-  NS_ERROR_FTP_LIST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28),
-
-
-
-
-
-  NS_ERROR_UNKNOWN_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(30),
-
-
-  NS_ERROR_DNS_LOOKUP_QUEUE_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(33),
-
-
-
-  NS_ERROR_UNKNOWN_PROXY_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(42),
-
-
-
-
-
-  NS_ERROR_UNKNOWN_SOCKET_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(51),
-
-  NS_ERROR_SOCKET_CREATE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(52),
-
-  NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(53),
-
-  NS_ERROR_SOCKET_ADDRESS_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(54),
-
-
-  NS_ERROR_CACHE_KEY_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(61),
-  NS_ERROR_CACHE_DATA_IS_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(62),
-  NS_ERROR_CACHE_DATA_IS_NOT_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(63),
-  NS_ERROR_CACHE_WAIT_FOR_VALIDATION = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(64),
-  NS_ERROR_CACHE_ENTRY_DOOMED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(65),
-  NS_ERROR_CACHE_READ_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(66),
-  NS_ERROR_CACHE_WRITE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(67),
-  NS_ERROR_CACHE_IN_USE = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(68),
-
-
-  NS_ERROR_DOCUMENT_NOT_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(70),
-
-
-
-
-
-  NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(80),
-
-  NS_ERROR_HOST_IS_IP_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(81),
-
-
-
-
-
-
-
-  NS_SUCCESS_ADOPTED_DATA = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(90),
-
-
-  NS_NET_STATUS_BEGIN_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(27),
-  NS_NET_STATUS_END_FTP_TRANSACTION = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(28),
-
-
-
-
-  NS_SUCCESS_AUTH_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(40),
-
-
-
-
-  NS_NET_STATUS_READING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(8),
-  NS_NET_STATUS_WRITING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(9),
-
-
-  NS_NET_STATUS_RESOLVING_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(3),
-  NS_NET_STATUS_RESOLVED_HOST = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(11),
-  NS_NET_STATUS_CONNECTING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(7),
-  NS_NET_STATUS_CONNECTED_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(4),
-  NS_NET_STATUS_TLS_HANDSHAKE_STARTING = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(12),
-  NS_NET_STATUS_TLS_HANDSHAKE_ENDED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(13),
-  NS_NET_STATUS_SENDING_TO = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(5),
-  NS_NET_STATUS_WAITING_FOR = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(10),
-  NS_NET_STATUS_RECEIVING_FROM = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(6),
-
-
-
-  NS_ERROR_INTERCEPTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(100),
-
-
-
-  NS_ERROR_HSTS_PRIMING_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(6 + 0x45) << 16) | (uint32_t)(110),
-
-
-
-
-
-
-
-  NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1000),
-  NS_ERROR_PLUGIN_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1001),
-  NS_ERROR_PLUGIN_BLOCKLISTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1002),
-  NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1003),
-  NS_ERROR_PLUGIN_CLICKTOPLAY = ((uint32_t)(1) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1004),
-  NS_PLUGIN_INIT_PENDING = ((uint32_t)(0) << 31) | ((uint32_t)(7 + 0x45) << 16) | (uint32_t)(1005),
-# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_TABLELAYOUT_CELL_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(0),
-
-  NS_POSITION_BEFORE_TABLE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(3),
-
-
-  NS_STATE_PROPERTY_EXISTS = NS_OK,
-
-  NS_STATE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(8 + 0x45) << 16) | (uint32_t)(5),
-
-
-
-
-
-
-
-  NS_ERROR_HTMLPARSER_CONTINUE = NS_OK,
-
-  NS_ERROR_HTMLPARSER_EOF = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1000),
-  NS_ERROR_HTMLPARSER_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1001),
-  NS_ERROR_HTMLPARSER_CANTPROPAGATE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1002),
-  NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1003),
-  NS_ERROR_HTMLPARSER_BADFILENAME = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1004),
-  NS_ERROR_HTMLPARSER_BADURL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1005),
-  NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1006),
-  NS_ERROR_HTMLPARSER_INTERRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1007),
-  NS_ERROR_HTMLPARSER_BLOCK = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1008),
-  NS_ERROR_HTMLPARSER_BADTOKENIZER = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1009),
-  NS_ERROR_HTMLPARSER_BADATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1010),
-  NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1011),
-  NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1012),
-  NS_ERROR_HTMLPARSER_BADDTD = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1013),
-  NS_ERROR_HTMLPARSER_BADCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1014),
-  NS_ERROR_HTMLPARSER_STOPPARSING = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1015),
-  NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1016),
-  NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1017),
-  NS_ERROR_HTMLPARSER_FAKE_ENDTAG = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1018),
-  NS_ERROR_HTMLPARSER_INVALID_COMMENT = ((uint32_t)(1) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(1019),
-
-  NS_HTMLTOKENS_NOT_AN_ENTITY = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(2000),
-  NS_HTMLPARSER_VALID_META_CHARSET = ((uint32_t)(0) << 31) | ((uint32_t)(9 + 0x45) << 16) | (uint32_t)(3000),
-# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_RDF_ASSERTION_ACCEPTED = NS_OK,
-
-
-  NS_RDF_CURSOR_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(1),
-
-
-  NS_RDF_NO_VALUE = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(2),
-
-
-
-  NS_RDF_ASSERTION_REJECTED = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_RDF_STOP_VISIT = ((uint32_t)(0) << 31) | ((uint32_t)(10 + 0x45) << 16) | (uint32_t)(4),
-
-
-
-
-
-
-
-  NS_ERROR_UCONV_NOCONV = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_UDEC_ILLEGALINPUT = ((uint32_t)(1) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14),
-
-  NS_SUCCESS_USING_FALLBACK_LOCALE = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(2),
-  NS_OK_UDEC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(11),
-  NS_OK_UDEC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(12),
-  NS_OK_UDEC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(13),
-  NS_OK_UDEC_NOBOMFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(14),
-  NS_OK_UENC_EXACTLENGTH = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(33),
-  NS_OK_UENC_MOREOUTPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(34),
-  NS_ERROR_UENC_NOMAPPING = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(35),
-  NS_OK_UENC_MOREINPUT = ((uint32_t)(0) << 31) | ((uint32_t)(11 + 0x45) << 16) | (uint32_t)(36),
-
-
-  NS_EXACT_LENGTH = NS_OK_UDEC_EXACTLENGTH,
-  NS_PARTIAL_MORE_INPUT = NS_OK_UDEC_MOREINPUT,
-  NS_PARTIAL_MORE_OUTPUT = NS_OK_UDEC_MOREOUTPUT,
-  NS_ERROR_ILLEGAL_INPUT = NS_ERROR_UDEC_ILLEGALINPUT,
-# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_FILE_UNRECOGNIZED_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_FILE_EXECUTION_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_FILE_UNKNOWN_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_FILE_DESTINATION_NOT_DIR = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_FILE_COPY_OR_MOVE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_FILE_ALREADY_EXISTS = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_FILE_INVALID_PATH = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_FILE_DISK_FULL = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_FILE_CORRUPTED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_FILE_NOT_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_FILE_IS_DIRECTORY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(13),
-  NS_ERROR_FILE_IS_LOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(14),
-  NS_ERROR_FILE_TOO_BIG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(15),
-  NS_ERROR_FILE_NO_DEVICE_SPACE = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(16),
-  NS_ERROR_FILE_NAME_TOO_LONG = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(17),
-  NS_ERROR_FILE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(18),
-  NS_ERROR_FILE_READ_ONLY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(19),
-  NS_ERROR_FILE_DIR_NOT_EMPTY = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(20),
-  NS_ERROR_FILE_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(21),
-
-  NS_SUCCESS_FILE_DIRECTORY_EMPTY = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_SUCCESS_AGGREGATE_RESULT = ((uint32_t)(0) << 31) | ((uint32_t)(13 + 0x45) << 16) | (uint32_t)(2),
-# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INDEX_SIZE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_DOM_WRONG_DOCUMENT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_INVALID_CHARACTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_DOM_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_DOM_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_DOM_INVALID_STATE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_DOM_SYNTAX_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_DOM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(13),
-  NS_ERROR_DOM_NAMESPACE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(14),
-  NS_ERROR_DOM_INVALID_ACCESS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(15),
-  NS_ERROR_DOM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(17),
-  NS_ERROR_DOM_SECURITY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(18),
-  NS_ERROR_DOM_NETWORK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(19),
-  NS_ERROR_DOM_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(20),
-  NS_ERROR_DOM_URL_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(21),
-  NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(22),
-  NS_ERROR_DOM_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(23),
-  NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(24),
-  NS_ERROR_DOM_DATA_CLONE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(25),
-
-  NS_ERROR_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(26),
-  NS_ERROR_RANGE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(27),
-
-  NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(28),
-  NS_ERROR_DOM_INVALID_POINTER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(29),
-
-  NS_ERROR_DOM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(30),
-  NS_ERROR_DOM_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(31),
-  NS_ERROR_DOM_OPERATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(32),
-
-  NS_ERROR_DOM_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(33),
-
-  NS_ERROR_DOM_SECMAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1001),
-  NS_ERROR_DOM_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1002),
-  NS_ERROR_DOM_NOT_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1003),
-  NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1004),
-  NS_ERROR_DOM_NOT_NUMBER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1005),
-  NS_ERROR_DOM_NOT_BOOLEAN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1006),
-  NS_ERROR_DOM_NOT_FUNCTION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1007),
-  NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1008),
-  NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1009),
-  NS_ERROR_DOM_PROP_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1010),
-  NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1011),
-  NS_ERROR_DOM_BAD_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1012),
-  NS_ERROR_DOM_RETVAL_UNDEFINED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1013),
-  NS_ERROR_DOM_QUOTA_REACHED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1014),
-
-
-  NS_ERROR_UNCATCHABLE_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1015),
-
-  NS_ERROR_DOM_MALFORMED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1016),
-  NS_ERROR_DOM_INVALID_HEADER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1017),
-
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1018),
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1019),
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1020),
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1021),
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1022),
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1023),
-  NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1024),
-  NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = ((uint32_t)(1) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1025),
-
-
-
-
-
-  NS_SUCCESS_DOM_NO_OPERATION = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-
-
-
-  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(2),
-
-
-
-
-
-
-  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = ((uint32_t)(0) << 31) | ((uint32_t)(14 + 0x45) << 16) | (uint32_t)(3),
-
-
-
-
-
-
-
-  NS_IMAGELIB_SUCCESS_LOAD_FINISHED = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(0),
-  NS_IMAGELIB_CHANGING_OWNER = ((uint32_t)(0) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_IMAGELIB_ERROR_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(5),
-  NS_IMAGELIB_ERROR_NO_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(6),
-  NS_IMAGELIB_ERROR_NOT_FINISHED = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(7),
-  NS_IMAGELIB_ERROR_NO_ENCODER = ((uint32_t)(1) << 31) | ((uint32_t)(15 + 0x45) << 16) | (uint32_t)(9),
-
-
-
-
-
-
-
-  NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(1),
-  NS_SUCCESS_EDITOR_FOUND_TARGET = ((uint32_t)(0) << 31) | ((uint32_t)(17 + 0x45) << 16) | (uint32_t)(2),
-
-
-
-
-
-
-
-  NS_ERROR_XPC_NOT_ENOUGH_ARGS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_XPC_NEED_OUT_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_XPC_CANT_SET_OUT_VAL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_XPC_CANT_GET_METHOD_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_XPC_UNEXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_XPC_BAD_CONVERT_JS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_XPC_BAD_CONVERT_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(13),
-  NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(14),
-  NS_ERROR_XPC_CANT_WATCH_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(15),
-  NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(16),
-  NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(17),
-  NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(18),
-  NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(19),
-  NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(20),
-  NS_ERROR_XPC_CI_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(21),
-  NS_ERROR_XPC_GS_RETURNED_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(22),
-  NS_ERROR_XPC_BAD_CID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(23),
-  NS_ERROR_XPC_BAD_IID = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(24),
-  NS_ERROR_XPC_CANT_CREATE_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(25),
-  NS_ERROR_XPC_JS_THREW_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(26),
-  NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(27),
-  NS_ERROR_XPC_JS_THREW_JS_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(28),
-  NS_ERROR_XPC_JS_THREW_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(29),
-  NS_ERROR_XPC_JS_THREW_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(30),
-  NS_ERROR_XPC_JS_THREW_NUMBER = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(31),
-  NS_ERROR_XPC_JAVASCRIPT_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(32),
-  NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(33),
-  NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(34),
-  NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(35),
-  NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(36),
-  NS_ERROR_XPC_CANT_GET_ARRAY_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(37),
-  NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(38),
-  NS_ERROR_XPC_SECURITY_MANAGER_VETO = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(39),
-  NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(40),
-  NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(41),
-  NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(42),
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(43),
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(44),
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(45),
-  NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(46),
-  NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(47),
-  NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(48),
-  NS_ERROR_XPC_BAD_ID_STRING = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(49),
-  NS_ERROR_XPC_BAD_INITIALIZER_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(50),
-  NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(51),
-  NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(52),
-  NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(53),
-  NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = ((uint32_t)(1) << 31) | ((uint32_t)(18 + 0x45) << 16) | (uint32_t)(54),
-# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_LAUNCHED_CHILD_PROCESS = ((uint32_t)(1) << 31) | ((uint32_t)(19 + 0x45) << 16) | (uint32_t)(200),
-# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_CSP_FORM_ACTION_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(98),
-  NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(99),
-
-
-  NS_ERROR_SRI_CORRUPT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(200),
-  NS_ERROR_SRI_DISABLED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(201),
-  NS_ERROR_SRI_NOT_ELIGIBLE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(202),
-  NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(203),
-  NS_ERROR_SRI_IMPORT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(204),
-
-
-
-  NS_ERROR_CMS_VERIFY_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1024),
-  NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1025),
-  NS_ERROR_CMS_VERIFY_BAD_DIGEST = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1026),
-  NS_ERROR_CMS_VERIFY_NOCERT = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1028),
-  NS_ERROR_CMS_VERIFY_UNTRUSTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1029),
-  NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1031),
-  NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1032),
-  NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1033),
-  NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1034),
-  NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1035),
-  NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1036),
-  NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1037),
-  NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1038),
-  NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1039),
-  NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1040),
-  NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1056),
-  NS_ERROR_CMS_ENCRYPT_INCOMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(21 + 0x45) << 16) | (uint32_t)(1057),
-# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INVALID_EXPRESSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(51),
-  NS_ERROR_DOM_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(22 + 0x45) << 16) | (uint32_t)(52),
-
-
-
-
-
-
-
-  NS_ERROR_WONT_HANDLE_CONTENT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(1),
-
-
-  NS_ERROR_MALWARE_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(30),
-  NS_ERROR_PHISHING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(31),
-  NS_ERROR_TRACKING_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(34),
-  NS_ERROR_UNWANTED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(35),
-  NS_ERROR_BLOCKED_URI = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(37),
-
-
-  NS_ERROR_SAVE_LINK_AS_TIMEOUT = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(32),
-
-
-  NS_ERROR_PARSED_DATA_CACHED = ((uint32_t)(1) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(33),
-
-
-
-  NS_REFRESHURI_HEADER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(24 + 0x45) << 16) | (uint32_t)(2),
-# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_IMAGE_SRC_CHANGED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_IMAGE_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(5),
-
-  NS_ERROR_CONTENT_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(7),
-
-  NS_PROPTABLE_PROP_NOT_THERE = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(10),
-
-  NS_ERROR_XBL_BLOCKED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(15),
-
-  NS_ERROR_CONTENT_CRASHED = ((uint32_t)(1) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(16),
-
-
-  NS_HTML_STYLE_PROPERTY_NOT_THERE = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(2),
-  NS_CONTENT_BLOCKED = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(8),
-  NS_CONTENT_BLOCKED_SHOW_ALT = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(9),
-  NS_PROPTABLE_PROP_OVERWRITTEN = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(11),
-
-  NS_FINDBROADCASTER_NOT_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(12),
-  NS_FINDBROADCASTER_FOUND = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(13),
-  NS_FINDBROADCASTER_AWAIT_OVERLAYS = ((uint32_t)(0) << 31) | ((uint32_t)(25 + 0x45) << 16) | (uint32_t)(14),
-
-
-
-
-
-
-
-  NS_ERROR_XPATH_INVALID_ARG = NS_ERROR_INVALID_ARG,
-
-  NS_ERROR_XSLT_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_XPATH_PARSE_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_XSLT_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_XSLT_EXECUTION_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_XPATH_UNKNOWN_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_XSLT_BAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_XSLT_BAD_VALUE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_XSLT_NODESET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_XSLT_ABORTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_XSLT_NETWORK_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_XSLT_WRONG_MIME_TYPE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_XSLT_LOAD_RECURSION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(13),
-  NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(14),
-  NS_ERROR_XPATH_PAREN_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(15),
-  NS_ERROR_XPATH_INVALID_AXIS = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(16),
-  NS_ERROR_XPATH_NO_NODE_TYPE_TEST = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(17),
-  NS_ERROR_XPATH_BRACKET_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(18),
-  NS_ERROR_XPATH_INVALID_VAR_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(19),
-  NS_ERROR_XPATH_UNEXPECTED_END = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(20),
-  NS_ERROR_XPATH_OPERATOR_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(21),
-  NS_ERROR_XPATH_UNCLOSED_LITERAL = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(22),
-  NS_ERROR_XPATH_BAD_COLON = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(23),
-  NS_ERROR_XPATH_BAD_BANG = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(24),
-  NS_ERROR_XPATH_ILLEGAL_CHAR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(25),
-  NS_ERROR_XPATH_BINARY_EXPECTED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(26),
-  NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(27),
-  NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(28),
-  NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(29),
-  NS_ERROR_XSLT_BAD_NODE_NAME = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(30),
-  NS_ERROR_XSLT_VAR_ALREADY_SET = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(31),
-  NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = ((uint32_t)(1) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(32),
-
-  NS_XSLT_GET_NEW_HANDLER = ((uint32_t)(0) << 31) | ((uint32_t)(27 + 0x45) << 16) | (uint32_t)(1),
-# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_TRANSPORT_INIT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_ERROR_DUPLICATE_HANDLE = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(2),
-
-  NS_ERROR_BRIDGE_OPEN_PARENT = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_ERROR_BRIDGE_OPEN_CHILD = ((uint32_t)(1) << 31) | ((uint32_t)(28 + 0x45) << 16) | (uint32_t)(4),
-
-
-
-
-
-
-
-  NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(0),
-
-  NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = ((uint32_t)(1) << 31) | ((uint32_t)(29 + 0x45) << 16) | (uint32_t)(2),
-# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_STORAGE_BUSY = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_STORAGE_IOERR = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_STORAGE_CONSTRAINT = ((uint32_t)(1) << 31) | ((uint32_t)(30 + 0x45) << 16) | (uint32_t)(3),
-
-
-
-
-
-
-
-  NS_ERROR_DOM_FILE_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(0),
-  NS_ERROR_DOM_FILE_NOT_READABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_FILE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(32 + 0x45) << 16) | (uint32_t)(2),
-# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_INDEXEDDB_DATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(33 + 0x45) << 16) | (uint32_t)(1001),
-
-
-
-
-
-
-
-  NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(34 + 0x45) << 16) | (uint32_t)(6),
-
-
-
-
-
-
-  NS_ERROR_SIGNED_JAR_NOT_SIGNED = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_SIGNED_JAR_ENTRY_MISSING = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_SIGNED_JAR_ENTRY_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(35 + 0x45) << 16) | (uint32_t)(8),
-
-
-
-
-
-
-  NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(36 + 0x45) << 16) | (uint32_t)(6),
-
-
-
-
-
-
-  NS_ERROR_SIGNED_APP_MANIFEST_INVALID = ((uint32_t)(1) << 31) | ((uint32_t)(38 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-
-
-
-  NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(39 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-
-
-
-  NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_PUSH_DENIED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_DOM_PUSH_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(40 + 0x45) << 16) | (uint32_t)(6),
-
-
-
-
-
-
-
-  NS_ERROR_DOM_MEDIA_ABORT_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(3),
-
-
-  NS_ERROR_DOM_MEDIA_DECODE_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_DOM_MEDIA_FATAL_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_DOM_MEDIA_METADATA_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_DOM_MEDIA_END_OF_STREAM = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_DOM_MEDIA_CANCELED = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(11),
-  NS_ERROR_DOM_MEDIA_DEMUXER_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(12),
-  NS_ERROR_DOM_MEDIA_CDM_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(13),
-  NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(14),
-  NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(15),
-
-
-  NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = ((uint32_t)(1) << 31) | ((uint32_t)(41 + 0x45) << 16) | (uint32_t)(101),
-
-
-
-
-
-
-  NS_ERROR_UC_UPDATE_UNKNOWN = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(1),
-  NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_UC_UPDATE_INFINITE_LOOP = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(3),
-  NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(4),
-  NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(5),
-  NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(6),
-  NS_ERROR_UC_UPDATE_SHUTDOWNING = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(7),
-  NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(8),
-  NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(9),
-  NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(10),
-  NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = ((uint32_t)(1) << 31) | ((uint32_t)(42 + 0x45) << 16) | (uint32_t)(11),
-
-
-
-
-
-
-
-  NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(1),
-
-  NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(2),
-
-  NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(3),
-
-  NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(4),
-
-  NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = ((uint32_t)(1) << 31) | ((uint32_t)(43 + 0x45) << 16) | (uint32_t)(5),
-# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOWNLOAD_COMPLETE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-  NS_ERROR_DOWNLOAD_NOT_PARTIAL = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2),
-  NS_ERROR_UNORM_MOREOUTPUT = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(33),
-
-  NS_ERROR_DOCSHELL_REQUEST_REJECTED = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1001),
-
-
-
-
-  NS_ERROR_DOCUMENT_IS_PRINTMODE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(2001),
-
-  NS_SUCCESS_DONT_FIXUP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
-
-
-
-  NS_SUCCESS_RESTART_APP = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(1),
-  NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(3),
-  NS_SUCCESS_UNORM_NOTFOUND = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(17),
-
-
-
-
-  NS_ERROR_NOT_IN_TREE = ((uint32_t)(1) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(38),
-
-
-  NS_OK_NO_NAME_CLAUSE_HANDLED = ((uint32_t)(0) << 31) | ((uint32_t)(51 + 0x45) << 16) | (uint32_t)(34)
-# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2
-
-};
-
-
-
-
-
-const nsresult
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h" 1
-
-
-
-  NS_OK = nsresult::NS_OK,
-
-
-
-
-  NS_ERROR_BASE = nsresult::NS_ERROR_BASE,
-
-  NS_ERROR_NOT_INITIALIZED = nsresult::NS_ERROR_NOT_INITIALIZED,
-
-  NS_ERROR_ALREADY_INITIALIZED = nsresult::NS_ERROR_ALREADY_INITIALIZED,
-
-  NS_ERROR_NOT_IMPLEMENTED = nsresult::NS_ERROR_NOT_IMPLEMENTED,
-
-  NS_NOINTERFACE = nsresult::NS_NOINTERFACE,
-  NS_ERROR_NO_INTERFACE = nsresult::NS_ERROR_NO_INTERFACE,
-
-  NS_ERROR_ABORT = nsresult::NS_ERROR_ABORT,
-
-  NS_ERROR_FAILURE = nsresult::NS_ERROR_FAILURE,
-
-  NS_ERROR_UNEXPECTED = nsresult::NS_ERROR_UNEXPECTED,
-
-  NS_ERROR_OUT_OF_MEMORY = nsresult::NS_ERROR_OUT_OF_MEMORY,
-
-  NS_ERROR_ILLEGAL_VALUE = nsresult::NS_ERROR_ILLEGAL_VALUE,
-  NS_ERROR_INVALID_ARG = nsresult::NS_ERROR_INVALID_ARG,
-  NS_ERROR_INVALID_POINTER = nsresult::NS_ERROR_INVALID_POINTER,
-  NS_ERROR_NULL_POINTER = nsresult::NS_ERROR_NULL_POINTER,
-
-  NS_ERROR_NO_AGGREGATION = nsresult::NS_ERROR_NO_AGGREGATION,
-
-  NS_ERROR_NOT_AVAILABLE = nsresult::NS_ERROR_NOT_AVAILABLE,
-
-  NS_ERROR_FACTORY_NOT_REGISTERED = nsresult::NS_ERROR_FACTORY_NOT_REGISTERED,
-
-  NS_ERROR_FACTORY_REGISTER_AGAIN = nsresult::NS_ERROR_FACTORY_REGISTER_AGAIN,
-
-  NS_ERROR_FACTORY_NOT_LOADED = nsresult::NS_ERROR_FACTORY_NOT_LOADED,
-
-  NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT = nsresult::NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT,
-
-  NS_ERROR_FACTORY_EXISTS = nsresult::NS_ERROR_FACTORY_EXISTS,
-
-
-
-
-
-
-
-  NS_ERROR_CANNOT_CONVERT_DATA = nsresult::NS_ERROR_CANNOT_CONVERT_DATA,
-  NS_ERROR_OBJECT_IS_IMMUTABLE = nsresult::NS_ERROR_OBJECT_IS_IMMUTABLE,
-  NS_ERROR_LOSS_OF_SIGNIFICANT_DATA = nsresult::NS_ERROR_LOSS_OF_SIGNIFICANT_DATA,
-
-  NS_ERROR_NOT_SAME_THREAD = nsresult::NS_ERROR_NOT_SAME_THREAD,
-
-
-  NS_ERROR_ILLEGAL_DURING_SHUTDOWN = nsresult::NS_ERROR_ILLEGAL_DURING_SHUTDOWN,
-  NS_ERROR_SERVICE_NOT_AVAILABLE = nsresult::NS_ERROR_SERVICE_NOT_AVAILABLE,
-
-  NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA = nsresult::NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA,
-
-  NS_SUCCESS_INTERRUPTED_TRAVERSE = nsresult::NS_SUCCESS_INTERRUPTED_TRAVERSE,
-
-  NS_ERROR_SERVICE_NOT_FOUND = nsresult::NS_ERROR_SERVICE_NOT_FOUND,
-
-  NS_ERROR_SERVICE_IN_USE = nsresult::NS_ERROR_SERVICE_IN_USE,
-# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_BASE_STREAM_CLOSED = nsresult::NS_BASE_STREAM_CLOSED,
-
-  NS_BASE_STREAM_OSERROR = nsresult::NS_BASE_STREAM_OSERROR,
-
-  NS_BASE_STREAM_ILLEGAL_ARGS = nsresult::NS_BASE_STREAM_ILLEGAL_ARGS,
-
-  NS_BASE_STREAM_NO_CONVERTER = nsresult::NS_BASE_STREAM_NO_CONVERTER,
-
-  NS_BASE_STREAM_BAD_CONVERSION = nsresult::NS_BASE_STREAM_BAD_CONVERSION,
-  NS_BASE_STREAM_WOULD_BLOCK = nsresult::NS_BASE_STREAM_WOULD_BLOCK,
-# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE = nsresult::NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE,
-
-  NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND = nsresult::NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND,
-
-  NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE = nsresult::NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE,
-
-  NS_ERROR_GFX_PRINTER_STARTDOC = nsresult::NS_ERROR_GFX_PRINTER_STARTDOC,
-
-  NS_ERROR_GFX_PRINTER_ENDDOC = nsresult::NS_ERROR_GFX_PRINTER_ENDDOC,
-
-  NS_ERROR_GFX_PRINTER_STARTPAGE = nsresult::NS_ERROR_GFX_PRINTER_STARTPAGE,
-
-  NS_ERROR_GFX_PRINTER_DOC_IS_BUSY = nsresult::NS_ERROR_GFX_PRINTER_DOC_IS_BUSY,
-
-
-  NS_ERROR_GFX_CMAP_MALFORMED = nsresult::NS_ERROR_GFX_CMAP_MALFORMED,
-# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_SUCCESS_EVENT_CONSUMED = nsresult::NS_SUCCESS_EVENT_CONSUMED,
-
-
-
-
-  NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY = nsresult::NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY,
-# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_BINDING_SUCCEEDED = nsresult::NS_BINDING_SUCCEEDED,
-
-
-  NS_BINDING_FAILED = nsresult::NS_BINDING_FAILED,
-
-  NS_BINDING_ABORTED = nsresult::NS_BINDING_ABORTED,
-
-
-
-
-
-  NS_BINDING_REDIRECTED = nsresult::NS_BINDING_REDIRECTED,
-
-
-
-
-
-  NS_BINDING_RETARGETED = nsresult::NS_BINDING_RETARGETED,
-
-
-
-
-
-  NS_ERROR_MALFORMED_URI = nsresult::NS_ERROR_MALFORMED_URI,
-
-
-
-  NS_ERROR_IN_PROGRESS = nsresult::NS_ERROR_IN_PROGRESS,
-
-
-
-
-  NS_ERROR_NO_CONTENT = nsresult::NS_ERROR_NO_CONTENT,
-
-  NS_ERROR_UNKNOWN_PROTOCOL = nsresult::NS_ERROR_UNKNOWN_PROTOCOL,
-
-
-  NS_ERROR_INVALID_CONTENT_ENCODING = nsresult::NS_ERROR_INVALID_CONTENT_ENCODING,
-
-
-
-  NS_ERROR_CORRUPTED_CONTENT = nsresult::NS_ERROR_CORRUPTED_CONTENT,
-
-
-
-  NS_ERROR_INVALID_SIGNATURE = nsresult::NS_ERROR_INVALID_SIGNATURE,
-
-
-
-  NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY = nsresult::NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY,
-
-
-  NS_ERROR_ALREADY_OPENED = nsresult::NS_ERROR_ALREADY_OPENED,
-
-
-
-
-  NS_ERROR_ALREADY_CONNECTED = nsresult::NS_ERROR_ALREADY_CONNECTED,
-
-  NS_ERROR_NOT_CONNECTED = nsresult::NS_ERROR_NOT_CONNECTED,
-
-
-  NS_ERROR_CONNECTION_REFUSED = nsresult::NS_ERROR_CONNECTION_REFUSED,
-
-  NS_ERROR_NET_TIMEOUT = nsresult::NS_ERROR_NET_TIMEOUT,
-
-
-  NS_ERROR_OFFLINE = nsresult::NS_ERROR_OFFLINE,
-
-
-
-  NS_ERROR_PORT_ACCESS_NOT_ALLOWED = nsresult::NS_ERROR_PORT_ACCESS_NOT_ALLOWED,
-
-  NS_ERROR_NET_RESET = nsresult::NS_ERROR_NET_RESET,
-
-  NS_ERROR_NET_INTERRUPT = nsresult::NS_ERROR_NET_INTERRUPT,
-
-  NS_ERROR_PROXY_CONNECTION_REFUSED = nsresult::NS_ERROR_PROXY_CONNECTION_REFUSED,
-
-  NS_ERROR_NET_PARTIAL_TRANSFER = nsresult::NS_ERROR_NET_PARTIAL_TRANSFER,
-
-  NS_ERROR_NET_INADEQUATE_SECURITY = nsresult::NS_ERROR_NET_INADEQUATE_SECURITY,
-
-
-
-
-
-  NS_ERROR_NOT_RESUMABLE = nsresult::NS_ERROR_NOT_RESUMABLE,
-
-  NS_ERROR_REDIRECT_LOOP = nsresult::NS_ERROR_REDIRECT_LOOP,
-
-
-  NS_ERROR_ENTITY_CHANGED = nsresult::NS_ERROR_ENTITY_CHANGED,
-
-
-
-  NS_ERROR_UNSAFE_CONTENT_TYPE = nsresult::NS_ERROR_UNSAFE_CONTENT_TYPE,
-
-
-  NS_ERROR_REMOTE_XUL = nsresult::NS_ERROR_REMOTE_XUL,
-
-  NS_ERROR_LOAD_SHOWED_ERRORPAGE = nsresult::NS_ERROR_LOAD_SHOWED_ERRORPAGE,
-
-
-  NS_ERROR_DOCSHELL_DYING = nsresult::NS_ERROR_DOCSHELL_DYING,
-
-
-
-
-  NS_ERROR_FTP_LOGIN = nsresult::NS_ERROR_FTP_LOGIN,
-  NS_ERROR_FTP_CWD = nsresult::NS_ERROR_FTP_CWD,
-  NS_ERROR_FTP_PASV = nsresult::NS_ERROR_FTP_PASV,
-  NS_ERROR_FTP_PWD = nsresult::NS_ERROR_FTP_PWD,
-  NS_ERROR_FTP_LIST = nsresult::NS_ERROR_FTP_LIST,
-
-
-
-
-
-  NS_ERROR_UNKNOWN_HOST = nsresult::NS_ERROR_UNKNOWN_HOST,
-
-
-  NS_ERROR_DNS_LOOKUP_QUEUE_FULL = nsresult::NS_ERROR_DNS_LOOKUP_QUEUE_FULL,
-
-
-
-  NS_ERROR_UNKNOWN_PROXY_HOST = nsresult::NS_ERROR_UNKNOWN_PROXY_HOST,
-
-
-
-
-
-  NS_ERROR_UNKNOWN_SOCKET_TYPE = nsresult::NS_ERROR_UNKNOWN_SOCKET_TYPE,
-
-  NS_ERROR_SOCKET_CREATE_FAILED = nsresult::NS_ERROR_SOCKET_CREATE_FAILED,
-
-  NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED = nsresult::NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED,
-
-  NS_ERROR_SOCKET_ADDRESS_IN_USE = nsresult::NS_ERROR_SOCKET_ADDRESS_IN_USE,
-
-
-  NS_ERROR_CACHE_KEY_NOT_FOUND = nsresult::NS_ERROR_CACHE_KEY_NOT_FOUND,
-  NS_ERROR_CACHE_DATA_IS_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_STREAM,
-  NS_ERROR_CACHE_DATA_IS_NOT_STREAM = nsresult::NS_ERROR_CACHE_DATA_IS_NOT_STREAM,
-  NS_ERROR_CACHE_WAIT_FOR_VALIDATION = nsresult::NS_ERROR_CACHE_WAIT_FOR_VALIDATION,
-  NS_ERROR_CACHE_ENTRY_DOOMED = nsresult::NS_ERROR_CACHE_ENTRY_DOOMED,
-  NS_ERROR_CACHE_READ_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_READ_ACCESS_DENIED,
-  NS_ERROR_CACHE_WRITE_ACCESS_DENIED = nsresult::NS_ERROR_CACHE_WRITE_ACCESS_DENIED,
-  NS_ERROR_CACHE_IN_USE = nsresult::NS_ERROR_CACHE_IN_USE,
-
-
-  NS_ERROR_DOCUMENT_NOT_CACHED = nsresult::NS_ERROR_DOCUMENT_NOT_CACHED,
-
-
-
-
-
-  NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS = nsresult::NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS,
-
-  NS_ERROR_HOST_IS_IP_ADDRESS = nsresult::NS_ERROR_HOST_IS_IP_ADDRESS,
-
-
-
-
-
-
-
-  NS_SUCCESS_ADOPTED_DATA = nsresult::NS_SUCCESS_ADOPTED_DATA,
-
-
-  NS_NET_STATUS_BEGIN_FTP_TRANSACTION = nsresult::NS_NET_STATUS_BEGIN_FTP_TRANSACTION,
-  NS_NET_STATUS_END_FTP_TRANSACTION = nsresult::NS_NET_STATUS_END_FTP_TRANSACTION,
-
-
-
-
-  NS_SUCCESS_AUTH_FINISHED = nsresult::NS_SUCCESS_AUTH_FINISHED,
-
-
-
-
-  NS_NET_STATUS_READING = nsresult::NS_NET_STATUS_READING,
-  NS_NET_STATUS_WRITING = nsresult::NS_NET_STATUS_WRITING,
-
-
-  NS_NET_STATUS_RESOLVING_HOST = nsresult::NS_NET_STATUS_RESOLVING_HOST,
-  NS_NET_STATUS_RESOLVED_HOST = nsresult::NS_NET_STATUS_RESOLVED_HOST,
-  NS_NET_STATUS_CONNECTING_TO = nsresult::NS_NET_STATUS_CONNECTING_TO,
-  NS_NET_STATUS_CONNECTED_TO = nsresult::NS_NET_STATUS_CONNECTED_TO,
-  NS_NET_STATUS_TLS_HANDSHAKE_STARTING = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_STARTING,
-  NS_NET_STATUS_TLS_HANDSHAKE_ENDED = nsresult::NS_NET_STATUS_TLS_HANDSHAKE_ENDED,
-  NS_NET_STATUS_SENDING_TO = nsresult::NS_NET_STATUS_SENDING_TO,
-  NS_NET_STATUS_WAITING_FOR = nsresult::NS_NET_STATUS_WAITING_FOR,
-  NS_NET_STATUS_RECEIVING_FROM = nsresult::NS_NET_STATUS_RECEIVING_FROM,
-
-
-
-  NS_ERROR_INTERCEPTION_FAILED = nsresult::NS_ERROR_INTERCEPTION_FAILED,
-
-
-
-  NS_ERROR_HSTS_PRIMING_TIMEOUT = nsresult::NS_ERROR_HSTS_PRIMING_TIMEOUT,
-
-
-
-
-
-
-
-  NS_ERROR_PLUGINS_PLUGINSNOTCHANGED = nsresult::NS_ERROR_PLUGINS_PLUGINSNOTCHANGED,
-  NS_ERROR_PLUGIN_DISABLED = nsresult::NS_ERROR_PLUGIN_DISABLED,
-  NS_ERROR_PLUGIN_BLOCKLISTED = nsresult::NS_ERROR_PLUGIN_BLOCKLISTED,
-  NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED = nsresult::NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED,
-  NS_ERROR_PLUGIN_CLICKTOPLAY = nsresult::NS_ERROR_PLUGIN_CLICKTOPLAY,
-  NS_PLUGIN_INIT_PENDING = nsresult::NS_PLUGIN_INIT_PENDING,
-# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_TABLELAYOUT_CELL_NOT_FOUND = nsresult::NS_TABLELAYOUT_CELL_NOT_FOUND,
-
-  NS_POSITION_BEFORE_TABLE = nsresult::NS_POSITION_BEFORE_TABLE,
-
-
-  NS_STATE_PROPERTY_EXISTS = nsresult::NS_STATE_PROPERTY_EXISTS,
-
-  NS_STATE_PROPERTY_NOT_THERE = nsresult::NS_STATE_PROPERTY_NOT_THERE,
-
-
-
-
-
-
-
-  NS_ERROR_HTMLPARSER_CONTINUE = nsresult::NS_ERROR_HTMLPARSER_CONTINUE,
-
-  NS_ERROR_HTMLPARSER_EOF = nsresult::NS_ERROR_HTMLPARSER_EOF,
-  NS_ERROR_HTMLPARSER_UNKNOWN = nsresult::NS_ERROR_HTMLPARSER_UNKNOWN,
-  NS_ERROR_HTMLPARSER_CANTPROPAGATE = nsresult::NS_ERROR_HTMLPARSER_CANTPROPAGATE,
-  NS_ERROR_HTMLPARSER_CONTEXTMISMATCH = nsresult::NS_ERROR_HTMLPARSER_CONTEXTMISMATCH,
-  NS_ERROR_HTMLPARSER_BADFILENAME = nsresult::NS_ERROR_HTMLPARSER_BADFILENAME,
-  NS_ERROR_HTMLPARSER_BADURL = nsresult::NS_ERROR_HTMLPARSER_BADURL,
-  NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT = nsresult::NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT,
-  NS_ERROR_HTMLPARSER_INTERRUPTED = nsresult::NS_ERROR_HTMLPARSER_INTERRUPTED,
-  NS_ERROR_HTMLPARSER_BLOCK = nsresult::NS_ERROR_HTMLPARSER_BLOCK,
-  NS_ERROR_HTMLPARSER_BADTOKENIZER = nsresult::NS_ERROR_HTMLPARSER_BADTOKENIZER,
-  NS_ERROR_HTMLPARSER_BADATTRIBUTE = nsresult::NS_ERROR_HTMLPARSER_BADATTRIBUTE,
-  NS_ERROR_HTMLPARSER_UNRESOLVEDDTD = nsresult::NS_ERROR_HTMLPARSER_UNRESOLVEDDTD,
-  NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT = nsresult::NS_ERROR_HTMLPARSER_MISPLACEDTABLECONTENT,
-  NS_ERROR_HTMLPARSER_BADDTD = nsresult::NS_ERROR_HTMLPARSER_BADDTD,
-  NS_ERROR_HTMLPARSER_BADCONTEXT = nsresult::NS_ERROR_HTMLPARSER_BADCONTEXT,
-  NS_ERROR_HTMLPARSER_STOPPARSING = nsresult::NS_ERROR_HTMLPARSER_STOPPARSING,
-  NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL = nsresult::NS_ERROR_HTMLPARSER_UNTERMINATEDSTRINGLITERAL,
-  NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP = nsresult::NS_ERROR_HTMLPARSER_HIERARCHYTOODEEP,
-  NS_ERROR_HTMLPARSER_FAKE_ENDTAG = nsresult::NS_ERROR_HTMLPARSER_FAKE_ENDTAG,
-  NS_ERROR_HTMLPARSER_INVALID_COMMENT = nsresult::NS_ERROR_HTMLPARSER_INVALID_COMMENT,
-
-  NS_HTMLTOKENS_NOT_AN_ENTITY = nsresult::NS_HTMLTOKENS_NOT_AN_ENTITY,
-  NS_HTMLPARSER_VALID_META_CHARSET = nsresult::NS_HTMLPARSER_VALID_META_CHARSET,
-# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_RDF_ASSERTION_ACCEPTED = nsresult::NS_RDF_ASSERTION_ACCEPTED,
-
-
-  NS_RDF_CURSOR_EMPTY = nsresult::NS_RDF_CURSOR_EMPTY,
-
-
-  NS_RDF_NO_VALUE = nsresult::NS_RDF_NO_VALUE,
-
-
-
-  NS_RDF_ASSERTION_REJECTED = nsresult::NS_RDF_ASSERTION_REJECTED,
-
-  NS_RDF_STOP_VISIT = nsresult::NS_RDF_STOP_VISIT,
-
-
-
-
-
-
-
-  NS_ERROR_UCONV_NOCONV = nsresult::NS_ERROR_UCONV_NOCONV,
-  NS_ERROR_UDEC_ILLEGALINPUT = nsresult::NS_ERROR_UDEC_ILLEGALINPUT,
-
-  NS_SUCCESS_USING_FALLBACK_LOCALE = nsresult::NS_SUCCESS_USING_FALLBACK_LOCALE,
-  NS_OK_UDEC_EXACTLENGTH = nsresult::NS_OK_UDEC_EXACTLENGTH,
-  NS_OK_UDEC_MOREINPUT = nsresult::NS_OK_UDEC_MOREINPUT,
-  NS_OK_UDEC_MOREOUTPUT = nsresult::NS_OK_UDEC_MOREOUTPUT,
-  NS_OK_UDEC_NOBOMFOUND = nsresult::NS_OK_UDEC_NOBOMFOUND,
-  NS_OK_UENC_EXACTLENGTH = nsresult::NS_OK_UENC_EXACTLENGTH,
-  NS_OK_UENC_MOREOUTPUT = nsresult::NS_OK_UENC_MOREOUTPUT,
-  NS_ERROR_UENC_NOMAPPING = nsresult::NS_ERROR_UENC_NOMAPPING,
-  NS_OK_UENC_MOREINPUT = nsresult::NS_OK_UENC_MOREINPUT,
-
-
-  NS_EXACT_LENGTH = nsresult::NS_EXACT_LENGTH,
-  NS_PARTIAL_MORE_INPUT = nsresult::NS_PARTIAL_MORE_INPUT,
-  NS_PARTIAL_MORE_OUTPUT = nsresult::NS_PARTIAL_MORE_OUTPUT,
-  NS_ERROR_ILLEGAL_INPUT = nsresult::NS_ERROR_ILLEGAL_INPUT,
-# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_FILE_UNRECOGNIZED_PATH = nsresult::NS_ERROR_FILE_UNRECOGNIZED_PATH,
-  NS_ERROR_FILE_UNRESOLVABLE_SYMLINK = nsresult::NS_ERROR_FILE_UNRESOLVABLE_SYMLINK,
-  NS_ERROR_FILE_EXECUTION_FAILED = nsresult::NS_ERROR_FILE_EXECUTION_FAILED,
-  NS_ERROR_FILE_UNKNOWN_TYPE = nsresult::NS_ERROR_FILE_UNKNOWN_TYPE,
-  NS_ERROR_FILE_DESTINATION_NOT_DIR = nsresult::NS_ERROR_FILE_DESTINATION_NOT_DIR,
-  NS_ERROR_FILE_TARGET_DOES_NOT_EXIST = nsresult::NS_ERROR_FILE_TARGET_DOES_NOT_EXIST,
-  NS_ERROR_FILE_COPY_OR_MOVE_FAILED = nsresult::NS_ERROR_FILE_COPY_OR_MOVE_FAILED,
-  NS_ERROR_FILE_ALREADY_EXISTS = nsresult::NS_ERROR_FILE_ALREADY_EXISTS,
-  NS_ERROR_FILE_INVALID_PATH = nsresult::NS_ERROR_FILE_INVALID_PATH,
-  NS_ERROR_FILE_DISK_FULL = nsresult::NS_ERROR_FILE_DISK_FULL,
-  NS_ERROR_FILE_CORRUPTED = nsresult::NS_ERROR_FILE_CORRUPTED,
-  NS_ERROR_FILE_NOT_DIRECTORY = nsresult::NS_ERROR_FILE_NOT_DIRECTORY,
-  NS_ERROR_FILE_IS_DIRECTORY = nsresult::NS_ERROR_FILE_IS_DIRECTORY,
-  NS_ERROR_FILE_IS_LOCKED = nsresult::NS_ERROR_FILE_IS_LOCKED,
-  NS_ERROR_FILE_TOO_BIG = nsresult::NS_ERROR_FILE_TOO_BIG,
-  NS_ERROR_FILE_NO_DEVICE_SPACE = nsresult::NS_ERROR_FILE_NO_DEVICE_SPACE,
-  NS_ERROR_FILE_NAME_TOO_LONG = nsresult::NS_ERROR_FILE_NAME_TOO_LONG,
-  NS_ERROR_FILE_NOT_FOUND = nsresult::NS_ERROR_FILE_NOT_FOUND,
-  NS_ERROR_FILE_READ_ONLY = nsresult::NS_ERROR_FILE_READ_ONLY,
-  NS_ERROR_FILE_DIR_NOT_EMPTY = nsresult::NS_ERROR_FILE_DIR_NOT_EMPTY,
-  NS_ERROR_FILE_ACCESS_DENIED = nsresult::NS_ERROR_FILE_ACCESS_DENIED,
-
-  NS_SUCCESS_FILE_DIRECTORY_EMPTY = nsresult::NS_SUCCESS_FILE_DIRECTORY_EMPTY,
-
-  NS_SUCCESS_AGGREGATE_RESULT = nsresult::NS_SUCCESS_AGGREGATE_RESULT,
-# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INDEX_SIZE_ERR = nsresult::NS_ERROR_DOM_INDEX_SIZE_ERR,
-  NS_ERROR_DOM_HIERARCHY_REQUEST_ERR = nsresult::NS_ERROR_DOM_HIERARCHY_REQUEST_ERR,
-  NS_ERROR_DOM_WRONG_DOCUMENT_ERR = nsresult::NS_ERROR_DOM_WRONG_DOCUMENT_ERR,
-  NS_ERROR_DOM_INVALID_CHARACTER_ERR = nsresult::NS_ERROR_DOM_INVALID_CHARACTER_ERR,
-  NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR,
-  NS_ERROR_DOM_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_NOT_FOUND_ERR,
-  NS_ERROR_DOM_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_NOT_SUPPORTED_ERR,
-  NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR = nsresult::NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR,
-  NS_ERROR_DOM_INVALID_STATE_ERR = nsresult::NS_ERROR_DOM_INVALID_STATE_ERR,
-  NS_ERROR_DOM_SYNTAX_ERR = nsresult::NS_ERROR_DOM_SYNTAX_ERR,
-  NS_ERROR_DOM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_INVALID_MODIFICATION_ERR,
-  NS_ERROR_DOM_NAMESPACE_ERR = nsresult::NS_ERROR_DOM_NAMESPACE_ERR,
-  NS_ERROR_DOM_INVALID_ACCESS_ERR = nsresult::NS_ERROR_DOM_INVALID_ACCESS_ERR,
-  NS_ERROR_DOM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_TYPE_MISMATCH_ERR,
-  NS_ERROR_DOM_SECURITY_ERR = nsresult::NS_ERROR_DOM_SECURITY_ERR,
-  NS_ERROR_DOM_NETWORK_ERR = nsresult::NS_ERROR_DOM_NETWORK_ERR,
-  NS_ERROR_DOM_ABORT_ERR = nsresult::NS_ERROR_DOM_ABORT_ERR,
-  NS_ERROR_DOM_URL_MISMATCH_ERR = nsresult::NS_ERROR_DOM_URL_MISMATCH_ERR,
-  NS_ERROR_DOM_QUOTA_EXCEEDED_ERR = nsresult::NS_ERROR_DOM_QUOTA_EXCEEDED_ERR,
-  NS_ERROR_DOM_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_TIMEOUT_ERR,
-  NS_ERROR_DOM_INVALID_NODE_TYPE_ERR = nsresult::NS_ERROR_DOM_INVALID_NODE_TYPE_ERR,
-  NS_ERROR_DOM_DATA_CLONE_ERR = nsresult::NS_ERROR_DOM_DATA_CLONE_ERR,
-
-  NS_ERROR_TYPE_ERR = nsresult::NS_ERROR_TYPE_ERR,
-  NS_ERROR_RANGE_ERR = nsresult::NS_ERROR_RANGE_ERR,
-
-  NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR,
-  NS_ERROR_DOM_INVALID_POINTER_ERR = nsresult::NS_ERROR_DOM_INVALID_POINTER_ERR,
-
-  NS_ERROR_DOM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_UNKNOWN_ERR,
-  NS_ERROR_DOM_DATA_ERR = nsresult::NS_ERROR_DOM_DATA_ERR,
-  NS_ERROR_DOM_OPERATION_ERR = nsresult::NS_ERROR_DOM_OPERATION_ERR,
-
-  NS_ERROR_DOM_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_NOT_ALLOWED_ERR,
-
-  NS_ERROR_DOM_SECMAN_ERR = nsresult::NS_ERROR_DOM_SECMAN_ERR,
-  NS_ERROR_DOM_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_WRONG_TYPE_ERR,
-  NS_ERROR_DOM_NOT_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_OBJECT_ERR,
-  NS_ERROR_DOM_NOT_XPC_OBJECT_ERR = nsresult::NS_ERROR_DOM_NOT_XPC_OBJECT_ERR,
-  NS_ERROR_DOM_NOT_NUMBER_ERR = nsresult::NS_ERROR_DOM_NOT_NUMBER_ERR,
-  NS_ERROR_DOM_NOT_BOOLEAN_ERR = nsresult::NS_ERROR_DOM_NOT_BOOLEAN_ERR,
-  NS_ERROR_DOM_NOT_FUNCTION_ERR = nsresult::NS_ERROR_DOM_NOT_FUNCTION_ERR,
-  NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR = nsresult::NS_ERROR_DOM_TOO_FEW_PARAMETERS_ERR,
-  NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN = nsresult::NS_ERROR_DOM_BAD_DOCUMENT_DOMAIN,
-  NS_ERROR_DOM_PROP_ACCESS_DENIED = nsresult::NS_ERROR_DOM_PROP_ACCESS_DENIED,
-  NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED = nsresult::NS_ERROR_DOM_XPCONNECT_ACCESS_DENIED,
-  NS_ERROR_DOM_BAD_URI = nsresult::NS_ERROR_DOM_BAD_URI,
-  NS_ERROR_DOM_RETVAL_UNDEFINED = nsresult::NS_ERROR_DOM_RETVAL_UNDEFINED,
-  NS_ERROR_DOM_QUOTA_REACHED = nsresult::NS_ERROR_DOM_QUOTA_REACHED,
-
-
-  NS_ERROR_UNCATCHABLE_EXCEPTION = nsresult::NS_ERROR_UNCATCHABLE_EXCEPTION,
-
-  NS_ERROR_DOM_MALFORMED_URI = nsresult::NS_ERROR_DOM_MALFORMED_URI,
-  NS_ERROR_DOM_INVALID_HEADER_NAME = nsresult::NS_ERROR_DOM_INVALID_HEADER_NAME,
-
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_INVALID_CONTEXT,
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_BE_OPENED,
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_SENDING,
-  NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_MUST_NOT_BE_LOADING_OR_DONE,
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSEXML,
-  NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_HAS_WRONG_RESPONSETYPE_FOR_RESPONSETEXT,
-  NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_STATE_XHR_CHUNKED_RESPONSETYPES_UNSUPPORTED_FOR_SYNC,
-  NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC = nsresult::NS_ERROR_DOM_INVALID_ACCESS_XHR_TIMEOUT_AND_RESPONSETYPE_UNSUPPORTED_FOR_SYNC,
-
-
-
-
-
-  NS_SUCCESS_DOM_NO_OPERATION = nsresult::NS_SUCCESS_DOM_NO_OPERATION,
-
-
-
-
-
-
-  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW,
-
-
-
-
-
-
-  NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE = nsresult::NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE,
-
-
-
-
-
-
-
-  NS_IMAGELIB_SUCCESS_LOAD_FINISHED = nsresult::NS_IMAGELIB_SUCCESS_LOAD_FINISHED,
-  NS_IMAGELIB_CHANGING_OWNER = nsresult::NS_IMAGELIB_CHANGING_OWNER,
-
-  NS_IMAGELIB_ERROR_FAILURE = nsresult::NS_IMAGELIB_ERROR_FAILURE,
-  NS_IMAGELIB_ERROR_NO_DECODER = nsresult::NS_IMAGELIB_ERROR_NO_DECODER,
-  NS_IMAGELIB_ERROR_NOT_FINISHED = nsresult::NS_IMAGELIB_ERROR_NOT_FINISHED,
-  NS_IMAGELIB_ERROR_NO_ENCODER = nsresult::NS_IMAGELIB_ERROR_NO_ENCODER,
-
-
-
-
-
-
-
-  NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND = nsresult::NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND,
-  NS_SUCCESS_EDITOR_FOUND_TARGET = nsresult::NS_SUCCESS_EDITOR_FOUND_TARGET,
-
-
-
-
-
-
-
-  NS_ERROR_XPC_NOT_ENOUGH_ARGS = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ARGS,
-  NS_ERROR_XPC_NEED_OUT_OBJECT = nsresult::NS_ERROR_XPC_NEED_OUT_OBJECT,
-  NS_ERROR_XPC_CANT_SET_OUT_VAL = nsresult::NS_ERROR_XPC_CANT_SET_OUT_VAL,
-  NS_ERROR_XPC_NATIVE_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_NATIVE_RETURNED_FAILURE,
-  NS_ERROR_XPC_CANT_GET_INTERFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_INTERFACE_INFO,
-  NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO = nsresult::NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO,
-  NS_ERROR_XPC_CANT_GET_METHOD_INFO = nsresult::NS_ERROR_XPC_CANT_GET_METHOD_INFO,
-  NS_ERROR_XPC_UNEXPECTED = nsresult::NS_ERROR_XPC_UNEXPECTED,
-  NS_ERROR_XPC_BAD_CONVERT_JS = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS,
-  NS_ERROR_XPC_BAD_CONVERT_NATIVE = nsresult::NS_ERROR_XPC_BAD_CONVERT_NATIVE,
-  NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF,
-  NS_ERROR_XPC_BAD_OP_ON_WN_PROTO = nsresult::NS_ERROR_XPC_BAD_OP_ON_WN_PROTO,
-  NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN = nsresult::NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN,
-  NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN,
-  NS_ERROR_XPC_CANT_WATCH_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_WATCH_WN_STATIC,
-  NS_ERROR_XPC_CANT_EXPORT_WN_STATIC = nsresult::NS_ERROR_XPC_CANT_EXPORT_WN_STATIC,
-  NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED,
-  NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED = nsresult::NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED,
-  NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE,
-  NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE = nsresult::NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE,
-  NS_ERROR_XPC_CI_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_CI_RETURNED_FAILURE,
-  NS_ERROR_XPC_GS_RETURNED_FAILURE = nsresult::NS_ERROR_XPC_GS_RETURNED_FAILURE,
-  NS_ERROR_XPC_BAD_CID = nsresult::NS_ERROR_XPC_BAD_CID,
-  NS_ERROR_XPC_BAD_IID = nsresult::NS_ERROR_XPC_BAD_IID,
-  NS_ERROR_XPC_CANT_CREATE_WN = nsresult::NS_ERROR_XPC_CANT_CREATE_WN,
-  NS_ERROR_XPC_JS_THREW_EXCEPTION = nsresult::NS_ERROR_XPC_JS_THREW_EXCEPTION,
-  NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT,
-  NS_ERROR_XPC_JS_THREW_JS_OBJECT = nsresult::NS_ERROR_XPC_JS_THREW_JS_OBJECT,
-  NS_ERROR_XPC_JS_THREW_NULL = nsresult::NS_ERROR_XPC_JS_THREW_NULL,
-  NS_ERROR_XPC_JS_THREW_STRING = nsresult::NS_ERROR_XPC_JS_THREW_STRING,
-  NS_ERROR_XPC_JS_THREW_NUMBER = nsresult::NS_ERROR_XPC_JS_THREW_NUMBER,
-  NS_ERROR_XPC_JAVASCRIPT_ERROR = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR,
-  NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS = nsresult::NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS,
-  NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY,
-  NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY = nsresult::NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY,
-  NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY = nsresult::NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY,
-  NS_ERROR_XPC_CANT_GET_ARRAY_INFO = nsresult::NS_ERROR_XPC_CANT_GET_ARRAY_INFO,
-  NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING = nsresult::NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING,
-  NS_ERROR_XPC_SECURITY_MANAGER_VETO = nsresult::NS_ERROR_XPC_SECURITY_MANAGER_VETO,
-  NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE = nsresult::NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE,
-  NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS = nsresult::NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS,
-  NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT = nsresult::NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT,
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT,
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE,
-  NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD = nsresult::NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD,
-  NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE = nsresult::NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE,
-  NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED = nsresult::NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED,
-  NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED = nsresult::NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED,
-  NS_ERROR_XPC_BAD_ID_STRING = nsresult::NS_ERROR_XPC_BAD_ID_STRING,
-  NS_ERROR_XPC_BAD_INITIALIZER_NAME = nsresult::NS_ERROR_XPC_BAD_INITIALIZER_NAME,
-  NS_ERROR_XPC_HAS_BEEN_SHUTDOWN = nsresult::NS_ERROR_XPC_HAS_BEEN_SHUTDOWN,
-  NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN = nsresult::NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN,
-  NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL = nsresult::NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL,
-  NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE = nsresult::NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE,
-# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_LAUNCHED_CHILD_PROCESS = nsresult::NS_ERROR_LAUNCHED_CHILD_PROCESS,
-# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_CSP_FORM_ACTION_VIOLATION = nsresult::NS_ERROR_CSP_FORM_ACTION_VIOLATION,
-  NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION = nsresult::NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION,
-
-
-  NS_ERROR_SRI_CORRUPT = nsresult::NS_ERROR_SRI_CORRUPT,
-  NS_ERROR_SRI_DISABLED = nsresult::NS_ERROR_SRI_DISABLED,
-  NS_ERROR_SRI_NOT_ELIGIBLE = nsresult::NS_ERROR_SRI_NOT_ELIGIBLE,
-  NS_ERROR_SRI_UNEXPECTED_HASH_TYPE = nsresult::NS_ERROR_SRI_UNEXPECTED_HASH_TYPE,
-  NS_ERROR_SRI_IMPORT = nsresult::NS_ERROR_SRI_IMPORT,
-
-
-
-  NS_ERROR_CMS_VERIFY_NOT_SIGNED = nsresult::NS_ERROR_CMS_VERIFY_NOT_SIGNED,
-  NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO = nsresult::NS_ERROR_CMS_VERIFY_NO_CONTENT_INFO,
-  NS_ERROR_CMS_VERIFY_BAD_DIGEST = nsresult::NS_ERROR_CMS_VERIFY_BAD_DIGEST,
-  NS_ERROR_CMS_VERIFY_NOCERT = nsresult::NS_ERROR_CMS_VERIFY_NOCERT,
-  NS_ERROR_CMS_VERIFY_UNTRUSTED = nsresult::NS_ERROR_CMS_VERIFY_UNTRUSTED,
-  NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED = nsresult::NS_ERROR_CMS_VERIFY_ERROR_UNVERIFIED,
-  NS_ERROR_CMS_VERIFY_ERROR_PROCESSING = nsresult::NS_ERROR_CMS_VERIFY_ERROR_PROCESSING,
-  NS_ERROR_CMS_VERIFY_BAD_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_BAD_SIGNATURE,
-  NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_DIGEST_MISMATCH,
-  NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNKNOWN_ALGO,
-  NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO = nsresult::NS_ERROR_CMS_VERIFY_UNSUPPORTED_ALGO,
-  NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE = nsresult::NS_ERROR_CMS_VERIFY_MALFORMED_SIGNATURE,
-  NS_ERROR_CMS_VERIFY_HEADER_MISMATCH = nsresult::NS_ERROR_CMS_VERIFY_HEADER_MISMATCH,
-  NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED = nsresult::NS_ERROR_CMS_VERIFY_NOT_YET_ATTEMPTED,
-  NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS = nsresult::NS_ERROR_CMS_VERIFY_CERT_WITHOUT_ADDRESS,
-  NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG = nsresult::NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG,
-  NS_ERROR_CMS_ENCRYPT_INCOMPLETE = nsresult::NS_ERROR_CMS_ENCRYPT_INCOMPLETE,
-# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INVALID_EXPRESSION_ERR = nsresult::NS_ERROR_DOM_INVALID_EXPRESSION_ERR,
-  NS_ERROR_DOM_TYPE_ERR = nsresult::NS_ERROR_DOM_TYPE_ERR,
-
-
-
-
-
-
-
-  NS_ERROR_WONT_HANDLE_CONTENT = nsresult::NS_ERROR_WONT_HANDLE_CONTENT,
-
-
-  NS_ERROR_MALWARE_URI = nsresult::NS_ERROR_MALWARE_URI,
-  NS_ERROR_PHISHING_URI = nsresult::NS_ERROR_PHISHING_URI,
-  NS_ERROR_TRACKING_URI = nsresult::NS_ERROR_TRACKING_URI,
-  NS_ERROR_UNWANTED_URI = nsresult::NS_ERROR_UNWANTED_URI,
-  NS_ERROR_BLOCKED_URI = nsresult::NS_ERROR_BLOCKED_URI,
-
-
-  NS_ERROR_SAVE_LINK_AS_TIMEOUT = nsresult::NS_ERROR_SAVE_LINK_AS_TIMEOUT,
-
-
-  NS_ERROR_PARSED_DATA_CACHED = nsresult::NS_ERROR_PARSED_DATA_CACHED,
-
-
-
-  NS_REFRESHURI_HEADER_FOUND = nsresult::NS_REFRESHURI_HEADER_FOUND,
-# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_IMAGE_SRC_CHANGED = nsresult::NS_ERROR_IMAGE_SRC_CHANGED,
-  NS_ERROR_IMAGE_BLOCKED = nsresult::NS_ERROR_IMAGE_BLOCKED,
-
-  NS_ERROR_CONTENT_BLOCKED = nsresult::NS_ERROR_CONTENT_BLOCKED,
-  NS_ERROR_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_ERROR_CONTENT_BLOCKED_SHOW_ALT,
-
-  NS_PROPTABLE_PROP_NOT_THERE = nsresult::NS_PROPTABLE_PROP_NOT_THERE,
-
-  NS_ERROR_XBL_BLOCKED = nsresult::NS_ERROR_XBL_BLOCKED,
-
-  NS_ERROR_CONTENT_CRASHED = nsresult::NS_ERROR_CONTENT_CRASHED,
-
-
-  NS_HTML_STYLE_PROPERTY_NOT_THERE = nsresult::NS_HTML_STYLE_PROPERTY_NOT_THERE,
-  NS_CONTENT_BLOCKED = nsresult::NS_CONTENT_BLOCKED,
-  NS_CONTENT_BLOCKED_SHOW_ALT = nsresult::NS_CONTENT_BLOCKED_SHOW_ALT,
-  NS_PROPTABLE_PROP_OVERWRITTEN = nsresult::NS_PROPTABLE_PROP_OVERWRITTEN,
-
-  NS_FINDBROADCASTER_NOT_FOUND = nsresult::NS_FINDBROADCASTER_NOT_FOUND,
-  NS_FINDBROADCASTER_FOUND = nsresult::NS_FINDBROADCASTER_FOUND,
-  NS_FINDBROADCASTER_AWAIT_OVERLAYS = nsresult::NS_FINDBROADCASTER_AWAIT_OVERLAYS,
-
-
-
-
-
-
-
-  NS_ERROR_XPATH_INVALID_ARG = nsresult::NS_ERROR_XPATH_INVALID_ARG,
-
-  NS_ERROR_XSLT_PARSE_FAILURE = nsresult::NS_ERROR_XSLT_PARSE_FAILURE,
-  NS_ERROR_XPATH_PARSE_FAILURE = nsresult::NS_ERROR_XPATH_PARSE_FAILURE,
-  NS_ERROR_XSLT_ALREADY_SET = nsresult::NS_ERROR_XSLT_ALREADY_SET,
-  NS_ERROR_XSLT_EXECUTION_FAILURE = nsresult::NS_ERROR_XSLT_EXECUTION_FAILURE,
-  NS_ERROR_XPATH_UNKNOWN_FUNCTION = nsresult::NS_ERROR_XPATH_UNKNOWN_FUNCTION,
-  NS_ERROR_XSLT_BAD_RECURSION = nsresult::NS_ERROR_XSLT_BAD_RECURSION,
-  NS_ERROR_XSLT_BAD_VALUE = nsresult::NS_ERROR_XSLT_BAD_VALUE,
-  NS_ERROR_XSLT_NODESET_EXPECTED = nsresult::NS_ERROR_XSLT_NODESET_EXPECTED,
-  NS_ERROR_XSLT_ABORTED = nsresult::NS_ERROR_XSLT_ABORTED,
-  NS_ERROR_XSLT_NETWORK_ERROR = nsresult::NS_ERROR_XSLT_NETWORK_ERROR,
-  NS_ERROR_XSLT_WRONG_MIME_TYPE = nsresult::NS_ERROR_XSLT_WRONG_MIME_TYPE,
-  NS_ERROR_XSLT_LOAD_RECURSION = nsresult::NS_ERROR_XSLT_LOAD_RECURSION,
-  NS_ERROR_XPATH_BAD_ARGUMENT_COUNT = nsresult::NS_ERROR_XPATH_BAD_ARGUMENT_COUNT,
-  NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION = nsresult::NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION,
-  NS_ERROR_XPATH_PAREN_EXPECTED = nsresult::NS_ERROR_XPATH_PAREN_EXPECTED,
-  NS_ERROR_XPATH_INVALID_AXIS = nsresult::NS_ERROR_XPATH_INVALID_AXIS,
-  NS_ERROR_XPATH_NO_NODE_TYPE_TEST = nsresult::NS_ERROR_XPATH_NO_NODE_TYPE_TEST,
-  NS_ERROR_XPATH_BRACKET_EXPECTED = nsresult::NS_ERROR_XPATH_BRACKET_EXPECTED,
-  NS_ERROR_XPATH_INVALID_VAR_NAME = nsresult::NS_ERROR_XPATH_INVALID_VAR_NAME,
-  NS_ERROR_XPATH_UNEXPECTED_END = nsresult::NS_ERROR_XPATH_UNEXPECTED_END,
-  NS_ERROR_XPATH_OPERATOR_EXPECTED = nsresult::NS_ERROR_XPATH_OPERATOR_EXPECTED,
-  NS_ERROR_XPATH_UNCLOSED_LITERAL = nsresult::NS_ERROR_XPATH_UNCLOSED_LITERAL,
-  NS_ERROR_XPATH_BAD_COLON = nsresult::NS_ERROR_XPATH_BAD_COLON,
-  NS_ERROR_XPATH_BAD_BANG = nsresult::NS_ERROR_XPATH_BAD_BANG,
-  NS_ERROR_XPATH_ILLEGAL_CHAR = nsresult::NS_ERROR_XPATH_ILLEGAL_CHAR,
-  NS_ERROR_XPATH_BINARY_EXPECTED = nsresult::NS_ERROR_XPATH_BINARY_EXPECTED,
-  NS_ERROR_XSLT_LOAD_BLOCKED_ERROR = nsresult::NS_ERROR_XSLT_LOAD_BLOCKED_ERROR,
-  NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED = nsresult::NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED,
-  NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE = nsresult::NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE,
-  NS_ERROR_XSLT_BAD_NODE_NAME = nsresult::NS_ERROR_XSLT_BAD_NODE_NAME,
-  NS_ERROR_XSLT_VAR_ALREADY_SET = nsresult::NS_ERROR_XSLT_VAR_ALREADY_SET,
-  NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED = nsresult::NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED,
-
-  NS_XSLT_GET_NEW_HANDLER = nsresult::NS_XSLT_GET_NEW_HANDLER,
-# 831 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_TRANSPORT_INIT = nsresult::NS_ERROR_TRANSPORT_INIT,
-
-  NS_ERROR_DUPLICATE_HANDLE = nsresult::NS_ERROR_DUPLICATE_HANDLE,
-
-  NS_ERROR_BRIDGE_OPEN_PARENT = nsresult::NS_ERROR_BRIDGE_OPEN_PARENT,
-
-  NS_ERROR_BRIDGE_OPEN_CHILD = nsresult::NS_ERROR_BRIDGE_OPEN_CHILD,
-
-
-
-
-
-
-
-  NS_ERROR_DOM_SVG_WRONG_TYPE_ERR = nsresult::NS_ERROR_DOM_SVG_WRONG_TYPE_ERR,
-
-  NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE = nsresult::NS_ERROR_DOM_SVG_MATRIX_NOT_INVERTABLE,
-# 863 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_STORAGE_BUSY = nsresult::NS_ERROR_STORAGE_BUSY,
-  NS_ERROR_STORAGE_IOERR = nsresult::NS_ERROR_STORAGE_IOERR,
-  NS_ERROR_STORAGE_CONSTRAINT = nsresult::NS_ERROR_STORAGE_CONSTRAINT,
-
-
-
-
-
-
-
-  NS_ERROR_DOM_FILE_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_FOUND_ERR,
-  NS_ERROR_DOM_FILE_NOT_READABLE_ERR = nsresult::NS_ERROR_DOM_FILE_NOT_READABLE_ERR,
-  NS_ERROR_DOM_FILE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILE_ABORT_ERR,
-# 884 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR,
-  NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR,
-  NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR,
-  NS_ERROR_DOM_INDEXEDDB_DATA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_DATA_ERR,
-  NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR,
-  NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR,
-  NS_ERROR_DOM_INDEXEDDB_ABORT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_ABORT_ERR,
-  NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_READ_ONLY_ERR,
-  NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_TIMEOUT_ERR,
-  NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_QUOTA_ERR,
-  NS_ERROR_DOM_INDEXEDDB_VERSION_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_VERSION_ERR,
-  NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR = nsresult::NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR,
-
-
-
-
-
-
-
-  NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR,
-  NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_NOT_ALLOWED_ERR,
-  NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_INACTIVE_ERR,
-  NS_ERROR_DOM_FILEHANDLE_ABORT_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_ABORT_ERR,
-  NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_READ_ONLY_ERR,
-  NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR = nsresult::NS_ERROR_DOM_FILEHANDLE_QUOTA_ERR,
-
-
-
-
-
-
-  NS_ERROR_SIGNED_JAR_NOT_SIGNED = nsresult::NS_ERROR_SIGNED_JAR_NOT_SIGNED,
-  NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY,
-  NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY = nsresult::NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY,
-  NS_ERROR_SIGNED_JAR_ENTRY_MISSING = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_MISSING,
-  NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE = nsresult::NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE,
-  NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE,
-  NS_ERROR_SIGNED_JAR_ENTRY_INVALID = nsresult::NS_ERROR_SIGNED_JAR_ENTRY_INVALID,
-  NS_ERROR_SIGNED_JAR_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_JAR_MANIFEST_INVALID,
-
-
-
-
-
-
-  NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR,
-  NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_INVALID_MODIFICATION_ERR,
-  NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR,
-  NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_PATH_EXISTS_ERR,
-  NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_TYPE_MISMATCH_ERR,
-  NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR = nsresult::NS_ERROR_DOM_FILESYSTEM_UNKNOWN_ERR,
-
-
-
-
-
-
-  NS_ERROR_SIGNED_APP_MANIFEST_INVALID = nsresult::NS_ERROR_SIGNED_APP_MANIFEST_INVALID,
-
-
-
-
-
-
-  NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR = nsresult::NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR,
-
-
-
-
-
-
-  NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_REGISTRATION_ERR,
-  NS_ERROR_DOM_PUSH_DENIED_ERR = nsresult::NS_ERROR_DOM_PUSH_DENIED_ERR,
-  NS_ERROR_DOM_PUSH_ABORT_ERR = nsresult::NS_ERROR_DOM_PUSH_ABORT_ERR,
-  NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE = nsresult::NS_ERROR_DOM_PUSH_SERVICE_UNREACHABLE,
-  NS_ERROR_DOM_PUSH_INVALID_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_INVALID_KEY_ERR,
-  NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR = nsresult::NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR,
-
-
-
-
-
-
-
-  NS_ERROR_DOM_MEDIA_ABORT_ERR = nsresult::NS_ERROR_DOM_MEDIA_ABORT_ERR,
-  NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR,
-  NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR = nsresult::NS_ERROR_DOM_MEDIA_NOT_SUPPORTED_ERR,
-
-
-  NS_ERROR_DOM_MEDIA_DECODE_ERR = nsresult::NS_ERROR_DOM_MEDIA_DECODE_ERR,
-  NS_ERROR_DOM_MEDIA_FATAL_ERR = nsresult::NS_ERROR_DOM_MEDIA_FATAL_ERR,
-  NS_ERROR_DOM_MEDIA_METADATA_ERR = nsresult::NS_ERROR_DOM_MEDIA_METADATA_ERR,
-  NS_ERROR_DOM_MEDIA_OVERFLOW_ERR = nsresult::NS_ERROR_DOM_MEDIA_OVERFLOW_ERR,
-  NS_ERROR_DOM_MEDIA_END_OF_STREAM = nsresult::NS_ERROR_DOM_MEDIA_END_OF_STREAM,
-  NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA = nsresult::NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA,
-  NS_ERROR_DOM_MEDIA_CANCELED = nsresult::NS_ERROR_DOM_MEDIA_CANCELED,
-  NS_ERROR_DOM_MEDIA_MEDIASINK_ERR = nsresult::NS_ERROR_DOM_MEDIA_MEDIASINK_ERR,
-  NS_ERROR_DOM_MEDIA_DEMUXER_ERR = nsresult::NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
-  NS_ERROR_DOM_MEDIA_CDM_ERR = nsresult::NS_ERROR_DOM_MEDIA_CDM_ERR,
-  NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER = nsresult::NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER,
-  NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER = nsresult::NS_ERROR_DOM_MEDIA_INITIALIZING_DECODER,
-
-
-  NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR = nsresult::NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR,
-
-
-
-
-
-
-  NS_ERROR_UC_UPDATE_UNKNOWN = nsresult::NS_ERROR_UC_UPDATE_UNKNOWN,
-  NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX = nsresult::NS_ERROR_UC_UPDATE_DUPLICATE_PREFIX,
-  NS_ERROR_UC_UPDATE_INFINITE_LOOP = nsresult::NS_ERROR_UC_UPDATE_INFINITE_LOOP,
-  NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES = nsresult::NS_ERROR_UC_UPDATE_WRONG_REMOVAL_INDICES,
-  NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH = nsresult::NS_ERROR_UC_UPDATE_CHECKSUM_MISMATCH,
-  NS_ERROR_UC_UPDATE_MISSING_CHECKSUM = nsresult::NS_ERROR_UC_UPDATE_MISSING_CHECKSUM,
-  NS_ERROR_UC_UPDATE_SHUTDOWNING = nsresult::NS_ERROR_UC_UPDATE_SHUTDOWNING,
-  NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND = nsresult::NS_ERROR_UC_UPDATE_TABLE_NOT_FOUND,
-  NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE = nsresult::NS_ERROR_UC_UPDATE_BUILD_PREFIX_FAILURE,
-  NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK = nsresult::NS_ERROR_UC_UPDATE_FAIL_TO_WRITE_DISK,
-  NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR = nsresult::NS_ERROR_UC_UPDATE_PROTOCOL_PARSER_ERROR,
-
-
-
-
-
-
-
-  NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION,
-
-  NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION,
-
-  NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT,
-
-  NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR,
-
-  NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR = nsresult::NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR,
-# 1029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ErrorList.h"
-  NS_ERROR_DOWNLOAD_COMPLETE = nsresult::NS_ERROR_DOWNLOAD_COMPLETE,
-
-
-
-  NS_ERROR_DOWNLOAD_NOT_PARTIAL = nsresult::NS_ERROR_DOWNLOAD_NOT_PARTIAL,
-  NS_ERROR_UNORM_MOREOUTPUT = nsresult::NS_ERROR_UNORM_MOREOUTPUT,
-
-  NS_ERROR_DOCSHELL_REQUEST_REJECTED = nsresult::NS_ERROR_DOCSHELL_REQUEST_REJECTED,
-
-
-
-
-  NS_ERROR_DOCUMENT_IS_PRINTMODE = nsresult::NS_ERROR_DOCUMENT_IS_PRINTMODE,
-
-  NS_SUCCESS_DONT_FIXUP = nsresult::NS_SUCCESS_DONT_FIXUP,
-
-
-
-  NS_SUCCESS_RESTART_APP = nsresult::NS_SUCCESS_RESTART_APP,
-  NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = nsresult::NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE,
-  NS_SUCCESS_UNORM_NOTFOUND = nsresult::NS_SUCCESS_UNORM_NOTFOUND,
-
-
-
-
-  NS_ERROR_NOT_IN_TREE = nsresult::NS_ERROR_NOT_IN_TREE,
-
-
-  NS_OK_NO_NAME_CLAUSE_HANDLED = nsresult::NS_OK_NO_NAME_CLAUSE_HANDLED
-# 142 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h" 2
-
-;
-# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
-inline uint32_t
-NS_FAILED_impl(nsresult aErr)
-{
-  return static_cast<uint32_t>(aErr) & 0x80000000;
-}
-
-
-
-
-static_assert(((nsresult)0) < ((nsresult)-1),
-              "nsresult must be an unsigned type");
-static_assert(sizeof(nsresult) == sizeof(uint32_t),
-              "nsresult must be 32 bits");
-# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsError.h"
-extern nsresult
-NS_ErrorAccordingToNSPR();
-
-
-
-
-
-
-inline constexpr uint16_t
-NS_ERROR_GET_CODE(nsresult aErr)
-{
-  return uint32_t(aErr) & 0xffff;
-}
-inline constexpr uint16_t
-NS_ERROR_GET_MODULE(nsresult aErr)
-{
-  return ((uint32_t(aErr) >> 16) - 0x45) & 0x1fff;
-}
-inline bool
-NS_ERROR_GET_SEVERITY(nsresult aErr)
-{
-  return uint32_t(aErr) >> 31;
-}
-# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nscore.h" 2
-
-typedef MozRefCountType nsrefcnt;
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTraceRefcnt.h" 2
-
-class nsTraceRefcnt
-{
-public:
-  static void Shutdown();
-
-  static nsresult DumpStatistics();
-
-  static void ResetStatistics();
-
-  static void WalkTheStack(FILE* aStream);
-
-
-
-
-
-
-  static void SetActivityIsLegal(bool aLegal);
-};
-
-
-
-
-extern "C" void
-NS_MeanAndStdDev(double aNumberOfValues,
-                 double aSumOfValues, double aSumOfSquaredValues,
-                 double* aMeanResult, double* aStdDevResult);
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-
-
-
-
-
-
-
-
-extern "C" {
-extern __attribute__((weak)) __attribute__((visibility("default"))) const char* gMozCrashReason;
-}
-
-
-static inline void
-AnnotateMozCrashReason(const char* reason)
-{
-  gMozCrashReason = reason;
-}
-
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 2 3
-
-using std::abort;
-using std::atexit;
-using std::exit;
-
-
-  using std::at_quick_exit;
-
-
-  using std::quick_exit;
-
-
-
-
-using std::div_t;
-using std::ldiv_t;
-
-using std::abs;
-using std::atof;
-using std::atoi;
-using std::atol;
-using std::bsearch;
-using std::calloc;
-using std::div;
-using std::free;
-using std::getenv;
-using std::labs;
-using std::ldiv;
-using std::malloc;
-
-using std::mblen;
-using std::mbstowcs;
-using std::mbtowc;
-
-using std::qsort;
-using std::rand;
-using std::realloc;
-using std::srand;
-using std::strtod;
-using std::strtol;
-using std::strtoul;
-using std::system;
-
-using std::wcstombs;
-using std::wctomb;
-# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-# 1 "/usr/include/signal.h" 1 3 4
-# 30 "/usr/include/signal.h" 3 4
-extern "C" {
-
-
-# 1 "/usr/include/bits/sigset.h" 1 3 4
-# 102 "/usr/include/bits/sigset.h" 3 4
-extern int __sigismember (const __sigset_t *, int);
-extern int __sigaddset (__sigset_t *, int);
-extern int __sigdelset (__sigset_t *, int);
-# 33 "/usr/include/signal.h" 2 3 4
-
-
-
-
-
-
-
-typedef __sig_atomic_t sig_atomic_t;
-# 57 "/usr/include/signal.h" 3 4
-# 1 "/usr/include/bits/signum.h" 1 3 4
-# 58 "/usr/include/signal.h" 2 3 4
-# 75 "/usr/include/signal.h" 3 4
-# 1 "/usr/include/time.h" 1 3 4
-# 76 "/usr/include/signal.h" 2 3 4
-
-
-
-
-# 1 "/usr/include/bits/siginfo.h" 1 3 4
-# 24 "/usr/include/bits/siginfo.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 25 "/usr/include/bits/siginfo.h" 2 3 4
-
-
-
-
-
-
-
-typedef union sigval
-  {
-    int sival_int;
-    void *sival_ptr;
-  } sigval_t;
-# 58 "/usr/include/bits/siginfo.h" 3 4
-typedef __clock_t __sigchld_clock_t;
-
-
-
-typedef struct
-  {
-    int si_signo;
-    int si_errno;
-
-    int si_code;
-
-    union
-      {
- int _pad[((128 / sizeof (int)) - 4)];
-
-
- struct
-   {
-     __pid_t si_pid;
-     __uid_t si_uid;
-   } _kill;
-
-
- struct
-   {
-     int si_tid;
-     int si_overrun;
-     sigval_t si_sigval;
-   } _timer;
-
-
- struct
-   {
-     __pid_t si_pid;
-     __uid_t si_uid;
-     sigval_t si_sigval;
-   } _rt;
-
-
- struct
-   {
-     __pid_t si_pid;
-     __uid_t si_uid;
-     int si_status;
-     __sigchld_clock_t si_utime;
-     __sigchld_clock_t si_stime;
-   } _sigchld;
-
-
- struct
-   {
-     void *si_addr;
-     short int si_addr_lsb;
-     struct
-       {
-  void *_lower;
-  void *_upper;
-       } si_addr_bnd;
-   } _sigfault;
-
-
- struct
-   {
-     long int si_band;
-     int si_fd;
-   } _sigpoll;
-
-
- struct
-   {
-     void *_call_addr;
-     int _syscall;
-     unsigned int _arch;
-   } _sigsys;
-      } _sifields;
-  } siginfo_t ;
-# 160 "/usr/include/bits/siginfo.h" 3 4
-enum
-{
-  SI_ASYNCNL = -60,
-
-  SI_TKILL = -6,
-
-  SI_SIGIO,
-
-  SI_ASYNCIO,
-
-  SI_MESGQ,
-
-  SI_TIMER,
-
-  SI_QUEUE,
-
-  SI_USER,
-
-  SI_KERNEL = 0x80
-
-};
-
-
-
-
-enum
-{
-  ILL_ILLOPC = 1,
-
-  ILL_ILLOPN,
-
-  ILL_ILLADR,
-
-  ILL_ILLTRP,
-
-  ILL_PRVOPC,
-
-  ILL_PRVREG,
-
-  ILL_COPROC,
-
-  ILL_BADSTK
-
-};
-
-
-enum
-{
-  FPE_INTDIV = 1,
-
-  FPE_INTOVF,
-
-  FPE_FLTDIV,
-
-  FPE_FLTOVF,
-
-  FPE_FLTUND,
-
-  FPE_FLTRES,
-
-  FPE_FLTINV,
-
-  FPE_FLTSUB
-
-};
-
-
-enum
-{
-  SEGV_MAPERR = 1,
-
-  SEGV_ACCERR
-
-};
-
-
-enum
-{
-  BUS_ADRALN = 1,
-
-  BUS_ADRERR,
-
-  BUS_OBJERR,
-
-  BUS_MCEERR_AR,
-
-  BUS_MCEERR_AO
-
-};
-
-
-
-
-enum
-{
-  TRAP_BRKPT = 1,
-
-  TRAP_TRACE
-
-};
-
-
-
-
-enum
-{
-  CLD_EXITED = 1,
-
-  CLD_KILLED,
-
-  CLD_DUMPED,
-
-  CLD_TRAPPED,
-
-  CLD_STOPPED,
-
-  CLD_CONTINUED
-
-};
-
-
-enum
-{
-  POLL_IN = 1,
-
-  POLL_OUT,
-
-  POLL_MSG,
-
-  POLL_ERR,
-
-  POLL_PRI,
-
-  POLL_HUP
-
-};
-# 320 "/usr/include/bits/siginfo.h" 3 4
-typedef struct sigevent
-  {
-    sigval_t sigev_value;
-    int sigev_signo;
-    int sigev_notify;
-
-    union
-      {
- int _pad[((64 / sizeof (int)) - 4)];
-
-
-
- __pid_t _tid;
-
- struct
-   {
-     void (*_function) (sigval_t);
-     pthread_attr_t *_attribute;
-   } _sigev_thread;
-      } _sigev_un;
-  } sigevent_t;
-
-
-
-
-
-
-enum
-{
-  SIGEV_SIGNAL = 0,
-
-  SIGEV_NONE,
-
-  SIGEV_THREAD,
-
-
-  SIGEV_THREAD_ID = 4
-
-};
-# 81 "/usr/include/signal.h" 2 3 4
-
-
-
-
-typedef void (*__sighandler_t) (int);
-
-
-
-
-extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
-     throw ();
-
-extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
-     throw ();
-
-
-
-
-
-
-
-extern __sighandler_t signal (int __sig, __sighandler_t __handler)
-     throw ();
-# 119 "/usr/include/signal.h" 3 4
-extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
-     throw ();
-
-
-
-
-
-
-extern int kill (__pid_t __pid, int __sig) throw ();
-
-
-
-
-
-
-extern int killpg (__pid_t __pgrp, int __sig) throw ();
-
-
-
-
-extern int raise (int __sig) throw ();
-
-
-
-
-extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
-     throw ();
-extern int gsignal (int __sig) throw ();
-
-
-
-
-extern void psignal (int __sig, const char *__s);
-
-
-extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
-# 168 "/usr/include/signal.h" 3 4
-extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
-# 187 "/usr/include/signal.h" 3 4
-extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
-
-
-extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
-
-
-extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
-# 202 "/usr/include/signal.h" 3 4
-typedef __sighandler_t sighandler_t;
-
-
-
-
-typedef __sighandler_t sig_t;
-
-
-
-
-
-extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigismember (const sigset_t *__set, int __signo)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigandset (sigset_t *__set, const sigset_t *__left,
-        const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
-
-
-extern int sigorset (sigset_t *__set, const sigset_t *__left,
-       const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
-
-
-
-
-
-# 1 "/usr/include/bits/sigaction.h" 1 3 4
-# 24 "/usr/include/bits/sigaction.h" 3 4
-struct sigaction
-  {
-
-
-    union
-      {
-
- __sighandler_t sa_handler;
-
- void (*sa_sigaction) (int, siginfo_t *, void *);
-      }
-    __sigaction_handler;
-
-
-
-
-
-
-
-    __sigset_t sa_mask;
-
-
-    int sa_flags;
-
-
-    void (*sa_restorer) (void);
-  };
-# 244 "/usr/include/signal.h" 2 3 4
-
-
-extern int sigprocmask (int __how, const sigset_t *__restrict __set,
-   sigset_t *__restrict __oset) throw ();
-
-
-
-
-
-
-extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
-
-
-extern int sigaction (int __sig, const struct sigaction *__restrict __act,
-        struct sigaction *__restrict __oact) throw ();
-
-
-extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
-     __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-
-
-extern int sigwaitinfo (const sigset_t *__restrict __set,
-   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern int sigtimedwait (const sigset_t *__restrict __set,
-    siginfo_t *__restrict __info,
-    const struct timespec *__restrict __timeout)
-     __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
-     throw ();
-# 301 "/usr/include/signal.h" 3 4
-extern const char *const _sys_siglist[65];
-extern const char *const sys_siglist[65];
-
-
-
-
-# 1 "/usr/include/bits/sigcontext.h" 1 3 4
-# 29 "/usr/include/bits/sigcontext.h" 3 4
-struct _fpx_sw_bytes
-{
-  __uint32_t magic1;
-  __uint32_t extended_size;
-  __uint64_t xstate_bv;
-  __uint32_t xstate_size;
-  __uint32_t padding[7];
-};
-
-struct _fpreg
-{
-  unsigned short significand[4];
-  unsigned short exponent;
-};
-
-struct _fpxreg
-{
-  unsigned short significand[4];
-  unsigned short exponent;
-  unsigned short padding[3];
-};
-
-struct _xmmreg
-{
-  __uint32_t element[4];
-};
-# 121 "/usr/include/bits/sigcontext.h" 3 4
-struct _fpstate
-{
-
-  __uint16_t cwd;
-  __uint16_t swd;
-  __uint16_t ftw;
-  __uint16_t fop;
-  __uint64_t rip;
-  __uint64_t rdp;
-  __uint32_t mxcsr;
-  __uint32_t mxcr_mask;
-  struct _fpxreg _st[8];
-  struct _xmmreg _xmm[16];
-  __uint32_t padding[24];
-};
-
-struct sigcontext
-{
-  __uint64_t r8;
-  __uint64_t r9;
-  __uint64_t r10;
-  __uint64_t r11;
-  __uint64_t r12;
-  __uint64_t r13;
-  __uint64_t r14;
-  __uint64_t r15;
-  __uint64_t rdi;
-  __uint64_t rsi;
-  __uint64_t rbp;
-  __uint64_t rbx;
-  __uint64_t rdx;
-  __uint64_t rax;
-  __uint64_t rcx;
-  __uint64_t rsp;
-  __uint64_t rip;
-  __uint64_t eflags;
-  unsigned short cs;
-  unsigned short gs;
-  unsigned short fs;
-  unsigned short __pad0;
-  __uint64_t err;
-  __uint64_t trapno;
-  __uint64_t oldmask;
-  __uint64_t cr2;
-  __extension__ union
-    {
-      struct _fpstate * fpstate;
-      __uint64_t __fpstate_word;
-    };
-  __uint64_t __reserved1 [8];
-};
-
-
-
-struct _xsave_hdr
-{
-  __uint64_t xstate_bv;
-  __uint64_t reserved1[2];
-  __uint64_t reserved2[5];
-};
-
-struct _ymmh_state
-{
-  __uint32_t ymmh_space[64];
-};
-
-struct _xstate
-{
-  struct _fpstate fpstate;
-  struct _xsave_hdr xstate_hdr;
-  struct _ymmh_state ymmh;
-};
-# 307 "/usr/include/signal.h" 2 3 4
-
-
-extern int sigreturn (struct sigcontext *__scp) throw ();
-
-
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 317 "/usr/include/signal.h" 2 3 4
-
-
-
-
-extern int siginterrupt (int __sig, int __interrupt) throw ();
-
-
-# 1 "/usr/include/bits/sigstack.h" 1 3 4
-# 25 "/usr/include/bits/sigstack.h" 3 4
-struct sigstack
-  {
-    void *ss_sp;
-    int ss_onstack;
-  };
-
-
-
-enum
-{
-  SS_ONSTACK = 1,
-
-  SS_DISABLE
-
-};
-# 49 "/usr/include/bits/sigstack.h" 3 4
-typedef struct sigaltstack
-  {
-    void *ss_sp;
-    int ss_flags;
-    size_t ss_size;
-  } stack_t;
-# 324 "/usr/include/signal.h" 2 3 4
-
-
-# 1 "/usr/include/sys/ucontext.h" 1 3 4
-# 22 "/usr/include/sys/ucontext.h" 3 4
-# 1 "/usr/include/signal.h" 1 3 4
-# 23 "/usr/include/sys/ucontext.h" 2 3 4
-
-
-
-
-
-
-
-
-__extension__ typedef long long int greg_t;
-
-
-
-
-
-typedef greg_t gregset_t[23];
-
-
-
-enum
-{
-  REG_R8 = 0,
-
-  REG_R9,
-
-  REG_R10,
-
-  REG_R11,
-
-  REG_R12,
-
-  REG_R13,
-
-  REG_R14,
-
-  REG_R15,
-
-  REG_RDI,
-
-  REG_RSI,
-
-  REG_RBP,
-
-  REG_RBX,
-
-  REG_RDX,
-
-  REG_RAX,
-
-  REG_RCX,
-
-  REG_RSP,
-
-  REG_RIP,
-
-  REG_EFL,
-
-  REG_CSGSFS,
-
-  REG_ERR,
-
-  REG_TRAPNO,
-
-  REG_OLDMASK,
-
-  REG_CR2
-
-};
-
-
-struct _libc_fpxreg
-{
-  unsigned short int significand[4];
-  unsigned short int exponent;
-  unsigned short int padding[3];
-};
-
-struct _libc_xmmreg
-{
-  __uint32_t element[4];
-};
-
-struct _libc_fpstate
-{
-
-  __uint16_t cwd;
-  __uint16_t swd;
-  __uint16_t ftw;
-  __uint16_t fop;
-  __uint64_t rip;
-  __uint64_t rdp;
-  __uint32_t mxcsr;
-  __uint32_t mxcr_mask;
-  struct _libc_fpxreg _st[8];
-  struct _libc_xmmreg _xmm[16];
-  __uint32_t padding[24];
-};
-
-
-typedef struct _libc_fpstate *fpregset_t;
-
-
-typedef struct
-  {
-    gregset_t gregs;
-
-    fpregset_t fpregs;
-    __extension__ unsigned long long __reserved1 [8];
-} mcontext_t;
-
-
-typedef struct ucontext
-  {
-    unsigned long int uc_flags;
-    struct ucontext *uc_link;
-    stack_t uc_stack;
-    mcontext_t uc_mcontext;
-    __sigset_t uc_sigmask;
-    struct _libc_fpstate __fpregs_mem;
-  } ucontext_t;
-# 327 "/usr/include/signal.h" 2 3 4
-
-
-
-
-
-extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
-     throw () __attribute__ ((__deprecated__));
-
-
-
-extern int sigaltstack (const struct sigaltstack *__restrict __ss,
-   struct sigaltstack *__restrict __oss) throw ();
-
-
-
-
-
-
-
-extern int sighold (int __sig) throw ();
-
-
-extern int sigrelse (int __sig) throw ();
-
-
-extern int sigignore (int __sig) throw ();
-
-
-extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
-
-
-
-
-
-
-
-# 1 "/usr/include/bits/sigthread.h" 1 3 4
-# 30 "/usr/include/bits/sigthread.h" 3 4
-extern int pthread_sigmask (int __how,
-       const __sigset_t *__restrict __newmask,
-       __sigset_t *__restrict __oldmask)throw ();
-
-
-extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
-
-
-
-extern int pthread_sigqueue (pthread_t __threadid, int __signo,
-        const union sigval __value) throw ();
-# 363 "/usr/include/signal.h" 2 3 4
-
-
-
-
-
-
-extern int __libc_current_sigrtmin (void) throw ();
-
-extern int __libc_current_sigrtmax (void) throw ();
-
-
-
-}
-# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h" 2
-# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-extern "C" {
-# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void
-MOZ_ReportAssertionFailure(const char* aStr, const char* aFilename, int aLine)
-
-{
-
-
-
-
-
-  fprintf(stderr, "Assertion failure: %s, at %s:%d\n", aStr, aFilename, aLine);
-
-  nsTraceRefcnt::WalkTheStack(stderr);
-
-  fflush(stderr);
-
-}
-
-__attribute__ ((__unused__)) static __attribute__ ((cold)) __attribute__((noinline)) void
-MOZ_ReportCrash(const char* aStr, const char* aFilename, int aLine)
-
-{
-
-
-
-
-  fprintf(stderr, "Hit MOZ_CRASH(%s) at %s:%d\n", aStr, aFilename, aLine);
-
-  nsTraceRefcnt::WalkTheStack(stderr);
-
-  fflush(stderr);
-
-}
-# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) void
-MOZ_CrashOOL(int aLine, const char* aReason);
-
-
-
-
-
-
-
-static const size_t sPrintfMaxArgs = 4;
-static const size_t sPrintfCrashReasonSize = 1024;
-
-
-__attribute__((weak)) __attribute__((visibility("default"))) __attribute__ ((cold)) __attribute__((noreturn)) __attribute__((noinline)) __attribute__ ((format (printf, 2, 3))) void
-MOZ_CrashPrintf(int aLine, const char* aFormat, ...);
-# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-}
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Assertions.h"
-namespace mozilla {
-namespace detail {
-
-template<typename T>
-struct AssertionConditionType
-{
-  typedef typename RemoveReference<T>::Type ValueT;
-  static_assert(!IsArray<ValueT>::value,
-                "Expected boolean assertion condition, got an array or a "
-                "string!");
-  static_assert(!IsFunction<ValueT>::value,
-                "Expected boolean assertion condition, got a function! Did "
-                "you intend to call that function?");
-  static_assert(!IsFloatingPoint<ValueT>::value,
-                "It's often a bad idea to assert that a floating-point number "
-                "is nonzero, because such assertions tend to intermittently "
-                "fail. Shouldn't your code gracefully handle this case instead "
-                "of asserting? Anyway, if you really want to do that, write an "
-                "explicit boolean condition, like !!x or x!=0.");
-
-  static const bool isValid = true;
-};
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h"
-namespace mozilla {
-# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Move.h"
-template<typename T>
-inline typename RemoveReference<T>::Type&&
-Move(T&& aX)
-{
-  return static_cast<typename RemoveReference<T>::Type&&>(aX);
-}
-
-
-
-
-
-template<typename T>
-inline T&&
-Forward(typename RemoveReference<T>::Type& aX)
-{
-  return static_cast<T&&>(aX);
-}
-
-template<typename T>
-inline T&&
-Forward(typename RemoveReference<T>::Type&& aX)
-{
-  static_assert(!IsLvalueReference<T>::value,
-                "misuse of Forward detected!  try the other overload");
-  return static_cast<T&&>(aX);
-}
-
-
-template<typename T>
-inline void
-Swap(T& aX, T& aY)
-{
-  T tmp(Move(aX));
-  aX = Move(aY);
-  aY = Move(tmp);
-}
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h" 2
-
-namespace mozilla {
-
-struct unused_t;
-
-}
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
-template<class T>
-struct already_AddRefed
-{
-# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
-  already_AddRefed() : mRawPtr(nullptr) {}
-
-
-
-  typedef void (already_AddRefed::* MatchNullptr)(double, float);
-               already_AddRefed(MatchNullptr aRawPtr) : mRawPtr(nullptr) {}
-
-  explicit already_AddRefed(T* aRawPtr) : mRawPtr(aRawPtr) {}
-
-
-  already_AddRefed(const already_AddRefed<T>& aOther) = delete;
-  already_AddRefed<T>& operator=(const already_AddRefed<T>& aOther) = delete;
-
-  already_AddRefed(already_AddRefed<T>&& aOther) : mRawPtr(aOther.take()) {}
-
-  already_AddRefed<T>& operator=(already_AddRefed<T>&& aOther)
-  {
-    mRawPtr = aOther.take();
-    return *this;
-  }
-# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
-  template <typename U>
-               already_AddRefed(already_AddRefed<U>&& aOther) : mRawPtr(aOther.take()) {}
-
-  ~already_AddRefed() { do { } while (0); }
-
-
-
-
-
-  friend void operator<<(const mozilla::unused_t& aUnused,
-                         const already_AddRefed<T>& aRhs)
-  {
-    auto mutableAlreadyAddRefed = const_cast<already_AddRefed<T>*>(&aRhs);
-    aUnused << mutableAlreadyAddRefed->take();
-  }
-
-  __attribute__ ((warn_unused_result)) T* take()
-  {
-    T* rawPtr = mRawPtr;
-    mRawPtr = nullptr;
-    return rawPtr;
-  }
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AlreadyAddRefed.h"
-  template<class U>
-  already_AddRefed<U> downcast()
-  {
-    U* tmp = static_cast<U*>(mRawPtr);
-    mRawPtr = nullptr;
-    return already_AddRefed<U>(tmp);
-  }
-
-private:
-  T* mRawPtr;
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h" 2
-
-
-
-
-
-
-
-class nsCOMPtr_helper;
-
-namespace mozilla {
-template<class T> class OwningNonNull;
-template<class T> class StaticRefPtr;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-template<class U>
-struct RefPtrTraits
-{
-  static void AddRef(U* aPtr) {
-    aPtr->AddRef();
-  }
-  static void Release(U* aPtr) {
-    aPtr->Release();
-  }
-};
-
-}
-
-template <class T>
-class RefPtr
-{
-private:
-  void
-  assign_with_AddRef(T* aRawPtr)
-  {
-    if (aRawPtr) {
-      ConstRemovingRefPtrTraits<T>::AddRef(aRawPtr);
-    }
-    assign_assuming_AddRef(aRawPtr);
-  }
-
-  void
-  assign_assuming_AddRef(T* aNewPtr)
-  {
-    T* oldPtr = mRawPtr;
-    mRawPtr = aNewPtr;
-    if (oldPtr) {
-      ConstRemovingRefPtrTraits<T>::Release(oldPtr);
-    }
-  }
-
-private:
-  T* mRawPtr;
-
-public:
-  typedef T element_type;
-
-  ~RefPtr()
-  {
-    if (mRawPtr) {
-      ConstRemovingRefPtrTraits<T>::Release(mRawPtr);
-    }
-  }
-
-
-
-  RefPtr()
-    : mRawPtr(nullptr)
-
-  {
-  }
-
-  RefPtr(const RefPtr<T>& aSmartPtr)
-    : mRawPtr(aSmartPtr.mRawPtr)
-
-  {
-    if (mRawPtr) {
-      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
-    }
-  }
-
-  RefPtr(RefPtr<T>&& aRefPtr)
-    : mRawPtr(aRefPtr.mRawPtr)
-  {
-    aRefPtr.mRawPtr = nullptr;
-  }
-
-
-
-               RefPtr(T* aRawPtr)
-    : mRawPtr(aRawPtr)
-  {
-    if (mRawPtr) {
-      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
-    }
-  }
-
-               RefPtr(decltype(nullptr))
-    : mRawPtr(nullptr)
-  {
-  }
-
-  template <typename I>
-               RefPtr(already_AddRefed<I>& aSmartPtr)
-    : mRawPtr(aSmartPtr.take())
-
-  {
-  }
-
-  template <typename I>
-               RefPtr(already_AddRefed<I>&& aSmartPtr)
-    : mRawPtr(aSmartPtr.take())
-
-  {
-  }
-
-  template <typename I>
-               RefPtr(const RefPtr<I>& aSmartPtr)
-    : mRawPtr(aSmartPtr.get())
-
-  {
-    if (mRawPtr) {
-      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
-    }
-  }
-
-  template <typename I>
-               RefPtr(RefPtr<I>&& aSmartPtr)
-    : mRawPtr(aSmartPtr.forget().take())
-
-  {
-  }
-
-               RefPtr(const nsCOMPtr_helper& aHelper);
-
-
-  template<class U>
-               RefPtr(const mozilla::OwningNonNull<U>& aOther);
-
-
-  template<class U>
-               RefPtr(const mozilla::StaticRefPtr<U>& aOther);
-
-
-
-  RefPtr<T>&
-  operator=(decltype(nullptr))
-  {
-    assign_assuming_AddRef(nullptr);
-    return *this;
-  }
-
-  RefPtr<T>&
-  operator=(const RefPtr<T>& aRhs)
-
-  {
-    assign_with_AddRef(aRhs.mRawPtr);
-    return *this;
-  }
-
-  template <typename I>
-  RefPtr<T>&
-  operator=(const RefPtr<I>& aRhs)
-
-  {
-    assign_with_AddRef(aRhs.get());
-    return *this;
-  }
-
-  RefPtr<T>&
-  operator=(T* aRhs)
-
-  {
-    assign_with_AddRef(aRhs);
-    return *this;
-  }
-
-  template <typename I>
-  RefPtr<T>&
-  operator=(already_AddRefed<I>& aRhs)
-
-  {
-    assign_assuming_AddRef(aRhs.take());
-    return *this;
-  }
-
-  template <typename I>
-  RefPtr<T>&
-  operator=(already_AddRefed<I> && aRhs)
-
-  {
-    assign_assuming_AddRef(aRhs.take());
-    return *this;
-  }
-
-  RefPtr<T>& operator=(const nsCOMPtr_helper& aHelper);
-
-  RefPtr<T>&
-  operator=(RefPtr<T> && aRefPtr)
-  {
-    assign_assuming_AddRef(aRefPtr.mRawPtr);
-    aRefPtr.mRawPtr = nullptr;
-    return *this;
-  }
-
-
-  template<class U>
-  RefPtr<T>&
-  operator=(const mozilla::OwningNonNull<U>& aOther);
-
-
-  template<class U>
-  RefPtr<T>&
-  operator=(const mozilla::StaticRefPtr<U>& aOther);
-
-
-
-  void
-  swap(RefPtr<T>& aRhs)
-
-  {
-    T* temp = aRhs.mRawPtr;
-    aRhs.mRawPtr = mRawPtr;
-    mRawPtr = temp;
-  }
-
-  void
-  swap(T*& aRhs)
-
-  {
-    T* temp = aRhs;
-    aRhs = mRawPtr;
-    mRawPtr = temp;
-  }
-
-  already_AddRefed<T>
-
-  forget()
-
-
-  {
-    T* temp = nullptr;
-    swap(temp);
-    return already_AddRefed<T>(temp);
-  }
-
-  template <typename I>
-  void
-  forget(I** aRhs)
-
-
-
-
-  {
-    do { } while (0);
-    *aRhs = mRawPtr;
-    mRawPtr = nullptr;
-  }
-
-  T*
-  get() const
-
-
-
-
-  {
-    return const_cast<T*>(mRawPtr);
-  }
-
-  operator T*() const &
-# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-  {
-    return get();
-  }
-
-
-
-
-  operator T*() const && = delete;
-
-
-
-
-  explicit operator bool() const { return !!mRawPtr; }
-  bool operator!() const { return !mRawPtr; }
-
-  T*
-  operator->() const
-  {
-    do { } while (0);
-
-    return get();
-  }
-
-  template <typename R, typename... Args>
-  class Proxy
-  {
-    typedef R (T::*member_function)(Args...);
-    T* mRawPtr;
-    member_function mFunction;
-  public:
-    Proxy(T* aRawPtr, member_function aFunction)
-      : mRawPtr(aRawPtr),
-        mFunction(aFunction)
-    {
-    }
-    template<typename... ActualArgs>
-    R operator()(ActualArgs&&... aArgs)
-    {
-      return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
-    }
-  };
-
-  template <typename R, typename... Args>
-  Proxy<R, Args...> operator->*(R (T::*aFptr)(Args...)) const
-  {
-    do { } while (0);
-
-    return Proxy<R, Args...>(get(), aFptr);
-  }
-
-  RefPtr<T>*
-  get_address()
-
-
-  {
-    return this;
-  }
-
-  const RefPtr<T>*
-  get_address() const
-
-
-  {
-    return this;
-  }
-
-public:
-  T&
-  operator*() const
-  {
-    do { } while (0);
-
-    return *get();
-  }
-
-  T**
-  StartAssignment()
-  {
-    assign_assuming_AddRef(nullptr);
-    return reinterpret_cast<T**>(&mRawPtr);
-  }
-private:
-# 388 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-  template<class U>
-  struct ConstRemovingRefPtrTraits
-  {
-    static void AddRef(U* aPtr) {
-      mozilla::RefPtrTraits<U>::AddRef(aPtr);
-    }
-    static void Release(U* aPtr) {
-      mozilla::RefPtrTraits<U>::Release(aPtr);
-    }
-  };
-  template<class U>
-  struct ConstRemovingRefPtrTraits<const U>
-  {
-    static void AddRef(const U* aPtr) {
-      mozilla::RefPtrTraits<U>::AddRef(const_cast<U*>(aPtr));
-    }
-    static void Release(const U* aPtr) {
-      mozilla::RefPtrTraits<U>::Release(const_cast<U*>(aPtr));
-    }
-  };
-};
-
-class nsCycleCollectionTraversalCallback;
-template <typename T>
-void
-CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
-                         T* aChild, const char* aName, uint32_t aFlags);
-
-template <typename T>
-inline void
-ImplCycleCollectionUnlink(RefPtr<T>& aField)
-{
-  aField = nullptr;
-}
-
-template <typename T>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            RefPtr<T>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
-}
-
-template <class T>
-inline RefPtr<T>*
-address_of(RefPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-
-template <class T>
-inline const RefPtr<T>*
-address_of(const RefPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-
-template <class T>
-class RefPtrGetterAddRefs
-# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-{
-public:
-  explicit
-  RefPtrGetterAddRefs(RefPtr<T>& aSmartPtr)
-    : mTargetSmartPtr(aSmartPtr)
-  {
-
-  }
-
-  operator void**()
-  {
-    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-  }
-
-  operator T**()
-  {
-    return mTargetSmartPtr.StartAssignment();
-  }
-
-  T*&
-  operator*()
-  {
-    return *(mTargetSmartPtr.StartAssignment());
-  }
-
-private:
-  RefPtr<T>& mTargetSmartPtr;
-};
-
-template <class T>
-inline RefPtrGetterAddRefs<T>
-getter_AddRefs(RefPtr<T>& aSmartPtr)
-
-
-
-
-{
-  return RefPtrGetterAddRefs<T>(aSmartPtr);
-}
-
-
-
-
-template <class T, class U>
-inline bool
-operator==(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
-}
-
-
-template <class T, class U>
-inline bool
-operator!=(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
-}
-
-
-
-
-template <class T, class U>
-inline bool
-operator==(const RefPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator==(const U* aLhs, const RefPtr<T>& aRhs)
-{
-  return static_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator!=(const RefPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator!=(const U* aLhs, const RefPtr<T>& aRhs)
-{
-  return static_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator==(const RefPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator==(U* aLhs, const RefPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator!=(const RefPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator!=(U* aLhs, const RefPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
-}
-
-
-
-template <class T>
-inline bool
-operator==(const RefPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() == nullptr;
-}
-
-template <class T>
-inline bool
-operator==(decltype(nullptr), const RefPtr<T>& aRhs)
-{
-  return nullptr == aRhs.get();
-}
-
-template <class T>
-inline bool
-operator!=(const RefPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() != nullptr;
-}
-
-template <class T>
-inline bool
-operator!=(decltype(nullptr), const RefPtr<T>& aRhs)
-{
-  return nullptr != aRhs.get();
-}
-
-
-
-template <class T>
-inline already_AddRefed<T>
-do_AddRef(T* aObj)
-{
-  RefPtr<T> ref(aObj);
-  return ref.forget();
-}
-
-template <class T>
-inline already_AddRefed<T>
-do_AddRef(const RefPtr<T>& aObj)
-{
-  RefPtr<T> ref(aObj);
-  return ref.forget();
-}
-
-namespace mozilla {
-# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
-template<typename T, typename... Args>
-already_AddRefed<T>
-MakeAndAddRef(Args&&... aArgs)
-{
-  RefPtr<T> p(new T(Forward<Args>(aArgs)...));
-  return p.forget();
-}
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
-namespace mozilla {
-
-namespace detail {
-
-enum StorageType { AsBase, AsMember };
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
-template<typename A, typename B,
-         detail::StorageType =
-           IsEmpty<A>::value ? detail::AsBase : detail::AsMember,
-         detail::StorageType =
-           IsEmpty<B>::value && !IsBaseOf<A, B>::value && !IsBaseOf<B, A>::value
-           ? detail::AsBase
-           : detail::AsMember>
-struct PairHelper;
-
-template<typename A, typename B>
-struct PairHelper<A, B, AsMember, AsMember>
-{
-protected:
-  template<typename AArg, typename BArg>
-  PairHelper(AArg&& aA, BArg&& aB)
-    : mFirstA(Forward<AArg>(aA)),
-      mSecondB(Forward<BArg>(aB))
-  {}
-
-  A& first() { return mFirstA; }
-  const A& first() const { return mFirstA; }
-  B& second() { return mSecondB; }
-  const B& second() const { return mSecondB; }
-
-  void swap(PairHelper& aOther)
-  {
-    Swap(mFirstA, aOther.mFirstA);
-    Swap(mSecondB, aOther.mSecondB);
-  }
-
-private:
-  A mFirstA;
-  B mSecondB;
-};
-
-template<typename A, typename B>
-struct PairHelper<A, B, AsMember, AsBase> : private B
-{
-protected:
-  template<typename AArg, typename BArg>
-  PairHelper(AArg&& aA, BArg&& aB)
-    : B(Forward<BArg>(aB)),
-      mFirstA(Forward<AArg>(aA))
-  {}
-
-  A& first() { return mFirstA; }
-  const A& first() const { return mFirstA; }
-  B& second() { return *this; }
-  const B& second() const { return *this; }
-
-  void swap(PairHelper& aOther)
-  {
-    Swap(mFirstA, aOther.mFirstA);
-    Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
-  }
-
-private:
-  A mFirstA;
-};
-
-template<typename A, typename B>
-struct PairHelper<A, B, AsBase, AsMember> : private A
-{
-protected:
-  template<typename AArg, typename BArg>
-  PairHelper(AArg&& aA, BArg&& aB)
-    : A(Forward<AArg>(aA)),
-      mSecondB(Forward<BArg>(aB))
-  {}
-
-  A& first() { return *this; }
-  const A& first() const { return *this; }
-  B& second() { return mSecondB; }
-  const B& second() const { return mSecondB; }
-
-  void swap(PairHelper& aOther)
-  {
-    Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
-    Swap(mSecondB, aOther.mSecondB);
-  }
-
-private:
-  B mSecondB;
-};
-
-template<typename A, typename B>
-struct PairHelper<A, B, AsBase, AsBase> : private A, private B
-{
-protected:
-  template<typename AArg, typename BArg>
-  PairHelper(AArg&& aA, BArg&& aB)
-    : A(Forward<AArg>(aA)),
-      B(Forward<BArg>(aB))
-  {}
-
-  A& first() { return static_cast<A&>(*this); }
-  const A& first() const { return static_cast<A&>(*this); }
-  B& second() { return static_cast<B&>(*this); }
-  const B& second() const { return static_cast<B&>(*this); }
-
-  void swap(PairHelper& aOther)
-  {
-    Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
-    Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
-  }
-};
-
-}
-# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
-template<typename A, typename B>
-struct Pair
-  : private detail::PairHelper<A, B>
-{
-  typedef typename detail::PairHelper<A, B> Base;
-
-public:
-  template<typename AArg, typename BArg>
-  Pair(AArg&& aA, BArg&& aB)
-    : Base(Forward<AArg>(aA), Forward<BArg>(aB))
-  {}
-
-  Pair(Pair&& aOther)
-    : Base(Move(aOther.first()), Move(aOther.second()))
-  { }
-
-  Pair(const Pair& aOther) = default;
-
-  Pair& operator=(Pair&& aOther)
-  {
-    do { } while (0);
-
-    first() = Move(aOther.first());
-    second() = Move(aOther.second());
-
-    return *this;
-  }
-
-  Pair& operator=(const Pair& aOther) = default;
-
-
-  using Base::first;
-
-  using Base::second;
-
-
-  void swap(Pair& aOther) { Base::swap(aOther); }
-};
-
-template<typename A, class B>
-void
-Swap(Pair<A, B>& aX, Pair<A, B>& aY)
-{
-  aX.swap(aY);
-}
-# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Pair.h"
-template<typename A, typename B>
-Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
-     typename RemoveCV<typename RemoveReference<B>::Type>::Type>
-MakePair(A&& aA, B&& aB)
-{
-  return
-    Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
-         typename RemoveCV<typename RemoveReference<B>::Type>::Type>(
-             Forward<A>(aA),
-             Forward<B>(aB));
-}
-
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h" 2
-
-
-namespace mozilla {
-
-template<typename T> class DefaultDelete;
-template<typename T, class D = DefaultDelete<T>> class UniquePtr;
-
-}
-
-namespace mozilla {
-
-namespace detail {
-
-struct HasPointerTypeHelper
-{
-  template <class U> static double Test(...);
-  template <class U> static char Test(typename U::pointer* = 0);
-};
-
-template <class T>
-class HasPointerType : public IntegralConstant<bool, sizeof(HasPointerTypeHelper::Test<T>(0)) == 1>
-{
-};
-
-template <class T, class D, bool = HasPointerType<D>::value>
-struct PointerTypeImpl
-{
-  typedef typename D::pointer Type;
-};
-
-template <class T, class D>
-struct PointerTypeImpl<T, D, false>
-{
-  typedef T* Type;
-};
-
-template <class T, class D>
-struct PointerType
-{
-  typedef typename PointerTypeImpl<T, typename RemoveReference<D>::Type>::Type Type;
-};
-
-}
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
-template<typename T, class D>
-class UniquePtr
-{
-public:
-  typedef T ElementType;
-  typedef D DeleterType;
-  typedef typename detail::PointerType<T, DeleterType>::Type Pointer;
-
-private:
-  Pair<Pointer, DeleterType> mTuple;
-
-  Pointer& ptr() { return mTuple.first(); }
-  const Pointer& ptr() const { return mTuple.first(); }
-
-  DeleterType& del() { return mTuple.second(); }
-  const DeleterType& del() const { return mTuple.second(); }
-
-public:
-
-
-
-  constexpr UniquePtr()
-    : mTuple(static_cast<Pointer>(nullptr), DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-
-
-
-  explicit UniquePtr(Pointer aPtr)
-    : mTuple(aPtr, DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-  UniquePtr(Pointer aPtr,
-            typename Conditional<IsReference<D>::value,
-                                 D,
-                                 const D&>::Type aD1)
-    : mTuple(aPtr, aD1)
-  {}
-# 254 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
-  UniquePtr(Pointer aPtr,
-            typename RemoveReference<D>::Type&& aD2)
-    : mTuple(aPtr, Move(aD2))
-  {
-    static_assert(!IsReference<D>::value,
-                  "rvalue deleter can't be stored by reference");
-  }
-
-  UniquePtr(UniquePtr&& aOther)
-    : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
-  {}
-
-
-  UniquePtr(decltype(nullptr))
-    : mTuple(nullptr, DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-  template<typename U, class E>
-
-  UniquePtr(UniquePtr<U, E>&& aOther,
-            typename EnableIf<IsConvertible<typename UniquePtr<U, E>::Pointer,
-                                            Pointer>::value &&
-                              !IsArray<U>::value &&
-                              (IsReference<D>::value
-                               ? IsSame<D, E>::value
-                               : IsConvertible<E, D>::value),
-                              int>::Type aDummy = 0)
-    : mTuple(aOther.release(), Forward<E>(aOther.get_deleter()))
-  {
-  }
-
-  ~UniquePtr() { reset(nullptr); }
-
-  UniquePtr& operator=(UniquePtr&& aOther)
-  {
-    reset(aOther.release());
-    get_deleter() = Forward<DeleterType>(aOther.get_deleter());
-    return *this;
-  }
-
-  template<typename U, typename E>
-  UniquePtr& operator=(UniquePtr<U, E>&& aOther)
-  {
-    static_assert(IsConvertible<typename UniquePtr<U, E>::Pointer,
-                                Pointer>::value,
-                  "incompatible UniquePtr pointees");
-    static_assert(!IsArray<U>::value,
-                  "can't assign from UniquePtr holding an array");
-
-    reset(aOther.release());
-    get_deleter() = Forward<E>(aOther.get_deleter());
-    return *this;
-  }
-
-  UniquePtr& operator=(decltype(nullptr))
-  {
-    reset(nullptr);
-    return *this;
-  }
-
-  T& operator*() const { return *get(); }
-  Pointer operator->() const
-  {
-    do { } while (0);
-    return get();
-  }
-
-  explicit operator bool() const { return get() != nullptr; }
-
-  Pointer get() const { return ptr(); }
-
-  DeleterType& get_deleter() { return del(); }
-  const DeleterType& get_deleter() const { return del(); }
-
-  __attribute__ ((warn_unused_result)) Pointer release()
-  {
-    Pointer p = ptr();
-    ptr() = nullptr;
-    return p;
-  }
-
-  void reset(Pointer aPtr = Pointer())
-  {
-    Pointer old = ptr();
-    ptr() = aPtr;
-    if (old != nullptr) {
-      get_deleter()(old);
-    }
-  }
-
-  void swap(UniquePtr& aOther)
-  {
-    mTuple.swap(aOther.mTuple);
-  }
-
-  UniquePtr(const UniquePtr& aOther) = delete;
-  void operator=(const UniquePtr& aOther) = delete;
-};
-
-
-
-
-
-template<typename T, class D>
-class UniquePtr<T[], D>
-{
-public:
-  typedef T* Pointer;
-  typedef T ElementType;
-  typedef D DeleterType;
-
-private:
-  Pair<Pointer, DeleterType> mTuple;
-
-public:
-
-
-
-  constexpr UniquePtr()
-    : mTuple(static_cast<Pointer>(nullptr), DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-
-
-
-  explicit UniquePtr(Pointer aPtr)
-    : mTuple(aPtr, DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-
-
-
-
-
-  template<typename U>
-  UniquePtr(U&& aU,
-            typename EnableIf<IsPointer<U>::value &&
-                              IsConvertible<U, Pointer>::value,
-                              int>::Type aDummy = 0)
-  = delete;
-
-  UniquePtr(Pointer aPtr,
-            typename Conditional<IsReference<D>::value,
-                                 D,
-                                 const D&>::Type aD1)
-    : mTuple(aPtr, aD1)
-  {}
-
-
-
-
-
-  UniquePtr(Pointer aPtr,
-            typename RemoveReference<D>::Type&& aD2)
-    : mTuple(aPtr, Move(aD2))
-  {
-    static_assert(!IsReference<D>::value,
-                  "rvalue deleter can't be stored by reference");
-  }
-
-
-  template<typename U, typename V>
-  UniquePtr(U&& aU, V&& aV,
-            typename EnableIf<IsPointer<U>::value &&
-                              IsConvertible<U, Pointer>::value,
-                              int>::Type aDummy = 0)
-  = delete;
-
-  UniquePtr(UniquePtr&& aOther)
-    : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
-  {}
-
-
-  UniquePtr(decltype(nullptr))
-    : mTuple(nullptr, DeleterType())
-  {
-    static_assert(!IsPointer<D>::value, "must provide a deleter instance");
-    static_assert(!IsReference<D>::value, "must provide a deleter instance");
-  }
-
-  ~UniquePtr() { reset(nullptr); }
-
-  UniquePtr& operator=(UniquePtr&& aOther)
-  {
-    reset(aOther.release());
-    get_deleter() = Forward<DeleterType>(aOther.get_deleter());
-    return *this;
-  }
-
-  UniquePtr& operator=(decltype(nullptr))
-  {
-    reset();
-    return *this;
-  }
-
-  explicit operator bool() const { return get() != nullptr; }
-
-  T& operator[](decltype(sizeof(int)) aIndex) const { return get()[aIndex]; }
-  Pointer get() const { return mTuple.first(); }
-
-  DeleterType& get_deleter() { return mTuple.second(); }
-  const DeleterType& get_deleter() const { return mTuple.second(); }
-
-  __attribute__ ((warn_unused_result)) Pointer release()
-  {
-    Pointer p = mTuple.first();
-    mTuple.first() = nullptr;
-    return p;
-  }
-
-  void reset(Pointer aPtr = Pointer())
-  {
-    Pointer old = mTuple.first();
-    mTuple.first() = aPtr;
-    if (old != nullptr) {
-      mTuple.second()(old);
-    }
-  }
-
-  void reset(decltype(nullptr))
-  {
-    Pointer old = mTuple.first();
-    mTuple.first() = nullptr;
-    if (old != nullptr) {
-      mTuple.second()(old);
-    }
-  }
-
-  template<typename U>
-  void reset(U) = delete;
-
-  void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
-
-  UniquePtr(const UniquePtr& aOther) = delete;
-  void operator=(const UniquePtr& aOther) = delete;
-};
-# 513 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
-template<typename T>
-class DefaultDelete
-{
-public:
-  constexpr DefaultDelete() {}
-
-  template<typename U>
-               DefaultDelete(const DefaultDelete<U>& aOther,
-                             typename EnableIf<mozilla::IsConvertible<U*, T*>::value,
-                                               int>::Type aDummy = 0)
-  {}
-
-  void operator()(T* aPtr) const
-  {
-    static_assert(sizeof(T) > 0, "T must be complete");
-    delete aPtr;
-  }
-};
-
-
-template<typename T>
-class DefaultDelete<T[]>
-{
-public:
-  constexpr DefaultDelete() {}
-
-  void operator()(T* aPtr) const
-  {
-    static_assert(sizeof(T) > 0, "T must be complete");
-    delete[] aPtr;
-  }
-
-  template<typename U>
-  void operator()(U* aPtr) const = delete;
-};
-
-template<typename T, class D>
-void
-Swap(UniquePtr<T, D>& aX, UniquePtr<T, D>& aY)
-{
-  aX.swap(aY);
-}
-
-template<typename T, class D, typename U, class E>
-bool
-operator==(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY)
-{
-  return aX.get() == aY.get();
-}
-
-template<typename T, class D, typename U, class E>
-bool
-operator!=(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY)
-{
-  return aX.get() != aY.get();
-}
-
-template<typename T, class D>
-bool
-operator==(const UniquePtr<T, D>& aX, decltype(nullptr))
-{
-  return !aX;
-}
-
-template<typename T, class D>
-bool
-operator==(decltype(nullptr), const UniquePtr<T, D>& aX)
-{
-  return !aX;
-}
-
-template<typename T, class D>
-bool
-operator!=(const UniquePtr<T, D>& aX, decltype(nullptr))
-{
-  return bool(aX);
-}
-
-template<typename T, class D>
-bool
-operator!=(decltype(nullptr), const UniquePtr<T, D>& aX)
-{
-  return bool(aX);
-}
-
-
-
-namespace detail {
-
-template<typename T>
-struct UniqueSelector
-{
-  typedef UniquePtr<T> SingleObject;
-};
-
-template<typename T>
-struct UniqueSelector<T[]>
-{
-  typedef UniquePtr<T[]> UnknownBound;
-};
-
-template<typename T, decltype(sizeof(int)) N>
-struct UniqueSelector<T[N]>
-{
-  typedef UniquePtr<T[N]> KnownBound;
-};
-
-}
-# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UniquePtr.h"
-template<typename T, typename... Args>
-typename detail::UniqueSelector<T>::SingleObject
-MakeUnique(Args&&... aArgs)
-{
-  return UniquePtr<T>(new T(Forward<Args>(aArgs)...));
-}
-
-template<typename T>
-typename detail::UniqueSelector<T>::UnknownBound
-MakeUnique(decltype(sizeof(int)) aN)
-{
-  typedef typename RemoveExtent<T>::Type ArrayType;
-  return UniquePtr<T>(new ArrayType[aN]());
-}
-
-template<typename T, typename... Args>
-typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(Args&&... aArgs) = delete;
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArrayForwardDeclare.h" 2
-
-template<class E>
-class nsTArray;
-
-template<class E>
-class FallibleTArray;
-
-template<class E, size_t N>
-class AutoTArray;
-
-template<class E>
-using InfallibleTArray = nsTArray<E>;
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h" 2
-
-
-namespace mozilla {
-
-
-
-
-
-template<typename T>
-class AlignmentFinder
-{
-  struct Aligner
-  {
-    char mChar;
-    T mT;
-  };
-
-public:
-  static const size_t alignment = sizeof(Aligner) - sizeof(T);
-};
-# 64 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Alignment.h"
-template<size_t Align>
-struct AlignedElem;
-
-
-
-
-
-
-template<>
-struct AlignedElem<1>
-{
-  uint8_t elem __attribute__((aligned(1)));
-};
-
-template<>
-struct AlignedElem<2>
-{
-  uint8_t elem __attribute__((aligned(2)));
-};
-
-template<>
-struct AlignedElem<4>
-{
-  uint8_t elem __attribute__((aligned(4)));
-};
-
-template<>
-struct AlignedElem<8>
-{
-  uint8_t elem __attribute__((aligned(8)));
-};
-
-template<>
-struct AlignedElem<16>
-{
-  uint8_t elem __attribute__((aligned(16)));
-};
-
-template<typename T>
-struct AlignedStorage2
-{
-  union U
-  {
-    char mBytes[sizeof(T)];
-    uint64_t mDummy;
-  } u;
-
-  const T* addr() const { return reinterpret_cast<const T*>(u.mBytes); }
-  T* addr() { return static_cast<T*>(static_cast<void*>(u.mBytes)); }
-
-  AlignedStorage2() = default;
-
-
-
-  AlignedStorage2(const AlignedStorage2&) = delete;
-  void operator=(const AlignedStorage2&) = delete;
-};
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-  struct input_iterator_tag { };
-
-
-  struct output_iterator_tag { };
-
-
-  struct forward_iterator_tag : public input_iterator_tag { };
-
-
-
-  struct bidirectional_iterator_tag : public forward_iterator_tag { };
-
-
-
-  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
-# 116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
-           typename _Pointer = _Tp*, typename _Reference = _Tp&>
-    struct iterator
-    {
-
-      typedef _Category iterator_category;
-
-      typedef _Tp value_type;
-
-      typedef _Distance difference_type;
-
-      typedef _Pointer pointer;
-
-      typedef _Reference reference;
-    };
-# 143 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-  template<typename _Iterator, typename = __void_t<>>
-    struct __iterator_traits { };
-
-  template<typename _Iterator>
-    struct __iterator_traits<_Iterator,
-        __void_t<typename _Iterator::iterator_category,
-          typename _Iterator::value_type,
-          typename _Iterator::difference_type,
-          typename _Iterator::pointer,
-          typename _Iterator::reference>>
-    {
-      typedef typename _Iterator::iterator_category iterator_category;
-      typedef typename _Iterator::value_type value_type;
-      typedef typename _Iterator::difference_type difference_type;
-      typedef typename _Iterator::pointer pointer;
-      typedef typename _Iterator::reference reference;
-    };
-
-  template<typename _Iterator>
-    struct iterator_traits
-    : public __iterator_traits<_Iterator> { };
-# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-  template<typename _Tp>
-    struct iterator_traits<_Tp*>
-    {
-      typedef random_access_iterator_tag iterator_category;
-      typedef _Tp value_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef _Tp& reference;
-    };
-
-
-  template<typename _Tp>
-    struct iterator_traits<const _Tp*>
-    {
-      typedef random_access_iterator_tag iterator_category;
-      typedef _Tp value_type;
-      typedef ptrdiff_t difference_type;
-      typedef const _Tp* pointer;
-      typedef const _Tp& reference;
-    };
-
-
-
-
-
-  template<typename _Iter>
-    inline typename iterator_traits<_Iter>::iterator_category
-    __iterator_category(const _Iter&)
-    { return typename iterator_traits<_Iter>::iterator_category(); }
-# 230 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_types.h" 3
-  template<typename _InIter>
-    using _RequireInputIter = typename
-      enable_if<is_convertible<typename
-  iterator_traits<_InIter>::iterator_category,
-          input_iterator_tag>::value>::type;
-
-
-
-}
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/assertions.h" 1 3
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template <typename> struct _List_iterator;
-  template <typename> struct _List_const_iterator;
-
-
-
-
-  template<typename _InputIterator>
-    inline typename iterator_traits<_InputIterator>::difference_type
-    __distance(_InputIterator __first, _InputIterator __last,
-               input_iterator_tag)
-    {
-
-
-
-      typename iterator_traits<_InputIterator>::difference_type __n = 0;
-      while (__first != __last)
- {
-   ++__first;
-   ++__n;
- }
-      return __n;
-    }
-
-  template<typename _RandomAccessIterator>
-    inline typename iterator_traits<_RandomAccessIterator>::difference_type
-    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
-               random_access_iterator_tag)
-    {
-
-
-
-      return __last - __first;
-    }
-
-
-
-  template<typename _Tp>
-    ptrdiff_t
-    __distance(std::_List_iterator<_Tp>,
-        std::_List_iterator<_Tp>,
-        input_iterator_tag);
-
-  template<typename _Tp>
-    ptrdiff_t
-    __distance(std::_List_const_iterator<_Tp>,
-        std::_List_const_iterator<_Tp>,
-        input_iterator_tag);
-# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
-  template<typename _InputIterator>
-    inline typename iterator_traits<_InputIterator>::difference_type
-    distance(_InputIterator __first, _InputIterator __last)
-    {
-
-      return std::__distance(__first, __last,
-        std::__iterator_category(__first));
-    }
-
-  template<typename _InputIterator, typename _Distance>
-    inline void
-    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
-    {
-
-
-                                ;
-      while (__n--)
- ++__i;
-    }
-
-  template<typename _BidirectionalIterator, typename _Distance>
-    inline void
-    __advance(_BidirectionalIterator& __i, _Distance __n,
-       bidirectional_iterator_tag)
-    {
-
-
-
-      if (__n > 0)
-        while (__n--)
-   ++__i;
-      else
-        while (__n++)
-   --__i;
-    }
-
-  template<typename _RandomAccessIterator, typename _Distance>
-    inline void
-    __advance(_RandomAccessIterator& __i, _Distance __n,
-              random_access_iterator_tag)
-    {
-
-
-
-      __i += __n;
-    }
-# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator_base_funcs.h" 3
-  template<typename _InputIterator, typename _Distance>
-    inline void
-    advance(_InputIterator& __i, _Distance __n)
-    {
-
-      typename iterator_traits<_InputIterator>::difference_type __d = __n;
-      std::__advance(__i, __d, std::__iterator_category(__i));
-    }
-
-
-
-  template<typename _ForwardIterator>
-    inline _ForwardIterator
-    next(_ForwardIterator __x, typename
-  iterator_traits<_ForwardIterator>::difference_type __n = 1)
-    {
-
-
-
-      std::advance(__x, __n);
-      return __x;
-    }
-
-  template<typename _BidirectionalIterator>
-    inline _BidirectionalIterator
-    prev(_BidirectionalIterator __x, typename
-  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
-    {
-
-
-
-      std::advance(__x, -__n);
-      return __x;
-    }
-
-
-
-
-}
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 1 3
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
-extern "C++" {
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  struct __true_type { };
-  struct __false_type { };
-
-  template<bool>
-    struct __truth_type
-    { typedef __false_type __type; };
-
-  template<>
-    struct __truth_type<true>
-    { typedef __true_type __type; };
-
-
-
-  template<class _Sp, class _Tp>
-    struct __traitor
-    {
-      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
-      typedef typename __truth_type<__value>::__type __type;
-    };
-
-
-  template<typename, typename>
-    struct __are_same
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<typename _Tp>
-    struct __are_same<_Tp, _Tp>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_void
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_void<void>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_integer
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-
-
-
-  template<>
-    struct __is_integer<bool>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<signed char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_integer<wchar_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-  template<>
-    struct __is_integer<char16_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<char32_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_integer<short>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned short>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<int>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned int>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<long long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned long long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-# 278 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cpp_type_traits.h" 3
-  template<typename _Tp>
-    struct __is_floating
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-  template<>
-    struct __is_floating<float>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_floating<double>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_floating<long double>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_pointer
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<typename _Tp>
-    struct __is_pointer<_Tp*>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_arithmetic
-    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct __is_scalar
-    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct __is_char
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_char<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_char<wchar_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_byte
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_byte<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_byte<signed char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_byte<unsigned char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_move_iterator
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-
-  template<typename _Iterator>
-    inline _Iterator
-    __miter_base(_Iterator __it)
-    { return __it; }
-
-
-}
-}
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/type_traits.h" 3
-
-
-
-
-extern "C++" {
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<bool, typename>
-    struct __enable_if
-    { };
-
-  template<typename _Tp>
-    struct __enable_if<true, _Tp>
-    { typedef _Tp __type; };
-
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    struct __conditional_type
-    { typedef _Iftrue __type; };
-
-  template<typename _Iftrue, typename _Iffalse>
-    struct __conditional_type<false, _Iftrue, _Iffalse>
-    { typedef _Iffalse __type; };
-
-
-
-  template<typename _Tp>
-    struct __add_unsigned
-    {
-    private:
-      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-
-    public:
-      typedef typename __if_type::__type __type;
-    };
-
-  template<>
-    struct __add_unsigned<char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __add_unsigned<signed char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __add_unsigned<short>
-    { typedef unsigned short __type; };
-
-  template<>
-    struct __add_unsigned<int>
-    { typedef unsigned int __type; };
-
-  template<>
-    struct __add_unsigned<long>
-    { typedef unsigned long __type; };
-
-  template<>
-    struct __add_unsigned<long long>
-    { typedef unsigned long long __type; };
-
-
-  template<>
-    struct __add_unsigned<bool>;
-
-  template<>
-    struct __add_unsigned<wchar_t>;
-
-
-
-  template<typename _Tp>
-    struct __remove_unsigned
-    {
-    private:
-      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-
-    public:
-      typedef typename __if_type::__type __type;
-    };
-
-  template<>
-    struct __remove_unsigned<char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned short>
-    { typedef short __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned int>
-    { typedef int __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned long>
-    { typedef long __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned long long>
-    { typedef long long __type; };
-
-
-  template<>
-    struct __remove_unsigned<bool>;
-
-  template<>
-    struct __remove_unsigned<wchar_t>;
-
-
-
-  template<typename _Type>
-    inline bool
-    __is_null_pointer(_Type* __ptr)
-    { return __ptr == 0; }
-
-  template<typename _Type>
-    inline bool
-    __is_null_pointer(_Type)
-    { return false; }
-
-
-  inline bool
-  __is_null_pointer(std::nullptr_t)
-  { return true; }
-
-
-
-  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
-    struct __promote
-    { typedef double __type; };
-
-
-
-
-  template<typename _Tp>
-    struct __promote<_Tp, false>
-    { };
-
-  template<>
-    struct __promote<long double>
-    { typedef long double __type; };
-
-  template<>
-    struct __promote<double>
-    { typedef double __type; };
-
-  template<>
-    struct __promote<float>
-    { typedef float __type; };
-
-  template<typename _Tp, typename _Up,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type>
-    struct __promote_2
-    {
-      typedef __typeof__(_Tp2() + _Up2()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type,
-           typename _Vp2 = typename __promote<_Vp>::__type>
-    struct __promote_3
-    {
-      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type,
-           typename _Vp2 = typename __promote<_Vp>::__type,
-           typename _Wp2 = typename __promote<_Wp>::__type>
-    struct __promote_4
-    {
-      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
-    };
-
-
-}
-}
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ptr_traits.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  class __undefined;
-
-
-  template<typename _Tp>
-    struct __get_first_arg
-    { using type = __undefined; };
-
-  template<template<typename, typename...> class _Template, typename _Tp,
-           typename... _Types>
-    struct __get_first_arg<_Template<_Tp, _Types...>>
-    { using type = _Tp; };
-
-  template<typename _Tp>
-    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
-
-
-  template<typename _Tp, typename _Up>
-    struct __replace_first_arg
-    { using type = __undefined; };
-
-  template<template<typename, typename...> class _Template, typename _Up,
-           typename _Tp, typename... _Types>
-    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
-    { using type = _Template<_Up, _Types...>; };
-
-  template<typename _Tp, typename _Up>
-    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
-
-  template<typename _Tp>
-    using __make_not_void
-      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
-
-
-
-
-
-  template<typename _Ptr>
-    struct pointer_traits
-    {
-    private:
-      template<typename _Tp>
- using __element_type = typename _Tp::element_type;
-
-      template<typename _Tp>
- using __difference_type = typename _Tp::difference_type;
-
-      template<typename _Tp, typename _Up>
- using __rebind = typename _Tp::template rebind<_Up>;
-
-    public:
-
-      using pointer = _Ptr;
-
-
-      using element_type
- = __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>;
-
-
-      using difference_type
- = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
-
-
-      template<typename _Up>
-        using rebind
-   = __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>;
-
-      static _Ptr
-      pointer_to(__make_not_void<element_type>& __e)
-      { return _Ptr::pointer_to(__e); }
-
-      static_assert(!is_same<element_type, __undefined>::value,
-   "pointer type defines element_type or is like SomePointer<T, Args>");
-      static_assert(!is_same<rebind<element_type>, __undefined>::value,
-   "pointer type defines rebind<U> or is like SomePointer<T, Args>");
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct pointer_traits<_Tp*>
-    {
-
-      typedef _Tp* pointer;
-
-      typedef _Tp element_type;
-
-      typedef ptrdiff_t difference_type;
-
-      template<typename _Up>
-        using rebind = _Up*;
-
-
-
-
-
-
-      static pointer
-      pointer_to(__make_not_void<element_type>& __r) noexcept
-      { return std::addressof(__r); }
-    };
-
-
-  template<typename _Ptr, typename _Tp>
-    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
-
-
-}
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    class reverse_iterator
-    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
-        typename iterator_traits<_Iterator>::value_type,
-        typename iterator_traits<_Iterator>::difference_type,
-        typename iterator_traits<_Iterator>::pointer,
-                      typename iterator_traits<_Iterator>::reference>
-    {
-    protected:
-      _Iterator current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::difference_type difference_type;
-      typedef typename __traits_type::pointer pointer;
-      typedef typename __traits_type::reference reference;
-
-
-
-
-
-
-
-      reverse_iterator() : current() { }
-
-
-
-
-      explicit
-      reverse_iterator(iterator_type __x) : current(__x) { }
-
-
-
-
-      reverse_iterator(const reverse_iterator& __x)
-      : current(__x.current) { }
-
-
-
-
-
-      template<typename _Iter>
-        reverse_iterator(const reverse_iterator<_Iter>& __x)
- : current(__x.base()) { }
-
-
-
-
-      iterator_type
-      base() const
-      { return current; }
-# 160 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-      reference
-      operator*() const
-      {
- _Iterator __tmp = current;
- return *--__tmp;
-      }
-
-
-
-
-
-
-      pointer
-      operator->() const
-      { return &(operator*()); }
-
-
-
-
-
-
-      reverse_iterator&
-      operator++()
-      {
- --current;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator++(int)
-      {
- reverse_iterator __tmp = *this;
- --current;
- return __tmp;
-      }
-
-
-
-
-
-
-      reverse_iterator&
-      operator--()
-      {
- ++current;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator--(int)
-      {
- reverse_iterator __tmp = *this;
- ++current;
- return __tmp;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator+(difference_type __n) const
-      { return reverse_iterator(current - __n); }
-
-
-
-
-
-
-
-      reverse_iterator&
-      operator+=(difference_type __n)
-      {
- current -= __n;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator-(difference_type __n) const
-      { return reverse_iterator(current + __n); }
-
-
-
-
-
-
-
-      reverse_iterator&
-      operator-=(difference_type __n)
-      {
- current += __n;
- return *this;
-      }
-
-
-
-
-
-
-      reference
-      operator[](difference_type __n) const
-      { return *(*this + __n); }
-    };
-# 290 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    inline bool
-    operator==(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<(const reverse_iterator<_Iterator>& __x,
-       const reverse_iterator<_Iterator>& __y)
-    { return __y.base() < __x.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator!=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__x == __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>(const reverse_iterator<_Iterator>& __x,
-       const reverse_iterator<_Iterator>& __y)
-    { return __y < __x; }
-
-  template<typename _Iterator>
-    inline bool
-    operator<=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__y < __x); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__x < __y); }
-
-  template<typename _Iterator>
-
-
-
-
-
-    inline auto
-    operator-(const reverse_iterator<_Iterator>& __x,
-       const reverse_iterator<_Iterator>& __y)
-    -> decltype(__x.base() - __y.base())
-
-    { return __y.base() - __x.base(); }
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
-       const reverse_iterator<_Iterator>& __x)
-    { return reverse_iterator<_Iterator>(__x.base() - __n); }
-
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator==(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    { return __y.base() < __x.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator!=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__x == __y); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    { return __y < __x; }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__y < __x); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__x < __y); }
-
-  template<typename _IteratorL, typename _IteratorR>
-
-
-    inline auto
-    operator-(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    -> decltype(__y.base() - __x.base())
-
-
-
-
-
-    { return __y.base() - __x.base(); }
-
-
-
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    __make_reverse_iterator(_Iterator __i)
-    { return reverse_iterator<_Iterator>(__i); }
-
-
-
-
-
-
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    make_reverse_iterator(_Iterator __i)
-    { return reverse_iterator<_Iterator>(__i); }
-
-
-
-
-  template<typename _Iterator>
-    auto
-    __niter_base(reverse_iterator<_Iterator> __it)
-    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
-    { return __make_reverse_iterator(__niter_base(__it.base())); }
-
-  template<typename _Iterator>
-    struct __is_move_iterator<reverse_iterator<_Iterator> >
-      : __is_move_iterator<_Iterator>
-    { };
-
-  template<typename _Iterator>
-    auto
-    __miter_base(reverse_iterator<_Iterator> __it)
-    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
-    { return __make_reverse_iterator(__miter_base(__it.base())); }
-# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class back_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-
-    public:
-
-      typedef _Container container_type;
-
-
-      explicit
-      back_insert_iterator(_Container& __x)
-      : container(std::__addressof(__x)) { }
-# 483 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-      back_insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- container->push_back(__value);
- return *this;
-      }
-
-      back_insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- container->push_back(std::move(__value));
- return *this;
-      }
-
-
-
-      back_insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      back_insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      back_insert_iterator
-      operator++(int)
-      { return *this; }
-    };
-# 525 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container>
-    inline back_insert_iterator<_Container>
-    back_inserter(_Container& __x)
-    { return back_insert_iterator<_Container>(__x); }
-# 540 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class front_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-
-    public:
-
-      typedef _Container container_type;
-
-
-      explicit front_insert_iterator(_Container& __x)
-      : container(std::__addressof(__x)) { }
-# 574 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-      front_insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- container->push_front(__value);
- return *this;
-      }
-
-      front_insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- container->push_front(std::move(__value));
- return *this;
-      }
-
-
-
-      front_insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      front_insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      front_insert_iterator
-      operator++(int)
-      { return *this; }
-    };
-# 616 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container>
-    inline front_insert_iterator<_Container>
-    front_inserter(_Container& __x)
-    { return front_insert_iterator<_Container>(__x); }
-# 635 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-      typename _Container::iterator iter;
-
-    public:
-
-      typedef _Container container_type;
-
-
-
-
-
-      insert_iterator(_Container& __x, typename _Container::iterator __i)
-      : container(std::__addressof(__x)), iter(__i) {}
-# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-      insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- iter = container->insert(iter, __value);
- ++iter;
- return *this;
-      }
-
-      insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- iter = container->insert(iter, std::move(__value));
- ++iter;
- return *this;
-      }
-
-
-
-      insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      insert_iterator&
-      operator++(int)
-      { return *this; }
-    };
-# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Container, typename _Iterator>
-    inline insert_iterator<_Container>
-    inserter(_Container& __x, _Iterator __i)
-    {
-      return insert_iterator<_Container>(__x,
-      typename _Container::iterator(__i));
-    }
-
-
-
-
-}
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-# 754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  using std::iterator_traits;
-  using std::iterator;
-  template<typename _Iterator, typename _Container>
-    class __normal_iterator
-    {
-    protected:
-      _Iterator _M_current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::iterator_category iterator_category;
-      typedef typename __traits_type::value_type value_type;
-      typedef typename __traits_type::difference_type difference_type;
-      typedef typename __traits_type::reference reference;
-      typedef typename __traits_type::pointer pointer;
-
-      constexpr __normal_iterator() noexcept
-      : _M_current(_Iterator()) { }
-
-      explicit
-      __normal_iterator(const _Iterator& __i) noexcept
-      : _M_current(__i) { }
-
-
-      template<typename _Iter>
-        __normal_iterator(const __normal_iterator<_Iter,
-     typename __enable_if<
-              (std::__are_same<_Iter, typename _Container::pointer>::__value),
-        _Container>::__type>& __i) noexcept
-        : _M_current(__i.base()) { }
-
-
-      reference
-      operator*() const noexcept
-      { return *_M_current; }
-
-      pointer
-      operator->() const noexcept
-      { return _M_current; }
-
-      __normal_iterator&
-      operator++() noexcept
-      {
- ++_M_current;
- return *this;
-      }
-
-      __normal_iterator
-      operator++(int) noexcept
-      { return __normal_iterator(_M_current++); }
-
-
-      __normal_iterator&
-      operator--() noexcept
-      {
- --_M_current;
- return *this;
-      }
-
-      __normal_iterator
-      operator--(int) noexcept
-      { return __normal_iterator(_M_current--); }
-
-
-      reference
-      operator[](difference_type __n) const noexcept
-      { return _M_current[__n]; }
-
-      __normal_iterator&
-      operator+=(difference_type __n) noexcept
-      { _M_current += __n; return *this; }
-
-      __normal_iterator
-      operator+(difference_type __n) const noexcept
-      { return __normal_iterator(_M_current + __n); }
-
-      __normal_iterator&
-      operator-=(difference_type __n) noexcept
-      { _M_current -= __n; return *this; }
-
-      __normal_iterator
-      operator-(difference_type __n) const noexcept
-      { return __normal_iterator(_M_current - __n); }
-
-      const _Iterator&
-      base() const noexcept
-      { return _M_current; }
-    };
-# 854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() == __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() == __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() != __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() != __rhs.base(); }
-
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() < __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() < __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() > __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() > __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() <= __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() <= __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() >= __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() >= __rhs.base(); }
-
-
-
-
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-
-
-    inline auto
-    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-    -> decltype(__lhs.base() - __rhs.base())
-
-
-
-
-
-    { return __lhs.base() - __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline typename __normal_iterator<_Iterator, _Container>::difference_type
-    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() - __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline __normal_iterator<_Iterator, _Container>
-    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
-       __n, const __normal_iterator<_Iterator, _Container>& __i)
-    noexcept
-    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
-
-
-}
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Iterator, typename _Container>
-    _Iterator
-    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
-    { return __it.base(); }
-
-
-}
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 1006 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    class move_iterator
-    {
-    protected:
-      _Iterator _M_current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-      typedef typename __traits_type::reference __base_ref;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::iterator_category iterator_category;
-      typedef typename __traits_type::value_type value_type;
-      typedef typename __traits_type::difference_type difference_type;
-
-      typedef _Iterator pointer;
-
-
-      typedef typename conditional<is_reference<__base_ref>::value,
-    typename remove_reference<__base_ref>::type&&,
-    __base_ref>::type reference;
-
-      move_iterator()
-      : _M_current() { }
-
-      explicit
-      move_iterator(iterator_type __i)
-      : _M_current(__i) { }
-
-      template<typename _Iter>
- move_iterator(const move_iterator<_Iter>& __i)
- : _M_current(__i.base()) { }
-
-      iterator_type
-      base() const
-      { return _M_current; }
-
-      reference
-      operator*() const
-      { return static_cast<reference>(*_M_current); }
-
-      pointer
-      operator->() const
-      { return _M_current; }
-
-      move_iterator&
-      operator++()
-      {
- ++_M_current;
- return *this;
-      }
-
-      move_iterator
-      operator++(int)
-      {
- move_iterator __tmp = *this;
- ++_M_current;
- return __tmp;
-      }
-
-      move_iterator&
-      operator--()
-      {
- --_M_current;
- return *this;
-      }
-
-      move_iterator
-      operator--(int)
-      {
- move_iterator __tmp = *this;
- --_M_current;
- return __tmp;
-      }
-
-      move_iterator
-      operator+(difference_type __n) const
-      { return move_iterator(_M_current + __n); }
-
-      move_iterator&
-      operator+=(difference_type __n)
-      {
- _M_current += __n;
- return *this;
-      }
-
-      move_iterator
-      operator-(difference_type __n) const
-      { return move_iterator(_M_current - __n); }
-
-      move_iterator&
-      operator-=(difference_type __n)
-      {
- _M_current -= __n;
- return *this;
-      }
-
-      reference
-      operator[](difference_type __n) const
-      { return std::move(_M_current[__n]); }
-    };
-
-
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator==(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator==(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator!=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__x == __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator!=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__x == __y); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    { return __x.base() < __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<(const move_iterator<_Iterator>& __x,
-       const move_iterator<_Iterator>& __y)
-    { return __x.base() < __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__y < __x); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__y < __x); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    { return __y < __x; }
-
-  template<typename _Iterator>
-    inline bool
-    operator>(const move_iterator<_Iterator>& __x,
-       const move_iterator<_Iterator>& __y)
-    { return __y < __x; }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__x < __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline auto
-    operator-(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    -> decltype(__x.base() - __y.base())
-    { return __x.base() - __y.base(); }
-
-  template<typename _Iterator>
-    inline auto
-    operator-(const move_iterator<_Iterator>& __x,
-       const move_iterator<_Iterator>& __y)
-    -> decltype(__x.base() - __y.base())
-    { return __x.base() - __y.base(); }
-
-  template<typename _Iterator>
-    inline move_iterator<_Iterator>
-    operator+(typename move_iterator<_Iterator>::difference_type __n,
-       const move_iterator<_Iterator>& __x)
-    { return __x + __n; }
-
-  template<typename _Iterator>
-    inline move_iterator<_Iterator>
-    make_move_iterator(_Iterator __i)
-    { return move_iterator<_Iterator>(__i); }
-
-  template<typename _Iterator, typename _ReturnType
-    = typename conditional<__move_if_noexcept_cond
-      <typename iterator_traits<_Iterator>::value_type>::value,
-                _Iterator, move_iterator<_Iterator>>::type>
-    inline _ReturnType
-    __make_move_if_noexcept_iterator(_Iterator __i)
-    { return _ReturnType(__i); }
-
-
-
-  template<typename _Tp, typename _ReturnType
-    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
-      const _Tp*, move_iterator<_Tp*>>::type>
-    inline _ReturnType
-    __make_move_if_noexcept_iterator(_Tp* __i)
-    { return _ReturnType(__i); }
-
-
-
-  template<typename _Iterator>
-    auto
-    __niter_base(move_iterator<_Iterator> __it)
-    -> decltype(make_move_iterator(__niter_base(__it.base())))
-    { return make_move_iterator(__niter_base(__it.base())); }
-
-  template<typename _Iterator>
-    struct __is_move_iterator<move_iterator<_Iterator> >
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<typename _Iterator>
-    auto
-    __miter_base(move_iterator<_Iterator> __it)
-    -> decltype(__miter_base(__it.base()))
-    { return __miter_base(__it.base()); }
-
-
-}
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 1 3
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/memoryfwd.h" 3
-  template<typename>
-    class allocator;
-
-  template<>
-    class allocator<void>;
-
-
-  template<typename, typename>
-    struct uses_allocator;
-
-
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stringfwd.h" 3
-  template<class _CharT>
-    struct char_traits;
-
-  template<> struct char_traits<char>;
-
-
-  template<> struct char_traits<wchar_t>;
-
-
-
-
-  template<> struct char_traits<char16_t>;
-  template<> struct char_traits<char32_t>;
-
-
-namespace __cxx11 {
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT>,
-           typename _Alloc = allocator<_CharT> >
-    class basic_string;
-
-
-  typedef basic_string<char> string;
-
-
-
-  typedef basic_string<wchar_t> wstring;
-
-
-
-
-
-  typedef basic_string<char16_t> u16string;
-
-
-  typedef basic_string<char32_t> u32string;
-
-
-}
-
-
-
-
-}
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 1 3
-# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-
-
-
-
-# 1 "/usr/include/wchar.h" 1 3 4
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-namespace std
-{
-  using ::mbstate_t;
-}
-# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  using ::wint_t;
-
-  using ::btowc;
-  using ::fgetwc;
-  using ::fgetws;
-  using ::fputwc;
-  using ::fputws;
-  using ::fwide;
-  using ::fwprintf;
-  using ::fwscanf;
-  using ::getwc;
-  using ::getwchar;
-  using ::mbrlen;
-  using ::mbrtowc;
-  using ::mbsinit;
-  using ::mbsrtowcs;
-  using ::putwc;
-  using ::putwchar;
-
-  using ::swprintf;
-
-  using ::swscanf;
-  using ::ungetwc;
-  using ::vfwprintf;
-
-  using ::vfwscanf;
-
-
-  using ::vswprintf;
-
-
-  using ::vswscanf;
-
-  using ::vwprintf;
-
-  using ::vwscanf;
-
-  using ::wcrtomb;
-  using ::wcscat;
-  using ::wcscmp;
-  using ::wcscoll;
-  using ::wcscpy;
-  using ::wcscspn;
-  using ::wcsftime;
-  using ::wcslen;
-  using ::wcsncat;
-  using ::wcsncmp;
-  using ::wcsncpy;
-  using ::wcsrtombs;
-  using ::wcsspn;
-  using ::wcstod;
-
-  using ::wcstof;
-
-  using ::wcstok;
-  using ::wcstol;
-  using ::wcstoul;
-  using ::wcsxfrm;
-  using ::wctob;
-  using ::wmemcmp;
-  using ::wmemcpy;
-  using ::wmemmove;
-  using ::wmemset;
-  using ::wprintf;
-  using ::wscanf;
-  using ::wcschr;
-  using ::wcspbrk;
-  using ::wcsrchr;
-  using ::wcsstr;
-  using ::wmemchr;
-
-
-  inline wchar_t*
-  wcschr(wchar_t* __p, wchar_t __c)
-  { return wcschr(const_cast<const wchar_t*>(__p), __c); }
-
-  inline wchar_t*
-  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
-  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
-
-  inline wchar_t*
-  wcsrchr(wchar_t* __p, wchar_t __c)
-  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
-
-  inline wchar_t*
-  wcsstr(wchar_t* __s1, const wchar_t* __s2)
-  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
-
-  inline wchar_t*
-  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
-  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
-
-
-
-}
-
-
-
-
-
-
-
-namespace __gnu_cxx
-{
-
-
-
-
-
-  using ::wcstold;
-# 257 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-  using ::wcstoll;
-  using ::wcstoull;
-
-}
-
-namespace std
-{
-  using ::__gnu_cxx::wcstold;
-  using ::__gnu_cxx::wcstoll;
-  using ::__gnu_cxx::wcstoull;
-}
-# 277 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-namespace std
-{
-
-  using std::wcstof;
-
-
-  using std::vfwscanf;
-
-
-  using std::vswscanf;
-
-
-  using std::vwscanf;
-
-
-
-  using std::wcstold;
-  using std::wcstoll;
-  using std::wcstoull;
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 2 3
-# 68 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-  typedef long streamoff;
-# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-  typedef ptrdiff_t streamsize;
-# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-  template<typename _StateT>
-    class fpos
-    {
-    private:
-      streamoff _M_off;
-      _StateT _M_state;
-
-    public:
-
-
-
-
-      fpos()
-      : _M_off(0), _M_state() { }
-# 133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/postypes.h" 3
-      fpos(streamoff __off)
-      : _M_off(__off), _M_state() { }
-
-
-      operator streamoff() const { return _M_off; }
-
-
-      void
-      state(_StateT __st)
-      { _M_state = __st; }
-
-
-      _StateT
-      state() const
-      { return _M_state; }
-
-
-
-
-
-      fpos&
-      operator+=(streamoff __off)
-      {
- _M_off += __off;
- return *this;
-      }
-
-
-
-
-
-      fpos&
-      operator-=(streamoff __off)
-      {
- _M_off -= __off;
- return *this;
-      }
-
-
-
-
-
-
-
-      fpos
-      operator+(streamoff __off) const
-      {
- fpos __pos(*this);
- __pos += __off;
- return __pos;
-      }
-
-
-
-
-
-
-
-      fpos
-      operator-(streamoff __off) const
-      {
- fpos __pos(*this);
- __pos -= __off;
- return __pos;
-      }
-
-
-
-
-
-
-      streamoff
-      operator-(const fpos& __other) const
-      { return _M_off - __other._M_off; }
-    };
-
-
-
-
-
-
-  template<typename _StateT>
-    inline bool
-    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
-    { return streamoff(__lhs) == streamoff(__rhs); }
-
-  template<typename _StateT>
-    inline bool
-    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
-    { return streamoff(__lhs) != streamoff(__rhs); }
-
-
-
-
-
-  typedef fpos<mbstate_t> streampos;
-
-  typedef fpos<mbstate_t> wstreampos;
-
-
-
-  typedef fpos<mbstate_t> u16streampos;
-
-  typedef fpos<mbstate_t> u32streampos;
-
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 74 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iosfwd" 3
-  class ios_base;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_ios;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_streambuf;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_istream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_ostream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_iostream;
-
-
-namespace __cxx11 {
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT>,
-     typename _Alloc = allocator<_CharT> >
-    class basic_stringbuf;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT>,
-    typename _Alloc = allocator<_CharT> >
-    class basic_istringstream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT>,
-    typename _Alloc = allocator<_CharT> >
-    class basic_ostringstream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT>,
-    typename _Alloc = allocator<_CharT> >
-    class basic_stringstream;
-
-}
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_filebuf;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_ifstream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_ofstream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class basic_fstream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class istreambuf_iterator;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-    class ostreambuf_iterator;
-
-
-
-  typedef basic_ios<char> ios;
-
-
-  typedef basic_streambuf<char> streambuf;
-
-
-  typedef basic_istream<char> istream;
-
-
-  typedef basic_ostream<char> ostream;
-
-
-  typedef basic_iostream<char> iostream;
-
-
-  typedef basic_stringbuf<char> stringbuf;
-
-
-  typedef basic_istringstream<char> istringstream;
-
-
-  typedef basic_ostringstream<char> ostringstream;
-
-
-  typedef basic_stringstream<char> stringstream;
-
-
-  typedef basic_filebuf<char> filebuf;
-
-
-  typedef basic_ifstream<char> ifstream;
-
-
-  typedef basic_ofstream<char> ofstream;
-
-
-  typedef basic_fstream<char> fstream;
-
-
-
-  typedef basic_ios<wchar_t> wios;
-
-
-  typedef basic_streambuf<wchar_t> wstreambuf;
-
-
-  typedef basic_istream<wchar_t> wistream;
-
-
-  typedef basic_ostream<wchar_t> wostream;
-
-
-  typedef basic_iostream<wchar_t> wiostream;
-
-
-  typedef basic_stringbuf<wchar_t> wstringbuf;
-
-
-  typedef basic_istringstream<wchar_t> wistringstream;
-
-
-  typedef basic_ostringstream<wchar_t> wostringstream;
-
-
-  typedef basic_stringstream<wchar_t> wstringstream;
-
-
-  typedef basic_filebuf<wchar_t> wfilebuf;
-
-
-  typedef basic_ifstream<wchar_t> wifstream;
-
-
-  typedef basic_ofstream<wchar_t> wofstream;
-
-
-  typedef basic_fstream<wchar_t> wfstream;
-
-
-
-
-}
-# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 1 3
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 1 3
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functexcept.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  void
-  __throw_bad_exception(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_alloc(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_cast(void) __attribute__((__noreturn__));
-
-  void
-  __throw_bad_typeid(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_logic_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_domain_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_length_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_out_of_range(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
-    __attribute__((__format__(__gnu_printf__, 1, 2)));
-
-  void
-  __throw_runtime_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_range_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_overflow_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_underflow_error(const char*) __attribute__((__noreturn__));
-
-
-  void
-  __throw_ios_failure(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_system_error(int) __attribute__((__noreturn__));
-
-  void
-  __throw_future_error(int) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_function_call() __attribute__((__noreturn__));
-
-
-}
-# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
-  template<typename _Value>
-    struct __numeric_traits_integer
-    {
-
-      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
-      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
-
-
-
-      static const bool __is_signed = ((_Value)(-1) < 0);
-      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
-    };
-
-  template<typename _Value>
-    const _Value __numeric_traits_integer<_Value>::__min;
-
-  template<typename _Value>
-    const _Value __numeric_traits_integer<_Value>::__max;
-
-  template<typename _Value>
-    const bool __numeric_traits_integer<_Value>::__is_signed;
-
-  template<typename _Value>
-    const int __numeric_traits_integer<_Value>::__digits;
-# 99 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/numeric_traits.h" 3
-  template<typename _Value>
-    struct __numeric_traits_floating
-    {
-
-      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
-
-
-      static const bool __is_signed = true;
-      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
-      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
-    };
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__max_digits10;
-
-  template<typename _Value>
-    const bool __numeric_traits_floating<_Value>::__is_signed;
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__digits10;
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__max_exponent10;
-
-  template<typename _Value>
-    struct __numeric_traits
-    : public __conditional_type<std::__is_integer<_Value>::__value,
-    __numeric_traits_integer<_Value>,
-    __numeric_traits_floating<_Value> >::__type
-    { };
-
-
-}
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 1 3
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 76 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
-
-
-  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
-
-
-  template<typename...>
-    class tuple;
-
-  template<std::size_t...>
-    struct _Index_tuple;
-
-
-
-
-
-
-  template <bool, typename _T1, typename _T2>
-    struct _PCC
-    {
-      template <typename _U1, typename _U2>
-      static constexpr bool _ConstructiblePair()
-      {
- return __and_<is_constructible<_T1, const _U1&>,
-        is_constructible<_T2, const _U2&>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyConvertiblePair()
-      {
- return __and_<is_convertible<const _U1&, _T1>,
-        is_convertible<const _U2&, _T2>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _MoveConstructiblePair()
-      {
- return __and_<is_constructible<_T1, _U1&&>,
-        is_constructible<_T2, _U2&&>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyMoveConvertiblePair()
-      {
- return __and_<is_convertible<_U1&&, _T1>,
-        is_convertible<_U2&&, _T2>>::value;
-      }
-
-      template <bool __implicit, typename _U1, typename _U2>
-      static constexpr bool _CopyMovePair()
-      {
- using __do_converts = __and_<is_convertible<const _U1&, _T1>,
-      is_convertible<_U2&&, _T2>>;
- using __converts = typename conditional<__implicit,
-           __do_converts,
-           __not_<__do_converts>>::type;
- return __and_<is_constructible<_T1, const _U1&>,
-        is_constructible<_T2, _U2&&>,
-        __converts
-        >::value;
-      }
-
-      template <bool __implicit, typename _U1, typename _U2>
-      static constexpr bool _MoveCopyPair()
-      {
- using __do_converts = __and_<is_convertible<_U1&&, _T1>,
-      is_convertible<const _U2&, _T2>>;
- using __converts = typename conditional<__implicit,
-           __do_converts,
-           __not_<__do_converts>>::type;
- return __and_<is_constructible<_T1, _U1&&>,
-        is_constructible<_T2, const _U2&&>,
-        __converts
-        >::value;
-      }
-  };
-
-  template <typename _T1, typename _T2>
-    struct _PCC<false, _T1, _T2>
-    {
-      template <typename _U1, typename _U2>
-      static constexpr bool _ConstructiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyConvertiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _MoveConstructiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyMoveConvertiblePair()
-      {
- return false;
-      }
-  };
-# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-  template<typename _T1, typename _T2>
-    struct pair
-    {
-      typedef _T1 first_type;
-      typedef _T2 second_type;
-
-      _T1 first;
-      _T2 second;
-
-
-
-
-
-
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<__and_<
-                                     __is_implicitly_default_constructible<_U1>,
-                                     __is_implicitly_default_constructible<_U2>>
-                                   ::value, bool>::type = true>
-
-      constexpr pair()
-      : first(), second() { }
-
-
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<__and_<
-                       is_default_constructible<_U1>,
-                       is_default_constructible<_U2>,
-                       __not_<
-                         __and_<__is_implicitly_default_constructible<_U1>,
-                                __is_implicitly_default_constructible<_U2>>>>
-                                   ::value, bool>::type = false>
-      explicit constexpr pair()
-      : first(), second() { }
-# 233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-      using _PCCP = _PCC<true, _T1, _T2>;
-
-      template<typename _U1 = _T1, typename _U2=_T2, typename
-        enable_if<_PCCP::template
-      _ConstructiblePair<_U1, _U2>()
-                  && _PCCP::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
-      constexpr pair(const _T1& __a, const _T2& __b)
-      : first(__a), second(__b) { }
-
-       template<typename _U1 = _T1, typename _U2=_T2, typename
-  enable_if<_PCCP::template
-       _ConstructiblePair<_U1, _U2>()
-                   && !_PCCP::template
-       _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
-      explicit constexpr pair(const _T1& __a, const _T2& __b)
-      : first(__a), second(__b) { }
-# 261 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-      template <typename _U1, typename _U2>
-        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
-       || !is_same<_T2, _U2>::value,
-       _T1, _T2>;
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _ConstructiblePair<_U1, _U2>()
-                  && _PCCFP<_U1, _U2>::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-     bool>::type=true>
-        constexpr pair(const pair<_U1, _U2>& __p)
-        : first(__p.first), second(__p.second) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _ConstructiblePair<_U1, _U2>()
-    && !_PCCFP<_U1, _U2>::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(const pair<_U1, _U2>& __p)
- : first(__p.first), second(__p.second) { }
-
-      constexpr pair(const pair&) = default;
-      constexpr pair(pair&&) = default;
-
-
-      template<typename _U1, typename
-        enable_if<_PCCP::template
-      _MoveCopyPair<true, _U1, _T2>(),
-                         bool>::type=true>
-       constexpr pair(_U1&& __x, const _T2& __y)
-       : first(std::forward<_U1>(__x)), second(__y) { }
-
-      template<typename _U1, typename
-        enable_if<_PCCP::template
-      _MoveCopyPair<false, _U1, _T2>(),
-                         bool>::type=false>
-       explicit constexpr pair(_U1&& __x, const _T2& __y)
-       : first(std::forward<_U1>(__x)), second(__y) { }
-
-      template<typename _U2, typename
-        enable_if<_PCCP::template
-      _CopyMovePair<true, _T1, _U2>(),
-                         bool>::type=true>
-       constexpr pair(const _T1& __x, _U2&& __y)
-       : first(__x), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U2, typename
-        enable_if<_PCCP::template
-      _CopyMovePair<false, _T1, _U2>(),
-                         bool>::type=false>
-       explicit pair(const _T1& __x, _U2&& __y)
-       : first(__x), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCP::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && _PCCP::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
- constexpr pair(_U1&& __x, _U2&& __y)
- : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCP::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && !_PCCP::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(_U1&& __x, _U2&& __y)
- : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
-
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && _PCCFP<_U1, _U2>::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
- constexpr pair(pair<_U1, _U2>&& __p)
- : first(std::forward<_U1>(__p.first)),
-   second(std::forward<_U2>(__p.second)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && !_PCCFP<_U1, _U2>::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(pair<_U1, _U2>&& __p)
- : first(std::forward<_U1>(__p.first)),
-   second(std::forward<_U2>(__p.second)) { }
-
-      template<typename... _Args1, typename... _Args2>
-        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
-
-      pair&
-      operator=(typename conditional<
-  __and_<is_copy_assignable<_T1>,
-         is_copy_assignable<_T2>>::value,
-  const pair&, const __nonesuch&>::type __p)
-      {
- first = __p.first;
- second = __p.second;
- return *this;
-      }
-
-      pair&
-      operator=(typename conditional<
-  __not_<__and_<is_copy_assignable<_T1>,
-                is_copy_assignable<_T2>>>::value,
-  const pair&, const __nonesuch&>::type __p) = delete;
-
-      pair&
-      operator=(typename conditional<
-  __and_<is_move_assignable<_T1>,
-         is_move_assignable<_T2>>::value,
-  pair&&, __nonesuch&&>::type __p)
-      noexcept(__and_<is_nothrow_move_assignable<_T1>,
-               is_nothrow_move_assignable<_T2>>::value)
-      {
- first = std::forward<first_type>(__p.first);
- second = std::forward<second_type>(__p.second);
- return *this;
-      }
-
-      template<typename _U1, typename _U2>
-      typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
-    is_assignable<_T2&, const _U2&>>::value,
-    pair&>::type
- operator=(const pair<_U1, _U2>& __p)
- {
-   first = __p.first;
-   second = __p.second;
-   return *this;
- }
-
-      template<typename _U1, typename _U2>
-      typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
-    is_assignable<_T2&, _U2&&>>::value,
-    pair&>::type
- operator=(pair<_U1, _U2>&& __p)
- {
-   first = std::forward<_U1>(__p.first);
-   second = std::forward<_U2>(__p.second);
-   return *this;
- }
-
-      void
-      swap(pair& __p)
-      noexcept(__is_nothrow_swappable<_T1>::value
-               && __is_nothrow_swappable<_T2>::value)
-      {
- using std::swap;
- swap(first, __p.first);
- swap(second, __p.second);
-      }
-
-    private:
-      template<typename... _Args1, std::size_t... _Indexes1,
-               typename... _Args2, std::size_t... _Indexes2>
-        pair(tuple<_Args1...>&, tuple<_Args2...>&,
-             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
-
-    };
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __x.first == __y.first && __x.second == __y.second; }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __x.first < __y.first
-      || (!(__y.first < __x.first) && __x.second < __y.second); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __y < __x; }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__x < __y); }
-
-
-
-
-
-  template<typename _T1, typename _T2>
-    inline void
-    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-# 490 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-  template<typename _T1, typename _T2>
-    constexpr pair<typename __decay_and_strip<_T1>::__type,
-                   typename __decay_and_strip<_T2>::__type>
-    make_pair(_T1&& __x, _T2&& __y)
-    {
-      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
-      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
-      typedef pair<__ds_type1, __ds_type2> __pair_type;
-      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
-    }
-# 510 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_pair.h" 3
-}
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 1 3
-# 48 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/debug/debug.h" 3
-namespace std
-{
-  namespace __debug { }
-}
-
-
-
-
-namespace __gnu_debug
-{
-  using namespace std::__debug;
-}
-# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/predefined_ops.h" 3
-namespace __gnu_cxx
-{
-namespace __ops
-{
-  struct _Iter_less_iter
-  {
-    template<typename _Iterator1, typename _Iterator2>
-      constexpr
-      bool
-      operator()(_Iterator1 __it1, _Iterator2 __it2) const
-      { return *__it1 < *__it2; }
-  };
-  constexpr
-  inline _Iter_less_iter
-  __iter_less_iter()
-  { return _Iter_less_iter(); }
-
-  struct _Iter_less_val
-  {
-    template<typename _Iterator, typename _Value>
-      bool
-      operator()(_Iterator __it, _Value& __val) const
-      { return *__it < __val; }
-    };
-
-  inline _Iter_less_val
-  __iter_less_val()
-  { return _Iter_less_val(); }
-
-  inline _Iter_less_val
-  __iter_comp_val(_Iter_less_iter)
-  { return _Iter_less_val(); }
-
-  struct _Val_less_iter
-  {
-    template<typename _Value, typename _Iterator>
-      bool
-      operator()(_Value& __val, _Iterator __it) const
-      { return __val < *__it; }
-    };
-
-  inline _Val_less_iter
-  __val_less_iter()
-  { return _Val_less_iter(); }
-
-  inline _Val_less_iter
-  __val_comp_iter(_Iter_less_iter)
-  { return _Val_less_iter(); }
-
-  struct _Iter_equal_to_iter
-  {
-    template<typename _Iterator1, typename _Iterator2>
-      bool
-      operator()(_Iterator1 __it1, _Iterator2 __it2) const
-      { return *__it1 == *__it2; }
-    };
-
-  inline _Iter_equal_to_iter
-  __iter_equal_to_iter()
-  { return _Iter_equal_to_iter(); }
-
-  struct _Iter_equal_to_val
-  {
-    template<typename _Iterator, typename _Value>
-      bool
-      operator()(_Iterator __it, _Value& __val) const
-      { return *__it == __val; }
-    };
-
-  inline _Iter_equal_to_val
-  __iter_equal_to_val()
-  { return _Iter_equal_to_val(); }
-
-  inline _Iter_equal_to_val
-  __iter_comp_val(_Iter_equal_to_iter)
-  { return _Iter_equal_to_val(); }
-
-  template<typename _Compare>
-    struct _Iter_comp_iter
-    {
-      _Compare _M_comp;
-      constexpr
-      _Iter_comp_iter(_Compare __comp)
- : _M_comp(__comp)
-      { }
-
-      template<typename _Iterator1, typename _Iterator2>
-        constexpr
-        bool
-        operator()(_Iterator1 __it1, _Iterator2 __it2)
-        { return bool(_M_comp(*__it1, *__it2)); }
-    };
-
-  template<typename _Compare>
-    constexpr
-    inline _Iter_comp_iter<_Compare>
-    __iter_comp_iter(_Compare __comp)
-    { return _Iter_comp_iter<_Compare>(__comp); }
-
-  template<typename _Compare>
-    struct _Iter_comp_val
-    {
-      _Compare _M_comp;
-
-      _Iter_comp_val(_Compare __comp)
- : _M_comp(__comp)
-      { }
-
-      template<typename _Iterator, typename _Value>
- bool
- operator()(_Iterator __it, _Value& __val)
- { return bool(_M_comp(*__it, __val)); }
-    };
-
-  template<typename _Compare>
-   inline _Iter_comp_val<_Compare>
-    __iter_comp_val(_Compare __comp)
-    { return _Iter_comp_val<_Compare>(__comp); }
-
-  template<typename _Compare>
-    inline _Iter_comp_val<_Compare>
-    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
-    { return _Iter_comp_val<_Compare>(__comp._M_comp); }
-
-  template<typename _Compare>
-    struct _Val_comp_iter
-    {
-      _Compare _M_comp;
-
-      _Val_comp_iter(_Compare __comp)
- : _M_comp(__comp)
-      { }
-
-      template<typename _Value, typename _Iterator>
- bool
- operator()(_Value& __val, _Iterator __it)
- { return bool(_M_comp(__val, *__it)); }
-    };
-
-  template<typename _Compare>
-    inline _Val_comp_iter<_Compare>
-    __val_comp_iter(_Compare __comp)
-    { return _Val_comp_iter<_Compare>(__comp); }
-
-  template<typename _Compare>
-    inline _Val_comp_iter<_Compare>
-    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
-    { return _Val_comp_iter<_Compare>(__comp._M_comp); }
-
-  template<typename _Value>
-    struct _Iter_equals_val
-    {
-      _Value& _M_value;
-
-      _Iter_equals_val(_Value& __value)
- : _M_value(__value)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return *__it == _M_value; }
-    };
-
-  template<typename _Value>
-    inline _Iter_equals_val<_Value>
-    __iter_equals_val(_Value& __val)
-    { return _Iter_equals_val<_Value>(__val); }
-
-  template<typename _Iterator1>
-    struct _Iter_equals_iter
-    {
-      typename std::iterator_traits<_Iterator1>::reference _M_ref;
-
-      _Iter_equals_iter(_Iterator1 __it1)
- : _M_ref(*__it1)
-      { }
-
-      template<typename _Iterator2>
- bool
- operator()(_Iterator2 __it2)
- { return *__it2 == _M_ref; }
-    };
-
-  template<typename _Iterator>
-    inline _Iter_equals_iter<_Iterator>
-    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
-    { return _Iter_equals_iter<_Iterator>(__it); }
-
-  template<typename _Predicate>
-    struct _Iter_pred
-    {
-      _Predicate _M_pred;
-
-      _Iter_pred(_Predicate __pred)
- : _M_pred(__pred)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return bool(_M_pred(*__it)); }
-    };
-
-  template<typename _Predicate>
-    inline _Iter_pred<_Predicate>
-    __pred_iter(_Predicate __pred)
-    { return _Iter_pred<_Predicate>(__pred); }
-
-  template<typename _Compare, typename _Value>
-    struct _Iter_comp_to_val
-    {
-      _Compare _M_comp;
-      _Value& _M_value;
-
-      _Iter_comp_to_val(_Compare __comp, _Value& __value)
- : _M_comp(__comp), _M_value(__value)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return bool(_M_comp(*__it, _M_value)); }
-    };
-
-  template<typename _Compare, typename _Value>
-    _Iter_comp_to_val<_Compare, _Value>
-    __iter_comp_val(_Compare __comp, _Value &__val)
-    { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
-
-  template<typename _Compare, typename _Iterator1>
-    struct _Iter_comp_to_iter
-    {
-      _Compare _M_comp;
-      typename std::iterator_traits<_Iterator1>::reference _M_ref;
-
-      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
- : _M_comp(__comp), _M_ref(*__it1)
-      { }
-
-      template<typename _Iterator2>
- bool
- operator()(_Iterator2 __it2)
- { return bool(_M_comp(*__it2, _M_ref)); }
-    };
-
-  template<typename _Compare, typename _Iterator>
-    inline _Iter_comp_to_iter<_Compare, _Iterator>
-    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
-    { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
-
-  template<typename _Predicate>
-    struct _Iter_negate
-    {
-      _Predicate _M_pred;
-
-      _Iter_negate(_Predicate __pred)
- : _M_pred(__pred)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return !bool(_M_pred(*__it)); }
-    };
-
-  template<typename _Predicate>
-    inline _Iter_negate<_Predicate>
-    __negate(_Iter_pred<_Predicate> __pred)
-    { return _Iter_negate<_Predicate>(__pred._M_pred); }
-
-}
-}
-# 72 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 118 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline void
-    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
-    {
-# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-      swap(*__a, *__b);
-
-    }
-# 164 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    _ForwardIterator2
-    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-  _ForwardIterator2 __first2)
-    {
-
-
-
-
-
-                                                       ;
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2)
- std::iter_swap(__first1, __first2);
-      return __first2;
-    }
-# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _Tp>
-    constexpr
-    inline const _Tp&
-    min(const _Tp& __a, const _Tp& __b)
-    {
-
-
-
-      if (__b < __a)
- return __b;
-      return __a;
-    }
-# 216 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _Tp>
-    constexpr
-    inline const _Tp&
-    max(const _Tp& __a, const _Tp& __b)
-    {
-
-
-
-      if (__a < __b)
- return __b;
-      return __a;
-    }
-# 240 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline const _Tp&
-    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
-    {
-
-      if (__comp(__b, __a))
- return __b;
-      return __a;
-    }
-# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline const _Tp&
-    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
-    {
-
-      if (__comp(__a, __b))
- return __b;
-      return __a;
-    }
-
-
-
-  template<typename _Iterator>
-    inline _Iterator
-    __niter_base(_Iterator __it)
-    { return __it; }
-
-
-
-
-
-
-
-  template<bool, bool, typename>
-    struct __copy_move
-    {
-      template<typename _II, typename _OI>
-        static _OI
-        __copy_m(_II __first, _II __last, _OI __result)
-        {
-   for (; __first != __last; ++__result, (void)++__first)
-     *__result = *__first;
-   return __result;
- }
-    };
-
-
-  template<typename _Category>
-    struct __copy_move<true, false, _Category>
-    {
-      template<typename _II, typename _OI>
-        static _OI
-        __copy_m(_II __first, _II __last, _OI __result)
-        {
-   for (; __first != __last; ++__result, (void)++__first)
-     *__result = std::move(*__first);
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move<false, false, random_access_iterator_tag>
-    {
-      template<typename _II, typename _OI>
-        static _OI
-        __copy_m(_II __first, _II __last, _OI __result)
-        {
-   typedef typename iterator_traits<_II>::difference_type _Distance;
-   for(_Distance __n = __last - __first; __n > 0; --__n)
-     {
-       *__result = *__first;
-       ++__first;
-       ++__result;
-     }
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move<true, false, random_access_iterator_tag>
-    {
-      template<typename _II, typename _OI>
-        static _OI
-        __copy_m(_II __first, _II __last, _OI __result)
-        {
-   typedef typename iterator_traits<_II>::difference_type _Distance;
-   for(_Distance __n = __last - __first; __n > 0; --__n)
-     {
-       *__result = std::move(*__first);
-       ++__first;
-       ++__result;
-     }
-   return __result;
- }
-    };
-
-
-  template<bool _IsMove>
-    struct __copy_move<_IsMove, true, random_access_iterator_tag>
-    {
-      template<typename _Tp>
-        static _Tp*
-        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
-        {
-
-   using __assignable = conditional<_IsMove,
-        is_move_assignable<_Tp>,
-        is_copy_assignable<_Tp>>;
-
-   static_assert( __assignable::type::value, "type is not assignable" );
-
-   const ptrdiff_t _Num = __last - __first;
-   if (_Num)
-     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
-   return __result + _Num;
- }
-    };
-
-  template<bool _IsMove, typename _II, typename _OI>
-    inline _OI
-    __copy_move_a(_II __first, _II __last, _OI __result)
-    {
-      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
-      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
-      typedef typename iterator_traits<_II>::iterator_category _Category;
-      const bool __simple = (__is_trivial(_ValueTypeI)
-                      && __is_pointer<_II>::__value
-                      && __is_pointer<_OI>::__value
-        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
-
-      return std::__copy_move<_IsMove, __simple,
-                       _Category>::__copy_m(__first, __last, __result);
-    }
-
-
-
-  template<typename _CharT>
-    struct char_traits;
-
-  template<typename _CharT, typename _Traits>
-    class istreambuf_iterator;
-
-  template<typename _CharT, typename _Traits>
-    class ostreambuf_iterator;
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
-    __copy_move_a2(_CharT*, _CharT*,
-     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
-    __copy_move_a2(const _CharT*, const _CharT*,
-     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-        _CharT*>::__type
-    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
-     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
-
-  template<bool _IsMove, typename _II, typename _OI>
-    inline _OI
-    __copy_move_a2(_II __first, _II __last, _OI __result)
-    {
-      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
-          std::__niter_base(__last),
-          std::__niter_base(__result)));
-    }
-# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II, typename _OI>
-    inline _OI
-    copy(_II __first, _II __last, _OI __result)
-    {
-
-
-
-
-                                                     ;
-
-      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
-       (std::__miter_base(__first), std::__miter_base(__last),
-        __result));
-    }
-# 477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II, typename _OI>
-    inline _OI
-    move(_II __first, _II __last, _OI __result)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__copy_move_a2<true>(std::__miter_base(__first),
-           std::__miter_base(__last), __result);
-    }
-
-
-
-
-
-
-  template<bool, bool, typename>
-    struct __copy_move_backward
-    {
-      template<typename _BI1, typename _BI2>
-        static _BI2
-        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
-        {
-   while (__first != __last)
-     *--__result = *--__last;
-   return __result;
- }
-    };
-
-
-  template<typename _Category>
-    struct __copy_move_backward<true, false, _Category>
-    {
-      template<typename _BI1, typename _BI2>
-        static _BI2
-        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
-        {
-   while (__first != __last)
-     *--__result = std::move(*--__last);
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move_backward<false, false, random_access_iterator_tag>
-    {
-      template<typename _BI1, typename _BI2>
-        static _BI2
-        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
-        {
-   typename iterator_traits<_BI1>::difference_type __n;
-   for (__n = __last - __first; __n > 0; --__n)
-     *--__result = *--__last;
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move_backward<true, false, random_access_iterator_tag>
-    {
-      template<typename _BI1, typename _BI2>
-        static _BI2
-        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
-        {
-   typename iterator_traits<_BI1>::difference_type __n;
-   for (__n = __last - __first; __n > 0; --__n)
-     *--__result = std::move(*--__last);
-   return __result;
- }
-    };
-
-
-  template<bool _IsMove>
-    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
-    {
-      template<typename _Tp>
-        static _Tp*
-        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
-        {
-
-   using __assignable = conditional<_IsMove,
-        is_move_assignable<_Tp>,
-        is_copy_assignable<_Tp>>;
-
-   static_assert( __assignable::type::value, "type is not assignable" );
-
-   const ptrdiff_t _Num = __last - __first;
-   if (_Num)
-     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
-   return __result - _Num;
- }
-    };
-
-  template<bool _IsMove, typename _BI1, typename _BI2>
-    inline _BI2
-    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
-      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
-      typedef typename iterator_traits<_BI1>::iterator_category _Category;
-      const bool __simple = (__is_trivial(_ValueType1)
-                      && __is_pointer<_BI1>::__value
-                      && __is_pointer<_BI2>::__value
-        && __are_same<_ValueType1, _ValueType2>::__value);
-
-      return std::__copy_move_backward<_IsMove, __simple,
-                                _Category>::__copy_move_b(__first,
-         __last,
-         __result);
-    }
-
-  template<bool _IsMove, typename _BI1, typename _BI2>
-    inline _BI2
-    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-      return _BI2(std::__copy_move_backward_a<_IsMove>
-    (std::__niter_base(__first), std::__niter_base(__last),
-     std::__niter_base(__result)));
-    }
-# 620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _BI1, typename _BI2>
-    inline _BI2
-    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
-       (std::__miter_base(__first), std::__miter_base(__last),
-        __result));
-    }
-# 656 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _BI1, typename _BI2>
-    inline _BI2
-    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
-      std::__miter_base(__last),
-      __result);
-    }
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
-    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
-       const _Tp& __value)
-    {
-      for (; __first != __last; ++__first)
- *__first = __value;
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
-    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
-      const _Tp& __value)
-    {
-      const _Tp __tmp = __value;
-      for (; __first != __last; ++__first)
- *__first = __tmp;
-    }
-
-
-  template<typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
-    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
-    {
-      const _Tp __tmp = __c;
-      if (const size_t __len = __last - __first)
- __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
-    }
-# 722 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline void
-    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
-    {
-
-
-
-                                                     ;
-
-      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
-      __value);
-    }
-
-  template<typename _OutputIterator, typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
-    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
-    {
-      for (__decltype(__n + 0) __niter = __n;
-    __niter > 0; --__niter, ++__first)
- *__first = __value;
-      return __first;
-    }
-
-  template<typename _OutputIterator, typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
-    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
-    {
-      const _Tp __tmp = __value;
-      for (__decltype(__n + 0) __niter = __n;
-    __niter > 0; --__niter, ++__first)
- *__first = __tmp;
-      return __first;
-    }
-
-  template<typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
-    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
-    {
-      std::__fill_a(__first, __first + __n, __c);
-      return __first + __n;
-    }
-# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _OI, typename _Size, typename _Tp>
-    inline _OI
-    fill_n(_OI __first, _Size __n, const _Tp& __value)
-    {
-
-
-
-      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
-    }
-
-  template<bool _BoolType>
-    struct __equal
-    {
-      template<typename _II1, typename _II2>
-        static bool
-        equal(_II1 __first1, _II1 __last1, _II2 __first2)
-        {
-   for (; __first1 != __last1; ++__first1, (void)++__first2)
-     if (!(*__first1 == *__first2))
-       return false;
-   return true;
- }
-    };
-
-  template<>
-    struct __equal<true>
-    {
-      template<typename _Tp>
-        static bool
-        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
-        {
-   if (const size_t __len = (__last1 - __first1))
-     return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
-   return true;
- }
-    };
-
-  template<typename _II1, typename _II2>
-    inline bool
-    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
-    {
-      typedef typename iterator_traits<_II1>::value_type _ValueType1;
-      typedef typename iterator_traits<_II2>::value_type _ValueType2;
-      const bool __simple = ((__is_integer<_ValueType1>::__value
-         || __is_pointer<_ValueType1>::__value)
-                      && __is_pointer<_II1>::__value
-                      && __is_pointer<_II2>::__value
-        && __are_same<_ValueType1, _ValueType2>::__value);
-
-      return std::__equal<__simple>::equal(__first1, __last1, __first2);
-    }
-
-  template<typename, typename>
-    struct __lc_rai
-    {
-      template<typename _II1, typename _II2>
-        static _II1
-        __newlast1(_II1, _II1 __last1, _II2, _II2)
-        { return __last1; }
-
-      template<typename _II>
-        static bool
-        __cnd2(_II __first, _II __last)
-        { return __first != __last; }
-    };
-
-  template<>
-    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
-    {
-      template<typename _RAI1, typename _RAI2>
-        static _RAI1
-        __newlast1(_RAI1 __first1, _RAI1 __last1,
-     _RAI2 __first2, _RAI2 __last2)
-        {
-   const typename iterator_traits<_RAI1>::difference_type
-     __diff1 = __last1 - __first1;
-   const typename iterator_traits<_RAI2>::difference_type
-     __diff2 = __last2 - __first2;
-   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
- }
-
-      template<typename _RAI>
-        static bool
-        __cnd2(_RAI, _RAI)
-        { return true; }
-    };
-
-  template<typename _II1, typename _II2, typename _Compare>
-    bool
-    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2,
-       _Compare __comp)
-    {
-      typedef typename iterator_traits<_II1>::iterator_category _Category1;
-      typedef typename iterator_traits<_II2>::iterator_category _Category2;
-      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
-
-      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
-      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
-    ++__first1, (void)++__first2)
- {
-   if (__comp(__first1, __first2))
-     return true;
-   if (__comp(__first2, __first1))
-     return false;
- }
-      return __first1 == __last1 && __first2 != __last2;
-    }
-
-  template<bool _BoolType>
-    struct __lexicographical_compare
-    {
-      template<typename _II1, typename _II2>
-        static bool __lc(_II1, _II1, _II2, _II2);
-    };
-
-  template<bool _BoolType>
-    template<typename _II1, typename _II2>
-      bool
-      __lexicographical_compare<_BoolType>::
-      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
-      {
- return std::__lexicographical_compare_impl(__first1, __last1,
-         __first2, __last2,
-     __gnu_cxx::__ops::__iter_less_iter());
-      }
-
-  template<>
-    struct __lexicographical_compare<true>
-    {
-      template<typename _Tp, typename _Up>
-        static bool
-        __lc(const _Tp* __first1, const _Tp* __last1,
-      const _Up* __first2, const _Up* __last2)
- {
-   const size_t __len1 = __last1 - __first1;
-   const size_t __len2 = __last2 - __first2;
-   if (const size_t __len = std::min(__len1, __len2))
-     if (int __result = __builtin_memcmp(__first1, __first2, __len))
-       return __result < 0;
-   return __len1 < __len2;
- }
-    };
-
-  template<typename _II1, typename _II2>
-    inline bool
-    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
-      _II2 __first2, _II2 __last2)
-    {
-      typedef typename iterator_traits<_II1>::value_type _ValueType1;
-      typedef typename iterator_traits<_II2>::value_type _ValueType2;
-      const bool __simple =
- (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
-  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
-  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
-  && __is_pointer<_II1>::__value
-  && __is_pointer<_II2>::__value);
-
-      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
-           __first2, __last2);
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    _ForwardIterator
-    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val, _Compare __comp)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _DistanceType __len = std::distance(__first, __last);
-
-      while (__len > 0)
- {
-   _DistanceType __half = __len >> 1;
-   _ForwardIterator __middle = __first;
-   std::advance(__middle, __half);
-   if (__comp(__middle, __val))
-     {
-       __first = __middle;
-       ++__first;
-       __len = __len - __half - 1;
-     }
-   else
-     __len = __half;
- }
-      return __first;
-    }
-# 982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline _ForwardIterator
-    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val)
-    {
-
-
-
-
-                                                                  ;
-
-      return std::__lower_bound(__first, __last, __val,
-    __gnu_cxx::__ops::__iter_less_val());
-    }
-
-
-
-  inline constexpr int
-  __lg(int __n)
-  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
-
-  inline constexpr unsigned
-  __lg(unsigned __n)
-  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
-
-  inline constexpr long
-  __lg(long __n)
-  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
-
-  inline constexpr unsigned long
-  __lg(unsigned long __n)
-  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
-
-  inline constexpr long long
-  __lg(long long __n)
-  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
-
-  inline constexpr unsigned long long
-  __lg(unsigned long long __n)
-  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
-# 1039 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    equal(_II1 __first1, _II1 __last1, _II2 __first2)
-    {
-
-
-
-
-
-
-                                                       ;
-
-      return std::__equal_aux(std::__niter_base(__first1),
-         std::__niter_base(__last1),
-         std::__niter_base(__first2));
-    }
-# 1071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    inline bool
-    equal(_IIter1 __first1, _IIter1 __last1,
-   _IIter2 __first2, _BinaryPredicate __binary_pred)
-    {
-
-
-
-                                                       ;
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2)
- if (!bool(__binary_pred(*__first1, *__first2)))
-   return false;
-      return true;
-    }
-# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      using _RATag = random_access_iterator_tag;
-      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
-      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
-      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
-      if (_RAIters())
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 != __d2)
-     return false;
-   return std::equal(__first1, __last1, __first2);
- }
-
-      for (; __first1 != __last1 && __first2 != __last2;
-   ++__first1, (void)++__first2)
- if (!(*__first1 == *__first2))
-   return false;
-      return __first1 == __last1 && __first2 == __last2;
-    }
-# 1153 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    inline bool
-    equal(_IIter1 __first1, _IIter1 __last1,
-   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
-    {
-
-
-
-                                                       ;
-                                                       ;
-
-      using _RATag = random_access_iterator_tag;
-      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
-      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
-      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
-      if (_RAIters())
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 != __d2)
-     return false;
-   return std::equal(__first1, __last1, __first2,
-           __binary_pred);
- }
-
-      for (; __first1 != __last1 && __first2 != __last2;
-   ++__first1, (void)++__first2)
- if (!bool(__binary_pred(*__first1, *__first2)))
-   return false;
-      return __first1 == __last1 && __first2 == __last2;
-    }
-# 1201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    lexicographical_compare(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2)
-    {
-# 1215 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-                                                       ;
-                                                       ;
-
-      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
-      std::__niter_base(__last1),
-      std::__niter_base(__first2),
-      std::__niter_base(__last2));
-    }
-# 1237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2, typename _Compare>
-    inline bool
-    lexicographical_compare(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2, _Compare __comp)
-    {
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__lexicographical_compare_impl
- (__first1, __last1, __first2, __last2,
-  __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    pair<_InputIterator1, _InputIterator2>
-    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
-    {
-      while (__first1 != __last1 && __binary_pred(__first1, __first2))
-        {
-   ++__first1;
-   ++__first2;
-        }
-      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
-    }
-# 1280 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2)
-    {
-
-
-
-
-
-
-                                                       ;
-
-      return std::__mismatch(__first1, __last1, __first2,
-        __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 1313 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
-    {
-
-
-
-                                                       ;
-
-      return std::__mismatch(__first1, __last1, __first2,
- __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-
-
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    pair<_InputIterator1, _InputIterator2>
-    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _BinaryPredicate __binary_pred)
-    {
-      while (__first1 != __last1 && __first2 != __last2
-      && __binary_pred(__first1, __first2))
-        {
-   ++__first1;
-   ++__first2;
-        }
-      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
-    }
-# 1360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__mismatch(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 1395 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2,
-      _BinaryPredicate __binary_pred)
-    {
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__mismatch(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-
-
-
-}
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-
-
-
-
-# 1 "/usr/include/wchar.h" 1 3 4
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
-  template<typename _CharT>
-    struct _Char_types
-    {
-      typedef unsigned long int_type;
-      typedef std::streampos pos_type;
-      typedef std::streamoff off_type;
-      typedef std::mbstate_t state_type;
-    };
-# 82 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
-  template<typename _CharT>
-    struct char_traits
-    {
-      typedef _CharT char_type;
-      typedef typename _Char_types<_CharT>::int_type int_type;
-      typedef typename _Char_types<_CharT>::pos_type pos_type;
-      typedef typename _Char_types<_CharT>::off_type off_type;
-      typedef typename _Char_types<_CharT>::state_type state_type;
-
-      static void
-      assign(char_type& __c1, const char_type& __c2)
-      { __c1 = __c2; }
-
-      static constexpr bool
-      eq(const char_type& __c1, const char_type& __c2)
-      { return __c1 == __c2; }
-
-      static constexpr bool
-      lt(const char_type& __c1, const char_type& __c2)
-      { return __c1 < __c2; }
-
-      static int
-      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
-
-      static std::size_t
-      length(const char_type* __s);
-
-      static const char_type*
-      find(const char_type* __s, std::size_t __n, const char_type& __a);
-
-      static char_type*
-      move(char_type* __s1, const char_type* __s2, std::size_t __n);
-
-      static char_type*
-      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
-
-      static char_type*
-      assign(char_type* __s, std::size_t __n, char_type __a);
-
-      static constexpr char_type
-      to_char_type(const int_type& __c)
-      { return static_cast<char_type>(__c); }
-
-      static constexpr int_type
-      to_int_type(const char_type& __c)
-      { return static_cast<int_type>(__c); }
-
-      static constexpr bool
-      eq_int_type(const int_type& __c1, const int_type& __c2)
-      { return __c1 == __c2; }
-
-      static constexpr int_type
-      eof()
-      { return static_cast<int_type>(-1); }
-
-      static constexpr int_type
-      not_eof(const int_type& __c)
-      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
-    };
-
-  template<typename _CharT>
-    int
-    char_traits<_CharT>::
-    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
-    {
-      for (std::size_t __i = 0; __i < __n; ++__i)
- if (lt(__s1[__i], __s2[__i]))
-   return -1;
- else if (lt(__s2[__i], __s1[__i]))
-   return 1;
-      return 0;
-    }
-
-  template<typename _CharT>
-    std::size_t
-    char_traits<_CharT>::
-    length(const char_type* __p)
-    {
-      std::size_t __i = 0;
-      while (!eq(__p[__i], char_type()))
-        ++__i;
-      return __i;
-    }
-
-  template<typename _CharT>
-    const typename char_traits<_CharT>::char_type*
-    char_traits<_CharT>::
-    find(const char_type* __s, std::size_t __n, const char_type& __a)
-    {
-      for (std::size_t __i = 0; __i < __n; ++__i)
-        if (eq(__s[__i], __a))
-          return __s + __i;
-      return 0;
-    }
-
-  template<typename _CharT>
-    typename char_traits<_CharT>::char_type*
-    char_traits<_CharT>::
-    move(char_type* __s1, const char_type* __s2, std::size_t __n)
-    {
-      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
-          __n * sizeof(char_type)));
-    }
-
-  template<typename _CharT>
-    typename char_traits<_CharT>::char_type*
-    char_traits<_CharT>::
-    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
-    {
-
-      std::copy(__s2, __s2 + __n, __s1);
-      return __s1;
-    }
-
-  template<typename _CharT>
-    typename char_traits<_CharT>::char_type*
-    char_traits<_CharT>::
-    assign(char_type* __s, std::size_t __n, char_type __a)
-    {
-
-      std::fill_n(__s, __n, __a);
-      return __s;
-    }
-
-
-}
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 226 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 3
-  template<class _CharT>
-    struct char_traits : public __gnu_cxx::char_traits<_CharT>
-    { };
-
-
-
-  template<>
-    struct char_traits<char>
-    {
-      typedef char char_type;
-      typedef int int_type;
-      typedef streampos pos_type;
-      typedef streamoff off_type;
-      typedef mbstate_t state_type;
-
-      static void
-      assign(char_type& __c1, const char_type& __c2) noexcept
-      { __c1 = __c2; }
-
-      static constexpr bool
-      eq(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr bool
-      lt(const char_type& __c1, const char_type& __c2) noexcept
-      {
-
- return (static_cast<unsigned char>(__c1)
-  < static_cast<unsigned char>(__c2));
-      }
-
-      static int
-      compare(const char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return 0;
- return __builtin_memcmp(__s1, __s2, __n);
-      }
-
-      static size_t
-      length(const char_type* __s)
-      { return __builtin_strlen(__s); }
-
-      static const char_type*
-      find(const char_type* __s, size_t __n, const char_type& __a)
-      {
- if (__n == 0)
-   return 0;
- return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
-      }
-
-      static char_type*
-      move(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
-      }
-
-      static char_type*
-      copy(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
-      }
-
-      static char_type*
-      assign(char_type* __s, size_t __n, char_type __a)
-      {
- if (__n == 0)
-   return __s;
- return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
-      }
-
-      static constexpr char_type
-      to_char_type(const int_type& __c) noexcept
-      { return static_cast<char_type>(__c); }
-
-
-
-      static constexpr int_type
-      to_int_type(const char_type& __c) noexcept
-      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
-
-      static constexpr bool
-      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr int_type
-      eof() noexcept
-      { return static_cast<int_type>(-1); }
-
-      static constexpr int_type
-      not_eof(const int_type& __c) noexcept
-      { return (__c == eof()) ? 0 : __c; }
-  };
-
-
-
-
-  template<>
-    struct char_traits<wchar_t>
-    {
-      typedef wchar_t char_type;
-      typedef wint_t int_type;
-      typedef streamoff off_type;
-      typedef wstreampos pos_type;
-      typedef mbstate_t state_type;
-
-      static void
-      assign(char_type& __c1, const char_type& __c2) noexcept
-      { __c1 = __c2; }
-
-      static constexpr bool
-      eq(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr bool
-      lt(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 < __c2; }
-
-      static int
-      compare(const char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return 0;
- return wmemcmp(__s1, __s2, __n);
-      }
-
-      static size_t
-      length(const char_type* __s)
-      { return wcslen(__s); }
-
-      static const char_type*
-      find(const char_type* __s, size_t __n, const char_type& __a)
-      {
- if (__n == 0)
-   return 0;
- return wmemchr(__s, __a, __n);
-      }
-
-      static char_type*
-      move(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return wmemmove(__s1, __s2, __n);
-      }
-
-      static char_type*
-      copy(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return wmemcpy(__s1, __s2, __n);
-      }
-
-      static char_type*
-      assign(char_type* __s, size_t __n, char_type __a)
-      {
- if (__n == 0)
-   return __s;
- return wmemset(__s, __a, __n);
-      }
-
-      static constexpr char_type
-      to_char_type(const int_type& __c) noexcept
-      { return char_type(__c); }
-
-      static constexpr int_type
-      to_int_type(const char_type& __c) noexcept
-      { return int_type(__c); }
-
-      static constexpr bool
-      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr int_type
-      eof() noexcept
-      { return static_cast<int_type>((0xffffffffu)); }
-
-      static constexpr int_type
-      not_eof(const int_type& __c) noexcept
-      { return eq_int_type(__c, eof()) ? 0 : __c; }
-  };
-
-
-
-}
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3
-# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdint" 3
-namespace std
-{
-  using ::int8_t;
-  using ::int16_t;
-  using ::int32_t;
-  using ::int64_t;
-
-  using ::int_fast8_t;
-  using ::int_fast16_t;
-  using ::int_fast32_t;
-  using ::int_fast64_t;
-
-  using ::int_least8_t;
-  using ::int_least16_t;
-  using ::int_least32_t;
-  using ::int_least64_t;
-
-  using ::intmax_t;
-  using ::intptr_t;
-
-  using ::uint8_t;
-  using ::uint16_t;
-  using ::uint32_t;
-  using ::uint64_t;
-
-  using ::uint_fast8_t;
-  using ::uint_fast16_t;
-  using ::uint_fast32_t;
-  using ::uint_fast64_t;
-
-  using ::uint_least8_t;
-  using ::uint_least16_t;
-  using ::uint_least32_t;
-  using ::uint_least64_t;
-
-  using ::uintmax_t;
-  using ::uintptr_t;
-}
-# 421 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/char_traits.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<>
-    struct char_traits<char16_t>
-    {
-      typedef char16_t char_type;
-      typedef uint_least16_t int_type;
-      typedef streamoff off_type;
-      typedef u16streampos pos_type;
-      typedef mbstate_t state_type;
-
-      static void
-      assign(char_type& __c1, const char_type& __c2) noexcept
-      { __c1 = __c2; }
-
-      static constexpr bool
-      eq(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr bool
-      lt(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 < __c2; }
-
-      static int
-      compare(const char_type* __s1, const char_type* __s2, size_t __n)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   if (lt(__s1[__i], __s2[__i]))
-     return -1;
-   else if (lt(__s2[__i], __s1[__i]))
-     return 1;
- return 0;
-      }
-
-      static size_t
-      length(const char_type* __s)
-      {
- size_t __i = 0;
- while (!eq(__s[__i], char_type()))
-   ++__i;
- return __i;
-      }
-
-      static const char_type*
-      find(const char_type* __s, size_t __n, const char_type& __a)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   if (eq(__s[__i], __a))
-     return __s + __i;
- return 0;
-      }
-
-      static char_type*
-      move(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return (static_cast<char_type*>
-  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
-      }
-
-      static char_type*
-      copy(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return (static_cast<char_type*>
-  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
-      }
-
-      static char_type*
-      assign(char_type* __s, size_t __n, char_type __a)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   assign(__s[__i], __a);
- return __s;
-      }
-
-      static constexpr char_type
-      to_char_type(const int_type& __c) noexcept
-      { return char_type(__c); }
-
-      static constexpr int_type
-      to_int_type(const char_type& __c) noexcept
-      { return int_type(__c); }
-
-      static constexpr bool
-      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr int_type
-      eof() noexcept
-      { return static_cast<int_type>(-1); }
-
-      static constexpr int_type
-      not_eof(const int_type& __c) noexcept
-      { return eq_int_type(__c, eof()) ? 0 : __c; }
-    };
-
-  template<>
-    struct char_traits<char32_t>
-    {
-      typedef char32_t char_type;
-      typedef uint_least32_t int_type;
-      typedef streamoff off_type;
-      typedef u32streampos pos_type;
-      typedef mbstate_t state_type;
-
-      static void
-      assign(char_type& __c1, const char_type& __c2) noexcept
-      { __c1 = __c2; }
-
-      static constexpr bool
-      eq(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr bool
-      lt(const char_type& __c1, const char_type& __c2) noexcept
-      { return __c1 < __c2; }
-
-      static int
-      compare(const char_type* __s1, const char_type* __s2, size_t __n)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   if (lt(__s1[__i], __s2[__i]))
-     return -1;
-   else if (lt(__s2[__i], __s1[__i]))
-     return 1;
- return 0;
-      }
-
-      static size_t
-      length(const char_type* __s)
-      {
- size_t __i = 0;
- while (!eq(__s[__i], char_type()))
-   ++__i;
- return __i;
-      }
-
-      static const char_type*
-      find(const char_type* __s, size_t __n, const char_type& __a)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   if (eq(__s[__i], __a))
-     return __s + __i;
- return 0;
-      }
-
-      static char_type*
-      move(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return (static_cast<char_type*>
-  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
-      }
-
-      static char_type*
-      copy(char_type* __s1, const char_type* __s2, size_t __n)
-      {
- if (__n == 0)
-   return __s1;
- return (static_cast<char_type*>
-  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
-      }
-
-      static char_type*
-      assign(char_type* __s, size_t __n, char_type __a)
-      {
- for (size_t __i = 0; __i < __n; ++__i)
-   assign(__s[__i], __a);
- return __s;
-      }
-
-      static constexpr char_type
-      to_char_type(const int_type& __c) noexcept
-      { return char_type(__c); }
-
-      static constexpr int_type
-      to_int_type(const char_type& __c) noexcept
-      { return int_type(__c); }
-
-      static constexpr bool
-      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
-      { return __c1 == __c2; }
-
-      static constexpr int_type
-      eof() noexcept
-      { return static_cast<int_type>(-1); }
-
-      static constexpr int_type
-      not_eof(const int_type& __c) noexcept
-      { return eq_int_type(__c, eof()) ? 0 : __c; }
-    };
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 3
-
-
-# 1 "/usr/include/locale.h" 1 3 4
-# 28 "/usr/include/locale.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 29 "/usr/include/locale.h" 2 3 4
-# 1 "/usr/include/bits/locale.h" 1 3 4
-# 30 "/usr/include/locale.h" 2 3 4
-
-extern "C" {
-# 53 "/usr/include/locale.h" 3 4
-struct lconv
-{
-
-
-  char *decimal_point;
-  char *thousands_sep;
-
-
-
-
-
-  char *grouping;
-
-
-
-
-
-  char *int_curr_symbol;
-  char *currency_symbol;
-  char *mon_decimal_point;
-  char *mon_thousands_sep;
-  char *mon_grouping;
-  char *positive_sign;
-  char *negative_sign;
-  char int_frac_digits;
-  char frac_digits;
-
-  char p_cs_precedes;
-
-  char p_sep_by_space;
-
-  char n_cs_precedes;
-
-  char n_sep_by_space;
-
-
-
-
-
-
-  char p_sign_posn;
-  char n_sign_posn;
-
-
-  char int_p_cs_precedes;
-
-  char int_p_sep_by_space;
-
-  char int_n_cs_precedes;
-
-  char int_n_sep_by_space;
-
-
-
-
-
-
-  char int_p_sign_posn;
-  char int_n_sign_posn;
-# 120 "/usr/include/locale.h" 3 4
-};
-
-
-
-extern char *setlocale (int __category, const char *__locale) throw ();
-
-
-extern struct lconv *localeconv (void) throw ();
-# 151 "/usr/include/locale.h" 3 4
-extern __locale_t newlocale (int __category_mask, const char *__locale,
-        __locale_t __base) throw ();
-# 186 "/usr/include/locale.h" 3 4
-extern __locale_t duplocale (__locale_t __dataset) throw ();
-
-
-
-extern void freelocale (__locale_t __dataset) throw ();
-
-
-
-
-
-
-extern __locale_t uselocale (__locale_t __dataset) throw ();
-
-
-
-
-
-
-
-}
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/clocale" 2 3
-
-
-
-
-
-
-
-
-namespace std
-{
-  using ::lconv;
-  using ::setlocale;
-  using ::localeconv;
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 2 3
-
-
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-  extern "C" __typeof(uselocale) __uselocale;
-
-
-}
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  typedef __locale_t __c_locale;
-
-
-
-
-
-  inline int
-  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
-     char* __out,
-     const int __size __attribute__ ((__unused__)),
-     const char* __fmt, ...)
-  {
-
-    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
-# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++locale.h" 3
-    __builtin_va_list __args;
-    __builtin_va_start(__args, __fmt);
-
-
-    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
-
-
-
-
-    __builtin_va_end(__args);
-
-
-    __gnu_cxx::__uselocale(__old);
-
-
-
-
-
-
-
-    return __ret;
-  }
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
-
-
-# 1 "/usr/include/ctype.h" 1 3 4
-# 28 "/usr/include/ctype.h" 3 4
-extern "C" {
-# 46 "/usr/include/ctype.h" 3 4
-enum
-{
-  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
-  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
-  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
-  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
-  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
-  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
-  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
-  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
-  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
-  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
-  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
-  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
-};
-# 79 "/usr/include/ctype.h" 3 4
-extern const unsigned short int **__ctype_b_loc (void)
-     throw () __attribute__ ((__const__));
-extern const __int32_t **__ctype_tolower_loc (void)
-     throw () __attribute__ ((__const__));
-extern const __int32_t **__ctype_toupper_loc (void)
-     throw () __attribute__ ((__const__));
-# 110 "/usr/include/ctype.h" 3 4
-extern int isalnum (int) throw ();
-extern int isalpha (int) throw ();
-extern int iscntrl (int) throw ();
-extern int isdigit (int) throw ();
-extern int islower (int) throw ();
-extern int isgraph (int) throw ();
-extern int isprint (int) throw ();
-extern int ispunct (int) throw ();
-extern int isspace (int) throw ();
-extern int isupper (int) throw ();
-extern int isxdigit (int) throw ();
-
-
-
-extern int tolower (int __c) throw ();
-
-
-extern int toupper (int __c) throw ();
-# 136 "/usr/include/ctype.h" 3 4
-extern int isblank (int) throw ();
-
-
-
-
-
-
-extern int isctype (int __c, int __mask) throw ();
-
-
-
-
-
-
-extern int isascii (int __c) throw ();
-
-
-
-extern int toascii (int __c) throw ();
-
-
-
-extern int _toupper (int) throw ();
-extern int _tolower (int) throw ();
-# 271 "/usr/include/ctype.h" 3 4
-extern int isalnum_l (int, __locale_t) throw ();
-extern int isalpha_l (int, __locale_t) throw ();
-extern int iscntrl_l (int, __locale_t) throw ();
-extern int isdigit_l (int, __locale_t) throw ();
-extern int islower_l (int, __locale_t) throw ();
-extern int isgraph_l (int, __locale_t) throw ();
-extern int isprint_l (int, __locale_t) throw ();
-extern int ispunct_l (int, __locale_t) throw ();
-extern int isspace_l (int, __locale_t) throw ();
-extern int isupper_l (int, __locale_t) throw ();
-extern int isxdigit_l (int, __locale_t) throw ();
-
-extern int isblank_l (int, __locale_t) throw ();
-
-
-
-extern int __tolower_l (int __c, __locale_t __l) throw ();
-extern int tolower_l (int __c, __locale_t __l) throw ();
-
-
-extern int __toupper_l (int __c, __locale_t __l) throw ();
-extern int toupper_l (int __c, __locale_t __l) throw ();
-# 347 "/usr/include/ctype.h" 3 4
-}
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 2 3
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
-namespace std
-{
-  using ::isalnum;
-  using ::isalpha;
-  using ::iscntrl;
-  using ::isdigit;
-  using ::isgraph;
-  using ::islower;
-  using ::isprint;
-  using ::ispunct;
-  using ::isspace;
-  using ::isupper;
-  using ::isxdigit;
-  using ::tolower;
-  using ::toupper;
-}
-
-
-
-
-
-
-
-namespace std
-{
-  using ::isblank;
-}
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/localefwd.h" 3
-  class locale;
-
-  template<typename _Facet>
-    bool
-    has_facet(const locale&) throw();
-
-  template<typename _Facet>
-    const _Facet&
-    use_facet(const locale&);
-
-
-  template<typename _CharT>
-    bool
-    isspace(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isprint(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    iscntrl(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isupper(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    islower(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isalpha(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isdigit(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    ispunct(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isxdigit(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isalnum(_CharT, const locale&);
-
-  template<typename _CharT>
-    bool
-    isgraph(_CharT, const locale&);
-
-
-  template<typename _CharT>
-    bool
-    isblank(_CharT, const locale&);
-
-
-  template<typename _CharT>
-    _CharT
-    toupper(_CharT, const locale&);
-
-  template<typename _CharT>
-    _CharT
-    tolower(_CharT, const locale&);
-
-
-  class ctype_base;
-  template<typename _CharT>
-    class ctype;
-  template<> class ctype<char>;
-
-  template<> class ctype<wchar_t>;
-
-  template<typename _CharT>
-    class ctype_byname;
-
-
-  class codecvt_base;
-  template<typename _InternT, typename _ExternT, typename _StateT>
-    class codecvt;
-  template<> class codecvt<char, char, mbstate_t>;
-
-  template<> class codecvt<wchar_t, char, mbstate_t>;
-
-  template<typename _InternT, typename _ExternT, typename _StateT>
-    class codecvt_byname;
-
-
-
-  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
-    class num_get;
-  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
-    class num_put;
-
-namespace __cxx11 {
-  template<typename _CharT> class numpunct;
-  template<typename _CharT> class numpunct_byname;
-}
-
-namespace __cxx11 {
-
-  template<typename _CharT>
-    class collate;
-  template<typename _CharT>
-    class collate_byname;
-}
-
-
-  class time_base;
-namespace __cxx11 {
-  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
-    class time_get;
-  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
-    class time_get_byname;
-}
-  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
-    class time_put;
-  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
-    class time_put_byname;
-
-
-  class money_base;
-namespace __cxx11 {
-  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
-    class money_get;
-  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
-    class money_put;
-}
-namespace __cxx11 {
-  template<typename _CharT, bool _Intl = false>
-    class moneypunct;
-  template<typename _CharT, bool _Intl = false>
-    class moneypunct_byname;
-}
-
-
-  class messages_base;
-namespace __cxx11 {
-  template<typename _CharT>
-    class messages;
-  template<typename _CharT>
-    class messages_byname;
-}
-
-
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 1 3
-# 30 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3
-#pragma GCC visibility push(default)
-# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 1 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-# 1 "/usr/include/pthread.h" 1 3 4
-# 23 "/usr/include/pthread.h" 3 4
-# 1 "/usr/include/sched.h" 1 3 4
-# 28 "/usr/include/sched.h" 3 4
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 29 "/usr/include/sched.h" 2 3 4
-
-
-
-
-
-# 1 "/usr/include/time.h" 1 3 4
-# 35 "/usr/include/sched.h" 2 3 4
-
-
-
-
-
-
-
-
-# 1 "/usr/include/bits/sched.h" 1 3 4
-# 73 "/usr/include/bits/sched.h" 3 4
-struct sched_param
-  {
-    int __sched_priority;
-  };
-
-extern "C" {
-
-
-
-extern int clone (int (*__fn) (void *__arg), void *__child_stack,
-    int __flags, void *__arg, ...) throw ();
-
-
-extern int unshare (int __flags) throw ();
-
-
-extern int sched_getcpu (void) throw ();
-
-
-extern int setns (int __fd, int __nstype) throw ();
-
-
-
-}
-
-
-
-
-
-
-
-struct __sched_param
-  {
-    int __sched_priority;
-  };
-# 119 "/usr/include/bits/sched.h" 3 4
-typedef unsigned long int __cpu_mask;
-
-
-
-
-
-
-typedef struct
-{
-  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
-} cpu_set_t;
-# 202 "/usr/include/bits/sched.h" 3 4
-extern "C" {
-
-extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
-  throw ();
-extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
-extern void __sched_cpufree (cpu_set_t *__set) throw ();
-
-}
-# 44 "/usr/include/sched.h" 2 3 4
-
-
-
-
-extern "C" {
-
-
-extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
-     throw ();
-
-
-extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
-
-
-extern int sched_setscheduler (__pid_t __pid, int __policy,
-          const struct sched_param *__param) throw ();
-
-
-extern int sched_getscheduler (__pid_t __pid) throw ();
-
-
-extern int sched_yield (void) throw ();
-
-
-extern int sched_get_priority_max (int __algorithm) throw ();
-
-
-extern int sched_get_priority_min (int __algorithm) throw ();
-
-
-extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
-# 118 "/usr/include/sched.h" 3 4
-extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
-         const cpu_set_t *__cpuset) throw ();
-
-
-extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
-         cpu_set_t *__cpuset) throw ();
-
-
-}
-# 24 "/usr/include/pthread.h" 2 3 4
-# 1 "/usr/include/time.h" 1 3 4
-# 29 "/usr/include/time.h" 3 4
-extern "C" {
-
-
-
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3 4
-# 38 "/usr/include/time.h" 2 3 4
-
-
-
-# 1 "/usr/include/bits/time.h" 1 3 4
-# 88 "/usr/include/bits/time.h" 3 4
-# 1 "/usr/include/bits/timex.h" 1 3 4
-# 25 "/usr/include/bits/timex.h" 3 4
-struct timex
-{
-  unsigned int modes;
-  __syscall_slong_t offset;
-  __syscall_slong_t freq;
-  __syscall_slong_t maxerror;
-  __syscall_slong_t esterror;
-  int status;
-  __syscall_slong_t constant;
-  __syscall_slong_t precision;
-  __syscall_slong_t tolerance;
-  struct timeval time;
-  __syscall_slong_t tick;
-  __syscall_slong_t ppsfreq;
-  __syscall_slong_t jitter;
-  int shift;
-  __syscall_slong_t stabil;
-  __syscall_slong_t jitcnt;
-  __syscall_slong_t calcnt;
-  __syscall_slong_t errcnt;
-  __syscall_slong_t stbcnt;
-
-  int tai;
-
-
-  int :32; int :32; int :32; int :32;
-  int :32; int :32; int :32; int :32;
-  int :32; int :32; int :32;
-};
-# 89 "/usr/include/bits/time.h" 2 3 4
-
-extern "C" {
-
-
-extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
-
-}
-# 42 "/usr/include/time.h" 2 3 4
-# 133 "/usr/include/time.h" 3 4
-struct tm
-{
-  int tm_sec;
-  int tm_min;
-  int tm_hour;
-  int tm_mday;
-  int tm_mon;
-  int tm_year;
-  int tm_wday;
-  int tm_yday;
-  int tm_isdst;
-
-
-  long int tm_gmtoff;
-  const char *tm_zone;
-
-
-
-
-};
-# 161 "/usr/include/time.h" 3 4
-struct itimerspec
-  {
-    struct timespec it_interval;
-    struct timespec it_value;
-  };
-
-
-struct sigevent;
-# 189 "/usr/include/time.h" 3 4
-extern clock_t clock (void) throw ();
-
-
-extern time_t time (time_t *__timer) throw ();
-
-
-extern double difftime (time_t __time1, time_t __time0)
-     throw () __attribute__ ((__const__));
-
-
-extern time_t mktime (struct tm *__tp) throw ();
-
-
-
-
-
-extern size_t strftime (char *__restrict __s, size_t __maxsize,
-   const char *__restrict __format,
-   const struct tm *__restrict __tp) throw ();
-
-
-
-
-
-extern char *strptime (const char *__restrict __s,
-         const char *__restrict __fmt, struct tm *__tp)
-     throw ();
-
-
-
-
-
-
-
-extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
-     const char *__restrict __format,
-     const struct tm *__restrict __tp,
-     __locale_t __loc) throw ();
-
-
-
-extern char *strptime_l (const char *__restrict __s,
-    const char *__restrict __fmt, struct tm *__tp,
-    __locale_t __loc) throw ();
-
-
-
-
-
-
-extern struct tm *gmtime (const time_t *__timer) throw ();
-
-
-
-extern struct tm *localtime (const time_t *__timer) throw ();
-
-
-
-
-
-extern struct tm *gmtime_r (const time_t *__restrict __timer,
-       struct tm *__restrict __tp) throw ();
-
-
-
-extern struct tm *localtime_r (const time_t *__restrict __timer,
-          struct tm *__restrict __tp) throw ();
-
-
-
-
-
-extern char *asctime (const struct tm *__tp) throw ();
-
-
-extern char *ctime (const time_t *__timer) throw ();
-
-
-
-
-
-
-
-extern char *asctime_r (const struct tm *__restrict __tp,
-   char *__restrict __buf) throw ();
-
-
-extern char *ctime_r (const time_t *__restrict __timer,
-        char *__restrict __buf) throw ();
-
-
-
-
-extern char *__tzname[2];
-extern int __daylight;
-extern long int __timezone;
-
-
-
-
-extern char *tzname[2];
-
-
-
-extern void tzset (void) throw ();
-
-
-
-extern int daylight;
-extern long int timezone;
-
-
-
-
-
-extern int stime (const time_t *__when) throw ();
-# 319 "/usr/include/time.h" 3 4
-extern time_t timegm (struct tm *__tp) throw ();
-
-
-extern time_t timelocal (struct tm *__tp) throw ();
-
-
-extern int dysize (int __year) throw () __attribute__ ((__const__));
-# 334 "/usr/include/time.h" 3 4
-extern int nanosleep (const struct timespec *__requested_time,
-        struct timespec *__remaining);
-
-
-
-extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
-
-
-extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
-
-
-extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
-     throw ();
-
-
-
-
-
-
-extern int clock_nanosleep (clockid_t __clock_id, int __flags,
-       const struct timespec *__req,
-       struct timespec *__rem);
-
-
-extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
-
-
-
-
-extern int timer_create (clockid_t __clock_id,
-    struct sigevent *__restrict __evp,
-    timer_t *__restrict __timerid) throw ();
-
-
-extern int timer_delete (timer_t __timerid) throw ();
-
-
-extern int timer_settime (timer_t __timerid, int __flags,
-     const struct itimerspec *__restrict __value,
-     struct itimerspec *__restrict __ovalue) throw ();
-
-
-extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
-     throw ();
-
-
-extern int timer_getoverrun (timer_t __timerid) throw ();
-
-
-
-
-
-extern int timespec_get (struct timespec *__ts, int __base)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 403 "/usr/include/time.h" 3 4
-extern int getdate_err;
-# 412 "/usr/include/time.h" 3 4
-extern struct tm *getdate (const char *__string);
-# 426 "/usr/include/time.h" 3 4
-extern int getdate_r (const char *__restrict __string,
-        struct tm *__restrict __resbufp);
-
-
-}
-# 25 "/usr/include/pthread.h" 2 3 4
-
-
-# 1 "/usr/include/bits/setjmp.h" 1 3 4
-# 26 "/usr/include/bits/setjmp.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 27 "/usr/include/bits/setjmp.h" 2 3 4
-
-
-
-
-typedef long int __jmp_buf[8];
-# 28 "/usr/include/pthread.h" 2 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 29 "/usr/include/pthread.h" 2 3 4
-
-
-
-enum
-{
-  PTHREAD_CREATE_JOINABLE,
-
-  PTHREAD_CREATE_DETACHED
-
-};
-
-
-
-enum
-{
-  PTHREAD_MUTEX_TIMED_NP,
-  PTHREAD_MUTEX_RECURSIVE_NP,
-  PTHREAD_MUTEX_ERRORCHECK_NP,
-  PTHREAD_MUTEX_ADAPTIVE_NP
-
-  ,
-  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
-  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
-  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
-  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
-
-
-
-  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
-
-};
-
-
-
-
-enum
-{
-  PTHREAD_MUTEX_STALLED,
-  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
-  PTHREAD_MUTEX_ROBUST,
-  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
-};
-
-
-
-
-
-enum
-{
-  PTHREAD_PRIO_NONE,
-  PTHREAD_PRIO_INHERIT,
-  PTHREAD_PRIO_PROTECT
-};
-# 114 "/usr/include/pthread.h" 3 4
-enum
-{
-  PTHREAD_RWLOCK_PREFER_READER_NP,
-  PTHREAD_RWLOCK_PREFER_WRITER_NP,
-  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
-  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
-};
-# 155 "/usr/include/pthread.h" 3 4
-enum
-{
-  PTHREAD_INHERIT_SCHED,
-
-  PTHREAD_EXPLICIT_SCHED
-
-};
-
-
-
-enum
-{
-  PTHREAD_SCOPE_SYSTEM,
-
-  PTHREAD_SCOPE_PROCESS
-
-};
-
-
-
-enum
-{
-  PTHREAD_PROCESS_PRIVATE,
-
-  PTHREAD_PROCESS_SHARED
-
-};
-# 190 "/usr/include/pthread.h" 3 4
-struct _pthread_cleanup_buffer
-{
-  void (*__routine) (void *);
-  void *__arg;
-  int __canceltype;
-  struct _pthread_cleanup_buffer *__prev;
-};
-
-
-enum
-{
-  PTHREAD_CANCEL_ENABLE,
-
-  PTHREAD_CANCEL_DISABLE
-
-};
-enum
-{
-  PTHREAD_CANCEL_DEFERRED,
-
-  PTHREAD_CANCEL_ASYNCHRONOUS
-
-};
-# 228 "/usr/include/pthread.h" 3 4
-extern "C" {
-
-
-
-
-extern int pthread_create (pthread_t *__restrict __newthread,
-      const pthread_attr_t *__restrict __attr,
-      void *(*__start_routine) (void *),
-      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
-
-
-
-
-
-extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
-
-
-
-
-
-
-
-extern int pthread_join (pthread_t __th, void **__thread_return);
-
-
-
-
-extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
-
-
-
-
-
-
-
-extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
-     const struct timespec *__abstime);
-
-
-
-
-
-
-extern int pthread_detach (pthread_t __th) throw ();
-
-
-
-extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
-
-
-extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
-  throw () __attribute__ ((__const__));
-
-
-
-
-
-
-
-extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_attr_destroy (pthread_attr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
-     int *__detachstate)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
-     int __detachstate)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
-          size_t *__guardsize)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
-          size_t __guardsize)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
-           struct sched_param *__restrict __param)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
-           const struct sched_param *__restrict
-           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
-     __attr, int *__restrict __policy)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
-      __attr, int *__restrict __inherit)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
-      int __inherit)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
-      int *__restrict __scope)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
-          __attr, void **__restrict __stackaddr)
-     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
-
-
-
-
-
-extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
-          void *__stackaddr)
-     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
-
-
-extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
-          __attr, size_t *__restrict __stacksize)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
-          size_t __stacksize)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
-      void **__restrict __stackaddr,
-      size_t *__restrict __stacksize)
-     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
-
-
-
-
-extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
-      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
-     size_t __cpusetsize,
-     const cpu_set_t *__cpuset)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-
-
-
-extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
-     size_t __cpusetsize,
-     cpu_set_t *__cpuset)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-
-
-extern int pthread_getattr_default_np (pthread_attr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-
-
-
-extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
-      const struct sched_param *__param)
-     throw () __attribute__ ((__nonnull__ (3)));
-
-
-extern int pthread_getschedparam (pthread_t __target_thread,
-      int *__restrict __policy,
-      struct sched_param *__restrict __param)
-     throw () __attribute__ ((__nonnull__ (2, 3)));
-
-
-extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
-     throw ();
-
-
-
-
-extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
-          size_t __buflen)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
-     throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-
-extern int pthread_getconcurrency (void) throw ();
-
-
-extern int pthread_setconcurrency (int __level) throw ();
-
-
-
-
-
-
-
-extern int pthread_yield (void) throw ();
-
-
-
-
-extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
-       const cpu_set_t *__cpuset)
-     throw () __attribute__ ((__nonnull__ (3)));
-
-
-extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
-       cpu_set_t *__cpuset)
-     throw () __attribute__ ((__nonnull__ (3)));
-# 494 "/usr/include/pthread.h" 3 4
-extern int pthread_once (pthread_once_t *__once_control,
-    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
-# 506 "/usr/include/pthread.h" 3 4
-extern int pthread_setcancelstate (int __state, int *__oldstate);
-
-
-
-extern int pthread_setcanceltype (int __type, int *__oldtype);
-
-
-extern int pthread_cancel (pthread_t __th);
-
-
-
-
-extern void pthread_testcancel (void);
-
-
-
-
-typedef struct
-{
-  struct
-  {
-    __jmp_buf __cancel_jmp_buf;
-    int __mask_was_saved;
-  } __cancel_jmp_buf[1];
-  void *__pad[4];
-} __pthread_unwind_buf_t __attribute__ ((__aligned__));
-# 540 "/usr/include/pthread.h" 3 4
-struct __pthread_cleanup_frame
-{
-  void (*__cancel_routine) (void *);
-  void *__cancel_arg;
-  int __do_it;
-  int __cancel_type;
-};
-
-
-
-
-class __pthread_cleanup_class
-{
-  void (*__cancel_routine) (void *);
-  void *__cancel_arg;
-  int __do_it;
-  int __cancel_type;
-
- public:
-  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
-    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
-  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
-  void __setdoit (int __newval) { __do_it = __newval; }
-  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
-        &__cancel_type); }
-  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
-};
-# 742 "/usr/include/pthread.h" 3 4
-struct __jmp_buf_tag;
-extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
-
-
-
-
-
-extern int pthread_mutex_init (pthread_mutex_t *__mutex,
-          const pthread_mutexattr_t *__mutexattr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
-        const struct timespec *__restrict
-        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
-      __restrict __mutex,
-      int *__restrict __prioceiling)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
-      int __prioceiling,
-      int *__restrict __old_ceiling)
-     throw () __attribute__ ((__nonnull__ (1, 3)));
-
-
-
-
-extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 806 "/usr/include/pthread.h" 3 4
-extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
-      __restrict __attr,
-      int *__restrict __pshared)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
-      int __pshared)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
-          __attr, int *__restrict __kind)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-
-extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
-       __restrict __attr,
-       int *__restrict __protocol)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
-       int __protocol)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
-          __restrict __attr,
-          int *__restrict __prioceiling)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
-          int __prioceiling)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
-     int *__robustness)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
-        int *__robustness)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
-     int __robustness)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
-        int __robustness)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 888 "/usr/include/pthread.h" 3 4
-extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
-    const pthread_rwlockattr_t *__restrict
-    __attr) throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
-  throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
-           const struct timespec *__restrict
-           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
-           const struct timespec *__restrict
-           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-
-extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
-       __restrict __attr,
-       int *__restrict __pshared)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
-       int __pshared)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
-       __restrict __attr,
-       int *__restrict __pref)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
-       int __pref) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-
-extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
-         const pthread_condattr_t *__restrict __cond_attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_cond_destroy (pthread_cond_t *__cond)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_cond_signal (pthread_cond_t *__cond)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_cond_broadcast (pthread_cond_t *__cond)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
-         pthread_mutex_t *__restrict __mutex)
-     __attribute__ ((__nonnull__ (1, 2)));
-# 1000 "/usr/include/pthread.h" 3 4
-extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
-       pthread_mutex_t *__restrict __mutex,
-       const struct timespec *__restrict __abstime)
-     __attribute__ ((__nonnull__ (1, 2, 3)));
-
-
-
-
-extern int pthread_condattr_init (pthread_condattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_condattr_getpshared (const pthread_condattr_t *
-     __restrict __attr,
-     int *__restrict __pshared)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
-     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_condattr_getclock (const pthread_condattr_t *
-          __restrict __attr,
-          __clockid_t *__restrict __clock_id)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
-          __clockid_t __clock_id)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 1044 "/usr/include/pthread.h" 3 4
-extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_spin_lock (pthread_spinlock_t *__lock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-
-
-
-extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
-     const pthread_barrierattr_t *__restrict
-     __attr, unsigned int __count)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-
-extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
-        __restrict __attr,
-        int *__restrict __pshared)
-     throw () __attribute__ ((__nonnull__ (1, 2)));
-
-
-extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
-        int __pshared)
-     throw () __attribute__ ((__nonnull__ (1)));
-# 1111 "/usr/include/pthread.h" 3 4
-extern int pthread_key_create (pthread_key_t *__key,
-          void (*__destr_function) (void *))
-     throw () __attribute__ ((__nonnull__ (1)));
-
-
-extern int pthread_key_delete (pthread_key_t __key) throw ();
-
-
-extern void *pthread_getspecific (pthread_key_t __key) throw ();
-
-
-extern int pthread_setspecific (pthread_key_t __key,
-    const void *__pointer) throw () ;
-
-
-
-
-extern int pthread_getcpuclockid (pthread_t __thread_id,
-      __clockid_t *__clock_id)
-     throw () __attribute__ ((__nonnull__ (2)));
-# 1145 "/usr/include/pthread.h" 3 4
-extern int pthread_atfork (void (*__prepare) (void),
-      void (*__parent) (void),
-      void (*__child) (void)) throw ();
-# 1159 "/usr/include/pthread.h" 3 4
-}
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 2 3
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-typedef pthread_t __gthread_t;
-typedef pthread_key_t __gthread_key_t;
-typedef pthread_once_t __gthread_once_t;
-typedef pthread_mutex_t __gthread_mutex_t;
-typedef pthread_mutex_t __gthread_recursive_mutex_t;
-typedef pthread_cond_t __gthread_cond_t;
-typedef struct timespec __gthread_time_t;
-# 101 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
-static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
-static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
-
-static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
-static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
-static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
-static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
-static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
-
-static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
-
-static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
-
-static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
-static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
-
-static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
-
-static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
-static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
-static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
-
-static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
-static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
-static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
-static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
-static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
-static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
-
-static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
-static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
-static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
-static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
-static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
-# 236 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
-# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static inline int
-__gthread_active_p (void)
-{
-  static void *const __gthread_active_ptr
-    = __extension__ (void *) &__gthrw___pthread_key_create;
-  return __gthread_active_ptr != 0;
-}
-# 658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static inline int
-__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
-    void *__args)
-{
-  return __gthrw_pthread_create (__threadid, __null, __func, __args);
-}
-
-static inline int
-__gthread_join (__gthread_t __threadid, void **__value_ptr)
-{
-  return __gthrw_pthread_join (__threadid, __value_ptr);
-}
-
-static inline int
-__gthread_detach (__gthread_t __threadid)
-{
-  return __gthrw_pthread_detach (__threadid);
-}
-
-static inline int
-__gthread_equal (__gthread_t __t1, __gthread_t __t2)
-{
-  return __gthrw_pthread_equal (__t1, __t2);
-}
-
-static inline __gthread_t
-__gthread_self (void)
-{
-  return __gthrw_pthread_self ();
-}
-
-static inline int
-__gthread_yield (void)
-{
-  return __gthrw_sched_yield ();
-}
-
-static inline int
-__gthread_once (__gthread_once_t *__once, void (*__func) (void))
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_once (__once, __func);
-  else
-    return -1;
-}
-
-static inline int
-__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
-{
-  return __gthrw_pthread_key_create (__key, __dtor);
-}
-
-static inline int
-__gthread_key_delete (__gthread_key_t __key)
-{
-  return __gthrw_pthread_key_delete (__key);
-}
-
-static inline void *
-__gthread_getspecific (__gthread_key_t __key)
-{
-  return __gthrw_pthread_getspecific (__key);
-}
-
-static inline int
-__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
-{
-  return __gthrw_pthread_setspecific (__key, __ptr);
-}
-
-static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
-{
-  if (__gthread_active_p ())
-    __gthrw_pthread_mutex_init (__mutex, __null);
-}
-
-static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_mutex_destroy (__mutex);
-  else
-    return 0;
-}
-
-static inline int
-__gthread_mutex_lock (__gthread_mutex_t *__mutex)
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_mutex_lock (__mutex);
-  else
-    return 0;
-}
-
-static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_mutex_trylock (__mutex);
-  else
-    return 0;
-}
-
-
-static inline int
-__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
-      const __gthread_time_t *__abs_timeout)
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
-  else
-    return 0;
-}
-
-
-static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
-{
-  if (__gthread_active_p ())
-    return __gthrw_pthread_mutex_unlock (__mutex);
-  else
-    return 0;
-}
-# 807 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
-{
-  return __gthread_mutex_lock (__mutex);
-}
-
-static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
-{
-  return __gthread_mutex_trylock (__mutex);
-}
-
-
-static inline int
-__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
-         const __gthread_time_t *__abs_timeout)
-{
-  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
-}
-
-
-static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
-{
-  return __gthread_mutex_unlock (__mutex);
-}
-
-static inline int
-__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
-{
-  return __gthread_mutex_destroy (__mutex);
-}
-# 849 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr-default.h" 3
-static inline int
-__gthread_cond_broadcast (__gthread_cond_t *__cond)
-{
-  return __gthrw_pthread_cond_broadcast (__cond);
-}
-
-static inline int
-__gthread_cond_signal (__gthread_cond_t *__cond)
-{
-  return __gthrw_pthread_cond_signal (__cond);
-}
-
-static inline int
-__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
-{
-  return __gthrw_pthread_cond_wait (__cond, __mutex);
-}
-
-static inline int
-__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
-     const __gthread_time_t *__abs_timeout)
-{
-  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
-}
-
-static inline int
-__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
-          __gthread_recursive_mutex_t *__mutex)
-{
-  return __gthread_cond_wait (__cond, __mutex);
-}
-
-static inline int
-__gthread_cond_destroy (__gthread_cond_t* __cond)
-{
-  return __gthrw_pthread_cond_destroy (__cond);
-}
-# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/gthr.h" 2 3
-
-
-#pragma GCC visibility pop
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 1 3
-# 32 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/atomic_word.h" 3
-typedef int _Atomic_word;
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 2 3
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  static inline _Atomic_word
-  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
-  { return __atomic_fetch_add(__mem, __val, 4); }
-
-  static inline void
-  __atomic_add(volatile _Atomic_word* __mem, int __val)
-  { __atomic_fetch_add(__mem, __val, 4); }
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/atomicity.h" 3
-  static inline _Atomic_word
-  __exchange_and_add_single(_Atomic_word* __mem, int __val)
-  {
-    _Atomic_word __result = *__mem;
-    *__mem += __val;
-    return __result;
-  }
-
-  static inline void
-  __atomic_add_single(_Atomic_word* __mem, int __val)
-  { *__mem += __val; }
-
-  static inline _Atomic_word
-  __attribute__ ((__unused__))
-  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
-  {
-
-    if (__gthread_active_p())
-      return __exchange_and_add(__mem, __val);
-    else
-      return __exchange_and_add_single(__mem, __val);
-
-
-
-  }
-
-  static inline void
-  __attribute__ ((__unused__))
-  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
-  {
-
-    if (__gthread_active_p())
-      __atomic_add(__mem, __val);
-    else
-      __atomic_add_single(__mem, __val);
-
-
-
-  }
-
-
-}
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 3
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 1 3
-# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-  using std::size_t;
-  using std::ptrdiff_t;
-# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
-  template<typename _Tp>
-    class new_allocator
-    {
-    public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef const _Tp* const_pointer;
-      typedef _Tp& reference;
-      typedef const _Tp& const_reference;
-      typedef _Tp value_type;
-
-      template<typename _Tp1>
-        struct rebind
-        { typedef new_allocator<_Tp1> other; };
-
-
-
-
-      typedef std::true_type propagate_on_container_move_assignment;
-
-
-      new_allocator() noexcept { }
-
-      new_allocator(const new_allocator&) noexcept { }
-
-      template<typename _Tp1>
-        new_allocator(const new_allocator<_Tp1>&) noexcept { }
-
-      ~new_allocator() noexcept { }
-
-      pointer
-      address(reference __x) const noexcept
-      { return std::__addressof(__x); }
-
-      const_pointer
-      address(const_reference __x) const noexcept
-      { return std::__addressof(__x); }
-
-
-
-      pointer
-      allocate(size_type __n, const void* = 0)
-      {
- if (__n > this->max_size())
-   std::__throw_bad_alloc();
-
- return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
-      }
-
-
-      void
-      deallocate(pointer __p, size_type)
-      { ::operator delete(__p); }
-
-      size_type
-      max_size() const noexcept
-      { return size_t(-1) / sizeof(_Tp); }
-
-
-      template<typename _Up, typename... _Args>
-        void
-        construct(_Up* __p, _Args&&... __args)
- { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
-
-      template<typename _Up>
-        void
-        destroy(_Up* __p) { __p->~_Up(); }
-# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/new_allocator.h" 3
-    };
-
-  template<typename _Tp>
-    inline bool
-    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
-    { return true; }
-
-  template<typename _Tp>
-    inline bool
-    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
-    { return false; }
-
-
-}
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 2 3
-
-
-namespace std
-{
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/c++allocator.h" 3
-  template<typename _Tp>
-    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
-}
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 2 3
-# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
-  template<>
-    class allocator<void>
-    {
-    public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef void* pointer;
-      typedef const void* const_pointer;
-      typedef void value_type;
-
-      template<typename _Tp1>
-        struct rebind
-        { typedef allocator<_Tp1> other; };
-
-
-
-
-      typedef true_type propagate_on_container_move_assignment;
-
-      typedef true_type is_always_equal;
-
-      template<typename _Up, typename... _Args>
- void
- construct(_Up* __p, _Args&&... __args)
- { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
-
-      template<typename _Up>
- void
- destroy(_Up* __p) { __p->~_Up(); }
-
-    };
-# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/allocator.h" 3
-  template<typename _Tp>
-    class allocator: public __allocator_base<_Tp>
-    {
-   public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef const _Tp* const_pointer;
-      typedef _Tp& reference;
-      typedef const _Tp& const_reference;
-      typedef _Tp value_type;
-
-      template<typename _Tp1>
-        struct rebind
-        { typedef allocator<_Tp1> other; };
-
-
-
-
-      typedef true_type propagate_on_container_move_assignment;
-
-      typedef true_type is_always_equal;
-
-
-      allocator() throw() { }
-
-      allocator(const allocator& __a) throw()
-      : __allocator_base<_Tp>(__a) { }
-
-      template<typename _Tp1>
-        allocator(const allocator<_Tp1>&) throw() { }
-
-      ~allocator() throw() { }
-
-
-    };
-
-  template<typename _T1, typename _T2>
-    inline bool
-    operator==(const allocator<_T1>&, const allocator<_T2>&)
-    noexcept
-    { return true; }
-
-  template<typename _Tp>
-    inline bool
-    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
-    noexcept
-    { return true; }
-
-  template<typename _T1, typename _T2>
-    inline bool
-    operator!=(const allocator<_T1>&, const allocator<_T2>&)
-    noexcept
-    { return false; }
-
-  template<typename _Tp>
-    inline bool
-    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
-    noexcept
-    { return false; }
-
-
-
-
-
-
-  extern template class allocator<char>;
-  extern template class allocator<wchar_t>;
-
-
-
-
-
-
-  template<typename _Alloc, bool = __is_empty(_Alloc)>
-    struct __alloc_swap
-    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
-
-  template<typename _Alloc>
-    struct __alloc_swap<_Alloc, false>
-    {
-      static void
-      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
-      {
-
- if (__one != __two)
-   swap(__one, __two);
-      }
-    };
-
-
-  template<typename _Alloc, bool = __is_empty(_Alloc)>
-    struct __alloc_neq
-    {
-      static bool
-      _S_do_it(const _Alloc&, const _Alloc&)
-      { return false; }
-    };
-
-  template<typename _Alloc>
-    struct __alloc_neq<_Alloc, false>
-    {
-      static bool
-      _S_do_it(const _Alloc& __one, const _Alloc& __two)
-      { return __one != __two; }
-    };
-
-
-  template<typename _Tp, bool
-    = __or_<is_copy_constructible<typename _Tp::value_type>,
-            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
-    struct __shrink_to_fit_aux
-    { static bool _S_do_it(_Tp&) noexcept { return false; } };
-
-  template<typename _Tp>
-    struct __shrink_to_fit_aux<_Tp, true>
-    {
-      static bool
-      _S_do_it(_Tp& __c) noexcept
-      {
-
- try
-   {
-     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
-  __make_move_if_noexcept_iterator(__c.end()),
-  __c.get_allocator()).swap(__c);
-     return true;
-   }
- catch(...)
-   { return false; }
-
-
-
-      }
-    };
-
-
-
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 1 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/cxxabi_forced.h" 3
-
-#pragma GCC visibility push(default)
-
-
-namespace __cxxabiv1
-{
-
-
-
-
-
-
-
-  class __forced_unwind
-  {
-    virtual ~__forced_unwind() throw();
-
-
-    virtual void __pure_dummy() = 0;
-  };
-}
-
-
-#pragma GCC visibility pop
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream_insert.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    inline void
-    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
-      const _CharT* __s, streamsize __n)
-    {
-      typedef basic_ostream<_CharT, _Traits> __ostream_type;
-      typedef typename __ostream_type::ios_base __ios_base;
-
-      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
-      if (__put != __n)
- __out.setstate(__ios_base::badbit);
-    }
-
-  template<typename _CharT, typename _Traits>
-    inline void
-    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
-    {
-      typedef basic_ostream<_CharT, _Traits> __ostream_type;
-      typedef typename __ostream_type::ios_base __ios_base;
-
-      const _CharT __c = __out.fill();
-      for (; __n > 0; --__n)
- {
-   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
-   if (_Traits::eq_int_type(__put, _Traits::eof()))
-     {
-       __out.setstate(__ios_base::badbit);
-       break;
-     }
- }
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
-       const _CharT* __s, streamsize __n)
-    {
-      typedef basic_ostream<_CharT, _Traits> __ostream_type;
-      typedef typename __ostream_type::ios_base __ios_base;
-
-      typename __ostream_type::sentry __cerb(__out);
-      if (__cerb)
- {
-   try
-     {
-       const streamsize __w = __out.width();
-       if (__w > __n)
-  {
-    const bool __left = ((__out.flags()
-     & __ios_base::adjustfield)
-           == __ios_base::left);
-    if (!__left)
-      __ostream_fill(__out, __w - __n);
-    if (__out.good())
-      __ostream_write(__out, __s, __n);
-    if (__left && __out.good())
-      __ostream_fill(__out, __w - __n);
-  }
-       else
-  __ostream_write(__out, __s, __n);
-       __out.width(0);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __out._M_setstate(__ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { __out._M_setstate(__ios_base::badbit); }
- }
-      return __out;
-    }
-
-
-
-
-  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
-
-
-  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
-          streamsize);
-
-
-
-
-}
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Arg, typename _Result>
-    struct unary_function
-    {
-
-      typedef _Arg argument_type;
-
-
-      typedef _Result result_type;
-    };
-
-
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    struct binary_function
-    {
-
-      typedef _Arg1 first_argument_type;
-
-
-      typedef _Arg2 second_argument_type;
-
-
-      typedef _Result result_type;
-    };
-# 144 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  struct __is_transparent;
-
-  template<typename _Tp = void>
-    struct plus;
-
-  template<typename _Tp = void>
-    struct minus;
-
-  template<typename _Tp = void>
-    struct multiplies;
-
-  template<typename _Tp = void>
-    struct divides;
-
-  template<typename _Tp = void>
-    struct modulus;
-
-  template<typename _Tp = void>
-    struct negate;
-
-
-
-  template<typename _Tp>
-    struct plus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x + __y; }
-    };
-
-
-  template<typename _Tp>
-    struct minus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x - __y; }
-    };
-
-
-  template<typename _Tp>
-    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x * __y; }
-    };
-
-
-  template<typename _Tp>
-    struct divides : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x / __y; }
-    };
-
-
-  template<typename _Tp>
-    struct modulus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x % __y; }
-    };
-
-
-  template<typename _Tp>
-    struct negate : public unary_function<_Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x) const
-      { return -__x; }
-    };
-
-
-
-
-
-  template<>
-    struct plus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct minus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct multiplies<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct divides<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct modulus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct negate<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(-std::forward<_Tp>(__t)))
- -> decltype(-std::forward<_Tp>(__t))
- { return -std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Tp = void>
-    struct equal_to;
-
-  template<typename _Tp = void>
-    struct not_equal_to;
-
-  template<typename _Tp = void>
-    struct greater;
-
-  template<typename _Tp = void>
-    struct less;
-
-  template<typename _Tp = void>
-    struct greater_equal;
-
-  template<typename _Tp = void>
-    struct less_equal;
-
-
-
-  template<typename _Tp>
-    struct equal_to : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x == __y; }
-    };
-
-
-  template<typename _Tp>
-    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x != __y; }
-    };
-
-
-  template<typename _Tp>
-    struct greater : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x > __y; }
-    };
-
-
-  template<typename _Tp>
-    struct less : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x < __y; }
-    };
-
-
-  template<typename _Tp>
-    struct greater_equal : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x >= __y; }
-    };
-
-
-  template<typename _Tp>
-    struct less_equal : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x <= __y; }
-    };
-
-
-
-  template<>
-    struct equal_to<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct not_equal_to<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct greater<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct less<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct greater_equal<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct less_equal<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Tp = void>
-    struct logical_and;
-
-  template<typename _Tp = void>
-    struct logical_or;
-
-  template<typename _Tp = void>
-    struct logical_not;
-
-
-
-  template<typename _Tp>
-    struct logical_and : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x && __y; }
-    };
-
-
-  template<typename _Tp>
-    struct logical_or : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x || __y; }
-    };
-
-
-  template<typename _Tp>
-    struct logical_not : public unary_function<_Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x) const
-      { return !__x; }
-    };
-
-
-
-  template<>
-    struct logical_and<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct logical_or<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct logical_not<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(!std::forward<_Tp>(__t)))
- -> decltype(!std::forward<_Tp>(__t))
- { return !std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-
-
-  template<typename _Tp = void>
-    struct bit_and;
-
-  template<typename _Tp = void>
-    struct bit_or;
-
-  template<typename _Tp = void>
-    struct bit_xor;
-
-  template<typename _Tp = void>
-    struct bit_not;
-
-
-
-
-  template<typename _Tp>
-    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x & __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x | __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x ^ __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_not : public unary_function<_Tp, _Tp>
-    {
-    constexpr
-      _Tp
-      operator()(const _Tp& __x) const
-      { return ~__x; }
-    };
-
-
-  template <>
-    struct bit_and<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_or<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_xor<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_not<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(~std::forward<_Tp>(__t)))
- -> decltype(~std::forward<_Tp>(__t))
- { return ~std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 740 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Predicate>
-    class unary_negate
-    : public unary_function<typename _Predicate::argument_type, bool>
-    {
-    protected:
-      _Predicate _M_pred;
-
-    public:
-      constexpr
-      explicit
-      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
-
-      constexpr
-      bool
-      operator()(const typename _Predicate::argument_type& __x) const
-      { return !_M_pred(__x); }
-    };
-
-
-  template<typename _Predicate>
-    constexpr
-    inline unary_negate<_Predicate>
-    not1(const _Predicate& __pred)
-    { return unary_negate<_Predicate>(__pred); }
-
-
-  template<typename _Predicate>
-    class binary_negate
-    : public binary_function<typename _Predicate::first_argument_type,
-        typename _Predicate::second_argument_type, bool>
-    {
-    protected:
-      _Predicate _M_pred;
-
-    public:
-      constexpr
-      explicit
-      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
-
-      constexpr
-      bool
-      operator()(const typename _Predicate::first_argument_type& __x,
-   const typename _Predicate::second_argument_type& __y) const
-      { return !_M_pred(__x, __y); }
-    };
-
-
-  template<typename _Predicate>
-    constexpr
-    inline binary_negate<_Predicate>
-    not2(const _Predicate& __pred)
-    { return binary_negate<_Predicate>(__pred); }
-# 817 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Arg, typename _Result>
-    class pointer_to_unary_function : public unary_function<_Arg, _Result>
-    {
-    protected:
-      _Result (*_M_ptr)(_Arg);
-
-    public:
-      pointer_to_unary_function() { }
-
-      explicit
-      pointer_to_unary_function(_Result (*__x)(_Arg))
-      : _M_ptr(__x) { }
-
-      _Result
-      operator()(_Arg __x) const
-      { return _M_ptr(__x); }
-    };
-
-
-  template<typename _Arg, typename _Result>
-    inline pointer_to_unary_function<_Arg, _Result>
-    ptr_fun(_Result (*__x)(_Arg))
-    { return pointer_to_unary_function<_Arg, _Result>(__x); }
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    class pointer_to_binary_function
-    : public binary_function<_Arg1, _Arg2, _Result>
-    {
-    protected:
-      _Result (*_M_ptr)(_Arg1, _Arg2);
-
-    public:
-      pointer_to_binary_function() { }
-
-      explicit
-      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
-      : _M_ptr(__x) { }
-
-      _Result
-      operator()(_Arg1 __x, _Arg2 __y) const
-      { return _M_ptr(__x, __y); }
-    };
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
-    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
-    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
-
-
-  template<typename _Tp>
-    struct _Identity
-    : public unary_function<_Tp,_Tp>
-    {
-      _Tp&
-      operator()(_Tp& __x) const
-      { return __x; }
-
-      const _Tp&
-      operator()(const _Tp& __x) const
-      { return __x; }
-    };
-
-  template<typename _Pair>
-    struct _Select1st
-    : public unary_function<_Pair, typename _Pair::first_type>
-    {
-      typename _Pair::first_type&
-      operator()(_Pair& __x) const
-      { return __x.first; }
-
-      const typename _Pair::first_type&
-      operator()(const _Pair& __x) const
-      { return __x.first; }
-
-
-      template<typename _Pair2>
-        typename _Pair2::first_type&
-        operator()(_Pair2& __x) const
-        { return __x.first; }
-
-      template<typename _Pair2>
-        const typename _Pair2::first_type&
-        operator()(const _Pair2& __x) const
-        { return __x.first; }
-
-    };
-
-  template<typename _Pair>
-    struct _Select2nd
-    : public unary_function<_Pair, typename _Pair::second_type>
-    {
-      typename _Pair::second_type&
-      operator()(_Pair& __x) const
-      { return __x.second; }
-
-      const typename _Pair::second_type&
-      operator()(const _Pair& __x) const
-      { return __x.second; }
-    };
-# 937 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 3
-  template<typename _Ret, typename _Tp>
-    class mem_fun_t : public unary_function<_Tp*, _Ret>
-    {
-    public:
-      explicit
-      mem_fun_t(_Ret (_Tp::*__pf)())
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp* __p) const
-      { return (__p->*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)();
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp* __p) const
-      { return (__p->*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)() const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
-    {
-    public:
-      explicit
-      mem_fun_ref_t(_Ret (_Tp::*__pf)())
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp& __r) const
-      { return (__r.*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)();
-  };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp& __r) const
-      { return (__r.*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)() const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
-    {
-    public:
-      explicit
-      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp* __p, _Arg __x) const
-      { return (__p->*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg);
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp* __p, _Arg __x) const
-      { return (__p->*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg) const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
-    {
-    public:
-      explicit
-      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp& __r, _Arg __x) const
-      { return (__r.*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg);
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp& __r, _Arg __x) const
-      { return (__r.*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg) const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    inline mem_fun_t<_Ret, _Tp>
-    mem_fun(_Ret (_Tp::*__f)())
-    { return mem_fun_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline const_mem_fun_t<_Ret, _Tp>
-    mem_fun(_Ret (_Tp::*__f)() const)
-    { return const_mem_fun_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline mem_fun_ref_t<_Ret, _Tp>
-    mem_fun_ref(_Ret (_Tp::*__f)())
-    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline const_mem_fun_ref_t<_Ret, _Tp>
-    mem_fun_ref(_Ret (_Tp::*__f)() const)
-    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline mem_fun1_t<_Ret, _Tp, _Arg>
-    mem_fun(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
-    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
-    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
-    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
-
-
-
-
-}
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 1 3
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/backward/binders.h" 3
-  template<typename _Operation>
-    class binder1st
-    : public unary_function<typename _Operation::second_argument_type,
-       typename _Operation::result_type>
-    {
-    protected:
-      _Operation op;
-      typename _Operation::first_argument_type value;
-
-    public:
-      binder1st(const _Operation& __x,
-  const typename _Operation::first_argument_type& __y)
-      : op(__x), value(__y) { }
-
-      typename _Operation::result_type
-      operator()(const typename _Operation::second_argument_type& __x) const
-      { return op(value, __x); }
-
-
-
-      typename _Operation::result_type
-      operator()(typename _Operation::second_argument_type& __x) const
-      { return op(value, __x); }
-    } __attribute__ ((__deprecated__));
-
-
-  template<typename _Operation, typename _Tp>
-    inline binder1st<_Operation>
-    bind1st(const _Operation& __fn, const _Tp& __x)
-    {
-      typedef typename _Operation::first_argument_type _Arg1_type;
-      return binder1st<_Operation>(__fn, _Arg1_type(__x));
-    }
-
-
-  template<typename _Operation>
-    class binder2nd
-    : public unary_function<typename _Operation::first_argument_type,
-       typename _Operation::result_type>
-    {
-    protected:
-      _Operation op;
-      typename _Operation::second_argument_type value;
-
-    public:
-      binder2nd(const _Operation& __x,
-  const typename _Operation::second_argument_type& __y)
-      : op(__x), value(__y) { }
-
-      typename _Operation::result_type
-      operator()(const typename _Operation::first_argument_type& __x) const
-      { return op(__x, value); }
-
-
-
-      typename _Operation::result_type
-      operator()(typename _Operation::first_argument_type& __x) const
-      { return op(__x, value); }
-    } __attribute__ ((__deprecated__));
-
-
-  template<typename _Operation, typename _Tp>
-    inline binder2nd<_Operation>
-    bind2nd(const _Operation& __fn, const _Tp& __x)
-    {
-      typedef typename _Operation::second_argument_type _Arg2_type;
-      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
-    }
-
-
-
-}
-
-#pragma GCC diagnostic pop
-# 1128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_function.h" 2 3
-# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/initializer_list" 3
-
-
-
-
-
-#pragma GCC visibility push(default)
-
-
-
-namespace std
-{
-
-  template<class _E>
-    class initializer_list
-    {
-    public:
-      typedef _E value_type;
-      typedef const _E& reference;
-      typedef const _E& const_reference;
-      typedef size_t size_type;
-      typedef const _E* iterator;
-      typedef const _E* const_iterator;
-
-    private:
-      iterator _M_array;
-      size_type _M_len;
-
-
-      constexpr initializer_list(const_iterator __a, size_type __l)
-      : _M_array(__a), _M_len(__l) { }
-
-    public:
-      constexpr initializer_list() noexcept
-      : _M_array(0), _M_len(0) { }
-
-
-      constexpr size_type
-      size() const noexcept { return _M_len; }
-
-
-      constexpr const_iterator
-      begin() const noexcept { return _M_array; }
-
-
-      constexpr const_iterator
-      end() const noexcept { return begin() + size(); }
-    };
-
-
-
-
-
-
-  template<class _Tp>
-    constexpr const _Tp*
-    begin(initializer_list<_Tp> __ils) noexcept
-    { return __ils.begin(); }
-
-
-
-
-
-
-  template<class _Tp>
-    constexpr const _Tp*
-    end(initializer_list<_Tp> __ils) noexcept
-    { return __ils.end(); }
-}
-
-#pragma GCC visibility pop
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 2 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    begin(_Container& __cont) -> decltype(__cont.begin())
-    { return __cont.begin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    begin(const _Container& __cont) -> decltype(__cont.begin())
-    { return __cont.begin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    end(_Container& __cont) -> decltype(__cont.end())
-    { return __cont.end(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    end(const _Container& __cont) -> decltype(__cont.end())
-    { return __cont.end(); }
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline constexpr _Tp*
-    begin(_Tp (&__arr)[_Nm])
-    { return __arr; }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline constexpr _Tp*
-    end(_Tp (&__arr)[_Nm])
-    { return __arr + _Nm; }
-
-
-
-  template<typename _Tp> class valarray;
-
-  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
-  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
-  template<typename _Tp> _Tp* end(valarray<_Tp>&);
-  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
-
-
-
-
-
-
-  template<typename _Container>
-    inline constexpr auto
-    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
-      -> decltype(std::begin(__cont))
-    { return std::begin(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline constexpr auto
-    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
-      -> decltype(std::end(__cont))
-    { return std::end(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
-    { return __cont.rbegin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
-    { return __cont.rbegin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rend(_Container& __cont) -> decltype(__cont.rend())
-    { return __cont.rend(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rend(const _Container& __cont) -> decltype(__cont.rend())
-    { return __cont.rend(); }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline reverse_iterator<_Tp*>
-    rbegin(_Tp (&__arr)[_Nm])
-    { return reverse_iterator<_Tp*>(__arr + _Nm); }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline reverse_iterator<_Tp*>
-    rend(_Tp (&__arr)[_Nm])
-    { return reverse_iterator<_Tp*>(__arr); }
-
-
-
-
-
-
-  template<typename _Tp>
-    inline reverse_iterator<const _Tp*>
-    rbegin(initializer_list<_Tp> __il)
-    { return reverse_iterator<const _Tp*>(__il.end()); }
-
-
-
-
-
-
-  template<typename _Tp>
-    inline reverse_iterator<const _Tp*>
-    rend(initializer_list<_Tp> __il)
-    { return reverse_iterator<const _Tp*>(__il.begin()); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
-    { return std::rbegin(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    crend(const _Container& __cont) -> decltype(std::rend(__cont))
-    { return std::rend(__cont); }
-# 320 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/range_access.h" 3
-}
-# 52 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 1 3
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  struct __allocator_traits_base
-  {
-    template<typename _Alloc, typename _Up>
-      using __rebind = typename _Alloc::template rebind<_Up>::other;
-
-  protected:
-    template<typename _Tp>
-      using __pointer = typename _Tp::pointer;
-    template<typename _Tp>
-      using __c_pointer = typename _Tp::const_pointer;
-    template<typename _Tp>
-      using __v_pointer = typename _Tp::void_pointer;
-    template<typename _Tp>
-      using __cv_pointer = typename _Tp::const_void_pointer;
-    template<typename _Tp>
-      using __diff_type = typename _Tp::difference_type;
-    template<typename _Tp>
-      using __size_type = typename _Tp::size_type;
-    template<typename _Tp>
-      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
-    template<typename _Tp>
-      using __pocma = typename _Tp::propagate_on_container_move_assignment;
-    template<typename _Tp>
-      using __pocs = typename _Tp::propagate_on_container_swap;
-    template<typename _Tp>
-      using __equal = typename _Tp::is_always_equal;
-  };
-
-  template<typename _Alloc, typename _Up>
-    using __alloc_rebind = __detected_or_t_<__replace_first_arg_t,
-         __allocator_traits_base::__rebind,
-         _Alloc, _Up>;
-
-
-
-
-
-  template<typename _Alloc>
-    struct allocator_traits : __allocator_traits_base
-    {
-
-      typedef _Alloc allocator_type;
-
-      typedef typename _Alloc::value_type value_type;
-
-
-
-
-
-
-      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
-
-
-
-
-
-
-
-      using const_pointer
- = __detected_or_t<__ptr_rebind<pointer, const value_type>,
-     __c_pointer, _Alloc>;
-
-
-
-
-
-
-
-      using void_pointer
- = __detected_or_t<__ptr_rebind<pointer, void>, __v_pointer, _Alloc>;
-
-
-
-
-
-
-
-      using const_void_pointer
- = __detected_or_t<__ptr_rebind<pointer, const void>, __cv_pointer,
-     _Alloc>;
-
-
-
-
-
-
-
-      using difference_type
- = __detected_or_t<typename pointer_traits<pointer>::difference_type,
-     __diff_type, _Alloc>;
-
-
-
-
-
-
-
-      using size_type
- = __detected_or_t<typename make_unsigned<difference_type>::type,
-     __size_type, _Alloc>;
-
-
-
-
-
-
-
-      using propagate_on_container_copy_assignment
- = __detected_or_t<false_type, __pocca, _Alloc>;
-
-
-
-
-
-
-
-      using propagate_on_container_move_assignment
- = __detected_or_t<false_type, __pocma, _Alloc>;
-
-
-
-
-
-
-
-      using propagate_on_container_swap
- = __detected_or_t<false_type, __pocs, _Alloc>;
-
-
-
-
-
-
-
-      using is_always_equal
- = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
-
-      template<typename _Tp>
- using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
-      template<typename _Tp>
- using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
-
-      static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value,
-   "allocator defines rebind or is like Alloc<T, Args>");
-
-    private:
-      template<typename _Alloc2>
- static auto
- _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
- -> decltype(__a.allocate(__n, __hint))
- { return __a.allocate(__n, __hint); }
-
-      template<typename _Alloc2>
- static pointer
- _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
- { return __a.allocate(__n); }
-
-      template<typename _Tp, typename... _Args>
- struct __construct_helper
- {
-   template<typename _Alloc2,
-     typename = decltype(std::declval<_Alloc2*>()->construct(
-    std::declval<_Tp*>(), std::declval<_Args>()...))>
-     static true_type __test(int);
-
-   template<typename>
-     static false_type __test(...);
-
-   using type = decltype(__test<_Alloc>(0));
- };
-
-      template<typename _Tp, typename... _Args>
- using __has_construct
-   = typename __construct_helper<_Tp, _Args...>::type;
-
-      template<typename _Tp, typename... _Args>
- static _Require<__has_construct<_Tp, _Args...>>
- _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
- { __a.construct(__p, std::forward<_Args>(__args)...); }
-
-      template<typename _Tp, typename... _Args>
- static
- _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
-          is_constructible<_Tp, _Args...>>>
- _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
- { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
-
-      template<typename _Alloc2, typename _Tp>
- static auto
- _S_destroy(_Alloc2& __a, _Tp* __p, int)
- -> decltype(__a.destroy(__p))
- { __a.destroy(__p); }
-
-      template<typename _Alloc2, typename _Tp>
- static void
- _S_destroy(_Alloc2&, _Tp* __p, ...)
- { __p->~_Tp(); }
-
-      template<typename _Alloc2>
- static auto
- _S_max_size(_Alloc2& __a, int)
- -> decltype(__a.max_size())
- { return __a.max_size(); }
-
-      template<typename _Alloc2>
- static size_type
- _S_max_size(_Alloc2&, ...)
- {
-
-
-   return __gnu_cxx::__numeric_traits<size_type>::__max
-     / sizeof(value_type);
- }
-
-      template<typename _Alloc2>
- static auto
- _S_select(_Alloc2& __a, int)
- -> decltype(__a.select_on_container_copy_construction())
- { return __a.select_on_container_copy_construction(); }
-
-      template<typename _Alloc2>
- static _Alloc2
- _S_select(_Alloc2& __a, ...)
- { return __a; }
-
-    public:
-# 279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static pointer
-      allocate(_Alloc& __a, size_type __n)
-      { return __a.allocate(__n); }
-# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static pointer
-      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
-      { return _S_allocate(__a, __n, __hint, 0); }
-# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static void
-      deallocate(_Alloc& __a, pointer __p, size_type __n)
-      { __a.deallocate(__p, __n); }
-# 321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      template<typename _Tp, typename... _Args>
- static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
- -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
- { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
-# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      template<typename _Tp>
- static void destroy(_Alloc& __a, _Tp* __p)
- { _S_destroy(__a, __p, 0); }
-# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static size_type max_size(const _Alloc& __a) noexcept
-      { return _S_max_size(__a, 0); }
-# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static _Alloc
-      select_on_container_copy_construction(const _Alloc& __rhs)
-      { return _S_select(__rhs, 0); }
-    };
-
-
-  template<typename _Tp>
-    struct allocator_traits<allocator<_Tp>>
-    {
-
-      using allocator_type = allocator<_Tp>;
-
-      using value_type = _Tp;
-
-
-      using pointer = _Tp*;
-
-
-      using const_pointer = const _Tp*;
-
-
-      using void_pointer = void*;
-
-
-      using const_void_pointer = const void*;
-
-
-      using difference_type = std::ptrdiff_t;
-
-
-      using size_type = std::size_t;
-
-
-      using propagate_on_container_copy_assignment = false_type;
-
-
-      using propagate_on_container_move_assignment = true_type;
-
-
-      using propagate_on_container_swap = false_type;
-
-
-      using is_always_equal = true_type;
-
-      template<typename _Up>
- using rebind_alloc = allocator<_Up>;
-
-      template<typename _Up>
- using rebind_traits = allocator_traits<allocator<_Up>>;
-# 414 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static pointer
-      allocate(allocator_type& __a, size_type __n)
-      { return __a.allocate(__n); }
-# 428 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static pointer
-      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
-      { return __a.allocate(__n, __hint); }
-# 440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      static void
-      deallocate(allocator_type& __a, pointer __p, size_type __n)
-      { __a.deallocate(__p, __n); }
-# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      template<typename _Up, typename... _Args>
- static void
- construct(allocator_type& __a, _Up* __p, _Args&&... __args)
- { __a.construct(__p, std::forward<_Args>(__args)...); }
-# 464 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/alloc_traits.h" 3
-      template<typename _Up>
- static void
- destroy(allocator_type& __a, _Up* __p)
- { __a.destroy(__p); }
-
-
-
-
-
-
-      static size_type
-      max_size(const allocator_type& __a) noexcept
-      { return __a.max_size(); }
-
-
-
-
-
-
-      static allocator_type
-      select_on_container_copy_construction(const allocator_type& __rhs)
-      { return __rhs; }
-    };
-
-
-  template<typename _Alloc>
-    inline void
-    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
-    { __one = __two; }
-
-  template<typename _Alloc>
-    inline void
-    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
-      __do_alloc_on_copy(__one, __two, __pocca());
-    }
-
-  template<typename _Alloc>
-    inline _Alloc __alloc_on_copy(const _Alloc& __a)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      return __traits::select_on_container_copy_construction(__a);
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
-    { __one = std::move(__two); }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_move_assignment __pocma;
-      __do_alloc_on_move(__one, __two, __pocma());
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
-    {
-      using std::swap;
-      swap(__one, __two);
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_swap __pocs;
-      __do_alloc_on_swap(__one, __two, __pocs());
-    }
-
-  template<typename _Alloc>
-    class __is_copy_insertable_impl
-    {
-      typedef allocator_traits<_Alloc> _Traits;
-
-      template<typename _Up, typename
-        = decltype(_Traits::construct(std::declval<_Alloc&>(),
-          std::declval<_Up*>(),
-          std::declval<const _Up&>()))>
- static true_type
- _M_select(int);
-
-      template<typename _Up>
- static false_type
- _M_select(...);
-
-    public:
-      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
-    };
-
-
-  template<typename _Alloc>
-    struct __is_copy_insertable
-    : __is_copy_insertable_impl<_Alloc>::type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_copy_insertable<allocator<_Tp>>
-    : is_copy_constructible<_Tp>
-    { };
-
-
-}
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 2 3
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-template<typename _Alloc>
-  struct __alloc_traits
-
-  : std::allocator_traits<_Alloc>
-
-  {
-    typedef _Alloc allocator_type;
-
-    typedef std::allocator_traits<_Alloc> _Base_type;
-    typedef typename _Base_type::value_type value_type;
-    typedef typename _Base_type::pointer pointer;
-    typedef typename _Base_type::const_pointer const_pointer;
-    typedef typename _Base_type::size_type size_type;
-    typedef typename _Base_type::difference_type difference_type;
-
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    using _Base_type::allocate;
-    using _Base_type::deallocate;
-    using _Base_type::construct;
-    using _Base_type::destroy;
-    using _Base_type::max_size;
-
-  private:
-    template<typename _Ptr>
-      using __is_custom_pointer
- = std::__and_<std::is_same<pointer, _Ptr>,
-        std::__not_<std::is_pointer<_Ptr>>>;
-
-  public:
-
-    template<typename _Ptr, typename... _Args>
-      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
-      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
-      {
- _Base_type::construct(__a, std::addressof(*__p),
-         std::forward<_Args>(__args)...);
-      }
-
-
-    template<typename _Ptr>
-      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
-      destroy(_Alloc& __a, _Ptr __p)
-      { _Base_type::destroy(__a, std::addressof(*__p)); }
-
-    static _Alloc _S_select_on_copy(const _Alloc& __a)
-    { return _Base_type::select_on_container_copy_construction(__a); }
-
-    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
-    { std::__alloc_on_swap(__a, __b); }
-
-    static constexpr bool _S_propagate_on_copy_assign()
-    { return _Base_type::propagate_on_container_copy_assignment::value; }
-
-    static constexpr bool _S_propagate_on_move_assign()
-    { return _Base_type::propagate_on_container_move_assignment::value; }
-
-    static constexpr bool _S_propagate_on_swap()
-    { return _Base_type::propagate_on_container_swap::value; }
-
-    static constexpr bool _S_always_equal()
-    { return _Base_type::is_always_equal::value; }
-
-    static constexpr bool _S_nothrow_move()
-    { return _S_propagate_on_move_assign() || _S_always_equal(); }
-
-    template<typename _Tp>
-      struct rebind
-      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
-# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/alloc_traits.h" 3
-  };
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-namespace __cxx11 {
-# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    class basic_string
-    {
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_CharT>::other _Char_alloc_type;
-      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
-
-
-    public:
-      typedef _Traits traits_type;
-      typedef typename _Traits::char_type value_type;
-      typedef _Char_alloc_type allocator_type;
-      typedef typename _Alloc_traits::size_type size_type;
-      typedef typename _Alloc_traits::difference_type difference_type;
-      typedef typename _Alloc_traits::reference reference;
-      typedef typename _Alloc_traits::const_reference const_reference;
-      typedef typename _Alloc_traits::pointer pointer;
-      typedef typename _Alloc_traits::const_pointer const_pointer;
-      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
-      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
-       const_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-
-
-      static const size_type npos = static_cast<size_type>(-1);
-
-    private:
-
-
-
-
-      typedef const_iterator __const_iterator;
-
-
-
-      struct _Alloc_hider : allocator_type
-      {
- _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
- : allocator_type(__a), _M_p(__dat) { }
-
- pointer _M_p;
-      };
-
-      _Alloc_hider _M_dataplus;
-      size_type _M_string_length;
-
-      enum { _S_local_capacity = 15 / sizeof(_CharT) };
-
-      union
-      {
- _CharT _M_local_buf[_S_local_capacity + 1];
- size_type _M_allocated_capacity;
-      };
-
-      void
-      _M_data(pointer __p)
-      { _M_dataplus._M_p = __p; }
-
-      void
-      _M_length(size_type __length)
-      { _M_string_length = __length; }
-
-      pointer
-      _M_data() const
-      { return _M_dataplus._M_p; }
-
-      pointer
-      _M_local_data()
-      {
-
- return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
-
-
-
-      }
-
-      const_pointer
-      _M_local_data() const
-      {
-
- return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
-
-
-
-      }
-
-      void
-      _M_capacity(size_type __capacity)
-      { _M_allocated_capacity = __capacity; }
-
-      void
-      _M_set_length(size_type __n)
-      {
- _M_length(__n);
- traits_type::assign(_M_data()[__n], _CharT());
-      }
-
-      bool
-      _M_is_local() const
-      { return _M_data() == _M_local_data(); }
-
-
-      pointer
-      _M_create(size_type&, size_type);
-
-      void
-      _M_dispose()
-      {
- if (!_M_is_local())
-   _M_destroy(_M_allocated_capacity);
-      }
-
-      void
-      _M_destroy(size_type __size) throw()
-      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
-
-
-
-      template<typename _InIterator>
-        void
-        _M_construct_aux(_InIterator __beg, _InIterator __end,
-    std::__false_type)
- {
-          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
-          _M_construct(__beg, __end, _Tag());
- }
-
-
-
-      template<typename _Integer>
-        void
-        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
- { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
-
-      void
-      _M_construct_aux_2(size_type __req, _CharT __c)
-      { _M_construct(__req, __c); }
-
-      template<typename _InIterator>
-        void
-        _M_construct(_InIterator __beg, _InIterator __end)
- {
-   typedef typename std::__is_integer<_InIterator>::__type _Integral;
-   _M_construct_aux(__beg, __end, _Integral());
-        }
-
-
-      template<typename _InIterator>
-        void
-        _M_construct(_InIterator __beg, _InIterator __end,
-       std::input_iterator_tag);
-
-
-
-      template<typename _FwdIterator>
-        void
-        _M_construct(_FwdIterator __beg, _FwdIterator __end,
-       std::forward_iterator_tag);
-
-      void
-      _M_construct(size_type __req, _CharT __c);
-
-      allocator_type&
-      _M_get_allocator()
-      { return _M_dataplus; }
-
-      const allocator_type&
-      _M_get_allocator() const
-      { return _M_dataplus; }
-
-    private:
-# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      _M_check(size_type __pos, const char* __s) const
-      {
- if (__pos > this->size())
-   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),
-
-       __s, __pos, this->size());
- return __pos;
-      }
-
-      void
-      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
-      {
- if (this->max_size() - (this->size() - __n1) < __n2)
-   __throw_length_error((__s));
-      }
-
-
-
-      size_type
-      _M_limit(size_type __pos, size_type __off) const noexcept
-      {
- const bool __testoff = __off < this->size() - __pos;
- return __testoff ? __off : this->size() - __pos;
-      }
-
-
-      bool
-      _M_disjunct(const _CharT* __s) const noexcept
-      {
- return (less<const _CharT*>()(__s, _M_data())
-  || less<const _CharT*>()(_M_data() + this->size(), __s));
-      }
-
-
-
-      static void
-      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
-      {
- if (__n == 1)
-   traits_type::assign(*__d, *__s);
- else
-   traits_type::copy(__d, __s, __n);
-      }
-
-      static void
-      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
-      {
- if (__n == 1)
-   traits_type::assign(*__d, *__s);
- else
-   traits_type::move(__d, __s, __n);
-      }
-
-      static void
-      _S_assign(_CharT* __d, size_type __n, _CharT __c)
-      {
- if (__n == 1)
-   traits_type::assign(*__d, __c);
- else
-   traits_type::assign(__d, __n, __c);
-      }
-
-
-
-      template<class _Iterator>
-        static void
-        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
-        {
-   for (; __k1 != __k2; ++__k1, (void)++__p)
-     traits_type::assign(*__p, *__k1);
- }
-
-      static void
-      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
-      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
-
-      static void
-      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
-      noexcept
-      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
-
-      static void
-      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
-      { _S_copy(__p, __k1, __k2 - __k1); }
-
-      static void
-      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
-      noexcept
-      { _S_copy(__p, __k1, __k2 - __k1); }
-
-      static int
-      _S_compare(size_type __n1, size_type __n2) noexcept
-      {
- const difference_type __d = difference_type(__n1 - __n2);
-
- if (__d > __gnu_cxx::__numeric_traits<int>::__max)
-   return __gnu_cxx::__numeric_traits<int>::__max;
- else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
-   return __gnu_cxx::__numeric_traits<int>::__min;
- else
-   return int(__d);
-      }
-
-      void
-      _M_assign(const basic_string& __rcs);
-
-      void
-      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
-  size_type __len2);
-
-      void
-      _M_erase(size_type __pos, size_type __n);
-
-    public:
-
-
-
-
-
-
-
-      basic_string()
-      noexcept(is_nothrow_default_constructible<_Alloc>::value)
-      : _M_dataplus(_M_local_data())
-      { _M_set_length(0); }
-
-
-
-
-      explicit
-      basic_string(const _Alloc& __a) noexcept
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_set_length(0); }
-
-
-
-
-
-      basic_string(const basic_string& __str)
-      : _M_dataplus(_M_local_data(),
-      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
-      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
-# 410 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string(const basic_string& __str, size_type __pos,
-     size_type __n = npos)
-      : _M_dataplus(_M_local_data())
-      {
- const _CharT* __start = __str._M_data()
-   + __str._M_check(__pos, "basic_string::basic_string");
- _M_construct(__start, __start + __str._M_limit(__pos, __n));
-      }
-# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string(const basic_string& __str, size_type __pos,
-     size_type __n, const _Alloc& __a)
-      : _M_dataplus(_M_local_data(), __a)
-      {
- const _CharT* __start
-   = __str._M_data() + __str._M_check(__pos, "string::string");
- _M_construct(__start, __start + __str._M_limit(__pos, __n));
-      }
-# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string(const _CharT* __s, size_type __n,
-     const _Alloc& __a = _Alloc())
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_construct(__s, __s + __n); }
-
-
-
-
-
-
-      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
-
-
-
-
-
-
-
-      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_construct(__n, __c); }
-# 476 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string(basic_string&& __str) noexcept
-      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
-      {
- if (__str._M_is_local())
-   {
-     traits_type::copy(_M_local_buf, __str._M_local_buf,
-         _S_local_capacity + 1);
-   }
- else
-   {
-     _M_data(__str._M_data());
-     _M_capacity(__str._M_allocated_capacity);
-   }
-
-
-
-
- _M_length(__str.length());
- __str._M_data(__str._M_local_data());
- __str._M_set_length(0);
-      }
-
-
-
-
-
-
-      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_construct(__l.begin(), __l.end()); }
-
-      basic_string(const basic_string& __str, const _Alloc& __a)
-      : _M_dataplus(_M_local_data(), __a)
-      { _M_construct(__str.begin(), __str.end()); }
-
-      basic_string(basic_string&& __str, const _Alloc& __a)
-      noexcept(_Alloc_traits::_S_always_equal())
-      : _M_dataplus(_M_local_data(), __a)
-      {
- if (__str._M_is_local())
-   {
-     traits_type::copy(_M_local_buf, __str._M_local_buf,
-         _S_local_capacity + 1);
-     _M_length(__str.length());
-     __str._M_set_length(0);
-   }
- else if (_Alloc_traits::_S_always_equal()
-     || __str.get_allocator() == __a)
-   {
-     _M_data(__str._M_data());
-     _M_length(__str.length());
-     _M_capacity(__str._M_allocated_capacity);
-     __str._M_data(__str._M_local_buf);
-     __str._M_set_length(0);
-   }
- else
-   _M_construct(__str.begin(), __str.end());
-      }
-# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-
-
-
-        basic_string(_InputIterator __beg, _InputIterator __end,
-       const _Alloc& __a = _Alloc())
- : _M_dataplus(_M_local_data(), __a)
- { _M_construct(__beg, __end); }
-
-
-
-
-      ~basic_string()
-      { _M_dispose(); }
-
-
-
-
-
-      basic_string&
-      operator=(const basic_string& __str)
-      {
-
- if (_Alloc_traits::_S_propagate_on_copy_assign())
-   {
-     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
-  && _M_get_allocator() != __str._M_get_allocator())
-       {
-
-  _M_destroy(_M_allocated_capacity);
-  _M_data(_M_local_data());
-  _M_set_length(0);
-       }
-     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
-   }
-
- return this->assign(__str);
-      }
-
-
-
-
-
-      basic_string&
-      operator=(const _CharT* __s)
-      { return this->assign(__s); }
-# 599 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      operator=(_CharT __c)
-      {
- this->assign(1, __c);
- return *this;
-      }
-# 617 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      operator=(basic_string&& __str)
-      noexcept(_Alloc_traits::_S_nothrow_move())
-      {
- if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
-     && !_Alloc_traits::_S_always_equal()
-     && _M_get_allocator() != __str._M_get_allocator())
-   {
-
-     _M_destroy(_M_allocated_capacity);
-     _M_data(_M_local_data());
-     _M_set_length(0);
-   }
-
- std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
-
- if (!__str._M_is_local()
-     && (_Alloc_traits::_S_propagate_on_move_assign()
-       || _Alloc_traits::_S_always_equal()))
-   {
-     pointer __data = nullptr;
-     size_type __capacity;
-     if (!_M_is_local())
-       {
-  if (_Alloc_traits::_S_always_equal())
-    {
-      __data = _M_data();
-      __capacity = _M_allocated_capacity;
-    }
-  else
-    _M_destroy(_M_allocated_capacity);
-       }
-
-     _M_data(__str._M_data());
-     _M_length(__str.length());
-     _M_capacity(__str._M_allocated_capacity);
-     if (__data)
-       {
-  __str._M_data(__data);
-  __str._M_capacity(__capacity);
-       }
-     else
-       __str._M_data(__str._M_local_buf);
-   }
- else
-     assign(__str);
- __str.clear();
- return *this;
-      }
-
-
-
-
-
-      basic_string&
-      operator=(initializer_list<_CharT> __l)
-      {
- this->assign(__l.begin(), __l.size());
- return *this;
-      }
-
-
-
-
-
-
-
-      iterator
-      begin() noexcept
-      { return iterator(_M_data()); }
-
-
-
-
-
-      const_iterator
-      begin() const noexcept
-      { return const_iterator(_M_data()); }
-
-
-
-
-
-      iterator
-      end() noexcept
-      { return iterator(_M_data() + this->size()); }
-
-
-
-
-
-      const_iterator
-      end() const noexcept
-      { return const_iterator(_M_data() + this->size()); }
-
-
-
-
-
-
-      reverse_iterator
-      rbegin() noexcept
-      { return reverse_iterator(this->end()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rbegin() const noexcept
-      { return const_reverse_iterator(this->end()); }
-
-
-
-
-
-
-      reverse_iterator
-      rend() noexcept
-      { return reverse_iterator(this->begin()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rend() const noexcept
-      { return const_reverse_iterator(this->begin()); }
-
-
-
-
-
-
-      const_iterator
-      cbegin() const noexcept
-      { return const_iterator(this->_M_data()); }
-
-
-
-
-
-      const_iterator
-      cend() const noexcept
-      { return const_iterator(this->_M_data() + this->size()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      crbegin() const noexcept
-      { return const_reverse_iterator(this->end()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      crend() const noexcept
-      { return const_reverse_iterator(this->begin()); }
-
-
-    public:
-
-
-
-      size_type
-      size() const noexcept
-      { return _M_string_length; }
-
-
-
-      size_type
-      length() const noexcept
-      { return _M_string_length; }
-
-
-      size_type
-      max_size() const noexcept
-      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
-# 813 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      void
-      resize(size_type __n, _CharT __c);
-# 826 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      void
-      resize(size_type __n)
-      { this->resize(__n, _CharT()); }
-
-
-
-      void
-      shrink_to_fit() noexcept
-      {
-
- if (capacity() > size())
-   {
-     try
-       { reserve(0); }
-     catch(...)
-       { }
-   }
-
-      }
-
-
-
-
-
-
-      size_type
-      capacity() const noexcept
-      {
- return _M_is_local() ? size_type(_S_local_capacity)
-                      : _M_allocated_capacity;
-      }
-# 875 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      void
-      reserve(size_type __res_arg = 0);
-
-
-
-
-      void
-      clear() noexcept
-      { _M_set_length(0); }
-
-
-
-
-
-      bool
-      empty() const noexcept
-      { return this->size() == 0; }
-# 904 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      const_reference
-      operator[] (size_type __pos) const noexcept
-      {
-                                  ;
- return _M_data()[__pos];
-      }
-# 921 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      reference
-      operator[](size_type __pos)
-      {
-
-
-                                  ;
-
-                                                                   ;
- return _M_data()[__pos];
-      }
-# 942 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      const_reference
-      at(size_type __n) const
-      {
- if (__n >= this->size())
-   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
-
-
-       __n, this->size());
- return _M_data()[__n];
-      }
-# 963 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      reference
-      at(size_type __n)
-      {
- if (__n >= size())
-   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
-
-
-       __n, this->size());
- return _M_data()[__n];
-      }
-
-
-
-
-
-
-      reference
-      front() noexcept
-      {
-                           ;
- return operator[](0);
-      }
-
-
-
-
-
-      const_reference
-      front() const noexcept
-      {
-                           ;
- return operator[](0);
-      }
-
-
-
-
-
-      reference
-      back() noexcept
-      {
-                           ;
- return operator[](this->size() - 1);
-      }
-
-
-
-
-
-      const_reference
-      back() const noexcept
-      {
-                           ;
- return operator[](this->size() - 1);
-      }
-# 1026 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      operator+=(const basic_string& __str)
-      { return this->append(__str); }
-
-
-
-
-
-
-      basic_string&
-      operator+=(const _CharT* __s)
-      { return this->append(__s); }
-
-
-
-
-
-
-      basic_string&
-      operator+=(_CharT __c)
-      {
- this->push_back(__c);
- return *this;
-      }
-
-
-
-
-
-
-
-      basic_string&
-      operator+=(initializer_list<_CharT> __l)
-      { return this->append(__l.begin(), __l.size()); }
-
-
-
-
-
-
-
-      basic_string&
-      append(const basic_string& __str)
-      { return _M_append(__str._M_data(), __str.size()); }
-# 1084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      append(const basic_string& __str, size_type __pos, size_type __n)
-      { return _M_append(__str._M_data()
-    + __str._M_check(__pos, "basic_string::append"),
-    __str._M_limit(__pos, __n)); }
-
-
-
-
-
-
-
-      basic_string&
-      append(const _CharT* __s, size_type __n)
-      {
-                                        ;
- _M_check_length(size_type(0), __n, "basic_string::append");
- return _M_append(__s, __n);
-      }
-
-
-
-
-
-
-      basic_string&
-      append(const _CharT* __s)
-      {
-                               ;
- const size_type __n = traits_type::length(__s);
- _M_check_length(size_type(0), __n, "basic_string::append");
- return _M_append(__s, __n);
-      }
-# 1126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      append(size_type __n, _CharT __c)
-      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
-
-
-
-
-
-
-
-      basic_string&
-      append(initializer_list<_CharT> __l)
-      { return this->append(__l.begin(), __l.size()); }
-# 1150 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      template<class _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-
-
-
-        basic_string&
-        append(_InputIterator __first, _InputIterator __last)
-        { return this->replace(end(), end(), __first, __last); }
-
-
-
-
-
-      void
-      push_back(_CharT __c)
-      {
- const size_type __size = this->size();
- if (__size + 1 > this->capacity())
-   this->_M_mutate(__size, size_type(0), 0, size_type(1));
- traits_type::assign(this->_M_data()[__size], __c);
- this->_M_set_length(__size + 1);
-      }
-
-
-
-
-
-
-      basic_string&
-      assign(const basic_string& __str)
-      {
- this->_M_assign(__str);
- return *this;
-      }
-# 1194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      assign(basic_string&& __str)
-      noexcept(_Alloc_traits::_S_nothrow_move())
-      {
-
-
- return *this = std::move(__str);
-      }
-# 1217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      assign(const basic_string& __str, size_type __pos, size_type __n)
-      { return _M_replace(size_type(0), this->size(), __str._M_data()
-     + __str._M_check(__pos, "basic_string::assign"),
-     __str._M_limit(__pos, __n)); }
-# 1233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      assign(const _CharT* __s, size_type __n)
-      {
-                                        ;
- return _M_replace(size_type(0), this->size(), __s, __n);
-      }
-# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      assign(const _CharT* __s)
-      {
-                               ;
- return _M_replace(size_type(0), this->size(), __s,
-     traits_type::length(__s));
-      }
-# 1266 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      assign(size_type __n, _CharT __c)
-      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
-# 1279 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      template<class _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-
-
-
-        basic_string&
-        assign(_InputIterator __first, _InputIterator __last)
-        { return this->replace(begin(), end(), __first, __last); }
-
-
-
-
-
-
-
-      basic_string&
-      assign(initializer_list<_CharT> __l)
-      { return this->assign(__l.begin(), __l.size()); }
-# 1315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      iterator
-      insert(const_iterator __p, size_type __n, _CharT __c)
-      {
-                                                         ;
- const size_type __pos = __p - begin();
- this->replace(__p, __p, __n, __c);
- return iterator(this->_M_data() + __pos);
-      }
-# 1357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      template<class _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
- iterator
-        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
-        {
-                                                           ;
-   const size_type __pos = __p - begin();
-   this->replace(__p, __p, __beg, __end);
-   return iterator(this->_M_data() + __pos);
- }
-# 1393 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      void
-      insert(iterator __p, initializer_list<_CharT> __l)
-      {
-                                                         ;
- this->insert(__p - begin(), __l.begin(), __l.size());
-      }
-# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      insert(size_type __pos1, const basic_string& __str)
-      { return this->replace(__pos1, size_type(0),
-        __str._M_data(), __str.size()); }
-# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      insert(size_type __pos1, const basic_string& __str,
-      size_type __pos2, size_type __n)
-      { return this->replace(__pos1, size_type(0), __str._M_data()
-        + __str._M_check(__pos2, "basic_string::insert"),
-        __str._M_limit(__pos2, __n)); }
-# 1459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      insert(size_type __pos, const _CharT* __s, size_type __n)
-      { return this->replace(__pos, size_type(0), __s, __n); }
-# 1478 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      insert(size_type __pos, const _CharT* __s)
-      {
-                               ;
- return this->replace(__pos, size_type(0), __s,
-        traits_type::length(__s));
-      }
-# 1502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      insert(size_type __pos, size_type __n, _CharT __c)
-      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
-         size_type(0), __n, __c); }
-# 1520 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      iterator
-      insert(__const_iterator __p, _CharT __c)
-      {
-                                                         ;
- const size_type __pos = __p - begin();
- _M_replace_aux(__pos, size_type(0), size_type(1), __c);
- return iterator(_M_data() + __pos);
-      }
-# 1544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      erase(size_type __pos = 0, size_type __n = npos)
-      {
- this->_M_erase(_M_check(__pos, "basic_string::erase"),
-         _M_limit(__pos, __n));
- return *this;
-      }
-# 1560 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      iterator
-      erase(__const_iterator __position)
-      {
-
-                           ;
- const size_type __pos = __position - begin();
- this->_M_erase(__pos, size_type(1));
- return iterator(_M_data() + __pos);
-      }
-# 1579 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      iterator
-      erase(__const_iterator __first, __const_iterator __last)
-      {
-
-                        ;
-        const size_type __pos = __first - begin();
- this->_M_erase(__pos, __last - __first);
- return iterator(this->_M_data() + __pos);
-      }
-
-
-
-
-
-
-
-      void
-      pop_back() noexcept
-      {
-                           ;
- _M_erase(size() - 1, 1);
-      }
-# 1620 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(size_type __pos, size_type __n, const basic_string& __str)
-      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
-# 1642 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(size_type __pos1, size_type __n1, const basic_string& __str,
-       size_type __pos2, size_type __n2)
-      { return this->replace(__pos1, __n1, __str._M_data()
-        + __str._M_check(__pos2, "basic_string::replace"),
-        __str._M_limit(__pos2, __n2)); }
-# 1667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(size_type __pos, size_type __n1, const _CharT* __s,
-       size_type __n2)
-      {
-                                         ;
- return _M_replace(_M_check(__pos, "basic_string::replace"),
-     _M_limit(__pos, __n1), __s, __n2);
-      }
-# 1692 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(size_type __pos, size_type __n1, const _CharT* __s)
-      {
-                               ;
- return this->replace(__pos, __n1, __s, traits_type::length(__s));
-      }
-# 1716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
-      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
-         _M_limit(__pos, __n1), __n2, __c); }
-# 1734 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       const basic_string& __str)
-      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
-# 1754 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       const _CharT* __s, size_type __n)
-      {
-
-                      ;
- return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
-      }
-# 1776 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
-      {
-                               ;
- return this->replace(__i1, __i2, __s, traits_type::length(__s));
-      }
-# 1797 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
-       _CharT __c)
-      {
-
-                      ;
- return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
-      }
-# 1822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      template<class _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        basic_string&
-        replace(const_iterator __i1, const_iterator __i2,
-  _InputIterator __k1, _InputIterator __k2)
-        {
-
-                        ;
-                                             ;
-   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
-        std::__false_type());
- }
-# 1854 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       _CharT* __k1, _CharT* __k2)
-      {
-
-                      ;
-                                           ;
- return this->replace(__i1 - begin(), __i2 - __i1,
-        __k1, __k2 - __k1);
-      }
-
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       const _CharT* __k1, const _CharT* __k2)
-      {
-
-                      ;
-                                           ;
- return this->replace(__i1 - begin(), __i2 - __i1,
-        __k1, __k2 - __k1);
-      }
-
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       iterator __k1, iterator __k2)
-      {
-
-                      ;
-                                           ;
- return this->replace(__i1 - begin(), __i2 - __i1,
-        __k1.base(), __k2 - __k1);
-      }
-
-      basic_string&
-      replace(__const_iterator __i1, __const_iterator __i2,
-       const_iterator __k1, const_iterator __k2)
-      {
-
-                      ;
-                                           ;
- return this->replace(__i1 - begin(), __i2 - __i1,
-        __k1.base(), __k2 - __k1);
-      }
-# 1913 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string& replace(const_iterator __i1, const_iterator __i2,
-       initializer_list<_CharT> __l)
-      { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
-
-
-    private:
-      template<class _Integer>
- basic_string&
- _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
-       _Integer __n, _Integer __val, __true_type)
-        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
-
-      template<class _InputIterator>
- basic_string&
- _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
-       _InputIterator __k1, _InputIterator __k2,
-       __false_type);
-
-      basic_string&
-      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
-       _CharT __c);
-
-      basic_string&
-      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
-   const size_type __len2);
-
-      basic_string&
-      _M_append(const _CharT* __s, size_type __n);
-
-    public:
-# 1956 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
-# 1966 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      void
-      swap(basic_string& __s) noexcept;
-# 1976 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      const _CharT*
-      c_str() const noexcept
-      { return _M_data(); }
-
-
-
-
-
-
-
-      const _CharT*
-      data() const noexcept
-      { return _M_data(); }
-
-
-
-
-      allocator_type
-      get_allocator() const noexcept
-      { return _M_get_allocator(); }
-# 2009 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find(const _CharT* __s, size_type __pos, size_type __n) const;
-# 2022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find(const basic_string& __str, size_type __pos = 0) const
- noexcept
-      { return this->find(__str.data(), __pos, __str.size()); }
-# 2037 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find(const _CharT* __s, size_type __pos = 0) const
-      {
-                               ;
- return this->find(__s, __pos, traits_type::length(__s));
-      }
-# 2054 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find(_CharT __c, size_type __pos = 0) const noexcept;
-# 2067 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      rfind(const basic_string& __str, size_type __pos = npos) const
- noexcept
-      { return this->rfind(__str.data(), __pos, __str.size()); }
-# 2084 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
-# 2097 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      rfind(const _CharT* __s, size_type __pos = npos) const
-      {
-                               ;
- return this->rfind(__s, __pos, traits_type::length(__s));
-      }
-# 2114 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      rfind(_CharT __c, size_type __pos = npos) const noexcept;
-# 2128 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_of(const basic_string& __str, size_type __pos = 0) const
- noexcept
-      { return this->find_first_of(__str.data(), __pos, __str.size()); }
-# 2145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
-# 2158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_of(const _CharT* __s, size_type __pos = 0) const
-      {
-                               ;
- return this->find_first_of(__s, __pos, traits_type::length(__s));
-      }
-# 2177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
-      { return this->find(__c, __pos); }
-# 2192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_of(const basic_string& __str, size_type __pos = npos) const
- noexcept
-      { return this->find_last_of(__str.data(), __pos, __str.size()); }
-# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
-# 2222 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_of(const _CharT* __s, size_type __pos = npos) const
-      {
-                               ;
- return this->find_last_of(__s, __pos, traits_type::length(__s));
-      }
-# 2241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
-      { return this->rfind(__c, __pos); }
-# 2255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
- noexcept
-      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
-# 2272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_not_of(const _CharT* __s, size_type __pos,
-   size_type __n) const;
-# 2286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
-      {
-                               ;
- return this->find_first_not_of(__s, __pos, traits_type::length(__s));
-      }
-# 2303 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_first_not_of(_CharT __c, size_type __pos = 0) const
- noexcept;
-# 2318 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
- noexcept
-      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
-# 2335 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_not_of(const _CharT* __s, size_type __pos,
-         size_type __n) const;
-# 2349 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
-      {
-                               ;
- return this->find_last_not_of(__s, __pos, traits_type::length(__s));
-      }
-# 2366 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      size_type
-      find_last_not_of(_CharT __c, size_type __pos = npos) const
- noexcept;
-# 2382 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      basic_string
-      substr(size_type __pos = 0, size_type __n = npos) const
-      { return basic_string(*this,
-       _M_check(__pos, "basic_string::substr"), __n); }
-# 2401 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(const basic_string& __str) const
-      {
- const size_type __size = this->size();
- const size_type __osize = __str.size();
- const size_type __len = std::min(__size, __osize);
-
- int __r = traits_type::compare(_M_data(), __str.data(), __len);
- if (!__r)
-   __r = _S_compare(__size, __osize);
- return __r;
-      }
-# 2433 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(size_type __pos, size_type __n, const basic_string& __str) const;
-# 2459 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(size_type __pos1, size_type __n1, const basic_string& __str,
-       size_type __pos2, size_type __n2) const;
-# 2477 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(const _CharT* __s) const;
-# 2501 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
-# 2528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-      int
-      compare(size_type __pos, size_type __n1, const _CharT* __s,
-       size_type __n2) const;
-  };
-}
-# 4927 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>
-    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    {
-      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
-      __str.append(__rhs);
-      return __str;
-    }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT,_Traits,_Alloc>
-    operator+(const _CharT* __lhs,
-       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT,_Traits,_Alloc>
-    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const _CharT* __rhs)
-    {
-      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
-      __str.append(__rhs);
-      return __str;
-    }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
-    {
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef typename __string_type::size_type __size_type;
-      __string_type __str(__lhs);
-      __str.append(__size_type(1), __rhs);
-      return __str;
-    }
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return std::move(__lhs.append(__rhs)); }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
-    { return std::move(__rhs.insert(0, __lhs)); }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
-       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
-    {
-      const auto __size = __lhs.size() + __rhs.size();
-      const bool __cond = (__size > __lhs.capacity()
-      && __size <= __rhs.capacity());
-      return __cond ? std::move(__rhs.insert(0, __lhs))
-             : std::move(__lhs.append(__rhs));
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(const _CharT* __lhs,
-       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
-    { return std::move(__rhs.insert(0, __lhs)); }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(_CharT __lhs,
-       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
-    { return std::move(__rhs.insert(0, 1, __lhs)); }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
-       const _CharT* __rhs)
-    { return std::move(__lhs.append(__rhs)); }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_string<_CharT, _Traits, _Alloc>
-    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
-       _CharT __rhs)
-    { return std::move(__lhs.append(1, __rhs)); }
-# 5048 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return __lhs.compare(__rhs) == 0; }
-
-  template<typename _CharT>
-    inline
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
-    operator==(const basic_string<_CharT>& __lhs,
-        const basic_string<_CharT>& __rhs) noexcept
-    { return (__lhs.size() == __rhs.size()
-       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
-          __lhs.size())); }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator==(const _CharT* __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return __rhs.compare(__lhs) == 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const _CharT* __rhs)
-    { return __lhs.compare(__rhs) == 0; }
-# 5095 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return !(__lhs == __rhs); }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator!=(const _CharT* __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return !(__lhs == __rhs); }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const _CharT* __rhs)
-    { return !(__lhs == __rhs); }
-# 5133 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return __lhs.compare(__rhs) < 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const _CharT* __rhs)
-    { return __lhs.compare(__rhs) < 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<(const _CharT* __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return __rhs.compare(__lhs) > 0; }
-# 5171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return __lhs.compare(__rhs) > 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-       const _CharT* __rhs)
-    { return __lhs.compare(__rhs) > 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>(const _CharT* __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return __rhs.compare(__lhs) < 0; }
-# 5209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return __lhs.compare(__rhs) <= 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const _CharT* __rhs)
-    { return __lhs.compare(__rhs) <= 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator<=(const _CharT* __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return __rhs.compare(__lhs) >= 0; }
-# 5247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept
-    { return __lhs.compare(__rhs) >= 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
-        const _CharT* __rhs)
-    { return __lhs.compare(__rhs) >= 0; }
-
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline bool
-    operator>=(const _CharT* __lhs,
-      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    { return __rhs.compare(__lhs) <= 0; }
-# 5285 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline void
-    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
-  basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    noexcept(noexcept(__lhs.swap(__rhs)))
-    { __lhs.swap(__rhs); }
-# 5305 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-        basic_string<_CharT, _Traits, _Alloc>& __str);
-
-  template<>
-    basic_istream<char>&
-    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
-# 5323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-        const basic_string<_CharT, _Traits, _Alloc>& __str)
-    {
-
-
-      return __ostream_insert(__os, __str.data(), __str.size());
-    }
-# 5346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>& __is,
-     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
-# 5363 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>& __is,
-     basic_string<_CharT, _Traits, _Alloc>& __str)
-    { return std::getline(__is, __str, __is.widen('\n')); }
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>&& __is,
-     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
-    { return std::getline(__is, __str, __delim); }
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    inline basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>&& __is,
-     basic_string<_CharT, _Traits, _Alloc>& __str)
-    { return std::getline(__is, __str); }
-
-
-  template<>
-    basic_istream<char>&
-    getline(basic_istream<char>& __in, basic_string<char>& __str,
-     char __delim);
-
-
-  template<>
-    basic_istream<wchar_t>&
-    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
-     wchar_t __delim);
-
-
-
-}
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 3
-
-
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 3
-
-
-
-
-# 1 "/usr/include/wchar.h" 1 3 4
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwchar" 2 3
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
-# 96 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
-namespace std
-{
-  using ::FILE;
-  using ::fpos_t;
-
-  using ::clearerr;
-  using ::fclose;
-  using ::feof;
-  using ::ferror;
-  using ::fflush;
-  using ::fgetc;
-  using ::fgetpos;
-  using ::fgets;
-  using ::fopen;
-  using ::fprintf;
-  using ::fputc;
-  using ::fputs;
-  using ::fread;
-  using ::freopen;
-  using ::fscanf;
-  using ::fseek;
-  using ::fsetpos;
-  using ::ftell;
-  using ::fwrite;
-  using ::getc;
-  using ::getchar;
-
-
-
-
-  using ::perror;
-  using ::printf;
-  using ::putc;
-  using ::putchar;
-  using ::puts;
-  using ::remove;
-  using ::rename;
-  using ::rewind;
-  using ::scanf;
-  using ::setbuf;
-  using ::setvbuf;
-  using ::sprintf;
-  using ::sscanf;
-  using ::tmpfile;
-
-  using ::tmpnam;
-
-  using ::ungetc;
-  using ::vfprintf;
-  using ::vprintf;
-  using ::vsprintf;
-}
-# 157 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
-namespace __gnu_cxx
-{
-# 175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdio" 3
-  using ::snprintf;
-  using ::vfscanf;
-  using ::vscanf;
-  using ::vsnprintf;
-  using ::vsscanf;
-
-}
-
-namespace std
-{
-  using ::__gnu_cxx::snprintf;
-  using ::__gnu_cxx::vfscanf;
-  using ::__gnu_cxx::vscanf;
-  using ::__gnu_cxx::vsnprintf;
-  using ::__gnu_cxx::vsscanf;
-}
-# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3
-
-
-# 1 "/usr/include/errno.h" 1 3 4
-# 31 "/usr/include/errno.h" 3 4
-extern "C" {
-
-
-
-
-# 1 "/usr/include/bits/errno.h" 1 3 4
-# 24 "/usr/include/bits/errno.h" 3 4
-# 1 "/usr/include/linux/errno.h" 1 3 4
-# 1 "/usr/include/asm/errno.h" 1 3 4
-# 1 "/usr/include/asm-generic/errno.h" 1 3 4
-
-
-
-# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
-# 5 "/usr/include/asm-generic/errno.h" 2 3 4
-# 2 "/usr/include/asm/errno.h" 2 3 4
-# 2 "/usr/include/linux/errno.h" 2 3 4
-# 25 "/usr/include/bits/errno.h" 2 3 4
-# 50 "/usr/include/bits/errno.h" 3 4
-extern int *__errno_location (void) throw () __attribute__ ((__const__));
-# 36 "/usr/include/errno.h" 2 3 4
-# 54 "/usr/include/errno.h" 3 4
-extern char *program_invocation_name, *program_invocation_short_name;
-
-
-
-}
-# 68 "/usr/include/errno.h" 3 4
-typedef int error_t;
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ext/string_conversions.h" 2 3
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
-    typename... _Base>
-    _Ret
-    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
-    const char* __name, const _CharT* __str, std::size_t* __idx,
-    _Base... __base)
-    {
-      _Ret __ret;
-
-      _CharT* __endptr;
-
-      struct _Save_errno {
- _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
- ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
- int _M_errno;
-      } const __save_errno;
-
-      const _TRet __tmp = __convf(__str, &__endptr, __base...);
-
-      if (__endptr == __str)
- std::__throw_invalid_argument(__name);
-      else if ((*__errno_location ()) == 34
-        || (std::__are_same<_Ret, int>::__value
-     && (__tmp < __numeric_traits<int>::__min
-         || __tmp > __numeric_traits<int>::__max)))
- std::__throw_out_of_range(__name);
-      else
- __ret = __tmp;
-
-      if (__idx)
- *__idx = __endptr - __str;
-
-      return __ret;
-    }
-
-
-  template<typename _String, typename _CharT = typename _String::value_type>
-    _String
-    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
-     __builtin_va_list), std::size_t __n,
-   const _CharT* __fmt, ...)
-    {
-
-
-      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-         * __n));
-
-      __builtin_va_list __args;
-      __builtin_va_start(__args, __fmt);
-
-      const int __len = __convf(__s, __n, __fmt, __args);
-
-      __builtin_va_end(__args);
-
-      return _String(__s, __s + __len);
-    }
-
-
-}
-# 5403 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-namespace __cxx11 {
-
-
-
-  inline int
-  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
-     __idx, __base); }
-
-  inline long
-  stol(const string& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
-        __idx, __base); }
-
-  inline unsigned long
-  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
-        __idx, __base); }
-
-  inline long long
-  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
-        __idx, __base); }
-
-  inline unsigned long long
-  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
-        __idx, __base); }
-
-
-  inline float
-  stof(const string& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
-
-  inline double
-  stod(const string& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
-
-  inline long double
-  stold(const string& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
-
-
-
-
-
-
-  inline string
-  to_string(int __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
-        "%d", __val); }
-
-  inline string
-  to_string(unsigned __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
-        4 * sizeof(unsigned),
-        "%u", __val); }
-
-  inline string
-  to_string(long __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
-        "%ld", __val); }
-
-  inline string
-  to_string(unsigned long __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
-        4 * sizeof(unsigned long),
-        "%lu", __val); }
-
-  inline string
-  to_string(long long __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
-        4 * sizeof(long long),
-        "%lld", __val); }
-
-  inline string
-  to_string(unsigned long long __val)
-  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
-        4 * sizeof(unsigned long long),
-        "%llu", __val); }
-
-  inline string
-  to_string(float __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
-        "%f", __val);
-  }
-
-  inline string
-  to_string(double __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
-        "%f", __val);
-  }
-
-  inline string
-  to_string(long double __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
-        "%Lf", __val);
-  }
-
-
-
-  inline int
-  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
-     __idx, __base); }
-
-  inline long
-  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
-        __idx, __base); }
-
-  inline unsigned long
-  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
-        __idx, __base); }
-
-  inline long long
-  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
-        __idx, __base); }
-
-  inline unsigned long long
-  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
-  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
-        __idx, __base); }
-
-
-  inline float
-  stof(const wstring& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
-
-  inline double
-  stod(const wstring& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
-
-  inline long double
-  stold(const wstring& __str, size_t* __idx = 0)
-  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
-
-
-
-  inline wstring
-  to_wstring(int __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
-         L"%d", __val); }
-
-  inline wstring
-  to_wstring(unsigned __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
-         4 * sizeof(unsigned),
-         L"%u", __val); }
-
-  inline wstring
-  to_wstring(long __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
-         L"%ld", __val); }
-
-  inline wstring
-  to_wstring(unsigned long __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
-         4 * sizeof(unsigned long),
-         L"%lu", __val); }
-
-  inline wstring
-  to_wstring(long long __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
-         4 * sizeof(long long),
-         L"%lld", __val); }
-
-  inline wstring
-  to_wstring(unsigned long long __val)
-  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
-         4 * sizeof(unsigned long long),
-         L"%llu", __val); }
-
-  inline wstring
-  to_wstring(float __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
-         L"%f", __val);
-  }
-
-  inline wstring
-  to_wstring(double __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
-         L"%f", __val);
-  }
-
-  inline wstring
-  to_wstring(long double __val)
-  {
-    const int __n =
-      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
-    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
-         L"%Lf", __val);
-  }
-
-
-
-}
-
-}
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/hash_bytes.h" 3
-
-
-
-namespace std
-{
-
-
-
-
-
-
-
-  size_t
-  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
-
-
-
-
-
-  size_t
-  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
-
-
-}
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
-  template<typename _Result, typename _Arg>
-    struct __hash_base
-    {
-      typedef _Result result_type;
-      typedef _Arg argument_type;
-    };
-
-
-  template<typename _Tp>
-    struct hash;
-
-
-  template<typename _Tp, bool = is_enum<_Tp>::value>
-    struct __hash_enum
-    {
-    private:
-
-      __hash_enum(__hash_enum&&);
-      ~__hash_enum();
-    };
-
-
-  template<typename _Tp>
-    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
-    {
-      size_t
-      operator()(_Tp __val) const noexcept
-      {
-       using __type = typename underlying_type<_Tp>::type;
-       return hash<__type>{}(static_cast<__type>(__val));
-      }
-    };
-
-
-
-  template<typename _Tp>
-    struct hash : __hash_enum<_Tp>
-    { };
-
-
-  template<typename _Tp>
-    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
-    {
-      size_t
-      operator()(_Tp* __p) const noexcept
-      { return reinterpret_cast<size_t>(__p); }
-    };
-# 108 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
-  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
-
-
-  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
-# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/functional_hash.h" 3
-  struct _Hash_impl
-  {
-    static size_t
-    hash(const void* __ptr, size_t __clength,
-  size_t __seed = static_cast<size_t>(0xc70f6907UL))
-    { return _Hash_bytes(__ptr, __clength, __seed); }
-
-    template<typename _Tp>
-      static size_t
-      hash(const _Tp& __val)
-      { return hash(&__val, sizeof(__val)); }
-
-    template<typename _Tp>
-      static size_t
-      __hash_combine(const _Tp& __val, size_t __hash)
-      { return hash(&__val, sizeof(__val), __hash); }
-  };
-
-  struct _Fnv_hash_impl
-  {
-    static size_t
-    hash(const void* __ptr, size_t __clength,
-  size_t __seed = static_cast<size_t>(2166136261UL))
-    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
-
-    template<typename _Tp>
-      static size_t
-      hash(const _Tp& __val)
-      { return hash(&__val, sizeof(__val)); }
-
-    template<typename _Tp>
-      static size_t
-      __hash_combine(const _Tp& __val, size_t __hash)
-      { return hash(&__val, sizeof(__val), __hash); }
-  };
-
-
-  template<>
-    struct hash<float> : public __hash_base<size_t, float>
-    {
-      size_t
-      operator()(float __val) const noexcept
-      {
-
- return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
-      }
-    };
-
-
-  template<>
-    struct hash<double> : public __hash_base<size_t, double>
-    {
-      size_t
-      operator()(double __val) const noexcept
-      {
-
- return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
-      }
-    };
-
-
-  template<>
-    struct hash<long double>
-    : public __hash_base<size_t, long double>
-    {
-      __attribute__ ((__pure__)) size_t
-      operator()(long double __val) const noexcept;
-    };
-
-
-
-
-
-
-
-  template<typename _Hash>
-    struct __is_fast_hash : public std::true_type
-    { };
-
-  template<>
-    struct __is_fast_hash<hash<long double>> : public std::false_type
-    { };
-
-
-}
-# 5629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-  template<>
-    struct hash<string>
-    : public __hash_base<size_t, string>
-    {
-      size_t
-      operator()(const string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<string>> : std::false_type
-    { };
-
-
-
-  template<>
-    struct hash<wstring>
-    : public __hash_base<size_t, wstring>
-    {
-      size_t
-      operator()(const wstring& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(wchar_t)); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<wstring>> : std::false_type
-    { };
-
-
-
-
-
-  template<>
-    struct hash<u16string>
-    : public __hash_base<size_t, u16string>
-    {
-      size_t
-      operator()(const u16string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(char16_t)); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<u16string>> : std::false_type
-    { };
-
-
-  template<>
-    struct hash<u32string>
-    : public __hash_base<size_t, u32string>
-    {
-      size_t
-      operator()(const u32string& __s) const noexcept
-      { return std::_Hash_impl::hash(__s.data(),
-                                     __s.length() * sizeof(char32_t)); }
-    };
-
-  template<>
-    struct __is_fast_hash<hash<u32string>> : std::false_type
-    { };
-# 5707 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.h" 3
-  inline namespace literals
-  {
-  inline namespace string_literals
-  {
-
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    inline basic_string<char>
-    operator""s(const char* __str, size_t __len)
-    { return basic_string<char>{__str, __len}; }
-
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    inline basic_string<wchar_t>
-    operator""s(const wchar_t* __str, size_t __len)
-    { return basic_string<wchar_t>{__str, __len}; }
-
-
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    inline basic_string<char16_t>
-    operator""s(const char16_t* __str, size_t __len)
-    { return basic_string<char16_t>{__str, __len}; }
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    inline basic_string<char32_t>
-    operator""s(const char32_t* __str, size_t __len)
-    { return basic_string<char32_t>{__str, __len}; }
-
-
-
-  }
-  }
-
-
-
-}
-# 53 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 1 3
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::npos;
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    swap(basic_string& __s) noexcept
-    {
-      if (this == &__s)
- return;
-
-      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
-
-      if (_M_is_local())
- if (__s._M_is_local())
-   {
-     if (length() && __s.length())
-       {
-  _CharT __tmp_data[_S_local_capacity + 1];
-  traits_type::copy(__tmp_data, __s._M_local_buf,
-      _S_local_capacity + 1);
-  traits_type::copy(__s._M_local_buf, _M_local_buf,
-      _S_local_capacity + 1);
-  traits_type::copy(_M_local_buf, __tmp_data,
-      _S_local_capacity + 1);
-       }
-     else if (__s.length())
-       {
-  traits_type::copy(_M_local_buf, __s._M_local_buf,
-      _S_local_capacity + 1);
-  _M_length(__s.length());
-  __s._M_set_length(0);
-  return;
-       }
-     else if (length())
-       {
-  traits_type::copy(__s._M_local_buf, _M_local_buf,
-      _S_local_capacity + 1);
-  __s._M_length(length());
-  _M_set_length(0);
-  return;
-       }
-   }
- else
-   {
-     const size_type __tmp_capacity = __s._M_allocated_capacity;
-     traits_type::copy(__s._M_local_buf, _M_local_buf,
-         _S_local_capacity + 1);
-     _M_data(__s._M_data());
-     __s._M_data(__s._M_local_buf);
-     _M_capacity(__tmp_capacity);
-   }
-      else
- {
-   const size_type __tmp_capacity = _M_allocated_capacity;
-   if (__s._M_is_local())
-     {
-       traits_type::copy(_M_local_buf, __s._M_local_buf,
-    _S_local_capacity + 1);
-       __s._M_data(_M_data());
-       _M_data(_M_local_buf);
-     }
-   else
-     {
-       pointer __tmp_ptr = _M_data();
-       _M_data(__s._M_data());
-       __s._M_data(__tmp_ptr);
-       _M_capacity(__s._M_allocated_capacity);
-     }
-   __s._M_capacity(__tmp_capacity);
- }
-
-      const size_type __tmp_length = length();
-      _M_length(__s.length());
-      __s._M_length(__tmp_length);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::pointer
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_create(size_type& __capacity, size_type __old_capacity)
-    {
-
-
-      if (__capacity > max_size())
- std::__throw_length_error(("basic_string::_M_create"));
-
-
-
-
-      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
- {
-   __capacity = 2 * __old_capacity;
-
-   if (__capacity > max_size())
-     __capacity = max_size();
- }
-
-
-
-      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
-    }
-
-
-
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InIterator>
-      void
-      basic_string<_CharT, _Traits, _Alloc>::
-      _M_construct(_InIterator __beg, _InIterator __end,
-     std::input_iterator_tag)
-      {
- size_type __len = 0;
- size_type __capacity = size_type(_S_local_capacity);
-
- while (__beg != __end && __len < __capacity)
-   {
-     _M_data()[__len++] = *__beg;
-     ++__beg;
-   }
-
- try
-   {
-     while (__beg != __end)
-       {
-  if (__len == __capacity)
-    {
-
-      __capacity = __len + 1;
-      pointer __another = _M_create(__capacity, __len);
-      this->_S_copy(__another, _M_data(), __len);
-      _M_dispose();
-      _M_data(__another);
-      _M_capacity(__capacity);
-    }
-  _M_data()[__len++] = *__beg;
-  ++__beg;
-       }
-   }
- catch(...)
-   {
-     _M_dispose();
-     throw;
-   }
-
- _M_set_length(__len);
-      }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InIterator>
-      void
-      basic_string<_CharT, _Traits, _Alloc>::
-      _M_construct(_InIterator __beg, _InIterator __end,
-     std::forward_iterator_tag)
-      {
-
- if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
-   std::__throw_logic_error(("basic_string::" "_M_construct null not valid"));
-
-
- size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
-
- if (__dnew > size_type(_S_local_capacity))
-   {
-     _M_data(_M_create(__dnew, size_type(0)));
-     _M_capacity(__dnew);
-   }
-
-
- try
-   { this->_S_copy_chars(_M_data(), __beg, __end); }
- catch(...)
-   {
-     _M_dispose();
-     throw;
-   }
-
- _M_set_length(__dnew);
-      }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_construct(size_type __n, _CharT __c)
-    {
-      if (__n > size_type(_S_local_capacity))
- {
-   _M_data(_M_create(__n, size_type(0)));
-   _M_capacity(__n);
- }
-
-      if (__n)
- this->_S_assign(_M_data(), __n, __c);
-
-      _M_set_length(__n);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_assign(const basic_string& __str)
-    {
-      if (this != &__str)
- {
-   const size_type __rsize = __str.length();
-   const size_type __capacity = capacity();
-
-   if (__rsize > __capacity)
-     {
-       size_type __new_capacity = __rsize;
-       pointer __tmp = _M_create(__new_capacity, __capacity);
-       _M_dispose();
-       _M_data(__tmp);
-       _M_capacity(__new_capacity);
-     }
-
-   if (__rsize)
-     this->_S_copy(_M_data(), __str._M_data(), __rsize);
-
-   _M_set_length(__rsize);
- }
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    reserve(size_type __res)
-    {
-
-      if (__res < length())
- __res = length();
-
-      const size_type __capacity = capacity();
-      if (__res != __capacity)
- {
-   if (__res > __capacity
-       || __res > size_type(_S_local_capacity))
-     {
-       pointer __tmp = _M_create(__res, __capacity);
-       this->_S_copy(__tmp, _M_data(), length() + 1);
-       _M_dispose();
-       _M_data(__tmp);
-       _M_capacity(__res);
-     }
-   else if (!_M_is_local())
-     {
-       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
-       _M_destroy(__capacity);
-       _M_data(_M_local_data());
-     }
- }
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
-       size_type __len2)
-    {
-      const size_type __how_much = length() - __pos - __len1;
-
-      size_type __new_capacity = length() + __len2 - __len1;
-      pointer __r = _M_create(__new_capacity, capacity());
-
-      if (__pos)
- this->_S_copy(__r, _M_data(), __pos);
-      if (__s && __len2)
- this->_S_copy(__r + __pos, __s, __len2);
-      if (__how_much)
- this->_S_copy(__r + __pos + __len2,
-        _M_data() + __pos + __len1, __how_much);
-
-      _M_dispose();
-      _M_data(__r);
-      _M_capacity(__new_capacity);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_erase(size_type __pos, size_type __n)
-    {
-      const size_type __how_much = length() - __pos - __n;
-
-      if (__how_much && __n)
- this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
-
-      _M_set_length(length() - __n);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    void
-    basic_string<_CharT, _Traits, _Alloc>::
-    resize(size_type __n, _CharT __c)
-    {
-      const size_type __size = this->size();
-      if (__size < __n)
- this->append(__n - __size, __c);
-      else if (__n < __size)
- this->_M_erase(__n, __size - __n);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>&
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_append(const _CharT* __s, size_type __n)
-    {
-      const size_type __len = __n + this->size();
-
-      if (__len <= this->capacity())
- {
-   if (__n)
-     this->_S_copy(this->_M_data() + this->size(), __s, __n);
- }
-      else
- this->_M_mutate(this->size(), size_type(0), __s, __n);
-
-      this->_M_set_length(__len);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    template<typename _InputIterator>
-      basic_string<_CharT, _Traits, _Alloc>&
-      basic_string<_CharT, _Traits, _Alloc>::
-      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
-     _InputIterator __k1, _InputIterator __k2,
-     std::__false_type)
-      {
- const basic_string __s(__k1, __k2);
- const size_type __n1 = __i2 - __i1;
- return _M_replace(__i1 - begin(), __n1, __s._M_data(),
-     __s.size());
-      }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>&
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
-     _CharT __c)
-    {
-      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
-
-      const size_type __old_size = this->size();
-      const size_type __new_size = __old_size + __n2 - __n1;
-
-      if (__new_size <= this->capacity())
- {
-   pointer __p = this->_M_data() + __pos1;
-
-   const size_type __how_much = __old_size - __pos1 - __n1;
-   if (__how_much && __n1 != __n2)
-     this->_S_move(__p + __n2, __p + __n1, __how_much);
- }
-      else
- this->_M_mutate(__pos1, __n1, 0, __n2);
-
-      if (__n2)
- this->_S_assign(this->_M_data() + __pos1, __n2, __c);
-
-      this->_M_set_length(__new_size);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>&
-    basic_string<_CharT, _Traits, _Alloc>::
-    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
-        const size_type __len2)
-    {
-      _M_check_length(__len1, __len2, "basic_string::_M_replace");
-
-      const size_type __old_size = this->size();
-      const size_type __new_size = __old_size + __len2 - __len1;
-
-      if (__new_size <= this->capacity())
- {
-   pointer __p = this->_M_data() + __pos;
-
-   const size_type __how_much = __old_size - __pos - __len1;
-   if (_M_disjunct(__s))
-     {
-       if (__how_much && __len1 != __len2)
-  this->_S_move(__p + __len2, __p + __len1, __how_much);
-       if (__len2)
-  this->_S_copy(__p, __s, __len2);
-     }
-   else
-     {
-
-       if (__len2 && __len2 <= __len1)
-  this->_S_move(__p, __s, __len2);
-       if (__how_much && __len1 != __len2)
-  this->_S_move(__p + __len2, __p + __len1, __how_much);
-       if (__len2 > __len1)
-  {
-    if (__s + __len2 <= __p + __len1)
-      this->_S_move(__p, __s, __len2);
-    else if (__s >= __p + __len1)
-      this->_S_copy(__p, __s + __len2 - __len1, __len2);
-    else
-      {
-        const size_type __nleft = (__p + __len1) - __s;
-        this->_S_move(__p, __s, __nleft);
-        this->_S_copy(__p + __nleft, __p + __len2,
-        __len2 - __nleft);
-      }
-  }
-     }
- }
-      else
- this->_M_mutate(__pos, __len1, __s, __len2);
-
-      this->_M_set_length(__new_size);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    copy(_CharT* __s, size_type __n, size_type __pos) const
-    {
-      _M_check(__pos, "basic_string::copy");
-      __n = _M_limit(__pos, __n);
-                                             ;
-      if (__n)
- _S_copy(__s, _M_data() + __pos, __n);
-
-      return __n;
-    }
-# 1145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_string.tcc" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>
-    operator+(const _CharT* __lhs,
-       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    {
-                                      ;
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef typename __string_type::size_type __size_type;
-      const __size_type __len = _Traits::length(__lhs);
-      __string_type __str;
-      __str.reserve(__len + __rhs.size());
-      __str.append(__lhs, __len);
-      __str.append(__rhs);
-      return __str;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>
-    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
-    {
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef typename __string_type::size_type __size_type;
-      __string_type __str;
-      const __size_type __len = __rhs.size();
-      __str.reserve(__len + 1);
-      __str.append(__size_type(1), __lhs);
-      __str.append(__rhs);
-      return __str;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      const size_type __size = this->size();
-      const _CharT* __data = _M_data();
-
-      if (__n == 0)
- return __pos <= __size ? __pos : npos;
-
-      if (__n <= __size)
- {
-   for (; __pos <= __size - __n; ++__pos)
-     if (traits_type::eq(__data[__pos], __s[0])
-  && traits_type::compare(__data + __pos + 1,
-     __s + 1, __n - 1) == 0)
-       return __pos;
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find(_CharT __c, size_type __pos) const noexcept
-    {
-      size_type __ret = npos;
-      const size_type __size = this->size();
-      if (__pos < __size)
- {
-   const _CharT* __data = _M_data();
-   const size_type __n = __size - __pos;
-   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
-   if (__p)
-     __ret = __p - __data;
- }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    rfind(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      const size_type __size = this->size();
-      if (__n <= __size)
- {
-   __pos = std::min(size_type(__size - __n), __pos);
-   const _CharT* __data = _M_data();
-   do
-     {
-       if (traits_type::compare(__data + __pos, __s, __n) == 0)
-  return __pos;
-     }
-   while (__pos-- > 0);
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    rfind(_CharT __c, size_type __pos) const noexcept
-    {
-      size_type __size = this->size();
-      if (__size)
- {
-   if (--__size > __pos)
-     __size = __pos;
-   for (++__size; __size-- > 0; )
-     if (traits_type::eq(_M_data()[__size], __c))
-       return __size;
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      for (; __n && __pos < this->size(); ++__pos)
- {
-   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
-   if (__p)
-     return __pos;
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      size_type __size = this->size();
-      if (__size && __n)
- {
-   if (--__size > __pos)
-     __size = __pos;
-   do
-     {
-       if (traits_type::find(__s, __n, _M_data()[__size]))
-  return __size;
-     }
-   while (__size-- != 0);
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      for (; __pos < this->size(); ++__pos)
- if (!traits_type::find(__s, __n, _M_data()[__pos]))
-   return __pos;
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_first_not_of(_CharT __c, size_type __pos) const noexcept
-    {
-      for (; __pos < this->size(); ++__pos)
- if (!traits_type::eq(_M_data()[__pos], __c))
-   return __pos;
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
-    {
-                                             ;
-      size_type __size = this->size();
-      if (__size)
- {
-   if (--__size > __pos)
-     __size = __pos;
-   do
-     {
-       if (!traits_type::find(__s, __n, _M_data()[__size]))
-  return __size;
-     }
-   while (__size--);
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    typename basic_string<_CharT, _Traits, _Alloc>::size_type
-    basic_string<_CharT, _Traits, _Alloc>::
-    find_last_not_of(_CharT __c, size_type __pos) const noexcept
-    {
-      size_type __size = this->size();
-      if (__size)
- {
-   if (--__size > __pos)
-     __size = __pos;
-   do
-     {
-       if (!traits_type::eq(_M_data()[__size], __c))
-  return __size;
-     }
-   while (__size--);
- }
-      return npos;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    int
-    basic_string<_CharT, _Traits, _Alloc>::
-    compare(size_type __pos, size_type __n, const basic_string& __str) const
-    {
-      _M_check(__pos, "basic_string::compare");
-      __n = _M_limit(__pos, __n);
-      const size_type __osize = __str.size();
-      const size_type __len = std::min(__n, __osize);
-      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
-      if (!__r)
- __r = _S_compare(__n, __osize);
-      return __r;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    int
-    basic_string<_CharT, _Traits, _Alloc>::
-    compare(size_type __pos1, size_type __n1, const basic_string& __str,
-     size_type __pos2, size_type __n2) const
-    {
-      _M_check(__pos1, "basic_string::compare");
-      __str._M_check(__pos2, "basic_string::compare");
-      __n1 = _M_limit(__pos1, __n1);
-      __n2 = __str._M_limit(__pos2, __n2);
-      const size_type __len = std::min(__n1, __n2);
-      int __r = traits_type::compare(_M_data() + __pos1,
-         __str.data() + __pos2, __len);
-      if (!__r)
- __r = _S_compare(__n1, __n2);
-      return __r;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    int
-    basic_string<_CharT, _Traits, _Alloc>::
-    compare(const _CharT* __s) const
-    {
-                                    ;
-      const size_type __size = this->size();
-      const size_type __osize = traits_type::length(__s);
-      const size_type __len = std::min(__size, __osize);
-      int __r = traits_type::compare(_M_data(), __s, __len);
-      if (!__r)
- __r = _S_compare(__size, __osize);
-      return __r;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    int
-    basic_string <_CharT, _Traits, _Alloc>::
-    compare(size_type __pos, size_type __n1, const _CharT* __s) const
-    {
-                                    ;
-      _M_check(__pos, "basic_string::compare");
-      __n1 = _M_limit(__pos, __n1);
-      const size_type __osize = traits_type::length(__s);
-      const size_type __len = std::min(__n1, __osize);
-      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
-      if (!__r)
- __r = _S_compare(__n1, __osize);
-      return __r;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    int
-    basic_string <_CharT, _Traits, _Alloc>::
-    compare(size_type __pos, size_type __n1, const _CharT* __s,
-     size_type __n2) const
-    {
-                                              ;
-      _M_check(__pos, "basic_string::compare");
-      __n1 = _M_limit(__pos, __n1);
-      const size_type __len = std::min(__n1, __n2);
-      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
-      if (!__r)
- __r = _S_compare(__n1, __n2);
-      return __r;
-    }
-
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in,
-        basic_string<_CharT, _Traits, _Alloc>& __str)
-    {
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef typename __istream_type::ios_base __ios_base;
-      typedef typename __istream_type::int_type __int_type;
-      typedef typename __string_type::size_type __size_type;
-      typedef ctype<_CharT> __ctype_type;
-      typedef typename __ctype_type::ctype_base __ctype_base;
-
-      __size_type __extracted = 0;
-      typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, false);
-      if (__cerb)
- {
-   try
-     {
-
-       __str.erase();
-       _CharT __buf[128];
-       __size_type __len = 0;
-       const streamsize __w = __in.width();
-       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
-                                : __str.max_size();
-       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
-       const __int_type __eof = _Traits::eof();
-       __int_type __c = __in.rdbuf()->sgetc();
-
-       while (__extracted < __n
-       && !_Traits::eq_int_type(__c, __eof)
-       && !__ct.is(__ctype_base::space,
-     _Traits::to_char_type(__c)))
-  {
-    if (__len == sizeof(__buf) / sizeof(_CharT))
-      {
-        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
-        __len = 0;
-      }
-    __buf[__len++] = _Traits::to_char_type(__c);
-    ++__extracted;
-    __c = __in.rdbuf()->snextc();
-  }
-       __str.append(__buf, __len);
-
-       if (_Traits::eq_int_type(__c, __eof))
-  __err |= __ios_base::eofbit;
-       __in.width(0);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __in._M_setstate(__ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     {
-
-
-
-       __in._M_setstate(__ios_base::badbit);
-     }
- }
-
-      if (!__extracted)
- __err |= __ios_base::failbit;
-      if (__err)
- __in.setstate(__err);
-      return __in;
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>& __in,
-     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
-    {
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef typename __istream_type::ios_base __ios_base;
-      typedef typename __istream_type::int_type __int_type;
-      typedef typename __string_type::size_type __size_type;
-
-      __size_type __extracted = 0;
-      const __size_type __n = __str.max_size();
-      typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, true);
-      if (__cerb)
- {
-   try
-     {
-       __str.erase();
-       const __int_type __idelim = _Traits::to_int_type(__delim);
-       const __int_type __eof = _Traits::eof();
-       __int_type __c = __in.rdbuf()->sgetc();
-
-       while (__extracted < __n
-       && !_Traits::eq_int_type(__c, __eof)
-       && !_Traits::eq_int_type(__c, __idelim))
-  {
-    __str += _Traits::to_char_type(__c);
-    ++__extracted;
-    __c = __in.rdbuf()->snextc();
-  }
-
-       if (_Traits::eq_int_type(__c, __eof))
-  __err |= __ios_base::eofbit;
-       else if (_Traits::eq_int_type(__c, __idelim))
-  {
-    ++__extracted;
-    __in.rdbuf()->sbumpc();
-  }
-       else
-  __err |= __ios_base::failbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __in._M_setstate(__ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     {
-
-
-
-       __in._M_setstate(__ios_base::badbit);
-     }
- }
-      if (!__extracted)
- __err |= __ios_base::failbit;
-      if (__err)
- __in.setstate(__err);
-      return __in;
-    }
-
-
-
-
-  extern template class basic_string<char>;
-  extern template
-    basic_istream<char>&
-    operator>>(basic_istream<char>&, string&);
-  extern template
-    basic_ostream<char>&
-    operator<<(basic_ostream<char>&, const string&);
-  extern template
-    basic_istream<char>&
-    getline(basic_istream<char>&, string&, char);
-  extern template
-    basic_istream<char>&
-    getline(basic_istream<char>&, string&);
-
-
-  extern template class basic_string<wchar_t>;
-  extern template
-    basic_istream<wchar_t>&
-    operator>>(basic_istream<wchar_t>&, wstring&);
-  extern template
-    basic_ostream<wchar_t>&
-    operator<<(basic_ostream<wchar_t>&, const wstring&);
-  extern template
-    basic_istream<wchar_t>&
-    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
-  extern template
-    basic_istream<wchar_t>&
-    getline(basic_istream<wchar_t>&, wstring&);
-
-
-
-
-}
-# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/string" 2 3
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-  class locale
-  {
-  public:
-
-
-    typedef int category;
-
-
-    class facet;
-    class id;
-    class _Impl;
-
-    friend class facet;
-    friend class _Impl;
-
-    template<typename _Facet>
-      friend bool
-      has_facet(const locale&) throw();
-
-    template<typename _Facet>
-      friend const _Facet&
-      use_facet(const locale&);
-
-    template<typename _Cache>
-      friend struct __use_cache;
-# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    static const category none = 0;
-    static const category ctype = 1L << 0;
-    static const category numeric = 1L << 1;
-    static const category collate = 1L << 2;
-    static const category time = 1L << 3;
-    static const category monetary = 1L << 4;
-    static const category messages = 1L << 5;
-    static const category all = (ctype | numeric | collate |
-        time | monetary | messages);
-# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    locale() throw();
-# 126 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    locale(const locale& __other) throw();
-# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    explicit
-    locale(const char* __s);
-# 151 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    locale(const locale& __base, const char* __s, category __cat);
-# 162 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    explicit
-    locale(const std::string& __s) : locale(__s.c_str()) { }
-# 177 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    locale(const locale& __base, const std::string& __s, category __cat)
-    : locale(__base, __s.c_str(), __cat) { }
-# 192 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    locale(const locale& __base, const locale& __add, category __cat);
-# 205 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    template<typename _Facet>
-      locale(const locale& __other, _Facet* __f);
-
-
-    ~locale() throw();
-# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    const locale&
-    operator=(const locale& __other) throw();
-# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    template<typename _Facet>
-      locale
-      combine(const locale& __other) const;
-
-
-
-
-
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    string
-    name() const;
-# 254 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    bool
-    operator==(const locale& __other) const throw();
-
-
-
-
-
-
-
-    bool
-    operator!=(const locale& __other) const throw()
-    { return !(this->operator==(__other)); }
-# 282 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    template<typename _Char, typename _Traits, typename _Alloc>
-      bool
-      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
-   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
-# 298 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    static locale
-    global(const locale& __loc);
-
-
-
-
-    static const locale&
-    classic();
-
-  private:
-
-    _Impl* _M_impl;
-
-
-    static _Impl* _S_classic;
-
-
-    static _Impl* _S_global;
-
-
-
-
-
-    static const char* const* const _S_categories;
-# 333 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    enum { _S_categories_size = 6 + 6 };
-
-
-    static __gthread_once_t _S_once;
-
-
-    explicit
-    locale(_Impl*) throw();
-
-    static void
-    _S_initialize();
-
-    static void
-    _S_initialize_once() throw();
-
-    static category
-    _S_normalize_category(category);
-
-    void
-    _M_coalesce(const locale& __base, const locale& __add, category __cat);
-
-
-    static const id* const _S_twinned_facets[];
-
-  };
-# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-  class locale::facet
-  {
-  private:
-    friend class locale;
-    friend class locale::_Impl;
-
-    mutable _Atomic_word _M_refcount;
-
-
-    static __c_locale _S_c_locale;
-
-
-    static const char _S_c_name[2];
-
-
-    static __gthread_once_t _S_once;
-
-
-    static void
-    _S_initialize_once();
-
-  protected:
-# 402 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    explicit
-    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
-    { }
-
-
-    virtual
-    ~facet();
-
-    static void
-    _S_create_c_locale(__c_locale& __cloc, const char* __s,
-         __c_locale __old = 0);
-
-    static __c_locale
-    _S_clone_c_locale(__c_locale& __cloc) throw();
-
-    static void
-    _S_destroy_c_locale(__c_locale& __cloc);
-
-    static __c_locale
-    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
-
-
-
-    static __c_locale
-    _S_get_c_locale();
-
-    __attribute__ ((__const__)) static const char*
-    _S_get_c_name() throw();
-# 438 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-    facet(const facet&) = delete;
-
-    facet&
-    operator=(const facet&) = delete;
-
-
-  private:
-    void
-    _M_add_reference() const throw()
-    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
-
-    void
-    _M_remove_reference() const throw()
-    {
-
-                                                           ;
-      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
- {
-                                                              ;
-   try
-     { delete this; }
-   catch(...)
-     { }
- }
-    }
-
-    class __shim;
-
-    const facet* _M_sso_shim(const id*) const;
-    const facet* _M_cow_shim(const id*) const;
-  };
-# 482 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-  class locale::id
-  {
-  private:
-    friend class locale;
-    friend class locale::_Impl;
-
-    template<typename _Facet>
-      friend const _Facet&
-      use_facet(const locale&);
-
-    template<typename _Facet>
-      friend bool
-      has_facet(const locale&) throw();
-
-
-
-
-    mutable size_t _M_index;
-
-
-    static _Atomic_word _S_refcount;
-
-    void
-    operator=(const id&);
-
-    id(const id&);
-
-  public:
-
-
-
-    id() { }
-
-    size_t
-    _M_id() const throw();
-  };
-
-
-
-  class locale::_Impl
-  {
-  public:
-
-    friend class locale;
-    friend class locale::facet;
-
-    template<typename _Facet>
-      friend bool
-      has_facet(const locale&) throw();
-
-    template<typename _Facet>
-      friend const _Facet&
-      use_facet(const locale&);
-
-    template<typename _Cache>
-      friend struct __use_cache;
-
-  private:
-
-    _Atomic_word _M_refcount;
-    const facet** _M_facets;
-    size_t _M_facets_size;
-    const facet** _M_caches;
-    char** _M_names;
-    static const locale::id* const _S_id_ctype[];
-    static const locale::id* const _S_id_numeric[];
-    static const locale::id* const _S_id_collate[];
-    static const locale::id* const _S_id_time[];
-    static const locale::id* const _S_id_monetary[];
-    static const locale::id* const _S_id_messages[];
-    static const locale::id* const* const _S_facet_categories[];
-
-    void
-    _M_add_reference() throw()
-    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
-
-    void
-    _M_remove_reference() throw()
-    {
-
-                                                           ;
-      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
- {
-                                                              ;
-   try
-     { delete this; }
-   catch(...)
-     { }
- }
-    }
-
-    _Impl(const _Impl&, size_t);
-    _Impl(const char*, size_t);
-    _Impl(size_t) throw();
-
-   ~_Impl() throw();
-
-    _Impl(const _Impl&);
-
-    void
-    operator=(const _Impl&);
-
-    bool
-    _M_check_same_name()
-    {
-      bool __ret = true;
-      if (_M_names[1])
-
- for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
-   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
-      return __ret;
-    }
-
-    void
-    _M_replace_categories(const _Impl*, category);
-
-    void
-    _M_replace_category(const _Impl*, const locale::id* const*);
-
-    void
-    _M_replace_facet(const _Impl*, const locale::id*);
-
-    void
-    _M_install_facet(const locale::id*, const facet*);
-
-    template<typename _Facet>
-      void
-      _M_init_facet(_Facet* __facet)
-      { _M_install_facet(&_Facet::id, __facet); }
-
-    template<typename _Facet>
-      void
-      _M_init_facet_unchecked(_Facet* __facet)
-      {
- __facet->_M_add_reference();
- _M_facets[_Facet::id._M_id()] = __facet;
-      }
-
-    void
-    _M_install_cache(const facet*, size_t);
-
-    void _M_init_extra(facet**);
-    void _M_init_extra(void*, void*, const char*, const char*);
-  };
-# 640 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-  template<typename _CharT>
-    class __cxx11:: collate : public locale::facet
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef basic_string<_CharT> string_type;
-
-
-    protected:
-
-
-      __c_locale _M_c_locale_collate;
-
-    public:
-
-      static locale::id id;
-# 667 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      explicit
-      collate(size_t __refs = 0)
-      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
-      { }
-# 681 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      explicit
-      collate(__c_locale __cloc, size_t __refs = 0)
-      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
-      { }
-# 698 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      int
-      compare(const _CharT* __lo1, const _CharT* __hi1,
-       const _CharT* __lo2, const _CharT* __hi2) const
-      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
-# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      string_type
-      transform(const _CharT* __lo, const _CharT* __hi) const
-      { return this->do_transform(__lo, __hi); }
-# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      long
-      hash(const _CharT* __lo, const _CharT* __hi) const
-      { return this->do_hash(__lo, __hi); }
-
-
-      int
-      _M_compare(const _CharT*, const _CharT*) const throw();
-
-      size_t
-      _M_transform(_CharT*, const _CharT*, size_t) const throw();
-
-  protected:
-
-      virtual
-      ~collate()
-      { _S_destroy_c_locale(_M_c_locale_collate); }
-# 760 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      virtual int
-      do_compare(const _CharT* __lo1, const _CharT* __hi1,
-   const _CharT* __lo2, const _CharT* __hi2) const;
-# 774 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      virtual string_type
-      do_transform(const _CharT* __lo, const _CharT* __hi) const;
-# 787 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 3
-      virtual long
-      do_hash(const _CharT* __lo, const _CharT* __hi) const;
-    };
-
-  template<typename _CharT>
-    locale::id collate<_CharT>::id;
-
-
-  template<>
-    int
-    collate<char>::_M_compare(const char*, const char*) const throw();
-
-  template<>
-    size_t
-    collate<char>::_M_transform(char*, const char*, size_t) const throw();
-
-
-  template<>
-    int
-    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
-
-  template<>
-    size_t
-    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
-
-
-
-  template<typename _CharT>
-    class __cxx11:: collate_byname : public collate<_CharT>
-    {
-    public:
-
-
-      typedef _CharT char_type;
-      typedef basic_string<_CharT> string_type;
-
-
-      explicit
-      collate_byname(const char* __s, size_t __refs = 0)
-      : collate<_CharT>(__refs)
-      {
- if (__builtin_strcmp(__s, "C") != 0
-     && __builtin_strcmp(__s, "POSIX") != 0)
-   {
-     this->_S_destroy_c_locale(this->_M_c_locale_collate);
-     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
-   }
-      }
-
-
-      explicit
-      collate_byname(const string& __s, size_t __refs = 0)
-      : collate_byname(__s.c_str(), __refs) { }
-
-
-    protected:
-      virtual
-      ~collate_byname() { }
-    };
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Facet>
-    locale::
-    locale(const locale& __other, _Facet* __f)
-    {
-      _M_impl = new _Impl(*__other._M_impl, 1);
-
-      try
- { _M_impl->_M_install_facet(&_Facet::id, __f); }
-      catch(...)
- {
-   _M_impl->_M_remove_reference();
-   throw;
- }
-      delete [] _M_impl->_M_names[0];
-      _M_impl->_M_names[0] = 0;
-    }
-
-  template<typename _Facet>
-    locale
-    locale::
-    combine(const locale& __other) const
-    {
-      _Impl* __tmp = new _Impl(*_M_impl, 1);
-      try
- {
-   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
- }
-      catch(...)
- {
-   __tmp->_M_remove_reference();
-   throw;
- }
-      return locale(__tmp);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    bool
-    locale::
-    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
-        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
-    {
-      typedef std::collate<_CharT> __collate_type;
-      const __collate_type& __collate = use_facet<__collate_type>(*this);
-      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
-    __s2.data(), __s2.data() + __s2.length()) < 0);
-    }
-# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
-  template<typename _Facet>
-    bool
-    has_facet(const locale& __loc) throw()
-    {
-      const size_t __i = _Facet::id._M_id();
-      const locale::facet** __facets = __loc._M_impl->_M_facets;
-      return (__i < __loc._M_impl->_M_facets_size
-
-       && dynamic_cast<const _Facet*>(__facets[__i]));
-
-
-
-    }
-# 130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.tcc" 3
-  template<typename _Facet>
-    const _Facet&
-    use_facet(const locale& __loc)
-    {
-      const size_t __i = _Facet::id._M_id();
-      const locale::facet** __facets = __loc._M_impl->_M_facets;
-      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
-        __throw_bad_cast();
-
-      return dynamic_cast<const _Facet&>(*__facets[__i]);
-
-
-
-    }
-
-
-
-  template<typename _CharT>
-    int
-    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
-    { return 0; }
-
-
-  template<typename _CharT>
-    size_t
-    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
-    { return 0; }
-
-  template<typename _CharT>
-    int
-    collate<_CharT>::
-    do_compare(const _CharT* __lo1, const _CharT* __hi1,
-        const _CharT* __lo2, const _CharT* __hi2) const
-    {
-
-
-      const string_type __one(__lo1, __hi1);
-      const string_type __two(__lo2, __hi2);
-
-      const _CharT* __p = __one.c_str();
-      const _CharT* __pend = __one.data() + __one.length();
-      const _CharT* __q = __two.c_str();
-      const _CharT* __qend = __two.data() + __two.length();
-
-
-
-
-      for (;;)
- {
-   const int __res = _M_compare(__p, __q);
-   if (__res)
-     return __res;
-
-   __p += char_traits<_CharT>::length(__p);
-   __q += char_traits<_CharT>::length(__q);
-   if (__p == __pend && __q == __qend)
-     return 0;
-   else if (__p == __pend)
-     return -1;
-   else if (__q == __qend)
-     return 1;
-
-   __p++;
-   __q++;
- }
-    }
-
-  template<typename _CharT>
-    typename collate<_CharT>::string_type
-    collate<_CharT>::
-    do_transform(const _CharT* __lo, const _CharT* __hi) const
-    {
-      string_type __ret;
-
-
-      const string_type __str(__lo, __hi);
-
-      const _CharT* __p = __str.c_str();
-      const _CharT* __pend = __str.data() + __str.length();
-
-      size_t __len = (__hi - __lo) * 2;
-
-      _CharT* __c = new _CharT[__len];
-
-      try
- {
-
-
-
-   for (;;)
-     {
-
-       size_t __res = _M_transform(__c, __p, __len);
-
-
-       if (__res >= __len)
-  {
-    __len = __res + 1;
-    delete [] __c, __c = 0;
-    __c = new _CharT[__len];
-    __res = _M_transform(__c, __p, __len);
-  }
-
-       __ret.append(__c, __res);
-       __p += char_traits<_CharT>::length(__p);
-       if (__p == __pend)
-  break;
-
-       __p++;
-       __ret.push_back(_CharT());
-     }
- }
-      catch(...)
- {
-   delete [] __c;
-   throw;
- }
-
-      delete [] __c;
-
-      return __ret;
-    }
-
-  template<typename _CharT>
-    long
-    collate<_CharT>::
-    do_hash(const _CharT* __lo, const _CharT* __hi) const
-    {
-      unsigned long __val = 0;
-      for (; __lo < __hi; ++__lo)
- __val =
-   *__lo + ((__val << 7)
-     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
-    __digits - 7)));
-      return static_cast<long>(__val);
-    }
-
-
-
-
-  extern template class collate<char>;
-  extern template class collate_byname<char>;
-
-  extern template
-    const collate<char>&
-    use_facet<collate<char> >(const locale&);
-
-  extern template
-    bool
-    has_facet<collate<char> >(const locale&);
-
-
-  extern template class collate<wchar_t>;
-  extern template class collate_byname<wchar_t>;
-
-  extern template
-    const collate<wchar_t>&
-    use_facet<collate<wchar_t> >(const locale&);
-
-  extern template
-    bool
-    has_facet<collate<wchar_t> >(const locale&);
-
-
-
-
-}
-# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_classes.h" 2 3
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 3
-
-
-# 1 "/usr/include/errno.h" 1 3 4
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cerrno" 2 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/error_constants.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  enum class errc
-    {
-      address_family_not_supported = 97,
-      address_in_use = 98,
-      address_not_available = 99,
-      already_connected = 106,
-      argument_list_too_long = 7,
-      argument_out_of_domain = 33,
-      bad_address = 14,
-      bad_file_descriptor = 9,
-
-
-      bad_message = 74,
-
-
-      broken_pipe = 32,
-      connection_aborted = 103,
-      connection_already_in_progress = 114,
-      connection_refused = 111,
-      connection_reset = 104,
-      cross_device_link = 18,
-      destination_address_required = 89,
-      device_or_resource_busy = 16,
-      directory_not_empty = 39,
-      executable_format_error = 8,
-      file_exists = 17,
-      file_too_large = 27,
-      filename_too_long = 36,
-      function_not_supported = 38,
-      host_unreachable = 113,
-
-
-      identifier_removed = 43,
-
-
-      illegal_byte_sequence = 84,
-      inappropriate_io_control_operation = 25,
-      interrupted = 4,
-      invalid_argument = 22,
-      invalid_seek = 29,
-      io_error = 5,
-      is_a_directory = 21,
-      message_size = 90,
-      network_down = 100,
-      network_reset = 102,
-      network_unreachable = 101,
-      no_buffer_space = 105,
-      no_child_process = 10,
-
-
-      no_link = 67,
-
-
-      no_lock_available = 37,
-
-
-      no_message_available = 61,
-
-
-      no_message = 42,
-      no_protocol_option = 92,
-      no_space_on_device = 28,
-
-
-      no_stream_resources = 63,
-
-
-      no_such_device_or_address = 6,
-      no_such_device = 19,
-      no_such_file_or_directory = 2,
-      no_such_process = 3,
-      not_a_directory = 20,
-      not_a_socket = 88,
-
-
-      not_a_stream = 60,
-
-
-      not_connected = 107,
-      not_enough_memory = 12,
-
-
-      not_supported = 95,
-
-
-
-      operation_canceled = 125,
-
-
-      operation_in_progress = 115,
-      operation_not_permitted = 1,
-      operation_not_supported = 95,
-      operation_would_block = 11,
-
-
-      owner_dead = 130,
-
-
-      permission_denied = 13,
-
-
-      protocol_error = 71,
-
-
-      protocol_not_supported = 93,
-      read_only_file_system = 30,
-      resource_deadlock_would_occur = 35,
-      resource_unavailable_try_again = 11,
-      result_out_of_range = 34,
-
-
-      state_not_recoverable = 131,
-
-
-
-      stream_timeout = 62,
-
-
-
-      text_file_busy = 26,
-
-
-      timed_out = 110,
-      too_many_files_open_in_system = 23,
-      too_many_files_open = 24,
-      too_many_links = 31,
-      too_many_symbolic_link_levels = 40,
-
-
-      value_too_large = 75,
-
-
-      wrong_protocol_type = 91
-    };
-
-
-}
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-  struct __cow_string
-  {
-    union {
-      const char* _M_p;
-      char _M_bytes[sizeof(const char*)];
-    };
-
-    __cow_string();
-    __cow_string(const std::string&);
-    __cow_string(const char*, size_t);
-    __cow_string(const __cow_string&) noexcept;
-    __cow_string& operator=(const __cow_string&) noexcept;
-    ~__cow_string();
-
-    __cow_string(__cow_string&&) noexcept;
-    __cow_string& operator=(__cow_string&&) noexcept;
-
-  };
-
-  typedef basic_string<char> __sso_string;
-# 113 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdexcept" 3
-  class logic_error : public exception
-  {
-    __cow_string _M_msg;
-
-  public:
-
-    explicit
-    logic_error(const string& __arg) ;
-
-
-    explicit
-    logic_error(const char*) ;
-
-
-
-    logic_error(const logic_error&) noexcept;
-    logic_error& operator=(const logic_error&) noexcept;
-
-
-    virtual ~logic_error() noexcept;
-
-
-
-    virtual const char*
-    what() const noexcept;
-
-
-
-
-
-  };
-
-
-
-  class domain_error : public logic_error
-  {
-  public:
-    explicit domain_error(const string& __arg) ;
-
-    explicit domain_error(const char*) ;
-
-    virtual ~domain_error() noexcept;
-  };
-
-
-  class invalid_argument : public logic_error
-  {
-  public:
-    explicit invalid_argument(const string& __arg) ;
-
-    explicit invalid_argument(const char*) ;
-
-    virtual ~invalid_argument() noexcept;
-  };
-
-
-
-  class length_error : public logic_error
-  {
-  public:
-    explicit length_error(const string& __arg) ;
-
-    explicit length_error(const char*) ;
-
-    virtual ~length_error() noexcept;
-  };
-
-
-
-  class out_of_range : public logic_error
-  {
-  public:
-    explicit out_of_range(const string& __arg) ;
-
-    explicit out_of_range(const char*) ;
-
-    virtual ~out_of_range() noexcept;
-  };
-
-
-
-
-
-
-  class runtime_error : public exception
-  {
-    __cow_string _M_msg;
-
-  public:
-
-    explicit
-    runtime_error(const string& __arg) ;
-
-
-    explicit
-    runtime_error(const char*) ;
-
-
-
-    runtime_error(const runtime_error&) noexcept;
-    runtime_error& operator=(const runtime_error&) noexcept;
-
-
-    virtual ~runtime_error() noexcept;
-
-
-
-    virtual const char*
-    what() const noexcept;
-
-
-
-
-
-  };
-
-
-  class range_error : public runtime_error
-  {
-  public:
-    explicit range_error(const string& __arg) ;
-
-    explicit range_error(const char*) ;
-
-    virtual ~range_error() noexcept;
-  };
-
-
-  class overflow_error : public runtime_error
-  {
-  public:
-    explicit overflow_error(const string& __arg) ;
-
-    explicit overflow_error(const char*) ;
-
-    virtual ~overflow_error() noexcept;
-  };
-
-
-  class underflow_error : public runtime_error
-  {
-  public:
-    explicit underflow_error(const string& __arg) ;
-
-    explicit underflow_error(const char*) ;
-
-    virtual ~underflow_error() noexcept;
-  };
-
-
-
-
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  class error_code;
-  class error_condition;
-  class system_error;
-
-
-  template<typename _Tp>
-    struct is_error_code_enum : public false_type { };
-
-
-  template<typename _Tp>
-    struct is_error_condition_enum : public false_type { };
-
-  template<>
-    struct is_error_condition_enum<errc>
-    : public true_type { };
-
-  inline namespace _V2 {
-
-
-  class error_category
-  {
-  public:
-    constexpr error_category() noexcept = default;
-
-    virtual ~error_category();
-
-    error_category(const error_category&) = delete;
-    error_category& operator=(const error_category&) = delete;
-
-    virtual const char*
-    name() const noexcept = 0;
-
-
-
-
-
-
-  private:
-    __attribute ((__abi_tag__ ("cxx11")))
-    virtual __cow_string
-    _M_message(int) const;
-
-  public:
-    __attribute ((__abi_tag__ ("cxx11")))
-    virtual string
-    message(int) const = 0;
-# 102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/system_error" 3
-  public:
-    virtual error_condition
-    default_error_condition(int __i) const noexcept;
-
-    virtual bool
-    equivalent(int __i, const error_condition& __cond) const noexcept;
-
-    virtual bool
-    equivalent(const error_code& __code, int __i) const noexcept;
-
-    bool
-    operator<(const error_category& __other) const noexcept
-    { return less<const error_category*>()(this, &__other); }
-
-    bool
-    operator==(const error_category& __other) const noexcept
-    { return this == &__other; }
-
-    bool
-    operator!=(const error_category& __other) const noexcept
-    { return this != &__other; }
-  };
-
-
-  __attribute__ ((__const__)) const error_category& system_category() noexcept;
-  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
-
-  }
-
-  error_code make_error_code(errc) noexcept;
-
-  template<typename _Tp>
-    struct hash;
-
-
-
-  struct error_code
-  {
-    error_code() noexcept
-    : _M_value(0), _M_cat(&system_category()) { }
-
-    error_code(int __v, const error_category& __cat) noexcept
-    : _M_value(__v), _M_cat(&__cat) { }
-
-    template<typename _ErrorCodeEnum, typename = typename
-      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
-      error_code(_ErrorCodeEnum __e) noexcept
-      { *this = make_error_code(__e); }
-
-    void
-    assign(int __v, const error_category& __cat) noexcept
-    {
-      _M_value = __v;
-      _M_cat = &__cat;
-    }
-
-    void
-    clear() noexcept
-    { assign(0, system_category()); }
-
-
-    template<typename _ErrorCodeEnum>
-      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
-    error_code&>::type
-      operator=(_ErrorCodeEnum __e) noexcept
-      { return *this = make_error_code(__e); }
-
-    int
-    value() const noexcept { return _M_value; }
-
-    const error_category&
-    category() const noexcept { return *_M_cat; }
-
-    error_condition
-    default_error_condition() const noexcept;
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    string
-    message() const
-    { return category().message(value()); }
-
-    explicit operator bool() const noexcept
-    { return _M_value != 0; }
-
-
-  private:
-    friend class hash<error_code>;
-
-    int _M_value;
-    const error_category* _M_cat;
-  };
-
-
-  inline error_code
-  make_error_code(errc __e) noexcept
-  { return error_code(static_cast<int>(__e), generic_category()); }
-
-  inline bool
-  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
-  {
-    return (__lhs.category() < __rhs.category()
-     || (__lhs.category() == __rhs.category()
-  && __lhs.value() < __rhs.value()));
-  }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
-    { return (__os << __e.category().name() << ':' << __e.value()); }
-
-  error_condition make_error_condition(errc) noexcept;
-
-
-
-  struct error_condition
-  {
-    error_condition() noexcept
-    : _M_value(0), _M_cat(&generic_category()) { }
-
-    error_condition(int __v, const error_category& __cat) noexcept
-    : _M_value(__v), _M_cat(&__cat) { }
-
-    template<typename _ErrorConditionEnum, typename = typename
-  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
-      error_condition(_ErrorConditionEnum __e) noexcept
-      { *this = make_error_condition(__e); }
-
-    void
-    assign(int __v, const error_category& __cat) noexcept
-    {
-      _M_value = __v;
-      _M_cat = &__cat;
-    }
-
-
-    template<typename _ErrorConditionEnum>
-      typename enable_if<is_error_condition_enum
-    <_ErrorConditionEnum>::value, error_condition&>::type
-      operator=(_ErrorConditionEnum __e) noexcept
-      { return *this = make_error_condition(__e); }
-
-    void
-    clear() noexcept
-    { assign(0, generic_category()); }
-
-
-    int
-    value() const noexcept { return _M_value; }
-
-    const error_category&
-    category() const noexcept { return *_M_cat; }
-
-    __attribute ((__abi_tag__ ("cxx11")))
-    string
-    message() const
-    { return category().message(value()); }
-
-    explicit operator bool() const noexcept
-    { return _M_value != 0; }
-
-
-  private:
-    int _M_value;
-    const error_category* _M_cat;
-  };
-
-
-  inline error_condition
-  make_error_condition(errc __e) noexcept
-  { return error_condition(static_cast<int>(__e), generic_category()); }
-
-  inline bool
-  operator<(const error_condition& __lhs,
-     const error_condition& __rhs) noexcept
-  {
-    return (__lhs.category() < __rhs.category()
-     || (__lhs.category() == __rhs.category()
-  && __lhs.value() < __rhs.value()));
-  }
-
-
-  inline bool
-  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
-  { return (__lhs.category() == __rhs.category()
-     && __lhs.value() == __rhs.value()); }
-
-  inline bool
-  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
-  {
-    return (__lhs.category().equivalent(__lhs.value(), __rhs)
-     || __rhs.category().equivalent(__lhs, __rhs.value()));
-  }
-
-  inline bool
-  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
-  {
-    return (__rhs.category().equivalent(__rhs.value(), __lhs)
-     || __lhs.category().equivalent(__rhs, __lhs.value()));
-  }
-
-  inline bool
-  operator==(const error_condition& __lhs,
-      const error_condition& __rhs) noexcept
-  {
-    return (__lhs.category() == __rhs.category()
-     && __lhs.value() == __rhs.value());
-  }
-
-  inline bool
-  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
-  { return !(__lhs == __rhs); }
-
-  inline bool
-  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
-  { return !(__lhs == __rhs); }
-
-  inline bool
-  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
-  { return !(__lhs == __rhs); }
-
-  inline bool
-  operator!=(const error_condition& __lhs,
-      const error_condition& __rhs) noexcept
-  { return !(__lhs == __rhs); }
-
-
-
-
-
-
-
-  class system_error : public std::runtime_error
-  {
-  private:
-    error_code _M_code;
-
-  public:
-    system_error(error_code __ec = error_code())
-    : runtime_error(__ec.message()), _M_code(__ec) { }
-
-    system_error(error_code __ec, const string& __what)
-    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
-
-    system_error(error_code __ec, const char* __what)
-    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
-
-    system_error(int __v, const error_category& __ecat, const char* __what)
-    : system_error(error_code(__v, __ecat), __what) { }
-
-    system_error(int __v, const error_category& __ecat)
-    : runtime_error(error_code(__v, __ecat).message()),
-      _M_code(__v, __ecat) { }
-
-    system_error(int __v, const error_category& __ecat, const string& __what)
-    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
-      _M_code(__v, __ecat) { }
-
-    virtual ~system_error() noexcept;
-
-    const error_code&
-    code() const noexcept { return _M_code; }
-  };
-
-
-}
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template<>
-    struct hash<error_code>
-    : public __hash_base<size_t, error_code>
-    {
-      size_t
-      operator()(const error_code& __e) const noexcept
-      {
- const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
- return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
-      }
-    };
-
-
-}
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 2 3
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-  enum _Ios_Fmtflags
-    {
-      _S_boolalpha = 1L << 0,
-      _S_dec = 1L << 1,
-      _S_fixed = 1L << 2,
-      _S_hex = 1L << 3,
-      _S_internal = 1L << 4,
-      _S_left = 1L << 5,
-      _S_oct = 1L << 6,
-      _S_right = 1L << 7,
-      _S_scientific = 1L << 8,
-      _S_showbase = 1L << 9,
-      _S_showpoint = 1L << 10,
-      _S_showpos = 1L << 11,
-      _S_skipws = 1L << 12,
-      _S_unitbuf = 1L << 13,
-      _S_uppercase = 1L << 14,
-      _S_adjustfield = _S_left | _S_right | _S_internal,
-      _S_basefield = _S_dec | _S_oct | _S_hex,
-      _S_floatfield = _S_scientific | _S_fixed,
-      _S_ios_fmtflags_end = 1L << 16,
-      _S_ios_fmtflags_max = 2147483647,
-      _S_ios_fmtflags_min = ~2147483647
-    };
-
-  inline constexpr _Ios_Fmtflags
-  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
-  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Fmtflags
-  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
-  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Fmtflags
-  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
-  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Fmtflags
-  operator~(_Ios_Fmtflags __a)
-  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
-
-  inline const _Ios_Fmtflags&
-  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
-  { return __a = __a | __b; }
-
-  inline const _Ios_Fmtflags&
-  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
-  { return __a = __a & __b; }
-
-  inline const _Ios_Fmtflags&
-  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
-  { return __a = __a ^ __b; }
-
-
-  enum _Ios_Openmode
-    {
-      _S_app = 1L << 0,
-      _S_ate = 1L << 1,
-      _S_bin = 1L << 2,
-      _S_in = 1L << 3,
-      _S_out = 1L << 4,
-      _S_trunc = 1L << 5,
-      _S_ios_openmode_end = 1L << 16,
-      _S_ios_openmode_max = 2147483647,
-      _S_ios_openmode_min = ~2147483647
-    };
-
-  inline constexpr _Ios_Openmode
-  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
-  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Openmode
-  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
-  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Openmode
-  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
-  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Openmode
-  operator~(_Ios_Openmode __a)
-  { return _Ios_Openmode(~static_cast<int>(__a)); }
-
-  inline const _Ios_Openmode&
-  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
-  { return __a = __a | __b; }
-
-  inline const _Ios_Openmode&
-  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
-  { return __a = __a & __b; }
-
-  inline const _Ios_Openmode&
-  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
-  { return __a = __a ^ __b; }
-
-
-  enum _Ios_Iostate
-    {
-      _S_goodbit = 0,
-      _S_badbit = 1L << 0,
-      _S_eofbit = 1L << 1,
-      _S_failbit = 1L << 2,
-      _S_ios_iostate_end = 1L << 16,
-      _S_ios_iostate_max = 2147483647,
-      _S_ios_iostate_min = ~2147483647
-    };
-
-  inline constexpr _Ios_Iostate
-  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
-  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Iostate
-  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
-  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Iostate
-  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
-  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
-
-  inline constexpr _Ios_Iostate
-  operator~(_Ios_Iostate __a)
-  { return _Ios_Iostate(~static_cast<int>(__a)); }
-
-  inline const _Ios_Iostate&
-  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
-  { return __a = __a | __b; }
-
-  inline const _Ios_Iostate&
-  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
-  { return __a = __a & __b; }
-
-  inline const _Ios_Iostate&
-  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
-  { return __a = __a ^ __b; }
-
-
-  enum _Ios_Seekdir
-    {
-      _S_beg = 0,
-      _S_cur = 1,
-      _S_end = 2,
-      _S_ios_seekdir_end = 1L << 16
-    };
-
-
-
-  enum class io_errc { stream = 1 };
-
-  template <> struct is_error_code_enum<io_errc> : public true_type { };
-
-  const error_category& iostream_category() noexcept;
-
-  inline error_code
-  make_error_code(io_errc e) noexcept
-  { return error_code(static_cast<int>(e), iostream_category()); }
-
-  inline error_condition
-  make_error_condition(io_errc e) noexcept
-  { return error_condition(static_cast<int>(e), iostream_category()); }
-# 228 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-  class ios_base
-  {
-# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-  public:
-# 255 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
-    {
-    public:
-      explicit
-      failure(const string& __str);
-
-
-      explicit
-      failure(const string&, const error_code&);
-
-      explicit
-      failure(const char*, const error_code& = io_errc::stream);
-
-
-      virtual
-      ~failure() throw();
-
-      virtual const char*
-      what() const throw();
-    };
-# 323 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    typedef _Ios_Fmtflags fmtflags;
-
-
-    static const fmtflags boolalpha = _S_boolalpha;
-
-
-    static const fmtflags dec = _S_dec;
-
-
-    static const fmtflags fixed = _S_fixed;
-
-
-    static const fmtflags hex = _S_hex;
-
-
-
-
-    static const fmtflags internal = _S_internal;
-
-
-
-    static const fmtflags left = _S_left;
-
-
-    static const fmtflags oct = _S_oct;
-
-
-
-    static const fmtflags right = _S_right;
-
-
-    static const fmtflags scientific = _S_scientific;
-
-
-
-    static const fmtflags showbase = _S_showbase;
-
-
-
-    static const fmtflags showpoint = _S_showpoint;
-
-
-    static const fmtflags showpos = _S_showpos;
-
-
-    static const fmtflags skipws = _S_skipws;
-
-
-    static const fmtflags unitbuf = _S_unitbuf;
-
-
-
-    static const fmtflags uppercase = _S_uppercase;
-
-
-    static const fmtflags adjustfield = _S_adjustfield;
-
-
-    static const fmtflags basefield = _S_basefield;
-
-
-    static const fmtflags floatfield = _S_floatfield;
-# 398 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    typedef _Ios_Iostate iostate;
-
-
-
-    static const iostate badbit = _S_badbit;
-
-
-    static const iostate eofbit = _S_eofbit;
-
-
-
-
-    static const iostate failbit = _S_failbit;
-
-
-    static const iostate goodbit = _S_goodbit;
-# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    typedef _Ios_Openmode openmode;
-
-
-    static const openmode app = _S_app;
-
-
-    static const openmode ate = _S_ate;
-
-
-
-
-    static const openmode binary = _S_bin;
-
-
-    static const openmode in = _S_in;
-
-
-    static const openmode out = _S_out;
-
-
-    static const openmode trunc = _S_trunc;
-# 461 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    typedef _Ios_Seekdir seekdir;
-
-
-    static const seekdir beg = _S_beg;
-
-
-    static const seekdir cur = _S_cur;
-
-
-    static const seekdir end = _S_end;
-
-
-    typedef int io_state;
-    typedef int open_mode;
-    typedef int seek_dir;
-
-    typedef std::streampos streampos;
-    typedef std::streamoff streamoff;
-# 487 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    enum event
-    {
-      erase_event,
-      imbue_event,
-      copyfmt_event
-    };
-# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
-# 516 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    void
-    register_callback(event_callback __fn, int __index);
-
-  protected:
-    streamsize _M_precision;
-    streamsize _M_width;
-    fmtflags _M_flags;
-    iostate _M_exception;
-    iostate _M_streambuf_state;
-
-
-
-    struct _Callback_list
-    {
-
-      _Callback_list* _M_next;
-      ios_base::event_callback _M_fn;
-      int _M_index;
-      _Atomic_word _M_refcount;
-
-      _Callback_list(ios_base::event_callback __fn, int __index,
-       _Callback_list* __cb)
-      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
-
-      void
-      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
-
-
-      int
-      _M_remove_reference()
-      {
-
-                                                             ;
-        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
-        if (__res == 0)
-          {
-                                                                ;
-          }
-        return __res;
-      }
-    };
-
-     _Callback_list* _M_callbacks;
-
-    void
-    _M_call_callbacks(event __ev) throw();
-
-    void
-    _M_dispose_callbacks(void) throw();
-
-
-    struct _Words
-    {
-      void* _M_pword;
-      long _M_iword;
-      _Words() : _M_pword(0), _M_iword(0) { }
-    };
-
-
-    _Words _M_word_zero;
-
-
-
-    enum { _S_local_word_size = 8 };
-    _Words _M_local_word[_S_local_word_size];
-
-
-    int _M_word_size;
-    _Words* _M_word;
-
-    _Words&
-    _M_grow_words(int __index, bool __iword);
-
-
-    locale _M_ios_locale;
-
-    void
-    _M_init() throw();
-
-  public:
-
-
-
-
-
-    class Init
-    {
-      friend class ios_base;
-    public:
-      Init();
-      ~Init();
-
-    private:
-      static _Atomic_word _S_refcount;
-      static bool _S_synced_with_stdio;
-    };
-
-
-
-
-
-
-    fmtflags
-    flags() const
-    { return _M_flags; }
-# 629 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    fmtflags
-    flags(fmtflags __fmtfl)
-    {
-      fmtflags __old = _M_flags;
-      _M_flags = __fmtfl;
-      return __old;
-    }
-# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    fmtflags
-    setf(fmtflags __fmtfl)
-    {
-      fmtflags __old = _M_flags;
-      _M_flags |= __fmtfl;
-      return __old;
-    }
-# 662 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    fmtflags
-    setf(fmtflags __fmtfl, fmtflags __mask)
-    {
-      fmtflags __old = _M_flags;
-      _M_flags &= ~__mask;
-      _M_flags |= (__fmtfl & __mask);
-      return __old;
-    }
-
-
-
-
-
-
-
-    void
-    unsetf(fmtflags __mask)
-    { _M_flags &= ~__mask; }
-# 688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    streamsize
-    precision() const
-    { return _M_precision; }
-
-
-
-
-
-
-    streamsize
-    precision(streamsize __prec)
-    {
-      streamsize __old = _M_precision;
-      _M_precision = __prec;
-      return __old;
-    }
-
-
-
-
-
-
-
-    streamsize
-    width() const
-    { return _M_width; }
-
-
-
-
-
-
-    streamsize
-    width(streamsize __wide)
-    {
-      streamsize __old = _M_width;
-      _M_width = __wide;
-      return __old;
-    }
-# 739 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    static bool
-    sync_with_stdio(bool __sync = true);
-# 751 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    locale
-    imbue(const locale& __loc) throw();
-# 762 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    locale
-    getloc() const
-    { return _M_ios_locale; }
-# 773 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    const locale&
-    _M_getloc() const
-    { return _M_ios_locale; }
-# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    static int
-    xalloc() throw();
-# 808 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    long&
-    iword(int __ix)
-    {
-      _Words& __word = (__ix < _M_word_size)
-   ? _M_word[__ix] : _M_grow_words(__ix, true);
-      return __word._M_iword;
-    }
-# 829 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    void*&
-    pword(int __ix)
-    {
-      _Words& __word = (__ix < _M_word_size)
-   ? _M_word[__ix] : _M_grow_words(__ix, false);
-      return __word._M_pword;
-    }
-# 846 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-    virtual ~ios_base();
-
-  protected:
-    ios_base() throw ();
-# 860 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ios_base.h" 3
-  public:
-    ios_base(const ios_base&) = delete;
-
-    ios_base&
-    operator=(const ios_base&) = delete;
-
-  protected:
-    void
-    _M_move(ios_base&) noexcept;
-
-    void
-    _M_swap(ios_base& __rhs) noexcept;
-
-  };
-
-
-
-  inline ios_base&
-  boolalpha(ios_base& __base)
-  {
-    __base.setf(ios_base::boolalpha);
-    return __base;
-  }
-
-
-  inline ios_base&
-  noboolalpha(ios_base& __base)
-  {
-    __base.unsetf(ios_base::boolalpha);
-    return __base;
-  }
-
-
-  inline ios_base&
-  showbase(ios_base& __base)
-  {
-    __base.setf(ios_base::showbase);
-    return __base;
-  }
-
-
-  inline ios_base&
-  noshowbase(ios_base& __base)
-  {
-    __base.unsetf(ios_base::showbase);
-    return __base;
-  }
-
-
-  inline ios_base&
-  showpoint(ios_base& __base)
-  {
-    __base.setf(ios_base::showpoint);
-    return __base;
-  }
-
-
-  inline ios_base&
-  noshowpoint(ios_base& __base)
-  {
-    __base.unsetf(ios_base::showpoint);
-    return __base;
-  }
-
-
-  inline ios_base&
-  showpos(ios_base& __base)
-  {
-    __base.setf(ios_base::showpos);
-    return __base;
-  }
-
-
-  inline ios_base&
-  noshowpos(ios_base& __base)
-  {
-    __base.unsetf(ios_base::showpos);
-    return __base;
-  }
-
-
-  inline ios_base&
-  skipws(ios_base& __base)
-  {
-    __base.setf(ios_base::skipws);
-    return __base;
-  }
-
-
-  inline ios_base&
-  noskipws(ios_base& __base)
-  {
-    __base.unsetf(ios_base::skipws);
-    return __base;
-  }
-
-
-  inline ios_base&
-  uppercase(ios_base& __base)
-  {
-    __base.setf(ios_base::uppercase);
-    return __base;
-  }
-
-
-  inline ios_base&
-  nouppercase(ios_base& __base)
-  {
-    __base.unsetf(ios_base::uppercase);
-    return __base;
-  }
-
-
-  inline ios_base&
-  unitbuf(ios_base& __base)
-  {
-     __base.setf(ios_base::unitbuf);
-     return __base;
-  }
-
-
-  inline ios_base&
-  nounitbuf(ios_base& __base)
-  {
-     __base.unsetf(ios_base::unitbuf);
-     return __base;
-  }
-
-
-
-  inline ios_base&
-  internal(ios_base& __base)
-  {
-     __base.setf(ios_base::internal, ios_base::adjustfield);
-     return __base;
-  }
-
-
-  inline ios_base&
-  left(ios_base& __base)
-  {
-    __base.setf(ios_base::left, ios_base::adjustfield);
-    return __base;
-  }
-
-
-  inline ios_base&
-  right(ios_base& __base)
-  {
-    __base.setf(ios_base::right, ios_base::adjustfield);
-    return __base;
-  }
-
-
-
-  inline ios_base&
-  dec(ios_base& __base)
-  {
-    __base.setf(ios_base::dec, ios_base::basefield);
-    return __base;
-  }
-
-
-  inline ios_base&
-  hex(ios_base& __base)
-  {
-    __base.setf(ios_base::hex, ios_base::basefield);
-    return __base;
-  }
-
-
-  inline ios_base&
-  oct(ios_base& __base)
-  {
-    __base.setf(ios_base::oct, ios_base::basefield);
-    return __base;
-  }
-
-
-
-  inline ios_base&
-  fixed(ios_base& __base)
-  {
-    __base.setf(ios_base::fixed, ios_base::floatfield);
-    return __base;
-  }
-
-
-  inline ios_base&
-  scientific(ios_base& __base)
-  {
-    __base.setf(ios_base::scientific, ios_base::floatfield);
-    return __base;
-  }
-
-
-
-
-
-
-  inline ios_base&
-  hexfloat(ios_base& __base)
-  {
-    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
-    return __base;
-  }
-
-
-  inline ios_base&
-  defaultfloat(ios_base& __base)
-  {
-    __base.unsetf(ios_base::floatfield);
-    return __base;
-  }
-
-
-
-}
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-
-
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
-     basic_streambuf<_CharT, _Traits>*, bool&);
-# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-  template<typename _CharT, typename _Traits>
-    class basic_streambuf
-    {
-    public:
-
-
-
-
-
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-      typedef typename traits_type::int_type int_type;
-      typedef typename traits_type::pos_type pos_type;
-      typedef typename traits_type::off_type off_type;
-
-
-
-
-      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
-
-
-      friend class basic_ios<char_type, traits_type>;
-      friend class basic_istream<char_type, traits_type>;
-      friend class basic_ostream<char_type, traits_type>;
-      friend class istreambuf_iterator<char_type, traits_type>;
-      friend class ostreambuf_iterator<char_type, traits_type>;
-
-      friend streamsize
-      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
-
-      template<bool _IsMove, typename _CharT2>
-        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-            _CharT2*>::__type
-        __copy_move_a2(istreambuf_iterator<_CharT2>,
-         istreambuf_iterator<_CharT2>, _CharT2*);
-
-      template<typename _CharT2>
-        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-      istreambuf_iterator<_CharT2> >::__type
-        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
-      const _CharT2&);
-
-      template<typename _CharT2, typename _Traits2>
-        friend basic_istream<_CharT2, _Traits2>&
-        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
-
-      template<typename _CharT2, typename _Traits2, typename _Alloc>
-        friend basic_istream<_CharT2, _Traits2>&
-        operator>>(basic_istream<_CharT2, _Traits2>&,
-     basic_string<_CharT2, _Traits2, _Alloc>&);
-
-      template<typename _CharT2, typename _Traits2, typename _Alloc>
-        friend basic_istream<_CharT2, _Traits2>&
-        getline(basic_istream<_CharT2, _Traits2>&,
-  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
-
-    protected:
-
-
-
-
-
-
-
-      char_type* _M_in_beg;
-      char_type* _M_in_cur;
-      char_type* _M_in_end;
-      char_type* _M_out_beg;
-      char_type* _M_out_cur;
-      char_type* _M_out_end;
-
-
-      locale _M_buf_locale;
-
-  public:
-
-      virtual
-      ~basic_streambuf()
-      { }
-# 208 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      locale
-      pubimbue(const locale& __loc)
-      {
- locale __tmp(this->getloc());
- this->imbue(__loc);
- _M_buf_locale = __loc;
- return __tmp;
-      }
-# 225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      locale
-      getloc() const
-      { return _M_buf_locale; }
-# 238 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      basic_streambuf*
-      pubsetbuf(char_type* __s, streamsize __n)
-      { return this->setbuf(__s, __n); }
-# 250 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      pos_type
-      pubseekoff(off_type __off, ios_base::seekdir __way,
-   ios_base::openmode __mode = ios_base::in | ios_base::out)
-      { return this->seekoff(__off, __way, __mode); }
-# 262 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      pos_type
-      pubseekpos(pos_type __sp,
-   ios_base::openmode __mode = ios_base::in | ios_base::out)
-      { return this->seekpos(__sp, __mode); }
-
-
-
-
-      int
-      pubsync() { return this->sync(); }
-# 283 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      streamsize
-      in_avail()
-      {
- const streamsize __ret = this->egptr() - this->gptr();
- return __ret ? __ret : this->showmanyc();
-      }
-# 297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      snextc()
-      {
- int_type __ret = traits_type::eof();
- if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
-             __ret), true))
-   __ret = this->sgetc();
- return __ret;
-      }
-# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      sbumpc()
-      {
- int_type __ret;
- if (__builtin_expect(this->gptr() < this->egptr(), true))
-   {
-     __ret = traits_type::to_int_type(*this->gptr());
-     this->gbump(1);
-   }
- else
-   __ret = this->uflow();
- return __ret;
-      }
-# 337 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      sgetc()
-      {
- int_type __ret;
- if (__builtin_expect(this->gptr() < this->egptr(), true))
-   __ret = traits_type::to_int_type(*this->gptr());
- else
-   __ret = this->underflow();
- return __ret;
-      }
-# 356 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      streamsize
-      sgetn(char_type* __s, streamsize __n)
-      { return this->xsgetn(__s, __n); }
-# 371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      sputbackc(char_type __c)
-      {
- int_type __ret;
- const bool __testpos = this->eback() < this->gptr();
- if (__builtin_expect(!__testpos ||
-        !traits_type::eq(__c, this->gptr()[-1]), false))
-   __ret = this->pbackfail(traits_type::to_int_type(__c));
- else
-   {
-     this->gbump(-1);
-     __ret = traits_type::to_int_type(*this->gptr());
-   }
- return __ret;
-      }
-# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      sungetc()
-      {
- int_type __ret;
- if (__builtin_expect(this->eback() < this->gptr(), true))
-   {
-     this->gbump(-1);
-     __ret = traits_type::to_int_type(*this->gptr());
-   }
- else
-   __ret = this->pbackfail();
- return __ret;
-      }
-# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      int_type
-      sputc(char_type __c)
-      {
- int_type __ret;
- if (__builtin_expect(this->pptr() < this->epptr(), true))
-   {
-     *this->pptr() = __c;
-     this->pbump(1);
-     __ret = traits_type::to_int_type(__c);
-   }
- else
-   __ret = this->overflow(traits_type::to_int_type(__c));
- return __ret;
-      }
-# 449 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      streamsize
-      sputn(const char_type* __s, streamsize __n)
-      { return this->xsputn(__s, __n); }
-
-    protected:
-# 463 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      basic_streambuf()
-      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
-      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
-      _M_buf_locale(locale())
-      { }
-# 481 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      char_type*
-      eback() const { return _M_in_beg; }
-
-      char_type*
-      gptr() const { return _M_in_cur; }
-
-      char_type*
-      egptr() const { return _M_in_end; }
-# 497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      void
-      gbump(int __n) { _M_in_cur += __n; }
-# 508 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      void
-      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
-      {
- _M_in_beg = __gbeg;
- _M_in_cur = __gnext;
- _M_in_end = __gend;
-      }
-# 528 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      char_type*
-      pbase() const { return _M_out_beg; }
-
-      char_type*
-      pptr() const { return _M_out_cur; }
-
-      char_type*
-      epptr() const { return _M_out_end; }
-# 544 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      void
-      pbump(int __n) { _M_out_cur += __n; }
-# 554 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      void
-      setp(char_type* __pbeg, char_type* __pend)
-      {
- _M_out_beg = _M_out_cur = __pbeg;
- _M_out_end = __pend;
-      }
-# 575 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual void
-      imbue(const locale& __loc)
-      { }
-# 590 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual basic_streambuf<char_type,_Traits>*
-      setbuf(char_type*, streamsize)
-      { return this; }
-# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual pos_type
-      seekoff(off_type, ios_base::seekdir,
-       ios_base::openmode = ios_base::in | ios_base::out)
-      { return pos_type(off_type(-1)); }
-# 613 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual pos_type
-      seekpos(pos_type,
-       ios_base::openmode = ios_base::in | ios_base::out)
-      { return pos_type(off_type(-1)); }
-# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual int
-      sync() { return 0; }
-# 648 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual streamsize
-      showmanyc() { return 0; }
-# 664 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual streamsize
-      xsgetn(char_type* __s, streamsize __n);
-# 686 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual int_type
-      underflow()
-      { return traits_type::eof(); }
-# 699 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual int_type
-      uflow()
-      {
- int_type __ret = traits_type::eof();
- const bool __testeof = traits_type::eq_int_type(this->underflow(),
-       __ret);
- if (!__testeof)
-   {
-     __ret = traits_type::to_int_type(*this->gptr());
-     this->gbump(1);
-   }
- return __ret;
-      }
-# 723 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual int_type
-      pbackfail(int_type __c = traits_type::eof())
-      { return traits_type::eof(); }
-# 741 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual streamsize
-      xsputn(const char_type* __s, streamsize __n);
-# 767 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      virtual int_type
-      overflow(int_type __c = traits_type::eof())
-      { return traits_type::eof(); }
-
-
-
-    public:
-# 782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 3
-      void
-      stossc()
-      {
- if (this->gptr() < this->egptr())
-   this->gbump(1);
- else
-   this->uflow();
-      }
-
-
-
-      void
-      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
-
-      void
-      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
-
-
-
-
-    protected:
-
-      basic_streambuf(const basic_streambuf&);
-
-      basic_streambuf&
-      operator=(const basic_streambuf&);
-
-
-      void
-      swap(basic_streambuf& __sb)
-      {
- std::swap(_M_in_beg, __sb._M_in_beg);
- std::swap(_M_in_cur, __sb._M_in_cur);
- std::swap(_M_in_end, __sb._M_in_end);
- std::swap(_M_out_beg, __sb._M_out_beg);
- std::swap(_M_out_cur, __sb._M_out_cur);
- std::swap(_M_out_end, __sb._M_out_end);
- std::swap(_M_buf_locale, __sb._M_buf_locale);
-      }
-
-    };
-
-
-  template<typename _CharT, typename _Traits>
-    std::basic_streambuf<_CharT, _Traits>::
-    basic_streambuf(const basic_streambuf&) = default;
-
-  template<typename _CharT, typename _Traits>
-    std::basic_streambuf<_CharT, _Traits>&
-    std::basic_streambuf<_CharT, _Traits>::
-    operator=(const basic_streambuf&) = default;
-
-
-
-  template<>
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
-     basic_streambuf<char>* __sbout, bool& __ineof);
-
-  template<>
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
-     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
-
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf.tcc" 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    streamsize
-    basic_streambuf<_CharT, _Traits>::
-    xsgetn(char_type* __s, streamsize __n)
-    {
-      streamsize __ret = 0;
-      while (__ret < __n)
- {
-   const streamsize __buf_len = this->egptr() - this->gptr();
-   if (__buf_len)
-     {
-       const streamsize __remaining = __n - __ret;
-       const streamsize __len = std::min(__buf_len, __remaining);
-       traits_type::copy(__s, this->gptr(), __len);
-       __ret += __len;
-       __s += __len;
-       this->__safe_gbump(__len);
-     }
-
-   if (__ret < __n)
-     {
-       const int_type __c = this->uflow();
-       if (!traits_type::eq_int_type(__c, traits_type::eof()))
-  {
-    traits_type::assign(*__s++, traits_type::to_char_type(__c));
-    ++__ret;
-  }
-       else
-  break;
-     }
- }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    streamsize
-    basic_streambuf<_CharT, _Traits>::
-    xsputn(const char_type* __s, streamsize __n)
-    {
-      streamsize __ret = 0;
-      while (__ret < __n)
- {
-   const streamsize __buf_len = this->epptr() - this->pptr();
-   if (__buf_len)
-     {
-       const streamsize __remaining = __n - __ret;
-       const streamsize __len = std::min(__buf_len, __remaining);
-       traits_type::copy(this->pptr(), __s, __len);
-       __ret += __len;
-       __s += __len;
-       this->__safe_pbump(__len);
-     }
-
-   if (__ret < __n)
-     {
-       int_type __c = this->overflow(traits_type::to_int_type(*__s));
-       if (!traits_type::eq_int_type(__c, traits_type::eof()))
-  {
-    ++__ret;
-    ++__s;
-  }
-       else
-  break;
-     }
- }
-      return __ret;
-    }
-
-
-
-
-  template<typename _CharT, typename _Traits>
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
-     basic_streambuf<_CharT, _Traits>* __sbout,
-     bool& __ineof)
-    {
-      streamsize __ret = 0;
-      __ineof = true;
-      typename _Traits::int_type __c = __sbin->sgetc();
-      while (!_Traits::eq_int_type(__c, _Traits::eof()))
- {
-   __c = __sbout->sputc(_Traits::to_char_type(__c));
-   if (_Traits::eq_int_type(__c, _Traits::eof()))
-     {
-       __ineof = false;
-       break;
-     }
-   ++__ret;
-   __c = __sbin->snextc();
- }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    inline streamsize
-    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
-        basic_streambuf<_CharT, _Traits>* __sbout)
-    {
-      bool __ineof;
-      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
-    }
-
-
-
-
-  extern template class basic_streambuf<char>;
-  extern template
-    streamsize
-    __copy_streambufs(basic_streambuf<char>*,
-        basic_streambuf<char>*);
-  extern template
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<char>*,
-     basic_streambuf<char>*, bool&);
-
-
-  extern template class basic_streambuf<wchar_t>;
-  extern template
-    streamsize
-    __copy_streambufs(basic_streambuf<wchar_t>*,
-        basic_streambuf<wchar_t>*);
-  extern template
-    streamsize
-    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
-     basic_streambuf<wchar_t>*, bool&);
-
-
-
-
-}
-# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/streambuf" 2 3
-# 44 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
-# 50 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
-# 1 "/usr/include/wctype.h" 1 3 4
-# 33 "/usr/include/wctype.h" 3 4
-# 1 "/usr/include/wchar.h" 1 3 4
-# 34 "/usr/include/wctype.h" 2 3 4
-# 52 "/usr/include/wctype.h" 3 4
-typedef unsigned long int wctype_t;
-# 71 "/usr/include/wctype.h" 3 4
-enum
-{
-  __ISwupper = 0,
-  __ISwlower = 1,
-  __ISwalpha = 2,
-  __ISwdigit = 3,
-  __ISwxdigit = 4,
-  __ISwspace = 5,
-  __ISwprint = 6,
-  __ISwgraph = 7,
-  __ISwblank = 8,
-  __ISwcntrl = 9,
-  __ISwpunct = 10,
-  __ISwalnum = 11,
-
-  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
-  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
-  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
-  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
-  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
-  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
-  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
-  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
-  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
-  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
-  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
-  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
-};
-
-
-
-extern "C" {
-# 111 "/usr/include/wctype.h" 3 4
-extern int iswalnum (wint_t __wc) throw ();
-
-
-
-
-
-extern int iswalpha (wint_t __wc) throw ();
-
-
-extern int iswcntrl (wint_t __wc) throw ();
-
-
-
-extern int iswdigit (wint_t __wc) throw ();
-
-
-
-extern int iswgraph (wint_t __wc) throw ();
-
-
-
-
-extern int iswlower (wint_t __wc) throw ();
-
-
-extern int iswprint (wint_t __wc) throw ();
-
-
-
-
-extern int iswpunct (wint_t __wc) throw ();
-
-
-
-
-extern int iswspace (wint_t __wc) throw ();
-
-
-
-
-extern int iswupper (wint_t __wc) throw ();
-
-
-
-
-extern int iswxdigit (wint_t __wc) throw ();
-
-
-
-
-
-extern int iswblank (wint_t __wc) throw ();
-# 171 "/usr/include/wctype.h" 3 4
-extern wctype_t wctype (const char *__property) throw ();
-
-
-
-extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
-# 186 "/usr/include/wctype.h" 3 4
-typedef const __int32_t *wctrans_t;
-
-
-
-
-
-
-
-extern wint_t towlower (wint_t __wc) throw ();
-
-
-extern wint_t towupper (wint_t __wc) throw ();
-
-
-}
-# 213 "/usr/include/wctype.h" 3 4
-extern "C" {
-
-
-
-
-extern wctrans_t wctrans (const char *__property) throw ();
-
-
-extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
-# 230 "/usr/include/wctype.h" 3 4
-extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-
-extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-
-extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-extern wctype_t wctype_l (const char *__property, __locale_t __locale)
-     throw ();
-
-
-
-extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
-     throw ();
-
-
-
-
-
-
-
-extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
-
-
-
-extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
-     throw ();
-
-
-extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
-      __locale_t __locale) throw ();
-
-
-
-}
-# 51 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 2 3
-# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cwctype" 3
-namespace std
-{
-  using ::wctrans_t;
-  using ::wctype_t;
-  using ::wint_t;
-
-  using ::iswalnum;
-  using ::iswalpha;
-
-  using ::iswblank;
-
-  using ::iswcntrl;
-  using ::iswctype;
-  using ::iswdigit;
-  using ::iswgraph;
-  using ::iswlower;
-  using ::iswprint;
-  using ::iswpunct;
-  using ::iswspace;
-  using ::iswupper;
-  using ::iswxdigit;
-  using ::towctrans;
-  using ::towlower;
-  using ::towupper;
-  using ::wctrans;
-  using ::wctype;
-}
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cctype" 3
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 1 3
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_base.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  struct ctype_base
-  {
-
-    typedef const int* __to_type;
-
-
-
-    typedef unsigned short mask;
-    static const mask upper = _ISupper;
-    static const mask lower = _ISlower;
-    static const mask alpha = _ISalpha;
-    static const mask digit = _ISdigit;
-    static const mask xdigit = _ISxdigit;
-    static const mask space = _ISspace;
-    static const mask print = _ISprint;
-    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
-    static const mask cntrl = _IScntrl;
-    static const mask punct = _ISpunct;
-    static const mask alnum = _ISalpha | _ISdigit;
-
-    static const mask blank = _ISblank;
-
-  };
-
-
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/streambuf_iterator.h" 3
-  template<typename _CharT, typename _Traits>
-    class istreambuf_iterator
-    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
-                      _CharT*,
-
-
-        _CharT>
-
-
-
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-      typedef typename _Traits::int_type int_type;
-      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
-      typedef basic_istream<_CharT, _Traits> istream_type;
-
-
-      template<typename _CharT2>
- friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-                      ostreambuf_iterator<_CharT2> >::__type
- copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
-      ostreambuf_iterator<_CharT2>);
-
-      template<bool _IsMove, typename _CharT2>
- friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-            _CharT2*>::__type
- __copy_move_a2(istreambuf_iterator<_CharT2>,
-         istreambuf_iterator<_CharT2>, _CharT2*);
-
-      template<typename _CharT2>
- friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-               istreambuf_iterator<_CharT2> >::__type
- find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
-      const _CharT2&);
-
-    private:
-
-
-
-
-
-
-
-      mutable streambuf_type* _M_sbuf;
-      mutable int_type _M_c;
-
-    public:
-
-      constexpr istreambuf_iterator() noexcept
-      : _M_sbuf(0), _M_c(traits_type::eof()) { }
-
-
-      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
-
-      ~istreambuf_iterator() = default;
-
-
-
-      istreambuf_iterator(istream_type& __s) noexcept
-      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
-
-
-      istreambuf_iterator(streambuf_type* __s) noexcept
-      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
-
-
-
-
-      char_type
-      operator*() const
-      {
-
-
-
-
-
-
-
- return traits_type::to_char_type(_M_get());
-      }
-
-
-      istreambuf_iterator&
-      operator++()
-      {
-
-
-                        ;
- if (_M_sbuf)
-   {
-     _M_sbuf->sbumpc();
-     _M_c = traits_type::eof();
-   }
- return *this;
-      }
-
-
-      istreambuf_iterator
-      operator++(int)
-      {
-
-
-                        ;
-
- istreambuf_iterator __old = *this;
- if (_M_sbuf)
-   {
-     __old._M_c = _M_sbuf->sbumpc();
-     _M_c = traits_type::eof();
-   }
- return __old;
-      }
-
-
-
-
-
-      bool
-      equal(const istreambuf_iterator& __b) const
-      { return _M_at_eof() == __b._M_at_eof(); }
-
-    private:
-      int_type
-      _M_get() const
-      {
- const int_type __eof = traits_type::eof();
- int_type __ret = __eof;
- if (_M_sbuf)
-   {
-     if (!traits_type::eq_int_type(_M_c, __eof))
-       __ret = _M_c;
-     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
-            __eof))
-       _M_c = __ret;
-     else
-       _M_sbuf = 0;
-   }
- return __ret;
-      }
-
-      bool
-      _M_at_eof() const
-      {
- const int_type __eof = traits_type::eof();
- return traits_type::eq_int_type(_M_get(), __eof);
-      }
-    };
-
-  template<typename _CharT, typename _Traits>
-    inline bool
-    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
-        const istreambuf_iterator<_CharT, _Traits>& __b)
-    { return __a.equal(__b); }
-
-  template<typename _CharT, typename _Traits>
-    inline bool
-    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
-        const istreambuf_iterator<_CharT, _Traits>& __b)
-    { return !__a.equal(__b); }
-
-
-  template<typename _CharT, typename _Traits>
-    class ostreambuf_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
-      typedef basic_ostream<_CharT, _Traits> ostream_type;
-
-
-      template<typename _CharT2>
- friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-                      ostreambuf_iterator<_CharT2> >::__type
- copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
-      ostreambuf_iterator<_CharT2>);
-
-    private:
-      streambuf_type* _M_sbuf;
-      bool _M_failed;
-
-    public:
-
-      ostreambuf_iterator(ostream_type& __s) noexcept
-      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
-
-
-      ostreambuf_iterator(streambuf_type* __s) noexcept
-      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
-
-
-      ostreambuf_iterator&
-      operator=(_CharT __c)
-      {
- if (!_M_failed &&
-     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
-   _M_failed = true;
- return *this;
-      }
-
-
-      ostreambuf_iterator&
-      operator*()
-      { return *this; }
-
-
-      ostreambuf_iterator&
-      operator++(int)
-      { return *this; }
-
-
-      ostreambuf_iterator&
-      operator++()
-      { return *this; }
-
-
-      bool
-      failed() const noexcept
-      { return _M_failed; }
-
-      ostreambuf_iterator&
-      _M_put(const _CharT* __ws, streamsize __len)
-      {
- if (__builtin_expect(!_M_failed, true)
-     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
-    false))
-   _M_failed = true;
- return *this;
-      }
-    };
-
-
-  template<typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-                           ostreambuf_iterator<_CharT> >::__type
-    copy(istreambuf_iterator<_CharT> __first,
-  istreambuf_iterator<_CharT> __last,
-  ostreambuf_iterator<_CharT> __result)
-    {
-      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
- {
-   bool __ineof;
-   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
-   if (!__ineof)
-     __result._M_failed = true;
- }
-      return __result;
-    }
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-            ostreambuf_iterator<_CharT> >::__type
-    __copy_move_a2(_CharT* __first, _CharT* __last,
-     ostreambuf_iterator<_CharT> __result)
-    {
-      const streamsize __num = __last - __first;
-      if (__num > 0)
- __result._M_put(__first, __num);
-      return __result;
-    }
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-        ostreambuf_iterator<_CharT> >::__type
-    __copy_move_a2(const _CharT* __first, const _CharT* __last,
-     ostreambuf_iterator<_CharT> __result)
-    {
-      const streamsize __num = __last - __first;
-      if (__num > 0)
- __result._M_put(__first, __num);
-      return __result;
-    }
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-            _CharT*>::__type
-    __copy_move_a2(istreambuf_iterator<_CharT> __first,
-     istreambuf_iterator<_CharT> __last, _CharT* __result)
-    {
-      typedef istreambuf_iterator<_CharT> __is_iterator_type;
-      typedef typename __is_iterator_type::traits_type traits_type;
-      typedef typename __is_iterator_type::streambuf_type streambuf_type;
-      typedef typename traits_type::int_type int_type;
-
-      if (__first._M_sbuf && !__last._M_sbuf)
- {
-   streambuf_type* __sb = __first._M_sbuf;
-   int_type __c = __sb->sgetc();
-   while (!traits_type::eq_int_type(__c, traits_type::eof()))
-     {
-       const streamsize __n = __sb->egptr() - __sb->gptr();
-       if (__n > 1)
-  {
-    traits_type::copy(__result, __sb->gptr(), __n);
-    __sb->__safe_gbump(__n);
-    __result += __n;
-    __c = __sb->underflow();
-  }
-       else
-  {
-    *__result++ = traits_type::to_char_type(__c);
-    __c = __sb->snextc();
-  }
-     }
- }
-      return __result;
-    }
-
-  template<typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-          istreambuf_iterator<_CharT> >::__type
-    find(istreambuf_iterator<_CharT> __first,
-  istreambuf_iterator<_CharT> __last, const _CharT& __val)
-    {
-      typedef istreambuf_iterator<_CharT> __is_iterator_type;
-      typedef typename __is_iterator_type::traits_type traits_type;
-      typedef typename __is_iterator_type::streambuf_type streambuf_type;
-      typedef typename traits_type::int_type int_type;
-
-      if (__first._M_sbuf && !__last._M_sbuf)
- {
-   const int_type __ival = traits_type::to_int_type(__val);
-   streambuf_type* __sb = __first._M_sbuf;
-   int_type __c = __sb->sgetc();
-   while (!traits_type::eq_int_type(__c, traits_type::eof())
-   && !traits_type::eq_int_type(__c, __ival))
-     {
-       streamsize __n = __sb->egptr() - __sb->gptr();
-       if (__n > 1)
-  {
-    const _CharT* __p = traits_type::find(__sb->gptr(),
-       __n, __val);
-    if (__p)
-      __n = __p - __sb->gptr();
-    __sb->__safe_gbump(__n);
-    __c = __sb->sgetc();
-  }
-       else
-  __c = __sb->snextc();
-     }
-
-   if (!traits_type::eq_int_type(__c, traits_type::eof()))
-     __first._M_c = __c;
-   else
-     __first._M_sbuf = 0;
- }
-      return __first;
-    }
-
-
-
-
-}
-# 49 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 71 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _Tp>
-    void
-    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
-     const __c_locale&) throw();
-
-
-  template<>
-    void
-    __convert_to_v(const char*, float&, ios_base::iostate&,
-     const __c_locale&) throw();
-
-  template<>
-    void
-    __convert_to_v(const char*, double&, ios_base::iostate&,
-     const __c_locale&) throw();
-
-  template<>
-    void
-    __convert_to_v(const char*, long double&, ios_base::iostate&,
-     const __c_locale&) throw();
-
-
-
-  template<typename _CharT, typename _Traits>
-    struct __pad
-    {
-      static void
-      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
-      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
-    };
-
-
-
-
-
-
-  template<typename _CharT>
-    _CharT*
-    __add_grouping(_CharT* __s, _CharT __sep,
-     const char* __gbeg, size_t __gsize,
-     const _CharT* __first, const _CharT* __last);
-
-
-
-
-  template<typename _CharT>
-    inline
-    ostreambuf_iterator<_CharT>
-    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
-    {
-      __s._M_put(__ws, __len);
-      return __s;
-    }
-
-
-  template<typename _CharT, typename _OutIter>
-    inline
-    _OutIter
-    __write(_OutIter __s, const _CharT* __ws, int __len)
-    {
-      for (int __j = 0; __j < __len; __j++, ++__s)
- *__s = __ws[__j];
-      return __s;
-    }
-# 149 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT>
-    class __ctype_abstract_base : public locale::facet, public ctype_base
-    {
-    public:
-
-
-      typedef _CharT char_type;
-# 168 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      bool
-      is(mask __m, char_type __c) const
-      { return this->do_is(__m, __c); }
-# 185 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
-      { return this->do_is(__lo, __hi, __vec); }
-# 201 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
-      { return this->do_scan_is(__m, __lo, __hi); }
-# 217 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
-      { return this->do_scan_not(__m, __lo, __hi); }
-# 231 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      toupper(char_type __c) const
-      { return this->do_toupper(__c); }
-# 246 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      toupper(char_type *__lo, const char_type* __hi) const
-      { return this->do_toupper(__lo, __hi); }
-# 260 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      tolower(char_type __c) const
-      { return this->do_tolower(__c); }
-# 275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      tolower(char_type* __lo, const char_type* __hi) const
-      { return this->do_tolower(__lo, __hi); }
-# 292 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      widen(char __c) const
-      { return this->do_widen(__c); }
-# 311 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char*
-      widen(const char* __lo, const char* __hi, char_type* __to) const
-      { return this->do_widen(__lo, __hi, __to); }
-# 330 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char
-      narrow(char_type __c, char __dfault) const
-      { return this->do_narrow(__c, __dfault); }
-# 352 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      narrow(const char_type* __lo, const char_type* __hi,
-       char __dfault, char* __to) const
-      { return this->do_narrow(__lo, __hi, __dfault, __to); }
-
-    protected:
-      explicit
-      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
-
-      virtual
-      ~__ctype_abstract_base() { }
-# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual bool
-      do_is(mask __m, char_type __c) const = 0;
-# 396 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_is(const char_type* __lo, const char_type* __hi,
-     mask* __vec) const = 0;
-# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_scan_is(mask __m, const char_type* __lo,
-   const char_type* __hi) const = 0;
-# 434 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_scan_not(mask __m, const char_type* __lo,
-    const char_type* __hi) const = 0;
-# 452 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_toupper(char_type __c) const = 0;
-# 469 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
-# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_tolower(char_type __c) const = 0;
-# 502 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
-# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_widen(char __c) const = 0;
-# 542 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char*
-      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
-# 563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char
-      do_narrow(char_type __c, char __dfault) const = 0;
-# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_narrow(const char_type* __lo, const char_type* __hi,
-  char __dfault, char* __to) const = 0;
-    };
-# 611 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT>
-    class ctype : public __ctype_abstract_base<_CharT>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef typename __ctype_abstract_base<_CharT>::mask mask;
-
-
-      static locale::id id;
-
-      explicit
-      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
-
-   protected:
-      virtual
-      ~ctype();
-
-      virtual bool
-      do_is(mask __m, char_type __c) const;
-
-      virtual const char_type*
-      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
-
-      virtual const char_type*
-      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
-
-      virtual const char_type*
-      do_scan_not(mask __m, const char_type* __lo,
-    const char_type* __hi) const;
-
-      virtual char_type
-      do_toupper(char_type __c) const;
-
-      virtual const char_type*
-      do_toupper(char_type* __lo, const char_type* __hi) const;
-
-      virtual char_type
-      do_tolower(char_type __c) const;
-
-      virtual const char_type*
-      do_tolower(char_type* __lo, const char_type* __hi) const;
-
-      virtual char_type
-      do_widen(char __c) const;
-
-      virtual const char*
-      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
-
-      virtual char
-      do_narrow(char_type, char __dfault) const;
-
-      virtual const char_type*
-      do_narrow(const char_type* __lo, const char_type* __hi,
-  char __dfault, char* __to) const;
-    };
-
-  template<typename _CharT>
-    locale::id ctype<_CharT>::id;
-# 680 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<>
-    class ctype<char> : public locale::facet, public ctype_base
-    {
-    public:
-
-
-      typedef char char_type;
-
-    protected:
-
-      __c_locale _M_c_locale_ctype;
-      bool _M_del;
-      __to_type _M_toupper;
-      __to_type _M_tolower;
-      const mask* _M_table;
-      mutable char _M_widen_ok;
-      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
-      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
-      mutable char _M_narrow_ok;
-
-
-    public:
-
-      static locale::id id;
-
-      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
-# 717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
-# 730 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
-     size_t __refs = 0);
-# 743 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      inline bool
-      is(mask __m, char __c) const;
-# 758 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      inline const char*
-      is(const char* __lo, const char* __hi, mask* __vec) const;
-# 772 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      inline const char*
-      scan_is(mask __m, const char* __lo, const char* __hi) const;
-# 786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      inline const char*
-      scan_not(mask __m, const char* __lo, const char* __hi) const;
-# 801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      toupper(char_type __c) const
-      { return this->do_toupper(__c); }
-# 818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      toupper(char_type *__lo, const char_type* __hi) const
-      { return this->do_toupper(__lo, __hi); }
-# 834 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      tolower(char_type __c) const
-      { return this->do_tolower(__c); }
-# 851 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      tolower(char_type* __lo, const char_type* __hi) const
-      { return this->do_tolower(__lo, __hi); }
-# 871 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      widen(char __c) const
-      {
- if (_M_widen_ok)
-   return _M_widen[static_cast<unsigned char>(__c)];
- this->_M_widen_init();
- return this->do_widen(__c);
-      }
-# 898 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char*
-      widen(const char* __lo, const char* __hi, char_type* __to) const
-      {
- if (_M_widen_ok == 1)
-   {
-     __builtin_memcpy(__to, __lo, __hi - __lo);
-     return __hi;
-   }
- if (!_M_widen_ok)
-   _M_widen_init();
- return this->do_widen(__lo, __hi, __to);
-      }
-# 929 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char
-      narrow(char_type __c, char __dfault) const
-      {
- if (_M_narrow[static_cast<unsigned char>(__c)])
-   return _M_narrow[static_cast<unsigned char>(__c)];
- const char __t = do_narrow(__c, __dfault);
- if (__t != __dfault)
-   _M_narrow[static_cast<unsigned char>(__c)] = __t;
- return __t;
-      }
-# 962 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      const char_type*
-      narrow(const char_type* __lo, const char_type* __hi,
-      char __dfault, char* __to) const
-      {
- if (__builtin_expect(_M_narrow_ok == 1, true))
-   {
-     __builtin_memcpy(__to, __lo, __hi - __lo);
-     return __hi;
-   }
- if (!_M_narrow_ok)
-   _M_narrow_init();
- return this->do_narrow(__lo, __hi, __dfault, __to);
-      }
-
-
-
-
-
-      const mask*
-      table() const throw()
-      { return _M_table; }
-
-
-      static const mask*
-      classic_table() throw();
-    protected:
-
-
-
-
-
-
-
-      virtual
-      ~ctype();
-# 1011 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_toupper(char_type __c) const;
-# 1028 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_toupper(char_type* __lo, const char_type* __hi) const;
-# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_tolower(char_type __c) const;
-# 1061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_tolower(char_type* __lo, const char_type* __hi) const;
-# 1081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_widen(char __c) const
-      { return __c; }
-# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char*
-      do_widen(const char* __lo, const char* __hi, char_type* __to) const
-      {
- __builtin_memcpy(__to, __lo, __hi - __lo);
- return __hi;
-      }
-# 1130 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char
-      do_narrow(char_type __c, char __dfault) const
-      { return __c; }
-# 1156 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_narrow(const char_type* __lo, const char_type* __hi,
-  char __dfault, char* __to) const
-      {
- __builtin_memcpy(__to, __lo, __hi - __lo);
- return __hi;
-      }
-
-    private:
-      void _M_narrow_init() const;
-      void _M_widen_init() const;
-    };
-# 1181 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<>
-    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
-    {
-    public:
-
-
-      typedef wchar_t char_type;
-      typedef wctype_t __wmask_type;
-
-    protected:
-      __c_locale _M_c_locale_ctype;
-
-
-      bool _M_narrow_ok;
-      char _M_narrow[128];
-      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
-
-
-      mask _M_bit[16];
-      __wmask_type _M_wmask[16];
-
-    public:
-
-
-      static locale::id id;
-# 1214 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      ctype(size_t __refs = 0);
-# 1225 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      ctype(__c_locale __cloc, size_t __refs = 0);
-
-    protected:
-      __wmask_type
-      _M_convert_to_wmask(const mask __m) const throw();
-
-
-      virtual
-      ~ctype();
-# 1249 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual bool
-      do_is(mask __m, char_type __c) const;
-# 1268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
-# 1286 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
-# 1304 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_scan_not(mask __m, const char_type* __lo,
-    const char_type* __hi) const;
-# 1321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_toupper(char_type __c) const;
-# 1338 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_toupper(char_type* __lo, const char_type* __hi) const;
-# 1354 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_tolower(char_type __c) const;
-# 1371 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_tolower(char_type* __lo, const char_type* __hi) const;
-# 1391 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_widen(char __c) const;
-# 1413 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char*
-      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
-# 1436 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char
-      do_narrow(char_type __c, char __dfault) const;
-# 1462 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual const char_type*
-      do_narrow(const char_type* __lo, const char_type* __hi,
-  char __dfault, char* __to) const;
-
-
-      void
-      _M_initialize_ctype() throw();
-    };
-
-
-
-  template<typename _CharT>
-    class ctype_byname : public ctype<_CharT>
-    {
-    public:
-      typedef typename ctype<_CharT>::mask mask;
-
-      explicit
-      ctype_byname(const char* __s, size_t __refs = 0);
-
-
-      explicit
-      ctype_byname(const string& __s, size_t __refs = 0)
-      : ctype_byname(__s.c_str(), __refs) { }
-
-
-    protected:
-      virtual
-      ~ctype_byname() { };
-    };
-
-
-  template<>
-    class ctype_byname<char> : public ctype<char>
-    {
-    public:
-      explicit
-      ctype_byname(const char* __s, size_t __refs = 0);
-
-
-      explicit
-      ctype_byname(const string& __s, size_t __refs = 0);
-
-
-    protected:
-      virtual
-      ~ctype_byname();
-    };
-
-
-  template<>
-    class ctype_byname<wchar_t> : public ctype<wchar_t>
-    {
-    public:
-      explicit
-      ctype_byname(const char* __s, size_t __refs = 0);
-
-
-      explicit
-      ctype_byname(const string& __s, size_t __refs = 0);
-
-
-    protected:
-      virtual
-      ~ctype_byname();
-    };
-
-
-
-}
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/x86_64-redhat-linux/bits/ctype_inline.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  bool
-  ctype<char>::
-  is(mask __m, char __c) const
-  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
-
-  const char*
-  ctype<char>::
-  is(const char* __low, const char* __high, mask* __vec) const
-  {
-    while (__low < __high)
-      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
-    return __high;
-  }
-
-  const char*
-  ctype<char>::
-  scan_is(mask __m, const char* __low, const char* __high) const
-  {
-    while (__low < __high
-    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
-      ++__low;
-    return __low;
-  }
-
-  const char*
-  ctype<char>::
-  scan_not(mask __m, const char* __low, const char* __high) const
-  {
-    while (__low < __high
-    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
-      ++__low;
-    return __low;
-  }
-
-
-}
-# 1535 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  class __num_base
-  {
-  public:
-
-
-    enum
-      {
- _S_ominus,
- _S_oplus,
- _S_ox,
- _S_oX,
- _S_odigits,
- _S_odigits_end = _S_odigits + 16,
- _S_oudigits = _S_odigits_end,
- _S_oudigits_end = _S_oudigits + 16,
- _S_oe = _S_odigits + 14,
- _S_oE = _S_oudigits + 14,
- _S_oend = _S_oudigits_end
-      };
-
-
-
-
-
-
-    static const char* _S_atoms_out;
-
-
-
-    static const char* _S_atoms_in;
-
-    enum
-    {
-      _S_iminus,
-      _S_iplus,
-      _S_ix,
-      _S_iX,
-      _S_izero,
-      _S_ie = _S_izero + 14,
-      _S_iE = _S_izero + 20,
-      _S_iend = 26
-    };
-
-
-
-    static void
-    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
-  };
-
-  template<typename _CharT>
-    struct __numpunct_cache : public locale::facet
-    {
-      const char* _M_grouping;
-      size_t _M_grouping_size;
-      bool _M_use_grouping;
-      const _CharT* _M_truename;
-      size_t _M_truename_size;
-      const _CharT* _M_falsename;
-      size_t _M_falsename_size;
-      _CharT _M_decimal_point;
-      _CharT _M_thousands_sep;
-
-
-
-
-
-      _CharT _M_atoms_out[__num_base::_S_oend];
-
-
-
-
-
-      _CharT _M_atoms_in[__num_base::_S_iend];
-
-      bool _M_allocated;
-
-      __numpunct_cache(size_t __refs = 0)
-      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
- _M_use_grouping(false),
- _M_truename(0), _M_truename_size(0), _M_falsename(0),
- _M_falsename_size(0), _M_decimal_point(_CharT()),
- _M_thousands_sep(_CharT()), _M_allocated(false)
- { }
-
-      ~__numpunct_cache();
-
-      void
-      _M_cache(const locale& __loc);
-
-    private:
-      __numpunct_cache&
-      operator=(const __numpunct_cache&);
-
-      explicit
-      __numpunct_cache(const __numpunct_cache&);
-    };
-
-  template<typename _CharT>
-    __numpunct_cache<_CharT>::~__numpunct_cache()
-    {
-      if (_M_allocated)
- {
-   delete [] _M_grouping;
-   delete [] _M_truename;
-   delete [] _M_falsename;
- }
-    }
-
-namespace __cxx11 {
-# 1665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT>
-    class numpunct : public locale::facet
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef basic_string<_CharT> string_type;
-
-      typedef __numpunct_cache<_CharT> __cache_type;
-
-    protected:
-      __cache_type* _M_data;
-
-    public:
-
-      static locale::id id;
-
-
-
-
-
-
-      explicit
-      numpunct(size_t __refs = 0)
-      : facet(__refs), _M_data(0)
-      { _M_initialize_numpunct(); }
-# 1703 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      numpunct(__cache_type* __cache, size_t __refs = 0)
-      : facet(__refs), _M_data(__cache)
-      { _M_initialize_numpunct(); }
-# 1717 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      numpunct(__c_locale __cloc, size_t __refs = 0)
-      : facet(__refs), _M_data(0)
-      { _M_initialize_numpunct(__cloc); }
-# 1731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      decimal_point() const
-      { return this->do_decimal_point(); }
-# 1744 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      char_type
-      thousands_sep() const
-      { return this->do_thousands_sep(); }
-# 1775 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      string
-      grouping() const
-      { return this->do_grouping(); }
-# 1788 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      string_type
-      truename() const
-      { return this->do_truename(); }
-# 1801 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      string_type
-      falsename() const
-      { return this->do_falsename(); }
-
-    protected:
-
-      virtual
-      ~numpunct();
-# 1818 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_decimal_point() const
-      { return _M_data->_M_decimal_point; }
-# 1830 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual char_type
-      do_thousands_sep() const
-      { return _M_data->_M_thousands_sep; }
-# 1843 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual string
-      do_grouping() const
-      { return _M_data->_M_grouping; }
-# 1856 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual string_type
-      do_truename() const
-      { return _M_data->_M_truename; }
-# 1869 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual string_type
-      do_falsename() const
-      { return _M_data->_M_falsename; }
-
-
-      void
-      _M_initialize_numpunct(__c_locale __cloc = 0);
-    };
-
-  template<typename _CharT>
-    locale::id numpunct<_CharT>::id;
-
-  template<>
-    numpunct<char>::~numpunct();
-
-  template<>
-    void
-    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
-
-
-  template<>
-    numpunct<wchar_t>::~numpunct();
-
-  template<>
-    void
-    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
-
-
-
-  template<typename _CharT>
-    class numpunct_byname : public numpunct<_CharT>
-    {
-    public:
-      typedef _CharT char_type;
-      typedef basic_string<_CharT> string_type;
-
-      explicit
-      numpunct_byname(const char* __s, size_t __refs = 0)
-      : numpunct<_CharT>(__refs)
-      {
- if (__builtin_strcmp(__s, "C") != 0
-     && __builtin_strcmp(__s, "POSIX") != 0)
-   {
-     __c_locale __tmp;
-     this->_S_create_c_locale(__tmp, __s);
-     this->_M_initialize_numpunct(__tmp);
-     this->_S_destroy_c_locale(__tmp);
-   }
-      }
-
-
-      explicit
-      numpunct_byname(const string& __s, size_t __refs = 0)
-      : numpunct_byname(__s.c_str(), __refs) { }
-
-
-    protected:
-      virtual
-      ~numpunct_byname() { }
-    };
-
-}
-# 1947 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT, typename _InIter>
-    class num_get : public locale::facet
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef _InIter iter_type;
-
-
-
-      static locale::id id;
-# 1968 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      num_get(size_t __refs = 0) : facet(__refs) { }
-# 1994 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, bool& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-# 2031 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, unsigned short& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, unsigned int& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, unsigned long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, long long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, unsigned long long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-# 2091 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, float& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, double& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, long double& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-# 2134 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
-   ios_base::iostate& __err, void*& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
-
-    protected:
-
-      virtual ~num_get() { }
-
-      __attribute ((__abi_tag__ ("cxx11")))
-      iter_type
-      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
-         string&) const;
-
-      template<typename _ValueT>
- __attribute ((__abi_tag__ ("cxx11")))
- iter_type
- _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
-         _ValueT&) const;
-
-      template<typename _CharT2>
-      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
- _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
- {
-   int __ret = -1;
-   if (__len <= 10)
-     {
-       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
-  __ret = __c - _CharT2('0');
-     }
-   else
-     {
-       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
-  __ret = __c - _CharT2('0');
-       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
-  __ret = 10 + (__c - _CharT2('a'));
-       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
-  __ret = 10 + (__c - _CharT2('A'));
-     }
-   return __ret;
- }
-
-      template<typename _CharT2>
-      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
-          int>::__type
- _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
- {
-   int __ret = -1;
-   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
-   if (__q)
-     {
-       __ret = __q - __zero;
-       if (__ret > 15)
-  __ret -= 6;
-     }
-   return __ret;
- }
-# 2207 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual iter_type
-      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, long& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, unsigned short& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, unsigned int& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, unsigned long& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, long long& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-      virtual iter_type
-      do_get(iter_type __beg, iter_type __end, ios_base& __io,
-      ios_base::iostate& __err, unsigned long long& __v) const
-      { return _M_extract_int(__beg, __end, __io, __err, __v); }
-
-
-      virtual iter_type
-      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
-
-      virtual iter_type
-      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
-      double&) const;
-
-
-
-
-
-
-
-      virtual iter_type
-      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
-      long double&) const;
-
-
-      virtual iter_type
-      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
-# 2270 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-    };
-
-  template<typename _CharT, typename _InIter>
-    locale::id num_get<_CharT, _InIter>::id;
-# 2288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT, typename _OutIter>
-    class num_put : public locale::facet
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef _OutIter iter_type;
-
-
-
-      static locale::id id;
-# 2309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      explicit
-      num_put(size_t __refs = 0) : facet(__refs) { }
-# 2327 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-# 2369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill,
-   unsigned long __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-
-
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill,
-   unsigned long long __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-# 2432 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill,
-   long double __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-# 2457 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      iter_type
-      put(iter_type __s, ios_base& __io, char_type __fill,
-   const void* __v) const
-      { return this->do_put(__s, __io, __fill, __v); }
-
-    protected:
-      template<typename _ValueT>
- iter_type
- _M_insert_float(iter_type, ios_base& __io, char_type __fill,
-   char __mod, _ValueT __v) const;
-
-      void
-      _M_group_float(const char* __grouping, size_t __grouping_size,
-       char_type __sep, const char_type* __p, char_type* __new,
-       char_type* __cs, int& __len) const;
-
-      template<typename _ValueT>
- iter_type
- _M_insert_int(iter_type, ios_base& __io, char_type __fill,
-        _ValueT __v) const;
-
-      void
-      _M_group_int(const char* __grouping, size_t __grouping_size,
-     char_type __sep, ios_base& __io, char_type* __new,
-     char_type* __cs, int& __len) const;
-
-      void
-      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
-      char_type* __new, const char_type* __cs, int& __len) const;
-
-
-      virtual
-      ~num_put() { };
-# 2505 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-      virtual iter_type
-      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
-
-      virtual iter_type
-      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
-      { return _M_insert_int(__s, __io, __fill, __v); }
-
-      virtual iter_type
-      do_put(iter_type __s, ios_base& __io, char_type __fill,
-      unsigned long __v) const
-      { return _M_insert_int(__s, __io, __fill, __v); }
-
-
-      virtual iter_type
-      do_put(iter_type __s, ios_base& __io, char_type __fill,
-      long long __v) const
-      { return _M_insert_int(__s, __io, __fill, __v); }
-
-      virtual iter_type
-      do_put(iter_type __s, ios_base& __io, char_type __fill,
-      unsigned long long __v) const
-      { return _M_insert_int(__s, __io, __fill, __v); }
-
-
-      virtual iter_type
-      do_put(iter_type, ios_base&, char_type, double) const;
-
-
-
-
-
-
-      virtual iter_type
-      do_put(iter_type, ios_base&, char_type, long double) const;
-
-
-      virtual iter_type
-      do_put(iter_type, ios_base&, char_type, const void*) const;
-
-
-
-
-
-
-
-    };
-
-  template <typename _CharT, typename _OutIter>
-    locale::id num_put<_CharT, _OutIter>::id;
-# 2563 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 3
-  template<typename _CharT>
-    inline bool
-    isspace(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isprint(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    iscntrl(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isupper(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    islower(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isalpha(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isdigit(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    ispunct(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isxdigit(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isalnum(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
-
-
-  template<typename _CharT>
-    inline bool
-    isgraph(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
-
-
-
-  template<typename _CharT>
-    inline bool
-    isblank(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
-
-
-
-  template<typename _CharT>
-    inline _CharT
-    toupper(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
-
-
-  template<typename _CharT>
-    inline _CharT
-    tolower(_CharT __c, const locale& __loc)
-    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template<typename _Facet>
-    struct __use_cache
-    {
-      const _Facet*
-      operator() (const locale& __loc) const;
-    };
-
-
-  template<typename _CharT>
-    struct __use_cache<__numpunct_cache<_CharT> >
-    {
-      const __numpunct_cache<_CharT>*
-      operator() (const locale& __loc) const
-      {
- const size_t __i = numpunct<_CharT>::id._M_id();
- const locale::facet** __caches = __loc._M_impl->_M_caches;
- if (!__caches[__i])
-   {
-     __numpunct_cache<_CharT>* __tmp = 0;
-     try
-       {
-  __tmp = new __numpunct_cache<_CharT>;
-  __tmp->_M_cache(__loc);
-       }
-     catch(...)
-       {
-  delete __tmp;
-  throw;
-       }
-     __loc._M_impl->_M_install_cache(__tmp, __i);
-   }
- return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
-      }
-    };
-
-  template<typename _CharT>
-    void
-    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
-    {
-      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
-
-      char* __grouping = 0;
-      _CharT* __truename = 0;
-      _CharT* __falsename = 0;
-      try
- {
-   const string& __g = __np.grouping();
-   _M_grouping_size = __g.size();
-   __grouping = new char[_M_grouping_size];
-   __g.copy(__grouping, _M_grouping_size);
-   _M_use_grouping = (_M_grouping_size
-        && static_cast<signed char>(__grouping[0]) > 0
-        && (__grouping[0]
-     != __gnu_cxx::__numeric_traits<char>::__max));
-
-   const basic_string<_CharT>& __tn = __np.truename();
-   _M_truename_size = __tn.size();
-   __truename = new _CharT[_M_truename_size];
-   __tn.copy(__truename, _M_truename_size);
-
-   const basic_string<_CharT>& __fn = __np.falsename();
-   _M_falsename_size = __fn.size();
-   __falsename = new _CharT[_M_falsename_size];
-   __fn.copy(__falsename, _M_falsename_size);
-
-   _M_decimal_point = __np.decimal_point();
-   _M_thousands_sep = __np.thousands_sep();
-
-   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
-   __ct.widen(__num_base::_S_atoms_out,
-       __num_base::_S_atoms_out
-       + __num_base::_S_oend, _M_atoms_out);
-   __ct.widen(__num_base::_S_atoms_in,
-       __num_base::_S_atoms_in
-       + __num_base::_S_iend, _M_atoms_in);
-
-   _M_grouping = __grouping;
-   _M_truename = __truename;
-   _M_falsename = __falsename;
-   _M_allocated = true;
- }
-      catch(...)
- {
-   delete [] __grouping;
-   delete [] __truename;
-   delete [] __falsename;
-   throw;
- }
-    }
-# 139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-  __attribute__ ((__pure__)) bool
-  __verify_grouping(const char* __grouping, size_t __grouping_size,
-      const string& __grouping_tmp) throw ();
-
-
-
-  template<typename _CharT, typename _InIter>
-    __attribute ((__abi_tag__ ("cxx11")))
-    _InIter
-    num_get<_CharT, _InIter>::
-    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
-       ios_base::iostate& __err, string& __xtrc) const
-    {
-      typedef char_traits<_CharT> __traits_type;
-      typedef __numpunct_cache<_CharT> __cache_type;
-      __use_cache<__cache_type> __uc;
-      const locale& __loc = __io._M_getloc();
-      const __cache_type* __lc = __uc(__loc);
-      const _CharT* __lit = __lc->_M_atoms_in;
-      char_type __c = char_type();
-
-
-      bool __testeof = __beg == __end;
-
-
-      if (!__testeof)
- {
-   __c = *__beg;
-   const bool __plus = __c == __lit[__num_base::_S_iplus];
-   if ((__plus || __c == __lit[__num_base::_S_iminus])
-       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-       && !(__c == __lc->_M_decimal_point))
-     {
-       __xtrc += __plus ? '+' : '-';
-       if (++__beg != __end)
-  __c = *__beg;
-       else
-  __testeof = true;
-     }
- }
-
-
-      bool __found_mantissa = false;
-      int __sep_pos = 0;
-      while (!__testeof)
- {
-   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-       || __c == __lc->_M_decimal_point)
-     break;
-   else if (__c == __lit[__num_base::_S_izero])
-     {
-       if (!__found_mantissa)
-  {
-    __xtrc += '0';
-    __found_mantissa = true;
-  }
-       ++__sep_pos;
-
-       if (++__beg != __end)
-  __c = *__beg;
-       else
-  __testeof = true;
-     }
-   else
-     break;
- }
-
-
-      bool __found_dec = false;
-      bool __found_sci = false;
-      string __found_grouping;
-      if (__lc->_M_use_grouping)
- __found_grouping.reserve(32);
-      const char_type* __lit_zero = __lit + __num_base::_S_izero;
-
-      if (!__lc->_M_allocated)
-
- while (!__testeof)
-   {
-     const int __digit = _M_find(__lit_zero, 10, __c);
-     if (__digit != -1)
-       {
-  __xtrc += '0' + __digit;
-  __found_mantissa = true;
-       }
-     else if (__c == __lc->_M_decimal_point
-       && !__found_dec && !__found_sci)
-       {
-  __xtrc += '.';
-  __found_dec = true;
-       }
-     else if ((__c == __lit[__num_base::_S_ie]
-        || __c == __lit[__num_base::_S_iE])
-       && !__found_sci && __found_mantissa)
-       {
-
-  __xtrc += 'e';
-  __found_sci = true;
-
-
-  if (++__beg != __end)
-    {
-      __c = *__beg;
-      const bool __plus = __c == __lit[__num_base::_S_iplus];
-      if (__plus || __c == __lit[__num_base::_S_iminus])
-        __xtrc += __plus ? '+' : '-';
-      else
-        continue;
-    }
-  else
-    {
-      __testeof = true;
-      break;
-    }
-       }
-     else
-       break;
-
-     if (++__beg != __end)
-       __c = *__beg;
-     else
-       __testeof = true;
-   }
-      else
- while (!__testeof)
-   {
-
-
-     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-       {
-  if (!__found_dec && !__found_sci)
-    {
-
-
-      if (__sep_pos)
-        {
-   __found_grouping += static_cast<char>(__sep_pos);
-   __sep_pos = 0;
-        }
-      else
-        {
-
-
-   __xtrc.clear();
-   break;
-        }
-    }
-  else
-    break;
-       }
-     else if (__c == __lc->_M_decimal_point)
-       {
-  if (!__found_dec && !__found_sci)
-    {
-
-
-
-      if (__found_grouping.size())
-        __found_grouping += static_cast<char>(__sep_pos);
-      __xtrc += '.';
-      __found_dec = true;
-    }
-  else
-    break;
-       }
-     else
-       {
-  const char_type* __q =
-    __traits_type::find(__lit_zero, 10, __c);
-  if (__q)
-    {
-      __xtrc += '0' + (__q - __lit_zero);
-      __found_mantissa = true;
-      ++__sep_pos;
-    }
-  else if ((__c == __lit[__num_base::_S_ie]
-     || __c == __lit[__num_base::_S_iE])
-    && !__found_sci && __found_mantissa)
-    {
-
-      if (__found_grouping.size() && !__found_dec)
-        __found_grouping += static_cast<char>(__sep_pos);
-      __xtrc += 'e';
-      __found_sci = true;
-
-
-      if (++__beg != __end)
-        {
-   __c = *__beg;
-   const bool __plus = __c == __lit[__num_base::_S_iplus];
-   if ((__plus || __c == __lit[__num_base::_S_iminus])
-       && !(__lc->_M_use_grouping
-     && __c == __lc->_M_thousands_sep)
-       && !(__c == __lc->_M_decimal_point))
-        __xtrc += __plus ? '+' : '-';
-   else
-     continue;
-        }
-      else
-        {
-   __testeof = true;
-   break;
-        }
-    }
-  else
-    break;
-       }
-
-     if (++__beg != __end)
-       __c = *__beg;
-     else
-       __testeof = true;
-   }
-
-
-
-      if (__found_grouping.size())
-        {
-
-   if (!__found_dec && !__found_sci)
-     __found_grouping += static_cast<char>(__sep_pos);
-
-          if (!std::__verify_grouping(__lc->_M_grouping,
-          __lc->_M_grouping_size,
-          __found_grouping))
-     __err = ios_base::failbit;
-        }
-
-      return __beg;
-    }
-
-  template<typename _CharT, typename _InIter>
-    template<typename _ValueT>
-      __attribute ((__abi_tag__ ("cxx11")))
-      _InIter
-      num_get<_CharT, _InIter>::
-      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
-       ios_base::iostate& __err, _ValueT& __v) const
-      {
-        typedef char_traits<_CharT> __traits_type;
- using __gnu_cxx::__add_unsigned;
- typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
- typedef __numpunct_cache<_CharT> __cache_type;
- __use_cache<__cache_type> __uc;
- const locale& __loc = __io._M_getloc();
- const __cache_type* __lc = __uc(__loc);
- const _CharT* __lit = __lc->_M_atoms_in;
- char_type __c = char_type();
-
-
- const ios_base::fmtflags __basefield = __io.flags()
-                                        & ios_base::basefield;
- const bool __oct = __basefield == ios_base::oct;
- int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
-
-
- bool __testeof = __beg == __end;
-
-
- bool __negative = false;
- if (!__testeof)
-   {
-     __c = *__beg;
-     __negative = __c == __lit[__num_base::_S_iminus];
-     if ((__negative || __c == __lit[__num_base::_S_iplus])
-  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-  && !(__c == __lc->_M_decimal_point))
-       {
-  if (++__beg != __end)
-    __c = *__beg;
-  else
-    __testeof = true;
-       }
-   }
-
-
-
- bool __found_zero = false;
- int __sep_pos = 0;
- while (!__testeof)
-   {
-     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-  || __c == __lc->_M_decimal_point)
-       break;
-     else if (__c == __lit[__num_base::_S_izero]
-       && (!__found_zero || __base == 10))
-       {
-  __found_zero = true;
-  ++__sep_pos;
-  if (__basefield == 0)
-    __base = 8;
-  if (__base == 8)
-    __sep_pos = 0;
-       }
-     else if (__found_zero
-       && (__c == __lit[__num_base::_S_ix]
-    || __c == __lit[__num_base::_S_iX]))
-       {
-  if (__basefield == 0)
-    __base = 16;
-  if (__base == 16)
-    {
-      __found_zero = false;
-      __sep_pos = 0;
-    }
-  else
-    break;
-       }
-     else
-       break;
-
-     if (++__beg != __end)
-       {
-  __c = *__beg;
-  if (!__found_zero)
-    break;
-       }
-     else
-       __testeof = true;
-   }
-
-
-
- const size_t __len = (__base == 16 ? __num_base::_S_iend
-         - __num_base::_S_izero : __base);
-
-
- string __found_grouping;
- if (__lc->_M_use_grouping)
-   __found_grouping.reserve(32);
- bool __testfail = false;
- bool __testoverflow = false;
- const __unsigned_type __max =
-   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
-   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
-   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
- const __unsigned_type __smax = __max / __base;
- __unsigned_type __result = 0;
- int __digit = 0;
- const char_type* __lit_zero = __lit + __num_base::_S_izero;
-
- if (!__lc->_M_allocated)
-
-   while (!__testeof)
-     {
-       __digit = _M_find(__lit_zero, __len, __c);
-       if (__digit == -1)
-  break;
-
-       if (__result > __smax)
-  __testoverflow = true;
-       else
-  {
-    __result *= __base;
-    __testoverflow |= __result > __max - __digit;
-    __result += __digit;
-    ++__sep_pos;
-  }
-
-       if (++__beg != __end)
-  __c = *__beg;
-       else
-  __testeof = true;
-     }
- else
-   while (!__testeof)
-     {
-
-
-       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
-  {
-
-
-    if (__sep_pos)
-      {
-        __found_grouping += static_cast<char>(__sep_pos);
-        __sep_pos = 0;
-      }
-    else
-      {
-        __testfail = true;
-        break;
-      }
-  }
-       else if (__c == __lc->_M_decimal_point)
-  break;
-       else
-  {
-    const char_type* __q =
-      __traits_type::find(__lit_zero, __len, __c);
-    if (!__q)
-      break;
-
-    __digit = __q - __lit_zero;
-    if (__digit > 15)
-      __digit -= 6;
-    if (__result > __smax)
-      __testoverflow = true;
-    else
-      {
-        __result *= __base;
-        __testoverflow |= __result > __max - __digit;
-        __result += __digit;
-        ++__sep_pos;
-      }
-  }
-
-       if (++__beg != __end)
-  __c = *__beg;
-       else
-  __testeof = true;
-     }
-
-
-
- if (__found_grouping.size())
-   {
-
-     __found_grouping += static_cast<char>(__sep_pos);
-
-     if (!std::__verify_grouping(__lc->_M_grouping,
-     __lc->_M_grouping_size,
-     __found_grouping))
-       __err = ios_base::failbit;
-   }
-
-
-
- if ((!__sep_pos && !__found_zero && !__found_grouping.size())
-     || __testfail)
-   {
-     __v = 0;
-     __err = ios_base::failbit;
-   }
- else if (__testoverflow)
-   {
-     if (__negative
-  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
-       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
-     else
-       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
-     __err = ios_base::failbit;
-   }
- else
-   __v = __negative ? -__result : __result;
-
- if (__testeof)
-   __err |= ios_base::eofbit;
- return __beg;
-      }
-
-
-
-  template<typename _CharT, typename _InIter>
-    _InIter
-    num_get<_CharT, _InIter>::
-    do_get(iter_type __beg, iter_type __end, ios_base& __io,
-           ios_base::iostate& __err, bool& __v) const
-    {
-      if (!(__io.flags() & ios_base::boolalpha))
-        {
-
-
-
-   long __l = -1;
-          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
-   if (__l == 0 || __l == 1)
-     __v = bool(__l);
-   else
-     {
-
-
-       __v = true;
-       __err = ios_base::failbit;
-       if (__beg == __end)
-  __err |= ios_base::eofbit;
-     }
-        }
-      else
-        {
-
-   typedef __numpunct_cache<_CharT> __cache_type;
-   __use_cache<__cache_type> __uc;
-   const locale& __loc = __io._M_getloc();
-   const __cache_type* __lc = __uc(__loc);
-
-   bool __testf = true;
-   bool __testt = true;
-   bool __donef = __lc->_M_falsename_size == 0;
-   bool __donet = __lc->_M_truename_size == 0;
-   bool __testeof = false;
-   size_t __n = 0;
-   while (!__donef || !__donet)
-     {
-       if (__beg == __end)
-  {
-    __testeof = true;
-    break;
-  }
-
-       const char_type __c = *__beg;
-
-       if (!__donef)
-  __testf = __c == __lc->_M_falsename[__n];
-
-       if (!__testf && __donet)
-  break;
-
-       if (!__donet)
-  __testt = __c == __lc->_M_truename[__n];
-
-       if (!__testt && __donef)
-  break;
-
-       if (!__testt && !__testf)
-  break;
-
-       ++__n;
-       ++__beg;
-
-       __donef = !__testf || __n >= __lc->_M_falsename_size;
-       __donet = !__testt || __n >= __lc->_M_truename_size;
-     }
-   if (__testf && __n == __lc->_M_falsename_size && __n)
-     {
-       __v = false;
-       if (__testt && __n == __lc->_M_truename_size)
-  __err = ios_base::failbit;
-       else
-  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
-     }
-   else if (__testt && __n == __lc->_M_truename_size && __n)
-     {
-       __v = true;
-       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
-     }
-   else
-     {
-
-
-       __v = false;
-       __err = ios_base::failbit;
-       if (__testeof)
-  __err |= ios_base::eofbit;
-     }
- }
-      return __beg;
-    }
-
-  template<typename _CharT, typename _InIter>
-    _InIter
-    num_get<_CharT, _InIter>::
-    do_get(iter_type __beg, iter_type __end, ios_base& __io,
-    ios_base::iostate& __err, float& __v) const
-    {
-      string __xtrc;
-      __xtrc.reserve(32);
-      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
-      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
-      if (__beg == __end)
- __err |= ios_base::eofbit;
-      return __beg;
-    }
-
-  template<typename _CharT, typename _InIter>
-    _InIter
-    num_get<_CharT, _InIter>::
-    do_get(iter_type __beg, iter_type __end, ios_base& __io,
-           ios_base::iostate& __err, double& __v) const
-    {
-      string __xtrc;
-      __xtrc.reserve(32);
-      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
-      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
-      if (__beg == __end)
- __err |= ios_base::eofbit;
-      return __beg;
-    }
-# 735 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-  template<typename _CharT, typename _InIter>
-    _InIter
-    num_get<_CharT, _InIter>::
-    do_get(iter_type __beg, iter_type __end, ios_base& __io,
-           ios_base::iostate& __err, long double& __v) const
-    {
-      string __xtrc;
-      __xtrc.reserve(32);
-      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
-      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
-      if (__beg == __end)
- __err |= ios_base::eofbit;
-      return __beg;
-    }
-
-  template<typename _CharT, typename _InIter>
-    _InIter
-    num_get<_CharT, _InIter>::
-    do_get(iter_type __beg, iter_type __end, ios_base& __io,
-           ios_base::iostate& __err, void*& __v) const
-    {
-
-      typedef ios_base::fmtflags fmtflags;
-      const fmtflags __fmt = __io.flags();
-      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
-
-      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
-          <= sizeof(unsigned long)),
- unsigned long, unsigned long long>::__type _UIntPtrType;
-
-      _UIntPtrType __ul;
-      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
-
-
-      __io.flags(__fmt);
-
-      __v = reinterpret_cast<void*>(__ul);
-      return __beg;
-    }
-
-
-
-  template<typename _CharT, typename _OutIter>
-    void
-    num_put<_CharT, _OutIter>::
-    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
-    _CharT* __new, const _CharT* __cs, int& __len) const
-    {
-
-
-      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
-        __cs, __w, __len);
-      __len = static_cast<int>(__w);
-    }
-
-
-
-  template<typename _CharT, typename _ValueT>
-    int
-    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
-    ios_base::fmtflags __flags, bool __dec)
-    {
-      _CharT* __buf = __bufend;
-      if (__builtin_expect(__dec, true))
- {
-
-   do
-     {
-       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
-       __v /= 10;
-     }
-   while (__v != 0);
- }
-      else if ((__flags & ios_base::basefield) == ios_base::oct)
- {
-
-   do
-     {
-       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
-       __v >>= 3;
-     }
-   while (__v != 0);
- }
-      else
- {
-
-   const bool __uppercase = __flags & ios_base::uppercase;
-   const int __case_offset = __uppercase ? __num_base::_S_oudigits
-                                         : __num_base::_S_odigits;
-   do
-     {
-       *--__buf = __lit[(__v & 0xf) + __case_offset];
-       __v >>= 4;
-     }
-   while (__v != 0);
- }
-      return __bufend - __buf;
-    }
-
-
-
-  template<typename _CharT, typename _OutIter>
-    void
-    num_put<_CharT, _OutIter>::
-    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
-   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
-    {
-      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
-     __grouping_size, __cs, __cs + __len);
-      __len = __p - __new;
-    }
-
-  template<typename _CharT, typename _OutIter>
-    template<typename _ValueT>
-      _OutIter
-      num_put<_CharT, _OutIter>::
-      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
-      _ValueT __v) const
-      {
- using __gnu_cxx::__add_unsigned;
- typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
- typedef __numpunct_cache<_CharT> __cache_type;
- __use_cache<__cache_type> __uc;
- const locale& __loc = __io._M_getloc();
- const __cache_type* __lc = __uc(__loc);
- const _CharT* __lit = __lc->_M_atoms_out;
- const ios_base::fmtflags __flags = __io.flags();
-
-
- const int __ilen = 5 * sizeof(_ValueT);
- _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-            * __ilen));
-
-
-
- const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
- const bool __dec = (__basefield != ios_base::oct
-       && __basefield != ios_base::hex);
- const __unsigned_type __u = ((__v > 0 || !__dec)
-         ? __unsigned_type(__v)
-         : -__unsigned_type(__v));
-  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
- __cs += __ilen - __len;
-
-
- if (__lc->_M_use_grouping)
-   {
-
-
-     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-          * (__len + 1)
-          * 2));
-     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
-    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
-     __cs = __cs2 + 2;
-   }
-
-
- if (__builtin_expect(__dec, true))
-   {
-
-     if (__v >= 0)
-       {
-  if (bool(__flags & ios_base::showpos)
-      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
-    *--__cs = __lit[__num_base::_S_oplus], ++__len;
-       }
-     else
-       *--__cs = __lit[__num_base::_S_ominus], ++__len;
-   }
- else if (bool(__flags & ios_base::showbase) && __v)
-   {
-     if (__basefield == ios_base::oct)
-       *--__cs = __lit[__num_base::_S_odigits], ++__len;
-     else
-       {
-
-  const bool __uppercase = __flags & ios_base::uppercase;
-  *--__cs = __lit[__num_base::_S_ox + __uppercase];
-
-  *--__cs = __lit[__num_base::_S_odigits];
-  __len += 2;
-       }
-   }
-
-
- const streamsize __w = __io.width();
- if (__w > static_cast<streamsize>(__len))
-   {
-     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-          * __w));
-     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
-     __cs = __cs3;
-   }
- __io.width(0);
-
-
-
- return std::__write(__s, __cs, __len);
-      }
-
-  template<typename _CharT, typename _OutIter>
-    void
-    num_put<_CharT, _OutIter>::
-    _M_group_float(const char* __grouping, size_t __grouping_size,
-     _CharT __sep, const _CharT* __p, _CharT* __new,
-     _CharT* __cs, int& __len) const
-    {
-
-
-
-      const int __declen = __p ? __p - __cs : __len;
-      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
-      __grouping_size,
-      __cs, __cs + __declen);
-
-
-      int __newlen = __p2 - __new;
-      if (__p)
- {
-   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
-   __newlen += __len - __declen;
- }
-      __len = __newlen;
-    }
-# 971 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-  template<typename _CharT, typename _OutIter>
-    template<typename _ValueT>
-      _OutIter
-      num_put<_CharT, _OutIter>::
-      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
-         _ValueT __v) const
-      {
- typedef __numpunct_cache<_CharT> __cache_type;
- __use_cache<__cache_type> __uc;
- const locale& __loc = __io._M_getloc();
- const __cache_type* __lc = __uc(__loc);
-
-
- const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
-
- const int __max_digits =
-   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
-
-
- int __len;
-
- char __fbuf[16];
- __num_base::_S_format_float(__io, __fbuf, __mod);
-
-
-
- const bool __use_prec =
-   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
-
-
-
- int __cs_size = __max_digits * 3;
- char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
- if (__use_prec)
-   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
-     __fbuf, __prec, __v);
- else
-   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
-     __fbuf, __v);
-
-
- if (__len >= __cs_size)
-   {
-     __cs_size = __len + 1;
-     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
-     if (__use_prec)
-       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
-         __fbuf, __prec, __v);
-     else
-       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
-         __fbuf, __v);
-   }
-# 1044 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
- const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
-
- _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-            * __len));
- __ctype.widen(__cs, __cs + __len, __ws);
-
-
- _CharT* __wp = 0;
- const char* __p = char_traits<char>::find(__cs, __len, '.');
- if (__p)
-   {
-     __wp = __ws + (__p - __cs);
-     *__wp = __lc->_M_decimal_point;
-   }
-
-
-
-
- if (__lc->_M_use_grouping
-     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
-          && __cs[1] >= '0' && __cs[2] >= '0')))
-   {
-
-
-     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-          * __len * 2));
-
-     streamsize __off = 0;
-     if (__cs[0] == '-' || __cs[0] == '+')
-       {
-  __off = 1;
-  __ws2[0] = __ws[0];
-  __len -= 1;
-       }
-
-     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
-      __lc->_M_thousands_sep, __wp, __ws2 + __off,
-      __ws + __off, __len);
-     __len += __off;
-
-     __ws = __ws2;
-   }
-
-
- const streamsize __w = __io.width();
- if (__w > static_cast<streamsize>(__len))
-   {
-     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-          * __w));
-     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
-     __ws = __ws3;
-   }
- __io.width(0);
-
-
-
- return std::__write(__s, __ws, __len);
-      }
-
-  template<typename _CharT, typename _OutIter>
-    _OutIter
-    num_put<_CharT, _OutIter>::
-    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
-    {
-      const ios_base::fmtflags __flags = __io.flags();
-      if ((__flags & ios_base::boolalpha) == 0)
-        {
-          const long __l = __v;
-          __s = _M_insert_int(__s, __io, __fill, __l);
-        }
-      else
-        {
-   typedef __numpunct_cache<_CharT> __cache_type;
-   __use_cache<__cache_type> __uc;
-   const locale& __loc = __io._M_getloc();
-   const __cache_type* __lc = __uc(__loc);
-
-   const _CharT* __name = __v ? __lc->_M_truename
-                              : __lc->_M_falsename;
-   int __len = __v ? __lc->_M_truename_size
-                   : __lc->_M_falsename_size;
-
-   const streamsize __w = __io.width();
-   if (__w > static_cast<streamsize>(__len))
-     {
-       const streamsize __plen = __w - __len;
-       _CharT* __ps
-  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
-       * __plen));
-
-       char_traits<_CharT>::assign(__ps, __plen, __fill);
-       __io.width(0);
-
-       if ((__flags & ios_base::adjustfield) == ios_base::left)
-  {
-    __s = std::__write(__s, __name, __len);
-    __s = std::__write(__s, __ps, __plen);
-  }
-       else
-  {
-    __s = std::__write(__s, __ps, __plen);
-    __s = std::__write(__s, __name, __len);
-  }
-       return __s;
-     }
-   __io.width(0);
-   __s = std::__write(__s, __name, __len);
- }
-      return __s;
-    }
-
-  template<typename _CharT, typename _OutIter>
-    _OutIter
-    num_put<_CharT, _OutIter>::
-    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
-    { return _M_insert_float(__s, __io, __fill, char(), __v); }
-# 1169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-  template<typename _CharT, typename _OutIter>
-    _OutIter
-    num_put<_CharT, _OutIter>::
-    do_put(iter_type __s, ios_base& __io, char_type __fill,
-    long double __v) const
-    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
-
-  template<typename _CharT, typename _OutIter>
-    _OutIter
-    num_put<_CharT, _OutIter>::
-    do_put(iter_type __s, ios_base& __io, char_type __fill,
-           const void* __v) const
-    {
-      const ios_base::fmtflags __flags = __io.flags();
-      const ios_base::fmtflags __fmt = ~(ios_base::basefield
-      | ios_base::uppercase);
-      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
-
-      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
-          <= sizeof(unsigned long)),
- unsigned long, unsigned long long>::__type _UIntPtrType;
-
-      __s = _M_insert_int(__s, __io, __fill,
-     reinterpret_cast<_UIntPtrType>(__v));
-      __io.flags(__flags);
-      return __s;
-    }
-# 1206 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.tcc" 3
-  template<typename _CharT, typename _Traits>
-    void
-    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
-       _CharT* __news, const _CharT* __olds,
-       streamsize __newlen, streamsize __oldlen)
-    {
-      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
-      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
-
-
-      if (__adjust == ios_base::left)
- {
-   _Traits::copy(__news, __olds, __oldlen);
-   _Traits::assign(__news + __oldlen, __plen, __fill);
-   return;
- }
-
-      size_t __mod = 0;
-      if (__adjust == ios_base::internal)
- {
-
-
-
-          const locale& __loc = __io._M_getloc();
-   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
-
-   if (__ctype.widen('-') == __olds[0]
-       || __ctype.widen('+') == __olds[0])
-     {
-       __news[0] = __olds[0];
-       __mod = 1;
-       ++__news;
-     }
-   else if (__ctype.widen('0') == __olds[0]
-     && __oldlen > 1
-     && (__ctype.widen('x') == __olds[1]
-         || __ctype.widen('X') == __olds[1]))
-     {
-       __news[0] = __olds[0];
-       __news[1] = __olds[1];
-       __mod = 2;
-       __news += 2;
-     }
-
- }
-      _Traits::assign(__news, __plen, __fill);
-      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
-    }
-
-  template<typename _CharT>
-    _CharT*
-    __add_grouping(_CharT* __s, _CharT __sep,
-     const char* __gbeg, size_t __gsize,
-     const _CharT* __first, const _CharT* __last)
-    {
-      size_t __idx = 0;
-      size_t __ctr = 0;
-
-      while (__last - __first > __gbeg[__idx]
-      && static_cast<signed char>(__gbeg[__idx]) > 0
-      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
- {
-   __last -= __gbeg[__idx];
-   __idx < __gsize - 1 ? ++__idx : ++__ctr;
- }
-
-      while (__first != __last)
- *__s++ = *__first++;
-
-      while (__ctr--)
- {
-   *__s++ = __sep;
-   for (char __i = __gbeg[__idx]; __i > 0; --__i)
-     *__s++ = *__first++;
- }
-
-      while (__idx--)
- {
-   *__s++ = __sep;
-   for (char __i = __gbeg[__idx]; __i > 0; --__i)
-     *__s++ = *__first++;
- }
-
-      return __s;
-    }
-
-
-
-
-  extern template class __cxx11:: numpunct<char>;
-  extern template class __cxx11:: numpunct_byname<char>;
-  extern template class num_get<char>;
-  extern template class num_put<char>;
-  extern template class ctype_byname<char>;
-
-  extern template
-    const ctype<char>&
-    use_facet<ctype<char> >(const locale&);
-
-  extern template
-    const numpunct<char>&
-    use_facet<numpunct<char> >(const locale&);
-
-  extern template
-    const num_put<char>&
-    use_facet<num_put<char> >(const locale&);
-
-  extern template
-    const num_get<char>&
-    use_facet<num_get<char> >(const locale&);
-
-  extern template
-    bool
-    has_facet<ctype<char> >(const locale&);
-
-  extern template
-    bool
-    has_facet<numpunct<char> >(const locale&);
-
-  extern template
-    bool
-    has_facet<num_put<char> >(const locale&);
-
-  extern template
-    bool
-    has_facet<num_get<char> >(const locale&);
-
-
-  extern template class __cxx11:: numpunct<wchar_t>;
-  extern template class __cxx11:: numpunct_byname<wchar_t>;
-  extern template class num_get<wchar_t>;
-  extern template class num_put<wchar_t>;
-  extern template class ctype_byname<wchar_t>;
-
-  extern template
-    const ctype<wchar_t>&
-    use_facet<ctype<wchar_t> >(const locale&);
-
-  extern template
-    const numpunct<wchar_t>&
-    use_facet<numpunct<wchar_t> >(const locale&);
-
-  extern template
-    const num_put<wchar_t>&
-    use_facet<num_put<wchar_t> >(const locale&);
-
-  extern template
-    const num_get<wchar_t>&
-    use_facet<num_get<wchar_t> >(const locale&);
-
- extern template
-    bool
-    has_facet<ctype<wchar_t> >(const locale&);
-
-  extern template
-    bool
-    has_facet<numpunct<wchar_t> >(const locale&);
-
-  extern template
-    bool
-    has_facet<num_put<wchar_t> >(const locale&);
-
-  extern template
-    bool
-    has_facet<num_get<wchar_t> >(const locale&);
-
-
-
-
-}
-# 2652 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/locale_facets.h" 2 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Facet>
-    inline const _Facet&
-    __check_facet(const _Facet* __f)
-    {
-      if (!__f)
- __throw_bad_cast();
-      return *__f;
-    }
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-  template<typename _CharT, typename _Traits>
-    class basic_ios : public ios_base
-    {
-    public:
-
-
-
-
-
-
-      typedef _CharT char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef typename _Traits::off_type off_type;
-      typedef _Traits traits_type;
-
-
-
-
-
-
-      typedef ctype<_CharT> __ctype_type;
-      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
-           __num_put_type;
-      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
-           __num_get_type;
-
-
-
-    protected:
-      basic_ostream<_CharT, _Traits>* _M_tie;
-      mutable char_type _M_fill;
-      mutable bool _M_fill_init;
-      basic_streambuf<_CharT, _Traits>* _M_streambuf;
-
-
-      const __ctype_type* _M_ctype;
-
-      const __num_put_type* _M_num_put;
-
-      const __num_get_type* _M_num_get;
-
-    public:
-# 117 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      explicit operator bool() const
-      { return !this->fail(); }
-
-
-
-
-
-      bool
-      operator!() const
-      { return this->fail(); }
-# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      iostate
-      rdstate() const
-      { return _M_streambuf_state; }
-# 147 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      void
-      clear(iostate __state = goodbit);
-
-
-
-
-
-
-
-      void
-      setstate(iostate __state)
-      { this->clear(this->rdstate() | __state); }
-
-
-
-
-      void
-      _M_setstate(iostate __state)
-      {
-
-
- _M_streambuf_state |= __state;
- if (this->exceptions() & __state)
-   throw;
-      }
-
-
-
-
-
-
-
-      bool
-      good() const
-      { return this->rdstate() == 0; }
-
-
-
-
-
-
-
-      bool
-      eof() const
-      { return (this->rdstate() & eofbit) != 0; }
-# 200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      bool
-      fail() const
-      { return (this->rdstate() & (badbit | failbit)) != 0; }
-
-
-
-
-
-
-
-      bool
-      bad() const
-      { return (this->rdstate() & badbit) != 0; }
-# 221 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      iostate
-      exceptions() const
-      { return _M_exception; }
-# 256 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      void
-      exceptions(iostate __except)
-      {
-        _M_exception = __except;
-        this->clear(_M_streambuf_state);
-      }
-
-
-
-
-
-
-
-      explicit
-      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
-      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
- _M_ctype(0), _M_num_put(0), _M_num_get(0)
-      { this->init(__sb); }
-
-
-
-
-
-
-
-      virtual
-      ~basic_ios() { }
-# 294 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      basic_ostream<_CharT, _Traits>*
-      tie() const
-      { return _M_tie; }
-# 306 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      basic_ostream<_CharT, _Traits>*
-      tie(basic_ostream<_CharT, _Traits>* __tiestr)
-      {
-        basic_ostream<_CharT, _Traits>* __old = _M_tie;
-        _M_tie = __tiestr;
-        return __old;
-      }
-
-
-
-
-
-
-
-      basic_streambuf<_CharT, _Traits>*
-      rdbuf() const
-      { return _M_streambuf; }
-# 346 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      basic_streambuf<_CharT, _Traits>*
-      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
-# 360 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      basic_ios&
-      copyfmt(const basic_ios& __rhs);
-
-
-
-
-
-
-
-      char_type
-      fill() const
-      {
- if (!_M_fill_init)
-   {
-     _M_fill = this->widen(' ');
-     _M_fill_init = true;
-   }
- return _M_fill;
-      }
-# 389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      char_type
-      fill(char_type __ch)
-      {
- char_type __old = this->fill();
- _M_fill = __ch;
- return __old;
-      }
-# 409 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      locale
-      imbue(const locale& __loc);
-# 429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      char
-      narrow(char_type __c, char __dfault) const
-      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
-# 448 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 3
-      char_type
-      widen(char __c) const
-      { return __check_facet(_M_ctype).widen(__c); }
-
-    protected:
-
-
-
-
-
-
-
-      basic_ios()
-      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
- _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
-      { }
-
-
-
-
-
-
-
-      void
-      init(basic_streambuf<_CharT, _Traits>* __sb);
-
-
-      basic_ios(const basic_ios&) = delete;
-      basic_ios& operator=(const basic_ios&) = delete;
-
-      void
-      move(basic_ios& __rhs)
-      {
- ios_base::_M_move(__rhs);
- _M_cache_locale(_M_ios_locale);
- this->tie(__rhs.tie(nullptr));
- _M_fill = __rhs._M_fill;
- _M_fill_init = __rhs._M_fill_init;
- _M_streambuf = nullptr;
-      }
-
-      void
-      move(basic_ios&& __rhs)
-      { this->move(__rhs); }
-
-      void
-      swap(basic_ios& __rhs) noexcept
-      {
- ios_base::_M_swap(__rhs);
- _M_cache_locale(_M_ios_locale);
- __rhs._M_cache_locale(__rhs._M_ios_locale);
- std::swap(_M_tie, __rhs._M_tie);
- std::swap(_M_fill, __rhs._M_fill);
- std::swap(_M_fill_init, __rhs._M_fill_init);
-      }
-
-      void
-      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
-      { _M_streambuf = __sb; }
-
-
-      void
-      _M_cache_locale(const locale& __loc);
-    };
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    void
-    basic_ios<_CharT, _Traits>::clear(iostate __state)
-    {
-      if (this->rdbuf())
- _M_streambuf_state = __state;
-      else
-   _M_streambuf_state = __state | badbit;
-      if (this->exceptions() & this->rdstate())
- __throw_ios_failure(("basic_ios::clear"));
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>*
-    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
-    {
-      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
-      _M_streambuf = __sb;
-      this->clear();
-      return __old;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ios<_CharT, _Traits>&
-    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
-    {
-
-
-      if (this != &__rhs)
- {
-
-
-
-
-   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
-                      _M_local_word : new _Words[__rhs._M_word_size];
-
-
-   _Callback_list* __cb = __rhs._M_callbacks;
-   if (__cb)
-     __cb->_M_add_reference();
-   _M_call_callbacks(erase_event);
-   if (_M_word != _M_local_word)
-     {
-       delete [] _M_word;
-       _M_word = 0;
-     }
-   _M_dispose_callbacks();
-
-
-   _M_callbacks = __cb;
-   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
-     __words[__i] = __rhs._M_word[__i];
-   _M_word = __words;
-   _M_word_size = __rhs._M_word_size;
-
-   this->flags(__rhs.flags());
-   this->width(__rhs.width());
-   this->precision(__rhs.precision());
-   this->tie(__rhs.tie());
-   this->fill(__rhs.fill());
-   _M_ios_locale = __rhs.getloc();
-   _M_cache_locale(_M_ios_locale);
-
-   _M_call_callbacks(copyfmt_event);
-
-
-   this->exceptions(__rhs.exceptions());
- }
-      return *this;
-    }
-
-
-  template<typename _CharT, typename _Traits>
-    locale
-    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
-    {
-      locale __old(this->getloc());
-      ios_base::imbue(__loc);
-      _M_cache_locale(__loc);
-      if (this->rdbuf() != 0)
- this->rdbuf()->pubimbue(__loc);
-      return __old;
-    }
-
-  template<typename _CharT, typename _Traits>
-    void
-    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
-    {
-
-      ios_base::_M_init();
-
-
-      _M_cache_locale(_M_ios_locale);
-# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.tcc" 3
-      _M_fill = _CharT();
-      _M_fill_init = false;
-
-      _M_tie = 0;
-      _M_exception = goodbit;
-      _M_streambuf = __sb;
-      _M_streambuf_state = __sb ? goodbit : badbit;
-    }
-
-  template<typename _CharT, typename _Traits>
-    void
-    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
-    {
-      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
- _M_ctype = &use_facet<__ctype_type>(__loc);
-      else
- _M_ctype = 0;
-
-      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
- _M_num_put = &use_facet<__num_put_type>(__loc);
-      else
- _M_num_put = 0;
-
-      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
- _M_num_get = &use_facet<__num_get_type>(__loc);
-      else
- _M_num_get = 0;
-    }
-
-
-
-
-  extern template class basic_ios<char>;
-
-
-  extern template class basic_ios<wchar_t>;
-
-
-
-
-}
-# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/basic_ios.h" 2 3
-# 45 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ios" 2 3
-# 39 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits>
-    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef typename _Traits::off_type off_type;
-      typedef _Traits traits_type;
-
-
-      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
-      typedef basic_ios<_CharT, _Traits> __ios_type;
-      typedef basic_ostream<_CharT, _Traits> __ostream_type;
-      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
-             __num_put_type;
-      typedef ctype<_CharT> __ctype_type;
-# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      explicit
-      basic_ostream(__streambuf_type* __sb)
-      { this->init(__sb); }
-
-
-
-
-
-
-      virtual
-      ~basic_ostream() { }
-
-
-      class sentry;
-      friend class sentry;
-# 107 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      operator<<(__ostream_type& (*__pf)(__ostream_type&))
-      {
-
-
-
- return __pf(*this);
-      }
-
-      __ostream_type&
-      operator<<(__ios_type& (*__pf)(__ios_type&))
-      {
-
-
-
- __pf(*this);
- return *this;
-      }
-
-      __ostream_type&
-      operator<<(ios_base& (*__pf) (ios_base&))
-      {
-
-
-
- __pf(*this);
- return *this;
-      }
-# 165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      operator<<(long __n)
-      { return _M_insert(__n); }
-
-      __ostream_type&
-      operator<<(unsigned long __n)
-      { return _M_insert(__n); }
-
-      __ostream_type&
-      operator<<(bool __n)
-      { return _M_insert(__n); }
-
-      __ostream_type&
-      operator<<(short __n);
-
-      __ostream_type&
-      operator<<(unsigned short __n)
-      {
-
-
- return _M_insert(static_cast<unsigned long>(__n));
-      }
-
-      __ostream_type&
-      operator<<(int __n);
-
-      __ostream_type&
-      operator<<(unsigned int __n)
-      {
-
-
- return _M_insert(static_cast<unsigned long>(__n));
-      }
-
-
-      __ostream_type&
-      operator<<(long long __n)
-      { return _M_insert(__n); }
-
-      __ostream_type&
-      operator<<(unsigned long long __n)
-      { return _M_insert(__n); }
-# 219 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      operator<<(double __f)
-      { return _M_insert(__f); }
-
-      __ostream_type&
-      operator<<(float __f)
-      {
-
-
- return _M_insert(static_cast<double>(__f));
-      }
-
-      __ostream_type&
-      operator<<(long double __f)
-      { return _M_insert(__f); }
-# 244 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      operator<<(const void* __p)
-      { return _M_insert(__p); }
-# 269 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      operator<<(__streambuf_type* __sb);
-# 302 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      put(char_type __c);
-
-
-
-
-
-
-      void
-      _M_write(const char_type* __s, streamsize __n)
-      {
- const streamsize __put = this->rdbuf()->sputn(__s, __n);
- if (__put != __n)
-   this->setstate(ios_base::badbit);
-      }
-# 334 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      write(const char_type* __s, streamsize __n);
-# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      flush();
-# 357 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      pos_type
-      tellp();
-# 368 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      __ostream_type&
-      seekp(pos_type);
-# 380 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-       __ostream_type&
-      seekp(off_type, ios_base::seekdir);
-
-    protected:
-      basic_ostream()
-      { this->init(0); }
-
-
-
-      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
-
-      basic_ostream(const basic_ostream&) = delete;
-
-      basic_ostream(basic_ostream&& __rhs)
-      : __ios_type()
-      { __ios_type::move(__rhs); }
-
-
-
-      basic_ostream& operator=(const basic_ostream&) = delete;
-
-      basic_ostream&
-      operator=(basic_ostream&& __rhs)
-      {
- swap(__rhs);
- return *this;
-      }
-
-      void
-      swap(basic_ostream& __rhs)
-      { __ios_type::swap(__rhs); }
-
-
-      template<typename _ValueT>
- __ostream_type&
- _M_insert(_ValueT __v);
-    };
-# 425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template <typename _CharT, typename _Traits>
-    class basic_ostream<_CharT, _Traits>::sentry
-    {
-
-      bool _M_ok;
-      basic_ostream<_CharT, _Traits>& _M_os;
-
-    public:
-# 444 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      explicit
-      sentry(basic_ostream<_CharT, _Traits>& __os);
-# 454 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      ~sentry()
-      {
-
- if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
-   {
-
-     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
-       _M_os.setstate(ios_base::badbit);
-   }
-      }
-# 473 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-      explicit
-
-      operator bool() const
-      { return _M_ok; }
-    };
-# 495 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
-    { return __ostream_insert(__out, &__c, 1); }
-
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
-    { return (__out << __out.widen(__c)); }
-
-
-  template <class _Traits>
-    inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, char __c)
-    { return __ostream_insert(__out, &__c, 1); }
-
-
-  template<class _Traits>
-    inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
-    { return (__out << static_cast<char>(__c)); }
-
-  template<class _Traits>
-    inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
-    { return (__out << static_cast<char>(__c)); }
-# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
-    {
-      if (!__s)
- __out.setstate(ios_base::badbit);
-      else
- __ostream_insert(__out, __s,
-    static_cast<streamsize>(_Traits::length(__s)));
-      return __out;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits> &
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
-
-
-  template<class _Traits>
-    inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
-    {
-      if (!__s)
- __out.setstate(ios_base::badbit);
-      else
- __ostream_insert(__out, __s,
-    static_cast<streamsize>(_Traits::length(__s)));
-      return __out;
-    }
-
-
-  template<class _Traits>
-    inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
-    { return (__out << reinterpret_cast<const char*>(__s)); }
-
-  template<class _Traits>
-    inline basic_ostream<char, _Traits> &
-    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
-    { return (__out << reinterpret_cast<const char*>(__s)); }
-# 588 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    endl(basic_ostream<_CharT, _Traits>& __os)
-    { return flush(__os.put(__os.widen('\n'))); }
-# 600 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    ends(basic_ostream<_CharT, _Traits>& __os)
-    { return __os.put(_CharT()); }
-
-
-
-
-
-
-  template<typename _CharT, typename _Traits>
-    inline basic_ostream<_CharT, _Traits>&
-    flush(basic_ostream<_CharT, _Traits>& __os)
-    { return __os.flush(); }
-# 626 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 3
-  template<typename _CharT, typename _Traits, typename _Tp>
-    inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
-    {
-      __os << __x;
-      return __os;
-    }
-
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/ostream.tcc" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>::sentry::
-    sentry(basic_ostream<_CharT, _Traits>& __os)
-    : _M_ok(false), _M_os(__os)
-    {
-
-      if (__os.tie() && __os.good())
- __os.tie()->flush();
-
-      if (__os.good())
- _M_ok = true;
-      else
- __os.setstate(ios_base::failbit);
-    }
-
-  template<typename _CharT, typename _Traits>
-    template<typename _ValueT>
-      basic_ostream<_CharT, _Traits>&
-      basic_ostream<_CharT, _Traits>::
-      _M_insert(_ValueT __v)
-      {
- sentry __cerb(*this);
- if (__cerb)
-   {
-     ios_base::iostate __err = ios_base::goodbit;
-     try
-       {
-  const __num_put_type& __np = __check_facet(this->_M_num_put);
-  if (__np.put(*this, *this, this->fill(), __v).failed())
-    __err |= ios_base::badbit;
-       }
-     catch(__cxxabiv1::__forced_unwind&)
-       {
-  this->_M_setstate(ios_base::badbit);
-  throw;
-       }
-     catch(...)
-       { this->_M_setstate(ios_base::badbit); }
-     if (__err)
-       this->setstate(__err);
-   }
- return *this;
-      }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    operator<<(short __n)
-    {
-
-
-      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
-      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
- return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
-      else
- return _M_insert(static_cast<long>(__n));
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    operator<<(int __n)
-    {
-
-
-      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
-      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
- return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
-      else
- return _M_insert(static_cast<long>(__n));
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    operator<<(__streambuf_type* __sbin)
-    {
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this);
-      if (__cerb && __sbin)
- {
-   try
-     {
-       if (!__copy_streambufs(__sbin, this->rdbuf()))
-  __err |= ios_base::failbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::failbit); }
- }
-      else if (!__sbin)
- __err |= ios_base::badbit;
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    put(char_type __c)
-    {
-
-
-
-
-
-
-      sentry __cerb(*this);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       const int_type __put = this->rdbuf()->sputc(__c);
-       if (traits_type::eq_int_type(__put, traits_type::eof()))
-  __err |= ios_base::badbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    write(const _CharT* __s, streamsize __n)
-    {
-
-
-
-
-
-
-
-      sentry __cerb(*this);
-      if (__cerb)
- {
-   try
-     { _M_write(__s, __n); }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    flush()
-    {
-
-
-
-      ios_base::iostate __err = ios_base::goodbit;
-      try
- {
-   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
-     __err |= ios_base::badbit;
- }
-      catch(__cxxabiv1::__forced_unwind&)
- {
-   this->_M_setstate(ios_base::badbit);
-   throw;
- }
-      catch(...)
- { this->_M_setstate(ios_base::badbit); }
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    typename basic_ostream<_CharT, _Traits>::pos_type
-    basic_ostream<_CharT, _Traits>::
-    tellp()
-    {
-      pos_type __ret = pos_type(-1);
-      try
- {
-   if (!this->fail())
-     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
- }
-      catch(__cxxabiv1::__forced_unwind&)
- {
-   this->_M_setstate(ios_base::badbit);
-   throw;
- }
-      catch(...)
- { this->_M_setstate(ios_base::badbit); }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    seekp(pos_type __pos)
-    {
-      ios_base::iostate __err = ios_base::goodbit;
-      try
- {
-   if (!this->fail())
-     {
-
-
-       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
-            ios_base::out);
-
-
-       if (__p == pos_type(off_type(-1)))
-  __err |= ios_base::failbit;
-     }
- }
-      catch(__cxxabiv1::__forced_unwind&)
- {
-   this->_M_setstate(ios_base::badbit);
-   throw;
- }
-      catch(...)
- { this->_M_setstate(ios_base::badbit); }
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    basic_ostream<_CharT, _Traits>::
-    seekp(off_type __off, ios_base::seekdir __dir)
-    {
-      ios_base::iostate __err = ios_base::goodbit;
-      try
- {
-   if (!this->fail())
-     {
-
-
-       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
-            ios_base::out);
-
-
-       if (__p == pos_type(off_type(-1)))
-  __err |= ios_base::failbit;
-     }
- }
-      catch(__cxxabiv1::__forced_unwind&)
- {
-   this->_M_setstate(ios_base::badbit);
-   throw;
- }
-      catch(...)
- { this->_M_setstate(ios_base::badbit); }
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
-    {
-      if (!__s)
- __out.setstate(ios_base::badbit);
-      else
- {
-
-
-   const size_t __clen = char_traits<char>::length(__s);
-   try
-     {
-       struct __ptr_guard
-       {
-  _CharT *__p;
-  __ptr_guard (_CharT *__ip): __p(__ip) { }
-  ~__ptr_guard() { delete[] __p; }
-  _CharT* __get() { return __p; }
-       } __pg (new _CharT[__clen]);
-
-       _CharT *__ws = __pg.__get();
-       for (size_t __i = 0; __i < __clen; ++__i)
-  __ws[__i] = __out.widen(__s[__i]);
-       __ostream_insert(__out, __ws, __clen);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __out._M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { __out._M_setstate(ios_base::badbit); }
- }
-      return __out;
-    }
-
-
-
-
-  extern template class basic_ostream<char>;
-  extern template ostream& endl(ostream&);
-  extern template ostream& ends(ostream&);
-  extern template ostream& flush(ostream&);
-  extern template ostream& operator<<(ostream&, char);
-  extern template ostream& operator<<(ostream&, unsigned char);
-  extern template ostream& operator<<(ostream&, signed char);
-  extern template ostream& operator<<(ostream&, const char*);
-  extern template ostream& operator<<(ostream&, const unsigned char*);
-  extern template ostream& operator<<(ostream&, const signed char*);
-
-  extern template ostream& ostream::_M_insert(long);
-  extern template ostream& ostream::_M_insert(unsigned long);
-  extern template ostream& ostream::_M_insert(bool);
-
-  extern template ostream& ostream::_M_insert(long long);
-  extern template ostream& ostream::_M_insert(unsigned long long);
-
-  extern template ostream& ostream::_M_insert(double);
-  extern template ostream& ostream::_M_insert(long double);
-  extern template ostream& ostream::_M_insert(const void*);
-
-
-  extern template class basic_ostream<wchar_t>;
-  extern template wostream& endl(wostream&);
-  extern template wostream& ends(wostream&);
-  extern template wostream& flush(wostream&);
-  extern template wostream& operator<<(wostream&, wchar_t);
-  extern template wostream& operator<<(wostream&, char);
-  extern template wostream& operator<<(wostream&, const wchar_t*);
-  extern template wostream& operator<<(wostream&, const char*);
-
-  extern template wostream& wostream::_M_insert(long);
-  extern template wostream& wostream::_M_insert(unsigned long);
-  extern template wostream& wostream::_M_insert(bool);
-
-  extern template wostream& wostream::_M_insert(long long);
-  extern template wostream& wostream::_M_insert(unsigned long long);
-
-  extern template wostream& wostream::_M_insert(double);
-  extern template wostream& wostream::_M_insert(long double);
-  extern template wostream& wostream::_M_insert(const void*);
-
-
-
-
-}
-# 639 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/ostream" 2 3
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 57 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    class basic_istream : virtual public basic_ios<_CharT, _Traits>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef typename _Traits::off_type off_type;
-      typedef _Traits traits_type;
-
-
-      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
-      typedef basic_ios<_CharT, _Traits> __ios_type;
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
-        __num_get_type;
-      typedef ctype<_CharT> __ctype_type;
-
-    protected:
-
-
-
-
-
-      streamsize _M_gcount;
-
-    public:
-
-
-
-
-
-
-
-      explicit
-      basic_istream(__streambuf_type* __sb)
-      : _M_gcount(streamsize(0))
-      { this->init(__sb); }
-
-
-
-
-
-
-      virtual
-      ~basic_istream()
-      { _M_gcount = streamsize(0); }
-
-
-      class sentry;
-      friend class sentry;
-# 119 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      operator>>(__istream_type& (*__pf)(__istream_type&))
-      { return __pf(*this); }
-
-      __istream_type&
-      operator>>(__ios_type& (*__pf)(__ios_type&))
-      {
- __pf(*this);
- return *this;
-      }
-
-      __istream_type&
-      operator>>(ios_base& (*__pf)(ios_base&))
-      {
- __pf(*this);
- return *this;
-      }
-# 167 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      operator>>(bool& __n)
-      { return _M_extract(__n); }
-
-      __istream_type&
-      operator>>(short& __n);
-
-      __istream_type&
-      operator>>(unsigned short& __n)
-      { return _M_extract(__n); }
-
-      __istream_type&
-      operator>>(int& __n);
-
-      __istream_type&
-      operator>>(unsigned int& __n)
-      { return _M_extract(__n); }
-
-      __istream_type&
-      operator>>(long& __n)
-      { return _M_extract(__n); }
-
-      __istream_type&
-      operator>>(unsigned long& __n)
-      { return _M_extract(__n); }
-
-
-      __istream_type&
-      operator>>(long long& __n)
-      { return _M_extract(__n); }
-
-      __istream_type&
-      operator>>(unsigned long long& __n)
-      { return _M_extract(__n); }
-# 213 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      operator>>(float& __f)
-      { return _M_extract(__f); }
-
-      __istream_type&
-      operator>>(double& __f)
-      { return _M_extract(__f); }
-
-      __istream_type&
-      operator>>(long double& __f)
-      { return _M_extract(__f); }
-# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      operator>>(void*& __p)
-      { return _M_extract(__p); }
-# 258 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      operator>>(__streambuf_type* __sb);
-# 268 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      streamsize
-      gcount() const
-      { return _M_gcount; }
-# 301 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      int_type
-      get();
-# 315 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      get(char_type& __c);
-# 342 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      get(char_type* __s, streamsize __n, char_type __delim);
-# 353 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      get(char_type* __s, streamsize __n)
-      { return this->get(__s, __n, this->widen('\n')); }
-# 376 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      get(__streambuf_type& __sb, char_type __delim);
-# 386 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      get(__streambuf_type& __sb)
-      { return this->get(__sb, this->widen('\n')); }
-# 415 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      getline(char_type* __s, streamsize __n, char_type __delim);
-# 426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      getline(char_type* __s, streamsize __n)
-      { return this->getline(__s, __n, this->widen('\n')); }
-# 450 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      ignore(streamsize __n, int_type __delim);
-
-      __istream_type&
-      ignore(streamsize __n);
-
-      __istream_type&
-      ignore();
-# 467 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      int_type
-      peek();
-# 485 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      read(char_type* __s, streamsize __n);
-# 504 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      streamsize
-      readsome(char_type* __s, streamsize __n);
-# 521 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      putback(char_type __c);
-# 537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      unget();
-# 555 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      int
-      sync();
-# 570 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      pos_type
-      tellg();
-# 585 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      seekg(pos_type);
-# 601 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      __istream_type&
-      seekg(off_type, ios_base::seekdir);
-
-
-    protected:
-      basic_istream()
-      : _M_gcount(streamsize(0))
-      { this->init(0); }
-
-
-      basic_istream(const basic_istream&) = delete;
-
-      basic_istream(basic_istream&& __rhs)
-      : __ios_type(), _M_gcount(__rhs._M_gcount)
-      {
- __ios_type::move(__rhs);
- __rhs._M_gcount = 0;
-      }
-
-
-
-      basic_istream& operator=(const basic_istream&) = delete;
-
-      basic_istream&
-      operator=(basic_istream&& __rhs)
-      {
- swap(__rhs);
- return *this;
-      }
-
-      void
-      swap(basic_istream& __rhs)
-      {
- __ios_type::swap(__rhs);
- std::swap(_M_gcount, __rhs._M_gcount);
-      }
-
-
-      template<typename _ValueT>
- __istream_type&
- _M_extract(_ValueT& __v);
-    };
-
-
-  template<>
-    basic_istream<char>&
-    basic_istream<char>::
-    getline(char_type* __s, streamsize __n, char_type __delim);
-
-  template<>
-    basic_istream<char>&
-    basic_istream<char>::
-    ignore(streamsize __n);
-
-  template<>
-    basic_istream<char>&
-    basic_istream<char>::
-    ignore(streamsize __n, int_type __delim);
-
-
-  template<>
-    basic_istream<wchar_t>&
-    basic_istream<wchar_t>::
-    getline(char_type* __s, streamsize __n, char_type __delim);
-
-  template<>
-    basic_istream<wchar_t>&
-    basic_istream<wchar_t>::
-    ignore(streamsize __n);
-
-  template<>
-    basic_istream<wchar_t>&
-    basic_istream<wchar_t>::
-    ignore(streamsize __n, int_type __delim);
-# 685 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    class basic_istream<_CharT, _Traits>::sentry
-    {
-
-      bool _M_ok;
-
-    public:
-
-      typedef _Traits traits_type;
-      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef typename __istream_type::__ctype_type __ctype_type;
-      typedef typename _Traits::int_type __int_type;
-# 721 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      explicit
-      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
-# 732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-      explicit
-
-      operator bool() const
-      { return _M_ok; }
-    };
-# 750 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
-
-  template<class _Traits>
-    inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
-    { return (__in >> reinterpret_cast<char&>(__c)); }
-
-  template<class _Traits>
-    inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
-    { return (__in >> reinterpret_cast<char&>(__c)); }
-# 792 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
-
-
-  template<>
-    basic_istream<char>&
-    operator>>(basic_istream<char>& __in, char* __s);
-
-  template<class _Traits>
-    inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
-    { return (__in >> reinterpret_cast<char*>(__s)); }
-
-  template<class _Traits>
-    inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
-    { return (__in >> reinterpret_cast<char*>(__s)); }
-# 823 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    class basic_iostream
-    : public basic_istream<_CharT, _Traits>,
-      public basic_ostream<_CharT, _Traits>
-    {
-    public:
-
-
-
-      typedef _CharT char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef typename _Traits::off_type off_type;
-      typedef _Traits traits_type;
-
-
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef basic_ostream<_CharT, _Traits> __ostream_type;
-
-
-
-
-
-
-
-      explicit
-      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
-      : __istream_type(__sb), __ostream_type(__sb) { }
-
-
-
-
-      virtual
-      ~basic_iostream() { }
-
-    protected:
-      basic_iostream()
-      : __istream_type(), __ostream_type() { }
-
-
-      basic_iostream(const basic_iostream&) = delete;
-
-      basic_iostream(basic_iostream&& __rhs)
-      : __istream_type(std::move(__rhs)), __ostream_type(*this)
-      { }
-
-
-
-      basic_iostream& operator=(const basic_iostream&) = delete;
-
-      basic_iostream&
-      operator=(basic_iostream&& __rhs)
-      {
- swap(__rhs);
- return *this;
-      }
-
-      void
-      swap(basic_iostream& __rhs)
-      { __istream_type::swap(__rhs); }
-
-    };
-# 906 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    ws(basic_istream<_CharT, _Traits>& __is);
-# 922 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 3
-  template<typename _CharT, typename _Traits, typename _Tp>
-    inline basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
-    {
-      __is >> __x;
-      return __is;
-    }
-
-
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>::sentry::
-    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
-    {
-      ios_base::iostate __err = ios_base::goodbit;
-      if (__in.good())
- {
-   if (__in.tie())
-     __in.tie()->flush();
-   if (!__noskip && bool(__in.flags() & ios_base::skipws))
-     {
-       const __int_type __eof = traits_type::eof();
-       __streambuf_type* __sb = __in.rdbuf();
-       __int_type __c = __sb->sgetc();
-
-       const __ctype_type& __ct = __check_facet(__in._M_ctype);
-       while (!traits_type::eq_int_type(__c, __eof)
-       && __ct.is(ctype_base::space,
-    traits_type::to_char_type(__c)))
-  __c = __sb->snextc();
-
-
-
-
-       if (traits_type::eq_int_type(__c, __eof))
-  __err |= ios_base::eofbit;
-     }
- }
-
-      if (__in.good() && __err == ios_base::goodbit)
- _M_ok = true;
-      else
- {
-   __err |= ios_base::failbit;
-   __in.setstate(__err);
- }
-    }
-
-  template<typename _CharT, typename _Traits>
-    template<typename _ValueT>
-      basic_istream<_CharT, _Traits>&
-      basic_istream<_CharT, _Traits>::
-      _M_extract(_ValueT& __v)
-      {
- sentry __cerb(*this, false);
- if (__cerb)
-   {
-     ios_base::iostate __err = ios_base::goodbit;
-     try
-       {
-  const __num_get_type& __ng = __check_facet(this->_M_num_get);
-  __ng.get(*this, 0, *this, __err, __v);
-       }
-     catch(__cxxabiv1::__forced_unwind&)
-       {
-  this->_M_setstate(ios_base::badbit);
-  throw;
-       }
-     catch(...)
-       { this->_M_setstate(ios_base::badbit); }
-     if (__err)
-       this->setstate(__err);
-   }
- return *this;
-      }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    operator>>(short& __n)
-    {
-
-
-      sentry __cerb(*this, false);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       long __l;
-       const __num_get_type& __ng = __check_facet(this->_M_num_get);
-       __ng.get(*this, 0, *this, __err, __l);
-
-
-
-       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
-  {
-    __err |= ios_base::failbit;
-    __n = __gnu_cxx::__numeric_traits<short>::__min;
-  }
-       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
-  {
-    __err |= ios_base::failbit;
-    __n = __gnu_cxx::__numeric_traits<short>::__max;
-  }
-       else
-  __n = short(__l);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    operator>>(int& __n)
-    {
-
-
-      sentry __cerb(*this, false);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       long __l;
-       const __num_get_type& __ng = __check_facet(this->_M_num_get);
-       __ng.get(*this, 0, *this, __err, __l);
-
-
-
-       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
-  {
-    __err |= ios_base::failbit;
-    __n = __gnu_cxx::__numeric_traits<int>::__min;
-  }
-       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
-  {
-    __err |= ios_base::failbit;
-    __n = __gnu_cxx::__numeric_traits<int>::__max;
-  }
-       else
-  __n = int(__l);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    operator>>(__streambuf_type* __sbout)
-    {
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, false);
-      if (__cerb && __sbout)
- {
-   try
-     {
-       bool __ineof;
-       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
-  __err |= ios_base::failbit;
-       if (__ineof)
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::failbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::failbit); }
- }
-      else if (!__sbout)
- __err |= ios_base::failbit;
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    typename basic_istream<_CharT, _Traits>::int_type
-    basic_istream<_CharT, _Traits>::
-    get(void)
-    {
-      const int_type __eof = traits_type::eof();
-      int_type __c = __eof;
-      _M_gcount = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   try
-     {
-       __c = this->rdbuf()->sbumpc();
-
-       if (!traits_type::eq_int_type(__c, __eof))
-  _M_gcount = 1;
-       else
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-      if (!_M_gcount)
- __err |= ios_base::failbit;
-      if (__err)
- this->setstate(__err);
-      return __c;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    get(char_type& __c)
-    {
-      _M_gcount = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   try
-     {
-       const int_type __cb = this->rdbuf()->sbumpc();
-
-       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
-  {
-    _M_gcount = 1;
-    __c = traits_type::to_char_type(__cb);
-  }
-       else
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-      if (!_M_gcount)
- __err |= ios_base::failbit;
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    get(char_type* __s, streamsize __n, char_type __delim)
-    {
-      _M_gcount = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   try
-     {
-       const int_type __idelim = traits_type::to_int_type(__delim);
-       const int_type __eof = traits_type::eof();
-       __streambuf_type* __sb = this->rdbuf();
-       int_type __c = __sb->sgetc();
-
-       while (_M_gcount + 1 < __n
-       && !traits_type::eq_int_type(__c, __eof)
-       && !traits_type::eq_int_type(__c, __idelim))
-  {
-    *__s++ = traits_type::to_char_type(__c);
-    ++_M_gcount;
-    __c = __sb->snextc();
-  }
-       if (traits_type::eq_int_type(__c, __eof))
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-
-
-      if (__n > 0)
- *__s = char_type();
-      if (!_M_gcount)
- __err |= ios_base::failbit;
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    get(__streambuf_type& __sb, char_type __delim)
-    {
-      _M_gcount = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   try
-     {
-       const int_type __idelim = traits_type::to_int_type(__delim);
-       const int_type __eof = traits_type::eof();
-       __streambuf_type* __this_sb = this->rdbuf();
-       int_type __c = __this_sb->sgetc();
-       char_type __c2 = traits_type::to_char_type(__c);
-
-       while (!traits_type::eq_int_type(__c, __eof)
-       && !traits_type::eq_int_type(__c, __idelim)
-       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
-  {
-    ++_M_gcount;
-    __c = __this_sb->snextc();
-    __c2 = traits_type::to_char_type(__c);
-  }
-       if (traits_type::eq_int_type(__c, __eof))
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-      if (!_M_gcount)
- __err |= ios_base::failbit;
-      if (__err)
- this->setstate(__err);
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    getline(char_type* __s, streamsize __n, char_type __delim)
-    {
-      _M_gcount = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      sentry __cerb(*this, true);
-      if (__cerb)
-        {
-          try
-            {
-              const int_type __idelim = traits_type::to_int_type(__delim);
-              const int_type __eof = traits_type::eof();
-              __streambuf_type* __sb = this->rdbuf();
-              int_type __c = __sb->sgetc();
-
-              while (_M_gcount + 1 < __n
-                     && !traits_type::eq_int_type(__c, __eof)
-                     && !traits_type::eq_int_type(__c, __idelim))
-                {
-                  *__s++ = traits_type::to_char_type(__c);
-                  __c = __sb->snextc();
-                  ++_M_gcount;
-                }
-              if (traits_type::eq_int_type(__c, __eof))
-                __err |= ios_base::eofbit;
-              else
-                {
-                  if (traits_type::eq_int_type(__c, __idelim))
-                    {
-                      __sb->sbumpc();
-                      ++_M_gcount;
-                    }
-                  else
-                    __err |= ios_base::failbit;
-                }
-            }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-          catch(...)
-            { this->_M_setstate(ios_base::badbit); }
-        }
-
-
-      if (__n > 0)
- *__s = char_type();
-      if (!_M_gcount)
-        __err |= ios_base::failbit;
-      if (__err)
-        this->setstate(__err);
-      return *this;
-    }
-
-
-
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    ignore(void)
-    {
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       const int_type __eof = traits_type::eof();
-       __streambuf_type* __sb = this->rdbuf();
-
-       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
-  __err |= ios_base::eofbit;
-       else
-  _M_gcount = 1;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    ignore(streamsize __n)
-    {
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb && __n > 0)
-        {
-          ios_base::iostate __err = ios_base::goodbit;
-          try
-            {
-              const int_type __eof = traits_type::eof();
-              __streambuf_type* __sb = this->rdbuf();
-              int_type __c = __sb->sgetc();
-# 513 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/istream.tcc" 3
-       bool __large_ignore = false;
-       while (true)
-  {
-    while (_M_gcount < __n
-    && !traits_type::eq_int_type(__c, __eof))
-      {
-        ++_M_gcount;
-        __c = __sb->snextc();
-      }
-    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
-        && !traits_type::eq_int_type(__c, __eof))
-      {
-        _M_gcount =
-   __gnu_cxx::__numeric_traits<streamsize>::__min;
-        __large_ignore = true;
-      }
-    else
-      break;
-  }
-
-       if (__large_ignore)
-  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
-
-       if (traits_type::eq_int_type(__c, __eof))
-                __err |= ios_base::eofbit;
-            }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-          catch(...)
-            { this->_M_setstate(ios_base::badbit); }
-          if (__err)
-            this->setstate(__err);
-        }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    ignore(streamsize __n, int_type __delim)
-    {
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb && __n > 0)
-        {
-          ios_base::iostate __err = ios_base::goodbit;
-          try
-            {
-              const int_type __eof = traits_type::eof();
-              __streambuf_type* __sb = this->rdbuf();
-              int_type __c = __sb->sgetc();
-
-
-       bool __large_ignore = false;
-       while (true)
-  {
-    while (_M_gcount < __n
-    && !traits_type::eq_int_type(__c, __eof)
-    && !traits_type::eq_int_type(__c, __delim))
-      {
-        ++_M_gcount;
-        __c = __sb->snextc();
-      }
-    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
-        && !traits_type::eq_int_type(__c, __eof)
-        && !traits_type::eq_int_type(__c, __delim))
-      {
-        _M_gcount =
-   __gnu_cxx::__numeric_traits<streamsize>::__min;
-        __large_ignore = true;
-      }
-    else
-      break;
-  }
-
-       if (__large_ignore)
-  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
-
-              if (traits_type::eq_int_type(__c, __eof))
-                __err |= ios_base::eofbit;
-       else if (traits_type::eq_int_type(__c, __delim))
-  {
-    if (_M_gcount
-        < __gnu_cxx::__numeric_traits<streamsize>::__max)
-      ++_M_gcount;
-    __sb->sbumpc();
-  }
-            }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-          catch(...)
-            { this->_M_setstate(ios_base::badbit); }
-          if (__err)
-            this->setstate(__err);
-        }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    typename basic_istream<_CharT, _Traits>::int_type
-    basic_istream<_CharT, _Traits>::
-    peek(void)
-    {
-      int_type __c = traits_type::eof();
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       __c = this->rdbuf()->sgetc();
-       if (traits_type::eq_int_type(__c, traits_type::eof()))
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return __c;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    read(char_type* __s, streamsize __n)
-    {
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       _M_gcount = this->rdbuf()->sgetn(__s, __n);
-       if (_M_gcount != __n)
-  __err |= (ios_base::eofbit | ios_base::failbit);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    streamsize
-    basic_istream<_CharT, _Traits>::
-    readsome(char_type* __s, streamsize __n)
-    {
-      _M_gcount = 0;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-
-       const streamsize __num = this->rdbuf()->in_avail();
-       if (__num > 0)
-  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
-       else if (__num == -1)
-  __err |= ios_base::eofbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return _M_gcount;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    putback(char_type __c)
-    {
-
-
-      _M_gcount = 0;
-
-      this->clear(this->rdstate() & ~ios_base::eofbit);
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       const int_type __eof = traits_type::eof();
-       __streambuf_type* __sb = this->rdbuf();
-       if (!__sb
-    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
-  __err |= ios_base::badbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    unget(void)
-    {
-
-
-      _M_gcount = 0;
-
-      this->clear(this->rdstate() & ~ios_base::eofbit);
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       const int_type __eof = traits_type::eof();
-       __streambuf_type* __sb = this->rdbuf();
-       if (!__sb
-    || traits_type::eq_int_type(__sb->sungetc(), __eof))
-  __err |= ios_base::badbit;
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    int
-    basic_istream<_CharT, _Traits>::
-    sync(void)
-    {
-
-
-      int __ret = -1;
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       __streambuf_type* __sb = this->rdbuf();
-       if (__sb)
-  {
-    if (__sb->pubsync() == -1)
-      __err |= ios_base::badbit;
-    else
-      __ret = 0;
-  }
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    typename basic_istream<_CharT, _Traits>::pos_type
-    basic_istream<_CharT, _Traits>::
-    tellg(void)
-    {
-
-
-      pos_type __ret = pos_type(-1);
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   try
-     {
-       if (!this->fail())
-  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
-        ios_base::in);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
- }
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    seekg(pos_type __pos)
-    {
-
-
-
-      this->clear(this->rdstate() & ~ios_base::eofbit);
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       if (!this->fail())
-  {
-
-    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
-         ios_base::in);
-
-
-    if (__p == pos_type(off_type(-1)))
-      __err |= ios_base::failbit;
-  }
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    basic_istream<_CharT, _Traits>::
-    seekg(off_type __off, ios_base::seekdir __dir)
-    {
-
-
-
-      this->clear(this->rdstate() & ~ios_base::eofbit);
-      sentry __cerb(*this, true);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       if (!this->fail())
-  {
-
-    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
-         ios_base::in);
-
-
-    if (__p == pos_type(off_type(-1)))
-      __err |= ios_base::failbit;
-  }
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       this->_M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { this->_M_setstate(ios_base::badbit); }
-   if (__err)
-     this->setstate(__err);
- }
-      return *this;
-    }
-
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
-    {
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef typename __istream_type::int_type __int_type;
-
-      typename __istream_type::sentry __cerb(__in, false);
-      if (__cerb)
- {
-   ios_base::iostate __err = ios_base::goodbit;
-   try
-     {
-       const __int_type __cb = __in.rdbuf()->sbumpc();
-       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
-  __c = _Traits::to_char_type(__cb);
-       else
-  __err |= (ios_base::eofbit | ios_base::failbit);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __in._M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { __in._M_setstate(ios_base::badbit); }
-   if (__err)
-     __in.setstate(__err);
- }
-      return __in;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
-    {
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
-      typedef typename _Traits::int_type int_type;
-      typedef _CharT char_type;
-      typedef ctype<_CharT> __ctype_type;
-
-      streamsize __extracted = 0;
-      ios_base::iostate __err = ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, false);
-      if (__cerb)
- {
-   try
-     {
-
-       streamsize __num = __in.width();
-       if (__num <= 0)
-  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
-
-       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
-
-       const int_type __eof = _Traits::eof();
-       __streambuf_type* __sb = __in.rdbuf();
-       int_type __c = __sb->sgetc();
-
-       while (__extracted < __num - 1
-       && !_Traits::eq_int_type(__c, __eof)
-       && !__ct.is(ctype_base::space,
-     _Traits::to_char_type(__c)))
-  {
-    *__s++ = _Traits::to_char_type(__c);
-    ++__extracted;
-    __c = __sb->snextc();
-  }
-       if (_Traits::eq_int_type(__c, __eof))
-  __err |= ios_base::eofbit;
-
-
-
-       *__s = char_type();
-       __in.width(0);
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __in._M_setstate(ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { __in._M_setstate(ios_base::badbit); }
- }
-      if (!__extracted)
- __err |= ios_base::failbit;
-      if (__err)
- __in.setstate(__err);
-      return __in;
-    }
-
-
-  template<typename _CharT, typename _Traits>
-    basic_istream<_CharT, _Traits>&
-    ws(basic_istream<_CharT, _Traits>& __in)
-    {
-      typedef basic_istream<_CharT, _Traits> __istream_type;
-      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
-      typedef typename __istream_type::int_type __int_type;
-      typedef ctype<_CharT> __ctype_type;
-
-      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
-      const __int_type __eof = _Traits::eof();
-      __streambuf_type* __sb = __in.rdbuf();
-      __int_type __c = __sb->sgetc();
-
-      while (!_Traits::eq_int_type(__c, __eof)
-      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
- __c = __sb->snextc();
-
-       if (_Traits::eq_int_type(__c, __eof))
-  __in.setstate(ios_base::eofbit);
-      return __in;
-    }
-
-
-
-
-  extern template class basic_istream<char>;
-  extern template istream& ws(istream&);
-  extern template istream& operator>>(istream&, char&);
-  extern template istream& operator>>(istream&, char*);
-  extern template istream& operator>>(istream&, unsigned char&);
-  extern template istream& operator>>(istream&, signed char&);
-  extern template istream& operator>>(istream&, unsigned char*);
-  extern template istream& operator>>(istream&, signed char*);
-
-  extern template istream& istream::_M_extract(unsigned short&);
-  extern template istream& istream::_M_extract(unsigned int&);
-  extern template istream& istream::_M_extract(long&);
-  extern template istream& istream::_M_extract(unsigned long&);
-  extern template istream& istream::_M_extract(bool&);
-
-  extern template istream& istream::_M_extract(long long&);
-  extern template istream& istream::_M_extract(unsigned long long&);
-
-  extern template istream& istream::_M_extract(float&);
-  extern template istream& istream::_M_extract(double&);
-  extern template istream& istream::_M_extract(long double&);
-  extern template istream& istream::_M_extract(void*&);
-
-  extern template class basic_iostream<char>;
-
-
-  extern template class basic_istream<wchar_t>;
-  extern template wistream& ws(wistream&);
-  extern template wistream& operator>>(wistream&, wchar_t&);
-  extern template wistream& operator>>(wistream&, wchar_t*);
-
-  extern template wistream& wistream::_M_extract(unsigned short&);
-  extern template wistream& wistream::_M_extract(unsigned int&);
-  extern template wistream& wistream::_M_extract(long&);
-  extern template wistream& wistream::_M_extract(unsigned long&);
-  extern template wistream& wistream::_M_extract(bool&);
-
-  extern template wistream& wistream::_M_extract(long long&);
-  extern template wistream& wistream::_M_extract(unsigned long long&);
-
-  extern template wistream& wistream::_M_extract(float&);
-  extern template wistream& wistream::_M_extract(double&);
-  extern template wistream& wistream::_M_extract(long double&);
-  extern template wistream& wistream::_M_extract(void*&);
-
-  extern template class basic_iostream<wchar_t>;
-
-
-
-
-}
-# 935 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/istream" 2 3
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
-  template<typename _Tp, typename _CharT = char,
-           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
-    class istream_iterator
-    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
-    {
-    public:
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-      typedef basic_istream<_CharT, _Traits> istream_type;
-
-    private:
-      istream_type* _M_stream;
-      _Tp _M_value;
-      bool _M_ok;
-
-    public:
-
-      constexpr istream_iterator()
-      : _M_stream(0), _M_value(), _M_ok(false) {}
-
-
-      istream_iterator(istream_type& __s)
-      : _M_stream(&__s)
-      { _M_read(); }
-
-      istream_iterator(const istream_iterator& __obj)
-      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
-        _M_ok(__obj._M_ok)
-      { }
-
-      const _Tp&
-      operator*() const
-      {
-
-
-                        ;
- return _M_value;
-      }
-
-      const _Tp*
-      operator->() const { return &(operator*()); }
-
-      istream_iterator&
-      operator++()
-      {
-
-
-                        ;
- _M_read();
- return *this;
-      }
-
-      istream_iterator
-      operator++(int)
-      {
-
-
-                        ;
- istream_iterator __tmp = *this;
- _M_read();
- return __tmp;
-      }
-
-      bool
-      _M_equal(const istream_iterator& __x) const
-      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
-
-    private:
-      void
-      _M_read()
-      {
- _M_ok = (_M_stream && *_M_stream) ? true : false;
- if (_M_ok)
-   {
-     *_M_stream >> _M_value;
-     _M_ok = *_M_stream ? true : false;
-   }
-      }
-    };
-
-
-  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
-    inline bool
-    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
-        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
-    { return __x._M_equal(__y); }
-
-
-  template <class _Tp, class _CharT, class _Traits, class _Dist>
-    inline bool
-    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
-        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
-    { return !__x._M_equal(__y); }
-# 152 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
-  template<typename _Tp, typename _CharT = char,
-           typename _Traits = char_traits<_CharT> >
-    class ostream_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    public:
-
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-      typedef basic_ostream<_CharT, _Traits> ostream_type;
-
-
-    private:
-      ostream_type* _M_stream;
-      const _CharT* _M_string;
-
-    public:
-
-      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
-# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stream_iterator.h" 3
-      ostream_iterator(ostream_type& __s, const _CharT* __c)
-      : _M_stream(&__s), _M_string(__c) { }
-
-
-      ostream_iterator(const ostream_iterator& __obj)
-      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
-
-
-
-      ostream_iterator&
-      operator=(const _Tp& __value)
-      {
-
-
-                        ;
- *_M_stream << __value;
- if (_M_string) *_M_stream << _M_string;
- return *this;
-      }
-
-      ostream_iterator&
-      operator*()
-      { return *this; }
-
-      ostream_iterator&
-      operator++()
-      { return *this; }
-
-      ostream_iterator&
-      operator++(int)
-      { return *this; }
-    };
-
-
-
-
-}
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/iterator" 2 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h" 2
-
-
-
-namespace mozilla {
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayIterator.h"
-template<class Element, class ArrayType>
-class ArrayIterator
-{
-public:
-  typedef ArrayType array_type;
-  typedef ArrayIterator<Element, ArrayType> iterator_type;
-  typedef typename array_type::index_type index_type;
-  typedef typename RemoveReference<Element>::Type value_type;
-  typedef ptrdiff_t difference_type;
-  typedef value_type* pointer;
-  typedef value_type& reference;
-  typedef std::random_access_iterator_tag iterator_category;
-
-private:
-  const array_type* mArray;
-  index_type mIndex;
-
-public:
-  ArrayIterator() : mArray(nullptr), mIndex(0) {}
-  ArrayIterator(const iterator_type& aOther)
-    : mArray(aOther.mArray), mIndex(aOther.mIndex) {}
-  ArrayIterator(const array_type& aArray, index_type aIndex)
-    : mArray(&aArray), mIndex(aIndex) {}
-
-  iterator_type& operator=(const iterator_type& aOther) {
-    mArray = aOther.mArray;
-    mIndex = aOther.mIndex;
-    return *this;
-  }
-
-  bool operator==(const iterator_type& aRhs) const {
-    return mIndex == aRhs.mIndex;
-  }
-  bool operator!=(const iterator_type& aRhs) const {
-    return !(*this == aRhs);
-  }
-  bool operator<(const iterator_type& aRhs) const {
-    return mIndex < aRhs.mIndex;
-  }
-  bool operator>(const iterator_type& aRhs) const {
-    return mIndex > aRhs.mIndex;
-  }
-  bool operator<=(const iterator_type& aRhs) const {
-    return mIndex <= aRhs.mIndex;
-  }
-  bool operator>=(const iterator_type& aRhs) const {
-    return mIndex >= aRhs.mIndex;
-  }
-
-
-
-  value_type* operator->() const {
-    return const_cast<value_type*>(&mArray->ElementAt(mIndex));
-  }
-  Element operator*() const {
-    return const_cast<Element>(mArray->ElementAt(mIndex));
-  }
-
-  iterator_type& operator++() {
-    ++mIndex;
-    return *this;
-  }
-  iterator_type operator++(int) {
-    iterator_type it = *this;
-    ++*this;
-    return it;
-  }
-  iterator_type& operator--() {
-    --mIndex;
-    return *this;
-  }
-  iterator_type operator--(int) {
-    iterator_type it = *this;
-    --*this;
-    return it;
-  }
-
-  iterator_type& operator+=(difference_type aDiff) {
-    mIndex += aDiff;
-    return *this;
-  }
-  iterator_type& operator-=(difference_type aDiff) {
-    mIndex -= aDiff;
-    return *this;
-  }
-
-  iterator_type operator+(difference_type aDiff) const {
-    iterator_type it = *this;
-    it += aDiff;
-    return it;
-  }
-  iterator_type operator-(difference_type aDiff) const {
-    iterator_type it = *this;
-    it -= aDiff;
-    return it;
-  }
-
-  difference_type operator-(const iterator_type& aOther) const {
-    return static_cast<difference_type>(mIndex) -
-      static_cast<difference_type>(aOther.mIndex);
-  }
-
-  Element operator[](difference_type aIndex) const {
-    return *this->operator+(aIndex);
-  }
-};
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h" 2
-
-namespace mozilla {
-# 66 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BinarySearch.h"
-template<typename Container, typename Comparator>
-bool
-BinarySearchIf(const Container& aContainer, size_t aBegin, size_t aEnd,
-               const Comparator& aCompare, size_t* aMatchOrInsertionPoint)
-{
-  do { } while (0);
-
-  size_t low = aBegin;
-  size_t high = aEnd;
-  while (high != low) {
-    size_t middle = low + (high - low) / 2;
-
-
-
-    const int result = aCompare(aContainer[middle]);
-
-    if (result == 0) {
-      *aMatchOrInsertionPoint = middle;
-      return true;
-    }
-
-    if (result < 0) {
-      high = middle;
-    } else {
-      low = middle + 1;
-    }
-  }
-
-  *aMatchOrInsertionPoint = low;
-  return false;
-}
-
-namespace detail {
-
-template<class T>
-class BinarySearchDefaultComparator
-{
-public:
-  explicit BinarySearchDefaultComparator(const T& aTarget)
-    : mTarget(aTarget)
-  {}
-
-  template <class U>
-  int operator()(const U& aVal) const {
-    if (mTarget == aVal) {
-      return 0;
-    }
-
-    if (mTarget < aVal) {
-      return -1;
-    }
-
-    return 1;
-  }
-
-private:
-  const T& mTarget;
-};
-
-}
-
-template <typename Container, typename T>
-bool
-BinarySearch(const Container& aContainer, size_t aBegin, size_t aEnd,
-             T aTarget, size_t* aMatchOrInsertionPoint)
-{
-  return BinarySearchIf(aContainer, aBegin, aEnd,
-                        detail::BinarySearchDefaultComparator<T>(aTarget),
-                        aMatchOrInsertionPoint);
-}
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-
-
-
-
-
-# 1 "/usr/include/math.h" 1 3 4
-# 28 "/usr/include/math.h" 3 4
-extern "C" {
-
-
-
-# 1 "/usr/include/bits/math-vector.h" 1 3 4
-# 25 "/usr/include/bits/math-vector.h" 3 4
-# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
-# 26 "/usr/include/bits/math-vector.h" 2 3 4
-# 32 "/usr/include/math.h" 2 3 4
-
-
-
-# 1 "/usr/include/bits/huge_val.h" 1 3 4
-# 36 "/usr/include/math.h" 2 3 4
-
-# 1 "/usr/include/bits/huge_valf.h" 1 3 4
-# 38 "/usr/include/math.h" 2 3 4
-# 1 "/usr/include/bits/huge_vall.h" 1 3 4
-# 39 "/usr/include/math.h" 2 3 4
-
-
-# 1 "/usr/include/bits/inf.h" 1 3 4
-# 42 "/usr/include/math.h" 2 3 4
-
-
-# 1 "/usr/include/bits/nan.h" 1 3 4
-# 45 "/usr/include/math.h" 2 3 4
-
-
-
-# 1 "/usr/include/bits/mathdef.h" 1 3 4
-# 28 "/usr/include/bits/mathdef.h" 3 4
-typedef float float_t;
-typedef double double_t;
-# 49 "/usr/include/math.h" 2 3 4
-# 83 "/usr/include/math.h" 3 4
-# 1 "/usr/include/bits/mathcalls.h" 1 3 4
-# 54 "/usr/include/bits/mathcalls.h" 3 4
-extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
-
-extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
-
-extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
-
-extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
-
-
- extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
-
- extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
-
-extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
-
-
-
-
-extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
-
-extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
-
-extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
-
-
-
-
- extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
-
-
-
-
-
-
-extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
-
-extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
-
-extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
-
-
-
-
-
-
-
- extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
-
-
-extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
-
-
-extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
-
-
- extern double log (double __x) throw (); extern double __log (double __x) throw ();
-
-
-extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
-
-
-extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
-
-extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
-
-
-
-
-
-extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
-
-
-extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
-
-
-extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
-
-
-
-
-
-
-extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
-
-
-extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
-# 153 "/usr/include/bits/mathcalls.h" 3 4
- extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
-
-
-extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
-
-
-
-
-
-extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
-
-
-
-
-
-
-extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
-# 178 "/usr/include/bits/mathcalls.h" 3 4
-extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
-
-
-extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
-
-
-extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
-
-
-extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
-
-
-
-
-extern int __isinf (double __value) throw () __attribute__ ((__const__));
-
-
-extern int __finite (double __value) throw () __attribute__ ((__const__));
-# 208 "/usr/include/bits/mathcalls.h" 3 4
-extern int finite (double __value) throw () __attribute__ ((__const__));
-
-
-extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
-
-
-
-extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
-
-
-
-
-
-extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
-
-
-
-
-
-
-extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
-
-
-
-
-
-extern int __isnan (double __value) throw () __attribute__ ((__const__));
-# 247 "/usr/include/bits/mathcalls.h" 3 4
-extern double j0 (double) throw (); extern double __j0 (double) throw ();
-extern double j1 (double) throw (); extern double __j1 (double) throw ();
-extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
-extern double y0 (double) throw (); extern double __y0 (double) throw ();
-extern double y1 (double) throw (); extern double __y1 (double) throw ();
-extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
-
-
-
-
-
-
-extern double erf (double) throw (); extern double __erf (double) throw ();
-extern double erfc (double) throw (); extern double __erfc (double) throw ();
-extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
-
-
-
-
-
-
-extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
-
-
-
-
-
-extern double gamma (double) throw (); extern double __gamma (double) throw ();
-
-
-
-
-
-
-extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
-
-
-
-
-
-
-
-extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
-
-
-extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
-
-extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
-
-
-
-
-extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
-
-extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
-
-
-
-extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
-
-
-
-extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
-
-
-
-extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
-
-
-
-
-extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
-
-
-
-extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
-
-
-
-extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
-
-
-
-extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
-
-
-
-
-extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
-
-
-
-
-
-
-extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
-__extension__
-extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
-
-
-
-extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
-__extension__
-extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
-
-
-
-extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
-
-
-extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
-
-
-extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
-
-
-
-extern int __fpclassify (double __value) throw ()
-     __attribute__ ((__const__));
-
-
-extern int __signbit (double __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
-# 382 "/usr/include/bits/mathcalls.h" 3 4
-extern int __issignaling (double __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-
-
-
-extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
-# 84 "/usr/include/math.h" 2 3 4
-# 104 "/usr/include/math.h" 3 4
-# 1 "/usr/include/bits/mathcalls.h" 1 3 4
-# 54 "/usr/include/bits/mathcalls.h" 3 4
-extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
-
-extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
-
-extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
-
-extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
-
-
- extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
-
- extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
-
-extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
-
-
-
-
-extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
-
-extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
-
-extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
-
-
-
-
- extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
-
-
-
-
-
-
-extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
-
-extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
-
-extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
-
-
-
-
-
-
-
- extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
-
-
-extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
-
-
-extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
-
-
- extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
-
-
-extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
-
-
-extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
-
-extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
-
-
-
-
-
-extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
-
-
-extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
-
-
-extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
-
-
-
-
-
-
-extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
-
-
-extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
-# 153 "/usr/include/bits/mathcalls.h" 3 4
- extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
-
-
-extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
-
-
-
-
-
-extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
-
-
-
-
-
-
-extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
-# 178 "/usr/include/bits/mathcalls.h" 3 4
-extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
-
-
-extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
-
-
-extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
-
-
-extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
-
-
-
-
-extern int __isinff (float __value) throw () __attribute__ ((__const__));
-
-
-extern int __finitef (float __value) throw () __attribute__ ((__const__));
-# 204 "/usr/include/bits/mathcalls.h" 3 4
-extern int isinff (float __value) throw () __attribute__ ((__const__));
-
-
-
-extern int finitef (float __value) throw () __attribute__ ((__const__));
-
-
-extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
-
-
-
-extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
-
-
-
-
-
-extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
-
-
-
-
-
-
-extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
-
-
-
-
-
-extern int __isnanf (float __value) throw () __attribute__ ((__const__));
-
-
-
-
-
-
-extern int isnanf (float __value) throw () __attribute__ ((__const__));
-
-
-
-
-
-extern float j0f (float) throw (); extern float __j0f (float) throw ();
-extern float j1f (float) throw (); extern float __j1f (float) throw ();
-extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
-extern float y0f (float) throw (); extern float __y0f (float) throw ();
-extern float y1f (float) throw (); extern float __y1f (float) throw ();
-extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
-
-
-
-
-
-
-extern float erff (float) throw (); extern float __erff (float) throw ();
-extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
-extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
-
-
-
-
-
-
-extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
-
-
-
-
-
-extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
-
-
-
-
-
-
-extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
-
-
-
-
-
-
-
-extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
-
-
-extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
-
-extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
-
-
-
-
-extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
-
-extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
-
-
-
-extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
-
-
-
-extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
-
-
-
-extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
-
-
-
-
-extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
-
-
-
-extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
-
-
-
-extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
-
-
-
-extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
-
-
-
-
-extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
-
-
-
-
-
-
-extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
-__extension__
-extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
-
-
-
-extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
-__extension__
-extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
-
-
-
-extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
-
-
-extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
-
-
-extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
-
-
-
-extern int __fpclassifyf (float __value) throw ()
-     __attribute__ ((__const__));
-
-
-extern int __signbitf (float __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
-# 382 "/usr/include/bits/mathcalls.h" 3 4
-extern int __issignalingf (float __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-
-
-
-extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
-# 105 "/usr/include/math.h" 2 3 4
-# 151 "/usr/include/math.h" 3 4
-# 1 "/usr/include/bits/mathcalls.h" 1 3 4
-# 54 "/usr/include/bits/mathcalls.h" 3 4
-extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
-
-extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
-
-extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
-
-extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
-
-
- extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
-
- extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
-
-extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
-
-
-
-
-extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
-
-extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
-
-extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
-
-
-
-
- extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
-
-
-
-
-
-
-extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
-
-extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
-
-extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
-
-
-
-
-
-
-
- extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
-
-
-extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
-
-
-extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
-
-
- extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
-
-
-extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
-
-
-extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
-
-
-
-
-extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
-
-extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
-
-
-
-
-
-extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
-
-
-extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
-
-
-extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
-
-
-
-
-
-
-extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
-
-
-extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
-# 153 "/usr/include/bits/mathcalls.h" 3 4
- extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
-
-
-extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
-
-
-
-
-
-extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
-
-
-
-
-
-
-extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
-# 178 "/usr/include/bits/mathcalls.h" 3 4
-extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
-
-
-extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
-
-
-extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
-
-
-extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
-
-
-
-
-extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
-
-
-extern int __finitel (long double __value) throw () __attribute__ ((__const__));
-# 204 "/usr/include/bits/mathcalls.h" 3 4
-extern int isinfl (long double __value) throw () __attribute__ ((__const__));
-
-
-
-extern int finitel (long double __value) throw () __attribute__ ((__const__));
-
-
-extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
-
-
-
-extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
-
-
-
-
-
-extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
-
-
-
-
-
-
-extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
-
-
-
-
-
-extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
-
-
-
-
-
-
-extern int isnanl (long double __value) throw () __attribute__ ((__const__));
-
-
-
-
-
-extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
-extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
-extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
-extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
-extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
-extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
-
-
-
-
-
-
-extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
-extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
-extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
-
-
-
-
-
-
-extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
-
-
-
-
-
-extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
-
-
-
-
-
-
-extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
-
-
-
-
-
-
-
-extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
-
-
-extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
-
-extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
-
-
-
-
-extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
-
-extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
-
-
-
-extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
-
-
-
-extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
-
-
-
-extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
-
-
-
-
-extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
-
-
-
-extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
-
-
-
-extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
-
-
-
-extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
-
-
-
-
-extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
-
-
-
-
-
-
-extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
-__extension__
-extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
-
-
-
-extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
-__extension__
-extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
-
-
-
-extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
-
-
-extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
-
-
-extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
-
-
-
-extern int __fpclassifyl (long double __value) throw ()
-     __attribute__ ((__const__));
-
-
-extern int __signbitl (long double __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
-# 382 "/usr/include/bits/mathcalls.h" 3 4
-extern int __issignalingl (long double __value) throw ()
-     __attribute__ ((__const__));
-
-
-
-
-
-
-extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
-# 152 "/usr/include/math.h" 2 3 4
-# 168 "/usr/include/math.h" 3 4
-extern int signgam;
-# 209 "/usr/include/math.h" 3 4
-enum
-  {
-    FP_NAN =
-
-      0,
-    FP_INFINITE =
-
-      1,
-    FP_ZERO =
-
-      2,
-    FP_SUBNORMAL =
-
-      3,
-    FP_NORMAL =
-
-      4
-  };
-# 347 "/usr/include/math.h" 3 4
-typedef enum
-{
-  _IEEE_ = -1,
-  _SVID_,
-  _XOPEN_,
-  _POSIX_,
-  _ISOC_
-} _LIB_VERSION_TYPE;
-
-
-
-
-extern _LIB_VERSION_TYPE _LIB_VERSION;
-# 370 "/usr/include/math.h" 3 4
-struct __exception
-
-
-
-  {
-    int type;
-    char *name;
-    double arg1;
-    double arg2;
-    double retval;
-  };
-
-
-extern int matherr (struct __exception *__exc) throw ();
-# 534 "/usr/include/math.h" 3 4
-}
-# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 2 3
-# 77 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-extern "C++"
-{
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  inline constexpr double
-  abs(double __x)
-  { return __builtin_fabs(__x); }
-
-
-
-  inline constexpr float
-  abs(float __x)
-  { return __builtin_fabsf(__x); }
-
-  inline constexpr long double
-  abs(long double __x)
-  { return __builtin_fabsl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    abs(_Tp __x)
-    { return __builtin_fabs(__x); }
-
-  using ::acos;
-
-
-  inline constexpr float
-  acos(float __x)
-  { return __builtin_acosf(__x); }
-
-  inline constexpr long double
-  acos(long double __x)
-  { return __builtin_acosl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    acos(_Tp __x)
-    { return __builtin_acos(__x); }
-
-  using ::asin;
-
-
-  inline constexpr float
-  asin(float __x)
-  { return __builtin_asinf(__x); }
-
-  inline constexpr long double
-  asin(long double __x)
-  { return __builtin_asinl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    asin(_Tp __x)
-    { return __builtin_asin(__x); }
-
-  using ::atan;
-
-
-  inline constexpr float
-  atan(float __x)
-  { return __builtin_atanf(__x); }
-
-  inline constexpr long double
-  atan(long double __x)
-  { return __builtin_atanl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    atan(_Tp __x)
-    { return __builtin_atan(__x); }
-
-  using ::atan2;
-
-
-  inline constexpr float
-  atan2(float __y, float __x)
-  { return __builtin_atan2f(__y, __x); }
-
-  inline constexpr long double
-  atan2(long double __y, long double __x)
-  { return __builtin_atan2l(__y, __x); }
-
-
-  template<typename _Tp, typename _Up>
-    inline constexpr
-    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    atan2(_Tp __y, _Up __x)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return atan2(__type(__y), __type(__x));
-    }
-
-  using ::ceil;
-
-
-  inline constexpr float
-  ceil(float __x)
-  { return __builtin_ceilf(__x); }
-
-  inline constexpr long double
-  ceil(long double __x)
-  { return __builtin_ceill(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    ceil(_Tp __x)
-    { return __builtin_ceil(__x); }
-
-  using ::cos;
-
-
-  inline constexpr float
-  cos(float __x)
-  { return __builtin_cosf(__x); }
-
-  inline constexpr long double
-  cos(long double __x)
-  { return __builtin_cosl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    cos(_Tp __x)
-    { return __builtin_cos(__x); }
-
-  using ::cosh;
-
-
-  inline constexpr float
-  cosh(float __x)
-  { return __builtin_coshf(__x); }
-
-  inline constexpr long double
-  cosh(long double __x)
-  { return __builtin_coshl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    cosh(_Tp __x)
-    { return __builtin_cosh(__x); }
-
-  using ::exp;
-
-
-  inline constexpr float
-  exp(float __x)
-  { return __builtin_expf(__x); }
-
-  inline constexpr long double
-  exp(long double __x)
-  { return __builtin_expl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    exp(_Tp __x)
-    { return __builtin_exp(__x); }
-
-  using ::fabs;
-
-
-  inline constexpr float
-  fabs(float __x)
-  { return __builtin_fabsf(__x); }
-
-  inline constexpr long double
-  fabs(long double __x)
-  { return __builtin_fabsl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    fabs(_Tp __x)
-    { return __builtin_fabs(__x); }
-
-  using ::floor;
-
-
-  inline constexpr float
-  floor(float __x)
-  { return __builtin_floorf(__x); }
-
-  inline constexpr long double
-  floor(long double __x)
-  { return __builtin_floorl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    floor(_Tp __x)
-    { return __builtin_floor(__x); }
-
-  using ::fmod;
-
-
-  inline constexpr float
-  fmod(float __x, float __y)
-  { return __builtin_fmodf(__x, __y); }
-
-  inline constexpr long double
-  fmod(long double __x, long double __y)
-  { return __builtin_fmodl(__x, __y); }
-
-
-  template<typename _Tp, typename _Up>
-    inline constexpr
-    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fmod(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fmod(__type(__x), __type(__y));
-    }
-
-  using ::frexp;
-
-
-  inline float
-  frexp(float __x, int* __exp)
-  { return __builtin_frexpf(__x, __exp); }
-
-  inline long double
-  frexp(long double __x, int* __exp)
-  { return __builtin_frexpl(__x, __exp); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    frexp(_Tp __x, int* __exp)
-    { return __builtin_frexp(__x, __exp); }
-
-  using ::ldexp;
-
-
-  inline constexpr float
-  ldexp(float __x, int __exp)
-  { return __builtin_ldexpf(__x, __exp); }
-
-  inline constexpr long double
-  ldexp(long double __x, int __exp)
-  { return __builtin_ldexpl(__x, __exp); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    ldexp(_Tp __x, int __exp)
-    { return __builtin_ldexp(__x, __exp); }
-
-  using ::log;
-
-
-  inline constexpr float
-  log(float __x)
-  { return __builtin_logf(__x); }
-
-  inline constexpr long double
-  log(long double __x)
-  { return __builtin_logl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    log(_Tp __x)
-    { return __builtin_log(__x); }
-
-  using ::log10;
-
-
-  inline constexpr float
-  log10(float __x)
-  { return __builtin_log10f(__x); }
-
-  inline constexpr long double
-  log10(long double __x)
-  { return __builtin_log10l(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    log10(_Tp __x)
-    { return __builtin_log10(__x); }
-
-  using ::modf;
-
-
-  inline float
-  modf(float __x, float* __iptr)
-  { return __builtin_modff(__x, __iptr); }
-
-  inline long double
-  modf(long double __x, long double* __iptr)
-  { return __builtin_modfl(__x, __iptr); }
-
-
-  using ::pow;
-
-
-  inline constexpr float
-  pow(float __x, float __y)
-  { return __builtin_powf(__x, __y); }
-
-  inline constexpr long double
-  pow(long double __x, long double __y)
-  { return __builtin_powl(__x, __y); }
-# 435 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-  template<typename _Tp, typename _Up>
-    inline constexpr
-    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    pow(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return pow(__type(__x), __type(__y));
-    }
-
-  using ::sin;
-
-
-  inline constexpr float
-  sin(float __x)
-  { return __builtin_sinf(__x); }
-
-  inline constexpr long double
-  sin(long double __x)
-  { return __builtin_sinl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    sin(_Tp __x)
-    { return __builtin_sin(__x); }
-
-  using ::sinh;
-
-
-  inline constexpr float
-  sinh(float __x)
-  { return __builtin_sinhf(__x); }
-
-  inline constexpr long double
-  sinh(long double __x)
-  { return __builtin_sinhl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    sinh(_Tp __x)
-    { return __builtin_sinh(__x); }
-
-  using ::sqrt;
-
-
-  inline constexpr float
-  sqrt(float __x)
-  { return __builtin_sqrtf(__x); }
-
-  inline constexpr long double
-  sqrt(long double __x)
-  { return __builtin_sqrtl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    sqrt(_Tp __x)
-    { return __builtin_sqrt(__x); }
-
-  using ::tan;
-
-
-  inline constexpr float
-  tan(float __x)
-  { return __builtin_tanf(__x); }
-
-  inline constexpr long double
-  tan(long double __x)
-  { return __builtin_tanl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    tan(_Tp __x)
-    { return __builtin_tan(__x); }
-
-  using ::tanh;
-
-
-  inline constexpr float
-  tanh(float __x)
-  { return __builtin_tanhf(__x); }
-
-  inline constexpr long double
-  tanh(long double __x)
-  { return __builtin_tanhl(__x); }
-
-
-  template<typename _Tp>
-    inline constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    double>::__type
-    tanh(_Tp __x)
-    { return __builtin_tanh(__x); }
-
-
-}
-# 559 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-  constexpr int
-  fpclassify(float __x)
-  { return __builtin_fpclassify(0, 1, 4,
-    3, 2, __x); }
-
-  constexpr int
-  fpclassify(double __x)
-  { return __builtin_fpclassify(0, 1, 4,
-    3, 2, __x); }
-
-  constexpr int
-  fpclassify(long double __x)
-  { return __builtin_fpclassify(0, 1, 4,
-    3, 2, __x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              int>::__type
-    fpclassify(_Tp __x)
-    { return __x != 0 ? 4 : 2; }
-
-
-
-  constexpr bool
-  isfinite(float __x)
-  { return __builtin_isfinite(__x); }
-
-  constexpr bool
-  isfinite(double __x)
-  { return __builtin_isfinite(__x); }
-
-  constexpr bool
-  isfinite(long double __x)
-  { return __builtin_isfinite(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              bool>::__type
-    isfinite(_Tp __x)
-    { return true; }
-
-
-
-  constexpr bool
-  isinf(float __x)
-  { return __builtin_isinf(__x); }
-
-
-
-
-
-  constexpr bool
-  isinf(double __x)
-  { return __builtin_isinf(__x); }
-
-
-  constexpr bool
-  isinf(long double __x)
-  { return __builtin_isinf(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              bool>::__type
-    isinf(_Tp __x)
-    { return false; }
-
-
-
-  constexpr bool
-  isnan(float __x)
-  { return __builtin_isnan(__x); }
-
-
-
-
-
-  constexpr bool
-  isnan(double __x)
-  { return __builtin_isnan(__x); }
-
-
-  constexpr bool
-  isnan(long double __x)
-  { return __builtin_isnan(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              bool>::__type
-    isnan(_Tp __x)
-    { return false; }
-
-
-
-  constexpr bool
-  isnormal(float __x)
-  { return __builtin_isnormal(__x); }
-
-  constexpr bool
-  isnormal(double __x)
-  { return __builtin_isnormal(__x); }
-
-  constexpr bool
-  isnormal(long double __x)
-  { return __builtin_isnormal(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              bool>::__type
-    isnormal(_Tp __x)
-    { return __x != 0 ? true : false; }
-
-
-
-
-  constexpr bool
-  signbit(float __x)
-  { return __builtin_signbit(__x); }
-
-  constexpr bool
-  signbit(double __x)
-  { return __builtin_signbit(__x); }
-
-  constexpr bool
-  signbit(long double __x)
-  { return __builtin_signbit(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              bool>::__type
-    signbit(_Tp __x)
-    { return __x < 0 ? true : false; }
-
-
-
-  constexpr bool
-  isgreater(float __x, float __y)
-  { return __builtin_isgreater(__x, __y); }
-
-  constexpr bool
-  isgreater(double __x, double __y)
-  { return __builtin_isgreater(__x, __y); }
-
-  constexpr bool
-  isgreater(long double __x, long double __y)
-  { return __builtin_isgreater(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    isgreater(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_isgreater(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr bool
-  isgreaterequal(float __x, float __y)
-  { return __builtin_isgreaterequal(__x, __y); }
-
-  constexpr bool
-  isgreaterequal(double __x, double __y)
-  { return __builtin_isgreaterequal(__x, __y); }
-
-  constexpr bool
-  isgreaterequal(long double __x, long double __y)
-  { return __builtin_isgreaterequal(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    isgreaterequal(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_isgreaterequal(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr bool
-  isless(float __x, float __y)
-  { return __builtin_isless(__x, __y); }
-
-  constexpr bool
-  isless(double __x, double __y)
-  { return __builtin_isless(__x, __y); }
-
-  constexpr bool
-  isless(long double __x, long double __y)
-  { return __builtin_isless(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    isless(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_isless(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr bool
-  islessequal(float __x, float __y)
-  { return __builtin_islessequal(__x, __y); }
-
-  constexpr bool
-  islessequal(double __x, double __y)
-  { return __builtin_islessequal(__x, __y); }
-
-  constexpr bool
-  islessequal(long double __x, long double __y)
-  { return __builtin_islessequal(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    islessequal(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_islessequal(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr bool
-  islessgreater(float __x, float __y)
-  { return __builtin_islessgreater(__x, __y); }
-
-  constexpr bool
-  islessgreater(double __x, double __y)
-  { return __builtin_islessgreater(__x, __y); }
-
-  constexpr bool
-  islessgreater(long double __x, long double __y)
-  { return __builtin_islessgreater(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    islessgreater(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_islessgreater(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr bool
-  isunordered(float __x, float __y)
-  { return __builtin_isunordered(__x, __y); }
-
-  constexpr bool
-  isunordered(double __x, double __y)
-  { return __builtin_isunordered(__x, __y); }
-
-  constexpr bool
-  isunordered(long double __x, long double __y)
-  { return __builtin_isunordered(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename
-    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-       && __is_arithmetic<_Up>::__value), bool>::__type
-    isunordered(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return __builtin_isunordered(__type(__x), __type(__y));
-    }
-# 981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-}
-# 1096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  using ::double_t;
-  using ::float_t;
-
-
-  using ::acosh;
-  using ::acoshf;
-  using ::acoshl;
-
-  using ::asinh;
-  using ::asinhf;
-  using ::asinhl;
-
-  using ::atanh;
-  using ::atanhf;
-  using ::atanhl;
-
-  using ::cbrt;
-  using ::cbrtf;
-  using ::cbrtl;
-
-  using ::copysign;
-  using ::copysignf;
-  using ::copysignl;
-
-  using ::erf;
-  using ::erff;
-  using ::erfl;
-
-  using ::erfc;
-  using ::erfcf;
-  using ::erfcl;
-
-  using ::exp2;
-  using ::exp2f;
-  using ::exp2l;
-
-  using ::expm1;
-  using ::expm1f;
-  using ::expm1l;
-
-  using ::fdim;
-  using ::fdimf;
-  using ::fdiml;
-
-  using ::fma;
-  using ::fmaf;
-  using ::fmal;
-
-  using ::fmax;
-  using ::fmaxf;
-  using ::fmaxl;
-
-  using ::fmin;
-  using ::fminf;
-  using ::fminl;
-
-  using ::hypot;
-  using ::hypotf;
-  using ::hypotl;
-
-  using ::ilogb;
-  using ::ilogbf;
-  using ::ilogbl;
-
-  using ::lgamma;
-  using ::lgammaf;
-  using ::lgammal;
-
-  using ::llrint;
-  using ::llrintf;
-  using ::llrintl;
-
-  using ::llround;
-  using ::llroundf;
-  using ::llroundl;
-
-  using ::log1p;
-  using ::log1pf;
-  using ::log1pl;
-
-  using ::log2;
-  using ::log2f;
-  using ::log2l;
-
-  using ::logb;
-  using ::logbf;
-  using ::logbl;
-
-  using ::lrint;
-  using ::lrintf;
-  using ::lrintl;
-
-  using ::lround;
-  using ::lroundf;
-  using ::lroundl;
-
-  using ::nan;
-  using ::nanf;
-  using ::nanl;
-
-  using ::nearbyint;
-  using ::nearbyintf;
-  using ::nearbyintl;
-
-  using ::nextafter;
-  using ::nextafterf;
-  using ::nextafterl;
-
-  using ::nexttoward;
-  using ::nexttowardf;
-  using ::nexttowardl;
-
-  using ::remainder;
-  using ::remainderf;
-  using ::remainderl;
-
-  using ::remquo;
-  using ::remquof;
-  using ::remquol;
-
-  using ::rint;
-  using ::rintf;
-  using ::rintl;
-
-  using ::round;
-  using ::roundf;
-  using ::roundl;
-
-  using ::scalbln;
-  using ::scalblnf;
-  using ::scalblnl;
-
-  using ::scalbn;
-  using ::scalbnf;
-  using ::scalbnl;
-
-  using ::tgamma;
-  using ::tgammaf;
-  using ::tgammal;
-
-  using ::trunc;
-  using ::truncf;
-  using ::truncl;
-
-
-
-  constexpr float
-  acosh(float __x)
-  { return __builtin_acoshf(__x); }
-
-  constexpr long double
-  acosh(long double __x)
-  { return __builtin_acoshl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    acosh(_Tp __x)
-    { return __builtin_acosh(__x); }
-
-
-
-  constexpr float
-  asinh(float __x)
-  { return __builtin_asinhf(__x); }
-
-  constexpr long double
-  asinh(long double __x)
-  { return __builtin_asinhl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    asinh(_Tp __x)
-    { return __builtin_asinh(__x); }
-
-
-
-  constexpr float
-  atanh(float __x)
-  { return __builtin_atanhf(__x); }
-
-  constexpr long double
-  atanh(long double __x)
-  { return __builtin_atanhl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    atanh(_Tp __x)
-    { return __builtin_atanh(__x); }
-
-
-
-  constexpr float
-  cbrt(float __x)
-  { return __builtin_cbrtf(__x); }
-
-  constexpr long double
-  cbrt(long double __x)
-  { return __builtin_cbrtl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    cbrt(_Tp __x)
-    { return __builtin_cbrt(__x); }
-
-
-
-  constexpr float
-  copysign(float __x, float __y)
-  { return __builtin_copysignf(__x, __y); }
-
-  constexpr long double
-  copysign(long double __x, long double __y)
-  { return __builtin_copysignl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    copysign(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return copysign(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr float
-  erf(float __x)
-  { return __builtin_erff(__x); }
-
-  constexpr long double
-  erf(long double __x)
-  { return __builtin_erfl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    erf(_Tp __x)
-    { return __builtin_erf(__x); }
-
-
-
-  constexpr float
-  erfc(float __x)
-  { return __builtin_erfcf(__x); }
-
-  constexpr long double
-  erfc(long double __x)
-  { return __builtin_erfcl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    erfc(_Tp __x)
-    { return __builtin_erfc(__x); }
-
-
-
-  constexpr float
-  exp2(float __x)
-  { return __builtin_exp2f(__x); }
-
-  constexpr long double
-  exp2(long double __x)
-  { return __builtin_exp2l(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    exp2(_Tp __x)
-    { return __builtin_exp2(__x); }
-
-
-
-  constexpr float
-  expm1(float __x)
-  { return __builtin_expm1f(__x); }
-
-  constexpr long double
-  expm1(long double __x)
-  { return __builtin_expm1l(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    expm1(_Tp __x)
-    { return __builtin_expm1(__x); }
-
-
-
-  constexpr float
-  fdim(float __x, float __y)
-  { return __builtin_fdimf(__x, __y); }
-
-  constexpr long double
-  fdim(long double __x, long double __y)
-  { return __builtin_fdiml(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fdim(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fdim(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr float
-  fma(float __x, float __y, float __z)
-  { return __builtin_fmaf(__x, __y, __z); }
-
-  constexpr long double
-  fma(long double __x, long double __y, long double __z)
-  { return __builtin_fmal(__x, __y, __z); }
-
-
-
-  template<typename _Tp, typename _Up, typename _Vp>
-    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
-    fma(_Tp __x, _Up __y, _Vp __z)
-    {
-      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
-      return fma(__type(__x), __type(__y), __type(__z));
-    }
-
-
-
-  constexpr float
-  fmax(float __x, float __y)
-  { return __builtin_fmaxf(__x, __y); }
-
-  constexpr long double
-  fmax(long double __x, long double __y)
-  { return __builtin_fmaxl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fmax(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fmax(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr float
-  fmin(float __x, float __y)
-  { return __builtin_fminf(__x, __y); }
-
-  constexpr long double
-  fmin(long double __x, long double __y)
-  { return __builtin_fminl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    fmin(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return fmin(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr float
-  hypot(float __x, float __y)
-  { return __builtin_hypotf(__x, __y); }
-
-  constexpr long double
-  hypot(long double __x, long double __y)
-  { return __builtin_hypotl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    hypot(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return hypot(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr int
-  ilogb(float __x)
-  { return __builtin_ilogbf(__x); }
-
-  constexpr int
-  ilogb(long double __x)
-  { return __builtin_ilogbl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr
-    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                    int>::__type
-    ilogb(_Tp __x)
-    { return __builtin_ilogb(__x); }
-
-
-
-  constexpr float
-  lgamma(float __x)
-  { return __builtin_lgammaf(__x); }
-
-  constexpr long double
-  lgamma(long double __x)
-  { return __builtin_lgammal(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    lgamma(_Tp __x)
-    { return __builtin_lgamma(__x); }
-
-
-
-  constexpr long long
-  llrint(float __x)
-  { return __builtin_llrintf(__x); }
-
-  constexpr long long
-  llrint(long double __x)
-  { return __builtin_llrintl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              long long>::__type
-    llrint(_Tp __x)
-    { return __builtin_llrint(__x); }
-
-
-
-  constexpr long long
-  llround(float __x)
-  { return __builtin_llroundf(__x); }
-
-  constexpr long long
-  llround(long double __x)
-  { return __builtin_llroundl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              long long>::__type
-    llround(_Tp __x)
-    { return __builtin_llround(__x); }
-
-
-
-  constexpr float
-  log1p(float __x)
-  { return __builtin_log1pf(__x); }
-
-  constexpr long double
-  log1p(long double __x)
-  { return __builtin_log1pl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    log1p(_Tp __x)
-    { return __builtin_log1p(__x); }
-
-
-
-
-  constexpr float
-  log2(float __x)
-  { return __builtin_log2f(__x); }
-
-  constexpr long double
-  log2(long double __x)
-  { return __builtin_log2l(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    log2(_Tp __x)
-    { return __builtin_log2(__x); }
-
-
-
-  constexpr float
-  logb(float __x)
-  { return __builtin_logbf(__x); }
-
-  constexpr long double
-  logb(long double __x)
-  { return __builtin_logbl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    logb(_Tp __x)
-    { return __builtin_logb(__x); }
-
-
-
-  constexpr long
-  lrint(float __x)
-  { return __builtin_lrintf(__x); }
-
-  constexpr long
-  lrint(long double __x)
-  { return __builtin_lrintl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              long>::__type
-    lrint(_Tp __x)
-    { return __builtin_lrint(__x); }
-
-
-
-  constexpr long
-  lround(float __x)
-  { return __builtin_lroundf(__x); }
-
-  constexpr long
-  lround(long double __x)
-  { return __builtin_lroundl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              long>::__type
-    lround(_Tp __x)
-    { return __builtin_lround(__x); }
-
-
-
-  constexpr float
-  nearbyint(float __x)
-  { return __builtin_nearbyintf(__x); }
-
-  constexpr long double
-  nearbyint(long double __x)
-  { return __builtin_nearbyintl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    nearbyint(_Tp __x)
-    { return __builtin_nearbyint(__x); }
-
-
-
-  constexpr float
-  nextafter(float __x, float __y)
-  { return __builtin_nextafterf(__x, __y); }
-
-  constexpr long double
-  nextafter(long double __x, long double __y)
-  { return __builtin_nextafterl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    nextafter(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return nextafter(__type(__x), __type(__y));
-    }
-
-
-
-  constexpr float
-  nexttoward(float __x, long double __y)
-  { return __builtin_nexttowardf(__x, __y); }
-
-  constexpr long double
-  nexttoward(long double __x, long double __y)
-  { return __builtin_nexttowardl(__x, __y); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    nexttoward(_Tp __x, long double __y)
-    { return __builtin_nexttoward(__x, __y); }
-
-
-
-  constexpr float
-  remainder(float __x, float __y)
-  { return __builtin_remainderf(__x, __y); }
-
-  constexpr long double
-  remainder(long double __x, long double __y)
-  { return __builtin_remainderl(__x, __y); }
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    remainder(_Tp __x, _Up __y)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return remainder(__type(__x), __type(__y));
-    }
-
-
-
-  inline float
-  remquo(float __x, float __y, int* __pquo)
-  { return __builtin_remquof(__x, __y, __pquo); }
-
-  inline long double
-  remquo(long double __x, long double __y, int* __pquo)
-  { return __builtin_remquol(__x, __y, __pquo); }
-
-
-
-  template<typename _Tp, typename _Up>
-    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-    remquo(_Tp __x, _Up __y, int* __pquo)
-    {
-      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-      return remquo(__type(__x), __type(__y), __pquo);
-    }
-
-
-
-  constexpr float
-  rint(float __x)
-  { return __builtin_rintf(__x); }
-
-  constexpr long double
-  rint(long double __x)
-  { return __builtin_rintl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    rint(_Tp __x)
-    { return __builtin_rint(__x); }
-
-
-
-  constexpr float
-  round(float __x)
-  { return __builtin_roundf(__x); }
-
-  constexpr long double
-  round(long double __x)
-  { return __builtin_roundl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    round(_Tp __x)
-    { return __builtin_round(__x); }
-
-
-
-  constexpr float
-  scalbln(float __x, long __ex)
-  { return __builtin_scalblnf(__x, __ex); }
-
-  constexpr long double
-  scalbln(long double __x, long __ex)
-  { return __builtin_scalblnl(__x, __ex); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    scalbln(_Tp __x, long __ex)
-    { return __builtin_scalbln(__x, __ex); }
-
-
-
-  constexpr float
-  scalbn(float __x, int __ex)
-  { return __builtin_scalbnf(__x, __ex); }
-
-  constexpr long double
-  scalbn(long double __x, int __ex)
-  { return __builtin_scalbnl(__x, __ex); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    scalbn(_Tp __x, int __ex)
-    { return __builtin_scalbn(__x, __ex); }
-
-
-
-  constexpr float
-  tgamma(float __x)
-  { return __builtin_tgammaf(__x); }
-
-  constexpr long double
-  tgamma(long double __x)
-  { return __builtin_tgammal(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    tgamma(_Tp __x)
-    { return __builtin_tgamma(__x); }
-
-
-
-  constexpr float
-  trunc(float __x)
-  { return __builtin_truncf(__x); }
-
-  constexpr long double
-  trunc(long double __x)
-  { return __builtin_truncl(__x); }
-
-
-
-  template<typename _Tp>
-    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-                                              double>::__type
-    trunc(_Tp __x)
-    { return __builtin_trunc(__x); }
-
-
-
-}
-# 1889 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h" 2
-
-
-
-namespace mozilla {
-
-
-template<typename IntegerType>
-__attribute__((always_inline)) inline IntegerType
-EuclidGCD(IntegerType aA, IntegerType aB)
-{
-
-
-  do { } while (0);
-  do { } while (0);
-
-  while (aA != aB) {
-    if (aA > aB) {
-      aA = aA - aB;
-    } else {
-      aB = aB - aA;
-    }
-  }
-
-  return aA;
-}
-
-
-template<typename IntegerType>
-__attribute__((always_inline)) inline IntegerType
-EuclidLCM(IntegerType aA, IntegerType aB)
-{
-
-  return (aA / EuclidGCD(aA, aB)) * aB;
-}
-
-namespace detail {
-
-template<typename T>
-struct AllowDeprecatedAbsFixed : FalseType {};
-
-template<> struct AllowDeprecatedAbsFixed<int32_t> : TrueType {};
-template<> struct AllowDeprecatedAbsFixed<int64_t> : TrueType {};
-
-template<typename T>
-struct AllowDeprecatedAbs : AllowDeprecatedAbsFixed<T> {};
-
-template<> struct AllowDeprecatedAbs<int> : TrueType {};
-template<> struct AllowDeprecatedAbs<long> : TrueType {};
-
-}
-
-
-
-template<typename T>
-inline typename mozilla::EnableIf<detail::AllowDeprecatedAbs<T>::value, T>::Type
-DeprecatedAbs(const T aValue)
-{
-# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-  do { } while (0);
-
-
-  return aValue >= 0 ? aValue : -aValue;
-}
-
-namespace detail {
-
-
-
-
-
-template<typename T>
-struct AbsReturnTypeFixed;
-
-template<> struct AbsReturnTypeFixed<int8_t> { typedef uint8_t Type; };
-template<> struct AbsReturnTypeFixed<int16_t> { typedef uint16_t Type; };
-template<> struct AbsReturnTypeFixed<int32_t> { typedef uint32_t Type; };
-template<> struct AbsReturnTypeFixed<int64_t> { typedef uint64_t Type; };
-
-template<typename T>
-struct AbsReturnType : AbsReturnTypeFixed<T> {};
-
-template<> struct AbsReturnType<char> :
-  EnableIf<char(-1) < char(0), unsigned char> {};
-template<> struct AbsReturnType<signed char> { typedef unsigned char Type; };
-template<> struct AbsReturnType<short> { typedef unsigned short Type; };
-template<> struct AbsReturnType<int> { typedef unsigned int Type; };
-template<> struct AbsReturnType<long> { typedef unsigned long Type; };
-template<> struct AbsReturnType<long long> { typedef unsigned long long Type; };
-template<> struct AbsReturnType<float> { typedef float Type; };
-template<> struct AbsReturnType<double> { typedef double Type; };
-template<> struct AbsReturnType<long double> { typedef long double Type; };
-
-}
-
-template<typename T>
-inline typename detail::AbsReturnType<T>::Type
-Abs(const T aValue)
-{
-  typedef typename detail::AbsReturnType<T>::Type ReturnType;
-  return aValue >= 0 ? ReturnType(aValue) : ~ReturnType(aValue) + 1;
-}
-
-template<>
-inline float
-Abs<float>(const float aFloat)
-{
-  return std::fabs(aFloat);
-}
-
-template<>
-inline double
-Abs<double>(const double aDouble)
-{
-  return std::fabs(aDouble);
-}
-
-template<>
-inline long double
-Abs<long double>(const long double aLongDouble)
-{
-  return std::fabs(aLongDouble);
-}
-
-}
-# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-namespace mozilla {
-
-namespace detail {
-# 250 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-inline uint_fast8_t
-CountLeadingZeroes32(uint32_t aValue)
-{
-  return __builtin_clz(aValue);
-}
-
-inline uint_fast8_t
-CountTrailingZeroes32(uint32_t aValue)
-{
-  return __builtin_ctz(aValue);
-}
-
-inline uint_fast8_t
-CountPopulation32(uint32_t aValue)
-{
-  return __builtin_popcount(aValue);
-}
-
-inline uint_fast8_t
-CountPopulation64(uint64_t aValue)
-{
-  return __builtin_popcountll(aValue);
-}
-
-inline uint_fast8_t
-CountLeadingZeroes64(uint64_t aValue)
-{
-  return __builtin_clzll(aValue);
-}
-
-inline uint_fast8_t
-CountTrailingZeroes64(uint64_t aValue)
-{
-  return __builtin_ctzll(aValue);
-}
-# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-}
-# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-inline uint_fast8_t
-CountLeadingZeroes32(uint32_t aValue)
-{
-  do { } while (0);
-  return detail::CountLeadingZeroes32(aValue);
-}
-# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-inline uint_fast8_t
-CountTrailingZeroes32(uint32_t aValue)
-{
-  do { } while (0);
-  return detail::CountTrailingZeroes32(aValue);
-}
-
-
-
-
-inline uint_fast8_t
-CountPopulation32(uint32_t aValue)
-{
-  return detail::CountPopulation32(aValue);
-}
-
-
-inline uint_fast8_t
-CountPopulation64(uint64_t aValue)
-{
-  return detail::CountPopulation64(aValue);
-}
-
-
-inline uint_fast8_t
-CountLeadingZeroes64(uint64_t aValue)
-{
-  do { } while (0);
-  return detail::CountLeadingZeroes64(aValue);
-}
-
-
-inline uint_fast8_t
-CountTrailingZeroes64(uint64_t aValue)
-{
-  do { } while (0);
-  return detail::CountTrailingZeroes64(aValue);
-}
-
-namespace detail {
-
-template<typename T, size_t Size = sizeof(T)>
-class CeilingLog2;
-
-template<typename T>
-class CeilingLog2<T, 4>
-{
-public:
-  static uint_fast8_t compute(const T aValue)
-  {
-
-    return aValue <= 1 ? 0u : 32u - CountLeadingZeroes32(aValue - 1);
-  }
-};
-
-template<typename T>
-class CeilingLog2<T, 8>
-{
-public:
-  static uint_fast8_t compute(const T aValue)
-  {
-
-    return aValue <= 1 ? 0u : 64u - CountLeadingZeroes64(aValue - 1);
-  }
-};
-
-}
-# 404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-template<typename T>
-inline uint_fast8_t
-CeilingLog2(const T aValue)
-{
-  return detail::CeilingLog2<T>::compute(aValue);
-}
-
-
-inline uint_fast8_t
-CeilingLog2Size(size_t aValue)
-{
-  return CeilingLog2(aValue);
-}
-
-namespace detail {
-
-template<typename T, size_t Size = sizeof(T)>
-class FloorLog2;
-
-template<typename T>
-class FloorLog2<T, 4>
-{
-public:
-  static uint_fast8_t compute(const T aValue)
-  {
-    return 31u - CountLeadingZeroes32(aValue | 1);
-  }
-};
-
-template<typename T>
-class FloorLog2<T, 8>
-{
-public:
-  static uint_fast8_t compute(const T aValue)
-  {
-    return 63u - CountLeadingZeroes64(aValue | 1);
-  }
-};
-
-}
-# 453 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MathAlgorithms.h"
-template<typename T>
-inline uint_fast8_t
-FloorLog2(const T aValue)
-{
-  return detail::FloorLog2<T>::compute(aValue);
-}
-
-
-inline uint_fast8_t
-FloorLog2Size(size_t aValue)
-{
-  return FloorLog2(aValue);
-}
-
-
-
-
-
-inline size_t
-RoundUpPow2(size_t aValue)
-{
-  do { } while (0);
-
-  return size_t(1) << CeilingLog2(aValue);
-}
-
-
-
-
-template<typename T>
-inline T
-RotateLeft(const T aValue, uint_fast8_t aShift)
-{
-  do { } while (0);
-  do { } while (0);
-
-
-
-
-  static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
-  return (aValue << aShift) | (aValue >> (sizeof(T) * 8 - aShift));
-}
-
-
-
-
-template<typename T>
-inline T
-RotateRight(const T aValue, uint_fast8_t aShift)
-{
-  do { } while (0);
-  do { } while (0);
-
-
-
-
-  static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
-  return (aValue >> aShift) | (aValue << (sizeof(T) * 8 - aShift));
-}
-
-
-
-
-
-template<typename T>
-constexpr bool
-IsPowerOfTwo(T x)
-{
-    static_assert(IsUnsigned<T>::value,
-                  "IsPowerOfTwo requires unsigned values");
-    return x && (x & (x - 1)) == 0;
-}
-
-template<typename T>
-inline T
-Clamp(const T aValue, const T aMin, const T aMax)
-{
-    static_assert(IsIntegral<T>::value,
-                  "Clamp accepts only integral types, so that it doesn't have"
-                  " to distinguish differently-signed zeroes (which users may"
-                  " or may not care to distinguish, likely at a perf cost) or"
-                  " to decide how to clamp NaN or a range with a NaN"
-                  " endpoint.");
-    do { } while (0);
-
-    if (aValue <= aMin)
-        return aMin;
-    if (aValue >= aMax)
-        return aMax;
-    return aValue;
-}
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryReporting.h" 2
-
-
-
-namespace mozilla {
-
-
-
-
-
-typedef size_t (*MallocSizeOf)(const void* p);
-
-}
-
-
-
-typedef size_t (*MozMallocSizeOf)(const void* p);
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReverseIterator.h"
-namespace mozilla {
-
-template<typename IteratorT>
-class ReverseIterator
-{
-public:
-  template<typename Iterator>
-  explicit ReverseIterator(Iterator aIter)
-    : mCurrent(aIter) { }
-
-  template<typename Iterator>
-               ReverseIterator(const ReverseIterator<Iterator>& aOther)
-    : mCurrent(aOther.mCurrent) { }
-
-  decltype(*DeclVal<IteratorT>()) operator*() const
-  {
-    IteratorT tmp = mCurrent;
-    return *--tmp;
-  }
-
-
-
-  ReverseIterator& operator++() { --mCurrent; return *this; }
-  ReverseIterator& operator--() { ++mCurrent; return *this; }
-  ReverseIterator operator++(int) { auto ret = *this; mCurrent--; return ret; }
-  ReverseIterator operator--(int) { auto ret = *this; mCurrent++; return ret; }
-
-
-
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator==(const ReverseIterator<Iterator1>& aIter1,
-                         const ReverseIterator<Iterator2>& aIter2);
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator!=(const ReverseIterator<Iterator1>& aIter1,
-                         const ReverseIterator<Iterator2>& aIter2);
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator<(const ReverseIterator<Iterator1>& aIter1,
-                        const ReverseIterator<Iterator2>& aIter2);
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator<=(const ReverseIterator<Iterator1>& aIter1,
-                         const ReverseIterator<Iterator2>& aIter2);
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator>(const ReverseIterator<Iterator1>& aIter1,
-                        const ReverseIterator<Iterator2>& aIter2);
-  template<typename Iterator1, typename Iterator2>
-  friend bool operator>=(const ReverseIterator<Iterator1>& aIter1,
-                         const ReverseIterator<Iterator2>& aIter2);
-
-private:
-  IteratorT mCurrent;
-};
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator==(const ReverseIterator<Iterator1>& aIter1,
-           const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent == aIter2.mCurrent;
-}
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator!=(const ReverseIterator<Iterator1>& aIter1,
-           const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent != aIter2.mCurrent;
-}
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator<(const ReverseIterator<Iterator1>& aIter1,
-          const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent > aIter2.mCurrent;
-}
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator<=(const ReverseIterator<Iterator1>& aIter1,
-           const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent >= aIter2.mCurrent;
-}
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator>(const ReverseIterator<Iterator1>& aIter1,
-          const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent < aIter2.mCurrent;
-}
-
-template<typename Iterator1, typename Iterator2>
-bool
-operator>=(const ReverseIterator<Iterator1>& aIter1,
-           const ReverseIterator<Iterator2>& aIter2)
-{
-  return aIter1.mCurrent <= aIter2.mCurrent;
-}
-
-namespace detail {
-
-template<typename IteratorT>
-class IteratorRange
-{
-public:
-  typedef IteratorT iterator;
-  typedef IteratorT const_iterator;
-  typedef ReverseIterator<IteratorT> reverse_iterator;
-  typedef ReverseIterator<IteratorT> const_reverse_iterator;
-
-  template<typename Iterator1, typename Iterator2>
-               IteratorRange(Iterator1 aIterBegin, Iterator2 aIterEnd)
-    : mIterBegin(aIterBegin), mIterEnd(aIterEnd) { }
-
-  template<typename Iterator>
-               IteratorRange(const IteratorRange<Iterator>& aOther)
-    : mIterBegin(aOther.mIterBegin), mIterEnd(aOther.mIterEnd) { }
-
-  iterator begin() const { return mIterBegin; }
-  const_iterator cbegin() const { return begin(); }
-  iterator end() const { return mIterEnd; }
-  const_iterator cend() const { return end(); }
-  reverse_iterator rbegin() const { return reverse_iterator(mIterEnd); }
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  reverse_iterator rend() const { return reverse_iterator(mIterBegin); }
-  const_reverse_iterator crend() const { return rend(); }
-
-private:
-  IteratorT mIterBegin;
-  IteratorT mIterEnd;
-};
-
-}
-
-template<typename Range>
-detail::IteratorRange<typename Range::reverse_iterator>
-Reversed(Range& aRange)
-{
-  return {aRange.rbegin(), aRange.rend()};
-}
-
-template<typename Range>
-detail::IteratorRange<typename Range::const_reverse_iterator>
-Reversed(const Range& aRange)
-{
-  return {aRange.rbegin(), aRange.rend()};
-}
-
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Array.h" 2
-
-namespace mozilla {
-
-template<typename T, size_t Length>
-class Array
-{
-  T mArr[Length];
-
-public:
-  Array() {}
-
-  template <typename... Args>
-               Array(Args&&... aArgs)
-    : mArr{mozilla::Forward<Args>(aArgs)...}
-  {
-    static_assert(sizeof...(aArgs) == Length,
-                  "The number of arguments should be equal to the template parameter Length");
-  }
-
-  T& operator[](size_t aIndex)
-  {
-    do { } while (0);
-    return mArr[aIndex];
-  }
-
-  const T& operator[](size_t aIndex) const
-  {
-    do { } while (0);
-    return mArr[aIndex];
-  }
-
-  bool operator==(const Array<T, Length>& aOther) const
-  {
-    for (size_t i = 0; i < Length; i++) {
-      if (mArr[i] != aOther[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  typedef T* iterator;
-  typedef const T* const_iterator;
-  typedef ReverseIterator<T*> reverse_iterator;
-  typedef ReverseIterator<const T*> const_reverse_iterator;
-
-
-  iterator begin() { return mArr; }
-  const_iterator begin() const { return mArr; }
-  const_iterator cbegin() const { return begin(); }
-  iterator end() { return mArr + Length; }
-  const_iterator end() const { return mArr + Length; }
-  const_iterator cend() const { return end(); }
-
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-  const_reverse_iterator crend() const { return rend(); }
-};
-
-template<typename T>
-class Array<T, 0>
-{
-public:
-  T& operator[](size_t aIndex)
-  {
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 87; ::abort(); } while (0); } while (0);
-  }
-
-  const T& operator[](size_t aIndex) const
-  {
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "indexing into zero-length array" ")"); do { *((volatile int*) __null) = 92; ::abort(); } while (0); } while (0);
-  }
-};
-
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h"
-namespace mozilla {
-# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Casting.h"
-template<typename To, typename From>
-inline void
-BitwiseCast(const From aFrom, To* aResult)
-{
-  static_assert(sizeof(From) == sizeof(To),
-                "To and From must have the same size");
-  union
-  {
-    From mFrom;
-    To mTo;
-  } u;
-  u.mFrom = aFrom;
-  *aResult = u.mTo;
-}
-
-template<typename To, typename From>
-inline To
-BitwiseCast(const From aFrom)
-{
-  To temp;
-  BitwiseCast<To, From>(aFrom, &temp);
-  return temp;
-}
-
-namespace detail {
-
-enum ToSignedness { ToIsSigned, ToIsUnsigned };
-enum FromSignedness { FromIsSigned, FromIsUnsigned };
-
-template<typename From,
-         typename To,
-         FromSignedness = IsSigned<From>::value ? FromIsSigned : FromIsUnsigned,
-         ToSignedness = IsSigned<To>::value ? ToIsSigned : ToIsUnsigned>
-struct BoundsCheckImpl;
-
-
-
-
-
-
-enum UUComparison { FromIsBigger, FromIsNotBigger };
-
-
-
-template<typename From, typename To,
-         UUComparison = (sizeof(From) > sizeof(To))
-                        ? FromIsBigger
-                        : FromIsNotBigger>
-struct UnsignedUnsignedCheck;
-
-template<typename From, typename To>
-struct UnsignedUnsignedCheck<From, To, FromIsBigger>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return aFrom <= From(To(-1));
-  }
-};
-
-template<typename From, typename To>
-struct UnsignedUnsignedCheck<From, To, FromIsNotBigger>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return true;
-  }
-};
-
-template<typename From, typename To>
-struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsUnsigned>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return UnsignedUnsignedCheck<From, To>::checkBounds(aFrom);
-  }
-};
-
-
-
-template<typename From, typename To>
-struct BoundsCheckImpl<From, To, FromIsSigned, ToIsUnsigned>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    if (aFrom < 0) {
-      return false;
-    }
-    if (sizeof(To) >= sizeof(From)) {
-      return true;
-    }
-    return aFrom <= From(To(-1));
-  }
-};
-
-
-
-enum USComparison { FromIsSmaller, FromIsNotSmaller };
-
-template<typename From, typename To,
-         USComparison = (sizeof(From) < sizeof(To))
-                        ? FromIsSmaller
-                        : FromIsNotSmaller>
-struct UnsignedSignedCheck;
-
-template<typename From, typename To>
-struct UnsignedSignedCheck<From, To, FromIsSmaller>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return true;
-  }
-};
-
-template<typename From, typename To>
-struct UnsignedSignedCheck<From, To, FromIsNotSmaller>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1);
-    return aFrom <= From(MaxValue);
-  }
-};
-
-template<typename From, typename To>
-struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsSigned>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return UnsignedSignedCheck<From, To>::checkBounds(aFrom);
-  }
-};
-
-
-
-template<typename From, typename To>
-struct BoundsCheckImpl<From, To, FromIsSigned, ToIsSigned>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    if (sizeof(From) <= sizeof(To)) {
-      return true;
-    }
-    const To MaxValue = To((1ULL << (8 * sizeof(To) - 1)) - 1);
-    const To MinValue = -MaxValue - To(1);
-    return From(MinValue) <= aFrom &&
-           From(aFrom) <= From(MaxValue);
-  }
-};
-
-template<typename From, typename To,
-         bool TypesAreIntegral = IsIntegral<From>::value &&
-                                 IsIntegral<To>::value>
-class BoundsChecker;
-
-template<typename From>
-class BoundsChecker<From, From, true>
-{
-public:
-  static bool checkBounds(const From aFrom) { return true; }
-};
-
-template<typename From, typename To>
-class BoundsChecker<From, To, true>
-{
-public:
-  static bool checkBounds(const From aFrom)
-  {
-    return BoundsCheckImpl<From, To>::checkBounds(aFrom);
-  }
-};
-
-template<typename From, typename To>
-inline bool
-IsInBounds(const From aFrom)
-{
-  return BoundsChecker<From, To>::checkBounds(aFrom);
-}
-
-}
-
-
-
-
-
-
-template<typename To, typename From>
-inline To
-AssertedCast(const From aFrom)
-{
-  do { } while (0);
-  return static_cast<To>(aFrom);
-}
-
-
-
-
-
-
-template<typename To, typename From>
-inline To
-ReleaseAssertedCast(const From aFrom)
-{
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype((detail::IsInBounds<From, To>(aFrom)))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((detail::IsInBounds<From, To>(aFrom))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(detail::IsInBounds<From, To>(aFrom))" ")"); do { *((volatile int*) __null) = 250; ::abort(); } while (0); } } while (0);
-  return static_cast<To>(aFrom);
-}
-
-}
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3
-# 69 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 1 3
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-  namespace rel_ops
-  {
-# 85 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
-    template <class _Tp>
-      inline bool
-      operator!=(const _Tp& __x, const _Tp& __y)
-      { return !(__x == __y); }
-# 98 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
-    template <class _Tp>
-      inline bool
-      operator>(const _Tp& __x, const _Tp& __y)
-      { return __y < __x; }
-# 111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
-    template <class _Tp>
-      inline bool
-      operator<=(const _Tp& __x, const _Tp& __y)
-      { return !(__y < __x); }
-# 124 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_relops.h" 3
-    template <class _Tp>
-      inline bool
-      operator>=(const _Tp& __x, const _Tp& __y)
-      { return !(__x < __y); }
-
-
-  }
-
-}
-# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/utility" 2 3
-
-
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _Tp>
-    struct tuple_size;
-
-
-
-  template<typename _Tp>
-    struct tuple_size<const _Tp>
-    : integral_constant<size_t, tuple_size<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct tuple_size<volatile _Tp>
-    : integral_constant<size_t, tuple_size<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct tuple_size<const volatile _Tp>
-    : integral_constant<size_t, tuple_size<_Tp>::value> { };
-
-
-  template<std::size_t __i, typename _Tp>
-    struct tuple_element;
-
-
-  template<std::size_t __i, typename _Tp>
-    using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
-
-  template<std::size_t __i, typename _Tp>
-    struct tuple_element<__i, const _Tp>
-    {
-      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
-    };
-
-  template<std::size_t __i, typename _Tp>
-    struct tuple_element<__i, volatile _Tp>
-    {
-      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
-    };
-
-  template<std::size_t __i, typename _Tp>
-    struct tuple_element<__i, const volatile _Tp>
-    {
-      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
-    };
-
-
-
-
-  template<std::size_t __i, typename _Tp>
-    using tuple_element_t = typename tuple_element<__i, _Tp>::type;
-
-
-  template<typename>
-    struct __is_tuple_like_impl : false_type
-    { };
-
-
-
-
-  template<typename _T1, typename _T2>
-    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
-    { };
-
-
-  template<class _Tp1, class _Tp2>
-    struct tuple_size<std::pair<_Tp1, _Tp2>>
-    : public integral_constant<std::size_t, 2> { };
-
-
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
-    { typedef _Tp1 type; };
-
-
-  template<class _Tp1, class _Tp2>
-    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
-    { typedef _Tp2 type; };
-
-  template<std::size_t _Int>
-    struct __pair_get;
-
-  template<>
-    struct __pair_get<0>
-    {
-      template<typename _Tp1, typename _Tp2>
-        static constexpr _Tp1&
-        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
-        { return __pair.first; }
-
-      template<typename _Tp1, typename _Tp2>
-        static constexpr _Tp1&&
-        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
-        { return std::forward<_Tp1>(__pair.first); }
-
-      template<typename _Tp1, typename _Tp2>
-        static constexpr const _Tp1&
-        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
-        { return __pair.first; }
-    };
-
-  template<>
-    struct __pair_get<1>
-    {
-      template<typename _Tp1, typename _Tp2>
-        static constexpr _Tp2&
-        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
-        { return __pair.second; }
-
-      template<typename _Tp1, typename _Tp2>
-        static constexpr _Tp2&&
-        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
-        { return std::forward<_Tp2>(__pair.second); }
-
-      template<typename _Tp1, typename _Tp2>
-        static constexpr const _Tp2&
-        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
-        { return __pair.second; }
-    };
-
-  template<std::size_t _Int, class _Tp1, class _Tp2>
-    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
-    get(std::pair<_Tp1, _Tp2>& __in) noexcept
-    { return __pair_get<_Int>::__get(__in); }
-
-  template<std::size_t _Int, class _Tp1, class _Tp2>
-    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
-    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
-    { return __pair_get<_Int>::__move_get(std::move(__in)); }
-
-  template<std::size_t _Int, class _Tp1, class _Tp2>
-    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
-    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
-    { return __pair_get<_Int>::__const_get(__in); }
-
-
-
-
-
-  template <typename _Tp, typename _Up>
-    constexpr _Tp&
-    get(pair<_Tp, _Up>& __p) noexcept
-    { return __p.first; }
-
-  template <typename _Tp, typename _Up>
-    constexpr const _Tp&
-    get(const pair<_Tp, _Up>& __p) noexcept
-    { return __p.first; }
-
-  template <typename _Tp, typename _Up>
-    constexpr _Tp&&
-    get(pair<_Tp, _Up>&& __p) noexcept
-    { return std::move(__p.first); }
-
-  template <typename _Tp, typename _Up>
-    constexpr _Tp&
-    get(pair<_Up, _Tp>& __p) noexcept
-    { return __p.second; }
-
-  template <typename _Tp, typename _Up>
-    constexpr const _Tp&
-    get(const pair<_Up, _Tp>& __p) noexcept
-    { return __p.second; }
-
-  template <typename _Tp, typename _Up>
-    constexpr _Tp&&
-    get(pair<_Up, _Tp>&& __p) noexcept
-    { return std::move(__p.second); }
-
-
-
-
-  template <typename _Tp, typename _Up = _Tp>
-    inline _Tp
-    exchange(_Tp& __obj, _Up&& __new_val)
-    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
-
-
-
-
-  template<size_t... _Indexes> struct _Index_tuple { };
-
-
-  template<typename _Itup1, typename _Itup2> struct _Itup_cat;
-
-  template<size_t... _Ind1, size_t... _Ind2>
-    struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
-    {
-      using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>;
-    };
-
-
-  template<size_t _Num>
-    struct _Build_index_tuple
-    : _Itup_cat<typename _Build_index_tuple<_Num / 2>::__type,
-  typename _Build_index_tuple<_Num - _Num / 2>::__type>
-    { };
-
-  template<>
-    struct _Build_index_tuple<1>
-    {
-      typedef _Index_tuple<0> __type;
-    };
-
-  template<>
-    struct _Build_index_tuple<0>
-    {
-      typedef _Index_tuple<> __type;
-    };
-
-
-
-
-
-
-  template<typename _Tp, _Tp... _Idx>
-    struct integer_sequence
-    {
-      typedef _Tp value_type;
-      static constexpr size_t size() { return sizeof...(_Idx); }
-    };
-
-  template<typename _Tp, _Tp _Num,
-    typename _ISeq = typename _Build_index_tuple<_Num>::__type>
-    struct _Make_integer_sequence;
-
-  template<typename _Tp, _Tp _Num, size_t... _Idx>
-    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
-    {
-      static_assert( _Num >= 0,
-       "Cannot make integer sequence of negative length" );
-
-      typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
-    };
-
-
-  template<typename _Tp, _Tp _Num>
-    using make_integer_sequence
-      = typename _Make_integer_sequence<_Tp, _Num>::__type;
-
-
-  template<size_t... _Idx>
-    using index_sequence = integer_sequence<size_t, _Idx...>;
-
-
-  template<size_t _Num>
-    using make_index_sequence = make_integer_sequence<size_t, _Num>;
-
-
-  template<typename... _Types>
-    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
-
-
-
-}
-# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstdlib" 3
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
-
-
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
-  template<typename _IIter, typename _Predicate>
-    bool
-    all_of(_IIter, _IIter, _Predicate);
-
-  template<typename _IIter, typename _Predicate>
-    bool
-    any_of(_IIter, _IIter, _Predicate);
-
-
-  template<typename _FIter, typename _Tp>
-    bool
-    binary_search(_FIter, _FIter, const _Tp&);
-
-  template<typename _FIter, typename _Tp, typename _Compare>
-    bool
-    binary_search(_FIter, _FIter, const _Tp&, _Compare);
-
-  template<typename _IIter, typename _OIter>
-    _OIter
-    copy(_IIter, _IIter, _OIter);
-
-  template<typename _BIter1, typename _BIter2>
-    _BIter2
-    copy_backward(_BIter1, _BIter1, _BIter2);
-
-
-  template<typename _IIter, typename _OIter, typename _Predicate>
-    _OIter
-    copy_if(_IIter, _IIter, _OIter, _Predicate);
-
-  template<typename _IIter, typename _Size, typename _OIter>
-    _OIter
-    copy_n(_IIter, _Size, _OIter);
-
-
-
-
-
-  template<typename _FIter, typename _Tp>
-    pair<_FIter, _FIter>
-    equal_range(_FIter, _FIter, const _Tp&);
-
-  template<typename _FIter, typename _Tp, typename _Compare>
-    pair<_FIter, _FIter>
-    equal_range(_FIter, _FIter, const _Tp&, _Compare);
-
-  template<typename _FIter, typename _Tp>
-    void
-    fill(_FIter, _FIter, const _Tp&);
-
-  template<typename _OIter, typename _Size, typename _Tp>
-    _OIter
-    fill_n(_OIter, _Size, const _Tp&);
-
-
-
-  template<typename _FIter1, typename _FIter2>
-    _FIter1
-    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
-
-  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
-    _FIter1
-    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
-
-
-
-
-
-  template<typename _IIter, typename _Predicate>
-    _IIter
-    find_if_not(_IIter, _IIter, _Predicate);
-
-
-
-
-
-
-  template<typename _IIter1, typename _IIter2>
-    bool
-    includes(_IIter1, _IIter1, _IIter2, _IIter2);
-
-  template<typename _IIter1, typename _IIter2, typename _Compare>
-    bool
-    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
-
-  template<typename _BIter>
-    void
-    inplace_merge(_BIter, _BIter, _BIter);
-
-  template<typename _BIter, typename _Compare>
-    void
-    inplace_merge(_BIter, _BIter, _BIter, _Compare);
-
-
-  template<typename _RAIter>
-    bool
-    is_heap(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    bool
-    is_heap(_RAIter, _RAIter, _Compare);
-
-  template<typename _RAIter>
-    _RAIter
-    is_heap_until(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    _RAIter
-    is_heap_until(_RAIter, _RAIter, _Compare);
-
-  template<typename _IIter, typename _Predicate>
-    bool
-    is_partitioned(_IIter, _IIter, _Predicate);
-
-  template<typename _FIter1, typename _FIter2>
-    bool
-    is_permutation(_FIter1, _FIter1, _FIter2);
-
-  template<typename _FIter1, typename _FIter2,
-    typename _BinaryPredicate>
-    bool
-    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
-
-  template<typename _FIter>
-    bool
-    is_sorted(_FIter, _FIter);
-
-  template<typename _FIter, typename _Compare>
-    bool
-    is_sorted(_FIter, _FIter, _Compare);
-
-  template<typename _FIter>
-    _FIter
-    is_sorted_until(_FIter, _FIter);
-
-  template<typename _FIter, typename _Compare>
-    _FIter
-    is_sorted_until(_FIter, _FIter, _Compare);
-
-
-  template<typename _FIter1, typename _FIter2>
-    void
-    iter_swap(_FIter1, _FIter2);
-
-  template<typename _FIter, typename _Tp>
-    _FIter
-    lower_bound(_FIter, _FIter, const _Tp&);
-
-  template<typename _FIter, typename _Tp, typename _Compare>
-    _FIter
-    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
-
-  template<typename _RAIter>
-    void
-    make_heap(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    make_heap(_RAIter, _RAIter, _Compare);
-
-  template<typename _Tp>
-    constexpr
-    const _Tp&
-    max(const _Tp&, const _Tp&);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    const _Tp&
-    max(const _Tp&, const _Tp&, _Compare);
-
-
-
-
-  template<typename _Tp>
-    constexpr
-    const _Tp&
-    min(const _Tp&, const _Tp&);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    const _Tp&
-    min(const _Tp&, const _Tp&, _Compare);
-
-
-
-
-  template<typename _Tp>
-    constexpr
-    pair<const _Tp&, const _Tp&>
-    minmax(const _Tp&, const _Tp&);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    pair<const _Tp&, const _Tp&>
-    minmax(const _Tp&, const _Tp&, _Compare);
-
-  template<typename _FIter>
-    constexpr
-    pair<_FIter, _FIter>
-    minmax_element(_FIter, _FIter);
-
-  template<typename _FIter, typename _Compare>
-    constexpr
-    pair<_FIter, _FIter>
-    minmax_element(_FIter, _FIter, _Compare);
-
-  template<typename _Tp>
-    constexpr
-    _Tp
-    min(initializer_list<_Tp>);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    _Tp
-    min(initializer_list<_Tp>, _Compare);
-
-  template<typename _Tp>
-    constexpr
-    _Tp
-    max(initializer_list<_Tp>);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    _Tp
-    max(initializer_list<_Tp>, _Compare);
-
-  template<typename _Tp>
-    constexpr
-    pair<_Tp, _Tp>
-    minmax(initializer_list<_Tp>);
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    pair<_Tp, _Tp>
-    minmax(initializer_list<_Tp>, _Compare);
-
-
-
-
-  template<typename _BIter>
-    bool
-    next_permutation(_BIter, _BIter);
-
-  template<typename _BIter, typename _Compare>
-    bool
-    next_permutation(_BIter, _BIter, _Compare);
-
-
-  template<typename _IIter, typename _Predicate>
-    bool
-    none_of(_IIter, _IIter, _Predicate);
-
-
-
-
-
-  template<typename _IIter, typename _RAIter>
-    _RAIter
-    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
-
-  template<typename _IIter, typename _RAIter, typename _Compare>
-    _RAIter
-    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
-
-
-
-
-  template<typename _IIter, typename _OIter1,
-    typename _OIter2, typename _Predicate>
-    pair<_OIter1, _OIter2>
-    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
-
-  template<typename _FIter, typename _Predicate>
-    _FIter
-    partition_point(_FIter, _FIter, _Predicate);
-
-
-  template<typename _RAIter>
-    void
-    pop_heap(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    pop_heap(_RAIter, _RAIter, _Compare);
-
-  template<typename _BIter>
-    bool
-    prev_permutation(_BIter, _BIter);
-
-  template<typename _BIter, typename _Compare>
-    bool
-    prev_permutation(_BIter, _BIter, _Compare);
-
-  template<typename _RAIter>
-    void
-    push_heap(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    push_heap(_RAIter, _RAIter, _Compare);
-
-
-
-  template<typename _FIter, typename _Tp>
-    _FIter
-    remove(_FIter, _FIter, const _Tp&);
-
-  template<typename _FIter, typename _Predicate>
-    _FIter
-    remove_if(_FIter, _FIter, _Predicate);
-
-  template<typename _IIter, typename _OIter, typename _Tp>
-    _OIter
-    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
-
-  template<typename _IIter, typename _OIter, typename _Predicate>
-    _OIter
-    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
-
-
-
-  template<typename _IIter, typename _OIter, typename _Tp>
-    _OIter
-    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
-
-  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
-    _OIter
-    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
-
-
-
-  template<typename _BIter>
-    void
-    reverse(_BIter, _BIter);
-
-  template<typename _BIter, typename _OIter>
-    _OIter
-    reverse_copy(_BIter, _BIter, _OIter);
-
-  inline namespace _V2
-  {
-    template<typename _FIter>
-      _FIter
-      rotate(_FIter, _FIter, _FIter);
-  }
-
-  template<typename _FIter, typename _OIter>
-    _OIter
-    rotate_copy(_FIter, _FIter, _FIter, _OIter);
-# 552 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
-  template<typename _RAIter, typename _UGenerator>
-    void
-    shuffle(_RAIter, _RAIter, _UGenerator&&);
-
-
-  template<typename _RAIter>
-    void
-    sort_heap(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    sort_heap(_RAIter, _RAIter, _Compare);
-
-  template<typename _BIter, typename _Predicate>
-    _BIter
-    stable_partition(_BIter, _BIter, _Predicate);
-# 581 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/algorithmfwd.h" 3
-  template<typename _FIter1, typename _FIter2>
-    _FIter2
-    swap_ranges(_FIter1, _FIter1, _FIter2);
-
-
-
-  template<typename _FIter>
-    _FIter
-    unique(_FIter, _FIter);
-
-  template<typename _FIter, typename _BinaryPredicate>
-    _FIter
-    unique(_FIter, _FIter, _BinaryPredicate);
-
-
-
-  template<typename _FIter, typename _Tp>
-    _FIter
-    upper_bound(_FIter, _FIter, const _Tp&);
-
-  template<typename _FIter, typename _Tp, typename _Compare>
-    _FIter
-    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
-
-
-
-
-
-  template<typename _FIter>
-    _FIter
-    adjacent_find(_FIter, _FIter);
-
-  template<typename _FIter, typename _BinaryPredicate>
-    _FIter
-    adjacent_find(_FIter, _FIter, _BinaryPredicate);
-
-  template<typename _IIter, typename _Tp>
-    typename iterator_traits<_IIter>::difference_type
-    count(_IIter, _IIter, const _Tp&);
-
-  template<typename _IIter, typename _Predicate>
-    typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, _Predicate);
-
-  template<typename _IIter1, typename _IIter2>
-    bool
-    equal(_IIter1, _IIter1, _IIter2);
-
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    bool
-    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
-
-  template<typename _IIter, typename _Tp>
-    _IIter
-    find(_IIter, _IIter, const _Tp&);
-
-  template<typename _FIter1, typename _FIter2>
-    _FIter1
-    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
-
-  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
-    _FIter1
-    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
-
-  template<typename _IIter, typename _Predicate>
-    _IIter
-    find_if(_IIter, _IIter, _Predicate);
-
-  template<typename _IIter, typename _Funct>
-    _Funct
-    for_each(_IIter, _IIter, _Funct);
-
-  template<typename _FIter, typename _Generator>
-    void
-    generate(_FIter, _FIter, _Generator);
-
-  template<typename _OIter, typename _Size, typename _Generator>
-    _OIter
-    generate_n(_OIter, _Size, _Generator);
-
-  template<typename _IIter1, typename _IIter2>
-    bool
-    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
-
-  template<typename _IIter1, typename _IIter2, typename _Compare>
-    bool
-    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
-
-  template<typename _FIter>
-    constexpr
-    _FIter
-    max_element(_FIter, _FIter);
-
-  template<typename _FIter, typename _Compare>
-    constexpr
-    _FIter
-    max_element(_FIter, _FIter, _Compare);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter
-    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _Compare>
-    _OIter
-    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
-
-  template<typename _FIter>
-    constexpr
-    _FIter
-    min_element(_FIter, _FIter);
-
-  template<typename _FIter, typename _Compare>
-    constexpr
-    _FIter
-    min_element(_FIter, _FIter, _Compare);
-
-  template<typename _IIter1, typename _IIter2>
-    pair<_IIter1, _IIter2>
-    mismatch(_IIter1, _IIter1, _IIter2);
-
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    pair<_IIter1, _IIter2>
-    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
-
-  template<typename _RAIter>
-    void
-    nth_element(_RAIter, _RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
-
-  template<typename _RAIter>
-    void
-    partial_sort(_RAIter, _RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
-
-  template<typename _BIter, typename _Predicate>
-    _BIter
-    partition(_BIter, _BIter, _Predicate);
-
-  template<typename _RAIter>
-    void
-    random_shuffle(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Generator>
-    void
-    random_shuffle(_RAIter, _RAIter,
-
-     _Generator&&);
-
-
-
-
-  template<typename _FIter, typename _Tp>
-    void
-    replace(_FIter, _FIter, const _Tp&, const _Tp&);
-
-  template<typename _FIter, typename _Predicate, typename _Tp>
-    void
-    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
-
-  template<typename _FIter1, typename _FIter2>
-    _FIter1
-    search(_FIter1, _FIter1, _FIter2, _FIter2);
-
-  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
-    _FIter1
-    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
-
-  template<typename _FIter, typename _Size, typename _Tp>
-    _FIter
-    search_n(_FIter, _FIter, _Size, const _Tp&);
-
-  template<typename _FIter, typename _Size, typename _Tp,
-    typename _BinaryPredicate>
-    _FIter
-    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter
-    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _Compare>
-    _OIter
-    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter
-    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _Compare>
-    _OIter
-    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter
-    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _Compare>
-    _OIter
-    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
-        _OIter, _Compare);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter
-    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _Compare>
-    _OIter
-    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
-
-  template<typename _RAIter>
-    void
-    sort(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    sort(_RAIter, _RAIter, _Compare);
-
-  template<typename _RAIter>
-    void
-    stable_sort(_RAIter, _RAIter);
-
-  template<typename _RAIter, typename _Compare>
-    void
-    stable_sort(_RAIter, _RAIter, _Compare);
-
-  template<typename _IIter, typename _OIter, typename _UnaryOperation>
-    _OIter
-    transform(_IIter, _IIter, _OIter, _UnaryOperation);
-
-  template<typename _IIter1, typename _IIter2, typename _OIter,
-    typename _BinaryOperation>
-    _OIter
-    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
-
-  template<typename _IIter, typename _OIter>
-    _OIter
-    unique_copy(_IIter, _IIter, _OIter);
-
-  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
-    _OIter
-    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
-
-
-}
-# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 1 3
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _RandomAccessIterator, typename _Distance,
-    typename _Compare>
-    _Distance
-    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
-      _Compare __comp)
-    {
-      _Distance __parent = 0;
-      for (_Distance __child = 1; __child < __n; ++__child)
- {
-   if (__comp(__first + __parent, __first + __child))
-     return __child;
-   if ((__child & 1) == 0)
-     ++__parent;
- }
-      return __n;
-    }
-
-
-
-  template<typename _RandomAccessIterator, typename _Distance>
-    inline bool
-    __is_heap(_RandomAccessIterator __first, _Distance __n)
-    {
-      return std::__is_heap_until(__first, __n,
-   __gnu_cxx::__ops::__iter_less_iter()) == __n;
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare,
-    typename _Distance>
-    inline bool
-    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
-    {
-      return std::__is_heap_until(__first, __n,
- __gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n;
-    }
-
-  template<typename _RandomAccessIterator>
-    inline bool
-    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    { return std::__is_heap(__first, std::distance(__first, __last)); }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline bool
-    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       _Compare __comp)
-    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
-
-
-
-
-  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
-    typename _Compare>
-    void
-    __push_heap(_RandomAccessIterator __first,
-  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
-  _Compare __comp)
-    {
-      _Distance __parent = (__holeIndex - 1) / 2;
-      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
- {
-   *(__first + __holeIndex) = std::move(*(__first + __parent));
-   __holeIndex = __parent;
-   __parent = (__holeIndex - 1) / 2;
- }
-      *(__first + __holeIndex) = std::move(__value);
-    }
-# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
-   _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
-   _DistanceType;
-
-
-
-
-
-                                                     ;
-                                                     ;
-                                                  ;
-
-      _ValueType __value = std::move(*(__last - 1));
-      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
-         _DistanceType(0), std::move(__value),
-         __gnu_cxx::__ops::__iter_less_val());
-    }
-# 183 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       _Compare __comp)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
-   _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
-   _DistanceType;
-
-
-
-
-                                                     ;
-                                                                  ;
-                                                               ;
-
-      _ValueType __value = std::move(*(__last - 1));
-      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
-         _DistanceType(0), std::move(__value),
-         __gnu_cxx::__ops::__iter_comp_val(__comp));
-    }
-
-  template<typename _RandomAccessIterator, typename _Distance,
-    typename _Tp, typename _Compare>
-    void
-    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
-    _Distance __len, _Tp __value, _Compare __comp)
-    {
-      const _Distance __topIndex = __holeIndex;
-      _Distance __secondChild = __holeIndex;
-      while (__secondChild < (__len - 1) / 2)
- {
-   __secondChild = 2 * (__secondChild + 1);
-   if (__comp(__first + __secondChild,
-       __first + (__secondChild - 1)))
-     __secondChild--;
-   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
-   __holeIndex = __secondChild;
- }
-      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
- {
-   __secondChild = 2 * (__secondChild + 1);
-   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));
-
-   __holeIndex = __secondChild - 1;
- }
-      std::__push_heap(__first, __holeIndex, __topIndex,
-         std::move(__value),
-         __gnu_cxx::__ops::__iter_comp_val(__comp));
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-        _RandomAccessIterator __result, _Compare __comp)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
- _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
- _DistanceType;
-
-      _ValueType __value = std::move(*__result);
-      *__result = std::move(*__first);
-      std::__adjust_heap(__first, _DistanceType(0),
-    _DistanceType(__last - __first),
-    std::move(__value), __comp);
-    }
-# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                         ;
-                                                     ;
-                                                     ;
-                                              ;
-
-      if (__last - __first > 1)
- {
-   --__last;
-   std::__pop_heap(__first, __last, __last,
-     __gnu_cxx::__ops::__iter_less_iter());
- }
-    }
-# 296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    pop_heap(_RandomAccessIterator __first,
-      _RandomAccessIterator __last, _Compare __comp)
-    {
-
-
-
-                                                     ;
-                                                                  ;
-                                                         ;
-                                                           ;
-
-      if (__last - __first > 1)
- {
-   --__last;
-   std::__pop_heap(__first, __last, __last,
-     __gnu_cxx::__ops::__iter_comp_iter(__comp));
- }
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-  _Compare __comp)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
-   _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
-   _DistanceType;
-
-      if (__last - __first < 2)
- return;
-
-      const _DistanceType __len = __last - __first;
-      _DistanceType __parent = (__len - 2) / 2;
-      while (true)
- {
-   _ValueType __value = std::move(*(__first + __parent));
-   std::__adjust_heap(__first, __parent, __len, std::move(__value),
-        __comp);
-   if (__parent == 0)
-     return;
-   __parent--;
- }
-    }
-# 351 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      std::__make_heap(__first, __last,
-         __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 377 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       _Compare __comp)
-    {
-
-
-
-                                                     ;
-                                                                  ;
-
-      std::__make_heap(__first, __last,
-         __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-  _Compare __comp)
-    {
-      while (__last - __first > 1)
- {
-   --__last;
-   std::__pop_heap(__first, __last, __last, __comp);
- }
-    }
-# 412 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-                                              ;
-
-      std::__sort_heap(__first, __last,
-         __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 439 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       _Compare __comp)
-    {
-
-
-
-                                                     ;
-                                                                  ;
-                                                           ;
-
-      std::__sort_heap(__first, __last,
-         __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline _RandomAccessIterator
-    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return __first +
- std::__is_heap_until(__first, std::distance(__first, __last),
-        __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 494 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline _RandomAccessIterator
-    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
-    _Compare __comp)
-    {
-
-
-
-                                                     ;
-                                                                  ;
-
-      return __first
- + std::__is_heap_until(__first, std::distance(__first, __last),
-          __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 517 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator>
-    inline bool
-    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    { return std::is_heap_until(__first, __last) == __last; }
-# 530 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_heap.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline bool
-    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
-     _Compare __comp)
-    { return std::is_heap_until(__first, __last, __comp) == __last; }
-
-
-
-}
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 1 3
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _T1, typename... _Args>
-    inline void
-    _Construct(_T1* __p, _Args&&... __args)
-    { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
-# 90 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_construct.h" 3
-  template<typename _Tp>
-    inline void
-    _Destroy(_Tp* __pointer)
-    { __pointer->~_Tp(); }
-
-  template<bool>
-    struct _Destroy_aux
-    {
-      template<typename _ForwardIterator>
-        static void
-        __destroy(_ForwardIterator __first, _ForwardIterator __last)
- {
-   for (; __first != __last; ++__first)
-     std::_Destroy(std::__addressof(*__first));
- }
-    };
-
-  template<>
-    struct _Destroy_aux<true>
-    {
-      template<typename _ForwardIterator>
-        static void
-        __destroy(_ForwardIterator, _ForwardIterator) { }
-    };
-
-
-
-
-
-
-  template<typename _ForwardIterator>
-    inline void
-    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::value_type
-                       _Value_type;
-      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
- __destroy(__first, __last);
-    }
-
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Allocator>
-    void
-    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
-      _Allocator& __alloc)
-    {
-      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-      for (; __first != __last; ++__first)
- __traits::destroy(__alloc, std::__addressof(*__first));
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline void
-    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
-      allocator<_Tp>&)
-    {
-      _Destroy(__first, __last);
-    }
-
-
-}
-# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 83 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
-  template<typename _Tp>
-    pair<_Tp*, ptrdiff_t>
-    get_temporary_buffer(ptrdiff_t __len) noexcept
-    {
-      const ptrdiff_t __max =
- __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
-      if (__len > __max)
- __len = __max;
-
-      while (__len > 0)
- {
-   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
-       std::nothrow));
-   if (__tmp != 0)
-     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
-   __len /= 2;
- }
-      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
-    }
-# 110 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
-  template<typename _Tp>
-    inline void
-    return_temporary_buffer(_Tp* __p)
-    { ::operator delete(__p, std::nothrow); }
-
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Tp>
-    class _Temporary_buffer
-    {
-
-
-
-    public:
-      typedef _Tp value_type;
-      typedef value_type* pointer;
-      typedef pointer iterator;
-      typedef ptrdiff_t size_type;
-
-    protected:
-      size_type _M_original_len;
-      size_type _M_len;
-      pointer _M_buffer;
-
-    public:
-
-      size_type
-      size() const
-      { return _M_len; }
-
-
-      size_type
-      requested_size() const
-      { return _M_original_len; }
-
-
-      iterator
-      begin()
-      { return _M_buffer; }
-
-
-      iterator
-      end()
-      { return _M_buffer + _M_len; }
-
-
-
-
-
-      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
-
-      ~_Temporary_buffer()
-      {
- std::_Destroy(_M_buffer, _M_buffer + _M_len);
- std::return_temporary_buffer(_M_buffer);
-      }
-
-    private:
-
-      _Temporary_buffer(const _Temporary_buffer&);
-
-      void
-      operator=(const _Temporary_buffer&);
-    };
-
-
-  template<bool>
-    struct __uninitialized_construct_buf_dispatch
-    {
-      template<typename _Pointer, typename _ForwardIterator>
-        static void
-        __ucr(_Pointer __first, _Pointer __last,
-       _ForwardIterator __seed)
-        {
-   if(__first == __last)
-     return;
-
-   _Pointer __cur = __first;
-   try
-     {
-       std::_Construct(std::__addressof(*__first),
-         std::move(*__seed));
-       _Pointer __prev = __cur;
-       ++__cur;
-       for(; __cur != __last; ++__cur, ++__prev)
-  std::_Construct(std::__addressof(*__cur),
-    std::move(*__prev));
-       *__seed = std::move(*__prev);
-     }
-   catch(...)
-     {
-       std::_Destroy(__first, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_construct_buf_dispatch<true>
-    {
-      template<typename _Pointer, typename _ForwardIterator>
-        static void
-        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
-    };
-# 229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_tempbuf.h" 3
-  template<typename _Pointer, typename _ForwardIterator>
-    inline void
-    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
-      _ForwardIterator __seed)
-    {
-      typedef typename std::iterator_traits<_Pointer>::value_type
- _ValueType;
-
-      std::__uninitialized_construct_buf_dispatch<
-        __has_trivial_constructor(_ValueType)>::
-   __ucr(__first, __last, __seed);
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    _Temporary_buffer<_ForwardIterator, _Tp>::
-    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
-    : _M_original_len(std::distance(__first, __last)),
-      _M_len(0), _M_buffer(0)
-    {
-      try
- {
-   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
-         value_type>(_M_original_len));
-   _M_buffer = __p.first;
-   _M_len = __p.second;
-   if (_M_buffer)
-     std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
-            __first);
- }
-      catch(...)
- {
-   std::return_temporary_buffer(_M_buffer);
-   _M_buffer = 0;
-   _M_len = 0;
-   throw;
- }
-    }
-
-
-}
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 1 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 1 3
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  enum float_round_style
-  {
-    round_indeterminate = -1,
-    round_toward_zero = 0,
-    round_to_nearest = 1,
-    round_toward_infinity = 2,
-    round_toward_neg_infinity = 3
-  };
-
-
-
-
-
-
-
-  enum float_denorm_style
-  {
-
-    denorm_indeterminate = -1,
-
-    denorm_absent = 0,
-
-    denorm_present = 1
-  };
-# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-  struct __numeric_limits_base
-  {
-
-
-    static constexpr bool is_specialized = false;
-
-
-
-
-    static constexpr int digits = 0;
-
-
-    static constexpr int digits10 = 0;
-
-
-
-
-    static constexpr int max_digits10 = 0;
-
-
-
-    static constexpr bool is_signed = false;
-
-
-    static constexpr bool is_integer = false;
-
-
-
-
-    static constexpr bool is_exact = false;
-
-
-
-    static constexpr int radix = 0;
-
-
-
-    static constexpr int min_exponent = 0;
-
-
-
-    static constexpr int min_exponent10 = 0;
-
-
-
-
-    static constexpr int max_exponent = 0;
-
-
-
-    static constexpr int max_exponent10 = 0;
-
-
-    static constexpr bool has_infinity = false;
-
-
-
-    static constexpr bool has_quiet_NaN = false;
-
-
-
-    static constexpr bool has_signaling_NaN = false;
-
-
-    static constexpr float_denorm_style has_denorm = denorm_absent;
-
-
-
-    static constexpr bool has_denorm_loss = false;
-
-
-
-    static constexpr bool is_iec559 = false;
-
-
-
-
-    static constexpr bool is_bounded = false;
-# 288 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-    static constexpr bool is_modulo = false;
-
-
-    static constexpr bool traps = false;
-
-
-    static constexpr bool tinyness_before = false;
-
-
-
-
-    static constexpr float_round_style round_style =
-          round_toward_zero;
-  };
-# 314 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-  template<typename _Tp>
-    struct numeric_limits : public __numeric_limits_base
-    {
-
-
-      static constexpr _Tp
-      min() noexcept { return _Tp(); }
-
-
-      static constexpr _Tp
-      max() noexcept { return _Tp(); }
-
-
-
-
-      static constexpr _Tp
-      lowest() noexcept { return _Tp(); }
-
-
-
-
-      static constexpr _Tp
-      epsilon() noexcept { return _Tp(); }
-
-
-      static constexpr _Tp
-      round_error() noexcept { return _Tp(); }
-
-
-      static constexpr _Tp
-      infinity() noexcept { return _Tp(); }
-
-
-
-      static constexpr _Tp
-      quiet_NaN() noexcept { return _Tp(); }
-
-
-
-      static constexpr _Tp
-      signaling_NaN() noexcept { return _Tp(); }
-
-
-
-
-      static constexpr _Tp
-      denorm_min() noexcept { return _Tp(); }
-    };
-
-
-  template<typename _Tp>
-    struct numeric_limits<const _Tp>
-    : public numeric_limits<_Tp> { };
-
-  template<typename _Tp>
-    struct numeric_limits<volatile _Tp>
-    : public numeric_limits<_Tp> { };
-
-  template<typename _Tp>
-    struct numeric_limits<const volatile _Tp>
-    : public numeric_limits<_Tp> { };
-
-
-
-
-
-
-  template<>
-    struct numeric_limits<bool>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr bool
-      min() noexcept { return false; }
-
-      static constexpr bool
-      max() noexcept { return true; }
-
-
-      static constexpr bool
-      lowest() noexcept { return min(); }
-
-      static constexpr int digits = 1;
-      static constexpr int digits10 = 0;
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr bool
-      epsilon() noexcept { return false; }
-
-      static constexpr bool
-      round_error() noexcept { return false; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr bool
-      infinity() noexcept { return false; }
-
-      static constexpr bool
-      quiet_NaN() noexcept { return false; }
-
-      static constexpr bool
-      signaling_NaN() noexcept { return false; }
-
-      static constexpr bool
-      denorm_min() noexcept { return false; }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-
-
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<char>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr char
-      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
-
-      static constexpr char
-      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
-
-
-      static constexpr char
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = ((char)(-1) < 0);
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr char
-      epsilon() noexcept { return 0; }
-
-      static constexpr char
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr
-      char infinity() noexcept { return char(); }
-
-      static constexpr char
-      quiet_NaN() noexcept { return char(); }
-
-      static constexpr char
-      signaling_NaN() noexcept { return char(); }
-
-      static constexpr char
-      denorm_min() noexcept { return static_cast<char>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = !is_signed;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<signed char>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr signed char
-      min() noexcept { return -127 - 1; }
-
-      static constexpr signed char
-      max() noexcept { return 127; }
-
-
-      static constexpr signed char
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr signed char
-      epsilon() noexcept { return 0; }
-
-      static constexpr signed char
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr signed char
-      infinity() noexcept { return static_cast<signed char>(0); }
-
-      static constexpr signed char
-      quiet_NaN() noexcept { return static_cast<signed char>(0); }
-
-      static constexpr signed char
-      signaling_NaN() noexcept
-      { return static_cast<signed char>(0); }
-
-      static constexpr signed char
-      denorm_min() noexcept
-      { return static_cast<signed char>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<unsigned char>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr unsigned char
-      min() noexcept { return 0; }
-
-      static constexpr unsigned char
-      max() noexcept { return 127 * 2U + 1; }
-
-
-      static constexpr unsigned char
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr unsigned char
-      epsilon() noexcept { return 0; }
-
-      static constexpr unsigned char
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr unsigned char
-      infinity() noexcept
-      { return static_cast<unsigned char>(0); }
-
-      static constexpr unsigned char
-      quiet_NaN() noexcept
-      { return static_cast<unsigned char>(0); }
-
-      static constexpr unsigned char
-      signaling_NaN() noexcept
-      { return static_cast<unsigned char>(0); }
-
-      static constexpr unsigned char
-      denorm_min() noexcept
-      { return static_cast<unsigned char>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = true;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<wchar_t>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr wchar_t
-      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
-
-      static constexpr wchar_t
-      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
-
-
-      static constexpr wchar_t
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr wchar_t
-      epsilon() noexcept { return 0; }
-
-      static constexpr wchar_t
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr wchar_t
-      infinity() noexcept { return wchar_t(); }
-
-      static constexpr wchar_t
-      quiet_NaN() noexcept { return wchar_t(); }
-
-      static constexpr wchar_t
-      signaling_NaN() noexcept { return wchar_t(); }
-
-      static constexpr wchar_t
-      denorm_min() noexcept { return wchar_t(); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = !is_signed;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-
-  template<>
-    struct numeric_limits<char16_t>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr char16_t
-      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
-
-      static constexpr char16_t
-      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
-
-      static constexpr char16_t
-      lowest() noexcept { return min(); }
-
-      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
-      static constexpr int max_digits10 = 0;
-      static constexpr bool is_signed = ((char16_t)(-1) < 0);
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr char16_t
-      epsilon() noexcept { return 0; }
-
-      static constexpr char16_t
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr char16_t
-      infinity() noexcept { return char16_t(); }
-
-      static constexpr char16_t
-      quiet_NaN() noexcept { return char16_t(); }
-
-      static constexpr char16_t
-      signaling_NaN() noexcept { return char16_t(); }
-
-      static constexpr char16_t
-      denorm_min() noexcept { return char16_t(); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = !is_signed;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<char32_t>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr char32_t
-      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
-
-      static constexpr char32_t
-      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
-
-      static constexpr char32_t
-      lowest() noexcept { return min(); }
-
-      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
-      static constexpr int max_digits10 = 0;
-      static constexpr bool is_signed = ((char32_t)(-1) < 0);
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr char32_t
-      epsilon() noexcept { return 0; }
-
-      static constexpr char32_t
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr char32_t
-      infinity() noexcept { return char32_t(); }
-
-      static constexpr char32_t
-      quiet_NaN() noexcept { return char32_t(); }
-
-      static constexpr char32_t
-      signaling_NaN() noexcept { return char32_t(); }
-
-      static constexpr char32_t
-      denorm_min() noexcept { return char32_t(); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = !is_signed;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style = round_toward_zero;
-    };
-
-
-
-  template<>
-    struct numeric_limits<short>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr short
-      min() noexcept { return -32767 - 1; }
-
-      static constexpr short
-      max() noexcept { return 32767; }
-
-
-      static constexpr short
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr short
-      epsilon() noexcept { return 0; }
-
-      static constexpr short
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr short
-      infinity() noexcept { return short(); }
-
-      static constexpr short
-      quiet_NaN() noexcept { return short(); }
-
-      static constexpr short
-      signaling_NaN() noexcept { return short(); }
-
-      static constexpr short
-      denorm_min() noexcept { return short(); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<unsigned short>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr unsigned short
-      min() noexcept { return 0; }
-
-      static constexpr unsigned short
-      max() noexcept { return 32767 * 2U + 1; }
-
-
-      static constexpr unsigned short
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr unsigned short
-      epsilon() noexcept { return 0; }
-
-      static constexpr unsigned short
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr unsigned short
-      infinity() noexcept
-      { return static_cast<unsigned short>(0); }
-
-      static constexpr unsigned short
-      quiet_NaN() noexcept
-      { return static_cast<unsigned short>(0); }
-
-      static constexpr unsigned short
-      signaling_NaN() noexcept
-      { return static_cast<unsigned short>(0); }
-
-      static constexpr unsigned short
-      denorm_min() noexcept
-      { return static_cast<unsigned short>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = true;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<int>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr int
-      min() noexcept { return -2147483647 - 1; }
-
-      static constexpr int
-      max() noexcept { return 2147483647; }
-
-
-      static constexpr int
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr int
-      epsilon() noexcept { return 0; }
-
-      static constexpr int
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr int
-      infinity() noexcept { return static_cast<int>(0); }
-
-      static constexpr int
-      quiet_NaN() noexcept { return static_cast<int>(0); }
-
-      static constexpr int
-      signaling_NaN() noexcept { return static_cast<int>(0); }
-
-      static constexpr int
-      denorm_min() noexcept { return static_cast<int>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<unsigned int>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr unsigned int
-      min() noexcept { return 0; }
-
-      static constexpr unsigned int
-      max() noexcept { return 2147483647 * 2U + 1; }
-
-
-      static constexpr unsigned int
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr unsigned int
-      epsilon() noexcept { return 0; }
-
-      static constexpr unsigned int
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr unsigned int
-      infinity() noexcept { return static_cast<unsigned int>(0); }
-
-      static constexpr unsigned int
-      quiet_NaN() noexcept
-      { return static_cast<unsigned int>(0); }
-
-      static constexpr unsigned int
-      signaling_NaN() noexcept
-      { return static_cast<unsigned int>(0); }
-
-      static constexpr unsigned int
-      denorm_min() noexcept
-      { return static_cast<unsigned int>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = true;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<long>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr long
-      min() noexcept { return -9223372036854775807L - 1; }
-
-      static constexpr long
-      max() noexcept { return 9223372036854775807L; }
-
-
-      static constexpr long
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
-      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr long
-      epsilon() noexcept { return 0; }
-
-      static constexpr long
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr long
-      infinity() noexcept { return static_cast<long>(0); }
-
-      static constexpr long
-      quiet_NaN() noexcept { return static_cast<long>(0); }
-
-      static constexpr long
-      signaling_NaN() noexcept { return static_cast<long>(0); }
-
-      static constexpr long
-      denorm_min() noexcept { return static_cast<long>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<unsigned long>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr unsigned long
-      min() noexcept { return 0; }
-
-      static constexpr unsigned long
-      max() noexcept { return 9223372036854775807L * 2UL + 1; }
-
-
-      static constexpr unsigned long
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr unsigned long
-      epsilon() noexcept { return 0; }
-
-      static constexpr unsigned long
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr unsigned long
-      infinity() noexcept
-      { return static_cast<unsigned long>(0); }
-
-      static constexpr unsigned long
-      quiet_NaN() noexcept
-      { return static_cast<unsigned long>(0); }
-
-      static constexpr unsigned long
-      signaling_NaN() noexcept
-      { return static_cast<unsigned long>(0); }
-
-      static constexpr unsigned long
-      denorm_min() noexcept
-      { return static_cast<unsigned long>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = true;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<long long>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr long long
-      min() noexcept { return -9223372036854775807LL - 1; }
-
-      static constexpr long long
-      max() noexcept { return 9223372036854775807LL; }
-
-
-      static constexpr long long
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr long long
-      epsilon() noexcept { return 0; }
-
-      static constexpr long long
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr long long
-      infinity() noexcept { return static_cast<long long>(0); }
-
-      static constexpr long long
-      quiet_NaN() noexcept { return static_cast<long long>(0); }
-
-      static constexpr long long
-      signaling_NaN() noexcept
-      { return static_cast<long long>(0); }
-
-      static constexpr long long
-      denorm_min() noexcept { return static_cast<long long>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-
-
-  template<>
-    struct numeric_limits<unsigned long long>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr unsigned long long
-      min() noexcept { return 0; }
-
-      static constexpr unsigned long long
-      max() noexcept { return 9223372036854775807LL * 2ULL + 1; }
-
-
-      static constexpr unsigned long long
-      lowest() noexcept { return min(); }
-
-
-      static constexpr int digits
-       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
-      static constexpr int digits10
-       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
-
-      static constexpr int max_digits10 = 0;
-
-      static constexpr bool is_signed = false;
-      static constexpr bool is_integer = true;
-      static constexpr bool is_exact = true;
-      static constexpr int radix = 2;
-
-      static constexpr unsigned long long
-      epsilon() noexcept { return 0; }
-
-      static constexpr unsigned long long
-      round_error() noexcept { return 0; }
-
-      static constexpr int min_exponent = 0;
-      static constexpr int min_exponent10 = 0;
-      static constexpr int max_exponent = 0;
-      static constexpr int max_exponent10 = 0;
-
-      static constexpr bool has_infinity = false;
-      static constexpr bool has_quiet_NaN = false;
-      static constexpr bool has_signaling_NaN = false;
-      static constexpr float_denorm_style has_denorm
-       = denorm_absent;
-      static constexpr bool has_denorm_loss = false;
-
-      static constexpr unsigned long long
-      infinity() noexcept
-      { return static_cast<unsigned long long>(0); }
-
-      static constexpr unsigned long long
-      quiet_NaN() noexcept
-      { return static_cast<unsigned long long>(0); }
-
-      static constexpr unsigned long long
-      signaling_NaN() noexcept
-      { return static_cast<unsigned long long>(0); }
-
-      static constexpr unsigned long long
-      denorm_min() noexcept
-      { return static_cast<unsigned long long>(0); }
-
-      static constexpr bool is_iec559 = false;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = true;
-
-      static constexpr bool traps = true;
-      static constexpr bool tinyness_before = false;
-      static constexpr float_round_style round_style
-       = round_toward_zero;
-    };
-# 1592 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/limits" 3
-  template<>
-    struct numeric_limits<float>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr float
-      min() noexcept { return 1.17549435e-38F; }
-
-      static constexpr float
-      max() noexcept { return 3.40282347e+38F; }
-
-
-      static constexpr float
-      lowest() noexcept { return -3.40282347e+38F; }
-
-
-      static constexpr int digits = 24;
-      static constexpr int digits10 = 6;
-
-      static constexpr int max_digits10
-  = (2 + (24) * 643L / 2136);
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = false;
-      static constexpr bool is_exact = false;
-      static constexpr int radix = 2;
-
-      static constexpr float
-      epsilon() noexcept { return 1.19209290e-7F; }
-
-      static constexpr float
-      round_error() noexcept { return 0.5F; }
-
-      static constexpr int min_exponent = (-125);
-      static constexpr int min_exponent10 = (-37);
-      static constexpr int max_exponent = 128;
-      static constexpr int max_exponent10 = 38;
-
-      static constexpr bool has_infinity = 1;
-      static constexpr bool has_quiet_NaN = 1;
-      static constexpr bool has_signaling_NaN = has_quiet_NaN;
-      static constexpr float_denorm_style has_denorm
- = bool(1) ? denorm_present : denorm_absent;
-      static constexpr bool has_denorm_loss
-       = false;
-
-      static constexpr float
-      infinity() noexcept { return __builtin_huge_valf(); }
-
-      static constexpr float
-      quiet_NaN() noexcept { return __builtin_nanf(""); }
-
-      static constexpr float
-      signaling_NaN() noexcept { return __builtin_nansf(""); }
-
-      static constexpr float
-      denorm_min() noexcept { return 1.40129846e-45F; }
-
-      static constexpr bool is_iec559
- = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = false;
-      static constexpr bool tinyness_before
-       = false;
-      static constexpr float_round_style round_style
-       = round_to_nearest;
-    };
-
-
-
-
-
-
-  template<>
-    struct numeric_limits<double>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr double
-      min() noexcept { return 2.2250738585072014e-308; }
-
-      static constexpr double
-      max() noexcept { return 1.7976931348623157e+308; }
-
-
-      static constexpr double
-      lowest() noexcept { return -1.7976931348623157e+308; }
-
-
-      static constexpr int digits = 53;
-      static constexpr int digits10 = 15;
-
-      static constexpr int max_digits10
-  = (2 + (53) * 643L / 2136);
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = false;
-      static constexpr bool is_exact = false;
-      static constexpr int radix = 2;
-
-      static constexpr double
-      epsilon() noexcept { return 2.2204460492503131e-16; }
-
-      static constexpr double
-      round_error() noexcept { return 0.5; }
-
-      static constexpr int min_exponent = (-1021);
-      static constexpr int min_exponent10 = (-307);
-      static constexpr int max_exponent = 1024;
-      static constexpr int max_exponent10 = 308;
-
-      static constexpr bool has_infinity = 1;
-      static constexpr bool has_quiet_NaN = 1;
-      static constexpr bool has_signaling_NaN = has_quiet_NaN;
-      static constexpr float_denorm_style has_denorm
- = bool(1) ? denorm_present : denorm_absent;
-      static constexpr bool has_denorm_loss
-        = false;
-
-      static constexpr double
-      infinity() noexcept { return __builtin_huge_val(); }
-
-      static constexpr double
-      quiet_NaN() noexcept { return __builtin_nan(""); }
-
-      static constexpr double
-      signaling_NaN() noexcept { return __builtin_nans(""); }
-
-      static constexpr double
-      denorm_min() noexcept { return 4.9406564584124654e-324; }
-
-      static constexpr bool is_iec559
- = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = false;
-      static constexpr bool tinyness_before
-       = false;
-      static constexpr float_round_style round_style
-       = round_to_nearest;
-    };
-
-
-
-
-
-
-  template<>
-    struct numeric_limits<long double>
-    {
-      static constexpr bool is_specialized = true;
-
-      static constexpr long double
-      min() noexcept { return 3.36210314311209350626e-4932L; }
-
-      static constexpr long double
-      max() noexcept { return 1.18973149535723176502e+4932L; }
-
-
-      static constexpr long double
-      lowest() noexcept { return -1.18973149535723176502e+4932L; }
-
-
-      static constexpr int digits = 64;
-      static constexpr int digits10 = 18;
-
-      static constexpr int max_digits10
-  = (2 + (64) * 643L / 2136);
-
-      static constexpr bool is_signed = true;
-      static constexpr bool is_integer = false;
-      static constexpr bool is_exact = false;
-      static constexpr int radix = 2;
-
-      static constexpr long double
-      epsilon() noexcept { return 1.08420217248550443401e-19L; }
-
-      static constexpr long double
-      round_error() noexcept { return 0.5L; }
-
-      static constexpr int min_exponent = (-16381);
-      static constexpr int min_exponent10 = (-4931);
-      static constexpr int max_exponent = 16384;
-      static constexpr int max_exponent10 = 4932;
-
-      static constexpr bool has_infinity = 1;
-      static constexpr bool has_quiet_NaN = 1;
-      static constexpr bool has_signaling_NaN = has_quiet_NaN;
-      static constexpr float_denorm_style has_denorm
- = bool(1) ? denorm_present : denorm_absent;
-      static constexpr bool has_denorm_loss
- = false;
-
-      static constexpr long double
-      infinity() noexcept { return __builtin_huge_vall(); }
-
-      static constexpr long double
-      quiet_NaN() noexcept { return __builtin_nanl(""); }
-
-      static constexpr long double
-      signaling_NaN() noexcept { return __builtin_nansl(""); }
-
-      static constexpr long double
-      denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
-
-      static constexpr bool is_iec559
- = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
-      static constexpr bool is_bounded = true;
-      static constexpr bool is_modulo = false;
-
-      static constexpr bool traps = false;
-      static constexpr bool tinyness_before =
-      false;
-      static constexpr float_round_style round_style =
-            round_to_nearest;
-    };
-
-
-
-
-
-
-}
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-  namespace __detail
-  {
-
-
-    template<typename _Tp>
-      inline bool
-      _Power_of_2(_Tp __x)
-      {
- return ((__x - 1) & __x) == 0;
-      };
-
-  }
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
-  template<typename _IntType = int>
-    class uniform_int_distribution
-    {
-      static_assert(std::is_integral<_IntType>::value,
-      "template argument not an integral type");
-
-    public:
-
-      typedef _IntType result_type;
-
-      struct param_type
-      {
- typedef uniform_int_distribution<_IntType> distribution_type;
-
- explicit
- param_type(_IntType __a = 0,
-     _IntType __b = std::numeric_limits<_IntType>::max())
- : _M_a(__a), _M_b(__b)
- {
-                                 ;
- }
-
- result_type
- a() const
- { return _M_a; }
-
- result_type
- b() const
- { return _M_b; }
-
- friend bool
- operator==(const param_type& __p1, const param_type& __p2)
- { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
-
-      private:
- _IntType _M_a;
- _IntType _M_b;
-      };
-
-    public:
-
-
-
-      explicit
-      uniform_int_distribution(_IntType __a = 0,
-      _IntType __b = std::numeric_limits<_IntType>::max())
-      : _M_param(__a, __b)
-      { }
-
-      explicit
-      uniform_int_distribution(const param_type& __p)
-      : _M_param(__p)
-      { }
-
-
-
-
-
-
-      void
-      reset() { }
-
-      result_type
-      a() const
-      { return _M_param.a(); }
-
-      result_type
-      b() const
-      { return _M_param.b(); }
-
-
-
-
-      param_type
-      param() const
-      { return _M_param; }
-
-
-
-
-
-      void
-      param(const param_type& __param)
-      { _M_param = __param; }
-
-
-
-
-      result_type
-      min() const
-      { return this->a(); }
-
-
-
-
-      result_type
-      max() const
-      { return this->b(); }
-
-
-
-
-      template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng)
-        { return this->operator()(__urng, _M_param); }
-
-      template<typename _UniformRandomNumberGenerator>
- result_type
- operator()(_UniformRandomNumberGenerator& __urng,
-     const param_type& __p);
-
-      template<typename _ForwardIterator,
-        typename _UniformRandomNumberGenerator>
- void
- __generate(_ForwardIterator __f, _ForwardIterator __t,
-     _UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, _M_param); }
-
-      template<typename _ForwardIterator,
-        typename _UniformRandomNumberGenerator>
- void
- __generate(_ForwardIterator __f, _ForwardIterator __t,
-     _UniformRandomNumberGenerator& __urng,
-     const param_type& __p)
- { this->__generate_impl(__f, __t, __urng, __p); }
-
-      template<typename _UniformRandomNumberGenerator>
- void
- __generate(result_type* __f, result_type* __t,
-     _UniformRandomNumberGenerator& __urng,
-     const param_type& __p)
- { this->__generate_impl(__f, __t, __urng, __p); }
-
-
-
-
-
-      friend bool
-      operator==(const uniform_int_distribution& __d1,
-   const uniform_int_distribution& __d2)
-      { return __d1._M_param == __d2._M_param; }
-
-    private:
-      template<typename _ForwardIterator,
-        typename _UniformRandomNumberGenerator>
- void
- __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
-   _UniformRandomNumberGenerator& __urng,
-   const param_type& __p);
-
-      param_type _M_param;
-    };
-
-  template<typename _IntType>
-    template<typename _UniformRandomNumberGenerator>
-      typename uniform_int_distribution<_IntType>::result_type
-      uniform_int_distribution<_IntType>::
-      operator()(_UniformRandomNumberGenerator& __urng,
-   const param_type& __param)
-      {
- typedef typename _UniformRandomNumberGenerator::result_type
-   _Gresult_type;
- typedef typename std::make_unsigned<result_type>::type __utype;
- typedef typename std::common_type<_Gresult_type, __utype>::type
-   __uctype;
-
- const __uctype __urngmin = __urng.min();
- const __uctype __urngmax = __urng.max();
- const __uctype __urngrange = __urngmax - __urngmin;
- const __uctype __urange
-   = __uctype(__param.b()) - __uctype(__param.a());
-
- __uctype __ret;
-
- if (__urngrange > __urange)
-   {
-
-     const __uctype __uerange = __urange + 1;
-     const __uctype __scaling = __urngrange / __uerange;
-     const __uctype __past = __uerange * __scaling;
-     do
-       __ret = __uctype(__urng()) - __urngmin;
-     while (__ret >= __past);
-     __ret /= __scaling;
-   }
- else if (__urngrange < __urange)
-   {
-# 263 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
-     __uctype __tmp;
-     do
-       {
-  const __uctype __uerngrange = __urngrange + 1;
-  __tmp = (__uerngrange * operator()
-    (__urng, param_type(0, __urange / __uerngrange)));
-  __ret = __tmp + (__uctype(__urng()) - __urngmin);
-       }
-     while (__ret > __urange || __ret < __tmp);
-   }
- else
-   __ret = __uctype(__urng()) - __urngmin;
-
- return __ret + __param.a();
-      }
-
-
-  template<typename _IntType>
-    template<typename _ForwardIterator,
-      typename _UniformRandomNumberGenerator>
-      void
-      uniform_int_distribution<_IntType>::
-      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
-        _UniformRandomNumberGenerator& __urng,
-        const param_type& __param)
-      {
-
- typedef typename _UniformRandomNumberGenerator::result_type
-   _Gresult_type;
- typedef typename std::make_unsigned<result_type>::type __utype;
- typedef typename std::common_type<_Gresult_type, __utype>::type
-   __uctype;
-
- const __uctype __urngmin = __urng.min();
- const __uctype __urngmax = __urng.max();
- const __uctype __urngrange = __urngmax - __urngmin;
- const __uctype __urange
-   = __uctype(__param.b()) - __uctype(__param.a());
-
- __uctype __ret;
-
- if (__urngrange > __urange)
-   {
-     if (__detail::_Power_of_2(__urngrange + 1)
-  && __detail::_Power_of_2(__urange + 1))
-       {
-  while (__f != __t)
-    {
-      __ret = __uctype(__urng()) - __urngmin;
-      *__f++ = (__ret & __urange) + __param.a();
-    }
-       }
-     else
-       {
-
-  const __uctype __uerange = __urange + 1;
-  const __uctype __scaling = __urngrange / __uerange;
-  const __uctype __past = __uerange * __scaling;
-  while (__f != __t)
-    {
-      do
-        __ret = __uctype(__urng()) - __urngmin;
-      while (__ret >= __past);
-      *__f++ = __ret / __scaling + __param.a();
-    }
-       }
-   }
- else if (__urngrange < __urange)
-   {
-# 347 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uniform_int_dist.h" 3
-     __uctype __tmp;
-     while (__f != __t)
-       {
-  do
-    {
-      const __uctype __uerngrange = __urngrange + 1;
-      __tmp = (__uerngrange * operator()
-        (__urng, param_type(0, __urange / __uerngrange)));
-      __ret = __tmp + (__uctype(__urng()) - __urngmin);
-    }
-  while (__ret > __urange || __ret < __tmp);
-  *__f++ = __ret;
-       }
-   }
- else
-   while (__f != __t)
-     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
-      }
-
-
-}
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 2 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _Iterator, typename _Compare>
-    void
-    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
-      _Iterator __c, _Compare __comp)
-    {
-      if (__comp(__a, __b))
- {
-   if (__comp(__b, __c))
-     std::iter_swap(__result, __b);
-   else if (__comp(__a, __c))
-     std::iter_swap(__result, __c);
-   else
-     std::iter_swap(__result, __a);
- }
-      else if (__comp(__a, __c))
- std::iter_swap(__result, __a);
-      else if (__comp(__b, __c))
- std::iter_swap(__result, __c);
-      else
- std::iter_swap(__result, __b);
-    }
-
-
-  template<typename _InputIterator, typename _Predicate>
-    inline _InputIterator
-    __find_if(_InputIterator __first, _InputIterator __last,
-       _Predicate __pred, input_iterator_tag)
-    {
-      while (__first != __last && !__pred(__first))
- ++__first;
-      return __first;
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Predicate>
-    _RandomAccessIterator
-    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       _Predicate __pred, random_access_iterator_tag)
-    {
-      typename iterator_traits<_RandomAccessIterator>::difference_type
- __trip_count = (__last - __first) >> 2;
-
-      for (; __trip_count > 0; --__trip_count)
- {
-   if (__pred(__first))
-     return __first;
-   ++__first;
-
-   if (__pred(__first))
-     return __first;
-   ++__first;
-
-   if (__pred(__first))
-     return __first;
-   ++__first;
-
-   if (__pred(__first))
-     return __first;
-   ++__first;
- }
-
-      switch (__last - __first)
- {
- case 3:
-   if (__pred(__first))
-     return __first;
-   ++__first;
- case 2:
-   if (__pred(__first))
-     return __first;
-   ++__first;
- case 1:
-   if (__pred(__first))
-     return __first;
-   ++__first;
- case 0:
- default:
-   return __last;
- }
-    }
-
-  template<typename _Iterator, typename _Predicate>
-    inline _Iterator
-    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
-    {
-      return __find_if(__first, __last, __pred,
-         std::__iterator_category(__first));
-    }
-
-
-  template<typename _InputIterator, typename _Predicate>
-    inline _InputIterator
-    __find_if_not(_InputIterator __first, _InputIterator __last,
-    _Predicate __pred)
-    {
-      return std::__find_if(__first, __last,
-       __gnu_cxx::__ops::__negate(__pred),
-       std::__iterator_category(__first));
-    }
-
-
-
-
-  template<typename _InputIterator, typename _Predicate, typename _Distance>
-    _InputIterator
-    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
-    {
-      for (; __len; --__len, ++__first)
- if (!__pred(__first))
-   break;
-      return __first;
-    }
-# 202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    _ForwardIterator1
-    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-      _BinaryPredicate __predicate)
-    {
-
-      if (__first1 == __last1 || __first2 == __last2)
- return __first1;
-
-
-      _ForwardIterator2 __p1(__first2);
-      if (++__p1 == __last2)
- return std::__find_if(__first1, __last1,
-  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
-
-
-      _ForwardIterator2 __p;
-      _ForwardIterator1 __current = __first1;
-
-      for (;;)
- {
-   __first1 =
-     std::__find_if(__first1, __last1,
-  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
-
-   if (__first1 == __last1)
-     return __last1;
-
-   __p = __p1;
-   __current = __first1;
-   if (++__current == __last1)
-     return __last1;
-
-   while (__predicate(__current, __p))
-     {
-       if (++__p == __last2)
-  return __first1;
-       if (++__current == __last1)
-  return __last1;
-     }
-   ++__first1;
- }
-      return __first1;
-    }
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Integer,
-    typename _UnaryPredicate>
-    _ForwardIterator
-    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
-     _Integer __count, _UnaryPredicate __unary_pred,
-     std::forward_iterator_tag)
-    {
-      __first = std::__find_if(__first, __last, __unary_pred);
-      while (__first != __last)
- {
-   typename iterator_traits<_ForwardIterator>::difference_type
-     __n = __count;
-   _ForwardIterator __i = __first;
-   ++__i;
-   while (__i != __last && __n != 1 && __unary_pred(__i))
-     {
-       ++__i;
-       --__n;
-     }
-   if (__n == 1)
-     return __first;
-   if (__i == __last)
-     return __last;
-   __first = std::__find_if(++__i, __last, __unary_pred);
- }
-      return __last;
-    }
-
-
-
-
-
-  template<typename _RandomAccessIter, typename _Integer,
-    typename _UnaryPredicate>
-    _RandomAccessIter
-    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
-     _Integer __count, _UnaryPredicate __unary_pred,
-     std::random_access_iterator_tag)
-    {
-      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
- _DistanceType;
-
-      _DistanceType __tailSize = __last - __first;
-      _DistanceType __remainder = __count;
-
-      while (__remainder <= __tailSize)
- {
-   __first += __remainder;
-   __tailSize -= __remainder;
-
-
-   _RandomAccessIter __backTrack = __first;
-   while (__unary_pred(--__backTrack))
-     {
-       if (--__remainder == 0)
-  return (__first - __count);
-     }
-   __remainder = __count + 1 - (__first - __backTrack);
- }
-      return __last;
-    }
-
-  template<typename _ForwardIterator, typename _Integer,
-    typename _UnaryPredicate>
-    _ForwardIterator
-    __search_n(_ForwardIterator __first, _ForwardIterator __last,
-        _Integer __count,
-        _UnaryPredicate __unary_pred)
-    {
-      if (__count <= 0)
- return __first;
-
-      if (__count == 1)
- return std::__find_if(__first, __last, __unary_pred);
-
-      return std::__search_n_aux(__first, __last, __count, __unary_pred,
-     std::__iterator_category(__first));
-    }
-
-
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    _ForwardIterator1
-    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-        forward_iterator_tag, forward_iterator_tag,
-        _BinaryPredicate __comp)
-    {
-      if (__first2 == __last2)
- return __last1;
-
-      _ForwardIterator1 __result = __last1;
-      while (1)
- {
-   _ForwardIterator1 __new_result
-     = std::__search(__first1, __last1, __first2, __last2, __comp);
-   if (__new_result == __last1)
-     return __result;
-   else
-     {
-       __result = __new_result;
-       __first1 = __new_result;
-       ++__first1;
-     }
- }
-    }
-
-
-  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
-    typename _BinaryPredicate>
-    _BidirectionalIterator1
-    __find_end(_BidirectionalIterator1 __first1,
-        _BidirectionalIterator1 __last1,
-        _BidirectionalIterator2 __first2,
-        _BidirectionalIterator2 __last2,
-        bidirectional_iterator_tag, bidirectional_iterator_tag,
-        _BinaryPredicate __comp)
-    {
-
-
-
-
-
-
-      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
-      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
-
-      _RevIterator1 __rlast1(__first1);
-      _RevIterator2 __rlast2(__first2);
-      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
-           _RevIterator2(__last2), __rlast2,
-           __comp);
-
-      if (__rresult == __rlast1)
- return __last1;
-      else
- {
-   _BidirectionalIterator1 __result = __rresult.base();
-   std::advance(__result, -std::distance(__first2, __last2));
-   return __result;
- }
-    }
-# 423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline _ForwardIterator1
-    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__find_end(__first1, __last1, __first2, __last2,
-        std::__iterator_category(__first1),
-        std::__iterator_category(__first2),
-        __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 471 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    inline _ForwardIterator1
-    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-      _BinaryPredicate __comp)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__find_end(__first1, __last1, __first2, __last2,
-        std::__iterator_category(__first1),
-        std::__iterator_category(__first2),
-        __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 506 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline bool
-    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-    { return __last == std::find_if_not(__first, __last, __pred); }
-# 523 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline bool
-    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-    { return __last == std::find_if(__first, __last, __pred); }
-# 541 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline bool
-    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-    { return !std::none_of(__first, __last, __pred); }
-# 556 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline _InputIterator
-    find_if_not(_InputIterator __first, _InputIterator __last,
-  _Predicate __pred)
-    {
-
-
-
-
-                                                     ;
-      return std::__find_if_not(__first, __last,
-    __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-# 580 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline bool
-    is_partitioned(_InputIterator __first, _InputIterator __last,
-     _Predicate __pred)
-    {
-      __first = std::find_if_not(__first, __last, __pred);
-      return std::none_of(__first, __last, __pred);
-    }
-# 598 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Predicate>
-    _ForwardIterator
-    partition_point(_ForwardIterator __first, _ForwardIterator __last,
-      _Predicate __pred)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _DistanceType __len = std::distance(__first, __last);
-      _DistanceType __half;
-      _ForwardIterator __middle;
-
-      while (__len > 0)
- {
-   __half = __len >> 1;
-   __middle = __first;
-   std::advance(__middle, __half);
-   if (__pred(*__middle))
-     {
-       __first = __middle;
-       ++__first;
-       __len = __len - __half - 1;
-     }
-   else
-     __len = __half;
- }
-      return __first;
-    }
-
-
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Predicate>
-    _OutputIterator
-    __remove_copy_if(_InputIterator __first, _InputIterator __last,
-       _OutputIterator __result, _Predicate __pred)
-    {
-      for (; __first != __last; ++__first)
- if (!__pred(__first))
-   {
-     *__result = *__first;
-     ++__result;
-   }
-      return __result;
-    }
-# 665 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
-    inline _OutputIterator
-    remove_copy(_InputIterator __first, _InputIterator __last,
-  _OutputIterator __result, const _Tp& __value)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__remove_copy_if(__first, __last, __result,
- __gnu_cxx::__ops::__iter_equals_val(__value));
-    }
-# 697 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Predicate>
-    inline _OutputIterator
-    remove_copy_if(_InputIterator __first, _InputIterator __last,
-     _OutputIterator __result, _Predicate __pred)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__remove_copy_if(__first, __last, __result,
-       __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-# 731 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Predicate>
-    _OutputIterator
-    copy_if(_InputIterator __first, _InputIterator __last,
-     _OutputIterator __result, _Predicate __pred)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      for (; __first != __last; ++__first)
- if (__pred(*__first))
-   {
-     *__result = *__first;
-     ++__result;
-   }
-      return __result;
-    }
-
-  template<typename _InputIterator, typename _Size, typename _OutputIterator>
-    _OutputIterator
-    __copy_n(_InputIterator __first, _Size __n,
-      _OutputIterator __result, input_iterator_tag)
-    {
-      if (__n > 0)
- {
-   while (true)
-     {
-       *__result = *__first;
-       ++__result;
-       if (--__n > 0)
-  ++__first;
-       else
-  break;
-     }
- }
-      return __result;
-    }
-
-  template<typename _RandomAccessIterator, typename _Size,
-    typename _OutputIterator>
-    inline _OutputIterator
-    __copy_n(_RandomAccessIterator __first, _Size __n,
-      _OutputIterator __result, random_access_iterator_tag)
-    { return std::copy(__first, __first + __n, __result); }
-# 794 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Size, typename _OutputIterator>
-    inline _OutputIterator
-    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
-    {
-
-
-
-
-
-      return std::__copy_n(__first, __n, __result,
-      std::__iterator_category(__first));
-    }
-# 822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator1,
-    typename _OutputIterator2, typename _Predicate>
-    pair<_OutputIterator1, _OutputIterator2>
-    partition_copy(_InputIterator __first, _InputIterator __last,
-     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
-     _Predicate __pred)
-    {
-# 837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                     ;
-
-      for (; __first != __last; ++__first)
- if (__pred(*__first))
-   {
-     *__out_true = *__first;
-     ++__out_true;
-   }
- else
-   {
-     *__out_false = *__first;
-     ++__out_false;
-   }
-
-      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
-    }
-
-
-  template<typename _ForwardIterator, typename _Predicate>
-    _ForwardIterator
-    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
-  _Predicate __pred)
-    {
-      __first = std::__find_if(__first, __last, __pred);
-      if (__first == __last)
- return __first;
-      _ForwardIterator __result = __first;
-      ++__first;
-      for (; __first != __last; ++__first)
- if (!__pred(__first))
-   {
-     *__result = std::move(*__first);
-     ++__result;
-   }
-      return __result;
-    }
-# 891 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline _ForwardIterator
-    remove(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __value)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__remove_if(__first, __last,
-  __gnu_cxx::__ops::__iter_equals_val(__value));
-    }
-# 924 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Predicate>
-    inline _ForwardIterator
-    remove_if(_ForwardIterator __first, _ForwardIterator __last,
-       _Predicate __pred)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__remove_if(__first, __last,
-         __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-
-  template<typename _ForwardIterator, typename _BinaryPredicate>
-    _ForwardIterator
-    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
-      _BinaryPredicate __binary_pred)
-    {
-      if (__first == __last)
- return __last;
-      _ForwardIterator __next = __first;
-      while (++__next != __last)
- {
-   if (__binary_pred(__first, __next))
-     return __first;
-   __first = __next;
- }
-      return __last;
-    }
-
-  template<typename _ForwardIterator, typename _BinaryPredicate>
-    _ForwardIterator
-    __unique(_ForwardIterator __first, _ForwardIterator __last,
-      _BinaryPredicate __binary_pred)
-    {
-
-      __first = std::__adjacent_find(__first, __last, __binary_pred);
-      if (__first == __last)
- return __last;
-
-
-      _ForwardIterator __dest = __first;
-      ++__first;
-      while (++__first != __last)
- if (!__binary_pred(__dest, __first))
-   *++__dest = std::move(*__first);
-      return ++__dest;
-    }
-# 990 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    inline _ForwardIterator
-    unique(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__unique(__first, __last,
-      __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 1020 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _BinaryPredicate>
-    inline _ForwardIterator
-    unique(_ForwardIterator __first, _ForwardIterator __last,
-    _BinaryPredicate __binary_pred)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__unique(__first, __last,
-      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _OutputIterator,
-    typename _BinaryPredicate>
-    _OutputIterator
-    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
-    _OutputIterator __result, _BinaryPredicate __binary_pred,
-    forward_iterator_tag, output_iterator_tag)
-    {
-
-
-
-
-
-      _ForwardIterator __next = __first;
-      *__result = *__first;
-      while (++__next != __last)
- if (!__binary_pred(__first, __next))
-   {
-     __first = __next;
-     *++__result = *__first;
-   }
-      return ++__result;
-    }
-
-
-
-
-
-
-
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _BinaryPredicate>
-    _OutputIterator
-    __unique_copy(_InputIterator __first, _InputIterator __last,
-    _OutputIterator __result, _BinaryPredicate __binary_pred,
-    input_iterator_tag, output_iterator_tag)
-    {
-
-
-
-
-
-      typename iterator_traits<_InputIterator>::value_type __value = *__first;
-      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
- __rebound_pred
- = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
-      *__result = __value;
-      while (++__first != __last)
- if (!__rebound_pred(__first, __value))
-   {
-     __value = *__first;
-     *++__result = __value;
-   }
-      return ++__result;
-    }
-
-
-
-
-
-
-
-  template<typename _InputIterator, typename _ForwardIterator,
-    typename _BinaryPredicate>
-    _ForwardIterator
-    __unique_copy(_InputIterator __first, _InputIterator __last,
-    _ForwardIterator __result, _BinaryPredicate __binary_pred,
-    input_iterator_tag, forward_iterator_tag)
-    {
-
-
-
-
-      *__result = *__first;
-      while (++__first != __last)
- if (!__binary_pred(__result, __first))
-   *++__result = *__first;
-      return ++__result;
-    }
-
-
-
-
-
-
-  template<typename _BidirectionalIterator>
-    void
-    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
-       bidirectional_iterator_tag)
-    {
-      while (true)
- if (__first == __last || __first == --__last)
-   return;
- else
-   {
-     std::iter_swap(__first, __last);
-     ++__first;
-   }
-    }
-
-
-
-
-
-
-  template<typename _RandomAccessIterator>
-    void
-    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
-       random_access_iterator_tag)
-    {
-      if (__first == __last)
- return;
-      --__last;
-      while (__first < __last)
- {
-   std::iter_swap(__first, __last);
-   ++__first;
-   --__last;
- }
-    }
-# 1175 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator>
-    inline void
-    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
-    {
-
-
-
-                                                     ;
-      std::__reverse(__first, __last, std::__iterator_category(__first));
-    }
-# 1202 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator, typename _OutputIterator>
-    _OutputIterator
-    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
-   _OutputIterator __result)
-    {
-
-
-
-
-
-                                                     ;
-
-      while (__first != __last)
- {
-   --__last;
-   *__result = *__last;
-   ++__result;
- }
-      return __result;
-    }
-
-
-
-
-
-  template<typename _EuclideanRingElement>
-    _EuclideanRingElement
-    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
-    {
-      while (__n != 0)
- {
-   _EuclideanRingElement __t = __m % __n;
-   __m = __n;
-   __n = __t;
- }
-      return __m;
-    }
-
-  inline namespace _V2
-  {
-
-
-  template<typename _ForwardIterator>
-    _ForwardIterator
-    __rotate(_ForwardIterator __first,
-      _ForwardIterator __middle,
-      _ForwardIterator __last,
-      forward_iterator_tag)
-    {
-      if (__first == __middle)
- return __last;
-      else if (__last == __middle)
- return __first;
-
-      _ForwardIterator __first2 = __middle;
-      do
- {
-   std::iter_swap(__first, __first2);
-   ++__first;
-   ++__first2;
-   if (__first == __middle)
-     __middle = __first2;
- }
-      while (__first2 != __last);
-
-      _ForwardIterator __ret = __first;
-
-      __first2 = __middle;
-
-      while (__first2 != __last)
- {
-   std::iter_swap(__first, __first2);
-   ++__first;
-   ++__first2;
-   if (__first == __middle)
-     __middle = __first2;
-   else if (__first2 == __last)
-     __first2 = __middle;
- }
-      return __ret;
-    }
-
-
-  template<typename _BidirectionalIterator>
-    _BidirectionalIterator
-    __rotate(_BidirectionalIterator __first,
-      _BidirectionalIterator __middle,
-      _BidirectionalIterator __last,
-       bidirectional_iterator_tag)
-    {
-
-
-
-
-      if (__first == __middle)
- return __last;
-      else if (__last == __middle)
- return __first;
-
-      std::__reverse(__first, __middle, bidirectional_iterator_tag());
-      std::__reverse(__middle, __last, bidirectional_iterator_tag());
-
-      while (__first != __middle && __middle != __last)
- {
-   std::iter_swap(__first, --__last);
-   ++__first;
- }
-
-      if (__first == __middle)
- {
-   std::__reverse(__middle, __last, bidirectional_iterator_tag());
-   return __last;
- }
-      else
- {
-   std::__reverse(__first, __middle, bidirectional_iterator_tag());
-   return __first;
- }
-    }
-
-
-  template<typename _RandomAccessIterator>
-    _RandomAccessIterator
-    __rotate(_RandomAccessIterator __first,
-      _RandomAccessIterator __middle,
-      _RandomAccessIterator __last,
-      random_access_iterator_tag)
-    {
-
-
-
-
-      if (__first == __middle)
- return __last;
-      else if (__last == __middle)
- return __first;
-
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
- _Distance;
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
- _ValueType;
-
-      _Distance __n = __last - __first;
-      _Distance __k = __middle - __first;
-
-      if (__k == __n - __k)
- {
-   std::swap_ranges(__first, __middle, __middle);
-   return __middle;
- }
-
-      _RandomAccessIterator __p = __first;
-      _RandomAccessIterator __ret = __first + (__last - __middle);
-
-      for (;;)
- {
-   if (__k < __n - __k)
-     {
-       if (__is_pod(_ValueType) && __k == 1)
-  {
-    _ValueType __t = std::move(*__p);
-    std::move(__p + 1, __p + __n, __p);
-    *(__p + __n - 1) = std::move(__t);
-    return __ret;
-  }
-       _RandomAccessIterator __q = __p + __k;
-       for (_Distance __i = 0; __i < __n - __k; ++ __i)
-  {
-    std::iter_swap(__p, __q);
-    ++__p;
-    ++__q;
-  }
-       __n %= __k;
-       if (__n == 0)
-  return __ret;
-       std::swap(__n, __k);
-       __k = __n - __k;
-     }
-   else
-     {
-       __k = __n - __k;
-       if (__is_pod(_ValueType) && __k == 1)
-  {
-    _ValueType __t = std::move(*(__p + __n - 1));
-    std::move_backward(__p, __p + __n - 1, __p + __n);
-    *__p = std::move(__t);
-    return __ret;
-  }
-       _RandomAccessIterator __q = __p + __n;
-       __p = __q - __k;
-       for (_Distance __i = 0; __i < __n - __k; ++ __i)
-  {
-    --__p;
-    --__q;
-    std::iter_swap(__p, __q);
-  }
-       __n %= __k;
-       if (__n == 0)
-  return __ret;
-       std::swap(__n, __k);
-     }
- }
-    }
-# 1429 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    inline _ForwardIterator
-    rotate(_ForwardIterator __first, _ForwardIterator __middle,
-    _ForwardIterator __last)
-    {
-
-
-
-                                                       ;
-                                                      ;
-
-      return std::__rotate(__first, __middle, __last,
-      std::__iterator_category(__first));
-    }
-
-  }
-# 1466 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _OutputIterator>
-    inline _OutputIterator
-    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
-  _ForwardIterator __last, _OutputIterator __result)
-    {
-
-
-
-
-                                                       ;
-                                                      ;
-
-      return std::copy(__first, __middle,
-         std::copy(__middle, __last, __result));
-    }
-
-
-  template<typename _ForwardIterator, typename _Predicate>
-    _ForwardIterator
-    __partition(_ForwardIterator __first, _ForwardIterator __last,
-  _Predicate __pred, forward_iterator_tag)
-    {
-      if (__first == __last)
- return __first;
-
-      while (__pred(*__first))
- if (++__first == __last)
-   return __first;
-
-      _ForwardIterator __next = __first;
-
-      while (++__next != __last)
- if (__pred(*__next))
-   {
-     std::iter_swap(__first, __next);
-     ++__first;
-   }
-
-      return __first;
-    }
-
-
-  template<typename _BidirectionalIterator, typename _Predicate>
-    _BidirectionalIterator
-    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
-  _Predicate __pred, bidirectional_iterator_tag)
-    {
-      while (true)
- {
-   while (true)
-     if (__first == __last)
-       return __first;
-     else if (__pred(*__first))
-       ++__first;
-     else
-       break;
-   --__last;
-   while (true)
-     if (__first == __last)
-       return __first;
-     else if (!bool(__pred(*__last)))
-       --__last;
-     else
-       break;
-   std::iter_swap(__first, __last);
-   ++__first;
- }
-    }
-# 1543 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
-    typename _Distance>
-    _ForwardIterator
-    __stable_partition_adaptive(_ForwardIterator __first,
-    _ForwardIterator __last,
-    _Predicate __pred, _Distance __len,
-    _Pointer __buffer,
-    _Distance __buffer_size)
-    {
-      if (__len == 1)
- return __first;
-
-      if (__len <= __buffer_size)
- {
-   _ForwardIterator __result1 = __first;
-   _Pointer __result2 = __buffer;
-
-
-
-
-   *__result2 = std::move(*__first);
-   ++__result2;
-   ++__first;
-   for (; __first != __last; ++__first)
-     if (__pred(__first))
-       {
-  *__result1 = std::move(*__first);
-  ++__result1;
-       }
-     else
-       {
-  *__result2 = std::move(*__first);
-  ++__result2;
-       }
-
-   std::move(__buffer, __result2, __result1);
-   return __result1;
- }
-
-      _ForwardIterator __middle = __first;
-      std::advance(__middle, __len / 2);
-      _ForwardIterator __left_split =
- std::__stable_partition_adaptive(__first, __middle, __pred,
-      __len / 2, __buffer,
-      __buffer_size);
-
-
-
-      _Distance __right_len = __len - __len / 2;
-      _ForwardIterator __right_split =
- std::__find_if_not_n(__middle, __right_len, __pred);
-
-      if (__right_len)
- __right_split =
-   std::__stable_partition_adaptive(__right_split, __last, __pred,
-        __right_len,
-        __buffer, __buffer_size);
-
-      std::rotate(__left_split, __middle, __right_split);
-      std::advance(__left_split, std::distance(__middle, __right_split));
-      return __left_split;
-    }
-
-  template<typename _ForwardIterator, typename _Predicate>
-    _ForwardIterator
-    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
-         _Predicate __pred)
-    {
-      __first = std::__find_if_not(__first, __last, __pred);
-
-      if (__first == __last)
- return __first;
-
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
-      return
- std::__stable_partition_adaptive(__first, __last, __pred,
-      _DistanceType(__buf.requested_size()),
-      __buf.begin(),
-      _DistanceType(__buf.size()));
-    }
-# 1646 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Predicate>
-    inline _ForwardIterator
-    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
-       _Predicate __pred)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__stable_partition(__first, __last,
-         __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __heap_select(_RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last, _Compare __comp)
-    {
-      std::__make_heap(__first, __middle, __comp);
-      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
- if (__comp(__i, __first))
-   std::__pop_heap(__first, __middle, __i, __comp);
-    }
-
-
-
-  template<typename _InputIterator, typename _RandomAccessIterator,
-    typename _Compare>
-    _RandomAccessIterator
-    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
-   _RandomAccessIterator __result_first,
-   _RandomAccessIterator __result_last,
-   _Compare __comp)
-    {
-      typedef typename iterator_traits<_InputIterator>::value_type
- _InputValueType;
-      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
-      typedef typename _RItTraits::difference_type _DistanceType;
-
-      if (__result_first == __result_last)
- return __result_last;
-      _RandomAccessIterator __result_real_last = __result_first;
-      while (__first != __last && __result_real_last != __result_last)
- {
-   *__result_real_last = *__first;
-   ++__result_real_last;
-   ++__first;
- }
-
-      std::__make_heap(__result_first, __result_real_last, __comp);
-      while (__first != __last)
- {
-   if (__comp(__first, __result_first))
-     std::__adjust_heap(__result_first, _DistanceType(0),
-          _DistanceType(__result_real_last
-          - __result_first),
-          _InputValueType(*__first), __comp);
-   ++__first;
- }
-      std::__sort_heap(__result_first, __result_real_last, __comp);
-      return __result_real_last;
-    }
-# 1732 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _RandomAccessIterator>
-    inline _RandomAccessIterator
-    partial_sort_copy(_InputIterator __first, _InputIterator __last,
-        _RandomAccessIterator __result_first,
-        _RandomAccessIterator __result_last)
-    {
-# 1752 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                     ;
-                                                     ;
-                                                                   ;
-
-      return std::__partial_sort_copy(__first, __last,
-          __result_first, __result_last,
-          __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 1781 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _RandomAccessIterator,
-    typename _Compare>
-    inline _RandomAccessIterator
-    partial_sort_copy(_InputIterator __first, _InputIterator __last,
-        _RandomAccessIterator __result_first,
-        _RandomAccessIterator __result_last,
-        _Compare __comp)
-    {
-# 1806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                     ;
-                                                                  ;
-                                                                   ;
-
-      return std::__partial_sort_copy(__first, __last,
-          __result_first, __result_last,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __unguarded_linear_insert(_RandomAccessIterator __last,
-         _Compare __comp)
-    {
-      typename iterator_traits<_RandomAccessIterator>::value_type
- __val = std::move(*__last);
-      _RandomAccessIterator __next = __last;
-      --__next;
-      while (__comp(__val, __next))
- {
-   *__last = std::move(*__next);
-   __last = __next;
-   --__next;
- }
-      *__last = std::move(__val);
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __insertion_sort(_RandomAccessIterator __first,
-       _RandomAccessIterator __last, _Compare __comp)
-    {
-      if (__first == __last) return;
-
-      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
- {
-   if (__comp(__i, __first))
-     {
-       typename iterator_traits<_RandomAccessIterator>::value_type
-  __val = std::move(*__i);
-       std::move_backward(__first, __i, __i + 1);
-       *__first = std::move(__val);
-     }
-   else
-     std::__unguarded_linear_insert(__i,
-    __gnu_cxx::__ops::__val_comp_iter(__comp));
- }
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    __unguarded_insertion_sort(_RandomAccessIterator __first,
-          _RandomAccessIterator __last, _Compare __comp)
-    {
-      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
- std::__unguarded_linear_insert(__i,
-    __gnu_cxx::__ops::__val_comp_iter(__comp));
-    }
-
-
-
-
-
-  enum { _S_threshold = 16 };
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __final_insertion_sort(_RandomAccessIterator __first,
-      _RandomAccessIterator __last, _Compare __comp)
-    {
-      if (__last - __first > int(_S_threshold))
- {
-   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
-   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
-       __comp);
- }
-      else
- std::__insertion_sort(__first, __last, __comp);
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    _RandomAccessIterator
-    __unguarded_partition(_RandomAccessIterator __first,
-     _RandomAccessIterator __last,
-     _RandomAccessIterator __pivot, _Compare __comp)
-    {
-      while (true)
- {
-   while (__comp(__first, __pivot))
-     ++__first;
-   --__last;
-   while (__comp(__pivot, __last))
-     --__last;
-   if (!(__first < __last))
-     return __first;
-   std::iter_swap(__first, __last);
-   ++__first;
- }
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline _RandomAccessIterator
-    __unguarded_partition_pivot(_RandomAccessIterator __first,
-    _RandomAccessIterator __last, _Compare __comp)
-    {
-      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
-      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
-      __comp);
-      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    __partial_sort(_RandomAccessIterator __first,
-     _RandomAccessIterator __middle,
-     _RandomAccessIterator __last,
-     _Compare __comp)
-    {
-      std::__heap_select(__first, __middle, __last, __comp);
-      std::__sort_heap(__first, __middle, __comp);
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
-    void
-    __introsort_loop(_RandomAccessIterator __first,
-       _RandomAccessIterator __last,
-       _Size __depth_limit, _Compare __comp)
-    {
-      while (__last - __first > int(_S_threshold))
- {
-   if (__depth_limit == 0)
-     {
-       std::__partial_sort(__first, __last, __last, __comp);
-       return;
-     }
-   --__depth_limit;
-   _RandomAccessIterator __cut =
-     std::__unguarded_partition_pivot(__first, __last, __comp);
-   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
-   __last = __cut;
- }
-    }
-
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-    _Compare __comp)
-    {
-      if (__first != __last)
- {
-   std::__introsort_loop(__first, __last,
-    std::__lg(__last - __first) * 2,
-    __comp);
-   std::__final_insertion_sort(__first, __last, __comp);
- }
-    }
-
-  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
-    void
-    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
-    _RandomAccessIterator __last, _Size __depth_limit,
-    _Compare __comp)
-    {
-      while (__last - __first > 3)
- {
-   if (__depth_limit == 0)
-     {
-       std::__heap_select(__first, __nth + 1, __last, __comp);
-
-       std::iter_swap(__first, __nth);
-       return;
-     }
-   --__depth_limit;
-   _RandomAccessIterator __cut =
-     std::__unguarded_partition_pivot(__first, __last, __comp);
-   if (__cut <= __nth)
-     __first = __cut;
-   else
-     __last = __cut;
- }
-      std::__insertion_sort(__first, __last, __comp);
-    }
-# 2018 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    inline _ForwardIterator
-    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val, _Compare __comp)
-    {
-
-
-
-
-
-                    ;
-
-      return std::__lower_bound(__first, __last, __val,
-    __gnu_cxx::__ops::__iter_comp_val(__comp));
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    _ForwardIterator
-    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val, _Compare __comp)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _DistanceType __len = std::distance(__first, __last);
-
-      while (__len > 0)
- {
-   _DistanceType __half = __len >> 1;
-   _ForwardIterator __middle = __first;
-   std::advance(__middle, __half);
-   if (__comp(__val, __middle))
-     __len = __half;
-   else
-     {
-       __first = __middle;
-       ++__first;
-       __len = __len - __half - 1;
-     }
- }
-      return __first;
-    }
-# 2072 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline _ForwardIterator
-    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val)
-    {
-
-
-
-
-                                                                  ;
-
-      return std::__upper_bound(__first, __last, __val,
-    __gnu_cxx::__ops::__val_less_iter());
-    }
-# 2102 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    inline _ForwardIterator
-    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val, _Compare __comp)
-    {
-
-
-
-
-
-                    ;
-
-      return std::__upper_bound(__first, __last, __val,
-    __gnu_cxx::__ops::__val_comp_iter(__comp));
-    }
-
-  template<typename _ForwardIterator, typename _Tp,
-    typename _CompareItTp, typename _CompareTpIt>
-    pair<_ForwardIterator, _ForwardIterator>
-    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val,
-    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _DistanceType __len = std::distance(__first, __last);
-
-      while (__len > 0)
- {
-   _DistanceType __half = __len >> 1;
-   _ForwardIterator __middle = __first;
-   std::advance(__middle, __half);
-   if (__comp_it_val(__middle, __val))
-     {
-       __first = __middle;
-       ++__first;
-       __len = __len - __half - 1;
-     }
-   else if (__comp_val_it(__val, __middle))
-     __len = __half;
-   else
-     {
-       _ForwardIterator __left
-  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
-       std::advance(__first, __len);
-       _ForwardIterator __right
-  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
-       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
-     }
- }
-      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
-    }
-# 2173 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline pair<_ForwardIterator, _ForwardIterator>
-    equal_range(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val)
-    {
-
-
-
-
-
-
-                                                                  ;
-                                                                  ;
-
-      return std::__equal_range(__first, __last, __val,
-    __gnu_cxx::__ops::__iter_less_val(),
-    __gnu_cxx::__ops::__val_less_iter());
-    }
-# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    inline pair<_ForwardIterator, _ForwardIterator>
-    equal_range(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val, _Compare __comp)
-    {
-
-
-
-
-
-
-
-                    ;
-
-                    ;
-
-      return std::__equal_range(__first, __last, __val,
-    __gnu_cxx::__ops::__iter_comp_val(__comp),
-    __gnu_cxx::__ops::__val_comp_iter(__comp));
-    }
-# 2242 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    bool
-    binary_search(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val)
-    {
-
-
-
-
-                                                                  ;
-                                                                  ;
-
-      _ForwardIterator __i
- = std::__lower_bound(__first, __last, __val,
-        __gnu_cxx::__ops::__iter_less_val());
-      return __i != __last && !(__val < *__i);
-    }
-# 2275 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    bool
-    binary_search(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val, _Compare __comp)
-    {
-
-
-
-
-
-                    ;
-
-                    ;
-
-      _ForwardIterator __i
- = std::__lower_bound(__first, __last, __val,
-        __gnu_cxx::__ops::__iter_comp_val(__comp));
-      return __i != __last && !bool(__comp(__val, *__i));
-    }
-
-
-
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    void
-    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
-     _InputIterator2 __first2, _InputIterator2 __last2,
-     _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- {
-   if (__comp(__first2, __first1))
-     {
-       *__result = std::move(*__first2);
-       ++__first2;
-     }
-   else
-     {
-       *__result = std::move(*__first1);
-       ++__first1;
-     }
-   ++__result;
- }
-      if (__first1 != __last1)
- std::move(__first1, __last1, __result);
-    }
-
-
-  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
-    typename _BidirectionalIterator3, typename _Compare>
-    void
-    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
-       _BidirectionalIterator1 __last1,
-       _BidirectionalIterator2 __first2,
-       _BidirectionalIterator2 __last2,
-       _BidirectionalIterator3 __result,
-       _Compare __comp)
-    {
-      if (__first1 == __last1)
- {
-   std::move_backward(__first2, __last2, __result);
-   return;
- }
-      else if (__first2 == __last2)
- return;
-
-      --__last1;
-      --__last2;
-      while (true)
- {
-   if (__comp(__last2, __last1))
-     {
-       *--__result = std::move(*__last1);
-       if (__first1 == __last1)
-  {
-    std::move_backward(__first2, ++__last2, __result);
-    return;
-  }
-       --__last1;
-     }
-   else
-     {
-       *--__result = std::move(*__last2);
-       if (__first2 == __last2)
-  return;
-       --__last2;
-     }
- }
-    }
-
-
-  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
-    typename _Distance>
-    _BidirectionalIterator1
-    __rotate_adaptive(_BidirectionalIterator1 __first,
-        _BidirectionalIterator1 __middle,
-        _BidirectionalIterator1 __last,
-        _Distance __len1, _Distance __len2,
-        _BidirectionalIterator2 __buffer,
-        _Distance __buffer_size)
-    {
-      _BidirectionalIterator2 __buffer_end;
-      if (__len1 > __len2 && __len2 <= __buffer_size)
- {
-   if (__len2)
-     {
-       __buffer_end = std::move(__middle, __last, __buffer);
-       std::move_backward(__first, __middle, __last);
-       return std::move(__buffer, __buffer_end, __first);
-     }
-   else
-     return __first;
- }
-      else if (__len1 <= __buffer_size)
- {
-   if (__len1)
-     {
-       __buffer_end = std::move(__first, __middle, __buffer);
-       std::move(__middle, __last, __first);
-       return std::move_backward(__buffer, __buffer_end, __last);
-     }
-   else
-     return __last;
- }
-      else
- {
-   std::rotate(__first, __middle, __last);
-   std::advance(__first, std::distance(__middle, __last));
-   return __first;
- }
-    }
-
-
-  template<typename _BidirectionalIterator, typename _Distance,
-    typename _Pointer, typename _Compare>
-    void
-    __merge_adaptive(_BidirectionalIterator __first,
-       _BidirectionalIterator __middle,
-       _BidirectionalIterator __last,
-       _Distance __len1, _Distance __len2,
-       _Pointer __buffer, _Distance __buffer_size,
-       _Compare __comp)
-    {
-      if (__len1 <= __len2 && __len1 <= __buffer_size)
- {
-   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
-   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
-         __first, __comp);
- }
-      else if (__len2 <= __buffer_size)
- {
-   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
-   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
-           __buffer_end, __last, __comp);
- }
-      else
- {
-   _BidirectionalIterator __first_cut = __first;
-   _BidirectionalIterator __second_cut = __middle;
-   _Distance __len11 = 0;
-   _Distance __len22 = 0;
-   if (__len1 > __len2)
-     {
-       __len11 = __len1 / 2;
-       std::advance(__first_cut, __len11);
-       __second_cut
-  = std::__lower_bound(__middle, __last, *__first_cut,
-         __gnu_cxx::__ops::__iter_comp_val(__comp));
-       __len22 = std::distance(__middle, __second_cut);
-     }
-   else
-     {
-       __len22 = __len2 / 2;
-       std::advance(__second_cut, __len22);
-       __first_cut
-  = std::__upper_bound(__first, __middle, *__second_cut,
-         __gnu_cxx::__ops::__val_comp_iter(__comp));
-       __len11 = std::distance(__first, __first_cut);
-     }
-
-   _BidirectionalIterator __new_middle
-     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
-         __len1 - __len11, __len22, __buffer,
-         __buffer_size);
-   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
-    __len22, __buffer, __buffer_size, __comp);
-   std::__merge_adaptive(__new_middle, __second_cut, __last,
-    __len1 - __len11,
-    __len2 - __len22, __buffer,
-    __buffer_size, __comp);
- }
-    }
-
-
-  template<typename _BidirectionalIterator, typename _Distance,
-    typename _Compare>
-    void
-    __merge_without_buffer(_BidirectionalIterator __first,
-      _BidirectionalIterator __middle,
-      _BidirectionalIterator __last,
-      _Distance __len1, _Distance __len2,
-      _Compare __comp)
-    {
-      if (__len1 == 0 || __len2 == 0)
- return;
-
-      if (__len1 + __len2 == 2)
- {
-   if (__comp(__middle, __first))
-     std::iter_swap(__first, __middle);
-   return;
- }
-
-      _BidirectionalIterator __first_cut = __first;
-      _BidirectionalIterator __second_cut = __middle;
-      _Distance __len11 = 0;
-      _Distance __len22 = 0;
-      if (__len1 > __len2)
- {
-   __len11 = __len1 / 2;
-   std::advance(__first_cut, __len11);
-   __second_cut
-     = std::__lower_bound(__middle, __last, *__first_cut,
-     __gnu_cxx::__ops::__iter_comp_val(__comp));
-   __len22 = std::distance(__middle, __second_cut);
- }
-      else
- {
-   __len22 = __len2 / 2;
-   std::advance(__second_cut, __len22);
-   __first_cut
-     = std::__upper_bound(__first, __middle, *__second_cut,
-     __gnu_cxx::__ops::__val_comp_iter(__comp));
-   __len11 = std::distance(__first, __first_cut);
- }
-
-      std::rotate(__first_cut, __middle, __second_cut);
-      _BidirectionalIterator __new_middle = __first_cut;
-      std::advance(__new_middle, std::distance(__middle, __second_cut));
-      std::__merge_without_buffer(__first, __first_cut, __new_middle,
-      __len11, __len22, __comp);
-      std::__merge_without_buffer(__new_middle, __second_cut, __last,
-      __len1 - __len11, __len2 - __len22, __comp);
-    }
-
-  template<typename _BidirectionalIterator, typename _Compare>
-    void
-    __inplace_merge(_BidirectionalIterator __first,
-      _BidirectionalIterator __middle,
-      _BidirectionalIterator __last,
-      _Compare __comp)
-    {
-      typedef typename iterator_traits<_BidirectionalIterator>::value_type
-   _ValueType;
-      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
-   _DistanceType;
-
-      if (__first == __middle || __middle == __last)
- return;
-
-      const _DistanceType __len1 = std::distance(__first, __middle);
-      const _DistanceType __len2 = std::distance(__middle, __last);
-
-      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
-      _TmpBuf __buf(__first, __last);
-
-      if (__buf.begin() == 0)
- std::__merge_without_buffer
-   (__first, __middle, __last, __len1, __len2, __comp);
-      else
- std::__merge_adaptive
-   (__first, __middle, __last, __len1, __len2, __buf.begin(),
-    _DistanceType(__buf.size()), __comp);
-    }
-# 2569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator>
-    inline void
-    inplace_merge(_BidirectionalIterator __first,
-    _BidirectionalIterator __middle,
-    _BidirectionalIterator __last)
-    {
-
-
-
-
-
-                                                  ;
-                                                 ;
-                                                     ;
-
-      std::__inplace_merge(__first, __middle, __last,
-      __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 2610 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator, typename _Compare>
-    inline void
-    inplace_merge(_BidirectionalIterator __first,
-    _BidirectionalIterator __middle,
-    _BidirectionalIterator __last,
-    _Compare __comp)
-    {
-
-
-
-
-
-
-                                                               ;
-                                                              ;
-                                                                  ;
-
-      std::__inplace_merge(__first, __middle, __last,
-      __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-
-
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Compare>
-    _OutputIterator
-    __move_merge(_InputIterator __first1, _InputIterator __last1,
-   _InputIterator __first2, _InputIterator __last2,
-   _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- {
-   if (__comp(__first2, __first1))
-     {
-       *__result = std::move(*__first2);
-       ++__first2;
-     }
-   else
-     {
-       *__result = std::move(*__first1);
-       ++__first1;
-     }
-   ++__result;
- }
-      return std::move(__first2, __last2, std::move(__first1, __last1, __result));
-
-
-    }
-
-  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
-    typename _Distance, typename _Compare>
-    void
-    __merge_sort_loop(_RandomAccessIterator1 __first,
-        _RandomAccessIterator1 __last,
-        _RandomAccessIterator2 __result, _Distance __step_size,
-        _Compare __comp)
-    {
-      const _Distance __two_step = 2 * __step_size;
-
-      while (__last - __first >= __two_step)
- {
-   __result = std::__move_merge(__first, __first + __step_size,
-           __first + __step_size,
-           __first + __two_step,
-           __result, __comp);
-   __first += __two_step;
- }
-      __step_size = std::min(_Distance(__last - __first), __step_size);
-
-      std::__move_merge(__first, __first + __step_size,
-   __first + __step_size, __last, __result, __comp);
-    }
-
-  template<typename _RandomAccessIterator, typename _Distance,
-    typename _Compare>
-    void
-    __chunk_insertion_sort(_RandomAccessIterator __first,
-      _RandomAccessIterator __last,
-      _Distance __chunk_size, _Compare __comp)
-    {
-      while (__last - __first >= __chunk_size)
- {
-   std::__insertion_sort(__first, __first + __chunk_size, __comp);
-   __first += __chunk_size;
- }
-      std::__insertion_sort(__first, __last, __comp);
-    }
-
-  enum { _S_chunk_size = 7 };
-
-  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
-    void
-    __merge_sort_with_buffer(_RandomAccessIterator __first,
-        _RandomAccessIterator __last,
-        _Pointer __buffer, _Compare __comp)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
- _Distance;
-
-      const _Distance __len = __last - __first;
-      const _Pointer __buffer_last = __buffer + __len;
-
-      _Distance __step_size = _S_chunk_size;
-      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
-
-      while (__step_size < __len)
- {
-   std::__merge_sort_loop(__first, __last, __buffer,
-     __step_size, __comp);
-   __step_size *= 2;
-   std::__merge_sort_loop(__buffer, __buffer_last, __first,
-     __step_size, __comp);
-   __step_size *= 2;
- }
-    }
-
-  template<typename _RandomAccessIterator, typename _Pointer,
-    typename _Distance, typename _Compare>
-    void
-    __stable_sort_adaptive(_RandomAccessIterator __first,
-      _RandomAccessIterator __last,
-      _Pointer __buffer, _Distance __buffer_size,
-      _Compare __comp)
-    {
-      const _Distance __len = (__last - __first + 1) / 2;
-      const _RandomAccessIterator __middle = __first + __len;
-      if (__len > __buffer_size)
- {
-   std::__stable_sort_adaptive(__first, __middle, __buffer,
-          __buffer_size, __comp);
-   std::__stable_sort_adaptive(__middle, __last, __buffer,
-          __buffer_size, __comp);
- }
-      else
- {
-   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
-   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
- }
-      std::__merge_adaptive(__first, __middle, __last,
-       _Distance(__middle - __first),
-       _Distance(__last - __middle),
-       __buffer, __buffer_size,
-       __comp);
-    }
-
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    void
-    __inplace_stable_sort(_RandomAccessIterator __first,
-     _RandomAccessIterator __last, _Compare __comp)
-    {
-      if (__last - __first < 15)
- {
-   std::__insertion_sort(__first, __last, __comp);
-   return;
- }
-      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
-      std::__inplace_stable_sort(__first, __middle, __comp);
-      std::__inplace_stable_sort(__middle, __last, __comp);
-      std::__merge_without_buffer(__first, __middle, __last,
-      __middle - __first,
-      __last - __middle,
-      __comp);
-    }
-# 2782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _Compare>
-    bool
-    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- if (__comp(__first2, __first1))
-   return false;
- else if (__comp(__first1, __first2))
-   ++__first1;
- else
-   {
-     ++__first1;
-     ++__first2;
-   }
-
-      return __first2 == __last2;
-    }
-# 2821 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2>
-    inline bool
-    includes(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2)
-    {
-# 2835 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__includes(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 2865 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _Compare>
-    inline bool
-    includes(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2,
-      _Compare __comp)
-    {
-# 2881 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__includes(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 2900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator, typename _Compare>
-    bool
-    __next_permutation(_BidirectionalIterator __first,
-         _BidirectionalIterator __last, _Compare __comp)
-    {
-      if (__first == __last)
- return false;
-      _BidirectionalIterator __i = __first;
-      ++__i;
-      if (__i == __last)
- return false;
-      __i = __last;
-      --__i;
-
-      for(;;)
- {
-   _BidirectionalIterator __ii = __i;
-   --__i;
-   if (__comp(__i, __ii))
-     {
-       _BidirectionalIterator __j = __last;
-       while (!__comp(__i, --__j))
-  {}
-       std::iter_swap(__i, __j);
-       std::__reverse(__ii, __last,
-        std::__iterator_category(__first));
-       return true;
-     }
-   if (__i == __first)
-     {
-       std::__reverse(__first, __last,
-        std::__iterator_category(__first));
-       return false;
-     }
- }
-    }
-# 2949 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator>
-    inline bool
-    next_permutation(_BidirectionalIterator __first,
-       _BidirectionalIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__next_permutation
- (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 2981 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator, typename _Compare>
-    inline bool
-    next_permutation(_BidirectionalIterator __first,
-       _BidirectionalIterator __last, _Compare __comp)
-    {
-
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__next_permutation
- (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _BidirectionalIterator, typename _Compare>
-    bool
-    __prev_permutation(_BidirectionalIterator __first,
-         _BidirectionalIterator __last, _Compare __comp)
-    {
-      if (__first == __last)
- return false;
-      _BidirectionalIterator __i = __first;
-      ++__i;
-      if (__i == __last)
- return false;
-      __i = __last;
-      --__i;
-
-      for(;;)
- {
-   _BidirectionalIterator __ii = __i;
-   --__i;
-   if (__comp(__ii, __i))
-     {
-       _BidirectionalIterator __j = __last;
-       while (!__comp(--__j, __i))
-  {}
-       std::iter_swap(__i, __j);
-       std::__reverse(__ii, __last,
-        std::__iterator_category(__first));
-       return true;
-     }
-   if (__i == __first)
-     {
-       std::__reverse(__first, __last,
-        std::__iterator_category(__first));
-       return false;
-     }
- }
-    }
-# 3049 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator>
-    inline bool
-    prev_permutation(_BidirectionalIterator __first,
-       _BidirectionalIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__prev_permutation(__first, __last,
-         __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 3081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _BidirectionalIterator, typename _Compare>
-    inline bool
-    prev_permutation(_BidirectionalIterator __first,
-       _BidirectionalIterator __last, _Compare __comp)
-    {
-
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__prev_permutation(__first, __last,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-
-
-
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Predicate, typename _Tp>
-    _OutputIterator
-    __replace_copy_if(_InputIterator __first, _InputIterator __last,
-        _OutputIterator __result,
-        _Predicate __pred, const _Tp& __new_value)
-    {
-      for (; __first != __last; ++__first, (void)++__result)
- if (__pred(__first))
-   *__result = __new_value;
- else
-   *__result = *__first;
-      return __result;
-    }
-# 3131 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
-    inline _OutputIterator
-    replace_copy(_InputIterator __first, _InputIterator __last,
-   _OutputIterator __result,
-   const _Tp& __old_value, const _Tp& __new_value)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__replace_copy_if(__first, __last, __result,
-   __gnu_cxx::__ops::__iter_equals_val(__old_value),
-           __new_value);
-    }
-# 3165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _Predicate, typename _Tp>
-    inline _OutputIterator
-    replace_copy_if(_InputIterator __first, _InputIterator __last,
-      _OutputIterator __result,
-      _Predicate __pred, const _Tp& __new_value)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      return std::__replace_copy_if(__first, __last, __result,
-    __gnu_cxx::__ops::__pred_iter(__pred),
-           __new_value);
-    }
-
-  template<typename _InputIterator, typename _Predicate>
-    typename iterator_traits<_InputIterator>::difference_type
-    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-    {
-      typename iterator_traits<_InputIterator>::difference_type __n = 0;
-      for (; __first != __last; ++__first)
- if (__pred(__first))
-   ++__n;
-      return __n;
-    }
-# 3204 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    inline bool
-    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
-    { return std::is_sorted_until(__first, __last) == __last; }
-# 3218 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Compare>
-    inline bool
-    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
-       _Compare __comp)
-    { return std::is_sorted_until(__first, __last, __comp) == __last; }
-
-  template<typename _ForwardIterator, typename _Compare>
-    _ForwardIterator
-    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
-        _Compare __comp)
-    {
-      if (__first == __last)
- return __last;
-
-      _ForwardIterator __next = __first;
-      for (++__next; __next != __last; __first = __next, (void)++__next)
- if (__comp(__next, __first))
-   return __next;
-      return __next;
-    }
-# 3247 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    inline _ForwardIterator
-    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__is_sorted_until(__first, __last,
-        __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 3271 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Compare>
-    inline _ForwardIterator
-    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
-      _Compare __comp)
-    {
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__is_sorted_until(__first, __last,
-        __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 3296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _Tp>
-    constexpr
-    inline pair<const _Tp&, const _Tp&>
-    minmax(const _Tp& __a, const _Tp& __b)
-    {
-
-
-
-      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
-         : pair<const _Tp&, const _Tp&>(__a, __b);
-    }
-# 3317 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline pair<const _Tp&, const _Tp&>
-    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
-    {
-      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
-         : pair<const _Tp&, const _Tp&>(__a, __b);
-    }
-
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    pair<_ForwardIterator, _ForwardIterator>
-    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
-       _Compare __comp)
-    {
-      _ForwardIterator __next = __first;
-      if (__first == __last
-   || ++__next == __last)
- return std::make_pair(__first, __first);
-
-      _ForwardIterator __min{}, __max{};
-      if (__comp(__next, __first))
- {
-   __min = __next;
-   __max = __first;
- }
-      else
- {
-   __min = __first;
-   __max = __next;
- }
-
-      __first = __next;
-      ++__first;
-
-      while (__first != __last)
- {
-   __next = __first;
-   if (++__next == __last)
-     {
-       if (__comp(__first, __min))
-  __min = __first;
-       else if (!__comp(__first, __max))
-  __max = __first;
-       break;
-     }
-
-   if (__comp(__next, __first))
-     {
-       if (__comp(__next, __min))
-  __min = __next;
-       if (!__comp(__first, __max))
-  __max = __first;
-     }
-   else
-     {
-       if (__comp(__first, __min))
-  __min = __first;
-       if (!__comp(__next, __max))
-  __max = __next;
-     }
-
-   __first = __next;
-   ++__first;
- }
-
-      return std::make_pair(__min, __max);
-    }
-# 3397 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    constexpr
-    inline pair<_ForwardIterator, _ForwardIterator>
-    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__minmax_element(__first, __last,
-       __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 3425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    inline pair<_ForwardIterator, _ForwardIterator>
-    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
-     _Compare __comp)
-    {
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__minmax_element(__first, __last,
-       __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-
-  template<typename _Tp>
-    constexpr
-    inline _Tp
-    min(initializer_list<_Tp> __l)
-    { return *std::min_element(__l.begin(), __l.end()); }
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline _Tp
-    min(initializer_list<_Tp> __l, _Compare __comp)
-    { return *std::min_element(__l.begin(), __l.end(), __comp); }
-
-  template<typename _Tp>
-    constexpr
-    inline _Tp
-    max(initializer_list<_Tp> __l)
-    { return *std::max_element(__l.begin(), __l.end()); }
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline _Tp
-    max(initializer_list<_Tp> __l, _Compare __comp)
-    { return *std::max_element(__l.begin(), __l.end(), __comp); }
-
-  template<typename _Tp>
-    constexpr
-    inline pair<_Tp, _Tp>
-    minmax(initializer_list<_Tp> __l)
-    {
-      pair<const _Tp*, const _Tp*> __p =
- std::minmax_element(__l.begin(), __l.end());
-      return std::make_pair(*__p.first, *__p.second);
-    }
-
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline pair<_Tp, _Tp>
-    minmax(initializer_list<_Tp> __l, _Compare __comp)
-    {
-      pair<const _Tp*, const _Tp*> __p =
- std::minmax_element(__l.begin(), __l.end(), __comp);
-      return std::make_pair(*__p.first, *__p.second);
-    }
-
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    bool
-    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-       _ForwardIterator2 __first2, _BinaryPredicate __pred)
-    {
-
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2)
- if (!__pred(__first1, __first2))
-   break;
-
-      if (__first1 == __last1)
- return true;
-
-
-
-      _ForwardIterator2 __last2 = __first2;
-      std::advance(__last2, std::distance(__first1, __last1));
-      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
- {
-   if (__scan != std::__find_if(__first1, __scan,
-     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
-     continue;
-
-   auto __matches
-     = std::__count_if(__first2, __last2,
-   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
-   if (0 == __matches ||
-       std::__count_if(__scan, __last1,
-   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
-       != __matches)
-     return false;
- }
-      return true;
-    }
-# 3537 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline bool
-    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-     _ForwardIterator2 __first2)
-    {
-
-
-
-
-
-
-                                                       ;
-
-      return std::__is_permutation(__first1, __last1, __first2,
-       __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 3568 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    inline bool
-    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-     _ForwardIterator2 __first2, _BinaryPredicate __pred)
-    {
-
-
-
-
-
-
-                                                       ;
-
-      return std::__is_permutation(__first1, __last1, __first2,
-       __gnu_cxx::__ops::__iter_comp_iter(__pred));
-    }
-
-
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    bool
-    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-       _BinaryPredicate __pred)
-    {
-      using _Cat1
- = typename iterator_traits<_ForwardIterator1>::iterator_category;
-      using _Cat2
- = typename iterator_traits<_ForwardIterator2>::iterator_category;
-      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
-      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
-      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
-      if (__ra_iters)
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 != __d2)
-     return false;
- }
-
-
-
-      for (; __first1 != __last1 && __first2 != __last2;
-   ++__first1, (void)++__first2)
- if (!__pred(__first1, __first2))
-   break;
-
-      if (__ra_iters)
- {
-   if (__first1 == __last1)
-     return true;
- }
-      else
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 == 0 && __d2 == 0)
-     return true;
-   if (__d1 != __d2)
-     return false;
- }
-
-      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
- {
-   if (__scan != std::__find_if(__first1, __scan,
-   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
-     continue;
-
-   auto __matches = std::__count_if(__first2, __last2,
-  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
-   if (0 == __matches
-       || std::__count_if(__scan, __last1,
-   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
-       != __matches)
-     return false;
- }
-      return true;
-    }
-# 3661 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline bool
-    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
-    {
-                                                       ;
-                                                       ;
-
-      return
- std::__is_permutation(__first1, __last1, __first2, __last2,
-         __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 3688 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    inline bool
-    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-     _BinaryPredicate __pred)
-    {
-                                                       ;
-                                                       ;
-
-      return std::__is_permutation(__first1, __last1, __first2, __last2,
-       __gnu_cxx::__ops::__iter_comp_iter(__pred));
-    }
-# 3716 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator,
-    typename _UniformRandomNumberGenerator>
-    void
-    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-     _UniformRandomNumberGenerator&& __g)
-    {
-
-
-
-                                                     ;
-
-      if (__first == __last)
- return;
-
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
- _DistanceType;
-
-      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
-      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
-      typedef typename __distr_type::param_type __p_type;
-      __distr_type __d;
-
-      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
- std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
-    }
-# 3761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Function>
-    _Function
-    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
-    {
-
-
-                                                     ;
-      for (; __first != __last; ++__first)
- __f(*__first);
-      return std::move(__f);
-    }
-# 3782 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Tp>
-    inline _InputIterator
-    find(_InputIterator __first, _InputIterator __last,
-  const _Tp& __val)
-    {
-
-
-
-
-                                                     ;
-      return std::__find_if(__first, __last,
-       __gnu_cxx::__ops::__iter_equals_val(__val));
-    }
-# 3806 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline _InputIterator
-    find_if(_InputIterator __first, _InputIterator __last,
-     _Predicate __pred)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__find_if(__first, __last,
-       __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-# 3837 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _ForwardIterator>
-    _InputIterator
-    find_first_of(_InputIterator __first1, _InputIterator __last1,
-    _ForwardIterator __first2, _ForwardIterator __last2)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      for (; __first1 != __last1; ++__first1)
- for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
-   if (*__first1 == *__iter)
-     return __first1;
-      return __last1;
-    }
-# 3877 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _ForwardIterator,
-    typename _BinaryPredicate>
-    _InputIterator
-    find_first_of(_InputIterator __first1, _InputIterator __last1,
-    _ForwardIterator __first2, _ForwardIterator __last2,
-    _BinaryPredicate __comp)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      for (; __first1 != __last1; ++__first1)
- for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
-   if (__comp(*__first1, *__iter))
-     return __first1;
-      return __last1;
-    }
-# 3909 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    inline _ForwardIterator
-    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__adjacent_find(__first, __last,
-      __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 3934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _BinaryPredicate>
-    inline _ForwardIterator
-    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
-    _BinaryPredicate __binary_pred)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__adjacent_find(__first, __last,
-   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-# 3959 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Tp>
-    inline typename iterator_traits<_InputIterator>::difference_type
-    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__count_if(__first, __last,
-        __gnu_cxx::__ops::__iter_equals_val(__value));
-    }
-# 3982 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _Predicate>
-    inline typename iterator_traits<_InputIterator>::difference_type
-    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__count_if(__first, __last,
-        __gnu_cxx::__ops::__pred_iter(__pred));
-    }
-# 4022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline _ForwardIterator1
-    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__search(__first1, __last1, __first2, __last2,
-      __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 4061 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2,
-    typename _BinaryPredicate>
-    inline _ForwardIterator1
-    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-    _BinaryPredicate __predicate)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                       ;
-
-      return std::__search(__first1, __last1, __first2, __last2,
-      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
-    }
-# 4096 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Integer, typename _Tp>
-    inline _ForwardIterator
-    search_n(_ForwardIterator __first, _ForwardIterator __last,
-      _Integer __count, const _Tp& __val)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__search_n(__first, __last, __count,
-        __gnu_cxx::__ops::__iter_equals_val(__val));
-    }
-# 4129 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Integer, typename _Tp,
-    typename _BinaryPredicate>
-    inline _ForwardIterator
-    search_n(_ForwardIterator __first, _ForwardIterator __last,
-      _Integer __count, const _Tp& __val,
-      _BinaryPredicate __binary_pred)
-    {
-
-
-
-
-                                                     ;
-
-      return std::__search_n(__first, __last, __count,
-  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
-    }
-# 4163 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _UnaryOperation>
-    _OutputIterator
-    transform(_InputIterator __first, _InputIterator __last,
-       _OutputIterator __result, _UnaryOperation __unary_op)
-    {
-
-
-
-
-
-                                                     ;
-
-      for (; __first != __last; ++__first, (void)++__result)
- *__result = __unary_op(*__first);
-      return __result;
-    }
-# 4200 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _BinaryOperation>
-    _OutputIterator
-    transform(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _OutputIterator __result,
-       _BinaryOperation __binary_op)
-    {
-
-
-
-
-
-
-                                                       ;
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
- *__result = __binary_op(*__first1, *__first2);
-      return __result;
-    }
-# 4233 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    void
-    replace(_ForwardIterator __first, _ForwardIterator __last,
-     const _Tp& __old_value, const _Tp& __new_value)
-    {
-
-
-
-
-
-
-
-                                                     ;
-
-      for (; __first != __last; ++__first)
- if (*__first == __old_value)
-   *__first = __new_value;
-    }
-# 4265 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
-    void
-    replace_if(_ForwardIterator __first, _ForwardIterator __last,
-        _Predicate __pred, const _Tp& __new_value)
-    {
-
-
-
-
-
-
-
-                                                     ;
-
-      for (; __first != __last; ++__first)
- if (__pred(*__first))
-   *__first = __new_value;
-    }
-# 4297 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Generator>
-    void
-    generate(_ForwardIterator __first, _ForwardIterator __last,
-      _Generator __gen)
-    {
-
-
-
-
-                                                     ;
-
-      for (; __first != __last; ++__first)
- *__first = __gen();
-    }
-# 4328 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _OutputIterator, typename _Size, typename _Generator>
-    _OutputIterator
-    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
-    {
-
-
-
-
-
-      for (__decltype(__n + 0) __niter = __n;
-    __niter > 0; --__niter, ++__first)
- *__first = __gen();
-      return __first;
-    }
-# 4364 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator>
-    inline _OutputIterator
-    unique_copy(_InputIterator __first, _InputIterator __last,
-  _OutputIterator __result)
-    {
-
-
-
-
-
-
-                                                     ;
-
-      if (__first == __last)
- return __result;
-      return std::__unique_copy(__first, __last, __result,
-    __gnu_cxx::__ops::__iter_equal_to_iter(),
-    std::__iterator_category(__first),
-    std::__iterator_category(__result));
-    }
-# 4404 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator, typename _OutputIterator,
-    typename _BinaryPredicate>
-    inline _OutputIterator
-    unique_copy(_InputIterator __first, _InputIterator __last,
-  _OutputIterator __result,
-  _BinaryPredicate __binary_pred)
-    {
-
-
-
-
-                                                     ;
-
-      if (__first == __last)
- return __result;
-      return std::__unique_copy(__first, __last, __result,
-   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
-    std::__iterator_category(__first),
-    std::__iterator_category(__result));
-    }
-# 4437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-                                                     ;
-
-      if (__first != __last)
- for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
-   {
-
-     _RandomAccessIterator __j = __first
-     + std::rand() % ((__i - __first) + 1);
-     if (__i != __j)
-       std::iter_swap(__i, __j);
-   }
-    }
-# 4472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
-    void
-    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-
-     _RandomNumberGenerator&& __rand)
-
-
-
-    {
-
-
-
-                                                     ;
-
-      if (__first == __last)
- return;
-      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
- {
-   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
-   if (__i != __j)
-     std::iter_swap(__i, __j);
- }
-    }
-# 4512 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Predicate>
-    inline _ForwardIterator
-    partition(_ForwardIterator __first, _ForwardIterator __last,
-       _Predicate __pred)
-    {
-
-
-
-
-
-                                                     ;
-
-      return std::__partition(__first, __last, __pred,
-         std::__iterator_category(__first));
-    }
-# 4545 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    partial_sort(_RandomAccessIterator __first,
-   _RandomAccessIterator __middle,
-   _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                       ;
-                                                      ;
-                                                     ;
-
-      std::__partial_sort(__first, __middle, __last,
-     __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 4583 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    partial_sort(_RandomAccessIterator __first,
-   _RandomAccessIterator __middle,
-   _RandomAccessIterator __last,
-   _Compare __comp)
-    {
-
-
-
-
-
-
-                                                       ;
-                                                      ;
-                                                                  ;
-
-      std::__partial_sort(__first, __middle, __last,
-     __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 4619 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
-  _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                    ;
-                                                   ;
-                                                     ;
-
-      if (__first == __last || __nth == __last)
- return;
-
-      std::__introselect(__first, __nth, __last,
-    std::__lg(__last - __first) * 2,
-    __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 4658 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
-  _RandomAccessIterator __last, _Compare __comp)
-    {
-
-
-
-
-
-
-                                                    ;
-                                                   ;
-                                                                  ;
-
-      if (__first == __last || __nth == __last)
- return;
-
-      std::__introselect(__first, __nth, __last,
-    std::__lg(__last - __first) * 2,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-# 4695 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 4725 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-  _Compare __comp)
-    {
-
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    _OutputIterator
-    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
-     _InputIterator2 __first2, _InputIterator2 __last2,
-     _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- {
-   if (__comp(__first2, __first1))
-     {
-       *__result = *__first2;
-       ++__first2;
-     }
-   else
-     {
-       *__result = *__first1;
-       ++__first1;
-     }
-   ++__result;
- }
-      return std::copy(__first2, __last2,
-         std::copy(__first1, __last1, __result));
-    }
-# 4786 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator>
-    inline _OutputIterator
-    merge(_InputIterator1 __first1, _InputIterator1 __last1,
-   _InputIterator2 __first2, _InputIterator2 __last2,
-   _OutputIterator __result)
-    {
-# 4803 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__merge(__first1, __last1,
-         __first2, __last2, __result,
-         __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 4836 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    inline _OutputIterator
-    merge(_InputIterator1 __first1, _InputIterator1 __last1,
-   _InputIterator2 __first2, _InputIterator2 __last2,
-   _OutputIterator __result, _Compare __comp)
-    {
-# 4853 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__merge(__first1, __last1,
-    __first2, __last2, __result,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-    _Compare __comp)
-    {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type
- _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
- _DistanceType;
-
-      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
-      _TmpBuf __buf(__first, __last);
-
-      if (__buf.begin() == 0)
- std::__inplace_stable_sort(__first, __last, __comp);
-      else
- std::__stable_sort_adaptive(__first, __last, __buf.begin(),
-        _DistanceType(__buf.size()), __comp);
-    }
-# 4900 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator>
-    inline void
-    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
-    {
-
-
-
-
-
-                                                     ;
-                                                     ;
-
-      std::__stable_sort(__first, __last,
-        __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 4934 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _RandomAccessIterator, typename _Compare>
-    inline void
-    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-  _Compare __comp)
-    {
-
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      std::__stable_sort(__first, __last,
-        __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator,
-    typename _Compare>
-    _OutputIterator
-    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
-  _InputIterator2 __first2, _InputIterator2 __last2,
-  _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- {
-   if (__comp(__first1, __first2))
-     {
-       *__result = *__first1;
-       ++__first1;
-     }
-   else if (__comp(__first2, __first1))
-     {
-       *__result = *__first2;
-       ++__first2;
-     }
-   else
-     {
-       *__result = *__first1;
-       ++__first1;
-       ++__first2;
-     }
-   ++__result;
- }
-      return std::copy(__first2, __last2,
-         std::copy(__first1, __last1, __result));
-    }
-# 5002 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator>
-    inline _OutputIterator
-    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _InputIterator2 __last2,
-       _OutputIterator __result)
-    {
-# 5022 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__set_union(__first1, __last1,
-    __first2, __last2, __result,
-    __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5051 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    inline _OutputIterator
-    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _InputIterator2 __last2,
-       _OutputIterator __result, _Compare __comp)
-    {
-# 5071 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__set_union(__first1, __last1,
-    __first2, __last2, __result,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator,
-    typename _Compare>
-    _OutputIterator
-    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
-         _InputIterator2 __first2, _InputIterator2 __last2,
-         _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- if (__comp(__first1, __first2))
-   ++__first1;
- else if (__comp(__first2, __first1))
-   ++__first2;
- else
-   {
-     *__result = *__first1;
-     ++__first1;
-     ++__first2;
-     ++__result;
-   }
-      return __result;
-    }
-# 5121 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator>
-    inline _OutputIterator
-    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _InputIterator2 __last2,
-       _OutputIterator __result)
-    {
-# 5139 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__set_intersection(__first1, __last1,
-         __first2, __last2, __result,
-         __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    inline _OutputIterator
-    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _InputIterator2 __last2,
-       _OutputIterator __result, _Compare __comp)
-    {
-# 5187 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__set_intersection(__first1, __last1,
-    __first2, __last2, __result,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator,
-    typename _Compare>
-    _OutputIterator
-    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
-       _InputIterator2 __first2, _InputIterator2 __last2,
-       _OutputIterator __result, _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- if (__comp(__first1, __first2))
-   {
-     *__result = *__first1;
-     ++__first1;
-     ++__result;
-   }
- else if (__comp(__first2, __first1))
-   ++__first2;
- else
-   {
-     ++__first1;
-     ++__first2;
-   }
-      return std::copy(__first1, __last1, __result);
-    }
-# 5241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator>
-    inline _OutputIterator
-    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
-     _InputIterator2 __first2, _InputIterator2 __last2,
-     _OutputIterator __result)
-    {
-# 5259 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__set_difference(__first1, __last1,
-       __first2, __last2, __result,
-       __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5291 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    inline _OutputIterator
-    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
-     _InputIterator2 __first2, _InputIterator2 __last2,
-     _OutputIterator __result, _Compare __comp)
-    {
-# 5309 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__set_difference(__first1, __last1,
-       __first2, __last2, __result,
-       __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator,
-    typename _Compare>
-    _OutputIterator
-    __set_symmetric_difference(_InputIterator1 __first1,
-          _InputIterator1 __last1,
-          _InputIterator2 __first2,
-          _InputIterator2 __last2,
-          _OutputIterator __result,
-          _Compare __comp)
-    {
-      while (__first1 != __last1 && __first2 != __last2)
- if (__comp(__first1, __first2))
-   {
-     *__result = *__first1;
-     ++__first1;
-     ++__result;
-   }
- else if (__comp(__first2, __first1))
-   {
-     *__result = *__first2;
-     ++__first2;
-     ++__result;
-   }
- else
-   {
-     ++__first1;
-     ++__first2;
-   }
-      return std::copy(__first2, __last2,
-         std::copy(__first1, __last1, __result));
-    }
-# 5369 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator>
-    inline _OutputIterator
-    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _OutputIterator __result)
-    {
-# 5389 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                ;
-                                                                ;
-                                                        ;
-                                                        ;
-
-      return std::__set_symmetric_difference(__first1, __last1,
-     __first2, __last2, __result,
-     __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5419 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _OutputIterator, typename _Compare>
-    inline _OutputIterator
-    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _OutputIterator __result,
-        _Compare __comp)
-    {
-# 5440 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-                                                                             ;
-                                                                             ;
-                                                                     ;
-                                                                     ;
-
-      return std::__set_symmetric_difference(__first1, __last1,
-    __first2, __last2, __result,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    _ForwardIterator
-    __min_element(_ForwardIterator __first, _ForwardIterator __last,
-    _Compare __comp)
-    {
-      if (__first == __last)
- return __first;
-      _ForwardIterator __result = __first;
-      while (++__first != __last)
- if (__comp(__first, __result))
-   __result = __first;
-      return __result;
-    }
-# 5472 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    constexpr
-    _ForwardIterator
-    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__min_element(__first, __last,
-    __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5497 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    inline _ForwardIterator
-    min_element(_ForwardIterator __first, _ForwardIterator __last,
-  _Compare __comp)
-    {
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__min_element(__first, __last,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    _ForwardIterator
-    __max_element(_ForwardIterator __first, _ForwardIterator __last,
-    _Compare __comp)
-    {
-      if (__first == __last) return __first;
-      _ForwardIterator __result = __first;
-      while (++__first != __last)
- if (__comp(__result, __first))
-   __result = __first;
-      return __result;
-    }
-# 5536 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator>
-    constexpr
-    inline _ForwardIterator
-    max_element(_ForwardIterator __first, _ForwardIterator __last)
-    {
-
-
-
-
-                                                     ;
-                                                     ;
-
-      return std::__max_element(__first, __last,
-    __gnu_cxx::__ops::__iter_less_iter());
-    }
-# 5561 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_algo.h" 3
-  template<typename _ForwardIterator, typename _Compare>
-    constexpr
-    inline _ForwardIterator
-    max_element(_ForwardIterator __first, _ForwardIterator __last,
-  _Compare __comp)
-    {
-
-
-
-
-
-                                                     ;
-                                                                  ;
-
-      return std::__max_element(__first, __last,
-    __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-
-}
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/algorithm" 2 3
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Tp, std::size_t _Nm>
-    struct __array_traits
-    {
-      typedef _Tp _Type[_Nm];
-
-      static constexpr _Tp&
-      _S_ref(const _Type& __t, std::size_t __n) noexcept
-      { return const_cast<_Tp&>(__t[__n]); }
-
-      static constexpr _Tp*
-      _S_ptr(const _Type& __t) noexcept
-      { return const_cast<_Tp*>(__t); }
-    };
-
- template<typename _Tp>
-   struct __array_traits<_Tp, 0>
-   {
-     struct _Type { };
-
-     static constexpr _Tp&
-     _S_ref(const _Type&, std::size_t) noexcept
-     { return *static_cast<_Tp*>(nullptr); }
-
-     static constexpr _Tp*
-     _S_ptr(const _Type&) noexcept
-     { return nullptr; }
-   };
-# 89 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/array" 3
-  template<typename _Tp, std::size_t _Nm>
-    struct array
-    {
-      typedef _Tp value_type;
-      typedef value_type* pointer;
-      typedef const value_type* const_pointer;
-      typedef value_type& reference;
-      typedef const value_type& const_reference;
-      typedef value_type* iterator;
-      typedef const value_type* const_iterator;
-      typedef std::size_t size_type;
-      typedef std::ptrdiff_t difference_type;
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-
-      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
-      typename _AT_Type::_Type _M_elems;
-
-
-
-
-      void
-      fill(const value_type& __u)
-      { std::fill_n(begin(), size(), __u); }
-
-      void
-      swap(array& __other)
-      noexcept(__is_nothrow_swappable<_Tp>::value)
-      { std::swap_ranges(begin(), end(), __other.begin()); }
-
-
-      iterator
-      begin() noexcept
-      { return iterator(data()); }
-
-      const_iterator
-      begin() const noexcept
-      { return const_iterator(data()); }
-
-      iterator
-      end() noexcept
-      { return iterator(data() + _Nm); }
-
-      const_iterator
-      end() const noexcept
-      { return const_iterator(data() + _Nm); }
-
-      reverse_iterator
-      rbegin() noexcept
-      { return reverse_iterator(end()); }
-
-      const_reverse_iterator
-      rbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-      reverse_iterator
-      rend() noexcept
-      { return reverse_iterator(begin()); }
-
-      const_reverse_iterator
-      rend() const noexcept
-      { return const_reverse_iterator(begin()); }
-
-      const_iterator
-      cbegin() const noexcept
-      { return const_iterator(data()); }
-
-      const_iterator
-      cend() const noexcept
-      { return const_iterator(data() + _Nm); }
-
-      const_reverse_iterator
-      crbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-      const_reverse_iterator
-      crend() const noexcept
-      { return const_reverse_iterator(begin()); }
-
-
-      constexpr size_type
-      size() const noexcept { return _Nm; }
-
-      constexpr size_type
-      max_size() const noexcept { return _Nm; }
-
-      constexpr bool
-      empty() const noexcept { return size() == 0; }
-
-
-      reference
-      operator[](size_type __n) noexcept
-      { return _AT_Type::_S_ref(_M_elems, __n); }
-
-      constexpr const_reference
-      operator[](size_type __n) const noexcept
-      { return _AT_Type::_S_ref(_M_elems, __n); }
-
-      reference
-      at(size_type __n)
-      {
- if (__n >= _Nm)
-   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
-
-     __n, _Nm);
- return _AT_Type::_S_ref(_M_elems, __n);
-      }
-
-      constexpr const_reference
-      at(size_type __n) const
-      {
-
-
- return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
-   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
-
-        __n, _Nm),
-      _AT_Type::_S_ref(_M_elems, 0));
-      }
-
-      reference
-      front() noexcept
-      { return *begin(); }
-
-      constexpr const_reference
-      front() const noexcept
-      { return _AT_Type::_S_ref(_M_elems, 0); }
-
-      reference
-      back() noexcept
-      { return _Nm ? *(end() - 1) : *end(); }
-
-      constexpr const_reference
-      back() const noexcept
-      {
- return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
-             : _AT_Type::_S_ref(_M_elems, 0);
-      }
-
-      pointer
-      data() noexcept
-      { return _AT_Type::_S_ptr(_M_elems); }
-
-      const_pointer
-      data() const noexcept
-      { return _AT_Type::_S_ptr(_M_elems); }
-    };
-
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one == __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
-    {
-      return std::lexicographical_compare(__a.begin(), __a.end(),
-       __b.begin(), __b.end());
-    }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return __two < __one; }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one > __two); }
-
-  template<typename _Tp, std::size_t _Nm>
-    inline bool
-    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-    { return !(__one < __two); }
-
-
-  template<typename _Tp, std::size_t _Nm>
-    inline void
-    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
-    noexcept(noexcept(__one.swap(__two)))
-    { __one.swap(__two); }
-
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr _Tp&
-    get(array<_Tp, _Nm>& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "index is out of bounds");
-      return std::__array_traits<_Tp, _Nm>::
- _S_ref(__arr._M_elems, _Int);
-    }
-
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr _Tp&&
-    get(array<_Tp, _Nm>&& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "index is out of bounds");
-      return std::move(std::get<_Int>(__arr));
-    }
-
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    constexpr const _Tp&
-    get(const array<_Tp, _Nm>& __arr) noexcept
-    {
-      static_assert(_Int < _Nm, "index is out of bounds");
-      return std::__array_traits<_Tp, _Nm>::
- _S_ref(__arr._M_elems, _Int);
-    }
-
-
-}
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-  template<typename _Tp>
-    class tuple_size;
-
-
-  template<typename _Tp, std::size_t _Nm>
-    struct tuple_size<std::array<_Tp, _Nm>>
-    : public integral_constant<std::size_t, _Nm> { };
-
-
-  template<std::size_t _Int, typename _Tp>
-    class tuple_element;
-
-
-  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-    struct tuple_element<_Int, std::array<_Tp, _Nm>>
-    {
-      static_assert(_Int < _Nm, "index is out of bounds");
-      typedef _Tp type;
-    };
-
-  template<typename _Tp, std::size_t _Nm>
-    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
-    { };
-
-
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cstring" 3
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h" 2
-# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
-namespace mozilla {
-
-
-
-
-template<class T, class U>
-inline constexpr T
-narrow_cast(U&& u)
-{
-  return static_cast<T>(mozilla::Forward<U>(u));
-}
-# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
-constexpr const size_t dynamic_extent = mozilla::MaxValue<size_t>::value;
-
-template<class ElementType, size_t Extent = dynamic_extent>
-class Span;
-
-
-namespace span_details {
-
-inline size_t strlen16(const char16_t* aZeroTerminated) {
-  size_t len = 0;
-  while (*(aZeroTerminated++)) {
-    len++;
-  }
-  return len;
-}
-
-
-template<class T>
-using remove_cv_t = typename mozilla::RemoveCV<T>::Type;
-template<class T>
-using remove_const_t = typename mozilla::RemoveConst<T>::Type;
-template<bool B, class T, class F>
-using conditional_t = typename mozilla::Conditional<B, T, F>::Type;
-template<class T>
-using add_pointer_t = typename mozilla::AddPointer<T>::Type;
-template<bool B, class T = void>
-using enable_if_t = typename mozilla::EnableIf<B, T>::Type;
-
-template<class T>
-struct is_span_oracle : mozilla::FalseType
-{
-};
-
-template<class ElementType, size_t Extent>
-struct is_span_oracle<mozilla::Span<ElementType, Extent>> : mozilla::TrueType
-{
-};
-
-template<class T>
-struct is_span : public is_span_oracle<remove_cv_t<T>>
-{
-};
-
-template<class T>
-struct is_std_array_oracle : mozilla::FalseType
-{
-};
-
-template<class ElementType, size_t Extent>
-struct is_std_array_oracle<std::array<ElementType, Extent>> : mozilla::TrueType
-{
-};
-
-template<class T>
-struct is_std_array : public is_std_array_oracle<remove_cv_t<T>>
-{
-};
-
-template<size_t From, size_t To>
-struct is_allowed_extent_conversion
-  : public mozilla::IntegralConstant<bool,
-                                  From == To ||
-                                    From == mozilla::dynamic_extent ||
-                                    To == mozilla::dynamic_extent>
-{
-};
-
-template<class From, class To>
-struct is_allowed_element_type_conversion
-  : public mozilla::IntegralConstant<bool, mozilla::IsConvertible<From (*)[], To (*)[]>::value>
-{
-};
-
-template<class Span, bool IsConst>
-class span_iterator
-{
-  using element_type_ = typename Span::element_type;
-
-public:
-  using iterator_category = std::random_access_iterator_tag;
-  using value_type = remove_const_t<element_type_>;
-  using difference_type = typename Span::index_type;
-
-  using reference = conditional_t<IsConst, const element_type_, element_type_>&;
-  using pointer = add_pointer_t<reference>;
-
-  constexpr span_iterator() : span_iterator(nullptr, 0) {}
-
-                               span_iterator(const Span* span,
-                                             typename Span::index_type index)
-    : span_(span)
-    , index_(index)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span == nullptr || (index_ >= 0 && index <= span_->Length()))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span == nullptr || (index_ >= 0 && index <= span_->Length())))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span == nullptr || (index_ >= 0 && index <= span_->Length())" ")"); do { *((volatile int*) __null) = 176; ::abort(); } while (0); } } while (0);
-
-  }
-
-  friend class span_iterator<Span, true>;
-  constexpr span_iterator(const span_iterator<Span, false>& other)
-    : span_iterator(other.span_, other.index_)
-  {
-  }
-
-                                          span_iterator<Span, IsConst>&
-  operator=(const span_iterator<Span, IsConst>&) = default;
-
-                         reference operator*() const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 190; ::abort(); } while (0); } } while (0);
-    return (*span_)[index_];
-  }
-
-                         pointer operator->() const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_" ")"); do { *((volatile int*) __null) = 196; ::abort(); } while (0); } } while (0);
-    return &((*span_)[index_]);
-  }
-
-                               span_iterator& operator++()
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && index_ >= 0 && index_ < span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ >= 0 && index_ < span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ >= 0 && index_ < span_->Length()" ")"); do { *((volatile int*) __null) = 202; ::abort(); } while (0); } } while (0);
-    ++index_;
-    return *this;
-  }
-
-                               span_iterator operator++(int)
-  {
-    auto ret = *this;
-    ++(*this);
-    return ret;
-  }
-
-                               span_iterator& operator--()
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && index_ > 0 && index_ <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && index_ > 0 && index_ <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && index_ > 0 && index_ <= span_->Length()" ")"); do { *((volatile int*) __null) = 216; ::abort(); } while (0); } } while (0);
-    --index_;
-    return *this;
-  }
-
-                               span_iterator operator--(int)
-  {
-    auto ret = *this;
-    --(*this);
-    return ret;
-  }
-
-                                     span_iterator
-  operator+(difference_type n) const
-  {
-    auto ret = *this;
-    return ret += n;
-  }
-
-                         span_iterator& operator+=(difference_type n)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ && (index_ + n) >= 0 && (index_ + n) <= span_->Length()" ")"); do { *((volatile int*) __null) = 238; ::abort(); } while (0); } } while (0);
-
-    index_ += n;
-    return *this;
-  }
-
-                                     span_iterator
-  operator-(difference_type n) const
-  {
-    auto ret = *this;
-    return ret -= n;
-  }
-
-                               span_iterator& operator-=(difference_type n)
-
-  {
-    return *this += -n;
-  }
-
-                         difference_type
-  operator-(const span_iterator& rhs) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(span_ == rhs.span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 259; ::abort(); } while (0); } } while (0);
-    return index_ - rhs.index_;
-  }
-
-  constexpr reference operator[](difference_type n) const
-  {
-    return *(*this + n);
-  }
-
-  constexpr friend bool operator==(const span_iterator& lhs,
-                                   const span_iterator& rhs)
-  {
-    return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
-  }
-
-  constexpr friend bool operator!=(const span_iterator& lhs,
-                                   const span_iterator& rhs)
-  {
-    return !(lhs == rhs);
-  }
-
-                         friend bool operator<(const span_iterator& lhs,
-                                               const span_iterator& rhs)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(lhs.span_ == rhs.span_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(lhs.span_ == rhs.span_))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "lhs.span_ == rhs.span_" ")"); do { *((volatile int*) __null) = 283; ::abort(); } while (0); } } while (0);
-    return lhs.index_ < rhs.index_;
-  }
-
-  constexpr friend bool operator<=(const span_iterator& lhs,
-                                   const span_iterator& rhs)
-  {
-    return !(rhs < lhs);
-  }
-
-  constexpr friend bool operator>(const span_iterator& lhs,
-                                  const span_iterator& rhs)
-  {
-    return rhs < lhs;
-  }
-
-  constexpr friend bool operator>=(const span_iterator& lhs,
-                                   const span_iterator& rhs)
-  {
-    return !(rhs > lhs);
-  }
-
-  void swap(span_iterator& rhs)
-  {
-    std::swap(index_, rhs.index_);
-    std::swap(span_, rhs.span_);
-  }
-
-protected:
-  const Span* span_;
-  size_t index_;
-};
-
-template<class Span, bool IsConst>
-inline constexpr span_iterator<Span, IsConst>
-operator+(typename span_iterator<Span, IsConst>::difference_type n,
-          const span_iterator<Span, IsConst>& rhs)
-{
-  return rhs + n;
-}
-
-template<size_t Ext>
-class extent_type
-{
-public:
-  using index_type = size_t;
-
-  static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size.");
-
-  constexpr extent_type() {}
-
-  template<index_type Other>
-                                            extent_type(extent_type<Other> ext)
-  {
-    static_assert(
-      Other == Ext || Other == dynamic_extent,
-      "Mismatch between fixed-size extent and size of initializing data.");
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(ext.size() == Ext)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ext.size() == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "ext.size() == Ext" ")"); do { *((volatile int*) __null) = 340; ::abort(); } while (0); } } while (0);
-  }
-
-                                            extent_type(index_type length)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(length == Ext)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(length == Ext))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "length == Ext" ")"); do { *((volatile int*) __null) = 345; ::abort(); } while (0); } } while (0);
-  }
-
-  constexpr index_type size() const { return Ext; }
-};
-
-template<>
-class extent_type<dynamic_extent>
-{
-public:
-  using index_type = size_t;
-
-  template<index_type Other>
-  explicit constexpr extent_type(extent_type<Other> ext)
-    : size_(ext.size())
-  {
-  }
-
-  explicit constexpr extent_type(index_type length)
-    : size_(length)
-  {
-  }
-
-  constexpr index_type size() const { return size_; }
-
-private:
-  index_type size_;
-};
-}
-# 436 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Span.h"
-template<class ElementType, size_t Extent>
-class Span
-{
-public:
-
-  using element_type = ElementType;
-  using index_type = size_t;
-  using pointer = element_type*;
-  using reference = element_type&;
-
-  using iterator =
-    span_details::span_iterator<Span<ElementType, Extent>, false>;
-  using const_iterator =
-    span_details::span_iterator<Span<ElementType, Extent>, true>;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-  constexpr static const index_type extent = Extent;
-
-
-
-
-
-
-
-  template<
-    bool Dependent = false,
-    class = span_details::enable_if_t<
-      (Dependent || Extent == 0 || Extent == mozilla::MaxValue<size_t>::value)>>
-  constexpr Span()
-    : storage_(nullptr, span_details::extent_type<0>())
-  {
-  }
-
-
-
-
-  constexpr Span(std::nullptr_t) : Span() {}
-
-
-
-
-  constexpr Span(pointer aPtr, index_type aLength)
-    : storage_(aPtr, aLength)
-  {
-  }
-
-
-
-
-  constexpr Span(pointer aStartPtr, pointer aEndPtr)
-    : storage_(aStartPtr, std::distance(aStartPtr, aEndPtr))
-  {
-  }
-
-
-
-
-  template<size_t N>
-  constexpr Span(element_type (&aArr)[N])
-    : storage_(&aArr[0], span_details::extent_type<N>())
-  {
-  }
-
-
-
-
-  template<size_t N,
-           class ArrayElementType = span_details::remove_const_t<element_type>>
-  constexpr Span(std::array<ArrayElementType, N>& aArr)
-    : storage_(&aArr[0], span_details::extent_type<N>())
-  {
-  }
-
-
-
-
-  template<size_t N>
-  constexpr Span(
-    const std::array<span_details::remove_const_t<element_type>, N>& aArr)
-    : storage_(&aArr[0], span_details::extent_type<N>())
-  {
-  }
-
-
-
-
-  template<size_t N,
-           class ArrayElementType = span_details::remove_const_t<element_type>>
-  constexpr Span(mozilla::Array<ArrayElementType, N>& aArr)
-    : storage_(&aArr[0], span_details::extent_type<N>())
-  {
-  }
-
-
-
-
-  template<size_t N>
-  constexpr Span(
-    const mozilla::Array<span_details::remove_const_t<element_type>, N>& aArr)
-    : storage_(&aArr[0], span_details::extent_type<N>())
-  {
-  }
-
-
-
-
-  template<class ArrayElementType = std::add_pointer<element_type>>
-  constexpr Span(const mozilla::UniquePtr<ArrayElementType>& aPtr,
-                 index_type aLength)
-    : storage_(aPtr.get(), aLength)
-  {
-  }
-
-
-
-
-
-
-  template<
-    class Container,
-    class = span_details::enable_if_t<
-      !span_details::is_span<Container>::value &&
-      !span_details::is_std_array<Container>::value &&
-      mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
-      mozilla::IsConvertible<typename Container::pointer,
-                          decltype(mozilla::DeclVal<Container>().data())>::value>>
-  constexpr Span(Container& cont)
-    : Span(cont.data(), ReleaseAssertedCast<index_type>(cont.size()))
-  {
-  }
-
-
-
-
-  template<
-    class Container,
-    class = span_details::enable_if_t<
-      mozilla::IsConst<element_type>::value &&
-      !span_details::is_span<Container>::value &&
-      mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
-      mozilla::IsConvertible<typename Container::pointer,
-                          decltype(mozilla::DeclVal<Container>().data())>::value>>
-  constexpr Span(const Container& cont)
-    : Span(cont.data(), ReleaseAssertedCast<index_type>(cont.size()))
-  {
-  }
-
-
-
-
-  constexpr Span(const Span& other) = default;
-
-
-
-
-  constexpr Span(Span&& other) = default;
-
-
-
-
-  template<
-    class OtherElementType,
-    size_t OtherExtent,
-    class = span_details::enable_if_t<
-      span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
-      span_details::is_allowed_element_type_conversion<OtherElementType,
-                                                       element_type>::value>>
-  constexpr Span(const Span<OtherElementType, OtherExtent>& other)
-    : storage_(other.data(),
-               span_details::extent_type<OtherExtent>(other.size()))
-  {
-  }
-
-
-
-
-  template<
-    class OtherElementType,
-    size_t OtherExtent,
-    class = span_details::enable_if_t<
-      span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
-      span_details::is_allowed_element_type_conversion<OtherElementType,
-                                                       element_type>::value>>
-  constexpr Span(Span<OtherElementType, OtherExtent>&& other)
-    : storage_(other.data(),
-               span_details::extent_type<OtherExtent>(other.size()))
-  {
-  }
-
-  ~Span() = default;
-                                          Span& operator=(const Span& other)
-    = default;
-
-                                          Span& operator=(Span&& other)
-    = default;
-
-
-
-
-
-  template<size_t Count>
-                         Span<element_type, Count> First() const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Count <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 640; ::abort(); } while (0); } } while (0);
-    return { data(), Count };
-  }
-
-
-
-
-  template<size_t Count>
-                         Span<element_type, Count> Last() const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Count <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Count <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Count <= size()" ")"); do { *((volatile int*) __null) = 650; ::abort(); } while (0); } } while (0);
-    return { data() + (size() - Count), Count };
-  }
-
-
-
-
-  template<size_t Offset, size_t Count = dynamic_extent>
-                         Span<element_type, Count> Subspan() const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size())))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "Offset <= size() && (Count == dynamic_extent || (Offset + Count <= size()))" ")"); do { *((volatile int*) __null) = 661; ::abort(); } while (0); } } while (0);
-
-    return { data() + Offset,
-             Count == dynamic_extent ? size() - Offset : Count };
-  }
-
-
-
-
-                         Span<element_type, dynamic_extent> First(
-    index_type aCount) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 672; ::abort(); } while (0); } } while (0);
-    return { data(), aCount };
-  }
-
-
-
-
-                         Span<element_type, dynamic_extent> Last(
-    index_type aCount) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount <= size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount <= size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount <= size()" ")"); do { *((volatile int*) __null) = 682; ::abort(); } while (0); } } while (0);
-    return { data() + (size() - aCount), aCount };
-  }
-
-
-
-
-                         Span<element_type, dynamic_extent> Subspan(
-    index_type aStart,
-    index_type aLength = dynamic_extent) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size())))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= size() && (aLength == dynamic_extent || (aStart + aLength <= size()))" ")"); do { *((volatile int*) __null) = 695; ::abort(); } while (0); } } while (0);
-
-
-    return { data() + aStart,
-             aLength == dynamic_extent ? size() - aStart : aLength };
-  }
-
-
-
-
-                         Span<element_type, dynamic_extent> From(
-    index_type aStart) const
-  {
-    return Subspan(aStart);
-  }
-
-
-
-
-                         Span<element_type, dynamic_extent> To(
-    index_type aEnd) const
-  {
-    return Subspan(0, aEnd);
-  }
-
-
-
-
-
-                         Span<element_type, dynamic_extent> FromTo(
-    index_type aStart,
-    index_type aEnd) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aStart <= aEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aStart <= aEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aStart <= aEnd" ")"); do { *((volatile int*) __null) = 726; ::abort(); } while (0); } } while (0);
-    return Subspan(aStart, aEnd - aStart);
-  }
-
-
-
-
-
-  constexpr index_type Length() const { return size(); }
-
-
-
-
-  constexpr index_type size() const { return storage_.size(); }
-
-
-
-
-  constexpr index_type LengthBytes() const { return size_bytes(); }
-
-
-
-
-  constexpr index_type size_bytes() const
-  {
-    return size() * narrow_cast<index_type>(sizeof(element_type));
-  }
-
-
-
-
-  constexpr bool IsEmpty() const { return empty(); }
-
-
-
-
-
-  constexpr bool empty() const { return size() == 0; }
-
-
-                         reference operator[](index_type idx) const
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(idx < storage_.size())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(idx < storage_.size()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "idx < storage_.size()" ")"); do { *((volatile int*) __null) = 768; ::abort(); } while (0); } } while (0);
-    return data()[idx];
-  }
-
-
-
-
-  constexpr reference at(index_type idx) const { return this->operator[](idx); }
-
-  constexpr reference operator()(index_type idx) const
-  {
-    return this->operator[](idx);
-  }
-
-
-
-
-  constexpr pointer Elements() const { return data(); }
-
-
-
-
-  constexpr pointer data() const { return storage_.data(); }
-
-
-  iterator begin() const { return { this, 0 }; }
-  iterator end() const { return { this, Length() }; }
-
-  const_iterator cbegin() const { return { this, 0 }; }
-  const_iterator cend() const { return { this, Length() }; }
-
-  reverse_iterator rbegin() const
-  {
-    return reverse_iterator{ end() };
-  }
-  reverse_iterator rend() const
-  {
-    return reverse_iterator{ begin() };
-  }
-
-  const_reverse_iterator crbegin() const
-  {
-    return const_reverse_iterator{ cend() };
-  }
-  const_reverse_iterator crend() const
-  {
-    return const_reverse_iterator{ cbegin() };
-  }
-
-private:
-
-
-
-  template<class ExtentType>
-  class storage_type : public ExtentType
-  {
-  public:
-    template<class OtherExtentType>
-                                 storage_type(pointer elements,
-                                              OtherExtentType ext)
-      : ExtentType(ext)
-      , data_(elements)
-    {
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)" ")"); do { *((volatile int*) __null) = 833; ::abort(); } while (0); } } while (0);
-
-
-    }
-
-    constexpr pointer data() const { return data_; }
-
-  private:
-    pointer data_;
-  };
-
-  storage_type<span_details::extent_type<Extent>> storage_;
-};
-
-
-template<class ElementType, size_t FirstExtent, size_t SecondExtent>
-inline constexpr bool
-operator==(const Span<ElementType, FirstExtent>& l,
-           const Span<ElementType, SecondExtent>& r)
-{
-  return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin());
-}
-
-template<class ElementType, size_t Extent>
-inline constexpr bool
-operator!=(const Span<ElementType, Extent>& l,
-           const Span<ElementType, Extent>& r)
-{
-  return !(l == r);
-}
-
-template<class ElementType, size_t Extent>
-inline constexpr bool
-operator<(const Span<ElementType, Extent>& l,
-          const Span<ElementType, Extent>& r)
-{
-  return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
-}
-
-template<class ElementType, size_t Extent>
-inline constexpr bool
-operator<=(const Span<ElementType, Extent>& l,
-           const Span<ElementType, Extent>& r)
-{
-  return !(l > r);
-}
-
-template<class ElementType, size_t Extent>
-inline constexpr bool
-operator>(const Span<ElementType, Extent>& l,
-          const Span<ElementType, Extent>& r)
-{
-  return r < l;
-}
-
-template<class ElementType, size_t Extent>
-inline constexpr bool
-operator>=(const Span<ElementType, Extent>& l,
-           const Span<ElementType, Extent>& r)
-{
-  return !(l < r);
-}
-
-namespace span_details {
-
-
-
-
-
-
-template<class ElementType, size_t Extent>
-struct calculate_byte_size
-  : mozilla::IntegralConstant<size_t,
-                           static_cast<size_t>(sizeof(ElementType) *
-                                               static_cast<size_t>(Extent))>
-{
-};
-
-template<class ElementType>
-struct calculate_byte_size<ElementType, dynamic_extent>
-  : mozilla::IntegralConstant<size_t, dynamic_extent>
-{
-};
-}
-
-
-
-
-
-template<class ElementType, size_t Extent>
-Span<const uint8_t,
-     span_details::calculate_byte_size<ElementType, Extent>::value>
-AsBytes(Span<ElementType, Extent> s)
-{
-  return { reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes() };
-}
-
-
-
-
-template<class ElementType,
-         size_t Extent,
-         class = span_details::enable_if_t<!mozilla::IsConst<ElementType>::value>>
-Span<uint8_t, span_details::calculate_byte_size<ElementType, Extent>::value>
-AsWritableBytes(Span<ElementType, Extent> s)
-{
-  return { reinterpret_cast<uint8_t*>(s.data()), s.size_bytes() };
-}
-
-
-
-
-
-
-
-template<class ElementType>
-Span<ElementType>
-MakeSpan(ElementType* aPtr, typename Span<ElementType>::index_type aLength)
-{
-  return Span<ElementType>(aPtr, aLength);
-}
-
-
-
-
-template<class ElementType>
-Span<ElementType>
-MakeSpan(ElementType* aStartPtr, ElementType* aEndPtr)
-{
-  return Span<ElementType>(aStartPtr, aEndPtr);
-}
-
-
-
-
-template<class ElementType, size_t N>
-Span<ElementType> MakeSpan(ElementType (&aArr)[N])
-{
-  return Span<ElementType>(aArr);
-}
-
-
-
-
-template<class ElementType, size_t N>
-Span<ElementType>
-MakeSpan(mozilla::Array<ElementType, N>& aArr)
-{
-  return aArr;
-}
-
-
-
-
-template<class ElementType, size_t N>
-Span<const ElementType>
-MakeSpan(const mozilla::Array<ElementType, N>& arr)
-{
-  return arr;
-}
-
-
-
-
-template<class Container>
-Span<typename Container::value_type>
-MakeSpan(Container& cont)
-{
-  return Span<typename Container::value_type>(cont);
-}
-
-
-
-
-template<class Container>
-Span<const typename Container::value_type>
-MakeSpan(const Container& cont)
-{
-  return Span<const typename Container::value_type>(cont);
-}
-
-
-
-
-template<class Ptr>
-Span<typename Ptr::element_type>
-MakeSpan(Ptr& aPtr, size_t aLength)
-{
-  return Span<typename Ptr::element_type>(aPtr, aLength);
-}
-
-
-
-
-inline Span<const char>
-MakeStringSpan(const char* aZeroTerminated)
-{
-  return Span<const char>(aZeroTerminated, std::strlen(aZeroTerminated));
-}
-
-
-
-
-inline Span<const char16_t>
-MakeStringSpan(const char16_t* aZeroTerminated)
-{
-  return Span<const char16_t>(aZeroTerminated, span_details::strlen16(aZeroTerminated));
-}
-
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h"
-namespace mozilla {
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumeratedArray.h"
-template<typename IndexType,
-         IndexType SizeAsEnumValue,
-         typename ValueType>
-class EnumeratedArray
-{
-public:
-  static const size_t kSize = size_t(SizeAsEnumValue);
-
-private:
-  typedef Array<ValueType, kSize> ArrayType;
-
-  ArrayType mArray;
-
-public:
-  EnumeratedArray() {}
-
-  template <typename... Args>
-               EnumeratedArray(Args&&... aArgs)
-    : mArray{mozilla::Forward<Args>(aArgs)...}
-  {}
-
-  explicit EnumeratedArray(const EnumeratedArray& aOther)
-  {
-    for (size_t i = 0; i < kSize; i++) {
-      mArray[i] = aOther.mArray[i];
-    }
-  }
-
-  EnumeratedArray(EnumeratedArray&& aOther)
-  {
-    for (size_t i = 0; i < kSize; i++) {
-      mArray[i] = Move(aOther.mArray[i]);
-    }
-  }
-
-  ValueType& operator[](IndexType aIndex)
-  {
-    return mArray[size_t(aIndex)];
-  }
-
-  const ValueType& operator[](IndexType aIndex) const
-  {
-    return mArray[size_t(aIndex)];
-  }
-
-  typedef typename ArrayType::iterator iterator;
-  typedef typename ArrayType::const_iterator const_iterator;
-  typedef typename ArrayType::reverse_iterator reverse_iterator;
-  typedef typename ArrayType::const_reverse_iterator const_reverse_iterator;
-
-
-  iterator begin() { return mArray.begin(); }
-  const_iterator begin() const { return mArray.begin(); }
-  const_iterator cbegin() const { return mArray.cbegin(); }
-  iterator end() { return mArray.end(); }
-  const_iterator end() const { return mArray.end(); }
-  const_iterator cend() const { return mArray.cend(); }
-
-
-  reverse_iterator rbegin() { return mArray.rbegin(); }
-  const_reverse_iterator rbegin() const { return mArray.rbegin(); }
-  const_reverse_iterator crbegin() const { return mArray.crbegin(); }
-  reverse_iterator rend() { return mArray.rend(); }
-  const_reverse_iterator rend() const { return mArray.rend(); }
-  const_reverse_iterator crend() const { return mArray.crend(); }
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h" 1
-# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
-namespace mozilla {
-
-template<typename T>
-class LinkedListElement;
-
-namespace detail {
-
-
-
-
-
-
-template<typename T>
-struct LinkedListElementTraits
-{
-  typedef T* RawType;
-  typedef const T* ConstRawType;
-  typedef T* ClientType;
-  typedef const T* ConstClientType;
-
-
-
-
-
-
-  static void enterList(LinkedListElement<T>* elt) {}
-  static void exitList(LinkedListElement<T>* elt) {}
-};
-
-template<typename T>
-struct LinkedListElementTraits<RefPtr<T>>
-{
-  typedef T* RawType;
-  typedef const T* ConstRawType;
-  typedef RefPtr<T> ClientType;
-  typedef RefPtr<const T> ConstClientType;
-
-  static void enterList(LinkedListElement<RefPtr<T>>* elt) { elt->asT()->AddRef(); }
-  static void exitList(LinkedListElement<RefPtr<T>>* elt) { elt->asT()->Release(); }
-};
-
-}
-
-template<typename T>
-class LinkedList;
-
-template<typename T>
-class LinkedListElement
-{
-  typedef typename detail::LinkedListElementTraits<T> Traits;
-  typedef typename Traits::RawType RawType;
-  typedef typename Traits::ConstRawType ConstRawType;
-  typedef typename Traits::ClientType ClientType;
-  typedef typename Traits::ConstClientType ConstClientType;
-# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
-private:
-  LinkedListElement* mNext;
-  LinkedListElement* mPrev;
-  const bool mIsSentinel;
-
-public:
-  LinkedListElement()
-    : mNext(this),
-      mPrev(this),
-      mIsSentinel(false)
-  { }
-
-
-
-
-
-  LinkedListElement(LinkedListElement<T>&& aOther)
-    : mIsSentinel(aOther.mIsSentinel)
-  {
-    adjustLinkForMove(Move(aOther));
-  }
-
-  LinkedListElement& operator=(LinkedListElement<T>&& aOther)
-  {
-    do { } while (0);
-    do { } while (0);
-
-    adjustLinkForMove(Move(aOther));
-    return *this;
-  }
-
-  ~LinkedListElement()
-  {
-    if (!mIsSentinel && isInList()) {
-      remove();
-    }
-  }
-
-
-
-
-
-  RawType getNext() { return mNext->asT(); }
-  ConstRawType getNext() const { return mNext->asT(); }
-
-
-
-
-
-  RawType getPrevious() { return mPrev->asT(); }
-  ConstRawType getPrevious() const { return mPrev->asT(); }
-
-
-
-
-
-  void setNext(RawType aElem)
-  {
-    do { } while (0);
-    setNextUnsafe(aElem);
-  }
-
-
-
-
-
-
-  void setPrevious(RawType aElem)
-  {
-    do { } while (0);
-    setPreviousUnsafe(aElem);
-  }
-
-
-
-
-
-  void remove()
-  {
-    do { } while (0);
-
-    mPrev->mNext = mNext;
-    mNext->mPrev = mPrev;
-    mNext = this;
-    mPrev = this;
-
-    Traits::exitList(this);
-  }
-
-
-
-
-
-
-  ClientType removeAndGetNext()
-  {
-    ClientType r = getNext();
-    remove();
-    return r;
-  }
-
-
-
-
-
-
-  ClientType removeAndGetPrevious()
-  {
-    ClientType r = getPrevious();
-    remove();
-    return r;
-  }
-
-
-
-
-
-  void removeFrom(const LinkedList<T>& aList)
-  {
-    aList.assertContains(asT());
-    remove();
-  }
-
-
-
-
-  bool isInList() const
-  {
-    do { } while (0);
-    return mNext != this;
-  }
-
-private:
-  friend class LinkedList<T>;
-  friend struct detail::LinkedListElementTraits<T>;
-
-  enum class NodeKind {
-    Normal,
-    Sentinel
-  };
-
-  explicit LinkedListElement(NodeKind nodeKind)
-    : mNext(this),
-      mPrev(this),
-      mIsSentinel(nodeKind == NodeKind::Sentinel)
-  { }
-
-
-
-
-
-  RawType asT()
-  {
-    return mIsSentinel ? nullptr : static_cast<RawType>(this);
-  }
-  ConstRawType asT() const
-  {
-    return mIsSentinel ? nullptr : static_cast<ConstRawType>(this);
-  }
-
-
-
-
-
-  void setNextUnsafe(RawType aElem)
-  {
-    LinkedListElement *listElem = static_cast<LinkedListElement*>(aElem);
-    do { } while (0);
-
-    listElem->mNext = this->mNext;
-    listElem->mPrev = this;
-    this->mNext->mPrev = listElem;
-    this->mNext = listElem;
-
-    Traits::enterList(aElem);
-  }
-
-
-
-
-
-  void setPreviousUnsafe(RawType aElem)
-  {
-    LinkedListElement<T>* listElem = static_cast<LinkedListElement<T>*>(aElem);
-    do { } while (0);
-
-    listElem->mNext = this;
-    listElem->mPrev = this->mPrev;
-    this->mPrev->mNext = listElem;
-    this->mPrev = listElem;
-
-    Traits::enterList(aElem);
-  }
-
-
-
-
-
-  void adjustLinkForMove(LinkedListElement<T>&& aOther)
-  {
-    if (!aOther.isInList()) {
-      mNext = this;
-      mPrev = this;
-      return;
-    }
-
-    if (!mIsSentinel) {
-      Traits::enterList(this);
-    }
-
-    do { } while (0);
-    do { } while (0);
-
-
-
-
-
-    mNext = aOther.mNext;
-    mPrev = aOther.mPrev;
-
-    mNext->mPrev = this;
-    mPrev->mNext = this;
-
-
-
-
-
-    aOther.mNext = &aOther;
-    aOther.mPrev = &aOther;
-
-    if (!mIsSentinel) {
-      Traits::exitList(&aOther);
-    }
-  }
-
-  LinkedListElement& operator=(const LinkedListElement<T>& aOther) = delete;
-  LinkedListElement(const LinkedListElement<T>& aOther) = delete;
-};
-
-template<typename T>
-class LinkedList
-{
-private:
-  typedef typename detail::LinkedListElementTraits<T> Traits;
-  typedef typename Traits::RawType RawType;
-  typedef typename Traits::ConstRawType ConstRawType;
-  typedef typename Traits::ClientType ClientType;
-  typedef typename Traits::ConstClientType ConstClientType;
-
-  LinkedListElement<T> sentinel;
-
-public:
-  class Iterator {
-    RawType mCurrent;
-
-  public:
-    explicit Iterator(RawType aCurrent) : mCurrent(aCurrent) {}
-
-    RawType operator *() const {
-      return mCurrent;
-    }
-
-    const Iterator& operator++() {
-      mCurrent = mCurrent->getNext();
-      return *this;
-    }
-
-    bool operator!=(Iterator& aOther) const {
-      return mCurrent != aOther.mCurrent;
-    }
-  };
-
-  LinkedList() : sentinel(LinkedListElement<T>::NodeKind::Sentinel) { }
-
-  LinkedList(LinkedList<T>&& aOther)
-    : sentinel(mozilla::Move(aOther.sentinel))
-  { }
-
-  LinkedList& operator=(LinkedList<T>&& aOther)
-  {
-    do { } while (0);
-    sentinel = mozilla::Move(aOther.sentinel);
-    return *this;
-  }
-
-  ~LinkedList() {
-    do { } while (0);
-
-
-
-  }
-
-
-
-
-  void insertFront(RawType aElem)
-  {
-
-    sentinel.setNextUnsafe(aElem);
-  }
-
-
-
-
-  void insertBack(RawType aElem)
-  {
-    sentinel.setPreviousUnsafe(aElem);
-  }
-
-
-
-
-  RawType getFirst() { return sentinel.getNext(); }
-  ConstRawType getFirst() const { return sentinel.getNext(); }
-
-
-
-
-  RawType getLast() { return sentinel.getPrevious(); }
-  ConstRawType getLast() const { return sentinel.getPrevious(); }
-
-
-
-
-
-  ClientType popFirst()
-  {
-    ClientType ret = sentinel.getNext();
-    if (ret) {
-      static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
-    }
-    return ret;
-  }
-
-
-
-
-
-  ClientType popLast()
-  {
-    ClientType ret = sentinel.getPrevious();
-    if (ret) {
-      static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
-    }
-    return ret;
-  }
-
-
-
-
-  bool isEmpty() const
-  {
-    return !sentinel.isInList();
-  }
-
-
-
-
-
-
-
-  void clear()
-  {
-    while (popFirst()) {
-      continue;
-    }
-  }
-
-
-
-
-
-
-  Iterator begin() {
-    return Iterator(getFirst());
-  }
-  Iterator end() {
-    return Iterator(nullptr);
-  }
-
-
-
-
-
-
-
-  size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
-  {
-    size_t n = 0;
-    for (const T* t = getFirst(); t; t = t->getNext()) {
-      n += aMallocSizeOf(t);
-    }
-    return n;
-  }
-
-
-
-
-  size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-
-  void debugAssertIsSane() const
-  {
-# 622 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
-  }
-
-private:
-  friend class LinkedListElement<T>;
-
-  void assertContains(const RawType aValue) const
-  {
-# 637 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
-  }
-
-  LinkedList& operator=(const LinkedList<T>& aOther) = delete;
-  LinkedList(const LinkedList<T>& aOther) = delete;
-};
-
-template <typename T>
-class AutoCleanLinkedList : public LinkedList<T>
-{
-public:
-  ~AutoCleanLinkedList()
-  {
-    while (T* element = this->popFirst()) {
-      delete element;
-    }
-  }
-};
-
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h" 2
-
-
-
-
-
-
-
-
-namespace mozilla {
-# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
-template<class T>
-__attribute__((always_inline)) inline size_t
-PointerRangeSize(T* aBegin, T* aEnd)
-{
-  do { } while (0);
-  return (size_t(aEnd) - size_t(aBegin)) / sizeof(T);
-}
-
-
-
-
-
-
-
-template<typename T, size_t N>
-constexpr size_t
-ArrayLength(T (&aArr)[N])
-{
-  return N;
-}
-
-template<typename T, size_t N>
-constexpr size_t
-ArrayLength(const Array<T, N>& aArr)
-{
-  return N;
-}
-
-template<typename E, E N, typename T>
-constexpr size_t
-ArrayLength(const EnumeratedArray<E, N, T>& aArr)
-{
-  return size_t(N);
-}
-
-
-
-
-
-
-template<typename T, size_t N>
-constexpr T*
-ArrayEnd(T (&aArr)[N])
-{
-  return aArr + ArrayLength(aArr);
-}
-
-template<typename T, size_t N>
-constexpr T*
-ArrayEnd(Array<T, N>& aArr)
-{
-  return &aArr[0] + ArrayLength(aArr);
-}
-
-template<typename T, size_t N>
-constexpr const T*
-ArrayEnd(const Array<T, N>& aArr)
-{
-  return &aArr[0] + ArrayLength(aArr);
-}
-
-namespace detail {
-
-template<typename AlignType, typename Pointee,
-         typename = EnableIf<!IsVoid<AlignType>::value>>
-struct AlignedChecker
-{
-  static void
-  test(const Pointee* aPtr)
-  {
-    do { } while (0);
-
-  }
-};
-
-template<typename AlignType, typename Pointee>
-struct AlignedChecker<AlignType, Pointee>
-{
-  static void
-  test(const Pointee* aPtr)
-  {
-  }
-};
-
-}
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayUtils.h"
-template<typename T, typename U>
-inline typename EnableIf<IsSame<T, U>::value ||
-                         IsBaseOf<T, U>::value ||
-                         IsVoid<T>::value,
-                         bool>::Type
-IsInRange(const T* aPtr, const U* aBegin, const U* aEnd)
-{
-  do { } while (0);
-  detail::AlignedChecker<U, T>::test(aPtr);
-  detail::AlignedChecker<U, U>::test(aBegin);
-  detail::AlignedChecker<U, U>::test(aEnd);
-  return aBegin <= reinterpret_cast<const U*>(aPtr) &&
-         reinterpret_cast<const U*>(aPtr) < aEnd;
-}
-
-
-
-
-
-
-template<typename T>
-inline bool
-IsInRange(const T* aPtr, uintptr_t aBegin, uintptr_t aEnd)
-{
-  return IsInRange(aPtr,
-                   reinterpret_cast<const T*>(aBegin),
-                   reinterpret_cast<const T*>(aEnd));
-}
-
-namespace detail {
-
-
-
-
-
-template <typename T, size_t N>
-char (&ArrayLengthHelper(T (&array)[N]))[N];
-
-}
-
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h" 2
-
-
-
-
-
-namespace mozilla {
-
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodZero(T* aT)
-{
-  memset(aT, 0, sizeof(T));
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodZero(T* aT, size_t aNElem)
-{
-
-
-
-
-
-  for (T* end = aT + aNElem; aT < end; aT++) {
-    memset(aT, 0, sizeof(T));
-  }
-}
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
-template<typename T, size_t N>
-static void PodZero(T (&aT)[N]) = delete;
-template<typename T, size_t N>
-static void PodZero(T (&aT)[N], size_t aNElem) = delete;
-
-
-template <class T, size_t N>
-static __attribute__((always_inline)) inline void
-PodArrayZero(T (&aT)[N])
-{
-  memset(aT, 0, N * sizeof(T));
-}
-
-template <typename T, size_t N>
-static __attribute__((always_inline)) inline void
-PodArrayZero(Array<T, N>& aArr)
-{
-  memset(&aArr[0], 0, N * sizeof(T));
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodAssign(T* aDst, const T* aSrc)
-{
-  do { } while (0);
-
-  memcpy(reinterpret_cast<char*>(aDst), reinterpret_cast<const char*>(aSrc),
-         sizeof(T));
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodCopy(T* aDst, const T* aSrc, size_t aNElem)
-{
-  do { } while (0);
-
-  if (aNElem < 128) {
-
-
-
-
-    for (const T* srcend = aSrc + aNElem; aSrc < srcend; aSrc++, aDst++) {
-      PodAssign(aDst, aSrc);
-    }
-  } else {
-    memcpy(aDst, aSrc, aNElem * sizeof(T));
-  }
-}
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodCopy(volatile T* aDst, const volatile T* aSrc, size_t aNElem)
-{
-  do { } while (0);
-# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PodOperations.h"
-  for (const volatile T* srcend = aSrc + aNElem;
-       aSrc < srcend;
-       aSrc++, aDst++) {
-    *aDst = *aSrc;
-  }
-}
-
-
-
-
-
-template <class T, size_t N>
-static __attribute__((always_inline)) inline void
-PodArrayCopy(T (&aDst)[N], const T (&aSrc)[N])
-{
-  PodCopy(aDst, aSrc, N);
-}
-
-
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline void
-PodMove(T* aDst, const T* aSrc, size_t aNElem)
-{
-  do { } while (0);
-
-  memmove(aDst, aSrc, aNElem * sizeof(T));
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-PodEqual(const T* one, const T* two, size_t len)
-{
-  if (len < 128) {
-    const T* p1end = one + len;
-    const T* p1 = one;
-    const T* p2 = two;
-    for (; p1 < p1end; p1++, p2++) {
-      if (*p1 != *p2) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  return !memcmp(one, two, len * sizeof(T));
-}
-
-
-
-
-
-template <class T, size_t N>
-static __attribute__((always_inline)) inline bool
-PodEqual(const T (&one)[N], const T (&two)[N])
-{
-  return PodEqual(one, two, N);
-}
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsprototypes.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 1
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js-config.h" 1
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsversion.h" 1
-# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 1
-# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
-namespace mozilla {
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
-template<typename T>
-class DebugOnly
-{
-public:
-# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DebugOnly.h"
-  DebugOnly() { }
-               DebugOnly(const T&) { }
-  DebugOnly(const DebugOnly&) { }
-  DebugOnly& operator=(const T&) { return *this; }
-  void operator++(int) { }
-  void operator--(int) { }
-  DebugOnly& operator+=(const T&) { return *this; }
-  DebugOnly& operator-=(const T&) { return *this; }
-  DebugOnly& operator&=(const T&) { return *this; }
-  DebugOnly& operator|=(const T&) { return *this; }
-  DebugOnly& operator^=(const T&) { return *this; }
-
-
-
-
-
-
-
-  ~DebugOnly() {}
-};
-
-}
-# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h" 2
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
-namespace mozilla {
-
-namespace detail {
-
-
-
-
-
-
-template<typename T, size_t Size = sizeof(T)>
-struct Swapper;
-
-template<typename T>
-struct Swapper<T, 2>
-{
-  static T swap(T aValue)
-  {
-
-    return __builtin_bswap16(aValue);
-
-
-
-  }
-};
-
-template<typename T>
-struct Swapper<T, 4>
-{
-  static T swap(T aValue)
-  {
-
-    return T(__builtin_bswap32(aValue));
-# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
-  }
-};
-
-template<typename T>
-struct Swapper<T, 8>
-{
-  static inline T swap(T aValue)
-  {
-
-    return T(__builtin_bswap64(aValue));
-# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
-  }
-};
-
-enum Endianness { Little, Big };
-
-
-
-
-
-
-
-class EndianUtils
-{
-
-
-
-
-  static void assertNoOverlap(const void* aDest, const void* aSrc,
-                              size_t aCount)
-  {
-    DebugOnly<const uint8_t*> byteDestPtr = static_cast<const uint8_t*>(aDest);
-    DebugOnly<const uint8_t*> byteSrcPtr = static_cast<const uint8_t*>(aSrc);
-    do { } while (0);
-
-
-
-  }
-
-  template<typename T>
-  static void assertAligned(T* aPtr)
-  {
-    do { } while (0);
-  }
-
-protected:
-
-
-
-
-  template<Endianness SourceEndian, Endianness DestEndian, typename T>
-  static inline T maybeSwap(T aValue)
-  {
-    if (SourceEndian == DestEndian) {
-      return aValue;
-    }
-    return Swapper<T>::swap(aValue);
-  }
-
-
-
-
-
-  template<Endianness SourceEndian, Endianness DestEndian, typename T>
-  static inline void maybeSwapInPlace(T* aPtr, size_t aCount)
-  {
-    assertAligned(aPtr);
-
-    if (SourceEndian == DestEndian) {
-      return;
-    }
-    for (size_t i = 0; i < aCount; i++) {
-      aPtr[i] = Swapper<T>::swap(aPtr[i]);
-    }
-  }
-
-
-
-
-
-  template<Endianness SourceEndian, Endianness DestEndian, typename T>
-  static void copyAndSwapTo(void* aDest, const T* aSrc, size_t aCount)
-  {
-    assertNoOverlap(aDest, aSrc, aCount * sizeof(T));
-    assertAligned(aSrc);
-
-    if (SourceEndian == DestEndian) {
-      memcpy(aDest, aSrc, aCount * sizeof(T));
-      return;
-    }
-
-    uint8_t* byteDestPtr = static_cast<uint8_t*>(aDest);
-    for (size_t i = 0; i < aCount; ++i) {
-      union
-      {
-        T mVal;
-        uint8_t mBuffer[sizeof(T)];
-      } u;
-      u.mVal = maybeSwap<SourceEndian, DestEndian>(aSrc[i]);
-      memcpy(byteDestPtr, u.mBuffer, sizeof(T));
-      byteDestPtr += sizeof(T);
-    }
-  }
-
-
-
-
-
-  template<Endianness SourceEndian, Endianness DestEndian, typename T>
-  static void copyAndSwapFrom(T* aDest, const void* aSrc, size_t aCount)
-  {
-    assertNoOverlap(aDest, aSrc, aCount * sizeof(T));
-    assertAligned(aDest);
-
-    if (SourceEndian == DestEndian) {
-      memcpy(aDest, aSrc, aCount * sizeof(T));
-      return;
-    }
-
-    const uint8_t* byteSrcPtr = static_cast<const uint8_t*>(aSrc);
-    for (size_t i = 0; i < aCount; ++i) {
-      union
-      {
-        T mVal;
-        uint8_t mBuffer[sizeof(T)];
-      } u;
-      memcpy(u.mBuffer, byteSrcPtr, sizeof(T));
-      aDest[i] = maybeSwap<SourceEndian, DestEndian>(u.mVal);
-      byteSrcPtr += sizeof(T);
-    }
-  }
-};
-
-template<Endianness ThisEndian>
-class Endian : private EndianUtils
-{
-protected:
-
-  static __attribute__ ((warn_unused_result)) uint16_t readUint16(const void* aPtr)
-  {
-    return read<uint16_t>(aPtr);
-  }
-
-
-  static __attribute__ ((warn_unused_result)) uint32_t readUint32(const void* aPtr)
-  {
-    return read<uint32_t>(aPtr);
-  }
-
-
-  static __attribute__ ((warn_unused_result)) uint64_t readUint64(const void* aPtr)
-  {
-    return read<uint64_t>(aPtr);
-  }
-
-
-  static __attribute__ ((warn_unused_result)) int16_t readInt16(const void* aPtr)
-  {
-    return read<int16_t>(aPtr);
-  }
-
-
-  static __attribute__ ((warn_unused_result)) int32_t readInt32(const void* aPtr)
-  {
-    return read<uint32_t>(aPtr);
-  }
-
-
-  static __attribute__ ((warn_unused_result)) int64_t readInt64(const void* aPtr)
-  {
-    return read<int64_t>(aPtr);
-  }
-
-
-  static void writeUint16(void* aPtr, uint16_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-
-
-  static void writeUint32(void* aPtr, uint32_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-
-
-  static void writeUint64(void* aPtr, uint64_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-
-
-  static void writeInt16(void* aPtr, int16_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-
-
-  static void writeInt32(void* aPtr, int32_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-
-
-  static void writeInt64(void* aPtr, int64_t aValue)
-  {
-    write(aPtr, aValue);
-  }
-# 425 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EndianUtils.h"
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapToLittleEndian(T aValue)
-  {
-    return maybeSwap<ThisEndian, Little>(aValue);
-  }
-
-
-
-
-
-
-  template<typename T>
-  static void copyAndSwapToLittleEndian(void* aDest, const T* aSrc,
-                                        size_t aCount)
-  {
-    copyAndSwapTo<ThisEndian, Little>(aDest, aSrc, aCount);
-  }
-
-
-
-
-  template<typename T>
-  static void swapToLittleEndianInPlace(T* aPtr, size_t aCount)
-  {
-    maybeSwapInPlace<ThisEndian, Little>(aPtr, aCount);
-  }
-
-
-
-
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapToBigEndian(T aValue)
-  {
-    return maybeSwap<ThisEndian, Big>(aValue);
-  }
-
-
-
-
-
-
-  template<typename T>
-  static void copyAndSwapToBigEndian(void* aDest, const T* aSrc,
-                                     size_t aCount)
-  {
-    copyAndSwapTo<ThisEndian, Big>(aDest, aSrc, aCount);
-  }
-
-
-
-
-  template<typename T>
-  static void swapToBigEndianInPlace(T* aPtr, size_t aCount)
-  {
-    maybeSwapInPlace<ThisEndian, Big>(aPtr, aCount);
-  }
-
-
-
-
-
-
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapToNetworkOrder(T aValue)
-  {
-    return swapToBigEndian(aValue);
-  }
-
-  template<typename T>
-  static void
-  copyAndSwapToNetworkOrder(void* aDest, const T* aSrc, size_t aCount)
-  {
-    copyAndSwapToBigEndian(aDest, aSrc, aCount);
-  }
-
-  template<typename T>
-  static void
-  swapToNetworkOrderInPlace(T* aPtr, size_t aCount)
-  {
-    swapToBigEndianInPlace(aPtr, aCount);
-  }
-
-
-
-
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapFromLittleEndian(T aValue)
-  {
-    return maybeSwap<Little, ThisEndian>(aValue);
-  }
-
-
-
-
-
-
-  template<typename T>
-  static void copyAndSwapFromLittleEndian(T* aDest, const void* aSrc,
-                                          size_t aCount)
-  {
-    copyAndSwapFrom<Little, ThisEndian>(aDest, aSrc, aCount);
-  }
-
-
-
-
-  template<typename T>
-  static void swapFromLittleEndianInPlace(T* aPtr, size_t aCount)
-  {
-    maybeSwapInPlace<Little, ThisEndian>(aPtr, aCount);
-  }
-
-
-
-
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapFromBigEndian(T aValue)
-  {
-    return maybeSwap<Big, ThisEndian>(aValue);
-  }
-
-
-
-
-
-
-  template<typename T>
-  static void copyAndSwapFromBigEndian(T* aDest, const void* aSrc,
-                                       size_t aCount)
-  {
-    copyAndSwapFrom<Big, ThisEndian>(aDest, aSrc, aCount);
-  }
-
-
-
-
-  template<typename T>
-  static void swapFromBigEndianInPlace(T* aPtr, size_t aCount)
-  {
-    maybeSwapInPlace<Big, ThisEndian>(aPtr, aCount);
-  }
-
-
-
-
-
-  template<typename T>
-  __attribute__ ((warn_unused_result)) static T swapFromNetworkOrder(T aValue)
-  {
-    return swapFromBigEndian(aValue);
-  }
-
-  template<typename T>
-  static void copyAndSwapFromNetworkOrder(T* aDest, const void* aSrc,
-                                          size_t aCount)
-  {
-    copyAndSwapFromBigEndian(aDest, aSrc, aCount);
-  }
-
-  template<typename T>
-  static void swapFromNetworkOrderInPlace(T* aPtr, size_t aCount)
-  {
-    swapFromBigEndianInPlace(aPtr, aCount);
-  }
-
-private:
-
-
-
-
-  template<typename T>
-  static T read(const void* aPtr)
-  {
-    union
-    {
-      T mVal;
-      uint8_t mBuffer[sizeof(T)];
-    } u;
-    memcpy(u.mBuffer, aPtr, sizeof(T));
-    return maybeSwap<ThisEndian, detail::Little>(u.mVal);
-  }
-
-
-
-
-
-  template<typename T>
-  static void write(void* aPtr, T aValue)
-  {
-    T tmp = maybeSwap<detail::Little, ThisEndian>(aValue);
-    memcpy(aPtr, &tmp, sizeof(T));
-  }
-
-  Endian() = delete;
-  Endian(const Endian& aTther) = delete;
-  void operator=(const Endian& aOther) = delete;
-};
-
-template<Endianness ThisEndian>
-class EndianReadWrite : public Endian<ThisEndian>
-{
-private:
-  typedef Endian<ThisEndian> super;
-
-public:
-  using super::readUint16;
-  using super::readUint32;
-  using super::readUint64;
-  using super::readInt16;
-  using super::readInt32;
-  using super::readInt64;
-  using super::writeUint16;
-  using super::writeUint32;
-  using super::writeUint64;
-  using super::writeInt16;
-  using super::writeInt32;
-  using super::writeInt64;
-};
-
-}
-
-class LittleEndian final : public detail::EndianReadWrite<detail::Little>
-{};
-
-class BigEndian final : public detail::EndianReadWrite<detail::Big>
-{};
-
-typedef BigEndian NetworkEndian;
-
-class NativeEndian final : public detail::Endian<detail::Little>
-{
-private:
-  typedef detail::Endian<detail::Little> super;
-
-public:
-
-
-
-
-
-  using super::swapToLittleEndian;
-  using super::copyAndSwapToLittleEndian;
-  using super::swapToLittleEndianInPlace;
-  using super::swapToBigEndian;
-  using super::copyAndSwapToBigEndian;
-  using super::swapToBigEndianInPlace;
-  using super::swapToNetworkOrder;
-  using super::copyAndSwapToNetworkOrder;
-  using super::swapToNetworkOrderInPlace;
-
-
-
-
-
-
-  using super::swapFromLittleEndian;
-  using super::copyAndSwapFromLittleEndian;
-  using super::swapFromLittleEndianInPlace;
-  using super::swapFromBigEndian;
-  using super::copyAndSwapFromBigEndian;
-  using super::swapFromBigEndianInPlace;
-  using super::swapFromNetworkOrder;
-  using super::copyAndSwapFromNetworkOrder;
-  using super::swapFromNetworkOrderInPlace;
-};
-
-
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jscpucfg.h" 2
-# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jstypes.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 1
-# 119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h"
-namespace mozilla {
-enum NotNullTag {
-  KnownNotNull,
-};
-}
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OperatorNewExtensions.h"
-inline void*
-operator new(size_t, mozilla::NotNullTag, void* p)
-{
-  do { } while (0);
-  return p;
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 2
-
-
-
-
-
-
-namespace mozilla {
-
-template<typename... Ts>
-class Variant;
-
-namespace detail {
-
-template <typename...>
-struct FirstTypeIsInRest;
-
-template <typename First>
-struct FirstTypeIsInRest<First> : FalseType {};
-
-template <typename First, typename Second, typename... Rest>
-struct FirstTypeIsInRest<First, Second, Rest...>
-{
-  static constexpr bool value =
-    IsSame<First, Second>::value ||
-    FirstTypeIsInRest<First, Rest...>::value;
-};
-
-template <typename...>
-struct TypesAreDistinct;
-
-template <>
-struct TypesAreDistinct<> : TrueType { };
-
-template<typename First, typename... Rest>
-struct TypesAreDistinct<First, Rest...>
-{
-  static constexpr bool value =
-    !FirstTypeIsInRest<First, Rest...>::value &&
-    TypesAreDistinct<Rest...>::value;
-};
-
-
-
-
-
-
-template<typename Needle, typename... Haystack>
-struct IsVariant;
-
-template<typename Needle>
-struct IsVariant<Needle> : FalseType {};
-
-template<typename Needle, typename... Haystack>
-struct IsVariant<Needle, Needle, Haystack...> : TrueType {};
-
-template<typename Needle, typename T, typename... Haystack>
-struct IsVariant<Needle, T, Haystack...> : public IsVariant<Needle, Haystack...> { };
-
-
-template<typename T, typename... Variants>
-struct SelectVariantTypeHelper;
-
-template<typename T>
-struct SelectVariantTypeHelper<T>
-{ };
-
-template<typename T, typename... Variants>
-struct SelectVariantTypeHelper<T, T, Variants...>
-{
-  typedef T Type;
-};
-
-template<typename T, typename... Variants>
-struct SelectVariantTypeHelper<T, const T, Variants...>
-{
-  typedef const T Type;
-};
-
-template<typename T, typename... Variants>
-struct SelectVariantTypeHelper<T, const T&, Variants...>
-{
-  typedef const T& Type;
-};
-
-template<typename T, typename... Variants>
-struct SelectVariantTypeHelper<T, T&&, Variants...>
-{
-  typedef T&& Type;
-};
-
-template<typename T, typename Head, typename... Variants>
-struct SelectVariantTypeHelper<T, Head, Variants...>
-  : public SelectVariantTypeHelper<T, Variants...>
-{ };
-
-
-
-
-
-
-template <typename T, typename... Variants>
-struct SelectVariantType
-  : public SelectVariantTypeHelper<typename RemoveConst<typename RemoveReference<T>::Type>::Type,
-                                   Variants...>
-{ };
-
-
-
-template<typename... Ts>
-struct VariantTag
-{
-private:
-  static const size_t TypeCount = sizeof...(Ts);
-
-public:
-  using Type =
-    typename Conditional<TypeCount < 3,
-                         bool,
-                         typename Conditional<TypeCount < (1 << 8),
-                                              uint_fast8_t,
-                                              size_t
-                                              >::Type
-                         >::Type;
-};
-
-
-
-
-
-template<typename Tag, size_t N, typename T, typename U, typename Next, bool isMatch>
-struct TagHelper;
-
-
-template<typename Tag, size_t N, typename T, typename U, typename Next>
-struct TagHelper<Tag, N, T, U, Next, false>
-{
-  static Tag tag() { return Next::template tag<U>(); }
-};
-
-
-template<typename Tag, size_t N, typename T, typename U, typename Next>
-struct TagHelper<Tag, N, T, U, Next, true>
-{
-  static Tag tag() { return Tag(N); }
-};
-
-
-
-
-
-
-
-template<typename Tag, size_t N, typename... Ts>
-struct VariantImplementation;
-
-
-template<typename Tag, size_t N, typename T>
-struct VariantImplementation<Tag, N, T>
-{
-  template<typename U>
-  static Tag tag() {
-    static_assert(mozilla::IsSame<T, U>::value,
-                  "mozilla::Variant: tag: bad type!");
-    return Tag(N);
-  }
-
-  template<typename Variant>
-  static void copyConstruct(void* aLhs, const Variant& aRhs) {
-    ::new (KnownNotNull, aLhs) T(aRhs.template as<T>());
-  }
-
-  template<typename Variant>
-  static void moveConstruct(void* aLhs, Variant&& aRhs) {
-    ::new (KnownNotNull, aLhs) T(aRhs.template extract<T>());
-  }
-
-  template<typename Variant>
-  static void destroy(Variant& aV) {
-    aV.template as<T>().~T();
-  }
-
-  template<typename Variant>
-  static bool
-  equal(const Variant& aLhs, const Variant& aRhs) {
-      return aLhs.template as<T>() == aRhs.template as<T>();
-  }
-
-  template<typename Matcher, typename ConcreteVariant>
-  static auto
-  match(Matcher&& aMatcher, ConcreteVariant& aV)
-    -> decltype(aMatcher.match(aV.template as<T>()))
-  {
-    return aMatcher.match(aV.template as<T>());
-  }
-};
-
-
-template<typename Tag, size_t N, typename T, typename... Ts>
-struct VariantImplementation<Tag, N, T, Ts...>
-{
-
-  using Next = VariantImplementation<Tag, N + 1, Ts...>;
-
-  template<typename U>
-  static Tag tag() {
-    return TagHelper<Tag, N, T, U, Next, IsSame<T, U>::value>::tag();
-  }
-
-  template<typename Variant>
-  static void copyConstruct(void* aLhs, const Variant& aRhs) {
-    if (aRhs.template is<T>()) {
-      ::new (KnownNotNull, aLhs) T(aRhs.template as<T>());
-    } else {
-      Next::copyConstruct(aLhs, aRhs);
-    }
-  }
-
-  template<typename Variant>
-  static void moveConstruct(void* aLhs, Variant&& aRhs) {
-    if (aRhs.template is<T>()) {
-      ::new (KnownNotNull, aLhs) T(aRhs.template extract<T>());
-    } else {
-      Next::moveConstruct(aLhs, aRhs);
-    }
-  }
-
-  template<typename Variant>
-  static void destroy(Variant& aV) {
-    if (aV.template is<T>()) {
-      aV.template as<T>().~T();
-    } else {
-      Next::destroy(aV);
-    }
-  }
-
-  template<typename Variant>
-  static bool equal(const Variant& aLhs, const Variant& aRhs) {
-    if (aLhs.template is<T>()) {
-      do { } while (0);
-      return aLhs.template as<T>() == aRhs.template as<T>();
-    } else {
-      return Next::equal(aLhs, aRhs);
-    }
-  }
-
-  template<typename Matcher, typename ConcreteVariant>
-  static auto
-  match(Matcher&& aMatcher, ConcreteVariant& aV)
-    -> decltype(aMatcher.match(aV.template as<T>()))
-  {
-    if (aV.template is<T>()) {
-      return aMatcher.match(aV.template as<T>());
-    } else {
-# 278 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
-      return Next::match(aMatcher, aV);
-    }
-  }
-};
-
-
-
-
-
-
-
-template <typename T>
-struct AsVariantTemporary
-{
-  explicit AsVariantTemporary(const T& aValue)
-    : mValue(aValue)
-  {}
-
-  template<typename U>
-  explicit AsVariantTemporary(U&& aValue)
-    : mValue(Forward<U>(aValue))
-  {}
-
-  AsVariantTemporary(const AsVariantTemporary& aOther)
-    : mValue(aOther.mValue)
-  {}
-
-  AsVariantTemporary(AsVariantTemporary&& aOther)
-    : mValue(Move(aOther.mValue))
-  {}
-
-  AsVariantTemporary() = delete;
-  void operator=(const AsVariantTemporary&) = delete;
-  void operator=(AsVariantTemporary&&) = delete;
-
-  typename RemoveConst<typename RemoveReference<T>::Type>::Type mValue;
-};
-
-}
-# 447 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
-template<typename... Ts>
-class Variant
-{
-  static_assert(detail::TypesAreDistinct<Ts...>::value,
-                "Variant with duplicate types is not supported");
-
-  using Tag = typename detail::VariantTag<Ts...>::Type;
-  using Impl = detail::VariantImplementation<Tag, 0, Ts...>;
-
-  static constexpr size_t RawDataAlignment = tl::Max<alignof(Ts)...>::value;
-  static constexpr size_t RawDataSize = tl::Max<sizeof(Ts)...>::value;
-
-
-  alignas(RawDataAlignment) unsigned char rawData[RawDataSize];
-
-
-
-  Tag tag;
-
-
-
-
-
-  void* ptr() {
-    return rawData;
-  }
-
-  const void* ptr() const {
-    return rawData;
-  }
-
-public:
-
-  template<typename RefT,
-
-
-
-
-           typename T = typename detail::SelectVariantType<RefT, Ts...>::Type>
-  explicit Variant(RefT&& aT)
-    : tag(Impl::template tag<T>())
-  {
-    ::new (KnownNotNull, ptr()) T(Forward<RefT>(aT));
-  }
-
-
-
-
-
-
-  template<typename RefT,
-           typename T = typename detail::SelectVariantType<RefT, Ts...>::Type>
-               Variant(detail::AsVariantTemporary<RefT>&& aValue)
-    : tag(Impl::template tag<T>())
-  {
-    ::new (KnownNotNull, ptr()) T(Move(aValue.mValue));
-  }
-
-
-  Variant(const Variant& aRhs)
-    : tag(aRhs.tag)
-  {
-    Impl::copyConstruct(ptr(), aRhs);
-  }
-
-
-  Variant(Variant&& aRhs)
-    : tag(aRhs.tag)
-  {
-    Impl::moveConstruct(ptr(), Move(aRhs));
-  }
-
-
-  Variant& operator=(const Variant& aRhs) {
-    do { } while (0);
-    this->~Variant();
-    ::new (KnownNotNull, this) Variant(aRhs);
-    return *this;
-  }
-
-
-  Variant& operator=(Variant&& aRhs) {
-    do { } while (0);
-    this->~Variant();
-    ::new (KnownNotNull, this) Variant(Move(aRhs));
-    return *this;
-  }
-
-
-  template <typename T>
-  Variant& operator=(detail::AsVariantTemporary<T>&& aValue)
-  {
-    this->~Variant();
-    ::new (KnownNotNull, this) Variant(Move(aValue));
-    return *this;
-  }
-
-  ~Variant()
-  {
-    Impl::destroy(*this);
-  }
-
-
-  template<typename T>
-  bool is() const {
-    static_assert(detail::IsVariant<T, Ts...>::value,
-                  "provided a type not found in this Variant's type list");
-    return Impl::template tag<T>() == tag;
-  }
-
-
-
-
-
-  bool operator==(const Variant& aRhs) const {
-    return tag == aRhs.tag && Impl::equal(*this, aRhs);
-  }
-
-
-
-
-
-
-  bool operator!=(const Variant& aRhs) const {
-    return !(*this == aRhs);
-  }
-
-
-
-
-  template<typename T>
-  T& as() {
-    static_assert(detail::IsVariant<T, Ts...>::value,
-                  "provided a type not found in this Variant's type list");
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(is<T>())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is<T>()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is<T>()" ")"); do { *((volatile int*) __null) = 581; ::abort(); } while (0); } } while (0);
-    return *static_cast<T*>(ptr());
-  }
-
-
-  template<typename T>
-  const T& as() const {
-    static_assert(detail::IsVariant<T, Ts...>::value,
-                  "provided a type not found in this Variant's type list");
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(is<T>())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(is<T>()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "is<T>()" ")"); do { *((volatile int*) __null) = 590; ::abort(); } while (0); } } while (0);
-    return *static_cast<const T*>(ptr());
-  }
-
-
-
-
-
-
-
-  template<typename T>
-  T extract() {
-    static_assert(detail::IsVariant<T, Ts...>::value,
-                  "provided a type not found in this Variant's type list");
-    do { } while (0);
-    return T(Move(as<T>()));
-  }
-
-
-
-
-  template<typename Matcher>
-  auto
-  match(Matcher&& aMatcher) const
-    -> decltype(Impl::match(aMatcher, *this))
-  {
-    return Impl::match(aMatcher, *this);
-  }
-
-
-  template<typename Matcher>
-  auto
-  match(Matcher&& aMatcher)
-    -> decltype(Impl::match(aMatcher, *this))
-  {
-    return Impl::match(aMatcher, *this);
-  }
-};
-# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h"
-template<typename T>
-detail::AsVariantTemporary<T>
-AsVariant(T&& aValue)
-{
-  return detail::AsVariantTemporary<T>(Forward<T>(aValue));
-}
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h" 2
-
-namespace mozilla {
-
-
-
-
-
-
-struct Ok {};
-
-template <typename E> class GenericErrorResult;
-template <typename V, typename E> class Result;
-
-namespace detail {
-
-enum class PackingStrategy {
-  Variant,
-  NullIsOk,
-  LowBitTagIsError,
-  PackedVariant,
-};
-
-template <typename V, typename E, PackingStrategy Strategy>
-class ResultImplementation;
-
-template <typename V, typename E>
-class ResultImplementation<V, E, PackingStrategy::Variant>
-{
-  mozilla::Variant<V, E> mStorage;
-
-public:
-  explicit ResultImplementation(V aValue) : mStorage(aValue) {}
-  explicit ResultImplementation(E aErrorValue) : mStorage(aErrorValue) {}
-
-  bool isOk() const { return mStorage.template is<V>(); }
-
-
-
-
-  V unwrap() const { return mStorage.template as<V>(); }
-  E unwrapErr() const { return mStorage.template as<E>(); }
-};
-
-
-
-
-
-template <typename V, typename E>
-class ResultImplementation<V, E&, PackingStrategy::Variant>
-{
-  mozilla::Variant<V, E*> mStorage;
-
-public:
-  explicit ResultImplementation(V aValue) : mStorage(aValue) {}
-  explicit ResultImplementation(E& aErrorValue) : mStorage(&aErrorValue) {}
-
-  bool isOk() const { return mStorage.template is<V>(); }
-  V unwrap() const { return mStorage.template as<V>(); }
-  E& unwrapErr() const { return *mStorage.template as<E*>(); }
-};
-
-
-
-
-
-template <typename V, typename E>
-class ResultImplementation<V, E&, PackingStrategy::NullIsOk>
-{
-  E* mErrorValue;
-
-public:
-  explicit ResultImplementation(V) : mErrorValue(nullptr) {}
-  explicit ResultImplementation(E& aErrorValue) : mErrorValue(&aErrorValue) {}
-
-  bool isOk() const { return mErrorValue == nullptr; }
-
-  V unwrap() const { return V(); }
-  E& unwrapErr() const { return *mErrorValue; }
-};
-
-
-
-
-
-template <typename V, typename E>
-class ResultImplementation<V*, E&, PackingStrategy::LowBitTagIsError>
-{
-  uintptr_t mBits;
-
-public:
-  explicit ResultImplementation(V* aValue)
-    : mBits(reinterpret_cast<uintptr_t>(aValue))
-  {
-    do { } while (0);
-
-  }
-  explicit ResultImplementation(E& aErrorValue)
-    : mBits(reinterpret_cast<uintptr_t>(&aErrorValue) | 1)
-  {
-    do { } while (0);
-
-  }
-
-  bool isOk() const { return (mBits & 1) == 0; }
-
-  V* unwrap() const { return reinterpret_cast<V*>(mBits); }
-  E& unwrapErr() const { return *reinterpret_cast<E*>(mBits ^ 1); }
-};
-
-
-template<typename V, typename E>
-struct IsPackableVariant
-{
-  struct VEbool {
-      V v;
-      E e;
-      bool ok;
-  };
-  struct EVbool {
-      E e;
-      V v;
-      bool ok;
-  };
-
-  using Impl = typename Conditional<sizeof(VEbool) <= sizeof(EVbool),
-                                    VEbool, EVbool>::Type;
-
-  static const bool value = sizeof(Impl) <= sizeof(uintptr_t);
-};
-
-
-
-
-
-template <typename V, typename E>
-class ResultImplementation<V, E, PackingStrategy::PackedVariant>
-{
-  using Impl = typename IsPackableVariant<V, E>::Impl;
-  Impl data;
-
-public:
-  explicit ResultImplementation(V aValue)
-  {
-    data.v = aValue;
-    data.ok = true;
-  }
-  explicit ResultImplementation(E aErrorValue)
-  {
-    data.e = aErrorValue;
-    data.ok = false;
-  }
-
-  bool isOk() const { return data.ok; }
-
-  V unwrap() const { return data.v; }
-  E unwrapErr() const { return data.e; }
-};
-
-
-
-
-
-template<typename T>
-struct UnusedZero
-{
-  static const bool value = false;
-};
-
-
-template<typename T>
-struct UnusedZero<T&>
-{
-  static const bool value = true;
-};
-
-
-
-
-template <typename T> struct HasFreeLSB { static const bool value = false; };
-
-
-
-
-template <typename T> struct HasFreeLSB<T*> {
-  static const bool value = (mozilla::AlignmentFinder<T>::alignment & 1) == 0;
-};
-
-
-
-template <typename T> struct HasFreeLSB<T&> {
-  static const bool value = HasFreeLSB<T*>::value;
-};
-
-
-
-template <typename V, typename E>
-struct SelectResultImpl
-{
-  static const PackingStrategy value =
-      (IsEmpty<V>::value && UnusedZero<E>::value)
-    ? PackingStrategy::NullIsOk
-    : (detail::HasFreeLSB<V>::value && detail::HasFreeLSB<E>::value)
-    ? PackingStrategy::LowBitTagIsError
-    : (IsDefaultConstructible<V>::value && IsDefaultConstructible<E>::value &&
-       IsPackableVariant<V, E>::value)
-    ? PackingStrategy::PackedVariant
-    : PackingStrategy::Variant;
-
-  using Type = detail::ResultImplementation<V, E, value>;
-};
-
-template <typename T>
-struct IsResult : FalseType { };
-
-template <typename V, typename E>
-struct IsResult<Result<V, E>> : TrueType { };
-
-}
-# 263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
-template <typename V, typename E>
-class Result final
-{
-  using Impl = typename detail::SelectResultImpl<V, E>::Type;
-
-  Impl mImpl;
-
-public:
-
-
-
-               Result(V aValue) : mImpl(aValue) { do { } while (0); }
-
-
-
-
-  explicit Result(E aErrorValue) : mImpl(aErrorValue) { do { } while (0); }
-
-
-
-
-
-  template <typename E2>
-               Result(const GenericErrorResult<E2>& aErrorResult)
-    : mImpl(aErrorResult.mErrorValue)
-  {
-    static_assert(mozilla::IsConvertible<E2, E>::value,
-                  "E2 must be convertible to E");
-    do { } while (0);
-  }
-
-  Result(const Result&) = default;
-  Result& operator=(const Result&) = default;
-
-
-  bool isOk() const { return mImpl.isOk(); }
-
-
-  bool isErr() const { return !mImpl.isOk(); }
-
-
-  V unwrap() const {
-    do { } while (0);
-    return mImpl.unwrap();
-  }
-
-
-  E unwrapErr() const {
-    do { } while (0);
-    return mImpl.unwrapErr();
-  }
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
-  template<typename F>
-  auto map(F f) const -> Result<decltype(f(*((V*) nullptr))), E> {
-      using RetResult = Result<decltype(f(*((V*) nullptr))), E>;
-      return isOk() ? RetResult(f(unwrap())) : RetResult(unwrapErr());
-  }
-# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Result.h"
-  template<
-      typename F,
-      typename = typename EnableIf<
-          detail::IsResult<decltype((*((F*) nullptr))(*((V*) nullptr)))>::value
-      >::Type
-  >
-  auto andThen(F f) const -> decltype(f(*((V*) nullptr))) {
-      return isOk() ? f(unwrap()) : GenericErrorResult<E>(unwrapErr());
-  }
-};
-
-
-
-
-
-
-
-template <typename E>
-class GenericErrorResult
-{
-  E mErrorValue;
-
-  template<typename V, typename E2> friend class Result;
-
-public:
-  explicit GenericErrorResult(E aErrorValue) : mErrorValue(aErrorValue) {}
-};
-
-template <typename E>
-inline GenericErrorResult<E>
-Err(E&& aErrorValue)
-{
-  return GenericErrorResult<E>(aErrorValue);
-}
-
-}
-# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h" 2
-
-struct JSContext;
-# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
-namespace JS {
-
-using mozilla::Ok;
-
-
-
-
-
-struct Error
-{
-
-
-    int dummy;
-};
-
-struct OOM : public Error
-{
-};
-# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Result.h"
-template <typename V = Ok, typename E = Error&>
-using Result = mozilla::Result<V, E>;
-
-static_assert(sizeof(Result<>) == sizeof(uintptr_t),
-              "Result<> should be pointer-sized");
-
-static_assert(sizeof(Result<int*, Error&>) == sizeof(uintptr_t),
-              "Result<V*, Error&> should be pointer-sized");
-
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TypeDecls.h" 2
-
-
-
-
-struct JSContext;
-class JSFunction;
-class JSObject;
-class JSScript;
-class JSString;
-class JSAddonId;
-
-struct jsid;
-
-namespace JS {
-
-typedef unsigned char Latin1Char;
-
-class Symbol;
-class Value;
-template <typename T> class Handle;
-template <typename T> class MutableHandle;
-template <typename T> class Rooted;
-template <typename T> class PersistentRooted;
-
-typedef Handle<JSFunction*> HandleFunction;
-typedef Handle<jsid> HandleId;
-typedef Handle<JSObject*> HandleObject;
-typedef Handle<JSScript*> HandleScript;
-typedef Handle<JSString*> HandleString;
-typedef Handle<JS::Symbol*> HandleSymbol;
-typedef Handle<Value> HandleValue;
-
-typedef MutableHandle<JSFunction*> MutableHandleFunction;
-typedef MutableHandle<jsid> MutableHandleId;
-typedef MutableHandle<JSObject*> MutableHandleObject;
-typedef MutableHandle<JSScript*> MutableHandleScript;
-typedef MutableHandle<JSString*> MutableHandleString;
-typedef MutableHandle<JS::Symbol*> MutableHandleSymbol;
-typedef MutableHandle<Value> MutableHandleValue;
-
-typedef Rooted<JSObject*> RootedObject;
-typedef Rooted<JSFunction*> RootedFunction;
-typedef Rooted<JSScript*> RootedScript;
-typedef Rooted<JSString*> RootedString;
-typedef Rooted<JS::Symbol*> RootedSymbol;
-typedef Rooted<jsid> RootedId;
-typedef Rooted<JS::Value> RootedValue;
-
-typedef PersistentRooted<JSFunction*> PersistentRootedFunction;
-typedef PersistentRooted<jsid> PersistentRootedId;
-typedef PersistentRooted<JSObject*> PersistentRootedObject;
-typedef PersistentRooted<JSScript*> PersistentRootedScript;
-typedef PersistentRooted<JSString*> PersistentRootedString;
-typedef PersistentRooted<JS::Symbol*> PersistentRootedSymbol;
-typedef PersistentRooted<Value> PersistentRootedValue;
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h" 2
-
-
-namespace js {
-class BaseShape;
-class LazyScript;
-class ObjectGroup;
-class RegExpShared;
-class Shape;
-class Scope;
-namespace jit {
-class JitCode;
-}
-}
-
-namespace JS {
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
-enum class TraceKind
-{
-
-
-
-    Object = 0x00,
-    String = 0x02,
-    Symbol = 0x03,
-
-
-    Script = 0x01,
-
-
-    Shape = 0x04,
-
-
-    ObjectGroup = 0x05,
-
-
-    Null = 0x06,
-
-
-    BaseShape = 0x0F,
-    JitCode = 0x1F,
-    LazyScript = 0x2F,
-    Scope = 0x3F,
-    RegExpShared = 0x4F
-};
-const static uintptr_t OutOfLineTraceKindMask = 0x07;
-static_assert(uintptr_t(JS::TraceKind::BaseShape) & OutOfLineTraceKindMask, "mask bits are set");
-static_assert(uintptr_t(JS::TraceKind::JitCode) & OutOfLineTraceKindMask, "mask bits are set");
-static_assert(uintptr_t(JS::TraceKind::LazyScript) & OutOfLineTraceKindMask, "mask bits are set");
-static_assert(uintptr_t(JS::TraceKind::Scope) & OutOfLineTraceKindMask, "mask bits are set");
-static_assert(uintptr_t(JS::TraceKind::RegExpShared) & OutOfLineTraceKindMask, "mask bits are set");
-
-
-
-
-template <typename T>
-struct MapTypeToTraceKind {
-    static const JS::TraceKind kind = T::TraceKind;
-};
-# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
-template <> struct MapTypeToTraceKind<js::BaseShape> { static const JS::TraceKind kind = JS::TraceKind::BaseShape; }; template <> struct MapTypeToTraceKind<js::jit::JitCode> { static const JS::TraceKind kind = JS::TraceKind::JitCode; }; template <> struct MapTypeToTraceKind<js::LazyScript> { static const JS::TraceKind kind = JS::TraceKind::LazyScript; }; template <> struct MapTypeToTraceKind<js::Scope> { static const JS::TraceKind kind = JS::TraceKind::Scope; }; template <> struct MapTypeToTraceKind<JSObject> { static const JS::TraceKind kind = JS::TraceKind::Object; }; template <> struct MapTypeToTraceKind<js::ObjectGroup> { static const JS::TraceKind kind = JS::TraceKind::ObjectGroup; }; template <> struct MapTypeToTraceKind<JSScript> { static const JS::TraceKind kind = JS::TraceKind::Script; }; template <> struct MapTypeToTraceKind<js::Shape> { static const JS::TraceKind kind = JS::TraceKind::Shape; }; template <> struct MapTypeToTraceKind<JSString> { static const JS::TraceKind kind = JS::TraceKind::String; }; template <> struct MapTypeToTraceKind<JS::Symbol> { static const JS::TraceKind kind = JS::TraceKind::Symbol; }; template <> struct MapTypeToTraceKind<js::RegExpShared> { static const JS::TraceKind kind = JS::TraceKind::RegExpShared; };;
-
-
-
-
-
-enum class RootKind : int8_t
-{
-
-
-
-BaseShape, JitCode, LazyScript, Scope, Object, ObjectGroup, Script, Shape, String, Symbol, RegExpShared,
-
-
-
-    Id,
-    Value,
-
-
-    Traceable,
-
-    Limit
-};
-
-
-template <TraceKind traceKind> struct MapTraceKindToRootKind {};
-
-
-
-
-template <> struct MapTraceKindToRootKind<JS::TraceKind::BaseShape> { static const JS::RootKind kind = JS::RootKind::BaseShape; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::JitCode> { static const JS::RootKind kind = JS::RootKind::JitCode; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::LazyScript> { static const JS::RootKind kind = JS::RootKind::LazyScript; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Scope> { static const JS::RootKind kind = JS::RootKind::Scope; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Object> { static const JS::RootKind kind = JS::RootKind::Object; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::ObjectGroup> { static const JS::RootKind kind = JS::RootKind::ObjectGroup; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Script> { static const JS::RootKind kind = JS::RootKind::Script; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Shape> { static const JS::RootKind kind = JS::RootKind::Shape; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::String> { static const JS::RootKind kind = JS::RootKind::String; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::Symbol> { static const JS::RootKind kind = JS::RootKind::Symbol; }; template <> struct MapTraceKindToRootKind<JS::TraceKind::RegExpShared> { static const JS::RootKind kind = JS::RootKind::RegExpShared; };
-
-
-
-
-
-template <typename T>
-struct MapTypeToRootKind {
-    static const JS::RootKind kind = JS::RootKind::Traceable;
-};
-template <typename T>
-struct MapTypeToRootKind<T*> {
-    static const JS::RootKind kind =
-        JS::MapTraceKindToRootKind<JS::MapTypeToTraceKind<T>::kind>::kind;
-};
-template <typename T>
-struct MapTypeToRootKind<mozilla::UniquePtr<T>> {
-    static const JS::RootKind kind = JS::MapTypeToRootKind<T>::kind;
-};
-template <> struct MapTypeToRootKind<JS::Value> {
-    static const JS::RootKind kind = JS::RootKind::Value;
-};
-template <> struct MapTypeToRootKind<jsid> {
-    static const JS::RootKind kind = JS::RootKind::Id;
-};
-template <> struct MapTypeToRootKind<JSFunction*> : public MapTypeToRootKind<JSObject*> {};
-# 183 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TraceKind.h"
-template <typename F, typename... Args>
-auto
-DispatchTraceKindTyped(F f, JS::TraceKind traceKind, Args&&... args)
-  -> decltype(f. template operator()<JSObject>(mozilla::Forward<Args>(args)...))
-{
-    switch (traceKind) {
-
-
-
-      case JS::TraceKind::BaseShape: return f. template operator()<js::BaseShape>(mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f. template operator()<js::jit::JitCode>(mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f. template operator()<js::LazyScript>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f. template operator()<js::Scope>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f. template operator()<JSObject>(mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f. template operator()<js::ObjectGroup>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f. template operator()<JSScript>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f. template operator()<js::Shape>(mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f. template operator()<JSString>(mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f. template operator()<JS::Symbol>(mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f. template operator()<js::RegExpShared>(mozilla::Forward<Args>(args)...);;
-
-      default:
-          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 195; ::abort(); } while (0); } while (0);
-    }
-}
-
-
-template <typename F, typename... Args>
-auto
-DispatchTraceKindTyped(F f, void* thing, JS::TraceKind traceKind, Args&&... args)
-  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
-{
-    switch (traceKind) {
-
-
-
-      case JS::TraceKind::BaseShape: return f(static_cast<js::BaseShape*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f(static_cast<js::jit::JitCode*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f(static_cast<js::LazyScript*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f(static_cast<js::Scope*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f(static_cast<JSObject*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f(static_cast<js::ObjectGroup*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f(static_cast<JSScript*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f(static_cast<js::Shape*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f(static_cast<JSString*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f(static_cast<JS::Symbol*>(thing), mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f(static_cast<js::RegExpShared*>(thing), mozilla::Forward<Args>(args)...);;
-
-      default:
-          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTraceKindTyped." ")"); do { *((volatile int*) __null) = 212; ::abort(); } while (0); } while (0);
-    }
-}
-
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h" 2
-
-
-
-
-
-
-namespace JS {
-
-class AutoIdVector;
-class CallArgs;
-
-template <typename T>
-class Rooted;
-
-class CompileOptions;
-class ReadOnlyCompileOptions;
-class OwningCompileOptions;
-class TransitiveCompileOptions;
-class CompartmentOptions;
-
-class Value;
-struct Zone;
-
-}
-
-
-
-
-
-
-enum JSVersion {
-    JSVERSION_ECMA_3 = 148,
-    JSVERSION_1_6 = 160,
-    JSVERSION_1_7 = 170,
-    JSVERSION_1_8 = 180,
-    JSVERSION_ECMA_5 = 185,
-    JSVERSION_DEFAULT = 0,
-    JSVERSION_UNKNOWN = -1,
-    JSVERSION_LATEST = JSVERSION_ECMA_5
-};
-
-
-enum JSType {
-    JSTYPE_UNDEFINED,
-    JSTYPE_OBJECT,
-    JSTYPE_FUNCTION,
-    JSTYPE_STRING,
-    JSTYPE_NUMBER,
-    JSTYPE_BOOLEAN,
-    JSTYPE_NULL,
-    JSTYPE_SYMBOL,
-    JSTYPE_LIMIT
-};
-
-
-enum JSProtoKey {
-
-    JSProto_Null = 0, JSProto_Object = 1, JSProto_Function = 2, JSProto_Array = 3, JSProto_Boolean = 4, JSProto_JSON = 5, JSProto_Date = 6, JSProto_Math = 7, JSProto_Number = 8, JSProto_String = 9, JSProto_RegExp = 10, JSProto_Error = 11, JSProto_InternalError = 12, JSProto_EvalError = 13, JSProto_RangeError = 14, JSProto_ReferenceError = 15, JSProto_SyntaxError = 16, JSProto_TypeError = 17, JSProto_URIError = 18, JSProto_DebuggeeWouldRun = 19, JSProto_CompileError = 20, JSProto_LinkError = 21, JSProto_RuntimeError = 22, JSProto_Iterator = 23, JSProto_StopIteration = 24, JSProto_ArrayBuffer = 25, JSProto_Int8Array = 26, JSProto_Uint8Array = 27, JSProto_Int16Array = 28, JSProto_Uint16Array = 29, JSProto_Int32Array = 30, JSProto_Uint32Array = 31, JSProto_Float32Array = 32, JSProto_Float64Array = 33, JSProto_Uint8ClampedArray = 34, JSProto_Proxy = 35, JSProto_WeakMap = 36, JSProto_Map = 37, JSProto_Set = 38, JSProto_DataView = 39, JSProto_Symbol = 40, JSProto_SharedArrayBuffer = 41, JSProto_Intl = 42, JSProto_TypedObject = 43, JSProto_Reflect = 44, JSProto_SIMD = 45, JSProto_WeakSet = 46, JSProto_TypedArray = 47, JSProto_Atomics = 48, JSProto_SavedFrame = 49, JSProto_WebAssembly = 50, JSProto_WasmModule = 51, JSProto_WasmInstance = 52, JSProto_WasmMemory = 53, JSProto_WasmTable = 54, JSProto_Promise = 55,
-
-    JSProto_LIMIT
-};
-
-
-struct JSClass;
-struct JSCompartment;
-struct JSCrossCompartmentCall;
-class JSErrorReport;
-struct JSExceptionState;
-struct JSFunctionSpec;
-struct JSLocaleCallbacks;
-struct JSObjectMap;
-struct JSPrincipals;
-struct JSPropertyName;
-struct JSPropertySpec;
-struct JSRuntime;
-struct JSSecurityCallbacks;
-struct JSStructuredCloneCallbacks;
-struct JSStructuredCloneReader;
-struct JSStructuredCloneWriter;
-class JSTracer;
-
-class JSFlatString;
-
-typedef bool (*JSInitCallback)(void);
-
-template<typename T> struct JSConstScalarSpec;
-typedef JSConstScalarSpec<double> JSConstDoubleSpec;
-typedef JSConstScalarSpec<int32_t> JSConstIntegerSpec;
-
-
-
-
-
-typedef void
-(* JSTraceDataOp)(JSTracer* trc, void* data);
-
-namespace js {
-namespace gc {
-class AutoTraceSession;
-class StoreBuffer;
-}
-
-class CooperatingContext;
-
-inline JSCompartment* GetContextCompartment(const JSContext* cx);
-inline JS::Zone* GetContextZone(const JSContext* cx);
-
-
-
-bool
-CurrentThreadCanAccessRuntime(const JSRuntime* rt);
-
-
-
-
-
-
-}
-
-namespace JS {
-
-class AutoEnterCycleCollection;
-class AutoAssertOnBarrier;
-struct PropertyDescriptor;
-
-typedef void (*OffThreadCompileCallback)(void* token, void* callbackData);
-
-enum class HeapState {
-    Idle,
-    Tracing,
-    MajorCollecting,
-    MinorCollecting,
-    CycleCollecting
-};
-
-HeapState
-CurrentThreadHeapState();
-
-static inline bool
-CurrentThreadIsHeapBusy()
-{
-    return CurrentThreadHeapState() != HeapState::Idle;
-}
-
-static inline bool
-CurrentThreadIsHeapTracing()
-{
-    return CurrentThreadHeapState() == HeapState::Tracing;
-}
-
-static inline bool
-CurrentThreadIsHeapMajorCollecting()
-{
-    return CurrentThreadHeapState() == HeapState::MajorCollecting;
-}
-
-static inline bool
-CurrentThreadIsHeapMinorCollecting()
-{
-    return CurrentThreadHeapState() == HeapState::MinorCollecting;
-}
-
-static inline bool
-CurrentThreadIsHeapCollecting()
-{
-    HeapState state = CurrentThreadHeapState();
-    return state == HeapState::MajorCollecting || state == HeapState::MinorCollecting;
-}
-
-static inline bool
-CurrentThreadIsHeapCycleCollecting()
-{
-    return CurrentThreadHeapState() == HeapState::CycleCollecting;
-}
-
-
-
-class AutoEnterCycleCollection
-{
-
-
-
-
-
-
-
-  public:
-    explicit AutoEnterCycleCollection(JSContext* cx) {}
-    ~AutoEnterCycleCollection() {}
-
-};
-
-class RootingContext;
-
-class AutoGCRooter
-{
-  public:
-    AutoGCRooter(JSContext* cx, ptrdiff_t tag);
-    AutoGCRooter(RootingContext* cx, ptrdiff_t tag);
-
-    ~AutoGCRooter() {
-        do { } while (0);
-        *stackTop = down;
-    }
-
-
-    inline void trace(JSTracer* trc);
-    static void traceAll(const js::CooperatingContext& target, JSTracer* trc);
-    static void traceAllWrappers(const js::CooperatingContext& target, JSTracer* trc);
-
-  protected:
-    AutoGCRooter * const down;
-# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
-    ptrdiff_t tag_;
-
-    enum {
-        VALARRAY = -2,
-        PARSER = -3,
-        VALVECTOR = -10,
-        IDVECTOR = -11,
-        OBJVECTOR = -14,
-        IONMASM = -19,
-        WRAPVECTOR = -20,
-        WRAPPER = -21,
-        CUSTOM = -26
-    };
-
-    static ptrdiff_t GetTag(const Value& value) { return VALVECTOR; }
-    static ptrdiff_t GetTag(const jsid& id) { return IDVECTOR; }
-    static ptrdiff_t GetTag(JSObject* obj) { return OBJVECTOR; }
-
-  private:
-    AutoGCRooter ** const stackTop;
-
-
-    AutoGCRooter(AutoGCRooter& ida) = delete;
-    void operator=(AutoGCRooter& ida) = delete;
-};
-
-
-
-template <>
-struct MapTypeToRootKind<void*> {
-    static const RootKind kind = RootKind::Traceable;
-};
-
-using RootedListHeads = mozilla::EnumeratedArray<RootKind, RootKind::Limit,
-                                                 Rooted<void*>*>;
-
-
-
-
-
-
-enum StackKind
-{
-    StackForSystemCode,
-    StackForTrustedScript,
-    StackForUntrustedScript,
-    StackKindCount
-};
-
-
-
-class RootingContext
-{
-
-    RootedListHeads stackRoots_;
-    template <typename T> friend class JS::Rooted;
-
-
-    JS::AutoGCRooter* autoGCRooters_;
-    friend class JS::AutoGCRooter;
-
-  public:
-    RootingContext();
-
-    void traceStackRoots(JSTracer* trc);
-    void checkNoGCRooters();
-
-  protected:
-
-
-
-
-
-    JSCompartment* compartment_;
-
-
-    JS::Zone* zone_;
-
-  public:
-
-    uintptr_t nativeStackLimit[StackKindCount];
-
-    static const RootingContext* get(const JSContext* cx) {
-        return reinterpret_cast<const RootingContext*>(cx);
-    }
-
-    static RootingContext* get(JSContext* cx) {
-        return reinterpret_cast<RootingContext*>(cx);
-    }
-
-    friend JSCompartment* js::GetContextCompartment(const JSContext* cx);
-    friend JS::Zone* js::GetContextZone(const JSContext* cx);
-};
-
-}
-
-namespace js {
-# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jspubtd.h"
-inline JSCompartment*
-GetContextCompartment(const JSContext* cx)
-{
-    return JS::RootingContext::get(cx)->compartment_;
-}
-
-inline JS::Zone*
-GetContextZone(const JSContext* cx)
-{
-    return JS::RootingContext::get(cx)->zone_;
-}
-
-}
-
-extern "C" {
-
-
-typedef struct PRFileDesc PRFileDesc;
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 1
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-namespace mozilla {
-# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-enum MemoryOrdering {
-# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-  Relaxed,
-# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-  ReleaseAcquire,
-# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-  SequentiallyConsistent,
-};
-
-}
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 1 3
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 3
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 1 3
-# 34 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
-# 43 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 55 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
-  typedef enum memory_order
-    {
-      memory_order_relaxed,
-      memory_order_consume,
-      memory_order_acquire,
-      memory_order_release,
-      memory_order_acq_rel,
-      memory_order_seq_cst
-    } memory_order;
-
-  enum __memory_order_modifier
-    {
-      __memory_order_mask = 0x0ffff,
-      __memory_order_modifier_mask = 0xffff0000,
-      __memory_order_hle_acquire = 0x10000,
-      __memory_order_hle_release = 0x20000
-    };
-
-  constexpr memory_order
-  operator|(memory_order __m, __memory_order_modifier __mod)
-  {
-    return memory_order(__m | int(__mod));
-  }
-
-  constexpr memory_order
-  operator&(memory_order __m, __memory_order_modifier __mod)
-  {
-    return memory_order(__m & int(__mod));
-  }
-
-
-  constexpr memory_order
-  __cmpexch_failure_order2(memory_order __m) noexcept
-  {
-    return __m == memory_order_acq_rel ? memory_order_acquire
-      : __m == memory_order_release ? memory_order_relaxed : __m;
-  }
-
-  constexpr memory_order
-  __cmpexch_failure_order(memory_order __m) noexcept
-  {
-    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
-      | (__m & __memory_order_modifier_mask));
-  }
-
-  inline __attribute__((__always_inline__)) void
-  atomic_thread_fence(memory_order __m) noexcept
-  { __atomic_thread_fence(__m); }
-
-  inline __attribute__((__always_inline__)) void
-  atomic_signal_fence(memory_order __m) noexcept
-  { __atomic_signal_fence(__m); }
-
-
-  template<typename _Tp>
-    inline _Tp
-    kill_dependency(_Tp __y) noexcept
-    {
-      _Tp __ret(__y);
-      return __ret;
-    }
-
-
-
-  template<typename _IntTp>
-    struct __atomic_base;
-
-
-
-
-  template<typename _Tp>
-    struct atomic;
-
-  template<typename _Tp>
-    struct atomic<_Tp*>;
-
-
-
-    typedef bool __atomic_flag_data_type;
-# 148 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
-  extern "C" {
-
-  struct __atomic_flag_base
-  {
-    __atomic_flag_data_type _M_i;
-  };
-
-  }
-
-
-
-
-  struct atomic_flag : public __atomic_flag_base
-  {
-    atomic_flag() noexcept = default;
-    ~atomic_flag() noexcept = default;
-    atomic_flag(const atomic_flag&) = delete;
-    atomic_flag& operator=(const atomic_flag&) = delete;
-    atomic_flag& operator=(const atomic_flag&) volatile = delete;
-
-
-    constexpr atomic_flag(bool __i) noexcept
-      : __atomic_flag_base{ _S_init(__i) }
-    { }
-
-    inline __attribute__((__always_inline__)) bool
-    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
-    {
-      return __atomic_test_and_set (&_M_i, __m);
-    }
-
-    inline __attribute__((__always_inline__)) bool
-    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
-    {
-      return __atomic_test_and_set (&_M_i, __m);
-    }
-
-    inline __attribute__((__always_inline__)) void
-    clear(memory_order __m = memory_order_seq_cst) noexcept
-    {
-      memory_order __b = __m & __memory_order_mask;
-                                                   ;
-                                                   ;
-                                                   ;
-
-      __atomic_clear (&_M_i, __m);
-    }
-
-    inline __attribute__((__always_inline__)) void
-    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
-    {
-      memory_order __b = __m & __memory_order_mask;
-                                                   ;
-                                                   ;
-                                                   ;
-
-      __atomic_clear (&_M_i, __m);
-    }
-
-  private:
-    static constexpr __atomic_flag_data_type
-    _S_init(bool __i)
-    { return __i ? 1 : 0; }
-  };
-# 237 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/atomic_base.h" 3
-  template<typename _ITp>
-    struct __atomic_base
-    {
-    private:
-      typedef _ITp __int_type;
-
-      static constexpr int _S_alignment =
- sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
-
-      alignas(_S_alignment) __int_type _M_i;
-
-    public:
-      __atomic_base() noexcept = default;
-      ~__atomic_base() noexcept = default;
-      __atomic_base(const __atomic_base&) = delete;
-      __atomic_base& operator=(const __atomic_base&) = delete;
-      __atomic_base& operator=(const __atomic_base&) volatile = delete;
-
-
-      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
-
-      operator __int_type() const noexcept
-      { return load(); }
-
-      operator __int_type() const volatile noexcept
-      { return load(); }
-
-      __int_type
-      operator=(__int_type __i) noexcept
-      {
- store(__i);
- return __i;
-      }
-
-      __int_type
-      operator=(__int_type __i) volatile noexcept
-      {
- store(__i);
- return __i;
-      }
-
-      __int_type
-      operator++(int) noexcept
-      { return fetch_add(1); }
-
-      __int_type
-      operator++(int) volatile noexcept
-      { return fetch_add(1); }
-
-      __int_type
-      operator--(int) noexcept
-      { return fetch_sub(1); }
-
-      __int_type
-      operator--(int) volatile noexcept
-      { return fetch_sub(1); }
-
-      __int_type
-      operator++() noexcept
-      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
-
-      __int_type
-      operator++() volatile noexcept
-      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
-
-      __int_type
-      operator--() noexcept
-      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
-
-      __int_type
-      operator--() volatile noexcept
-      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
-
-      __int_type
-      operator+=(__int_type __i) noexcept
-      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator+=(__int_type __i) volatile noexcept
-      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator-=(__int_type __i) noexcept
-      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator-=(__int_type __i) volatile noexcept
-      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator&=(__int_type __i) noexcept
-      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator&=(__int_type __i) volatile noexcept
-      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator|=(__int_type __i) noexcept
-      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator|=(__int_type __i) volatile noexcept
-      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator^=(__int_type __i) noexcept
-      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      __int_type
-      operator^=(__int_type __i) volatile noexcept
-      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
-
-      bool
-      is_lock_free() const noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_i),
-     reinterpret_cast<void *>(-__alignof(_M_i)));
-      }
-
-      bool
-      is_lock_free() const volatile noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_i),
-     reinterpret_cast<void *>(-__alignof(_M_i)));
-      }
-
-      inline __attribute__((__always_inline__)) void
-      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-                                              ;
-
- __atomic_store_n(&_M_i, __i, __m);
-      }
-
-      inline __attribute__((__always_inline__)) void
-      store(__int_type __i,
-     memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-                                              ;
-
- __atomic_store_n(&_M_i, __i, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __int_type
-      load(memory_order __m = memory_order_seq_cst) const noexcept
-      {
-       memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-
- return __atomic_load_n(&_M_i, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __int_type
-      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-
- return __atomic_load_n(&_M_i, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __int_type
-      exchange(__int_type __i,
-        memory_order __m = memory_order_seq_cst) noexcept
-      {
- return __atomic_exchange_n(&_M_i, __i, __m);
-      }
-
-
-      inline __attribute__((__always_inline__)) __int_type
-      exchange(__int_type __i,
-        memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return __atomic_exchange_n(&_M_i, __i, __m);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_weak(__int_type& __i1, __int_type __i2,
-       memory_order __m1, memory_order __m2) noexcept
-      {
-       memory_order __b2 = __m2 & __memory_order_mask;
-       memory_order __b1 = __m1 & __memory_order_mask;
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_weak(__int_type& __i1, __int_type __i2,
-       memory_order __m1,
-       memory_order __m2) volatile noexcept
-      {
-       memory_order __b2 = __m2 & __memory_order_mask;
-       memory_order __b1 = __m1 & __memory_order_mask;
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_weak(__int_type& __i1, __int_type __i2,
-       memory_order __m = memory_order_seq_cst) noexcept
-      {
- return compare_exchange_weak(__i1, __i2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_weak(__int_type& __i1, __int_type __i2,
-     memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return compare_exchange_weak(__i1, __i2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__int_type& __i1, __int_type __i2,
-         memory_order __m1, memory_order __m2) noexcept
-      {
-        memory_order __b2 = __m2 & __memory_order_mask;
-        memory_order __b1 = __m1 & __memory_order_mask;
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__int_type& __i1, __int_type __i2,
-         memory_order __m1,
-         memory_order __m2) volatile noexcept
-      {
-        memory_order __b2 = __m2 & __memory_order_mask;
-        memory_order __b1 = __m1 & __memory_order_mask;
-
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__int_type& __i1, __int_type __i2,
-         memory_order __m = memory_order_seq_cst) noexcept
-      {
- return compare_exchange_strong(__i1, __i2, __m,
-           __cmpexch_failure_order(__m));
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__int_type& __i1, __int_type __i2,
-   memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return compare_exchange_strong(__i1, __i2, __m,
-           __cmpexch_failure_order(__m));
-      }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_add(__int_type __i,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_add(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_add(__int_type __i,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_add(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_sub(__int_type __i,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_sub(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_sub(__int_type __i,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_sub(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_and(__int_type __i,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_and(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_and(__int_type __i,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_and(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_or(__int_type __i,
-        memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_or(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_or(__int_type __i,
-        memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_or(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_xor(__int_type __i,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_xor(&_M_i, __i, __m); }
-
-      inline __attribute__((__always_inline__)) __int_type
-      fetch_xor(__int_type __i,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_xor(&_M_i, __i, __m); }
-    };
-
-
-
-  template<typename _PTp>
-    struct __atomic_base<_PTp*>
-    {
-    private:
-      typedef _PTp* __pointer_type;
-
-      __pointer_type _M_p;
-
-
-      constexpr ptrdiff_t
-      _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
-
-      constexpr ptrdiff_t
-      _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
-
-    public:
-      __atomic_base() noexcept = default;
-      ~__atomic_base() noexcept = default;
-      __atomic_base(const __atomic_base&) = delete;
-      __atomic_base& operator=(const __atomic_base&) = delete;
-      __atomic_base& operator=(const __atomic_base&) volatile = delete;
-
-
-      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
-
-      operator __pointer_type() const noexcept
-      { return load(); }
-
-      operator __pointer_type() const volatile noexcept
-      { return load(); }
-
-      __pointer_type
-      operator=(__pointer_type __p) noexcept
-      {
- store(__p);
- return __p;
-      }
-
-      __pointer_type
-      operator=(__pointer_type __p) volatile noexcept
-      {
- store(__p);
- return __p;
-      }
-
-      __pointer_type
-      operator++(int) noexcept
-      { return fetch_add(1); }
-
-      __pointer_type
-      operator++(int) volatile noexcept
-      { return fetch_add(1); }
-
-      __pointer_type
-      operator--(int) noexcept
-      { return fetch_sub(1); }
-
-      __pointer_type
-      operator--(int) volatile noexcept
-      { return fetch_sub(1); }
-
-      __pointer_type
-      operator++() noexcept
-      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator++() volatile noexcept
-      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator--() noexcept
-      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator--() volatile noexcept
-      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator+=(ptrdiff_t __d) noexcept
-      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator+=(ptrdiff_t __d) volatile noexcept
-      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator-=(ptrdiff_t __d) noexcept
-      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
-      memory_order_seq_cst); }
-
-      __pointer_type
-      operator-=(ptrdiff_t __d) volatile noexcept
-      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
-      memory_order_seq_cst); }
-
-      bool
-      is_lock_free() const noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_p),
-     reinterpret_cast<void *>(-__alignof(_M_p)));
-      }
-
-      bool
-      is_lock_free() const volatile noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_p),
-     reinterpret_cast<void *>(-__alignof(_M_p)));
-      }
-
-      inline __attribute__((__always_inline__)) void
-      store(__pointer_type __p,
-     memory_order __m = memory_order_seq_cst) noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-
-                                              ;
-                                              ;
-                                              ;
-
- __atomic_store_n(&_M_p, __p, __m);
-      }
-
-      inline __attribute__((__always_inline__)) void
-      store(__pointer_type __p,
-     memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-                                              ;
-
- __atomic_store_n(&_M_p, __p, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-
- return __atomic_load_n(&_M_p, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
-      {
-        memory_order __b = __m & __memory_order_mask;
-                                              ;
-                                              ;
-
- return __atomic_load_n(&_M_p, __m);
-      }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      exchange(__pointer_type __p,
-        memory_order __m = memory_order_seq_cst) noexcept
-      {
- return __atomic_exchange_n(&_M_p, __p, __m);
-      }
-
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      exchange(__pointer_type __p,
-        memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return __atomic_exchange_n(&_M_p, __p, __m);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-         memory_order __m1,
-         memory_order __m2) noexcept
-      {
-        memory_order __b2 = __m2 & __memory_order_mask;
-        memory_order __b1 = __m1 & __memory_order_mask;
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-         memory_order __m1,
-         memory_order __m2) volatile noexcept
-      {
-        memory_order __b2 = __m2 & __memory_order_mask;
-        memory_order __b1 = __m1 & __memory_order_mask;
-
-                                               ;
-                                               ;
-                               ;
-
- return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
-      }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      fetch_add(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      fetch_add(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      fetch_sub(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
-
-      inline __attribute__((__always_inline__)) __pointer_type
-      fetch_sub(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
-    };
-
-
-
-
-}
-# 42 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/atomic" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _Tp>
-    struct atomic;
-
-
-
-  template<>
-  struct atomic<bool>
-  {
-  private:
-    __atomic_base<bool> _M_base;
-
-  public:
-    atomic() noexcept = default;
-    ~atomic() noexcept = default;
-    atomic(const atomic&) = delete;
-    atomic& operator=(const atomic&) = delete;
-    atomic& operator=(const atomic&) volatile = delete;
-
-    constexpr atomic(bool __i) noexcept : _M_base(__i) { }
-
-    bool
-    operator=(bool __i) noexcept
-    { return _M_base.operator=(__i); }
-
-    bool
-    operator=(bool __i) volatile noexcept
-    { return _M_base.operator=(__i); }
-
-    operator bool() const noexcept
-    { return _M_base.load(); }
-
-    operator bool() const volatile noexcept
-    { return _M_base.load(); }
-
-    bool
-    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
-
-    bool
-    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
-
-    void
-    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
-    { _M_base.store(__i, __m); }
-
-    void
-    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
-    { _M_base.store(__i, __m); }
-
-    bool
-    load(memory_order __m = memory_order_seq_cst) const noexcept
-    { return _M_base.load(__m); }
-
-    bool
-    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
-    { return _M_base.load(__m); }
-
-    bool
-    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
-    { return _M_base.exchange(__i, __m); }
-
-    bool
-    exchange(bool __i,
-      memory_order __m = memory_order_seq_cst) volatile noexcept
-    { return _M_base.exchange(__i, __m); }
-
-    bool
-    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
-     memory_order __m2) noexcept
-    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
-
-    bool
-    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
-     memory_order __m2) volatile noexcept
-    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
-
-    bool
-    compare_exchange_weak(bool& __i1, bool __i2,
-     memory_order __m = memory_order_seq_cst) noexcept
-    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
-
-    bool
-    compare_exchange_weak(bool& __i1, bool __i2,
-       memory_order __m = memory_order_seq_cst) volatile noexcept
-    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
-
-    bool
-    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
-       memory_order __m2) noexcept
-    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
-
-    bool
-    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
-       memory_order __m2) volatile noexcept
-    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
-
-    bool
-    compare_exchange_strong(bool& __i1, bool __i2,
-       memory_order __m = memory_order_seq_cst) noexcept
-    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
-
-    bool
-    compare_exchange_strong(bool& __i1, bool __i2,
-      memory_order __m = memory_order_seq_cst) volatile noexcept
-    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
-  };
-
-
-
-
-
-
-
-  template<typename _Tp>
-    struct atomic
-    {
-    private:
-
-      static constexpr int _S_min_alignment
- = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
- ? 0 : sizeof(_Tp);
-
-      static constexpr int _S_alignment
-        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
-
-      alignas(_S_alignment) _Tp _M_i;
-
-      static_assert(__is_trivially_copyable(_Tp),
-      "std::atomic requires a trivially copyable type");
-
-      static_assert(sizeof(_Tp) > 0,
-      "Incomplete or zero-sized types are not supported");
-
-    public:
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
-
-      operator _Tp() const noexcept
-      { return load(); }
-
-      operator _Tp() const volatile noexcept
-      { return load(); }
-
-      _Tp
-      operator=(_Tp __i) noexcept
-      { store(__i); return __i; }
-
-      _Tp
-      operator=(_Tp __i) volatile noexcept
-      { store(__i); return __i; }
-
-      bool
-      is_lock_free() const noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_i),
-     reinterpret_cast<void *>(-__alignof(_M_i)));
-      }
-
-      bool
-      is_lock_free() const volatile noexcept
-      {
-
- return __atomic_is_lock_free(sizeof(_M_i),
-     reinterpret_cast<void *>(-__alignof(_M_i)));
-      }
-
-      void
-      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
-      { __atomic_store(&_M_i, &__i, __m); }
-
-      void
-      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
-      { __atomic_store(&_M_i, &__i, __m); }
-
-      _Tp
-      load(memory_order __m = memory_order_seq_cst) const noexcept
-      {
-        _Tp tmp;
- __atomic_load(&_M_i, &tmp, __m);
- return tmp;
-      }
-
-      _Tp
-      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
-      {
-        _Tp tmp;
- __atomic_load(&_M_i, &tmp, __m);
- return tmp;
-      }
-
-      _Tp
-      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
-      {
-        _Tp tmp;
- __atomic_exchange(&_M_i, &__i, &tmp, __m);
- return tmp;
-      }
-
-      _Tp
-      exchange(_Tp __i,
-        memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
-        _Tp tmp;
- __atomic_exchange(&_M_i, &__i, &tmp, __m);
- return tmp;
-      }
-
-      bool
-      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
-       memory_order __f) noexcept
-      {
- return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
-      }
-
-      bool
-      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
-       memory_order __f) volatile noexcept
-      {
- return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
-      }
-
-      bool
-      compare_exchange_weak(_Tp& __e, _Tp __i,
-       memory_order __m = memory_order_seq_cst) noexcept
-      { return compare_exchange_weak(__e, __i, __m,
-                                     __cmpexch_failure_order(__m)); }
-
-      bool
-      compare_exchange_weak(_Tp& __e, _Tp __i,
-       memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return compare_exchange_weak(__e, __i, __m,
-                                     __cmpexch_failure_order(__m)); }
-
-      bool
-      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
-         memory_order __f) noexcept
-      {
- return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
-      }
-
-      bool
-      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
-         memory_order __f) volatile noexcept
-      {
- return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
-      }
-
-      bool
-      compare_exchange_strong(_Tp& __e, _Tp __i,
-          memory_order __m = memory_order_seq_cst) noexcept
-      { return compare_exchange_strong(__e, __i, __m,
-                                       __cmpexch_failure_order(__m)); }
-
-      bool
-      compare_exchange_strong(_Tp& __e, _Tp __i,
-       memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return compare_exchange_strong(__e, __i, __m,
-                                       __cmpexch_failure_order(__m)); }
-    };
-
-
-
-  template<typename _Tp>
-    struct atomic<_Tp*>
-    {
-      typedef _Tp* __pointer_type;
-      typedef __atomic_base<_Tp*> __base_type;
-      __base_type _M_b;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
-
-      operator __pointer_type() const noexcept
-      { return __pointer_type(_M_b); }
-
-      operator __pointer_type() const volatile noexcept
-      { return __pointer_type(_M_b); }
-
-      __pointer_type
-      operator=(__pointer_type __p) noexcept
-      { return _M_b.operator=(__p); }
-
-      __pointer_type
-      operator=(__pointer_type __p) volatile noexcept
-      { return _M_b.operator=(__p); }
-
-      __pointer_type
-      operator++(int) noexcept
-      { return _M_b++; }
-
-      __pointer_type
-      operator++(int) volatile noexcept
-      { return _M_b++; }
-
-      __pointer_type
-      operator--(int) noexcept
-      { return _M_b--; }
-
-      __pointer_type
-      operator--(int) volatile noexcept
-      { return _M_b--; }
-
-      __pointer_type
-      operator++() noexcept
-      { return ++_M_b; }
-
-      __pointer_type
-      operator++() volatile noexcept
-      { return ++_M_b; }
-
-      __pointer_type
-      operator--() noexcept
-      { return --_M_b; }
-
-      __pointer_type
-      operator--() volatile noexcept
-      { return --_M_b; }
-
-      __pointer_type
-      operator+=(ptrdiff_t __d) noexcept
-      { return _M_b.operator+=(__d); }
-
-      __pointer_type
-      operator+=(ptrdiff_t __d) volatile noexcept
-      { return _M_b.operator+=(__d); }
-
-      __pointer_type
-      operator-=(ptrdiff_t __d) noexcept
-      { return _M_b.operator-=(__d); }
-
-      __pointer_type
-      operator-=(ptrdiff_t __d) volatile noexcept
-      { return _M_b.operator-=(__d); }
-
-      bool
-      is_lock_free() const noexcept
-      { return _M_b.is_lock_free(); }
-
-      bool
-      is_lock_free() const volatile noexcept
-      { return _M_b.is_lock_free(); }
-
-      void
-      store(__pointer_type __p,
-     memory_order __m = memory_order_seq_cst) noexcept
-      { return _M_b.store(__p, __m); }
-
-      void
-      store(__pointer_type __p,
-     memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return _M_b.store(__p, __m); }
-
-      __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const noexcept
-      { return _M_b.load(__m); }
-
-      __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
-      { return _M_b.load(__m); }
-
-      __pointer_type
-      exchange(__pointer_type __p,
-        memory_order __m = memory_order_seq_cst) noexcept
-      { return _M_b.exchange(__p, __m); }
-
-      __pointer_type
-      exchange(__pointer_type __p,
-        memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return _M_b.exchange(__p, __m); }
-
-      bool
-      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-       memory_order __m1, memory_order __m2) noexcept
-      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
-
-      bool
-      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-       memory_order __m1,
-       memory_order __m2) volatile noexcept
-      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
-
-      bool
-      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-       memory_order __m = memory_order_seq_cst) noexcept
-      {
- return compare_exchange_weak(__p1, __p2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      bool
-      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-      memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return compare_exchange_weak(__p1, __p2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-         memory_order __m1, memory_order __m2) noexcept
-      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
-
-      bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-         memory_order __m1,
-         memory_order __m2) volatile noexcept
-      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
-
-      bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-         memory_order __m = memory_order_seq_cst) noexcept
-      {
- return _M_b.compare_exchange_strong(__p1, __p2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      bool
-      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-      memory_order __m = memory_order_seq_cst) volatile noexcept
-      {
- return _M_b.compare_exchange_strong(__p1, __p2, __m,
-         __cmpexch_failure_order(__m));
-      }
-
-      __pointer_type
-      fetch_add(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return _M_b.fetch_add(__d, __m); }
-
-      __pointer_type
-      fetch_add(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return _M_b.fetch_add(__d, __m); }
-
-      __pointer_type
-      fetch_sub(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) noexcept
-      { return _M_b.fetch_sub(__d, __m); }
-
-      __pointer_type
-      fetch_sub(ptrdiff_t __d,
-  memory_order __m = memory_order_seq_cst) volatile noexcept
-      { return _M_b.fetch_sub(__d, __m); }
-    };
-
-
-
-  template<>
-    struct atomic<char> : __atomic_base<char>
-    {
-      typedef char __integral_type;
-      typedef __atomic_base<char> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<signed char> : __atomic_base<signed char>
-    {
-      typedef signed char __integral_type;
-      typedef __atomic_base<signed char> __base_type;
-
-      atomic() noexcept= default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<unsigned char> : __atomic_base<unsigned char>
-    {
-      typedef unsigned char __integral_type;
-      typedef __atomic_base<unsigned char> __base_type;
-
-      atomic() noexcept= default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<short> : __atomic_base<short>
-    {
-      typedef short __integral_type;
-      typedef __atomic_base<short> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<unsigned short> : __atomic_base<unsigned short>
-    {
-      typedef unsigned short __integral_type;
-      typedef __atomic_base<unsigned short> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<int> : __atomic_base<int>
-    {
-      typedef int __integral_type;
-      typedef __atomic_base<int> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<unsigned int> : __atomic_base<unsigned int>
-    {
-      typedef unsigned int __integral_type;
-      typedef __atomic_base<unsigned int> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<long> : __atomic_base<long>
-    {
-      typedef long __integral_type;
-      typedef __atomic_base<long> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<unsigned long> : __atomic_base<unsigned long>
-    {
-      typedef unsigned long __integral_type;
-      typedef __atomic_base<unsigned long> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<long long> : __atomic_base<long long>
-    {
-      typedef long long __integral_type;
-      typedef __atomic_base<long long> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
-    {
-      typedef unsigned long long __integral_type;
-      typedef __atomic_base<unsigned long long> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<wchar_t> : __atomic_base<wchar_t>
-    {
-      typedef wchar_t __integral_type;
-      typedef __atomic_base<wchar_t> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<char16_t> : __atomic_base<char16_t>
-    {
-      typedef char16_t __integral_type;
-      typedef __atomic_base<char16_t> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-  template<>
-    struct atomic<char32_t> : __atomic_base<char32_t>
-    {
-      typedef char32_t __integral_type;
-      typedef __atomic_base<char32_t> __base_type;
-
-      atomic() noexcept = default;
-      ~atomic() noexcept = default;
-      atomic(const atomic&) = delete;
-      atomic& operator=(const atomic&) = delete;
-      atomic& operator=(const atomic&) volatile = delete;
-
-      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
-
-      using __base_type::operator __integral_type;
-      using __base_type::operator=;
-    };
-
-
-
-  typedef atomic<bool> atomic_bool;
-
-
-  typedef atomic<char> atomic_char;
-
-
-  typedef atomic<signed char> atomic_schar;
-
-
-  typedef atomic<unsigned char> atomic_uchar;
-
-
-  typedef atomic<short> atomic_short;
-
-
-  typedef atomic<unsigned short> atomic_ushort;
-
-
-  typedef atomic<int> atomic_int;
-
-
-  typedef atomic<unsigned int> atomic_uint;
-
-
-  typedef atomic<long> atomic_long;
-
-
-  typedef atomic<unsigned long> atomic_ulong;
-
-
-  typedef atomic<long long> atomic_llong;
-
-
-  typedef atomic<unsigned long long> atomic_ullong;
-
-
-  typedef atomic<wchar_t> atomic_wchar_t;
-
-
-  typedef atomic<char16_t> atomic_char16_t;
-
-
-  typedef atomic<char32_t> atomic_char32_t;
-
-
-
-  typedef atomic<int_least8_t> atomic_int_least8_t;
-
-
-  typedef atomic<uint_least8_t> atomic_uint_least8_t;
-
-
-  typedef atomic<int_least16_t> atomic_int_least16_t;
-
-
-  typedef atomic<uint_least16_t> atomic_uint_least16_t;
-
-
-  typedef atomic<int_least32_t> atomic_int_least32_t;
-
-
-  typedef atomic<uint_least32_t> atomic_uint_least32_t;
-
-
-  typedef atomic<int_least64_t> atomic_int_least64_t;
-
-
-  typedef atomic<uint_least64_t> atomic_uint_least64_t;
-
-
-
-  typedef atomic<int_fast8_t> atomic_int_fast8_t;
-
-
-  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
-
-
-  typedef atomic<int_fast16_t> atomic_int_fast16_t;
-
-
-  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
-
-
-  typedef atomic<int_fast32_t> atomic_int_fast32_t;
-
-
-  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
-
-
-  typedef atomic<int_fast64_t> atomic_int_fast64_t;
-
-
-  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
-
-
-
-  typedef atomic<intptr_t> atomic_intptr_t;
-
-
-  typedef atomic<uintptr_t> atomic_uintptr_t;
-
-
-  typedef atomic<size_t> atomic_size_t;
-
-
-  typedef atomic<intmax_t> atomic_intmax_t;
-
-
-  typedef atomic<uintmax_t> atomic_uintmax_t;
-
-
-  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
-
-
-
-  inline bool
-  atomic_flag_test_and_set_explicit(atomic_flag* __a,
-        memory_order __m) noexcept
-  { return __a->test_and_set(__m); }
-
-  inline bool
-  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
-        memory_order __m) noexcept
-  { return __a->test_and_set(__m); }
-
-  inline void
-  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
-  { __a->clear(__m); }
-
-  inline void
-  atomic_flag_clear_explicit(volatile atomic_flag* __a,
-        memory_order __m) noexcept
-  { __a->clear(__m); }
-
-  inline bool
-  atomic_flag_test_and_set(atomic_flag* __a) noexcept
-  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
-
-  inline bool
-  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
-  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
-
-  inline void
-  atomic_flag_clear(atomic_flag* __a) noexcept
-  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
-
-  inline void
-  atomic_flag_clear(volatile atomic_flag* __a) noexcept
-  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
-
-
-
-  template<typename _ITp>
-    inline bool
-    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
-    { return __a->is_lock_free(); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
-    { return __a->is_lock_free(); }
-
-  template<typename _ITp>
-    inline void
-    atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
-    { __a->store(__i, memory_order_relaxed); }
-
-  template<typename _ITp>
-    inline void
-    atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
-    { __a->store(__i, memory_order_relaxed); }
-
-  template<typename _ITp>
-    inline void
-    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
-     memory_order __m) noexcept
-    { __a->store(__i, __m); }
-
-  template<typename _ITp>
-    inline void
-    atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
-     memory_order __m) noexcept
-    { __a->store(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
-    { return __a->load(__m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_load_explicit(const volatile atomic<_ITp>* __a,
-    memory_order __m) noexcept
-    { return __a->load(__m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
-        memory_order __m) noexcept
-    { return __a->exchange(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
-        memory_order __m) noexcept
-    { return __a->exchange(__i, __m); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
-       _ITp* __i1, _ITp __i2,
-       memory_order __m1,
-       memory_order __m2) noexcept
-    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
-       _ITp* __i1, _ITp __i2,
-       memory_order __m1,
-       memory_order __m2) noexcept
-    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
-         _ITp* __i1, _ITp __i2,
-         memory_order __m1,
-         memory_order __m2) noexcept
-    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
-         _ITp* __i1, _ITp __i2,
-         memory_order __m1,
-         memory_order __m2) noexcept
-    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
-
-
-  template<typename _ITp>
-    inline void
-    atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
-    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline void
-    atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
-    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_load(const atomic<_ITp>* __a) noexcept
-    { return atomic_load_explicit(__a, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_load(const volatile atomic<_ITp>* __a) noexcept
-    { return atomic_load_explicit(__a, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_weak(atomic<_ITp>* __a,
-     _ITp* __i1, _ITp __i2) noexcept
-    {
-      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
-         memory_order_seq_cst,
-         memory_order_seq_cst);
-    }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
-     _ITp* __i1, _ITp __i2) noexcept
-    {
-      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
-         memory_order_seq_cst,
-         memory_order_seq_cst);
-    }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_strong(atomic<_ITp>* __a,
-       _ITp* __i1, _ITp __i2) noexcept
-    {
-      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
-           memory_order_seq_cst,
-           memory_order_seq_cst);
-    }
-
-  template<typename _ITp>
-    inline bool
-    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
-       _ITp* __i1, _ITp __i2) noexcept
-    {
-      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
-           memory_order_seq_cst,
-           memory_order_seq_cst);
-    }
-
-
-
-
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_add(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_add(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_sub(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_sub(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_and(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_and(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-        memory_order __m) noexcept
-    { return __a->fetch_or(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-        memory_order __m) noexcept
-    { return __a->fetch_or(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_xor(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-         memory_order __m) noexcept
-    { return __a->fetch_xor(__i, __m); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
-
-  template<typename _ITp>
-    inline _ITp
-    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
-    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
-
-
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
-         memory_order __m) noexcept
-    { return __a->fetch_add(__d, __m); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
-         memory_order __m) noexcept
-    { return __a->fetch_add(__d, __m); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
-    { return __a->fetch_add(__d); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
-    { return __a->fetch_add(__d); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
-         ptrdiff_t __d, memory_order __m) noexcept
-    { return __a->fetch_sub(__d, __m); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
-         memory_order __m) noexcept
-    { return __a->fetch_sub(__d, __m); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
-    { return __a->fetch_sub(__d); }
-
-  template<typename _ITp>
-    inline _ITp*
-    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
-    { return __a->fetch_sub(__d); }
-
-
-
-}
-# 171 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h" 2
-
-namespace mozilla {
-namespace detail {
-
-
-
-
-
-template<MemoryOrdering Order> struct AtomicOrderConstraints;
-
-template<>
-struct AtomicOrderConstraints<Relaxed>
-{
-  static const std::memory_order AtomicRMWOrder = std::memory_order_relaxed;
-  static const std::memory_order LoadOrder = std::memory_order_relaxed;
-  static const std::memory_order StoreOrder = std::memory_order_relaxed;
-  static const std::memory_order CompareExchangeFailureOrder =
-    std::memory_order_relaxed;
-};
-
-template<>
-struct AtomicOrderConstraints<ReleaseAcquire>
-{
-  static const std::memory_order AtomicRMWOrder = std::memory_order_acq_rel;
-  static const std::memory_order LoadOrder = std::memory_order_acquire;
-  static const std::memory_order StoreOrder = std::memory_order_release;
-  static const std::memory_order CompareExchangeFailureOrder =
-    std::memory_order_acquire;
-};
-
-template<>
-struct AtomicOrderConstraints<SequentiallyConsistent>
-{
-  static const std::memory_order AtomicRMWOrder = std::memory_order_seq_cst;
-  static const std::memory_order LoadOrder = std::memory_order_seq_cst;
-  static const std::memory_order StoreOrder = std::memory_order_seq_cst;
-  static const std::memory_order CompareExchangeFailureOrder =
-    std::memory_order_seq_cst;
-};
-
-template<typename T, MemoryOrdering Order>
-struct IntrinsicBase
-{
-  typedef std::atomic<T> ValueType;
-  typedef AtomicOrderConstraints<Order> OrderedOp;
-};
-
-template<typename T, MemoryOrdering Order>
-struct IntrinsicMemoryOps : public IntrinsicBase<T, Order>
-{
-  typedef IntrinsicBase<T, Order> Base;
-
-  static T load(const typename Base::ValueType& aPtr)
-  {
-    return aPtr.load(Base::OrderedOp::LoadOrder);
-  }
-
-  static void store(typename Base::ValueType& aPtr, T aVal)
-  {
-    aPtr.store(aVal, Base::OrderedOp::StoreOrder);
-  }
-
-  static T exchange(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.exchange(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-
-  static bool compareExchange(typename Base::ValueType& aPtr,
-                              T aOldVal, T aNewVal)
-  {
-    return aPtr.compare_exchange_strong(aOldVal, aNewVal,
-                                        Base::OrderedOp::AtomicRMWOrder,
-                                        Base::OrderedOp::CompareExchangeFailureOrder);
-  }
-};
-
-template<typename T, MemoryOrdering Order>
-struct IntrinsicAddSub : public IntrinsicBase<T, Order>
-{
-  typedef IntrinsicBase<T, Order> Base;
-
-  static T add(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-
-  static T sub(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-};
-
-template<typename T, MemoryOrdering Order>
-struct IntrinsicAddSub<T*, Order> : public IntrinsicBase<T*, Order>
-{
-  typedef IntrinsicBase<T*, Order> Base;
-
-  static T* add(typename Base::ValueType& aPtr, ptrdiff_t aVal)
-  {
-    return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-
-  static T* sub(typename Base::ValueType& aPtr, ptrdiff_t aVal)
-  {
-    return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-};
-
-template<typename T, MemoryOrdering Order>
-struct IntrinsicIncDec : public IntrinsicAddSub<T, Order>
-{
-  typedef IntrinsicBase<T, Order> Base;
-
-  static T inc(typename Base::ValueType& aPtr)
-  {
-    return IntrinsicAddSub<T, Order>::add(aPtr, 1);
-  }
-
-  static T dec(typename Base::ValueType& aPtr)
-  {
-    return IntrinsicAddSub<T, Order>::sub(aPtr, 1);
-  }
-};
-
-template<typename T, MemoryOrdering Order>
-struct AtomicIntrinsics : public IntrinsicMemoryOps<T, Order>,
-                          public IntrinsicIncDec<T, Order>
-{
-  typedef IntrinsicBase<T, Order> Base;
-
-  static T or_(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.fetch_or(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-
-  static T xor_(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.fetch_xor(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-
-  static T and_(typename Base::ValueType& aPtr, T aVal)
-  {
-    return aPtr.fetch_and(aVal, Base::OrderedOp::AtomicRMWOrder);
-  }
-};
-
-template<typename T, MemoryOrdering Order>
-struct AtomicIntrinsics<T*, Order>
-  : public IntrinsicMemoryOps<T*, Order>, public IntrinsicIncDec<T*, Order>
-{
-};
-
-template<typename T>
-struct ToStorageTypeArgument
-{
-  static constexpr T convert (T aT) { return aT; }
-};
-
-}
-}
-# 533 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-namespace mozilla {
-
-namespace detail {
-
-template<typename T, MemoryOrdering Order>
-class AtomicBase
-{
-  static_assert(sizeof(T) == 4 || sizeof(T) == 8,
-                "mozilla/Atomics.h only supports 32-bit and 64-bit types");
-
-protected:
-  typedef typename detail::AtomicIntrinsics<T, Order> Intrinsics;
-  typedef typename Intrinsics::ValueType ValueType;
-  ValueType mValue;
-
-public:
-  constexpr AtomicBase() : mValue() {}
-  explicit constexpr AtomicBase(T aInit)
-    : mValue(ToStorageTypeArgument<T>::convert(aInit))
-  {}
-
-
-
-
-
-
-  T operator=(T aVal)
-  {
-    Intrinsics::store(mValue, aVal);
-    return aVal;
-  }
-
-
-
-
-
-  T exchange(T aVal)
-  {
-    return Intrinsics::exchange(mValue, aVal);
-  }
-# 585 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-  bool compareExchange(T aOldValue, T aNewValue)
-  {
-    return Intrinsics::compareExchange(mValue, aOldValue, aNewValue);
-  }
-
-private:
-  template<MemoryOrdering AnyOrder>
-  AtomicBase(const AtomicBase<T, AnyOrder>& aCopy) = delete;
-};
-
-template<typename T, MemoryOrdering Order>
-class AtomicBaseIncDec : public AtomicBase<T, Order>
-{
-  typedef typename detail::AtomicBase<T, Order> Base;
-
-public:
-  constexpr AtomicBaseIncDec() : Base() {}
-  explicit constexpr AtomicBaseIncDec(T aInit) : Base(aInit) {}
-
-  using Base::operator=;
-
-  operator T() const { return Base::Intrinsics::load(Base::mValue); }
-  T operator++(int) { return Base::Intrinsics::inc(Base::mValue); }
-  T operator--(int) { return Base::Intrinsics::dec(Base::mValue); }
-  T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; }
-  T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; }
-
-private:
-  template<MemoryOrdering AnyOrder>
-  AtomicBaseIncDec(const AtomicBaseIncDec<T, AnyOrder>& aCopy) = delete;
-};
-
-}
-# 636 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-template<typename T,
-         MemoryOrdering Order = SequentiallyConsistent,
-         typename Enable = void>
-class Atomic;
-# 649 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-template<typename T, MemoryOrdering Order>
-class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value &&
-                       !IsSame<T, bool>::value>::Type>
-  : public detail::AtomicBaseIncDec<T, Order>
-{
-  typedef typename detail::AtomicBaseIncDec<T, Order> Base;
-
-public:
-  constexpr Atomic() : Base() {}
-  explicit constexpr Atomic(T aInit) : Base(aInit) {}
-
-  using Base::operator=;
-
-  T operator+=(T aDelta)
-  {
-    return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
-  }
-
-  T operator-=(T aDelta)
-  {
-    return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta;
-  }
-
-  T operator|=(T aVal)
-  {
-    return Base::Intrinsics::or_(Base::mValue, aVal) | aVal;
-  }
-
-  T operator^=(T aVal)
-  {
-    return Base::Intrinsics::xor_(Base::mValue, aVal) ^ aVal;
-  }
-
-  T operator&=(T aVal)
-  {
-    return Base::Intrinsics::and_(Base::mValue, aVal) & aVal;
-  }
-
-private:
-  Atomic(Atomic<T, Order>& aOther) = delete;
-};
-# 699 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-template<typename T, MemoryOrdering Order>
-class Atomic<T*, Order> : public detail::AtomicBaseIncDec<T*, Order>
-{
-  typedef typename detail::AtomicBaseIncDec<T*, Order> Base;
-
-public:
-  constexpr Atomic() : Base() {}
-  explicit constexpr Atomic(T* aInit) : Base(aInit) {}
-
-  using Base::operator=;
-
-  T* operator+=(ptrdiff_t aDelta)
-  {
-    return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
-  }
-
-  T* operator-=(ptrdiff_t aDelta)
-  {
-    return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta;
-  }
-
-private:
-  Atomic(Atomic<T*, Order>& aOther) = delete;
-};
-
-
-
-
-
-
-template<typename T, MemoryOrdering Order>
-class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type>
-  : public detail::AtomicBase<T, Order>
-{
-  typedef typename detail::AtomicBase<T, Order> Base;
-
-public:
-  constexpr Atomic() : Base() {}
-  explicit constexpr Atomic(T aInit) : Base(aInit) {}
-
-  operator T() const { return T(Base::Intrinsics::load(Base::mValue)); }
-
-  using Base::operator=;
-
-private:
-  Atomic(Atomic<T, Order>& aOther) = delete;
-};
-# 763 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Atomics.h"
-template<MemoryOrdering Order>
-class Atomic<bool, Order>
-  : protected detail::AtomicBase<uint32_t, Order>
-{
-  typedef typename detail::AtomicBase<uint32_t, Order> Base;
-
-public:
-  constexpr Atomic() : Base() {}
-  explicit constexpr Atomic(bool aInit) : Base(aInit) {}
-
-
-               operator bool() const
-  {
-    return Base::Intrinsics::load(Base::mValue);
-  }
-
-  bool operator=(bool aVal)
-  {
-    return Base::operator=(aVal);
-  }
-
-  bool exchange(bool aVal)
-  {
-    return Base::exchange(aVal);
-  }
-
-  bool compareExchange(bool aOldValue, bool aNewValue)
-  {
-    return Base::compareExchange(aOldValue, aNewValue);
-  }
-
-private:
-  Atomic(Atomic<bool, Order>& aOther) = delete;
-};
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 1
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/GuardObjects.h" 1
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h" 2
-
-
-namespace mozilla {
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
-template<typename Traits>
-class Scoped
-{
-public:
-  typedef typename Traits::type Resource;
-
-  explicit Scoped()
-    : mValue(Traits::empty())
-  {
-    do { } while (0);
-  }
-
-  explicit Scoped(const Resource& aValue
-                                                 )
-    : mValue(aValue)
-  {
-    do { } while (0);
-  }
-
-
-  Scoped(Scoped&& aOther
-                                        )
-    : mValue(Move(aOther.mValue))
-  {
-    do { } while (0);
-    aOther.mValue = Traits::empty();
-  }
-
-  ~Scoped() { Traits::release(mValue); }
-
-
-  operator const Resource&() const { return mValue; }
-  const Resource& operator->() const { return mValue; }
-  const Resource& get() const { return mValue; }
-
-  Resource& rwget() { return mValue; }
-# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
-  Resource forget()
-  {
-    Resource tmp = mValue;
-    mValue = Traits::empty();
-    return tmp;
-  }
-
-
-
-
-
-
-  void dispose()
-  {
-    Traits::release(mValue);
-    mValue = Traits::empty();
-  }
-
-  bool operator==(const Resource& aOther) const { return mValue == aOther; }
-# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
-  Scoped& operator=(const Resource& aOther) { return reset(aOther); }
-
-  Scoped& reset(const Resource& aOther)
-  {
-    Traits::release(mValue);
-    mValue = aOther;
-    return *this;
-  }
-
-
-  Scoped& operator=(Scoped&& aRhs)
-  {
-    do { } while (0);
-    this->~Scoped();
-    new(this) Scoped(Move(aRhs));
-    return *this;
-  }
-
-private:
-  explicit Scoped(const Scoped& aValue) = delete;
-  Scoped& operator=(const Scoped& aValue) = delete;
-
-private:
-  Resource mValue;
-
-};
-# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Scoped.h"
-template <typename T> void TypeSpecificDelete(T* aValue);
-
-template <typename T>
-struct TypeSpecificScopedPointerTraits
-{
-  typedef T* type;
-  static type empty() { return nullptr; }
-  static void release(type aValue)
-  {
-    if (aValue) {
-      TypeSpecificDelete(aValue);
-    }
-  }
-};
-
-template<typename Type> struct TypeSpecificScopedPointer : public mozilla::Scoped<TypeSpecificScopedPointerTraits<Type> > { typedef mozilla::Scoped<TypeSpecificScopedPointerTraits<Type> > Super; typedef typename Super::Resource Resource; TypeSpecificScopedPointer& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit TypeSpecificScopedPointer() : Super() {} explicit TypeSpecificScopedPointer(Resource aRhs ) : Super(aRhs ) {} TypeSpecificScopedPointer(TypeSpecificScopedPointer&& aRhs ) : Super(Move(aRhs) ) {} private: explicit TypeSpecificScopedPointer(TypeSpecificScopedPointer&) = delete; TypeSpecificScopedPointer& operator=(TypeSpecificScopedPointer&) = delete; };
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h" 2
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-namespace JS {}
-
-
-namespace mozilla {}
-
-
-namespace js {}
-
-
-
-
-extern __attribute__((noreturn)) __attribute__ ((cold)) void
-JS_Assert(const char* s, const char* file, int ln);
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-namespace js {
-namespace oom {
-
-
-
-
-
-
-
-enum ThreadType {
-    THREAD_TYPE_NONE = 0,
-    THREAD_TYPE_COOPERATING,
-    THREAD_TYPE_WASM,
-    THREAD_TYPE_ION,
-    THREAD_TYPE_PARSE,
-    THREAD_TYPE_COMPRESS,
-    THREAD_TYPE_GCHELPER,
-    THREAD_TYPE_GCPARALLEL,
-    THREAD_TYPE_PROMISE_TASK,
-    THREAD_TYPE_MAX
-};
-# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-inline bool InitThreadType(void) { return true; }
-inline void SetThreadType(ThreadType t) {};
-inline uint32_t GetThreadType(void) { return 0; }
-
-
-}
-}
-# 169 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-namespace js {
-namespace oom {
-static inline bool IsSimulatedOOMAllocation() { return false; }
-static inline bool ShouldFailWithOOM() { return false; }
-}
-}
-
-
-
-namespace js {
-
-
-struct AutoEnterOOMUnsafeRegion
-{
-    __attribute__((noreturn)) __attribute__ ((cold)) void crash(const char* reason);
-    __attribute__((noreturn)) __attribute__ ((cold)) void crash(size_t size, const char* reason);
-
-    using AnnotateOOMAllocationSizeCallback = void(*)(size_t);
-    static AnnotateOOMAllocationSizeCallback annotateOOMSizeCallback;
-    static void setAnnotateOOMAllocationSizeCallback(AnnotateOOMAllocationSizeCallback callback) {
-        annotateOOMSizeCallback = callback;
-    }
-# 222 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-};
-
-}
-
-static inline void* js_malloc(size_t bytes)
-{
-    do {} while(0);
-    return malloc(bytes);
-}
-
-static inline void* js_calloc(size_t bytes)
-{
-    do {} while(0);
-    return calloc(bytes, 1);
-}
-
-static inline void* js_calloc(size_t nmemb, size_t size)
-{
-    do {} while(0);
-    return calloc(nmemb, size);
-}
-
-static inline void* js_realloc(void* p, size_t bytes)
-{
-
-
-
-    do { } while (0);
-
-    do {} while(0);
-    return realloc(p, bytes);
-}
-
-static inline void js_free(void* p)
-{
-    free(p);
-}
-
-static inline char* js_strdup(const char* s)
-{
-    do {} while(0);
-    return strdup(s);
-}
-# 346 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-template <class T, typename... Args> static __attribute__((always_inline)) inline T * js_new(Args&&... args) { void* memory = js_malloc(sizeof(T)); return (__builtin_expect(!!(memory), 1)) ? new(memory) T(mozilla::Forward<Args>(args)...) : nullptr; }
-
-namespace js {
-
-
-
-
-
-template <typename T>
-__attribute__ ((warn_unused_result)) inline bool
-CalculateAllocSize(size_t numElems, size_t* bytesOut)
-{
-    *bytesOut = numElems * sizeof(T);
-    return (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) == 0;
-}
-
-
-
-
-
-
-template <typename T, typename Extra>
-__attribute__ ((warn_unused_result)) inline bool
-CalculateAllocSizeWithExtra(size_t numExtra, size_t* bytesOut)
-{
-    *bytesOut = sizeof(T) + numExtra * sizeof(Extra);
-    return (numExtra & mozilla::tl::MulOverflowMask<sizeof(Extra)>::value) == 0 &&
-           *bytesOut >= sizeof(T);
-}
-
-}
-
-template <class T>
-static __attribute__((always_inline)) inline void
-js_delete(const T* p)
-{
-    if (p) {
-        p->~T();
-        js_free(const_cast<T*>(p));
-    }
-}
-
-template<class T>
-static __attribute__((always_inline)) inline void
-js_delete_poison(const T* p)
-{
-    if (p) {
-        p->~T();
-        memset(const_cast<T*>(p), 0x3B, sizeof(T));
-        js_free(const_cast<T*>(p));
-    }
-}
-
-template <class T>
-static __attribute__((always_inline)) inline T*
-js_pod_malloc()
-{
-    return static_cast<T*>(js_malloc(sizeof(T)));
-}
-
-template <class T>
-static __attribute__((always_inline)) inline T*
-js_pod_calloc()
-{
-    return static_cast<T*>(js_calloc(sizeof(T)));
-}
-
-template <class T>
-static __attribute__((always_inline)) inline T*
-js_pod_malloc(size_t numElems)
-{
-    size_t bytes;
-    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems, &bytes)), 0)))
-        return nullptr;
-    return static_cast<T*>(js_malloc(bytes));
-}
-
-template <class T>
-static __attribute__((always_inline)) inline T*
-js_pod_calloc(size_t numElems)
-{
-    size_t bytes;
-    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems, &bytes)), 0)))
-        return nullptr;
-    return static_cast<T*>(js_calloc(bytes));
-}
-
-template <class T>
-static __attribute__((always_inline)) inline T*
-js_pod_realloc(T* prior, size_t oldSize, size_t newSize)
-{
-    do { } while (0);
-    size_t bytes;
-    if ((__builtin_expect(!!(!js::CalculateAllocSize<T>(newSize, &bytes)), 0)))
-        return nullptr;
-    return static_cast<T*>(js_realloc(prior, bytes));
-}
-
-namespace js {
-
-template<typename T>
-struct ScopedFreePtrTraits
-{
-    typedef T* type;
-    static T* empty() { return nullptr; }
-    static void release(T* ptr) { js_free(ptr); }
-};
-template<typename Type> struct ScopedJSFreePtr : public mozilla::Scoped<ScopedFreePtrTraits<Type> > { typedef mozilla::Scoped<ScopedFreePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedJSFreePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSFreePtr& operator=(ScopedJSFreePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSFreePtr() : Super() {} explicit ScopedJSFreePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSFreePtr(ScopedJSFreePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSFreePtr(ScopedJSFreePtr&) = delete; ScopedJSFreePtr& operator=(ScopedJSFreePtr&) = delete; };
-
-template <typename T>
-struct ScopedDeletePtrTraits : public ScopedFreePtrTraits<T>
-{
-    static void release(T* ptr) { js_delete(ptr); }
-};
-template<typename Type> struct ScopedJSDeletePtr : public mozilla::Scoped<ScopedDeletePtrTraits<Type> > { typedef mozilla::Scoped<ScopedDeletePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedJSDeletePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedJSDeletePtr() : Super() {} explicit ScopedJSDeletePtr(Resource aRhs ) : Super(aRhs ) {} ScopedJSDeletePtr(ScopedJSDeletePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedJSDeletePtr(ScopedJSDeletePtr&) = delete; ScopedJSDeletePtr& operator=(ScopedJSDeletePtr&) = delete; };
-
-template <typename T>
-struct ScopedReleasePtrTraits : public ScopedFreePtrTraits<T>
-{
-    static void release(T* ptr) { if (ptr) ptr->release(); }
-};
-template<typename Type> struct ScopedReleasePtr : public mozilla::Scoped<ScopedReleasePtrTraits<Type> > { typedef mozilla::Scoped<ScopedReleasePtrTraits<Type> > Super; typedef typename Super::Resource Resource; ScopedReleasePtr& operator=(Resource aRhs) { Super::operator=(aRhs); return *this; } ScopedReleasePtr& operator=(ScopedReleasePtr&& aRhs) { Super::operator=(Move(aRhs)); return *this; } explicit ScopedReleasePtr() : Super() {} explicit ScopedReleasePtr(Resource aRhs ) : Super(aRhs ) {} ScopedReleasePtr(ScopedReleasePtr&& aRhs ) : Super(Move(aRhs) ) {} private: explicit ScopedReleasePtr(ScopedReleasePtr&) = delete; ScopedReleasePtr& operator=(ScopedReleasePtr&) = delete; };
-
-}
-
-namespace JS {
-
-template<typename T>
-struct DeletePolicy
-{
-    constexpr DeletePolicy() {}
-
-    template<typename U>
-                 DeletePolicy(DeletePolicy<U> other,
-                              typename mozilla::EnableIf<mozilla::IsConvertible<U*, T*>::value,
-                                                         int>::Type dummy = 0)
-    {}
-
-    void operator()(const T* ptr) {
-        js_delete(const_cast<T*>(ptr));
-    }
-};
-
-struct FreePolicy
-{
-    void operator()(const void* ptr) {
-        js_free(const_cast<void*>(ptr));
-    }
-};
-
-typedef mozilla::UniquePtr<char[], JS::FreePolicy> UniqueChars;
-typedef mozilla::UniquePtr<char16_t[], JS::FreePolicy> UniqueTwoByteChars;
-
-}
-
-namespace js {
-
-
-typedef uint32_t HashNumber;
-const unsigned HashNumberSizeBits = 32;
-
-namespace detail {
-# 524 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-inline HashNumber
-ScrambleHashCode(HashNumber h)
-{
-# 542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
-    static const HashNumber goldenRatio = 0x9E3779B9U;
-    return h * goldenRatio;
-}
-
-}
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h" 2
-
-
-namespace js {
-
-bool
-CurrentThreadCanAccessZone(JS::Zone* zone);
-
-namespace gc {
-
-struct Cell;
-
-const size_t ArenaShift = 12;
-const size_t ArenaSize = size_t(1) << ArenaShift;
-const size_t ArenaMask = ArenaSize - 1;
-
-
-
-
-const size_t ChunkShift = 20;
-
-const size_t ChunkSize = size_t(1) << ChunkShift;
-const size_t ChunkMask = ChunkSize - 1;
-
-const size_t CellShift = 3;
-const size_t CellSize = size_t(1) << CellShift;
-const size_t CellMask = CellSize - 1;
-
-
-
-
-
-
-const size_t ChunkMarkBitmapOffset = 1032352;
-const size_t ChunkMarkBitmapBits = 129024;
-
-const size_t ChunkRuntimeOffset = ChunkSize - sizeof(void*);
-const size_t ChunkTrailerSize = 2 * sizeof(uintptr_t) + sizeof(uint64_t);
-const size_t ChunkLocationOffset = ChunkSize - ChunkTrailerSize;
-const size_t ArenaZoneOffset = sizeof(size_t);
-const size_t ArenaHeaderSize = sizeof(size_t) + 2 * sizeof(uintptr_t) +
-                               sizeof(size_t) + sizeof(uintptr_t);
-
-
-
-
-
-
-static const uint32_t BLACK = 0;
-static const uint32_t GRAY = 1;
-
-
-
-
-
-enum class ChunkLocation : uint32_t
-{
-    Invalid = 0,
-    Nursery = 1,
-    TenuredHeap = 2
-};
-
-
-
-extern void
-AssertGCThingHasType(js::gc::Cell* cell, JS::TraceKind kind);
-
-
-
-
-
-__attribute__((always_inline)) inline bool IsInsideNursery(const js::gc::Cell* cell);
-
-}
-}
-
-namespace JS {
-struct Zone;
-
-
-const uint32_t DefaultNurseryBytes = 16 * js::gc::ChunkSize;
-
-
-const uint32_t DefaultHeapMaxBytes = 32 * 1024 * 1024;
-
-namespace shadow {
-
-struct Zone
-{
-  protected:
-    JSRuntime* const runtime_;
-    JSTracer* const barrierTracer_;
-
-  public:
-    bool needsIncrementalBarrier_;
-
-    Zone(JSRuntime* runtime, JSTracer* barrierTracerArg)
-      : runtime_(runtime),
-        barrierTracer_(barrierTracerArg),
-        needsIncrementalBarrier_(false)
-    {}
-
-    bool needsIncrementalBarrier() const {
-        return needsIncrementalBarrier_;
-    }
-
-    JSTracer* barrierTracer() {
-        do { } while (0);
-        do { } while (0);
-        return barrierTracer_;
-    }
-
-    JSRuntime* runtimeFromActiveCooperatingThread() const {
-        do { } while (0);
-        return runtime_;
-    }
-
-
-
-    JSRuntime* runtimeFromAnyThread() const {
-        return runtime_;
-    }
-
-    static __attribute__((always_inline)) inline JS::shadow::Zone* asShadowZone(JS::Zone* zone) {
-        return reinterpret_cast<JS::shadow::Zone*>(zone);
-    }
-};
-
-}
-# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HeapAPI.h"
-class GCCellPtr
-{
-  public:
-
-    GCCellPtr(void* gcthing, JS::TraceKind traceKind) : ptr(checkedCast(gcthing, traceKind)) {}
-
-
-                 GCCellPtr(decltype(nullptr)) : ptr(checkedCast(nullptr, JS::TraceKind::Null)) {}
-
-
-    template <typename T>
-    explicit GCCellPtr(T* p) : ptr(checkedCast(p, JS::MapTypeToTraceKind<T>::kind)) { }
-    explicit GCCellPtr(JSFunction* p) : ptr(checkedCast(p, JS::TraceKind::Object)) { }
-    explicit GCCellPtr(JSFlatString* str) : ptr(checkedCast(str, JS::TraceKind::String)) { }
-    explicit GCCellPtr(const Value& v);
-
-    JS::TraceKind kind() const {
-        JS::TraceKind traceKind = JS::TraceKind(ptr & OutOfLineTraceKindMask);
-        if (uintptr_t(traceKind) != OutOfLineTraceKindMask)
-            return traceKind;
-        return outOfLineKind();
-    }
-
-
-    explicit operator bool() const {
-        do { } while (0);
-        return asCell();
-    }
-
-
-    template <typename T>
-    bool is() const { return kind() == JS::MapTypeToTraceKind<T>::kind; }
-
-
-
-    template <typename T>
-    T& as() const {
-        do { } while (0);
-
-
-        return *reinterpret_cast<T*>(asCell());
-    }
-
-
-
-
-    js::gc::Cell* asCell() const {
-        return reinterpret_cast<js::gc::Cell*>(ptr & ~OutOfLineTraceKindMask);
-    }
-
-
-    uint64_t unsafeAsInteger() const {
-        return static_cast<uint64_t>(unsafeAsUIntPtr());
-    }
-
-    uintptr_t unsafeAsUIntPtr() const {
-        do { } while (0);
-        do { } while (0);
-        return reinterpret_cast<uintptr_t>(asCell());
-    }
-
-    bool mayBeOwnedByOtherRuntime() const;
-
-  private:
-    static uintptr_t checkedCast(void* p, JS::TraceKind traceKind) {
-        js::gc::Cell* cell = static_cast<js::gc::Cell*>(p);
-        do { } while (0);
-        AssertGCThingHasType(cell, traceKind);
-
-
-        do { } while (0);
-
-        return uintptr_t(p) | (uintptr_t(traceKind) & OutOfLineTraceKindMask);
-    }
-
-    JS::TraceKind outOfLineKind() const;
-
-    uintptr_t ptr;
-};
-
-inline bool
-operator==(const GCCellPtr& ptr1, const GCCellPtr& ptr2)
-{
-    return ptr1.asCell() == ptr2.asCell();
-}
-
-inline bool
-operator!=(const GCCellPtr& ptr1, const GCCellPtr& ptr2)
-{
-    return !(ptr1 == ptr2);
-}
-
-
-
-template <typename F, typename... Args>
-auto
-DispatchTyped(F f, GCCellPtr thing, Args&&... args)
-  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
-{
-    switch (thing.kind()) {
-
-
-
-      case JS::TraceKind::BaseShape: return f(&thing.as<js::BaseShape>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::JitCode: return f(&thing.as<js::jit::JitCode>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::LazyScript: return f(&thing.as<js::LazyScript>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Scope: return f(&thing.as<js::Scope>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Object: return f(&thing.as<JSObject>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::ObjectGroup: return f(&thing.as<js::ObjectGroup>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Script: return f(&thing.as<JSScript>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Shape: return f(&thing.as<js::Shape>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::String: return f(&thing.as<JSString>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::Symbol: return f(&thing.as<JS::Symbol>(), mozilla::Forward<Args>(args)...); case JS::TraceKind::RegExpShared: return f(&thing.as<js::RegExpShared>(), mozilla::Forward<Args>(args)...);;
-
-      default:
-          do { AnnotateMozCrashReason("MOZ_CRASH(" "Invalid trace kind in DispatchTyped for GCCellPtr." ")"); do { *((volatile int*) __null) = 258; ::abort(); } while (0); } while (0);
-    }
-}
-
-}
-
-namespace js {
-namespace gc {
-namespace detail {
-
-static __attribute__((always_inline)) inline uintptr_t*
-GetGCThingMarkBitmap(const uintptr_t addr)
-{
-    do { } while (0);
-    const uintptr_t bmap_addr = (addr & ~ChunkMask) | ChunkMarkBitmapOffset;
-    return reinterpret_cast<uintptr_t*>(bmap_addr);
-}
-
-static __attribute__((always_inline)) inline void
-GetGCThingMarkWordAndMask(const uintptr_t addr, uint32_t color,
-                          uintptr_t** wordp, uintptr_t* maskp)
-{
-    do { } while (0);
-    const size_t bit = (addr & js::gc::ChunkMask) / js::gc::CellSize + color;
-    do { } while (0);
-    uintptr_t* bitmap = GetGCThingMarkBitmap(addr);
-    const uintptr_t nbits = sizeof(*bitmap) * 8;
-    *maskp = uintptr_t(1) << (bit % nbits);
-    *wordp = &bitmap[bit / nbits];
-}
-
-static __attribute__((always_inline)) inline JS::Zone*
-GetGCThingZone(const uintptr_t addr)
-{
-    do { } while (0);
-    const uintptr_t zone_addr = (addr & ~ArenaMask) | ArenaZoneOffset;
-    return *reinterpret_cast<JS::Zone**>(zone_addr);
-
-}
-
-static __attribute__((always_inline)) inline bool
-CellIsMarkedGray(const Cell* cell)
-{
-    do { } while (0);
-    if (js::gc::IsInsideNursery(cell))
-        return false;
-
-    uintptr_t* word, mask;
-    js::gc::detail::GetGCThingMarkWordAndMask(uintptr_t(cell), js::gc::GRAY, &word, &mask);
-    return *word & mask;
-}
-
-extern bool
-CellIsMarkedGrayIfKnown(const Cell* cell);
-
-
-
-
-
-
-}
-
-__attribute__((always_inline)) inline bool
-IsInsideNursery(const js::gc::Cell* cell)
-{
-    if (!cell)
-        return false;
-    uintptr_t addr = uintptr_t(cell);
-    addr &= ~js::gc::ChunkMask;
-    addr |= js::gc::ChunkLocationOffset;
-    auto location = *reinterpret_cast<ChunkLocation*>(addr);
-    do { } while (0);
-    return location == ChunkLocation::Nursery;
-}
-
-}
-}
-
-namespace JS {
-
-static __attribute__((always_inline)) inline Zone*
-GetTenuredGCThingZone(GCCellPtr thing)
-{
-    do { } while (0);
-    return js::gc::detail::GetGCThingZone(thing.unsafeAsUIntPtr());
-}
-
-static __attribute__((always_inline)) inline Zone*
-GetStringZone(JSString* str)
-{
-    return js::gc::detail::GetGCThingZone(uintptr_t(str));
-}
-
-extern Zone*
-GetObjectZone(JSObject* obj);
-
-static __attribute__((always_inline)) inline bool
-GCThingIsMarkedGray(GCCellPtr thing)
-{
-    if (thing.mayBeOwnedByOtherRuntime())
-        return false;
-    return js::gc::detail::CellIsMarkedGrayIfKnown(thing.asCell());
-}
-
-extern JS::TraceKind
-GCThingTraceKind(void* thing);
-
-}
-
-namespace js {
-namespace gc {
-
-static __attribute__((always_inline)) inline bool
-IsIncrementalBarrierNeededOnTenuredGCThing(const JS::GCCellPtr thing)
-{
-    do { } while (0);
-    do { } while (0);
-
-
-
-
-    do { } while (0);
-
-    JS::Zone* zone = JS::GetTenuredGCThingZone(thing);
-    return JS::shadow::Zone::asShadowZone(zone)->needsIncrementalBarrier();
-}
-
-
-
-
-
-
-extern JSObject*
-NewMemoryInfoObject(JSContext* cx);
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsrootidl.h"
-typedef int64_t PRTime;
-
-
-
-class nsAString;
-class nsACString;
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
-# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
-struct nsID
-{
-
-
-
-
-
-  uint32_t m0;
-  uint16_t m1;
-  uint16_t m2;
-  uint8_t m3[8];
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
-  void Clear();
-
-
-
-
-
-
-  inline bool Equals(const nsID& aOther) const
-  {
-
-    return
-      (((uint32_t*)&m0)[0] == ((uint32_t*)&aOther.m0)[0]) &&
-      (((uint32_t*)&m0)[1] == ((uint32_t*)&aOther.m0)[1]) &&
-      (((uint32_t*)&m0)[2] == ((uint32_t*)&aOther.m0)[2]) &&
-      (((uint32_t*)&m0)[3] == ((uint32_t*)&aOther.m0)[3]);
-  }
-
-  inline bool operator==(const nsID& aOther) const
-  {
-    return Equals(aOther);
-  }
-
-
-
-
-
-  bool Parse(const char* aIDStr);
-
-
-
-
-
-
-
-  char* ToString() const;
-
-
-
-
-
-
-  void ToProvidedString(char (&aDest)[39]) const;
-
-
-
-
-};
-# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
-class nsIDToCString
-{
-public:
-  explicit nsIDToCString(const nsID& aID)
-  {
-    aID.ToProvidedString(mStringBytes);
-  }
-
-  const char *get() const
-  {
-    return mStringBytes;
-  }
-
-protected:
-  char mStringBytes[39];
-};
-
-
-
-
-
-
-typedef nsID nsCID;
-# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsID.h"
-typedef nsID nsIID;
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h" 2
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
-class nsISupports
-{
-public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
-  virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
-
-
-
-
-
-
-
-  virtual MozExternalRefCountType AddRef(void) = 0;
-# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsBase.h"
-  virtual MozExternalRefCountType Release(void) = 0;
-
-
-};
-
-template<typename T> struct nsISupports::COMTypeInfo<nsISupports, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupports::COMTypeInfo<nsISupports, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x00000000, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} };
-# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOMCID.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-class nsAString;
-class nsACString;
-
-class nsISupports;
-class nsIModule;
-class nsIComponentManager;
-class nsIComponentRegistrar;
-class nsIServiceManager;
-class nsIFile;
-class nsILocalFile;
-class nsIDirectoryServiceProvider;
-class nsIMemory;
-class nsIDebug2;
-
-
-namespace mozilla {
-struct Module;
-}
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult
-NS_InitXPCOM2(nsIServiceManager** aResult,
-              nsIFile* aBinDirectory,
-              nsIDirectoryServiceProvider* aAppFileLocationProvider);
-
-
-
-
-
-extern "C" nsresult
-NS_InitMinimalXPCOM();
-# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_ShutdownXPCOM(nsIServiceManager* aServMgr);
-# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_GetServiceManager(nsIServiceManager** aResult);
-# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_GetComponentManager(nsIComponentManager** aResult);
-# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_GetComponentRegistrar(nsIComponentRegistrar** aResult);
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_GetMemoryManager(nsIMemory** aResult);
-# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_NewLocalFile(const nsAString& aPath,
-                                    bool aFollowLinks,
-                                    nsIFile** aResult);
-
-extern "C" nsresult NS_NewNativeLocalFile(const nsACString& aPath,
-                                          bool aFollowLinks,
-                                          nsIFile** aResult);
-
-
-
-
-class NS_ConvertUTF16toUTF8;
-nsresult NS_NewNativeLocalFile(const NS_ConvertUTF16toUTF8& aPath,
-                               bool aFollowLinks,
-                               nsIFile** aResult) = delete;
-# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-enum
-{
-  NS_DEBUG_WARNING = 0,
-  NS_DEBUG_ASSERTION = 1,
-  NS_DEBUG_BREAK = 2,
-  NS_DEBUG_ABORT = 3
-};
-# 255 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" void NS_DebugBreak(uint32_t aSeverity,
-                              const char* aStr, const char* aExpr,
-                              const char* aFile, int32_t aLine);
-# 275 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" void NS_LogInit();
-
-extern "C" void NS_LogTerm();
-
-
-
-
-
-
-
-class ScopedLogging
-{
-public:
-    ScopedLogging()
-    {
-        NS_LogInit();
-    }
-
-    ~ScopedLogging()
-    {
-        NS_LogTerm();
-    }
-};
-# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" void NS_LogCtor(void* aPtr, const char* aTypeName,
-                           uint32_t aInstanceSize);
-
-extern "C" void NS_LogDtor(void* aPtr, const char* aTypeName,
-                           uint32_t aInstanceSize);
-# 326 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" void NS_LogAddRef(void* aPtr, nsrefcnt aNewRefCnt,
-                             const char* aTypeName, uint32_t aInstanceSize);
-
-extern "C" void NS_LogRelease(void* aPtr, nsrefcnt aNewRefCnt,
-                              const char* aTypeName);
-# 342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" void NS_LogCOMPtrAddRef(void* aCOMPtr, nsISupports* aObject);
-
-extern "C" void NS_LogCOMPtrRelease(void* aCOMPtr, nsISupports* aObject);
-# 354 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-class nsCycleCollectionParticipant;
-class nsCycleCollectingAutoRefCnt;
-
-extern "C" void NS_CycleCollectorSuspect3(void* aPtr,
-                                          nsCycleCollectionParticipant* aCp,
-                                          nsCycleCollectingAutoRefCnt* aRefCnt,
-                                          bool* aShouldDelete);
-# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXPCOM.h"
-extern "C" nsresult NS_GetDebug(nsIDebug2** aResult);
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h" 2
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
-void NS_ABORT_OOM(size_t aSize);
-# 390 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
-extern "C" {
-# 402 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
-void printf_stderr(const char* aFmt, ...) __attribute__ ((format (printf, 1, 2)));
-
-
-
-
-void vprintf_stderr(const char* aFmt, va_list aArgs);
-# 424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDebug.h"
-void fprintf_stderr(FILE* aFile, const char* aFmt, ...) __attribute__ ((format (printf, 2, 3)));
-
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 1
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/md/_linux.cfg" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prcpucfg.h" 2
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h" 2
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-extern "C" {
-# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef unsigned char PRUint8;
-# 260 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef signed char PRInt8;
-# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef unsigned short PRUint16;
-typedef short PRInt16;
-# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef unsigned int PRUint32;
-typedef int PRInt32;
-# 365 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef long PRInt64;
-typedef unsigned long PRUint64;
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef int PRIntn;
-typedef unsigned int PRUintn;
-# 421 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef double PRFloat64;
-
-
-
-
-
-
-typedef size_t PRSize;
-
-
-
-
-
-
-
-typedef PRInt32 PROffset32;
-typedef PRInt64 PROffset64;
-
-
-
-
-
-
-
-typedef ptrdiff_t PRPtrdiff;
-# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef unsigned long PRUptrdiff;
-# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef PRIntn PRBool;
-# 477 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef PRUint8 PRPackedBool;
-
-
-
-
-
-typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
-
-
-
-
-
-
-typedef PRUint16 PRUnichar;
-# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-typedef long PRWord;
-typedef unsigned long PRUword;
-# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtypes.h"
-}
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
-extern "C" {
-
-
-
-
-
-typedef PRUint32 PRIntervalTime;
-# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
-extern __attribute__((visibility("default"))) PRIntervalTime PR_IntervalNow(void);
-# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
-extern __attribute__((visibility("default"))) PRUint32 PR_TicksPerSecond(void);
-# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
-extern __attribute__((visibility("default"))) PRIntervalTime PR_SecondsToInterval(PRUint32 seconds);
-extern __attribute__((visibility("default"))) PRIntervalTime PR_MillisecondsToInterval(PRUint32 milli);
-extern __attribute__((visibility("default"))) PRIntervalTime PR_MicrosecondsToInterval(PRUint32 micro);
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prinrval.h"
-extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToSeconds(PRIntervalTime ticks);
-extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMilliseconds(PRIntervalTime ticks);
-extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMicroseconds(PRIntervalTime ticks);
-
-}
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h" 2
-
-extern "C" {
-
-typedef struct PRThread PRThread;
-typedef struct PRThreadStack PRThreadStack;
-
-typedef enum PRThreadType {
-    PR_USER_THREAD,
-    PR_SYSTEM_THREAD
-} PRThreadType;
-
-typedef enum PRThreadScope {
-    PR_LOCAL_THREAD,
-    PR_GLOBAL_THREAD,
-    PR_GLOBAL_BOUND_THREAD
-} PRThreadScope;
-
-typedef enum PRThreadState {
-    PR_JOINABLE_THREAD,
-    PR_UNJOINABLE_THREAD
-} PRThreadState;
-
-typedef enum PRThreadPriority
-{
-    PR_PRIORITY_FIRST = 0,
-    PR_PRIORITY_LOW = 0,
-    PR_PRIORITY_NORMAL = 1,
-    PR_PRIORITY_HIGH = 2,
-    PR_PRIORITY_URGENT = 3,
-    PR_PRIORITY_LAST = 3
-} PRThreadPriority;
-# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) PRThread* PR_CreateThread(PRThreadType type,
-                     void ( *start)(void *arg),
-                     void *arg,
-                     PRThreadPriority priority,
-                     PRThreadScope scope,
-                     PRThreadState state,
-                     PRUint32 stackSize);
-# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) PRStatus PR_JoinThread(PRThread *thread);
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRThread* PR_GetCurrentThread(void);
-
-
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRThreadPriority PR_GetThreadPriority(const PRThread *thread);
-# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) void PR_SetThreadPriority(PRThread *thread, PRThreadPriority priority);
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRStatus PR_SetCurrentThreadName(const char *name);
-
-
-
-
-extern __attribute__((visibility("default"))) const char * PR_GetThreadName(const PRThread *thread);
-# 189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-typedef void ( *PRThreadPrivateDTOR)(void *priv);
-
-extern __attribute__((visibility("default"))) PRStatus PR_NewThreadPrivateIndex(
-    PRUintn *newIndex, PRThreadPrivateDTOR destructor);
-# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) PRStatus PR_SetThreadPrivate(PRUintn tpdIndex, void *priv);
-# 216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) void* PR_GetThreadPrivate(PRUintn tpdIndex);
-# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) PRStatus PR_Interrupt(PRThread *thread);
-
-
-
-
-
-extern __attribute__((visibility("default"))) void PR_ClearInterrupt(void);
-
-
-
-
-extern __attribute__((visibility("default"))) void PR_BlockInterrupt(void);
-
-
-
-
-extern __attribute__((visibility("default"))) void PR_UnblockInterrupt(void);
-# 253 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prthread.h"
-extern __attribute__((visibility("default"))) PRStatus PR_Sleep(PRIntervalTime ticks);
-
-
-
-
-extern __attribute__((visibility("default"))) PRThreadScope PR_GetThreadScope(const PRThread *thread);
-
-
-
-
-extern __attribute__((visibility("default"))) PRThreadType PR_GetThreadType(const PRThread *thread);
-
-
-
-
-extern __attribute__((visibility("default"))) PRThreadState PR_GetThreadState(const PRThread *thread);
-
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MacroForEach.h" 1
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h" 2
-
-
-
-
-
-
-
-inline nsISupports*
-ToSupports(nsISupports* aSupports)
-{
-  return aSupports;
-}
-
-inline nsISupports*
-ToCanonicalSupports(nsISupports* aSupports)
-{
-  return nullptr;
-}
-# 174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
-class nsCycleCollectingAutoRefCnt
-{
-public:
-  nsCycleCollectingAutoRefCnt() : mRefCntAndFlags(0) {}
-
-  explicit nsCycleCollectingAutoRefCnt(uintptr_t aValue)
-    : mRefCntAndFlags(aValue << 2)
-  {
-  }
-
-  nsCycleCollectingAutoRefCnt(const nsCycleCollectingAutoRefCnt&) = delete;
-  void operator=(const nsCycleCollectingAutoRefCnt&) = delete;
-
-  __attribute__((always_inline)) inline uintptr_t incr(nsISupports* aOwner)
-  {
-    return incr(aOwner, nullptr);
-  }
-
-  __attribute__((always_inline)) inline uintptr_t incr(void* aOwner,
-                                   nsCycleCollectionParticipant* aCp)
-  {
-    mRefCntAndFlags += (1 << 2);
-    mRefCntAndFlags &= ~(1 << 1);
-
-
-    if (!IsInPurpleBuffer()) {
-      mRefCntAndFlags |= (1 << 0);
-
-      do { } while (0);
-      NS_CycleCollectorSuspect3(aOwner, aCp, this, nullptr);
-    }
-    return (mRefCntAndFlags >> 2);
-  }
-
-  __attribute__((always_inline)) inline void stabilizeForDeletion()
-  {
-
-
-    mRefCntAndFlags = (1 << 2) | (1 << 0);
-  }
-
-  __attribute__((always_inline)) inline uintptr_t decr(nsISupports* aOwner,
-                                   bool* aShouldDelete = nullptr)
-  {
-    return decr(aOwner, nullptr, aShouldDelete);
-  }
-
-  __attribute__((always_inline)) inline uintptr_t decr(void* aOwner,
-                                   nsCycleCollectionParticipant* aCp,
-                                   bool* aShouldDelete = nullptr)
-  {
-    do { } while (0);
-    if (!IsInPurpleBuffer()) {
-      mRefCntAndFlags -= (1 << 2);
-      mRefCntAndFlags |= ((1 << 0) | (1 << 1));
-      uintptr_t retval = (mRefCntAndFlags >> 2);
-
-      NS_CycleCollectorSuspect3(aOwner, aCp, this, aShouldDelete);
-      return retval;
-    }
-    mRefCntAndFlags -= (1 << 2);
-    mRefCntAndFlags |= ((1 << 0) | (1 << 1));
-    return (mRefCntAndFlags >> 2);
-  }
-
-  __attribute__((always_inline)) inline void RemovePurple()
-  {
-    do { } while (0);
-    mRefCntAndFlags &= ~(1 << 1);
-  }
-
-  __attribute__((always_inline)) inline void RemoveFromPurpleBuffer()
-  {
-    do { } while (0);
-    mRefCntAndFlags &= ~((1 << 1) | (1 << 0));
-  }
-
-  __attribute__((always_inline)) inline bool IsPurple() const
-  {
-    return !!(mRefCntAndFlags & (1 << 1));
-  }
-
-  __attribute__((always_inline)) inline bool IsInPurpleBuffer() const
-  {
-    return !!(mRefCntAndFlags & (1 << 0));
-  }
-
-  __attribute__((always_inline)) inline nsrefcnt get() const
-  {
-    return (mRefCntAndFlags >> 2);
-  }
-
-  __attribute__((always_inline)) inline operator nsrefcnt() const
-  {
-    return get();
-  }
-
-private:
-  uintptr_t mRefCntAndFlags;
-};
-
-class nsAutoRefCnt
-{
-public:
-  nsAutoRefCnt() : mValue(0) {}
-  explicit nsAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {}
-
-  nsAutoRefCnt(const nsAutoRefCnt&) = delete;
-  void operator=(const nsAutoRefCnt&) = delete;
-
-
-  nsrefcnt operator++() { return ++mValue; }
-  nsrefcnt operator--() { return --mValue; }
-
-  nsrefcnt operator=(nsrefcnt aValue) { return (mValue = aValue); }
-  operator nsrefcnt() const { return mValue; }
-  nsrefcnt get() const { return mValue; }
-
-  static const bool isThreadSafe = false;
-private:
-  nsrefcnt operator++(int) = delete;
-  nsrefcnt operator--(int) = delete;
-  nsrefcnt mValue;
-};
-
-namespace mozilla {
-class ThreadSafeAutoRefCnt
-{
-public:
-  ThreadSafeAutoRefCnt() : mValue(0) {}
-  explicit ThreadSafeAutoRefCnt(nsrefcnt aValue) : mValue(aValue) {}
-
-  ThreadSafeAutoRefCnt(const ThreadSafeAutoRefCnt&) = delete;
-  void operator=(const ThreadSafeAutoRefCnt&) = delete;
-
-
-  __attribute__((always_inline)) inline nsrefcnt operator++()
-  {
-# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
-    return mValue.fetch_add(1, std::memory_order_relaxed) + 1;
-  }
-  __attribute__((always_inline)) inline nsrefcnt operator--()
-  {
-
-
-
-
-    nsrefcnt result = mValue.fetch_sub(1, std::memory_order_release) - 1;
-    if (result == 0) {
-
-
-
-
-      result = mValue.load(std::memory_order_acquire);
-    }
-    return result;
-  }
-
-  __attribute__((always_inline)) inline nsrefcnt operator=(nsrefcnt aValue)
-  {
-
-
-    mValue.store(aValue, std::memory_order_release);
-    return aValue;
-  }
-  __attribute__((always_inline)) inline operator nsrefcnt() const { return get(); }
-  __attribute__((always_inline)) inline nsrefcnt get() const
-  {
-
-
-    return mValue.load(std::memory_order_acquire);
-  }
-
-  static const bool isThreadSafe = true;
-private:
-  nsrefcnt operator++(int) = delete;
-  nsrefcnt operator--(int) = delete;
-  std::atomic<nsrefcnt> mValue;
-};
-}
-# 759 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsImpl.h"
-struct QITableEntry
-{
-  const nsIID* iid;
-  int32_t offset;
-};
-
-nsresult
-NS_TableDrivenQI(void* aThis, const nsIID& aIID,
-                 void** aInstancePtr, const QITableEntry* aEntries);
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h" 2
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
-template<class T>
-inline void
-ns_if_addref(T aExpr)
-{
-  if (aExpr) {
-    aExpr->AddRef();
-  }
-}
-# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsUtils.h"
-template<class T, class DestinationType>
-inline nsresult
-CallQueryInterface(T* aSource, DestinationType** aDestination)
-{
-
-
-  static_assert(!mozilla::IsSame<T, DestinationType>::value ||
-                mozilla::IsSame<DestinationType, nsISupports>::value,
-                "don't use CallQueryInterface for compile-time-determinable casts");
-
-  do { } while(0);
-  do { } while(0);
-
-  return aSource->QueryInterface((DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                                 reinterpret_cast<void**>(aDestination));
-}
-
-template <class SourceType, class DestinationType>
-inline nsresult
-CallQueryInterface(RefPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr)
-{
-  return CallQueryInterface(aSourcePtr.get(), aDestPtr);
-}
-# 131 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupports.h" 2
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionTraversalCallback.h" 2
-
-class nsCycleCollectionParticipant;
-
-class nsCycleCollectionTraversalCallback
-{
-public:
-
-
-
-
-  virtual void DescribeRefCountedNode(nsrefcnt aRefcount,
-                                           const char* aObjName) = 0;
-
-  virtual void DescribeGCedNode(bool aIsMarked,
-                                     const char* aObjName,
-                                     uint64_t aCompartmentAddress = 0) = 0;
-
-  virtual void NoteXPCOMChild(nsISupports* aChild) = 0;
-  virtual void NoteJSChild(const JS::GCCellPtr& aThing) = 0;
-  virtual void NoteNativeChild(void* aChild,
-                                    nsCycleCollectionParticipant* aHelper) = 0;
-
-
-
-
-
-  virtual void NoteNextEdgeName(const char* aName) = 0;
-
-  enum
-  {
-
-
-
-
-    WANT_DEBUG_INFO = (1 << 0),
-
-
-
-    WANT_ALL_TRACES = (1 << 1)
-  };
-  uint32_t Flags() const { return mFlags; }
-  bool WantDebugInfo() const { return (mFlags & WANT_DEBUG_INFO) != 0; }
-  bool WantAllTraces() const { return (mFlags & WANT_ALL_TRACES) != 0; }
-protected:
-  nsCycleCollectionTraversalCallback() : mFlags(0) {}
-
-  uint32_t mFlags;
-};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h" 2
-
-
-
-enum
-{
-  CycleCollectionEdgeNameArrayFlag = 1
-};
-
-
-void
-CycleCollectionNoteEdgeNameImpl(nsCycleCollectionTraversalCallback& aCallback,
-                                const char* aName,
-                                uint32_t aFlags = 0);
-
-
-__attribute__((always_inline)) inline void
-CycleCollectionNoteEdgeName(nsCycleCollectionTraversalCallback& aCallback,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  if ((__builtin_expect(!!(aCallback.WantDebugInfo()), 0))) {
-    CycleCollectionNoteEdgeNameImpl(aCallback, aName, aFlags);
-  }
-}
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionNoteChild.h"
-template<typename T>
-nsISupports*
-ToSupports(T* aPtr, typename T::cycleCollection* aDummy = 0)
-{
-  return T::cycleCollection::Upcast(aPtr);
-}
-
-
-
-template<typename T,
-         bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
-struct CycleCollectionNoteChildImpl
-{
-};
-
-template<typename T>
-struct CycleCollectionNoteChildImpl<T, true>
-{
-  static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild)
-  {
-    aCallback.NoteXPCOMChild(ToSupports(aChild));
-  }
-};
-
-template<typename T>
-struct CycleCollectionNoteChildImpl<T, false>
-{
-  static void Run(nsCycleCollectionTraversalCallback& aCallback, T* aChild)
-  {
-    aCallback.NoteNativeChild(aChild, T::cycleCollection::GetParticipant());
-  }
-};
-
-
-
-
-template<typename T>
-inline void
-CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
-                         T* aChild, const char* aName, uint32_t aFlags)
-{
-  CycleCollectionNoteEdgeName(aCallback, aName, aFlags);
-  CycleCollectionNoteChildImpl<T>::Run(aCallback, aChild);
-}
-
-template<typename T>
-inline void
-CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
-                         T* aChild, const char* aName)
-{
-  CycleCollectionNoteChild(aCallback, aChild, aName, 0);
-}
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h" 1
-# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCharTraits.h"
-template <class CharT>
-struct nsCharTraits
-{
-};
-
-template <>
-struct nsCharTraits<char16_t>
-{
-  typedef char16_t char_type;
-  typedef uint16_t unsigned_char_type;
-  typedef char incompatible_char_type;
-
-  static char_type* const sEmptyBuffer;
-
-  static void
-  assign(char_type& aLhs, char_type aRhs)
-  {
-    aLhs = aRhs;
-  }
-
-
-
-  typedef int int_type;
-
-  static char_type
-  to_char_type(int_type aChar)
-  {
-    return char_type(aChar);
-  }
-
-  static int_type
-  to_int_type(char_type aChar)
-  {
-    return int_type(static_cast<unsigned_char_type>(aChar));
-  }
-
-  static bool
-  eq_int_type(int_type aLhs, int_type aRhs)
-  {
-    return aLhs == aRhs;
-  }
-
-
-
-
-  static bool
-  eq(char_type aLhs, char_type aRhs)
-  {
-    return aLhs == aRhs;
-  }
-
-  static bool
-  lt(char_type aLhs, char_type aRhs)
-  {
-    return aLhs < aRhs;
-  }
-
-
-
-
-  static char_type*
-  move(char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    return static_cast<char_type*>(memmove(aStr1, aStr2,
-                                           aN * sizeof(char_type)));
-  }
-
-  static char_type*
-  copy(char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    return static_cast<char_type*>(memcpy(aStr1, aStr2,
-                                          aN * sizeof(char_type)));
-  }
-
-  static char_type*
-  copyASCII(char_type* aStr1, const char* aStr2, size_t aN)
-  {
-    for (char_type* s = aStr1; aN--; ++s, ++aStr2) {
-      do { } while(0);
-      *s = static_cast<char_type>(*aStr2);
-    }
-    return aStr1;
-  }
-
-  static char_type*
-  assign(char_type* aStr, size_t aN, char_type aChar)
-  {
-    char_type* result = aStr;
-    while (aN--) {
-      assign(*aStr++, aChar);
-    }
-    return result;
-  }
-
-  static int
-  compare(const char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      if (!eq(*aStr1, *aStr2)) {
-        return to_int_type(*aStr1) - to_int_type(*aStr2);
-      }
-    }
-
-    return 0;
-  }
-
-  static int
-  compareASCII(const char_type* aStr1, const char* aStr2, size_t aN)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      do { } while(0);
-      if (!eq_int_type(to_int_type(*aStr1),
-                       to_int_type(static_cast<char_type>(*aStr2)))) {
-        return to_int_type(*aStr1) -
-               to_int_type(static_cast<char_type>(*aStr2));
-      }
-    }
-
-    return 0;
-  }
-
-
-
-
-  static int
-  compareASCIINullTerminated(const char_type* aStr1, size_t aN,
-                             const char* aStr2)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      if (!*aStr2) {
-        return 1;
-      }
-      do { } while(0);
-      if (!eq_int_type(to_int_type(*aStr1),
-                       to_int_type(static_cast<char_type>(*aStr2)))) {
-        return to_int_type(*aStr1) -
-               to_int_type(static_cast<char_type>(*aStr2));
-      }
-    }
-
-    if (*aStr2) {
-      return -1;
-    }
-
-    return 0;
-  }
-
-
-
-
-
-  static char_type
-  ASCIIToLower(char_type aChar)
-  {
-    if (aChar >= 'A' && aChar <= 'Z') {
-      return char_type(aChar + ('a' - 'A'));
-    }
-
-    return aChar;
-  }
-
-  static int
-  compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      do { } while(0);
-      do { } while(0);
-
-      char_type lower_s1 = ASCIIToLower(*aStr1);
-      if (lower_s1 != static_cast<char_type>(*aStr2)) {
-        return to_int_type(lower_s1) -
-               to_int_type(static_cast<char_type>(*aStr2));
-      }
-    }
-
-    return 0;
-  }
-
-
-
-
-  static int
-  compareLowerCaseToASCIINullTerminated(const char_type* aStr1,
-                                        size_t aN, const char* aStr2)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      if (!*aStr2) {
-        return 1;
-      }
-      do { } while(0);
-      do { } while(0);
-
-      char_type lower_s1 = ASCIIToLower(*aStr1);
-      if (lower_s1 != static_cast<char_type>(*aStr2)) {
-        return to_int_type(lower_s1) -
-               to_int_type(static_cast<char_type>(*aStr2));
-      }
-    }
-
-    if (*aStr2) {
-      return -1;
-    }
-
-    return 0;
-  }
-
-  static size_t
-  length(const char_type* aStr)
-  {
-    size_t result = 0;
-    while (!eq(*aStr++, char_type(0))) {
-      ++result;
-    }
-    return result;
-  }
-
-  static const char_type*
-  find(const char_type* aStr, size_t aN, char_type aChar)
-  {
-    while (aN--) {
-      if (eq(*aStr, aChar)) {
-        return aStr;
-      }
-      ++aStr;
-    }
-
-    return 0;
-  }
-};
-
-template <>
-struct nsCharTraits<char>
-{
-  typedef char char_type;
-  typedef unsigned char unsigned_char_type;
-  typedef char16_t incompatible_char_type;
-
-  static char_type* const sEmptyBuffer;
-
-  static void
-  assign(char_type& aLhs, char_type aRhs)
-  {
-    aLhs = aRhs;
-  }
-
-
-
-
-  typedef int int_type;
-
-  static char_type
-  to_char_type(int_type aChar)
-  {
-    return char_type(aChar);
-  }
-
-  static int_type
-  to_int_type(char_type aChar)
-  {
-    return int_type(static_cast<unsigned_char_type>(aChar));
-  }
-
-  static bool
-  eq_int_type(int_type aLhs, int_type aRhs)
-  {
-    return aLhs == aRhs;
-  }
-
-
-
-
-  static bool eq(char_type aLhs, char_type aRhs)
-  {
-    return aLhs == aRhs;
-  }
-
-  static bool
-  lt(char_type aLhs, char_type aRhs)
-  {
-    return aLhs < aRhs;
-  }
-
-
-
-
-  static char_type*
-  move(char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    return static_cast<char_type*>(memmove(aStr1, aStr2,
-                                           aN * sizeof(char_type)));
-  }
-
-  static char_type*
-  copy(char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    return static_cast<char_type*>(memcpy(aStr1, aStr2,
-                                          aN * sizeof(char_type)));
-  }
-
-  static char_type*
-  copyASCII(char_type* aStr1, const char* aStr2, size_t aN)
-  {
-    return copy(aStr1, aStr2, aN);
-  }
-
-  static char_type*
-  assign(char_type* aStr, size_t aN, char_type aChar)
-  {
-    return static_cast<char_type*>(memset(aStr, to_int_type(aChar), aN));
-  }
-
-  static int
-  compare(const char_type* aStr1, const char_type* aStr2, size_t aN)
-  {
-    return memcmp(aStr1, aStr2, aN);
-  }
-
-  static int
-  compareASCII(const char_type* aStr1, const char* aStr2, size_t aN)
-  {
-
-
-
-
-
-    return compare(aStr1, aStr2, aN);
-  }
-
-
-
-
-  static int
-  compareASCIINullTerminated(const char_type* aStr1, size_t aN,
-                             const char* aStr2)
-  {
-
-
-    for (; aN--; ++aStr1, ++aStr2) {
-      if (!*aStr2) {
-        return 1;
-      }
-      do { } while(0);
-      if (*aStr1 != *aStr2) {
-        return to_int_type(*aStr1) - to_int_type(*aStr2);
-      }
-    }
-
-    if (*aStr2) {
-      return -1;
-    }
-
-    return 0;
-  }
-
-
-
-
-  static char_type
-  ASCIIToLower(char_type aChar)
-  {
-    if (aChar >= 'A' && aChar <= 'Z') {
-      return char_type(aChar + ('a' - 'A'));
-    }
-
-    return aChar;
-  }
-
-  static int
-  compareLowerCaseToASCII(const char_type* aStr1, const char* aStr2, size_t aN)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      do { } while(0);
-      do { } while(0);
-
-      char_type lower_s1 = ASCIIToLower(*aStr1);
-      if (lower_s1 != *aStr2) {
-        return to_int_type(lower_s1) - to_int_type(*aStr2);
-      }
-    }
-    return 0;
-  }
-
-
-
-
-  static int
-  compareLowerCaseToASCIINullTerminated(const char_type* aStr1, size_t aN,
-                                        const char* aStr2)
-  {
-    for (; aN--; ++aStr1, ++aStr2) {
-      if (!*aStr2) {
-        return 1;
-      }
-      do { } while(0);
-      do { } while(0);
-
-      char_type lower_s1 = ASCIIToLower(*aStr1);
-      if (lower_s1 != *aStr2) {
-        return to_int_type(lower_s1) - to_int_type(*aStr2);
-      }
-    }
-
-    if (*aStr2) {
-      return -1;
-    }
-
-    return 0;
-  }
-
-  static size_t
-  length(const char_type* aStr)
-  {
-    return strlen(aStr);
-  }
-
-  static const char_type*
-  find(const char_type* aStr, size_t aN, char_type aChar)
-  {
-    return reinterpret_cast<const char_type*>(memchr(aStr, to_int_type(aChar),
-                                                     aN));
-  }
-};
-
-template <class InputIterator>
-struct nsCharSourceTraits
-{
-  typedef typename InputIterator::difference_type difference_type;
-
-  static uint32_t
-  readable_distance(const InputIterator& aFirst, const InputIterator& aLast)
-  {
-
-    return uint32_t(aLast.get() - aFirst.get());
-  }
-
-  static const typename InputIterator::value_type*
-  read(const InputIterator& aIter)
-  {
-    return aIter.get();
-  }
-
-  static void
-  advance(InputIterator& aStr, difference_type aN)
-  {
-    aStr.advance(aN);
-  }
-};
-
-template <class CharT>
-struct nsCharSourceTraits<CharT*>
-{
-  typedef ptrdiff_t difference_type;
-
-  static uint32_t
-  readable_distance(CharT* aStr)
-  {
-    return uint32_t(nsCharTraits<CharT>::length(aStr));
-
-  }
-
-  static uint32_t
-  readable_distance(CharT* aFirst, CharT* aLast)
-  {
-    return uint32_t(aLast - aFirst);
-  }
-
-  static const CharT*
-  read(CharT* aStr)
-  {
-    return aStr;
-  }
-
-  static void
-  advance(CharT*& aStr, difference_type aN)
-  {
-    aStr += aN;
-  }
-};
-
-template <class OutputIterator>
-struct nsCharSinkTraits
-{
-  static void
-  write(OutputIterator& aIter, const typename OutputIterator::value_type* aStr,
-        uint32_t aN)
-  {
-    aIter.write(aStr, aN);
-  }
-};
-
-template <class CharT>
-struct nsCharSinkTraits<CharT*>
-{
-  static void
-  write(CharT*& aIter, const CharT* aStr, uint32_t aN)
-  {
-    nsCharTraits<CharT>::move(aIter, aStr, aN);
-    aIter += aN;
-  }
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAlgorithm.h" 2
-
-template <class T>
-inline T
-NS_ROUNDUP(const T& aA, const T& aB)
-{
-  return ((aA + (aB - 1)) / aB) * aB;
-}
-
-
-
-
-template <class T>
-inline const T&
-XPCOM_MIN(const T& aA, const T& aB)
-{
-  return aB < aA ? aB : aA;
-}
-
-
-template <class T>
-inline const T&
-XPCOM_MAX(const T& aA, const T& aB)
-{
-  return aA > aB ? aA : aB;
-}
-
-namespace mozilla {
-
-template <class T>
-inline const T&
-clamped(const T& aA, const T& aMin, const T& aMax)
-{
-  do { } while (0);
-
-  return XPCOM_MIN(XPCOM_MAX(aA, aMin), aMax);
-}
-
-}
-
-template <class InputIterator, class T>
-inline uint32_t
-NS_COUNT(InputIterator& aFirst, const InputIterator& aLast, const T& aValue)
-{
-  uint32_t result = 0;
-  for (; aFirst != aLast; ++aFirst)
-    if (*aFirst == aValue) {
-      ++result;
-    }
-  return result;
-}
-
-template <class InputIterator, class OutputIterator>
-inline OutputIterator&
-copy_string(const InputIterator& aFirst, const InputIterator& aLast,
-            OutputIterator& aResult)
-{
-  typedef nsCharSourceTraits<InputIterator> source_traits;
-  typedef nsCharSinkTraits<OutputIterator> sink_traits;
-
-  sink_traits::write(aResult, source_traits::read(aFirst),
-                     source_traits::readable_distance(aFirst, aLast));
-  return aResult;
-}
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h"
-extern "C" {
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQuickSort.h"
-void NS_QuickSort(void*, unsigned int, unsigned int,
-                  int (*)(const void*, const void*, void*),
-                  void*);
-
-
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegionFwd.h"
-namespace mozilla {
-namespace gfx {
-
-struct UnknownUnits;
-
-template <class units>
-class IntRegionTyped;
-
-typedef IntRegionTyped<UnknownUnits> IntRegion;
-
-}
-}
-
-typedef mozilla::gfx::IntRegion nsIntRegion;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 1 3
-# 47 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
-
-
-
-
-
-
-#pragma GCC visibility push(default)
-
-extern "C++" {
-
-namespace __cxxabiv1
-{
-  class __class_type_info;
-}
-# 80 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
-namespace std
-{
-
-
-
-
-
-
-  class type_info
-  {
-  public:
-
-
-
-
-    virtual ~type_info();
-
-
-
-    const char* name() const noexcept
-    { return __name[0] == '*' ? __name + 1 : __name; }
-# 115 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
-    bool before(const type_info& __arg) const noexcept
-    { return (__name[0] == '*' && __arg.__name[0] == '*')
- ? __name < __arg.__name
- : __builtin_strcmp (__name, __arg.__name) < 0; }
-
-    bool operator==(const type_info& __arg) const noexcept
-    {
-      return ((__name == __arg.__name)
-       || (__name[0] != '*' &&
-    __builtin_strcmp (__name, __arg.__name) == 0));
-    }
-# 136 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/typeinfo" 3
-    bool operator!=(const type_info& __arg) const noexcept
-    { return !operator==(__arg); }
-
-
-    size_t hash_code() const noexcept
-    {
-
-      return _Hash_bytes(name(), __builtin_strlen(name()),
-    static_cast<size_t>(0xc70f6907UL));
-
-
-
-    }
-
-
-
-    virtual bool __is_pointer_p() const;
-
-
-    virtual bool __is_function_p() const;
-
-
-
-
-
-
-
-    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
-       unsigned __outer) const;
-
-
-    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
-        void **__obj_ptr) const;
-
-  protected:
-    const char *__name;
-
-    explicit type_info(const char *__n): __name(__n) { }
-
-  private:
-
-    type_info& operator=(const type_info&);
-    type_info(const type_info&);
-  };
-
-
-
-
-
-
-
-  class bad_cast : public exception
-  {
-  public:
-    bad_cast() noexcept { }
-
-
-
-    virtual ~bad_cast() noexcept;
-
-
-    virtual const char* what() const noexcept;
-  };
-
-
-
-
-
-  class bad_typeid : public exception
-  {
-  public:
-    bad_typeid () noexcept { }
-
-
-
-    virtual ~bad_typeid() noexcept;
-
-
-    virtual const char* what() const noexcept;
-  };
-}
-
-}
-
-#pragma GCC visibility pop
-# 54 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 1 3
-# 33 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3
-
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 1 3
-# 35 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/uses_allocator.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  struct __erased_type { };
-
-  template<typename _Alloc, typename _Tp>
-    using __is_erased_or_convertible
-      = __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
-
-
-  struct allocator_arg_t { explicit allocator_arg_t() = default; };
-
-  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
-
-  template<typename _Tp, typename _Alloc, typename = __void_t<>>
-    struct __uses_allocator_helper
-    : false_type { };
-
-  template<typename _Tp, typename _Alloc>
-    struct __uses_allocator_helper<_Tp, _Alloc,
-       __void_t<typename _Tp::allocator_type>>
-    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
-    { };
-
-
-  template<typename _Tp, typename _Alloc>
-    struct uses_allocator
-    : __uses_allocator_helper<_Tp, _Alloc>::type
-    { };
-
-  struct __uses_alloc_base { };
-
-  struct __uses_alloc0 : __uses_alloc_base
-  {
-    struct _Sink { void operator=(const void*) { } } _M_a;
-  };
-
-  template<typename _Alloc>
-    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
-
-  template<typename _Alloc>
-    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
-
-  template<bool, typename _Tp, typename _Alloc, typename... _Args>
-    struct __uses_alloc;
-
-  template<typename _Tp, typename _Alloc, typename... _Args>
-    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
-    : conditional<
-        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
-        __uses_alloc1<_Alloc>,
-        __uses_alloc2<_Alloc>>::type
-    {
-      static_assert(__or_<
-   is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>,
-   is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with"
-   " an allocator must be possible if uses_allocator is true");
-    };
-
-  template<typename _Tp, typename _Alloc, typename... _Args>
-    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
-    : __uses_alloc0 { };
-
-  template<typename _Tp, typename _Alloc, typename... _Args>
-    using __uses_alloc_t =
-      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
-
-  template<typename _Tp, typename _Alloc, typename... _Args>
-    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
-    __use_alloc(const _Alloc& __a)
-    {
-      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
-      __ret._M_a = std::__addressof(__a);
-      return __ret;
-    }
-
-
-}
-# 41 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
-    struct _Head_base;
-
-  template<std::size_t _Idx, typename _Head>
-    struct _Head_base<_Idx, _Head, true>
-    : public _Head
-    {
-      constexpr _Head_base()
-      : _Head() { }
-
-      constexpr _Head_base(const _Head& __h)
-      : _Head(__h) { }
-
-      constexpr _Head_base(const _Head_base&) = default;
-      constexpr _Head_base(_Head_base&&) = default;
-
-      template<typename _UHead>
-        constexpr _Head_base(_UHead&& __h)
- : _Head(std::forward<_UHead>(__h)) { }
-
-      _Head_base(allocator_arg_t, __uses_alloc0)
-      : _Head() { }
-
-      template<typename _Alloc>
- _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
- : _Head(allocator_arg, *__a._M_a) { }
-
-      template<typename _Alloc>
- _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
- : _Head(*__a._M_a) { }
-
-      template<typename _UHead>
- _Head_base(__uses_alloc0, _UHead&& __uhead)
- : _Head(std::forward<_UHead>(__uhead)) { }
-
-      template<typename _Alloc, typename _UHead>
- _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
- : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
-
-      template<typename _Alloc, typename _UHead>
- _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
- : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
-
-      static constexpr _Head&
-      _M_head(_Head_base& __b) noexcept { return __b; }
-
-      static constexpr const _Head&
-      _M_head(const _Head_base& __b) noexcept { return __b; }
-    };
-
-  template<std::size_t _Idx, typename _Head>
-    struct _Head_base<_Idx, _Head, false>
-    {
-      constexpr _Head_base()
-      : _M_head_impl() { }
-
-      constexpr _Head_base(const _Head& __h)
-      : _M_head_impl(__h) { }
-
-      constexpr _Head_base(const _Head_base&) = default;
-      constexpr _Head_base(_Head_base&&) = default;
-
-      template<typename _UHead>
-        constexpr _Head_base(_UHead&& __h)
- : _M_head_impl(std::forward<_UHead>(__h)) { }
-
-      _Head_base(allocator_arg_t, __uses_alloc0)
-      : _M_head_impl() { }
-
-      template<typename _Alloc>
- _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
- : _M_head_impl(allocator_arg, *__a._M_a) { }
-
-      template<typename _Alloc>
- _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
- : _M_head_impl(*__a._M_a) { }
-
-      template<typename _UHead>
- _Head_base(__uses_alloc0, _UHead&& __uhead)
- : _M_head_impl(std::forward<_UHead>(__uhead)) { }
-
-      template<typename _Alloc, typename _UHead>
- _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
- : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
- { }
-
-      template<typename _Alloc, typename _UHead>
- _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
- : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
-
-      static constexpr _Head&
-      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
-
-      static constexpr const _Head&
-      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
-
-      _Head _M_head_impl;
-    };
-# 158 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/tuple" 3
-  template<std::size_t _Idx, typename... _Elements>
-    struct _Tuple_impl;
-
-  template<typename _Tp>
-    struct __is_empty_non_tuple : is_empty<_Tp> { };
-
-
-  template<typename _El0, typename... _El>
-    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
-
-
-  template<typename _Tp>
-    using __empty_not_final
-    = typename conditional<__is_final(_Tp), false_type,
-      __is_empty_non_tuple<_Tp>>::type;
-
-
-
-
-
-
-  template<std::size_t _Idx, typename _Head, typename... _Tail>
-    struct _Tuple_impl<_Idx, _Head, _Tail...>
-    : public _Tuple_impl<_Idx + 1, _Tail...>,
-      private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
-    {
-      template<std::size_t, typename...> friend class _Tuple_impl;
-
-      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
-      typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
-
-      static constexpr _Head&
-      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
-
-      static constexpr const _Head&
-      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
-
-      static constexpr _Inherited&
-      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
-
-      static constexpr const _Inherited&
-      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
-
-      constexpr _Tuple_impl()
-      : _Inherited(), _Base() { }
-
-      explicit
-      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
-      : _Inherited(__tail...), _Base(__head) { }
-
-      template<typename _UHead, typename... _UTail, typename = typename
-               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
-        explicit
-        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
- : _Inherited(std::forward<_UTail>(__tail)...),
-   _Base(std::forward<_UHead>(__head)) { }
-
-      constexpr _Tuple_impl(const _Tuple_impl&) = default;
-
-      constexpr
-      _Tuple_impl(_Tuple_impl&& __in)
-      noexcept(__and_<is_nothrow_move_constructible<_Head>,
-               is_nothrow_move_constructible<_Inherited>>::value)
-      : _Inherited(std::move(_M_tail(__in))),
- _Base(std::forward<_Head>(_M_head(__in))) { }
-
-      template<typename... _UElements>
-        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
-   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
-
-      template<typename _UHead, typename... _UTails>
-        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
- : _Inherited(std::move
-       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
-   _Base(std::forward<_UHead>
-  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
- : _Inherited(__tag, __a),
-          _Base(__tag, __use_alloc<_Head>(__a)) { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-      const _Head& __head, const _Tail&... __tail)
- : _Inherited(__tag, __a, __tail...),
-          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
-
-      template<typename _Alloc, typename _UHead, typename... _UTail,
-               typename = typename enable_if<sizeof...(_Tail)
-          == sizeof...(_UTail)>::type>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _UHead&& __head, _UTail&&... __tail)
- : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
-          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
-         std::forward<_UHead>(__head)) { }
-
-      template<typename _Alloc>
-        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             const _Tuple_impl& __in)
- : _Inherited(__tag, __a, _M_tail(__in)),
-          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _Tuple_impl&& __in)
- : _Inherited(__tag, __a, std::move(_M_tail(__in))),
-   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-         std::forward<_Head>(_M_head(__in))) { }
-
-      template<typename _Alloc, typename... _UElements>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             const _Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(__tag, __a,
-       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
-   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-  _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
-
-      template<typename _Alloc, typename _UHead, typename... _UTails>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
- : _Inherited(__tag, __a, std::move
-       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
-   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
-                std::forward<_UHead>
-  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
-
-      _Tuple_impl&
-      operator=(const _Tuple_impl& __in)
-      {
- _M_head(*this) = _M_head(__in);
- _M_tail(*this) = _M_tail(__in);
- return *this;
-      }
-
-      _Tuple_impl&
-      operator=(_Tuple_impl&& __in)
-      noexcept(__and_<is_nothrow_move_assignable<_Head>,
-               is_nothrow_move_assignable<_Inherited>>::value)
-      {
- _M_head(*this) = std::forward<_Head>(_M_head(__in));
- _M_tail(*this) = std::move(_M_tail(__in));
- return *this;
-      }
-
-      template<typename... _UElements>
-        _Tuple_impl&
-        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
-        {
-   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
-   _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
-   return *this;
- }
-
-      template<typename _UHead, typename... _UTails>
-        _Tuple_impl&
-        operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
-        {
-   _M_head(*this) = std::forward<_UHead>
-     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
-   _M_tail(*this) = std::move
-     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
-   return *this;
- }
-
-    protected:
-      void
-      _M_swap(_Tuple_impl& __in)
-      noexcept(__is_nothrow_swappable<_Head>::value
-               && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
-      {
- using std::swap;
- swap(_M_head(*this), _M_head(__in));
- _Inherited::_M_swap(_M_tail(__in));
-      }
-    };
-
-
-  template<std::size_t _Idx, typename _Head>
-    struct _Tuple_impl<_Idx, _Head>
-    : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
-    {
-      template<std::size_t, typename...> friend class _Tuple_impl;
-
-      typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
-
-      static constexpr _Head&
-      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
-
-      static constexpr const _Head&
-      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
-
-      constexpr _Tuple_impl()
-      : _Base() { }
-
-      explicit
-      constexpr _Tuple_impl(const _Head& __head)
-      : _Base(__head) { }
-
-      template<typename _UHead>
-        explicit
-        constexpr _Tuple_impl(_UHead&& __head)
- : _Base(std::forward<_UHead>(__head)) { }
-
-      constexpr _Tuple_impl(const _Tuple_impl&) = default;
-
-      constexpr
-      _Tuple_impl(_Tuple_impl&& __in)
-      noexcept(is_nothrow_move_constructible<_Head>::value)
-      : _Base(std::forward<_Head>(_M_head(__in))) { }
-
-      template<typename _UHead>
-        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
- : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
-
-      template<typename _UHead>
-        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
- : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
- { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
- : _Base(__tag, __use_alloc<_Head>(__a)) { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-      const _Head& __head)
- : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
-
-      template<typename _Alloc, typename _UHead>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _UHead&& __head)
- : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
-         std::forward<_UHead>(__head)) { }
-
-      template<typename _Alloc>
-        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             const _Tuple_impl& __in)
- : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
-
-      template<typename _Alloc>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _Tuple_impl&& __in)
- : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-         std::forward<_Head>(_M_head(__in))) { }
-
-      template<typename _Alloc, typename _UHead>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             const _Tuple_impl<_Idx, _UHead>& __in)
- : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
-
-      template<typename _Alloc, typename _UHead>
- _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-             _Tuple_impl<_Idx, _UHead>&& __in)
- : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
-                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
- { }
-
-      _Tuple_impl&
-      operator=(const _Tuple_impl& __in)
-      {
- _M_head(*this) = _M_head(__in);
- return *this;
-      }
-
-      _Tuple_impl&
-      operator=(_Tuple_impl&& __in)
-      noexcept(is_nothrow_move_assignable<_Head>::value)
-      {
- _M_head(*this) = std::forward<_Head>(_M_head(__in));
- return *this;
-      }
-
-      template<typename _UHead>
-        _Tuple_impl&
-        operator=(const _Tuple_impl<_Idx, _UHead>& __in)
-        {
-   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
-   return *this;
- }
-
-      template<typename _UHead>
-        _Tuple_impl&
-        operator=(_Tuple_impl<_Idx, _UHead>&& __in)
-        {
-   _M_head(*this)
-     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
-   return *this;
- }
-
-    protected:
-      void
-      _M_swap(_Tuple_impl& __in)
-      noexcept(__is_nothrow_swappable<_Head>::value)
-      {
- using std::swap;
- swap(_M_head(*this), _M_head(__in));
-      }
-    };
-
-  template<typename... _Elements>
-    class tuple;
-
-
-
-  template<bool, typename... _Elements>
-  struct _TC
-  {
-    template<typename... _UElements>
-    static constexpr bool _ConstructibleTuple()
-    {
-      return __and_<is_constructible<_Elements, const _UElements&>...>::value;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _ImplicitlyConvertibleTuple()
-    {
-      return __and_<is_convertible<const _UElements&, _Elements>...>::value;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _MoveConstructibleTuple()
-    {
-      return __and_<is_constructible<_Elements, _UElements&&>...>::value;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _ImplicitlyMoveConvertibleTuple()
-    {
-      return __and_<is_convertible<_UElements&&, _Elements>...>::value;
-    }
-
-    template<typename _SrcTuple>
-    static constexpr bool _NonNestedTuple()
-    {
-      return __and_<__not_<is_same<tuple<_Elements...>,
-                                   typename remove_cv<
-                                     typename remove_reference<_SrcTuple>::type
-                                   >::type>>,
-                     __not_<is_convertible<_SrcTuple, _Elements...>>,
-                     __not_<is_constructible<_Elements..., _SrcTuple>>
-              >::value;
-    }
-    template<typename... _UElements>
-    static constexpr bool _NotSameTuple()
-    {
-      return __not_<is_same<tuple<_Elements...>,
-        typename remove_const<
-          typename remove_reference<_UElements...>::type
-          >::type>>::value;
-    }
-  };
-
-  template<typename... _Elements>
-  struct _TC<false, _Elements...>
-  {
-    template<typename... _UElements>
-    static constexpr bool _ConstructibleTuple()
-    {
-      return false;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _ImplicitlyConvertibleTuple()
-    {
-      return false;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _MoveConstructibleTuple()
-    {
-      return false;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _ImplicitlyMoveConvertibleTuple()
-    {
-      return false;
-    }
-
-    template<typename... _UElements>
-    static constexpr bool _NonNestedTuple()
-    {
-      return true;
-    }
-    template<typename... _UElements>
-    static constexpr bool _NotSameTuple()
-    {
-      return true;
-    }
-  };
-
-
-  template<typename... _Elements>
-    class tuple : public _Tuple_impl<0, _Elements...>
-    {
-      typedef _Tuple_impl<0, _Elements...> _Inherited;
-
-
-
-      template<typename _Dummy>
-      struct _TC2
-      {
-        static constexpr bool _DefaultConstructibleTuple()
-        {
-          return __and_<is_default_constructible<_Elements>...>::value;
-        }
-        static constexpr bool _ImplicitlyDefaultConstructibleTuple()
-        {
-          return __and_<__is_implicitly_default_constructible<_Elements>...>
-            ::value;
-        }
-      };
-
-    public:
-      template<typename _Dummy = void,
-               typename enable_if<_TC2<_Dummy>::
-                                    _ImplicitlyDefaultConstructibleTuple(),
-                                  bool>::type = true>
-      constexpr tuple()
-      : _Inherited() { }
-
-      template<typename _Dummy = void,
-               typename enable_if<_TC2<_Dummy>::
-                                    _DefaultConstructibleTuple()
-                                  &&
-                                  !_TC2<_Dummy>::
-                                    _ImplicitlyDefaultConstructibleTuple(),
-                                  bool>::type = false>
-      explicit constexpr tuple()
-      : _Inherited() { }
-
-
-
-      template<typename _Dummy> using _TCC =
-        _TC<is_same<_Dummy, void>::value,
-            _Elements...>;
-
-      template<typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_Elements...>()
-                 && _TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_Elements...>()
-                 && (sizeof...(_Elements) >= 1),
-               bool>::type=true>
-        constexpr tuple(const _Elements&... __elements)
-      : _Inherited(__elements...) { }
-
-      template<typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_Elements...>()
-                 && !_TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_Elements...>()
-                 && (sizeof...(_Elements) >= 1),
-               bool>::type=false>
-      explicit constexpr tuple(const _Elements&... __elements)
-      : _Inherited(__elements...) { }
-
-
-
-      template<typename... _UElements> using _TMC =
-                  _TC<(sizeof...(_Elements) == sizeof...(_UElements)),
-                      _Elements...>;
-
-      template<typename... _UElements, typename
-        enable_if<
-    _TC<sizeof...(_UElements) == 1, _Elements...>::template
-      _NotSameTuple<_UElements...>()
-    && _TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
-                  && (sizeof...(_Elements) >= 1),
-        bool>::type=true>
-        constexpr tuple(_UElements&&... __elements)
-        : _Inherited(std::forward<_UElements>(__elements)...) { }
-
-      template<typename... _UElements, typename
-        enable_if<
-    _TC<sizeof...(_UElements) == 1, _Elements...>::template
-      _NotSameTuple<_UElements...>()
-    && _TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
-                  && (sizeof...(_Elements) >= 1),
-        bool>::type=false>
-        explicit constexpr tuple(_UElements&&... __elements)
- : _Inherited(std::forward<_UElements>(__elements)...) { }
-
-      constexpr tuple(const tuple&) = default;
-
-      constexpr tuple(tuple&&) = default;
-
-
-
-      template<typename _Dummy> using _TNTC =
-        _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
-            _Elements...>;
-
-      template<typename... _UElements, typename _Dummy = void, typename
-        enable_if<_TMC<_UElements...>::template
-                    _ConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyConvertibleTuple<_UElements...>()
-                  && _TNTC<_Dummy>::template
-                    _NonNestedTuple<const tuple<_UElements...>&>(),
-        bool>::type=true>
-        constexpr tuple(const tuple<_UElements...>& __in)
-        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
-        { }
-
-      template<typename... _UElements, typename _Dummy = void, typename
-        enable_if<_TMC<_UElements...>::template
-                    _ConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyConvertibleTuple<_UElements...>()
-                  && _TNTC<_Dummy>::template
-                    _NonNestedTuple<const tuple<_UElements...>&>(),
-        bool>::type=false>
-        explicit constexpr tuple(const tuple<_UElements...>& __in)
-        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
-        { }
-
-      template<typename... _UElements, typename _Dummy = void, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
-                  && _TNTC<_Dummy>::template
-                    _NonNestedTuple<tuple<_UElements...>&&>(),
-        bool>::type=true>
-        constexpr tuple(tuple<_UElements...>&& __in)
-        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
-
-      template<typename... _UElements, typename _Dummy = void, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
-                  && _TNTC<_Dummy>::template
-                    _NonNestedTuple<tuple<_UElements...>&&>(),
-        bool>::type=false>
-        explicit constexpr tuple(tuple<_UElements...>&& __in)
-        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
-
-
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a)
- : _Inherited(__tag, __a) { }
-
-      template<typename _Alloc, typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_Elements...>()
-                 && _TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_Elements...>(),
-               bool>::type=true>
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const _Elements&... __elements)
- : _Inherited(__tag, __a, __elements...) { }
-
-      template<typename _Alloc, typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_Elements...>()
-                 && !_TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_Elements...>(),
-               bool>::type=false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-                       const _Elements&... __elements)
- : _Inherited(__tag, __a, __elements...) { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
-        bool>::type=true>
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       _UElements&&... __elements)
- : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
-        { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
-        bool>::type=false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       _UElements&&... __elements)
- : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
-        { }
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
- : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
- : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _ConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyConvertibleTuple<_UElements...>(),
-        bool>::type=true>
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const tuple<_UElements...>& __in)
- : _Inherited(__tag, __a,
-              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
- { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _ConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyConvertibleTuple<_UElements...>(),
-        bool>::type=false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const tuple<_UElements...>& __in)
- : _Inherited(__tag, __a,
-              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
- { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && _TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
-        bool>::type=true>
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       tuple<_UElements...>&& __in)
- : _Inherited(__tag, __a,
-              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
- { }
-
-      template<typename _Alloc, typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
-                    _MoveConstructibleTuple<_UElements...>()
-                  && !_TMC<_UElements...>::template
-                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
-        bool>::type=false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       tuple<_UElements...>&& __in)
- : _Inherited(__tag, __a,
-              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
- { }
-
-      tuple&
-      operator=(const tuple& __in)
-      {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
-      }
-
-      tuple&
-      operator=(tuple&& __in)
-      noexcept(is_nothrow_move_assignable<_Inherited>::value)
-      {
- static_cast<_Inherited&>(*this) = std::move(__in);
- return *this;
-      }
-
-      template<typename... _UElements, typename = typename
-        enable_if<sizeof...(_UElements)
-    == sizeof...(_Elements)>::type>
-        tuple&
-        operator=(const tuple<_UElements...>& __in)
-        {
-   static_cast<_Inherited&>(*this) = __in;
-   return *this;
- }
-
-      template<typename... _UElements, typename = typename
-        enable_if<sizeof...(_UElements)
-    == sizeof...(_Elements)>::type>
-        tuple&
-        operator=(tuple<_UElements...>&& __in)
-        {
-   static_cast<_Inherited&>(*this) = std::move(__in);
-   return *this;
- }
-
-      void
-      swap(tuple& __in)
-      noexcept(noexcept(__in._M_swap(__in)))
-      { _Inherited::_M_swap(__in); }
-    };
-
-
-  template<>
-    class tuple<>
-    {
-    public:
-      void swap(tuple&) noexcept { }
-    };
-
-
-
-  template<typename _T1, typename _T2>
-    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
-    {
-      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
-
-    public:
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<__and_<
-                                     __is_implicitly_default_constructible<_U1>,
-                                     __is_implicitly_default_constructible<_U2>>
-                                   ::value, bool>::type = true>
-
-      constexpr tuple()
-      : _Inherited() { }
-
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<
-                  __and_<
-                    is_default_constructible<_U1>,
-                    is_default_constructible<_U2>,
-                    __not_<
-                      __and_<__is_implicitly_default_constructible<_U1>,
-                             __is_implicitly_default_constructible<_U2>>>>
-                  ::value, bool>::type = false>
-
-      explicit constexpr tuple()
-      : _Inherited() { }
-
-
-
-      template<typename _Dummy> using _TCC =
-        _TC<is_same<_Dummy, void>::value, _T1, _T2>;
-
-      template<typename _Dummy = void, typename
-               enable_if<_TCC<_Dummy>::template
-                           _ConstructibleTuple<_T1, _T2>()
-                         && _TCC<_Dummy>::template
-                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
- bool>::type = true>
-        constexpr tuple(const _T1& __a1, const _T2& __a2)
-        : _Inherited(__a1, __a2) { }
-
-      template<typename _Dummy = void, typename
-               enable_if<_TCC<_Dummy>::template
-                           _ConstructibleTuple<_T1, _T2>()
-                         && !_TCC<_Dummy>::template
-                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
- bool>::type = false>
-        explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
-        : _Inherited(__a1, __a2) { }
-
-
-
-      using _TMC = _TC<true, _T1, _T2>;
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        constexpr tuple(_U1&& __a1, _U2&& __a2)
- : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
- : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
-
-      constexpr tuple(const tuple&) = default;
-
-      constexpr tuple(tuple&&) = default;
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        constexpr tuple(const tuple<_U1, _U2>& __in)
- : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit constexpr tuple(const tuple<_U1, _U2>& __in)
- : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        constexpr tuple(tuple<_U1, _U2>&& __in)
- : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit constexpr tuple(tuple<_U1, _U2>&& __in)
- : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        constexpr tuple(const pair<_U1, _U2>& __in)
- : _Inherited(__in.first, __in.second) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit constexpr tuple(const pair<_U1, _U2>& __in)
- : _Inherited(__in.first, __in.second) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        constexpr tuple(pair<_U1, _U2>&& __in)
- : _Inherited(std::forward<_U1>(__in.first),
-       std::forward<_U2>(__in.second)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit constexpr tuple(pair<_U1, _U2>&& __in)
- : _Inherited(std::forward<_U1>(__in.first),
-       std::forward<_U2>(__in.second)) { }
-
-
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a)
- : _Inherited(__tag, __a) { }
-
-      template<typename _Alloc, typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_T1, _T2>()
-                 && _TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
-               bool>::type=true>
-
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const _T1& __a1, const _T2& __a2)
- : _Inherited(__tag, __a, __a1, __a2) { }
-
-      template<typename _Alloc, typename _Dummy = void,
-               typename enable_if<
-                 _TCC<_Dummy>::template
-                   _ConstructibleTuple<_T1, _T2>()
-                 && !_TCC<_Dummy>::template
-                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
-               bool>::type=false>
-
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const _T1& __a1, const _T2& __a2)
- : _Inherited(__tag, __a, __a1, __a2) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
- tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
- : _Inherited(__tag, __a, std::forward<_U1>(__a1),
-              std::forward<_U2>(__a2)) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-                       _U1&& __a1, _U2&& __a2)
- : _Inherited(__tag, __a, std::forward<_U1>(__a1),
-              std::forward<_U2>(__a2)) { }
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
- : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
-
-      template<typename _Alloc>
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
- : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
- tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const tuple<_U1, _U2>& __in)
- : _Inherited(__tag, __a,
-              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
- { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const tuple<_U1, _U2>& __in)
- : _Inherited(__tag, __a,
-              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
- { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
- { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
- explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-                       tuple<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
- { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const pair<_U1, _U2>& __in)
- : _Inherited(__tag, __a, __in.first, __in.second) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _ConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-       const pair<_U1, _U2>& __in)
- : _Inherited(__tag, __a, __in.first, __in.second) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && _TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = true>
-        tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
-       std::forward<_U2>(__in.second)) { }
-
-      template<typename _Alloc, typename _U1, typename _U2, typename
-        enable_if<_TMC::template
-                    _MoveConstructibleTuple<_U1, _U2>()
-                  && !_TMC::template
-                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
- bool>::type = false>
-        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
-                       pair<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
-       std::forward<_U2>(__in.second)) { }
-
-      tuple&
-      operator=(const tuple& __in)
-      {
- static_cast<_Inherited&>(*this) = __in;
- return *this;
-      }
-
-      tuple&
-      operator=(tuple&& __in)
-      noexcept(is_nothrow_move_assignable<_Inherited>::value)
-      {
- static_cast<_Inherited&>(*this) = std::move(__in);
- return *this;
-      }
-
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(const tuple<_U1, _U2>& __in)
-        {
-   static_cast<_Inherited&>(*this) = __in;
-   return *this;
- }
-
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(tuple<_U1, _U2>&& __in)
-        {
-   static_cast<_Inherited&>(*this) = std::move(__in);
-   return *this;
- }
-
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(const pair<_U1, _U2>& __in)
-        {
-   this->_M_head(*this) = __in.first;
-   this->_M_tail(*this)._M_head(*this) = __in.second;
-   return *this;
- }
-
-      template<typename _U1, typename _U2>
-        tuple&
-        operator=(pair<_U1, _U2>&& __in)
-        {
-   this->_M_head(*this) = std::forward<_U1>(__in.first);
-   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
-   return *this;
- }
-
-      void
-      swap(tuple& __in)
-      noexcept(noexcept(__in._M_swap(__in)))
-      { _Inherited::_M_swap(__in); }
-    };
-
-
-
-
-
-
-  template<std::size_t __i, typename _Head, typename... _Tail>
-    struct tuple_element<__i, tuple<_Head, _Tail...> >
-    : tuple_element<__i - 1, tuple<_Tail...> > { };
-
-
-
-
-  template<typename _Head, typename... _Tail>
-    struct tuple_element<0, tuple<_Head, _Tail...> >
-    {
-      typedef _Head type;
-    };
-
-
-  template<typename... _Elements>
-    struct tuple_size<tuple<_Elements...>>
-    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
-
-  template<std::size_t __i, typename _Head, typename... _Tail>
-    constexpr _Head&
-    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
-    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
-
-  template<std::size_t __i, typename _Head, typename... _Tail>
-    constexpr const _Head&
-    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
-    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
-
-
-  template<std::size_t __i, typename... _Elements>
-    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
-    get(tuple<_Elements...>& __t) noexcept
-    { return std::__get_helper<__i>(__t); }
-
-
-  template<std::size_t __i, typename... _Elements>
-    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
-    get(const tuple<_Elements...>& __t) noexcept
-    { return std::__get_helper<__i>(__t); }
-
-
-  template<std::size_t __i, typename... _Elements>
-    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
-    get(tuple<_Elements...>&& __t) noexcept
-    {
-      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
-      return std::forward<__element_type&&>(std::get<__i>(__t));
-    }
-
-
-
-
-
-  template<typename _Head, size_t __i, typename... _Tail>
-    constexpr _Head&
-    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
-    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
-
-  template<typename _Head, size_t __i, typename... _Tail>
-    constexpr const _Head&
-    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
-    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
-
-
-  template <typename _Tp, typename... _Types>
-    constexpr _Tp&
-    get(tuple<_Types...>& __t) noexcept
-    { return std::__get_helper2<_Tp>(__t); }
-
-
-  template <typename _Tp, typename... _Types>
-    constexpr _Tp&&
-    get(tuple<_Types...>&& __t) noexcept
-    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
-
-
-  template <typename _Tp, typename... _Types>
-    constexpr const _Tp&
-    get(const tuple<_Types...>& __t) noexcept
-    { return std::__get_helper2<_Tp>(__t); }
-
-
-
-  template<typename _Tp, typename _Up, size_t __i, size_t __size>
-    struct __tuple_compare
-    {
-      static constexpr bool
-      __eq(const _Tp& __t, const _Up& __u)
-      {
- return bool(std::get<__i>(__t) == std::get<__i>(__u))
-   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
-      }
-
-      static constexpr bool
-      __less(const _Tp& __t, const _Up& __u)
-      {
- return bool(std::get<__i>(__t) < std::get<__i>(__u))
-   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
-       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
-      }
-    };
-
-  template<typename _Tp, typename _Up, size_t __size>
-    struct __tuple_compare<_Tp, _Up, __size, __size>
-    {
-      static constexpr bool
-      __eq(const _Tp&, const _Up&) { return true; }
-
-      static constexpr bool
-      __less(const _Tp&, const _Up&) { return false; }
-    };
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator==(const tuple<_TElements...>& __t,
-        const tuple<_UElements...>& __u)
-    {
-      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
-   "tuple objects can only be compared if they have equal sizes.");
-      using __compare = __tuple_compare<tuple<_TElements...>,
-     tuple<_UElements...>,
-     0, sizeof...(_TElements)>;
-      return __compare::__eq(__t, __u);
-    }
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator<(const tuple<_TElements...>& __t,
-       const tuple<_UElements...>& __u)
-    {
-      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
-   "tuple objects can only be compared if they have equal sizes.");
-      using __compare = __tuple_compare<tuple<_TElements...>,
-     tuple<_UElements...>,
-     0, sizeof...(_TElements)>;
-      return __compare::__less(__t, __u);
-    }
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator!=(const tuple<_TElements...>& __t,
-        const tuple<_UElements...>& __u)
-    { return !(__t == __u); }
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator>(const tuple<_TElements...>& __t,
-       const tuple<_UElements...>& __u)
-    { return __u < __t; }
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator<=(const tuple<_TElements...>& __t,
-        const tuple<_UElements...>& __u)
-    { return !(__u < __t); }
-
-  template<typename... _TElements, typename... _UElements>
-    constexpr bool
-    operator>=(const tuple<_TElements...>& __t,
-        const tuple<_UElements...>& __u)
-    { return !(__t < __u); }
-
-
-  template<typename... _Elements>
-    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
-    make_tuple(_Elements&&... __args)
-    {
-      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
- __result_type;
-      return __result_type(std::forward<_Elements>(__args)...);
-    }
-
-
-
-  template<typename... _Elements>
-    constexpr tuple<_Elements&&...>
-    forward_as_tuple(_Elements&&... __args) noexcept
-    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
-
-  template<typename... _Tps>
-    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_tuple_like
-    : public __is_tuple_like_impl<typename std::remove_cv
-            <typename std::remove_reference<_Tp>::type>::type>::type
-    { };
-
-  template<size_t, typename, typename, size_t>
-    struct __make_tuple_impl;
-
-  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
-    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
-    : __make_tuple_impl<_Idx + 1,
-   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
-   _Tuple, _Nm>
-    { };
-
-  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
-    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
-    {
-      typedef tuple<_Tp...> __type;
-    };
-
-  template<typename _Tuple>
-    struct __do_make_tuple
-    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
-    { };
-
-
-  template<typename _Tuple>
-    struct __make_tuple
-    : public __do_make_tuple<typename std::remove_cv
-            <typename std::remove_reference<_Tuple>::type>::type>
-    { };
-
-
-  template<typename...>
-    struct __combine_tuples;
-
-  template<>
-    struct __combine_tuples<>
-    {
-      typedef tuple<> __type;
-    };
-
-  template<typename... _Ts>
-    struct __combine_tuples<tuple<_Ts...>>
-    {
-      typedef tuple<_Ts...> __type;
-    };
-
-  template<typename... _T1s, typename... _T2s, typename... _Rem>
-    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
-    {
-      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
-     _Rem...>::__type __type;
-    };
-
-
-  template<typename... _Tpls>
-    struct __tuple_cat_result
-    {
-      typedef typename __combine_tuples
-        <typename __make_tuple<_Tpls>::__type...>::__type __type;
-    };
-
-
-
-  template<typename...>
-    struct __make_1st_indices;
-
-  template<>
-    struct __make_1st_indices<>
-    {
-      typedef std::_Index_tuple<> __type;
-    };
-
-  template<typename _Tp, typename... _Tpls>
-    struct __make_1st_indices<_Tp, _Tpls...>
-    {
-      typedef typename std::_Build_index_tuple<std::tuple_size<
- typename std::remove_reference<_Tp>::type>::value>::__type __type;
-    };
-
-
-
-
-  template<typename _Ret, typename _Indices, typename... _Tpls>
-    struct __tuple_concater;
-
-  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
-    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
-    {
-      template<typename... _Us>
-        static constexpr _Ret
-        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
-        {
-   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
-   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
-   return __next::_S_do(std::forward<_Tpls>(__tps)...,
-          std::forward<_Us>(__us)...,
-          std::get<_Is>(std::forward<_Tp>(__tp))...);
- }
-    };
-
-  template<typename _Ret>
-    struct __tuple_concater<_Ret, std::_Index_tuple<>>
-    {
-      template<typename... _Us>
- static constexpr _Ret
- _S_do(_Us&&... __us)
-        {
-   return _Ret(std::forward<_Us>(__us)...);
- }
-    };
-
-
-  template<typename... _Tpls, typename = typename
-           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
-    constexpr auto
-    tuple_cat(_Tpls&&... __tpls)
-    -> typename __tuple_cat_result<_Tpls...>::__type
-    {
-      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
-      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
-      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
-      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
-    }
-
-
-
-
-  template<typename... _Elements>
-    constexpr tuple<_Elements&...>
-    tie(_Elements&... __args) noexcept
-    { return tuple<_Elements&...>(__args...); }
-
-
-  template<typename... _Elements>
-    inline void
-    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-
-  struct _Swallow_assign
-  {
-    template<class _Tp>
-      const _Swallow_assign&
-      operator=(const _Tp&) const
-      { return *this; }
-  };
-
-  const _Swallow_assign ignore{};
-
-
-  template<typename... _Types, typename _Alloc>
-    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
-
-
-  template<class _T1, class _T2>
-    template<typename... _Args1, typename... _Args2>
-      inline
-      pair<_T1, _T2>::
-      pair(piecewise_construct_t,
-    tuple<_Args1...> __first, tuple<_Args2...> __second)
-      : pair(__first, __second,
-      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
-      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
-      { }
-
-  template<class _T1, class _T2>
-    template<typename... _Args1, std::size_t... _Indexes1,
-             typename... _Args2, std::size_t... _Indexes2>
-      inline
-      pair<_T1, _T2>::
-      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
-    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
-      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
-        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
-      { }
-
-
-
-
-}
-# 56 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 2 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _MemberPointer>
-    class _Mem_fn;
-  template<typename _Tp, typename _Class>
-    _Mem_fn<_Tp _Class::*>
-    mem_fn(_Tp _Class::*) noexcept;
-
-
-  template<typename _Functor, typename = __void_t<>>
-    struct _Maybe_get_result_type
-    { };
-
-  template<typename _Functor>
-    struct _Maybe_get_result_type<_Functor,
-      __void_t<typename _Functor::result_type>>
-    { typedef typename _Functor::result_type result_type; };
-
-
-
-
-
-  template<typename _Functor>
-    struct _Weak_result_type_impl
-    : _Maybe_get_result_type<_Functor>
-    { };
-
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes......)>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
-    { typedef _Res result_type; };
-
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
-      const volatile>
-    { typedef _Res result_type; };
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
-      const volatile>
-    { typedef _Res result_type; };
-
-
-
-
-
-  template<typename _Functor>
-    struct _Weak_result_type
-    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
-    { };
-
-  template<typename _Tp, typename _Up = typename decay<_Tp>::type>
-    struct __inv_unwrap
-    {
-      using type = _Tp;
-    };
-
-  template<typename _Tp, typename _Up>
-    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
-    {
-      using type = _Up&;
-    };
-
-
-
-  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
-    inline _Up&&
-    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
-    { return static_cast<_Up&&>(__t); }
-
-  template<typename _Res, typename _Fn, typename... _Args>
-    inline _Res
-    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
-    noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...)))
-    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
-
-  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
-    inline _Res
-    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
-    _Args&&... __args)
-    noexcept(noexcept(
-   (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...)))
-    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
-
-  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
-    inline _Res
-    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
-    _Args&&... __args)
-    noexcept(noexcept(
-   ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...)))
-    {
-      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
-    }
-
-  template<typename _Res, typename _MemPtr, typename _Tp>
-    inline _Res
-    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
-    noexcept(noexcept(__invfwd<_Tp>(__t).*__f))
-    { return __invfwd<_Tp>(__t).*__f; }
-
-  template<typename _Res, typename _MemPtr, typename _Tp>
-    inline _Res
-    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
-    noexcept(noexcept((*std::forward<_Tp>(__t)).*__f))
-    { return (*std::forward<_Tp>(__t)).*__f; }
-
-
-  template<typename _Callable, typename... _Args>
-    inline typename result_of<_Callable&&(_Args&&...)>::type
-    __invoke(_Callable&& __fn, _Args&&... __args)
-    {
-      using __result_of = result_of<_Callable&&(_Args&&...)>;
-      using __type = typename __result_of::type;
-      using __tag = typename __result_of::__invoke_type;
-      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
-     std::forward<_Args>(__args)...);
-    }
-# 272 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<bool _Unary, bool _Binary, typename _Tp>
-    struct _Reference_wrapper_base_impl;
-
-
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, false, _Tp>
-    : _Weak_result_type<_Tp>
-    { };
-
-
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, false, _Tp>
-    : _Weak_result_type<_Tp>
-    {
-      typedef typename _Tp::argument_type argument_type;
-    };
-
-
-  template<typename _Tp>
-    struct _Reference_wrapper_base_impl<false, true, _Tp>
-    : _Weak_result_type<_Tp>
-    {
-      typedef typename _Tp::first_argument_type first_argument_type;
-      typedef typename _Tp::second_argument_type second_argument_type;
-    };
-
-
-   template<typename _Tp>
-    struct _Reference_wrapper_base_impl<true, true, _Tp>
-    : _Weak_result_type<_Tp>
-    {
-      typedef typename _Tp::argument_type argument_type;
-      typedef typename _Tp::first_argument_type first_argument_type;
-      typedef typename _Tp::second_argument_type second_argument_type;
-    };
-
-  template<typename _Tp, typename = __void_t<>> struct __has_argument_type : false_type { }; template<typename _Tp> struct __has_argument_type<_Tp, __void_t<typename _Tp::argument_type>> : true_type { };
-  template<typename _Tp, typename = __void_t<>> struct __has_first_argument_type : false_type { }; template<typename _Tp> struct __has_first_argument_type<_Tp, __void_t<typename _Tp::first_argument_type>> : true_type { };
-  template<typename _Tp, typename = __void_t<>> struct __has_second_argument_type : false_type { }; template<typename _Tp> struct __has_second_argument_type<_Tp, __void_t<typename _Tp::second_argument_type>> : true_type { };
-
-
-
-
-
-
-
-  template<typename _Tp>
-    struct _Reference_wrapper_base
-    : _Reference_wrapper_base_impl<
-      __has_argument_type<_Tp>::value,
-      __has_first_argument_type<_Tp>::value
-      && __has_second_argument_type<_Tp>::value,
-      _Tp>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1) const>
-    : unary_function<_T1, _Res>
-    { };
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1) volatile>
-    : unary_function<_T1, _Res>
-    { };
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(_T1) const volatile>
-    : unary_function<_T1, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res(*)(_T1)>
-    : unary_function<_T1, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
-    : binary_function<_T1, _T2, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)()>
-    : unary_function<_T1*, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
-    : binary_function<_T1*, _T2, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const>
-    : unary_function<const _T1*, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
-    : binary_function<const _T1*, _T2, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
-    : unary_function<volatile _T1*, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
-    : binary_function<volatile _T1*, _T2, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
-    : unary_function<const volatile _T1*, _Res>
-    { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
-    : binary_function<const volatile _T1*, _T2, _Res>
-    { };
-
-
-
-
-
-
-  template<typename _Tp>
-    class reference_wrapper
-    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
-    {
-      _Tp* _M_data;
-
-    public:
-      typedef _Tp type;
-
-      reference_wrapper(_Tp& __indata) noexcept
-      : _M_data(std::__addressof(__indata))
-      { }
-
-      reference_wrapper(_Tp&&) = delete;
-
-      reference_wrapper(const reference_wrapper&) = default;
-
-      reference_wrapper&
-      operator=(const reference_wrapper&) = default;
-
-      operator _Tp&() const noexcept
-      { return this->get(); }
-
-      _Tp&
-      get() const noexcept
-      { return *_M_data; }
-
-      template<typename... _Args>
- typename result_of<_Tp&(_Args&&...)>::type
- operator()(_Args&&... __args) const
- {
-   return std::__invoke(get(), std::forward<_Args>(__args)...);
- }
-    };
-
-
-
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(_Tp& __t) noexcept
-    { return reference_wrapper<_Tp>(__t); }
-
-
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(const _Tp& __t) noexcept
-    { return reference_wrapper<const _Tp>(__t); }
-
-  template<typename _Tp>
-    void ref(const _Tp&&) = delete;
-
-  template<typename _Tp>
-    void cref(const _Tp&&) = delete;
-
-
-  template<typename _Tp>
-    inline reference_wrapper<_Tp>
-    ref(reference_wrapper<_Tp> __t) noexcept
-    { return ref(__t.get()); }
-
-
-  template<typename _Tp>
-    inline reference_wrapper<const _Tp>
-    cref(reference_wrapper<_Tp> __t) noexcept
-    { return cref(__t.get()); }
-
-
-
-  template<typename... _Types>
-    struct _Pack : integral_constant<size_t, sizeof...(_Types)>
-    { };
-
-  template<typename _From, typename _To, bool = _From::value == _To::value>
-    struct _AllConvertible : false_type
-    { };
-
-  template<typename... _From, typename... _To>
-    struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
-    : __and_<is_convertible<_From, _To>...>
-    { };
-
-  template<typename _Tp1, typename _Tp2>
-    using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
-        typename std::decay<_Tp2>::type>>;
-
-
-
-
-
-
-  template<typename _Res, typename... _ArgTypes>
-    struct _Maybe_unary_or_binary_function { };
-
-
-  template<typename _Res, typename _T1>
-    struct _Maybe_unary_or_binary_function<_Res, _T1>
-    : std::unary_function<_T1, _Res> { };
-
-
-  template<typename _Res, typename _T1, typename _T2>
-    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
-    : std::binary_function<_T1, _T2, _Res> { };
-
-  template<typename _Signature>
-    struct _Mem_fn_traits;
-
-  template<typename _Res, typename _Class, typename... _ArgTypes>
-    struct _Mem_fn_traits_base
-    {
-      using __result_type = _Res;
-      using __maybe_type
- = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
-      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
-    };
-# 569 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
-template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
-template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
-
-
-
-
-  template<typename _MemFunPtr,
-    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
-    class _Mem_fn_base
-    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
-    {
-      using _Traits = _Mem_fn_traits<_MemFunPtr>;
-
-      using _Arity = typename _Traits::__arity;
-      using _Varargs = typename _Traits::__vararg;
-
-      template<typename _Func, typename... _BoundArgs>
- friend struct _Bind_check_arity;
-
-      _MemFunPtr _M_pmf;
-
-    public:
-
-      using result_type = typename _Traits::__result_type;
-
-      explicit constexpr
-      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
-
-      template<typename... _Args>
- auto
- operator()(_Args&&... __args) const
- noexcept(noexcept(
-       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
- -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
- { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
-    };
-
-
-  template<typename _MemObjPtr>
-    class _Mem_fn_base<_MemObjPtr, false>
-    {
-      using _Arity = integral_constant<size_t, 0>;
-      using _Varargs = false_type;
-
-      template<typename _Func, typename... _BoundArgs>
- friend struct _Bind_check_arity;
-
-      _MemObjPtr _M_pm;
-
-    public:
-      explicit constexpr
-      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
-
-      template<typename _Tp>
- auto
- operator()(_Tp&& __obj) const
- noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
- -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
- { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
-    };
-
-  template<typename _Res, typename _Class>
-    struct _Mem_fn<_Res _Class::*>
-    : _Mem_fn_base<_Res _Class::*>
-    {
-      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
-    };
-# 645 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Tp, typename _Class>
-    inline _Mem_fn<_Tp _Class::*>
-    mem_fn(_Tp _Class::* __pm) noexcept
-    {
-      return _Mem_fn<_Tp _Class::*>(__pm);
-    }
-# 660 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Tp>
-    struct is_bind_expression
-    : public false_type { };
-# 671 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Tp>
-    struct is_placeholder
-    : public integral_constant<int, 0>
-    { };
-
-
-
-
-  template<int _Num> struct _Placeholder { };
-
-
-
-
-
-
-
-  namespace placeholders
-  {
-
-
-
-
-
-    extern const _Placeholder<1> _1;
-    extern const _Placeholder<2> _2;
-    extern const _Placeholder<3> _3;
-    extern const _Placeholder<4> _4;
-    extern const _Placeholder<5> _5;
-    extern const _Placeholder<6> _6;
-    extern const _Placeholder<7> _7;
-    extern const _Placeholder<8> _8;
-    extern const _Placeholder<9> _9;
-    extern const _Placeholder<10> _10;
-    extern const _Placeholder<11> _11;
-    extern const _Placeholder<12> _12;
-    extern const _Placeholder<13> _13;
-    extern const _Placeholder<14> _14;
-    extern const _Placeholder<15> _15;
-    extern const _Placeholder<16> _16;
-    extern const _Placeholder<17> _17;
-    extern const _Placeholder<18> _18;
-    extern const _Placeholder<19> _19;
-    extern const _Placeholder<20> _20;
-    extern const _Placeholder<21> _21;
-    extern const _Placeholder<22> _22;
-    extern const _Placeholder<23> _23;
-    extern const _Placeholder<24> _24;
-    extern const _Placeholder<25> _25;
-    extern const _Placeholder<26> _26;
-    extern const _Placeholder<27> _27;
-    extern const _Placeholder<28> _28;
-    extern const _Placeholder<29> _29;
-
-  }
-# 733 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<int _Num>
-    struct is_placeholder<_Placeholder<_Num> >
-    : public integral_constant<int, _Num>
-    { };
-
-  template<int _Num>
-    struct is_placeholder<const _Placeholder<_Num> >
-    : public integral_constant<int, _Num>
-    { };
-
-
-
- template<std::size_t __i, typename _Tuple>
-   using _Safe_tuple_element_t
-     = typename enable_if<(__i < tuple_size<_Tuple>::value),
-     tuple_element<__i, _Tuple>>::type::type;
-# 761 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Arg,
-    bool _IsBindExp = is_bind_expression<_Arg>::value,
-    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
-    class _Mu;
-
-
-
-
-
-
-  template<typename _Tp>
-    class _Mu<reference_wrapper<_Tp>, false, false>
-    {
-    public:
-
-
-
-
-      template<typename _CVRef, typename _Tuple>
- _Tp&
- operator()(_CVRef& __arg, _Tuple&) const volatile
- { return __arg.get(); }
-    };
-
-
-
-
-
-
-
-  template<typename _Arg>
-    class _Mu<_Arg, true, false>
-    {
-    public:
-      template<typename _CVArg, typename... _Args>
- auto
- operator()(_CVArg& __arg,
-     tuple<_Args...>& __tuple) const volatile
- -> decltype(__arg(declval<_Args>()...))
- {
-
-   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
-     _Indexes;
-   return this->__call(__arg, __tuple, _Indexes());
- }
-
-    private:
-
-
-      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
- auto
- __call(_CVArg& __arg, tuple<_Args...>& __tuple,
-        const _Index_tuple<_Indexes...>&) const volatile
- -> decltype(__arg(declval<_Args>()...))
- {
-   return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
- }
-    };
-
-
-
-
-
-
-  template<typename _Arg>
-    class _Mu<_Arg, false, true>
-    {
-    public:
-      template<typename _Tuple>
- _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
- operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
- {
-   using __type
-     = __tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>;
-   return std::forward<__type>(
-       ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
- }
-    };
-
-
-
-
-
-
-  template<typename _Arg>
-    class _Mu<_Arg, false, false>
-    {
-    public:
-      template<typename _CVArg, typename _Tuple>
- _CVArg&&
- operator()(_CVArg&& __arg, _Tuple&) const volatile
- { return std::forward<_CVArg>(__arg); }
-    };
-
-
-
-
-
-
-  template<typename _Tp>
-    struct _Maybe_wrap_member_pointer
-    {
-      typedef _Tp type;
-
-      static constexpr const _Tp&
-      __do_wrap(const _Tp& __x)
-      { return __x; }
-
-      static constexpr _Tp&&
-      __do_wrap(_Tp&& __x)
-      { return static_cast<_Tp&&>(__x); }
-    };
-
-
-
-
-
-
-  template<typename _Tp, typename _Class>
-    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
-    {
-      typedef _Mem_fn<_Tp _Class::*> type;
-
-      static constexpr type
-      __do_wrap(_Tp _Class::* __pm)
-      { return type(__pm); }
-    };
-
-
-
-
-
-  template<>
-    struct _Maybe_wrap_member_pointer<void>
-    {
-      typedef void type;
-    };
-
-
-  template<std::size_t _Ind, typename... _Tp>
-    inline auto
-    __volget(volatile tuple<_Tp...>& __tuple)
-    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
-    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
-
-
-  template<std::size_t _Ind, typename... _Tp>
-    inline auto
-    __volget(const volatile tuple<_Tp...>& __tuple)
-    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
-    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
-
-
-  template<typename _Signature>
-    struct _Bind;
-
-   template<typename _Functor, typename... _Bound_args>
-    class _Bind<_Functor(_Bound_args...)>
-    : public _Weak_result_type<_Functor>
-    {
-      typedef _Bind __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-
-      template<typename _Result, typename... _Args, std::size_t... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
- {
-   return _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Result, typename... _Args, std::size_t... _Indexes>
- _Result
- __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
- {
-   return _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Result, typename... _Args, std::size_t... _Indexes>
- _Result
- __call_v(tuple<_Args...>&& __args,
-   _Index_tuple<_Indexes...>) volatile
- {
-   return _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Result, typename... _Args, std::size_t... _Indexes>
- _Result
- __call_c_v(tuple<_Args...>&& __args,
-     _Index_tuple<_Indexes...>) const volatile
- {
-   return _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-     public:
-      template<typename... _Args>
- explicit _Bind(const _Functor& __f, _Args&&... __args)
- : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
- { }
-
-      template<typename... _Args>
- explicit _Bind(_Functor&& __f, _Args&&... __args)
- : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
- { }
-
-      _Bind(const _Bind&) = default;
-
-      _Bind(_Bind&& __b)
-      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
-      { }
-
-
-      template<typename... _Args, typename _Result
- = decltype( std::declval<_Functor&>()(
-       _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
-      std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args)
- {
-   return this->__call<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args, typename _Result
- = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
-         typename add_const<_Functor>::type&>::type>()(
-       _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
-      std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) const
- {
-   return this->__call_c<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args, typename _Result
- = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
-                       typename add_volatile<_Functor>::type&>::type>()(
-       _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
-      std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) volatile
- {
-   return this->__call_v<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args, typename _Result
- = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
-                       typename add_cv<_Functor>::type&>::type>()(
-       _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
-      std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) const volatile
- {
-   return this->__call_c_v<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-    };
-
-
-  template<typename _Result, typename _Signature>
-    struct _Bind_result;
-
-  template<typename _Result, typename _Functor, typename... _Bound_args>
-    class _Bind_result<_Result, _Functor(_Bound_args...)>
-    {
-      typedef _Bind_result __self_type;
-      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
-
-      _Functor _M_f;
-      tuple<_Bound_args...> _M_bound_args;
-
-
-      template<typename _Res>
- struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
-      template<typename _Res>
- struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __disable_if_void<_Res>::type = 0)
- {
-   return _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __enable_if_void<_Res>::type = 0)
- {
-   _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __disable_if_void<_Res>::type = 0) const
- {
-   return _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __enable_if_void<_Res>::type = 0) const
- {
-   _M_f(_Mu<_Bound_args>()
-        (std::get<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __disable_if_void<_Res>::type = 0) volatile
- {
-   return _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __enable_if_void<_Res>::type = 0) volatile
- {
-   _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
-     typename __disable_if_void<_Res>::type = 0) const volatile
- {
-   return _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-
-      template<typename _Res, typename... _Args, std::size_t... _Indexes>
- void
- __call(tuple<_Args...>&& __args,
-        _Index_tuple<_Indexes...>,
-     typename __enable_if_void<_Res>::type = 0) const volatile
- {
-   _M_f(_Mu<_Bound_args>()
-        (__volget<_Indexes>(_M_bound_args), __args)...);
- }
-
-    public:
-      typedef _Result result_type;
-
-      template<typename... _Args>
- explicit _Bind_result(const _Functor& __f, _Args&&... __args)
- : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
- { }
-
-      template<typename... _Args>
- explicit _Bind_result(_Functor&& __f, _Args&&... __args)
- : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
- { }
-
-      _Bind_result(const _Bind_result&) = default;
-
-      _Bind_result(_Bind_result&& __b)
-      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
-      { }
-
-
-      template<typename... _Args>
- result_type
- operator()(_Args&&... __args)
- {
-   return this->__call<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args>
- result_type
- operator()(_Args&&... __args) const
- {
-   return this->__call<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args>
- result_type
- operator()(_Args&&... __args) volatile
- {
-   return this->__call<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-
-
-      template<typename... _Args>
- result_type
- operator()(_Args&&... __args) const volatile
- {
-   return this->__call<_Result>(
-       std::forward_as_tuple(std::forward<_Args>(__args)...),
-       _Bound_indexes());
- }
-    };
-
-
-
-
-
-  template<typename _Signature>
-    struct is_bind_expression<_Bind<_Signature> >
-    : public true_type { };
-
-
-
-
-
-  template<typename _Signature>
-    struct is_bind_expression<const _Bind<_Signature> >
-    : public true_type { };
-
-
-
-
-
-  template<typename _Signature>
-    struct is_bind_expression<volatile _Bind<_Signature> >
-    : public true_type { };
-
-
-
-
-
-  template<typename _Signature>
-    struct is_bind_expression<const volatile _Bind<_Signature>>
-    : public true_type { };
-
-
-
-
-
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<_Bind_result<_Result, _Signature>>
-    : public true_type { };
-
-
-
-
-
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
-    : public true_type { };
-
-
-
-
-
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
-    : public true_type { };
-
-
-
-
-
-  template<typename _Result, typename _Signature>
-    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
-    : public true_type { };
-
-  template<typename _Func, typename... _BoundArgs>
-    struct _Bind_check_arity { };
-
-  template<typename _Ret, typename... _Args, typename... _BoundArgs>
-    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
-    {
-      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
-                   "Wrong number of arguments for function");
-    };
-
-  template<typename _Ret, typename... _Args, typename... _BoundArgs>
-    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
-    {
-      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
-                   "Wrong number of arguments for function");
-    };
-
-  template<typename _Tp, typename _Class, typename... _BoundArgs>
-    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
-    {
-      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
-      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
-      static_assert(_Varargs::value
-      ? sizeof...(_BoundArgs) >= _Arity::value + 1
-      : sizeof...(_BoundArgs) == _Arity::value + 1,
-      "Wrong number of arguments for pointer-to-member");
-    };
-
-
-
-
-  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
-    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
-
-  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
-    struct _Bind_helper
-    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
-    {
-      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
- __maybe_type;
-      typedef typename __maybe_type::type __func_type;
-      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
-    };
-
-
-
-
-  template<typename _Func, typename... _BoundArgs>
-    struct _Bind_helper<true, _Func, _BoundArgs...>
-    { };
-
-
-
-
-
-  template<typename _Func, typename... _BoundArgs>
-    inline typename
-    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
-    bind(_Func&& __f, _BoundArgs&&... __args)
-    {
-      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
-      typedef typename __helper_type::__maybe_type __maybe_type;
-      typedef typename __helper_type::type __result_type;
-      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
-      std::forward<_BoundArgs>(__args)...);
-    }
-
-  template<typename _Result, typename _Func, typename... _BoundArgs>
-    struct _Bindres_helper
-    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
-    {
-      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
- __maybe_type;
-      typedef typename __maybe_type::type __functor_type;
-      typedef _Bind_result<_Result,
-      __functor_type(typename decay<_BoundArgs>::type...)>
- type;
-    };
-
-
-
-
-
-  template<typename _Result, typename _Func, typename... _BoundArgs>
-    inline
-    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
-    bind(_Func&& __f, _BoundArgs&&... __args)
-    {
-      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
-      typedef typename __helper_type::__maybe_type __maybe_type;
-      typedef typename __helper_type::type __result_type;
-      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
-      std::forward<_BoundArgs>(__args)...);
-    }
-
-  template<typename _Signature>
-    struct _Bind_simple;
-
-  template<typename _Callable, typename... _Args>
-    struct _Bind_simple<_Callable(_Args...)>
-    {
-      typedef typename result_of<_Callable(_Args...)>::type result_type;
-
-      template<typename _Tp, typename... _Up>
-        explicit
-        _Bind_simple(_Tp&& __f, _Up&&... __args)
-        : _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
-        { }
-
-      _Bind_simple(const _Bind_simple&) = default;
-      _Bind_simple(_Bind_simple&&) = default;
-
-      result_type
-      operator()()
-      {
-        typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
-        return _M_invoke(_Indices());
-      }
-
-    private:
-      template<std::size_t... _Indices>
-        typename result_of<_Callable(_Args...)>::type
-        _M_invoke(_Index_tuple<_Indices...>)
-        {
-
-
-          return std::forward<_Callable>(std::get<0>(_M_bound))(
-              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
-        }
-
-      std::tuple<_Callable, _Args...> _M_bound;
-    };
-
-  template<typename _Func, typename... _BoundArgs>
-    struct _Bind_simple_helper
-    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
-    {
-      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
-        __maybe_type;
-      typedef typename __maybe_type::type __func_type;
-      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
-        __type;
-    };
-
-
-
-  template<typename _Callable, typename... _Args>
-    typename _Bind_simple_helper<_Callable, _Args...>::__type
-    __bind_simple(_Callable&& __callable, _Args&&... __args)
-    {
-      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
-      typedef typename __helper_type::__maybe_type __maybe_type;
-      typedef typename __helper_type::__type __result_type;
-      return __result_type(
-          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
-          std::forward<_Args>(__args)...);
-    }
-
-
-
-
-
-
-  class bad_function_call : public std::exception
-  {
-  public:
-    virtual ~bad_function_call() noexcept;
-
-    const char* what() const noexcept;
-  };
-
-
-
-
-
-
-
-  template<typename _Tp>
-    struct __is_location_invariant
-    : is_trivially_copyable<_Tp>::type
-    { };
-
-  class _Undefined_class;
-
-  union _Nocopy_types
-  {
-    void* _M_object;
-    const void* _M_const_object;
-    void (*_M_function_pointer)();
-    void (_Undefined_class::*_M_member_pointer)();
-  };
-
-  union [[gnu::may_alias]] _Any_data
-  {
-    void* _M_access() { return &_M_pod_data[0]; }
-    const void* _M_access() const { return &_M_pod_data[0]; }
-
-    template<typename _Tp>
-      _Tp&
-      _M_access()
-      { return *static_cast<_Tp*>(_M_access()); }
-
-    template<typename _Tp>
-      const _Tp&
-      _M_access() const
-      { return *static_cast<const _Tp*>(_M_access()); }
-
-    _Nocopy_types _M_unused;
-    char _M_pod_data[sizeof(_Nocopy_types)];
-  };
-
-  enum _Manager_operation
-  {
-    __get_type_info,
-    __get_functor_ptr,
-    __clone_functor,
-    __destroy_functor
-  };
-
-
-
-  template<typename _Tp>
-    struct _Simple_type_wrapper
-    {
-      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
-
-      _Tp __value;
-    };
-
-  template<typename _Tp>
-    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
-    : __is_location_invariant<_Tp>
-    { };
-
-
-
-  template<typename _Functor>
-    inline _Functor&
-    __callable_functor(_Functor& __f)
-    { return __f; }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* &__p)
-    { return std::mem_fn(__p); }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* const &__p)
-    { return std::mem_fn(__p); }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* volatile &__p)
-    { return std::mem_fn(__p); }
-
-  template<typename _Member, typename _Class>
-    inline _Mem_fn<_Member _Class::*>
-    __callable_functor(_Member _Class::* const volatile &__p)
-    { return std::mem_fn(__p); }
-
-  template<typename _Signature>
-    class function;
-
-
-  class _Function_base
-  {
-  public:
-    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
-    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
-
-    template<typename _Functor>
-      class _Base_manager
-      {
-      protected:
- static const bool __stored_locally =
- (__is_location_invariant<_Functor>::value
-  && sizeof(_Functor) <= _M_max_size
-  && __alignof__(_Functor) <= _M_max_align
-  && (_M_max_align % __alignof__(_Functor) == 0));
-
- typedef integral_constant<bool, __stored_locally> _Local_storage;
-
-
- static _Functor*
- _M_get_pointer(const _Any_data& __source)
- {
-   const _Functor* __ptr =
-     __stored_locally? std::__addressof(__source._M_access<_Functor>())
-                                 : __source._M_access<_Functor*>();
-   return const_cast<_Functor*>(__ptr);
- }
-
-
-
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
- {
-   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
- }
-
-
-
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
- {
-   __dest._M_access<_Functor*>() =
-     new _Functor(*__source._M_access<_Functor*>());
- }
-
-
-
- static void
- _M_destroy(_Any_data& __victim, true_type)
- {
-   __victim._M_access<_Functor>().~_Functor();
- }
-
-
- static void
- _M_destroy(_Any_data& __victim, false_type)
- {
-   delete __victim._M_access<_Functor*>();
- }
-
-      public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
-     _Manager_operation __op)
- {
-   switch (__op)
-     {
-
-     case __get_type_info:
-       __dest._M_access<const type_info*>() = &typeid(_Functor);
-       break;
-
-     case __get_functor_ptr:
-       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
-       break;
-
-     case __clone_functor:
-       _M_clone(__dest, __source, _Local_storage());
-       break;
-
-     case __destroy_functor:
-       _M_destroy(__dest, _Local_storage());
-       break;
-     }
-   return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f)
- { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
-
- template<typename _Signature>
-   static bool
-   _M_not_empty_function(const function<_Signature>& __f)
-   { return static_cast<bool>(__f); }
-
- template<typename _Tp>
-   static bool
-   _M_not_empty_function(_Tp* __fp)
-   { return __fp != nullptr; }
-
- template<typename _Class, typename _Tp>
-   static bool
-   _M_not_empty_function(_Tp _Class::* __mp)
-   { return __mp != nullptr; }
-
- template<typename _Tp>
-   static bool
-   _M_not_empty_function(const _Tp&)
-   { return true; }
-
-      private:
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
- { ::new (__functor._M_access()) _Functor(std::move(__f)); }
-
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
- { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
-      };
-
-    template<typename _Functor>
-      class _Ref_manager : public _Base_manager<_Functor*>
-      {
- typedef _Function_base::_Base_manager<_Functor*> _Base;
-
-      public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
-     _Manager_operation __op)
- {
-   switch (__op)
-     {
-
-     case __get_type_info:
-       __dest._M_access<const type_info*>() = &typeid(_Functor);
-       break;
-
-     case __get_functor_ptr:
-       __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
-       return is_const<_Functor>::value;
-       break;
-
-     default:
-       _Base::_M_manager(__dest, __source, __op);
-     }
-   return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
- {
-   _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
- }
-      };
-
-    _Function_base() : _M_manager(nullptr) { }
-
-    ~_Function_base()
-    {
-      if (_M_manager)
- _M_manager(_M_functor, _M_functor, __destroy_functor);
-    }
-
-
-    bool _M_empty() const { return !_M_manager; }
-
-    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
-      _Manager_operation);
-
-    _Any_data _M_functor;
-    _Manager_type _M_manager;
-  };
-
-  template<typename _Signature, typename _Functor>
-    class _Function_handler;
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-    public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- return (*_Base::_M_get_pointer(__functor))(
-     std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Functor>
-    : public _Function_base::_Base_manager<_Functor>
-    {
-      typedef _Function_base::_Base_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- (*_Base::_M_get_pointer(__functor))(
-     std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _Res, typename _Functor, typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- return std::__callable_functor(**_Base::_M_get_pointer(__functor))(
-       std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _Functor, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
-    : public _Function_base::_Ref_manager<_Functor>
-    {
-      typedef _Function_base::_Ref_manager<_Functor> _Base;
-
-     public:
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- std::__callable_functor(**_Base::_M_get_pointer(__functor))(
-     std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename _Res,
-    typename... _ArgTypes>
-    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
-    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    {
-      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
- _Base;
-
-     public:
-      static _Res
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
-     std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _Class, typename _Member, typename... _ArgTypes>
-    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
-    : public _Function_base::_Base_manager<
-   _Simple_type_wrapper< _Member _Class::* > >
-    {
-      typedef _Member _Class::* _Functor;
-      typedef _Simple_type_wrapper<_Functor> _Wrapper;
-      typedef _Function_base::_Base_manager<_Wrapper> _Base;
-
-    public:
-      static bool
-      _M_manager(_Any_data& __dest, const _Any_data& __source,
-   _Manager_operation __op)
-      {
- switch (__op)
-   {
-
-   case __get_type_info:
-     __dest._M_access<const type_info*>() = &typeid(_Functor);
-     break;
-
-   case __get_functor_ptr:
-     __dest._M_access<_Functor*>() =
-       &_Base::_M_get_pointer(__source)->__value;
-     break;
-
-   default:
-     _Base::_M_manager(__dest, __source, __op);
-   }
- return false;
-      }
-
-      static void
-      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
-      {
- std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
-     std::forward<_ArgTypes>(__args)...);
-      }
-    };
-
-  template<typename _From, typename _To>
-    using __check_func_return_type
-      = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
-
-
-
-
-
-
-
-  template<typename _Res, typename... _ArgTypes>
-    class function<_Res(_ArgTypes...)>
-    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
-      private _Function_base
-    {
-      typedef _Res _Signature_type(_ArgTypes...);
-
-      template<typename _Func,
-        typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
- struct _Callable : __check_func_return_type<_Res2, _Res> { };
-
-
-
-      template<typename _Tp>
- struct _Callable<function, _Tp> : false_type { };
-
-      template<typename _Cond, typename _Tp>
- using _Requires = typename enable_if<_Cond::value, _Tp>::type;
-
-    public:
-      typedef _Res result_type;
-
-
-
-
-
-
-
-      function() noexcept
-      : _Function_base() { }
-
-
-
-
-
-      function(nullptr_t) noexcept
-      : _Function_base() { }
-# 1879 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      function(const function& __x);
-# 1888 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      function(function&& __x) : _Function_base()
-      {
- __x.swap(*this);
-      }
-# 1911 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      template<typename _Functor,
-        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
-        typename = _Requires<_Callable<_Functor>, void>>
- function(_Functor);
-# 1928 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      function&
-      operator=(const function& __x)
-      {
- function(__x).swap(*this);
- return *this;
-      }
-# 1946 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      function&
-      operator=(function&& __x)
-      {
- function(std::move(__x)).swap(*this);
- return *this;
-      }
-# 1960 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      function&
-      operator=(nullptr_t) noexcept
-      {
- if (_M_manager)
-   {
-     _M_manager(_M_functor, _M_functor, __destroy_functor);
-     _M_manager = nullptr;
-     _M_invoker = nullptr;
-   }
- return *this;
-      }
-# 1988 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      template<typename _Functor>
- _Requires<_Callable<typename decay<_Functor>::type>, function&>
- operator=(_Functor&& __f)
- {
-   function(std::forward<_Functor>(__f)).swap(*this);
-   return *this;
- }
-
-
-      template<typename _Functor>
- function&
- operator=(reference_wrapper<_Functor> __f) noexcept
- {
-   function(__f).swap(*this);
-   return *this;
- }
-# 2014 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      void swap(function& __x) noexcept
-      {
- std::swap(_M_functor, __x._M_functor);
- std::swap(_M_manager, __x._M_manager);
- std::swap(_M_invoker, __x._M_invoker);
-      }
-# 2042 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      explicit operator bool() const noexcept
-      { return !_M_empty(); }
-# 2055 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      _Res operator()(_ArgTypes... __args) const;
-# 2068 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      const type_info& target_type() const noexcept;
-# 2079 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-      template<typename _Functor> _Functor* target() noexcept;
-
-
-      template<typename _Functor> const _Functor* target() const noexcept;
-
-
-    private:
-      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
-      _Invoker_type _M_invoker;
-  };
-
-
-  template<typename _Res, typename... _ArgTypes>
-    function<_Res(_ArgTypes...)>::
-    function(const function& __x)
-    : _Function_base()
-    {
-      if (static_cast<bool>(__x))
- {
-   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
-   _M_invoker = __x._M_invoker;
-   _M_manager = __x._M_manager;
- }
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor, typename, typename>
-      function<_Res(_ArgTypes...)>::
-      function(_Functor __f)
-      : _Function_base()
-      {
- typedef _Function_handler<_Signature_type, _Functor> _My_handler;
-
- if (_My_handler::_M_not_empty_function(__f))
-   {
-     _My_handler::_M_init_functor(_M_functor, std::move(__f));
-     _M_invoker = &_My_handler::_M_invoke;
-     _M_manager = &_My_handler::_M_manager;
-   }
-      }
-
-  template<typename _Res, typename... _ArgTypes>
-    _Res
-    function<_Res(_ArgTypes...)>::
-    operator()(_ArgTypes... __args) const
-    {
-      if (_M_empty())
- __throw_bad_function_call();
-      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
-    }
-
-
-  template<typename _Res, typename... _ArgTypes>
-    const type_info&
-    function<_Res(_ArgTypes...)>::
-    target_type() const noexcept
-    {
-      if (_M_manager)
- {
-   _Any_data __typeinfo_result;
-   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
-   return *__typeinfo_result._M_access<const type_info*>();
- }
-      else
- return typeid(void);
-    }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      _Functor*
-      function<_Res(_ArgTypes...)>::
-      target() noexcept
-      {
- if (typeid(_Functor) == target_type() && _M_manager)
-   {
-     _Any_data __ptr;
-     if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
-  && !is_const<_Functor>::value)
-       return 0;
-     else
-       return __ptr._M_access<_Functor*>();
-   }
- else
-   return 0;
-      }
-
-  template<typename _Res, typename... _ArgTypes>
-    template<typename _Functor>
-      const _Functor*
-      function<_Res(_ArgTypes...)>::
-      target() const noexcept
-      {
- if (typeid(_Functor) == target_type() && _M_manager)
-   {
-     _Any_data __ptr;
-     _M_manager(__ptr, _M_functor, __get_functor_ptr);
-     return __ptr._M_access<const _Functor*>();
-   }
- else
-   return 0;
-      }
-# 2191 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Res, typename... _Args>
-    inline bool
-    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
-    { return !static_cast<bool>(__f); }
-
-
-  template<typename _Res, typename... _Args>
-    inline bool
-    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
-    { return !static_cast<bool>(__f); }
-# 2209 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Res, typename... _Args>
-    inline bool
-    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
-    { return static_cast<bool>(__f); }
-
-
-  template<typename _Res, typename... _Args>
-    inline bool
-    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
-    { return static_cast<bool>(__f); }
-# 2229 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/functional" 3
-  template<typename _Res, typename... _Args>
-    inline void
-    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
-    { __x.swap(__y); }
-
-
-}
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-
-
-
-namespace JS {
-template<class T>
-class Heap;
-}
-
-class nsRegion;
-namespace mozilla {
-namespace layers {
-struct TileClient;
-}
-}
-
-namespace mozilla {
-struct SerializedStructuredCloneBuffer;
-class SourceBufferTask;
-}
-
-namespace mozilla {
-namespace dom {
-namespace ipc {
-class StructuredCloneData;
-}
-}
-}
-
-namespace mozilla {
-namespace dom {
-class ClonedMessageData;
-class MessagePortMessage;
-namespace indexedDB {
-struct StructuredCloneReadInfo;
-class SerializedStructuredCloneReadInfo;
-class ObjectStoreCursorResponse;
-}
-}
-}
-
-class JSStructuredCloneData;
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-struct nsTArrayFallibleResult
-{
-
-               nsTArrayFallibleResult(bool aResult) : mResult(aResult) {}
-
-               operator bool() { return mResult; }
-
-private:
-  bool mResult;
-};
-
-struct nsTArrayInfallibleResult
-{
-};
-
-
-
-
-
-
-struct nsTArrayFallibleAllocatorBase
-{
-  typedef bool ResultType;
-  typedef nsTArrayFallibleResult ResultTypeProxy;
-
-  static ResultType Result(ResultTypeProxy aResult) { return aResult; }
-  static bool Successful(ResultTypeProxy aResult) { return aResult; }
-  static ResultTypeProxy SuccessResult() { return true; }
-  static ResultTypeProxy FailureResult() { return false; }
-  static ResultType ConvertBoolToResultType(bool aValue) { return aValue; }
-};
-
-struct nsTArrayInfallibleAllocatorBase
-{
-  typedef void ResultType;
-  typedef nsTArrayInfallibleResult ResultTypeProxy;
-
-  static ResultType Result(ResultTypeProxy aResult) {}
-  static bool Successful(ResultTypeProxy) { return true; }
-  static ResultTypeProxy SuccessResult() { return ResultTypeProxy(); }
-
-  static ResultTypeProxy FailureResult()
-  {
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "Infallible nsTArray should never fail" ")"); do { *((volatile int*) __null) = 180; ::abort(); } while (0); } while (0);
-    return ResultTypeProxy();
-  }
-
-  static ResultType ConvertBoolToResultType(bool aValue)
-  {
-    if (!aValue) {
-      do { AnnotateMozCrashReason("MOZ_CRASH(" "infallible nsTArray should never convert false to ResultType" ")"); do { *((volatile int*) __null) = 187; ::abort(); } while (0); } while (0);
-    }
-  }
-};
-
-struct nsTArrayFallibleAllocator : nsTArrayFallibleAllocatorBase
-{
-  static void* Malloc(size_t aSize) { return malloc(aSize); }
-  static void* Realloc(void* aPtr, size_t aSize)
-  {
-    return realloc(aPtr, aSize);
-  }
-
-  static void Free(void* aPtr) { free(aPtr); }
-  static void SizeTooBig(size_t) {}
-};
-
-
-
-
-struct nsTArrayInfallibleAllocator : nsTArrayInfallibleAllocatorBase
-{
-  static void* Malloc(size_t aSize) { return moz_xmalloc(aSize); }
-  static void* Realloc(void* aPtr, size_t aSize)
-  {
-    return moz_xrealloc(aPtr, aSize);
-  }
-
-  static void Free(void* aPtr) { free(aPtr); }
-  static void SizeTooBig(size_t aSize) { NS_ABORT_OOM(aSize); }
-};
-# 251 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-struct nsTArrayHeader
-{
-  static nsTArrayHeader sEmptyHdr;
-
-  uint32_t mLength;
-  uint32_t mCapacity : 31;
-  uint32_t mIsAutoArray : 1;
-};
-
-
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtHelper
-{
-  typedef E* elem_type;
-  typedef size_t index_type;
-
-
-
-
-  elem_type& SafeElementAt(index_type aIndex);
-  const elem_type& SafeElementAt(index_type aIndex) const;
-};
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtHelper<E*, Derived>
-{
-  typedef E* elem_type;
-
-  typedef size_t index_type;
-
-  elem_type SafeElementAt(index_type aIndex)
-  {
-    return static_cast<Derived*>(this)->SafeElementAt(aIndex, nullptr);
-  }
-
-
-
-
-
-  elem_type SafeElementAt(index_type aIndex) const
-  {
-    return static_cast<const Derived*>(this)->SafeElementAt(aIndex, nullptr);
-  }
-};
-
-
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtSmartPtrHelper
-{
-  typedef E* elem_type;
-  typedef const E* const_elem_type;
-  typedef size_t index_type;
-
-  elem_type SafeElementAt(index_type aIndex)
-  {
-    return static_cast<Derived*>(this)->SafeElementAt(aIndex, nullptr);
-  }
-
-
-  elem_type SafeElementAt(index_type aIndex) const
-  {
-    return static_cast<const Derived*>(this)->SafeElementAt(aIndex, nullptr);
-  }
-};
-
-template<class T> class nsCOMPtr;
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtHelper<nsCOMPtr<E>, Derived>
-  : public nsTArray_SafeElementAtSmartPtrHelper<E, Derived>
-{
-};
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtHelper<RefPtr<E>, Derived>
-  : public nsTArray_SafeElementAtSmartPtrHelper<E, Derived>
-{
-};
-
-namespace mozilla {
-template<class T> class OwningNonNull;
-}
-
-template<class E, class Derived>
-struct nsTArray_SafeElementAtHelper<mozilla::OwningNonNull<E>, Derived>
-{
-  typedef E* elem_type;
-  typedef const E* const_elem_type;
-  typedef size_t index_type;
-
-  elem_type SafeElementAt(index_type aIndex)
-  {
-    if (aIndex < static_cast<Derived*>(this)->Length()) {
-      return static_cast<Derived*>(this)->ElementAt(aIndex);
-    }
-    return nullptr;
-  }
-
-
-  elem_type SafeElementAt(index_type aIndex) const
-  {
-    if (aIndex < static_cast<const Derived*>(this)->Length()) {
-      return static_cast<const Derived*>(this)->ElementAt(aIndex);
-    }
-    return nullptr;
-  }
-};
-
-
-extern "C" void Gecko_EnsureTArrayCapacity(void* aArray,
-                                           size_t aCapacity,
-                                           size_t aElementSize);
-extern "C" void Gecko_ClearPODTArray(void* aArray,
-                                     size_t aElementSize,
-                                     size_t aElementAlign);
-
-__attribute__((noreturn)) __attribute__ ((cold)) void
-InvalidArrayIndex_CRASH(size_t aIndex, size_t aLength);
-
-
-
-
-
-
-template<class Alloc, class Copy>
-class nsTArray_base
-{
-
-
-
-  template<class Allocator, class Copier>
-  friend class nsTArray_base;
-  friend void Gecko_EnsureTArrayCapacity(void* aArray, size_t aCapacity,
-                                         size_t aElemSize);
-  friend void Gecko_ClearPODTArray(void* aTArray, size_t aElementSize,
-                                   size_t aElementAlign);
-
-protected:
-  typedef nsTArrayHeader Header;
-
-public:
-  typedef size_t size_type;
-  typedef size_t index_type;
-
-
-  size_type Length() const { return mHdr->mLength; }
-
-
-  bool IsEmpty() const { return Length() == 0; }
-
-
-
-
-  size_type Capacity() const { return mHdr->mCapacity; }
-
-
-
-
-
-protected:
-  nsTArray_base();
-
-  ~nsTArray_base();
-
-
-
-
-
-  template<typename ActualAlloc>
-  typename ActualAlloc::ResultTypeProxy EnsureCapacity(size_type aCapacity,
-                                                       size_type aElemSize);
-
-
-
-
-
-  void ShrinkCapacity(size_type aElemSize, size_t aElemAlign);
-# 439 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<typename ActualAlloc>
-  void ShiftData(index_type aStart, size_type aOldLen, size_type aNewLen,
-                 size_type aElemSize, size_t aElemAlign);
-
-
-
-
-
-  void IncrementLength(size_t aNum)
-  {
-    if (mHdr == EmptyHdr()) {
-      if ((__builtin_expect(!!(aNum != 0), 0))) {
-
-        do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 452; ::abort(); } while (0); } while (0);
-      }
-    } else {
-      mHdr->mLength += aNum;
-    }
-  }
-
-
-
-
-
-
-
-  template<typename ActualAlloc>
-  bool InsertSlotsAt(index_type aIndex, size_type aCount,
-                     size_type aElementSize, size_t aElemAlign);
-
-  template<typename ActualAlloc, class Allocator>
-  typename ActualAlloc::ResultTypeProxy
-  SwapArrayElements(nsTArray_base<Allocator, Copy>& aOther,
-                    size_type aElemSize,
-                    size_t aElemAlign);
-
-
-  class IsAutoArrayRestorer
-  {
-  public:
-    IsAutoArrayRestorer(nsTArray_base<Alloc, Copy>& aArray, size_t aElemAlign);
-    ~IsAutoArrayRestorer();
-
-  private:
-    nsTArray_base<Alloc, Copy>& mArray;
-    size_t mElemAlign;
-    bool mIsAuto;
-  };
-
-
-
-  template<typename ActualAlloc>
-  bool EnsureNotUsingAutoArrayBuffer(size_type aElemSize);
-
-
-  bool IsAutoArray() const { return mHdr->mIsAutoArray; }
-
-
-  Header* GetAutoArrayBuffer(size_t aElemAlign)
-  {
-    do { } while (0);
-    return GetAutoArrayBufferUnsafe(aElemAlign);
-  }
-  const Header* GetAutoArrayBuffer(size_t aElemAlign) const
-  {
-    do { } while (0);
-    return GetAutoArrayBufferUnsafe(aElemAlign);
-  }
-
-
-
-  Header* GetAutoArrayBufferUnsafe(size_t aElemAlign)
-  {
-    return const_cast<Header*>(static_cast<const nsTArray_base<Alloc, Copy>*>(
-      this)->GetAutoArrayBufferUnsafe(aElemAlign));
-  }
-  const Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) const;
-
-
-
-  bool UsesAutoArrayBuffer() const;
-
-
-
-  Header* mHdr;
-
-  Header* Hdr() const { return mHdr; }
-  Header** PtrToHdr() { return &mHdr; }
-  static Header* EmptyHdr() { return &Header::sEmptyHdr; }
-};
-
-
-
-
-
-template<class E>
-class nsTArrayElementTraits
-{
-public:
-
-  static inline void Construct(E* aE)
-  {
-
-
-
-
-
-    new (static_cast<void*>(aE)) E;
-  }
-
-  template<class A>
-  static inline void Construct(E* aE, A&& aArg)
-  {
-    typedef typename mozilla::RemoveCV<E>::Type E_NoCV;
-    typedef typename mozilla::RemoveCV<A>::Type A_NoCV;
-    static_assert(!mozilla::IsSame<E_NoCV*, A_NoCV>::value,
-                  "For safety, we disallow constructing nsTArray<E> elements "
-                  "from E* pointers. See bug 960591.");
-    new (static_cast<void*>(aE)) E(mozilla::Forward<A>(aArg));
-  }
-
-  static inline void Destruct(E* aE) { aE->~E(); }
-};
-
-
-template<class A, class B>
-class nsDefaultComparator
-{
-public:
-  bool Equals(const A& aA, const B& aB) const { return aA == aB; }
-  bool LessThan(const A& aA, const B& aB) const { return aA < aB; }
-};
-
-template<bool IsPod, bool IsSameType>
-struct AssignRangeAlgorithm
-{
-  template<class Item, class ElemType, class IndexType, class SizeType>
-  static void implementation(ElemType* aElements, IndexType aStart,
-                             SizeType aCount, const Item* aValues)
-  {
-    ElemType* iter = aElements + aStart;
-    ElemType* end = iter + aCount;
-    for (; iter != end; ++iter, ++aValues) {
-      nsTArrayElementTraits<ElemType>::Construct(iter, *aValues);
-    }
-  }
-};
-
-template<>
-struct AssignRangeAlgorithm<true, true>
-{
-  template<class Item, class ElemType, class IndexType, class SizeType>
-  static void implementation(ElemType* aElements, IndexType aStart,
-                             SizeType aCount, const Item* aValues)
-  {
-    memcpy(aElements + aStart, aValues, aCount * sizeof(ElemType));
-  }
-};
-# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-struct nsTArray_CopyWithMemutils
-{
-  const static bool allowRealloc = true;
-
-  static void MoveNonOverlappingRegionWithHeader(void* aDest, const void* aSrc,
-                                                 size_t aCount, size_t aElemSize)
-  {
-    memcpy(aDest, aSrc, sizeof(nsTArrayHeader) + aCount * aElemSize);
-  }
-
-  static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
-                                    size_t aElemSize)
-  {
-    memmove(aDest, aSrc, aCount * aElemSize);
-  }
-
-  static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
-                                       size_t aElemSize)
-  {
-    memcpy(aDest, aSrc, aCount * aElemSize);
-  }
-};
-
-
-
-
-
-template<class ElemType>
-struct nsTArray_CopyWithConstructors
-{
-  typedef nsTArrayElementTraits<ElemType> traits;
-
-  const static bool allowRealloc = false;
-
-  static void MoveNonOverlappingRegionWithHeader(void* aDest, void* aSrc, size_t aCount,
-                                                 size_t aElemSize)
-  {
-    nsTArrayHeader* destHeader = static_cast<nsTArrayHeader*>(aDest);
-    nsTArrayHeader* srcHeader = static_cast<nsTArrayHeader*>(aSrc);
-    *destHeader = *srcHeader;
-    MoveNonOverlappingRegion(static_cast<uint8_t*>(aDest) + sizeof(nsTArrayHeader),
-                             static_cast<uint8_t*>(aSrc) + sizeof(nsTArrayHeader),
-                             aCount, aElemSize);
-  }
-# 662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  static void MoveOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
-                                    size_t aElemSize)
-  {
-    ElemType* destElem = static_cast<ElemType*>(aDest);
-    ElemType* srcElem = static_cast<ElemType*>(aSrc);
-    ElemType* destElemEnd = destElem + aCount;
-    ElemType* srcElemEnd = srcElem + aCount;
-    if (destElem == srcElem) {
-      return;
-    }
-
-
-    if (srcElemEnd > destElem && srcElemEnd < destElemEnd) {
-      while (destElemEnd != destElem) {
-        --destElemEnd;
-        --srcElemEnd;
-        traits::Construct(destElemEnd, mozilla::Move(*srcElemEnd));
-        traits::Destruct(srcElemEnd);
-      }
-    } else {
-      MoveNonOverlappingRegion(aDest, aSrc, aCount, aElemSize);
-    }
-  }
-
-  static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
-                                       size_t aElemSize)
-  {
-    ElemType* destElem = static_cast<ElemType*>(aDest);
-    ElemType* srcElem = static_cast<ElemType*>(aSrc);
-    ElemType* destElemEnd = destElem + aCount;
-
-
-
-
-    while (destElem != destElemEnd) {
-      traits::Construct(destElem, mozilla::Move(*srcElem));
-      traits::Destruct(srcElem);
-      ++destElem;
-      ++srcElem;
-    }
-  }
-};
-
-
-
-
-template<class E>
-struct nsTArray_CopyChooser
-{
-  typedef nsTArray_CopyWithMemutils Type;
-};
-# 725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-template<class E>
-struct nsTArray_CopyChooser<JS::Heap<E>>
-{
-  typedef nsTArray_CopyWithConstructors<JS::Heap<E>> Type;
-};
-
-template<> struct nsTArray_CopyChooser<nsRegion> { typedef nsTArray_CopyWithConstructors<nsRegion> Type; };
-template<> struct nsTArray_CopyChooser<nsIntRegion> { typedef nsTArray_CopyWithConstructors<nsIntRegion> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::layers::TileClient> { typedef nsTArray_CopyWithConstructors<mozilla::layers::TileClient> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::SerializedStructuredCloneBuffer> { typedef nsTArray_CopyWithConstructors<mozilla::SerializedStructuredCloneBuffer> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::dom::ipc::StructuredCloneData> { typedef nsTArray_CopyWithConstructors<mozilla::dom::ipc::StructuredCloneData> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::dom::ClonedMessageData> { typedef nsTArray_CopyWithConstructors<mozilla::dom::ClonedMessageData> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::StructuredCloneReadInfo> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::StructuredCloneReadInfo> Type; };;
-template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::ObjectStoreCursorResponse> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::ObjectStoreCursorResponse> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo> { typedef nsTArray_CopyWithConstructors<mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo> Type; };;
-template<> struct nsTArray_CopyChooser<JSStructuredCloneData> { typedef nsTArray_CopyWithConstructors<JSStructuredCloneData> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::dom::MessagePortMessage> { typedef nsTArray_CopyWithConstructors<mozilla::dom::MessagePortMessage> Type; };
-template<> struct nsTArray_CopyChooser<mozilla::SourceBufferTask> { typedef nsTArray_CopyWithConstructors<mozilla::SourceBufferTask> Type; };
-
-template<typename T>
-struct nsTArray_CopyChooser<std::function<T>>
-{
-  typedef nsTArray_CopyWithConstructors<std::function<T>> Type;
-};
-
-
-
-
-
-
-
-template<class E, class Derived>
-struct nsTArray_TypedBase : public nsTArray_SafeElementAtHelper<E, Derived>
-{
-};
-# 772 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-template<class E, class Derived>
-struct nsTArray_TypedBase<JS::Heap<E>, Derived>
-  : public nsTArray_SafeElementAtHelper<JS::Heap<E>, Derived>
-{
-  operator const nsTArray<E>&()
-  {
-    static_assert(sizeof(E) == sizeof(JS::Heap<E>),
-                  "JS::Heap<E> must be binary compatible with E.");
-    Derived* self = static_cast<Derived*>(this);
-    return *reinterpret_cast<nsTArray<E> *>(self);
-  }
-
-  operator const FallibleTArray<E>&()
-  {
-    Derived* self = static_cast<Derived*>(this);
-    return *reinterpret_cast<FallibleTArray<E> *>(self);
-  }
-};
-
-namespace detail {
-
-template<class Item, class Comparator>
-struct ItemComparatorEq
-{
-  const Item& mItem;
-  const Comparator& mComp;
-  ItemComparatorEq(const Item& aItem, const Comparator& aComp)
-    : mItem(aItem)
-    , mComp(aComp)
-  {}
-  template<class T>
-  int operator()(const T& aElement) const {
-    if (mComp.Equals(aElement, mItem)) {
-      return 0;
-    }
-
-    return mComp.LessThan(aElement, mItem) ? 1 : -1;
-  }
-};
-
-template<class Item, class Comparator>
-struct ItemComparatorFirstElementGT
-{
-  const Item& mItem;
-  const Comparator& mComp;
-  ItemComparatorFirstElementGT(const Item& aItem, const Comparator& aComp)
-    : mItem(aItem)
-    , mComp(aComp)
-  {}
-  template<class T>
-  int operator()(const T& aElement) const {
-    if (mComp.LessThan(aElement, mItem) ||
-        mComp.Equals(aElement, mItem)) {
-      return 1;
-    } else {
-      return -1;
-    }
-  }
-};
-
-}
-# 846 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-template<class E, class Alloc>
-class nsTArray_Impl
-  : public nsTArray_base<Alloc, typename nsTArray_CopyChooser<E>::Type>
-  , public nsTArray_TypedBase<E, nsTArray_Impl<E, Alloc>>
-{
-private:
-  typedef nsTArrayFallibleAllocator FallibleAlloc;
-  typedef nsTArrayInfallibleAllocator InfallibleAlloc;
-
-public:
-  typedef typename nsTArray_CopyChooser<E>::Type copy_type;
-  typedef nsTArray_base<Alloc, copy_type> base_type;
-  typedef typename base_type::size_type size_type;
-  typedef typename base_type::index_type index_type;
-  typedef E elem_type;
-  typedef nsTArray_Impl<E, Alloc> self_type;
-  typedef nsTArrayElementTraits<E> elem_traits;
-  typedef nsTArray_SafeElementAtHelper<E, self_type> safeelementat_helper_type;
-  typedef mozilla::ArrayIterator<elem_type&, nsTArray<E>> iterator;
-  typedef mozilla::ArrayIterator<const elem_type&, nsTArray<E>> const_iterator;
-  typedef mozilla::ReverseIterator<iterator> reverse_iterator;
-  typedef mozilla::ReverseIterator<const_iterator> const_reverse_iterator;
-
-  using safeelementat_helper_type::SafeElementAt;
-  using base_type::EmptyHdr;
-
-
-
-  static const index_type NoIndex = index_type(-1);
-
-  using base_type::Length;
-
-
-
-
-
-  ~nsTArray_Impl() { Clear(); }
-
-
-
-
-
-  nsTArray_Impl() {}
-
-
-  explicit nsTArray_Impl(size_type aCapacity) { SetCapacity(aCapacity); }
-
-
-
-  template<typename Allocator>
-  explicit nsTArray_Impl(nsTArray_Impl<E, Allocator>&& aOther)
-  {
-    SwapElements(aOther);
-  }
-# 916 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  explicit nsTArray_Impl(const self_type& aOther) { AppendElements(aOther); }
-
-  explicit nsTArray_Impl(std::initializer_list<E> aIL) { AppendElements(aIL.begin(), aIL.size()); }
-
-
-  template<typename Allocator>
-  operator const nsTArray_Impl<E, Allocator>&() const
-  {
-    return *reinterpret_cast<const nsTArray_Impl<E, Allocator>*>(this);
-  }
-
-  operator const nsTArray<E>&() const
-  {
-    return *reinterpret_cast<const InfallibleTArray<E>*>(this);
-  }
-  operator const FallibleTArray<E>&() const
-  {
-    return *reinterpret_cast<const FallibleTArray<E>*>(this);
-  }
-
-
-
-
-  self_type& operator=(const self_type& aOther)
-  {
-    if (this != &aOther) {
-      ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length());
-    }
-    return *this;
-  }
-
-
-
-
-  self_type& operator=(self_type&& aOther)
-  {
-    if (this != &aOther) {
-      Clear();
-      SwapElements(aOther);
-    }
-    return *this;
-  }
-
-
-
-  template<typename Allocator>
-  bool operator==(const nsTArray_Impl<E, Allocator>& aOther) const
-  {
-    size_type len = Length();
-    if (len != aOther.Length()) {
-      return false;
-    }
-
-
-    for (index_type i = 0; i < len; ++i) {
-      if (!(operator[](i) == aOther[i])) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-
-
-  bool operator!=(const self_type& aOther) const { return !operator==(aOther); }
-
-  template<typename Allocator>
-  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
-  {
-    ReplaceElementsAt(0, Length(), aOther.Elements(), aOther.Length());
-    return *this;
-  }
-
-  template<typename Allocator>
-  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
-  {
-    Clear();
-    SwapElements(aOther);
-    return *this;
-  }
-
-
-
-
-
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    if (this->UsesAutoArrayBuffer() || Hdr() == EmptyHdr()) {
-      return 0;
-    }
-    return aMallocSizeOf(this->Hdr());
-  }
-
-
-
-
-
-  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-# 1026 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  elem_type* Elements() { return reinterpret_cast<elem_type*>(Hdr() + 1); }
-
-
-
-
-  const elem_type* Elements() const
-  {
-    return reinterpret_cast<const elem_type*>(Hdr() + 1);
-  }
-
-
-
-
-
-  elem_type& ElementAt(index_type aIndex)
-  {
-    if ((__builtin_expect(!!(aIndex >= Length()), 0))) {
-      InvalidArrayIndex_CRASH(aIndex, Length());
-    }
-    return Elements()[aIndex];
-  }
-
-
-
-
-
-  const elem_type& ElementAt(index_type aIndex) const
-  {
-    if ((__builtin_expect(!!(aIndex >= Length()), 0))) {
-      InvalidArrayIndex_CRASH(aIndex, Length());
-    }
-    return Elements()[aIndex];
-  }
-
-
-
-
-
-
-  elem_type& SafeElementAt(index_type aIndex, elem_type& aDef)
-  {
-    return aIndex < Length() ? Elements()[aIndex] : aDef;
-  }
-
-
-
-
-
-
-  const elem_type& SafeElementAt(index_type aIndex, const elem_type& aDef) const
-  {
-    return aIndex < Length() ? Elements()[aIndex] : aDef;
-  }
-
-
-  elem_type& operator[](index_type aIndex) { return ElementAt(aIndex); }
-
-
-  const elem_type& operator[](index_type aIndex) const { return ElementAt(aIndex); }
-
-
-  elem_type& LastElement() { return ElementAt(Length() - 1); }
-
-
-  const elem_type& LastElement() const { return ElementAt(Length() - 1); }
-
-
-  elem_type& SafeLastElement(elem_type& aDef)
-  {
-    return SafeElementAt(Length() - 1, aDef);
-  }
-
-
-  const elem_type& SafeLastElement(const elem_type& aDef) const
-  {
-    return SafeElementAt(Length() - 1, aDef);
-  }
-
-
-  iterator begin() { return iterator(*this, 0); }
-  const_iterator begin() const { return const_iterator(*this, 0); }
-  const_iterator cbegin() const { return begin(); }
-  iterator end() { return iterator(*this, Length()); }
-  const_iterator end() const { return const_iterator(*this, Length()); }
-  const_iterator cend() const { return end(); }
-
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-  const_reverse_iterator crend() const { return rend(); }
-
-
-
-  operator mozilla::Span<elem_type>()
-  {
-    return mozilla::Span<elem_type>(Elements(), Length());
-  }
-
-  operator mozilla::Span<const elem_type>() const
-  {
-    return mozilla::Span<const elem_type>(Elements(), Length());
-  }
-# 1141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Item, class Comparator>
-  bool Contains(const Item& aItem, const Comparator& aComp) const
-  {
-    return IndexOf(aItem, 0, aComp) != NoIndex;
-  }
-
-
-
-
-
-
-  template<class Item>
-  bool Contains(const Item& aItem) const
-  {
-    return IndexOf(aItem) != NoIndex;
-  }
-
-
-
-
-
-
-
-  template<class Item, class Comparator>
-  index_type IndexOf(const Item& aItem, index_type aStart,
-                     const Comparator& aComp) const
-  {
-    const elem_type* iter = Elements() + aStart;
-    const elem_type* iend = Elements() + Length();
-    for (; iter != iend; ++iter) {
-      if (aComp.Equals(*iter, aItem)) {
-        return index_type(iter - Elements());
-      }
-    }
-    return NoIndex;
-  }
-
-
-
-
-
-
-
-  template<class Item>
-  index_type IndexOf(const Item& aItem, index_type aStart = 0) const
-  {
-    return IndexOf(aItem, aStart, nsDefaultComparator<elem_type, Item>());
-  }
-# 1197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Item, class Comparator>
-  index_type LastIndexOf(const Item& aItem, index_type aStart,
-                         const Comparator& aComp) const
-  {
-    size_type endOffset = aStart >= Length() ? Length() : aStart + 1;
-    const elem_type* iend = Elements() - 1;
-    const elem_type* iter = iend + endOffset;
-    for (; iter != iend; --iter) {
-      if (aComp.Equals(*iter, aItem)) {
-        return index_type(iter - Elements());
-      }
-    }
-    return NoIndex;
-  }
-# 1219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Item>
-  index_type LastIndexOf(const Item& aItem,
-                         index_type aStart = NoIndex) const
-  {
-    return LastIndexOf(aItem, aStart, nsDefaultComparator<elem_type, Item>());
-  }
-# 1233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Item, class Comparator>
-  index_type BinaryIndexOf(const Item& aItem, const Comparator& aComp) const
-  {
-    using mozilla::BinarySearchIf;
-    typedef ::detail::ItemComparatorEq<Item, Comparator> Cmp;
-
-    size_t index;
-    bool found = BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index);
-    return found ? index : NoIndex;
-  }
-
-
-
-
-
-
-  template<class Item>
-  index_type BinaryIndexOf(const Item& aItem) const
-  {
-    return BinaryIndexOf(aItem, nsDefaultComparator<elem_type, Item>());
-  }
-
-
-
-
-
-  template<class Allocator, typename ActualAlloc = Alloc>
-  typename ActualAlloc::ResultType Assign(
-      const nsTArray_Impl<E, Allocator>& aOther)
-  {
-    return ActualAlloc::ConvertBoolToResultType(
-      !!ReplaceElementsAt<E, ActualAlloc>(0, Length(),
-                                          aOther.Elements(), aOther.Length()));
-  }
-
-  template<class Allocator>
-  __attribute__ ((warn_unused_result))
-  bool Assign(const nsTArray_Impl<E, Allocator>& aOther,
-              const mozilla::fallible_t&)
-  {
-    return Assign<Allocator, FallibleAlloc>(aOther);
-  }
-
-  template<class Allocator>
-  void Assign(nsTArray_Impl<E, Allocator>&& aOther)
-  {
-    Clear();
-    SwapElements(aOther);
-  }
-
-
-
-
-
-
-  void ClearAndRetainStorage()
-  {
-    if (base_type::mHdr == EmptyHdr()) {
-      return;
-    }
-
-    DestructRange(0, Length());
-    base_type::mHdr->mLength = 0;
-  }
-# 1306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  void SetLengthAndRetainStorage(size_type aNewLen)
-  {
-    do { } while (0);
-    size_type oldLen = Length();
-    if (aNewLen > oldLen) {
-      InsertElementsAt(oldLen, aNewLen - oldLen);
-      return;
-    }
-    if (aNewLen < oldLen) {
-      DestructRange(aNewLen, oldLen - aNewLen);
-      base_type::mHdr->mLength = aNewLen;
-    }
-  }
-# 1330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const Item* aArray, size_type aArrayLen);
-
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const Item* aArray, size_type aArrayLen,
-                               const mozilla::fallible_t&)
-  {
-    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount,
-                                                  aArray, aArrayLen);
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const nsTArray<Item>& aArray)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(
-      aStart, aCount, aArray.Elements(), aArray.Length());
-  }
-
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* ReplaceElementsAt(index_type aStart,
-                               size_type aCount,
-                               mozilla::Span<const Item> aSpan)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(
-      aStart, aCount, aSpan.Elements(), aSpan.Length());
-  }
-
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const nsTArray<Item>& aArray,
-                               const mozilla::fallible_t&)
-  {
-    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aArray);
-  }
-
-  template<class Item>
-  __attribute__ ((warn_unused_result)) elem_type* ReplaceElementsAt(index_type aStart,
-                                            size_type aCount,
-                                            mozilla::Span<const Item> aSpan,
-                                            const mozilla::fallible_t&)
-  {
-    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aSpan);
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const Item& aItem)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(aStart, aCount, &aItem, 1);
-  }
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* ReplaceElementsAt(index_type aStart, size_type aCount,
-                               const Item& aItem, const mozilla::fallible_t&)
-  {
-    return ReplaceElementsAt<Item, FallibleAlloc>(aStart, aCount, aItem);
-  }
-
-
-  template<class Item>
-  elem_type* ReplaceElementAt(index_type aIndex, const Item& aItem)
-  {
-    return ReplaceElementsAt(aIndex, 1, &aItem, 1);
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* InsertElementsAt(index_type aIndex, const Item* aArray,
-                              size_type aArrayLen)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(aIndex, 0, aArray, aArrayLen);
-  }
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementsAt(index_type aIndex, const Item* aArray,
-                              size_type aArrayLen, const mozilla::fallible_t&)
-  {
-    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aArray, aArrayLen);
-  }
-
-
-protected:
-  template<class Item, class Allocator, typename ActualAlloc = Alloc>
-  elem_type* InsertElementsAt(index_type aIndex,
-                              const nsTArray_Impl<Item, Allocator>& aArray)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(
-      aIndex, 0, aArray.Elements(), aArray.Length());
-  }
-
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* InsertElementsAt(index_type aIndex,
-                              mozilla::Span<const Item> aSpan)
-  {
-    return ReplaceElementsAt<Item, ActualAlloc>(
-      aIndex, 0, aSpan.Elements(), aSpan.Length());
-  }
-
-public:
-
-  template<class Item, class Allocator>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementsAt(index_type aIndex,
-                              const nsTArray_Impl<Item, Allocator>& aArray,
-                              const mozilla::fallible_t&)
-  {
-    return InsertElementsAt<Item, Allocator, FallibleAlloc>(aIndex, aArray);
-  }
-
-  template<class Item>
-  __attribute__ ((warn_unused_result)) elem_type* InsertElementsAt(index_type aIndex,
-                                           mozilla::Span<const Item> aSpan,
-                                           const mozilla::fallible_t&)
-  {
-    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aSpan);
-  }
-
-
-
-
-protected:
-  template<typename ActualAlloc = Alloc>
-  elem_type* InsertElementAt(index_type aIndex);
-
-public:
-
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementAt(index_type aIndex, const mozilla::fallible_t&)
-  {
-    return InsertElementAt<FallibleAlloc>(aIndex);
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* InsertElementAt(index_type aIndex, Item&& aItem);
-
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementAt(index_type aIndex, Item&& aItem,
-                             const mozilla::fallible_t&)
-  {
-    return InsertElementAt<Item, FallibleAlloc>(aIndex,
-                                                mozilla::Forward<Item>(aItem));
-  }
-# 1507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  elem_type* ReconstructElementAt(index_type aIndex)
-  {
-    elem_type* elem = &ElementAt(aIndex);
-    elem_traits::Destruct(elem);
-    elem_traits::Construct(elem);
-    return elem;
-  }
-# 1530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Item, class Comparator>
-  index_type IndexOfFirstElementGt(const Item& aItem,
-                                   const Comparator& aComp) const
-  {
-    using mozilla::BinarySearchIf;
-    typedef ::detail::ItemComparatorFirstElementGT<Item, Comparator> Cmp;
-
-    size_t index;
-    BinarySearchIf(*this, 0, Length(), Cmp(aItem, aComp), &index);
-    return index;
-  }
-
-
-  template<class Item>
-  index_type
-  IndexOfFirstElementGt(const Item& aItem) const
-  {
-    return IndexOfFirstElementGt(aItem, nsDefaultComparator<elem_type, Item>());
-  }
-
-
-
-
-protected:
-  template<class Item, class Comparator, typename ActualAlloc = Alloc>
-  elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp)
-  {
-    index_type index = IndexOfFirstElementGt<Item, Comparator>(aItem, aComp);
-    return InsertElementAt<Item, ActualAlloc>(
-      index, mozilla::Forward<Item>(aItem));
-  }
-public:
-
-  template<class Item, class Comparator>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp,
-                                 const mozilla::fallible_t&)
-  {
-    return InsertElementSorted<Item, Comparator, FallibleAlloc>(
-      mozilla::Forward<Item>(aItem), aComp);
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* InsertElementSorted(Item&& aItem)
-  {
-    nsDefaultComparator<elem_type, Item> comp;
-    return InsertElementSorted<Item, decltype(comp), ActualAlloc>(
-      mozilla::Forward<Item>(aItem), comp);
-  }
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementSorted(Item&& aItem, const mozilla::fallible_t&)
-  {
-    return InsertElementSorted<Item, FallibleAlloc>(
-      mozilla::Forward<Item>(aItem));
-  }
-
-
-
-
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* AppendElements(const Item* aArray, size_type aArrayLen);
-
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* AppendElements(mozilla::Span<const Item> aSpan)
-  {
-    return AppendElements<Item, FallibleAlloc>(aSpan.Elements(),
-                                               aSpan.Length());
-  }
-
-  template<class Item, size_t Length, typename ActualAlloc = Alloc>
-  elem_type* AppendElements(const mozilla::Array<Item, Length>& aArray)
-  {
-    return AppendElements<Item, ActualAlloc>(&aArray[0], Length);
-  }
-
-public:
-
-  template<class Item>
-
-  elem_type* AppendElements(const Item* aArray, size_type aArrayLen,
-                            const mozilla::fallible_t&)
-  {
-    return AppendElements<Item, FallibleAlloc>(aArray, aArrayLen);
-  }
-
-  template<class Item>
-
-  elem_type* AppendElements(mozilla::Span<const Item> aSpan,
-                            const mozilla::fallible_t&)
-  {
-    return AppendElements<Item, FallibleAlloc>(aSpan.Elements(),
-                                               aSpan.Length());
-  }
-
-
-protected:
-  template<class Item, class Allocator, typename ActualAlloc = Alloc>
-  elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray)
-  {
-    return AppendElements<Item, ActualAlloc>(aArray.Elements(), aArray.Length());
-  }
-public:
-
-  template<class Item, class Allocator>
-
-  elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray,
-                            const mozilla::fallible_t&)
-  {
-    return AppendElements<Item, Allocator, FallibleAlloc>(aArray);
-  }
-
-
-
-protected:
-  template<class Item, class Allocator, typename ActualAlloc = Alloc>
-  elem_type* AppendElements(nsTArray_Impl<Item, Allocator>&& aArray);
-
-public:
-
-  template<class Item, class Allocator, typename ActualAlloc = Alloc>
-
-  elem_type* AppendElements(nsTArray_Impl<Item, Allocator>&& aArray,
-                            const mozilla::fallible_t&)
-  {
-    return AppendElements<Item, Allocator>(mozilla::Move(aArray));
-  }
-
-
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* AppendElement(Item&& aItem);
-
-public:
-
-  template<class Item>
-
-  elem_type* AppendElement(Item&& aItem,
-                           const mozilla::fallible_t&)
-  {
-    return AppendElement<Item, FallibleAlloc>(mozilla::Forward<Item>(aItem));
-  }
-
-
-
-
-protected:
-  template<typename ActualAlloc = Alloc>
-  elem_type* AppendElements(size_type aCount) {
-    if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-          Length() + aCount, sizeof(elem_type)))) {
-      return nullptr;
-    }
-    elem_type* elems = Elements() + Length();
-    size_type i;
-    for (i = 0; i < aCount; ++i) {
-      elem_traits::Construct(elems + i);
-    }
-    this->IncrementLength(aCount);
-    return elems;
-  }
-public:
-
-
-  elem_type* AppendElements(size_type aCount,
-                            const mozilla::fallible_t&)
-  {
-    return AppendElements<FallibleAlloc>(aCount);
-  }
-
-
-
-
-protected:
-  template<typename ActualAlloc = Alloc>
-  elem_type* AppendElement()
-  {
-    return AppendElements<ActualAlloc>(1);
-  }
-public:
-
-
-  elem_type* AppendElement(const mozilla::fallible_t&)
-  {
-    return AppendElement<FallibleAlloc>();
-  }
-
-
-
-
-  void RemoveElementsAt(index_type aStart, size_type aCount);
-
-
-  void RemoveElementAt(index_type aIndex) { RemoveElementsAt(aIndex, 1); }
-
-
-  void Clear() { RemoveElementsAt(0, Length()); }
-
-
-
-
-
-
-  template<typename Predicate>
-  void RemoveElementsBy(Predicate aPredicate);
-
-
-
-
-
-
-  template<class Item, class Comparator>
-  bool RemoveElement(const Item& aItem, const Comparator& aComp)
-  {
-    index_type i = IndexOf(aItem, 0, aComp);
-    if (i == NoIndex) {
-      return false;
-    }
-
-    RemoveElementAt(i);
-    return true;
-  }
-
-
-
-  template<class Item>
-  bool RemoveElement(const Item& aItem)
-  {
-    return RemoveElement(aItem, nsDefaultComparator<elem_type, Item>());
-  }
-
-
-
-
-
-
-
-  template<class Item, class Comparator>
-  bool RemoveElementSorted(const Item& aItem, const Comparator& aComp)
-  {
-    index_type index = IndexOfFirstElementGt(aItem, aComp);
-    if (index > 0 && aComp.Equals(ElementAt(index - 1), aItem)) {
-      RemoveElementAt(index - 1);
-      return true;
-    }
-    return false;
-  }
-
-
-  template<class Item>
-  bool RemoveElementSorted(const Item& aItem)
-  {
-    return RemoveElementSorted(aItem, nsDefaultComparator<elem_type, Item>());
-  }
-
-
-
-  template<class Allocator>
-  typename Alloc::ResultType SwapElements(nsTArray_Impl<E, Allocator>& aOther)
-  {
-    return Alloc::Result(this->template SwapArrayElements<Alloc>(
-      aOther, sizeof(elem_type), mozilla::AlignmentFinder<elem_type>::alignment));
-  }
-# 1811 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-protected:
-  template<typename ActualAlloc = Alloc>
-  typename ActualAlloc::ResultType SetCapacity(size_type aCapacity)
-  {
-    return ActualAlloc::Result(this->template EnsureCapacity<ActualAlloc>(
-      aCapacity, sizeof(elem_type)));
-  }
-public:
-
-  __attribute__ ((warn_unused_result))
-  bool SetCapacity(size_type aCapacity, const mozilla::fallible_t&)
-  {
-    return SetCapacity<FallibleAlloc>(aCapacity);
-  }
-# 1834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-protected:
-  template<typename ActualAlloc = Alloc>
-  typename ActualAlloc::ResultType SetLength(size_type aNewLen)
-  {
-    size_type oldLen = Length();
-    if (aNewLen > oldLen) {
-      return ActualAlloc::ConvertBoolToResultType(
-        InsertElementsAt<ActualAlloc>(oldLen, aNewLen - oldLen) != nullptr);
-    }
-
-    TruncateLength(aNewLen);
-    return ActualAlloc::ConvertBoolToResultType(true);
-  }
-public:
-
-  __attribute__ ((warn_unused_result))
-  bool SetLength(size_type aNewLen, const mozilla::fallible_t&)
-  {
-    return SetLength<FallibleAlloc>(aNewLen);
-  }
-
-
-
-
-
-
-
-  void TruncateLength(size_type aNewLen)
-  {
-    size_type oldLen = Length();
-    do { } while (0);
-
-    RemoveElementsAt(aNewLen, oldLen - aNewLen);
-  }
-
-
-
-
-
-
-
-protected:
-  template<typename ActualAlloc = Alloc>
-  typename ActualAlloc::ResultType EnsureLengthAtLeast(size_type aMinLen)
-  {
-    size_type oldLen = Length();
-    if (aMinLen > oldLen) {
-      return ActualAlloc::ConvertBoolToResultType(
-        !!InsertElementsAt<ActualAlloc>(oldLen, aMinLen - oldLen));
-    }
-    return ActualAlloc::ConvertBoolToResultType(true);
-  }
-public:
-
-  __attribute__ ((warn_unused_result))
-  bool EnsureLengthAtLeast(size_type aMinLen, const mozilla::fallible_t&)
-  {
-    return EnsureLengthAtLeast<FallibleAlloc>(aMinLen);
-  }
-
-
-
-
-
-
-protected:
-  template<typename ActualAlloc = Alloc>
-  elem_type* InsertElementsAt(index_type aIndex, size_type aCount)
-  {
-    if (!base_type::template InsertSlotsAt<ActualAlloc>(aIndex, aCount,
-                                                        sizeof(elem_type),
-                                                        mozilla::AlignmentFinder<elem_type>::alignment)) {
-      return nullptr;
-    }
-
-
-    elem_type* iter = Elements() + aIndex;
-    elem_type* iend = iter + aCount;
-    for (; iter != iend; ++iter) {
-      elem_traits::Construct(iter);
-    }
-
-    return Elements() + aIndex;
-  }
-public:
-
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
-                              const mozilla::fallible_t&)
-  {
-    return InsertElementsAt<FallibleAlloc>(aIndex, aCount);
-  }
-# 1934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-protected:
-  template<class Item, typename ActualAlloc = Alloc>
-  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
-                              const Item& aItem);
-
-public:
-
-  template<class Item>
-  __attribute__ ((warn_unused_result))
-  elem_type* InsertElementsAt(index_type aIndex, size_type aCount,
-                              const Item& aItem, const mozilla::fallible_t&)
-  {
-    return InsertElementsAt<Item, FallibleAlloc>(aIndex, aCount, aItem);
-  }
-
-
-  void Compact()
-  {
-    ShrinkCapacity(sizeof(elem_type), mozilla::AlignmentFinder<elem_type>::alignment);
-  }
-# 1962 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-  template<class Comparator>
-  static int Compare(const void* aE1, const void* aE2, void* aData)
-  {
-    const Comparator* c = reinterpret_cast<const Comparator*>(aData);
-    const elem_type* a = static_cast<const elem_type*>(aE1);
-    const elem_type* b = static_cast<const elem_type*>(aE2);
-    return c->LessThan(*a, *b) ? -1 : (c->Equals(*a, *b) ? 0 : 1);
-  }
-
-
-
-
-  template<class Comparator>
-  void Sort(const Comparator& aComp)
-  {
-    NS_QuickSort(Elements(), Length(), sizeof(elem_type),
-                 Compare<Comparator>, const_cast<Comparator*>(&aComp));
-  }
-
-
-
-  void Sort() { Sort(nsDefaultComparator<elem_type, elem_type>()); }
-
-
-  void Reverse()
-  {
-    elem_type* elements = Elements();
-    const size_type len = Length();
-    for (index_type i = 0, iend = len / 2; i < iend; ++i) {
-      mozilla::Swap(elements[i], elements[len - i - 1]);
-    }
-  }
-
-protected:
-  using base_type::Hdr;
-  using base_type::ShrinkCapacity;
-
-
-
-
-  void DestructRange(index_type aStart, size_type aCount)
-  {
-    elem_type* iter = Elements() + aStart;
-    elem_type *iend = iter + aCount;
-    for (; iter != iend; ++iter) {
-      elem_traits::Destruct(iter);
-    }
-  }
-
-
-
-
-
-  template<class Item>
-  void AssignRange(index_type aStart, size_type aCount, const Item* aValues)
-  {
-    AssignRangeAlgorithm<mozilla::IsPod<Item>::value,
-                         mozilla::IsSame<Item, elem_type>::value>
-                         ::implementation(Elements(), aStart, aCount, aValues);
-  }
-};
-
-template<typename E, class Alloc>
-template<class Item, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::ReplaceElementsAt(index_type aStart, size_type aCount,
-                                           const Item* aArray, size_type aArrayLen) -> elem_type*
-{
-  if ((__builtin_expect(!!(aStart > Length()), 0))) {
-    InvalidArrayIndex_CRASH(aStart, Length());
-  }
-
-
-  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-        Length() + aArrayLen - aCount, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  DestructRange(aStart, aCount);
-  this->template ShiftData<ActualAlloc>(aStart, aCount, aArrayLen,
-                                        sizeof(elem_type),
-                                        mozilla::AlignmentFinder<elem_type>::alignment);
-  AssignRange(aStart, aArrayLen, aArray);
-  return Elements() + aStart;
-}
-
-template<typename E, class Alloc>
-void
-nsTArray_Impl<E, Alloc>::RemoveElementsAt(index_type aStart, size_type aCount)
-{
-  do { } while (0);
-  do { } while (0);
-
-  do { } while (0);
-  DestructRange(aStart, aCount);
-  this->template ShiftData<InfallibleAlloc>(aStart, aCount, 0,
-                                            sizeof(elem_type),
-                                            mozilla::AlignmentFinder<elem_type>::alignment);
-}
-
-template<typename E, class Alloc>
-template<typename Predicate>
-void
-nsTArray_Impl<E, Alloc>::RemoveElementsBy(Predicate aPredicate)
-{
-  if (base_type::mHdr == EmptyHdr()) {
-    return;
-  }
-
-  index_type j = 0;
-  index_type len = Length();
-  for (index_type i = 0; i < len; ++i) {
-    if (aPredicate(Elements()[i])) {
-      elem_traits::Destruct(Elements() + i);
-    } else {
-      if (j < i) {
-        copy_type::MoveNonOverlappingRegion(Elements() + j, Elements() + i,
-                                            1, sizeof(elem_type));
-      }
-      ++j;
-    }
-  }
-  base_type::mHdr->mLength = j;
-}
-
-template<typename E, class Alloc>
-template<class Item, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::InsertElementsAt(index_type aIndex, size_type aCount,
-                                          const Item& aItem) -> elem_type*
-{
-  if (!base_type::template InsertSlotsAt<ActualAlloc>(aIndex, aCount,
-                                                      sizeof(elem_type),
-                                                      mozilla::AlignmentFinder<elem_type>::alignment)) {
-    return nullptr;
-  }
-
-
-  elem_type* iter = Elements() + aIndex;
-  elem_type* iend = iter + aCount;
-  for (; iter != iend; ++iter) {
-    elem_traits::Construct(iter, aItem);
-  }
-
-  return Elements() + aIndex;
-}
-
-template<typename E, class Alloc>
-template<typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::InsertElementAt(index_type aIndex) -> elem_type*
-{
-  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
-    InvalidArrayIndex_CRASH(aIndex, Length());
-  }
-
-  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-        Length() + 1, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(elem_type),
-                                        mozilla::AlignmentFinder<elem_type>::alignment);
-  elem_type* elem = Elements() + aIndex;
-  elem_traits::Construct(elem);
-  return elem;
-}
-
-template<typename E, class Alloc>
-template<class Item, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::InsertElementAt(index_type aIndex, Item&& aItem) -> elem_type*
-{
-  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
-    InvalidArrayIndex_CRASH(aIndex, Length());
-  }
-
-  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-         Length() + 1, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(elem_type),
-                                        mozilla::AlignmentFinder<elem_type>::alignment);
-  elem_type* elem = Elements() + aIndex;
-  elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
-  return elem;
-}
-
-template<typename E, class Alloc>
-template<class Item, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::AppendElements(const Item* aArray, size_type aArrayLen) -> elem_type*
-{
-  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-        Length() + aArrayLen, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  index_type len = Length();
-  AssignRange(len, aArrayLen, aArray);
-  this->IncrementLength(aArrayLen);
-  return Elements() + len;
-}
-
-template<typename E, class Alloc>
-template<class Item, class Allocator, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::AppendElements(nsTArray_Impl<Item, Allocator>&& aArray) -> elem_type*
-{
-  do { } while (0);
-  if (Length() == 0) {
-    SwapElements<ActualAlloc>(aArray);
-    return Elements();
-  }
-
-  index_type len = Length();
-  index_type otherLen = aArray.Length();
-  if (!Alloc::Successful(this->template EnsureCapacity<Alloc>(
-        len + otherLen, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  copy_type::MoveNonOverlappingRegion(Elements() + len, aArray.Elements(), otherLen,
-                                      sizeof(elem_type));
-  this->IncrementLength(otherLen);
-  aArray.template ShiftData<Alloc>(0, otherLen, 0, sizeof(elem_type),
-                                   mozilla::AlignmentFinder<elem_type>::alignment);
-  return Elements() + len;
-}
-
-template<typename E, class Alloc>
-template<class Item, typename ActualAlloc>
-auto
-nsTArray_Impl<E, Alloc>::AppendElement(Item&& aItem) -> elem_type*
-{
-  if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
-         Length() + 1, sizeof(elem_type)))) {
-    return nullptr;
-  }
-  elem_type* elem = Elements() + Length();
-  elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
-  this->IncrementLength(1);
-  return elem;
-}
-
-template<typename E, typename Alloc>
-inline void
-ImplCycleCollectionUnlink(nsTArray_Impl<E, Alloc>& aField)
-{
-  aField.Clear();
-}
-
-template<typename E, typename Alloc>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsTArray_Impl<E, Alloc>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  aFlags |= CycleCollectionEdgeNameArrayFlag;
-  size_t length = aField.Length();
-  for (size_t i = 0; i < length; ++i) {
-    ImplCycleCollectionTraverse(aCallback, aField[i], aName, aFlags);
-  }
-}
-
-
-
-
-
-template<class E>
-class nsTArray : public nsTArray_Impl<E, nsTArrayInfallibleAllocator>
-{
-public:
-  typedef nsTArray_Impl<E, nsTArrayInfallibleAllocator> base_type;
-  typedef nsTArray<E> self_type;
-  typedef typename base_type::size_type size_type;
-
-  nsTArray() {}
-  explicit nsTArray(size_type aCapacity) : base_type(aCapacity) {}
-  explicit nsTArray(const nsTArray& aOther) : base_type(aOther) {}
-               nsTArray(nsTArray&& aOther) : base_type(mozilla::Move(aOther)) {}
-               nsTArray(std::initializer_list<E> aIL) : base_type(aIL) {}
-
-  template<class Allocator>
-  explicit nsTArray(const nsTArray_Impl<E, Allocator>& aOther)
-    : base_type(aOther)
-  {
-  }
-  template<class Allocator>
-               nsTArray(nsTArray_Impl<E, Allocator>&& aOther)
-    : base_type(mozilla::Move(aOther))
-  {
-  }
-
-  self_type& operator=(const self_type& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-  template<class Allocator>
-  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-  self_type& operator=(self_type&& aOther)
-  {
-    base_type::operator=(mozilla::Move(aOther));
-    return *this;
-  }
-  template<class Allocator>
-  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
-  {
-    base_type::operator=(mozilla::Move(aOther));
-    return *this;
-  }
-
-  using base_type::AppendElement;
-  using base_type::AppendElements;
-  using base_type::EnsureLengthAtLeast;
-  using base_type::InsertElementAt;
-  using base_type::InsertElementsAt;
-  using base_type::InsertElementSorted;
-  using base_type::ReplaceElementsAt;
-  using base_type::SetCapacity;
-  using base_type::SetLength;
-};
-
-
-
-
-template<class E>
-class FallibleTArray : public nsTArray_Impl<E, nsTArrayFallibleAllocator>
-{
-public:
-  typedef nsTArray_Impl<E, nsTArrayFallibleAllocator> base_type;
-  typedef FallibleTArray<E> self_type;
-  typedef typename base_type::size_type size_type;
-
-  FallibleTArray() {}
-  explicit FallibleTArray(size_type aCapacity) : base_type(aCapacity) {}
-  explicit FallibleTArray(const FallibleTArray<E>& aOther) : base_type(aOther) {}
-  FallibleTArray(FallibleTArray<E>&& aOther)
-    : base_type(mozilla::Move(aOther))
-  {
-  }
-
-  template<class Allocator>
-  explicit FallibleTArray(const nsTArray_Impl<E, Allocator>& aOther)
-    : base_type(aOther)
-  {
-  }
-  template<class Allocator>
-  explicit FallibleTArray(nsTArray_Impl<E, Allocator>&& aOther)
-    : base_type(mozilla::Move(aOther))
-  {
-  }
-
-  self_type& operator=(const self_type& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-  template<class Allocator>
-  self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-  self_type& operator=(self_type&& aOther)
-  {
-    base_type::operator=(mozilla::Move(aOther));
-    return *this;
-  }
-  template<class Allocator>
-  self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
-  {
-    base_type::operator=(mozilla::Move(aOther));
-    return *this;
-  }
-};
-
-
-
-
-
-template<class E, size_t N>
-class AutoTArray : public nsTArray<E>
-{
-  static_assert(N != 0, "AutoTArray<E, 0> should be specialized");
-public:
-  typedef AutoTArray<E, N> self_type;
-  typedef nsTArray<E> base_type;
-  typedef typename base_type::Header Header;
-  typedef typename base_type::elem_type elem_type;
-
-  AutoTArray()
-  {
-    Init();
-  }
-
-  AutoTArray(const self_type& aOther)
-  {
-    Init();
-    this->AppendElements(aOther);
-  }
-
-  explicit AutoTArray(const base_type& aOther)
-  {
-    Init();
-    this->AppendElements(aOther);
-  }
-
-  explicit AutoTArray(base_type&& aOther)
-  {
-    Init();
-    this->SwapElements(aOther);
-  }
-
-  template<typename Allocator>
-  explicit AutoTArray(nsTArray_Impl<elem_type, Allocator>&& aOther)
-  {
-    Init();
-    this->SwapElements(aOther);
-  }
-
-               AutoTArray(std::initializer_list<E> aIL)
-  {
-    Init();
-    this->AppendElements(aIL.begin(), aIL.size());
-  }
-
-  self_type& operator=(const self_type& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-
-  template<typename Allocator>
-  self_type& operator=(const nsTArray_Impl<elem_type, Allocator>& aOther)
-  {
-    base_type::operator=(aOther);
-    return *this;
-  }
-
-private:
-
-
-  template<class Allocator, class Copier>
-  friend class nsTArray_base;
-
-  void Init()
-  {
-    static_assert(mozilla::AlignmentFinder<elem_type>::alignment <= 8,
-                  "can't handle alignments greater than 8, "
-                  "see nsTArray_base::UsesAutoArrayBuffer()");
-
-    Header** phdr = base_type::PtrToHdr();
-    *phdr = reinterpret_cast<Header*>(&mAutoBuf);
-    (*phdr)->mLength = 0;
-    (*phdr)->mCapacity = N;
-    (*phdr)->mIsAutoArray = 1;
-
-    do { } while (0);
-
-
-  }
-
-
-
-
-
-  union
-  {
-    char mAutoBuf[sizeof(nsTArrayHeader) + N * sizeof(elem_type)];
-
-    mozilla::AlignedElem<(mozilla::AlignmentFinder<Header>::alignment > mozilla::AlignmentFinder<elem_type>::alignment) ?
-                         mozilla::AlignmentFinder<Header>::alignment : mozilla::AlignmentFinder<elem_type>::alignment> mAlign;
-  };
-};
-# 2454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-template<class E>
-class AutoTArray<E, 0> : public nsTArray<E>
-{
-};
-
-template<class E, size_t N>
-struct nsTArray_CopyChooser<AutoTArray<E, N>>
-{
-  typedef nsTArray_CopyWithConstructors<AutoTArray<E, N>> Type;
-};
-
-
-namespace mozilla {
-
-template<class ElementType, class TArrayAlloc>
-Span<ElementType>
-MakeSpan(nsTArray_Impl<ElementType, TArrayAlloc>& aTArray)
-{
-  return aTArray;
-}
-
-template<class ElementType, class TArrayAlloc>
-Span<const ElementType>
-MakeSpan(const nsTArray_Impl<ElementType, TArrayAlloc>& aTArray)
-{
-  return aTArray;
-}
-
-}
-# 2497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h"
-static_assert(sizeof(AutoTArray<uint32_t, 2>) ==
-              sizeof(void*) + sizeof(nsTArrayHeader) + sizeof(uint32_t) * 2,
-              "AutoTArray shouldn't contain any extra padding, "
-              "see the comment");
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
-template<class Alloc, class Copy>
-nsTArray_base<Alloc, Copy>::nsTArray_base()
-  : mHdr(EmptyHdr())
-{
-                               ;
-}
-
-template<class Alloc, class Copy>
-nsTArray_base<Alloc, Copy>::~nsTArray_base()
-{
-  if (mHdr != EmptyHdr() && !UsesAutoArrayBuffer()) {
-    Alloc::Free(mHdr);
-  }
-                               ;
-}
-
-template<class Alloc, class Copy>
-const nsTArrayHeader*
-nsTArray_base<Alloc, Copy>::GetAutoArrayBufferUnsafe(size_t aElemAlign) const
-{
-
-
-
-  const void* autoBuf =
-    &reinterpret_cast<const AutoTArray<nsTArray<uint32_t>, 1>*>(this)->mAutoBuf;
-
-
-
-
-  static_assert(sizeof(void*) != 4 ||
-                (mozilla::AlignmentFinder<mozilla::AlignedElem<8> >::alignment == 8 &&
-                 sizeof(AutoTArray<mozilla::AlignedElem<8>, 1>) ==
-                   sizeof(void*) + sizeof(nsTArrayHeader) +
-                   4 + sizeof(mozilla::AlignedElem<8>)),
-                "auto array padding wasn't what we expected");
-
-
-  do { } while (0);
-
-  if (sizeof(void*) == 4 && aElemAlign == 8) {
-    autoBuf = reinterpret_cast<const char*>(autoBuf) + 4;
-  }
-
-  return reinterpret_cast<const Header*>(autoBuf);
-}
-
-template<class Alloc, class Copy>
-bool
-nsTArray_base<Alloc, Copy>::UsesAutoArrayBuffer() const
-{
-  if (!mHdr->mIsAutoArray) {
-    return false;
-  }
-# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
-  static_assert(sizeof(nsTArrayHeader) > 4,
-                "see comment above");
-# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
-  return mHdr == GetAutoArrayBuffer(4) || mHdr == GetAutoArrayBuffer(8);
-}
-
-
-bool IsTwiceTheRequiredBytesRepresentableAsUint32(size_t aCapacity,
-                                                  size_t aElemSize);
-
-template<class Alloc, class Copy>
-template<typename ActualAlloc>
-typename ActualAlloc::ResultTypeProxy
-nsTArray_base<Alloc, Copy>::EnsureCapacity(size_type aCapacity,
-                                           size_type aElemSize)
-{
-
-  if (aCapacity <= mHdr->mCapacity) {
-    return ActualAlloc::SuccessResult();
-  }
-
-
-
-
-
-
-  if (!IsTwiceTheRequiredBytesRepresentableAsUint32(aCapacity, aElemSize)) {
-    ActualAlloc::SizeTooBig((size_t)aCapacity * aElemSize);
-    return ActualAlloc::FailureResult();
-  }
-
-  size_t reqSize = sizeof(Header) + aCapacity * aElemSize;
-
-  if (mHdr == EmptyHdr()) {
-
-    Header* header = static_cast<Header*>(ActualAlloc::Malloc(reqSize));
-    if (!header) {
-      return ActualAlloc::FailureResult();
-    }
-    header->mLength = 0;
-    header->mCapacity = aCapacity;
-    header->mIsAutoArray = 0;
-    mHdr = header;
-
-    return ActualAlloc::SuccessResult();
-  }
-
-
-
-
-
-  const size_t slowGrowthThreshold = 8 * 1024 * 1024;
-
-  size_t bytesToAlloc;
-  if (reqSize >= slowGrowthThreshold) {
-    size_t currSize = sizeof(Header) + Capacity() * aElemSize;
-    size_t minNewSize = currSize + (currSize >> 3);
-    bytesToAlloc = reqSize > minNewSize ? reqSize : minNewSize;
-
-
-    const size_t MiB = 1 << 20;
-    bytesToAlloc = MiB * ((bytesToAlloc + MiB - 1) / MiB);
-  } else {
-
-    bytesToAlloc = mozilla::RoundUpPow2(reqSize);
-  }
-
-  Header* header;
-  if (UsesAutoArrayBuffer() || !Copy::allowRealloc) {
-
-    header = static_cast<Header*>(ActualAlloc::Malloc(bytesToAlloc));
-    if (!header) {
-      return ActualAlloc::FailureResult();
-    }
-
-    Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize);
-
-    if (!UsesAutoArrayBuffer()) {
-      ActualAlloc::Free(mHdr);
-    }
-  } else {
-
-    header = static_cast<Header*>(ActualAlloc::Realloc(mHdr, bytesToAlloc));
-    if (!header) {
-      return ActualAlloc::FailureResult();
-    }
-  }
-
-
-  size_t newCapacity = (bytesToAlloc - sizeof(Header)) / aElemSize;
-  do { } while (0);
-  header->mCapacity = newCapacity;
-
-  mHdr = header;
-
-  return ActualAlloc::SuccessResult();
-}
-
-
-
-template<class Alloc, class Copy>
-void
-nsTArray_base<Alloc, Copy>::ShrinkCapacity(size_type aElemSize,
-                                           size_t aElemAlign)
-{
-  if (mHdr == EmptyHdr() || UsesAutoArrayBuffer()) {
-    return;
-  }
-
-  if (mHdr->mLength >= mHdr->mCapacity) {
-    return;
-  }
-
-  size_type length = Length();
-
-  if (IsAutoArray() && GetAutoArrayBuffer(aElemAlign)->mCapacity >= length) {
-    Header* header = GetAutoArrayBuffer(aElemAlign);
-
-
-    header->mLength = length;
-    Copy::MoveNonOverlappingRegion(header + 1, mHdr + 1, length, aElemSize);
-
-    nsTArrayFallibleAllocator::Free(mHdr);
-    mHdr = header;
-    return;
-  }
-
-  if (length == 0) {
-    do { } while (0);
-    nsTArrayFallibleAllocator::Free(mHdr);
-    mHdr = EmptyHdr();
-    return;
-  }
-
-  size_type size = sizeof(Header) + length * aElemSize;
-  void* ptr = nsTArrayFallibleAllocator::Realloc(mHdr, size);
-  if (!ptr) {
-    return;
-  }
-  mHdr = static_cast<Header*>(ptr);
-  mHdr->mCapacity = length;
-}
-
-template<class Alloc, class Copy>
-template<typename ActualAlloc>
-void
-nsTArray_base<Alloc, Copy>::ShiftData(index_type aStart,
-                                      size_type aOldLen, size_type aNewLen,
-                                      size_type aElemSize, size_t aElemAlign)
-{
-  if (aOldLen == aNewLen) {
-    return;
-  }
-
-
-  size_type num = mHdr->mLength - (aStart + aOldLen);
-
-
-  mHdr->mLength += aNewLen - aOldLen;
-  if (mHdr->mLength == 0) {
-    ShrinkCapacity(aElemSize, aElemAlign);
-  } else {
-
-    if (num == 0) {
-      return;
-    }
-
-    aStart *= aElemSize;
-    aNewLen *= aElemSize;
-    aOldLen *= aElemSize;
-    char* baseAddr = reinterpret_cast<char*>(mHdr + 1) + aStart;
-    Copy::MoveOverlappingRegion(baseAddr + aNewLen, baseAddr + aOldLen, num, aElemSize);
-  }
-}
-
-template<class Alloc, class Copy>
-template<typename ActualAlloc>
-bool
-nsTArray_base<Alloc, Copy>::InsertSlotsAt(index_type aIndex, size_type aCount,
-                                          size_type aElemSize,
-                                          size_t aElemAlign)
-{
-  if ((__builtin_expect(!!(aIndex > Length()), 0))) {
-    InvalidArrayIndex_CRASH(aIndex, Length());
-  }
-
-  size_type newLen = Length() + aCount;
-
-  EnsureCapacity<ActualAlloc>(newLen, aElemSize);
-
-
-  if (Capacity() < newLen) {
-    return false;
-  }
-
-
-
-  ShiftData<ActualAlloc>(aIndex, 0, aCount, aElemSize, aElemAlign);
-
-  return true;
-}
-# 311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
-template<class Alloc, class Copy>
-nsTArray_base<Alloc, Copy>::IsAutoArrayRestorer::IsAutoArrayRestorer(
-      nsTArray_base<Alloc, Copy>& aArray,
-      size_t aElemAlign)
-  : mArray(aArray)
-  , mElemAlign(aElemAlign)
-  , mIsAuto(aArray.IsAutoArray())
-{
-}
-
-template<class Alloc, class Copy>
-nsTArray_base<Alloc, Copy>::IsAutoArrayRestorer::~IsAutoArrayRestorer()
-{
-
-  if (mIsAuto && mArray.mHdr == mArray.EmptyHdr()) {
-
-
-    mArray.mHdr = mArray.GetAutoArrayBufferUnsafe(mElemAlign);
-    mArray.mHdr->mLength = 0;
-  } else if (mArray.mHdr != mArray.EmptyHdr()) {
-    mArray.mHdr->mIsAutoArray = mIsAuto;
-  }
-}
-
-template<class Alloc, class Copy>
-template<typename ActualAlloc, class Allocator>
-typename ActualAlloc::ResultTypeProxy
-nsTArray_base<Alloc, Copy>::SwapArrayElements(nsTArray_base<Allocator,
-                                                            Copy>& aOther,
-                                              size_type aElemSize,
-                                              size_t aElemAlign)
-{
-
-
-
-
-
-
-  IsAutoArrayRestorer ourAutoRestorer(*this, aElemAlign);
-  typename nsTArray_base<Allocator, Copy>::IsAutoArrayRestorer
-    otherAutoRestorer(aOther, aElemAlign);
-
-
-
-
-  if ((!UsesAutoArrayBuffer() || Capacity() < aOther.Length()) &&
-      (!aOther.UsesAutoArrayBuffer() || aOther.Capacity() < Length())) {
-
-    if (!EnsureNotUsingAutoArrayBuffer<ActualAlloc>(aElemSize) ||
-        !aOther.template EnsureNotUsingAutoArrayBuffer<ActualAlloc>(aElemSize)) {
-      return ActualAlloc::FailureResult();
-    }
-
-    Header* temp = mHdr;
-    mHdr = aOther.mHdr;
-    aOther.mHdr = temp;
-
-    return ActualAlloc::SuccessResult();
-  }
-# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray-inl.h"
-  if (!ActualAlloc::Successful(EnsureCapacity<ActualAlloc>(aOther.Length(), aElemSize)) ||
-      !Allocator::Successful(aOther.template EnsureCapacity<Allocator>(Length(), aElemSize))) {
-    return ActualAlloc::FailureResult();
-  }
-
-
-
-  do { } while (0);
-
-
-  size_type smallerLength = XPCOM_MIN(Length(), aOther.Length());
-  size_type largerLength = XPCOM_MAX(Length(), aOther.Length());
-  void* smallerElements;
-  void* largerElements;
-  if (Length() <= aOther.Length()) {
-    smallerElements = Hdr() + 1;
-    largerElements = aOther.Hdr() + 1;
-  } else {
-    smallerElements = aOther.Hdr() + 1;
-    largerElements = Hdr() + 1;
-  }
-
-
-
-
-
-
-  AutoTArray<nsTArray_Impl<uint8_t, ActualAlloc>, 64> temp;
-  if (!ActualAlloc::Successful(temp.template EnsureCapacity<ActualAlloc>(smallerLength,
-                                                                         aElemSize))) {
-    return ActualAlloc::FailureResult();
-  }
-
-  Copy::MoveNonOverlappingRegion(temp.Elements(), smallerElements, smallerLength, aElemSize);
-  Copy::MoveNonOverlappingRegion(smallerElements, largerElements, largerLength, aElemSize);
-  Copy::MoveNonOverlappingRegion(largerElements, temp.Elements(), smallerLength, aElemSize);
-
-
-  do { } while (0);
-
-
-  size_type tempLength = Length();
-
-
-
-  if (mHdr != EmptyHdr()) {
-    mHdr->mLength = aOther.Length();
-  }
-  if (aOther.mHdr != EmptyHdr()) {
-    aOther.mHdr->mLength = tempLength;
-  }
-
-  return ActualAlloc::SuccessResult();
-}
-
-template<class Alloc, class Copy>
-template<typename ActualAlloc>
-bool
-nsTArray_base<Alloc, Copy>::EnsureNotUsingAutoArrayBuffer(size_type aElemSize)
-{
-  if (UsesAutoArrayBuffer()) {
-
-
-
-
-
-    if (Length() == 0) {
-      mHdr = EmptyHdr();
-      return true;
-    }
-
-    size_type size = sizeof(Header) + Length() * aElemSize;
-
-    Header* header = static_cast<Header*>(ActualAlloc::Malloc(size));
-    if (!header) {
-      return false;
-    }
-
-    Copy::MoveNonOverlappingRegionWithHeader(header, mHdr, Length(), aElemSize);
-    header->mCapacity = Length();
-    mHdr = header;
-  }
-
-  return true;
-}
-# 2504 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTArray.h" 2
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleAutoArray.h" 2
-
-
-
-
-
-
-template<typename T>
-class nsStyleAutoArray
-{
-public:
-
-  enum WithSingleInitialElement { WITH_SINGLE_INITIAL_ELEMENT };
-  explicit nsStyleAutoArray(WithSingleInitialElement) {}
-  nsStyleAutoArray(const nsStyleAutoArray& aOther) { *this = aOther; }
-  nsStyleAutoArray& operator=(const nsStyleAutoArray& aOther) {
-    mFirstElement = aOther.mFirstElement;
-    mOtherElements = aOther.mOtherElements;
-    return *this;
-  }
-
-  bool operator==(const nsStyleAutoArray& aOther) const {
-    return Length() == aOther.Length() &&
-           mFirstElement == aOther.mFirstElement &&
-           mOtherElements == aOther.mOtherElements;
-  }
-  bool operator!=(const nsStyleAutoArray& aOther) const {
-    return !(*this == aOther);
-  }
-
-  nsStyleAutoArray& operator=(nsStyleAutoArray&& aOther) {
-    mFirstElement = aOther.mFirstElement;
-    mOtherElements.SwapElements(aOther.mOtherElements);
-
-    return *this;
-  }
-
-  size_t Length() const {
-    return mOtherElements.Length() + 1;
-  }
-  const T& operator[](size_t aIndex) const {
-    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
-  }
-  T& operator[](size_t aIndex) {
-    return aIndex == 0 ? mFirstElement : mOtherElements[aIndex - 1];
-  }
-
-  void EnsureLengthAtLeast(size_t aMinLen) {
-    if (aMinLen > 0) {
-      mOtherElements.EnsureLengthAtLeast(aMinLen - 1);
-    }
-  }
-
-  void SetLengthNonZero(size_t aNewLen) {
-    do { } while (0);
-    mOtherElements.SetLength(aNewLen - 1);
-  }
-
-  void TruncateLengthNonZero(size_t aNewLen) {
-    do { } while (0);
-    do { } while (0);
-    mOtherElements.TruncateLength(aNewLen - 1);
-  }
-
-private:
-  T mFirstElement;
-  nsTArray<T> mOtherElements;
-};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-
-
-struct RawServoStyleSet;
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
-
-
-
-
-
-
-
-
-struct ServoCssRules;
-struct RawServoStyleSheet;
-struct ServoComputedValues;
-struct RawServoDeclarationBlock;
-struct RawServoStyleRule;
-struct RawServoImportRule;
-struct RawServoAnimationValue;
-struct RawServoAnimationValueMap;
-struct RawServoMediaList;
-struct RawServoMediaRule;
-struct RawServoNamespaceRule;
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-
-
-namespace mozilla {
-  class ServoElementSnapshot;
-  struct StyleAnimation;
-namespace css {
-struct URLExtraData;
-}
-namespace dom {
-class Element;
-class StyleChildrenIterator;
-}
-struct AnimationPropertySegment;
-struct ComputedTiming;
-struct Keyframe;
-struct PropertyStyleAnimationValuePair;
-using ComputedKeyframeValues = nsTArray<PropertyStyleAnimationValuePair>;
-}
-
-class nsCSSValue;
-struct nsFontFaceRuleContainer;
-class nsIDocument;
-class nsINode;
-class nsPresContext;
-struct nsTimingFunction;
-
-using mozilla::dom::StyleChildrenIterator;
-using mozilla::ServoElementSnapshot;
-
-typedef nsINode RawGeckoNode;
-typedef mozilla::dom::Element RawGeckoElement;
-typedef nsIDocument RawGeckoDocument;
-typedef nsPresContext RawGeckoPresContext;
-typedef mozilla::css::URLExtraData RawGeckoURLExtraData;
-typedef nsTArray<mozilla::Keyframe> RawGeckoKeyframeList;
-typedef nsTArray<mozilla::ComputedKeyframeValues> RawGeckoComputedKeyframeValuesList;
-typedef nsTArray<mozilla::PropertyStyleAnimationValuePair> RawGeckoAnimationValueList;
-typedef nsStyleAutoArray<mozilla::StyleAnimation> RawGeckoStyleAnimationList;
-typedef nsTArray<nsFontFaceRuleContainer> RawGeckoFontFaceRuleList;
-typedef mozilla::AnimationPropertySegment RawGeckoAnimationPropertySegment;
-typedef mozilla::ComputedTiming RawGeckoComputedTiming;
-# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
-
-
-
-
-
-
-
-
-typedef ServoCssRules const* ServoCssRulesBorrowedOrNull; typedef ServoCssRules const* ServoCssRulesBorrowed; typedef ServoCssRules* ServoCssRulesBorrowedMut; struct ServoCssRulesStrong { ServoCssRules* mPtr; already_AddRefed<ServoCssRules> Consume(); };
-typedef RawServoStyleSheet const* RawServoStyleSheetBorrowedOrNull; typedef RawServoStyleSheet const* RawServoStyleSheetBorrowed; typedef RawServoStyleSheet* RawServoStyleSheetBorrowedMut; struct RawServoStyleSheetStrong { RawServoStyleSheet* mPtr; already_AddRefed<RawServoStyleSheet> Consume(); };
-typedef ServoComputedValues const* ServoComputedValuesBorrowedOrNull; typedef ServoComputedValues const* ServoComputedValuesBorrowed; typedef ServoComputedValues* ServoComputedValuesBorrowedMut; struct ServoComputedValuesStrong { ServoComputedValues* mPtr; already_AddRefed<ServoComputedValues> Consume(); };
-typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowedOrNull; typedef RawServoDeclarationBlock const* RawServoDeclarationBlockBorrowed; typedef RawServoDeclarationBlock* RawServoDeclarationBlockBorrowedMut; struct RawServoDeclarationBlockStrong { RawServoDeclarationBlock* mPtr; already_AddRefed<RawServoDeclarationBlock> Consume(); };
-typedef RawServoStyleRule const* RawServoStyleRuleBorrowedOrNull; typedef RawServoStyleRule const* RawServoStyleRuleBorrowed; typedef RawServoStyleRule* RawServoStyleRuleBorrowedMut; struct RawServoStyleRuleStrong { RawServoStyleRule* mPtr; already_AddRefed<RawServoStyleRule> Consume(); };
-typedef RawServoImportRule const* RawServoImportRuleBorrowedOrNull; typedef RawServoImportRule const* RawServoImportRuleBorrowed; typedef RawServoImportRule* RawServoImportRuleBorrowedMut; struct RawServoImportRuleStrong { RawServoImportRule* mPtr; already_AddRefed<RawServoImportRule> Consume(); };
-typedef RawServoAnimationValue const* RawServoAnimationValueBorrowedOrNull; typedef RawServoAnimationValue const* RawServoAnimationValueBorrowed; typedef RawServoAnimationValue* RawServoAnimationValueBorrowedMut; struct RawServoAnimationValueStrong { RawServoAnimationValue* mPtr; already_AddRefed<RawServoAnimationValue> Consume(); };
-typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowedOrNull; typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowed; typedef RawServoAnimationValueMap* RawServoAnimationValueMapBorrowedMut; struct RawServoAnimationValueMapStrong { RawServoAnimationValueMap* mPtr; already_AddRefed<RawServoAnimationValueMap> Consume(); };
-typedef RawServoMediaList const* RawServoMediaListBorrowedOrNull; typedef RawServoMediaList const* RawServoMediaListBorrowed; typedef RawServoMediaList* RawServoMediaListBorrowedMut; struct RawServoMediaListStrong { RawServoMediaList* mPtr; already_AddRefed<RawServoMediaList> Consume(); };
-typedef RawServoMediaRule const* RawServoMediaRuleBorrowedOrNull; typedef RawServoMediaRule const* RawServoMediaRuleBorrowed; typedef RawServoMediaRule* RawServoMediaRuleBorrowedMut; struct RawServoMediaRuleStrong { RawServoMediaRule* mPtr; already_AddRefed<RawServoMediaRule> Consume(); };
-typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowedOrNull; typedef RawServoNamespaceRule const* RawServoNamespaceRuleBorrowed; typedef RawServoNamespaceRule* RawServoNamespaceRuleBorrowedMut; struct RawServoNamespaceRuleStrong { RawServoNamespaceRule* mPtr; already_AddRefed<RawServoNamespaceRule> Consume(); };
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
-typedef RawServoDeclarationBlockStrong const* RawServoDeclarationBlockStrongBorrowedOrNull;
-
-typedef RawServoStyleSet* RawServoStyleSetOwned; typedef RawServoStyleSet const* RawServoStyleSetBorrowed; typedef RawServoStyleSet* RawServoStyleSetBorrowedMut;
-typedef StyleChildrenIterator* StyleChildrenIteratorOwnedOrNull; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowedOrNull; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMutOrNull;
-typedef StyleChildrenIterator* StyleChildrenIteratorOwned; typedef StyleChildrenIterator const* StyleChildrenIteratorBorrowed; typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut;
-typedef ServoElementSnapshot* ServoElementSnapshotOwned; typedef ServoElementSnapshot const* ServoElementSnapshotBorrowed; typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut;
-
-
-
-
-
-
-typedef RawGeckoNode const* RawGeckoNodeBorrowed;
-typedef RawGeckoNode const* RawGeckoNodeBorrowedOrNull;
-typedef RawGeckoElement const* RawGeckoElementBorrowed;
-typedef RawGeckoElement const* RawGeckoElementBorrowedOrNull;
-typedef RawGeckoDocument const* RawGeckoDocumentBorrowed;
-typedef RawGeckoDocument const* RawGeckoDocumentBorrowedOrNull;
-typedef StyleChildrenIterator* StyleChildrenIteratorBorrowedMut;
-typedef ServoElementSnapshot* ServoElementSnapshotBorrowedMut;
-typedef nsCSSValue const* nsCSSValueBorrowed;
-typedef nsCSSValue* nsCSSValueBorrowedMut;
-typedef RawGeckoPresContext* RawGeckoPresContextOwned; typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed; typedef RawGeckoPresContext* RawGeckoPresContextBorrowedMut;
-typedef RawGeckoPresContext const* RawGeckoPresContextBorrowed;
-typedef RawGeckoAnimationValueList* RawGeckoAnimationValueListBorrowedMut;
-typedef RawGeckoKeyframeList* RawGeckoKeyframeListBorrowedMut;
-typedef RawGeckoKeyframeList const* RawGeckoKeyframeListBorrowed;
-typedef RawGeckoComputedKeyframeValuesList* RawGeckoComputedKeyframeValuesListBorrowedMut;
-typedef RawGeckoStyleAnimationList const* RawGeckoStyleAnimationListBorrowed;
-typedef nsTimingFunction* nsTimingFunctionBorrowedMut;
-typedef nsTimingFunction const* nsTimingFunctionBorrowed;
-typedef RawGeckoFontFaceRuleList* RawGeckoFontFaceRuleListBorrowedMut;
-typedef RawGeckoAnimationPropertySegment const* RawGeckoAnimationPropertySegmentBorrowed;
-typedef RawGeckoComputedTiming const* RawGeckoComputedTimingBorrowed;
-# 164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
-
-
-
-
-
-
-
-
-extern "C" { void Servo_CssRules_AddRef( ServoCssRulesBorrowed ptr); void Servo_CssRules_Release( ServoCssRulesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<ServoCssRules> { static void AddRef(ServoCssRules* aPtr) { Servo_CssRules_AddRef(aPtr); } static void Release(ServoCssRules* aPtr) { Servo_CssRules_Release(aPtr); } }; }
-extern "C" { void Servo_StyleSheet_AddRef( RawServoStyleSheetBorrowed ptr); void Servo_StyleSheet_Release( RawServoStyleSheetBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoStyleSheet> { static void AddRef(RawServoStyleSheet* aPtr) { Servo_StyleSheet_AddRef(aPtr); } static void Release(RawServoStyleSheet* aPtr) { Servo_StyleSheet_Release(aPtr); } }; }
-extern "C" { void Servo_ComputedValues_AddRef( ServoComputedValuesBorrowed ptr); void Servo_ComputedValues_Release( ServoComputedValuesBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<ServoComputedValues> { static void AddRef(ServoComputedValues* aPtr) { Servo_ComputedValues_AddRef(aPtr); } static void Release(ServoComputedValues* aPtr) { Servo_ComputedValues_Release(aPtr); } }; }
-extern "C" { void Servo_DeclarationBlock_AddRef( RawServoDeclarationBlockBorrowed ptr); void Servo_DeclarationBlock_Release( RawServoDeclarationBlockBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoDeclarationBlock> { static void AddRef(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_AddRef(aPtr); } static void Release(RawServoDeclarationBlock* aPtr) { Servo_DeclarationBlock_Release(aPtr); } }; }
-extern "C" { void Servo_StyleRule_AddRef( RawServoStyleRuleBorrowed ptr); void Servo_StyleRule_Release( RawServoStyleRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoStyleRule> { static void AddRef(RawServoStyleRule* aPtr) { Servo_StyleRule_AddRef(aPtr); } static void Release(RawServoStyleRule* aPtr) { Servo_StyleRule_Release(aPtr); } }; }
-extern "C" { void Servo_ImportRule_AddRef( RawServoImportRuleBorrowed ptr); void Servo_ImportRule_Release( RawServoImportRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoImportRule> { static void AddRef(RawServoImportRule* aPtr) { Servo_ImportRule_AddRef(aPtr); } static void Release(RawServoImportRule* aPtr) { Servo_ImportRule_Release(aPtr); } }; }
-extern "C" { void Servo_AnimationValue_AddRef( RawServoAnimationValueBorrowed ptr); void Servo_AnimationValue_Release( RawServoAnimationValueBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoAnimationValue> { static void AddRef(RawServoAnimationValue* aPtr) { Servo_AnimationValue_AddRef(aPtr); } static void Release(RawServoAnimationValue* aPtr) { Servo_AnimationValue_Release(aPtr); } }; }
-extern "C" { void Servo_AnimationValueMap_AddRef( RawServoAnimationValueMapBorrowed ptr); void Servo_AnimationValueMap_Release( RawServoAnimationValueMapBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoAnimationValueMap> { static void AddRef(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_AddRef(aPtr); } static void Release(RawServoAnimationValueMap* aPtr) { Servo_AnimationValueMap_Release(aPtr); } }; }
-extern "C" { void Servo_MediaList_AddRef( RawServoMediaListBorrowed ptr); void Servo_MediaList_Release( RawServoMediaListBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoMediaList> { static void AddRef(RawServoMediaList* aPtr) { Servo_MediaList_AddRef(aPtr); } static void Release(RawServoMediaList* aPtr) { Servo_MediaList_Release(aPtr); } }; }
-extern "C" { void Servo_MediaRule_AddRef( RawServoMediaRuleBorrowed ptr); void Servo_MediaRule_Release( RawServoMediaRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoMediaRule> { static void AddRef(RawServoMediaRule* aPtr) { Servo_MediaRule_AddRef(aPtr); } static void Release(RawServoMediaRule* aPtr) { Servo_MediaRule_Release(aPtr); } }; }
-extern "C" { void Servo_NamespaceRule_AddRef( RawServoNamespaceRuleBorrowed ptr); void Servo_NamespaceRule_Release( RawServoNamespaceRuleBorrowed ptr); } namespace mozilla { template<> struct RefPtrTraits<RawServoNamespaceRule> { static void AddRef(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_AddRef(aPtr); } static void Release(RawServoNamespaceRule* aPtr) { Servo_NamespaceRule_Release(aPtr); } }; }
-# 165 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h" 2
-# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingTypes.h"
-extern "C" void Servo_StyleSet_Drop( RawServoStyleSetOwned ptr); namespace mozilla { template<> class DefaultDelete<RawServoStyleSet> { public: void operator()(RawServoStyleSet* aPtr) const { Servo_StyleSet_Drop(aPtr); } }; };
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-namespace mozilla {
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-class EventStates
-{
-public:
-  typedef uint64_t InternalType;
-  typedef uint64_t ServoType;
-
-  constexpr EventStates()
-    : mStates(0)
-  {
-  }
-
-
-
-
-
-
-  explicit constexpr EventStates(InternalType aStates)
-    : mStates(aStates)
-  {
-  }
-
-  EventStates constexpr operator|(const EventStates& aEventStates) const
-  {
-    return EventStates(mStates | aEventStates.mStates);
-  }
-
-  EventStates& operator|=(const EventStates& aEventStates)
-  {
-    mStates |= aEventStates.mStates;
-    return *this;
-  }
-
-
-
-
-  EventStates constexpr operator&(const EventStates& aEventStates) const
-  {
-    return EventStates(mStates & aEventStates.mStates);
-  }
-
-  EventStates& operator&=(const EventStates& aEventStates)
-  {
-    mStates &= aEventStates.mStates;
-    return *this;
-  }
-
-  bool operator==(const EventStates& aEventStates) const
-  {
-    return mStates == aEventStates.mStates;
-  }
-
-  bool operator!=(const EventStates& aEventStates) const
-  {
-    return mStates != aEventStates.mStates;
-  }
-
-  EventStates operator~() const
-  {
-    return EventStates(~mStates);
-  }
-
-  EventStates operator^(const EventStates& aEventStates) const
-  {
-    return EventStates(mStates ^ aEventStates.mStates);
-  }
-
-  EventStates& operator^=(const EventStates& aEventStates)
-  {
-    mStates ^= aEventStates.mStates;
-    return *this;
-  }
-
-
-
-
-
-
-
-  bool IsEmpty() const
-  {
-    return mStates == 0;
-  }
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-  bool HasState(EventStates aEventStates) const
-  {
-# 124 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-    return mStates & aEventStates.mStates;
-  }
-# 135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-  bool HasAtLeastOneOfStates(EventStates aEventStates) const
-  {
-    return mStates & aEventStates.mStates;
-  }
-# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventStates.h"
-  bool HasAllStates(EventStates aEventStates) const
-  {
-    return (mStates & aEventStates.mStates) == aEventStates.mStates;
-  }
-
-
-
-  InternalType GetInternalValue() const {
-    return mStates;
-  }
-
-
-
-
-  ServoType ServoValue() const
-  {
-    return mStates;
-  }
-
-private:
-  InternalType mStates;
-};
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h"
-class nsAttrName;
-class nsAttrValue;
-
-namespace mozilla {
-namespace dom {
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BorrowedAttrInfo.h"
-struct BorrowedAttrInfo
-{
-  BorrowedAttrInfo()
-    : mName(nullptr)
-    , mValue(nullptr)
-  {
-  }
-
-  BorrowedAttrInfo(const nsAttrName* aName, const nsAttrValue* aValue);
-
-  BorrowedAttrInfo(const BorrowedAttrInfo& aOther);
-
-  const nsAttrName* mName;
-  const nsAttrValue* mValue;
-
-  explicit operator bool() const { return mName != nullptr; }
-};
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAnnotations.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-namespace mozilla {
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-struct FloatTypeTraits
-{
-  typedef uint32_t Bits;
-
-  static const unsigned kExponentBias = 127;
-  static const unsigned kExponentShift = 23;
-
-  static const Bits kSignBit = 0x80000000UL;
-  static const Bits kExponentBits = 0x7F800000UL;
-  static const Bits kSignificandBits = 0x007FFFFFUL;
-};
-
-struct DoubleTypeTraits
-{
-  typedef uint64_t Bits;
-
-  static const unsigned kExponentBias = 1023;
-  static const unsigned kExponentShift = 52;
-
-  static const Bits kSignBit = 0x8000000000000000ULL;
-  static const Bits kExponentBits = 0x7ff0000000000000ULL;
-  static const Bits kSignificandBits = 0x000fffffffffffffULL;
-};
-
-template<typename T> struct SelectTrait;
-template<> struct SelectTrait<float> : public FloatTypeTraits {};
-template<> struct SelectTrait<double> : public DoubleTypeTraits {};
-# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-struct FloatingPoint : public SelectTrait<T>
-{
-  typedef SelectTrait<T> Base;
-  typedef typename Base::Bits Bits;
-
-  static_assert((Base::kSignBit & Base::kExponentBits) == 0,
-                "sign bit shouldn't overlap exponent bits");
-  static_assert((Base::kSignBit & Base::kSignificandBits) == 0,
-                "sign bit shouldn't overlap significand bits");
-  static_assert((Base::kExponentBits & Base::kSignificandBits) == 0,
-                "exponent bits shouldn't overlap significand bits");
-
-  static_assert((Base::kSignBit | Base::kExponentBits | Base::kSignificandBits) ==
-                ~Bits(0),
-                "all bits accounted for");
-# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-  static_assert(sizeof(T) == sizeof(Bits), "Bits must be same size as T");
-};
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsNaN(T aValue)
-{
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  return (BitwiseCast<Bits>(aValue) & Traits::kExponentBits) == Traits::kExponentBits &&
-         (BitwiseCast<Bits>(aValue) & Traits::kSignificandBits) != 0;
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsInfinite(T aValue)
-{
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return (bits & ~Traits::kSignBit) == Traits::kExponentBits;
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsFinite(T aValue)
-{
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return (bits & Traits::kExponentBits) != Traits::kExponentBits;
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsNegative(T aValue)
-{
-  do { } while (0);
-
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return (bits & Traits::kSignBit) != 0;
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsNegativeZero(T aValue)
-{
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return bits == Traits::kSignBit;
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline bool
-IsPositiveZero(T aValue)
-{
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return bits == 0;
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-ToZeroIfNonfinite(T aValue)
-{
-  return IsFinite(aValue) ? aValue : 0;
-}
-
-
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline int_fast16_t
-ExponentComponent(T aValue)
-{
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  Bits bits = BitwiseCast<Bits>(aValue);
-  return int_fast16_t((bits & Traits::kExponentBits) >> Traits::kExponentShift) -
-         int_fast16_t(Traits::kExponentBias);
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-PositiveInfinity()
-{
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  return BitwiseCast<T>(Traits::kExponentBits);
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-NegativeInfinity()
-{
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  return BitwiseCast<T>(Traits::kSignBit | Traits::kExponentBits);
-}
-
-
-
-
-
-template<typename T,
-         int SignBit,
-         typename FloatingPoint<T>::Bits Significand>
-struct SpecificNaNBits
-{
-  using Traits = FloatingPoint<T>;
-
-  static_assert(SignBit == 0 || SignBit == 1, "bad sign bit");
-  static_assert((Significand & ~Traits::kSignificandBits) == 0,
-                "significand must only have significand bits set");
-  static_assert(Significand & Traits::kSignificandBits,
-                "significand must be nonzero");
-
-  static constexpr typename Traits::Bits value =
-    (SignBit * Traits::kSignBit) | Traits::kExponentBits | Significand;
-};
-# 296 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-static __attribute__((always_inline)) inline void
-SpecificNaN(int signbit, typename FloatingPoint<T>::Bits significand, T* result)
-{
-  typedef FloatingPoint<T> Traits;
-  do { } while (0);
-  do { } while (0);
-  do { } while (0);
-
-  BitwiseCast<T>((signbit ? Traits::kSignBit : 0) |
-                  Traits::kExponentBits |
-                  significand,
-                  result);
-  do { } while (0);
-}
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-SpecificNaN(int signbit, typename FloatingPoint<T>::Bits significand)
-{
-  T t;
-  SpecificNaN(signbit, significand, &t);
-  return t;
-}
-
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-MinNumberValue()
-{
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  return BitwiseCast<T>(Bits(1));
-}
-# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-static __attribute__((always_inline)) inline bool
-NumberEqualsInt32(T aValue, int32_t* aInt32)
-{
-
-
-
-
-
-
-  return aValue == (*aInt32 = int32_t(aValue));
-}
-# 358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-static __attribute__((always_inline)) inline bool
-NumberIsInt32(T aValue, int32_t* aInt32)
-{
-  return !IsNegativeZero(aValue) && NumberEqualsInt32(aValue, aInt32);
-}
-
-
-
-
-
-template<typename T>
-static __attribute__((always_inline)) inline T
-UnspecifiedNaN()
-{
-
-
-
-
-
-
-  typedef FloatingPoint<T> Traits;
-  return SpecificNaN<T>(1, Traits::kSignificandBits);
-}
-
-
-
-
-
-
-template<typename T>
-static inline bool
-NumbersAreIdentical(T aValue1, T aValue2)
-{
-  typedef FloatingPoint<T> Traits;
-  typedef typename Traits::Bits Bits;
-  if (IsNaN(aValue1)) {
-    return IsNaN(aValue2);
-  }
-  return BitwiseCast<Bits>(aValue1) == BitwiseCast<Bits>(aValue2);
-}
-
-namespace detail {
-
-template<typename T>
-struct FuzzyEqualsEpsilon;
-
-template<>
-struct FuzzyEqualsEpsilon<float>
-{
-
-  static float value() { return 1.0f / (1 << 17); }
-};
-
-template<>
-struct FuzzyEqualsEpsilon<double>
-{
-
-  static double value() { return 1.0 / (1LL << 40); }
-};
-
-}
-# 433 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-static __attribute__((always_inline)) inline bool
-FuzzyEqualsAdditive(T aValue1, T aValue2,
-                    T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
-{
-  static_assert(IsFloatingPoint<T>::value, "floating point type required");
-  return Abs(aValue1 - aValue2) <= aEpsilon;
-}
-# 454 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-template<typename T>
-static __attribute__((always_inline)) inline bool
-FuzzyEqualsMultiplicative(T aValue1, T aValue2,
-                          T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
-{
-  static_assert(IsFloatingPoint<T>::value, "floating point type required");
-
-  T smaller = Abs(aValue1) < Abs(aValue2) ? Abs(aValue1) : Abs(aValue2);
-  return Abs(aValue1 - aValue2) <= aEpsilon * smaller;
-}
-# 473 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FloatingPoint.h"
-__attribute__ ((warn_unused_result))
-extern __attribute__((weak)) __attribute__((visibility("default"))) bool
-IsFloat32Representable(double aFloat32);
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h" 2
-
-
-
-namespace IPC {
-template<typename T> struct ParamTraits;
-}
-
-
-
-
-
-
-
-namespace mozilla {
-
-
-typedef uint64_t TimeStampValue;
-
-
-class TimeStamp;
-
-
-
-
-class BaseTimeDurationPlatformUtils
-{
-public:
-  static __attribute__((weak)) __attribute__((visibility("default"))) double ToSeconds(int64_t aTicks);
-  static __attribute__((weak)) __attribute__((visibility("default"))) double ToSecondsSigDigits(int64_t aTicks);
-  static __attribute__((weak)) __attribute__((visibility("default"))) int64_t TicksFromMilliseconds(double aMilliseconds);
-  static __attribute__((weak)) __attribute__((visibility("default"))) int64_t ResolutionInTicks();
-};
-# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-template <typename ValueCalculator>
-class BaseTimeDuration
-{
-public:
-
-  constexpr BaseTimeDuration() : mValue(0) {}
-
-
-  struct _SomethingVeryRandomHere;
-               BaseTimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0)
-  {
-    do { } while (0);
-  }
-
-
-
-  template <typename E>
-  explicit BaseTimeDuration(const BaseTimeDuration<E>& aOther)
-    : mValue(aOther.mValue)
-  { }
-
-  template <typename E>
-  BaseTimeDuration& operator=(const BaseTimeDuration<E>& aOther)
-  {
-    mValue = aOther.mValue;
-    return *this;
-  }
-
-  double ToSeconds() const
-  {
-    if (mValue == (9223372036854775807L)) {
-      return PositiveInfinity<double>();
-    }
-    if (mValue == (-9223372036854775807L -1)) {
-      return NegativeInfinity<double>();
-    }
-    return BaseTimeDurationPlatformUtils::ToSeconds(mValue);
-  }
-
-
-
-  double ToSecondsSigDigits() const
-  {
-    if (mValue == (9223372036854775807L)) {
-      return PositiveInfinity<double>();
-    }
-    if (mValue == (-9223372036854775807L -1)) {
-      return NegativeInfinity<double>();
-    }
-    return BaseTimeDurationPlatformUtils::ToSecondsSigDigits(mValue);
-  }
-  double ToMilliseconds() const { return ToSeconds() * 1000.0; }
-  double ToMicroseconds() const { return ToMilliseconds() * 1000.0; }
-
-
-
-
-
-
-  static inline BaseTimeDuration FromSeconds(double aSeconds)
-  {
-    return FromMilliseconds(aSeconds * 1000.0);
-  }
-  static BaseTimeDuration FromMilliseconds(double aMilliseconds)
-  {
-    if (aMilliseconds == PositiveInfinity<double>()) {
-      return Forever();
-    }
-    if (aMilliseconds == NegativeInfinity<double>()) {
-      return FromTicks((-9223372036854775807L -1));
-    }
-    return FromTicks(
-      BaseTimeDurationPlatformUtils::TicksFromMilliseconds(aMilliseconds));
-  }
-  static inline BaseTimeDuration FromMicroseconds(double aMicroseconds)
-  {
-    return FromMilliseconds(aMicroseconds / 1000.0);
-  }
-
-  static BaseTimeDuration Forever()
-  {
-    return FromTicks((9223372036854775807L));
-  }
-
-  BaseTimeDuration operator+(const BaseTimeDuration& aOther) const
-  {
-    return FromTicks(ValueCalculator::Add(mValue, aOther.mValue));
-  }
-  BaseTimeDuration operator-(const BaseTimeDuration& aOther) const
-  {
-    return FromTicks(ValueCalculator::Subtract(mValue, aOther.mValue));
-  }
-  BaseTimeDuration& operator+=(const BaseTimeDuration& aOther)
-  {
-    mValue = ValueCalculator::Add(mValue, aOther.mValue);
-    return *this;
-  }
-  BaseTimeDuration& operator-=(const BaseTimeDuration& aOther)
-  {
-    mValue = ValueCalculator::Subtract(mValue, aOther.mValue);
-    return *this;
-  }
-  BaseTimeDuration operator-() const
-  {
-
-
-    int64_t ticks;
-    if (mValue == (9223372036854775807L)) {
-      ticks = (-9223372036854775807L -1);
-    } else if (mValue == (-9223372036854775807L -1)) {
-      ticks = (9223372036854775807L);
-    } else {
-      ticks = -mValue;
-    }
-
-    return FromTicks(ticks);
-  }
-
-  static BaseTimeDuration Max(const BaseTimeDuration& aA,
-                              const BaseTimeDuration& aB)
-  {
-    return FromTicks(std::max(aA.mValue, aB.mValue));
-  }
-  static BaseTimeDuration Min(const BaseTimeDuration& aA,
-                              const BaseTimeDuration& aB)
-  {
-    return FromTicks(std::min(aA.mValue, aB.mValue));
-  }
-
-private:
-
-
-  BaseTimeDuration operator*(const double aMultiplier) const = delete;
-
-
-
-
-  BaseTimeDuration operator/(const double aDivisor) const = delete;
-
-public:
-  BaseTimeDuration MultDouble(double aMultiplier) const
-  {
-    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
-  }
-  BaseTimeDuration operator*(const int32_t aMultiplier) const
-  {
-    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
-  }
-  BaseTimeDuration operator*(const uint32_t aMultiplier) const
-  {
-    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
-  }
-  BaseTimeDuration operator*(const int64_t aMultiplier) const
-  {
-    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
-  }
-  BaseTimeDuration operator*(const uint64_t aMultiplier) const
-  {
-    if (aMultiplier > (9223372036854775807L)) {
-      return Forever();
-    }
-    return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
-  }
-  BaseTimeDuration operator/(const int64_t aDivisor) const
-  {
-    do { } while (0);
-    return FromTicks(ValueCalculator::Divide(mValue, aDivisor));
-  }
-  double operator/(const BaseTimeDuration& aOther) const
-  {
-
-
-    do { } while (0);
-
-    return ValueCalculator::DivideDouble(mValue, aOther.mValue);
-  }
-  BaseTimeDuration operator%(const BaseTimeDuration& aOther) const
-  {
-    do { } while (0);
-    return FromTicks(ValueCalculator::Modulo(mValue, aOther.mValue));
-  }
-
-  template<typename E>
-  bool operator<(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue < aOther.mValue;
-  }
-  template<typename E>
-  bool operator<=(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue <= aOther.mValue;
-  }
-  template<typename E>
-  bool operator>=(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue >= aOther.mValue;
-  }
-  template<typename E>
-  bool operator>(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue > aOther.mValue;
-  }
-  template<typename E>
-  bool operator==(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue == aOther.mValue;
-  }
-  template<typename E>
-  bool operator!=(const BaseTimeDuration<E>& aOther) const
-  {
-    return mValue != aOther.mValue;
-  }
-  bool IsZero() const
-  {
-    return mValue == 0;
-  }
-  explicit operator bool() const
-  {
-    return mValue != 0;
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream,
-                                  const BaseTimeDuration& aDuration) {
-    return aStream << aDuration.ToMilliseconds() << " ms";
-  }
-
-
-
-
-
-  static BaseTimeDuration Resolution() {
-    return FromTicks(BaseTimeDurationPlatformUtils::ResolutionInTicks());
-  }
-# 303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-private:
-  friend class TimeStamp;
-  friend struct IPC::ParamTraits<mozilla::BaseTimeDuration<ValueCalculator>>;
-  template <typename>
-  friend class BaseTimeDuration;
-
-  static BaseTimeDuration FromTicks(int64_t aTicks)
-  {
-    BaseTimeDuration t;
-    t.mValue = aTicks;
-    return t;
-  }
-
-  static BaseTimeDuration FromTicks(double aTicks)
-  {
-
-
-    if (aTicks >= double((9223372036854775807L))) {
-      return FromTicks((9223372036854775807L));
-    }
-
-
-    if (aTicks <= double((-9223372036854775807L -1))) {
-      return FromTicks((-9223372036854775807L -1));
-    }
-
-    return FromTicks(int64_t(aTicks));
-  }
-
-
-  int64_t mValue;
-};
-
-
-
-
-
-class TimeDurationValueCalculator
-{
-public:
-  static int64_t Add(int64_t aA, int64_t aB) { return aA + aB; }
-  static int64_t Subtract(int64_t aA, int64_t aB) { return aA - aB; }
-
-  template <typename T>
-  static int64_t Multiply(int64_t aA, T aB)
-  {
-    static_assert(IsIntegral<T>::value,
-                  "Using integer multiplication routine with non-integer type."
-                  " Further specialization required");
-    return aA * static_cast<int64_t>(aB);
-  }
-
-  static int64_t Divide(int64_t aA, int64_t aB) { return aA / aB; }
-  static double DivideDouble(int64_t aA, int64_t aB)
-  {
-    return static_cast<double>(aA) / aB;
-  }
-  static int64_t Modulo(int64_t aA, int64_t aB) { return aA % aB; }
-};
-
-template <>
-inline int64_t
-TimeDurationValueCalculator::Multiply<double>(int64_t aA, double aB)
-{
-  return static_cast<int64_t>(aA * aB);
-}
-# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-typedef BaseTimeDuration<TimeDurationValueCalculator> TimeDuration;
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-class TimeStamp
-{
-public:
-
-
-
-  constexpr TimeStamp() : mValue(0) {}
-# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-  bool IsNull() const { return mValue == 0; }
-
-
-
-
-
-  explicit operator bool() const
-  {
-    return mValue != 0;
-  }
-# 467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-  static TimeStamp Now() { return Now(true); }
-  static TimeStamp NowLoRes() { return Now(false); }
-# 482 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-  static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp ProcessCreation(bool& aIsInconsistent);
-
-
-
-
-
-
-  static __attribute__((weak)) __attribute__((visibility("default"))) void RecordProcessRestart();
-
-
-
-
-  TimeDuration operator-(const TimeStamp& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-    static_assert(-(9223372036854775807L) > (-9223372036854775807L -1), "int64_t sanity check");
-    int64_t ticks = int64_t(mValue - aOther.mValue);
-
-    if (mValue > aOther.mValue) {
-      if (ticks < 0) {
-        ticks = (9223372036854775807L);
-      }
-    } else {
-      if (ticks > 0) {
-        ticks = (-9223372036854775807L -1);
-      }
-    }
-    return TimeDuration::FromTicks(ticks);
-  }
-
-  TimeStamp operator+(const TimeDuration& aOther) const
-  {
-    TimeStamp result = *this;
-    result += aOther;
-    return result;
-  }
-  TimeStamp operator-(const TimeDuration& aOther) const
-  {
-    TimeStamp result = *this;
-    result -= aOther;
-    return result;
-  }
-  TimeStamp& operator+=(const TimeDuration& aOther)
-  {
-    do { } while (0);
-    TimeStampValue value = mValue + aOther.mValue;
-
-
-
-    if (aOther.mValue < 0 && value > mValue) {
-      value = 0;
-    }
-    mValue = value;
-    return *this;
-  }
-  TimeStamp& operator-=(const TimeDuration& aOther)
-  {
-    do { } while (0);
-    TimeStampValue value = mValue - aOther.mValue;
-
-
-
-    if (aOther.mValue > 0 && value > mValue) {
-      value = 0;
-    }
-    mValue = value;
-    return *this;
-  }
-
-  bool operator<(const TimeStamp& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mValue < aOther.mValue;
-  }
-  bool operator<=(const TimeStamp& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mValue <= aOther.mValue;
-  }
-  bool operator>=(const TimeStamp& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mValue >= aOther.mValue;
-  }
-  bool operator>(const TimeStamp& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mValue > aOther.mValue;
-  }
-  bool operator==(const TimeStamp& aOther) const
-  {
-    return IsNull()
-           ? aOther.IsNull()
-           : !aOther.IsNull() && mValue == aOther.mValue;
-  }
-  bool operator!=(const TimeStamp& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-
-
-
-
-  static __attribute__((weak)) __attribute__((visibility("default"))) void Startup();
-  static __attribute__((weak)) __attribute__((visibility("default"))) void Shutdown();
-
-private:
-  friend struct IPC::ParamTraits<mozilla::TimeStamp>;
-  friend void StartupTimelineRecordExternal(int, uint64_t);
-
-               TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
-
-  static __attribute__((weak)) __attribute__((visibility("default"))) TimeStamp Now(bool aHighResolution);
-# 610 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-  static __attribute__((weak)) __attribute__((visibility("default"))) uint64_t ComputeProcessUptime();
-# 625 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TimeStamp.h"
-  TimeStampValue mValue;
-};
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h" 2
-
-namespace mozilla {
-# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AllocPolicy.h"
-class MallocAllocPolicy
-{
-public:
-  template <typename T>
-  T* maybe_pod_malloc(size_t aNumElems)
-  {
-    if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
-      return nullptr;
-    }
-    return static_cast<T*>(malloc(aNumElems * sizeof(T)));
-  }
-
-  template <typename T>
-  T* maybe_pod_calloc(size_t aNumElems)
-  {
-    return static_cast<T*>(calloc(aNumElems, sizeof(T)));
-  }
-
-  template <typename T>
-  T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
-  {
-    if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
-      return nullptr;
-    }
-    return static_cast<T*>(realloc(aPtr, aNewSize * sizeof(T)));
-  }
-
-  template <typename T>
-  T* pod_malloc(size_t aNumElems)
-  {
-    return maybe_pod_malloc<T>(aNumElems);
-  }
-
-  template <typename T>
-  T* pod_calloc(size_t aNumElems)
-  {
-    return maybe_pod_calloc<T>(aNumElems);
-  }
-
-  template <typename T>
-  T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
-  {
-    return maybe_pod_realloc<T>(aPtr, aOldSize, aNewSize);
-  }
-
-  void free_(void* aPtr)
-  {
-    free(aPtr);
-  }
-
-  void reportAllocOverflow() const
-  {
-  }
-
-  __attribute__ ((warn_unused_result)) bool checkSimulatedOOM() const
-  {
-    return true;
-  }
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ReentrancyGuard.h"
-namespace mozilla {
-
-
-class ReentrancyGuard
-{
-
-
-
-
-
-public:
-  template<class T>
-
-
-
-
-
-  explicit ReentrancyGuard(T&
-                                                          )
-
-  {
-    do { } while (0);
-
-
-
-
-  }
-  ~ReentrancyGuard()
-  {
-
-
-
-  }
-
-private:
-  ReentrancyGuard(const ReentrancyGuard&) = delete;
-  void operator=(const ReentrancyGuard&) = delete;
-};
-
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h" 2
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-namespace mozilla {
-
-template<typename T, size_t N, class AllocPolicy>
-class Vector;
-
-namespace detail {
-
-
-
-
-
-
-template<typename T>
-static bool CapacityHasExcessSpace(size_t aCapacity)
-{
-  size_t size = aCapacity * sizeof(T);
-  return RoundUpPow2(size) - size >= sizeof(T);
-}
-
-
-
-
-
-template<typename T, size_t N, class AP, bool IsPod>
-struct VectorImpl
-{
-
-
-
-  template<typename... Args>
-  __attribute__ ((nonnull(1)))
-  static inline void new_(T* aDst, Args&&... aArgs)
-  {
-    new(KnownNotNull, aDst) T(Forward<Args>(aArgs)...);
-  }
-
-
-  static inline void destroy(T* aBegin, T* aEnd)
-  {
-    do { } while (0);
-    for (T* p = aBegin; p < aEnd; ++p) {
-      p->~T();
-    }
-  }
-
-
-  static inline void initialize(T* aBegin, T* aEnd)
-  {
-    do { } while (0);
-    for (T* p = aBegin; p < aEnd; ++p) {
-      new_(p);
-    }
-  }
-
-
-
-
-
-  template<typename U>
-  static inline void copyConstruct(T* aDst,
-                                   const U* aSrcStart, const U* aSrcEnd)
-  {
-    do { } while (0);
-    for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
-      new_(aDst, *p);
-    }
-  }
-
-
-
-
-
-  template<typename U>
-  static inline void moveConstruct(T* aDst, U* aSrcStart, U* aSrcEnd)
-  {
-    do { } while (0);
-    for (U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
-      new_(aDst, Move(*p));
-    }
-  }
-
-
-
-
-
-  template<typename U>
-  static inline void copyConstructN(T* aDst, size_t aN, const U& aU)
-  {
-    for (T* end = aDst + aN; aDst < end; ++aDst) {
-      new_(aDst, aU);
-    }
-  }
-
-
-
-
-
-
-
-  static inline __attribute__ ((warn_unused_result)) bool
-  growTo(Vector<T, N, AP>& aV, size_t aNewCap)
-  {
-    do { } while (0);
-    do { } while (0);
-    T* newbuf = aV.template pod_malloc<T>(aNewCap);
-    if ((__builtin_expect(!!(!newbuf), 0))) {
-      return false;
-    }
-    T* dst = newbuf;
-    T* src = aV.beginNoCheck();
-    for (; src < aV.endNoCheck(); ++dst, ++src) {
-      new_(dst, Move(*src));
-    }
-    VectorImpl::destroy(aV.beginNoCheck(), aV.endNoCheck());
-    aV.free_(aV.mBegin);
-    aV.mBegin = newbuf;
-
-    aV.mTail.mCapacity = aNewCap;
-    return true;
-  }
-};
-
-
-
-
-
-
-template<typename T, size_t N, class AP>
-struct VectorImpl<T, N, AP, true>
-{
-  template<typename... Args>
-  __attribute__ ((nonnull(1)))
-  static inline void new_(T* aDst, Args&&... aArgs)
-  {
-
-
-
-
-    T temp(Forward<Args>(aArgs)...);
-    *aDst = temp;
-  }
-
-  static inline void destroy(T*, T*) {}
-
-  static inline void initialize(T* aBegin, T* aEnd)
-  {
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-    do { } while (0);
-    for (T* p = aBegin; p < aEnd; ++p) {
-      new_(p);
-    }
-  }
-
-  template<typename U>
-  static inline void copyConstruct(T* aDst,
-                                   const U* aSrcStart, const U* aSrcEnd)
-  {
-
-
-
-
-
-
-
-    do { } while (0);
-    for (const U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
-      new_(aDst, *p);
-    }
-  }
-
-  template<typename U>
-  static inline void moveConstruct(T* aDst,
-                                   const U* aSrcStart, const U* aSrcEnd)
-  {
-    copyConstruct(aDst, aSrcStart, aSrcEnd);
-  }
-
-  static inline void copyConstructN(T* aDst, size_t aN, const T& aT)
-  {
-    for (T* end = aDst + aN; aDst < end; ++aDst) {
-      new_(aDst, aT);
-    }
-  }
-
-  static inline __attribute__ ((warn_unused_result)) bool
-  growTo(Vector<T, N, AP>& aV, size_t aNewCap)
-  {
-    do { } while (0);
-    do { } while (0);
-    T* newbuf =
-      aV.template pod_realloc<T>(aV.mBegin, aV.mTail.mCapacity, aNewCap);
-    if ((__builtin_expect(!!(!newbuf), 0))) {
-      return false;
-    }
-    aV.mBegin = newbuf;
-
-    aV.mTail.mCapacity = aNewCap;
-    return true;
-  }
-
-  static inline void
-  podResizeToFit(Vector<T, N, AP>& aV)
-  {
-    if (aV.usingInlineStorage() || aV.mLength == aV.mTail.mCapacity) {
-      return;
-    }
-    T* newbuf =
-      aV.template pod_realloc<T>(aV.mBegin, aV.mTail.mCapacity, aV.mLength);
-    if ((__builtin_expect(!!(!newbuf), 0))) {
-      return;
-    }
-    aV.mBegin = newbuf;
-    aV.mTail.mCapacity = aV.mLength;
-  }
-};
-
-
-
-struct VectorTesting;
-
-}
-# 280 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-template<typename T,
-         size_t MinInlineCapacity = 0,
-         class AllocPolicy = MallocAllocPolicy>
-class Vector final : private AllocPolicy
-{
-
-
-  static const bool kElemIsPod = IsPod<T>::value;
-  typedef detail::VectorImpl<T, MinInlineCapacity, AllocPolicy, kElemIsPod> Impl;
-  friend struct detail::VectorImpl<T, MinInlineCapacity, AllocPolicy, kElemIsPod>;
-
-  friend struct detail::VectorTesting;
-
-  __attribute__ ((warn_unused_result)) bool growStorageBy(size_t aIncr);
-  __attribute__ ((warn_unused_result)) bool convertToHeapStorage(size_t aNewCap);
-  __attribute__ ((warn_unused_result)) bool maybeCheckSimulatedOOM(size_t aRequestedSize);
-# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  static constexpr size_t kMaxInlineBytes =
-    1024 - (sizeof(AllocPolicy) + sizeof(T*) + sizeof(size_t) + sizeof(size_t));
-# 317 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  template<size_t MinimumInlineCapacity, size_t Dummy>
-  struct ComputeCapacity
-  {
-    static constexpr size_t value =
-      tl::Min<MinimumInlineCapacity, kMaxInlineBytes / sizeof(T)>::value;
-  };
-
-  template<size_t Dummy>
-  struct ComputeCapacity<0, Dummy>
-  {
-    static constexpr size_t value = 0;
-  };
-
-
-  static constexpr size_t kInlineCapacity =
-    ComputeCapacity<MinInlineCapacity, 0>::value;
-# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  T* mBegin;
-
-
-  size_t mLength;
-# 367 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  struct CapacityAndReserved
-  {
-    explicit CapacityAndReserved(size_t aCapacity, size_t aReserved)
-      : mCapacity(aCapacity)
-
-
-
-    {}
-    CapacityAndReserved() = default;
-
-
-    size_t mCapacity;
-
-
-
-
-
-  };
-# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  template<size_t Capacity, size_t Dummy>
-  struct CRAndStorage : CapacityAndReserved
-  {
-    explicit CRAndStorage(size_t aCapacity, size_t aReserved)
-      : CapacityAndReserved(aCapacity, aReserved)
-    {}
-    CRAndStorage() = default;
-
-    alignas(T) unsigned char mBytes[Capacity * sizeof(T)];
-
-
-
-    void* data() { return mBytes; }
-
-    T* storage() { return static_cast<T*>(data()); }
-  };
-
-  template<size_t Dummy>
-  struct CRAndStorage<0, Dummy> : CapacityAndReserved
-  {
-    explicit CRAndStorage(size_t aCapacity, size_t aReserved)
-      : CapacityAndReserved(aCapacity, aReserved)
-    {}
-    CRAndStorage() = default;
-
-    T* storage() { return nullptr; }
-  };
-
-  CRAndStorage<kInlineCapacity, 0> mTail;
-# 434 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  bool usingInlineStorage() const
-  {
-    return mBegin == const_cast<Vector*>(this)->inlineStorage();
-  }
-
-  T* inlineStorage()
-  {
-    return mTail.storage();
-  }
-
-  T* beginNoCheck() const
-  {
-    return mBegin;
-  }
-
-  T* endNoCheck()
-  {
-    return mBegin + mLength;
-  }
-
-  const T* endNoCheck() const
-  {
-    return mBegin + mLength;
-  }
-# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  template<typename U> void internalAppend(U&& aU);
-  template<typename U, size_t O, class BP>
-  void internalAppendAll(const Vector<U, O, BP>& aU);
-  void internalAppendN(const T& aT, size_t aN);
-  template<typename U> void internalAppend(const U* aBegin, size_t aLength);
-
-public:
-  static const size_t sMaxInlineStorage = MinInlineCapacity;
-
-  typedef T ElementType;
-
-  explicit Vector(AllocPolicy = AllocPolicy());
-  Vector(Vector&&);
-  Vector& operator=(Vector&&);
-  ~Vector();
-
-
-
-  const AllocPolicy& allocPolicy() const { return *this; }
-
-  AllocPolicy& allocPolicy() { return *this; }
-
-  enum { InlineLength = MinInlineCapacity };
-
-  size_t length() const { return mLength; }
-
-  bool empty() const { return mLength == 0; }
-
-  size_t capacity() const { return mTail.mCapacity; }
-
-  T* begin()
-  {
-    do { } while (0);
-    return mBegin;
-  }
-
-  const T* begin() const
-  {
-    do { } while (0);
-    return mBegin;
-  }
-
-  T* end()
-  {
-    do { } while (0);
-    return mBegin + mLength;
-  }
-
-  const T* end() const
-  {
-    do { } while (0);
-    return mBegin + mLength;
-  }
-
-  T& operator[](size_t aIndex)
-  {
-    do { } while (0);
-    do { } while (0);
-    return begin()[aIndex];
-  }
-
-  const T& operator[](size_t aIndex) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return begin()[aIndex];
-  }
-
-  T& back()
-  {
-    do { } while (0);
-    do { } while (0);
-    return *(end() - 1);
-  }
-
-  const T& back() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return *(end() - 1);
-  }
-
-  class Range
-  {
-    friend class Vector;
-    T* mCur;
-    T* mEnd;
-    Range(T* aCur, T* aEnd)
-      : mCur(aCur)
-      , mEnd(aEnd)
-    {
-      do { } while (0);
-    }
-
-  public:
-    bool empty() const { return mCur == mEnd; }
-    size_t remain() const { return PointerRangeSize(mCur, mEnd); }
-    T& front() const { do { } while (0); return *mCur; }
-    void popFront() { do { } while (0); ++mCur; }
-    T popCopyFront() { do { } while (0); return *mCur++; }
-  };
-
-  class ConstRange
-  {
-    friend class Vector;
-    const T* mCur;
-    const T* mEnd;
-    ConstRange(const T* aCur, const T* aEnd)
-      : mCur(aCur)
-      , mEnd(aEnd)
-    {
-      do { } while (0);
-    }
-
-  public:
-    bool empty() const { return mCur == mEnd; }
-    size_t remain() const { return PointerRangeSize(mCur, mEnd); }
-    const T& front() const { do { } while (0); return *mCur; }
-    void popFront() { do { } while (0); ++mCur; }
-    T popCopyFront() { do { } while (0); return *mCur++; }
-  };
-
-  Range all() { return Range(begin(), end()); }
-  ConstRange all() const { return ConstRange(begin(), end()); }
-
-
-
-
-
-
-  void reverse();
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool initCapacity(size_t aRequest);
-# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  __attribute__ ((warn_unused_result)) bool initLengthUninitialized(size_t aRequest);
-# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  __attribute__ ((warn_unused_result)) bool reserve(size_t aRequest);
-
-
-
-
-
-  void shrinkBy(size_t aIncr);
-
-
-
-
-
-  void shrinkTo(size_t aNewLength);
-
-
-  __attribute__ ((warn_unused_result)) bool growBy(size_t aIncr);
-
-
-  __attribute__ ((warn_unused_result)) bool resize(size_t aNewLength);
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool growByUninitialized(size_t aIncr);
-  void infallibleGrowByUninitialized(size_t aIncr);
-  __attribute__ ((warn_unused_result)) bool resizeUninitialized(size_t aNewLength);
-
-
-  void clear();
-
-
-  void clearAndFree();
-
-
-
-
-
-
-  void podResizeToFit();
-
-
-
-
-
-
-
-  bool canAppendWithoutRealloc(size_t aNeeded) const;
-# 687 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  template<typename U> __attribute__ ((warn_unused_result)) bool append(U&& aU);
-
-
-
-
-  template<typename... Args>
-  __attribute__ ((warn_unused_result)) bool emplaceBack(Args&&... aArgs)
-  {
-    if (!growByUninitialized(1))
-      return false;
-    Impl::new_(&back(), Forward<Args>(aArgs)...);
-    return true;
-  }
-
-  template<typename U, size_t O, class BP>
-  __attribute__ ((warn_unused_result)) bool appendAll(const Vector<U, O, BP>& aU);
-  __attribute__ ((warn_unused_result)) bool appendN(const T& aT, size_t aN);
-  template<typename U> __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd);
-  template<typename U> __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength);
-
-
-
-
-
-
-  template<typename U> void infallibleAppend(U&& aU)
-  {
-    internalAppend(Forward<U>(aU));
-  }
-  void infallibleAppendN(const T& aT, size_t aN)
-  {
-    internalAppendN(aT, aN);
-  }
-  template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd)
-  {
-    internalAppend(aBegin, PointerRangeSize(aBegin, aEnd));
-  }
-  template<typename U> void infallibleAppend(const U* aBegin, size_t aLength)
-  {
-    internalAppend(aBegin, aLength);
-  }
-  template<typename... Args>
-  void infallibleEmplaceBack(Args&&... aArgs)
-  {
-    infallibleGrowByUninitialized(1);
-    Impl::new_(&back(), Forward<Args>(aArgs)...);
-  }
-
-  void popBack();
-
-  T popCopy();
-# 749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  __attribute__ ((warn_unused_result)) T* extractRawBuffer();
-# 767 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  __attribute__ ((warn_unused_result)) T* extractOrCopyRawBuffer();
-# 777 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  void replaceRawBuffer(T* aP, size_t aLength);
-# 794 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  template<typename U>
-  __attribute__ ((warn_unused_result)) T* insert(T* aP, U&& aVal);
-
-
-
-
-
-  void erase(T* aT);
-
-
-
-
-
-
-  void erase(T* aBegin, T* aEnd);
-
-
-
-
-  size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
-
-
-
-
-
-  size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
-
-  void swap(Vector& aOther);
-
-private:
-  Vector(const Vector&) = delete;
-  void operator=(const Vector&) = delete;
-};
-# 838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline
-Vector<T, N, AP>::Vector(AP aAP)
-  : AP(aAP)
-  , mLength(0)
-  , mTail(kInlineCapacity, 0)
-
-
-
-{
-  mBegin = inlineStorage();
-}
-
-
-template<typename T, size_t N, class AllocPolicy>
-__attribute__((always_inline)) inline
-Vector<T, N, AllocPolicy>::Vector(Vector&& aRhs)
-  : AllocPolicy(Move(aRhs))
-
-
-
-{
-  mLength = aRhs.mLength;
-  mTail.mCapacity = aRhs.mTail.mCapacity;
-
-
-
-
-  if (aRhs.usingInlineStorage()) {
-
-    mBegin = inlineStorage();
-    Impl::moveConstruct(mBegin, aRhs.beginNoCheck(), aRhs.endNoCheck());
-
-
-
-
-  } else {
-
-
-
-
-    mBegin = aRhs.mBegin;
-    aRhs.mBegin = aRhs.inlineStorage();
-    aRhs.mTail.mCapacity = kInlineCapacity;
-    aRhs.mLength = 0;
-
-
-
-  }
-}
-
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline Vector<T, N, AP>&
-Vector<T, N, AP>::operator=(Vector&& aRhs)
-{
-  do { } while (0);
-  this->~Vector();
-  new(KnownNotNull, this) Vector(Move(aRhs));
-  return *this;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline
-Vector<T, N, AP>::~Vector()
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  Impl::destroy(beginNoCheck(), endNoCheck());
-  if (!usingInlineStorage()) {
-    this->free_(beginNoCheck());
-  }
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::reverse() {
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  T* elems = mBegin;
-  size_t len = mLength;
-  size_t mid = len / 2;
-  for (size_t i = 0; i < mid; i++) {
-    Swap(elems[i], elems[len - i - 1]);
-  }
-}
-
-
-
-
-
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::convertToHeapStorage(size_t aNewCap)
-{
-  do { } while (0);
-
-
-  do { } while (0);
-  T* newBuf = this->template pod_malloc<T>(aNewCap);
-  if ((__builtin_expect(!!(!newBuf), 0))) {
-    return false;
-  }
-
-
-  Impl::moveConstruct(newBuf, beginNoCheck(), endNoCheck());
-  Impl::destroy(beginNoCheck(), endNoCheck());
-
-
-  mBegin = newBuf;
-
-  mTail.mCapacity = aNewCap;
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((noinline)) bool
-Vector<T, N, AP>::growStorageBy(size_t aIncr)
-{
-  do { } while (0);
-# 966 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-  size_t newCap;
-
-  if (aIncr == 1) {
-    if (usingInlineStorage()) {
-
-      size_t newSize =
-        tl::RoundUpPow2<(kInlineCapacity + 1) * sizeof(T)>::value;
-      newCap = newSize / sizeof(T);
-      goto convert;
-    }
-
-    if (mLength == 0) {
-
-      newCap = 1;
-      goto grow;
-    }
-# 994 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Vector.h"
-    if ((__builtin_expect(!!(mLength & tl::MulOverflowMask<4 * sizeof(T)>::value), 0))) {
-      this->reportAllocOverflow();
-      return false;
-    }
-
-
-
-
-
-
-    newCap = mLength * 2;
-    if (detail::CapacityHasExcessSpace<T>(newCap)) {
-      newCap += 1;
-    }
-  } else {
-
-    size_t newMinCap = mLength + aIncr;
-
-
-    if ((__builtin_expect(!!(newMinCap < mLength || newMinCap & tl::MulOverflowMask<2 * sizeof(T)>::value), 0)))
-
-    {
-      this->reportAllocOverflow();
-      return false;
-    }
-
-    size_t newMinSize = newMinCap * sizeof(T);
-    size_t newSize = RoundUpPow2(newMinSize);
-    newCap = newSize / sizeof(T);
-  }
-
-  if (usingInlineStorage()) {
-convert:
-    return convertToHeapStorage(newCap);
-  }
-
-grow:
-  return Impl::growTo(*this, newCap);
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::initCapacity(size_t aRequest)
-{
-  do { } while (0);
-  do { } while (0);
-  if (aRequest == 0) {
-    return true;
-  }
-  T* newbuf = this->template pod_malloc<T>(aRequest);
-  if ((__builtin_expect(!!(!newbuf), 0))) {
-    return false;
-  }
-  mBegin = newbuf;
-  mTail.mCapacity = aRequest;
-
-
-
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::initLengthUninitialized(size_t aRequest)
-{
-  if (!initCapacity(aRequest)) {
-    return false;
-  }
-  infallibleGrowByUninitialized(aRequest);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::maybeCheckSimulatedOOM(size_t aRequestedSize)
-{
-  if (aRequestedSize <= N) {
-    return true;
-  }
-
-
-
-
-
-
-
-  return allocPolicy().checkSimulatedOOM();
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::reserve(size_t aRequest)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  if (aRequest > mTail.mCapacity) {
-    if ((__builtin_expect(!!(!growStorageBy(aRequest - mLength)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(aRequest)) {
-    return false;
-  }
-
-
-
-
-
-
-
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::shrinkBy(size_t aIncr)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  do { } while (0);
-  Impl::destroy(endNoCheck() - aIncr, endNoCheck());
-  mLength -= aIncr;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::shrinkTo(size_t aNewLength)
-{
-  do { } while (0);
-  shrinkBy(mLength - aNewLength);
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::growBy(size_t aIncr)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  if (aIncr > mTail.mCapacity - mLength) {
-    if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) {
-    return false;
-  }
-  do { } while (0);
-  T* newend = endNoCheck() + aIncr;
-  Impl::initialize(endNoCheck(), newend);
-  mLength += aIncr;
-
-
-
-
-
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::growByUninitialized(size_t aIncr)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  if (aIncr > mTail.mCapacity - mLength) {
-    if ((__builtin_expect(!!(!growStorageBy(aIncr)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(mLength + aIncr)) {
-    return false;
-  }
-
-
-
-
-
-  infallibleGrowByUninitialized(aIncr);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::infallibleGrowByUninitialized(size_t aIncr)
-{
-  do { } while (0);
-  mLength += aIncr;
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::resize(size_t aNewLength)
-{
-  size_t curLength = mLength;
-  if (aNewLength > curLength) {
-    return growBy(aNewLength - curLength);
-  }
-  shrinkBy(curLength - aNewLength);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::resizeUninitialized(size_t aNewLength)
-{
-  size_t curLength = mLength;
-  if (aNewLength > curLength) {
-    return growByUninitialized(aNewLength - curLength);
-  }
-  shrinkBy(curLength - aNewLength);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::clear()
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  Impl::destroy(beginNoCheck(), endNoCheck());
-  mLength = 0;
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::clearAndFree()
-{
-  clear();
-
-  if (usingInlineStorage()) {
-    return;
-  }
-  this->free_(beginNoCheck());
-  mBegin = inlineStorage();
-  mTail.mCapacity = kInlineCapacity;
-
-
-
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::podResizeToFit()
-{
-
-
-  Impl::podResizeToFit(*this);
-}
-
-template<typename T, size_t N, class AP>
-inline bool
-Vector<T, N, AP>::canAppendWithoutRealloc(size_t aNeeded) const
-{
-  return mLength + aNeeded <= mTail.mCapacity;
-}
-
-template<typename T, size_t N, class AP>
-template<typename U, size_t O, class BP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::internalAppendAll(const Vector<U, O, BP>& aOther)
-{
-  internalAppend(aOther.begin(), aOther.length());
-}
-
-template<typename T, size_t N, class AP>
-template<typename U>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::internalAppend(U&& aU)
-{
-  do { } while (0);
-  do { } while (0);
-  Impl::new_(endNoCheck(), Forward<U>(aU));
-  ++mLength;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::appendN(const T& aT, size_t aNeeded)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  if (mLength + aNeeded > mTail.mCapacity) {
-    if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) {
-    return false;
-  }
-
-
-
-
-
-  internalAppendN(aT, aNeeded);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::internalAppendN(const T& aT, size_t aNeeded)
-{
-  do { } while (0);
-  do { } while (0);
-  Impl::copyConstructN(endNoCheck(), aNeeded, aT);
-  mLength += aNeeded;
-}
-
-template<typename T, size_t N, class AP>
-template<typename U>
-inline T*
-Vector<T, N, AP>::insert(T* aP, U&& aVal)
-{
-  do { } while (0);
-  do { } while (0);
-  size_t pos = aP - begin();
-  do { } while (0);
-  size_t oldLength = mLength;
-  if (pos == oldLength) {
-    if (!append(Forward<U>(aVal))) {
-      return nullptr;
-    }
-  } else {
-    T oldBack = Move(back());
-    if (!append(Move(oldBack))) {
-      return nullptr;
-    }
-    for (size_t i = oldLength - 1; i > pos; --i) {
-      (*this)[i] = Move((*this)[i - 1]);
-    }
-    (*this)[pos] = Forward<U>(aVal);
-  }
-  return begin() + pos;
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::erase(T* aIt)
-{
-  do { } while (0);
-  do { } while (0);
-  while (aIt + 1 < end()) {
-    *aIt = Move(*(aIt + 1));
-    ++aIt;
-  }
-  popBack();
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::erase(T* aBegin, T* aEnd)
-{
-  do { } while (0);
-  do { } while (0);
-  do { } while (0);
-  while (aEnd < end()) {
-    *aBegin++ = Move(*aEnd++);
-  }
-  shrinkBy(aEnd - aBegin);
-}
-
-template<typename T, size_t N, class AP>
-template<typename U>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::append(const U* aInsBegin, const U* aInsEnd)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  size_t aNeeded = PointerRangeSize(aInsBegin, aInsEnd);
-  if (mLength + aNeeded > mTail.mCapacity) {
-    if ((__builtin_expect(!!(!growStorageBy(aNeeded)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(mLength + aNeeded)) {
-      return false;
-  }
-
-
-
-
-
-  internalAppend(aInsBegin, aNeeded);
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-template<typename U>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::internalAppend(const U* aInsBegin, size_t aInsLength)
-{
-  do { } while (0);
-  do { } while (0);
-  Impl::copyConstruct(endNoCheck(), aInsBegin, aInsBegin + aInsLength);
-  mLength += aInsLength;
-}
-
-template<typename T, size_t N, class AP>
-template<typename U>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::append(U&& aU)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  if (mLength == mTail.mCapacity) {
-    if ((__builtin_expect(!!(!growStorageBy(1)), 0))) {
-      return false;
-    }
-  } else if (!maybeCheckSimulatedOOM(mLength + 1)) {
-      return false;
-  }
-
-
-
-
-
-  internalAppend(Forward<U>(aU));
-  return true;
-}
-
-template<typename T, size_t N, class AP>
-template<typename U, size_t O, class BP>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::appendAll(const Vector<U, O, BP>& aOther)
-{
-  return append(aOther.begin(), aOther.length());
-}
-
-template<typename T, size_t N, class AP>
-template<class U>
-__attribute__((always_inline)) inline bool
-Vector<T, N, AP>::append(const U* aInsBegin, size_t aInsLength)
-{
-  return append(aInsBegin, aInsBegin + aInsLength);
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline void
-Vector<T, N, AP>::popBack()
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-  do { } while (0);
-  --mLength;
-  endNoCheck()->~T();
-}
-
-template<typename T, size_t N, class AP>
-__attribute__((always_inline)) inline T
-Vector<T, N, AP>::popCopy()
-{
-  T ret = back();
-  popBack();
-  return ret;
-}
-
-template<typename T, size_t N, class AP>
-inline T*
-Vector<T, N, AP>::extractRawBuffer()
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-
-  if (usingInlineStorage()) {
-    return nullptr;
-  }
-
-  T* ret = mBegin;
-  mBegin = inlineStorage();
-  mLength = 0;
-  mTail.mCapacity = kInlineCapacity;
-
-
-
-  return ret;
-}
-
-template<typename T, size_t N, class AP>
-inline T*
-Vector<T, N, AP>::extractOrCopyRawBuffer()
-{
-  if (T* ret = extractRawBuffer()) {
-    return ret;
-  }
-
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-
-  T* copy = this->template pod_malloc<T>(mLength);
-  if (!copy) {
-    return nullptr;
-  }
-
-  Impl::moveConstruct(copy, beginNoCheck(), endNoCheck());
-  Impl::destroy(beginNoCheck(), endNoCheck());
-  mBegin = inlineStorage();
-  mLength = 0;
-  mTail.mCapacity = kInlineCapacity;
-
-
-
-  return copy;
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::replaceRawBuffer(T* aP, size_t aLength)
-{
-  ReentrancyGuard g(*this); do { } while (0); do { } while (0); do { } while (0); do { } while (0);
-
-
-  Impl::destroy(beginNoCheck(), endNoCheck());
-  if (!usingInlineStorage()) {
-    this->free_(beginNoCheck());
-  }
-
-
-  if (aLength <= kInlineCapacity) {
-
-
-
-
-
-    mBegin = inlineStorage();
-    mLength = aLength;
-    mTail.mCapacity = kInlineCapacity;
-    Impl::moveConstruct(mBegin, aP, aP + aLength);
-    Impl::destroy(aP, aP + aLength);
-    this->free_(aP);
-  } else {
-    mBegin = aP;
-    mLength = aLength;
-    mTail.mCapacity = aLength;
-  }
-
-
-
-}
-
-template<typename T, size_t N, class AP>
-inline size_t
-Vector<T, N, AP>::sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
-{
-  return usingInlineStorage() ? 0 : aMallocSizeOf(beginNoCheck());
-}
-
-template<typename T, size_t N, class AP>
-inline size_t
-Vector<T, N, AP>::sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
-{
-  return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf);
-}
-
-template<typename T, size_t N, class AP>
-inline void
-Vector<T, N, AP>::swap(Vector& aOther)
-{
-  static_assert(N == 0,
-                "still need to implement this for N != 0");
-
-
-  if (!usingInlineStorage() && aOther.usingInlineStorage()) {
-    aOther.mBegin = mBegin;
-    mBegin = inlineStorage();
-  } else if (usingInlineStorage() && !aOther.usingInlineStorage()) {
-    mBegin = aOther.mBegin;
-    aOther.mBegin = aOther.inlineStorage();
-  } else if (!usingInlineStorage() && !aOther.usingInlineStorage()) {
-    Swap(mBegin, aOther.mBegin);
-  } else {
-
-  }
-
-  Swap(mLength, aOther.mLength);
-  Swap(mTail.mCapacity, aOther.mTail.mCapacity);
-
-
-
-}
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/UniquePtr.h"
-namespace js {
-
-
-template <typename T, typename D = JS::DeletePolicy<T>>
-using UniquePtr = mozilla::UniquePtr<T, D>;
-
-namespace detail {
-
-template<typename T>
-struct UniqueSelector
-{
-  typedef UniquePtr<T> SingleObject;
-};
-
-template<typename T>
-struct UniqueSelector<T[]>
-{
-  typedef UniquePtr<T[]> UnknownBound;
-};
-
-template<typename T, decltype(sizeof(int)) N>
-struct UniqueSelector<T[N]>
-{
-  typedef UniquePtr<T[N]> KnownBound;
-};
-
-}
-
-
-
-template<typename T, typename... Args>
-typename detail::UniqueSelector<T>::SingleObject
-MakeUnique(Args&&... aArgs)
-{
-  return UniquePtr<T>(js_new<T>(mozilla::Forward<Args>(aArgs)...));
-}
-
-template<typename T>
-typename detail::UniqueSelector<T>::UnknownBound
-MakeUnique(decltype(sizeof(int)) aN) = delete;
-
-template<typename T, typename... Args>
-typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(Args&&... aArgs) = delete;
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h" 2
-
-namespace js {
-namespace gc {
-class GCRuntime;
-}
-namespace gcstats {
-struct Statistics;
-}
-}
-
-typedef enum JSGCMode {
-
-    JSGC_MODE_GLOBAL = 0,
-
-
-    JSGC_MODE_ZONE = 1,
-
-
-
-
-
-    JSGC_MODE_INCREMENTAL = 2
-} JSGCMode;
-
-
-
-
-typedef enum JSGCInvocationKind {
-
-    GC_NORMAL = 0,
-
-
-    GC_SHRINK = 1
-} JSGCInvocationKind;
-
-namespace JS {
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-namespace gcreason {
-
-
-enum Reason {
-
-    API, EAGER_ALLOC_TRIGGER, DESTROY_RUNTIME, UNUSED0, LAST_DITCH, TOO_MUCH_MALLOC, ALLOC_TRIGGER, DEBUG_GC, COMPARTMENT_REVIVED, RESET, OUT_OF_NURSERY, EVICT_NURSERY, FULL_STORE_BUFFER, SHARED_MEMORY_LIMIT, UNUSED1, INCREMENTAL_TOO_SLOW, ABORT_GC, RESERVED0, RESERVED1, RESERVED2, RESERVED3, RESERVED4, RESERVED5, RESERVED6, RESERVED7, RESERVED8, RESERVED9, RESERVED10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15, DOM_WINDOW_UTILS, COMPONENT_UTILS, MEM_PRESSURE, CC_WAITING, CC_FORCED, LOAD_END, POST_COMPARTMENT, PAGE_HIDE, NSJSCONTEXT_DESTROY, SET_NEW_DOCUMENT, SET_DOC_SHELL, DOM_UTILS, DOM_IPC, DOM_WORKER, INTER_SLICE_GC, REFRESH_FRAME, FULL_GC_TIMER, SHUTDOWN_CC, FINISH_LARGE_EVALUATE, USER_INACTIVE, XPCONNECT_SHUTDOWN,
-
-    NO_REASON,
-    NUM_REASONS,
-
-
-
-
-
-
-
-    NUM_TELEMETRY_REASONS = 100
-};
-
-
-
-
-extern const char*
-ExplainReason(JS::gcreason::Reason reason);
-
-}
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-extern void
-PrepareZoneForGC(Zone* zone);
-
-
-
-
-extern void
-PrepareForFullGC(JSContext* cx);
-
-
-
-
-
-
-extern void
-PrepareForIncrementalGC(JSContext* cx);
-
-
-
-
-
-extern bool
-IsGCScheduled(JSContext* cx);
-
-
-
-
-
-extern void
-SkipZoneForGC(Zone* zone);
-# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-extern void
-GCForReason(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason);
-# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-extern void
-StartIncrementalGC(JSContext* cx, JSGCInvocationKind gckind, gcreason::Reason reason,
-                   int64_t millis = 0);
-# 248 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-extern void
-IncrementalGCSlice(JSContext* cx, gcreason::Reason reason, int64_t millis = 0);
-
-
-
-
-
-
-
-extern void
-FinishIncrementalGC(JSContext* cx, gcreason::Reason reason);
-
-
-
-
-
-
-
-extern void
-AbortIncrementalGC(JSContext* cx);
-
-namespace dbg {
-
-
-
-
-class GarbageCollectionEvent
-{
-
-    uint64_t majorGCNumber_;
-
-
-
-    const char* reason;
-
-
-
-
-    const char* nonincrementalReason;
-
-
-
-    struct Collection {
-        mozilla::TimeStamp startTimestamp;
-        mozilla::TimeStamp endTimestamp;
-    };
-
-
-    mozilla::Vector<Collection> collections;
-
-    GarbageCollectionEvent(const GarbageCollectionEvent& rhs) = delete;
-    GarbageCollectionEvent& operator=(const GarbageCollectionEvent& rhs) = delete;
-
-  public:
-    explicit GarbageCollectionEvent(uint64_t majorGCNum)
-        : majorGCNumber_(majorGCNum)
-        , reason(nullptr)
-        , nonincrementalReason(nullptr)
-        , collections()
-    { }
-
-    using Ptr = js::UniquePtr<GarbageCollectionEvent>;
-    static Ptr Create(JSRuntime* rt, ::js::gcstats::Statistics& stats, uint64_t majorGCNumber);
-
-    JSObject* toJSObject(JSContext* cx) const;
-
-    uint64_t majorGCNumber() const { return majorGCNumber_; }
-};
-
-}
-
-enum GCProgress {
-# 330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-    GC_CYCLE_BEGIN,
-    GC_SLICE_BEGIN,
-    GC_SLICE_END,
-    GC_CYCLE_END
-};
-
-struct GCDescription {
-    bool isZone_;
-    JSGCInvocationKind invocationKind_;
-    gcreason::Reason reason_;
-
-    GCDescription(bool isZone, JSGCInvocationKind kind, gcreason::Reason reason)
-      : isZone_(isZone), invocationKind_(kind), reason_(reason) {}
-
-    char16_t* formatSliceMessage(JSContext* cx) const;
-    char16_t* formatSummaryMessage(JSContext* cx) const;
-    char16_t* formatJSON(JSContext* cx, uint64_t timestamp) const;
-
-    JS::dbg::GarbageCollectionEvent::Ptr toGCEvent(JSContext* cx) const;
-};
-
-typedef void
-(* GCSliceCallback)(JSContext* cx, GCProgress progress, const GCDescription& desc);
-
-
-
-
-
-
-extern GCSliceCallback
-SetGCSliceCallback(JSContext* cx, GCSliceCallback callback);
-
-
-
-
-enum class GCNurseryProgress {
-
-
-
-    GC_NURSERY_COLLECTION_START,
-
-
-
-    GC_NURSERY_COLLECTION_END
-};
-
-
-
-
-
-using GCNurseryCollectionCallback = void(*)(JSContext* cx, GCNurseryProgress progress,
-                                            gcreason::Reason reason);
-
-
-
-
-
-extern GCNurseryCollectionCallback
-SetGCNurseryCollectionCallback(JSContext* cx, GCNurseryCollectionCallback callback);
-
-typedef void
-(* DoCycleCollectionCallback)(JSContext* cx);
-
-
-
-
-
-extern DoCycleCollectionCallback
-SetDoCycleCollectionCallback(JSContext* cx, DoCycleCollectionCallback callback);
-
-
-
-
-
-
-
-extern void
-DisableIncrementalGC(JSContext* cx);
-# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-extern bool
-IsIncrementalGCEnabled(JSContext* cx);
-
-
-
-
-
-extern bool
-IsIncrementalGCInProgress(JSContext* cx);
-
-
-
-
-
-
-
-extern bool
-IsIncrementalBarrierNeeded(JSContext* cx);
-
-
-
-
-
-extern void
-IncrementalPreWriteBarrier(JSObject* obj);
-
-
-
-
-
-extern void
-IncrementalReadBarrier(GCCellPtr thing);
-
-
-
-
-extern bool
-WasIncrementalGC(JSContext* cx);
-# 465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-class AutoDisableGenerationalGC
-{
-    JSContext* cx;
-
-  public:
-    explicit AutoDisableGenerationalGC(JSContext* cx);
-    ~AutoDisableGenerationalGC();
-};
-
-
-
-
-
-extern bool
-IsGenerationalGCEnabled(JSRuntime* rt);
-
-
-
-
-
-
-extern size_t
-GetGCNumber();
-
-
-
-
-
-
-class AutoRequireNoGC
-{
-  protected:
-    AutoRequireNoGC() {}
-    ~AutoRequireNoGC() {}
-};
-# 509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-class AutoAssertNoGC : public AutoRequireNoGC
-{
-    JSContext* cx_;
-
-  public:
-    explicit AutoAssertNoGC(JSContext* cx = nullptr);
-    ~AutoAssertNoGC();
-};
-
-
-
-
-
-class AutoAssertNoAlloc
-{
-
-    js::gc::GCRuntime* gc;
-
-  public:
-    AutoAssertNoAlloc() : gc(nullptr) {}
-    explicit AutoAssertNoAlloc(JSContext* cx);
-    void disallowAlloc(JSRuntime* rt);
-    ~AutoAssertNoAlloc();
-
-
-
-
-
-
-};
-
-
-
-
-
-class AutoAssertOnBarrier
-{
-    JSContext* context;
-    bool prev;
-
-  public:
-    explicit AutoAssertOnBarrier(JSContext* cx);
-    ~AutoAssertOnBarrier();
-};
-# 568 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-class AutoSuppressGCAnalysis : public AutoAssertNoAlloc
-{
-  public:
-    AutoSuppressGCAnalysis() : AutoAssertNoAlloc() {}
-    explicit AutoSuppressGCAnalysis(JSContext* cx) : AutoAssertNoAlloc(cx) {}
-} ;
-# 583 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-class AutoAssertGCCallback : public AutoSuppressGCAnalysis
-{
-  public:
-    explicit AutoAssertGCCallback(JSObject* obj);
-};
-# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCAPI.h"
-class AutoCheckCannotGC : public AutoRequireNoGC
-{
-  public:
-    explicit AutoCheckCannotGC(JSContext* cx = nullptr) {}
-} ;
-
-
-
-
-
-
-
-extern bool
-UnmarkGrayGCThingRecursively(GCCellPtr thing);
-
-}
-
-namespace js {
-namespace gc {
-
-extern bool
-BarriersAreAllowedOnCurrentThread();
-
-static __attribute__((always_inline)) inline void
-ExposeGCThingToActiveJS(JS::GCCellPtr thing)
-{
-
-
-
-    if (IsInsideNursery(thing.asCell()))
-        return;
-
-
-
-    if (thing.mayBeOwnedByOtherRuntime())
-        return;
-
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(BarriersAreAllowedOnCurrentThread())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 645; ::abort(); } while (0); } } while (0);
-
-    if (IsIncrementalBarrierNeededOnTenuredGCThing(thing))
-        JS::IncrementalReadBarrier(thing);
-    else if (js::gc::detail::CellIsMarkedGray(thing.asCell()))
-        JS::UnmarkGrayGCThingRecursively(thing);
-
-    do { } while (0);
-}
-
-static __attribute__((always_inline)) inline void
-GCThingReadBarrier(JS::GCCellPtr thing)
-{
-
-
-    if (IsInsideNursery(thing.asCell()))
-        return;
-
-
-
-    if (thing.mayBeOwnedByOtherRuntime())
-        return;
-
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(BarriersAreAllowedOnCurrentThread())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(BarriersAreAllowedOnCurrentThread()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "BarriersAreAllowedOnCurrentThread()" ")"); do { *((volatile int*) __null) = 668; ::abort(); } while (0); } } while (0);
-
-    if (IsIncrementalBarrierNeededOnTenuredGCThing(thing))
-        JS::IncrementalReadBarrier(thing);
-}
-
-}
-}
-
-namespace JS {
-
-
-
-
-
-
-
-static __attribute__((always_inline)) inline void
-ExposeObjectToActiveJS(JSObject* obj)
-{
-    do { } while (0);
-    js::gc::ExposeGCThingToActiveJS(GCCellPtr(obj));
-}
-
-static __attribute__((always_inline)) inline void
-ExposeScriptToActiveJS(JSScript* script)
-{
-    js::gc::ExposeGCThingToActiveJS(GCCellPtr(script));
-}
-
-
-
-
-static __attribute__((always_inline)) inline void
-StringReadBarrier(JSString* string)
-{
-    do { } while (0);
-    js::gc::GCThingReadBarrier(GCCellPtr(string));
-}
-
-
-
-
-
-
-extern void
-PokeGC(JSContext* cx);
-
-
-
-
-extern void
-NotifyDidPaint(JSContext* cx);
-
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 1
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h"
-namespace js {
-
-enum class AllocFunction {
-    Malloc,
-    Calloc,
-    Realloc
-};
-
-
-class SystemAllocPolicy
-{
-  public:
-    template <typename T> T* maybe_pod_malloc(size_t numElems) { return js_pod_malloc<T>(numElems); }
-    template <typename T> T* maybe_pod_calloc(size_t numElems) { return js_pod_calloc<T>(numElems); }
-    template <typename T> T* maybe_pod_realloc(T* p, size_t oldSize, size_t newSize) {
-        return js_pod_realloc<T>(p, oldSize, newSize);
-    }
-    template <typename T> T* pod_malloc(size_t numElems) { return maybe_pod_malloc<T>(numElems); }
-    template <typename T> T* pod_calloc(size_t numElems) { return maybe_pod_calloc<T>(numElems); }
-    template <typename T> T* pod_realloc(T* p, size_t oldSize, size_t newSize) {
-        return maybe_pod_realloc<T>(p, oldSize, newSize);
-    }
-    void free_(void* p) { js_free(p); }
-    void reportAllocOverflow() const {}
-    bool checkSimulatedOOM() const {
-        return !js::oom::ShouldFailWithOOM();
-    }
-};
-
-void ReportOutOfMemory(JSContext* cx);
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsalloc.h"
-class TempAllocPolicy
-{
-    JSContext* const cx_;
-
-
-
-
-
-    void* onOutOfMemory(AllocFunction allocFunc, size_t nbytes,
-                                       void* reallocPtr = nullptr);
-
-    template <typename T>
-    T* onOutOfMemoryTyped(AllocFunction allocFunc, size_t numElems, void* reallocPtr = nullptr) {
-        size_t bytes;
-        if ((__builtin_expect(!!(!CalculateAllocSize<T>(numElems, &bytes)), 0)))
-            return nullptr;
-        return static_cast<T*>(onOutOfMemory(allocFunc, bytes, reallocPtr));
-    }
-
-  public:
-                 TempAllocPolicy(JSContext* cx) : cx_(cx) {}
-
-    template <typename T>
-    T* maybe_pod_malloc(size_t numElems) {
-        return js_pod_malloc<T>(numElems);
-    }
-
-    template <typename T>
-    T* maybe_pod_calloc(size_t numElems) {
-        return js_pod_calloc<T>(numElems);
-    }
-
-    template <typename T>
-    T* maybe_pod_realloc(T* prior, size_t oldSize, size_t newSize) {
-        return js_pod_realloc<T>(prior, oldSize, newSize);
-    }
-
-    template <typename T>
-    T* pod_malloc(size_t numElems) {
-        T* p = maybe_pod_malloc<T>(numElems);
-        if ((__builtin_expect(!!(!p), 0)))
-            p = onOutOfMemoryTyped<T>(AllocFunction::Malloc, numElems);
-        return p;
-    }
-
-    template <typename T>
-    T* pod_calloc(size_t numElems) {
-        T* p = maybe_pod_calloc<T>(numElems);
-        if ((__builtin_expect(!!(!p), 0)))
-            p = onOutOfMemoryTyped<T>(AllocFunction::Calloc, numElems);
-        return p;
-    }
-
-    template <typename T>
-    T* pod_realloc(T* prior, size_t oldSize, size_t newSize) {
-        T* p2 = maybe_pod_realloc<T>(prior, oldSize, newSize);
-        if ((__builtin_expect(!!(!p2), 0)))
-            p2 = onOutOfMemoryTyped<T>(AllocFunction::Realloc, newSize, prior);
-        return p2;
-    }
-
-    void free_(void* p) {
-        js_free(p);
-    }
-
-    void reportAllocOverflow() const;
-
-    bool checkSimulatedOOM() const {
-        if (js::oom::ShouldFailWithOOM()) {
-            ReportOutOfMemory(cx_);
-            return false;
-        }
-
-        return true;
-    }
-};
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h" 1
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-namespace mozilla {
-
-
-
-
-static const uint32_t kGoldenRatioU32 = 0x9E3779B9U;
-
-inline uint32_t
-RotateBitsLeft32(uint32_t aValue, uint8_t aBits)
-{
-  do { } while (0);
-  return (aValue << aBits) | (aValue >> (32 - aBits));
-}
-
-namespace detail {
-
-inline uint32_t
-AddU32ToHash(uint32_t aHash, uint32_t aValue)
-{
-# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-  return kGoldenRatioU32 * (RotateBitsLeft32(aHash, 5) ^ aValue);
-}
-
-
-
-
-template<size_t PtrSize>
-inline uint32_t
-AddUintptrToHash(uint32_t aHash, uintptr_t aValue);
-
-template<>
-inline uint32_t
-AddUintptrToHash<4>(uint32_t aHash, uintptr_t aValue)
-{
-  return AddU32ToHash(aHash, static_cast<uint32_t>(aValue));
-}
-
-template<>
-inline uint32_t
-AddUintptrToHash<8>(uint32_t aHash, uintptr_t aValue)
-{
-
-
-
-
-
-
-
-  uint32_t v1 = static_cast<uint32_t>(aValue);
-  uint32_t v2 = static_cast<uint32_t>(static_cast<uint64_t>(aValue) >> 32);
-  return AddU32ToHash(AddU32ToHash(aHash, v1), v2);
-}
-
-}
-# 159 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-template<typename A>
-__attribute__ ((warn_unused_result)) inline uint32_t
-AddToHash(uint32_t aHash, A aA)
-{
-
-
-
-
-  return detail::AddU32ToHash(aHash, aA);
-}
-
-template<typename A>
-__attribute__ ((warn_unused_result)) inline uint32_t
-AddToHash(uint32_t aHash, A* aA)
-{
-
-
-
-
-
-  static_assert(sizeof(aA) == sizeof(uintptr_t), "Strange pointer!");
-
-  return detail::AddUintptrToHash<sizeof(uintptr_t)>(aHash, uintptr_t(aA));
-}
-
-template<>
-__attribute__ ((warn_unused_result)) inline uint32_t
-AddToHash(uint32_t aHash, uintptr_t aA)
-{
-  return detail::AddUintptrToHash<sizeof(uintptr_t)>(aHash, aA);
-}
-
-template<typename A, typename... Args>
-__attribute__ ((warn_unused_result)) uint32_t
-AddToHash(uint32_t aHash, A aArg, Args... aArgs)
-{
-  return AddToHash(AddToHash(aHash, aArg), aArgs...);
-}
-# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-template<typename... Args>
-__attribute__ ((warn_unused_result)) inline uint32_t
-HashGeneric(Args... aArgs)
-{
-  return AddToHash(0, aArgs...);
-}
-
-namespace detail {
-
-template<typename T>
-uint32_t
-HashUntilZero(const T* aStr)
-{
-  uint32_t hash = 0;
-  for (T c; (c = *aStr); aStr++) {
-    hash = AddToHash(hash, c);
-  }
-  return hash;
-}
-
-template<typename T>
-uint32_t
-HashKnownLength(const T* aStr, size_t aLength)
-{
-  uint32_t hash = 0;
-  for (size_t i = 0; i < aLength; i++) {
-    hash = AddToHash(hash, aStr[i]);
-  }
-  return hash;
-}
-
-}
-
-
-
-
-
-
-
-__attribute__ ((warn_unused_result)) inline uint32_t
-HashString(const char* aStr)
-{
-  return detail::HashUntilZero(reinterpret_cast<const unsigned char*>(aStr));
-}
-
-__attribute__ ((warn_unused_result)) inline uint32_t
-HashString(const char* aStr, size_t aLength)
-{
-  return detail::HashKnownLength(reinterpret_cast<const unsigned char*>(aStr), aLength);
-}
-
-__attribute__ ((warn_unused_result))
-inline uint32_t
-HashString(const unsigned char* aStr, size_t aLength)
-{
-  return detail::HashKnownLength(aStr, aLength);
-}
-
-__attribute__ ((warn_unused_result)) inline uint32_t
-HashString(const char16_t* aStr)
-{
-  return detail::HashUntilZero(aStr);
-}
-
-__attribute__ ((warn_unused_result)) inline uint32_t
-HashString(const char16_t* aStr, size_t aLength)
-{
-  return detail::HashKnownLength(aStr, aLength);
-}
-# 299 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-__attribute__ ((warn_unused_result)) extern __attribute__((weak)) __attribute__((visibility("default"))) uint32_t
-HashBytes(const void* bytes, size_t aLength);
-# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashFunctions.h"
-class HashCodeScrambler
-{
-  struct SipHasher;
-
-  uint64_t mK0, mK1;
-
-public:
-
-  constexpr HashCodeScrambler(uint64_t aK0, uint64_t aK1) : mK0(aK0), mK1(aK1) {}
-
-
-
-
-
-  uint32_t scramble(uint32_t aHashCode) const
-  {
-    SipHasher hasher(mK0, mK1);
-    return uint32_t(hasher.sipHash(aHashCode));
-  }
-
-private:
-  struct SipHasher
-  {
-    SipHasher(uint64_t aK0, uint64_t aK1)
-    {
-
-      mV0 = aK0 ^ 0x736f6d6570736575UL;
-      mV1 = aK1 ^ 0x646f72616e646f6dUL;
-      mV2 = aK0 ^ 0x6c7967656e657261UL;
-      mV3 = aK1 ^ 0x7465646279746573UL;
-    }
-
-    uint64_t sipHash(uint64_t aM)
-    {
-
-      mV3 ^= aM;
-      sipRound();
-      mV0 ^= aM;
-
-
-      mV2 ^= 0xff;
-      for (int i = 0; i < 3; i++)
-        sipRound();
-      return mV0 ^ mV1 ^ mV2 ^ mV3;
-    }
-
-    void sipRound()
-    {
-      mV0 += mV1;
-      mV1 = RotateLeft(mV1, 13);
-      mV1 ^= mV0;
-      mV0 = RotateLeft(mV0, 32);
-      mV2 += mV3;
-      mV3 = RotateLeft(mV3, 16);
-      mV3 ^= mV2;
-      mV0 += mV3;
-      mV3 = RotateLeft(mV3, 21);
-      mV3 ^= mV0;
-      mV2 += mV1;
-      mV1 = RotateLeft(mV1, 17);
-      mV1 ^= mV2;
-      mV2 = RotateLeft(mV2, 32);
-    }
-
-    uint64_t mV0, mV1, mV2, mV3;
-  };
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Opaque.h"
-namespace mozilla {
-
-
-
-
-
-
-template<typename T>
-class Opaque final
-{
-  static_assert(mozilla::IsIntegral<T>::value,
-                "mozilla::Opaque only supports integral types");
-
-  T mValue;
-
-public:
-  Opaque() {}
-  explicit Opaque(T aValue) : mValue(aValue) {}
-
-  bool operator==(const Opaque& aOther) const {
-    return mValue == aOther.mValue;
-  }
-
-  bool operator!=(const Opaque& aOther) const {
-    return !(*this == aOther);
-  }
-};
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h" 2
-
-
-
-
-
-
-
-
-namespace js {
-
-class TempAllocPolicy;
-template <class> struct DefaultHasher;
-template <class, class> class HashMapEntry;
-namespace detail {
-    template <class T> class HashTableEntry;
-    template <class T, class HashPolicy, class AllocPolicy> class HashTable;
-}
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-using Generation = mozilla::Opaque<uint64_t>;
-# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-template <class Key,
-          class Value,
-          class HashPolicy = DefaultHasher<Key>,
-          class AllocPolicy = TempAllocPolicy>
-class HashMap
-{
-    typedef HashMapEntry<Key, Value> TableEntry;
-
-    struct MapHashPolicy : HashPolicy
-    {
-        using Base = HashPolicy;
-        typedef Key KeyType;
-        static const Key& getKey(TableEntry& e) { return e.key(); }
-        static void setKey(TableEntry& e, Key& k) { HashPolicy::rekey(e.mutableKey(), k); }
-    };
-
-    typedef detail::HashTable<TableEntry, MapHashPolicy, AllocPolicy> Impl;
-    Impl impl;
-
-  public:
-    typedef typename HashPolicy::Lookup Lookup;
-    typedef TableEntry Entry;
-
-
-
-    explicit HashMap(AllocPolicy a = AllocPolicy()) : impl(a) {}
-    __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); }
-    bool initialized() const { return impl.initialized(); }
-# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Ptr Ptr;
-    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); }
-
-
-
-    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const {
-        return impl.readonlyThreadsafeLookup(l);
-    }
-
-
-    void remove(Ptr p) { impl.remove(p); }
-# 150 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::AddPtr AddPtr;
-    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const {
-        return impl.lookupForAdd(l);
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) {
-        return impl.add(p,
-                        mozilla::Forward<KeyInput>(k),
-                        mozilla::Forward<ValueInput>(v));
-    }
-
-    template<typename KeyInput>
-    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, KeyInput&& k) {
-        return impl.add(p, mozilla::Forward<KeyInput>(k), Value());
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) {
-        return impl.relookupOrAdd(p, k,
-                                  mozilla::Forward<KeyInput>(k),
-                                  mozilla::Forward<ValueInput>(v));
-    }
-# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Range Range;
-    Range all() const { return impl.all(); }
-# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Enum Enum;
-
-
-
-    void clear() { impl.clear(); }
-
-
-
-    void clearAndShrink() { impl.clearAndShrink(); }
-
-
-
-    void finish() { impl.finish(); }
-
-
-    bool empty() const { return impl.empty(); }
-
-
-    uint32_t count() const { return impl.count(); }
-
-
-
-    size_t capacity() const { return impl.capacity(); }
-
-
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return impl.sizeOfExcludingThis(mallocSizeOf);
-    }
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf);
-    }
-
-    Generation generation() const {
-        return impl.generation();
-    }
-
-
-
-    bool has(const Lookup& l) const {
-        return impl.lookup(l).found();
-    }
-
-
-    template<typename KeyInput, typename ValueInput>
-    __attribute__ ((warn_unused_result)) bool put(KeyInput&& k, ValueInput&& v) {
-        AddPtr p = lookupForAdd(k);
-        if (p) {
-            p->value() = mozilla::Forward<ValueInput>(v);
-            return true;
-        }
-        return add(p, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
-    }
-
-
-    template<typename KeyInput, typename ValueInput>
-    __attribute__ ((warn_unused_result)) bool putNew(KeyInput&& k, ValueInput&& v) {
-        return impl.putNew(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
-    }
-
-
-    template<typename KeyInput, typename ValueInput>
-    void putNewInfallible(KeyInput&& k, ValueInput&& v) {
-        impl.putNewInfallible(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
-    }
-
-
-    Ptr lookupWithDefault(const Key& k, const Value& defaultValue) {
-        AddPtr p = lookupForAdd(k);
-        if (p)
-            return p;
-        bool ok = add(p, k, defaultValue);
-        do { } while (0);
-        (void)ok;
-        return p;
-    }
-
-
-    void remove(const Lookup& l) {
-        if (Ptr p = lookup(l))
-            remove(p);
-    }
-
-
-
-    void rekeyIfMoved(const Key& old_key, const Key& new_key) {
-        if (old_key != new_key)
-            rekeyAs(old_key, new_key, new_key);
-    }
-
-
-    bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const Key& new_key) {
-        if (Ptr p = lookup(old_lookup)) {
-            impl.rekeyAndMaybeRehash(p, new_lookup, new_key);
-            return true;
-        }
-        return false;
-    }
-
-
-    HashMap(HashMap&& rhs) : impl(mozilla::Move(rhs.impl)) {}
-    void operator=(HashMap&& rhs) {
-        do { } while (0);
-        impl = mozilla::Move(rhs.impl);
-    }
-
-  private:
-
-    HashMap(const HashMap& hm) = delete;
-    HashMap& operator=(const HashMap& hm) = delete;
-
-    friend class Impl::Enum;
-};
-# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-template <class T,
-          class HashPolicy = DefaultHasher<T>,
-          class AllocPolicy = TempAllocPolicy>
-class HashSet
-{
-    struct SetOps : HashPolicy
-    {
-        using Base = HashPolicy;
-        typedef T KeyType;
-        static const KeyType& getKey(const T& t) { return t; }
-        static void setKey(T& t, KeyType& k) { HashPolicy::rekey(t, k); }
-    };
-
-    typedef detail::HashTable<const T, SetOps, AllocPolicy> Impl;
-    Impl impl;
-
-  public:
-    typedef typename HashPolicy::Lookup Lookup;
-    typedef T Entry;
-
-
-
-    explicit HashSet(AllocPolicy a = AllocPolicy()) : impl(a) {}
-    __attribute__ ((warn_unused_result)) bool init(uint32_t len = 16) { return impl.init(len); }
-    bool initialized() const { return impl.initialized(); }
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Ptr Ptr;
-    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const { return impl.lookup(l); }
-
-
-
-    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const {
-        return impl.readonlyThreadsafeLookup(l);
-    }
-
-
-    void remove(Ptr p) { impl.remove(p); }
-# 406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::AddPtr AddPtr;
-    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const {
-        return impl.lookupForAdd(l);
-    }
-
-    template <typename U>
-    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, U&& u) {
-        return impl.add(p, mozilla::Forward<U>(u));
-    }
-
-    template <typename U>
-    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, U&& u) {
-        return impl.relookupOrAdd(p, l, mozilla::Forward<U>(u));
-    }
-# 429 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Range Range;
-    Range all() const { return impl.all(); }
-# 443 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-    typedef typename Impl::Enum Enum;
-
-
-
-    void clear() { impl.clear(); }
-
-
-
-    void clearAndShrink() { impl.clearAndShrink(); }
-
-
-
-    void finish() { impl.finish(); }
-
-
-    bool empty() const { return impl.empty(); }
-
-
-    uint32_t count() const { return impl.count(); }
-
-
-
-    size_t capacity() const { return impl.capacity(); }
-
-
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return impl.sizeOfExcludingThis(mallocSizeOf);
-    }
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return mallocSizeOf(this) + impl.sizeOfExcludingThis(mallocSizeOf);
-    }
-
-    Generation generation() const {
-        return impl.generation();
-    }
-
-
-
-    bool has(const Lookup& l) const {
-        return impl.lookup(l).found();
-    }
-
-
-    template <typename U>
-    __attribute__ ((warn_unused_result)) bool put(U&& u) {
-        AddPtr p = lookupForAdd(u);
-        return p ? true : add(p, mozilla::Forward<U>(u));
-    }
-
-
-    template <typename U>
-    __attribute__ ((warn_unused_result)) bool putNew(U&& u) {
-        return impl.putNew(u, mozilla::Forward<U>(u));
-    }
-
-    template <typename U>
-    __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, U&& u) {
-        return impl.putNew(l, mozilla::Forward<U>(u));
-    }
-
-
-    template <typename U>
-    void putNewInfallible(const Lookup& l, U&& u) {
-        impl.putNewInfallible(l, mozilla::Forward<U>(u));
-    }
-
-    void remove(const Lookup& l) {
-        if (Ptr p = lookup(l))
-            remove(p);
-    }
-
-
-
-    void rekeyIfMoved(const Lookup& old_value, const T& new_value) {
-        if (old_value != new_value)
-            rekeyAs(old_value, new_value, new_value);
-    }
-
-
-    bool rekeyAs(const Lookup& old_lookup, const Lookup& new_lookup, const T& new_value) {
-        if (Ptr p = lookup(old_lookup)) {
-            impl.rekeyAndMaybeRehash(p, new_lookup, new_value);
-            return true;
-        }
-        return false;
-    }
-
-
-
-
-
-    void replaceKey(Ptr p, const T& new_value) {
-        do { } while (0);
-        do { } while (0);
-        do { } while (0);
-        do { } while (0);
-        const_cast<T&>(*p) = new_value;
-    }
-
-
-    HashSet(HashSet&& rhs) : impl(mozilla::Move(rhs.impl)) {}
-    void operator=(HashSet&& rhs) {
-        do { } while (0);
-        impl = mozilla::Move(rhs.impl);
-    }
-
-  private:
-
-    HashSet(const HashSet& hs) = delete;
-    HashSet& operator=(const HashSet& hs) = delete;
-
-    friend class Impl::Enum;
-};
-# 587 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-template <typename Key, size_t zeroBits>
-struct PointerHasher
-{
-    typedef Key Lookup;
-    static HashNumber hash(const Lookup& l) {
-        size_t word = reinterpret_cast<size_t>(l) >> zeroBits;
-        static_assert(sizeof(HashNumber) == 4,
-                      "subsequent code assumes a four-byte hash");
-
-
-
-        static_assert(sizeof(word) == 8,
-                      "unexpected word size, new hashing strategy required to "
-                      "properly incorporate all bits");
-        return HashNumber((word >> 32) ^ word);
-
-    }
-    static bool match(const Key& k, const Lookup& l) {
-        return k == l;
-    }
-    static void rekey(Key& k, const Key& newKey) {
-        k = newKey;
-    }
-};
-
-
-
-
-
-template <class Key>
-struct DefaultHasher
-{
-    typedef Key Lookup;
-    static HashNumber hash(const Lookup& l) {
-
-        return l;
-    }
-    static bool match(const Key& k, const Lookup& l) {
-
-        return k == l;
-    }
-    static void rekey(Key& k, const Key& newKey) {
-        k = newKey;
-    }
-};
-
-
-
-template <class T>
-struct DefaultHasher<T*> : PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>
-{};
-
-
-
-template <class T, class D>
-struct DefaultHasher<mozilla::UniquePtr<T, D>>
-{
-    using Lookup = mozilla::UniquePtr<T, D>;
-    using PtrHasher = PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>;
-
-    static HashNumber hash(const Lookup& l) {
-        return PtrHasher::hash(l.get());
-    }
-    static bool match(const mozilla::UniquePtr<T, D>& k, const Lookup& l) {
-        return PtrHasher::match(k.get(), l.get());
-    }
-    static void rekey(mozilla::UniquePtr<T, D>& k, mozilla::UniquePtr<T, D>&& newKey) {
-        k = mozilla::Move(newKey);
-    }
-};
-
-
-template <>
-struct DefaultHasher<double>
-{
-    typedef double Lookup;
-    static HashNumber hash(double d) {
-        static_assert(sizeof(HashNumber) == 4,
-                      "subsequent code assumes a four-byte hash");
-        uint64_t u = mozilla::BitwiseCast<uint64_t>(d);
-        return HashNumber(u ^ (u >> 32));
-    }
-    static bool match(double lhs, double rhs) {
-        return mozilla::BitwiseCast<uint64_t>(lhs) == mozilla::BitwiseCast<uint64_t>(rhs);
-    }
-};
-
-template <>
-struct DefaultHasher<float>
-{
-    typedef float Lookup;
-    static HashNumber hash(float f) {
-        static_assert(sizeof(HashNumber) == 4,
-                      "subsequent code assumes a four-byte hash");
-        return HashNumber(mozilla::BitwiseCast<uint32_t>(f));
-    }
-    static bool match(float lhs, float rhs) {
-        return mozilla::BitwiseCast<uint32_t>(lhs) == mozilla::BitwiseCast<uint32_t>(rhs);
-    }
-};
-
-
-struct CStringHasher
-{
-    typedef const char* Lookup;
-    static js::HashNumber hash(Lookup l) {
-        return mozilla::HashString(l);
-    }
-    static bool match(const char* key, Lookup lookup) {
-        return strcmp(key, lookup) == 0;
-    }
-};
-# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-template <typename HashPolicy>
-struct FallibleHashMethods
-{
-
-
-    template <typename Lookup> static bool hasHash(Lookup&& l) { return true; }
-
-
-
-    template <typename Lookup> static bool ensureHash(Lookup&& l) { return true; }
-};
-
-template <typename HashPolicy, typename Lookup>
-static bool
-HasHash(Lookup&& l) {
-    return FallibleHashMethods<typename HashPolicy::Base>::hasHash(mozilla::Forward<Lookup>(l));
-}
-
-template <typename HashPolicy, typename Lookup>
-static bool
-EnsureHash(Lookup&& l) {
-    return FallibleHashMethods<typename HashPolicy::Base>::ensureHash(mozilla::Forward<Lookup>(l));
-}
-# 739 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-template <class Key, class Value>
-class HashMapEntry
-{
-    Key key_;
-    Value value_;
-
-    template <class, class, class> friend class detail::HashTable;
-    template <class> friend class detail::HashTableEntry;
-    template <class, class, class, class> friend class HashMap;
-
-  public:
-    template<typename KeyInput, typename ValueInput>
-    HashMapEntry(KeyInput&& k, ValueInput&& v)
-      : key_(mozilla::Forward<KeyInput>(k)),
-        value_(mozilla::Forward<ValueInput>(v))
-    {}
-
-    HashMapEntry(HashMapEntry&& rhs)
-      : key_(mozilla::Move(rhs.key_)),
-        value_(mozilla::Move(rhs.value_))
-    {}
-
-    void operator=(HashMapEntry&& rhs) {
-        key_ = mozilla::Move(rhs.key_);
-        value_ = mozilla::Move(rhs.value_);
-    }
-
-    typedef Key KeyType;
-    typedef Value ValueType;
-
-    const Key& key() const { return key_; }
-    Key& mutableKey() { return key_; }
-    const Value& value() const { return value_; }
-    Value& value() { return value_; }
-
-  private:
-    HashMapEntry(const HashMapEntry&) = delete;
-    void operator=(const HashMapEntry&) = delete;
-};
-
-}
-
-namespace mozilla {
-
-template <typename T>
-struct IsPod<js::detail::HashTableEntry<T> > : IsPod<T> {};
-
-template <typename K, typename V>
-struct IsPod<js::HashMapEntry<K, V> >
-  : IntegralConstant<bool, IsPod<K>::value && IsPod<V>::value>
-{};
-
-}
-
-namespace js {
-
-namespace detail {
-
-template <class T, class HashPolicy, class AllocPolicy>
-class HashTable;
-
-template <class T>
-class HashTableEntry
-{
-    template <class, class, class> friend class HashTable;
-    typedef typename mozilla::RemoveConst<T>::Type NonConstT;
-
-    HashNumber keyHash;
-    mozilla::AlignedStorage2<NonConstT> mem;
-
-    static const HashNumber sFreeKey = 0;
-    static const HashNumber sRemovedKey = 1;
-    static const HashNumber sCollisionBit = 1;
-
-    static bool isLiveHash(HashNumber hash)
-    {
-        return hash > sRemovedKey;
-    }
-
-    HashTableEntry(const HashTableEntry&) = delete;
-    void operator=(const HashTableEntry&) = delete;
-    ~HashTableEntry() = delete;
-
-  public:
-
-
-    void destroyIfLive() {
-        if (isLive())
-            mem.addr()->~T();
-    }
-
-    void destroy() {
-        do { } while (0);
-        mem.addr()->~T();
-    }
-
-    void swap(HashTableEntry* other) {
-        if (this == other)
-            return;
-        do { } while (0);
-        if (other->isLive()) {
-            mozilla::Swap(*mem.addr(), *other->mem.addr());
-        } else {
-            *other->mem.addr() = mozilla::Move(*mem.addr());
-            destroy();
-        }
-        mozilla::Swap(keyHash, other->keyHash);
-    }
-
-    T& get() { do { } while (0); return *mem.addr(); }
-    NonConstT& getMutable() { do { } while (0); return *mem.addr(); }
-
-    bool isFree() const { return keyHash == sFreeKey; }
-    void clearLive() { do { } while (0); keyHash = sFreeKey; mem.addr()->~T(); }
-    void clear() { if (isLive()) mem.addr()->~T(); keyHash = sFreeKey; }
-    bool isRemoved() const { return keyHash == sRemovedKey; }
-    void removeLive() { do { } while (0); keyHash = sRemovedKey; mem.addr()->~T(); }
-    bool isLive() const { return isLiveHash(keyHash); }
-    void setCollision() { do { } while (0); keyHash |= sCollisionBit; }
-    void unsetCollision() { keyHash &= ~sCollisionBit; }
-    bool hasCollision() const { return keyHash & sCollisionBit; }
-    bool matchHash(HashNumber hn) { return (keyHash & ~sCollisionBit) == hn; }
-    HashNumber getKeyHash() const { return keyHash & ~sCollisionBit; }
-
-    template <typename... Args>
-    void setLive(HashNumber hn, Args&&... args)
-    {
-        do { } while (0);
-        keyHash = hn;
-        new(mem.addr()) T(mozilla::Forward<Args>(args)...);
-        do { } while (0);
-    }
-};
-
-template <class T, class HashPolicy, class AllocPolicy>
-class HashTable : private AllocPolicy
-{
-    friend class mozilla::ReentrancyGuard;
-
-    typedef typename mozilla::RemoveConst<T>::Type NonConstT;
-    typedef typename HashPolicy::KeyType Key;
-    typedef typename HashPolicy::Lookup Lookup;
-
-  public:
-    typedef HashTableEntry<T> Entry;
-
-
-
-
-
-    class Ptr
-    {
-        friend class HashTable;
-
-        Entry* entry_;
-
-        const HashTable* table_;
-        Generation generation;
-
-
-      protected:
-        Ptr(Entry& entry, const HashTable& tableArg)
-          : entry_(&entry)
-
-          , table_(&tableArg)
-          , generation(tableArg.generation())
-
-        {}
-
-      public:
-        Ptr()
-          : entry_(nullptr)
-
-          , table_(nullptr)
-          , generation(0)
-
-        {}
-
-        bool isValid() const {
-            return !entry_;
-        }
-
-        bool found() const {
-            if (isValid())
-                return false;
-
-            do { } while (0);
-
-            return entry_->isLive();
-        }
-
-        explicit operator bool() const {
-            return found();
-        }
-
-        bool operator==(const Ptr& rhs) const {
-            do { } while (0);
-            return entry_ == rhs.entry_;
-        }
-
-        bool operator!=(const Ptr& rhs) const {
-
-            do { } while (0);
-
-            return !(*this == rhs);
-        }
-
-        T& operator*() const {
-
-            do { } while (0);
-            do { } while (0);
-
-            return entry_->get();
-        }
-
-        T* operator->() const {
-
-            do { } while (0);
-            do { } while (0);
-
-            return &entry_->get();
-        }
-    };
-
-
-    class AddPtr : public Ptr
-    {
-        friend class HashTable;
-        HashNumber keyHash;
-
-        uint64_t mutationCount;
-
-
-        AddPtr(Entry& entry, const HashTable& tableArg, HashNumber hn)
-          : Ptr(entry, tableArg)
-          , keyHash(hn)
-
-          , mutationCount(tableArg.mutationCount)
-
-        {}
-
-      public:
-        AddPtr() : keyHash(0) {}
-    };
-
-
-
-
-
-    class Range
-    {
-      protected:
-        friend class HashTable;
-
-        Range(const HashTable& tableArg, Entry* c, Entry* e)
-          : cur(c)
-          , end(e)
-
-          , table_(&tableArg)
-          , mutationCount(tableArg.mutationCount)
-          , generation(tableArg.generation())
-          , validEntry(true)
-
-        {
-            while (cur < end && !cur->isLive())
-                ++cur;
-        }
-
-        Entry* cur;
-        Entry* end;
-
-        const HashTable* table_;
-        uint64_t mutationCount;
-        Generation generation;
-        bool validEntry;
-
-
-      public:
-        Range()
-          : cur(nullptr)
-          , end(nullptr)
-
-          , table_(nullptr)
-          , mutationCount(0)
-          , generation(0)
-          , validEntry(false)
-
-        {}
-
-        bool empty() const {
-
-            do { } while (0);
-            do { } while (0);
-
-            return cur == end;
-        }
-
-        T& front() const {
-            do { } while (0);
-
-            do { } while (0);
-            do { } while (0);
-            do { } while (0);
-
-            return cur->get();
-        }
-
-        void popFront() {
-            do { } while (0);
-
-            do { } while (0);
-            do { } while (0);
-
-            while (++cur < end && !cur->isLive())
-                continue;
-
-            validEntry = true;
-
-        }
-    };
-
-
-
-
-
-
-    class Enum : public Range
-    {
-        friend class HashTable;
-
-        HashTable& table_;
-        bool rekeyed;
-        bool removed;
-
-
-        Enum(const Enum&) = delete;
-        void operator=(const Enum&) = delete;
-
-      public:
-        template<class Map> explicit
-        Enum(Map& map) : Range(map.all()), table_(map.impl), rekeyed(false), removed(false) {}
-# 1088 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/HashTable.h"
-        void removeFront() {
-            table_.remove(*this->cur);
-            removed = true;
-
-            this->validEntry = false;
-            this->mutationCount = table_.mutationCount;
-
-        }
-
-        NonConstT& mutableFront() {
-            do { } while (0);
-
-            do { } while (0);
-            do { } while (0);
-            do { } while (0);
-
-            return this->cur->getMutable();
-        }
-
-
-
-
-        void rekeyFront(const Lookup& l, const Key& k) {
-            do { } while (0);
-            Ptr p(*this->cur, table_);
-            table_.rekeyWithoutRehash(p, l, k);
-            rekeyed = true;
-
-            this->validEntry = false;
-            this->mutationCount = table_.mutationCount;
-
-        }
-
-        void rekeyFront(const Key& k) {
-            rekeyFront(k, k);
-        }
-
-
-        ~Enum() {
-            if (rekeyed) {
-                table_.gen++;
-                table_.checkOverRemoved();
-            }
-
-            if (removed)
-                table_.compactIfUnderloaded();
-        }
-    };
-
-
-    HashTable(HashTable&& rhs)
-      : AllocPolicy(rhs)
-    {
-        mozilla::PodAssign(this, &rhs);
-        rhs.table = nullptr;
-    }
-    void operator=(HashTable&& rhs) {
-        do { } while (0);
-        if (table)
-            destroyTable(*this, table, capacity());
-        mozilla::PodAssign(this, &rhs);
-        rhs.table = nullptr;
-    }
-
-  private:
-
-    HashTable(const HashTable&) = delete;
-    void operator=(const HashTable&) = delete;
-
-  private:
-    static const size_t CAP_BITS = 30;
-
-  public:
-    uint64_t gen:56;
-    uint64_t hashShift:8;
-    Entry* table;
-    uint32_t entryCount;
-    uint32_t removedCount;
-
-
-    uint64_t mutationCount;
-    mutable bool mEntered;
-
-
-    mutable struct Stats
-    {
-        uint32_t searches;
-        uint32_t steps;
-        uint32_t hits;
-        uint32_t misses;
-        uint32_t addOverRemoved;
-        uint32_t removes;
-        uint32_t removeFrees;
-        uint32_t grows;
-        uint32_t shrinks;
-        uint32_t compresses;
-        uint32_t rehashes;
-    } stats;
-
-
-
-
-
-
-
-    static const unsigned sMinCapacityLog2 = 2;
-    static const unsigned sMinCapacity = 1 << sMinCapacityLog2;
-    static const unsigned sMaxInit = ((uint32_t)1 << (CAP_BITS - 1));
-    static const unsigned sMaxCapacity = ((uint32_t)1 << (CAP_BITS));
-    static const unsigned sHashBits = mozilla::tl::BitSize<HashNumber>::value;
-
-
-
-    static const uint8_t sAlphaDenominator = 4;
-    static const uint8_t sMinAlphaNumerator = 1;
-    static const uint8_t sMaxAlphaNumerator = 3;
-
-    static const HashNumber sFreeKey = Entry::sFreeKey;
-    static const HashNumber sRemovedKey = Entry::sRemovedKey;
-    static const HashNumber sCollisionBit = Entry::sCollisionBit;
-
-    void setTableSizeLog2(unsigned sizeLog2)
-    {
-        hashShift = sHashBits - sizeLog2;
-    }
-
-    static bool isLiveHash(HashNumber hash)
-    {
-        return Entry::isLiveHash(hash);
-    }
-
-    static HashNumber prepareHash(const Lookup& l)
-    {
-        HashNumber keyHash = ScrambleHashCode(HashPolicy::hash(l));
-
-
-        if (!isLiveHash(keyHash))
-            keyHash -= (sRemovedKey + 1);
-        return keyHash & ~sCollisionBit;
-    }
-
-    enum FailureBehavior { DontReportFailure = false, ReportFailure = true };
-
-    static Entry* createTable(AllocPolicy& alloc, uint32_t capacity,
-                              FailureBehavior reportFailure = ReportFailure)
-    {
-        static_assert(sFreeKey == 0,
-                      "newly-calloc'd tables have to be considered empty");
-        if (reportFailure)
-            return alloc.template pod_calloc<Entry>(capacity);
-
-        return alloc.template maybe_pod_calloc<Entry>(capacity);
-    }
-
-    static Entry* maybeCreateTable(AllocPolicy& alloc, uint32_t capacity)
-    {
-        static_assert(sFreeKey == 0,
-                      "newly-calloc'd tables have to be considered empty");
-        return alloc.template maybe_pod_calloc<Entry>(capacity);
-    }
-
-    static void destroyTable(AllocPolicy& alloc, Entry* oldTable, uint32_t capacity)
-    {
-        Entry* end = oldTable + capacity;
-        for (Entry* e = oldTable; e < end; ++e)
-            e->destroyIfLive();
-        alloc.free_(oldTable);
-    }
-
-  public:
-    explicit HashTable(AllocPolicy ap)
-      : AllocPolicy(ap)
-      , gen(0)
-      , hashShift(sHashBits)
-      , table(nullptr)
-      , entryCount(0)
-      , removedCount(0)
-
-      , mutationCount(0)
-      , mEntered(false)
-
-    {}
-
-    __attribute__ ((warn_unused_result)) bool init(uint32_t length)
-    {
-        do { } while (0);
-
-
-
-
-        if ((__builtin_expect(!!(length > sMaxInit), 0))) {
-            this->reportAllocOverflow();
-            return false;
-        }
-
-        static_assert((sMaxInit * sAlphaDenominator) / sAlphaDenominator == sMaxInit,
-                      "multiplication in numerator below could overflow");
-        static_assert(sMaxInit * sAlphaDenominator <= (4294967295U) - sMaxAlphaNumerator,
-                      "numerator calculation below could potentially overflow");
-
-
-
-
-        uint32_t newCapacity =
-            (length * sAlphaDenominator + sMaxAlphaNumerator - 1) / sMaxAlphaNumerator;
-        if (newCapacity < sMinCapacity)
-            newCapacity = sMinCapacity;
-
-
-        uint32_t roundUp = sMinCapacity, roundUpLog2 = sMinCapacityLog2;
-        while (roundUp < newCapacity) {
-            roundUp <<= 1;
-            ++roundUpLog2;
-        }
-
-        newCapacity = roundUp;
-        do { } while (0);
-        do { } while (0);
-
-        table = createTable(*this, newCapacity);
-        if (!table)
-            return false;
-
-        setTableSizeLog2(roundUpLog2);
-        memset(&stats, 0, sizeof(stats));
-        return true;
-    }
-
-    bool initialized() const
-    {
-        return !!table;
-    }
-
-    ~HashTable()
-    {
-        if (table)
-            destroyTable(*this, table, capacity());
-    }
-
-  private:
-    HashNumber hash1(HashNumber hash0) const
-    {
-        return hash0 >> hashShift;
-    }
-
-    struct DoubleHash
-    {
-        HashNumber h2;
-        HashNumber sizeMask;
-    };
-
-    DoubleHash hash2(HashNumber curKeyHash) const
-    {
-        unsigned sizeLog2 = sHashBits - hashShift;
-        DoubleHash dh = {
-            ((curKeyHash << sizeLog2) >> hashShift) | 1,
-            (HashNumber(1) << sizeLog2) - 1
-        };
-        return dh;
-    }
-
-    static HashNumber applyDoubleHash(HashNumber h1, const DoubleHash& dh)
-    {
-        return (h1 - dh.h2) & dh.sizeMask;
-    }
-
-    bool overloaded()
-    {
-        static_assert(sMaxCapacity <= (4294967295U) / sMaxAlphaNumerator,
-                      "multiplication below could overflow");
-        return entryCount + removedCount >=
-               capacity() * sMaxAlphaNumerator / sAlphaDenominator;
-    }
-
-
-    static bool wouldBeUnderloaded(uint32_t capacity, uint32_t entryCount)
-    {
-        static_assert(sMaxCapacity <= (4294967295U) / sMinAlphaNumerator,
-                      "multiplication below could overflow");
-        return capacity > sMinCapacity &&
-               entryCount <= capacity * sMinAlphaNumerator / sAlphaDenominator;
-    }
-
-    bool underloaded()
-    {
-        return wouldBeUnderloaded(capacity(), entryCount);
-    }
-
-    static __attribute__((always_inline)) inline bool match(Entry& e, const Lookup& l)
-    {
-        return HashPolicy::match(HashPolicy::getKey(e.get()), l);
-    }
-
-
-
-
-
-
-    __attribute__((always_inline)) inline Entry&
-    lookup(const Lookup& l, HashNumber keyHash, unsigned collisionBit) const
-    {
-        do { } while (0);
-        do { } while (0);
-        do { } while (0);
-        do { } while (0);
-        stats.searches++;
-
-
-        HashNumber h1 = hash1(keyHash);
-        Entry* entry = &table[h1];
-
-
-        if (entry->isFree()) {
-            stats.misses++;
-            return *entry;
-        }
-
-
-        if (entry->matchHash(keyHash) && match(*entry, l)) {
-            stats.hits++;
-            return *entry;
-        }
-
-
-        DoubleHash dh = hash2(keyHash);
-
-
-        Entry* firstRemoved = nullptr;
-
-        while (true) {
-            if ((__builtin_expect(!!(entry->isRemoved()), 0))) {
-                if (!firstRemoved)
-                    firstRemoved = entry;
-            } else {
-                if (collisionBit == sCollisionBit)
-                    entry->setCollision();
-            }
-
-            stats.steps++;
-            h1 = applyDoubleHash(h1, dh);
-
-            entry = &table[h1];
-            if (entry->isFree()) {
-                stats.misses++;
-                return firstRemoved ? *firstRemoved : *entry;
-            }
-
-            if (entry->matchHash(keyHash) && match(*entry, l)) {
-                stats.hits++;
-                return *entry;
-            }
-        }
-    }
-
-
-
-
-
-
-
-    Entry& findFreeEntry(HashNumber keyHash)
-    {
-        do { } while (0);
-        do { } while (0);
-        stats.searches++;
-
-
-
-
-        HashNumber h1 = hash1(keyHash);
-        Entry* entry = &table[h1];
-
-
-        if (!entry->isLive()) {
-            stats.misses++;
-            return *entry;
-        }
-
-
-        DoubleHash dh = hash2(keyHash);
-
-        while (true) {
-            do { } while (0);
-            entry->setCollision();
-
-            stats.steps++;
-            h1 = applyDoubleHash(h1, dh);
-
-            entry = &table[h1];
-            if (!entry->isLive()) {
-                stats.misses++;
-                return *entry;
-            }
-        }
-    }
-
-    enum RebuildStatus { NotOverloaded, Rehashed, RehashFailed };
-
-    RebuildStatus changeTableSize(int deltaLog2, FailureBehavior reportFailure = ReportFailure)
-    {
-
-        Entry* oldTable = table;
-        uint32_t oldCap = capacity();
-        uint32_t newLog2 = sHashBits - hashShift + deltaLog2;
-        uint32_t newCapacity = ((uint32_t)1 << (newLog2));
-        if ((__builtin_expect(!!(newCapacity > sMaxCapacity), 0))) {
-            if (reportFailure)
-                this->reportAllocOverflow();
-            return RehashFailed;
-        }
-
-        Entry* newTable = createTable(*this, newCapacity, reportFailure);
-        if (!newTable)
-            return RehashFailed;
-
-
-        setTableSizeLog2(newLog2);
-        removedCount = 0;
-        gen++;
-        table = newTable;
-
-
-        Entry* end = oldTable + oldCap;
-        for (Entry* src = oldTable; src < end; ++src) {
-            if (src->isLive()) {
-                HashNumber hn = src->getKeyHash();
-                findFreeEntry(hn).setLive(
-                    hn, mozilla::Move(const_cast<typename Entry::NonConstT&>(src->get())));
-                src->destroy();
-            }
-        }
-
-
-        this->free_(oldTable);
-        return Rehashed;
-    }
-
-    bool shouldCompressTable()
-    {
-
-        return removedCount >= (capacity() >> 2);
-    }
-
-    RebuildStatus checkOverloaded(FailureBehavior reportFailure = ReportFailure)
-    {
-        if (!overloaded())
-            return NotOverloaded;
-
-        int deltaLog2;
-        if (shouldCompressTable()) {
-            stats.compresses++;
-            deltaLog2 = 0;
-        } else {
-            stats.grows++;
-            deltaLog2 = 1;
-        }
-
-        return changeTableSize(deltaLog2, reportFailure);
-    }
-
-
-    void checkOverRemoved()
-    {
-        if (overloaded()) {
-            if (checkOverloaded(DontReportFailure) == RehashFailed)
-                rehashTableInPlace();
-        }
-    }
-
-    void remove(Entry& e)
-    {
-        do { } while (0);
-        stats.removes++;
-
-        if (e.hasCollision()) {
-            e.removeLive();
-            removedCount++;
-        } else {
-            stats.removeFrees++;
-            e.clearLive();
-        }
-        entryCount--;
-
-        mutationCount++;
-
-    }
-
-    void checkUnderloaded()
-    {
-        if (underloaded()) {
-            stats.shrinks++;
-            (void) changeTableSize(-1, DontReportFailure);
-        }
-    }
-
-
-
-
-    void compactIfUnderloaded()
-    {
-        int32_t resizeLog2 = 0;
-        uint32_t newCapacity = capacity();
-        while (wouldBeUnderloaded(newCapacity, entryCount)) {
-            newCapacity = newCapacity >> 1;
-            resizeLog2--;
-        }
-
-        if (resizeLog2 != 0)
-            (void) changeTableSize(resizeLog2, DontReportFailure);
-    }
-
-
-
-
-
-
-    void rehashTableInPlace()
-    {
-        stats.rehashes++;
-        removedCount = 0;
-        for (size_t i = 0; i < capacity(); ++i)
-            table[i].unsetCollision();
-
-        for (size_t i = 0; i < capacity();) {
-            Entry* src = &table[i];
-
-            if (!src->isLive() || src->hasCollision()) {
-                ++i;
-                continue;
-            }
-
-            HashNumber keyHash = src->getKeyHash();
-            HashNumber h1 = hash1(keyHash);
-            DoubleHash dh = hash2(keyHash);
-            Entry* tgt = &table[h1];
-            while (true) {
-                if (!tgt->hasCollision()) {
-                    src->swap(tgt);
-                    tgt->setCollision();
-                    break;
-                }
-
-                h1 = applyDoubleHash(h1, dh);
-                tgt = &table[h1];
-            }
-        }
-
-
-
-
-
-
-    }
-
-
-
-
-
-
-    template <typename... Args>
-    void putNewInfallibleInternal(const Lookup& l, Args&&... args)
-    {
-        do { } while (0);
-
-        HashNumber keyHash = prepareHash(l);
-        Entry* entry = &findFreeEntry(keyHash);
-        do { } while (0);
-
-        if (entry->isRemoved()) {
-            stats.addOverRemoved++;
-            removedCount--;
-            keyHash |= sCollisionBit;
-        }
-
-        entry->setLive(keyHash, mozilla::Forward<Args>(args)...);
-        entryCount++;
-
-        mutationCount++;
-
-    }
-
-  public:
-    void clear()
-    {
-        if (mozilla::IsPod<Entry>::value) {
-            memset(table, 0, sizeof(*table) * capacity());
-        } else {
-            uint32_t tableCapacity = capacity();
-            Entry* end = table + tableCapacity;
-            for (Entry* e = table; e < end; ++e)
-                e->clear();
-        }
-        removedCount = 0;
-        entryCount = 0;
-
-        mutationCount++;
-
-    }
-
-    void clearAndShrink()
-    {
-        clear();
-        compactIfUnderloaded();
-    }
-
-    void finish()
-    {
-
-        do { } while (0);
-
-        if (!table)
-            return;
-
-        destroyTable(*this, table, capacity());
-        table = nullptr;
-        gen++;
-        entryCount = 0;
-        removedCount = 0;
-
-        mutationCount++;
-
-    }
-
-    Range all() const
-    {
-        do { } while (0);
-        return Range(*this, table, table + capacity());
-    }
-
-    bool empty() const
-    {
-        do { } while (0);
-        return !entryCount;
-    }
-
-    uint32_t count() const
-    {
-        do { } while (0);
-        return entryCount;
-    }
-
-    uint32_t capacity() const
-    {
-        do { } while (0);
-        return ((uint32_t)1 << (sHashBits - hashShift));
-    }
-
-    Generation generation() const
-    {
-        do { } while (0);
-        return Generation(gen);
-    }
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
-    {
-        return mallocSizeOf(table);
-    }
-
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
-    {
-        return mallocSizeOf(this) + sizeOfExcludingThis(mallocSizeOf);
-    }
-
-    __attribute__((always_inline)) inline Ptr lookup(const Lookup& l) const
-    {
-        mozilla::ReentrancyGuard g(*this);
-        if (!HasHash<HashPolicy>(l))
-            return Ptr();
-        HashNumber keyHash = prepareHash(l);
-        return Ptr(lookup(l, keyHash, 0), *this);
-    }
-
-    __attribute__((always_inline)) inline Ptr readonlyThreadsafeLookup(const Lookup& l) const
-    {
-        if (!HasHash<HashPolicy>(l))
-            return Ptr();
-        HashNumber keyHash = prepareHash(l);
-        return Ptr(lookup(l, keyHash, 0), *this);
-    }
-
-    __attribute__((always_inline)) inline AddPtr lookupForAdd(const Lookup& l) const
-    {
-        mozilla::ReentrancyGuard g(*this);
-        if (!EnsureHash<HashPolicy>(l))
-            return AddPtr();
-        HashNumber keyHash = prepareHash(l);
-        Entry& entry = lookup(l, keyHash, sCollisionBit);
-        AddPtr p(entry, *this, keyHash);
-        return p;
-    }
-
-    template <typename... Args>
-    __attribute__ ((warn_unused_result)) bool add(AddPtr& p, Args&&... args)
-    {
-        mozilla::ReentrancyGuard g(*this);
-        do { } while (0);
-        do { } while (0);
-        do { } while (0);
-
-
-        if (p.isValid())
-            return false;
-
-
-
-        if (p.entry_->isRemoved()) {
-            if (!this->checkSimulatedOOM())
-                return false;
-            stats.addOverRemoved++;
-            removedCount--;
-            p.keyHash |= sCollisionBit;
-        } else {
-
-            RebuildStatus status = checkOverloaded();
-            if (status == RehashFailed)
-                return false;
-            if (status == NotOverloaded && !this->checkSimulatedOOM())
-                return false;
-            if (status == Rehashed)
-                p.entry_ = &findFreeEntry(p.keyHash);
-        }
-
-        p.entry_->setLive(p.keyHash, mozilla::Forward<Args>(args)...);
-        entryCount++;
-
-        mutationCount++;
-        p.generation = generation();
-        p.mutationCount = mutationCount;
-
-        return true;
-    }
-
-
-
-    template <typename... Args>
-    void putNewInfallible(const Lookup& l, Args&&... args)
-    {
-        do { } while (0);
-        mozilla::ReentrancyGuard g(*this);
-        putNewInfallibleInternal(l, mozilla::Forward<Args>(args)...);
-    }
-
-
-
-    template <typename... Args>
-    __attribute__ ((warn_unused_result)) bool putNew(const Lookup& l, Args&&... args)
-    {
-        if (!this->checkSimulatedOOM())
-            return false;
-
-        if (!EnsureHash<HashPolicy>(l))
-            return false;
-
-        if (checkOverloaded() == RehashFailed)
-            return false;
-
-        putNewInfallible(l, mozilla::Forward<Args>(args)...);
-        return true;
-    }
-
-
-
-    template <typename... Args>
-    __attribute__ ((warn_unused_result)) bool relookupOrAdd(AddPtr& p, const Lookup& l, Args&&... args)
-    {
-
-        if (p.isValid())
-            return false;
-
-
-        p.generation = generation();
-        p.mutationCount = mutationCount;
-
-        {
-            mozilla::ReentrancyGuard g(*this);
-            do { } while (0);
-            p.entry_ = &lookup(l, p.keyHash, sCollisionBit);
-        }
-        return p.found() || add(p, mozilla::Forward<Args>(args)...);
-    }
-
-    void remove(Ptr p)
-    {
-        do { } while (0);
-        mozilla::ReentrancyGuard g(*this);
-        do { } while (0);
-        remove(*p.entry_);
-        checkUnderloaded();
-    }
-
-    void rekeyWithoutRehash(Ptr p, const Lookup& l, const Key& k)
-    {
-        do { } while (0);
-        mozilla::ReentrancyGuard g(*this);
-        do { } while (0);
-        typename HashTableEntry<T>::NonConstT t(mozilla::Move(*p));
-        HashPolicy::setKey(t, const_cast<Key&>(k));
-        remove(*p.entry_);
-        putNewInfallibleInternal(l, mozilla::Move(t));
-    }
-
-    void rekeyAndMaybeRehash(Ptr p, const Lookup& l, const Key& k)
-    {
-        rekeyWithoutRehash(p, l, k);
-        checkOverRemoved();
-    }
-
-
-};
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h" 2
-
-
-
-class JSTracer;
-
-namespace JS {
-class CallbackTracer;
-template <typename T> class Heap;
-template <typename T> class TenuredHeap;
-
-
-const char*
-GCTraceKindToAscii(JS::TraceKind kind);
-
-}
-
-enum WeakMapTraceKind {
-
-
-
-
-    DoNotTraceWeakMaps,
-
-
-
-
-
-    ExpandWeakMaps,
-
-
-
-
-
-    TraceWeakMapValues,
-
-
-
-
-
-    TraceWeakMapKeysValues
-};
-
-class JSTracer
-{
-  public:
-
-    JSRuntime* runtime() const { return runtime_; }
-
-
-    WeakMapTraceKind weakMapAction() const { return weakMapAction_; }
-
-    enum class TracerKindTag {
-
-
-
-        Marking,
-
-
-
-
-
-        WeakMarking,
-
-
-
-        Tenuring,
-
-
-
-        Callback
-    };
-    bool isMarkingTracer() const { return tag_ == TracerKindTag::Marking || tag_ == TracerKindTag::WeakMarking; }
-    bool isWeakMarkingTracer() const { return tag_ == TracerKindTag::WeakMarking; }
-    bool isTenuringTracer() const { return tag_ == TracerKindTag::Tenuring; }
-    bool isCallbackTracer() const { return tag_ == TracerKindTag::Callback; }
-    inline JS::CallbackTracer* asCallbackTracer();
-    bool traceWeakEdges() const { return traceWeakEdges_; }
-
-
-
-
-  protected:
-    JSTracer(JSRuntime* rt, TracerKindTag tag,
-             WeakMapTraceKind weakTraceKind = TraceWeakMapValues)
-      : runtime_(rt)
-      , weakMapAction_(weakTraceKind)
-
-
-
-      , tag_(tag)
-      , traceWeakEdges_(true)
-    {}
-# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
-  private:
-    JSRuntime* runtime_;
-    WeakMapTraceKind weakMapAction_;
-
-
-
-
-  protected:
-    TracerKindTag tag_;
-    bool traceWeakEdges_;
-};
-
-namespace JS {
-
-class AutoTracingName;
-class AutoTracingIndex;
-class AutoTracingCallback;
-
-class CallbackTracer : public JSTracer
-{
-  public:
-    CallbackTracer(JSRuntime* rt, WeakMapTraceKind weakTraceKind = TraceWeakMapValues)
-      : JSTracer(rt, JSTracer::TracerKindTag::Callback, weakTraceKind),
-        contextName_(nullptr), contextIndex_(InvalidIndex), contextFunctor_(nullptr)
-    {}
-    CallbackTracer(JSContext* cx, WeakMapTraceKind weakTraceKind = TraceWeakMapValues);
-
-
-
-
-
-
-    virtual void onObjectEdge(JSObject** objp) { onChild(JS::GCCellPtr(*objp)); }
-    virtual void onStringEdge(JSString** strp) { onChild(JS::GCCellPtr(*strp)); }
-    virtual void onSymbolEdge(JS::Symbol** symp) { onChild(JS::GCCellPtr(*symp)); }
-    virtual void onScriptEdge(JSScript** scriptp) { onChild(JS::GCCellPtr(*scriptp)); }
-    virtual void onShapeEdge(js::Shape** shapep) {
-        onChild(JS::GCCellPtr(*shapep, JS::TraceKind::Shape));
-    }
-    virtual void onObjectGroupEdge(js::ObjectGroup** groupp) {
-        onChild(JS::GCCellPtr(*groupp, JS::TraceKind::ObjectGroup));
-    }
-    virtual void onBaseShapeEdge(js::BaseShape** basep) {
-        onChild(JS::GCCellPtr(*basep, JS::TraceKind::BaseShape));
-    }
-    virtual void onJitCodeEdge(js::jit::JitCode** codep) {
-        onChild(JS::GCCellPtr(*codep, JS::TraceKind::JitCode));
-    }
-    virtual void onLazyScriptEdge(js::LazyScript** lazyp) {
-        onChild(JS::GCCellPtr(*lazyp, JS::TraceKind::LazyScript));
-    }
-    virtual void onScopeEdge(js::Scope** scopep) {
-        onChild(JS::GCCellPtr(*scopep, JS::TraceKind::Scope));
-    }
-    virtual void onRegExpSharedEdge(js::RegExpShared** sharedp) {
-        onChild(JS::GCCellPtr(*sharedp, JS::TraceKind::RegExpShared));
-    }
-
-
-
-    virtual void onChild(const JS::GCCellPtr& thing) = 0;
-# 195 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
-    const char* contextName() const { do { } while (0); return contextName_; }
-
-
-
-
-    const static size_t InvalidIndex = size_t(-1);
-    size_t contextIndex() const { return contextIndex_; }
-
-
-
-
-
-
-    void getTracingEdgeName(char* buffer, size_t bufferSize);
-
-
-
-
-
-
-    class ContextFunctor {
-      public:
-        virtual void operator()(CallbackTracer* trc, char* buf, size_t bufsize) = 0;
-    };
-# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
-    void dispatchToOnEdge(JSObject** objp) { onObjectEdge(objp); }
-    void dispatchToOnEdge(JSString** strp) { onStringEdge(strp); }
-    void dispatchToOnEdge(JS::Symbol** symp) { onSymbolEdge(symp); }
-    void dispatchToOnEdge(JSScript** scriptp) { onScriptEdge(scriptp); }
-    void dispatchToOnEdge(js::Shape** shapep) { onShapeEdge(shapep); }
-    void dispatchToOnEdge(js::ObjectGroup** groupp) { onObjectGroupEdge(groupp); }
-    void dispatchToOnEdge(js::BaseShape** basep) { onBaseShapeEdge(basep); }
-    void dispatchToOnEdge(js::jit::JitCode** codep) { onJitCodeEdge(codep); }
-    void dispatchToOnEdge(js::LazyScript** lazyp) { onLazyScriptEdge(lazyp); }
-    void dispatchToOnEdge(js::Scope** scopep) { onScopeEdge(scopep); }
-    void dispatchToOnEdge(js::RegExpShared** sharedp) { onRegExpSharedEdge(sharedp); }
-
-  protected:
-    void setTraceWeakEdges(bool value) {
-        traceWeakEdges_ = value;
-    }
-
-  private:
-    friend class AutoTracingName;
-    const char* contextName_;
-
-    friend class AutoTracingIndex;
-    size_t contextIndex_;
-
-    friend class AutoTracingDetails;
-    ContextFunctor* contextFunctor_;
-};
-
-
-class AutoTracingName
-{
-    CallbackTracer* trc_;
-    const char* prior_;
-
-  public:
-    AutoTracingName(CallbackTracer* trc, const char* name) : trc_(trc), prior_(trc->contextName_) {
-        do { } while (0);
-        trc->contextName_ = name;
-    }
-    ~AutoTracingName() {
-        do { } while (0);
-        trc_->contextName_ = prior_;
-    }
-};
-
-
-class AutoTracingIndex
-{
-    CallbackTracer* trc_;
-
-  public:
-    explicit AutoTracingIndex(JSTracer* trc, size_t initial = 0) : trc_(nullptr) {
-        if (trc->isCallbackTracer()) {
-            trc_ = trc->asCallbackTracer();
-            do { } while (0);
-            trc_->contextIndex_ = initial;
-        }
-    }
-    ~AutoTracingIndex() {
-        if (trc_) {
-            do { } while (0);
-            trc_->contextIndex_ = CallbackTracer::InvalidIndex;
-        }
-    }
-
-    void operator++() {
-        if (trc_) {
-            do { } while (0);
-            ++trc_->contextIndex_;
-        }
-    }
-};
-
-
-
-class AutoTracingDetails
-{
-    CallbackTracer* trc_;
-
-  public:
-    AutoTracingDetails(JSTracer* trc, CallbackTracer::ContextFunctor& func) : trc_(nullptr) {
-        if (trc->isCallbackTracer()) {
-            trc_ = trc->asCallbackTracer();
-            do { } while (0);
-            trc_->contextFunctor_ = &func;
-        }
-    }
-    ~AutoTracingDetails() {
-        if (trc_) {
-            do { } while (0);
-            trc_->contextFunctor_ = nullptr;
-        }
-    }
-};
-
-}
-
-JS::CallbackTracer*
-JSTracer::asCallbackTracer()
-{
-    do { } while (0);
-    return static_cast<JS::CallbackTracer*>(this);
-}
-
-namespace JS {
-# 350 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/TracingAPI.h"
-template <typename T>
-extern void
-TraceEdge(JSTracer* trc, JS::Heap<T>* edgep, const char* name);
-
-extern void
-TraceEdge(JSTracer* trc, JS::TenuredHeap<JSObject*>* edgep, const char* name);
-
-
-
-
-
-
-
-template <typename T>
-extern void
-UnsafeTraceRoot(JSTracer* trc, T* edgep, const char* name);
-
-extern void
-TraceChildren(JSTracer* trc, GCCellPtr thing);
-
-using ZoneSet = js::HashSet<Zone*, js::DefaultHasher<Zone*>, js::SystemAllocPolicy>;
-using CompartmentSet = js::HashSet<JSCompartment*, js::DefaultHasher<JSCompartment*>,
-                                   js::SystemAllocPolicy>;
-
-
-
-
-
-
-extern void
-TraceIncomingCCWs(JSTracer* trc, const JS::CompartmentSet& compartments);
-
-}
-
-extern void
-JS_GetTraceThingInfo(char* buf, size_t bufsize, JSTracer* trc,
-                     void* thing, JS::TraceKind kind, bool includeDetails);
-
-namespace js {
-
-
-
-
-
-
-template <typename T>
-extern void
-UnsafeTraceManuallyBarrieredEdge(JSTracer* trc, T* edgep, const char* name);
-
-namespace gc {
-
-
-template <typename T>
-extern bool
-EdgeNeedsSweep(JS::Heap<T>* edgep);
-
-
-
-template <typename T>
-bool
-IsAboutToBeFinalizedUnbarriered(T* thingp);
-
-}
-}
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h" 2
-# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCPolicyAPI.h"
-class JSAtom;
-class JSFunction;
-class JSObject;
-class JSScript;
-class JSString;
-namespace JS {
-class Symbol;
-}
-
-namespace JS {
-
-
-
-template <typename T>
-struct StructGCPolicy
-{
-    static T initial() {
-        return T();
-    }
-
-    static void trace(JSTracer* trc, T* tp, const char* name) {
-        tp->trace(trc);
-    }
-
-    static void sweep(T* tp) {
-        return tp->sweep();
-    }
-
-    static bool needsSweep(T* tp) {
-        return tp->needsSweep();
-    }
-};
-
-
-
-
-
-template <typename T> struct GCPolicy : public StructGCPolicy<T> {};
-
-
-template <typename T>
-struct IgnoreGCPolicy {
-    static T initial() { return T(); }
-    static void trace(JSTracer* trc, T* t, const char* name) {}
-    static bool needsSweep(T* v) { return false; }
-};
-template <> struct GCPolicy<uint32_t> : public IgnoreGCPolicy<uint32_t> {};
-template <> struct GCPolicy<uint64_t> : public IgnoreGCPolicy<uint64_t> {};
-
-template <typename T>
-struct GCPointerPolicy
-{
-    static T initial() { return nullptr; }
-    static void trace(JSTracer* trc, T* vp, const char* name) {
-        if (*vp)
-            js::UnsafeTraceManuallyBarrieredEdge(trc, vp, name);
-    }
-    static bool needsSweep(T* vp) {
-        if (*vp)
-            return js::gc::IsAboutToBeFinalizedUnbarriered(vp);
-        return false;
-    }
-};
-template <> struct GCPolicy<JS::Symbol*> : public GCPointerPolicy<JS::Symbol*> {};
-template <> struct GCPolicy<JSAtom*> : public GCPointerPolicy<JSAtom*> {};
-template <> struct GCPolicy<JSFunction*> : public GCPointerPolicy<JSFunction*> {};
-template <> struct GCPolicy<JSObject*> : public GCPointerPolicy<JSObject*> {};
-template <> struct GCPolicy<JSScript*> : public GCPointerPolicy<JSScript*> {};
-template <> struct GCPolicy<JSString*> : public GCPointerPolicy<JSString*> {};
-
-template <typename T>
-struct GCPolicy<JS::Heap<T>>
-{
-    static void trace(JSTracer* trc, JS::Heap<T>* thingp, const char* name) {
-        TraceEdge(trc, thingp, name);
-    }
-    static bool needsSweep(JS::Heap<T>* thingp) {
-        return js::gc::EdgeNeedsSweep(thingp);
-    }
-};
-
-
-template <typename T, typename D>
-struct GCPolicy<mozilla::UniquePtr<T, D>>
-{
-    static mozilla::UniquePtr<T,D> initial() { return mozilla::UniquePtr<T,D>(); }
-    static void trace(JSTracer* trc, mozilla::UniquePtr<T,D>* tp, const char* name) {
-        if (tp->get())
-            GCPolicy<T>::trace(trc, tp->get(), name);
-    }
-    static bool needsSweep(mozilla::UniquePtr<T,D>* tp) {
-        if (tp->get())
-            return GCPolicy<T>::needsSweep(tp->get());
-        return false;
-    }
-};
-
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h" 2
-# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-namespace js {
-
-template <typename T>
-struct BarrierMethods {
-};
-
-template <typename Element, typename Wrapper>
-class WrappedPtrOperations {};
-
-template <typename Element, typename Wrapper>
-class MutableWrappedPtrOperations : public WrappedPtrOperations<Element, Wrapper> {};
-
-template <typename T, typename Wrapper>
-class RootedBase : public MutableWrappedPtrOperations<T, Wrapper> {};
-
-template <typename T, typename Wrapper>
-class HandleBase : public WrappedPtrOperations<T, Wrapper> {};
-
-template <typename T, typename Wrapper>
-class MutableHandleBase : public MutableWrappedPtrOperations<T, Wrapper> {};
-
-template <typename T, typename Wrapper>
-class HeapBase : public MutableWrappedPtrOperations<T, Wrapper> {};
-
-
-template <typename T> struct IsHeapConstructibleType { static constexpr bool value = false; };
-
-
-template <> struct IsHeapConstructibleType<JS::Symbol*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSAtom*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSFunction*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSObject*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSScript*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSString*> { static constexpr bool value = true; };
-template <> struct IsHeapConstructibleType<JS::Value> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<jsid> { static constexpr bool value = true; };
-
-
-template <typename T, typename Wrapper>
-class PersistentRootedBase : public MutableWrappedPtrOperations<T, Wrapper> {};
-
-namespace gc {
-struct Cell;
-template<typename T>
-struct PersistentRootedMarker;
-}
-# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-}
-
-namespace JS {
-
-template <typename T> class Rooted;
-template <typename T> class PersistentRooted;
-
-
-bool isGCEnabled();
-
-void HeapObjectPostBarrier(JSObject** objp, JSObject* prev, JSObject* next);
-
-
-
-
-
-
-extern void
-AssertGCThingMustBeTenured(JSObject* obj);
-extern void
-AssertGCThingIsNotAnObjectSubclass(js::gc::Cell* cell);
-# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class Heap : public js::HeapBase<T, Heap<T>>
-{
-
-    static_assert(js::IsHeapConstructibleType<T>::value,
-                  "Type T must be a public GC pointer type");
-  public:
-    using ElementType = T;
-
-    Heap() {
-        static_assert(sizeof(T) == sizeof(Heap<T>),
-                      "Heap<T> must be binary compatible with T.");
-        init(GCPolicy<T>::initial());
-    }
-    explicit Heap(const T& p) { init(p); }
-
-
-
-
-
-
-
-    explicit Heap(const Heap<T>& p) { init(p.ptr); }
-
-    ~Heap() {
-        post(ptr, GCPolicy<T>::initial());
-    }
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    Heap<T>& operator=(const T& p) { set(p); return *this; } Heap<T>& operator=(const Heap<T>& other) { set(other.get()); return *this; };
-
-    const T* address() const { return &ptr; }
-
-    void exposeToActiveJS() const {
-        js::BarrierMethods<T>::exposeToJS(ptr);
-    }
-    const T& get() const {
-        exposeToActiveJS();
-        return ptr;
-    }
-    const T& unbarrieredGet() const {
-        return ptr;
-    }
-
-    T* unsafeGet() { return &ptr; }
-
-    explicit operator bool() const {
-        return bool(js::BarrierMethods<T>::asGCThingOrNull(ptr));
-    }
-    explicit operator bool() {
-        return bool(js::BarrierMethods<T>::asGCThingOrNull(ptr));
-    }
-
-  private:
-    void init(const T& newPtr) {
-        ptr = newPtr;
-        post(GCPolicy<T>::initial(), ptr);
-    }
-
-    void set(const T& newPtr) {
-        T tmp = ptr;
-        ptr = newPtr;
-        post(tmp, ptr);
-    }
-
-    void post(const T& prev, const T& next) {
-        js::BarrierMethods<T>::postBarrier(&ptr, prev, next);
-    }
-
-    T ptr;
-};
-
-static __attribute__((always_inline)) inline bool
-ObjectIsTenured(JSObject* obj)
-{
-    return !js::gc::IsInsideNursery(reinterpret_cast<js::gc::Cell*>(obj));
-}
-
-static __attribute__((always_inline)) inline bool
-ObjectIsTenured(const Heap<JSObject*>& obj)
-{
-    return ObjectIsTenured(obj.unbarrieredGet());
-}
-
-static __attribute__((always_inline)) inline bool
-ObjectIsMarkedGray(JSObject* obj)
-{
-    auto cell = reinterpret_cast<js::gc::Cell*>(obj);
-    return js::gc::detail::CellIsMarkedGrayIfKnown(cell);
-}
-
-static __attribute__((always_inline)) inline bool
-ObjectIsMarkedGray(const JS::Heap<JSObject*>& obj)
-{
-    return ObjectIsMarkedGray(obj.unbarrieredGet());
-}
-# 380 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class TenuredHeap : public js::HeapBase<T, TenuredHeap<T>>
-{
-  public:
-    using ElementType = T;
-
-    TenuredHeap() : bits(0) {
-        static_assert(sizeof(T) == sizeof(TenuredHeap<T>),
-                      "TenuredHeap<T> must be binary compatible with T.");
-    }
-    explicit TenuredHeap(T p) : bits(0) { setPtr(p); }
-    explicit TenuredHeap(const TenuredHeap<T>& p) : bits(0) { setPtr(p.getPtr()); }
-
-    void setPtr(T newPtr) {
-        do { } while (0);
-        if (newPtr)
-            AssertGCThingMustBeTenured(newPtr);
-        bits = (bits & flagsMask) | reinterpret_cast<uintptr_t>(newPtr);
-    }
-
-    void setFlags(uintptr_t flagsToSet) {
-        do { } while (0);
-        bits |= flagsToSet;
-    }
-
-    void unsetFlags(uintptr_t flagsToUnset) {
-        do { } while (0);
-        bits &= ~flagsToUnset;
-    }
-
-    bool hasFlag(uintptr_t flag) const {
-        do { } while (0);
-        return (bits & flag) != 0;
-    }
-
-    T unbarrieredGetPtr() const { return reinterpret_cast<T>(bits & ~flagsMask); }
-    uintptr_t getFlags() const { return bits & flagsMask; }
-
-    void exposeToActiveJS() const {
-        js::BarrierMethods<T>::exposeToJS(unbarrieredGetPtr());
-    }
-    T getPtr() const {
-        exposeToActiveJS();
-        return unbarrieredGetPtr();
-    }
-
-    operator T() const { return getPtr(); }
-    T operator->() const { return getPtr(); }
-
-    explicit operator bool() const {
-        return bool(js::BarrierMethods<T>::asGCThingOrNull(unbarrieredGetPtr()));
-    }
-    explicit operator bool() {
-        return bool(js::BarrierMethods<T>::asGCThingOrNull(unbarrieredGetPtr()));
-    }
-
-    TenuredHeap<T>& operator=(T p) {
-        setPtr(p);
-        return *this;
-    }
-
-    TenuredHeap<T>& operator=(const TenuredHeap<T>& other) {
-        bits = other.bits;
-        return *this;
-    }
-
-  private:
-    enum {
-        maskBits = 3,
-        flagsMask = (1 << maskBits) - 1,
-    };
-
-    uintptr_t bits;
-};
-# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class Handle : public js::HandleBase<T, Handle<T>>
-{
-    friend class JS::MutableHandle<T>;
-
-  public:
-    using ElementType = T;
-
-
-    template <typename S>
-                 Handle(Handle<S> handle,
-                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0)
-    {
-        static_assert(sizeof(Handle<T>) == sizeof(T*),
-                      "Handle must be binary compatible with T*.");
-        ptr = reinterpret_cast<const T*>(handle.address());
-    }
-
-                 Handle(decltype(nullptr)) {
-        static_assert(mozilla::IsPointer<T>::value,
-                      "nullptr_t overload not valid for non-pointer types");
-        static void* const ConstNullValue = nullptr;
-        ptr = reinterpret_cast<const T*>(&ConstNullValue);
-    }
-
-                 Handle(MutableHandle<T> handle) {
-        ptr = handle.address();
-    }
-# 507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-    static constexpr Handle fromMarkedLocation(const T* p) {
-        return Handle(p, DeliberatelyChoosingThisOverload,
-                      ImUsingThisOnlyInFromFromMarkedLocation);
-    }
-
-
-
-
-
-    template <typename S>
-    inline
-                 Handle(const Rooted<S>& root,
-                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
-
-    template <typename S>
-    inline
-                 Handle(const PersistentRooted<S>& root,
-                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
-
-
-    template <typename S>
-    inline
-                 Handle(MutableHandle<S>& root,
-                        typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
-
-  private:
-    Handle() {}
-    template <typename S> Handle<T>& operator=(S) = delete; Handle<T>& operator=(const Handle<T>&) = delete;;
-
-    enum Disambiguator { DeliberatelyChoosingThisOverload = 42 };
-    enum CallerIdentity { ImUsingThisOnlyInFromFromMarkedLocation = 17 };
-    constexpr Handle(const T* p, Disambiguator, CallerIdentity) : ptr(p) {}
-
-    const T* ptr;
-};
-# 554 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class MutableHandle : public js::MutableHandleBase<T, MutableHandle<T>>
-{
-  public:
-    using ElementType = T;
-
-    inline MutableHandle(Rooted<T>* root);
-    inline MutableHandle(PersistentRooted<T>* root);
-
-  private:
-
-    MutableHandle(decltype(nullptr)) = delete;
-
-  public:
-    void set(const T& v) {
-        *ptr = v;
-    }
-# 579 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-    static MutableHandle fromMarkedLocation(T* p) {
-        MutableHandle h;
-        h.ptr = p;
-        return h;
-    }
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
-    T* address() { return &(*ptr); } T& get() { return (*ptr); };
-
-  private:
-    MutableHandle() {}
-    template <typename S> MutableHandle<T>& operator=(S) = delete; MutableHandle<T>& operator=(const MutableHandle<T>&) = delete;;
-
-    T* ptr;
-};
-
-}
-
-namespace js {
-
-template <typename T>
-struct BarrierMethods<T*>
-{
-    static T* initial() { return nullptr; }
-    static gc::Cell* asGCThingOrNull(T* v) {
-        if (!v)
-            return nullptr;
-        do { } while (0);
-        return reinterpret_cast<gc::Cell*>(v);
-    }
-    static void postBarrier(T** vp, T* prev, T* next) {
-        if (next)
-            JS::AssertGCThingIsNotAnObjectSubclass(reinterpret_cast<js::gc::Cell*>(next));
-    }
-    static void exposeToJS(T* t) {
-        if (t)
-            js::gc::ExposeGCThingToActiveJS(JS::GCCellPtr(t));
-    }
-};
-
-template <>
-struct BarrierMethods<JSObject*>
-{
-    static JSObject* initial() { return nullptr; }
-    static gc::Cell* asGCThingOrNull(JSObject* v) {
-        if (!v)
-            return nullptr;
-        do { } while (0);
-        return reinterpret_cast<gc::Cell*>(v);
-    }
-    static void postBarrier(JSObject** vp, JSObject* prev, JSObject* next) {
-        JS::HeapObjectPostBarrier(vp, prev, next);
-    }
-    static void exposeToJS(JSObject* obj) {
-        if (obj)
-            JS::ExposeObjectToActiveJS(obj);
-    }
-};
-
-template <>
-struct BarrierMethods<JSFunction*>
-{
-    static JSFunction* initial() { return nullptr; }
-    static gc::Cell* asGCThingOrNull(JSFunction* v) {
-        if (!v)
-            return nullptr;
-        do { } while (0);
-        return reinterpret_cast<gc::Cell*>(v);
-    }
-    static void postBarrier(JSFunction** vp, JSFunction* prev, JSFunction* next) {
-        JS::HeapObjectPostBarrier(reinterpret_cast<JSObject**>(vp),
-                                  reinterpret_cast<JSObject*>(prev),
-                                  reinterpret_cast<JSObject*>(next));
-    }
-    static void exposeToJS(JSFunction* fun) {
-        if (fun)
-            JS::ExposeObjectToActiveJS(reinterpret_cast<JSObject*>(fun));
-    }
-};
-# 671 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-struct MovableCellHasher
-{
-    using Key = T;
-    using Lookup = T;
-
-    static bool hasHash(const Lookup& l);
-    static bool ensureHash(const Lookup& l);
-    static HashNumber hash(const Lookup& l);
-    static bool match(const Key& k, const Lookup& l);
-    static void rekey(Key& k, const Key& newKey) { k = newKey; }
-};
-
-template <typename T>
-struct MovableCellHasher<JS::Heap<T>>
-{
-    using Key = JS::Heap<T>;
-    using Lookup = T;
-
-    static bool hasHash(const Lookup& l) { return MovableCellHasher<T>::hasHash(l); }
-    static bool ensureHash(const Lookup& l) { return MovableCellHasher<T>::ensureHash(l); }
-    static HashNumber hash(const Lookup& l) { return MovableCellHasher<T>::hash(l); }
-    static bool match(const Key& k, const Lookup& l) {
-        return MovableCellHasher<T>::match(k.unbarrieredGet(), l);
-    }
-    static void rekey(Key& k, const Key& newKey) { k.unsafeSet(newKey); }
-};
-
-template <typename T>
-struct FallibleHashMethods<MovableCellHasher<T>>
-{
-    template <typename Lookup> static bool hasHash(Lookup&& l) {
-        return MovableCellHasher<T>::hasHash(mozilla::Forward<Lookup>(l));
-    }
-    template <typename Lookup> static bool ensureHash(Lookup&& l) {
-        return MovableCellHasher<T>::ensureHash(mozilla::Forward<Lookup>(l));
-    }
-};
-
-}
-
-namespace js {
-# 722 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class alignas(8) DispatchWrapper
-{
-    static_assert(JS::MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
-                  "DispatchWrapper is intended only for usage with a Traceable");
-
-    using TraceFn = void (*)(JSTracer*, T*, const char*);
-    TraceFn tracer;
-    alignas(gc::CellSize) T storage;
-
-  public:
-    template <typename U>
-                 DispatchWrapper(U&& initial)
-      : tracer(&JS::GCPolicy<T>::trace),
-        storage(mozilla::Forward<U>(initial))
-    { }
-
-
-    T* operator &() { return &storage; }
-    const T* operator &() const { return &storage; }
-    operator T&() { return storage; }
-    operator const T&() const { return storage; }
-
-
-
-    static void TraceWrapped(JSTracer* trc, T* thingp, const char* name) {
-        auto wrapper = reinterpret_cast<DispatchWrapper*>(
-                           uintptr_t(thingp) - __builtin_offsetof(DispatchWrapper, storage));
-        wrapper->tracer(trc, &wrapper->storage, name);
-    }
-};
-
-}
-
-namespace JS {
-# 766 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-class Rooted : public js::RootedBase<T, Rooted<T>>
-{
-    inline void registerWithRootLists(RootedListHeads& roots) {
-        this->stack = &roots[JS::MapTypeToRootKind<T>::kind];
-        this->prev = *stack;
-        *stack = reinterpret_cast<Rooted<void*>*>(this);
-    }
-
-    inline RootedListHeads& rootLists(RootingContext* cx) {
-        return cx->stackRoots_;
-    }
-    inline RootedListHeads& rootLists(JSContext* cx) {
-        return rootLists(RootingContext::get(cx));
-    }
-
-  public:
-    using ElementType = T;
-
-    template <typename RootingContext>
-    explicit Rooted(const RootingContext& cx)
-      : ptr(GCPolicy<T>::initial())
-    {
-        registerWithRootLists(rootLists(cx));
-    }
-
-    template <typename RootingContext, typename S>
-    Rooted(const RootingContext& cx, S&& initial)
-      : ptr(mozilla::Forward<S>(initial))
-    {
-        registerWithRootLists(rootLists(cx));
-    }
-
-    ~Rooted() {
-        do { } while (0);
-        *stack = prev;
-    }
-
-    Rooted<T>* previous() { return reinterpret_cast<Rooted<T>*>(prev); }
-
-
-
-
-
-    void set(const T& value) {
-        ptr = value;
-    }
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    Rooted<T>& operator=(const T& p) { set(p); return *this; } Rooted<T>& operator=(const Rooted<T>& other) { set(other.get()); return *this; };
-    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
-    T* address() { return &(ptr); } T& get() { return (ptr); };
-
-  private:
-
-
-
-
-
-    Rooted<void*>** stack;
-    Rooted<void*>* prev;
-# 836 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-    using MaybeWrapped = typename mozilla::Conditional<
-        MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
-        js::DispatchWrapper<T>,
-        T>::Type;
-    MaybeWrapped ptr;
-
-    Rooted(const Rooted&) = delete;
-} ;
-
-}
-
-namespace js {
-# 859 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename Container>
-class RootedBase<JSObject*, Container> : public MutableWrappedPtrOperations<JSObject*, Container>
-{
-  public:
-    template <class U>
-    JS::Handle<U*> as() const;
-};
-# 877 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename Container>
-class HandleBase<JSObject*, Container> : public WrappedPtrOperations<JSObject*, Container>
-{
-  public:
-    template <class U>
-    JS::Handle<U*> as() const;
-};
-
-
-template <typename T>
-class FakeRooted : public RootedBase<T, FakeRooted<T>>
-{
-  public:
-    using ElementType = T;
-
-    template <typename CX>
-    explicit FakeRooted(CX* cx) : ptr(JS::GCPolicy<T>::initial()) {}
-
-    template <typename CX>
-    FakeRooted(CX* cx, T initial) : ptr(initial) {}
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    FakeRooted<T>& operator=(const T& p) { set(p); return *this; } FakeRooted<T>& operator=(const FakeRooted<T>& other) { set(other.get()); return *this; };
-    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
-    T* address() { return &(ptr); } T& get() { return (ptr); };
-
-  private:
-    T ptr;
-
-    void set(const T& value) {
-        ptr = value;
-    }
-
-    FakeRooted(const FakeRooted&) = delete;
-};
-
-
-template <typename T>
-class FakeMutableHandle : public js::MutableHandleBase<T, FakeMutableHandle<T>>
-{
-  public:
-    using ElementType = T;
-
-                 FakeMutableHandle(T* t) {
-        ptr = t;
-    }
-
-                 FakeMutableHandle(FakeRooted<T>* root) {
-        ptr = root->address();
-    }
-
-    void set(const T& v) {
-        *ptr = v;
-    }
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    const T* address() const { return &(*ptr); } const T& get() const { return (*ptr); };
-    T* address() { return &(*ptr); } T& get() { return (*ptr); };
-
-  private:
-    FakeMutableHandle() {}
-    template <typename S> FakeMutableHandle<T>& operator=(S) = delete; FakeMutableHandle<T>& operator=(const FakeMutableHandle<T>&) = delete;;
-
-    T* ptr;
-};
-# 952 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-enum AllowGC {
-    NoGC = 0,
-    CanGC = 1
-};
-template <typename T, AllowGC allowGC>
-class MaybeRooted
-{
-};
-
-template <typename T> class MaybeRooted<T, CanGC>
-{
-  public:
-    typedef JS::Handle<T> HandleType;
-    typedef JS::Rooted<T> RootType;
-    typedef JS::MutableHandle<T> MutableHandleType;
-
-    static inline JS::Handle<T> toHandle(HandleType v) {
-        return v;
-    }
-
-    static inline JS::MutableHandle<T> toMutableHandle(MutableHandleType v) {
-        return v;
-    }
-
-    template <typename T2>
-    static inline JS::Handle<T2*> downcastHandle(HandleType v) {
-        return v.template as<T2>();
-    }
-};
-
-template <typename T> class MaybeRooted<T, NoGC>
-{
-  public:
-    typedef const T& HandleType;
-    typedef FakeRooted<T> RootType;
-    typedef FakeMutableHandle<T> MutableHandleType;
-
-    static JS::Handle<T> toHandle(HandleType v) {
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 990; ::abort(); } while (0); } while (0);
-    }
-
-    static JS::MutableHandle<T> toMutableHandle(MutableHandleType v) {
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "Bad conversion" ")"); do { *((volatile int*) __null) = 994; ::abort(); } while (0); } while (0);
-    }
-
-    template <typename T2>
-    static inline T2* downcastHandle(HandleType v) {
-        return &v->template as<T2>();
-    }
-};
-
-}
-
-namespace JS {
-
-template <typename T> template <typename S>
-inline
-Handle<T>::Handle(const Rooted<S>& root,
-                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
-{
-    ptr = reinterpret_cast<const T*>(root.address());
-}
-
-template <typename T> template <typename S>
-inline
-Handle<T>::Handle(const PersistentRooted<S>& root,
-                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
-{
-    ptr = reinterpret_cast<const T*>(root.address());
-}
-
-template <typename T> template <typename S>
-inline
-Handle<T>::Handle(MutableHandle<S>& root,
-                  typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
-{
-    ptr = reinterpret_cast<const T*>(root.address());
-}
-
-template <typename T>
-inline
-MutableHandle<T>::MutableHandle(Rooted<T>* root)
-{
-    static_assert(sizeof(MutableHandle<T>) == sizeof(T*),
-                  "MutableHandle must be binary compatible with T*.");
-    ptr = root->address();
-}
-
-template <typename T>
-inline
-MutableHandle<T>::MutableHandle(PersistentRooted<T>* root)
-{
-    static_assert(sizeof(MutableHandle<T>) == sizeof(T*),
-                  "MutableHandle must be binary compatible with T*.");
-    ptr = root->address();
-}
-
-void
-AddPersistentRoot(RootingContext* cx, RootKind kind, PersistentRooted<void*>* root);
-# 1086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template<typename T>
-class PersistentRooted : public js::RootedBase<T, PersistentRooted<T>>,
-                         private mozilla::LinkedListElement<PersistentRooted<T>>
-{
-    using ListBase = mozilla::LinkedListElement<PersistentRooted<T>>;
-
-    friend class mozilla::LinkedList<PersistentRooted>;
-    friend class mozilla::LinkedListElement<PersistentRooted>;
-
-    void registerWithRootLists(RootingContext* cx) {
-        do { } while (0);
-        JS::RootKind kind = JS::MapTypeToRootKind<T>::kind;
-        AddPersistentRoot(cx, kind, reinterpret_cast<JS::PersistentRooted<void*>*>(this));
-    }
-
-  public:
-    using ElementType = T;
-
-    PersistentRooted() : ptr(GCPolicy<T>::initial()) {}
-
-    explicit PersistentRooted(RootingContext* cx)
-      : ptr(GCPolicy<T>::initial())
-    {
-        registerWithRootLists(cx);
-    }
-
-    explicit PersistentRooted(JSContext* cx)
-      : ptr(GCPolicy<T>::initial())
-    {
-        registerWithRootLists(RootingContext::get(cx));
-    }
-
-    template <typename U>
-    PersistentRooted(RootingContext* cx, U&& initial)
-      : ptr(mozilla::Forward<U>(initial))
-    {
-        registerWithRootLists(cx);
-    }
-
-    template <typename U>
-    PersistentRooted(JSContext* cx, U&& initial)
-      : ptr(mozilla::Forward<U>(initial))
-    {
-        registerWithRootLists(RootingContext::get(cx));
-    }
-
-    PersistentRooted(const PersistentRooted& rhs)
-      : mozilla::LinkedListElement<PersistentRooted<T>>(),
-        ptr(rhs.ptr)
-    {
-# 1144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-        const_cast<PersistentRooted&>(rhs).setNext(this);
-    }
-
-    bool initialized() {
-        return ListBase::isInList();
-    }
-
-    void init(JSContext* cx) {
-        init(cx, GCPolicy<T>::initial());
-    }
-
-    template <typename U>
-    void init(JSContext* cx, U&& initial) {
-        ptr = mozilla::Forward<U>(initial);
-        registerWithRootLists(RootingContext::get(cx));
-    }
-
-    void reset() {
-        if (initialized()) {
-            set(GCPolicy<T>::initial());
-            ListBase::remove();
-        }
-    }
-
-    operator const T&() const { return get(); } const T& operator->() const { return get(); };
-    PersistentRooted<T>& operator=(const T& p) { set(p); return *this; } PersistentRooted<T>& operator=(const PersistentRooted<T>& other) { set(other.get()); return *this; };
-    const T* address() const { return &(ptr); } const T& get() const { return (ptr); };
-
-
-
-
-    T* address() {
-        do { } while (0);
-        return &ptr;
-    }
-    T& get() {
-        do { } while (0);
-        return ptr;
-    }
-
-  private:
-    template <typename U>
-    void set(U&& value) {
-        do { } while (0);
-        ptr = mozilla::Forward<U>(value);
-    }
-
-
-    using MaybeWrapped = typename mozilla::Conditional<
-        MapTypeToRootKind<T>::kind == JS::RootKind::Traceable,
-        js::DispatchWrapper<T>,
-        T>::Type;
-    MaybeWrapped ptr;
-} ;
-
-class ObjectPtr
-{
-    Heap<JSObject*> value;
-
-  public:
-    using ElementType = JSObject*;
-
-    ObjectPtr() : value(nullptr) {}
-
-    explicit ObjectPtr(JSObject* obj) : value(obj) {}
-
-
-    ~ObjectPtr() { do { } while (0); }
-
-    void finalize(JSRuntime* rt);
-    void finalize(JSContext* cx);
-
-    void init(JSObject* obj) { value = obj; }
-
-    JSObject* get() const { return value; }
-    JSObject* unbarrieredGet() const { return value.unbarrieredGet(); }
-
-    void writeBarrierPre(JSContext* cx) {
-        IncrementalPreWriteBarrier(value);
-    }
-
-    void updateWeakPointerAfterGC();
-
-    ObjectPtr& operator=(JSObject* obj) {
-        IncrementalPreWriteBarrier(value);
-        value = obj;
-        return *this;
-    }
-
-    void trace(JSTracer* trc, const char* name);
-
-    JSObject& operator*() const { return *value; }
-    JSObject* operator->() const { return value; }
-    operator JSObject*() const { return value; }
-
-    explicit operator bool() const { return value.unbarrieredGet(); }
-    explicit operator bool() { return value.unbarrieredGet(); }
-};
-
-}
-
-namespace js {
-
-template <typename T, typename D, typename Container>
-class WrappedPtrOperations<UniquePtr<T, D>, Container>
-{
-    const UniquePtr<T, D>& uniquePtr() const { return static_cast<const Container*>(this)->get(); }
-
-  public:
-    explicit operator bool() const { return !!uniquePtr(); }
-};
-
-template <typename T, typename D, typename Container>
-class MutableWrappedPtrOperations<UniquePtr<T, D>, Container>
-  : public WrappedPtrOperations<UniquePtr<T, D>, Container>
-{
-    UniquePtr<T, D>& uniquePtr() { return static_cast<Container*>(this)->get(); }
-
-  public:
-    __attribute__ ((warn_unused_result)) typename UniquePtr<T, D>::Pointer release() { return uniquePtr().release(); }
-};
-
-namespace gc {
-
-template <typename T, typename TraceCallbacks>
-void
-CallTraceCallbackOnNonHeap(T* v, const TraceCallbacks& aCallbacks, const char* aName, void* aClosure)
-{
-    static_assert(sizeof(T) == sizeof(JS::Heap<T>), "T and Heap<T> must be compatible.");
-    do { } while (0);
-    mozilla::DebugOnly<Cell*> cell = BarrierMethods<T>::asGCThingOrNull(*v);
-    do { } while (0);
-    do { } while (0);
-    JS::Heap<T>* asHeapT = reinterpret_cast<JS::Heap<T>*>(v);
-    aCallbacks.Trace(asHeapT, aName, aClosure);
-}
-
-}
-}
-
-
-
-namespace mozilla {
-
-template <typename T>
-inline void
-Swap(JS::Heap<T>& aX, JS::Heap<T>& aY)
-{
-    T tmp = aX;
-    aX = aY;
-    aY = tmp;
-}
-
-template <typename T>
-inline void
-Swap(JS::TenuredHeap<T>& aX, JS::TenuredHeap<T>& aY)
-{
-    T tmp = aX;
-    aX = aY;
-    aY = tmp;
-}
-
-}
-
-namespace js {
-namespace detail {
-# 1320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T>
-struct DefineComparisonOps : mozilla::FalseType {};
-
-template <typename T>
-struct DefineComparisonOps<JS::Heap<T>> : mozilla::TrueType {
-    static const T& get(const JS::Heap<T>& v) { return v.unbarrieredGet(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<JS::TenuredHeap<T>> : mozilla::TrueType {
-    static const T get(const JS::TenuredHeap<T>& v) { return v.unbarrieredGetPtr(); }
-};
-
-template <>
-struct DefineComparisonOps<JS::ObjectPtr> : mozilla::TrueType {
-    static const JSObject* get(const JS::ObjectPtr& v) { return v.unbarrieredGet(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<JS::Rooted<T>> : mozilla::TrueType {
-    static const T& get(const JS::Rooted<T>& v) { return v.get(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<JS::Handle<T>> : mozilla::TrueType {
-    static const T& get(const JS::Handle<T>& v) { return v.get(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<JS::MutableHandle<T>> : mozilla::TrueType {
-    static const T& get(const JS::MutableHandle<T>& v) { return v.get(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<JS::PersistentRooted<T>> : mozilla::TrueType {
-    static const T& get(const JS::PersistentRooted<T>& v) { return v.get(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<js::FakeRooted<T>> : mozilla::TrueType {
-    static const T& get(const js::FakeRooted<T>& v) { return v.get(); }
-};
-
-template <typename T>
-struct DefineComparisonOps<js::FakeMutableHandle<T>> : mozilla::TrueType {
-    static const T& get(const js::FakeMutableHandle<T>& v) { return v.get(); }
-};
-
-}
-}
-# 1378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RootingAPI.h"
-template <typename T, typename U>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           js::detail::DefineComparisonOps<U>::value, bool>::Type
-operator==(const T& a, const U& b) {
-    return js::detail::DefineComparisonOps<T>::get(a) == js::detail::DefineComparisonOps<U>::get(b);
-}
-
-template <typename T, typename U>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           js::detail::DefineComparisonOps<U>::value, bool>::Type
-operator!=(const T& a, const U& b) {
-    return !(a == b);
-}
-
-
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
-operator==(const T& a, const typename T::ElementType& b) {
-    return js::detail::DefineComparisonOps<T>::get(a) == b;
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
-operator!=(const T& a, const typename T::ElementType& b) {
-    return !(a == b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
-operator==(const typename T::ElementType& a, const T& b) {
-    return a == js::detail::DefineComparisonOps<T>::get(b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
-operator!=(const typename T::ElementType& a, const T& b) {
-    return !(a == b);
-}
-
-
-
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator==(const typename mozilla::RemovePointer<typename T::ElementType>::Type* a, const T& b) {
-    return a == js::detail::DefineComparisonOps<T>::get(b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator!=(const typename mozilla::RemovePointer<typename T::ElementType>::Type* a, const T& b) {
-    return !(a == b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator==(const T& a, const typename mozilla::RemovePointer<typename T::ElementType>::Type* b) {
-    return js::detail::DefineComparisonOps<T>::get(a) == b;
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator!=(const T& a, const typename mozilla::RemovePointer<typename T::ElementType>::Type* b) {
-    return !(a == b);
-}
-
-
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator==(std::nullptr_t a, const T& b) {
-    return a == js::detail::DefineComparisonOps<T>::get(b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator!=(std::nullptr_t a, const T& b) {
-    return !(a == b);
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator==(const T& a, std::nullptr_t b) {
-    return js::detail::DefineComparisonOps<T>::get(a) == b;
-}
-
-template <typename T>
-typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
-                           mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
-operator!=(const T& a, std::nullptr_t b) {
-    return !(a == b);
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h" 2
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-class nsCycleCollectionISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-};
-
-template<typename T> struct nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc61eac14, 0x5f7a, 0x4481, { 0x96, 0x5e, 0x7e, 0xaa, 0x6e, 0xff, 0xa8, 0x5f } };
-
-
-namespace JS {
-template<class T> class Heap;
-}
-
-
-
-
-
-
-struct TraceCallbacks
-{
-  virtual void Trace(JS::Heap<JS::Value>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::Heap<jsid>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::Heap<JSObject*>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JSObject** aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::TenuredHeap<JSObject*>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::Heap<JSString*>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::Heap<JSScript*>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-  virtual void Trace(JS::Heap<JSFunction*>* aPtr, const char* aName,
-                     void* aClosure) const = 0;
-};
-
-
-
-
-
-struct TraceCallbackFunc : public TraceCallbacks
-{
-  typedef void (*Func)(JS::GCCellPtr aPtr, const char* aName, void* aClosure);
-
-  explicit TraceCallbackFunc(Func aCb) : mCallback(aCb) {}
-
-  virtual void Trace(JS::Heap<JS::Value>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::Heap<jsid>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::Heap<JSObject*>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JSObject** aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::TenuredHeap<JSObject*>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::Heap<JSString*>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::Heap<JSScript*>* aPtr, const char* aName,
-                     void* aClosure) const override;
-  virtual void Trace(JS::Heap<JSFunction*>* aPtr, const char* aName,
-                     void* aClosure) const override;
-
-private:
-  Func mCallback;
-};
-
-
-
-
-class nsCycleCollectionParticipant
-{
-public:
-  constexpr explicit nsCycleCollectionParticipant(bool aSkip,
-                                                  bool aTraverseShouldTrace = false)
-    : mMightSkip(aSkip)
-    , mTraverseShouldTrace(aTraverseShouldTrace)
-  {
-  }
-
-  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb) = 0;
-
-  nsresult TraverseNativeAndJS(void* aPtr,
-                               nsCycleCollectionTraversalCallback& aCb)
-  {
-    nsresult rv = TraverseNative(aPtr, aCb);
-    if (mTraverseShouldTrace) {
-
-
-      TraceCallbackFunc noteJsChild(&nsCycleCollectionParticipant::NoteJSChild);
-      Trace(aPtr, noteJsChild, &aCb);
-    }
-    return rv;
-  }
-
-
-  static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName,
-                          void* aClosure);
-
-  virtual void Root(void* aPtr) = 0;
-  virtual void Unlink(void* aPtr) = 0;
-  virtual void Unroot(void* aPtr) = 0;
-  virtual const char* ClassName() = 0;
-
-  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
-                          void* aClosure) {}
-# 163 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-  bool CanSkip(void* aPtr, bool aRemovingAllowed)
-  {
-    return mMightSkip ? CanSkipReal(aPtr, aRemovingAllowed) : false;
-  }
-# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-  bool CanSkipInCC(void* aPtr)
-  {
-    return mMightSkip ? CanSkipInCCReal(aPtr) : false;
-  }
-# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-  bool CanSkipThis(void* aPtr)
-  {
-    return mMightSkip ? CanSkipThisReal(aPtr) : false;
-  }
-
-  virtual void DeleteCycleCollectable(void* aPtr) = 0;
-
-protected:
-  virtual bool CanSkipReal(void* aPtr, bool aRemovingAllowed)
-  {
-    do { } while(0);
-    return false;
-  }
-  virtual bool CanSkipInCCReal(void* aPtr)
-  {
-    do { } while(0);
-    return false;
-  }
-  virtual bool CanSkipThisReal(void* aPtr)
-  {
-    do { } while(0);
-    return false;
-  }
-
-private:
-  const bool mMightSkip;
-  const bool mTraverseShouldTrace;
-};
-
-class nsScriptObjectTracer : public nsCycleCollectionParticipant
-{
-public:
-  constexpr explicit nsScriptObjectTracer(bool aSkip)
-    : nsCycleCollectionParticipant(aSkip, true)
-  {
-  }
-
-  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
-                          void* aClosure) override = 0;
-
-};
-
-class nsXPCOMCycleCollectionParticipant : public nsScriptObjectTracer
-{
-public:
-  constexpr explicit nsXPCOMCycleCollectionParticipant(bool aSkip)
-    : nsScriptObjectTracer(aSkip)
-  {
-  }
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  virtual void Root(void* aPtr) override;
-  virtual void Unroot(void* aPtr) override;
-
-  virtual void Trace(void* aPtr, const TraceCallbacks& aCb,
-                          void* aClosure) override;
-
-  static bool CheckForRightISupports(nsISupports* aSupports);
-};
-
-template<typename T> struct nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x9674489b, 0x1f6f, 0x4550, { 0xa7, 0x30, 0xcc, 0xae, 0xdd, 0x10, 0x4c, 0xf9 } };
-# 341 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCycleCollectionParticipant.h"
-template<typename T,
-         bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
-struct DowncastCCParticipantImpl
-{
-};
-
-
-template<typename T>
-struct DowncastCCParticipantImpl<T, true>
-{
-  static T* Run(void* aPtr)
-  {
-    nsISupports* s = static_cast<nsISupports*>(aPtr);
-    do { } while (0);
-
-    T* rval = T::cycleCollection::Downcast(s);
-                                        ;
-    return rval;
-  }
-};
-
-
-template<typename T>
-struct DowncastCCParticipantImpl<T, false>
-{
-  static T* Run(void* aPtr) { return static_cast<T*>(aPtr); }
-};
-
-template<typename T>
-T*
-DowncastCCParticipant(void* aPtr)
-{
-  return DowncastCCParticipantImpl<T>::Run(aPtr);
-}
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NameSpaceConstants.h"
-static const int32_t kNameSpaceID_None = 0;
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringFwd.h"
-namespace mozilla {
-namespace detail {
-
-class nsStringRepr;
-class nsCStringRepr;
-
-}
-}
-
-
-
-
-
-class nsAString;
-class nsSubstringTuple;
-class nsString;
-class nsAutoString;
-class nsDependentString;
-class nsDependentSubstring;
-class nsPromiseFlatString;
-class nsStringComparator;
-class nsDefaultStringComparator;
-class nsXPIDLString;
-
-
-
-
-
-
-class nsACString;
-class nsCSubstringTuple;
-class nsCString;
-class nsAutoCString;
-class nsDependentCString;
-class nsDependentCSubstring;
-class nsPromiseFlatCString;
-class nsCStringComparator;
-class nsDefaultCStringComparator;
-class nsXPIDLCString;
-
-
-
-
-
-
-typedef nsAString nsSubstring;
-typedef nsACString nsCSubstring;
-
-typedef nsString nsAFlatString;
-typedef nsSubstring nsASingleFragmentString;
-
-typedef nsCString nsAFlatCString;
-typedef nsCSubstring nsASingleFragmentCString;
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringIterator.h"
-template <class CharT>
-class nsReadingIterator
-{
-public:
-  typedef nsReadingIterator<CharT> self_type;
-  typedef ptrdiff_t difference_type;
-  typedef size_t size_type;
-  typedef CharT value_type;
-  typedef const CharT* pointer;
-  typedef const CharT& reference;
-
-private:
-  friend class mozilla::detail::nsStringRepr;
-  friend class mozilla::detail::nsCStringRepr;
-
-
-
-
-
-
-  const CharT* mStart;
-  const CharT* mEnd;
-  const CharT* mPosition;
-
-public:
-  nsReadingIterator()
-  {
-  }
-
-
-
-  pointer get() const
-  {
-    return mPosition;
-  }
-
-  CharT operator*() const
-  {
-    return *get();
-  }
-
-  self_type& operator++()
-  {
-    ++mPosition;
-    return *this;
-  }
-
-  self_type operator++(int)
-  {
-    self_type result(*this);
-    ++mPosition;
-    return result;
-  }
-
-  self_type& operator--()
-  {
-    --mPosition;
-    return *this;
-  }
-
-  self_type operator--(int)
-  {
-    self_type result(*this);
-    --mPosition;
-    return result;
-  }
-
-  self_type& advance(difference_type aN)
-  {
-    if (aN > 0) {
-      difference_type step = XPCOM_MIN(aN, mEnd - mPosition);
-
-      do { } while(0);
-
-
-      mPosition += step;
-    } else if (aN < 0) {
-      difference_type step = XPCOM_MAX(aN, -(mPosition - mStart));
-
-      do { } while(0);
-
-
-      mPosition += step;
-    }
-    return *this;
-  }
-
-
-
-
-
-
-  size_type operator-(const self_type& aOther) const
-  {
-    do { } while (0);
-    return mPosition - aOther.mPosition;
-  }
-};
-
-
-
-
-
-template <class CharT>
-class nsWritingIterator
-{
-public:
-  typedef nsWritingIterator<CharT> self_type;
-  typedef ptrdiff_t difference_type;
-  typedef size_t size_type;
-  typedef CharT value_type;
-  typedef CharT* pointer;
-  typedef CharT& reference;
-
-private:
-  friend class nsAString;
-  friend class nsACString;
-
-
-
-
-
-
-  CharT* mStart;
-  CharT* mEnd;
-  CharT* mPosition;
-
-public:
-  nsWritingIterator()
-  {
-  }
-
-
-
-  pointer get() const
-  {
-    return mPosition;
-  }
-
-  reference operator*() const
-  {
-    return *get();
-  }
-
-  self_type& operator++()
-  {
-    ++mPosition;
-    return *this;
-  }
-
-  self_type operator++(int)
-  {
-    self_type result(*this);
-    ++mPosition;
-    return result;
-  }
-
-  self_type& operator--()
-  {
-    --mPosition;
-    return *this;
-  }
-
-  self_type operator--(int)
-  {
-    self_type result(*this);
-    --mPosition;
-    return result;
-  }
-
-  self_type& advance(difference_type aN)
-  {
-    if (aN > 0) {
-      difference_type step = XPCOM_MIN(aN, mEnd - mPosition);
-
-      do { } while(0);
-
-
-      mPosition += step;
-    } else if (aN < 0) {
-      difference_type step = XPCOM_MAX(aN, -(mPosition - mStart));
-
-      do { } while(0);
-
-
-      mPosition += step;
-    }
-    return *this;
-  }
-
-
-
-
-
-
-  size_type operator-(const self_type& aOther) const
-  {
-    do { } while (0);
-    return mPosition - aOther.mPosition;
-  }
-};
-
-template <class CharT>
-struct nsCharSinkTraits<nsWritingIterator<CharT>>
-{
-  static void
-  write(nsWritingIterator<CharT>& aIter, const CharT* aStr, uint32_t aN)
-  {
-    nsCharTraits<CharT>::move(aIter.get(), aStr, aN);
-    aIter.advance(aN);
-  }
-};
-
-template <class CharT>
-inline bool
-operator==(const nsReadingIterator<CharT>& aLhs,
-           const nsReadingIterator<CharT>& aRhs)
-{
-  return aLhs.get() == aRhs.get();
-}
-
-template <class CharT>
-inline bool
-operator!=(const nsReadingIterator<CharT>& aLhs,
-           const nsReadingIterator<CharT>& aRhs)
-{
-  return aLhs.get() != aRhs.get();
-}
-
-
-
-
-
-
-template <class CharT>
-inline bool
-operator==(const nsWritingIterator<CharT>& aLhs,
-           const nsWritingIterator<CharT>& aRhs)
-{
-  return aLhs.get() == aRhs.get();
-}
-
-template <class CharT>
-inline bool
-operator!=(const nsWritingIterator<CharT>& aLhs,
-           const nsWritingIterator<CharT>& aRhs)
-{
-  return aLhs.get() != aRhs.get();
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 1
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 1 3
-# 30 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 3
-# 1 "/usr/include/inttypes.h" 1 3 4
-# 266 "/usr/include/inttypes.h" 3 4
-extern "C" {
-
-
-
-
-typedef struct
-  {
-    long int quot;
-    long int rem;
-  } imaxdiv_t;
-# 290 "/usr/include/inttypes.h" 3 4
-extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));
-
-
-extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
-      throw () __attribute__ ((__const__));
-
-
-extern intmax_t strtoimax (const char *__restrict __nptr,
-      char **__restrict __endptr, int __base) throw ();
-
-
-extern uintmax_t strtoumax (const char *__restrict __nptr,
-       char ** __restrict __endptr, int __base) throw ();
-
-
-extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
-      wchar_t **__restrict __endptr, int __base)
-     throw ();
-
-
-extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
-       wchar_t ** __restrict __endptr, int __base)
-     throw ();
-# 432 "/usr/include/inttypes.h" 3 4
-}
-# 31 "/usr/local/bin/../lib/clang/3.9.1/include/inttypes.h" 2 3
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IntegerPrintfMacros.h" 2
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 2
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsStringComparator
-{
-public:
-  typedef char16_t char_type;
-
-  nsStringComparator()
-  {
-  }
-
-  virtual int operator()(const char_type*, const char_type*,
-                         uint32_t, uint32_t) const = 0;
-};
-
-
-
-
-
-class nsDefaultStringComparator
-  : public nsStringComparator
-{
-public:
-  typedef char16_t char_type;
-
-  nsDefaultStringComparator()
-  {
-  }
-
-  virtual int operator()(const char_type*, const char_type*,
-                         uint32_t, uint32_t) const override;
-};
-
-class nsSubstringSplitter;
-
-namespace mozilla {
-namespace detail {
-# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsStringRepr
-{
-public:
-  typedef mozilla::fallible_t fallible_t;
-
-  typedef char16_t char_type;
-
-  typedef nsCharTraits<char_type> char_traits;
-  typedef char_traits::incompatible_char_type incompatible_char_type;
-
-  typedef nsStringRepr self_type;
-  typedef self_type base_string_type;
-
-  typedef nsAString substring_type;
-  typedef nsSubstringTuple substring_tuple_type;
-  typedef nsString string_type;
-
-  typedef nsReadingIterator<char_type> const_iterator;
-  typedef nsWritingIterator<char_type> iterator;
-
-  typedef nsStringComparator comparator_type;
-
-  typedef char_type* char_iterator;
-  typedef const char_type* const_char_iterator;
-
-  typedef uint32_t index_type;
-  typedef uint32_t size_type;
-
-
-
-
-
-  const_char_iterator BeginReading() const
-  {
-    return mData;
-  }
-  const_char_iterator EndReading() const
-  {
-    return mData + mLength;
-  }
-
-
-
-
-
-  const_iterator& BeginReading(const_iterator& aIter) const
-  {
-    aIter.mStart = mData;
-    aIter.mEnd = mData + mLength;
-    aIter.mPosition = aIter.mStart;
-    return aIter;
-  }
-
-  const_iterator& EndReading(const_iterator& aIter) const
-  {
-    aIter.mStart = mData;
-    aIter.mEnd = mData + mLength;
-    aIter.mPosition = aIter.mEnd;
-    return aIter;
-  }
-
-  const_char_iterator& BeginReading(const_char_iterator& aIter) const
-  {
-    return aIter = mData;
-  }
-
-  const_char_iterator& EndReading(const_char_iterator& aIter) const
-  {
-    return aIter = mData + mLength;
-  }
-# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  const char_type* Data() const
-
-  {
-    return mData;
-  }
-
-  size_type Length() const
-  {
-    return mLength;
-  }
-
-  uint32_t Flags() const
-  {
-    return mFlags;
-  }
-
-  bool IsEmpty() const
-  {
-    return mLength == 0;
-  }
-
-  bool IsLiteral() const
-  {
-    return (mFlags & F_LITERAL) != 0;
-  }
-
-  bool IsVoid() const
-  {
-    return (mFlags & F_VOIDED) != 0;
-  }
-
-  bool IsTerminated() const
-  {
-    return (mFlags & F_TERMINATED) != 0;
-  }
-
-  char_type CharAt(index_type aIndex) const
-  {
-    do { } while(0);
-    return mData[aIndex];
-  }
-
-  char_type operator[](index_type aIndex) const
-  {
-    return CharAt(aIndex);
-  }
-
-  char_type First() const;
-
-  char_type Last() const;
-
-  size_type CountChar(char_type) const;
-  int32_t FindChar(char_type, index_type aOffset = 0) const;
-
-  inline bool Contains(char_type aChar) const
-  {
-    return FindChar(aChar) != -1;
-  }
-
-
-
-
-
-  bool Equals(const self_type&) const;
-  bool Equals(const self_type&, const comparator_type&) const;
-
-  bool Equals(const substring_tuple_type& aTuple) const;
-  bool Equals(const substring_tuple_type& aTuple,
-                          const comparator_type& aComp) const;
-
-  bool Equals(const char_type* aData) const;
-  bool Equals(const char_type* aData,
-                          const comparator_type& aComp) const;
-# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  bool EqualsASCII(const char* aData, size_type aLen) const;
-
-
-
-
-
-  bool EqualsASCII(const char* aData) const;
-
-
-
-
-
-
-
-  template<int N>
-  inline bool EqualsLiteral(const char (&aStr)[N]) const
-  {
-    return EqualsASCII(aStr, N - 1);
-  }
-
-
-
-
-
-
-
-  bool LowerCaseEqualsASCII(const char* aData,
-                                        size_type aLen) const;
-  bool LowerCaseEqualsASCII(const char* aData) const;
-
-
-
-
-
-
-  template<int N>
-  inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const
-  {
-    return LowerCaseEqualsASCII(aStr, N - 1);
-  }
-
-
-
-
-  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const
-  {
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-    return (aStart < (mData + mLength) && aEnd > mData);
-  }
-
-protected:
-  nsStringRepr() = delete;
-
-  constexpr
-  nsStringRepr(char_type* aData, size_type aLength, uint32_t aFlags)
-    : mData(aData)
-    , mLength(aLength)
-    , mFlags(aFlags)
-  {
-  }
-
-  char_type* mData;
-  size_type mLength;
-  uint32_t mFlags;
-
-public:
-
-
-
-
-
-
-  enum
-  {
-    F_NONE = 0,
-
-
-    F_TERMINATED = 1 << 0,
-    F_VOIDED = 1 << 1,
-    F_SHARED = 1 << 2,
-    F_OWNED = 1 << 3,
-    F_FIXED = 1 << 4,
-    F_LITERAL = 1 << 5,
-
-
-    F_CLASS_FIXED = 1 << 16
-  };
-# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-};
-
-}
-}
-# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsAString : public mozilla::detail::nsStringRepr
-{
-public:
-  typedef nsAString self_type;
-
-
-  ~nsAString()
-  {
-    Finalize();
-  }
-
-
-
-
-
-  char_iterator BeginWriting()
-  {
-    if (!EnsureMutable()) {
-      AllocFailed(mLength);
-    }
-
-    return mData;
-  }
-
-  char_iterator BeginWriting(const fallible_t&)
-  {
-    return EnsureMutable() ? mData : char_iterator(0);
-  }
-
-  char_iterator EndWriting()
-  {
-    if (!EnsureMutable()) {
-      AllocFailed(mLength);
-    }
-
-    return mData + mLength;
-  }
-
-  char_iterator EndWriting(const fallible_t&)
-  {
-    return EnsureMutable() ? (mData + mLength) : char_iterator(0);
-  }
-
-  char_iterator& BeginWriting(char_iterator& aIter)
-  {
-    return aIter = BeginWriting();
-  }
-
-  char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible)
-  {
-    return aIter = BeginWriting(aFallible);
-  }
-
-  char_iterator& EndWriting(char_iterator& aIter)
-  {
-    return aIter = EndWriting();
-  }
-
-  char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible)
-  {
-    return aIter = EndWriting(aFallible);
-  }
-
-
-
-
-
-  iterator& BeginWriting(iterator& aIter)
-  {
-    char_type* data = BeginWriting();
-    aIter.mStart = data;
-    aIter.mEnd = data + mLength;
-    aIter.mPosition = aIter.mStart;
-    return aIter;
-  }
-
-  iterator& EndWriting(iterator& aIter)
-  {
-    char_type* data = BeginWriting();
-    aIter.mStart = data;
-    aIter.mEnd = data + mLength;
-    aIter.mPosition = aIter.mEnd;
-    return aIter;
-  }
-
-
-
-
-
-  void Assign(char_type aChar);
-  __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&);
-
-  void Assign(const char_type* aData);
-  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
-                                       const fallible_t&);
-
-  void Assign(const char_type* aData, size_type aLength);
-  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
-                                       size_type aLength, const fallible_t&);
-
-  void Assign(const self_type&);
-  __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&);
-
-  void Assign(const substring_tuple_type&);
-  __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&,
-                                       const fallible_t&);
-# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void AssignASCII(const char* aData, size_type aLength);
-  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
-                                            size_type aLength,
-                                            const fallible_t&);
-
-  void AssignASCII(const char* aData)
-  {
-    AssignASCII(aData, mozilla::AssertedCast<size_type, size_t>(strlen(aData)));
-  }
-  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
-                                            const fallible_t& aFallible)
-  {
-    return AssignASCII(aData,
-                       mozilla::AssertedCast<size_type, size_t>(strlen(aData)),
-                       aFallible);
-  }
-
-
-
-
-
-
-
-  template<int N>
-  void AssignLiteral(const char_type (&aStr)[N])
-  {
-    AssignLiteral(aStr, N - 1);
-  }
-
-  template<int N>
-  void AssignLiteral(const char (&aStr)[N])
-  {
-    AssignASCII(aStr, N - 1);
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-  void Adopt(char_type* aData, size_type aLength = size_type(-1));
-
-
-
-
-
-
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           char_type aChar);
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                                        size_type aCutLength,
-                                        char_type aChar,
-                                        const fallible_t&);
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           const char_type* aData,
-                           size_type aLength = size_type(-1));
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                                        size_type aCutLength,
-                                        const char_type* aData,
-                                        size_type aLength,
-                                        const fallible_t&);
-  void Replace(index_type aCutStart, size_type aCutLength,
-               const self_type& aStr)
-  {
-    Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length());
-  }
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                            size_type aCutLength,
-                            const self_type& aStr,
-                            const fallible_t& aFallible)
-  {
-    return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(),
-                   aFallible);
-  }
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           const substring_tuple_type& aTuple);
-
-  void ReplaceASCII(index_type aCutStart, size_type aCutLength,
-                                const char* aData,
-                                size_type aLength = size_type(-1));
-
-  __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength,
-                                             const char* aData,
-                                             size_type aLength,
-                                             const fallible_t&);
-
-
-
-
-  template<int N>
-  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
-                      const char_type (&aStr)[N])
-  {
-    ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1);
-  }
-
-  void Append(char_type aChar)
-  {
-    Replace(mLength, 0, aChar);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aChar, aFallible);
-  }
-  void Append(const char_type* aData, size_type aLength = size_type(-1))
-  {
-    Replace(mLength, 0, aData, aLength);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength,
-                           const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aData, aLength, aFallible);
-  }
-# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void Append(const self_type& aStr)
-  {
-    Replace(mLength, 0, aStr);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aStr, aFallible);
-  }
-  void Append(const substring_tuple_type& aTuple)
-  {
-    Replace(mLength, 0, aTuple);
-  }
-
-  void AppendASCII(const char* aData, size_type aLength = size_type(-1))
-  {
-    ReplaceASCII(mLength, 0, aData, aLength);
-  }
-
-  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible)
-  {
-    return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible);
-  }
-
-  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible)
-  {
-    return ReplaceASCII(mLength, 0, aData, aLength, aFallible);
-  }
-
-
-
-
-
-
-
-  void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3)));
-  void AppendPrintf(const char* aFormat, va_list aAp);
-  void AppendInt(int32_t aInteger)
-  {
-    AppendPrintf("%" "d", aInteger);
-  }
-  void AppendInt(int32_t aInteger, int aRadix)
-  {
-    if (aRadix == 10) {
-      AppendPrintf("%" "d", aInteger);
-    } else {
-      AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x",
-                   static_cast<uint32_t>(aInteger));
-    }
-  }
-  void AppendInt(uint32_t aInteger)
-  {
-    AppendPrintf("%" "u", aInteger);
-  }
-  void AppendInt(uint32_t aInteger, int aRadix)
-  {
-    AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x",
-                 aInteger);
-  }
-  void AppendInt(int64_t aInteger)
-  {
-    AppendPrintf("%" "l" "d", aInteger);
-  }
-  void AppendInt(int64_t aInteger, int aRadix)
-  {
-    if (aRadix == 10) {
-      AppendPrintf("%" "l" "d", aInteger);
-    } else {
-      AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
-                   static_cast<uint64_t>(aInteger));
-    }
-  }
-  void AppendInt(uint64_t aInteger)
-  {
-    AppendPrintf("%" "l" "u", aInteger);
-  }
-  void AppendInt(uint64_t aInteger, int aRadix)
-  {
-    AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
-                 aInteger);
-  }
-
-
-
-
-  void AppendFloat(float aFloat);
-  void AppendFloat(double aFloat);
-public:
-
-
-
-
-  template<int N>
-  void AppendLiteral(const char_type (&aStr)[N])
-  {
-    ReplaceLiteral(mLength, 0, aStr, N - 1);
-  }
-
-  template<int N>
-  void AppendLiteral(const char (&aStr)[N])
-  {
-    AppendASCII(aStr, N - 1);
-  }
-
-  template<int N>
-  __attribute__ ((warn_unused_result)) bool AppendLiteral(const char (&aStr)[N], const fallible_t& aFallible)
-  {
-    return AppendASCII(aStr, N - 1, aFallible);
-  }
-
-
-  self_type& operator+=(char_type aChar)
-  {
-    Append(aChar);
-    return *this;
-  }
-  self_type& operator+=(const char_type* aData)
-  {
-    Append(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator+=(const self_type& aStr)
-  {
-    Append(aStr);
-    return *this;
-  }
-  self_type& operator+=(const substring_tuple_type& aTuple)
-  {
-    Append(aTuple);
-    return *this;
-  }
-
-  void Insert(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 0, aChar);
-  }
-  void Insert(const char_type* aData, index_type aPos,
-              size_type aLength = size_type(-1))
-  {
-    Replace(aPos, 0, aData, aLength);
-  }
-
-
-
-
-
-
-
-  void Insert(const self_type& aStr, index_type aPos)
-  {
-    Replace(aPos, 0, aStr);
-  }
-  void Insert(const substring_tuple_type& aTuple, index_type aPos)
-  {
-    Replace(aPos, 0, aTuple);
-  }
-
-
-
-
-  template<int N>
-  void InsertLiteral(const char_type (&aStr)[N], index_type aPos)
-  {
-    ReplaceLiteral(aPos, 0, aStr, N - 1);
-  }
-
-  void Cut(index_type aCutStart, size_type aCutLength)
-  {
-    Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0);
-  }
-
-  nsSubstringSplitter Split(const char_type aChar) const;
-# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void SetCapacity(size_type aNewCapacity);
-  __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity,
-                                            const fallible_t&);
-
-  void SetLength(size_type aNewLength);
-  __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength,
-                                          const fallible_t&);
-
-  void Truncate(size_type aNewLength = 0)
-  {
-    do { } while(0);
-    SetLength(aNewLength);
-  }
-# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  inline size_type GetData(const char_type** aData) const
-  {
-    *aData = mData;
-    return mLength;
-  }
-# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1))
-  {
-    if (!EnsureMutable(aNewLen)) {
-      AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen);
-    }
-
-    *aData = mData;
-    return mLength;
-  }
-
-  size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&)
-  {
-    if (!EnsureMutable(aNewLen)) {
-      *aData = nullptr;
-      return 0;
-    }
-
-    *aData = mData;
-    return mLength;
-  }
-# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  operator mozilla::Span<char_type>()
-  {
-    return mozilla::MakeSpan(BeginWriting(), Length());
-  }
-
-  operator mozilla::Span<const char_type>() const
-  {
-    return mozilla::MakeSpan(BeginReading(), Length());
-  }
-
-  void Append(mozilla::Span<const char_type> aSpan)
-  {
-    auto len = aSpan.Length();
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
-    Append(aSpan.Elements(), len);
-  }
-
-  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const char_type> aSpan,
-                           const fallible_t& aFallible)
-  {
-    auto len = aSpan.Length();
-    if (len > mozilla::MaxValue<size_type>::value) {
-      return false;
-    }
-    return Append(aSpan.Elements(), len, aFallible);
-  }
-# 995 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void SetIsVoid(bool);
-# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void StripChar(char_type aChar, int32_t aOffset = 0);
-# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void StripChars(const char_type* aChars, uint32_t aOffset = 0);
-
-
-
-
-
-  void ForgetSharedBuffer()
-  {
-    if (mFlags & nsSubstring::F_SHARED) {
-      mData = char_traits::sEmptyBuffer;
-      mLength = 0;
-      mFlags = F_TERMINATED;
-    }
-  }
-
-public:
-
-
-
-
-
-               nsAString(const substring_tuple_type& aTuple)
-    : nsStringRepr(nullptr, 0, F_NONE)
-  {
-    Assign(aTuple);
-  }
-
-  size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-
-
-
-
-
-
-
-  size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-
-  template<class T>
-  void NS_ABORT_OOM(T)
-  {
-    struct never {};
-    static_assert(mozilla::IsSame<T, never>::value,
-      "In string classes, use AllocFailed to account for sizeof(char_type). "
-      "Use the global ::NS_ABORT_OOM if you really have a count of bytes.");
-  }
-
-  __attribute__((always_inline)) inline void AllocFailed(size_t aLength)
-  {
-    ::NS_ABORT_OOM(aLength * sizeof(char_type));
-  }
-
-protected:
-
-
-  nsAString()
-    : nsStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED)
-  {
-  }
-
-
-
-  nsAString(const self_type& aStr)
-    : nsStringRepr(aStr.mData, aStr.mLength,
-                          aStr.mFlags & (F_TERMINATED | F_VOIDED))
-  {
-  }
-# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  nsAString(char_type* aData, size_type aLength, uint32_t aFlags)
-    : nsStringRepr(aData, aLength, aFlags)
-  {
-  }
-
-
-
-
-
-
-
-  void Finalize();
-# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  bool MutatePrep(size_type aCapacity,
-                              char_type** aOldData, uint32_t* aOldFlags);
-# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart,
-                                size_type aCutLength,
-                                size_type aNewLength);
-
-  __attribute__ ((warn_unused_result)) bool ReplacePrepInternal(
-    index_type aCutStart,
-    size_type aCutLength,
-    size_type aNewFragLength,
-    size_type aNewTotalLength);
-# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  size_type Capacity() const;
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool EnsureMutable(
-    size_type aNewLen = size_type(-1));
-
-
-
-
-  static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) {
-    if (aCapacity > kMaxCapacity) {
-
-
-      do { } while(0);
-      return false;
-    }
-
-    return true;
-  }
-
-
-
-
-  void SetDataFlags(uint32_t aDataFlags)
-  {
-    do { } while(0);
-    mFlags = aDataFlags | (mFlags & 0xFFFF0000);
-  }
-
-  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
-                                  const char_type* aData, size_type aLength);
-
-  static const size_type kMaxCapacity;
-public:
-
-
-
-  void AssignLiteral(const char_type* aData, size_type aLength);
-};
-
-static_assert(sizeof(nsAString) ==
-              sizeof(mozilla::detail::nsStringRepr),
-              "Don't add new data fields to nsTSubstring_CharT. "
-              "Add to nsTStringRepr_CharT instead.");
-
-int
-Compare(const nsAString::base_string_type& aLhs,
-        const nsAString::base_string_type& aRhs,
-        const nsStringComparator& = nsDefaultStringComparator());
-
-
-inline bool
-operator!=(const nsAString::base_string_type& aLhs,
-           const nsAString::base_string_type& aRhs)
-{
-  return !aLhs.Equals(aRhs);
-}
-
-inline bool
-operator!=(const nsAString::base_string_type& aLhs,
-           const nsAString::char_type* aRhs)
-{
-  return !aLhs.Equals(aRhs);
-}
-
-inline bool
-operator<(const nsAString::base_string_type& aLhs,
-          const nsAString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) < 0;
-}
-
-inline bool
-operator<=(const nsAString::base_string_type& aLhs,
-           const nsAString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) <= 0;
-}
-
-inline bool
-operator==(const nsAString::base_string_type& aLhs,
-           const nsAString::base_string_type& aRhs)
-{
-  return aLhs.Equals(aRhs);
-}
-
-inline bool
-operator==(const nsAString::base_string_type& aLhs,
-           const nsAString::char_type* aRhs)
-{
-  return aLhs.Equals(aRhs);
-}
-
-
-inline bool
-operator>=(const nsAString::base_string_type& aLhs,
-           const nsAString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) >= 0;
-}
-
-inline bool
-operator>(const nsAString::base_string_type& aLhs,
-          const nsAString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) > 0;
-}
-
-
-
-class nsSubstringSplitter
-{
-  typedef nsAString::size_type size_type;
-  typedef nsAString::char_type char_type;
-
-  class nsTSubstringSplit_Iter
-  {
-  public:
-    nsTSubstringSplit_Iter(const nsSubstringSplitter& aObj,
-                           size_type aPos)
-      : mObj(aObj)
-      , mPos(aPos)
-    {
-    }
-
-    bool operator!=(const nsTSubstringSplit_Iter& other) const
-    {
-      return mPos != other.mPos;
-    }
-
-    const nsDependentSubstring& operator*() const;
-
-    const nsTSubstringSplit_Iter& operator++()
-    {
-      ++mPos;
-      return *this;
-    }
-
-  private:
-    const nsSubstringSplitter& mObj;
-    size_type mPos;
-  };
-
-private:
-  const nsAString* const mStr;
-  mozilla::UniquePtr<nsDependentSubstring[]> mArray;
-  size_type mArraySize;
-  const char_type mDelim;
-
-public:
-  nsSubstringSplitter(const nsAString* aStr, char_type aDelim);
-
-  nsTSubstringSplit_Iter begin() const
-  {
-    return nsTSubstringSplit_Iter(*this, 0);
-  }
-
-  nsTSubstringSplit_Iter end() const
-  {
-    return nsTSubstringSplit_Iter(*this, mArraySize);
-  }
-
-  const nsDependentSubstring& Get(const size_type index) const
-  {
-    do { } while (0);
-    return mArray[index];
-  }
-};
-
-
-
-
-namespace mozilla {
-
-inline Span<char16_t>
-MakeSpan(nsAString& aString)
-{
-  return aString;
-}
-
-inline Span<const char16_t>
-MakeSpan(const nsAString& aString)
-{
-  return aString;
-}
-
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsCStringComparator
-{
-public:
-  typedef char char_type;
-
-  nsCStringComparator()
-  {
-  }
-
-  virtual int operator()(const char_type*, const char_type*,
-                         uint32_t, uint32_t) const = 0;
-};
-
-
-
-
-
-class nsDefaultCStringComparator
-  : public nsCStringComparator
-{
-public:
-  typedef char char_type;
-
-  nsDefaultCStringComparator()
-  {
-  }
-
-  virtual int operator()(const char_type*, const char_type*,
-                         uint32_t, uint32_t) const override;
-};
-
-class nsCSubstringSplitter;
-
-namespace mozilla {
-namespace detail {
-# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsCStringRepr
-{
-public:
-  typedef mozilla::fallible_t fallible_t;
-
-  typedef char char_type;
-
-  typedef nsCharTraits<char_type> char_traits;
-  typedef char_traits::incompatible_char_type incompatible_char_type;
-
-  typedef nsCStringRepr self_type;
-  typedef self_type base_string_type;
-
-  typedef nsACString substring_type;
-  typedef nsCSubstringTuple substring_tuple_type;
-  typedef nsCString string_type;
-
-  typedef nsReadingIterator<char_type> const_iterator;
-  typedef nsWritingIterator<char_type> iterator;
-
-  typedef nsCStringComparator comparator_type;
-
-  typedef char_type* char_iterator;
-  typedef const char_type* const_char_iterator;
-
-  typedef uint32_t index_type;
-  typedef uint32_t size_type;
-
-
-
-
-
-  const_char_iterator BeginReading() const
-  {
-    return mData;
-  }
-  const_char_iterator EndReading() const
-  {
-    return mData + mLength;
-  }
-
-
-
-
-
-  const_iterator& BeginReading(const_iterator& aIter) const
-  {
-    aIter.mStart = mData;
-    aIter.mEnd = mData + mLength;
-    aIter.mPosition = aIter.mStart;
-    return aIter;
-  }
-
-  const_iterator& EndReading(const_iterator& aIter) const
-  {
-    aIter.mStart = mData;
-    aIter.mEnd = mData + mLength;
-    aIter.mPosition = aIter.mEnd;
-    return aIter;
-  }
-
-  const_char_iterator& BeginReading(const_char_iterator& aIter) const
-  {
-    return aIter = mData;
-  }
-
-  const_char_iterator& EndReading(const_char_iterator& aIter) const
-  {
-    return aIter = mData + mLength;
-  }
-# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  const char_type* Data() const
-
-  {
-    return mData;
-  }
-
-  size_type Length() const
-  {
-    return mLength;
-  }
-
-  uint32_t Flags() const
-  {
-    return mFlags;
-  }
-
-  bool IsEmpty() const
-  {
-    return mLength == 0;
-  }
-
-  bool IsLiteral() const
-  {
-    return (mFlags & F_LITERAL) != 0;
-  }
-
-  bool IsVoid() const
-  {
-    return (mFlags & F_VOIDED) != 0;
-  }
-
-  bool IsTerminated() const
-  {
-    return (mFlags & F_TERMINATED) != 0;
-  }
-
-  char_type CharAt(index_type aIndex) const
-  {
-    do { } while(0);
-    return mData[aIndex];
-  }
-
-  char_type operator[](index_type aIndex) const
-  {
-    return CharAt(aIndex);
-  }
-
-  char_type First() const;
-
-  char_type Last() const;
-
-  size_type CountChar(char_type) const;
-  int32_t FindChar(char_type, index_type aOffset = 0) const;
-
-  inline bool Contains(char_type aChar) const
-  {
-    return FindChar(aChar) != -1;
-  }
-
-
-
-
-
-  bool Equals(const self_type&) const;
-  bool Equals(const self_type&, const comparator_type&) const;
-
-  bool Equals(const substring_tuple_type& aTuple) const;
-  bool Equals(const substring_tuple_type& aTuple,
-                          const comparator_type& aComp) const;
-
-  bool Equals(const char_type* aData) const;
-  bool Equals(const char_type* aData,
-                          const comparator_type& aComp) const;
-# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  bool EqualsASCII(const char* aData, size_type aLen) const;
-
-
-
-
-
-  bool EqualsASCII(const char* aData) const;
-
-
-
-
-
-
-
-  template<int N>
-  inline bool EqualsLiteral(const char (&aStr)[N]) const
-  {
-    return EqualsASCII(aStr, N - 1);
-  }
-
-
-
-
-
-
-
-  bool LowerCaseEqualsASCII(const char* aData,
-                                        size_type aLen) const;
-  bool LowerCaseEqualsASCII(const char* aData) const;
-
-
-
-
-
-
-  template<int N>
-  inline bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const
-  {
-    return LowerCaseEqualsASCII(aStr, N - 1);
-  }
-
-
-
-
-  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const
-  {
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-    return (aStart < (mData + mLength) && aEnd > mData);
-  }
-
-protected:
-  nsCStringRepr() = delete;
-
-  constexpr
-  nsCStringRepr(char_type* aData, size_type aLength, uint32_t aFlags)
-    : mData(aData)
-    , mLength(aLength)
-    , mFlags(aFlags)
-  {
-  }
-
-  char_type* mData;
-  size_type mLength;
-  uint32_t mFlags;
-
-public:
-
-
-
-
-
-
-  enum
-  {
-    F_NONE = 0,
-
-
-    F_TERMINATED = 1 << 0,
-    F_VOIDED = 1 << 1,
-    F_SHARED = 1 << 2,
-    F_OWNED = 1 << 3,
-    F_FIXED = 1 << 4,
-    F_LITERAL = 1 << 5,
-
-
-    F_CLASS_FIXED = 1 << 16
-  };
-# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-};
-
-}
-}
-# 389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-class nsACString : public mozilla::detail::nsCStringRepr
-{
-public:
-  typedef nsACString self_type;
-
-
-  ~nsACString()
-  {
-    Finalize();
-  }
-
-
-
-
-
-  char_iterator BeginWriting()
-  {
-    if (!EnsureMutable()) {
-      AllocFailed(mLength);
-    }
-
-    return mData;
-  }
-
-  char_iterator BeginWriting(const fallible_t&)
-  {
-    return EnsureMutable() ? mData : char_iterator(0);
-  }
-
-  char_iterator EndWriting()
-  {
-    if (!EnsureMutable()) {
-      AllocFailed(mLength);
-    }
-
-    return mData + mLength;
-  }
-
-  char_iterator EndWriting(const fallible_t&)
-  {
-    return EnsureMutable() ? (mData + mLength) : char_iterator(0);
-  }
-
-  char_iterator& BeginWriting(char_iterator& aIter)
-  {
-    return aIter = BeginWriting();
-  }
-
-  char_iterator& BeginWriting(char_iterator& aIter, const fallible_t& aFallible)
-  {
-    return aIter = BeginWriting(aFallible);
-  }
-
-  char_iterator& EndWriting(char_iterator& aIter)
-  {
-    return aIter = EndWriting();
-  }
-
-  char_iterator& EndWriting(char_iterator& aIter, const fallible_t& aFallible)
-  {
-    return aIter = EndWriting(aFallible);
-  }
-
-
-
-
-
-  iterator& BeginWriting(iterator& aIter)
-  {
-    char_type* data = BeginWriting();
-    aIter.mStart = data;
-    aIter.mEnd = data + mLength;
-    aIter.mPosition = aIter.mStart;
-    return aIter;
-  }
-
-  iterator& EndWriting(iterator& aIter)
-  {
-    char_type* data = BeginWriting();
-    aIter.mStart = data;
-    aIter.mEnd = data + mLength;
-    aIter.mPosition = aIter.mEnd;
-    return aIter;
-  }
-
-
-
-
-
-  void Assign(char_type aChar);
-  __attribute__ ((warn_unused_result)) bool Assign(char_type aChar, const fallible_t&);
-
-  void Assign(const char_type* aData);
-  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
-                                       const fallible_t&);
-
-  void Assign(const char_type* aData, size_type aLength);
-  __attribute__ ((warn_unused_result)) bool Assign(const char_type* aData,
-                                       size_type aLength, const fallible_t&);
-
-  void Assign(const self_type&);
-  __attribute__ ((warn_unused_result)) bool Assign(const self_type&, const fallible_t&);
-
-  void Assign(const substring_tuple_type&);
-  __attribute__ ((warn_unused_result)) bool Assign(const substring_tuple_type&,
-                                       const fallible_t&);
-# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void AssignASCII(const char* aData, size_type aLength);
-  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
-                                            size_type aLength,
-                                            const fallible_t&);
-
-  void AssignASCII(const char* aData)
-  {
-    AssignASCII(aData, mozilla::AssertedCast<size_type, size_t>(strlen(aData)));
-  }
-  __attribute__ ((warn_unused_result)) bool AssignASCII(const char* aData,
-                                            const fallible_t& aFallible)
-  {
-    return AssignASCII(aData,
-                       mozilla::AssertedCast<size_type, size_t>(strlen(aData)),
-                       aFallible);
-  }
-
-
-
-
-
-
-
-  template<int N>
-  void AssignLiteral(const char_type (&aStr)[N])
-  {
-    AssignLiteral(aStr, N - 1);
-  }
-# 551 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-  void Adopt(char_type* aData, size_type aLength = size_type(-1));
-
-
-
-
-
-
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           char_type aChar);
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                                        size_type aCutLength,
-                                        char_type aChar,
-                                        const fallible_t&);
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           const char_type* aData,
-                           size_type aLength = size_type(-1));
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                                        size_type aCutLength,
-                                        const char_type* aData,
-                                        size_type aLength,
-                                        const fallible_t&);
-  void Replace(index_type aCutStart, size_type aCutLength,
-               const self_type& aStr)
-  {
-    Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length());
-  }
-  __attribute__ ((warn_unused_result)) bool Replace(index_type aCutStart,
-                            size_type aCutLength,
-                            const self_type& aStr,
-                            const fallible_t& aFallible)
-  {
-    return Replace(aCutStart, aCutLength, aStr.Data(), aStr.Length(),
-                   aFallible);
-  }
-  void Replace(index_type aCutStart, size_type aCutLength,
-                           const substring_tuple_type& aTuple);
-
-  void ReplaceASCII(index_type aCutStart, size_type aCutLength,
-                                const char* aData,
-                                size_type aLength = size_type(-1));
-
-  __attribute__ ((warn_unused_result)) bool ReplaceASCII(index_type aCutStart, size_type aCutLength,
-                                             const char* aData,
-                                             size_type aLength,
-                                             const fallible_t&);
-
-
-
-
-  template<int N>
-  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
-                      const char_type (&aStr)[N])
-  {
-    ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1);
-  }
-
-  void Append(char_type aChar)
-  {
-    Replace(mLength, 0, aChar);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(char_type aChar, const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aChar, aFallible);
-  }
-  void Append(const char_type* aData, size_type aLength = size_type(-1))
-  {
-    Replace(mLength, 0, aData, aLength);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(const char_type* aData, size_type aLength,
-                           const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aData, aLength, aFallible);
-  }
-# 660 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void Append(const self_type& aStr)
-  {
-    Replace(mLength, 0, aStr);
-  }
-  __attribute__ ((warn_unused_result)) bool Append(const self_type& aStr, const fallible_t& aFallible)
-  {
-    return Replace(mLength, 0, aStr, aFallible);
-  }
-  void Append(const substring_tuple_type& aTuple)
-  {
-    Replace(mLength, 0, aTuple);
-  }
-
-  void AppendASCII(const char* aData, size_type aLength = size_type(-1))
-  {
-    ReplaceASCII(mLength, 0, aData, aLength);
-  }
-
-  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, const fallible_t& aFallible)
-  {
-    return ReplaceASCII(mLength, 0, aData, size_type(-1), aFallible);
-  }
-
-  __attribute__ ((warn_unused_result)) bool AppendASCII(const char* aData, size_type aLength, const fallible_t& aFallible)
-  {
-    return ReplaceASCII(mLength, 0, aData, aLength, aFallible);
-  }
-
-
-
-
-
-
-
-  void AppendPrintf(const char* aFormat, ...) __attribute__ ((format (printf, 2, 3)));
-  void AppendPrintf(const char* aFormat, va_list aAp);
-  void AppendInt(int32_t aInteger)
-  {
-    AppendPrintf("%" "d", aInteger);
-  }
-  void AppendInt(int32_t aInteger, int aRadix)
-  {
-    if (aRadix == 10) {
-      AppendPrintf("%" "d", aInteger);
-    } else {
-      AppendPrintf(aRadix == 8 ? "%" "o" : "%" "x",
-                   static_cast<uint32_t>(aInteger));
-    }
-  }
-  void AppendInt(uint32_t aInteger)
-  {
-    AppendPrintf("%" "u", aInteger);
-  }
-  void AppendInt(uint32_t aInteger, int aRadix)
-  {
-    AppendPrintf(aRadix == 10 ? "%" "u" : aRadix == 8 ? "%" "o" : "%" "x",
-                 aInteger);
-  }
-  void AppendInt(int64_t aInteger)
-  {
-    AppendPrintf("%" "l" "d", aInteger);
-  }
-  void AppendInt(int64_t aInteger, int aRadix)
-  {
-    if (aRadix == 10) {
-      AppendPrintf("%" "l" "d", aInteger);
-    } else {
-      AppendPrintf(aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
-                   static_cast<uint64_t>(aInteger));
-    }
-  }
-  void AppendInt(uint64_t aInteger)
-  {
-    AppendPrintf("%" "l" "u", aInteger);
-  }
-  void AppendInt(uint64_t aInteger, int aRadix)
-  {
-    AppendPrintf(aRadix == 10 ? "%" "l" "u" : aRadix == 8 ? "%" "l" "o" : "%" "l" "x",
-                 aInteger);
-  }
-
-
-
-
-  void AppendFloat(float aFloat);
-  void AppendFloat(double aFloat);
-public:
-
-
-
-
-  template<int N>
-  void AppendLiteral(const char_type (&aStr)[N])
-  {
-    ReplaceLiteral(mLength, 0, aStr, N - 1);
-  }
-# 770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  self_type& operator+=(char_type aChar)
-  {
-    Append(aChar);
-    return *this;
-  }
-  self_type& operator+=(const char_type* aData)
-  {
-    Append(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator+=(const self_type& aStr)
-  {
-    Append(aStr);
-    return *this;
-  }
-  self_type& operator+=(const substring_tuple_type& aTuple)
-  {
-    Append(aTuple);
-    return *this;
-  }
-
-  void Insert(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 0, aChar);
-  }
-  void Insert(const char_type* aData, index_type aPos,
-              size_type aLength = size_type(-1))
-  {
-    Replace(aPos, 0, aData, aLength);
-  }
-
-
-
-
-
-
-
-  void Insert(const self_type& aStr, index_type aPos)
-  {
-    Replace(aPos, 0, aStr);
-  }
-  void Insert(const substring_tuple_type& aTuple, index_type aPos)
-  {
-    Replace(aPos, 0, aTuple);
-  }
-
-
-
-
-  template<int N>
-  void InsertLiteral(const char_type (&aStr)[N], index_type aPos)
-  {
-    ReplaceLiteral(aPos, 0, aStr, N - 1);
-  }
-
-  void Cut(index_type aCutStart, size_type aCutLength)
-  {
-    Replace(aCutStart, aCutLength, char_traits::sEmptyBuffer, 0);
-  }
-
-  nsCSubstringSplitter Split(const char_type aChar) const;
-# 850 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void SetCapacity(size_type aNewCapacity);
-  __attribute__ ((warn_unused_result)) bool SetCapacity(size_type aNewCapacity,
-                                            const fallible_t&);
-
-  void SetLength(size_type aNewLength);
-  __attribute__ ((warn_unused_result)) bool SetLength(size_type aNewLength,
-                                          const fallible_t&);
-
-  void Truncate(size_type aNewLength = 0)
-  {
-    do { } while(0);
-    SetLength(aNewLength);
-  }
-# 876 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  inline size_type GetData(const char_type** aData) const
-  {
-    *aData = mData;
-    return mLength;
-  }
-# 892 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  size_type GetMutableData(char_type** aData, size_type aNewLen = size_type(-1))
-  {
-    if (!EnsureMutable(aNewLen)) {
-      AllocFailed(aNewLen == size_type(-1) ? mLength : aNewLen);
-    }
-
-    *aData = mData;
-    return mLength;
-  }
-
-  size_type GetMutableData(char_type** aData, size_type aNewLen, const fallible_t&)
-  {
-    if (!EnsureMutable(aNewLen)) {
-      *aData = nullptr;
-      return 0;
-    }
-
-    *aData = mData;
-    return mLength;
-  }
-# 931 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  operator mozilla::Span<char_type>()
-  {
-    return mozilla::MakeSpan(BeginWriting(), Length());
-  }
-
-  operator mozilla::Span<const char_type>() const
-  {
-    return mozilla::MakeSpan(BeginReading(), Length());
-  }
-
-  void Append(mozilla::Span<const char_type> aSpan)
-  {
-    auto len = aSpan.Length();
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
-    Append(aSpan.Elements(), len);
-  }
-
-  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const char_type> aSpan,
-                           const fallible_t& aFallible)
-  {
-    auto len = aSpan.Length();
-    if (len > mozilla::MaxValue<size_type>::value) {
-      return false;
-    }
-    return Append(aSpan.Elements(), len, aFallible);
-  }
-
-
-  operator mozilla::Span<uint8_t>()
-  {
-    return mozilla::MakeSpan(reinterpret_cast<uint8_t*>(BeginWriting()),
-                             Length());
-  }
-
-  operator mozilla::Span<const uint8_t>() const
-  {
-    return mozilla::MakeSpan(reinterpret_cast<const uint8_t*>(BeginReading()),
-                             Length());
-  }
-
-  void Append(mozilla::Span<const uint8_t> aSpan)
-  {
-    auto len = aSpan.Length();
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 974; ::abort(); } while (0); } } while (0);
-    Append(reinterpret_cast<const char*>(aSpan.Elements()), len);
-  }
-
-  __attribute__ ((warn_unused_result)) bool Append(mozilla::Span<const uint8_t> aSpan,
-                           const fallible_t& aFallible)
-  {
-    auto len = aSpan.Length();
-    if (len > mozilla::MaxValue<size_type>::value) {
-      return false;
-    }
-    return Append(
-      reinterpret_cast<const char*>(aSpan.Elements()), len, aFallible);
-  }
-
-
-
-
-
-
-
-  void SetIsVoid(bool);
-# 1005 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void StripChar(char_type aChar, int32_t aOffset = 0);
-# 1015 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  void StripChars(const char_type* aChars, uint32_t aOffset = 0);
-
-
-
-
-
-  void ForgetSharedBuffer()
-  {
-    if (mFlags & nsSubstring::F_SHARED) {
-      mData = char_traits::sEmptyBuffer;
-      mLength = 0;
-      mFlags = F_TERMINATED;
-    }
-  }
-
-public:
-
-
-
-
-
-               nsACString(const substring_tuple_type& aTuple)
-    : nsCStringRepr(nullptr, 0, F_NONE)
-  {
-    Assign(aTuple);
-  }
-
-  size_t SizeOfExcludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-
-
-
-
-
-
-
-  size_t SizeOfExcludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf)
-  const;
-
-  template<class T>
-  void NS_ABORT_OOM(T)
-  {
-    struct never {};
-    static_assert(mozilla::IsSame<T, never>::value,
-      "In string classes, use AllocFailed to account for sizeof(char_type). "
-      "Use the global ::NS_ABORT_OOM if you really have a count of bytes.");
-  }
-
-  __attribute__((always_inline)) inline void AllocFailed(size_t aLength)
-  {
-    ::NS_ABORT_OOM(aLength * sizeof(char_type));
-  }
-
-protected:
-
-
-  nsACString()
-    : nsCStringRepr(char_traits::sEmptyBuffer, 0, F_TERMINATED)
-  {
-  }
-
-
-
-  nsACString(const self_type& aStr)
-    : nsCStringRepr(aStr.mData, aStr.mLength,
-                          aStr.mFlags & (F_TERMINATED | F_VOIDED))
-  {
-  }
-# 1097 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  nsACString(char_type* aData, size_type aLength, uint32_t aFlags)
-    : nsCStringRepr(aData, aLength, aFlags)
-  {
-  }
-
-
-
-
-
-
-
-  void Finalize();
-# 1128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  bool MutatePrep(size_type aCapacity,
-                              char_type** aOldData, uint32_t* aOldFlags);
-# 1151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  __attribute__ ((warn_unused_result)) bool ReplacePrep(index_type aCutStart,
-                                size_type aCutLength,
-                                size_type aNewLength);
-
-  __attribute__ ((warn_unused_result)) bool ReplacePrepInternal(
-    index_type aCutStart,
-    size_type aCutLength,
-    size_type aNewFragLength,
-    size_type aNewTotalLength);
-# 1168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstring.h"
-  size_type Capacity() const;
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool EnsureMutable(
-    size_type aNewLen = size_type(-1));
-
-
-
-
-  static __attribute__ ((warn_unused_result)) bool CheckCapacity(size_type aCapacity) {
-    if (aCapacity > kMaxCapacity) {
-
-
-      do { } while(0);
-      return false;
-    }
-
-    return true;
-  }
-
-
-
-
-  void SetDataFlags(uint32_t aDataFlags)
-  {
-    do { } while(0);
-    mFlags = aDataFlags | (mFlags & 0xFFFF0000);
-  }
-
-  void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
-                                  const char_type* aData, size_type aLength);
-
-  static const size_type kMaxCapacity;
-public:
-
-
-
-  void AssignLiteral(const char_type* aData, size_type aLength);
-};
-
-static_assert(sizeof(nsACString) ==
-              sizeof(mozilla::detail::nsCStringRepr),
-              "Don't add new data fields to nsTSubstring_CharT. "
-              "Add to nsTStringRepr_CharT instead.");
-
-int
-Compare(const nsACString::base_string_type& aLhs,
-        const nsACString::base_string_type& aRhs,
-        const nsCStringComparator& = nsDefaultCStringComparator());
-
-
-inline bool
-operator!=(const nsACString::base_string_type& aLhs,
-           const nsACString::base_string_type& aRhs)
-{
-  return !aLhs.Equals(aRhs);
-}
-
-inline bool
-operator!=(const nsACString::base_string_type& aLhs,
-           const nsACString::char_type* aRhs)
-{
-  return !aLhs.Equals(aRhs);
-}
-
-inline bool
-operator<(const nsACString::base_string_type& aLhs,
-          const nsACString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) < 0;
-}
-
-inline bool
-operator<=(const nsACString::base_string_type& aLhs,
-           const nsACString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) <= 0;
-}
-
-inline bool
-operator==(const nsACString::base_string_type& aLhs,
-           const nsACString::base_string_type& aRhs)
-{
-  return aLhs.Equals(aRhs);
-}
-
-inline bool
-operator==(const nsACString::base_string_type& aLhs,
-           const nsACString::char_type* aRhs)
-{
-  return aLhs.Equals(aRhs);
-}
-
-
-inline bool
-operator>=(const nsACString::base_string_type& aLhs,
-           const nsACString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) >= 0;
-}
-
-inline bool
-operator>(const nsACString::base_string_type& aLhs,
-          const nsACString::base_string_type& aRhs)
-{
-  return Compare(aLhs, aRhs) > 0;
-}
-
-
-
-class nsCSubstringSplitter
-{
-  typedef nsACString::size_type size_type;
-  typedef nsACString::char_type char_type;
-
-  class nsTSubstringSplit_Iter
-  {
-  public:
-    nsTSubstringSplit_Iter(const nsCSubstringSplitter& aObj,
-                           size_type aPos)
-      : mObj(aObj)
-      , mPos(aPos)
-    {
-    }
-
-    bool operator!=(const nsTSubstringSplit_Iter& other) const
-    {
-      return mPos != other.mPos;
-    }
-
-    const nsDependentCSubstring& operator*() const;
-
-    const nsTSubstringSplit_Iter& operator++()
-    {
-      ++mPos;
-      return *this;
-    }
-
-  private:
-    const nsCSubstringSplitter& mObj;
-    size_type mPos;
-  };
-
-private:
-  const nsACString* const mStr;
-  mozilla::UniquePtr<nsDependentCSubstring[]> mArray;
-  size_type mArraySize;
-  const char_type mDelim;
-
-public:
-  nsCSubstringSplitter(const nsACString* aStr, char_type aDelim);
-
-  nsTSubstringSplit_Iter begin() const
-  {
-    return nsTSubstringSplit_Iter(*this, 0);
-  }
-
-  nsTSubstringSplit_Iter end() const
-  {
-    return nsTSubstringSplit_Iter(*this, mArraySize);
-  }
-
-  const nsDependentCSubstring& Get(const size_type index) const
-  {
-    do { } while (0);
-    return mArray[index];
-  }
-};
-
-
-
-
-namespace mozilla {
-
-inline Span<char>
-MakeSpan(nsACString& aString)
-{
-  return aString;
-}
-
-inline Span<const char>
-MakeSpan(const nsACString& aString)
-{
-  return aString;
-}
-
-}
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-
-
-
-
-
-
-class nsCaseInsensitiveCStringComparator
-  : public nsCStringComparator
-{
-public:
-  nsCaseInsensitiveCStringComparator()
-  {
-  }
-  typedef char char_type;
-
-  virtual int operator()(const char_type*, const char_type*,
-                         uint32_t, uint32_t) const override;
-};
-
-class nsCaseInsensitiveCStringArrayComparator
-{
-public:
-  template<class A, class B>
-  bool Equals(const A& aStrA, const B& aStrB) const
-  {
-    return aStrA.Equals(aStrB, nsCaseInsensitiveCStringComparator());
-  }
-};
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h"
-class nsSubstringTuple
-{
-public:
-
-  typedef char16_t char_type;
-  typedef nsCharTraits<char_type> char_traits;
-
-  typedef nsSubstringTuple self_type;
-  typedef mozilla::detail::nsStringRepr base_string_type;
-  typedef uint32_t size_type;
-
-public:
-
-  nsSubstringTuple(const base_string_type* aStrA,
-                          const base_string_type* aStrB)
-    : mHead(nullptr)
-    , mFragA(aStrA)
-    , mFragB(aStrB)
-  {
-  }
-
-  nsSubstringTuple(const self_type& aHead,
-                          const base_string_type* aStrB)
-    : mHead(&aHead)
-    , mFragA(nullptr)
-    , mFragB(aStrB)
-  {
-  }
-
-
-
-
-  size_type Length() const;
-
-
-
-
-
-
-  void WriteTo(char_type* aBuf, uint32_t aBufLen) const;
-
-
-
-
-
-  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const;
-
-private:
-
-  const self_type* const mHead;
-  const base_string_type* const mFragA;
-  const base_string_type* const mFragB;
-};
-
-inline const nsSubstringTuple
-operator+(const nsSubstringTuple::base_string_type& aStrA,
-          const nsSubstringTuple::base_string_type& aStrB)
-{
-  return nsSubstringTuple(&aStrA, &aStrB);
-}
-
-inline const nsSubstringTuple
-operator+(const nsSubstringTuple& aHead,
-          const nsSubstringTuple::base_string_type& aStrB)
-{
-  return nsSubstringTuple(aHead, &aStrB);
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTSubstringTuple.h"
-class nsCSubstringTuple
-{
-public:
-
-  typedef char char_type;
-  typedef nsCharTraits<char_type> char_traits;
-
-  typedef nsCSubstringTuple self_type;
-  typedef mozilla::detail::nsCStringRepr base_string_type;
-  typedef uint32_t size_type;
-
-public:
-
-  nsCSubstringTuple(const base_string_type* aStrA,
-                          const base_string_type* aStrB)
-    : mHead(nullptr)
-    , mFragA(aStrA)
-    , mFragB(aStrB)
-  {
-  }
-
-  nsCSubstringTuple(const self_type& aHead,
-                          const base_string_type* aStrB)
-    : mHead(&aHead)
-    , mFragA(nullptr)
-    , mFragB(aStrB)
-  {
-  }
-
-
-
-
-  size_type Length() const;
-
-
-
-
-
-
-  void WriteTo(char_type* aBuf, uint32_t aBufLen) const;
-
-
-
-
-
-  bool IsDependentOn(const char_type* aStart, const char_type* aEnd) const;
-
-private:
-
-  const self_type* const mHead;
-  const base_string_type* const mFragA;
-  const base_string_type* const mFragB;
-};
-
-inline const nsCSubstringTuple
-operator+(const nsCSubstringTuple::base_string_type& aStrA,
-          const nsCSubstringTuple::base_string_type& aStrB)
-{
-  return nsCSubstringTuple(&aStrA, &aStrB);
-}
-
-inline const nsCSubstringTuple
-operator+(const nsCSubstringTuple& aHead,
-          const nsCSubstringTuple::base_string_type& aStrB)
-{
-  return nsCSubstringTuple(aHead, &aStrB);
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstringTuple.h" 2
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAString.h" 2
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSubstring.h" 2
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
-class nsDependentSubstring : public nsAString
-{
-public:
-
-  typedef nsDependentSubstring self_type;
-
-public:
-
-  void Rebind(const substring_type&, uint32_t aStartPos,
-              uint32_t aLength = size_type(-1));
-
-  void Rebind(const char_type* aData, size_type aLength);
-
-  void Rebind(const char_type* aStart, const char_type* aEnd);
-
-  nsDependentSubstring(const substring_type& aStr, uint32_t aStartPos,
-                              uint32_t aLength = size_type(-1))
-    : substring_type()
-  {
-    Rebind(aStr, aStartPos, aLength);
-  }
-
-  nsDependentSubstring(const char_type* aData, size_type aLength)
-    : substring_type(const_cast<char_type*>(aData), aLength, F_NONE)
-  {
-  }
-
-  nsDependentSubstring(const char_type* aStart, const char_type* aEnd);
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
-  nsDependentSubstring(const const_iterator& aStart,
-                              const const_iterator& aEnd);
-
-
-  nsDependentSubstring()
-    : substring_type()
-  {
-  }
-
-
-
-private:
-
-  void operator=(const self_type&);
-};
-
-inline const nsDependentSubstring
-Substring(const nsAString& aStr, uint32_t aStartPos,
-          uint32_t aLength = uint32_t(-1))
-{
-  return nsDependentSubstring(aStr, aStartPos, aLength);
-}
-
-inline const nsDependentSubstring
-Substring(const nsReadingIterator<char16_t>& aStart,
-          const nsReadingIterator<char16_t>& aEnd)
-{
-  return nsDependentSubstring(aStart.get(), aEnd.get());
-}
-
-inline const nsDependentSubstring
-Substring(const char16_t* aData, uint32_t aLength)
-{
-  return nsDependentSubstring(aData, aLength);
-}
-
-const nsDependentSubstring
-Substring(const char16_t* aStart, const char16_t* aEnd);
-
-inline const nsDependentSubstring
-StringHead(const nsAString& aStr, uint32_t aCount)
-{
-  return nsDependentSubstring(aStr, 0, aCount);
-}
-
-inline const nsDependentSubstring
-StringTail(const nsAString& aStr, uint32_t aCount)
-{
-  return nsDependentSubstring(aStr, aStr.Length() - aCount, aCount);
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
-class nsDependentCSubstring : public nsACString
-{
-public:
-
-  typedef nsDependentCSubstring self_type;
-
-public:
-
-  void Rebind(const substring_type&, uint32_t aStartPos,
-              uint32_t aLength = size_type(-1));
-
-  void Rebind(const char_type* aData, size_type aLength);
-
-  void Rebind(const char_type* aStart, const char_type* aEnd);
-
-  nsDependentCSubstring(const substring_type& aStr, uint32_t aStartPos,
-                              uint32_t aLength = size_type(-1))
-    : substring_type()
-  {
-    Rebind(aStr, aStartPos, aLength);
-  }
-
-  nsDependentCSubstring(const char_type* aData, size_type aLength)
-    : substring_type(const_cast<char_type*>(aData), aLength, F_NONE)
-  {
-  }
-
-  nsDependentCSubstring(const char_type* aStart, const char_type* aEnd);
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentSubstring.h"
-  nsDependentCSubstring(const const_iterator& aStart,
-                              const const_iterator& aEnd);
-
-
-  nsDependentCSubstring()
-    : substring_type()
-  {
-  }
-
-
-
-private:
-
-  void operator=(const self_type&);
-};
-
-inline const nsDependentCSubstring
-Substring(const nsACString& aStr, uint32_t aStartPos,
-          uint32_t aLength = uint32_t(-1))
-{
-  return nsDependentCSubstring(aStr, aStartPos, aLength);
-}
-
-inline const nsDependentCSubstring
-Substring(const nsReadingIterator<char>& aStart,
-          const nsReadingIterator<char>& aEnd)
-{
-  return nsDependentCSubstring(aStart.get(), aEnd.get());
-}
-
-inline const nsDependentCSubstring
-Substring(const char* aData, uint32_t aLength)
-{
-  return nsDependentCSubstring(aData, aLength);
-}
-
-const nsDependentCSubstring
-Substring(const char* aStart, const char* aEnd);
-
-inline const nsDependentCSubstring
-StringHead(const nsACString& aStr, uint32_t aCount)
-{
-  return nsDependentCSubstring(aStr, 0, aCount);
-}
-
-inline const nsDependentCSubstring
-StringTail(const nsACString& aStr, uint32_t aCount)
-{
-  return nsDependentCSubstring(aStr, aStr.Length() - aCount, aCount);
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentSubstring.h" 2
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-inline size_t
-Distance(const nsReadingIterator<char16_t>& aStart,
-         const nsReadingIterator<char16_t>& aEnd)
-{
-  do { } while (0);
-  return static_cast<size_t>(aEnd.get() - aStart.get());
-}
-inline size_t
-Distance(const nsReadingIterator<char>& aStart,
-         const nsReadingIterator<char>& aEnd)
-{
-  do { } while (0);
-  return static_cast<size_t>(aEnd.get() - aStart.get());
-}
-
-void LossyCopyUTF16toASCII(const nsAString& aSource, nsACString& aDest);
-void CopyASCIItoUTF16(const nsACString& aSource, nsAString& aDest);
-
-void LossyCopyUTF16toASCII(const char16ptr_t aSource, nsACString& aDest);
-void CopyASCIItoUTF16(const char* aSource, nsAString& aDest);
-
-void CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest);
-__attribute__ ((warn_unused_result)) bool CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest,
-                                  const mozilla::fallible_t&);
-void CopyUTF8toUTF16(const nsACString& aSource, nsAString& aDest);
-
-void CopyUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest);
-void CopyUTF8toUTF16(const char* aSource, nsAString& aDest);
-
-void LossyAppendUTF16toASCII(const nsAString& aSource, nsACString& aDest);
-void AppendASCIItoUTF16(const nsACString& aSource, nsAString& aDest);
-__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const nsACString& aSource,
-                                     nsAString& aDest,
-                                     const mozilla::fallible_t&);
-
-void LossyAppendUTF16toASCII(const char16ptr_t aSource, nsACString& aDest);
-__attribute__ ((warn_unused_result)) bool AppendASCIItoUTF16(const char* aSource,
-                                     nsAString& aDest,
-                                     const mozilla::fallible_t&);
-void AppendASCIItoUTF16(const char* aSource, nsAString& aDest);
-
-void AppendUTF16toUTF8(const nsAString& aSource, nsACString& aDest);
-__attribute__ ((warn_unused_result)) bool AppendUTF16toUTF8(const nsAString& aSource,
-                                    nsACString& aDest,
-                                    const mozilla::fallible_t&);
-void AppendUTF8toUTF16(const nsACString& aSource, nsAString& aDest);
-__attribute__ ((warn_unused_result)) bool AppendUTF8toUTF16(const nsACString& aSource,
-                                    nsAString& aDest,
-                                    const mozilla::fallible_t&);
-
-void AppendUTF16toUTF8(const char16ptr_t aSource, nsACString& aDest);
-void AppendUTF8toUTF16(const char* aSource, nsAString& aDest);
-# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char* ToNewCString(const nsAString& aSource);
-# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char* ToNewCString(const nsACString& aSource);
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char* ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count = nullptr);
-# 129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char16_t* ToNewUnicode(const nsAString& aSource);
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char16_t* ToNewUnicode(const nsACString& aSource);
-# 153 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-uint32_t CalcUTF8ToUnicodeLength(const nsACString& aSource);
-# 173 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char16_t* UTF8ToUnicodeBuffer(const nsACString& aSource,
-                              char16_t* aBuffer,
-                              uint32_t* aUTF16Count = nullptr);
-# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char16_t* UTF8ToNewUnicode(const nsACString& aSource,
-                           uint32_t* aUTF16Count = nullptr);
-# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-char16_t* CopyUnicodeTo(const nsAString& aSource,
-                        uint32_t aSrcOffset,
-                        char16_t* aDest,
-                        uint32_t aLength);
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-void CopyUnicodeTo(const nsAString::const_iterator& aSrcStart,
-                   const nsAString::const_iterator& aSrcEnd,
-                   nsAString& aDest);
-# 238 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-void AppendUnicodeTo(const nsAString::const_iterator& aSrcStart,
-                     const nsAString::const_iterator& aSrcEnd,
-                     nsAString& aDest);
-
-
-
-
-
-
-bool IsASCII(const nsAString& aString);
-
-
-
-
-
-
-bool IsASCII(const nsACString& aString);
-# 287 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-bool IsUTF8(const nsACString& aString, bool aRejectNonChar = true);
-
-bool ParseString(const nsACString& aAstring, char aDelimiter,
-                 nsTArray<nsCString>& aArray);
-
-
-
-
-void ToUpperCase(nsACString&);
-
-void ToLowerCase(nsACString&);
-
-void ToUpperCase(nsCSubstring&);
-
-void ToLowerCase(nsCSubstring&);
-
-
-
-
-void ToUpperCase(const nsACString& aSource, nsACString& aDest);
-
-void ToLowerCase(const nsACString& aSource, nsACString& aDest);
-# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-bool FindInReadable(const nsAString& aPattern, nsAString::const_iterator&,
-                    nsAString::const_iterator&,
-                    const nsStringComparator& = nsDefaultStringComparator());
-bool FindInReadable(const nsACString& aPattern, nsACString::const_iterator&,
-                    nsACString::const_iterator&,
-                    const nsCStringComparator& = nsDefaultCStringComparator());
-
-
-
-inline bool
-FindInReadable(const nsAString& aPattern, const nsAString& aSource,
-               const nsStringComparator& aCompare = nsDefaultStringComparator())
-{
-  nsAString::const_iterator start, end;
-  aSource.BeginReading(start);
-  aSource.EndReading(end);
-  return FindInReadable(aPattern, start, end, aCompare);
-}
-
-inline bool
-FindInReadable(const nsACString& aPattern, const nsACString& aSource,
-               const nsCStringComparator& aCompare = nsDefaultCStringComparator())
-{
-  nsACString::const_iterator start, end;
-  aSource.BeginReading(start);
-  aSource.EndReading(end);
-  return FindInReadable(aPattern, start, end, aCompare);
-}
-
-
-bool CaseInsensitiveFindInReadable(const nsACString& aPattern,
-                                   nsACString::const_iterator&,
-                                   nsACString::const_iterator&);
-
-
-
-
-
-
-
-bool RFindInReadable(const nsAString& aPattern, nsAString::const_iterator&,
-                     nsAString::const_iterator&,
-                     const nsStringComparator& = nsDefaultStringComparator());
-bool RFindInReadable(const nsACString& aPattern, nsACString::const_iterator&,
-                     nsACString::const_iterator&,
-                     const nsCStringComparator& = nsDefaultCStringComparator());
-# 375 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-bool FindCharInReadable(char16_t aChar, nsAString::const_iterator& aSearchStart,
-                        const nsAString::const_iterator& aSearchEnd);
-bool FindCharInReadable(char aChar, nsACString::const_iterator& aSearchStart,
-                        const nsACString::const_iterator& aSearchEnd);
-
-
-
-
-uint32_t CountCharInReadable(const nsAString& aStr,
-                             char16_t aChar);
-uint32_t CountCharInReadable(const nsACString& aStr,
-                             char aChar);
-
-bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring);
-bool StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring,
-                      const nsStringComparator& aComparator);
-bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring);
-bool StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring,
-                      const nsCStringComparator& aComparator);
-bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring);
-bool StringEndsWith(const nsAString& aSource, const nsAString& aSubstring,
-                    const nsStringComparator& aComparator);
-bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring);
-bool StringEndsWith(const nsACString& aSource, const nsACString& aSubstring,
-                    const nsCStringComparator& aComparator);
-
-const nsAFlatString& EmptyString();
-const nsAFlatCString& EmptyCString();
-
-const nsAFlatString& NullString();
-const nsAFlatCString& NullCString();
-# 415 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsReadableUtils.h"
-int32_t CompareUTF8toUTF16(const nsASingleFragmentCString& aUTF8String,
-                           const nsASingleFragmentString& aUTF16String);
-
-void AppendUCS4ToUTF16(const uint32_t aSource, nsAString& aDest);
-
-template<class T>
-inline bool
-EnsureStringLength(T& aStr, uint32_t aLen)
-{
-  aStr.SetLength(aLen);
-  return (aStr.Length() == aLen);
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsString : public nsAString
-{
-public:
-
-  typedef nsString self_type;
-
-public:
-
-
-
-
-
-  nsString()
-    : substring_type()
-  {
-  }
-
-  explicit
-  nsString(const char_type* aData, size_type aLength = size_type(-1))
-    : substring_type()
-  {
-    Assign(aData, aLength);
-  }
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsString(const self_type& aStr)
-    : substring_type()
-  {
-    Assign(aStr);
-  }
-
-               nsString(const substring_tuple_type& aTuple)
-    : substring_type()
-  {
-    Assign(aTuple);
-  }
-
-  explicit
-  nsString(const substring_type& aReadable)
-    : substring_type()
-  {
-    Assign(aReadable);
-  }
-
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  const char_type* get() const
-
-  {
-    return mData;
-  }
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  char_type CharAt(index_type aIndex) const
-  {
-    do { } while(0);
-    return mData[aIndex];
-  }
-
-  char_type operator[](index_type aIndex) const
-  {
-    return CharAt(aIndex);
-  }
-# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t Find(const nsCString& aString, bool aIgnoreCase = false,
-               int32_t aOffset = 0, int32_t aCount = -1) const;
-  int32_t Find(const char* aString, bool aIgnoreCase = false,
-               int32_t aOffset = 0, int32_t aCount = -1) const;
-
-
-  int32_t Find(const nsAFlatString& aString, int32_t aOffset = 0,
-               int32_t aCount = -1) const;
-  int32_t Find(const char16_t* aString, int32_t aOffset = 0,
-               int32_t aCount = -1) const;
-# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFind(const nsCString& aString, bool aIgnoreCase = false,
-                int32_t aOffset = -1, int32_t aCount = -1) const;
-  int32_t RFind(const char* aCString, bool aIgnoreCase = false,
-                int32_t aOffset = -1, int32_t aCount = -1) const;
-
-
-  int32_t RFind(const nsAFlatString& aString, int32_t aOffset = -1,
-                int32_t aCount = -1) const;
-  int32_t RFind(const char16_t* aString, int32_t aOffset = -1,
-                int32_t aCount = -1) const;
-# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFindChar(char16_t aChar, int32_t aOffset = -1,
-                    int32_t aCount = -1) const;
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const;
-  int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const
-  {
-    return FindCharInSet(aString.get(), aOffset);
-  }
-
-
-  int32_t FindCharInSet(const char16_t* aString, int32_t aOffset = 0) const;
-# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const;
-  int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const
-  {
-    return RFindCharInSet(aString.get(), aOffset);
-  }
-# 281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const;
-# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  double ToDouble(nsresult* aErrorCode) const;
-
-
-
-
-
-
-
-  float ToFloat(nsresult* aErrorCode) const
-  {
-    return (float)ToDouble(aErrorCode);
-  }
-# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
-
-
-
-
-
-
-
-  int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const;
-
-  size_type Left(self_type& aResult, size_type aCount) const
-  {
-    return Mid(aResult, 0, aCount);
-  }
-
-  size_type Right(self_type& aResult, size_type aCount) const
-  {
-    aCount = XPCOM_MIN(mLength, aCount);
-    return Mid(aResult, mLength - aCount, aCount);
-  }
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  bool SetCharAt(char16_t aChar, uint32_t aIndex);
-# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  using nsAString::StripChars;
-
-  void StripChars(const char* aSet);
-  bool StripChars(const char* aSet, const fallible_t&);
-
-
-
-
-
-  void StripWhitespace();
-  bool StripWhitespace(const fallible_t&);
-
-
-
-
-
-
-  void ReplaceChar(char_type aOldChar, char_type aNewChar);
-  void ReplaceChar(const char* aSet, char_type aNewChar);
-
-  void ReplaceChar(const char16_t* aSet, char16_t aNewChar);
-
-
-
-
-
-
-  void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue);
-  void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue);
-  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget,
-                                     const self_type& aNewValue,
-                                     const fallible_t&);
-  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget,
-                                     const char_type* aNewValue,
-                                     const fallible_t&);
-# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void Trim(const char* aSet, bool aEliminateLeading = true,
-            bool aEliminateTrailing = true, bool aIgnoreQuotes = false);
-# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void CompressWhitespace(bool aEliminateLeading = true,
-                          bool aEliminateTrailing = true);
-
-
-
-
-
-
-  void AssignWithConversion(const nsACString& aString);
-  void AssignWithConversion(const incompatible_char_type* aData,
-                            int32_t aLength = -1);
-# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void Rebind(const char_type* aData, size_type aLength);
-
-
-
-
-  void AssertValidDependentString()
-  {
-    do { } while(0);
-    do { } while(0);
-    do { } while(0);
-
-
-  }
-
-
-protected:
-
-
-  nsString(char_type* aData, size_type aLength, uint32_t aFlags)
-    : substring_type(aData, aLength, aFlags)
-  {
-  }
-
-  struct Segment {
-    uint32_t mBegin, mLength;
-    Segment(uint32_t aBegin, uint32_t aLength)
-      : mBegin(aBegin)
-      , mLength(aLength)
-    {}
-  };
-};
-
-
-class nsFixedString : public nsString
-{
-public:
-
-  typedef nsFixedString self_type;
-  typedef nsFixedString fixed_string_type;
-
-public:
-# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsFixedString(char_type* aData, size_type aStorageSize)
-    : string_type(aData, uint32_t(char_traits::length(aData)),
-                  F_TERMINATED | F_FIXED | F_CLASS_FIXED)
-    , mFixedCapacity(aStorageSize - 1)
-    , mFixedBuf(aData)
-  {
-  }
-
-  nsFixedString(char_type* aData, size_type aStorageSize,
-                       size_type aLength)
-    : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED)
-    , mFixedCapacity(aStorageSize - 1)
-    , mFixedBuf(aData)
-  {
-
-    mFixedBuf[aLength] = char_type(0);
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-protected:
-
-  friend class nsAString;
-
-  size_type mFixedCapacity;
-  char_type* mFixedBuf;
-};
-# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsAutoString : public nsFixedString
-{
-public:
-
-  typedef nsAutoString self_type;
-
-public:
-
-
-
-
-
-  nsAutoString()
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-  }
-
-  explicit
-  nsAutoString(char_type aChar)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aChar);
-  }
-
-  explicit
-  nsAutoString(const char_type* aData, size_type aLength = size_type(-1))
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aData, aLength);
-  }
-# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsAutoString(const self_type& aStr)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aStr);
-  }
-
-  explicit
-  nsAutoString(const substring_type& aStr)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aStr);
-  }
-
-               nsAutoString(const substring_tuple_type& aTuple)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aTuple);
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-  enum
-  {
-    kDefaultStorageSize = 64
-  };
-
-private:
-
-  char_type mStorage[kDefaultStorageSize];
-};
-
-
-
-
-
-
-
-template<class E> class nsTArrayElementTraits;
-template<>
-class nsTArrayElementTraits<nsAutoString>
-{
-public:
-  template<class A> struct Dont_Instantiate_nsTArray_of;
-  template<class A> struct Instead_Use_nsTArray_of;
-
-  static Dont_Instantiate_nsTArray_of<nsAutoString>*
-  Construct(Instead_Use_nsTArray_of<nsString>* aE)
-  {
-    return 0;
-  }
-  template<class A>
-  static Dont_Instantiate_nsTArray_of<nsAutoString>*
-  Construct(Instead_Use_nsTArray_of<nsString>* aE, const A& aArg)
-  {
-    return 0;
-  }
-  static Dont_Instantiate_nsTArray_of<nsAutoString>*
-  Destruct(Instead_Use_nsTArray_of<nsString>* aE)
-  {
-    return 0;
-  }
-};
-# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsXPIDLString : public nsString
-{
-public:
-
-  typedef nsXPIDLString self_type;
-
-public:
-
-  nsXPIDLString()
-    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
-  {
-  }
-
-
-  nsXPIDLString(const self_type& aStr)
-    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
-  {
-    Assign(aStr);
-  }
-
-
-
-
-
-  const char_type* get() const
-
-  {
-    return (mFlags & F_VOIDED) ? nullptr : mData;
-  }
-
-
-
-  operator const char_type*() const
-  {
-    return get();
-  }
-
-
-  char_type operator[](int32_t aIndex) const
-  {
-    return CharAt(index_type(aIndex));
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-};
-# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsGetterCopies
-{
-public:
-  typedef char16_t char_type;
-
-  explicit nsGetterCopies(nsAString& aStr)
-    : mString(aStr)
-    , mData(nullptr)
-  {
-  }
-
-  ~nsGetterCopies()
-  {
-    mString.Adopt(mData);
-  }
-
-  operator char_type**()
-  {
-    return &mData;
-  }
-
-private:
-  nsAString& mString;
-  char_type* mData;
-};
-
-inline nsGetterCopies
-getter_Copies(nsAString& aString)
-{
-  return nsGetterCopies(aString);
-}
-# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsAdoptingString : public nsXPIDLString
-{
-public:
-
-  typedef nsAdoptingString self_type;
-
-public:
-
-  explicit nsAdoptingString()
-  {
-  }
-  explicit nsAdoptingString(char_type* aStr,
-                                   size_type aLength = size_type(-1))
-  {
-    Adopt(aStr, aLength);
-  }
-
-
-
-
-
-  nsAdoptingString(const self_type& aStr)
-    : nsXPIDLString()
-  {
-    *this = aStr;
-  }
-
-
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-
-
-
-  self_type& operator=(const self_type& aStr);
-
-private:
-  self_type& operator=(const char_type* aData) = delete;
-  self_type& operator=(char_type* aData) = delete;
-};
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsCString : public nsACString
-{
-public:
-
-  typedef nsCString self_type;
-
-public:
-
-
-
-
-
-  nsCString()
-    : substring_type()
-  {
-  }
-
-  explicit
-  nsCString(const char_type* aData, size_type aLength = size_type(-1))
-    : substring_type()
-  {
-    Assign(aData, aLength);
-  }
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsCString(const self_type& aStr)
-    : substring_type()
-  {
-    Assign(aStr);
-  }
-
-               nsCString(const substring_tuple_type& aTuple)
-    : substring_type()
-  {
-    Assign(aTuple);
-  }
-
-  explicit
-  nsCString(const substring_type& aReadable)
-    : substring_type()
-  {
-    Assign(aReadable);
-  }
-
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  const char_type* get() const
-
-  {
-    return mData;
-  }
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  char_type CharAt(index_type aIndex) const
-  {
-    do { } while(0);
-    return mData[aIndex];
-  }
-
-  char_type operator[](index_type aIndex) const
-  {
-    return CharAt(aIndex);
-  }
-# 154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t Find(const nsCString& aString, bool aIgnoreCase = false,
-               int32_t aOffset = 0, int32_t aCount = -1) const;
-  int32_t Find(const char* aString, bool aIgnoreCase = false,
-               int32_t aOffset = 0, int32_t aCount = -1) const;
-# 186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFind(const nsCString& aString, bool aIgnoreCase = false,
-                int32_t aOffset = -1, int32_t aCount = -1) const;
-  int32_t RFind(const char* aCString, bool aIgnoreCase = false,
-                int32_t aOffset = -1, int32_t aCount = -1) const;
-# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFindChar(char16_t aChar, int32_t aOffset = -1,
-                    int32_t aCount = -1) const;
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t FindCharInSet(const char* aString, int32_t aOffset = 0) const;
-  int32_t FindCharInSet(const self_type& aString, int32_t aOffset = 0) const
-  {
-    return FindCharInSet(aString.get(), aOffset);
-  }
-# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t RFindCharInSet(const char_type* aString, int32_t aOffset = -1) const;
-  int32_t RFindCharInSet(const self_type& aString, int32_t aOffset = -1) const
-  {
-    return RFindCharInSet(aString.get(), aOffset);
-  }
-# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t Compare(const char* aString, bool aIgnoreCase = false,
-                  int32_t aCount = -1) const;
-# 276 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  bool EqualsIgnoreCase(const char* aString, int32_t aCount = -1) const
-  {
-    return Compare(aString, true, aCount) == 0;
-  }
-# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  double ToDouble(nsresult* aErrorCode) const;
-
-
-
-
-
-
-
-  float ToFloat(nsresult* aErrorCode) const
-  {
-    return (float)ToDouble(aErrorCode);
-  }
-# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  int32_t ToInteger(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
-
-
-
-
-
-
-
-  int64_t ToInteger64(nsresult* aErrorCode, uint32_t aRadix = (10)) const;
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  size_type Mid(self_type& aResult, uint32_t aStartPos, uint32_t aCount) const;
-
-  size_type Left(self_type& aResult, size_type aCount) const
-  {
-    return Mid(aResult, 0, aCount);
-  }
-
-  size_type Right(self_type& aResult, size_type aCount) const
-  {
-    aCount = XPCOM_MIN(mLength, aCount);
-    return Mid(aResult, mLength - aCount, aCount);
-  }
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  bool SetCharAt(char16_t aChar, uint32_t aIndex);
-# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void StripChars(const char* aSet);
-  bool StripChars(const char* aSet, const fallible_t&);
-
-
-
-
-
-  void StripWhitespace();
-  bool StripWhitespace(const fallible_t&);
-
-
-
-
-
-
-  void ReplaceChar(char_type aOldChar, char_type aNewChar);
-  void ReplaceChar(const char* aSet, char_type aNewChar);
-# 399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void ReplaceSubstring(const self_type& aTarget, const self_type& aNewValue);
-  void ReplaceSubstring(const char_type* aTarget, const char_type* aNewValue);
-  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const self_type& aTarget,
-                                     const self_type& aNewValue,
-                                     const fallible_t&);
-  __attribute__ ((warn_unused_result)) bool ReplaceSubstring(const char_type* aTarget,
-                                     const char_type* aNewValue,
-                                     const fallible_t&);
-# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void Trim(const char* aSet, bool aEliminateLeading = true,
-            bool aEliminateTrailing = true, bool aIgnoreQuotes = false);
-# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void CompressWhitespace(bool aEliminateLeading = true,
-                          bool aEliminateTrailing = true);
-
-
-
-
-
-
-  void AssignWithConversion(const nsAString& aString);
-  void AssignWithConversion(const incompatible_char_type* aData,
-                            int32_t aLength = -1);
-# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  void Rebind(const char_type* aData, size_type aLength);
-
-
-
-
-  void AssertValidDependentString()
-  {
-    do { } while(0);
-    do { } while(0);
-    do { } while(0);
-
-
-  }
-
-
-protected:
-
-
-  nsCString(char_type* aData, size_type aLength, uint32_t aFlags)
-    : substring_type(aData, aLength, aFlags)
-  {
-  }
-
-  struct Segment {
-    uint32_t mBegin, mLength;
-    Segment(uint32_t aBegin, uint32_t aLength)
-      : mBegin(aBegin)
-      , mLength(aLength)
-    {}
-  };
-};
-
-
-class nsFixedCString : public nsCString
-{
-public:
-
-  typedef nsFixedCString self_type;
-  typedef nsFixedCString fixed_string_type;
-
-public:
-# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsFixedCString(char_type* aData, size_type aStorageSize)
-    : string_type(aData, uint32_t(char_traits::length(aData)),
-                  F_TERMINATED | F_FIXED | F_CLASS_FIXED)
-    , mFixedCapacity(aStorageSize - 1)
-    , mFixedBuf(aData)
-  {
-  }
-
-  nsFixedCString(char_type* aData, size_type aStorageSize,
-                       size_type aLength)
-    : string_type(aData, aLength, F_TERMINATED | F_FIXED | F_CLASS_FIXED)
-    , mFixedCapacity(aStorageSize - 1)
-    , mFixedBuf(aData)
-  {
-
-    mFixedBuf[aLength] = char_type(0);
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-protected:
-
-  friend class nsACString;
-
-  size_type mFixedCapacity;
-  char_type* mFixedBuf;
-};
-# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsAutoCString : public nsFixedCString
-{
-public:
-
-  typedef nsAutoCString self_type;
-
-public:
-
-
-
-
-
-  nsAutoCString()
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-  }
-
-  explicit
-  nsAutoCString(char_type aChar)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aChar);
-  }
-
-  explicit
-  nsAutoCString(const char_type* aData, size_type aLength = size_type(-1))
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aData, aLength);
-  }
-# 601 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-  nsAutoCString(const self_type& aStr)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aStr);
-  }
-
-  explicit
-  nsAutoCString(const substring_type& aStr)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aStr);
-  }
-
-               nsAutoCString(const substring_tuple_type& aTuple)
-    : fixed_string_type(mStorage, kDefaultStorageSize, 0)
-  {
-    Assign(aTuple);
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aData)
-  {
-    Assign(aData);
-    return *this;
-  }
-
-
-
-
-
-
-
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-  enum
-  {
-    kDefaultStorageSize = 64
-  };
-
-private:
-
-  char_type mStorage[kDefaultStorageSize];
-};
-
-
-
-
-
-
-
-template<class E> class nsTArrayElementTraits;
-template<>
-class nsTArrayElementTraits<nsAutoCString>
-{
-public:
-  template<class A> struct Dont_Instantiate_nsTArray_of;
-  template<class A> struct Instead_Use_nsTArray_of;
-
-  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
-  Construct(Instead_Use_nsTArray_of<nsCString>* aE)
-  {
-    return 0;
-  }
-  template<class A>
-  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
-  Construct(Instead_Use_nsTArray_of<nsCString>* aE, const A& aArg)
-  {
-    return 0;
-  }
-  static Dont_Instantiate_nsTArray_of<nsAutoCString>*
-  Destruct(Instead_Use_nsTArray_of<nsCString>* aE)
-  {
-    return 0;
-  }
-};
-# 708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsXPIDLCString : public nsCString
-{
-public:
-
-  typedef nsXPIDLCString self_type;
-
-public:
-
-  nsXPIDLCString()
-    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
-  {
-  }
-
-
-  nsXPIDLCString(const self_type& aStr)
-    : string_type(char_traits::sEmptyBuffer, 0, F_TERMINATED | F_VOIDED)
-  {
-    Assign(aStr);
-  }
-
-
-
-
-
-  const char_type* get() const
-
-  {
-    return (mFlags & F_VOIDED) ? nullptr : mData;
-  }
-
-
-
-  operator const char_type*() const
-  {
-    return get();
-  }
-
-
-  char_type operator[](int32_t aIndex) const
-  {
-    return CharAt(index_type(aIndex));
-  }
-
-
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-  self_type& operator=(const char_type* aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const self_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-};
-# 792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsCGetterCopies
-{
-public:
-  typedef char char_type;
-
-  explicit nsCGetterCopies(nsACString& aStr)
-    : mString(aStr)
-    , mData(nullptr)
-  {
-  }
-
-  ~nsCGetterCopies()
-  {
-    mString.Adopt(mData);
-  }
-
-  operator char_type**()
-  {
-    return &mData;
-  }
-
-private:
-  nsACString& mString;
-  char_type* mData;
-};
-
-inline nsCGetterCopies
-getter_Copies(nsACString& aString)
-{
-  return nsCGetterCopies(aString);
-}
-# 833 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTString.h"
-class nsAdoptingCString : public nsXPIDLCString
-{
-public:
-
-  typedef nsAdoptingCString self_type;
-
-public:
-
-  explicit nsAdoptingCString()
-  {
-  }
-  explicit nsAdoptingCString(char_type* aStr,
-                                   size_type aLength = size_type(-1))
-  {
-    Adopt(aStr, aLength);
-  }
-
-
-
-
-
-  nsAdoptingCString(const self_type& aStr)
-    : nsXPIDLCString()
-  {
-    *this = aStr;
-  }
-
-
-  self_type& operator=(const substring_type& aStr)
-  {
-    Assign(aStr);
-    return *this;
-  }
-  self_type& operator=(const substring_tuple_type& aTuple)
-  {
-    Assign(aTuple);
-    return *this;
-  }
-
-
-
-
-  self_type& operator=(const self_type& aStr);
-
-private:
-  self_type& operator=(const char_type* aData) = delete;
-  self_type& operator=(char_type* aData) = delete;
-};
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-
-static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2");
-static_assert(sizeof(nsString::char_type) == 2,
-              "size of nsString::char_type must be 2");
-static_assert(nsString::char_type(-1) > nsString::char_type(0),
-              "nsString::char_type must be unsigned");
-static_assert(sizeof(nsCString::char_type) == 1,
-              "size of nsCString::char_type must be 1");
-
-
-
-
-
-class NS_LossyConvertUTF16toASCII : public nsAutoCString
-{
-public:
-  explicit NS_LossyConvertUTF16toASCII(const char16ptr_t aString)
-  {
-    LossyAppendUTF16toASCII(aString, *this);
-  }
-
-  NS_LossyConvertUTF16toASCII(const char16ptr_t aString, uint32_t aLength)
-  {
-    LossyAppendUTF16toASCII(Substring(aString, aLength), *this);
-  }
-
-  explicit NS_LossyConvertUTF16toASCII(const nsAString& aString)
-  {
-    LossyAppendUTF16toASCII(aString, *this);
-  }
-
-private:
-
-  NS_LossyConvertUTF16toASCII(char) = delete;
-};
-
-
-class NS_ConvertASCIItoUTF16 : public nsAutoString
-{
-public:
-  explicit NS_ConvertASCIItoUTF16(const char* aCString)
-  {
-    AppendASCIItoUTF16(aCString, *this);
-  }
-
-  NS_ConvertASCIItoUTF16(const char* aCString, uint32_t aLength)
-  {
-    AppendASCIItoUTF16(Substring(aCString, aLength), *this);
-  }
-
-  explicit NS_ConvertASCIItoUTF16(const nsACString& aCString)
-  {
-    AppendASCIItoUTF16(aCString, *this);
-  }
-
-private:
-
-  NS_ConvertASCIItoUTF16(char16_t) = delete;
-};
-
-
-
-
-
-class NS_ConvertUTF16toUTF8 : public nsAutoCString
-{
-public:
-  explicit NS_ConvertUTF16toUTF8(const char16ptr_t aString)
-  {
-    AppendUTF16toUTF8(aString, *this);
-  }
-
-  NS_ConvertUTF16toUTF8(const char16ptr_t aString, uint32_t aLength)
-  {
-    AppendUTF16toUTF8(Substring(aString, aLength), *this);
-  }
-
-  explicit NS_ConvertUTF16toUTF8(const nsAString& aString)
-  {
-    AppendUTF16toUTF8(aString, *this);
-  }
-
-private:
-
-  NS_ConvertUTF16toUTF8(char) = delete;
-};
-
-
-class NS_ConvertUTF8toUTF16 : public nsAutoString
-{
-public:
-  explicit NS_ConvertUTF8toUTF16(const char* aCString)
-  {
-    AppendUTF8toUTF16(aCString, *this);
-  }
-
-  NS_ConvertUTF8toUTF16(const char* aCString, uint32_t aLength)
-  {
-    AppendUTF8toUTF16(Substring(aCString, aLength), *this);
-  }
-
-  explicit NS_ConvertUTF8toUTF16(const nsACString& aCString)
-  {
-    AppendUTF8toUTF16(aCString, *this);
-  }
-
-private:
-
-  NS_ConvertUTF8toUTF16(char16_t) = delete;
-};
-# 180 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h"
-inline char16_t*
-wwc(char16_t* aStr)
-{
-  return aStr;
-}
-
-inline const char16_t*
-wwc(const char16_t* aStr)
-{
-  return aStr;
-}
-
-
-
-
-typedef nsAutoString nsVoidableString;
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-class nsDependentString : public nsString
-{
-public:
-
-  typedef nsDependentString self_type;
-
-public:
-
-
-
-
-
-  nsDependentString(const char_type* aStart, const char_type* aEnd);
-
-  nsDependentString(const char_type* aData, uint32_t aLength)
-    : string_type(const_cast<char_type*>(aData), aLength, F_TERMINATED)
-  {
-    AssertValidDependentString();
-  }
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  explicit
-  nsDependentString(const char_type* aData)
-    : string_type(const_cast<char_type*>(aData),
-                  uint32_t(char_traits::length(aData)), F_TERMINATED)
-  {
-    AssertValidDependentString();
-  }
-# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  nsDependentString(const string_type& aStr, uint32_t aStartPos)
-    : string_type()
-  {
-    Rebind(aStr, aStartPos);
-  }
-
-
-  nsDependentString()
-    : string_type()
-  {
-  }
-# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  using nsString::Rebind;
-  void Rebind(const char_type* aData)
-  {
-    Rebind(aData, uint32_t(char_traits::length(aData)));
-  }
-
-  void Rebind(const char_type* aStart, const char_type* aEnd);
-  void Rebind(const string_type&, uint32_t aStartPos);
-
-private:
-
-
-  nsDependentString(const substring_tuple_type&) = delete;
-};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-class nsDependentCString : public nsCString
-{
-public:
-
-  typedef nsDependentCString self_type;
-
-public:
-
-
-
-
-
-  nsDependentCString(const char_type* aStart, const char_type* aEnd);
-
-  nsDependentCString(const char_type* aData, uint32_t aLength)
-    : string_type(const_cast<char_type*>(aData), aLength, F_TERMINATED)
-  {
-    AssertValidDependentString();
-  }
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  explicit
-  nsDependentCString(const char_type* aData)
-    : string_type(const_cast<char_type*>(aData),
-                  uint32_t(char_traits::length(aData)), F_TERMINATED)
-  {
-    AssertValidDependentString();
-  }
-# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  nsDependentCString(const string_type& aStr, uint32_t aStartPos)
-    : string_type()
-  {
-    Rebind(aStr, aStartPos);
-  }
-
-
-  nsDependentCString()
-    : string_type()
-  {
-  }
-# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTDependentString.h"
-  using nsCString::Rebind;
-  void Rebind(const char_type* aData)
-  {
-    Rebind(aData, uint32_t(char_traits::length(aData)));
-  }
-
-  void Rebind(const char_type* aStart, const char_type* aEnd);
-  void Rebind(const string_type&, uint32_t aStartPos);
-
-private:
-
-
-  nsDependentCString(const substring_tuple_type&) = delete;
-};
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDependentString.h" 2
-# 198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
-class nsLiteralString : public mozilla::detail::nsStringRepr
-{
-public:
-
-  typedef nsLiteralString self_type;
-
-public:
-
-
-
-
-
-  template<size_type N>
-  explicit nsLiteralString(const char_type (&aStr)[N])
-    : base_string_type(const_cast<char_type*>(aStr), N - 1, F_TERMINATED | F_LITERAL)
-  {
-  }
-
-
-
-
-
-
-  const nsString& AsString() const
-  {
-    return *reinterpret_cast<const nsString*>(this);
-  }
-
-  operator const nsString&() const
-  {
-    return AsString();
-  }
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
-  const char_type* get() const && = delete;
-  const char_type* get() const &
-
-  {
-    return mData;
-  }
-
-private:
-
-
-  template<size_type N>
-  nsLiteralString(char_type (&aStr)[N]) = delete;
-
-  self_type& operator=(const self_type&) = delete;
-};
-
-static_assert(sizeof(nsLiteralString) == sizeof(nsString),
-              "nsTLiteralString_CharT can masquerade as nsTString_CharT, "
-              "so they must have identical layout");
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
-class nsLiteralCString : public mozilla::detail::nsCStringRepr
-{
-public:
-
-  typedef nsLiteralCString self_type;
-
-public:
-
-
-
-
-
-  template<size_type N>
-  explicit nsLiteralCString(const char_type (&aStr)[N])
-    : base_string_type(const_cast<char_type*>(aStr), N - 1, F_TERMINATED | F_LITERAL)
-  {
-  }
-
-
-
-
-
-
-  const nsCString& AsString() const
-  {
-    return *reinterpret_cast<const nsCString*>(this);
-  }
-
-  operator const nsCString&() const
-  {
-    return AsString();
-  }
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTLiteralString.h"
-  const char_type* get() const && = delete;
-  const char_type* get() const &
-
-  {
-    return mData;
-  }
-
-private:
-
-
-  template<size_type N>
-  nsLiteralCString(char_type (&aStr)[N]) = delete;
-
-  self_type& operator=(const self_type&) = delete;
-};
-
-static_assert(sizeof(nsLiteralCString) == sizeof(nsCString),
-              "nsTLiteralString_CharT can masquerade as nsTString_CharT, "
-              "so they must have identical layout");
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsLiteralString.h" 2
-# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-unichar.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h"
-class nsPromiseFlatString : public nsString
-{
-public:
-
-  typedef nsPromiseFlatString self_type;
-
-private:
-
-  void Init(const substring_type&);
-
-
-  void operator=(const self_type&) = delete;
-
-
-  nsPromiseFlatString() = delete;
-
-
-  nsPromiseFlatString(const string_type& aStr) = delete;
-
-public:
-
-  explicit
-  nsPromiseFlatString(const substring_type& aStr)
-    : string_type()
-  {
-    Init(aStr);
-  }
-
-  explicit
-  nsPromiseFlatString(const substring_tuple_type& aTuple)
-    : string_type()
-  {
-
-
-    Assign(aTuple);
-  }
-};
-
-
-
-template<class T>
-const nsPromiseFlatString
-PromiseFlatString(const T& aString)
-{
-  return nsPromiseFlatString(aString);
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-def-char.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h" 1
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTPromiseFlatString.h"
-class nsPromiseFlatCString : public nsCString
-{
-public:
-
-  typedef nsPromiseFlatCString self_type;
-
-private:
-
-  void Init(const substring_type&);
-
-
-  void operator=(const self_type&) = delete;
-
-
-  nsPromiseFlatCString() = delete;
-
-
-  nsPromiseFlatCString(const string_type& aStr) = delete;
-
-public:
-
-  explicit
-  nsPromiseFlatCString(const substring_type& aStr)
-    : string_type()
-  {
-    Init(aStr);
-  }
-
-  explicit
-  nsPromiseFlatCString(const substring_tuple_type& aTuple)
-    : string_type()
-  {
-
-
-    Assign(aTuple);
-  }
-};
-
-
-
-template<class T>
-const nsPromiseFlatCString
-PromiseFlatCString(const T& aString)
-{
-  return nsPromiseFlatCString(aString);
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/string-template-undef.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPromiseFlatString.h" 2
-# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
-class nsIMemory;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
-class nsMemory
-{
-public:
-  static nsresult HeapMinimize(bool aImmediate);
-  static void* Clone(const void* aPtr, size_t aSize);
-  static nsIMemory* GetGlobalMemoryService();
-};
-# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMemory.h"
-namespace mozilla {
-template<class T>
-struct AlignmentTestStruct
-{
-  char c;
-  T t;
-};
-}
-
-
-
-
-
-
-
-enum nsAssignmentType
-{
-  NS_ASSIGNMENT_COPY,
-  NS_ASSIGNMENT_DEPEND,
-  NS_ASSIGNMENT_ADOPT
-};
-# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plhash.h"
-extern "C" {
-
-typedef struct PLHashEntry PLHashEntry;
-typedef struct PLHashTable PLHashTable;
-typedef PRUint32 PLHashNumber;
-
-typedef PLHashNumber ( *PLHashFunction)(const void *key);
-typedef PRIntn ( *PLHashComparator)(const void *v1, const void *v2);
-
-typedef PRIntn ( *PLHashEnumerator)(PLHashEntry *he, PRIntn i, void *arg);
-
-
-
-
-
-
-
-typedef struct PLHashAllocOps {
-    void * ( *allocTable)(void *pool, PRSize size);
-    void ( *freeTable)(void *pool, void *item);
-    PLHashEntry * ( *allocEntry)(void *pool, const void *key);
-    void ( *freeEntry)(void *pool, PLHashEntry *he, PRUintn flag);
-} PLHashAllocOps;
-
-
-
-
-struct PLHashEntry {
-    PLHashEntry *next;
-    PLHashNumber keyHash;
-    const void *key;
-    void *value;
-};
-
-struct PLHashTable {
-    PLHashEntry **buckets;
-    PRUint32 nentries;
-    PRUint32 shift;
-    PLHashFunction keyHash;
-    PLHashComparator keyCompare;
-    PLHashComparator valueCompare;
-    const PLHashAllocOps *allocOps;
-    void *allocPriv;
-
-
-
-
-
-
-};
-
-
-
-
-
-extern __attribute__((visibility("default"))) PLHashTable *
-PL_NewHashTable(PRUint32 numBuckets, PLHashFunction keyHash,
-                PLHashComparator keyCompare, PLHashComparator valueCompare,
-                const PLHashAllocOps *allocOps, void *allocPriv);
-
-extern __attribute__((visibility("default"))) void
-PL_HashTableDestroy(PLHashTable *ht);
-
-
-extern __attribute__((visibility("default"))) PLHashEntry *
-PL_HashTableAdd(PLHashTable *ht, const void *key, void *value);
-
-extern __attribute__((visibility("default"))) PRBool
-PL_HashTableRemove(PLHashTable *ht, const void *key);
-
-extern __attribute__((visibility("default"))) void *
-PL_HashTableLookup(PLHashTable *ht, const void *key);
-
-extern __attribute__((visibility("default"))) void *
-PL_HashTableLookupConst(PLHashTable *ht, const void *key);
-
-extern __attribute__((visibility("default"))) PRIntn
-PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg);
-
-
-extern __attribute__((visibility("default"))) PLHashNumber
-PL_HashString(const void *key);
-
-
-extern __attribute__((visibility("default"))) PRIntn
-PL_CompareStrings(const void *v1, const void *v2);
-
-
-extern __attribute__((visibility("default"))) PRIntn
-PL_CompareValues(const void *v1, const void *v2);
-
-
-extern __attribute__((visibility("default"))) PLHashEntry **
-PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key);
-
-extern __attribute__((visibility("default"))) PLHashEntry **
-PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash,
-                           const void *key);
-
-extern __attribute__((visibility("default"))) PLHashEntry *
-PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep, PLHashNumber keyHash,
-                   const void *key, void *value);
-
-extern __attribute__((visibility("default"))) void
-PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he);
-
-
-extern __attribute__((visibility("default"))) PRIntn
-PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp);
-
-}
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsString.h" 2
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringGlue.h" 2
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h" 1
-# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-namespace mozilla {
-template<class T> class OwningNonNull;
-}
-
-template<class T>
-inline already_AddRefed<T>
-dont_AddRef(T* aRawPtr)
-{
-  return already_AddRefed<T>(aRawPtr);
-}
-
-template<class T>
-inline already_AddRefed<T>&&
-dont_AddRef(already_AddRefed<T>&& aAlreadyAddRefedPtr)
-{
-  return mozilla::Move(aAlreadyAddRefedPtr);
-}
-# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-class nsCOMPtr_helper
-{
-public:
-  virtual nsresult operator()(const nsIID&, void**) const = 0;
-};
-
-
-
-
-
-
-
-class nsQueryInterface final
-{
-public:
-  explicit
-  nsQueryInterface(nsISupports* aRawPtr) : mRawPtr(aRawPtr) {}
-
-  nsresult operator()(const nsIID& aIID, void**) const;
-
-private:
-  nsISupports* mRawPtr;
-};
-
-class nsQueryInterfaceWithError final
-{
-public:
-  nsQueryInterfaceWithError(nsISupports* aRawPtr, nsresult* aError)
-    : mRawPtr(aRawPtr)
-    , mErrorPtr(aError)
-  {
-  }
-
-  nsresult operator()(const nsIID& aIID, void**) const;
-
-private:
-  nsISupports* mRawPtr;
-  nsresult* mErrorPtr;
-};
-
-inline nsQueryInterface
-do_QueryInterface(nsISupports* aRawPtr)
-{
-  return nsQueryInterface(aRawPtr);
-}
-
-inline nsQueryInterfaceWithError
-do_QueryInterface(nsISupports* aRawPtr, nsresult* aError)
-{
-  return nsQueryInterfaceWithError(aRawPtr, aError);
-}
-
-template<class T>
-inline void
-do_QueryInterface(already_AddRefed<T>&)
-{
-
-
-
-}
-
-template<class T>
-inline void
-do_QueryInterface(already_AddRefed<T>&, nsresult*)
-{
-
-
-
-}
-
-
-
-
-class nsGetServiceByCID final
-{
-public:
-  explicit nsGetServiceByCID(const nsCID& aCID) : mCID(aCID) {}
-
-  nsresult operator()(const nsIID&, void**) const;
-
-private:
-  const nsCID& mCID;
-};
-
-class nsGetServiceByCIDWithError final
-{
-public:
-  nsGetServiceByCIDWithError(const nsCID& aCID, nsresult* aErrorPtr)
-    : mCID(aCID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  nsresult operator()(const nsIID&, void**) const;
-
-private:
-  const nsCID& mCID;
-  nsresult* mErrorPtr;
-};
-
-class nsGetServiceByContractID final
-{
-public:
-  explicit nsGetServiceByContractID(const char* aContractID)
-    : mContractID(aContractID)
-  {
-  }
-
-  nsresult operator()(const nsIID&, void**) const;
-
-private:
-  const char* mContractID;
-};
-
-class nsGetServiceByContractIDWithError final
-{
-public:
-  nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr)
-    : mContractID(aContractID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  nsresult operator()(const nsIID&, void**) const;
-
-private:
-  const char* mContractID;
-  nsresult* mErrorPtr;
-};
-# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-class nsCOMPtr_base
-{
-public:
-  explicit nsCOMPtr_base(nsISupports* aRawPtr = nullptr) : mRawPtr(aRawPtr) {}
-
-                          ~nsCOMPtr_base()
-  {
-                                    ;
-    if (mRawPtr) {
-      (mRawPtr)->Release();
-    }
-  }
-
-  void
-  assign_with_AddRef(nsISupports*);
-  void
-  assign_from_qi(const nsQueryInterface, const nsIID&);
-  void
-  assign_from_qi_with_error(const nsQueryInterfaceWithError&, const nsIID&);
-  void
-  assign_from_gs_cid(const nsGetServiceByCID, const nsIID&);
-  void
-  assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError&, const nsIID&);
-  void
-  assign_from_gs_contractid(const nsGetServiceByContractID, const nsIID&);
-  void
-  assign_from_gs_contractid_with_error(const nsGetServiceByContractIDWithError&,
-                                       const nsIID&);
-  void
-  assign_from_helper(const nsCOMPtr_helper&, const nsIID&);
-  void**
-  begin_assignment();
-
-protected:
-  nsISupports* __attribute__((__may_alias__)) mRawPtr;
-
-  void assign_assuming_AddRef(nsISupports* aNewPtr)
-  {
-
-
-
-
-
-
-    nsISupports* oldPtr = mRawPtr;
-    mRawPtr = aNewPtr;
-                                       ;
-                                   ;
-    if (oldPtr) {
-      (oldPtr)->Release();
-    }
-  }
-};
-
-
-
-
-template<class T>
-char (&TestForIID(decltype(&(T::template COMTypeInfo<T, void>::kIID))))[2];
-template<class T>
-char TestForIID(...);
-
-template<class T>
-class nsCOMPtr final
-
-  : private nsCOMPtr_base
-
-{
-# 387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-  void assert_validity()
-  {
-    static_assert(1 < sizeof(TestForIID<T>(nullptr)), "nsCOMPtr only works "
-                  "for types with IIDs.  Either use RefPtr; add an IID to "
-                  "your type with NS_DECLARE_STATIC_IID_ACCESSOR/"
-                  "NS_DEFINE_STATIC_IID_ACCESSOR; or make the nsCOMPtr point "
-                  "to a base class with an IID.");
-  }
-
-public:
-  typedef T element_type;
-# 426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-  nsCOMPtr()
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-  }
-
-               nsCOMPtr(decltype(nullptr))
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-  }
-
-  nsCOMPtr(const nsCOMPtr<T>& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.mRawPtr)
-  {
-    assert_validity();
-    if (mRawPtr) {
-      (mRawPtr)->AddRef();
-    }
-                                                 ;
-  }
-
-  nsCOMPtr(nsCOMPtr<T>&& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.mRawPtr)
-  {
-    assert_validity();
-    aSmartPtr.mRawPtr = nullptr;
-                                       ;
-                                  ;
-  }
-
-               nsCOMPtr(T* aRawPtr)
-    : nsCOMPtr_base(aRawPtr)
-  {
-    assert_validity();
-    if (mRawPtr) {
-      (mRawPtr)->AddRef();
-    }
-                                       ;
-                                  ;
-  }
-
-               nsCOMPtr(already_AddRefed<T>& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.take())
-  {
-    assert_validity();
-                                       ;
-                                  ;
-  }
-
-
-               nsCOMPtr(already_AddRefed<T>&& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.take())
-  {
-    assert_validity();
-                                       ;
-                                  ;
-  }
-
-
-  template<typename U>
-               nsCOMPtr(already_AddRefed<U>& aSmartPtr)
-    : nsCOMPtr_base(static_cast<T*>(aSmartPtr.take()))
-  {
-    assert_validity();
-
-    static_assert(mozilla::IsBaseOf<T, U>::value,
-                  "U is not a subclass of T");
-                                                        ;
-                                  ;
-  }
-
-
-  template<typename U>
-               nsCOMPtr(already_AddRefed<U>&& aSmartPtr)
-    : nsCOMPtr_base(static_cast<T*>(aSmartPtr.take()))
-  {
-    assert_validity();
-
-    static_assert(mozilla::IsBaseOf<T, U>::value,
-                  "U is not a subclass of T");
-                                                        ;
-                                  ;
-  }
-
-
-               nsCOMPtr(const nsQueryInterface aQI)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_qi(aQI, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsQueryInterfaceWithError& aQI)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_qi_with_error(aQI, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByCID aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_gs_cid(aGS, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_gs_cid_with_error(aGS, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByContractID aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_gs_contractid(aGS, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_gs_contractid_with_error(aGS, (T::template COMTypeInfo<T, void>::kIID));
-  }
-
-
-
-               nsCOMPtr(const nsCOMPtr_helper& aHelper)
-    : nsCOMPtr_base(nullptr)
-  {
-    assert_validity();
-                                       ;
-    assign_from_helper(aHelper, (T::template COMTypeInfo<T, void>::kIID));
-                                  ;
-  }
-
-
-  template<class U>
-               nsCOMPtr(const mozilla::OwningNonNull<U>& aOther);
-
-
-
-
-  nsCOMPtr<T>& operator=(const nsCOMPtr<T>& aRhs)
-  {
-    assign_with_AddRef(aRhs.mRawPtr);
-    return *this;
-  }
-
-  nsCOMPtr<T>& operator=(T* aRhs)
-  {
-    assign_with_AddRef(aRhs);
-                                  ;
-    return *this;
-  }
-
-  nsCOMPtr<T>& operator=(decltype(nullptr))
-  {
-    assign_assuming_AddRef(nullptr);
-    return *this;
-  }
-
-
-  template<typename U>
-  nsCOMPtr<T>& operator=(already_AddRefed<U>& aRhs)
-  {
-
-    static_assert(mozilla::IsBaseOf<T, U>::value,
-                  "U is not a subclass of T");
-    assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
-                                  ;
-    return *this;
-  }
-
-
-  template<typename U>
-  nsCOMPtr<T>& operator=(already_AddRefed<U>&& aRhs)
-  {
-
-    static_assert(mozilla::IsBaseOf<T, U>::value,
-                  "U is not a subclass of T");
-    assign_assuming_AddRef(static_cast<T*>(aRhs.take()));
-                                  ;
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsQueryInterface aRhs)
-  {
-    assign_from_qi(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsQueryInterfaceWithError& aRhs)
-  {
-    assign_from_qi_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsGetServiceByCID aRhs)
-  {
-    assign_from_gs_cid(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsGetServiceByCIDWithError& aRhs)
-  {
-    assign_from_gs_cid_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsGetServiceByContractID aRhs)
-  {
-    assign_from_gs_contractid(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<T>& operator=(const nsGetServiceByContractIDWithError& aRhs)
-  {
-    assign_from_gs_contractid_with_error(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-    return *this;
-  }
-
-
-
-  nsCOMPtr<T>& operator=(const nsCOMPtr_helper& aRhs)
-  {
-    assign_from_helper(aRhs, (T::template COMTypeInfo<T, void>::kIID));
-                                  ;
-    return *this;
-  }
-
-
-  template<class U>
-  nsCOMPtr<T>& operator=(const mozilla::OwningNonNull<U>& aOther);
-
-
-  void swap(nsCOMPtr<T>& aRhs)
-  {
-
-    nsISupports* temp = aRhs.mRawPtr;
-
-
-
-                                        ;
-                                    ;
-                                    ;
-                                  ;
-    aRhs.mRawPtr = mRawPtr;
-    mRawPtr = temp;
-
-  }
-
-
-  void swap(T*& aRhs)
-  {
-
-    nsISupports* temp = aRhs;
-
-
-
-                                    ;
-                                    ;
-    aRhs = reinterpret_cast<T*>(mRawPtr);
-    mRawPtr = temp;
-                                  ;
-  }
-
-
-
-
-
-
-  already_AddRefed<T> forget()
-  {
-    T* temp = nullptr;
-    swap(temp);
-    return already_AddRefed<T>(temp);
-  }
-
-
-
-
-  template<typename I>
-  void forget(I** aRhs)
-  {
-    do { } while(0);
-                                    ;
-    *aRhs = get();
-    mRawPtr = nullptr;
-  }
-
-
-
-
-  T* get() const { return reinterpret_cast<T*>(mRawPtr); }
-
-
-
-
-
-
-
-  operator T*() const & { return get(); }
-
-
-
-
-  operator T*() const && = delete;
-
-
-  explicit operator bool() const { return !!mRawPtr; }
-
-  T* operator->() const
-  {
-    do { } while (0);
-
-    return get();
-  }
-
-
-  nsCOMPtr<T>* get_address() { return this; }
-  const nsCOMPtr<T>* get_address() const { return this; }
-
-public:
-  T& operator*() const
-  {
-    do { } while (0);
-
-    return *get();
-  }
-
-  T** StartAssignment()
-  {
-
-    return reinterpret_cast<T**>(begin_assignment());
-
-
-
-
-  }
-};
-# 800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-template<>
-class nsCOMPtr<nsISupports>
-  : private nsCOMPtr_base
-{
-public:
-  typedef nsISupports element_type;
-
-
-
-  nsCOMPtr()
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-  }
-
-               nsCOMPtr(decltype(nullptr))
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-  }
-
-  nsCOMPtr(const nsCOMPtr<nsISupports>& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.mRawPtr)
-  {
-    if (mRawPtr) {
-      (mRawPtr)->AddRef();
-    }
-                                                 ;
-  }
-
-               nsCOMPtr(nsISupports* aRawPtr)
-    : nsCOMPtr_base(aRawPtr)
-  {
-    if (mRawPtr) {
-      (mRawPtr)->AddRef();
-    }
-                                       ;
-  }
-
-
-               nsCOMPtr(already_AddRefed<nsISupports>& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.take())
-  {
-                                       ;
-  }
-
-
-               nsCOMPtr(already_AddRefed<nsISupports>&& aSmartPtr)
-    : nsCOMPtr_base(aSmartPtr.take())
-  {
-                                       ;
-  }
-
-
-               nsCOMPtr(const nsQueryInterface aQI)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_qi(aQI, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsQueryInterfaceWithError& aQI)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_qi_with_error(aQI, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByCID aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_gs_cid(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_gs_cid_with_error(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByContractID aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_gs_contractid(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-               nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_gs_contractid_with_error(aGS, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-
-               nsCOMPtr(const nsCOMPtr_helper& aHelper)
-    : nsCOMPtr_base(nullptr)
-  {
-                                       ;
-    assign_from_helper(aHelper, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-  }
-
-
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsCOMPtr<nsISupports>& aRhs)
-  {
-    assign_with_AddRef(aRhs.mRawPtr);
-    return *this;
-  }
-
-  nsCOMPtr<nsISupports>& operator=(nsISupports* aRhs)
-  {
-    assign_with_AddRef(aRhs);
-    return *this;
-  }
-
-  nsCOMPtr<nsISupports>& operator=(decltype(nullptr))
-  {
-    assign_assuming_AddRef(nullptr);
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>& aRhs)
-  {
-    assign_assuming_AddRef(aRhs.take());
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(already_AddRefed<nsISupports>&& aRhs)
-  {
-    assign_assuming_AddRef(aRhs.take());
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsQueryInterface aRhs)
-  {
-    assign_from_qi(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsQueryInterfaceWithError& aRhs)
-  {
-    assign_from_qi_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCID aRhs)
-  {
-    assign_from_gs_cid(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByCIDWithError& aRhs)
-  {
-    assign_from_gs_cid_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractID aRhs)
-  {
-    assign_from_gs_contractid(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsGetServiceByContractIDWithError& aRhs)
-  {
-    assign_from_gs_contractid_with_error(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-
-  nsCOMPtr<nsISupports>& operator=(const nsCOMPtr_helper& aRhs)
-  {
-    assign_from_helper(aRhs, (nsISupports::COMTypeInfo<nsISupports, void>::kIID));
-    return *this;
-  }
-
-
-  void swap(nsCOMPtr<nsISupports>& aRhs)
-  {
-    nsISupports* temp = aRhs.mRawPtr;
-                                        ;
-                                    ;
-                                    ;
-                                  ;
-    aRhs.mRawPtr = mRawPtr;
-    mRawPtr = temp;
-  }
-
-
-  void swap(nsISupports*& aRhs)
-  {
-    nsISupports* temp = aRhs;
-                                    ;
-                                    ;
-    aRhs = mRawPtr;
-    mRawPtr = temp;
-  }
-
-
-
-  already_AddRefed<nsISupports> forget()
-  {
-    nsISupports* temp = nullptr;
-    swap(temp);
-    return already_AddRefed<nsISupports>(temp);
-  }
-
-
-
-
-  void forget(nsISupports** aRhs)
-  {
-    do { } while(0);
-    *aRhs = nullptr;
-    swap(*aRhs);
-  }
-
-
-
-
-
-
-  nsISupports* get() const { return reinterpret_cast<nsISupports*>(mRawPtr); }
-
-
-
-
-
-
-
-  operator nsISupports* () const { return get(); }
-
-  nsISupports* operator->() const
-  {
-    do { } while (0);
-
-    return get();
-  }
-
-
-  nsCOMPtr<nsISupports>* get_address() { return this; }
-  const nsCOMPtr<nsISupports>* get_address() const { return this; }
-
-public:
-
-  nsISupports& operator*() const
-  {
-    do { } while (0);
-
-    return *get();
-  }
-
-  nsISupports** StartAssignment()
-  {
-
-    return reinterpret_cast<nsISupports**>(begin_assignment());
-
-
-
-
-  }
-};
-
-template<typename T>
-inline void
-ImplCycleCollectionUnlink(nsCOMPtr<T>& aField)
-{
-  aField = nullptr;
-}
-
-template<typename T>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsCOMPtr<T>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
-}
-# 1206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-template<class T>
-inline nsCOMPtr<T>*
-address_of(nsCOMPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-
-template<class T>
-inline const nsCOMPtr<T>*
-address_of(const nsCOMPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-# 1235 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-template<class T>
-class nsGetterAddRefs
-{
-public:
-  explicit nsGetterAddRefs(nsCOMPtr<T>& aSmartPtr)
-    : mTargetSmartPtr(aSmartPtr)
-  {
-  }
-# 1258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-  operator void**()
-  {
-    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-  }
-
-  operator T**() { return mTargetSmartPtr.StartAssignment(); }
-  T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
-
-private:
-  nsCOMPtr<T>& mTargetSmartPtr;
-};
-
-
-template<>
-class nsGetterAddRefs<nsISupports>
-{
-public:
-  explicit nsGetterAddRefs(nsCOMPtr<nsISupports>& aSmartPtr)
-    : mTargetSmartPtr(aSmartPtr)
-  {
-  }
-# 1288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMPtr.h"
-  operator void**()
-  {
-    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-  }
-
-  operator nsISupports**() { return mTargetSmartPtr.StartAssignment(); }
-  nsISupports*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
-
-private:
-  nsCOMPtr<nsISupports>& mTargetSmartPtr;
-};
-
-template<class T>
-inline nsGetterAddRefs<T>
-getter_AddRefs(nsCOMPtr<T>& aSmartPtr)
-{
-  return nsGetterAddRefs<T>(aSmartPtr);
-}
-
-template<class T, class DestinationType>
-inline nsresult
-CallQueryInterface(T* aSource, nsGetterAddRefs<DestinationType> aDestination)
-{
-  return CallQueryInterface(aSource,
-                            static_cast<DestinationType**>(aDestination));
-}
-
-
-
-
-template<class T, class U>
-inline bool
-operator==(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
-}
-
-
-template<class T, class U>
-inline bool
-operator!=(const nsCOMPtr<T>& aLhs, const nsCOMPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
-}
-
-
-
-
-template<class T, class U>
-inline bool
-operator==(const nsCOMPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == aRhs;
-}
-
-template<class T, class U>
-inline bool
-operator==(const U* aLhs, const nsCOMPtr<T>& aRhs)
-{
-  return aLhs == static_cast<const T*>(aRhs.get());
-}
-
-template<class T, class U>
-inline bool
-operator!=(const nsCOMPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != aRhs;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const U* aLhs, const nsCOMPtr<T>& aRhs)
-{
-  return aLhs != static_cast<const T*>(aRhs.get());
-}
-
-template<class T, class U>
-inline bool
-operator==(const nsCOMPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
-}
-
-template<class T, class U>
-inline bool
-operator==(U* aLhs, const nsCOMPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
-}
-
-template<class T, class U>
-inline bool
-operator!=(const nsCOMPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
-}
-
-template<class T, class U>
-inline bool
-operator!=(U* aLhs, const nsCOMPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
-}
-
-
-
-
-
-template<class T>
-inline bool
-operator==(const nsCOMPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() == nullptr;
-}
-
-template<class T>
-inline bool
-operator==(decltype(nullptr), const nsCOMPtr<T>& aRhs)
-{
-  return nullptr == aRhs.get();
-}
-
-template<class T>
-inline bool
-operator!=(const nsCOMPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() != nullptr;
-}
-
-template<class T>
-inline bool
-operator!=(decltype(nullptr), const nsCOMPtr<T>& aRhs)
-{
-  return nullptr != aRhs.get();
-}
-
-
-
-
-inline bool
-SameCOMIdentity(nsISupports* aLhs, nsISupports* aRhs)
-{
-  return nsCOMPtr<nsISupports>(do_QueryInterface(aLhs)) ==
-    nsCOMPtr<nsISupports>(do_QueryInterface(aRhs));
-}
-
-
-
-template<class SourceType, class DestinationType>
-inline nsresult
-CallQueryInterface(nsCOMPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr)
-{
-  return CallQueryInterface(aSourcePtr.get(), aDestPtr);
-}
-
-template <class T>
-RefPtr<T>::RefPtr(const nsCOMPtr_helper& aHelper)
-{
-  void* newRawPtr;
-  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo<T, void>::kIID), &newRawPtr))), 0)))) {
-    newRawPtr = nullptr;
-  }
-  mRawPtr = static_cast<T*>(newRawPtr);
-}
-
-template <class T>
-RefPtr<T>&
-RefPtr<T>::operator=(const nsCOMPtr_helper& aHelper)
-{
-  void* newRawPtr;
-  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(aHelper((T::template COMTypeInfo<T, void>::kIID), &newRawPtr))), 0)))) {
-    newRawPtr = nullptr;
-  }
-  assign_assuming_AddRef(static_cast<T*>(newRawPtr));
-  return *this;
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-template<class T> struct already_AddRefed;
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-class nsStringBuffer
-{
-private:
-  friend class CheckStaticAtomSizes;
-
-  std::atomic<uint32_t> mRefCount;
-  uint32_t mStorageSize;
-
-public:
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  static already_AddRefed<nsStringBuffer> Alloc(size_t aStorageSize);
-# 61 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  static nsStringBuffer* Realloc(nsStringBuffer* aBuf, size_t aStorageSize);
-
-
-
-
-  void AddRef();
-
-
-
-
-
-  void Release();
-
-
-
-
-
-
-  static nsStringBuffer* FromData(void* aData)
-  {
-    return reinterpret_cast<nsStringBuffer*>(aData) - 1;
-  }
-
-
-
-
-  void* Data() const
-  {
-    return const_cast<char*>(reinterpret_cast<const char*>(this + 1));
-  }
-
-
-
-
-
-
-  uint32_t StorageSize() const
-  {
-    return mStorageSize;
-  }
-# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  bool IsReadonly() const
-  {
-# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-    return mRefCount.load(std::memory_order_relaxed) > 1;
-  }
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  static nsStringBuffer* FromString(const nsAString& aStr);
-  static nsStringBuffer* FromString(const nsACString& aStr);
-# 160 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  void ToString(uint32_t aLen, nsAString& aStr, bool aMoveOwnership = false);
-  void ToString(uint32_t aLen, nsACString& aStr, bool aMoveOwnership = false);
-
-
-
-
-  size_t SizeOfIncludingThisIfUnshared(mozilla::MallocSizeOf aMallocSizeOf) const;
-# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStringBuffer.h"
-  size_t SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSizeOf) const;
-};
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h" 2
-
-
-
-
-
-
-
-
-class nsIAtom : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult ScriptableToString(nsAString & _retval) = 0;
-
-
-  virtual nsresult ToUTF8String(nsACString & _retval) = 0;
-
-
-  virtual nsresult ScriptableEquals(const nsAString & aString, bool *_retval) = 0;
-
-
-  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) = 0;
-
-
-  inline bool Equals(char16ptr_t aString, uint32_t aLength) const
-  {
-    return mLength == aLength &&
-           memcmp(mString, aString, mLength * sizeof(char16_t)) == 0;
-  }
-  inline bool Equals(const nsAString& aString) const {
-    return Equals(aString.BeginReading(), aString.Length());
-  }
-  inline bool IsStaticAtom() const {
-    return mIsStatic;
-  }
-  inline char16ptr_t GetUTF16String() const {
-    return mString;
-  }
-  inline uint32_t GetLength() const {
-    return mLength;
-  }
-  inline void ToString(nsAString& aBuf) const {
-
-    nsStringBuffer::FromData(mString)->ToString(mLength, aBuf);
-  }
-  inline nsStringBuffer* GetStringBuffer() const {
-
-    return nsStringBuffer::FromData(mString);
-  }
-
-
-
-
-
-  inline uint32_t hash() const {
-    return mHash;
-  }
-protected:
-  uint32_t mLength:31;
-  uint32_t mIsStatic:1;
-  uint32_t mHash;
-
-
-
-
-
-  char16_t* mString;
-};
-
-  template<typename T> struct nsIAtom::COMTypeInfo<nsIAtom, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAtom::COMTypeInfo<nsIAtom, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8b8c11d4, 0x3ed5, 0x4079, { 0x89, 0x74, 0x73, 0xc7, 0x57, 0x6c, 0xdb, 0x34 }};
-# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAtom.h"
-extern already_AddRefed<nsIAtom> NS_Atomize(const char* aUTF8String);
-
-
-
-extern already_AddRefed<nsIAtom> NS_Atomize(const nsACString& aUTF8String);
-
-
-
-
-extern already_AddRefed<nsIAtom> NS_Atomize(const char16_t* aUTF16String);
-
-
-
-extern already_AddRefed<nsIAtom> NS_Atomize(const nsAString& aUTF16String);
-
-
-
-extern already_AddRefed<nsIAtom> NS_AtomizeMainThread(const nsAString& aUTF16String);
-
-
-
-
-extern nsrefcnt NS_GetNumberOfAtoms(void);
-
-
-
-
-extern nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
-
-
-
-extern void NS_SealStaticAtomTable();
-class nsAtomString : public nsString
-{
-public:
-  explicit nsAtomString(const nsIAtom* aAtom)
-  {
-    aAtom->ToString(*this);
-  }
-};
-class nsAtomCString : public nsCString
-{
-public:
-  explicit nsAtomCString(nsIAtom* aAtom)
-  {
-    aAtom->ToUTF8String(*this);
-  }
-};
-class nsDependentAtomString : public nsDependentString
-{
-public:
-  explicit nsDependentAtomString(const nsIAtom* aAtom)
-    : nsDependentString(aAtom->GetUTF16String(), aAtom->GetLength())
-  {
-  }
-};
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h" 2
-
-class nsIDocument;
-class nsNodeInfoManager;
-
-namespace mozilla {
-namespace dom {
-
-class NodeInfo final
-{
-public:
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<NodeInfo>::value, "Reference-counted class " "NodeInfo" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsCycleCollectionParticipant { public: constexpr cycleCollection () : nsCycleCollectionParticipant(true) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "NodeInfo"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<NodeInfo>(n)->DeleteCycleCollectable(); } static NodeInfo* Downcast(void* s) { return DowncastCCParticipant<NodeInfo>(s); } static void* Upcast(NodeInfo *p) { return static_cast<void*>(p); } virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static nsCycleCollectionParticipant* GetParticipant() { return &NodeInfo::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-
-
-
-
-
-  void GetName(nsAString& aName) const;
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
-  nsIAtom* NameAtom() const
-  {
-    return mInner.mName;
-  }
-# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
-  const nsString& QualifiedName() const {
-    return mQualifiedName;
-  }
-
-
-
-
-  const nsString& NodeName() const {
-    return mNodeName;
-  }
-
-
-
-
-  const nsString& LocalName() const {
-    return mLocalName;
-  }
-
-
-
-
-
-
-
-  void GetPrefix(nsAString& aPrefix) const;
-
-
-
-
-
-
-
-  nsIAtom* GetPrefixAtom() const
-  {
-    return mInner.mPrefix;
-  }
-
-
-
-
-  void GetNamespaceURI(nsAString& aNameSpaceURI) const;
-
-
-
-
-
-  int32_t NamespaceID() const
-  {
-    return mInner.mNamespaceID;
-  }
-
-
-
-
-
-  uint16_t NodeType() const
-  {
-    return mInner.mNodeType;
-  }
-
-
-
-
-  nsIAtom* GetExtraName() const
-  {
-    return mInner.mExtraName;
-  }
-
-
-
-
-
-  nsNodeInfoManager* NodeInfoManager() const
-  {
-    return mOwnerManager;
-  }
-
-
-
-
-
-
-  inline bool Equals(NodeInfo* aNodeInfo) const;
-
-  bool NameAndNamespaceEquals(NodeInfo* aNodeInfo) const;
-
-  bool Equals(nsIAtom* aNameAtom) const
-  {
-    return mInner.mName == aNameAtom;
-  }
-
-  bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom) const
-  {
-    return (mInner.mName == aNameAtom) && (mInner.mPrefix == aPrefixAtom);
-  }
-
-  bool Equals(nsIAtom* aNameAtom, int32_t aNamespaceID) const
-  {
-    return ((mInner.mName == aNameAtom) &&
-            (mInner.mNamespaceID == aNamespaceID));
-  }
-
-  bool Equals(nsIAtom* aNameAtom, nsIAtom* aPrefixAtom, int32_t aNamespaceID) const
-  {
-    return ((mInner.mName == aNameAtom) &&
-            (mInner.mPrefix == aPrefixAtom) &&
-            (mInner.mNamespaceID == aNamespaceID));
-  }
-
-  bool NamespaceEquals(int32_t aNamespaceID) const
-  {
-    return mInner.mNamespaceID == aNamespaceID;
-  }
-
-  inline bool Equals(const nsAString& aName) const;
-
-  inline bool Equals(const nsAString& aName, const nsAString& aPrefix) const;
-
-  inline bool Equals(const nsAString& aName, int32_t aNamespaceID) const;
-
-  inline bool Equals(const nsAString& aName, const nsAString& aPrefix, int32_t aNamespaceID) const;
-
-  bool NamespaceEquals(const nsAString& aNamespaceURI) const;
-
-  inline bool QualifiedNameEquals(nsIAtom* aNameAtom) const;
-
-  bool QualifiedNameEquals(const nsAString& aQualifiedName) const
-  {
-    return mQualifiedName == aQualifiedName;
-  }
-
-
-
-
-  nsIDocument* GetDocument() const
-  {
-    return mDocument;
-  }
-
-private:
-  NodeInfo() = delete;
-  NodeInfo(const NodeInfo& aOther) = delete;
-
-
-
-  NodeInfo(nsIAtom* aName, nsIAtom* aPrefix, int32_t aNamespaceID,
-           uint16_t aNodeType, nsIAtom* aExtraName,
-           nsNodeInfoManager* aOwnerManager);
-
-  ~NodeInfo();
-
-public:
-  bool CanSkip();
-
-
-
-
-
-  void DeleteCycleCollectable();
-
-protected:
-# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NodeInfo.h"
-  class NodeInfoInner
-  {
-  public:
-    NodeInfoInner()
-      : mName(nullptr), mPrefix(nullptr), mNamespaceID(-1),
-        mNodeType(0), mNameString(nullptr), mExtraName(nullptr)
-    {
-    }
-    NodeInfoInner(nsIAtom *aName, nsIAtom *aPrefix, int32_t aNamespaceID,
-                    uint16_t aNodeType, nsIAtom* aExtraName)
-      : mName(aName), mPrefix(aPrefix), mNamespaceID(aNamespaceID),
-        mNodeType(aNodeType), mNameString(nullptr), mExtraName(aExtraName)
-    {
-    }
-    NodeInfoInner(const nsAString& aTmpName, nsIAtom *aPrefix,
-                    int32_t aNamespaceID, uint16_t aNodeType)
-      : mName(nullptr), mPrefix(aPrefix), mNamespaceID(aNamespaceID),
-        mNodeType(aNodeType), mNameString(&aTmpName), mExtraName(nullptr)
-    {
-    }
-
-    nsCOMPtr<nsIAtom> mName;
-    nsCOMPtr<nsIAtom> mPrefix;
-    int32_t mNamespaceID;
-    uint16_t mNodeType;
-    const nsAString* mNameString;
-    nsCOMPtr<nsIAtom> mExtraName;
-  };
-
-
-  friend class ::nsNodeInfoManager;
-
-
-
-  nsIDocument* mDocument;
-
-  NodeInfoInner mInner;
-
-  RefPtr<nsNodeInfoManager> mOwnerManager;
-
-
-
-
-
-
-
-  nsString mQualifiedName;
-
-
-  nsString mNodeName;
-
-
-
-  nsString mLocalName;
-};
-
-}
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMString.h"
-inline bool DOMStringIsNull(const nsAString& aString)
-{
-  return aString.IsVoid();
-}
-
-inline void SetDOMStringToNull(nsAString& aString)
-{
-  aString.SetIsVoid(true);
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrName.h" 2
-
-
-class nsAttrName
-{
-public:
-  nsAttrName(const nsAttrName& aOther)
-    : mBits(aOther.mBits)
-  {
-    AddRefInternalName();
-  }
-
-  explicit nsAttrName(nsIAtom* aAtom)
-    : mBits(reinterpret_cast<uintptr_t>(aAtom))
-  {
-    do { } while(0);
-    (aAtom)->AddRef();
-  }
-
-  explicit nsAttrName(mozilla::dom::NodeInfo* aNodeInfo)
-  {
-    do { } while(0);
-    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
-      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
-      (aNodeInfo->NameAtom())->AddRef();
-    }
-    else {
-      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
-              1;
-      (aNodeInfo)->AddRef();
-    }
-  }
-
-  ~nsAttrName()
-  {
-    ReleaseInternalName();
-  }
-
-  void SetTo(mozilla::dom::NodeInfo* aNodeInfo)
-  {
-    do { } while(0);
-
-    ReleaseInternalName();
-    if (aNodeInfo->NamespaceEquals(kNameSpaceID_None)) {
-      mBits = reinterpret_cast<uintptr_t>(aNodeInfo->NameAtom());
-      (aNodeInfo->NameAtom())->AddRef();
-    }
-    else {
-      mBits = reinterpret_cast<uintptr_t>(aNodeInfo) |
-              1;
-      (aNodeInfo)->AddRef();
-    }
-  }
-
-  void SetTo(nsIAtom* aAtom)
-  {
-    do { } while(0);
-
-    ReleaseInternalName();
-    mBits = reinterpret_cast<uintptr_t>(aAtom);
-    (aAtom)->AddRef();
-  }
-
-  bool IsAtom() const
-  {
-    return !(mBits & 1);
-  }
-
-  mozilla::dom::NodeInfo* NodeInfo() const
-  {
-    do { } while(0);
-    return reinterpret_cast<mozilla::dom::NodeInfo*>(mBits & ~1);
-  }
-
-  nsIAtom* Atom() const
-  {
-    do { } while(0);
-    return reinterpret_cast<nsIAtom*>(mBits);
-  }
-
-  bool Equals(const nsAttrName& aOther) const
-  {
-    return mBits == aOther.mBits;
-  }
-
-
-  bool Equals(nsIAtom* aAtom) const
-  {
-    return reinterpret_cast<uintptr_t>(aAtom) == mBits;
-  }
-
-
-  bool Equals(const nsAString& aLocalName) const
-  {
-    return IsAtom() && Atom()->Equals(aLocalName);
-  }
-
-  bool Equals(nsIAtom* aLocalName, int32_t aNamespaceID) const
-  {
-    if (aNamespaceID == kNameSpaceID_None) {
-      return Equals(aLocalName);
-    }
-    return !IsAtom() && NodeInfo()->Equals(aLocalName, aNamespaceID);
-  }
-
-  bool Equals(mozilla::dom::NodeInfo* aNodeInfo) const
-  {
-    return Equals(aNodeInfo->NameAtom(), aNodeInfo->NamespaceID());
-  }
-
-  int32_t NamespaceID() const
-  {
-    return IsAtom() ? kNameSpaceID_None : NodeInfo()->NamespaceID();
-  }
-
-  int32_t NamespaceEquals(int32_t aNamespaceID) const
-  {
-    return aNamespaceID == kNameSpaceID_None ?
-           IsAtom() :
-           (!IsAtom() && NodeInfo()->NamespaceEquals(aNamespaceID));
-  }
-
-  nsIAtom* LocalName() const
-  {
-    return IsAtom() ? Atom() : NodeInfo()->NameAtom();
-  }
-
-  nsIAtom* GetPrefix() const
-  {
-    return IsAtom() ? nullptr : NodeInfo()->GetPrefixAtom();
-  }
-
-  bool QualifiedNameEquals(const nsAString& aName) const
-  {
-    return IsAtom() ? Atom()->Equals(aName) :
-                      NodeInfo()->QualifiedNameEquals(aName);
-  }
-
-  void GetQualifiedName(nsAString& aStr) const
-  {
-    if (IsAtom()) {
-      Atom()->ToString(aStr);
-    }
-    else {
-      aStr = NodeInfo()->QualifiedName();
-    }
-  }
-
-
-  void GetPrefix(nsAString& aStr) const
-  {
-    if (IsAtom()) {
-      SetDOMStringToNull(aStr);
-    }
-    else {
-      NodeInfo()->GetPrefix(aStr);
-    }
-  }
-
-
-  uint32_t HashValue() const
-  {
-
-
-
-    return mBits - 0;
-  }
-
-  bool IsSmaller(nsIAtom* aOther) const
-  {
-    return mBits < reinterpret_cast<uintptr_t>(aOther);
-  }
-
-private:
-
-  void AddRefInternalName()
-  {
-    if (IsAtom()) {
-      (Atom())->AddRef();
-    } else {
-      (NodeInfo())->AddRef();
-    }
-  }
-
-  void ReleaseInternalName()
-  {
-    if (IsAtom()) {
-      Atom()->Release();
-    } else {
-      NodeInfo()->Release();
-    }
-  }
-
-  uintptr_t mBits;
-};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 1
-
-
-
-
-
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/float.h" 1 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h" 2
-
-
-
-
-
-
-
-
-inline double
-NS_round(double aNum)
-{
-  return aNum >= 0.0 ? floor(aNum + 0.5) : ceil(aNum - 0.5);
-}
-inline float
-NS_roundf(float aNum)
-{
-  return aNum >= 0.0f ? floorf(aNum + 0.5f) : ceilf(aNum - 0.5f);
-}
-inline int32_t
-NS_lround(double aNum)
-{
-  return aNum >= 0.0 ? int32_t(aNum + 0.5) : int32_t(aNum - 0.5);
-}
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
-inline int32_t
-NS_lroundf(float aNum)
-{
-  return aNum >= 0.0f ? int32_t(aNum + 0.5f) : int32_t(aNum - 0.5f);
-}
-
-
-
-
-
-
-inline double
-NS_hypot(double aNum1, double aNum2)
-{
-
-  return __builtin_hypot(aNum1, aNum2);
-
-
-
-
-
-}
-
-
-
-
-
-inline bool
-NS_finite(double aNum)
-{
-# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMathUtils.h"
-  return finite(aNum);
-
-}
-
-
-
-
-
-
-
-inline double
-NS_floorModulo(double aNum1, double aNum2)
-{
-  return (aNum1 - aNum2 * floor(aNum1 / aNum2));
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
-# 36 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 2 3
-
-using std::abs;
-using std::acos;
-using std::asin;
-using std::atan;
-using std::atan2;
-using std::cos;
-using std::sin;
-using std::tan;
-using std::cosh;
-using std::sinh;
-using std::tanh;
-using std::exp;
-using std::frexp;
-using std::ldexp;
-using std::log;
-using std::log10;
-using std::modf;
-using std::pow;
-using std::sqrt;
-using std::ceil;
-using std::fabs;
-using std::floor;
-using std::fmod;
-
-
-using std::fpclassify;
-using std::isfinite;
-using std::isinf;
-using std::isnan;
-using std::isnormal;
-using std::signbit;
-using std::isgreater;
-using std::isgreaterequal;
-using std::isless;
-using std::islessequal;
-using std::islessgreater;
-using std::isunordered;
-
-
-
-using std::acosh;
-using std::asinh;
-using std::atanh;
-using std::cbrt;
-using std::copysign;
-using std::erf;
-using std::erfc;
-using std::exp2;
-using std::expm1;
-using std::fdim;
-using std::fma;
-using std::fmax;
-using std::fmin;
-using std::hypot;
-using std::ilogb;
-using std::lgamma;
-using std::llrint;
-using std::llround;
-using std::log1p;
-using std::log2;
-using std::logb;
-using std::lrint;
-using std::lround;
-using std::nearbyint;
-using std::nextafter;
-using std::nexttoward;
-using std::remainder;
-using std::remquo;
-using std::rint;
-using std::round;
-using std::scalbln;
-using std::scalbn;
-using std::tgamma;
-using std::trunc;
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h" 2
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
-inline float NS_IEEEPositiveInfinity() {
-  union { uint32_t mPRUint32; float mFloat; } pun;
-  pun.mPRUint32 = 0x7F800000;
-  return pun.mFloat;
-}
-inline bool NS_IEEEIsNan(float aF) {
-  union { uint32_t mBits; float mFloat; } pun;
-  pun.mFloat = aF;
-  return (pun.mBits & 0x7F800000) == 0x7F800000 &&
-    (pun.mBits & 0x007FFFFF) != 0;
-}
-
-
-
-
-
-typedef int32_t nscoord;
-
-
-
-
-
-inline void VERIFY_COORD(nscoord aCoord) {
-
-
-
-
-}
-
-
-
-
-
-inline nscoord NSCoordDivRem(nscoord aSpace, size_t aN, nscoord* aQuotient)
-{
-
-
-
-
-  div_t result = div(aSpace, aN);
-  *aQuotient = nscoord(result.quot);
-  return nscoord(result.rem);
-
-}
-
-inline nscoord NSCoordMulDiv(nscoord aMult1, nscoord aMult2, nscoord aDiv) {
-
-
-
-  return (int64_t(aMult1) * int64_t(aMult2) / int64_t(aDiv));
-
-}
-
-inline nscoord NSToCoordRound(float aValue)
-{
-
-
-
-  return nscoord(floorf(aValue + 0.5f));
-
-}
-
-inline nscoord NSToCoordRound(double aValue)
-{
-
-
-
-  return nscoord(floor(aValue + 0.5f));
-
-}
-
-inline nscoord NSToCoordRoundWithClamp(float aValue)
-{
-
-
-  if (aValue >= nscoord(1 << 30)) {
-    return nscoord(1 << 30);
-  }
-  if (aValue <= (-nscoord(1 << 30))) {
-    return (-nscoord(1 << 30));
-  }
-
-  return NSToCoordRound(aValue);
-}
-
-
-
-
-
-
-
-inline nscoord _nscoordSaturatingMultiply(nscoord aCoord, float aScale,
-                                          bool requireNotNegative) {
-  VERIFY_COORD(aCoord);
-  if (requireNotNegative) {
-    do { } while (0);
-
-  }
-
-
-
-  float product = aCoord * aScale;
-  if (requireNotNegative ? aCoord > 0 : (aCoord > 0) == (aScale > 0))
-    return NSToCoordRoundWithClamp(std::min<float>(nscoord(1 << 30), product));
-  return NSToCoordRoundWithClamp(std::max<float>((-nscoord(1 << 30)), product));
-
-}
-
-
-
-
-
-
-
-inline nscoord NSCoordSaturatingNonnegativeMultiply(nscoord aCoord, float aScale) {
-  return _nscoordSaturatingMultiply(aCoord, aScale, true);
-}
-
-
-
-
-
-inline nscoord NSCoordSaturatingMultiply(nscoord aCoord, float aScale) {
-  return _nscoordSaturatingMultiply(aCoord, aScale, false);
-}
-# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
-inline nscoord
-NSCoordSaturatingAdd(nscoord a, nscoord b)
-{
-  VERIFY_COORD(a);
-  VERIFY_COORD(b);
-
-
-
-
-
-  if (a == nscoord(1 << 30) || b == nscoord(1 << 30)) {
-
-    return nscoord(1 << 30);
-  } else {
-
-
-    return std::min(nscoord(1 << 30), a + b);
-  }
-
-}
-# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
-inline nscoord
-NSCoordSaturatingSubtract(nscoord a, nscoord b,
-                          nscoord infMinusInfResult)
-{
-  VERIFY_COORD(a);
-  VERIFY_COORD(b);
-
-  if (b == nscoord(1 << 30)) {
-    if (a == nscoord(1 << 30)) {
-
-      return infMinusInfResult;
-    } else {
-
-      do { } while(0);
-      return 0;
-    }
-  } else {
-
-
-
-
-    if (a == nscoord(1 << 30)) {
-
-      return nscoord(1 << 30);
-    } else {
-
-
-      return std::min(nscoord(1 << 30), a - b);
-    }
-
-  }
-}
-
-inline float NSCoordToFloat(nscoord aCoord) {
-  VERIFY_COORD(aCoord);
-
-
-
-  return (float)aCoord;
-}
-
-
-
-
-inline nscoord NSToCoordFloor(float aValue)
-{
-  return nscoord(floorf(aValue));
-}
-
-inline nscoord NSToCoordFloor(double aValue)
-{
-  return nscoord(floor(aValue));
-}
-
-inline nscoord NSToCoordFloorClamped(float aValue)
-{
-
-
-  if (aValue >= nscoord(1 << 30)) {
-    return nscoord(1 << 30);
-  }
-  if (aValue <= (-nscoord(1 << 30))) {
-    return (-nscoord(1 << 30));
-  }
-
-  return NSToCoordFloor(aValue);
-}
-
-inline nscoord NSToCoordCeil(float aValue)
-{
-  return nscoord(ceilf(aValue));
-}
-
-inline nscoord NSToCoordCeil(double aValue)
-{
-  return nscoord(ceil(aValue));
-}
-
-inline nscoord NSToCoordCeilClamped(double aValue)
-{
-
-
-  if (aValue >= nscoord(1 << 30)) {
-    return nscoord(1 << 30);
-  }
-  if (aValue <= (-nscoord(1 << 30))) {
-    return (-nscoord(1 << 30));
-  }
-
-  return NSToCoordCeil(aValue);
-}
-
-
-
-
-
-inline nscoord NSToCoordTrunc(float aValue)
-{
-
-
-  return nscoord(aValue);
-}
-
-inline nscoord NSToCoordTrunc(double aValue)
-{
-
-
-  return nscoord(aValue);
-}
-
-inline nscoord NSToCoordTruncClamped(float aValue)
-{
-
-
-  if (aValue >= nscoord(1 << 30)) {
-    return nscoord(1 << 30);
-  }
-  if (aValue <= (-nscoord(1 << 30))) {
-    return (-nscoord(1 << 30));
-  }
-
-  return NSToCoordTrunc(aValue);
-}
-
-inline nscoord NSToCoordTruncClamped(double aValue)
-{
-
-
-  if (aValue >= nscoord(1 << 30)) {
-    return nscoord(1 << 30);
-  }
-  if (aValue <= (-nscoord(1 << 30))) {
-    return (-nscoord(1 << 30));
-  }
-
-  return NSToCoordTrunc(aValue);
-}
-
-
-
-
-inline int32_t NSToIntFloor(float aValue)
-{
-  return int32_t(floorf(aValue));
-}
-
-inline int32_t NSToIntCeil(float aValue)
-{
-  return int32_t(ceilf(aValue));
-}
-
-inline int32_t NSToIntRound(float aValue)
-{
-  return NS_lroundf(aValue);
-}
-
-inline int32_t NSToIntRound(double aValue)
-{
-  return NS_lround(aValue);
-}
-
-inline int32_t NSToIntRoundUp(double aValue)
-{
-  return int32_t(floor(aValue + 0.5));
-}
-
-
-
-
-inline nscoord NSFloatPixelsToAppUnits(float aPixels, float aAppUnitsPerPixel)
-{
-  return NSToCoordRoundWithClamp(aPixels * aAppUnitsPerPixel);
-}
-
-inline nscoord NSIntPixelsToAppUnits(int32_t aPixels, int32_t aAppUnitsPerPixel)
-{
-
-
-  nscoord r = aPixels * (nscoord)aAppUnitsPerPixel;
-  VERIFY_COORD(r);
-  return r;
-}
-
-inline float NSAppUnitsToFloatPixels(nscoord aAppUnits, float aAppUnitsPerPixel)
-{
-  return (float(aAppUnits) / aAppUnitsPerPixel);
-}
-
-inline double NSAppUnitsToDoublePixels(nscoord aAppUnits, double aAppUnitsPerPixel)
-{
-  return (double(aAppUnits) / aAppUnitsPerPixel);
-}
-
-inline int32_t NSAppUnitsToIntPixels(nscoord aAppUnits, float aAppUnitsPerPixel)
-{
-  return NSToIntRound(float(aAppUnits) / aAppUnitsPerPixel);
-}
-
-inline float NSCoordScale(nscoord aCoord, int32_t aFromAPP, int32_t aToAPP)
-{
-  return (NSCoordToFloat(aCoord) * aToAPP) / aFromAPP;
-}
-# 418 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCoord.h"
-inline float NSUnitsToTwips(float aValue, float aPointsPerUnit)
-{
-  return aValue * aPointsPerUnit * 20.0f;
-}
-
-inline float NSTwipsToUnits(float aTwips, float aUnitsPerPoint)
-{
-  return (aTwips * (aUnitsPerPoint / 20.0f));
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h" 2
-
-class nsAString;
-class nsString;
-
-
-
-typedef uint32_t nscolor;
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h"
-namespace mozilla {
-
-template<typename T>
-inline uint8_t ClampColor(T aColor)
-{
-  if (aColor >= 255) {
-    return 255;
-  }
-  if (aColor <= 0) {
-    return 0;
-  }
-  return NSToIntRound(aColor);
-}
-
-}
-# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsColor.h"
-enum class nsHexColorType : uint8_t {
-  NoAlpha,
-  AllowAlpha,
-};
-
-
-
-
-bool
-NS_HexToRGBA(const nsAString& aBuf, nsHexColorType aType, nscolor* aResult);
-
-
-
-nscolor NS_ComposeColors(nscolor aBG, nscolor aFG);
-
-namespace mozilla {
-
-inline uint32_t RoundingDivideBy255(uint32_t n)
-{
-
-
-
-  return (n + 127) / 255;
-}
-
-
-
-nscolor LinearBlendColors(nscolor aBg, nscolor aFg, uint_fast8_t aFgRatio);
-
-}
-
-
-
-
-bool NS_LooseHexToRGB(const nsString& aBuf, nscolor* aResult);
-
-
-
-
-
-
-bool NS_ColorNameToRGB(const nsAString& aBuf, nscolor* aResult);
-
-
-
-const char * const * NS_AllColorNames(size_t *aSizeArray);
-
-
-
-nscolor NS_HSL2RGB(float h, float s, float l);
-
-
-
-
-
-
-const char* NS_RGBToColorName(nscolor aColor);
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCaseTreatment.h"
-enum nsCaseTreatment {
-  eCaseMatters,
-  eIgnoreCase
-};
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseSize.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-
-template <class T, class Sub>
-struct BaseSize {
-  union {
-    struct {
-      T width, height;
-    };
-    T components[2];
-  };
-
-
-  constexpr BaseSize() : width(0), height(0) {}
-  constexpr BaseSize(T aWidth, T aHeight) : width(aWidth), height(aHeight) {}
-
-  void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; }
-
-  bool IsEmpty() const {
-    return width <= 0 || height <= 0;
-  }
-
-  bool IsSquare() const {
-    return width == height;
-  }
-
-
-
-
-  bool operator==(const Sub& aSize) const {
-    return width == aSize.width && height == aSize.height;
-  }
-  bool operator!=(const Sub& aSize) const {
-    return width != aSize.width || height != aSize.height;
-  }
-  bool operator<=(const Sub& aSize) const {
-    return width <= aSize.width && height <= aSize.height;
-  }
-  bool operator<(const Sub& aSize) const {
-    return *this <= aSize && *this != aSize;
-  }
-
-  Sub operator+(const Sub& aSize) const {
-    return Sub(width + aSize.width, height + aSize.height);
-  }
-  Sub operator-(const Sub& aSize) const {
-    return Sub(width - aSize.width, height - aSize.height);
-  }
-  Sub& operator+=(const Sub& aSize) {
-    width += aSize.width;
-    height += aSize.height;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const Sub& aSize) {
-    width -= aSize.width;
-    height -= aSize.height;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub operator*(T aScale) const {
-    return Sub(width * aScale, height * aScale);
-  }
-  Sub operator/(T aScale) const {
-    return Sub(width / aScale, height / aScale);
-  }
-  friend Sub operator*(T aScale, const Sub& aSize) {
-    return Sub(aScale * aSize.width, aScale * aSize.height);
-  }
-  void Scale(T aXScale, T aYScale) {
-    width *= aXScale;
-    height *= aYScale;
-  }
-
-  Sub operator*(const Sub& aSize) const {
-    return Sub(width * aSize.width, height * aSize.height);
-  }
-  Sub operator/(const Sub& aSize) const {
-    return Sub(width / aSize.width, height / aSize.height);
-  }
-
-  friend Sub Min(const Sub& aA, const Sub& aB) {
-    return Sub(std::min(aA.width, aB.width),
-               std::min(aA.height, aB.height));
-  }
-
-  friend Sub Max(const Sub& aA, const Sub& aB) {
-    return Sub(std::max(aA.width, aB.width),
-               std::max(aA.height, aB.height));
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream,
-      const BaseSize<T, Sub>& aSize) {
-    return aStream << aSize.width << " x " << aSize.height;
-  }
-};
-
-}
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 1
-
-
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint.h" 2
-
-
-
-
-
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-
-template <class T, class Sub, class Coord = T>
-struct BasePoint {
-  union {
-    struct {
-      T x, y;
-    };
-    T components[2];
-  };
-
-
-  constexpr BasePoint() : x(0), y(0) {}
-  constexpr BasePoint(Coord aX, Coord aY) : x(aX), y(aY) {}
-
-  void MoveTo(T aX, T aY) { x = aX; y = aY; }
-  void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; }
-
-
-
-
-  bool operator==(const Sub& aPoint) const {
-    return x == aPoint.x && y == aPoint.y;
-  }
-  bool operator!=(const Sub& aPoint) const {
-    return x != aPoint.x || y != aPoint.y;
-  }
-
-  Sub operator+(const Sub& aPoint) const {
-    return Sub(x + aPoint.x, y + aPoint.y);
-  }
-  Sub operator-(const Sub& aPoint) const {
-    return Sub(x - aPoint.x, y - aPoint.y);
-  }
-  Sub& operator+=(const Sub& aPoint) {
-    x += aPoint.x;
-    y += aPoint.y;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const Sub& aPoint) {
-    x -= aPoint.x;
-    y -= aPoint.y;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub operator*(T aScale) const {
-    return Sub(x * aScale, y * aScale);
-  }
-  Sub operator/(T aScale) const {
-    return Sub(x / aScale, y / aScale);
-  }
-
-  Sub operator-() const {
-    return Sub(-x, -y);
-  }
-
-  T DotProduct(const Sub& aPoint) const {
-      return x * aPoint.x + y * aPoint.y;
-  }
-
-  Coord Length() const {
-    return hypot(x, y);
-  }
-
-  T LengthSquare() const {
-    return x * x + y * y;
-  }
-
-
-
-
-  Sub& Round() {
-    x = Coord(floor(T(x) + T(0.5)));
-    y = Coord(floor(T(y) + T(0.5)));
-    return *static_cast<Sub*>(this);
-  }
-
-
-  bool IsFinite() const
-  {
-    typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
-    return (mozilla::IsFinite(FloatType(x)) && mozilla::IsFinite(FloatType(y)));
-    return true;
-  }
-
-  void Clamp(T aMaxAbsValue)
-  {
-    x = std::max(std::min(x, aMaxAbsValue), -aMaxAbsValue);
-    y = std::max(std::min(y, aMaxAbsValue), -aMaxAbsValue);
-  }
-
-  friend std::ostream& operator<<(std::ostream& stream, const BasePoint<T, Sub, Coord>& aPoint) {
-    return stream << '(' << aPoint.x << ',' << aPoint.y << ')';
-  }
-
-};
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h" 2
-
-
-namespace mozilla {
-namespace gfx {
-
-typedef float Float;
-
-enum class SurfaceType : int8_t {
-  DATA,
-  D2D1_BITMAP,
-  D2D1_DRAWTARGET,
-  CAIRO,
-  CAIRO_IMAGE,
-  COREGRAPHICS_IMAGE,
-  COREGRAPHICS_CGCONTEXT,
-  SKIA,
-  DUAL_DT,
-  D2D1_1_IMAGE,
-  RECORDING,
-  TILED,
-  DATA_SHARED,
-};
-
-enum class SurfaceFormat : int8_t {
-
-
-
-
-  B8G8R8A8,
-  B8G8R8X8,
-  R8G8B8A8,
-  R8G8B8X8,
-  A8R8G8B8,
-  X8R8G8B8,
-
-  R8G8B8,
-  B8G8R8,
-
-
-
-
-  R5G6B5_UINT16,
-
-
-  A8,
-
-
-  YUV,
-  NV12,
-  YUV422,
-  HSV,
-  Lab,
-  Depth,
-
-
-  UNKNOWN,
-
-
-
-
-
-  A8R8G8B8_UINT32 = B8G8R8A8,
-  X8R8G8B8_UINT32 = B8G8R8X8
-
-
-
-
-
-
-};
-
-inline bool IsOpaque(SurfaceFormat aFormat)
-{
-  switch (aFormat) {
-  case SurfaceFormat::B8G8R8X8:
-  case SurfaceFormat::R8G8B8X8:
-  case SurfaceFormat::R5G6B5_UINT16:
-  case SurfaceFormat::YUV:
-  case SurfaceFormat::NV12:
-  case SurfaceFormat::YUV422:
-    return true;
-  default:
-    return false;
-  }
-}
-
-enum class FilterType : int8_t {
-  BLEND = 0,
-  TRANSFORM,
-  MORPHOLOGY,
-  COLOR_MATRIX,
-  FLOOD,
-  TILE,
-  TABLE_TRANSFER,
-  DISCRETE_TRANSFER,
-  LINEAR_TRANSFER,
-  GAMMA_TRANSFER,
-  CONVOLVE_MATRIX,
-  DISPLACEMENT_MAP,
-  TURBULENCE,
-  ARITHMETIC_COMBINE,
-  COMPOSITE,
-  DIRECTIONAL_BLUR,
-  GAUSSIAN_BLUR,
-  POINT_DIFFUSE,
-  POINT_SPECULAR,
-  SPOT_DIFFUSE,
-  SPOT_SPECULAR,
-  DISTANT_DIFFUSE,
-  DISTANT_SPECULAR,
-  CROP,
-  PREMULTIPLY,
-  UNPREMULTIPLY
-};
-
-enum class DrawTargetType : int8_t {
-  SOFTWARE_RASTER = 0,
-  HARDWARE_RASTER,
-  VECTOR
-};
-
-enum class BackendType : int8_t {
-  NONE = 0,
-  DIRECT2D,
-  CAIRO,
-  SKIA,
-  RECORDING,
-  DIRECT2D1_1,
-
-
-  BACKEND_LAST
-};
-
-enum class FontType : int8_t {
-  DWRITE,
-  GDI,
-  MAC,
-  SKIA,
-  CAIRO,
-  COREGRAPHICS,
-  FONTCONFIG
-};
-
-enum class NativeSurfaceType : int8_t {
-  D3D10_TEXTURE,
-  CAIRO_CONTEXT,
-  CGCONTEXT,
-  CGCONTEXT_ACCELERATED,
-  OPENGL_TEXTURE
-};
-
-enum class NativeFontType : int8_t {
-  DWRITE_FONT_FACE,
-  GDI_FONT_FACE,
-  MAC_FONT_FACE,
-  SKIA_FONT_FACE,
-  CAIRO_FONT_FACE
-};
-
-enum class FontStyle : int8_t {
-  NORMAL,
-  ITALIC,
-  BOLD,
-  BOLD_ITALIC
-};
-
-enum class FontHinting : int8_t {
-  NONE,
-  LIGHT,
-  NORMAL,
-  FULL
-};
-
-enum class CompositionOp : int8_t {
-  OP_OVER,
-  OP_ADD,
-  OP_ATOP,
-  OP_OUT,
-  OP_IN,
-  OP_SOURCE,
-  OP_DEST_IN,
-  OP_DEST_OUT,
-  OP_DEST_OVER,
-  OP_DEST_ATOP,
-  OP_XOR,
-  OP_MULTIPLY,
-  OP_SCREEN,
-  OP_OVERLAY,
-  OP_DARKEN,
-  OP_LIGHTEN,
-  OP_COLOR_DODGE,
-  OP_COLOR_BURN,
-  OP_HARD_LIGHT,
-  OP_SOFT_LIGHT,
-  OP_DIFFERENCE,
-  OP_EXCLUSION,
-  OP_HUE,
-  OP_SATURATION,
-  OP_COLOR,
-  OP_LUMINOSITY,
-  OP_COUNT
-};
-
-enum class Axis : int8_t {
-  X_AXIS,
-  Y_AXIS,
-  BOTH
-};
-
-enum class ExtendMode : int8_t {
-  CLAMP,
-  REPEAT,
-  REPEAT_X,
-  REPEAT_Y,
-  REFLECT
-};
-
-enum class FillRule : int8_t {
-  FILL_WINDING,
-  FILL_EVEN_ODD
-};
-
-enum class AntialiasMode : int8_t {
-  NONE,
-  GRAY,
-  SUBPIXEL,
-  DEFAULT
-};
-
-
-enum class SamplingFilter : int8_t {
-  GOOD,
-  LINEAR,
-  POINT,
-  SENTINEL
-};
-
-enum class PatternType : int8_t {
-  COLOR,
-  SURFACE,
-  LINEAR_GRADIENT,
-  RADIAL_GRADIENT
-};
-
-enum class JoinStyle : int8_t {
-  BEVEL,
-  ROUND,
-  MITER,
-
-
-  MITER_OR_BEVEL
-};
-
-enum class CapStyle : int8_t {
-  BUTT,
-  ROUND,
-  SQUARE
-};
-
-enum class SamplingBounds : int8_t {
-  UNBOUNDED,
-  BOUNDED
-};
-
-
-struct Color
-{
-public:
-  Color()
-    : r(0.0f), g(0.0f), b(0.0f), a(0.0f)
-  {}
-  Color(Float aR, Float aG, Float aB, Float aA)
-    : r(aR), g(aG), b(aB), a(aA)
-  {}
-  Color(Float aR, Float aG, Float aB)
-    : r(aR), g(aG), b(aB), a(1.0f)
-  {}
-
-  static Color FromABGR(uint32_t aColor)
-  {
-    Color newColor(((aColor >> 0) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 8) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 16) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 24) & 0xff) * (1.0f / 255.0f));
-
-    return newColor;
-  }
-
-
-
-  static Color UnusualFromARGB(uint32_t aColor)
-  {
-    Color newColor(((aColor >> 16) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 8) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 0) & 0xff) * (1.0f / 255.0f),
-                   ((aColor >> 24) & 0xff) * (1.0f / 255.0f));
-
-    return newColor;
-  }
-
-  uint32_t ToABGR() const
-  {
-    return uint32_t(r * 255.0f) | uint32_t(g * 255.0f) << 8 |
-           uint32_t(b * 255.0f) << 16 | uint32_t(a * 255.0f) << 24;
-  }
-
-
-
-  uint32_t UnusualToARGB() const
-  {
-    return uint32_t(b * 255.0f) | uint32_t(g * 255.0f) << 8 |
-           uint32_t(r * 255.0f) << 16 | uint32_t(a * 255.0f) << 24;
-  }
-
-  bool operator==(const Color& aColor) const {
-    return r == aColor.r && g == aColor.g && b == aColor.b && a == aColor.a;
-  }
-
-  bool operator!=(const Color& aColor) const {
-    return !(*this == aColor);
-  }
-
-  Float r, g, b, a;
-};
-
-struct GradientStop
-{
-  bool operator<(const GradientStop& aOther) const {
-    return offset < aOther.offset;
-  }
-
-  Float offset;
-  Color color;
-};
-
-enum class JobStatus {
-    Complete,
-    Wait,
-    Yield,
-    Error
-};
-
-}
-}
-
-
-typedef mozilla::gfx::SurfaceFormat gfxImageFormat;
-# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-namespace mozilla {
-
-
-enum Side { eSideTop, eSideRight, eSideBottom, eSideLeft };
-
-enum SideBits {
-  eSideBitsNone = 0,
-  eSideBitsTop = 1 << eSideTop,
-  eSideBitsRight = 1 << eSideRight,
-  eSideBitsBottom = 1 << eSideBottom,
-  eSideBitsLeft = 1 << eSideLeft,
-  eSideBitsTopBottom = eSideBitsTop | eSideBitsBottom,
-  eSideBitsLeftRight = eSideBitsLeft | eSideBitsRight,
-  eSideBitsAll = eSideBitsTopBottom | eSideBitsLeftRight
-};
-# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-static inline Side& operator++(Side& side) {
-  do { } while (0);
-
-  side = Side(side + 1);
-  return side;
-}
-
-enum Corner {
-
-  eCornerTopLeft = 0,
-  eCornerTopRight = 1,
-  eCornerBottomRight = 2,
-  eCornerBottomLeft = 3
-};
-
-
-
-
-constexpr int eCornerCount = 4;
-# 427 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-static inline Corner operator++(Corner& aCorner) {
-  do { } while (0);
-
-  aCorner = Corner(aCorner + 1);
-  return aCorner;
-}
-
-
-enum HalfCorner {
-
-  eCornerTopLeftX = 0,
-  eCornerTopLeftY = 1,
-  eCornerTopRightX = 2,
-  eCornerTopRightY = 3,
-  eCornerBottomRightX = 4,
-  eCornerBottomRightY = 5,
-  eCornerBottomLeftX = 6,
-  eCornerBottomLeftY = 7
-};
-# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-static inline HalfCorner operator++(HalfCorner& aHalfCorner) {
-  do { } while (0);
-
-  aHalfCorner = HalfCorner(aHalfCorner + 1);
-  return aHalfCorner;
-}
-
-
-
-
-constexpr bool HalfCornerIsX(HalfCorner aHalfCorner)
-{
-  return !(aHalfCorner % 2);
-}
-
-constexpr Corner HalfToFullCorner(HalfCorner aHalfCorner)
-{
-  return Corner(aHalfCorner / 2);
-}
-
-constexpr HalfCorner FullToHalfCorner(Corner aCorner, bool aIsVertical)
-{
-  return HalfCorner(aCorner * 2 + aIsVertical);
-}
-
-constexpr bool SideIsVertical(Side aSide)
-{
-  return aSide % 2;
-}
-
-
-
-
-
-constexpr Corner SideToFullCorner(Side aSide, bool aIsSecond)
-{
-  return Corner((aSide + aIsSecond) % 4);
-}
-# 502 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Types.h"
-constexpr HalfCorner SideToHalfCorner(Side aSide, bool aIsSecond,
-                                      bool aIsParallel)
-{
-  return HalfCorner(((aSide + aIsSecond) * 2 + (aSide + !aIsParallel) % 2) % 8);
-}
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseCoord.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-
-template <class T, class Sub>
-struct BaseCoord {
-  T value;
-
-
-  constexpr BaseCoord() : value(0) {}
-  explicit constexpr BaseCoord(T aValue) : value(aValue) {}
-
-
-
-
-  operator T() const { return value; }
-
-  friend bool operator==(Sub aA, Sub aB) {
-    return aA.value == aB.value;
-  }
-  friend bool operator!=(Sub aA, Sub aB) {
-    return aA.value != aB.value;
-  }
-
-  friend Sub operator+(Sub aA, Sub aB) {
-    return Sub(aA.value + aB.value);
-  }
-  friend Sub operator-(Sub aA, Sub aB) {
-    return Sub(aA.value - aB.value);
-  }
-  friend Sub operator*(Sub aCoord, T aScale) {
-    return Sub(aCoord.value * aScale);
-  }
-  friend Sub operator*(T aScale, Sub aCoord) {
-    return Sub(aScale * aCoord.value);
-  }
-  friend Sub operator/(Sub aCoord, T aScale) {
-    return Sub(aCoord.value / aScale);
-  }
-
-
-  Sub& operator+=(Sub aCoord) {
-    value += aCoord.value;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(Sub aCoord) {
-    value -= aCoord.value;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator*=(T aScale) {
-    value *= aScale;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator/=(T aScale) {
-    value /= aScale;
-    return *static_cast<Sub*>(this);
-  }
-
-
-
-
-
-  friend bool operator==(Sub aA, T aB) {
-    return aA.value == aB;
-  }
-  friend bool operator==(T aA, Sub aB) {
-    return aA == aB.value;
-  }
-  friend bool operator!=(Sub aA, T aB) {
-    return aA.value != aB;
-  }
-  friend bool operator!=(T aA, Sub aB) {
-    return aA != aB.value;
-  }
-  friend T operator+(Sub aA, T aB) {
-    return aA.value + aB;
-  }
-  friend T operator+(T aA, Sub aB) {
-    return aA + aB.value;
-  }
-  friend T operator-(Sub aA, T aB) {
-    return aA.value - aB;
-  }
-  friend T operator-(T aA, Sub aB) {
-    return aA - aB.value;
-  }
-
-  Sub operator-() const {
-    return Sub(-value);
-  }
-};
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h" 2
-
-namespace mozilla {
-
-template <typename> struct IsPixel;
-
-namespace gfx {
-
-template <class units> struct IntCoordTyped;
-template <class units, class F = Float> struct CoordTyped;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
-template <class coord, class primitive>
-struct CommonType;
-
-template <class units, class primitive>
-struct CommonType<IntCoordTyped<units>, primitive> {
-    typedef decltype(int32_t() + primitive()) type;
-};
-
-template <class units, class F, class primitive>
-struct CommonType<CoordTyped<units, F>, primitive> {
-    typedef decltype(F() + primitive()) type;
-};
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Coord.h"
-template <bool B, class coord, class primitive>
-struct CoordOperatorsHelper {
-
-
-};
-
-template <class coord, class primitive>
-struct CoordOperatorsHelper<true, coord, primitive> {
-  friend bool operator==(coord aA, primitive aB) {
-    return aA.value == aB;
-  }
-  friend bool operator==(primitive aA, coord aB) {
-    return aA == aB.value;
-  }
-  friend bool operator!=(coord aA, primitive aB) {
-    return aA.value != aB;
-  }
-  friend bool operator!=(primitive aA, coord aB) {
-    return aA != aB.value;
-  }
-
-  typedef typename CommonType<coord, primitive>::type result_type;
-
-  friend result_type operator+(coord aA, primitive aB) {
-    return aA.value + aB;
-  }
-  friend result_type operator+(primitive aA, coord aB) {
-    return aA + aB.value;
-  }
-  friend result_type operator-(coord aA, primitive aB) {
-    return aA.value - aB;
-  }
-  friend result_type operator-(primitive aA, coord aB) {
-    return aA - aB.value;
-  }
-  friend result_type operator*(coord aCoord, primitive aScale) {
-    return aCoord.value * aScale;
-  }
-  friend result_type operator*(primitive aScale, coord aCoord) {
-    return aScale * aCoord.value;
-  }
-  friend result_type operator/(coord aCoord, primitive aScale) {
-    return aCoord.value / aScale;
-  }
-
-};
-
-
-
-
-template<class units>
-struct IntCoordTyped :
-  public BaseCoord< int32_t, IntCoordTyped<units> >,
-  public CoordOperatorsHelper< true, IntCoordTyped<units>, float >,
-  public CoordOperatorsHelper< true, IntCoordTyped<units>, double > {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef BaseCoord< int32_t, IntCoordTyped<units> > Super;
-
-  constexpr IntCoordTyped() : Super() {}
-  constexpr IntCoordTyped(int32_t aValue) : Super(aValue) {}
-};
-
-template<class units, class F>
-struct CoordTyped :
-  public BaseCoord< F, CoordTyped<units, F> >,
-  public CoordOperatorsHelper< !IsSame<F, int32_t>::value, CoordTyped<units, F>, int32_t >,
-  public CoordOperatorsHelper< !IsSame<F, uint32_t>::value, CoordTyped<units, F>, uint32_t >,
-  public CoordOperatorsHelper< !IsSame<F, double>::value, CoordTyped<units, F>, double >,
-  public CoordOperatorsHelper< !IsSame<F, float>::value, CoordTyped<units, F>, float > {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef BaseCoord< F, CoordTyped<units, F> > Super;
-
-  constexpr CoordTyped() : Super() {}
-  constexpr CoordTyped(F aValue) : Super(aValue) {}
-  explicit constexpr CoordTyped(const IntCoordTyped<units>& aCoord) : Super(F(aCoord.value)) {}
-
-  void Round() {
-    this->value = floor(this->value + 0.5);
-  }
-  void Truncate() {
-    this->value = int32_t(this->value);
-  }
-
-  IntCoordTyped<units> Rounded() const {
-    return IntCoordTyped<units>(int32_t(floor(this->value + 0.5)));
-  }
-  IntCoordTyped<units> Truncated() const {
-    return IntCoordTyped<units>(int32_t(this->value));
-  }
-};
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint3D.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-
-template <class T, class Sub>
-struct BasePoint3D {
-  union {
-    struct {
-      T x, y, z;
-    };
-    T components[3];
-  };
-
-
-  BasePoint3D() : x(0), y(0), z(0) {}
-  BasePoint3D(T aX, T aY, T aZ) : x(aX), y(aY), z(aZ) {}
-
-  void MoveTo(T aX, T aY, T aZ) { x = aX; y = aY; z = aZ; }
-  void MoveBy(T aDx, T aDy, T aDz) { x += aDx; y += aDy; z += aDz; }
-
-
-
-
-  T& operator[](int aIndex) {
-    do { } while (0);
-    return *((&x)+aIndex);
-  }
-
-  const T& operator[](int aIndex) const {
-    do { } while (0);
-    return *((&x)+aIndex);
-  }
-
-  bool operator==(const Sub& aPoint) const {
-    return x == aPoint.x && y == aPoint.y && z == aPoint.z;
-  }
-  bool operator!=(const Sub& aPoint) const {
-    return x != aPoint.x || y != aPoint.y || z != aPoint.z;
-  }
-
-  Sub operator+(const Sub& aPoint) const {
-    return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z);
-  }
-  Sub operator-(const Sub& aPoint) const {
-    return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z);
-  }
-  Sub& operator+=(const Sub& aPoint) {
-    x += aPoint.x;
-    y += aPoint.y;
-    z += aPoint.z;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const Sub& aPoint) {
-    x -= aPoint.x;
-    y -= aPoint.y;
-    z -= aPoint.z;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub operator*(T aScale) const {
-    return Sub(x * aScale, y * aScale, z * aScale);
-  }
-  Sub operator/(T aScale) const {
-    return Sub(x / aScale, y / aScale, z / aScale);
-  }
-
-  Sub& operator*=(T aScale) {
-    x *= aScale;
-    y *= aScale;
-    z *= aScale;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub& operator/=(T aScale) {
-      x /= aScale;
-      y /= aScale;
-      z /= aScale;
-      return *static_cast<Sub*>(this);
-  }
-
-  Sub operator-() const {
-    return Sub(-x, -y, -z);
-  }
-
-  Sub CrossProduct(const Sub& aPoint) const {
-      return Sub(y * aPoint.z - aPoint.y * z,
-                 z * aPoint.x - aPoint.z * x,
-                 x * aPoint.y - aPoint.x * y);
-  }
-
-  T DotProduct(const Sub& aPoint) const {
-      return x * aPoint.x + y * aPoint.y + z * aPoint.z;
-  }
-
-  T Length() const {
-      return sqrt(x*x + y*y + z*z);
-  }
-
-
-  void Normalize() {
-      *this /= Length();
-  }
-};
-
-}
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BasePoint4D.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-
-template <class T, class Sub>
-struct BasePoint4D {
-  union {
-    struct {
-      T x, y, z, w;
-    };
-    T components[4];
-  };
-
-
-  BasePoint4D() : x(0), y(0), z(0), w(0) {}
-  BasePoint4D(T aX, T aY, T aZ, T aW) : x(aX), y(aY), z(aZ), w(aW) {}
-
-  void MoveTo(T aX, T aY, T aZ, T aW) { x = aX; y = aY; z = aZ; w = aW; }
-  void MoveBy(T aDx, T aDy, T aDz, T aDw) { x += aDx; y += aDy; z += aDz; w += aDw; }
-
-
-
-
-  bool operator==(const Sub& aPoint) const {
-    return x == aPoint.x && y == aPoint.y &&
-           z == aPoint.z && w == aPoint.w;
-  }
-  bool operator!=(const Sub& aPoint) const {
-    return x != aPoint.x || y != aPoint.y ||
-           z != aPoint.z || w != aPoint.w;
-  }
-
-  Sub operator+(const Sub& aPoint) const {
-    return Sub(x + aPoint.x, y + aPoint.y, z + aPoint.z, w + aPoint.w);
-  }
-  Sub operator-(const Sub& aPoint) const {
-    return Sub(x - aPoint.x, y - aPoint.y, z - aPoint.z, w - aPoint.w);
-  }
-  Sub& operator+=(const Sub& aPoint) {
-    x += aPoint.x;
-    y += aPoint.y;
-    z += aPoint.z;
-    w += aPoint.w;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const Sub& aPoint) {
-    x -= aPoint.x;
-    y -= aPoint.y;
-    z -= aPoint.z;
-    w -= aPoint.w;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub operator*(T aScale) const {
-    return Sub(x * aScale, y * aScale, z * aScale, w * aScale);
-  }
-  Sub operator/(T aScale) const {
-    return Sub(x / aScale, y / aScale, z / aScale, w / aScale);
-  }
-
-  Sub& operator*=(T aScale) {
-    x *= aScale;
-    y *= aScale;
-    z *= aScale;
-    w *= aScale;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub& operator/=(T aScale) {
-    x /= aScale;
-    y /= aScale;
-    z /= aScale;
-    w /= aScale;
-    return *static_cast<Sub*>(this);
-  }
-
-  Sub operator-() const {
-    return Sub(-x, -y, -z, -w);
-  }
-
-  T& operator[](int aIndex) {
-    do { } while (0);
-    return *((&x)+aIndex);
-  }
-
-  const T& operator[](int aIndex) const {
-    do { } while (0);
-    return *((&x)+aIndex);
-  }
-
-  T DotProduct(const Sub& aPoint) const {
-    return x * aPoint.x + y * aPoint.y + z * aPoint.z + w * aPoint.w;
-  }
-
-
-  Sub CrossProduct(const Sub& aPoint) const {
-      return Sub(y * aPoint.z - aPoint.y * z,
-          z * aPoint.x - aPoint.z * x,
-          x * aPoint.y - aPoint.x * y,
-          0);
-  }
-
-  T Length() const {
-    return sqrt(x*x + y*y + z*z + w*w);
-  }
-
-  void Normalize() {
-    *this /= Length();
-  }
-
-  bool HasPositiveWCoord() { return w > 0; }
-};
-
-}
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Point.h" 2
-
-namespace mozilla {
-
-template <typename> struct IsPixel;
-
-namespace gfx {
-
-
-struct UnknownUnits {};
-
-}
-
-template<> struct IsPixel<gfx::UnknownUnits> : TrueType {};
-
-namespace gfx {
-
-
-
-
-
-
-template<typename T>
-struct IntParam {
-  constexpr IntParam(char val) : value(val) {}
-  constexpr IntParam(unsigned char val) : value(val) {}
-  constexpr IntParam(short val) : value(val) {}
-  constexpr IntParam(unsigned short val) : value(val) {}
-  constexpr IntParam(int val) : value(val) {}
-  constexpr IntParam(unsigned int val) : value(val) {}
-  constexpr IntParam(long val) : value(val) {}
-  constexpr IntParam(unsigned long val) : value(val) {}
-  constexpr IntParam(long long val) : value(val) {}
-  constexpr IntParam(unsigned long long val) : value(val) {}
-  template<typename Unit>
-  constexpr IntParam(IntCoordTyped<Unit> val) : value(val) {}
-
-
-               IntParam(float val) = delete;
-               IntParam(double val) = delete;
-
-  T value;
-};
-
-template<class units, class> struct PointTyped;
-template<class units, class> struct SizeTyped;
-
-template<class units>
-struct IntPointTyped :
-  public BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> >,
-  public units {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef IntParam<int32_t> ToInt;
-  typedef IntCoordTyped<units> Coord;
-  typedef BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> > Super;
-
-  constexpr IntPointTyped() : Super() {}
-  constexpr IntPointTyped(ToInt aX, ToInt aY) : Super(Coord(aX.value), Coord(aY.value)) {}
-
-  static IntPointTyped<units> Round(float aX, float aY) {
-    return IntPointTyped(int32_t(floorf(aX + 0.5)), int32_t(floorf(aY + 0.5)));
-  }
-
-  static IntPointTyped<units> Ceil(float aX, float aY) {
-    return IntPointTyped(int32_t(ceil(aX)), int32_t(ceil(aY)));
-  }
-
-  static IntPointTyped<units> Floor(float aX, float aY) {
-    return IntPointTyped(int32_t(floorf(aX)), int32_t(floorf(aY)));
-  }
-
-  static IntPointTyped<units> Truncate(float aX, float aY) {
-    return IntPointTyped(int32_t(aX), int32_t(aY));
-  }
-
-  static IntPointTyped<units> Round(const PointTyped<units, float>& aPoint);
-  static IntPointTyped<units> Ceil(const PointTyped<units, float>& aPoint);
-  static IntPointTyped<units> Floor(const PointTyped<units, float>& aPoint);
-  static IntPointTyped<units> Truncate(const PointTyped<units, float>& aPoint);
-
-
-
-
-  static IntPointTyped<units> FromUnknownPoint(const IntPointTyped<UnknownUnits>& aPoint) {
-    return IntPointTyped<units>(aPoint.x, aPoint.y);
-  }
-
-  IntPointTyped<UnknownUnits> ToUnknownPoint() const {
-    return IntPointTyped<UnknownUnits>(this->x, this->y);
-  }
-};
-typedef IntPointTyped<UnknownUnits> IntPoint;
-
-template<class units, class F = Float>
-struct PointTyped :
-  public BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> >,
-  public units {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef CoordTyped<units, F> Coord;
-  typedef BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> > Super;
-
-  constexpr PointTyped() : Super() {}
-  constexpr PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {}
-
-
-  constexpr PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {}
-  constexpr PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {}
-  constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
-  constexpr PointTyped(const IntPointTyped<units>& point) : Super(F(point.x), F(point.y)) {}
-
-
-
-
-  static PointTyped<units, F> FromUnknownPoint(const PointTyped<UnknownUnits, F>& aPoint) {
-    return PointTyped<units, F>(aPoint.x, aPoint.y);
-  }
-
-  PointTyped<UnknownUnits, F> ToUnknownPoint() const {
-    return PointTyped<UnknownUnits, F>(this->x, this->y);
-  }
-};
-typedef PointTyped<UnknownUnits> Point;
-typedef PointTyped<UnknownUnits, double> PointDouble;
-
-template<class units>
-IntPointTyped<units> RoundedToInt(const PointTyped<units>& aPoint) {
-  return IntPointTyped<units>::Round(aPoint.x, aPoint.y);
-}
-
-template<class units>
-IntPointTyped<units> TruncatedToInt(const PointTyped<units>& aPoint) {
-  return IntPointTyped<units>::Truncate(aPoint.x, aPoint.y);
-}
-
-template<class units, class F = Float>
-struct Point3DTyped :
-  public BasePoint3D< F, Point3DTyped<units, F> > {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef BasePoint3D< F, Point3DTyped<units, F> > Super;
-
-  Point3DTyped() : Super() {}
-  Point3DTyped(F aX, F aY, F aZ) : Super(aX, aY, aZ) {}
-
-
-
-
-  static Point3DTyped<units, F> FromUnknownPoint(const Point3DTyped<UnknownUnits, F>& aPoint) {
-    return Point3DTyped<units, F>(aPoint.x, aPoint.y, aPoint.z);
-  }
-
-  Point3DTyped<UnknownUnits, F> ToUnknownPoint() const {
-    return Point3DTyped<UnknownUnits, F>(this->x, this->y, this->z);
-  }
-};
-typedef Point3DTyped<UnknownUnits> Point3D;
-typedef Point3DTyped<UnknownUnits, double> PointDouble3D;
-
-template<typename units>
-IntPointTyped<units>
-IntPointTyped<units>::Round(const PointTyped<units, float>& aPoint)
-{
-  return IntPointTyped::Round(aPoint.x, aPoint.y);
-}
-
-template<typename units>
-IntPointTyped<units>
-IntPointTyped<units>::Ceil(const PointTyped<units, float>& aPoint)
-{
-  return IntPointTyped::Ceil(aPoint.x, aPoint.y);
-}
-
-template<typename units>
-IntPointTyped<units>
-IntPointTyped<units>::Floor(const PointTyped<units, float>& aPoint)
-{
-  return IntPointTyped::Floor(aPoint.x, aPoint.y);
-}
-
-template<typename units>
-IntPointTyped<units>
-IntPointTyped<units>::Truncate(const PointTyped<units, float>& aPoint)
-{
-  return IntPointTyped::Truncate(aPoint.x, aPoint.y);
-}
-
-template<class units, class F = Float>
-struct Point4DTyped :
-  public BasePoint4D< F, Point4DTyped<units, F> > {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef BasePoint4D< F, Point4DTyped<units, F> > Super;
-
-  Point4DTyped() : Super() {}
-  Point4DTyped(F aX, F aY, F aZ, F aW) : Super(aX, aY, aZ, aW) {}
-
-  explicit Point4DTyped(const Point3DTyped<units, F>& aPoint)
-    : Super(aPoint.x, aPoint.y, aPoint.z, 1) {}
-
-
-
-
-  static Point4DTyped<units, F> FromUnknownPoint(const Point4DTyped<UnknownUnits, F>& aPoint) {
-    return Point4DTyped<units, F>(aPoint.x, aPoint.y, aPoint.z, aPoint.w);
-  }
-
-  Point4DTyped<UnknownUnits, F> ToUnknownPoint() const {
-    return Point4DTyped<UnknownUnits, F>(this->x, this->y, this->z, this->w);
-  }
-
-  PointTyped<units, F> As2DPoint() const {
-    return PointTyped<units, F>(this->x / this->w,
-                                this->y / this->w);
-  }
-
-  Point3DTyped<units, F> As3DPoint() const {
-    return Point3DTyped<units, F>(this->x / this->w,
-                                  this->y / this->w,
-                                  this->z / this->w);
-  }
-};
-typedef Point4DTyped<UnknownUnits> Point4D;
-typedef Point4DTyped<UnknownUnits, double> PointDouble4D;
-
-template<class units>
-struct IntSizeTyped :
-  public BaseSize< int32_t, IntSizeTyped<units> >,
-  public units {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef IntParam<int32_t> ToInt;
-  typedef BaseSize< int32_t, IntSizeTyped<units> > Super;
-
-  constexpr IntSizeTyped() : Super() {}
-  constexpr IntSizeTyped(ToInt aWidth, ToInt aHeight) : Super(aWidth.value, aHeight.value) {}
-
-  static IntSizeTyped<units> Round(float aWidth, float aHeight) {
-    return IntSizeTyped(int32_t(floorf(aWidth + 0.5)), int32_t(floorf(aHeight + 0.5)));
-  }
-
-  static IntSizeTyped<units> Truncate(float aWidth, float aHeight) {
-    return IntSizeTyped(int32_t(aWidth), int32_t(aHeight));
-  }
-
-  static IntSizeTyped<units> Ceil(float aWidth, float aHeight) {
-    return IntSizeTyped(int32_t(ceil(aWidth)), int32_t(ceil(aHeight)));
-  }
-
-  static IntSizeTyped<units> Floor(float aWidth, float aHeight) {
-    return IntSizeTyped(int32_t(floorf(aWidth)), int32_t(floorf(aHeight)));
-  }
-
-  static IntSizeTyped<units> Round(const SizeTyped<units, float>& aSize);
-  static IntSizeTyped<units> Ceil(const SizeTyped<units, float>& aSize);
-  static IntSizeTyped<units> Floor(const SizeTyped<units, float>& aSize);
-  static IntSizeTyped<units> Truncate(const SizeTyped<units, float>& aSize);
-
-
-
-
-  static IntSizeTyped<units> FromUnknownSize(const IntSizeTyped<UnknownUnits>& aSize) {
-    return IntSizeTyped<units>(aSize.width, aSize.height);
-  }
-
-  IntSizeTyped<UnknownUnits> ToUnknownSize() const {
-    return IntSizeTyped<UnknownUnits>(this->width, this->height);
-  }
-};
-typedef IntSizeTyped<UnknownUnits> IntSize;
-
-template<class units, class F = Float>
-struct SizeTyped :
-  public BaseSize< F, SizeTyped<units, F> >,
-  public units {
-  static_assert(IsPixel<units>::value,
-                "'units' must be a coordinate system tag");
-
-  typedef BaseSize< F, SizeTyped<units, F> > Super;
-
-  constexpr SizeTyped() : Super() {}
-  constexpr SizeTyped(F aWidth, F aHeight) : Super(aWidth, aHeight) {}
-  explicit SizeTyped(const IntSizeTyped<units>& size) :
-    Super(F(size.width), F(size.height)) {}
-
-
-
-
-  static SizeTyped<units, F> FromUnknownSize(const SizeTyped<UnknownUnits, F>& aSize) {
-    return SizeTyped<units, F>(aSize.width, aSize.height);
-  }
-
-  SizeTyped<UnknownUnits, F> ToUnknownSize() const {
-    return SizeTyped<UnknownUnits, F>(this->width, this->height);
-  }
-};
-typedef SizeTyped<UnknownUnits> Size;
-typedef SizeTyped<UnknownUnits, double> SizeDouble;
-
-template<class units>
-IntSizeTyped<units> RoundedToInt(const SizeTyped<units>& aSize) {
-  return IntSizeTyped<units>(int32_t(floorf(aSize.width + 0.5f)),
-                             int32_t(floorf(aSize.height + 0.5f)));
-}
-
-template<typename units> IntSizeTyped<units>
-IntSizeTyped<units>::Round(const SizeTyped<units, float>& aSize) {
-  return IntSizeTyped::Round(aSize.width, aSize.height);
-}
-
-template<typename units> IntSizeTyped<units>
-IntSizeTyped<units>::Ceil(const SizeTyped<units, float>& aSize) {
-  return IntSizeTyped::Ceil(aSize.width, aSize.height);
-}
-
-template<typename units> IntSizeTyped<units>
-IntSizeTyped<units>::Floor(const SizeTyped<units, float>& aSize) {
-  return IntSizeTyped::Floor(aSize.width, aSize.height);
-}
-
-template<typename units> IntSizeTyped<units>
-IntSizeTyped<units>::Truncate(const SizeTyped<units, float>& aSize) {
-  return IntSizeTyped::Truncate(aSize.width, aSize.height);
-}
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSize.h" 2
-
-
-
-
-typedef mozilla::gfx::IntSize nsIntSize;
-
-struct nsSize : public mozilla::gfx::BaseSize<nscoord, nsSize> {
-  typedef mozilla::gfx::BaseSize<nscoord, nsSize> Super;
-
-  nsSize() : Super() {}
-  nsSize(nscoord aWidth, nscoord aHeight) : Super(aWidth, aHeight) {}
-
-  inline mozilla::gfx::IntSize ScaleToNearestPixels(float aXScale, float aYScale,
-                                        nscoord aAppUnitsPerPixel) const;
-  inline mozilla::gfx::IntSize ToNearestPixels(nscoord aAppUnitsPerPixel) const;
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) inline nsSize
-    ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const;
-};
-
-inline mozilla::gfx::IntSize
-nsSize::ScaleToNearestPixels(float aXScale, float aYScale,
-                             nscoord aAppUnitsPerPixel) const
-{
-  return mozilla::gfx::IntSize(
-      NSToIntRoundUp(NSAppUnitsToDoublePixels(width, aAppUnitsPerPixel) * aXScale),
-      NSToIntRoundUp(NSAppUnitsToDoublePixels(height, aAppUnitsPerPixel) * aYScale));
-}
-
-inline mozilla::gfx::IntSize
-nsSize::ToNearestPixels(nscoord aAppUnitsPerPixel) const
-{
-  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
-}
-
-inline nsSize
-nsSize::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const {
-  if (aFromAPP != aToAPP) {
-    nsSize size;
-    size.width = NSToCoordRound(NSCoordScale(width, aFromAPP, aToAPP));
-    size.height = NSToCoordRound(NSCoordScale(height, aFromAPP, aToAPP));
-    return size;
-  }
-  return *this;
-}
-
-inline nsSize
-IntSizeToAppUnits(mozilla::gfx::IntSize aSize, nscoord aAppUnitsPerPixel)
-{
-  return nsSize(NSIntPixelsToAppUnits(aSize.width, aAppUnitsPerPixel),
-                NSIntPixelsToAppUnits(aSize.height, aAppUnitsPerPixel));
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPoint.h" 2
-
-
-
-
-
-typedef mozilla::gfx::IntPoint nsIntPoint;
-
-
-
-struct nsPoint : public mozilla::gfx::BasePoint<nscoord, nsPoint> {
-  typedef mozilla::gfx::BasePoint<nscoord, nsPoint> Super;
-
-  nsPoint() : Super() {}
-  nsPoint(const nsPoint& aPoint) : Super(aPoint) {}
-  nsPoint(nscoord aX, nscoord aY) : Super(aX, aY) {}
-
-  inline nsIntPoint ScaleToNearestPixels(float aXScale, float aYScale,
-                                         nscoord aAppUnitsPerPixel) const;
-  inline nsIntPoint ToNearestPixels(nscoord aAppUnitsPerPixel) const;
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) inline nsPoint
-    ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const;
-
-  __attribute__ ((warn_unused_result)) inline nsPoint
-    RemoveResolution(const float resolution) const;
-  __attribute__ ((warn_unused_result)) inline nsPoint
-    ApplyResolution(const float resolution) const;
-};
-
-inline nsPoint ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel);
-
-inline nsIntPoint
-nsPoint::ScaleToNearestPixels(float aXScale, float aYScale,
-                              nscoord aAppUnitsPerPixel) const
-{
-  return nsIntPoint(
-      NSToIntRoundUp(NSAppUnitsToDoublePixels(x, aAppUnitsPerPixel) * aXScale),
-      NSToIntRoundUp(NSAppUnitsToDoublePixels(y, aAppUnitsPerPixel) * aYScale));
-}
-
-inline nsIntPoint
-nsPoint::ToNearestPixels(nscoord aAppUnitsPerPixel) const
-{
-  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
-}
-
-inline nsPoint
-nsPoint::ScaleToOtherAppUnits(int32_t aFromAPP, int32_t aToAPP) const
-{
-  if (aFromAPP != aToAPP) {
-    nsPoint point;
-    point.x = NSToCoordRound(NSCoordScale(x, aFromAPP, aToAPP));
-    point.y = NSToCoordRound(NSCoordScale(y, aFromAPP, aToAPP));
-    return point;
-  }
-  return *this;
-}
-
-inline nsPoint
-nsPoint::RemoveResolution(const float resolution) const {
-  if (resolution != 1.0f) {
-    nsPoint point;
-    point.x = NSToCoordRound(NSCoordToFloat(x) / resolution);
-    point.y = NSToCoordRound(NSCoordToFloat(y) / resolution);
-    return point;
-  }
-  return *this;
-}
-
-inline nsPoint
-nsPoint::ApplyResolution(const float resolution) const {
-  if (resolution != 1.0f) {
-    nsPoint point;
-    point.x = NSToCoordRound(NSCoordToFloat(x) * resolution);
-    point.y = NSToCoordRound(NSCoordToFloat(y) * resolution);
-    return point;
-  }
-  return *this;
-}
-
-
-inline nsPoint
-ToAppUnits(const nsIntPoint& aPoint, nscoord aAppUnitsPerPixel)
-{
-  return nsPoint(NSIntPixelsToAppUnits(aPoint.x, aAppUnitsPerPixel),
-                 NSIntPixelsToAppUnits(aPoint.y, aAppUnitsPerPixel));
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseMargin.h"
-namespace mozilla {
-
-
-
-
-struct Sides final {
-  Sides() : mBits(0) {}
-  explicit Sides(SideBits aSideBits)
-  {
-    do { } while (0);
-    mBits = aSideBits;
-  }
-  bool IsEmpty() const { return mBits == 0; }
-  bool Top() const { return (mBits & eSideBitsTop) != 0; }
-  bool Right() const { return (mBits & eSideBitsRight) != 0; }
-  bool Bottom() const { return (mBits & eSideBitsBottom) != 0; }
-  bool Left() const { return (mBits & eSideBitsLeft) != 0; }
-  bool Contains(SideBits aSideBits) const
-  {
-    do { } while (0);
-    return (mBits & aSideBits) == aSideBits;
-  }
-  Sides operator|(Sides aOther) const
-  {
-    return Sides(SideBits(mBits | aOther.mBits));
-  }
-  Sides operator|(SideBits aSideBits) const
-  {
-    return *this | Sides(aSideBits);
-  }
-  Sides& operator|=(Sides aOther)
-  {
-    mBits |= aOther.mBits;
-    return *this;
-  }
-  Sides& operator|=(SideBits aSideBits)
-  {
-    return *this |= Sides(aSideBits);
-  }
-  bool operator==(Sides aOther) const
-  {
-    return mBits == aOther.mBits;
-  }
-  bool operator!=(Sides aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-private:
-  uint8_t mBits;
-};
-
-namespace gfx {
-
-
-
-
-
-template <class T, class Sub>
-struct BaseMargin {
-  typedef mozilla::Side SideT;
-
-
-
-  T top, right, bottom, left;
-
-
-  BaseMargin() : top(0), right(0), bottom(0), left(0) {}
-  BaseMargin(T aTop, T aRight, T aBottom, T aLeft) :
-      top(aTop), right(aRight), bottom(aBottom), left(aLeft) {}
-
-  void SizeTo(T aTop, T aRight, T aBottom, T aLeft)
-  {
-    top = aTop; right = aRight; bottom = aBottom; left = aLeft;
-  }
-
-  T LeftRight() const { return left + right; }
-  T TopBottom() const { return top + bottom; }
-
-  T& Side(SideT aSide) {
-
-    return *(&top + int(aSide));
-  }
-  T Side(SideT aSide) const {
-
-    return *(&top + int(aSide));
-  }
-
-  void ApplySkipSides(Sides aSkipSides)
-  {
-    if (aSkipSides.Top()) {
-      top = 0;
-    }
-    if (aSkipSides.Right()) {
-      right = 0;
-    }
-    if (aSkipSides.Bottom()) {
-      bottom = 0;
-    }
-    if (aSkipSides.Left()) {
-      left = 0;
-    }
-  }
-
-
-
-  bool operator==(const Sub& aMargin) const {
-    return top == aMargin.top && right == aMargin.right &&
-           bottom == aMargin.bottom && left == aMargin.left;
-  }
-  bool operator!=(const Sub& aMargin) const {
-    return !(*this == aMargin);
-  }
-  Sub operator+(const Sub& aMargin) const {
-    return Sub(top + aMargin.top, right + aMargin.right,
-               bottom + aMargin.bottom, left + aMargin.left);
-  }
-  Sub operator-(const Sub& aMargin) const {
-    return Sub(top - aMargin.top, right - aMargin.right,
-               bottom - aMargin.bottom, left - aMargin.left);
-  }
-  Sub& operator+=(const Sub& aMargin) {
-    top += aMargin.top;
-    right += aMargin.right;
-    bottom += aMargin.bottom;
-    left += aMargin.left;
-    return *static_cast<Sub*>(this);
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream,
-      const BaseMargin& aMargin) {
-    return aStream << '(' << aMargin.top << ',' << aMargin.right << ','
-                  << aMargin.bottom << ',' << aMargin.left << ')';
-  }
-};
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h" 2
-
-
-
-
-
-
-
-namespace mozilla {
-namespace gfx {
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
-template <class T, class Sub, class Point, class SizeT, class MarginT>
-struct BaseRect {
-  T x, y, width, height;
-
-
-  BaseRect() : x(0), y(0), width(0), height(0) {}
-  BaseRect(const Point& aOrigin, const SizeT &aSize) :
-      x(aOrigin.x), y(aOrigin.y), width(aSize.width), height(aSize.height)
-  {
-  }
-  BaseRect(T aX, T aY, T aWidth, T aHeight) :
-      x(aX), y(aY), width(aWidth), height(aHeight)
-  {
-  }
-
-
-
-  bool IsEmpty() const { return height <= 0 || width <= 0; }
-  void SetEmpty() { width = height = 0; }
-
-
-  bool IsFinite() const
-  {
-    typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
-    return (mozilla::IsFinite(FloatType(x)) &&
-            mozilla::IsFinite(FloatType(y)) &&
-            mozilla::IsFinite(FloatType(width)) &&
-            mozilla::IsFinite(FloatType(height)));
-  }
-
-
-
-
-  bool Contains(const Sub& aRect) const
-  {
-    return aRect.IsEmpty() ||
-           (x <= aRect.x && aRect.XMost() <= XMost() &&
-            y <= aRect.y && aRect.YMost() <= YMost());
-  }
-
-
-
-  bool Contains(T aX, T aY) const
-  {
-    return x <= aX && aX < XMost() &&
-           y <= aY && aY < YMost();
-  }
-
-
-
-  bool Contains(const Point& aPoint) const { return Contains(aPoint.x, aPoint.y); }
-
-
-
-
-  bool Intersects(const Sub& aRect) const
-  {
-    return !IsEmpty() && !aRect.IsEmpty() &&
-           x < aRect.XMost() && aRect.x < XMost() &&
-           y < aRect.YMost() && aRect.y < YMost();
-  }
-
-
-
-
-  __attribute__ ((warn_unused_result)) Sub Intersect(const Sub& aRect) const
-  {
-    Sub result;
-    result.x = std::max<T>(x, aRect.x);
-    result.y = std::max<T>(y, aRect.y);
-    result.width = std::min<T>(x - result.x + width, aRect.x - result.x + aRect.width);
-    result.height = std::min<T>(y - result.y + height, aRect.y - result.y + aRect.height);
-    if (result.width < 0 || result.height < 0) {
-      result.SizeTo(0, 0);
-    }
-    return result;
-  }
-
-
-
-
-
-
-  bool IntersectRect(const Sub& aRect1, const Sub& aRect2)
-  {
-    *static_cast<Sub*>(this) = aRect1.Intersect(aRect2);
-    return !IsEmpty();
-  }
-
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) Sub Union(const Sub& aRect) const
-  {
-    if (IsEmpty()) {
-      return aRect;
-    } else if (aRect.IsEmpty()) {
-      return *static_cast<const Sub*>(this);
-    } else {
-      return UnionEdges(aRect);
-    }
-  }
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) Sub UnionEdges(const Sub& aRect) const
-  {
-    Sub result;
-    result.x = std::min(x, aRect.x);
-    result.y = std::min(y, aRect.y);
-    result.width = std::max(XMost(), aRect.XMost()) - result.x;
-    result.height = std::max(YMost(), aRect.YMost()) - result.y;
-    return result;
-  }
-
-
-
-
-
-
-  void UnionRect(const Sub& aRect1, const Sub& aRect2)
-  {
-    *static_cast<Sub*>(this) = aRect1.Union(aRect2);
-  }
-
-
-
-
-
-
-  void UnionRectEdges(const Sub& aRect1, const Sub& aRect2)
-  {
-    *static_cast<Sub*>(this) = aRect1.UnionEdges(aRect2);
-  }
-
-
-  void ExpandToEnclose(const Point& aPoint)
-  {
-    if (aPoint.x < x) {
-      width = XMost() - aPoint.x;
-      x = aPoint.x;
-    } else if (aPoint.x > XMost()) {
-      width = aPoint.x - x;
-    }
-    if (aPoint.y < y) {
-      height = YMost() - aPoint.y;
-      y = aPoint.y;
-    } else if (aPoint.y > YMost()) {
-      height = aPoint.y - y;
-    }
-  }
-
-  void SetRect(T aX, T aY, T aWidth, T aHeight)
-  {
-    x = aX; y = aY; width = aWidth; height = aHeight;
-  }
-  void SetRect(const Point& aPt, const SizeT& aSize)
-  {
-    SetRect(aPt.x, aPt.y, aSize.width, aSize.height);
-  }
-  void MoveTo(T aX, T aY) { x = aX; y = aY; }
-  void MoveTo(const Point& aPoint) { x = aPoint.x; y = aPoint.y; }
-  void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; }
-  void MoveBy(const Point& aPoint) { x += aPoint.x; y += aPoint.y; }
-  void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; }
-  void SizeTo(const SizeT& aSize) { width = aSize.width; height = aSize.height; }
-
-  void Inflate(T aD) { Inflate(aD, aD); }
-  void Inflate(T aDx, T aDy)
-  {
-    x -= aDx;
-    y -= aDy;
-    width += 2 * aDx;
-    height += 2 * aDy;
-  }
-  void Inflate(const MarginT& aMargin)
-  {
-    x -= aMargin.left;
-    y -= aMargin.top;
-    width += aMargin.LeftRight();
-    height += aMargin.TopBottom();
-  }
-  void Inflate(const SizeT& aSize) { Inflate(aSize.width, aSize.height); }
-
-  void Deflate(T aD) { Deflate(aD, aD); }
-  void Deflate(T aDx, T aDy)
-  {
-    x += aDx;
-    y += aDy;
-    width = std::max(T(0), width - 2 * aDx);
-    height = std::max(T(0), height - 2 * aDy);
-  }
-  void Deflate(const MarginT& aMargin)
-  {
-    x += aMargin.left;
-    y += aMargin.top;
-    width = std::max(T(0), width - aMargin.LeftRight());
-    height = std::max(T(0), height - aMargin.TopBottom());
-  }
-  void Deflate(const SizeT& aSize) { Deflate(aSize.width, aSize.height); }
-
-
-
-
-
-  bool IsEqualEdges(const Sub& aRect) const
-  {
-    return x == aRect.x && y == aRect.y &&
-           width == aRect.width && height == aRect.height;
-  }
-
-
-  bool IsEqualInterior(const Sub& aRect) const
-  {
-    return IsEqualEdges(aRect) || (IsEmpty() && aRect.IsEmpty());
-  }
-
-  friend Sub operator+(Sub aSub, const Point& aPoint)
-  {
-    aSub += aPoint;
-    return aSub;
-  }
-  friend Sub operator-(Sub aSub, const Point& aPoint)
-  {
-    aSub -= aPoint;
-    return aSub;
-  }
-  friend Sub operator+(Sub aSub, const SizeT& aSize)
-  {
-    aSub += aSize;
-    return aSub;
-  }
-  friend Sub operator-(Sub aSub, const SizeT& aSize)
-  {
-    aSub -= aSize;
-    return aSub;
-  }
-  Sub& operator+=(const Point& aPoint)
-  {
-    MoveBy(aPoint);
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const Point& aPoint)
-  {
-    MoveBy(-aPoint);
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator+=(const SizeT& aSize)
-  {
-    width += aSize.width;
-    height += aSize.height;
-    return *static_cast<Sub*>(this);
-  }
-  Sub& operator-=(const SizeT& aSize)
-  {
-    width -= aSize.width;
-    height -= aSize.height;
-    return *static_cast<Sub*>(this);
-  }
-
-  MarginT operator-(const Sub& aRect) const
-  {
-    return MarginT(aRect.y - y,
-                   XMost() - aRect.XMost(),
-                   YMost() - aRect.YMost(),
-                   aRect.x - x);
-  }
-
-
-  Point TopLeft() const { return Point(x, y); }
-  Point TopRight() const { return Point(XMost(), y); }
-  Point BottomLeft() const { return Point(x, YMost()); }
-  Point BottomRight() const { return Point(XMost(), YMost()); }
-  Point AtCorner(Corner aCorner) const {
-    switch (aCorner) {
-      case eCornerTopLeft: return TopLeft();
-      case eCornerTopRight: return TopRight();
-      case eCornerBottomRight: return BottomRight();
-      case eCornerBottomLeft: return BottomLeft();
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 329; ::abort(); } while (0); } while (0);
-  }
-  Point CCWCorner(mozilla::Side side) const {
-    switch (side) {
-      case eSideTop: return TopLeft();
-      case eSideRight: return TopRight();
-      case eSideBottom: return BottomRight();
-      case eSideLeft: return BottomLeft();
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 338; ::abort(); } while (0); } while (0);
-  }
-  Point CWCorner(mozilla::Side side) const {
-    switch (side) {
-      case eSideTop: return TopRight();
-      case eSideRight: return BottomRight();
-      case eSideBottom: return BottomLeft();
-      case eSideLeft: return TopLeft();
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 347; ::abort(); } while (0); } while (0);
-  }
-  Point Center() const { return Point(x, y) + Point(width, height)/2; }
-  SizeT Size() const { return SizeT(width, height); }
-
-  T Area() const { return width * height; }
-
-
-  T X() const { return x; }
-  T Y() const { return y; }
-  T Width() const { return width; }
-  T Height() const { return height; }
-  T XMost() const { return x + width; }
-  T YMost() const { return y + height; }
-
-
-  T Edge(mozilla::Side aSide) const
-  {
-    switch (aSide) {
-      case eSideTop: return Y();
-      case eSideRight: return XMost();
-      case eSideBottom: return YMost();
-      case eSideLeft: return X();
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "GFX: Incomplete switch" ")"); do { *((volatile int*) __null) = 371; ::abort(); } while (0); } while (0);
-  }
-
-
-  void SetLeftEdge(T aX) {
-    do { } while (0);
-    width = XMost() - aX;
-    x = aX;
-  }
-  void SetRightEdge(T aXMost) {
-    do { } while (0);
-    width = aXMost - x;
-  }
-  void SetTopEdge(T aY) {
-    do { } while (0);
-    height = YMost() - aY;
-    y = aY;
-  }
-  void SetBottomEdge(T aYMost) {
-    do { } while (0);
-    height = aYMost - y;
-  }
-# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/BaseRect.h"
-  void Round()
-  {
-    T x0 = static_cast<T>(floor(T(X()) + 0.5));
-    T y0 = static_cast<T>(floor(T(Y()) + 0.5));
-    T x1 = static_cast<T>(floor(T(XMost()) + 0.5));
-    T y1 = static_cast<T>(floor(T(YMost()) + 0.5));
-
-    x = x0;
-    y = y0;
-
-    width = x1 - x0;
-    height = y1 - y0;
-  }
-
-
-
-  void RoundIn()
-  {
-    T x0 = static_cast<T>(ceil(T(X())));
-    T y0 = static_cast<T>(ceil(T(Y())));
-    T x1 = static_cast<T>(floor(T(XMost())));
-    T y1 = static_cast<T>(floor(T(YMost())));
-
-    x = x0;
-    y = y0;
-
-    width = x1 - x0;
-    height = y1 - y0;
-  }
-
-
-
-  void RoundOut()
-  {
-    T x0 = static_cast<T>(floor(T(X())));
-    T y0 = static_cast<T>(floor(T(Y())));
-    T x1 = static_cast<T>(ceil(T(XMost())));
-    T y1 = static_cast<T>(ceil(T(YMost())));
-
-    x = x0;
-    y = y0;
-
-    width = x1 - x0;
-    height = y1 - y0;
-  }
-
-
-  void Scale(T aScale) { Scale(aScale, aScale); }
-
-  void Scale(T aXScale, T aYScale)
-  {
-    T right = XMost() * aXScale;
-    T bottom = YMost() * aYScale;
-    x = x * aXScale;
-    y = y * aYScale;
-    width = right - x;
-    height = bottom - y;
-  }
-
-
-
-  void ScaleRoundOut(double aScale) { ScaleRoundOut(aScale, aScale); }
-
-
-
-
-  void ScaleRoundOut(double aXScale, double aYScale)
-  {
-    T right = static_cast<T>(ceil(double(XMost()) * aXScale));
-    T bottom = static_cast<T>(ceil(double(YMost()) * aYScale));
-    x = static_cast<T>(floor(double(x) * aXScale));
-    y = static_cast<T>(floor(double(y) * aYScale));
-    width = right - x;
-    height = bottom - y;
-  }
-
-
-  void ScaleRoundIn(double aScale) { ScaleRoundIn(aScale, aScale); }
-
-
-
-  void ScaleRoundIn(double aXScale, double aYScale)
-  {
-    T right = static_cast<T>(floor(double(XMost()) * aXScale));
-    T bottom = static_cast<T>(floor(double(YMost()) * aYScale));
-    x = static_cast<T>(ceil(double(x) * aXScale));
-    y = static_cast<T>(ceil(double(y) * aYScale));
-    width = std::max<T>(0, right - x);
-    height = std::max<T>(0, bottom - y);
-  }
-
-
-
-  void ScaleInverseRoundOut(double aScale) { ScaleInverseRoundOut(aScale, aScale); }
-
-
-
-
-  void ScaleInverseRoundOut(double aXScale, double aYScale)
-  {
-    T right = static_cast<T>(ceil(double(XMost()) / aXScale));
-    T bottom = static_cast<T>(ceil(double(YMost()) / aYScale));
-    x = static_cast<T>(floor(double(x) / aXScale));
-    y = static_cast<T>(floor(double(y) / aYScale));
-    width = right - x;
-    height = bottom - y;
-  }
-
-
-  void ScaleInverseRoundIn(double aScale) { ScaleInverseRoundIn(aScale, aScale); }
-
-
-
-  void ScaleInverseRoundIn(double aXScale, double aYScale)
-  {
-    T right = static_cast<T>(floor(double(XMost()) / aXScale));
-    T bottom = static_cast<T>(floor(double(YMost()) / aYScale));
-    x = static_cast<T>(ceil(double(x) / aXScale));
-    y = static_cast<T>(ceil(double(y) / aYScale));
-    width = std::max<T>(0, right - x);
-    height = std::max<T>(0, bottom - y);
-  }
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) Point ClampPoint(const Point& aPoint) const
-  {
-    return Point(std::max(x, std::min(XMost(), aPoint.x)),
-                 std::max(y, std::min(YMost(), aPoint.y)));
-  }
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) Sub MoveInsideAndClamp(const Sub& aRect) const
-  {
-    Sub rect(std::max(aRect.x, x),
-             std::max(aRect.y, y),
-             std::min(aRect.width, width),
-             std::min(aRect.height, height));
-    rect.x = std::min(rect.XMost(), aRect.XMost()) - rect.width;
-    rect.y = std::min(rect.YMost(), aRect.YMost()) - rect.height;
-    return rect;
-  }
-
-
-
-
-
-
-
-  static Sub MaxIntRect()
-  {
-    return Sub(
-      static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
-      static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
-      static_cast<T>(std::numeric_limits<int32_t>::max()),
-      static_cast<T>(std::numeric_limits<int32_t>::max())
-    );
-  };
-
-  friend std::ostream& operator<<(std::ostream& stream,
-      const BaseRect<T, Sub, Point, SizeT, MarginT>& aRect) {
-    return stream << '(' << aRect.x << ',' << aRect.y << ','
-                  << aRect.width << ',' << aRect.height << ')';
-  }
-
-private:
-
-
-  bool operator==(const Sub& aRect) const { return false; }
-  bool operator!=(const Sub& aRect) const { return false; }
-};
-
-}
-}
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/NumericTools.h" 1
-
-
-
-
-
-
-
-
-namespace mozilla {
-
-
-
-
-
-
-inline int32_t
-RoundDownToMultiple(int32_t x, int32_t aMultiplier)
-{
-
-
-  int mod = x % aMultiplier;
-  if (x > 0) {
-    return x - mod;
-  }
-  return mod ? x - aMultiplier - mod : x;
-}
-
-
-
-
-inline int32_t
-RoundUpToMultiple(int32_t x, int32_t aMultiplier)
-{
-  int mod = x % aMultiplier;
-  if (x > 0) {
-    return mod ? x + aMultiplier - mod : x;
-  }
-  return x - mod;
-}
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-namespace mozilla {
-
-template<typename T> class CheckedInt;
-
-namespace detail {
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-struct UnsupportedType {};
-
-template<typename IntegerType>
-struct IsSupportedPass2
-{
-  static const bool value = false;
-};
-
-template<typename IntegerType>
-struct IsSupported
-{
-  static const bool value = IsSupportedPass2<IntegerType>::value;
-};
-
-template<>
-struct IsSupported<int8_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<uint8_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<int16_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<uint16_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<int32_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<uint32_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<int64_t>
-{ static const bool value = true; };
-
-template<>
-struct IsSupported<uint64_t>
-{ static const bool value = true; };
-
-
-template<>
-struct IsSupportedPass2<char>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<signed char>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<unsigned char>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<short>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<unsigned short>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<int>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<unsigned int>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<long>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<unsigned long>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<long long>
-{ static const bool value = true; };
-
-template<>
-struct IsSupportedPass2<unsigned long long>
-{ static const bool value = true; };
-
-
-
-
-
-
-
-template<typename IntegerType, size_t Size = sizeof(IntegerType)>
-struct TwiceBiggerType
-{
-  typedef typename detail::StdintTypeForSizeAndSignedness<
-                     sizeof(IntegerType) * 2,
-                     IsSigned<IntegerType>::value
-                   >::Type Type;
-};
-
-template<typename IntegerType>
-struct TwiceBiggerType<IntegerType, 8>
-{
-  typedef UnsupportedType Type;
-};
-
-template<typename T>
-inline bool
-HasSignBit(T aX)
-{
-
-
-
-
-  return bool(typename MakeUnsigned<T>::Type(aX) >>
-              PositionOfSignBit<T>::value);
-}
-
-
-
-template<typename T>
-inline T
-BinaryComplement(T aX)
-{
-  return ~aX;
-}
-
-template<typename T,
-         typename U,
-         bool IsTSigned = IsSigned<T>::value,
-         bool IsUSigned = IsSigned<U>::value>
-struct DoesRangeContainRange
-{
-};
-
-template<typename T, typename U, bool Signedness>
-struct DoesRangeContainRange<T, U, Signedness, Signedness>
-{
-  static const bool value = sizeof(T) >= sizeof(U);
-};
-
-template<typename T, typename U>
-struct DoesRangeContainRange<T, U, true, false>
-{
-  static const bool value = sizeof(T) > sizeof(U);
-};
-
-template<typename T, typename U>
-struct DoesRangeContainRange<T, U, false, true>
-{
-  static const bool value = false;
-};
-
-template<typename T,
-         typename U,
-         bool IsTSigned = IsSigned<T>::value,
-         bool IsUSigned = IsSigned<U>::value,
-         bool DoesTRangeContainURange = DoesRangeContainRange<T, U>::value>
-struct IsInRangeImpl {};
-
-template<typename T, typename U, bool IsTSigned, bool IsUSigned>
-struct IsInRangeImpl<T, U, IsTSigned, IsUSigned, true>
-{
-  static bool constexpr run(U)
-  {
-    return true;
-  }
-};
-
-template<typename T, typename U>
-struct IsInRangeImpl<T, U, true, true, false>
-{
-  static bool constexpr run(U aX)
-  {
-    return aX <= MaxValue<T>::value && aX >= MinValue<T>::value;
-  }
-};
-
-template<typename T, typename U>
-struct IsInRangeImpl<T, U, false, false, false>
-{
-  static bool constexpr run(U aX)
-  {
-    return aX <= MaxValue<T>::value;
-  }
-};
-
-template<typename T, typename U>
-struct IsInRangeImpl<T, U, true, false, false>
-{
-  static bool constexpr run(U aX)
-  {
-    return sizeof(T) > sizeof(U) || aX <= U(MaxValue<T>::value);
-  }
-};
-
-template<typename T, typename U>
-struct IsInRangeImpl<T, U, false, true, false>
-{
-  static bool constexpr run(U aX)
-  {
-    return sizeof(T) >= sizeof(U)
-           ? aX >= 0
-           : aX >= 0 && aX <= U(MaxValue<T>::value);
-  }
-};
-
-template<typename T, typename U>
-inline constexpr bool
-IsInRange(U aX)
-{
-  return IsInRangeImpl<T, U>::run(aX);
-}
-
-template<typename T>
-inline bool
-IsAddValid(T aX, T aY)
-{
-
-
-
-
-
-
-  typename MakeUnsigned<T>::Type ux = aX;
-  typename MakeUnsigned<T>::Type uy = aY;
-  typename MakeUnsigned<T>::Type result = ux + uy;
-  return IsSigned<T>::value
-         ? HasSignBit(BinaryComplement(T((result ^ aX) & (result ^ aY))))
-         : BinaryComplement(aX) >= aY;
-}
-
-template<typename T>
-inline bool
-IsSubValid(T aX, T aY)
-{
-
-
-
-  typename MakeUnsigned<T>::Type ux = aX;
-  typename MakeUnsigned<T>::Type uy = aY;
-  typename MakeUnsigned<T>::Type result = ux - uy;
-
-  return IsSigned<T>::value
-         ? HasSignBit(BinaryComplement(T((result ^ aX) & (aX ^ aY))))
-         : aX >= aY;
-}
-
-template<typename T,
-         bool IsTSigned = IsSigned<T>::value,
-         bool TwiceBiggerTypeIsSupported =
-           IsSupported<typename TwiceBiggerType<T>::Type>::value>
-struct IsMulValidImpl {};
-
-template<typename T, bool IsTSigned>
-struct IsMulValidImpl<T, IsTSigned, true>
-{
-  static bool run(T aX, T aY)
-  {
-    typedef typename TwiceBiggerType<T>::Type TwiceBiggerType;
-    TwiceBiggerType product = TwiceBiggerType(aX) * TwiceBiggerType(aY);
-    return IsInRange<T>(product);
-  }
-};
-
-template<typename T>
-struct IsMulValidImpl<T, true, false>
-{
-  static bool run(T aX, T aY)
-  {
-    const T max = MaxValue<T>::value;
-    const T min = MinValue<T>::value;
-
-    if (aX == 0 || aY == 0) {
-      return true;
-    }
-    if (aX > 0) {
-      return aY > 0
-             ? aX <= max / aY
-             : aY >= min / aX;
-    }
-
-
-    return aY > 0
-           ? aX >= min / aY
-           : aY >= max / aX;
-  }
-};
-
-template<typename T>
-struct IsMulValidImpl<T, false, false>
-{
-  static bool run(T aX, T aY)
-  {
-    return aY == 0 || aX <= MaxValue<T>::value / aY;
-  }
-};
-
-template<typename T>
-inline bool
-IsMulValid(T aX, T aY)
-{
-  return IsMulValidImpl<T>::run(aX, aY);
-}
-
-template<typename T>
-inline bool
-IsDivValid(T aX, T aY)
-{
-
-
-  return aY != 0 &&
-         !(IsSigned<T>::value && aX == MinValue<T>::value && aY == T(-1));
-}
-
-template<typename T, bool IsTSigned = IsSigned<T>::value>
-struct IsModValidImpl;
-
-template<typename T>
-inline bool
-IsModValid(T aX, T aY)
-{
-  return IsModValidImpl<T>::run(aX, aY);
-}
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-template<typename T>
-struct IsModValidImpl<T, false>
-{
-  static inline bool run(T aX, T aY)
-  {
-    return aY >= 1;
-  }
-};
-
-template<typename T>
-struct IsModValidImpl<T, true>
-{
-  static inline bool run(T aX, T aY)
-  {
-    if (aX < 0) {
-      return false;
-    }
-    return aY >= 1;
-  }
-};
-
-template<typename T, bool IsSigned = IsSigned<T>::value>
-struct NegateImpl;
-
-template<typename T>
-struct NegateImpl<T, false>
-{
-  static CheckedInt<T> negate(const CheckedInt<T>& aVal)
-  {
-
-
-    return CheckedInt<T>(0, aVal.isValid() && aVal.mValue == 0);
-  }
-};
-
-template<typename T>
-struct NegateImpl<T, true>
-{
-  static CheckedInt<T> negate(const CheckedInt<T>& aVal)
-  {
-
-
-    if (!aVal.isValid() || aVal.mValue == MinValue<T>::value) {
-      return CheckedInt<T>(aVal.mValue, false);
-    }
-    return CheckedInt<T>(-aVal.mValue, true);
-  }
-};
-
-}
-# 499 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-template<typename T>
-class CheckedInt
-{
-protected:
-  T mValue;
-  bool mIsValid;
-
-  template<typename U>
-  CheckedInt(U aValue, bool aIsValid) : mValue(aValue), mIsValid(aIsValid)
-  {
-    static_assert(detail::IsSupported<T>::value &&
-                  detail::IsSupported<U>::value,
-                  "This type is not supported by CheckedInt");
-  }
-
-  friend struct detail::NegateImpl<T>;
-
-public:
-# 528 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-  template<typename U>
-               constexpr CheckedInt(U aValue)
-    : mValue(T(aValue)),
-      mIsValid(detail::IsInRange<T>(aValue))
-  {
-    static_assert(detail::IsSupported<T>::value &&
-                  detail::IsSupported<U>::value,
-                  "This type is not supported by CheckedInt");
-  }
-
-  template<typename U>
-  friend class CheckedInt;
-
-  template<typename U>
-  CheckedInt<U> toChecked() const
-  {
-    CheckedInt<U> ret(mValue);
-    ret.mIsValid = ret.mIsValid && mIsValid;
-    return ret;
-  }
-
-
-  constexpr CheckedInt() : mValue(0), mIsValid(true)
-  {
-    static_assert(detail::IsSupported<T>::value,
-                  "This type is not supported by CheckedInt");
-  }
-
-
-  T value() const
-  {
-    do { } while (0);
-    return mValue;
-  }
-
-
-
-
-
-
-  bool isValid() const
-  {
-    return mIsValid;
-  }
-
-  template<typename U>
-  friend CheckedInt<U> operator +(const CheckedInt<U>& aLhs,
-                                  const CheckedInt<U>& aRhs);
-  template<typename U>
-  CheckedInt& operator +=(U aRhs);
-  CheckedInt& operator +=(const CheckedInt<T>& aRhs);
-
-  template<typename U>
-  friend CheckedInt<U> operator -(const CheckedInt<U>& aLhs,
-                                  const CheckedInt<U>& aRhs);
-  template<typename U>
-  CheckedInt& operator -=(U aRhs);
-  CheckedInt& operator -=(const CheckedInt<T>& aRhs);
-
-  template<typename U>
-  friend CheckedInt<U> operator *(const CheckedInt<U>& aLhs,
-                                  const CheckedInt<U>& aRhs);
-  template<typename U>
-  CheckedInt& operator *=(U aRhs);
-  CheckedInt& operator *=(const CheckedInt<T>& aRhs);
-
-  template<typename U>
-  friend CheckedInt<U> operator /(const CheckedInt<U>& aLhs,
-                                  const CheckedInt<U>& aRhs);
-  template<typename U>
-  CheckedInt& operator /=(U aRhs);
-  CheckedInt& operator /=(const CheckedInt<T>& aRhs);
-
-  template<typename U>
-  friend CheckedInt<U> operator %(const CheckedInt<U>& aLhs,
-                                  const CheckedInt<U>& aRhs);
-  template<typename U>
-  CheckedInt& operator %=(U aRhs);
-  CheckedInt& operator %=(const CheckedInt<T>& aRhs);
-
-  CheckedInt operator -() const
-  {
-    return detail::NegateImpl<T>::negate(*this);
-  }
-# 631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-  bool operator ==(const CheckedInt& aOther) const
-  {
-    return mIsValid && aOther.mIsValid && mValue == aOther.mValue;
-  }
-
-
-  CheckedInt& operator++()
-  {
-    *this += 1;
-    return *this;
-  }
-
-
-  CheckedInt operator++(int)
-  {
-    CheckedInt tmp = *this;
-    *this += 1;
-    return tmp;
-  }
-
-
-  CheckedInt& operator--()
-  {
-    *this -= 1;
-    return *this;
-  }
-
-
-  CheckedInt operator--(int)
-  {
-    CheckedInt tmp = *this;
-    *this -= 1;
-    return tmp;
-  }
-
-private:
-
-
-
-
-  template<typename U> bool operator !=(U aOther) const = delete;
-  template<typename U> bool operator < (U aOther) const = delete;
-  template<typename U> bool operator <=(U aOther) const = delete;
-  template<typename U> bool operator > (U aOther) const = delete;
-  template<typename U> bool operator >=(U aOther) const = delete;
-};
-# 690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-template<typename T> inline CheckedInt<T> operator +(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsAddValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue + aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
-template<typename T> inline CheckedInt<T> operator -(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsSubValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue - aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
-template<typename T> inline CheckedInt<T> operator *(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsMulValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue * aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
-template<typename T> inline CheckedInt<T> operator /(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsDivValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue / aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
-template<typename T> inline CheckedInt<T> operator %(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs) { if (!detail::IsModValid(aLhs.mValue, aRhs.mValue)) { return CheckedInt<T>(0, false); } return CheckedInt<T>(aLhs.mValue % aRhs.mValue, aLhs.mIsValid && aRhs.mIsValid); }
-# 704 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-namespace detail {
-
-template<typename T, typename U>
-struct CastToCheckedIntImpl
-{
-  typedef CheckedInt<T> ReturnType;
-  static CheckedInt<T> run(U aU) { return aU; }
-};
-
-template<typename T>
-struct CastToCheckedIntImpl<T, CheckedInt<T> >
-{
-  typedef const CheckedInt<T>& ReturnType;
-  static const CheckedInt<T>& run(const CheckedInt<T>& aU) { return aU; }
-};
-
-}
-
-template<typename T, typename U>
-inline typename detail::CastToCheckedIntImpl<T, U>::ReturnType
-castToCheckedInt(U aU)
-{
-  static_assert(detail::IsSupported<T>::value &&
-                detail::IsSupported<U>::value,
-                "This type is not supported by CheckedInt");
-  return detail::CastToCheckedIntImpl<T, U>::run(aU);
-}
-# 757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CheckedInt.h"
-template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator +=(U aRhs) { *this = *this + castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator +=(const CheckedInt<T>& aRhs) { *this = *this + aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator +(const CheckedInt<T>& aLhs, U aRhs) { return aLhs + castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator +(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) + aRhs; }
-template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator *=(U aRhs) { *this = *this * castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator *=(const CheckedInt<T>& aRhs) { *this = *this * aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator *(const CheckedInt<T>& aLhs, U aRhs) { return aLhs * castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator *(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) * aRhs; }
-template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator -=(U aRhs) { *this = *this - castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator -=(const CheckedInt<T>& aRhs) { *this = *this - aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator -(const CheckedInt<T>& aLhs, U aRhs) { return aLhs - castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator -(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) - aRhs; }
-template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator /=(U aRhs) { *this = *this / castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator /=(const CheckedInt<T>& aRhs) { *this = *this / aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator /(const CheckedInt<T>& aLhs, U aRhs) { return aLhs / castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator /(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) / aRhs; }
-template<typename T> template<typename U> CheckedInt<T>& CheckedInt<T>::operator %=(U aRhs) { *this = *this % castToCheckedInt<T>(aRhs); return *this; } template<typename T> CheckedInt<T>& CheckedInt<T>::operator %=(const CheckedInt<T>& aRhs) { *this = *this % aRhs; return *this; } template<typename T, typename U> inline CheckedInt<T> operator %(const CheckedInt<T>& aLhs, U aRhs) { return aLhs % castToCheckedInt<T>(aRhs); } template<typename T, typename U> inline CheckedInt<T> operator %(U aLhs, const CheckedInt<T>& aRhs) { return castToCheckedInt<T>(aLhs) % aRhs; }
-
-
-
-template<typename T, typename U>
-inline bool
-operator ==(const CheckedInt<T>& aLhs, U aRhs)
-{
-  return aLhs == castToCheckedInt<T>(aRhs);
-}
-
-template<typename T, typename U>
-inline bool
-operator ==(U aLhs, const CheckedInt<T>& aRhs)
-{
-  return castToCheckedInt<T>(aLhs) == aRhs;
-}
-
-
-typedef CheckedInt<int8_t> CheckedInt8;
-typedef CheckedInt<uint8_t> CheckedUint8;
-typedef CheckedInt<int16_t> CheckedInt16;
-typedef CheckedInt<uint16_t> CheckedUint16;
-typedef CheckedInt<int32_t> CheckedInt32;
-typedef CheckedInt<uint32_t> CheckedUint32;
-typedef CheckedInt<int64_t> CheckedInt64;
-typedef CheckedInt<uint64_t> CheckedUint64;
-
-}
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h" 2
-
-namespace mozilla {
-namespace gfx {
-
-static inline bool
-IsOperatorBoundByMask(CompositionOp aOp) {
-  switch (aOp) {
-  case CompositionOp::OP_IN:
-  case CompositionOp::OP_OUT:
-  case CompositionOp::OP_DEST_IN:
-  case CompositionOp::OP_DEST_ATOP:
-  case CompositionOp::OP_SOURCE:
-    return false;
-  default:
-    return true;
-  }
-}
-
-template <class T>
-struct ClassStorage
-{
-  char bytes[sizeof(T)];
-
-  const T *addr() const { return (const T *)bytes; }
-  T *addr() { return (T *)(void *)bytes; }
-};
-
-static inline bool
-FuzzyEqual(Float aA, Float aB, Float aErr)
-{
-  if ((aA + aErr >= aB) && (aA - aErr <= aB)) {
-    return true;
-  }
-  return false;
-}
-
-static inline void
-NudgeToInteger(float *aVal)
-{
-  float r = floorf(*aVal + 0.5f);
-
-
-
-
-
-  if (FuzzyEqual(r, *aVal, r == 0.0f ? 1e-6f : fabs(r*1e-6f))) {
-    *aVal = r;
-  }
-}
-
-static inline void
-NudgeToInteger(float *aVal, float aErr)
-{
-  float r = floorf(*aVal + 0.5f);
-  if (FuzzyEqual(r, *aVal, aErr)) {
-    *aVal = r;
-  }
-}
-
-static inline Float
-Distance(Point aA, Point aB)
-{
-  return hypotf(aB.x - aA.x, aB.y - aA.y);
-}
-
-static inline int
-BytesPerPixel(SurfaceFormat aFormat)
-{
-  switch (aFormat) {
-  case SurfaceFormat::A8:
-    return 1;
-  case SurfaceFormat::R5G6B5_UINT16:
-    return 2;
-  case SurfaceFormat::R8G8B8:
-  case SurfaceFormat::B8G8R8:
-    return 3;
-  case SurfaceFormat::HSV:
-  case SurfaceFormat::Lab:
-    return 3 * sizeof(float);
-  case SurfaceFormat::Depth:
-    return sizeof(uint16_t);
-  default:
-    return 4;
-  }
-}
-
-static inline bool
-IsOpaqueFormat(SurfaceFormat aFormat) {
-  switch (aFormat) {
-    case SurfaceFormat::B8G8R8X8:
-    case SurfaceFormat::R8G8B8X8:
-    case SurfaceFormat::X8R8G8B8:
-    case SurfaceFormat::YUV:
-    case SurfaceFormat::NV12:
-    case SurfaceFormat::YUV422:
-    case SurfaceFormat::R5G6B5_UINT16:
-      return true;
-    default:
-      return false;
-  }
-}
-
-template<typename T, int alignment = 16>
-struct AlignedArray
-{
-  typedef T value_type;
-
-  AlignedArray()
-    : mPtr(nullptr)
-    , mStorage(nullptr)
-  {
-  }
-
-  explicit __attribute__((always_inline)) inline AlignedArray(size_t aCount, bool aZero = false)
-    : mStorage(nullptr)
-    , mCount(0)
-  {
-    Realloc(aCount, aZero);
-  }
-
-  __attribute__((always_inline)) inline ~AlignedArray()
-  {
-    Dealloc();
-  }
-
-  void Dealloc()
-  {
-
-
-
-
-    static_assert(mozilla::IsPod<T>::value,
-                  "Destructors must be invoked for this type");
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h"
-    free(mStorage);
-    mStorage = nullptr;
-    mPtr = nullptr;
-  }
-
-  __attribute__((always_inline)) inline void Realloc(size_t aCount, bool aZero = false)
-  {
-    free(mStorage);
-    CheckedInt32 storageByteCount =
-      CheckedInt32(sizeof(T)) * aCount + (alignment - 1);
-    if (!storageByteCount.isValid()) {
-      mStorage = nullptr;
-      mPtr = nullptr;
-      mCount = 0;
-      return;
-    }
-
-
-    if (aZero) {
-
-
-      mStorage = static_cast<uint8_t *>(calloc(1, storageByteCount.value()));
-    } else {
-      mStorage = static_cast<uint8_t *>(malloc(storageByteCount.value()));
-    }
-    if (!mStorage) {
-      mStorage = nullptr;
-      mPtr = nullptr;
-      mCount = 0;
-      return;
-    }
-    if (uintptr_t(mStorage) % alignment) {
-
-      mPtr = (T*)(uintptr_t(mStorage) + alignment - (uintptr_t(mStorage) % alignment));
-    } else {
-      mPtr = (T*)(mStorage);
-    }
-
-
-
-
-    mPtr = new (mPtr) T[aCount];
-    mCount = aCount;
-  }
-
-  void Swap(AlignedArray<T, alignment>& aOther)
-  {
-    mozilla::Swap(mPtr, aOther.mPtr);
-    mozilla::Swap(mStorage, aOther.mStorage);
-    mozilla::Swap(mCount, aOther.mCount);
-  }
-
-  __attribute__((always_inline)) inline operator T*()
-  {
-    return mPtr;
-  }
-
-  T *mPtr;
-
-private:
-  uint8_t *mStorage;
-  size_t mCount;
-};
-# 230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Tools.h"
-template<int alignment>
-int32_t GetAlignedStride(int32_t aWidth, int32_t aBytesPerPixel)
-{
-  static_assert(alignment > 0 && (alignment & (alignment-1)) == 0,
-                "This implementation currently require power-of-two alignment");
-  const int32_t mask = alignment - 1;
-  CheckedInt32 stride = CheckedInt32(aWidth) * CheckedInt32(aBytesPerPixel) + CheckedInt32(mask);
-  if (stride.isValid()) {
-    return stride.value() & ~mask;
-  }
-  return 0;
-}
-
-}
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
-namespace mozilla {
-
-struct Nothing { };
-# 85 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
-template<class T>
-class Maybe
-{
-  alignas(T) unsigned char mStorage[sizeof(T)];
-  char mIsSome;
-
-
-
-  void* data() { return mStorage; }
-  const void* data() const { return mStorage; }
-
-public:
-  using ValueType = T;
-
-  Maybe() : mIsSome(false) { }
-  ~Maybe() { reset(); }
-
-               Maybe(Nothing) : mIsSome(false) { }
-
-  Maybe(const Maybe& aOther)
-    : mIsSome(false)
-  {
-    if (aOther.mIsSome) {
-      emplace(*aOther);
-    }
-  }
-
-
-
-
-  template<typename U,
-           typename =
-             typename std::enable_if<std::is_convertible<U, T>::value>::type>
-
-  Maybe(const Maybe<U>& aOther)
-    : mIsSome(false)
-  {
-    if (aOther.isSome()) {
-      emplace(*aOther);
-    }
-  }
-
-  Maybe(Maybe&& aOther)
-    : mIsSome(false)
-  {
-    if (aOther.mIsSome) {
-      emplace(Move(*aOther));
-      aOther.reset();
-    }
-  }
-
-
-
-
-  template<typename U,
-           typename =
-             typename std::enable_if<std::is_convertible<U, T>::value>::type>
-
-  Maybe(Maybe<U>&& aOther)
-    : mIsSome(false)
-  {
-    if (aOther.isSome()) {
-      emplace(Move(*aOther));
-      aOther.reset();
-    }
-  }
-
-  Maybe& operator=(const Maybe& aOther)
-  {
-    if (&aOther != this) {
-      if (aOther.mIsSome) {
-        if (mIsSome) {
-          ref() = aOther.ref();
-        } else {
-          emplace(*aOther);
-        }
-      } else {
-        reset();
-      }
-    }
-    return *this;
-  }
-
-  template<typename U,
-           typename =
-             typename std::enable_if<std::is_convertible<U, T>::value>::type>
-  Maybe& operator=(const Maybe<U>& aOther)
-  {
-    if (aOther.isSome()) {
-      if (mIsSome) {
-        ref() = aOther.ref();
-      } else {
-        emplace(*aOther);
-      }
-    } else {
-      reset();
-    }
-    return *this;
-  }
-
-  Maybe& operator=(Maybe&& aOther)
-  {
-    do { } while (0);
-
-    if (aOther.mIsSome) {
-      if (mIsSome) {
-        ref() = Move(aOther.ref());
-      } else {
-        emplace(Move(*aOther));
-      }
-      aOther.reset();
-    } else {
-      reset();
-    }
-
-    return *this;
-  }
-
-  template<typename U,
-           typename =
-             typename std::enable_if<std::is_convertible<U, T>::value>::type>
-  Maybe& operator=(Maybe<U>&& aOther)
-  {
-    if (aOther.isSome()) {
-      if (mIsSome) {
-        ref() = Move(aOther.ref());
-      } else {
-        emplace(Move(*aOther));
-      }
-      aOther.reset();
-    } else {
-      reset();
-    }
-
-    return *this;
-  }
-
-
-  explicit operator bool() const { return isSome(); }
-  bool isSome() const { return mIsSome; }
-  bool isNothing() const { return !mIsSome; }
-
-
-  T value() const
-  {
-    do { } while (0);
-    return ref();
-  }
-
-
-
-
-
-  template<typename V>
-  T valueOr(V&& aDefault) const
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return Forward<V>(aDefault);
-  }
-
-
-
-
-
-  template<typename F>
-  T valueOrFrom(F&& aFunc) const
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return aFunc();
-  }
-
-
-  T* ptr()
-  {
-    do { } while (0);
-    return &ref();
-  }
-
-  const T* ptr() const
-  {
-    do { } while (0);
-    return &ref();
-  }
-
-
-
-
-
-  T* ptrOr(T* aDefault)
-  {
-    if (isSome()) {
-      return ptr();
-    }
-    return aDefault;
-  }
-
-  const T* ptrOr(const T* aDefault) const
-  {
-    if (isSome()) {
-      return ptr();
-    }
-    return aDefault;
-  }
-
-
-
-
-
-  template<typename F>
-  T* ptrOrFrom(F&& aFunc)
-  {
-    if (isSome()) {
-      return ptr();
-    }
-    return aFunc();
-  }
-
-  template<typename F>
-  const T* ptrOrFrom(F&& aFunc) const
-  {
-    if (isSome()) {
-      return ptr();
-    }
-    return aFunc();
-  }
-
-  T* operator->()
-  {
-    do { } while (0);
-    return ptr();
-  }
-
-  const T* operator->() const
-  {
-    do { } while (0);
-    return ptr();
-  }
-
-
-  T& ref()
-  {
-    do { } while (0);
-    return *static_cast<T*>(data());
-  }
-
-  const T& ref() const
-  {
-    do { } while (0);
-    return *static_cast<const T*>(data());
-  }
-
-
-
-
-
-  T& refOr(T& aDefault)
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return aDefault;
-  }
-
-  const T& refOr(const T& aDefault) const
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return aDefault;
-  }
-
-
-
-
-
-  template<typename F>
-  T& refOrFrom(F&& aFunc)
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return aFunc();
-  }
-
-  template<typename F>
-  const T& refOrFrom(F&& aFunc) const
-  {
-    if (isSome()) {
-      return ref();
-    }
-    return aFunc();
-  }
-
-  T& operator*()
-  {
-    do { } while (0);
-    return ref();
-  }
-
-  const T& operator*() const
-  {
-    do { } while (0);
-    return ref();
-  }
-
-
-
-  template<typename Func>
-  Maybe& apply(Func aFunc)
-  {
-    if (isSome()) {
-      aFunc(ref());
-    }
-    return *this;
-  }
-
-  template<typename Func>
-  const Maybe& apply(Func aFunc) const
-  {
-    if (isSome()) {
-      aFunc(ref());
-    }
-    return *this;
-  }
-
-
-
-
-
-  template<typename Func>
-  auto map(Func aFunc) -> Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>
-  {
-    using ReturnType = decltype(aFunc(ref()));
-    if (isSome()) {
-      Maybe<ReturnType> val;
-      val.emplace(aFunc(ref()));
-      return val;
-    }
-    return Maybe<ReturnType>();
-  }
-
-  template<typename Func>
-  auto map(Func aFunc) const -> Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>
-  {
-    using ReturnType = decltype(aFunc(ref()));
-    if (isSome()) {
-      Maybe<ReturnType> val;
-      val.emplace(aFunc(ref()));
-      return val;
-    }
-    return Maybe<ReturnType>();
-  }
-
-
-  void reset()
-  {
-    if (isSome()) {
-      ref().T::~T();
-      mIsSome = false;
-    }
-  }
-
-
-
-
-
-  template<typename... Args>
-  void emplace(Args&&... aArgs)
-  {
-    do { } while (0);
-    ::new (KnownNotNull, data()) T(Forward<Args>(aArgs)...);
-    mIsSome = true;
-  }
-
-  friend std::ostream&
-  operator<<(std::ostream& aStream, const Maybe<T>& aMaybe)
-  {
-    if (aMaybe) {
-      aStream << aMaybe.ref();
-    } else {
-      aStream << "<Nothing>";
-    }
-    return aStream;
-  }
-};
-# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
-template<typename T,
-         typename U = typename std::remove_cv<
-           typename std::remove_reference<T>::type>::type>
-Maybe<U>
-Some(T&& aValue)
-{
-  Maybe<U> value;
-  value.emplace(Forward<T>(aValue));
-  return value;
-}
-
-template<typename T>
-Maybe<typename RemoveCV<typename RemoveReference<T>::Type>::Type>
-ToMaybe(T* aPtr)
-{
-  if (aPtr) {
-    return Some(*aPtr);
-  }
-  return Nothing();
-}
-
-
-
-
-
-
-template<typename T> bool
-operator==(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  if (aLHS.isNothing() != aRHS.isNothing()) {
-    return false;
-  }
-  return aLHS.isNothing() || *aLHS == *aRHS;
-}
-
-template<typename T> bool
-operator!=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  return !(aLHS == aRHS);
-}
-
-
-
-
-
-template<typename T> bool
-operator==(const Maybe<T>& aLHS, const Nothing& aRHS)
-{
-  return aLHS.isNothing();
-}
-
-template<typename T> bool
-operator!=(const Maybe<T>& aLHS, const Nothing& aRHS)
-{
-  return !(aLHS == aRHS);
-}
-
-template<typename T> bool
-operator==(const Nothing& aLHS, const Maybe<T>& aRHS)
-{
-  return aRHS.isNothing();
-}
-
-template<typename T> bool
-operator!=(const Nothing& aLHS, const Maybe<T>& aRHS)
-{
-  return !(aLHS == aRHS);
-}
-
-
-
-
-
-template<typename T> bool
-operator<(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  if (aLHS.isNothing()) {
-    return aRHS.isSome();
-  }
-  if (aRHS.isNothing()) {
-    return false;
-  }
-  return *aLHS < *aRHS;
-}
-
-template<typename T> bool
-operator>(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  return !(aLHS < aRHS || aLHS == aRHS);
-}
-
-template<typename T> bool
-operator<=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  return aLHS < aRHS || aLHS == aRHS;
-}
-
-template<typename T> bool
-operator>=(const Maybe<T>& aLHS, const Maybe<T>& aRHS)
-{
-  return !(aLHS < aRHS);
-}
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 1 3
-# 40 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/cmath" 3
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Rect.h" 2
-
-namespace mozilla {
-
-template <typename> struct IsPixel;
-
-namespace gfx {
-
-template<class units, class F> struct RectTyped;
-
-template<class units>
-struct IntMarginTyped:
-    public BaseMargin<int32_t, IntMarginTyped<units> >,
-    public units {
-    static_assert(IsPixel<units>::value,
-                  "'units' must be a coordinate system tag");
-
-    typedef BaseMargin<int32_t, IntMarginTyped<units> > Super;
-
-    IntMarginTyped() : Super() {}
-    IntMarginTyped(int32_t aTop, int32_t aRight, int32_t aBottom, int32_t aLeft) :
-        Super(aTop, aRight, aBottom, aLeft) {}
-
-
-
-
-    static IntMarginTyped<units> FromUnknownMargin(const IntMarginTyped<UnknownUnits>& aMargin) {
-        return IntMarginTyped<units>(aMargin.top, aMargin.right,
-                                     aMargin.bottom, aMargin.left);
-    }
-
-    IntMarginTyped<UnknownUnits> ToUnknownMargin() const {
-        return IntMarginTyped<UnknownUnits>(this->top, this->right,
-                                            this->bottom, this->left);
-    }
-};
-typedef IntMarginTyped<UnknownUnits> IntMargin;
-
-template<class units, class F = Float>
-struct MarginTyped:
-    public BaseMargin<F, MarginTyped<units> >,
-    public units {
-    static_assert(IsPixel<units>::value,
-                  "'units' must be a coordinate system tag");
-
-    typedef BaseMargin<F, MarginTyped<units, F> > Super;
-
-    MarginTyped() : Super() {}
-    MarginTyped(F aTop, F aRight, F aBottom, F aLeft) :
-        Super(aTop, aRight, aBottom, aLeft) {}
-    explicit MarginTyped(const IntMarginTyped<units>& aMargin) :
-        Super(F(aMargin.top), F(aMargin.right),
-              F(aMargin.bottom), F(aMargin.left)) {}
-};
-typedef MarginTyped<UnknownUnits> Margin;
-typedef MarginTyped<UnknownUnits, double> MarginDouble;
-
-template<class units>
-IntMarginTyped<units> RoundedToInt(const MarginTyped<units>& aMargin)
-{
-  return IntMarginTyped<units>(int32_t(floorf(aMargin.top + 0.5f)),
-                               int32_t(floorf(aMargin.right + 0.5f)),
-                               int32_t(floorf(aMargin.bottom + 0.5f)),
-                               int32_t(floorf(aMargin.left + 0.5f)));
-}
-
-template<class units>
-struct IntRectTyped :
-    public BaseRect<int32_t, IntRectTyped<units>, IntPointTyped<units>, IntSizeTyped<units>, IntMarginTyped<units> >,
-    public units {
-    static_assert(IsPixel<units>::value,
-                  "'units' must be a coordinate system tag");
-
-    typedef BaseRect<int32_t, IntRectTyped<units>, IntPointTyped<units>, IntSizeTyped<units>, IntMarginTyped<units> > Super;
-    typedef IntRectTyped<units> Self;
-    typedef IntParam<int32_t> ToInt;
-
-    IntRectTyped() : Super() {}
-    IntRectTyped(const IntPointTyped<units>& aPos, const IntSizeTyped<units>& aSize) :
-        Super(aPos, aSize) {}
-
-    IntRectTyped(ToInt aX, ToInt aY, ToInt aWidth, ToInt aHeight) :
-        Super(aX.value, aY.value, aWidth.value, aHeight.value) {}
-
-    static IntRectTyped<units> RoundIn(float aX, float aY, float aW, float aH) {
-      return IntRectTyped<units>::RoundIn(RectTyped<units, float>(aX, aY, aW, aH));
-    }
-
-    static IntRectTyped<units> RoundOut(float aX, float aY, float aW, float aH) {
-      return IntRectTyped<units>::RoundOut(RectTyped<units, float>(aX, aY, aW, aH));
-    }
-
-    static IntRectTyped<units> Round(float aX, float aY, float aW, float aH) {
-      return IntRectTyped<units>::Round(RectTyped<units, float>(aX, aY, aW, aH));
-    }
-
-    static IntRectTyped<units> Truncate(float aX, float aY, float aW, float aH) {
-      return IntRectTyped<units>(IntPointTyped<units>::Truncate(aX, aY),
-                                 IntSizeTyped<units>::Truncate(aW, aH));
-    }
-
-    static IntRectTyped<units> RoundIn(const RectTyped<units, float>& aRect) {
-      auto tmp(aRect);
-      tmp.RoundIn();
-      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
-                          int32_t(tmp.width), int32_t(tmp.height));
-    }
-
-    static IntRectTyped<units> RoundOut(const RectTyped<units, float>& aRect) {
-      auto tmp(aRect);
-      tmp.RoundOut();
-      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
-                          int32_t(tmp.width), int32_t(tmp.height));
-    }
-
-    static IntRectTyped<units> Round(const RectTyped<units, float>& aRect) {
-      auto tmp(aRect);
-      tmp.Round();
-      return IntRectTyped(int32_t(tmp.x), int32_t(tmp.y),
-                          int32_t(tmp.width), int32_t(tmp.height));
-    }
-
-    static IntRectTyped<units> Truncate(const RectTyped<units, float>& aRect) {
-      return IntRectTyped::Truncate(aRect.x, aRect.y, aRect.width, aRect.height);
-    }
-
-
-    void Round() {}
-    void RoundIn() {}
-    void RoundOut() {}
-
-
-
-
-    static IntRectTyped<units> FromUnknownRect(const IntRectTyped<UnknownUnits>& rect) {
-        return IntRectTyped<units>(rect.x, rect.y, rect.width, rect.height);
-    }
-
-    IntRectTyped<UnknownUnits> ToUnknownRect() const {
-        return IntRectTyped<UnknownUnits>(this->x, this->y, this->width, this->height);
-    }
-
-    bool Overflows() const {
-      CheckedInt<int32_t> xMost = this->x;
-      xMost += this->width;
-      CheckedInt<int32_t> yMost = this->y;
-      yMost += this->height;
-      return !xMost.isValid() || !yMost.isValid();
-    }
-
-
-
-
-    __attribute__ ((warn_unused_result)) Maybe<Self> SafeUnion(const Self& aRect) const
-    {
-      if (this->IsEmpty()) {
-        return aRect.Overflows() ? Nothing() : Some(aRect);
-      } else if (aRect.IsEmpty()) {
-        return Some(*static_cast<const Self*>(this));
-      } else {
-        return this->SafeUnionEdges(aRect);
-      }
-    }
-
-
-
-    __attribute__ ((warn_unused_result)) Maybe<Self> SafeUnionEdges(const Self& aRect) const
-    {
-      if (this->Overflows() || aRect.Overflows()) {
-        return Nothing();
-      }
-
-
-      CheckedInt<int32_t> newX = std::min(this->x, aRect.x);
-      CheckedInt<int32_t> newY = std::min(this->y, aRect.y);
-      CheckedInt<int32_t> newXMost = std::max(this->XMost(), aRect.XMost());
-      CheckedInt<int32_t> newYMost = std::max(this->YMost(), aRect.YMost());
-      CheckedInt<int32_t> newW = newXMost - newX;
-      CheckedInt<int32_t> newH = newYMost - newY;
-      if (!newW.isValid() || !newH.isValid()) {
-        return Nothing();
-      }
-      return Some(Self(newX.value(), newY.value(), newW.value(), newH.value()));
-    }
-
-
-    bool operator==(const IntRectTyped<units>& aRect) const
-    {
-      return IntRectTyped<units>::IsEqualEdges(aRect);
-    }
-
-    void InflateToMultiple(const IntSizeTyped<units>& aTileSize)
-    {
-      if (this->IsEmpty()) {
-        return;
-      }
-
-      int32_t yMost = this->YMost();
-      int32_t xMost = this->XMost();
-
-      this->x = mozilla::RoundDownToMultiple(this->x, aTileSize.width);
-      this->y = mozilla::RoundDownToMultiple(this->y, aTileSize.height);
-      xMost = mozilla::RoundUpToMultiple(xMost, aTileSize.width);
-      yMost = mozilla::RoundUpToMultiple(yMost, aTileSize.height);
-
-      this->width = xMost - this->x;
-      this->height = yMost - this->y;
-    }
-
-};
-typedef IntRectTyped<UnknownUnits> IntRect;
-
-template<class units, class F = Float>
-struct RectTyped :
-    public BaseRect<F, RectTyped<units, F>, PointTyped<units, F>, SizeTyped<units, F>, MarginTyped<units, F> >,
-    public units {
-    static_assert(IsPixel<units>::value,
-                  "'units' must be a coordinate system tag");
-
-    typedef BaseRect<F, RectTyped<units, F>, PointTyped<units, F>, SizeTyped<units, F>, MarginTyped<units, F> > Super;
-
-    RectTyped() : Super() {}
-    RectTyped(const PointTyped<units, F>& aPos, const SizeTyped<units, F>& aSize) :
-        Super(aPos, aSize) {}
-    RectTyped(F _x, F _y, F _width, F _height) :
-        Super(_x, _y, _width, _height) {}
-    explicit RectTyped(const IntRectTyped<units>& rect) :
-        Super(F(rect.x), F(rect.y),
-              F(rect.width), F(rect.height)) {}
-
-    void NudgeToIntegers()
-    {
-      NudgeToInteger(&(this->x));
-      NudgeToInteger(&(this->y));
-      NudgeToInteger(&(this->width));
-      NudgeToInteger(&(this->height));
-    }
-
-    bool ToIntRect(IntRectTyped<units> *aOut) const
-    {
-      *aOut = IntRectTyped<units>(int32_t(this->X()), int32_t(this->Y()),
-                                  int32_t(this->Width()), int32_t(this->Height()));
-      return RectTyped<units, F>(F(aOut->x), F(aOut->y),
-                                 F(aOut->width), F(aOut->height))
-             .IsEqualEdges(*this);
-    }
-
-
-
-
-    static RectTyped<units, F> FromUnknownRect(const RectTyped<UnknownUnits, F>& rect) {
-        return RectTyped<units, F>(rect.x, rect.y, rect.width, rect.height);
-    }
-
-    RectTyped<UnknownUnits, F> ToUnknownRect() const {
-        return RectTyped<UnknownUnits, F>(this->x, this->y, this->width, this->height);
-    }
-
-
-    bool operator==(const RectTyped<units, F>& aRect) const
-    {
-      return RectTyped<units, F>::IsEqualEdges(aRect);
-    }
-};
-typedef RectTyped<UnknownUnits> Rect;
-typedef RectTyped<UnknownUnits, double> RectDouble;
-
-template<class units>
-IntRectTyped<units> RoundedToInt(const RectTyped<units>& aRect)
-{
-  RectTyped<units> copy(aRect);
-  copy.Round();
-  return IntRectTyped<units>(int32_t(copy.x),
-                             int32_t(copy.y),
-                             int32_t(copy.width),
-                             int32_t(copy.height));
-}
-
-template<class units>
-IntRectTyped<units> RoundedIn(const RectTyped<units>& aRect)
-{
-  return IntRectTyped<units>::RoundIn(aRect);
-}
-
-template<class units>
-IntRectTyped<units> RoundedOut(const RectTyped<units>& aRect)
-{
-  return IntRectTyped<units>::RoundOut(aRect);
-}
-
-template<class units>
-IntRectTyped<units> TruncatedToInt(const RectTyped<units>& aRect) {
-  return IntRectTyped<units>::Truncate(aRect);
-}
-
-template<class units>
-RectTyped<units> IntRectToRect(const IntRectTyped<units>& aRect)
-{
-  return RectTyped<units>(aRect.x, aRect.y, aRect.width, aRect.height);
-}
-
-
-template <typename T>
-Maybe<T>
-IntersectMaybeRects(const Maybe<T>& a, const Maybe<T>& b)
-{
-  if (!a) {
-    return b;
-  } else if (!b) {
-    return a;
-  } else {
-    return Some(a->Intersect(*b));
-  }
-}
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsMargin.h" 2
-
-struct nsMargin : public mozilla::gfx::BaseMargin<nscoord, nsMargin> {
-  typedef mozilla::gfx::BaseMargin<nscoord, nsMargin> Super;
-
-
-  nsMargin() : Super() {}
-  nsMargin(const nsMargin& aMargin) : Super(aMargin) {}
-  nsMargin(nscoord aTop, nscoord aRight, nscoord aBottom, nscoord aLeft)
-    : Super(aTop, aRight, aBottom, aLeft) {}
-};
-
-typedef mozilla::gfx::IntMargin nsIntMargin;
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/SVGAttrValueWrapper.h"
-class nsSVGAngle;
-class nsSVGIntegerPair;
-class nsSVGLength2;
-class nsSVGNumberPair;
-class nsSVGViewBox;
-
-namespace mozilla {
-class SVGLengthList;
-class SVGNumberList;
-class SVGPathData;
-class SVGPointList;
-class SVGAnimatedPreserveAspectRatio;
-class SVGStringList;
-class SVGTransformList;
-}
-
-namespace mozilla {
-
-class SVGAttrValueWrapper
-{
-public:
-  static void ToString(const nsSVGAngle* aAngle, nsAString& aResult);
-  static void ToString(const nsSVGIntegerPair* aIntegerPair,
-                       nsAString& aResult);
-  static void ToString(const nsSVGLength2* aLength, nsAString& aResult);
-  static void ToString(const mozilla::SVGLengthList* aLengthList,
-                       nsAString& aResult);
-  static void ToString(const mozilla::SVGNumberList* aNumberList,
-                       nsAString& aResult);
-  static void ToString(const nsSVGNumberPair* aNumberPair, nsAString& aResult);
-  static void ToString(const mozilla::SVGPathData* aPathData,
-                       nsAString& aResult);
-  static void ToString(const mozilla::SVGPointList* aPointList,
-                       nsAString& aResult);
-  static void ToString(
-    const mozilla::SVGAnimatedPreserveAspectRatio* aPreserveAspectRatio,
-    nsAString& aResult);
-  static void ToString(const mozilla::SVGStringList* aStringList,
-                       nsAString& aResult);
-  static void ToString(const mozilla::SVGTransformList* aTransformList,
-                       nsAString& aResult);
-  static void ToString(const nsSVGViewBox* aViewBox, nsAString& aResult);
-};
-
-}
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-namespace JS { class Value; }
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-enum JSValueType
-{
-    JSVAL_TYPE_DOUBLE = 0x00,
-    JSVAL_TYPE_INT32 = 0x01,
-    JSVAL_TYPE_UNDEFINED = 0x02,
-    JSVAL_TYPE_NULL = 0x03,
-    JSVAL_TYPE_BOOLEAN = 0x04,
-    JSVAL_TYPE_MAGIC = 0x05,
-    JSVAL_TYPE_STRING = 0x06,
-    JSVAL_TYPE_SYMBOL = 0x07,
-    JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
-    JSVAL_TYPE_OBJECT = 0x0c,
-
-
-    JSVAL_TYPE_UNKNOWN = 0x20,
-    JSVAL_TYPE_MISSING = 0x21
-} __attribute__((packed));
-
-static_assert(sizeof(JSValueType) == 1,
-              "compiler typed enum support is apparently buggy");
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-enum JSValueTag
-{
-    JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
-    JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
-    JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
-    JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
-    JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
-    JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
-    JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
-    JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
-    JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
-    JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
-} __attribute__((packed));
-
-static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
-              "compiler typed enum support is apparently buggy");
-
-enum JSValueShiftedTag
-{
-    JSVAL_SHIFTED_TAG_MAX_DOUBLE = ((((uint64_t)JSVAL_TAG_MAX_DOUBLE) << 47) | 0xFFFFFFFF),
-    JSVAL_SHIFTED_TAG_INT32 = (((uint64_t)JSVAL_TAG_INT32) << 47),
-    JSVAL_SHIFTED_TAG_UNDEFINED = (((uint64_t)JSVAL_TAG_UNDEFINED) << 47),
-    JSVAL_SHIFTED_TAG_NULL = (((uint64_t)JSVAL_TAG_NULL) << 47),
-    JSVAL_SHIFTED_TAG_BOOLEAN = (((uint64_t)JSVAL_TAG_BOOLEAN) << 47),
-    JSVAL_SHIFTED_TAG_MAGIC = (((uint64_t)JSVAL_TAG_MAGIC) << 47),
-    JSVAL_SHIFTED_TAG_STRING = (((uint64_t)JSVAL_TAG_STRING) << 47),
-    JSVAL_SHIFTED_TAG_SYMBOL = (((uint64_t)JSVAL_TAG_SYMBOL) << 47),
-    JSVAL_SHIFTED_TAG_PRIVATE_GCTHING = (((uint64_t)JSVAL_TAG_PRIVATE_GCTHING) << 47),
-    JSVAL_SHIFTED_TAG_OBJECT = (((uint64_t)JSVAL_TAG_OBJECT) << 47)
-} __attribute__((packed));
-
-static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
-              "compiler typed enum support is apparently buggy");
-# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-typedef enum JSWhyMagic
-{
-
-    JS_ELEMENTS_HOLE,
-
-
-    JS_NO_ITER_VALUE,
-
-
-    JS_GENERATOR_CLOSING,
-
-
-    JS_NO_CONSTANT,
-
-
-    JS_THIS_POISON,
-
-
-    JS_ARG_POISON,
-
-
-    JS_SERIALIZE_NO_NODE,
-
-
-    JS_LAZY_ARGUMENTS,
-
-
-    JS_OPTIMIZED_ARGUMENTS,
-
-
-    JS_IS_CONSTRUCTING,
-
-
-    JS_BLOCK_NEEDS_CLONE,
-
-
-    JS_HASH_KEY_EMPTY,
-
-
-    JS_ION_ERROR,
-
-
-    JS_ION_BAILOUT,
-
-
-    JS_OPTIMIZED_OUT,
-
-
-    JS_UNINITIALIZED_LEXICAL,
-
-
-    JS_GENERIC_MAGIC,
-
-    JS_WHY_MAGIC_COUNT
-} JSWhyMagic;
-
-namespace JS {
-
-static inline constexpr JS::Value UndefinedValue();
-static inline JS::Value PoisonedObjectValue(JSObject* obj);
-
-namespace detail {
-
-constexpr int CanonicalizedNaNSignBit = 0;
-constexpr uint64_t CanonicalizedNaNSignificand = 0x8000000000000ULL;
-
-constexpr uint64_t CanonicalizedNaNBits =
-    mozilla::SpecificNaNBits<double,
-                             detail::CanonicalizedNaNSignBit,
-                             detail::CanonicalizedNaNSignificand>::value;
-
-}
-
-
-
-
-
-
-
-static __attribute__((always_inline)) inline double
-GenericNaN()
-{
-  return mozilla::SpecificNaN<double>(detail::CanonicalizedNaNSignBit,
-                                      detail::CanonicalizedNaNSignificand);
-}
-
-
-
-
-
-static inline double
-CanonicalizeNaN(double d)
-{
-    if ((__builtin_expect(!!(mozilla::IsNaN(d)), 0)))
-        return GenericNaN();
-    return d;
-}
-# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-class alignas(8) Value
-{
-  public:
-
-
-
-    using PayloadType = uint64_t;
-
-
-
-
-
-
-    Value() = default;
-    Value(const Value& v) = default;
-
-
-
-
-
-    template <typename T>
-    static bool isNumberRepresentable(const T t) {
-        return T(double(t)) == t;
-    }
-
-
-
-    void setNull() {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_NULL, 0);
-    }
-
-    void setUndefined() {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_UNDEFINED, 0);
-    }
-
-    void setInt32(int32_t i) {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
-    }
-
-    int32_t& getInt32Ref() {
-        do { } while (0);
-        return data.s.payload.i32;
-    }
-
-    void setDouble(double d) {
-
-
-        data = layout(d);
-        do { } while (0);
-    }
-
-    void setNaN() {
-        setDouble(GenericNaN());
-    }
-
-    double& getDoubleRef() {
-        do { } while (0);
-        return data.asDouble;
-    }
-
-    void setString(JSString* str) {
-        do { } while (0);
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_STRING, PayloadType(str));
-    }
-
-    void setSymbol(JS::Symbol* sym) {
-        do { } while (0);
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_SYMBOL, PayloadType(sym));
-    }
-
-    void setObject(JSObject& obj) {
-        do { } while (0);
-
-
-
-
-
-        do { } while (0);
-
-        setObjectNoCheck(&obj);
-    }
-
-  private:
-    void setObjectNoCheck(JSObject* obj) {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_OBJECT, PayloadType(obj));
-    }
-
-    friend inline Value PoisonedObjectValue(JSObject* obj);
-
-  public:
-    void setBoolean(bool b) {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(b));
-    }
-
-    void setMagic(JSWhyMagic why) {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, uint32_t(why));
-    }
-
-    void setMagicUint32(uint32_t payload) {
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, payload);
-    }
-
-    bool setNumber(uint32_t ui) {
-        if (ui > ((int32_t)0x7fffffff)) {
-            setDouble((double)ui);
-            return false;
-        } else {
-            setInt32((int32_t)ui);
-            return true;
-        }
-    }
-
-    bool setNumber(double d) {
-        int32_t i;
-        if (mozilla::NumberIsInt32(d, &i)) {
-            setInt32(i);
-            return true;
-        }
-
-        setDouble(d);
-        return false;
-    }
-
-    void setObjectOrNull(JSObject* arg) {
-        if (arg)
-            setObject(*arg);
-        else
-            setNull();
-    }
-
-    void swap(Value& rhs) {
-        uint64_t tmp = rhs.data.asBits;
-        rhs.data.asBits = data.asBits;
-        data.asBits = tmp;
-    }
-
-  private:
-    JSValueTag toTag() const {
-
-
-
-        return JSValueTag(data.asBits >> 47);
-
-    }
-
-  public:
-# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-    const void* bitsAsPunboxPointer() const {
-        return reinterpret_cast<void*>(data.asBits);
-    }
-# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-    bool isUndefined() const {
-
-
-
-        return data.asBits == JSVAL_SHIFTED_TAG_UNDEFINED;
-
-    }
-
-    bool isNull() const {
-
-
-
-        return data.asBits == JSVAL_SHIFTED_TAG_NULL;
-
-    }
-
-    bool isNullOrUndefined() const {
-        return isNull() || isUndefined();
-    }
-
-    bool isInt32() const {
-        return toTag() == JSVAL_TAG_INT32;
-    }
-
-    bool isInt32(int32_t i32) const {
-        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i32));
-    }
-
-    bool isDouble() const {
-
-
-
-        return (data.asBits | mozilla::DoubleTypeTraits::kSignBit) <= JSVAL_SHIFTED_TAG_MAX_DOUBLE;
-
-    }
-
-    bool isNumber() const {
-
-
-
-
-        return data.asBits < JSVAL_SHIFTED_TAG_UNDEFINED;
-
-    }
-
-    bool isString() const {
-        return toTag() == JSVAL_TAG_STRING;
-    }
-
-    bool isSymbol() const {
-        return toTag() == JSVAL_TAG_SYMBOL;
-    }
-
-    bool isObject() const {
-
-
-
-        do { } while (0);
-        return data.asBits >= JSVAL_SHIFTED_TAG_OBJECT;
-
-    }
-
-    bool isPrimitive() const {
-
-
-
-        return data.asBits < JSVAL_SHIFTED_TAG_OBJECT;
-
-    }
-
-    bool isObjectOrNull() const {
-        return isObject() || isNull();
-    }
-
-    bool isGCThing() const {
-
-
-
-
-        return data.asBits >= JSVAL_SHIFTED_TAG_STRING;
-
-    }
-
-    bool isBoolean() const {
-        return toTag() == JSVAL_TAG_BOOLEAN;
-    }
-
-    bool isTrue() const {
-        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(true));
-    }
-
-    bool isFalse() const {
-        return data.asBits == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(false));
-    }
-
-    bool isMagic() const {
-        return toTag() == JSVAL_TAG_MAGIC;
-    }
-
-    bool isMagic(JSWhyMagic why) const {
-        do { } while (0);
-        return isMagic();
-    }
-
-    JS::TraceKind traceKind() const {
-        do { } while (0);
-        static_assert((JSVAL_TAG_STRING & 0x03) == size_t(JS::TraceKind::String),
-                      "Value type tags must correspond with JS::TraceKinds.");
-        static_assert((JSVAL_TAG_SYMBOL & 0x03) == size_t(JS::TraceKind::Symbol),
-                      "Value type tags must correspond with JS::TraceKinds.");
-        static_assert((JSVAL_TAG_OBJECT & 0x03) == size_t(JS::TraceKind::Object),
-                      "Value type tags must correspond with JS::TraceKinds.");
-        if ((__builtin_expect(!!(isPrivateGCThing()), 0)))
-            return JS::GCThingTraceKind(toGCThing());
-        return JS::TraceKind(toTag() & 0x03);
-    }
-
-    JSWhyMagic whyMagic() const {
-        do { } while (0);
-        return data.s.payload.why;
-    }
-
-    uint32_t magicUint32() const {
-        do { } while (0);
-        return data.s.payload.u32;
-    }
-
-
-
-    bool operator==(const Value& rhs) const {
-        return data.asBits == rhs.data.asBits;
-    }
-
-    bool operator!=(const Value& rhs) const {
-        return data.asBits != rhs.data.asBits;
-    }
-
-    friend inline bool SameType(const Value& lhs, const Value& rhs);
-
-
-
-    int32_t toInt32() const {
-        do { } while (0);
-
-
-
-        return int32_t(data.asBits);
-
-    }
-
-    double toDouble() const {
-        do { } while (0);
-        return data.asDouble;
-    }
-
-    double toNumber() const {
-        do { } while (0);
-        return isDouble() ? toDouble() : double(toInt32());
-    }
-
-    JSString* toString() const {
-        do { } while (0);
-
-
-
-        return reinterpret_cast<JSString*>(data.asBits & 0x00007FFFFFFFFFFFLL);
-
-    }
-
-    JS::Symbol* toSymbol() const {
-        do { } while (0);
-
-
-
-        return reinterpret_cast<JS::Symbol*>(data.asBits & 0x00007FFFFFFFFFFFLL);
-
-    }
-
-    JSObject& toObject() const {
-        do { } while (0);
-
-
-
-        return *toObjectOrNull();
-
-    }
-
-    JSObject* toObjectOrNull() const {
-        do { } while (0);
-
-
-
-        uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL;
-        do { } while (0);
-        return reinterpret_cast<JSObject*>(ptrBits);
-
-    }
-
-    js::gc::Cell* toGCThing() const {
-        do { } while (0);
-
-
-
-        uint64_t ptrBits = data.asBits & 0x00007FFFFFFFFFFFLL;
-        do { } while (0);
-        return reinterpret_cast<js::gc::Cell*>(ptrBits);
-
-    }
-
-    GCCellPtr toGCCellPtr() const {
-        return GCCellPtr(toGCThing(), traceKind());
-    }
-
-    bool toBoolean() const {
-        do { } while (0);
-
-
-
-        return bool(data.asBits & 0x00007FFFFFFFFFFFLL);
-
-    }
-
-    uint32_t payloadAsRawUint32() const {
-        do { } while (0);
-        return data.s.payload.u32;
-    }
-
-    uint64_t asRawBits() const {
-        return data.asBits;
-    }
-
-    JSValueType extractNonDoubleType() const {
-        uint32_t type = toTag() & 0xF;
-        do { } while (0);
-        return JSValueType(type);
-    }
-# 709 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-    void setPrivate(void* ptr) {
-        do { } while (0);
-
-
-
-
-        data.asBits = uintptr_t(ptr) >> 1;
-
-        do { } while (0);
-    }
-
-    void* toPrivate() const {
-        do { } while (0);
-
-
-
-        do { } while (0);
-        return reinterpret_cast<void*>(data.asBits << 1);
-
-    }
-
-    void setPrivateUint32(uint32_t ui) {
-        do { } while (0);
-        setInt32(int32_t(ui));
-    }
-
-    uint32_t toPrivateUint32() const {
-        return uint32_t(toInt32());
-    }
-# 748 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-    void setPrivateGCThing(js::gc::Cell* cell) {
-        do { } while (0);
-
-        do { } while (0);
-
-        do { } while (0);
-
-
-        do { } while (0);
-
-
-
-
-
-        do { } while (0);
-
-        data.asBits = bitsFromTagAndPayload(JSVAL_TAG_PRIVATE_GCTHING, PayloadType(cell));
-    }
-
-    bool isPrivateGCThing() const {
-        return toTag() == JSVAL_TAG_PRIVATE_GCTHING;
-    }
-
-    const size_t* payloadWord() const {
-
-
-
-        return &data.asWord;
-
-    }
-
-    const uintptr_t* payloadUIntPtr() const {
-
-
-
-        return &data.asUIntPtr;
-
-    }
-
-
-
-
-
-  private:
-# 822 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-    union layout {
-        uint64_t asBits;
-
-
-        struct {
-            uint64_t payload47 : 47;
-            JSValueTag tag : 17;
-        } debugView;
-
-        struct {
-            union {
-                int32_t i32;
-                uint32_t u32;
-                JSWhyMagic why;
-            } payload;
-        } s;
-        double asDouble;
-        void* asPtr;
-        size_t asWord;
-        uintptr_t asUIntPtr;
-
-        layout() = default;
-        explicit constexpr layout(uint64_t bits) : asBits(bits) {}
-        explicit constexpr layout(double d) : asDouble(d) {}
-    } data;
-# 902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-  private:
-    explicit constexpr Value(uint64_t asBits) : data(asBits) {}
-    explicit constexpr Value(double d) : data(d) {}
-
-    void staticAssertions() {
-        static_assert(sizeof(JSValueType) == 1, "JS_STATIC_ASSERT");
-        static_assert(sizeof(JSValueTag) == 4, "JS_STATIC_ASSERT");
-        static_assert(sizeof(JSWhyMagic) <= 4, "JS_STATIC_ASSERT");
-        static_assert(sizeof(Value) == 8, "JS_STATIC_ASSERT");
-    }
-
-    friend constexpr Value JS::UndefinedValue();
-
-  public:
-    static constexpr uint64_t
-    bitsFromTagAndPayload(JSValueTag tag, PayloadType payload)
-    {
-
-
-
-        return (uint64_t(uint32_t(tag)) << 47) | payload;
-
-    }
-
-    static constexpr Value
-    fromTagAndPayload(JSValueTag tag, PayloadType payload)
-    {
-        return fromRawBits(bitsFromTagAndPayload(tag, payload));
-    }
-
-    static constexpr Value
-    fromRawBits(uint64_t asBits) {
-        return Value(asBits);
-    }
-
-    static constexpr Value
-    fromInt32(int32_t i) {
-        return fromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
-    }
-
-    static constexpr Value
-    fromDouble(double d) {
-        return Value(d);
-    }
-} ;
-
-static_assert(sizeof(Value) == 8, "Value size must leave three tag bits, be a binary power, and is ubiquitously depended upon everywhere");
-
-inline bool
-IsOptimizedPlaceholderMagicValue(const Value& v)
-{
-    if (v.isMagic()) {
-        do { } while (0);
-        return true;
-    }
-    return false;
-}
-
-static __attribute__((always_inline)) inline void
-ExposeValueToActiveJS(const Value& v)
-{
-    if (v.isGCThing())
-        js::gc::ExposeGCThingToActiveJS(GCCellPtr(v));
-}
-
-
-
-static inline Value
-NullValue()
-{
-    Value v;
-    v.setNull();
-    return v;
-}
-
-static inline constexpr Value
-UndefinedValue()
-{
-    return Value::fromTagAndPayload(JSVAL_TAG_UNDEFINED, 0);
-}
-
-static inline constexpr Value
-Int32Value(int32_t i32)
-{
-    return Value::fromInt32(i32);
-}
-
-static inline Value
-DoubleValue(double dbl)
-{
-    Value v;
-    v.setDouble(dbl);
-    return v;
-}
-
-static inline Value
-CanonicalizedDoubleValue(double d)
-{
-    return (__builtin_expect(!!(mozilla::IsNaN(d)), 0))
-           ? Value::fromRawBits(detail::CanonicalizedNaNBits)
-           : Value::fromDouble(d);
-}
-
-static inline bool
-IsCanonicalized(double d)
-{
-  if (mozilla::IsInfinite(d) || mozilla::IsFinite(d))
-      return true;
-
-  uint64_t bits;
-  mozilla::BitwiseCast<uint64_t>(d, &bits);
-  return (bits & ~mozilla::DoubleTypeTraits::kSignBit) == detail::CanonicalizedNaNBits;
-}
-
-static inline Value
-DoubleNaNValue()
-{
-    Value v;
-    v.setNaN();
-    return v;
-}
-
-static inline Value
-Float32Value(float f)
-{
-    Value v;
-    v.setDouble(f);
-    return v;
-}
-
-static inline Value
-StringValue(JSString* str)
-{
-    Value v;
-    v.setString(str);
-    return v;
-}
-
-static inline Value
-SymbolValue(JS::Symbol* sym)
-{
-    Value v;
-    v.setSymbol(sym);
-    return v;
-}
-
-static inline Value
-BooleanValue(bool boo)
-{
-    Value v;
-    v.setBoolean(boo);
-    return v;
-}
-
-static inline Value
-TrueValue()
-{
-    Value v;
-    v.setBoolean(true);
-    return v;
-}
-
-static inline Value
-FalseValue()
-{
-    Value v;
-    v.setBoolean(false);
-    return v;
-}
-
-static inline Value
-ObjectValue(JSObject& obj)
-{
-    Value v;
-    v.setObject(obj);
-    return v;
-}
-
-static inline Value
-ObjectValueCrashOnTouch()
-{
-    Value v;
-    v.setObject(*reinterpret_cast<JSObject*>(0x48));
-    return v;
-}
-
-static inline Value
-MagicValue(JSWhyMagic why)
-{
-    Value v;
-    v.setMagic(why);
-    return v;
-}
-
-static inline Value
-MagicValueUint32(uint32_t payload)
-{
-    Value v;
-    v.setMagicUint32(payload);
-    return v;
-}
-
-static inline Value
-NumberValue(float f)
-{
-    Value v;
-    v.setNumber(f);
-    return v;
-}
-
-static inline Value
-NumberValue(double dbl)
-{
-    Value v;
-    v.setNumber(dbl);
-    return v;
-}
-
-static inline Value
-NumberValue(int8_t i)
-{
-    return Int32Value(i);
-}
-
-static inline Value
-NumberValue(uint8_t i)
-{
-    return Int32Value(i);
-}
-
-static inline Value
-NumberValue(int16_t i)
-{
-    return Int32Value(i);
-}
-
-static inline Value
-NumberValue(uint16_t i)
-{
-    return Int32Value(i);
-}
-
-static inline Value
-NumberValue(int32_t i)
-{
-    return Int32Value(i);
-}
-
-static inline constexpr Value
-NumberValue(uint32_t i)
-{
-    return i <= ((int32_t)0x7fffffff)
-           ? Int32Value(int32_t(i))
-           : Value::fromDouble(double(i));
-}
-
-namespace detail {
-
-template <bool Signed>
-class MakeNumberValue
-{
-  public:
-    template<typename T>
-    static inline Value create(const T t)
-    {
-        Value v;
-        if (((int32_t)0x80000000) <= t && t <= ((int32_t)0x7fffffff))
-            v.setInt32(int32_t(t));
-        else
-            v.setDouble(double(t));
-        return v;
-    }
-};
-
-template <>
-class MakeNumberValue<false>
-{
-  public:
-    template<typename T>
-    static inline Value create(const T t)
-    {
-        Value v;
-        if (t <= ((int32_t)0x7fffffff))
-            v.setInt32(int32_t(t));
-        else
-            v.setDouble(double(t));
-        return v;
-    }
-};
-
-}
-
-template <typename T>
-static inline Value
-NumberValue(const T t)
-{
-    do { } while (0);
-    return detail::MakeNumberValue<std::numeric_limits<T>::is_signed>::create(t);
-}
-
-static inline Value
-ObjectOrNullValue(JSObject* obj)
-{
-    Value v;
-    v.setObjectOrNull(obj);
-    return v;
-}
-
-static inline Value
-PrivateValue(void* ptr)
-{
-    Value v;
-    v.setPrivate(ptr);
-    return v;
-}
-
-static inline Value
-PrivateUint32Value(uint32_t ui)
-{
-    Value v;
-    v.setPrivateUint32(ui);
-    return v;
-}
-
-static inline Value
-PrivateGCThingValue(js::gc::Cell* cell)
-{
-    Value v;
-    v.setPrivateGCThing(cell);
-    return v;
-}
-
-static inline Value
-PoisonedObjectValue(JSObject* obj)
-{
-    Value v;
-    v.setObjectNoCheck(obj);
-    return v;
-}
-
-inline bool
-SameType(const Value& lhs, const Value& rhs)
-{
-
-
-
-
-    return (lhs.isDouble() && rhs.isDouble()) ||
-           (((lhs.data.asBits ^ rhs.data.asBits) & 0xFFFF800000000000ULL) == 0);
-
-}
-
-}
-
-
-
-namespace JS {
-void HeapValuePostBarrier(Value* valuep, const Value& prev, const Value& next);
-
-template <>
-struct GCPolicy<JS::Value>
-{
-    static Value initial() { return UndefinedValue(); }
-    static void trace(JSTracer* trc, Value* v, const char* name) {
-        js::UnsafeTraceManuallyBarrieredEdge(trc, v, name);
-    }
-    static bool isTenured(const Value& thing) {
-        return !thing.isGCThing() || !IsInsideNursery(thing.toGCThing());
-    }
-};
-
-}
-
-namespace js {
-
-template <>
-struct BarrierMethods<JS::Value>
-{
-    static gc::Cell* asGCThingOrNull(const JS::Value& v) {
-        return v.isGCThing() ? v.toGCThing() : nullptr;
-    }
-    static void postBarrier(JS::Value* v, const JS::Value& prev, const JS::Value& next) {
-        JS::HeapValuePostBarrier(v, prev, next);
-    }
-    static void exposeToJS(const JS::Value& v) {
-        JS::ExposeValueToActiveJS(v);
-    }
-};
-
-template <class Wrapper> class MutableValueOperations;
-
-
-
-
-
-
-
-template <class Wrapper>
-class WrappedPtrOperations<JS::Value, Wrapper>
-{
-    const JS::Value& value() const { return static_cast<const Wrapper*>(this)->get(); }
-
-  public:
-    bool isUndefined() const { return value().isUndefined(); }
-    bool isNull() const { return value().isNull(); }
-    bool isBoolean() const { return value().isBoolean(); }
-    bool isTrue() const { return value().isTrue(); }
-    bool isFalse() const { return value().isFalse(); }
-    bool isNumber() const { return value().isNumber(); }
-    bool isInt32() const { return value().isInt32(); }
-    bool isInt32(int32_t i32) const { return value().isInt32(i32); }
-    bool isDouble() const { return value().isDouble(); }
-    bool isString() const { return value().isString(); }
-    bool isSymbol() const { return value().isSymbol(); }
-    bool isObject() const { return value().isObject(); }
-    bool isMagic() const { return value().isMagic(); }
-    bool isMagic(JSWhyMagic why) const { return value().isMagic(why); }
-    bool isGCThing() const { return value().isGCThing(); }
-    bool isPrimitive() const { return value().isPrimitive(); }
-
-    bool isNullOrUndefined() const { return value().isNullOrUndefined(); }
-    bool isObjectOrNull() const { return value().isObjectOrNull(); }
-
-    bool toBoolean() const { return value().toBoolean(); }
-    double toNumber() const { return value().toNumber(); }
-    int32_t toInt32() const { return value().toInt32(); }
-    double toDouble() const { return value().toDouble(); }
-    JSString* toString() const { return value().toString(); }
-    JS::Symbol* toSymbol() const { return value().toSymbol(); }
-    JSObject& toObject() const { return value().toObject(); }
-    JSObject* toObjectOrNull() const { return value().toObjectOrNull(); }
-    gc::Cell* toGCThing() const { return value().toGCThing(); }
-    JS::TraceKind traceKind() const { return value().traceKind(); }
-    void* toPrivate() const { return value().toPrivate(); }
-    uint32_t toPrivateUint32() const { return value().toPrivateUint32(); }
-
-    uint64_t asRawBits() const { return value().asRawBits(); }
-    JSValueType extractNonDoubleType() const { return value().extractNonDoubleType(); }
-
-    JSWhyMagic whyMagic() const { return value().whyMagic(); }
-    uint32_t magicUint32() const { return value().magicUint32(); }
-};
-
-
-
-
-
-
-
-template <class Wrapper>
-class MutableWrappedPtrOperations<JS::Value, Wrapper> : public WrappedPtrOperations<JS::Value, Wrapper>
-{
-    JS::Value& value() { return static_cast<Wrapper*>(this)->get(); }
-
-  public:
-    void setNull() { value().setNull(); }
-    void setUndefined() { value().setUndefined(); }
-    void setInt32(int32_t i) { value().setInt32(i); }
-    void setDouble(double d) { value().setDouble(d); }
-    void setNaN() { setDouble(JS::GenericNaN()); }
-    void setBoolean(bool b) { value().setBoolean(b); }
-    void setMagic(JSWhyMagic why) { value().setMagic(why); }
-    bool setNumber(uint32_t ui) { return value().setNumber(ui); }
-    bool setNumber(double d) { return value().setNumber(d); }
-    void setString(JSString* str) { this->value().setString(str); }
-    void setSymbol(JS::Symbol* sym) { this->value().setSymbol(sym); }
-    void setObject(JSObject& obj) { this->value().setObject(obj); }
-    void setObjectOrNull(JSObject* arg) { this->value().setObjectOrNull(arg); }
-    void setPrivate(void* ptr) { this->value().setPrivate(ptr); }
-    void setPrivateUint32(uint32_t ui) { this->value().setPrivateUint32(ui); }
-    void setPrivateGCThing(js::gc::Cell* cell) { this->value().setPrivateGCThing(cell); }
-};
-
-
-
-
-
-template <typename Wrapper>
-class HeapBase<JS::Value, Wrapper> : public WrappedPtrOperations<JS::Value, Wrapper>
-{
-    void setBarriered(const JS::Value& v) {
-        *static_cast<JS::Heap<JS::Value>*>(this) = v;
-    }
-
-  public:
-    void setNull() { setBarriered(JS::NullValue()); }
-    void setUndefined() { setBarriered(JS::UndefinedValue()); }
-    void setInt32(int32_t i) { setBarriered(JS::Int32Value(i)); }
-    void setDouble(double d) { setBarriered(JS::DoubleValue(d)); }
-    void setNaN() { setDouble(JS::GenericNaN()); }
-    void setBoolean(bool b) { setBarriered(JS::BooleanValue(b)); }
-    void setMagic(JSWhyMagic why) { setBarriered(JS::MagicValue(why)); }
-    void setString(JSString* str) { setBarriered(JS::StringValue(str)); }
-    void setSymbol(JS::Symbol* sym) { setBarriered(JS::SymbolValue(sym)); }
-    void setObject(JSObject& obj) { setBarriered(JS::ObjectValue(obj)); }
-    void setPrivateGCThing(js::gc::Cell* cell) { setBarriered(JS::PrivateGCThingValue(cell)); }
-
-    bool setNumber(uint32_t ui) {
-        if (ui > ((int32_t)0x7fffffff)) {
-            setDouble((double)ui);
-            return false;
-        } else {
-            setInt32((int32_t)ui);
-            return true;
-        }
-    }
-
-    bool setNumber(double d) {
-        int32_t i;
-        if (mozilla::NumberIsInt32(d, &i)) {
-            setInt32(i);
-            return true;
-        }
-
-        setDouble(d);
-        return false;
-    }
-
-    void setObjectOrNull(JSObject* arg) {
-        if (arg)
-            setObject(*arg);
-        else
-            setNull();
-    }
-};
-
-
-
-
-
-template <typename F, typename... Args>
-auto
-DispatchTyped(F f, const JS::Value& val, Args&&... args)
-  -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
-{
-    if (val.isString())
-        return f(val.toString(), mozilla::Forward<Args>(args)...);
-    if (val.isObject())
-        return f(&val.toObject(), mozilla::Forward<Args>(args)...);
-    if (val.isSymbol())
-        return f(val.toSymbol(), mozilla::Forward<Args>(args)...);
-    if ((__builtin_expect(!!(val.isPrivateGCThing()), 0)))
-        return DispatchTyped(f, val.toGCCellPtr(), mozilla::Forward<Args>(args)...);
-    do { } while (0);
-    return F::defaultValue(val);
-}
-
-template <class S> struct VoidDefaultAdaptor { static void defaultValue(const S&) {} };
-template <class S> struct IdentityDefaultAdaptor { static S defaultValue(const S& v) {return v;} };
-template <class S, bool v> struct BoolDefaultAdaptor { static bool defaultValue(const S&) { return v; } };
-
-}
-# 1478 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Value.h"
-namespace JS {
-
-extern const HandleValue NullHandleValue;
-extern const HandleValue UndefinedHandleValue;
-extern const HandleValue TrueHandleValue;
-extern const HandleValue FalseHandleValue;
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
-template <class T>
-class nsAutoPtr
-{
-private:
-  static_assert(!mozilla::IsScalar<T>::value, "If you are using "
-                "nsAutoPtr to hold an array, use UniquePtr<T[]> instead");
-
-  void**
-  begin_assignment()
-  {
-    assign(0);
-    return reinterpret_cast<void**>(&mRawPtr);
-  }
-
-  void
-  assign(T* aNewPtr)
-  {
-    T* oldPtr = mRawPtr;
-
-    if (aNewPtr && aNewPtr == oldPtr) {
-      do { AnnotateMozCrashReason("MOZ_CRASH(" "Logic flaw in the caller" ")"); do { *((volatile int*) __null) = 41; ::abort(); } while (0); } while (0);
-    }
-
-    mRawPtr = aNewPtr;
-    delete oldPtr;
-  }
-
-
-
-
-
-
-  class Ptr
-  {
-  public:
-                 Ptr(T* aPtr)
-      : mPtr(aPtr)
-    {
-    }
-
-    operator T*() const
-    {
-      return mPtr;
-    }
-
-  private:
-    T* mPtr;
-  };
-
-private:
-  T* mRawPtr;
-
-public:
-  typedef T element_type;
-
-  ~nsAutoPtr()
-  {
-    delete mRawPtr;
-  }
-
-
-
-  nsAutoPtr()
-    : mRawPtr(0)
-
-  {
-  }
-
-               nsAutoPtr(Ptr aRawPtr)
-    : mRawPtr(aRawPtr)
-
-  {
-  }
-
-
-
-  nsAutoPtr(nsAutoPtr<T>& aSmartPtr)
-    : mRawPtr(aSmartPtr.forget())
-
-  {
-  }
-
-  template <typename I>
-               nsAutoPtr(nsAutoPtr<I>& aSmartPtr)
-    : mRawPtr(aSmartPtr.forget())
-
-  {
-  }
-
-  nsAutoPtr(nsAutoPtr<T>&& aSmartPtr)
-    : mRawPtr(aSmartPtr.forget())
-
-  {
-  }
-
-  template <typename I>
-               nsAutoPtr(nsAutoPtr<I>&& aSmartPtr)
-    : mRawPtr(aSmartPtr.forget())
-
-  {
-  }
-
-
-
-  nsAutoPtr<T>&
-  operator=(T* aRhs)
-
-  {
-    assign(aRhs);
-    return *this;
-  }
-
-  nsAutoPtr<T>& operator=(nsAutoPtr<T>& aRhs)
-
-  {
-    assign(aRhs.forget());
-    return *this;
-  }
-
-  template <typename I>
-  nsAutoPtr<T>& operator=(nsAutoPtr<I>& aRhs)
-
-  {
-    assign(aRhs.forget());
-    return *this;
-  }
-
-  nsAutoPtr<T>& operator=(nsAutoPtr<T>&& aRhs)
-  {
-    assign(aRhs.forget());
-    return *this;
-  }
-
-  template <typename I>
-  nsAutoPtr<T>& operator=(nsAutoPtr<I>&& aRhs)
-  {
-    assign(aRhs.forget());
-    return *this;
-  }
-
-
-
-  T*
-  get() const
-
-
-
-
-
-  {
-    return mRawPtr;
-  }
-
-  operator T*() const
-# 184 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
-  {
-    return get();
-  }
-
-  T*
-  forget()
-  {
-    T* temp = mRawPtr;
-    mRawPtr = 0;
-    return temp;
-  }
-
-  T*
-  operator->() const
-  {
-    do { } while(0);
-
-    return get();
-  }
-
-  template <typename R, typename... Args>
-  class Proxy
-  {
-    typedef R (T::*member_function)(Args...);
-    T* mRawPtr;
-    member_function mFunction;
-  public:
-    Proxy(T* aRawPtr, member_function aFunction)
-      : mRawPtr(aRawPtr),
-        mFunction(aFunction)
-    {
-    }
-    template<typename... ActualArgs>
-    R operator()(ActualArgs&&... aArgs)
-    {
-      return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
-    }
-  };
-
-  template <typename R, typename C, typename... Args>
-  Proxy<R, Args...> operator->*(R (C::*aFptr)(Args...)) const
-  {
-    do { } while(0);
-
-    return Proxy<R, Args...>(get(), aFptr);
-  }
-
-  nsAutoPtr<T>*
-  get_address()
-
-
-  {
-    return this;
-  }
-
-  const nsAutoPtr<T>*
-  get_address() const
-
-
-  {
-    return this;
-  }
-
-public:
-  T&
-  operator*() const
-  {
-    do { } while(0);
-
-    return *get();
-  }
-
-  T**
-  StartAssignment()
-  {
-
-    return reinterpret_cast<T**>(begin_assignment());
-
-
-
-
-  }
-};
-
-template <class T>
-inline nsAutoPtr<T>*
-address_of(nsAutoPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-
-template <class T>
-inline const nsAutoPtr<T>*
-address_of(const nsAutoPtr<T>& aPtr)
-{
-  return aPtr.get_address();
-}
-
-template <class T>
-class nsAutoPtrGetterTransfers
-# 301 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAutoPtr.h"
-{
-public:
-  explicit
-  nsAutoPtrGetterTransfers(nsAutoPtr<T>& aSmartPtr)
-    : mTargetSmartPtr(aSmartPtr)
-  {
-
-  }
-
-  operator void**()
-  {
-    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-  }
-
-  operator T**()
-  {
-    return mTargetSmartPtr.StartAssignment();
-  }
-
-  T*&
-  operator*()
-  {
-    return *(mTargetSmartPtr.StartAssignment());
-  }
-
-private:
-  nsAutoPtr<T>& mTargetSmartPtr;
-};
-
-template <class T>
-inline nsAutoPtrGetterTransfers<T>
-getter_Transfers(nsAutoPtr<T>& aSmartPtr)
-
-
-
-
-{
-  return nsAutoPtrGetterTransfers<T>(aSmartPtr);
-}
-
-
-
-
-
-template <class T, class U>
-inline bool
-operator==(const nsAutoPtr<T>& aLhs, const nsAutoPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
-}
-
-
-template <class T, class U>
-inline bool
-operator!=(const nsAutoPtr<T>& aLhs, const nsAutoPtr<U>& aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
-}
-
-
-
-
-template <class T, class U>
-inline bool
-operator==(const nsAutoPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator==(const U* aLhs, const nsAutoPtr<T>& aRhs)
-{
-  return static_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator!=(const nsAutoPtr<T>& aLhs, const U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator!=(const U* aLhs, const nsAutoPtr<T>& aRhs)
-{
-  return static_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator==(const nsAutoPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator==(U* aLhs, const nsAutoPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
-}
-
-template <class T, class U>
-inline bool
-operator!=(const nsAutoPtr<T>& aLhs, U* aRhs)
-{
-  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
-}
-
-template <class T, class U>
-inline bool
-operator!=(U* aLhs, const nsAutoPtr<T>& aRhs)
-{
-  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
-}
-
-
-
-
-
-template <class T>
-inline bool
-operator==(const nsAutoPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() == nullptr;
-}
-
-template <class T>
-inline bool
-operator==(decltype(nullptr), const nsAutoPtr<T>& aRhs)
-{
-  return nullptr == aRhs.get();
-}
-
-template <class T>
-inline bool
-operator!=(const nsAutoPtr<T>& aLhs, decltype(nullptr))
-{
-  return aLhs.get() != nullptr;
-}
-
-template <class T>
-inline bool
-operator!=(decltype(nullptr), const nsAutoPtr<T>& aRhs)
-{
-  return nullptr != aRhs.get();
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OwningNonNull.h" 2
-
-
-namespace mozilla {
-
-template<class T>
-class OwningNonNull
-{
-public:
-  OwningNonNull() {}
-
-               OwningNonNull(T& aValue)
-  {
-    init(&aValue);
-  }
-
-  template<class U>
-               OwningNonNull(already_AddRefed<U>&& aValue)
-  {
-    init(aValue);
-  }
-
-  template<class U>
-               OwningNonNull(const OwningNonNull<U>& aValue)
-  {
-    init(aValue);
-  }
-
-
-  operator T&() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return *mPtr;
-  }
-
-  operator T*() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mPtr;
-  }
-
-
-  explicit operator bool() const = delete;
-
-  T*
-  operator->() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mPtr;
-  }
-
-  OwningNonNull<T>&
-  operator=(T* aValue)
-  {
-    init(aValue);
-    return *this;
-  }
-
-  OwningNonNull<T>&
-  operator=(T& aValue)
-  {
-    init(&aValue);
-    return *this;
-  }
-
-  template<class U>
-  OwningNonNull<T>&
-  operator=(already_AddRefed<U>&& aValue)
-  {
-    init(aValue);
-    return *this;
-  }
-
-  template<class U>
-  OwningNonNull<T>&
-  operator=(const OwningNonNull<U>& aValue)
-  {
-    init(aValue);
-    return *this;
-  }
-
-
-  void operator=(decltype(nullptr)) = delete;
-
-  already_AddRefed<T> forget()
-  {
-
-
-
-    return mPtr.forget();
-  }
-
-  template<class U>
-  void
-  forget(U** aOther)
-  {
-
-
-
-    mPtr.forget(aOther);
-  }
-
-
-  T* get() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mPtr;
-  }
-
-  template<typename U>
-  void swap(U& aOther)
-  {
-    mPtr.swap(aOther);
-
-
-
-  }
-
-
-
-
-  bool isInitialized() const
-  {
-    do { } while (0);
-    return mPtr;
-  }
-
-protected:
-  template<typename U>
-  void init(U&& aValue)
-  {
-    mPtr = aValue;
-    do { } while (0);
-
-
-
-  }
-
-  RefPtr<T> mPtr;
-
-
-
-};
-
-template <typename T>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            OwningNonNull<T>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
-}
-
-}
-
-
-template<class T> template<class U>
-nsCOMPtr<T>::nsCOMPtr(const mozilla::OwningNonNull<U>& aOther)
-  : nsCOMPtr(aOther.get())
-{}
-
-template<class T> template<class U>
-nsCOMPtr<T>&
-nsCOMPtr<T>::operator=(const mozilla::OwningNonNull<U>& aOther)
-{
-  return operator=(aOther.get());
-}
-
-
-template<class T> template<class U>
-RefPtr<T>::RefPtr(const mozilla::OwningNonNull<U>& aOther)
-  : RefPtr(aOther.get())
-{}
-
-template<class T> template<class U>
-RefPtr<T>&
-RefPtr<T>::operator=(const mozilla::OwningNonNull<U>& aOther)
-{
-  return operator=(aOther.get());
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h" 2
-
-
-
-namespace JS {
-template<typename T>
-struct GCPolicy<mozilla::OwningNonNull<T>>
-{
-  typedef mozilla::OwningNonNull<T> SmartPtrType;
-
-  static SmartPtrType initial()
-  {
-    return SmartPtrType();
-  }
-
-  static void trace(JSTracer* trc, SmartPtrType* tp,
-                    const char* name)
-  {
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedOwningNonNull.h"
-    if ((*tp).isInitialized()) {
-      (*tp)->Trace(trc);
-    }
-  }
-};
-}
-
-namespace js {
-template<typename T, typename Wrapper>
-struct WrappedPtrOperations<mozilla::OwningNonNull<T>, Wrapper>
-{
-  operator T& () const
-  {
-    return static_cast<const Wrapper*>(this)->get();
-  }
-};
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RootedRefPtr.h"
-namespace JS {
-template<typename T>
-struct GCPolicy<RefPtr<T>>
-{
-  static RefPtr<T> initial() {
-    return RefPtr<T>();
-  }
-
-  static void trace(JSTracer* trc, RefPtr<T>* tp, const char* name)
-  {
-    if (*tp) {
-      (*tp)->Trace(trc);
-    }
-  }
-};
-}
-
-namespace js {
-template<typename T, typename Wrapper>
-struct WrappedPtrOperations<RefPtr<T>, Wrapper>
-{
-  operator T*() const
-  {
-    return static_cast<const Wrapper*>(this)->get();
-  }
-};
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h"
-namespace mozilla {
-namespace dom {
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMString.h"
-class DOMString {
-public:
-  DOMString()
-    : mStringBuffer(nullptr)
-    , mLength(0)
-    , mIsNull(false)
-    , mStringBufferOwned(false)
-  {}
-  ~DOMString()
-  {
-    do { } while (0);
-
-    if (mStringBufferOwned) {
-      do { } while (0);
-      mStringBuffer->Release();
-    }
-  }
-
-  operator nsString&()
-  {
-    return AsAString();
-  }
-
-
-
-  operator const nsString&() = delete;
-  operator const nsAString&() = delete;
-
-  nsString& AsAString()
-  {
-    do { } while (0);
-    do { } while (0);
-    if (!mString) {
-      mString.emplace();
-    }
-    return *mString;
-  }
-
-  bool HasStringBuffer() const
-  {
-    do { } while (0);
-
-    do { } while (0);
-    return !mString;
-  }
-
-
-
-
-
-
-  nsStringBuffer* StringBuffer() const
-  {
-    do { } while (0);
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-
-    return mStringBuffer;
-  }
-
-
-
-  uint32_t StringBufferLength() const
-  {
-    do { } while (0);
-    return mLength;
-  }
-
-
-
-  void RelinquishBufferOwnership()
-  {
-    do { } while (0);
-    if (mStringBufferOwned) {
-
-      mStringBufferOwned = false;
-    } else {
-
-      mStringBuffer->AddRef();
-    }
-  }
-
-
-
-
-  void SetStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength)
-  {
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    mStringBuffer = aStringBuffer;
-    mLength = aLength;
-  }
-
-
-  void SetEphemeralStringBuffer(nsStringBuffer* aStringBuffer, uint32_t aLength)
-  {
-
-    SetStringBuffer(aStringBuffer, aLength);
-    aStringBuffer->AddRef();
-    mStringBufferOwned = true;
-  }
-
-  void SetOwnedString(const nsAString& aString)
-  {
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    nsStringBuffer* buf = nsStringBuffer::FromString(aString);
-    if (buf) {
-      SetStringBuffer(buf, aString.Length());
-    } else if (aString.IsVoid()) {
-      SetNull();
-    } else if (!aString.IsEmpty()) {
-      AsAString() = aString;
-    }
-  }
-
-  enum NullHandling
-  {
-    eTreatNullAsNull,
-    eTreatNullAsEmpty,
-    eNullNotExpected
-  };
-
-  void SetOwnedAtom(nsIAtom* aAtom, NullHandling aNullHandling)
-  {
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    if (aNullHandling == eNullNotExpected || aAtom) {
-      SetStringBuffer(aAtom->GetStringBuffer(), aAtom->GetLength());
-    } else if (aNullHandling == eTreatNullAsNull) {
-      SetNull();
-    }
-  }
-
-  void SetNull()
-  {
-    do { } while (0);
-    do { } while (0);
-    mIsNull = true;
-  }
-
-  bool IsNull() const
-  {
-    do { } while (0);
-
-    return mIsNull || (mString && mString->IsVoid());
-  }
-
-  void ToString(nsAString& aString)
-  {
-    if (IsNull()) {
-      SetDOMStringToNull(aString);
-    } else if (HasStringBuffer()) {
-      if (StringBufferLength() == 0) {
-        aString.Truncate();
-      } else {
-
-
-        nsStringBuffer* buf = StringBuffer();
-        uint32_t len = StringBufferLength();
-        auto chars = static_cast<char16_t*>(buf->Data());
-        if (chars[len] == '\0') {
-
-          buf->ToString(len, aString);
-        } else {
-
-          aString.Assign(chars, len);
-        }
-      }
-    } else {
-      aString = AsAString();
-    }
-  }
-
-private:
-
-  Maybe<nsAutoString> mString;
-
-
-
-  nsStringBuffer* mStringBuffer;
-
-
-  uint32_t mLength;
-  bool mIsNull;
-  bool mStringBufferOwned;
-};
-
-}
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingDeclarations.h" 2
-
-
-
-
-
-class nsIPrincipal;
-class nsWrapperCache;
-
-namespace mozilla {
-namespace dom {
-
-
-
-struct DictionaryBase
-{
-protected:
-  bool ParseJSON(JSContext* aCx, const nsAString& aJSON,
-                 JS::MutableHandle<JS::Value> aVal);
-
-  bool StringifyToJSON(JSContext* aCx,
-                       JS::Handle<JSObject*> aObj,
-                       nsAString& aJSON) const;
-
-
-
-
-
-  struct FastDictionaryInitializer {
-  };
-
-  bool mIsAnyMemberPresent = false;
-
-private:
-
-
-  static bool AppendJSONToString(const char16_t* aJSONData,
-                                 uint32_t aDataLength, void* aString);
-
-public:
-  bool IsAnyMemberPresent() const
-  {
-    return mIsAnyMemberPresent;
-  }
-};
-
-
-
-
-struct AllTypedArraysBase {
-};
-
-
-
-
-struct AllOwningUnionBase {
-};
-
-
-struct EnumEntry {
-  const char* value;
-  size_t length;
-};
-
-enum class CallerType : uint32_t;
-
-class GlobalObject
-{
-public:
-  GlobalObject(JSContext* aCx, JSObject* aObject);
-
-  JSObject* Get() const
-  {
-    return mGlobalJSObject;
-  }
-
-  nsISupports* GetAsSupports() const;
-
-
-
-
-  JSContext* Context() const
-  {
-    return mCx;
-  }
-
-  bool Failed() const
-  {
-    return !Get();
-  }
-
-
-
-  nsIPrincipal* GetSubjectPrincipal() const;
-
-
-
-  dom::CallerType CallerType() const;
-
-protected:
-  JS::Rooted<JSObject*> mGlobalJSObject;
-  JSContext* mCx;
-  mutable nsISupports* mGlobalObject;
-
-
-
-};
-
-
-template<typename T, typename InternalType>
-class Optional_base
-{
-public:
-  Optional_base()
-  {}
-
-  explicit Optional_base(const T& aValue)
-  {
-    mImpl.emplace(aValue);
-  }
-
-  bool operator==(const Optional_base<T, InternalType>& aOther) const
-  {
-    return mImpl == aOther.mImpl;
-  }
-
-  template<typename T1, typename T2>
-  explicit Optional_base(const T1& aValue1, const T2& aValue2)
-  {
-    mImpl.emplace(aValue1, aValue2);
-  }
-
-  bool WasPassed() const
-  {
-    return mImpl.isSome();
-  }
-
-
-  template<typename... Args>
-  InternalType& Construct(Args&&... aArgs)
-  {
-    mImpl.emplace(Forward<Args>(aArgs)...);
-    return *mImpl;
-  }
-
-  void Reset()
-  {
-    mImpl.reset();
-  }
-
-  const T& Value() const
-  {
-    return *mImpl;
-  }
-
-
-  InternalType& Value()
-  {
-    return *mImpl;
-  }
-
-
-  const InternalType& InternalValue() const
-  {
-    return *mImpl;
-  }
-
-
-
-
-
-private:
-
-  Optional_base(const Optional_base& other) = delete;
-  const Optional_base &operator=(const Optional_base &other) = delete;
-
-protected:
-  Maybe<InternalType> mImpl;
-};
-
-template<typename T>
-class Optional : public Optional_base<T, T>
-{
-public:
-  Optional() :
-    Optional_base<T, T>()
-  {}
-
-  explicit Optional(const T& aValue) :
-    Optional_base<T, T>(aValue)
-  {}
-};
-
-template<typename T>
-class Optional<JS::Handle<T> > :
-  public Optional_base<JS::Handle<T>, JS::Rooted<T> >
-{
-public:
-  Optional() :
-    Optional_base<JS::Handle<T>, JS::Rooted<T> >()
-  {}
-
-  explicit Optional(JSContext* cx) :
-    Optional_base<JS::Handle<T>, JS::Rooted<T> >()
-  {
-    this->Construct(cx);
-  }
-
-  Optional(JSContext* cx, const T& aValue) :
-    Optional_base<JS::Handle<T>, JS::Rooted<T> >(cx, aValue)
-  {}
-
-
-
-  JS::Handle<T> Value() const
-  {
-    return *this->mImpl;
-  }
-
-
-
-  JS::Rooted<T>& Value()
-  {
-    return *this->mImpl;
-  }
-};
-
-
-
-
-template<>
-class Optional<JSObject*> : public Optional_base<JSObject*, JSObject*>
-{
-public:
-  Optional() :
-    Optional_base<JSObject*, JSObject*>()
-  {}
-
-  explicit Optional(JSObject* aValue) :
-    Optional_base<JSObject*, JSObject*>(aValue)
-  {}
-
-
-  JSObject*& Construct()
-  {
-
-
-    return Optional_base<JSObject*, JSObject*>::Construct(
-      static_cast<JSObject*>(nullptr));
-  }
-
-  template <class T1>
-  JSObject*& Construct(const T1& t1)
-  {
-    return Optional_base<JSObject*, JSObject*>::Construct(t1);
-  }
-};
-
-
-template<>
-class Optional<JS::Value>
-{
-private:
-  Optional() = delete;
-
-  explicit Optional(const JS::Value& aValue) = delete;
-};
-
-
-template<typename U> class NonNull;
-template<typename T>
-class Optional<NonNull<T> > : public Optional_base<T, NonNull<T> >
-{
-public:
-
-
-
-  T& Value() const
-  {
-    return *this->mImpl->get();
-  }
-
-
-
-  NonNull<T>& Value()
-  {
-    return *this->mImpl;
-  }
-};
-
-
-
-template<typename T>
-class Optional<OwningNonNull<T> > : public Optional_base<T, OwningNonNull<T> >
-{
-public:
-
-
-
-  T& Value() const
-  {
-    return *this->mImpl->get();
-  }
-
-
-
-  OwningNonNull<T>& Value()
-  {
-    return *this->mImpl;
-  }
-};
-
-
-
-
-
-
-namespace binding_detail {
-struct FakeString;
-}
-
-template<>
-class Optional<nsAString>
-{
-public:
-  Optional() : mPassed(false) {}
-
-  bool WasPassed() const
-  {
-    return mPassed;
-  }
-
-  void operator=(const nsAString* str)
-  {
-    do { } while (0);
-    mStr = str;
-    mPassed = true;
-  }
-
-
-
-  void operator=(const binding_detail::FakeString* str)
-  {
-    do { } while (0);
-    mStr = reinterpret_cast<const nsString*>(str);
-    mPassed = true;
-  }
-
-  const nsAString& Value() const
-  {
-    do { } while (0);
-    return *mStr;
-  }
-
-private:
-
-  Optional(const Optional& other) = delete;
-  const Optional &operator=(const Optional &other) = delete;
-
-  bool mPassed;
-  const nsAString* mStr;
-};
-
-template<class T>
-class NonNull
-{
-public:
-  NonNull()
-
-
-
-  {}
-
-
-  operator T&() const {
-    do { } while (0);
-    do { } while (0);
-    return *ptr;
-  }
-
-  operator T*() const {
-    do { } while (0);
-    do { } while (0);
-    return ptr;
-  }
-
-  void operator=(T* t) {
-    ptr = t;
-    do { } while (0);
-
-
-
-  }
-
-  template<typename U>
-  void operator=(U* t) {
-    ptr = t->ToAStringPtr();
-    do { } while (0);
-
-
-
-  }
-
-  T** Slot() {
-
-
-
-    return &ptr;
-  }
-
-  T* Ptr() {
-    do { } while (0);
-    do { } while (0);
-    return ptr;
-  }
-
-
-  T* get() const {
-    do { } while (0);
-    do { } while (0);
-    return ptr;
-  }
-
-protected:
-  T* ptr;
-
-
-
-};
-
-
-
-
-
-template<typename T>
-class Sequence : public FallibleTArray<T>
-{
-public:
-  Sequence() : FallibleTArray<T>()
-  {}
-};
-
-inline nsWrapperCache*
-GetWrapperCache(nsWrapperCache* cache)
-{
-  return cache;
-}
-
-inline nsWrapperCache*
-GetWrapperCache(void* p)
-{
-  return nullptr;
-}
-
-
-
-template <template <typename> class SmartPtr, typename T>
-inline nsWrapperCache*
-GetWrapperCache(const SmartPtr<T>& aObject)
-{
-  return GetWrapperCache(aObject.get());
-}
-
-struct ParentObject {
-  template<class T>
-               ParentObject(T* aObject) :
-    mObject(aObject),
-    mWrapperCache(GetWrapperCache(aObject)),
-    mUseXBLScope(false)
-  {}
-
-  template<class T, template<typename> class SmartPtr>
-               ParentObject(const SmartPtr<T>& aObject) :
-    mObject(aObject.get()),
-    mWrapperCache(GetWrapperCache(aObject.get())),
-    mUseXBLScope(false)
-  {}
-
-  ParentObject(nsISupports* aObject, nsWrapperCache* aCache) :
-    mObject(aObject),
-    mWrapperCache(aCache),
-    mUseXBLScope(false)
-  {}
-
-
-
-  nsISupports* const mObject;
-  nsWrapperCache* const mWrapperCache;
-  bool mUseXBLScope;
-};
-
-namespace binding_detail {
-
-
-template<typename T>
-class AutoSequence : public AutoTArray<T, 16>
-{
-public:
-  AutoSequence() : AutoTArray<T, 16>()
-  {}
-
-
-  operator const Sequence<T>&() const {
-    return *reinterpret_cast<const Sequence<T>*>(this);
-  }
-};
-
-}
-
-
-enum class CallerType : uint32_t {
-  System,
-  NonSystem
-};
-
-
-
-
-class SystemCallerGuarantee {
-public:
-  operator CallerType() const { return CallerType::System; }
-};
-
-}
-}
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h"
-namespace mozilla {
-
-namespace detail {
-
-template<size_t EnumSize, bool EnumSigned, size_t StorageSize, bool StorageSigned>
-struct EnumFitsWithinHelper;
-
-
-template<size_t EnumSize, size_t StorageSize>
-struct EnumFitsWithinHelper<EnumSize, true, StorageSize, true>
-  : public std::integral_constant<bool, (EnumSize <= StorageSize)>
-{};
-
-
-template<size_t EnumSize, size_t StorageSize>
-struct EnumFitsWithinHelper<EnumSize, true, StorageSize, false>
-  : public std::integral_constant<bool, false>
-{};
-
-
-template<size_t EnumSize, size_t StorageSize>
-struct EnumFitsWithinHelper<EnumSize, false, StorageSize, true>
-  : public std::integral_constant<bool, (EnumSize * 2 <= StorageSize)>
-{};
-
-
-template<size_t EnumSize, size_t StorageSize>
-struct EnumFitsWithinHelper<EnumSize, false, StorageSize, false>
-  : public std::integral_constant<bool, (EnumSize <= StorageSize)>
-{};
-
-}
-# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EnumTypeTraits.h"
-template<typename T, typename Storage>
-struct EnumTypeFitsWithin
-  : public detail::EnumFitsWithinHelper<
-      sizeof(T),
-      std::is_signed<typename std::underlying_type<T>::type>::value,
-      sizeof(Storage),
-      std::is_signed<Storage>::value
-    >
-{
-  static_assert(std::is_enum<T>::value, "must provide an enum type");
-  static_assert(std::is_integral<Storage>::value, "must provide an integral type");
-};
-
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h" 2
-
-
-
-
-class nsAString;
-class nsIDocument;
-class nsStyledElement;
-struct MiscContainer;
-
-namespace mozilla {
-class DeclarationBlock;
-namespace css {
-struct URLValue;
-struct ImageValue;
-}
-}
-# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-class nsCheapString : public nsString {
-public:
-  explicit nsCheapString(nsStringBuffer* aBuf)
-  {
-    if (aBuf)
-      aBuf->ToString(aBuf->StorageSize()/sizeof(char16_t) - 1, *this);
-  }
-};
-
-class nsAttrValue {
-  friend struct MiscContainer;
-public:
-  typedef nsTArray< nsCOMPtr<nsIAtom> > AtomArray;
-
-
-  enum ValueType {
-    eString = 0x00,
-
-    eAtom = 0x02,
-    eInteger = 0x03,
-    eColor = 0x07,
-    eEnum = 0x0B,
-    ePercent = 0x0F,
-
-
-    eCSSDeclaration = 0x10,
-    eURL,
-    eImage,
-    eAtomArray,
-    eDoubleValue,
-    eIntMarginValue,
-    eSVGAngle,
-    eSVGTypesBegin = eSVGAngle,
-    eSVGIntegerPair,
-    eSVGLength,
-    eSVGLengthList,
-    eSVGNumberList,
-    eSVGNumberPair,
-    eSVGPathData,
-    eSVGPointList,
-    eSVGPreserveAspectRatio,
-    eSVGStringList,
-    eSVGTransformList,
-    eSVGViewBox,
-    eSVGTypesEnd = eSVGViewBox,
-  };
-
-  nsAttrValue();
-  nsAttrValue(const nsAttrValue& aOther);
-  explicit nsAttrValue(const nsAString& aValue);
-  explicit nsAttrValue(nsIAtom* aValue);
-  nsAttrValue(already_AddRefed<mozilla::DeclarationBlock> aValue,
-              const nsAString* aSerialized);
-  explicit nsAttrValue(const nsIntMargin& aValue);
-  ~nsAttrValue();
-
-  inline const nsAttrValue& operator=(const nsAttrValue& aOther);
-
-  static nsresult Init();
-  static void Shutdown();
-
-  ValueType Type() const;
-
-
-
-
-
-  inline bool StoresOwnData() const;
-
-  void Reset();
-
-  void SetTo(const nsAttrValue& aOther);
-  void SetTo(const nsAString& aValue);
-  void SetTo(nsIAtom* aValue);
-  void SetTo(int16_t aInt);
-  void SetTo(int32_t aInt, const nsAString* aSerialized);
-  void SetTo(double aValue, const nsAString* aSerialized);
-  void SetTo(already_AddRefed<mozilla::DeclarationBlock> aValue,
-             const nsAString* aSerialized);
-  void SetTo(mozilla::css::URLValue* aValue, const nsAString* aSerialized);
-  void SetTo(const nsIntMargin& aValue);
-  void SetTo(const nsSVGAngle& aValue, const nsAString* aSerialized);
-  void SetTo(const nsSVGIntegerPair& aValue, const nsAString* aSerialized);
-  void SetTo(const nsSVGLength2& aValue, const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGLengthList& aValue,
-             const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGNumberList& aValue,
-             const nsAString* aSerialized);
-  void SetTo(const nsSVGNumberPair& aValue, const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGPathData& aValue, const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGPointList& aValue, const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGAnimatedPreserveAspectRatio& aValue,
-             const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGStringList& aValue,
-             const nsAString* aSerialized);
-  void SetTo(const mozilla::SVGTransformList& aValue,
-             const nsAString* aSerialized);
-  void SetTo(const nsSVGViewBox& aValue, const nsAString* aSerialized);
-# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  void SetToSerialized(const nsAttrValue& aValue);
-
-  void SwapValueWith(nsAttrValue& aOther);
-
-  void ToString(nsAString& aResult) const;
-  inline void ToString(mozilla::dom::DOMString& aResult) const;
-
-
-
-
-
-  already_AddRefed<nsIAtom> GetAsAtom() const;
-
-
-
-  inline bool IsEmptyString() const;
-  const nsCheapString GetStringValue() const;
-  inline nsIAtom* GetAtomValue() const;
-  inline int32_t GetIntegerValue() const;
-  bool GetColorValue(nscolor& aColor) const;
-  inline int16_t GetEnumValue() const;
-  inline float GetPercentValue() const;
-  inline AtomArray* GetAtomArrayValue() const;
-  inline mozilla::DeclarationBlock* GetCSSDeclarationValue() const;
-  inline mozilla::css::URLValue* GetURLValue() const;
-  inline mozilla::css::ImageValue* GetImageValue() const;
-  inline double GetDoubleValue() const;
-  bool GetIntMarginValue(nsIntMargin& aMargin) const;
-
-
-
-
-
-
-
-  void GetEnumString(nsAString& aResult, bool aRealTag) const;
-
-
-
-
-  uint32_t GetAtomCount() const;
-
-
-  nsIAtom* AtomAt(int32_t aIndex) const;
-
-  uint32_t HashValue() const;
-  bool Equals(const nsAttrValue& aOther) const;
-
-  bool Equals(const nsAString& aValue, nsCaseTreatment aCaseSensitive) const;
-  bool Equals(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const;
-# 239 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool EqualsAsStrings(const nsAttrValue& aOther) const;
-
-
-
-
-
-  bool Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const;
-
-
-
-
-
-  bool Contains(const nsAString& aValue) const;
-
-  void ParseAtom(const nsAString& aValue);
-  void ParseAtomArray(const nsAString& aValue);
-  void ParseStringOrAtom(const nsAString& aValue);
-# 267 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  struct EnumTable {
-
-
-
-    constexpr EnumTable(const char* aTag, int16_t aValue)
-      : tag(aTag)
-      , value(aValue)
-    {
-    }
-
-    template<typename T,
-             typename = typename std::enable_if<std::is_enum<T>::value>::type>
-    constexpr EnumTable(const char* aTag, T aValue)
-      : tag(aTag)
-      , value(static_cast<int16_t>(aValue))
-    {
-      static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
-                    "aValue must be an enum that fits within int16_t");
-    }
-
-
-    const char* tag;
-
-    int16_t value;
-  };
-# 304 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseEnumValue(const nsAString& aValue,
-                        const EnumTable* aTable,
-                        bool aCaseSensitive,
-                        const EnumTable* aDefaultValue = nullptr);
-# 319 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseSpecialIntValue(const nsAString& aString);
-# 328 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseIntValue(const nsAString& aString) {
-    return ParseIntWithBounds(aString, (-2147483647-1), (2147483647));
-  }
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseIntWithBounds(const nsAString& aString, int32_t aMin,
-                            int32_t aMax = (2147483647));
-# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  void ParseIntWithFallback(const nsAString& aString, int32_t aDefault,
-                            int32_t aMax = (2147483647));
-# 363 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseNonNegativeIntValue(const nsAString& aString);
-# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParsePositiveIntValue(const nsAString& aString);
-# 387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseColor(const nsAString& aString);
-
-
-
-
-
-
-
-  bool ParseDoubleValue(const nsAString& aString);
-
-
-
-
-
-  bool ParseLazyURIValue(const nsAString& aString);
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  bool ParseIntMarginValue(const nsAString& aString);
-
-
-
-
-
-
-  void LoadImage(nsIDocument* aDocument);
-
-
-
-
-
-
-
-  bool ParseStyleAttribute(const nsAString& aString,
-                           nsStyledElement* aElement);
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  enum ValueBaseType {
-    eStringBase = eString,
-    eOtherBase = 0x01,
-    eAtomBase = eAtom,
-    eIntegerBase = 0x03
-  };
-
-  inline ValueBaseType BaseType() const;
-  inline bool IsSVGType(ValueType aType) const;
-# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrValue.h"
-  int16_t GetEnumTableIndex(const EnumTable* aTable);
-
-  inline void SetPtrValueAndType(void* aValue, ValueBaseType aType);
-  void SetIntValueAndType(int32_t aValue, ValueType aType,
-                          const nsAString* aStringValue);
-  void SetColorValue(nscolor aColor, const nsAString& aString);
-  void SetMiscAtomOrString(const nsAString* aValue);
-  void ResetMiscAtomOrString();
-  void SetSVGType(ValueType aType, const void* aValue,
-                  const nsAString* aSerialized);
-  inline void ResetIfSet();
-
-  inline void* GetPtr() const;
-  inline MiscContainer* GetMiscContainer() const;
-  inline int32_t GetIntInternal() const;
-
-
-
-  MiscContainer* ClearMiscContainer();
-
-
-  MiscContainer* EnsureEmptyMiscContainer();
-  bool EnsureEmptyAtomArray();
-  already_AddRefed<nsStringBuffer>
-    GetStringBuffer(const nsAString& aValue) const;
-
-
-  int32_t EnumTableEntryToValue(const EnumTable* aEnumTable,
-                                const EnumTable* aTableEntry);
-
-  static nsTArray<const EnumTable*>* sEnumTableArray;
-
-  uintptr_t mBits;
-};
-
-inline const nsAttrValue&
-nsAttrValue::operator=(const nsAttrValue& aOther)
-{
-  SetTo(aOther);
-  return *this;
-}
-
-inline nsIAtom*
-nsAttrValue::GetAtomValue() const
-{
-  do { } while(0);
-  return reinterpret_cast<nsIAtom*>(GetPtr());
-}
-
-inline nsAttrValue::ValueBaseType
-nsAttrValue::BaseType() const
-{
-  return static_cast<ValueBaseType>(mBits & (uintptr_t(3)));
-}
-
-inline void*
-nsAttrValue::GetPtr() const
-{
-  do { } while(0);
-
-  return reinterpret_cast<void*>(mBits & (~(uintptr_t(3))));
-}
-
-inline bool
-nsAttrValue::IsEmptyString() const
-{
-  return !mBits;
-}
-
-inline void
-nsAttrValue::ToString(mozilla::dom::DOMString& aResult) const
-{
-  switch (Type()) {
-    case eString:
-    {
-      nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
-      if (str) {
-        aResult.SetStringBuffer(str, str->StorageSize()/sizeof(char16_t) - 1);
-      }
-
-      return;
-    }
-    case eAtom:
-    {
-      nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
-      aResult.SetStringBuffer(atom->GetStringBuffer(), atom->GetLength());
-      break;
-    }
-    default:
-    {
-      ToString(aResult.AsAString());
-    }
-  }
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-struct nsCSSSelector;
-
-
-
-enum nsChangeHint {
-  nsChangeHint_Empty = 0,
-
-
-
-
-  nsChangeHint_RepaintFrame = 1 << 0,
-
-
-
-  nsChangeHint_NeedReflow = 1 << 1,
-
-
-
-  nsChangeHint_ClearAncestorIntrinsics = 1 << 2,
-
-
-
-
-  nsChangeHint_ClearDescendantIntrinsics = 1 << 3,
-
-
-
-
-  nsChangeHint_NeedDirtyReflow = 1 << 4,
-
-
-
-  nsChangeHint_SyncFrameView = 1 << 5,
-
-
-  nsChangeHint_UpdateCursor = 1 << 6,
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_UpdateEffects = 1 << 7,
-
-
-
-
-
-
-  nsChangeHint_UpdateOpacityLayer = 1 << 8,
-
-
-
-
-  nsChangeHint_UpdateTransformLayer = 1 << 9,
-# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_ReconstructFrame = 1 << 10,
-
-
-
-
-
-  nsChangeHint_UpdateOverflow = 1 << 11,
-
-
-
-
-
-  nsChangeHint_UpdateSubtreeOverflow = 1 << 12,
-# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_UpdatePostTransformOverflow = 1 << 13,
-
-
-
-
-
-
-
-  nsChangeHint_UpdateParentOverflow = 1 << 14,
-
-
-
-
-
-  nsChangeHint_ChildrenOnlyTransform = 1 << 15,
-# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_RecomputePosition = 1 << 16,
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_UpdateContainingBlock = 1 << 17,
-
-
-
-
-
-
-
-  nsChangeHint_BorderStyleNoneChange = 1 << 18,
-
-
-
-
-
-  nsChangeHint_UpdateTextPath = 1 << 19,
-
-
-
-
-
-  nsChangeHint_SchedulePaint = 1 << 20,
-# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_NeutralChange = 1 << 21,
-
-
-
-
-  nsChangeHint_InvalidateRenderingObservers = 1 << 22,
-
-
-
-
-
-
-
-  nsChangeHint_ReflowChangesSizeOrPosition = 1 << 23,
-
-
-
-
-
-  nsChangeHint_UpdateComputedBSize = 1 << 24,
-# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_UpdateUsesOpacity = 1 << 25,
-# 217 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_UpdateBackgroundPosition = 1 << 26,
-
-
-
-
-
-  nsChangeHint_AddOrRemoveTransform = 1 << 27,
-# 240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  nsChangeHint_AllHints = (1 << 28) - 1,
-};
-
-
-
-
-inline void operator<(nsChangeHint s1, nsChangeHint s2) {}
-inline void operator>(nsChangeHint s1, nsChangeHint s2) {}
-inline void operator!=(nsChangeHint s1, nsChangeHint s2) {}
-inline void operator==(nsChangeHint s1, nsChangeHint s2) {}
-inline void operator<=(nsChangeHint s1, nsChangeHint s2) {}
-inline void operator>=(nsChangeHint s1, nsChangeHint s2) {}
-
-
-
-
-inline bool NS_IsHintSubset(nsChangeHint aSubset, nsChangeHint aSuperSet) {
-  return (aSubset & aSuperSet) == aSubset;
-}
-
-
-
-typedef decltype(nsChangeHint(0) + nsChangeHint(0)) nsChangeHint_size_t;
-
-inline nsChangeHint constexpr
-operator|(nsChangeHint aLeft, nsChangeHint aRight)
-{
-  return nsChangeHint(nsChangeHint_size_t(aLeft) | nsChangeHint_size_t(aRight));
-}
-
-inline nsChangeHint constexpr
-operator&(nsChangeHint aLeft, nsChangeHint aRight)
-{
-  return nsChangeHint(nsChangeHint_size_t(aLeft) & nsChangeHint_size_t(aRight));
-}
-
-inline nsChangeHint& operator|=(nsChangeHint& aLeft, nsChangeHint aRight)
-{
-  return aLeft = aLeft | aRight;
-}
-
-inline nsChangeHint& operator&=(nsChangeHint& aLeft, nsChangeHint aRight)
-{
-  return aLeft = aLeft & aRight;
-}
-
-inline nsChangeHint constexpr
-operator~(nsChangeHint aArg)
-{
-  return nsChangeHint(~nsChangeHint_size_t(aArg));
-}
-
-inline nsChangeHint constexpr
-operator^(nsChangeHint aLeft, nsChangeHint aRight)
-{
-  return nsChangeHint(nsChangeHint_size_t(aLeft) ^ nsChangeHint_size_t(aRight));
-}
-
-inline nsChangeHint operator^=(nsChangeHint& aLeft, nsChangeHint aRight)
-{
-  return aLeft = aLeft ^ aRight;
-}
-# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-static_assert(!(( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) &
-                ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform )) &&
-              !(( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) &
-                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )) &&
-              !(( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform ) &
-                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )) &&
-              !(nsChangeHint_AllHints ^
-                ( nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow | nsChangeHint_NeutralChange | nsChangeHint_ReconstructFrame | nsChangeHint_RepaintFrame | nsChangeHint_SchedulePaint | nsChangeHint_SyncFrameView | nsChangeHint_UpdateCursor | nsChangeHint_UpdateSubtreeOverflow | nsChangeHint_UpdateTextPath ) ^
-                ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform ) ^
-                ( nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition )),
-              "change hints must be present in exactly one of "
-              "nsChangeHint_Hints_{Always,Never,Sometimes}"
-              "HandledForDescendants");
-# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-inline nsChangeHint NS_HintsNotHandledForDescendantsIn(nsChangeHint aChangeHint) {
-  nsChangeHint result =
-    aChangeHint & ( nsChangeHint_BorderStyleNoneChange | nsChangeHint_ChildrenOnlyTransform | nsChangeHint_InvalidateRenderingObservers | nsChangeHint_RecomputePosition | nsChangeHint_UpdateBackgroundPosition | nsChangeHint_UpdateComputedBSize | nsChangeHint_UpdateContainingBlock | nsChangeHint_UpdateEffects | nsChangeHint_UpdateOpacityLayer | nsChangeHint_UpdateOverflow | nsChangeHint_UpdateParentOverflow | nsChangeHint_UpdatePostTransformOverflow | nsChangeHint_UpdateTransformLayer | nsChangeHint_UpdateUsesOpacity | nsChangeHint_AddOrRemoveTransform );
-
-  if (!NS_IsHintSubset(nsChangeHint_NeedDirtyReflow, aChangeHint)) {
-    if (NS_IsHintSubset(nsChangeHint_NeedReflow, aChangeHint)) {
-
-
-      result |= nsChangeHint_NeedReflow;
-    }
-
-    if (NS_IsHintSubset(nsChangeHint_ReflowChangesSizeOrPosition,
-                        aChangeHint)) {
-
-
-      result |= nsChangeHint_ReflowChangesSizeOrPosition;
-    }
-  }
-
-  if (!NS_IsHintSubset(nsChangeHint_ClearDescendantIntrinsics, aChangeHint) &&
-      NS_IsHintSubset(nsChangeHint_ClearAncestorIntrinsics, aChangeHint)) {
-
-
-    result |= nsChangeHint_ClearAncestorIntrinsics;
-  }
-
-  do { } while (0);
-
-
-
-  return result;
-}
-
-inline nsChangeHint
-NS_HintsHandledForDescendantsIn(nsChangeHint aChangeHint)
-{
-  return aChangeHint & ~NS_HintsNotHandledForDescendantsIn(aChangeHint);
-}
-
-
-
-inline nsChangeHint
-NS_RemoveSubsumedHints(nsChangeHint aOurChange, nsChangeHint aHintsHandled)
-{
-  nsChangeHint result =
-    aOurChange & ~NS_HintsHandledForDescendantsIn(aHintsHandled);
-
-  if (result & (nsChangeHint_ClearAncestorIntrinsics |
-                nsChangeHint_ClearDescendantIntrinsics |
-                nsChangeHint_NeedDirtyReflow |
-                nsChangeHint_ReflowChangesSizeOrPosition |
-                nsChangeHint_UpdateComputedBSize)) {
-    result |= nsChangeHint_NeedReflow;
-  }
-
-  if (result & (nsChangeHint_ClearDescendantIntrinsics)) {
-    do { } while (0);
-    result |=
-              nsChangeHint_NeedDirtyReflow;
-  }
-
-  return result;
-}
-# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-enum nsRestyleHint {
-
-
-
-
-  eRestyle_Self = 1 << 0,
-
-
-
-  eRestyle_SomeDescendants = 1 << 1,
-
-
-
-
-
-  eRestyle_Subtree = 1 << 2,
-
-
-
-  eRestyle_LaterSiblings = 1 << 3,
-
-
-
-
-
-
-  eRestyle_CSSTransitions = 1 << 4,
-
-
-
-
-
-
-  eRestyle_CSSAnimations = 1 << 5,
-# 519 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsChangeHint.h"
-  eRestyle_StyleAttribute = 1 << 6,
-
-
-
-  eRestyle_StyleAttribute_Animations = 1 << 7,
-
-
-
-  eRestyle_Force = 1 << 8,
-
-
-
-
-
-
-  eRestyle_ForceDescendants = 1 << 9,
-
-
-  eRestyle_AllHintsWithAnimations = eRestyle_CSSTransitions |
-                                    eRestyle_CSSAnimations |
-                                    eRestyle_StyleAttribute_Animations,
-};
-
-
-
-typedef decltype(nsRestyleHint(0) + nsRestyleHint(0)) nsRestyleHint_size_t;
-
-inline constexpr nsRestyleHint operator|(nsRestyleHint aLeft,
-                                             nsRestyleHint aRight)
-{
-  return nsRestyleHint(nsRestyleHint_size_t(aLeft) |
-                       nsRestyleHint_size_t(aRight));
-}
-
-inline constexpr nsRestyleHint operator&(nsRestyleHint aLeft,
-                                             nsRestyleHint aRight)
-{
-  return nsRestyleHint(nsRestyleHint_size_t(aLeft) &
-                       nsRestyleHint_size_t(aRight));
-}
-
-inline nsRestyleHint& operator|=(nsRestyleHint& aLeft, nsRestyleHint aRight)
-{
-  return aLeft = aLeft | aRight;
-}
-
-inline nsRestyleHint& operator&=(nsRestyleHint& aLeft, nsRestyleHint aRight)
-{
-  return aLeft = aLeft & aRight;
-}
-
-inline constexpr nsRestyleHint operator~(nsRestyleHint aArg)
-{
-  return nsRestyleHint(~nsRestyleHint_size_t(aArg));
-}
-
-inline constexpr nsRestyleHint operator^(nsRestyleHint aLeft,
-                                             nsRestyleHint aRight)
-{
-  return nsRestyleHint(nsRestyleHint_size_t(aLeft) ^
-                       nsRestyleHint_size_t(aRight));
-}
-
-inline nsRestyleHint operator^=(nsRestyleHint& aLeft, nsRestyleHint aRight)
-{
-  return aLeft = aLeft ^ aRight;
-}
-
-namespace mozilla {
-
-
-
-
-
-struct RestyleHintData
-{
-
-
-  nsTArray<nsCSSSelector*> mSelectorsForDescendants;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h" 2
-
-
-namespace mozilla {
-
-namespace dom {
-class Element;
-}
-
-
-
-
-
-
-struct ServoAttrSnapshot
-{
-  nsAttrName mName;
-  nsAttrValue mValue;
-
-  ServoAttrSnapshot(const nsAttrName& aName, const nsAttrValue& aValue)
-    : mName(aName)
-    , mValue(aValue)
-  {
-  }
-};
-
-
-
-
-
-enum class ServoElementSnapshotFlags : uint8_t
-{
-  State = 1 << 0,
-  Attributes = 1 << 1,
-  All = State | Attributes
-};
-
-inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator |(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) | U(b))); } inline ServoElementSnapshotFlags& operator |=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator &(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) & U(b))); } inline ServoElementSnapshotFlags& operator &=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator ^(ServoElementSnapshotFlags a, ServoElementSnapshotFlags b) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(U(a) ^ U(b))); } inline ServoElementSnapshotFlags& operator ^=(ServoElementSnapshotFlags& a, ServoElementSnapshotFlags b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> operator~(ServoElementSnapshotFlags a) { typedef mozilla::CastableTypedEnumResult<ServoElementSnapshotFlags> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<ServoElementSnapshotFlags>::Type U; return Result(ServoElementSnapshotFlags(~(U(a)))); }
-# 61 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoElementSnapshot.h"
-class ServoElementSnapshot
-{
-  typedef dom::BorrowedAttrInfo BorrowedAttrInfo;
-  typedef dom::Element Element;
-  typedef EventStates::ServoType ServoStateType;
-
-public:
-  typedef ServoElementSnapshotFlags Flags;
-
-  explicit ServoElementSnapshot(const Element* aElement);
-  ~ServoElementSnapshot();
-
-  bool HasAttrs() { return HasAny(Flags::Attributes); }
-
-  bool HasState() { return HasAny(Flags::State); }
-
-
-
-
-  void AddState(EventStates aState)
-  {
-    if (!HasAny(Flags::State)) {
-      mState = aState.ServoValue();
-      mContains |= Flags::State;
-    }
-  }
-
-
-
-
-  void AddAttrs(Element* aElement);
-
-
-
-
-  BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const
-  {
-    if (aIndex >= mAttrs.Length()) {
-      return BorrowedAttrInfo(nullptr, nullptr);
-    }
-    return BorrowedAttrInfo(&mAttrs[aIndex].mName, &mAttrs[aIndex].mValue);
-  }
-
-  const nsAttrValue* GetParsedAttr(nsIAtom* aLocalName) const
-  {
-    return GetParsedAttr(aLocalName, kNameSpaceID_None);
-  }
-
-  const nsAttrValue* GetParsedAttr(nsIAtom* aLocalName,
-                                   int32_t aNamespaceID) const
-  {
-    uint32_t i, len = mAttrs.Length();
-    if (aNamespaceID == kNameSpaceID_None) {
-
-      for (i = 0; i < len; ++i) {
-        if (mAttrs[i].mName.Equals(aLocalName)) {
-          return &mAttrs[i].mValue;
-        }
-      }
-
-      return nullptr;
-    }
-
-    for (i = 0; i < len; ++i) {
-      if (mAttrs[i].mName.Equals(aLocalName, aNamespaceID)) {
-        return &mAttrs[i].mValue;
-      }
-    }
-
-    return nullptr;
-  }
-
-  bool IsInChromeDocument() const
-  {
-    return mIsInChromeDocument;
-  }
-
-  bool HasAny(Flags aFlags) { return bool(mContains & aFlags); }
-
-private:
-
-
-
-
-  Flags mContains;
-  nsTArray<ServoAttrSnapshot> mAttrs;
-  ServoStateType mState;
-  bool mIsHTMLElementInHTMLDocument;
-  bool mIsInChromeDocument;
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h"
-namespace mozilla {
-namespace css {
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/css/SheetParsingMode.h"
-enum SheetParsingMode {
-  eAuthorSheetFeatures = 0,
-  eUserSheetFeatures,
-  eAgentSheetFeatures
-};
-
-}
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h"
-class nsINode;
-class nsIContent;
-class nsMappedAttributes;
-class nsHTMLStyleSheet;
-class nsRuleWalker;
-class nsMappedAttributeElement;
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsAttrAndChildArray.h"
-class nsAttrAndChildArray
-{
-  typedef mozilla::dom::BorrowedAttrInfo BorrowedAttrInfo;
-public:
-  nsAttrAndChildArray();
-  ~nsAttrAndChildArray();
-
-  uint32_t ChildCount() const
-  {
-    return mImpl ? (mImpl->mAttrAndChildCount >> 10) : 0;
-  }
-  nsIContent* ChildAt(uint32_t aPos) const
-  {
-    do { } while(0);
-    return reinterpret_cast<nsIContent*>(mImpl->mBuffer[AttrSlotsSize() + aPos]);
-  }
-  nsIContent* GetSafeChildAt(uint32_t aPos) const;
-  nsIContent * const * GetChildArray(uint32_t* aChildCount) const;
-  nsresult AppendChild(nsIContent* aChild)
-  {
-    return InsertChildAt(aChild, ChildCount());
-  }
-  nsresult InsertChildAt(nsIContent* aChild, uint32_t aPos);
-  void RemoveChildAt(uint32_t aPos);
-
-
-  already_AddRefed<nsIContent> TakeChildAt(uint32_t aPos);
-  int32_t IndexOfChild(const nsINode* aPossibleChild) const;
-
-  bool HasAttrs() const
-  {
-    return MappedAttrCount() || (AttrSlotCount() && AttrSlotIsTaken(0));
-  }
-
-  uint32_t AttrCount() const;
-  const nsAttrValue* GetAttr(nsIAtom* aLocalName,
-                             int32_t aNamespaceID = kNameSpaceID_None) const;
-
-
-  const nsAttrValue* GetAttr(const nsAString& aName) const;
-
-
-  const nsAttrValue* GetAttr(const nsAString& aName,
-                             nsCaseTreatment aCaseSensitive) const;
-  const nsAttrValue* AttrAt(uint32_t aPos) const;
-
-  nsresult SetAndSwapAttr(nsIAtom* aLocalName, nsAttrValue& aValue);
-  nsresult SetAndSwapAttr(mozilla::dom::NodeInfo* aName, nsAttrValue& aValue);
-
-
-
-  nsresult RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue);
-
-
-  const nsAttrName* AttrNameAt(uint32_t aPos) const;
-
-
-  BorrowedAttrInfo AttrInfoAt(uint32_t aPos) const;
-
-
-  const nsAttrName* GetSafeAttrNameAt(uint32_t aPos) const;
-
-  const nsAttrName* GetExistingAttrNameFromQName(const nsAString& aName) const;
-  int32_t IndexOfAttr(nsIAtom* aLocalName, int32_t aNamespaceID = kNameSpaceID_None) const;
-
-  nsresult SetAndTakeMappedAttr(nsIAtom* aLocalName, nsAttrValue& aValue,
-                                nsMappedAttributeElement* aContent,
-                                nsHTMLStyleSheet* aSheet);
-  nsresult SetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet) {
-    if (!mImpl || !mImpl->mMappedAttrs) {
-      return NS_OK;
-    }
-    return DoSetMappedAttrStyleSheet(aSheet);
-  }
-  void WalkMappedAttributeStyleRules(nsRuleWalker* aRuleWalker);
-
-  void Compact();
-
-  bool CanFitMoreAttrs() const
-  {
-    return AttrSlotCount() < ((1 << 10) - 1) ||
-           !AttrSlotIsTaken(((1 << 10) - 1) - 1);
-  }
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-  bool HasMappedAttrs() const
-  {
-    return MappedAttrCount();
-  }
-  const nsMappedAttributes* GetMapped() const;
-
-
-  nsresult ForceMapped(nsMappedAttributeElement* aContent, nsIDocument* aDocument);
-
-
-
-  void ClearMappedServoStyle();
-
-private:
-  nsAttrAndChildArray(const nsAttrAndChildArray& aOther) = delete;
-  nsAttrAndChildArray& operator=(const nsAttrAndChildArray& aOther) = delete;
-
-  void Clear();
-
-  uint32_t NonMappedAttrCount() const;
-  uint32_t MappedAttrCount() const;
-
-
-  nsMappedAttributes*
-  GetModifiableMapped(nsMappedAttributeElement* aContent,
-                      nsHTMLStyleSheet* aSheet,
-                      bool aWillAddAttr,
-                      int32_t aAttrCount = 1);
-  nsresult MakeMappedUnique(nsMappedAttributes* aAttributes);
-
-  uint32_t AttrSlotsSize() const
-  {
-    return AttrSlotCount() * (sizeof(InternalAttr) / sizeof(void*));
-  }
-
-  uint32_t AttrSlotCount() const
-  {
-    return mImpl ? mImpl->mAttrAndChildCount & ((1 << 10) - 1) : 0;
-  }
-
-  bool AttrSlotIsTaken(uint32_t aSlot) const
-  {
-    do { } while(0);
-    return mImpl->mBuffer[aSlot * (sizeof(InternalAttr) / sizeof(void*))];
-  }
-
-  void SetChildCount(uint32_t aCount)
-  {
-    mImpl->mAttrAndChildCount =
-        (mImpl->mAttrAndChildCount & ((1 << 10) - 1)) |
-        (aCount << 10);
-  }
-
-  void SetAttrSlotCount(uint32_t aCount)
-  {
-    mImpl->mAttrAndChildCount =
-        (mImpl->mAttrAndChildCount & ~((1 << 10) - 1)) |
-        aCount;
-  }
-
-  void SetAttrSlotAndChildCount(uint32_t aSlotCount, uint32_t aChildCount)
-  {
-    mImpl->mAttrAndChildCount = aSlotCount |
-      (aChildCount << 10);
-  }
-
-  bool GrowBy(uint32_t aGrowSize);
-  bool AddAttrSlot();
-
-
-
-
-
-
-  inline void SetChildAtPos(void** aPos, nsIContent* aChild, uint32_t aIndex,
-                            uint32_t aChildCount);
-
-
-
-
-  nsresult DoSetMappedAttrStyleSheet(nsHTMLStyleSheet* aSheet);
-
-  struct InternalAttr
-  {
-    nsAttrName mName;
-    nsAttrValue mValue;
-  };
-
-  struct Impl {
-    uint32_t mAttrAndChildCount;
-    uint32_t mBufferSize;
-    nsMappedAttributes* mMappedAttrs;
-    void* mBuffer[1];
-  };
-
-  Impl* mImpl;
-};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h"
-class nsIAtom;
-
-class nsGkAtoms {
-public:
-
-  static void AddRefAtoms();
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtomList.h" 1
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtomList.h"
-static nsIAtom* _empty;
-static nsIAtom* moz;
-static nsIAtom* mozframetype;
-static nsIAtom* _moz_abspos;
-static nsIAtom* _moz_activated;
-static nsIAtom* _moz_anonclass;
-static nsIAtom* _moz_resizing;
-static nsIAtom* mozallowfullscreen;
-static nsIAtom* moztype;
-static nsIAtom* mozdirty;
-static nsIAtom* mozdisallowselectionprint;
-static nsIAtom* mozdonotsend;
-static nsIAtom* mozeditorbogusnode;
-static nsIAtom* mozgeneratedcontentbefore;
-static nsIAtom* mozgeneratedcontentafter;
-static nsIAtom* mozgeneratedcontentimage;
-static nsIAtom* mozquote;
-static nsIAtom* mozsignature;
-static nsIAtom* _moz_is_glyph;
-static nsIAtom* _moz_original_size;
-static nsIAtom* _moz_target;
-static nsIAtom* menuactive;
-static nsIAtom* _poundDefault;
-static nsIAtom* _asterisk;
-static nsIAtom* a;
-static nsIAtom* abbr;
-static nsIAtom* abort;
-static nsIAtom* above;
-static nsIAtom* acceltext;
-static nsIAtom* accept;
-static nsIAtom* acceptcharset;
-static nsIAtom* accesskey;
-static nsIAtom* acronym;
-static nsIAtom* action;
-static nsIAtom* active;
-static nsIAtom* activetitlebarcolor;
-static nsIAtom* activateontab;
-static nsIAtom* actuate;
-static nsIAtom* address;
-static nsIAtom* after;
-static nsIAtom* after_end;
-static nsIAtom* after_start;
-static nsIAtom* align;
-static nsIAtom* alink;
-static nsIAtom* all;
-static nsIAtom* allowdirs;
-static nsIAtom* allowevents;
-static nsIAtom* allownegativeassertions;
-static nsIAtom* allowforms;
-static nsIAtom* allowfullscreen;
-static nsIAtom* allowmodals;
-static nsIAtom* alloworientationlock;
-static nsIAtom* allowpointerlock;
-static nsIAtom* allowpopupstoescapesandbox;
-static nsIAtom* allowpopups;
-static nsIAtom* allowpresentation;
-static nsIAtom* allowsameorigin;
-static nsIAtom* allowscripts;
-static nsIAtom* allowtopnavigation;
-static nsIAtom* allowuntrusted;
-static nsIAtom* alt;
-static nsIAtom* alternate;
-static nsIAtom* always;
-static nsIAtom* ancestor;
-static nsIAtom* ancestorOrSelf;
-static nsIAtom* anchor;
-static nsIAtom* _and;
-static nsIAtom* animations;
-static nsIAtom* anonid;
-static nsIAtom* anonlocation;
-static nsIAtom* any;
-static nsIAtom* applet;
-static nsIAtom* applyImports;
-static nsIAtom* applyTemplates;
-static nsIAtom* mozapptype;
-static nsIAtom* archive;
-static nsIAtom* area;
-static nsIAtom* arrow;
-static nsIAtom* article;
-static nsIAtom* ascending;
-static nsIAtom* aside;
-static nsIAtom* aspectRatio;
-static nsIAtom* assign;
-static nsIAtom* async;
-static nsIAtom* attribute;
-static nsIAtom* attributes;
-static nsIAtom* attributeSet;
-static nsIAtom* aural;
-static nsIAtom* _auto;
-static nsIAtom* autocheck;
-static nsIAtom* autocomplete;
-static nsIAtom* autofocus;
-static nsIAtom* autoplay;
-static nsIAtom* autorepeatbutton;
-static nsIAtom* axis;
-static nsIAtom* b;
-static nsIAtom* backdropFrame;
-static nsIAtom* background;
-static nsIAtom* base;
-static nsIAtom* basefont;
-static nsIAtom* baseline;
-static nsIAtom* bdi;
-static nsIAtom* bdo;
-static nsIAtom* before;
-static nsIAtom* before_end;
-static nsIAtom* before_start;
-static nsIAtom* below;
-static nsIAtom* bgcolor;
-static nsIAtom* bgsound;
-static nsIAtom* big;
-static nsIAtom* binding;
-static nsIAtom* bindings;
-static nsIAtom* bindToUntrustedContent;
-static nsIAtom* blankrow;
-static nsIAtom* block;
-static nsIAtom* blockquote;
-static nsIAtom* blur;
-static nsIAtom* body;
-static nsIAtom* boolean;
-static nsIAtom* border;
-static nsIAtom* bordercolor;
-static nsIAtom* both;
-static nsIAtom* bottom;
-static nsIAtom* bottomend;
-static nsIAtom* bottomstart;
-static nsIAtom* bottomleft;
-static nsIAtom* bottommargin;
-static nsIAtom* bottompadding;
-static nsIAtom* bottomright;
-static nsIAtom* box;
-static nsIAtom* br;
-static nsIAtom* braille;
-static nsIAtom* broadcast;
-static nsIAtom* broadcaster;
-static nsIAtom* broadcasterset;
-static nsIAtom* browser;
-static nsIAtom* mozbrowser;
-static nsIAtom* bulletinboard;
-static nsIAtom* button;
-static nsIAtom* brighttitlebarforeground;
-static nsIAtom* callTemplate;
-static nsIAtom* cancel;
-static nsIAtom* canvas;
-static nsIAtom* caption;
-static nsIAtom* capture;
-static nsIAtom* caseOrder;
-static nsIAtom* cdataSectionElements;
-static nsIAtom* ceiling;
-static nsIAtom* cell;
-static nsIAtom* cellpadding;
-static nsIAtom* cellspacing;
-static nsIAtom* center;
-static nsIAtom* ch;
-static nsIAtom* change;
-static nsIAtom* _char;
-static nsIAtom* characterData;
-static nsIAtom* charcode;
-static nsIAtom* charoff;
-static nsIAtom* charset;
-static nsIAtom* checkbox;
-static nsIAtom* checked;
-static nsIAtom* child;
-static nsIAtom* children;
-static nsIAtom* childList;
-static nsIAtom* choose;
-static nsIAtom* chromemargin;
-static nsIAtom* chromeOnlyContent;
-static nsIAtom* exposeToUntrustedContent;
-static nsIAtom* circ;
-static nsIAtom* circle;
-static nsIAtom* cite;
-static nsIAtom* _class;
-static nsIAtom* classid;
-static nsIAtom* clear;
-static nsIAtom* click;
-static nsIAtom* clickcount;
-static nsIAtom* clickthrough;
-static nsIAtom* movetoclick;
-static nsIAtom* clip;
-static nsIAtom* close;
-static nsIAtom* closed;
-static nsIAtom* closemenu;
-static nsIAtom* coalesceduplicatearcs;
-static nsIAtom* code;
-static nsIAtom* codebase;
-static nsIAtom* codetype;
-static nsIAtom* col;
-static nsIAtom* colgroup;
-static nsIAtom* collapse;
-static nsIAtom* collapsed;
-static nsIAtom* color;
-static nsIAtom* colorIndex;
-static nsIAtom* cols;
-static nsIAtom* colspan;
-static nsIAtom* column;
-static nsIAtom* columns;
-static nsIAtom* combobox;
-static nsIAtom* command;
-static nsIAtom* commands;
-static nsIAtom* commandset;
-static nsIAtom* commandupdate;
-static nsIAtom* commandupdater;
-static nsIAtom* comment;
-static nsIAtom* compact;
-static nsIAtom* concat;
-static nsIAtom* conditions;
-static nsIAtom* constructor;
-static nsIAtom* consumeoutsideclicks;
-static nsIAtom* container;
-static nsIAtom* containment;
-static nsIAtom* contains;
-static nsIAtom* content;
-static nsIAtom* contenteditable;
-static nsIAtom* headerContentDisposition;
-static nsIAtom* headerContentLanguage;
-static nsIAtom* contentLocation;
-static nsIAtom* headerContentScriptType;
-static nsIAtom* headerContentStyleType;
-static nsIAtom* headerContentType;
-static nsIAtom* consumeanchor;
-static nsIAtom* context;
-static nsIAtom* contextmenu;
-static nsIAtom* control;
-static nsIAtom* controls;
-static nsIAtom* coords;
-static nsIAtom* copy;
-static nsIAtom* copyOf;
-static nsIAtom* count;
-static nsIAtom* crop;
-static nsIAtom* crossorigin;
-static nsIAtom* curpos;
-static nsIAtom* current;
-static nsIAtom* cutoutregion;
-static nsIAtom* cycler;
-static nsIAtom* data;
-static nsIAtom* datalist;
-static nsIAtom* dataType;
-static nsIAtom* dateTime;
-static nsIAtom* datasources;
-static nsIAtom* datetime;
-static nsIAtom* datetimebox;
-static nsIAtom* dblclick;
-static nsIAtom* dd;
-static nsIAtom* debug;
-static nsIAtom* decimalFormat;
-static nsIAtom* decimalSeparator;
-static nsIAtom* deck;
-static nsIAtom* declare;
-static nsIAtom* decoderDoctor;
-static nsIAtom* decrement;
-static nsIAtom* _default;
-static nsIAtom* headerDefaultStyle;
-static nsIAtom* defaultAction;
-static nsIAtom* defaultchecked;
-static nsIAtom* defaultLabel;
-static nsIAtom* defaultselected;
-static nsIAtom* defaultvalue;
-static nsIAtom* defaultplaybackrate;
-static nsIAtom* defer;
-static nsIAtom* del;
-static nsIAtom* descendant;
-static nsIAtom* descendantOrSelf;
-static nsIAtom* descending;
-static nsIAtom* description;
-static nsIAtom* destructor;
-static nsIAtom* details;
-static nsIAtom* deviceAspectRatio;
-static nsIAtom* deviceHeight;
-static nsIAtom* devicePixelRatio;
-static nsIAtom* deviceWidth;
-static nsIAtom* dfn;
-static nsIAtom* dialog;
-static nsIAtom* difference;
-static nsIAtom* digit;
-static nsIAtom* dir;
-static nsIAtom* dirAutoSetBy;
-static nsIAtom* directionality;
-static nsIAtom* directory;
-static nsIAtom* disableOutputEscaping;
-static nsIAtom* disabled;
-static nsIAtom* disableglobalhistory;
-static nsIAtom* disablehistory;
-static nsIAtom* disablefullscreen;
-static nsIAtom* display;
-static nsIAtom* displayMode;
-static nsIAtom* distinct;
-static nsIAtom* div;
-static nsIAtom* dl;
-static nsIAtom* doctypePublic;
-static nsIAtom* doctypeSystem;
-static nsIAtom* document;
-static nsIAtom* download;
-static nsIAtom* DOMAttrModified;
-static nsIAtom* DOMCharacterDataModified;
-static nsIAtom* DOMNodeInserted;
-static nsIAtom* DOMNodeInsertedIntoDocument;
-static nsIAtom* DOMNodeRemoved;
-static nsIAtom* DOMNodeRemovedFromDocument;
-static nsIAtom* DOMSubtreeModified;
-static nsIAtom* double_;
-static nsIAtom* drag;
-static nsIAtom* dragend;
-static nsIAtom* dragenter;
-static nsIAtom* dragevent;
-static nsIAtom* dragexit;
-static nsIAtom* draggable;
-static nsIAtom* dragging;
-static nsIAtom* dragleave;
-static nsIAtom* dragover;
-static nsIAtom* dragSession;
-static nsIAtom* dragstart;
-static nsIAtom* drawintitlebar;
-static nsIAtom* drawtitle;
-static nsIAtom* drop;
-static nsIAtom* dropAfter;
-static nsIAtom* dropBefore;
-static nsIAtom* dropOn;
-static nsIAtom* dropMarker;
-static nsIAtom* dt;
-static nsIAtom* editable;
-static nsIAtom* editing;
-static nsIAtom* editor;
-static nsIAtom* editorDisplayList;
-static nsIAtom* element;
-static nsIAtom* elementAvailable;
-static nsIAtom* elements;
-static nsIAtom* em;
-static nsIAtom* embed;
-static nsIAtom* embossed;
-static nsIAtom* empty;
-static nsIAtom* encoding;
-static nsIAtom* enctype;
-static nsIAtom* end;
-static nsIAtom* endEvent;
-static nsIAtom* end_after;
-static nsIAtom* end_before;
-static nsIAtom* equalsize;
-static nsIAtom* error;
-static nsIAtom* even;
-static nsIAtom* event;
-static nsIAtom* events;
-static nsIAtom* excludeResultPrefixes;
-static nsIAtom* excludes;
-static nsIAtom* expr;
-static nsIAtom* extends;
-static nsIAtom* extensionElementPrefixes;
-static nsIAtom* face;
-static nsIAtom* fallback;
-static nsIAtom* _false;
-static nsIAtom* farthest;
-static nsIAtom* field;
-static nsIAtom* fieldset;
-static nsIAtom* figcaption;
-static nsIAtom* figure;
-static nsIAtom* fixed;
-static nsIAtom* flags;
-static nsIAtom* flex;
-static nsIAtom* flexgroup;
-static nsIAtom* flip;
-static nsIAtom* floating;
-static nsIAtom* floor;
-static nsIAtom* flowlength;
-static nsIAtom* focus;
-static nsIAtom* focused;
-static nsIAtom* followanchor;
-static nsIAtom* following;
-static nsIAtom* followingSibling;
-static nsIAtom* font;
-static nsIAtom* fontWeight;
-static nsIAtom* fontpicker;
-static nsIAtom* footer;
-static nsIAtom* _for;
-static nsIAtom* forEach;
-static nsIAtom* forceOwnRefreshDriver;
-static nsIAtom* form;
-static nsIAtom* formaction;
-static nsIAtom* format;
-static nsIAtom* formatNumber;
-static nsIAtom* formenctype;
-static nsIAtom* formmethod;
-static nsIAtom* formnovalidate;
-static nsIAtom* formtarget;
-static nsIAtom* frame;
-static nsIAtom* frameborder;
-static nsIAtom* frameset;
-static nsIAtom* from;
-static nsIAtom* fullscreenchange;
-static nsIAtom* fullscreenerror;
-static nsIAtom* functionAvailable;
-static nsIAtom* freshProcess;
-static nsIAtom* generateId;
-static nsIAtom* getter;
-static nsIAtom* glyphchar;
-static nsIAtom* glyphid;
-static nsIAtom* grid;
-static nsIAtom* grippy;
-static nsIAtom* group;
-static nsIAtom* groupingSeparator;
-static nsIAtom* groupingSize;
-static nsIAtom* grow;
-static nsIAtom* gutter;
-static nsIAtom* h1;
-static nsIAtom* h2;
-static nsIAtom* h3;
-static nsIAtom* h4;
-static nsIAtom* h5;
-static nsIAtom* h6;
-static nsIAtom* handheld;
-static nsIAtom* handheldFriendly;
-static nsIAtom* handler;
-static nsIAtom* handlers;
-static nsIAtom* HARD;
-static nsIAtom* hasSameNode;
-static nsIAtom* hbox;
-static nsIAtom* head;
-static nsIAtom* header;
-static nsIAtom* headers;
-static nsIAtom* height;
-static nsIAtom* hgroup;
-static nsIAtom* hidden;
-static nsIAtom* hidechrome;
-static nsIAtom* hidecolumnpicker;
-static nsIAtom* high;
-static nsIAtom* highest;
-static nsIAtom* horizontal;
-static nsIAtom* hover;
-static nsIAtom* hr;
-static nsIAtom* href;
-static nsIAtom* hreflang;
-static nsIAtom* hspace;
-static nsIAtom* html;
-static nsIAtom* httpEquiv;
-static nsIAtom* i;
-static nsIAtom* icon;
-static nsIAtom* id;
-static nsIAtom* _if;
-static nsIAtom* iframe;
-static nsIAtom* ignorecase;
-static nsIAtom* ignorekeys;
-static nsIAtom* ignoreuserfocus;
-static nsIAtom* ilayer;
-static nsIAtom* image;
-static nsIAtom* imageClickedPoint;
-static nsIAtom* img;
-static nsIAtom* implementation;
-static nsIAtom* implements;
-static nsIAtom* import;
-static nsIAtom* inactivetitlebarcolor;
-static nsIAtom* include;
-static nsIAtom* includes;
-static nsIAtom* increment;
-static nsIAtom* indent;
-static nsIAtom* indeterminate;
-static nsIAtom* index;
-static nsIAtom* infer;
-static nsIAtom* infinity;
-static nsIAtom* inherit;
-static nsIAtom* inherits;
-static nsIAtom* inheritstyle;
-static nsIAtom* initial_scale;
-static nsIAtom* input;
-static nsIAtom* inputmode;
-static nsIAtom* ins;
-static nsIAtom* insertafter;
-static nsIAtom* insertbefore;
-static nsIAtom* install;
-static nsIAtom* instanceOf;
-static nsIAtom* int32;
-static nsIAtom* int64;
-static nsIAtom* integer;
-static nsIAtom* integrity;
-static nsIAtom* intersection;
-static nsIAtom* is;
-static nsIAtom* iscontainer;
-static nsIAtom* isempty;
-static nsIAtom* ismap;
-static nsIAtom* itemid;
-static nsIAtom* itemprop;
-static nsIAtom* itemref;
-static nsIAtom* itemscope;
-static nsIAtom* itemtype;
-static nsIAtom* kbd;
-static nsIAtom* keepcurrentinview;
-static nsIAtom* keepobjectsalive;
-static nsIAtom* key;
-static nsIAtom* keycode;
-static nsIAtom* keystatuseschange;
-static nsIAtom* keydown;
-static nsIAtom* keygen;
-static nsIAtom* keypress;
-static nsIAtom* keyset;
-static nsIAtom* keysystem;
-static nsIAtom* keytext;
-static nsIAtom* keyup;
-static nsIAtom* kind;
-static nsIAtom* label;
-static nsIAtom* lang;
-static nsIAtom* language;
-static nsIAtom* last;
-static nsIAtom* layer;
-static nsIAtom* LayerActivity;
-static nsIAtom* layout;
-static nsIAtom* leading;
-static nsIAtom* leaf;
-static nsIAtom* left;
-static nsIAtom* leftmargin;
-static nsIAtom* leftpadding;
-static nsIAtom* legend;
-static nsIAtom* length;
-static nsIAtom* letterValue;
-static nsIAtom* level;
-static nsIAtom* li;
-static nsIAtom* line;
-static nsIAtom* link;
-static nsIAtom* list;
-static nsIAtom* listbox;
-static nsIAtom* listboxbody;
-static nsIAtom* listcell;
-static nsIAtom* listcol;
-static nsIAtom* listcols;
-static nsIAtom* listener;
-static nsIAtom* listhead;
-static nsIAtom* listheader;
-static nsIAtom* listing;
-static nsIAtom* listitem;
-static nsIAtom* listrows;
-static nsIAtom* load;
-static nsIAtom* loadingprincipal;
-static nsIAtom* localedir;
-static nsIAtom* localName;
-static nsIAtom* longdesc;
-static nsIAtom* loop;
-static nsIAtom* low;
-static nsIAtom* lowerFirst;
-static nsIAtom* lowest;
-static nsIAtom* lowsrc;
-static nsIAtom* ltr;
-static nsIAtom* lwtheme;
-static nsIAtom* lwthemetextcolor;
-static nsIAtom* main;
-static nsIAtom* map;
-static nsIAtom* manifest;
-static nsIAtom* marginBottom;
-static nsIAtom* marginLeft;
-static nsIAtom* marginRight;
-static nsIAtom* marginTop;
-static nsIAtom* marginheight;
-static nsIAtom* marginwidth;
-static nsIAtom* mark;
-static nsIAtom* marquee;
-static nsIAtom* match;
-static nsIAtom* max;
-static nsIAtom* maxheight;
-static nsIAtom* maximum_scale;
-static nsIAtom* maxlength;
-static nsIAtom* maxpos;
-static nsIAtom* maxwidth;
-static nsIAtom* mayscript;
-static nsIAtom* media;
-static nsIAtom* mediaType;
-static nsIAtom* member;
-static nsIAtom* menu;
-static nsIAtom* menubar;
-static nsIAtom* menubutton;
-static nsIAtom* menuButton;
-static nsIAtom* menugroup;
-static nsIAtom* menuitem;
-static nsIAtom* menulist;
-static nsIAtom* menupopup;
-static nsIAtom* menuseparator;
-static nsIAtom* message;
-static nsIAtom* meta;
-static nsIAtom* referrer;
-static nsIAtom* referrerpolicy;
-static nsIAtom* headerReferrerPolicy;
-static nsIAtom* meter;
-static nsIAtom* method;
-static nsIAtom* middle;
-static nsIAtom* min;
-static nsIAtom* minheight;
-static nsIAtom* minimum_scale;
-static nsIAtom* minlength;
-static nsIAtom* minpos;
-static nsIAtom* minusSign;
-static nsIAtom* minwidth;
-static nsIAtom* _mixed;
-static nsIAtom* messagemanagergroup;
-static nsIAtom* mod;
-static nsIAtom* mode;
-static nsIAtom* modifiers;
-static nsIAtom* monochrome;
-static nsIAtom* mousedown;
-static nsIAtom* mousemove;
-static nsIAtom* mouseout;
-static nsIAtom* mouseover;
-static nsIAtom* mousethrough;
-static nsIAtom* mouseup;
-static nsIAtom* mozaudiochannel;
-static nsIAtom* mozfullscreenchange;
-static nsIAtom* mozfullscreenerror;
-static nsIAtom* mozpointerlockchange;
-static nsIAtom* mozpointerlockerror;
-static nsIAtom* mozprivatebrowsing;
-static nsIAtom* moz_opaque;
-static nsIAtom* moz_action_hint;
-static nsIAtom* x_moz_errormessage;
-static nsIAtom* msthemecompatible;
-static nsIAtom* multicol;
-static nsIAtom* multiple;
-static nsIAtom* muted;
-static nsIAtom* name;
-static nsIAtom* _namespace;
-static nsIAtom* namespaceAlias;
-static nsIAtom* namespaceUri;
-static nsIAtom* NaN;
-static nsIAtom* nativeAnonymousChildList;
-static nsIAtom* nav;
-static nsIAtom* negate;
-static nsIAtom* never;
-static nsIAtom* _new;
-static nsIAtom* newline;
-static nsIAtom* nextBidi;
-static nsIAtom* no;
-static nsIAtom* noautofocus;
-static nsIAtom* noautohide;
-static nsIAtom* norolluponanchor;
-static nsIAtom* nobr;
-static nsIAtom* node;
-static nsIAtom* nodefaultsrc;
-static nsIAtom* nodeSet;
-static nsIAtom* noembed;
-static nsIAtom* noframes;
-static nsIAtom* nohref;
-static nsIAtom* noisolation;
-static nsIAtom* nonce;
-static nsIAtom* none;
-static nsIAtom* noresize;
-static nsIAtom* normal;
-static nsIAtom* normalizeSpace;
-static nsIAtom* noscript;
-static nsIAtom* noshade;
-static nsIAtom* novalidate;
-static nsIAtom* _not;
-static nsIAtom* nowrap;
-static nsIAtom* number;
-static nsIAtom* null;
-static nsIAtom* object;
-static nsIAtom* objectType;
-static nsIAtom* observer;
-static nsIAtom* observes;
-static nsIAtom* odd;
-static nsIAtom* OFF;
-static nsIAtom* ol;
-static nsIAtom* omitXmlDeclaration;
-static nsIAtom* ona2dpstatuschanged;
-static nsIAtom* onabort;
-static nsIAtom* onmozaccesskeynotfound;
-static nsIAtom* onactivate;
-static nsIAtom* onadapteradded;
-static nsIAtom* onadapterremoved;
-static nsIAtom* onafterprint;
-static nsIAtom* onafterscriptexecute;
-static nsIAtom* onalerting;
-static nsIAtom* onanimationcancel;
-static nsIAtom* onanimationend;
-static nsIAtom* onanimationiteration;
-static nsIAtom* onanimationstart;
-static nsIAtom* onantennaavailablechange;
-static nsIAtom* onAppCommand;
-static nsIAtom* onappinstalled;
-static nsIAtom* onattributechanged;
-static nsIAtom* onattributereadreq;
-static nsIAtom* onattributewritereq;
-static nsIAtom* onaudioprocess;
-static nsIAtom* onauxclick;
-static nsIAtom* onbeforecopy;
-static nsIAtom* onbeforecut;
-static nsIAtom* onbeforepaste;
-static nsIAtom* onbeforeevicted;
-static nsIAtom* onbeforeprint;
-static nsIAtom* onbeforescriptexecute;
-static nsIAtom* onbeforeunload;
-static nsIAtom* onblocked;
-static nsIAtom* onblur;
-static nsIAtom* onbroadcast;
-static nsIAtom* onbusy;
-static nsIAtom* onbufferedamountlow;
-static nsIAtom* oncached;
-static nsIAtom* oncallschanged;
-static nsIAtom* oncancel;
-static nsIAtom* oncardstatechange;
-static nsIAtom* oncfstatechange;
-static nsIAtom* onchange;
-static nsIAtom* oncharacteristicchanged;
-static nsIAtom* onchargingchange;
-static nsIAtom* onchargingtimechange;
-static nsIAtom* onchecking;
-static nsIAtom* onclick;
-static nsIAtom* onclirmodechange;
-static nsIAtom* onclose;
-static nsIAtom* oncommand;
-static nsIAtom* oncommandupdate;
-static nsIAtom* oncomplete;
-static nsIAtom* oncompositionend;
-static nsIAtom* oncompositionstart;
-static nsIAtom* oncompositionupdate;
-static nsIAtom* onconnect;
-static nsIAtom* onconnected;
-static nsIAtom* onconnecting;
-static nsIAtom* onconnectionavailable;
-static nsIAtom* onconnectionstatechanged;
-static nsIAtom* oncontextmenu;
-static nsIAtom* oncopy;
-static nsIAtom* oncurrentchannelchanged;
-static nsIAtom* oncurrentsourcechanged;
-static nsIAtom* oncut;
-static nsIAtom* ondatachange;
-static nsIAtom* ondataerror;
-static nsIAtom* ondblclick;
-static nsIAtom* ondeleted;
-static nsIAtom* ondeliverysuccess;
-static nsIAtom* ondeliveryerror;
-static nsIAtom* ondevicefound;
-static nsIAtom* ondevicepaired;
-static nsIAtom* ondeviceunpaired;
-static nsIAtom* ondialing;
-static nsIAtom* ondisabled;
-static nsIAtom* ondischargingtimechange;
-static nsIAtom* ondisconnect;
-static nsIAtom* ondisconnected;
-static nsIAtom* ondisconnecting;
-static nsIAtom* ondisplaypasskeyreq;
-static nsIAtom* ondownloading;
-static nsIAtom* onDOMActivate;
-static nsIAtom* onDOMAttrModified;
-static nsIAtom* onDOMCharacterDataModified;
-static nsIAtom* onDOMFocusIn;
-static nsIAtom* onDOMFocusOut;
-static nsIAtom* onDOMMouseScroll;
-static nsIAtom* onDOMNodeInserted;
-static nsIAtom* onDOMNodeInsertedIntoDocument;
-static nsIAtom* onDOMNodeRemoved;
-static nsIAtom* onDOMNodeRemovedFromDocument;
-static nsIAtom* onDOMSubtreeModified;
-static nsIAtom* ondata;
-static nsIAtom* ondrag;
-static nsIAtom* ondragdrop;
-static nsIAtom* ondragend;
-static nsIAtom* ondragenter;
-static nsIAtom* ondragexit;
-static nsIAtom* ondraggesture;
-static nsIAtom* ondragleave;
-static nsIAtom* ondragover;
-static nsIAtom* ondragstart;
-static nsIAtom* ondrain;
-static nsIAtom* ondrop;
-static nsIAtom* oneitbroadcasted;
-static nsIAtom* onenabled;
-static nsIAtom* onenterpincodereq;
-static nsIAtom* onemergencycbmodechange;
-static nsIAtom* onerror;
-static nsIAtom* onevicted;
-static nsIAtom* onfailed;
-static nsIAtom* onfetch;
-static nsIAtom* onfinish;
-static nsIAtom* onfocus;
-static nsIAtom* onfocusin;
-static nsIAtom* onfocusout;
-static nsIAtom* onfrequencychange;
-static nsIAtom* onfullscreenchange;
-static nsIAtom* onfullscreenerror;
-static nsIAtom* onspeakerforcedchange;
-static nsIAtom* onget;
-static nsIAtom* ongroupchange;
-static nsIAtom* onhashchange;
-static nsIAtom* onheadphoneschange;
-static nsIAtom* onheld;
-static nsIAtom* onhfpstatuschanged;
-static nsIAtom* onhidstatuschanged;
-static nsIAtom* onholding;
-static nsIAtom* oniccchange;
-static nsIAtom* oniccdetected;
-static nsIAtom* oniccinfochange;
-static nsIAtom* oniccundetected;
-static nsIAtom* onincoming;
-static nsIAtom* oninput;
-static nsIAtom* oninstall;
-static nsIAtom* oninvalid;
-static nsIAtom* onkeydown;
-static nsIAtom* onkeypress;
-static nsIAtom* onkeyup;
-static nsIAtom* onlanguagechange;
-static nsIAtom* onlevelchange;
-static nsIAtom* onLoad;
-static nsIAtom* onload;
-static nsIAtom* onloading;
-static nsIAtom* onloadingdone;
-static nsIAtom* onloadingerror;
-static nsIAtom* onpopstate;
-static nsIAtom* only;
-static nsIAtom* onmessage;
-static nsIAtom* onmousedown;
-static nsIAtom* onmouseenter;
-static nsIAtom* onmouseleave;
-static nsIAtom* onmouselongtap;
-static nsIAtom* onmousemove;
-static nsIAtom* onmouseout;
-static nsIAtom* onmouseover;
-static nsIAtom* onMozMouseHittest;
-static nsIAtom* onmouseup;
-static nsIAtom* onMozAfterPaint;
-static nsIAtom* onmozfullscreenchange;
-static nsIAtom* onmozfullscreenerror;
-static nsIAtom* onmozkeydownonplugin;
-static nsIAtom* onmozkeyuponplugin;
-static nsIAtom* onmozpointerlockchange;
-static nsIAtom* onmozpointerlockerror;
-static nsIAtom* onmoztimechange;
-static nsIAtom* onMozMousePixelScroll;
-static nsIAtom* onMozScrolledAreaChanged;
-static nsIAtom* onmoznetworkupload;
-static nsIAtom* onmoznetworkdownload;
-static nsIAtom* onmapfolderlistingreq;
-static nsIAtom* onmapmessageslistingreq;
-static nsIAtom* onmapgetmessagereq;
-static nsIAtom* onmapsetmessagestatusreq;
-static nsIAtom* onmapsendmessagereq;
-static nsIAtom* onmapmessageupdatereq;
-static nsIAtom* onnewrdsgroup;
-static nsIAtom* onnotificationclick;
-static nsIAtom* onnotificationclose;
-static nsIAtom* onnoupdate;
-static nsIAtom* onobexpasswordreq;
-static nsIAtom* onobsolete;
-static nsIAtom* ononline;
-static nsIAtom* onoffline;
-static nsIAtom* onopen;
-static nsIAtom* onorientationchange;
-static nsIAtom* onotastatuschange;
-static nsIAtom* onoverflow;
-static nsIAtom* onoverflowchanged;
-static nsIAtom* onpagehide;
-static nsIAtom* onpageshow;
-static nsIAtom* onpaint;
-static nsIAtom* onpairingaborted;
-static nsIAtom* onpairingconfirmationreq;
-static nsIAtom* onpairingconsentreq;
-static nsIAtom* onpaste;
-static nsIAtom* onpendingchange;
-static nsIAtom* onpichange;
-static nsIAtom* onpointerlockchange;
-static nsIAtom* onpointerlockerror;
-static nsIAtom* onpopuphidden;
-static nsIAtom* onpopuphiding;
-static nsIAtom* onpopuppositioned;
-static nsIAtom* onpopupshowing;
-static nsIAtom* onpopupshown;
-static nsIAtom* onpullphonebookreq;
-static nsIAtom* onpullvcardentryreq;
-static nsIAtom* onpullvcardlistingreq;
-static nsIAtom* onpush;
-static nsIAtom* onpushsubscriptionchange;
-static nsIAtom* onpschange;
-static nsIAtom* onptychange;
-static nsIAtom* onradiostatechange;
-static nsIAtom* onrdsdisabled;
-static nsIAtom* onrdsenabled;
-static nsIAtom* onreaderror;
-static nsIAtom* onreadsuccess;
-static nsIAtom* onready;
-static nsIAtom* onreadystatechange;
-static nsIAtom* onreceived;
-static nsIAtom* onremoteheld;
-static nsIAtom* onremoteresumed;
-static nsIAtom* onrequestprogress;
-static nsIAtom* onresourcetimingbufferfull;
-static nsIAtom* onresponseprogress;
-static nsIAtom* onretrieving;
-static nsIAtom* onRequest;
-static nsIAtom* onrequestmediaplaystatus;
-static nsIAtom* onreset;
-static nsIAtom* onresuming;
-static nsIAtom* onresize;
-static nsIAtom* onrtchange;
-static nsIAtom* onscanningstatechanged;
-static nsIAtom* onscostatuschanged;
-static nsIAtom* onscroll;
-static nsIAtom* onselect;
-static nsIAtom* onselectionchange;
-static nsIAtom* onselectstart;
-static nsIAtom* onsending;
-static nsIAtom* onsent;
-static nsIAtom* onset;
-static nsIAtom* onshow;
-static nsIAtom* onstatechange;
-static nsIAtom* onstatuschanged;
-static nsIAtom* onstkcommand;
-static nsIAtom* onstksessionend;
-static nsIAtom* onstorage;
-static nsIAtom* onstorageareachanged;
-static nsIAtom* onsubmit;
-static nsIAtom* onsuccess;
-static nsIAtom* ontypechange;
-static nsIAtom* onterminate;
-static nsIAtom* ontext;
-static nsIAtom* ontoggle;
-static nsIAtom* ontouchstart;
-static nsIAtom* ontouchend;
-static nsIAtom* ontouchmove;
-static nsIAtom* ontouchcancel;
-static nsIAtom* ontransitioncancel;
-static nsIAtom* ontransitionend;
-static nsIAtom* ontransitionrun;
-static nsIAtom* ontransitionstart;
-static nsIAtom* onunderflow;
-static nsIAtom* onunload;
-static nsIAtom* onupdatefound;
-static nsIAtom* onupdateready;
-static nsIAtom* onupgradeneeded;
-static nsIAtom* onussdreceived;
-static nsIAtom* onversionchange;
-static nsIAtom* onvoicechange;
-static nsIAtom* onvoiceschanged;
-static nsIAtom* onvrdisplayactivate;
-static nsIAtom* onvrdisplayconnect;
-static nsIAtom* onvrdisplaydeactivate;
-static nsIAtom* onvrdisplaydisconnect;
-static nsIAtom* onvrdisplaypresentchange;
-static nsIAtom* onwebkitAnimationEnd;
-static nsIAtom* onwebkitAnimationIteration;
-static nsIAtom* onwebkitAnimationStart;
-static nsIAtom* onwebkitTransitionEnd;
-static nsIAtom* onwebkitanimationend;
-static nsIAtom* onwebkitanimationiteration;
-static nsIAtom* onwebkitanimationstart;
-static nsIAtom* onwebkittransitionend;
-static nsIAtom* onwebsocket;
-static nsIAtom* onwheel;
-static nsIAtom* open;
-static nsIAtom* optgroup;
-static nsIAtom* optimum;
-static nsIAtom* option;
-static nsIAtom* _or;
-static nsIAtom* order;
-static nsIAtom* ordinal;
-static nsIAtom* orient;
-static nsIAtom* orientation;
-static nsIAtom* otherwise;
-static nsIAtom* output;
-static nsIAtom* overflow;
-static nsIAtom* overflowchanged;
-static nsIAtom* overlay;
-static nsIAtom* overlap;
-static nsIAtom* p;
-static nsIAtom* pack;
-static nsIAtom* page;
-static nsIAtom* pageincrement;
-static nsIAtom* pagex;
-static nsIAtom* pagey;
-static nsIAtom* paint_order;
-static nsIAtom* palettename;
-static nsIAtom* panel;
-static nsIAtom* param;
-static nsIAtom* parameter;
-static nsIAtom* parent;
-static nsIAtom* parentfocused;
-static nsIAtom* parsetype;
-static nsIAtom* password;
-static nsIAtom* pattern;
-static nsIAtom* patternSeparator;
-static nsIAtom* perMille;
-static nsIAtom* percent;
-static nsIAtom* persist;
-static nsIAtom* phase;
-static nsIAtom* picture;
-static nsIAtom* ping;
-static nsIAtom* pinned;
-static nsIAtom* placeholder;
-static nsIAtom* plaintext;
-static nsIAtom* playbackrate;
-static nsIAtom* pointSize;
-static nsIAtom* pointerlockchange;
-static nsIAtom* pointerlockerror;
-static nsIAtom* poly;
-static nsIAtom* polygon;
-static nsIAtom* popup;
-static nsIAtom* popupalign;
-static nsIAtom* popupanchor;
-static nsIAtom* popupgroup;
-static nsIAtom* popuphidden;
-static nsIAtom* popuphiding;
-static nsIAtom* popupset;
-static nsIAtom* popupshowing;
-static nsIAtom* popupshown;
-static nsIAtom* popupsinherittooltip;
-static nsIAtom* position;
-static nsIAtom* poster;
-static nsIAtom* pre;
-static nsIAtom* preceding;
-static nsIAtom* precedingSibling;
-static nsIAtom* predicate;
-static nsIAtom* prefix;
-static nsIAtom* preload;
-static nsIAtom* prerendered;
-static nsIAtom* mozpresentation;
-static nsIAtom* preserve;
-static nsIAtom* preserveSpace;
-static nsIAtom* preventdefault;
-static nsIAtom* primary;
-static nsIAtom* print;
-static nsIAtom* priority;
-static nsIAtom* processingInstruction;
-static nsIAtom* profile;
-static nsIAtom* progress;
-static nsIAtom* progressmeter;
-static nsIAtom* progressNormal;
-static nsIAtom* progressUndetermined;
-static nsIAtom* projection;
-static nsIAtom* prompt;
-static nsIAtom* propagate;
-static nsIAtom* properties;
-static nsIAtom* property;
-static nsIAtom* pubdate;
-static nsIAtom* q;
-static nsIAtom* query;
-static nsIAtom* queryset;
-static nsIAtom* querytype;
-static nsIAtom* radio;
-static nsIAtom* radiogroup;
-static nsIAtom* range;
-static nsIAtom* readonly;
-static nsIAtom* rect;
-static nsIAtom* rectangle;
-static nsIAtom* ref;
-static nsIAtom* refresh;
-static nsIAtom* rel;
-static nsIAtom* onreloadpage;
-static nsIAtom* rem;
-static nsIAtom* removeelement;
-static nsIAtom* renderingobserverlist;
-static nsIAtom* repeat;
-static nsIAtom* replace;
-static nsIAtom* required;
-static nsIAtom* reserved;
-static nsIAtom* reset;
-static nsIAtom* resizeafter;
-static nsIAtom* resizebefore;
-static nsIAtom* resizer;
-static nsIAtom* resolution;
-static nsIAtom* resource;
-static nsIAtom* resources;
-static nsIAtom* result;
-static nsIAtom* resultPrefix;
-static nsIAtom* retargetdocumentfocus;
-static nsIAtom* rev;
-static nsIAtom* reverse;
-static nsIAtom* reversed;
-static nsIAtom* richlistbox;
-static nsIAtom* richlistitem;
-static nsIAtom* right;
-static nsIAtom* rightmargin;
-static nsIAtom* rightpadding;
-static nsIAtom* role;
-static nsIAtom* rolluponmousewheel;
-static nsIAtom* round;
-static nsIAtom* row;
-static nsIAtom* rows;
-static nsIAtom* rowspan;
-static nsIAtom* rb;
-static nsIAtom* rp;
-static nsIAtom* rt;
-static nsIAtom* rtc;
-static nsIAtom* rtl;
-static nsIAtom* ruby;
-static nsIAtom* rubyBase;
-static nsIAtom* rubyBaseContainer;
-static nsIAtom* rubyText;
-static nsIAtom* rubyTextContainer;
-static nsIAtom* rule;
-static nsIAtom* rules;
-static nsIAtom* s;
-static nsIAtom* samp;
-static nsIAtom* sandbox;
-static nsIAtom* sbattr;
-static nsIAtom* scale;
-static nsIAtom* scan;
-static nsIAtom* scheme;
-static nsIAtom* scope;
-static nsIAtom* scoped;
-static nsIAtom* screen;
-static nsIAtom* screenX;
-static nsIAtom* screenY;
-static nsIAtom* script;
-static nsIAtom* scriptEnabledBeforePrintOrPreview;
-static nsIAtom* scrollbar;
-static nsIAtom* scrollbarbutton;
-static nsIAtom* scrollbarDownBottom;
-static nsIAtom* scrollbarDownTop;
-static nsIAtom* scrollbarUpBottom;
-static nsIAtom* scrollbarUpTop;
-static nsIAtom* scrollbox;
-static nsIAtom* scrollcorner;
-static nsIAtom* scrolling;
-static nsIAtom* scrollPosition;
-static nsIAtom* section;
-static nsIAtom* select;
-static nsIAtom* selectable;
-static nsIAtom* selected;
-static nsIAtom* selectedIndex;
-static nsIAtom* selectedindex;
-static nsIAtom* self;
-static nsIAtom* seltype;
-static nsIAtom* setcookie;
-static nsIAtom* setter;
-static nsIAtom* shape;
-static nsIAtom* show;
-static nsIAtom* showcaret;
-static nsIAtom* showresizer;
-static nsIAtom* simple;
-static nsIAtom* single;
-static nsIAtom* size;
-static nsIAtom* sizes;
-static nsIAtom* sizemode;
-static nsIAtom* sizetopopup;
-static nsIAtom* slider;
-static nsIAtom* small;
-static nsIAtom* smooth;
-static nsIAtom* snap;
-static nsIAtom* sort;
-static nsIAtom* sortActive;
-static nsIAtom* sortDirection;
-static nsIAtom* sorted;
-static nsIAtom* sorthints;
-static nsIAtom* sortLocked;
-static nsIAtom* sortResource;
-static nsIAtom* sortResource2;
-static nsIAtom* sortSeparators;
-static nsIAtom* sortStaticsLast;
-static nsIAtom* source;
-static nsIAtom* space;
-static nsIAtom* spacer;
-static nsIAtom* span;
-static nsIAtom* spellcheck;
-static nsIAtom* spinner;
-static nsIAtom* split;
-static nsIAtom* splitter;
-static nsIAtom* spring;
-static nsIAtom* src;
-static nsIAtom* srcdoc;
-static nsIAtom* srclang;
-static nsIAtom* srcset;
-static nsIAtom* stack;
-static nsIAtom* standalone;
-static nsIAtom* standby;
-static nsIAtom* start;
-static nsIAtom* start_after;
-static nsIAtom* start_before;
-static nsIAtom* startsWith;
-static nsIAtom* state;
-static nsIAtom* statedatasource;
-static nsIAtom* staticHint;
-static nsIAtom* statusbar;
-static nsIAtom* statustext;
-static nsIAtom* step;
-static nsIAtom* stop;
-static nsIAtom* stretch;
-static nsIAtom* strike;
-static nsIAtom* string;
-static nsIAtom* stringLength;
-static nsIAtom* stripSpace;
-static nsIAtom* strong;
-static nsIAtom* style;
-static nsIAtom* stylesheet;
-static nsIAtom* stylesheetPrefix;
-static nsIAtom* subject;
-static nsIAtom* submit;
-static nsIAtom* substate;
-static nsIAtom* substring;
-static nsIAtom* substringAfter;
-static nsIAtom* substringBefore;
-static nsIAtom* sub;
-static nsIAtom* sum;
-static nsIAtom* sup;
-static nsIAtom* summary;
-static nsIAtom* systemProperty;
-static nsIAtom* tab;
-static nsIAtom* tabbox;
-static nsIAtom* tabindex;
-static nsIAtom* table;
-static nsIAtom* tabpanel;
-static nsIAtom* tabpanels;
-static nsIAtom* tag;
-static nsIAtom* target;
-static nsIAtom* targets;
-static nsIAtom* tbody;
-static nsIAtom* td;
-static nsIAtom* _template;
-static nsIAtom* text_decoration;
-static nsIAtom* terminate;
-static nsIAtom* test;
-static nsIAtom* text;
-static nsIAtom* textAlign;
-static nsIAtom* textarea;
-static nsIAtom* textbox;
-static nsIAtom* textnode;
-static nsIAtom* textNodeDirectionalityMap;
-static nsIAtom* tfoot;
-static nsIAtom* th;
-static nsIAtom* thead;
-static nsIAtom* thumb;
-static nsIAtom* time;
-static nsIAtom* title;
-static nsIAtom* titlebar;
-static nsIAtom* titletip;
-static nsIAtom* toggled;
-static nsIAtom* token;
-static nsIAtom* tokenize;
-static nsIAtom* toolbar;
-static nsIAtom* toolbarbutton;
-static nsIAtom* toolbaritem;
-static nsIAtom* toolbox;
-static nsIAtom* tooltip;
-static nsIAtom* tooltiptext;
-static nsIAtom* top;
-static nsIAtom* topleft;
-static nsIAtom* topmargin;
-static nsIAtom* toppadding;
-static nsIAtom* topright;
-static nsIAtom* tr;
-static nsIAtom* track;
-static nsIAtom* trailing;
-static nsIAtom* transform;
-static nsIAtom* transform_3d;
-static nsIAtom* transformiix;
-static nsIAtom* translate;
-static nsIAtom* transparent;
-static nsIAtom* tree;
-static nsIAtom* treecell;
-static nsIAtom* treechildren;
-static nsIAtom* treecol;
-static nsIAtom* treecolpicker;
-static nsIAtom* treecols;
-static nsIAtom* treeitem;
-static nsIAtom* treerow;
-static nsIAtom* treeseparator;
-static nsIAtom* triple;
-static nsIAtom* _true;
-static nsIAtom* tt;
-static nsIAtom* tty;
-static nsIAtom* tv;
-static nsIAtom* type;
-static nsIAtom* typemustmatch;
-static nsIAtom* u;
-static nsIAtom* ul;
-static nsIAtom* underflow;
-static nsIAtom* undetermined;
-static nsIAtom* unload;
-static nsIAtom* unparsedEntityUri;
-static nsIAtom* upperFirst;
-static nsIAtom* uri;
-static nsIAtom* use;
-static nsIAtom* useAttributeSets;
-static nsIAtom* usemap;
-static nsIAtom* user_scalable;
-static nsIAtom* userInput;
-static nsIAtom* validate;
-static nsIAtom* valign;
-static nsIAtom* value;
-static nsIAtom* values;
-static nsIAtom* valueOf;
-static nsIAtom* valuetype;
-static nsIAtom* var;
-static nsIAtom* variable;
-static nsIAtom* vbox;
-static nsIAtom* vcard_name;
-static nsIAtom* vendor;
-static nsIAtom* vendorUrl;
-static nsIAtom* version;
-static nsIAtom* vert;
-static nsIAtom* vertical;
-static nsIAtom* audio;
-static nsIAtom* video;
-static nsIAtom* videocontrols;
-static nsIAtom* viewport;
-static nsIAtom* viewport_height;
-static nsIAtom* viewport_initial_scale;
-static nsIAtom* viewport_maximum_scale;
-static nsIAtom* viewport_minimum_scale;
-static nsIAtom* viewport_user_scalable;
-static nsIAtom* viewport_width;
-static nsIAtom* visibility;
-static nsIAtom* visuallyselected;
-static nsIAtom* vlink;
-static nsIAtom* vspace;
-static nsIAtom* wbr;
-static nsIAtom* webkitdirectory;
-static nsIAtom* when;
-static nsIAtom* where;
-static nsIAtom* widget;
-static nsIAtom* width;
-static nsIAtom* willChange;
-static nsIAtom* window;
-static nsIAtom* headerWindowTarget;
-static nsIAtom* windowtype;
-static nsIAtom* withParam;
-static nsIAtom* wizard;
-static nsIAtom* wrap;
-static nsIAtom* headerDNSPrefetchControl;
-static nsIAtom* headerCSP;
-static nsIAtom* headerCSPReportOnly;
-static nsIAtom* headerXFO;
-static nsIAtom* x_western;
-static nsIAtom* xml;
-static nsIAtom* xml_stylesheet;
-static nsIAtom* xmlns;
-static nsIAtom* xmp;
-static nsIAtom* xulcontentsgenerated;
-static nsIAtom* yes;
-static nsIAtom* z_index;
-static nsIAtom* zeroDigit;
-
-
-static nsIAtom* percentage;
-static nsIAtom* A;
-static nsIAtom* alignment_baseline;
-static nsIAtom* amplitude;
-static nsIAtom* animate;
-static nsIAtom* animateColor;
-static nsIAtom* animateMotion;
-static nsIAtom* animateTransform;
-static nsIAtom* arithmetic;
-static nsIAtom* atop;
-static nsIAtom* azimuth;
-static nsIAtom* B;
-static nsIAtom* backgroundColor;
-static nsIAtom* background_image;
-static nsIAtom* baseFrequency;
-static nsIAtom* baseline_shift;
-static nsIAtom* bias;
-static nsIAtom* caption_side;
-static nsIAtom* clip_path;
-static nsIAtom* clip_rule;
-static nsIAtom* clipPath;
-static nsIAtom* clipPathUnits;
-static nsIAtom* cm;
-static nsIAtom* colorBurn;
-static nsIAtom* colorDodge;
-static nsIAtom* colorInterpolation;
-static nsIAtom* colorInterpolationFilters;
-static nsIAtom* colorProfile;
-static nsIAtom* cursor;
-static nsIAtom* cx;
-static nsIAtom* cy;
-static nsIAtom* d;
-static nsIAtom* darken;
-static nsIAtom* defs;
-static nsIAtom* deg;
-static nsIAtom* desc;
-static nsIAtom* diffuseConstant;
-static nsIAtom* dilate;
-static nsIAtom* direction;
-static nsIAtom* disable;
-static nsIAtom* discrete;
-static nsIAtom* divisor;
-static nsIAtom* dominant_baseline;
-static nsIAtom* duplicate;
-static nsIAtom* dx;
-static nsIAtom* dy;
-static nsIAtom* edgeMode;
-static nsIAtom* ellipse;
-static nsIAtom* elevation;
-static nsIAtom* erode;
-static nsIAtom* ex;
-static nsIAtom* exact;
-static nsIAtom* exclusion;
-static nsIAtom* exponent;
-static nsIAtom* feBlend;
-static nsIAtom* feColorMatrix;
-static nsIAtom* feComponentTransfer;
-static nsIAtom* feComposite;
-static nsIAtom* feConvolveMatrix;
-static nsIAtom* feDiffuseLighting;
-static nsIAtom* feDisplacementMap;
-static nsIAtom* feDistantLight;
-static nsIAtom* feDropShadow;
-static nsIAtom* feFlood;
-static nsIAtom* feFuncA;
-static nsIAtom* feFuncB;
-static nsIAtom* feFuncG;
-static nsIAtom* feFuncR;
-static nsIAtom* feGaussianBlur;
-static nsIAtom* feImage;
-static nsIAtom* feMerge;
-static nsIAtom* feMergeNode;
-static nsIAtom* feMorphology;
-static nsIAtom* feOffset;
-static nsIAtom* fePointLight;
-static nsIAtom* feSpecularLighting;
-static nsIAtom* feSpotLight;
-static nsIAtom* feTile;
-static nsIAtom* feTurbulence;
-static nsIAtom* fill;
-static nsIAtom* fill_opacity;
-static nsIAtom* fill_rule;
-static nsIAtom* filter;
-static nsIAtom* filterUnits;
-static nsIAtom* _float;
-static nsIAtom* flood_color;
-static nsIAtom* flood_opacity;
-static nsIAtom* font_face;
-static nsIAtom* font_face_format;
-static nsIAtom* font_face_name;
-static nsIAtom* font_face_src;
-static nsIAtom* font_face_uri;
-static nsIAtom* font_family;
-static nsIAtom* font_size;
-static nsIAtom* font_size_adjust;
-static nsIAtom* font_stretch;
-static nsIAtom* font_style;
-static nsIAtom* font_variant;
-static nsIAtom* foreignObject;
-static nsIAtom* fractalNoise;
-static nsIAtom* fx;
-static nsIAtom* fy;
-static nsIAtom* G;
-static nsIAtom* g;
-static nsIAtom* gamma;
-
-static nsIAtom* generic_;
-static nsIAtom* glyphRef;
-static nsIAtom* grad;
-static nsIAtom* gradientTransform;
-static nsIAtom* gradientUnits;
-static nsIAtom* hardLight;
-static nsIAtom* hue;
-static nsIAtom* hueRotate;
-static nsIAtom* identity;
-static nsIAtom* image_rendering;
-static nsIAtom* in;
-static nsIAtom* in2;
-static nsIAtom* intercept;
-static nsIAtom* k1;
-static nsIAtom* k2;
-static nsIAtom* k3;
-static nsIAtom* k4;
-static nsIAtom* kernelMatrix;
-static nsIAtom* kernelUnitLength;
-static nsIAtom* lengthAdjust;
-static nsIAtom* letter_spacing;
-static nsIAtom* lighten;
-static nsIAtom* lighting_color;
-static nsIAtom* limitingConeAngle;
-static nsIAtom* linear;
-static nsIAtom* linearGradient;
-static nsIAtom* linearRGB;
-static nsIAtom* list_style_type;
-static nsIAtom* luminanceToAlpha;
-static nsIAtom* luminosity;
-static nsIAtom* magnify;
-static nsIAtom* marker;
-static nsIAtom* marker_end;
-static nsIAtom* marker_mid;
-static nsIAtom* marker_start;
-static nsIAtom* markerHeight;
-static nsIAtom* markerUnits;
-static nsIAtom* markerWidth;
-static nsIAtom* mask;
-static nsIAtom* maskContentUnits;
-static nsIAtom* mask_type;
-static nsIAtom* maskUnits;
-static nsIAtom* matrix;
-static nsIAtom* metadata;
-static nsIAtom* missingGlyph;
-static nsIAtom* mm;
-static nsIAtom* mpath;
-static nsIAtom* noStitch;
-static nsIAtom* numOctaves;
-static nsIAtom* multiply;
-static nsIAtom* objectBoundingBox;
-static nsIAtom* offset;
-static nsIAtom* onSVGLoad;
-static nsIAtom* onSVGResize;
-static nsIAtom* onSVGScroll;
-static nsIAtom* onSVGUnload;
-static nsIAtom* onSVGZoom;
-static nsIAtom* onzoom;
-static nsIAtom* opacity;
-static nsIAtom* _operator;
-static nsIAtom* out;
-static nsIAtom* over;
-static nsIAtom* overridePreserveAspectRatio;
-static nsIAtom* pad;
-static nsIAtom* path;
-static nsIAtom* pathLength;
-static nsIAtom* patternContentUnits;
-static nsIAtom* patternTransform;
-static nsIAtom* patternUnits;
-static nsIAtom* pc;
-static nsIAtom* pointer_events;
-static nsIAtom* points;
-static nsIAtom* pointsAtX;
-static nsIAtom* pointsAtY;
-static nsIAtom* pointsAtZ;
-static nsIAtom* polyline;
-static nsIAtom* preserveAlpha;
-static nsIAtom* preserveAspectRatio;
-static nsIAtom* primitiveUnits;
-static nsIAtom* pt;
-static nsIAtom* px;
-static nsIAtom* R;
-static nsIAtom* r;
-static nsIAtom* rad;
-static nsIAtom* radialGradient;
-static nsIAtom* radius;
-static nsIAtom* reflect;
-static nsIAtom* refX;
-static nsIAtom* refY;
-static nsIAtom* requiredExtensions;
-static nsIAtom* requiredFeatures;
-static nsIAtom* rotate;
-static nsIAtom* rx;
-static nsIAtom* ry;
-static nsIAtom* saturate;
-static nsIAtom* saturation;
-static nsIAtom* set;
-static nsIAtom* seed;
-static nsIAtom* shadow;
-static nsIAtom* shape_rendering;
-static nsIAtom* skewX;
-static nsIAtom* skewY;
-static nsIAtom* slope;
-static nsIAtom* softLight;
-static nsIAtom* spacing;
-static nsIAtom* spacingAndGlyphs;
-static nsIAtom* specularConstant;
-static nsIAtom* specularExponent;
-static nsIAtom* spreadMethod;
-static nsIAtom* sRGB;
-static nsIAtom* startOffset;
-static nsIAtom* stdDeviation;
-static nsIAtom* stitch;
-static nsIAtom* stitchTiles;
-static nsIAtom* stop_color;
-static nsIAtom* stop_opacity;
-static nsIAtom* stroke;
-static nsIAtom* stroke_dasharray;
-static nsIAtom* stroke_dashoffset;
-static nsIAtom* stroke_linecap;
-static nsIAtom* stroke_linejoin;
-static nsIAtom* stroke_miterlimit;
-static nsIAtom* stroke_opacity;
-static nsIAtom* stroke_width;
-static nsIAtom* strokeWidth;
-static nsIAtom* surfaceScale;
-static nsIAtom* svg;
-static nsIAtom* svgContextPaint;
-static nsIAtom* svgSwitch;
-static nsIAtom* symbol;
-static nsIAtom* systemLanguage;
-static nsIAtom* tableValues;
-static nsIAtom* targetX;
-static nsIAtom* targetY;
-static nsIAtom* text_anchor;
-static nsIAtom* text_rendering;
-static nsIAtom* textLength;
-static nsIAtom* textPath;
-static nsIAtom* tref;
-static nsIAtom* tspan;
-static nsIAtom* turbulence;
-static nsIAtom* unicode_bidi;
-static nsIAtom* userSpaceOnUse;
-static nsIAtom* view;
-static nsIAtom* viewBox;
-static nsIAtom* viewTarget;
-static nsIAtom* white_space;
-static nsIAtom* word_spacing;
-static nsIAtom* writing_mode;
-static nsIAtom* x;
-static nsIAtom* x1;
-static nsIAtom* x2;
-static nsIAtom* xChannelSelector;
-static nsIAtom* xor_;
-static nsIAtom* y;
-static nsIAtom* y1;
-static nsIAtom* y2;
-static nsIAtom* yChannelSelector;
-static nsIAtom* z;
-static nsIAtom* zoomAndPan;
-static nsIAtom* vector_effect;
-static nsIAtom* vertical_align;
-
-static nsIAtom* accumulate;
-static nsIAtom* additive;
-static nsIAtom* attributeName;
-static nsIAtom* attributeType;
-static nsIAtom* auto_reverse;
-static nsIAtom* begin;
-static nsIAtom* beginEvent;
-static nsIAtom* by;
-static nsIAtom* calcMode;
-static nsIAtom* css;
-static nsIAtom* dur;
-static nsIAtom* keyPoints;
-static nsIAtom* keySplines;
-static nsIAtom* keyTimes;
-static nsIAtom* mozAnimateMotionDummyAttr;
-static nsIAtom* onbegin;
-static nsIAtom* onbeginEvent;
-static nsIAtom* onend;
-static nsIAtom* onendEvent;
-static nsIAtom* onrepeat;
-static nsIAtom* onrepeatEvent;
-static nsIAtom* repeatCount;
-static nsIAtom* repeatDur;
-static nsIAtom* repeatEvent;
-static nsIAtom* restart;
-static nsIAtom* to;
-static nsIAtom* XML;
-
-static nsIAtom* abs_;
-static nsIAtom* accent_;
-static nsIAtom* accentunder_;
-static nsIAtom* actiontype_;
-static nsIAtom* alignmentscope_;
-static nsIAtom* altimg_;
-static nsIAtom* altimg_height_;
-static nsIAtom* altimg_valign_;
-static nsIAtom* altimg_width_;
-static nsIAtom* annotation_;
-static nsIAtom* annotation_xml_;
-static nsIAtom* apply_;
-static nsIAtom* approx_;
-static nsIAtom* arccos_;
-static nsIAtom* arccosh_;
-static nsIAtom* arccot_;
-static nsIAtom* arccoth_;
-static nsIAtom* arccsc_;
-static nsIAtom* arccsch_;
-static nsIAtom* arcsec_;
-static nsIAtom* arcsech_;
-static nsIAtom* arcsin_;
-static nsIAtom* arcsinh_;
-static nsIAtom* arctan_;
-static nsIAtom* arctanh_;
-static nsIAtom* arg_;
-static nsIAtom* bevelled_;
-static nsIAtom* bind_;
-static nsIAtom* bvar_;
-static nsIAtom* card_;
-static nsIAtom* cartesianproduct_;
-static nsIAtom* cbytes_;
-static nsIAtom* cd_;
-static nsIAtom* cdgroup_;
-static nsIAtom* cerror_;
-static nsIAtom* charalign_;
-static nsIAtom* ci_;
-static nsIAtom* closure_;
-static nsIAtom* cn_;
-static nsIAtom* codomain_;
-static nsIAtom* columnalign_;
-static nsIAtom* columnalignment_;
-static nsIAtom* columnlines_;
-static nsIAtom* columnspacing_;
-static nsIAtom* columnspan_;
-static nsIAtom* columnwidth_;
-static nsIAtom* complexes_;
-static nsIAtom* compose_;
-static nsIAtom* condition_;
-static nsIAtom* conjugate_;
-static nsIAtom* cos_;
-static nsIAtom* cosh_;
-static nsIAtom* cot_;
-static nsIAtom* coth_;
-static nsIAtom* crossout_;
-static nsIAtom* csc_;
-static nsIAtom* csch_;
-static nsIAtom* cs_;
-static nsIAtom* csymbol_;
-static nsIAtom* curl_;
-static nsIAtom* decimalpoint_;
-static nsIAtom* definitionURL_;
-static nsIAtom* degree_;
-static nsIAtom* denomalign_;
-static nsIAtom* depth_;
-static nsIAtom* determinant_;
-static nsIAtom* diff_;
-static nsIAtom* displaystyle_;
-static nsIAtom* divergence_;
-static nsIAtom* divide_;
-static nsIAtom* domain_;
-static nsIAtom* domainofapplication_;
-static nsIAtom* edge_;
-static nsIAtom* el_;
-static nsIAtom* emptyset_;
-static nsIAtom* eq_;
-static nsIAtom* equalcolumns_;
-static nsIAtom* equalrows_;
-static nsIAtom* equivalent_;
-static nsIAtom* eulergamma_;
-static nsIAtom* exists_;
-static nsIAtom* exp_;
-static nsIAtom* exponentiale_;
-static nsIAtom* factorial_;
-static nsIAtom* factorof_;
-static nsIAtom* fence_;
-static nsIAtom* fn_;
-static nsIAtom* fontfamily_;
-static nsIAtom* fontsize_;
-static nsIAtom* fontstyle_;
-static nsIAtom* fontweight_;
-static nsIAtom* forall_;
-static nsIAtom* framespacing_;
-static nsIAtom* gcd_;
-static nsIAtom* geq_;
-static nsIAtom* groupalign_;
-static nsIAtom* gt_;
-static nsIAtom* ident_;
-static nsIAtom* imaginaryi_;
-static nsIAtom* imaginary_;
-static nsIAtom* implies_;
-static nsIAtom* indentalignfirst_;
-static nsIAtom* indentalign_;
-static nsIAtom* indentalignlast_;
-static nsIAtom* indentshiftfirst_;
-static nsIAtom* indentshift_;
-static nsIAtom* indenttarget_;
-static nsIAtom* integers_;
-static nsIAtom* intersect_;
-static nsIAtom* interval_;
-static nsIAtom* int_;
-static nsIAtom* inverse_;
-static nsIAtom* lambda_;
-static nsIAtom* laplacian_;
-static nsIAtom* largeop_;
-static nsIAtom* lcm_;
-static nsIAtom* leq_;
-static nsIAtom* limit_;
-static nsIAtom* linebreak_;
-static nsIAtom* linebreakmultchar_;
-static nsIAtom* linebreakstyle_;
-static nsIAtom* linethickness_;
-static nsIAtom* list_;
-static nsIAtom* ln_;
-static nsIAtom* location_;
-static nsIAtom* logbase_;
-static nsIAtom* log_;
-static nsIAtom* longdivstyle_;
-static nsIAtom* lowlimit_;
-static nsIAtom* lquote_;
-static nsIAtom* lspace_;
-static nsIAtom* lt_;
-static nsIAtom* maction_;
-static nsIAtom* maligngroup_;
-static nsIAtom* malignmark_;
-static nsIAtom* mathbackground_;
-static nsIAtom* mathcolor_;
-static nsIAtom* mathsize_;
-static nsIAtom* mathvariant_;
-static nsIAtom* matrixrow_;
-static nsIAtom* maxsize_;
-static nsIAtom* mean_;
-static nsIAtom* median_;
-static nsIAtom* menclose_;
-static nsIAtom* merror_;
-static nsIAtom* mfenced_;
-static nsIAtom* mfrac_;
-static nsIAtom* mglyph_;
-static nsIAtom* mi_;
-static nsIAtom* minlabelspacing_;
-static nsIAtom* minsize_;
-static nsIAtom* minus_;
-static nsIAtom* mlabeledtr_;
-static nsIAtom* mlongdiv_;
-static nsIAtom* mmultiscripts_;
-static nsIAtom* mn_;
-static nsIAtom* momentabout_;
-static nsIAtom* moment_;
-static nsIAtom* mo_;
-static nsIAtom* movablelimits_;
-static nsIAtom* mover_;
-static nsIAtom* mpadded_;
-static nsIAtom* mphantom_;
-static nsIAtom* mprescripts_;
-static nsIAtom* mroot_;
-static nsIAtom* mrow_;
-static nsIAtom* mscarries_;
-static nsIAtom* mscarry_;
-static nsIAtom* msgroup_;
-static nsIAtom* msline_;
-static nsIAtom* ms_;
-static nsIAtom* mspace_;
-static nsIAtom* msqrt_;
-static nsIAtom* msrow_;
-static nsIAtom* mstack_;
-static nsIAtom* mstyle_;
-static nsIAtom* msub_;
-static nsIAtom* msubsup_;
-static nsIAtom* msup_;
-static nsIAtom* mtable_;
-static nsIAtom* mtd_;
-static nsIAtom* mtext_;
-static nsIAtom* mtr_;
-static nsIAtom* munder_;
-static nsIAtom* munderover_;
-static nsIAtom* naturalnumbers_;
-static nsIAtom* neq_;
-static nsIAtom* notanumber_;
-static nsIAtom* notation_;
-static nsIAtom* note_;
-static nsIAtom* notin_;
-static nsIAtom* notprsubset_;
-static nsIAtom* notsubset_;
-static nsIAtom* numalign_;
-static nsIAtom* other_;
-static nsIAtom* outerproduct_;
-static nsIAtom* partialdiff_;
-static nsIAtom* piece_;
-static nsIAtom* piecewise_;
-static nsIAtom* pi_;
-static nsIAtom* plus_;
-static nsIAtom* power_;
-static nsIAtom* primes_;
-static nsIAtom* product_;
-static nsIAtom* prsubset_;
-static nsIAtom* quotient_;
-static nsIAtom* rationals_;
-static nsIAtom* real_;
-static nsIAtom* reals_;
-static nsIAtom* reln_;
-static nsIAtom* root_;
-static nsIAtom* rowalign_;
-static nsIAtom* rowlines_;
-static nsIAtom* rowspacing_;
-static nsIAtom* rquote_;
-static nsIAtom* rspace_;
-static nsIAtom* scalarproduct_;
-static nsIAtom* schemaLocation_;
-static nsIAtom* scriptlevel_;
-static nsIAtom* scriptminsize_;
-static nsIAtom* scriptsizemultiplier_;
-static nsIAtom* scriptsize_;
-static nsIAtom* sdev_;
-static nsIAtom* sech_;
-static nsIAtom* sec_;
-static nsIAtom* selection_;
-static nsIAtom* selector_;
-static nsIAtom* semantics_;
-static nsIAtom* separator_;
-static nsIAtom* separators_;
-static nsIAtom* sep_;
-static nsIAtom* setdiff_;
-static nsIAtom* set_;
-static nsIAtom* share_;
-static nsIAtom* shift_;
-static nsIAtom* side_;
-static nsIAtom* sinh_;
-static nsIAtom* sin_;
-static nsIAtom* stackalign_;
-static nsIAtom* stretchy_;
-static nsIAtom* subscriptshift_;
-static nsIAtom* subset_;
-static nsIAtom* superscriptshift_;
-static nsIAtom* symmetric_;
-static nsIAtom* tanh_;
-static nsIAtom* tan_;
-static nsIAtom* tendsto_;
-static nsIAtom* times_;
-static nsIAtom* transpose_;
-static nsIAtom* union_;
-static nsIAtom* uplimit_;
-static nsIAtom* variance_;
-static nsIAtom* vectorproduct_;
-static nsIAtom* vector_;
-static nsIAtom* voffset_;
-static nsIAtom* xref_;
-static nsIAtom* math;
-static nsIAtom* avg;
-static nsIAtom* booleanFromString;
-static nsIAtom* countNonEmpty;
-static nsIAtom* daysFromDate;
-static nsIAtom* init;
-static nsIAtom* instance;
-static nsIAtom* months;
-static nsIAtom* now;
-static nsIAtom* seconds;
-static nsIAtom* secondsFromDateTime;
-
-
-static nsIAtom* onMozSwipeGestureMayStart;
-static nsIAtom* onMozSwipeGestureStart;
-static nsIAtom* onMozSwipeGestureUpdate;
-static nsIAtom* onMozSwipeGestureEnd;
-static nsIAtom* onMozSwipeGesture;
-static nsIAtom* onMozMagnifyGestureStart;
-static nsIAtom* onMozMagnifyGestureUpdate;
-static nsIAtom* onMozMagnifyGesture;
-static nsIAtom* onMozRotateGestureStart;
-static nsIAtom* onMozRotateGestureUpdate;
-static nsIAtom* onMozRotateGesture;
-static nsIAtom* onMozTapGesture;
-static nsIAtom* onMozPressTapGesture;
-static nsIAtom* onMozEdgeUIStarted;
-static nsIAtom* onMozEdgeUICanceled;
-static nsIAtom* onMozEdgeUICompleted;
-
-
-static nsIAtom* onpointerdown;
-static nsIAtom* onpointermove;
-static nsIAtom* onpointerup;
-static nsIAtom* onpointercancel;
-static nsIAtom* onpointerover;
-static nsIAtom* onpointerout;
-static nsIAtom* onpointerenter;
-static nsIAtom* onpointerleave;
-static nsIAtom* ongotpointercapture;
-static nsIAtom* onlostpointercapture;
-
-
-static nsIAtom* ondevicemotion;
-static nsIAtom* ondeviceorientation;
-static nsIAtom* onabsolutedeviceorientation;
-static nsIAtom* ondeviceproximity;
-static nsIAtom* onmozorientationchange;
-static nsIAtom* onuserproximity;
-
-
-static nsIAtom* ondevicelight;
-
-
-static nsIAtom* onmozinterruptbegin;
-static nsIAtom* onmozinterruptend;
-
-
-static nsIAtom* ondevicechange;
-
-
-static nsIAtom* mozinputrangeignorepreventdefault;
-
-
-
-
-
-
-static nsIAtom* cdataTagName;
-static nsIAtom* commentTagName;
-static nsIAtom* documentNodeName;
-static nsIAtom* documentFragmentNodeName;
-static nsIAtom* documentTypeNodeName;
-static nsIAtom* processingInstructionTagName;
-static nsIAtom* textTagName;
-
-
-static nsIAtom* bcTableCellFrame;
-static nsIAtom* blockFrame;
-static nsIAtom* boxFrame;
-static nsIAtom* brFrame;
-static nsIAtom* bulletFrame;
-static nsIAtom* colorControlFrame;
-static nsIAtom* columnSetFrame;
-static nsIAtom* comboboxControlFrame;
-static nsIAtom* comboboxDisplayFrame;
-static nsIAtom* dateTimeControlFrame;
-static nsIAtom* deckFrame;
-static nsIAtom* detailsFrame;
-static nsIAtom* fieldSetFrame;
-static nsIAtom* flexContainerFrame;
-static nsIAtom* formControlFrame;
-static nsIAtom* frameSetFrame;
-static nsIAtom* gfxButtonControlFrame;
-static nsIAtom* gridContainerFrame;
-static nsIAtom* HTMLButtonControlFrame;
-static nsIAtom* HTMLCanvasFrame;
-static nsIAtom* subDocumentFrame;
-static nsIAtom* imageBoxFrame;
-static nsIAtom* imageFrame;
-static nsIAtom* imageControlFrame;
-static nsIAtom* inlineFrame;
-static nsIAtom* leafBoxFrame;
-static nsIAtom* legendFrame;
-static nsIAtom* letterFrame;
-static nsIAtom* lineFrame;
-static nsIAtom* listControlFrame;
-static nsIAtom* menuFrame;
-static nsIAtom* meterFrame;
-static nsIAtom* menuPopupFrame;
-static nsIAtom* numberControlFrame;
-static nsIAtom* objectFrame;
-static nsIAtom* pageFrame;
-static nsIAtom* pageBreakFrame;
-static nsIAtom* pageContentFrame;
-static nsIAtom* placeholderFrame;
-static nsIAtom* popupSetFrame;
-static nsIAtom* progressFrame;
-static nsIAtom* canvasFrame;
-static nsIAtom* rangeFrame;
-static nsIAtom* rootFrame;
-static nsIAtom* rubyBaseContainerFrame;
-static nsIAtom* rubyBaseFrame;
-static nsIAtom* rubyFrame;
-static nsIAtom* rubyTextContainerFrame;
-static nsIAtom* rubyTextFrame;
-static nsIAtom* scrollFrame;
-static nsIAtom* scrollbarFrame;
-static nsIAtom* sequenceFrame;
-static nsIAtom* sliderFrame;
-static nsIAtom* tableCellFrame;
-static nsIAtom* tableColFrame;
-static nsIAtom* tableColGroupFrame;
-static nsIAtom* tableFrame;
-static nsIAtom* tableWrapperFrame;
-static nsIAtom* tableRowGroupFrame;
-static nsIAtom* tableRowFrame;
-static nsIAtom* textInputFrame;
-static nsIAtom* textFrame;
-static nsIAtom* viewportFrame;
-
-static nsIAtom* XULLabelFrame;
-
-static nsIAtom* svgAFrame;
-static nsIAtom* svgClipPathFrame;
-static nsIAtom* svgDefsFrame;
-static nsIAtom* svgFEContainerFrame;
-static nsIAtom* svgFEImageFrame;
-static nsIAtom* svgFELeafFrame;
-static nsIAtom* svgFEUnstyledLeafFrame;
-static nsIAtom* svgFilterFrame;
-static nsIAtom* svgForeignObjectFrame;
-static nsIAtom* svgGenericContainerFrame;
-static nsIAtom* svgGeometryFrame;
-static nsIAtom* svgGFrame;
-static nsIAtom* svgGradientFrame;
-static nsIAtom* svgImageFrame;
-static nsIAtom* svgInnerSVGFrame;
-static nsIAtom* svgLinearGradientFrame;
-static nsIAtom* svgMarkerFrame;
-static nsIAtom* svgMarkerAnonChildFrame;
-static nsIAtom* svgMaskFrame;
-static nsIAtom* svgOuterSVGFrame;
-static nsIAtom* svgOuterSVGAnonChildFrame;
-static nsIAtom* svgPatternFrame;
-static nsIAtom* svgRadialGradientFrame;
-static nsIAtom* svgStopFrame;
-static nsIAtom* svgSwitchFrame;
-static nsIAtom* svgTextFrame;
-static nsIAtom* svgUseFrame;
-static nsIAtom* svgViewFrame;
-static nsIAtom* HTMLVideoFrame;
-static nsIAtom* onloadend;
-static nsIAtom* onloadstart;
-static nsIAtom* onprogress;
-static nsIAtom* onsuspend;
-static nsIAtom* onemptied;
-static nsIAtom* onstalled;
-static nsIAtom* onplay;
-static nsIAtom* onpause;
-static nsIAtom* onloadedmetadata;
-static nsIAtom* onloadeddata;
-static nsIAtom* onwaiting;
-static nsIAtom* onplaying;
-static nsIAtom* oncanplay;
-static nsIAtom* oncanplaythrough;
-static nsIAtom* onseeking;
-static nsIAtom* onseeked;
-static nsIAtom* ontimeout;
-static nsIAtom* ontimeupdate;
-static nsIAtom* onended;
-static nsIAtom* onratechange;
-static nsIAtom* ondurationchange;
-static nsIAtom* onvolumechange;
-static nsIAtom* onaddtrack;
-static nsIAtom* oncontrollerchange;
-static nsIAtom* oncuechange;
-static nsIAtom* onenter;
-static nsIAtom* onexit;
-static nsIAtom* onencrypted;
-static nsIAtom* encrypted;
-static nsIAtom* onwaitingforkey;
-static nsIAtom* onkeystatuseschange;
-static nsIAtom* onremovetrack;
-static nsIAtom* loadstart;
-static nsIAtom* suspend;
-static nsIAtom* emptied;
-static nsIAtom* stalled;
-static nsIAtom* play;
-static nsIAtom* pause;
-static nsIAtom* loadedmetadata;
-static nsIAtom* loadeddata;
-static nsIAtom* waiting;
-static nsIAtom* playing;
-static nsIAtom* seeking;
-static nsIAtom* seeked;
-static nsIAtom* timeupdate;
-static nsIAtom* ended;
-static nsIAtom* canplay;
-static nsIAtom* canplaythrough;
-static nsIAtom* ratechange;
-static nsIAtom* durationchange;
-static nsIAtom* volumechange;
-static nsIAtom* ondataavailable;
-static nsIAtom* onwarning;
-static nsIAtom* onstart;
-static nsIAtom* onstop;
-static nsIAtom* onphoto;
-static nsIAtom* onactivestatechanged;
-static nsIAtom* ongamepadbuttondown;
-static nsIAtom* ongamepadbuttonup;
-static nsIAtom* ongamepadaxismove;
-static nsIAtom* ongamepadconnected;
-static nsIAtom* ongamepaddisconnected;
-
-
-static nsIAtom* animationsProperty;
-static nsIAtom* animationsOfBeforeProperty;
-static nsIAtom* animationsOfAfterProperty;
-static nsIAtom* animationEffectsProperty;
-static nsIAtom* animationEffectsForBeforeProperty;
-static nsIAtom* animationEffectsForAfterProperty;
-static nsIAtom* cssPseudoElementBeforeProperty;
-static nsIAtom* cssPseudoElementAfterProperty;
-static nsIAtom* transitionsProperty;
-static nsIAtom* transitionsOfBeforeProperty;
-static nsIAtom* transitionsOfAfterProperty;
-static nsIAtom* genConInitializerProperty;
-static nsIAtom* labelMouseDownPtProperty;
-static nsIAtom* lockedStyleStates;
-static nsIAtom* apzCallbackTransform;
-static nsIAtom* restylableAnonymousNode;
-static nsIAtom* paintRequestTime;
-static nsIAtom* pseudoProperty;
-
-
-static nsIAtom* Japanese;
-static nsIAtom* Chinese;
-static nsIAtom* Taiwanese;
-static nsIAtom* HongKongChinese;
-static nsIAtom* Unicode;
-
-
-static nsIAtom* ko;
-static nsIAtom* zh_cn;
-static nsIAtom* zh_hk;
-static nsIAtom* zh_tw;
-
-
-static nsIAtom* x_cyrillic;
-static nsIAtom* he;
-static nsIAtom* ar;
-static nsIAtom* x_devanagari;
-static nsIAtom* x_tamil;
-static nsIAtom* x_armn;
-static nsIAtom* x_beng;
-static nsIAtom* x_cans;
-static nsIAtom* x_ethi;
-static nsIAtom* x_geor;
-static nsIAtom* x_gujr;
-static nsIAtom* x_guru;
-static nsIAtom* x_khmr;
-static nsIAtom* x_knda;
-static nsIAtom* x_mlym;
-static nsIAtom* x_orya;
-static nsIAtom* x_sinh;
-static nsIAtom* x_telu;
-static nsIAtom* x_tibt;
-
-
-static nsIAtom* az;
-static nsIAtom* ba;
-static nsIAtom* crh;
-static nsIAtom* el;
-static nsIAtom* ga;
-static nsIAtom* nl;
-
-
-static nsIAtom* x_math;
-
-
-static nsIAtom* TypingTxnName;
-static nsIAtom* IMETxnName;
-static nsIAtom* DeleteTxnName;
-
-
-static nsIAtom* serif;
-static nsIAtom* sans_serif;
-static nsIAtom* cursive;
-static nsIAtom* fantasy;
-static nsIAtom* monospace;
-static nsIAtom* mozfixed;
-
-
-static nsIAtom* Remote;
-static nsIAtom* RemoteId;
-static nsIAtom* RemoteType;
-static nsIAtom* DisplayPort;
-static nsIAtom* DisplayPortMargins;
-static nsIAtom* DisplayPortBase;
-static nsIAtom* AsyncScrollLayerCreationFailed;
-static nsIAtom* forcemessagemanager;
-
-
-static nsIAtom* color_picker_available;
-static nsIAtom* scrollbar_start_backward;
-static nsIAtom* scrollbar_start_forward;
-static nsIAtom* scrollbar_end_backward;
-static nsIAtom* scrollbar_end_forward;
-static nsIAtom* scrollbar_thumb_proportional;
-static nsIAtom* overlay_scrollbars;
-static nsIAtom* windows_default_theme;
-static nsIAtom* mac_graphite_theme;
-static nsIAtom* mac_yosemite_theme;
-static nsIAtom* windows_compositor;
-static nsIAtom* windows_glass;
-static nsIAtom* touch_enabled;
-static nsIAtom* menubar_drag;
-static nsIAtom* swipe_animation_enabled;
-static nsIAtom* physical_home_button;
-
-
-static nsIAtom* windows_classic;
-static nsIAtom* windows_theme_aero;
-static nsIAtom* windows_theme_aero_lite;
-static nsIAtom* windows_theme_luna_blue;
-static nsIAtom* windows_theme_luna_olive;
-static nsIAtom* windows_theme_luna_silver;
-static nsIAtom* windows_theme_royale;
-static nsIAtom* windows_theme_zune;
-static nsIAtom* windows_theme_generic;
-
-
-static nsIAtom* _moz_color_picker_available;
-static nsIAtom* _moz_scrollbar_start_backward;
-static nsIAtom* _moz_scrollbar_start_forward;
-static nsIAtom* _moz_scrollbar_end_backward;
-static nsIAtom* _moz_scrollbar_end_forward;
-static nsIAtom* _moz_scrollbar_thumb_proportional;
-static nsIAtom* _moz_overlay_scrollbars;
-static nsIAtom* _moz_windows_default_theme;
-static nsIAtom* _moz_mac_graphite_theme;
-static nsIAtom* _moz_mac_yosemite_theme;
-static nsIAtom* _moz_windows_compositor;
-static nsIAtom* _moz_windows_classic;
-static nsIAtom* _moz_windows_glass;
-static nsIAtom* _moz_windows_theme;
-static nsIAtom* _moz_os_version;
-static nsIAtom* _moz_touch_enabled;
-static nsIAtom* _moz_menubar_drag;
-static nsIAtom* _moz_device_pixel_ratio;
-static nsIAtom* _moz_device_orientation;
-static nsIAtom* _moz_is_resource_document;
-static nsIAtom* _moz_swipe_animation_enabled;
-static nsIAtom* _moz_physical_home_button;
-
-
-static nsIAtom* Back;
-static nsIAtom* Forward;
-static nsIAtom* Reload;
-static nsIAtom* Stop;
-static nsIAtom* Search;
-static nsIAtom* Bookmarks;
-static nsIAtom* Home;
-static nsIAtom* Clear;
-static nsIAtom* VolumeUp;
-static nsIAtom* VolumeDown;
-static nsIAtom* NextTrack;
-static nsIAtom* PreviousTrack;
-static nsIAtom* MediaStop;
-static nsIAtom* PlayPause;
-static nsIAtom* Menu;
-static nsIAtom* New;
-static nsIAtom* Open;
-static nsIAtom* Close;
-static nsIAtom* Save;
-static nsIAtom* Find;
-static nsIAtom* Help;
-static nsIAtom* Print;
-static nsIAtom* SendMail;
-static nsIAtom* ForwardMail;
-static nsIAtom* ReplyToMail;
-
-
-
-
-
-
-static nsIAtom* mouseWheel;
-static nsIAtom* pixels;
-static nsIAtom* lines;
-static nsIAtom* pages;
-static nsIAtom* scrollbars;
-static nsIAtom* other;
-
-static nsIAtom* apz;
-static nsIAtom* restore;
-
-
-static nsIAtom* alert;
-static nsIAtom* alertdialog;
-static nsIAtom* application;
-static nsIAtom* aria_activedescendant;
-static nsIAtom* aria_atomic;
-static nsIAtom* aria_autocomplete;
-static nsIAtom* aria_busy;
-static nsIAtom* aria_checked;
-static nsIAtom* aria_colcount;
-static nsIAtom* aria_colindex;
-static nsIAtom* aria_controls;
-static nsIAtom* aria_describedby;
-static nsIAtom* aria_details;
-static nsIAtom* aria_disabled;
-static nsIAtom* aria_dropeffect;
-static nsIAtom* aria_errormessage;
-static nsIAtom* aria_expanded;
-static nsIAtom* aria_flowto;
-static nsIAtom* aria_grabbed;
-static nsIAtom* aria_haspopup;
-static nsIAtom* aria_hidden;
-static nsIAtom* aria_invalid;
-static nsIAtom* aria_label;
-static nsIAtom* aria_labelledby;
-static nsIAtom* aria_level;
-static nsIAtom* aria_live;
-static nsIAtom* aria_modal;
-static nsIAtom* aria_multiline;
-static nsIAtom* aria_multiselectable;
-static nsIAtom* aria_orientation;
-static nsIAtom* aria_owns;
-static nsIAtom* aria_posinset;
-static nsIAtom* aria_pressed;
-static nsIAtom* aria_readonly;
-static nsIAtom* aria_relevant;
-static nsIAtom* aria_required;
-static nsIAtom* aria_rowcount;
-static nsIAtom* aria_rowindex;
-static nsIAtom* aria_selected;
-static nsIAtom* aria_setsize;
-static nsIAtom* aria_sort;
-static nsIAtom* aria_valuenow;
-static nsIAtom* aria_valuemin;
-static nsIAtom* aria_valuemax;
-static nsIAtom* aria_valuetext;
-static nsIAtom* AreaFrame;
-static nsIAtom* auto_generated;
-static nsIAtom* banner;
-static nsIAtom* checkable;
-static nsIAtom* choices;
-static nsIAtom* columnheader;
-static nsIAtom* complementary;
-static nsIAtom* containerAtomic;
-static nsIAtom* containerBusy;
-static nsIAtom* containerLive;
-static nsIAtom* containerLiveRole;
-static nsIAtom* containerRelevant;
-static nsIAtom* contentinfo;
-static nsIAtom* cycles;
-static nsIAtom* datatable;
-static nsIAtom* eventFromInput;
-static nsIAtom* feed;
-static nsIAtom* grammar;
-static nsIAtom* gridcell;
-static nsIAtom* heading;
-static nsIAtom* hitregion;
-static nsIAtom* InlineBlockFrame;
-static nsIAtom* inlinevalue;
-static nsIAtom* invalid;
-static nsIAtom* item;
-static nsIAtom* itemset;
-static nsIAtom* lineNumber;
-static nsIAtom* linkedPanel;
-static nsIAtom* live;
-static nsIAtom* menuitemcheckbox;
-static nsIAtom* menuitemradio;
-static nsIAtom* mixed;
-static nsIAtom* multiline;
-static nsIAtom* navigation;
-static nsIAtom* polite;
-static nsIAtom* posinset;
-static nsIAtom* presentation;
-static nsIAtom* progressbar;
-static nsIAtom* region;
-static nsIAtom* rowgroup;
-static nsIAtom* rowheader;
-static nsIAtom* search;
-static nsIAtom* searchbox;
-static nsIAtom* select1;
-static nsIAtom* setsize;
-static nsIAtom* spelling;
-static nsIAtom* spinbutton;
-static nsIAtom* status;
-static nsIAtom* _switch;
-static nsIAtom* tableCellIndex;
-static nsIAtom* tablist;
-static nsIAtom* textIndent;
-static nsIAtom* textInputType;
-static nsIAtom* textLineThroughColor;
-static nsIAtom* textLineThroughStyle;
-static nsIAtom* textPosition;
-static nsIAtom* textUnderlineColor;
-static nsIAtom* textUnderlineStyle;
-static nsIAtom* timer;
-static nsIAtom* toolbarname;
-static nsIAtom* toolbarseparator;
-static nsIAtom* toolbarspacer;
-static nsIAtom* toolbarspring;
-static nsIAtom* treegrid;
-static nsIAtom* _undefined;
-static nsIAtom* xmlroles;
-
-
-static nsIAtom* close_fence;
-static nsIAtom* denominator;
-static nsIAtom* numerator;
-static nsIAtom* open_fence;
-static nsIAtom* overscript;
-static nsIAtom* presubscript;
-static nsIAtom* presuperscript;
-static nsIAtom* root_index;
-static nsIAtom* subscript;
-static nsIAtom* superscript;
-static nsIAtom* underscript;
-
-
-
-static nsIAtom* onaudiostart;
-static nsIAtom* onaudioend;
-static nsIAtom* onsoundstart;
-static nsIAtom* onsoundend;
-static nsIAtom* onspeechstart;
-static nsIAtom* onspeechend;
-static nsIAtom* onresult;
-static nsIAtom* onnomatch;
-static nsIAtom* onresume;
-static nsIAtom* onmark;
-static nsIAtom* onboundary;
-
-
-
-static nsIAtom* usercontextid;
-
-
-static nsIAtom* nsuri_xmlns;
-static nsIAtom* nsuri_xml;
-static nsIAtom* nsuri_xhtml;
-static nsIAtom* nsuri_xlink;
-static nsIAtom* nsuri_xslt;
-static nsIAtom* nsuri_xbl;
-static nsIAtom* nsuri_mathml;
-static nsIAtom* nsuri_rdf;
-static nsIAtom* nsuri_xul;
-static nsIAtom* nsuri_svg;
-
-
-static nsIAtom* onsourceopen;
-static nsIAtom* onsourceended;
-static nsIAtom* onsourceclosed;
-static nsIAtom* onupdatestart;
-static nsIAtom* onupdate;
-static nsIAtom* onupdateend;
-static nsIAtom* onaddsourcebuffer;
-static nsIAtom* onremovesourcebuffer;
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsGkAtoms.h" 2
-
-};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/domstubs.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/domstubs.h"
-class nsWrapperCache;
-typedef uint64_t DOMTimeStamp;
-
-typedef double DOMHighResTimeStamp;
-
-class nsIDOMAttr;
-
-class nsIDOMCDATASection;
-
-class nsIDOMCharacterData;
-
-class nsIDOMComment;
-
-class nsIDOMDOMImplementation;
-
-class nsIDOMDocument;
-
-class nsIDOMDocumentFragment;
-
-class nsIDOMDocumentType;
-
-class nsIDOMElement;
-
-class nsIDOMNode;
-
-class nsIDOMNodeList;
-
-class nsIDOMProcessingInstruction;
-
-class nsIDOMText;
-
-class nsIDOMClientRect;
-
-class nsIDOMClientRectList;
-
-class DOMException;
-
-class nsIDOMStyleSheetList;
-
-class nsIDOMStyleSheet;
-
-class nsIDOMMediaList;
-
-class nsIDOMWindow;
-
-class nsIDOMWindowCollection;
-
-class nsIDOMNavigator;
-
-class nsIDOMScreen;
-
-class nsIDOMEvent;
-
-class nsIDOMEventTarget;
-
-class nsIDOMEventListener;
-
-class nsIDOMHTMLElement;
-
-class nsIDOMHTMLFormElement;
-
-class nsIDOMHTMLCollection;
-
-class nsIDOMHTMLHeadElement;
-
-class nsIDOMCSSValue;
-
-class nsIDOMCSSPrimitiveValue;
-
-class nsIDOMCSSRule;
-
-class nsIDOMCSSRuleList;
-
-class nsIDOMCSSKeyframeRule;
-
-class nsIDOMCSSFontFeatureValuesRule;
-
-class nsIDOMCSSStyleSheet;
-
-class nsIDOMCSSStyleDeclaration;
-
-class nsIDOMCounter;
-
-class nsIDOMRect;
-
-class nsIDOMCSSStyleRule;
-
-class nsIDOMCSSStyleRuleCollection;
-
-class nsIDOMRange;
-
-class nsIDOMCrypto;
-
-class nsIDOMFontFace;
-
-class nsIDOMFontFaceList;
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h" 2
-
-
-
-
-
-
-class nsIVariant;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNode.h"
-class nsIDOMNode : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    ELEMENT_NODE = 1U,
-    ATTRIBUTE_NODE = 2U,
-    TEXT_NODE = 3U,
-    CDATA_SECTION_NODE = 4U,
-    ENTITY_REFERENCE_NODE = 5U,
-    ENTITY_NODE = 6U,
-    PROCESSING_INSTRUCTION_NODE = 7U,
-    COMMENT_NODE = 8U,
-    DOCUMENT_NODE = 9U,
-    DOCUMENT_TYPE_NODE = 10U,
-    DOCUMENT_FRAGMENT_NODE = 11U,
-    NOTATION_NODE = 12U
-  };
-
-
-  virtual nsresult GetNodeName(nsAString & aNodeName) = 0;
-
-
-  virtual nsresult GetNodeValue(nsAString & aNodeValue) = 0;
-  virtual nsresult SetNodeValue(const nsAString & aNodeValue) = 0;
-
-
-  virtual nsresult GetNodeType(uint16_t *aNodeType) = 0;
-
-
-  virtual nsresult GetParentNode(nsIDOMNode * *aParentNode) = 0;
-
-
-  virtual nsresult GetChildNodes(nsIDOMNodeList * *aChildNodes) = 0;
-
-
-  virtual nsresult GetFirstChild(nsIDOMNode * *aFirstChild) = 0;
-
-
-  virtual nsresult GetLastChild(nsIDOMNode * *aLastChild) = 0;
-
-
-  virtual nsresult GetPreviousSibling(nsIDOMNode * *aPreviousSibling) = 0;
-
-
-  virtual nsresult GetNextSibling(nsIDOMNode * *aNextSibling) = 0;
-
-
-  virtual nsresult GetOwnerDocument(nsIDOMDocument * *aOwnerDocument) = 0;
-
-
-  virtual nsresult RemoveChild(nsIDOMNode *oldChild, nsIDOMNode * *_retval) = 0;
-
-
-  virtual nsresult HasChildNodes(bool *_retval) = 0;
-
-
-  virtual nsresult CloneNode(bool deep, uint8_t _argc, nsIDOMNode * *_retval) = 0;
-
-
-  virtual nsresult GetNamespaceURI(nsAString & aNamespaceURI) = 0;
-
-
-  virtual nsresult GetPrefix(nsAString & aPrefix) = 0;
-
-
-  virtual nsresult GetLocalName(nsAString & aLocalName) = 0;
-
-  enum {
-    DOCUMENT_POSITION_DISCONNECTED = 1U,
-    DOCUMENT_POSITION_PRECEDING = 2U,
-    DOCUMENT_POSITION_FOLLOWING = 4U,
-    DOCUMENT_POSITION_CONTAINS = 8U,
-    DOCUMENT_POSITION_CONTAINED_BY = 16U,
-    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32U
-  };
-
-
-  virtual nsresult GetTextContent(nsAString & aTextContent) = 0;
-  virtual nsresult SetTextContent(const nsAString & aTextContent) = 0;
-
-};
-
-  template<typename T> struct nsIDOMNode::COMTypeInfo<nsIDOMNode, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMNode::COMTypeInfo<nsIDOMNode, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcc35b412, 0x009b, 0x46a3, { 0x9b, 0xe0, 0x76, 0x44, 0x8f, 0x12, 0x54, 0x8d }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h" 1
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
-class nsIDataType : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    VTYPE_INT8 = 0U,
-    VTYPE_INT16 = 1U,
-    VTYPE_INT32 = 2U,
-    VTYPE_INT64 = 3U,
-    VTYPE_UINT8 = 4U,
-    VTYPE_UINT16 = 5U,
-    VTYPE_UINT32 = 6U,
-    VTYPE_UINT64 = 7U,
-    VTYPE_FLOAT = 8U,
-    VTYPE_DOUBLE = 9U,
-    VTYPE_BOOL = 10U,
-    VTYPE_CHAR = 11U,
-    VTYPE_WCHAR = 12U,
-    VTYPE_VOID = 13U,
-    VTYPE_ID = 14U,
-    VTYPE_DOMSTRING = 15U,
-    VTYPE_CHAR_STR = 16U,
-    VTYPE_WCHAR_STR = 17U,
-    VTYPE_INTERFACE = 18U,
-    VTYPE_INTERFACE_IS = 19U,
-    VTYPE_ARRAY = 20U,
-    VTYPE_STRING_SIZE_IS = 21U,
-    VTYPE_WSTRING_SIZE_IS = 22U,
-    VTYPE_UTF8STRING = 23U,
-    VTYPE_CSTRING = 24U,
-    VTYPE_ASTRING = 25U,
-    VTYPE_EMPTY_ARRAY = 254U,
-    VTYPE_EMPTY = 255U
-  };
-
-};
-
-  template<typename T> struct nsIDataType::COMTypeInfo<nsIDataType, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDataType::COMTypeInfo<nsIDataType, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4d12e540, 0x83d7, 0x11d5, { 0x90, 0xed, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
-# 123 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
-class nsIVariant : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetDataType(uint16_t *aDataType) = 0;
-
-
-  virtual nsresult GetAsInt8(uint8_t *_retval) = 0;
-
-
-  virtual nsresult GetAsInt16(int16_t *_retval) = 0;
-
-
-  virtual nsresult GetAsInt32(int32_t *_retval) = 0;
-
-
-  virtual nsresult GetAsInt64(int64_t *_retval) = 0;
-
-
-  virtual nsresult GetAsUint8(uint8_t *_retval) = 0;
-
-
-  virtual nsresult GetAsUint16(uint16_t *_retval) = 0;
-
-
-  virtual nsresult GetAsUint32(uint32_t *_retval) = 0;
-
-
-  virtual nsresult GetAsUint64(uint64_t *_retval) = 0;
-
-
-  virtual nsresult GetAsFloat(float *_retval) = 0;
-
-
-  virtual nsresult GetAsDouble(double *_retval) = 0;
-
-
-  virtual nsresult GetAsBool(bool *_retval) = 0;
-
-
-  virtual nsresult GetAsChar(char *_retval) = 0;
-
-
-  virtual nsresult GetAsWChar(char16_t *_retval) = 0;
-
-
-  virtual nsresult GetAsID(nsID *retval) = 0;
-
-
-  virtual nsresult GetAsAString(nsAString & _retval) = 0;
-
-
-  virtual nsresult GetAsDOMString(nsAString & _retval) = 0;
-
-
-  virtual nsresult GetAsACString(nsACString & _retval) = 0;
-
-
-  virtual nsresult GetAsAUTF8String(nsACString & _retval) = 0;
-
-
-  virtual nsresult GetAsString(char * *_retval) = 0;
-
-
-  virtual nsresult GetAsWString(char16_t * *_retval) = 0;
-
-
-  virtual nsresult GetAsISupports(nsISupports * *_retval) = 0;
-
-
-  virtual nsresult GetAsJSVal(JS::MutableHandleValue _retval) = 0;
-
-
-  virtual nsresult GetAsInterface(nsIID **iid, void **iface) = 0;
-
-
-  virtual nsresult GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) = 0;
-
-
-  virtual nsresult GetAsStringWithSize(uint32_t *size, char * *str) = 0;
-
-
-  virtual nsresult GetAsWStringWithSize(uint32_t *size, char16_t * *str) = 0;
-
-};
-
-  template<typename T> struct nsIVariant::COMTypeInfo<nsIVariant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIVariant::COMTypeInfo<nsIVariant, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x81e4c2de, 0xacac, 0x4ad6, { 0x90, 0x1a, 0xb5, 0xfb, 0x1b, 0x85, 0x1a, 0x0d }};
-# 539 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIVariant.h"
-class nsIWritableVariant : public nsIVariant {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetWritable(bool *aWritable) = 0;
-  virtual nsresult SetWritable(bool aWritable) = 0;
-
-
-  virtual nsresult SetAsInt8(uint8_t aValue) = 0;
-
-
-  virtual nsresult SetAsInt16(int16_t aValue) = 0;
-
-
-  virtual nsresult SetAsInt32(int32_t aValue) = 0;
-
-
-  virtual nsresult SetAsInt64(int64_t aValue) = 0;
-
-
-  virtual nsresult SetAsUint8(uint8_t aValue) = 0;
-
-
-  virtual nsresult SetAsUint16(uint16_t aValue) = 0;
-
-
-  virtual nsresult SetAsUint32(uint32_t aValue) = 0;
-
-
-  virtual nsresult SetAsUint64(uint64_t aValue) = 0;
-
-
-  virtual nsresult SetAsFloat(float aValue) = 0;
-
-
-  virtual nsresult SetAsDouble(double aValue) = 0;
-
-
-  virtual nsresult SetAsBool(bool aValue) = 0;
-
-
-  virtual nsresult SetAsChar(char aValue) = 0;
-
-
-  virtual nsresult SetAsWChar(char16_t aValue) = 0;
-
-
-  virtual nsresult SetAsID(const nsID & aValue) = 0;
-
-
-  virtual nsresult SetAsAString(const nsAString & aValue) = 0;
-
-
-  virtual nsresult SetAsDOMString(const nsAString & aValue) = 0;
-
-
-  virtual nsresult SetAsACString(const nsACString & aValue) = 0;
-
-
-  virtual nsresult SetAsAUTF8String(const nsACString & aValue) = 0;
-
-
-  virtual nsresult SetAsString(const char * aValue) = 0;
-
-
-  virtual nsresult SetAsWString(const char16_t * aValue) = 0;
-
-
-  virtual nsresult SetAsISupports(nsISupports *aValue) = 0;
-
-
-  virtual nsresult SetAsInterface(const nsIID & iid, void *iface) = 0;
-
-
-  virtual nsresult SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) = 0;
-
-
-  virtual nsresult SetAsStringWithSize(uint32_t size, const char * str) = 0;
-
-
-  virtual nsresult SetAsWStringWithSize(uint32_t size, const char16_t * str) = 0;
-
-
-  virtual nsresult SetAsVoid(void) = 0;
-
-
-  virtual nsresult SetAsEmpty(void) = 0;
-
-
-  virtual nsresult SetAsEmptyArray(void) = 0;
-
-
-  virtual nsresult SetFromVariant(nsIVariant *aValue) = 0;
-
-};
-
-  template<typename T> struct nsIWritableVariant::COMTypeInfo<nsIWritableVariant, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIWritableVariant::COMTypeInfo<nsIWritableVariant, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5586a590, 0x8c82, 0x11d5, { 0x90, 0xf3, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeInfoManager.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeInfoManager.h"
-class nsAString;
-class nsBindingManager;
-class nsIAtom;
-class nsIDocument;
-class nsIDOMDocumentType;
-class nsIPrincipal;
-struct PLHashEntry;
-struct PLHashTable;
-template<class T> struct already_AddRefed;
-
-namespace mozilla {
-namespace dom {
-class NodeInfo;
-}
-}
-
-
-
-class nsNodeInfoManager final
-{
-private:
-  ~nsNodeInfoManager();
-
-public:
-  nsNodeInfoManager();
-
-  void DeleteCycleCollectable(void) { delete this; } class cycleCollection : public nsCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsCycleCollectionParticipant(true) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsNodeInfoManager"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<nsNodeInfoManager>(n)->DeleteCycleCollectable(); } static nsNodeInfoManager* Downcast(void* s) { return DowncastCCParticipant<nsNodeInfoManager>(s); } static void* Upcast(nsNodeInfoManager *p) { return static_cast<void*>(p); } virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static nsCycleCollectionParticipant* GetParticipant() { return &nsNodeInfoManager::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsNodeInfoManager>::value, "Reference-counted class " "nsNodeInfoManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-
-
-
-
-  nsresult Init(nsIDocument *aDocument);
-
-
-
-
-
-  void DropDocumentReference();
-
-
-
-
-  already_AddRefed<mozilla::dom::NodeInfo>
-  GetNodeInfo(nsIAtom *aName, nsIAtom *aPrefix, int32_t aNamespaceID,
-              uint16_t aNodeType, nsIAtom* aExtraName = nullptr);
-  nsresult GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
-                       int32_t aNamespaceID, uint16_t aNodeType,
-                       mozilla::dom::NodeInfo** aNodeInfo);
-  nsresult GetNodeInfo(const nsAString& aName, nsIAtom *aPrefix,
-                       const nsAString& aNamespaceURI, uint16_t aNodeType,
-                       mozilla::dom::NodeInfo** aNodeInfo);
-
-
-
-
-  already_AddRefed<mozilla::dom::NodeInfo> GetTextNodeInfo();
-
-
-
-
-  already_AddRefed<mozilla::dom::NodeInfo> GetCommentNodeInfo();
-
-
-
-
-  already_AddRefed<mozilla::dom::NodeInfo> GetDocumentNodeInfo();
-
-
-
-
-
-  nsIDocument* GetDocument() const
-  {
-    return mDocument;
-  }
-
-
-
-
-  nsIPrincipal *DocumentPrincipal() const {
-    do { } while(0);
-    return mPrincipal;
-  }
-
-  void RemoveNodeInfo(mozilla::dom::NodeInfo *aNodeInfo);
-
-  nsBindingManager* GetBindingManager() const
-  {
-    return mBindingManager;
-  }
-
-protected:
-  friend class nsDocument;
-  friend class nsXULPrototypeDocument;
-  friend nsresult NS_NewDOMDocumentType(nsIDOMDocumentType** ,
-                                        nsNodeInfoManager *,
-                                        nsIAtom *,
-                                        const nsAString& ,
-                                        const nsAString& ,
-                                        const nsAString& );
-
-
-
-
-  void SetDocumentPrincipal(nsIPrincipal *aPrincipal);
-
-private:
-  static int NodeInfoInnerKeyCompare(const void *key1, const void *key2);
-  static PLHashNumber GetNodeInfoInnerHashValue(const void *key);
-  static int DropNodeInfoDocument(PLHashEntry *he, int hashIndex,
-                                     void *arg);
-
-  PLHashTable *mNodeInfoHash;
-  nsIDocument * mDocument;
-  uint32_t mNonDocumentNodeInfos;
-  nsCOMPtr<nsIPrincipal> mPrincipal;
-  nsCOMPtr<nsIPrincipal> mDefaultPrincipal;
-  mozilla::dom::NodeInfo * mTextNodeInfo;
-  mozilla::dom::NodeInfo * mCommentNodeInfo;
-  mozilla::dom::NodeInfo * mDocumentNodeInfo;
-  RefPtr<nsBindingManager> mBindingManager;
-  mozilla::dom::NodeInfo* mRecentlyUsedNodeInfos[31];
-};
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h" 1
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
-class nsIAtom;
-
-typedef void
-(*NSPropertyFunc)(void *aObject,
-                  nsIAtom *aPropertyName,
-                  void *aPropertyValue,
-                  void *aData);
-
-
-
-
-
-
-
-typedef NSPropertyFunc NSPropertyDtorFunc;
-class nsINode;
-class nsIFrame;
-
-class nsPropertyOwner
-{
-public:
-  nsPropertyOwner(const nsPropertyOwner& aOther) : mObject(aOther.mObject) {}
-
-
-
-
-               nsPropertyOwner(const nsINode* aObject) : mObject(aObject) {}
-               nsPropertyOwner(const nsIFrame* aObject) : mObject(aObject) {}
-
-  operator const void*() { return mObject; }
-  const void* get() { return mObject; }
-
-private:
-  const void* mObject;
-};
-
-class nsPropertyTable
-{
- public:
-
-
-
-
-  void* GetProperty(const nsPropertyOwner& aObject,
-                    nsIAtom *aPropertyName,
-                    nsresult *aResult = nullptr)
-  {
-    return GetPropertyInternal(aObject, aPropertyName, false, aResult);
-  }
-# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
-  nsresult SetProperty(const nsPropertyOwner& aObject,
-                                   nsIAtom *aPropertyName,
-                                   void *aPropertyValue,
-                                   NSPropertyDtorFunc aDtor,
-                                   void *aDtorData,
-                                   bool aTransfer = false,
-                                   void **aOldValue = nullptr)
-  {
-    return SetPropertyInternal(aObject, aPropertyName, aPropertyValue,
-                               aDtor, aDtorData, aTransfer, aOldValue);
-  }
-
-
-
-
-
-  nsresult DeleteProperty(nsPropertyOwner aObject,
-                                      nsIAtom *aPropertyName);
-
-
-
-
-
-
-  void* UnsetProperty(const nsPropertyOwner& aObject,
-                      nsIAtom *aPropertyName,
-                      nsresult *aStatus = nullptr)
-  {
-    return GetPropertyInternal(aObject, aPropertyName, true, aStatus);
-  }
-
-
-
-
-
-  void DeleteAllPropertiesFor(nsPropertyOwner aObject);
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPropertyTable.h"
-  nsresult
-    TransferOrDeleteAllPropertiesFor(nsPropertyOwner aObject,
-                                     nsPropertyTable *aOtherTable);
-
-
-
-
-
-
-  void Enumerate(nsPropertyOwner aObject,
-                             NSPropertyFunc aCallback, void *aData);
-
-
-
-
-
-
-  void EnumerateAll(NSPropertyFunc aCallback, void *aData);
-
-
-
-
-
-  void DeleteAllProperties();
-
-  nsPropertyTable() : mPropertyList(nullptr) {}
-  ~nsPropertyTable() {
-    DeleteAllProperties();
-  }
-
-
-
-
-
-
-  static void SupportsDtorFunc(void *aObject, nsIAtom *aPropertyName,
-                               void *aPropertyValue, void *aData);
-
-  class PropertyList;
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
- private:
-  void DestroyPropertyList();
-  PropertyList* GetPropertyListFor(nsIAtom *aPropertyName) const;
-  void* GetPropertyInternal(nsPropertyOwner aObject,
-                                        nsIAtom *aPropertyName,
-                                        bool aRemove,
-                                        nsresult *aStatus);
-  nsresult SetPropertyInternal(nsPropertyOwner aObject,
-                                           nsIAtom *aPropertyName,
-                                           void *aPropertyValue,
-                                           NSPropertyDtorFunc aDtor,
-                                           void *aDtorData,
-                                           bool aTransfer,
-                                           void **aOldValue);
-
-  PropertyList *mPropertyList;
-};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-class nsTObserverArray_base
-{
-public:
-  typedef size_t index_type;
-  typedef size_t size_type;
-  typedef ptrdiff_t diff_type;
-
-protected:
-  class Iterator_base
-  {
-  protected:
-    friend class nsTObserverArray_base;
-
-    Iterator_base(index_type aPosition, Iterator_base* aNext)
-      : mPosition(aPosition)
-      , mNext(aNext)
-    {
-    }
-
-
-
-    index_type mPosition;
-
-
-    Iterator_base* mNext;
-  };
-
-  nsTObserverArray_base() : mIterators(nullptr) {}
-
-  ~nsTObserverArray_base()
-  {
-    do { } while(0);
-  }
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-  void AdjustIterators(index_type aModPos, diff_type aAdjustment);
-
-
-
-
-  void ClearIterators();
-
-  mutable Iterator_base* mIterators;
-};
-
-template<class T, size_t N>
-class nsAutoTObserverArray : protected nsTObserverArray_base
-{
-public:
-  typedef T elem_type;
-  typedef nsTArray<T> array_type;
-
-  nsAutoTObserverArray() {}
-
-
-
-
-
-
-  size_type Length() const { return mArray.Length(); }
-
-
-  bool IsEmpty() const { return mArray.IsEmpty(); }
-
-
-
-
-
-
-  elem_type& ElementAt(index_type aIndex)
-  {
-    return mArray.ElementAt(aIndex);
-  }
-
-
-  const elem_type& ElementAt(index_type aIndex) const
-  {
-    return mArray.ElementAt(aIndex);
-  }
-
-
-
-
-
-
-  elem_type& SafeElementAt(index_type aIndex, elem_type& aDef)
-  {
-    return mArray.SafeElementAt(aIndex, aDef);
-  }
-
-
-  const elem_type& SafeElementAt(index_type aIndex, const elem_type& aDef) const
-  {
-    return mArray.SafeElementAt(aIndex, aDef);
-  }
-# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-  template<class Item>
-  bool Contains(const Item& aItem) const
-  {
-    return IndexOf(aItem) != array_type::NoIndex;
-  }
-
-
-
-
-
-
-
-  template<class Item>
-  index_type IndexOf(const Item& aItem, index_type aStart = 0) const
-  {
-    return mArray.IndexOf(aItem, aStart);
-  }
-# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-  template<class Item>
-  elem_type* InsertElementAt(index_type aIndex, const Item& aItem)
-  {
-    elem_type* item = mArray.InsertElementAt(aIndex, aItem);
-    AdjustIterators(aIndex, 1);
-    return item;
-  }
-
-
-
-  elem_type* InsertElementAt(index_type aIndex)
-  {
-    elem_type* item = mArray.InsertElementAt(aIndex);
-    AdjustIterators(aIndex, 1);
-    return item;
-  }
-
-
-
-
-
-  template<class Item>
-  bool PrependElementUnlessExists(const Item& aItem)
-  {
-    if (Contains(aItem)) {
-      return true;
-    }
-
-    bool inserted = mArray.InsertElementAt(0, aItem) != nullptr;
-    AdjustIterators(0, 1);
-    return inserted;
-  }
-
-
-
-
-  template<class Item>
-  elem_type* AppendElement(const Item& aItem)
-  {
-    return mArray.AppendElement(aItem);
-  }
-
-
-
-  elem_type* AppendElement()
-  {
-    return mArray.AppendElement();
-  }
-
-
-
-
-
-  template<class Item>
-  bool AppendElementUnlessExists(const Item& aItem)
-  {
-    return Contains(aItem) || AppendElement(aItem) != nullptr;
-  }
-
-
-
-  void RemoveElementAt(index_type aIndex)
-  {
-    do { } while(0);
-    mArray.RemoveElementAt(aIndex);
-    AdjustIterators(aIndex, -1);
-  }
-
-
-
-
-
-
-  template<class Item>
-  bool RemoveElement(const Item& aItem)
-  {
-    index_type index = mArray.IndexOf(aItem, 0);
-    if (index == array_type::NoIndex) {
-      return false;
-    }
-
-    mArray.RemoveElementAt(index);
-    AdjustIterators(index, -1);
-    return true;
-  }
-
-
-  void RemoveElementsBy(std::function<bool(const elem_type&)> aPredicate)
-  {
-    index_type i = 0;
-    mArray.RemoveElementsBy([&](const elem_type& aItem) {
-      if (aPredicate(aItem)) {
-
-        AdjustIterators(i, -1);
-        return true;
-      }
-      ++i;
-      return false;
-    });
-  }
-
-
-
-
-  void Clear()
-  {
-    mArray.Clear();
-    ClearIterators();
-  }
-
-
-  void Compact() { mArray.Compact(); }
-
-
-
-
-
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-
-
-  class Iterator : public Iterator_base
-  {
-  protected:
-    friend class nsAutoTObserverArray;
-    typedef nsAutoTObserverArray<T, N> array_type;
-
-    Iterator(index_type aPosition, const array_type& aArray)
-      : Iterator_base(aPosition, aArray.mIterators)
-      , mArray(const_cast<array_type&>(aArray))
-    {
-      aArray.mIterators = this;
-    }
-
-    ~Iterator()
-    {
-      do { } while(0);
-
-
-
-      mArray.mIterators = mNext;
-    }
-
-
-    array_type& mArray;
-  };
-# 327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-  class ForwardIterator : protected Iterator
-  {
-  public:
-    typedef nsAutoTObserverArray<T, N> array_type;
-    typedef Iterator base_type;
-
-    explicit ForwardIterator(const array_type& aArray)
-      : Iterator(0, aArray)
-    {
-    }
-
-    ForwardIterator(const array_type& aArray, index_type aPos)
-      : Iterator(aPos, aArray)
-    {
-    }
-
-    bool operator<(const ForwardIterator& aOther) const
-    {
-      do { } while(0);
-
-      return base_type::mPosition < aOther.mPosition;
-    }
-
-
-
-
-    bool HasMore() const
-    {
-      return base_type::mPosition < base_type::mArray.Length();
-    }
-
-
-
-
-    elem_type& GetNext()
-    {
-      do { } while(0);
-      return base_type::mArray.ElementAt(base_type::mPosition++);
-    }
-  };
-
-
-
-  class EndLimitedIterator : protected ForwardIterator
-  {
-  public:
-    typedef nsAutoTObserverArray<T, N> array_type;
-    typedef Iterator base_type;
-
-    explicit EndLimitedIterator(const array_type& aArray)
-      : ForwardIterator(aArray)
-      , mEnd(aArray, aArray.Length())
-    {
-    }
-
-
-
-
-    bool HasMore() const { return *this < mEnd; }
-
-
-
-
-    elem_type& GetNext()
-    {
-      do { } while(0);
-      return base_type::mArray.ElementAt(base_type::mPosition++);
-    }
-
-  private:
-    ForwardIterator mEnd;
-  };
-# 407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTObserverArray.h"
-  class BackwardIterator : protected Iterator
-  {
-  public:
-    typedef nsAutoTObserverArray<T, N> array_type;
-    typedef Iterator base_type;
-
-    explicit BackwardIterator(const array_type& aArray)
-      : Iterator(aArray.Length(), aArray)
-    {
-    }
-
-
-
-
-    bool HasMore() const { return base_type::mPosition > 0; }
-
-
-
-
-    elem_type& GetNext()
-    {
-      do { } while(0);
-      return base_type::mArray.ElementAt(--base_type::mPosition);
-    }
-
-
-
-
-    void Remove()
-    {
-      return base_type::mArray.RemoveElementAt(base_type::mPosition);
-    }
-  };
-
-protected:
-  AutoTArray<T, N> mArray;
-};
-
-template<class T>
-class nsTObserverArray : public nsAutoTObserverArray<T, 0>
-{
-public:
-  typedef nsAutoTObserverArray<T, 0> base_type;
-  typedef nsTObserverArray_base::size_type size_type;
-
-
-
-
-
-  nsTObserverArray() {}
-
-
-  explicit nsTObserverArray(size_type aCapacity)
-  {
-    base_type::mArray.SetCapacity(aCapacity);
-  }
-};
-
-template<typename T, size_t N>
-inline void
-ImplCycleCollectionUnlink(nsAutoTObserverArray<T, N>& aField)
-{
-  aField.Clear();
-}
-
-template<typename T, size_t N>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsAutoTObserverArray<T, N>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  aFlags |= CycleCollectionEdgeNameArrayFlag;
-  size_t length = aField.Length();
-  for (size_t i = 0; i < length; ++i) {
-    ImplCycleCollectionTraverse(aCallback, aField.ElementAt(i), aName, aFlags);
-  }
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h" 1
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-namespace IPC {
-class Message;
-template <typename> struct ParamTraits;
-}
-class PickleIterator;
-
-namespace mozilla {
-
-namespace dom {
-
-enum ErrNum {
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Errors.msg" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Errors.msg"
-MSG_INVALID_ENUM_VALUE,
-MSG_MISSING_ARGUMENTS,
-MSG_NOT_OBJECT,
-MSG_NOT_CALLABLE,
-MSG_NOT_CONSTRUCTOR,
-MSG_DOES_NOT_IMPLEMENT_INTERFACE,
-MSG_METHOD_THIS_DOES_NOT_IMPLEMENT_INTERFACE,
-MSG_METHOD_THIS_UNWRAPPING_DENIED,
-MSG_THIS_DOES_NOT_IMPLEMENT_INTERFACE,
-MSG_NOT_IN_UNION,
-MSG_ILLEGAL_CONSTRUCTOR,
-MSG_CONSTRUCTOR_WITHOUT_NEW,
-MSG_ENFORCE_RANGE_NON_FINITE,
-MSG_ENFORCE_RANGE_OUT_OF_RANGE,
-MSG_NOT_SEQUENCE,
-MSG_NOT_DICTIONARY,
-MSG_OVERLOAD_RESOLUTION_FAILED,
-MSG_GLOBAL_NOT_NATIVE,
-MSG_ENCODING_NOT_SUPPORTED,
-MSG_DOM_ENCODING_NOT_UTF,
-MSG_DOM_DECODING_FAILED,
-MSG_NOT_FINITE,
-MSG_INVALID_VERSION,
-MSG_INVALID_BYTESTRING,
-
-MSG_NOT_DATE,
-MSG_INVALID_ADVANCE_COUNT,
-MSG_DEFINEPROPERTY_ON_GSP,
-MSG_INVALID_URL,
-MSG_URL_HAS_CREDENTIALS,
-MSG_METADATA_NOT_CONFIGURED,
-MSG_INVALID_READ_SIZE,
-MSG_HEADERS_IMMUTABLE,
-MSG_INVALID_HEADER_NAME,
-MSG_INVALID_HEADER_VALUE,
-MSG_INVALID_HEADER_SEQUENCE,
-MSG_PERMISSION_DENIED_TO_PASS_ARG,
-MSG_MISSING_REQUIRED_DICTIONARY_MEMBER,
-MSG_REQUEST_INTEGRITY_METADATA_NOT_EMPTY,
-MSG_INVALID_REQUEST_METHOD,
-MSG_INVALID_REQUEST_MODE,
-MSG_INVALID_REFERRER_URL,
-MSG_CROSS_ORIGIN_REFERRER_URL,
-MSG_FETCH_BODY_CONSUMED_ERROR,
-MSG_RESPONSE_INVALID_STATUSTEXT_ERROR,
-MSG_FETCH_FAILED,
-MSG_NO_BODY_ALLOWED_FOR_GET_AND_HEAD,
-MSG_RESPONSE_NULL_STATUS_WITH_BODY,
-MSG_DEFINE_NON_CONFIGURABLE_PROP_ON_WINDOW,
-MSG_INVALID_ZOOMANDPAN_VALUE_ERROR,
-MSG_INVALID_TRANSFORM_ANGLE_ERROR,
-MSG_INVALID_RESPONSE_STATUSCODE_ERROR,
-MSG_INVALID_REDIRECT_STATUSCODE_ERROR,
-MSG_INVALID_URL_SCHEME,
-MSG_RESPONSE_URL_IS_NULL,
-MSG_RESPONSE_HAS_VARY_STAR,
-MSG_BAD_FORMDATA,
-MSG_NO_ACTIVE_WORKER,
-MSG_NOTIFICATION_PERMISSION_DENIED,
-MSG_NOTIFICATION_NO_CONSTRUCTOR_IN_SERVICEWORKER,
-MSG_INVALID_SCOPE,
-MSG_INVALID_KEYFRAME_OFFSETS,
-MSG_IS_NOT_PROMISE,
-MSG_SW_INSTALL_ERROR,
-MSG_SW_SCRIPT_THREW,
-MSG_TYPEDARRAY_IS_SHARED,
-MSG_TYPEDARRAY_IS_DETACHED,
-MSG_CACHE_ADD_FAILED_RESPONSE,
-MSG_SW_UPDATE_BAD_REGISTRATION,
-MSG_INVALID_DURATION_ERROR,
-MSG_INVALID_EASING_ERROR,
-MSG_INVALID_SPACING_MODE_ERROR,
-MSG_USELESS_SETTIMEOUT,
-MSG_TOKENLIST_NO_SUPPORTED_TOKENS,
-MSG_CACHE_STREAM_CLOSED,
-MSG_TIME_VALUE_OUT_OF_RANGE,
-MSG_ONLY_IF_CACHED_WITHOUT_SAME_ORIGIN,
-MSG_THRESHOLD_RANGE_ERROR,
-MSG_WORKER_THREAD_SHUTTING_DOWN,
-MSG_CACHE_OPEN_FAILED,
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h" 2
-
-  Err_Limit
-};
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-uint16_t
-GetErrorArgCount(const ErrNum aErrorNumber);
-
-namespace binding_detail {
-void ThrowErrorMessage(JSContext* aCx, const unsigned aErrorNumber, ...);
-}
-
-template<typename... Ts>
-inline bool
-ThrowErrorMessage(JSContext* aCx, const ErrNum aErrorNumber, Ts&&... aArgs)
-{
-  binding_detail::ThrowErrorMessage(aCx, static_cast<const unsigned>(aErrorNumber),
-                                    mozilla::Forward<Ts>(aArgs)...);
-  return false;
-}
-
-struct StringArrayAppender
-{
-  static void Append(nsTArray<nsString>& aArgs, uint16_t aCount)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aCount == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aCount == 0))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aCount == 0" ") (" "Must give at least as many string arguments as are required by the ErrNum." ")"); do { *((volatile int*) __null) = 87; ::abort(); } while (0); } } while (0);
-  }
-
-  template<typename... Ts>
-  static void Append(nsTArray<nsString>& aArgs, uint16_t aCount, const nsAString& aFirst, Ts&&... aOtherArgs)
-  {
-    if (aCount == 0) {
-      do { } while (0);
-      return;
-    }
-    aArgs.AppendElement(aFirst);
-    Append(aArgs, aCount - 1, Forward<Ts>(aOtherArgs)...);
-  }
-};
-
-}
-
-class ErrorResult;
-class OOMReporter;
-
-namespace binding_danger {
-# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-template<typename CleanupPolicy>
-class TErrorResult {
-public:
-  TErrorResult()
-    : mResult(NS_OK)
-
-
-
-
-  {
-  }
-
-  ~TErrorResult() {
-    AssertInOwningThread();
-
-    if (CleanupPolicy::assertHandled) {
-
-
-      AssertReportedOrSuppressed();
-    }
-
-    if (CleanupPolicy::suppress) {
-      SuppressException();
-    }
-
-
-    AssertReportedOrSuppressed();
-  }
-
-  TErrorResult(TErrorResult&& aRHS)
-
-
-
-    : TErrorResult()
-  {
-    *this = Move(aRHS);
-  }
-  TErrorResult& operator=(TErrorResult&& aRHS);
-
-  explicit TErrorResult(nsresult aRv)
-    : TErrorResult()
-  {
-    AssignErrorCode(aRv);
-  }
-
-  operator ErrorResult&();
-  operator OOMReporter&();
-
-  void Throw(nsresult rv) {
-    do { } while (0);
-    AssignErrorCode(rv);
-  }
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  void ThrowWithCustomCleanup(nsresult rv) {
-    Throw(rv);
-  }
-
-
-
-
-  void CloneTo(TErrorResult& aRv) const;
-
-
-
-
-  void SuppressException();
-
-
-
-
-  nsresult StealNSResult() {
-    nsresult rv = ErrorCode();
-    SuppressException();
-
-    if (rv == NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR ||
-        rv == NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR ||
-        rv == NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION ||
-        rv == NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION) {
-
-      return NS_ERROR_DOM_INVALID_STATE_ERR;
-    }
-
-    return rv;
-  }
-# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  bool MaybeSetPendingException(JSContext* cx)
-  {
-    WouldReportJSException();
-    if (!Failed()) {
-      return false;
-    }
-
-    SetPendingException(cx);
-    return true;
-  }
-# 286 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  void StealExceptionFromJSContext(JSContext* cx);
-
-  template<dom::ErrNum errorNumber, typename... Ts>
-  void ThrowTypeError(Ts&&... messageArgs)
-  {
-    ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR,
-                                       Forward<Ts>(messageArgs)...);
-  }
-
-  template<dom::ErrNum errorNumber, typename... Ts>
-  void ThrowRangeError(Ts&&... messageArgs)
-  {
-    ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR,
-                                       Forward<Ts>(messageArgs)...);
-  }
-
-  bool IsErrorWithMessage() const
-  {
-    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR ||
-           ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR;
-  }
-# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  void ThrowJSException(JSContext* cx, JS::Handle<JS::Value> exn);
-  bool IsJSException() const
-  {
-    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_JS_EXCEPTION;
-  }
-
-
-
-
-
-
-  void ThrowDOMException(nsresult rv, const nsACString& message = EmptyCString());
-  bool IsDOMException() const
-  {
-    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_DOMEXCEPTION;
-  }
-
-
-
-
-  void NoteJSContextException(JSContext* aCx);
-
-
-
-  bool IsJSContextException() {
-    return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_EXCEPTION_ON_JSCONTEXT;
-  }
-
-
-  void ThrowUncatchableException() {
-    Throw(NS_ERROR_UNCATCHABLE_EXCEPTION);
-  }
-  bool IsUncatchableException() const {
-    return ErrorCode() == NS_ERROR_UNCATCHABLE_EXCEPTION;
-  }
-
-  void __attribute__((always_inline)) inline MightThrowJSException()
-  {
-
-
-
-  }
-  void __attribute__((always_inline)) inline WouldReportJSException()
-  {
-
-
-
-  }
-# 374 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  void operator=(nsresult rv) {
-    AssignErrorCode(rv);
-  }
-
-  bool Failed() const {
-    return ((bool)(__builtin_expect(!!(NS_FAILED_impl(mResult)), 0)));
-  }
-
-  bool ErrorCodeIs(nsresult rv) const {
-    return mResult == rv;
-  }
-
-
-  uint32_t ErrorCodeAsInt() const {
-    return static_cast<uint32_t>(ErrorCode());
-  }
-
-protected:
-  nsresult ErrorCode() const {
-    return mResult;
-  }
-
-private:
-# 406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  friend struct IPC::ParamTraits<TErrorResult>;
-  friend struct IPC::ParamTraits<ErrorResult>;
-  void SerializeMessage(IPC::Message* aMsg) const;
-  bool DeserializeMessage(const IPC::Message* aMsg, PickleIterator* aIter);
-
-  void SerializeDOMExceptionInfo(IPC::Message* aMsg) const;
-  bool DeserializeDOMExceptionInfo(const IPC::Message* aMsg, PickleIterator* aIter);
-
-
-
-  nsTArray<nsString>& CreateErrorMessageHelper(const dom::ErrNum errorNumber, nsresult errorType);
-
-  template<dom::ErrNum errorNumber, typename... Ts>
-  void ThrowErrorWithMessage(nsresult errorType, Ts&&... messageArgs)
-  {
-
-
-
-
-
-    ClearUnionData();
-
-    nsTArray<nsString>& messageArgsArray = CreateErrorMessageHelper(errorNumber, errorType);
-    uint16_t argCount = dom::GetErrorArgCount(errorNumber);
-    dom::StringArrayAppender::Append(messageArgsArray, argCount,
-                                     Forward<Ts>(messageArgs)...);
-
-
-
-  }
-
-  __attribute__((always_inline)) inline void AssertInOwningThread() const {
-
-
-
-  }
-
-  void AssignErrorCode(nsresult aRv) {
-    do { } while (0);
-
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-
-    mResult = aRv;
-  }
-
-  void ClearMessage();
-  void ClearDOMExceptionInfo();
-
-
-
-
-
-
-
-  void ClearUnionData();
-
-
-
-  void SetPendingException(JSContext* cx);
-
-
-  void SetPendingExceptionWithMessage(JSContext* cx);
-  void SetPendingJSException(JSContext* cx);
-  void SetPendingDOMException(JSContext* cx);
-  void SetPendingGenericErrorException(JSContext* cx);
-
-  __attribute__((always_inline)) inline void AssertReportedOrSuppressed()
-  {
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-  }
-# 497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  nsresult mResult;
-
-  struct Message;
-  struct DOMExceptionInfo;
-
-
-
-
-
-
-  union {
-    Message* mMessage;
-    JS::Value mJSException;
-    DOMExceptionInfo* mDOMExceptionInfo;
-  };
-# 530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-  TErrorResult(const TErrorResult&) = delete;
-  void operator=(const TErrorResult&) = delete;
-};
-
-struct JustAssertCleanupPolicy {
-  static const bool assertHandled = true;
-  static const bool suppress = false;
-};
-
-struct AssertAndSuppressCleanupPolicy {
-  static const bool assertHandled = true;
-  static const bool suppress = true;
-};
-
-struct JustSuppressCleanupPolicy {
-  static const bool assertHandled = false;
-  static const bool suppress = true;
-};
-
-}
-
-
-
-class ErrorResult :
-    public binding_danger::TErrorResult<binding_danger::AssertAndSuppressCleanupPolicy>
-{
-  typedef binding_danger::TErrorResult<binding_danger::AssertAndSuppressCleanupPolicy> BaseErrorResult;
-
-public:
-  ErrorResult()
-    : BaseErrorResult()
-  {}
-
-  ErrorResult(ErrorResult&& aRHS)
-    : BaseErrorResult(Move(aRHS))
-  {}
-
-  explicit ErrorResult(nsresult aRv)
-    : BaseErrorResult(aRv)
-  {}
-
-  void operator=(nsresult rv)
-  {
-    BaseErrorResult::operator=(rv);
-  }
-
-  ErrorResult& operator=(ErrorResult&& aRHS)
-  {
-    BaseErrorResult::operator=(Move(aRHS));
-    return *this;
-  }
-
-private:
-
-
-  ErrorResult(const ErrorResult&) = delete;
-  void operator=(const ErrorResult&) = delete;
-};
-
-template<typename CleanupPolicy>
-binding_danger::TErrorResult<CleanupPolicy>::operator ErrorResult&()
-{
-  return *static_cast<ErrorResult*>(
-     reinterpret_cast<TErrorResult<AssertAndSuppressCleanupPolicy>*>(this));
-}
-
-
-
-
-class IgnoredErrorResult :
-    public binding_danger::TErrorResult<binding_danger::JustSuppressCleanupPolicy>
-{
-};
-
-namespace dom {
-namespace binding_detail {
-class FastErrorResult :
-    public mozilla::binding_danger::TErrorResult<
-      mozilla::binding_danger::JustAssertCleanupPolicy>
-{
-};
-}
-}
-# 627 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-namespace binding_danger {
-class OOMReporterInstantiator;
-}
-
-class OOMReporter : private dom::binding_detail::FastErrorResult
-{
-public:
-  void ReportOOM()
-  {
-    Throw(NS_ERROR_OUT_OF_MEMORY);
-  }
-
-private:
-
-
-  friend class binding_danger::OOMReporterInstantiator;
-
-
-  template<typename CleanupPolicy>
-  friend class binding_danger::TErrorResult;
-
-  OOMReporter()
-    : dom::binding_detail::FastErrorResult()
-  {
-  }
-};
-
-namespace binding_danger {
-class OOMReporterInstantiator : public OOMReporter
-{
-public:
-  OOMReporterInstantiator()
-    : OOMReporter()
-  {
-  }
-
-
-
-
-  bool MaybeSetPendingException(JSContext* cx)
-  {
-    return OOMReporter::MaybeSetPendingException(cx);
-  }
-};
-}
-
-template<typename CleanupPolicy>
-binding_danger::TErrorResult<CleanupPolicy>::operator OOMReporter&()
-{
-  return *static_cast<OOMReporter*>(
-     reinterpret_cast<TErrorResult<JustAssertCleanupPolicy>*>(this));
-}
-# 706 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ErrorResult.h"
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h"
-class nsCString;
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h"
-enum nsEventStatus
-{
-
-  nsEventStatus_eIgnore,
-
-  nsEventStatus_eConsumeNoDefault,
-
-  nsEventStatus_eConsumeDoDefault,
-
-  nsEventStatus_eSentinel
-};
-
-namespace mozilla {
-
-
-
-
-
-typedef uint16_t EventMessageType;
-
-enum EventMessage : EventMessageType
-{
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventMessageList.h" 1
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventMessageList.h"
-eVoidEvent,
-
-
-
-eAllEvents,
-
-
-eWindowClose,
-
-eKeyPress,
-eKeyUp,
-eKeyDown,
-
-
-
-
-
-eKeyDownOnPlugin,
-eKeyUpOnPlugin,
-
-
-
-
-
-eAccessKeyNotFound,
-
-eResize,
-eScroll,
-
-
-eInstall,
-eAppInstalled,
-
-
-
-
-
-ePluginActivate,
-ePluginFocus,
-
-eOffline,
-eOnline,
-
-eLanguageChange,
-
-eMouseMove,
-eMouseUp,
-eMouseDown,
-eMouseEnterIntoWidget,
-eMouseExitFromWidget,
-eMouseDoubleClick,
-eMouseClick,
-eMouseAuxClick,
-
-eMouseActivate,
-eMouseOver,
-eMouseOut,
-eMouseHitTest,
-eMouseEnter,
-eMouseLeave,
-eMouseTouchDrag,
-eMouseLongTap,
-eMouseEventFirst = eMouseMove, eMouseEventLast = eMouseLongTap,
-
-
-ePointerMove,
-ePointerUp,
-ePointerDown,
-ePointerOver,
-ePointerOut,
-ePointerEnter,
-ePointerLeave,
-ePointerCancel,
-ePointerGotCapture,
-ePointerLostCapture,
-ePointerEventFirst = ePointerMove, ePointerEventLast = ePointerLostCapture,
-
-eContextMenu,
-
-eLoad,
-eUnload,
-eHashChange,
-eImageAbort,
-eLoadError,
-eLoadEnd,
-ePopState,
-eStorage,
-eBeforeUnload,
-eReadyStateChange,
-
-eFormSubmit,
-eFormReset,
-eFormChange,
-eFormSelect,
-eFormInvalid,
-
-
-eFocus,
-eBlur,
-eFocusIn,
-eFocusOut,
-
-eDragEnter,
-eDragOver,
-eDragExit,
-eDrag,
-eDragEnd,
-eDragStart,
-eDrop,
-eDragLeave,
-eDragDropEventFirst = eDragEnter, eDragDropEventLast = eDragLeave,
-
-
-eXULPopupShowing,
-eXULPopupShown,
-eXULPopupPositioned,
-eXULPopupHiding,
-eXULPopupHidden,
-eXULBroadcast,
-eXULCommandUpdate,
-
-
-eLegacyMouseLineOrPageScroll,
-eLegacyMousePixelScroll,
-
-eScrollPortUnderflow,
-eScrollPortOverflow,
-
-eLegacySubtreeModified,
-eLegacyNodeInserted,
-eLegacyNodeRemoved,
-eLegacyNodeRemovedFromDocument,
-eLegacyNodeInsertedIntoDocument,
-eLegacyAttrModified,
-eLegacyCharacterDataModified,
-eLegacyMutationEventFirst = eLegacySubtreeModified, eLegacyMutationEventLast = eLegacyCharacterDataModified,
-
-
-eUnidentifiedEvent,
-
-
-eCompositionStart,
-
-
-
-eCompositionEnd,
-
-
-
-
-eCompositionUpdate,
-
-
-
-
-eCompositionChange,
-
-
-
-
-
-
-eCompositionCommitAsIs,
-
-
-
-
-
-eCompositionCommit,
-
-
-
-
-eLegacyDOMActivate,
-
-eLegacyDOMFocusIn,
-
-eLegacyDOMFocusOut,
-
-
-ePageShow,
-ePageHide,
-
-
-eSVGLoad,
-eSVGUnload,
-eSVGResize,
-eSVGScroll,
-
-
-eSVGZoom,
-
-
-eXULCommand,
-
-
-eCopy,
-eCut,
-ePaste,
-ePasteNoFormatting,
-
-
-
-eQuerySelectedText,
-
-
-
-eQueryTextContent,
-
-
-eQueryCaretRect,
-
-
-
-eQueryTextRect,
-
-
-eQueryTextRectArray,
-
-
-eQueryEditorRect,
-
-
-eQueryContentState,
-
-eQuerySelectionAsTransferable,
-
-
-
-eQueryCharacterAtPoint,
-
-
-eQueryDOMWidgetHittest,
-
-
-eLoadStart,
-eProgress,
-eSuspend,
-eEmptied,
-eStalled,
-ePlay,
-ePause,
-eLoadedMetaData,
-eLoadedData,
-eWaiting,
-ePlaying,
-eCanPlay,
-eCanPlayThrough,
-eSeeking,
-eSeeked,
-eTimeUpdate,
-eEnded,
-eRateChange,
-eDurationChange,
-eVolumeChange,
-
-
-eAfterPaint,
-
-
-eSwipeGestureMayStart,
-eSwipeGestureStart,
-eSwipeGestureUpdate,
-eSwipeGestureEnd,
-eSwipeGesture,
-eMagnifyGestureStart,
-eMagnifyGestureUpdate,
-eMagnifyGesture,
-eRotateGestureStart,
-eRotateGestureUpdate,
-eRotateGesture,
-eTapGesture,
-ePressTapGesture,
-eEdgeUIStarted,
-eEdgeUICanceled,
-eEdgeUICompleted,
-
-
-ePluginInputEvent,
-
-
-
-eSetSelection,
-
-
-eContentCommandCut,
-eContentCommandCopy,
-eContentCommandPaste,
-eContentCommandDelete,
-eContentCommandUndo,
-eContentCommandRedo,
-eContentCommandPasteTransferable,
-eContentCommandLookUpDictionary,
-
-
-
-
-
-
-eContentCommandScroll,
-
-
-eGestureNotify,
-
-eScrolledAreaChanged,
-
-
-eTransitionStart,
-eTransitionRun,
-eTransitionEnd,
-eTransitionCancel,
-eAnimationStart,
-eAnimationEnd,
-eAnimationIteration,
-eAnimationCancel,
-
-
-eWebkitTransitionEnd,
-eWebkitAnimationStart,
-eWebkitAnimationEnd,
-eWebkitAnimationIteration,
-
-eSMILBeginEvent,
-eSMILEndEvent,
-eSMILRepeatEvent,
-
-eAudioProcess,
-eAudioComplete,
-
-
-eBeforeScriptExecute,
-eAfterScriptExecute,
-
-eBeforePrint,
-eAfterPrint,
-
-eMessage,
-
-
-eOpen,
-
-
-eDeviceOrientation,
-eAbsoluteDeviceOrientation,
-eDeviceMotion,
-eDeviceProximity,
-eUserProximity,
-eDeviceLight,
-
-
-
-
-
-eVRDisplayActivate,
-eVRDisplayDeactivate,
-eVRDisplayConnect,
-eVRDisplayDisconnect,
-eVRDisplayPresentChange,
-
-eShow,
-
-
-eFullscreenChange,
-eFullscreenError,
-eMozFullscreenChange,
-eMozFullscreenError,
-
-eTouchStart,
-eTouchMove,
-eTouchEnd,
-eTouchCancel,
-eTouchPointerCancel,
-
-
-ePointerLockChange,
-ePointerLockError,
-eMozPointerLockChange,
-eMozPointerLockError,
-
-
-eWheel,
-
-
-
-eWheelOperationStart,
-
-
-
-eWheelOperationEnd,
-
-
-eTimeChange,
-
-
-eNetworkUpload,
-eNetworkDownload,
-
-
-eMediaRecorderDataAvailable,
-eMediaRecorderWarning,
-eMediaRecorderStop,
-
-
-eGamepadButtonDown,
-eGamepadButtonUp,
-eGamepadAxisMove,
-eGamepadConnected,
-eGamepadDisconnected,
-eGamepadEventFirst = eGamepadButtonDown, eGamepadEventLast = eGamepadDisconnected,
-
-
-
-eEditorInput,
-
-
-eSelectStart,
-eSelectionChange,
-
-
-eToggle,
-
-
-eClose,
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-
-
-
-
-
-  eEventMessage_MaxValue
-};
-
-const char* ToChar(EventMessage aEventMessage);
-
-
-
-
-
-typedef uint8_t EventClassIDType;
-
-enum EventClassID : EventClassIDType
-{
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h"
-eBasicEventClass
-, eGUIEventClass
-, eInputEventClass
-, eUIEventClass
-
-
-, eKeyboardEventClass
-, eCompositionEventClass
-, eQueryContentEventClass
-, eSelectionEventClass
-, eEditorInputEventClass
-
-
-, eMouseEventBaseClass
-, eMouseEventClass
-, eDragEventClass
-, eMouseScrollEventClass
-, eWheelEventClass
-, ePointerEventClass
-
-
-, eGestureNotifyEventClass
-, eSimpleGestureEventClass
-, eTouchEventClass
-
-
-, eScrollPortEventClass
-, eScrollAreaEventClass
-, eFormEventClass
-, eClipboardEventClass
-, eFocusEventClass
-, eTransitionEventClass
-, eAnimationEventClass
-, eSMILTimeEventClass
-
-
-, eCommandEventClass
-, eContentCommandEventClass
-, ePluginEventClass
-
-
-, eMutationEventClass
-# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-
-
-
-};
-
-const char* ToChar(EventClassID aEventClassID);
-
-typedef uint16_t Modifiers;
-
-
-
-
-typedef uint16_t KeyNameIndexType;
-enum KeyNameIndex : KeyNameIndexType
-{
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h"
-KEY_NAME_INDEX_Unidentified,
-
-
-
-
-KEY_NAME_INDEX_PrintableKey,
-KEY_NAME_INDEX_SoftLeft,
-KEY_NAME_INDEX_SoftRight,
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/KeyNameList.h"
-KEY_NAME_INDEX_Alt,
-KEY_NAME_INDEX_AltGraph,
-KEY_NAME_INDEX_CapsLock,
-KEY_NAME_INDEX_Control,
-KEY_NAME_INDEX_Fn,
-KEY_NAME_INDEX_FnLock,
-KEY_NAME_INDEX_Hyper,
-KEY_NAME_INDEX_Meta,
-KEY_NAME_INDEX_NumLock,
-KEY_NAME_INDEX_OS,
-KEY_NAME_INDEX_ScrollLock,
-KEY_NAME_INDEX_Shift,
-KEY_NAME_INDEX_Super,
-KEY_NAME_INDEX_Symbol,
-KEY_NAME_INDEX_SymbolLock,
-
-
-
-
-KEY_NAME_INDEX_Enter,
-KEY_NAME_INDEX_Tab,
-
-
-
-
-KEY_NAME_INDEX_ArrowDown,
-KEY_NAME_INDEX_ArrowLeft,
-KEY_NAME_INDEX_ArrowRight,
-KEY_NAME_INDEX_ArrowUp,
-KEY_NAME_INDEX_End,
-KEY_NAME_INDEX_Home,
-KEY_NAME_INDEX_PageDown,
-KEY_NAME_INDEX_PageUp,
-
-
-
-
-KEY_NAME_INDEX_Backspace,
-KEY_NAME_INDEX_Clear,
-KEY_NAME_INDEX_Copy,
-KEY_NAME_INDEX_CrSel,
-KEY_NAME_INDEX_Cut,
-KEY_NAME_INDEX_Delete,
-KEY_NAME_INDEX_EraseEof,
-KEY_NAME_INDEX_ExSel,
-KEY_NAME_INDEX_Insert,
-KEY_NAME_INDEX_Paste,
-KEY_NAME_INDEX_Redo,
-KEY_NAME_INDEX_Undo,
-
-
-
-
-KEY_NAME_INDEX_Accept,
-KEY_NAME_INDEX_Again,
-KEY_NAME_INDEX_Attn,
-KEY_NAME_INDEX_Cancel,
-KEY_NAME_INDEX_ContextMenu,
-KEY_NAME_INDEX_Escape,
-KEY_NAME_INDEX_Execute,
-KEY_NAME_INDEX_Find,
-KEY_NAME_INDEX_Help,
-KEY_NAME_INDEX_Pause,
-KEY_NAME_INDEX_Play,
-KEY_NAME_INDEX_Props,
-KEY_NAME_INDEX_Select,
-KEY_NAME_INDEX_ZoomIn,
-KEY_NAME_INDEX_ZoomOut,
-
-
-
-
-KEY_NAME_INDEX_BrightnessDown,
-KEY_NAME_INDEX_BrightnessUp,
-KEY_NAME_INDEX_Eject,
-KEY_NAME_INDEX_LogOff,
-KEY_NAME_INDEX_Power,
-KEY_NAME_INDEX_PowerOff,
-KEY_NAME_INDEX_PrintScreen,
-KEY_NAME_INDEX_Hibernate,
-KEY_NAME_INDEX_Standby,
-KEY_NAME_INDEX_WakeUp,
-
-
-
-
-KEY_NAME_INDEX_AllCandidates,
-KEY_NAME_INDEX_Alphanumeric,
-KEY_NAME_INDEX_CodeInput,
-KEY_NAME_INDEX_Compose,
-KEY_NAME_INDEX_Convert,
-KEY_NAME_INDEX_Dead,
-KEY_NAME_INDEX_FinalMode,
-KEY_NAME_INDEX_GroupFirst,
-KEY_NAME_INDEX_GroupLast,
-KEY_NAME_INDEX_GroupNext,
-KEY_NAME_INDEX_GroupPrevious,
-KEY_NAME_INDEX_ModeChange,
-KEY_NAME_INDEX_NextCandidate,
-KEY_NAME_INDEX_NonConvert,
-KEY_NAME_INDEX_PreviousCandidate,
-KEY_NAME_INDEX_Process,
-KEY_NAME_INDEX_SingleCandidate,
-
-
-
-
-KEY_NAME_INDEX_HangulMode,
-KEY_NAME_INDEX_HanjaMode,
-KEY_NAME_INDEX_JunjaMode,
-
-
-
-
-KEY_NAME_INDEX_Eisu,
-KEY_NAME_INDEX_Hankaku,
-KEY_NAME_INDEX_Hiragana,
-KEY_NAME_INDEX_HiraganaKatakana,
-KEY_NAME_INDEX_KanaMode,
-KEY_NAME_INDEX_KanjiMode,
-KEY_NAME_INDEX_Katakana,
-KEY_NAME_INDEX_Romaji,
-KEY_NAME_INDEX_Zenkaku,
-KEY_NAME_INDEX_ZenkakuHankaku,
-
-
-
-
-KEY_NAME_INDEX_F1,
-KEY_NAME_INDEX_F2,
-KEY_NAME_INDEX_F3,
-KEY_NAME_INDEX_F4,
-KEY_NAME_INDEX_F5,
-KEY_NAME_INDEX_F6,
-KEY_NAME_INDEX_F7,
-KEY_NAME_INDEX_F8,
-KEY_NAME_INDEX_F9,
-KEY_NAME_INDEX_F10,
-KEY_NAME_INDEX_F11,
-KEY_NAME_INDEX_F12,
-KEY_NAME_INDEX_F13,
-KEY_NAME_INDEX_F14,
-KEY_NAME_INDEX_F15,
-KEY_NAME_INDEX_F16,
-KEY_NAME_INDEX_F17,
-KEY_NAME_INDEX_F18,
-KEY_NAME_INDEX_F19,
-KEY_NAME_INDEX_F20,
-KEY_NAME_INDEX_F21,
-KEY_NAME_INDEX_F22,
-KEY_NAME_INDEX_F23,
-KEY_NAME_INDEX_F24,
-KEY_NAME_INDEX_F25,
-KEY_NAME_INDEX_F26,
-KEY_NAME_INDEX_F27,
-KEY_NAME_INDEX_F28,
-KEY_NAME_INDEX_F29,
-KEY_NAME_INDEX_F30,
-KEY_NAME_INDEX_F31,
-KEY_NAME_INDEX_F32,
-KEY_NAME_INDEX_F33,
-KEY_NAME_INDEX_F34,
-KEY_NAME_INDEX_F35,
-KEY_NAME_INDEX_Soft1,
-KEY_NAME_INDEX_Soft2,
-KEY_NAME_INDEX_Soft3,
-KEY_NAME_INDEX_Soft4,
-
-
-
-
-KEY_NAME_INDEX_ChannelDown,
-KEY_NAME_INDEX_ChannelUp,
-KEY_NAME_INDEX_Close,
-KEY_NAME_INDEX_MailForward,
-KEY_NAME_INDEX_MailReply,
-KEY_NAME_INDEX_MailSend,
-KEY_NAME_INDEX_MediaFastForward,
-KEY_NAME_INDEX_MediaPause,
-KEY_NAME_INDEX_MediaPlay,
-KEY_NAME_INDEX_MediaPlayPause,
-KEY_NAME_INDEX_MediaRecord,
-KEY_NAME_INDEX_MediaRewind,
-KEY_NAME_INDEX_MediaStop,
-KEY_NAME_INDEX_MediaTrackNext,
-KEY_NAME_INDEX_MediaTrackPrevious,
-KEY_NAME_INDEX_New,
-KEY_NAME_INDEX_Open,
-KEY_NAME_INDEX_Print,
-KEY_NAME_INDEX_Save,
-KEY_NAME_INDEX_SpellCheck,
-
-
-
-
-KEY_NAME_INDEX_Key11,
-KEY_NAME_INDEX_Key12,
-
-
-
-
-KEY_NAME_INDEX_AudioBalanceLeft,
-KEY_NAME_INDEX_AudioBalanceRight,
-KEY_NAME_INDEX_AudioBassBoostDown,
-KEY_NAME_INDEX_AudioBassBoostToggle,
-KEY_NAME_INDEX_AudioBassBoostUp,
-KEY_NAME_INDEX_AudioFaderFront,
-KEY_NAME_INDEX_AudioFaderRear,
-KEY_NAME_INDEX_AudioSurroundModeNext,
-KEY_NAME_INDEX_AudioTrebleDown,
-KEY_NAME_INDEX_AudioTrebleUp,
-KEY_NAME_INDEX_AudioVolumeDown,
-KEY_NAME_INDEX_AudioVolumeUp,
-KEY_NAME_INDEX_AudioVolumeMute,
-
-KEY_NAME_INDEX_MicrophoneToggle,
-KEY_NAME_INDEX_MicrophoneVolumeDown,
-KEY_NAME_INDEX_MicrophoneVolumeUp,
-KEY_NAME_INDEX_MicrophoneVolumeMute,
-
-
-
-
-KEY_NAME_INDEX_SpeechCorrectionList,
-KEY_NAME_INDEX_SpeechInputToggle,
-
-
-
-
-KEY_NAME_INDEX_LaunchCalculator,
-KEY_NAME_INDEX_LaunchCalendar,
-KEY_NAME_INDEX_LaunchContacts,
-KEY_NAME_INDEX_LaunchMail,
-KEY_NAME_INDEX_LaunchMediaPlayer,
-KEY_NAME_INDEX_LaunchMusicPlayer,
-KEY_NAME_INDEX_LaunchMyComputer,
-KEY_NAME_INDEX_LaunchPhone,
-KEY_NAME_INDEX_LaunchScreenSaver,
-KEY_NAME_INDEX_LaunchSpreadsheet,
-KEY_NAME_INDEX_LaunchWebBrowser,
-KEY_NAME_INDEX_LaunchWebCam,
-KEY_NAME_INDEX_LaunchWordProcessor,
-
-KEY_NAME_INDEX_LaunchApplication1,
-KEY_NAME_INDEX_LaunchApplication2,
-KEY_NAME_INDEX_LaunchApplication3,
-KEY_NAME_INDEX_LaunchApplication4,
-KEY_NAME_INDEX_LaunchApplication5,
-KEY_NAME_INDEX_LaunchApplication6,
-KEY_NAME_INDEX_LaunchApplication7,
-KEY_NAME_INDEX_LaunchApplication8,
-KEY_NAME_INDEX_LaunchApplication9,
-KEY_NAME_INDEX_LaunchApplication10,
-KEY_NAME_INDEX_LaunchApplication11,
-KEY_NAME_INDEX_LaunchApplication12,
-KEY_NAME_INDEX_LaunchApplication13,
-KEY_NAME_INDEX_LaunchApplication14,
-KEY_NAME_INDEX_LaunchApplication15,
-KEY_NAME_INDEX_LaunchApplication16,
-KEY_NAME_INDEX_LaunchApplication17,
-KEY_NAME_INDEX_LaunchApplication18,
-
-
-
-
-KEY_NAME_INDEX_BrowserBack,
-KEY_NAME_INDEX_BrowserFavorites,
-KEY_NAME_INDEX_BrowserForward,
-KEY_NAME_INDEX_BrowserHome,
-KEY_NAME_INDEX_BrowserRefresh,
-KEY_NAME_INDEX_BrowserSearch,
-KEY_NAME_INDEX_BrowserStop,
-
-
-
-
-KEY_NAME_INDEX_AppSwitch,
-KEY_NAME_INDEX_Call,
-KEY_NAME_INDEX_Camera,
-KEY_NAME_INDEX_CameraFocus,
-KEY_NAME_INDEX_EndCall,
-KEY_NAME_INDEX_GoBack,
-KEY_NAME_INDEX_GoHome,
-KEY_NAME_INDEX_HeadsetHook,
-KEY_NAME_INDEX_LastNumberRedial,
-KEY_NAME_INDEX_Notification,
-KEY_NAME_INDEX_MannerMode,
-KEY_NAME_INDEX_VoiceDial,
-
-
-
-
-KEY_NAME_INDEX_TV,
-KEY_NAME_INDEX_TV3DMode,
-KEY_NAME_INDEX_TVAntennaCable,
-KEY_NAME_INDEX_TVAudioDescription,
-KEY_NAME_INDEX_TVAudioDescriptionMixDown,
-KEY_NAME_INDEX_TVAudioDescriptionMixUp,
-KEY_NAME_INDEX_TVContentsMenu,
-KEY_NAME_INDEX_TVDataService,
-KEY_NAME_INDEX_TVInput,
-KEY_NAME_INDEX_TVInputComponent1,
-KEY_NAME_INDEX_TVInputComponent2,
-KEY_NAME_INDEX_TVInputComposite1,
-KEY_NAME_INDEX_TVInputComposite2,
-KEY_NAME_INDEX_TVInputHDMI1,
-KEY_NAME_INDEX_TVInputHDMI2,
-KEY_NAME_INDEX_TVInputHDMI3,
-KEY_NAME_INDEX_TVInputHDMI4,
-KEY_NAME_INDEX_TVInputVGA1,
-KEY_NAME_INDEX_TVMediaContext,
-KEY_NAME_INDEX_TVNetwork,
-KEY_NAME_INDEX_TVNumberEntry,
-KEY_NAME_INDEX_TVPower,
-KEY_NAME_INDEX_TVRadioService,
-KEY_NAME_INDEX_TVSatellite,
-KEY_NAME_INDEX_TVSatelliteBS,
-KEY_NAME_INDEX_TVSatelliteCS,
-KEY_NAME_INDEX_TVSatelliteToggle,
-KEY_NAME_INDEX_TVTerrestrialAnalog,
-KEY_NAME_INDEX_TVTerrestrialDigital,
-KEY_NAME_INDEX_TVTimer,
-
-
-
-
-KEY_NAME_INDEX_AVRInput,
-KEY_NAME_INDEX_AVRPower,
-KEY_NAME_INDEX_ColorF0Red,
-KEY_NAME_INDEX_ColorF1Green,
-KEY_NAME_INDEX_ColorF2Yellow,
-KEY_NAME_INDEX_ColorF3Blue,
-KEY_NAME_INDEX_ColorF4Grey,
-KEY_NAME_INDEX_ColorF5Brown,
-KEY_NAME_INDEX_ClosedCaptionToggle,
-KEY_NAME_INDEX_Dimmer,
-KEY_NAME_INDEX_DisplaySwap,
-KEY_NAME_INDEX_DVR,
-KEY_NAME_INDEX_Exit,
-KEY_NAME_INDEX_FavoriteClear0,
-KEY_NAME_INDEX_FavoriteClear1,
-KEY_NAME_INDEX_FavoriteClear2,
-KEY_NAME_INDEX_FavoriteClear3,
-KEY_NAME_INDEX_FavoriteRecall0,
-KEY_NAME_INDEX_FavoriteRecall1,
-KEY_NAME_INDEX_FavoriteRecall2,
-KEY_NAME_INDEX_FavoriteRecall3,
-KEY_NAME_INDEX_FavoriteStore0,
-KEY_NAME_INDEX_FavoriteStore1,
-KEY_NAME_INDEX_FavoriteStore2,
-KEY_NAME_INDEX_FavoriteStore3,
-KEY_NAME_INDEX_Guide,
-KEY_NAME_INDEX_GuideNextDay,
-KEY_NAME_INDEX_GuidePreviousDay,
-KEY_NAME_INDEX_Info,
-KEY_NAME_INDEX_InstantReplay,
-KEY_NAME_INDEX_Link,
-KEY_NAME_INDEX_ListProgram,
-KEY_NAME_INDEX_LiveContent,
-KEY_NAME_INDEX_Lock,
-KEY_NAME_INDEX_MediaApps,
-KEY_NAME_INDEX_MediaAudioTrack,
-KEY_NAME_INDEX_MediaLast,
-KEY_NAME_INDEX_MediaSkipBackward,
-KEY_NAME_INDEX_MediaSkipForward,
-KEY_NAME_INDEX_MediaStepBackward,
-KEY_NAME_INDEX_MediaStepForward,
-KEY_NAME_INDEX_MediaTopMenu,
-KEY_NAME_INDEX_NavigateIn,
-KEY_NAME_INDEX_NavigateNext,
-KEY_NAME_INDEX_NavigateOut,
-KEY_NAME_INDEX_NavigatePrevious,
-KEY_NAME_INDEX_NextFavoriteChannel,
-KEY_NAME_INDEX_NextUserProfile,
-KEY_NAME_INDEX_OnDemand,
-KEY_NAME_INDEX_Pairing,
-KEY_NAME_INDEX_PinPDown,
-KEY_NAME_INDEX_PinPMove,
-KEY_NAME_INDEX_PinPToggle,
-KEY_NAME_INDEX_PinPUp,
-KEY_NAME_INDEX_PlaySpeedDown,
-KEY_NAME_INDEX_PlaySpeedReset,
-KEY_NAME_INDEX_PlaySpeedUp,
-KEY_NAME_INDEX_RandomToggle,
-KEY_NAME_INDEX_RcLowBattery,
-KEY_NAME_INDEX_RecordSpeedNext,
-KEY_NAME_INDEX_RfBypass,
-KEY_NAME_INDEX_ScanChannelsToggle,
-KEY_NAME_INDEX_ScreenModeNext,
-KEY_NAME_INDEX_Settings,
-KEY_NAME_INDEX_SplitScreenToggle,
-KEY_NAME_INDEX_STBInput,
-KEY_NAME_INDEX_STBPower,
-KEY_NAME_INDEX_Subtitle,
-KEY_NAME_INDEX_Teletext,
-KEY_NAME_INDEX_VideoModeNext,
-KEY_NAME_INDEX_Wink,
-KEY_NAME_INDEX_ZoomToggle,
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-
-
-  KEY_NAME_INDEX_USE_STRING
-};
-
-
-
-const nsCString ToString(KeyNameIndex aKeyNameIndex);
-
-
-
-
-typedef uint8_t CodeNameIndexType;
-enum CodeNameIndex : CodeNameIndexType
-{
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h"
-CODE_NAME_INDEX_UNKNOWN,
-
-
-CODE_NAME_INDEX_Backquote,
-CODE_NAME_INDEX_Backslash,
-CODE_NAME_INDEX_Backspace,
-CODE_NAME_INDEX_BracketLeft,
-CODE_NAME_INDEX_BracketRight,
-CODE_NAME_INDEX_Comma,
-CODE_NAME_INDEX_Digit0,
-CODE_NAME_INDEX_Digit1,
-CODE_NAME_INDEX_Digit2,
-CODE_NAME_INDEX_Digit3,
-CODE_NAME_INDEX_Digit4,
-CODE_NAME_INDEX_Digit5,
-CODE_NAME_INDEX_Digit6,
-CODE_NAME_INDEX_Digit7,
-CODE_NAME_INDEX_Digit8,
-CODE_NAME_INDEX_Digit9,
-CODE_NAME_INDEX_Equal,
-CODE_NAME_INDEX_IntlBackslash,
-CODE_NAME_INDEX_IntlHash,
-CODE_NAME_INDEX_IntlRo,
-CODE_NAME_INDEX_IntlYen,
-CODE_NAME_INDEX_KeyA,
-CODE_NAME_INDEX_KeyB,
-CODE_NAME_INDEX_KeyC,
-CODE_NAME_INDEX_KeyD,
-CODE_NAME_INDEX_KeyE,
-CODE_NAME_INDEX_KeyF,
-CODE_NAME_INDEX_KeyG,
-CODE_NAME_INDEX_KeyH,
-CODE_NAME_INDEX_KeyI,
-CODE_NAME_INDEX_KeyJ,
-CODE_NAME_INDEX_KeyK,
-CODE_NAME_INDEX_KeyL,
-CODE_NAME_INDEX_KeyM,
-CODE_NAME_INDEX_KeyN,
-CODE_NAME_INDEX_KeyO,
-CODE_NAME_INDEX_KeyP,
-CODE_NAME_INDEX_KeyQ,
-CODE_NAME_INDEX_KeyR,
-CODE_NAME_INDEX_KeyS,
-CODE_NAME_INDEX_KeyT,
-CODE_NAME_INDEX_KeyU,
-CODE_NAME_INDEX_KeyV,
-CODE_NAME_INDEX_KeyW,
-CODE_NAME_INDEX_KeyX,
-CODE_NAME_INDEX_KeyY,
-CODE_NAME_INDEX_KeyZ,
-CODE_NAME_INDEX_Minus,
-CODE_NAME_INDEX_Period,
-CODE_NAME_INDEX_Quote,
-CODE_NAME_INDEX_Semicolon,
-CODE_NAME_INDEX_Slash,
-
-
-CODE_NAME_INDEX_AltLeft,
-CODE_NAME_INDEX_AltRight,
-CODE_NAME_INDEX_CapsLock,
-CODE_NAME_INDEX_ContextMenu,
-CODE_NAME_INDEX_ControlLeft,
-CODE_NAME_INDEX_ControlRight,
-CODE_NAME_INDEX_Enter,
-CODE_NAME_INDEX_OSLeft,
-CODE_NAME_INDEX_OSRight,
-CODE_NAME_INDEX_ShiftLeft,
-CODE_NAME_INDEX_ShiftRight,
-CODE_NAME_INDEX_Space,
-CODE_NAME_INDEX_Tab,
-
-
-CODE_NAME_INDEX_Convert,
-CODE_NAME_INDEX_KanaMode,
-CODE_NAME_INDEX_Lang1,
-CODE_NAME_INDEX_Lang2,
-CODE_NAME_INDEX_Lang3,
-CODE_NAME_INDEX_Lang4,
-CODE_NAME_INDEX_Lang5,
-CODE_NAME_INDEX_NonConvert,
-
-
-CODE_NAME_INDEX_Delete,
-CODE_NAME_INDEX_End,
-CODE_NAME_INDEX_Help,
-CODE_NAME_INDEX_Home,
-CODE_NAME_INDEX_Insert,
-CODE_NAME_INDEX_PageDown,
-CODE_NAME_INDEX_PageUp,
-
-
-CODE_NAME_INDEX_ArrowDown,
-CODE_NAME_INDEX_ArrowLeft,
-CODE_NAME_INDEX_ArrowRight,
-CODE_NAME_INDEX_ArrowUp,
-
-
-CODE_NAME_INDEX_NumLock,
-CODE_NAME_INDEX_Numpad0,
-CODE_NAME_INDEX_Numpad1,
-CODE_NAME_INDEX_Numpad2,
-CODE_NAME_INDEX_Numpad3,
-CODE_NAME_INDEX_Numpad4,
-CODE_NAME_INDEX_Numpad5,
-CODE_NAME_INDEX_Numpad6,
-CODE_NAME_INDEX_Numpad7,
-CODE_NAME_INDEX_Numpad8,
-CODE_NAME_INDEX_Numpad9,
-CODE_NAME_INDEX_NumpadAdd,
-CODE_NAME_INDEX_NumpadBackspace,
-CODE_NAME_INDEX_NumpadClear,
-CODE_NAME_INDEX_NumpadClearEntry,
-CODE_NAME_INDEX_NumpadComma,
-CODE_NAME_INDEX_NumpadDecimal,
-CODE_NAME_INDEX_NumpadDivide,
-CODE_NAME_INDEX_NumpadEnter,
-CODE_NAME_INDEX_NumpadEqual,
-CODE_NAME_INDEX_NumpadMemoryAdd,
-CODE_NAME_INDEX_NumpadMemoryClear,
-CODE_NAME_INDEX_NumpadMemoryRecall,
-CODE_NAME_INDEX_NumpadMemoryStore,
-CODE_NAME_INDEX_NumpadMemorySubtract,
-CODE_NAME_INDEX_NumpadMultiply,
-CODE_NAME_INDEX_NumpadParenLeft,
-CODE_NAME_INDEX_NumpadParenRight,
-CODE_NAME_INDEX_NumpadSubtract,
-
-
-CODE_NAME_INDEX_Escape,
-CODE_NAME_INDEX_F1,
-CODE_NAME_INDEX_F2,
-CODE_NAME_INDEX_F3,
-CODE_NAME_INDEX_F4,
-CODE_NAME_INDEX_F5,
-CODE_NAME_INDEX_F6,
-CODE_NAME_INDEX_F7,
-CODE_NAME_INDEX_F8,
-CODE_NAME_INDEX_F9,
-CODE_NAME_INDEX_F10,
-CODE_NAME_INDEX_F11,
-CODE_NAME_INDEX_F12,
-CODE_NAME_INDEX_F13,
-CODE_NAME_INDEX_F14,
-CODE_NAME_INDEX_F15,
-CODE_NAME_INDEX_F16,
-CODE_NAME_INDEX_F17,
-CODE_NAME_INDEX_F18,
-CODE_NAME_INDEX_F19,
-CODE_NAME_INDEX_F20,
-CODE_NAME_INDEX_F21,
-CODE_NAME_INDEX_F22,
-CODE_NAME_INDEX_F23,
-CODE_NAME_INDEX_F24,
-CODE_NAME_INDEX_Fn,
-CODE_NAME_INDEX_FnLock,
-CODE_NAME_INDEX_PrintScreen,
-CODE_NAME_INDEX_ScrollLock,
-CODE_NAME_INDEX_Pause,
-
-
-CODE_NAME_INDEX_BrowserBack,
-CODE_NAME_INDEX_BrowserFavorites,
-CODE_NAME_INDEX_BrowserForward,
-CODE_NAME_INDEX_BrowserHome,
-CODE_NAME_INDEX_BrowserRefresh,
-CODE_NAME_INDEX_BrowserSearch,
-CODE_NAME_INDEX_BrowserStop,
-CODE_NAME_INDEX_Eject,
-CODE_NAME_INDEX_LaunchApp1,
-CODE_NAME_INDEX_LaunchApp2,
-CODE_NAME_INDEX_LaunchMail,
-CODE_NAME_INDEX_MediaPlayPause,
-CODE_NAME_INDEX_MediaSelect,
-CODE_NAME_INDEX_MediaStop,
-CODE_NAME_INDEX_MediaTrackNext,
-CODE_NAME_INDEX_MediaTrackPrevious,
-CODE_NAME_INDEX_Power,
-CODE_NAME_INDEX_Sleep,
-CODE_NAME_INDEX_VolumeDown,
-CODE_NAME_INDEX_VolumeMute,
-CODE_NAME_INDEX_VolumeUp,
-CODE_NAME_INDEX_WakeUp,
-# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PhysicalKeyCodeNameList.h"
-CODE_NAME_INDEX_Again,
-CODE_NAME_INDEX_Copy,
-CODE_NAME_INDEX_Cut,
-CODE_NAME_INDEX_Find,
-CODE_NAME_INDEX_Open,
-CODE_NAME_INDEX_Paste,
-CODE_NAME_INDEX_Props,
-CODE_NAME_INDEX_Select,
-CODE_NAME_INDEX_Undo,
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-
-
-  CODE_NAME_INDEX_USE_STRING
-};
-
-
-
-const nsCString ToString(CodeNameIndex aCodeNameIndex);
-
-
-
-typedef int8_t CommandInt;
-enum Command : CommandInt
-{
-  CommandDoNothing
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CommandList.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CommandList.h"
-, CommandBeginLine
-, CommandCharNext
-, CommandCharPrevious
-, CommandCopy
-, CommandCut
-, CommandDelete
-, CommandDeleteCharBackward
-, CommandDeleteCharForward
-, CommandDeleteToBeginningOfLine
-, CommandDeleteToEndOfLine
-, CommandDeleteWordBackward
-, CommandDeleteWordForward
-, CommandEndLine
-, CommandLineNext
-, CommandLinePrevious
-, CommandMoveBottom
-, CommandMovePageDown
-, CommandMovePageUp
-, CommandMoveTop
-, CommandPaste
-, CommandScrollBottom
-, CommandScrollLineDown
-, CommandScrollLineUp
-, CommandScrollPageDown
-, CommandScrollPageUp
-, CommandScrollTop
-, CommandSelectAll
-, CommandSelectBeginLine
-, CommandSelectBottom
-, CommandSelectCharNext
-, CommandSelectCharPrevious
-, CommandSelectEndLine
-, CommandSelectLineNext
-, CommandSelectLinePrevious
-, CommandSelectPageDown
-, CommandSelectPageUp
-, CommandSelectTop
-, CommandSelectWordNext
-, CommandSelectWordPrevious
-, CommandWordNext
-, CommandWordPrevious
-# 125 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-};
-
-
-}
-
-
-
-
-
-namespace mozilla {
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventClassList.h"
-class WidgetEvent;
-class WidgetGUIEvent;
-class WidgetInputEvent;
-class InternalUIEvent;
-
-
-class WidgetKeyboardEvent;
-class WidgetCompositionEvent;
-class WidgetQueryContentEvent;
-class WidgetSelectionEvent;
-class InternalEditorInputEvent;
-
-
-class WidgetMouseEventBase;
-class WidgetMouseEvent;
-class WidgetDragEvent;
-class WidgetMouseScrollEvent;
-class WidgetWheelEvent;
-class WidgetPointerEvent;
-
-
-class WidgetGestureNotifyEvent;
-class WidgetSimpleGestureEvent;
-class WidgetTouchEvent;
-
-
-class InternalScrollPortEvent;
-class InternalScrollAreaEvent;
-class InternalFormEvent;
-class InternalClipboardEvent;
-class InternalFocusEvent;
-class InternalTransitionEvent;
-class InternalAnimationEvent;
-class InternalSMILTimeEvent;
-
-
-class WidgetCommandEvent;
-class WidgetContentCommandEvent;
-class WidgetPluginEvent;
-
-
-class InternalMutationEvent;
-# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventForwards.h" 2
-
-
-
-
-
-struct BaseEventFlags;
-struct EventFlags;
-
-class WidgetEventTime;
-
-class NativeEventData;
-
-
-struct AlternativeCharCode;
-struct ShortcutKeyCandidate;
-
-typedef nsTArray<ShortcutKeyCandidate> ShortcutKeyCandidateArray;
-typedef AutoTArray<ShortcutKeyCandidate, 10> AutoShortcutKeyCandidateArray;
-
-
-typedef uint8_t RawTextRangeType;
-enum class TextRangeType : RawTextRangeType;
-
-struct TextRangeStyle;
-struct TextRange;
-
-class TextRangeArray;
-
-
-struct FontRange;
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Nullable.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Nullable.h"
-class nsCycleCollectionTraversalCallback;
-
-namespace mozilla {
-namespace dom {
-
-
-template <typename T>
-struct Nullable
-{
-private:
-  Maybe<T> mValue;
-
-public:
-  Nullable()
-    : mValue()
-  {}
-
-               Nullable(const decltype(nullptr)&)
-    : mValue()
-  {}
-
-  explicit Nullable(const T& aValue)
-    : mValue()
-  {
-    mValue.emplace(aValue);
-  }
-
-               Nullable(T&& aValue)
-    : mValue()
-  {
-    mValue.emplace(mozilla::Move(aValue));
-  }
-
-  Nullable(Nullable<T>&& aOther)
-    : mValue(mozilla::Move(aOther.mValue))
-  {}
-
-  Nullable(const Nullable<T>& aOther)
-    : mValue(aOther.mValue)
-  {}
-
-  void operator=(const Nullable<T>& aOther)
-  {
-    mValue = aOther.mValue;
-  }
-
-  void SetValue(const T& aArgs)
-  {
-    mValue.reset();
-    mValue.emplace(aArgs);
-  }
-
-  void SetValue(T&& aArgs)
-  {
-    mValue.reset();
-    mValue.emplace(mozilla::Move(aArgs));
-  }
-
-
-
-
-  T& SetValue() {
-    if (mValue.isNothing()) {
-      mValue.emplace();
-    }
-    return mValue.ref();
-  }
-
-  void SetNull() {
-    mValue.reset();
-  }
-
-  const T& Value() const {
-    return mValue.ref();
-  }
-
-  T& Value() {
-    return mValue.ref();
-  }
-
-  bool IsNull() const {
-    return mValue.isNothing();
-  }
-
-  bool Equals(const Nullable<T>& aOtherNullable) const
-  {
-    return mValue == aOtherNullable.mValue;
-  }
-
-  bool operator==(const Nullable<T>& aOtherNullable) const
-  {
-    return Equals(aOtherNullable);
-  }
-
-  bool operator!=(const Nullable<T>& aOtherNullable) const
-  {
-    return !Equals(aOtherNullable);
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream,
-                                  const Nullable& aNullable) {
-    return aStream << aNullable.mValue;
-  }
-};
-
-
-template<typename T>
-void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            Nullable<T>& aNullable,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  if (!aNullable.IsNull()) {
-    ImplCycleCollectionTraverse(aCallback, aNullable.Value(), aName, aFlags);
-  }
-}
-
-template<typename T>
-void
-ImplCycleCollectionUnlink(Nullable<T>& aNullable)
-{
-  if (!aNullable.IsNull()) {
-    ImplCycleCollectionUnlink(aNullable.Value());
-  }
-}
-
-}
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h" 2
-
-using mozilla::dom::Nullable;
-namespace mozilla {
-class EventChainVisitor;
-class EventChainPostVisitor;
-class EventChainPreVisitor;
-class EventListenerManager;
-namespace dom {
-class EventTarget;
-}
-}
-class nsPresContext;
-class nsIScriptContext;
-
-class nsIDOMEventListener;
-
-class nsIDOMEvent;
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMEventTarget.h"
-class nsIDOMEventTarget : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult AddEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc) = 0;
-
-
-  virtual nsresult AddSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc) = 0;
-
-
-  nsresult AddEventListener(const nsAString& aType,
-                            nsIDOMEventListener* aListener,
-                            bool aUseCapture)
-  {
-    return AddEventListener(aType, aListener, aUseCapture, false, 1);
-  }
-
-  nsresult AddEventListener(const nsAString& aType,
-                            nsIDOMEventListener* aListener,
-                            bool aUseCapture,
-                            bool aWantsUntrusted)
-  {
-    return AddEventListener(aType, aListener, aUseCapture, aWantsUntrusted, 2);
-  }
-
-  nsresult AddSystemEventListener(const nsAString& aType,
-                                  nsIDOMEventListener* aListener,
-                                  bool aUseCapture)
-  {
-    return AddSystemEventListener(aType, aListener, aUseCapture, false, 1);
-  }
-
-  nsresult AddSystemEventListener(const nsAString& aType,
-                                  nsIDOMEventListener* aListener,
-                                  bool aUseCapture,
-                                  bool aWantsUntrusted)
-  {
-    return AddSystemEventListener(aType, aListener, aUseCapture,
-                                  aWantsUntrusted, 2);
-  }
-
-  virtual nsresult RemoveEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture) = 0;
-
-
-  virtual nsresult RemoveSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture) = 0;
-
-
-  virtual nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval) = 0;
-
-
-  virtual mozilla::dom::EventTarget * GetTargetForDOMEvent(void) = 0;
-
-
-  virtual mozilla::dom::EventTarget * GetTargetForEventTargetChain(void) = 0;
-
-
-  virtual nsresult GetEventTargetParent(mozilla::EventChainPreVisitor & aVisitor) = 0;
-
-   virtual nsresult PreHandleEvent(mozilla::EventChainVisitor& aVisitor)
-  {
-    return NS_OK;
-  }
-
-  virtual nsresult WillHandleEvent(mozilla::EventChainPostVisitor & aVisitor) = 0;
-
-
-  virtual nsresult PostHandleEvent(mozilla::EventChainPostVisitor & aVisitor) = 0;
-
-
-  virtual nsresult DispatchDOMEvent(mozilla::WidgetEvent *aEvent, nsIDOMEvent *aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) = 0;
-
-
-  virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv) = 0;
-
-};
-
-  template<typename T> struct nsIDOMEventTarget::COMTypeInfo<nsIDOMEventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMEventTarget::COMTypeInfo<nsIDOMEventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9a78ac3c, 0x9507, 0x4d00, { 0xb2, 0xd6, 0x10, 0xb5, 0x08, 0xd2, 0xec, 0x31 }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h" 1
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
-struct jsid
-{
-    size_t asBits;
-    bool operator==(const jsid& rhs) const { return asBits == rhs.asBits; }
-    bool operator!=(const jsid& rhs) const { return asBits != rhs.asBits; }
-} ;
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
-static __attribute__((always_inline)) inline bool
-JSID_IS_STRING(jsid iden)
-{
-    return ((iden.asBits) & 0x7) == 0;
-}
-
-static __attribute__((always_inline)) inline JSString*
-JSID_TO_STRING(jsid iden)
-{
-    do { } while (0);
-    return (JSString*)(iden.asBits);
-}
-# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Id.h"
-jsid
-INTERNED_STRING_TO_JSID(JSContext* cx, JSString* str);
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_INT(jsid iden)
-{
-    return !!((iden.asBits) & 0x1);
-}
-
-static __attribute__((always_inline)) inline int32_t
-JSID_TO_INT(jsid iden)
-{
-    do { } while (0);
-    uint32_t bits = static_cast<uint32_t>((iden.asBits)) >> 1;
-    return static_cast<int32_t>(bits);
-}
-
-
-
-
-static __attribute__((always_inline)) inline bool
-INT_FITS_IN_JSID(int32_t i)
-{
-    return i >= 0;
-}
-
-static __attribute__((always_inline)) inline jsid
-INT_TO_JSID(int32_t i)
-{
-    jsid iden;
-    do { } while (0);
-    uint32_t bits = (static_cast<uint32_t>(i) << 1) | 0x1;
-    (iden.asBits) = static_cast<size_t>(bits);
-    return iden;
-}
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_SYMBOL(jsid iden)
-{
-    return ((iden.asBits) & 0x7) == 0x4 &&
-           (iden.asBits) != 0x4;
-}
-
-static __attribute__((always_inline)) inline JS::Symbol*
-JSID_TO_SYMBOL(jsid iden)
-{
-    do { } while (0);
-    return (JS::Symbol*)((iden.asBits) & ~(size_t)0x7);
-}
-
-static __attribute__((always_inline)) inline jsid
-SYMBOL_TO_JSID(JS::Symbol* sym)
-{
-    jsid iden;
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    (iden.asBits) = (size_t(sym) | 0x4);
-    return iden;
-}
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_GCTHING(jsid iden)
-{
-    return JSID_IS_STRING(iden) || JSID_IS_SYMBOL(iden);
-}
-
-static __attribute__((always_inline)) inline JS::GCCellPtr
-JSID_TO_GCTHING(jsid iden)
-{
-    void* thing = (void*)((iden.asBits) & ~(size_t)0x7);
-    if (JSID_IS_STRING(iden))
-        return JS::GCCellPtr(thing, JS::TraceKind::String);
-    do { } while (0);
-    return JS::GCCellPtr(thing, JS::TraceKind::Symbol);
-}
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_VOID(const jsid iden)
-{
-    do { } while (0);
-
-    return (size_t)(iden.asBits) == 0x2;
-}
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_EMPTY(const jsid iden)
-{
-    return (size_t)(iden.asBits) == 0x4;
-}
-
-extern const jsid JSID_VOID;
-extern const jsid JSID_EMPTY;
-
-extern const JS::HandleId JSID_VOIDHANDLE;
-extern const JS::HandleId JSID_EMPTYHANDLE;
-
-namespace JS {
-
-template <>
-struct GCPolicy<jsid>
-{
-    static jsid initial() { return JSID_VOID; }
-    static void trace(JSTracer* trc, jsid* idp, const char* name) {
-        js::UnsafeTraceManuallyBarrieredEdge(trc, idp, name);
-    }
-};
-
-}
-
-namespace js {
-
-template <>
-struct BarrierMethods<jsid>
-{
-    static void postBarrier(jsid* idp, jsid prev, jsid next) {}
-    static void exposeToJS(jsid iden) {
-        if (JSID_IS_GCTHING(iden))
-            js::gc::ExposeGCThingToActiveJS(JSID_TO_GCTHING(iden));
-    }
-};
-
-
-
-template <typename F, typename... Args>
-auto
-DispatchTyped(F f, const jsid& iden, Args&&... args)
-  -> decltype(f(static_cast<JSString*>(nullptr), mozilla::Forward<Args>(args)...))
-{
-    if (JSID_IS_STRING(iden))
-        return f(JSID_TO_STRING(iden), mozilla::Forward<Args>(args)...);
-    if (JSID_IS_SYMBOL(iden))
-        return f(JSID_TO_SYMBOL(iden), mozilla::Forward<Args>(args)...);
-    do { } while (0);
-    return F::defaultValue(iden);
-}
-
-
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h" 2
-
-
-
-
-namespace mozilla {
-namespace dom {
-class TabChildGlobal;
-class ProcessGlobal;
-}
-}
-class SandboxPrivate;
-class nsInProcessTabChildGlobal;
-class nsWindowRoot;
-# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
-class nsWrapperCache
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  nsWrapperCache() : mWrapper(nullptr), mFlags(0)
-  {
-  }
-  ~nsWrapperCache()
-  {
-    do { } while (0);
-
-  }
-
-
-
-
-
-
-
-  JSObject* GetWrapper() const;
-# 101 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
-  JSObject* GetWrapperPreserveColor() const
-  {
-    return GetWrapperJSObject();
-  }
-# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
-  void SetWrapper(JSObject* aWrapper)
-  {
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-
-
-    SetWrapperJSObject(aWrapper);
-  }
-
-
-
-
-
-  void ClearWrapper()
-  {
-    do { } while (0);
-
-    SetWrapperJSObject(nullptr);
-  }
-
-
-
-
-
-
-
-  void UpdateWrapper(JSObject* aNewObject, const JSObject* aOldObject)
-  {
-    if (mWrapper) {
-      do { } while (0);
-      mWrapper = aNewObject;
-    }
-  }
-
-  bool PreservingWrapper() const
-  {
-    return HasWrapperFlag(WRAPPER_BIT_PRESERVED);
-  }
-
-  bool IsDOMBinding() const
-  {
-    return !HasWrapperFlag(WRAPPER_IS_NOT_DOM_BINDING);
-  }
-
-
-
-
-
-  virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) = 0;
-
-
-
-
-
-  bool HasKnownLiveWrapper() const;
-
-
-
-
-
-
-  bool HasKnownLiveWrapperAndDoesNotNeedTracing(nsISupports* aThis);
-
-  bool HasNothingToTrace(nsISupports* aThis);
-
-
-
-
-  void MarkWrapperLive();
-
-
-  void SetPreservingWrapper(bool aPreserve)
-  {
-    if(aPreserve) {
-      SetWrapperFlags(WRAPPER_BIT_PRESERVED);
-    }
-    else {
-      UnsetWrapperFlags(WRAPPER_BIT_PRESERVED);
-    }
-  }
-
-  void TraceWrapper(const TraceCallbacks& aCallbacks, void* aClosure)
-  {
-    if (PreservingWrapper() && mWrapper) {
-      aCallbacks.Trace(&mWrapper, "Preserved wrapper", aClosure);
-    }
-  }
-
-
-
-
-
-
-  typedef uint32_t FlagsType;
-
-  FlagsType GetFlags() const
-  {
-    return mFlags & ~kWrapperFlagsMask;
-  }
-
-  bool HasFlag(FlagsType aFlag) const
-  {
-    do { } while (0);
-    return !!(mFlags & aFlag);
-  }
-
-  void SetFlags(FlagsType aFlagsToSet)
-  {
-    do { } while (0);
-    mFlags |= aFlagsToSet;
-  }
-
-  void UnsetFlags(FlagsType aFlagsToUnset)
-  {
-    do { } while (0);
-    mFlags &= ~aFlagsToUnset;
-  }
-
-  void PreserveWrapper(nsISupports* aScriptObjectHolder)
-  {
-    if (PreservingWrapper()) {
-      return;
-    }
-
-    nsISupports* ccISupports;
-    aScriptObjectHolder->QueryInterface((nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports, void>::kIID),
-                                        reinterpret_cast<void**>(&ccISupports));
-    do { } while (0);
-
-    nsXPCOMCycleCollectionParticipant* participant;
-    CallQueryInterface(ccISupports, &participant);
-    PreserveWrapper(ccISupports, participant);
-  }
-
-  void PreserveWrapper(void* aScriptObjectHolder, nsScriptObjectTracer* aTracer)
-  {
-    if (PreservingWrapper()) {
-      return;
-    }
-
-    HoldJSObjects(aScriptObjectHolder, aTracer);
-    SetPreservingWrapper(true);
-
-
-
-
-  }
-
-  void ReleaseWrapper(void* aScriptObjectHolder);
-
-protected:
-  void TraceWrapper(JSTracer* aTrc, const char* name)
-  {
-    if (mWrapper) {
-      js::UnsafeTraceManuallyBarrieredEdge(aTrc, &mWrapper, name);
-    }
-  }
-
-  void PoisonWrapper()
-  {
-    if (mWrapper) {
-
-
-      mWrapper = reinterpret_cast<JSObject*>(1);
-    }
-  }
-
-private:
-
-
-
-  friend class mozilla::dom::TabChildGlobal;
-  friend class mozilla::dom::ProcessGlobal;
-  friend class SandboxPrivate;
-  friend class nsInProcessTabChildGlobal;
-  friend class nsWindowRoot;
-  void SetIsNotDOMBinding()
-  {
-    do { } while (0);
-
-    SetWrapperFlags(WRAPPER_IS_NOT_DOM_BINDING);
-  }
-
-  JSObject *GetWrapperJSObject() const
-  {
-    return mWrapper;
-  }
-
-  void SetWrapperJSObject(JSObject* aWrapper);
-
-  FlagsType GetWrapperFlags() const
-  {
-    return mFlags & kWrapperFlagsMask;
-  }
-
-  bool HasWrapperFlag(FlagsType aFlag) const
-  {
-    do { } while (0);
-    return !!(mFlags & aFlag);
-  }
-
-  void SetWrapperFlags(FlagsType aFlagsToSet)
-  {
-    do { } while (0);
-    mFlags |= aFlagsToSet;
-  }
-
-  void UnsetWrapperFlags(FlagsType aFlagsToUnset)
-  {
-    do { } while (0);
-    mFlags &= ~aFlagsToUnset;
-  }
-
-  void HoldJSObjects(void* aScriptObjectHolder,
-                     nsScriptObjectTracer* aTracer);
-# 347 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCache.h"
-  enum { WRAPPER_BIT_PRESERVED = 1 << 0 };
-
-
-
-
-
-  enum { WRAPPER_IS_NOT_DOM_BINDING = 1 << 1 };
-
-  enum { kWrapperFlagsMask = (WRAPPER_BIT_PRESERVED | WRAPPER_IS_NOT_DOM_BINDING) };
-
-  JSObject* mWrapper;
-  FlagsType mFlags;
-};
-
-enum { WRAPPER_CACHE_FLAGS_BITS_USED = 2 };
-
-template<typename T> struct nsWrapperCache::COMTypeInfo<nsWrapperCache, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsWrapperCache::COMTypeInfo<nsWrapperCache, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x6f3179a1, 0x36f7, 0x4a5c, { 0x8c, 0xf1, 0xad, 0xc8, 0x7c, 0xde, 0x3e, 0x87 } };
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/EventTarget.h" 2
-
-
-class nsPIDOMWindowOuter;
-class nsIGlobalObject;
-
-namespace mozilla {
-
-class AsyncEventDispatcher;
-class ErrorResult;
-class EventListenerManager;
-
-namespace dom {
-
-class AddEventListenerOptionsOrBoolean;
-class Event;
-class EventListener;
-class EventListenerOptionsOrBoolean;
-class EventHandlerNonNull;
-
-template <class T> struct Nullable;
-
-
-
-
-
-
-class EventTarget : public nsIDOMEventTarget,
-                    public nsWrapperCache
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  using nsIDOMEventTarget::AddEventListener;
-  using nsIDOMEventTarget::RemoveEventListener;
-  using nsIDOMEventTarget::DispatchEvent;
-  virtual void AddEventListener(const nsAString& aType,
-                                EventListener* aCallback,
-                                const AddEventListenerOptionsOrBoolean& aOptions,
-                                const Nullable<bool>& aWantsUntrusted,
-                                ErrorResult& aRv) = 0;
-  virtual void RemoveEventListener(const nsAString& aType,
-                                   EventListener* aCallback,
-                                   const EventListenerOptionsOrBoolean& aOptions,
-                                   ErrorResult& aRv);
-  bool DispatchEvent(Event& aEvent, CallerType aCallerType, ErrorResult& aRv);
-
-
-  EventHandlerNonNull* GetEventHandler(const nsAString& aType)
-  {
-    nsCOMPtr<nsIAtom> type = NS_Atomize(aType);
-    return GetEventHandler(type, EmptyString());
-  }
-
-
-  void SetEventHandler(const nsAString& aType, EventHandlerNonNull* aHandler,
-                       ErrorResult& rv);
-
-
-  virtual void EventListenerAdded(nsIAtom* aType) {}
-  virtual void EventListenerRemoved(nsIAtom* aType) {}
-
-
-
-
-  virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() = 0;
-
-
-
-
-  virtual nsIGlobalObject* GetOwnerGlobal() const = 0;
-
-
-
-
-  virtual EventListenerManager* GetOrCreateListenerManager() = 0;
-
-
-
-
-
-  virtual EventListenerManager* GetExistingListenerManager() const = 0;
-
-
-  virtual void AsyncEventRunning(AsyncEventDispatcher* aEvent) {}
-
-  virtual bool IsApzAware() const;
-
-protected:
-  EventHandlerNonNull* GetEventHandler(nsIAtom* aType,
-                                       const nsAString& aTypeString);
-  void SetEventHandler(nsIAtom* aType, const nsAString& aTypeString,
-                       EventHandlerNonNull* aHandler);
-};
-
-template<typename T> struct EventTarget::COMTypeInfo<EventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID EventTarget::COMTypeInfo<EventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xde651c36, 0x0053, 0x4c67, { 0xb1, 0x3d, 0x67, 0xb9, 0x40, 0xfc, 0x82, 0xe4 } };
-
-}
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-class nsAttrAndChildArray;
-class nsChildContentList;
-struct nsCSSSelectorList;
-class nsDOMAttributeMap;
-class nsIAnimationObserver;
-class nsIContent;
-class nsIDocument;
-class nsIDOMElement;
-class nsIDOMNodeList;
-class nsIEditor;
-class nsIFrame;
-class nsIMutationObserver;
-class nsINode;
-class nsINodeList;
-class nsIPresShell;
-class nsIPrincipal;
-class nsIURI;
-class nsNodeSupportsWeakRefTearoff;
-class nsNodeWeakReference;
-class nsDOMMutationObserver;
-
-namespace mozilla {
-class EventListenerManager;
-namespace dom {
-
-
-
-
-inline bool IsSpaceCharacter(char16_t aChar) {
-  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
-         aChar == '\f';
-}
-inline bool IsSpaceCharacter(char aChar) {
-  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
-         aChar == '\f';
-}
-class AccessibleNode;
-struct BoxQuadOptions;
-struct ConvertCoordinateOptions;
-class DOMPoint;
-class DOMQuad;
-class DOMRectReadOnly;
-class Element;
-class EventHandlerNonNull;
-template<typename T> class Optional;
-class OwningNodeOrString;
-template<typename> class Sequence;
-class Text;
-class TextOrElementOrDocument;
-struct DOMPointInit;
-struct GetRootNodeOptions;
-enum class CallerType : uint32_t;
-}
-}
-
-
-
-
-enum {
-
-  NODE_HAS_LISTENERMANAGER = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (0))),
-
-
-  NODE_HAS_PROPERTIES = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (1))),
-
-
-
-
-
-
-  NODE_IS_ANONYMOUS_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (2))),
-
-
-
-
-
-
-
-  NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (3))),
-
-
-
-
-
-  NODE_IS_NATIVE_ANONYMOUS_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (4))),
-
-
-
-  NODE_FORCE_XBL_BINDINGS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (5))),
-
-
-  NODE_MAY_BE_IN_BINDING_MNGR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (6))),
-
-  NODE_IS_EDITABLE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (7))),
-# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  NODE_IS_NATIVE_ANONYMOUS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (8))),
-
-
-  NODE_IS_IN_SHADOW_TREE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (9))),
-
-
-  NODE_HAS_EMPTY_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (10))),
-
-
-
-  NODE_HAS_SLOW_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (11))),
-
-
-
-  NODE_HAS_EDGE_CHILD_SELECTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (12))),
-# 174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (13))),
-
-  NODE_ALL_SELECTOR_FLAGS = NODE_HAS_EMPTY_SELECTOR |
-                                          NODE_HAS_SLOW_SELECTOR |
-                                          NODE_HAS_EDGE_CHILD_SELECTOR |
-                                          NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS,
-
-
-
-  NODE_NEEDS_FRAME = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (14))),
-
-
-
-
-  NODE_DESCENDANTS_NEED_FRAMES = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (15))),
-
-
-  NODE_HAS_ACCESSKEY = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (16))),
-
-
-  NODE_HAS_DIRECTION_RTL = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (17))),
-
-
-  NODE_HAS_DIRECTION_LTR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (18))),
-
-  NODE_ALL_DIRECTION_FLAGS = NODE_HAS_DIRECTION_LTR |
-                                          NODE_HAS_DIRECTION_RTL,
-
-  NODE_CHROME_ONLY_ACCESS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (19))),
-
-  NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (20))),
-
-
-
-
-
-
-  NODE_SHARED_RESTYLE_BIT_1 = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (21))),
-  NODE_SHARED_RESTYLE_BIT_2 = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (22))),
-
-
-  NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO = NODE_SHARED_RESTYLE_BIT_1,
-
-
-
-  NODE_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO =
-    NODE_SHARED_RESTYLE_BIT_2,
-
-
-  NODE_TYPE_SPECIFIC_BITS_OFFSET = 23
-};
-
-
-
-
-
-
-static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET) <= sizeof(nsWrapperCache::FlagsType) * 8, "Not enough space for our bits");
-
-
-
-
-
-
-
-class nsMutationGuard {
-public:
-  nsMutationGuard()
-  {
-    mStartingGeneration = sGeneration;
-  }
-# 258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  bool Mutated(uint8_t aIgnoreCount)
-  {
-    return (sGeneration - mStartingGeneration) > aIgnoreCount;
-  }
-
-
-
-
-  static void DidMutate()
-  {
-    sGeneration++;
-  }
-
-private:
-
-  uint64_t mStartingGeneration;
-
-
-  static uint64_t sGeneration;
-};
-# 301 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-class nsINode : public mozilla::dom::EventTarget
-{
-public:
-  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;
-  typedef mozilla::dom::ConvertCoordinateOptions ConvertCoordinateOptions;
-  typedef mozilla::dom::DOMPoint DOMPoint;
-  typedef mozilla::dom::DOMPointInit DOMPointInit;
-  typedef mozilla::dom::DOMQuad DOMQuad;
-  typedef mozilla::dom::DOMRectReadOnly DOMRectReadOnly;
-  typedef mozilla::dom::OwningNodeOrString OwningNodeOrString;
-  typedef mozilla::dom::TextOrElementOrDocument TextOrElementOrDocument;
-  typedef mozilla::dom::CallerType CallerType;
-  typedef mozilla::ErrorResult ErrorResult;
-
-  template<class T>
-  using Sequence = mozilla::dom::Sequence<T>;
-
-  template<typename T, typename U> struct COMTypeInfo;
-# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-
-
-
-
-
-  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-  }
-
-  friend class nsNodeUtils;
-  friend class nsNodeWeakReference;
-  friend class nsNodeSupportsWeakRefTearoff;
-  friend class nsAttrAndChildArray;
-
-
-  explicit nsINode(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
-  : mNodeInfo(aNodeInfo)
-  , mParent(nullptr)
-  , mBoolFlags(0)
-  , mNextSibling(nullptr)
-  , mPreviousSibling(nullptr)
-  , mFirstChild(nullptr)
-  , mSubtreeRoot(this)
-  , mSlots(nullptr)
-  {
-  }
-
-
-  virtual ~nsINode();
-
-
-
-
-  enum {
-
-    eCONTENT = 1 << 0,
-
-    eDOCUMENT = 1 << 1,
-
-    eATTRIBUTE = 1 << 2,
-
-    eTEXT = 1 << 3,
-
-    ePROCESSING_INSTRUCTION = 1 << 4,
-
-    eCOMMENT = 1 << 5,
-
-    eHTML_FORM_CONTROL = 1 << 6,
-
-    eDOCUMENT_FRAGMENT = 1 << 7,
-
-
-    eDATA_NODE = 1 << 8,
-
-    eMEDIA = 1 << 9,
-
-    eANIMATION = 1 << 10,
-
-    eFILTER = 1 << 11
-  };
-# 414 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual bool IsNodeOfType(uint32_t aFlags) const = 0;
-
-  virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override;
-
-
-
-
-
-  static bool HasBoxQuadsSupport(JSContext* aCx, JSObject* );
-
-protected:
-# 434 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual JSObject* WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) = 0;
-
-public:
-  mozilla::dom::ParentObject GetParentObject() const;
-
-
-
-
-
-
-  virtual nsINode* GetScopeChainParent() const;
-
-
-
-
-  bool IsElement() const {
-    return GetBoolFlag(NodeIsElement);
-  }
-
-
-
-
-
-  mozilla::dom::Element* AsElement();
-  const mozilla::dom::Element* AsElement() const;
-
-
-
-
-
-  nsIContent* AsContent();
-  const nsIContent* AsContent() const
-  {
-    return const_cast<nsINode*>(this)->AsContent();
-  }
-
-
-
-
-
-  mozilla::dom::Text* GetAsText();
-  const mozilla::dom::Text* GetAsText() const;
-
-  virtual nsIDOMNode* AsDOMNode() = 0;
-
-
-
-
-  bool HasChildren() const { return !!mFirstChild; }
-
-
-
-
-
-  virtual uint32_t GetChildCount() const = 0;
-
-
-
-
-
-
-  virtual nsIContent* GetChildAt(uint32_t aIndex) const = 0;
-# 506 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const = 0;
-# 516 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual int32_t IndexOf(const nsINode* aPossibleChild) const = 0;
-# 532 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIDocument *OwnerDoc() const
-  {
-    return mNodeInfo->GetDocument();
-  }
-
-
-
-
-
-  nsINode *OwnerDocAsNode() const;
-
-
-
-
-
-
-  bool IsInUncomposedDoc() const
-  {
-    return GetBoolFlag(IsInDocument);
-  }
-# 560 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIDocument* GetUncomposedDoc() const
-  {
-    return IsInUncomposedDoc() ? OwnerDoc() : nullptr;
-  }
-
-
-
-
-
-
-  nsIDocument* GetComposedDoc() const
-  {
-    return IsInShadowTree() ?
-      GetComposedDocInternal() : GetUncomposedDoc();
-  }
-
-
-
-
-  bool IsInComposedDoc() const
-  {
-    return IsInUncomposedDoc() || (IsInShadowTree() && GetComposedDocInternal());
-  }
-
-
-
-
-
-  uint16_t NodeType() const
-  {
-    return mNodeInfo->NodeType();
-  }
-  const nsString& NodeName() const
-  {
-    return mNodeInfo->NodeName();
-  }
-  const nsString& LocalName() const
-  {
-    return mNodeInfo->LocalName();
-  }
-
-
-
-
-
-  inline mozilla::dom::NodeInfo* NodeInfo() const
-  {
-    return mNodeInfo;
-  }
-
-  inline bool IsInNamespace(int32_t aNamespace) const
-  {
-    return mNodeInfo->NamespaceID() == aNamespace;
-  }
-
-
-
-
-
-  friend std::ostream& operator<<(std::ostream& aStream, const nsINode& aNode);
-
-protected:
-
-
-  inline bool IsNodeInternal() const
-  {
-    return false;
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsNodeInternal(First aFirst, Args... aArgs) const
-  {
-    return mNodeInfo->Equals(aFirst) || IsNodeInternal(aArgs...);
-  }
-
-public:
-  inline bool IsHTMLElement() const
-  {
-    return IsElement() && IsInNamespace(3);
-  }
-
-  inline bool IsHTMLElement(nsIAtom* aTag) const
-  {
-    return IsElement() && mNodeInfo->Equals(aTag, 3);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const
-  {
-    return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsSVGElement() const
-  {
-    return IsElement() && IsInNamespace(10);
-  }
-
-  inline bool IsSVGElement(nsIAtom* aTag) const
-  {
-    return IsElement() && mNodeInfo->Equals(aTag, 10);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const
-  {
-    return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsXULElement() const
-  {
-    return IsElement() && IsInNamespace(9);
-  }
-
-  inline bool IsXULElement(nsIAtom* aTag) const
-  {
-    return IsElement() && mNodeInfo->Equals(aTag, 9);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const
-  {
-    return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsMathMLElement() const
-  {
-    return IsElement() && IsInNamespace(7);
-  }
-
-  inline bool IsMathMLElement(nsIAtom* aTag) const
-  {
-    return IsElement() && mNodeInfo->Equals(aTag, 7);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const
-  {
-    return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-# 720 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
-                                 bool aNotify) = 0;
-# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult AppendChildTo(nsIContent* aKid, bool aNotify)
-  {
-    return InsertChildAt(aKid, GetChildCount(), aNotify);
-  }
-# 757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) = 0;
-# 770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void* GetProperty(nsIAtom *aPropertyName,
-                    nsresult *aStatus = nullptr) const
-  {
-    return GetProperty(0, aPropertyName, aStatus);
-  }
-# 788 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void* GetProperty(uint16_t aCategory, nsIAtom *aPropertyName,
-                    nsresult *aStatus = nullptr) const;
-# 808 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult SetProperty(nsIAtom *aPropertyName, void *aValue,
-                       NSPropertyDtorFunc aDtor = nullptr,
-                       bool aTransfer = false)
-  {
-    return SetProperty(0, aPropertyName, aValue, aDtor, aTransfer);
-  }
-# 834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult SetProperty(uint16_t aCategory,
-                       nsIAtom *aPropertyName, void *aValue,
-                       NSPropertyDtorFunc aDtor = nullptr,
-                       bool aTransfer = false,
-                       void **aOldValue = nullptr);
-
-
-
-
-  template<class T>
-  static void DeleteProperty(void *, nsIAtom *, void *aPropertyValue, void *)
-  {
-    delete static_cast<T *>(aPropertyValue);
-  }
-
-
-
-
-
-
-
-  void DeleteProperty(nsIAtom *aPropertyName)
-  {
-    DeleteProperty(0, aPropertyName);
-  }
-# 867 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void DeleteProperty(uint16_t aCategory, nsIAtom *aPropertyName);
-# 882 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void* UnsetProperty(nsIAtom *aPropertyName,
-                      nsresult *aStatus = nullptr)
-  {
-    return UnsetProperty(0, aPropertyName, aStatus);
-  }
-# 902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void* UnsetProperty(uint16_t aCategory, nsIAtom *aPropertyName,
-                      nsresult *aStatus = nullptr);
-
-  bool HasProperties() const
-  {
-    return HasFlag(NODE_HAS_PROPERTIES);
-  }
-
-
-
-
-
-  nsIPrincipal* NodePrincipal() const {
-    return mNodeInfo->NodeInfoManager()->DocumentPrincipal();
-  }
-
-
-
-
-
-  nsIContent* GetParent() const {
-    return (__builtin_expect(!!(GetBoolFlag(ParentIsContent)), 1)) ?
-      reinterpret_cast<nsIContent*>(mParent) : nullptr;
-  }
-
-
-
-
-
-
-  nsINode* GetParentNode() const
-  {
-    return mParent;
-  }
-# 945 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  inline nsINode* GetFlattenedTreeParentNode() const;
-
-
-
-
-
-
-
-  inline nsINode* GetFlattenedTreeParentNodeForStyle() const;
-
-
-
-
-
-  mozilla::dom::Element* GetParentElement() const
-  {
-    return mParent && mParent->IsElement() ? mParent->AsElement() : nullptr;
-  }
-
-
-
-
-
-  mozilla::dom::Element* GetParentElementCrossingShadowRoot() const;
-
-
-
-
-
-
-  nsINode* SubtreeRoot() const;
-
-
-
-
-
-  nsINode* GetRootNode(const mozilla::dom::GetRootNodeOptions& aOptions);
-
-
-
-
-  virtual nsresult AddEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture, bool wantsUntrusted, uint8_t _argc) override; virtual nsresult AddSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture, bool aWantsUntrusted, uint8_t _argc) override; virtual nsresult RemoveEventListener(const nsAString & type, nsIDOMEventListener *listener, bool useCapture) override; virtual nsresult RemoveSystemEventListener(const nsAString & type, nsIDOMEventListener *listener, bool aUseCapture) override; virtual nsresult DispatchEvent(nsIDOMEvent *evt, bool *_retval) override; virtual mozilla::dom::EventTarget * GetTargetForDOMEvent(void) override; virtual mozilla::dom::EventTarget * GetTargetForEventTargetChain(void) override; virtual nsresult GetEventTargetParent(mozilla::EventChainPreVisitor & aVisitor) override; virtual nsresult WillHandleEvent(mozilla::EventChainPostVisitor & aVisitor) override; virtual nsresult PostHandleEvent(mozilla::EventChainPostVisitor & aVisitor) override; virtual nsresult DispatchDOMEvent(mozilla::WidgetEvent *aEvent, nsIDOMEvent *aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) override; virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv) override;
-
-  virtual mozilla::EventListenerManager*
-    GetExistingListenerManager() const override;
-  virtual mozilla::EventListenerManager*
-    GetOrCreateListenerManager() override;
-
-  using mozilla::dom::EventTarget::RemoveEventListener;
-  using nsIDOMEventTarget::AddEventListener;
-  virtual void AddEventListener(const nsAString& aType,
-                                mozilla::dom::EventListener* aListener,
-                                const mozilla::dom::AddEventListenerOptionsOrBoolean& aOptions,
-                                const mozilla::dom::Nullable<bool>& aWantsUntrusted,
-                                mozilla::ErrorResult& aRv) override;
-  using nsIDOMEventTarget::AddSystemEventListener;
-
-  virtual bool IsApzAware() const override;
-
-  virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() override;
-  virtual nsIGlobalObject* GetOwnerGlobal() const override;
-
-
-
-
-
-
-  bool IsStyledByServo() const;
-
-
-
-
-  inline void UnsetRestyleFlagsIfGecko();
-# 1032 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void AddMutationObserver(nsIMutationObserver* aMutationObserver)
-  {
-    nsSlots* s = Slots();
-    do { } while(0);
-
-
-    s->mMutationObservers.AppendElement(aMutationObserver);
-  }
-# 1048 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void AddMutationObserverUnlessExists(nsIMutationObserver* aMutationObserver)
-  {
-    nsSlots* s = Slots();
-    s->mMutationObservers.AppendElementUnlessExists(aMutationObserver);
-  }
-
-
-
-
-
-
-
-  void AddAnimationObserver(nsIAnimationObserver* aAnimationObserver);
-
-
-
-
-
-  void AddAnimationObserverUnlessExists(nsIAnimationObserver* aAnimationObserver);
-
-
-
-
-  void RemoveMutationObserver(nsIMutationObserver* aMutationObserver)
-  {
-    nsSlots* s = GetExistingSlots();
-    if (s) {
-      s->mMutationObservers.RemoveElement(aMutationObserver);
-    }
-  }
-# 1088 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const = 0;
-
-
-
-  class nsSlots
-  {
-  public:
-    nsSlots();
-
-
-
-    virtual ~nsSlots();
-
-    void Traverse(nsCycleCollectionTraversalCallback &cb);
-    void Unlink();
-
-
-
-
-    nsTObserverArray<nsIMutationObserver*> mMutationObservers;
-
-
-
-
-
-
-    RefPtr<nsChildContentList> mChildNodes;
-
-
-
-
-
-    nsNodeWeakReference* mWeakReference;
-
-
-
-
-
-    uint32_t mEditableDescendantCount;
-  };
-# 1139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void SetFlags(FlagsType aFlagsToSet)
-  {
-    do { } while(0);
-
-
-
-
-
-
-
-    nsWrapperCache::SetFlags(aFlagsToSet);
-  }
-
-  void UnsetFlags(FlagsType aFlagsToUnset)
-  {
-    do { } while(0);
-
-
-
-
-    nsWrapperCache::UnsetFlags(aFlagsToUnset);
-  }
-
-  void ChangeEditableDescendantCount(int32_t aDelta);
-
-
-
-
-
-  uint32_t EditableDescendantCount();
-
-
-
-
-
-
-
-  void ResetEditableDescendantCount();
-
-  void SetEditableFlag(bool aEditable)
-  {
-    if (aEditable) {
-      SetFlags(NODE_IS_EDITABLE);
-    }
-    else {
-      UnsetFlags(NODE_IS_EDITABLE);
-    }
-  }
-
-  bool IsEditable() const
-  {
-
-    return IsEditableInternal();
-
-
-
-  }
-
-
-
-
-
-  bool IsNativeAnonymous() const
-  {
-    return HasFlag(NODE_IS_NATIVE_ANONYMOUS);
-  }
-
-
-
-
-  bool IsInNativeAnonymousSubtree() const
-  {
-
-
-
-
-
-
-
-    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE);
-
-  }
-
-  bool IsInAnonymousSubtree() const;
-
-
-  bool IsAnonymousContentInSVGUseSubtree() const;
-
-
-
-  bool ChromeOnlyAccess() const
-  {
-    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | NODE_CHROME_ONLY_ACCESS);
-  }
-
-  bool IsInShadowTree() const
-  {
-    return HasFlag(NODE_IS_IN_SHADOW_TREE);
-  }
-
-
-
-
-
-
-
-  bool IsSelectionDescendant() const
-  {
-    return IsDescendantOfCommonAncestorForRangeInSelection() ||
-           IsCommonAncestorForRangeInSelection();
-  }
-
-
-
-
-
-
-  nsIContent* GetTextEditorRootContent(nsIEditor** aEditor = nullptr);
-# 1266 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIContent* GetSelectionRootContent(nsIPresShell* aPresShell);
-
-  virtual nsINodeList* ChildNodes();
-  nsIContent* GetFirstChild() const { return mFirstChild; }
-  nsIContent* GetLastChild() const
-  {
-    uint32_t count;
-    nsIContent* const* children = GetChildArray(&count);
-
-    return count > 0 ? children[count - 1] : nullptr;
-  }
-
-
-
-
-
-  nsIDocument* GetOwnerDocument() const;
-
-  void Normalize();
-# 1294 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const = 0;
-  already_AddRefed<nsIURI> GetBaseURIObject() const;
-# 1305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  bool IsNodeApzAware() const
-  {
-    return NodeMayBeApzAware() ? IsNodeApzAwareInternal() : false;
-  }
-# 1318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  virtual bool IsNodeApzAwareInternal() const;
-
-
-
-  virtual bool IsHTMLShadowElement() const { return false; }
-
-
-
-  virtual bool IsHTMLContentElement() const { return false; }
-
-  void GetTextContent(nsAString& aTextContent,
-                      mozilla::OOMReporter& aError)
-  {
-    GetTextContentInternal(aTextContent, aError);
-  }
-  void SetTextContent(const nsAString& aTextContent,
-                      mozilla::ErrorResult& aError)
-  {
-    SetTextContentInternal(aTextContent, aError);
-  }
-
-  mozilla::dom::Element* QuerySelector(const nsAString& aSelector,
-                                       mozilla::ErrorResult& aResult);
-  already_AddRefed<nsINodeList> QuerySelectorAll(const nsAString& aSelector,
-                                                 mozilla::ErrorResult& aResult);
-
-protected:
-
-
-  mozilla::dom::Element* GetElementById(const nsAString& aId);
-# 1361 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult SetUserData(const nsAString& aKey, nsIVariant* aData,
-                       nsIVariant** aResult);
-# 1372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIVariant* GetUserData(const nsAString& aKey);
-
-public:
-  void LookupPrefix(const nsAString& aNamespace, nsAString& aResult);
-  bool IsDefaultNamespace(const nsAString& aNamespaceURI)
-  {
-    nsAutoString defaultNamespace;
-    LookupNamespaceURI(EmptyString(), defaultNamespace);
-    return aNamespaceURI.Equals(defaultNamespace);
-  }
-  void LookupNamespaceURI(const nsAString& aNamespacePrefix,
-                          nsAString& aNamespaceURI);
-
-  nsIContent* GetNextSibling() const { return mNextSibling; }
-  nsIContent* GetPreviousSibling() const { return mPreviousSibling; }
-# 1395 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIContent* GetNextNode(const nsINode* aRoot = nullptr) const
-  {
-    return GetNextNodeImpl(aRoot, false);
-  }
-# 1407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIContent* GetNextNonChildNode(const nsINode* aRoot = nullptr) const
-  {
-    return GetNextNodeImpl(aRoot, true);
-  }
-
-
-
-
-
-
-  bool Contains(const nsINode* aOther) const;
-
-  bool UnoptimizableCCNode() const;
-
-private:
-
-  nsIDocument* GetComposedDocInternal() const;
-
-  nsIContent* GetNextNodeImpl(const nsINode* aRoot,
-                              const bool aSkipChildren) const
-  {
-# 1438 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-    if (!aSkipChildren) {
-      nsIContent* kid = GetFirstChild();
-      if (kid) {
-        return kid;
-      }
-    }
-    if (this == aRoot) {
-      return nullptr;
-    }
-    const nsINode* cur = this;
-    while (1) {
-      nsIContent* next = cur->GetNextSibling();
-      if (next) {
-        return next;
-      }
-      nsINode* parent = cur->GetParentNode();
-      if (parent == aRoot) {
-        return nullptr;
-      }
-      cur = parent;
-    }
-    do { } while(0);
-  }
-
-public:
-# 1471 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsIContent* GetPreviousContent(const nsINode* aRoot = nullptr) const
-  {
-# 1484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-    if (this == aRoot) {
-      return nullptr;
-    }
-    nsIContent* cur = this->GetParent();
-    nsIContent* iter = this->GetPreviousSibling();
-    while (iter) {
-      cur = iter;
-      iter = reinterpret_cast<nsINode*>(iter)->GetLastChild();
-    }
-    return cur;
-  }
-
-
-
-
-private:
-  enum BooleanFlag {
-
-    NodeHasRenderingObservers,
-
-
-    IsInDocument,
-
-    ParentIsContent,
-
-    NodeIsElement,
-
-
-
-    ElementHasID,
-
-    ElementMayHaveClass,
-
-    ElementMayHaveStyle,
-
-    ElementHasName,
-
-    ElementMayHaveContentEditableAttr,
-
-
-    NodeIsCommonAncestorForRangeInSelection,
-
-    NodeIsDescendantOfCommonAncestorForRangeInSelection,
-
-    NodeIsCCMarkedRoot,
-
-    NodeIsCCBlackTree,
-
-
-    NodeIsPurpleRoot,
-
-    ElementHasLockedStyleStates,
-
-    ElementHasPointerLock,
-
-    NodeMayHaveDOMMutationObserver,
-
-    NodeIsContent,
-
-    ElementHasAnimations,
-
-    NodeHasValidDirAttribute,
-
-    NodeHasFixedDir,
-
-
-    NodeHasDirAutoSet,
-
-
-
-    NodeHasTextNodeDirectionalityMap,
-
-    NodeHasDirAuto,
-
-    NodeAncestorHasDirAuto,
-
-
-    ElementIsInStyleScope,
-
-    ElementIsScopedStyleRoot,
-
-    NodeHandlingClick,
-
-    NodeHasRelevantHoverRules,
-
-
-    ElementHasWeirdParserInsertionMode,
-
-    ParserHasNotified,
-
-    MayBeApzAware,
-
-    BooleanFlagCount
-  };
-
-  void SetBoolFlag(BooleanFlag name, bool value) {
-    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
-                  "Too many boolean flags");
-    mBoolFlags = (mBoolFlags & ~(1 << name)) | (value << name);
-  }
-
-  void SetBoolFlag(BooleanFlag name) {
-    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
-                  "Too many boolean flags");
-    mBoolFlags |= (1 << name);
-  }
-
-  void ClearBoolFlag(BooleanFlag name) {
-    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
-                  "Too many boolean flags");
-    mBoolFlags &= ~(1 << name);
-  }
-
-  bool GetBoolFlag(BooleanFlag name) const {
-    static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
-                  "Too many boolean flags");
-    return mBoolFlags & (1 << name);
-  }
-
-public:
-  bool HasRenderingObservers() const
-    { return GetBoolFlag(NodeHasRenderingObservers); }
-  void SetHasRenderingObservers(bool aValue)
-    { SetBoolFlag(NodeHasRenderingObservers, aValue); }
-  bool IsContent() const { return GetBoolFlag(NodeIsContent); }
-  bool HasID() const { return GetBoolFlag(ElementHasID); }
-  bool MayHaveClass() const { return GetBoolFlag(ElementMayHaveClass); }
-  void SetMayHaveClass() { SetBoolFlag(ElementMayHaveClass); }
-  bool MayHaveStyle() const { return GetBoolFlag(ElementMayHaveStyle); }
-  bool HasName() const { return GetBoolFlag(ElementHasName); }
-  bool MayHaveContentEditableAttr() const
-    { return GetBoolFlag(ElementMayHaveContentEditableAttr); }
-  bool IsCommonAncestorForRangeInSelection() const
-    { return GetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
-  void SetCommonAncestorForRangeInSelection()
-    { SetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
-  void ClearCommonAncestorForRangeInSelection()
-    { ClearBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
-  bool IsDescendantOfCommonAncestorForRangeInSelection() const
-    { return GetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
-  void SetDescendantOfCommonAncestorForRangeInSelection()
-    { SetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
-  void ClearDescendantOfCommonAncestorForRangeInSelection()
-    { ClearBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
-
-  void SetCCMarkedRoot(bool aValue)
-    { SetBoolFlag(NodeIsCCMarkedRoot, aValue); }
-  bool CCMarkedRoot() const { return GetBoolFlag(NodeIsCCMarkedRoot); }
-  void SetInCCBlackTree(bool aValue)
-    { SetBoolFlag(NodeIsCCBlackTree, aValue); }
-  bool InCCBlackTree() const { return GetBoolFlag(NodeIsCCBlackTree); }
-  void SetIsPurpleRoot(bool aValue)
-    { SetBoolFlag(NodeIsPurpleRoot, aValue); }
-  bool IsPurpleRoot() const { return GetBoolFlag(NodeIsPurpleRoot); }
-  bool MayHaveDOMMutationObserver()
-    { return GetBoolFlag(NodeMayHaveDOMMutationObserver); }
-  void SetMayHaveDOMMutationObserver()
-    { SetBoolFlag(NodeMayHaveDOMMutationObserver, true); }
-  bool HasListenerManager() { return HasFlag(NODE_HAS_LISTENERMANAGER); }
-  bool HasPointerLock() const { return GetBoolFlag(ElementHasPointerLock); }
-  void SetPointerLock() { SetBoolFlag(ElementHasPointerLock); }
-  void ClearPointerLock() { ClearBoolFlag(ElementHasPointerLock); }
-  bool MayHaveAnimations() const { return GetBoolFlag(ElementHasAnimations); }
-  void SetMayHaveAnimations() { SetBoolFlag(ElementHasAnimations); }
-  void SetHasValidDir() { SetBoolFlag(NodeHasValidDirAttribute); }
-  void ClearHasValidDir() { ClearBoolFlag(NodeHasValidDirAttribute); }
-  bool HasValidDir() const { return GetBoolFlag(NodeHasValidDirAttribute); }
-  void SetHasFixedDir() {
-    do { } while (0);
-
-    SetBoolFlag(NodeHasFixedDir);
-  }
-  void ClearHasFixedDir() {
-    do { } while (0);
-
-    ClearBoolFlag(NodeHasFixedDir);
-  }
-  bool HasFixedDir() const { return GetBoolFlag(NodeHasFixedDir); }
-  void SetHasDirAutoSet() {
-    do { } while (0);
-
-    SetBoolFlag(NodeHasDirAutoSet);
-  }
-  void ClearHasDirAutoSet() {
-    do { } while (0);
-
-    ClearBoolFlag(NodeHasDirAutoSet);
-  }
-  bool HasDirAutoSet() const
-    { return GetBoolFlag(NodeHasDirAutoSet); }
-  void SetHasTextNodeDirectionalityMap() {
-    do { } while (0);
-
-    SetBoolFlag(NodeHasTextNodeDirectionalityMap);
-  }
-  void ClearHasTextNodeDirectionalityMap() {
-    do { } while (0);
-
-    ClearBoolFlag(NodeHasTextNodeDirectionalityMap);
-  }
-  bool HasTextNodeDirectionalityMap() const {
-    do { } while (0);
-
-    return GetBoolFlag(NodeHasTextNodeDirectionalityMap);
-  }
-
-  void SetHasDirAuto() { SetBoolFlag(NodeHasDirAuto); }
-  void ClearHasDirAuto() { ClearBoolFlag(NodeHasDirAuto); }
-  bool HasDirAuto() const { return GetBoolFlag(NodeHasDirAuto); }
-
-  void SetAncestorHasDirAuto() { SetBoolFlag(NodeAncestorHasDirAuto); }
-  void ClearAncestorHasDirAuto() { ClearBoolFlag(NodeAncestorHasDirAuto); }
-  bool AncestorHasDirAuto() const { return GetBoolFlag(NodeAncestorHasDirAuto); }
-
-  bool NodeOrAncestorHasDirAuto() const
-    { return HasDirAuto() || AncestorHasDirAuto(); }
-
-  void SetIsElementInStyleScope(bool aValue) {
-    do { } while (0);
-    SetBoolFlag(ElementIsInStyleScope, aValue);
-  }
-  void SetIsElementInStyleScope() {
-    do { } while (0);
-    SetBoolFlag(ElementIsInStyleScope);
-  }
-  void ClearIsElementInStyleScope() {
-    do { } while (0);
-    ClearBoolFlag(ElementIsInStyleScope);
-  }
-  bool IsElementInStyleScope() const { return GetBoolFlag(ElementIsInStyleScope); }
-
-  void SetIsScopedStyleRoot() { SetBoolFlag(ElementIsScopedStyleRoot); }
-  void ClearIsScopedStyleRoot() { ClearBoolFlag(ElementIsScopedStyleRoot); }
-  bool IsScopedStyleRoot() { return GetBoolFlag(ElementIsScopedStyleRoot); }
-  bool HasRelevantHoverRules() const { return GetBoolFlag(NodeHasRelevantHoverRules); }
-  void SetHasRelevantHoverRules() { SetBoolFlag(NodeHasRelevantHoverRules); }
-  void SetParserHasNotified() { SetBoolFlag(ParserHasNotified); };
-  bool HasParserNotified() { return GetBoolFlag(ParserHasNotified); }
-
-  void SetMayBeApzAware() { SetBoolFlag(MayBeApzAware); }
-  bool NodeMayBeApzAware() const
-  {
-    return GetBoolFlag(MayBeApzAware);
-  }
-protected:
-  void SetParentIsContent(bool aValue) { SetBoolFlag(ParentIsContent, aValue); }
-  void SetIsInDocument() { SetBoolFlag(IsInDocument); }
-  void SetNodeIsContent() { SetBoolFlag(NodeIsContent); }
-  void ClearInDocument() { ClearBoolFlag(IsInDocument); }
-  void SetIsElement() { SetBoolFlag(NodeIsElement); }
-  void SetHasID() { SetBoolFlag(ElementHasID); }
-  void ClearHasID() { ClearBoolFlag(ElementHasID); }
-  void SetMayHaveStyle() { SetBoolFlag(ElementMayHaveStyle); }
-  void SetHasName() { SetBoolFlag(ElementHasName); }
-  void ClearHasName() { ClearBoolFlag(ElementHasName); }
-  void SetMayHaveContentEditableAttr()
-    { SetBoolFlag(ElementMayHaveContentEditableAttr); }
-  void SetHasLockedStyleStates() { SetBoolFlag(ElementHasLockedStyleStates); }
-  void ClearHasLockedStyleStates() { ClearBoolFlag(ElementHasLockedStyleStates); }
-  bool HasLockedStyleStates() const
-    { return GetBoolFlag(ElementHasLockedStyleStates); }
-  void SetHasWeirdParserInsertionMode() { SetBoolFlag(ElementHasWeirdParserInsertionMode); }
-  bool HasWeirdParserInsertionMode() const
-  { return GetBoolFlag(ElementHasWeirdParserInsertionMode); }
-  bool HandlingClick() const { return GetBoolFlag(NodeHandlingClick); }
-  void SetHandlingClick() { SetBoolFlag(NodeHandlingClick); }
-  void ClearHandlingClick() { ClearBoolFlag(NodeHandlingClick); }
-
-  void SetSubtreeRootPointer(nsINode* aSubtreeRoot)
-  {
-    do { } while(0);
-    do { } while(0);
-
-    mSubtreeRoot = aSubtreeRoot;
-  }
-
-  void ClearSubtreeRootPointer()
-  {
-    mSubtreeRoot = nullptr;
-  }
-
-public:
-
-  void BindObject(nsISupports* aObject);
-
-
-  void UnbindObject(nsISupports* aObject);
-
-  void GetBoundMutationObservers(nsTArray<RefPtr<nsDOMMutationObserver> >& aResult);
-
-  already_AddRefed<mozilla::dom::AccessibleNode> GetAccessibleNode();
-
-
-
-
-
-  uint32_t Length() const;
-
-  void GetNodeName(mozilla::dom::DOMString& aNodeName)
-  {
-    const nsString& nodeName = NodeName();
-    aNodeName.SetStringBuffer(nsStringBuffer::FromString(nodeName),
-                              nodeName.Length());
-  }
-  __attribute__ ((warn_unused_result)) nsresult GetBaseURI(nsAString& aBaseURI) const;
-
-
-
-
-  void GetBaseURIFromJS(nsAString& aBaseURI,
-                        CallerType aCallerType,
-                        ErrorResult& aRv) const;
-  bool HasChildNodes() const
-  {
-    return HasChildren();
-  }
-  uint16_t CompareDocumentPosition(nsINode& aOther) const;
-  void GetNodeValue(nsAString& aNodeValue)
-  {
-    GetNodeValueInternal(aNodeValue);
-  }
-  void SetNodeValue(const nsAString& aNodeValue,
-                    mozilla::ErrorResult& aError)
-  {
-    SetNodeValueInternal(aNodeValue, aError);
-  }
-  virtual void GetNodeValueInternal(nsAString& aNodeValue);
-  virtual void SetNodeValueInternal(const nsAString& aNodeValue,
-                                    mozilla::ErrorResult& aError)
-  {
-
-
-  }
-  void EnsurePreInsertionValidity(nsINode& aNewChild, nsINode* aRefChild,
-                                  mozilla::ErrorResult& aError);
-  nsINode* InsertBefore(nsINode& aNode, nsINode* aChild,
-                        mozilla::ErrorResult& aError)
-  {
-    return ReplaceOrInsertBefore(false, &aNode, aChild, aError);
-  }
-  nsINode* AppendChild(nsINode& aNode, mozilla::ErrorResult& aError)
-  {
-    return InsertBefore(aNode, nullptr, aError);
-  }
-  nsINode* ReplaceChild(nsINode& aNode, nsINode& aChild,
-                        mozilla::ErrorResult& aError)
-  {
-    return ReplaceOrInsertBefore(true, &aNode, &aChild, aError);
-  }
-  nsINode* RemoveChild(nsINode& aChild, mozilla::ErrorResult& aError);
-  already_AddRefed<nsINode> CloneNode(bool aDeep, mozilla::ErrorResult& aError);
-  bool IsSameNode(nsINode* aNode);
-  bool IsEqualNode(nsINode* aNode);
-  void GetNamespaceURI(nsAString& aNamespaceURI) const
-  {
-    mNodeInfo->GetNamespaceURI(aNamespaceURI);
-  }
-
-  void GetPrefix(nsAString& aPrefix)
-  {
-    mNodeInfo->GetPrefix(aPrefix);
-  }
-
-  void GetLocalName(mozilla::dom::DOMString& aLocalName) const
-  {
-    const nsString& localName = LocalName();
-    if (localName.IsVoid()) {
-      aLocalName.SetNull();
-    } else {
-      aLocalName.SetStringBuffer(nsStringBuffer::FromString(localName),
-                                 localName.Length());
-    }
-  }
-
-  nsDOMAttributeMap* GetAttributes();
-  void SetUserData(JSContext* aCx, const nsAString& aKey,
-                   JS::Handle<JS::Value> aData,
-                   JS::MutableHandle<JS::Value> aRetval,
-                   mozilla::ErrorResult& aError);
-  void GetUserData(JSContext* aCx, const nsAString& aKey,
-                   JS::MutableHandle<JS::Value> aRetval,
-                   mozilla::ErrorResult& aError);
-
-
-
-
-  nsresult RemoveFromParent()
-  {
-    nsINode* parent = GetParentNode();
-    mozilla::ErrorResult rv;
-    parent->RemoveChild(*this, rv);
-    return rv.StealNSResult();
-  }
-
-
-  mozilla::dom::Element* GetPreviousElementSibling() const;
-  mozilla::dom::Element* GetNextElementSibling() const;
-
-  void Before(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
-  void After(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
-  void ReplaceWith(const Sequence<OwningNodeOrString>& aNodes,
-                   ErrorResult& aRv);
-
-
-
-  void Remove();
-
-
-  mozilla::dom::Element* GetFirstElementChild() const;
-  mozilla::dom::Element* GetLastElementChild() const;
-
-  void Prepend(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
-  void Append(const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
-
-  void GetBoxQuads(const BoxQuadOptions& aOptions,
-                   nsTArray<RefPtr<DOMQuad> >& aResult,
-                   CallerType aCallerType,
-                   ErrorResult& aRv);
-
-  already_AddRefed<DOMQuad> ConvertQuadFromNode(DOMQuad& aQuad,
-                                                const TextOrElementOrDocument& aFrom,
-                                                const ConvertCoordinateOptions& aOptions,
-                                                CallerType aCallerType,
-                                                ErrorResult& aRv);
-  already_AddRefed<DOMQuad> ConvertRectFromNode(DOMRectReadOnly& aRect,
-                                                const TextOrElementOrDocument& aFrom,
-                                                const ConvertCoordinateOptions& aOptions,
-                                                CallerType aCallerType,
-                                                ErrorResult& aRv);
-  already_AddRefed<DOMPoint> ConvertPointFromNode(const DOMPointInit& aPoint,
-                                                  const TextOrElementOrDocument& aFrom,
-                                                  const ConvertCoordinateOptions& aOptions,
-                                                  CallerType aCallerType,
-                                                  ErrorResult& aRv);
-
-protected:
-
-
-
-  virtual nsINode::nsSlots* CreateSlots();
-
-  bool HasSlots() const
-  {
-    return mSlots != nullptr;
-  }
-
-  nsSlots* GetExistingSlots() const
-  {
-    return mSlots;
-  }
-
-  nsSlots* Slots()
-  {
-    if (!HasSlots()) {
-      mSlots = CreateSlots();
-      do { } while (0);
-    }
-    return GetExistingSlots();
-  }
-
-  nsTObserverArray<nsIMutationObserver*> *GetMutationObservers()
-  {
-    return HasSlots() ? &GetExistingSlots()->mMutationObservers : nullptr;
-  }
-
-  bool IsEditableInternal() const;
-  virtual bool IsEditableExternal() const
-  {
-    return IsEditableInternal();
-  }
-
-  virtual void GetTextContentInternal(nsAString& aTextContent,
-                                      mozilla::OOMReporter& aError);
-  virtual void SetTextContentInternal(const nsAString& aTextContent,
-                                      mozilla::ErrorResult& aError)
-  {
-  }
-# 1970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult GetParentNode(nsIDOMNode** aParentNode);
-  nsresult GetChildNodes(nsIDOMNodeList** aChildNodes);
-  nsresult GetFirstChild(nsIDOMNode** aFirstChild);
-  nsresult GetLastChild(nsIDOMNode** aLastChild);
-  nsresult GetPreviousSibling(nsIDOMNode** aPrevSibling);
-  nsresult GetNextSibling(nsIDOMNode** aNextSibling);
-  nsresult GetOwnerDocument(nsIDOMDocument** aOwnerDocument);
-
-  void EnsurePreInsertionValidity1(nsINode& aNewChild, nsINode* aRefChild,
-                                   mozilla::ErrorResult& aError);
-  void EnsurePreInsertionValidity2(bool aReplace, nsINode& aNewChild,
-                                   nsINode* aRefChild,
-                                   mozilla::ErrorResult& aError);
-  nsINode* ReplaceOrInsertBefore(bool aReplace, nsINode* aNewChild,
-                                 nsINode* aRefChild,
-                                 mozilla::ErrorResult& aError);
-  nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn);
-
-
-
-
-
-
-
-  virtual mozilla::dom::Element* GetNameSpaceElement() = 0;
-# 2007 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  void doRemoveChildAt(uint32_t aIndex, bool aNotify, nsIContent* aKid,
-                       nsAttrAndChildArray& aChildArray);
-# 2020 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsresult doInsertChildAt(nsIContent* aKid, uint32_t aIndex,
-                           bool aNotify, nsAttrAndChildArray& aChildArray);
-# 2031 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-  nsCSSSelectorList* ParseSelectorList(const nsAString& aSelectorString,
-                                       mozilla::ErrorResult& aRv);
-
-public:
-# 2048 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h" 1
-# 151 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
-mozilla::dom::EventHandlerNonNull* GetOnabort(); void SetOnabort(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOncanplay(); void SetOncanplay(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOncanplaythrough(); void SetOncanplaythrough(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnchange(); void SetOnchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnauxclick(); void SetOnauxclick(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnclick(); void SetOnclick(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnclose(); void SetOnclose(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOncontextmenu(); void SetOncontextmenu(mozilla::dom::EventHandlerNonNull* listener);
-# 189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
-mozilla::dom::EventHandlerNonNull* GetOndblclick(); void SetOndblclick(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndrag(); void SetOndrag(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragend(); void SetOndragend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragenter(); void SetOndragenter(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragexit(); void SetOndragexit(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragleave(); void SetOndragleave(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragover(); void SetOndragover(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndragstart(); void SetOndragstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndrop(); void SetOndrop(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOndurationchange(); void SetOndurationchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnemptied(); void SetOnemptied(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnended(); void SetOnended(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnfullscreenchange(); void SetOnfullscreenchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnfullscreenerror(); void SetOnfullscreenerror(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOninput(); void SetOninput(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOninvalid(); void SetOninvalid(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnkeydown(); void SetOnkeydown(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnkeypress(); void SetOnkeypress(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnkeyup(); void SetOnkeyup(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozkeydownonplugin(); void SetOnmozkeydownonplugin(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozkeyuponplugin(); void SetOnmozkeyuponplugin(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnloadeddata(); void SetOnloadeddata(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnloadedmetadata(); void SetOnloadedmetadata(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnloadend(); void SetOnloadend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnloadstart(); void SetOnloadstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmousedown(); void SetOnmousedown(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmouseenter(); void SetOnmouseenter(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmouseleave(); void SetOnmouseleave(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmousemove(); void SetOnmousemove(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmouseout(); void SetOnmouseout(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmouseover(); void SetOnmouseover(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmouseup(); void SetOnmouseup(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozfullscreenchange(); void SetOnmozfullscreenchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozfullscreenerror(); void SetOnmozfullscreenerror(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozpointerlockchange(); void SetOnmozpointerlockchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnmozpointerlockerror(); void SetOnmozpointerlockerror(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerlockchange(); void SetOnpointerlockchange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerlockerror(); void SetOnpointerlockerror(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerdown(); void SetOnpointerdown(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointermove(); void SetOnpointermove(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerup(); void SetOnpointerup(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointercancel(); void SetOnpointercancel(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerover(); void SetOnpointerover(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerout(); void SetOnpointerout(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerenter(); void SetOnpointerenter(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpointerleave(); void SetOnpointerleave(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOngotpointercapture(); void SetOngotpointercapture(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnlostpointercapture(); void SetOnlostpointercapture(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnselectstart(); void SetOnselectstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpause(); void SetOnpause(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnplay(); void SetOnplay(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnplaying(); void SetOnplaying(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnprogress(); void SetOnprogress(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnratechange(); void SetOnratechange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnreset(); void SetOnreset(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnseeked(); void SetOnseeked(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnseeking(); void SetOnseeking(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnselect(); void SetOnselect(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnshow(); void SetOnshow(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnstalled(); void SetOnstalled(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnsubmit(); void SetOnsubmit(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnsuspend(); void SetOnsuspend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntimeupdate(); void SetOntimeupdate(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntoggle(); void SetOntoggle(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnvolumechange(); void SetOnvolumechange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwaiting(); void SetOnwaiting(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwheel(); void SetOnwheel(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOncopy(); void SetOncopy(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOncut(); void SetOncut(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnpaste(); void SetOnpaste(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnbeforescriptexecute(); void SetOnbeforescriptexecute(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnafterscriptexecute(); void SetOnafterscriptexecute(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnblur(); void SetOnblur(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnerror(); void SetOnerror(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnfocus(); void SetOnfocus(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnfocusin(); void SetOnfocusin(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnfocusout(); void SetOnfocusout(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnload(); void SetOnload(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnresize(); void SetOnresize(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnscroll(); void SetOnscroll(mozilla::dom::EventHandlerNonNull* listener);
-# 652 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
-mozilla::dom::EventHandlerNonNull* GetOntouchstart(); void SetOntouchstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntouchend(); void SetOntouchend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntouchmove(); void SetOntouchmove(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntouchcancel(); void SetOntouchcancel(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnreadystatechange(); void SetOnreadystatechange(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnselectionchange(); void SetOnselectionchange(mozilla::dom::EventHandlerNonNull* listener);
-# 970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EventNameList.h"
-mozilla::dom::EventHandlerNonNull* GetOntransitionstart(); void SetOntransitionstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntransitionrun(); void SetOntransitionrun(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntransitionend(); void SetOntransitionend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOntransitioncancel(); void SetOntransitioncancel(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnanimationstart(); void SetOnanimationstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnanimationend(); void SetOnanimationend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnanimationiteration(); void SetOnanimationiteration(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnanimationcancel(); void SetOnanimationcancel(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationEnd(); void SetOnwebkitAnimationEnd(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationIteration(); void SetOnwebkitAnimationIteration(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitAnimationStart(); void SetOnwebkitAnimationStart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitTransitionEnd(); void SetOnwebkitTransitionEnd(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationend(); void SetOnwebkitanimationend(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationiteration(); void SetOnwebkitanimationiteration(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkitanimationstart(); void SetOnwebkitanimationstart(mozilla::dom::EventHandlerNonNull* listener);
-
-
-
-mozilla::dom::EventHandlerNonNull* GetOnwebkittransitionend(); void SetOnwebkittransitionend(mozilla::dom::EventHandlerNonNull* listener);
-# 2049 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINode.h" 2
-
-
-
-
-protected:
-  static bool Traverse(nsINode *tmp, nsCycleCollectionTraversalCallback &cb);
-  static void Unlink(nsINode *tmp);
-
-  RefPtr<mozilla::dom::NodeInfo> mNodeInfo;
-
-
-
-
-  nsINode* mParent;
-
-private:
-
-  uint32_t mBoolFlags;
-
-protected:
-
-
-  nsIContent* mNextSibling;
-  nsIContent* mPreviousSibling;
-
-
-
-  nsIContent* mFirstChild;
-
-  union {
-
-    nsIFrame* mPrimaryFrame;
-
-
-
-
-    nsINode* mSubtreeRoot;
-  };
-
-
-  nsSlots* mSlots;
-};
-
-inline nsIDOMNode* GetAsDOMNode(nsINode* aNode)
-{
-  return aNode ? aNode->AsDOMNode() : nullptr;
-}
-
-
-
-
-
-
-template<class C, class D>
-inline nsINode* NODE_FROM(C& aContent, D& aDocument)
-{
-  if (aContent)
-    return static_cast<nsINode*>(aContent);
-  return static_cast<nsINode*>(aDocument);
-}
-
-template<typename T> struct nsINode::COMTypeInfo<nsINode, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINode::COMTypeInfo<nsINode, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x70ba4547, 0x7699, 0x44fc, { 0xb3, 0x20, 0x52, 0xdb, 0xe3, 0xd1, 0xf9, 0x0a } };
-
-inline nsISupports*
-ToSupports(nsINode* aPointer)
-{
-  return aPointer;
-}
-
-inline nsISupports*
-ToCanonicalSupports(nsINode* aPointer)
-{
-  return aPointer;
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h" 2
-
-
-class nsAString;
-class nsIAtom;
-class nsIURI;
-class nsRuleWalker;
-class nsAttrValue;
-class nsAttrName;
-class nsTextFragment;
-class nsIFrame;
-class nsXBLBinding;
-
-namespace mozilla {
-class EventChainPreVisitor;
-namespace dom {
-class ShadowRoot;
-}
-namespace widget {
-struct IMEState;
-}
-}
-
-enum nsLinkState {
-  eLinkState_Unvisited = 1,
-  eLinkState_Visited = 2,
-  eLinkState_NotLink = 3
-};
-# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-class nsIContent : public nsINode {
-public:
-  typedef mozilla::widget::IMEState IMEState;
-
-
-
-
-
-  explicit nsIContent(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
-    : nsINode(aNodeInfo)
-  {
-    do { } while (0);
-    SetNodeIsContent();
-  }
-
-
-  template<typename T, typename U> struct COMTypeInfo;
-# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
-                              nsIContent* aBindingParent,
-                              bool aCompileEventHandlers) = 0;
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual void UnbindFromTree(bool aDeep = true,
-                              bool aNullParent = true) = 0;
-
-  enum {
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-    eAllChildren = 0,
-# 141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-    eAllButXBL = 1,
-
-
-
-
-
-    eSkipPlaceholderContent = 2,
-
-
-
-
-
-
-    eSkipDocumentLevelNativeAnonymousContent = 4,
-  };
-# 167 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) = 0;
-
-
-
-
-
-
-  bool IsRootOfNativeAnonymousSubtree() const
-  {
-    do { } while(0);
-
-
-
-    return HasFlag(NODE_IS_NATIVE_ANONYMOUS_ROOT);
-  }
-
-  bool IsRootOfChromeAccessOnlySubtree() const
-  {
-    return HasFlag(NODE_IS_NATIVE_ANONYMOUS_ROOT |
-                   NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS);
-  }
-
-
-
-
-
-  void SetIsNativeAnonymousRoot()
-  {
-    SetFlags(NODE_IS_ANONYMOUS_ROOT | NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
-             NODE_IS_NATIVE_ANONYMOUS_ROOT | NODE_IS_NATIVE_ANONYMOUS);
-  }
-
-
-
-
-
-  virtual nsIContent* FindFirstNonChromeOnlyAccessContent() const;
-
-
-
-
-
-  bool IsRootOfAnonymousSubtree() const
-  {
-    do { } while(0);
-
-
-
-    do { } while(0);
-# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-    return HasFlag(NODE_IS_ANONYMOUS_ROOT);
-  }
-
-
-
-
-
-
-  bool IsInAnonymousSubtree() const
-  {
-    do { } while(0);
-
-
-
-
-    return IsInNativeAnonymousSubtree() || (!IsInShadowTree() && GetBindingParent() != nullptr);
-  }
-
-
-
-
-
-  inline bool IsInHTMLDocument() const;
-
-
-
-
-
-  virtual bool IsInChromeDocument() const;
-
-
-
-
-
-  inline int32_t GetNameSpaceID() const
-  {
-    return mNodeInfo->NamespaceID();
-  }
-
-  inline bool IsHTMLElement() const
-  {
-    return IsInNamespace(3);
-  }
-
-  inline bool IsHTMLElement(nsIAtom* aTag) const
-  {
-    return mNodeInfo->Equals(aTag, 3);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const
-  {
-    return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsSVGElement() const
-  {
-    return IsInNamespace(10);
-  }
-
-  inline bool IsSVGElement(nsIAtom* aTag) const
-  {
-    return mNodeInfo->Equals(aTag, 10);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const
-  {
-    return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsXULElement() const
-  {
-    return IsInNamespace(9);
-  }
-
-  inline bool IsXULElement(nsIAtom* aTag) const
-  {
-    return mNodeInfo->Equals(aTag, 9);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const
-  {
-    return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-
-  inline bool IsMathMLElement() const
-  {
-    return IsInNamespace(7);
-  }
-
-  inline bool IsMathMLElement(nsIAtom* aTag) const
-  {
-    return mNodeInfo->Equals(aTag, 7);
-  }
-
-  template<typename First, typename... Args>
-  inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const
-  {
-    return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
-  }
-  inline bool IsActiveChildrenElement() const
-  {
-    return mNodeInfo->Equals(nsGkAtoms::children, 6) &&
-           GetBindingParent();
-  }
-
-  bool IsGeneratedContentContainerForBefore() const
-  {
-    return IsRootOfNativeAnonymousSubtree() &&
-           mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore;
-  }
-
-  bool IsGeneratedContentContainerForAfter() const
-  {
-    return IsRootOfNativeAnonymousSubtree() &&
-           mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentafter;
-  }
-# 361 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-                   const nsAString& aValue, bool aNotify)
-  {
-    return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
-  }
-# 381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-                           nsIAtom* aPrefix, const nsAString& aValue,
-                           bool aNotify) = 0;
-# 395 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-               nsAString& aResult) const;
-# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  bool HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const;
-# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  bool AttrValueIs(int32_t aNameSpaceID,
-                   nsIAtom* aName,
-                   const nsAString& aValue,
-                   nsCaseTreatment aCaseSensitive) const;
-# 432 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  bool AttrValueIs(int32_t aNameSpaceID,
-                   nsIAtom* aName,
-                   nsIAtom* aValue,
-                   nsCaseTreatment aCaseSensitive) const;
-
-  enum {
-    ATTR_MISSING = -1,
-    ATTR_VALUE_NO_MATCH = -2
-  };
-# 458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  typedef nsIAtom* const* const AttrValuesArray;
-  virtual int32_t FindAttrValueIn(int32_t aNameSpaceID,
-                                  nsIAtom* aName,
-                                  AttrValuesArray* aValues,
-                                  nsCaseTreatment aCaseSensitive) const
-  {
-    return ATTR_MISSING;
-  }
-# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttr,
-                             bool aNotify) = 0;
-# 490 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const = 0;
-
-
-
-
-  virtual mozilla::dom::BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const = 0;
-
-
-
-
-
-
-  virtual uint32_t GetAttrCount() const = 0;
-
-
-
-
-
-
-  virtual const nsTextFragment *GetText() = 0;
-
-
-
-
-
-  virtual uint32_t TextLength() const = 0;
-# 524 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual bool IsEventAttributeName(nsIAtom* aName)
-  {
-    return false;
-  }
-
-
-
-
-
-
-  virtual nsresult SetText(const char16_t* aBuffer, uint32_t aLength,
-                           bool aNotify) = 0;
-
-
-
-
-
-
-  virtual nsresult AppendText(const char16_t* aBuffer, uint32_t aLength,
-                              bool aNotify) = 0;
-
-
-
-
-
-
-  nsresult SetText(const nsAString& aStr, bool aNotify)
-  {
-    return SetText(aStr.BeginReading(), aStr.Length(), aNotify);
-  }
-
-
-
-
-
-  virtual bool TextIsOnlyWhitespace() = 0;
-
-
-
-
-  virtual bool ThreadSafeTextIsOnlyWhitespace() const = 0;
-
-
-
-
-
-
-
-  virtual bool HasTextForTranslation() = 0;
-
-
-
-
-
-  virtual void AppendTextTo(nsAString& aResult) = 0;
-
-
-
-
-
-  __attribute__ ((warn_unused_result))
-  virtual bool AppendTextTo(nsAString& aResult, const mozilla::fallible_t&) = 0;
-# 609 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  bool IsFocusable(int32_t* aTabIndex = nullptr, bool aWithMouse = false);
-  virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse);
-# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual bool PerformAccesskey(bool aKeyCausesActivation,
-                                bool aIsTrustedEvent)
-  {
-    return false;
-  }
-# 642 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual IMEState GetDesiredIMEState();
-# 654 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual nsIContent *GetBindingParent() const = 0;
-
-
-
-
-
-
-  virtual nsXBLBinding *GetXBLBinding() const = 0;
-# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual void SetXBLBinding(nsXBLBinding* aBinding,
-                             nsBindingManager* aOldBindingManager = nullptr) = 0;
-
-
-
-
-
-
-
-  virtual void SetShadowRoot(mozilla::dom::ShadowRoot* aShadowRoot) = 0;
-
-
-
-
-
-
-  inline mozilla::dom::ShadowRoot *GetShadowRoot() const;
-# 701 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual mozilla::dom::ShadowRoot *GetContainingShadow() const = 0;
-
-
-
-
-
-
-  virtual nsTArray<nsIContent*> &DestInsertionPoints() = 0;
-
-
-
-
-
-
-  virtual nsTArray<nsIContent*> *GetExistingDestInsertionPoints() const = 0;
-
-
-
-
-
-
-
-  virtual nsIContent *GetXBLInsertionParent() const = 0;
-
-
-
-
-
-
-  virtual void SetXBLInsertionParent(nsIContent* aContent) = 0;
-
-
-
-
-
-  inline nsIContent *GetFlattenedTreeParent() const;
-
-
-  enum FlattenedParentType { eNotForStyle, eForStyle };
-  nsINode* GetFlattenedTreeParentNodeInternal(FlattenedParentType aType) const;
-# 755 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual bool IsLink(nsIURI** aURI) const = 0;
-# 764 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual already_AddRefed<nsIURI> GetHrefURI() const
-  {
-    return nullptr;
-  }
-# 796 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual void DoneCreatingElement()
-  {
-  }
-
-
-
-
-
-
-
-  virtual void BeginAddingChildren()
-  {
-  }
-# 829 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual void DoneAddingChildren(bool aHaveNotified)
-  {
-  }
-# 842 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual bool IsDoneAddingChildren()
-  {
-    return true;
-  }
-
-
-
-
-
-  nsIAtom* GetID() const {
-    if (HasID()) {
-      return DoGetID();
-    }
-    return nullptr;
-  }
-
-
-
-
-
-  virtual nsresult WalkContentStyleRules(nsRuleWalker* aRuleWalker) = 0;
-
-
-
-
-
-
-
-  virtual void UpdateEditableState(bool aNotify);
-
-
-
-
-
-  virtual void DestroyContent()
-  {
-  }
-
-
-
-
-  virtual void SaveSubtreeState() = 0;
-# 896 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  nsIFrame* GetPrimaryFrame() const
-  {
-    return (IsInUncomposedDoc() || IsInShadowTree()) ? mPrimaryFrame : nullptr;
-  }
-  void SetPrimaryFrame(nsIFrame* aFrame) {
-    do { } while (0);
-    do { } while(0);
-
-    mPrimaryFrame = aFrame;
-  }
-
-  nsresult LookupNamespaceURIInternal(const nsAString& aNamespacePrefix,
-                                      nsAString& aNamespaceURI) const;
-
-
-
-
-
-  bool HasIndependentSelection();
-
-
-
-
-
-
-  mozilla::dom::Element* GetEditingHost();
-
-
-
-
-
-
-  bool GetLang(nsAString& aResult) const {
-    for (const nsIContent* content = this; content; content = content->GetParent()) {
-      if (content->GetAttrCount() > 0) {
-
-
-        bool hasAttr = content->GetAttr(2, nsGkAtoms::lang,
-                                          aResult);
-        if (!hasAttr && (content->IsHTMLElement() || content->IsSVGElement() ||
-            content->IsXULElement())) {
-          hasAttr = content->GetAttr(kNameSpaceID_None, nsGkAtoms::lang,
-                                     aResult);
-        }
-        do { } while(0);
-
-        if (hasAttr) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-
-  bool IsNativeScrollbarContent() const {
-    return IsNativeAnonymous() &&
-           IsAnyOfXULElements(nsGkAtoms::scrollbar,
-                              nsGkAtoms::resizer,
-                              nsGkAtoms::scrollcorner);
-  }
-
-
-  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
-
-
-  already_AddRefed<nsIURI> GetBaseURIForStyleAttr() const;
-
-  virtual nsresult GetEventTargetParent(
-                     mozilla::EventChainPreVisitor& aVisitor) override;
-
-  virtual bool IsPurple() = 0;
-  virtual void RemovePurple() = 0;
-
-  virtual bool OwnedOnlyByTheDOMTree() { return false; }
-protected:
-
-
-
-
-  nsIAtom* DoGetID() const;
-
-
-  inline nsIURI* GetBaseURIWithoutXMLBase() const;
-
-public:
-# 1002 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContent.h"
-  virtual void Describe(nsAString& aOutDescription) const {
-    aOutDescription = static_cast<const nsLiteralString&>(nsLiteralString(u"" "(not an element)"));
-  }
-
-  enum ETabFocusType {
-    eTabFocus_textControlsMask = (1<<0),
-    eTabFocus_formElementsMask = (1<<1),
-    eTabFocus_linksMask = (1<<2),
-    eTabFocus_any = 1 + (1<<1) + (1<<2)
-  };
-
-
-  static int32_t sTabFocusModel;
-
-
-
-  static bool sTabFocusModelAppliesToXUL;
-};
-
-template<typename T> struct nsIContent::COMTypeInfo<nsIContent, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContent::COMTypeInfo<nsIContent, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x8e1bab9d, 0x8815, 0x4d2c, { 0xa2, 0x4d, 0x7a, 0xba, 0x52, 0x39, 0xdc, 0x22 } };
-
-inline nsIContent* nsINode::AsContent()
-{
-  do { } while (0);
-  return static_cast<nsIContent*>(this);
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
-class nsIWeakReference : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult QueryReferent(const nsIID & uuid, void **result) = 0;
-
-     virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const = 0;
-};
-
-  template<typename T> struct nsIWeakReference::COMTypeInfo<nsIWeakReference, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIWeakReference::COMTypeInfo<nsIWeakReference, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9188bc85, 0xf92e, 0x11d2, { 0x81, 0xef, 0x00, 0x60, 0x08, 0x3a, 0x0b, 0xcf }};
-# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
-class nsISupportsWeakReference : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsISupportsWeakReference::COMTypeInfo<nsISupportsWeakReference, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupportsWeakReference::COMTypeInfo<nsISupportsWeakReference, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x9188bc86, 0xf92e, 0x11d2, { 0x81, 0xef, 0x00, 0x60, 0x08, 0x3a, 0x0b, 0xcf }};
-# 176 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h" 2
-
-typedef nsCOMPtr<nsIWeakReference> nsWeakPtr;
-
-
-
-
-
-
-
-template<class T, class DestinationType>
-inline nsresult
-CallQueryReferent(T* aSource, DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return aSource->QueryReferent((DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                                reinterpret_cast<void**>(aDestination));
-}
-
-
-class nsQueryReferent final : public nsCOMPtr_helper
-{
-public:
-  nsQueryReferent(nsIWeakReference* aWeakPtr, nsresult* aError)
-    : mWeakPtr(aWeakPtr)
-    , mErrorPtr(aError)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID& aIID, void**) const
-    override;
-
-private:
-  nsIWeakReference* mWeakPtr;
-  nsresult* mErrorPtr;
-};
-
-inline const nsQueryReferent
-do_QueryReferent(nsIWeakReference* aRawPtr, nsresult* aError = 0)
-{
-  return nsQueryReferent(aRawPtr, aError);
-}
-
-
-
-
-
-extern nsIWeakReference* NS_GetWeakReference(nsISupports*,
-                                             nsresult* aResult = 0);
-# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReferenceUtils.h"
-inline already_AddRefed<nsIWeakReference>
-do_GetWeakReference(nsISupports* aRawPtr, nsresult* aError = 0)
-{
-  return dont_AddRef(NS_GetWeakReference(aRawPtr, aError));
-}
-
-inline void
-do_GetWeakReference(nsIWeakReference* aRawPtr, nsresult* aError = 0)
-{
-
-
-
-}
-
-template<class T>
-inline void
-do_GetWeakReference(already_AddRefed<T>&)
-{
-
-
-
-}
-
-template<class T>
-inline void
-do_GetWeakReference(already_AddRefed<T>&, nsresult*)
-{
-
-
-
-}
-# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWeakReference.h" 2
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-class nsAttrValue;
-class nsIAtom;
-class nsIContent;
-class nsIDocument;
-class nsINode;
-
-namespace mozilla {
-namespace dom {
-class Element;
-}
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-struct CharacterDataChangeInfo
-{
-
-
-
-  bool mAppend;
-
-
-
-
-  uint32_t mChangeStart;
-
-
-
-
-
-
-  uint32_t mChangeEnd;
-
-
-
-
-
-  uint32_t mReplaceLength;
-# 66 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  struct Details {
-    enum {
-      eMerge,
-      eSplit
-    } mType;
-
-
-
-
-    nsIContent* mNextSibling;
-  };
-
-
-
-
-  Details* mDetails;
-};
-# 98 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-class nsIMutationObserver : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void CharacterDataWillChange(nsIDocument *aDocument,
-                                       nsIContent* aContent,
-                                       CharacterDataChangeInfo* aInfo) = 0;
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void CharacterDataChanged(nsIDocument *aDocument,
-                                    nsIContent* aContent,
-                                    CharacterDataChangeInfo* aInfo) = 0;
-# 170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void AttributeWillChange(nsIDocument* aDocument,
-                                   mozilla::dom::Element* aElement,
-                                   int32_t aNameSpaceID,
-                                   nsIAtom* aAttribute,
-                                   int32_t aModType,
-                                   const nsAttrValue* aNewValue) = 0;
-# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void AttributeChanged(nsIDocument* aDocument,
-                                mozilla::dom::Element* aElement,
-                                int32_t aNameSpaceID,
-                                nsIAtom* aAttribute,
-                                int32_t aModType,
-                                const nsAttrValue* aOldValue) = 0;
-# 211 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void NativeAnonymousChildListChange(nsIDocument* aDocument,
-                                              nsIContent* aContent,
-                                              bool aIsRemove) {}
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void AttributeSetToCurrentValue(nsIDocument* aDocument,
-                                          mozilla::dom::Element* aElement,
-                                          int32_t aNameSpaceID,
-                                          nsIAtom* aAttribute) {}
-# 246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void ContentAppended(nsIDocument *aDocument,
-                               nsIContent* aContainer,
-                               nsIContent* aFirstNewContent,
-                               int32_t aNewIndexInContainer) = 0;
-# 270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void ContentInserted(nsIDocument *aDocument,
-                               nsIContent* aContainer,
-                               nsIContent* aChild,
-                               int32_t aIndexInContainer) = 0;
-# 297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void ContentRemoved(nsIDocument *aDocument,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              int32_t aIndexInContainer,
-                              nsIContent* aPreviousSibling) = 0;
-# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void NodeWillBeDestroyed(const nsINode *aNode) = 0;
-# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMutationObserver.h"
-  virtual void ParentChainChanged(nsIContent *aContent) = 0;
-};
-
-template<typename T> struct nsIMutationObserver::COMTypeInfo<nsIMutationObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMutationObserver::COMTypeInfo<nsIMutationObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x6d674c17, 0x0fbc, 0x4633, { 0x8f, 0x46, 0x73, 0x4e, 0x87, 0xeb, 0xf0, 0xc7 } };
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
-class nsCOMArray_base
-{
-  friend class nsArrayBase;
-protected:
-  nsCOMArray_base() {}
-  explicit nsCOMArray_base(int32_t aCount) : mArray(aCount) {}
-  nsCOMArray_base(const nsCOMArray_base& aOther);
-  ~nsCOMArray_base();
-
-  int32_t IndexOf(nsISupports* aObject, uint32_t aStartIndex = 0) const;
-  bool Contains(nsISupports* aObject) const
-  {
-    return IndexOf(aObject) != -1;
-  }
-
-  int32_t IndexOfObject(nsISupports* aObject) const;
-  bool ContainsObject(nsISupports* aObject) const
-  {
-    return IndexOfObject(aObject) != -1;
-  }
-
-  typedef bool (*nsBaseArrayEnumFunc)(void* aElement, void* aData);
-
-
-  bool EnumerateForwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
-
-  bool EnumerateBackwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
-
-  typedef int (*nsBaseArrayComparatorFunc)(nsISupports* aElement1,
-                                           nsISupports* aElement2,
-                                           void* aData);
-
-  struct nsCOMArrayComparatorContext
-  {
-    nsBaseArrayComparatorFunc mComparatorFunc;
-    void* mData;
-  };
-
-  static int nsCOMArrayComparator(const void* aElement1, const void* aElement2,
-                                  void* aData);
-  void Sort(nsBaseArrayComparatorFunc aFunc, void* aData);
-
-  bool InsertObjectAt(nsISupports* aObject, int32_t aIndex);
-  void InsertElementAt(uint32_t aIndex, nsISupports* aElement);
-  void InsertElementAt(uint32_t aIndex, already_AddRefed<nsISupports> aElement);
-  bool InsertObjectsAt(const nsCOMArray_base& aObjects, int32_t aIndex);
-  void InsertElementsAt(uint32_t aIndex, const nsCOMArray_base& aElements);
-  void InsertElementsAt(uint32_t aIndex, nsISupports* const* aElements,
-                        uint32_t aCount);
-  void ReplaceObjectAt(nsISupports* aObject, int32_t aIndex);
-  void ReplaceElementAt(uint32_t aIndex, nsISupports* aElement)
-  {
-    nsISupports* oldElement = mArray[aIndex];
-    ns_if_addref(mArray[aIndex] = aElement);
-    do { if (oldElement) { (oldElement)->Release(); (oldElement) = 0; } } while (0);
-  }
-  bool AppendObject(nsISupports* aObject)
-  {
-    return InsertObjectAt(aObject, Count());
-  }
-  void AppendElement(nsISupports* aElement)
-  {
-    InsertElementAt(Length(), aElement);
-  }
-  void AppendElement(already_AddRefed<nsISupports> aElement)
-  {
-    InsertElementAt(Length(), mozilla::Move(aElement));
-  }
-
-  bool AppendObjects(const nsCOMArray_base& aObjects)
-  {
-    return InsertObjectsAt(aObjects, Count());
-  }
-  void AppendElements(const nsCOMArray_base& aElements)
-  {
-    return InsertElementsAt(Length(), aElements);
-  }
-  void AppendElements(nsISupports* const* aElements, uint32_t aCount)
-  {
-    return InsertElementsAt(Length(), aElements, aCount);
-  }
-  bool RemoveObject(nsISupports* aObject);
-  nsISupports** Elements() { return mArray.Elements(); }
-  void SwapElements(nsCOMArray_base& aOther)
-  {
-    mArray.SwapElements(aOther.mArray);
-  }
-
-  void Adopt(nsISupports** aElements, uint32_t aCount);
-  uint32_t Forget(nsISupports*** aElements);
-public:
-
-  int32_t Count() const { return mArray.Length(); }
-
-  uint32_t Length() const { return mArray.Length(); }
-  bool IsEmpty() const { return mArray.IsEmpty(); }
-
-
-
-  bool SetCount(int32_t aNewCount);
-
-  void TruncateLength(uint32_t aNewLength)
-  {
-    if (mArray.Length() > aNewLength) {
-      RemoveElementsAt(aNewLength, mArray.Length() - aNewLength);
-    }
-  }
-
-
-  void Clear();
-
-  nsISupports* ObjectAt(int32_t aIndex) const { return mArray[aIndex]; }
-
-  nsISupports* ElementAt(uint32_t aIndex) const { return mArray[aIndex]; }
-
-  nsISupports* SafeObjectAt(int32_t aIndex) const
-  {
-    return mArray.SafeElementAt(aIndex, nullptr);
-  }
-
-  nsISupports* SafeElementAt(uint32_t aIndex) const
-  {
-    return mArray.SafeElementAt(aIndex, nullptr);
-  }
-
-  nsISupports* operator[](int32_t aIndex) const { return mArray[aIndex]; }
-
-
-
-  bool RemoveObjectAt(int32_t aIndex);
-
-  void RemoveElementAt(uint32_t aIndex);
-
-
-
-  bool RemoveObjectsAt(int32_t aIndex, int32_t aCount);
-
-  void RemoveElementsAt(uint32_t aIndex, uint32_t aCount);
-
-  void SwapElementsAt(uint32_t aIndex1, uint32_t aIndex2)
-  {
-    nsISupports* tmp = mArray[aIndex1];
-    mArray[aIndex1] = mArray[aIndex2];
-    mArray[aIndex2] = tmp;
-  }
-
-
-
-  void SetCapacity(uint32_t aCapacity) { mArray.SetCapacity(aCapacity); }
-  uint32_t Capacity() { return mArray.Capacity(); }
-# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-private:
-
-
-  nsTArray<nsISupports*> mArray;
-
-
-  nsCOMArray_base& operator=(const nsCOMArray_base& aOther) = delete;
-};
-
-inline void
-ImplCycleCollectionUnlink(nsCOMArray_base& aField)
-{
-  aField.Clear();
-}
-
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsCOMArray_base& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  aFlags |= CycleCollectionEdgeNameArrayFlag;
-  int32_t length = aField.Count();
-  for (int32_t i = 0; i < length; ++i) {
-    CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
-  }
-}
-# 232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
-template<class T>
-class nsCOMArray : public nsCOMArray_base
-{
-public:
-  typedef int32_t index_type;
-  typedef mozilla::ArrayIterator<T*, nsCOMArray> iterator;
-  typedef mozilla::ArrayIterator<const T*, nsCOMArray> const_iterator;
-  typedef mozilla::ReverseIterator<iterator> reverse_iterator;
-  typedef mozilla::ReverseIterator<const_iterator> const_reverse_iterator;
-
-  nsCOMArray() {}
-  explicit nsCOMArray(int32_t aCount) : nsCOMArray_base(aCount) {}
-  explicit nsCOMArray(const nsCOMArray<T>& aOther) : nsCOMArray_base(aOther) {}
-  nsCOMArray(nsCOMArray<T>&& aOther) { SwapElements(aOther); }
-  ~nsCOMArray() {}
-
-
-  nsCOMArray<T>& operator=(nsCOMArray<T> && aOther)
-  {
-    SwapElements(aOther);
-    return *this;
-  }
-
-
-  T* ObjectAt(int32_t aIndex) const
-  {
-    return static_cast<T*>(nsCOMArray_base::ObjectAt(aIndex));
-  }
-
-  T* ElementAt(uint32_t aIndex) const
-  {
-    return static_cast<T*>(nsCOMArray_base::ElementAt(aIndex));
-  }
-
-
-  T* SafeObjectAt(int32_t aIndex) const
-  {
-    return static_cast<T*>(nsCOMArray_base::SafeObjectAt(aIndex));
-  }
-
-  T* SafeElementAt(uint32_t aIndex) const
-  {
-    return static_cast<T*>(nsCOMArray_base::SafeElementAt(aIndex));
-  }
-
-
-  T* operator[](int32_t aIndex) const { return ObjectAt(aIndex); }
-
-
-
-
-  int32_t IndexOf(T* aObject, uint32_t aStartIndex = 0) const
-  {
-    return nsCOMArray_base::IndexOf(aObject, aStartIndex);
-  }
-  bool Contains(T* aObject) const
-  {
-    return nsCOMArray_base::Contains(aObject);
-  }
-
-
-
-
-
-
-  int32_t IndexOfObject(T* aObject) const
-  {
-    return nsCOMArray_base::IndexOfObject(aObject);
-  }
-  bool ContainsObject(nsISupports* aObject) const
-  {
-    return nsCOMArray_base::ContainsObject(aObject);
-  }
-
-
-
-  bool InsertObjectAt(T* aObject, int32_t aIndex)
-  {
-    return nsCOMArray_base::InsertObjectAt(aObject, aIndex);
-  }
-
-  void InsertElementAt(uint32_t aIndex, T* aElement)
-  {
-    nsCOMArray_base::InsertElementAt(aIndex, aElement);
-  }
-
-
-
-  bool InsertObjectsAt(const nsCOMArray<T>& aObjects, int32_t aIndex)
-  {
-    return nsCOMArray_base::InsertObjectsAt(aObjects, aIndex);
-  }
-
-  void InsertElementsAt(uint32_t aIndex, const nsCOMArray<T>& aElements)
-  {
-    nsCOMArray_base::InsertElementsAt(aIndex, aElements);
-  }
-  void InsertElementsAt(uint32_t aIndex, T* const* aElements, uint32_t aCount)
-  {
-    nsCOMArray_base::InsertElementsAt(
-      aIndex, reinterpret_cast<nsISupports* const*>(aElements), aCount);
-  }
-
-
-
-  void ReplaceObjectAt(T* aObject, int32_t aIndex)
-  {
-    nsCOMArray_base::ReplaceObjectAt(aObject, aIndex);
-  }
-
-  void ReplaceElementAt(uint32_t aIndex, T* aElement)
-  {
-    nsCOMArray_base::ReplaceElementAt(aIndex, aElement);
-  }
-
-  typedef int (*nsCOMArrayComparatorFunc)(T* aElement1, T* aElement2,
-                                          void* aData);
-
-  void Sort(nsCOMArrayComparatorFunc aFunc, void* aData)
-  {
-    nsCOMArray_base::Sort(nsBaseArrayComparatorFunc(aFunc), aData);
-  }
-
-
-  bool AppendObject(T* aObject)
-  {
-    return nsCOMArray_base::AppendObject(aObject);
-  }
-
-  void AppendElement(T* aElement)
-  {
-    nsCOMArray_base::AppendElement(aElement);
-  }
-  void AppendElement(already_AddRefed<T> aElement)
-  {
-    nsCOMArray_base::AppendElement(mozilla::Move(aElement));
-  }
-
-
-  bool AppendObjects(const nsCOMArray<T>& aObjects)
-  {
-    return nsCOMArray_base::AppendObjects(aObjects);
-  }
-
-  void AppendElements(const nsCOMArray<T>& aElements)
-  {
-    return nsCOMArray_base::AppendElements(aElements);
-  }
-  void AppendElements(T* const* aElements, uint32_t aCount)
-  {
-    InsertElementsAt(Length(), aElements, aCount);
-  }
-
-
-
-
-  bool RemoveObject(T* aObject)
-  {
-    return nsCOMArray_base::RemoveObject(aObject);
-  }
-
-  bool RemoveElement(T* aElement)
-  {
-    return nsCOMArray_base::RemoveObject(aElement);
-  }
-
-  T** Elements()
-  {
-    return reinterpret_cast<T**>(nsCOMArray_base::Elements());
-  }
-  void SwapElements(nsCOMArray<T>& aOther)
-  {
-    nsCOMArray_base::SwapElements(aOther);
-  }
-# 418 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
-  void Adopt(T** aElements, uint32_t aSize)
-  {
-    nsCOMArray_base::Adopt(reinterpret_cast<nsISupports**>(aElements), aSize);
-  }
-# 431 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCOMArray.h"
-  uint32_t Forget(T*** aElements)
-  {
-    return nsCOMArray_base::Forget(reinterpret_cast<nsISupports***>(aElements));
-  }
-
-
-  iterator begin() { return iterator(*this, 0); }
-  const_iterator begin() const { return const_iterator(*this, 0); }
-  const_iterator cbegin() const { return begin(); }
-  iterator end() { return iterator(*this, Length()); }
-  const_iterator end() const { return const_iterator(*this, Length()); }
-  const_iterator cend() const { return end(); }
-
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-  const_reverse_iterator crend() const { return rend(); }
-
-private:
-
-
-  nsCOMArray<T>& operator=(const nsCOMArray<T>& aOther) = delete;
-};
-
-template<typename T>
-inline void
-ImplCycleCollectionUnlink(nsCOMArray<T>& aField)
-{
-  aField.Clear();
-}
-
-template<typename E>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsCOMArray<E>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  aFlags |= CycleCollectionEdgeNameArrayFlag;
-  int32_t length = aField.Count();
-  for (int32_t i = 0; i < length; ++i) {
-    CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
-  }
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h" 2
-
-struct CharacterDataChangeInfo;
-template<class E> class nsCOMArray;
-class nsCycleCollectionTraversalCallback;
-namespace mozilla {
-struct NonOwningAnimationTarget;
-namespace dom {
-class Animation;
-}
-}
-
-class nsNodeUtils
-{
-public:
-
-
-
-
-
-
-  static void CharacterDataWillChange(nsIContent* aContent,
-                                      CharacterDataChangeInfo* aInfo);
-
-
-
-
-
-
-
-  static void CharacterDataChanged(nsIContent* aContent,
-                                   CharacterDataChangeInfo* aInfo);
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static void AttributeWillChange(mozilla::dom::Element* aElement,
-                                  int32_t aNameSpaceID,
-                                  nsIAtom* aAttribute,
-                                  int32_t aModType,
-                                  const nsAttrValue* aNewValue);
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static void AttributeChanged(mozilla::dom::Element* aElement,
-                               int32_t aNameSpaceID,
-                               nsIAtom* aAttribute,
-                               int32_t aModType,
-                               const nsAttrValue* aOldValue);
-# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static void AttributeSetToCurrentValue(mozilla::dom::Element* aElement,
-                                         int32_t aNameSpaceID,
-                                         nsIAtom* aAttribute);
-# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static void ContentAppended(nsIContent* aContainer,
-                              nsIContent* aFirstNewContent,
-                              int32_t aNewIndexInContainer);
-
-
-
-
-
-
-
-  static void NativeAnonymousChildListChange(nsIContent* aContent,
-                                             bool aIsRemove);
-# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static void ContentInserted(nsINode* aContainer,
-                              nsIContent* aChild,
-                              int32_t aIndexInContainer);
-
-
-
-
-
-
-
-  static void ContentRemoved(nsINode* aContainer,
-                             nsIContent* aChild,
-                             int32_t aIndexInContainer,
-                             nsIContent* aPreviousSibling);
-
-
-
-
-
-  static inline void ParentChainChanged(nsIContent *aContent)
-  {
-    nsINode::nsSlots* slots = aContent->GetExistingSlots();
-    if (slots && !slots->mMutationObservers.IsEmpty()) {
-      do { nsTObserverArray<nsIMutationObserver *>::ForwardIterator iter_(slots->mMutationObservers); nsIMutationObserver* obs_; while (iter_.HasMore()) { obs_ = iter_.GetNext(); obs_ -> ParentChainChanged (aContent) ; } } while(0);
-
-
-
-    }
-  }
-
-
-
-
-
-
-  static mozilla::Maybe<mozilla::NonOwningAnimationTarget>
-    GetTargetForAnimation(const mozilla::dom::Animation* aAnimation);
-
-
-
-
-
-  static void AnimationAdded(mozilla::dom::Animation* aAnimation);
-  static void AnimationChanged(mozilla::dom::Animation* aAnimation);
-  static void AnimationRemoved(mozilla::dom::Animation* aAnimation);
-
-
-
-
-
-  static void LastRelease(nsINode* aNode);
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static nsresult Clone(nsINode *aNode, bool aDeep,
-                        nsNodeInfoManager *aNewNodeInfoManager,
-                        nsCOMArray<nsINode> &aNodesWithProperties,
-                        nsINode **aResult)
-  {
-    return CloneAndAdopt(aNode, true, aDeep, aNewNodeInfoManager,
-                         nullptr, aNodesWithProperties, nullptr, aResult);
-  }
-
-
-
-
-  static nsresult Clone(nsINode *aNode, bool aDeep, nsINode **aResult)
-  {
-    nsCOMArray<nsINode> dummyNodeWithProperties;
-    return CloneAndAdopt(aNode, true, aDeep, nullptr, nullptr,
-                         dummyNodeWithProperties, aNode->GetParent(), aResult);
-  }
-# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static nsresult Adopt(nsINode *aNode, nsNodeInfoManager *aNewNodeInfoManager,
-                        JS::Handle<JSObject*> aReparentScope,
-                        nsCOMArray<nsINode> &aNodesWithProperties)
-  {
-    nsCOMPtr<nsINode> node;
-    nsresult rv = CloneAndAdopt(aNode, false, true, aNewNodeInfoManager,
-                                aReparentScope, aNodesWithProperties,
-                                nullptr, getter_AddRefs(node));
-
-    nsMutationGuard::DidMutate();
-
-    return rv;
-  }
-
-
-
-
-
-
-
-  static void TraverseUserData(nsINode* aNode,
-                               nsCycleCollectionTraversalCallback &aCb);
-# 254 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static nsresult CloneNodeImpl(nsINode *aNode, bool aDeep, nsINode **aResult);
-
-
-
-
-
-
-  static void UnlinkUserData(nsINode *aNode);
-
-
-
-
-
-
-  static bool IsTemplateElement(const nsINode *aNode);
-# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static nsIContent* GetFirstChildOfTemplateOrNode(nsINode* aNode);
-
-private:
-# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsNodeUtils.h"
-  static nsresult CloneAndAdopt(nsINode *aNode, bool aClone, bool aDeep,
-                                nsNodeInfoManager *aNewNodeInfoManager,
-                                JS::Handle<JSObject*> aReparentScope,
-                                nsCOMArray<nsINode> &aNodesWithProperties,
-                                nsINode *aParent, nsINode **aResult);
-
-  enum class AnimationMutationType
-  {
-    Added,
-    Changed,
-    Removed
-  };
-
-
-
-
-
-
-  static void AnimationMutated(mozilla::dom::Animation* aAnimation,
-                               AnimationMutationType aMutatedType);
-
-};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMHTMLCollection.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMHTMLCollection.h"
-class nsIDOMHTMLCollection : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-
-  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) = 0;
-
-
-  virtual nsresult NamedItem(const nsAString & name, nsIDOMNode * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIDOMHTMLCollection::COMTypeInfo<nsIDOMHTMLCollection, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMHTMLCollection::COMTypeInfo<nsIDOMHTMLCollection, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbb07f567, 0x5b37, 0x4172, { 0x92, 0xaa, 0x7d, 0x00, 0xce, 0xed, 0x48, 0x09 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h" 2
-
-
-
-
-
-class nsINode;
-class nsString;
-
-namespace mozilla {
-namespace dom {
-class Element;
-}
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHTMLCollection.h"
-class nsIHTMLCollection : public nsIDOMHTMLCollection
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-  virtual nsINode* GetParentObject() = 0;
-
-  using nsIDOMHTMLCollection::Item;
-  using nsIDOMHTMLCollection::NamedItem;
-
-  uint32_t Length()
-  {
-    uint32_t length;
-    GetLength(&length);
-    return length;
-  }
-  virtual mozilla::dom::Element* GetElementAt(uint32_t index) = 0;
-  mozilla::dom::Element* Item(uint32_t index)
-  {
-    return GetElementAt(index);
-  }
-  mozilla::dom::Element* IndexedGetter(uint32_t index, bool& aFound)
-  {
-    mozilla::dom::Element* item = Item(index);
-    aFound = !!item;
-    return item;
-  }
-  mozilla::dom::Element* NamedItem(const nsAString& aName)
-  {
-    bool dummy;
-    return NamedGetter(aName, dummy);
-  }
-  mozilla::dom::Element* NamedGetter(const nsAString& aName, bool& aFound)
-  {
-    return GetFirstNamedElement(aName, aFound);
-  }
-  virtual mozilla::dom::Element*
-  GetFirstNamedElement(const nsAString& aName, bool& aFound) = 0;
-
-  virtual void GetSupportedNames(nsTArray<nsString>& aNames) = 0;
-
-  JSObject* GetWrapperPreserveColor()
-  {
-    return GetWrapperPreserveColorInternal();
-  }
-  JSObject* GetWrapper()
-  {
-    JSObject* obj = GetWrapperPreserveColor();
-    if (obj) {
-      JS::ExposeObjectToActiveJS(obj);
-    }
-    return obj;
-  }
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) = 0;
-protected:
-  virtual JSObject* GetWrapperPreserveColorInternal() = 0;
-};
-
-template<typename T> struct nsIHTMLCollection::COMTypeInfo<nsIHTMLCollection, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHTMLCollection::COMTypeInfo<nsIHTMLCollection, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x4e169191, 0x5196, 0x4e17, { 0xa4, 0x79, 0xd5, 0x35, 0x0b, 0x5b, 0x0a, 0xcd } };
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHashable.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHashable.h"
-class nsIHashable : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Equals(nsIHashable *aOther, bool *_retval) = 0;
-
-
-  virtual nsresult GetHashCode(uint32_t *aHashCode) = 0;
-
-};
-
-  template<typename T> struct nsIHashable::COMTypeInfo<nsIHashable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHashable::COMTypeInfo<nsIHashable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x17e595fa, 0xb57a, 0x4933, { 0xbd, 0x0f, 0xb1, 0x81, 0x2e, 0x8a, 0xb1, 0x88 }};
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-typedef uint32_t PLDHashNumber;
-
-class PLDHashTable;
-struct PLDHashTableOps;
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-struct PLDHashEntryHdr
-{
-private:
-  friend class PLDHashTable;
-
-  PLDHashNumber mKeyHash;
-};
-# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-class PLDHashTable
-{
-private:
-
-
-  class EntryStore
-  {
-  private:
-    char* mEntryStore;
-    uint32_t mGeneration;
-
-  public:
-    EntryStore() : mEntryStore(nullptr), mGeneration(0) {}
-
-    ~EntryStore()
-    {
-      free(mEntryStore);
-      mEntryStore = nullptr;
-      mGeneration++;
-    }
-
-    char* Get() { return mEntryStore; }
-    const char* Get() const { return mEntryStore; }
-
-    void Set(char* aEntryStore)
-    {
-      mEntryStore = aEntryStore;
-      mGeneration++;
-    }
-
-    uint32_t Generation() const { return mGeneration; }
-  };
-
-  const PLDHashTableOps* const mOps;
-  int16_t mHashShift;
-  const uint32_t mEntrySize;
-  uint32_t mEntryCount;
-  uint32_t mRemovedCount;
-  EntryStore mEntryStore;
-
-
-
-
-
-public:
-
-
-
-
-
-
-  static const uint32_t kMaxCapacity = ((uint32_t)1 << 26);
-
-  static const uint32_t kMinCapacity = 8;
-
-
-
-  static const uint32_t kMaxInitialLength = kMaxCapacity / 2;
-
-
-  static const uint32_t kDefaultInitialLength = 4;
-# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-  PLDHashTable(const PLDHashTableOps* aOps, uint32_t aEntrySize,
-               uint32_t aLength = kDefaultInitialLength);
-
-  PLDHashTable(PLDHashTable&& aOther)
-
-
-    : mOps(aOther.mOps)
-    , mEntrySize(aOther.mEntrySize)
-
-
-    , mEntryStore()
-
-
-
-  {
-    *this = mozilla::Move(aOther);
-  }
-
-  PLDHashTable& operator=(PLDHashTable&& aOther);
-
-  ~PLDHashTable();
-
-
-  const PLDHashTableOps* Ops() const { return mOps; }
-
-
-
-
-  uint32_t Capacity() const
-  {
-    return mEntryStore.Get() ? CapacityFromHashShift() : 0;
-  }
-
-  uint32_t EntrySize() const { return mEntrySize; }
-  uint32_t EntryCount() const { return mEntryCount; }
-  uint32_t Generation() const { return mEntryStore.Generation(); }
-
-
-
-
-
-
-
-  PLDHashEntryHdr* Search(const void* aKey);
-# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-  PLDHashEntryHdr* Add(const void* aKey, const mozilla::fallible_t&);
-
-
-
-  PLDHashEntryHdr* Add(const void* aKey);
-
-
-
-
-
-
-
-  void Remove(const void* aKey);
-
-
-
-
-
-
-
-  void RemoveEntry(PLDHashEntryHdr* aEntry);
-
-
-
-
-
-
-
-  void RawRemove(PLDHashEntryHdr* aEntry);
-
-
-
-  void Clear();
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-  void ClearAndPrepareForLength(uint32_t aLength);
-
-
-
-
-  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-# 396 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-  static const PLDHashTableOps* StubOps();
-
-
-  static PLDHashNumber HashVoidPtrKeyStub(const void* aKey);
-  static bool MatchEntryStub(const PLDHashEntryHdr* aEntry, const void* aKey);
-  static void MoveEntryStub(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
-                            PLDHashEntryHdr* aTo);
-  static void ClearEntryStub(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
-
-
-  static PLDHashNumber HashStringKey(const void* aKey);
-  static bool MatchStringKey(const PLDHashEntryHdr* aEntry, const void* aKey);
-# 435 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-  class Iterator
-  {
-  public:
-    explicit Iterator(PLDHashTable* aTable);
-    Iterator(Iterator&& aOther);
-    ~Iterator();
-
-
-    bool Done() const { return mNexts == mNextsLimit; }
-
-
-    PLDHashEntryHdr* Get() const
-    {
-      do { } while (0);
-
-      PLDHashEntryHdr* entry = reinterpret_cast<PLDHashEntryHdr*>(mCurrent);
-      do { } while (0);
-      return entry;
-    }
-
-
-    void Next();
-
-
-
-    void Remove();
-
-  protected:
-    PLDHashTable* mTable;
-
-  private:
-    char* mStart;
-    char* mLimit;
-    char* mCurrent;
-    uint32_t mNexts;
-    uint32_t mNextsLimit;
-
-    bool mHaveRemoved;
-
-    bool IsOnNonLiveEntry() const;
-    void MoveToNextEntry();
-
-    Iterator() = delete;
-    Iterator(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&&) = delete;
-  };
-
-  Iterator Iter() { return Iterator(this); }
-
-
-
-  Iterator ConstIter() const
-  {
-    return Iterator(const_cast<PLDHashTable*>(this));
-  }
-
-private:
-
-
-  static const uint32_t kHashBits = 32;
-  static const uint32_t kGoldenRatio = 0x9E3779B9U;
-
-  static uint32_t HashShift(uint32_t aEntrySize, uint32_t aLength);
-
-  static const PLDHashNumber kCollisionFlag = 1;
-
-  static bool EntryIsFree(PLDHashEntryHdr* aEntry)
-  {
-    return aEntry->mKeyHash == 0;
-  }
-  static bool EntryIsRemoved(PLDHashEntryHdr* aEntry)
-  {
-    return aEntry->mKeyHash == 1;
-  }
-  static bool EntryIsLive(PLDHashEntryHdr* aEntry)
-  {
-    return aEntry->mKeyHash >= 2;
-  }
-
-  static void MarkEntryFree(PLDHashEntryHdr* aEntry)
-  {
-    aEntry->mKeyHash = 0;
-  }
-  static void MarkEntryRemoved(PLDHashEntryHdr* aEntry)
-  {
-    aEntry->mKeyHash = 1;
-  }
-
-  PLDHashNumber Hash1(PLDHashNumber aHash0);
-  void Hash2(PLDHashNumber aHash, uint32_t& aHash2Out, uint32_t& aSizeMaskOut);
-
-  static bool MatchEntryKeyhash(PLDHashEntryHdr* aEntry, PLDHashNumber aHash);
-  PLDHashEntryHdr* AddressEntry(uint32_t aIndex);
-
-
-
-  uint32_t CapacityFromHashShift() const
-  {
-    return ((uint32_t)1 << (kHashBits - mHashShift));
-  }
-
-  PLDHashNumber ComputeKeyHash(const void* aKey);
-
-  enum SearchReason { ForSearchOrRemove, ForAdd };
-
-  template <SearchReason Reason>
-  PLDHashEntryHdr*
-    SearchTable(const void* aKey, PLDHashNumber aKeyHash);
-
-  PLDHashEntryHdr* FindFreeEntry(PLDHashNumber aKeyHash);
-
-  bool ChangeTable(int aDeltaLog2);
-
-  void ShrinkIfAppropriate();
-
-  PLDHashTable(const PLDHashTable& aOther) = delete;
-  PLDHashTable& operator=(const PLDHashTable& aOther) = delete;
-};
-
-
-
-typedef PLDHashNumber (*PLDHashHashKey)(const void* aKey);
-
-
-
-typedef bool (*PLDHashMatchEntry)(const PLDHashEntryHdr* aEntry,
-                                  const void* aKey);
-
-
-
-
-
-typedef void (*PLDHashMoveEntry)(PLDHashTable* aTable,
-                                 const PLDHashEntryHdr* aFrom,
-                                 PLDHashEntryHdr* aTo);
-
-
-
-typedef void (*PLDHashClearEntry)(PLDHashTable* aTable,
-                                  PLDHashEntryHdr* aEntry);
-
-
-
-
-
-typedef void (*PLDHashInitEntry)(PLDHashEntryHdr* aEntry, const void* aKey);
-# 603 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PLDHashTable.h"
-struct PLDHashTableOps
-{
-
-  PLDHashHashKey hashKey;
-  PLDHashMatchEntry matchEntry;
-  PLDHashMoveEntry moveEntry;
-  PLDHashClearEntry clearEntry;
-
-
-  PLDHashInitEntry initEntry;
-};
-
-
-struct PLDHashEntryStub : public PLDHashEntryHdr
-{
-  const void* key;
-};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
-const char* NS_strspnp(const char* aDelims, const char* aStr);
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
-char* NS_strtok(const char* aDelims, char** aStr);
-
-
-
-
-uint32_t NS_strlen(const char16_t* aString);
-
-
-
-
-int NS_strcmp(const char16_t* aStrA, const char16_t* aStrB);
-
-
-
-
-int NS_strncmp(const char16_t* aStrA, const char16_t* aStrB, size_t aLen);
-
-
-
-
-char16_t* NS_strdup(const char16_t* aString);
-
-
-
-
-char* NS_strdup(const char* aString);
-# 72 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRTGlue.h"
-template<typename CharT>
-CharT* NS_strndup(const CharT* aString, uint32_t aLen);
-
-
-
-
-
-class nsLowerUpperUtils
-{
-public:
-  static const unsigned char kLower2Upper[256];
-  static const unsigned char kUpper2Lower[256];
-};
-
-inline char
-NS_ToUpper(char aChar)
-{
-  return (char)nsLowerUpperUtils::kLower2Upper[(unsigned char)aChar];
-}
-
-inline char
-NS_ToLower(char aChar)
-{
-  return (char)nsLowerUpperUtils::kUpper2Lower[(unsigned char)aChar];
-}
-
-bool NS_IsUpper(char aChar);
-bool NS_IsLower(char aChar);
-
-bool NS_IsAscii(char16_t aChar);
-bool NS_IsAscii(const char16_t* aString);
-bool NS_IsAsciiAlpha(char16_t aChar);
-bool NS_IsAsciiDigit(char16_t aChar);
-bool NS_IsAsciiWhitespace(char16_t aChar);
-bool NS_IsAscii(const char* aString);
-bool NS_IsAscii(const char* aString, uint32_t aLength);
-
-
-void NS_MakeRandomString(char* aBuf, int32_t aBufLen);
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
-void ToLowerCase(nsAString&);
-void ToUpperCase(nsAString&);
-
-void ToLowerCase(const nsAString& aSource, nsAString& aDest);
-void ToUpperCase(const nsAString& aSource, nsAString& aDest);
-
-uint32_t ToLowerCase(uint32_t);
-uint32_t ToUpperCase(uint32_t);
-uint32_t ToTitleCase(uint32_t);
-
-void ToLowerCase(const char16_t*, char16_t*, uint32_t);
-void ToUpperCase(const char16_t*, char16_t*, uint32_t);
-
-inline bool IsUpperCase(uint32_t c) {
-  return ToLowerCase(c) != c;
-}
-
-inline bool IsLowerCase(uint32_t c) {
-  return ToUpperCase(c) != c;
-}
-
-
-
-class nsCaseInsensitiveStringComparator : public nsStringComparator
-{
-public:
-  virtual int32_t operator() (const char16_t*,
-                              const char16_t*,
-                              uint32_t,
-                              uint32_t) const override;
-};
-
-class nsCaseInsensitiveUTF8StringComparator : public nsCStringComparator
-{
-public:
-  virtual int32_t operator() (const char*,
-                              const char*,
-                              uint32_t,
-                              uint32_t) const override;
-};
-
-class nsCaseInsensitiveStringArrayComparator
-{
-public:
-  template<class A, class B>
-  bool Equals(const A& a, const B& b) const {
-    return a.Equals(b, nsCaseInsensitiveStringComparator());
-  }
-};
-
-class nsASCIICaseInsensitiveStringComparator : public nsStringComparator
-{
-public:
-  nsASCIICaseInsensitiveStringComparator() {}
-  virtual int operator() (const char16_t*,
-                          const char16_t*,
-                          uint32_t,
-                          uint32_t) const override;
-};
-
-inline bool
-CaseInsensitiveFindInReadable(const nsAString& aPattern,
-                              nsAString::const_iterator& aSearchStart,
-                              nsAString::const_iterator& aSearchEnd)
-{
-  return FindInReadable(aPattern, aSearchStart, aSearchEnd,
-                        nsCaseInsensitiveStringComparator());
-}
-
-inline bool
-CaseInsensitiveFindInReadable(const nsAString& aPattern,
-                              const nsAString& aHay)
-{
-  nsAString::const_iterator searchBegin, searchEnd;
-  return FindInReadable(aPattern, aHay.BeginReading(searchBegin),
-                        aHay.EndReading(searchEnd),
-                        nsCaseInsensitiveStringComparator());
-}
-
-
-
-int32_t
-CaseInsensitiveCompare(const char16_t *a, const char16_t *b, uint32_t len);
-
-int32_t
-CaseInsensitiveCompare(const char* aLeft, const char* aRight,
-                       uint32_t aLeftBytes, uint32_t aRightBytes);
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
-bool
-CaseInsensitiveUTF8CharsEqual(const char* aLeft, const char* aRight,
-                              const char* aLeftEnd, const char* aRightEnd,
-                              const char** aLeftNext, const char** aRightNext,
-                              bool* aErr);
-
-namespace mozilla {
-# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsUnicharUtils.h"
-uint32_t
-HashUTF8AsUTF16(const char* aUTF8, uint32_t aLength, bool* aErr);
-
-bool
-IsSegmentBreakSkipChar(uint32_t u);
-
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPointerHashKeys.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPointerHashKeys.h"
-template<class T>
-class nsPtrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef T* KeyType;
-  typedef const T* KeyTypePointer;
-
-  explicit nsPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
-  nsPtrHashKey(const nsPtrHashKey<T>& aToCopy) : mKey(aToCopy.mKey) {}
-  ~nsPtrHashKey() {}
-
-  KeyType GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return ((uint32_t)(intptr_t)(aKey)) >> 2;
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-protected:
-  T* mKey;
-};
-
-typedef nsPtrHashKey<const void> nsVoidPtrHashKey;
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h" 2
-
-
-
-
-
-namespace mozilla {
-
-
-
-inline uint32_t
-HashString(const nsAString& aStr)
-{
-  return HashString(aStr.BeginReading(), aStr.Length());
-}
-
-inline uint32_t
-HashString(const nsACString& aStr)
-{
-  return HashString(aStr.BeginReading(), aStr.Length());
-}
-
-}
-# 75 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-class nsStringHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const nsAString& KeyType;
-  typedef const nsAString* KeyTypePointer;
-
-  explicit nsStringHashKey(KeyTypePointer aStr) : mStr(*aStr) {}
-  nsStringHashKey(const nsStringHashKey& aToCopy) : mStr(aToCopy.mStr) {}
-  ~nsStringHashKey() {}
-
-  KeyType GetKey() const { return mStr; }
-  bool KeyEquals(const KeyTypePointer aKey) const
-  {
-    return mStr.Equals(*aKey);
-  }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(const KeyTypePointer aKey)
-  {
-    return mozilla::HashString(*aKey);
-  }
-
-
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
-  }
-
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const nsString mStr;
-};
-# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-class nsStringCaseInsensitiveHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const nsAString& KeyType;
-  typedef const nsAString* KeyTypePointer;
-
-  explicit nsStringCaseInsensitiveHashKey(KeyTypePointer aStr)
-    : mStr(*aStr)
-  {
-
-  }
-  nsStringCaseInsensitiveHashKey(const nsStringCaseInsensitiveHashKey& aToCopy)
-    : mStr(aToCopy.mStr)
-  {
-  }
-  ~nsStringCaseInsensitiveHashKey() {}
-
-  KeyType GetKey() const { return mStr; }
-  bool KeyEquals(const KeyTypePointer aKey) const
-  {
-    return mStr.Equals(*aKey, nsCaseInsensitiveStringComparator());
-  }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(const KeyTypePointer aKey)
-  {
-    nsAutoString tmKey(*aKey);
-    ToLowerCase(tmKey);
-    return mozilla::HashString(tmKey);
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
-  }
-
-private:
-  const nsString mStr;
-};
-# 170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-class nsCStringHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const nsACString& KeyType;
-  typedef const nsACString* KeyTypePointer;
-
-  explicit nsCStringHashKey(const nsACString* aStr) : mStr(*aStr) {}
-  nsCStringHashKey(const nsCStringHashKey& aToCopy) : mStr(aToCopy.mStr) {}
-  ~nsCStringHashKey() {}
-
-  KeyType GetKey() const { return mStr; }
-  bool KeyEquals(KeyTypePointer aKey) const { return mStr.Equals(*aKey); }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return mozilla::HashString(*aKey);
-  }
-
-
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
-  }
-
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const nsCString mStr;
-};
-
-
-
-
-
-
-class nsUint32HashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const uint32_t& KeyType;
-  typedef const uint32_t* KeyTypePointer;
-
-  explicit nsUint32HashKey(KeyTypePointer aKey) : mValue(*aKey) {}
-  nsUint32HashKey(const nsUint32HashKey& aToCopy) : mValue(aToCopy.mValue) {}
-  ~nsUint32HashKey() {}
-
-  KeyType GetKey() const { return mValue; }
-  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey) { return *aKey; }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const uint32_t mValue;
-};
-
-
-
-
-
-
-class nsUint64HashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const uint64_t& KeyType;
-  typedef const uint64_t* KeyTypePointer;
-
-  explicit nsUint64HashKey(KeyTypePointer aKey) : mValue(*aKey) {}
-  nsUint64HashKey(const nsUint64HashKey& aToCopy) : mValue(aToCopy.mValue) {}
-  ~nsUint64HashKey() {}
-
-  KeyType GetKey() const { return mValue; }
-  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return PLDHashNumber(*aKey);
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const uint64_t mValue;
-};
-
-
-
-
-
-
-class nsFloatHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const float& KeyType;
-  typedef const float* KeyTypePointer;
-
-  explicit nsFloatHashKey(KeyTypePointer aKey) : mValue(*aKey) {}
-  nsFloatHashKey(const nsFloatHashKey& aToCopy) : mValue(aToCopy.mValue) {}
-  ~nsFloatHashKey() {}
-
-  KeyType GetKey() const { return mValue; }
-  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return *reinterpret_cast<const uint32_t*>(aKey);
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const float mValue;
-};
-
-
-
-
-
-
-class nsISupportsHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef nsISupports* KeyType;
-  typedef const nsISupports* KeyTypePointer;
-
-  explicit nsISupportsHashKey(const nsISupports* aKey)
-    : mSupports(const_cast<nsISupports*>(aKey))
-  {
-  }
-  nsISupportsHashKey(const nsISupportsHashKey& aToCopy)
-    : mSupports(aToCopy.mSupports)
-  {
-  }
-  ~nsISupportsHashKey() {}
-
-  KeyType GetKey() const { return mSupports; }
-  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mSupports; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return ((uint32_t)(intptr_t)(aKey)) >> 2;
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  nsCOMPtr<nsISupports> mSupports;
-};
-
-
-
-
-
-
-template<class T>
-class nsRefPtrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef T* KeyType;
-  typedef const T* KeyTypePointer;
-
-  explicit nsRefPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
-  nsRefPtrHashKey(const nsRefPtrHashKey& aToCopy) : mKey(aToCopy.mKey) {}
-  ~nsRefPtrHashKey() {}
-
-  KeyType GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return ((uint32_t)(intptr_t)(aKey)) >> 2;
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  RefPtr<T> mKey;
-};
-
-template<class T>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsRefPtrHashKey<T>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  CycleCollectionNoteChild(aCallback, aField.GetKey(), aName, aFlags);
-}
-# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-template<class T>
-class nsClearingPtrHashKey : public nsPtrHashKey<T>
-{
-public:
-  explicit nsClearingPtrHashKey(const T* aKey) : nsPtrHashKey<T>(aKey) {}
-  nsClearingPtrHashKey(const nsClearingPtrHashKey<T>& aToCopy)
-    : nsPtrHashKey<T>(aToCopy)
-  {
-  }
-  ~nsClearingPtrHashKey() { nsPtrHashKey<T>::mKey = nullptr; }
-};
-
-typedef nsClearingPtrHashKey<const void> nsClearingVoidPtrHashKey;
-
-
-
-
-
-
-template<class T>
-class nsFuncPtrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef T& KeyType;
-  typedef const T* KeyTypePointer;
-
-  explicit nsFuncPtrHashKey(const T* aKey) : mKey(*const_cast<T*>(aKey)) {}
-  nsFuncPtrHashKey(const nsFuncPtrHashKey<T>& aToCopy) : mKey(aToCopy.mKey) {}
-  ~nsFuncPtrHashKey() {}
-
-  KeyType GetKey() const { return const_cast<T&>(mKey); }
-  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return ((uint32_t)(intptr_t)(*aKey)) >> 2;
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-protected:
-  T mKey;
-};
-
-
-
-
-
-
-class nsIDHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const nsID& KeyType;
-  typedef const nsID* KeyTypePointer;
-
-  explicit nsIDHashKey(const nsID* aInID) : mID(*aInID) {}
-  nsIDHashKey(const nsIDHashKey& aToCopy) : mID(aToCopy.mID) {}
-  ~nsIDHashKey() {}
-
-  KeyType GetKey() const { return mID; }
-  bool KeyEquals(KeyTypePointer aKey) const { return aKey->Equals(mID); }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-
-    return mozilla::HashBytes(aKey, sizeof(KeyType));
-  }
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const nsID mID;
-};
-# 455 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsHashKeys.h"
-class nsDepCharHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const char* KeyType;
-  typedef const char* KeyTypePointer;
-
-  explicit nsDepCharHashKey(const char* aKey) : mKey(aKey) {}
-  nsDepCharHashKey(const nsDepCharHashKey& aToCopy) : mKey(aToCopy.mKey) {}
-  ~nsDepCharHashKey() {}
-
-  const char* GetKey() const { return mKey; }
-  bool KeyEquals(const char* aKey) const { return !strcmp(mKey, aKey); }
-
-  static const char* KeyToPointer(const char* aKey) { return aKey; }
-  static PLDHashNumber HashKey(const char* aKey)
-  {
-    return mozilla::HashString(aKey);
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const char* mKey;
-};
-
-
-
-
-
-
-class nsCharPtrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const char* KeyType;
-  typedef const char* KeyTypePointer;
-
-  explicit nsCharPtrHashKey(const char* aKey) : mKey(strdup(aKey)) {}
-  nsCharPtrHashKey(const nsCharPtrHashKey& aToCopy)
-    : mKey(strdup(aToCopy.mKey))
-  {
-  }
-
-  nsCharPtrHashKey(nsCharPtrHashKey&& aOther)
-    : mKey(aOther.mKey)
-  {
-    aOther.mKey = nullptr;
-  }
-
-  ~nsCharPtrHashKey()
-  {
-    if (mKey) {
-      free(const_cast<char*>(mKey));
-    }
-  }
-
-  const char* GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const { return !strcmp(mKey, aKey); }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return mozilla::HashString(aKey);
-  }
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(mKey);
-  }
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const char* mKey;
-};
-
-
-
-
-
-
-class nsUnicharPtrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const char16_t* KeyType;
-  typedef const char16_t* KeyTypePointer;
-
-  explicit nsUnicharPtrHashKey(const char16_t* aKey) : mKey(NS_strdup(aKey)) {}
-  nsUnicharPtrHashKey(const nsUnicharPtrHashKey& aToCopy)
-    : mKey(NS_strdup(aToCopy.mKey))
-  {
-  }
-
-  nsUnicharPtrHashKey(nsUnicharPtrHashKey&& aOther)
-    : mKey(aOther.mKey)
-  {
-    aOther.mKey = nullptr;
-  }
-
-  ~nsUnicharPtrHashKey()
-  {
-    if (mKey) {
-      free(const_cast<char16_t*>(mKey));
-    }
-  }
-
-  const char16_t* GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const { return !NS_strcmp(mKey, aKey); }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    return mozilla::HashString(aKey);
-  }
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(mKey);
-  }
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  const char16_t* mKey;
-};
-
-
-
-
-class nsHashableHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef nsIHashable* KeyType;
-  typedef const nsIHashable* KeyTypePointer;
-
-  explicit nsHashableHashKey(const nsIHashable* aKey)
-    : mKey(const_cast<nsIHashable*>(aKey))
-  {
-  }
-  nsHashableHashKey(const nsHashableHashKey& aToCopy) : mKey(aToCopy.mKey) {}
-  ~nsHashableHashKey() {}
-
-  nsIHashable* GetKey() const { return mKey; }
-
-  bool KeyEquals(const nsIHashable* aKey) const
-  {
-    bool eq;
-    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(mKey->Equals(const_cast<nsIHashable*>(aKey), &eq))), 1)))) {
-      return eq;
-    }
-    return false;
-  }
-
-  static const nsIHashable* KeyToPointer(nsIHashable* aKey) { return aKey; }
-  static PLDHashNumber HashKey(const nsIHashable* aKey)
-  {
-    uint32_t code = 8888;
-
-
-
-      const_cast<nsIHashable*>(aKey)->GetHashCode(&code);
-    do { } while(0);
-    return code;
-  }
-
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  nsCOMPtr<nsIHashable> mKey;
-};
-
-namespace mozilla {
-
-template <typename T>
-PLDHashNumber
-Hash(const T& aValue)
-{
-  return aValue.Hash();
-}
-
-}
-
-
-
-
-
-template<typename T>
-class nsGenericHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const T& KeyType;
-  typedef const T* KeyTypePointer;
-
-  explicit nsGenericHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
-  nsGenericHashKey(const nsGenericHashKey<T>& aOther) : mKey(aOther.mKey) {}
-
-  KeyType GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey) { return ::mozilla::Hash(*aKey); }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  T mKey;
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MemoryChecking.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h" 2
-# 76 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-template<class EntryType>
-class nsTHashtable
-{
-  typedef mozilla::fallible_t fallible_t;
-  static_assert(mozilla::IsPointer<typename EntryType::KeyTypePointer>::value,
-                "KeyTypePointer should be a pointer");
-
-public:
-
-
-  nsTHashtable()
-    : mTable(Ops(), sizeof(EntryType), PLDHashTable::kDefaultInitialLength)
-  {}
-  explicit nsTHashtable(uint32_t aInitLength)
-    : mTable(Ops(), sizeof(EntryType), aInitLength)
-  {}
-
-
-
-
-  ~nsTHashtable();
-
-  nsTHashtable(nsTHashtable<EntryType>&& aOther);
-
-
-
-
-
-  uint32_t GetGeneration() const { return mTable.Generation(); }
-
-
-
-
-  typedef typename EntryType::KeyType KeyType;
-
-
-
-
-  typedef typename EntryType::KeyTypePointer KeyTypePointer;
-
-
-
-
-
-  uint32_t Count() const { return mTable.EntryCount(); }
-
-
-
-
-  bool IsEmpty() const { return Count() == 0; }
-
-
-
-
-
-
-
-  EntryType* GetEntry(KeyType aKey) const
-  {
-    return static_cast<EntryType*>(
-      const_cast<PLDHashTable*>(&mTable)->Search(EntryType::KeyToPointer(aKey)));
-  }
-
-
-
-
-
-
-  bool Contains(KeyType aKey) const { return !!GetEntry(aKey); }
-
-
-
-
-
-
-
-  EntryType* PutEntry(KeyType aKey)
-  {
-
-    return static_cast<EntryType*>(mTable.Add(EntryType::KeyToPointer(aKey)));
-  }
-
-  __attribute__ ((warn_unused_result))
-  EntryType* PutEntry(KeyType aKey, const fallible_t&)
-  {
-    return static_cast<EntryType*>(mTable.Add(EntryType::KeyToPointer(aKey),
-                                              mozilla::fallible));
-  }
-
-
-
-
-
-  void RemoveEntry(KeyType aKey)
-  {
-    mTable.Remove(EntryType::KeyToPointer(aKey));
-  }
-
-
-
-
-
-  void RemoveEntry(EntryType* aEntry)
-  {
-    mTable.RemoveEntry(aEntry);
-  }
-# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-  void RawRemoveEntry(EntryType* aEntry)
-  {
-    mTable.RawRemove(aEntry);
-  }
-# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-  class Iterator : public PLDHashTable::Iterator
-  {
-  public:
-    typedef PLDHashTable::Iterator Base;
-
-    explicit Iterator(nsTHashtable* aTable) : Base(&aTable->mTable) {}
-    Iterator(Iterator&& aOther) : Base(aOther.mTable) {}
-    ~Iterator() {}
-
-    EntryType* Get() const { return static_cast<EntryType*>(Base::Get()); }
-
-  private:
-    Iterator() = delete;
-    Iterator(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&&) = delete;
-  };
-
-  Iterator Iter() { return Iterator(this); }
-
-  Iterator ConstIter() const
-  {
-    return Iterator(const_cast<nsTHashtable*>(this));
-  }
-
-
-
-
-
-
-  void Clear()
-  {
-    mTable.Clear();
-  }
-# 247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    size_t n = ShallowSizeOfExcludingThis(aMallocSizeOf);
-    for (auto iter = ConstIter(); !iter.Done(); iter.Next()) {
-      n += (*iter.Get()).SizeOfExcludingThis(aMallocSizeOf);
-    }
-    return n;
-  }
-
-
-
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-  void SwapElements(nsTHashtable<EntryType>& aOther)
-  {
-    do { } while (0);
-
-    mozilla::Swap(this->mTable, aOther.mTable);
-  }
-# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-protected:
-  PLDHashTable mTable;
-
-  static PLDHashNumber s_HashKey(const void* aKey);
-
-  static bool s_MatchEntry(const PLDHashEntryHdr* aEntry,
-                           const void* aKey);
-
-  static void s_CopyEntry(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
-                          PLDHashEntryHdr* aTo);
-
-  static void s_ClearEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
-
-  static void s_InitEntry(PLDHashEntryHdr* aEntry, const void* aKey);
-
-private:
-
-  nsTHashtable(nsTHashtable<EntryType>& aToCopy) = delete;
-
-
-
-
-  static const PLDHashTableOps* Ops();
-
-
-  nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>& aToEqual) = delete;
-};
-
-
-
-
-
-template<class EntryType>
-nsTHashtable<EntryType>::nsTHashtable(nsTHashtable<EntryType>&& aOther)
-  : mTable(mozilla::Move(aOther.mTable))
-{
-
-
-  do {} while (0);
-}
-
-template<class EntryType>
-nsTHashtable<EntryType>::~nsTHashtable()
-{
-}
-
-template<class EntryType>
-             const PLDHashTableOps*
-nsTHashtable<EntryType>::Ops()
-{
-
-
-
-  static const PLDHashTableOps sOps =
-  {
-    s_HashKey,
-    s_MatchEntry,
-    EntryType::ALLOW_MEMMOVE ? PLDHashTable::MoveEntryStub : s_CopyEntry,
-    s_ClearEntry,
-    s_InitEntry
-  };
-  return &sOps;
-}
-
-
-
-template<class EntryType>
-PLDHashNumber
-nsTHashtable<EntryType>::s_HashKey(const void* aKey)
-{
-  return EntryType::HashKey(static_cast<const KeyTypePointer>(aKey));
-}
-
-template<class EntryType>
-bool
-nsTHashtable<EntryType>::s_MatchEntry(const PLDHashEntryHdr* aEntry,
-                                      const void* aKey)
-{
-  return ((const EntryType*)aEntry)->KeyEquals(
-    static_cast<const KeyTypePointer>(aKey));
-}
-
-template<class EntryType>
-void
-nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable* aTable,
-                                     const PLDHashEntryHdr* aFrom,
-                                     PLDHashEntryHdr* aTo)
-{
-  EntryType* fromEntry =
-    const_cast<EntryType*>(static_cast<const EntryType*>(aFrom));
-
-  new (mozilla::KnownNotNull, aTo) EntryType(mozilla::Move(*fromEntry));
-
-  fromEntry->~EntryType();
-}
-
-template<class EntryType>
-void
-nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable* aTable,
-                                      PLDHashEntryHdr* aEntry)
-{
-  static_cast<EntryType*>(aEntry)->~EntryType();
-}
-
-template<class EntryType>
-void
-nsTHashtable<EntryType>::s_InitEntry(PLDHashEntryHdr* aEntry,
-                                     const void* aKey)
-{
-  new (mozilla::KnownNotNull, aEntry) EntryType(static_cast<KeyTypePointer>(aKey));
-}
-
-class nsCycleCollectionTraversalCallback;
-
-template<class EntryType>
-inline void
-ImplCycleCollectionUnlink(nsTHashtable<EntryType>& aField)
-{
-  aField.Clear();
-}
-
-template<class EntryType>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsTHashtable<EntryType>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  for (auto iter = aField.Iter(); !iter.Done(); iter.Next()) {
-    EntryType* entry = iter.Get();
-    ImplCycleCollectionTraverse(aCallback, *entry, aName, aFlags);
-  }
-}
-# 456 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsTHashtable.h"
-namespace detail {
-
-class VoidPtrHashKey : public nsPtrHashKey<const void>
-{
-  typedef nsPtrHashKey<const void> Base;
-
-public:
-  explicit VoidPtrHashKey(const void* aKey) : Base(aKey) {}
-};
-
-}
-
-
-
-
-
-template<typename T>
-class nsTHashtable<nsPtrHashKey<T>> : protected nsTHashtable<::detail::VoidPtrHashKey>
-{
-  typedef nsTHashtable<::detail::VoidPtrHashKey> Base;
-  typedef nsPtrHashKey<T> EntryType;
-
-
-
-  static_assert(sizeof(nsPtrHashKey<T>) == sizeof(::detail::VoidPtrHashKey),
-                "hash keys must be the same size");
-
-  nsTHashtable(const nsTHashtable& aOther) = delete;
-  nsTHashtable& operator=(const nsTHashtable& aOther) = delete;
-
-public:
-  nsTHashtable() = default;
-  explicit nsTHashtable(uint32_t aInitLength)
-    : Base(aInitLength)
-  {}
-
-  ~nsTHashtable() = default;
-
-  nsTHashtable(nsTHashtable&&) = default;
-
-
-  using Base::GetGeneration;
-  using Base::Count;
-  using Base::IsEmpty;
-  using Base::Clear;
-
-  using Base::ShallowSizeOfExcludingThis;
-  using Base::ShallowSizeOfIncludingThis;
-
-
-
-
-
-  EntryType* GetEntry(T* aKey) const
-  {
-    return reinterpret_cast<EntryType*>(Base::GetEntry(aKey));
-  }
-
-  bool Contains(T* aKey) const
-  {
-    return Base::Contains(aKey);
-  }
-
-  EntryType* PutEntry(T* aKey)
-  {
-    return reinterpret_cast<EntryType*>(Base::PutEntry(aKey));
-  }
-
-  __attribute__ ((warn_unused_result))
-  EntryType* PutEntry(T* aKey, const mozilla::fallible_t&)
-  {
-    return reinterpret_cast<EntryType*>(
-      Base::PutEntry(aKey, mozilla::fallible));
-  }
-
-  void RemoveEntry(T* aKey)
-  {
-    Base::RemoveEntry(aKey);
-  }
-
-  void RemoveEntry(EntryType* aEntry)
-  {
-    Base::RemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
-  }
-
-  void RawRemoveEntry(EntryType* aEntry)
-  {
-    Base::RawRemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
-  }
-
-  class Iterator : public Base::Iterator
-  {
-  public:
-    typedef nsTHashtable::Base::Iterator Base;
-
-    explicit Iterator(nsTHashtable* aTable) : Base(aTable) {}
-    Iterator(Iterator&& aOther) : Base(mozilla::Move(aOther)) {}
-    ~Iterator() = default;
-
-    EntryType* Get() const { return reinterpret_cast<EntryType*>(Base::Get()); }
-
-  private:
-    Iterator() = delete;
-    Iterator(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&) = delete;
-    Iterator& operator=(Iterator&&) = delete;
-  };
-
-  Iterator Iter() { return Iterator(this); }
-
-  Iterator ConstIter() const
-  {
-    return Iterator(const_cast<nsTHashtable*>(this));
-  }
-
-  void SwapElements(nsTHashtable& aOther)
-  {
-    Base::SwapElements(aOther);
-  }
-};
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h" 2
-
-
-template<class KeyClass, class DataType, class UserDataType>
-class nsBaseHashtable;
-
-
-
-
-
-
-template<class KeyClass, class DataType>
-class nsBaseHashtableET : public KeyClass
-{
-public:
-  DataType mData;
-  friend class nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
-
-private:
-  typedef typename KeyClass::KeyType KeyType;
-  typedef typename KeyClass::KeyTypePointer KeyTypePointer;
-
-  explicit nsBaseHashtableET(KeyTypePointer aKey);
-  nsBaseHashtableET(nsBaseHashtableET<KeyClass, DataType>&& aToMove);
-  ~nsBaseHashtableET();
-};
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-template<class KeyClass, class DataType, class UserDataType>
-class nsBaseHashtable
-  : protected nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>
-{
-  typedef mozilla::fallible_t fallible_t;
-
-public:
-  typedef typename KeyClass::KeyType KeyType;
-  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
-
-  using nsTHashtable<EntryType>::Contains;
-
-  nsBaseHashtable() {}
-  explicit nsBaseHashtable(uint32_t aInitLength)
-    : nsTHashtable<EntryType>(aInitLength)
-  {
-  }
-
-
-
-
-
-  uint32_t Count() const { return nsTHashtable<EntryType>::Count(); }
-# 84 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-  bool Get(KeyType aKey, UserDataType* aData) const
-  {
-    EntryType* ent = this->GetEntry(aKey);
-    if (!ent) {
-      return false;
-    }
-
-    if (aData) {
-      *aData = ent->mData;
-    }
-
-    return true;
-  }
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-  UserDataType Get(KeyType aKey) const
-  {
-    EntryType* ent = this->GetEntry(aKey);
-    if (!ent) {
-      return UserDataType{};
-    }
-
-    return ent->mData;
-  }
-
-
-
-
-
-
-  DataType& GetOrInsert(const KeyType& aKey)
-  {
-    EntryType* ent = this->GetEntry(aKey);
-    if (ent) {
-      return ent->mData;
-    }
-
-    ent = this->PutEntry(aKey);
-    return ent->mData;
-  }
-
-
-
-
-
-
-
-  void Put(KeyType aKey, const UserDataType& aData)
-  {
-    if (!Put(aKey, aData, mozilla::fallible)) {
-      NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
-    }
-  }
-
-  __attribute__ ((warn_unused_result)) bool Put(KeyType aKey, const UserDataType& aData,
-                        const fallible_t&)
-  {
-    EntryType* ent = this->PutEntry(aKey, mozilla::fallible);
-    if (!ent) {
-      return false;
-    }
-
-    ent->mData = aData;
-
-    return true;
-  }
-
-
-
-
-
-  void Remove(KeyType aKey) { this->RemoveEntry(aKey); }
-# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-  class Iterator : public PLDHashTable::Iterator
-  {
-  public:
-    typedef PLDHashTable::Iterator Base;
-
-    explicit Iterator(nsBaseHashtable* aTable) : Base(&aTable->mTable) {}
-    Iterator(Iterator&& aOther) : Base(aOther.mTable) {}
-    ~Iterator() {}
-
-    KeyType Key() const { return static_cast<EntryType*>(Get())->GetKey(); }
-    UserDataType UserData() const
-    {
-      return static_cast<EntryType*>(Get())->mData;
-    }
-    DataType& Data() const { return static_cast<EntryType*>(Get())->mData; }
-
-  private:
-    Iterator() = delete;
-    Iterator(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&) = delete;
-    Iterator& operator=(const Iterator&&) = delete;
-  };
-
-  Iterator Iter() { return Iterator(this); }
-
-  Iterator ConstIter() const
-  {
-    return Iterator(const_cast<nsBaseHashtable*>(this));
-  }
-
-
-
-
-  void Clear() { nsTHashtable<EntryType>::Clear(); }
-# 219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsBaseHashtable.h"
-  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return this->mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-
-
-  void SwapElements(nsBaseHashtable& aOther)
-  {
-    nsTHashtable<EntryType>::SwapElements(aOther);
-  }
-
-
-
-
-
-};
-
-
-
-
-
-template<class KeyClass, class DataType>
-nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(KeyTypePointer aKey)
-  : KeyClass(aKey)
-  , mData()
-{
-}
-
-template<class KeyClass, class DataType>
-nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(
-      nsBaseHashtableET<KeyClass, DataType>&& aToMove)
-  : KeyClass(mozilla::Move(aToMove))
-  , mData(mozilla::Move(aToMove.mData))
-{
-}
-
-template<class KeyClass, class DataType>
-nsBaseHashtableET<KeyClass, DataType>::~nsBaseHashtableET()
-{
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h" 2
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
-template<class KeyClass, class DataType>
-class nsDataHashtable
-  : public nsBaseHashtable<KeyClass, DataType, DataType>
-{
-private:
-  typedef nsBaseHashtable<KeyClass, DataType, DataType> BaseClass;
-
-public:
-  using typename BaseClass::KeyType;
-  using typename BaseClass::EntryType;
-
-  nsDataHashtable() {}
-  explicit nsDataHashtable(uint32_t aInitLength)
-    : BaseClass(aInitLength)
-  {
-  }
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDataHashtable.h"
-  mozilla::Maybe<DataType> GetAndRemove(KeyType aKey)
-  {
-    mozilla::Maybe<DataType> value;
-    if (EntryType* ent = this->GetEntry(aKey)) {
-      value.emplace(mozilla::Move(ent->mData));
-      this->RemoveEntry(ent);
-    }
-    return value;
-  }
-};
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h" 2
-
-class ContentUnbinder;
-class nsContentList;
-class nsDOMAttributeMap;
-class nsDOMTokenList;
-class nsIControllers;
-class nsICSSDeclaration;
-class nsIDocument;
-class nsDOMStringMap;
-class nsIURI;
-
-namespace mozilla {
-class DeclarationBlock;
-namespace dom {
-struct CustomElementData;
-class DOMIntersectionObserver;
-class Element;
-}
-}
-
-
-
-
-
-class nsNodeWeakReference final : public nsIWeakReference
-{
-public:
-  explicit nsNodeWeakReference(nsINode* aNode)
-    : mNode(aNode)
-  {
-  }
-
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-
-  virtual nsresult QueryReferent(const nsIID & uuid, void **result) override;
-  virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
-
-  void NoticeNodeDestruction()
-  {
-    mNode = nullptr;
-  }
-
-private:
-  ~nsNodeWeakReference();
-
-  nsINode* mNode;
-};
-
-
-
-
-class nsNodeSupportsWeakRefTearoff final : public nsISupportsWeakReference
-{
-public:
-  explicit nsNodeSupportsWeakRefTearoff(nsINode* aNode)
-    : mNode(aNode)
-  {
-  }
-
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-
-
-  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) override;
-
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsNodeSupportsWeakRefTearoff"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsNodeSupportsWeakRefTearoff>(p)->DeleteCycleCollectable(); } static nsNodeSupportsWeakRefTearoff* Downcast(nsISupports* s) { return static_cast<nsNodeSupportsWeakRefTearoff*>(static_cast<nsNodeSupportsWeakRefTearoff*>(s)); } static nsISupports* Upcast(nsNodeSupportsWeakRefTearoff *p) { return static_cast<nsISupports*>(static_cast<nsNodeSupportsWeakRefTearoff*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsNodeSupportsWeakRefTearoff::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-private:
-  ~nsNodeSupportsWeakRefTearoff() {}
-
-  nsCOMPtr<nsINode> mNode;
-};
-
-
-
-
-
-namespace mozilla {
-namespace dom {
-
-class ShadowRoot;
-
-class FragmentOrElement : public nsIContent
-{
-public:
-  explicit FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
-  explicit FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-
-  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
-
-
-  virtual uint32_t GetChildCount() const override;
-  virtual nsIContent *GetChildAt(uint32_t aIndex) const override;
-  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const override;
-  virtual int32_t IndexOf(const nsINode* aPossibleChild) const override;
-  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
-                                 bool aNotify) override;
-  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) override;
-  virtual void GetTextContentInternal(nsAString& aTextContent,
-                                      mozilla::OOMReporter& aError) override;
-  virtual void SetTextContentInternal(const nsAString& aTextContent,
-                                      mozilla::ErrorResult& aError) override;
-
-
-  virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) override;
-  virtual const nsTextFragment *GetText() override;
-  virtual uint32_t TextLength() const override;
-  virtual nsresult SetText(const char16_t* aBuffer, uint32_t aLength,
-                           bool aNotify) override;
-
-  nsresult SetText(const nsAString& aStr, bool aNotify)
-  {
-    return SetText(aStr.BeginReading(), aStr.Length(), aNotify);
-  }
-  virtual nsresult AppendText(const char16_t* aBuffer, uint32_t aLength,
-                              bool aNotify) override;
-  virtual bool TextIsOnlyWhitespace() override;
-  virtual bool ThreadSafeTextIsOnlyWhitespace() const override;
-  virtual bool HasTextForTranslation() override;
-  virtual void AppendTextTo(nsAString& aResult) override;
-  __attribute__ ((warn_unused_result))
-  virtual bool AppendTextTo(nsAString& aResult, const mozilla::fallible_t&) override;
-  virtual nsIContent *GetBindingParent() const override;
-  virtual nsXBLBinding *GetXBLBinding() const override;
-  virtual void SetXBLBinding(nsXBLBinding* aBinding,
-                             nsBindingManager* aOldBindingManager = nullptr) override;
-  virtual ShadowRoot *GetContainingShadow() const override;
-  virtual nsTArray<nsIContent*> &DestInsertionPoints() override;
-  virtual nsTArray<nsIContent*> *GetExistingDestInsertionPoints() const override;
-  virtual void SetShadowRoot(ShadowRoot* aBinding) override;
-  virtual nsIContent *GetXBLInsertionParent() const override;
-  virtual void SetXBLInsertionParent(nsIContent* aContent) override;
-  virtual bool IsLink(nsIURI** aURI) const override;
-
-  virtual void DestroyContent() override;
-  virtual void SaveSubtreeState() override;
-
-  virtual nsresult WalkContentStyleRules(nsRuleWalker* aRuleWalker) override;
-
-  nsIHTMLCollection* Children();
-  uint32_t ChildElementCount()
-  {
-    return Children()->Length();
-  }
-
-
-
-
-
-
-
-  void SetIsElementInStyleScopeFlagOnSubtree(bool aInStyleScope);
-
-public:
-
-
-
-
-  static void FireNodeInserted(nsIDocument* aDoc,
-                               nsINode* aParent,
-                               nsTArray<nsCOMPtr<nsIContent> >& aNodes);
-
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "FragmentOrElement"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<FragmentOrElement>(p)->DeleteCycleCollectable(); } static FragmentOrElement* Downcast(nsISupports* s) { return static_cast<FragmentOrElement*>(static_cast<FragmentOrElement*>(s)); } static nsISupports* Upcast(FragmentOrElement *p) { return static_cast<nsISupports*>(static_cast<FragmentOrElement*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &FragmentOrElement::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-
-
-  void FireNodeRemovedForChildren();
-
-  virtual bool OwnedOnlyByTheDOMTree() override
-  {
-    uint32_t rc = mRefCnt.get();
-    if (GetParent()) {
-      --rc;
-    }
-    rc -= mAttrsAndChildren.ChildCount();
-    return rc == 0;
-  }
-
-  virtual bool IsPurple() override
-  {
-    return mRefCnt.IsPurple();
-  }
-
-  virtual void RemovePurple() override
-  {
-    mRefCnt.RemovePurple();
-  }
-
-  static void ClearContentUnbinder();
-  static bool CanSkip(nsINode* aNode, bool aRemovingAllowed);
-  static bool CanSkipInCC(nsINode* aNode);
-  static bool CanSkipThis(nsINode* aNode);
-  static void RemoveBlackMarkedNode(nsINode* aNode);
-  static void MarkNodeChildren(nsINode* aNode);
-  static void InitCCCallbacks();
-  static void MarkUserData(void* aObject, nsIAtom* aKey, void* aChild,
-                           void *aData);
-
-
-
-
-  static bool IsHTMLVoid(nsIAtom* aLocalName);
-protected:
-  virtual ~FragmentOrElement();
-
-
-
-
-
-  nsresult CopyInnerTo(FragmentOrElement* aDest);
-
-public:
-# 252 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FragmentOrElement.h"
-  class nsDOMSlots : public nsINode::nsSlots
-  {
-  public:
-    nsDOMSlots();
-    virtual ~nsDOMSlots();
-
-    void Traverse(nsCycleCollectionTraversalCallback &cb, bool aIsXUL);
-    void Unlink(bool aIsXUL);
-
-    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-
-
-
-
-
-    nsCOMPtr<nsICSSDeclaration> mStyle;
-
-
-
-
-
-    nsDOMStringMap* mDataset;
-
-
-
-
-
-    nsCOMPtr<nsICSSDeclaration> mSMILOverrideStyle;
-
-
-
-
-    RefPtr<mozilla::DeclarationBlock> mSMILOverrideStyleDeclaration;
-
-
-
-
-
-    RefPtr<nsDOMAttributeMap> mAttributeMap;
-
-    union {
-
-
-
-
-      nsIContent* mBindingParent;
-
-
-
-
-      nsIControllers* mControllers;
-    };
-
-
-
-
-    RefPtr<nsContentList> mChildrenList;
-
-
-
-
-    RefPtr<nsDOMTokenList> mClassList;
-
-
-
-
-    RefPtr<ShadowRoot> mShadowRoot;
-
-
-
-
-    RefPtr<ShadowRoot> mContainingShadow;
-
-
-
-
-
-    nsTArray<nsIContent*> mDestInsertionPoints;
-
-
-
-
-    RefPtr<nsXBLBinding> mXBLBinding;
-
-
-
-
-    nsCOMPtr<nsIContent> mXBLInsertionParent;
-
-
-
-
-    RefPtr<CustomElementData> mCustomElementData;
-
-
-
-
-    nsDataHashtable<nsRefPtrHashKey<DOMIntersectionObserver>, int32_t>
-      mRegisteredIntersectionObservers;
-  };
-
-protected:
-  void GetMarkup(bool aIncludeSelf, nsAString& aMarkup);
-  void SetInnerHTMLInternal(const nsAString& aInnerHTML, ErrorResult& aError);
-
-
-  virtual nsINode::nsSlots* CreateSlots() override;
-
-  nsDOMSlots *DOMSlots()
-  {
-    return static_cast<nsDOMSlots*>(Slots());
-  }
-
-  nsDOMSlots *GetExistingDOMSlots() const
-  {
-    return static_cast<nsDOMSlots*>(GetExistingSlots());
-  }
-
-
-
-
-
-
-
-  void SetIsElementInStyleScopeFlagOnShadowTree(bool aInStyleScope);
-
-  friend class ::ContentUnbinder;
-
-
-
-  nsAttrAndChildArray mAttrsAndChildren;
-};
-
-}
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
-class nsIContent;
-class nsAString;
-class nsAttrValue;
-class nsTextNode;
-
-namespace mozilla {
-namespace dom {
-class Element;
-}
-}
-
-namespace mozilla {
-
-enum Directionality : uint8_t {
-  eDir_NotSet,
-  eDir_RTL,
-  eDir_LTR,
-  eDir_Auto
-};
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
-Directionality RecomputeDirectionality(mozilla::dom::Element* aElement,
-                                       bool aNotify = true);
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
-void SetDirectionalityOnDescendants(mozilla::dom::Element* aElement,
-                                    Directionality aDir,
-                                    bool aNotify = true);
-
-
-
-
-
-
-
-void WalkDescendantsResetAutoDirection(mozilla::dom::Element* aElement);
-# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
-void WalkDescendantsSetDirAuto(mozilla::dom::Element* aElement,
-                               bool aNotify = true);
-
-
-
-
-
-
-void WalkDescendantsClearAncestorDirAuto(mozilla::dom::Element* aElement);
-
-
-
-
-
-
-
-bool TextNodeWillChangeDirection(nsIContent* aTextNode, Directionality* aOldDir,
-                                 uint32_t aOffset);
-
-
-
-
-
-void TextNodeChangedDirection(nsTextNode* aTextNode, Directionality aOldDir,
-                              bool aNotify);
-
-
-
-
-
-void SetDirectionFromNewTextNode(nsTextNode* aTextNode);
-
-
-
-
-
-
-
-void ResetDirectionSetByTextNode(nsTextNode* aTextNode);
-
-
-
-
-
-void SetDirectionalityFromValue(mozilla::dom::Element* aElement,
-                                const nsAString& aValue,
-                                bool aNotify);
-# 125 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DirectionalityUtils.h"
-void OnSetDirAttr(mozilla::dom::Element* aElement,
-                  const nsAttrValue* aNewValue,
-                  bool hadValidDir,
-                  bool hadDirAuto,
-                  bool aNotify);
-
-
-
-
-
-
-void SetDirOnBind(mozilla::dom::Element* aElement, nsIContent* aParent);
-
-
-
-
-
-
-void ResetDir(mozilla::dom::Element* aElement);
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h"
-class nsIDOMMozNamedAttrMap;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMElement.h"
-class nsIDOMElement : public nsIDOMNode {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetTagName(nsAString & aTagName) = 0;
-
-
-  virtual nsresult GetAttributes(nsIDOMMozNamedAttrMap * *aAttributes) = 0;
-
-
-  virtual nsresult GetAttribute(const nsAString & name, nsAString & _retval) = 0;
-
-
-  virtual nsresult SetAttribute(const nsAString & name, const nsAString & value) = 0;
-
-
-  virtual nsresult HasAttribute(const nsAString & name, bool *_retval) = 0;
-
-
-  virtual nsresult GetAttributeNode(const nsAString & name, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult GetAttributeNodeNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIDOMElement::COMTypeInfo<nsIDOMElement, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMElement::COMTypeInfo<nsIDOMElement, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x6289999b, 0x1008, 0x4269, { 0xb4, 0x2a, 0x41, 0x3e, 0xc5, 0xa9, 0xd3, 0xf4 }};
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
-class nsIContent;
-class nsIDocShell;
-class nsIInputStream;
-class nsIRequest;
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
-class nsILinkHandler : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
-  virtual nsresult OnLinkClick(nsIContent* aContent,
-                         nsIURI* aURI,
-                         const char16_t* aTargetSpec,
-                         const nsAString& aFileName,
-                         nsIInputStream* aPostDataStream,
-                         nsIInputStream* aHeadersDataStream,
-                         bool aIsTrusted,
-                         nsIPrincipal* aTriggeringPrincipal) = 0;
-# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
-  virtual nsresult OnLinkClickSync(nsIContent* aContent,
-                             nsIURI* aURI,
-                             const char16_t* aTargetSpec,
-                             const nsAString& aFileName,
-                             nsIInputStream* aPostDataStream = 0,
-                             nsIInputStream* aHeadersDataStream = 0,
-                             bool aNoOpenerImplied = false,
-                             nsIDocShell** aDocShell = 0,
-                             nsIRequest** aRequest = 0,
-                             nsIPrincipal* aTriggeringPrincipal = nullptr) = 0;
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILinkHandler.h"
-  virtual nsresult OnOverLink(nsIContent* aContent,
-                        nsIURI* aURLSpec,
-                        const char16_t* aTargetSpec) = 0;
-
-
-
-
-  virtual nsresult OnLeaveLink() = 0;
-};
-
-template<typename T> struct nsILinkHandler::COMTypeInfo<nsILinkHandler, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILinkHandler::COMTypeInfo<nsILinkHandler, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xceb9aade, 0x43da, 0x4f1a, { 0xac, 0x8a, 0xc7, 0x09, 0xfb, 0x22, 0x46, 0x64 } };
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNodeList.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMNodeList.h"
-class nsIDOMNodeList : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) = 0;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-};
-
-  template<typename T> struct nsIDOMNodeList::COMTypeInfo<nsIDOMNodeList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMNodeList::COMTypeInfo<nsIDOMNodeList, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x450cf0ba, 0xde90, 0x4f86, { 0x85, 0xbf, 0xe1, 0x0c, 0xc8, 0xb8, 0x71, 0x3f }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINodeList.h" 2
-
-
-
-
-
-
-
-
-class nsIContent;
-class nsINode;
-
-
-
-
-class nsINodeList : public nsIDOMNodeList,
-                    public nsWrapperCache
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-  virtual int32_t IndexOf(nsIContent* aContent) = 0;
-
-
-
-
-  virtual nsINode* GetParentObject() = 0;
-
-  using nsIDOMNodeList::Item;
-
-  uint32_t Length()
-  {
-    uint32_t length;
-    GetLength(&length);
-    return length;
-  }
-  virtual nsIContent* Item(uint32_t aIndex) = 0;
-  nsIContent* IndexedGetter(uint32_t aIndex, bool& aFound)
-  {
-    nsIContent* item = Item(aIndex);
-    aFound = !!item;
-    return item;
-  }
-};
-
-
-
-
-template<typename T> struct nsINodeList::COMTypeInfo<nsINodeList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINodeList::COMTypeInfo<nsINodeList, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xadb5e54c, 0x6e96, 0x4102, { 0x8d, 0x40, 0xe0, 0x12, 0x3d, 0xcf, 0x48, 0x7a } };
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h" 2
-
-namespace mozilla {
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/FlushType.h"
-enum class FlushType : uint8_t {
-  None = 0,
-  Content = 1,
-  ContentAndNotify = 2,
-
-
-  Style = 3,
-  Frames = Style,
-  InterruptibleLayout = 4,
-
-
-  Layout = 5,
-
-  Display = 6,
-
-  Count
-};
-
-struct ChangesToFlush {
-  ChangesToFlush(FlushType aFlushType, bool aFlushAnimations)
-    : mFlushType(aFlushType)
-    , mFlushAnimations(aFlushAnimations)
-  {}
-
-  FlushType mFlushType;
-  bool mFlushAnimations;
-};
-
-}
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAttribute.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAttribute.h"
-class nsDOMAttributeMap;
-
-
-
-
-
-class nsIAttribute : public nsINode
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  virtual void SetMap(nsDOMAttributeMap *aMap) = 0;
-
-  nsDOMAttributeMap *GetMap()
-  {
-    return mAttrMap;
-  }
-
-  mozilla::dom::NodeInfo *NodeInfo() const
-  {
-    return mNodeInfo;
-  }
-
-
-
-
-
-  virtual nsresult SetOwnerDocument(nsIDocument* aDocument) = 0;
-
-protected:
-
-  nsIAttribute(nsDOMAttributeMap *aAttrMap,
-               already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
-
-  virtual ~nsIAttribute();
-
-  RefPtr<nsDOMAttributeMap> mAttrMap;
-};
-
-template<typename T> struct nsIAttribute::COMTypeInfo<nsIAttribute, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAttribute::COMTypeInfo<nsIAttribute, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x84d43da7, 0xb45d, 0x47ae, { 0x8f, 0xbf, 0x95, 0x26, 0x78, 0x4d, 0x5e, 0x47 } };
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMAttr.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMAttr.h"
-class nsIDOMAttr : public nsIDOMNode {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetName(nsAString & aName) = 0;
-
-
-  virtual nsresult GetSpecified(bool *aSpecified) = 0;
-
-
-  virtual nsresult GetValue(nsAString & aValue) = 0;
-  virtual nsresult SetValue(const nsAString & aValue) = 0;
-
-
-  virtual nsresult GetOwnerElement(nsIDOMElement * *aOwnerElement) = 0;
-
-
-  virtual nsresult GetIsId(bool *aIsId) = 0;
-
-};
-
-  template<typename T> struct nsIDOMAttr::COMTypeInfo<nsIDOMAttr, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMAttr::COMTypeInfo<nsIDOMAttr, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x7db491e8, 0xa3a3, 0x4432, { 0xad, 0x67, 0xe6, 0xc3, 0x3e, 0x24, 0xac, 0x6d }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCharacterData.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCharacterData.h"
-class nsIDOMCharacterData : public nsIDOMNode {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetData(nsAString & aData) = 0;
-  virtual nsresult SetData(const nsAString & aData) = 0;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-
-  virtual nsresult SubstringData(uint32_t offset, uint32_t count, nsAString & _retval) = 0;
-
-
-  virtual nsresult AppendData(const nsAString & arg) = 0;
-
-
-  virtual nsresult InsertData(uint32_t offset, const nsAString & arg) = 0;
-
-
-  virtual nsresult DeleteData(uint32_t offset, uint32_t count) = 0;
-
-
-  virtual nsresult ReplaceData(uint32_t offset, uint32_t count, const nsAString & arg) = 0;
-
-};
-
-  template<typename T> struct nsIDOMCharacterData::COMTypeInfo<nsIDOMCharacterData, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMCharacterData::COMTypeInfo<nsIDOMCharacterData, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4109a2d2, 0xe7af, 0x445d, { 0xbb, 0x72, 0xc7, 0xc9, 0xb8, 0x75, 0xf3, 0x5e }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMText.h"
-class nsIDOMText : public nsIDOMCharacterData {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult SplitText(uint32_t offset, nsIDOMText * *_retval) = 0;
-
-
-  virtual nsresult GetWholeText(nsAString & aWholeText) = 0;
-
-};
-
-  template<typename T> struct nsIDOMText::COMTypeInfo<nsIDOMText, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMText::COMTypeInfo<nsIDOMText, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x67273994, 0x6aff, 0x4091, { 0x9d, 0xe9, 0xb7, 0x88, 0xa2, 0x49, 0xf7, 0x83 }};
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStubMutationObserver.h" 1
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStubMutationObserver.h"
-class nsStubMutationObserver : public nsIMutationObserver {
-public:
-  virtual void CharacterDataWillChange(nsIDocument* aDocument, nsIContent* aContent, CharacterDataChangeInfo* aInfo) override; virtual void CharacterDataChanged(nsIDocument* aDocument, nsIContent* aContent, CharacterDataChangeInfo* aInfo) override; virtual void AttributeWillChange(nsIDocument* aDocument, mozilla::dom::Element* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType, const nsAttrValue* aNewValue) override; virtual void NativeAnonymousChildListChange(nsIDocument* aDocument, nsIContent* aContent, bool aIsRemove) override; virtual void AttributeChanged(nsIDocument* aDocument, mozilla::dom::Element* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType, const nsAttrValue* aOldValue) override; virtual void ContentAppended(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aFirstNewContent, int32_t aNewIndexInContainer) override; virtual void ContentInserted(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t aIndexInContainer) override; virtual void ContentRemoved(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t aIndexInContainer, nsIContent* aPreviousSibling) override; virtual void NodeWillBeDestroyed(const nsINode* aNode) override; virtual void ParentChainChanged(nsIContent *aContent) override;
-};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Attr.h" 2
-
-class nsIDocument;
-
-namespace mozilla {
-class EventChainPreVisitor;
-namespace dom {
-
-
-
-class Attr final : public nsIAttribute,
-                   public nsIDOMAttr
-{
-  virtual ~Attr() {}
-
-public:
-  Attr(nsDOMAttributeMap* aAttrMap,
-       already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
-       const nsAString& aValue);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-
-
-  virtual nsresult GetNodeName(nsAString& aNodeName) final override { aNodeName = nsINode::NodeName(); return NS_OK; } virtual nsresult GetNodeValue(nsAString& aNodeValue) final override { nsINode::GetNodeValue(aNodeValue); return NS_OK; } virtual nsresult SetNodeValue(const nsAString& aNodeValue) final override { mozilla::ErrorResult rv; nsINode::SetNodeValue(aNodeValue, rv); return rv.StealNSResult(); } virtual nsresult GetNodeType(uint16_t* aNodeType) final override { *aNodeType = nsINode::NodeType(); return NS_OK; } virtual nsresult GetParentNode(nsIDOMNode** aParentNode) final override { return nsINode::GetParentNode(aParentNode); } virtual nsresult GetChildNodes(nsIDOMNodeList** aChildNodes) final override { return nsINode::GetChildNodes(aChildNodes); } virtual nsresult GetFirstChild(nsIDOMNode** aFirstChild) final override { return nsINode::GetFirstChild(aFirstChild); } virtual nsresult GetLastChild(nsIDOMNode** aLastChild) final override { return nsINode::GetLastChild(aLastChild); } virtual nsresult GetPreviousSibling(nsIDOMNode** aPreviousSibling) final override { return nsINode::GetPreviousSibling(aPreviousSibling); } virtual nsresult GetNextSibling(nsIDOMNode** aNextSibling) final override { return nsINode::GetNextSibling(aNextSibling); } virtual nsresult GetOwnerDocument(nsIDOMDocument** aOwnerDocument) final override { return nsINode::GetOwnerDocument(aOwnerDocument); } virtual nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aResult) final override { return nsINode::RemoveChild(aOldChild, aResult); } virtual nsresult HasChildNodes(bool* aResult) final override { *aResult = nsINode::HasChildNodes(); return NS_OK; } virtual nsresult CloneNode(bool aDeep, uint8_t aArgc, nsIDOMNode** aResult) final override { if (aArgc == 0) { aDeep = true; } mozilla::ErrorResult rv; nsCOMPtr<nsINode> clone = nsINode::CloneNode(aDeep, rv); if (rv.Failed()) { return rv.StealNSResult(); } *aResult = clone.forget().take()->AsDOMNode(); return NS_OK; } virtual nsresult GetNamespaceURI(nsAString& aNamespaceURI) final override { nsINode::GetNamespaceURI(aNamespaceURI); return NS_OK; } virtual nsresult GetPrefix(nsAString& aPrefix) final override { nsINode::GetPrefix(aPrefix); return NS_OK; } virtual nsresult GetLocalName(nsAString& aLocalName) final override { aLocalName = nsINode::LocalName(); return NS_OK; } virtual nsresult GetTextContent(nsAString& aTextContent) final override { mozilla::ErrorResult rv; nsINode::GetTextContent(aTextContent, rv); return rv.StealNSResult(); } virtual nsresult SetTextContent(const nsAString& aTextContent) final override { mozilla::ErrorResult rv; nsINode::SetTextContent(aTextContent, rv); return rv.StealNSResult(); }
-  virtual void GetTextContentInternal(nsAString& aTextContent,
-                                      OOMReporter& aError) override;
-  virtual void SetTextContentInternal(const nsAString& aTextContent,
-                                      ErrorResult& aError) override;
-  virtual void GetNodeValueInternal(nsAString& aNodeValue) override;
-  virtual void SetNodeValueInternal(const nsAString& aNodeValue,
-                                    ErrorResult& aError) override;
-
-
-  virtual nsresult GetName(nsAString & aName) override; virtual nsresult GetSpecified(bool *aSpecified) override; virtual nsresult GetValue(nsAString & aValue) override; virtual nsresult SetValue(const nsAString & aValue) override; virtual nsresult GetOwnerElement(nsIDOMElement * *aOwnerElement) override; virtual nsresult GetIsId(bool *aIsId) override;
-
-  virtual nsresult GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
-
-
-  void SetMap(nsDOMAttributeMap *aMap) override;
-  Element* GetElement() const;
-  nsresult SetOwnerDocument(nsIDocument* aDocument) override;
-
-
-  virtual bool IsNodeOfType(uint32_t aFlags) const override;
-  virtual uint32_t GetChildCount() const override;
-  virtual nsIContent *GetChildAt(uint32_t aIndex) const override;
-  virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const override;
-  virtual int32_t IndexOf(const nsINode* aPossibleChild) const override;
-  virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
-                                 bool aNotify) override;
-  virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) override;
-  virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const override;
-  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
-
-  static void Initialize();
-  static void Shutdown();
-
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "Attr"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<Attr>(p)->DeleteCycleCollectable(); } static Attr* Downcast(nsISupports* s) { return static_cast<Attr*>(static_cast<nsIAttribute*>(s)); } static nsISupports* Upcast(Attr *p) { return static_cast<nsISupports*>(static_cast<nsIAttribute*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &Attr::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  virtual nsIDOMNode* AsDOMNode() override { return this; }
-
-
-  virtual JSObject* WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
-
-
-
-
-  void SetValue(const nsAString& aValue, ErrorResult& aRv);
-
-  bool Specified() const;
-
-
-
-
-
-  Element* GetOwnerElement(ErrorResult& aRv);
-
-protected:
-  virtual Element* GetNameSpaceElement() override
-  {
-    return GetElement();
-  }
-
-  static bool sInitialized;
-
-private:
-  nsString mValue;
-};
-
-}
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMMozNamedAttrMap.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMMozNamedAttrMap.h"
-class nsIDOMMozNamedAttrMap : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetNamedItem(const nsAString & name, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult RemoveNamedItem(const nsAString & name, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult Item(uint32_t index, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-
-  virtual nsresult GetNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr * *_retval) = 0;
-
-
-  virtual nsresult RemoveNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIDOMMozNamedAttrMap::COMTypeInfo<nsIDOMMozNamedAttrMap, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMMozNamedAttrMap::COMTypeInfo<nsIDOMMozNamedAttrMap, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcb5564cd, 0x26ec, 0x418f, { 0xa6, 0xd6, 0x1d, 0x57, 0xcd, 0x2c, 0x97, 0x1c }};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h"
-template<class KeyClass, class PtrType>
-class nsRefPtrHashtable
-  : public nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*>
-{
-public:
-  typedef typename KeyClass::KeyType KeyType;
-  typedef PtrType* UserDataType;
-  typedef nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*> base_type;
-
-  nsRefPtrHashtable() {}
-  explicit nsRefPtrHashtable(uint32_t aInitLength)
-    : nsBaseHashtable<KeyClass, RefPtr<PtrType>, PtrType*>(aInitLength)
-  {
-  }
-
-
-
-
-
-
-  bool Get(KeyType aKey, UserDataType* aData) const;
-
-
-
-
-
-
-
-  PtrType* GetWeak(KeyType aKey, bool* aFound = nullptr) const;
-
-
-  using base_type::Put;
-
-  void Put(KeyType aKey, already_AddRefed<PtrType> aData);
-
-  __attribute__ ((warn_unused_result)) bool Put(KeyType aKey, already_AddRefed<PtrType> aData,
-                        const mozilla::fallible_t&);
-
-
-  using base_type::Remove;
-# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRefPtrHashtable.h"
-  bool Remove(KeyType aKey, UserDataType* aData);
-};
-
-template<typename K, typename T>
-inline void
-ImplCycleCollectionUnlink(nsRefPtrHashtable<K, T>& aField)
-{
-  aField.Clear();
-}
-
-template<typename K, typename T>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsRefPtrHashtable<K, T>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  for (auto iter = aField.ConstIter(); !iter.Done(); iter.Next()) {
-    CycleCollectionNoteChild(aCallback, iter.UserData(), aName, aFlags);
-  }
-}
-
-
-
-
-
-template<class KeyClass, class PtrType>
-bool
-nsRefPtrHashtable<KeyClass, PtrType>::Get(KeyType aKey,
-                                          UserDataType* aRefPtr) const
-{
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-
-  if (ent) {
-    if (aRefPtr) {
-      *aRefPtr = ent->mData;
-
-      ns_if_addref(*aRefPtr);
-    }
-
-    return true;
-  }
-
-
-
-  if (aRefPtr) {
-    *aRefPtr = nullptr;
-  }
-
-  return false;
-}
-
-template<class KeyClass, class PtrType>
-PtrType*
-nsRefPtrHashtable<KeyClass, PtrType>::GetWeak(KeyType aKey, bool* aFound) const
-{
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-
-  if (ent) {
-    if (aFound) {
-      *aFound = true;
-    }
-
-    return ent->mData;
-  }
-
-
-  if (aFound) {
-    *aFound = false;
-  }
-
-  return nullptr;
-}
-
-template<class KeyClass, class PtrType>
-void
-nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
-                                          already_AddRefed<PtrType> aData)
-{
-  if (!Put(aKey, mozilla::Move(aData), mozilla::fallible)) {
-    NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
-  }
-}
-
-template<class KeyClass, class PtrType>
-bool
-nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
-                                          already_AddRefed<PtrType> aData,
-                                          const mozilla::fallible_t&)
-{
-  typename base_type::EntryType* ent = this->PutEntry(aKey);
-
-  if (!ent) {
-    return false;
-  }
-
-  ent->mData = aData;
-
-  return true;
-}
-
-template<class KeyClass, class PtrType>
-bool
-nsRefPtrHashtable<KeyClass, PtrType>::Remove(KeyType aKey,
-                                             UserDataType* aRefPtr)
-{
-  do { } while (0);
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-
-  if (ent) {
-    ent->mData.forget(aRefPtr);
-    this->Remove(aKey);
-    return true;
-  }
-
-
-
-  *aRefPtr = nullptr;
-  return false;
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
-
-
-
-class nsIAtom;
-class nsIDocument;
-
-
-
-
-class nsAttrKey
-{
-public:
-
-
-
-  int32_t mNamespaceID;
-
-
-
-
-
-  void* mLocalName;
-
-  nsAttrKey(int32_t aNs, nsIAtom* aName)
-    : mNamespaceID(aNs), mLocalName(aName) {}
-
-  nsAttrKey(const nsAttrKey& aAttr)
-    : mNamespaceID(aAttr.mNamespaceID), mLocalName(aAttr.mLocalName) {}
-};
-
-
-
-
-class nsAttrHashKey : public PLDHashEntryHdr
-{
-public:
-  typedef const nsAttrKey& KeyType;
-  typedef const nsAttrKey* KeyTypePointer;
-
-  explicit nsAttrHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
-  nsAttrHashKey(const nsAttrHashKey& aCopy) : mKey(aCopy.mKey) {}
-  ~nsAttrHashKey() {}
-
-  KeyType GetKey() const { return mKey; }
-  bool KeyEquals(KeyTypePointer aKey) const
-    {
-      return mKey.mLocalName == aKey->mLocalName &&
-             mKey.mNamespaceID == aKey->mNamespaceID;
-    }
-
-  static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-    {
-      if (!aKey)
-        return 0;
-
-      return mozilla::HashGeneric(aKey->mNamespaceID, aKey->mLocalName);
-    }
-  enum { ALLOW_MEMMOVE = true };
-
-private:
-  nsAttrKey mKey;
-};
-
-
-class nsDOMAttributeMap final : public nsIDOMMozNamedAttrMap
-                              , public nsWrapperCache
-{
-public:
-  typedef mozilla::dom::Attr Attr;
-  typedef mozilla::dom::Element Element;
-  typedef mozilla::ErrorResult ErrorResult;
-
-  explicit nsDOMAttributeMap(Element *aContent);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsDOMAttributeMap"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsDOMAttributeMap>(p)->DeleteCycleCollectable(); } static nsDOMAttributeMap* Downcast(nsISupports* s) { return static_cast<nsDOMAttributeMap*>(static_cast<nsDOMAttributeMap*>(s)); } static nsISupports* Upcast(nsDOMAttributeMap *p) { return static_cast<nsISupports*>(static_cast<nsDOMAttributeMap*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsDOMAttributeMap::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  virtual nsresult GetNamedItem(const nsAString & name, nsIDOMAttr * *_retval) override; virtual nsresult SetNamedItem(nsIDOMAttr *arg, nsIDOMAttr * *_retval) override; virtual nsresult RemoveNamedItem(const nsAString & name, nsIDOMAttr * *_retval) override; virtual nsresult Item(uint32_t index, nsIDOMAttr * *_retval) override; virtual nsresult GetLength(uint32_t *aLength) override; virtual nsresult GetNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) override; virtual nsresult SetNamedItemNS(nsIDOMAttr *arg, nsIDOMAttr * *_retval) override; virtual nsresult RemoveNamedItemNS(const nsAString & namespaceURI, const nsAString & localName, nsIDOMAttr * *_retval) override;
-
-  void DropReference();
-
-  Element* GetContent()
-  {
-    return mContent;
-  }
-
-
-
-
-
-  nsresult SetOwnerDocument(nsIDocument* aDocument);
-
-
-
-
-
-  void DropAttribute(int32_t aNamespaceID, nsIAtom* aLocalName);
-# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h"
-  uint32_t Count() const;
-
-  typedef nsRefPtrHashtable<nsAttrHashKey, Attr> AttrCache;
-
-  static void BlastSubtreeToPieces(nsINode *aNode);
-
-  Element* GetParentObject() const
-  {
-    return mContent;
-  }
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
-
-
-  Attr* GetNamedItem(const nsAString& aAttrName);
-  Attr* NamedGetter(const nsAString& aAttrName, bool& aFound);
-  already_AddRefed<Attr>
-  RemoveNamedItem(mozilla::dom::NodeInfo* aNodeInfo, ErrorResult& aError);
-  already_AddRefed<Attr>
-  RemoveNamedItem(const nsAString& aName, ErrorResult& aError);
-
-  Attr* Item(uint32_t aIndex);
-  Attr* IndexedGetter(uint32_t aIndex, bool& aFound);
-  uint32_t Length() const;
-
-  Attr*
-  GetNamedItemNS(const nsAString& aNamespaceURI,
-                 const nsAString& aLocalName);
-  already_AddRefed<Attr>
-  SetNamedItemNS(Attr& aNode, ErrorResult& aError);
-  already_AddRefed<Attr>
-  RemoveNamedItemNS(const nsAString& aNamespaceURI, const nsAString& aLocalName,
-                    ErrorResult& aError);
-
-  void
-  GetSupportedNames(nsTArray<nsString>& aNames);
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-protected:
-  virtual ~nsDOMAttributeMap();
-
-private:
-  nsCOMPtr<Element> mContent;
-
-
-
-
-  AttrCache mAttributeCache;
-
-  already_AddRefed<mozilla::dom::NodeInfo>
-  GetAttrNodeInfo(const nsAString& aNamespaceURI,
-                  const nsAString& aLocalName);
-
-  Attr* GetAttribute(mozilla::dom::NodeInfo* aNodeInfo);
-};
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDOMAttributeMap.h" 2
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h" 1
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h" 1
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-namespace mozilla {
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-namespace detail {
-const MozRefCountType DEAD = 0xffffdead;
-# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-enum RefCountAtomicity
-{
-  AtomicRefCount,
-  NonAtomicRefCount
-};
-
-template<typename T, RefCountAtomicity Atomicity>
-class RefCounted
-{
-protected:
-  RefCounted() : mRefCnt(0) {}
-  ~RefCounted() { do { } while (0); }
-
-public:
-
-  void AddRef() const
-  {
-
-    do { } while (0);
-
-    ++mRefCnt;
-
-
-
-
-
-
-
-  }
-
-  void Release() const
-  {
-
-    do { } while (0);
-
-    MozRefCountType cnt = --mRefCnt;
-# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-    if (0 == cnt) {
-
-
-
-
-
-
-
-      delete static_cast<const T*>(this);
-    }
-  }
-
-
-  void ref() { AddRef(); }
-  void deref() { Release(); }
-  MozRefCountType refCount() const { return mRefCnt; }
-  bool hasOneRef() const
-  {
-    do { } while (0);
-    return mRefCnt == 1;
-  }
-
-private:
-  mutable typename Conditional<Atomicity == AtomicRefCount,
-                               Atomic<MozRefCountType>,
-                               MozRefCountType>::Type mRefCnt;
-};
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-}
-
-template<typename T>
-class RefCounted : public detail::RefCounted<T, detail::NonAtomicRefCount>
-{
-public:
-  ~RefCounted()
-  {
-    static_assert(IsBaseOf<RefCounted, T>::value,
-                  "T must derive from RefCounted<T>");
-  }
-};
-
-namespace external {
-# 197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
-template<typename T>
-class AtomicRefCounted :
-  public mozilla::detail::RefCounted<T, mozilla::detail::AtomicRefCount>
-{
-public:
-  ~AtomicRefCounted()
-  {
-    static_assert(IsBaseOf<AtomicRefCounted, T>::value,
-                  "T must derive from AtomicRefCounted<T>");
-  }
-};
-
-}
-
-}
-# 74 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h" 2
-# 131 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
-namespace mozilla {
-
-template <typename T> class WeakPtr;
-template <typename T> class SupportsWeakPtr;
-# 143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
-namespace detail {
-
-
-
-template<class T>
-class WeakReference : public ::mozilla::RefCounted<WeakReference<T> >
-{
-public:
-  explicit WeakReference(T* p) : mPtr(p)
-  {
-    do { } while (false);
-  }
-
-  T* get() const {
-    do { } while (false);
-    return mPtr;
-  }
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/WeakPtr.h"
-private:
-  friend class mozilla::SupportsWeakPtr<T>;
-
-  void detach() {
-    do { } while (false);
-    mPtr = nullptr;
-  }
-
-  T* mPtr;
-
-};
-
-}
-
-template <typename T>
-class SupportsWeakPtr
-{
-protected:
-  ~SupportsWeakPtr()
-  {
-    static_assert(IsBaseOf<SupportsWeakPtr<T>, T>::value,
-                  "T must derive from SupportsWeakPtr<T>");
-    if (mSelfReferencingWeakPtr) {
-      mSelfReferencingWeakPtr.mRef->detach();
-    }
-  }
-
-private:
-  const WeakPtr<T>& SelfReferencingWeakPtr()
-  {
-    if (!mSelfReferencingWeakPtr) {
-      mSelfReferencingWeakPtr.mRef = new detail::WeakReference<T>(static_cast<T*>(this));
-    } else {
-      do { } while (false);
-    }
-    return mSelfReferencingWeakPtr;
-  }
-
-  const WeakPtr<const T>& SelfReferencingWeakPtr() const
-  {
-    const WeakPtr<T>& p = const_cast<SupportsWeakPtr*>(this)->SelfReferencingWeakPtr();
-    return reinterpret_cast<const WeakPtr<const T>&>(p);
-  }
-
-  friend class WeakPtr<T>;
-  friend class WeakPtr<const T>;
-
-  WeakPtr<T> mSelfReferencingWeakPtr;
-};
-
-template <typename T>
-class WeakPtr
-{
-  typedef detail::WeakReference<T> WeakReference;
-
-public:
-  WeakPtr& operator=(const WeakPtr& aOther)
-  {
-    mRef = aOther.mRef;
-    do { } while (false);
-    return *this;
-  }
-
-  WeakPtr(const WeakPtr& aOther)
-  {
-
-    *this = aOther;
-  }
-
-  WeakPtr& operator=(T* aOther)
-  {
-    if (aOther) {
-      *this = aOther->SelfReferencingWeakPtr();
-    } else if (!mRef || mRef->get()) {
-
-      mRef = new WeakReference(nullptr);
-    }
-
-
-    return *this;
-  }
-
-               WeakPtr(T* aOther)
-  {
-    *this = aOther;
-    do { } while (false);
-  }
-
-
-  WeakPtr() : mRef(new WeakReference(nullptr)) {}
-
-  operator T*() const { return mRef->get(); }
-  T& operator*() const { return *mRef->get(); }
-
-  T* operator->() const { return mRef->get(); }
-
-  T* get() const { return mRef->get(); }
-
-private:
-  friend class SupportsWeakPtr<T>;
-
-  explicit WeakPtr(const RefPtr<WeakReference>& aOther) : mRef(aOther) {}
-
-  RefPtr<WeakReference> mRef;
-};
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h" 1
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h"
-class nsQueryFrame
-{
-public:
-  enum FrameIID {
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameIdList.h" 1
-
-
-
-
-BRFrame_id,
-DetailsFrame_id,
-nsAutoRepeatBoxFrame_id,
-nsBCTableCellFrame_id,
-nsBackdropFrame_id,
-nsBlockFrame_id,
-nsBox_id,
-nsBoxFrame_id,
-nsBulletFrame_id,
-nsButtonBoxFrame_id,
-nsCanvasFrame_id,
-nsColorControlFrame_id,
-nsColumnSetFrame_id,
-nsComboboxControlFrame_id,
-nsComboboxDisplayFrame_id,
-nsContainerFrame_id,
-nsContinuingTextFrame_id,
-nsDateTimeControlFrame_id,
-nsDeckFrame_id,
-nsDocElementBoxFrame_id,
-nsFieldSetFrame_id,
-nsFileControlFrame_id,
-nsFirstLetterFrame_id,
-nsFirstLineFrame_id,
-nsFlexContainerFrame_id,
-nsFormControlFrame_id,
-nsFrame_id,
-nsGfxButtonControlFrame_id,
-nsGfxCheckboxControlFrame_id,
-nsGfxRadioControlFrame_id,
-nsGridContainerFrame_id,
-nsGridRowGroupFrame_id,
-nsGridRowLeafFrame_id,
-nsGroupBoxFrame_id,
-nsHTMLButtonControlFrame_id,
-nsHTMLCanvasFrame_id,
-nsHTMLFramesetBlankFrame_id,
-nsHTMLFramesetBorderFrame_id,
-nsHTMLFramesetFrame_id,
-nsHTMLScrollFrame_id,
-nsIAnonymousContentCreator_id,
-nsIComboboxControlFrame_id,
-nsIFormControlFrame_id,
-nsIFrame_id,
-nsIFrameFrame_id,
-nsIListControlFrame_id,
-nsIMathMLFrame_id,
-nsIMenuFrame_id,
-nsIObjectFrame_id,
-nsIPageSequenceFrame_id,
-nsIPercentBSizeObserver_id,
-nsIRootBox_id,
-nsSVGDisplayableFrame_id,
-nsISVGSVGFrame_id,
-nsIScrollableFrame_id,
-nsIScrollbarMediator_id,
-nsISelectControlFrame_id,
-nsIStatefulFrame_id,
-nsITableCellLayout_id,
-nsITableLayout_id,
-nsITextControlFrame_id,
-nsITreeBoxObject_id,
-nsImageBoxFrame_id,
-nsImageControlFrame_id,
-nsImageFrame_id,
-nsInlineFrame_id,
-nsLeafBoxFrame_id,
-nsLeafFrame_id,
-nsLegendFrame_id,
-nsListBoxBodyFrame_id,
-nsListControlFrame_id,
-nsListItemFrame_id,
-nsMathMLContainerFrame_id,
-nsMathMLFrame_id,
-nsMathMLmactionFrame_id,
-nsMathMLmathBlockFrame_id,
-nsMathMLmathInlineFrame_id,
-nsMathMLmencloseFrame_id,
-nsMathMLmfencedFrame_id,
-nsMathMLmfracFrame_id,
-nsMathMLmmultiscriptsFrame_id,
-nsMathMLmoFrame_id,
-nsMathMLmoverFrame_id,
-nsMathMLmpaddedFrame_id,
-nsMathMLmrootFrame_id,
-nsMathMLmrowFrame_id,
-nsMathMLmspaceFrame_id,
-nsMathMLmsqrtFrame_id,
-nsMathMLmstyleFrame_id,
-nsMathMLmtableFrame_id,
-nsMathMLmtableWrapperFrame_id,
-nsMathMLmtdFrame_id,
-nsMathMLmtdInnerFrame_id,
-nsMathMLmtrFrame_id,
-nsMathMLmunderFrame_id,
-nsMathMLmunderoverFrame_id,
-nsMathMLsemanticsFrame_id,
-nsMathMLTokenFrame_id,
-nsMenuBarFrame_id,
-nsMenuFrame_id,
-nsMenuPopupFrame_id,
-nsMeterFrame_id,
-nsNumberControlFrame_id,
-nsPluginFrame_id,
-nsPageBreakFrame_id,
-nsPageContentFrame_id,
-nsPageFrame_id,
-nsPlaceholderFrame_id,
-nsPopupSetFrame_id,
-nsProgressFrame_id,
-nsProgressMeterFrame_id,
-nsRangeFrame_id,
-nsResizerFrame_id,
-nsRootBoxFrame_id,
-nsRubyBaseContainerFrame_id,
-nsRubyBaseFrame_id,
-nsRubyContentFrame_id,
-nsRubyFrame_id,
-nsRubyTextContainerFrame_id,
-nsRubyTextFrame_id,
-nsScrollbarButtonFrame_id,
-nsScrollbarFrame_id,
-nsSelectsAreaFrame_id,
-nsSimplePageSequenceFrame_id,
-nsSliderFrame_id,
-nsSplittableFrame_id,
-nsSplitterFrame_id,
-nsStackFrame_id,
-nsSubDocumentFrame_id,
-nsSVGAFrame_id,
-nsSVGClipPathFrame_id,
-nsSVGContainerFrame_id,
-nsSVGDisplayContainerFrame_id,
-SVGFEContainerFrame_id,
-SVGFEImageFrame_id,
-SVGFELeafFrame_id,
-SVGFEUnstyledLeafFrame_id,
-nsSVGFilterFrame_id,
-nsSVGForeignObjectFrame_id,
-nsSVGGenericContainerFrame_id,
-nsSVGGFrame_id,
-nsSVGGradientFrame_id,
-nsSVGImageFrame_id,
-nsSVGInnerSVGFrame_id,
-nsSVGLinearGradientFrame_id,
-nsSVGMarkerFrame_id,
-nsSVGMarkerAnonChildFrame_id,
-nsSVGMaskFrame_id,
-nsSVGOuterSVGFrame_id,
-nsSVGOuterSVGAnonChildFrame_id,
-nsSVGPaintServerFrame_id,
-SVGGeometryFrame_id,
-nsSVGPatternFrame_id,
-nsSVGRadialGradientFrame_id,
-nsSVGStopFrame_id,
-nsSVGSwitchFrame_id,
-SVGTextFrame_id,
-nsSVGUseFrame_id,
-SVGViewFrame_id,
-nsTableCellFrame_id,
-nsTableColFrame_id,
-nsTableColGroupFrame_id,
-nsTableFrame_id,
-nsTableWrapperFrame_id,
-nsTableRowFrame_id,
-nsTableRowGroupFrame_id,
-nsTextBoxFrame_id,
-nsTextControlFrame_id,
-nsTextFrame_id,
-nsTitleBarFrame_id,
-nsTreeBodyFrame_id,
-nsTreeColFrame_id,
-nsVideoFrame_id,
-nsXULLabelFrame_id,
-nsXULScrollFrame_id,
-ViewportFrame_id,
-# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsQueryFrame.h" 2
-
-
-
-
-
-
-
-
-    NON_FRAME_MARKER = 0x20000000
-  };
-
-  virtual void* QueryFrame(FrameIID id) = 0;
-};
-
-class do_QueryFrame
-{
-public:
-  explicit do_QueryFrame(nsQueryFrame *s) : mRawPtr(s) { }
-
-
-
-  typedef void (do_QueryFrame::* MatchNullptr)(double, float);
-
-               do_QueryFrame(MatchNullptr aRawPtr) : mRawPtr(nullptr) {}
-
-  template<class Dest>
-  operator Dest*() {
-    static_assert(mozilla::IsSame<Dest, typename Dest::Has_NS_DECL_QUERYFRAME_TARGET>::value,
-                  "Dest must declare itself as a queryframe target");
-    if (!mRawPtr)
-      return nullptr;
-
-    return reinterpret_cast<Dest*>(mRawPtr->QueryFrame(Dest::kFrameIID));
-  }
-
-private:
-  nsQueryFrame *mRawPtr;
-};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 2
-
-namespace mozilla {
-
-enum ArenaObjectID {
-  eArenaObjectID_DummyBeforeFirstObjectID = nsQueryFrame::NON_FRAME_MARKER - 1,
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h" 1
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h"
-eArenaObjectID_nsLineBox,
-eArenaObjectID_nsRuleNode,
-eArenaObjectID_nsStyleContext,
-eArenaObjectID_nsInheritedStyleData,
-eArenaObjectID_nsResetStyleData,
-eArenaObjectID_nsConditionalResetStyleData,
-eArenaObjectID_nsConditionalResetStyleDataEntry,
-eArenaObjectID_nsFrameList,
-eArenaObjectID_CustomCounterStyle,
-eArenaObjectID_DependentBuiltinCounterStyle,
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
-eArenaObjectID_nsStyleFont,
-
-
-
-eArenaObjectID_nsStyleColor,
-
-
-eArenaObjectID_nsStyleList,
-
-
-
-
-eArenaObjectID_nsStyleText,
-
-
-
-
-
-eArenaObjectID_nsStyleVisibility,
-
-
-eArenaObjectID_nsStyleUserInterface,
-
-
-eArenaObjectID_nsStyleTableBorder,
-
-
-
-
-eArenaObjectID_nsStyleSVG,
-
-
-
-
-
-eArenaObjectID_nsStyleVariables,
-
-eArenaObjectID_nsStyleBackground,
-
-
-
-
-
-eArenaObjectID_nsStylePosition,
-
-
-
-
-eArenaObjectID_nsStyleTextReset,
-
-
-
-
-
-eArenaObjectID_nsStyleDisplay,
-
-
-
-
-eArenaObjectID_nsStyleContent,
-
-
-
-
-eArenaObjectID_nsStyleUIReset,
-
-
-eArenaObjectID_nsStyleTable,
-
-
-eArenaObjectID_nsStyleMargin,
-
-
-
-
-eArenaObjectID_nsStylePadding,
-
-
-
-
-eArenaObjectID_nsStyleBorder,
-
-
-
-
-
-eArenaObjectID_nsStyleOutline,
-
-
-
-
-
-eArenaObjectID_nsStyleXUL,
-
-
-eArenaObjectID_nsStyleSVGReset,
-
-
-
-
-
-eArenaObjectID_nsStyleColumn,
-
-
-
-
-
-eArenaObjectID_nsStyleEffects,
-# 62 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArenaObjectList.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h" 2
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaObjectID.h"
-  eArenaObjectID_NON_OBJECT_MARKER = 0x40000000
-};
-
-};
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-namespace mozilla {
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-template<class T>
-class StaticAutoPtr
-{
-public:
-# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-  StaticAutoPtr<T>& operator=(T* aRhs)
-  {
-    Assign(aRhs);
-    return *this;
-  }
-
-  T* get() const { return mRawPtr; }
-
-  operator T*() const { return get(); }
-
-  T* operator->() const
-  {
-    do { } while (0);
-    return get();
-  }
-
-  T& operator*() const { return *get(); }
-
-private:
-# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-  void Assign(T* aNewPtr)
-  {
-    do { } while (0);
-    T* oldPtr = mRawPtr;
-    mRawPtr = aNewPtr;
-    delete oldPtr;
-  }
-
-  T* mRawPtr;
-};
-
-template<class T>
-class StaticRefPtr
-{
-public:
-# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-  StaticRefPtr<T>& operator=(T* aRhs)
-  {
-    AssignWithAddref(aRhs);
-    return *this;
-  }
-
-  StaticRefPtr<T>& operator=(const StaticRefPtr<T>& aRhs)
-  {
-    return (this = aRhs.mRawPtr);
-  }
-
-  StaticRefPtr<T>& operator=(already_AddRefed<T>& aRhs)
-  {
-    AssignAssumingAddRef(aRhs.take());
-    return *this;
-  }
-
-  StaticRefPtr<T>& operator=(already_AddRefed<T>&& aRhs)
-  {
-    AssignAssumingAddRef(aRhs.take());
-    return *this;
-  }
-
-  already_AddRefed<T>
-  forget()
-  {
-    T* temp = mRawPtr;
-    mRawPtr = nullptr;
-    return already_AddRefed<T>(temp);
-  }
-
-  T* get() const { return mRawPtr; }
-
-  operator T*() const { return get(); }
-
-  T* operator->() const
-  {
-    do { } while (0);
-    return get();
-  }
-
-  T& operator*() const { return *get(); }
-
-private:
-  void AssignWithAddref(T* aNewPtr)
-  {
-    if (aNewPtr) {
-      aNewPtr->AddRef();
-    }
-    AssignAssumingAddRef(aNewPtr);
-  }
-
-  void AssignAssumingAddRef(T* aNewPtr)
-  {
-    T* oldPtr = mRawPtr;
-    mRawPtr = aNewPtr;
-    if (oldPtr) {
-      oldPtr->Release();
-    }
-  }
-
-  T* mRawPtr;
-};
-
-namespace StaticPtr_internal {
-class Zero;
-}
-# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPtr.h"
-template<class T, class U>
-inline bool
-operator==(const StaticAutoPtr<T>& aLhs, const StaticAutoPtr<U>& aRhs)
-{
-  return aLhs.get() == aRhs.get();
-}
-
-template<class T, class U>
-inline bool
-operator!=(const StaticAutoPtr<T>& aLhs, const StaticAutoPtr<U>& aRhs)
-{
-  return !(aLhs == aRhs);
-}
-
-template<class T, class U> inline bool operator==(const StaticAutoPtr<T>& lhs, const U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(const U* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticAutoPtr<T>& lhs, const U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(const U* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-template<class T, class U> inline bool operator==(const StaticAutoPtr<T>& lhs, U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(U* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticAutoPtr<T>& lhs, U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(U* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-
-template<class T> inline bool operator==(const StaticAutoPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return lhs.get() == nullptr; } template<class T> inline bool operator==(StaticPtr_internal::Zero* lhs, const StaticAutoPtr<T>& rhs) { return rhs == lhs; } template<class T> inline bool operator!=(const StaticAutoPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return !(lhs == rhs); } template<class T> inline bool operator!=(StaticPtr_internal::Zero* lhs, const StaticAutoPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-
-
-template<class T, class U>
-inline bool
-operator==(const StaticRefPtr<T>& aLhs, const StaticRefPtr<U>& aRhs)
-{
-  return aLhs.get() == aRhs.get();
-}
-
-template<class T, class U>
-inline bool
-operator!=(const StaticRefPtr<T>& aLhs, const StaticRefPtr<U>& aRhs)
-{
-  return !(aLhs == aRhs);
-}
-
-template<class T, class U> inline bool operator==(const StaticRefPtr<T>& lhs, const U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(const U* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticRefPtr<T>& lhs, const U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(const U* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-template<class T, class U> inline bool operator==(const StaticRefPtr<T>& lhs, U* rhs) { return lhs.get() == rhs; } template<class T, class U> inline bool operator==(U* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T, class U> inline bool operator!=(const StaticRefPtr<T>& lhs, U* rhs) { return !(lhs == rhs); } template<class T, class U> inline bool operator!=(U* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-
-template<class T> inline bool operator==(const StaticRefPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return lhs.get() == nullptr; } template<class T> inline bool operator==(StaticPtr_internal::Zero* lhs, const StaticRefPtr<T>& rhs) { return rhs == lhs; } template<class T> inline bool operator!=(const StaticRefPtr<T>& lhs, StaticPtr_internal::Zero* rhs) { return !(lhs == rhs); } template<class T> inline bool operator!=(StaticPtr_internal::Zero* lhs, const StaticRefPtr<T>& rhs) { return !(lhs == rhs); }
-
-
-
-
-}
-
-
-template<class T> template<class U>
-RefPtr<T>::RefPtr(const mozilla::StaticRefPtr<U>& aOther)
-  : RefPtr(aOther.get())
-{}
-
-template<class T> template<class U>
-RefPtr<T>&
-RefPtr<T>::operator=(const mozilla::StaticRefPtr<U>& aOther)
-{
-  return operator=(aOther.get());
-}
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SheetType.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SheetType.h"
-namespace mozilla {
-
-
-
-
-
-
-enum class SheetType : uint8_t {
-  Agent,
-  User,
-  PresHint,
-  Doc,
-  ScopedDoc,
-  StyleAttr,
-  Override,
-  Animation,
-  Transition,
-
-  Count,
-  Unknown = 0xff
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleBackendType.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleBackendType.h"
-namespace mozilla {
-
-
-
-
-enum class StyleBackendType : uint8_t
-{
-  None,
-  Gecko,
-  Servo
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h"
-namespace mozilla {
-
-class StyleSheet;
-struct StyleSheetAtoms;
-
-namespace dom {
-
-struct NativePropertyHooks;
-class ProtoAndIfaceCache;
-
-}
-
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class CSSStyleSheetParsingMode : uint8_t {
-  Author,
-  User,
-  Agent,
-  EndGuard_
-};
-
-namespace CSSStyleSheetParsingModeValues {
-extern const EnumEntry strings[4];
-}
-
-bool
-ToJSValue(JSContext* aCx, CSSStyleSheetParsingMode aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-namespace CSSStyleSheetBinding {
-
-  typedef mozilla::StyleSheet NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::StyleSheet* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 71 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CSSStyleSheetBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/net/ReferrerPolicy.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h"
-class nsILoadGroup;
-
-typedef uint32_t nsLoadFlags;
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequest.h"
-class nsIRequest : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetName(nsACString & aName) = 0;
-
-
-  virtual nsresult IsPending(bool *_retval) = 0;
-
-
-  virtual nsresult GetStatus(nsresult *aStatus) = 0;
-
-
-  virtual nsresult Cancel(nsresult aStatus) = 0;
-
-
-  virtual nsresult Suspend(void) = 0;
-
-
-  virtual nsresult Resume(void) = 0;
-
-
-  virtual nsresult GetLoadGroup(nsILoadGroup * *aLoadGroup) = 0;
-  virtual nsresult SetLoadGroup(nsILoadGroup *aLoadGroup) = 0;
-
-
-  virtual nsresult GetLoadFlags(nsLoadFlags *aLoadFlags) = 0;
-  virtual nsresult SetLoadFlags(nsLoadFlags aLoadFlags) = 0;
-
-  enum {
-    LOAD_REQUESTMASK = 65535U,
-    LOAD_NORMAL = 0U,
-    LOAD_BACKGROUND = 1U,
-    LOAD_HTML_OBJECT_DATA = 2U,
-    INHIBIT_CACHING = 128U,
-    INHIBIT_PERSISTENT_CACHING = 256U,
-    LOAD_BYPASS_CACHE = 512U,
-    LOAD_FROM_CACHE = 1024U,
-    VALIDATE_ALWAYS = 2048U,
-    VALIDATE_NEVER = 4096U,
-    VALIDATE_ONCE_PER_SESSION = 8192U,
-    LOAD_ANONYMOUS = 16384U,
-    LOAD_FRESH_CONNECTION = 32768U
-  };
-
-};
-
-  template<typename T> struct nsIRequest::COMTypeInfo<nsIRequest, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRequest::COMTypeInfo<nsIRequest, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xef6bfbd2, 0xfd46, 0x48d8, { 0x96, 0xb7, 0x9f, 0x8f, 0x0f, 0xd3, 0x87, 0xfe }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h"
-class nsIURI;
-
-class nsIDOMNode;
-
-class nsIPrincipal;
-
-typedef uint32_t nsContentPolicyType;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicyBase.h"
-class nsIContentPolicyBase : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    TYPE_INVALID = 0U,
-    TYPE_OTHER = 1U,
-    TYPE_SCRIPT = 2U,
-    TYPE_IMAGE = 3U,
-    TYPE_STYLESHEET = 4U,
-    TYPE_OBJECT = 5U,
-    TYPE_DOCUMENT = 6U,
-    TYPE_SUBDOCUMENT = 7U,
-    TYPE_REFRESH = 8U,
-    TYPE_XBL = 9U,
-    TYPE_PING = 10U,
-    TYPE_XMLHTTPREQUEST = 11U,
-    TYPE_DATAREQUEST = 11U,
-    TYPE_OBJECT_SUBREQUEST = 12U,
-    TYPE_DTD = 13U,
-    TYPE_FONT = 14U,
-    TYPE_MEDIA = 15U,
-    TYPE_WEBSOCKET = 16U,
-    TYPE_CSP_REPORT = 17U,
-    TYPE_XSLT = 18U,
-    TYPE_BEACON = 19U,
-    TYPE_FETCH = 20U,
-    TYPE_IMAGESET = 21U,
-    TYPE_WEB_MANIFEST = 22U,
-    TYPE_INTERNAL_SCRIPT = 23U,
-    TYPE_INTERNAL_WORKER = 24U,
-    TYPE_INTERNAL_SHARED_WORKER = 25U,
-    TYPE_INTERNAL_EMBED = 26U,
-    TYPE_INTERNAL_OBJECT = 27U,
-    TYPE_INTERNAL_FRAME = 28U,
-    TYPE_INTERNAL_IFRAME = 29U,
-    TYPE_INTERNAL_AUDIO = 30U,
-    TYPE_INTERNAL_VIDEO = 31U,
-    TYPE_INTERNAL_TRACK = 32U,
-    TYPE_INTERNAL_XMLHTTPREQUEST = 33U,
-    TYPE_INTERNAL_EVENTSOURCE = 34U,
-    TYPE_INTERNAL_SERVICE_WORKER = 35U,
-    TYPE_INTERNAL_SCRIPT_PRELOAD = 36U,
-    TYPE_INTERNAL_IMAGE = 37U,
-    TYPE_INTERNAL_IMAGE_PRELOAD = 38U,
-    TYPE_INTERNAL_STYLESHEET = 39U,
-    TYPE_INTERNAL_STYLESHEET_PRELOAD = 40U,
-    TYPE_INTERNAL_IMAGE_FAVICON = 41U,
-    TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS = 42U,
-    REJECT_REQUEST = -1,
-    REJECT_TYPE = -2,
-    REJECT_SERVER = -3,
-    REJECT_OTHER = -4,
-    ACCEPT = 1
-  };
-
-};
-
-  template<typename T> struct nsIContentPolicyBase::COMTypeInfo<nsIContentPolicyBase, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentPolicyBase::COMTypeInfo<nsIContentPolicyBase, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x17418187, 0xd86f, 0x48dd, { 0x92, 0xd1, 0x23, 0x88, 0x38, 0xdf, 0x0a, 0x4e }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h" 2
-
-
-
-
-
-
-class nsIURI;
-
-class nsIDOMNode;
-
-class nsIPrincipal;
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIContentPolicy.h"
-class nsIContentPolicy : public nsIContentPolicyBase {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult ShouldLoad(nsContentPolicyType aContentType, nsIURI *aContentLocation, nsIURI *aRequestOrigin, nsISupports *aContext, const nsACString & aMimeTypeGuess, nsISupports *aExtra, nsIPrincipal *aRequestPrincipal, int16_t *_retval) = 0;
-
-
-  virtual nsresult ShouldProcess(nsContentPolicyType aContentType, nsIURI *aContentLocation, nsIURI *aRequestOrigin, nsISupports *aContext, const nsACString & aMimeType, nsISupports *aExtra, nsIPrincipal *aRequestPrincipal, int16_t *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIContentPolicy::COMTypeInfo<nsIContentPolicy, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentPolicy::COMTypeInfo<nsIContentPolicy, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcaad4f1f, 0xd047, 0x46ac, { 0xae, 0x9d, 0xdc, 0x59, 0x8e, 0x4f, 0xb9, 0x1b }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
-class nsIDOMDocument;
-
-class nsINode;
-
-class nsIPrincipal;
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
-namespace mozilla {
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
-template<typename T>
-class RangedPtr
-{
-  T* mPtr;
-
-
-
-
-
-
-  void checkSanity()
-  {
-    do { } while (0);
-    do { } while (0);
-  }
-
-
-  RangedPtr<T> create(T* aPtr) const
-  {
-
-
-
-    return RangedPtr<T>(aPtr, nullptr, size_t(0));
-
-  }
-
-  uintptr_t asUintptr() const { return reinterpret_cast<uintptr_t>(mPtr); }
-
-public:
-  RangedPtr(T* aPtr, T* aStart, T* aEnd)
-    : mPtr(aPtr)
-
-
-
-  {
-    do { } while (0);
-    checkSanity();
-  }
-  RangedPtr(T* aPtr, T* aStart, size_t aLength)
-    : mPtr(aPtr)
-
-
-
-  {
-    do { } while (0);
-    do { } while (0);
-
-    checkSanity();
-  }
-
-
-  RangedPtr(T* aPtr, size_t aLength)
-    : mPtr(aPtr)
-
-
-
-  {
-    do { } while (0);
-    do { } while (0);
-
-    checkSanity();
-  }
-
-
-  template<size_t N>
-  explicit RangedPtr(T (&aArr)[N])
-    : mPtr(aArr)
-
-
-
-  {
-    checkSanity();
-  }
-
-  T* get() const { return mPtr; }
-
-  explicit operator bool() const { return mPtr != nullptr; }
-
-  void checkIdenticalRange(const RangedPtr<T>& aOther) const
-  {
-    do { } while (0);
-    do { } while (0);
-  }
-# 136 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RangedPtr.h"
-  RangedPtr<T>& operator=(const RangedPtr<T>& aOther)
-  {
-    checkIdenticalRange(aOther);
-    mPtr = aOther.mPtr;
-    checkSanity();
-    return *this;
-  }
-
-  RangedPtr<T> operator+(size_t aInc) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return create(mPtr + aInc);
-  }
-
-  RangedPtr<T> operator-(size_t aDec) const
-  {
-    do { } while (0);
-    do { } while (0);
-    return create(mPtr - aDec);
-  }
-
-
-
-
-
-  template <typename U>
-  RangedPtr<T>& operator=(U* aPtr)
-  {
-    *this = create(aPtr);
-    return *this;
-  }
-
-  template <typename U>
-  RangedPtr<T>& operator=(const RangedPtr<U>& aPtr)
-  {
-    do { } while (0);
-    do { } while (0);
-    mPtr = aPtr.mPtr;
-    checkSanity();
-    return *this;
-  }
-
-  RangedPtr<T>& operator++()
-  {
-    return (*this += 1);
-  }
-
-  RangedPtr<T> operator++(int)
-  {
-    RangedPtr<T> rcp = *this;
-    ++*this;
-    return rcp;
-  }
-
-  RangedPtr<T>& operator--()
-  {
-    return (*this -= 1);
-  }
-
-  RangedPtr<T> operator--(int)
-  {
-    RangedPtr<T> rcp = *this;
-    --*this;
-    return rcp;
-  }
-
-  RangedPtr<T>& operator+=(size_t aInc)
-  {
-    *this = *this + aInc;
-    return *this;
-  }
-
-  RangedPtr<T>& operator-=(size_t aDec)
-  {
-    *this = *this - aDec;
-    return *this;
-  }
-
-  T& operator[](int aIndex) const
-  {
-    do { } while (0);
-    return *create(mPtr + aIndex);
-  }
-
-  T& operator*() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return *mPtr;
-  }
-
-  T* operator->() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mPtr;
-  }
-
-  template <typename U>
-  bool operator==(const RangedPtr<U>& aOther) const
-  {
-    return mPtr == aOther.mPtr;
-  }
-  template <typename U>
-  bool operator!=(const RangedPtr<U>& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  template<typename U>
-  bool operator==(const U* u) const
-  {
-    return mPtr == u;
-  }
-  template<typename U>
-  bool operator!=(const U* u) const
-  {
-    return !(*this == u);
-  }
-
-  template <typename U>
-  bool operator<(const RangedPtr<U>& aOther) const
-  {
-    return mPtr < aOther.mPtr;
-  }
-  template <typename U>
-  bool operator<=(const RangedPtr<U>& aOther) const
-  {
-    return mPtr <= aOther.mPtr;
-  }
-
-  template <typename U>
-  bool operator>(const RangedPtr<U>& aOther) const
-  {
-    return mPtr > aOther.mPtr;
-  }
-  template <typename U>
-  bool operator>=(const RangedPtr<U>& aOther) const
-  {
-    return mPtr >= aOther.mPtr;
-  }
-
-  size_t operator-(const RangedPtr<T>& aOther) const
-  {
-    do { } while (0);
-    return PointerRangeSize(aOther.mPtr, mPtr);
-  }
-
-private:
-  RangedPtr() = delete;
-};
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 2
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Range.h" 2
-
-namespace mozilla {
-
-
-template <typename T>
-class Range
-{
-  const RangedPtr<T> mStart;
-  const RangedPtr<T> mEnd;
-
-public:
-  Range() : mStart(nullptr, 0), mEnd(nullptr, 0) {}
-  Range(T* aPtr, size_t aLength)
-    : mStart(aPtr, aPtr, aPtr + aLength),
-      mEnd(aPtr + aLength, aPtr, aPtr + aLength)
-  {}
-  Range(const RangedPtr<T>& aStart, const RangedPtr<T>& aEnd)
-    : mStart(aStart.get(), aStart.get(), aEnd.get()),
-      mEnd(aEnd.get(), aStart.get(), aEnd.get())
-  {
-
-    aStart.checkIdenticalRange(aEnd);
-    do { } while (0);
-  }
-
-  template<typename U,
-           class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
-                                     int>::Type>
-               Range(const Range<U>& aOther)
-    : mStart(aOther.mStart),
-      mEnd(aOther.mEnd)
-  {}
-
-               Range(Span<T> aSpan)
-    : Range(aSpan.Elements(), aSpan.Length())
-  {
-  }
-
-  template<typename U,
-           class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
-                                     int>::Type>
-               Range(const Span<U>& aSpan)
-    : Range(aSpan.Elements(), aSpan.Length())
-  {
-  }
-
-  RangedPtr<T> begin() const { return mStart; }
-  RangedPtr<T> end() const { return mEnd; }
-  size_t length() const { return mEnd - mStart; }
-
-  T& operator[](size_t aOffset) const { return mStart[aOffset]; }
-
-  explicit operator bool() const { return mStart != nullptr; }
-
-  operator Span<T>() { return Span<T>(mStart.get(), length()); }
-
-  operator Span<const T>() const { return Span<T>(mStart.get(), length()); }
-};
-
-template<class T>
-Span<T>
-MakeSpan(Range<T>& aRange)
-{
-  return aRange;
-}
-
-template<class T>
-Span<const T>
-MakeSpan(const Range<T>& aRange)
-{
-  return aRange;
-}
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Variant.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-
-
-
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h" 1
-# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
-typedef bool
-(* JSNative)(JSContext* cx, unsigned argc, JS::Value* vp);
-
-namespace JS {
-
-extern const HandleValue UndefinedHandleValue;
-
-namespace detail {
-
-
-
-
-
-extern Value
-ComputeThis(JSContext* cx, JS::Value* vp);
-
-
-extern void
-CheckIsValidConstructible(const Value& v);
-
-
-class IncludeUsedRval
-{
-  protected:
-
-    mutable bool usedRval_;
-    void setUsedRval() const { usedRval_ = true; }
-    void clearUsedRval() const { usedRval_ = false; }
-    void assertUnusedRval() const { do { } while (0); }
-
-
-
-
-
-};
-
-class NoUsedRval
-{
-  protected:
-    void setUsedRval() const {}
-    void clearUsedRval() const {}
-    void assertUnusedRval() const {}
-};
-
-template<class WantUsedRval>
-class CallArgsBase : public WantUsedRval
-{
-    static_assert(mozilla::IsSame<WantUsedRval, IncludeUsedRval>::value ||
-                  mozilla::IsSame<WantUsedRval, NoUsedRval>::value,
-                  "WantUsedRval can only be IncludeUsedRval or NoUsedRval");
-
-  protected:
-    Value* argv_;
-    unsigned argc_;
-    bool constructing_:1;
-
-
-    bool ignoresReturnValue_:1;
-
-  public:
-
-
-
-
-
-
-    HandleValue calleev() const {
-        this->assertUnusedRval();
-        return HandleValue::fromMarkedLocation(&argv_[-2]);
-    }
-
-
-
-
-
-    JSObject& callee() const {
-        return calleev().toObject();
-    }
-
-
-
-    bool isConstructing() const {
-        if (!argv_[-1].isMagic())
-            return false;
-
-
-        if (!this->usedRval_)
-            CheckIsValidConstructible(calleev());
-
-
-        return true;
-    }
-
-    bool ignoresReturnValue() const {
-        return ignoresReturnValue_;
-    }
-
-    MutableHandleValue newTarget() const {
-        do { } while (0);
-        return MutableHandleValue::fromMarkedLocation(&this->argv_[argc_]);
-    }
-
-
-
-
-
-
-
-    HandleValue thisv() const {
-
-
-
-        return HandleValue::fromMarkedLocation(&argv_[-1]);
-    }
-
-    Value computeThis(JSContext* cx) const {
-        if (thisv().isObject())
-            return thisv();
-
-        return ComputeThis(cx, base());
-    }
-
-
-
-
-    unsigned length() const { return argc_; }
-
-
-    MutableHandleValue operator[](unsigned i) const {
-        do { } while (0);
-        return MutableHandleValue::fromMarkedLocation(&this->argv_[i]);
-    }
-
-
-
-
-
-    HandleValue get(unsigned i) const {
-        return i < length()
-               ? HandleValue::fromMarkedLocation(&this->argv_[i])
-               : UndefinedHandleValue;
-    }
-
-
-
-
-
-    bool hasDefined(unsigned i) const {
-        return i < argc_ && !this->argv_[i].isUndefined();
-    }
-# 241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
-    MutableHandleValue rval() const {
-        this->setUsedRval();
-        return MutableHandleValue::fromMarkedLocation(&argv_[-2]);
-    }
-
-  public:
-
-
-
-
-    void setCallee(const Value& aCalleev) const {
-        this->clearUsedRval();
-        argv_[-2] = aCalleev;
-    }
-
-    void setThis(const Value& aThisv) const {
-        argv_[-1] = aThisv;
-    }
-
-    MutableHandleValue mutableThisv() const {
-        return MutableHandleValue::fromMarkedLocation(&argv_[-1]);
-    }
-
-  public:
-
-
-
-
-    Value* array() const { return argv_; }
-    Value* end() const { return argv_ + argc_ + constructing_; }
-
-  public:
-
-
-
-    Value* base() const { return argv_ - 2; }
-
-    Value* spAfterCall() const {
-        this->setUsedRval();
-        return argv_ - 1;
-    }
-};
-
-}
-
-class CallArgs : public detail::CallArgsBase<detail::IncludeUsedRval>
-{
-  private:
-    friend CallArgs CallArgsFromVp(unsigned argc, Value* vp);
-    friend CallArgs CallArgsFromSp(unsigned stackSlots, Value* sp, bool constructing,
-                                   bool ignoresReturnValue);
-
-    static CallArgs create(unsigned argc, Value* argv, bool constructing,
-                           bool ignoresReturnValue = false) {
-        CallArgs args;
-        args.clearUsedRval();
-        args.argv_ = argv;
-        args.argc_ = argc;
-        args.constructing_ = constructing;
-        args.ignoresReturnValue_ = ignoresReturnValue;
-
-
-
-
-
-
-        return args;
-    }
-
-  public:
-
-
-
-
-    bool requireAtLeast(JSContext* cx, const char* fnname, unsigned required) const;
-
-};
-
-__attribute__((always_inline)) inline CallArgs
-CallArgsFromVp(unsigned argc, Value* vp)
-{
-    return CallArgs::create(argc, vp + 2, vp[1].isMagic(JS_IS_CONSTRUCTING));
-}
-
-
-
-
-__attribute__((always_inline)) inline CallArgs
-CallArgsFromSp(unsigned stackSlots, Value* sp, bool constructing = false,
-               bool ignoresReturnValue = false)
-{
-    return CallArgs::create(stackSlots - constructing, sp - stackSlots, constructing,
-                            ignoresReturnValue);
-}
-
-}
-# 353 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallArgs.h"
-__attribute__((always_inline)) inline JS::Value
-JS_THIS(JSContext* cx, JS::Value* vp)
-{
-    return vp[1].isPrimitive() ? JS::detail::ComputeThis(cx, vp) : vp[1];
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
-class JSFlatString;
-
-namespace JS {
-
-
-
-
-
-
-
-class Latin1Chars : public mozilla::Range<Latin1Char>
-{
-    typedef mozilla::Range<Latin1Char> Base;
-
-  public:
-    using CharT = Latin1Char;
-
-    Latin1Chars() : Base() {}
-    Latin1Chars(char* aBytes, size_t aLength) : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength) {}
-    Latin1Chars(const Latin1Char* aBytes, size_t aLength)
-      : Base(const_cast<Latin1Char*>(aBytes), aLength)
-    {}
-    Latin1Chars(const char* aBytes, size_t aLength)
-      : Base(reinterpret_cast<Latin1Char*>(const_cast<char*>(aBytes)), aLength)
-    {}
-};
-
-
-
-
-class Latin1CharsZ : public mozilla::RangedPtr<Latin1Char>
-{
-    typedef mozilla::RangedPtr<Latin1Char> Base;
-
-  public:
-    using CharT = Latin1Char;
-
-    Latin1CharsZ() : Base(nullptr, 0) {}
-
-    Latin1CharsZ(char* aBytes, size_t aLength)
-      : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength)
-    {
-        do { } while (0);
-    }
-
-    Latin1CharsZ(Latin1Char* aBytes, size_t aLength)
-      : Base(aBytes, aLength)
-    {
-        do { } while (0);
-    }
-
-    using Base::operator=;
-
-    char* c_str() { return reinterpret_cast<char*>(get()); }
-};
-
-class UTF8Chars : public mozilla::Range<unsigned char>
-{
-    typedef mozilla::Range<unsigned char> Base;
-
-  public:
-    using CharT = unsigned char;
-
-    UTF8Chars() : Base() {}
-    UTF8Chars(char* aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
-    {}
-    UTF8Chars(const char* aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char*>(const_cast<char*>(aBytes)), aLength)
-    {}
-};
-
-
-
-
-class UTF8CharsZ : public mozilla::RangedPtr<unsigned char>
-{
-    typedef mozilla::RangedPtr<unsigned char> Base;
-
-  public:
-    using CharT = unsigned char;
-
-    UTF8CharsZ() : Base(nullptr, 0) {}
-
-    UTF8CharsZ(char* aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
-    {
-        do { } while (0);
-    }
-
-    UTF8CharsZ(unsigned char* aBytes, size_t aLength)
-      : Base(aBytes, aLength)
-    {
-        do { } while (0);
-    }
-
-    using Base::operator=;
-
-    char* c_str() { return reinterpret_cast<char*>(get()); }
-};
-
-
-
-
-
-
-
-class ConstUTF8CharsZ
-{
-    const char* data_;
-
-  public:
-    using CharT = unsigned char;
-
-    ConstUTF8CharsZ() : data_(nullptr)
-    {}
-
-    ConstUTF8CharsZ(const char* aBytes, size_t aLength)
-      : data_(aBytes)
-    {
-        do { } while (0);
-
-
-
-    }
-
-    const void* get() const { return data_; }
-
-    const char* c_str() const { return data_; }
-
-    explicit operator bool() const { return data_ != nullptr; }
-
-  private:
-
-
-
-};
-# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
-class TwoByteChars : public mozilla::Range<char16_t>
-{
-    typedef mozilla::Range<char16_t> Base;
-
-  public:
-    using CharT = char16_t;
-
-    TwoByteChars() : Base() {}
-    TwoByteChars(char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
-    TwoByteChars(const char16_t* aChars, size_t aLength) : Base(const_cast<char16_t*>(aChars), aLength) {}
-};
-
-
-
-
-class TwoByteCharsZ : public mozilla::RangedPtr<char16_t>
-{
-    typedef mozilla::RangedPtr<char16_t> Base;
-
-  public:
-    using CharT = char16_t;
-
-    TwoByteCharsZ() : Base(nullptr, 0) {}
-
-    TwoByteCharsZ(char16_t* chars, size_t length)
-      : Base(chars, length)
-    {
-        do { } while (0);
-    }
-
-    using Base::operator=;
-};
-
-typedef mozilla::RangedPtr<const char16_t> ConstCharPtr;
-
-
-
-
-class ConstTwoByteChars : public mozilla::Range<const char16_t>
-{
-    typedef mozilla::Range<const char16_t> Base;
-
-  public:
-    using CharT = char16_t;
-
-    ConstTwoByteChars() : Base() {}
-    ConstTwoByteChars(const char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
-};
-# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
-extern Latin1CharsZ
-LossyTwoByteCharsToNewLatin1CharsZ(JSContext* cx,
-                                   const mozilla::Range<const char16_t> tbchars);
-
-inline Latin1CharsZ
-LossyTwoByteCharsToNewLatin1CharsZ(JSContext* cx, const char16_t* begin, size_t length)
-{
-    const mozilla::Range<const char16_t> tbchars(begin, length);
-    return JS::LossyTwoByteCharsToNewLatin1CharsZ(cx, tbchars);
-}
-
-template <typename CharT>
-extern UTF8CharsZ
-CharsToNewUTF8CharsZ(JSContext* maybeCx, const mozilla::Range<CharT> chars);
-
-uint32_t
-Utf8ToOneUcs4Char(const uint8_t* utf8Buffer, int utf8Length);
-
-
-
-
-
-
-
-extern TwoByteCharsZ
-UTF8CharsToNewTwoByteCharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
-
-
-
-
-extern TwoByteCharsZ
-UTF8CharsToNewTwoByteCharsZ(JSContext* cx, const ConstUTF8CharsZ& utf8, size_t* outlen);
-
-
-
-
-
-
-extern TwoByteCharsZ
-LossyUTF8CharsToNewTwoByteCharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
-
-extern TwoByteCharsZ
-LossyUTF8CharsToNewTwoByteCharsZ(JSContext* cx, const ConstUTF8CharsZ& utf8, size_t* outlen);
-
-
-
-
-
-size_t
-GetDeflatedUTF8StringLength(JSFlatString* s);
-# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CharacterEncoding.h"
-void
-DeflateStringToUTF8Buffer(JSFlatString* src, mozilla::RangedPtr<char> dst,
-                          size_t* dstlenp = nullptr, size_t* numcharsp = nullptr);
-
-
-
-
-
-enum class SmallestEncoding {
-    ASCII,
-    Latin1,
-    UTF16
-};
-
-
-
-
-
-
-SmallestEncoding
-FindSmallestEncoding(UTF8Chars utf8);
-
-
-
-
-
-
-
-extern Latin1CharsZ
-UTF8CharsToNewLatin1CharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
-
-
-
-
-
-
-extern Latin1CharsZ
-LossyUTF8CharsToNewLatin1CharsZ(JSContext* cx, const UTF8Chars utf8, size_t* outlen);
-
-
-
-
-
-extern bool
-StringIsASCII(const char* s);
-
-}
-
-inline void JS_free(JS::Latin1CharsZ& ptr) { js_free((void*)ptr.get()); }
-inline void JS_free(JS::UTF8CharsZ& ptr) { js_free((void*)ptr.get()); }
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-struct JSAtomState;
-struct JSFreeOp;
-struct JSFunctionSpec;
-
-namespace js {
-
-struct Class;
-class FreeOp;
-class Shape;
-
-
-
-extern const js::Class* const FunctionClassPtr;
-
-}
-
-namespace JS {
-
-class AutoIdVector;
-
-
-
-
-
-enum class IsArrayAnswer
-{
-    Array,
-    NotArray,
-    RevokedProxy
-};
-# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-extern bool
-IsArray(JSContext* cx, HandleObject obj, bool* isArray);
-# 79 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-extern bool
-IsArray(JSContext* cx, HandleObject obj, IsArrayAnswer* answer);
-# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-class ObjectOpResult
-{
-  private:
-# 127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    uintptr_t code_;
-
-  public:
-    enum SpecialCodes : uintptr_t {
-        OkCode = 0,
-        Uninitialized = uintptr_t(-1)
-    };
-
-    ObjectOpResult() : code_(Uninitialized) {}
-
-
-    bool ok() const {
-        do { } while (0);
-        return code_ == OkCode;
-    }
-
-    explicit operator bool() const { return ok(); }
-
-
-    bool succeed() {
-        code_ = OkCode;
-        return true;
-    }
-# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    bool fail(uint32_t msg) {
-        do { } while (0);
-        code_ = msg;
-        return true;
-    }
-
-    bool failCantRedefineProp();
-    bool failReadOnly();
-    bool failGetterOnly();
-    bool failCantDelete();
-
-    bool failCantSetInterposed();
-    bool failCantDefineWindowElement();
-    bool failCantDeleteWindowElement();
-    bool failCantDeleteWindowNamedProperty();
-    bool failCantPreventExtensions();
-    bool failCantSetProto();
-    bool failNoNamedSetter();
-    bool failNoIndexedSetter();
-
-    uint32_t failureCode() const {
-        do { } while (0);
-        return uint32_t(code_);
-    }
-# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    bool checkStrictErrorOrWarning(JSContext* cx, HandleObject obj, HandleId id, bool strict) {
-        if (ok())
-            return true;
-        return reportStrictErrorOrWarning(cx, obj, id, strict);
-    }
-
-
-
-
-
-
-
-    bool checkStrictErrorOrWarning(JSContext* cx, HandleObject obj, bool strict) {
-        return ok() || reportStrictErrorOrWarning(cx, obj, strict);
-    }
-
-
-    bool reportError(JSContext* cx, HandleObject obj, HandleId id) {
-        return reportStrictErrorOrWarning(cx, obj, id, true);
-    }
-
-
-
-
-
-    bool reportError(JSContext* cx, HandleObject obj) {
-        return reportStrictErrorOrWarning(cx, obj, true);
-    }
-
-
-    bool reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, HandleId id, bool strict);
-    bool reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, bool strict);
-
-
-
-
-
-    bool checkStrict(JSContext* cx, HandleObject obj, HandleId id) {
-        return checkStrictErrorOrWarning(cx, obj, id, true);
-    }
-
-
-
-
-
-    bool checkStrict(JSContext* cx, HandleObject obj) {
-        return checkStrictErrorOrWarning(cx, obj, true);
-    }
-};
-
-class PropertyResult
-{
-    union {
-        js::Shape* shape_;
-        uintptr_t bits_;
-    };
-
-    static const uintptr_t NotFound = 0;
-    static const uintptr_t NonNativeProperty = 1;
-    static const uintptr_t DenseOrTypedArrayElement = 1;
-
-  public:
-    PropertyResult() : bits_(NotFound) {}
-
-    explicit PropertyResult(js::Shape* propertyShape)
-      : shape_(propertyShape)
-    {
-        do { } while (0);
-    }
-
-    explicit operator bool() const {
-        return isFound();
-    }
-
-    bool isFound() const {
-        return bits_ != NotFound;
-    }
-
-    bool isNonNativeProperty() const {
-        return bits_ == NonNativeProperty;
-    }
-
-    bool isDenseOrTypedArrayElement() const {
-        return bits_ == DenseOrTypedArrayElement;
-    }
-
-    bool isNativeProperty() const {
-        return isFound() && !isNonNativeProperty();
-    }
-
-    js::Shape* maybeShape() const {
-        do { } while (0);
-        return isFound() ? shape_ : nullptr;
-    }
-
-    js::Shape* shape() const {
-        do { } while (0);
-        return shape_;
-    }
-
-    void setNotFound() {
-        bits_ = NotFound;
-    }
-
-    void setNativeProperty(js::Shape* propertyShape) {
-        shape_ = propertyShape;
-        do { } while (0);
-    }
-
-    void setNonNativeProperty() {
-        bits_ = NonNativeProperty;
-    }
-
-    void setDenseOrTypedArrayElement() {
-        bits_ = DenseOrTypedArrayElement;
-    }
-
-    void trace(JSTracer* trc);
-};
-
-}
-
-namespace js {
-
-template <class Wrapper>
-class WrappedPtrOperations<JS::PropertyResult, Wrapper>
-{
-    const JS::PropertyResult& value() const { return static_cast<const Wrapper*>(this)->get(); }
-
-  public:
-    bool isFound() const { return value().isFound(); }
-    explicit operator bool() const { return bool(value()); }
-    js::Shape* maybeShape() const { return value().maybeShape(); }
-    js::Shape* shape() const { return value().shape(); }
-    bool isNativeProperty() const { return value().isNativeProperty(); }
-    bool isNonNativeProperty() const { return value().isNonNativeProperty(); }
-    bool isDenseOrTypedArrayElement() const { return value().isDenseOrTypedArrayElement(); }
-    js::Shape* asTaggedShape() const { return value().asTaggedShape(); }
-};
-
-template <class Wrapper>
-class MutableWrappedPtrOperations<JS::PropertyResult, Wrapper>
-  : public WrappedPtrOperations<JS::PropertyResult, Wrapper>
-{
-    JS::PropertyResult& value() { return static_cast<Wrapper*>(this)->get(); }
-
-  public:
-    void setNotFound() {
-        value().setNotFound();
-    }
-    void setNativeProperty(js::Shape* shape) {
-        value().setNativeProperty(shape);
-    }
-    void setNonNativeProperty() {
-        value().setNonNativeProperty();
-    }
-    void setDenseOrTypedArrayElement() {
-        value().setDenseOrTypedArrayElement();
-    }
-};
-
-}
-# 371 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSGetterOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-               JS::MutableHandleValue vp);
-
-
-typedef bool
-(* JSAddPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v);
-# 386 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSSetterOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-               JS::MutableHandleValue vp, JS::ObjectOpResult& result);
-# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSDeletePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                       JS::ObjectOpResult& result);
-# 422 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSNewEnumerateOp)(JSContext* cx, JS::HandleObject obj, JS::AutoIdVector& properties,
-                     bool enumerableOnly);
-
-
-
-
-
-typedef bool
-(* JSEnumerateOp)(JSContext* cx, JS::HandleObject obj);
-
-
-
-
-
-
-typedef JSString*
-(* JSFunToStringOp)(JSContext* cx, JS::HandleObject obj, unsigned indent);
-# 450 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSResolveOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                bool* resolvedp);
-# 465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef bool
-(* JSMayResolveOp)(const JSAtomState& names, jsid id, JSObject* maybeObj);
-
-
-
-
-
-
-typedef void
-(* JSFinalizeOp)(JSFreeOp* fop, JSObject* obj);
-
-
-struct JSStringFinalizer {
-    void (*finalize)(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
-};
-
-
-
-
-
-
-typedef bool
-(* JSHasInstanceOp)(JSContext* cx, JS::HandleObject obj, JS::MutableHandleValue vp,
-                    bool* bp);
-# 504 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-typedef void
-(* JSTraceOp)(JSTracer* trc, JSObject* obj);
-
-typedef JSObject*
-(* JSWeakmapKeyDelegateOp)(JSObject* obj);
-
-typedef void
-(* JSObjectMovedOp)(JSObject* obj, const JSObject* old);
-
-
-
-namespace js {
-
-typedef bool
-(* LookupPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                     JS::MutableHandleObject objp, JS::MutableHandle<JS::PropertyResult> propp);
-typedef bool
-(* DefinePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                     JS::Handle<JS::PropertyDescriptor> desc,
-                     JS::ObjectOpResult& result);
-typedef bool
-(* HasPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
-typedef bool
-(* GetPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleValue receiver, JS::HandleId id,
-                  JS::MutableHandleValue vp);
-typedef bool
-(* SetPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v,
-                  JS::HandleValue receiver, JS::ObjectOpResult& result);
-typedef bool
-(* GetOwnPropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                     JS::MutableHandle<JS::PropertyDescriptor> desc);
-typedef bool
-(* DeletePropertyOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                     JS::ObjectOpResult& result);
-
-typedef bool
-(* WatchOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
-
-typedef bool
-(* UnwatchOp)(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
-
-class ElementAdder
-{
-  public:
-    enum GetBehavior {
-
-
-        CheckHasElemPreserveHoles,
-
-
-        GetElement
-    };
-
-  private:
-
-    JS::RootedObject resObj_;
-    JS::Value* vp_;
-
-    uint32_t index_;
-
-
-
-    GetBehavior getBehavior_;
-
-  public:
-    ElementAdder(JSContext* cx, JSObject* obj, uint32_t length, GetBehavior behavior)
-      : resObj_(cx, obj), vp_(nullptr), index_(0),
-
-
-
-        getBehavior_(behavior)
-    {}
-    ElementAdder(JSContext* cx, JS::Value* vp, uint32_t length, GetBehavior behavior)
-      : resObj_(cx), vp_(vp), index_(0),
-
-
-
-        getBehavior_(behavior)
-    {}
-
-    GetBehavior getBehavior() const { return getBehavior_; }
-
-    bool append(JSContext* cx, JS::HandleValue v);
-    void appendHole();
-};
-
-typedef bool
-(* GetElementsOp)(JSContext* cx, JS::HandleObject obj, uint32_t begin, uint32_t end,
-                  ElementAdder* adder);
-
-typedef void
-(* FinalizeOp)(FreeOp* fop, JSObject* obj);
-# 635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-struct ClassOps
-{
-
-    JSAddPropertyOp addProperty;
-    JSDeletePropertyOp delProperty;
-    JSGetterOp getProperty;
-    JSSetterOp setProperty;
-    JSEnumerateOp enumerate;
-    JSResolveOp resolve;
-    JSMayResolveOp mayResolve;
-    FinalizeOp finalize;
-    JSNative call;
-    JSHasInstanceOp hasInstance;
-    JSNative construct;
-    JSTraceOp trace;
-};
-
-
-typedef JSObject* (*ClassObjectCreationOp)(JSContext* cx, JSProtoKey key);
-
-
-typedef bool (*FinishClassInitOp)(JSContext* cx, JS::HandleObject ctor,
-                                  JS::HandleObject proto);
-
-const size_t JSCLASS_CACHED_PROTO_WIDTH = 6;
-
-struct ClassSpec
-{
-    ClassObjectCreationOp createConstructor;
-    ClassObjectCreationOp createPrototype;
-    const JSFunctionSpec* constructorFunctions;
-    const JSPropertySpec* constructorProperties;
-    const JSFunctionSpec* prototypeFunctions;
-    const JSPropertySpec* prototypeProperties;
-    FinishClassInitOp finishInit;
-    uintptr_t flags;
-
-    static const size_t ProtoKeyWidth = JSCLASS_CACHED_PROTO_WIDTH;
-
-    static const uintptr_t ProtoKeyMask = (1 << ProtoKeyWidth) - 1;
-    static const uintptr_t DontDefineConstructor = 1 << ProtoKeyWidth;
-
-    bool defined() const { return !!createConstructor; }
-
-
-    JSProtoKey inheritanceProtoKey() const {
-        do { } while (0);
-        static_assert(JSProto_Null == 0, "zeroed key must be null");
-
-
-        if (!(flags & ProtoKeyMask))
-            return JSProto_Object;
-
-        return JSProtoKey(flags & ProtoKeyMask);
-    }
-
-    bool shouldDefineConstructor() const {
-        do { } while (0);
-        return !(flags & DontDefineConstructor);
-    }
-};
-
-struct ClassExtension
-{
-# 710 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    JSWeakmapKeyDelegateOp weakmapKeyDelegateOp;
-# 723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    JSObjectMovedOp objectMovedOp;
-};
-
-
-
-
-struct ObjectOps
-{
-    LookupPropertyOp lookupProperty;
-    DefinePropertyOp defineProperty;
-    HasPropertyOp hasProperty;
-    GetPropertyOp getProperty;
-    SetPropertyOp setProperty;
-    GetOwnPropertyOp getOwnPropertyDescriptor;
-    DeletePropertyOp deleteProperty;
-    WatchOp watch;
-    UnwatchOp unwatch;
-    GetElementsOp getElements;
-    JSNewEnumerateOp enumerate;
-    JSFunToStringOp funToString;
-};
-
-
-
-}
-
-
-
-typedef void (*JSClassInternal)();
-
-struct JSClassOps
-{
-
-    JSAddPropertyOp addProperty;
-    JSDeletePropertyOp delProperty;
-    JSGetterOp getProperty;
-    JSSetterOp setProperty;
-    JSEnumerateOp enumerate;
-    JSResolveOp resolve;
-    JSMayResolveOp mayResolve;
-    JSFinalizeOp finalize;
-    JSNative call;
-    JSHasInstanceOp hasInstance;
-    JSNative construct;
-    JSTraceOp trace;
-};
-
-
-
-struct JSClass {
-    const char* name; uint32_t flags; const JSClassOps* cOps; JSAddPropertyOp getAddProperty() const { return cOps ? cOps->addProperty : nullptr; } JSDeletePropertyOp getDelProperty() const { return cOps ? cOps->delProperty : nullptr; } JSGetterOp getGetProperty() const { return cOps ? cOps->getProperty : nullptr; } JSSetterOp getSetProperty() const { return cOps ? cOps->setProperty : nullptr; } JSEnumerateOp getEnumerate() const { return cOps ? cOps->enumerate : nullptr; } JSResolveOp getResolve() const { return cOps ? cOps->resolve : nullptr; } JSMayResolveOp getMayResolve() const { return cOps ? cOps->mayResolve : nullptr; } JSNative getCall() const { return cOps ? cOps->call : nullptr; } JSHasInstanceOp getHasInstance() const { return cOps ? cOps->hasInstance : nullptr; } JSNative getConstruct() const { return cOps ? cOps->construct : nullptr; } bool hasFinalize() const { return cOps && cOps->finalize; } bool hasTrace() const { return cOps && cOps->trace; } bool isTrace(JSTraceOp trace) const { return cOps && cOps->trace == trace; } void doFinalize(JSFreeOp* fop, JSObject* obj) const { do { } while (0); cOps->finalize(fop, obj); } void doTrace(JSTracer* trc, JSObject* obj) const { do { } while (0); cOps->trace(trc, obj); };
-
-    void* reserved[3];
-};
-# 877 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-namespace js {
-
-struct Class
-{
-    const char* name; uint32_t flags; const js::ClassOps* cOps; JSAddPropertyOp getAddProperty() const { return cOps ? cOps->addProperty : nullptr; } JSDeletePropertyOp getDelProperty() const { return cOps ? cOps->delProperty : nullptr; } JSGetterOp getGetProperty() const { return cOps ? cOps->getProperty : nullptr; } JSSetterOp getSetProperty() const { return cOps ? cOps->setProperty : nullptr; } JSEnumerateOp getEnumerate() const { return cOps ? cOps->enumerate : nullptr; } JSResolveOp getResolve() const { return cOps ? cOps->resolve : nullptr; } JSMayResolveOp getMayResolve() const { return cOps ? cOps->mayResolve : nullptr; } JSNative getCall() const { return cOps ? cOps->call : nullptr; } JSHasInstanceOp getHasInstance() const { return cOps ? cOps->hasInstance : nullptr; } JSNative getConstruct() const { return cOps ? cOps->construct : nullptr; } bool hasFinalize() const { return cOps && cOps->finalize; } bool hasTrace() const { return cOps && cOps->trace; } bool isTrace(JSTraceOp trace) const { return cOps && cOps->trace == trace; } void doFinalize(FreeOp* fop, JSObject* obj) const { do { } while (0); cOps->finalize(fop, obj); } void doTrace(JSTracer* trc, JSObject* obj) const { do { } while (0); cOps->trace(trc, obj); };
-    const ClassSpec* spec;
-    const ClassExtension* ext;
-    const ObjectOps* oOps;
-# 893 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Class.h"
-    static const uint32_t NON_NATIVE = (1<<((8 + 8)+2));
-
-    bool isNative() const {
-        return !(flags & NON_NATIVE);
-    }
-
-    bool hasPrivate() const {
-        return !!(flags & (1<<0));
-    }
-
-    bool emulatesUndefined() const {
-        return flags & (1<<6);
-    }
-
-    bool isJSFunction() const {
-        return this == js::FunctionClassPtr;
-    }
-
-    bool nonProxyCallable() const {
-        do { } while (0);
-        return isJSFunction() || getCall();
-    }
-
-    bool isProxy() const {
-        return flags & (1<<((8 + 8)+4));
-    }
-
-    bool isDOMClass() const {
-        return flags & (1<<4);
-    }
-
-    bool shouldDelayMetadataBuilder() const {
-        return flags & (1<<1);
-    }
-
-    bool isWrappedNative() const {
-        return flags & (1<<2);
-    }
-
-    static size_t offsetOfFlags() { return __builtin_offsetof(Class, flags); }
-
-    bool specDefined() const { return spec ? spec->defined() : false; }
-    JSProtoKey specInheritanceProtoKey()
-                               const { return spec ? spec->inheritanceProtoKey() : JSProto_Null; }
-    bool specShouldDefineConstructor()
-                               const { return spec ? spec->shouldDefineConstructor() : true; }
-    ClassObjectCreationOp specCreateConstructorHook()
-                               const { return spec ? spec->createConstructor : nullptr; }
-    ClassObjectCreationOp specCreatePrototypeHook()
-                               const { return spec ? spec->createPrototype : nullptr; }
-    const JSFunctionSpec* specConstructorFunctions()
-                               const { return spec ? spec->constructorFunctions : nullptr; }
-    const JSPropertySpec* specConstructorProperties()
-                               const { return spec ? spec->constructorProperties : nullptr; }
-    const JSFunctionSpec* specPrototypeFunctions()
-                               const { return spec ? spec->prototypeFunctions : nullptr; }
-    const JSPropertySpec* specPrototypeProperties()
-                               const { return spec ? spec->prototypeProperties : nullptr; }
-    FinishClassInitOp specFinishInitHook()
-                               const { return spec ? spec->finishInit : nullptr; }
-
-    JSWeakmapKeyDelegateOp extWeakmapKeyDelegateOp()
-                               const { return ext ? ext->weakmapKeyDelegateOp : nullptr; }
-    JSObjectMovedOp extObjectMovedOp()
-                               const { return ext ? ext->objectMovedOp : nullptr; }
-
-    LookupPropertyOp getOpsLookupProperty() const { return oOps ? oOps->lookupProperty : nullptr; }
-    DefinePropertyOp getOpsDefineProperty() const { return oOps ? oOps->defineProperty : nullptr; }
-    HasPropertyOp getOpsHasProperty() const { return oOps ? oOps->hasProperty : nullptr; }
-    GetPropertyOp getOpsGetProperty() const { return oOps ? oOps->getProperty : nullptr; }
-    SetPropertyOp getOpsSetProperty() const { return oOps ? oOps->setProperty : nullptr; }
-    GetOwnPropertyOp getOpsGetOwnPropertyDescriptor()
-                                            const { return oOps ? oOps->getOwnPropertyDescriptor
-                                                                                     : nullptr; }
-    DeletePropertyOp getOpsDeleteProperty() const { return oOps ? oOps->deleteProperty : nullptr; }
-    WatchOp getOpsWatch() const { return oOps ? oOps->watch : nullptr; }
-    UnwatchOp getOpsUnwatch() const { return oOps ? oOps->unwatch : nullptr; }
-    GetElementsOp getOpsGetElements() const { return oOps ? oOps->getElements : nullptr; }
-    JSNewEnumerateOp getOpsEnumerate() const { return oOps ? oOps->enumerate : nullptr; }
-    JSFunToStringOp getOpsFunToString() const { return oOps ? oOps->funToString : nullptr; }
-};
-
-static_assert(__builtin_offsetof(JSClassOps, addProperty) == __builtin_offsetof(ClassOps, addProperty),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, delProperty) == __builtin_offsetof(ClassOps, delProperty),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, getProperty) == __builtin_offsetof(ClassOps, getProperty),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, setProperty) == __builtin_offsetof(ClassOps, setProperty),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, enumerate) == __builtin_offsetof(ClassOps, enumerate),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, resolve) == __builtin_offsetof(ClassOps, resolve),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, mayResolve) == __builtin_offsetof(ClassOps, mayResolve),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, finalize) == __builtin_offsetof(ClassOps, finalize),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, call) == __builtin_offsetof(ClassOps, call),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, construct) == __builtin_offsetof(ClassOps, construct),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, hasInstance) == __builtin_offsetof(ClassOps, hasInstance),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(__builtin_offsetof(JSClassOps, trace) == __builtin_offsetof(ClassOps, trace),
-              "ClassOps and JSClassOps must be consistent");
-static_assert(sizeof(JSClassOps) == sizeof(ClassOps),
-              "ClassOps and JSClassOps must be consistent");
-
-static_assert(__builtin_offsetof(JSClass, name) == __builtin_offsetof(Class, name),
-              "Class and JSClass must be consistent");
-static_assert(__builtin_offsetof(JSClass, flags) == __builtin_offsetof(Class, flags),
-              "Class and JSClass must be consistent");
-static_assert(__builtin_offsetof(JSClass, cOps) == __builtin_offsetof(Class, cOps),
-              "Class and JSClass must be consistent");
-static_assert(sizeof(JSClass) == sizeof(Class),
-              "Class and JSClass must be consistent");
-
-static __attribute__((always_inline)) inline const JSClass*
-Jsvalify(const Class* c)
-{
-    return (const JSClass*)c;
-}
-
-static __attribute__((always_inline)) inline const Class*
-Valueify(const JSClass* c)
-{
-    return (const Class*)c;
-}
-
-
-
-
-
-enum class ESClass {
-    Object,
-    Array,
-    Number,
-    String,
-    Boolean,
-    RegExp,
-    ArrayBuffer,
-    SharedArrayBuffer,
-    Date,
-    Set,
-    Map,
-    Promise,
-    MapIterator,
-    SetIterator,
-    Arguments,
-    Error,
-
-
-    Other
-};
-
-
-bool
-Unbox(JSContext* cx, JS::HandleObject obj, JS::MutableHandleValue vp);
-
-
-
-
-
-
-}
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Vector.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Vector.h"
-namespace js {
-
-class TempAllocPolicy;
-
-namespace detail {
-
-template <typename T>
-struct TypeIsGCThing : mozilla::FalseType
-{};
-
-
-
-
-
-
-}
-
-template <typename T,
-          size_t MinInlineCapacity = 0,
-          class AllocPolicy = TempAllocPolicy,
-
-         typename = typename mozilla::EnableIf<!detail::TypeIsGCThing<T>::value>::Type
-         >
-using Vector = mozilla::Vector<T, MinInlineCapacity, AllocPolicy>;
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h" 2
-
-namespace JS {
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/GCVector.h"
-template <typename T,
-          size_t MinInlineCapacity = 0,
-          typename AllocPolicy = js::TempAllocPolicy>
-class GCVector
-{
-    mozilla::Vector<T, MinInlineCapacity, AllocPolicy> vector;
-
-  public:
-    explicit GCVector(AllocPolicy alloc = AllocPolicy())
-      : vector(alloc)
-    {}
-
-    GCVector(GCVector&& vec)
-      : vector(mozilla::Move(vec.vector))
-    {}
-
-    GCVector& operator=(GCVector&& vec) {
-        vector = mozilla::Move(vec.vector);
-        return *this;
-    }
-
-    size_t length() const { return vector.length(); }
-    bool empty() const { return vector.empty(); }
-    size_t capacity() const { return vector.capacity(); }
-
-    T* begin() { return vector.begin(); }
-    const T* begin() const { return vector.begin(); }
-
-    T* end() { return vector.end(); }
-    const T* end() const { return vector.end(); }
-
-    T& operator[](size_t i) { return vector[i]; }
-    const T& operator[](size_t i) const { return vector[i]; }
-
-    T& back() { return vector.back(); }
-    const T& back() const { return vector.back(); }
-
-    bool initCapacity(size_t cap) { return vector.initCapacity(cap); }
-    __attribute__ ((warn_unused_result)) bool reserve(size_t req) { return vector.reserve(req); }
-    void shrinkBy(size_t amount) { return vector.shrinkBy(amount); }
-    __attribute__ ((warn_unused_result)) bool growBy(size_t amount) { return vector.growBy(amount); }
-    __attribute__ ((warn_unused_result)) bool resize(size_t newLen) { return vector.resize(newLen); }
-
-    void clear() { return vector.clear(); }
-    void clearAndFree() { return vector.clearAndFree(); }
-
-    template<typename U> bool append(U&& item) { return vector.append(mozilla::Forward<U>(item)); }
-
-    template<typename... Args>
-    __attribute__ ((warn_unused_result)) bool
-    emplaceBack(Args&&... args) {
-        return vector.emplaceBack(mozilla::Forward<Args>(args)...);
-    }
-
-    template<typename U>
-    void infallibleAppend(U&& aU) {
-        return vector.infallibleAppend(mozilla::Forward<U>(aU));
-    }
-    void infallibleAppendN(const T& aT, size_t aN) {
-        return vector.infallibleAppendN(aT, aN);
-    }
-    template<typename U> void
-    infallibleAppend(const U* aBegin, const U* aEnd) {
-        return vector.infallibleAppend(aBegin, aEnd);
-    }
-    template<typename U> void infallibleAppend(const U* aBegin, size_t aLength) {
-        return vector.infallibleAppend(aBegin, aLength);
-    }
-
-    template<typename U, size_t O, class BP>
-    __attribute__ ((warn_unused_result)) bool appendAll(const mozilla::Vector<U, O, BP>& aU) { return vector.appendAll(aU); }
-    template<typename U, size_t O, class BP>
-    __attribute__ ((warn_unused_result)) bool appendAll(const GCVector<U, O, BP>& aU) {
-        return vector.append(aU.begin(), aU.length());
-    }
-
-    __attribute__ ((warn_unused_result)) bool appendN(const T& val, size_t count) { return vector.appendN(val, count); }
-
-    template<typename U>
-    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd) {
-        return vector.append(aBegin, aEnd);
-    }
-    template<typename U>
-    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength) {
-        return vector.append(aBegin, aLength);
-    }
-
-    void popBack() { return vector.popBack(); }
-    T popCopy() { return vector.popCopy(); }
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return vector.sizeOfExcludingThis(mallocSizeOf);
-    }
-
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return vector.sizeOfIncludingThis(mallocSizeOf);
-    }
-
-    static void trace(GCVector* vec, JSTracer* trc) { vec->trace(trc); }
-
-    void trace(JSTracer* trc) {
-        for (auto& elem : vector)
-            GCPolicy<T>::trace(trc, &elem, "vector element");
-    }
-
-    void sweep() {
-        uint32_t src, dst = 0;
-        for (src = 0; src < length(); src++) {
-            if (!GCPolicy<T>::needsSweep(&vector[src])) {
-                if (dst != src)
-                    vector[dst] = vector[src].unbarrieredGet();
-                dst++;
-            }
-        }
-
-        if (dst != length())
-            vector.shrinkTo(dst);
-    }
-};
-
-}
-
-namespace js {
-
-template <typename Wrapper, typename T, size_t Capacity, typename AllocPolicy>
-class WrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
-{
-    using Vec = JS::GCVector<T, Capacity, AllocPolicy>;
-    const Vec& vec() const { return static_cast<const Wrapper*>(this)->get(); }
-
-  public:
-    const AllocPolicy& allocPolicy() const { return vec().allocPolicy(); }
-    size_t length() const { return vec().length(); }
-    bool empty() const { return vec().empty(); }
-    size_t capacity() const { return vec().capacity(); }
-    const T* begin() const { return vec().begin(); }
-    const T* end() const { return vec().end(); }
-    const T& back() const { return vec().back(); }
-
-    JS::Handle<T> operator[](size_t aIndex) const {
-        return JS::Handle<T>::fromMarkedLocation(&vec().operator[](aIndex));
-    }
-};
-
-template <typename Wrapper, typename T, size_t Capacity, typename AllocPolicy>
-class MutableWrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
-  : public WrappedPtrOperations<JS::GCVector<T, Capacity, AllocPolicy>, Wrapper>
-{
-    using Vec = JS::GCVector<T, Capacity, AllocPolicy>;
-    const Vec& vec() const { return static_cast<const Wrapper*>(this)->get(); }
-    Vec& vec() { return static_cast<Wrapper*>(this)->get(); }
-
-  public:
-    const AllocPolicy& allocPolicy() const { return vec().allocPolicy(); }
-    AllocPolicy& allocPolicy() { return vec().allocPolicy(); }
-    const T* begin() const { return vec().begin(); }
-    T* begin() { return vec().begin(); }
-    const T* end() const { return vec().end(); }
-    T* end() { return vec().end(); }
-    const T& back() const { return vec().back(); }
-    T& back() { return vec().back(); }
-
-    JS::Handle<T> operator[](size_t aIndex) const {
-        return JS::Handle<T>::fromMarkedLocation(&vec().operator[](aIndex));
-    }
-    JS::MutableHandle<T> operator[](size_t aIndex) {
-        return JS::MutableHandle<T>::fromMarkedLocation(&vec().operator[](aIndex));
-    }
-
-    __attribute__ ((warn_unused_result)) bool initCapacity(size_t aRequest) { return vec().initCapacity(aRequest); }
-    __attribute__ ((warn_unused_result)) bool reserve(size_t aRequest) { return vec().reserve(aRequest); }
-    void shrinkBy(size_t aIncr) { vec().shrinkBy(aIncr); }
-    __attribute__ ((warn_unused_result)) bool growBy(size_t aIncr) { return vec().growBy(aIncr); }
-    __attribute__ ((warn_unused_result)) bool resize(size_t aNewLength) { return vec().resize(aNewLength); }
-    __attribute__ ((warn_unused_result)) bool growByUninitialized(size_t aIncr) { return vec().growByUninitialized(aIncr); }
-    void infallibleGrowByUninitialized(size_t aIncr) { vec().infallibleGrowByUninitialized(aIncr); }
-    __attribute__ ((warn_unused_result)) bool resizeUninitialized(size_t aNewLength) { return vec().resizeUninitialized(aNewLength); }
-    void clear() { vec().clear(); }
-    void clearAndFree() { vec().clearAndFree(); }
-    template<typename U>
-    __attribute__ ((warn_unused_result)) bool append(U&& aU) { return vec().append(mozilla::Forward<U>(aU)); }
-    template<typename... Args>
-    __attribute__ ((warn_unused_result)) bool emplaceBack(Args&&... aArgs) {
-        return vec().emplaceBack(mozilla::Forward<Args...>(aArgs...));
-    }
-    template<typename U, size_t O, class BP>
-    __attribute__ ((warn_unused_result)) bool appendAll(const mozilla::Vector<U, O, BP>& aU) { return vec().appendAll(aU); }
-    template<typename U, size_t O, class BP>
-    __attribute__ ((warn_unused_result)) bool appendAll(const JS::GCVector<U, O, BP>& aU) { return vec().appendAll(aU); }
-    __attribute__ ((warn_unused_result)) bool appendN(const T& aT, size_t aN) { return vec().appendN(aT, aN); }
-    template<typename U>
-    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, const U* aEnd) {
-        return vec().append(aBegin, aEnd);
-    }
-    template<typename U>
-    __attribute__ ((warn_unused_result)) bool append(const U* aBegin, size_t aLength) {
-        return vec().append(aBegin, aLength);
-    }
-    template<typename U> void infallibleAppend(U&& aU) {
-        vec().infallibleAppend(mozilla::Forward<U>(aU));
-    }
-    void infallibleAppendN(const T& aT, size_t aN) { vec().infallibleAppendN(aT, aN); }
-    template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd) {
-        vec().infallibleAppend(aBegin, aEnd);
-    }
-    template<typename U> void infallibleAppend(const U* aBegin, size_t aLength) {
-        vec().infallibleAppend(aBegin, aLength);
-    }
-    void popBack() { vec().popBack(); }
-    T popCopy() { return vec().popCopy(); }
-    template<typename U> T* insert(T* aP, U&& aVal) {
-        return vec().insert(aP, mozilla::Forward<U>(aVal));
-    }
-    void erase(T* aT) { vec().erase(aT); }
-    void erase(T* aBegin, T* aEnd) { vec().erase(aBegin, aEnd); }
-};
-
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ScopeExit.h" 1
-# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ScopeExit.h"
-namespace mozilla {
-
-template <typename ExitFunction>
-class ScopeExit {
-  ExitFunction mExitFunction;
-  bool mExecuteOnDestruction;
-
-
-public:
-  explicit ScopeExit(ExitFunction&& cleanup
-                                                    )
-   : mExitFunction(cleanup)
-   , mExecuteOnDestruction(true)
-  {
-    do { } while (0);
-  }
-
-  ScopeExit(ScopeExit&& rhs)
-   : mExitFunction(mozilla::Move(rhs.mExitFunction))
-   , mExecuteOnDestruction(rhs.mExecuteOnDestruction)
-  {
-    rhs.release();
-  }
-
-  ~ScopeExit() {
-    if (mExecuteOnDestruction) {
-      mExitFunction();
-    }
-  }
-
-  void release() {
-    mExecuteOnDestruction = false;
-  }
-
-private:
-  explicit ScopeExit(const ScopeExit&) = delete;
-  ScopeExit& operator=(const ScopeExit&) = delete;
-  ScopeExit& operator=(ScopeExit&&) = delete;
-};
-
-template <typename ExitFunction>
-ScopeExit<ExitFunction>
-MakeScopeExit(ExitFunction&& exitFunction)
-{
-  return ScopeExit<ExitFunction>(mozilla::Move(exitFunction));
-}
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
-namespace mozilla {
-
-template<typename AllocPolicy>
-class BufferList : private AllocPolicy
-{
-
-
-  struct Segment
-  {
-    char* mData;
-    size_t mSize;
-    size_t mCapacity;
-
-    Segment(char* aData, size_t aSize, size_t aCapacity)
-     : mData(aData),
-       mSize(aSize),
-       mCapacity(aCapacity)
-    {
-    }
-
-    Segment(const Segment&) = delete;
-    Segment& operator=(const Segment&) = delete;
-
-    Segment(Segment&&) = default;
-    Segment& operator=(Segment&&) = default;
-
-    char* Start() const { return mData; }
-    char* End() const { return mData + mSize; }
-  };
-
-  template<typename OtherAllocPolicy>
-  friend class BufferList;
-
- public:
-
-
-
-
-
-  static const size_t kSegmentAlignment = 8;
-
-
-
-
-
-
-  BufferList(size_t aInitialSize,
-             size_t aInitialCapacity,
-             size_t aStandardCapacity,
-             AllocPolicy aAP = AllocPolicy())
-   : AllocPolicy(aAP),
-     mOwning(true),
-     mSegments(aAP),
-     mSize(0),
-     mStandardCapacity(aStandardCapacity)
-  {
-    do { } while (0);
-    do { } while (0);
-
-    if (aInitialCapacity) {
-      AllocateSegment(aInitialSize, aInitialCapacity);
-    }
-  }
-
-  BufferList(const BufferList& aOther) = delete;
-
-  BufferList(BufferList&& aOther)
-   : mOwning(aOther.mOwning),
-     mSegments(Move(aOther.mSegments)),
-     mSize(aOther.mSize),
-     mStandardCapacity(aOther.mStandardCapacity)
-  {
-    aOther.mSegments.clear();
-    aOther.mSize = 0;
-  }
-
-  BufferList& operator=(const BufferList& aOther) = delete;
-
-  BufferList& operator=(BufferList&& aOther)
-  {
-    Clear();
-
-    mOwning = aOther.mOwning;
-    mSegments = Move(aOther.mSegments);
-    mSize = aOther.mSize;
-    aOther.mSegments.clear();
-    aOther.mSize = 0;
-    return *this;
-  }
-
-  ~BufferList() { Clear(); }
-
-
-  size_t Size() const { return mSize; }
-
-  void Clear()
-  {
-    if (mOwning) {
-      for (Segment& segment : mSegments) {
-        this->free_(segment.mData);
-      }
-    }
-    mSegments.clear();
-
-    mSize = 0;
-  }
-
-
-
-  class IterImpl
-  {
-
-
-
-
-    uintptr_t mSegment;
-    char* mData;
-    char* mDataEnd;
-
-    friend class BufferList;
-
-  public:
-    explicit IterImpl(const BufferList& aBuffers)
-     : mSegment(0),
-       mData(nullptr),
-       mDataEnd(nullptr)
-    {
-      if (!aBuffers.mSegments.empty()) {
-        mData = aBuffers.mSegments[0].Start();
-        mDataEnd = aBuffers.mSegments[0].End();
-      }
-    }
-
-
-
-    char* Data() const
-    {
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(!Done())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(!Done()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "!Done()" ")"); do { *((volatile int*) __null) = 162; ::abort(); } while (0); } } while (0);
-      return mData;
-    }
-
-
-
-    bool HasRoomFor(size_t aBytes) const
-    {
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 170; ::abort(); } while (0); } } while (0);
-      return size_t(mDataEnd - mData) >= aBytes;
-    }
-
-
-
-    size_t RemainingInSegment() const
-    {
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 178; ::abort(); } while (0); } } while (0);
-      return mDataEnd - mData;
-    }
-
-
-
-
-
-    void Advance(const BufferList& aBuffers, size_t aBytes)
-    {
-      const Segment& segment = aBuffers.mSegments[mSegment];
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(segment.Start() <= mData)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(segment.Start() <= mData))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "segment.Start() <= mData" ")"); do { *((volatile int*) __null) = 189; ::abort(); } while (0); } } while (0);
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData <= mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData <= mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData <= mDataEnd" ")"); do { *((volatile int*) __null) = 190; ::abort(); } while (0); } } while (0);
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(mDataEnd == segment.End())>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mDataEnd == segment.End()))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mDataEnd == segment.End()" ")"); do { *((volatile int*) __null) = 191; ::abort(); } while (0); } } while (0);
-
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(HasRoomFor(aBytes))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(HasRoomFor(aBytes)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "HasRoomFor(aBytes)" ")"); do { *((volatile int*) __null) = 193; ::abort(); } while (0); } } while (0);
-      mData += aBytes;
-
-      if (mData == mDataEnd && mSegment + 1 < aBuffers.mSegments.length()) {
-        mSegment++;
-        const Segment& nextSegment = aBuffers.mSegments[mSegment];
-        mData = nextSegment.Start();
-        mDataEnd = nextSegment.End();
-        do { static_assert(mozilla::detail::AssertionConditionType<decltype(mData < mDataEnd)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mData < mDataEnd))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mData < mDataEnd" ")"); do { *((volatile int*) __null) = 201; ::abort(); } while (0); } } while (0);
-      }
-    }
-
-
-
-
-    bool AdvanceAcrossSegments(const BufferList& aBuffers, size_t aBytes)
-    {
-      size_t bytes = aBytes;
-      while (bytes) {
-        size_t toAdvance = std::min(bytes, RemainingInSegment());
-        if (!toAdvance) {
-          return false;
-        }
-        Advance(aBuffers, toAdvance);
-        bytes -= toAdvance;
-      }
-      return true;
-    }
-
-
-    bool Done() const
-    {
-      return mData == mDataEnd;
-    }
-
-   private:
-
-
-    size_t BytesUntil(const BufferList& aBuffers, const IterImpl& aTarget) const {
-      size_t offset = 0;
-
-      do { } while (0);
-
-      char* data = mData;
-      for (uintptr_t segment = mSegment; segment < aTarget.mSegment; segment++) {
-        offset += aBuffers.mSegments[segment].End() - data;
-        data = aBuffers.mSegments[segment].mData;
-      }
-
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(IsIn(aBuffers))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(IsIn(aBuffers)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "IsIn(aBuffers)" ")"); do { *((volatile int*) __null) = 242; ::abort(); } while (0); } } while (0);
-      do { static_assert(mozilla::detail::AssertionConditionType<decltype(aTarget.mData >= data)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aTarget.mData >= data))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aTarget.mData >= data" ")"); do { *((volatile int*) __null) = 243; ::abort(); } while (0); } } while (0);
-
-      offset += aTarget.mData - data;
-      return offset;
-    }
-
-    bool IsIn(const BufferList& aBuffers) const {
-      return mSegment < aBuffers.mSegments.length() &&
-             mData >= aBuffers.mSegments[mSegment].mData &&
-             mData < aBuffers.mSegments[mSegment].End();
-    }
-  };
-
-
-  char* Start() { return mSegments[0].mData; }
-  const char* Start() const { return mSegments[0].mData; }
-
-  IterImpl Iter() const { return IterImpl(*this); }
-
-
-
-  inline bool WriteBytes(const char* aData, size_t aSize);
-
-
-
-
-  inline bool ReadBytes(IterImpl& aIter, char* aData, size_t aSize) const;
-
-
-
-
-
-
-
-  template<typename BorrowingAllocPolicy>
-  BufferList<BorrowingAllocPolicy> Borrow(IterImpl& aIter, size_t aSize, bool* aSuccess,
-                                          BorrowingAllocPolicy aAP = BorrowingAllocPolicy()) const;
-
-
-
-
-
-
-
-  template<typename OtherAllocPolicy>
-  BufferList<OtherAllocPolicy> MoveFallible(bool* aSuccess, OtherAllocPolicy aAP = OtherAllocPolicy());
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BufferList.h"
-  BufferList Extract(IterImpl& aIter, size_t aSize, bool* aSuccess);
-
-
-
-  size_t RangeLength(const IterImpl& start, const IterImpl& end) const {
-    do { } while (0);
-    return start.BytesUntil(*this, end);
-  }
-
-private:
-  explicit BufferList(AllocPolicy aAP)
-   : AllocPolicy(aAP),
-     mOwning(false),
-     mSize(0),
-     mStandardCapacity(0)
-  {
-  }
-
-  void* AllocateSegment(size_t aSize, size_t aCapacity)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 318; ::abort(); } while (0); } } while (0);
-    do { } while (0);
-
-    char* data = this->template pod_malloc<char>(aCapacity);
-    if (!data) {
-      return nullptr;
-    }
-    if (!mSegments.append(Segment(data, aSize, aCapacity))) {
-      this->free_(data);
-      return nullptr;
-    }
-    mSize += aSize;
-    return data;
-  }
-
-  bool mOwning;
-  Vector<Segment, 1, AllocPolicy> mSegments;
-  size_t mSize;
-  size_t mStandardCapacity;
-};
-
-template<typename AllocPolicy>
-bool
-BufferList<AllocPolicy>::WriteBytes(const char* aData, size_t aSize)
-{
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 343; ::abort(); } while (0); } } while (0);
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mStandardCapacity)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mStandardCapacity))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mStandardCapacity" ")"); do { *((volatile int*) __null) = 344; ::abort(); } while (0); } } while (0);
-
-  size_t copied = 0;
-  size_t remaining = aSize;
-
-  if (!mSegments.empty()) {
-    Segment& lastSegment = mSegments.back();
-
-    size_t toCopy = std::min(aSize, lastSegment.mCapacity - lastSegment.mSize);
-    memcpy(lastSegment.mData + lastSegment.mSize, aData, toCopy);
-    lastSegment.mSize += toCopy;
-    mSize += toCopy;
-
-    copied += toCopy;
-    remaining -= toCopy;
-  }
-
-  while (remaining) {
-    size_t toCopy = std::min(remaining, mStandardCapacity);
-
-    void* data = AllocateSegment(toCopy, mStandardCapacity);
-    if (!data) {
-      return false;
-    }
-    memcpy(data, aData + copied, toCopy);
-
-    copied += toCopy;
-    remaining -= toCopy;
-  }
-
-  return true;
-}
-
-template<typename AllocPolicy>
-bool
-BufferList<AllocPolicy>::ReadBytes(IterImpl& aIter, char* aData, size_t aSize) const
-{
-  size_t copied = 0;
-  size_t remaining = aSize;
-  while (remaining) {
-    size_t toCopy = std::min(aIter.RemainingInSegment(), remaining);
-    if (!toCopy) {
-
-      return false;
-    }
-    memcpy(aData + copied, aIter.Data(), toCopy);
-    copied += toCopy;
-    remaining -= toCopy;
-
-    aIter.Advance(*this, toCopy);
-  }
-
-  return true;
-}
-
-template<typename AllocPolicy> template<typename BorrowingAllocPolicy>
-BufferList<BorrowingAllocPolicy>
-BufferList<AllocPolicy>::Borrow(IterImpl& aIter, size_t aSize, bool* aSuccess,
-                                BorrowingAllocPolicy aAP) const
-{
-  BufferList<BorrowingAllocPolicy> result(aAP);
-
-  size_t size = aSize;
-  while (size) {
-    size_t toAdvance = std::min(size, aIter.RemainingInSegment());
-
-    if (!toAdvance || !result.mSegments.append(typename BufferList<BorrowingAllocPolicy>::Segment(aIter.mData, toAdvance, toAdvance))) {
-      *aSuccess = false;
-      return result;
-    }
-    aIter.Advance(*this, toAdvance);
-    size -= toAdvance;
-  }
-
-  result.mSize = aSize;
-  *aSuccess = true;
-  return result;
-}
-
-template<typename AllocPolicy> template<typename OtherAllocPolicy>
-BufferList<OtherAllocPolicy>
-BufferList<AllocPolicy>::MoveFallible(bool* aSuccess, OtherAllocPolicy aAP)
-{
-  BufferList<OtherAllocPolicy> result(0, 0, mStandardCapacity, aAP);
-
-  IterImpl iter = Iter();
-  while (!iter.Done()) {
-    size_t toAdvance = iter.RemainingInSegment();
-
-    if (!toAdvance || !result.mSegments.append(typename BufferList<OtherAllocPolicy>::Segment(iter.mData, toAdvance, toAdvance))) {
-      *aSuccess = false;
-      result.mSegments.clear();
-      return result;
-    }
-    iter.Advance(*this, toAdvance);
-  }
-
-  result.mSize = mSize;
-  mSegments.clear();
-  mSize = 0;
-  *aSuccess = true;
-  return result;
-}
-
-template<typename AllocPolicy>
-BufferList<AllocPolicy>
-BufferList<AllocPolicy>::Extract(IterImpl& aIter, size_t aSize, bool* aSuccess)
-{
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(aSize)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aSize))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aSize" ")"); do { *((volatile int*) __null) = 452; ::abort(); } while (0); } } while (0);
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(mOwning)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mOwning))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mOwning" ")"); do { *((volatile int*) __null) = 453; ::abort(); } while (0); } } while (0);
-  do { } while (0);
-  do { } while (0);
-
-  IterImpl iter = aIter;
-  size_t size = aSize;
-  size_t toCopy = std::min(size, aIter.RemainingInSegment());
-  do { } while (0);
-
-  BufferList result(0, toCopy, mStandardCapacity);
-  BufferList error(0, 0, mStandardCapacity);
-
-
-  if (!result.WriteBytes(aIter.mData, toCopy)) {
-    *aSuccess = false;
-    return error;
-  }
-  iter.Advance(*this, toCopy);
-  size -= toCopy;
-
-
-  auto resultGuard = MakeScopeExit([&] {
-    *aSuccess = false;
-    result.mSegments.erase(result.mSegments.begin()+1, result.mSegments.end());
-  });
-
-  size_t movedSize = 0;
-  uintptr_t toRemoveStart = iter.mSegment;
-  uintptr_t toRemoveEnd = iter.mSegment;
-  while (!iter.Done() &&
-         !iter.HasRoomFor(size)) {
-    if (!result.mSegments.append(Segment(mSegments[iter.mSegment].mData,
-                                         mSegments[iter.mSegment].mSize,
-                                         mSegments[iter.mSegment].mCapacity))) {
-      return error;
-    }
-    movedSize += iter.RemainingInSegment();
-    size -= iter.RemainingInSegment();
-    toRemoveEnd++;
-    iter.Advance(*this, iter.RemainingInSegment());
-  }
-
-  if (size) {
-    if (!iter.HasRoomFor(size) ||
-        !result.WriteBytes(iter.Data(), size)) {
-      return error;
-    }
-    iter.Advance(*this, size);
-  }
-
-  mSegments.erase(mSegments.begin() + toRemoveStart, mSegments.begin() + toRemoveEnd);
-  mSize -= movedSize;
-  aIter.mSegment = iter.mSegment - (toRemoveEnd - toRemoveStart);
-  aIter.mData = iter.mData;
-  aIter.mDataEnd = iter.mDataEnd;
-  do { } while (0);
-  result.mSize = aSize;
-
-  resultGuard.release();
-  *aSuccess = true;
-  return result;
-}
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-struct JSRuntime;
-struct JSStructuredCloneReader;
-struct JSStructuredCloneWriter;
-
-
-
-namespace JS {
-
-enum class StructuredCloneScope : uint32_t {
-    SameProcessSameThread,
-    SameProcessDifferentThread,
-    DifferentProcess
-};
-
-enum TransferableOwnership {
-
-    SCTAG_TMO_UNFILLED = 0,
-
-
-    SCTAG_TMO_UNOWNED = 1,
-
-
-    SCTAG_TMO_FIRST_OWNED = 2,
-
-
-    SCTAG_TMO_ALLOC_DATA = 2,
-
-
-    SCTAG_TMO_MAPPED_DATA = 3,
-
-
-
-
-
-
-    SCTAG_TMO_CUSTOM = 4,
-
-    SCTAG_TMO_USER_MIN
-};
-
-class CloneDataPolicy
-{
-    bool sharedArrayBuffer_;
-
-  public:
-
-
-    CloneDataPolicy() :
-      sharedArrayBuffer_(true)
-    {}
-# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-    CloneDataPolicy& denySharedArrayBuffer() {
-        sharedArrayBuffer_ = false;
-        return *this;
-    }
-
-    bool isSharedArrayBufferAllowed() const {
-        return sharedArrayBuffer_;
-    }
-};
-
-}
-# 101 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-typedef JSObject* (*ReadStructuredCloneOp)(JSContext* cx, JSStructuredCloneReader* r,
-                                           uint32_t tag, uint32_t data, void* closure);
-# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-typedef bool (*WriteStructuredCloneOp)(JSContext* cx, JSStructuredCloneWriter* w,
-                                       JS::HandleObject obj, void* closure);
-
-
-
-
-
-
-typedef void (*StructuredCloneErrorOp)(JSContext* cx, uint32_t errorid);
-# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-typedef bool (*ReadTransferStructuredCloneOp)(JSContext* cx, JSStructuredCloneReader* r,
-                                              uint32_t tag, void* content, uint64_t extraData,
-                                              void* closure,
-                                              JS::MutableHandleObject returnObject);
-# 153 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-typedef bool (*TransferStructuredCloneOp)(JSContext* cx,
-                                          JS::Handle<JSObject*> obj,
-                                          void* closure,
-
-                                          uint32_t* tag,
-                                          JS::TransferableOwnership* ownership,
-                                          void** content,
-                                          uint64_t* extraData);
-
-
-
-
-
-
-typedef void (*FreeTransferStructuredCloneOp)(uint32_t tag, JS::TransferableOwnership ownership,
-                                              void* content, uint64_t extraData, void* closure);
-
-
-
-
-
-
-
-struct JSStructuredCloneCallbacks {
-    ReadStructuredCloneOp read;
-    WriteStructuredCloneOp write;
-    StructuredCloneErrorOp reportError;
-    ReadTransferStructuredCloneOp readTransfer;
-    TransferStructuredCloneOp writeTransfer;
-    FreeTransferStructuredCloneOp freeTransfer;
-};
-
-enum OwnTransferablePolicy {
-    OwnsTransferablesIfAny,
-    IgnoreTransferablesIfAny,
-    NoTransferables
-};
-
-class JSStructuredCloneData :
-    public mozilla::BufferList<js::SystemAllocPolicy>
-{
-    typedef js::SystemAllocPolicy AllocPolicy;
-    typedef mozilla::BufferList<js::SystemAllocPolicy> BufferList;
-
-    static const size_t kInitialSize = 0;
-    static const size_t kInitialCapacity = 4096;
-    static const size_t kStandardCapacity = 4096;
-
-    const JSStructuredCloneCallbacks* callbacks_;
-    void* closure_;
-    OwnTransferablePolicy ownTransferables_;
-
-    void setOptionalCallbacks(const JSStructuredCloneCallbacks* callbacks,
-                              void* closure,
-                              OwnTransferablePolicy policy) {
-        callbacks_ = callbacks;
-        closure_ = closure;
-        ownTransferables_ = policy;
-    }
-
-    friend struct JSStructuredCloneWriter;
-    friend class JSAutoStructuredCloneBuffer;
-
-public:
-    explicit JSStructuredCloneData(AllocPolicy aAP = AllocPolicy())
-        : BufferList(kInitialSize, kInitialCapacity, kStandardCapacity, aAP)
-        , callbacks_(nullptr)
-        , closure_(nullptr)
-        , ownTransferables_(OwnTransferablePolicy::NoTransferables)
-    {}
-                 JSStructuredCloneData(BufferList&& buffers)
-        : BufferList(Move(buffers))
-        , callbacks_(nullptr)
-        , closure_(nullptr)
-        , ownTransferables_(OwnTransferablePolicy::NoTransferables)
-    {}
-    JSStructuredCloneData(JSStructuredCloneData&& other) = default;
-    JSStructuredCloneData& operator=(JSStructuredCloneData&& other) = default;
-    ~JSStructuredCloneData();
-
-    using BufferList::BufferList;
-};
-
-
-bool
-JS_ReadStructuredClone(JSContext* cx, JSStructuredCloneData& data, uint32_t version,
-                       JS::StructuredCloneScope scope,
-                       JS::MutableHandleValue vp,
-                       const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
-
-bool
-JS_WriteStructuredClone(JSContext* cx, JS::HandleValue v, JSStructuredCloneData* data,
-                        JS::StructuredCloneScope scope,
-                        JS::CloneDataPolicy cloneDataPolicy,
-                        const JSStructuredCloneCallbacks* optionalCallbacks,
-                        void* closure, JS::HandleValue transferable);
-
-bool
-JS_StructuredCloneHasTransferables(JSStructuredCloneData& data, bool* hasTransferable);
-
-bool
-JS_StructuredClone(JSContext* cx, JS::HandleValue v, JS::MutableHandleValue vp,
-                   const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
-
-
-class JSAutoStructuredCloneBuffer {
-    const JS::StructuredCloneScope scope_;
-    JSStructuredCloneData data_;
-    uint32_t version_;
-
-  public:
-    JSAutoStructuredCloneBuffer(JS::StructuredCloneScope scope,
-                                const JSStructuredCloneCallbacks* callbacks, void* closure)
-        : scope_(scope), version_(8)
-    {
-        data_.setOptionalCallbacks(callbacks, closure, OwnTransferablePolicy::NoTransferables);
-    }
-
-    JSAutoStructuredCloneBuffer(JSAutoStructuredCloneBuffer&& other);
-    JSAutoStructuredCloneBuffer& operator=(JSAutoStructuredCloneBuffer&& other);
-
-    ~JSAutoStructuredCloneBuffer() { clear(); }
-
-    JSStructuredCloneData& data() { return data_; }
-    bool empty() const { return !data_.Size(); }
-
-    void clear(const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
-
-
-    bool copy(const JSStructuredCloneData& data, uint32_t version=8,
-              const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
-
-
-
-
-
-
-    void adopt(JSStructuredCloneData&& data, uint32_t version=8,
-               const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
-
-
-
-
-    void steal(JSStructuredCloneData* data, uint32_t* versionp=nullptr,
-               const JSStructuredCloneCallbacks** callbacks=nullptr, void** closure=nullptr);
-
-
-
-
-
-
-
-    void abandon() { data_.ownTransferables_ = OwnTransferablePolicy::IgnoreTransferablesIfAny; }
-
-    bool read(JSContext* cx, JS::MutableHandleValue vp,
-              const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
-
-    bool write(JSContext* cx, JS::HandleValue v,
-               const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
-
-    bool write(JSContext* cx, JS::HandleValue v, JS::HandleValue transferable,
-               JS::CloneDataPolicy cloneDataPolicy,
-               const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
-
-  private:
-
-    JSAutoStructuredCloneBuffer(const JSAutoStructuredCloneBuffer& other) = delete;
-    JSAutoStructuredCloneBuffer& operator=(const JSAutoStructuredCloneBuffer& other) = delete;
-};
-# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/StructuredClone.h"
-bool
-JS_ReadUint32Pair(JSStructuredCloneReader* r, uint32_t* p1, uint32_t* p2);
-
-bool
-JS_ReadBytes(JSStructuredCloneReader* r, void* p, size_t len);
-
-bool
-JS_ReadTypedArray(JSStructuredCloneReader* r, JS::MutableHandleValue vp);
-
-bool
-JS_WriteUint32Pair(JSStructuredCloneWriter* w, uint32_t tag, uint32_t data);
-
-bool
-JS_WriteBytes(JSStructuredCloneWriter* w, const void* p, size_t len);
-
-bool
-JS_WriteString(JSStructuredCloneWriter* w, JS::HandleString str);
-
-bool
-JS_WriteTypedArray(JSStructuredCloneWriter* w, JS::HandleValue v);
-
-bool
-JS_ObjectNotWritten(JSStructuredCloneWriter* w, JS::HandleObject obj);
-
-JS::StructuredCloneScope
-JS_GetStructuredCloneScope(JSStructuredCloneWriter* w);
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h" 2
-
-namespace js {
-    struct PerformanceGroup;
-}
-
-struct JSPrincipals {
-
-    mozilla::Atomic<int32_t> refcount;
-
-
-
-    uint32_t debugToken;
-
-
-    JSPrincipals() : refcount(0) {}
-
-    void setDebugToken(uint32_t token) {
-
-        debugToken = token;
-
-    }
-
-
-
-
-
-    virtual bool write(JSContext* cx, JSStructuredCloneWriter* writer) = 0;
-
-
-
-
-
-    void dump();
-};
-
-extern void
-JS_HoldPrincipals(JSPrincipals* principals);
-
-extern void
-JS_DropPrincipals(JSContext* cx, JSPrincipals* principals);
-
-
-
-
-typedef bool
-(* JSSubsumesOp)(JSPrincipals* first, JSPrincipals* second);
-
-
-
-
-
-typedef bool
-(* JSCSPEvalChecker)(JSContext* cx);
-
-struct JSSecurityCallbacks {
-    JSCSPEvalChecker contentSecurityPolicyAllows;
-    JSSubsumesOp subsumes;
-};
-
-extern void
-JS_SetSecurityCallbacks(JSContext* cx, const JSSecurityCallbacks* callbacks);
-
-extern const JSSecurityCallbacks*
-JS_GetSecurityCallbacks(JSContext* cx);
-# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
-extern void
-JS_SetTrustedPrincipals(JSContext* cx, JSPrincipals* prin);
-
-typedef void
-(* JSDestroyPrincipalsOp)(JSPrincipals* principals);
-
-
-
-
-
-
-extern void
-JS_InitDestroyPrincipalsCallback(JSContext* cx, JSDestroyPrincipalsOp destroyPrincipals);
-# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Principals.h"
-using JSReadPrincipalsOp = bool (*)(JSContext* cx, JSStructuredCloneReader* reader,
-                                    JSPrincipals** outPrincipals);
-
-
-
-
-
-extern void
-JS_InitReadPrincipalsCallback(JSContext* cx, JSReadPrincipalsOp read);
-# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Realm.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Realm.h"
-struct JSContext;
-class JSObject;
-
-namespace JS {
-
-extern JSObject*
-GetRealmObjectPrototype(JSContext* cx);
-
-extern JSObject*
-GetRealmFunctionPrototype(JSContext* cx);
-
-extern JSObject*
-GetRealmArrayPrototype(JSContext* cx);
-
-extern JSObject*
-GetRealmErrorPrototype(JSContext* cx);
-
-extern JSObject*
-GetRealmIteratorPrototype(JSContext* cx);
-
-}
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RefCounted.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/RefCounted.h"
-namespace js {
-
-template <typename T>
-class RefCounted
-{
-    static const MozRefCountType DEAD = 0xffffdead;
-
-  protected:
-    RefCounted() : mRefCnt(0) {}
-    ~RefCounted() { do { } while (0); }
-
-  public:
-    void AddRef() const
-    {
-        do { } while (0);
-        ++mRefCnt;
-    }
-
-    void Release() const
-    {
-      do { } while (0);
-      MozRefCountType cnt = --mRefCnt;
-      if (0 == cnt) {
-
-
-
-          js_delete(const_cast<T*>(static_cast<const T*>(this)));
-      }
-    }
-
-  private:
-    mutable MozRefCountType mRefCnt;
-};
-
-template <typename T>
-class AtomicRefCounted
-{
-    static const MozRefCountType DEAD = 0xffffdead;
-
-  protected:
-    AtomicRefCounted() : mRefCnt(0) {}
-    ~AtomicRefCounted() { do { } while (0); }
-
-  public:
-    void AddRef() const
-    {
-        do { } while (0);
-        ++mRefCnt;
-    }
-
-    void Release() const
-    {
-        do { } while (0);
-        MozRefCountType cnt = --mRefCnt;
-        if (0 == cnt) {
-
-
-
-            js_delete(const_cast<T*>(static_cast<const T*>(this)));
-        }
-    }
-
-  private:
-    mutable mozilla::Atomic<MozRefCountType> mRefCnt;
-};
-
-}
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h" 2
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-namespace JS {
-
-class TwoByteChars;
-
-
-
-class AutoCheckRequestDepth
-{
-    JSContext* cx;
-  public:
-    explicit AutoCheckRequestDepth(JSContext* cx);
-    ~AutoCheckRequestDepth();
-};
-# 72 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-template <size_t N>
-class AutoValueArray : public AutoGCRooter
-{
-    const size_t length_;
-    Value elements_[N];
-
-  public:
-    explicit AutoValueArray(JSContext* cx
-                                                           )
-      : AutoGCRooter(cx, VALARRAY), length_(N)
-    {
-
-        mozilla::PodArrayZero(elements_);
-        do { } while (0);
-    }
-
-    unsigned length() const { return length_; }
-    const Value* begin() const { return elements_; }
-    Value* begin() { return elements_; }
-
-    HandleValue operator[](unsigned i) const {
-        do { } while (0);
-        return HandleValue::fromMarkedLocation(&elements_[i]);
-    }
-    MutableHandleValue operator[](unsigned i) {
-        do { } while (0);
-        return MutableHandleValue::fromMarkedLocation(&elements_[i]);
-    }
-
-
-};
-
-template<class T>
-class AutoVectorRooterBase : protected AutoGCRooter
-{
-    typedef js::Vector<T, 8> VectorImpl;
-    VectorImpl vector;
-
-  public:
-    explicit AutoVectorRooterBase(JSContext* cx, ptrdiff_t tag
-                                                             )
-      : AutoGCRooter(cx, tag), vector(cx)
-    {
-        do { } while (0);
-    }
-
-    typedef T ElementType;
-    typedef typename VectorImpl::Range Range;
-
-    size_t length() const { return vector.length(); }
-    bool empty() const { return vector.empty(); }
-
-    __attribute__ ((warn_unused_result)) bool append(const T& v) { return vector.append(v); }
-    __attribute__ ((warn_unused_result)) bool appendN(const T& v, size_t len) { return vector.appendN(v, len); }
-    __attribute__ ((warn_unused_result)) bool append(const T* ptr, size_t len) { return vector.append(ptr, len); }
-    __attribute__ ((warn_unused_result)) bool appendAll(const AutoVectorRooterBase<T>& other) {
-        return vector.appendAll(other.vector);
-    }
-
-    __attribute__ ((warn_unused_result)) bool insert(T* p, const T& val) { return vector.insert(p, val); }
-
-
-    void infallibleAppend(const T& v) { vector.infallibleAppend(v); }
-
-    void popBack() { vector.popBack(); }
-    T popCopy() { return vector.popCopy(); }
-
-    __attribute__ ((warn_unused_result)) bool growBy(size_t inc) {
-        size_t oldLength = vector.length();
-        if (!vector.growByUninitialized(inc))
-            return false;
-        makeRangeGCSafe(oldLength);
-        return true;
-    }
-
-    __attribute__ ((warn_unused_result)) bool resize(size_t newLength) {
-        size_t oldLength = vector.length();
-        if (newLength <= oldLength) {
-            vector.shrinkBy(oldLength - newLength);
-            return true;
-        }
-        if (!vector.growByUninitialized(newLength - oldLength))
-            return false;
-        makeRangeGCSafe(oldLength);
-        return true;
-    }
-
-    void clear() { vector.clear(); }
-
-    __attribute__ ((warn_unused_result)) bool reserve(size_t newLength) {
-        return vector.reserve(newLength);
-    }
-
-    JS::MutableHandle<T> operator[](size_t i) {
-        return JS::MutableHandle<T>::fromMarkedLocation(&vector[i]);
-    }
-    JS::Handle<T> operator[](size_t i) const {
-        return JS::Handle<T>::fromMarkedLocation(&vector[i]);
-    }
-
-    const T* begin() const { return vector.begin(); }
-    T* begin() { return vector.begin(); }
-
-    const T* end() const { return vector.end(); }
-    T* end() { return vector.end(); }
-
-    Range all() { return vector.all(); }
-
-    const T& back() const { return vector.back(); }
-
-    friend void AutoGCRooter::trace(JSTracer* trc);
-
-  private:
-    void makeRangeGCSafe(size_t oldLength) {
-        T* t = vector.begin() + oldLength;
-        for (size_t i = oldLength; i < vector.length(); ++i, ++t)
-            memset(t, 0, sizeof(T));
-    }
-
-
-};
-
-template <typename T>
-class AutoVectorRooter : public AutoVectorRooterBase<T>
-{
-  public:
-    explicit AutoVectorRooter(JSContext* cx
-                                                            )
-        : AutoVectorRooterBase<T>(cx, this->GetTag(T()))
-    {
-        do { } while (0);
-    }
-
-
-};
-
-class AutoValueVector : public Rooted<GCVector<Value, 8>> {
-    using Vec = GCVector<Value, 8>;
-    using Base = Rooted<Vec>;
-  public:
-    explicit AutoValueVector(JSContext* cx) : Base(cx, Vec(cx)) {}
-};
-
-class AutoIdVector : public Rooted<GCVector<jsid, 8>> {
-    using Vec = GCVector<jsid, 8>;
-    using Base = Rooted<Vec>;
-  public:
-    explicit AutoIdVector(JSContext* cx) : Base(cx, Vec(cx)) {}
-
-    bool appendAll(const AutoIdVector& other) { return this->Base::appendAll(other.get()); }
-};
-
-class AutoObjectVector : public Rooted<GCVector<JSObject*, 8>> {
-    using Vec = GCVector<JSObject*, 8>;
-    using Base = Rooted<Vec>;
-  public:
-    explicit AutoObjectVector(JSContext* cx) : Base(cx, Vec(cx)) {}
-};
-
-using ValueVector = JS::GCVector<JS::Value>;
-using IdVector = JS::GCVector<jsid>;
-using ScriptVector = JS::GCVector<JSScript*>;
-using StringVector = JS::GCVector<JSString*>;
-
-template<class Key, class Value>
-class AutoHashMapRooter : protected AutoGCRooter
-{
-  private:
-    typedef js::HashMap<Key, Value> HashMapImpl;
-
-  public:
-    explicit AutoHashMapRooter(JSContext* cx, ptrdiff_t tag
-                                                              )
-      : AutoGCRooter(cx, tag), map(cx)
-    {
-        do { } while (0);
-    }
-
-    typedef Key KeyType;
-    typedef Value ValueType;
-    typedef typename HashMapImpl::Entry Entry;
-    typedef typename HashMapImpl::Lookup Lookup;
-    typedef typename HashMapImpl::Ptr Ptr;
-    typedef typename HashMapImpl::AddPtr AddPtr;
-
-    bool init(uint32_t len = 16) {
-        return map.init(len);
-    }
-    bool initialized() const {
-        return map.initialized();
-    }
-    Ptr lookup(const Lookup& l) const {
-        return map.lookup(l);
-    }
-    void remove(Ptr p) {
-        map.remove(p);
-    }
-    AddPtr lookupForAdd(const Lookup& l) const {
-        return map.lookupForAdd(l);
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    bool add(AddPtr& p, const KeyInput& k, const ValueInput& v) {
-        return map.add(p, k, v);
-    }
-
-    bool add(AddPtr& p, const Key& k) {
-        return map.add(p, k);
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    bool relookupOrAdd(AddPtr& p, const KeyInput& k, const ValueInput& v) {
-        return map.relookupOrAdd(p, k, v);
-    }
-
-    typedef typename HashMapImpl::Range Range;
-    Range all() const {
-        return map.all();
-    }
-
-    typedef typename HashMapImpl::Enum Enum;
-
-    void clear() {
-        map.clear();
-    }
-
-    void finish() {
-        map.finish();
-    }
-
-    bool empty() const {
-        return map.empty();
-    }
-
-    uint32_t count() const {
-        return map.count();
-    }
-
-    size_t capacity() const {
-        return map.capacity();
-    }
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return map.sizeOfExcludingThis(mallocSizeOf);
-    }
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return map.sizeOfIncludingThis(mallocSizeOf);
-    }
-
-
-
-    bool has(const Lookup& l) const {
-        return map.has(l);
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    bool put(const KeyInput& k, const ValueInput& v) {
-        return map.put(k, v);
-    }
-
-    template<typename KeyInput, typename ValueInput>
-    bool putNew(const KeyInput& k, const ValueInput& v) {
-        return map.putNew(k, v);
-    }
-
-    Ptr lookupWithDefault(const Key& k, const Value& defaultValue) {
-        return map.lookupWithDefault(k, defaultValue);
-    }
-
-    void remove(const Lookup& l) {
-        map.remove(l);
-    }
-
-    friend void AutoGCRooter::trace(JSTracer* trc);
-
-  private:
-    AutoHashMapRooter(const AutoHashMapRooter& hmr) = delete;
-    AutoHashMapRooter& operator=(const AutoHashMapRooter& hmr) = delete;
-
-    HashMapImpl map;
-
-
-};
-
-template<class T>
-class AutoHashSetRooter : protected AutoGCRooter
-{
-  private:
-    typedef js::HashSet<T> HashSetImpl;
-
-  public:
-    explicit AutoHashSetRooter(JSContext* cx, ptrdiff_t tag
-                                                              )
-      : AutoGCRooter(cx, tag), set(cx)
-    {
-        do { } while (0);
-    }
-
-    typedef typename HashSetImpl::Lookup Lookup;
-    typedef typename HashSetImpl::Ptr Ptr;
-    typedef typename HashSetImpl::AddPtr AddPtr;
-
-    bool init(uint32_t len = 16) {
-        return set.init(len);
-    }
-    bool initialized() const {
-        return set.initialized();
-    }
-    Ptr lookup(const Lookup& l) const {
-        return set.lookup(l);
-    }
-    void remove(Ptr p) {
-        set.remove(p);
-    }
-    AddPtr lookupForAdd(const Lookup& l) const {
-        return set.lookupForAdd(l);
-    }
-
-    bool add(AddPtr& p, const T& t) {
-        return set.add(p, t);
-    }
-
-    bool relookupOrAdd(AddPtr& p, const Lookup& l, const T& t) {
-        return set.relookupOrAdd(p, l, t);
-    }
-
-    typedef typename HashSetImpl::Range Range;
-    Range all() const {
-        return set.all();
-    }
-
-    typedef typename HashSetImpl::Enum Enum;
-
-    void clear() {
-        set.clear();
-    }
-
-    void finish() {
-        set.finish();
-    }
-
-    bool empty() const {
-        return set.empty();
-    }
-
-    uint32_t count() const {
-        return set.count();
-    }
-
-    size_t capacity() const {
-        return set.capacity();
-    }
-
-    size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return set.sizeOfExcludingThis(mallocSizeOf);
-    }
-    size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
-        return set.sizeOfIncludingThis(mallocSizeOf);
-    }
-
-
-
-    bool has(const Lookup& l) const {
-        return set.has(l);
-    }
-
-    bool put(const T& t) {
-        return set.put(t);
-    }
-
-    bool putNew(const T& t) {
-        return set.putNew(t);
-    }
-
-    void remove(const Lookup& l) {
-        set.remove(l);
-    }
-
-    friend void AutoGCRooter::trace(JSTracer* trc);
-
-  private:
-    AutoHashSetRooter(const AutoHashSetRooter& hmr) = delete;
-    AutoHashSetRooter& operator=(const AutoHashSetRooter& hmr) = delete;
-
-    HashSetImpl set;
-
-
-};
-
-
-
-
-class CustomAutoRooter : private AutoGCRooter
-{
-  public:
-    template <typename CX>
-    explicit CustomAutoRooter(const CX& cx )
-      : AutoGCRooter(cx, CUSTOM)
-    {
-        do { } while (0);
-    }
-
-    friend void AutoGCRooter::trace(JSTracer* trc);
-
-  protected:
-    virtual ~CustomAutoRooter() {}
-
-
-    virtual void trace(JSTracer* trc) = 0;
-
-  private:
-
-};
-
-
-class HandleValueArray
-{
-    const size_t length_;
-    const Value * const elements_;
-
-    HandleValueArray(size_t len, const Value* elements) : length_(len), elements_(elements) {}
-
-  public:
-    explicit HandleValueArray(const RootedValue& value) : length_(1), elements_(value.address()) {}
-
-                 HandleValueArray(const AutoValueVector& values)
-      : length_(values.length()), elements_(values.begin()) {}
-
-    template <size_t N>
-                 HandleValueArray(const AutoValueArray<N>& values) : length_(N), elements_(values.begin()) {}
-
-
-                 HandleValueArray(const JS::CallArgs& args) : length_(args.length()), elements_(args.array()) {}
-
-
-    static HandleValueArray fromMarkedLocation(size_t len, const Value* elements) {
-        return HandleValueArray(len, elements);
-    }
-
-    static HandleValueArray subarray(const HandleValueArray& values, size_t startIndex, size_t len) {
-        do { } while (0);
-        return HandleValueArray(len, values.begin() + startIndex);
-    }
-
-    static HandleValueArray empty() {
-        return HandleValueArray(0, nullptr);
-    }
-
-    size_t length() const { return length_; }
-    const Value* begin() const { return elements_; }
-
-    HandleValue operator[](size_t i) const {
-        do { } while (0);
-        return HandleValue::fromMarkedLocation(&elements_[i]);
-    }
-};
-
-}
-
-
-
-struct JSFreeOp {
-  protected:
-    JSRuntime* runtime_;
-
-    explicit JSFreeOp(JSRuntime* rt)
-      : runtime_(rt) { }
-
-  public:
-    JSRuntime* runtime() const {
-        do { } while (0);
-        return runtime_;
-    }
-};
-
-
-
-
-
-typedef enum JSGCStatus {
-    JSGC_BEGIN,
-    JSGC_END
-} JSGCStatus;
-
-typedef void
-(* JSGCCallback)(JSContext* cx, JSGCStatus status, void* data);
-
-typedef void
-(* JSObjectsTenuredCallback)(JSContext* cx, void* data);
-
-typedef enum JSFinalizeStatus {
-
-
-
-
-
-    JSFINALIZE_GROUP_START,
-
-
-
-
-
-
-
-    JSFINALIZE_GROUP_END,
-
-
-
-
-    JSFINALIZE_COLLECTION_END
-} JSFinalizeStatus;
-
-typedef void
-(* JSFinalizeCallback)(JSFreeOp* fop, JSFinalizeStatus status, bool isZoneGC, void* data);
-
-typedef void
-(* JSWeakPointerZonesCallback)(JSContext* cx, void* data);
-
-typedef void
-(* JSWeakPointerCompartmentCallback)(JSContext* cx, JSCompartment* comp, void* data);
-
-typedef bool
-(* JSInterruptCallback)(JSContext* cx);
-
-typedef JSObject*
-(* JSGetIncumbentGlobalCallback)(JSContext* cx);
-
-typedef bool
-(* JSEnqueuePromiseJobCallback)(JSContext* cx, JS::HandleObject job,
-                                JS::HandleObject allocationSite, JS::HandleObject incumbentGlobal,
-                                void* data);
-
-enum class PromiseRejectionHandlingState {
-    Unhandled,
-    Handled
-};
-
-typedef void
-(* JSPromiseRejectionTrackerCallback)(JSContext* cx, JS::HandleObject promise,
-                                      PromiseRejectionHandlingState state, void* data);
-
-typedef void
-(* JSProcessPromiseCallback)(JSContext* cx, JS::HandleObject promise);
-# 624 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef enum JSExnType {
-    JSEXN_ERR,
-    JSEXN_FIRST = JSEXN_ERR,
-        JSEXN_INTERNALERR,
-        JSEXN_EVALERR,
-        JSEXN_RANGEERR,
-        JSEXN_REFERENCEERR,
-        JSEXN_SYNTAXERR,
-        JSEXN_TYPEERR,
-        JSEXN_URIERR,
-        JSEXN_DEBUGGEEWOULDRUN,
-        JSEXN_WASMCOMPILEERROR,
-        JSEXN_WASMLINKERROR,
-        JSEXN_WASMRUNTIMEERROR,
-    JSEXN_ERROR_LIMIT,
-    JSEXN_WARN = JSEXN_ERROR_LIMIT,
-    JSEXN_NOTE,
-    JSEXN_LIMIT
-} JSExnType;
-
-typedef struct JSErrorFormatString {
-
-    const char* name;
-
-
-    const char* format;
-
-
-    uint16_t argCount;
-
-
-    int16_t exnType;
-} JSErrorFormatString;
-
-typedef const JSErrorFormatString*
-(* JSErrorCallback)(void* userRef, const unsigned errorNumber);
-
-typedef bool
-(* JSLocaleToUpperCase)(JSContext* cx, JS::HandleString src, JS::MutableHandleValue rval);
-
-typedef bool
-(* JSLocaleToLowerCase)(JSContext* cx, JS::HandleString src, JS::MutableHandleValue rval);
-
-typedef bool
-(* JSLocaleCompare)(JSContext* cx, JS::HandleString src1, JS::HandleString src2,
-                    JS::MutableHandleValue rval);
-
-typedef bool
-(* JSLocaleToUnicode)(JSContext* cx, const char* src, JS::MutableHandleValue rval);
-# 683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef JSObject*
-(* JSWrapObjectCallback)(JSContext* cx, JS::HandleObject existing, JS::HandleObject obj);
-
-
-
-
-
-
-typedef void
-(* JSPreWrapCallback)(JSContext* cx, JS::HandleObject scope, JS::HandleObject obj,
-                      JS::HandleObject objectPassedToWrap,
-                      JS::MutableHandleObject retObj);
-
-struct JSWrapObjectCallbacks
-{
-    JSWrapObjectCallback wrap;
-    JSPreWrapCallback preWrap;
-};
-
-typedef void
-(* JSDestroyCompartmentCallback)(JSFreeOp* fop, JSCompartment* compartment);
-
-typedef size_t
-(* JSSizeOfIncludingThisCompartmentCallback)(mozilla::MallocSizeOf mallocSizeOf,
-                                             JSCompartment* compartment);
-
-typedef void
-(* JSZoneCallback)(JS::Zone* zone);
-
-typedef void
-(* JSCompartmentNameCallback)(JSContext* cx, JSCompartment* compartment,
-                              char* buf, size_t bufsize);
-# 724 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-using JSExternalStringSizeofCallback =
-    size_t (*)(JSString* str, mozilla::MallocSizeOf mallocSizeOf);
-
-
-
-static __attribute__((always_inline)) inline JS::Value
-JS_NumberValue(double d)
-{
-    int32_t i;
-    d = JS::CanonicalizeNaN(d);
-    if (mozilla::NumberIsInt32(d, &i))
-        return JS::Int32Value(i);
-    return JS::DoubleValue(d);
-}
-
-
-
-bool
-JS_StringHasBeenPinned(JSContext* cx, JSString* str);
-
-namespace JS {
-# 767 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class SourceBufferHolder final
-{
-  public:
-    enum Ownership {
-      NoOwnership,
-      GiveOwnership
-    };
-
-    SourceBufferHolder(const char16_t* data, size_t dataLength, Ownership ownership)
-      : data_(data),
-        length_(dataLength),
-        ownsChars_(ownership == GiveOwnership)
-    {
-
-
-        static const char16_t NullChar_ = 0;
-        if (!get()) {
-            data_ = &NullChar_;
-            length_ = 0;
-            ownsChars_ = false;
-        }
-    }
-
-    SourceBufferHolder(SourceBufferHolder&& other)
-      : data_(other.data_),
-        length_(other.length_),
-        ownsChars_(other.ownsChars_)
-    {
-        other.data_ = nullptr;
-        other.length_ = 0;
-        other.ownsChars_ = false;
-    }
-
-    ~SourceBufferHolder() {
-        if (ownsChars_)
-            js_free(const_cast<char16_t*>(data_));
-    }
-
-
-    const char16_t* get() const { return data_; }
-
-
-    size_t length() const { return length_; }
-
-
-
-    bool ownsChars() const { return ownsChars_; }
-# 827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    char16_t* take() {
-        do { } while (0);
-        ownsChars_ = false;
-        return const_cast<char16_t*>(data_);
-    }
-
-  private:
-    SourceBufferHolder(SourceBufferHolder&) = delete;
-    SourceBufferHolder& operator=(SourceBufferHolder&) = delete;
-
-    const char16_t* data_;
-    size_t length_;
-    bool ownsChars_;
-};
-
-}
-# 912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern int64_t
-JS_Now(void);
-
-
-extern JS::Value
-JS_GetNaNValue(JSContext* cx);
-
-extern JS::Value
-JS_GetNegativeInfinityValue(JSContext* cx);
-
-extern JS::Value
-JS_GetPositiveInfinityValue(JSContext* cx);
-
-extern JS::Value
-JS_GetEmptyStringValue(JSContext* cx);
-
-extern JSString*
-JS_GetEmptyString(JSContext* cx);
-
-extern bool
-JS_ValueToObject(JSContext* cx, JS::HandleValue v, JS::MutableHandleObject objp);
-
-extern JSFunction*
-JS_ValueToFunction(JSContext* cx, JS::HandleValue v);
-
-extern JSFunction*
-JS_ValueToConstructor(JSContext* cx, JS::HandleValue v);
-
-extern JSString*
-JS_ValueToSource(JSContext* cx, JS::Handle<JS::Value> v);
-
-extern bool
-JS_DoubleIsInt32(double d, int32_t* ip);
-
-extern JSType
-JS_TypeOfValue(JSContext* cx, JS::Handle<JS::Value> v);
-
-namespace JS {
-
-extern const char*
-InformalValueTypeName(const JS::Value& v);
-
-}
-
-extern bool
-JS_StrictlyEqual(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* equal);
-
-extern bool
-JS_LooselyEqual(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* equal);
-
-extern bool
-JS_SameValue(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* same);
-
-
-extern bool
-JS_IsBuiltinEvalFunction(JSFunction* fun);
-
-
-extern bool
-JS_IsBuiltinFunctionConstructor(JSFunction* fun);
-# 986 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSContext*
-JS_NewContext(uint32_t maxbytes,
-              uint32_t maxNurseryBytes = JS::DefaultNurseryBytes,
-              JSRuntime* parentRuntime = nullptr);
-
-
-
-
-
-
-
-extern void
-JS_YieldCooperativeContext(JSContext* cx);
-
-
-
-extern void
-JS_ResumeCooperativeContext(JSContext* cx);
-
-
-
-
-
-extern JSContext*
-JS_NewCooperativeContext(JSContext* siblingContext);
-
-
-
-
-extern void
-JS_DestroyContext(JSContext* cx);
-
-void*
-JS_GetContextPrivate(JSContext* cx);
-
-void
-JS_SetContextPrivate(JSContext* cx, void* data);
-
-extern JSRuntime*
-JS_GetParentRuntime(JSContext* cx);
-
-extern void
-JS_BeginRequest(JSContext* cx);
-
-extern void
-JS_EndRequest(JSContext* cx);
-
-extern void
-JS_SetFutexCanWait(JSContext* cx);
-
-namespace JS {
-# 1051 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef void (*BeginSingleThreadedExecutionCallback)(JSContext* cx);
-typedef void (*EndSingleThreadedExecutionCallback)(JSContext* cx);
-
-extern void
-SetSingleThreadedExecutionCallbacks(JSContext* cx,
-                                    BeginSingleThreadedExecutionCallback begin,
-                                    EndSingleThreadedExecutionCallback end);
-
-}
-
-namespace js {
-
-void
-AssertHeapIsIdle();
-
-}
-
-class JSAutoRequest
-{
-  public:
-    explicit JSAutoRequest(JSContext* cx
-                                                          )
-      : mContext(cx)
-    {
-        do { } while (0);
-        JS_BeginRequest(mContext);
-    }
-    ~JSAutoRequest() {
-        JS_EndRequest(mContext);
-    }
-
-  protected:
-    JSContext* mContext;
-
-
-
-
-
-
-
-};
-
-extern JSVersion
-JS_GetVersion(JSContext* cx);
-# 1104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-void
-JS_SetVersionForCompartment(JSCompartment* compartment, JSVersion version);
-
-extern const char*
-JS_VersionToString(JSVersion version);
-
-extern JSVersion
-JS_StringToVersion(const char* string);
-
-namespace JS {
-
-class ContextOptions {
-  public:
-    ContextOptions()
-      : baseline_(true),
-        ion_(true),
-        asmJS_(true),
-        wasm_(false),
-        wasmAlwaysBaseline_(false),
-        throwOnAsmJSValidationFailure_(false),
-        nativeRegExp_(true),
-        unboxedArrays_(false),
-        asyncStack_(true),
-        throwOnDebuggeeWouldRun_(true),
-        dumpStackOnDebuggeeWouldRun_(false),
-        werror_(false),
-        strictMode_(false),
-        extraWarnings_(false),
-
-        forEachStatement_(false)
-
-
-
-    {
-    }
-
-    bool baseline() const { return baseline_; }
-    ContextOptions& setBaseline(bool flag) {
-        baseline_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleBaseline() {
-        baseline_ = !baseline_;
-        return *this;
-    }
-
-    bool ion() const { return ion_; }
-    ContextOptions& setIon(bool flag) {
-        ion_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleIon() {
-        ion_ = !ion_;
-        return *this;
-    }
-
-    bool asmJS() const { return asmJS_; }
-    ContextOptions& setAsmJS(bool flag) {
-        asmJS_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleAsmJS() {
-        asmJS_ = !asmJS_;
-        return *this;
-    }
-
-    bool wasm() const { return wasm_; }
-    ContextOptions& setWasm(bool flag) {
-        wasm_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleWasm() {
-        wasm_ = !wasm_;
-        return *this;
-    }
-
-    bool wasmAlwaysBaseline() const { return wasmAlwaysBaseline_; }
-    ContextOptions& setWasmAlwaysBaseline(bool flag) {
-        wasmAlwaysBaseline_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleWasmAlwaysBaseline() {
-        wasmAlwaysBaseline_ = !wasmAlwaysBaseline_;
-        return *this;
-    }
-
-    bool throwOnAsmJSValidationFailure() const { return throwOnAsmJSValidationFailure_; }
-    ContextOptions& setThrowOnAsmJSValidationFailure(bool flag) {
-        throwOnAsmJSValidationFailure_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleThrowOnAsmJSValidationFailure() {
-        throwOnAsmJSValidationFailure_ = !throwOnAsmJSValidationFailure_;
-        return *this;
-    }
-
-    bool nativeRegExp() const { return nativeRegExp_; }
-    ContextOptions& setNativeRegExp(bool flag) {
-        nativeRegExp_ = flag;
-        return *this;
-    }
-
-    bool unboxedArrays() const { return unboxedArrays_; }
-    ContextOptions& setUnboxedArrays(bool flag) {
-        unboxedArrays_ = flag;
-        return *this;
-    }
-
-    bool asyncStack() const { return asyncStack_; }
-    ContextOptions& setAsyncStack(bool flag) {
-        asyncStack_ = flag;
-        return *this;
-    }
-
-    bool throwOnDebuggeeWouldRun() const { return throwOnDebuggeeWouldRun_; }
-    ContextOptions& setThrowOnDebuggeeWouldRun(bool flag) {
-        throwOnDebuggeeWouldRun_ = flag;
-        return *this;
-    }
-
-    bool dumpStackOnDebuggeeWouldRun() const { return dumpStackOnDebuggeeWouldRun_; }
-    ContextOptions& setDumpStackOnDebuggeeWouldRun(bool flag) {
-        dumpStackOnDebuggeeWouldRun_ = flag;
-        return *this;
-    }
-
-    bool werror() const { return werror_; }
-    ContextOptions& setWerror(bool flag) {
-        werror_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleWerror() {
-        werror_ = !werror_;
-        return *this;
-    }
-
-    bool strictMode() const { return strictMode_; }
-    ContextOptions& setStrictMode(bool flag) {
-        strictMode_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleStrictMode() {
-        strictMode_ = !strictMode_;
-        return *this;
-    }
-
-    bool extraWarnings() const { return extraWarnings_; }
-    ContextOptions& setExtraWarnings(bool flag) {
-        extraWarnings_ = flag;
-        return *this;
-    }
-    ContextOptions& toggleExtraWarnings() {
-        extraWarnings_ = !extraWarnings_;
-        return *this;
-    }
-
-    bool forEachStatement() const { return forEachStatement_; }
-    ContextOptions& setForEachStatement(bool flag) {
-        forEachStatement_ = flag;
-        return *this;
-    }
-# 1274 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-  private:
-    bool baseline_ : 1;
-    bool ion_ : 1;
-    bool asmJS_ : 1;
-    bool wasm_ : 1;
-    bool wasmAlwaysBaseline_ : 1;
-    bool throwOnAsmJSValidationFailure_ : 1;
-    bool nativeRegExp_ : 1;
-    bool unboxedArrays_ : 1;
-    bool asyncStack_ : 1;
-    bool throwOnDebuggeeWouldRun_ : 1;
-    bool dumpStackOnDebuggeeWouldRun_ : 1;
-    bool werror_ : 1;
-    bool strictMode_ : 1;
-    bool extraWarnings_ : 1;
-    bool forEachStatement_: 1;
-
-
-
-
-};
-
-ContextOptions&
-ContextOptionsRef(JSContext* cx);
-
-
-
-
-
-
-bool
-InitSelfHostedCode(JSContext* cx);
-
-
-
-
-
-void
-AssertObjectBelongsToCurrentThread(JSObject* obj);
-
-}
-
-extern const char*
-JS_GetImplementationVersion(void);
-
-extern void
-JS_SetDestroyCompartmentCallback(JSContext* cx, JSDestroyCompartmentCallback callback);
-
-extern void
-JS_SetSizeOfIncludingThisCompartmentCallback(JSContext* cx,
-                                             JSSizeOfIncludingThisCompartmentCallback callback);
-
-extern void
-JS_SetDestroyZoneCallback(JSContext* cx, JSZoneCallback callback);
-
-extern void
-JS_SetSweepZoneCallback(JSContext* cx, JSZoneCallback callback);
-
-extern void
-JS_SetCompartmentNameCallback(JSContext* cx, JSCompartmentNameCallback callback);
-
-extern void
-JS_SetWrapObjectCallbacks(JSContext* cx, const JSWrapObjectCallbacks* callbacks);
-
-extern void
-JS_SetExternalStringSizeofCallback(JSContext* cx, JSExternalStringSizeofCallback callback);
-
-extern void
-JS_SetCompartmentPrivate(JSCompartment* compartment, void* data);
-
-extern void*
-JS_GetCompartmentPrivate(JSCompartment* compartment);
-
-extern void
-JS_SetZoneUserData(JS::Zone* zone, void* data);
-
-extern void*
-JS_GetZoneUserData(JS::Zone* zone);
-
-extern bool
-JS_WrapObject(JSContext* cx, JS::MutableHandleObject objp);
-
-extern bool
-JS_WrapValue(JSContext* cx, JS::MutableHandleValue vp);
-
-extern JSObject*
-JS_TransplantObject(JSContext* cx, JS::HandleObject origobj, JS::HandleObject target);
-
-extern bool
-JS_RefreshCrossCompartmentWrappers(JSContext* cx, JS::Handle<JSObject*> obj);
-# 1400 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class JSAutoCompartment
-{
-    JSContext* cx_;
-    JSCompartment* oldCompartment_;
-  public:
-    JSAutoCompartment(JSContext* cx, JSObject* target
-                                                     );
-    JSAutoCompartment(JSContext* cx, JSScript* target
-                                                     );
-    ~JSAutoCompartment();
-
-
-};
-
-class JSAutoNullableCompartment
-{
-    JSContext* cx_;
-    JSCompartment* oldCompartment_;
-  public:
-    explicit JSAutoNullableCompartment(JSContext* cx, JSObject* targetOrNull
-                                                                      );
-    ~JSAutoNullableCompartment();
-
-
-};
-
-
-extern JSCompartment*
-JS_EnterCompartment(JSContext* cx, JSObject* target);
-
-extern void
-JS_LeaveCompartment(JSContext* cx, JSCompartment* oldCompartment);
-
-typedef void (*JSIterateCompartmentCallback)(JSContext* cx, void* data, JSCompartment* compartment);
-
-
-
-
-
-
-extern void
-JS_IterateCompartments(JSContext* cx, void* data,
-                       JSIterateCompartmentCallback compartmentCallback);
-
-
-
-
-
-
-
-extern void
-JS_MarkCrossZoneId(JSContext* cx, jsid id);
-
-
-
-
-
-extern void
-JS_MarkCrossZoneIdValue(JSContext* cx, const JS::Value& value);
-# 1467 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_InitStandardClasses(JSContext* cx, JS::Handle<JSObject*> obj);
-# 1483 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ResolveStandardClass(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* resolved);
-
-extern bool
-JS_MayResolveStandardClass(const JSAtomState& names, jsid id, JSObject* maybeObj);
-
-extern bool
-JS_EnumerateStandardClasses(JSContext* cx, JS::HandleObject obj);
-
-extern bool
-JS_GetClassObject(JSContext* cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);
-
-extern bool
-JS_GetClassPrototype(JSContext* cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);
-
-namespace JS {
-
-
-
-
-
-
-extern JSProtoKey
-IdentifyStandardInstance(JSObject* obj);
-
-extern JSProtoKey
-IdentifyStandardPrototype(JSObject* obj);
-
-extern JSProtoKey
-IdentifyStandardInstanceOrPrototype(JSObject* obj);
-
-extern JSProtoKey
-IdentifyStandardConstructor(JSObject* obj);
-
-extern void
-ProtoKeyToId(JSContext* cx, JSProtoKey key, JS::MutableHandleId idp);
-
-}
-
-extern JSProtoKey
-JS_IdToProtoKey(JSContext* cx, JS::HandleId id);
-
-
-
-
-
-extern JSObject*
-JS_GetFunctionPrototype(JSContext* cx, JS::HandleObject forObj);
-
-
-
-
-
-extern JSObject*
-JS_GetObjectPrototype(JSContext* cx, JS::HandleObject forObj);
-
-
-
-
-
-extern JSObject*
-JS_GetArrayPrototype(JSContext* cx, JS::HandleObject forObj);
-
-
-
-
-
-extern JSObject*
-JS_GetErrorPrototype(JSContext* cx);
-
-
-
-
-
-extern JSObject*
-JS_GetIteratorPrototype(JSContext* cx);
-
-extern JSObject*
-JS_GetGlobalForObject(JSContext* cx, JSObject* obj);
-
-extern bool
-JS_IsGlobalObject(JSObject* obj);
-
-extern JSObject*
-JS_GlobalLexicalEnvironment(JSObject* obj);
-
-extern bool
-JS_HasExtensibleLexicalEnvironment(JSObject* obj);
-
-extern JSObject*
-JS_ExtensibleLexicalEnvironment(JSObject* obj);
-
-
-
-
-
-extern JSObject*
-JS_GetGlobalForCompartmentOrNull(JSContext* cx, JSCompartment* c);
-
-namespace JS {
-
-extern JSObject*
-CurrentGlobalOrNull(JSContext* cx);
-
-}
-
-
-
-
-
-extern bool
-JS_InitReflectParse(JSContext* cx, JS::HandleObject global);
-
-
-
-
-
-extern bool
-JS_DefineProfilingFunctions(JSContext* cx, JS::HandleObject obj);
-
-
-extern bool
-JS_DefineDebuggerObject(JSContext* cx, JS::HandleObject obj);
-
-
-
-
-
-
-extern bool
-JS_InitCTypesClass(JSContext* cx, JS::HandleObject global);
-
-
-
-
-
-
-typedef char*
-(* JSCTypesUnicodeToNativeFun)(JSContext* cx, const char16_t* source, size_t slen);
-
-
-
-
-
-
-struct JSCTypesCallbacks {
-    JSCTypesUnicodeToNativeFun unicodeToNative;
-};
-
-typedef struct JSCTypesCallbacks JSCTypesCallbacks;
-
-
-
-
-
-
-
-extern void
-JS_SetCTypesCallbacks(JSObject* ctypesObj, const JSCTypesCallbacks* callbacks);
-
-
-extern void*
-JS_malloc(JSContext* cx, size_t nbytes);
-
-extern void*
-JS_realloc(JSContext* cx, void* p, size_t oldBytes, size_t newBytes);
-
-
-
-
-
-
-extern void
-JS_free(JSContext* cx, void* p);
-
-
-
-
-
-extern void
-JS_freeop(JSFreeOp* fop, void* p);
-
-extern void
-JS_updateMallocCounter(JSContext* cx, size_t nbytes);
-
-extern char*
-JS_strdup(JSContext* cx, const char* s);
-# 1678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_AddExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
-
-
-extern void
-JS_RemoveExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
-
-
-
-
-extern void
-JS_GC(JSContext* cx);
-
-extern void
-JS_MaybeGC(JSContext* cx);
-
-extern void
-JS_SetGCCallback(JSContext* cx, JSGCCallback cb, void* data);
-
-extern void
-JS_SetObjectsTenuredCallback(JSContext* cx, JSObjectsTenuredCallback cb,
-                             void* data);
-
-extern bool
-JS_AddFinalizeCallback(JSContext* cx, JSFinalizeCallback cb, void* data);
-
-extern void
-JS_RemoveFinalizeCallback(JSContext* cx, JSFinalizeCallback cb);
-# 1741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_AddWeakPointerZonesCallback(JSContext* cx, JSWeakPointerZonesCallback cb, void* data);
-
-extern void
-JS_RemoveWeakPointerZonesCallback(JSContext* cx, JSWeakPointerZonesCallback cb);
-
-extern bool
-JS_AddWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb,
-                                     void* data);
-
-extern void
-JS_RemoveWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb);
-
-extern void
-JS_UpdateWeakPointerAfterGC(JS::Heap<JSObject*>* objp);
-
-extern void
-JS_UpdateWeakPointerAfterGCUnbarriered(JSObject** objp);
-
-typedef enum JSGCParamKey {
-
-    JSGC_MAX_BYTES = 0,
-
-
-    JSGC_MAX_MALLOC_BYTES = 1,
-
-
-    JSGC_MAX_NURSERY_BYTES = 2,
-
-
-    JSGC_BYTES = 3,
-
-
-    JSGC_NUMBER = 4,
-
-
-    JSGC_MODE = 6,
-
-
-    JSGC_UNUSED_CHUNKS = 7,
-
-
-    JSGC_TOTAL_CHUNKS = 8,
-
-
-    JSGC_SLICE_TIME_BUDGET = 9,
-
-
-    JSGC_MARK_STACK_LIMIT = 10,
-
-
-
-
-
-    JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11,
-
-
-    JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12,
-
-
-    JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13,
-
-
-    JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14,
-
-
-    JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15,
-
-
-    JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16,
-
-
-
-
-
-    JSGC_DYNAMIC_HEAP_GROWTH = 17,
-
-
-    JSGC_DYNAMIC_MARK_SLICE = 18,
-
-
-    JSGC_ALLOCATION_THRESHOLD = 19,
-
-
-
-
-
-    JSGC_MIN_EMPTY_CHUNK_COUNT = 21,
-
-
-    JSGC_MAX_EMPTY_CHUNK_COUNT = 22,
-
-
-    JSGC_COMPACTING_ENABLED = 23,
-
-
-    JSGC_REFRESH_FRAME_SLICES_ENABLED = 24,
-} JSGCParamKey;
-
-extern void
-JS_SetGCParameter(JSContext* cx, JSGCParamKey key, uint32_t value);
-
-extern uint32_t
-JS_GetGCParameter(JSContext* cx, JSGCParamKey key);
-
-extern void
-JS_SetGCParametersBasedOnAvailableMemory(JSContext* cx, uint32_t availMem);
-
-
-
-
-
-extern JSString*
-JS_NewExternalString(JSContext* cx, const char16_t* chars, size_t length,
-                     const JSStringFinalizer* fin);
-# 1864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSString*
-JS_NewMaybeExternalString(JSContext* cx, const char16_t* chars, size_t length,
-                          const JSStringFinalizer* fin, bool* isExternal);
-
-
-
-
-
-extern bool
-JS_IsExternalString(JSString* str);
-
-
-
-
-extern const JSStringFinalizer*
-JS_GetExternalStringFinalizer(JSString* str);
-# 1899 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-JS_SetNativeStackQuota(JSContext* cx, size_t systemCodeStackSize,
-                       size_t trustedScriptStackSize = 0,
-                       size_t untrustedScriptStackSize = 0);
-
-
-
-extern bool
-JS_ValueToId(JSContext* cx, JS::HandleValue v, JS::MutableHandleId idp);
-
-extern bool
-JS_StringToId(JSContext* cx, JS::HandleString s, JS::MutableHandleId idp);
-
-extern bool
-JS_IdToValue(JSContext* cx, jsid id, JS::MutableHandle<JS::Value> vp);
-
-namespace JS {
-# 1926 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-ToPrimitive(JSContext* cx, JS::HandleObject obj, JSType hint, JS::MutableHandleValue vp);
-# 1936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-GetFirstArgumentAsTypeHint(JSContext* cx, CallArgs args, JSType *result);
-
-}
-
-extern bool
-JS_PropertyStub(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                JS::MutableHandleValue vp);
-
-extern bool
-JS_StrictPropertyStub(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                      JS::MutableHandleValue vp, JS::ObjectOpResult& result);
-
-template<typename T>
-struct JSConstScalarSpec {
-    const char* name;
-    T val;
-};
-
-typedef JSConstScalarSpec<double> JSConstDoubleSpec;
-typedef JSConstScalarSpec<int32_t> JSConstIntegerSpec;
-
-struct JSJitInfo;
-
-
-
-
-
-
-typedef struct JSNativeWrapper {
-    JSNative op;
-    const JSJitInfo* info;
-} JSNativeWrapper;
-# 1981 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-struct JSPropertySpec {
-    struct SelfHostedWrapper {
-        void* unused;
-        const char* funname;
-    };
-
-    struct ValueWrapper {
-        uintptr_t type;
-        union {
-            const char* string;
-            int32_t int32;
-        };
-    };
-
-    const char* name;
-    uint8_t flags;
-    union {
-        struct {
-            union {
-                JSNativeWrapper native;
-                SelfHostedWrapper selfHosted;
-            } getter;
-            union {
-                JSNativeWrapper native;
-                SelfHostedWrapper selfHosted;
-            } setter;
-        } accessors;
-        ValueWrapper value;
-    };
-
-    bool isAccessor() const {
-        return !(flags & 0x80);
-    }
-    bool getValue(JSContext* cx, JS::MutableHandleValue value) const;
-
-    bool isSelfHosted() const {
-        do { } while (0);
-# 2026 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-        return (flags & 0x10);
-    }
-
-    static_assert(sizeof(SelfHostedWrapper) == sizeof(JSNativeWrapper),
-                  "JSPropertySpec::getter/setter must be compact");
-    static_assert(__builtin_offsetof(SelfHostedWrapper, funname) == __builtin_offsetof(JSNativeWrapper, info),
-                  "JS_SELF_HOSTED* macros below require that "
-                  "SelfHostedWrapper::funname overlay "
-                  "JSNativeWrapper::info");
-private:
-    void checkAccessorsAreNative() const {
-        do { } while (0);
-
-
-
-
-        do { } while (0);
-    }
-
-    void checkAccessorsAreSelfHosted() const {
-        do { } while (0);
-        do { } while (0);
-    }
-};
-
-namespace JS {
-namespace detail {
-
-
-inline int CheckIsNative(JSNative native);
-
-
-template<size_t N>
-inline int
-CheckIsCharacterLiteral(const char (&arr)[N]);
-
-
-inline int CheckIsInt32(int32_t value);
-
-
-inline int CheckIsGetterOp(JSGetterOp op);
-
-
-inline int CheckIsSetterOp(JSSetterOp op);
-
-}
-}
-# 2152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-struct JSFunctionSpec {
-    const char* name;
-    JSNativeWrapper call;
-    uint16_t nargs;
-    uint16_t flags;
-    const char* selfHostedName;
-};
-# 2200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-JS_InitClass(JSContext* cx, JS::HandleObject obj, JS::HandleObject parent_proto,
-             const JSClass* clasp, JSNative constructor, unsigned nargs,
-             const JSPropertySpec* ps, const JSFunctionSpec* fs,
-             const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs);
-
-
-
-
-
-extern bool
-JS_LinkConstructorAndPrototype(JSContext* cx, JS::Handle<JSObject*> ctor,
-                               JS::Handle<JSObject*> proto);
-
-extern const JSClass*
-JS_GetClass(JSObject* obj);
-
-extern bool
-JS_InstanceOf(JSContext* cx, JS::Handle<JSObject*> obj, const JSClass* clasp, JS::CallArgs* args);
-
-extern bool
-JS_HasInstance(JSContext* cx, JS::Handle<JSObject*> obj, JS::Handle<JS::Value> v, bool* bp);
-
-namespace JS {
-
-
-
-
-
-extern bool
-OrdinaryHasInstance(JSContext* cx, HandleObject objArg, HandleValue v, bool* bp);
-
-}
-
-extern void*
-JS_GetPrivate(JSObject* obj);
-
-extern void
-JS_SetPrivate(JSObject* obj, void* data);
-
-extern void*
-JS_GetInstancePrivate(JSContext* cx, JS::Handle<JSObject*> obj, const JSClass* clasp,
-                      JS::CallArgs* args);
-
-extern JSObject*
-JS_GetConstructor(JSContext* cx, JS::Handle<JSObject*> proto);
-
-namespace JS {
-
-
-enum ZoneSpecifier {
-
-
-    SystemZone,
-
-
-    ExistingZone,
-
-
-    NewZoneInNewZoneGroup,
-
-
-    NewZoneInSystemZoneGroup,
-
-
-    NewZoneInExistingZoneGroup
-};
-# 2276 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class CompartmentCreationOptions
-{
-  public:
-    CompartmentCreationOptions()
-      : addonId_(nullptr),
-        traceGlobal_(nullptr),
-        zoneSpec_(NewZoneInSystemZoneGroup),
-        zonePointer_(nullptr),
-        invisibleToDebugger_(false),
-        mergeable_(false),
-        preserveJitCode_(false),
-        cloneSingletons_(false),
-        experimentalNumberFormatFormatToPartsEnabled_(false),
-        sharedMemoryAndAtomics_(false),
-        secureContext_(false)
-    {}
-
-
-
-    JSAddonId* addonIdOrNull() const { return addonId_; }
-    CompartmentCreationOptions& setAddonId(JSAddonId* id) {
-        addonId_ = id;
-        return *this;
-    }
-
-    JSTraceOp getTrace() const {
-        return traceGlobal_;
-    }
-    CompartmentCreationOptions& setTrace(JSTraceOp op) {
-        traceGlobal_ = op;
-        return *this;
-    }
-
-    void* zonePointer() const { return zonePointer_; }
-    ZoneSpecifier zoneSpecifier() const { return zoneSpec_; }
-
-
-    CompartmentCreationOptions& setSystemZone();
-    CompartmentCreationOptions& setExistingZone(JSObject* obj);
-    CompartmentCreationOptions& setNewZoneInNewZoneGroup();
-    CompartmentCreationOptions& setNewZoneInSystemZoneGroup();
-    CompartmentCreationOptions& setNewZoneInExistingZoneGroup(JSObject* obj);
-
-
-
-
-
-    bool invisibleToDebugger() const { return invisibleToDebugger_; }
-    CompartmentCreationOptions& setInvisibleToDebugger(bool flag) {
-        invisibleToDebugger_ = flag;
-        return *this;
-    }
-
-
-
-
-
-    bool mergeable() const { return mergeable_; }
-    CompartmentCreationOptions& setMergeable(bool flag) {
-        mergeable_ = flag;
-        return *this;
-    }
-
-
-
-    bool preserveJitCode() const { return preserveJitCode_; }
-    CompartmentCreationOptions& setPreserveJitCode(bool flag) {
-        preserveJitCode_ = flag;
-        return *this;
-    }
-
-    bool cloneSingletons() const { return cloneSingletons_; }
-    CompartmentCreationOptions& setCloneSingletons(bool flag) {
-        cloneSingletons_ = flag;
-        return *this;
-    }
-# 2362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    bool experimentalNumberFormatFormatToPartsEnabled() const {
-        return experimentalNumberFormatFormatToPartsEnabled_;
-    }
-    CompartmentCreationOptions& setExperimentalNumberFormatFormatToPartsEnabled(bool flag) {
-        experimentalNumberFormatFormatToPartsEnabled_ = flag;
-        return *this;
-    }
-
-    bool getSharedMemoryAndAtomicsEnabled() const;
-    CompartmentCreationOptions& setSharedMemoryAndAtomicsEnabled(bool flag);
-
-
-
-
-
-    bool secureContext() const { return secureContext_; }
-    CompartmentCreationOptions& setSecureContext(bool flag) {
-        secureContext_ = flag;
-        return *this;
-    }
-
-  private:
-    JSAddonId* addonId_;
-    JSTraceOp traceGlobal_;
-    ZoneSpecifier zoneSpec_;
-    void* zonePointer_;
-    bool invisibleToDebugger_;
-    bool mergeable_;
-    bool preserveJitCode_;
-    bool cloneSingletons_;
-    bool experimentalNumberFormatFormatToPartsEnabled_;
-    bool sharedMemoryAndAtomics_;
-    bool secureContext_;
-};
-
-
-
-
-
-class CompartmentBehaviors
-{
-  public:
-    class Override {
-      public:
-        Override() : mode_(Default) {}
-
-        bool get(bool defaultValue) const {
-            if (mode_ == Default)
-                return defaultValue;
-            return mode_ == ForceTrue;
-        }
-
-        void set(bool overrideValue) {
-            mode_ = overrideValue ? ForceTrue : ForceFalse;
-        }
-
-        void reset() {
-            mode_ = Default;
-        }
-
-      private:
-        enum Mode {
-            Default,
-            ForceTrue,
-            ForceFalse
-        };
-
-        Mode mode_;
-    };
-
-    CompartmentBehaviors()
-      : version_(JSVERSION_UNKNOWN)
-      , discardSource_(false)
-      , disableLazyParsing_(false)
-      , singletonsAsTemplates_(true)
-    {
-    }
-
-    JSVersion version() const { return version_; }
-    CompartmentBehaviors& setVersion(JSVersion aVersion) {
-        do { } while (0);
-        version_ = aVersion;
-        return *this;
-    }
-
-
-
-    bool discardSource() const { return discardSource_; }
-    CompartmentBehaviors& setDiscardSource(bool flag) {
-        discardSource_ = flag;
-        return *this;
-    }
-
-    bool disableLazyParsing() const { return disableLazyParsing_; }
-    CompartmentBehaviors& setDisableLazyParsing(bool flag) {
-        disableLazyParsing_ = flag;
-        return *this;
-    }
-
-    bool extraWarnings(JSContext* cx) const;
-    Override& extraWarningsOverride() { return extraWarningsOverride_; }
-
-    bool getSingletonsAsTemplates() const {
-        return singletonsAsTemplates_;
-    }
-    CompartmentBehaviors& setSingletonsAsValues() {
-        singletonsAsTemplates_ = false;
-        return *this;
-    }
-
-  private:
-    JSVersion version_;
-    bool discardSource_;
-    bool disableLazyParsing_;
-    Override extraWarningsOverride_;
-
-
-
-
-    bool singletonsAsTemplates_;
-};
-
-
-
-
-
-
-
-class CompartmentOptions
-{
-  public:
-    explicit CompartmentOptions()
-      : creationOptions_(),
-        behaviors_()
-    {}
-
-    CompartmentOptions(const CompartmentCreationOptions& compartmentCreation,
-                       const CompartmentBehaviors& compartmentBehaviors)
-      : creationOptions_(compartmentCreation),
-        behaviors_(compartmentBehaviors)
-    {}
-
-
-
-
-    CompartmentCreationOptions& creationOptions() {
-        return creationOptions_;
-    }
-    const CompartmentCreationOptions& creationOptions() const {
-        return creationOptions_;
-    }
-
-
-
-    CompartmentBehaviors& behaviors() {
-        return behaviors_;
-    }
-    const CompartmentBehaviors& behaviors() const {
-        return behaviors_;
-    }
-
-  private:
-    CompartmentCreationOptions creationOptions_;
-    CompartmentBehaviors behaviors_;
-};
-
-const CompartmentCreationOptions&
-CompartmentCreationOptionsRef(JSCompartment* compartment);
-
-const CompartmentCreationOptions&
-CompartmentCreationOptionsRef(JSObject* obj);
-
-const CompartmentCreationOptions&
-CompartmentCreationOptionsRef(JSContext* cx);
-
-CompartmentBehaviors&
-CompartmentBehaviorsRef(JSCompartment* compartment);
-
-CompartmentBehaviors&
-CompartmentBehaviorsRef(JSObject* obj);
-
-CompartmentBehaviors&
-CompartmentBehaviorsRef(JSContext* cx);
-# 2568 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-enum OnNewGlobalHookOption {
-    FireOnNewGlobalHook,
-    DontFireOnNewGlobalHook
-};
-
-}
-
-extern JSObject*
-JS_NewGlobalObject(JSContext* cx, const JSClass* clasp, JSPrincipals* principals,
-                   JS::OnNewGlobalHookOption hookOption,
-                   const JS::CompartmentOptions& options);
-# 2588 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-JS_GlobalObjectTraceHook(JSTracer* trc, JSObject* global);
-
-extern void
-JS_FireOnNewGlobalObject(JSContext* cx, JS::HandleObject global);
-
-extern JSObject*
-JS_NewObject(JSContext* cx, const JSClass* clasp);
-
-extern bool
-JS_IsNative(JSObject* obj);
-
-
-
-
-
-extern JSObject*
-JS_NewObjectWithGivenProto(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
-
-
-extern JSObject*
-JS_NewPlainObject(JSContext* cx);
-
-
-
-
-
-
-extern bool
-JS_DeepFreezeObject(JSContext* cx, JS::Handle<JSObject*> obj);
-
-
-
-
-extern bool
-JS_FreezeObject(JSContext* cx, JS::Handle<JSObject*> obj);
-
-
-
-
-namespace JS {
-
-struct PropertyDescriptor {
-    JSObject* obj;
-    unsigned attrs;
-    JSGetterOp getter;
-    JSSetterOp setter;
-    JS::Value value;
-
-    PropertyDescriptor()
-      : obj(nullptr), attrs(0), getter(nullptr), setter(nullptr), value(JS::UndefinedValue())
-    {}
-
-    static void trace(PropertyDescriptor* self, JSTracer* trc) { self->trace(trc); }
-    void trace(JSTracer* trc);
-};
-
-}
-
-namespace js {
-
-template <typename Wrapper>
-class WrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
-{
-    const JS::PropertyDescriptor& desc() const { return static_cast<const Wrapper*>(this)->get(); }
-
-    bool has(unsigned bit) const {
-        do { } while (0);
-        do { } while (0);
-        return (desc().attrs & bit) != 0;
-    }
-
-    bool hasAny(unsigned bits) const {
-        return (desc().attrs & bits) != 0;
-    }
-
-    bool hasAll(unsigned bits) const {
-        return (desc().attrs & bits) == bits;
-    }
-
-
-    enum { SHADOWABLE = 0x80 };
-
-  public:
-
-
-    bool isAccessorDescriptor() const { return hasAny(0x10 | 0x20); }
-    bool isGenericDescriptor() const {
-        return (desc().attrs&
-                (0x10 | 0x20 | 0x8000 | 0x20000)) ==
-               (0x8000 | 0x20000);
-    }
-    bool isDataDescriptor() const { return !isAccessorDescriptor() && !isGenericDescriptor(); }
-
-    bool hasConfigurable() const { return !has(0x10000); }
-    bool configurable() const { do { } while (0); return !has(0x04); }
-
-    bool hasEnumerable() const { return !has(0x4000); }
-    bool enumerable() const { do { } while (0); return has(0x01); }
-
-    bool hasValue() const { return !isAccessorDescriptor() && !has(0x20000); }
-    JS::HandleValue value() const {
-        return JS::HandleValue::fromMarkedLocation(&desc().value);
-    }
-
-    bool hasWritable() const { return !isAccessorDescriptor() && !has(0x8000); }
-    bool writable() const { do { } while (0); return !has(0x02); }
-
-    bool hasGetterObject() const { return has(0x10); }
-    JS::HandleObject getterObject() const {
-        do { } while (0);
-        return JS::HandleObject::fromMarkedLocation(
-                reinterpret_cast<JSObject* const*>(&desc().getter));
-    }
-    bool hasSetterObject() const { return has(0x20); }
-    JS::HandleObject setterObject() const {
-        do { } while (0);
-        return JS::HandleObject::fromMarkedLocation(
-                reinterpret_cast<JSObject* const*>(&desc().setter));
-    }
-
-    bool hasGetterOrSetter() const { return desc().getter || desc().setter; }
-    bool isShared() const { return has(0x40); }
-
-    JS::HandleObject object() const {
-        return JS::HandleObject::fromMarkedLocation(&desc().obj);
-    }
-    unsigned attributes() const { return desc().attrs; }
-    JSGetterOp getter() const { return desc().getter; }
-    JSSetterOp setter() const { return desc().setter; }
-
-    void assertValid() const {
-# 2755 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    }
-
-    void assertComplete() const {
-# 2771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    }
-
-    void assertCompleteIfFound() const {
-
-
-
-
-    }
-};
-
-template <typename Wrapper>
-class MutableWrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
-    : public js::WrappedPtrOperations<JS::PropertyDescriptor, Wrapper>
-{
-    JS::PropertyDescriptor& desc() { return static_cast<Wrapper*>(this)->get(); }
-
-  public:
-    void clear() {
-        object().set(nullptr);
-        setAttributes(0);
-        setGetter(nullptr);
-        setSetter(nullptr);
-        value().setUndefined();
-    }
-
-    void initFields(JS::HandleObject obj, JS::HandleValue v, unsigned attrs,
-                    JSGetterOp getterOp, JSSetterOp setterOp) {
-        do { } while (0);
-        do { } while (0);
-
-        object().set(obj);
-        value().set(v);
-        setAttributes(attrs);
-        setGetter(getterOp);
-        setSetter(setterOp);
-    }
-
-    void assign(JS::PropertyDescriptor& other) {
-        object().set(other.obj);
-        setAttributes(other.attrs);
-        setGetter(other.getter);
-        setSetter(other.setter);
-        value().set(other.value);
-    }
-
-    void setDataDescriptor(JS::HandleValue v, unsigned attrs) {
-        do { } while (0);
-
-
-
-
-
-        object().set(nullptr);
-        setAttributes(attrs);
-        setGetter(nullptr);
-        setSetter(nullptr);
-        value().set(v);
-    }
-
-    JS::MutableHandleObject object() {
-        return JS::MutableHandleObject::fromMarkedLocation(&desc().obj);
-    }
-    unsigned& attributesRef() { return desc().attrs; }
-    JSGetterOp& getter() { return desc().getter; }
-    JSSetterOp& setter() { return desc().setter; }
-    JS::MutableHandleValue value() {
-        return JS::MutableHandleValue::fromMarkedLocation(&desc().value);
-    }
-    void setValue(JS::HandleValue v) {
-        do { } while (0);
-        attributesRef() &= ~0x20000;
-        value().set(v);
-    }
-
-    void setConfigurable(bool configurable) {
-        setAttributes((desc().attrs & ~(0x10000 | 0x04)) |
-                      (configurable ? 0 : 0x04));
-    }
-    void setEnumerable(bool enumerable) {
-        setAttributes((desc().attrs & ~(0x4000 | 0x01)) |
-                      (enumerable ? 0x01 : 0));
-    }
-    void setWritable(bool writable) {
-        do { } while (0);
-        setAttributes((desc().attrs & ~(0x8000 | 0x02)) |
-                      (writable ? 0 : 0x02));
-    }
-    void setAttributes(unsigned attrs) { desc().attrs = attrs; }
-
-    void setGetter(JSGetterOp op) {
-        do { } while (0);
-        desc().getter = op;
-    }
-    void setSetter(JSSetterOp op) {
-        do { } while (0);
-        desc().setter = op;
-    }
-    void setGetterObject(JSObject* obj) {
-        desc().getter = reinterpret_cast<JSGetterOp>(obj);
-        desc().attrs &= ~(0x20000 | 0x8000 | 0x02);
-        desc().attrs |= 0x10 | 0x40;
-    }
-    void setSetterObject(JSObject* obj) {
-        desc().setter = reinterpret_cast<JSSetterOp>(obj);
-        desc().attrs &= ~(0x20000 | 0x8000 | 0x02);
-        desc().attrs |= 0x20 | 0x40;
-    }
-
-    JS::MutableHandleObject getterObject() {
-        do { } while (0);
-        return JS::MutableHandleObject::fromMarkedLocation(
-                reinterpret_cast<JSObject**>(&desc().getter));
-    }
-    JS::MutableHandleObject setterObject() {
-        do { } while (0);
-        return JS::MutableHandleObject::fromMarkedLocation(
-                reinterpret_cast<JSObject**>(&desc().setter));
-    }
-};
-
-}
-
-namespace JS {
-
-extern bool
-ObjectToCompletePropertyDescriptor(JSContext* cx,
-                                   JS::HandleObject obj,
-                                   JS::HandleValue descriptor,
-                                   JS::MutableHandle<PropertyDescriptor> desc);
-
-
-
-
-
-
-extern bool
-FromPropertyDescriptor(JSContext* cx,
-                       JS::Handle<JS::PropertyDescriptor> desc,
-                       JS::MutableHandleValue vp);
-
-}
-# 2936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_GetPrototype(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject result);
-# 2946 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_GetPrototypeIfOrdinary(JSContext* cx, JS::HandleObject obj, bool* isOrdinary,
-                          JS::MutableHandleObject result);
-# 2963 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_SetPrototype(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
-# 2973 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_IsExtensible(JSContext* cx, JS::HandleObject obj, bool* extensible);
-# 2984 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_PreventExtensions(JSContext* cx, JS::HandleObject obj, JS::ObjectOpResult& result);
-# 2996 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_SetImmutablePrototype(JSContext* cx, JS::HandleObject obj, bool* succeeded);
-
-
-
-
-
-
-
-extern bool
-JS_GetOwnPropertyDescriptorById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                                JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-extern bool
-JS_GetOwnPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char* name,
-                            JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-extern bool
-JS_GetOwnUCPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char16_t* name,
-                              JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-
-
-
-
-
-
-extern bool
-JS_GetPropertyDescriptorById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                             JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-extern bool
-JS_GetPropertyDescriptor(JSContext* cx, JS::HandleObject obj, const char* name,
-                         JS::MutableHandle<JS::PropertyDescriptor> desc);
-# 3042 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                      JS::Handle<JS::PropertyDescriptor> desc,
-                      JS::ObjectOpResult& result);
-
-
-
-
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                      JS::Handle<JS::PropertyDescriptor> desc);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleString value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, int32_t value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, uint32_t value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, double value,
-                      unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleValue value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleObject value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleString value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, int32_t value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, uint32_t value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, double value,
-                  unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::Handle<JS::PropertyDescriptor> desc,
-                    JS::ObjectOpResult& result);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::Handle<JS::PropertyDescriptor> desc);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::HandleValue value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::HandleObject value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::HandleString value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    int32_t value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    uint32_t value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    double value, unsigned attrs,
-                    JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleValue value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleObject value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleString value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, int32_t value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, uint32_t value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-
-extern bool
-JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, double value,
-                 unsigned attrs, JSNative getter = nullptr, JSNative setter = nullptr);
-# 3175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_HasPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
-
-extern bool
-JS_HasProperty(JSContext* cx, JS::HandleObject obj, const char* name, bool* foundp);
-
-extern bool
-JS_HasUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                 bool* vp);
-
-extern bool
-JS_HasElement(JSContext* cx, JS::HandleObject obj, uint32_t index, bool* foundp);
-
-
-
-
-
-
-extern bool
-JS_HasOwnPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
-
-extern bool
-JS_HasOwnProperty(JSContext* cx, JS::HandleObject obj, const char* name, bool* foundp);
-# 3210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ForwardGetPropertyTo(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                        JS::HandleValue receiver, JS::MutableHandleValue vp);
-
-extern bool
-JS_ForwardGetElementTo(JSContext* cx, JS::HandleObject obj, uint32_t index,
-                       JS::HandleObject receiver, JS::MutableHandleValue vp);
-
-
-
-
-
-
-
-extern bool
-JS_GetPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                   JS::MutableHandleValue vp);
-
-extern bool
-JS_GetProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::MutableHandleValue vp);
-
-extern bool
-JS_GetUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                 JS::MutableHandleValue vp);
-
-extern bool
-JS_GetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::MutableHandleValue vp);
-# 3246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ForwardSetPropertyTo(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v,
-                        JS::HandleValue receiver, JS::ObjectOpResult& result);
-
-
-
-
-
-
-
-extern bool
-JS_SetPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue v);
-
-extern bool
-JS_SetProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleValue v);
-
-extern bool
-JS_SetUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                 JS::HandleValue v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleValue v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleObject v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleString v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, int32_t v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, uint32_t v);
-
-extern bool
-JS_SetElement(JSContext* cx, JS::HandleObject obj, uint32_t index, double v);
-# 3295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_DeletePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                      JS::ObjectOpResult& result);
-
-extern bool
-JS_DeleteProperty(JSContext* cx, JS::HandleObject obj, const char* name,
-                  JS::ObjectOpResult& result);
-
-extern bool
-JS_DeleteUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name, size_t namelen,
-                    JS::ObjectOpResult& result);
-
-extern bool
-JS_DeleteElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::ObjectOpResult& result);
-
-
-
-
-
-extern bool
-JS_DeletePropertyById(JSContext* cx, JS::HandleObject obj, jsid id);
-
-extern bool
-JS_DeleteProperty(JSContext* cx, JS::HandleObject obj, const char* name);
-
-extern bool
-JS_DeleteElement(JSContext* cx, JS::HandleObject obj, uint32_t index);
-# 3338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_Enumerate(JSContext* cx, JS::HandleObject obj, JS::MutableHandle<JS::IdVector> props);
-
-
-
-
-
-
-
-namespace JS {
-# 3358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-IsCallable(JSObject* obj);
-# 3372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-IsConstructor(JSObject* obj);
-
-}
-# 3384 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_CallFunctionValue(JSContext* cx, JS::HandleObject obj, JS::HandleValue fval,
-                     const JS::HandleValueArray& args, JS::MutableHandleValue rval);
-
-extern bool
-JS_CallFunction(JSContext* cx, JS::HandleObject obj, JS::HandleFunction fun,
-                const JS::HandleValueArray& args, JS::MutableHandleValue rval);
-
-
-
-
-extern bool
-JS_CallFunctionName(JSContext* cx, JS::HandleObject obj, const char* name,
-                    const JS::HandleValueArray& args, JS::MutableHandleValue rval);
-
-namespace JS {
-
-static inline bool
-Call(JSContext* cx, JS::HandleObject thisObj, JS::HandleFunction fun,
-     const JS::HandleValueArray& args, MutableHandleValue rval)
-{
-    return !!JS_CallFunction(cx, thisObj, fun, args, rval);
-}
-
-static inline bool
-Call(JSContext* cx, JS::HandleObject thisObj, JS::HandleValue fun, const JS::HandleValueArray& args,
-     MutableHandleValue rval)
-{
-    return !!JS_CallFunctionValue(cx, thisObj, fun, args, rval);
-}
-
-static inline bool
-Call(JSContext* cx, JS::HandleObject thisObj, const char* name, const JS::HandleValueArray& args,
-     MutableHandleValue rval)
-{
-    return !!JS_CallFunctionName(cx, thisObj, name, args, rval);
-}
-
-extern bool
-Call(JSContext* cx, JS::HandleValue thisv, JS::HandleValue fun, const JS::HandleValueArray& args,
-     MutableHandleValue rval);
-
-static inline bool
-Call(JSContext* cx, JS::HandleValue thisv, JS::HandleObject funObj, const JS::HandleValueArray& args,
-     MutableHandleValue rval)
-{
-    do { } while (0);
-    JS::RootedValue fun(cx, JS::ObjectValue(*funObj));
-    return Call(cx, thisv, fun, args, rval);
-}
-# 3447 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-Construct(JSContext* cx, JS::HandleValue fun, HandleObject newTarget,
-          const JS::HandleValueArray &args, MutableHandleObject objp);
-# 3458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-Construct(JSContext* cx, JS::HandleValue fun, const JS::HandleValueArray& args,
-          MutableHandleObject objp);
-
-}
-
-
-
-
-
-extern JSObject*
-JS_New(JSContext* cx, JS::HandleObject ctor, const JS::HandleValueArray& args);
-
-
-
-
-extern JSObject*
-JS_DefineObject(JSContext* cx, JS::HandleObject obj, const char* name,
-                const JSClass* clasp = nullptr, unsigned attrs = 0);
-
-extern bool
-JS_DefineConstDoubles(JSContext* cx, JS::HandleObject obj, const JSConstDoubleSpec* cds);
-
-extern bool
-JS_DefineConstIntegers(JSContext* cx, JS::HandleObject obj, const JSConstIntegerSpec* cis);
-
-extern bool
-JS_DefineProperties(JSContext* cx, JS::HandleObject obj, const JSPropertySpec* ps);
-
-
-
-
-extern bool
-JS_AlreadyHasOwnPropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                             bool* foundp);
-
-extern bool
-JS_AlreadyHasOwnProperty(JSContext* cx, JS::HandleObject obj, const char* name,
-                         bool* foundp);
-
-extern bool
-JS_AlreadyHasOwnUCProperty(JSContext* cx, JS::HandleObject obj, const char16_t* name,
-                           size_t namelen, bool* foundp);
-
-extern bool
-JS_AlreadyHasOwnElement(JSContext* cx, JS::HandleObject obj, uint32_t index, bool* foundp);
-
-extern JSObject*
-JS_NewArrayObject(JSContext* cx, const JS::HandleValueArray& contents);
-
-extern JSObject*
-JS_NewArrayObject(JSContext* cx, size_t length);
-# 3518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_IsArrayObject(JSContext* cx, JS::HandleValue value, bool* isArray);
-# 3528 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_IsArrayObject(JSContext* cx, JS::HandleObject obj, bool* isArray);
-
-extern bool
-JS_GetArrayLength(JSContext* cx, JS::Handle<JSObject*> obj, uint32_t* lengthp);
-
-extern bool
-JS_SetArrayLength(JSContext* cx, JS::Handle<JSObject*> obj, uint32_t length);
-
-namespace JS {
-# 3546 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-IsMapObject(JSContext* cx, JS::HandleObject obj, bool* isMap);
-# 3556 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-IsSetObject(JSContext* cx, JS::HandleObject obj, bool* isSet);
-
-}
-
-
-
-
-
-void
-JS_SetAllNonReservedSlotsToUndefined(JSContext* cx, JSObject* objArg);
-
-
-
-
-
-
-extern JSObject*
-JS_NewArrayBufferWithContents(JSContext* cx, size_t nbytes, void* contents);
-
-
-
-
-
-extern JSObject*
-JS_NewArrayBufferWithExternalContents(JSContext* cx, size_t nbytes, void* contents);
-
-
-
-
-
-
-
-extern void*
-JS_StealArrayBufferContents(JSContext* cx, JS::HandleObject obj);
-# 3608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void*
-JS_ExternalizeArrayBufferContents(JSContext* cx, JS::HandleObject obj);
-
-
-
-
-
-
-extern JSObject*
-JS_NewMappedArrayBufferWithContents(JSContext* cx, size_t nbytes, void* contents);
-
-
-
-
-
-extern void*
-JS_CreateMappedArrayBufferContents(int fd, size_t offset, size_t length);
-# 3633 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-JS_ReleaseMappedArrayBufferContents(void* contents, size_t length);
-
-extern JS::Value
-JS_GetReservedSlot(JSObject* obj, uint32_t index);
-
-extern void
-JS_SetReservedSlot(JSObject* obj, uint32_t index, const JS::Value& v);
-
-
-
-
-
-
-
-extern JSFunction*
-JS_NewFunction(JSContext* cx, JSNative call, unsigned nargs, unsigned flags,
-               const char* name);
-
-namespace JS {
-
-extern JSFunction*
-GetSelfHostedFunction(JSContext* cx, const char* selfHostedName, HandleId id,
-                      unsigned nargs);
-# 3666 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSFunction*
-NewFunctionFromSpec(JSContext* cx, const JSFunctionSpec* fs, HandleId id);
-
-}
-
-extern JSObject*
-JS_GetFunctionObject(JSFunction* fun);
-
-
-
-
-
-
-
-extern JSString*
-JS_GetFunctionId(JSFunction* fun);
-# 3690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSString*
-JS_GetFunctionDisplayId(JSFunction* fun);
-
-
-
-
-extern uint16_t
-JS_GetFunctionArity(JSFunction* fun);
-
-
-
-
-
-
-
-extern bool
-JS_ObjectIsFunction(JSContext* cx, JSObject* obj);
-
-extern bool
-JS_IsNativeFunction(JSObject* funobj, JSNative call);
-
-
-extern bool
-JS_IsConstructor(JSFunction* fun);
-
-extern bool
-JS_DefineFunctions(JSContext* cx, JS::Handle<JSObject*> obj, const JSFunctionSpec* fs);
-
-extern JSFunction*
-JS_DefineFunction(JSContext* cx, JS::Handle<JSObject*> obj, const char* name, JSNative call,
-                  unsigned nargs, unsigned attrs);
-
-extern JSFunction*
-JS_DefineUCFunction(JSContext* cx, JS::Handle<JSObject*> obj,
-                    const char16_t* name, size_t namelen, JSNative call,
-                    unsigned nargs, unsigned attrs);
-
-extern JSFunction*
-JS_DefineFunctionById(JSContext* cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JSNative call,
-                      unsigned nargs, unsigned attrs);
-
-extern bool
-JS_IsFunctionBound(JSFunction* fun);
-
-extern JSObject*
-JS_GetBoundFunctionTarget(JSFunction* fun);
-
-namespace JS {
-
-
-
-
-
-extern JSObject*
-CloneFunctionObject(JSContext* cx, HandleObject funobj);
-
-
-
-
-
-
-extern JSObject*
-CloneFunctionObject(JSContext* cx, HandleObject funobj, AutoObjectVector& scopeChain);
-
-}
-# 3763 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_BufferIsCompilableUnit(JSContext* cx, JS::Handle<JSObject*> obj, const char* utf8,
-                          size_t length);
-
-
-
-
-extern bool
-JS_CompileScript(JSContext* cx, const char* ascii, size_t length,
-                 const JS::CompileOptions& options,
-                 JS::MutableHandleScript script);
-
-
-
-
-extern bool
-JS_CompileUCScript(JSContext* cx, const char16_t* chars, size_t length,
-                   const JS::CompileOptions& options,
-                   JS::MutableHandleScript script);
-
-extern JSObject*
-JS_GetGlobalFromScript(JSScript* script);
-
-extern const char*
-JS_GetScriptFilename(JSScript* script);
-
-extern unsigned
-JS_GetScriptBaseLineNumber(JSContext* cx, JSScript* script);
-
-extern JSScript*
-JS_GetFunctionScript(JSContext* cx, JS::HandleFunction fun);
-
-namespace JS {
-# 3843 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-enum class AsmJSOption : uint8_t { Enabled, Disabled, DisabledByDebugger };
-
-
-
-
-
-
-
-class TransitiveCompileOptions
-{
-  protected:
-# 3865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    bool mutedErrors_;
-    const char* filename_;
-    const char* introducerFilename_;
-    const char16_t* sourceMapURL_;
-
-
-
-
-
-    TransitiveCompileOptions()
-      : mutedErrors_(false),
-        filename_(nullptr),
-        introducerFilename_(nullptr),
-        sourceMapURL_(nullptr),
-        version(JSVERSION_UNKNOWN),
-        versionSet(false),
-        utf8(false),
-        selfHostingMode(false),
-        canLazilyParse(true),
-        strictOption(false),
-        extraWarningsOption(false),
-        forEachStatementOption(false),
-        werrorOption(false),
-        asmJSOption(AsmJSOption::Disabled),
-        throwOnAsmJSValidationFailureOption(false),
-        forceAsync(false),
-        sourceIsLazy(false),
-        allowHTMLComments(true),
-        isProbablySystemOrAddonCode(false),
-        introductionType(nullptr),
-        introductionLineno(0),
-        introductionOffset(0),
-        hasIntroductionInfo(false)
-    { }
-
-
-
-    void copyPODTransitiveOptions(const TransitiveCompileOptions& rhs);
-
-  public:
-
-
-    bool mutedErrors() const { return mutedErrors_; }
-    const char* filename() const { return filename_; }
-    const char* introducerFilename() const { return introducerFilename_; }
-    const char16_t* sourceMapURL() const { return sourceMapURL_; }
-    virtual JSObject* element() const = 0;
-    virtual JSString* elementAttributeName() const = 0;
-    virtual JSScript* introductionScript() const = 0;
-
-
-    JSVersion version;
-    bool versionSet;
-    bool utf8;
-    bool selfHostingMode;
-    bool canLazilyParse;
-    bool strictOption;
-    bool extraWarningsOption;
-    bool forEachStatementOption;
-    bool werrorOption;
-    AsmJSOption asmJSOption;
-    bool throwOnAsmJSValidationFailureOption;
-    bool forceAsync;
-    bool sourceIsLazy;
-    bool allowHTMLComments;
-    bool isProbablySystemOrAddonCode;
-
-
-
-    const char* introductionType;
-    unsigned introductionLineno;
-    uint32_t introductionOffset;
-    bool hasIntroductionInfo;
-
-  private:
-    void operator=(const TransitiveCompileOptions&) = delete;
-};
-# 3951 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class ReadOnlyCompileOptions : public TransitiveCompileOptions
-{
-    friend class CompileOptions;
-
-  protected:
-    ReadOnlyCompileOptions()
-      : TransitiveCompileOptions(),
-        lineno(1),
-        column(0),
-        isRunOnce(false),
-        noScriptRval(false)
-    { }
-
-
-
-    void copyPODOptions(const ReadOnlyCompileOptions& rhs);
-
-  public:
-
-
-    bool mutedErrors() const { return mutedErrors_; }
-    const char* filename() const { return filename_; }
-    const char* introducerFilename() const { return introducerFilename_; }
-    const char16_t* sourceMapURL() const { return sourceMapURL_; }
-    virtual JSObject* element() const = 0;
-    virtual JSString* elementAttributeName() const = 0;
-    virtual JSScript* introductionScript() const = 0;
-
-
-    unsigned lineno;
-    unsigned column;
-
-    bool isRunOnce;
-    bool noScriptRval;
-
-  private:
-    void operator=(const ReadOnlyCompileOptions&) = delete;
-};
-# 4003 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class OwningCompileOptions : public ReadOnlyCompileOptions
-{
-    PersistentRootedObject elementRoot;
-    PersistentRootedString elementAttributeNameRoot;
-    PersistentRootedScript introductionScriptRoot;
-
-  public:
-
-
-
-
-    explicit OwningCompileOptions(JSContext* cx);
-    ~OwningCompileOptions();
-
-    JSObject* element() const override { return elementRoot; }
-    JSString* elementAttributeName() const override { return elementAttributeNameRoot; }
-    JSScript* introductionScript() const override { return introductionScriptRoot; }
-
-
-    bool copy(JSContext* cx, const ReadOnlyCompileOptions& rhs);
-
-
-    bool setFile(JSContext* cx, const char* f);
-    bool setFileAndLine(JSContext* cx, const char* f, unsigned l);
-    bool setSourceMapURL(JSContext* cx, const char16_t* s);
-    bool setIntroducerFilename(JSContext* cx, const char* s);
-
-
-    OwningCompileOptions& setLine(unsigned l) { lineno = l; return *this; }
-    OwningCompileOptions& setElement(JSObject* e) {
-        elementRoot = e;
-        return *this;
-    }
-    OwningCompileOptions& setElementAttributeName(JSString* p) {
-        elementAttributeNameRoot = p;
-        return *this;
-    }
-    OwningCompileOptions& setIntroductionScript(JSScript* s) {
-        introductionScriptRoot = s;
-        return *this;
-    }
-    OwningCompileOptions& setMutedErrors(bool mute) {
-        mutedErrors_ = mute;
-        return *this;
-    }
-    OwningCompileOptions& setVersion(JSVersion v) {
-        version = v;
-        versionSet = true;
-        return *this;
-    }
-    OwningCompileOptions& setUTF8(bool u) { utf8 = u; return *this; }
-    OwningCompileOptions& setColumn(unsigned c) { column = c; return *this; }
-    OwningCompileOptions& setIsRunOnce(bool once) { isRunOnce = once; return *this; }
-    OwningCompileOptions& setNoScriptRval(bool nsr) { noScriptRval = nsr; return *this; }
-    OwningCompileOptions& setSelfHostingMode(bool shm) { selfHostingMode = shm; return *this; }
-    OwningCompileOptions& setCanLazilyParse(bool clp) { canLazilyParse = clp; return *this; }
-    OwningCompileOptions& setSourceIsLazy(bool l) { sourceIsLazy = l; return *this; }
-    OwningCompileOptions& setIntroductionType(const char* t) { introductionType = t; return *this; }
-    bool setIntroductionInfo(JSContext* cx, const char* introducerFn, const char* intro,
-                             unsigned line, JSScript* script, uint32_t offset)
-    {
-        if (!setIntroducerFilename(cx, introducerFn))
-            return false;
-        introductionType = intro;
-        introductionLineno = line;
-        introductionScriptRoot = script;
-        introductionOffset = offset;
-        hasIntroductionInfo = true;
-        return true;
-    }
-
-  private:
-    void operator=(const CompileOptions& rhs) = delete;
-};
-# 4085 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class CompileOptions final : public ReadOnlyCompileOptions
-{
-    RootedObject elementRoot;
-    RootedString elementAttributeNameRoot;
-    RootedScript introductionScriptRoot;
-
-  public:
-    explicit CompileOptions(JSContext* cx, JSVersion version = JSVERSION_UNKNOWN);
-    CompileOptions(JSContext* cx, const ReadOnlyCompileOptions& rhs)
-      : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx),
-        introductionScriptRoot(cx)
-    {
-        copyPODOptions(rhs);
-
-        filename_ = rhs.filename();
-        introducerFilename_ = rhs.introducerFilename();
-        sourceMapURL_ = rhs.sourceMapURL();
-        elementRoot = rhs.element();
-        elementAttributeNameRoot = rhs.elementAttributeName();
-        introductionScriptRoot = rhs.introductionScript();
-    }
-
-    CompileOptions(JSContext* cx, const TransitiveCompileOptions& rhs)
-      : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx),
-        introductionScriptRoot(cx)
-    {
-        copyPODTransitiveOptions(rhs);
-
-        filename_ = rhs.filename();
-        introducerFilename_ = rhs.introducerFilename();
-        sourceMapURL_ = rhs.sourceMapURL();
-        elementRoot = rhs.element();
-        elementAttributeNameRoot = rhs.elementAttributeName();
-        introductionScriptRoot = rhs.introductionScript();
-    }
-
-    JSObject* element() const override { return elementRoot; }
-    JSString* elementAttributeName() const override { return elementAttributeNameRoot; }
-    JSScript* introductionScript() const override { return introductionScriptRoot; }
-
-    CompileOptions& setFile(const char* f) { filename_ = f; return *this; }
-    CompileOptions& setLine(unsigned l) { lineno = l; return *this; }
-    CompileOptions& setFileAndLine(const char* f, unsigned l) {
-        filename_ = f; lineno = l; return *this;
-    }
-    CompileOptions& setSourceMapURL(const char16_t* s) { sourceMapURL_ = s; return *this; }
-    CompileOptions& setElement(JSObject* e) { elementRoot = e; return *this; }
-    CompileOptions& setElementAttributeName(JSString* p) {
-        elementAttributeNameRoot = p;
-        return *this;
-    }
-    CompileOptions& setIntroductionScript(JSScript* s) {
-        introductionScriptRoot = s;
-        return *this;
-    }
-    CompileOptions& setMutedErrors(bool mute) {
-        mutedErrors_ = mute;
-        return *this;
-    }
-    CompileOptions& setVersion(JSVersion v) {
-        version = v;
-        versionSet = true;
-        return *this;
-    }
-    CompileOptions& setUTF8(bool u) { utf8 = u; return *this; }
-    CompileOptions& setColumn(unsigned c) { column = c; return *this; }
-    CompileOptions& setIsRunOnce(bool once) { isRunOnce = once; return *this; }
-    CompileOptions& setNoScriptRval(bool nsr) { noScriptRval = nsr; return *this; }
-    CompileOptions& setSelfHostingMode(bool shm) { selfHostingMode = shm; return *this; }
-    CompileOptions& setCanLazilyParse(bool clp) { canLazilyParse = clp; return *this; }
-    CompileOptions& setSourceIsLazy(bool l) { sourceIsLazy = l; return *this; }
-    CompileOptions& setIntroductionType(const char* t) { introductionType = t; return *this; }
-    CompileOptions& setIntroductionInfo(const char* introducerFn, const char* intro,
-                                        unsigned line, JSScript* script, uint32_t offset)
-    {
-        introducerFilename_ = introducerFn;
-        introductionType = intro;
-        introductionLineno = line;
-        introductionScriptRoot = script;
-        introductionOffset = offset;
-        hasIntroductionInfo = true;
-        return *this;
-    }
-    CompileOptions& maybeMakeStrictMode(bool strict) {
-        strictOption = strictOption || strict;
-        return *this;
-    }
-
-  private:
-    void operator=(const CompileOptions& rhs) = delete;
-};
-
-
-
-
-extern bool
-Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
-        SourceBufferHolder& srcBuf, JS::MutableHandleScript script);
-
-extern bool
-Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
-        const char* bytes, size_t length, JS::MutableHandleScript script);
-
-extern bool
-Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
-        const char16_t* chars, size_t length, JS::MutableHandleScript script);
-
-extern bool
-Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
-        FILE* file, JS::MutableHandleScript script);
-
-extern bool
-Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
-        const char* filename, JS::MutableHandleScript script);
-
-extern bool
-CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
-                            SourceBufferHolder& srcBuf, JS::MutableHandleScript script);
-
-extern bool
-CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
-                            const char* bytes, size_t length, JS::MutableHandleScript script);
-
-extern bool
-CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
-                            const char16_t* chars, size_t length, JS::MutableHandleScript script);
-
-extern bool
-CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
-                            FILE* file, JS::MutableHandleScript script);
-
-extern bool
-CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options,
-                            const char* filename, JS::MutableHandleScript script);
-
-extern bool
-CanCompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options, size_t length);
-# 4240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-CompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options,
-                 const char16_t* chars, size_t length,
-                 OffThreadCompileCallback callback, void* callbackData);
-
-extern JSScript*
-FinishOffThreadScript(JSContext* cx, void* token);
-
-extern void
-CancelOffThreadScript(JSContext* cx, void* token);
-
-extern bool
-CompileOffThreadModule(JSContext* cx, const ReadOnlyCompileOptions& options,
-                       const char16_t* chars, size_t length,
-                       OffThreadCompileCallback callback, void* callbackData);
-
-extern JSObject*
-FinishOffThreadModule(JSContext* cx, void* token);
-
-extern void
-CancelOffThreadModule(JSContext* cx, void* token);
-
-extern bool
-DecodeOffThreadScript(JSContext* cx, const ReadOnlyCompileOptions& options,
-                      mozilla::Vector<uint8_t>& buffer , size_t cursor,
-                      OffThreadCompileCallback callback, void* callbackData);
-
-extern JSScript*
-FinishOffThreadScriptDecoder(JSContext* cx, void* token);
-
-extern void
-CancelOffThreadScriptDecoder(JSContext* cx, void* token);
-# 4280 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-CompileFunction(JSContext* cx, AutoObjectVector& envChain,
-                const ReadOnlyCompileOptions& options,
-                const char* name, unsigned nargs, const char* const* argnames,
-                const char16_t* chars, size_t length, JS::MutableHandleFunction fun);
-
-
-
-
-extern bool
-CompileFunction(JSContext* cx, AutoObjectVector& envChain,
-                const ReadOnlyCompileOptions& options,
-                const char* name, unsigned nargs, const char* const* argnames,
-                SourceBufferHolder& srcBuf, JS::MutableHandleFunction fun);
-
-
-
-
-extern bool
-CompileFunction(JSContext* cx, AutoObjectVector& envChain,
-                const ReadOnlyCompileOptions& options,
-                const char* name, unsigned nargs, const char* const* argnames,
-                const char* bytes, size_t length, JS::MutableHandleFunction fun);
-
-}
-
-extern JSString*
-JS_DecompileScript(JSContext* cx, JS::Handle<JSScript*> script, const char* name, unsigned indent);
-
-
-
-
-
-
-
-extern JSString*
-JS_DecompileFunction(JSContext* cx, JS::Handle<JSFunction*> fun, unsigned indent);
-# 4339 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ExecuteScript(JSContext* cx, JS::HandleScript script, JS::MutableHandleValue rval);
-
-extern bool
-JS_ExecuteScript(JSContext* cx, JS::HandleScript script);
-
-
-
-
-
-
-extern bool
-JS_ExecuteScript(JSContext* cx, JS::AutoObjectVector& envChain,
-                 JS::HandleScript script, JS::MutableHandleValue rval);
-
-extern bool
-JS_ExecuteScript(JSContext* cx, JS::AutoObjectVector& envChain, JS::HandleScript script);
-
-namespace JS {
-
-
-
-
-
-extern bool
-CloneAndExecuteScript(JSContext* cx, JS::Handle<JSScript*> script,
-                      JS::MutableHandleValue rval);
-
-}
-
-namespace JS {
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
-         SourceBufferHolder& srcBuf, JS::MutableHandleValue rval);
-
-
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options,
-         SourceBufferHolder& srcBuf, JS::MutableHandleValue rval);
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
-         const char16_t* chars, size_t length, JS::MutableHandleValue rval);
-
-
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options,
-         const char16_t* chars, size_t length, JS::MutableHandleValue rval);
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
-         const char* bytes, size_t length, JS::MutableHandleValue rval);
-
-
-
-
-extern bool
-Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options,
-         const char* filename, JS::MutableHandleValue rval);
-
-
-
-
-extern JSFunction*
-GetModuleResolveHook(JSContext* cx);
-
-
-
-
-extern void
-SetModuleResolveHook(JSContext* cx, JS::HandleFunction func);
-
-
-
-
-
-extern bool
-CompileModule(JSContext* cx, const ReadOnlyCompileOptions& options,
-              SourceBufferHolder& srcBuf, JS::MutableHandleObject moduleRecord);
-
-
-
-
-
-extern void
-SetModuleHostDefinedField(JSObject* module, const JS::Value& value);
-
-
-
-
-extern JS::Value
-GetModuleHostDefinedField(JSObject* module);
-# 4458 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-ModuleDeclarationInstantiation(JSContext* cx, JS::HandleObject moduleRecord);
-# 4471 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-ModuleEvaluation(JSContext* cx, JS::HandleObject moduleRecord);
-# 4482 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-GetRequestedModules(JSContext* cx, JS::HandleObject moduleRecord);
-
-
-
-
-extern JSScript*
-GetModuleScript(JSContext* cx, JS::HandleObject moduleRecord);
-
-}
-
-extern bool
-JS_CheckForInterrupt(JSContext* cx);
-# 4509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_AddInterruptCallback(JSContext* cx, JSInterruptCallback callback);
-
-extern bool
-JS_DisableInterruptCallback(JSContext* cx);
-
-extern void
-JS_ResetInterruptCallback(JSContext* cx, bool enable);
-
-extern void
-JS_RequestInterruptCallback(JSContext* cx);
-
-namespace JS {
-# 4530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-SetGetIncumbentGlobalCallback(JSContext* cx, JSGetIncumbentGlobalCallback callback);
-# 4542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-SetEnqueuePromiseJobCallback(JSContext* cx, JSEnqueuePromiseJobCallback callback,
-                             void* data = nullptr);
-
-
-
-
-
-
-extern void
-SetPromiseRejectionTrackerCallback(JSContext* cx, JSPromiseRejectionTrackerCallback callback,
-                                   void* data = nullptr);
-
-
-
-
-
-
-
-extern JSObject*
-NewPromiseObject(JSContext* cx, JS::HandleObject executor, JS::HandleObject proto = nullptr);
-
-
-
-
-
-extern bool
-IsPromiseObject(JS::HandleObject obj);
-
-
-
-
-extern JSObject*
-GetPromiseConstructor(JSContext* cx);
-
-
-
-
-extern JSObject*
-GetPromisePrototype(JSContext* cx);
-
-
-enum class PromiseState {
-    Pending,
-    Fulfilled,
-    Rejected
-};
-
-
-
-
-extern PromiseState
-GetPromiseState(JS::HandleObject promise);
-
-
-
-
-uint64_t
-GetPromiseID(JS::HandleObject promise);
-
-
-
-
-
-extern JS::Value
-GetPromiseResult(JS::HandleObject promise);
-
-
-
-
-
-extern JSObject*
-GetPromiseAllocationSite(JS::HandleObject promise);
-
-extern JSObject*
-GetPromiseResolutionSite(JS::HandleObject promise);
-# 4631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-CallOriginalPromiseResolve(JSContext* cx, JS::HandleValue resolutionValue);
-
-
-
-
-
-extern JSObject*
-CallOriginalPromiseReject(JSContext* cx, JS::HandleValue rejectionValue);
-
-
-
-
-
-
-
-extern bool
-ResolvePromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue resolutionValue);
-
-
-
-
-
-
-
-extern bool
-RejectPromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue rejectionValue);
-# 4667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-CallOriginalPromiseThen(JSContext* cx, JS::HandleObject promise,
-                        JS::HandleObject onResolve, JS::HandleObject onReject);
-# 4682 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-AddPromiseReactions(JSContext* cx, JS::HandleObject promise,
-                    JS::HandleObject onResolve, JS::HandleObject onReject);
-# 4697 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-GetWaitForAllPromise(JSContext* cx, const JS::AutoObjectVector& promises);
-# 4707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-struct AsyncTask
-{
-    AsyncTask() : user(nullptr) {}
-    virtual ~AsyncTask() {}
-
-
-
-
-
-    virtual void finish(JSContext* cx) = 0;
-    virtual void cancel(JSContext* cx) = 0;
-
-
-    void* user;
-};
-# 4734 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef bool
-(*StartAsyncTaskCallback)(JSContext* cx, AsyncTask* task);
-# 4744 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef bool
-(*FinishAsyncTaskCallback)(AsyncTask* task);
-
-
-
-
-extern void
-SetAsyncTaskCallbacks(JSContext* cx, StartAsyncTaskCallback start, FinishAsyncTaskCallback finish);
-# 4770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class AutoSetAsyncStackForNewCalls
-{
-    JSContext* cx;
-    RootedObject oldAsyncStack;
-    const char* oldAsyncCause;
-    bool oldAsyncCallIsExplicit;
-
-  public:
-    enum class AsyncCallKind {
-
-
-        IMPLICIT,
-
-
-        EXPLICIT
-    };
-# 4796 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    AutoSetAsyncStackForNewCalls(JSContext* cx, HandleObject stack,
-                                 const char* asyncCause,
-                                 AsyncCallKind kind = AsyncCallKind::IMPLICIT);
-    ~AutoSetAsyncStackForNewCalls();
-};
-
-}
-# 4815 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSString*
-JS_NewStringCopyN(JSContext* cx, const char* s, size_t n);
-
-extern JSString*
-JS_NewStringCopyZ(JSContext* cx, const char* s);
-
-extern JSString*
-JS_NewStringCopyUTF8Z(JSContext* cx, const JS::ConstUTF8CharsZ s);
-
-extern JSString*
-JS_NewStringCopyUTF8N(JSContext* cx, const JS::UTF8Chars s);
-
-extern JSString*
-JS_AtomizeAndPinJSString(JSContext* cx, JS::HandleString str);
-
-extern JSString*
-JS_AtomizeStringN(JSContext* cx, const char* s, size_t length);
-
-extern JSString*
-JS_AtomizeString(JSContext* cx, const char* s);
-
-extern JSString*
-JS_AtomizeAndPinStringN(JSContext* cx, const char* s, size_t length);
-
-extern JSString*
-JS_AtomizeAndPinString(JSContext* cx, const char* s);
-
-extern JSString*
-JS_NewUCString(JSContext* cx, char16_t* chars, size_t length);
-
-extern JSString*
-JS_NewUCStringCopyN(JSContext* cx, const char16_t* s, size_t n);
-
-extern JSString*
-JS_NewUCStringCopyZ(JSContext* cx, const char16_t* s);
-
-extern JSString*
-JS_AtomizeUCStringN(JSContext* cx, const char16_t* s, size_t length);
-
-extern JSString*
-JS_AtomizeUCString(JSContext* cx, const char16_t* s);
-
-extern JSString*
-JS_AtomizeAndPinUCStringN(JSContext* cx, const char16_t* s, size_t length);
-
-extern JSString*
-JS_AtomizeAndPinUCString(JSContext* cx, const char16_t* s);
-
-extern bool
-JS_CompareStrings(JSContext* cx, JSString* str1, JSString* str2, int32_t* result);
-
-extern bool
-JS_StringEqualsAscii(JSContext* cx, JSString* str, const char* asciiBytes, bool* match);
-
-extern size_t
-JS_PutEscapedString(JSContext* cx, char* buffer, size_t size, JSString* str, char quote);
-
-extern bool
-JS_FileEscapedString(FILE* fp, JSString* str, char quote);
-# 4914 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern size_t
-JS_GetStringLength(JSString* str);
-
-extern bool
-JS_StringIsFlat(JSString* str);
-
-
-extern bool
-JS_StringHasLatin1Chars(JSString* str);
-
-extern const JS::Latin1Char*
-JS_GetLatin1StringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str,
-                                 size_t* length);
-
-extern const char16_t*
-JS_GetTwoByteStringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str,
-                                  size_t* length);
-
-extern bool
-JS_GetStringCharAt(JSContext* cx, JSString* str, size_t index, char16_t* res);
-
-extern char16_t
-JS_GetFlatStringCharAt(JSFlatString* str, size_t index);
-
-extern const char16_t*
-JS_GetTwoByteExternalStringChars(JSString* str);
-
-extern bool
-JS_CopyStringChars(JSContext* cx, mozilla::Range<char16_t> dest, JSString* str);
-
-extern JSFlatString*
-JS_FlattenString(JSContext* cx, JSString* str);
-
-extern const JS::Latin1Char*
-JS_GetLatin1FlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str);
-
-extern const char16_t*
-JS_GetTwoByteFlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str);
-
-static __attribute__((always_inline)) inline JSFlatString*
-JSID_TO_FLAT_STRING(jsid id)
-{
-    do { } while (0);
-    return (JSFlatString*)((id.asBits));
-}
-
-static __attribute__((always_inline)) inline JSFlatString*
-JS_ASSERT_STRING_IS_FLAT(JSString* str)
-{
-    do { } while (0);
-    return (JSFlatString*)str;
-}
-
-static __attribute__((always_inline)) inline JSString*
-JS_FORGET_STRING_FLATNESS(JSFlatString* fstr)
-{
-    return (JSString*)fstr;
-}
-
-
-
-
-
-extern bool
-JS_FlatStringEqualsAscii(JSFlatString* str, const char* asciiBytes);
-
-extern size_t
-JS_PutEscapedFlatString(char* buffer, size_t size, JSFlatString* str, char quote);
-
-
-
-
-
-
-extern JSString*
-JS_NewDependentString(JSContext* cx, JS::HandleString str, size_t start,
-                      size_t length);
-
-
-
-
-
-extern JSString*
-JS_ConcatStrings(JSContext* cx, JS::HandleString left, JS::HandleString right);
-# 5012 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-bool
-JS_DecodeBytes(JSContext* cx, const char* src, size_t srclen, char16_t* dst,
-               size_t* dstlenp);
-
-
-
-
-
-char*
-JS_EncodeString(JSContext* cx, JSString* str);
-
-
-
-
-char*
-JS_EncodeStringToUTF8(JSContext* cx, JS::HandleString str);
-
-
-
-
-
-
-size_t
-JS_GetStringEncodingLength(JSContext* cx, JSString* str);
-# 5045 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-size_t
-JS_EncodeStringToBuffer(JSContext* cx, JSString* str, char* buffer, size_t length);
-
-class JSAutoByteString
-{
-  public:
-    JSAutoByteString(JSContext* cx, JSString* str
-                                                    )
-      : mBytes(JS_EncodeString(cx, str))
-    {
-        do { } while (0);
-        do { } while (0);
-    }
-
-    explicit JSAutoByteString()
-      : mBytes(nullptr)
-    {
-        do { } while (0);
-    }
-
-    ~JSAutoByteString() {
-        JS_free(nullptr, mBytes);
-    }
-
-
-    void initBytes(char* bytes) {
-        do { } while (0);
-        mBytes = bytes;
-    }
-
-    char* encodeLatin1(JSContext* cx, JSString* str) {
-        do { } while (0);
-        do { } while (0);
-        mBytes = JS_EncodeString(cx, str);
-        return mBytes;
-    }
-
-    char* encodeUtf8(JSContext* cx, JS::HandleString str) {
-        do { } while (0);
-        do { } while (0);
-        mBytes = JS_EncodeStringToUTF8(cx, str);
-        return mBytes;
-    }
-
-    void clear() {
-        js_free(mBytes);
-        mBytes = nullptr;
-    }
-
-    char* ptr() const {
-        return mBytes;
-    }
-
-    bool operator!() const {
-        return !mBytes;
-    }
-
-    size_t length() const {
-        if (!mBytes)
-            return 0;
-        return strlen(mBytes);
-    }
-
-  private:
-    char* mBytes;
-
-
-
-    JSAutoByteString(const JSAutoByteString& another);
-    JSAutoByteString& operator=(const JSAutoByteString& another);
-};
-
-namespace JS {
-
-extern JSAddonId*
-NewAddonId(JSContext* cx, JS::HandleString str);
-
-extern JSString*
-StringOfAddonId(JSAddonId* id);
-
-extern JSAddonId*
-AddonIdOfObject(JSObject* obj);
-
-}
-
-
-
-
-
-
-namespace JS {
-# 5144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-Symbol*
-NewSymbol(JSContext* cx, HandleString description);
-# 5154 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-Symbol*
-GetSymbolFor(JSContext* cx, HandleString key);
-
-
-
-
-
-
-
-JSString*
-GetSymbolDescription(HandleSymbol symbol);
-# 5181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-enum class SymbolCode : uint32_t {
-
-
-    isConcatSpreadable, iterator, match, replace, search, species, hasInstance, split, toPrimitive, toStringTag, unscopables, asyncIterator,
-
-    Limit,
-    InSymbolRegistry = 0xfffffffe,
-    UniqueSymbol = 0xffffffff
-};
-
-
-const size_t WellKnownSymbolLimit = size_t(SymbolCode::Limit);
-
-
-
-
-
-
-SymbolCode
-GetSymbolCode(Handle<Symbol*> symbol);
-
-
-
-
-
-
-
-Symbol*
-GetWellKnownSymbol(JSContext* cx, SymbolCode which);
-
-
-
-
-
-inline bool
-PropertySpecNameIsSymbol(const char* name)
-{
-    uintptr_t u = reinterpret_cast<uintptr_t>(name);
-    return u != 0 && u - 1 < WellKnownSymbolLimit;
-}
-
-bool
-PropertySpecNameEqualsId(const char* name, HandleId id);
-# 5233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-bool
-PropertySpecNameToPermanentId(JSContext* cx, const char* name, jsid* idp);
-
-}
-
-
-
-
-
-typedef bool (* JSONWriteCallback)(const char16_t* buf, uint32_t len, void* data);
-
-
-
-
-bool
-JS_Stringify(JSContext* cx, JS::MutableHandleValue value, JS::HandleObject replacer,
-             JS::HandleValue space, JSONWriteCallback callback, void* data);
-
-namespace JS {
-# 5270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-bool
-ToJSONMaybeSafely(JSContext* cx, JS::HandleObject input,
-                  JSONWriteCallback callback, void* data);
-
-}
-
-
-
-
-bool
-JS_ParseJSON(JSContext* cx, const char16_t* chars, uint32_t len, JS::MutableHandleValue vp);
-
-bool
-JS_ParseJSON(JSContext* cx, JS::HandleString str, JS::MutableHandleValue vp);
-
-bool
-JS_ParseJSONWithReviver(JSContext* cx, const char16_t* chars, uint32_t len, JS::HandleValue reviver,
-                        JS::MutableHandleValue vp);
-
-bool
-JS_ParseJSONWithReviver(JSContext* cx, JS::HandleString str, JS::HandleValue reviver,
-                        JS::MutableHandleValue vp);
-# 5302 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_SetDefaultLocale(JSContext* cx, const char* locale);
-
-
-
-
-extern JS::UniqueChars
-JS_GetDefaultLocale(JSContext* cx);
-
-
-
-
-extern void
-JS_ResetDefaultLocale(JSContext* cx);
-
-
-
-
-struct JSLocaleCallbacks {
-    JSLocaleToUpperCase localeToUpperCase;
-    JSLocaleToLowerCase localeToLowerCase;
-    JSLocaleCompare localeCompare;
-    JSLocaleToUnicode localeToUnicode;
-};
-
-
-
-
-
-extern void
-JS_SetLocaleCallbacks(JSContext* cx, const JSLocaleCallbacks* callbacks);
-
-
-
-
-
-extern const JSLocaleCallbacks*
-JS_GetLocaleCallbacks(JSContext* cx);
-
-
-
-
-
-
-
-namespace JS {
-const uint16_t MaxNumErrorArguments = 10;
-};
-
-
-
-
-
-extern void
-JS_ReportErrorASCII(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-extern void
-JS_ReportErrorLatin1(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-extern void
-JS_ReportErrorUTF8(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-
-
-
-extern void
-JS_ReportErrorNumberASCII(JSContext* cx, JSErrorCallback errorCallback,
-                          void* userRef, const unsigned errorNumber, ...);
-
-extern void
-JS_ReportErrorNumberASCIIVA(JSContext* cx, JSErrorCallback errorCallback,
-                            void* userRef, const unsigned errorNumber, va_list ap);
-
-extern void
-JS_ReportErrorNumberLatin1(JSContext* cx, JSErrorCallback errorCallback,
-                           void* userRef, const unsigned errorNumber, ...);
-
-
-extern void
-JS_ReportErrorNumberLatin1VA(JSContext* cx, JSErrorCallback errorCallback,
-                             void* userRef, const unsigned errorNumber, va_list ap);
-
-
-extern void
-JS_ReportErrorNumberUTF8(JSContext* cx, JSErrorCallback errorCallback,
-                           void* userRef, const unsigned errorNumber, ...);
-
-
-extern void
-JS_ReportErrorNumberUTF8VA(JSContext* cx, JSErrorCallback errorCallback,
-                           void* userRef, const unsigned errorNumber, va_list ap);
-
-
-
-
-
-extern void
-JS_ReportErrorNumberUC(JSContext* cx, JSErrorCallback errorCallback,
-                     void* userRef, const unsigned errorNumber, ...);
-
-extern void
-JS_ReportErrorNumberUCArray(JSContext* cx, JSErrorCallback errorCallback,
-                            void* userRef, const unsigned errorNumber,
-                            const char16_t** args);
-
-
-
-
-
-
-
-extern bool
-JS_ReportWarningASCII(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-extern bool
-JS_ReportWarningLatin1(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-extern bool
-JS_ReportWarningUTF8(JSContext* cx, const char* format, ...)
-    __attribute__ ((format (printf, 2, 3)));
-
-extern bool
-JS_ReportErrorFlagsAndNumberASCII(JSContext* cx, unsigned flags,
-                                  JSErrorCallback errorCallback, void* userRef,
-                                  const unsigned errorNumber, ...);
-
-extern bool
-JS_ReportErrorFlagsAndNumberLatin1(JSContext* cx, unsigned flags,
-                                   JSErrorCallback errorCallback, void* userRef,
-                                   const unsigned errorNumber, ...);
-
-extern bool
-JS_ReportErrorFlagsAndNumberUTF8(JSContext* cx, unsigned flags,
-                                 JSErrorCallback errorCallback, void* userRef,
-                                 const unsigned errorNumber, ...);
-
-extern bool
-JS_ReportErrorFlagsAndNumberUC(JSContext* cx, unsigned flags,
-                               JSErrorCallback errorCallback, void* userRef,
-                               const unsigned errorNumber, ...);
-
-
-
-
-extern void
-JS_ReportOutOfMemory(JSContext* cx);
-
-
-
-
-extern void
-JS_ReportAllocationOverflow(JSContext* cx);
-
-
-
-
-
-class JSErrorBase
-{
-
-
-    JS::ConstUTF8CharsZ message_;
-
-  public:
-    JSErrorBase()
-      : filename(nullptr), lineno(0), column(0),
-        errorNumber(0),
-        ownsMessage_(false)
-    {}
-
-    ~JSErrorBase() {
-        freeMessage();
-    }
-
-
-    const char* filename;
-
-
-    unsigned lineno;
-
-
-    unsigned column;
-
-
-    unsigned errorNumber;
-
-  private:
-    bool ownsMessage_ : 1;
-
-  public:
-    const JS::ConstUTF8CharsZ message() const {
-        return message_;
-    }
-
-    void initOwnedMessage(const char* messageArg) {
-        initBorrowedMessage(messageArg);
-        ownsMessage_ = true;
-    }
-    void initBorrowedMessage(const char* messageArg) {
-        do { } while (0);
-        message_ = JS::ConstUTF8CharsZ(messageArg, strlen(messageArg));
-    }
-
-    JSString* newMessageString(JSContext* cx);
-
-  private:
-    void freeMessage();
-};
-
-
-
-
-class JSErrorNotes
-{
-  public:
-    class Note : public JSErrorBase
-    {};
-
-  private:
-
-    js::Vector<js::UniquePtr<Note>, 1, js::SystemAllocPolicy> notes_;
-
-  public:
-    JSErrorNotes();
-    ~JSErrorNotes();
-
-
-    bool addNoteASCII(JSContext* cx,
-                      const char* filename, unsigned lineno, unsigned column,
-                      JSErrorCallback errorCallback, void* userRef,
-                      const unsigned errorNumber, ...);
-    bool addNoteLatin1(JSContext* cx,
-                       const char* filename, unsigned lineno, unsigned column,
-                       JSErrorCallback errorCallback, void* userRef,
-                       const unsigned errorNumber, ...);
-    bool addNoteUTF8(JSContext* cx,
-                     const char* filename, unsigned lineno, unsigned column,
-                     JSErrorCallback errorCallback, void* userRef,
-                     const unsigned errorNumber, ...);
-
-    size_t length();
-
-
-    js::UniquePtr<JSErrorNotes> copy(JSContext* cx);
-
-    class iterator : public std::iterator<std::input_iterator_tag, js::UniquePtr<Note>>
-    {
-        js::UniquePtr<Note>* note_;
-      public:
-        explicit iterator(js::UniquePtr<Note>* note = nullptr) : note_(note)
-        {}
-
-        bool operator==(iterator other) const {
-            return note_ == other.note_;
-        }
-        bool operator!=(iterator other) const {
-            return !(*this == other);
-        }
-        iterator& operator++() {
-            note_++;
-            return *this;
-        }
-        reference operator*() {
-            return *note_;
-        }
-    };
-    iterator begin();
-    iterator end();
-};
-
-
-
-
-class JSErrorReport : public JSErrorBase
-{
-
-
-    const char16_t* linebuf_;
-
-
-    size_t linebufLength_;
-
-
-    size_t tokenOffset_;
-
-  public:
-    JSErrorReport()
-      : linebuf_(nullptr), linebufLength_(0), tokenOffset_(0),
-        notes(nullptr),
-        flags(0), exnType(0), isMuted(false),
-        ownsLinebuf_(false)
-    {}
-
-    ~JSErrorReport() {
-        freeLinebuf();
-    }
-
-
-    js::UniquePtr<JSErrorNotes> notes;
-
-
-    unsigned flags;
-
-
-    int16_t exnType;
-
-
-    bool isMuted : 1;
-
-  private:
-    bool ownsLinebuf_ : 1;
-
-  public:
-    const char16_t* linebuf() const {
-        return linebuf_;
-    }
-    size_t linebufLength() const {
-        return linebufLength_;
-    }
-    size_t tokenOffset() const {
-        return tokenOffset_;
-    }
-    void initOwnedLinebuf(const char16_t* linebufArg, size_t linebufLengthArg,
-                          size_t tokenOffsetArg) {
-        initBorrowedLinebuf(linebufArg, linebufLengthArg, tokenOffsetArg);
-        ownsLinebuf_ = true;
-    }
-    void initBorrowedLinebuf(const char16_t* linebufArg, size_t linebufLengthArg,
-                             size_t tokenOffsetArg);
-
-  private:
-    void freeLinebuf();
-};
-# 5662 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-namespace JS {
-
-using WarningReporter = void (*)(JSContext* cx, JSErrorReport* report);
-
-extern WarningReporter
-SetWarningReporter(JSContext* cx, WarningReporter reporter);
-
-extern WarningReporter
-GetWarningReporter(JSContext* cx);
-
-extern bool
-CreateError(JSContext* cx, JSExnType type, HandleObject stack,
-            HandleString fileName, uint32_t lineNumber, uint32_t columnNumber,
-            JSErrorReport* report, HandleString message, MutableHandleValue rval);
-
-
-
-
-
-
-
-extern JSObject*
-NewWeakMapObject(JSContext* cx);
-
-extern bool
-IsWeakMapObject(JSObject* obj);
-
-extern bool
-GetWeakMapEntry(JSContext* cx, JS::HandleObject mapObj, JS::HandleObject key,
-                JS::MutableHandleValue val);
-
-extern bool
-SetWeakMapEntry(JSContext* cx, JS::HandleObject mapObj, JS::HandleObject key,
-                JS::HandleValue val);
-
-
-
-
-extern JSObject*
-NewMapObject(JSContext* cx);
-
-extern uint32_t
-MapSize(JSContext* cx, HandleObject obj);
-
-extern bool
-MapGet(JSContext* cx, HandleObject obj,
-       HandleValue key, MutableHandleValue rval);
-
-extern bool
-MapHas(JSContext* cx, HandleObject obj, HandleValue key, bool* rval);
-
-extern bool
-MapSet(JSContext* cx, HandleObject obj, HandleValue key, HandleValue val);
-
-extern bool
-MapDelete(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
-
-extern bool
-MapClear(JSContext* cx, HandleObject obj);
-
-extern bool
-MapKeys(JSContext* cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-MapValues(JSContext* cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-MapEntries(JSContext* cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-MapForEach(JSContext *cx, HandleObject obj, HandleValue callbackFn, HandleValue thisVal);
-
-
-
-
-extern JSObject *
-NewSetObject(JSContext *cx);
-
-extern uint32_t
-SetSize(JSContext *cx, HandleObject obj);
-
-extern bool
-SetHas(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
-
-extern bool
-SetDelete(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
-
-extern bool
-SetAdd(JSContext *cx, HandleObject obj, HandleValue key);
-
-extern bool
-SetClear(JSContext *cx, HandleObject obj);
-
-extern bool
-SetKeys(JSContext *cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-SetValues(JSContext *cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-SetEntries(JSContext *cx, HandleObject obj, MutableHandleValue rval);
-
-extern bool
-SetForEach(JSContext *cx, HandleObject obj, HandleValue callbackFn, HandleValue thisVal);
-
-}
-
-
-
-
-
-extern JSObject*
-JS_NewDateObject(JSContext* cx, int year, int mon, int mday, int hour, int min, int sec);
-# 5783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ObjectIsDate(JSContext* cx, JS::HandleObject obj, bool* isDate);
-# 5797 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-JS_NewRegExpObject(JSContext* cx, const char* bytes, size_t length, unsigned flags);
-
-extern JSObject*
-JS_NewUCRegExpObject(JSContext* cx, const char16_t* chars, size_t length, unsigned flags);
-
-extern bool
-JS_SetRegExpInput(JSContext* cx, JS::HandleObject obj, JS::HandleString input);
-
-extern bool
-JS_ClearRegExpStatics(JSContext* cx, JS::HandleObject obj);
-
-extern bool
-JS_ExecuteRegExp(JSContext* cx, JS::HandleObject obj, JS::HandleObject reobj,
-                 char16_t* chars, size_t length, size_t* indexp, bool test,
-                 JS::MutableHandleValue rval);
-
-
-
-extern bool
-JS_ExecuteRegExpNoStatics(JSContext* cx, JS::HandleObject reobj, char16_t* chars, size_t length,
-                          size_t* indexp, bool test, JS::MutableHandleValue rval);
-# 5827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-JS_ObjectIsRegExp(JSContext* cx, JS::HandleObject obj, bool* isRegExp);
-
-extern unsigned
-JS_GetRegExpFlags(JSContext* cx, JS::HandleObject obj);
-
-extern JSString*
-JS_GetRegExpSource(JSContext* cx, JS::HandleObject obj);
-
-
-
-extern bool
-JS_IsExceptionPending(JSContext* cx);
-
-extern bool
-JS_GetPendingException(JSContext* cx, JS::MutableHandleValue vp);
-
-extern void
-JS_SetPendingException(JSContext* cx, JS::HandleValue v);
-
-extern void
-JS_ClearPendingException(JSContext* cx);
-
-namespace JS {
-# 5864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class AutoSaveExceptionState
-{
-  private:
-    JSContext* context;
-    bool wasPropagatingForcedReturn;
-    bool wasOverRecursed;
-    bool wasThrowing;
-    RootedValue exceptionValue;
-
-  public:
-
-
-
-
-    explicit AutoSaveExceptionState(JSContext* cx);
-
-
-
-
-
-    ~AutoSaveExceptionState();
-
-
-
-
-
-    void drop() {
-        wasPropagatingForcedReturn = false;
-        wasOverRecursed = false;
-        wasThrowing = false;
-        exceptionValue.setUndefined();
-    }
-
-
-
-
-
-
-    void restore();
-};
-
-}
-
-
-extern JSExceptionState*
-JS_SaveExceptionState(JSContext* cx);
-
-extern void
-JS_RestoreExceptionState(JSContext* cx, JSExceptionState* state);
-
-extern void
-JS_DropExceptionState(JSContext* cx, JSExceptionState* state);
-# 5924 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSErrorReport*
-JS_ErrorFromException(JSContext* cx, JS::HandleObject obj);
-# 5934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-ExceptionStackOrNull(JS::HandleObject obj);
-
-
-
-
-extern bool
-JS_ThrowStopIteration(JSContext* cx);
-
-extern bool
-JS_IsStopIteration(const JS::Value& v);
-# 5956 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-JS_AbortIfWrongThread(JSContext* cx);
-# 5966 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern JSObject*
-JS_NewObjectForConstructor(JSContext* cx, const JSClass* clasp, const JS::CallArgs& args);
-
-
-
-
-
-
-extern void
-JS_GetGCZealBits(JSContext* cx, uint32_t* zealBits, uint32_t* frequency, uint32_t* nextScheduled);
-
-extern void
-JS_SetGCZeal(JSContext* cx, uint8_t zeal, uint32_t frequency);
-
-extern void
-JS_ScheduleGC(JSContext* cx, uint32_t count);
-
-
-extern void
-JS_SetParallelParsingEnabled(JSContext* cx, bool enabled);
-
-extern void
-JS_SetOffthreadIonCompilationEnabled(JSContext* cx, bool enabled);
-# 6006 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef enum JSJitCompilerOption {
-
-
-
-    JSJITCOMPILER_BASELINE_WARMUP_TRIGGER, JSJITCOMPILER_ION_WARMUP_TRIGGER, JSJITCOMPILER_ION_GVN_ENABLE, JSJITCOMPILER_ION_FORCE_IC, JSJITCOMPILER_ION_ENABLE, JSJITCOMPILER_ION_INTERRUPT_WITHOUT_SIGNAL, JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS, JSJITCOMPILER_BASELINE_ENABLE, JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE, JSJITCOMPILER_FULL_DEBUG_CHECKS, JSJITCOMPILER_JUMP_THRESHOLD, JSJITCOMPILER_ASMJS_ATOMICS_ENABLE, JSJITCOMPILER_WASM_TEST_MODE, JSJITCOMPILER_WASM_FOLD_OFFSETS,
-
-
-    JSJITCOMPILER_NOT_AN_OPTION
-} JSJitCompilerOption;
-
-extern void
-JS_SetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t value);
-extern bool
-JS_GetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t* valueOut);
-
-
-
-
-extern bool
-JS_IndexToId(JSContext* cx, uint32_t index, JS::MutableHandleId);
-
-
-
-
-
-
-extern bool
-JS_CharsToId(JSContext* cx, JS::TwoByteChars chars, JS::MutableHandleId);
-
-
-
-
-extern bool
-JS_IsIdentifier(JSContext* cx, JS::HandleString str, bool* isIdentifier);
-
-
-
-
-
-
-extern bool
-JS_IsIdentifier(const char16_t* chars, size_t length);
-
-namespace js {
-class ScriptSource;
-}
-
-namespace JS {
-
-class AutoFilename
-{
-  private:
-    js::ScriptSource* ss_;
-    mozilla::Variant<const char*, UniqueChars> filename_;
-
-    AutoFilename(const AutoFilename&) = delete;
-    AutoFilename& operator=(const AutoFilename&) = delete;
-
-  public:
-    AutoFilename()
-      : ss_(nullptr),
-        filename_(mozilla::AsVariant<const char*>(nullptr))
-    {}
-
-    ~AutoFilename() {
-        reset();
-    }
-
-    void reset();
-
-    void setOwned(UniqueChars&& filename);
-    void setUnowned(const char* filename);
-    void setScriptSource(js::ScriptSource* ss);
-
-    const char* get() const;
-};
-# 6091 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-DescribeScriptedCaller(JSContext* cx, AutoFilename* filename = nullptr,
-                       unsigned* lineno = nullptr, unsigned* column = nullptr);
-
-extern JSObject*
-GetScriptedCallerGlobal(JSContext* cx);
-# 6110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-HideScriptedCaller(JSContext* cx);
-
-extern void
-UnhideScriptedCaller(JSContext* cx);
-
-class AutoHideScriptedCaller
-{
-  public:
-    explicit AutoHideScriptedCaller(JSContext* cx
-                                                                   )
-      : mContext(cx)
-    {
-        do { } while (0);
-        HideScriptedCaller(mContext);
-    }
-    ~AutoHideScriptedCaller() {
-        UnhideScriptedCaller(mContext);
-    }
-
-  protected:
-    JSContext* mContext;
-
-};
-
-
-
-
-
-typedef mozilla::Vector<uint8_t> TranscodeBuffer;
-
-enum TranscodeResult
-{
-
-    TranscodeResult_Ok = 0,
-
-
-    TranscodeResult_Failure = 0x100,
-    TranscodeResult_Failure_BadBuildId = TranscodeResult_Failure | 0x1,
-    TranscodeResult_Failure_RunOnceNotSupported = TranscodeResult_Failure | 0x2,
-    TranscodeResult_Failure_AsmJSNotSupported = TranscodeResult_Failure | 0x3,
-    TranscodeResult_Failure_UnknownClassKind = TranscodeResult_Failure | 0x4,
-    TranscodeResult_Failure_WrongCompileOption = TranscodeResult_Failure | 0x5,
-    TranscodeResult_Failure_NotInterpretedFun = TranscodeResult_Failure | 0x6,
-
-
-    TranscodeResult_Throw = 0x200
-};
-
-extern TranscodeResult
-EncodeScript(JSContext* cx, TranscodeBuffer& buffer, JS::HandleScript script);
-
-extern TranscodeResult
-EncodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, JS::HandleObject funobj);
-
-extern TranscodeResult
-DecodeScript(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleScript scriptp,
-             size_t cursorIndex = 0);
-
-extern TranscodeResult
-DecodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleFunction funp,
-                          size_t cursorIndex = 0);
-# 6186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-StartIncrementalEncoding(JSContext* cx, TranscodeBuffer& buffer, JS::HandleScript script);
-
-extern bool
-FinishIncrementalEncoding(JSContext* cx, JS::HandleScript script);
-
-}
-
-namespace js {
-
-enum class StackFormat { SpiderMonkey, V8, Default };
-# 6205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern void
-SetStackFormat(JSContext* cx, StackFormat format);
-
-extern StackFormat
-GetStackFormat(JSContext* cx);
-
-}
-
-namespace JS {
-# 6224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef bool
-(* OpenAsmJSCacheEntryForReadOp)(HandleObject global, const char16_t* begin, const char16_t* limit,
-                                 size_t* size, const uint8_t** memory, intptr_t* handle);
-typedef void
-(* CloseAsmJSCacheEntryForReadOp)(size_t size, const uint8_t* memory, intptr_t handle);
-
-
-enum AsmJSCacheResult
-{
-    AsmJSCache_Success,
-    AsmJSCache_MIN = AsmJSCache_Success,
-    AsmJSCache_ModuleTooSmall,
-    AsmJSCache_SynchronousScript,
-    AsmJSCache_QuotaExceeded,
-    AsmJSCache_StorageInitFailure,
-    AsmJSCache_Disabled_Internal,
-    AsmJSCache_Disabled_ShellFlags,
-    AsmJSCache_Disabled_JitInspector,
-    AsmJSCache_InternalError,
-    AsmJSCache_Disabled_PrivateBrowsing,
-    AsmJSCache_LIMIT
-};
-# 6256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef AsmJSCacheResult
-(* OpenAsmJSCacheEntryForWriteOp)(HandleObject global, const char16_t* begin,
-                                  const char16_t* end, size_t size,
-                                  uint8_t** memory, intptr_t* handle);
-typedef void
-(* CloseAsmJSCacheEntryForWriteOp)(size_t size, uint8_t* memory, intptr_t handle);
-
-struct AsmJSCacheOps
-{
-    OpenAsmJSCacheEntryForReadOp openEntryForRead;
-    CloseAsmJSCacheEntryForReadOp closeEntryForRead;
-    OpenAsmJSCacheEntryForWriteOp openEntryForWrite;
-    CloseAsmJSCacheEntryForWriteOp closeEntryForWrite;
-};
-
-extern void
-SetAsmJSCacheOps(JSContext* cx, const AsmJSCacheOps* callbacks);
-# 6281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef js::Vector<char, 0, js::SystemAllocPolicy> BuildIdCharVector;
-
-typedef bool
-(* BuildIdOp)(BuildIdCharVector* buildId);
-
-extern void
-SetBuildIdOp(JSContext* cx, BuildIdOp buildIdOp);
-# 6315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-struct WasmModule : js::AtomicRefCounted<WasmModule>
-{
-    virtual ~WasmModule() {}
-
-    virtual void serializedSize(size_t* maybeBytecodeSize, size_t* maybeCompiledSize) const = 0;
-    virtual void serialize(uint8_t* maybeBytecodeBegin, size_t maybeBytecodeSize,
-                           uint8_t* maybeCompiledBegin, size_t maybeCompiledSize) const = 0;
-
-    virtual JSObject* createObject(JSContext* cx) = 0;
-};
-
-extern bool
-IsWasmModuleObject(HandleObject obj);
-
-extern RefPtr<WasmModule>
-GetWasmModule(HandleObject obj);
-
-extern bool
-CompiledWasmModuleAssumptionsMatch(PRFileDesc* compiled, BuildIdCharVector&& buildId);
-
-extern RefPtr<WasmModule>
-DeserializeWasmModule(PRFileDesc* bytecode, PRFileDesc* maybeCompiled, BuildIdCharVector&& buildId,
-                      JS::UniqueChars filename, unsigned line, unsigned column);
-# 6356 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-class ForOfIterator {
-  protected:
-    JSContext* cx_;
-# 6373 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-    JS::RootedObject iterator;
-    uint32_t index;
-
-    static const uint32_t NOT_ARRAY = (4294967295U);
-
-    ForOfIterator(const ForOfIterator&) = delete;
-    ForOfIterator& operator=(const ForOfIterator&) = delete;
-
-  public:
-    explicit ForOfIterator(JSContext* cx) : cx_(cx), iterator(cx_), index(NOT_ARRAY) { }
-
-    enum NonIterableBehavior {
-        ThrowOnNonIterable,
-        AllowNonIterable
-    };
-
-
-
-
-
-
-
-    bool init(JS::HandleValue iterable,
-              NonIterableBehavior nonIterableBehavior = ThrowOnNonIterable);
-
-
-
-
-
-    bool next(JS::MutableHandleValue val, bool* done);
-
-
-
-
-
-    void closeThrow();
-
-
-
-
-
-    bool valueIsIterable() const {
-        return iterator;
-    }
-
-  private:
-    inline bool nextFromOptimizedArray(MutableHandleValue val, bool* done);
-    bool materializeArrayIterator();
-};
-# 6431 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef void
-(* LargeAllocationFailureCallback)(void* data);
-
-extern void
-SetLargeAllocationFailureCallback(JSContext* cx, LargeAllocationFailureCallback afc, void* data);
-# 6448 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-typedef void
-(* OutOfMemoryCallback)(JSContext* cx, void* data);
-
-extern void
-SetOutOfMemoryCallback(JSContext* cx, OutOfMemoryCallback cb, void* data);
-
-
-
-
-struct AllFrames { };
-
-
-
-
-struct MaxFrames
-{
-    uint32_t maxFrames;
-
-    explicit MaxFrames(uint32_t max)
-      : maxFrames(max)
-    {
-        do { } while (0);
-    }
-};
-
-
-
-
-
-
-struct FirstSubsumedFrame
-{
-    JSContext* cx;
-    JSPrincipals* principals;
-    bool ignoreSelfHosted;
-
-
-
-
-    explicit FirstSubsumedFrame(JSContext* cx, bool ignoreSelfHostedFrames = true);
-
-    explicit FirstSubsumedFrame(JSContext* ctx, JSPrincipals* p, bool ignoreSelfHostedFrames = true)
-      : cx(ctx)
-      , principals(p)
-      , ignoreSelfHosted(ignoreSelfHostedFrames)
-    {
-        if (principals)
-            JS_HoldPrincipals(principals);
-    }
-
-
-
-    FirstSubsumedFrame(const FirstSubsumedFrame&) = delete;
-    FirstSubsumedFrame& operator=(const FirstSubsumedFrame&) = delete;
-
-    FirstSubsumedFrame(FirstSubsumedFrame&& rhs)
-      : principals(rhs.principals)
-      , ignoreSelfHosted(rhs.ignoreSelfHosted)
-    {
-        do { } while (0);
-        rhs.principals = nullptr;
-    }
-
-    FirstSubsumedFrame& operator=(FirstSubsumedFrame&& rhs) {
-        new (this) FirstSubsumedFrame(mozilla::Move(rhs));
-        return *this;
-    }
-
-    ~FirstSubsumedFrame() {
-        if (principals)
-            JS_DropPrincipals(cx, principals);
-    }
-};
-
-using StackCapture = mozilla::Variant<AllFrames, MaxFrames, FirstSubsumedFrame>;
-# 6542 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-CaptureCurrentStack(JSContext* cx, MutableHandleObject stackp,
-                    StackCapture&& capture = StackCapture(AllFrames()));
-# 6560 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-CopyAsyncStack(JSContext* cx, HandleObject asyncStack,
-               HandleString asyncCause, MutableHandleObject stackp,
-               unsigned maxFrameCount);
-# 6595 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-enum class SavedFrameResult {
-    Ok,
-    AccessDenied
-};
-
-enum class SavedFrameSelfHosted {
-    Include,
-    Exclude
-};
-
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameSource(JSContext* cx, HandleObject savedFrame, MutableHandleString sourcep,
-                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameLine(JSContext* cx, HandleObject savedFrame, uint32_t* linep,
-                  SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameColumn(JSContext* cx, HandleObject savedFrame, uint32_t* columnp,
-                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameFunctionDisplayName(JSContext* cx, HandleObject savedFrame, MutableHandleString namep,
-                                 SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameAsyncCause(JSContext* cx, HandleObject savedFrame, MutableHandleString asyncCausep,
-                        SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameAsyncParent(JSContext* cx, HandleObject savedFrame, MutableHandleObject asyncParentp,
-                SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-
-
-
-
-
-
-extern SavedFrameResult
-GetSavedFrameParent(JSContext* cx, HandleObject savedFrame, MutableHandleObject parentp,
-                    SavedFrameSelfHosted selfHosted = SavedFrameSelfHosted::Include);
-# 6673 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-BuildStackString(JSContext* cx, HandleObject stack, MutableHandleString stringp,
-                 size_t indent = 0, js::StackFormat stackFormat = js::StackFormat::Default);
-
-
-
-
-
-extern bool
-IsSavedFrame(JSObject* obj);
-
-}
-
-
-
-
-namespace js {
-
-class AutoStopwatch;
-
-
-
-
-
-
-
-struct PerformanceGroup {
-    PerformanceGroup();
-
-
-    uint64_t iteration() const;
-
-
-
-
-    bool isAcquired(uint64_t it) const;
-
-
-
-
-    bool isAcquired(uint64_t it, const AutoStopwatch* owner) const;
-
-
-
-    void acquire(uint64_t it, const AutoStopwatch* owner);
-
-
-
-    void release(uint64_t it, const AutoStopwatch* owner);
-
-
-
-
-
-    uint64_t recentCycles(uint64_t iteration) const;
-    void addRecentCycles(uint64_t iteration, uint64_t cycles);
-
-
-
-    uint64_t recentTicks(uint64_t iteration) const;
-    void addRecentTicks(uint64_t iteration, uint64_t ticks);
-
-
-
-    uint64_t recentCPOW(uint64_t iteration) const;
-    void addRecentCPOW(uint64_t iteration, uint64_t CPOW);
-
-
-    void resetRecentData();
-
-
-
-    bool isActive() const;
-    void setIsActive(bool);
-
-
-
-    bool isUsedInThisIteration() const;
-    void setIsUsedInThisIteration(bool);
-  protected:
-
-
-    virtual void Delete() = 0;
-
-  private:
-
-
-
-
-    uint64_t recentCycles_;
-
-
-
-    uint64_t recentTicks_;
-
-
-
-    uint64_t recentCPOW_;
-
-
-
-    uint64_t iteration_;
-
-
-
-    bool isActive_;
-
-
-
-    bool isUsedInThisIteration_;
-
-
-
-    const AutoStopwatch* owner_;
-
-  public:
-
-    void AddRef();
-    void Release();
-    uint64_t refCount_;
-};
-
-using PerformanceGroupVector = mozilla::Vector<RefPtr<js::PerformanceGroup>, 8, SystemAllocPolicy>;
-
-
-
-
-
-
-
-extern bool
-FlushPerformanceMonitoring(JSContext*);
-
-
-
-
-extern void
-ResetPerformanceMonitoring(JSContext*);
-
-
-
-
-extern void
-DisposePerformanceMonitoring(JSContext*);
-# 6825 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsapi.h"
-extern bool
-SetStopwatchIsMonitoringCPOW(JSContext*, bool);
-extern bool
-GetStopwatchIsMonitoringCPOW(JSContext*);
-extern bool
-SetStopwatchIsMonitoringJank(JSContext*, bool);
-extern bool
-GetStopwatchIsMonitoringJank(JSContext*);
-
-
-extern void
-GetPerfMonitoringTestCpuRescheduling(JSContext*, uint64_t* stayed, uint64_t* moved);
-
-
-
-
-
-
-extern void
-AddCPOWPerformanceDelta(JSContext*, uint64_t delta);
-
-typedef bool
-(*StopwatchStartCallback)(uint64_t, void*);
-extern bool
-SetStopwatchStartCallback(JSContext*, StopwatchStartCallback, void*);
-
-typedef bool
-(*StopwatchCommitCallback)(uint64_t, PerformanceGroupVector&, void*);
-extern bool
-SetStopwatchCommitCallback(JSContext*, StopwatchCommitCallback, void*);
-
-typedef bool
-(*GetGroupsCallback)(JSContext*, PerformanceGroupVector&, void*);
-extern bool
-SetGetPerformanceGroupsCallback(JSContext*, GetGroupsCallback, void*);
-
-}
-
-namespace js {
-
-enum class CompletionKind {
-    Normal,
-    Return,
-    Throw
-};
-
-}
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h"
-class nsIObjectInputStream;
-
-class nsIObjectOutputStream;
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISerializable.h"
-class nsISerializable : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Read(nsIObjectInputStream *aInputStream) = 0;
-
-
-  virtual nsresult Write(nsIObjectOutputStream *aOutputStream) = 0;
-
-};
-
-  template<typename T> struct nsISerializable::COMTypeInfo<nsISerializable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISerializable::COMTypeInfo<nsISerializable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x91cca981, 0xc26d, 0x44a8, { 0xbe, 0xbe, 0xd9, 0xed, 0x48, 0x91, 0x50, 0x3a }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h" 2
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
-struct JSPrincipals;
-
-
-
-namespace mozilla {
-class OriginAttributes;
-}
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
-class nsIURI;
-
-class nsIContentSecurityPolicy;
-
-class nsIDOMDocument;
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
-class nsIPrincipal : public nsISerializable {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Equals(nsIPrincipal *other, bool *_retval) = 0;
-
-
-  virtual nsresult EqualsConsideringDomain(nsIPrincipal *other, bool *_retval) = 0;
-
-       inline bool Equals(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(Equals(aOther, &retVal))), 1))) && retVal); }
-      inline bool EqualsConsideringDomain(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(EqualsConsideringDomain(aOther, &retVal))), 1))) && retVal); }
-
-  virtual nsresult GetHashValue(uint32_t *aHashValue) = 0;
-
-
-  virtual nsresult GetURI(nsIURI * *aURI) = 0;
-
-
-  virtual nsresult GetDomain(nsIURI * *aDomain) = 0;
-  virtual nsresult SetDomain(nsIURI *aDomain) = 0;
-
-
-  virtual nsresult Subsumes(nsIPrincipal *other, bool *_retval) = 0;
-
-
-  virtual nsresult SubsumesConsideringDomain(nsIPrincipal *other, bool *_retval) = 0;
-
-
-  virtual nsresult SubsumesConsideringDomainIgnoringFPD(nsIPrincipal *other, bool *_retval) = 0;
-
-       inline bool Subsumes(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(Subsumes(aOther, &retVal))), 1))) && retVal); }
-      inline bool SubsumesConsideringDomain(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(SubsumesConsideringDomain(aOther, &retVal))), 1))) && retVal); }
-      inline bool SubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther) { mozilla::DebugOnly<bool> val = false; do { } while (0); bool retVal = false; return this == aOther || (((bool)(__builtin_expect(!!(!NS_FAILED_impl(SubsumesConsideringDomainIgnoringFPD(aOther, &retVal))), 1))) && retVal); }
-
-
-  virtual nsresult CheckMayLoad(nsIURI *uri, bool report, bool allowIfInheritsPrincipal) = 0;
-
-
-  virtual nsresult GetCsp(nsIContentSecurityPolicy * *aCsp) = 0;
-  virtual nsresult SetCsp(nsIContentSecurityPolicy *aCsp) = 0;
-
-
-  virtual nsresult EnsureCSP(nsIDOMDocument *aDocument, nsIContentSecurityPolicy * *_retval) = 0;
-
-
-  virtual nsresult GetPreloadCsp(nsIContentSecurityPolicy * *aPreloadCsp) = 0;
-
-
-  virtual nsresult EnsurePreloadCSP(nsIDOMDocument *aDocument, nsIContentSecurityPolicy * *_retval) = 0;
-
-
-  virtual nsresult GetCspJSON(nsAString & aCspJSON) = 0;
-
-
-  virtual nsresult GetOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) = 0;
-
-
-  virtual const mozilla::OriginAttributes & OriginAttributesRef(void) = 0;
-
-
-  virtual nsresult GetOrigin(nsACString & aOrigin) = 0;
-
-
-  virtual nsresult GetOriginNoSuffix(nsACString & aOriginNoSuffix) = 0;
-
-
-  virtual nsresult GetOriginSuffix(nsACString & aOriginSuffix) = 0;
-
-
-  virtual nsresult GetBaseDomain(nsACString & aBaseDomain) = 0;
-
-  enum {
-    APP_STATUS_NOT_INSTALLED = 0,
-    APP_STATUS_INSTALLED = 1,
-    APP_STATUS_PRIVILEGED = 2,
-    APP_STATUS_CERTIFIED = 3
-  };
-
-
-  virtual nsresult GetAppStatus(uint16_t *aAppStatus) = 0;
-  inline uint16_t GetAppStatus()
-  {
-    uint16_t result;
-    mozilla::DebugOnly<nsresult> rv = GetAppStatus(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetAppId(uint32_t *aAppId) = 0;
-  inline uint32_t GetAppId()
-  {
-    uint32_t result;
-    mozilla::DebugOnly<nsresult> rv = GetAppId(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetAddonId(nsAString & aAddonId) = 0;
-
-
-  virtual nsresult GetUserContextId(uint32_t *aUserContextId) = 0;
-  inline uint32_t GetUserContextId()
-  {
-    uint32_t result;
-    mozilla::DebugOnly<nsresult> rv = GetUserContextId(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetPrivateBrowsingId(uint32_t *aPrivateBrowsingId) = 0;
-  inline uint32_t GetPrivateBrowsingId()
-  {
-    uint32_t result;
-    mozilla::DebugOnly<nsresult> rv = GetPrivateBrowsingId(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsInIsolatedMozBrowserElement(bool *aIsInIsolatedMozBrowserElement) = 0;
-  inline bool GetIsInIsolatedMozBrowserElement()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsInIsolatedMozBrowserElement(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetUnknownAppId(bool *aUnknownAppId) = 0;
-  inline bool GetUnknownAppId()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetUnknownAppId(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsNullPrincipal(bool *aIsNullPrincipal) = 0;
-  inline bool GetIsNullPrincipal()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsNullPrincipal(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsCodebasePrincipal(bool *aIsCodebasePrincipal) = 0;
-  inline bool GetIsCodebasePrincipal()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsCodebasePrincipal(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsExpandedPrincipal(bool *aIsExpandedPrincipal) = 0;
-  inline bool GetIsExpandedPrincipal()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsExpandedPrincipal(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsSystemPrincipal(bool *aIsSystemPrincipal) = 0;
-  inline bool GetIsSystemPrincipal()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsSystemPrincipal(&result);
-    do { } while (0);
-    return result;
-  }
-
-};
-
-  template<typename T> struct nsIPrincipal::COMTypeInfo<nsIPrincipal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrincipal::COMTypeInfo<nsIPrincipal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf75f502d, 0x79fd, 0x48be, { 0xa0, 0x79, 0xe5, 0xa7, 0xb8, 0xf8, 0x0c, 0x8b }};
-# 658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrincipal.h"
-class nsIExpandedPrincipal : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetAllowList(nsTArray<nsCOMPtr<nsIPrincipal> > **anAllowList) = 0;
-
-};
-
-  template<typename T> struct nsIExpandedPrincipal::COMTypeInfo<nsIExpandedPrincipal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIExpandedPrincipal::COMTypeInfo<nsIExpandedPrincipal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf3e177df, 0x6a5e, 0x489f, { 0x80, 0xa7, 0x2d, 0xd1, 0x48, 0x14, 0x71, 0xd8 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSPrincipals.h" 2
-
-class nsJSPrincipals : public nsIPrincipal, public JSPrincipals
-{
-public:
-
-  static bool Subsume(JSPrincipals *jsprin, JSPrincipals *other);
-  static void Destroy(JSPrincipals *jsprin);
-
-
-  static bool ReadPrincipals(JSContext* aCx, JSStructuredCloneReader* aReader,
-                             JSPrincipals** aOutPrincipals);
-
-  static bool ReadKnownPrincipalType(JSContext* aCx,
-                                     JSStructuredCloneReader* aReader,
-                                     uint32_t aTag,
-                                     JSPrincipals** aOutPrincipals);
-
-  bool write(JSContext* aCx, JSStructuredCloneWriter* aWriter) final;
-
-
-
-
-
-  static nsJSPrincipals* get(JSPrincipals *principals) {
-    nsJSPrincipals *self = static_cast<nsJSPrincipals *>(principals);
-    do { } while (0);
-    return self;
-  }
-  static nsJSPrincipals* get(nsIPrincipal *principal) {
-    nsJSPrincipals *self = static_cast<nsJSPrincipals *>(principal);
-    do { } while (0);
-    return self;
-  }
-
-  virtual MozExternalRefCountType AddRef(void) override;
-  virtual MozExternalRefCountType Release(void) override;
-
-  nsJSPrincipals() {
-    refcount = 0;
-    setDebugToken(DEBUG_TOKEN);
-  }
-
-
-
-
-  virtual nsresult GetScriptLocation(nsACString &aStr) = 0;
-  static const uint32_t DEBUG_TOKEN = 0x0bf41760;
-
-protected:
-  virtual ~nsJSPrincipals() {
-    setDebugToken(0);
-  }
-
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h"
-namespace mozilla {
-namespace dom {
-
-class ChromeUtils;
-struct ChromeUtilsAtoms;
-struct CompileScriptOptionsDictionaryAtoms;
-struct NativePropertyHooks;
-struct OriginAttributesDictionaryAtoms;
-struct OriginAttributesPatternDictionaryAtoms;
-class ProtoAndIfaceCache;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-struct CompileScriptOptionsDictionary : public DictionaryBase
-{
-                        nsString mCharset;
-                        bool mHasReturnValue;
-                        bool mLazilyParse;
-
-  CompileScriptOptionsDictionary();
-
-  explicit inline CompileScriptOptionsDictionary(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline CompileScriptOptionsDictionary(const CompileScriptOptionsDictionary& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  CompileScriptOptionsDictionary&
-  operator=(const CompileScriptOptionsDictionary& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, CompileScriptOptionsDictionaryAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastCompileScriptOptionsDictionary : public CompileScriptOptionsDictionary
-{
-  inline FastCompileScriptOptionsDictionary()
-    : CompileScriptOptionsDictionary(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct OriginAttributesDictionary : public DictionaryBase
-{
-                        uint32_t mAppId;
-                        nsString mFirstPartyDomain;
-                        bool mInIsolatedMozBrowser;
-                        uint32_t mPrivateBrowsingId;
-                        uint32_t mUserContextId;
-
-  OriginAttributesDictionary();
-
-  explicit inline OriginAttributesDictionary(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline OriginAttributesDictionary(const OriginAttributesDictionary& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  OriginAttributesDictionary&
-  operator=(const OriginAttributesDictionary& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, OriginAttributesDictionaryAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastOriginAttributesDictionary : public OriginAttributesDictionary
-{
-  inline FastOriginAttributesDictionary()
-    : OriginAttributesDictionary(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct OriginAttributesPatternDictionary : public DictionaryBase
-{
-                        Optional<uint32_t> mAppId;
-                        Optional<nsString> mFirstPartyDomain;
-                        Optional<bool> mInIsolatedMozBrowser;
-                        Optional<uint32_t> mPrivateBrowsingId;
-                        Optional<uint32_t> mUserContextId;
-
-  OriginAttributesPatternDictionary();
-
-  explicit inline OriginAttributesPatternDictionary(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline OriginAttributesPatternDictionary(const OriginAttributesPatternDictionary& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  OriginAttributesPatternDictionary&
-  operator=(const OriginAttributesPatternDictionary& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, OriginAttributesPatternDictionaryAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastOriginAttributesPatternDictionary : public OriginAttributesPatternDictionary
-{
-  inline FastOriginAttributesPatternDictionary()
-    : OriginAttributesPatternDictionary(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-namespace ChromeUtilsBinding {
-
-  typedef mozilla::dom::ChromeUtils NativeType;
-
-  bool
-  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-# 209 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtilsBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h"
-namespace mozilla {
-namespace dom {
-
-struct Base64URLDecodeOptionsAtoms;
-struct Base64URLEncodeOptionsAtoms;
-struct HeapSnapshotBoundariesAtoms;
-struct NativePropertyHooks;
-class ProtoAndIfaceCache;
-class ThreadSafeChromeUtils;
-struct ThreadSafeChromeUtilsAtoms;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class Base64URLDecodePadding : uint8_t {
-  Require,
-  Ignore,
-  Reject,
-  EndGuard_
-};
-
-namespace Base64URLDecodePaddingValues {
-extern const EnumEntry strings[4];
-}
-
-bool
-ToJSValue(JSContext* aCx, Base64URLDecodePadding aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-struct Base64URLDecodeOptions : public DictionaryBase
-{
-                        Base64URLDecodePadding mPadding;
-
-  Base64URLDecodeOptions();
-
-  explicit inline Base64URLDecodeOptions(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline Base64URLDecodeOptions(const Base64URLDecodeOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  Base64URLDecodeOptions&
-  operator=(const Base64URLDecodeOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, Base64URLDecodeOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastBase64URLDecodeOptions : public Base64URLDecodeOptions
-{
-  inline FastBase64URLDecodeOptions()
-    : Base64URLDecodeOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct Base64URLEncodeOptions : public DictionaryBase
-{
-                        bool mPad;
-
-  Base64URLEncodeOptions();
-
-  explicit inline Base64URLEncodeOptions(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline Base64URLEncodeOptions(const Base64URLEncodeOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  Base64URLEncodeOptions&
-  operator=(const Base64URLEncodeOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, Base64URLEncodeOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastBase64URLEncodeOptions : public Base64URLEncodeOptions
-{
-  inline FastBase64URLEncodeOptions()
-    : Base64URLEncodeOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct HeapSnapshotBoundaries : public DictionaryBase
-{
-                        Optional<JSObject*> mDebugger;
-                        Optional<Sequence<JSObject*>> mGlobals;
-                        Optional<bool> mRuntime;
-
-  HeapSnapshotBoundaries();
-
-  explicit inline HeapSnapshotBoundaries(const FastDictionaryInitializer& )
-  {
-
-  }
-
-private:
-  HeapSnapshotBoundaries(const HeapSnapshotBoundaries&) = delete;
-  HeapSnapshotBoundaries& operator=(const HeapSnapshotBoundaries&) = delete;
-
-  static bool
-  InitIds(JSContext* cx, HeapSnapshotBoundariesAtoms* atomsCache);
-
-public:
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-};
-
-namespace binding_detail {
-struct FastHeapSnapshotBoundaries : public HeapSnapshotBoundaries
-{
-  inline FastHeapSnapshotBoundaries()
-    : HeapSnapshotBoundaries(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-namespace ThreadSafeChromeUtilsBinding {
-
-  typedef mozilla::dom::ThreadSafeChromeUtils NativeType;
-
-  bool
-  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ThreadSafeChromeUtilsBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ChromeUtils.h" 2
-
-
-namespace mozilla {
-
-namespace devtools {
-class HeapSnapshot;
-}
-
-namespace dom {
-
-class ArrayBufferViewOrArrayBuffer;
-class PrecompiledScript;
-class Promise;
-
-class ThreadSafeChromeUtils
-{
-private:
-
-  static void SaveHeapSnapshotShared(GlobalObject& global,
-                                     const HeapSnapshotBoundaries& boundaries,
-                                     nsAString& filePath,
-                                     nsAString& snapshotId,
-                                     ErrorResult& rv);
-
-public:
-
-  static void SaveHeapSnapshot(GlobalObject& global,
-                               const HeapSnapshotBoundaries& boundaries,
-                               nsAString& filePath,
-                               ErrorResult& rv);
-
-
-  static void SaveHeapSnapshotGetId(GlobalObject& global,
-                                    const HeapSnapshotBoundaries& boundaries,
-                                    nsAString& snapshotId,
-                                    ErrorResult& rv);
-
-
-  static already_AddRefed<devtools::HeapSnapshot> ReadHeapSnapshot(GlobalObject& global,
-                                                                   const nsAString& filePath,
-                                                                   ErrorResult& rv);
-
-  static void NondeterministicGetWeakMapKeys(GlobalObject& aGlobal,
-                                             JS::Handle<JS::Value> aMap,
-                                             JS::MutableHandle<JS::Value> aRetval,
-                                             ErrorResult& aRv);
-
-  static void NondeterministicGetWeakSetKeys(GlobalObject& aGlobal,
-                                             JS::Handle<JS::Value> aSet,
-                                             JS::MutableHandle<JS::Value> aRetval,
-                                             ErrorResult& aRv);
-
-  static void Base64URLEncode(GlobalObject& aGlobal,
-                              const ArrayBufferViewOrArrayBuffer& aSource,
-                              const Base64URLEncodeOptions& aOptions,
-                              nsACString& aResult,
-                              ErrorResult& aRv);
-
-  static void Base64URLDecode(GlobalObject& aGlobal,
-                              const nsACString& aString,
-                              const Base64URLDecodeOptions& aOptions,
-                              JS::MutableHandle<JSObject*> aRetval,
-                              ErrorResult& aRv);
-};
-
-class ChromeUtils : public ThreadSafeChromeUtils
-{
-public:
-  static void
-  OriginAttributesToSuffix(GlobalObject& aGlobal,
-                           const dom::OriginAttributesDictionary& aAttrs,
-                           nsCString& aSuffix);
-
-  static bool
-  OriginAttributesMatchPattern(dom::GlobalObject& aGlobal,
-                               const dom::OriginAttributesDictionary& aAttrs,
-                               const dom::OriginAttributesPatternDictionary& aPattern);
-
-  static void
-  CreateOriginAttributesFromOrigin(dom::GlobalObject& aGlobal,
-                                   const nsAString& aOrigin,
-                                   dom::OriginAttributesDictionary& aAttrs,
-                                   ErrorResult& aRv);
-
-  static void
-  FillNonDefaultOriginAttributes(dom::GlobalObject& aGlobal,
-                                 const dom::OriginAttributesDictionary& aAttrs,
-                                 dom::OriginAttributesDictionary& aNewAttrs);
-
-  static bool
-  IsOriginAttributesEqual(dom::GlobalObject& aGlobal,
-                          const dom::OriginAttributesDictionary& aA,
-                          const dom::OriginAttributesDictionary& aB);
-
-  static bool
-  IsOriginAttributesEqual(const dom::OriginAttributesDictionary& aA,
-                          const dom::OriginAttributesDictionary& aB);
-
-  static bool
-  IsOriginAttributesEqualIgnoringFPD(const dom::OriginAttributesDictionary& aA,
-                                     const dom::OriginAttributesDictionary& aB)
-  {
-    return aA.mAppId == aB.mAppId &&
-           aA.mInIsolatedMozBrowser == aB.mInIsolatedMozBrowser &&
-           aA.mUserContextId == aB.mUserContextId &&
-           aA.mPrivateBrowsingId == aB.mPrivateBrowsingId;
-  }
-
-
-  static already_AddRefed<Promise>
-  CompileScript(GlobalObject& aGlobal,
-                const nsAString& aUrl,
-                const dom::CompileScriptOptionsDictionary& aOptions,
-                ErrorResult& aRv);
-};
-
-}
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h"
-class nsIURI;
-
-class nsIChannel;
-
-class nsIClassInfo;
-
-class nsIDocShell;
-
-class nsIDomainPolicy;
-
-class nsILoadContext;
-
-
-namespace mozilla {
-namespace dom {
-class DomainPolicyClone;
-}
-}
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptSecurityManager.h"
-class nsIScriptSecurityManager : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult CanCreateWrapper(JSContext *aJSContext, const nsIID & aIID, nsISupports *aObj, nsIClassInfo *aClassInfo) = 0;
-
-
-  virtual nsresult CanCreateInstance(JSContext *aJSContext, const nsCID & aCID) = 0;
-
-
-  virtual nsresult CanGetService(JSContext *aJSContext, const nsCID & aCID) = 0;
-
-
-  virtual nsresult CheckLoadURIFromScript(JSContext *cx, nsIURI *uri) = 0;
-
-  enum {
-    STANDARD = 0U,
-    LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT = 1U,
-    ALLOW_CHROME = 2U,
-    DISALLOW_INHERIT_PRINCIPAL = 4U,
-    DISALLOW_SCRIPT_OR_DATA = 4U,
-    DISALLOW_SCRIPT = 8U,
-    DONT_REPORT_ERRORS = 16U
-  };
-
-
-  virtual nsresult CheckLoadURIWithPrincipal(nsIPrincipal *aPrincipal, nsIURI *uri, uint32_t flags) = 0;
-
-
-  virtual nsresult CheckLoadURIStrWithPrincipal(nsIPrincipal *aPrincipal, const nsACString & uri, uint32_t flags) = 0;
-
-
-  virtual nsresult GetSystemPrincipal(nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetAppCodebasePrincipal(nsIURI *uri, uint32_t appId, bool inMozBrowser, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetLoadContextCodebasePrincipal(nsIURI *uri, nsILoadContext *loadContext, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetDocShellCodebasePrincipal(nsIURI *uri, nsIDocShell *docShell, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetNoAppCodebasePrincipal(nsIURI *uri, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetCodebasePrincipal(nsIURI *uri, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult CreateCodebasePrincipal(nsIURI *uri, JS::HandleValue originAttributes, JSContext* cx, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult CreateCodebasePrincipalFromOrigin(const nsACString & origin, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult CreateNullPrincipal(JS::HandleValue originAttributes, JSContext* cx, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult CheckSameOriginURI(nsIURI *aSourceURI, nsIURI *aTargetURI, bool reportError) = 0;
-
-
-  virtual nsresult GetChannelResultPrincipal(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetChannelResultPrincipalIfNotSandboxed(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult GetChannelURIPrincipal(nsIChannel *aChannel, nsIPrincipal * *_retval) = 0;
-
-
-  virtual nsresult IsSystemPrincipal(nsIPrincipal *aPrincipal, bool *_retval) = 0;
-
-     bool IsSystemPrincipal(nsIPrincipal* aPrincipal) {
-      bool isSystem = false;
-      IsSystemPrincipal(aPrincipal, &isSystem);
-      return isSystem;
-    }
-  enum {
-    NO_APP_ID = 0U,
-    UNKNOWN_APP_ID = 4294967295U,
-    DEFAULT_USER_CONTEXT_ID = 0U
-  };
-
-
-  virtual nsresult ActivateDomainPolicy(nsIDomainPolicy * *_retval) = 0;
-
-
-  virtual nsresult GetDomainPolicyActive(bool *aDomainPolicyActive) = 0;
-
-
-  virtual nsresult ActivateDomainPolicyInternal(nsIDomainPolicy * *_retval) = 0;
-
-
-  virtual void CloneDomainPolicy(mozilla::dom::DomainPolicyClone *aClone) = 0;
-
-
-  virtual nsresult PolicyAllowsScript(nsIURI *aDomain, bool *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIScriptSecurityManager::COMTypeInfo<nsIScriptSecurityManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptSecurityManager::COMTypeInfo<nsIScriptSecurityManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x51daad87, 0x3a0c, 0x44cc, { 0xb6, 0x20, 0x73, 0x56, 0x80, 0x1c, 0x90, 0x22 }};
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/OriginAttributes.h" 2
-
-namespace mozilla {
-
-class OriginAttributes : public dom::OriginAttributesDictionary
-{
-public:
-  OriginAttributes() {}
-
-  OriginAttributes(uint32_t aAppId, bool aInIsolatedMozBrowser)
-  {
-    mAppId = aAppId;
-    mInIsolatedMozBrowser = aInIsolatedMozBrowser;
-  }
-
-  explicit OriginAttributes(const OriginAttributesDictionary& aOther)
-    : OriginAttributesDictionary(aOther)
-  {}
-
-  void SetFirstPartyDomain(const bool aIsTopLevelDocument, nsIURI* aURI);
-  void SetFirstPartyDomain(const bool aIsTopLevelDocument, const nsACString& aDomain);
-
-  enum {
-    STRIP_FIRST_PARTY_DOMAIN = 0x01,
-    STRIP_USER_CONTEXT_ID = 0x02,
-  };
-
-  inline void StripAttributes(uint32_t aFlags)
-  {
-    if (aFlags & STRIP_FIRST_PARTY_DOMAIN) {
-      mFirstPartyDomain.Truncate();
-    }
-
-    if (aFlags & STRIP_USER_CONTEXT_ID) {
-      mUserContextId = nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID;
-    }
-  }
-
-  bool operator==(const OriginAttributes& aOther) const
-  {
-    return mAppId == aOther.mAppId &&
-           mInIsolatedMozBrowser == aOther.mInIsolatedMozBrowser &&
-           mUserContextId == aOther.mUserContextId &&
-           mPrivateBrowsingId == aOther.mPrivateBrowsingId &&
-           mFirstPartyDomain == aOther.mFirstPartyDomain;
-  }
-
-  bool operator!=(const OriginAttributes& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-
-
-
-  void CreateSuffix(nsACString& aStr) const;
-
-
-  void CreateAnonymizedSuffix(nsACString& aStr) const;
-
-  __attribute__ ((warn_unused_result)) bool PopulateFromSuffix(const nsACString& aStr);
-
-
-
-  __attribute__ ((warn_unused_result)) bool PopulateFromOrigin(const nsACString& aOrigin,
-                                       nsACString& aOriginNoSuffix);
-
-
-
-  void SyncAttributesWithPrivateBrowsing(bool aInPrivateBrowsing);
-
-
-  static inline bool IsFirstPartyEnabled()
-  {
-    return sFirstPartyIsolation;
-  }
-
-
-
-
-  static inline bool IsRestrictOpenerAccessForFPI()
-  {
-
-
-    return !sFirstPartyIsolation || sRestrictedOpenerAccess;
-  }
-
-
-
-  static bool IsPrivateBrowsing(const nsACString& aOrigin);
-
-  static void InitPrefs();
-
-private:
-  static bool sFirstPartyIsolation;
-  static bool sRestrictedOpenerAccess;
-};
-
-class OriginAttributesPattern : public dom::OriginAttributesPatternDictionary
-{
-public:
-
-
-
-
-
-
-  OriginAttributesPattern() {}
-
-  explicit OriginAttributesPattern(const OriginAttributesPatternDictionary& aOther)
-    : OriginAttributesPatternDictionary(aOther) {}
-
-
-  bool Matches(const OriginAttributes& aAttrs) const
-  {
-    if (mAppId.WasPassed() && mAppId.Value() != aAttrs.mAppId) {
-      return false;
-    }
-
-    if (mInIsolatedMozBrowser.WasPassed() && mInIsolatedMozBrowser.Value() != aAttrs.mInIsolatedMozBrowser) {
-      return false;
-    }
-
-    if (mUserContextId.WasPassed() && mUserContextId.Value() != aAttrs.mUserContextId) {
-      return false;
-    }
-
-    if (mPrivateBrowsingId.WasPassed() && mPrivateBrowsingId.Value() != aAttrs.mPrivateBrowsingId) {
-      return false;
-    }
-
-    if (mFirstPartyDomain.WasPassed() && mFirstPartyDomain.Value() != aAttrs.mFirstPartyDomain) {
-      return false;
-    }
-
-    return true;
-  }
-
-  bool Overlaps(const OriginAttributesPattern& aOther) const
-  {
-    if (mAppId.WasPassed() && aOther.mAppId.WasPassed() &&
-        mAppId.Value() != aOther.mAppId.Value()) {
-      return false;
-    }
-
-    if (mInIsolatedMozBrowser.WasPassed() &&
-        aOther.mInIsolatedMozBrowser.WasPassed() &&
-        mInIsolatedMozBrowser.Value() != aOther.mInIsolatedMozBrowser.Value()) {
-      return false;
-    }
-
-    if (mUserContextId.WasPassed() && aOther.mUserContextId.WasPassed() &&
-        mUserContextId.Value() != aOther.mUserContextId.Value()) {
-      return false;
-    }
-
-    if (mPrivateBrowsingId.WasPassed() && aOther.mPrivateBrowsingId.WasPassed() &&
-        mPrivateBrowsingId.Value() != aOther.mPrivateBrowsingId.Value()) {
-      return false;
-    }
-
-    if (mFirstPartyDomain.WasPassed() && aOther.mFirstPartyDomain.WasPassed() &&
-        mFirstPartyDomain.Value() != aOther.mFirstPartyDomain.Value()) {
-      return false;
-    }
-
-    return true;
-  }
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h" 2
-
-class nsIContentSecurityPolicy;
-class nsIObjectOutputStream;
-class nsIObjectInputStream;
-class nsIURI;
-
-class ExpandedPrincipal;
-
-namespace mozilla {
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BasePrincipal.h"
-class BasePrincipal : public nsJSPrincipals
-{
-public:
-  enum PrincipalKind {
-    eNullPrincipal,
-    eCodebasePrincipal,
-    eExpandedPrincipal,
-    eSystemPrincipal
-  };
-
-  explicit BasePrincipal(PrincipalKind aKind);
-
-  enum DocumentDomainConsideration { DontConsiderDocumentDomain, ConsiderDocumentDomain};
-  bool Subsumes(nsIPrincipal* aOther, DocumentDomainConsideration aConsideration);
-
-  virtual nsresult GetOrigin(nsACString& aOrigin) final;
-  virtual nsresult GetOriginNoSuffix(nsACString& aOrigin) final;
-  virtual nsresult Equals(nsIPrincipal* other, bool* _retval) final;
-  virtual nsresult EqualsConsideringDomain(nsIPrincipal* other, bool* _retval) final;
-  virtual nsresult Subsumes(nsIPrincipal* other, bool* _retval) final;
-  virtual nsresult SubsumesConsideringDomain(nsIPrincipal* other, bool* _retval) final;
-  virtual nsresult SubsumesConsideringDomainIgnoringFPD(nsIPrincipal* other, bool* _retval) final;
-  virtual nsresult CheckMayLoad(nsIURI* uri, bool report, bool allowIfInheritsPrincipal) final;
-  virtual nsresult GetCsp(nsIContentSecurityPolicy** aCsp) override;
-  virtual nsresult SetCsp(nsIContentSecurityPolicy* aCsp) override;
-  virtual nsresult EnsureCSP(nsIDOMDocument* aDocument, nsIContentSecurityPolicy** aCSP) override;
-  virtual nsresult GetPreloadCsp(nsIContentSecurityPolicy** aPreloadCSP) override;
-  virtual nsresult EnsurePreloadCSP(nsIDOMDocument* aDocument, nsIContentSecurityPolicy** aCSP) override;
-  virtual nsresult GetCspJSON(nsAString& outCSPinJSON) override;
-  virtual nsresult GetIsNullPrincipal(bool* aResult) override;
-  virtual nsresult GetIsCodebasePrincipal(bool* aResult) override;
-  virtual nsresult GetIsExpandedPrincipal(bool* aResult) override;
-  virtual nsresult GetIsSystemPrincipal(bool* aResult) override;
-  virtual nsresult GetOriginAttributes(JSContext* aCx, JS::MutableHandle<JS::Value> aVal) final;
-  virtual nsresult GetOriginSuffix(nsACString& aOriginSuffix) final;
-  virtual nsresult GetAppStatus(uint16_t* aAppStatus) final;
-  virtual nsresult GetAppId(uint32_t* aAppStatus) final;
-  virtual nsresult GetIsInIsolatedMozBrowserElement(bool* aIsInIsolatedMozBrowserElement) final;
-  virtual nsresult GetUnknownAppId(bool* aUnknownAppId) final;
-  virtual nsresult GetUserContextId(uint32_t* aUserContextId) final;
-  virtual nsresult GetPrivateBrowsingId(uint32_t* aPrivateBrowsingId) final;
-
-  virtual bool AddonHasPermission(const nsAString& aPerm);
-
-  virtual bool IsCodebasePrincipal() const { return false; };
-
-  static BasePrincipal* Cast(nsIPrincipal* aPrin) { return static_cast<BasePrincipal*>(aPrin); }
-
-  static already_AddRefed<BasePrincipal>
-  CreateCodebasePrincipal(const nsACString& aOrigin);
-
-
-
-
-
-  static already_AddRefed<BasePrincipal>
-  CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs);
-
-  const OriginAttributes& OriginAttributesRef() final { return mOriginAttributes; }
-  uint32_t AppId() const { return mOriginAttributes.mAppId; }
-  uint32_t UserContextId() const { return mOriginAttributes.mUserContextId; }
-  uint32_t PrivateBrowsingId() const { return mOriginAttributes.mPrivateBrowsingId; }
-  bool IsInIsolatedMozBrowserElement() const { return mOriginAttributes.mInIsolatedMozBrowser; }
-
-  PrincipalKind Kind() const { return mKind; }
-
-  already_AddRefed<BasePrincipal> CloneStrippingUserContextIdAndFirstPartyDomain();
-
-
-
-
-  bool AddonAllowsLoad(nsIURI* aURI, bool aExplicit = false);
-
-
-  inline bool FastEquals(nsIPrincipal* aOther);
-  inline bool FastEqualsConsideringDomain(nsIPrincipal* aOther);
-  inline bool FastSubsumes(nsIPrincipal* aOther);
-  inline bool FastSubsumesConsideringDomain(nsIPrincipal* aOther);
-  inline bool FastSubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther);
-
-protected:
-  virtual ~BasePrincipal();
-
-
-
-  virtual bool SubsumesInternal(nsIPrincipal* aOther, DocumentDomainConsideration aConsider) = 0;
-
-
-
-
-  virtual bool MayLoadInternal(nsIURI* aURI) = 0;
-  friend class ::ExpandedPrincipal;
-
-  void
-  SetHasExplicitDomain()
-  {
-    mHasExplicitDomain = true;
-  }
-
-
-
-
-  void FinishInit(const nsACString& aOriginNoSuffix,
-                  const OriginAttributes& aOriginAttributes);
-
-  nsCOMPtr<nsIContentSecurityPolicy> mCSP;
-  nsCOMPtr<nsIContentSecurityPolicy> mPreloadCSP;
-
-private:
-  static already_AddRefed<BasePrincipal>
-  CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs,
-                          const nsACString& aOriginNoSuffix);
-
-  nsCOMPtr<nsIAtom> mOriginNoSuffix;
-  nsCOMPtr<nsIAtom> mOriginSuffix;
-
-  OriginAttributes mOriginAttributes;
-  PrincipalKind mKind;
-  bool mHasExplicitDomain;
-  bool mInitialized;
-};
-
-inline bool
-BasePrincipal::FastEquals(nsIPrincipal* aOther)
-{
-  auto other = Cast(aOther);
-  if (Kind() != other->Kind()) {
-
-    return false;
-  }
-
-
-
-
-
-
-  if (Kind() == eNullPrincipal || Kind() == eSystemPrincipal) {
-    return this == other;
-  }
-
-  if (Kind() == eCodebasePrincipal) {
-    return mOriginNoSuffix == other->mOriginNoSuffix &&
-           mOriginSuffix == other->mOriginSuffix;
-  }
-
-  do { } while (0);
-  return mOriginNoSuffix == other->mOriginNoSuffix;
-}
-
-inline bool
-BasePrincipal::FastEqualsConsideringDomain(nsIPrincipal* aOther)
-{
-
-
-  auto other = Cast(aOther);
-  if (!mHasExplicitDomain && !other->mHasExplicitDomain) {
-    return FastEquals(aOther);
-  }
-
-  return Subsumes(aOther, ConsiderDocumentDomain) &&
-         other->Subsumes(this, ConsiderDocumentDomain);
-}
-
-inline bool
-BasePrincipal::FastSubsumes(nsIPrincipal* aOther)
-{
-
-
-
-
-  auto other = Cast(aOther);
-  if (Kind() == eNullPrincipal && other->Kind() == eNullPrincipal) {
-    return this == other;
-  }
-  if (FastEquals(aOther)) {
-    return true;
-  }
-
-
-  return Subsumes(aOther, DontConsiderDocumentDomain);
-}
-
-inline bool
-BasePrincipal::FastSubsumesConsideringDomain(nsIPrincipal* aOther)
-{
-
-
-
-  if (!mHasExplicitDomain && !Cast(aOther)->mHasExplicitDomain) {
-    return FastSubsumes(aOther);
-  }
-
-  return Subsumes(aOther, ConsiderDocumentDomain);
-}
-
-inline bool
-BasePrincipal::FastSubsumesConsideringDomainIgnoringFPD(nsIPrincipal* aOther)
-{
-  if (Kind() == eCodebasePrincipal &&
-      !dom::ChromeUtils::IsOriginAttributesEqualIgnoringFPD(
-            mOriginAttributes, Cast(aOther)->mOriginAttributes)) {
-    return false;
-  }
-
- return SubsumesInternal(aOther, ConsiderDocumentDomain);
-}
-
-}
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h"
-namespace mozilla {
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LoadTainting.h"
-enum class LoadTainting : uint8_t
-{
-  Basic = 0,
-  CORS = 1,
-  Opaque = 2
-};
-
-}
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h" 2
-class nsCString;
-typedef uint32_t nsSecurityFlags;
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadInfo.h"
-class nsILoadInfo : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    SEC_NORMAL = 0U,
-    SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS = 1U,
-    SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED = 2U,
-    SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS = 4U,
-    SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL = 8U,
-    SEC_REQUIRE_CORS_DATA_INHERITS = 16U,
-    SEC_COOKIES_DEFAULT = 0U,
-    SEC_COOKIES_INCLUDE = 32U,
-    SEC_COOKIES_SAME_ORIGIN = 64U,
-    SEC_COOKIES_OMIT = 96U,
-    SEC_FORCE_INHERIT_PRINCIPAL = 128U,
-    SEC_SANDBOXED = 256U,
-    SEC_ABOUT_BLANK_INHERITS = 512U,
-    SEC_ALLOW_CHROME = 1024U,
-    SEC_DISALLOW_SCRIPT = 2048U,
-    SEC_DONT_FOLLOW_REDIRECTS = 4096U,
-    SEC_LOAD_ERROR_PAGE = 8192U,
-    SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER = 16384U
-  };
-
-
-  virtual nsresult GetLoadingPrincipal(nsIPrincipal * *aLoadingPrincipal) = 0;
-
-
-  virtual nsIPrincipal * LoadingPrincipal(void) = 0;
-
-
-  virtual nsresult GetTriggeringPrincipal(nsIPrincipal * *aTriggeringPrincipal) = 0;
-
-
-  virtual nsIPrincipal * TriggeringPrincipal(void) = 0;
-
-
-  virtual nsresult GetPrincipalToInherit(nsIPrincipal * *aPrincipalToInherit) = 0;
-  virtual nsresult SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit) = 0;
-
-
-  virtual nsIPrincipal * PrincipalToInherit(void) = 0;
-
-
-  virtual nsresult GetLoadingDocument(nsIDOMDocument * *aLoadingDocument) = 0;
-
-
-  virtual nsINode * LoadingNode(void) = 0;
-
-
-  virtual nsresult GetSecurityFlags(nsSecurityFlags *aSecurityFlags) = 0;
-
-   inline nsSecurityFlags GetSecurityFlags()
-  {
-    nsSecurityFlags result;
-    mozilla::DebugOnly<nsresult> rv = GetSecurityFlags(&result);
-    do { } while (0);
-    return result;
-  }
-
-  virtual nsresult GetSecurityMode(uint32_t *aSecurityMode) = 0;
-  inline uint32_t GetSecurityMode()
-  {
-    uint32_t result;
-    mozilla::DebugOnly<nsresult> rv = GetSecurityMode(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsInThirdPartyContext(bool *aIsInThirdPartyContext) = 0;
-  inline bool GetIsInThirdPartyContext()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsInThirdPartyContext(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetCookiePolicy(uint32_t *aCookiePolicy) = 0;
-  inline uint32_t GetCookiePolicy()
-  {
-    uint32_t result;
-    mozilla::DebugOnly<nsresult> rv = GetCookiePolicy(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetForceInheritPrincipal(bool *aForceInheritPrincipal) = 0;
-  inline bool GetForceInheritPrincipal()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipal(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner) = 0;
-  inline bool GetForceInheritPrincipalOverruleOwner()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalOverruleOwner(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetLoadingSandboxed(bool *aLoadingSandboxed) = 0;
-  inline bool GetLoadingSandboxed()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetLoadingSandboxed(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetAboutBlankInherits(bool *aAboutBlankInherits) = 0;
-  inline bool GetAboutBlankInherits()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetAboutBlankInherits(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetAllowChrome(bool *aAllowChrome) = 0;
-  inline bool GetAllowChrome()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetAllowChrome(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetDisallowScript(bool *aDisallowScript) = 0;
-  inline bool GetDisallowScript()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetDisallowScript(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetDontFollowRedirects(bool *aDontFollowRedirects) = 0;
-  inline bool GetDontFollowRedirects()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetDontFollowRedirects(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetLoadErrorPage(bool *aLoadErrorPage) = 0;
-  inline bool GetLoadErrorPage()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetLoadErrorPage(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType) = 0;
-
-   inline nsContentPolicyType GetExternalContentPolicyType()
-  {
-    nsContentPolicyType result;
-    mozilla::DebugOnly<nsresult> rv = GetExternalContentPolicyType(&result);
-    do { } while (0);
-    return result;
-  }
-
-  virtual nsContentPolicyType InternalContentPolicyType(void) = 0;
-
-
-  virtual nsresult GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests) = 0;
-  inline bool GetUpgradeInsecureRequests()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetUpgradeInsecureRequests(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetVerifySignedContent(bool *aVerifySignedContent) = 0;
-  inline bool GetVerifySignedContent()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetVerifySignedContent(&result);
-    do { } while (0);
-    return result;
-  }
-  virtual nsresult SetVerifySignedContent(bool aVerifySignedContent) = 0;
-
-
-  virtual nsresult GetEnforceSRI(bool *aEnforceSRI) = 0;
-  inline bool GetEnforceSRI()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetEnforceSRI(&result);
-    do { } while (0);
-    return result;
-  }
-  virtual nsresult SetEnforceSRI(bool aEnforceSRI) = 0;
-
-
-  virtual nsresult GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped) = 0;
-  inline bool GetForceInheritPrincipalDropped()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalDropped(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetInnerWindowID(uint64_t *aInnerWindowID) = 0;
-  inline uint64_t GetInnerWindowID()
-  {
-    uint64_t result;
-    mozilla::DebugOnly<nsresult> rv = GetInnerWindowID(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetOuterWindowID(uint64_t *aOuterWindowID) = 0;
-  inline uint64_t GetOuterWindowID()
-  {
-    uint64_t result;
-    mozilla::DebugOnly<nsresult> rv = GetOuterWindowID(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetParentOuterWindowID(uint64_t *aParentOuterWindowID) = 0;
-  inline uint64_t GetParentOuterWindowID()
-  {
-    uint64_t result;
-    mozilla::DebugOnly<nsresult> rv = GetParentOuterWindowID(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetFrameOuterWindowID(uint64_t *aFrameOuterWindowID) = 0;
-  inline uint64_t GetFrameOuterWindowID()
-  {
-    uint64_t result;
-    mozilla::DebugOnly<nsresult> rv = GetFrameOuterWindowID(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult ResetPrincipalToInheritToNullPrincipal(void) = 0;
-
-
-  virtual nsresult GetScriptableOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) = 0;
-  virtual nsresult SetScriptableOriginAttributes(JSContext* cx, JS::HandleValue aOriginAttributes) = 0;
-
-
-  virtual nsresult GetOriginAttributes(mozilla::OriginAttributes *_retval) = 0;
-
-
-  virtual nsresult SetOriginAttributes(const mozilla::OriginAttributes & aOriginAttrs) = 0;
-
-   inline mozilla::OriginAttributes GetOriginAttributes()
-  {
-    mozilla::OriginAttributes result;
-    mozilla::DebugOnly<nsresult> rv = GetOriginAttributes(&result);
-    do { } while (0);
-    return result;
-  }
-
-  virtual nsresult GetEnforceSecurity(bool *aEnforceSecurity) = 0;
-  inline bool GetEnforceSecurity()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetEnforceSecurity(&result);
-    do { } while (0);
-    return result;
-  }
-  virtual nsresult SetEnforceSecurity(bool aEnforceSecurity) = 0;
-
-
-  virtual nsresult GetInitialSecurityCheckDone(bool *aInitialSecurityCheckDone) = 0;
-  inline bool GetInitialSecurityCheckDone()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetInitialSecurityCheckDone(&result);
-    do { } while (0);
-    return result;
-  }
-  virtual nsresult SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) = 0;
-
-
-  virtual nsresult AppendRedirectedPrincipal(nsIPrincipal *principal, bool isInternalRedirect) = 0;
-
-
-  virtual nsresult GetRedirectChainIncludingInternalRedirects(JSContext* cx, JS::MutableHandleValue aRedirectChainIncludingInternalRedirects) = 0;
-
-
-  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & RedirectChainIncludingInternalRedirects(void) = 0;
-
-
-  virtual nsresult GetRedirectChain(JSContext* cx, JS::MutableHandleValue aRedirectChain) = 0;
-
-
-  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & RedirectChain(void) = 0;
-
-
-  virtual void SetCorsPreflightInfo(const nsTArray<nsCString> & unsafeHeaders, bool forcePreflight) = 0;
-
-
-  virtual const nsTArray<nsCString> & CorsUnsafeHeaders(void) = 0;
-
-
-  virtual nsresult GetForcePreflight(bool *aForcePreflight) = 0;
-  inline bool GetForcePreflight()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetForcePreflight(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsPreflight(bool *aIsPreflight) = 0;
-  inline bool GetIsPreflight()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsPreflight(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetForceHSTSPriming(bool *aForceHSTSPriming) = 0;
-  inline bool GetForceHSTSPriming()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetForceHSTSPriming(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetMixedContentWouldBlock(bool *aMixedContentWouldBlock) = 0;
-  inline bool GetMixedContentWouldBlock()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetMixedContentWouldBlock(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual void SetHSTSPriming(bool mixeContentWouldBlock) = 0;
-
-
-  virtual void ClearHSTSPriming(void) = 0;
-
-  enum {
-    TAINTING_BASIC = 0U,
-    TAINTING_CORS = 1U,
-    TAINTING_OPAQUE = 2U
-  };
-
-
-  virtual nsresult GetTainting(uint32_t *aTainting) = 0;
-
-
-  virtual nsresult MaybeIncreaseTainting(uint32_t aTainting) = 0;
-
-   static_assert(TAINTING_BASIC == static_cast<uint32_t>(mozilla::LoadTainting::Basic),
-                "basic tainting enums should match");
-  static_assert(TAINTING_CORS == static_cast<uint32_t>(mozilla::LoadTainting::CORS),
-                "cors tainting enums should match");
-  static_assert(TAINTING_OPAQUE == static_cast<uint32_t>(mozilla::LoadTainting::Opaque),
-                "opaque tainting enums should match");
-  mozilla::LoadTainting GetTainting()
-  {
-    uint32_t tainting = TAINTING_BASIC;
-    do { if ((((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetTainting(&tainting))), 1))))) { } } while (0);
-    return static_cast<mozilla::LoadTainting>(tainting);
-  }
-  void MaybeIncreaseTainting(mozilla::LoadTainting aTainting)
-  {
-    uint32_t tainting = static_cast<uint32_t>(aTainting);
-    do { if ((((bool)(__builtin_expect(!!(!NS_FAILED_impl(MaybeIncreaseTainting(tainting))), 1))))) { } } while (0);
-  }
-
-  virtual nsresult GetIsTopLevelLoad(bool *aIsTopLevelLoad) = 0;
-  inline bool GetIsTopLevelLoad()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsTopLevelLoad(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetSandboxedLoadingPrincipal(nsIPrincipal * *aSandboxedLoadingPrincipal) = 0;
-
-};
-
-  template<typename T> struct nsILoadInfo::COMTypeInfo<nsILoadInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILoadInfo::COMTypeInfo<nsILoadInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xddc65bf9, 0x2f60, 0x41ab, { 0xb2, 0x2a, 0x4f, 0x1a, 0xe9, 0xef, 0xcd, 0x36 }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h" 2
-
-
-
-
-
-
-class nsIURI;
-
-class nsIInterfaceRequestor;
-
-class nsIInputStream;
-
-class nsIStreamListener;
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannel.h"
-class nsIChannel : public nsIRequest {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetOriginalURI(nsIURI * *aOriginalURI) = 0;
-  virtual nsresult SetOriginalURI(nsIURI *aOriginalURI) = 0;
-
-
-  virtual nsresult GetURI(nsIURI * *aURI) = 0;
-
-
-  virtual nsresult GetOwner(nsISupports * *aOwner) = 0;
-  virtual nsresult SetOwner(nsISupports *aOwner) = 0;
-
-
-  virtual nsresult GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) = 0;
-  virtual nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) = 0;
-
-
-  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
-
-
-  virtual nsresult GetContentType(nsACString & aContentType) = 0;
-  virtual nsresult SetContentType(const nsACString & aContentType) = 0;
-
-
-  virtual nsresult GetContentCharset(nsACString & aContentCharset) = 0;
-  virtual nsresult SetContentCharset(const nsACString & aContentCharset) = 0;
-
-
-  virtual nsresult GetContentLength(int64_t *aContentLength) = 0;
-  virtual nsresult SetContentLength(int64_t aContentLength) = 0;
-
-
-  virtual nsresult Open(nsIInputStream * *_retval) = 0;
-
-
-  virtual nsresult Open2(nsIInputStream * *_retval) = 0;
-
-
-  virtual nsresult AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext) = 0;
-
-
-  virtual nsresult AsyncOpen2(nsIStreamListener *aListener) = 0;
-
-  enum {
-    LOAD_DOCUMENT_URI = 65536U,
-    LOAD_RETARGETED_DOCUMENT_URI = 131072U,
-    LOAD_REPLACE = 262144U,
-    LOAD_INITIAL_DOCUMENT_URI = 524288U,
-    LOAD_TARGETED = 1048576U,
-    LOAD_CALL_CONTENT_SNIFFERS = 2097152U,
-    LOAD_CLASSIFY_URI = 4194304U,
-    LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE = 8388608U,
-    LOAD_EXPLICIT_CREDENTIALS = 16777216U,
-    LOAD_BYPASS_SERVICE_WORKER = 33554432U
-  };
-
-
-  virtual nsresult GetContentDisposition(uint32_t *aContentDisposition) = 0;
-  virtual nsresult SetContentDisposition(uint32_t aContentDisposition) = 0;
-
-  enum {
-    DISPOSITION_INLINE = 0U,
-    DISPOSITION_ATTACHMENT = 1U
-  };
-
-
-  virtual nsresult GetContentDispositionFilename(nsAString & aContentDispositionFilename) = 0;
-  virtual nsresult SetContentDispositionFilename(const nsAString & aContentDispositionFilename) = 0;
-
-
-  virtual nsresult GetContentDispositionHeader(nsACString & aContentDispositionHeader) = 0;
-
-
-  virtual nsresult GetLoadInfo(nsILoadInfo * *aLoadInfo) = 0;
-  virtual nsresult SetLoadInfo(nsILoadInfo *aLoadInfo) = 0;
-
-   inline already_AddRefed<nsILoadInfo> GetLoadInfo()
-  {
-    nsCOMPtr<nsILoadInfo> result;
-    mozilla::DebugOnly<nsresult> rv = GetLoadInfo(getter_AddRefs(result));
-    do { } while (0);
-    return result.forget();
-  }
-};
-
-  template<typename T> struct nsIChannel::COMTypeInfo<nsIChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIChannel::COMTypeInfo<nsIChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2c389865, 0x23db, 0x4aa7, { 0x9f, 0xe5, 0x60, 0xcc, 0x7b, 0x00, 0x69, 0x7e }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h" 2
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
-class nsIHttpHeaderVisitor;
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIHttpChannel.h"
-class nsIHttpChannel : public nsIChannel {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestMethod(nsACString & aRequestMethod) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestMethod(const nsACString & aRequestMethod) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetReferrer(nsIURI * *aReferrer) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetReferrer(nsIURI *aReferrer) = 0;
-
-  enum {
-    REFERRER_POLICY_UNSET = 0U,
-    REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE = 1U,
-    REFERRER_POLICY_NO_REFERRER = 2U,
-    REFERRER_POLICY_ORIGIN = 3U,
-    REFERRER_POLICY_ORIGIN_WHEN_XORIGIN = 4U,
-    REFERRER_POLICY_UNSAFE_URL = 5U,
-    REFERRER_POLICY_SAME_ORIGIN = 6U,
-    REFERRER_POLICY_STRICT_ORIGIN = 7U,
-    REFERRER_POLICY_STRICT_ORIGIN_WHEN_XORIGIN = 8U
-  };
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetReferrerPolicy(uint32_t *aReferrerPolicy) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetProtocolVersion(nsACString & aProtocolVersion) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetTransferSize(uint64_t *aTransferSize) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetDecodedBodySize(uint64_t *aDecodedBodySize) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetEncodedBodySize(uint64_t *aEncodedBodySize) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestHeader(const nsACString & aHeader, nsACString & _retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestHeader(const nsACString & aHeader, const nsACString & aValue, bool aMerge) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetEmptyRequestHeader(const nsACString & aHeader) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult VisitRequestHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult VisitNonDefaultRequestHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetAllowPipelining(bool *aAllowPipelining) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetAllowPipelining(bool aAllowPipelining) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetAllowSTS(bool *aAllowSTS) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetAllowSTS(bool aAllowSTS) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRedirectionLimit(uint32_t *aRedirectionLimit) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRedirectionLimit(uint32_t aRedirectionLimit) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseStatus(uint32_t *aResponseStatus) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseStatusText(nsACString & aResponseStatusText) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestSucceeded(bool *aRequestSucceeded) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetIsMainDocumentChannel(bool *aIsMainDocumentChannel) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetIsMainDocumentChannel(bool aIsMainDocumentChannel) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResponseHeader(const nsACString & header, nsACString & _retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetResponseHeader(const nsACString & header, const nsACString & value, bool merge) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult VisitResponseHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetOriginalResponseHeader(const nsACString & aHeader, nsIHttpHeaderVisitor *aVisitor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult VisitOriginalResponseHeaders(nsIHttpHeaderVisitor *aVisitor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult IsNoStoreResponse(bool *_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult IsNoCacheResponse(bool *_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult IsPrivateResponse(bool *_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult RedirectTo(nsIURI *aTargetURI) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRequestContextID(uint64_t *aRequestContextID) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRequestContextID(uint64_t aRequestContextID) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetChannelId(uint64_t *aChannelId) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetChannelId(uint64_t aChannelId) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetTopLevelContentWindowId(uint64_t *aTopLevelContentWindowId) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetTopLevelContentWindowId(uint64_t aTopLevelContentWindowId) = 0;
-
-
-  virtual nsresult GetIsTrackingResource(bool *aIsTrackingResource) = 0;
-  inline bool GetIsTrackingResource()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsTrackingResource(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetTopLevelOuterContentWindowId(uint64_t *aTopLevelOuterContentWindowId) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetTopLevelOuterContentWindowId(uint64_t aTopLevelOuterContentWindowId) = 0;
-
-};
-
-  template<typename T> struct nsIHttpChannel::COMTypeInfo<nsIHttpChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIHttpChannel::COMTypeInfo<nsIHttpChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xc5a4a073, 0x4539, 0x49c7, { 0xa3, 0xf2, 0xce, 0xc3, 0xf0, 0x61, 0x9c, 0x6c }};
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/net/ReferrerPolicy.h" 2
-
-
-namespace mozilla { namespace net {
-
-enum ReferrerPolicy {
-
-  RP_No_Referrer = nsIHttpChannel::REFERRER_POLICY_NO_REFERRER,
-
-
-  RP_Origin = nsIHttpChannel::REFERRER_POLICY_ORIGIN,
-
-
-  RP_No_Referrer_When_Downgrade = nsIHttpChannel::REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE,
-
-
-  RP_Origin_When_Crossorigin = nsIHttpChannel::REFERRER_POLICY_ORIGIN_WHEN_XORIGIN,
-
-
-  RP_Unsafe_URL = nsIHttpChannel::REFERRER_POLICY_UNSAFE_URL,
-
-
-  RP_Same_Origin = nsIHttpChannel::REFERRER_POLICY_SAME_ORIGIN,
-
-
-  RP_Strict_Origin = nsIHttpChannel::REFERRER_POLICY_STRICT_ORIGIN,
-
-
-  RP_Strict_Origin_When_Cross_Origin = nsIHttpChannel::REFERRER_POLICY_STRICT_ORIGIN_WHEN_XORIGIN,
-
-
-
-  RP_Unset = nsIHttpChannel::REFERRER_POLICY_UNSET,
-};
-
-
-const char kRPS_Never[] = "never";
-const char kRPS_No_Referrer[] = "no-referrer";
-
-
-const char kRPS_Origin[] = "origin";
-
-
-const char kRPS_Default[] = "default";
-const char kRPS_No_Referrer_When_Downgrade[] = "no-referrer-when-downgrade";
-
-
-const char kRPS_Origin_When_Cross_Origin[] = "origin-when-cross-origin";
-const char kRPS_Origin_When_Crossorigin[] = "origin-when-crossorigin";
-
-
-const char kRPS_Same_Origin[] = "same-origin";
-
-
-const char kRPS_Strict_Origin[] = "strict-origin";
-
-
-const char kRPS_Strict_Origin_When_Cross_Origin[] = "strict-origin-when-cross-origin";
-
-
-const char kRPS_Always[] = "always";
-const char kRPS_Unsafe_URL[] = "unsafe-url";
-
-inline ReferrerPolicy
-ReferrerPolicyFromString(const nsAString& content)
-{
-  if (content.IsEmpty()) {
-    return RP_No_Referrer;
-  }
-
-  nsString lowerContent(content);
-  ToLowerCase(lowerContent);
-
-
-  if (lowerContent.EqualsLiteral(kRPS_Never) ||
-      lowerContent.EqualsLiteral(kRPS_No_Referrer)) {
-    return RP_No_Referrer;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Origin)) {
-    return RP_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Default) ||
-      lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)) {
-    return RP_No_Referrer_When_Downgrade;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin) ||
-      lowerContent.EqualsLiteral(kRPS_Origin_When_Crossorigin)) {
-    return RP_Origin_When_Crossorigin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Same_Origin)) {
-    return RP_Same_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin)) {
-    return RP_Strict_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)) {
-    return RP_Strict_Origin_When_Cross_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Always) ||
-      lowerContent.EqualsLiteral(kRPS_Unsafe_URL)) {
-    return RP_Unsafe_URL;
-  }
-
-  return RP_Unset;
-
-}
-
-inline bool
-IsValidReferrerPolicy(const nsAString& content)
-{
-  if (content.IsEmpty()) {
-    return true;
-  }
-
-  nsString lowerContent(content);
-  ToLowerCase(lowerContent);
-
-  return lowerContent.EqualsLiteral(kRPS_Never)
-      || lowerContent.EqualsLiteral(kRPS_No_Referrer)
-      || lowerContent.EqualsLiteral(kRPS_Origin)
-      || lowerContent.EqualsLiteral(kRPS_Default)
-      || lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)
-      || lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin)
-      || lowerContent.EqualsLiteral(kRPS_Origin_When_Crossorigin)
-      || lowerContent.EqualsLiteral(kRPS_Same_Origin)
-      || lowerContent.EqualsLiteral(kRPS_Strict_Origin)
-      || lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)
-      || lowerContent.EqualsLiteral(kRPS_Always)
-      || lowerContent.EqualsLiteral(kRPS_Unsafe_URL);
-}
-
-inline ReferrerPolicy
-AttributeReferrerPolicyFromString(const nsAString& content)
-{
-
-
-  if (content.IsEmpty()) {
-    return RP_Unset;
-  }
-
-  nsString lowerContent(content);
-  ToLowerCase(lowerContent);
-
-  if (lowerContent.EqualsLiteral(kRPS_No_Referrer)) {
-    return RP_No_Referrer;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Origin)) {
-    return RP_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_No_Referrer_When_Downgrade)) {
-    return RP_No_Referrer_When_Downgrade;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Origin_When_Cross_Origin)) {
-    return RP_Origin_When_Crossorigin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Unsafe_URL)) {
-    return RP_Unsafe_URL;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin)) {
-    return RP_Strict_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Same_Origin)) {
-    return RP_Same_Origin;
-  }
-  if (lowerContent.EqualsLiteral(kRPS_Strict_Origin_When_Cross_Origin)) {
-    return RP_Strict_Origin_When_Cross_Origin;
-  }
-
-
-
-  return RP_Unset;
-}
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CORSMode.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CORSMode.h"
-namespace mozilla {
-
-enum CORSMode : uint8_t {
-
-
-
-  CORS_NONE,
-
-
-
-
-
-  CORS_ANONYMOUS,
-
-
-
-
-
-  CORS_USE_CREDENTIALS
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoUtils.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h" 2
-
-
-
-
-
-class nsICSSLoaderObserver : public nsISupports {
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICSSLoaderObserver.h"
-  virtual nsresult StyleSheetLoaded(mozilla::StyleSheet* aSheet,
-                              bool aWasAlternate,
-                              nsresult aStatus) = 0;
-};
-
-template<typename T> struct nsICSSLoaderObserver::COMTypeInfo<nsICSSLoaderObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsICSSLoaderObserver::COMTypeInfo<nsICSSLoaderObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xf51fbf2c, 0xfe4b, 0x4a15, { 0xaf, 0x7e, 0x5e, 0x20, 0x64, 0x5f, 0xaf, 0x58 } };
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMStyleSheet.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMStyleSheet.h"
-class nsIDOMStyleSheet : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetType(nsAString & aType) = 0;
-
-
-  virtual nsresult GetDisabled(bool *aDisabled) = 0;
-  virtual nsresult SetDisabled(bool aDisabled) = 0;
-
-
-  virtual nsresult GetOwnerNode(nsIDOMNode * *aOwnerNode) = 0;
-
-
-  virtual nsresult GetParentStyleSheet(nsIDOMStyleSheet * *aParentStyleSheet) = 0;
-
-
-  virtual nsresult GetHref(nsAString & aHref) = 0;
-
-
-  virtual nsresult GetTitle(nsAString & aTitle) = 0;
-
-
-  virtual nsresult GetMedia(nsIDOMMediaList * *aMedia) = 0;
-
-};
-
-  template<typename T> struct nsIDOMStyleSheet::COMTypeInfo<nsIDOMStyleSheet, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMStyleSheet::COMTypeInfo<nsIDOMStyleSheet, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa6cf9080, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMCSSStyleSheet.h"
-class nsIDOMCSSStyleSheet : public nsIDOMStyleSheet {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetOwnerRule(nsIDOMCSSRule * *aOwnerRule) = 0;
-
-
-  virtual nsresult GetCssRules(nsIDOMCSSRuleList * *aCssRules) = 0;
-
-
-  virtual nsresult InsertRule(const nsAString & rule, uint32_t index, uint32_t *_retval) = 0;
-
-
-  virtual nsresult DeleteRule(uint32_t index) = 0;
-
-};
-
-  template<typename T> struct nsIDOMCSSStyleSheet::COMTypeInfo<nsIDOMCSSStyleSheet, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMCSSStyleSheet::COMTypeInfo<nsIDOMCSSStyleSheet, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa6cf90c2, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h" 2
-
-
-class nsIDocument;
-class nsINode;
-class nsIPrincipal;
-class nsCSSRuleProcessor;
-
-namespace mozilla {
-
-class CSSStyleSheet;
-class ServoStyleSheet;
-struct StyleSheetInfo;
-struct CSSStyleSheetInner;
-
-namespace dom {
-class CSSRuleList;
-class MediaList;
-class SRIMetadata;
-}
-
-namespace css {
-class GroupRule;
-class ImportRule;
-class Rule;
-}
-
-
-
-
-class StyleSheet : public nsIDOMCSSStyleSheet
-                 , public nsICSSLoaderObserver
-                 , public nsWrapperCache
-{
-protected:
-  StyleSheet(StyleBackendType aType, css::SheetParsingMode aParsingMode);
-  StyleSheet(const StyleSheet& aCopy,
-             nsIDocument* aDocumentToUse,
-             nsINode* aOwningNodeToUse);
-  virtual ~StyleSheet();
-
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "StyleSheet"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<StyleSheet>(p)->DeleteCycleCollectable(); } static StyleSheet* Downcast(nsISupports* s) { return static_cast<StyleSheet*>(static_cast<nsIDOMCSSStyleSheet*>(s)); } static nsISupports* Upcast(StyleSheet *p) { return static_cast<nsISupports*>(static_cast<nsIDOMCSSStyleSheet*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &StyleSheet::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  void SetOwningNode(nsINode* aOwningNode)
-  {
-    mOwningNode = aOwningNode;
-  }
-
-  css::SheetParsingMode ParsingMode() { return mParsingMode; }
-  mozilla::dom::CSSStyleSheetParsingMode ParsingModeDOM();
-
-
-
-
-  bool IsComplete() const;
-  void SetComplete();
-# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
-  void SetEnabled(bool aEnabled);
-
-  bool IsGecko() const { return !IsServo(); } bool IsServo() const { return mType == StyleBackendType::Servo; } inline CSSStyleSheet* AsGecko(); inline ServoStyleSheet* AsServo(); inline const CSSStyleSheet* AsGecko() const; inline const ServoStyleSheet* AsServo() const; inline CSSStyleSheet* GetAsGecko(); inline ServoStyleSheet* GetAsServo(); inline const CSSStyleSheet* GetAsGecko() const; inline const ServoStyleSheet* GetAsServo() const;
-
-
-  inline bool IsInline() const;
-
-  inline nsIURI* GetSheetURI() const;
-
-
-  inline nsIURI* GetOriginalURI() const;
-  inline nsIURI* GetBaseURI() const;
-
-
-
-
-
-  inline void SetURIs(nsIURI* aSheetURI, nsIURI* aOriginalSheetURI,
-                      nsIURI* aBaseURI);
-
-
-
-
-
-
-
-  inline bool IsApplicable() const;
-  inline bool HasRules() const;
-
-  virtual already_AddRefed<StyleSheet> Clone(StyleSheet* aCloneParent,
-                                             css::ImportRule* aCloneOwnerRule,
-                                             nsIDocument* aCloneDocument,
-                                             nsINode* aCloneOwningNode) const = 0;
-
-  virtual bool IsModified() const = 0;
-
-
-  enum DocumentAssociationMode {
-
-
-    OwnedByDocument,
-
-
-    NotOwnedByDocument
-  };
-  nsIDocument* GetAssociatedDocument() const { return mDocument; }
-  bool IsOwnedByDocument() const {
-    return mDocumentAssociationMode == OwnedByDocument;
-  }
-
-  void SetAssociatedDocument(nsIDocument* aDocument,
-                             DocumentAssociationMode aMode);
-  void ClearAssociatedDocument();
-  nsINode* GetOwnerNode() const { return mOwningNode; }
-  inline StyleSheet* GetParentSheet() const { return mParent; }
-
-  void AppendStyleSheet(StyleSheet* aSheet);
-
-  StyleSheet* GetFirstChild() const;
-
-
-  inline nsIPrincipal* Principal() const;
-
-
-
-
-
-  inline void SetPrincipal(nsIPrincipal* aPrincipal);
-
-  void SetTitle(const nsAString& aTitle) { mTitle = aTitle; }
-  void SetMedia(dom::MediaList* aMedia);
-
-
-  inline CORSMode GetCORSMode() const;
-
-  inline net::ReferrerPolicy GetReferrerPolicy() const;
-
-  inline void GetIntegrity(dom::SRIMetadata& aResult) const;
-
-  virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSheet.h"
-  inline StyleSheet* GetParentStyleSheet() const;
-
-  dom::MediaList* Media();
-  bool Disabled() const { return mDisabled; }
-
-
-
-  virtual css::Rule* GetDOMOwnerRule() const = 0;
-  dom::CSSRuleList* GetCssRules(nsIPrincipal& aSubjectPrincipal,
-                                ErrorResult& aRv);
-  uint32_t InsertRule(const nsAString& aRule, uint32_t aIndex,
-                      nsIPrincipal& aSubjectPrincipal,
-                      ErrorResult& aRv);
-  void DeleteRule(uint32_t aIndex,
-                  nsIPrincipal& aSubjectPrincipal,
-                  ErrorResult& aRv);
-
-
-  inline dom::ParentObject GetParentObject() const;
-  JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
-
-
-  virtual nsresult GetType(nsAString& aType) final;
-  virtual nsresult GetDisabled(bool* aDisabled) final;
-  virtual nsresult SetDisabled(bool aDisabled) final;
-  virtual nsresult GetOwnerNode(nsIDOMNode** aOwnerNode) final;
-  virtual nsresult GetParentStyleSheet(nsIDOMStyleSheet** aParentStyleSheet) final;
-  virtual nsresult GetHref(nsAString& aHref) final;
-  virtual nsresult GetTitle(nsAString& aTitle) final;
-  virtual nsresult GetMedia(nsIDOMMediaList** aMedia) final;
-
-
-  virtual nsresult GetOwnerRule(nsIDOMCSSRule** aOwnerRule) final;
-  virtual nsresult GetCssRules(nsIDOMCSSRuleList** aCssRules) final;
-  virtual nsresult InsertRule(const nsAString& aRule, uint32_t aIndex,
-                      uint32_t* aReturn) final;
-  virtual nsresult DeleteRule(uint32_t aIndex) final;
-
-
-
-
-  inline void WillDirty();
-  inline void DidDirty();
-
-  nsresult DeleteRuleFromGroup(css::GroupRule* aGroup, uint32_t aIndex);
-  nsresult InsertRuleIntoGroup(const nsAString& aRule,
-                               css::GroupRule* aGroup, uint32_t aIndex);
-
-private:
-
-
-  inline StyleSheetInfo& SheetInfo();
-  inline const StyleSheetInfo& SheetInfo() const;
-
-
-
-
-
-  bool AreRulesAvailable(nsIPrincipal& aSubjectPrincipal,
-                         ErrorResult& aRv);
-
-protected:
-  struct ChildSheetListBuilder {
-    RefPtr<StyleSheet>* sheetSlot;
-    StyleSheet* parent;
-
-    void SetParentLinks(StyleSheet* aSheet);
-
-    static void ReparentChildList(StyleSheet* aPrimarySheet,
-                                  StyleSheet* aFirstChild);
-  };
-
-  void UnparentChildren();
-
-
-
-
-
-  void SubjectSubsumesInnerPrincipal(nsIPrincipal& aSubjectPrincipal,
-                                     ErrorResult& aRv);
-
-
-  void DropMedia();
-
-
-  void EnabledStateChanged();
-
-
-  virtual void UnlinkInner();
-
-  virtual void TraverseInner(nsCycleCollectionTraversalCallback &);
-
-  StyleSheet* mParent;
-
-  nsString mTitle;
-  nsIDocument* mDocument;
-  nsINode* mOwningNode;
-
-  RefPtr<dom::MediaList> mMedia;
-
-  RefPtr<StyleSheet> mNext;
-
-
-
-
-  css::SheetParsingMode mParsingMode;
-
-  const StyleBackendType mType;
-  bool mDisabled;
-
-
-
-
-  DocumentAssociationMode mDocumentAssociationMode;
-
-
-
-  StyleSheetInfo* mInner;
-
-  friend class ::nsCSSRuleProcessor;
-
-
-
-
-  friend class mozilla::CSSStyleSheet;
-  friend class mozilla::ServoStyleSheet;
-
-
-
-  friend struct mozilla::StyleSheetInfo;
-  friend struct mozilla::CSSStyleSheetInner;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSEnabledState.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSEnabledState.h"
-namespace mozilla {
-
-enum class CSSEnabledState
-{
-
-
-  eForAllContent = 0,
-
-  eInUASheets = 0x01,
-
-  eInChrome = 0x02,
-
-
-
-
-  eIgnoreEnabledState = 0xff
-};
-
-inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator |(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) | U(b))); } inline CSSEnabledState& operator |=(CSSEnabledState& a, CSSEnabledState b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator &(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) & U(b))); } inline CSSEnabledState& operator &=(CSSEnabledState& a, CSSEnabledState b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator ^(CSSEnabledState a, CSSEnabledState b) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(U(a) ^ U(b))); } inline CSSEnabledState& operator ^=(CSSEnabledState& a, CSSEnabledState b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<CSSEnabledState> operator~(CSSEnabledState a) { typedef mozilla::CastableTypedEnumResult<CSSEnabledState> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<CSSEnabledState>::Type U; return Result(CSSEnabledState(~(U(a)))); }
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
-namespace mozilla {
-
-
-
-typedef uint8_t CSSPseudoElementTypeBase;
-enum class CSSPseudoElementType : CSSPseudoElementTypeBase {
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h" 1
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h"
-after,
-before,
-
-backdrop,
-
-cue,
-
-
-firstLetter,
-
-
-firstLine,
-
-
-
-mozSelection,
-
-
-
-
-mozFocusInner,
-mozFocusOuter,
-
-
-
-mozListBullet,
-mozListNumber,
-
-mozMathAnonymous,
-
-
-mozNumberWrapper,
-
-
-mozNumberText,
-
-
-mozNumberSpinBox,
-
-
-mozNumberSpinUp,
-
-
-mozNumberSpinDown,
-
-
-mozProgressBar,
-
-mozRangeTrack,
-
-mozRangeProgress,
-
-mozRangeThumb,
-
-mozMeterBar,
-
-mozPlaceholder,
-
-placeholder,
-
-mozColorSwatch,
-# 55 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
-
-  Count,
-  InheritingAnonBox = Count,
-
-  NonInheritingAnonBox,
-
-  XULTree,
-
-  NotPseudo,
-  MAX
-};
-
-}
-
-
-
-class nsICSSPseudoElement : public nsIAtom {};
-
-class nsCSSPseudoElements
-{
-  typedef mozilla::CSSPseudoElementType Type;
-  typedef mozilla::CSSEnabledState EnabledState;
-
-public:
-  static void AddRefAtoms();
-
-  static bool IsPseudoElement(nsIAtom *aAtom);
-
-  static bool IsCSS2PseudoElement(nsIAtom *aAtom);
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h" 1
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElementList.h"
-static nsICSSPseudoElement* after;
-static nsICSSPseudoElement* before;
-
-static nsICSSPseudoElement* backdrop;
-
-static nsICSSPseudoElement* cue;
-
-
-static nsICSSPseudoElement* firstLetter;
-
-
-static nsICSSPseudoElement* firstLine;
-
-
-
-static nsICSSPseudoElement* mozSelection;
-
-
-
-
-static nsICSSPseudoElement* mozFocusInner;
-static nsICSSPseudoElement* mozFocusOuter;
-
-
-
-static nsICSSPseudoElement* mozListBullet;
-static nsICSSPseudoElement* mozListNumber;
-
-static nsICSSPseudoElement* mozMathAnonymous;
-
-
-static nsICSSPseudoElement* mozNumberWrapper;
-
-
-static nsICSSPseudoElement* mozNumberText;
-
-
-static nsICSSPseudoElement* mozNumberSpinBox;
-
-
-static nsICSSPseudoElement* mozNumberSpinUp;
-
-
-static nsICSSPseudoElement* mozNumberSpinDown;
-
-
-static nsICSSPseudoElement* mozProgressBar;
-
-static nsICSSPseudoElement* mozRangeTrack;
-
-static nsICSSPseudoElement* mozRangeProgress;
-
-static nsICSSPseudoElement* mozRangeThumb;
-
-static nsICSSPseudoElement* mozMeterBar;
-
-static nsICSSPseudoElement* mozPlaceholder;
-
-static nsICSSPseudoElement* placeholder;
-
-static nsICSSPseudoElement* mozColorSwatch;
-# 88 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h" 2
-
-
-  static Type GetPseudoType(nsIAtom* aAtom, EnabledState aEnabledState);
-
-
-  static nsIAtom* GetPseudoAtom(Type aType);
-
-  static bool PseudoElementContainsElements(const Type aType) {
-    return PseudoElementHasFlags(aType, (1<<1));
-  }
-
-  static bool PseudoElementSupportsStyleAttribute(const Type aType) {
-    do { } while (0);
-    return PseudoElementHasFlags(aType,
-                                 (1<<2));
-  }
-
-  static bool PseudoElementSupportsUserActionState(const Type aType);
-
-  static bool PseudoElementIsJSCreatedNAC(Type aType)
-  {
-    return PseudoElementHasFlags(aType, (1<<5));
-  }
-
-  static bool IsEnabled(Type aType, EnabledState aEnabledState)
-  {
-    return !PseudoElementHasFlags(aType, (1<<4)) ||
-           (aEnabledState & EnabledState::eInUASheets);
-  }
-
-private:
-# 130 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoElements.h"
-  static bool PseudoElementHasFlags(const Type aType, uint32_t aFlags)
-  {
-    do { } while (0);
-    return (kPseudoElementFlags[size_t(aType)] & aFlags) == aFlags;
-  }
-
-  static const uint32_t kPseudoElementFlags[size_t(Type::Count)];
-};
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleSetHandle.h" 2
-
-
-namespace mozilla {
-class CSSStyleSheet;
-class ServoStyleSet;
-namespace dom {
-class Element;
-}
-}
-struct nsFontFaceRuleContainer;
-class nsIAtom;
-class nsIContent;
-class nsIDocument;
-class nsStyleContext;
-class nsStyleSet;
-class nsPresContext;
-struct TreeMatchContext;
-
-namespace mozilla {
-
-
-
-
-
-
-
-class StyleSetHandle
-{
-public:
-
-
-
-
-  class Ptr
-  {
-  public:
-    friend class ::mozilla::StyleSetHandle;
-
-    bool IsGecko() const { return !IsServo(); }
-    bool IsServo() const
-    {
-      do { } while (0);
-
-      return mValue & 0x1;
-
-
-
-    }
-
-    StyleBackendType BackendType() const
-    {
-      return IsGecko() ? StyleBackendType::Gecko :
-                         StyleBackendType::Servo;
-    }
-
-    nsStyleSet* AsGecko()
-    {
-      do { } while (0);
-      return reinterpret_cast<nsStyleSet*>(mValue);
-    }
-
-    ServoStyleSet* AsServo()
-    {
-      do { } while (0);
-      return reinterpret_cast<ServoStyleSet*>(mValue & ~0x1);
-    }
-
-    nsStyleSet* GetAsGecko() { return IsGecko() ? AsGecko() : nullptr; }
-    ServoStyleSet* GetAsServo() { return IsServo() ? AsServo() : nullptr; }
-
-    const nsStyleSet* AsGecko() const
-    {
-      return const_cast<Ptr*>(this)->AsGecko();
-    }
-
-    const ServoStyleSet* AsServo() const
-    {
-      do { } while (0);
-      return const_cast<Ptr*>(this)->AsServo();
-    }
-
-    const nsStyleSet* GetAsGecko() const { return IsGecko() ? AsGecko() : nullptr; }
-    const ServoStyleSet* GetAsServo() const { return IsServo() ? AsServo() : nullptr; }
-
-
-    inline void Delete();
-
-
-
-
-
-
-    inline void Init(nsPresContext* aPresContext);
-    inline void BeginShutdown();
-    inline void Shutdown();
-    inline bool GetAuthorStyleDisabled() const;
-    inline nsresult SetAuthorStyleDisabled(bool aStyleDisabled);
-    inline void BeginUpdate();
-    inline nsresult EndUpdate();
-    inline already_AddRefed<nsStyleContext>
-    ResolveStyleFor(dom::Element* aElement,
-                    nsStyleContext* aParentContext,
-                    LazyComputeBehavior aMayCompute);
-    inline already_AddRefed<nsStyleContext>
-    ResolveStyleFor(dom::Element* aElement,
-                    nsStyleContext* aParentContext,
-                    LazyComputeBehavior aMayCompute,
-                    TreeMatchContext& aTreeMatchContext);
-    inline already_AddRefed<nsStyleContext>
-    ResolveStyleForText(nsIContent* aTextNode,
-                        nsStyleContext* aParentContext);
-    inline already_AddRefed<nsStyleContext>
-    ResolveStyleForFirstLetterContinuation(nsStyleContext* aParentContext);
-    inline already_AddRefed<nsStyleContext>
-    ResolveStyleForPlaceholder();
-    inline already_AddRefed<nsStyleContext>
-    ResolvePseudoElementStyle(dom::Element* aParentElement,
-                              mozilla::CSSPseudoElementType aType,
-                              nsStyleContext* aParentContext,
-                              dom::Element* aPseudoElement);
-    inline already_AddRefed<nsStyleContext>
-    ResolveInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag,
-                                       nsStyleContext* aParentContext,
-                                       uint32_t aFlags = 0);
-    inline already_AddRefed<nsStyleContext>
-    ResolveNonInheritingAnonymousBoxStyle(nsIAtom* aPseudoTag);
-    inline nsresult AppendStyleSheet(SheetType aType, StyleSheet* aSheet);
-    inline nsresult PrependStyleSheet(SheetType aType, StyleSheet* aSheet);
-    inline nsresult RemoveStyleSheet(SheetType aType, StyleSheet* aSheet);
-    inline nsresult ReplaceSheets(SheetType aType,
-                           const nsTArray<RefPtr<StyleSheet>>& aNewSheets);
-    inline nsresult InsertStyleSheetBefore(SheetType aType,
-                                    StyleSheet* aNewSheet,
-                                    StyleSheet* aReferenceSheet);
-    inline int32_t SheetCount(SheetType aType) const;
-    inline StyleSheet* StyleSheetAt(SheetType aType, int32_t aIndex) const;
-    inline nsresult RemoveDocStyleSheet(StyleSheet* aSheet);
-    inline nsresult AddDocStyleSheet(StyleSheet* aSheet, nsIDocument* aDocument);
-    inline already_AddRefed<nsStyleContext>
-    ProbePseudoElementStyle(dom::Element* aParentElement,
-                            mozilla::CSSPseudoElementType aType,
-                            nsStyleContext* aParentContext);
-    inline already_AddRefed<nsStyleContext>
-    ProbePseudoElementStyle(dom::Element* aParentElement,
-                            mozilla::CSSPseudoElementType aType,
-                            nsStyleContext* aParentContext,
-                            TreeMatchContext& aTreeMatchContext,
-                            dom::Element* aPseudoElement = nullptr);
-    inline nsRestyleHint HasStateDependentStyle(dom::Element* aElement,
-                                                EventStates aStateMask);
-    inline nsRestyleHint HasStateDependentStyle(
-        dom::Element* aElement,
-        mozilla::CSSPseudoElementType aPseudoType,
-        dom::Element* aPseudoElement,
-        EventStates aStateMask);
-
-    inline void RootStyleContextAdded();
-    inline void RootStyleContextRemoved();
-
-    inline bool AppendFontFaceRules(nsTArray<nsFontFaceRuleContainer>& aArray);
-
-  private:
-
-
-
-
-    uintptr_t mValue;
-  };
-
-  StyleSetHandle() { mPtr.mValue = 0; }
-  StyleSetHandle(const StyleSetHandle& aOth) { mPtr.mValue = aOth.mPtr.mValue; }
-               StyleSetHandle(nsStyleSet* aSet) { *this = aSet; }
-               StyleSetHandle(ServoStyleSet* aSet) { *this = aSet; }
-
-  StyleSetHandle& operator=(nsStyleSet* aStyleSet)
-  {
-    do { } while (0);
-
-    mPtr.mValue = reinterpret_cast<uintptr_t>(aStyleSet);
-    return *this;
-  }
-
-  StyleSetHandle& operator=(ServoStyleSet* aStyleSet)
-  {
-
-    do { } while (0);
-
-    mPtr.mValue =
-      aStyleSet ? (reinterpret_cast<uintptr_t>(aStyleSet) | 0x1) : 0;
-    return *this;
-
-
-
-
-  }
-
-
-  explicit operator bool() const { return !!mPtr.mValue; }
-  bool operator!() const { return !mPtr.mValue; }
-
-
-  Ptr* operator->() { return &mPtr; }
-  const Ptr* operator->() const { return &mPtr; }
-
-private:
-  Ptr mPtr;
-};
-
-
-
-}
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Triangle.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Triangle.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-template<class Units, class F = Float>
-struct TriangleTyped
-{
-  PointTyped<Units, F> p1, p2, p3;
-  F width, height;
-
-  TriangleTyped()
-    : p1(), p2(), p3() {}
-
-  TriangleTyped(PointTyped<Units, F> aP1,
-                PointTyped<Units, F> aP2,
-                PointTyped<Units, F> aP3)
-    : p1(aP1), p2(aP2), p3(aP3) {}
-
-  RectTyped<Units, F> BoundingBox() const
-  {
-    F minX = std::min(std::min(p1.x, p2.x), p3.x);
-    F maxX = std::max(std::max(p1.x, p2.x), p3.x);
-
-    F minY = std::min(std::min(p1.y, p2.y), p3.y);
-    F maxY = std::max(std::max(p1.y, p2.y), p3.y);
-
-    return RectTyped<Units, F>(minX, minY, maxX - minX, maxY - minY);
-  }
-};
-
-typedef TriangleTyped<UnknownUnits, Float> Triangle;
-
-template<class Units, class F = Float>
-struct TexturedTriangleTyped : public TriangleTyped<Units, F>
-{
-  explicit TexturedTriangleTyped(const TriangleTyped<Units, F>& aTriangle)
-    : TriangleTyped<Units, F>(aTriangle) {}
-
-  explicit TexturedTriangleTyped(TriangleTyped<Units, F>&& aTriangle)
-    : TriangleTyped<Units, F>(Move(aTriangle)) {}
-
-  TriangleTyped<Units, F> textureCoords;
-};
-
-typedef TexturedTriangleTyped<UnknownUnits, Float> TexturedTriangle;
-
-}
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/MatrixFwd.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/MatrixFwd.h"
-namespace mozilla {
-namespace gfx {
-
-struct UnknownUnits;
-
-template<class SourceUnits, class TargetUnits>
-class Matrix4x4Typed;
-
-typedef Matrix4x4Typed<UnknownUnits, UnknownUnits> Matrix4x4;
-
-}
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Quaternion.h" 2
-
-
-namespace mozilla {
-namespace gfx {
-
-class Quaternion
-{
-public:
-  Quaternion()
-    : x(0.0f), y(0.0f), z(0.0f), w(1.0f)
-  {}
-
-  Quaternion(Float aX, Float aY, Float aZ, Float aW)
-    : x(aX), y(aY), z(aZ), w(aW)
-  {}
-
-
-  Quaternion(const Quaternion& aOther)
-  {
-    memcpy(this, &aOther, sizeof(*this));
-  }
-
-  Float x, y, z, w;
-
-  friend std::ostream& operator<<(std::ostream& aStream, const Quaternion& aQuat);
-
-  void Set(Float aX, Float aY, Float aZ, Float aW)
-  {
-    x = aX; y = aY; z = aZ; w = aW;
-  }
-
-
-  void SetFromRotationMatrix(const Matrix4x4& aMatrix);
-
-
-  Quaternion operator*(const Quaternion &aQuat) const
-  {
-    Quaternion o;
-    const Float bx = aQuat.x, by = aQuat.y, bz = aQuat.z, bw = aQuat.w;
-
-    o.x = x*bw + w*bx + y*bz - z*by;
-    o.y = y*bw + w*by + z*bx - x*bz;
-    o.z = z*bw + w*bz + x*by - y*bx;
-    o.w = w*bw - x*bx - y*by - z*bz;
-    return o;
-  }
-
-  Quaternion& operator*=(const Quaternion &aQuat)
-  {
-    *this = *this * aQuat;
-    return *this;
-  }
-
-  Float Length() const
-  {
-    return sqrt(x*x + y*y + z*z + w*w);
-  }
-
-  Quaternion& Conjugate()
-  {
-    x *= -1.f; y *= -1.f; z *= -1.f;
-    return *this;
-  }
-
-  Quaternion& Normalize()
-  {
-    Float l = Length();
-    if (l) {
-      l = 1.0f / l;
-      x *= l; y *= l; z *= l; w *= l;
-    } else {
-      x = y = z = 0.f;
-      w = 1.f;
-    }
-    return *this;
-  }
-
-  Quaternion& Invert()
-  {
-    return Conjugate().Normalize();
-  }
-
-  Point3D RotatePoint(const Point3D& aPoint) {
-    Float uvx = Float(2.0) * (y*aPoint.z - z*aPoint.y);
-    Float uvy = Float(2.0) * (z*aPoint.x - x*aPoint.z);
-    Float uvz = Float(2.0) * (x*aPoint.y - y*aPoint.x);
-
-    return Point3D(aPoint.x + w*uvx + y*uvz - z*uvy,
-                   aPoint.y + w*uvy + z*uvx - x*uvz,
-                   aPoint.z + w*uvz + x*uvy - y*uvx);
-  }
-};
-
-}
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h" 2
-
-
-
-
-namespace mozilla {
-namespace gfx {
-
-static bool FuzzyEqual(Float aV1, Float aV2) {
-
-  return fabs(aV2 - aV1) < 1e-6;
-}
-
-class Matrix
-{
-public:
-  Matrix()
-    : _11(1.0f), _12(0)
-    , _21(0), _22(1.0f)
-    , _31(0), _32(0)
-  {}
-  Matrix(Float a11, Float a12, Float a21, Float a22, Float a31, Float a32)
-    : _11(a11), _12(a12)
-    , _21(a21), _22(a22)
-    , _31(a31), _32(a32)
-  {}
-  union {
-    struct {
-      Float _11, _12;
-      Float _21, _22;
-      Float _31, _32;
-    };
-    Float components[6];
-  };
-
-  __attribute__((always_inline)) inline Matrix Copy() const
-  {
-    return Matrix(*this);
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream, const Matrix& aMatrix);
-
-  Point TransformPoint(const Point &aPoint) const
-  {
-    Point retPoint;
-
-    retPoint.x = aPoint.x * _11 + aPoint.y * _21 + _31;
-    retPoint.y = aPoint.x * _12 + aPoint.y * _22 + _32;
-
-    return retPoint;
-  }
-
-  Size TransformSize(const Size &aSize) const
-  {
-    Size retSize;
-
-    retSize.width = aSize.width * _11 + aSize.height * _21;
-    retSize.height = aSize.width * _12 + aSize.height * _22;
-
-    return retSize;
-  }
-
-            Rect TransformBounds(const Rect& rect) const;
-
-  static Matrix Translation(Float aX, Float aY)
-  {
-    return Matrix(1.0f, 0.0f, 0.0f, 1.0f, aX, aY);
-  }
-
-  static Matrix Translation(Point aPoint)
-  {
-    return Translation(aPoint.x, aPoint.y);
-  }
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  Matrix &PreTranslate(Float aX, Float aY)
-  {
-    _31 += _11 * aX + _21 * aY;
-    _32 += _12 * aX + _22 * aY;
-
-    return *this;
-  }
-
-  Matrix &PreTranslate(const Point &aPoint)
-  {
-    return PreTranslate(aPoint.x, aPoint.y);
-  }
-# 133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  Matrix &PostTranslate(Float aX, Float aY)
-  {
-    _31 += aX;
-    _32 += aY;
-    return *this;
-  }
-
-  Matrix &PostTranslate(const Point &aPoint)
-  {
-    return PostTranslate(aPoint.x, aPoint.y);
-  }
-
-  static Matrix Scaling(Float aScaleX, Float aScaleY)
-  {
-    return Matrix(aScaleX, 0.0f, 0.0f, aScaleY, 0.0f, 0.0f);
-  }
-
-
-
-
-  Matrix &PreScale(Float aX, Float aY)
-  {
-    _11 *= aX;
-    _12 *= aX;
-    _21 *= aY;
-    _22 *= aY;
-
-    return *this;
-  }
-
-
-
-
-  Matrix &PostScale(Float aScaleX, Float aScaleY)
-  {
-    _11 *= aScaleX;
-    _12 *= aScaleY;
-    _21 *= aScaleX;
-    _22 *= aScaleY;
-    _31 *= aScaleX;
-    _32 *= aScaleY;
-
-    return *this;
-  }
-
-            static Matrix Rotation(Float aAngle);
-
-
-
-
-  Matrix &PreRotate(Float aAngle)
-  {
-    return *this = Matrix::Rotation(aAngle) * *this;
-  }
-
-  bool Invert()
-  {
-
-    Float A = _22;
-    Float B = -_21;
-    Float C = _21 * _32 - _22 * _31;
-    Float D = -_12;
-    Float E = _11;
-    Float F = _31 * _12 - _11 * _32;
-
-    Float det = Determinant();
-
-    if (!det) {
-      return false;
-    }
-
-    Float inv_det = 1 / det;
-
-    _11 = inv_det * A;
-    _12 = inv_det * D;
-    _21 = inv_det * B;
-    _22 = inv_det * E;
-    _31 = inv_det * C;
-    _32 = inv_det * F;
-
-    return true;
-  }
-
-  Matrix Inverse() const
-  {
-    Matrix clone = *this;
-    DebugOnly<bool> inverted = clone.Invert();
-    do { } while (0);
-    return clone;
-  }
-
-  Float Determinant() const
-  {
-    return _11 * _22 - _12 * _21;
-  }
-
-  Matrix operator*(const Matrix &aMatrix) const
-  {
-    Matrix resultMatrix;
-
-    resultMatrix._11 = this->_11 * aMatrix._11 + this->_12 * aMatrix._21;
-    resultMatrix._12 = this->_11 * aMatrix._12 + this->_12 * aMatrix._22;
-    resultMatrix._21 = this->_21 * aMatrix._11 + this->_22 * aMatrix._21;
-    resultMatrix._22 = this->_21 * aMatrix._12 + this->_22 * aMatrix._22;
-    resultMatrix._31 = this->_31 * aMatrix._11 + this->_32 * aMatrix._21 + aMatrix._31;
-    resultMatrix._32 = this->_31 * aMatrix._12 + this->_32 * aMatrix._22 + aMatrix._32;
-
-    return resultMatrix;
-  }
-
-  Matrix& operator*=(const Matrix &aMatrix)
-  {
-    *this = *this * aMatrix;
-    return *this;
-  }
-
-
-
-
-  Matrix &PreMultiply(const Matrix &aMatrix)
-  {
-    *this = aMatrix * *this;
-    return *this;
-  }
-
-
-
-
-  bool operator==(const Matrix& other) const
-  {
-    return FuzzyEqual(_11, other._11) && FuzzyEqual(_12, other._12) &&
-           FuzzyEqual(_21, other._21) && FuzzyEqual(_22, other._22) &&
-           FuzzyEqual(_31, other._31) && FuzzyEqual(_32, other._32);
-  }
-
-  bool operator!=(const Matrix& other) const
-  {
-    return !(*this == other);
-  }
-
-  bool ExactlyEquals(const Matrix& o) const
-  {
-    return _11 == o._11 && _12 == o._12 &&
-           _21 == o._21 && _22 == o._22 &&
-           _31 == o._31 && _32 == o._32;
-  }
-
-
-  bool IsFinite() const
-  {
-    return mozilla::IsFinite(_11) && mozilla::IsFinite(_12) &&
-           mozilla::IsFinite(_21) && mozilla::IsFinite(_22) &&
-           mozilla::IsFinite(_31) && mozilla::IsFinite(_32);
-  }
-
-
-
-
-  bool IsRectilinear() const {
-    if (FuzzyEqual(_12, 0) && FuzzyEqual(_21, 0)) {
-      return true;
-    } else if (FuzzyEqual(_22, 0) && FuzzyEqual(_11, 0)) {
-      return true;
-    }
-
-    return false;
-  }
-
-
-
-
-
-  bool HasNonIntegerTranslation() const {
-    return HasNonTranslation() ||
-      !FuzzyEqual(_31, floor(_31 + Float(0.5))) ||
-      !FuzzyEqual(_32, floor(_32 + Float(0.5)));
-  }
-
-
-
-
-  bool HasOnlyIntegerTranslation() const {
-    return !HasNonIntegerTranslation();
-  }
-
-
-
-
-
-  bool HasNonTranslation() const {
-    return !FuzzyEqual(_11, 1.0) || !FuzzyEqual(_22, 1.0) ||
-           !FuzzyEqual(_12, 0.0) || !FuzzyEqual(_21, 0.0);
-  }
-
-
-
-
-
-  bool HasNonTranslationOrFlip() const {
-      return !FuzzyEqual(_11, 1.0) ||
-             (!FuzzyEqual(_22, 1.0) && !FuzzyEqual(_22, -1.0)) ||
-             !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
-  }
-
-
-
-  bool IsIdentity() const
-  {
-    return _11 == 1.0f && _12 == 0.0f &&
-           _21 == 0.0f && _22 == 1.0f &&
-           _31 == 0.0f && _32 == 0.0f;
-  }
-
-
-
-  bool IsSingular() const
-  {
-    Float det = Determinant();
-    return !mozilla::IsFinite(det) || det == 0;
-  }
-
-            Matrix &NudgeToIntegers();
-
-  bool IsTranslation() const
-  {
-    return FuzzyEqual(_11, 1.0f) && FuzzyEqual(_12, 0.0f) &&
-           FuzzyEqual(_21, 0.0f) && FuzzyEqual(_22, 1.0f);
-  }
-
-  static bool FuzzyIsInteger(Float aValue)
-  {
-    return FuzzyEqual(aValue, floorf(aValue + 0.5f));
-  }
-
-  bool IsIntegerTranslation() const
-  {
-    return IsTranslation() && FuzzyIsInteger(_31) && FuzzyIsInteger(_32);
-  }
-
-  bool IsAllIntegers() const
-  {
-    return FuzzyIsInteger(_11) && FuzzyIsInteger(_12) &&
-           FuzzyIsInteger(_21) && FuzzyIsInteger(_22) &&
-           FuzzyIsInteger(_31) && FuzzyIsInteger(_32);
-  }
-
-  Point GetTranslation() const {
-    return Point(_31, _32);
-  }
-
-
-
-
-
-  bool PreservesAxisAlignedRectangles() const {
-      return ((FuzzyEqual(_11, 0.0) && FuzzyEqual(_22, 0.0))
-          || (FuzzyEqual(_12, 0.0) && FuzzyEqual(_21, 0.0)));
-  }
-
-
-
-
-
-
-  bool HasNonAxisAlignedTransform() const {
-      return !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
-  }
-
-
-
-
-  bool HasNegativeScaling() const {
-      return (_11 < 0.0) || (_22 < 0.0);
-  }
-};
-
-
-double
-SafeTangent(double aTheta);
-double
-FlushToZero(double aVal);
-
-template<class Units, class F>
-Point4DTyped<Units, F>
-ComputePerspectivePlaneIntercept(const Point4DTyped<Units, F>& aFirst,
-                                 const Point4DTyped<Units, F>& aSecond)
-{
-# 429 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  float t = -aFirst.w / (aSecond.w - aFirst.w);
-
-
-  return aFirst + (aSecond - aFirst) * t;
-}
-
-
-template <typename SourceUnits, typename TargetUnits>
-class Matrix4x4Typed
-{
-public:
-  typedef PointTyped<SourceUnits> SourcePoint;
-  typedef PointTyped<TargetUnits> TargetPoint;
-  typedef Point3DTyped<SourceUnits> SourcePoint3D;
-  typedef Point3DTyped<TargetUnits> TargetPoint3D;
-  typedef Point4DTyped<SourceUnits> SourcePoint4D;
-  typedef Point4DTyped<TargetUnits> TargetPoint4D;
-  typedef RectTyped<SourceUnits> SourceRect;
-  typedef RectTyped<TargetUnits> TargetRect;
-
-  Matrix4x4Typed()
-    : _11(1.0f), _12(0.0f), _13(0.0f), _14(0.0f)
-    , _21(0.0f), _22(1.0f), _23(0.0f), _24(0.0f)
-    , _31(0.0f), _32(0.0f), _33(1.0f), _34(0.0f)
-    , _41(0.0f), _42(0.0f), _43(0.0f), _44(1.0f)
-  {}
-
-  Matrix4x4Typed(Float a11, Float a12, Float a13, Float a14,
-                 Float a21, Float a22, Float a23, Float a24,
-                 Float a31, Float a32, Float a33, Float a34,
-                 Float a41, Float a42, Float a43, Float a44)
-    : _11(a11), _12(a12), _13(a13), _14(a14)
-    , _21(a21), _22(a22), _23(a23), _24(a24)
-    , _31(a31), _32(a32), _33(a33), _34(a34)
-    , _41(a41), _42(a42), _43(a43), _44(a44)
-  {}
-
-  explicit Matrix4x4Typed(const Float aArray[16])
-  {
-    memcpy(components, aArray, sizeof(components));
-  }
-
-  Matrix4x4Typed(const Matrix4x4Typed& aOther)
-  {
-    memcpy(this, &aOther, sizeof(*this));
-  }
-
-  union {
-    struct {
-      Float _11, _12, _13, _14;
-      Float _21, _22, _23, _24;
-      Float _31, _32, _33, _34;
-      Float _41, _42, _43, _44;
-    };
-    Float components[16];
-  };
-
-  friend std::ostream& operator<<(std::ostream& aStream, const Matrix4x4Typed& aMatrix)
-  {
-    const Float *f = &aMatrix._11;
-    aStream << "[ " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
-    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
-    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
-    aStream << "  " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ]" << std::endl;
-    return aStream;
-  }
-
-  Point4D& operator[](int aIndex)
-  {
-      do { } while (0);
-      return *reinterpret_cast<Point4D*>((&_11)+4*aIndex);
-  }
-  const Point4D& operator[](int aIndex) const
-  {
-      do { } while (0);
-      return *reinterpret_cast<const Point4D*>((&_11)+4*aIndex);
-  }
-
-
-
-
-  bool Is2D() const
-  {
-    if (_13 != 0.0f || _14 != 0.0f ||
-        _23 != 0.0f || _24 != 0.0f ||
-        _31 != 0.0f || _32 != 0.0f || _33 != 1.0f || _34 != 0.0f ||
-        _43 != 0.0f || _44 != 1.0f) {
-      return false;
-    }
-    return true;
-  }
-
-  bool Is2D(Matrix* aMatrix) const {
-    if (!Is2D()) {
-      return false;
-    }
-    if (aMatrix) {
-      aMatrix->_11 = _11;
-      aMatrix->_12 = _12;
-      aMatrix->_21 = _21;
-      aMatrix->_22 = _22;
-      aMatrix->_31 = _41;
-      aMatrix->_32 = _42;
-    }
-    return true;
-  }
-
-  Matrix As2D() const
-  {
-    do { } while (0);
-
-    return Matrix(_11, _12, _21, _22, _41, _42);
-  }
-
-  bool CanDraw2D(Matrix* aMatrix = nullptr) const {
-    if (_14 != 0.0f ||
-        _24 != 0.0f ||
-        _44 != 1.0f) {
-      return false;
-    }
-    if (aMatrix) {
-      aMatrix->_11 = _11;
-      aMatrix->_12 = _12;
-      aMatrix->_21 = _21;
-      aMatrix->_22 = _22;
-      aMatrix->_31 = _41;
-      aMatrix->_32 = _42;
-    }
-    return true;
-  }
-
-  Matrix4x4Typed& ProjectTo2D() {
-    _31 = 0.0f;
-    _32 = 0.0f;
-    _13 = 0.0f;
-    _23 = 0.0f;
-    _33 = 1.0f;
-    _43 = 0.0f;
-    _34 = 0.0f;
-
-
-
-
-
-
-
-    if (_14 == 0.0f && _24 == 0.0f &&
-        _44 != 1.0f && _44 != 0.0f) {
-      Float scale = 1.0f / _44;
-      _11 *= scale;
-      _12 *= scale;
-      _21 *= scale;
-      _22 *= scale;
-      _41 *= scale;
-      _42 *= scale;
-      _44 = 1.0f;
-    }
-    return *this;
-  }
-
-  template<class F>
-  Point4DTyped<TargetUnits, F>
-  ProjectPoint(const PointTyped<SourceUnits, F>& aPoint) const {
-
-
-
-
-
-
-    F z = -(aPoint.x * _13 + aPoint.y * _23 + _43) / _33;
-
-
-    return this->TransformPoint(Point4DTyped<SourceUnits, F>(aPoint.x, aPoint.y, z, 1));
-  }
-
-  template<class F>
-  RectTyped<TargetUnits, F>
-  ProjectRectBounds(const RectTyped<SourceUnits, F>& aRect, const RectTyped<TargetUnits, F>& aClip) const
-  {
-# 632 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-    Point4DTyped<TargetUnits, F> points[4];
-
-    points[0] = ProjectPoint(aRect.TopLeft());
-    points[1] = ProjectPoint(aRect.TopRight());
-    points[2] = ProjectPoint(aRect.BottomRight());
-    points[3] = ProjectPoint(aRect.BottomLeft());
-
-    F min_x = std::numeric_limits<F>::max();
-    F min_y = std::numeric_limits<F>::max();
-    F max_x = -std::numeric_limits<F>::max();
-    F max_y = -std::numeric_limits<F>::max();
-
-    for (int i=0; i<4; i++) {
-
-      if (points[i].HasPositiveWCoord()) {
-        PointTyped<TargetUnits, F> point2d = aClip.ClampPoint(points[i].As2DPoint());
-        min_x = std::min<F>(point2d.x, min_x);
-        max_x = std::max<F>(point2d.x, max_x);
-        min_y = std::min<F>(point2d.y, min_y);
-        max_y = std::max<F>(point2d.y, max_y);
-      }
-
-      int next = (i == 3) ? 0 : i + 1;
-      if (points[i].HasPositiveWCoord() != points[next].HasPositiveWCoord()) {
-
-
-
-        Point4DTyped<TargetUnits, F> intercept =
-          ComputePerspectivePlaneIntercept(points[i], points[next]);
-
-
-        if (intercept.x < 0.0f) {
-          min_x = aClip.x;
-        } else if (intercept.x > 0.0f) {
-          max_x = aClip.XMost();
-        }
-        if (intercept.y < 0.0f) {
-          min_y = aClip.y;
-        } else if (intercept.y > 0.0f) {
-          max_y = aClip.YMost();
-        }
-      }
-    }
-
-    if (max_x < min_x || max_y < min_y) {
-      return RectTyped<TargetUnits, F>(0, 0, 0, 0);
-    }
-
-    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
-  }
-
-
-
-
-
-  template<class F>
-  RectTyped<TargetUnits, F> TransformAndClipBounds(const RectTyped<SourceUnits, F>& aRect,
-                                                   const RectTyped<TargetUnits, F>& aClip) const
-  {
-    PointTyped<UnknownUnits, F> verts[kTransformAndClipRectMaxVerts];
-    size_t vertCount = TransformAndClipRect(aRect, aClip, verts);
-
-    F min_x = std::numeric_limits<F>::max();
-    F min_y = std::numeric_limits<F>::max();
-    F max_x = -std::numeric_limits<F>::max();
-    F max_y = -std::numeric_limits<F>::max();
-    for (size_t i=0; i < vertCount; i++) {
-      min_x = std::min(min_x, verts[i].x);
-      max_x = std::max(max_x, verts[i].x);
-      min_y = std::min(min_y, verts[i].y);
-      max_y = std::max(max_y, verts[i].y);
-    }
-
-    if (max_x < min_x || max_y < min_y) {
-      return RectTyped<TargetUnits, F>(0, 0, 0, 0);
-    }
-
-    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
-  }
-
-  template<class F>
-  RectTyped<TargetUnits, F> TransformAndClipBounds(const TriangleTyped<SourceUnits, F>& aTriangle,
-                                                   const RectTyped<TargetUnits, F>& aClip) const
-  {
-    return TransformAndClipBounds(aTriangle.BoundingBox(), aClip);
-  }
-# 729 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  template<class F>
-  size_t TransformAndClipRect(const RectTyped<SourceUnits, F>& aRect,
-                              const RectTyped<TargetUnits, F>& aClip,
-                              PointTyped<TargetUnits, F>* aVerts) const
-  {
-
-
-    Point4DTyped<UnknownUnits, F> points[2][kTransformAndClipRectMaxVerts];
-    Point4DTyped<UnknownUnits, F>* dstPoint = points[0];
-
-    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.x, aRect.y, 0, 1));
-    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.XMost(), aRect.y, 0, 1));
-    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.XMost(), aRect.YMost(), 0, 1));
-    *dstPoint++ = TransformPoint(Point4DTyped<UnknownUnits, F>(aRect.x, aRect.YMost(), 0, 1));
-
-
-
-    Point4DTyped<UnknownUnits, F> planeNormals[4];
-    planeNormals[0] = Point4DTyped<UnknownUnits, F>(1.0, 0.0, 0.0, -aClip.x);
-    planeNormals[1] = Point4DTyped<UnknownUnits, F>(-1.0, 0.0, 0.0, aClip.XMost());
-    planeNormals[2] = Point4DTyped<UnknownUnits, F>(0.0, 1.0, 0.0, -aClip.y);
-    planeNormals[3] = Point4DTyped<UnknownUnits, F>(0.0, -1.0, 0.0, aClip.YMost());
-
-
-
-
-    for (int plane=0; plane < 4; plane++) {
-      planeNormals[plane].Normalize();
-      Point4DTyped<UnknownUnits, F>* srcPoint = points[plane & 1];
-      Point4DTyped<UnknownUnits, F>* srcPointEnd = dstPoint;
-
-      dstPoint = points[~plane & 1];
-      Point4DTyped<UnknownUnits, F>* dstPointStart = dstPoint;
-
-      Point4DTyped<UnknownUnits, F>* prevPoint = srcPointEnd - 1;
-      F prevDot = planeNormals[plane].DotProduct(*prevPoint);
-      while (srcPoint < srcPointEnd && ((dstPoint - dstPointStart) < kTransformAndClipRectMaxVerts)) {
-        F nextDot = planeNormals[plane].DotProduct(*srcPoint);
-
-        if ((nextDot >= 0.0) != (prevDot >= 0.0)) {
-
-
-          F t = -prevDot / (nextDot - prevDot);
-          *dstPoint++ = *srcPoint * t + *prevPoint * (1.0 - t);
-        }
-
-        if (nextDot >= 0.0) {
-
-
-          *dstPoint++ = *srcPoint;
-        }
-
-        prevPoint = srcPoint++;
-        prevDot = nextDot;
-      }
-
-      if (dstPoint == dstPointStart) {
-        break;
-      }
-    }
-
-    size_t dstPointCount = 0;
-    size_t srcPointCount = dstPoint - points[0];
-    for (Point4DTyped<UnknownUnits, F>* srcPoint = points[0]; srcPoint < points[0] + srcPointCount; srcPoint++) {
-
-      PointTyped<TargetUnits, F> p;
-      if (srcPoint->w == 0.0) {
-
-
-        p = PointTyped<TargetUnits, F>(0.0, 0.0);
-      } else {
-        p = srcPoint->As2DPoint();
-      }
-
-      if (dstPointCount == 0 || p != aVerts[dstPointCount - 1]) {
-        aVerts[dstPointCount++] = p;
-      }
-    }
-
-    return dstPointCount;
-  }
-
-  static const int kTransformAndClipRectMaxVerts = 32;
-
-  static Matrix4x4Typed From2D(const Matrix &aMatrix) {
-    Matrix4x4Typed matrix;
-    matrix._11 = aMatrix._11;
-    matrix._12 = aMatrix._12;
-    matrix._21 = aMatrix._21;
-    matrix._22 = aMatrix._22;
-    matrix._41 = aMatrix._31;
-    matrix._42 = aMatrix._32;
-    return matrix;
-  }
-
-  bool Is2DIntegerTranslation() const
-  {
-    return Is2D() && As2D().IsIntegerTranslation();
-  }
-
-  TargetPoint4D TransposeTransform4D(const SourcePoint4D& aPoint) const
-  {
-      Float x = aPoint.x * _11 + aPoint.y * _12 + aPoint.z * _13 + aPoint.w * _14;
-      Float y = aPoint.x * _21 + aPoint.y * _22 + aPoint.z * _23 + aPoint.w * _24;
-      Float z = aPoint.x * _31 + aPoint.y * _32 + aPoint.z * _33 + aPoint.w * _34;
-      Float w = aPoint.x * _41 + aPoint.y * _42 + aPoint.z * _43 + aPoint.w * _44;
-
-      return TargetPoint4D(x, y, z, w);
-  }
-
-  template<class F>
-  Point4DTyped<TargetUnits, F> TransformPoint(const Point4DTyped<SourceUnits, F>& aPoint) const
-  {
-    Point4DTyped<TargetUnits, F> retPoint;
-
-    retPoint.x = aPoint.x * _11 + aPoint.y * _21 + aPoint.z * _31 + aPoint.w * _41;
-    retPoint.y = aPoint.x * _12 + aPoint.y * _22 + aPoint.z * _32 + aPoint.w * _42;
-    retPoint.z = aPoint.x * _13 + aPoint.y * _23 + aPoint.z * _33 + aPoint.w * _43;
-    retPoint.w = aPoint.x * _14 + aPoint.y * _24 + aPoint.z * _34 + aPoint.w * _44;
-
-    return retPoint;
-  }
-
-  template<class F>
-  Point3DTyped<TargetUnits, F> TransformPoint(const Point3DTyped<SourceUnits, F>& aPoint) const
-  {
-    Point3DTyped<TargetUnits, F> result;
-    result.x = aPoint.x * _11 + aPoint.y * _21 + aPoint.z * _31 + _41;
-    result.y = aPoint.x * _12 + aPoint.y * _22 + aPoint.z * _32 + _42;
-    result.z = aPoint.x * _13 + aPoint.y * _23 + aPoint.z * _33 + _43;
-
-    result /= (aPoint.x * _14 + aPoint.y * _24 + aPoint.z * _34 + _44);
-
-    return result;
-  }
-
-  template<class F>
-  PointTyped<TargetUnits, F> TransformPoint(const PointTyped<SourceUnits, F> &aPoint) const
-  {
-    Point4DTyped<SourceUnits, F> temp(aPoint.x, aPoint.y, 0, 1);
-    return TransformPoint(temp).As2DPoint();
-  }
-
-  template<class F>
-            RectTyped<TargetUnits, F> TransformBounds(const RectTyped<SourceUnits, F>& aRect) const
-  {
-    Point4DTyped<TargetUnits, F> verts[4];
-    verts[0] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.x, aRect.y, 0.0, 1.0));
-    verts[1] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.XMost(), aRect.y, 0.0, 1.0));
-    verts[2] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.XMost(), aRect.YMost(), 0.0, 1.0));
-    verts[3] = TransformPoint(Point4DTyped<SourceUnits, F>(aRect.x, aRect.YMost(), 0.0, 1.0));
-
-    PointTyped<TargetUnits, F> quad[4];
-    F min_x, max_x;
-    F min_y, max_y;
-
-    quad[0] = TransformPoint(aRect.TopLeft());
-    quad[1] = TransformPoint(aRect.TopRight());
-    quad[2] = TransformPoint(aRect.BottomLeft());
-    quad[3] = TransformPoint(aRect.BottomRight());
-
-    min_x = max_x = quad[0].x;
-    min_y = max_y = quad[0].y;
-
-    for (int i = 1; i < 4; i++) {
-      if (quad[i].x < min_x) {
-        min_x = quad[i].x;
-      }
-      if (quad[i].x > max_x) {
-        max_x = quad[i].x;
-      }
-
-      if (quad[i].y < min_y) {
-        min_y = quad[i].y;
-      }
-      if (quad[i].y > max_y) {
-        max_y = quad[i].y;
-      }
-    }
-
-    return RectTyped<TargetUnits, F>(min_x, min_y, max_x - min_x, max_y - min_y);
-  }
-
-  static Matrix4x4Typed Translation(Float aX, Float aY, Float aZ)
-  {
-    return Matrix4x4Typed(1.0f, 0.0f, 0.0f, 0.0f,
-                          0.0f, 1.0f, 0.0f, 0.0f,
-                          0.0f, 0.0f, 1.0f, 0.0f,
-                          aX, aY, aZ, 1.0f);
-  }
-
-  static Matrix4x4Typed Translation(const TargetPoint3D& aP)
-  {
-    return Translation(aP.x, aP.y, aP.z);
-  }
-
-  static Matrix4x4Typed Translation(const TargetPoint& aP)
-  {
-    return Translation(aP.x, aP.y, 0);
-  }
-# 949 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  Matrix4x4Typed &PreTranslate(Float aX, Float aY, Float aZ)
-  {
-    _41 += aX * _11 + aY * _21 + aZ * _31;
-    _42 += aX * _12 + aY * _22 + aZ * _32;
-    _43 += aX * _13 + aY * _23 + aZ * _33;
-    _44 += aX * _14 + aY * _24 + aZ * _34;
-
-    return *this;
-  }
-
-  Matrix4x4Typed &PreTranslate(const Point3D& aPoint) {
-    return PreTranslate(aPoint.x, aPoint.y, aPoint.z);
-  }
-# 975 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Matrix.h"
-  Matrix4x4Typed &PostTranslate(Float aX, Float aY, Float aZ)
-  {
-    _11 += _14 * aX;
-    _21 += _24 * aX;
-    _31 += _34 * aX;
-    _41 += _44 * aX;
-    _12 += _14 * aY;
-    _22 += _24 * aY;
-    _32 += _34 * aY;
-    _42 += _44 * aY;
-    _13 += _14 * aZ;
-    _23 += _24 * aZ;
-    _33 += _34 * aZ;
-    _43 += _44 * aZ;
-
-    return *this;
-  }
-
-  Matrix4x4Typed &PostTranslate(const TargetPoint3D& aPoint) {
-    return PostTranslate(aPoint.x, aPoint.y, aPoint.z);
-  }
-
-  Matrix4x4Typed &PostTranslate(const TargetPoint& aPoint) {
-    return PostTranslate(aPoint.x, aPoint.y, 0);
-  }
-
-  static Matrix4x4Typed Scaling(Float aScaleX, Float aScaleY, float aScaleZ)
-  {
-    return Matrix4x4Typed(aScaleX, 0.0f, 0.0f, 0.0f,
-                          0.0f, aScaleY, 0.0f, 0.0f,
-                          0.0f, 0.0f, aScaleZ, 0.0f,
-                          0.0f, 0.0f, 0.0f, 1.0f);
-  }
-
-
-
-
-  Matrix4x4Typed &PreScale(Float aX, Float aY, Float aZ)
-  {
-    _11 *= aX;
-    _12 *= aX;
-    _13 *= aX;
-    _14 *= aX;
-    _21 *= aY;
-    _22 *= aY;
-    _23 *= aY;
-    _24 *= aY;
-    _31 *= aZ;
-    _32 *= aZ;
-    _33 *= aZ;
-    _34 *= aZ;
-
-    return *this;
-  }
-
-
-
-
-  Matrix4x4Typed &PostScale(Float aScaleX, Float aScaleY, Float aScaleZ)
-  {
-    _11 *= aScaleX;
-    _21 *= aScaleX;
-    _31 *= aScaleX;
-    _41 *= aScaleX;
-    _12 *= aScaleY;
-    _22 *= aScaleY;
-    _32 *= aScaleY;
-    _42 *= aScaleY;
-    _13 *= aScaleZ;
-    _23 *= aScaleZ;
-    _33 *= aScaleZ;
-    _43 *= aScaleZ;
-
-    return *this;
-  }
-
-  void SkewXY(Float aSkew)
-  {
-    (*this)[1] += (*this)[0] * aSkew;
-  }
-
-  void SkewXZ(Float aSkew)
-  {
-      (*this)[2] += (*this)[0] * aSkew;
-  }
-
-  void SkewYZ(Float aSkew)
-  {
-      (*this)[2] += (*this)[1] * aSkew;
-  }
-
-  Matrix4x4Typed &ChangeBasis(const Point3D& aOrigin)
-  {
-    return ChangeBasis(aOrigin.x, aOrigin.y, aOrigin.z);
-  }
-
-  Matrix4x4Typed &ChangeBasis(Float aX, Float aY, Float aZ)
-  {
-
-    PreTranslate(-aX, -aY, -aZ);
-
-
-    PostTranslate(aX, aY, aZ);
-
-    return *this;
-  }
-
-  Matrix4x4Typed& Transpose() {
-    std::swap(_12, _21);
-    std::swap(_13, _31);
-    std::swap(_14, _41);
-
-    std::swap(_23, _32);
-    std::swap(_24, _42);
-
-    std::swap(_34, _43);
-
-    return *this;
-  }
-
-  bool operator==(const Matrix4x4Typed& o) const
-  {
-
-    return _11 == o._11 && _12 == o._12 && _13 == o._13 && _14 == o._14 &&
-           _21 == o._21 && _22 == o._22 && _23 == o._23 && _24 == o._24 &&
-           _31 == o._31 && _32 == o._32 && _33 == o._33 && _34 == o._34 &&
-           _41 == o._41 && _42 == o._42 && _43 == o._43 && _44 == o._44;
-  }
-
-  bool operator!=(const Matrix4x4Typed& o) const
-  {
-    return !((*this) == o);
-  }
-
-  template <typename NewTargetUnits>
-  Matrix4x4Typed<SourceUnits, NewTargetUnits> operator*(const Matrix4x4Typed<TargetUnits, NewTargetUnits> &aMatrix) const
-  {
-    Matrix4x4Typed<SourceUnits, NewTargetUnits> matrix;
-
-    matrix._11 = _11 * aMatrix._11 + _12 * aMatrix._21 + _13 * aMatrix._31 + _14 * aMatrix._41;
-    matrix._21 = _21 * aMatrix._11 + _22 * aMatrix._21 + _23 * aMatrix._31 + _24 * aMatrix._41;
-    matrix._31 = _31 * aMatrix._11 + _32 * aMatrix._21 + _33 * aMatrix._31 + _34 * aMatrix._41;
-    matrix._41 = _41 * aMatrix._11 + _42 * aMatrix._21 + _43 * aMatrix._31 + _44 * aMatrix._41;
-    matrix._12 = _11 * aMatrix._12 + _12 * aMatrix._22 + _13 * aMatrix._32 + _14 * aMatrix._42;
-    matrix._22 = _21 * aMatrix._12 + _22 * aMatrix._22 + _23 * aMatrix._32 + _24 * aMatrix._42;
-    matrix._32 = _31 * aMatrix._12 + _32 * aMatrix._22 + _33 * aMatrix._32 + _34 * aMatrix._42;
-    matrix._42 = _41 * aMatrix._12 + _42 * aMatrix._22 + _43 * aMatrix._32 + _44 * aMatrix._42;
-    matrix._13 = _11 * aMatrix._13 + _12 * aMatrix._23 + _13 * aMatrix._33 + _14 * aMatrix._43;
-    matrix._23 = _21 * aMatrix._13 + _22 * aMatrix._23 + _23 * aMatrix._33 + _24 * aMatrix._43;
-    matrix._33 = _31 * aMatrix._13 + _32 * aMatrix._23 + _33 * aMatrix._33 + _34 * aMatrix._43;
-    matrix._43 = _41 * aMatrix._13 + _42 * aMatrix._23 + _43 * aMatrix._33 + _44 * aMatrix._43;
-    matrix._14 = _11 * aMatrix._14 + _12 * aMatrix._24 + _13 * aMatrix._34 + _14 * aMatrix._44;
-    matrix._24 = _21 * aMatrix._14 + _22 * aMatrix._24 + _23 * aMatrix._34 + _24 * aMatrix._44;
-    matrix._34 = _31 * aMatrix._14 + _32 * aMatrix._24 + _33 * aMatrix._34 + _34 * aMatrix._44;
-    matrix._44 = _41 * aMatrix._14 + _42 * aMatrix._24 + _43 * aMatrix._34 + _44 * aMatrix._44;
-
-    return matrix;
-  }
-
-  Matrix4x4Typed& operator*=(const Matrix4x4Typed<TargetUnits, TargetUnits> &aMatrix)
-  {
-    *this = *this * aMatrix;
-    return *this;
-  }
-
-
-
-  bool IsIdentity() const
-  {
-    return _11 == 1.0f && _12 == 0.0f && _13 == 0.0f && _14 == 0.0f &&
-           _21 == 0.0f && _22 == 1.0f && _23 == 0.0f && _24 == 0.0f &&
-           _31 == 0.0f && _32 == 0.0f && _33 == 1.0f && _34 == 0.0f &&
-           _41 == 0.0f && _42 == 0.0f && _43 == 0.0f && _44 == 1.0f;
-  }
-
-  bool IsSingular() const
-  {
-    return Determinant() == 0.0;
-  }
-
-  Float Determinant() const
-  {
-    return _14 * _23 * _32 * _41
-         - _13 * _24 * _32 * _41
-         - _14 * _22 * _33 * _41
-         + _12 * _24 * _33 * _41
-         + _13 * _22 * _34 * _41
-         - _12 * _23 * _34 * _41
-         - _14 * _23 * _31 * _42
-         + _13 * _24 * _31 * _42
-         + _14 * _21 * _33 * _42
-         - _11 * _24 * _33 * _42
-         - _13 * _21 * _34 * _42
-         + _11 * _23 * _34 * _42
-         + _14 * _22 * _31 * _43
-         - _12 * _24 * _31 * _43
-         - _14 * _21 * _32 * _43
-         + _11 * _24 * _32 * _43
-         + _12 * _21 * _34 * _43
-         - _11 * _22 * _34 * _43
-         - _13 * _22 * _31 * _44
-         + _12 * _23 * _31 * _44
-         + _13 * _21 * _32 * _44
-         - _11 * _23 * _32 * _44
-         - _12 * _21 * _33 * _44
-         + _11 * _22 * _33 * _44;
-  }
-
-
-  bool Invert()
-  {
-    Float det = Determinant();
-    if (!det) {
-      return false;
-    }
-
-    Matrix4x4Typed<SourceUnits, TargetUnits> result;
-    result._11 = _23 * _34 * _42 - _24 * _33 * _42 + _24 * _32 * _43 - _22 * _34 * _43 - _23 * _32 * _44 + _22 * _33 * _44;
-    result._12 = _14 * _33 * _42 - _13 * _34 * _42 - _14 * _32 * _43 + _12 * _34 * _43 + _13 * _32 * _44 - _12 * _33 * _44;
-    result._13 = _13 * _24 * _42 - _14 * _23 * _42 + _14 * _22 * _43 - _12 * _24 * _43 - _13 * _22 * _44 + _12 * _23 * _44;
-    result._14 = _14 * _23 * _32 - _13 * _24 * _32 - _14 * _22 * _33 + _12 * _24 * _33 + _13 * _22 * _34 - _12 * _23 * _34;
-    result._21 = _24 * _33 * _41 - _23 * _34 * _41 - _24 * _31 * _43 + _21 * _34 * _43 + _23 * _31 * _44 - _21 * _33 * _44;
-    result._22 = _13 * _34 * _41 - _14 * _33 * _41 + _14 * _31 * _43 - _11 * _34 * _43 - _13 * _31 * _44 + _11 * _33 * _44;
-    result._23 = _14 * _23 * _41 - _13 * _24 * _41 - _14 * _21 * _43 + _11 * _24 * _43 + _13 * _21 * _44 - _11 * _23 * _44;
-    result._24 = _13 * _24 * _31 - _14 * _23 * _31 + _14 * _21 * _33 - _11 * _24 * _33 - _13 * _21 * _34 + _11 * _23 * _34;
-    result._31 = _22 * _34 * _41 - _24 * _32 * _41 + _24 * _31 * _42 - _21 * _34 * _42 - _22 * _31 * _44 + _21 * _32 * _44;
-    result._32 = _14 * _32 * _41 - _12 * _34 * _41 - _14 * _31 * _42 + _11 * _34 * _42 + _12 * _31 * _44 - _11 * _32 * _44;
-    result._33 = _12 * _24 * _41 - _14 * _22 * _41 + _14 * _21 * _42 - _11 * _24 * _42 - _12 * _21 * _44 + _11 * _22 * _44;
-    result._34 = _14 * _22 * _31 - _12 * _24 * _31 - _14 * _21 * _32 + _11 * _24 * _32 + _12 * _21 * _34 - _11 * _22 * _34;
-    result._41 = _23 * _32 * _41 - _22 * _33 * _41 - _23 * _31 * _42 + _21 * _33 * _42 + _22 * _31 * _43 - _21 * _32 * _43;
-    result._42 = _12 * _33 * _41 - _13 * _32 * _41 + _13 * _31 * _42 - _11 * _33 * _42 - _12 * _31 * _43 + _11 * _32 * _43;
-    result._43 = _13 * _22 * _41 - _12 * _23 * _41 - _13 * _21 * _42 + _11 * _23 * _42 + _12 * _21 * _43 - _11 * _22 * _43;
-    result._44 = _12 * _23 * _31 - _13 * _22 * _31 + _13 * _21 * _32 - _11 * _23 * _32 - _12 * _21 * _33 + _11 * _22 * _33;
-
-    result._11 /= det;
-    result._12 /= det;
-    result._13 /= det;
-    result._14 /= det;
-    result._21 /= det;
-    result._22 /= det;
-    result._23 /= det;
-    result._24 /= det;
-    result._31 /= det;
-    result._32 /= det;
-    result._33 /= det;
-    result._34 /= det;
-    result._41 /= det;
-    result._42 /= det;
-    result._43 /= det;
-    result._44 /= det;
-    *this = result;
-
-    return true;
-  }
-
-  Matrix4x4Typed<TargetUnits, SourceUnits> Inverse() const
-  {
-    typedef Matrix4x4Typed<TargetUnits, SourceUnits> InvertedMatrix;
-    InvertedMatrix clone = InvertedMatrix::FromUnknownMatrix(ToUnknownMatrix());
-    DebugOnly<bool> inverted = clone.Invert();
-    do { } while (0);
-    return clone;
-  }
-
-  Maybe<Matrix4x4Typed<TargetUnits, SourceUnits>> MaybeInverse() const
-  {
-    typedef Matrix4x4Typed<TargetUnits, SourceUnits> InvertedMatrix;
-    InvertedMatrix clone = InvertedMatrix::FromUnknownMatrix(ToUnknownMatrix());
-    if (clone.Invert()) {
-      return Some(clone);
-    }
-    return Nothing();
-  }
-
-  void Normalize()
-  {
-      for (int i = 0; i < 4; i++) {
-          for (int j = 0; j < 4; j++) {
-              (*this)[i][j] /= (*this)[3][3];
-         }
-      }
-  }
-
-  bool FuzzyEqual(const Matrix4x4Typed& o) const
-  {
-    return gfx::FuzzyEqual(_11, o._11) && gfx::FuzzyEqual(_12, o._12) &&
-           gfx::FuzzyEqual(_13, o._13) && gfx::FuzzyEqual(_14, o._14) &&
-           gfx::FuzzyEqual(_21, o._21) && gfx::FuzzyEqual(_22, o._22) &&
-           gfx::FuzzyEqual(_23, o._23) && gfx::FuzzyEqual(_24, o._24) &&
-           gfx::FuzzyEqual(_31, o._31) && gfx::FuzzyEqual(_32, o._32) &&
-           gfx::FuzzyEqual(_33, o._33) && gfx::FuzzyEqual(_34, o._34) &&
-           gfx::FuzzyEqual(_41, o._41) && gfx::FuzzyEqual(_42, o._42) &&
-           gfx::FuzzyEqual(_43, o._43) && gfx::FuzzyEqual(_44, o._44);
-  }
-
-  bool FuzzyEqualsMultiplicative(const Matrix4x4Typed& o) const
-  {
-    return ::mozilla::FuzzyEqualsMultiplicative(_11, o._11) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_12, o._12) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_13, o._13) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_14, o._14) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_21, o._21) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_22, o._22) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_23, o._23) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_24, o._24) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_31, o._31) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_32, o._32) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_33, o._33) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_34, o._34) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_41, o._41) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_42, o._42) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_43, o._43) &&
-           ::mozilla::FuzzyEqualsMultiplicative(_44, o._44);
-  }
-
-  bool IsBackfaceVisible() const
-  {
-
-    Float det = Determinant();
-    Float __33 = _12*_24*_41 - _14*_22*_41 +
-                _14*_21*_42 - _11*_24*_42 -
-                _12*_21*_44 + _11*_22*_44;
-    return (__33 * det) < 0;
-  }
-
-  Matrix4x4Typed &NudgeToIntegersFixedEpsilon()
-  {
-    NudgeToInteger(&_11);
-    NudgeToInteger(&_12);
-    NudgeToInteger(&_13);
-    NudgeToInteger(&_14);
-    NudgeToInteger(&_21);
-    NudgeToInteger(&_22);
-    NudgeToInteger(&_23);
-    NudgeToInteger(&_24);
-    NudgeToInteger(&_31);
-    NudgeToInteger(&_32);
-    NudgeToInteger(&_33);
-    NudgeToInteger(&_34);
-    static const float error = 1e-5f;
-    NudgeToInteger(&_41, error);
-    NudgeToInteger(&_42, error);
-    NudgeToInteger(&_43, error);
-    NudgeToInteger(&_44, error);
-    return *this;
-  }
-
-  Point4D TransposedVector(int aIndex) const
-  {
-      do { } while (0);
-      return Point4D(*((&_11)+aIndex), *((&_21)+aIndex), *((&_31)+aIndex), *((&_41)+aIndex));
-  }
-
-  void SetTransposedVector(int aIndex, Point4D &aVector)
-  {
-      do { } while (0);
-      *((&_11)+aIndex) = aVector.x;
-      *((&_21)+aIndex) = aVector.y;
-      *((&_31)+aIndex) = aVector.z;
-      *((&_41)+aIndex) = aVector.w;
-  }
-
-
-
-
-  void SetRotationFromQuaternion(const Quaternion& q)
-  {
-    const Float x2 = q.x + q.x, y2 = q.y + q.y, z2 = q.z + q.z;
-    const Float xx = q.x * x2, xy = q.x * y2, xz = q.x * z2;
-    const Float yy = q.y * y2, yz = q.y * z2, zz = q.z * z2;
-    const Float wx = q.w * x2, wy = q.w * y2, wz = q.w * z2;
-
-    _11 = 1.0f - (yy + zz);
-    _21 = xy + wz;
-    _31 = xz - wy;
-    _41 = 0.0f;
-
-    _12 = xy - wz;
-    _22 = 1.0f - (xx + zz);
-    _32 = yz + wx;
-    _42 = 0.0f;
-
-    _13 = xz + wy;
-    _23 = yz - wx;
-    _33 = 1.0f - (xx + yy);
-    _43 = 0.0f;
-
-    _14 = _42 = _43 = 0.0f;
-    _44 = 1.0f;
-  }
-
-
-  void SetNAN()
-  {
-    _11 = UnspecifiedNaN<Float>();
-    _21 = UnspecifiedNaN<Float>();
-    _31 = UnspecifiedNaN<Float>();
-    _41 = UnspecifiedNaN<Float>();
-    _12 = UnspecifiedNaN<Float>();
-    _22 = UnspecifiedNaN<Float>();
-    _32 = UnspecifiedNaN<Float>();
-    _42 = UnspecifiedNaN<Float>();
-    _13 = UnspecifiedNaN<Float>();
-    _23 = UnspecifiedNaN<Float>();
-    _33 = UnspecifiedNaN<Float>();
-    _43 = UnspecifiedNaN<Float>();
-    _14 = UnspecifiedNaN<Float>();
-    _24 = UnspecifiedNaN<Float>();
-    _34 = UnspecifiedNaN<Float>();
-    _44 = UnspecifiedNaN<Float>();
-  }
-
-  void SkewXY(double aXSkew, double aYSkew)
-  {
-
-    float tanX = SafeTangent(aXSkew);
-    float tanY = SafeTangent(aYSkew);
-    float temp;
-
-    temp = _11;
-    _11 += tanY * _21;
-    _21 += tanX * temp;
-
-    temp = _12;
-    _12 += tanY * _22;
-    _22 += tanX * temp;
-
-    temp = _13;
-    _13 += tanY * _23;
-    _23 += tanX * temp;
-
-    temp = _14;
-    _14 += tanY * _24;
-    _24 += tanX * temp;
-  }
-
-  void RotateX(double aTheta)
-  {
-
-    double cosTheta = FlushToZero(cos(aTheta));
-    double sinTheta = FlushToZero(sin(aTheta));
-
-    float temp;
-
-    temp = _21;
-    _21 = cosTheta * _21 + sinTheta * _31;
-    _31 = -sinTheta * temp + cosTheta * _31;
-
-    temp = _22;
-    _22 = cosTheta * _22 + sinTheta * _32;
-    _32 = -sinTheta * temp + cosTheta * _32;
-
-    temp = _23;
-    _23 = cosTheta * _23 + sinTheta * _33;
-    _33 = -sinTheta * temp + cosTheta * _33;
-
-    temp = _24;
-    _24 = cosTheta * _24 + sinTheta * _34;
-    _34 = -sinTheta * temp + cosTheta * _34;
-  }
-
-  void RotateY(double aTheta)
-  {
-
-    double cosTheta = FlushToZero(cos(aTheta));
-    double sinTheta = FlushToZero(sin(aTheta));
-
-    float temp;
-
-    temp = _11;
-    _11 = cosTheta * _11 + -sinTheta * _31;
-    _31 = sinTheta * temp + cosTheta * _31;
-
-    temp = _12;
-    _12 = cosTheta * _12 + -sinTheta * _32;
-    _32 = sinTheta * temp + cosTheta * _32;
-
-    temp = _13;
-    _13 = cosTheta * _13 + -sinTheta * _33;
-    _33 = sinTheta * temp + cosTheta * _33;
-
-    temp = _14;
-    _14 = cosTheta * _14 + -sinTheta * _34;
-    _34 = sinTheta * temp + cosTheta * _34;
-  }
-
-  void RotateZ(double aTheta)
-  {
-
-    double cosTheta = FlushToZero(cos(aTheta));
-    double sinTheta = FlushToZero(sin(aTheta));
-
-    float temp;
-
-    temp = _11;
-    _11 = cosTheta * _11 + sinTheta * _21;
-    _21 = -sinTheta * temp + cosTheta * _21;
-
-    temp = _12;
-    _12 = cosTheta * _12 + sinTheta * _22;
-    _22 = -sinTheta * temp + cosTheta * _22;
-
-    temp = _13;
-    _13 = cosTheta * _13 + sinTheta * _23;
-    _23 = -sinTheta * temp + cosTheta * _23;
-
-    temp = _14;
-    _14 = cosTheta * _14 + sinTheta * _24;
-    _24 = -sinTheta * temp + cosTheta * _24;
-  }
-
-
-
-
-
-  void SetRotateAxisAngle(double aX, double aY, double aZ, double aTheta)
-  {
-    Point3D vector(aX, aY, aZ);
-    if (!vector.Length()) {
-      return;
-    }
-    vector.Normalize();
-
-    double x = vector.x;
-    double y = vector.y;
-    double z = vector.z;
-
-    double cosTheta = FlushToZero(cos(aTheta));
-    double sinTheta = FlushToZero(sin(aTheta));
-
-
-    double sc = sinTheta / 2;
-
-    double sq = (1 - cosTheta) / 2;
-
-    _11 = 1 - 2 * (y * y + z * z) * sq;
-    _12 = 2 * (x * y * sq + z * sc);
-    _13 = 2 * (x * z * sq - y * sc);
-    _14 = 0.0f;
-    _21 = 2 * (x * y * sq - z * sc);
-    _22 = 1 - 2 * (x * x + z * z) * sq;
-    _23 = 2 * (y * z * sq + x * sc);
-    _24 = 0.0f;
-    _31 = 2 * (x * z * sq + y * sc);
-    _32 = 2 * (y * z * sq - x * sc);
-    _33 = 1 - 2 * (x * x + y * y) * sq;
-    _34 = 0.0f;
-    _41 = 0.0f;
-    _42 = 0.0f;
-    _43 = 0.0f;
-    _44 = 1.0f;
-  }
-
-  void Perspective(float aDepth)
-  {
-    do { } while (0);
-    _31 += -1.0/aDepth * _41;
-    _32 += -1.0/aDepth * _42;
-    _33 += -1.0/aDepth * _43;
-    _34 += -1.0/aDepth * _44;
-  }
-
-  Point3D GetNormalVector() const
-  {
-
-
-    Point3D a = TransformPoint(Point3D(0, 0, 0));
-    Point3D b = TransformPoint(Point3D(0, 1, 0));
-    Point3D c = TransformPoint(Point3D(1, 0, 0));
-
-
-    Point3D ab = b - a;
-    Point3D ac = c - a;
-
-    return ac.CrossProduct(ab);
-  }
-
-
-
-
-
-  bool HasNonTranslation() const {
-    return !gfx::FuzzyEqual(_11, 1.0) || !gfx::FuzzyEqual(_22, 1.0) ||
-           !gfx::FuzzyEqual(_12, 0.0) || !gfx::FuzzyEqual(_21, 0.0) ||
-           !gfx::FuzzyEqual(_13, 0.0) || !gfx::FuzzyEqual(_23, 0.0) ||
-           !gfx::FuzzyEqual(_31, 0.0) || !gfx::FuzzyEqual(_32, 0.0) ||
-           !gfx::FuzzyEqual(_33, 1.0);
-  }
-
-
-
-
-
-  bool HasNonIntegerTranslation() const {
-    return HasNonTranslation() ||
-      !gfx::FuzzyEqual(_41, floor(_41 + 0.5)) ||
-      !gfx::FuzzyEqual(_42, floor(_42 + 0.5)) ||
-      !gfx::FuzzyEqual(_43, floor(_43 + 0.5));
-  }
-
-
-
-
-  bool HasPerspectiveComponent() const {
-    return _14 != 0 || _24 != 0 || _34 != 0 || _44 != 1;
-  }
-
-
-
-
-  Matrix4x4 ToUnknownMatrix() const {
-    return Matrix4x4{_11, _12, _13, _14,
-                     _21, _22, _23, _24,
-                     _31, _32, _33, _34,
-                     _41, _42, _43, _44};
-  }
-  static Matrix4x4Typed FromUnknownMatrix(const Matrix4x4& aUnknown) {
-    return Matrix4x4Typed{aUnknown._11, aUnknown._12, aUnknown._13, aUnknown._14,
-                          aUnknown._21, aUnknown._22, aUnknown._23, aUnknown._24,
-                          aUnknown._31, aUnknown._32, aUnknown._33, aUnknown._34,
-                          aUnknown._41, aUnknown._42, aUnknown._43, aUnknown._44};
-  }
-};
-
-typedef Matrix4x4Typed<UnknownUnits, UnknownUnits> Matrix4x4;
-
-class Matrix5x4
-{
-public:
-  Matrix5x4()
-    : _11(1.0f), _12(0), _13(0), _14(0)
-    , _21(0), _22(1.0f), _23(0), _24(0)
-    , _31(0), _32(0), _33(1.0f), _34(0)
-    , _41(0), _42(0), _43(0), _44(1.0f)
-    , _51(0), _52(0), _53(0), _54(0)
-  {}
-  Matrix5x4(Float a11, Float a12, Float a13, Float a14,
-         Float a21, Float a22, Float a23, Float a24,
-         Float a31, Float a32, Float a33, Float a34,
-         Float a41, Float a42, Float a43, Float a44,
-         Float a51, Float a52, Float a53, Float a54)
-    : _11(a11), _12(a12), _13(a13), _14(a14)
-    , _21(a21), _22(a22), _23(a23), _24(a24)
-    , _31(a31), _32(a32), _33(a33), _34(a34)
-    , _41(a41), _42(a42), _43(a43), _44(a44)
-    , _51(a51), _52(a52), _53(a53), _54(a54)
-  {}
-
-  bool operator==(const Matrix5x4 &o) const
-  {
-    return _11 == o._11 && _12 == o._12 && _13 == o._13 && _14 == o._14 &&
-           _21 == o._21 && _22 == o._22 && _23 == o._23 && _24 == o._24 &&
-           _31 == o._31 && _32 == o._32 && _33 == o._33 && _34 == o._34 &&
-           _41 == o._41 && _42 == o._42 && _43 == o._43 && _44 == o._44 &&
-           _51 == o._51 && _52 == o._52 && _53 == o._53 && _54 == o._54;
-  }
-
-  bool operator!=(const Matrix5x4 &aMatrix) const
-  {
-    return !(*this == aMatrix);
-  }
-
-  Matrix5x4 operator*(const Matrix5x4 &aMatrix) const
-  {
-    Matrix5x4 resultMatrix;
-
-    resultMatrix._11 = this->_11 * aMatrix._11 + this->_12 * aMatrix._21 + this->_13 * aMatrix._31 + this->_14 * aMatrix._41;
-    resultMatrix._12 = this->_11 * aMatrix._12 + this->_12 * aMatrix._22 + this->_13 * aMatrix._32 + this->_14 * aMatrix._42;
-    resultMatrix._13 = this->_11 * aMatrix._13 + this->_12 * aMatrix._23 + this->_13 * aMatrix._33 + this->_14 * aMatrix._43;
-    resultMatrix._14 = this->_11 * aMatrix._14 + this->_12 * aMatrix._24 + this->_13 * aMatrix._34 + this->_14 * aMatrix._44;
-    resultMatrix._21 = this->_21 * aMatrix._11 + this->_22 * aMatrix._21 + this->_23 * aMatrix._31 + this->_24 * aMatrix._41;
-    resultMatrix._22 = this->_21 * aMatrix._12 + this->_22 * aMatrix._22 + this->_23 * aMatrix._32 + this->_24 * aMatrix._42;
-    resultMatrix._23 = this->_21 * aMatrix._13 + this->_22 * aMatrix._23 + this->_23 * aMatrix._33 + this->_24 * aMatrix._43;
-    resultMatrix._24 = this->_21 * aMatrix._14 + this->_22 * aMatrix._24 + this->_23 * aMatrix._34 + this->_24 * aMatrix._44;
-    resultMatrix._31 = this->_31 * aMatrix._11 + this->_32 * aMatrix._21 + this->_33 * aMatrix._31 + this->_34 * aMatrix._41;
-    resultMatrix._32 = this->_31 * aMatrix._12 + this->_32 * aMatrix._22 + this->_33 * aMatrix._32 + this->_34 * aMatrix._42;
-    resultMatrix._33 = this->_31 * aMatrix._13 + this->_32 * aMatrix._23 + this->_33 * aMatrix._33 + this->_34 * aMatrix._43;
-    resultMatrix._34 = this->_31 * aMatrix._14 + this->_32 * aMatrix._24 + this->_33 * aMatrix._34 + this->_34 * aMatrix._44;
-    resultMatrix._41 = this->_41 * aMatrix._11 + this->_42 * aMatrix._21 + this->_43 * aMatrix._31 + this->_44 * aMatrix._41;
-    resultMatrix._42 = this->_41 * aMatrix._12 + this->_42 * aMatrix._22 + this->_43 * aMatrix._32 + this->_44 * aMatrix._42;
-    resultMatrix._43 = this->_41 * aMatrix._13 + this->_42 * aMatrix._23 + this->_43 * aMatrix._33 + this->_44 * aMatrix._43;
-    resultMatrix._44 = this->_41 * aMatrix._14 + this->_42 * aMatrix._24 + this->_43 * aMatrix._34 + this->_44 * aMatrix._44;
-    resultMatrix._51 = this->_51 * aMatrix._11 + this->_52 * aMatrix._21 + this->_53 * aMatrix._31 + this->_54 * aMatrix._41 + aMatrix._51;
-    resultMatrix._52 = this->_51 * aMatrix._12 + this->_52 * aMatrix._22 + this->_53 * aMatrix._32 + this->_54 * aMatrix._42 + aMatrix._52;
-    resultMatrix._53 = this->_51 * aMatrix._13 + this->_52 * aMatrix._23 + this->_53 * aMatrix._33 + this->_54 * aMatrix._43 + aMatrix._53;
-    resultMatrix._54 = this->_51 * aMatrix._14 + this->_52 * aMatrix._24 + this->_53 * aMatrix._34 + this->_54 * aMatrix._44 + aMatrix._54;
-
-    return resultMatrix;
-  }
-
-  Matrix5x4& operator*=(const Matrix5x4 &aMatrix)
-  {
-    *this = *this * aMatrix;
-    return *this;
-  }
-
-  union {
-    struct {
-      Float _11, _12, _13, _14;
-      Float _21, _22, _23, _24;
-      Float _31, _32, _33, _34;
-      Float _41, _42, _43, _44;
-      Float _51, _52, _53, _54;
-    };
-    Float components[20];
-  };
-};
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h"
-typedef struct _cairo_surface cairo_surface_t;
-typedef struct _cairo_user_data_key cairo_user_data_key_t;
-
-typedef void (*thebes_destroy_func_t) (void *data);
-
-
-
-
-
-typedef double gfxFloat;
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxTypes.h"
-enum class gfxBreakPriority {
-  eNoBreak = 0,
-  eWordWrapBreak,
-  eNormalBreak
-};
-
-enum class gfxSurfaceType {
-  Image,
-  PDF,
-  PS,
-  Xlib,
-  Xcb,
-  Glitz,
-  Quartz,
-  Win32,
-  BeOS,
-  DirectFB,
-  SVG,
-  OS2,
-  Win32Printing,
-  QuartzImage,
-  Script,
-  QPainter,
-  Recording,
-  VG,
-  GL,
-  DRM,
-  Tee,
-  XML,
-  Skia,
-  Subsurface,
-  Max
-};
-
-enum class gfxContentType {
-  COLOR = 0x1000,
-  ALPHA = 0x2000,
-  COLOR_ALPHA = 0x3000,
-  SENTINEL = 0xffff
-};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxPoint.h" 2
-
-struct gfxSize : public mozilla::gfx::BaseSize<gfxFloat, gfxSize> {
-    typedef mozilla::gfx::BaseSize<gfxFloat, gfxSize> Super;
-
-    gfxSize() : Super() {}
-    gfxSize(gfxFloat aWidth, gfxFloat aHeight) : Super(aWidth, aHeight) {}
-                 gfxSize(const mozilla::gfx::IntSize& aSize) : Super(aSize.width, aSize.height) {}
-};
-
-struct gfxPoint : public mozilla::gfx::BasePoint<gfxFloat, gfxPoint> {
-    typedef mozilla::gfx::BasePoint<gfxFloat, gfxPoint> Super;
-
-    gfxPoint() : Super() {}
-    gfxPoint(gfxFloat aX, gfxFloat aY) : Super(aX, aY) {}
-                 gfxPoint(const nsIntPoint& aPoint) : Super(aPoint.x, aPoint.y) {}
-
-    bool WithinEpsilonOf(const gfxPoint& aPoint, gfxFloat aEpsilon) {
-        return fabs(aPoint.x - x) < aEpsilon && fabs(aPoint.y - y) < aEpsilon;
-    }
-
-    void Transform(const mozilla::gfx::Matrix4x4 &aMatrix)
-    {
-
-      double px = x;
-      double py = y;
-
-      x = px * aMatrix._11 + py * aMatrix._21 + aMatrix._41;
-      y = px * aMatrix._12 + py * aMatrix._22 + aMatrix._42;
-
-      double w = px * aMatrix._14 + py * aMatrix._24 + aMatrix._44;
-      x /= w;
-      y /= w;
-    }
-};
-
-inline gfxPoint
-operator*(const gfxPoint& aPoint, const gfxSize& aSize)
-{
-  return gfxPoint(aPoint.x * aSize.width, aPoint.y * aSize.height);
-}
-
-inline gfxPoint
-operator/(const gfxPoint& aPoint, const gfxSize& aSize)
-{
-  return gfxPoint(aPoint.x / aSize.width, aPoint.y / aSize.height);
-}
-
-inline gfxSize
-operator/(gfxFloat aValue, const gfxSize& aSize)
-{
-  return gfxSize(aValue / aSize.width, aValue / aSize.height);
-}
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionDisplay.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionDisplay.h"
-class nsISelectionDisplay : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    DISPLAY_TEXT = 1,
-    DISPLAY_IMAGES = 2,
-    DISPLAY_FRAMES = 4,
-    DISPLAY_ALL = 7
-  };
-
-
-  virtual nsresult SetSelectionFlags(int16_t toggle) = 0;
-
-
-  virtual nsresult GetSelectionFlags(int16_t *_retval) = 0;
-
-};
-
-  template<typename T> struct nsISelectionDisplay::COMTypeInfo<nsISelectionDisplay, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISelectionDisplay::COMTypeInfo<nsISelectionDisplay, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0ddf9e1c, 0x1dd2, 0x11b2, { 0xa1, 0x83, 0x90, 0x8a, 0x08, 0xaa, 0x75, 0xae }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h" 2
-
-
-
-
-
-
-typedef short SelectionRegion;
-class nsIContent;
-
-class nsIDOMNode;
-
-class nsISelection;
-
-class nsISelectionDisplay;
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
-class nsISelectionController : public nsISelectionDisplay {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    SELECTION_NONE = 0,
-    SELECTION_NORMAL = 1,
-    SELECTION_SPELLCHECK = 2,
-    SELECTION_IME_RAWINPUT = 4,
-    SELECTION_IME_SELECTEDRAWTEXT = 8,
-    SELECTION_IME_CONVERTEDTEXT = 16,
-    SELECTION_IME_SELECTEDCONVERTEDTEXT = 32,
-    SELECTION_ACCESSIBILITY = 64,
-    SELECTION_FIND = 128,
-    SELECTION_URLSECONDARY = 256,
-    SELECTION_URLSTRIKEOUT = 512,
-    NUM_SELECTIONTYPES = 11,
-    SELECTION_ANCHOR_REGION = 0,
-    SELECTION_FOCUS_REGION = 1,
-    SELECTION_WHOLE_SELECTION = 2,
-    NUM_SELECTION_REGIONS = 3,
-    SELECTION_OFF = 0,
-    SELECTION_HIDDEN = 1,
-    SELECTION_ON = 2,
-    SELECTION_DISABLED = 3,
-    SELECTION_ATTENTION = 4
-  };
-
-
-  virtual nsresult SetDisplaySelection(int16_t toggle) = 0;
-
-
-  virtual nsresult GetDisplaySelection(int16_t *_retval) = 0;
-
-
-  virtual nsresult GetSelection(int16_t type, nsISelection * *_retval) = 0;
-
-  enum {
-    SCROLL_SYNCHRONOUS = 2,
-    SCROLL_FIRST_ANCESTOR_ONLY = 4,
-    SCROLL_CENTER_VERTICALLY = 16,
-    SCROLL_OVERFLOW_HIDDEN = 32,
-    SCROLL_FOR_CARET_MOVE = 64
-  };
-
-
-  virtual nsresult ScrollSelectionIntoView(int16_t type, int16_t region, int16_t flags) = 0;
-
-
-  virtual nsresult RepaintSelection(int16_t type) = 0;
-
-
-  virtual nsresult SetCaretEnabled(bool enabled) = 0;
-
-
-  virtual nsresult SetCaretReadOnly(bool readOnly) = 0;
-
-
-  virtual nsresult GetCaretEnabled(bool *_retval) = 0;
-
-
-  virtual nsresult GetCaretVisible(bool *aCaretVisible) = 0;
-
-
-  virtual nsresult SetCaretVisibilityDuringSelection(bool visibility) = 0;
-
-
-  virtual nsresult CharacterMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult PhysicalMove(int16_t direction, int16_t amount, bool extend) = 0;
-
-  enum {
-    MOVE_LEFT = 0,
-    MOVE_RIGHT = 1,
-    MOVE_UP = 2,
-    MOVE_DOWN = 3
-  };
-
-
-  virtual nsresult CharacterExtendForDelete(void) = 0;
-
-
-  virtual nsresult CharacterExtendForBackspace(void) = 0;
-
-
-  virtual nsresult WordMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult WordExtendForDelete(bool forward) = 0;
-
-
-  virtual nsresult LineMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult IntraLineMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult PageMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult CompleteScroll(bool forward) = 0;
-
-
-  virtual nsresult CompleteMove(bool forward, bool extend) = 0;
-
-
-  virtual nsresult ScrollPage(bool forward) = 0;
-
-
-  virtual nsresult ScrollLine(bool forward) = 0;
-
-
-  virtual nsresult ScrollCharacter(bool right) = 0;
-
-
-  virtual nsresult SelectAll(void) = 0;
-
-
-  virtual nsresult CheckVisibility(nsIDOMNode *node, int16_t startOffset, int16_t endOffset, bool *_retval) = 0;
-
-
-  virtual nsresult CheckVisibilityContent(nsIContent *node, int16_t startOffset, int16_t endOffset, bool *_retval) = 0;
-
-};
-
-  template<typename T> struct nsISelectionController::COMTypeInfo<nsISelectionController, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISelectionController::COMTypeInfo<nsISelectionController, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3801c9d4, 0x8e69, 0x4bfc, { 0x9e, 0xdb, 0xb5, 0x82, 0x78, 0x62, 0x1f, 0x8f }};
-# 484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISelectionController.h"
-namespace mozilla {
-typedef short RawSelectionType;
-enum class SelectionType : RawSelectionType
-{
-  eInvalid = -1,
-  eNone = nsISelectionController::SELECTION_NONE,
-  eNormal = nsISelectionController::SELECTION_NORMAL,
-  eSpellCheck = nsISelectionController::SELECTION_SPELLCHECK,
-  eIMERawClause = nsISelectionController::SELECTION_IME_RAWINPUT,
-  eIMESelectedRawClause = nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT,
-  eIMEConvertedClause = nsISelectionController::SELECTION_IME_CONVERTEDTEXT,
-  eIMESelectedClause =
-    nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT,
-  eAccessibility = nsISelectionController::SELECTION_ACCESSIBILITY,
-  eFind = nsISelectionController::SELECTION_FIND,
-  eURLSecondary = nsISelectionController::SELECTION_URLSECONDARY,
-  eURLStrikeout = nsISelectionController::SELECTION_URLSTRIKEOUT,
-};
-
-
-
-
-
-enum : size_t
-{
-
-  kSelectionTypeCount = nsISelectionController::NUM_SELECTIONTYPES,
-
-  kPresentSelectionTypeCount = kSelectionTypeCount - 1
-};
-const char* ToChar(SelectionType aSelectionType);
-SelectionType ToSelectionType(RawSelectionType aRawSelectionType);
-RawSelectionType ToRawSelectionType(SelectionType aSelectionType);
-bool operator &(SelectionType aSelectionType,
-                RawSelectionType aRawSelectionTypes);
-}
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameManagerBase.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameManagerBase.h"
-class nsIFrame;
-class nsIPresShell;
-
-class nsFrameManagerBase
-{
-public:
-  nsFrameManagerBase();
-
-  bool IsDestroyingFrames() { return mIsDestroyingFrames; }
-
-
-
-
-
-
-  nsIFrame* GetRootFrame() const { return mRootFrame; }
-  void SetRootFrame(nsIFrame* aRootFrame)
-  {
-    do { } while(0);
-    mRootFrame = aRootFrame;
-  }
-
-protected:
-  class UndisplayedMap;
-
-
-  nsIPresShell* mPresShell;
-  nsIFrame* mRootFrame;
-  PLDHashTable mPlaceholderMap;
-  UndisplayedMap* mUndisplayedMap;
-  UndisplayedMap* mDisplayContentsMap;
-  bool mIsDestroyingFrames;
-};
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
-typedef mozilla::gfx::IntRect nsIntRect;
-
-struct nsRect :
-  public mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> {
-  typedef mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> Super;
-
-  static void VERIFY_COORD(nscoord aValue) { ::VERIFY_COORD(aValue); }
-
-
-  nsRect() : Super()
-  {
-                          ;
-  }
-  nsRect(const nsRect& aRect) : Super(aRect)
-  {
-                          ;
-  }
-  nsRect(const nsPoint& aOrigin, const nsSize &aSize) : Super(aOrigin, aSize)
-  {
-                          ;
-  }
-  nsRect(nscoord aX, nscoord aY, nscoord aWidth, nscoord aHeight) :
-      Super(aX, aY, aWidth, aHeight)
-  {
-                          ;
-  }
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
-  __attribute__ ((warn_unused_result)) nsRect SaturatingUnion(const nsRect& aRect) const
-  {
-    if (IsEmpty()) {
-      return aRect;
-    } else if (aRect.IsEmpty()) {
-      return *static_cast<const nsRect*>(this);
-    } else {
-      return SaturatingUnionEdges(aRect);
-    }
-  }
-
-  __attribute__ ((warn_unused_result)) nsRect SaturatingUnionEdges(const nsRect& aRect) const
-  {
-
-
-
-    nsRect result;
-    result.x = std::min(aRect.x, x);
-    int64_t w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
-    if ((__builtin_expect(!!(w > nscoord(1 << 30)), 0))) {
-
-      result.x = std::max(result.x, (-nscoord(1 << 30)) / 2);
-      w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
-      if ((__builtin_expect(!!(w > nscoord(1 << 30)), 0))) {
-        w = nscoord(1 << 30);
-      }
-    }
-    result.width = nscoord(w);
-
-    result.y = std::min(aRect.y, y);
-    int64_t h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
-    if ((__builtin_expect(!!(h > nscoord(1 << 30)), 0))) {
-
-      result.y = std::max(result.y, (-nscoord(1 << 30)) / 2);
-      h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
-      if ((__builtin_expect(!!(h > nscoord(1 << 30)), 0))) {
-        h = nscoord(1 << 30);
-      }
-    }
-    result.height = nscoord(h);
-    return result;
-
-  }
-
-
-
-  __attribute__ ((warn_unused_result)) nsRect UnionEdges(const nsRect& aRect) const
-  {
-    return SaturatingUnionEdges(aRect);
-  }
-  void UnionRectEdges(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    *this = aRect1.UnionEdges(aRect2);
-  }
-  __attribute__ ((warn_unused_result)) nsRect Union(const nsRect& aRect) const
-  {
-    return SaturatingUnion(aRect);
-  }
-  void UnionRect(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    *this = aRect1.Union(aRect2);
-  }
-
-
-  void SaturatingUnionRect(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    *this = aRect1.SaturatingUnion(aRect2);
-  }
-  void SaturatingUnionRectEdges(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    *this = aRect1.SaturatingUnionEdges(aRect2);
-  }
-
-
-  bool Overflows() const;
-# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRect.h"
-  __attribute__ ((warn_unused_result)) inline nsRect
-    ScaleToOtherAppUnitsRoundOut(int32_t aFromAPP, int32_t aToAPP) const;
-  __attribute__ ((warn_unused_result)) inline nsRect
-    ScaleToOtherAppUnitsRoundIn(int32_t aFromAPP, int32_t aToAPP) const;
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ScaleToNearestPixels(float aXScale, float aYScale,
-                       nscoord aAppUnitsPerPixel) const;
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ToNearestPixels(nscoord aAppUnitsPerPixel) const;
-
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ScaleToOutsidePixels(float aXScale, float aYScale,
-                       nscoord aAppUnitsPerPixel) const;
-
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ToOutsidePixels(nscoord aAppUnitsPerPixel) const;
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ScaleToInsidePixels(float aXScale, float aYScale,
-                      nscoord aAppUnitsPerPixel) const;
-
-  __attribute__ ((warn_unused_result)) inline mozilla::gfx::IntRect
-  ToInsidePixels(nscoord aAppUnitsPerPixel) const;
-
-
-  bool operator==(const nsRect& aRect) const
-  {
-    return IsEqualEdges(aRect);
-  }
-
-  __attribute__ ((warn_unused_result)) inline nsRect RemoveResolution(const float aResolution) const;
-};
-
-
-
-
-
-inline nsRect
-nsRect::ScaleToOtherAppUnitsRoundOut(int32_t aFromAPP, int32_t aToAPP) const
-{
-  if (aFromAPP == aToAPP) {
-    return *this;
-  }
-
-  nsRect rect;
-  nscoord right = NSToCoordCeil(NSCoordScale(XMost(), aFromAPP, aToAPP));
-  nscoord bottom = NSToCoordCeil(NSCoordScale(YMost(), aFromAPP, aToAPP));
-  rect.x = NSToCoordFloor(NSCoordScale(x, aFromAPP, aToAPP));
-  rect.y = NSToCoordFloor(NSCoordScale(y, aFromAPP, aToAPP));
-  rect.width = (right - rect.x);
-  rect.height = (bottom - rect.y);
-
-  return rect;
-}
-
-inline nsRect
-nsRect::ScaleToOtherAppUnitsRoundIn(int32_t aFromAPP, int32_t aToAPP) const
-{
-  if (aFromAPP == aToAPP) {
-    return *this;
-  }
-
-  nsRect rect;
-  nscoord right = NSToCoordFloor(NSCoordScale(XMost(), aFromAPP, aToAPP));
-  nscoord bottom = NSToCoordFloor(NSCoordScale(YMost(), aFromAPP, aToAPP));
-  rect.x = NSToCoordCeil(NSCoordScale(x, aFromAPP, aToAPP));
-  rect.y = NSToCoordCeil(NSCoordScale(y, aFromAPP, aToAPP));
-  rect.width = (right - rect.x);
-  rect.height = (bottom - rect.y);
-
-  return rect;
-}
-
-
-inline mozilla::gfx::IntRect
-nsRect::ScaleToNearestPixels(float aXScale, float aYScale,
-                             nscoord aAppUnitsPerPixel) const
-{
-  mozilla::gfx::IntRect rect;
-  rect.x = NSToIntRoundUp(NSAppUnitsToDoublePixels(x, aAppUnitsPerPixel) * aXScale);
-  rect.y = NSToIntRoundUp(NSAppUnitsToDoublePixels(y, aAppUnitsPerPixel) * aYScale);
-
-  rect.width = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(XMost(),
-                               aAppUnitsPerPixel) * aXScale) - rect.x);
-  rect.height = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(YMost(),
-                               aAppUnitsPerPixel) * aYScale) - rect.y);
-  return rect;
-}
-
-
-inline mozilla::gfx::IntRect
-nsRect::ScaleToOutsidePixels(float aXScale, float aYScale,
-                             nscoord aAppUnitsPerPixel) const
-{
-  mozilla::gfx::IntRect rect;
-  rect.x = NSToIntFloor(NSAppUnitsToFloatPixels(x, float(aAppUnitsPerPixel)) * aXScale);
-  rect.y = NSToIntFloor(NSAppUnitsToFloatPixels(y, float(aAppUnitsPerPixel)) * aYScale);
-
-  rect.width = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(XMost(),
-                            float(aAppUnitsPerPixel)) * aXScale) - rect.x);
-  rect.height = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(YMost(),
-                            float(aAppUnitsPerPixel)) * aYScale) - rect.y);
-  return rect;
-}
-
-
-inline mozilla::gfx::IntRect
-nsRect::ScaleToInsidePixels(float aXScale, float aYScale,
-                            nscoord aAppUnitsPerPixel) const
-{
-  mozilla::gfx::IntRect rect;
-  rect.x = NSToIntCeil(NSAppUnitsToFloatPixels(x, float(aAppUnitsPerPixel)) * aXScale);
-  rect.y = NSToIntCeil(NSAppUnitsToFloatPixels(y, float(aAppUnitsPerPixel)) * aYScale);
-
-  rect.width = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(XMost(),
-                             float(aAppUnitsPerPixel)) * aXScale) - rect.x);
-  rect.height = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(YMost(),
-                             float(aAppUnitsPerPixel)) * aYScale) - rect.y);
-  return rect;
-}
-
-inline mozilla::gfx::IntRect
-nsRect::ToNearestPixels(nscoord aAppUnitsPerPixel) const
-{
-  return ScaleToNearestPixels(1.0f, 1.0f, aAppUnitsPerPixel);
-}
-
-inline mozilla::gfx::IntRect
-nsRect::ToOutsidePixels(nscoord aAppUnitsPerPixel) const
-{
-  return ScaleToOutsidePixels(1.0f, 1.0f, aAppUnitsPerPixel);
-}
-
-inline mozilla::gfx::IntRect
-nsRect::ToInsidePixels(nscoord aAppUnitsPerPixel) const
-{
-  return ScaleToInsidePixels(1.0f, 1.0f, aAppUnitsPerPixel);
-}
-
-inline nsRect
-nsRect::RemoveResolution(const float aResolution) const
-{
-  do { } while (0);
-  nsRect rect;
-  rect.x = NSToCoordRound(NSCoordToFloat(x) / aResolution);
-  rect.y = NSToCoordRound(NSCoordToFloat(y) / aResolution);
-
-
-  if (width == 1 && height == 1) {
-    rect.width = rect.height = 1;
-  } else {
-    rect.width = NSToCoordCeil(NSCoordToFloat(width) / aResolution);
-    rect.height = NSToCoordCeil(NSCoordToFloat(height) / aResolution);
-  }
-
-  return rect;
-}
-
-const mozilla::gfx::IntRect& GetMaxSizedIntRect();
-
-
-template<class units>
-nsRect
-ToAppUnits(const mozilla::gfx::IntRectTyped<units>& aRect, nscoord aAppUnitsPerPixel)
-{
-  return nsRect(NSIntPixelsToAppUnits(aRect.x, aAppUnitsPerPixel),
-                NSIntPixelsToAppUnits(aRect.y, aAppUnitsPerPixel),
-                NSIntPixelsToAppUnits(aRect.width, aAppUnitsPerPixel),
-                NSIntPixelsToAppUnits(aRect.height, aAppUnitsPerPixel));
-}
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWeakReference.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWeakReference.h"
-class nsWeakReference;
-
-class nsSupportsWeakReference : public nsISupportsWeakReference
-{
-public:
-  nsSupportsWeakReference() : mProxy(0) {}
-
-  virtual nsresult GetWeakReference(nsIWeakReference * *_retval) override;
-
-protected:
-  inline ~nsSupportsWeakReference();
-
-private:
-  friend class nsWeakReference;
-
-
-
-  void NoticeProxyDestruction() { mProxy = nullptr; }
-
-  nsWeakReference* mProxy;
-
-protected:
-
-  void ClearWeakReferences();
-  bool HasWeakReferences() const { return !!mProxy; }
-};
-
-inline
-nsSupportsWeakReference::~nsSupportsWeakReference()
-{
-  ClearWeakReferences();
-}
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h"
-template<class KeyClass, class T>
-class nsClassHashtable
-  : public nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>
-{
-public:
-  typedef typename KeyClass::KeyType KeyType;
-  typedef T* UserDataType;
-  typedef nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*> base_type;
-
-  using base_type::IsEmpty;
-
-  nsClassHashtable() {}
-  explicit nsClassHashtable(uint32_t aInitLength)
-    : nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>(aInitLength)
-  {
-  }
-
-
-
-
-
-  template<typename... Args>
-  UserDataType LookupOrAdd(KeyType aKey, Args&&... aConstructionArgs);
-
-
-
-
-
-  bool Get(KeyType aKey, UserDataType* aData) const;
-
-
-
-
-
-  UserDataType Get(KeyType aKey) const;
-# 70 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsClassHashtable.h"
-  void RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut);
-};
-
-
-
-
-
-template<class KeyClass, class T>
-template<typename... Args>
-T*
-nsClassHashtable<KeyClass, T>::LookupOrAdd(KeyType aKey,
-                                           Args&&... aConstructionArgs)
-{
-  typename base_type::EntryType* ent = this->PutEntry(aKey);
-  if (!ent->mData) {
-    ent->mData = new T(mozilla::Forward<Args>(aConstructionArgs)...);
-  }
-  return ent->mData;
-}
-
-template<class KeyClass, class T>
-bool
-nsClassHashtable<KeyClass, T>::Get(KeyType aKey, T** aRetVal) const
-{
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-
-  if (ent) {
-    if (aRetVal) {
-      *aRetVal = ent->mData;
-    }
-
-    return true;
-  }
-
-  if (aRetVal) {
-    *aRetVal = nullptr;
-  }
-
-  return false;
-}
-
-template<class KeyClass, class T>
-T*
-nsClassHashtable<KeyClass, T>::Get(KeyType aKey) const
-{
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-  if (!ent) {
-    return nullptr;
-  }
-
-  return ent->mData;
-}
-
-template<class KeyClass, class T>
-void
-nsClassHashtable<KeyClass, T>::RemoveAndForget(KeyType aKey, nsAutoPtr<T>& aOut)
-{
-  aOut = nullptr;
-
-  typename base_type::EntryType* ent = this->GetEntry(aKey);
-  if (!ent) {
-    return;
-  }
-
-
-  aOut = mozilla::Move(ent->mData);
-
-  this->Remove(aKey);
-}
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h"
-namespace mozilla {
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaAllocator.h"
-template<size_t ArenaSize, size_t Alignment=1>
-class ArenaAllocator
-{
-public:
-  constexpr ArenaAllocator()
-    : mHead()
-    , mCurrent(nullptr)
-  {
-     static_assert(mozilla::tl::FloorLog2<Alignment>::value ==
-                   mozilla::tl::CeilingLog2<Alignment>::value,
-                  "ArenaAllocator alignment must be a power of two");
-  }
-
-  ArenaAllocator(const ArenaAllocator&) = delete;
-  ArenaAllocator& operator=(const ArenaAllocator&) = delete;
-
-
-
-
-
-  ~ArenaAllocator()
-  {
-    Clear();
-  }
-
-
-
-
-
-
-  __attribute__((always_inline)) inline void* Allocate(size_t aSize, const fallible_t&)
-  {
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(aSize)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aSize))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aSize" ") (" "Allocation size must be non-zero" ")"); do { *((volatile int*) __null) = 71; ::abort(); } while (0); } } while (0);
-    return InternalAllocate(AlignedSize(aSize));
-  }
-
-  void* Allocate(size_t aSize)
-  {
-    void* p = Allocate(aSize, fallible);
-    if ((__builtin_expect(!!(!p), 0))) {
-      NS_ABORT_OOM(std::max(aSize, ArenaSize));
-    }
-
-    return p;
-  }
-
-
-
-
-
-
-
-  void Clear()
-  {
-
-    auto a = mHead.next;
-    while (a) {
-      auto tmp = a;
-      a = a->next;
-      free(tmp);
-    }
-
-
-    mHead.next = nullptr;
-    mCurrent = nullptr;
-  }
-
-
-
-
-  static constexpr size_t AlignedSize(size_t aSize)
-  {
-    return (aSize + (Alignment - 1)) & ~(Alignment - 1);
-  }
-
-  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
-  {
-    size_t s = 0;
-    for (auto arena = mHead.next; arena; arena = arena->next) {
-      s += aMallocSizeOf(arena);
-    }
-
-    return s;
-  }
-
-private:
-  struct ArenaHeader
-  {
-
-
-
-    uintptr_t offset;
-
-
-
-    uintptr_t tail;
-  };
-
-  struct ArenaChunk
-  {
-    constexpr ArenaChunk() : header{0, 0}, next(nullptr) {}
-
-    explicit ArenaChunk(size_t aSize)
-      : header{AlignedSize(uintptr_t(this + 1)), uintptr_t(this) + aSize}
-      , next(nullptr)
-    {
-    }
-
-    ArenaHeader header;
-    ArenaChunk* next;
-
-
-
-
-    void* Allocate(size_t aSize)
-    {
-      do { } while (0);
-      char* p = reinterpret_cast<char*>(header.offset);
-      header.offset += aSize;
-      do {} while (0);
-      return p;
-    }
-
-
-
-
-    size_t Available() const {
-      return header.tail - header.offset;
-    }
-  };
-
-
-
-
-  ArenaChunk* AllocateChunk(size_t aSize)
-  {
-    static const size_t kOffset = AlignedSize(sizeof(ArenaChunk));
-    do { } while (0);
-
-    const size_t chunkSize = aSize + kOffset;
-    void* p = malloc(chunkSize);
-    if (!p) {
-      return nullptr;
-    }
-
-    ArenaChunk* arena = new (KnownNotNull, p) ArenaChunk(chunkSize);
-    do {} while (0);
-
-
-
-    arena->next = mHead.next;
-    mHead.next = arena;
-
-
-
-
-    if (aSize == ArenaSize - kOffset) {
-      mCurrent = arena;
-    }
-
-    return arena;
-  }
-
-  __attribute__((always_inline)) inline void* InternalAllocate(size_t aSize)
-  {
-    static_assert(ArenaSize > AlignedSize(sizeof(ArenaChunk)),
-                  "Arena size must be greater than the header size");
-
-    static const size_t kMaxArenaCapacity =
-        ArenaSize - AlignedSize(sizeof(ArenaChunk));
-
-    if (mCurrent && aSize <= mCurrent->Available()) {
-      return mCurrent->Allocate(aSize);
-    }
-
-    ArenaChunk* arena = AllocateChunk(std::max(kMaxArenaCapacity, aSize));
-    return arena ? arena->Allocate(aSize) : nullptr;
-  }
-
-  ArenaChunk mHead;
-  ArenaChunk* mCurrent;
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h"
-class nsPresArena;
-
-namespace mozilla {
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArenaRefPtr.h"
-template<typename T>
-class ArenaRefPtr
-{
-  friend class ::nsPresArena;
-
-public:
-  ArenaRefPtr()
-  {
-    AssertValidType();
-  }
-
-  template<typename I>
-               ArenaRefPtr(already_AddRefed<I>& aRhs)
-  {
-    AssertValidType();
-    assign(aRhs);
-  }
-
-  template<typename I>
-               ArenaRefPtr(already_AddRefed<I>&& aRhs)
-  {
-    AssertValidType();
-    assign(aRhs);
-  }
-
-               ArenaRefPtr(T* aRhs)
-  {
-    AssertValidType();
-    assign(aRhs);
-  }
-
-  template<typename I>
-  ArenaRefPtr<T>& operator=(already_AddRefed<I>& aRhs)
-  {
-    assign(aRhs);
-    return *this;
-  }
-
-  template<typename I>
-  ArenaRefPtr<T>& operator=(already_AddRefed<I>&& aRhs)
-  {
-    assign(aRhs);
-    return *this;
-  }
-
-  ArenaRefPtr<T>& operator=(T* aRhs)
-  {
-    assign(aRhs);
-    return *this;
-  }
-
-  ~ArenaRefPtr() { assign(nullptr); }
-
-  operator T*() const & { return get(); }
-  operator T*() const && = delete;
-  explicit operator bool() const { return !!mPtr; }
-  bool operator!() const { return !mPtr; }
-  T* operator->() const { return mPtr.operator->(); }
-  T& operator*() const { return *get(); }
-
-  T* get() const { return mPtr; }
-
-private:
-  void AssertValidType();
-
-
-
-
-
-
-
-  void ClearWithoutDeregistering()
-  {
-    mPtr = nullptr;
-  }
-
-  template<typename I>
-  void assign(already_AddRefed<I>& aSmartPtr)
-  {
-    RefPtr<T> newPtr(aSmartPtr);
-    assignFrom(newPtr);
-  }
-
-  template<typename I>
-  void assign(already_AddRefed<I>&& aSmartPtr)
-  {
-    RefPtr<T> newPtr(aSmartPtr);
-    assignFrom(newPtr);
-  }
-
-  void assign(T* aPtr) { assignFrom(aPtr); }
-
-  template<typename I>
-  void assignFrom(I& aPtr)
-  {
-    if (aPtr == mPtr) {
-      return;
-    }
-    bool sameArena = mPtr && aPtr && mPtr->Arena() == aPtr->Arena();
-    if (mPtr && !sameArena) {
-      do { } while (0);
-      mPtr->Arena()->DeregisterArenaRefPtr(this);
-    }
-    mPtr = Move(aPtr);
-    if (mPtr && !sameArena) {
-      do { } while (0);
-      mPtr->Arena()->RegisterArenaRefPtr(this);
-    }
-  }
-
-  RefPtr<T> mPtr;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
-struct nsArenaMemoryStats;
-
-class nsPresArena {
-public:
-  nsPresArena();
-  ~nsPresArena();
-
-
-
-
-  void* AllocateBySize(size_t aSize)
-  {
-    return Allocate(uint32_t(aSize) |
-                    uint32_t(mozilla::eArenaObjectID_NON_OBJECT_MARKER), aSize);
-  }
-  void FreeBySize(size_t aSize, void* aPtr)
-  {
-    Free(uint32_t(aSize) |
-         uint32_t(mozilla::eArenaObjectID_NON_OBJECT_MARKER), aPtr);
-  }
-
-
-
-
-
-  void* AllocateByFrameID(nsQueryFrame::FrameIID aID, size_t aSize)
-  {
-    return Allocate(aID, aSize);
-  }
-  void FreeByFrameID(nsQueryFrame::FrameIID aID, void* aPtr)
-  {
-    Free(aID, aPtr);
-  }
-
-
-
-
-
-  void* AllocateByObjectID(mozilla::ArenaObjectID aID, size_t aSize)
-  {
-    return Allocate(aID, aSize);
-  }
-  void FreeByObjectID(mozilla::ArenaObjectID aID, void* aPtr)
-  {
-    Free(aID, aPtr);
-  }
-# 82 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresArena.h"
-  template<typename T>
-  void RegisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr);
-
-
-
-
-
-  template<typename T>
-  void DeregisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
-  {
-    do { } while (0);
-    mArenaRefPtrs.Remove(aPtr);
-  }
-
-
-
-
-
-
-  void ClearArenaRefPtrs();
-
-
-
-
-
-
-
-  void ClearArenaRefPtrs(mozilla::ArenaObjectID aObjectID);
-
-
-
-
-
-  void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
-                              nsArenaMemoryStats* aArenaStats);
-
-private:
-  void* Allocate(uint32_t aCode, size_t aSize);
-  void Free(uint32_t aCode, void* aPtr);
-
-  inline void ClearArenaRefPtrWithoutDeregistering(
-      void* aPtr,
-      mozilla::ArenaObjectID aObjectID);
-
-
-
-  class FreeList : public PLDHashEntryHdr
-  {
-  public:
-    typedef uint32_t KeyType;
-    nsTArray<void *> mEntries;
-    size_t mEntrySize;
-    size_t mEntriesEverAllocated;
-
-    typedef const void* KeyTypePointer;
-    KeyTypePointer mKey;
-
-    explicit FreeList(KeyTypePointer aKey)
-    : mEntrySize(0), mEntriesEverAllocated(0), mKey(aKey) {}
-
-
-    bool KeyEquals(KeyTypePointer const aKey) const
-    { return mKey == aKey; }
-
-    static KeyTypePointer KeyToPointer(KeyType aKey)
-    { return ((void*)(intptr_t)(aKey)); }
-
-    static PLDHashNumber HashKey(KeyTypePointer aKey)
-    { return ((int32_t)(intptr_t)(aKey)); }
-
-    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-    { return mEntries.ShallowSizeOfExcludingThis(aMallocSizeOf); }
-
-    enum { ALLOW_MEMMOVE = false };
-  };
-
-  nsTHashtable<FreeList> mFreeLists;
-  mozilla::ArenaAllocator<8192, 8> mPool;
-  nsDataHashtable<nsPtrHashKey<void>, mozilla::ArenaObjectID> mArenaRefPtrs;
-};
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h"
-class imgIRequest;
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgINotificationObserver.h"
-class imgINotificationObserver : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    SIZE_AVAILABLE = 1,
-    FRAME_UPDATE = 2,
-    FRAME_COMPLETE = 3,
-    LOAD_COMPLETE = 4,
-    DECODE_COMPLETE = 5,
-    DISCARD = 6,
-    UNLOCKED_DRAW = 7,
-    IS_ANIMATED = 8,
-    HAS_TRANSPARENCY = 9
-  };
-
-
-  virtual nsresult Notify(imgIRequest *aProxy, int32_t aType, const nsIntRect *aRect) = 0;
-
-};
-
-  template<typename T> struct imgINotificationObserver::COMTypeInfo<imgINotificationObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID imgINotificationObserver::COMTypeInfo<imgINotificationObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x03da5641, 0xa333, 0x454a, { 0xa8, 0x59, 0x03, 0x6d, 0x0b, 0xb6, 0x83, 0xb7 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 2
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Visibility.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Visibility.h"
-namespace mozilla {
-
-
-enum class Visibility : uint8_t
-{
-
-  UNTRACKED,
-
-
-
-
-
-
-  APPROXIMATELY_NONVISIBLE,
-
-
-
-
-
-  APPROXIMATELY_VISIBLE
-};
-
-
-enum class OnNonvisible : uint8_t
-{
-  DISCARD_IMAGES
-};
-
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h" 2
-class imgIRequest;
-
-class nsIChannel;
-
-class nsIStreamListener;
-
-class nsIURI;
-
-class nsIDocument;
-
-class nsIFrame;
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIImageLoadingContent.h"
-class nsIImageLoadingContent : public imgINotificationObserver {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    UNKNOWN_REQUEST = -1,
-    CURRENT_REQUEST = 0,
-    PENDING_REQUEST = 1
-  };
-
-
-  virtual nsresult GetLoadingEnabled(bool *aLoadingEnabled) = 0;
-  virtual nsresult SetLoadingEnabled(bool aLoadingEnabled) = 0;
-
-
-  virtual nsresult GetImageBlockingStatus(int16_t *aImageBlockingStatus) = 0;
-
-
-  virtual nsresult AddObserver(imgINotificationObserver *aObserver) = 0;
-
-
-  virtual nsresult RemoveObserver(imgINotificationObserver *aObserver) = 0;
-
-
-  virtual nsresult GetRequest(int32_t aRequestType, imgIRequest * *_retval) = 0;
-
-
-  virtual bool CurrentRequestHasSize(void) = 0;
-
-
-  virtual void FrameCreated(nsIFrame *aFrame) = 0;
-
-
-  virtual void FrameDestroyed(nsIFrame *aFrame) = 0;
-
-
-  virtual nsresult GetRequestType(imgIRequest *aRequest, int32_t *_retval) = 0;
-
-
-  virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) = 0;
-
-
-  virtual nsresult LoadImageWithChannel(nsIChannel *aChannel, nsIStreamListener * *_retval) = 0;
-
-
-  virtual nsresult ForceReload(bool aNotify, uint8_t _argc) = 0;
-
-
-  virtual nsresult ForceImageState(bool aForce, uint64_t aState) = 0;
-
-
-  virtual nsresult GetNaturalWidth(uint32_t *aNaturalWidth) = 0;
-
-
-  virtual nsresult GetNaturalHeight(uint32_t *aNaturalHeight) = 0;
-
-
-  virtual void OnVisibilityChange(mozilla::Visibility aNewVisibility, const mozilla::Maybe<mozilla::OnNonvisible> & aNonvisibleAction) = 0;
-
-};
-
-  template<typename T> struct nsIImageLoadingContent::COMTypeInfo<nsIImageLoadingContent, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIImageLoadingContent::COMTypeInfo<nsIImageLoadingContent, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0357123d, 0x9224, 0x4d12, { 0xa4, 0x7e, 0x86, 0x8c, 0x32, 0x68, 0x97, 0x77 }};
-# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h"
-typedef uint64_t nsFrameState_size_t;
-
-
-
-enum nsFrameState : nsFrameState_size_t {
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h" 1
-# 56 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_FRAME_IN_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (0))),
-
-
-
-
-NS_FRAME_FIRST_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (1))),
-
-
-
-
-NS_FRAME_IS_FLUID_CONTINUATION = (nsFrameState(nsFrameState_size_t(1) << (2))),
-
-
-NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (3))),
-
-
-
-
-NS_FRAME_EXTERNAL_REFERENCE = (nsFrameState(nsFrameState_size_t(1) << (4))),
-
-
-
-
-
-NS_FRAME_CONTAINS_RELATIVE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (5))),
-
-
-NS_FRAME_GENERATED_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (6))),
-
-
-
-
-
-
-NS_FRAME_IS_OVERFLOW_CONTAINER = (nsFrameState(nsFrameState_size_t(1) << (7))),
-
-
-
-NS_FRAME_OUT_OF_FLOW = (nsFrameState(nsFrameState_size_t(1) << (8))),
-
-
-
-
-NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (9))),
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_FRAME_IS_DIRTY = (nsFrameState(nsFrameState_size_t(1) << (10))),
-
-
-
-
-NS_FRAME_TOO_DEEP_IN_FRAME_TREE = (nsFrameState(nsFrameState_size_t(1) << (11))),
-# 132 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_FRAME_HAS_DIRTY_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (12))),
-
-
-NS_FRAME_HAS_VIEW = (nsFrameState(nsFrameState_size_t(1) << (13))),
-
-
-NS_FRAME_INDEPENDENT_SELECTION = (nsFrameState(nsFrameState_size_t(1) << (14))),
-
-
-
-
-
-NS_FRAME_PART_OF_IBSPLIT = (nsFrameState(nsFrameState_size_t(1) << (15))),
-
-
-
-
-
-
-NS_FRAME_MAY_BE_TRANSFORMED = (nsFrameState(nsFrameState_size_t(1) << (16))),
-
-
-
-NS_FRAME_IS_BIDI = (nsFrameState(nsFrameState_size_t(1) << (17))),
-
-
-NS_FRAME_HAS_CHILD_WITH_VIEW = (nsFrameState(nsFrameState_size_t(1) << (18))),
-
-
-
-NS_FRAME_REFLOW_ROOT = (nsFrameState(nsFrameState_size_t(1) << (19))),
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_FRAME_IS_PUSHED_FLOAT = (nsFrameState(nsFrameState_size_t(1) << (32))),
-
-
-NS_FRAME_DRAWING_AS_PAINTSERVER = (nsFrameState(nsFrameState_size_t(1) << (33))),
-
-
-
-
-NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (34))),
-
-
-
-
-
-NS_FRAME_SIMPLE_EVENT_REGIONS = (nsFrameState(nsFrameState_size_t(1) << (35))),
-
-
-
-
-
-NS_FRAME_UPDATE_LAYER_TREE = (nsFrameState(nsFrameState_size_t(1) << (36))),
-
-
-NS_FRAME_HAS_ABSPOS_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (37))),
-
-
-NS_FRAME_PAINTED_THEBES = (nsFrameState(nsFrameState_size_t(1) << (38))),
-
-
-
-
-NS_FRAME_IN_CONSTRAINED_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (39))),
-
-
-NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO = (nsFrameState(nsFrameState_size_t(1) << (40))),
-
-
-
-
-NS_FRAME_FONT_INFLATION_CONTAINER = (nsFrameState(nsFrameState_size_t(1) << (41))),
-
-
-
-
-NS_FRAME_FONT_INFLATION_FLOW_ROOT = (nsFrameState(nsFrameState_size_t(1) << (42))),
-
-
-
-
-NS_FRAME_SVG_LAYOUT = (nsFrameState(nsFrameState_size_t(1) << (43))),
-
-
-NS_FRAME_MAY_HAVE_GENERATED_CONTENT = (nsFrameState(nsFrameState_size_t(1) << (44))),
-
-
-
-
-NS_FRAME_NO_COMPONENT_ALPHA = (nsFrameState(nsFrameState_size_t(1) << (45))),
-
-
-
-NS_FRAME_VISIBILITY_IS_TRACKED = (nsFrameState(nsFrameState_size_t(1) << (46))),
-
-
-
-NS_FRAME_IS_SVG_TEXT = (nsFrameState(nsFrameState_size_t(1) << (47))),
-
-
-NS_FRAME_NEEDS_PAINT = (nsFrameState(nsFrameState_size_t(1) << (48))),
-
-
-
-NS_FRAME_DESCENDANT_NEEDS_PAINT = (nsFrameState(nsFrameState_size_t(1) << (49))),
-
-
-NS_FRAME_IN_POPUP = (nsFrameState(nsFrameState_size_t(1) << (50))),
-
-
-
-
-
-NS_FRAME_ALL_DESCENDANTS_NEED_PAINT = (nsFrameState(nsFrameState_size_t(1) << (51))),
-
-
-
-NS_FRAME_HAS_INVALID_RECT = (nsFrameState(nsFrameState_size_t(1) << (52))),
-
-
-
-NS_FRAME_IS_NONDISPLAY = (nsFrameState(nsFrameState_size_t(1) << (53))),
-
-
-NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY = (nsFrameState(nsFrameState_size_t(1) << (54))),
-
-
-
-NS_FRAME_OWNS_ANON_BOXES = (nsFrameState(nsFrameState_size_t(1) << (55))),
-
-
-NS_FRAME_HAS_PROPERTIES = (nsFrameState(nsFrameState_size_t(1) << (56))),
-
-
-
-NS_FRAME_MATHML_SCRIPT_DESCENDANT = (nsFrameState(nsFrameState_size_t(1) << (58))),
-
-
-
-
-NS_FRAME_IS_IN_SINGLE_CHAR_MI = (nsFrameState(nsFrameState_size_t(1) << (59))),
-# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_STATE_BOX_CHILD_RESERVED = (nsFrameState(nsFrameState_size_t(1) << (20))),
-NS_STATE_STACK_NOT_POSITIONED = (nsFrameState(nsFrameState_size_t(1) << (21))),
-NS_STATE_IS_HORIZONTAL = (nsFrameState(nsFrameState_size_t(1) << (22))),
-NS_STATE_AUTO_STRETCH = (nsFrameState(nsFrameState_size_t(1) << (23))),
-NS_STATE_IS_ROOT = (nsFrameState(nsFrameState_size_t(1) << (24))),
-NS_STATE_CURRENTLY_IN_DEBUG = (nsFrameState(nsFrameState_size_t(1) << (25))),
-NS_STATE_SET_TO_DEBUG = (nsFrameState(nsFrameState_size_t(1) << (26))),
-NS_STATE_DEBUG_WAS_SET = (nsFrameState(nsFrameState_size_t(1) << (27))),
-NS_STATE_MENU_HAS_POPUP_LIST = (nsFrameState(nsFrameState_size_t(1) << (28))),
-NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK = (nsFrameState(nsFrameState_size_t(1) << (29))),
-NS_STATE_EQUAL_SIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
-NS_STATE_IS_DIRECTION_NORMAL = (nsFrameState(nsFrameState_size_t(1) << (31))),
-NS_FRAME_MOUSE_THROUGH_ALWAYS = (nsFrameState(nsFrameState_size_t(1) << (60))),
-NS_FRAME_MOUSE_THROUGH_NEVER = (nsFrameState(nsFrameState_size_t(1) << (61))),
-# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-
-
-NS_STATE_FLEX_IS_LEGACY_WEBKIT_BOX = (nsFrameState(nsFrameState_size_t(1) << (21))),
-
-
-NS_STATE_FLEX_SYNTHESIZE_BASELINE = (nsFrameState(nsFrameState_size_t(1) << (22))),
-
-
-
-
-
-
-
-NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-
-
-
-
-NS_STATE_GRID_DID_PUSH_ITEMS = (nsFrameState(nsFrameState_size_t(1) << (21))),
-
-
-NS_STATE_GRID_GENERATE_COMPUTED_VALUES = (nsFrameState(nsFrameState_size_t(1) << (22))),
-
-
-NS_STATE_GRID_SYNTHESIZE_BASELINE = (nsFrameState(nsFrameState_size_t(1) << (23))),
-
-
-
-
-
-
-NS_STATE_IS_OUTER_SVG = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-
-NS_STATE_SVG_CLIPPATH_CHILD = (nsFrameState(nsFrameState_size_t(1) << (21))),
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_STATE_SVG_POSITIONING_DIRTY = (nsFrameState(nsFrameState_size_t(1) << (22))),
-# 385 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES = (nsFrameState(nsFrameState_size_t(1) << (23))),
-
-NS_STATE_SVG_TEXT_IN_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (24))),
-# 400 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-TEXT_FIRST_LETTER = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-
-
-TEXT_START_OF_LINE = (nsFrameState(nsFrameState_size_t(1) << (21))),
-
-
-
-TEXT_END_OF_LINE = (nsFrameState(nsFrameState_size_t(1) << (22))),
-
-
-TEXT_HYPHEN_BREAK = (nsFrameState(nsFrameState_size_t(1) << (23))),
-
-
-
-TEXT_TRIMMED_TRAILING_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (24))),
-
-
-
-
-TEXT_JUSTIFICATION_ENABLED = (nsFrameState(nsFrameState_size_t(1) << (25))),
-
-
-TEXT_SELECTION_UNDERLINE_OVERFLOWED = (nsFrameState(nsFrameState_size_t(1) << (26))),
-
-
-
-
-
-
-TEXT_IS_ONLY_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (27))),
-
-
-TEXT_ISNOT_ONLY_WHITESPACE = (nsFrameState(nsFrameState_size_t(1) << (28))),
-
-
-
-
-TEXT_IN_TEXTRUN_USER_DATA = (nsFrameState(nsFrameState_size_t(1) << (29))),
-
-
-
-TEXT_OFFSETS_NEED_FIXING = (nsFrameState(nsFrameState_size_t(1) << (30))),
-
-
-
-TEXT_HAS_NONCOLLAPSED_CHARACTERS = (nsFrameState(nsFrameState_size_t(1) << (31))),
-
-
-
-
-TEXT_IS_IN_TOKEN_MATHML = (nsFrameState(nsFrameState_size_t(1) << (32))),
-
-
-
-TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA = (nsFrameState(nsFrameState_size_t(1) << (60))),
-
-TEXT_HAS_FONT_INFLATION = (nsFrameState(nsFrameState_size_t(1) << (61))),
-
-
-TEXT_NO_RENDERED_GLYPHS = (nsFrameState(nsFrameState_size_t(1) << (62))),
-
-
-
-TEXT_IN_OFFSET_CACHE = (nsFrameState(nsFrameState_size_t(1) << (63))),
-# 474 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_BLOCK_NEEDS_BIDI_RESOLUTION = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-NS_BLOCK_HAS_PUSHED_FLOATS = (nsFrameState(nsFrameState_size_t(1) << (21))),
-# 486 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_BLOCK_MARGIN_ROOT = (nsFrameState(nsFrameState_size_t(1) << (22))),
-
-
-
-
-NS_BLOCK_FLOAT_MGR = (nsFrameState(nsFrameState_size_t(1) << (23))),
-
-
-
-
-NS_BLOCK_HAS_LINE_CURSOR = (nsFrameState(nsFrameState_size_t(1) << (24))),
-
-NS_BLOCK_HAS_OVERFLOW_LINES = (nsFrameState(nsFrameState_size_t(1) << (25))),
-
-NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS = (nsFrameState(nsFrameState_size_t(1) << (26))),
-
-
-
-
-NS_BLOCK_HAS_CLEAR_CHILDREN = (nsFrameState(nsFrameState_size_t(1) << (27))),
-
-
-
-
-NS_BLOCK_CLIP_PAGINATED_OVERFLOW = (nsFrameState(nsFrameState_size_t(1) << (28))),
-
-
-
-NS_BLOCK_HAS_FIRST_LETTER_STYLE = (nsFrameState(nsFrameState_size_t(1) << (29))),
-
-
-
-NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET = (nsFrameState(nsFrameState_size_t(1) << (30))),
-NS_BLOCK_FRAME_HAS_INSIDE_BULLET = (nsFrameState(nsFrameState_size_t(1) << (31))),
-
-
-
-
-NS_BLOCK_LOOK_FOR_DIRTY_FRAMES = (nsFrameState(nsFrameState_size_t(1) << (61))),
-# 534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_BLOCK_FRAME_INTRINSICS_INFLATED = (nsFrameState(nsFrameState_size_t(1) << (62))),
-
-
-
-
-
-NS_BLOCK_HAS_FIRST_LETTER_CHILD = (nsFrameState(nsFrameState_size_t(1) << (63))),
-
-
-
-
-
-
-BULLET_FRAME_HAS_FONT_INFLATION = (nsFrameState(nsFrameState_size_t(1) << (62))),
-BULLET_FRAME_IMAGE_LOADING = (nsFrameState(nsFrameState_size_t(1) << (63))),
-# 559 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_SCROLLFRAME_INVALIDATE_CONTENTS_ON_SCROLL = (nsFrameState(nsFrameState_size_t(1) << (20))),
-
-
-
-
-
-
-IMAGE_SIZECONSTRAINED = (nsFrameState(nsFrameState_size_t(1) << (20))),
-IMAGE_GOTINITIALREFLOW = (nsFrameState(nsFrameState_size_t(1) << (21))),
-# 580 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET = (nsFrameState(nsFrameState_size_t(1) << (21))),
-NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST = (nsFrameState(nsFrameState_size_t(1) << (22))),
-NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST = (nsFrameState(nsFrameState_size_t(1) << (23))),
-# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_RUBY_TEXT_FRAME_AUTOHIDE = (nsFrameState(nsFrameState_size_t(1) << (24))),
-
-
-
-
-
-
-NS_RUBY_TEXT_CONTAINER_IS_SPAN = (nsFrameState(nsFrameState_size_t(1) << (20))),
-# 608 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-PLACEHOLDER_FOR_FLOAT = (nsFrameState(nsFrameState_size_t(1) << (20))),
-PLACEHOLDER_FOR_ABSPOS = (nsFrameState(nsFrameState_size_t(1) << (21))),
-PLACEHOLDER_FOR_FIXEDPOS = (nsFrameState(nsFrameState_size_t(1) << (22))),
-PLACEHOLDER_FOR_POPUP = (nsFrameState(nsFrameState_size_t(1) << (23))),
-PLACEHOLDER_FOR_TOPLAYER = (nsFrameState(nsFrameState_size_t(1) << (24))),
-# 621 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN = (nsFrameState(nsFrameState_size_t(1) << (25))),
-
-
-
-
-
-
-NS_TABLE_CELL_HAS_PCT_OVER_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (28))),
-NS_TABLE_CELL_HAD_SPECIAL_REFLOW = (nsFrameState(nsFrameState_size_t(1) << (29))),
-NS_TABLE_CELL_CONTENT_EMPTY = (nsFrameState(nsFrameState_size_t(1) << (31))),
-# 649 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_REPEATED_ROW_OR_ROWGROUP = (nsFrameState(nsFrameState_size_t(1) << (28))),
-# 658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameStateBits.h"
-NS_ROW_HAS_CELL_WITH_STYLE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (29))),
-
-NS_TABLE_ROW_HAS_UNPAGINATED_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
-
-
-
-
-
-
-NS_ROWGROUP_HAS_ROW_CURSOR = (nsFrameState(nsFrameState_size_t(1) << (27))),
-NS_ROWGROUP_HAS_STYLE_BSIZE = (nsFrameState(nsFrameState_size_t(1) << (30))),
-
-
-NS_ROWGROUP_REPEATABLE = (nsFrameState(nsFrameState_size_t(1) << (31))),
-
-
-
-NS_TABLE_PART_HAS_FIXED_BACKGROUND = (nsFrameState(nsFrameState_size_t(1) << (28))),
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFrameState.h" 2
-
-};
-
-inline nsFrameState operator|(nsFrameState aLeft, nsFrameState aRight)
-{
-  return nsFrameState(nsFrameState_size_t(aLeft) | nsFrameState_size_t(aRight));
-}
-
-inline nsFrameState operator&(nsFrameState aLeft, nsFrameState aRight)
-{
-  return nsFrameState(nsFrameState_size_t(aLeft) & nsFrameState_size_t(aRight));
-}
-
-inline nsFrameState& operator|=(nsFrameState& aLeft, nsFrameState aRight)
-{
-  aLeft = aLeft | aRight;
-  return aLeft;
-}
-
-inline nsFrameState& operator&=(nsFrameState& aLeft, nsFrameState aRight)
-{
-  aLeft = aLeft & aRight;
-  return aLeft;
-}
-
-inline nsFrameState operator~(nsFrameState aRight)
-{
-  return nsFrameState(~nsFrameState_size_t(aRight));
-}
-
-inline nsFrameState operator^(nsFrameState aLeft, nsFrameState aRight)
-{
-  return nsFrameState(nsFrameState_size_t(aLeft) ^ nsFrameState_size_t(aRight));
-}
-
-inline nsFrameState& operator^=(nsFrameState& aLeft, nsFrameState aRight)
-{
-  aLeft = aLeft ^ aRight;
-  return aLeft;
-}
-
-
-
-
-
-namespace mozilla {
-
-
-
-
-}
-# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h"
-namespace mozilla {
-namespace gfx {
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactor.h"
-template<class src, class dst>
-struct ScaleFactor {
-  float scale;
-
-  constexpr ScaleFactor() : scale(1.0) {}
-  constexpr ScaleFactor(const ScaleFactor<src, dst>& aCopy) : scale(aCopy.scale) {}
-  explicit constexpr ScaleFactor(float aScale) : scale(aScale) {}
-
-  ScaleFactor<dst, src> Inverse() {
-    return ScaleFactor<dst, src>(1 / scale);
-  }
-
-  bool operator==(const ScaleFactor<src, dst>& aOther) const {
-    return scale == aOther.scale;
-  }
-
-  bool operator!=(const ScaleFactor<src, dst>& aOther) const {
-    return !(*this == aOther);
-  }
-
-  bool operator<(const ScaleFactor<src, dst>& aOther) const {
-    return scale < aOther.scale;
-  }
-
-  bool operator<=(const ScaleFactor<src, dst>& aOther) const {
-    return scale <= aOther.scale;
-  }
-
-  bool operator>(const ScaleFactor<src, dst>& aOther) const {
-    return scale > aOther.scale;
-  }
-
-  bool operator>=(const ScaleFactor<src, dst>& aOther) const {
-    return scale >= aOther.scale;
-  }
-
-  template<class other>
-  ScaleFactor<other, dst> operator/(const ScaleFactor<src, other>& aOther) const {
-    return ScaleFactor<other, dst>(scale / aOther.scale);
-  }
-
-  template<class other>
-  ScaleFactor<src, other> operator/(const ScaleFactor<other, dst>& aOther) const {
-    return ScaleFactor<src, other>(scale / aOther.scale);
-  }
-
-  template<class other>
-  ScaleFactor<src, other> operator*(const ScaleFactor<dst, other>& aOther) const {
-    return ScaleFactor<src, other>(scale * aOther.scale);
-  }
-
-  template<class other>
-  ScaleFactor<other, dst> operator*(const ScaleFactor<other, src>& aOther) const {
-    return ScaleFactor<other, dst>(scale * aOther.scale);
-  }
-};
-
-}
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactors2D.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/ScaleFactors2D.h"
-namespace mozilla {
-namespace gfx {
-
-
-
-
-
-template<class src, class dst>
-struct ScaleFactors2D {
-  float xScale;
-  float yScale;
-
-  constexpr ScaleFactors2D() : xScale(1.0), yScale(1.0) {}
-  constexpr ScaleFactors2D(const ScaleFactors2D<src, dst>& aCopy)
-    : xScale(aCopy.xScale), yScale(aCopy.yScale) {}
-  constexpr ScaleFactors2D(float aXScale, float aYScale)
-    : xScale(aXScale), yScale(aYScale) {}
-
-  explicit constexpr ScaleFactors2D(const gfxSize& aSize)
-    : xScale(aSize.width), yScale(aSize.height) {}
-
-
-
-
-
-  explicit constexpr ScaleFactors2D(const ScaleFactor<src, dst>& aScale)
-    : xScale(aScale.scale), yScale(aScale.scale) {}
-
-  bool AreScalesSame() const {
-    return FuzzyEqualsMultiplicative(xScale, yScale);
-  }
-
-
-  ScaleFactor<src, dst> ToScaleFactor() const {
-    do { } while (0);
-    return ScaleFactor<src, dst>(xScale);
-  }
-
-  bool operator==(const ScaleFactors2D<src, dst>& aOther) const {
-    return xScale == aOther.xScale && yScale == aOther.yScale;
-  }
-
-  bool operator!=(const ScaleFactors2D<src, dst>& aOther) const {
-    return !(*this == aOther);
-  }
-
-  friend std::ostream& operator<<(std::ostream& aStream,
-                                  const ScaleFactors2D<src, dst>& aScale) {
-    if (aScale.AreScalesSame()) {
-      return aStream << aScale.xScale;
-    } else {
-      return aStream << '(' << aScale.xScale << ',' << aScale.yScale << ')';
-    }
-  }
-
-  template<class other>
-  ScaleFactors2D<other, dst> operator/(const ScaleFactors2D<src, other>& aOther) const {
-    return ScaleFactors2D<other, dst>(xScale / aOther.xScale, yScale / aOther.yScale);
-  }
-
-  template<class other>
-  ScaleFactors2D<src, other> operator/(const ScaleFactors2D<other, dst>& aOther) const {
-    return ScaleFactors2D<src, other>(xScale / aOther.xScale, yScale / aOther.yScale);
-  }
-
-  template<class other>
-  ScaleFactors2D<src, other> operator*(const ScaleFactors2D<dst, other>& aOther) const {
-    return ScaleFactors2D<src, other>(xScale * aOther.xScale, yScale * aOther.yScale);
-  }
-
-  template<class other>
-  ScaleFactors2D<other, dst> operator*(const ScaleFactors2D<other, src>& aOther) const {
-    return ScaleFactors2D<other, dst>(xScale * aOther.xScale, yScale * aOther.yScale);
-  }
-
-  template<class other>
-  ScaleFactors2D<src, other> operator*(const ScaleFactor<dst, other>& aOther) const {
-    return *this * ScaleFactors2D<dst, other>(aOther);
-  }
-
-  template<class other>
-  ScaleFactors2D<other, dst> operator*(const ScaleFactor<other, src>& aOther) const {
-    return *this * ScaleFactors2D<other, src>(aOther);
-  }
-
-  template<class other>
-  ScaleFactors2D<src, other> operator/(const ScaleFactor<other, dst>& aOther) const {
-    return *this / ScaleFactors2D<other, dst>(aOther);
-  }
-
-  template<class other>
-  ScaleFactors2D<other, dst> operator/(const ScaleFactor<src, other>& aOther) const {
-    return *this / ScaleFactors2D<src, other>(aOther);
-  }
-
-  template<class other>
-  friend ScaleFactors2D<other, dst> operator*(const ScaleFactor<other, src>& aA,
-                                              const ScaleFactors2D<src, dst>& aB) {
-    return ScaleFactors2D<other, src>(aA) * aB;
-  }
-
-  template<class other>
-  friend ScaleFactors2D<other, src> operator/(const ScaleFactor<other, dst>& aA,
-                                              const ScaleFactors2D<src, dst>& aB) {
-    return ScaleFactors2D<other, src>(aA) / aB;
-  }
-
-
-
-
-  gfxSize operator/(const ScaleFactors2D& aOther) const {
-    return gfxSize(xScale / aOther.xScale, yScale / aOther.yScale);
-  }
-};
-
-}
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayView.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ArrayView.h"
-namespace mozilla {
-namespace gfx {
-
-template<typename T>
-class ArrayView
-{
-    public:
-                     ArrayView(const nsTArray<T>& aData) :
-            mData(aData.Elements()), mLength(aData.Length())
-        {
-        }
-        ArrayView(const T* aData, const size_t aLength) :
-            mData(aData), mLength(aLength)
-        {
-        }
-        const T& operator[](const size_t aIdx) const
-        {
-            return mData[aIdx];
-        }
-        size_t Length() const
-        {
-            return mLength;
-        }
-        const T* Data() const
-        {
-            return mData;
-        }
-    private:
-        const T* mData;
-        const size_t mLength;
-};
-
-}
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 1
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/cairo/pixman-rename.h" 1
-# 74 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman-version.h" 1
-# 78 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h" 2
-# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-extern "C" {
-# 118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-typedef int pixman_bool_t;
-
-
-
-
-typedef int64_t pixman_fixed_32_32_t;
-typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
-typedef uint32_t pixman_fixed_1_31_t;
-typedef uint32_t pixman_fixed_1_16_t;
-typedef int32_t pixman_fixed_16_16_t;
-typedef pixman_fixed_16_16_t pixman_fixed_t;
-# 149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-typedef struct pixman_color pixman_color_t;
-typedef struct pixman_point_fixed pixman_point_fixed_t;
-typedef struct pixman_line_fixed pixman_line_fixed_t;
-typedef struct pixman_vector pixman_vector_t;
-typedef struct pixman_transform pixman_transform_t;
-
-struct pixman_color
-{
-    uint16_t red;
-    uint16_t green;
-    uint16_t blue;
-    uint16_t alpha;
-};
-
-struct pixman_point_fixed
-{
-    pixman_fixed_t x;
-    pixman_fixed_t y;
-};
-
-struct pixman_line_fixed
-{
-    pixman_point_fixed_t p1, p2;
-};
-
-
-
-
-
-struct pixman_vector
-{
-    pixman_fixed_t vector[3];
-};
-
-struct pixman_transform
-{
-    pixman_fixed_t matrix[3][3];
-};
-
-
-struct pixman_box16;
-typedef union pixman_image pixman_image_t;
-
-void _moz_pixman_transform_init_identity (struct pixman_transform *matrix);
-pixman_bool_t _moz_pixman_transform_point_3d (const struct pixman_transform *transform,
-       struct pixman_vector *vector);
-pixman_bool_t _moz_pixman_transform_point (const struct pixman_transform *transform,
-       struct pixman_vector *vector);
-pixman_bool_t _moz_pixman_transform_multiply (struct pixman_transform *dst,
-       const struct pixman_transform *l,
-       const struct pixman_transform *r);
-void _moz_pixman_transform_init_scale (struct pixman_transform *t,
-       pixman_fixed_t sx,
-       pixman_fixed_t sy);
-pixman_bool_t _moz_pixman_transform_scale (struct pixman_transform *forward,
-       struct pixman_transform *reverse,
-       pixman_fixed_t sx,
-       pixman_fixed_t sy);
-void _moz_pixman_transform_init_rotate (struct pixman_transform *t,
-       pixman_fixed_t cos,
-       pixman_fixed_t sin);
-pixman_bool_t _moz_pixman_transform_rotate (struct pixman_transform *forward,
-       struct pixman_transform *reverse,
-       pixman_fixed_t c,
-       pixman_fixed_t s);
-void _moz_pixman_transform_init_translate (struct pixman_transform *t,
-       pixman_fixed_t tx,
-       pixman_fixed_t ty);
-pixman_bool_t _moz_pixman_transform_translate (struct pixman_transform *forward,
-       struct pixman_transform *reverse,
-       pixman_fixed_t tx,
-       pixman_fixed_t ty);
-pixman_bool_t _moz_pixman_transform_bounds (const struct pixman_transform *matrix,
-       struct pixman_box16 *b);
-pixman_bool_t _moz_pixman_transform_invert (struct pixman_transform *dst,
-       const struct pixman_transform *src);
-pixman_bool_t _moz_pixman_transform_is_identity (const struct pixman_transform *t);
-pixman_bool_t _moz_pixman_transform_is_scale (const struct pixman_transform *t);
-pixman_bool_t _moz_pixman_transform_is_int_translate (const struct pixman_transform *t);
-pixman_bool_t _moz_pixman_transform_is_inverse (const struct pixman_transform *a,
-       const struct pixman_transform *b);
-
-
-
-
-typedef struct pixman_f_transform pixman_f_transform_t;
-typedef struct pixman_f_vector pixman_f_vector_t;
-
-struct pixman_f_vector
-{
-    double v[3];
-};
-
-struct pixman_f_transform
-{
-    double m[3][3];
-};
-
-pixman_bool_t _moz_pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
-       const struct pixman_f_transform *ft);
-void _moz_pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
-       const struct pixman_transform *t);
-pixman_bool_t _moz_pixman_f_transform_invert (struct pixman_f_transform *dst,
-       const struct pixman_f_transform *src);
-pixman_bool_t _moz_pixman_f_transform_point (const struct pixman_f_transform *t,
-       struct pixman_f_vector *v);
-void _moz_pixman_f_transform_point_3d (const struct pixman_f_transform *t,
-       struct pixman_f_vector *v);
-void _moz_pixman_f_transform_multiply (struct pixman_f_transform *dst,
-       const struct pixman_f_transform *l,
-       const struct pixman_f_transform *r);
-void _moz_pixman_f_transform_init_scale (struct pixman_f_transform *t,
-       double sx,
-       double sy);
-pixman_bool_t _moz_pixman_f_transform_scale (struct pixman_f_transform *forward,
-       struct pixman_f_transform *reverse,
-       double sx,
-       double sy);
-void _moz_pixman_f_transform_init_rotate (struct pixman_f_transform *t,
-       double cos,
-       double sin);
-pixman_bool_t _moz_pixman_f_transform_rotate (struct pixman_f_transform *forward,
-       struct pixman_f_transform *reverse,
-       double c,
-       double s);
-void _moz_pixman_f_transform_init_translate (struct pixman_f_transform *t,
-       double tx,
-       double ty);
-pixman_bool_t _moz_pixman_f_transform_translate (struct pixman_f_transform *forward,
-       struct pixman_f_transform *reverse,
-       double tx,
-       double ty);
-pixman_bool_t _moz_pixman_f_transform_bounds (const struct pixman_f_transform *t,
-       struct pixman_box16 *b);
-void _moz_pixman_f_transform_init_identity (struct pixman_f_transform *t);
-
-typedef enum
-{
-    PIXMAN_REPEAT_NONE,
-    PIXMAN_REPEAT_NORMAL,
-    PIXMAN_REPEAT_PAD,
-    PIXMAN_REPEAT_REFLECT
-} pixman_repeat_t;
-
-typedef enum
-{
-    PIXMAN_FILTER_FAST,
-    PIXMAN_FILTER_GOOD,
-    PIXMAN_FILTER_BEST,
-    PIXMAN_FILTER_NEAREST,
-    PIXMAN_FILTER_BILINEAR,
-    PIXMAN_FILTER_CONVOLUTION,
-# 321 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-    PIXMAN_FILTER_SEPARABLE_CONVOLUTION
-} pixman_filter_t;
-
-typedef enum
-{
-    PIXMAN_OP_CLEAR = 0x00,
-    PIXMAN_OP_SRC = 0x01,
-    PIXMAN_OP_DST = 0x02,
-    PIXMAN_OP_OVER = 0x03,
-    PIXMAN_OP_OVER_REVERSE = 0x04,
-    PIXMAN_OP_IN = 0x05,
-    PIXMAN_OP_IN_REVERSE = 0x06,
-    PIXMAN_OP_OUT = 0x07,
-    PIXMAN_OP_OUT_REVERSE = 0x08,
-    PIXMAN_OP_ATOP = 0x09,
-    PIXMAN_OP_ATOP_REVERSE = 0x0a,
-    PIXMAN_OP_XOR = 0x0b,
-    PIXMAN_OP_ADD = 0x0c,
-    PIXMAN_OP_SATURATE = 0x0d,
-
-    PIXMAN_OP_DISJOINT_CLEAR = 0x10,
-    PIXMAN_OP_DISJOINT_SRC = 0x11,
-    PIXMAN_OP_DISJOINT_DST = 0x12,
-    PIXMAN_OP_DISJOINT_OVER = 0x13,
-    PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
-    PIXMAN_OP_DISJOINT_IN = 0x15,
-    PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
-    PIXMAN_OP_DISJOINT_OUT = 0x17,
-    PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
-    PIXMAN_OP_DISJOINT_ATOP = 0x19,
-    PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
-    PIXMAN_OP_DISJOINT_XOR = 0x1b,
-
-    PIXMAN_OP_CONJOINT_CLEAR = 0x20,
-    PIXMAN_OP_CONJOINT_SRC = 0x21,
-    PIXMAN_OP_CONJOINT_DST = 0x22,
-    PIXMAN_OP_CONJOINT_OVER = 0x23,
-    PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
-    PIXMAN_OP_CONJOINT_IN = 0x25,
-    PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
-    PIXMAN_OP_CONJOINT_OUT = 0x27,
-    PIXMAN_OP_CONJOINT_OUT_REVERSE = 0x28,
-    PIXMAN_OP_CONJOINT_ATOP = 0x29,
-    PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
-    PIXMAN_OP_CONJOINT_XOR = 0x2b,
-
-    PIXMAN_OP_MULTIPLY = 0x30,
-    PIXMAN_OP_SCREEN = 0x31,
-    PIXMAN_OP_OVERLAY = 0x32,
-    PIXMAN_OP_DARKEN = 0x33,
-    PIXMAN_OP_LIGHTEN = 0x34,
-    PIXMAN_OP_COLOR_DODGE = 0x35,
-    PIXMAN_OP_COLOR_BURN = 0x36,
-    PIXMAN_OP_HARD_LIGHT = 0x37,
-    PIXMAN_OP_SOFT_LIGHT = 0x38,
-    PIXMAN_OP_DIFFERENCE = 0x39,
-    PIXMAN_OP_EXCLUSION = 0x3a,
-    PIXMAN_OP_HSL_HUE = 0x3b,
-    PIXMAN_OP_HSL_SATURATION = 0x3c,
-    PIXMAN_OP_HSL_COLOR = 0x3d,
-    PIXMAN_OP_HSL_LUMINOSITY = 0x3e
-
-
-
-
-
-
-} pixman_op_t;
-
-
-
-
-typedef struct pixman_region16_data pixman_region16_data_t;
-typedef struct pixman_box16 pixman_box16_t;
-typedef struct pixman_rectangle16 pixman_rectangle16_t;
-typedef struct pixman_region16 pixman_region16_t;
-
-struct pixman_region16_data {
-    long size;
-    long numRects;
-
-};
-
-struct pixman_rectangle16
-{
-    int16_t x, y;
-    uint16_t width, height;
-};
-
-struct pixman_box16
-{
-    int16_t x1, y1, x2, y2;
-};
-
-struct pixman_region16
-{
-    pixman_box16_t extents;
-    pixman_region16_data_t *data;
-};
-
-typedef enum
-{
-    PIXMAN_REGION_OUT,
-    PIXMAN_REGION_IN,
-    PIXMAN_REGION_PART
-} pixman_region_overlap_t;
-
-
-
-
-void _moz_pixman_region_set_static_pointers (pixman_box16_t *empty_box,
-     pixman_region16_data_t *empty_data,
-     pixman_region16_data_t *broken_data);
-
-
-void _moz_pixman_region_init (pixman_region16_t *region);
-void _moz_pixman_region_init_rect (pixman_region16_t *region,
-         int x,
-         int y,
-         unsigned int width,
-         unsigned int height);
-pixman_bool_t _moz_pixman_region_init_rects (pixman_region16_t *region,
-         const pixman_box16_t *boxes,
-         int count);
-void _moz_pixman_region_init_with_extents (pixman_region16_t *region,
-         pixman_box16_t *extents);
-void _moz_pixman_region_init_from_image (pixman_region16_t *region,
-         pixman_image_t *image);
-void _moz_pixman_region_fini (pixman_region16_t *region);
-
-
-
-void _moz_pixman_region_translate (pixman_region16_t *region,
-         int x,
-         int y);
-pixman_bool_t _moz_pixman_region_copy (pixman_region16_t *dest,
-         pixman_region16_t *source);
-pixman_bool_t _moz_pixman_region_intersect (pixman_region16_t *new_reg,
-         pixman_region16_t *reg1,
-         pixman_region16_t *reg2);
-pixman_bool_t _moz_pixman_region_union (pixman_region16_t *new_reg,
-         pixman_region16_t *reg1,
-         pixman_region16_t *reg2);
-pixman_bool_t _moz_pixman_region_union_rect (pixman_region16_t *dest,
-         pixman_region16_t *source,
-         int x,
-         int y,
-         unsigned int width,
-         unsigned int height);
-pixman_bool_t _moz_pixman_region_intersect_rect (pixman_region16_t *dest,
-         pixman_region16_t *source,
-         int x,
-         int y,
-         unsigned int width,
-         unsigned int height);
-pixman_bool_t _moz_pixman_region_subtract (pixman_region16_t *reg_d,
-         pixman_region16_t *reg_m,
-         pixman_region16_t *reg_s);
-pixman_bool_t _moz_pixman_region_inverse (pixman_region16_t *new_reg,
-         pixman_region16_t *reg1,
-         pixman_box16_t *inv_rect);
-pixman_bool_t _moz_pixman_region_contains_point (pixman_region16_t *region,
-         int x,
-         int y,
-         pixman_box16_t *box);
-pixman_region_overlap_t _moz_pixman_region_contains_rectangle (pixman_region16_t *region,
-         pixman_box16_t *prect);
-pixman_bool_t _moz_pixman_region_not_empty (pixman_region16_t *region);
-pixman_box16_t * _moz_pixman_region_extents (pixman_region16_t *region);
-int _moz_pixman_region_n_rects (pixman_region16_t *region);
-pixman_box16_t * _moz_pixman_region_rectangles (pixman_region16_t *region,
-         int *n_rects);
-pixman_bool_t _moz_pixman_region_equal (pixman_region16_t *region1,
-         pixman_region16_t *region2);
-pixman_bool_t _moz_pixman_region_selfcheck (pixman_region16_t *region);
-void _moz_pixman_region_reset (pixman_region16_t *region,
-         pixman_box16_t *box);
-void _moz_pixman_region_clear (pixman_region16_t *region);
-
-
-
-typedef struct pixman_region32_data pixman_region32_data_t;
-typedef struct pixman_box32 pixman_box32_t;
-typedef struct pixman_rectangle32 pixman_rectangle32_t;
-typedef struct pixman_region32 pixman_region32_t;
-
-struct pixman_region32_data {
-    long size;
-    long numRects;
-
-};
-
-struct pixman_rectangle32
-{
-    int32_t x, y;
-    uint32_t width, height;
-};
-
-struct pixman_box32
-{
-    int32_t x1, y1, x2, y2;
-};
-
-struct pixman_region32
-{
-    pixman_box32_t extents;
-    pixman_region32_data_t *data;
-};
-
-
-void _moz_pixman_region32_init (pixman_region32_t *region);
-void _moz_pixman_region32_init_rect (pixman_region32_t *region,
-           int x,
-           int y,
-           unsigned int width,
-           unsigned int height);
-pixman_bool_t _moz_pixman_region32_init_rects (pixman_region32_t *region,
-           const pixman_box32_t *boxes,
-           int count);
-void _moz_pixman_region32_init_with_extents (pixman_region32_t *region,
-           pixman_box32_t *extents);
-void _moz_pixman_region32_init_from_image (pixman_region32_t *region,
-           pixman_image_t *image);
-void _moz_pixman_region32_fini (pixman_region32_t *region);
-
-
-
-void _moz_pixman_region32_translate (pixman_region32_t *region,
-           int x,
-           int y);
-pixman_bool_t _moz_pixman_region32_copy (pixman_region32_t *dest,
-           pixman_region32_t *source);
-pixman_bool_t _moz_pixman_region32_intersect (pixman_region32_t *new_reg,
-           pixman_region32_t *reg1,
-           pixman_region32_t *reg2);
-pixman_bool_t _moz_pixman_region32_union (pixman_region32_t *new_reg,
-           pixman_region32_t *reg1,
-           pixman_region32_t *reg2);
-pixman_bool_t _moz_pixman_region32_intersect_rect (pixman_region32_t *dest,
-           pixman_region32_t *source,
-           int x,
-           int y,
-           unsigned int width,
-           unsigned int height);
-pixman_bool_t _moz_pixman_region32_union_rect (pixman_region32_t *dest,
-           pixman_region32_t *source,
-           int x,
-           int y,
-           unsigned int width,
-           unsigned int height);
-pixman_bool_t _moz_pixman_region32_subtract (pixman_region32_t *reg_d,
-           pixman_region32_t *reg_m,
-           pixman_region32_t *reg_s);
-pixman_bool_t _moz_pixman_region32_inverse (pixman_region32_t *new_reg,
-           pixman_region32_t *reg1,
-           pixman_box32_t *inv_rect);
-pixman_bool_t _moz_pixman_region32_contains_point (pixman_region32_t *region,
-           int x,
-           int y,
-           pixman_box32_t *box);
-pixman_region_overlap_t _moz_pixman_region32_contains_rectangle (pixman_region32_t *region,
-           pixman_box32_t *prect);
-pixman_bool_t _moz_pixman_region32_not_empty (pixman_region32_t *region);
-pixman_box32_t * _moz_pixman_region32_extents (pixman_region32_t *region);
-int _moz_pixman_region32_n_rects (pixman_region32_t *region);
-pixman_box32_t * _moz_pixman_region32_rectangles (pixman_region32_t *region,
-           int *n_rects);
-pixman_bool_t _moz_pixman_region32_equal (pixman_region32_t *region1,
-           pixman_region32_t *region2);
-pixman_bool_t _moz_pixman_region32_selfcheck (pixman_region32_t *region);
-void _moz_pixman_region32_reset (pixman_region32_t *region,
-           pixman_box32_t *box);
-void _moz_pixman_region32_clear (pixman_region32_t *region);
-
-
-
-pixman_bool_t _moz_pixman_blt (uint32_t *src_bits,
-      uint32_t *dst_bits,
-      int src_stride,
-      int dst_stride,
-      int src_bpp,
-      int dst_bpp,
-      int src_x,
-      int src_y,
-      int dest_x,
-      int dest_y,
-      int width,
-      int height);
-pixman_bool_t _moz_pixman_fill (uint32_t *bits,
-      int stride,
-      int bpp,
-      int x,
-      int y,
-      int width,
-      int height,
-      uint32_t _xor);
-
-int _moz_pixman_version (void);
-const char* _moz_pixman_version_string (void);
-
-
-
-
-typedef struct pixman_indexed pixman_indexed_t;
-typedef struct pixman_gradient_stop pixman_gradient_stop_t;
-
-typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
-typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
-
-typedef void (* pixman_image_destroy_func_t) (pixman_image_t *image, void *data);
-
-struct pixman_gradient_stop {
-    pixman_fixed_t x;
-    pixman_color_t color;
-};
-
-
-
-
-typedef uint8_t pixman_index_type;
-
-
-struct pixman_indexed
-{
-    pixman_bool_t color;
-    uint32_t rgba[256];
-    pixman_index_type ent[32768];
-};
-# 694 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-typedef enum {
-    PIXMAN_a8r8g8b8 = (((32) << 24) | ((2) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_x8r8g8b8 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_a8b8g8r8 = (((32) << 24) | ((3) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_x8b8g8r8 = (((32) << 24) | ((3) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_b8g8r8a8 = (((32) << 24) | ((8) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_b8g8r8x8 = (((32) << 24) | ((8) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_r8g8b8a8 = (((32) << 24) | ((9) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_r8g8b8x8 = (((32) << 24) | ((9) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_x14r6g6b6 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((6) << 8) | ((6) << 4) | ((6))),
-    PIXMAN_x2r10g10b10 = (((32) << 24) | ((2) << 16) | ((0) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
-    PIXMAN_a2r10g10b10 = (((32) << 24) | ((2) << 16) | ((2) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
-    PIXMAN_x2b10g10r10 = (((32) << 24) | ((3) << 16) | ((0) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
-    PIXMAN_a2b10g10r10 = (((32) << 24) | ((3) << 16) | ((2) << 12) | ((10) << 8) | ((10) << 4) | ((10))),
-
-
-    PIXMAN_a8r8g8b8_sRGB = (((32) << 24) | ((10) << 16) | ((8) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-
-
-    PIXMAN_r8g8b8 = (((24) << 24) | ((2) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-    PIXMAN_b8g8r8 = (((24) << 24) | ((3) << 16) | ((0) << 12) | ((8) << 8) | ((8) << 4) | ((8))),
-
-
-    PIXMAN_r5g6b5 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((5) << 8) | ((6) << 4) | ((5))),
-    PIXMAN_b5g6r5 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((5) << 8) | ((6) << 4) | ((5))),
-
-    PIXMAN_a1r5g5b5 = (((16) << 24) | ((2) << 16) | ((1) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
-    PIXMAN_x1r5g5b5 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
-    PIXMAN_a1b5g5r5 = (((16) << 24) | ((3) << 16) | ((1) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
-    PIXMAN_x1b5g5r5 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((5) << 8) | ((5) << 4) | ((5))),
-    PIXMAN_a4r4g4b4 = (((16) << 24) | ((2) << 16) | ((4) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
-    PIXMAN_x4r4g4b4 = (((16) << 24) | ((2) << 16) | ((0) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
-    PIXMAN_a4b4g4r4 = (((16) << 24) | ((3) << 16) | ((4) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
-    PIXMAN_x4b4g4r4 = (((16) << 24) | ((3) << 16) | ((0) << 12) | ((4) << 8) | ((4) << 4) | ((4))),
-
-
-    PIXMAN_a8 = (((8) << 24) | ((1) << 16) | ((8) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_r3g3b2 = (((8) << 24) | ((2) << 16) | ((0) << 12) | ((3) << 8) | ((3) << 4) | ((2))),
-    PIXMAN_b2g3r3 = (((8) << 24) | ((3) << 16) | ((0) << 12) | ((3) << 8) | ((3) << 4) | ((2))),
-    PIXMAN_a2r2g2b2 = (((8) << 24) | ((2) << 16) | ((2) << 12) | ((2) << 8) | ((2) << 4) | ((2))),
-    PIXMAN_a2b2g2r2 = (((8) << 24) | ((3) << 16) | ((2) << 12) | ((2) << 8) | ((2) << 4) | ((2))),
-
-    PIXMAN_c8 = (((8) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_g8 = (((8) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-    PIXMAN_x4a4 = (((8) << 24) | ((1) << 16) | ((4) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-    PIXMAN_x4c4 = (((8) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_x4g4 = (((8) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-
-    PIXMAN_a4 = (((4) << 24) | ((1) << 16) | ((4) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_r1g2b1 = (((4) << 24) | ((2) << 16) | ((0) << 12) | ((1) << 8) | ((2) << 4) | ((1))),
-    PIXMAN_b1g2r1 = (((4) << 24) | ((3) << 16) | ((0) << 12) | ((1) << 8) | ((2) << 4) | ((1))),
-    PIXMAN_a1r1g1b1 = (((4) << 24) | ((2) << 16) | ((1) << 12) | ((1) << 8) | ((1) << 4) | ((1))),
-    PIXMAN_a1b1g1r1 = (((4) << 24) | ((3) << 16) | ((1) << 12) | ((1) << 8) | ((1) << 4) | ((1))),
-
-    PIXMAN_c4 = (((4) << 24) | ((4) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_g4 = (((4) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-
-    PIXMAN_a1 = (((1) << 24) | ((1) << 16) | ((1) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-    PIXMAN_g1 = (((1) << 24) | ((5) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-
-
-    PIXMAN_yuy2 = (((16) << 24) | ((6) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0))),
-    PIXMAN_yv12 = (((12) << 24) | ((7) << 16) | ((0) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
-} pixman_format_code_t;
-
-
-pixman_bool_t _moz_pixman_format_supported_destination (pixman_format_code_t format);
-pixman_bool_t _moz_pixman_format_supported_source (pixman_format_code_t format);
-
-
-pixman_image_t *_moz_pixman_image_create_solid_fill (const pixman_color_t *color);
-pixman_image_t *_moz_pixman_image_create_linear_gradient (const pixman_point_fixed_t *p1,
-            const pixman_point_fixed_t *p2,
-            const pixman_gradient_stop_t *stops,
-            int n_stops);
-pixman_image_t *_moz_pixman_image_create_radial_gradient (const pixman_point_fixed_t *inner,
-            const pixman_point_fixed_t *outer,
-            pixman_fixed_t inner_radius,
-            pixman_fixed_t outer_radius,
-            const pixman_gradient_stop_t *stops,
-            int n_stops);
-pixman_image_t *_moz_pixman_image_create_conical_gradient (const pixman_point_fixed_t *center,
-            pixman_fixed_t angle,
-            const pixman_gradient_stop_t *stops,
-            int n_stops);
-pixman_image_t *_moz_pixman_image_create_bits (pixman_format_code_t format,
-            int width,
-            int height,
-            uint32_t *bits,
-            int rowstride_bytes);
-pixman_image_t *pixman_image_create_bits_no_clear (pixman_format_code_t format,
-            int width,
-            int height,
-            uint32_t * bits,
-            int rowstride_bytes);
-
-
-pixman_image_t *_moz_pixman_image_ref (pixman_image_t *image);
-pixman_bool_t _moz_pixman_image_unref (pixman_image_t *image);
-
-void _moz_pixman_image_set_destroy_function (pixman_image_t *image,
-            pixman_image_destroy_func_t function,
-            void *data);
-void * _moz_pixman_image_get_destroy_data (pixman_image_t *image);
-
-
-pixman_bool_t _moz_pixman_image_set_clip_region (pixman_image_t *image,
-            pixman_region16_t *region);
-pixman_bool_t _moz_pixman_image_set_clip_region32 (pixman_image_t *image,
-            pixman_region32_t *region);
-void _moz_pixman_image_set_has_client_clip (pixman_image_t *image,
-            pixman_bool_t clien_clip);
-pixman_bool_t _moz_pixman_image_set_transform (pixman_image_t *image,
-            const pixman_transform_t *transform);
-void _moz_pixman_image_set_repeat (pixman_image_t *image,
-            pixman_repeat_t repeat);
-pixman_bool_t _moz_pixman_image_set_filter (pixman_image_t *image,
-            pixman_filter_t filter,
-            const pixman_fixed_t *filter_params,
-            int n_filter_params);
-void _moz_pixman_image_set_source_clipping (pixman_image_t *image,
-            pixman_bool_t source_clipping);
-void _moz_pixman_image_set_alpha_map (pixman_image_t *image,
-            pixman_image_t *alpha_map,
-            int16_t x,
-            int16_t y);
-void _moz_pixman_image_set_component_alpha (pixman_image_t *image,
-            pixman_bool_t component_alpha);
-pixman_bool_t _moz_pixman_image_get_component_alpha (pixman_image_t *image);
-void _moz_pixman_image_set_accessors (pixman_image_t *image,
-            pixman_read_memory_func_t read_func,
-            pixman_write_memory_func_t write_func);
-void _moz_pixman_image_set_indexed (pixman_image_t *image,
-            const pixman_indexed_t *indexed);
-uint32_t *_moz_pixman_image_get_data (pixman_image_t *image);
-int _moz_pixman_image_get_width (pixman_image_t *image);
-int _moz_pixman_image_get_height (pixman_image_t *image);
-int _moz_pixman_image_get_stride (pixman_image_t *image);
-int _moz_pixman_image_get_depth (pixman_image_t *image);
-pixman_format_code_t _moz_pixman_image_get_format (pixman_image_t *image);
-
-typedef enum
-{
-    PIXMAN_KERNEL_IMPULSE,
-    PIXMAN_KERNEL_BOX,
-    PIXMAN_KERNEL_LINEAR,
-    PIXMAN_KERNEL_CUBIC,
-    PIXMAN_KERNEL_GAUSSIAN,
-    PIXMAN_KERNEL_LANCZOS2,
-    PIXMAN_KERNEL_LANCZOS3,
-    PIXMAN_KERNEL_LANCZOS3_STRETCHED
-} pixman_kernel_t;
-
-
-
-
-pixman_fixed_t *
-pixman_filter_create_separable_convolution (int *n_values,
-         pixman_fixed_t scale_x,
-         pixman_fixed_t scale_y,
-         pixman_kernel_t reconstruct_x,
-         pixman_kernel_t reconstruct_y,
-         pixman_kernel_t sample_x,
-         pixman_kernel_t sample_y,
-         int subsample_bits_x,
-         int subsample_bits_y);
-
-pixman_bool_t _moz_pixman_image_fill_rectangles (pixman_op_t op,
-            pixman_image_t *image,
-            const pixman_color_t *color,
-            int n_rects,
-            const pixman_rectangle16_t *rects);
-pixman_bool_t _moz_pixman_image_fill_boxes (pixman_op_t op,
-                                                      pixman_image_t *dest,
-                                                      const pixman_color_t *color,
-                                                      int n_boxes,
-                                                      const pixman_box32_t *boxes);
-
-
-pixman_bool_t _moz_pixman_compute_composite_region (pixman_region16_t *region,
-            pixman_image_t *src_image,
-            pixman_image_t *mask_image,
-            pixman_image_t *dest_image,
-            int16_t src_x,
-            int16_t src_y,
-            int16_t mask_x,
-            int16_t mask_y,
-            int16_t dest_x,
-            int16_t dest_y,
-            uint16_t width,
-            uint16_t height);
-void _moz_pixman_image_composite (pixman_op_t op,
-            pixman_image_t *src,
-            pixman_image_t *mask,
-            pixman_image_t *dest,
-            int16_t src_x,
-            int16_t src_y,
-            int16_t mask_x,
-            int16_t mask_y,
-            int16_t dest_x,
-            int16_t dest_y,
-            uint16_t width,
-            uint16_t height);
-void _moz_pixman_image_composite32 (pixman_op_t op,
-            pixman_image_t *src,
-            pixman_image_t *mask,
-            pixman_image_t *dest,
-            int32_t src_x,
-            int32_t src_y,
-            int32_t mask_x,
-            int32_t mask_y,
-            int32_t dest_x,
-            int32_t dest_y,
-            int32_t width,
-            int32_t height);
-# 933 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/pixman.h"
-void _moz_pixman_disable_out_of_bounds_workaround (void);
-
-
-
-
-typedef struct pixman_glyph_cache_t pixman_glyph_cache_t;
-typedef struct
-{
-    int x, y;
-    const void *glyph;
-} pixman_glyph_t;
-
-pixman_glyph_cache_t *_moz_pixman_glyph_cache_create (void);
-void _moz_pixman_glyph_cache_destroy (pixman_glyph_cache_t *cache);
-void _moz_pixman_glyph_cache_freeze (pixman_glyph_cache_t *cache);
-void _moz_pixman_glyph_cache_thaw (pixman_glyph_cache_t *cache);
-const void * _moz_pixman_glyph_cache_lookup (pixman_glyph_cache_t *cache,
-             void *font_key,
-             void *glyph_key);
-const void * _moz_pixman_glyph_cache_insert (pixman_glyph_cache_t *cache,
-             void *font_key,
-             void *glyph_key,
-             int origin_x,
-             int origin_y,
-             pixman_image_t *glyph_image);
-void _moz_pixman_glyph_cache_remove (pixman_glyph_cache_t *cache,
-             void *font_key,
-             void *glyph_key);
-void _moz_pixman_glyph_get_extents (pixman_glyph_cache_t *cache,
-             int n_glyphs,
-             pixman_glyph_t *glyphs,
-             pixman_box32_t *extents);
-pixman_format_code_t _moz_pixman_glyph_get_mask_format (pixman_glyph_cache_t *cache,
-             int n_glyphs,
-             const pixman_glyph_t *glyphs);
-void _moz_pixman_composite_glyphs (pixman_op_t op,
-             pixman_image_t *src,
-             pixman_image_t *dest,
-             pixman_format_code_t mask_format,
-             int32_t src_x,
-             int32_t src_y,
-             int32_t mask_x,
-             int32_t mask_y,
-             int32_t dest_x,
-             int32_t dest_y,
-             int32_t width,
-             int32_t height,
-             pixman_glyph_cache_t *cache,
-             int n_glyphs,
-             const pixman_glyph_t *glyphs);
-void _moz_pixman_composite_glyphs_no_mask (pixman_op_t op,
-             pixman_image_t *src,
-             pixman_image_t *dest,
-             int32_t src_x,
-             int32_t src_y,
-             int32_t dest_x,
-             int32_t dest_y,
-             pixman_glyph_cache_t *cache,
-             int n_glyphs,
-             const pixman_glyph_t *glyphs);
-
-
-
-
-typedef struct pixman_edge pixman_edge_t;
-typedef struct pixman_trapezoid pixman_trapezoid_t;
-typedef struct pixman_trap pixman_trap_t;
-typedef struct pixman_span_fix pixman_span_fix_t;
-typedef struct pixman_triangle pixman_triangle_t;
-
-
-
-
-
-
-struct pixman_edge
-{
-    pixman_fixed_t x;
-    pixman_fixed_t e;
-    pixman_fixed_t stepx;
-    pixman_fixed_t signdx;
-    pixman_fixed_t dy;
-    pixman_fixed_t dx;
-
-    pixman_fixed_t stepx_small;
-    pixman_fixed_t stepx_big;
-    pixman_fixed_t dx_small;
-    pixman_fixed_t dx_big;
-};
-
-struct pixman_trapezoid
-{
-    pixman_fixed_t top, bottom;
-    pixman_line_fixed_t left, right;
-};
-
-struct pixman_triangle
-{
-    pixman_point_fixed_t p1, p2, p3;
-};
-
-
-
-
-
-
-
-struct pixman_span_fix
-{
-    pixman_fixed_t l, r, y;
-};
-
-struct pixman_trap
-{
-    pixman_span_fix_t top, bot;
-};
-
-pixman_fixed_t _moz_pixman_sample_ceil_y (pixman_fixed_t y,
-         int bpp);
-pixman_fixed_t _moz_pixman_sample_floor_y (pixman_fixed_t y,
-         int bpp);
-void _moz_pixman_edge_step (pixman_edge_t *e,
-         int n);
-void _moz_pixman_edge_init (pixman_edge_t *e,
-         int bpp,
-         pixman_fixed_t y_start,
-         pixman_fixed_t x_top,
-         pixman_fixed_t y_top,
-         pixman_fixed_t x_bot,
-         pixman_fixed_t y_bot);
-void _moz_pixman_line_fixed_edge_init (pixman_edge_t *e,
-         int bpp,
-         pixman_fixed_t y,
-         const pixman_line_fixed_t *line,
-         int x_off,
-         int y_off);
-void _moz_pixman_rasterize_edges (pixman_image_t *image,
-         pixman_edge_t *l,
-         pixman_edge_t *r,
-         pixman_fixed_t t,
-         pixman_fixed_t b);
-void _moz_pixman_add_traps (pixman_image_t *image,
-         int16_t x_off,
-         int16_t y_off,
-         int ntrap,
-         const pixman_trap_t *traps);
-void _moz_pixman_add_trapezoids (pixman_image_t *image,
-         int16_t x_off,
-         int y_off,
-         int ntraps,
-         const pixman_trapezoid_t *traps);
-void _moz_pixman_rasterize_trapezoid (pixman_image_t *image,
-         const pixman_trapezoid_t *trap,
-         int x_off,
-         int y_off);
-void _moz_pixman_composite_trapezoids (pixman_op_t op,
-        pixman_image_t * src,
-        pixman_image_t * dst,
-        pixman_format_code_t mask_format,
-        int x_src,
-        int y_src,
-        int x_dst,
-        int y_dst,
-        int n_traps,
-        const pixman_trapezoid_t * traps);
-void _moz_pixman_composite_triangles (pixman_op_t op,
-       pixman_image_t * src,
-       pixman_image_t * dst,
-       pixman_format_code_t mask_format,
-       int x_src,
-       int y_src,
-       int x_dst,
-       int y_dst,
-       int n_tris,
-       const pixman_triangle_t * tris);
-void _moz_pixman_add_triangles (pixman_image_t *image,
-       int32_t x_off,
-       int32_t y_off,
-       int n_tris,
-       const pixman_triangle_t *tris);
-
-}
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h" 2
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-enum class VisitSide {
- TOP,
- BOTTOM,
- LEFT,
- RIGHT
-};
-
-class nsRegion
-{
-public:
-  typedef nsRect RectType;
-  typedef nsPoint PointType;
-  typedef nsMargin MarginType;
-
-  nsRegion () { _moz_pixman_region32_init(&mImpl); }
-               nsRegion (const nsRect& aRect) { _moz_pixman_region32_init_rect(&mImpl,
-                                                                          aRect.x,
-                                                                          aRect.y,
-                                                                          aRect.width,
-                                                                          aRect.height); }
-  explicit nsRegion (mozilla::gfx::ArrayView<pixman_box32_t> aRects)
-  {
-    _moz_pixman_region32_init_rects(&mImpl, aRects.Data(), aRects.Length());
-  }
-  nsRegion (const nsRegion& aRegion) { _moz_pixman_region32_init(&mImpl); _moz_pixman_region32_copy(&mImpl,aRegion.Impl()); }
-  nsRegion (nsRegion&& aRegion) { mImpl = aRegion.mImpl; _moz_pixman_region32_init(&aRegion.mImpl); }
-  nsRegion& operator = (nsRegion&& aRegion) {
-      _moz_pixman_region32_fini(&mImpl);
-      mImpl = aRegion.mImpl;
-      _moz_pixman_region32_init(&aRegion.mImpl);
-      return *this;
-  }
- ~nsRegion () { _moz_pixman_region32_fini(&mImpl); }
-  nsRegion& operator = (const nsRect& aRect) { Copy (aRect); return *this; }
-  nsRegion& operator = (const nsRegion& aRegion) { Copy (aRegion); return *this; }
-  bool operator==(const nsRegion& aRgn) const
-  {
-    return IsEqual(aRgn);
-  }
-  bool operator!=(const nsRegion& aRgn) const
-  {
-    return !(*this == aRgn);
-  }
-
-  friend std::ostream& operator<<(std::ostream& stream, const nsRegion& m);
-
-  void Swap(nsRegion* aOther)
-  {
-    pixman_region32_t tmp = mImpl;
-    mImpl = aOther->mImpl;
-    aOther->mImpl = tmp;
-  }
-
-  static
-  nsresult InitStatic()
-  {
-    return NS_OK;
-  }
-
-  static
-  void ShutdownStatic() {}
-
-  void AndWith(const nsRegion& aOther)
-  {
-    And(*this, aOther);
-  }
-  void AndWith(const nsRect& aOther)
-  {
-    And(*this, aOther);
-  }
-  nsRegion& And(const nsRegion& aRgn1, const nsRegion& aRgn2)
-  {
-    _moz_pixman_region32_intersect(&mImpl, aRgn1.Impl(), aRgn2.Impl());
-    return *this;
-  }
-  nsRegion& And(const nsRect& aRect, const nsRegion& aRegion)
-  {
-    return And(aRegion, aRect);
-  }
-  nsRegion& And(const nsRegion& aRegion, const nsRect& aRect)
-  {
-    _moz_pixman_region32_intersect_rect(&mImpl, aRegion.Impl(), aRect.x, aRect.y, aRect.width, aRect.height);
-    return *this;
-  }
-  nsRegion& And(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    nsRect TmpRect;
-
-    TmpRect.IntersectRect(aRect1, aRect2);
-    return Copy(TmpRect);
-  }
-
-  nsRegion& OrWith(const nsRegion& aOther)
-  {
-    return Or(*this, aOther);
-  }
-  nsRegion& OrWith(const nsRect& aOther)
-  {
-    return Or(*this, aOther);
-  }
-  nsRegion& Or(const nsRegion& aRgn1, const nsRegion& aRgn2)
-  {
-    _moz_pixman_region32_union(&mImpl, aRgn1.Impl(), aRgn2.Impl());
-    return *this;
-  }
-  nsRegion& Or(const nsRegion& aRegion, const nsRect& aRect)
-  {
-    _moz_pixman_region32_union_rect(&mImpl, aRegion.Impl(), aRect.x, aRect.y, aRect.width, aRect.height);
-    return *this;
-  }
-  nsRegion& Or(const nsRect& aRect, const nsRegion& aRegion)
-  {
-    return Or(aRegion, aRect);
-  }
-  nsRegion& Or(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    Copy (aRect1);
-    return Or (*this, aRect2);
-  }
-
-  nsRegion& XorWith(const nsRegion& aOther)
-  {
-    return Xor(*this, aOther);
-  }
-  nsRegion& XorWith(const nsRect& aOther)
-  {
-    return Xor(*this, aOther);
-  }
-  nsRegion& Xor(const nsRegion& aRgn1, const nsRegion& aRgn2)
-  {
-
-
-    nsRegion p;
-    p.Sub(aRgn1, aRgn2);
-    nsRegion q;
-    q.Sub(aRgn2, aRgn1);
-    return Or(p, q);
-  }
-  nsRegion& Xor(const nsRegion& aRegion, const nsRect& aRect)
-  {
-    return Xor(aRegion, nsRegion(aRect));
-  }
-  nsRegion& Xor(const nsRect& aRect, const nsRegion& aRegion)
-  {
-    return Xor(nsRegion(aRect), aRegion);
-  }
-  nsRegion& Xor(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    return Xor(nsRegion(aRect1), nsRegion(aRect2));
-  }
-
-  nsRegion ToAppUnits (nscoord aAppUnitsPerPixel) const;
-
-  nsRegion& SubOut(const nsRegion& aOther)
-  {
-    return Sub(*this, aOther);
-  }
-  nsRegion& SubOut(const nsRect& aOther)
-  {
-    return Sub(*this, aOther);
-  }
-  nsRegion& Sub(const nsRegion& aRgn1, const nsRegion& aRgn2)
-  {
-    _moz_pixman_region32_subtract(&mImpl, aRgn1.Impl(), aRgn2.Impl());
-    return *this;
-  }
-  nsRegion& Sub(const nsRegion& aRegion, const nsRect& aRect)
-  {
-    return Sub(aRegion, nsRegion(aRect));
-  }
-  nsRegion& Sub(const nsRect& aRect, const nsRegion& aRegion)
-  {
-    return Sub(nsRegion(aRect), aRegion);
-  }
-  nsRegion& Sub(const nsRect& aRect1, const nsRect& aRect2)
-  {
-    Copy(aRect1);
-    return Sub(*this, aRect2);
-  }
-
-
-
-
-
-
-  bool Contains (int aX, int aY) const
-  {
-    return _moz_pixman_region32_contains_point(Impl(), aX, aY, nullptr);
-  }
-  bool Contains (const nsRect& aRect) const
-  {
-    pixman_box32_t box = RectToBox(aRect);
-    return _moz_pixman_region32_contains_rectangle(Impl(), &box) == PIXMAN_REGION_IN;
-  }
-  bool Contains (const nsRegion& aRgn) const;
-  bool Intersects (const nsRect& aRect) const;
-
-  void MoveBy (int32_t aXOffset, int32_t aYOffset)
-  {
-    MoveBy (nsPoint (aXOffset, aYOffset));
-  }
-  void MoveBy (nsPoint aPt) { _moz_pixman_region32_translate(&mImpl, aPt.x, aPt.y); }
-  void SetEmpty ()
-  {
-    _moz_pixman_region32_clear(&mImpl);
-  }
-
-  nsRegion MovedBy(int32_t aXOffset, int32_t aYOffset) const
-  {
-    return MovedBy(nsPoint(aXOffset, aYOffset));
-  }
-  nsRegion MovedBy(const nsPoint& aPt) const
-  {
-    nsRegion copy(*this);
-    copy.MoveBy(aPt);
-    return copy;
-  }
-
-  nsRegion Intersect(const nsRegion& aOther) const
-  {
-    nsRegion intersection;
-    intersection.And(*this, aOther);
-    return intersection;
-  }
-
-  void Inflate(const nsMargin& aMargin);
-
-  nsRegion Inflated(const nsMargin& aMargin) const
-  {
-    nsRegion copy(*this);
-    copy.Inflate(aMargin);
-    return copy;
-  }
-
-  bool IsEmpty () const { return !_moz_pixman_region32_not_empty(Impl()); }
-  bool IsComplex () const { return GetNumRects() > 1; }
-  bool IsEqual (const nsRegion& aRegion) const
-  {
-    return _moz_pixman_region32_equal(Impl(), aRegion.Impl());
-  }
-  uint32_t GetNumRects () const
-  {
-
-
-    uint32_t result = _moz_pixman_region32_n_rects(Impl());
-    return (result == 1 && GetBounds().IsEmpty()) ? 0 : result;
-  }
-  const nsRect GetBounds () const { return BoxToRect(mImpl.extents); }
-  uint64_t Area () const;
-# 300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-  __attribute__ ((warn_unused_result)) nsRegion
-    ScaleToOtherAppUnitsRoundOut (int32_t aFromAPP, int32_t aToAPP) const;
-  __attribute__ ((warn_unused_result)) nsRegion
-    ScaleToOtherAppUnitsRoundIn (int32_t aFromAPP, int32_t aToAPP) const;
-  nsRegion& ScaleRoundOut(float aXScale, float aYScale);
-  nsRegion& ScaleInverseRoundOut(float aXScale, float aYScale);
-  nsRegion& Transform (const mozilla::gfx::Matrix4x4 &aTransform);
-  nsIntRegion ScaleToOutsidePixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
-  nsIntRegion ScaleToInsidePixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
-  nsIntRegion ScaleToNearestPixels (float aXScale, float aYScale, nscoord aAppUnitsPerPixel) const;
-  nsIntRegion ToOutsidePixels (nscoord aAppUnitsPerPixel) const;
-  nsIntRegion ToNearestPixels (nscoord aAppUnitsPerPixel) const;
-
-
-
-
-
-
-
-  nsRect GetLargestRectangle (const nsRect& aContainingRect = nsRect()) const;
-
-
-
-
-
-
-
-  void SimplifyOutward (uint32_t aMaxRects);
-
-
-
-
-
-
-  void SimplifyOutwardByArea(uint32_t aThreshold);
-
-
-
-
-
-  void SimplifyInward (uint32_t aMaxRects);
-# 354 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-  typedef void (*visitFn)(void *closure, VisitSide side, int x1, int y1, int x2, int y2);
-  void VisitEdges(visitFn, void *closure);
-
-  nsCString ToString() const;
-
-  class RectIterator
-  {
-    int mCurrent;
-    int mLimit;
-    mutable nsRect mTmp;
-    pixman_box32_t *mBoxes;
-
-  public:
-    explicit RectIterator(const nsRegion& aRegion)
-    {
-      mCurrent = 0;
-      mBoxes = _moz_pixman_region32_rectangles(aRegion.Impl(), &mLimit);
-
-
-      if (mLimit == 1 && nsRegion::BoxToRect(mBoxes[0]).IsEmpty()) {
-        mLimit = 0;
-      }
-    }
-
-    bool Done() const { return mCurrent == mLimit; }
-
-    const nsRect& Get() const
-    {
-      do { } while (0);
-      mTmp = nsRegion::BoxToRect(mBoxes[mCurrent]);
-      do { } while(0);
-      return mTmp;
-    }
-
-    void Next()
-    {
-      do { } while (0);
-      mCurrent++;
-    }
-  };
-
-  RectIterator RectIter() const { return RectIterator(*this); }
-
-private:
-  pixman_region32_t mImpl;
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsRegion.h"
-  nsIntRegion ToPixels(nscoord aAppUnitsPerPixel, bool aOutsidePixels) const;
-
-  nsRegion& Copy (const nsRegion& aRegion)
-  {
-    _moz_pixman_region32_copy(&mImpl, aRegion.Impl());
-    return *this;
-  }
-
-  nsRegion& Copy (const nsRect& aRect)
-  {
-
-
-
-
-
-    if (aRect.IsEmpty()) {
-      _moz_pixman_region32_clear(&mImpl);
-    } else {
-      pixman_box32_t box = RectToBox(aRect);
-      _moz_pixman_region32_reset(&mImpl, &box);
-    }
-    return *this;
-  }
-
-  static inline pixman_box32_t RectToBox(const nsRect &aRect)
-  {
-    pixman_box32_t box = { aRect.x, aRect.y, aRect.XMost(), aRect.YMost() };
-    return box;
-  }
-
-  static inline pixman_box32_t RectToBox(const mozilla::gfx::IntRect &aRect)
-  {
-    pixman_box32_t box = { aRect.x, aRect.y, aRect.XMost(), aRect.YMost() };
-    return box;
-  }
-
-
-  static inline nsRect BoxToRect(const pixman_box32_t &aBox)
-  {
-    return nsRect(aBox.x1, aBox.y1,
-                  aBox.x2 - aBox.x1,
-                  aBox.y2 - aBox.y1);
-  }
-
-  pixman_region32_t* Impl() const
-  {
-    return const_cast<pixman_region32_t*>(&mImpl);
-  }
-};
-
-namespace mozilla {
-namespace gfx {
-
-
-
-
-template <typename Derived, typename Rect, typename Point, typename Margin>
-class BaseIntRegion
-{
-  friend class ::nsRegion;
-
-
-
-  template <typename units>
-  friend class IntRegionTyped;
-
-public:
-  typedef Rect RectType;
-  typedef Point PointType;
-  typedef Margin MarginType;
-
-  BaseIntRegion () {}
-               BaseIntRegion (const Rect& aRect) : mImpl (ToRect(aRect)) {}
-  explicit BaseIntRegion (mozilla::gfx::ArrayView<pixman_box32_t> aRects) : mImpl (aRects) {}
-  BaseIntRegion (const BaseIntRegion& aRegion) : mImpl (aRegion.mImpl) {}
-  BaseIntRegion (BaseIntRegion&& aRegion) : mImpl (mozilla::Move(aRegion.mImpl)) {}
-  Derived& operator = (const Rect& aRect) { mImpl = ToRect (aRect); return This(); }
-  Derived& operator = (const Derived& aRegion) { mImpl = aRegion.mImpl; return This(); }
-  Derived& operator = (Derived&& aRegion) { mImpl = mozilla::Move(aRegion.mImpl); return This(); }
-
-  bool operator==(const Derived& aRgn) const
-  {
-    return IsEqual(aRgn);
-  }
-  bool operator!=(const Derived& aRgn) const
-  {
-    return !(*this == aRgn);
-  }
-
-  friend std::ostream& operator<<(std::ostream& stream, const Derived& m) {
-    return stream << m.mImpl;
-  }
-
-  void Swap(Derived* aOther)
-  {
-    mImpl.Swap(&aOther->mImpl);
-  }
-
-  void AndWith(const Derived& aOther)
-  {
-    And(This(), aOther);
-  }
-  void AndWith(const Rect& aOther)
-  {
-    And(This(), aOther);
-  }
-  Derived& And (const Derived& aRgn1, const Derived& aRgn2)
-  {
-    mImpl.And (aRgn1.mImpl, aRgn2.mImpl);
-    return This();
-  }
-  Derived& And (const Derived& aRegion, const Rect& aRect)
-  {
-    mImpl.And (aRegion.mImpl, ToRect (aRect));
-    return This();
-  }
-  Derived& And (const Rect& aRect, const Derived& aRegion)
-  {
-    return And (aRegion, aRect);
-  }
-  Derived& And (const Rect& aRect1, const Rect& aRect2)
-  {
-    Rect TmpRect;
-
-    TmpRect.IntersectRect (aRect1, aRect2);
-    mImpl = ToRect (TmpRect);
-    return This();
-  }
-
-  Derived& OrWith(const Derived& aOther)
-  {
-    return Or(This(), aOther);
-  }
-  Derived& OrWith(const Rect& aOther)
-  {
-    return Or(This(), aOther);
-  }
-  Derived& Or (const Derived& aRgn1, const Derived& aRgn2)
-  {
-    mImpl.Or (aRgn1.mImpl, aRgn2.mImpl);
-    return This();
-  }
-  Derived& Or (const Derived& aRegion, const Rect& aRect)
-  {
-    mImpl.Or (aRegion.mImpl, ToRect (aRect));
-    return This();
-  }
-  Derived& Or (const Rect& aRect, const Derived& aRegion)
-  {
-    return Or (aRegion, aRect);
-  }
-  Derived& Or (const Rect& aRect1, const Rect& aRect2)
-  {
-    mImpl = ToRect (aRect1);
-    return Or (This(), aRect2);
-  }
-
-  Derived& XorWith(const Derived& aOther)
-  {
-    return Xor(This(), aOther);
-  }
-  Derived& XorWith(const Rect& aOther)
-  {
-    return Xor(This(), aOther);
-  }
-  Derived& Xor (const Derived& aRgn1, const Derived& aRgn2)
-  {
-    mImpl.Xor (aRgn1.mImpl, aRgn2.mImpl);
-    return This();
-  }
-  Derived& Xor (const Derived& aRegion, const Rect& aRect)
-  {
-    mImpl.Xor (aRegion.mImpl, ToRect (aRect));
-    return This();
-  }
-  Derived& Xor (const Rect& aRect, const Derived& aRegion)
-  {
-    return Xor (aRegion, aRect);
-  }
-  Derived& Xor (const Rect& aRect1, const Rect& aRect2)
-  {
-    mImpl = ToRect (aRect1);
-    return Xor (This(), aRect2);
-  }
-
-  Derived& SubOut(const Derived& aOther)
-  {
-    return Sub(This(), aOther);
-  }
-  Derived& SubOut(const Rect& aOther)
-  {
-    return Sub(This(), aOther);
-  }
-  Derived& Sub (const Derived& aRgn1, const Derived& aRgn2)
-  {
-    mImpl.Sub (aRgn1.mImpl, aRgn2.mImpl);
-    return This();
-  }
-  Derived& Sub (const Derived& aRegion, const Rect& aRect)
-  {
-    mImpl.Sub (aRegion.mImpl, ToRect (aRect));
-    return This();
-  }
-  Derived& Sub (const Rect& aRect, const Derived& aRegion)
-  {
-    return Sub (Derived (aRect), aRegion);
-  }
-  Derived& Sub (const Rect& aRect1, const Rect& aRect2)
-  {
-    mImpl = ToRect (aRect1);
-    return Sub (This(), aRect2);
-  }
-
-
-
-
-
-
-  bool Contains (int aX, int aY) const
-  {
-    return mImpl.Contains(aX, aY);
-  }
-  bool Contains (const Rect& aRect) const
-  {
-    return mImpl.Contains (ToRect (aRect));
-  }
-  bool Contains (const Derived& aRgn) const
-  {
-    return mImpl.Contains (aRgn.mImpl);
-  }
-  bool Intersects (const Rect& aRect) const
-  {
-    return mImpl.Intersects (ToRect (aRect));
-  }
-
-  void MoveBy (int32_t aXOffset, int32_t aYOffset)
-  {
-    MoveBy (Point (aXOffset, aYOffset));
-  }
-  void MoveBy (Point aPt)
-  {
-    mImpl.MoveBy (aPt.x, aPt.y);
-  }
-  Derived MovedBy(int32_t aXOffset, int32_t aYOffset) const
-  {
-    return MovedBy(Point(aXOffset, aYOffset));
-  }
-  Derived MovedBy(const Point& aPt) const
-  {
-    Derived copy(This());
-    copy.MoveBy(aPt);
-    return copy;
-  }
-
-  Derived Intersect(const Derived& aOther) const
-  {
-    Derived intersection;
-    intersection.And(This(), aOther);
-    return intersection;
-  }
-
-  void Inflate(const Margin& aMargin)
-  {
-    mImpl.Inflate(nsMargin(aMargin.top, aMargin.right, aMargin.bottom, aMargin.left));
-  }
-  Derived Inflated(const Margin& aMargin) const
-  {
-    Derived copy(This());
-    copy.Inflate(aMargin);
-    return copy;
-  }
-
-  void SetEmpty ()
-  {
-    mImpl.SetEmpty ();
-  }
-
-  bool IsEmpty () const { return mImpl.IsEmpty (); }
-  bool IsComplex () const { return mImpl.IsComplex (); }
-  bool IsEqual (const Derived& aRegion) const
-  {
-    return mImpl.IsEqual (aRegion.mImpl);
-  }
-  uint32_t GetNumRects () const { return mImpl.GetNumRects (); }
-  Rect GetBounds () const { return FromRect (mImpl.GetBounds ()); }
-  uint64_t Area () const { return mImpl.Area(); }
-  nsRegion ToAppUnits (nscoord aAppUnitsPerPixel) const
-  {
-    nsRegion result;
-    for (auto iter = RectIter(); !iter.Done(); iter.Next()) {
-      nsRect appRect = ::ToAppUnits(iter.Get(), aAppUnitsPerPixel);
-      result.Or(result, appRect);
-    }
-    return result;
-  }
-  Rect GetLargestRectangle (const Rect& aContainingRect = Rect()) const
-  {
-    return FromRect (mImpl.GetLargestRectangle( ToRect(aContainingRect) ));
-  }
-
-  Derived& ScaleRoundOut (float aXScale, float aYScale)
-  {
-    mImpl.ScaleRoundOut(aXScale, aYScale);
-    return This();
-  }
-
-  Derived& ScaleInverseRoundOut (float aXScale, float aYScale)
-  {
-    mImpl.ScaleInverseRoundOut(aXScale, aYScale);
-    return This();
-  }
-
-
-
-
-
-  Derived& Transform (const mozilla::gfx::Matrix4x4 &aTransform)
-  {
-    mImpl.Transform(aTransform);
-    return This();
-  }
-
-
-
-
-
-
-
-  void SimplifyOutward (uint32_t aMaxRects)
-  {
-    mImpl.SimplifyOutward (aMaxRects);
-  }
-  void SimplifyOutwardByArea (uint32_t aThreshold)
-  {
-    mImpl.SimplifyOutwardByArea (aThreshold);
-  }
-
-
-
-
-
-  void SimplifyInward (uint32_t aMaxRects)
-  {
-    mImpl.SimplifyInward (aMaxRects);
-  }
-
-  typedef void (*visitFn)(void *closure, VisitSide side, int x1, int y1, int x2, int y2);
-  void VisitEdges (visitFn visit, void *closure)
-  {
-    mImpl.VisitEdges (visit, closure);
-  }
-
-  nsCString ToString() const { return mImpl.ToString(); }
-
-  class RectIterator
-  {
-    nsRegion::RectIterator mImpl;
-    mutable Rect mTmp;
-
-  public:
-    explicit RectIterator(const BaseIntRegion& aRegion)
-      : mImpl(aRegion.mImpl)
-    {}
-
-    bool Done() const { return mImpl.Done(); }
-
-    const Rect& Get() const
-    {
-      mTmp = FromRect(mImpl.Get());
-      return mTmp;
-    }
-
-    void Next() { mImpl.Next(); }
-  };
-
-  RectIterator RectIter() const { return RectIterator(*this); }
-
-protected:
-
-
-  explicit BaseIntRegion(const nsRegion& aImpl) : mImpl(aImpl) {}
-  const nsRegion& Impl() const { return mImpl; }
-private:
-  nsRegion mImpl;
-
-  static nsRect ToRect(const Rect& aRect)
-  {
-    return nsRect (aRect.x, aRect.y, aRect.width, aRect.height);
-  }
-  static Rect FromRect(const nsRect& aRect)
-  {
-    return Rect (aRect.x, aRect.y, aRect.width, aRect.height);
-  }
-
-  Derived& This()
-  {
-    return *static_cast<Derived*>(this);
-  }
-  const Derived& This() const
-  {
-    return *static_cast<const Derived*>(this);
-  }
-};
-
-template <class units>
-class IntRegionTyped :
-    public BaseIntRegion<IntRegionTyped<units>, IntRectTyped<units>, IntPointTyped<units>, IntMarginTyped<units>>
-{
-  typedef BaseIntRegion<IntRegionTyped<units>, IntRectTyped<units>, IntPointTyped<units>, IntMarginTyped<units>> Super;
-
-
-  template <typename OtherUnits>
-  friend class IntRegionTyped;
-
-  static_assert(IsPixel<units>::value, "'units' must be a coordinate system tag");
-
-public:
-  typedef IntRectTyped<units> RectType;
-  typedef IntPointTyped<units> PointType;
-  typedef IntMarginTyped<units> MarginType;
-
-
-  IntRegionTyped() {}
-               IntRegionTyped(const IntRectTyped<units>& aRect) : Super(aRect) {}
-  IntRegionTyped(const IntRegionTyped& aRegion) : Super(aRegion) {}
-  explicit IntRegionTyped(mozilla::gfx::ArrayView<pixman_box32_t> aRects) : Super(aRects) {}
-  IntRegionTyped(IntRegionTyped&& aRegion) : Super(mozilla::Move(aRegion)) {}
-
-
-
-  IntRegionTyped& operator=(const IntRegionTyped& aRegion)
-  {
-    return Super::operator=(aRegion);
-  }
-  IntRegionTyped& operator=(IntRegionTyped&& aRegion)
-  {
-    return Super::operator=(mozilla::Move(aRegion));
-  }
-
-  static IntRegionTyped FromUnknownRegion(const IntRegion& aRegion)
-  {
-    return IntRegionTyped(aRegion.Impl());
-  }
-  IntRegion ToUnknownRegion() const
-  {
-
-    return IntRegion(this->Impl());
-  }
-private:
-
-  explicit IntRegionTyped(const nsRegion& aRegion) : Super(aRegion) {}
-};
-
-}
-}
-
-typedef mozilla::gfx::IntRegion nsIntRegion;
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AppUnits.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AppUnits.h"
-namespace mozilla {
-inline int32_t AppUnitsPerCSSPixel() { return 60; }
-inline int32_t AppUnitsPerCSSInch() { return 96 * AppUnitsPerCSSPixel(); }
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h" 2
-
-
-namespace mozilla {
-
-template <typename T>
-struct IsPixel : FalseType {};
-
-
-struct CSSPixel;
-struct LayoutDevicePixel;
-struct LayerPixel;
-struct CSSTransformedLayerPixel;
-struct RenderTargetPixel;
-struct ScreenPixel;
-struct ParentLayerPixel;
-struct DesktopPixel;
-
-template<> struct IsPixel<CSSPixel> : TrueType {};
-template<> struct IsPixel<LayoutDevicePixel> : TrueType {};
-template<> struct IsPixel<LayerPixel> : TrueType {};
-template<> struct IsPixel<CSSTransformedLayerPixel> : TrueType {};
-template<> struct IsPixel<RenderTargetPixel> : TrueType {};
-template<> struct IsPixel<ScreenPixel> : TrueType {};
-template<> struct IsPixel<ParentLayerPixel> : TrueType {};
-template<> struct IsPixel<DesktopPixel> : TrueType {};
-
-typedef gfx::CoordTyped<CSSPixel> CSSCoord;
-typedef gfx::IntCoordTyped<CSSPixel> CSSIntCoord;
-typedef gfx::PointTyped<CSSPixel> CSSPoint;
-typedef gfx::IntPointTyped<CSSPixel> CSSIntPoint;
-typedef gfx::SizeTyped<CSSPixel> CSSSize;
-typedef gfx::IntSizeTyped<CSSPixel> CSSIntSize;
-typedef gfx::RectTyped<CSSPixel> CSSRect;
-typedef gfx::IntRectTyped<CSSPixel> CSSIntRect;
-typedef gfx::MarginTyped<CSSPixel> CSSMargin;
-typedef gfx::IntMarginTyped<CSSPixel> CSSIntMargin;
-typedef gfx::IntRegionTyped<CSSPixel> CSSIntRegion;
-
-typedef gfx::CoordTyped<LayoutDevicePixel> LayoutDeviceCoord;
-typedef gfx::IntCoordTyped<LayoutDevicePixel> LayoutDeviceIntCoord;
-typedef gfx::PointTyped<LayoutDevicePixel> LayoutDevicePoint;
-typedef gfx::IntPointTyped<LayoutDevicePixel> LayoutDeviceIntPoint;
-typedef gfx::SizeTyped<LayoutDevicePixel> LayoutDeviceSize;
-typedef gfx::IntSizeTyped<LayoutDevicePixel> LayoutDeviceIntSize;
-typedef gfx::RectTyped<LayoutDevicePixel> LayoutDeviceRect;
-typedef gfx::IntRectTyped<LayoutDevicePixel> LayoutDeviceIntRect;
-typedef gfx::MarginTyped<LayoutDevicePixel> LayoutDeviceMargin;
-typedef gfx::IntMarginTyped<LayoutDevicePixel> LayoutDeviceIntMargin;
-typedef gfx::IntRegionTyped<LayoutDevicePixel> LayoutDeviceIntRegion;
-
-typedef gfx::CoordTyped<LayerPixel> LayerCoord;
-typedef gfx::IntCoordTyped<LayerPixel> LayerIntCoord;
-typedef gfx::PointTyped<LayerPixel> LayerPoint;
-typedef gfx::IntPointTyped<LayerPixel> LayerIntPoint;
-typedef gfx::SizeTyped<LayerPixel> LayerSize;
-typedef gfx::IntSizeTyped<LayerPixel> LayerIntSize;
-typedef gfx::RectTyped<LayerPixel> LayerRect;
-typedef gfx::IntRectTyped<LayerPixel> LayerIntRect;
-typedef gfx::MarginTyped<LayerPixel> LayerMargin;
-typedef gfx::IntMarginTyped<LayerPixel> LayerIntMargin;
-typedef gfx::IntRegionTyped<LayerPixel> LayerIntRegion;
-
-typedef gfx::CoordTyped<CSSTransformedLayerPixel> CSSTransformedLayerCoord;
-typedef gfx::IntCoordTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntCoord;
-typedef gfx::PointTyped<CSSTransformedLayerPixel> CSSTransformedLayerPoint;
-typedef gfx::IntPointTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntPoint;
-typedef gfx::SizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerSize;
-typedef gfx::IntSizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntSize;
-typedef gfx::RectTyped<CSSTransformedLayerPixel> CSSTransformedLayerRect;
-typedef gfx::IntRectTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntRect;
-typedef gfx::MarginTyped<CSSTransformedLayerPixel> CSSTransformedLayerMargin;
-typedef gfx::IntMarginTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntMargin;
-typedef gfx::IntRegionTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntRegion;
-
-typedef gfx::PointTyped<RenderTargetPixel> RenderTargetPoint;
-typedef gfx::IntPointTyped<RenderTargetPixel> RenderTargetIntPoint;
-typedef gfx::SizeTyped<RenderTargetPixel> RenderTargetSize;
-typedef gfx::IntSizeTyped<RenderTargetPixel> RenderTargetIntSize;
-typedef gfx::RectTyped<RenderTargetPixel> RenderTargetRect;
-typedef gfx::IntRectTyped<RenderTargetPixel> RenderTargetIntRect;
-typedef gfx::MarginTyped<RenderTargetPixel> RenderTargetMargin;
-typedef gfx::IntMarginTyped<RenderTargetPixel> RenderTargetIntMargin;
-typedef gfx::IntRegionTyped<RenderTargetPixel> RenderTargetIntRegion;
-
-typedef gfx::CoordTyped<ScreenPixel> ScreenCoord;
-typedef gfx::IntCoordTyped<ScreenPixel> ScreenIntCoord;
-typedef gfx::PointTyped<ScreenPixel> ScreenPoint;
-typedef gfx::IntPointTyped<ScreenPixel> ScreenIntPoint;
-typedef gfx::SizeTyped<ScreenPixel> ScreenSize;
-typedef gfx::IntSizeTyped<ScreenPixel> ScreenIntSize;
-typedef gfx::RectTyped<ScreenPixel> ScreenRect;
-typedef gfx::IntRectTyped<ScreenPixel> ScreenIntRect;
-typedef gfx::MarginTyped<ScreenPixel> ScreenMargin;
-typedef gfx::IntMarginTyped<ScreenPixel> ScreenIntMargin;
-typedef gfx::IntRegionTyped<ScreenPixel> ScreenIntRegion;
-
-typedef gfx::CoordTyped<ParentLayerPixel> ParentLayerCoord;
-typedef gfx::IntCoordTyped<ParentLayerPixel> ParentLayerIntCoord;
-typedef gfx::PointTyped<ParentLayerPixel> ParentLayerPoint;
-typedef gfx::IntPointTyped<ParentLayerPixel> ParentLayerIntPoint;
-typedef gfx::SizeTyped<ParentLayerPixel> ParentLayerSize;
-typedef gfx::IntSizeTyped<ParentLayerPixel> ParentLayerIntSize;
-typedef gfx::RectTyped<ParentLayerPixel> ParentLayerRect;
-typedef gfx::IntRectTyped<ParentLayerPixel> ParentLayerIntRect;
-typedef gfx::MarginTyped<ParentLayerPixel> ParentLayerMargin;
-typedef gfx::IntMarginTyped<ParentLayerPixel> ParentLayerIntMargin;
-typedef gfx::IntRegionTyped<ParentLayerPixel> ParentLayerIntRegion;
-
-typedef gfx::CoordTyped<DesktopPixel> DesktopCoord;
-typedef gfx::IntCoordTyped<DesktopPixel> DesktopIntCoord;
-typedef gfx::PointTyped<DesktopPixel> DesktopPoint;
-typedef gfx::IntPointTyped<DesktopPixel> DesktopIntPoint;
-typedef gfx::SizeTyped<DesktopPixel> DesktopSize;
-typedef gfx::IntSizeTyped<DesktopPixel> DesktopIntSize;
-typedef gfx::RectTyped<DesktopPixel> DesktopRect;
-typedef gfx::IntRectTyped<DesktopPixel> DesktopIntRect;
-
-typedef gfx::ScaleFactor<CSSPixel, LayoutDevicePixel> CSSToLayoutDeviceScale;
-typedef gfx::ScaleFactor<CSSPixel, LayerPixel> CSSToLayerScale;
-typedef gfx::ScaleFactor<CSSPixel, ScreenPixel> CSSToScreenScale;
-typedef gfx::ScaleFactor<CSSPixel, ParentLayerPixel> CSSToParentLayerScale;
-typedef gfx::ScaleFactor<LayoutDevicePixel, CSSPixel> LayoutDeviceToCSSScale;
-typedef gfx::ScaleFactor<LayoutDevicePixel, LayerPixel> LayoutDeviceToLayerScale;
-typedef gfx::ScaleFactor<LayoutDevicePixel, ScreenPixel> LayoutDeviceToScreenScale;
-typedef gfx::ScaleFactor<LayoutDevicePixel, ParentLayerPixel> LayoutDeviceToParentLayerScale;
-typedef gfx::ScaleFactor<LayerPixel, CSSPixel> LayerToCSSScale;
-typedef gfx::ScaleFactor<LayerPixel, LayoutDevicePixel> LayerToLayoutDeviceScale;
-typedef gfx::ScaleFactor<LayerPixel, RenderTargetPixel> LayerToRenderTargetScale;
-typedef gfx::ScaleFactor<LayerPixel, ScreenPixel> LayerToScreenScale;
-typedef gfx::ScaleFactor<LayerPixel, ParentLayerPixel> LayerToParentLayerScale;
-typedef gfx::ScaleFactor<RenderTargetPixel, ScreenPixel> RenderTargetToScreenScale;
-typedef gfx::ScaleFactor<ScreenPixel, CSSPixel> ScreenToCSSScale;
-typedef gfx::ScaleFactor<ScreenPixel, LayoutDevicePixel> ScreenToLayoutDeviceScale;
-typedef gfx::ScaleFactor<ScreenPixel, LayerPixel> ScreenToLayerScale;
-typedef gfx::ScaleFactor<ScreenPixel, ParentLayerPixel> ScreenToParentLayerScale;
-typedef gfx::ScaleFactor<ParentLayerPixel, LayerPixel> ParentLayerToLayerScale;
-typedef gfx::ScaleFactor<ParentLayerPixel, ScreenPixel> ParentLayerToScreenScale;
-typedef gfx::ScaleFactor<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerScale;
-typedef gfx::ScaleFactor<DesktopPixel, LayoutDevicePixel> DesktopToLayoutDeviceScale;
-
-typedef gfx::ScaleFactors2D<CSSPixel, LayoutDevicePixel> CSSToLayoutDeviceScale2D;
-typedef gfx::ScaleFactors2D<CSSPixel, LayerPixel> CSSToLayerScale2D;
-typedef gfx::ScaleFactors2D<CSSPixel, ScreenPixel> CSSToScreenScale2D;
-typedef gfx::ScaleFactors2D<CSSPixel, ParentLayerPixel> CSSToParentLayerScale2D;
-typedef gfx::ScaleFactors2D<LayoutDevicePixel, CSSPixel> LayoutDeviceToCSSScale2D;
-typedef gfx::ScaleFactors2D<LayoutDevicePixel, LayerPixel> LayoutDeviceToLayerScale2D;
-typedef gfx::ScaleFactors2D<LayoutDevicePixel, ScreenPixel> LayoutDeviceToScreenScale2D;
-typedef gfx::ScaleFactors2D<LayoutDevicePixel, ParentLayerPixel> LayoutDeviceToParentLayerScale2D;
-typedef gfx::ScaleFactors2D<LayerPixel, CSSPixel> LayerToCSSScale2D;
-typedef gfx::ScaleFactors2D<LayerPixel, LayoutDevicePixel> LayerToLayoutDeviceScale2D;
-typedef gfx::ScaleFactors2D<LayerPixel, RenderTargetPixel> LayerToRenderTargetScale2D;
-typedef gfx::ScaleFactors2D<LayerPixel, ScreenPixel> LayerToScreenScale2D;
-typedef gfx::ScaleFactors2D<LayerPixel, ParentLayerPixel> LayerToParentLayerScale2D;
-typedef gfx::ScaleFactors2D<RenderTargetPixel, ScreenPixel> RenderTargetToScreenScale2D;
-typedef gfx::ScaleFactors2D<ScreenPixel, CSSPixel> ScreenToCSSScale2D;
-typedef gfx::ScaleFactors2D<ScreenPixel, LayoutDevicePixel> ScreenToLayoutDeviceScale2D;
-typedef gfx::ScaleFactors2D<ScreenPixel, LayerPixel> ScreenToLayerScale2D;
-typedef gfx::ScaleFactors2D<ScreenPixel, ParentLayerPixel> ScreenToParentLayerScale2D;
-typedef gfx::ScaleFactors2D<ParentLayerPixel, LayerPixel> ParentLayerToLayerScale2D;
-typedef gfx::ScaleFactors2D<ParentLayerPixel, ScreenPixel> ParentLayerToScreenScale2D;
-typedef gfx::ScaleFactors2D<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerScale2D;
-
-typedef gfx::Matrix4x4Typed<LayoutDevicePixel, LayoutDevicePixel> LayoutDeviceToLayoutDeviceMatrix4x4;
-typedef gfx::Matrix4x4Typed<LayerPixel, ParentLayerPixel> LayerToParentLayerMatrix4x4;
-typedef gfx::Matrix4x4Typed<ScreenPixel, ScreenPixel> ScreenToScreenMatrix4x4;
-typedef gfx::Matrix4x4Typed<ScreenPixel, ParentLayerPixel> ScreenToParentLayerMatrix4x4;
-typedef gfx::Matrix4x4Typed<ParentLayerPixel, LayerPixel> ParentLayerToLayerMatrix4x4;
-typedef gfx::Matrix4x4Typed<ParentLayerPixel, ScreenPixel> ParentLayerToScreenMatrix4x4;
-typedef gfx::Matrix4x4Typed<ParentLayerPixel, ParentLayerPixel> ParentLayerToParentLayerMatrix4x4;
-
-
-
-
-struct CSSPixel {
-
-
-
-  static CSSCoord FromAppUnits(nscoord aCoord) {
-    return NSAppUnitsToFloatPixels(aCoord, float(AppUnitsPerCSSPixel()));
-  }
-
-  static CSSPoint FromAppUnits(const nsPoint& aPoint) {
-    return CSSPoint(NSAppUnitsToFloatPixels(aPoint.x, float(AppUnitsPerCSSPixel())),
-                    NSAppUnitsToFloatPixels(aPoint.y, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSSize FromAppUnits(const nsSize& aSize) {
-    return CSSSize(NSAppUnitsToFloatPixels(aSize.width, float(AppUnitsPerCSSPixel())),
-                   NSAppUnitsToFloatPixels(aSize.height, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSRect FromAppUnits(const nsRect& aRect) {
-    return CSSRect(NSAppUnitsToFloatPixels(aRect.x, float(AppUnitsPerCSSPixel())),
-                   NSAppUnitsToFloatPixels(aRect.y, float(AppUnitsPerCSSPixel())),
-                   NSAppUnitsToFloatPixels(aRect.width, float(AppUnitsPerCSSPixel())),
-                   NSAppUnitsToFloatPixels(aRect.height, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSMargin FromAppUnits(const nsMargin& aMargin) {
-    return CSSMargin(NSAppUnitsToFloatPixels(aMargin.top, float(AppUnitsPerCSSPixel())),
-                     NSAppUnitsToFloatPixels(aMargin.right, float(AppUnitsPerCSSPixel())),
-                     NSAppUnitsToFloatPixels(aMargin.bottom, float(AppUnitsPerCSSPixel())),
-                     NSAppUnitsToFloatPixels(aMargin.left, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSIntPoint FromAppUnitsRounded(const nsPoint& aPoint) {
-    return CSSIntPoint(NSAppUnitsToIntPixels(aPoint.x, float(AppUnitsPerCSSPixel())),
-                       NSAppUnitsToIntPixels(aPoint.y, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSIntSize FromAppUnitsRounded(const nsSize& aSize)
-  {
-    return CSSIntSize(NSAppUnitsToIntPixels(aSize.width, float(AppUnitsPerCSSPixel())),
-                      NSAppUnitsToIntPixels(aSize.height, float(AppUnitsPerCSSPixel())));
-  }
-
-  static CSSIntRect FromAppUnitsRounded(const nsRect& aRect) {
-    return CSSIntRect(NSAppUnitsToIntPixels(aRect.x, float(AppUnitsPerCSSPixel())),
-                      NSAppUnitsToIntPixels(aRect.y, float(AppUnitsPerCSSPixel())),
-                      NSAppUnitsToIntPixels(aRect.width, float(AppUnitsPerCSSPixel())),
-                      NSAppUnitsToIntPixels(aRect.height, float(AppUnitsPerCSSPixel())));
-  }
-
-
-
-  static nscoord ToAppUnits(CSSCoord aCoord) {
-    return NSToCoordRoundWithClamp(aCoord * float(AppUnitsPerCSSPixel()));
-  }
-
-  static nsPoint ToAppUnits(const CSSPoint& aPoint) {
-    return nsPoint(NSToCoordRoundWithClamp(aPoint.x * float(AppUnitsPerCSSPixel())),
-                   NSToCoordRoundWithClamp(aPoint.y * float(AppUnitsPerCSSPixel())));
-  }
-
-  static nsPoint ToAppUnits(const CSSIntPoint& aPoint) {
-    return nsPoint(NSToCoordRoundWithClamp(float(aPoint.x) * float(AppUnitsPerCSSPixel())),
-                   NSToCoordRoundWithClamp(float(aPoint.y) * float(AppUnitsPerCSSPixel())));
-  }
-
-  static nsSize ToAppUnits(const CSSSize& aSize) {
-    return nsSize(NSToCoordRoundWithClamp(aSize.width * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(aSize.height * float(AppUnitsPerCSSPixel())));
-  }
-
-  static nsSize ToAppUnits(const CSSIntSize& aSize) {
-    return nsSize(NSToCoordRoundWithClamp(float(aSize.width) * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(float(aSize.height) * float(AppUnitsPerCSSPixel())));
-  }
-
-  static nsRect ToAppUnits(const CSSRect& aRect) {
-    return nsRect(NSToCoordRoundWithClamp(aRect.x * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(aRect.y * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(aRect.width * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(aRect.height * float(AppUnitsPerCSSPixel())));
-  }
-
-  static nsRect ToAppUnits(const CSSIntRect& aRect) {
-    return nsRect(NSToCoordRoundWithClamp(float(aRect.x) * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(float(aRect.y) * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(float(aRect.width) * float(AppUnitsPerCSSPixel())),
-                  NSToCoordRoundWithClamp(float(aRect.height) * float(AppUnitsPerCSSPixel())));
-  }
-};
-# 292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct LayoutDevicePixel {
-  static LayoutDeviceRect FromAppUnits(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceRect(NSAppUnitsToFloatPixels(aRect.x, float(aAppUnitsPerDevPixel)),
-                            NSAppUnitsToFloatPixels(aRect.y, float(aAppUnitsPerDevPixel)),
-                            NSAppUnitsToFloatPixels(aRect.width, float(aAppUnitsPerDevPixel)),
-                            NSAppUnitsToFloatPixels(aRect.height, float(aAppUnitsPerDevPixel)));
-  }
-
-  static LayoutDevicePoint FromAppUnits(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDevicePoint(NSAppUnitsToFloatPixels(aPoint.x, aAppUnitsPerDevPixel),
-                             NSAppUnitsToFloatPixels(aPoint.y, aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceMargin FromAppUnits(const nsMargin& aMargin, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceMargin(NSAppUnitsToFloatPixels(aMargin.top, aAppUnitsPerDevPixel),
-                              NSAppUnitsToFloatPixels(aMargin.right, aAppUnitsPerDevPixel),
-                              NSAppUnitsToFloatPixels(aMargin.bottom, aAppUnitsPerDevPixel),
-                              NSAppUnitsToFloatPixels(aMargin.left, aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntPoint FromAppUnitsRounded(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntPoint(NSAppUnitsToIntPixels(aPoint.x, aAppUnitsPerDevPixel),
-                                NSAppUnitsToIntPixels(aPoint.y, aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntPoint FromAppUnitsToNearest(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntPoint::FromUnknownPoint(aPoint.ToNearestPixels(aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntRect FromAppUnitsToNearest(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToNearestPixels(aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntRect FromAppUnitsToInside(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToInsidePixels(aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntRect FromAppUnitsToOutside(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntRect::FromUnknownRect(aRect.ToOutsidePixels(aAppUnitsPerDevPixel));
-  }
-
-  static LayoutDeviceIntSize FromAppUnitsRounded(const nsSize& aSize, nscoord aAppUnitsPerDevPixel) {
-    return LayoutDeviceIntSize(
-      NSAppUnitsToIntPixels(aSize.width, aAppUnitsPerDevPixel),
-      NSAppUnitsToIntPixels(aSize.height, aAppUnitsPerDevPixel));
-  }
-
-  static nsPoint ToAppUnits(const LayoutDeviceIntPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
-    return nsPoint(aPoint.x * aAppUnitsPerDevPixel,
-                   aPoint.y * aAppUnitsPerDevPixel);
-  }
-
-  static nsSize ToAppUnits(const LayoutDeviceIntSize& aSize, nscoord aAppUnitsPerDevPixel) {
-    return nsSize(aSize.width * aAppUnitsPerDevPixel,
-                  aSize.height * aAppUnitsPerDevPixel);
-  }
-
-  static nsSize ToAppUnits(const LayoutDeviceSize& aSize, nscoord aAppUnitsPerDevPixel) {
-    return nsSize(NSFloatPixelsToAppUnits(aSize.width, aAppUnitsPerDevPixel),
-                  NSFloatPixelsToAppUnits(aSize.height, aAppUnitsPerDevPixel));
-  }
-
-  static nsRect ToAppUnits(const LayoutDeviceIntRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return nsRect(aRect.x * aAppUnitsPerDevPixel,
-                  aRect.y * aAppUnitsPerDevPixel,
-                  aRect.width * aAppUnitsPerDevPixel,
-                  aRect.height * aAppUnitsPerDevPixel);
-  }
-
-  static nsRect ToAppUnits(const LayoutDeviceRect& aRect, nscoord aAppUnitsPerDevPixel) {
-    return nsRect(NSFloatPixelsToAppUnits(aRect.x, aAppUnitsPerDevPixel),
-                  NSFloatPixelsToAppUnits(aRect.y, aAppUnitsPerDevPixel),
-                  NSFloatPixelsToAppUnits(aRect.width, aAppUnitsPerDevPixel),
-                  NSFloatPixelsToAppUnits(aRect.height, aAppUnitsPerDevPixel));
-  }
-};
-# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct LayerPixel {
-};
-
-
-
-
-
-
-
-struct CSSTransformedLayerPixel {
-
-};
-# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct RenderTargetPixel {
-};
-# 410 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct ScreenPixel {
-};
-# 425 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct ParentLayerPixel {
-};
-# 442 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Units.h"
-struct DesktopPixel {
-};
-
-
-
-template<class src, class dst>
-gfx::CoordTyped<dst> operator*(const gfx::CoordTyped<src>& aCoord, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::CoordTyped<dst>(aCoord.value * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::CoordTyped<dst> operator/(const gfx::CoordTyped<src>& aCoord, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::CoordTyped<dst>(aCoord.value / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator*(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::PointTyped<dst>(aPoint.x * aScale.scale,
-                              aPoint.y * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator/(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::PointTyped<dst>(aPoint.x / aScale.scale,
-                              aPoint.y / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator*(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::PointTyped<dst>(aPoint.x * aScale.xScale,
-                              aPoint.y * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator/(const gfx::PointTyped<src>& aPoint, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::PointTyped<dst>(aPoint.x / aScale.xScale,
-                              aPoint.y / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator*(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::PointTyped<dst>(float(aPoint.x) * aScale.scale,
-                              float(aPoint.y) * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator/(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::PointTyped<dst>(float(aPoint.x) / aScale.scale,
-                              float(aPoint.y) / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator*(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::PointTyped<dst>(float(aPoint.x) * aScale.xScale,
-                              float(aPoint.y) * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::PointTyped<dst> operator/(const gfx::IntPointTyped<src>& aPoint, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::PointTyped<dst>(float(aPoint.x) / aScale.xScale,
-                              float(aPoint.y) / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator*(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::RectTyped<dst>(aRect.x * aScale.scale,
-                             aRect.y * aScale.scale,
-                             aRect.width * aScale.scale,
-                             aRect.height * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator/(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::RectTyped<dst>(aRect.x / aScale.scale,
-                             aRect.y / aScale.scale,
-                             aRect.width / aScale.scale,
-                             aRect.height / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator*(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::RectTyped<dst>(aRect.x * aScale.xScale,
-                             aRect.y * aScale.yScale,
-                             aRect.width * aScale.xScale,
-                             aRect.height * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator/(const gfx::RectTyped<src>& aRect, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::RectTyped<dst>(aRect.x / aScale.xScale,
-                             aRect.y / aScale.yScale,
-                             aRect.width / aScale.xScale,
-                             aRect.height / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator*(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::RectTyped<dst>(float(aRect.x) * aScale.scale,
-                             float(aRect.y) * aScale.scale,
-                             float(aRect.width) * aScale.scale,
-                             float(aRect.height) * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator/(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::RectTyped<dst>(float(aRect.x) / aScale.scale,
-                             float(aRect.y) / aScale.scale,
-                             float(aRect.width) / aScale.scale,
-                             float(aRect.height) / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator*(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::RectTyped<dst>(float(aRect.x) * aScale.xScale,
-                             float(aRect.y) * aScale.yScale,
-                             float(aRect.width) * aScale.xScale,
-                             float(aRect.height) * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::RectTyped<dst> operator/(const gfx::IntRectTyped<src>& aRect, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::RectTyped<dst>(float(aRect.x) / aScale.xScale,
-                             float(aRect.y) / aScale.yScale,
-                             float(aRect.width) / aScale.xScale,
-                             float(aRect.height) / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator*(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::SizeTyped<dst>(aSize.width * aScale.scale,
-                             aSize.height * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator/(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::SizeTyped<dst>(aSize.width / aScale.scale,
-                              aSize.height / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator*(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::SizeTyped<dst>(aSize.width * aScale.xScale,
-                             aSize.height * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator/(const gfx::SizeTyped<src>& aSize, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::SizeTyped<dst>(aSize.width / aScale.xScale,
-                             aSize.height / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator*(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::SizeTyped<dst>(float(aSize.width) * aScale.scale,
-                             float(aSize.height) * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator/(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::SizeTyped<dst>(float(aSize.width) / aScale.scale,
-                             float(aSize.height) / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator*(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::SizeTyped<dst>(float(aSize.width) * aScale.xScale,
-                             float(aSize.height) * aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::SizeTyped<dst> operator/(const gfx::IntSizeTyped<src>& aSize, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::SizeTyped<dst>(float(aSize.width) / aScale.xScale,
-                             float(aSize.height) / aScale.yScale);
-}
-
-template<class src, class dst>
-gfx::MarginTyped<dst> operator*(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactor<src, dst>& aScale) {
-  return gfx::MarginTyped<dst>(aMargin.top * aScale.scale,
-                               aMargin.right * aScale.scale,
-                               aMargin.bottom * aScale.scale,
-                               aMargin.left * aScale.scale);
-}
-
-template<class src, class dst>
-gfx::MarginTyped<dst> operator/(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactor<dst, src>& aScale) {
-  return gfx::MarginTyped<dst>(aMargin.top / aScale.scale,
-                               aMargin.right / aScale.scale,
-                               aMargin.bottom / aScale.scale,
-                               aMargin.left / aScale.scale);
-}
-
-template<class src, class dst>
-gfx::MarginTyped<dst> operator*(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactors2D<src, dst>& aScale) {
-  return gfx::MarginTyped<dst>(aMargin.top * aScale.yScale,
-                               aMargin.right * aScale.xScale,
-                               aMargin.bottom * aScale.yScale,
-                               aMargin.left * aScale.xScale);
-}
-
-template<class src, class dst>
-gfx::MarginTyped<dst> operator/(const gfx::MarginTyped<src>& aMargin, const gfx::ScaleFactors2D<dst, src>& aScale) {
-  return gfx::MarginTyped<dst>(aMargin.top / aScale.yScale,
-                               aMargin.right / aScale.xScale,
-                               aMargin.bottom / aScale.yScale,
-                               aMargin.left / aScale.xScale);
-}
-
-
-
-
-template<class src, class dst>
-gfx::ScaleFactor<src, dst> MaxScaleRatio(const gfx::SizeTyped<dst>& aDestSize, const gfx::SizeTyped<src>& aSrcSize) {
-  return gfx::ScaleFactor<src, dst>(std::max(aDestSize.width / aSrcSize.width,
-                                             aDestSize.height / aSrcSize.height));
-}
-
-template<class src, class dst>
-gfx::ScaleFactor<src, dst> MinScaleRatio(const gfx::SizeTyped<dst>& aDestSize, const gfx::SizeTyped<src>& aSrcSize) {
-  return gfx::ScaleFactor<src, dst>(std::min(aDestSize.width / aSrcSize.width,
-                                             aDestSize.height / aSrcSize.height));
-}
-
-}
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h" 2
-
-
-
-
-
-class nsDocShell;
-class nsIDocument;
-class nsIFrame;
-class nsPresContext;
-class nsViewManager;
-class nsView;
-class nsRenderingContext;
-class nsIPageSequenceFrame;
-class nsCanvasFrame;
-class nsAString;
-class nsCaret;
-namespace mozilla {
-class AccessibleCaretEventHub;
-class CSSStyleSheet;
-}
-class nsFrameSelection;
-class nsFrameManager;
-class nsILayoutHistoryState;
-class nsIReflowCallback;
-class nsIDOMNode;
-class nsCSSFrameConstructor;
-class nsISelection;
-template<class E> class nsCOMArray;
-class AutoWeakFrame;
-class WeakFrame;
-class nsIScrollableFrame;
-class gfxContext;
-class nsIDOMEvent;
-class nsDisplayList;
-class nsDisplayListBuilder;
-class nsPIDOMWindowOuter;
-struct nsPoint;
-class nsINode;
-struct nsRect;
-class nsRegion;
-class nsRefreshDriver;
-class nsARefreshObserver;
-class nsAPostRefreshObserver;
-
-class nsAccessibilityService;
-namespace mozilla {
-namespace a11y {
-class DocAccessible;
-}
-}
-
-struct nsArenaMemoryStats;
-class nsITimer;
-
-namespace mozilla {
-class EventStates;
-
-namespace dom {
-class Element;
-class Touch;
-class Selection;
-class ShadowRoot;
-}
-
-namespace layers {
-class LayerManager;
-}
-
-namespace gfx {
-class SourceSurface;
-}
-}
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-typedef struct CapturingContentInfo {
-
-  bool mAllowed;
-  bool mPointerLock;
-  bool mRetargetToElement;
-  bool mPreventDrag;
-  mozilla::StaticRefPtr<nsIContent> mContent;
-} CapturingContentInfo;
-# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-enum nsRectVisibility {
-  nsRectVisibility_kVisible,
-  nsRectVisibility_kAboveViewport,
-  nsRectVisibility_kBelowViewport,
-  nsRectVisibility_kLeftOfViewport,
-  nsRectVisibility_kRightOfViewport
-};
-# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-class nsIPresShell : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-protected:
-  typedef mozilla::layers::LayerManager LayerManager;
-  typedef mozilla::gfx::SourceSurface SourceSurface;
-
-  enum eRenderFlag {
-    STATE_IGNORING_VIEWPORT_SCROLLING = 0x1,
-    STATE_DRAWWINDOW_NOT_FLUSHING = 0x2
-  };
-  typedef uint8_t RenderFlags;
-
-public:
-  nsIPresShell();
-# 207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual void Destroy() = 0;
-
-  bool IsDestroying() { return mIsDestroying; }
-# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  void* AllocateFrame(nsQueryFrame::FrameIID aID, size_t aSize)
-  {
-    void* result = mFrameArena.AllocateByFrameID(aID, aSize);
-    RecordAlloc(result);
-    return result;
-  }
-
-  void FreeFrame(nsQueryFrame::FrameIID aID, void* aPtr)
-  {
-    RecordFree(aPtr);
-    if (!mIsDestroying)
-      mFrameArena.FreeByFrameID(aID, aPtr);
-  }
-
-
-
-
-
-
-
-  void* AllocateByObjectID(mozilla::ArenaObjectID aID, size_t aSize)
-  {
-    void* result = mFrameArena.AllocateByObjectID(aID, aSize);
-    RecordAlloc(result);
-    return result;
-  }
-
-  void FreeByObjectID(mozilla::ArenaObjectID aID, void* aPtr)
-  {
-    RecordFree(aPtr);
-    if (!mIsDestroying)
-      mFrameArena.FreeByObjectID(aID, aPtr);
-  }
-# 261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  void* AllocateMisc(size_t aSize)
-  {
-    void* result = mFrameArena.AllocateBySize(aSize);
-    RecordAlloc(result);
-    return result;
-  }
-
-  void FreeMisc(size_t aSize, void* aPtr)
-  {
-    RecordFree(aPtr);
-    if (!mIsDestroying)
-      mFrameArena.FreeBySize(aSize, aPtr);
-  }
-
-  template<typename T>
-  void RegisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
-  {
-    mFrameArena.RegisterArenaRefPtr(aPtr);
-  }
-
-  template<typename T>
-  void DeregisterArenaRefPtr(mozilla::ArenaRefPtr<T>* aPtr)
-  {
-    mFrameArena.DeregisterArenaRefPtr(aPtr);
-  }
-
-  void ClearArenaRefPtrs(mozilla::ArenaObjectID aObjectID)
-  {
-    mFrameArena.ClearArenaRefPtrs(aObjectID);
-  }
-
-  nsIDocument* GetDocument() const { return mDocument; }
-
-  nsPresContext* GetPresContext() const { return mPresContext; }
-
-  nsViewManager* GetViewManager() const { return mViewManager; }
-
-  nsRefreshDriver* GetRefreshDriver() const;
-
-
-
-
-
-  mozilla::a11y::DocAccessible* GetDocAccessible() const
-  {
-    return mDocAccessible;
-  }
-
-
-
-
-  void SetDocAccessible(mozilla::a11y::DocAccessible* aDocAccessible)
-  {
-    mDocAccessible = aDocAccessible;
-  }
-
-
-
-  mozilla::StyleSetHandle StyleSet() const { return mStyleSet; }
-
-  nsCSSFrameConstructor* FrameConstructor() const { return mFrameConstructor; }
-
-  nsFrameManager* FrameManager() const {
-
-
-    return reinterpret_cast<nsFrameManager*>
-                           (const_cast<nsIPresShell*>(this)->mFrameManager);
-  }
-# 337 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  void SetAuthorStyleDisabled(bool aDisabled);
-  bool GetAuthorStyleDisabled() const;
-# 359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  void RestyleForCSSRuleChanges();
-
-
-
-
-
-  virtual void UpdatePreferenceStyles() = 0;
-
-
-
-
-
-
-  already_AddRefed<nsFrameSelection> FrameSelection();
-
-
-
-
-
-  const nsFrameSelection* ConstFrameSelection() const { return mSelection; }
-
-
-
-  virtual void BeginObservingDocument() = 0;
-
-
-  virtual void EndObservingDocument() = 0;
-
-
-
-
-  bool DidInitialize() const { return mDidInitialize; }
-# 403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult Initialize(nscoord aWidth, nscoord aHeight) = 0;
-
-
-
-
-
-  virtual nsresult ResizeReflow(nscoord aWidth, nscoord aHeight, nscoord aOldWidth = 0, nscoord aOldHeight = 0) = 0;
-
-
-
-
-  virtual nsresult ResizeReflowIgnoreOverride(nscoord aWidth, nscoord aHeight, nscoord aOldWidth, nscoord aOldHeight) = 0;
-
-
-
-
-  virtual bool GetIsViewportOverridden() = 0;
-
-
-
-
-  virtual bool IsLayoutFlushObserver() = 0;
-
-
-
-
-  virtual void LoadComplete() = 0;
-
-
-
-
-  virtual nsIFrame* GetRootFrameExternal() const;
-  nsIFrame* GetRootFrame() const {
-
-    return mFrameManager->GetRootFrame();
-
-
-
-  }
-
-
-
-
-  nsIFrame* GetRootScrollFrame() const;
-
-
-
-
-  nsIScrollableFrame* GetRootScrollFrameAsScrollable() const;
-
-
-
-
-
-  virtual nsIScrollableFrame* GetRootScrollFrameAsScrollableExternal() const;
-# 466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  enum ScrollDirection { eHorizontal, eVertical, eEither };
-  nsIScrollableFrame* GetFrameToScrollAsScrollable(ScrollDirection aDirection);
-
-
-
-
-
-  virtual nsIPageSequenceFrame* GetPageSequenceFrame() const = 0;
-
-
-
-
-
-  virtual nsCanvasFrame* GetCanvasFrame() const = 0;
-
-
-
-
-
-  virtual nsIFrame* GetPlaceholderFrameFor(nsIFrame* aFrame) const = 0;
-# 498 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  enum IntrinsicDirty {
-
-    eResize,
-    eTreeChange,
-    eStyleChange
-  };
-  enum ReflowRootHandling {
-    ePositionOrSizeChange,
-    eNoPositionOrSizeChange,
-    eInferFromBitToAdd
-
-
-
-  };
-  virtual void FrameNeedsReflow(nsIFrame *aFrame,
-                                IntrinsicDirty aIntrinsicDirty,
-                                nsFrameState aBitToAdd,
-                                ReflowRootHandling aRootHandling =
-                                  eInferFromBitToAdd) = 0;
-
-
-
-
-  virtual void MarkFixedFramesForReflow(IntrinsicDirty aIntrinsicDirty);
-# 534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual void FrameNeedsToContinueReflow(nsIFrame *aFrame) = 0;
-
-  virtual void CancelAllPendingReflows() = 0;
-
-  virtual void NotifyCounterStylesAreDirty() = 0;
-# 547 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual void DestroyFramesFor(nsIContent* aContent,
-                                nsIContent** aDestroyedFramesFor) = 0;
-
-
-
-
-
-  virtual void CreateFramesFor(nsIContent* aContent) = 0;
-
-
-
-
-  virtual nsresult RecreateFramesFor(nsIContent* aContent) = 0;
-
-  void PostRecreateFramesFor(mozilla::dom::Element* aElement);
-  void RestyleForAnimation(mozilla::dom::Element* aElement,
-                           nsRestyleHint aHint);
-
-
-
-
-  virtual void RecordShadowStyleChange(mozilla::dom::ShadowRoot* aShadowRoot) = 0;
-
-
-
-
-
-
-  virtual bool IsSafeToFlush() const = 0;
-# 592 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-public:
-  void FlushPendingNotifications(mozilla::FlushType aType)
-  {
-    if (!NeedFlush(aType)) {
-      return;
-    }
-
-    DoFlushPendingNotifications(aType);
-  }
-
-  void FlushPendingNotifications(mozilla::ChangesToFlush aType)
-  {
-    if (!NeedFlush(aType.mFlushType)) {
-      return;
-    }
-
-    DoFlushPendingNotifications(aType);
-  }
-
-protected:
-
-
-
-  virtual void DoFlushPendingNotifications(mozilla::FlushType aType) = 0;
-  virtual void DoFlushPendingNotifications(mozilla::ChangesToFlush aType) = 0;
-
-public:
-# 627 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  bool NeedFlush(mozilla::FlushType aType) const
-  {
-
-
-
-
-    do { } while (0);
-    return mNeedStyleFlush ||
-           (mNeedLayoutFlush &&
-            aType >= mozilla::FlushType::InterruptibleLayout) ||
-           aType >= mozilla::FlushType::Display ||
-           mNeedThrottledAnimationFlush ||
-           mInFlush;
-  }
-
-  inline void SetNeedStyleFlush();
-  inline void SetNeedLayoutFlush();
-  inline void SetNeedThrottledAnimationFlush();
-
-  bool ObservingStyleFlushes() const { return mObservingStyleFlushes; }
-  bool ObservingLayoutFlushes() const { return mObservingLayoutFlushes; }
-
-  void ObserveStyleFlushes()
-  {
-    if (!ObservingStyleFlushes())
-      DoObserveStyleFlushes();
-  }
-
-  bool NeedStyleFlush() const { return mNeedStyleFlush; }
-
-
-
-
-
-  virtual nsresult PostReflowCallback(nsIReflowCallback* aCallback) = 0;
-  virtual void CancelReflowCallback(nsIReflowCallback* aCallback) = 0;
-
-  virtual void ClearFrameRefs(nsIFrame* aFrame) = 0;
-
-
-
-
-
-
-  virtual already_AddRefed<gfxContext> CreateReferenceRenderingContext() = 0;
-# 682 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult GoToAnchor(const nsAString& aAnchorName, bool aScroll,
-                              uint32_t aAdditionalScrollFlags = 0) = 0;
-# 693 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult ScrollToAnchor() = 0;
-
-  enum {
-    SCROLL_TOP = 0,
-    SCROLL_BOTTOM = 100,
-    SCROLL_LEFT = 0,
-    SCROLL_RIGHT = 100,
-    SCROLL_CENTER = 50,
-    SCROLL_MINIMUM = -1
-  };
-
-  enum WhenToScroll {
-    SCROLL_ALWAYS,
-    SCROLL_IF_NOT_VISIBLE,
-    SCROLL_IF_NOT_FULLY_VISIBLE
-  };
-  typedef struct ScrollAxis {
-    int16_t mWhereToScroll;
-    WhenToScroll mWhenToScroll : 8;
-    bool mOnlyIfPerceivedScrollableDirection : 1;
-# 748 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-    explicit ScrollAxis(int16_t aWhere = SCROLL_MINIMUM,
-                        WhenToScroll aWhen = SCROLL_IF_NOT_FULLY_VISIBLE,
-                        bool aOnlyIfPerceivedScrollableDirection = false) :
-      mWhereToScroll(aWhere), mWhenToScroll(aWhen),
-      mOnlyIfPerceivedScrollableDirection(aOnlyIfPerceivedScrollableDirection)
-    {}
-  } ScrollAxis;
-# 786 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult ScrollContentIntoView(nsIContent* aContent,
-                                                     ScrollAxis aVertical,
-                                                     ScrollAxis aHorizontal,
-                                                     uint32_t aFlags) = 0;
-
-  enum {
-    SCROLL_FIRST_ANCESTOR_ONLY = 0x01,
-    SCROLL_OVERFLOW_HIDDEN = 0x02,
-    SCROLL_NO_PARENT_FRAMES = 0x04,
-    SCROLL_SMOOTH = 0x08,
-    SCROLL_SMOOTH_AUTO = 0x10
-  };
-# 817 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual bool ScrollFrameRectIntoView(nsIFrame* aFrame,
-                                       const nsRect& aRect,
-                                       ScrollAxis aVertical,
-                                       ScrollAxis aHorizontal,
-                                       uint32_t aFlags) = 0;
-# 837 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsRectVisibility GetRectVisibility(nsIFrame *aFrame,
-                                             const nsRect &aRect,
-                                             nscoord aMinTwips) const = 0;
-
-
-
-
-
-  virtual void SetIgnoreFrameDestruction(bool aIgnore) = 0;
-
-
-
-
-
-
-  virtual void NotifyDestroyingFrame(nsIFrame* aFrame) = 0;
-
-
-
-
-  virtual already_AddRefed<mozilla::AccessibleCaretEventHub> GetAccessibleCaretEventHub() const = 0;
-
-
-
-
-  virtual already_AddRefed<nsCaret> GetCaret() const = 0;
-
-
-
-
-  virtual void SetCaret(nsCaret *aNewCaret) = 0;
-
-
-
-
-
-  virtual void RestoreCaret() = 0;
-# 883 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult SetSelectionFlags(int16_t aInEnable) = 0;
-
-
-
-
-
-
-  int16_t GetSelectionFlags() const { return mSelectionFlags; }
-
-  virtual mozilla::dom::Selection*
-    GetCurrentSelection(mozilla::SelectionType aSelectionType) = 0;
-# 909 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual already_AddRefed<nsISelectionController>
-            GetSelectionControllerForFocusedContent(
-              nsIContent** aFocusedContent = nullptr) = 0;
-
-
-
-
-
-  virtual nsresult HandleEventWithTarget(
-                                 mozilla::WidgetEvent* aEvent,
-                                 nsIFrame* aFrame,
-                                 nsIContent* aContent,
-                                 nsEventStatus* aStatus) = 0;
-
-
-
-
-
-  virtual nsresult HandleDOMEventWithTarget(
-                                 nsIContent* aTargetContent,
-                                 mozilla::WidgetEvent* aEvent,
-                                 nsEventStatus* aStatus) = 0;
-
-
-
-
-
-  virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
-                                                        nsIDOMEvent* aEvent,
-                                                        nsEventStatus* aStatus) = 0;
-
-
-
-
-  virtual bool CanDispatchEvent(
-      const mozilla::WidgetGUIEvent* aEvent = nullptr) const = 0;
-
-
-
-
-  virtual nsIFrame* GetEventTargetFrame() = 0;
-
-
-
-
-  virtual already_AddRefed<nsIContent> GetEventTargetContent(
-                                                     mozilla::WidgetEvent* aEvent) = 0;
-
-
-
-
-
-  virtual nsresult CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) = 0;
-
-
-
-
-
-  bool IsReflowLocked() const { return mIsReflowing; }
-
-
-
-
-
-
-  bool IsPaintingSuppressed() const { return mPaintingSuppressed; }
-
-
-
-
-
-
-  virtual void PausePainting() = 0;
-
-
-
-
-
-
-  virtual void ResumePainting() = 0;
-
-
-
-
-  virtual void UnsuppressPainting() = 0;
-
-
-
-
-  void DisableThemeSupport()
-  {
-
-    mIsThemeSupportDisabled = true;
-  }
-
-
-
-
-  bool IsThemeSupportEnabled() const { return !mIsThemeSupportDisabled; }
-
-
-
-
-  virtual nsresult GetAgentStyleSheets(
-      nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
-
-
-
-
-  virtual nsresult SetAgentStyleSheets(
-      const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
-
-
-
-
-  virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
-
-
-
-
-  virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
-
-
-
-
-  virtual void ReconstructFrames() = 0;
-
-
-
-
-  virtual void ContentStateChanged(nsIDocument* aDocument,
-                                   nsIContent* aContent,
-                                   mozilla::EventStates aStateMask) = 0;
-
-
-
-
-
-
-  static bool GetVerifyReflowEnable();
-
-
-
-
-  static void SetVerifyReflowEnable(bool aEnabled);
-
-  virtual nsIFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame);
-
-
-  virtual void DumpReflows() = 0;
-  virtual void CountReflows(const char * aName, nsIFrame * aFrame) = 0;
-  virtual void PaintCount(const char * aName,
-                                      nsRenderingContext* aRenderingContext,
-                                      nsPresContext * aPresContext,
-                                      nsIFrame * aFrame,
-                                      const nsPoint& aOffset,
-                                      uint32_t aColor) = 0;
-  virtual void SetPaintFrameCount(bool aOn) = 0;
-  virtual bool IsPaintingFrameCounts() = 0;
-# 1082 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  static bool IsAccessibilityActive();
-
-
-
-
-  static nsAccessibilityService* AccService();
-
-
-
-
-
-
-
-  virtual void Freeze() = 0;
-  bool IsFrozen() { return mFrozen; }
-
-
-
-
-
-  virtual void Thaw() = 0;
-
-  virtual void FireOrClearDelayedEvents(bool aFireEvents) = 0;
-
-
-
-
-
-
-
-  void SetForwardingContainer(const mozilla::WeakPtr<nsDocShell> &aContainer);
-# 1152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  enum {
-    RENDER_IS_UNTRUSTED = 0x01,
-    RENDER_IGNORE_VIEWPORT_SCROLLING = 0x02,
-    RENDER_CARET = 0x04,
-    RENDER_USE_WIDGET_LAYERS = 0x08,
-    RENDER_ASYNC_DECODE_IMAGES = 0x10,
-    RENDER_DOCUMENT_RELATIVE = 0x20,
-    RENDER_DRAWWINDOW_NOT_FLUSHING = 0x40
-  };
-  virtual nsresult RenderDocument(const nsRect& aRect, uint32_t aFlags,
-                                  nscolor aBackgroundColor,
-                                  gfxContext* aRenderedContext) = 0;
-
-  enum {
-    RENDER_IS_IMAGE = 0x100,
-    RENDER_AUTO_SCALE = 0x80
-  };
-
-
-
-
-
-
-
-  virtual already_AddRefed<mozilla::gfx::SourceSurface>
-  RenderNode(nsIDOMNode* aNode,
-             nsIntRegion* aRegion,
-             const mozilla::LayoutDeviceIntPoint aPoint,
-             mozilla::LayoutDeviceIntRect* aScreenRect,
-             uint32_t aFlags) = 0;
-# 1199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual already_AddRefed<mozilla::gfx::SourceSurface>
-  RenderSelection(nsISelection* aSelection,
-                  const mozilla::LayoutDeviceIntPoint aPoint,
-                  mozilla::LayoutDeviceIntRect* aScreenRect,
-                  uint32_t aFlags) = 0;
-
-  void AddAutoWeakFrameInternal(AutoWeakFrame* aWeakFrame);
-  virtual void AddAutoWeakFrameExternal(AutoWeakFrame* aWeakFrame);
-  void AddWeakFrameInternal(WeakFrame* aWeakFrame);
-  virtual void AddWeakFrameExternal(WeakFrame* aWeakFrame);
-
-  void AddAutoWeakFrame(AutoWeakFrame* aWeakFrame)
-  {
-
-    AddAutoWeakFrameInternal(aWeakFrame);
-
-
-
-  }
-  void AddWeakFrame(WeakFrame* aWeakFrame)
-  {
-
-    AddWeakFrameInternal(aWeakFrame);
-
-
-
-  }
-
-  void RemoveAutoWeakFrameInternal(AutoWeakFrame* aWeakFrame);
-  virtual void RemoveAutoWeakFrameExternal(AutoWeakFrame* aWeakFrame);
-  void RemoveWeakFrameInternal(WeakFrame* aWeakFrame);
-  virtual void RemoveWeakFrameExternal(WeakFrame* aWeakFrame);
-
-  void RemoveAutoWeakFrame(AutoWeakFrame* aWeakFrame)
-  {
-
-    RemoveAutoWeakFrameInternal(aWeakFrame);
-
-
-
-  }
-  void RemoveWeakFrame(WeakFrame* aWeakFrame)
-  {
-
-    RemoveWeakFrameInternal(aWeakFrame);
-
-
-
-  }
-# 1260 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual void DisableNonTestMouseEvents(bool aDisable) = 0;
-# 1269 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  void SetCanvasBackground(nscolor aColor) { mCanvasBackgroundColor = aColor; }
-  nscolor GetCanvasBackground() { return mCanvasBackgroundColor; }
-
-
-
-
-
-  virtual void UpdateCanvasBackground() = 0;
-# 1285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  enum {
-    FORCE_DRAW = 0x01
-  };
-  virtual void AddCanvasBackgroundColorItem(nsDisplayListBuilder& aBuilder,
-                                            nsDisplayList& aList,
-                                            nsIFrame* aFrame,
-                                            const nsRect& aBounds,
-                                            nscolor aBackstopColor = ((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))),
-                                            uint32_t aFlags = 0) = 0;
-
-
-
-
-
-
-
-  virtual void AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
-                                             nsDisplayList& aList,
-                                             nsIFrame* aFrame,
-                                             const nsRect& aBounds) = 0;
-
-
-
-
-
-
-  virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot) = 0;
-
-  void ObserveNativeAnonMutationsForPrint(bool aObserve)
-  {
-    mObservesMutationsForPrint = aObserve;
-  }
-  bool ObservesNativeAnonMutationsForPrint()
-  {
-    return mObservesMutationsForPrint;
-  }
-
-  virtual nsresult SetIsActive(bool aIsActive) = 0;
-
-  bool IsActive()
-  {
-    return mIsActive;
-  }
-
-
-  static CapturingContentInfo gCaptureInfo;
-
-  class PointerCaptureInfo final
-  {
-  public:
-    nsCOMPtr<nsIContent> mPendingContent;
-    nsCOMPtr<nsIContent> mOverrideContent;
-
-    explicit PointerCaptureInfo(nsIContent* aPendingContent)
-      : mPendingContent(aPendingContent)
-    {
-                                        ;
-    }
-
-    ~PointerCaptureInfo()
-    {
-                                        ;
-    }
-
-    bool Empty()
-    {
-      return !(mPendingContent || mOverrideContent);
-    }
-  };
-
-  class PointerInfo final
-  {
-  public:
-    uint16_t mPointerType;
-    bool mActiveState;
-    bool mPrimaryState;
-    bool mPreventMouseEventByContent;
-    explicit PointerInfo(bool aActiveState, uint16_t aPointerType,
-                         bool aPrimaryState)
-      : mPointerType(aPointerType)
-      , mActiveState(aActiveState)
-      , mPrimaryState(aPrimaryState)
-      , mPreventMouseEventByContent(false)
-    {
-    }
-  };
-
-  static void DispatchGotOrLostPointerCaptureEvent(
-                bool aIsGotCapture,
-                const mozilla::WidgetPointerEvent* aPointerEvent,
-                nsIContent* aCaptureTarget);
-
-  static PointerCaptureInfo* GetPointerCaptureInfo(uint32_t aPointerId);
-  static void SetPointerCapturingContent(uint32_t aPointerId,
-                                         nsIContent* aContent);
-  static void ReleasePointerCapturingContent(uint32_t aPointerId);
-  static nsIContent* GetPointerCapturingContent(uint32_t aPointerId);
-
-
-
-  static void CheckPointerCaptureState(
-                const mozilla::WidgetPointerEvent* aPointerEvent);
-
-
-
-
-
-  static bool GetPointerInfo(uint32_t aPointerId, bool& aActiveState);
-
-
-
-  static uint16_t GetPointerType(uint32_t aPointerId);
-
-
-
-  static bool GetPointerPrimaryState(uint32_t aPointerId);
-# 1424 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  static void SetCapturingContent(nsIContent* aContent, uint8_t aFlags);
-
-
-
-
-  static nsIContent* GetCapturingContent()
-  {
-    return gCaptureInfo.mContent;
-  }
-
-
-
-
-  static void AllowMouseCapture(bool aAllowed)
-  {
-    gCaptureInfo.mAllowed = aAllowed;
-  }
-
-
-
-
-
-  static bool IsMouseCapturePreventingDrag()
-  {
-    return gCaptureInfo.mPreventDrag && gCaptureInfo.mContent;
-  }
-
-
-
-
-
-  uint64_t GetPaintCount() { return mPaintCount; }
-  void IncrementPaintCount() { ++mPaintCount; }
-
-
-
-
-  virtual already_AddRefed<nsPIDOMWindowOuter> GetRootWindow() = 0;
-
-
-
-
-
-  virtual LayerManager* GetLayerManager() = 0;
-
-
-
-
-
-  virtual bool AsyncPanZoomEnabled() = 0;
-
-
-
-
-
-
-  virtual void SetIgnoreViewportScrolling(bool aIgnore) = 0;
-  bool IgnoringViewportScrolling() const
-  { return mRenderFlags & STATE_IGNORING_VIEWPORT_SCROLLING; }
-# 1493 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual nsresult SetResolution(float aResolution) = 0;
-  float GetResolution() const { return mResolution.valueOr(1.0); }
-  virtual float GetCumulativeResolution() = 0;
-
-
-
-
-
-  virtual float GetCumulativeNonRootScaleResolution() = 0;
-
-
-
-
-  bool IsResolutionSet() { return mResolution.isSome(); }
-
-
-
-
-
-  virtual nsresult SetResolutionAndScaleTo(float aResolution) = 0;
-
-
-
-
-
-
-  virtual bool ScaleToResolution() const = 0;
-
-
-
-
-
-  virtual void SetRestoreResolution(float aResolution,
-                                    mozilla::LayoutDeviceIntSize aDisplaySize) = 0;
-
-
-
-
-
-  bool InDrawWindowNotFlushing() const
-  { return mRenderFlags & STATE_DRAWWINDOW_NOT_FLUSHING; }
-
-
-
-
-  void SetIsFirstPaint(bool aIsFirstPaint) { mIsFirstPaint = aIsFirstPaint; }
-
-
-
-
-  bool GetIsFirstPaint() const { return mIsFirstPaint; }
-
-  uint32_t GetPresShellId() { return mPresShellId; }
-
-
-
-
-
-
-  virtual void SynthesizeMouseMove(bool aFromScroll) = 0;
-
-  enum PaintFlags {
-
-
-
-    PAINT_LAYERS = 0x01,
-
-    PAINT_COMPOSITE = 0x02,
-
-    PAINT_SYNC_DECODE_IMAGES = 0x04
-  };
-  virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
-                     uint32_t aFlags) = 0;
-  virtual nsresult HandleEvent(nsIFrame* aFrame,
-                               mozilla::WidgetGUIEvent* aEvent,
-                               bool aDontRetargetEvents,
-                               nsEventStatus* aEventStatus,
-                               nsIContent** aTargetContent = nullptr) = 0;
-  virtual bool ShouldIgnoreInvalidation() = 0;
-
-
-
-
-
-
-
-  virtual void WillPaint() = 0;
-
-
-
-
-
-  virtual void WillPaintWindow() = 0;
-
-
-
-
-
-  virtual void DidPaintWindow() = 0;
-# 1600 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  enum PaintType {
-    PAINT_DEFAULT,
-    PAINT_DELAYED_COMPRESS
-  };
-  virtual void ScheduleViewManagerFlush(PaintType aType = PAINT_DEFAULT) = 0;
-  virtual void ClearMouseCaptureOnView(nsView* aView) = 0;
-  virtual bool IsVisible() = 0;
-  virtual void DispatchSynthMouseMove(mozilla::WidgetGUIEvent* aEvent,
-                                      bool aFlushOnHoverChange) = 0;
-
-  virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
-                                      nsArenaMemoryStats *aArenaObjectsSize,
-                                      size_t *aPresShellSize,
-                                      size_t *aStyleSetsSize,
-                                      size_t *aTextRunsSize,
-                                      size_t *aPresContextSize) = 0;
-
-
-
-
-  uint32_t FontSizeInflationEmPerLine() const {
-    return mFontSizeInflationEmPerLine;
-  }
-
-  uint32_t FontSizeInflationMinTwips() const {
-    return mFontSizeInflationMinTwips;
-  }
-
-  uint32_t FontSizeInflationLineThreshold() const {
-    return mFontSizeInflationLineThreshold;
-  }
-
-  bool FontSizeInflationForceEnabled() const {
-    return mFontSizeInflationForceEnabled;
-  }
-
-  bool FontSizeInflationDisabledInMasterProcess() const {
-    return mFontSizeInflationDisabledInMasterProcess;
-  }
-
-
-
-
-
-
-
-  bool FontSizeInflationEnabled();
-
-
-
-
-
-
-
-  void NotifyFontSizeInflationEnabledIsDirty()
-  {
-    mFontSizeInflationEnabledIsDirty = true;
-  }
-# 1667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  virtual void ScheduleApproximateFrameVisibilityUpdateSoon() = 0;
-
-
-
-
-
-  virtual void ScheduleApproximateFrameVisibilityUpdateNow() = 0;
-
-
-
-  virtual void RebuildApproximateFrameVisibilityDisplayList(const nsDisplayList& aList) = 0;
-  virtual void RebuildApproximateFrameVisibility(nsRect* aRect = nullptr,
-                                                 bool aRemoveOnly = false) = 0;
-
-
-  virtual void EnsureFrameInApproximatelyVisibleList(nsIFrame* aFrame) = 0;
-
-
-  virtual void RemoveFrameFromApproximatelyVisibleList(nsIFrame* aFrame) = 0;
-
-
-  virtual bool AssumeAllFramesVisible() = 0;
-# 1697 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  nsresult HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType,
-                                                   bool* aRetVal);
-
-
-
-
-protected:
-  virtual bool AddRefreshObserverExternal(nsARefreshObserver* aObserver,
-                                          mozilla::FlushType aFlushType);
-  bool AddRefreshObserverInternal(nsARefreshObserver* aObserver,
-                                  mozilla::FlushType aFlushType);
-  virtual bool RemoveRefreshObserverExternal(nsARefreshObserver* aObserver,
-                                             mozilla::FlushType aFlushType);
-  bool RemoveRefreshObserverInternal(nsARefreshObserver* aObserver,
-                                     mozilla::FlushType aFlushType);
-
-  void DoObserveStyleFlushes();
-  void DoObserveLayoutFlushes();
-
-
-
-
-
-
-  void RecomputeFontSizeInflationEnabled();
-
-
-
-
-  bool DetermineFontSizeInflationState();
-
-
-
-
-
-  void HandleSystemFontScale();
-
-  void RecordAlloc(void* aPtr) {
-
-
-
-
-  }
-
-  void RecordFree(void* aPtr) {
-
-
-
-
-  }
-
-public:
-  bool AddRefreshObserver(nsARefreshObserver* aObserver,
-                          mozilla::FlushType aFlushType) {
-
-    return AddRefreshObserverInternal(aObserver, aFlushType);
-
-
-
-  }
-
-  bool RemoveRefreshObserver(nsARefreshObserver* aObserver,
-                             mozilla::FlushType aFlushType) {
-
-    return RemoveRefreshObserverInternal(aObserver, aFlushType);
-
-
-
-  }
-
-  virtual bool AddPostRefreshObserver(nsAPostRefreshObserver* aObserver);
-  virtual bool RemovePostRefreshObserver(nsAPostRefreshObserver* aObserver);
-
-
-
-
-  static void InitializeStatics();
-  static void ReleaseStatics();
-
-
-
-  static void ClearMouseCapture(nsIFrame* aFrame);
-
-  void SetScrollPositionClampingScrollPortSize(nscoord aWidth, nscoord aHeight);
-  bool IsScrollPositionClampingScrollPortSizeSet() {
-    return mScrollPositionClampingScrollPortSizeSet;
-  }
-  nsSize GetScrollPositionClampingScrollPortSize() {
-    do { } while(0);
-    return mScrollPositionClampingScrollPortSize;
-  }
-
-  virtual void WindowSizeMoveDone() = 0;
-  virtual void SysColorChanged() = 0;
-  virtual void ThemeChanged() = 0;
-  virtual void BackingScaleFactorChanged() = 0;
-
-
-
-
-  bool IsNeverPainting() {
-    return mIsNeverPainting;
-  }
-
-  void SetNeverPainting(bool aNeverPainting) {
-    mIsNeverPainting = aNeverPainting;
-  }
-
-  bool HasPendingReflow() const
-    { return mObservingLayoutFlushes || mReflowContinueTimer; }
-
-  void SyncWindowProperties(nsView* aView);
-
-  virtual nsIDocument* GetPrimaryContentDocument() = 0;
-
-
-  virtual void NotifyStyleSheetServiceSheetAdded(mozilla::StyleSheet* aSheet,
-                                                 uint32_t aSheetType) = 0;
-  virtual void NotifyStyleSheetServiceSheetRemoved(mozilla::StyleSheet* aSheet,
-                                                   uint32_t aSheetType) = 0;
-
-protected:
-  friend class nsRefreshDriver;
-
-
-
-
-
-
-
-  nsCOMPtr<nsIDocument> mDocument;
-  RefPtr<nsPresContext> mPresContext;
-  mozilla::StyleSetHandle mStyleSet;
-  nsCSSFrameConstructor* mFrameConstructor;
-  nsViewManager* mViewManager;
-  nsPresArena mFrameArena;
-  RefPtr<nsFrameSelection> mSelection;
-
-
-  nsFrameManagerBase* mFrameManager;
-  mozilla::WeakPtr<nsDocShell> mForwardingContainer;
-
-  mozilla::a11y::DocAccessible* mDocAccessible;
-
-
-
-
-
-
-  nsCOMPtr<nsITimer> mReflowContinueTimer;
-# 1858 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  uint64_t mPaintCount;
-
-  nsSize mScrollPositionClampingScrollPortSize;
-
-
-  AutoWeakFrame* mAutoWeakFrames;
-
-
-  nsTHashtable<nsPtrHashKey<WeakFrame>> mWeakFrames;
-
-
-  nscolor mCanvasBackgroundColor;
-
-
-
-  mozilla::Maybe<float> mResolution;
-
-  int16_t mSelectionFlags;
-
-
-
-
-
-
-  RenderFlags mRenderFlags;
-
-
-
-
-  bool mStylesHaveChanged : 1;
-  bool mDidInitialize : 1;
-  bool mIsDestroying : 1;
-  bool mIsReflowing : 1;
-
-
-  bool mPaintingSuppressed : 1;
-
-
-  bool mIsThemeSupportDisabled : 1;
-
-  bool mIsActive : 1;
-  bool mFrozen : 1;
-  bool mIsFirstPaint : 1;
-  bool mObservesMutationsForPrint : 1;
-
-  bool mSuppressInterruptibleReflows : 1;
-  bool mScrollPositionClampingScrollPortSizeSet : 1;
-
-
-  bool mNeedLayoutFlush : 1;
-
-
-  bool mNeedStyleFlush : 1;
-
-
-  bool mObservingStyleFlushes: 1;
-
-
-
-
-
-  bool mObservingLayoutFlushes: 1;
-
-
-
-  bool mNeedThrottledAnimationFlush : 1;
-
-  uint32_t mPresShellId;
-# 1934 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPresShell.h"
-  AutoTArray<RefPtr<mozilla::dom::Element>,1> mChangedScopeStyleRoots;
-
-  static nsIContent* gKeyDownTarget;
-
-
-
-  uint32_t mFontSizeInflationEmPerLine;
-  uint32_t mFontSizeInflationMinTwips;
-  uint32_t mFontSizeInflationLineThreshold;
-  bool mFontSizeInflationForceEnabled;
-  bool mFontSizeInflationDisabledInMasterProcess;
-  bool mFontSizeInflationEnabled;
-
-
-  bool mFontSizeInflationEnabledIsDirty;
-
-  bool mPaintingIsFrozen;
-
-
-
-
-  bool mIsNeverPainting;
-
-
-
-  bool mInFlush;
-};
-
-template<typename T> struct nsIPresShell::COMTypeInfo<nsIPresShell, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPresShell::COMTypeInfo<nsIPresShell, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xa75573d6, 0x34c8, 0x4485, { 0x8f, 0xb7, 0xed, 0xcb, 0x6f, 0xc7, 0x0e, 0x12 } };
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFamilyList.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFamilyList.h"
-namespace mozilla {
-
-
-
-
-
-
-
-enum FontFamilyType : uint32_t {
-  eFamily_none = 0,
-
-
-  eFamily_named,
-  eFamily_named_quoted,
-
-
-  eFamily_serif,
-  eFamily_sans_serif,
-  eFamily_monospace,
-  eFamily_cursive,
-  eFamily_fantasy,
-
-
-  eFamily_moz_variable,
-  eFamily_moz_fixed,
-
-  eFamily_generic_first = eFamily_serif,
-  eFamily_generic_last = eFamily_fantasy,
-  eFamily_generic_count = (eFamily_fantasy - eFamily_serif + 1)
-};
-
-enum QuotedName { eQuotedName, eUnquotedName };
-
-
-
-
-
-
-struct FontFamilyName final {
-    FontFamilyName()
-        : mType(eFamily_named)
-    {}
-
-
-    explicit FontFamilyName(const nsAString& aFamilyName,
-                            QuotedName aQuoted = eUnquotedName) {
-        mType = (aQuoted == eQuotedName) ? eFamily_named_quoted : eFamily_named;
-        mName = aFamilyName;
-    }
-
-
-    explicit FontFamilyName(FontFamilyType aType) {
-        do { } while(0);
-
-
-
-        mName.Truncate();
-        mType = aType;
-    }
-
-    FontFamilyName(const FontFamilyName& aCopy) {
-        mType = aCopy.mType;
-        mName = aCopy.mName;
-    }
-
-    bool IsNamed() const {
-        return mType == eFamily_named || mType == eFamily_named_quoted;
-    }
-
-    bool IsGeneric() const {
-        return !IsNamed();
-    }
-
-    void AppendToString(nsAString& aFamilyList, bool aQuotes = true) const {
-        switch (mType) {
-            case eFamily_named:
-                aFamilyList.Append(mName);
-                break;
-            case eFamily_named_quoted:
-                if (aQuotes) {
-                    aFamilyList.Append('"');
-                }
-                aFamilyList.Append(mName);
-                if (aQuotes) {
-                    aFamilyList.Append('"');
-                }
-                break;
-            case eFamily_serif:
-                aFamilyList.AppendLiteral("serif");
-                break;
-            case eFamily_sans_serif:
-                aFamilyList.AppendLiteral("sans-serif");
-                break;
-            case eFamily_monospace:
-                aFamilyList.AppendLiteral("monospace");
-                break;
-            case eFamily_cursive:
-                aFamilyList.AppendLiteral("cursive");
-                break;
-            case eFamily_fantasy:
-                aFamilyList.AppendLiteral("fantasy");
-                break;
-            case eFamily_moz_fixed:
-                aFamilyList.AppendLiteral("-moz-fixed");
-                break;
-            default:
-                break;
-        }
-    }
-
-
-    static FontFamilyName
-    Convert(const nsAString& aFamilyOrGenericName) {
-
-
-
-        do { } while(0);
-
-
-        FontFamilyType genericType = eFamily_none;
-        if (aFamilyOrGenericName.LowerCaseEqualsLiteral("serif")) {
-            genericType = eFamily_serif;
-        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("sans-serif")) {
-            genericType = eFamily_sans_serif;
-        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("monospace")) {
-            genericType = eFamily_monospace;
-        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("cursive")) {
-            genericType = eFamily_cursive;
-        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("fantasy")) {
-            genericType = eFamily_fantasy;
-        } else if (aFamilyOrGenericName.LowerCaseEqualsLiteral("-moz-fixed")) {
-            genericType = eFamily_moz_fixed;
-        } else {
-            return FontFamilyName(aFamilyOrGenericName, eUnquotedName);
-        }
-
-        return FontFamilyName(genericType);
-    }
-
-
-    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-        return mName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
-    }
-
-    FontFamilyType mType;
-    nsString mName;
-};
-
-inline bool
-operator==(const FontFamilyName& a, const FontFamilyName& b) {
-    return a.mType == b.mType && a.mName == b.mName;
-}
-
-
-
-
-
-
-
-class FontFamilyList {
-public:
-    FontFamilyList()
-        : mDefaultFontType(eFamily_none)
-    {
-    }
-
-    explicit FontFamilyList(FontFamilyType aGenericType)
-        : mDefaultFontType(eFamily_none)
-    {
-        Append(FontFamilyName(aGenericType));
-    }
-
-    FontFamilyList(const nsAString& aFamilyName,
-                   QuotedName aQuoted)
-        : mDefaultFontType(eFamily_none)
-    {
-        Append(FontFamilyName(aFamilyName, aQuoted));
-    }
-
-    FontFamilyList(const FontFamilyList& aOther)
-        : mFontlist(aOther.mFontlist)
-        , mDefaultFontType(aOther.mDefaultFontType)
-    {
-    }
-
-    void Append(const FontFamilyName& aFamilyName) {
-        mFontlist.AppendElement(aFamilyName);
-    }
-
-    void Append(const nsTArray<nsString>& aFamilyNameList) {
-        uint32_t len = aFamilyNameList.Length();
-        for (uint32_t i = 0; i < len; i++) {
-            mFontlist.AppendElement(FontFamilyName(aFamilyNameList[i],
-                                                   eUnquotedName));
-        }
-    }
-
-    void Clear() {
-        mFontlist.Clear();
-    }
-
-    uint32_t Length() const {
-        return mFontlist.Length();
-    }
-
-    bool IsEmpty() const {
-      return mFontlist.IsEmpty();
-    }
-
-    const nsTArray<FontFamilyName>& GetFontlist() const {
-        return mFontlist;
-    }
-
-    bool Equals(const FontFamilyList& aFontlist) const {
-        return mFontlist == aFontlist.mFontlist &&
-               mDefaultFontType == aFontlist.mDefaultFontType;
-    }
-
-    FontFamilyType FirstGeneric() const {
-        uint32_t len = mFontlist.Length();
-        for (uint32_t i = 0; i < len; i++) {
-            const FontFamilyName& name = mFontlist[i];
-            if (name.IsGeneric()) {
-                return name.mType;
-            }
-        }
-        return eFamily_none;
-    }
-
-    bool HasGeneric() const {
-        return FirstGeneric() != eFamily_none;
-    }
-
-    bool HasDefaultGeneric() const {
-        uint32_t len = mFontlist.Length();
-        for (uint32_t i = 0; i < len; i++) {
-            const FontFamilyName& name = mFontlist[i];
-            if (name.mType == mDefaultFontType) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-
-
-
-    bool PrioritizeFirstGeneric() {
-        uint32_t len = mFontlist.Length();
-        for (uint32_t i = 0; i < len; i++) {
-            const FontFamilyName name = mFontlist[i];
-            if (name.IsGeneric()) {
-                if (name.mType == eFamily_cursive ||
-                    name.mType == eFamily_fantasy) {
-                    continue;
-                }
-                if (i > 0) {
-                    mFontlist.RemoveElementAt(i);
-                    mFontlist.InsertElementAt(0, name);
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
-    void PrependGeneric(FontFamilyType aType) {
-        mFontlist.InsertElementAt(0, FontFamilyName(aType));
-    }
-
-    void ToString(nsAString& aFamilyList,
-                  bool aQuotes = true,
-                  bool aIncludeDefault = false) const {
-        aFamilyList.Truncate();
-        uint32_t len = mFontlist.Length();
-        for (uint32_t i = 0; i < len; i++) {
-            if (i != 0) {
-                aFamilyList.Append(',');
-            }
-            const FontFamilyName& name = mFontlist[i];
-            name.AppendToString(aFamilyList, aQuotes);
-        }
-        if (aIncludeDefault && mDefaultFontType != eFamily_none) {
-            if (!aFamilyList.IsEmpty()) {
-                aFamilyList.Append(',');
-            }
-            if (mDefaultFontType == eFamily_serif) {
-                aFamilyList.AppendLiteral("serif");
-            } else {
-                aFamilyList.AppendLiteral("sans-serif");
-            }
-        }
-    }
-
-
-    bool Contains(const nsAString& aFamilyName) const {
-        uint32_t len = mFontlist.Length();
-        nsAutoString fam(aFamilyName);
-        ToLowerCase(fam);
-        for (uint32_t i = 0; i < len; i++) {
-            const FontFamilyName& name = mFontlist[i];
-            if (name.mType != eFamily_named &&
-                name.mType != eFamily_named_quoted) {
-                continue;
-            }
-            nsAutoString listname(name.mName);
-            ToLowerCase(listname);
-            if (listname.Equals(fam)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    FontFamilyType GetDefaultFontType() const { return mDefaultFontType; }
-    void SetDefaultFontType(FontFamilyType aType) {
-        do { } while(0);
-
-
-        mDefaultFontType = aType;
-    }
-
-
-    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-        size_t n = 0;
-        n += mFontlist.ShallowSizeOfExcludingThis(aMallocSizeOf);
-        for (size_t i = 0; i < mFontlist.Length(); i++) {
-            n += mFontlist[i].SizeOfExcludingThis(aMallocSizeOf);
-        }
-        return n;
-    }
-
-    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-        return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-    }
-
-private:
-    nsTArray<FontFamilyName> mFontlist;
-    FontFamilyType mDefaultFontType;
-};
-
-inline bool
-operator==(const FontFamilyList& a, const FontFamilyList& b) {
-    return a.Equals(b);
-}
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h" 1
-# 50 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
-enum {
-    eFeatureAlternates_historical,
-    eFeatureAlternates_stylistic,
-    eFeatureAlternates_styleset,
-    eFeatureAlternates_character_variant,
-    eFeatureAlternates_swash,
-    eFeatureAlternates_ornaments,
-    eFeatureAlternates_annotation,
-
-    eFeatureAlternates_numFeatures
-};
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
-enum {
-    eFeatureEastAsian_jis78,
-    eFeatureEastAsian_jis83,
-    eFeatureEastAsian_jis90,
-    eFeatureEastAsian_jis04,
-    eFeatureEastAsian_simplified,
-    eFeatureEastAsian_traditional,
-    eFeatureEastAsian_full_width,
-    eFeatureEastAsian_prop_width,
-    eFeatureEastAsian_ruby,
-
-    eFeatureEastAsian_numFeatures
-};
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
-enum {
-    eFeatureLigatures_none,
-    eFeatureLigatures_common,
-    eFeatureLigatures_no_common,
-    eFeatureLigatures_discretionary,
-    eFeatureLigatures_no_discretionary,
-    eFeatureLigatures_historical,
-    eFeatureLigatures_no_historical,
-    eFeatureLigatures_contextual,
-    eFeatureLigatures_no_contextual,
-
-    eFeatureLigatures_numFeatures
-};
-# 168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
-enum {
-    eFeatureNumeric_lining,
-    eFeatureNumeric_oldstyle,
-    eFeatureNumeric_proportional,
-    eFeatureNumeric_tabular,
-    eFeatureNumeric_diagonal_fractions,
-    eFeatureNumeric_stacked_fractions,
-    eFeatureNumeric_slashedzero,
-    eFeatureNumeric_ordinal,
-
-    eFeatureNumeric_numFeatures
-};
-# 226 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h"
-enum eFontPrefLang {
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontPrefLangList.h" 1
-
-
-
-
-
-
-
-eFontPrefLang_Western,
-eFontPrefLang_Japanese,
-eFontPrefLang_ChineseTW,
-eFontPrefLang_ChineseCN,
-eFontPrefLang_ChineseHK,
-eFontPrefLang_Korean,
-eFontPrefLang_Cyrillic,
-eFontPrefLang_Greek,
-eFontPrefLang_Thai,
-eFontPrefLang_Hebrew,
-eFontPrefLang_Arabic,
-eFontPrefLang_Devanagari,
-eFontPrefLang_Tamil,
-eFontPrefLang_Armenian,
-eFontPrefLang_Bengali,
-eFontPrefLang_Canadian,
-eFontPrefLang_Ethiopic,
-eFontPrefLang_Georgian,
-eFontPrefLang_Gujarati,
-eFontPrefLang_Gurmukhi,
-eFontPrefLang_Khmer,
-eFontPrefLang_Malayalam,
-eFontPrefLang_Mathematics,
-eFontPrefLang_Oriya,
-eFontPrefLang_Telugu,
-eFontPrefLang_Kannada,
-eFontPrefLang_Sinhala,
-eFontPrefLang_Tibetan,
-eFontPrefLang_Others
-# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontConstants.h" 2
-
-
-    , eFontPrefLang_CJKSet
-    , eFontPrefLang_First = eFontPrefLang_Western
-    , eFontPrefLang_Last = eFontPrefLang_Others
-    , eFontPrefLang_Count = (eFontPrefLang_Last - eFontPrefLang_First + 1)
-};
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFeatures.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontFeatures.h"
-struct gfxFontFeature {
-    uint32_t mTag;
-    uint32_t mValue;
-
-};
-
-inline bool
-operator<(const gfxFontFeature& a, const gfxFontFeature& b)
-{
-    return (a.mTag < b.mTag) || ((a.mTag == b.mTag) && (a.mValue < b.mValue));
-}
-
-inline bool
-operator==(const gfxFontFeature& a, const gfxFontFeature& b)
-{
-    return (a.mTag == b.mTag) && (a.mValue == b.mValue);
-}
-
-struct gfxAlternateValue {
-    uint32_t alternate;
-    nsString value;
-};
-
-inline bool
-operator<(const gfxAlternateValue& a, const gfxAlternateValue& b)
-{
-    return (a.alternate < b.alternate) ||
-        ((a.alternate == b.alternate) && (a.value < b.value));
-}
-
-inline bool
-operator==(const gfxAlternateValue& a, const gfxAlternateValue& b)
-{
-    return (a.alternate == b.alternate) && (a.value == b.value);
-}
-
-class gfxFontFeatureValueSet final {
-public:
-    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<gfxFontFeatureValueSet>::value, "Reference-counted class " "gfxFontFeatureValueSet" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-    gfxFontFeatureValueSet();
-
-    struct ValueList {
-        ValueList(const nsAString& aName, const nsTArray<uint32_t>& aSelectors)
-          : name(aName), featureSelectors(aSelectors)
-        {}
-        nsString name;
-        nsTArray<uint32_t> featureSelectors;
-    };
-
-    struct FeatureValues {
-        uint32_t alternate;
-        nsTArray<ValueList> valuelist;
-    };
-
-
-    bool
-    GetFontFeatureValuesFor(const nsAString& aFamily,
-                            uint32_t aVariantProperty,
-                            const nsAString& aName,
-                            nsTArray<uint32_t>& aValues);
-    void
-    AddFontFeatureValues(const nsAString& aFamily,
-                const nsTArray<gfxFontFeatureValueSet::FeatureValues>& aValues);
-
-private:
-
-    ~gfxFontFeatureValueSet() {}
-
-    struct FeatureValueHashKey {
-        nsString mFamily;
-        uint32_t mPropVal;
-        nsString mName;
-
-        FeatureValueHashKey()
-            : mPropVal(0)
-        { }
-        FeatureValueHashKey(const nsAString& aFamily,
-                            uint32_t aPropVal,
-                            const nsAString& aName)
-            : mFamily(aFamily), mPropVal(aPropVal), mName(aName)
-        { }
-        FeatureValueHashKey(const FeatureValueHashKey& aKey)
-            : mFamily(aKey.mFamily), mPropVal(aKey.mPropVal), mName(aKey.mName)
-        { }
-    };
-
-    class FeatureValueHashEntry : public PLDHashEntryHdr {
-    public:
-        typedef const FeatureValueHashKey &KeyType;
-        typedef const FeatureValueHashKey *KeyTypePointer;
-
-        explicit FeatureValueHashEntry(KeyTypePointer aKey) { }
-        FeatureValueHashEntry(const FeatureValueHashEntry& toCopy)
-        {
-            do { } while(0);
-        }
-        ~FeatureValueHashEntry() { }
-
-        bool KeyEquals(const KeyTypePointer aKey) const;
-        static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
-        static PLDHashNumber HashKey(const KeyTypePointer aKey);
-        enum { ALLOW_MEMMOVE = true };
-
-        FeatureValueHashKey mKey;
-        nsTArray<uint32_t> mValues;
-    };
-
-    nsTHashtable<FeatureValueHashEntry> mFontFeatureValues;
-  };
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontVariations.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxFontVariations.h"
-struct gfxFontVariation {
-    uint32_t mTag;
-    float mValue;
-};
-
-inline bool
-operator==(const gfxFontVariation& a, const gfxFontVariation& b)
-{
-    return (a.mTag == b.mTag) && (a.mValue == b.mValue);
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsFont.h" 2
-
-
-
-
-
-
-struct gfxFontStyle;
-
-
-
-
-
-typedef bool (*nsFontFamilyEnumFunc)(const nsString& aFamily, bool aGeneric, void *aData);
-
-
-
-
-const uint8_t kGenericFont_NONE = 0x00;
-
-const uint8_t kGenericFont_moz_variable = 0x00;
-const uint8_t kGenericFont_moz_fixed = 0x01;
-
-const uint8_t kGenericFont_serif = 0x02;
-const uint8_t kGenericFont_sans_serif = 0x04;
-const uint8_t kGenericFont_monospace = 0x08;
-const uint8_t kGenericFont_cursive = 0x10;
-const uint8_t kGenericFont_fantasy = 0x20;
-
-
-struct nsFont {
-
-
-  mozilla::FontFamilyList fontlist;
-
-
-  uint8_t style = 0;
-
-
-
-  bool systemFont = false;
-
-
-  uint8_t variantCaps = 0;
-  uint8_t variantNumeric = 0;
-  uint8_t variantPosition = 0;
-  uint8_t variantWidth = 0;
-
-  uint16_t variantLigatures = 0;
-  uint16_t variantEastAsian = 0;
-
-
-
-
-
-
-  uint16_t variantAlternates = 0;
-
-
-  uint8_t smoothing = 0;
-
-
-  uint16_t weight = 400;
-
-
-
-  int16_t stretch = 0;
-
-
-  uint8_t kerning = 0;
-
-
-  uint8_t synthesis = 0x1 | 0x2;
-
-
-  nscoord size = 0;
-
-
-
-
-
-  float sizeAdjust = -1.0f;
-
-
-  nsTArray<gfxAlternateValue> alternateValues;
-
-
-  RefPtr<gfxFontFeatureValueSet> featureValueLookup;
-
-
-  nsTArray<gfxFontFeature> fontFeatureSettings;
-
-
-  nsTArray<gfxFontVariation> fontVariationSettings;
-
-
-
-
-  uint32_t languageOverride = 0;
-
-
-  nsFont(const mozilla::FontFamilyList& aFontlist, nscoord aSize);
-
-
-  nsFont(mozilla::FontFamilyType aGenericType, nscoord aSize);
-
-
-  nsFont(const nsFont& aFont);
-
-
-  nsFont();
-
-  ~nsFont();
-
-  bool operator==(const nsFont& aOther) const {
-    return Equals(aOther);
-  }
-
-  bool operator!=(const nsFont& aOther) const {
-    return !Equals(aOther);
-  }
-
-  bool Equals(const nsFont& aOther) const;
-
-  nsFont& operator=(const nsFont& aOther);
-
-  void CopyAlternates(const nsFont& aOther);
-
-
-  void AddFontFeaturesToStyle(gfxFontStyle *aStyle) const;
-
-  void AddFontVariationsToStyle(gfxFontStyle *aStyle) const;
-};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserver.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserver.h"
-class nsIObserver : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) = 0;
-
-};
-
-  template<typename T> struct nsIObserver::COMTypeInfo<nsIObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIObserver::COMTypeInfo<nsIObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xdb242e01, 0xe4d9, 0x11d2, { 0x9d, 0xde, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }};
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
-class nsIObserver;
-
-class nsIEventTarget;
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
-class nsITimer;
-typedef void (*nsTimerCallbackFunc) (nsITimer *aTimer, void *aClosure);
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
-typedef void (*nsTimerNameCallbackFunc) (nsITimer *aTimer,
-                                         bool aAnonymize,
-                                         void *aClosure,
-                                         char *aBuf, size_t aLen);
-class nsITimer;
-# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
-class nsITimerCallback : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Notify(nsITimer *timer) = 0;
-
-};
-
-  template<typename T> struct nsITimerCallback::COMTypeInfo<nsITimerCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimerCallback::COMTypeInfo<nsITimerCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa796816d, 0x7d47, 0x4348, { 0x9a, 0xb8, 0xc7, 0xae, 0xb3, 0x21, 0x6a, 0x7d }};
-# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimer.h"
-class nsITimer : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    TYPE_ONE_SHOT = 0,
-    TYPE_REPEATING_SLACK = 1,
-    TYPE_REPEATING_PRECISE = 2,
-    TYPE_REPEATING_PRECISE_CAN_SKIP = 3
-  };
-
-
-  virtual nsresult Init(nsIObserver *aObserver, uint32_t aDelay, uint32_t aType) = 0;
-
-
-  virtual nsresult InitWithFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType) = 0;
-
-
-  virtual nsresult InitWithCallback(nsITimerCallback *aCallback, uint32_t aDelay, uint32_t aType) = 0;
-
-
-  virtual nsresult Cancel(void) = 0;
-
-
-  virtual nsresult InitWithNamedFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType, const char * aName) = 0;
-
-
-  virtual nsresult InitWithNameableFuncCallback(nsTimerCallbackFunc aCallback, void *aClosure, uint32_t aDelay, uint32_t aType, nsTimerNameCallbackFunc aNameCallback) = 0;
-
-
-  virtual nsresult GetDelay(uint32_t *aDelay) = 0;
-  virtual nsresult SetDelay(uint32_t aDelay) = 0;
-
-
-  virtual nsresult GetType(uint32_t *aType) = 0;
-  virtual nsresult SetType(uint32_t aType) = 0;
-
-
-  virtual nsresult GetClosure(void **aClosure) = 0;
-
-
-  virtual nsresult GetCallback(nsITimerCallback * *aCallback) = 0;
-
-
-  virtual nsresult GetTarget(nsIEventTarget * *aTarget) = 0;
-  virtual nsresult SetTarget(nsIEventTarget *aTarget) = 0;
-
-   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const = 0;
-};
-
-  template<typename T> struct nsITimer::COMTypeInfo<nsITimer, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimer::COMTypeInfo<nsITimer, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3de4b105, 0x363c, 0x482c, { 0xa4, 0x09, 0xba, 0xac, 0x83, 0xa0, 0x1b, 0xfc }};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 1
-
-
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h" 1
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern "C" {
-
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRUint32
-PL_strlen(const char *str);
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) PRUint32
-PL_strnlen(const char *str, PRUint32 max);
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strcpy(char *dest, const char *src);
-# 73 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strncpy(char *dest, const char *src, PRUint32 max);
-# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strncpyz(char *dest, const char *src, PRUint32 max);
-# 110 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strdup(const char *s);
-
-
-
-
-
-
-
-extern __attribute__((visibility("default"))) void
-PL_strfree(char *s);
-# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strndup(const char *s, PRUint32 max);
-# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strcat(char *dst, const char *src);
-# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strncat(char *dst, const char *src, PRUint32 max);
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strcatn(char *dst, PRUint32 max, const char *src);
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) PRIntn
-PL_strcmp(const char *a, const char *b);
-# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) PRIntn
-PL_strncmp(const char *a, const char *b, PRUint32 max);
-# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) PRIntn
-PL_strcasecmp(const char *a, const char *b);
-# 225 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) PRIntn
-PL_strncasecmp(const char *a, const char *b, PRUint32 max);
-# 236 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strchr(const char *s, char c);
-# 247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strrchr(const char *s, char c);
-# 259 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnchr(const char *s, char c, PRUint32 n);
-# 271 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnrchr(const char *s, char c, PRUint32 n);
-# 287 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strpbrk(const char *s, const char *list);
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strprbrk(const char *s, const char *list);
-# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnpbrk(const char *s, const char *list, PRUint32 n);
-# 320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnprbrk(const char *s, const char *list, PRUint32 n);
-# 330 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strstr(const char *big, const char *little);
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strrstr(const char *big, const char *little);
-# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnstr(const char *big, const char *little, PRUint32 n);
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strnrstr(const char *big, const char *little, PRUint32 max);
-# 372 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strcasestr(const char *big, const char *little);
-# 382 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strcaserstr(const char *big, const char *little);
-# 393 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strncasestr(const char *big, const char *little, PRUint32 max);
-# 404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strncaserstr(const char *big, const char *little, PRUint32 max);
-# 426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/plstr.h"
-extern __attribute__((visibility("default"))) char *
-PL_strtok_r(char *s1, const char *s2, char **lasts);
-
-
-
-
-
-
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h"
-extern const char16_t kIsoLatin1ToUCS2[256];
-
-
-
-class nsCRT
-{
-public:
-  enum
-  {
-    LF = '\n' ,
-    VTAB = '\v' ,
-    CR = '\r'
-  };
-
-
-  static int32_t strcmp(const char* aStr1, const char* aStr2)
-  {
-    return int32_t(PL_strcmp(aStr1, aStr2));
-  }
-
-  static int32_t strncmp(const char* aStr1, const char* aStr2,
-                         uint32_t aMaxLen)
-  {
-    return int32_t(PL_strncmp(aStr1, aStr2, aMaxLen));
-  }
-
-
-  static int32_t strcasecmp(const char* aStr1, const char* aStr2)
-  {
-    return int32_t(PL_strcasecmp(aStr1, aStr2));
-  }
-
-
-  static int32_t strncasecmp(const char* aStr1, const char* aStr2,
-                             uint32_t aMaxLen)
-  {
-    int32_t result = int32_t(PL_strncasecmp(aStr1, aStr2, aMaxLen));
-
-
-    if (result < 0) {
-      result = -1;
-    }
-    return result;
-  }
-
-  static int32_t strncmp(const char* aStr1, const char* aStr2, int32_t aMaxLen)
-  {
-
-    int32_t diff =
-      ((const unsigned char*)aStr1)[0] - ((const unsigned char*)aStr2)[0];
-    if (diff != 0) {
-      return diff;
-    }
-    return int32_t(PL_strncmp(aStr1, aStr2, unsigned(aMaxLen)));
-  }
-# 100 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCRT.h"
-  static char* strtok(char* aStr, const char* aDelims, char** aNewStr);
-
-
-  static int32_t strcmp(const char16_t* aStr1, const char16_t* aStr2);
-
-  static int32_t strncmp(const char16_t* aStr1, const char16_t* aStr2,
-                         uint32_t aMaxLen);
-
-
-
-
-  static const char* memmem(const char* aHaystack, uint32_t aHaystackLen,
-                            const char* aNeedle, uint32_t aNeedleLen);
-
-
-  static int64_t atoll(const char* aStr);
-
-  static char ToUpper(char aChar) { return NS_ToUpper(aChar); }
-  static char ToLower(char aChar) { return NS_ToLower(aChar); }
-
-  static bool IsUpper(char aChar) { return NS_IsUpper(aChar); }
-  static bool IsLower(char aChar) { return NS_IsLower(aChar); }
-
-  static bool IsAscii(char16_t aChar) { return NS_IsAscii(aChar); }
-  static bool IsAscii(const char16_t* aString) { return NS_IsAscii(aString); }
-  static bool IsAsciiAlpha(char16_t aChar) { return NS_IsAsciiAlpha(aChar); }
-  static bool IsAsciiDigit(char16_t aChar) { return NS_IsAsciiDigit(aChar); }
-  static bool IsAsciiSpace(char16_t aChar) { return NS_IsAsciiWhitespace(aChar); }
-  static bool IsAscii(const char* aString) { return NS_IsAscii(aString); }
-  static bool IsAscii(const char* aString, uint32_t aLength)
-  {
-    return NS_IsAscii(aString, aLength);
-  }
-};
-
-
-inline bool
-NS_IS_SPACE(char16_t aChar)
-{
-  return ((int(aChar) & 0x7f) == int(aChar)) && isspace(int(aChar));
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h"
-class nsView;
-class nsIPresShell;
-class nsIWidget;
-class nsIXULWindow;
-
-
-
-
-enum nsSizeMode
-{
-  nsSizeMode_Normal = 0,
-  nsSizeMode_Minimized,
-  nsSizeMode_Maximized,
-  nsSizeMode_Fullscreen,
-  nsSizeMode_Invalid
-};
-
-
-
-
-enum nsWindowZ
-{
-  nsWindowZTop = 0,
-  nsWindowZBottom,
-  nsWindowZRelative
-};
-
-class nsIWidgetListener
-{
-public:
-
-
-
-
-
-
-  virtual nsIXULWindow* GetXULWindow();
-
-
-
-
-  virtual nsView* GetView();
-
-
-
-
-  virtual nsIPresShell* GetPresShell();
-
-
-
-
-
-  virtual bool WindowMoved(nsIWidget* aWidget, int32_t aX, int32_t aY);
-
-
-
-
-
-  virtual bool WindowResized(nsIWidget* aWidget,
-                             int32_t aWidth, int32_t aHeight);
-
-
-
-
-  virtual void SizeModeChanged(nsSizeMode aSizeMode);
-
-
-
-
-
-  virtual void UIResolutionChanged();
-# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIWidgetListener.h"
-  virtual bool ZLevelChanged(bool aImmediate, nsWindowZ* aPlacement,
-                             nsIWidget* aRequestBelow,
-                             nsIWidget** aActualBelow);
-
-
-
-
-  virtual void FullscreenChanged(bool aInFullscreen);
-
-
-
-
-  virtual void WindowActivated();
-
-
-
-
-  virtual void WindowDeactivated();
-
-
-
-
-  virtual void OSToolbarButtonPressed();
-
-
-
-
-
-  virtual bool RequestWindowClose(nsIWidget* aWidget);
-
-
-
-
-
-
-  virtual void WillPaintWindow(nsIWidget* aWidget);
-
-
-
-
-
-
-
-  virtual bool PaintWindow(nsIWidget* aWidget,
-                           mozilla::LayoutDeviceIntRegion aRegion);
-
-
-
-
-
-
-
-  virtual void DidPaintWindow();
-
-  virtual void DidCompositeWindow(uint64_t aTransactionId,
-                                  const mozilla::TimeStamp& aCompositeStart,
-                                  const mozilla::TimeStamp& aCompositeEnd);
-
-
-
-
-  virtual void RequestRepaint();
-
-
-
-
-  virtual nsEventStatus HandleEvent(mozilla::WidgetGUIEvent* aEvent,
-                                    bool aUseAttachedEvents);
-};
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Unused.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Unused.h"
-namespace mozilla {
-
-
-
-
-
-struct unused_t
-{
-  template<typename T>
-  inline void
-  operator<<(const T& ) const {}
-};
-
-extern __attribute__((weak)) __attribute__((visibility("default"))) const unused_t Unused;
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h" 2
-
-
-
-
-class nsIFrame;
-
-namespace mozilla {
-
-struct FramePropertyDescriptorUntyped
-{
-
-
-
-  typedef void UntypedDestructor(void* aPropertyValue);
-  UntypedDestructor* mDestructor;
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-  typedef void UntypedDestructorWithFrame(const nsIFrame* aFrame,
-                                          void* aPropertyValue);
-  UntypedDestructorWithFrame* mDestructorWithFrame;
-
-
-
-
-
-protected:
-
-
-
-
-
-  constexpr FramePropertyDescriptorUntyped(
-    UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
-    : mDestructor(aDtor)
-    , mDestructorWithFrame(aDtorWithFrame)
-  {}
-};
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-template<typename T>
-struct FramePropertyDescriptor : public FramePropertyDescriptorUntyped
-{
-  typedef void Destructor(T* aPropertyValue);
-  typedef void DestructorWithFrame(const nsIFrame* aaFrame,
-                                   T* aPropertyValue);
-
-  template<Destructor Dtor>
-  static constexpr const FramePropertyDescriptor<T> NewWithDestructor()
-  {
-    return { Destruct<Dtor>, nullptr };
-  }
-
-  template<DestructorWithFrame Dtor>
-  static constexpr
-  const FramePropertyDescriptor<T> NewWithDestructorWithFrame()
-  {
-    return { nullptr, DestructWithFrame<Dtor> };
-  }
-
-  static constexpr const FramePropertyDescriptor<T> NewWithoutDestructor()
-  {
-    return { nullptr, nullptr };
-  }
-
-private:
-  constexpr FramePropertyDescriptor(
-    UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
-    : FramePropertyDescriptorUntyped(aDtor, aDtorWithFrame)
-  {}
-
-  template<Destructor Dtor>
-  static void Destruct(void* aPropertyValue)
-  {
-    Dtor(static_cast<T*>(aPropertyValue));
-  }
-
-  template<DestructorWithFrame Dtor>
-  static void DestructWithFrame(const nsIFrame* aFrame, void* aPropertyValue)
-  {
-    Dtor(aFrame, static_cast<T*>(aPropertyValue));
-  }
-};
-
-
-
-
-
-template<typename T>
-class SmallValueHolder;
-
-namespace detail {
-
-template<typename T>
-struct FramePropertyTypeHelper
-{
-  typedef T* Type;
-};
-template<typename T>
-struct FramePropertyTypeHelper<SmallValueHolder<T>>
-{
-  typedef T Type;
-};
-
-}
-# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-class FramePropertyTable {
-public:
-  template<typename T>
-  using Descriptor = const FramePropertyDescriptor<T>*;
-  using UntypedDescriptor = const FramePropertyDescriptorUntyped*;
-
-  template<typename T>
-  using PropertyType = typename detail::FramePropertyTypeHelper<T>::Type;
-
-  FramePropertyTable() : mLastFrame(nullptr), mLastEntry(nullptr)
-  {
-  }
-  ~FramePropertyTable()
-  {
-    DeleteAll();
-  }
-
-
-
-
-
-
-
-  template<typename T>
-  void Set(nsIFrame* aFrame, Descriptor<T> aProperty,
-           PropertyType<T> aValue)
-  {
-    void* ptr = ReinterpretHelper<T>::ToPointer(aValue);
-    SetInternal(aFrame, aProperty, ptr);
-  }
-# 197 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-  template<typename T>
-  bool Has(const nsIFrame* aFrame, Descriptor<T> aProperty)
-  {
-    bool foundResult = false;
-    mozilla::Unused << GetInternal(aFrame, aProperty, false, &foundResult);
-    return foundResult;
-  }
-
-  template<typename T>
-  bool HasSkippingBitCheck(const nsIFrame* aFrame, Descriptor<T> aProperty)
-  {
-    bool foundResult = false;
-    mozilla::Unused << GetInternal(aFrame, aProperty, true, &foundResult);
-    return foundResult;
-  }
-# 224 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-  template<typename T>
-  PropertyType<T> Get(const nsIFrame* aFrame, Descriptor<T> aProperty,
-                      bool* aFoundResult = nullptr)
-  {
-    void* ptr = GetInternal(aFrame, aProperty, false, aFoundResult);
-    return ReinterpretHelper<T>::FromPointer(ptr);
-  }
-# 243 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-  template<typename T>
-  PropertyType<T> Remove(nsIFrame* aFrame, Descriptor<T> aProperty,
-                         bool* aFoundResult = nullptr)
-  {
-    void* ptr = RemoveInternal(aFrame, aProperty, false, aFoundResult);
-    return ReinterpretHelper<T>::FromPointer(ptr);
-  }
-# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-  template<typename T>
-  void Delete(nsIFrame* aFrame, Descriptor<T> aProperty)
-  {
-    DeleteInternal(aFrame, aProperty, false);
-  }
-
-  template<typename T>
-  void DeleteSkippingBitCheck(nsIFrame* aFrame, Descriptor<T> aProperty)
-  {
-    DeleteInternal(aFrame, aProperty, true);
-  }
-
-
-
-
-  void DeleteAllFor(nsIFrame* aFrame);
-
-
-
-  void DeleteAll();
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-protected:
-  void SetInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
-                   void* aValue);
-
-  void* GetInternal(const nsIFrame* aFrame, UntypedDescriptor aProperty,
-                    bool aSkipBitCheck, bool* aFoundResult);
-
-  void* RemoveInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
-                       bool aSkipBitCheck, bool* aFoundResult);
-
-  void DeleteInternal(nsIFrame* aFrame, UntypedDescriptor aProperty,
-                      bool aSkipBitCheck);
-
-  template<typename T>
-  struct ReinterpretHelper
-  {
-    static_assert(sizeof(PropertyType<T>) <= sizeof(void*),
-                  "size of the value must never be larger than a pointer");
-
-    static void* ToPointer(PropertyType<T> aValue)
-    {
-      void* ptr = nullptr;
-      memcpy(&ptr, &aValue, sizeof(aValue));
-      return ptr;
-    }
-
-    static PropertyType<T> FromPointer(void* aPtr)
-    {
-      PropertyType<T> value;
-      memcpy(&value, &aPtr, sizeof(value));
-      return value;
-    }
-  };
-
-  template<typename T>
-  struct ReinterpretHelper<T*>
-  {
-    static void* ToPointer(T* aValue)
-    {
-      return static_cast<void*>(aValue);
-    }
-
-    static T* FromPointer(void* aPtr)
-    {
-      return static_cast<T*>(aPtr);
-    }
-  };
-
-
-
-
-
-  struct PropertyValue {
-    PropertyValue() : mProperty(nullptr), mValue(nullptr) {}
-    PropertyValue(UntypedDescriptor aProperty, void* aValue)
-      : mProperty(aProperty), mValue(aValue) {}
-
-    bool IsArray() { return !mProperty && mValue; }
-    nsTArray<PropertyValue>* ToArray()
-    {
-      do { } while(0);
-      return reinterpret_cast<nsTArray<PropertyValue>*>(&mValue);
-    }
-
-    void DestroyValueFor(const nsIFrame* aFrame) {
-      if (mProperty->mDestructor) {
-        mProperty->mDestructor(mValue);
-      } else if (mProperty->mDestructorWithFrame) {
-        mProperty->mDestructorWithFrame(aFrame, mValue);
-      }
-    }
-
-    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
-      size_t n = 0;
-
-
-
-
-
-      if (IsArray()) {
-        nsTArray<PropertyValue>* array = ToArray();
-        n += array->ShallowSizeOfExcludingThis(aMallocSizeOf);
-      }
-      return n;
-    }
-
-    UntypedDescriptor mProperty;
-    void* mValue;
-  };
-
-
-
-
-
-  class PropertyComparator {
-  public:
-    bool Equals(const PropertyValue& a, const PropertyValue& b) const {
-      return a.mProperty == b.mProperty;
-    }
-    bool Equals(UntypedDescriptor a, const PropertyValue& b) const {
-      return a == b.mProperty;
-    }
-    bool Equals(const PropertyValue& a, UntypedDescriptor b) const {
-      return a.mProperty == b;
-    }
-  };
-
-
-
-
-
-  class Entry : public nsPtrHashKey<const nsIFrame>
-  {
-  public:
-    explicit Entry(KeyTypePointer aKey) : nsPtrHashKey<const nsIFrame>(aKey) {}
-    Entry(const Entry &toCopy) :
-      nsPtrHashKey<const nsIFrame>(toCopy), mProp(toCopy.mProp) {}
-
-    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
-      return mProp.SizeOfExcludingThis(aMallocSizeOf);
-    }
-
-    PropertyValue mProp;
-  };
-
-  static void DeleteAllForEntry(Entry* aEntry);
-
-
-
-
-  nsTHashtable<Entry> mEntries;
-  const nsIFrame* mLastFrame;
-  Entry* mLastEntry;
-};
-# 430 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FramePropertyTable.h"
-template<class CVnsIFrame>
-class FramePropertiesBase {
-public:
-  template<typename T> using Descriptor = FramePropertyTable::Descriptor<T>;
-  template<typename T> using PropertyType = FramePropertyTable::PropertyType<T>;
-
-  template<typename T>
-  bool Has(Descriptor<T> aProperty) const
-  {
-    return mTable->Has(mFrame, aProperty);
-  }
-
-  template<typename T>
-  PropertyType<T> Get(Descriptor<T> aProperty,
-                      bool* aFoundResult = nullptr) const
-  {
-    return mTable->Get(mFrame, aProperty, aFoundResult);
-  }
-
-protected:
-  FramePropertiesBase(FramePropertyTable* aTable, CVnsIFrame* aFrame)
-    : mTable(aTable), mFrame(aFrame) {}
-
-  FramePropertyTable* const mTable;
-  CVnsIFrame* const mFrame;
-};
-
-class ConstFrameProperties : public FramePropertiesBase<const nsIFrame> {
-public:
-  ConstFrameProperties(FramePropertyTable* aTable, const nsIFrame* aFrame)
-    : FramePropertiesBase(aTable, aFrame)
-  {
-  }
-};
-
-class FrameProperties : public FramePropertiesBase<nsIFrame> {
-public:
-  FrameProperties(FramePropertyTable* aTable, nsIFrame* aFrame)
-    : FramePropertiesBase(aTable, aFrame)
-  {
-  }
-
-  template<typename T>
-  void Set(Descriptor<T> aProperty, PropertyType<T> aValue) const
-  {
-    mTable->Set(mFrame, aProperty, aValue);
-  }
-
-  template<typename T>
-  PropertyType<T> Remove(Descriptor<T> aProperty,
-                         bool* aFoundResult = nullptr) const
-  {
-    return mTable->Remove(mFrame, aProperty, aFoundResult);
-  }
-
-  template<typename T>
-  void Delete(Descriptor<T> aProperty) const
-  {
-    mTable->Delete(mFrame, aProperty);
-  }
-
-};
-
-}
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxRect.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/gfxRect.h"
-struct gfxQuad;
-
-struct gfxMargin : public mozilla::gfx::BaseMargin<gfxFloat, gfxMargin> {
-  typedef mozilla::gfx::BaseMargin<gfxFloat, gfxMargin> Super;
-
-
-  gfxMargin() : Super() {}
-  gfxMargin(const gfxMargin& aMargin) : Super(aMargin) {}
-  gfxMargin(gfxFloat aTop, gfxFloat aRight, gfxFloat aBottom, gfxFloat aLeft)
-    : Super(aTop, aRight, aBottom, aLeft) {}
-};
-
-struct gfxRect :
-    public mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> {
-    typedef mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> Super;
-
-    gfxRect() : Super() {}
-    gfxRect(const gfxPoint& aPos, const gfxSize& aSize) :
-        Super(aPos, aSize) {}
-    gfxRect(gfxFloat aX, gfxFloat aY, gfxFloat aWidth, gfxFloat aHeight) :
-        Super(aX, aY, aWidth, aHeight) {}
-
-
-
-
-
-
-
-    bool WithinEpsilonOfIntegerPixels(gfxFloat aEpsilon) const;
-
-    gfxPoint AtCorner(mozilla::Corner corner) const {
-        switch (corner) {
-            case mozilla::eCornerTopLeft: return TopLeft();
-            case mozilla::eCornerTopRight: return TopRight();
-            case mozilla::eCornerBottomRight: return BottomRight();
-            case mozilla::eCornerBottomLeft: return BottomLeft();
-        }
-        return gfxPoint(0.0, 0.0);
-    }
-
-    gfxPoint CCWCorner(mozilla::Side side) const {
-        switch (side) {
-            case mozilla::eSideTop: return TopLeft();
-            case mozilla::eSideRight: return TopRight();
-            case mozilla::eSideBottom: return BottomRight();
-            case mozilla::eSideLeft: return BottomLeft();
-        }
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "Incomplete switch" ")"); do { *((volatile int*) __null) = 65; ::abort(); } while (0); } while (0);
-    }
-
-    gfxPoint CWCorner(mozilla::Side side) const {
-        switch (side) {
-            case mozilla::eSideTop: return TopRight();
-            case mozilla::eSideRight: return BottomRight();
-            case mozilla::eSideBottom: return BottomLeft();
-            case mozilla::eSideLeft: return TopLeft();
-        }
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "Incomplete switch" ")"); do { *((volatile int*) __null) = 75; ::abort(); } while (0); } while (0);
-    }
-
-
-
-
-
-    void Condition();
-
-    void Scale(gfxFloat k) {
-        do { } while(0);
-        x *= k;
-        y *= k;
-        width *= k;
-        height *= k;
-    }
-
-    void Scale(gfxFloat sx, gfxFloat sy) {
-        do { } while(0);
-        do { } while(0);
-        x *= sx;
-        y *= sy;
-        width *= sx;
-        height *= sy;
-    }
-
-    void ScaleInverse(gfxFloat k) {
-        do { } while(0);
-        x /= k;
-        y /= k;
-        width /= k;
-        height /= k;
-    }
-
-
-
-
-    gfxQuad TransformToQuad(const mozilla::gfx::Matrix4x4 &aMatrix) const;
-};
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prclist.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prclist.h"
-typedef struct PRCListStr PRCList;
-
-
-
-
-struct PRCListStr {
-    PRCList *next;
-    PRCList *prev;
-};
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/MainThreadUtils.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/MainThreadUtils.h"
-class nsIThread;
-
-
-
-
-
-
-
-extern nsresult NS_GetMainThread(nsIThread** aResult);
-
-
-
-
-
-
-extern nsIThread* NS_GetCurrentThread();
-
-
-
-bool NS_IsMainThread();
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h"
-class nsICancelableRunnable : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsICancelableRunnable.h"
-  virtual nsresult Cancel() = 0;
-
-protected:
-  nsICancelableRunnable() { }
-  virtual ~nsICancelableRunnable() {}
-};
-
-template<typename T> struct nsICancelableRunnable::COMTypeInfo<nsICancelableRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsICancelableRunnable::COMTypeInfo<nsICancelableRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xde93dc4c, 0x5eea, 0x4eb7, { 0xb6, 0xd1, 0xdb, 0xf1, 0xe0, 0xce, 0xf6, 0x5c } };
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h"
-namespace mozilla {
-class TimeStamp;
-}
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIdlePeriod.h"
-class nsIIdlePeriod : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetIdlePeriodHint(mozilla::TimeStamp *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIIdlePeriod::COMTypeInfo<nsIIdlePeriod, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIIdlePeriod::COMTypeInfo<nsIIdlePeriod, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x21dd35a2, 0xeae9, 0x4bd8, { 0xb4, 0x70, 0x0d, 0xfa, 0x35, 0xa0, 0xe3, 0xb9 }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIncrementalRunnable.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIIncrementalRunnable.h"
-class nsIIncrementalRunnable : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-  virtual void SetDeadline(mozilla::TimeStamp aDeadline) = 0;
-
-protected:
-  nsIIncrementalRunnable() { }
-  virtual ~nsIIncrementalRunnable() {}
-};
-
-template<typename T> struct nsIIncrementalRunnable::COMTypeInfo<nsIIncrementalRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIIncrementalRunnable::COMTypeInfo<nsIIncrementalRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x688be92e, 0x7ade, 0x4fdc, { 0x9d, 0x83, 0x74, 0xcb, 0xef, 0xf4, 0xa5, 0x2c } };
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINamed.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsINamed.h"
-class nsINamed : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetName(nsACString & aName) = 0;
-
-
-  virtual nsresult SetName(const char * aName) = 0;
-
-};
-
-  template<typename T> struct nsINamed::COMTypeInfo<nsINamed, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsINamed::COMTypeInfo<nsINamed, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0c5fe7de, 0x7e83, 0x4d0d, { 0xa8, 0xa6, 0x4a, 0x65, 0x18, 0xb9, 0xa7, 0xb3 }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h"
-class nsIRunnable : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Run(void) = 0;
-
-};
-
-  template<typename T> struct nsIRunnable::COMTypeInfo<nsIRunnable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRunnable::COMTypeInfo<nsIRunnable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4a2abaf0, 0x6886, 0x11d3, { 0x93, 0x82, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }};
-# 103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRunnable.h"
-class nsIRunnablePriority : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    PRIORITY_NORMAL = 0U,
-    PRIORITY_HIGH = 1U
-  };
-
-
-  virtual nsresult GetPriority(uint32_t *aPriority) = 0;
-
-};
-
-  template<typename T> struct nsIRunnablePriority::COMTypeInfo<nsIRunnablePriority, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRunnablePriority::COMTypeInfo<nsIRunnablePriority, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xe75aa42a, 0x80a9, 0x11e6, { 0xaf, 0xb5, 0xe8, 0x9d, 0x87, 0x34, 0x8e, 0x2c }};
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h"
-class nsIThread;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadManager.h"
-class nsIThreadManager : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    DEFAULT_STACK_SIZE = 0U
-  };
-
-
-  virtual nsresult NewThread(uint32_t creationFlags, uint32_t stackSize, nsIThread * *_retval) = 0;
-
-
-  virtual nsresult NewNamedThread(const nsACString & name, uint32_t stackSize, nsIThread * *_retval) = 0;
-
-
-  virtual nsresult GetThreadFromPRThread(PRThread *prthread, nsIThread * *_retval) = 0;
-
-
-  virtual nsresult GetMainThread(nsIThread * *aMainThread) = 0;
-
-
-  virtual nsresult GetCurrentThread(nsIThread * *aCurrentThread) = 0;
-
-
-  virtual nsresult GetIsMainThread(bool *aIsMainThread) = 0;
-
-};
-
-  template<typename T> struct nsIThreadManager::COMTypeInfo<nsIThreadManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThreadManager::COMTypeInfo<nsIThreadManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x1be89eca, 0xe2f7, 0x453b, { 0x8d, 0x38, 0xc1, 0x1b, 0xa2, 0x47, 0xf6, 0xf3 }};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIEventTarget.h" 1
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIEventTarget.h"
-class nsIEventTarget : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-     nsresult Dispatch(nsIRunnable* aEvent, uint32_t aFlags) {
-      return Dispatch(nsCOMPtr<nsIRunnable>(aEvent).forget(), aFlags);
-    }
-  enum {
-    DISPATCH_NORMAL = 0U,
-    DISPATCH_SYNC = 1U,
-    DISPATCH_AT_END = 2U
-  };
-
-
-  virtual nsresult IsOnCurrentThread(bool *_retval) = 0;
-
-
-  virtual nsresult Dispatch(already_AddRefed<nsIRunnable> event, uint32_t flags) = 0;
-
-
-  virtual nsresult DispatchFromScript(nsIRunnable *event, uint32_t flags) = 0;
-
-
-  virtual nsresult DelayedDispatch(already_AddRefed<nsIRunnable> event, uint32_t delay) = 0;
-
-};
-
-  template<typename T> struct nsIEventTarget::COMTypeInfo<nsIEventTarget, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIEventTarget::COMTypeInfo<nsIEventTarget, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x88145945, 0x3278, 0x424e, { 0x9f, 0x37, 0xd8, 0x74, 0xcb, 0xdd, 0x9f, 0x6f }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h" 2
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThread.h"
-class nsIThread : public nsIEventTarget {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetPRThread(PRThread **aPRThread) = 0;
-
-
-  virtual nsresult GetCanInvokeJS(bool *aCanInvokeJS) = 0;
-  virtual nsresult SetCanInvokeJS(bool aCanInvokeJS) = 0;
-
-
-  virtual nsresult Shutdown(void) = 0;
-
-
-  virtual nsresult HasPendingEvents(bool *_retval) = 0;
-
-
-  virtual nsresult ProcessNextEvent(bool mayWait, bool *_retval) = 0;
-
-
-  virtual nsresult AsyncShutdown(void) = 0;
-
-
-  virtual nsresult RegisterIdlePeriod(already_AddRefed<nsIIdlePeriod> aIdlePeriod) = 0;
-
-
-  virtual nsresult IdleDispatch(already_AddRefed<nsIRunnable> event) = 0;
-
-};
-
-  template<typename T> struct nsIThread::COMTypeInfo<nsIThread, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThread::COMTypeInfo<nsIThread, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5801d193, 0x29d1, 0x4964, { 0xa6, 0xb7, 0x70, 0xeb, 0x69, 0x7d, 0xdf, 0x2b }};
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h" 1
-# 67 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 68 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h" 2
-
-namespace mozilla {
-
-
-
-
-template<size_t... Indices>
-struct IndexSequence
-{
-  static constexpr size_t Size() { return sizeof...(Indices); }
-};
-
-namespace detail {
-
-
-
-template<size_t... Indices>
-struct IndexTuple
-{
-  typedef IndexTuple<Indices..., sizeof...(Indices)> Next;
-};
-
-
-template<size_t N>
-struct BuildIndexTuple
-{
-  typedef typename BuildIndexTuple<N - 1>::Type::Next Type;
-};
-
-template<>
-struct BuildIndexTuple<0>
-{
-  typedef IndexTuple<> Type;
-};
-
-template<size_t N, typename IndexTuple>
-struct MakeIndexSequenceImpl;
-
-template<size_t N, size_t... Indices>
-struct MakeIndexSequenceImpl<N, IndexTuple<Indices...>>
-{
-  typedef IndexSequence<Indices...> Type;
-};
-
-}
-
-
-
-
-
-
-
-template<size_t N>
-struct MakeIndexSequence
-{
-  typedef typename detail::MakeIndexSequenceImpl<N,
-    typename detail::BuildIndexTuple<N>::Type>::Type Type;
-};
-# 135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/IndexSequence.h"
-template<typename... Types>
-struct IndexSequenceFor
-{
-  typedef typename MakeIndexSequence<sizeof...(Types)>::Type Type;
-};
-
-}
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-# 1 "/usr/local/bin/../lib/clang/3.9.1/include/stddef.h" 1 3
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h" 2
-
-
-namespace mozilla {
-
-namespace detail {
-
-
-
-
-
-template<typename... Ts>
-struct Group;
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<typename Source, typename Target, bool SameSize>
-struct CheckConvertibilityImpl;
-
-template<typename Source, typename Target>
-struct CheckConvertibilityImpl<Source, Target, false>
-  : FalseType {};
-
-template<typename... SourceTypes, typename... TargetTypes>
-struct CheckConvertibilityImpl<Group<SourceTypes...>, Group<TargetTypes...>, true>
-  : IntegralConstant<bool, tl::And<IsConvertible<SourceTypes, TargetTypes>::value...>::value> { };
-
-template<typename Source, typename Target>
-struct CheckConvertibility;
-
-template<typename... SourceTypes, typename... TargetTypes>
-struct CheckConvertibility<Group<SourceTypes...>, Group<TargetTypes...>>
-  : CheckConvertibilityImpl<Group<SourceTypes...>, Group<TargetTypes...>,
-        sizeof...(SourceTypes) == sizeof...(TargetTypes)> { };
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<std::size_t Index, typename... Elements>
-struct TupleImpl;
-
-
-
-
-
-template<std::size_t Index>
-struct TupleImpl<Index> {
-  bool operator==(const TupleImpl<Index>& aOther) const
-  {
-    return true;
-  }
-};
-
-
-
-
-
-
-template<std::size_t Index, typename HeadT, typename... TailT>
-struct TupleImpl<Index, HeadT, TailT...>
-  : public TupleImpl<Index + 1, TailT...>
-{
-  typedef TupleImpl<Index + 1, TailT...> Base;
-
-
-
-
-
-
-  static HeadT& Head(TupleImpl& aTuple) { return aTuple.mHead; }
-  static const HeadT& Head(const TupleImpl& aTuple) { return aTuple.mHead; }
-  static Base& Tail(TupleImpl& aTuple) { return aTuple; }
-  static const Base& Tail(const TupleImpl& aTuple) { return aTuple; }
-
-  TupleImpl() : Base(), mHead() { }
-
-
-  explicit TupleImpl(const HeadT& aHead, const TailT&... aTail)
-    : Base(aTail...), mHead(aHead) { }
-
-
-
-
-
-  template <typename OtherHeadT, typename... OtherTailT,
-            typename = typename EnableIf<
-                CheckConvertibility<
-                    Group<OtherHeadT, OtherTailT...>,
-                    Group<HeadT, TailT...>>::value>::Type>
-  explicit TupleImpl(OtherHeadT&& aHead, OtherTailT&&... aTail)
-    : Base(Forward<OtherTailT>(aTail)...), mHead(Forward<OtherHeadT>(aHead)) { }
-
-
-
-
-  TupleImpl(const TupleImpl& aOther)
-    : Base(Tail(aOther))
-    , mHead(Head(aOther)) {}
-  TupleImpl(TupleImpl&& aOther)
-    : Base(Move(Tail(aOther)))
-    , mHead(Forward<HeadT>(Head(aOther))) {}
-
-
-
-  template <typename... OtherElements,
-            typename = typename EnableIf<
-                sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
-  TupleImpl& operator=(const TupleImpl<Index, OtherElements...>& aOther)
-  {
-    typedef TupleImpl<Index, OtherElements...> OtherT;
-    Head(*this) = OtherT::Head(aOther);
-    Tail(*this) = OtherT::Tail(aOther);
-    return *this;
-  }
-  template <typename... OtherElements,
-            typename = typename EnableIf<
-                sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
-  TupleImpl& operator=(TupleImpl<Index, OtherElements...>&& aOther)
-  {
-    typedef TupleImpl<Index, OtherElements...> OtherT;
-    Head(*this) = Move(OtherT::Head(aOther));
-    Tail(*this) = Move(OtherT::Tail(aOther));
-    return *this;
-  }
-
-
-  TupleImpl& operator=(const TupleImpl& aOther)
-  {
-    Head(*this) = Head(aOther);
-    Tail(*this) = Tail(aOther);
-    return *this;
-  }
-  TupleImpl& operator=(TupleImpl&& aOther)
-  {
-    Head(*this) = Move(Head(aOther));
-    Tail(*this) = Move(Tail(aOther));
-    return *this;
-  }
-  bool operator==(const TupleImpl& aOther) const
-  {
-    return Head(*this) == Head(aOther) && Tail(*this) == Tail(aOther);
-  }
-private:
-  HeadT mHead;
-};
-
-}
-# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<typename... Elements>
-class Tuple : public detail::TupleImpl<0, Elements...>
-{
-  typedef detail::TupleImpl<0, Elements...> Impl;
-public:
-
-
-
-  Tuple() : Impl() { }
-  explicit Tuple(const Elements&... aElements) : Impl(aElements...) { }
-
-
-
-
-  template <typename OtherHead, typename... OtherTail,
-            typename = typename EnableIf<
-                detail::CheckConvertibility<
-                    detail::Group<OtherHead, OtherTail...>,
-                    detail::Group<Elements...>>::value>::Type>
-  explicit Tuple(OtherHead&& aHead, OtherTail&&... aTail)
-    : Impl(Forward<OtherHead>(aHead), Forward<OtherTail>(aTail)...) { }
-  Tuple(const Tuple& aOther) : Impl(aOther) { }
-  Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
-
-  template <typename... OtherElements,
-            typename = typename EnableIf<
-                sizeof...(OtherElements) == sizeof...(Elements)>::Type>
-  Tuple& operator=(const Tuple<OtherElements...>& aOther)
-  {
-    static_cast<Impl&>(*this) = aOther;
-    return *this;
-  }
-  template <typename... OtherElements,
-            typename = typename EnableIf<
-                sizeof...(OtherElements) == sizeof...(Elements)>::Type>
-  Tuple& operator=(Tuple<OtherElements...>&& aOther)
-  {
-    static_cast<Impl&>(*this) = Move(aOther);
-    return *this;
-  }
-  Tuple& operator=(const Tuple& aOther)
-  {
-    static_cast<Impl&>(*this) = aOther;
-    return *this;
-  }
-  Tuple& operator=(Tuple&& aOther)
-  {
-    static_cast<Impl&>(*this) = Move(aOther);
-    return *this;
-  }
-  bool operator==(const Tuple& aOther) const
-  {
-    return static_cast<const Impl&>(*this) == static_cast<const Impl&>(aOther);
-  }
-};
-
-
-
-
-
-template <typename A, typename B>
-class Tuple<A, B> : public detail::TupleImpl<0, A, B>
-{
-  typedef detail::TupleImpl<0, A, B> Impl;
-
-public:
-
-
-
-  Tuple() : Impl() { }
-  explicit Tuple(const A& aA, const B& aB) : Impl(aA, aB) { }
-  template <typename AArg, typename BArg,
-            typename = typename EnableIf<
-                detail::CheckConvertibility<
-                    detail::Group<AArg, BArg>,
-                    detail::Group<A, B>>::value>::Type>
-  explicit Tuple(AArg&& aA, BArg&& aB)
-    : Impl(Forward<AArg>(aA), Forward<BArg>(aB)) { }
-  Tuple(const Tuple& aOther) : Impl(aOther) { }
-  Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
-  explicit Tuple(const Pair<A, B>& aOther)
-    : Impl(aOther.first(), aOther.second()) { }
-  explicit Tuple(Pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first()),
-                                    Forward<B>(aOther.second())) { }
-  explicit Tuple(const std::pair<A, B>& aOther)
-    : Impl(aOther.first, aOther.second) { }
-  explicit Tuple(std::pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first),
-                                    Forward<B>(aOther.second)) { }
-
-  template <typename AArg, typename BArg>
-  Tuple& operator=(const Tuple<AArg, BArg>& aOther)
-  {
-    static_cast<Impl&>(*this) = aOther;
-    return *this;
-  }
-  template <typename AArg, typename BArg>
-  Tuple& operator=(Tuple<AArg, BArg>&& aOther)
-  {
-    static_cast<Impl&>(*this) = Move(aOther);
-    return *this;
-  }
-  Tuple& operator=(const Tuple& aOther)
-  {
-    static_cast<Impl&>(*this) = aOther;
-    return *this;
-  }
-  Tuple& operator=(Tuple&& aOther)
-  {
-    static_cast<Impl&>(*this) = Move(aOther);
-    return *this;
-  }
-  template <typename AArg, typename BArg>
-  Tuple& operator=(const Pair<AArg, BArg>& aOther)
-  {
-    Impl::Head(*this) = aOther.first();
-    Impl::Tail(*this).Head(*this) = aOther.second();
-    return *this;
-  }
-  template <typename AArg, typename BArg>
-  Tuple& operator=(Pair<AArg, BArg>&& aOther)
-  {
-    Impl::Head(*this) = Forward<AArg>(aOther.first());
-    Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second());
-    return *this;
-  }
-  template <typename AArg, typename BArg>
-  Tuple& operator=(const std::pair<AArg, BArg>& aOther)
-  {
-    Impl::Head(*this) = aOther.first;
-    Impl::Tail(*this).Head(*this) = aOther.second;
-    return *this;
-  }
-  template <typename AArg, typename BArg>
-  Tuple& operator=(std::pair<AArg, BArg>&& aOther)
-  {
-    Impl::Head(*this) = Forward<AArg>(aOther.first);
-    Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second);
-    return *this;
-  }
-};
-
-
-
-
-
-
-
-template <>
-class Tuple<> {};
-
-namespace detail {
-# 369 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<std::size_t Index, typename... Elements>
-auto TupleGetHelper(TupleImpl<Index, Elements...>& aTuple)
-    -> decltype(TupleImpl<Index, Elements...>::Head(aTuple))
-{
-  return TupleImpl<Index, Elements...>::Head(aTuple);
-}
-
-
-template<std::size_t Index, typename... Elements>
-auto TupleGetHelper(const TupleImpl<Index, Elements...>& aTuple)
-    -> decltype(TupleImpl<Index, Elements...>::Head(aTuple))
-{
-  return TupleImpl<Index, Elements...>::Head(aTuple);
-}
-
-}
-# 398 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<std::size_t Index, typename... Elements>
-auto Get(Tuple<Elements...>& aTuple)
-    -> decltype(detail::TupleGetHelper<Index>(aTuple))
-{
-  return detail::TupleGetHelper<Index>(aTuple);
-}
-
-
-template<std::size_t Index, typename... Elements>
-auto Get(const Tuple<Elements...>& aTuple)
-    -> decltype(detail::TupleGetHelper<Index>(aTuple))
-{
-  return detail::TupleGetHelper<Index>(aTuple);
-}
-
-
-template<std::size_t Index, typename... Elements>
-auto Get(Tuple<Elements...>&& aTuple)
-    -> decltype(Move(mozilla::Get<Index>(aTuple)))
-{
-
-
-  return Move(mozilla::Get<Index>(aTuple));
-}
-# 432 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<typename... Elements>
-inline Tuple<typename Decay<Elements>::Type...>
-MakeTuple(Elements&&... aElements)
-{
-  return Tuple<typename Decay<Elements>::Type...>(Forward<Elements>(aElements)...);
-}
-# 452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Tuple.h"
-template<typename... Elements>
-inline Tuple<Elements&...>
-Tie(Elements&... aVariables)
-{
-  return Tuple<Elements&...>(aVariables...);
-}
-
-}
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h" 2
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern nsresult
-NS_NewThread(nsIThread** aResult,
-             nsIRunnable* aInitialEvent = nullptr,
-             uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE);
-
-
-
-
-extern nsresult
-NS_NewNamedThread(const nsACString& aName,
-                  nsIThread** aResult,
-                  nsIRunnable* aInitialEvent = nullptr,
-                  uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE);
-
-template<size_t LEN>
-inline nsresult
-NS_NewNamedThread(const char (&aName)[LEN],
-                  nsIThread** aResult,
-                  nsIRunnable* aInitialEvent = nullptr,
-                  uint32_t aStackSize = nsIThreadManager::DEFAULT_STACK_SIZE)
-{
-  static_assert(LEN <= 16,
-                "Thread name must be no more than 16 characters");
-  return NS_NewNamedThread(nsDependentCString(aName, LEN - 1),
-                           aResult, aInitialEvent, aStackSize);
-}
-
-
-
-
-
-
-
-extern nsresult NS_GetCurrentThread(nsIThread** aResult);
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern nsresult NS_DispatchToCurrentThread(nsIRunnable* aEvent);
-extern nsresult
-NS_DispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent);
-# 107 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern nsresult
-NS_DispatchToMainThread(nsIRunnable* aEvent,
-                        uint32_t aDispatchFlags = nsIEventTarget::DISPATCH_NORMAL);
-extern nsresult
-NS_DispatchToMainThread(already_AddRefed<nsIRunnable>&& aEvent,
-                        uint32_t aDispatchFlags = nsIEventTarget::DISPATCH_NORMAL);
-
-extern nsresult
-NS_DelayedDispatchToCurrentThread(
-  already_AddRefed<nsIRunnable>&& aEvent, uint32_t aDelayMs);
-
-extern nsresult
-NS_IdleDispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent);
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern nsresult
-NS_ProcessPendingEvents(nsIThread* aThread,
-                        PRIntervalTime aTimeout = 0xffffffffUL);
-# 156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern bool NS_HasPendingEvents(nsIThread* aThread = nullptr);
-# 175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern bool NS_ProcessNextEvent(nsIThread* aThread = nullptr,
-                                bool aMayWait = true);
-# 185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern bool NS_IsInCompositorThread();
-
-
-
-
-inline already_AddRefed<nsIThread>
-do_GetCurrentThread()
-{
-  nsIThread* thread = nullptr;
-  NS_GetCurrentThread(&thread);
-  return already_AddRefed<nsIThread>(thread);
-}
-
-inline already_AddRefed<nsIThread>
-do_GetMainThread()
-{
-  nsIThread* thread = nullptr;
-  NS_GetMainThread(&thread);
-  return already_AddRefed<nsIThread>(thread);
-}
-# 213 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-extern nsIThread* NS_GetCurrentThread();
-
-
-
-
-
-
-namespace mozilla {
-
-
-class IdlePeriod : public nsIIdlePeriod
-{
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-  virtual nsresult GetIdlePeriodHint(mozilla::TimeStamp *_retval) override;
-
-  IdlePeriod() {}
-
-protected:
-  virtual ~IdlePeriod() {}
-private:
-  IdlePeriod(const IdlePeriod&) = delete;
-  IdlePeriod& operator=(const IdlePeriod&) = delete;
-  IdlePeriod& operator=(const IdlePeriod&&) = delete;
-};
-
-
-class Runnable : public nsIRunnable, public nsINamed
-{
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-  virtual nsresult Run(void) override;
-  virtual nsresult GetName(nsACString & aName) override; virtual nsresult SetName(const char * aName) override;
-
-  Runnable() {}
-
-
-
-
-  explicit Runnable(const char* aName) : mName(aName) {}
-
-
-protected:
-  virtual ~Runnable() {}
-private:
-  Runnable(const Runnable&) = delete;
-  Runnable& operator=(const Runnable&) = delete;
-  Runnable& operator=(const Runnable&&) = delete;
-
-
-  const char* mName = nullptr;
-
-};
-
-
-class CancelableRunnable : public Runnable,
-                           public nsICancelableRunnable
-{
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
-
-  virtual nsresult Cancel() override;
-
-  CancelableRunnable() {}
-  explicit CancelableRunnable(const char* aName) : Runnable(aName) {}
-
-protected:
-  virtual ~CancelableRunnable() {}
-private:
-  CancelableRunnable(const CancelableRunnable&) = delete;
-  CancelableRunnable& operator=(const CancelableRunnable&) = delete;
-  CancelableRunnable& operator=(const CancelableRunnable&&) = delete;
-};
-
-
-class IncrementalRunnable : public CancelableRunnable,
-                            public nsIIncrementalRunnable
-{
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
-
-  virtual void SetDeadline(TimeStamp aDeadline) override;
-
-  IncrementalRunnable() {}
-
-protected:
-  virtual ~IncrementalRunnable() {}
-private:
-  IncrementalRunnable(const IncrementalRunnable&) = delete;
-  IncrementalRunnable& operator=(const IncrementalRunnable&) = delete;
-  IncrementalRunnable& operator=(const IncrementalRunnable&&) = delete;
-};
-
-namespace detail {
-
-
-
-
-template<typename StoredFunction>
-class RunnableFunction : public Runnable
-{
-public:
-  template <typename F>
-  explicit RunnableFunction(F&& aFunction)
-    : mFunction(Forward<F>(aFunction))
-  { }
-
-  virtual nsresult Run() override {
-    static_assert(IsVoid<decltype(mFunction())>::value,
-                  "The lambda must return void!");
-    mFunction();
-    return NS_OK;
-  }
-private:
-  StoredFunction mFunction;
-};
-
-
-template<typename Function>
-using RunnableFunctionImpl =
-
-  typename detail::RunnableFunction<typename RemoveReference<Function>::Type>;
-
-template <typename T>
-inline already_AddRefed<T>
-SetRunnableName(already_AddRefed<T>&& aObj, const char* aName)
-{
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(aName)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(aName))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "aName" ")"); do { *((volatile int*) __null) = 340; ::abort(); } while (0); } } while (0);
-  RefPtr<T> ref(aObj);
-  ref->SetName(aName);
-  return ref.forget();
-}
-
-}
-
-namespace detail {
-
-template<typename CVRemoved>
-struct IsRefcountedSmartPointerHelper : FalseType {};
-
-template<typename Pointee>
-struct IsRefcountedSmartPointerHelper<RefPtr<Pointee>> : TrueType {};
-
-template<typename Pointee>
-struct IsRefcountedSmartPointerHelper<nsCOMPtr<Pointee>> : TrueType {};
-
-}
-
-template<typename T>
-struct IsRefcountedSmartPointer
-  : detail::IsRefcountedSmartPointerHelper<typename RemoveCV<T>::Type>
-{};
-
-namespace detail {
-
-template<typename T, typename CVRemoved>
-struct RemoveSmartPointerHelper
-{
-  typedef T Type;
-};
-
-template<typename T, typename Pointee>
-struct RemoveSmartPointerHelper<T, RefPtr<Pointee>>
-{
-  typedef Pointee Type;
-};
-
-template<typename T, typename Pointee>
-struct RemoveSmartPointerHelper<T, nsCOMPtr<Pointee>>
-{
-  typedef Pointee Type;
-};
-
-}
-
-template<typename T>
-struct RemoveSmartPointer
-  : detail::RemoveSmartPointerHelper<T, typename RemoveCV<T>::Type>
-{};
-
-namespace detail {
-
-template<typename T, typename CVRemoved>
-struct RemoveRawOrSmartPointerHelper
-{
-  typedef T Type;
-};
-
-template<typename T, typename Pointee>
-struct RemoveRawOrSmartPointerHelper<T, Pointee*>
-{
-  typedef Pointee Type;
-};
-
-template<typename T, typename Pointee>
-struct RemoveRawOrSmartPointerHelper<T, RefPtr<Pointee>>
-{
-  typedef Pointee Type;
-};
-
-template<typename T, typename Pointee>
-struct RemoveRawOrSmartPointerHelper<T, nsCOMPtr<Pointee>>
-{
-  typedef Pointee Type;
-};
-
-}
-
-template<typename T>
-struct RemoveRawOrSmartPointer
-  : detail::RemoveRawOrSmartPointerHelper<T, typename RemoveCV<T>::Type>
-{};
-
-}
-
-inline nsISupports*
-ToSupports(mozilla::Runnable *p)
-{
-  return static_cast<nsIRunnable*>(p);
-}
-
-template<typename Function>
-already_AddRefed<mozilla::Runnable>
-NS_NewRunnableFunction(Function&& aFunction)
-{
-
-
-  return do_AddRef(new mozilla::detail::RunnableFunctionImpl<Function>
-    (mozilla::Forward<Function>(aFunction)));
-}
-
-template<typename Function>
-already_AddRefed<mozilla::Runnable>
-NS_NewRunnableFunction(const char* aName, Function&& aFunction)
-{
-  return mozilla::detail::SetRunnableName(
-    NS_NewRunnableFunction(mozilla::Forward<Function>(aFunction)), aName);
-}
-
-
-
-
-template<class ClassType,
-         typename ReturnType = void,
-         bool Owning = true,
-         bool Cancelable = false>
-class nsRunnableMethod : public mozilla::Conditional<!Cancelable,
-                                                     mozilla::Runnable,
-                                                     mozilla::CancelableRunnable>::Type
-{
-public:
-  virtual void Revoke() = 0;
-
-
-
-
-  template<typename OtherReturnType>
-  class ReturnTypeEnforcer
-  {
-  public:
-    typedef int ReturnTypeIsSafe;
-  };
-
-  template<class T>
-  class ReturnTypeEnforcer<already_AddRefed<T>>
-  {
-
-  };
-
-
-  typedef typename ReturnTypeEnforcer<ReturnType>::ReturnTypeIsSafe check;
-};
-
-template<class ClassType, bool Owning>
-struct nsRunnableMethodReceiver
-{
-  RefPtr<ClassType> mObj;
-  explicit nsRunnableMethodReceiver(ClassType* aObj) : mObj(aObj) {}
-  ~nsRunnableMethodReceiver() { Revoke(); }
-  ClassType* Get() const { return mObj.get(); }
-  void Revoke() { mObj = nullptr; }
-};
-
-template<class ClassType>
-struct nsRunnableMethodReceiver<ClassType, false>
-{
-  ClassType* mObj;
-  explicit nsRunnableMethodReceiver(ClassType* aObj) : mObj(aObj) {}
-  ClassType* Get() const { return mObj; }
-  void Revoke() { mObj = nullptr; }
-};
-
-template<typename PtrType, typename Method, bool Owning, bool Cancelable>
-struct nsRunnableMethodTraits;
-
-template<typename PtrType, class C, typename R, bool Owning, bool Cancelable, typename... As>
-struct nsRunnableMethodTraits<PtrType, R(C::*)(As...), Owning, Cancelable>
-{
-  typedef typename mozilla::RemoveRawOrSmartPointer<PtrType>::Type class_type;
-  static_assert(mozilla::IsBaseOf<C, class_type>::value,
-                "Stored class must inherit from method's class");
-  typedef R return_type;
-  typedef nsRunnableMethod<C, R, Owning, Cancelable> base_type;
-  static const bool can_cancel = Cancelable;
-};
-
-template<typename PtrType, class C, typename R, bool Owning, bool Cancelable, typename... As>
-struct nsRunnableMethodTraits<PtrType, R(C::*)(As...) const, Owning, Cancelable>
-{
-  typedef const typename mozilla::RemoveRawOrSmartPointer<PtrType>::Type class_type;
-  static_assert(mozilla::IsBaseOf<C, class_type>::value,
-                "Stored class must inherit from method's class");
-  typedef R return_type;
-  typedef nsRunnableMethod<C, R, Owning, Cancelable> base_type;
-  static const bool can_cancel = Cancelable;
-};
-# 582 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-template<typename T>
-struct IsParameterStorageClass : public mozilla::FalseType {};
-
-
-
-
-template<typename T>
-struct StoreCopyPassByValue
-{
-  typedef T stored_type;
-  typedef T passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByValue(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByValue<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreCopyPassByConstLRef
-{
-  typedef T stored_type;
-  typedef const T& passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByConstLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByConstLRef<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreCopyPassByLRef
-{
-  typedef T stored_type;
-  typedef T& passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByLRef<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreCopyPassByRRef
-{
-  typedef T stored_type;
-  typedef T&& passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByRRef(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return mozilla::Move(m); }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByRRef<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreRefPassByLRef
-{
-  typedef T& stored_type;
-  typedef T& passed_type;
-  stored_type m;
-  template <typename A>
-               StoreRefPassByLRef(A& a) : m(a) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreRefPassByLRef<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreConstRefPassByConstLRef
-{
-  typedef const T& stored_type;
-  typedef const T& passed_type;
-  stored_type m;
-  template <typename A>
-               StoreConstRefPassByConstLRef(const A& a) : m(a) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreConstRefPassByConstLRef<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreRefPtrPassByPtr
-{
-  typedef RefPtr<T> stored_type;
-  typedef T* passed_type;
-  stored_type m;
-  template <typename A>
-               StoreRefPtrPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return m.get(); }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreRefPtrPassByPtr<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StorePtrPassByPtr
-{
-  typedef T* stored_type;
-  typedef T* passed_type;
-  stored_type m;
-  template <typename A>
-               StorePtrPassByPtr(A a) : m(a) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StorePtrPassByPtr<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreConstPtrPassByConstPtr
-{
-  typedef const T* stored_type;
-  typedef const T* passed_type;
-  stored_type m;
-  template <typename A>
-               StoreConstPtrPassByConstPtr(A a) : m(a) {}
-  passed_type PassAsParameter() { return m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreConstPtrPassByConstPtr<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreCopyPassByConstPtr
-{
-  typedef T stored_type;
-  typedef const T* passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByConstPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return &m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByConstPtr<S>>
-  : public mozilla::TrueType {};
-
-template<typename T>
-struct StoreCopyPassByPtr
-{
-  typedef T stored_type;
-  typedef T* passed_type;
-  stored_type m;
-  template <typename A>
-               StoreCopyPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
-  passed_type PassAsParameter() { return &m; }
-};
-template<typename S>
-struct IsParameterStorageClass<StoreCopyPassByPtr<S>>
-  : public mozilla::TrueType {};
-
-namespace detail {
-
-template<typename>
-struct SFINAE1True : mozilla::TrueType
-{};
-
-template<class T>
-static auto HasRefCountMethodsTest(int)
-    -> SFINAE1True<decltype(mozilla::DeclVal<T>().AddRef(),
-                            mozilla::DeclVal<T>().Release())>;
-template<class>
-static auto HasRefCountMethodsTest(long) -> mozilla::FalseType;
-
-template<class T>
-struct HasRefCountMethods : decltype(HasRefCountMethodsTest<T>(0))
-{};
-
-template<typename TWithoutPointer>
-struct NonnsISupportsPointerStorageClass
-  : mozilla::Conditional<mozilla::IsConst<TWithoutPointer>::value,
-                         StoreConstPtrPassByConstPtr<
-                           typename mozilla::RemoveConst<TWithoutPointer>::Type>,
-                         StorePtrPassByPtr<TWithoutPointer>>
-{};
-
-template<typename TWithoutPointer>
-struct PointerStorageClass
-  : mozilla::Conditional<HasRefCountMethods<TWithoutPointer>::value,
-                         StoreRefPtrPassByPtr<TWithoutPointer>,
-                         typename NonnsISupportsPointerStorageClass<
-                           TWithoutPointer
-                         >::Type>
-{};
-
-template<typename TWithoutRef>
-struct LValueReferenceStorageClass
-  : mozilla::Conditional<mozilla::IsConst<TWithoutRef>::value,
-                         StoreConstRefPassByConstLRef<
-                           typename mozilla::RemoveConst<TWithoutRef>::Type>,
-                         StoreRefPassByLRef<TWithoutRef>>
-{};
-
-template<typename T>
-struct SmartPointerStorageClass
-  : mozilla::Conditional<mozilla::IsRefcountedSmartPointer<T>::value,
-                         StoreRefPtrPassByPtr<
-                           typename mozilla::RemoveSmartPointer<T>::Type>,
-                         StoreCopyPassByConstLRef<T>>
-{};
-
-template<typename T>
-struct NonLValueReferenceStorageClass
-  : mozilla::Conditional<mozilla::IsRvalueReference<T>::value,
-                         StoreCopyPassByRRef<
-                           typename mozilla::RemoveReference<T>::Type>,
-                         typename SmartPointerStorageClass<T>::Type>
-{};
-
-template<typename T>
-struct NonPointerStorageClass
-  : mozilla::Conditional<mozilla::IsLvalueReference<T>::value,
-                         typename LValueReferenceStorageClass<
-                           typename mozilla::RemoveReference<T>::Type
-                         >::Type,
-                         typename NonLValueReferenceStorageClass<T>::Type>
-{};
-
-template<typename T>
-struct NonParameterStorageClass
-  : mozilla::Conditional<mozilla::IsPointer<T>::value,
-                         typename PointerStorageClass<
-                           typename mozilla::RemovePointer<T>::Type
-                         >::Type,
-                         typename NonPointerStorageClass<T>::Type>
-{};
-# 837 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-template<typename T>
-struct ParameterStorage
-  : mozilla::Conditional<IsParameterStorageClass<T>::value,
-                         T,
-                         typename NonParameterStorageClass<T>::Type>
-{};
-
-}
-
-namespace mozilla {
-
-namespace detail {
-
-
-template <typename... Ts>
-struct RunnableMethodArguments final
-{
-  Tuple<typename ::detail::ParameterStorage<Ts>::Type...> mArguments;
-  template <typename... As>
-  explicit RunnableMethodArguments(As&&... aArguments)
-    : mArguments(Forward<As>(aArguments)...)
-  {}
-  template<typename C, typename M, typename... Args, size_t... Indices>
-  static auto
-  applyImpl(C* o, M m, Tuple<Args...>& args, IndexSequence<Indices...>)
-      -> decltype(((*o).*m)(Get<Indices>(args).PassAsParameter()...))
-  {
-    return ((*o).*m)(Get<Indices>(args).PassAsParameter()...);
-  }
-  template<class C, typename M> auto apply(C* o, M m)
-      -> decltype(applyImpl(o, m, mArguments,
-                  typename IndexSequenceFor<Ts...>::Type()))
-  {
-    return applyImpl(o, m, mArguments,
-        typename IndexSequenceFor<Ts...>::Type());
-  }
-};
-
-template<typename PtrType, typename Method, bool Owning, bool Cancelable, typename... Storages>
-class RunnableMethodImpl final
-  : public ::nsRunnableMethodTraits<PtrType, Method, Owning, Cancelable>::base_type
-{
-  typedef typename ::nsRunnableMethodTraits<PtrType, Method, Owning, Cancelable>::class_type
-      ClassType;
-  ::nsRunnableMethodReceiver<ClassType, Owning> mReceiver;
-  Method mMethod;
-  RunnableMethodArguments<Storages...> mArgs;
-private:
-  virtual ~RunnableMethodImpl() { Revoke(); };
-public:
-  template<typename ForwardedPtrType, typename... Args>
-  explicit RunnableMethodImpl(ForwardedPtrType&& aObj, Method aMethod,
-                              Args&&... aArgs)
-    : mReceiver(Forward<ForwardedPtrType>(aObj))
-    , mMethod(aMethod)
-    , mArgs(Forward<Args>(aArgs)...)
-  {
-    static_assert(sizeof...(Storages) == sizeof...(Args), "Storages and Args should have equal sizes");
-  }
-  virtual nsresult Run()
-  {
-    if ((__builtin_expect(!!(mReceiver.Get()), 1))) {
-      mArgs.apply(mReceiver.Get(), mMethod);
-    }
-    return NS_OK;
-  }
-  nsresult Cancel() {
-    static_assert(Cancelable, "Don't use me!");
-    Revoke();
-    return NS_OK;
-  }
-  void Revoke() { mReceiver.Revoke(); }
-};
-
-
-template<typename PtrType, typename Method>
-using OwningRunnableMethod = typename ::nsRunnableMethodTraits<
-  typename RemoveReference<PtrType>::Type, Method, true, false>::base_type;
-template<typename PtrType, typename Method, typename... Storages>
-using OwningRunnableMethodImpl = RunnableMethodImpl<
-  typename RemoveReference<PtrType>::Type, Method, true, false, Storages...>;
-
-
-template<typename PtrType, typename Method>
-using CancelableRunnableMethod = typename ::nsRunnableMethodTraits<
-  typename RemoveReference<PtrType>::Type, Method, true, true>::base_type;
-template<typename PtrType, typename Method, typename... Storages>
-using CancelableRunnableMethodImpl = RunnableMethodImpl<
-  typename RemoveReference<PtrType>::Type, Method, true, true, Storages...>;
-
-
-template<typename PtrType, typename Method>
-using NonOwningRunnableMethod = typename ::nsRunnableMethodTraits<
-  typename RemoveReference<PtrType>::Type, Method, false, false>::base_type;
-template<typename PtrType, typename Method, typename... Storages>
-using NonOwningRunnableMethodImpl = RunnableMethodImpl<
-  typename RemoveReference<PtrType>::Type, Method, false, false, Storages...>;
-
-
-template<typename PtrType, typename Method>
-using NonOwningCancelableRunnableMethod = typename ::nsRunnableMethodTraits<
-  typename RemoveReference<PtrType>::Type, Method, false, true>::base_type;
-template<typename PtrType, typename Method, typename... Storages>
-using NonOwningCancelableRunnableMethodImpl = RunnableMethodImpl<
-  typename RemoveReference<PtrType>::Type, Method, false, true, Storages...>;
-
-}
-# 1031 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-template<typename PtrType, typename Method>
-already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
-NewRunnableMethod(PtrType&& aPtr, Method aMethod)
-{
-  return do_AddRef(
-    new detail::OwningRunnableMethodImpl<PtrType, Method>
-      (Forward<PtrType>(aPtr), aMethod));
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
-NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
-{
-  return detail::SetRunnableName(
-    NewRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
-NewCancelableRunnableMethod(PtrType&& aPtr, Method aMethod)
-{
-  return do_AddRef(
-    new detail::CancelableRunnableMethodImpl<PtrType, Method>
-      (Forward<PtrType>(aPtr), aMethod));
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
-NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
-{
-  return detail::SetRunnableName(
-    NewCancelableRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
-NewNonOwningRunnableMethod(PtrType&& aPtr, Method aMethod)
-{
-  return do_AddRef(
-    new detail::NonOwningRunnableMethodImpl<PtrType, Method>
-      (Forward<PtrType>(aPtr), aMethod));
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
-NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
-{
-  return detail::SetRunnableName(
-    NewNonOwningRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
-NewNonOwningCancelableRunnableMethod(PtrType&& aPtr, Method aMethod)
-{
-  return do_AddRef(
-    new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method>
-      (Forward<PtrType>(aPtr), aMethod));
-}
-
-template<typename PtrType, typename Method>
-already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
-NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
-                                     Method aMethod)
-{
-  return detail::SetRunnableName(
-    NewNonOwningCancelableRunnableMethod(Forward<PtrType>(aPtr), aMethod), aName);
-}
-
-
-
-
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
-NewRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return do_AddRef(
-    new detail::OwningRunnableMethodImpl<PtrType, Method, Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
-NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod, Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return detail::SetRunnableName(
-    NewRunnableMethod<Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
-NewNonOwningRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return do_AddRef(
-      new detail::NonOwningRunnableMethodImpl<PtrType, Method, Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
-NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
-                           Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return detail::SetRunnableName(
-    NewNonOwningRunnableMethod<Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
-NewCancelableRunnableMethod(PtrType&& aPtr, Method aMethod, Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return do_AddRef(
-    new detail::CancelableRunnableMethodImpl<PtrType, Method, Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
-NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
-                            Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return detail::SetRunnableName(
-    NewCancelableRunnableMethod<Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
-NewNonOwningCancelableRunnableMethod(PtrType&& aPtr, Method aMethod,
-                                     Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return do_AddRef(
-    new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method, Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
-}
-
-template<typename... Storages, typename PtrType, typename Method, typename... Args>
-already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
-NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
-                                     Method aMethod, Args&&... aArgs)
-{
-  static_assert(sizeof...(Storages) == sizeof...(Args),
-                "<Storages...> size should be equal to number of arguments");
-  return detail::SetRunnableName(
-    NewNonOwningCancelableRunnableMethod<Storages...>
-      (Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...), aName);
-}
-
-}
-# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThreadUtils.h"
-template<class T>
-class nsRevocableEventPtr
-{
-public:
-  nsRevocableEventPtr() : mEvent(nullptr) {}
-  ~nsRevocableEventPtr() { Revoke(); }
-
-  const nsRevocableEventPtr& operator=(T* aEvent)
-  {
-    if (mEvent != aEvent) {
-      Revoke();
-      mEvent = aEvent;
-    }
-    return *this;
-  }
-
-  const nsRevocableEventPtr& operator=(already_AddRefed<T> aEvent)
-  {
-    RefPtr<T> event = aEvent;
-    if (mEvent != event) {
-      Revoke();
-      mEvent = event.forget();
-    }
-    return *this;
-  }
-
-  void Revoke()
-  {
-    if (mEvent) {
-      mEvent->Revoke();
-      mEvent = nullptr;
-    }
-  }
-
-  void Forget() { mEvent = nullptr; }
-  bool IsPending() { return mEvent != nullptr; }
-  T* get() { return mEvent; }
-
-private:
-
-  nsRevocableEventPtr(const nsRevocableEventPtr&);
-  nsRevocableEventPtr& operator=(const nsRevocableEventPtr&);
-
-  RefPtr<T> mEvent;
-};
-
-
-
-
-
-class nsThreadPoolNaming
-{
-public:
-  nsThreadPoolNaming() : mCounter(0) {}
-
-
-
-
-  nsCString GetNextThreadName(const nsACString& aPoolName);
-
-  template<size_t LEN>
-  nsCString GetNextThreadName(const char (&aPoolName)[LEN])
-  {
-    return GetNextThreadName(nsDependentCString(aPoolName, LEN - 1));
-  }
-
-private:
-  mozilla::Atomic<uint32_t> mCounter;
-
-  nsThreadPoolNaming(const nsThreadPoolNaming&) = delete;
-  void operator=(const nsThreadPoolNaming&) = delete;
-};
-
-
-
-
-
-
-
-class nsAutoLowPriorityIO
-{
-public:
-  nsAutoLowPriorityIO();
-  ~nsAutoLowPriorityIO();
-
-private:
-  bool lowIOPrioritySet;
-
-
-
-};
-
-void
-NS_SetMainThread();
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h" 2
-
-
-
-namespace mozilla {
-
-
-enum class StyleBasicShapeType : uint8_t {
-  Polygon,
-  Circle,
-  Ellipse,
-  Inset,
-};
-
-
-enum class StyleBoxAlign : uint8_t {
-  Stretch,
-  Start,
-  Center,
-  Baseline,
-  End,
-};
-
-
-enum class StyleBoxDecorationBreak : uint8_t {
-  Slice,
-  Clone,
-};
-
-
-enum class StyleBoxDirection : uint8_t {
-  Normal,
-  Reverse,
-};
-
-
-enum class StyleBoxOrient : uint8_t {
-  Horizontal,
-  Vertical,
-};
-
-
-enum class StyleBoxPack : uint8_t {
-  Start,
-  Center,
-  End,
-  Justify,
-};
-
-
-enum class StyleBoxSizing : uint8_t {
-  Content,
-  Border
-};
-
-
-enum class StyleBoxShadowType : uint8_t {
-  Inset,
-};
-
-
-enum class StyleClear : uint8_t {
-  None = 0,
-  Left,
-  Right,
-  InlineStart,
-  InlineEnd,
-  Both,
-
-
-  Line = 8,
-  Max = 13
-};
-
-
-
-enum class StyleGeometryBox : uint8_t {
-  ContentBox,
-  PaddingBox,
-  BorderBox,
-  MarginBox,
-
-
-
-  FillBox,
-  StrokeBox,
-  ViewBox,
-  NoClip,
-  Text,
-  NoBox,
-
-
-
-
-
-
-  MozAlmostPadding = 127
-
-
-
-
-
-
-};
-
-
-enum class StyleFillRule : uint8_t {
-  Nonzero,
-  Evenodd,
-};
-
-
-
-enum class StyleFloat : uint8_t {
-  None,
-  Left,
-  Right,
-  InlineStart,
-  InlineEnd
-};
-
-
-enum class StyleFloatEdge : uint8_t {
-  ContentBox,
-  MarginBox,
-};
-
-
-enum class StyleHyphens : uint8_t {
-  None,
-  Manual,
-  Auto,
-};
-
-
-enum class StyleShapeRadius : uint8_t {
-  ClosestSide,
-  FarthestSide,
-};
-
-
-enum class StyleShapeSourceType : uint8_t {
-  None,
-  URL,
-  Shape,
-  Box,
-};
-
-
-enum class StyleTextJustify : uint8_t {
-  None,
-  Auto,
-  InterWord,
-  InterCharacter,
-};
-
-
-enum class StyleUserFocus : uint8_t {
-  None,
-  Ignore,
-  Normal,
-  SelectAll,
-  SelectBefore,
-  SelectAfter,
-  SelectSame,
-  SelectMenu,
-};
-
-
-enum class StyleUserSelect : uint8_t {
-  None,
-  Text,
-  Element,
-  Elements,
-  All,
-  Toggle,
-  TriState,
-  Auto,
-  MozAll,
-  MozText,
-};
-
-
-enum class StyleUserInput : uint8_t {
-  None,
-  Enabled,
-  Disabled,
-  Auto,
-};
-
-
-enum class StyleUserModify : uint8_t {
-  ReadOnly,
-  ReadWrite,
-  WriteOnly,
-};
-
-
-enum class StyleWindowDragging : uint8_t {
-  Default,
-  Drag,
-  NoDrag,
-};
-
-
-enum class StyleOrient : uint8_t {
-  Inline,
-  Block,
-  Horizontal,
-  Vertical,
-};
-# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
-namespace dom {
-enum class PlaybackDirection : uint8_t;
-enum class FillMode : uint8_t;
-}
-# 475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
-enum class StyleDisplay : uint8_t {
-  None = 0,
-  Block,
-  FlowRoot,
-  Inline,
-  InlineBlock,
-  ListItem,
-  Table,
-  InlineTable,
-  TableRowGroup,
-  TableColumn,
-  TableColumnGroup,
-  TableHeaderGroup,
-  TableFooterGroup,
-  TableRow,
-  TableCell,
-  TableCaption,
-  Flex,
-  InlineFlex,
-  Grid,
-  InlineGrid,
-  Ruby,
-  RubyBase,
-  RubyBaseContainer,
-  RubyText,
-  RubyTextContainer,
-  Contents,
-  WebkitBox,
-  WebkitInlineBox,
-  MozBox,
-  MozInlineBox,
-
-  MozGrid,
-  MozInlineGrid,
-  MozGridGroup,
-  MozGridLine,
-  MozStack,
-  MozInlineStack,
-  MozDeck,
-  MozGroupbox,
-  MozPopup,
-
-};
-# 684 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
-enum class StyleGridTrackBreadth : uint8_t {
-  MaxContent = 1,
-  MinContent = 2,
-};
-# 1247 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleConsts.h"
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h"
-namespace mozilla {
-
-class WritingMode;
-
-
-enum LogicalAxis {
-  eLogicalAxisBlock = 0x0,
-  eLogicalAxisInline = 0x1
-};
-enum LogicalEdge {
-  eLogicalEdgeStart = 0x0,
-  eLogicalEdgeEnd = 0x1
-};
-enum LogicalSide {
-  eLogicalSideBStart = (eLogicalAxisBlock << 1) | eLogicalEdgeStart,
-  eLogicalSideBEnd = (eLogicalAxisBlock << 1) | eLogicalEdgeEnd,
-  eLogicalSideIStart = (eLogicalAxisInline << 1) | eLogicalEdgeStart,
-  eLogicalSideIEnd = (eLogicalAxisInline << 1) | eLogicalEdgeEnd
-};
-
-enum LogicalCorner
-{
-  eLogicalCornerBStartIStart = 0,
-  eLogicalCornerBStartIEnd = 1,
-  eLogicalCornerBEndIEnd = 2,
-  eLogicalCornerBEndIStart = 3
-};
-
-}
-
-enum nsStyleUnit : uint8_t {
-  eStyleUnit_Null = 0,
-  eStyleUnit_Normal = 1,
-  eStyleUnit_Auto = 2,
-  eStyleUnit_None = 3,
-  eStyleUnit_Percent = 10,
-  eStyleUnit_Factor = 11,
-  eStyleUnit_Degree = 12,
-  eStyleUnit_Grad = 13,
-  eStyleUnit_Radian = 14,
-  eStyleUnit_Turn = 15,
-  eStyleUnit_FlexFraction = 16,
-  eStyleUnit_Coord = 20,
-  eStyleUnit_Integer = 30,
-  eStyleUnit_Enumerated = 32,
-
-
-  eStyleUnit_Calc = 40,
-
-
-  eStyleUnit_MAX = 40
-};
-
-typedef union {
-  int32_t mInt;
-  float mFloat;
-
-
-  void* mPointer;
-} nsStyleUnion;
-# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleCoord.h"
-class nsStyleCoord {
-public:
-
-
-  struct CalcValue {
-
-    nscoord mLength;
-    float mPercent;
-    bool mHasPercent;
-
-    bool operator==(const CalcValue& aOther) const {
-      return mLength == aOther.mLength &&
-             mPercent == aOther.mPercent &&
-             mHasPercent == aOther.mHasPercent;
-    }
-    bool operator!=(const CalcValue& aOther) const {
-      return !(*this == aOther);
-    }
-
-    nscoord ToLength() const {
-      do { } while (0);
-      return mLength;
-    }
-
-
-
-    bool IsDefinitelyZero() const { return mLength == 0 && mPercent == 0; }
-  };
-
-
-
-  struct Calc final : public CalcValue {
-    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Calc>::value, "Reference-counted class " "Calc" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-    Calc() {}
-
-  private:
-    Calc(const Calc&) = delete;
-    ~Calc() {}
-    Calc& operator=(const Calc&) = delete;
-  };
-
-  explicit nsStyleCoord(nsStyleUnit aUnit = eStyleUnit_Null);
-  enum CoordConstructorType { CoordConstructor };
-  inline nsStyleCoord(nscoord aValue, CoordConstructorType);
-  nsStyleCoord(int32_t aValue, nsStyleUnit aUnit);
-  nsStyleCoord(float aValue, nsStyleUnit aUnit);
-  inline nsStyleCoord(const nsStyleCoord& aCopy);
-  inline nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit);
-  ~nsStyleCoord() { Reset(); }
-
-  nsStyleCoord& operator=(const nsStyleCoord& aOther)
-  {
-    if (this != &aOther) {
-      SetValue(mUnit, mValue, aOther);
-    }
-    return *this;
-  }
-  bool operator==(const nsStyleCoord& aOther) const;
-  bool operator!=(const nsStyleCoord& aOther) const;
-
-  nsStyleUnit GetUnit() const {
-    do { } while(0);
-    return mUnit;
-  }
-
-  bool IsAngleValue() const {
-    return eStyleUnit_Degree <= mUnit && mUnit <= eStyleUnit_Turn;
-  }
-
-  static bool IsCalcUnit(nsStyleUnit aUnit) {
-    return aUnit == eStyleUnit_Calc;
-  }
-
-  static bool IsPointerUnit(nsStyleUnit aUnit) {
-    return IsCalcUnit(aUnit);
-  }
-
-  bool IsCalcUnit() const {
-    return IsCalcUnit(mUnit);
-  }
-
-  bool IsPointerValue() const {
-    return IsPointerUnit(mUnit);
-  }
-
-  bool IsCoordPercentCalcUnit() const {
-    return mUnit == eStyleUnit_Coord ||
-           mUnit == eStyleUnit_Percent ||
-           IsCalcUnit();
-  }
-
-
-
-  bool CalcHasPercent() const {
-    return GetCalcValue()->mHasPercent;
-  }
-
-  bool HasPercent() const {
-    return mUnit == eStyleUnit_Percent ||
-           (IsCalcUnit() && CalcHasPercent());
-  }
-
-  static bool ConvertsToLength(const nsStyleUnit aUnit,
-                               const nsStyleUnion aValue) {
-    return aUnit == eStyleUnit_Coord ||
-           (IsCalcUnit(aUnit) && !AsCalcValue(aValue)->mHasPercent);
-  }
-
-  bool ConvertsToLength() const {
-    return ConvertsToLength(mUnit, mValue);
-  }
-
-  static nscoord ToLength(nsStyleUnit aUnit, nsStyleUnion aValue) {
-    do { } while (0);
-    if (IsCalcUnit(aUnit)) {
-      return AsCalcValue(aValue)->ToLength();
-    }
-    do { } while (0);
-    return aValue.mInt;
-  }
-
-  nscoord ToLength() const {
-    return ToLength(GetUnit(), mValue);
-  }
-
-
-  static Calc* AsCalcValue(nsStyleUnion aValue) {
-    return static_cast<Calc*>(aValue.mPointer);
-  }
-
-  nscoord GetCoordValue() const;
-  int32_t GetIntValue() const;
-  float GetPercentValue() const;
-  float GetFactorValue() const;
-  float GetFactorOrPercentValue() const;
-  float GetAngleValue() const;
-  double GetAngleValueInDegrees() const;
-  double GetAngleValueInRadians() const;
-  float GetFlexFractionValue() const;
-  Calc* GetCalcValue() const;
-  uint32_t HashValue(uint32_t aHash) const;
-  template<typename T,
-           typename = typename std::enable_if<std::is_enum<T>::value>::type>
-  T GetEnumValue() const
-  {
-    do { } while (0);
-
-    return static_cast<T>(GetIntValue());
-  }
-
-
-
-  void Reset();
-
-  void SetCoordValue(nscoord aValue);
-  void SetIntValue(int32_t aValue, nsStyleUnit aUnit);
-  void SetPercentValue(float aValue);
-  void SetFactorValue(float aValue);
-  void SetAngleValue(float aValue, nsStyleUnit aUnit);
-  void SetFlexFractionValue(float aValue);
-  void SetNormalValue();
-  void SetAutoValue();
-  void SetNoneValue();
-  void SetCalcValue(Calc* aValue);
-  template<typename T,
-           typename = typename std::enable_if<std::is_enum<T>::value>::type>
-  void SetEnumValue(T aValue)
-  {
-    static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
-                  "aValue must be an enum that fits within mValue.mInt!");
-    SetIntValue(static_cast<int32_t>(aValue), eStyleUnit_Enumerated);
-  }
-
-
-  static inline void Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue);
-
-
-
-  static inline void SetValue(nsStyleUnit& aUnit,
-                              nsStyleUnion& aValue,
-                              nsStyleUnit aOtherUnit,
-                              const nsStyleUnion& aOtherValue);
-
-
-  static inline void SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
-                              const nsStyleCoord& aOther);
-
-
-  static inline void InitWithValue(nsStyleUnit& aUnit,
-                                   nsStyleUnion& aValue,
-                                   nsStyleUnit aOtherUnit,
-                                   const nsStyleUnion& aOtherValue);
-
-  static inline void InitWithValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
-                                   const nsStyleCoord& aOther);
-
-private:
-  nsStyleUnit mUnit;
-  nsStyleUnion mValue;
-};
-
-
-
-
-
-
-
-class nsStyleSides {
-public:
-  nsStyleSides();
-  nsStyleSides(const nsStyleSides&);
-  ~nsStyleSides();
-
-  nsStyleSides& operator=(const nsStyleSides& aCopy);
-  bool operator==(const nsStyleSides& aOther) const;
-  bool operator!=(const nsStyleSides& aOther) const;
-
-  inline nsStyleUnit GetUnit(mozilla::Side aSide) const;
-  inline nsStyleUnit GetLeftUnit() const;
-  inline nsStyleUnit GetTopUnit() const;
-  inline nsStyleUnit GetRightUnit() const;
-  inline nsStyleUnit GetBottomUnit() const;
-
-  inline nsStyleCoord Get(mozilla::Side aSide) const;
-  inline nsStyleCoord GetLeft() const;
-  inline nsStyleCoord GetTop() const;
-  inline nsStyleCoord GetRight() const;
-  inline nsStyleCoord GetBottom() const;
-
-
-
-
-
-  inline nsStyleUnit GetUnit(mozilla::WritingMode aWritingMode,
-                             mozilla::LogicalSide aSide) const;
-  inline nsStyleUnit GetIStartUnit(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleUnit GetBStartUnit(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleUnit GetIEndUnit(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleUnit GetBEndUnit(mozilla::WritingMode aWritingMode) const;
-
-
-  inline bool HasBlockAxisAuto(mozilla::WritingMode aWritingMode) const;
-  inline bool HasInlineAxisAuto(mozilla::WritingMode aWritingMode) const;
-
-  inline nsStyleCoord Get(mozilla::WritingMode aWritingMode,
-                          mozilla::LogicalSide aSide) const;
-  inline nsStyleCoord GetIStart(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleCoord GetBStart(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleCoord GetIEnd(mozilla::WritingMode aWritingMode) const;
-  inline nsStyleCoord GetBEnd(mozilla::WritingMode aWritingMode) const;
-
-
-
-
-  void Reset();
-
-  inline void Set(mozilla::Side aSide, const nsStyleCoord& aCoord);
-  inline void SetLeft(const nsStyleCoord& aCoord);
-  inline void SetTop(const nsStyleCoord& aCoord);
-  inline void SetRight(const nsStyleCoord& aCoord);
-  inline void SetBottom(const nsStyleCoord& aCoord);
-
-  nscoord ToLength(mozilla::Side aSide) const {
-    return nsStyleCoord::ToLength(mUnits[aSide], mValues[aSide]);
-  }
-
-  bool ConvertsToLength() const {
-    int32_t side354 = mozilla::eSideTop; for (mozilla::Side side; side354 <= mozilla::eSideLeft && ((side = mozilla::Side(side354)), true); ++side354) {
-      if (!nsStyleCoord::ConvertsToLength(mUnits[side], mValues[side])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-protected:
-  nsStyleUnit mUnits[4];
-  nsStyleUnion mValues[4];
-};
-
-
-
-
-
-
-
-class nsStyleCorners {
-public:
-  nsStyleCorners();
-  nsStyleCorners(const nsStyleCorners&);
-  ~nsStyleCorners();
-
-
-  nsStyleCorners& operator=(const nsStyleCorners& aCopy);
-  bool operator==(const nsStyleCorners& aOther) const;
-  bool operator!=(const nsStyleCorners& aOther) const;
-
-
-  inline nsStyleUnit GetUnit(uint8_t aHalfCorner) const;
-
-  inline nsStyleCoord Get(uint8_t aHalfCorner) const;
-
-
-
-
-  void Reset();
-
-  inline void Set(uint8_t aHalfCorner, const nsStyleCoord& aCoord);
-
-protected:
-
-
-
-
-
-  nsStyleUnit mUnits[8];
-  nsStyleUnion mValues[8];
-};
-
-
-
-
-
-inline nsStyleCoord::nsStyleCoord(nscoord aValue, CoordConstructorType)
-  : mUnit(eStyleUnit_Coord)
-{
-  mValue.mInt = aValue;
-}
-
-inline nsStyleCoord::nsStyleCoord(const nsStyleCoord& aCopy)
-  : mUnit(eStyleUnit_Null)
-{
-  InitWithValue(mUnit, mValue, aCopy);
-}
-
-inline nsStyleCoord::nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit)
-  : mUnit(eStyleUnit_Null)
-{
-  InitWithValue(mUnit, mValue, aUnit, aValue);
-}
-
-inline bool nsStyleCoord::operator!=(const nsStyleCoord& aOther) const
-{
-  return !((*this) == aOther);
-}
-
-inline nscoord nsStyleCoord::GetCoordValue() const
-{
-  do { } while(0);
-  if (mUnit == eStyleUnit_Coord) {
-    return mValue.mInt;
-  }
-  return 0;
-}
-
-inline int32_t nsStyleCoord::GetIntValue() const
-{
-  do { } while(0);
-
-  if ((mUnit == eStyleUnit_Enumerated) ||
-      (mUnit == eStyleUnit_Integer)) {
-    return mValue.mInt;
-  }
-  return 0;
-}
-
-inline float nsStyleCoord::GetPercentValue() const
-{
-  do { } while(0);
-  if (mUnit == eStyleUnit_Percent) {
-    return mValue.mFloat;
-  }
-  return 0.0f;
-}
-
-inline float nsStyleCoord::GetFactorValue() const
-{
-  do { } while(0);
-  if (mUnit == eStyleUnit_Factor) {
-    return mValue.mFloat;
-  }
-  return 0.0f;
-}
-
-inline float nsStyleCoord::GetFactorOrPercentValue() const
-{
-  do { } while(0);
-
-  if (mUnit == eStyleUnit_Factor || mUnit == eStyleUnit_Percent) {
-    return mValue.mFloat;
-  }
-  return 0.0f;
-}
-
-inline float nsStyleCoord::GetAngleValue() const
-{
-  do { } while(0);
-
-  if (mUnit >= eStyleUnit_Degree && mUnit <= eStyleUnit_Turn) {
-    return mValue.mFloat;
-  }
-  return 0.0f;
-}
-
-inline float nsStyleCoord::GetFlexFractionValue() const
-{
-  do { } while(0);
-  if (mUnit == eStyleUnit_FlexFraction) {
-    return mValue.mFloat;
-  }
-  return 0.0f;
-}
-
-inline nsStyleCoord::Calc* nsStyleCoord::GetCalcValue() const
-{
-  do { } while(0);
-  if (IsCalcUnit()) {
-    return AsCalcValue(mValue);
-  }
-  return nullptr;
-}
-
-             inline void
-nsStyleCoord::Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue)
-{
-  do { } while (0);
-
-
-  switch (aUnit) {
-    case eStyleUnit_Calc:
-      static_cast<Calc*>(aValue.mPointer)->Release();
-      break;
-    default:
-      do { } while (0);
-  }
-
-  aUnit = eStyleUnit_Null;
-  aValue.mInt = 0;
-}
-
-             inline void
-nsStyleCoord::SetValue(nsStyleUnit& aUnit,
-                       nsStyleUnion& aValue,
-                       nsStyleUnit aOtherUnit,
-                       const nsStyleUnion& aOtherValue)
-{
-  Reset(aUnit, aValue);
-  InitWithValue(aUnit, aValue, aOtherUnit, aOtherValue);
-}
-
-             inline void
-nsStyleCoord::InitWithValue(nsStyleUnit& aUnit,
-                            nsStyleUnion& aValue,
-                            nsStyleUnit aOtherUnit,
-                            const nsStyleUnion& aOtherValue)
-{
-  aUnit = aOtherUnit;
-  aValue = aOtherValue;
-
-  switch (aUnit) {
-    case eStyleUnit_Calc:
-      static_cast<Calc*>(aValue.mPointer)->AddRef();
-      break;
-    default:
-      do { } while (0);
-  }
-}
-
-             inline void
-nsStyleCoord::SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
-                       const nsStyleCoord& aOther)
-{
-  SetValue(aUnit, aValue, aOther.mUnit, aOther.mValue);
-}
-
-             inline void
-nsStyleCoord::InitWithValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
-                            const nsStyleCoord& aOther)
-{
-  InitWithValue(aUnit, aValue, aOther.mUnit, aOther.mValue);
-}
-
-
-
-
-
-inline bool nsStyleSides::operator!=(const nsStyleSides& aOther) const
-{
-  return !((*this) == aOther);
-}
-
-inline nsStyleUnit nsStyleSides::GetUnit(mozilla::Side aSide) const
-{
-  return (nsStyleUnit)mUnits[aSide];
-}
-
-inline nsStyleUnit nsStyleSides::GetLeftUnit() const
-{
-  return GetUnit(mozilla::eSideLeft);
-}
-
-inline nsStyleUnit nsStyleSides::GetTopUnit() const
-{
-  return GetUnit(mozilla::eSideTop);
-}
-
-inline nsStyleUnit nsStyleSides::GetRightUnit() const
-{
-  return GetUnit(mozilla::eSideRight);
-}
-
-inline nsStyleUnit nsStyleSides::GetBottomUnit() const
-{
-  return GetUnit(mozilla::eSideBottom);
-}
-
-inline nsStyleCoord nsStyleSides::Get(mozilla::Side aSide) const
-{
-  return nsStyleCoord(mValues[aSide], nsStyleUnit(mUnits[aSide]));
-}
-
-inline nsStyleCoord nsStyleSides::GetLeft() const
-{
-  return Get(mozilla::eSideLeft);
-}
-
-inline nsStyleCoord nsStyleSides::GetTop() const
-{
-  return Get(mozilla::eSideTop);
-}
-
-inline nsStyleCoord nsStyleSides::GetRight() const
-{
-  return Get(mozilla::eSideRight);
-}
-
-inline nsStyleCoord nsStyleSides::GetBottom() const
-{
-  return Get(mozilla::eSideBottom);
-}
-
-inline void nsStyleSides::Set(mozilla::Side aSide, const nsStyleCoord& aCoord)
-{
-  nsStyleCoord::SetValue(mUnits[aSide], mValues[aSide], aCoord);
-}
-
-inline void nsStyleSides::SetLeft(const nsStyleCoord& aCoord)
-{
-  Set(mozilla::eSideLeft, aCoord);
-}
-
-inline void nsStyleSides::SetTop(const nsStyleCoord& aCoord)
-{
-  Set(mozilla::eSideTop, aCoord);
-}
-
-inline void nsStyleSides::SetRight(const nsStyleCoord& aCoord)
-{
-  Set(mozilla::eSideRight, aCoord);
-}
-
-inline void nsStyleSides::SetBottom(const nsStyleCoord& aCoord)
-{
-  Set(mozilla::eSideBottom, aCoord);
-}
-
-
-
-
-inline bool nsStyleCorners::operator!=(const nsStyleCorners& aOther) const
-{
-  return !((*this) == aOther);
-}
-
-inline nsStyleUnit nsStyleCorners::GetUnit(uint8_t aCorner) const
-{
-  return (nsStyleUnit)mUnits[aCorner];
-}
-
-inline nsStyleCoord nsStyleCorners::Get(uint8_t aCorner) const
-{
-  return nsStyleCoord(mValues[aCorner], nsStyleUnit(mUnits[aCorner]));
-}
-
-inline void nsStyleCorners::Set(uint8_t aCorner, const nsStyleCoord& aCoord)
-{
-  nsStyleCoord::SetValue(mUnits[aCorner], mValues[aCorner], aCoord);
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 1
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 1
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsbytecode.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsbytecode.h"
-typedef uint8_t jsbytecode;
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h"
-namespace JS {
-
-
-typedef bool (*IsAcceptableThis)(HandleValue v);
-
-
-
-typedef bool (*NativeImpl)(JSContext* cx, const CallArgs& args);
-
-namespace detail {
-
-
-extern bool
-CallMethodIfWrapped(JSContext* cx, IsAcceptableThis test, NativeImpl impl, const CallArgs& args);
-
-}
-# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/CallNonGenericMethod.h"
-template<IsAcceptableThis Test, NativeImpl Impl>
-__attribute__((always_inline)) inline bool
-CallNonGenericMethod(JSContext* cx, const CallArgs& args)
-{
-    HandleValue thisv = args.thisv();
-    if (Test(thisv))
-        return Impl(cx, args);
-
-    return detail::CallMethodIfWrapped(cx, Test, Impl, args);
-}
-
-__attribute__((always_inline)) inline bool
-CallNonGenericMethod(JSContext* cx, IsAcceptableThis Test, NativeImpl Impl, const CallArgs& args)
-{
-    HandleValue thisv = args.thisv();
-    if (Test(thisv))
-        return Impl(cx, args);
-
-    return detail::CallMethodIfWrapped(cx, Test, Impl, args);
-}
-
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-class JSAtom;
-struct JSErrorFormatString;
-class JSLinearString;
-struct JSJitInfo;
-class JSErrorReport;
-
-namespace JS {
-template <class T>
-class Heap;
-}
-
-namespace js {
-class BaseProxyHandler;
-class InterpreterFrame;
-}
-
-extern void
-JS_SetGrayGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
-
-extern JSObject*
-JS_FindCompilationScope(JSContext* cx, JS::HandleObject obj);
-
-extern JSFunction*
-JS_GetObjectFunction(JSObject* obj);
-
-extern bool
-JS_SplicePrototype(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
-
-extern JSObject*
-JS_NewObjectWithUniqueType(JSContext* cx, const JSClass* clasp, JS::HandleObject proto);
-
-
-
-
-
-
-
-extern JSObject*
-JS_NewObjectWithoutMetadata(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
-
-extern uint32_t
-JS_ObjectCountDynamicSlots(JS::HandleObject obj);
-
-extern size_t
-JS_SetProtoCalled(JSContext* cx);
-
-extern size_t
-JS_GetCustomIteratorCount(JSContext* cx);
-
-extern bool
-JS_NondeterministicGetWeakMapKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
-
-extern bool
-JS_NondeterministicGetWeakSetKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
-
-
-extern unsigned
-JS_PCToLineNumber(JSScript* script, jsbytecode* pc, unsigned* columnp = nullptr);
-
-
-
-
-
-
-
-extern bool
-JS_IsDeadWrapper(JSObject* obj);
-
-
-
-
-
-extern void
-JS_TraceShapeCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr shape);
-extern void
-JS_TraceObjectGroupCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr group);
-
-enum {
-    JS_TELEMETRY_GC_REASON,
-    JS_TELEMETRY_GC_IS_ZONE_GC,
-    JS_TELEMETRY_GC_MS,
-    JS_TELEMETRY_GC_BUDGET_MS,
-    JS_TELEMETRY_GC_ANIMATION_MS,
-    JS_TELEMETRY_GC_MAX_PAUSE_MS,
-    JS_TELEMETRY_GC_MARK_MS,
-    JS_TELEMETRY_GC_SWEEP_MS,
-    JS_TELEMETRY_GC_COMPACT_MS,
-    JS_TELEMETRY_GC_MARK_ROOTS_MS,
-    JS_TELEMETRY_GC_MARK_GRAY_MS,
-    JS_TELEMETRY_GC_SLICE_MS,
-    JS_TELEMETRY_GC_SLOW_PHASE,
-    JS_TELEMETRY_GC_MMU_50,
-    JS_TELEMETRY_GC_RESET,
-    JS_TELEMETRY_GC_RESET_REASON,
-    JS_TELEMETRY_GC_INCREMENTAL_DISABLED,
-    JS_TELEMETRY_GC_NON_INCREMENTAL,
-    JS_TELEMETRY_GC_NON_INCREMENTAL_REASON,
-    JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS,
-    JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS,
-    JS_TELEMETRY_GC_MINOR_REASON,
-    JS_TELEMETRY_GC_MINOR_REASON_LONG,
-    JS_TELEMETRY_GC_MINOR_US,
-    JS_TELEMETRY_GC_NURSERY_BYTES,
-    JS_TELEMETRY_GC_PRETENURE_COUNT,
-    JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT,
-    JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_ADDONS,
-    JS_TELEMETRY_ADDON_EXCEPTIONS,
-    JS_TELEMETRY_AOT_USAGE,
-    JS_TELEMETRY_PRIVILEGED_PARSER_COMPILE_LAZY_AFTER_MS,
-    JS_TELEMETRY_WEB_PARSER_COMPILE_LAZY_AFTER_MS,
-    JS_TELEMETRY_END
-};
-
-typedef void
-(*JSAccumulateTelemetryDataCallback)(int id, uint32_t sample, const char* key);
-
-extern void
-JS_SetAccumulateTelemetryCallback(JSContext* cx, JSAccumulateTelemetryDataCallback callback);
-
-extern bool
-JS_GetIsSecureContext(JSCompartment* compartment);
-
-extern JSPrincipals*
-JS_GetCompartmentPrincipals(JSCompartment* compartment);
-
-extern void
-JS_SetCompartmentPrincipals(JSCompartment* compartment, JSPrincipals* principals);
-
-extern JSPrincipals*
-JS_GetScriptPrincipals(JSScript* script);
-
-extern bool
-JS_ScriptHasMutedErrors(JSScript* script);
-
-extern JSObject*
-JS_CloneObject(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
-# 181 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_InitializePropertiesFromCompatibleNativeObject(JSContext* cx,
-                                                  JS::HandleObject dst,
-                                                  JS::HandleObject src);
-
-extern JSString*
-JS_BasicObjectToString(JSContext* cx, JS::HandleObject obj);
-
-namespace js {
-
-bool
-GetBuiltinClass(JSContext* cx, JS::HandleObject obj, ESClass* cls);
-
-const char*
-ObjectClassName(JSContext* cx, JS::HandleObject obj);
-
-void
-ReportOverRecursed(JSContext* maybecx);
-
-bool
-AddRawValueRoot(JSContext* cx, JS::Value* vp, const char* name);
-
-void
-RemoveRawValueRoot(JSContext* cx, JS::Value* vp);
-
-JSAtom*
-GetPropertyNameFromPC(JSScript* script, jsbytecode* pc);
-# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern void
-DumpString(JSString* str, FILE* fp);
-
-extern void
-DumpAtom(JSAtom* atom, FILE* fp);
-
-extern void
-DumpObject(JSObject* obj, FILE* fp);
-
-extern void
-DumpChars(const char16_t* s, size_t n, FILE* fp);
-
-extern void
-DumpValue(const JS::Value& val, FILE* fp);
-
-extern void
-DumpId(jsid id, FILE* fp);
-
-extern void
-DumpInterpreterFrame(JSContext* cx, FILE* fp, InterpreterFrame* start = nullptr);
-
-extern bool
-DumpPC(JSContext* cx, FILE* fp);
-
-extern bool
-DumpScript(JSContext* cx, JSScript* scriptArg, FILE* fp);
-
-
-
-extern void DumpString(JSString* str);
-extern void DumpAtom(JSAtom* atom);
-extern void DumpObject(JSObject* obj);
-extern void DumpChars(const char16_t* s, size_t n);
-extern void DumpValue(const JS::Value& val);
-extern void DumpId(jsid id);
-extern void DumpInterpreterFrame(JSContext* cx, InterpreterFrame* start = nullptr);
-extern bool DumpPC(JSContext* cx);
-extern bool DumpScript(JSContext* cx, JSScript* scriptArg);
-
-
-
-extern void
-DumpBacktrace(JSContext* cx, FILE* fp);
-
-extern void
-DumpBacktrace(JSContext* cx);
-
-}
-
-namespace JS {
-
-
-extern char*
-FormatStackDump(JSContext* cx, char* buf, bool showArgs, bool showLocals, bool showThisProps);
-
-
-
-
-
-extern bool
-ForceLexicalInitialization(JSContext *cx, HandleObject obj);
-
-
-
-
-
-
-extern int
-IsGCPoisoning();
-
-}
-# 297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_CopyPropertiesFrom(JSContext* cx, JS::HandleObject target, JS::HandleObject obj);
-# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-typedef enum {
-    MakeNonConfigurableIntoConfigurable,
-    CopyNonConfigurableAsIs
-} PropertyCopyBehavior;
-
-extern bool
-JS_CopyPropertyFrom(JSContext* cx, JS::HandleId id, JS::HandleObject target,
-                    JS::HandleObject obj,
-                    PropertyCopyBehavior copyBehavior = CopyNonConfigurableAsIs);
-
-extern bool
-JS_WrapPropertyDescriptor(JSContext* cx, JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-struct JSFunctionSpecWithHelp {
-    const char* name;
-    JSNative call;
-    uint16_t nargs;
-    uint16_t flags;
-    const JSJitInfo* jitInfo;
-    const char* usage;
-    const char* help;
-};
-# 340 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_DefineFunctionsWithHelp(JSContext* cx, JS::HandleObject obj, const JSFunctionSpecWithHelp* fs);
-
-namespace js {
-
-extern const js::ClassOps ProxyClassOps;
-extern const js::ClassExtension ProxyClassExtension;
-extern const js::ObjectOps ProxyObjectOps;
-# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern JSObject*
-proxy_WeakmapKeyDelegate(JSObject* obj);
-# 391 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-class SourceHook {
-  public:
-    virtual ~SourceHook() { }
-
-
-
-
-
-
-    virtual bool load(JSContext* cx, const char* filename, char16_t** src, size_t* length) = 0;
-};
-
-
-
-
-
-
-
-extern void
-SetSourceHook(JSContext* cx, mozilla::UniquePtr<SourceHook> hook);
-
-
-extern mozilla::UniquePtr<SourceHook>
-ForgetSourceHook(JSContext* cx);
-
-extern JS::Zone*
-GetCompartmentZone(JSCompartment* comp);
-
-typedef bool
-(* PreserveWrapperCallback)(JSContext* cx, JSObject* obj);
-
-typedef enum {
-    CollectNurseryBeforeDump,
-    IgnoreNurseryObjects
-} DumpHeapNurseryBehaviour;
-
-
-
-
-
-extern void
-DumpHeap(JSContext* cx, FILE* fp, DumpHeapNurseryBehaviour nurseryBehaviour);
-
-
-bool obj_defineGetter(JSContext* cx, unsigned argc, JS::Value* vp);
-bool obj_defineSetter(JSContext* cx, unsigned argc, JS::Value* vp);
-
-
-extern bool
-IsSystemCompartment(JSCompartment* comp);
-
-extern bool
-IsSystemZone(JS::Zone* zone);
-
-extern bool
-IsAtomsCompartment(JSCompartment* comp);
-
-extern bool
-IsAtomsZone(JS::Zone* zone);
-
-struct WeakMapTracer
-{
-    JSContext* context;
-
-    explicit WeakMapTracer(JSContext* cx) : context(cx) {}
-
-
-
-
-
-
-
-    virtual void trace(JSObject* m, JS::GCCellPtr key, JS::GCCellPtr value) = 0;
-};
-
-extern void
-TraceWeakMaps(WeakMapTracer* trc);
-
-extern bool
-AreGCGrayBitsValid(JSContext* cx);
-
-extern bool
-ZoneGlobalsAreAllGray(JS::Zone* zone);
-
-typedef void
-(*GCThingCallback)(void* closure, JS::GCCellPtr thing);
-
-extern void
-VisitGrayWrapperTargets(JS::Zone* zone, GCThingCallback callback, void* closure);
-
-extern JSObject*
-GetWeakmapKeyDelegate(JSObject* key);
-
-
-
-
-extern void
-IterateGrayObjects(JS::Zone* zone, GCThingCallback cellCallback, void* data);
-
-
-
-
-
-extern void
-IterateGrayObjectsUnderCC(JS::Zone* zone, GCThingCallback cellCallback, void* data);
-# 508 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern size_t
-SizeOfDataIfCDataObject(mozilla::MallocSizeOf mallocSizeOf, JSObject* obj);
-
-
-extern JSCompartment*
-GetAnyCompartmentInZone(JS::Zone* zone);
-
-
-
-
-
-
-
-namespace shadow {
-
-struct ObjectGroup {
-    const Class* clasp;
-    JSObject* proto;
-    JSCompartment* compartment;
-};
-
-struct BaseShape {
-    const js::Class* clasp_;
-    JSObject* parent;
-};
-
-class Shape {
-public:
-    shadow::BaseShape* base;
-    jsid _1;
-    uint32_t slotInfo;
-
-    static const uint32_t FIXED_SLOTS_SHIFT = 27;
-};
-
-
-
-
-
-
-struct Object {
-    shadow::ObjectGroup* group;
-    shadow::Shape* shape;
-    JS::Value* slots;
-    void* _1;
-
-    size_t numFixedSlots() const { return shape->slotInfo >> Shape::FIXED_SLOTS_SHIFT; }
-    JS::Value* fixedSlots() const {
-        return (JS::Value*)(uintptr_t(this) + sizeof(shadow::Object));
-    }
-
-    JS::Value& slotRef(size_t slot) const {
-        size_t nfixed = numFixedSlots();
-        if (slot < nfixed)
-            return fixedSlots()[slot];
-        return slots[slot - nfixed];
-    }
-};
-
-struct Function {
-    Object base;
-    uint16_t nargs;
-    uint16_t flags;
-
-    JSNative native;
-    const JSJitInfo* jitinfo;
-    void* _1;
-};
-
-struct String
-{
-    static const uint32_t INLINE_CHARS_BIT = ((uint32_t)1 << (2));
-    static const uint32_t LATIN1_CHARS_BIT = ((uint32_t)1 << (6));
-    static const uint32_t ROPE_FLAGS = 0;
-    static const uint32_t EXTERNAL_FLAGS = ((uint32_t)1 << (5));
-    static const uint32_t TYPE_FLAGS_MASK = ((uint32_t)1 << (6)) - 1;
-    uint32_t flags;
-    uint32_t length;
-    union {
-        const JS::Latin1Char* nonInlineCharsLatin1;
-        const char16_t* nonInlineCharsTwoByte;
-        JS::Latin1Char inlineStorageLatin1[1];
-        char16_t inlineStorageTwoByte[1];
-    };
-    const JSStringFinalizer* externalFinalizer;
-};
-
-}
-
-
-
-extern const js::Class* const ObjectClassPtr;
-
-inline const js::Class*
-GetObjectClass(const JSObject* obj)
-{
-    return reinterpret_cast<const shadow::Object*>(obj)->group->clasp;
-}
-
-inline const JSClass*
-GetObjectJSClass(JSObject* obj)
-{
-    return js::Jsvalify(GetObjectClass(obj));
-}
-
-const Class*
-ProtoKeyToClass(JSProtoKey key);
-# 623 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-inline JSProtoKey
-InheritanceProtoKeyForStandardClass(JSProtoKey key)
-{
-
-    if (key == JSProto_Object)
-        return JSProto_Null;
-
-
-    if (ProtoKeyToClass(key)->specDefined())
-        return ProtoKeyToClass(key)->specInheritanceProtoKey();
-
-
-    return JSProto_Object;
-}
-
-bool
-IsFunctionObject(JSObject* obj);
-
-static __attribute__((always_inline)) inline JSCompartment*
-GetObjectCompartment(JSObject* obj)
-{
-    return reinterpret_cast<shadow::Object*>(obj)->group->compartment;
-}
-
-JSObject*
-GetGlobalForObjectCrossCompartment(JSObject* obj);
-
-JSObject*
-GetPrototypeNoProxy(JSObject* obj);
-
-void
-AssertSameCompartment(JSContext* cx, JSObject* obj);
-
-void
-AssertSameCompartment(JSContext* cx, JS::HandleValue v);
-
-
-void
-AssertSameCompartment(JSObject* objA, JSObject* objB);
-
-
-
-
-void
-NotifyAnimationActivity(JSObject* obj);
-# 678 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-JSFunction*
-GetOutermostEnclosingFunctionOfScriptedCaller(JSContext* cx);
-
-JSFunction*
-DefineFunctionWithReserved(JSContext* cx, JSObject* obj, const char* name, JSNative call,
-                           unsigned nargs, unsigned attrs);
-
-JSFunction*
-NewFunctionWithReserved(JSContext* cx, JSNative call, unsigned nargs, unsigned flags,
-                        const char* name);
-
-JSFunction*
-NewFunctionByIdWithReserved(JSContext* cx, JSNative native, unsigned nargs, unsigned flags,
-                            jsid id);
-
-const JS::Value&
-GetFunctionNativeReserved(JSObject* fun, size_t which);
-
-void
-SetFunctionNativeReserved(JSObject* fun, size_t which, const JS::Value& val);
-
-bool
-FunctionHasNativeReserved(JSObject* fun);
-
-bool
-GetObjectProto(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject proto);
-
-extern JSObject*
-GetStaticPrototype(JSObject* obj);
-
-bool
-GetOriginalEval(JSContext* cx, JS::HandleObject scope,
-                JS::MutableHandleObject eval);
-
-inline void*
-GetObjectPrivate(JSObject* obj)
-{
-    do { } while (0);
-    const shadow::Object* nobj = reinterpret_cast<const shadow::Object*>(obj);
-    void** addr = reinterpret_cast<void**>(&nobj->fixedSlots()[nobj->numFixedSlots()]);
-    return *addr;
-}
-
-inline const JS::Value&
-GetReservedSlot(JSObject* obj, size_t slot)
-{
-    do { } while (0);
-    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
-}
-
-void
-SetReservedOrProxyPrivateSlotWithBarrier(JSObject* obj, size_t slot, const JS::Value& value);
-
-inline void
-SetReservedSlot(JSObject* obj, size_t slot, const JS::Value& value)
-{
-    do { } while (0);
-    shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
-    if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
-        SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
-    else
-        sobj->slotRef(slot) = value;
-}
-
-uint32_t
-GetObjectSlotSpan(JSObject* obj);
-
-inline const JS::Value&
-GetObjectSlot(JSObject* obj, size_t slot)
-{
-    do { } while (0);
-    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
-}
-
-__attribute__((always_inline)) inline size_t
-GetAtomLength(JSAtom* atom)
-{
-    return reinterpret_cast<shadow::String*>(atom)->length;
-}
-
-static const uint32_t MaxStringLength = (1 << 28) - 1;
-
-__attribute__((always_inline)) inline size_t
-GetStringLength(JSString* s)
-{
-    return reinterpret_cast<shadow::String*>(s)->length;
-}
-
-__attribute__((always_inline)) inline size_t
-GetFlatStringLength(JSFlatString* s)
-{
-    return reinterpret_cast<shadow::String*>(s)->length;
-}
-
-__attribute__((always_inline)) inline size_t
-GetLinearStringLength(JSLinearString* s)
-{
-    return reinterpret_cast<shadow::String*>(s)->length;
-}
-
-__attribute__((always_inline)) inline bool
-LinearStringHasLatin1Chars(JSLinearString* s)
-{
-    return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
-}
-
-__attribute__((always_inline)) inline bool
-AtomHasLatin1Chars(JSAtom* atom)
-{
-    return reinterpret_cast<shadow::String*>(atom)->flags & shadow::String::LATIN1_CHARS_BIT;
-}
-
-__attribute__((always_inline)) inline bool
-StringHasLatin1Chars(JSString* s)
-{
-    return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
-}
-
-__attribute__((always_inline)) inline const JS::Latin1Char*
-GetLatin1LinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
-{
-    do { } while (0);
-
-    using shadow::String;
-    String* s = reinterpret_cast<String*>(linear);
-    if (s->flags & String::INLINE_CHARS_BIT)
-        return s->inlineStorageLatin1;
-    return s->nonInlineCharsLatin1;
-}
-
-__attribute__((always_inline)) inline const char16_t*
-GetTwoByteLinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
-{
-    do { } while (0);
-
-    using shadow::String;
-    String* s = reinterpret_cast<String*>(linear);
-    if (s->flags & String::INLINE_CHARS_BIT)
-        return s->inlineStorageTwoByte;
-    return s->nonInlineCharsTwoByte;
-}
-
-__attribute__((always_inline)) inline JSLinearString*
-AtomToLinearString(JSAtom* atom)
-{
-    return reinterpret_cast<JSLinearString*>(atom);
-}
-
-__attribute__((always_inline)) inline JSFlatString*
-AtomToFlatString(JSAtom* atom)
-{
-    return reinterpret_cast<JSFlatString*>(atom);
-}
-
-__attribute__((always_inline)) inline JSLinearString*
-FlatStringToLinearString(JSFlatString* s)
-{
-    return reinterpret_cast<JSLinearString*>(s);
-}
-
-__attribute__((always_inline)) inline const JS::Latin1Char*
-GetLatin1AtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
-{
-    return GetLatin1LinearStringChars(nogc, AtomToLinearString(atom));
-}
-
-__attribute__((always_inline)) inline const char16_t*
-GetTwoByteAtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
-{
-    return GetTwoByteLinearStringChars(nogc, AtomToLinearString(atom));
-}
-
-__attribute__((always_inline)) inline bool
-IsExternalString(JSString* str, const JSStringFinalizer** fin, const char16_t** chars)
-{
-    using shadow::String;
-    String* s = reinterpret_cast<String*>(str);
-
-    if ((s->flags & String::TYPE_FLAGS_MASK) != String::EXTERNAL_FLAGS)
-        return false;
-
-    do { } while (0);
-    *fin = s->externalFinalizer;
-    *chars = s->nonInlineCharsTwoByte;
-    return true;
-}
-
-JSLinearString*
-StringToLinearStringSlow(JSContext* cx, JSString* str);
-
-__attribute__((always_inline)) inline JSLinearString*
-StringToLinearString(JSContext* cx, JSString* str)
-{
-    using shadow::String;
-    String* s = reinterpret_cast<String*>(str);
-    if ((__builtin_expect(!!((s->flags & String::TYPE_FLAGS_MASK) == String::ROPE_FLAGS), 0)))
-        return StringToLinearStringSlow(cx, str);
-    return reinterpret_cast<JSLinearString*>(str);
-}
-
-template<typename CharType>
-__attribute__((always_inline)) inline void
-CopyLinearStringChars(CharType* dest, JSLinearString* s, size_t len, size_t start = 0);
-
-__attribute__((always_inline)) inline void
-CopyLinearStringChars(char16_t* dest, JSLinearString* s, size_t len, size_t start = 0)
-{
-    do { } while (0);
-    JS::AutoCheckCannotGC nogc;
-    if (LinearStringHasLatin1Chars(s)) {
-        const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
-        for (size_t i = 0; i < len; i++)
-            dest[i] = src[start + i];
-    } else {
-        const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
-        mozilla::PodCopy(dest, src + start, len);
-    }
-}
-
-__attribute__((always_inline)) inline void
-CopyLinearStringChars(char* dest, JSLinearString* s, size_t len, size_t start = 0)
-{
-    do { } while (0);
-    JS::AutoCheckCannotGC nogc;
-    if (LinearStringHasLatin1Chars(s)) {
-        const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
-        for (size_t i = 0; i < len; i++)
-           dest[i] = char(src[start + i]);
-    } else {
-      const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
-      for (size_t i = 0; i < len; i++)
-          dest[i] = char(src[start + i]);
-    }
-}
-
-template<typename CharType>
-inline bool
-CopyStringChars(JSContext* cx, CharType* dest, JSString* s, size_t len, size_t start = 0)
-{
-    JSLinearString* linear = StringToLinearString(cx, s);
-    if (!linear)
-        return false;
-
-    CopyLinearStringChars(dest, linear, len, start);
-    return true;
-}
-
-inline void
-CopyFlatStringChars(char16_t* dest, JSFlatString* s, size_t len)
-{
-    CopyLinearStringChars(dest, FlatStringToLinearString(s), len);
-}
-# 952 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-bool
-GetPropertyKeys(JSContext* cx, JS::HandleObject obj, unsigned flags, JS::AutoIdVector* props);
-
-bool
-AppendUnique(JSContext* cx, JS::AutoIdVector& base, JS::AutoIdVector& others);
-
-bool
-StringIsArrayIndex(JSLinearString* str, uint32_t* indexp);
-
-void
-SetPreserveWrapperCallback(JSContext* cx, PreserveWrapperCallback callback);
-
-bool
-IsObjectInContextCompartment(JSObject* obj, const JSContext* cx);
-# 980 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-bool
-RunningWithTrustedPrincipals(JSContext* cx);
-
-__attribute__((always_inline)) inline uintptr_t
-GetNativeStackLimit(JSContext* cx, JS::StackKind kind, int extraAllowance = 0)
-{
-    uintptr_t limit = JS::RootingContext::get(cx)->nativeStackLimit[kind];
-
-
-
-    limit -= extraAllowance;
-
-    return limit;
-}
-
-__attribute__((always_inline)) inline uintptr_t
-GetNativeStackLimit(JSContext* cx, int extraAllowance = 0)
-{
-    JS::StackKind kind = RunningWithTrustedPrincipals(cx) ? JS::StackForTrustedScript
-                                                          : JS::StackForUntrustedScript;
-    return GetNativeStackLimit(cx, kind, extraAllowance);
-}
-# 1012 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-__attribute__((always_inline)) inline bool
-CheckRecursionLimit(JSContext* cx, uintptr_t limit)
-{
-    int stackDummy;
-    if (!((__builtin_expect(!!((uintptr_t)(&stackDummy) > (limit)), 1)))) {
-        ReportOverRecursed(cx);
-        return false;
-    }
-    return true;
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitDontReport(JSContext* cx, uintptr_t limit)
-{
-    int stackDummy;
-    return ((__builtin_expect(!!((uintptr_t)(&stackDummy) > (limit)), 1)));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimit(JSContext* cx)
-{
-
-
-
-
-    uintptr_t untrustedLimit = GetNativeStackLimit(cx, JS::StackForUntrustedScript);
-    if ((__builtin_expect(!!(CheckRecursionLimitDontReport(cx, untrustedLimit)), 1)))
-        return true;
-    return CheckRecursionLimit(cx, GetNativeStackLimit(cx));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitDontReport(JSContext* cx)
-{
-    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitWithStackPointerDontReport(JSContext* cx, void* sp)
-{
-    return ((__builtin_expect(!!((uintptr_t)(sp) > (GetNativeStackLimit(cx))), 1)));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitWithStackPointer(JSContext* cx, void* sp)
-{
-    if (!((__builtin_expect(!!((uintptr_t)(sp) > (GetNativeStackLimit(cx))), 1)))) {
-        ReportOverRecursed(cx);
-        return false;
-    }
-    return true;
-}
-
-__attribute__((always_inline)) inline bool
-CheckSystemRecursionLimit(JSContext* cx)
-{
-    return CheckRecursionLimit(cx, GetNativeStackLimit(cx, JS::StackForSystemCode));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitConservative(JSContext* cx)
-{
-    return CheckRecursionLimit(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
-                                                       -1024 * int(sizeof(size_t))));
-}
-
-__attribute__((always_inline)) inline bool
-CheckRecursionLimitConservativeDontReport(JSContext* cx)
-{
-    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
-                                                                 -1024 * int(sizeof(size_t))));
-}
-
-void
-StartPCCountProfiling(JSContext* cx);
-
-void
-StopPCCountProfiling(JSContext* cx);
-
-void
-PurgePCCounts(JSContext* cx);
-
-size_t
-GetPCCountScriptCount(JSContext* cx);
-
-JSString*
-GetPCCountScriptSummary(JSContext* cx, size_t script);
-
-JSString*
-GetPCCountScriptContents(JSContext* cx, size_t script);
-# 1111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-char*
-GetCodeCoverageSummary(JSContext* cx, size_t* length);
-
-typedef void
-(* ActivityCallback)(void* arg, bool active);
-
-
-
-
-
-
-void
-SetActivityCallback(JSContext* cx, ActivityCallback cb, void* arg);
-
-typedef bool
-(* DOMInstanceClassHasProtoAtDepth)(const Class* instanceClass,
-                                    uint32_t protoID, uint32_t depth);
-struct JSDOMCallbacks {
-    DOMInstanceClassHasProtoAtDepth instanceClassMatchesProto;
-};
-typedef struct JSDOMCallbacks DOMCallbacks;
-
-extern void
-SetDOMCallbacks(JSContext* cx, const DOMCallbacks* callbacks);
-
-extern const DOMCallbacks*
-GetDOMCallbacks(JSContext* cx);
-
-extern JSObject*
-GetTestingFunctions(JSContext* cx);
-
-
-
-
-
-
-inline JSFreeOp*
-CastToJSFreeOp(FreeOp* fop)
-{
-    return reinterpret_cast<JSFreeOp*>(fop);
-}
-
-
-
-
-
-
-
-extern JSFlatString*
-GetErrorTypeName(JSContext* cx, int16_t exnType);
-
-
-extern unsigned
-GetEnterCompartmentDepth(JSContext* cx);
-
-
-extern bool
-RegExpToSharedNonInline(JSContext* cx, JS::HandleObject regexp,
-                        JS::MutableHandle<RegExpShared*> shared);
-
-
-typedef enum NukeReferencesToWindow {
-    NukeWindowReferences,
-    DontNukeWindowReferences
-} NukeReferencesToWindow;
-
-typedef enum NukeReferencesFromTarget {
-    NukeAllReferences,
-    NukeIncomingReferences,
-} NukeReferencesFromTarget;
-
-
-
-
-
-struct CompartmentFilter {
-    virtual bool match(JSCompartment* c) const = 0;
-};
-
-struct AllCompartments : public CompartmentFilter {
-    virtual bool match(JSCompartment* c) const override { return true; }
-};
-
-struct ContentCompartmentsOnly : public CompartmentFilter {
-    virtual bool match(JSCompartment* c) const override {
-        return !IsSystemCompartment(c);
-    }
-};
-
-struct ChromeCompartmentsOnly : public CompartmentFilter {
-    virtual bool match(JSCompartment* c) const override {
-        return IsSystemCompartment(c);
-    }
-};
-
-struct SingleCompartment : public CompartmentFilter {
-    JSCompartment* ours;
-    explicit SingleCompartment(JSCompartment* c) : ours(c) {}
-    virtual bool match(JSCompartment* c) const override { return c == ours; }
-};
-
-struct CompartmentsWithPrincipals : public CompartmentFilter {
-    JSPrincipals* principals;
-    explicit CompartmentsWithPrincipals(JSPrincipals* p) : principals(p) {}
-    virtual bool match(JSCompartment* c) const override {
-        return JS_GetCompartmentPrincipals(c) == principals;
-    }
-};
-
-extern bool
-NukeCrossCompartmentWrappers(JSContext* cx,
-                             const CompartmentFilter& sourceFilter,
-                             const CompartmentFilter& targetFilter,
-                             NukeReferencesToWindow nukeReferencesToWindow,
-                             NukeReferencesFromTarget nukeReferencesFromTarget);
-# 1252 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-struct ExpandoAndGeneration {
-  ExpandoAndGeneration()
-    : expando(JS::UndefinedValue()),
-      generation(0)
-  {}
-
-  void OwnerUnlinked()
-  {
-      ++generation;
-  }
-
-  static size_t offsetOfExpando()
-  {
-      return __builtin_offsetof(ExpandoAndGeneration, expando);
-  }
-
-  static size_t offsetOfGeneration()
-  {
-      return __builtin_offsetof(ExpandoAndGeneration, generation);
-  }
-
-  JS::Heap<JS::Value> expando;
-  uint64_t generation;
-};
-
-typedef enum DOMProxyShadowsResult {
-  ShadowCheckFailed,
-  Shadows,
-  DoesntShadow,
-  DoesntShadowUnique,
-  ShadowsViaDirectExpando,
-  ShadowsViaIndirectExpando
-} DOMProxyShadowsResult;
-typedef DOMProxyShadowsResult
-(* DOMProxyShadowsCheck)(JSContext* cx, JS::HandleObject object, JS::HandleId id);
-void
-SetDOMProxyInformation(const void* domProxyHandlerFamily, uint32_t domProxyExpandoSlot,
-                       DOMProxyShadowsCheck domProxyShadowsCheck);
-
-const void* GetDOMProxyHandlerFamily();
-uint32_t GetDOMProxyExpandoSlot();
-DOMProxyShadowsCheck GetDOMProxyShadowsCheck();
-inline bool DOMProxyIsShadowing(DOMProxyShadowsResult result) {
-    return result == Shadows ||
-           result == ShadowsViaDirectExpando ||
-           result == ShadowsViaIndirectExpando;
-}
-
-
-
-
-extern bool
-DateIsValid(JSContext* cx, JS::HandleObject obj, bool* isValid);
-
-extern bool
-DateGetMsecSinceEpoch(JSContext* cx, JS::HandleObject obj, double* msecSinceEpoch);
-
-}
-
-
-
-
-
-
-
-typedef enum JSErrNum {
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js.msg" 1
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js.msg"
-JSMSG_NOT_AN_ERROR,
-JSMSG_NOT_DEFINED,
-JSMSG_MORE_ARGS_NEEDED,
-JSMSG_INCOMPATIBLE_PROTO,
-JSMSG_NO_CONSTRUCTOR,
-JSMSG_BAD_SORT_ARG,
-JSMSG_CANT_WATCH,
-JSMSG_READ_ONLY,
-JSMSG_CANT_DELETE,
-JSMSG_CANT_TRUNCATE_ARRAY,
-JSMSG_NOT_FUNCTION,
-JSMSG_NOT_CONSTRUCTOR,
-JSMSG_CANT_CONVERT_TO,
-JSMSG_TOPRIMITIVE_NOT_CALLABLE,
-JSMSG_TOPRIMITIVE_RETURNED_OBJECT,
-JSMSG_NO_PROPERTIES,
-JSMSG_BAD_REGEXP_FLAG,
-JSMSG_ARG_INDEX_OUT_OF_RANGE,
-JSMSG_SPREAD_TOO_LARGE,
-JSMSG_BAD_WEAKMAP_KEY,
-JSMSG_BAD_GETTER_OR_SETTER,
-JSMSG_BAD_ARRAY_LENGTH,
-JSMSG_REDECLARED_PREV,
-JSMSG_REDECLARED_VAR,
-JSMSG_UNDECLARED_VAR,
-JSMSG_GETTER_ONLY,
-JSMSG_OVERWRITING_ACCESSOR,
-JSMSG_UNDEFINED_PROP,
-JSMSG_INVALID_MAP_ITERABLE,
-JSMSG_NESTING_GENERATOR,
-JSMSG_INCOMPATIBLE_METHOD,
-JSMSG_OBJECT_WATCH_DEPRECATED,
-JSMSG_BAD_SURROGATE_CHAR,
-JSMSG_UTF8_CHAR_TOO_LARGE,
-JSMSG_MALFORMED_UTF8_CHAR,
-JSMSG_BUILTIN_CTOR_NO_NEW,
-JSMSG_BAD_GENERATOR_YIELD,
-JSMSG_EMPTY_ARRAY_REDUCE,
-JSMSG_UNEXPECTED_TYPE,
-JSMSG_MISSING_FUN_ARG,
-JSMSG_NOT_NONNULL_OBJECT,
-JSMSG_NOT_NONNULL_OBJECT_NAME,
-JSMSG_NOT_NONNULL_OBJECT_ARG,
-JSMSG_SET_NON_OBJECT_RECEIVER,
-JSMSG_INVALID_DESCRIPTOR,
-JSMSG_OBJECT_NOT_EXTENSIBLE,
-JSMSG_CANT_DEFINE_PROP_OBJECT_NOT_EXTENSIBLE,
-JSMSG_CANT_REDEFINE_PROP,
-JSMSG_CANT_REDEFINE_ARRAY_LENGTH,
-JSMSG_CANT_DEFINE_PAST_ARRAY_LENGTH,
-JSMSG_BAD_GET_SET_FIELD,
-JSMSG_THROW_TYPE_ERROR,
-JSMSG_NOT_EXPECTED_TYPE,
-JSMSG_NOT_ITERABLE,
-JSMSG_NOT_ITERATOR,
-JSMSG_ALREADY_HAS_PRAGMA,
-JSMSG_GET_ITER_RETURNED_PRIMITIVE,
-JSMSG_ITER_METHOD_RETURNED_PRIMITIVE,
-JSMSG_CANT_SET_PROTO,
-JSMSG_CANT_SET_PROTO_OF,
-JSMSG_CANT_SET_PROTO_CYCLE,
-JSMSG_INVALID_ARG_TYPE,
-JSMSG_TERMINATED,
-JSMSG_PROTO_NOT_OBJORNULL,
-JSMSG_CANT_CALL_CLASS_CONSTRUCTOR,
-JSMSG_UNINITIALIZED_THIS,
-JSMSG_UNINITIALIZED_THIS_ARROW,
-JSMSG_BAD_DERIVED_RETURN,
-
-
-JSMSG_JSON_BAD_PARSE,
-JSMSG_JSON_CYCLIC_VALUE,
-
-
-JSMSG_BAD_INSTANCEOF_RHS,
-JSMSG_BAD_LEFTSIDE_OF_ASS,
-JSMSG_BAD_PROTOTYPE,
-JSMSG_IN_NOT_OBJECT,
-JSMSG_TOO_MANY_CON_SPREADARGS,
-JSMSG_TOO_MANY_FUN_SPREADARGS,
-JSMSG_UNINITIALIZED_LEXICAL,
-JSMSG_BAD_CONST_ASSIGN,
-JSMSG_CANT_DECLARE_GLOBAL_BINDING,
-
-
-JSMSG_INVALID_DATE,
-JSMSG_BAD_TOISOSTRING_PROP,
-JSMSG_DEPRECATED_TOLOCALEFORMAT,
-
-
-JSMSG_BAD_URI,
-JSMSG_INVALID_NORMALIZE_FORM,
-JSMSG_NEGATIVE_REPETITION_COUNT,
-JSMSG_NOT_A_CODEPOINT,
-JSMSG_RESULTING_STRING_TOO_LARGE,
-JSMSG_DEPRECATED_STRING_METHOD,
-
-
-JSMSG_BAD_RADIX,
-JSMSG_PRECISION_RANGE,
-
-
-JSMSG_BAD_APPLY_ARGS,
-JSMSG_BAD_FORMAL,
-JSMSG_CALLER_IS_STRICT,
-JSMSG_DEPRECATED_USAGE,
-JSMSG_NOT_SCRIPTED_FUNCTION,
-JSMSG_NO_REST_NAME,
-JSMSG_PARAMETER_AFTER_REST,
-JSMSG_TOO_MANY_ARGUMENTS,
-
-
-JSMSG_CSP_BLOCKED_EVAL,
-JSMSG_CSP_BLOCKED_FUNCTION,
-
-
-JSMSG_ACCESSOR_DEF_DENIED,
-JSMSG_DEAD_OBJECT,
-JSMSG_OBJECT_ACCESS_DENIED,
-JSMSG_PROPERTY_ACCESS_DENIED,
-
-
-JSMSG_BAD_CLONE_FUNOBJ_SCOPE,
-JSMSG_CANT_CLONE_OBJECT,
-JSMSG_CANT_OPEN,
-JSMSG_USER_DEFINED_ERROR,
-
-
-JSMSG_ALLOC_OVERFLOW,
-JSMSG_BAD_BYTECODE,
-JSMSG_BUFFER_TOO_SMALL,
-JSMSG_BUILD_ID_NOT_AVAILABLE,
-JSMSG_BYTECODE_TOO_BIG,
-JSMSG_ERR_DURING_THROW,
-JSMSG_NEED_DIET,
-JSMSG_OUT_OF_MEMORY,
-JSMSG_OVER_RECURSED,
-JSMSG_TOO_BIG_TO_ENCODE,
-JSMSG_TOO_DEEP,
-JSMSG_UNCAUGHT_EXCEPTION,
-JSMSG_UNKNOWN_FORMAT,
-
-
-JSMSG_ACCESSOR_WRONG_ARGS,
-JSMSG_ARRAY_COMP_LEFTSIDE,
-JSMSG_ARRAY_INIT_TOO_BIG,
-JSMSG_AS_AFTER_IMPORT_STAR,
-JSMSG_AS_AFTER_RESERVED_WORD,
-JSMSG_ASYNC_GENERATOR,
-JSMSG_AWAIT_IN_DEFAULT,
-JSMSG_AWAIT_OUTSIDE_ASYNC,
-JSMSG_BAD_ARROW_ARGS,
-JSMSG_BAD_BINDING,
-JSMSG_BAD_CONST_DECL,
-JSMSG_BAD_CONTINUE,
-JSMSG_BAD_DESTRUCT_ASS,
-JSMSG_BAD_DESTRUCT_TARGET,
-JSMSG_BAD_DESTRUCT_PARENS,
-JSMSG_BAD_DESTRUCT_DECL,
-JSMSG_BAD_DUP_ARGS,
-JSMSG_BAD_FOR_EACH_LOOP,
-JSMSG_BAD_FOR_LEFTSIDE,
-JSMSG_LEXICAL_DECL_DEFINES_LET,
-JSMSG_LET_STARTING_FOROF_LHS,
-JSMSG_BAD_FUNCTION_YIELD,
-JSMSG_BAD_GENERATOR_RETURN,
-JSMSG_BAD_GENEXP_BODY,
-JSMSG_BAD_INCOP_OPERAND,
-JSMSG_BAD_METHOD_DEF,
-JSMSG_BAD_OCTAL,
-JSMSG_BAD_POW_LEFTSIDE,
-JSMSG_BAD_PROP_ID,
-JSMSG_BAD_RETURN_OR_YIELD,
-JSMSG_BAD_STRICT_ASSIGN,
-JSMSG_BAD_SWITCH,
-JSMSG_BAD_SUPER,
-JSMSG_BAD_SUPERPROP,
-JSMSG_BAD_SUPERCALL,
-JSMSG_BRACKET_AFTER_ARRAY_COMPREHENSION,
-JSMSG_BRACKET_AFTER_LIST,
-JSMSG_BRACKET_IN_INDEX,
-JSMSG_BRACKET_OPENED,
-JSMSG_CATCH_AFTER_GENERAL,
-JSMSG_CATCH_IDENTIFIER,
-JSMSG_CATCH_OR_FINALLY,
-JSMSG_CATCH_WITHOUT_TRY,
-JSMSG_COLON_AFTER_CASE,
-JSMSG_COLON_AFTER_ID,
-JSMSG_COLON_IN_COND,
-JSMSG_COMP_PROP_UNTERM_EXPR,
-JSMSG_CONTRARY_NONDIRECTIVE,
-JSMSG_CURLY_AFTER_BODY,
-JSMSG_CURLY_OPENED,
-JSMSG_CURLY_AFTER_CATCH,
-JSMSG_CURLY_AFTER_FINALLY,
-JSMSG_CURLY_AFTER_LIST,
-JSMSG_CURLY_AFTER_TRY,
-JSMSG_CURLY_BEFORE_BODY,
-JSMSG_CURLY_BEFORE_CATCH,
-JSMSG_CURLY_BEFORE_CLASS,
-JSMSG_CURLY_BEFORE_FINALLY,
-JSMSG_CURLY_BEFORE_SWITCH,
-JSMSG_CURLY_BEFORE_TRY,
-JSMSG_CURLY_IN_COMPOUND,
-JSMSG_DECLARATION_AFTER_EXPORT,
-JSMSG_DECLARATION_AFTER_IMPORT,
-JSMSG_DEPRECATED_DELETE_OPERAND,
-JSMSG_DEPRECATED_EXPR_CLOSURE,
-JSMSG_DEPRECATED_FOR_EACH,
-JSMSG_DEPRECATED_OCTAL,
-JSMSG_DEPRECATED_PRAGMA,
-JSMSG_DEPRECATED_BLOCK_SCOPE_FUN_REDECL,
-JSMSG_DUPLICATE_EXPORT_NAME,
-JSMSG_DUPLICATE_FORMAL,
-JSMSG_DUPLICATE_LABEL,
-JSMSG_DUPLICATE_PROPERTY,
-JSMSG_DUPLICATE_PROTO_PROPERTY,
-JSMSG_EMPTY_CONSEQUENT,
-JSMSG_EQUAL_AS_ASSIGN,
-JSMSG_EXPORT_DECL_AT_TOP_LEVEL,
-JSMSG_FINALLY_WITHOUT_TRY,
-JSMSG_FORBIDDEN_AS_STATEMENT,
-JSMSG_FROM_AFTER_IMPORT_CLAUSE,
-JSMSG_FROM_AFTER_EXPORT_STAR,
-JSMSG_GARBAGE_AFTER_INPUT,
-JSMSG_IDSTART_AFTER_NUMBER,
-JSMSG_ILLEGAL_CHARACTER,
-JSMSG_IMPORT_DECL_AT_TOP_LEVEL,
-JSMSG_OF_AFTER_FOR_LOOP_DECL,
-JSMSG_IN_AFTER_LEXICAL_FOR_DECL,
-JSMSG_INVALID_FOR_IN_DECL_WITH_INIT,
-JSMSG_INVALID_ID,
-JSMSG_LABEL_NOT_FOUND,
-JSMSG_LET_COMP_BINDING,
-JSMSG_LEXICAL_DECL_NOT_IN_BLOCK,
-JSMSG_LEXICAL_DECL_LABEL,
-JSMSG_GENERATOR_LABEL,
-JSMSG_FUNCTION_LABEL,
-JSMSG_SLOPPY_FUNCTION_LABEL,
-JSMSG_LINE_BREAK_AFTER_THROW,
-JSMSG_LINE_BREAK_BEFORE_ARROW,
-JSMSG_MALFORMED_ESCAPE,
-JSMSG_MISSING_BINARY_DIGITS,
-JSMSG_MISSING_EXPONENT,
-JSMSG_MISSING_EXPR_AFTER_THROW,
-JSMSG_MISSING_FORMAL,
-JSMSG_MISSING_HEXDIGITS,
-JSMSG_MISSING_OCTAL_DIGITS,
-JSMSG_MODULE_SPEC_AFTER_FROM,
-JSMSG_NAME_AFTER_DOT,
-JSMSG_NAMED_IMPORTS_OR_NAMESPACE_IMPORT,
-JSMSG_NO_BINDING_NAME,
-JSMSG_NO_EXPORT_NAME,
-JSMSG_NO_IMPORT_NAME,
-JSMSG_NO_VARIABLE_NAME,
-JSMSG_OF_AFTER_FOR_NAME,
-JSMSG_PAREN_AFTER_ARGS,
-JSMSG_PAREN_AFTER_CATCH,
-JSMSG_PAREN_AFTER_COND,
-JSMSG_PAREN_AFTER_FOR,
-JSMSG_PAREN_AFTER_FORMAL,
-JSMSG_PAREN_AFTER_FOR_CTRL,
-JSMSG_PAREN_AFTER_FOR_OF_ITERABLE,
-JSMSG_PAREN_AFTER_SWITCH,
-JSMSG_PAREN_AFTER_WITH,
-JSMSG_PAREN_BEFORE_CATCH,
-JSMSG_PAREN_BEFORE_COND,
-JSMSG_PAREN_BEFORE_FORMAL,
-JSMSG_PAREN_BEFORE_SWITCH,
-JSMSG_PAREN_BEFORE_WITH,
-JSMSG_PAREN_IN_PAREN,
-JSMSG_RC_AFTER_EXPORT_SPEC_LIST,
-JSMSG_RC_AFTER_IMPORT_SPEC_LIST,
-JSMSG_REDECLARED_CATCH_IDENTIFIER,
-JSMSG_RESERVED_ID,
-JSMSG_REST_WITH_COMMA,
-JSMSG_REST_WITH_DEFAULT,
-JSMSG_SELFHOSTED_TOP_LEVEL_LEXICAL,
-JSMSG_SELFHOSTED_METHOD_CALL,
-JSMSG_SELFHOSTED_UNBOUND_NAME,
-JSMSG_SEMI_AFTER_FOR_COND,
-JSMSG_SEMI_AFTER_FOR_INIT,
-JSMSG_SEMI_BEFORE_STMNT,
-JSMSG_SOURCE_TOO_LONG,
-JSMSG_STMT_AFTER_RETURN,
-JSMSG_STRICT_CODE_WITH,
-JSMSG_STRICT_NON_SIMPLE_PARAMS,
-JSMSG_TEMPLSTR_UNTERM_EXPR,
-JSMSG_SIMD_NOT_A_VECTOR,
-JSMSG_TOO_MANY_CASES,
-JSMSG_TOO_MANY_CATCH_VARS,
-JSMSG_TOO_MANY_CON_ARGS,
-JSMSG_TOO_MANY_DEFAULTS,
-JSMSG_TOO_MANY_FUN_ARGS,
-JSMSG_TOO_MANY_LOCALS,
-JSMSG_TOO_MANY_YIELDS,
-JSMSG_TOUGH_BREAK,
-JSMSG_UNEXPECTED_TOKEN,
-JSMSG_UNEXPECTED_PARAMLIST_END,
-JSMSG_UNNAMED_CLASS_STMT,
-JSMSG_UNNAMED_FUNCTION_STMT,
-JSMSG_UNTERMINATED_COMMENT,
-JSMSG_UNTERMINATED_REGEXP,
-JSMSG_UNTERMINATED_STRING,
-JSMSG_USELESS_EXPR,
-JSMSG_USE_ASM_DIRECTIVE_FAIL,
-JSMSG_VAR_HIDES_ARG,
-JSMSG_WHILE_AFTER_DO,
-JSMSG_YIELD_IN_ARROW,
-JSMSG_YIELD_IN_DEFAULT,
-JSMSG_YIELD_IN_METHOD,
-JSMSG_BAD_COLUMN_NUMBER,
-JSMSG_COMPUTED_NAME_IN_PATTERN,
-JSMSG_DEFAULT_IN_PATTERN,
-JSMSG_BAD_NEWTARGET,
-JSMSG_ESCAPED_KEYWORD,
-
-
-JSMSG_USE_ASM_TYPE_FAIL,
-JSMSG_USE_ASM_LINK_FAIL,
-JSMSG_USE_ASM_TYPE_OK,
-
-
-JSMSG_WASM_COMPILE_ERROR,
-JSMSG_WASM_BAD_IMPORT_TYPE,
-JSMSG_WASM_BAD_IMPORT_SIG,
-JSMSG_WASM_BAD_IMP_SIZE,
-JSMSG_WASM_BAD_IMP_MAX,
-JSMSG_WASM_BAD_FIT,
-JSMSG_WASM_IND_CALL_TO_NULL,
-JSMSG_WASM_IND_CALL_BAD_SIG,
-JSMSG_WASM_UNREACHABLE,
-JSMSG_WASM_INTEGER_OVERFLOW,
-JSMSG_WASM_INVALID_CONVERSION,
-JSMSG_WASM_INT_DIVIDE_BY_ZERO,
-JSMSG_WASM_OUT_OF_BOUNDS,
-JSMSG_WASM_UNALIGNED_ACCESS,
-JSMSG_WASM_BAD_UINT32,
-JSMSG_WASM_BAD_GROW,
-JSMSG_WASM_BAD_BUF_ARG,
-JSMSG_WASM_BAD_MOD_ARG,
-JSMSG_WASM_BAD_BUF_MOD_ARG,
-JSMSG_WASM_BAD_DESC_ARG,
-JSMSG_WASM_BAD_ELEMENT,
-JSMSG_WASM_BAD_IMPORT_ARG,
-JSMSG_WASM_BAD_IMPORT_FIELD,
-JSMSG_WASM_BAD_TABLE_VALUE,
-JSMSG_WASM_BAD_I64,
-JSMSG_WASM_NO_TRANSFER,
-JSMSG_WASM_TEXT_FAIL,
-
-
-JSMSG_BAD_TRAP_RETURN_VALUE,
-JSMSG_BAD_GETPROTOTYPEOF_TRAP_RETURN,
-JSMSG_INCONSISTENT_GETPROTOTYPEOF_TRAP,
-JSMSG_PROXY_SETPROTOTYPEOF_RETURNED_FALSE,
-JSMSG_PROXY_ISEXTENSIBLE_RETURNED_FALSE,
-JSMSG_INCONSISTENT_SETPROTOTYPEOF_TRAP,
-JSMSG_CANT_CHANGE_EXTENSIBILITY,
-JSMSG_CANT_DEFINE_INVALID,
-JSMSG_CANT_DEFINE_NEW,
-JSMSG_CANT_DEFINE_NE_AS_NC,
-JSMSG_PROXY_DEFINE_RETURNED_FALSE,
-JSMSG_PROXY_DELETE_RETURNED_FALSE,
-JSMSG_PROXY_PREVENTEXTENSIONS_RETURNED_FALSE,
-JSMSG_PROXY_SET_RETURNED_FALSE,
-JSMSG_CANT_REPORT_AS_NON_EXTENSIBLE,
-JSMSG_CANT_REPORT_C_AS_NC,
-JSMSG_CANT_REPORT_E_AS_NE,
-JSMSG_CANT_REPORT_INVALID,
-JSMSG_CANT_REPORT_NC_AS_NE,
-JSMSG_CANT_REPORT_NEW,
-JSMSG_CANT_REPORT_NE_AS_NC,
-JSMSG_CANT_SET_NW_NC,
-JSMSG_CANT_SET_WO_SETTER,
-JSMSG_CANT_SKIP_NC,
-JSMSG_ONWKEYS_STR_SYM,
-JSMSG_MUST_REPORT_SAME_VALUE,
-JSMSG_MUST_REPORT_UNDEFINED,
-JSMSG_PROXY_CONSTRUCT_OBJECT,
-JSMSG_PROXY_EXTENSIBILITY,
-JSMSG_PROXY_GETOWN_OBJORUNDEF,
-JSMSG_PROXY_REVOKED,
-JSMSG_PROXY_ARG_REVOKED,
-JSMSG_BAD_TRAP,
-
-
-JSMSG_SC_BAD_CLONE_VERSION,
-JSMSG_SC_BAD_SERIALIZED_DATA,
-JSMSG_SC_DUP_TRANSFERABLE,
-JSMSG_SC_NOT_TRANSFERABLE,
-JSMSG_SC_UNSUPPORTED_TYPE,
-JSMSG_SC_NOT_CLONABLE,
-JSMSG_SC_SAB_TRANSFERABLE,
-JSMSG_SC_SAB_DISABLED,
-
-
-JSMSG_ASSIGN_FUNCTION_OR_NULL,
-JSMSG_DEBUG_BAD_LINE,
-JSMSG_DEBUG_BAD_OFFSET,
-JSMSG_DEBUG_BAD_REFERENT,
-JSMSG_DEBUG_BAD_RESUMPTION,
-JSMSG_DEBUG_BAD_YIELD,
-JSMSG_DEBUG_CANT_DEBUG_GLOBAL,
-JSMSG_DEBUG_CCW_REQUIRED,
-JSMSG_DEBUG_COMPARTMENT_MISMATCH,
-JSMSG_DEBUG_LOOP,
-JSMSG_DEBUG_NOT_DEBUGGEE,
-JSMSG_DEBUG_NOT_DEBUGGING,
-JSMSG_DEBUG_NOT_IDLE,
-JSMSG_DEBUG_NOT_LIVE,
-JSMSG_DEBUG_NO_ENV_OBJECT,
-JSMSG_DEBUG_PROTO,
-JSMSG_DEBUG_WRONG_OWNER,
-JSMSG_DEBUG_OPTIMIZED_OUT,
-JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED,
-JSMSG_DEBUG_VARIABLE_NOT_FOUND,
-JSMSG_DEBUG_WRAPPER_IN_WAY,
-JSMSG_DEBUGGEE_WOULD_RUN,
-JSMSG_NOT_CALLABLE_OR_UNDEFINED,
-JSMSG_NOT_TRACKING_ALLOCATIONS,
-JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET,
-JSMSG_QUERY_INNERMOST_WITHOUT_LINE_URL,
-JSMSG_QUERY_LINE_WITHOUT_URL,
-JSMSG_DEBUG_CANT_SET_OPT_ENV,
-JSMSG_DEBUG_INVISIBLE_COMPARTMENT,
-JSMSG_DEBUG_CENSUS_BREAKDOWN,
-JSMSG_DEBUG_PROMISE_NOT_RESOLVED,
-JSMSG_DEBUG_PROMISE_NOT_FULFILLED,
-JSMSG_DEBUG_PROMISE_NOT_REJECTED,
-
-
-JSMSG_TRACELOGGER_ENABLE_FAIL,
-
-
-JSMSG_DATE_NOT_FINITE,
-JSMSG_INTERNAL_INTL_ERROR,
-JSMSG_INTL_OBJECT_NOT_INITED,
-JSMSG_INVALID_CURRENCY_CODE,
-JSMSG_INVALID_DIGITS_VALUE,
-JSMSG_INVALID_KEYS_TYPE,
-JSMSG_INVALID_KEY,
-JSMSG_INVALID_LANGUAGE_TAG,
-JSMSG_INVALID_LOCALES_ELEMENT,
-JSMSG_INVALID_LOCALE_MATCHER,
-JSMSG_INVALID_OPTION_VALUE,
-JSMSG_INVALID_TIME_ZONE,
-JSMSG_UNDEFINED_CURRENCY,
-
-
-JSMSG_BACK_REF_OUT_OF_RANGE,
-JSMSG_BAD_CLASS_RANGE,
-JSMSG_ESCAPE_AT_END_OF_REGEXP,
-JSMSG_EXEC_NOT_OBJORNULL,
-JSMSG_INVALID_DECIMAL_ESCAPE,
-JSMSG_INVALID_GROUP,
-JSMSG_INVALID_IDENTITY_ESCAPE,
-JSMSG_INVALID_UNICODE_ESCAPE,
-JSMSG_MISSING_PAREN,
-JSMSG_NEWREGEXP_FLAGGED,
-JSMSG_NOTHING_TO_REPEAT,
-JSMSG_NUMBERS_OUT_OF_ORDER,
-JSMSG_RANGE_WITH_CLASS_ESCAPE,
-JSMSG_RAW_BRACE_IN_REGEP,
-JSMSG_RAW_BRACKET_IN_REGEP,
-JSMSG_TOO_MANY_PARENS,
-JSMSG_UNICODE_OVERFLOW,
-JSMSG_UNMATCHED_RIGHT_PAREN,
-JSMSG_UNTERM_CLASS,
-
-
-JSMSG_DEFAULT_LOCALE_ERROR,
-JSMSG_NO_SUCH_SELF_HOSTED_PROP,
-
-
-JSMSG_INVALID_PROTOTYPE,
-JSMSG_TYPEDOBJECT_BAD_ARGS,
-JSMSG_TYPEDOBJECT_BINARYARRAY_BAD_INDEX,
-JSMSG_TYPEDOBJECT_HANDLE_UNATTACHED,
-JSMSG_TYPEDOBJECT_STRUCTTYPE_BAD_ARGS,
-JSMSG_TYPEDOBJECT_TOO_BIG,
-JSMSG_SIMD_FAILED_CONVERSION,
-JSMSG_SIMD_TO_NUMBER,
-
-
-JSMSG_TOO_LONG_ARRAY,
-
-
-JSMSG_BAD_INDEX,
-JSMSG_NON_ARRAY_BUFFER_RETURNED,
-JSMSG_SAME_ARRAY_BUFFER_RETURNED,
-JSMSG_SHORT_ARRAY_BUFFER_RETURNED,
-JSMSG_TYPED_ARRAY_BAD_ARGS,
-JSMSG_TYPED_ARRAY_NEGATIVE_ARG,
-JSMSG_TYPED_ARRAY_DETACHED,
-JSMSG_TYPED_ARRAY_CONSTRUCT_BOUNDS,
-JSMSG_TYPED_ARRAY_CALL_OR_CONSTRUCT,
-JSMSG_NON_TYPED_ARRAY_RETURNED,
-JSMSG_SHORT_TYPED_ARRAY_RETURNED,
-
-
-JSMSG_SHARED_ARRAY_BAD_LENGTH,
-JSMSG_NON_SHARED_ARRAY_BUFFER_RETURNED,
-JSMSG_SAME_SHARED_ARRAY_BUFFER_RETURNED,
-JSMSG_SHORT_SHARED_ARRAY_BUFFER_RETURNED,
-
-
-JSMSG_BAD_PARSE_NODE,
-
-
-JSMSG_SYMBOL_TO_STRING,
-JSMSG_SYMBOL_TO_NUMBER,
-
-
-JSMSG_ATOMICS_BAD_ARRAY,
-JSMSG_ATOMICS_TOO_LONG,
-JSMSG_ATOMICS_WAIT_NOT_ALLOWED,
-
-
-JSMSG_CANT_SET_INTERPOSED,
-JSMSG_CANT_DEFINE_WINDOW_ELEMENT,
-JSMSG_CANT_DELETE_WINDOW_ELEMENT,
-JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY,
-JSMSG_CANT_PREVENT_EXTENSIONS,
-JSMSG_NO_NAMED_SETTER,
-JSMSG_NO_INDEXED_SETTER,
-
-
-JSMSG_CANT_DELETE_SUPER,
-JSMSG_REINIT_THIS,
-
-
-JSMSG_BAD_DEFAULT_EXPORT,
-JSMSG_MISSING_INDIRECT_EXPORT,
-JSMSG_AMBIGUOUS_INDIRECT_EXPORT,
-JSMSG_MISSING_IMPORT,
-JSMSG_AMBIGUOUS_IMPORT,
-JSMSG_MISSING_NAMESPACE_EXPORT,
-JSMSG_MISSING_EXPORT,
-JSMSG_MODULE_INSTANTIATE_FAILED,
-JSMSG_BAD_MODULE_STATE,
-
-
-JSMSG_CANNOT_RESOLVE_PROMISE_WITH_ITSELF,
-JSMSG_PROMISE_CAPABILITY_HAS_SOMETHING_ALREADY,
-JSMSG_PROMISE_RESOLVE_FUNCTION_NOT_CALLABLE,
-JSMSG_PROMISE_REJECT_FUNCTION_NOT_CALLABLE,
-JSMSG_PROMISE_ERROR_IN_WRAPPED_REJECTION_REASON,
-
-
-JSMSG_RETURN_NOT_CALLABLE,
-JSMSG_ITERATOR_NO_THROW,
-
-
-JSMSG_FOR_AWAIT_NOT_OF,
-JSMSG_NOT_AN_ASYNC_GENERATOR,
-JSMSG_NOT_AN_ASYNC_ITERATOR,
-JSMSG_GET_ASYNC_ITER_RETURNED_PRIMITIVE,
-# 1321 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h" 2
-
-    JSErr_Limit
-} JSErrNum;
-
-namespace js {
-
-extern const JSErrorFormatString*
-GetErrorMessage(void* userRef, const unsigned errorNumber);
-# 1342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-class AutoStableStringChars
-{
-
-
-
-
-
-    static const size_t InlineCapacity = 24;
-
-
-    JS::RootedString s_;
-    union {
-        const char16_t* twoByteChars_;
-        const JS::Latin1Char* latin1Chars_;
-    };
-    mozilla::Maybe<Vector<uint8_t, InlineCapacity>> ownChars_;
-    enum State { Uninitialized, Latin1, TwoByte };
-    State state_;
-
-  public:
-    explicit AutoStableStringChars(JSContext* cx)
-      : s_(cx), state_(Uninitialized)
-    {}
-
-    __attribute__ ((warn_unused_result))
-    bool init(JSContext* cx, JSString* s);
-
-
-    __attribute__ ((warn_unused_result))
-    bool initTwoByte(JSContext* cx, JSString* s);
-
-    bool isLatin1() const { return state_ == Latin1; }
-    bool isTwoByte() const { return state_ == TwoByte; }
-
-    const char16_t* twoByteChars() const {
-        do { } while (0);
-        return twoByteChars_;
-    }
-
-    mozilla::Range<const JS::Latin1Char> latin1Range() const {
-        do { } while (0);
-        return mozilla::Range<const JS::Latin1Char>(latin1Chars_,
-                                                    GetStringLength(s_));
-    }
-
-    mozilla::Range<const char16_t> twoByteRange() const {
-        do { } while (0);
-        return mozilla::Range<const char16_t>(twoByteChars_,
-                                              GetStringLength(s_));
-    }
-
-
-    bool maybeGiveOwnershipToCaller() {
-        do { } while (0);
-        if (!ownChars_.isSome() || !ownChars_->extractRawBuffer())
-            return false;
-        state_ = Uninitialized;
-        ownChars_.reset();
-        return true;
-    }
-
-  private:
-    AutoStableStringChars(const AutoStableStringChars& other) = delete;
-    void operator=(const AutoStableStringChars& other) = delete;
-
-    bool baseIsInline(JS::Handle<JSLinearString*> linearString);
-    template <typename T> T* allocOwnChars(JSContext* cx, size_t count);
-    bool copyLatin1Chars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
-    bool copyTwoByteChars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
-    bool copyAndInflateLatin1Chars(JSContext*, JS::Handle<JSLinearString*> linearString);
-};
-
-struct ErrorReport
-{
-    explicit ErrorReport(JSContext* cx);
-    ~ErrorReport();
-
-    enum SniffingBehavior {
-        WithSideEffects,
-        NoSideEffects
-    };
-# 1452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-    bool init(JSContext* cx, JS::HandleValue exn,
-              SniffingBehavior sniffingBehavior);
-
-    JSErrorReport* report()
-    {
-        return reportp;
-    }
-
-    const JS::ConstUTF8CharsZ toStringResult()
-    {
-        return toStringResult_;
-    }
-
-  private:
-
-
-
-
-
-
-    bool populateUncaughtExceptionReportUTF8(JSContext* cx, ...);
-    bool populateUncaughtExceptionReportUTF8VA(JSContext* cx, va_list ap);
-
-
-    void ReportAddonExceptionToTelementry(JSContext* cx);
-
-
-    JSErrorReport* reportp;
-
-
-    JSErrorReport ownedReport;
-
-
-
-    JS::RootedString str;
-
-
-    AutoStableStringChars strChars;
-
-
-    JS::RootedObject exnObject;
-
-
-    JSAutoByteString filename;
-
-
-
-
-    JS::ConstUTF8CharsZ toStringResult_;
-    JSAutoByteString toStringResultBytesStorage;
-};
-
-
-extern uint64_t
-GetSCOffset(JSStructuredCloneWriter* writer);
-
-namespace Scalar {
-
-
-
-
-
-
-
-enum Type {
-    Int8 = 0,
-    Uint8,
-    Int16,
-    Uint16,
-    Int32,
-    Uint32,
-    Float32,
-    Float64,
-
-
-
-
-
-    Uint8Clamped,
-
-
-
-
-    MaxTypedArrayViewType,
-
-    Int64,
-    Float32x4,
-    Int8x16,
-    Int16x8,
-    Int32x4
-};
-
-static inline size_t
-byteSize(Type atype)
-{
-    switch (atype) {
-      case Int8:
-      case Uint8:
-      case Uint8Clamped:
-        return 1;
-      case Int16:
-      case Uint16:
-        return 2;
-      case Int32:
-      case Uint32:
-      case Float32:
-        return 4;
-      case Int64:
-      case Float64:
-        return 8;
-      case Int8x16:
-      case Int16x8:
-      case Int32x4:
-      case Float32x4:
-        return 16;
-      default:
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1568; ::abort(); } while (0); } while (0);
-    }
-}
-
-static inline bool
-isSignedIntType(Type atype) {
-    switch (atype) {
-      case Int8:
-      case Int16:
-      case Int32:
-      case Int64:
-      case Int8x16:
-      case Int16x8:
-      case Int32x4:
-        return true;
-      case Uint8:
-      case Uint8Clamped:
-      case Uint16:
-      case Uint32:
-      case Float32:
-      case Float64:
-      case Float32x4:
-        return false;
-      default:
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1592; ::abort(); } while (0); } while (0);
-    }
-}
-
-static inline bool
-isSimdType(Type atype) {
-    switch (atype) {
-      case Int8:
-      case Uint8:
-      case Uint8Clamped:
-      case Int16:
-      case Uint16:
-      case Int32:
-      case Uint32:
-      case Int64:
-      case Float32:
-      case Float64:
-        return false;
-      case Int8x16:
-      case Int16x8:
-      case Int32x4:
-      case Float32x4:
-        return true;
-      case MaxTypedArrayViewType:
-        break;
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid scalar type" ")"); do { *((volatile int*) __null) = 1618; ::abort(); } while (0); } while (0);
-}
-
-static inline size_t
-scalarByteSize(Type atype) {
-    switch (atype) {
-      case Int8x16:
-        return 1;
-      case Int16x8:
-        return 2;
-      case Int32x4:
-      case Float32x4:
-        return 4;
-      case Int8:
-      case Uint8:
-      case Uint8Clamped:
-      case Int16:
-      case Uint16:
-      case Int32:
-      case Uint32:
-      case Int64:
-      case Float32:
-      case Float64:
-      case MaxTypedArrayViewType:
-        break;
-    }
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "invalid simd type" ")"); do { *((volatile int*) __null) = 1644; ::abort(); } while (0); } while (0);
-}
-
-}
-}
-
-
-
-
-
-
-
-extern JSObject*
-JS_NewInt8Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewUint8Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewUint8ClampedArray(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewInt16Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewUint16Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewInt32Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewUint32Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewFloat32Array(JSContext* cx, uint32_t nelements);
-extern JSObject*
-JS_NewFloat64Array(JSContext* cx, uint32_t nelements);
-# 1683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern JSObject*
-JS_NewInt8ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewUint8ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewUint8ClampedArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewInt16ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewUint16ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewInt32ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewUint32ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewFloat32ArrayFromArray(JSContext* cx, JS::HandleObject array);
-extern JSObject*
-JS_NewFloat64ArrayFromArray(JSContext* cx, JS::HandleObject array);
-# 1709 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern JSObject*
-JS_NewInt8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                          uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewUint8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                           uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewUint8ClampedArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                                  uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewInt16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                           uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewUint16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                            uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewInt32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                           uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewUint32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                            uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewFloat32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                             uint32_t byteOffset, int32_t length);
-extern JSObject*
-JS_NewFloat64ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
-                             uint32_t byteOffset, int32_t length);
-
-
-
-
-
-
-
-extern JSObject*
-JS_NewSharedArrayBuffer(JSContext* cx, uint32_t nbytes);
-
-
-
-
-extern JSObject*
-JS_NewArrayBuffer(JSContext* cx, uint32_t nbytes);
-
-
-
-
-
-
-
-extern bool
-JS_IsTypedArrayObject(JSObject* obj);
-# 1768 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_IsArrayBufferViewObject(JSObject* obj);
-
-
-
-
-
-extern bool
-JS_IsInt8Array(JSObject* obj);
-extern bool
-JS_IsUint8Array(JSObject* obj);
-extern bool
-JS_IsUint8ClampedArray(JSObject* obj);
-extern bool
-JS_IsInt16Array(JSObject* obj);
-extern bool
-JS_IsUint16Array(JSObject* obj);
-extern bool
-JS_IsInt32Array(JSObject* obj);
-extern bool
-JS_IsUint32Array(JSObject* obj);
-extern bool
-JS_IsFloat32Array(JSObject* obj);
-extern bool
-JS_IsFloat64Array(JSObject* obj);
-# 1802 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_GetTypedArraySharedness(JSObject* obj);
-
-
-
-
-
-
-namespace js {
-
-extern JSObject*
-UnwrapInt8Array(JSObject* obj);
-extern JSObject*
-UnwrapUint8Array(JSObject* obj);
-extern JSObject*
-UnwrapUint8ClampedArray(JSObject* obj);
-extern JSObject*
-UnwrapInt16Array(JSObject* obj);
-extern JSObject*
-UnwrapUint16Array(JSObject* obj);
-extern JSObject*
-UnwrapInt32Array(JSObject* obj);
-extern JSObject*
-UnwrapUint32Array(JSObject* obj);
-extern JSObject*
-UnwrapFloat32Array(JSObject* obj);
-extern JSObject*
-UnwrapFloat64Array(JSObject* obj);
-
-extern JSObject*
-UnwrapArrayBuffer(JSObject* obj);
-
-extern JSObject*
-UnwrapArrayBufferView(JSObject* obj);
-
-extern JSObject*
-UnwrapSharedArrayBuffer(JSObject* obj);
-
-
-namespace detail {
-
-extern const Class* const Int8ArrayClassPtr;
-extern const Class* const Uint8ArrayClassPtr;
-extern const Class* const Uint8ClampedArrayClassPtr;
-extern const Class* const Int16ArrayClassPtr;
-extern const Class* const Uint16ArrayClassPtr;
-extern const Class* const Int32ArrayClassPtr;
-extern const Class* const Uint32ArrayClassPtr;
-extern const Class* const Float32ArrayClassPtr;
-extern const Class* const Float64ArrayClassPtr;
-
-const size_t TypedArrayLengthSlot = 1;
-
-}
-# 1868 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-inline void GetInt8ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int8_t*>(GetObjectPrivate(obj)); }
-inline void GetUint8ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint8_t*>(GetObjectPrivate(obj)); }
-inline void GetUint8ClampedArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint8_t*>(GetObjectPrivate(obj)); }
-inline void GetInt16ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int16_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int16_t*>(GetObjectPrivate(obj)); }
-inline void GetUint16ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint16_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint16_t*>(GetObjectPrivate(obj)); }
-inline void GetInt32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, int32_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<int32_t*>(GetObjectPrivate(obj)); }
-inline void GetUint32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint32_t** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<uint32_t*>(GetObjectPrivate(obj)); }
-inline void GetFloat32ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, float** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<float*>(GetObjectPrivate(obj)); }
-inline void GetFloat64ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, double** data) { do { } while (0); const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); *isSharedMemory = JS_GetTypedArraySharedness(obj); *data = static_cast<double*>(GetObjectPrivate(obj)); }
-
-
-
-
-
-extern void
-GetArrayBufferViewLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-
-
-
-
-
-
-extern void
-GetArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-
-
-
-
-
-extern void
-GetSharedArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-
-}
-
-uint8_t*
-JS_GetSharedArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-
-
-
-
-
-
-extern JSObject*
-JS_GetObjectAsInt8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int8_t** data);
-extern JSObject*
-JS_GetObjectAsUint8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-extern JSObject*
-JS_GetObjectAsUint8ClampedArray(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-extern JSObject*
-JS_GetObjectAsInt16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int16_t** data);
-extern JSObject*
-JS_GetObjectAsUint16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint16_t** data);
-extern JSObject*
-JS_GetObjectAsInt32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int32_t** data);
-extern JSObject*
-JS_GetObjectAsUint32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint32_t** data);
-extern JSObject*
-JS_GetObjectAsFloat32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, float** data);
-extern JSObject*
-JS_GetObjectAsFloat64Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, double** data);
-extern JSObject*
-JS_GetObjectAsArrayBufferView(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
-
-
-
-
-extern JSObject*
-JS_GetObjectAsArrayBuffer(JSObject* obj, uint32_t* length, uint8_t** data);
-# 1944 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern js::Scalar::Type
-JS_GetArrayBufferViewType(JSObject* obj);
-
-extern js::Scalar::Type
-JS_GetSharedArrayBufferViewType(JSObject* obj);
-
-
-
-
-
-
-
-extern bool
-JS_IsArrayBufferObject(JSObject* obj);
-
-extern bool
-JS_IsSharedArrayBufferObject(JSObject* obj);
-# 1969 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern uint32_t
-JS_GetArrayBufferByteLength(JSObject* obj);
-
-extern uint32_t
-JS_GetSharedArrayBufferByteLength(JSObject* obj);
-# 1983 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-JS_ArrayBufferHasData(JSObject* obj);
-# 2000 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern uint8_t*
-JS_GetArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-
-
-
-
-
-
-extern bool
-JS_IsMappedArrayBufferObject(JSObject* obj);
-# 2018 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern uint32_t
-JS_GetTypedArrayLength(JSObject* obj);
-# 2029 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern uint32_t
-JS_GetTypedArrayByteOffset(JSObject* obj);
-# 2039 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern uint32_t
-JS_GetTypedArrayByteLength(JSObject* obj);
-
-
-
-
-
-
-extern bool
-JS_IsArrayBufferViewObject(JSObject* obj);
-
-
-
-
-extern uint32_t
-JS_GetArrayBufferViewByteLength(JSObject* obj);
-# 2071 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern int8_t*
-JS_GetInt8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern uint8_t*
-JS_GetUint8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern uint8_t*
-JS_GetUint8ClampedArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern int16_t*
-JS_GetInt16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern uint16_t*
-JS_GetUint16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern int32_t*
-JS_GetInt32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern uint32_t*
-JS_GetUint32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern float*
-JS_GetFloat32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-extern double*
-JS_GetFloat64ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-
-
-
-
-
-extern void*
-JS_GetArrayBufferViewData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-
-
-
-
-
-
-extern JSObject*
-JS_GetArrayBufferViewBuffer(JSContext* cx, JS::HandleObject obj, bool* isSharedMemory);
-
-
-
-
-
-
-
-extern bool
-JS_DetachArrayBuffer(JSContext* cx, JS::HandleObject obj);
-
-
-
-
-
-
-extern bool
-JS_IsDetachedArrayBufferObject(JSObject* obj);
-
-
-
-
-bool
-JS_IsDataViewObject(JSObject* obj);
-# 2135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-JSObject*
-JS_NewDataView(JSContext* cx, JS::HandleObject buffer, uint32_t byteOffset, int32_t byteLength);
-# 2146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-uint32_t
-JS_GetDataViewByteOffset(JSObject* obj);
-# 2157 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-uint32_t
-JS_GetDataViewByteLength(JSObject* obj);
-# 2171 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-void*
-JS_GetDataViewData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
-
-namespace js {
-# 2185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-WatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
-# 2196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-UnwatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
-
-namespace jit {
-
-enum class InlinableNative : uint16_t;
-
-}
-
-}
-
-
-
-
-
-class JSJitGetterCallArgs : protected JS::MutableHandleValue
-{
-  public:
-    explicit JSJitGetterCallArgs(const JS::CallArgs& args)
-      : JS::MutableHandleValue(args.rval())
-    {}
-
-    explicit JSJitGetterCallArgs(JS::RootedValue* rooted)
-      : JS::MutableHandleValue(rooted)
-    {}
-
-    JS::MutableHandleValue rval() {
-        return *this;
-    }
-};
-
-
-
-
-
-class JSJitSetterCallArgs : protected JS::MutableHandleValue
-{
-  public:
-    explicit JSJitSetterCallArgs(const JS::CallArgs& args)
-      : JS::MutableHandleValue(args[0])
-    {}
-
-    JS::MutableHandleValue operator[](unsigned i) {
-        do { } while (0);
-        return *this;
-    }
-
-    unsigned length() const { return 1; }
-
-
-};
-
-struct JSJitMethodCallArgsTraits;
-
-
-
-
-
-class JSJitMethodCallArgs : protected JS::detail::CallArgsBase<JS::detail::NoUsedRval>
-{
-  private:
-    typedef JS::detail::CallArgsBase<JS::detail::NoUsedRval> Base;
-    friend struct JSJitMethodCallArgsTraits;
-
-  public:
-    explicit JSJitMethodCallArgs(const JS::CallArgs& args) {
-        argv_ = args.array();
-        argc_ = args.length();
-    }
-
-    JS::MutableHandleValue rval() const {
-        return Base::rval();
-    }
-
-    unsigned length() const { return Base::length(); }
-
-    JS::MutableHandleValue operator[](unsigned i) const {
-        return Base::operator[](i);
-    }
-
-    bool hasDefined(unsigned i) const {
-        return Base::hasDefined(i);
-    }
-
-    JSObject& callee() const {
-
-
-        return argv_[-2].toObject();
-    }
-
-    JS::HandleValue get(unsigned i) const {
-        return Base::get(i);
-    }
-};
-
-struct JSJitMethodCallArgsTraits
-{
-    static const size_t offsetOfArgv = __builtin_offsetof(JSJitMethodCallArgs, argv_);
-    static const size_t offsetOfArgc = __builtin_offsetof(JSJitMethodCallArgs, argc_);
-};
-
-typedef bool
-(* JSJitGetterOp)(JSContext* cx, JS::HandleObject thisObj,
-                  void* specializedThis, JSJitGetterCallArgs args);
-typedef bool
-(* JSJitSetterOp)(JSContext* cx, JS::HandleObject thisObj,
-                  void* specializedThis, JSJitSetterCallArgs args);
-typedef bool
-(* JSJitMethodOp)(JSContext* cx, JS::HandleObject thisObj,
-                  void* specializedThis, const JSJitMethodCallArgs& args);
-
-
-
-
-
-
-struct JSJitInfo {
-    enum OpType {
-        Getter,
-        Setter,
-        Method,
-        StaticMethod,
-        InlinableNative,
-        IgnoresReturnValueNative,
-
-        OpTypeCount
-    };
-
-    enum ArgType {
-
-        String = (1 << 0),
-        Integer = (1 << 1),
-        Double = (1 << 2),
-        Boolean = (1 << 3),
-        Object = (1 << 4),
-        Null = (1 << 5),
-
-
-        Numeric = Integer | Double,
-
-
-        Primitive = Numeric | Boolean | Null | String,
-        ObjectOrNull = Object | Null,
-        Any = ObjectOrNull | Primitive,
-
-
-        ArgTypeListEnd = (1 << 31)
-    };
-
-    static_assert(Any & String, "Any must include String.");
-    static_assert(Any & Integer, "Any must include Integer.");
-    static_assert(Any & Double, "Any must include Double.");
-    static_assert(Any & Boolean, "Any must include Boolean.");
-    static_assert(Any & Object, "Any must include Object.");
-    static_assert(Any & Null, "Any must include Null.");
-
-
-
-
-
-
-    enum AliasSet {
-
-
-
-
-        AliasNone,
-
-
-
-
-
-        AliasDOMSets,
-
-
-
-
-
-        AliasEverything,
-
-
-        AliasSetCount
-    };
-
-    bool needsOuterizedThisObject() const
-    {
-        return type() != Getter && type() != Setter;
-    }
-
-    bool isTypedMethodJitInfo() const
-    {
-        return isTypedMethod;
-    }
-
-    OpType type() const
-    {
-        return OpType(type_);
-    }
-
-    AliasSet aliasSet() const
-    {
-        return AliasSet(aliasSet_);
-    }
-
-    JSValueType returnType() const
-    {
-        return JSValueType(returnType_);
-    }
-
-    union {
-        JSJitGetterOp getter;
-        JSJitSetterOp setter;
-        JSJitMethodOp method;
-
-        JSNative staticMethod;
-        JSNative ignoresReturnValueMethod;
-    };
-
-    static unsigned offsetOfIgnoresReturnValueNative() {
-        return __builtin_offsetof(JSJitInfo, ignoresReturnValueMethod);
-    }
-
-    union {
-        uint16_t protoID;
-        js::jit::InlinableNative inlinableNative;
-    };
-
-    union {
-        uint16_t depth;
-
-
-        uint16_t nativeOp;
-    };
-# 2440 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-    uint32_t type_ : 4;
-
-
-
-
-
-
-
-    uint32_t aliasSet_ : 4;
-
-
-    uint32_t returnType_ : 8;
-
-    static_assert(OpTypeCount <= (1 << 4),
-                  "Not enough space for OpType");
-    static_assert(AliasSetCount <= (1 << 4),
-                  "Not enough space for AliasSet");
-    static_assert((sizeof(JSValueType) * 8) <= 8,
-                  "Not enough space for JSValueType");
-
-
-
-
-
-
-    uint32_t isInfallible : 1;
-
-
-
-
-
-
-
-    uint32_t isMovable : 1;
-
-
-
-
-
-
-    uint32_t isEliminatable : 1;
-
-
-
-
-
-
-    uint32_t isAlwaysInSlot : 1;
-
-
-
-
-
-    uint32_t isLazilyCachedInSlot : 1;
-
-
-    uint32_t isTypedMethod : 1;
-
-
-
-
-
-
-    uint32_t slotIndex : 10;
-
-    static const size_t maxSlotIndex = (1 << 10) - 1;
-
-
-};
-
-static_assert(sizeof(JSJitInfo) == (sizeof(void*) + 2 * sizeof(uint32_t)),
-              "There are several thousand instances of JSJitInfo stored in "
-              "a binary. Please don't increase its space requirements without "
-              "verifying that there is no other way forward (better packing, "
-              "smaller datatypes for fields, subclassing, etc.).");
-
-struct JSTypedMethodJitInfo
-{
-# 2526 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-    JSJitInfo base;
-
-    const JSJitInfo::ArgType* const argTypes;
-
-
-
-
-
-};
-
-namespace js {
-
-static __attribute__((always_inline)) inline shadow::Function*
-FunctionObjectToShadowFunction(JSObject* fun)
-{
-    do { } while (0);
-    return reinterpret_cast<shadow::Function*>(fun);
-}
-
-
-static const unsigned JS_FUNCTION_INTERPRETED_BITS = 0x0201;
-
-
-static __attribute__((always_inline)) inline bool
-FunctionObjectIsNative(JSObject* fun)
-{
-    return !(FunctionObjectToShadowFunction(fun)->flags & JS_FUNCTION_INTERPRETED_BITS);
-}
-
-static __attribute__((always_inline)) inline JSNative
-GetFunctionObjectNative(JSObject* fun)
-{
-    do { } while (0);
-    return FunctionObjectToShadowFunction(fun)->native;
-}
-
-}
-
-static __attribute__((always_inline)) inline const JSJitInfo*
-FUNCTION_VALUE_TO_JITINFO(const JS::Value& v)
-{
-    do { } while (0);
-    return js::FunctionObjectToShadowFunction(&v.toObject())->jitinfo;
-}
-
-static __attribute__((always_inline)) inline void
-SET_JITINFO(JSFunction * func, const JSJitInfo* info)
-{
-    js::shadow::Function* fun = reinterpret_cast<js::shadow::Function*>(func);
-    do { } while (0);
-    fun->jitinfo = info;
-}
-
-
-
-
-
-
-static __attribute__((always_inline)) inline jsid
-JSID_FROM_BITS(size_t bits)
-{
-    jsid id;
-    (id.asBits) = bits;
-    return id;
-}
-
-namespace js {
-namespace detail {
-bool IdMatchesAtom(jsid id, JSAtom* atom);
-}
-}
-# 2619 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-static __attribute__((always_inline)) inline jsid
-NON_INTEGER_ATOM_TO_JSID(JSAtom* atom)
-{
-    do { } while (0);
-    jsid id = JSID_FROM_BITS((size_t)atom);
-    do { } while (0);
-    return id;
-}
-
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_ATOM(jsid id)
-{
-    return JSID_IS_STRING(id);
-}
-
-static __attribute__((always_inline)) inline bool
-JSID_IS_ATOM(jsid id, JSAtom* atom)
-{
-    return id == JSID_FROM_BITS((size_t)atom);
-}
-
-static __attribute__((always_inline)) inline JSAtom*
-JSID_TO_ATOM(jsid id)
-{
-    return (JSAtom*)JSID_TO_STRING(id);
-}
-
-static_assert(sizeof(jsid) == sizeof(void*), "JS_STATIC_ASSERT");
-
-namespace js {
-
-static __attribute__((always_inline)) inline JS::Value
-IdToValue(jsid id)
-{
-    if (JSID_IS_STRING(id))
-        return JS::StringValue(JSID_TO_STRING(id));
-    if (JSID_IS_INT(id))
-        return JS::Int32Value(JSID_TO_INT(id));
-    if (JSID_IS_SYMBOL(id))
-        return JS::SymbolValue(JSID_TO_SYMBOL(id));
-    do { } while (0);
-    return JS::UndefinedValue();
-}
-# 2681 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-struct ScriptEnvironmentPreparer {
-    struct Closure {
-        virtual bool operator()(JSContext* cx) = 0;
-    };
-
-    virtual void invoke(JS::HandleObject scope, Closure& closure) = 0;
-};
-
-extern void
-PrepareScriptEnvironmentAndInvoke(JSContext* cx, JS::HandleObject scope,
-                                  ScriptEnvironmentPreparer::Closure& closure);
-
-void
-SetScriptEnvironmentPreparer(JSContext* cx, ScriptEnvironmentPreparer* preparer);
-
-enum CTypesActivityType {
-    CTYPES_CALL_BEGIN,
-    CTYPES_CALL_END,
-    CTYPES_CALLBACK_BEGIN,
-    CTYPES_CALLBACK_END
-};
-
-typedef void
-(* CTypesActivityCallback)(JSContext* cx, CTypesActivityType type);
-
-
-
-
-
-void
-SetCTypesActivityCallback(JSContext* cx, CTypesActivityCallback cb);
-
-class AutoCTypesActivityCallback {
-  private:
-    JSContext* cx;
-    CTypesActivityCallback callback;
-    CTypesActivityType endType;
-
-
-  public:
-    AutoCTypesActivityCallback(JSContext* cx, CTypesActivityType beginType,
-                               CTypesActivityType endType
-                                                              );
-    ~AutoCTypesActivityCallback() {
-        DoEndCallback();
-    }
-    void DoEndCallback() {
-        if (callback) {
-            callback(cx, endType);
-            callback = nullptr;
-        }
-    }
-};
-
-
-
-struct AllocationMetadataBuilder {
-    AllocationMetadataBuilder() { }
-
-
-
-
-
-
-
-    virtual JSObject* build(JSContext* cx, JS::HandleObject obj,
-                            AutoEnterOOMUnsafeRegion& oomUnsafe) const
-    {
-        return nullptr;
-    }
-};
-
-
-
-
-
-
-void
-SetAllocationMetadataBuilder(JSContext* cx, const AllocationMetadataBuilder *callback);
-
-
-JSObject*
-GetAllocationMetadata(JSObject* obj);
-
-bool
-GetElementsWithAdder(JSContext* cx, JS::HandleObject obj, JS::HandleObject receiver,
-                     uint32_t begin, uint32_t end, js::ElementAdder* adder);
-
-bool
-ForwardToNative(JSContext* cx, JSNative native, const JS::CallArgs& args);
-# 2792 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-bool
-SetPropertyIgnoringNamedGetter(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
-                               JS::HandleValue v, JS::HandleValue receiver,
-                               JS::Handle<JS::PropertyDescriptor> ownDesc,
-                               JS::ObjectOpResult& result);
-
-
-extern bool
-ExecuteInGlobalAndReturnScope(JSContext* cx, JS::HandleObject obj, JS::HandleScript script,
-                              JS::MutableHandleObject scope);
-# 2838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern JSObject*
-GetNearestEnclosingWithEnvironmentObjectForFunction(JSFunction* fun);
-# 2849 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern JSObject*
-GetFirstSubsumedSavedFrame(JSContext* cx, JS::HandleObject savedFrame, JS::SavedFrameSelfHosted selfHosted);
-
-extern bool
-ReportIsNotFunction(JSContext* cx, JS::HandleValue v);
-
-extern JSObject*
-ConvertArgsToArray(JSContext* cx, const JS::CallArgs& args);
-# 2878 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern void
-SetWindowProxyClass(JSContext* cx, const Class* clasp);
-
-
-
-
-
-extern void
-SetWindowProxy(JSContext* cx, JS::HandleObject global, JS::HandleObject windowProxy);
-
-namespace detail {
-
-bool
-IsWindowSlow(JSObject* obj);
-
-}
-
-
-
-
-
-inline bool
-IsWindow(JSObject* obj)
-{
-    if (GetObjectClass(obj)->flags & (1<<((8 + 8)+1)))
-        return detail::IsWindowSlow(obj);
-    return false;
-}
-
-
-
-
-bool
-IsWindowProxy(JSObject* obj);
-
-
-
-
-
-
-extern JSObject*
-ToWindowProxyIfWindow(JSObject* obj);
-
-
-
-
-
-
-extern JSObject*
-ToWindowIfWindowProxy(JSObject* obj);
-
-
-
-
-extern bool
-AddPluralRulesConstructor(JSContext* cx, JS::Handle<JSObject*> intl);
-# 2947 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jsfriendapi.h"
-extern bool
-AddMozDateTimeFormatConstructor(JSContext* cx, JS::Handle<JSObject*> intl);
-
-class AutoAssertNoContentJS
-{
-  public:
-    explicit AutoAssertNoContentJS(JSContext* cx);
-    ~AutoAssertNoContentJS();
-
-  private:
-    JSContext* context_;
-    bool prevAllowContentJS_;
-};
-
-
-
-
-
-extern void
-EnableAccessValidation(JSContext* cx, bool enabled);
-
-
-
-
-
-extern void
-SetCompartmentValidAccessPtr(JSContext* cx, JS::HandleObject global, bool* accessp);
-
-}
-
-class NativeProfiler
-{
-  public:
-    virtual ~NativeProfiler() {};
-    virtual void sampleNative(void* addr, uint32_t size) = 0;
-    virtual void removeNative(void* addr) = 0;
-    virtual void reset() = 0;
-};
-
-class GCHeapProfiler
-{
-  public:
-    virtual ~GCHeapProfiler() {};
-    virtual void sampleTenured(void* addr, uint32_t size) = 0;
-    virtual void sampleNursery(void* addr, uint32_t size) = 0;
-    virtual void markTenuredStart() = 0;
-    virtual void markTenured(void* addr) = 0;
-    virtual void sweepTenured() = 0;
-    virtual void sweepNursery() = 0;
-    virtual void moveNurseryToTenured(void* addrOld, void* addrNew) = 0;
-    virtual void reset() = 0;
-};
-
-class MemProfiler
-{
-    static mozilla::Atomic<uint32_t, mozilla::Relaxed> sActiveProfilerCount;
-    static NativeProfiler* sNativeProfiler;
-
-    static GCHeapProfiler* GetGCHeapProfiler(void* addr);
-    static GCHeapProfiler* GetGCHeapProfiler(JSRuntime* runtime);
-
-    static NativeProfiler* GetNativeProfiler() {
-        return sNativeProfiler;
-    }
-
-    GCHeapProfiler* mGCHeapProfiler;
-    JSRuntime* mRuntime;
-
-  public:
-    explicit MemProfiler(JSRuntime* aRuntime) : mGCHeapProfiler(nullptr), mRuntime(aRuntime) {}
-
-    void start(GCHeapProfiler* aGCHeapProfiler);
-    void stop();
-
-    GCHeapProfiler* getGCHeapProfiler() const {
-        return mGCHeapProfiler;
-    }
-
-    static __attribute__((always_inline)) inline bool enabled() {
-        return sActiveProfilerCount > 0;
-    }
-
-    static MemProfiler* GetMemProfiler(JSContext* context);
-
-    static void SetNativeProfiler(NativeProfiler* aProfiler) {
-        sNativeProfiler = aProfiler;
-    }
-
-    static __attribute__((always_inline)) inline void SampleNative(void* addr, uint32_t size) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        NativeProfiler* profiler = GetNativeProfiler();
-        if (profiler)
-            profiler->sampleNative(addr, size);
-    }
-
-    static __attribute__((always_inline)) inline void SampleTenured(void* addr, uint32_t size) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
-        if (profiler)
-            profiler->sampleTenured(addr, size);
-    }
-
-    static __attribute__((always_inline)) inline void SampleNursery(void* addr, uint32_t size) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
-        if (profiler)
-            profiler->sampleNursery(addr, size);
-    }
-
-    static __attribute__((always_inline)) inline void RemoveNative(void* addr) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        NativeProfiler* profiler = GetNativeProfiler();
-        if (profiler)
-            profiler->removeNative(addr);
-    }
-
-    static __attribute__((always_inline)) inline void MarkTenuredStart(JSRuntime* runtime) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
-        if (profiler)
-            profiler->markTenuredStart();
-    }
-
-    static __attribute__((always_inline)) inline void MarkTenured(void* addr) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
-        if (profiler)
-            profiler->markTenured(addr);
-    }
-
-    static __attribute__((always_inline)) inline void SweepTenured(JSRuntime* runtime) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
-        if (profiler)
-            profiler->sweepTenured();
-    }
-
-    static __attribute__((always_inline)) inline void SweepNursery(JSRuntime* runtime) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
-        if (profiler)
-            profiler->sweepNursery();
-    }
-
-    static __attribute__((always_inline)) inline void MoveNurseryToTenured(void* addrOld, void* addrNew) {
-        JS::AutoSuppressGCAnalysis nogc;
-
-        if ((__builtin_expect(!!(!enabled()), 1)))
-            return;
-
-        GCHeapProfiler* profiler = GetGCHeapProfiler(addrOld);
-        if (profiler)
-            profiler->moveNurseryToTenured(addrOld, addrNew);
-    }
-};
-# 8 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FakeString.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/FakeString.h"
-namespace mozilla {
-namespace dom {
-namespace binding_detail {
-
-
-
-struct FakeString {
-  FakeString() :
-    mFlags(nsString::F_TERMINATED)
-  {
-  }
-
-  ~FakeString() {
-    if (mFlags & nsString::F_SHARED) {
-      nsStringBuffer::FromData(mData)->Release();
-    }
-  }
-
-  void Rebind(const nsString::char_type* aData, nsString::size_type aLength) {
-    do { } while (0);
-    mData = const_cast<nsString::char_type*>(aData);
-    mLength = aLength;
-  }
-
-
-
-
-  void ShareOrDependUpon(const nsAString& aString) {
-    RefPtr<nsStringBuffer> sharedBuffer = nsStringBuffer::FromString(aString);
-    if (!sharedBuffer) {
-      Rebind(aString.Data(), aString.Length());
-    } else {
-      AssignFromStringBuffer(sharedBuffer.forget());
-      mLength = aString.Length();
-    }
-  }
-
-  void Truncate() {
-    do { } while (0);
-    mData = nsString::char_traits::sEmptyBuffer;
-    mLength = 0;
-  }
-
-  void SetIsVoid(bool aValue) {
-    do { } while (0);
-
-    Truncate();
-    mFlags |= nsString::F_VOIDED;
-  }
-
-  const nsString::char_type* Data() const
-  {
-    return mData;
-  }
-
-  nsString::char_type* BeginWriting()
-  {
-    return mData;
-  }
-
-  nsString::size_type Length() const
-  {
-    return mLength;
-  }
-
-
-  bool SetLength(nsString::size_type aLength, mozilla::fallible_t const&) {
-
-    if (aLength < sInlineCapacity) {
-      SetData(mInlineStorage);
-    } else {
-      RefPtr<nsStringBuffer> buf = nsStringBuffer::Alloc((aLength + 1) * sizeof(nsString::char_type));
-      if ((__builtin_expect(!!(!buf), 0))) {
-        return false;
-      }
-
-      AssignFromStringBuffer(buf.forget());
-    }
-    mLength = aLength;
-    mData[mLength] = char16_t(0);
-    return true;
-  }
-
-
-
-  const nsAString* ToAStringPtr() const {
-    return reinterpret_cast<const nsString*>(this);
-  }
-
-operator const nsAString& () const {
-    return *reinterpret_cast<const nsString*>(this);
-  }
-
-private:
-  nsAString* ToAStringPtr() {
-    return reinterpret_cast<nsString*>(this);
-  }
-
-  nsString::char_type* mData;
-  nsString::size_type mLength;
-  uint32_t mFlags;
-
-  static const size_t sInlineCapacity = 64;
-  nsString::char_type mInlineStorage[sInlineCapacity];
-
-  FakeString(const FakeString& other) = delete;
-  void operator=(const FakeString& other) = delete;
-
-  void SetData(nsString::char_type* aData) {
-    do { } while (0);
-    mData = const_cast<nsString::char_type*>(aData);
-  }
-  void AssignFromStringBuffer(already_AddRefed<nsStringBuffer> aBuffer) {
-    SetData(static_cast<nsString::char_type*>(aBuffer.take()->Data()));
-    mFlags = nsString::F_SHARED | nsString::F_TERMINATED;
-  }
-
-  friend class NonNull<nsAString>;
-
-
-
-  class StringAsserter;
-  friend class StringAsserter;
-
-  class StringAsserter : public nsString {
-  public:
-    static void StaticAsserts() {
-      static_assert(__builtin_offsetof(FakeString, mInlineStorage) ==
-                      sizeof(nsString),
-                    "FakeString should include all nsString members");
-      static_assert(__builtin_offsetof(FakeString, mData) ==
-                      __builtin_offsetof(StringAsserter, mData),
-                    "Offset of mData should match");
-      static_assert(__builtin_offsetof(FakeString, mLength) ==
-                      __builtin_offsetof(StringAsserter, mLength),
-                    "Offset of mLength should match");
-      static_assert(__builtin_offsetof(FakeString, mFlags) ==
-                      __builtin_offsetof(StringAsserter, mFlags),
-                    "Offset of mFlags should match");
-    }
-  };
-};
-}
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h"
-namespace mozilla {
-namespace dom {
-
-
-
-
-struct TypedArrayObjectStorage : AllTypedArraysBase {
-protected:
-  JSObject* mTypedObj;
-  JSObject* mWrappedObj;
-
-  TypedArrayObjectStorage()
-    : mTypedObj(nullptr),
-      mWrappedObj(nullptr)
-  {
-  }
-
-  TypedArrayObjectStorage(TypedArrayObjectStorage&& aOther)
-    : mTypedObj(aOther.mTypedObj),
-      mWrappedObj(aOther.mWrappedObj)
-  {
-    aOther.mTypedObj = nullptr;
-    aOther.mWrappedObj = nullptr;
-  }
-
-public:
-  inline void TraceSelf(JSTracer* trc)
-  {
-    JS::UnsafeTraceRoot(trc, &mTypedObj, "TypedArray.mTypedObj");
-    JS::UnsafeTraceRoot(trc, &mTypedObj, "TypedArray.mWrappedObj");
-  }
-
-private:
-  TypedArrayObjectStorage(const TypedArrayObjectStorage&) = delete;
-};
-
-
-
-
-
-
-
-template<typename T,
-         JSObject* UnwrapArray(JSObject*),
-         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*, T**)>
-struct TypedArray_base : public TypedArrayObjectStorage {
-  typedef T element_type;
-
-  TypedArray_base()
-    : mData(nullptr),
-      mLength(0),
-      mShared(false),
-      mComputed(false)
-  {
-  }
-
-  TypedArray_base(TypedArray_base&& aOther)
-    : TypedArrayObjectStorage(Move(aOther)),
-      mData(aOther.mData),
-      mLength(aOther.mLength),
-      mShared(aOther.mShared),
-      mComputed(aOther.mComputed)
-  {
-    aOther.mData = nullptr;
-    aOther.mLength = 0;
-    aOther.mShared = false;
-    aOther.mComputed = false;
-  }
-
-private:
-  mutable T* mData;
-  mutable uint32_t mLength;
-  mutable bool mShared;
-  mutable bool mComputed;
-
-public:
-  inline bool Init(JSObject* obj)
-  {
-    do { } while (0);
-    mTypedObj = mWrappedObj = UnwrapArray(obj);
-    return inited();
-  }
-
-  inline bool inited() const {
-    return !!mTypedObj;
-  }
-# 147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/TypedArray.h"
-  inline bool IsShared() const {
-    do { } while (0);
-    return mShared;
-  }
-
-  inline T *Data() const {
-    do { } while (0);
-    if (mShared)
-      return nullptr;
-    return mData;
-  }
-
-  inline T *DataAllowShared() const {
-    do { } while (0);
-    return mData;
-  }
-
-  inline uint32_t Length() const {
-    do { } while (0);
-    if (mShared)
-      return 0;
-    return mLength;
-  }
-
-  inline uint32_t LengthAllowShared() const {
-    do { } while (0);
-    return mLength;
-  }
-
-  inline JSObject *Obj() const {
-    do { } while (0);
-    return mWrappedObj;
-  }
-
-  inline bool WrapIntoNewCompartment(JSContext* cx)
-  {
-    return JS_WrapObject(cx,
-      JS::MutableHandle<JSObject*>::fromMarkedLocation(&mWrappedObj));
-  }
-
-  inline void ComputeLengthAndData() const
-  {
-    do { } while (0);
-    do { } while (0);
-    GetLengthAndDataAndSharedness(mTypedObj, &mLength, &mShared, &mData);
-    mComputed = true;
-  }
-
-private:
-  TypedArray_base(const TypedArray_base&) = delete;
-};
-
-template<typename T,
-         JSObject* UnwrapArray(JSObject*),
-         T* GetData(JSObject*, bool* isShared, const JS::AutoCheckCannotGC&),
-         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*, T**),
-         JSObject* CreateNew(JSContext*, uint32_t)>
-struct TypedArray
-  : public TypedArray_base<T, UnwrapArray, GetLengthAndDataAndSharedness>
-{
-private:
-  typedef TypedArray_base<T, UnwrapArray, GetLengthAndDataAndSharedness> Base;
-
-public:
-  TypedArray()
-    : Base()
-  {}
-
-  TypedArray(TypedArray&& aOther)
-    : Base(Move(aOther))
-  {
-  }
-
-  static inline JSObject*
-  Create(JSContext* cx, nsWrapperCache* creator, uint32_t length,
-         const T* data = nullptr) {
-    JS::Rooted<JSObject*> creatorWrapper(cx);
-    Maybe<JSAutoCompartment> ac;
-    if (creator && (creatorWrapper = creator->GetWrapperPreserveColor())) {
-      ac.emplace(cx, creatorWrapper);
-    }
-
-    return CreateCommon(cx, length, data);
-  }
-
-  static inline JSObject*
-  Create(JSContext* cx, uint32_t length, const T* data = nullptr) {
-    return CreateCommon(cx, length, data);
-  }
-
-private:
-  static inline JSObject*
-  CreateCommon(JSContext* cx, uint32_t length, const T* data) {
-    JSObject* obj = CreateNew(cx, length);
-    if (!obj) {
-      return nullptr;
-    }
-    if (data) {
-      JS::AutoCheckCannotGC nogc;
-      bool isShared;
-      T* buf = static_cast<T*>(GetData(obj, &isShared, nogc));
-
-
-      do { } while (0);
-      memcpy(buf, data, length*sizeof(T));
-    }
-    return obj;
-  }
-
-  TypedArray(const TypedArray&) = delete;
-};
-
-template<JSObject* UnwrapArray(JSObject*),
-         void GetLengthAndDataAndSharedness(JSObject*, uint32_t*, bool*,
-                                            uint8_t**),
-         js::Scalar::Type GetViewType(JSObject*)>
-struct ArrayBufferView_base
-  : public TypedArray_base<uint8_t, UnwrapArray, GetLengthAndDataAndSharedness>
-{
-private:
-  typedef TypedArray_base<uint8_t, UnwrapArray, GetLengthAndDataAndSharedness>
-          Base;
-
-public:
-  ArrayBufferView_base()
-    : Base()
-  {
-  }
-
-  ArrayBufferView_base(ArrayBufferView_base&& aOther)
-    : Base(Move(aOther)),
-      mType(aOther.mType)
-  {
-    aOther.mType = js::Scalar::MaxTypedArrayViewType;
-  }
-
-private:
-  js::Scalar::Type mType;
-
-public:
-  inline bool Init(JSObject* obj)
-  {
-    if (!Base::Init(obj)) {
-      return false;
-    }
-
-    mType = GetViewType(this->Obj());
-    return true;
-  }
-
-  inline js::Scalar::Type Type() const
-  {
-    do { } while (0);
-    return mType;
-  }
-};
-
-typedef TypedArray<int8_t, js::UnwrapInt8Array, JS_GetInt8ArrayData,
-                   js::GetInt8ArrayLengthAndData, JS_NewInt8Array>
-        Int8Array;
-typedef TypedArray<uint8_t, js::UnwrapUint8Array, JS_GetUint8ArrayData,
-                   js::GetUint8ArrayLengthAndData, JS_NewUint8Array>
-        Uint8Array;
-typedef TypedArray<uint8_t, js::UnwrapUint8ClampedArray, JS_GetUint8ClampedArrayData,
-                   js::GetUint8ClampedArrayLengthAndData, JS_NewUint8ClampedArray>
-        Uint8ClampedArray;
-typedef TypedArray<int16_t, js::UnwrapInt16Array, JS_GetInt16ArrayData,
-                   js::GetInt16ArrayLengthAndData, JS_NewInt16Array>
-        Int16Array;
-typedef TypedArray<uint16_t, js::UnwrapUint16Array, JS_GetUint16ArrayData,
-                   js::GetUint16ArrayLengthAndData, JS_NewUint16Array>
-        Uint16Array;
-typedef TypedArray<int32_t, js::UnwrapInt32Array, JS_GetInt32ArrayData,
-                   js::GetInt32ArrayLengthAndData, JS_NewInt32Array>
-        Int32Array;
-typedef TypedArray<uint32_t, js::UnwrapUint32Array, JS_GetUint32ArrayData,
-                   js::GetUint32ArrayLengthAndData, JS_NewUint32Array>
-        Uint32Array;
-typedef TypedArray<float, js::UnwrapFloat32Array, JS_GetFloat32ArrayData,
-                   js::GetFloat32ArrayLengthAndData, JS_NewFloat32Array>
-        Float32Array;
-typedef TypedArray<double, js::UnwrapFloat64Array, JS_GetFloat64ArrayData,
-                   js::GetFloat64ArrayLengthAndData, JS_NewFloat64Array>
-        Float64Array;
-typedef ArrayBufferView_base<js::UnwrapArrayBufferView,
-                             js::GetArrayBufferViewLengthAndData,
-                             JS_GetArrayBufferViewType>
-        ArrayBufferView;
-typedef TypedArray<uint8_t, js::UnwrapArrayBuffer, JS_GetArrayBufferData,
-                   js::GetArrayBufferLengthAndData, JS_NewArrayBuffer>
-        ArrayBuffer;
-
-typedef TypedArray<uint8_t, js::UnwrapSharedArrayBuffer, JS_GetSharedArrayBufferData,
-                   js::GetSharedArrayBufferLengthAndData, JS_NewSharedArrayBuffer>
-        SharedArrayBuffer;
-
-
-
-
-
-template<typename TypedArrayType>
-class TypedArrayCreator
-{
-  typedef nsTArray<typename TypedArrayType::element_type> ArrayType;
-
-  public:
-    explicit TypedArrayCreator(const ArrayType& aArray)
-      : mArray(aArray)
-    {}
-
-    JSObject* Create(JSContext* aCx) const
-    {
-      return TypedArrayType::Create(aCx, mArray.Length(), mArray.Elements());
-    }
-
-  private:
-    const ArrayType& mArray;
-};
-
-
-template<typename ArrayType>
-class TypedArrayRooter : private JS::CustomAutoRooter
-{
-public:
-  template <typename CX>
-  TypedArrayRooter(const CX& cx,
-                   ArrayType* aArray ) :
-    JS::CustomAutoRooter(cx ),
-    mArray(aArray)
-  {
-  }
-
-  virtual void trace(JSTracer* trc) override
-  {
-    mArray->TraceSelf(trc);
-  }
-
-private:
-  TypedArrayObjectStorage* const mArray;
-};
-
-
-template<typename Inner> struct Nullable;
-template<typename ArrayType>
-class TypedArrayRooter<Nullable<ArrayType> > :
-    private JS::CustomAutoRooter
-{
-public:
-  template <typename CX>
-  TypedArrayRooter(const CX& cx,
-                   Nullable<ArrayType>* aArray ) :
-    JS::CustomAutoRooter(cx ),
-    mArray(aArray)
-  {
-  }
-
-  virtual void trace(JSTracer* trc) override
-  {
-    if (!mArray->IsNull()) {
-      mArray->Value().TraceSelf(trc);
-    }
-  }
-
-private:
-  Nullable<ArrayType>* const mArray;
-};
-
-
-template<typename ArrayType>
-class RootedTypedArray final : public ArrayType,
-                                        private TypedArrayRooter<ArrayType>
-{
-public:
-  template <typename CX>
-  explicit RootedTypedArray(const CX& cx ) :
-    ArrayType(),
-    TypedArrayRooter<ArrayType>(cx, this
-                                                                         )
-  {
-  }
-
-  template <typename CX>
-  RootedTypedArray(const CX& cx, JSObject* obj ) :
-    ArrayType(obj),
-    TypedArrayRooter<ArrayType>(cx, this
-                                                                         )
-  {
-  }
-};
-
-}
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UnionMember.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UnionMember.h"
-namespace mozilla {
-namespace dom {
-
-
-
-template<class T>
-class UnionMember
-{
-  AlignedStorage2<T> mStorage;
-
-
-
-  UnionMember(const UnionMember&) = delete;
-
-public:
-  UnionMember() = default;
-  ~UnionMember() = default;
-
-  T& SetValue()
-  {
-    new (mStorage.addr()) T();
-    return *mStorage.addr();
-  }
-  template <typename T1>
-  T& SetValue(const T1& aValue)
-  {
-    new (mStorage.addr()) T(aValue);
-    return *mStorage.addr();
-  }
-  template<typename T1, typename T2>
-  T& SetValue(const T1& aValue1, const T2& aValue2)
-  {
-    new (mStorage.addr()) T(aValue1, aValue2);
-    return *mStorage.addr();
-  }
-  T& Value()
-  {
-    return *mStorage.addr();
-  }
-  const T& Value() const
-  {
-    return *mStorage.addr();
-  }
-  void Destroy()
-  {
-    mStorage.addr()->~T();
-  }
-};
-
-}
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h" 2
-
-namespace mozilla {
-namespace dom {
-
-class Blob;
-class CanvasRenderingContext2D;
-struct ChannelPixelLayoutAtoms;
-class HTMLCanvasElement;
-class HTMLImageElement;
-class HTMLVideoElement;
-class ImageBitmap;
-struct ImageBitmapAtoms;
-class ImageData;
-struct NativePropertyHooks;
-class OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer;
-class ProtoAndIfaceCache;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class ImageBitmapFormat : uint8_t {
-  RGBA32,
-  BGRA32,
-  RGB24,
-  BGR24,
-  GRAY8,
-  YUV444P,
-  YUV422P,
-  YUV420P,
-  YUV420SP_NV12,
-  YUV420SP_NV21,
-  HSV,
-  Lab,
-  DEPTH,
-  EndGuard_
-};
-
-namespace ImageBitmapFormatValues {
-extern const EnumEntry strings[14];
-}
-
-bool
-ToJSValue(JSContext* aCx, ImageBitmapFormat aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-enum class ChannelPixelLayoutDataType : uint8_t {
-  Uint8,
-  Int8,
-  Uint16,
-  Int16,
-  Uint32,
-  Int32,
-  Float32,
-  Float64,
-  EndGuard_
-};
-
-namespace ChannelPixelLayoutDataTypeValues {
-extern const EnumEntry strings[9];
-}
-
-bool
-ToJSValue(JSContext* aCx, ChannelPixelLayoutDataType aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion, const char* aName, uint32_t aFlags = 0);
-
-
-void
-ImplCycleCollectionUnlink(OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion);
-
-
-struct ChannelPixelLayout : public DictionaryBase
-{
-                        ChannelPixelLayoutDataType mDataType;
-                        uint32_t mHeight;
-                        uint32_t mOffset;
-                        uint32_t mSkip;
-                        uint32_t mStride;
-                        uint32_t mWidth;
-
-  ChannelPixelLayout();
-
-  explicit inline ChannelPixelLayout(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline ChannelPixelLayout(const ChannelPixelLayout& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  ChannelPixelLayout&
-  operator=(const ChannelPixelLayout& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, ChannelPixelLayoutAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastChannelPixelLayout : public ChannelPixelLayout
-{
-  inline FastChannelPixelLayout()
-    : ChannelPixelLayout(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-class HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer
-{
-  friend class HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBufferArgument;
-  enum Type
-  {
-    eUninitialized,
-    eHTMLImageElement,
-    eHTMLVideoElement,
-    eHTMLCanvasElement,
-    eBlob,
-    eImageData,
-    eCanvasRenderingContext2D,
-    eImageBitmap,
-    eArrayBufferView,
-    eArrayBuffer
-  };
-
-  union Value
-  {
-    UnionMember<NonNull<mozilla::dom::HTMLImageElement> > mHTMLImageElement;
-    UnionMember<NonNull<mozilla::dom::HTMLVideoElement> > mHTMLVideoElement;
-    UnionMember<NonNull<mozilla::dom::HTMLCanvasElement> > mHTMLCanvasElement;
-    UnionMember<NonNull<mozilla::dom::Blob> > mBlob;
-    UnionMember<NonNull<mozilla::dom::ImageData> > mImageData;
-    UnionMember<NonNull<mozilla::dom::CanvasRenderingContext2D> > mCanvasRenderingContext2D;
-    UnionMember<NonNull<mozilla::dom::ImageBitmap> > mImageBitmap;
-    UnionMember<RootedTypedArray<ArrayBufferView> > mArrayBufferView;
-    UnionMember<RootedTypedArray<ArrayBuffer> > mArrayBuffer;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-  HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer(const HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
-  HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& operator=(const HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
-public:
-  explicit inline HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
-    : mType(eUninitialized)
-  {
-  }
-
-  inline ~HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
-  {
-    Uninit();
-  }
-
-  inline NonNull<mozilla::dom::HTMLImageElement>&
-  RawSetAsHTMLImageElement()
-  {
-    if (mType == eHTMLImageElement) {
-      return mValue.mHTMLImageElement.Value();
-    }
-    do { } while (0);
-    mType = eHTMLImageElement;
-    return mValue.mHTMLImageElement.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::HTMLImageElement>&
-  SetAsHTMLImageElement()
-  {
-    if (mType == eHTMLImageElement) {
-      return mValue.mHTMLImageElement.Value();
-    }
-    Uninit();
-    mType = eHTMLImageElement;
-    return mValue.mHTMLImageElement.SetValue();
-  }
-
-  inline bool
-  IsHTMLImageElement() const
-  {
-    return mType == eHTMLImageElement;
-  }
-
-  inline NonNull<mozilla::dom::HTMLImageElement>&
-  GetAsHTMLImageElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLImageElement.Value();
-  }
-
-  inline mozilla::dom::HTMLImageElement&
-  GetAsHTMLImageElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLImageElement.Value();
-  }
-
-  inline NonNull<mozilla::dom::HTMLVideoElement>&
-  RawSetAsHTMLVideoElement()
-  {
-    if (mType == eHTMLVideoElement) {
-      return mValue.mHTMLVideoElement.Value();
-    }
-    do { } while (0);
-    mType = eHTMLVideoElement;
-    return mValue.mHTMLVideoElement.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::HTMLVideoElement>&
-  SetAsHTMLVideoElement()
-  {
-    if (mType == eHTMLVideoElement) {
-      return mValue.mHTMLVideoElement.Value();
-    }
-    Uninit();
-    mType = eHTMLVideoElement;
-    return mValue.mHTMLVideoElement.SetValue();
-  }
-
-  inline bool
-  IsHTMLVideoElement() const
-  {
-    return mType == eHTMLVideoElement;
-  }
-
-  inline NonNull<mozilla::dom::HTMLVideoElement>&
-  GetAsHTMLVideoElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLVideoElement.Value();
-  }
-
-  inline mozilla::dom::HTMLVideoElement&
-  GetAsHTMLVideoElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLVideoElement.Value();
-  }
-
-  inline NonNull<mozilla::dom::HTMLCanvasElement>&
-  RawSetAsHTMLCanvasElement()
-  {
-    if (mType == eHTMLCanvasElement) {
-      return mValue.mHTMLCanvasElement.Value();
-    }
-    do { } while (0);
-    mType = eHTMLCanvasElement;
-    return mValue.mHTMLCanvasElement.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::HTMLCanvasElement>&
-  SetAsHTMLCanvasElement()
-  {
-    if (mType == eHTMLCanvasElement) {
-      return mValue.mHTMLCanvasElement.Value();
-    }
-    Uninit();
-    mType = eHTMLCanvasElement;
-    return mValue.mHTMLCanvasElement.SetValue();
-  }
-
-  inline bool
-  IsHTMLCanvasElement() const
-  {
-    return mType == eHTMLCanvasElement;
-  }
-
-  inline NonNull<mozilla::dom::HTMLCanvasElement>&
-  GetAsHTMLCanvasElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLCanvasElement.Value();
-  }
-
-  inline mozilla::dom::HTMLCanvasElement&
-  GetAsHTMLCanvasElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLCanvasElement.Value();
-  }
-
-  inline NonNull<mozilla::dom::Blob>&
-  RawSetAsBlob()
-  {
-    if (mType == eBlob) {
-      return mValue.mBlob.Value();
-    }
-    do { } while (0);
-    mType = eBlob;
-    return mValue.mBlob.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::Blob>&
-  SetAsBlob()
-  {
-    if (mType == eBlob) {
-      return mValue.mBlob.Value();
-    }
-    Uninit();
-    mType = eBlob;
-    return mValue.mBlob.SetValue();
-  }
-
-  inline bool
-  IsBlob() const
-  {
-    return mType == eBlob;
-  }
-
-  inline NonNull<mozilla::dom::Blob>&
-  GetAsBlob()
-  {
-    do { } while (0);
-    return mValue.mBlob.Value();
-  }
-
-  inline mozilla::dom::Blob&
-  GetAsBlob() const
-  {
-    do { } while (0);
-    return mValue.mBlob.Value();
-  }
-
-  inline NonNull<mozilla::dom::ImageData>&
-  RawSetAsImageData()
-  {
-    if (mType == eImageData) {
-      return mValue.mImageData.Value();
-    }
-    do { } while (0);
-    mType = eImageData;
-    return mValue.mImageData.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::ImageData>&
-  SetAsImageData()
-  {
-    if (mType == eImageData) {
-      return mValue.mImageData.Value();
-    }
-    Uninit();
-    mType = eImageData;
-    return mValue.mImageData.SetValue();
-  }
-
-  inline bool
-  IsImageData() const
-  {
-    return mType == eImageData;
-  }
-
-  inline NonNull<mozilla::dom::ImageData>&
-  GetAsImageData()
-  {
-    do { } while (0);
-    return mValue.mImageData.Value();
-  }
-
-  inline mozilla::dom::ImageData&
-  GetAsImageData() const
-  {
-    do { } while (0);
-    return mValue.mImageData.Value();
-  }
-
-  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
-  RawSetAsCanvasRenderingContext2D()
-  {
-    if (mType == eCanvasRenderingContext2D) {
-      return mValue.mCanvasRenderingContext2D.Value();
-    }
-    do { } while (0);
-    mType = eCanvasRenderingContext2D;
-    return mValue.mCanvasRenderingContext2D.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
-  SetAsCanvasRenderingContext2D()
-  {
-    if (mType == eCanvasRenderingContext2D) {
-      return mValue.mCanvasRenderingContext2D.Value();
-    }
-    Uninit();
-    mType = eCanvasRenderingContext2D;
-    return mValue.mCanvasRenderingContext2D.SetValue();
-  }
-
-  inline bool
-  IsCanvasRenderingContext2D() const
-  {
-    return mType == eCanvasRenderingContext2D;
-  }
-
-  inline NonNull<mozilla::dom::CanvasRenderingContext2D>&
-  GetAsCanvasRenderingContext2D()
-  {
-    do { } while (0);
-    return mValue.mCanvasRenderingContext2D.Value();
-  }
-
-  inline mozilla::dom::CanvasRenderingContext2D&
-  GetAsCanvasRenderingContext2D() const
-  {
-    do { } while (0);
-    return mValue.mCanvasRenderingContext2D.Value();
-  }
-
-  inline NonNull<mozilla::dom::ImageBitmap>&
-  RawSetAsImageBitmap()
-  {
-    if (mType == eImageBitmap) {
-      return mValue.mImageBitmap.Value();
-    }
-    do { } while (0);
-    mType = eImageBitmap;
-    return mValue.mImageBitmap.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::ImageBitmap>&
-  SetAsImageBitmap()
-  {
-    if (mType == eImageBitmap) {
-      return mValue.mImageBitmap.Value();
-    }
-    Uninit();
-    mType = eImageBitmap;
-    return mValue.mImageBitmap.SetValue();
-  }
-
-  inline bool
-  IsImageBitmap() const
-  {
-    return mType == eImageBitmap;
-  }
-
-  inline NonNull<mozilla::dom::ImageBitmap>&
-  GetAsImageBitmap()
-  {
-    do { } while (0);
-    return mValue.mImageBitmap.Value();
-  }
-
-  inline mozilla::dom::ImageBitmap&
-  GetAsImageBitmap() const
-  {
-    do { } while (0);
-    return mValue.mImageBitmap.Value();
-  }
-
-  inline RootedTypedArray<ArrayBufferView>&
-  RawSetAsArrayBufferView(JSContext* cx)
-  {
-    if (mType == eArrayBufferView) {
-      return mValue.mArrayBufferView.Value();
-    }
-    do { } while (0);
-    mType = eArrayBufferView;
-    return mValue.mArrayBufferView.SetValue(cx);
-  }
-
-  inline RootedTypedArray<ArrayBufferView>&
-  SetAsArrayBufferView(JSContext* cx)
-  {
-    if (mType == eArrayBufferView) {
-      return mValue.mArrayBufferView.Value();
-    }
-    Uninit();
-    mType = eArrayBufferView;
-    return mValue.mArrayBufferView.SetValue(cx);
-  }
-
-  inline bool
-  IsArrayBufferView() const
-  {
-    return mType == eArrayBufferView;
-  }
-
-  inline RootedTypedArray<ArrayBufferView>&
-  GetAsArrayBufferView()
-  {
-    do { } while (0);
-    return mValue.mArrayBufferView.Value();
-  }
-
-  inline ArrayBufferView const &
-  GetAsArrayBufferView() const
-  {
-    do { } while (0);
-    return mValue.mArrayBufferView.Value();
-  }
-
-  inline RootedTypedArray<ArrayBuffer>&
-  RawSetAsArrayBuffer(JSContext* cx)
-  {
-    if (mType == eArrayBuffer) {
-      return mValue.mArrayBuffer.Value();
-    }
-    do { } while (0);
-    mType = eArrayBuffer;
-    return mValue.mArrayBuffer.SetValue(cx);
-  }
-
-  inline RootedTypedArray<ArrayBuffer>&
-  SetAsArrayBuffer(JSContext* cx)
-  {
-    if (mType == eArrayBuffer) {
-      return mValue.mArrayBuffer.Value();
-    }
-    Uninit();
-    mType = eArrayBuffer;
-    return mValue.mArrayBuffer.SetValue(cx);
-  }
-
-  inline bool
-  IsArrayBuffer() const
-  {
-    return mType == eArrayBuffer;
-  }
-
-  inline RootedTypedArray<ArrayBuffer>&
-  GetAsArrayBuffer()
-  {
-    do { } while (0);
-    return mValue.mArrayBuffer.Value();
-  }
-
-  inline ArrayBuffer const &
-  GetAsArrayBuffer() const
-  {
-    do { } while (0);
-    return mValue.mArrayBuffer.Value();
-  }
-
-  inline void
-  Uninit()
-  {
-    switch (mType) {
-      case eUninitialized: {
-        break;
-      }
-      case eHTMLImageElement: {
-        DestroyHTMLImageElement();
-        break;
-      }
-      case eHTMLVideoElement: {
-        DestroyHTMLVideoElement();
-        break;
-      }
-      case eHTMLCanvasElement: {
-        DestroyHTMLCanvasElement();
-        break;
-      }
-      case eBlob: {
-        DestroyBlob();
-        break;
-      }
-      case eImageData: {
-        DestroyImageData();
-        break;
-      }
-      case eCanvasRenderingContext2D: {
-        DestroyCanvasRenderingContext2D();
-        break;
-      }
-      case eImageBitmap: {
-        DestroyImageBitmap();
-        break;
-      }
-      case eArrayBufferView: {
-        DestroyArrayBufferView();
-        break;
-      }
-      case eArrayBuffer: {
-        DestroyArrayBuffer();
-        break;
-      }
-    }
-  }
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-private:
-  inline void
-  DestroyHTMLImageElement()
-  {
-    do { } while (0);
-    mValue.mHTMLImageElement.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyHTMLVideoElement()
-  {
-    do { } while (0);
-    mValue.mHTMLVideoElement.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyHTMLCanvasElement()
-  {
-    do { } while (0);
-    mValue.mHTMLCanvasElement.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyBlob()
-  {
-    do { } while (0);
-    mValue.mBlob.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyImageData()
-  {
-    do { } while (0);
-    mValue.mImageData.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyCanvasRenderingContext2D()
-  {
-    do { } while (0);
-    mValue.mCanvasRenderingContext2D.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyImageBitmap()
-  {
-    do { } while (0);
-    mValue.mImageBitmap.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyArrayBufferView()
-  {
-    do { } while (0);
-    mValue.mArrayBufferView.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyArrayBuffer()
-  {
-    do { } while (0);
-    mValue.mArrayBuffer.Destroy();
-    mType = eUninitialized;
-  }
-};
-
-
-class OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer : public AllOwningUnionBase
-{
-  friend void ImplCycleCollectionUnlink(OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& aUnion);
-  enum Type
-  {
-    eUninitialized,
-    eHTMLImageElement,
-    eHTMLVideoElement,
-    eHTMLCanvasElement,
-    eBlob,
-    eImageData,
-    eCanvasRenderingContext2D,
-    eImageBitmap,
-    eArrayBufferView,
-    eArrayBuffer
-  };
-
-  union Value
-  {
-    UnionMember<OwningNonNull<mozilla::dom::HTMLImageElement> > mHTMLImageElement;
-    UnionMember<OwningNonNull<mozilla::dom::HTMLVideoElement> > mHTMLVideoElement;
-    UnionMember<OwningNonNull<mozilla::dom::HTMLCanvasElement> > mHTMLCanvasElement;
-    UnionMember<OwningNonNull<mozilla::dom::Blob> > mBlob;
-    UnionMember<OwningNonNull<mozilla::dom::ImageData> > mImageData;
-    UnionMember<OwningNonNull<mozilla::dom::CanvasRenderingContext2D> > mCanvasRenderingContext2D;
-    UnionMember<OwningNonNull<mozilla::dom::ImageBitmap> > mImageBitmap;
-    UnionMember<ArrayBufferView > mArrayBufferView;
-    UnionMember<ArrayBuffer > mArrayBuffer;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-  OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer(const OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
-  OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer& operator=(const OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer&) = delete;
-public:
-  explicit inline OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
-    : mType(eUninitialized)
-  {
-  }
-
-  inline ~OwningHTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrCanvasRenderingContext2DOrImageBitmapOrArrayBufferViewOrArrayBuffer()
-  {
-    Uninit();
-  }
-
-  OwningNonNull<mozilla::dom::HTMLImageElement>&
-  RawSetAsHTMLImageElement();
-
-  OwningNonNull<mozilla::dom::HTMLImageElement>&
-  SetAsHTMLImageElement();
-
-  bool
-  TrySetToHTMLImageElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsHTMLImageElement() const
-  {
-    return mType == eHTMLImageElement;
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLImageElement>&
-  GetAsHTMLImageElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLImageElement.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLImageElement> const &
-  GetAsHTMLImageElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLImageElement.Value();
-  }
-
-  OwningNonNull<mozilla::dom::HTMLVideoElement>&
-  RawSetAsHTMLVideoElement();
-
-  OwningNonNull<mozilla::dom::HTMLVideoElement>&
-  SetAsHTMLVideoElement();
-
-  bool
-  TrySetToHTMLVideoElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsHTMLVideoElement() const
-  {
-    return mType == eHTMLVideoElement;
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLVideoElement>&
-  GetAsHTMLVideoElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLVideoElement.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLVideoElement> const &
-  GetAsHTMLVideoElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLVideoElement.Value();
-  }
-
-  OwningNonNull<mozilla::dom::HTMLCanvasElement>&
-  RawSetAsHTMLCanvasElement();
-
-  OwningNonNull<mozilla::dom::HTMLCanvasElement>&
-  SetAsHTMLCanvasElement();
-
-  bool
-  TrySetToHTMLCanvasElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsHTMLCanvasElement() const
-  {
-    return mType == eHTMLCanvasElement;
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLCanvasElement>&
-  GetAsHTMLCanvasElement()
-  {
-    do { } while (0);
-    return mValue.mHTMLCanvasElement.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::HTMLCanvasElement> const &
-  GetAsHTMLCanvasElement() const
-  {
-    do { } while (0);
-    return mValue.mHTMLCanvasElement.Value();
-  }
-
-  OwningNonNull<mozilla::dom::Blob>&
-  RawSetAsBlob();
-
-  OwningNonNull<mozilla::dom::Blob>&
-  SetAsBlob();
-
-  bool
-  TrySetToBlob(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsBlob() const
-  {
-    return mType == eBlob;
-  }
-
-  inline OwningNonNull<mozilla::dom::Blob>&
-  GetAsBlob()
-  {
-    do { } while (0);
-    return mValue.mBlob.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::Blob> const &
-  GetAsBlob() const
-  {
-    do { } while (0);
-    return mValue.mBlob.Value();
-  }
-
-  OwningNonNull<mozilla::dom::ImageData>&
-  RawSetAsImageData();
-
-  OwningNonNull<mozilla::dom::ImageData>&
-  SetAsImageData();
-
-  bool
-  TrySetToImageData(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsImageData() const
-  {
-    return mType == eImageData;
-  }
-
-  inline OwningNonNull<mozilla::dom::ImageData>&
-  GetAsImageData()
-  {
-    do { } while (0);
-    return mValue.mImageData.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::ImageData> const &
-  GetAsImageData() const
-  {
-    do { } while (0);
-    return mValue.mImageData.Value();
-  }
-
-  OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
-  RawSetAsCanvasRenderingContext2D();
-
-  OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
-  SetAsCanvasRenderingContext2D();
-
-  bool
-  TrySetToCanvasRenderingContext2D(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsCanvasRenderingContext2D() const
-  {
-    return mType == eCanvasRenderingContext2D;
-  }
-
-  inline OwningNonNull<mozilla::dom::CanvasRenderingContext2D>&
-  GetAsCanvasRenderingContext2D()
-  {
-    do { } while (0);
-    return mValue.mCanvasRenderingContext2D.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::CanvasRenderingContext2D> const &
-  GetAsCanvasRenderingContext2D() const
-  {
-    do { } while (0);
-    return mValue.mCanvasRenderingContext2D.Value();
-  }
-
-  OwningNonNull<mozilla::dom::ImageBitmap>&
-  RawSetAsImageBitmap();
-
-  OwningNonNull<mozilla::dom::ImageBitmap>&
-  SetAsImageBitmap();
-
-  bool
-  TrySetToImageBitmap(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsImageBitmap() const
-  {
-    return mType == eImageBitmap;
-  }
-
-  inline OwningNonNull<mozilla::dom::ImageBitmap>&
-  GetAsImageBitmap()
-  {
-    do { } while (0);
-    return mValue.mImageBitmap.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::ImageBitmap> const &
-  GetAsImageBitmap() const
-  {
-    do { } while (0);
-    return mValue.mImageBitmap.Value();
-  }
-
-  ArrayBufferView&
-  RawSetAsArrayBufferView();
-
-  ArrayBufferView&
-  SetAsArrayBufferView();
-
-  bool
-  TrySetToArrayBufferView(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsArrayBufferView() const
-  {
-    return mType == eArrayBufferView;
-  }
-
-  inline ArrayBufferView&
-  GetAsArrayBufferView()
-  {
-    do { } while (0);
-    return mValue.mArrayBufferView.Value();
-  }
-
-  inline ArrayBufferView const &
-  GetAsArrayBufferView() const
-  {
-    do { } while (0);
-    return mValue.mArrayBufferView.Value();
-  }
-
-  ArrayBuffer&
-  RawSetAsArrayBuffer();
-
-  ArrayBuffer&
-  SetAsArrayBuffer();
-
-  bool
-  TrySetToArrayBuffer(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsArrayBuffer() const
-  {
-    return mType == eArrayBuffer;
-  }
-
-  inline ArrayBuffer&
-  GetAsArrayBuffer()
-  {
-    do { } while (0);
-    return mValue.mArrayBuffer.Value();
-  }
-
-  inline ArrayBuffer const &
-  GetAsArrayBuffer() const
-  {
-    do { } while (0);
-    return mValue.mArrayBuffer.Value();
-  }
-
-  void
-  Uninit();
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceUnion(JSTracer* trc);
-
-private:
-  void
-  DestroyHTMLImageElement();
-
-  void
-  DestroyHTMLVideoElement();
-
-  void
-  DestroyHTMLCanvasElement();
-
-  void
-  DestroyBlob();
-
-  void
-  DestroyImageData();
-
-  void
-  DestroyCanvasRenderingContext2D();
-
-  void
-  DestroyImageBitmap();
-
-  void
-  DestroyArrayBufferView();
-
-  void
-  DestroyArrayBuffer();
-};
-
-
-namespace ImageBitmapBinding {
-
-  typedef mozilla::dom::ImageBitmap NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::ImageBitmap* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 1070 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ImageBitmapBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 7 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 1
-# 8 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-namespace js {
-
-using JS::AutoIdVector;
-using JS::CallArgs;
-using JS::Handle;
-using JS::HandleId;
-using JS::HandleObject;
-using JS::HandleValue;
-using JS::IsAcceptableThis;
-using JS::MutableHandle;
-using JS::MutableHandleObject;
-using JS::MutableHandleValue;
-using JS::NativeImpl;
-using JS::ObjectOpResult;
-using JS::PrivateValue;
-using JS::PropertyDescriptor;
-using JS::Value;
-
-class RegExpShared;
-
-class Wrapper;
-# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-class BaseProxyHandler
-{
-# 162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-    const void* mFamily;
-# 182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-    bool mHasPrototype;
-
-
-
-
-
-
-
-    bool mHasSecurityPolicy;
-
-  public:
-    explicit constexpr BaseProxyHandler(const void* aFamily, bool aHasPrototype = false,
-                                            bool aHasSecurityPolicy = false)
-      : mFamily(aFamily),
-        mHasPrototype(aHasPrototype),
-        mHasSecurityPolicy(aHasSecurityPolicy)
-    { }
-
-    bool hasPrototype() const {
-        return mHasPrototype;
-    }
-
-    bool hasSecurityPolicy() const {
-        return mHasSecurityPolicy;
-    }
-
-    inline const void* family() const {
-        return mFamily;
-    }
-    static size_t offsetOfFamily() {
-        return __builtin_offsetof(BaseProxyHandler, mFamily);
-    }
-
-    virtual bool finalizeInBackground(const Value& priv) const {
-
-
-
-
-        return true;
-    }
-
-    virtual bool canNurseryAllocate() const {
-
-
-
-
-        return false;
-    }
-# 248 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-    typedef uint32_t Action;
-    enum {
-        NONE = 0x00,
-        GET = 0x01,
-        SET = 0x02,
-        CALL = 0x04,
-        ENUMERATE = 0x08,
-        GET_PROPERTY_DESCRIPTOR = 0x10
-    };
-
-    virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Action act, bool mayThrow,
-                       bool* bp) const;
-
-
-    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
-                                          MutableHandle<PropertyDescriptor> desc) const = 0;
-    virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
-                                Handle<PropertyDescriptor> desc,
-                                ObjectOpResult& result) const = 0;
-    virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
-                                 AutoIdVector& props) const = 0;
-    virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
-                         ObjectOpResult& result) const = 0;
-
-
-
-
-
-
-
-    virtual bool getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject protop) const;
-    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
-                              ObjectOpResult& result) const;
-
-
-    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
-                                        MutableHandleObject protop) const = 0;
-    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy, bool* succeeded) const;
-
-    virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
-                                   ObjectOpResult& result) const = 0;
-    virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const = 0;
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-    virtual bool has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
-    virtual bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
-                     HandleId id, MutableHandleValue vp) const;
-    virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
-                     HandleValue receiver, ObjectOpResult& result) const;
-# 316 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-    virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
-    virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const;
-
-
-    virtual bool enumerate(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const;
-    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
-                                       MutableHandle<PropertyDescriptor> desc) const;
-    virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const;
-    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
-                                              AutoIdVector& props) const;
-    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
-                            const CallArgs& args) const;
-    virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v, bool* bp) const;
-    virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy,
-                                 ESClass* cls) const;
-    virtual bool isArray(JSContext* cx, HandleObject proxy, JS::IsArrayAnswer* answer) const;
-    virtual const char* className(JSContext* cx, HandleObject proxy) const;
-    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy, unsigned indent) const;
-    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
-                                 MutableHandle<js::RegExpShared*> shared) const;
-    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const;
-    virtual void trace(JSTracer* trc, JSObject* proxy) const;
-    virtual void finalize(JSFreeOp* fop, JSObject* proxy) const;
-    virtual void objectMoved(JSObject* proxy, const JSObject* old) const;
-
-
-
-
-
-    virtual bool isCallable(JSObject* obj) const;
-    virtual bool isConstructor(JSObject* obj) const;
-
-
-
-    virtual bool watch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
-                       JS::HandleObject callable) const;
-    virtual bool unwatch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id) const;
-
-    virtual bool getElements(JSContext* cx, HandleObject proxy, uint32_t begin, uint32_t end,
-                             ElementAdder* adder) const;
-
-
-    virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const;
-    virtual bool isScripted() const { return false; }
-};
-
-extern const js::Class* const ProxyClassPtr;
-
-inline bool IsProxy(const JSObject* obj)
-{
-    return GetObjectClass(obj)->isProxy();
-}
-
-namespace detail {
-const uint32_t PROXY_EXTRA_SLOTS = 2;
-
-
-
-
-
-
-struct ProxyValueArray
-{
-    Value privateSlot;
-    Value extraSlots[PROXY_EXTRA_SLOTS];
-
-    ProxyValueArray()
-      : privateSlot(JS::UndefinedValue())
-    {
-        for (size_t i = 0; i < PROXY_EXTRA_SLOTS; i++)
-            extraSlots[i] = JS::UndefinedValue();
-    }
-
-    static size_t offsetOfPrivateSlot() {
-        return __builtin_offsetof(ProxyValueArray, privateSlot);
-    }
-};
-# 402 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-struct ProxyDataLayout
-{
-    ProxyValueArray* values;
-    const BaseProxyHandler* handler;
-};
-
-const uint32_t ProxyDataOffset = 2 * sizeof(void*);
-
-inline ProxyDataLayout*
-GetProxyDataLayout(JSObject* obj)
-{
-    do { } while (0);
-    return reinterpret_cast<ProxyDataLayout*>(reinterpret_cast<uint8_t*>(obj) + ProxyDataOffset);
-}
-
-inline const ProxyDataLayout*
-GetProxyDataLayout(const JSObject* obj)
-{
-    do { } while (0);
-    return reinterpret_cast<const ProxyDataLayout*>(reinterpret_cast<const uint8_t*>(obj) +
-                                                    ProxyDataOffset);
-}
-}
-
-inline const BaseProxyHandler*
-GetProxyHandler(const JSObject* obj)
-{
-    return detail::GetProxyDataLayout(obj)->handler;
-}
-
-inline const Value&
-GetProxyPrivate(const JSObject* obj)
-{
-    return detail::GetProxyDataLayout(obj)->values->privateSlot;
-}
-
-inline JSObject*
-GetProxyTargetObject(JSObject* obj)
-{
-    return GetProxyPrivate(obj).toObjectOrNull();
-}
-
-inline const Value&
-GetProxyExtra(const JSObject* obj, size_t n)
-{
-    do { } while (0);
-    return detail::GetProxyDataLayout(obj)->values->extraSlots[n];
-}
-
-inline void
-SetProxyHandler(JSObject* obj, const BaseProxyHandler* handler)
-{
-    detail::GetProxyDataLayout(obj)->handler = handler;
-}
-
-void
-SetValueInProxy(Value* slot, const Value& value);
-
-inline void
-SetProxyExtra(JSObject* obj, size_t n, const Value& extra)
-{
-    do { } while (0);
-    Value* vp = &detail::GetProxyDataLayout(obj)->values->extraSlots[n];
-
-
-    if (vp->isGCThing() || extra.isGCThing())
-        SetValueInProxy(vp, extra);
-    else
-        *vp = extra;
-}
-
-inline bool
-IsScriptedProxy(const JSObject* obj)
-{
-    return IsProxy(obj) && GetProxyHandler(obj)->isScripted();
-}
-
-inline const Value&
-GetReservedOrProxyPrivateSlot(const JSObject* obj, size_t slot)
-{
-    do { } while (0);
-    do { } while (0);
-    return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
-}
-
-inline void
-SetReservedOrProxyPrivateSlot(JSObject* obj, size_t slot, const Value& value)
-{
-    do { } while (0);
-    do { } while (0);
-    shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
-    if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
-        SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
-    else
-        sobj->slotRef(slot) = value;
-}
-
-class ProxyOptions {
-  protected:
-
-    explicit ProxyOptions(bool singletonArg, bool lazyProtoArg = false)
-      : singleton_(singletonArg),
-        lazyProto_(lazyProtoArg),
-        clasp_(ProxyClassPtr)
-    {}
-
-  public:
-    ProxyOptions() : singleton_(false),
-                     lazyProto_(false),
-                     clasp_(ProxyClassPtr)
-    {}
-
-    bool singleton() const { return singleton_; }
-    ProxyOptions& setSingleton(bool flag) {
-        singleton_ = flag;
-        return *this;
-    }
-
-    bool lazyProto() const { return lazyProto_; }
-    ProxyOptions& setLazyProto(bool flag) {
-        lazyProto_ = flag;
-        return *this;
-    }
-
-    const Class* clasp() const {
-        return clasp_;
-    }
-    ProxyOptions& setClass(const Class* claspArg) {
-        clasp_ = claspArg;
-        return *this;
-    }
-
-  private:
-    bool singleton_;
-    bool lazyProto_;
-    const Class* clasp_;
-};
-
-JSObject*
-NewProxyObject(JSContext* cx, const BaseProxyHandler* handler, HandleValue priv,
-               JSObject* proto, const ProxyOptions& options = ProxyOptions());
-
-JSObject*
-RenewProxyObject(JSContext* cx, JSObject* obj, BaseProxyHandler* handler, const Value& priv);
-
-class AutoEnterPolicy
-{
-  public:
-    typedef BaseProxyHandler::Action Action;
-    AutoEnterPolicy(JSContext* cx, const BaseProxyHandler* handler,
-                    HandleObject wrapper, HandleId id, Action act, bool mayThrow)
-
-        : context(nullptr)
-
-    {
-        allow = handler->hasSecurityPolicy() ? handler->enter(cx, wrapper, id, act, mayThrow, &rv)
-                                             : true;
-        recordEnter(cx, wrapper, id, act);
-
-
-
-
-
-        if (!allow && !rv && mayThrow)
-            reportErrorIfExceptionIsNotPending(cx, id);
-    }
-
-    virtual ~AutoEnterPolicy() { recordLeave(); }
-    inline bool allowed() { return allow; }
-    inline bool returnValue() { do { } while (0); return rv; }
-
-  protected:
-
-    AutoEnterPolicy()
-
-        : context(nullptr)
-        , enteredAction(BaseProxyHandler::NONE)
-
-        {}
-    void reportErrorIfExceptionIsNotPending(JSContext* cx, jsid id);
-    bool allow;
-    bool rv;
-
-
-    JSContext* context;
-    mozilla::Maybe<HandleObject> enteredProxy;
-    mozilla::Maybe<HandleId> enteredId;
-    Action enteredAction;
-
-
-
-
-    AutoEnterPolicy* prev;
-    void recordEnter(JSContext* cx, HandleObject proxy, HandleId id, Action act);
-    void recordLeave();
-
-    friend void assertEnteredPolicy(JSContext* cx, JSObject* proxy, jsid id, Action act);
-
-
-
-
-
-  private:
-
-
-
-
-
-
-    AutoEnterPolicy(const AutoEnterPolicy&) = delete;
-    AutoEnterPolicy& operator=(const AutoEnterPolicy&) = delete;
-};
-
-
-class AutoWaivePolicy : public AutoEnterPolicy {
-public:
-    AutoWaivePolicy(JSContext* cx, HandleObject proxy, HandleId id,
-                    BaseProxyHandler::Action act)
-    {
-        allow = true;
-        recordEnter(cx, proxy, id, act);
-    }
-};
-# 635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Proxy.h"
-extern void
-assertEnteredPolicy(JSContext* cx, JSObject* obj, jsid id,
-                    BaseProxyHandler::Action act);
-
-
-
-
-
-
-extern JSObject*
-InitProxyClass(JSContext* cx, JS::HandleObject obj);
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h" 2
-
-namespace js {
-
-
-
-
-
-
-
-class WrapperOptions : public ProxyOptions {
-  public:
-    WrapperOptions() : ProxyOptions(false),
-                       proto_()
-    {}
-
-    explicit WrapperOptions(JSContext* cx) : ProxyOptions(false),
-                                             proto_()
-    {
-        proto_.emplace(cx);
-    }
-
-    inline JSObject* proto() const;
-    WrapperOptions& setProto(JSObject* protoArg) {
-        do { } while (0);
-        *proto_ = protoArg;
-        return *this;
-    }
-
-  private:
-    mozilla::Maybe<JS::RootedObject> proto_;
-};
-# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
-class Wrapper : public BaseProxyHandler
-{
-    unsigned mFlags;
-
-  public:
-    explicit constexpr Wrapper(unsigned aFlags, bool aHasPrototype = false,
-                                   bool aHasSecurityPolicy = false)
-      : BaseProxyHandler(&family, aHasPrototype, aHasSecurityPolicy),
-        mFlags(aFlags)
-    { }
-
-    virtual bool finalizeInBackground(const Value& priv) const override;
-
-
-    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
-                                          MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
-                                Handle<PropertyDescriptor> desc,
-                                ObjectOpResult& result) const override;
-    virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
-                                 AutoIdVector& props) const override;
-    virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
-                         ObjectOpResult& result) const override;
-    virtual bool enumerate(JSContext* cx, HandleObject proxy,
-                           MutableHandleObject objp) const override;
-    virtual bool getPrototype(JSContext* cx, HandleObject proxy,
-                              MutableHandleObject protop) const override;
-    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
-                              ObjectOpResult& result) const override;
-    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
-                                        MutableHandleObject protop) const override;
-    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
-                                       bool* succeeded) const override;
-    virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
-                                   ObjectOpResult& result) const override;
-    virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const override;
-    virtual bool has(JSContext* cx, HandleObject proxy, HandleId id,
-                     bool* bp) const override;
-    virtual bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
-                     HandleId id, MutableHandleValue vp) const override;
-    virtual bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
-                     HandleValue receiver, ObjectOpResult& result) const override;
-    virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
-    virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
-
-
-    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
-                                       MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id,
-                        bool* bp) const override;
-    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
-                                              AutoIdVector& props) const override;
-    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
-                            const CallArgs& args) const override;
-    virtual bool hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v,
-                             bool* bp) const override;
-    virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy, ESClass* cls) const override;
-    virtual bool isArray(JSContext* cx, HandleObject proxy,
-                         JS::IsArrayAnswer* answer) const override;
-    virtual const char* className(JSContext* cx, HandleObject proxy) const override;
-    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy,
-                                   unsigned indent) const override;
-    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
-                                 MutableHandle<RegExpShared*> shared) const override;
-    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy,
-                                  MutableHandleValue vp) const override;
-    virtual bool isCallable(JSObject* obj) const override;
-    virtual bool isConstructor(JSObject* obj) const override;
-    virtual JSObject* weakmapKeyDelegate(JSObject* proxy) const override;
-
-  public:
-    using BaseProxyHandler::Action;
-
-    enum Flags {
-        CROSS_COMPARTMENT = 1 << 0,
-        LAST_USED_FLAG = CROSS_COMPARTMENT
-    };
-
-    static JSObject* New(JSContext* cx, JSObject* obj, const Wrapper* handler,
-                         const WrapperOptions& options = WrapperOptions());
-
-    static JSObject* Renew(JSObject* existing, JSObject* obj, const Wrapper* handler);
-
-    static const Wrapper* wrapperHandler(JSObject* wrapper);
-
-    static JSObject* wrappedObject(JSObject* wrapper);
-
-    unsigned flags() const {
-        return mFlags;
-    }
-
-    static const char family;
-    static const Wrapper singleton;
-    static const Wrapper singletonWithPrototype;
-
-    static JSObject* defaultProto;
-};
-
-inline JSObject*
-WrapperOptions::proto() const
-{
-    return proto_ ? *proto_ : Wrapper::defaultProto;
-}
-
-
-class CrossCompartmentWrapper : public Wrapper
-{
-  public:
-    explicit constexpr CrossCompartmentWrapper(unsigned aFlags, bool aHasPrototype = false,
-                                                   bool aHasSecurityPolicy = false)
-      : Wrapper(CROSS_COMPARTMENT | aFlags, aHasPrototype, aHasSecurityPolicy)
-    { }
-
-
-    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
-                                          MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
-                                Handle<PropertyDescriptor> desc,
-                                ObjectOpResult& result) const override;
-    virtual bool ownPropertyKeys(JSContext* cx, HandleObject wrapper,
-                                 AutoIdVector& props) const override;
-    virtual bool delete_(JSContext* cx, HandleObject wrapper, HandleId id,
-                         ObjectOpResult& result) const override;
-    virtual bool enumerate(JSContext* cx, HandleObject wrapper, MutableHandleObject objp) const override;
-    virtual bool getPrototype(JSContext* cx, HandleObject proxy,
-                              MutableHandleObject protop) const override;
-    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
-                              ObjectOpResult& result) const override;
-
-    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
-                                        MutableHandleObject protop) const override;
-    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
-                                       bool* succeeded) const override;
-    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
-                                   ObjectOpResult& result) const override;
-    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
-    virtual bool has(JSContext* cx, HandleObject wrapper, HandleId id, bool* bp) const override;
-    virtual bool get(JSContext* cx, HandleObject wrapper, HandleValue receiver,
-                     HandleId id, MutableHandleValue vp) const override;
-    virtual bool set(JSContext* cx, HandleObject wrapper, HandleId id, HandleValue v,
-                     HandleValue receiver, ObjectOpResult& result) const override;
-    virtual bool call(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
-    virtual bool construct(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
-
-
-    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
-                                       MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id, bool* bp) const override;
-    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
-                                              AutoIdVector& props) const override;
-    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
-                            const CallArgs& args) const override;
-    virtual bool hasInstance(JSContext* cx, HandleObject wrapper, MutableHandleValue v,
-                             bool* bp) const override;
-    virtual const char* className(JSContext* cx, HandleObject proxy) const override;
-    virtual JSString* fun_toString(JSContext* cx, HandleObject wrapper,
-                                   unsigned indent) const override;
-    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
-                                 MutableHandle<RegExpShared*> shared) const override;
-    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const override;
-
-
-    virtual bool canNurseryAllocate() const override { return true; }
-
-    static const CrossCompartmentWrapper singleton;
-    static const CrossCompartmentWrapper singletonWithPrototype;
-};
-
-class OpaqueCrossCompartmentWrapper : public CrossCompartmentWrapper
-{
-  public:
-    explicit constexpr OpaqueCrossCompartmentWrapper() : CrossCompartmentWrapper(0)
-    { }
-
-
-    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
-                                          MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
-                                Handle<PropertyDescriptor> desc,
-                                ObjectOpResult& result) const override;
-    virtual bool ownPropertyKeys(JSContext* cx, HandleObject wrapper,
-                                 AutoIdVector& props) const override;
-    virtual bool delete_(JSContext* cx, HandleObject wrapper, HandleId id,
-                         ObjectOpResult& result) const override;
-    virtual bool enumerate(JSContext* cx, HandleObject wrapper,
-                           MutableHandleObject objp) const override;
-    virtual bool getPrototype(JSContext* cx, HandleObject wrapper,
-                              MutableHandleObject protop) const override;
-    virtual bool setPrototype(JSContext* cx, HandleObject wrapper, HandleObject proto,
-                              ObjectOpResult& result) const override;
-    virtual bool getPrototypeIfOrdinary(JSContext* cx, HandleObject wrapper, bool* isOrdinary,
-                                        MutableHandleObject protop) const override;
-    virtual bool setImmutablePrototype(JSContext* cx, HandleObject wrapper,
-                                       bool* succeeded) const override;
-    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
-                                   ObjectOpResult& result) const override;
-    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
-    virtual bool has(JSContext* cx, HandleObject wrapper, HandleId id,
-                     bool* bp) const override;
-    virtual bool get(JSContext* cx, HandleObject wrapper, HandleValue receiver,
-                     HandleId id, MutableHandleValue vp) const override;
-    virtual bool set(JSContext* cx, HandleObject wrapper, HandleId id, HandleValue v,
-                     HandleValue receiver, ObjectOpResult& result) const override;
-    virtual bool call(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
-    virtual bool construct(JSContext* cx, HandleObject wrapper, const CallArgs& args) const override;
-
-
-    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
-                                       MutableHandle<PropertyDescriptor> desc) const override;
-    virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id,
-                        bool* bp) const override;
-    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
-                                              AutoIdVector& props) const override;
-    virtual bool getBuiltinClass(JSContext* cx, HandleObject wrapper, ESClass* cls) const override;
-    virtual bool isArray(JSContext* cx, HandleObject obj,
-                         JS::IsArrayAnswer* answer) const override;
-    virtual const char* className(JSContext* cx, HandleObject wrapper) const override;
-    virtual JSString* fun_toString(JSContext* cx, HandleObject proxy, unsigned indent) const override;
-
-    static const OpaqueCrossCompartmentWrapper singleton;
-};
-# 289 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/jswrapper.h"
-template <class Base>
-class SecurityWrapper : public Base
-{
-  public:
-    explicit constexpr SecurityWrapper(unsigned flags, bool hasPrototype = false)
-      : Base(flags, hasPrototype, true)
-    { }
-
-    virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Wrapper::Action act,
-                       bool mayThrow, bool* bp) const override;
-
-    virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
-                                Handle<PropertyDescriptor> desc,
-                                ObjectOpResult& result) const override;
-    virtual bool isExtensible(JSContext* cx, HandleObject wrapper, bool* extensible) const override;
-    virtual bool preventExtensions(JSContext* cx, HandleObject wrapper,
-                                   ObjectOpResult& result) const override;
-    virtual bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
-                              ObjectOpResult& result) const override;
-    virtual bool setImmutablePrototype(JSContext* cx, HandleObject proxy, bool* succeeded) const override;
-
-    virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
-                            const CallArgs& args) const override;
-    virtual bool getBuiltinClass(JSContext* cx, HandleObject wrapper, ESClass* cls) const override;
-    virtual bool isArray(JSContext* cx, HandleObject wrapper, JS::IsArrayAnswer* answer) const override;
-    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy,
-                                 MutableHandle<RegExpShared*> shared) const override;
-    virtual bool boxedValue_unbox(JSContext* cx, HandleObject proxy, MutableHandleValue vp) const override;
-
-
-
-
-    virtual bool watch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
-                       JS::HandleObject callable) const override;
-    virtual bool unwatch(JSContext* cx, JS::HandleObject proxy, JS::HandleId id) const override;
-
-
-
-
-
-    typedef Base Permissive;
-    typedef SecurityWrapper<Base> Restrictive;
-};
-
-typedef SecurityWrapper<CrossCompartmentWrapper> CrossCompartmentSecurityWrapper;
-
-extern JSObject*
-TransparentObjectWrapper(JSContext* cx, HandleObject existing, HandleObject obj);
-
-inline bool
-IsWrapper(JSObject* obj)
-{
-    return IsProxy(obj) && GetProxyHandler(obj)->family() == &Wrapper::family;
-}
-
-
-
-
-
-JSObject*
-UncheckedUnwrap(JSObject* obj, bool stopAtWindowProxy = true, unsigned* flagsp = nullptr);
-
-
-
-
-
-JSObject*
-CheckedUnwrap(JSObject* obj, bool stopAtWindowProxy = true);
-
-
-
-JSObject*
-UnwrapOneChecked(JSObject* obj, bool stopAtWindowProxy = true);
-
-void
-ReportAccessDenied(JSContext* cx);
-
-bool
-IsCrossCompartmentWrapper(JSObject* obj);
-
-void
-NukeCrossCompartmentWrapper(JSContext* cx, JSObject* wrapper);
-
-void
-RemapWrapper(JSContext* cx, JSObject* wobj, JSObject* newTarget);
-
-bool
-RemapAllWrappersForObject(JSContext* cx, JSObject* oldTarget,
-                          JSObject* newTarget);
-
-
-
-bool
-RecomputeWrappers(JSContext* cx, const CompartmentFilter& sourceFilter,
-                  const CompartmentFilter& targetFilter);
-
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HoldDropJSObjects.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HoldDropJSObjects.h"
-class nsISupports;
-class nsScriptObjectTracer;
-
-
-
-namespace mozilla {
-namespace cyclecollector {
-
-void HoldJSObjectsImpl(void* aHolder, nsScriptObjectTracer* aTracer);
-void HoldJSObjectsImpl(nsISupports* aHolder);
-void DropJSObjectsImpl(void* aHolder);
-void DropJSObjectsImpl(nsISupports* aHolder);
-
-}
-
-
-template<class T, bool isISupports = IsBaseOf<nsISupports, T>::value>
-struct HoldDropJSObjectsHelper
-{
-  static void Hold(T* aHolder)
-  {
-    cyclecollector::HoldJSObjectsImpl(aHolder,
-                                      T::cycleCollection::GetParticipant());
-  }
-  static void Drop(T* aHolder)
-  {
-    cyclecollector::DropJSObjectsImpl(aHolder);
-  }
-};
-
-template<class T>
-struct HoldDropJSObjectsHelper<T, true>
-{
-  static void Hold(T* aHolder)
-  {
-    cyclecollector::HoldJSObjectsImpl(ToSupports(aHolder));
-  }
-  static void Drop(T* aHolder)
-  {
-    cyclecollector::DropJSObjectsImpl(ToSupports(aHolder));
-  }
-};
-
-
-template<class T>
-void
-HoldJSObjects(T* aHolder)
-{
-  HoldDropJSObjectsHelper<T>::Hold(aHolder);
-}
-
-template<class T>
-void
-DropJSObjects(T* aHolder)
-{
-  HoldDropJSObjectsHelper<T>::Drop(aHolder);
-}
-
-
-
-
-
-}
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TaskCategory.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/TaskCategory.h"
-namespace mozilla {
-
-
-
-enum class TaskCategory {
-
-  UI,
-
-
-  Network,
-
-
-  Timer,
-
-
-  Worker,
-
-
-  IdleCallback,
-
-
-  RefreshDriver,
-
-
-  GarbageCollection,
-
-
-  Other,
-
-  Count
-};
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DispatcherTrait.h" 2
-
-class nsIEventTarget;
-class nsIRunnable;
-
-namespace mozilla {
-class AbstractThread;
-namespace dom {
-class TabGroup;
-
-
-
-
-
-class DispatcherTrait {
-public:
-
-
-  virtual nsresult Dispatch(const char* aName,
-                            TaskCategory aCategory,
-                            already_AddRefed<nsIRunnable>&& aRunnable);
-
-
-
-
-  virtual nsIEventTarget* EventTargetFor(TaskCategory aCategory) const;
-
-
-
-  virtual AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
-};
-
-}
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h" 2
-
-
-
-
-
-
-
-
-class nsACString;
-class nsCString;
-class nsCycleCollectionTraversalCallback;
-class nsIPrincipal;
-
-class nsIGlobalObject : public nsISupports,
-                        public mozilla::dom::DispatcherTrait
-{
-  nsTArray<nsCString> mHostObjectURIs;
-  bool mIsDying;
-
-protected:
-  nsIGlobalObject()
-   : mIsDying(false)
-  {}
-
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIGlobalObject.h"
-  bool
-  IsDying() const
-  {
-    return mIsDying;
-  }
-
-
-
-
-
-
-
-  virtual JSObject* GetGlobalJSObject() = 0;
-
-
-  nsIPrincipal* PrincipalOrNull();
-
-  void RegisterHostObjectURI(const nsACString& aURI);
-
-  void UnregisterHostObjectURI(const nsACString& aURI);
-
-
-
-  void UnlinkHostObjectURIs();
-  void TraverseHostObjectURIs(nsCycleCollectionTraversalCallback &aCb);
-
-protected:
-  virtual ~nsIGlobalObject();
-
-  void
-  StartDying()
-  {
-    mIsDying = true;
-  }
-};
-
-template<typename T> struct nsIGlobalObject::COMTypeInfo<nsIGlobalObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIGlobalObject::COMTypeInfo<nsIGlobalObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x11afa8be, 0xd997, 0x4e07, { 0xa6, 0xa3, 0x6f, 0x87, 0x2e, 0xc3, 0xee, 0x7f } };
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-namespace js {
-class Debugger;
-}
-
-namespace JS {
-namespace dbg {
-# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-class BuilderOrigin;
-
-class Builder {
-
-
-    PersistentRootedObject debuggerObject;
-
-
-    js::Debugger* debugger;
-
-
-
-
-
-
-
-    void assertBuilt(JSObject* obj) { }
-
-
-  protected:
-
-
-    template<typename T>
-    class BuiltThing {
-        friend class BuilderOrigin;
-
-      protected:
-
-        Builder& owner;
-
-
-        PersistentRooted<T> value;
-
-        BuiltThing(JSContext* cx, Builder& owner_, T value_ = GCPolicy<T>::initial())
-          : owner(owner_), value(cx, value_)
-        {
-            owner.assertBuilt(value_);
-        }
-
-
-        js::Debugger* debugger() const { return owner.debugger; }
-        JSObject* debuggerObject() const { return owner.debuggerObject; }
-
-      public:
-        BuiltThing(const BuiltThing& rhs) : owner(rhs.owner), value(rhs.value) { }
-        BuiltThing& operator=(const BuiltThing& rhs) {
-            do { } while (0);
-            owner.assertBuilt(rhs.value);
-            value = rhs.value;
-            return *this;
-        }
-
-        explicit operator bool() const {
-
-            return value;
-        }
-
-      private:
-        BuiltThing() = delete;
-    };
-
-  public:
-
-
-
-    class Object: private BuiltThing<JSObject*> {
-        friend class Builder;
-        friend class BuilderOrigin;
-
-        typedef BuiltThing<JSObject*> Base;
-
-
-
-        Object(JSContext* cx, Builder& owner_, HandleObject obj) : Base(cx, owner_, obj.get()) { }
-
-        bool definePropertyToTrusted(JSContext* cx, const char* name,
-                                     JS::MutableHandleValue value);
-
-      public:
-        Object(JSContext* cx, Builder& owner_) : Base(cx, owner_, nullptr) { }
-        Object(const Object& rhs) : Base(rhs) { }
-# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-        bool defineProperty(JSContext* cx, const char* name, JS::HandleValue value);
-        bool defineProperty(JSContext* cx, const char* name, JS::HandleObject value);
-        bool defineProperty(JSContext* cx, const char* name, Object& value);
-
-        using Base::operator bool;
-    };
-
-
-
-    Object newObject(JSContext* cx);
-
-  protected:
-    Builder(JSContext* cx, js::Debugger* debugger);
-};
-
-
-
-class BuilderOrigin : public Builder {
-    template<typename T>
-    T unwrapAny(const BuiltThing<T>& thing) {
-        do { } while (0);
-        return thing.value.get();
-    }
-
-  public:
-    BuilderOrigin(JSContext* cx, js::Debugger* debugger_)
-      : Builder(cx, debugger_)
-    { }
-
-    JSObject* unwrap(Object& object) { return unwrapAny(object); }
-};
-# 262 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-void
-SetDebuggerMallocSizeOf(JSContext* cx, mozilla::MallocSizeOf mallocSizeOf);
-
-
-
-mozilla::MallocSizeOf
-GetDebuggerMallocSizeOf(JSContext* cx);
-# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-bool
-FireOnGarbageCollectionHook(JSContext* cx, GarbageCollectionEvent::Ptr&& data);
-# 303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-void
-onNewPromise(JSContext* cx, HandleObject promise);
-# 315 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-void
-onPromiseSettled(JSContext* cx, HandleObject promise);
-
-
-
-
-bool
-IsDebugger(JSObject& obj);
-
-
-
-bool
-GetDebuggeeGlobals(JSContext* cx, JSObject& dbgObj, AutoObjectVector& vector);
-# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-class AutoEntryMonitor {
-    JSContext* cx_;
-    AutoEntryMonitor* savedMonitor_;
-
-  public:
-    explicit AutoEntryMonitor(JSContext* cx);
-    ~AutoEntryMonitor();
-# 363 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Debug.h"
-    virtual void Entry(JSContext* cx, JSFunction* function,
-                       HandleValue asyncStack,
-                       const char* asyncCause) = 0;
-
-
-
-
-    virtual void Entry(JSContext* cx, JSScript* script,
-                       HandleValue asyncStack,
-                       const char* asyncCause) = 0;
-
-
-    virtual void Exit(JSContext* cx) { }
-};
-
-
-
-}
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h" 2
-
-class nsPIDOMWindowInner;
-class nsGlobalWindow;
-class nsIScriptContext;
-class nsIDocument;
-class nsIDocShell;
-
-namespace mozilla {
-namespace dom {
-
-
-
-
-
-void InitScriptSettings();
-void DestroyScriptSettings();
-bool ScriptSettingsInitialized();
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-void UseEntryScriptProfiling();
-void UnuseEntryScriptProfiling();
-# 86 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-nsIGlobalObject* GetEntryGlobal();
-
-
-
-nsIDocument* GetEntryDocument();
-
-
-
-nsIGlobalObject* GetIncumbentGlobal();
-
-
-nsIGlobalObject* GetCurrentGlobal();
-# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-nsIPrincipal* GetWebIDLCallerPrincipal();
-
-
-
-
-inline JSObject& IncumbentJSGlobal()
-{
-  return *GetIncumbentGlobal()->GetGlobalJSObject();
-}
-
-
-
-
-bool IsJSAPIActive();
-
-namespace danger {
-
-
-
-
-JSContext* GetJSContext();
-
-}
-
-JS::RootingContext* RootingCx();
-
-class ScriptSettingsStack;
-class ScriptSettingsStackEntry {
-  friend class ScriptSettingsStack;
-
-public:
-  ~ScriptSettingsStackEntry();
-
-  bool NoJSAPI() const { return mType == eNoJSAPI; }
-  bool IsEntryCandidate() const {
-    return mType == eEntryScript || mType == eNoJSAPI;
-  }
-  bool IsIncumbentCandidate() { return mType != eJSAPI; }
-  bool IsIncumbentScript() { return mType == eIncumbentScript; }
-
-protected:
-  enum Type {
-    eEntryScript,
-    eIncumbentScript,
-    eJSAPI,
-    eNoJSAPI
-  };
-
-  ScriptSettingsStackEntry(nsIGlobalObject *aGlobal,
-                           Type aEntryType);
-
-  nsCOMPtr<nsIGlobalObject> mGlobalObject;
-  Type mType;
-
-private:
-  ScriptSettingsStackEntry *mOlder;
-};
-# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-class AutoJSAPI : protected ScriptSettingsStackEntry {
-public:
-
-
-  AutoJSAPI();
-
-  ~AutoJSAPI();
-# 218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-  void Init();
-# 228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-  __attribute__ ((warn_unused_result)) bool Init(nsIGlobalObject* aGlobalObject);
-
-
-
-  __attribute__ ((warn_unused_result)) bool Init(JSObject* aObject);
-# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-  __attribute__ ((warn_unused_result)) bool Init(nsIGlobalObject* aGlobalObject, JSContext* aCx);
-
-
-
-  __attribute__ ((warn_unused_result)) bool Init(nsPIDOMWindowInner* aWindow);
-  __attribute__ ((warn_unused_result)) bool Init(nsPIDOMWindowInner* aWindow, JSContext* aCx);
-
-  __attribute__ ((warn_unused_result)) bool Init(nsGlobalWindow* aWindow);
-  __attribute__ ((warn_unused_result)) bool Init(nsGlobalWindow* aWindow, JSContext* aCx);
-
-  JSContext* cx() const {
-    do { } while (0);
-    do { } while (0);
-    return mCx;
-  }
-
-
-
-
-
-
-  void ReportException();
-
-  bool HasException() const {
-    do { } while (0);
-    return JS_IsExceptionPending(cx());
-  };
-
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool StealException(JS::MutableHandle<JS::Value> aVal);
-
-
-
-
-
-
-
-  __attribute__ ((warn_unused_result)) bool PeekException(JS::MutableHandle<JS::Value> aVal);
-
-  void ClearException() {
-    do { } while (0);
-    JS_ClearPendingException(cx());
-  }
-
-protected:
-
-
-  AutoJSAPI(nsIGlobalObject* aGlobalObject, bool aIsMainThread, Type aType);
-
-private:
-  mozilla::Maybe<JSAutoRequest> mAutoRequest;
-  mozilla::Maybe<JSAutoNullableCompartment> mAutoNullableCompartment;
-  JSContext *mCx;
-
-
-  bool mIsMainThread;
-  Maybe<JS::WarningReporter> mOldWarningReporter;
-
-  void InitInternal(nsIGlobalObject* aGlobalObject, JSObject* aGlobal,
-                    JSContext* aCx, bool aIsMainThread);
-
-  AutoJSAPI(const AutoJSAPI&) = delete;
-  AutoJSAPI& operator= (const AutoJSAPI&) = delete;
-};
-# 319 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-class AutoEntryScript : public AutoJSAPI {
-public:
-  AutoEntryScript(nsIGlobalObject* aGlobalObject,
-                  const char *aReason,
-                  bool aIsMainThread = NS_IsMainThread());
-
-  AutoEntryScript(JSObject* aObject,
-                  const char *aReason,
-                  bool aIsMainThread = NS_IsMainThread());
-
-  ~AutoEntryScript();
-
-  void SetWebIDLCallerPrincipal(nsIPrincipal *aPrincipal) {
-    mWebIDLCallerPrincipal = aPrincipal;
-  }
-
-private:
-
-  class DocshellEntryMonitor final : public JS::dbg::AutoEntryMonitor
-  {
-  public:
-    DocshellEntryMonitor(JSContext* aCx, const char* aReason);
-
-
-
-
-
-
-    void Entry(JSContext* aCx, JSFunction* aFunction,
-               JS::Handle<JS::Value> aAsyncStack,
-               const char* aAsyncCause) override
-    {
-      Entry(aCx, aFunction, nullptr, aAsyncStack, aAsyncCause);
-    }
-
-    void Entry(JSContext* aCx, JSScript* aScript,
-               JS::Handle<JS::Value> aAsyncStack,
-               const char* aAsyncCause) override
-    {
-      Entry(aCx, nullptr, aScript, aAsyncStack, aAsyncCause);
-    }
-
-    void Exit(JSContext* aCx) override;
-
-  private:
-    void Entry(JSContext* aCx, JSFunction* aFunction, JSScript* aScript,
-               JS::Handle<JS::Value> aAsyncStack,
-               const char* aAsyncCause);
-
-    const char* mReason;
-  };
-# 378 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-  nsIPrincipal* mWebIDLCallerPrincipal;
-  friend nsIPrincipal* GetWebIDLCallerPrincipal();
-
-  Maybe<DocshellEntryMonitor> mDocShellEntryMonitor;
-  JS::AutoHideScriptedCaller mCallerOverride;
-};
-
-
-
-
-class AutoIncumbentScript : protected ScriptSettingsStackEntry {
-public:
-  explicit AutoIncumbentScript(nsIGlobalObject* aGlobalObject);
-  ~AutoIncumbentScript();
-
-private:
-  JS::AutoHideScriptedCaller mCallerOverride;
-};
-# 405 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-class AutoNoJSAPI : protected ScriptSettingsStackEntry {
-public:
-  explicit AutoNoJSAPI();
-  ~AutoNoJSAPI();
-};
-
-}
-
-
-
-
-
-
-class AutoJSContext {
-public:
-  explicit AutoJSContext();
-  operator JSContext*() const;
-
-protected:
-  JSContext* mCx;
-  dom::AutoJSAPI mJSAPI;
-
-};
-
-
-
-
-
-
-
-class AutoSafeJSContext : public dom::AutoJSAPI {
-public:
-  explicit AutoSafeJSContext();
-  operator JSContext*() const
-  {
-    return cx();
-  }
-
-private:
-
-};
-# 455 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ScriptSettings.h"
-class AutoSlowOperation : public dom::AutoJSAPI
-{
-public:
-  explicit AutoSlowOperation();
-  void CheckForInterrupt();
-private:
-
-};
-
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 1
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h"
-class nsIScriptGlobalObject;
-
-
-
-
-
-class nsIOffThreadScriptReceiver;
-
-
-
-
-
-class nsIScriptContext : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-  virtual nsIScriptGlobalObject *GetGlobalObject() = 0;
-
-
-
-
-  virtual nsresult InitContext() = 0;
-# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptContext.h"
-  virtual bool IsContextInitialized() = 0;
-
-
-
-  virtual nsresult SetProperty(JS::Handle<JSObject*> aTarget,
-                               const char* aPropName, nsISupports* aVal) = 0;
-
-
-
-
-  virtual bool GetProcessingScriptTag() = 0;
-  virtual void SetProcessingScriptTag(bool aResult) = 0;
-
-
-
-
-
-
-
-  virtual nsresult InitClasses(JS::Handle<JSObject*> aGlobalObj) = 0;
-
-
-
-
-  virtual void WillInitializeContext() = 0;
-
-
-
-
-  virtual void DidInitializeContext() = 0;
-
-
-
-
-  virtual void SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) = 0;
-  virtual JSObject* GetWindowProxy() = 0;
-};
-
-template<typename T> struct nsIScriptContext::COMTypeInfo<nsIScriptContext, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptContext::COMTypeInfo<nsIScriptContext, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x54cbe9cf, 0x7282, 0x421a, { 0x91, 0x6f, 0xd0, 0x70, 0x73, 0xde, 0xb8, 0xc0 } };
-
-
-
-
-
-class nsIOffThreadScriptReceiver : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-
-  virtual nsresult OnScriptCompileComplete(JSScript* aScript, nsresult aStatus) = 0;
-};
-
-template<typename T> struct nsIOffThreadScriptReceiver::COMTypeInfo<nsIOffThreadScriptReceiver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIOffThreadScriptReceiver::COMTypeInfo<nsIOffThreadScriptReceiver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3a980010, 0x878d, 0x46a9, {0x93, 0xad, 0xbc, 0xfd, 0xd3, 0x8e, 0xa0, 0xc2}};
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
-class nsIScriptContext;
-class nsIScriptGlobalObject;
-
-namespace mozilla {
-namespace dom {
-struct ErrorEventInit;
-}
-}
-
-
-
-
-
-
-bool
-NS_HandleScriptError(nsIScriptGlobalObject *aScriptGlobal,
-                     const mozilla::dom::ErrorEventInit &aErrorEvent,
-                     nsEventStatus *aStatus);
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
-class nsIScriptGlobalObject : public nsIGlobalObject
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScriptGlobalObject.h"
-  virtual nsresult EnsureScriptEnvironment() = 0;
-
-
-
-  virtual nsIScriptContext *GetScriptContext() = 0;
-
-  nsIScriptContext* GetContext() {
-    return GetScriptContext();
-  }
-
-
-
-
-  virtual nsresult HandleScriptError(
-                     const mozilla::dom::ErrorEventInit &aErrorEventInit,
-                     nsEventStatus *aEventStatus) {
-    do { if ((__builtin_expect(!!(!(NS_HandleScriptError(this, aErrorEventInit, aEventStatus))), 0))) { do { } while(0); return NS_ERROR_UNEXPECTED; } } while(0);
-    return NS_OK;
-  }
-
-  virtual bool IsBlackForCC(bool aTracingNeeded = true) { return false; }
-
-protected:
-  virtual ~nsIScriptGlobalObject() {}
-};
-
-template<typename T> struct nsIScriptGlobalObject::COMTypeInfo<nsIScriptGlobalObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIScriptGlobalObject::COMTypeInfo<nsIScriptGlobalObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x876f83bd, 0x6314, 0x460a, { 0xa0, 0x45, 0x1c, 0x8f, 0x46, 0x2f, 0xb8, 0xe1 } };
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
-extern "C" {
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
-extern __attribute__((visibility("default"))) PRInt64 LL_MaxInt(void);
-extern __attribute__((visibility("default"))) PRInt64 LL_MinInt(void);
-extern __attribute__((visibility("default"))) PRInt64 LL_Zero(void);
-extern __attribute__((visibility("default"))) PRUint64 LL_MaxUint(void);
-# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prlong.h"
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h" 2
-
-extern "C" {
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-typedef PRInt64 PRTime;
-
-
-
-
-
-
-typedef struct PRTimeParameters {
-    PRInt32 tp_gmt_offset;
-    PRInt32 tp_dst_offset;
-} PRTimeParameters;
-# 83 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-typedef struct PRExplodedTime {
-    PRInt32 tm_usec;
-    PRInt32 tm_sec;
-
-    PRInt32 tm_min;
-    PRInt32 tm_hour;
-    PRInt32 tm_mday;
-
-    PRInt32 tm_month;
-    PRInt16 tm_year;
-
-
-    PRInt8 tm_wday;
-
-    PRInt16 tm_yday;
-
-
-    PRTimeParameters tm_params;
-} PRExplodedTime;
-# 126 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-typedef PRTimeParameters ( *PRTimeParamFn)(const PRExplodedTime *gmt);
-# 145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-extern __attribute__((visibility("default"))) PRTime
-PR_Now(void);
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-extern __attribute__((visibility("default"))) void PR_ExplodeTime(
-    PRTime usecs, PRTimeParamFn params, PRExplodedTime *exploded);
-
-
-extern __attribute__((visibility("default"))) PRTime
-PR_ImplodeTime(const PRExplodedTime *exploded);
-# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-extern __attribute__((visibility("default"))) void PR_NormalizeTime(
-    PRExplodedTime *exploded, PRTimeParamFn params);
-
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRTimeParameters PR_LocalTimeParameters(const PRExplodedTime *gmt);
-
-
-extern __attribute__((visibility("default"))) PRTimeParameters PR_GMTParameters(const PRExplodedTime *gmt);
-
-
-
-
-
-extern __attribute__((visibility("default"))) PRTimeParameters PR_USPacificTimeParameters(const PRExplodedTime *gmt);
-# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeStringToExplodedTime (
-        const char *string,
-        PRBool default_to_gmt,
-        PRExplodedTime *result);
-# 244 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prtime.h"
-extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeString (
- const char *string,
- PRBool default_to_gmt,
- PRTime *result);
-
-
-extern __attribute__((visibility("default"))) PRUint32 PR_FormatTime(char *buf, int buflen, const char *fmt,
-                                 const PRExplodedTime *time);
-
-
-
-
-extern __attribute__((visibility("default"))) PRUint32
-PR_FormatTimeUSEnglish(char *buf, PRUint32 bufSize,
-                       const char *format, const PRExplodedTime *time);
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-struct JSFreeOp;
-class nsWrapperCache;
-class nsAXPCNativeCallContext;
-class nsIXPCScriptable;
-
-class nsIXPConnect;
-
-class nsIXPConnectWrappedNative;
-
-class nsIInterfaceInfo;
-
-class nsIXPCSecurityManager;
-
-class nsIPrincipal;
-
-class nsIClassInfo;
-
-class nsIVariant;
-
-class nsIStackFrame;
-
-class nsIObjectInputStream;
-
-class nsIObjectOutputStream;
-# 56 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPConnectJSObjectHolder : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual JSObject * GetJSObject(void) = 0;
-
-};
-
-  template<typename T> struct nsIXPConnectJSObjectHolder::COMTypeInfo<nsIXPConnectJSObjectHolder, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectJSObjectHolder::COMTypeInfo<nsIXPConnectJSObjectHolder, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x73e6ff4a, 0xab99, 0x4d99, { 0xac, 0x00, 0xba, 0x39, 0xcc, 0xb8, 0xe4, 0xd7 }};
-# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPConnectWrappedNative : public nsIXPConnectJSObjectHolder {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetNative(nsISupports * *aNative) = 0;
-
-
-  virtual nsresult GetJSObjectPrototype(JSObject **aJSObjectPrototype) = 0;
-
-
-  virtual nsresult FindInterfaceWithMember(JS::Handle<jsid> nameID, nsIInterfaceInfo * *_retval) = 0;
-
-
-  virtual nsresult FindInterfaceWithName(JS::Handle<jsid> nameID, nsIInterfaceInfo * *_retval) = 0;
-
-
-  virtual bool HasNativeMember(JS::Handle<jsid> name) = 0;
-
-
-  virtual nsresult DebugDump(int16_t depth) = 0;
-
-
-
-
-    nsISupports* Native() const { return mIdentity; }
-protected:
-    nsCOMPtr<nsISupports> mIdentity;
-public:
-};
-
-  template<typename T> struct nsIXPConnectWrappedNative::COMTypeInfo<nsIXPConnectWrappedNative, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedNative::COMTypeInfo<nsIXPConnectWrappedNative, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xe787be29, 0xdb5d, 0x4a45, { 0xa3, 0xd6, 0x1d, 0xe1, 0xd6, 0xb8, 0x5c, 0x30 }};
-# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-inline
-const nsQueryInterface
-do_QueryWrappedNative(nsIXPConnectWrappedNative *aWrappedNative)
-{
-    return nsQueryInterface(aWrappedNative->Native());
-}
-inline
-const nsQueryInterfaceWithError
-do_QueryWrappedNative(nsIXPConnectWrappedNative *aWrappedNative,
-                      nsresult *aError)
-{
-    return nsQueryInterfaceWithError(aWrappedNative->Native(), aError);
-}
-# 298 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPConnectWrappedJS : public nsIXPConnectJSObjectHolder {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetInterfaceInfo(nsIInterfaceInfo * *aInterfaceInfo) = 0;
-
-
-  virtual nsresult GetInterfaceIID(nsIID **aInterfaceIID) = 0;
-
-
-  virtual nsresult DebugDump(int16_t depth) = 0;
-
-
-  virtual nsresult AggregatedQueryInterface(const nsIID & uuid, void **result) = 0;
-
-};
-
-  template<typename T> struct nsIXPConnectWrappedJS::COMTypeInfo<nsIXPConnectWrappedJS, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedJS::COMTypeInfo<nsIXPConnectWrappedJS, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3a01b0d6, 0x074b, 0x49ed, { 0xba, 0xc3, 0x08, 0xc7, 0x63, 0x66, 0xca, 0xe4 }};
-# 415 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPConnectWrappedJSUnmarkGray : public nsIXPConnectWrappedJS {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct nsIXPConnectWrappedJSUnmarkGray::COMTypeInfo<nsIXPConnectWrappedJSUnmarkGray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnectWrappedJSUnmarkGray::COMTypeInfo<nsIXPConnectWrappedJSUnmarkGray, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xc02a0ce6, 0x275f, 0x4ea1, { 0x9c, 0x23, 0x08, 0x49, 0x48, 0x98, 0xb0, 0x70 }};
-# 484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPCWrappedJSObjectGetter : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetNeverCalled(nsISupports * *aNeverCalled) = 0;
-
-};
-
-  template<typename T> struct nsIXPCWrappedJSObjectGetter::COMTypeInfo<nsIXPCWrappedJSObjectGetter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCWrappedJSObjectGetter::COMTypeInfo<nsIXPCWrappedJSObjectGetter, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x254bb2e0, 0x6439, 0x11d4, { 0x8f, 0xe0, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }};
-# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPCFunctionThisTranslator : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult TranslateThis(nsISupports *aInitialThis, nsISupports * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIXPCFunctionThisTranslator::COMTypeInfo<nsIXPCFunctionThisTranslator, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCFunctionThisTranslator::COMTypeInfo<nsIXPCFunctionThisTranslator, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf5f84b70, 0x92eb, 0x41f1, { 0xa1, 0xdd, 0x2e, 0xaa, 0xc0, 0xed, 0x56, 0x4c }};
-# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPConnect.h"
-class nsIXPConnect : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-   static const nsID& GetCID() {static const nsID cid = { 0xcb6593e0, 0xf9b2, 0x11d2, { 0xbd, 0xd6, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }; return cid;}
-
-  virtual nsresult InitClassesWithNewWrappedGlobal(JSContext *aJSContext, nsISupports *aCOMObj, nsIPrincipal *aPrincipal, uint32_t aFlags, JS::CompartmentOptions & aOptions, nsIXPConnectJSObjectHolder * *_retval) = 0;
-
-  enum {
-    INIT_JS_STANDARD_CLASSES = 1U,
-    DONT_FIRE_ONNEWGLOBALHOOK = 2U,
-    OMIT_COMPONENTS_OBJECT = 4U
-  };
-
-
-  virtual nsresult WrapNative(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, JSObject **_retval) = 0;
-
-
-  virtual nsresult WrapNativeHolder(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectJSObjectHolder * *_retval) = 0;
-
-
-  virtual nsresult WrapNativeToJSVal(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, nsWrapperCache *aCache, const nsIID *aIID, bool aAllowWrapper, JS::MutableHandleValue aVal) = 0;
-
-
-  virtual nsresult WrapJS(JSContext *aJSContext, JSObject *aJSObj, const nsIID & aIID, void **result) = 0;
-
-
-  virtual nsresult JSValToVariant(JSContext *cx, JS::HandleValue aJSVal, nsIVariant * *_retval) = 0;
-
-
-  virtual nsresult GetWrappedNativeOfJSObject(JSContext *aJSContext, JSObject *aJSObj, nsIXPConnectWrappedNative * *_retval) = 0;
-
-
-  virtual nsISupports * GetNativeOfWrapper(JSContext *aJSContext, JSObject *aJSObj) = 0;
-
-
-  virtual nsresult GetCurrentJSStack(nsIStackFrame * *aCurrentJSStack) = 0;
-
-
-  virtual nsresult GetCurrentNativeCallContext(nsAXPCNativeCallContext **aCurrentNativeCallContext) = 0;
-
-
-  virtual nsresult DebugDump(int16_t depth) = 0;
-
-
-  virtual nsresult DebugDumpObject(nsISupports *aCOMObj, int16_t depth) = 0;
-
-
-  virtual nsresult DebugDumpJSStack(bool showArgs, bool showLocals, bool showThisProps) = 0;
-
-
-  virtual nsresult WrapJSAggregatedToNative(nsISupports *aOuter, JSContext *aJSContext, JSObject *aJSObj, const nsIID & aIID, void **result) = 0;
-
-
-  virtual nsresult GetWrappedNativeOfNativeObject(JSContext *aJSContext, JSObject *aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectWrappedNative * *_retval) = 0;
-
-
-  virtual nsresult SetFunctionThisTranslator(const nsIID & aIID, nsIXPCFunctionThisTranslator *aTranslator) = 0;
-
-
-  virtual nsresult GetWrappedNativePrototype(JSContext *aJSContext, JSObject *aScope, nsIClassInfo *aClassInfo, JSObject **_retval) = 0;
-
-
-  virtual nsresult VariantToJS(JSContext *ctx, JSObject *scope, nsIVariant *value, JS::MutableHandleValue _retval) = 0;
-
-
-  virtual nsresult JSToVariant(JSContext *ctx, JS::HandleValue value, nsIVariant * *_retval) = 0;
-
-
-  virtual nsresult CreateSandbox(JSContext *cx, nsIPrincipal *principal, JSObject **_retval) = 0;
-
-
-  virtual nsresult EvalInSandboxObject(const nsAString & source, const char * filename, JSContext *cx, JSObject *sandbox, JS::MutableHandleValue _retval) = 0;
-
-
-  virtual nsresult GarbageCollect(uint32_t reason) = 0;
-
-
-  virtual nsresult NotifyDidPaint(void) = 0;
-
-
-
-
-
-
-
-    virtual nsIPrincipal* GetPrincipal(JSObject* obj,
-                                       bool allowShortCircuit) const = 0;
-    virtual char* DebugPrintJSStack(bool showArgs,
-                                    bool showLocals,
-                                    bool showThisProps) = 0;
-
-  virtual nsresult WriteScript(nsIObjectOutputStream *aStream, JSContext *aJSContext, JSScript *aJSScript) = 0;
-
-
-  virtual nsresult ReadScript(nsIObjectInputStream *aStream, JSContext *aJSContext, JSScript **_retval) = 0;
-
-
-  virtual nsresult WriteFunction(nsIObjectOutputStream *aStream, JSContext *aJSContext, JSObject *aJSObject) = 0;
-
-
-  virtual nsresult ReadFunction(nsIObjectInputStream *aStream, JSContext *aJSContext, JSObject **_retval) = 0;
-
-};
-
-  template<typename T> struct nsIXPConnect::COMTypeInfo<nsIXPConnect, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPConnect::COMTypeInfo<nsIXPConnect, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x768507b5, 0xb981, 0x40c7, { 0x82, 0x76, 0xf6, 0xa1, 0xda, 0x50, 0x2a, 0x24 }};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h"
-class nsISimpleEnumerator;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIArray.h"
-class nsIArray : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-
-  virtual nsresult QueryElementAt(uint32_t index, const nsIID & uuid, void **result) = 0;
-
-
-  virtual nsresult IndexOf(uint32_t startIndex, nsISupports *element, uint32_t *_retval) = 0;
-
-
-  virtual nsresult Enumerate(nsISimpleEnumerator * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIArray::COMTypeInfo<nsIArray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIArray::COMTypeInfo<nsIArray, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x114744d9, 0xc369, 0x456e, { 0xb5, 0x5a, 0x52, 0xfe, 0x52, 0x88, 0x0d, 0x2d }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIURI.h" 1
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIURI.h"
-class nsIURI : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetSpec(nsACString & aSpec) = 0;
-  virtual nsresult SetSpec(const nsACString & aSpec) = 0;
-
-
-
-
-
-    nsCString GetSpecOrDefault()
-    {
-        nsCString spec;
-        nsresult rv = GetSpec(spec);
-        if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
-            spec.Assign("[nsIURI::GetSpec failed]");
-        }
-        return spec;
-    }
-
-  virtual nsresult GetPrePath(nsACString & aPrePath) = 0;
-
-
-  virtual nsresult GetScheme(nsACString & aScheme) = 0;
-  virtual nsresult SetScheme(const nsACString & aScheme) = 0;
-
-
-  virtual nsresult GetUserPass(nsACString & aUserPass) = 0;
-  virtual nsresult SetUserPass(const nsACString & aUserPass) = 0;
-
-
-  virtual nsresult GetUsername(nsACString & aUsername) = 0;
-  virtual nsresult SetUsername(const nsACString & aUsername) = 0;
-
-
-  virtual nsresult GetPassword(nsACString & aPassword) = 0;
-  virtual nsresult SetPassword(const nsACString & aPassword) = 0;
-
-
-  virtual nsresult GetHostPort(nsACString & aHostPort) = 0;
-  virtual nsresult SetHostPort(const nsACString & aHostPort) = 0;
-
-
-  virtual nsresult SetHostAndPort(const nsACString & hostport) = 0;
-
-
-  virtual nsresult GetHost(nsACString & aHost) = 0;
-  virtual nsresult SetHost(const nsACString & aHost) = 0;
-
-
-  virtual nsresult GetPort(int32_t *aPort) = 0;
-  virtual nsresult SetPort(int32_t aPort) = 0;
-
-
-  virtual nsresult GetPath(nsACString & aPath) = 0;
-  virtual nsresult SetPath(const nsACString & aPath) = 0;
-
-
-  virtual nsresult Equals(nsIURI *other, bool *_retval) = 0;
-
-
-  virtual nsresult SchemeIs(const char * scheme, bool *_retval) = 0;
-
-
-  virtual nsresult Clone(nsIURI * *_retval) = 0;
-
-
-  virtual nsresult Resolve(const nsACString & relativePath, nsACString & _retval) = 0;
-
-
-  virtual nsresult GetAsciiSpec(nsACString & aAsciiSpec) = 0;
-
-
-  virtual nsresult GetAsciiHostPort(nsACString & aAsciiHostPort) = 0;
-
-
-  virtual nsresult GetAsciiHost(nsACString & aAsciiHost) = 0;
-
-
-  virtual nsresult GetOriginCharset(nsACString & aOriginCharset) = 0;
-
-
-  virtual nsresult GetRef(nsACString & aRef) = 0;
-  virtual nsresult SetRef(const nsACString & aRef) = 0;
-
-
-  virtual nsresult EqualsExceptRef(nsIURI *other, bool *_retval) = 0;
-
-
-  virtual nsresult CloneIgnoringRef(nsIURI * *_retval) = 0;
-
-
-  virtual nsresult CloneWithNewRef(const nsACString & newRef, nsIURI * *_retval) = 0;
-
-
-  virtual nsresult GetSpecIgnoringRef(nsACString & aSpecIgnoringRef) = 0;
-
-
-  virtual nsresult GetHasRef(bool *aHasRef) = 0;
-
-
-  virtual nsresult GetFilePath(nsACString & aFilePath) = 0;
-  virtual nsresult SetFilePath(const nsACString & aFilePath) = 0;
-
-
-  virtual nsresult GetQuery(nsACString & aQuery) = 0;
-  virtual nsresult SetQuery(const nsACString & aQuery) = 0;
-
-};
-
-  template<typename T> struct nsIURI::COMTypeInfo<nsIURI, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIURI::COMTypeInfo<nsIURI, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x92073a54, 0x6d78, 0x4f30, { 0x91, 0x3a, 0xb8, 0x71, 0x81, 0x32, 0x08, 0xc6 }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
-class nsIControllers;
-
-class nsIDOMBlob;
-
-class nsIDOMLocation;
-
-class nsIDOMOfflineResourceList;
-
-class nsIPrompt;
-
-class nsISelection;
-
-class nsIVariant;
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
-class nsIDOMWindow : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct nsIDOMWindow::COMTypeInfo<nsIDOMWindow, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMWindow::COMTypeInfo<nsIDOMWindow, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb8343993, 0x0383, 0x4add, { 0x99, 0x30, 0xad, 0x17, 0x6b, 0x18, 0x92, 0x40 }};
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMWindow.h"
-class nsIDOMWindowInternal : public nsIDOMWindow {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct nsIDOMWindowInternal::COMTypeInfo<nsIDOMWindowInternal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMWindowInternal::COMTypeInfo<nsIDOMWindowInternal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8c589e65, 0x3237, 0x4cd1, { 0x8b, 0xad, 0xc5, 0xc4, 0x71, 0x35, 0xe7, 0x9b }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h"
-class mozIDOMWindow : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct mozIDOMWindow::COMTypeInfo<mozIDOMWindow, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID mozIDOMWindow::COMTypeInfo<mozIDOMWindow, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x75fbabd6, 0x7a2e, 0x4787, { 0xaa, 0x33, 0x44, 0x9a, 0x33, 0x51, 0x21, 0x35 }};
-# 94 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozIDOMWindow.h"
-class mozIDOMWindowProxy : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct mozIDOMWindowProxy::COMTypeInfo<mozIDOMWindowProxy, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID mozIDOMWindowProxy::COMTypeInfo<mozIDOMWindowProxy, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x53ca090c, 0xe739, 0x48b9, { 0x89, 0x11, 0x20, 0x8c, 0x72, 0xf9, 0x19, 0x1e }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-class nsGlobalWindow;
-class nsIArray;
-class nsIContent;
-class nsICSSDeclaration;
-class nsIDocShell;
-class nsIDocShellLoadInfo;
-class nsIDocument;
-class nsIEventTarget;
-class nsIIdleObserver;
-class nsIPrincipal;
-class nsIScriptTimeoutHandler;
-class nsIURI;
-class nsPIDOMWindowInner;
-class nsPIDOMWindowOuter;
-class nsPIWindowRoot;
-class nsXBLPrototypeHandler;
-
-typedef uint32_t SuspendTypes;
-
-namespace mozilla {
-class ThrottledEventQueue;
-namespace dom {
-class AudioContext;
-class DocGroup;
-class TabGroup;
-class Element;
-class Performance;
-class ServiceWorkerRegistration;
-class Timeout;
-class TimeoutManager;
-class CustomElementRegistry;
-enum class CallerType : uint32_t;
-}
-}
-
-
-
-
-
-
-enum PopupControlState {
-  openAllowed = 0,
-  openControlled,
-  openAbused,
-  openOverridden
-};
-
-enum UIStateChangeType
-{
-  UIStateChangeType_NoChange,
-  UIStateChangeType_Set,
-  UIStateChangeType_Clear,
-  UIStateChangeType_Invalid
-};
-
-enum class FullscreenReason
-{
-
-  ForFullscreenMode,
-
-  ForFullscreenAPI,
-
-
-
-  ForForceExitFullscreen
-};
-
-namespace mozilla {
-namespace dom {
-
-
-
-
-enum class LargeAllocStatus : uint8_t
-{
-
-
-
-  NONE,
-  SUCCESS,
-
-
-
-
-  NON_GET,
-  NON_E10S,
-  NOT_ONLY_TOPLEVEL_IN_TABGROUP,
-  NON_WIN32
-};
-}
-}
-
-
-
-
-template<class T>
-class nsPIDOMWindow : public T
-{
-public:
-  nsPIDOMWindowInner* AsInner();
-  const nsPIDOMWindowInner* AsInner() const;
-  nsPIDOMWindowOuter* AsOuter();
-  const nsPIDOMWindowOuter* AsOuter() const;
-
-  virtual nsPIDOMWindowOuter* GetPrivateRoot() = 0;
-  virtual mozilla::dom::CustomElementRegistry* CustomElements() = 0;
-
-  virtual void ActivateOrDeactivate(bool aActivate) = 0;
-# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual already_AddRefed<nsPIDOMWindowOuter> GetTop() = 0;
-  virtual already_AddRefed<nsPIDOMWindowOuter> GetParent() = 0;
-  virtual nsPIDOMWindowOuter* GetScriptableTop() = 0;
-  virtual nsPIDOMWindowOuter* GetScriptableParent() = 0;
-  virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() = 0;
-
-  bool IsRootOuterWindow()
-  {
-    do { } while (0);
-    return mIsRootOuterWindow;
-  }
-
-
-
-
-
-  virtual nsPIDOMWindowOuter* GetScriptableParentOrNull() = 0;
-
-
-  virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
-  virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
-
-  virtual bool IsTopLevelWindowActive() = 0;
-
-
-  virtual void SetActive(bool aActive)
-  {
-    do { } while (0);
-    mIsActive = aActive;
-  }
-
-  virtual void SetIsBackground(bool aIsBackground)
-  {
-    do { } while (0);
-    mIsBackground = aIsBackground;
-  }
-
-  mozilla::dom::EventTarget* GetChromeEventHandler() const
-  {
-    return mChromeEventHandler;
-  }
-
-
-  virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler) = 0;
-
-  mozilla::dom::EventTarget* GetParentTarget()
-  {
-    if (!mParentTarget) {
-      UpdateParentTarget();
-    }
-    return mParentTarget;
-  }
-
-  virtual void MaybeUpdateTouchState() {}
-
-  nsIDocument* GetExtantDoc() const
-  {
-    return mDoc;
-  }
-  nsIURI* GetDocumentURI() const;
-  nsIURI* GetDocBaseURI() const;
-
-  nsIDocument* GetDoc()
-  {
-    if (!mDoc) {
-      MaybeCreateDoc();
-    }
-    return mDoc;
-  }
-
-protected:
-
-
-  void MaybeCreateDoc();
-
-public:
-
-  inline bool IsLoading() const;
-  inline bool IsHandlingResizeEvent() const;
-
-
-
-
-  virtual void SetInitialPrincipalToSubject() = 0;
-
-  virtual PopupControlState PushPopupControlState(PopupControlState aState,
-                                                  bool aForce) const = 0;
-  virtual void PopPopupControlState(PopupControlState state) const = 0;
-  virtual PopupControlState GetPopupControlState() const = 0;
-
-
-
-  virtual already_AddRefed<nsISupports> SaveWindowState() = 0;
-
-
-  virtual nsresult RestoreWindowState(nsISupports *aState) = 0;
-
-
-
-
-
-  virtual bool IsSuspended() const = 0;
-  virtual bool IsFrozen() const = 0;
-
-
-
-  virtual nsresult FireDelayedDOMEvents() = 0;
-
-  nsPIDOMWindowOuter* GetOuterWindow()
-  {
-    return mIsInnerWindow ? mOuterWindow.get() : AsOuter();
-  }
-
-  bool IsInnerWindow() const
-  {
-    return mIsInnerWindow;
-  }
-
-  bool IsOuterWindow() const
-  {
-    return !IsInnerWindow();
-  }
-
-
-  virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument) = 0;
-
-
-
-
-  nsIDocShell *GetDocShell() const;
-
-
-
-
-
-  virtual void SetDocShell(nsIDocShell *aDocShell) = 0;
-
-
-
-
-  virtual void DetachFromDocShell() = 0;
-# 302 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual nsresult SetNewDocument(nsIDocument *aDocument,
-                                  nsISupports *aState,
-                                  bool aForceReuseInnerWindow) = 0;
-# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual void SetOpenerWindow(nsPIDOMWindowOuter* aOpener,
-                               bool aOriginalOpener) = 0;
-
-  virtual void EnsureSizeUpToDate() = 0;
-
-
-
-
-
-  virtual void EnterModalState() = 0;
-  virtual void LeaveModalState() = 0;
-
-
-  virtual bool CanClose() = 0;
-  virtual void ForceClose() = 0;
-
-  bool IsModalContentWindow() const
-  {
-    return mIsModalContentWindow;
-  }
-
-
-
-
-
-  void SetHasPaintEventListeners()
-  {
-    mMayHavePaintEventListener = true;
-  }
-
-
-
-
-
-  bool HasPaintEventListeners()
-  {
-    return mMayHavePaintEventListener;
-  }
-
-
-
-
-
-  void SetHasTouchEventListeners()
-  {
-    if (!mMayHaveTouchEventListener) {
-      mMayHaveTouchEventListener = true;
-      MaybeUpdateTouchState();
-    }
-  }
-
-
-
-
-
-
-
-  virtual nsresult SetFullscreenInternal(
-    FullscreenReason aReason, bool aIsFullscreen) = 0;
-# 383 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual void FinishFullscreenChange(bool aIsFullscreen) = 0;
-
-  virtual JSObject* GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) = 0;
-  virtual void CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
-                                        JS::Handle<JSObject*> aHandler) = 0;
-# 397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  nsIContent* GetFocusedNode() const;
-  virtual void SetFocusedNode(nsIContent* aNode,
-                              uint32_t aFocusMethod = 0,
-                              bool aNeedsFocus = false) = 0;
-
-
-
-
-  virtual uint32_t GetFocusMethod() = 0;
-# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod) = 0;
-
-
-
-
-
-  virtual void SetReadyForFocus() = 0;
-
-
-
-
-  virtual bool ShouldShowFocusRing() = 0;
-
-
-
-
-  virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
-                                     UIStateChangeType aShowFocusRings) = 0;
-
-
-
-
-
-  virtual void PageHidden() = 0;
-
-
-
-
-
-  virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI,
-                                           nsIURI *aNewURI) = 0;
-
-
-
-
-  virtual nsresult DispatchSyncPopState() = 0;
-
-
-
-
-
-
-
-  virtual void EnableDeviceSensor(uint32_t aType) = 0;
-
-
-
-
-
-
-
-  virtual void DisableDeviceSensor(uint32_t aType) = 0;
-
-
-
-
-
-
-  virtual void EnableTimeChangeNotifications() = 0;
-  virtual void DisableTimeChangeNotifications() = 0;
-# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual void SetHasGamepadEventListener(bool aHasGamepad = true) = 0;
-# 515 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  virtual nsresult SetArguments(nsIArray *aArguments) = 0;
-
-
-
-
-
-
-  virtual uint32_t GetSerial() = 0;
-
-
-
-
-  uint64_t WindowID() const { return mWindowID; }
-
-
-
-
-
-
-
-  virtual bool DispatchCustomEvent(const nsAString& aEventName) = 0;
-
-
-
-
-
-
-  virtual nsresult
-  OpenNoNavigate(const nsAString& aUrl, const nsAString& aName,
-                 const nsAString& aOptions, nsPIDOMWindowOuter **_retval) = 0;
-
-
-
-
-  virtual void
-  FirePopupBlockedEvent(nsIDocument* aDoc,
-                        nsIURI* aPopupURI,
-                        const nsAString& aPopupWindowName,
-                        const nsAString& aPopupWindowFeatures) = 0;
-
-
-  void MarkUncollectableForCCGeneration(uint32_t aGeneration)
-  {
-    mMarkedCCGeneration = aGeneration;
-  }
-
-  uint32_t GetMarkedCCGeneration()
-  {
-    return mMarkedCCGeneration;
-  }
-
-  virtual nsIDOMScreen* GetScreen() = 0;
-  virtual nsIDOMNavigator* GetNavigator() = 0;
-  virtual nsIDOMLocation* GetLocation() = 0;
-  virtual nsresult GetPrompter(nsIPrompt** aPrompt) = 0;
-  virtual nsresult GetControllers(nsIControllers** aControllers) = 0;
-  virtual already_AddRefed<nsISelection> GetSelection() = 0;
-  virtual already_AddRefed<nsPIDOMWindowOuter> GetOpener() = 0;
-  virtual already_AddRefed<nsIDOMWindowCollection> GetFrames() = 0;
-
-
-
-  virtual nsresult Open(const nsAString& aUrl, const nsAString& aName,
-                        const nsAString& aOptions,
-                        nsIDocShellLoadInfo* aLoadInfo,
-                        bool aForceNoOpener,
-                        nsPIDOMWindowOuter **_retval) = 0;
-  virtual nsresult OpenDialog(const nsAString& aUrl, const nsAString& aName,
-                              const nsAString& aOptions,
-                              nsISupports* aExtraArgument,
-                              nsPIDOMWindowOuter** _retval) = 0;
-
-  virtual nsresult GetInnerWidth(int32_t* aWidth) = 0;
-  virtual nsresult GetInnerHeight(int32_t* aHeight) = 0;
-  virtual already_AddRefed<nsICSSDeclaration>
-    GetComputedStyle(mozilla::dom::Element& aElt, const nsAString& aPseudoElt,
-                     mozilla::ErrorResult& aError) = 0;
-  virtual already_AddRefed<nsIDOMElement> GetFrameElement() = 0;
-  virtual already_AddRefed<nsIDOMOfflineResourceList> GetApplicationCache() = 0;
-  virtual bool Closed() = 0;
-  virtual bool GetFullScreen() = 0;
-  virtual nsresult SetFullScreen(bool aFullScreen) = 0;
-
-  virtual nsresult Focus() = 0;
-  virtual nsresult Close() = 0;
-
-  virtual nsresult MoveBy(int32_t aXDif, int32_t aYDif) = 0;
-  virtual nsresult UpdateCommands(const nsAString& anAction, nsISelection* aSel, int16_t aReason) = 0;
-
-  mozilla::dom::TabGroup* TabGroup();
-
-  mozilla::dom::DocGroup* GetDocGroup() const;
-
-  virtual nsIEventTarget*
-  EventTargetFor(mozilla::TaskCategory aCategory) const = 0;
-
-protected:
-
-
-
-
-  explicit nsPIDOMWindow<T>(nsPIDOMWindowOuter *aOuterWindow);
-
-  ~nsPIDOMWindow<T>();
-
-  void SetChromeEventHandlerInternal(mozilla::dom::EventTarget* aChromeEventHandler) {
-    mChromeEventHandler = aChromeEventHandler;
-
-    mParentTarget = nullptr;
-  }
-
-  virtual void UpdateParentTarget() = 0;
-
-
-
-
-  nsCOMPtr<mozilla::dom::EventTarget> mChromeEventHandler;
-  nsCOMPtr<nsIDocument> mDoc;
-
-  nsCOMPtr<nsIURI> mDocumentURI;
-  nsCOMPtr<nsIURI> mDocBaseURI;
-
-  nsCOMPtr<mozilla::dom::EventTarget> mParentTarget;
-
-
-  nsCOMPtr<mozilla::dom::Element> mFrameElement;
-
-
-
-  nsIDocShell* mDocShell;
-
-
-  RefPtr<mozilla::dom::Performance> mPerformance;
-
-  mozilla::UniquePtr<mozilla::dom::TimeoutManager> mTimeoutManager;
-
-  typedef nsRefPtrHashtable<nsStringHashKey,
-                            mozilla::dom::ServiceWorkerRegistration>
-          ServiceWorkerRegistrationTable;
-  ServiceWorkerRegistrationTable mServiceWorkerRegistrationTable;
-
-  uint32_t mModalStateDepth;
-
-
-  uint32_t mMutationBits;
-
-  bool mIsDocumentLoaded;
-  bool mIsHandlingResizeEvent;
-  bool mIsInnerWindow;
-  bool mMayHavePaintEventListener;
-  bool mMayHaveTouchEventListener;
-  bool mMayHaveMouseEnterLeaveEventListener;
-  bool mMayHavePointerEnterLeaveEventListener;
-
-
-
-
-  bool mInnerObjectsFreed;
-
-
-
-
-  bool mIsModalContentWindow;
-
-
-
-  bool mIsActive;
-
-
-
-
-  bool mIsBackground;
-# 699 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  SuspendTypes mMediaSuspend;
-
-  bool mAudioMuted;
-  float mAudioVolume;
-
-  bool mAudioCaptured;
-
-
-  bool mDesktopModeViewport;
-
-  bool mIsRootOuterWindow;
-
-
-  nsPIDOMWindowInner* mInnerWindow;
-  nsCOMPtr<nsPIDOMWindowOuter> mOuterWindow;
-
-
-
-  nsCOMPtr<nsIContent> mFocusedNode;
-
-
-  nsTArray<mozilla::dom::AudioContext*> mAudioContexts;
-
-
-  RefPtr<mozilla::dom::TabGroup> mTabGroup;
-
-
-
-  uint64_t mWindowID;
-
-
-
-  bool mHasNotifiedGlobalCreated;
-
-  uint32_t mMarkedCCGeneration;
-
-
-
-  bool mServiceWorkersTestingEnabled;
-
-  mozilla::dom::LargeAllocStatus mLargeAllocStatus;
-
-
-
-  bool mShouldResumeOnFirstActiveMediaComponent;
-};
-# 756 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-class nsPIDOMWindowInner : public nsPIDOMWindow<mozIDOMWindow>
-{
-  friend nsGlobalWindow;
-
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  static nsPIDOMWindowInner* From(mozIDOMWindow* aFrom) {
-    return static_cast<nsPIDOMWindowInner*>(aFrom);
-  }
-
-
-
-  inline bool IsCurrentInnerWindow() const;
-
-
-
-
-  inline bool HasActiveDocument();
-
-  bool AddAudioContext(mozilla::dom::AudioContext* aAudioContext);
-  void RemoveAudioContext(mozilla::dom::AudioContext* aAudioContext);
-  void MuteAudioContexts();
-  void UnmuteAudioContexts();
-
-  bool GetAudioCaptured() const;
-  nsresult SetAudioCapture(bool aCapture);
-
-  already_AddRefed<mozilla::dom::ServiceWorkerRegistration>
-    GetServiceWorkerRegistration(const nsAString& aScope);
-  void InvalidateServiceWorkerRegistration(const nsAString& aScope);
-
-  mozilla::dom::Performance* GetPerformance();
-
-  bool HasMutationListeners(uint32_t aMutationEventType) const
-  {
-    if (!mOuterWindow) {
-      do { } while(0);
-
-      return false;
-    }
-
-    return (mMutationBits & aMutationEventType) != 0;
-  }
-
-  void SetMutationListeners(uint32_t aType)
-  {
-    if (!mOuterWindow) {
-      do { } while(0);
-
-      return;
-    }
-
-    mMutationBits |= aType;
-  }
-
-
-
-
-
-  bool HasMouseEnterLeaveEventListeners()
-  {
-    return mMayHaveMouseEnterLeaveEventListener;
-  }
-
-
-
-
-
-  void SetHasMouseEnterLeaveEventListeners()
-  {
-    mMayHaveMouseEnterLeaveEventListener = true;
-  }
-
-
-
-
-
-  bool HasPointerEnterLeaveEventListeners()
-  {
-    return mMayHavePointerEnterLeaveEventListener;
-  }
-
-
-
-
-
-  void SetHasPointerEnterLeaveEventListeners()
-  {
-    mMayHavePointerEnterLeaveEventListener = true;
-  }
-
-
-
-
-  bool InnerObjectsFreed() const
-  {
-    return mInnerObjectsFreed;
-  }
-
-
-
-
-  bool IsSecureContext() const;
-  bool IsSecureContextIfOpenerIgnored() const;
-# 869 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  void Suspend();
-  void Resume();
-# 879 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-  void Freeze();
-  void Thaw();
-
-
-
-  void SyncStateFromParentWindow();
-
-  bool IsPlayingAudio();
-
-  mozilla::dom::TimeoutManager& TimeoutManager();
-
-  bool IsRunningTimeout();
-
-protected:
-  void CreatePerformanceObjectIfNeeded();
-};
-
-template<typename T> struct nsPIDOMWindowInner::COMTypeInfo<nsPIDOMWindowInner, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsPIDOMWindowInner::COMTypeInfo<nsPIDOMWindowInner, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x775dabc9, 0x8f43, 0x4277, { 0x9a, 0xdb, 0xf1, 0x99, 0x0d, 0x77, 0xcf, 0xfb } };
-
-
-
-class nsPIDOMWindowOuter : public nsPIDOMWindow<mozIDOMWindowProxy>
-{
-protected:
-  void RefreshMediaElementsVolume();
-  void RefreshMediaElementsSuspend(SuspendTypes aSuspend);
-  bool IsDisposableSuspend(SuspendTypes aSuspend) const;
-  void MaybeNotifyMediaResumedFromBlock(SuspendTypes aSuspend);
-
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  static nsPIDOMWindowOuter* From(mozIDOMWindowProxy* aFrom) {
-    return static_cast<nsPIDOMWindowOuter*>(aFrom);
-  }
-
-
-
-  static nsPIDOMWindowOuter* GetFromCurrentInner(nsPIDOMWindowInner* aInner);
-
-  nsPIDOMWindowInner* GetCurrentInnerWindow() const
-  {
-    return mInnerWindow;
-  }
-
-  nsPIDOMWindowInner* EnsureInnerWindow()
-  {
-    do { } while (0);
-
-    GetDoc();
-    return GetCurrentInnerWindow();
-  }
-
-
-
-
-  void SetInitialKeyboardIndicators(UIStateChangeType aShowAccelerators,
-                                    UIStateChangeType aShowFocusRings);
-
-
-
-
-  mozilla::dom::Element* GetFrameElementInternal() const;
-  void SetFrameElementInternal(mozilla::dom::Element* aFrameElement);
-
-  bool IsActive()
-  {
-    return mIsActive;
-  }
-
-  void SetDesktopModeViewport(bool aDesktopModeViewport)
-  {
-    mDesktopModeViewport = aDesktopModeViewport;
-  }
-  bool IsDesktopModeViewport() const
-  {
-    return mDesktopModeViewport;
-  }
-  bool IsBackground()
-  {
-    return mIsBackground;
-  }
-
-
-  SuspendTypes GetMediaSuspend() const;
-  void SetMediaSuspend(SuspendTypes aSuspend);
-
-  bool GetAudioMuted() const;
-  void SetAudioMuted(bool aMuted);
-
-  float GetAudioVolume() const;
-  nsresult SetAudioVolume(float aVolume);
-
-  void NotifyCreatedNewMediaComponent();
-  void MaybeActiveMediaComponents();
-
-  void SetServiceWorkersTestingEnabled(bool aEnabled);
-  bool GetServiceWorkersTestingEnabled();
-
-  float GetDevicePixelRatio(mozilla::dom::CallerType aCallerType);
-
-  void SetLargeAllocStatus(mozilla::dom::LargeAllocStatus aStatus);
-
-  bool IsTopLevelWindow();
-  bool HadOriginalOpener() const;
-};
-
-template<typename T> struct nsPIDOMWindowOuter::COMTypeInfo<nsPIDOMWindowOuter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsPIDOMWindowOuter::COMTypeInfo<nsPIDOMWindowOuter, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x769693d4, 0xb009, 0x4fe2, { 0xaf, 0x18, 0x7d, 0xc8, 0xdf, 0x74, 0x96, 0xdf } };
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindowInlines.h" 1
-
-
-
-
-template<class T>
-nsPIDOMWindowInner*
-nsPIDOMWindow<T>::AsInner()
-{
-  do { } while (0);
-  return reinterpret_cast<nsPIDOMWindowInner*>(this);
-}
-
-template<class T>
-const nsPIDOMWindowInner*
-nsPIDOMWindow<T>::AsInner() const
-{
-  do { } while (0);
-  return reinterpret_cast<const nsPIDOMWindowInner*>(this);
-}
-
-template<class T>
-nsPIDOMWindowOuter*
-nsPIDOMWindow<T>::AsOuter()
-{
-  do { } while (0);
-  return reinterpret_cast<nsPIDOMWindowOuter*>(this);
-}
-
-template<class T>
-const nsPIDOMWindowOuter*
-nsPIDOMWindow<T>::AsOuter() const
-{
-  do { } while (0);
-  return reinterpret_cast<const nsPIDOMWindowOuter*>(this);
-}
-
-template <class T>
-bool
-nsPIDOMWindow<T>::IsLoading() const
-{
-  if (IsOuterWindow()) {
-    auto* win = AsOuter()->GetCurrentInnerWindow();
-
-    if (!win) {
-      do { } while(0);
-
-      return false;
-    }
-
-    return win->IsLoading();
-  }
-
-  if (!mOuterWindow) {
-    do { } while(0);
-
-    return false;
-  }
-
-  return !mIsDocumentLoaded;
-}
-
-template <class T>
-bool
-nsPIDOMWindow<T>::IsHandlingResizeEvent() const
-{
-  if (IsOuterWindow()) {
-    auto* win = AsOuter()->GetCurrentInnerWindow();
-
-    if (!win) {
-      do { } while(0);
-
-      return false;
-    }
-
-    return win->IsHandlingResizeEvent();
-  }
-
-  if (!mOuterWindow) {
-    do { } while(0);
-
-    return false;
-  }
-
-  return mIsHandlingResizeEvent;
-}
-
-bool
-nsPIDOMWindowInner::IsCurrentInnerWindow() const
-{
-  return mOuterWindow && mOuterWindow->GetCurrentInnerWindow() == AsInner();
-}
-
-bool
-nsPIDOMWindowInner::HasActiveDocument()
-{
-  return IsCurrentInnerWindow() ||
-    (mOuterWindow &&
-     mOuterWindow->GetCurrentInnerWindow() &&
-     mOuterWindow->GetCurrentInnerWindow()->GetDoc() == mDoc);
-}
-
-template <class T>
-nsIDocShell*
-nsPIDOMWindow<T>::GetDocShell() const
-{
-  if (mOuterWindow) {
-    return mOuterWindow->GetDocShell();
-  }
-
-  return mDocShell;
-}
-
-template <class T>
-nsIContent*
-nsPIDOMWindow<T>::GetFocusedNode() const
-{
-  if (IsOuterWindow()) {
-    return mInnerWindow ? mInnerWindow->GetFocusedNode() : nullptr;
-  }
-
-  return mFocusedNode;
-}
-# 989 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h" 2
-
-
-PopupControlState
-PushPopupControlState(PopupControlState aState, bool aForce);
-
-void
-PopPopupControlState(PopupControlState aState);
-# 1008 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-class nsAutoPopupStatePusherInternal
-{
-public:
-
-  explicit nsAutoPopupStatePusherInternal(PopupControlState aState, bool aForce = false)
-    : mOldState(::PushPopupControlState(aState, aForce))
-  {
-  }
-
-  ~nsAutoPopupStatePusherInternal()
-  {
-    PopPopupControlState(mOldState);
-  }
-# 1038 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPIDOMWindow.h"
-protected:
-
-
-
-  PopupControlState mOldState;
-
-private:
-
-  static void* operator new(size_t ) throw() { return nullptr; }
-  static void operator delete(void* ) {}
-};
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/JSSlots.h" 1
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h"
-class nsIObserver;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch.h"
-class nsIPrefBranch : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    PREF_INVALID = 0,
-    PREF_STRING = 32,
-    PREF_INT = 64,
-    PREF_BOOL = 128
-  };
-
-
-  virtual nsresult GetRoot(char * *aRoot) = 0;
-
-
-  virtual nsresult GetPrefType(const char * aPrefName, int32_t *_retval) = 0;
-
-
-  virtual nsresult GetBoolPrefWithDefault(const char * aPrefName, bool aDefaultValue, uint8_t _argc, bool *_retval) = 0;
-
-
-  virtual nsresult GetBoolPref(const char * aPrefName, bool *_retval) = 0;
-
-
-  virtual nsresult SetBoolPref(const char * aPrefName, bool aValue) = 0;
-
-
-  virtual nsresult GetFloatPrefWithDefault(const char * aPrefName, float aDefaultValue, uint8_t _argc, float *_retval) = 0;
-
-
-  virtual nsresult GetFloatPref(const char * aPrefName, float *_retval) = 0;
-
-
-  virtual nsresult GetCharPrefWithDefault(const char * aPrefName, const char * aDefaultValue, uint8_t _argc, char * *_retval) = 0;
-
-
-  virtual nsresult GetCharPref(const char * aPrefName, char * *_retval) = 0;
-
-
-  virtual nsresult SetCharPref(const char * aPrefName, const char * aValue) = 0;
-
-
-  virtual nsresult GetStringPref(const char * aPrefName, const nsACString & aDefaultValue, uint8_t _argc, nsACString & _retval) = 0;
-
-
-  virtual nsresult SetStringPref(const char * aPrefName, const nsACString & aValue) = 0;
-
-
-  virtual nsresult GetIntPrefWithDefault(const char * aPrefName, int32_t aDefaultValue, uint8_t _argc, int32_t *_retval) = 0;
-
-
-  virtual nsresult GetIntPref(const char * aPrefName, int32_t *_retval) = 0;
-
-
-  virtual nsresult SetIntPref(const char * aPrefName, int32_t aValue) = 0;
-
-
-  virtual nsresult GetComplexValue(const char * aPrefName, const nsIID & aType, void **aValue) = 0;
-
-
-  virtual nsresult SetComplexValue(const char * aPrefName, const nsIID & aType, nsISupports *aValue) = 0;
-
-
-  virtual nsresult ClearUserPref(const char * aPrefName) = 0;
-
-
-  virtual nsresult LockPref(const char * aPrefName) = 0;
-
-
-  virtual nsresult PrefHasUserValue(const char * aPrefName, bool *_retval) = 0;
-
-
-  virtual nsresult PrefIsLocked(const char * aPrefName, bool *_retval) = 0;
-
-
-  virtual nsresult UnlockPref(const char * aPrefName) = 0;
-
-
-  virtual nsresult DeleteBranch(const char * aStartingAt) = 0;
-
-
-  virtual nsresult GetChildList(const char * aStartingAt, uint32_t *aCount, char * **aChildArray) = 0;
-
-
-  virtual nsresult ResetBranch(const char * aStartingAt) = 0;
-
-
-  virtual nsresult AddObserver(const char * aDomain, nsIObserver *aObserver, bool aHoldWeak) = 0;
-
-
-  virtual nsresult RemoveObserver(const char * aDomain, nsIObserver *aObserver) = 0;
-
-};
-
-  template<typename T> struct nsIPrefBranch::COMTypeInfo<nsIPrefBranch, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranch::COMTypeInfo<nsIPrefBranch, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x55d25e49, 0x793f, 0x4727, { 0xa6, 0x9f, 0xde, 0x8b, 0x15, 0xf4, 0xb9, 0x85 }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h" 2
-
-
-
-
-
-
-struct PrefTuple;
-
-class nsIFile;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefService.h"
-class nsIPrefService : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult ReadUserPrefs(nsIFile *aFile) = 0;
-
-
-  virtual nsresult ResetPrefs(void) = 0;
-
-
-  virtual nsresult ResetUserPrefs(void) = 0;
-
-
-  virtual nsresult SavePrefFile(nsIFile *aFile) = 0;
-
-
-  virtual nsresult GetBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) = 0;
-
-
-  virtual nsresult GetDefaultBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) = 0;
-
-
-  virtual nsresult GetDirty(bool *aDirty) = 0;
-
-};
-
-  template<typename T> struct nsIPrefService::COMTypeInfo<nsIPrefService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefService::COMTypeInfo<nsIPrefService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x1f84fd56, 0x3956, 0x40df, { 0xb8, 0x6a, 0x1e, 0xa0, 0x14, 0x02, 0xee, 0x96 }};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch2.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranch2.h"
-class nsIPrefBranch2 : public nsIPrefBranch {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct nsIPrefBranch2::COMTypeInfo<nsIPrefBranch2, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranch2::COMTypeInfo<nsIPrefBranch2, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8892016d, 0x07f7, 0x4530, { 0xb5, 0xc1, 0xd7, 0x3d, 0xfc, 0xde, 0x4a, 0x1c }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIPrefBranchInternal.h"
-class nsIPrefBranchInternal : public nsIPrefBranch2 {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-};
-
-  template<typename T> struct nsIPrefBranchInternal::COMTypeInfo<nsIPrefBranchInternal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIPrefBranchInternal::COMTypeInfo<nsIPrefBranchInternal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x355bd1e9, 0x248a, 0x438b, { 0x80, 0x9d, 0xe0, 0xdb, 0x1b, 0x28, 0x78, 0x82 }};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h" 2
-
-
-
-
-
-
-
-class nsIFile;
-class nsAdoptingString;
-class nsAdoptingCString;
-
-
-typedef void (*PrefChangedFunc)(const char *, void *);
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-namespace mozilla {
-
-namespace dom {
-class PrefSetting;
-}
-
-class Preferences final : public nsIPrefService,
-                          public nsIObserver,
-                          public nsIPrefBranchInternal,
-                          public nsSupportsWeakReference
-{
-public:
-  typedef mozilla::dom::PrefSetting PrefSetting;
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-  virtual nsresult ReadUserPrefs(nsIFile *aFile) override; virtual nsresult ResetPrefs(void) override; virtual nsresult ResetUserPrefs(void) override; virtual nsresult SavePrefFile(nsIFile *aFile) override; virtual nsresult GetBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) override; virtual nsresult GetDefaultBranch(const char * aPrefRoot, nsIPrefBranch * *_retval) override; virtual nsresult GetDirty(bool *aDirty) override;
-  virtual nsresult GetRoot(char * *aRoot) override { return sRootBranch-> GetRoot(aRoot); } virtual nsresult GetPrefType(const char * aPrefName, int32_t *_retval) override { return sRootBranch-> GetPrefType(aPrefName, _retval); } virtual nsresult GetBoolPrefWithDefault(const char * aPrefName, bool aDefaultValue, uint8_t _argc, bool *_retval) override { return sRootBranch-> GetBoolPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetBoolPref(const char * aPrefName, bool *_retval) override { return sRootBranch-> GetBoolPref(aPrefName, _retval); } virtual nsresult SetBoolPref(const char * aPrefName, bool aValue) override { return sRootBranch-> SetBoolPref(aPrefName, aValue); } virtual nsresult GetFloatPrefWithDefault(const char * aPrefName, float aDefaultValue, uint8_t _argc, float *_retval) override { return sRootBranch-> GetFloatPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetFloatPref(const char * aPrefName, float *_retval) override { return sRootBranch-> GetFloatPref(aPrefName, _retval); } virtual nsresult GetCharPrefWithDefault(const char * aPrefName, const char * aDefaultValue, uint8_t _argc, char * *_retval) override { return sRootBranch-> GetCharPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetCharPref(const char * aPrefName, char * *_retval) override { return sRootBranch-> GetCharPref(aPrefName, _retval); } virtual nsresult SetCharPref(const char * aPrefName, const char * aValue) override { return sRootBranch-> SetCharPref(aPrefName, aValue); } virtual nsresult GetStringPref(const char * aPrefName, const nsACString & aDefaultValue, uint8_t _argc, nsACString & _retval) override { return sRootBranch-> GetStringPref(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult SetStringPref(const char * aPrefName, const nsACString & aValue) override { return sRootBranch-> SetStringPref(aPrefName, aValue); } virtual nsresult GetIntPrefWithDefault(const char * aPrefName, int32_t aDefaultValue, uint8_t _argc, int32_t *_retval) override { return sRootBranch-> GetIntPrefWithDefault(aPrefName, aDefaultValue, _argc, _retval); } virtual nsresult GetIntPref(const char * aPrefName, int32_t *_retval) override { return sRootBranch-> GetIntPref(aPrefName, _retval); } virtual nsresult SetIntPref(const char * aPrefName, int32_t aValue) override { return sRootBranch-> SetIntPref(aPrefName, aValue); } virtual nsresult GetComplexValue(const char * aPrefName, const nsIID & aType, void **aValue) override { return sRootBranch-> GetComplexValue(aPrefName, aType, aValue); } virtual nsresult SetComplexValue(const char * aPrefName, const nsIID & aType, nsISupports *aValue) override { return sRootBranch-> SetComplexValue(aPrefName, aType, aValue); } virtual nsresult ClearUserPref(const char * aPrefName) override { return sRootBranch-> ClearUserPref(aPrefName); } virtual nsresult LockPref(const char * aPrefName) override { return sRootBranch-> LockPref(aPrefName); } virtual nsresult PrefHasUserValue(const char * aPrefName, bool *_retval) override { return sRootBranch-> PrefHasUserValue(aPrefName, _retval); } virtual nsresult PrefIsLocked(const char * aPrefName, bool *_retval) override { return sRootBranch-> PrefIsLocked(aPrefName, _retval); } virtual nsresult UnlockPref(const char * aPrefName) override { return sRootBranch-> UnlockPref(aPrefName); } virtual nsresult DeleteBranch(const char * aStartingAt) override { return sRootBranch-> DeleteBranch(aStartingAt); } virtual nsresult GetChildList(const char * aStartingAt, uint32_t *aCount, char * **aChildArray) override { return sRootBranch-> GetChildList(aStartingAt, aCount, aChildArray); } virtual nsresult ResetBranch(const char * aStartingAt) override { return sRootBranch-> ResetBranch(aStartingAt); } virtual nsresult AddObserver(const char * aDomain, nsIObserver *aObserver, bool aHoldWeak) override { return sRootBranch-> AddObserver(aDomain, aObserver, aHoldWeak); } virtual nsresult RemoveObserver(const char * aDomain, nsIObserver *aObserver) override { return sRootBranch-> RemoveObserver(aDomain, aObserver); }
-  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
-
-  Preferences();
-
-  nsresult Init();
-
-
-
-
-  static bool IsServiceAvailable();
-
-
-
-
-  static nsresult ResetAndReadUserPrefs();
-
-
-
-
-  static Preferences* GetInstanceForService();
-
-
-
-
-  static void Shutdown();
-
-
-
-
-
-  static nsIPrefService* GetService()
-  {
-    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
-    return sPreferences;
-  }
-
-
-
-
-
-  static nsIPrefBranch* GetRootBranch()
-  {
-    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
-    return sRootBranch;
-  }
-
-
-
-
-
-  static nsIPrefBranch* GetDefaultRootBranch()
-  {
-    do { if ((__builtin_expect(!!(!(InitStaticMembers())), 0))) { do { } while(0); return nullptr; } } while(0);
-    return sDefaultRootBranch;
-  }
-
-
-
-
-
-  static bool GetBool(const char* aPref, bool aDefault = false)
-  {
-    bool result = aDefault;
-    GetBool(aPref, &result);
-    return result;
-  }
-
-  static int32_t GetInt(const char* aPref, int32_t aDefault = 0)
-  {
-    int32_t result = aDefault;
-    GetInt(aPref, &result);
-    return result;
-  }
-
-  static uint32_t GetUint(const char* aPref, uint32_t aDefault = 0)
-  {
-    uint32_t result = aDefault;
-    GetUint(aPref, &result);
-    return result;
-  }
-
-  static float GetFloat(const char* aPref, float aDefault = 0)
-  {
-    float result = aDefault;
-    GetFloat(aPref, &result);
-    return result;
-  }
-# 172 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-  static nsAdoptingCString GetCString(const char* aPref);
-  static nsAdoptingString GetString(const char* aPref);
-  static nsAdoptingCString GetLocalizedCString(const char* aPref);
-  static nsAdoptingString GetLocalizedString(const char* aPref);
-# 185 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-  static nsresult GetBool(const char* aPref, bool* aResult);
-  static nsresult GetInt(const char* aPref, int32_t* aResult);
-  static nsresult GetFloat(const char* aPref, float* aResult);
-  static nsresult GetUint(const char* aPref, uint32_t* aResult)
-  {
-    int32_t result;
-    nsresult rv = GetInt(aPref, &result);
-    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
-      *aResult = static_cast<uint32_t>(result);
-    }
-    return rv;
-  }
-# 205 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-  static nsresult GetCString(const char* aPref, nsACString* aResult);
-  static nsresult GetString(const char* aPref, nsAString* aResult);
-  static nsresult GetLocalizedCString(const char* aPref, nsACString* aResult);
-  static nsresult GetLocalizedString(const char* aPref, nsAString* aResult);
-
-  static nsresult GetComplex(const char* aPref, const nsIID &aType,
-                             void** aResult);
-
-
-
-
-  static nsresult SetBool(const char* aPref, bool aValue);
-  static nsresult SetInt(const char* aPref, int32_t aValue);
-  static nsresult SetUint(const char* aPref, uint32_t aValue)
-  {
-    return SetInt(aPref, static_cast<int32_t>(aValue));
-  }
-  static nsresult SetFloat(const char* aPref, float aValue);
-  static nsresult SetCString(const char* aPref, const char* aValue);
-  static nsresult SetCString(const char* aPref, const nsACString &aValue);
-  static nsresult SetString(const char* aPref, const char16ptr_t aValue);
-  static nsresult SetString(const char* aPref, const nsAString &aValue);
-
-  static nsresult SetComplex(const char* aPref, const nsIID &aType,
-                             nsISupports* aValue);
-
-
-
-
-  static nsresult ClearUser(const char* aPref);
-
-
-
-
-  static bool HasUserValue(const char* aPref);
-
-
-
-
-  static int32_t GetType(const char* aPref);
-
-
-
-
-
-
-
-  static nsresult AddStrongObserver(nsIObserver* aObserver, const char* aPref);
-  static nsresult AddWeakObserver(nsIObserver* aObserver, const char* aPref);
-  static nsresult RemoveObserver(nsIObserver* aObserver, const char* aPref);
-
-
-
-
-
-  static nsresult AddStrongObservers(nsIObserver* aObserver,
-                                     const char** aPrefs);
-  static nsresult AddWeakObservers(nsIObserver* aObserver,
-                                   const char** aPrefs);
-  static nsresult RemoveObservers(nsIObserver* aObserver,
-                                  const char** aPrefs);
-
-
-
-
-  static nsresult RegisterCallback(PrefChangedFunc aCallback,
-                                   const char* aPref,
-                                   void* aClosure = nullptr)
-  {
-    return RegisterCallback(aCallback, aPref, aClosure, ExactMatch);
-  }
-  static nsresult UnregisterCallback(PrefChangedFunc aCallback,
-                                     const char* aPref,
-                                     void* aClosure = nullptr)
-  {
-    return UnregisterCallback(aCallback, aPref, aClosure, ExactMatch);
-  }
-
-
-  static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
-                                          const char* aPref,
-                                          void* aClosure = nullptr)
-  {
-    return RegisterCallbackAndCall(aCallback, aPref, aClosure, ExactMatch);
-  }
-
-
-
-
-
-  static nsresult RegisterPrefixCallback(PrefChangedFunc aCallback,
-                                         const char* aPref,
-                                         void* aClosure = nullptr)
-  {
-    return RegisterCallback(aCallback, aPref, aClosure, PrefixMatch);
-  }
-
-
-
-
-
-  static nsresult RegisterPrefixCallbackAndCall(PrefChangedFunc aCallback,
-                                                const char* aPref,
-                                                void* aClosure = nullptr)
-  {
-    return RegisterCallbackAndCall(aCallback, aPref, aClosure, PrefixMatch);
-  }
-
-
-
-
-
-  static nsresult UnregisterPrefixCallback(PrefChangedFunc aCallback,
-                                           const char* aPref,
-                                           void* aClosure = nullptr)
-  {
-    return UnregisterCallback(aCallback, aPref, aClosure, PrefixMatch);
-  }
-
-
-
-
-
-
-
-  static nsresult AddBoolVarCache(bool* aVariable,
-                                  const char* aPref,
-                                  bool aDefault = false);
-  static nsresult AddIntVarCache(int32_t* aVariable,
-                                 const char* aPref,
-                                 int32_t aDefault = 0);
-  static nsresult AddUintVarCache(uint32_t* aVariable,
-                                  const char* aPref,
-                                  uint32_t aDefault = 0);
-  template <MemoryOrdering Order>
-  static nsresult AddAtomicUintVarCache(Atomic<uint32_t, Order>* aVariable,
-                                        const char* aPref,
-                                        uint32_t aDefault = 0);
-  static nsresult AddFloatVarCache(float* aVariable,
-                                   const char* aPref,
-                                   float aDefault = 0.0f);
-
-
-
-
-
-
-
-  static nsresult GetDefaultBool(const char* aPref, bool* aResult);
-  static nsresult GetDefaultInt(const char* aPref, int32_t* aResult);
-  static nsresult GetDefaultUint(const char* aPref, uint32_t* aResult)
-  {
-    return GetDefaultInt(aPref, reinterpret_cast<int32_t*>(aResult));
-  }
-
-
-
-
-
-
-
-  static bool GetDefaultBool(const char* aPref, bool aFailedResult)
-  {
-    bool result;
-    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetDefaultBool(aPref, &result))), 1))) ? result :
-                                                          aFailedResult;
-  }
-  static int32_t GetDefaultInt(const char* aPref, int32_t aFailedResult)
-  {
-    int32_t result;
-    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(GetDefaultInt(aPref, &result))), 1))) ? result : aFailedResult;
-  }
-  static uint32_t GetDefaultUint(const char* aPref, uint32_t aFailedResult)
-  {
-   return static_cast<uint32_t>(
-     GetDefaultInt(aPref, static_cast<int32_t>(aFailedResult)));
-  }
-# 391 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Preferences.h"
-  static nsAdoptingString GetDefaultString(const char* aPref);
-  static nsAdoptingCString GetDefaultCString(const char* aPref);
-  static nsAdoptingString GetDefaultLocalizedString(const char* aPref);
-  static nsAdoptingCString GetDefaultLocalizedCString(const char* aPref);
-
-  static nsresult GetDefaultCString(const char* aPref, nsACString* aResult);
-  static nsresult GetDefaultString(const char* aPref, nsAString* aResult);
-  static nsresult GetDefaultLocalizedCString(const char* aPref,
-                                             nsACString* aResult);
-  static nsresult GetDefaultLocalizedString(const char* aPref,
-                                            nsAString* aResult);
-
-  static nsresult GetDefaultComplex(const char* aPref, const nsIID &aType,
-                                    void** aResult);
-
-
-
-
-  static int32_t GetDefaultType(const char* aPref);
-
-
-  static void GetPreferences(InfallibleTArray<PrefSetting>* aPrefs);
-  static void GetPreference(PrefSetting* aPref);
-  static void SetPreference(const PrefSetting& aPref);
-
-  static void SetInitPreferences(nsTArray<PrefSetting>* aPrefs);
-
-
-
-
-
-
-  static int64_t SizeOfIncludingThisAndOtherStuff(mozilla::MallocSizeOf aMallocSizeOf);
-
-  static void DirtyCallback();
-
-protected:
-  virtual ~Preferences();
-
-  nsresult NotifyServiceObservers(const char *aSubject);
-
-
-
-
-
-
-  nsresult UseDefaultPrefFile();
-  nsresult UseUserPrefFile();
-  nsresult ReadAndOwnUserPrefFile(nsIFile *aFile);
-  nsresult ReadAndOwnSharedUserPrefFile(nsIFile *aFile);
-  nsresult SavePrefFileInternal(nsIFile* aFile);
-  nsresult WritePrefFile(nsIFile* aFile);
-  nsresult MakeBackupPrefFile(nsIFile *aFile);
-
-
-
-
-
-public:
-
-  enum MatchKind {
-    PrefixMatch,
-    ExactMatch,
-  };
-
-protected:
-  static nsresult RegisterCallback(PrefChangedFunc aCallback,
-                                   const char* aPref,
-                                   void* aClosure,
-                                   MatchKind aMatchKind);
-  static nsresult UnregisterCallback(PrefChangedFunc aCallback,
-                                     const char* aPref,
-                                     void* aClosure,
-                                     MatchKind aMatchKind);
-  static nsresult RegisterCallbackAndCall(PrefChangedFunc aCallback,
-                                          const char* aPref,
-                                          void* aClosure,
-                                          MatchKind aMatchKind);
-
-private:
-  nsCOMPtr<nsIFile> mCurrentFile;
-  bool mDirty;
-
-  static Preferences* sPreferences;
-  static nsIPrefBranch* sRootBranch;
-  static nsIPrefBranch* sDefaultRootBranch;
-  static bool sShutdown;
-
-
-
-
-  static bool InitStaticMembers();
-};
-
-}
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h" 2
-
-class nsGlobalWindow;
-class nsIPrincipal;
-class nsScriptNameSpaceManager;
-class nsIMemoryReporterCallback;
-
-namespace mozilla {
-namespace dom {
-class Exception;
-}
-}
-
-typedef void (* xpcGCCallback)(JSGCStatus status);
-
-namespace xpc {
-
-class Scriptability {
-public:
-    explicit Scriptability(JSCompartment* c);
-    bool Allowed();
-    bool IsImmuneToScriptPolicy();
-
-    void Block();
-    void Unblock();
-    void SetDocShellAllowsScript(bool aAllowed);
-
-    static Scriptability& Get(JSObject* aScope);
-
-private:
-
-
-
-
-    uint32_t mScriptBlocks;
-
-
-
-    bool mDocShellAllowsScript;
-
-
-
-    bool mImmuneToScriptPolicy;
-
-
-
-    bool mScriptBlockedByPolicy;
-};
-
-JSObject*
-TransplantObject(JSContext* cx, JS::HandleObject origobj, JS::HandleObject target);
-
-bool IsContentXBLScope(JSCompartment* compartment);
-bool IsInContentXBLScope(JSObject* obj);
-# 96 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-JSObject*
-GetXBLScope(JSContext* cx, JSObject* contentScope);
-
-inline JSObject*
-GetXBLScopeOrGlobal(JSContext* cx, JSObject* obj)
-{
-    if (IsInContentXBLScope(obj))
-        return js::GetGlobalForObjectCrossCompartment(obj);
-    return GetXBLScope(cx, obj);
-}
-
-
-
-
-
-JSObject*
-GetScopeForXBLExecution(JSContext* cx, JS::HandleObject obj, JSAddonId* addonId);
-
-
-
-bool
-AllowContentXBLScope(JSCompartment* c);
-
-
-
-
-
-bool
-UseContentXBLScope(JSCompartment* c);
-
-
-
-void
-ClearContentXBLScope(JSObject* global);
-
-bool
-IsInAddonScope(JSObject* obj);
-
-JSObject*
-GetAddonScope(JSContext* cx, JS::HandleObject contentScope, JSAddonId* addonId);
-
-bool
-IsSandboxPrototypeProxy(JSObject* obj);
-
-bool
-IsReflector(JSObject* obj);
-
-bool
-IsXrayWrapper(JSObject* obj);
-
-
-
-
-
-
-JSObject*
-XrayAwareCalleeGlobal(JSObject* fun);
-# 165 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-bool
-XrayAwareCalleeGlobalForSpecializedGetters(JSContext* cx,
-                                           JS::Handle<JSObject*> thisObj,
-                                           JS::MutableHandle<JSObject*> global);
-
-
-void
-TraceXPCGlobal(JSTracer* trc, JSObject* obj);
-
-}
-
-namespace JS {
-
-struct RuntimeStats;
-
-}
-# 193 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-inline JSObject*
-xpc_FastGetCachedWrapper(JSContext* cx, nsWrapperCache* cache, JS::MutableHandleValue vp)
-{
-    if (cache) {
-        JSObject* wrapper = cache->GetWrapper();
-        if (wrapper &&
-            js::GetObjectCompartment(wrapper) == js::GetContextCompartment(cx))
-        {
-            vp.setObject(*wrapper);
-            return wrapper;
-        }
-    }
-
-    return nullptr;
-}
-
-
-
-extern void
-xpc_MarkInCCGeneration(nsISupports* aVariant, uint32_t aGeneration);
-
-
-extern void
-xpc_TryUnmarkWrappedGrayObject(nsISupports* aWrappedJS);
-
-extern void
-xpc_UnmarkSkippableJSHolders();
-
-
-class XPCStringConvert
-{
-
-
-
-
-
-    struct ZoneStringCache
-    {
-# 241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-        void* mBuffer = nullptr;
-        uint32_t mLength = 0;
-        JSString* mString = nullptr;
-    };
-
-public:
-
-
-
-
-    static bool ReadableToJSVal(JSContext* cx, const nsAString& readable,
-                                nsStringBuffer** sharedBuffer,
-                                JS::MutableHandleValue vp);
-
-
-    static __attribute__((always_inline)) inline bool
-    StringBufferToJSVal(JSContext* cx, nsStringBuffer* buf, uint32_t length,
-                        JS::MutableHandleValue rval, bool* sharedBuffer)
-    {
-        JS::Zone* zone = js::GetContextZone(cx);
-        ZoneStringCache* cache = static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone));
-        if (cache && buf == cache->mBuffer && length == cache->mLength) {
-            do { } while (0);
-            JS::StringReadBarrier(cache->mString);
-            rval.setString(cache->mString);
-            *sharedBuffer = false;
-            return true;
-        }
-
-        bool isExternal;
-        JSString* str = JS_NewMaybeExternalString(cx,
-                                                  static_cast<char16_t*>(buf->Data()),
-                                                  length, &sDOMStringFinalizer, &isExternal);
-        if (!str) {
-            return false;
-        }
-        rval.setString(str);
-
-
-
-        if (!isExternal) {
-            *sharedBuffer = false;
-            return true;
-        }
-
-        if (!cache) {
-            cache = new ZoneStringCache();
-            JS_SetZoneUserData(zone, cache);
-        }
-        cache->mBuffer = buf;
-        cache->mLength = length;
-        cache->mString = str;
-        *sharedBuffer = true;
-        return true;
-    }
-
-    static void FreeZoneCache(JS::Zone* zone);
-    static void ClearZoneCache(JS::Zone* zone);
-
-    static __attribute__((always_inline)) inline bool IsLiteral(JSString* str)
-    {
-        return JS_IsExternalString(str) &&
-               JS_GetExternalStringFinalizer(str) == &sLiteralFinalizer;
-    }
-
-    static __attribute__((always_inline)) inline bool IsDOMString(JSString* str)
-    {
-        return JS_IsExternalString(str) &&
-               JS_GetExternalStringFinalizer(str) == &sDOMStringFinalizer;
-    }
-
-private:
-    static const JSStringFinalizer sLiteralFinalizer, sDOMStringFinalizer;
-
-    static void FinalizeLiteral(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
-
-    static void FinalizeDOMString(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
-
-    XPCStringConvert() = delete;
-};
-
-class nsIAddonInterposition;
-
-namespace xpc {
-
-
-bool Base64Encode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
-bool Base64Decode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
-
-
-
-
-
-
-bool NonVoidStringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval);
-inline bool StringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval)
-{
-
-    if (str.IsVoid()) {
-        rval.setNull();
-        return true;
-    }
-    return NonVoidStringToJsval(cx, str, rval);
-}
-
-inline bool
-NonVoidStringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
-{
-    nsString mutableCopy;
-    if (!mutableCopy.Assign(str, mozilla::fallible)) {
-        JS_ReportOutOfMemory(cx);
-        return false;
-    }
-    return NonVoidStringToJsval(cx, mutableCopy, rval);
-}
-
-inline bool
-StringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
-{
-    nsString mutableCopy;
-    if (!mutableCopy.Assign(str, mozilla::fallible)) {
-        JS_ReportOutOfMemory(cx);
-        return false;
-    }
-    return StringToJsval(cx, mutableCopy, rval);
-}
-
-
-
-
-inline
-bool NonVoidStringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
-                          JS::MutableHandleValue rval)
-{
-    if (!str.HasStringBuffer()) {
-
-        return NonVoidStringToJsval(cx, str.AsAString(), rval);
-    }
-
-    uint32_t length = str.StringBufferLength();
-    if (length == 0) {
-        rval.set(JS_GetEmptyStringValue(cx));
-        return true;
-    }
-
-    nsStringBuffer* buf = str.StringBuffer();
-    bool shared;
-    if (!XPCStringConvert::StringBufferToJSVal(cx, buf, length, rval,
-                                               &shared)) {
-        return false;
-    }
-    if (shared) {
-
-        str.RelinquishBufferOwnership();
-    }
-    return true;
-}
-
-__attribute__((always_inline)) inline
-bool StringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
-                   JS::MutableHandleValue rval)
-{
-    if (str.IsNull()) {
-        rval.setNull();
-        return true;
-    }
-    return NonVoidStringToJsval(cx, str, rval);
-}
-
-nsIPrincipal* GetCompartmentPrincipal(JSCompartment* compartment);
-
-void NukeAllWrappersForCompartment(JSContext* cx, JSCompartment* compartment,
-                                   js::NukeReferencesToWindow nukeReferencesToWindow = js::NukeWindowReferences);
-
-void SetLocationForGlobal(JSObject* global, const nsACString& location);
-void SetLocationForGlobal(JSObject* global, nsIURI* locationURI);
-
-void SetDocGroupValidation(JSObject* global);
-
-
-
-class ZoneStatsExtras {
-public:
-    ZoneStatsExtras() {}
-
-    nsCString pathPrefix;
-
-private:
-    ZoneStatsExtras(const ZoneStatsExtras& other) = delete;
-    ZoneStatsExtras& operator=(const ZoneStatsExtras& other) = delete;
-};
-
-
-
-class CompartmentStatsExtras {
-public:
-    CompartmentStatsExtras() {}
-
-    nsCString jsPathPrefix;
-    nsCString domPathPrefix;
-    nsCOMPtr<nsIURI> location;
-
-private:
-    CompartmentStatsExtras(const CompartmentStatsExtras& other) = delete;
-    CompartmentStatsExtras& operator=(const CompartmentStatsExtras& other) = delete;
-};
-
-
-
-
-
-void
-ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
-                                 const nsACString& rtPath,
-                                 nsIMemoryReporterCallback* handleReport,
-                                 nsISupports* data,
-                                 bool anonymize,
-                                 size_t* rtTotal = nullptr);
-
-
-
-
-bool
-Throw(JSContext* cx, nsresult rv);
-
-
-
-
-
-nsISupports*
-UnwrapReflectorToISupports(JSObject* reflector);
-# 480 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-JSObject*
-UnprivilegedJunkScope();
-
-JSObject*
-PrivilegedJunkScope();
-
-
-
-
-
-
-JSObject*
-CompilationScope();
-
-
-
-
-nsIGlobalObject*
-NativeGlobal(JSObject* aObj);
-
-
-
-
-
-nsGlobalWindow*
-WindowOrNull(JSObject* aObj);
-
-
-
-
-
-nsGlobalWindow*
-WindowGlobalOrNull(JSObject* aObj);
-
-
-
-
-
-
-nsGlobalWindow*
-AddonWindowOrNull(JSObject* aObj);
-
-
-
-
-
-nsGlobalWindow*
-CurrentWindowOrNull(JSContext* cx);
-
-void
-SimulateActivityCallback(bool aActive);
-
-
-
-bool
-ShouldDiscardSystemSource();
-
-bool
-SharedMemoryEnabled();
-
-bool
-SetAddonInterposition(const nsACString& addonId, nsIAddonInterposition* interposition);
-
-bool
-AllowCPOWsInAddon(const nsACString& addonId, bool allow);
-
-bool
-ExtraWarningsForSystemJS();
-
-class ErrorBase {
-  public:
-    nsString mErrorMsg;
-    nsString mFileName;
-    uint32_t mLineNumber;
-    uint32_t mColumn;
-
-    ErrorBase() : mLineNumber(0)
-                , mColumn(0)
-    {}
-
-    void Init(JSErrorBase* aReport);
-
-    void AppendErrorDetailsTo(nsCString& error);
-};
-
-class ErrorNote : public ErrorBase {
-  public:
-    void Init(JSErrorNotes::Note* aNote);
-
-
-
-
-    static void ErrorNoteToMessageString(JSErrorNotes::Note* aNote,
-                                         nsAString& aString);
-
-
-    void LogToStderr();
-};
-
-class ErrorReport : public ErrorBase {
-  public:
-    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ErrorReport>::value, "Reference-counted class " "ErrorReport" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
-
-    nsTArray<ErrorNote> mNotes;
-
-    nsCString mCategory;
-    nsString mSourceLine;
-    nsString mErrorMsgName;
-    uint64_t mWindowID;
-    uint32_t mFlags;
-    bool mIsMuted;
-
-    ErrorReport() : mWindowID(0)
-                  , mFlags(0)
-                  , mIsMuted(false)
-    {}
-
-    void Init(JSErrorReport* aReport, const char* aToStringResult,
-              bool aIsChrome, uint64_t aWindowID);
-    void Init(JSContext* aCx, mozilla::dom::Exception* aException,
-              bool aIsChrome, uint64_t aWindowID);
-
-
-
-    void LogToConsole();
-
-
-
-    void LogToConsoleWithStack(JS::HandleObject aStack);
-
-
-
-
-    static void ErrorReportToMessageString(JSErrorReport* aReport,
-                                           nsAString& aString);
-
-
-    void LogToStderr();
-
-  private:
-    ~ErrorReport() {}
-};
-
-void
-DispatchScriptErrorEvent(nsPIDOMWindowInner* win, JS::RootingContext* rootingCx,
-                         xpc::ErrorReport* xpcReport, JS::Handle<JS::Value> exception);
-# 638 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcpublic.h"
-JSObject*
-FindExceptionStackForConsoleReport(nsPIDOMWindowInner* win,
-                                   JS::HandleValue exceptionValue);
-
-
-
-
-extern void
-GetCurrentCompartmentName(JSContext*, nsCString& name);
-
-void AddGCCallback(xpcGCCallback cb);
-void RemoveGCCallback(xpcGCCallback cb);
-
-inline bool
-AreNonLocalConnectionsDisabled()
-{
-    static int disabledForTest = -1;
-    if (disabledForTest == -1) {
-        char *s = getenv("MOZ_DISABLE_NONLOCAL_CONNECTIONS");
-        if (s) {
-            disabledForTest = *s != '0';
-        } else {
-            disabledForTest = 0;
-        }
-    }
-    return disabledForTest;
-}
-
-inline bool
-IsInAutomation()
-{
-    const char* prefName =
-      "security.turn_off_all_security_so_that_viruses_can_take_over_this_computer";
-    return mozilla::Preferences::GetBool(prefName) &&
-        AreNonLocalConnectionsDisabled();
-}
-
-}
-
-namespace mozilla {
-namespace dom {
-
-
-
-
-
-bool IsChromeOrXBL(JSContext* cx, JSObject* );
-
-
-
-
-bool ThreadSafeIsChromeOrXBL(JSContext* cx, JSObject* obj);
-
-}
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h" 2
-
-class nsICycleCollectorListener;
-class nsScriptNameSpaceManager;
-
-namespace JS {
-class AutoValueVector;
-}
-
-namespace mozilla {
-template <class> class Maybe;
-struct CycleCollectorResults;
-}
-
-
-
-
-
-
-
-class nsJSContext : public nsIScriptContext
-{
-public:
-  nsJSContext(bool aGCOnDestruction, nsIScriptGlobalObject* aGlobalObject);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsJSContext"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsJSContext>(p)->DeleteCycleCollectable(); } static nsJSContext* Downcast(nsISupports* s) { return static_cast<nsJSContext*>(static_cast<nsIScriptContext*>(s)); } static nsISupports* Upcast(nsJSContext *p) { return static_cast<nsISupports*>(static_cast<nsIScriptContext*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsJSContext::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  virtual nsIScriptGlobalObject *GetGlobalObject() override;
-  inline nsIScriptGlobalObject *GetGlobalObjectRef() { return mGlobalObjectRef; }
-
-  virtual nsresult InitContext() override;
-  virtual bool IsContextInitialized() override;
-
-  virtual nsresult SetProperty(JS::Handle<JSObject*> aTarget, const char* aPropName, nsISupports* aVal) override;
-
-  virtual bool GetProcessingScriptTag() override;
-  virtual void SetProcessingScriptTag(bool aResult) override;
-
-  virtual nsresult InitClasses(JS::Handle<JSObject*> aGlobalObj) override;
-
-  virtual void WillInitializeContext() override;
-  virtual void DidInitializeContext() override;
-
-  virtual void SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) override;
-  virtual JSObject* GetWindowProxy() override;
-
-  static void LoadStart();
-  static void LoadEnd();
-
-  enum IsShrinking {
-    ShrinkingGC,
-    NonShrinkingGC
-  };
-
-  enum IsIncremental {
-    IncrementalGC,
-    NonIncrementalGC
-  };
-
-
-  void EnsureStatics();
-
-  static void GarbageCollectNow(JS::gcreason::Reason reason,
-                                IsIncremental aIncremental = NonIncrementalGC,
-                                IsShrinking aShrinking = NonShrinkingGC,
-                                int64_t aSliceMillis = 0);
-
-
-
-  static void CycleCollectNow(nsICycleCollectorListener *aListener = nullptr,
-                              int32_t aExtraForgetSkippableCalls = 0);
-
-
-  static void RunCycleCollectorSlice();
-
-
-  static void RunCycleCollectorWorkSlice(int64_t aWorkBudget);
-
-  static void BeginCycleCollectionCallback();
-  static void EndCycleCollectionCallback(mozilla::CycleCollectorResults &aResults);
-
-
-  static uint32_t GetMaxCCSliceTimeSinceClear();
-  static void ClearMaxCCSliceTime();
-
-  static void RunNextCollectorTimer();
-
-
-  static void PokeGC(JS::gcreason::Reason aReason, JSObject* aObj, int aDelay = 0);
-  static void KillGCTimer();
-
-  static void PokeShrinkingGC();
-  static void KillShrinkingGCTimer();
-
-  static void MaybePokeCC();
-  static void KillCCTimer();
-  static void KillICCTimer();
-  static void KillFullGCTimer();
-  static void KillInterSliceGCTimer();
-
-
-  static void LikelyShortLivingObjectCreated();
-
-  static uint32_t CleanupsSinceLastGC();
-
-  nsIScriptGlobalObject* GetCachedGlobalObject()
-  {
-
-
-    JSObject* global = GetWindowProxy();
-    return global ? mGlobalObjectRef.get() : nullptr;
-  }
-
-  static void NotifyDidPaint();
-protected:
-  virtual ~nsJSContext();
-
-
-  nsresult ConvertSupportsTojsvals(nsISupports *aArgs,
-                                   JS::Handle<JSObject*> aScope,
-                                   JS::AutoValueVector &aArgsOut);
-
-  nsresult AddSupportsPrimitiveTojsvals(nsISupports *aArg, JS::Value *aArgv);
-
-private:
-  void Destroy();
-
-  JS::Heap<JSObject*> mWindowProxy;
-
-  bool mIsInitialized;
-  bool mGCOnDestruction;
-  bool mProcessingScriptTag;
-
-  PRTime mModalStateTime;
-  uint32_t mModalStateDepth;
-
-
-
-  nsCOMPtr<nsIScriptGlobalObject> mGlobalObjectRef;
-
-  static bool DOMOperationCallback(JSContext *cx);
-};
-
-namespace mozilla {
-namespace dom {
-
-void StartupJSEnvironment();
-void ShutdownJSEnvironment();
-
-
-nsScriptNameSpaceManager* GetNameSpaceManager();
-
-
-nsScriptNameSpaceManager* PeekNameSpaceManager();
-
-
-class AsyncErrorReporter final : public mozilla::Runnable
-{
-public:
-
-  explicit AsyncErrorReporter(xpc::ErrorReport* aReport)
-    : mReport(aReport)
-  {}
-
-  virtual nsresult Run() override
-  {
-    mReport->LogToConsole();
-    return NS_OK;
-  }
-
-protected:
-  RefPtr<xpc::ErrorReport> mReport;
-};
-
-}
-}
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSEnvironment.h"
-class nsIJSArgArray : public nsIArray
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-  virtual nsresult GetArgs(uint32_t *argc, void **argv) = 0;
-};
-
-template<typename T> struct nsIJSArgArray::COMTypeInfo<nsIJSArgArray, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIJSArgArray::COMTypeInfo<nsIJSArgArray, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xb6acdac8, 0xf5c6, 0x432c, { 0xa8, 0x6e, 0x33, 0xee, 0xb1, 0xb0, 0xcd, 0xdc } };
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h" 2
-
-
-
-
-namespace mozilla {
-namespace dom {
-
-
-
-
-
-class CallbackObject : public nsISupports
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = true) : nsXPCOMCycleCollectionParticipant(true) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "CallbackObject"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<CallbackObject>(p)->DeleteCycleCollectable(); } static CallbackObject* Downcast(nsISupports* s) { return static_cast<CallbackObject*>(static_cast<CallbackObject*>(s)); } static nsISupports* Upcast(CallbackObject *p) { return static_cast<nsISupports*>(static_cast<CallbackObject*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; virtual bool CanSkipReal(void *p, bool aRemovingAllowed) override; virtual bool CanSkipInCCReal(void *p) override; virtual bool CanSkipThisReal(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &CallbackObject::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-# 58 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-  explicit CallbackObject(JSContext* aCx, JS::Handle<JSObject*> aCallback,
-                          nsIGlobalObject* aIncumbentGlobal)
-  {
-    if (aCx && JS::ContextOptionsRef(aCx).asyncStack()) {
-      JS::RootedObject stack(aCx);
-      if (!JS::CaptureCurrentStack(aCx, &stack)) {
-        JS_ClearPendingException(aCx);
-      }
-      Init(aCallback, stack, aIncumbentGlobal);
-    } else {
-      Init(aCallback, nullptr, aIncumbentGlobal);
-    }
-  }
-
-
-
-
-  explicit CallbackObject(JS::Handle<JSObject*> aCallback,
-                          JS::Handle<JSObject*> aAsyncStack,
-                          nsIGlobalObject* aIncumbentGlobal)
-  {
-    Init(aCallback, aAsyncStack, aIncumbentGlobal);
-  }
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-  JS::Handle<JSObject*> CallbackOrNull() const
-  {
-    mCallback.exposeToActiveJS();
-    return CallbackPreserveColor();
-  }
-
-  JSObject* GetCreationStack() const
-  {
-    return mCreationStack;
-  }
-
-  void MarkForCC()
-  {
-    mCallback.exposeToActiveJS();
-    mCreationStack.exposeToActiveJS();
-  }
-# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-  JS::Handle<JSObject*> CallbackPreserveColor() const
-  {
-
-
-    return JS::Handle<JSObject*>::fromMarkedLocation(mCallback.address());
-  }
-
-
-
-
-
-
-  JS::Handle<JSObject*> CallbackKnownNotGray() const
-  {
-    do { } while (0);
-    return CallbackPreserveColor();
-  }
-
-  nsIGlobalObject* IncumbentGlobalOrNull() const
-  {
-    return mIncumbentGlobal;
-  }
-
-  enum ExceptionHandling {
-
-    eReportExceptions,
-
-
-
-    eRethrowContentExceptions,
-
-
-
-
-    eRethrowExceptions
-  };
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this);
-  }
-
-protected:
-  virtual ~CallbackObject()
-  {
-    DropJSObjects();
-  }
-
-  explicit CallbackObject(CallbackObject* aCallbackObject)
-  {
-    Init(aCallbackObject->mCallback, aCallbackObject->mCreationStack,
-         aCallbackObject->mIncumbentGlobal);
-  }
-
-  bool operator==(const CallbackObject& aOther) const
-  {
-    JSObject* wrappedThis = CallbackPreserveColor();
-    JSObject* wrappedOther = aOther.CallbackPreserveColor();
-    if (!wrappedThis || !wrappedOther) {
-      return this == &aOther;
-    }
-
-    JSObject* thisObj = js::UncheckedUnwrap(wrappedThis);
-    JSObject* otherObj = js::UncheckedUnwrap(wrappedOther);
-    return thisObj == otherObj;
-  }
-
-  class JSObjectsDropper final
-  {
-  public:
-    explicit JSObjectsDropper(CallbackObject* aHolder)
-      : mHolder(aHolder)
-    {}
-
-    ~JSObjectsDropper()
-    {
-      mHolder->DropJSObjects();
-    }
-
-  private:
-    RefPtr<CallbackObject> mHolder;
-  };
-
-private:
-  inline void InitNoHold(JSObject* aCallback, JSObject* aCreationStack,
-                         nsIGlobalObject* aIncumbentGlobal)
-  {
-    do { } while (0);
-
-
-    mCallback = aCallback;
-    mCreationStack = aCreationStack;
-    if (aIncumbentGlobal) {
-      mIncumbentGlobal = aIncumbentGlobal;
-      mIncumbentJSGlobal = aIncumbentGlobal->GetGlobalJSObject();
-    }
-  }
-
-  inline void Init(JSObject* aCallback, JSObject* aCreationStack,
-                   nsIGlobalObject* aIncumbentGlobal)
-  {
-    InitNoHold(aCallback, aCreationStack, aIncumbentGlobal);
-    mozilla::HoldJSObjects(this);
-  }
-
-  inline void ClearJSReferences()
-  {
-    mCallback = nullptr;
-    mCreationStack = nullptr;
-    mIncumbentJSGlobal = nullptr;
-  }
-
-  CallbackObject(const CallbackObject&) = delete;
-  CallbackObject& operator =(const CallbackObject&) = delete;
-
-protected:
-  void DropJSObjects()
-  {
-    do { } while (0);
-    if (mCallback) {
-      ClearJSReferences();
-      mozilla::DropJSObjects(this);
-    }
-  }
-
-
-  void Trace(JSTracer* aTracer);
-
-
-
-
-
-  void FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx);
-
-
-
-
-
-
-
-  struct FastCallbackConstructor {
-  };
-
-
-
-
-
-
-  CallbackObject(JS::Handle<JSObject*> aCallback,
-                 const FastCallbackConstructor&)
-  {
-    InitNoHold(aCallback, nullptr, nullptr);
-  }
-
-
-
-
-
-  JS::Heap<JSObject*> mCallback;
-  JS::Heap<JSObject*> mCreationStack;
-# 283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-  nsCOMPtr<nsIGlobalObject> mIncumbentGlobal;
-  JS::TenuredHeap<JSObject*> mIncumbentJSGlobal;
-
-  class CallSetup
-  {
-
-
-
-
-
-
-  public:
-
-
-
-
-
-
-
-    CallSetup(CallbackObject* aCallback, ErrorResult& aRv,
-              const char* aExecutionReason,
-              ExceptionHandling aExceptionHandling,
-              JSCompartment* aCompartment = nullptr,
-              bool aIsJSImplementedWebIDL = false);
-    ~CallSetup();
-
-    JSContext* GetContext() const
-    {
-      return mCx;
-    }
-
-  private:
-
-    CallSetup(const CallSetup&) = delete;
-
-    bool ShouldRethrowException(JS::Handle<JS::Value> aException);
-
-
-    JSContext* mCx;
-
-
-
-    JSCompartment* mCompartment;
-
-
-    Maybe<AutoEntryScript> mAutoEntryScript;
-    Maybe<AutoIncumbentScript> mAutoIncumbentScript;
-
-    Maybe<JS::Rooted<JSObject*> > mRootedCallable;
-
-
-    Maybe<JS::Rooted<JSObject*>> mAsyncStack;
-    Maybe<JS::AutoSetAsyncStackForNewCalls> mAsyncStackSetter;
-
-
-
-
-
-    Maybe<JSAutoCompartment> mAc;
-
-
-
-    ErrorResult& mErrorResult;
-    const ExceptionHandling mExceptionHandling;
-    const bool mIsMainThread;
-  };
-};
-
-template<class WebIDLCallbackT, class XPCOMCallbackT>
-class CallbackObjectHolder;
-
-template<class T, class U>
-void ImplCycleCollectionUnlink(CallbackObjectHolder<T, U>& aField);
-
-class CallbackObjectHolderBase
-{
-protected:
-
-  already_AddRefed<nsISupports> ToXPCOMCallback(CallbackObject* aCallback,
-                                                const nsIID& aIID) const;
-};
-
-template<class WebIDLCallbackT, class XPCOMCallbackT>
-class CallbackObjectHolder : CallbackObjectHolderBase
-{
-# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackObject.h"
-public:
-  explicit CallbackObjectHolder(WebIDLCallbackT* aCallback)
-    : mPtrBits(reinterpret_cast<uintptr_t>(aCallback))
-  {
-    ns_if_addref(aCallback);
-  }
-
-  explicit CallbackObjectHolder(XPCOMCallbackT* aCallback)
-    : mPtrBits(reinterpret_cast<uintptr_t>(aCallback) | XPCOMCallbackFlag)
-  {
-    ns_if_addref(aCallback);
-  }
-
-  CallbackObjectHolder(CallbackObjectHolder&& aOther)
-    : mPtrBits(aOther.mPtrBits)
-  {
-    aOther.mPtrBits = 0;
-    static_assert(sizeof(CallbackObjectHolder) == sizeof(void*),
-                  "This object is expected to be as small as a pointer, and it "
-                  "is currently passed by value in various places. If it is "
-                  "bloating, we may want to pass it by reference then.");
-  }
-
-  CallbackObjectHolder(const CallbackObjectHolder& aOther) = delete;
-
-  CallbackObjectHolder()
-    : mPtrBits(0)
-  {}
-
-  ~CallbackObjectHolder()
-  {
-    UnlinkSelf();
-  }
-
-  void operator=(WebIDLCallbackT* aCallback)
-  {
-    UnlinkSelf();
-    mPtrBits = reinterpret_cast<uintptr_t>(aCallback);
-    ns_if_addref(aCallback);
-  }
-
-  void operator=(XPCOMCallbackT* aCallback)
-  {
-    UnlinkSelf();
-    mPtrBits = reinterpret_cast<uintptr_t>(aCallback) | XPCOMCallbackFlag;
-    ns_if_addref(aCallback);
-  }
-
-  void operator=(CallbackObjectHolder&& aOther)
-  {
-    UnlinkSelf();
-    mPtrBits = aOther.mPtrBits;
-    aOther.mPtrBits = 0;
-  }
-
-  void operator=(const CallbackObjectHolder& aOther) = delete;
-
-  nsISupports* GetISupports() const
-  {
-    return reinterpret_cast<nsISupports*>(mPtrBits & ~XPCOMCallbackFlag);
-  }
-
-
-  explicit operator bool() const
-  {
-    return GetISupports();
-  }
-
-  CallbackObjectHolder Clone() const
-  {
-    CallbackObjectHolder result;
-    result.mPtrBits = mPtrBits;
-    ns_if_addref(GetISupports());
-    return result;
-  }
-
-
-
-  bool HasWebIDLCallback() const
-  {
-    return !(mPtrBits & XPCOMCallbackFlag);
-  }
-
-  WebIDLCallbackT* GetWebIDLCallback() const
-  {
-    do { } while (0);
-    return reinterpret_cast<WebIDLCallbackT*>(mPtrBits);
-  }
-
-  XPCOMCallbackT* GetXPCOMCallback() const
-  {
-    do { } while (0);
-    return reinterpret_cast<XPCOMCallbackT*>(mPtrBits & ~XPCOMCallbackFlag);
-  }
-
-  bool operator==(WebIDLCallbackT* aOtherCallback) const
-  {
-    if (!aOtherCallback) {
-
-      return !GetISupports();
-    }
-
-    if (!HasWebIDLCallback() || !GetWebIDLCallback()) {
-
-
-      return false;
-    }
-
-    return *GetWebIDLCallback() == *aOtherCallback;
-  }
-
-  bool operator==(XPCOMCallbackT* aOtherCallback) const
-  {
-    return (!aOtherCallback && !GetISupports()) ||
-      (!HasWebIDLCallback() && GetXPCOMCallback() == aOtherCallback);
-  }
-
-  bool operator==(const CallbackObjectHolder& aOtherCallback) const
-  {
-    if (aOtherCallback.HasWebIDLCallback()) {
-      return *this == aOtherCallback.GetWebIDLCallback();
-    }
-
-    return *this == aOtherCallback.GetXPCOMCallback();
-  }
-
-
-  already_AddRefed<XPCOMCallbackT> ToXPCOMCallback() const
-  {
-    if (!HasWebIDLCallback()) {
-      RefPtr<XPCOMCallbackT> callback = GetXPCOMCallback();
-      return callback.forget();
-    }
-
-    nsCOMPtr<nsISupports> supp =
-      CallbackObjectHolderBase::ToXPCOMCallback(GetWebIDLCallback(),
-                                                (XPCOMCallbackT::template COMTypeInfo<XPCOMCallbackT, void>::kIID));
-    if (supp) {
-
-      return supp.forget().downcast<XPCOMCallbackT>();
-    }
-    return nullptr;
-  }
-
-
-  already_AddRefed<WebIDLCallbackT> ToWebIDLCallback() const
-  {
-    if (HasWebIDLCallback()) {
-      RefPtr<WebIDLCallbackT> callback = GetWebIDLCallback();
-      return callback.forget();
-    }
-    return nullptr;
-  }
-
-private:
-  static const uintptr_t XPCOMCallbackFlag = 1u;
-
-  friend void
-  ImplCycleCollectionUnlink<WebIDLCallbackT,
-                            XPCOMCallbackT>(CallbackObjectHolder& aField);
-
-  void UnlinkSelf()
-  {
-
-    nsISupports* ptr = GetISupports();
-    do { if (ptr) { (ptr)->Release(); (ptr) = 0; } } while (0);
-    mPtrBits = 0;
-  }
-
-  uintptr_t mPtrBits;
-};
-
-template<typename T> struct CallbackObject::COMTypeInfo<CallbackObject, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID CallbackObject::COMTypeInfo<CallbackObject, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xbe74c190, 0x6d76, 0x4991, { 0x84, 0xb9, 0x65, 0x06, 0x99, 0xe6, 0x93, 0x2b } };
-
-template<class T, class U>
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            CallbackObjectHolder<T, U>& aField,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  if (aField) {
-    CycleCollectionNoteChild(aCallback, aField.GetISupports(), aName, aFlags);
-  }
-}
-
-template<class T, class U>
-void
-ImplCycleCollectionUnlink(CallbackObjectHolder<T, U>& aField)
-{
-  aField.UnlinkSelf();
-}
-
-
-
-
-
-template<typename T>
-class RootedCallback : public JS::Rooted<T>
-{
-public:
-  explicit RootedCallback(JSContext* cx)
-    : JS::Rooted<T>(cx)
-    , mCx(cx)
-  {}
-
-
-
-  template<typename S>
-  void operator=(S* arg)
-  {
-    this->get().operator=(arg);
-  }
-
-
-
-  void operator=(decltype(nullptr) arg)
-  {
-    this->get().operator=(arg);
-  }
-
-
-  JS::Handle<JSObject*> CallbackOrNull() const
-  {
-    return this->get()->CallbackOrNull();
-  }
-
-  ~RootedCallback()
-  {
-
-
-
-
-    if (IsInitialized(this->get())) {
-      this->get()->FinishSlowJSInitIfMoreThanOneOwner(mCx);
-    }
-  }
-
-private:
-  template<typename U>
-  static bool IsInitialized(U& aArg);
-
-  template<typename U>
-  static bool IsInitialized(RefPtr<U>& aRefPtr)
-  {
-    return aRefPtr;
-  }
-
-  template<typename U>
-  static bool IsInitialized(OwningNonNull<U>& aOwningNonNull)
-  {
-    return aOwningNonNull.isInitialized();
-  }
-
-  JSContext* mCx;
-};
-
-}
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/CallbackFunction.h" 2
-
-namespace mozilla {
-namespace dom {
-
-class CallbackFunction : public CallbackObject
-{
-public:
-
-  explicit CallbackFunction(JSContext* aCx, JS::Handle<JSObject*> aCallable,
-                            nsIGlobalObject* aIncumbentGlobal)
-    : CallbackObject(aCx, aCallable, aIncumbentGlobal)
-  {
-  }
-
-
-  explicit CallbackFunction(JS::Handle<JSObject*> aCallable,
-                            JS::Handle<JSObject*> aAsyncStack,
-                            nsIGlobalObject* aIncumbentGlobal)
-    : CallbackObject(aCallable, aAsyncStack, aIncumbentGlobal)
-  {
-  }
-
-  JS::Handle<JSObject*> CallableOrNull() const
-  {
-    return CallbackOrNull();
-  }
-
-  JS::Handle<JSObject*> CallablePreserveColor() const
-  {
-    return CallbackPreserveColor();
-  }
-
-  bool HasGrayCallable() const
-  {
-
-    return mCallback && JS::ObjectIsMarkedGray(mCallback);
-  }
-
-protected:
-  explicit CallbackFunction(CallbackFunction* aCallbackFunction)
-    : CallbackObject(aCallbackFunction)
-  {
-  }
-
-
-  CallbackFunction(JS::Handle<JSObject*> aCallable,
-                   const FastCallbackConstructor&)
-    : CallbackObject(aCallable, FastCallbackConstructor())
-  {
-  }
-};
-
-}
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/math.h" 1 3
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h" 2
-
-
-
-
-
-
-struct JSContext;
-
-namespace js {
-
-
-extern bool
-ToBooleanSlow(JS::HandleValue v);
-
-
-extern bool
-ToNumberSlow(JSContext* cx, JS::HandleValue v, double* dp);
-
-
-extern bool
-ToInt8Slow(JSContext *cx, JS::HandleValue v, int8_t *out);
-
-
-extern bool
-ToUint8Slow(JSContext *cx, JS::HandleValue v, uint8_t *out);
-
-
-extern bool
-ToInt16Slow(JSContext *cx, JS::HandleValue v, int16_t *out);
-
-
-extern bool
-ToInt32Slow(JSContext* cx, JS::HandleValue v, int32_t* out);
-
-
-extern bool
-ToUint32Slow(JSContext* cx, JS::HandleValue v, uint32_t* out);
-
-
-extern bool
-ToUint16Slow(JSContext* cx, JS::HandleValue v, uint16_t* out);
-
-
-extern bool
-ToInt64Slow(JSContext* cx, JS::HandleValue v, int64_t* out);
-
-
-extern bool
-ToUint64Slow(JSContext* cx, JS::HandleValue v, uint64_t* out);
-
-
-extern JSString*
-ToStringSlow(JSContext* cx, JS::HandleValue v);
-
-
-extern JSObject*
-ToObjectSlow(JSContext* cx, JS::HandleValue v, bool reportScanStack);
-
-}
-
-namespace JS {
-
-namespace detail {
-
-
-
-
-
-
-
-extern void
-AssertArgumentsAreSane(JSContext* cx, HandleValue v);
-
-
-
-
-
-}
-# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
-extern bool
-OrdinaryToPrimitive(JSContext* cx, HandleObject obj, JSType type, MutableHandleValue vp);
-
-
-__attribute__((always_inline)) inline bool
-ToBoolean(HandleValue v)
-{
-    if (v.isBoolean())
-        return v.toBoolean();
-    if (v.isInt32())
-        return v.toInt32() != 0;
-    if (v.isNullOrUndefined())
-        return false;
-    if (v.isDouble()) {
-        double d = v.toDouble();
-        return !mozilla::IsNaN(d) && d != 0;
-    }
-    if (v.isSymbol())
-        return true;
-
-
-    return js::ToBooleanSlow(v);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToNumber(JSContext* cx, HandleValue v, double* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isNumber()) {
-        *out = v.toNumber();
-        return true;
-    }
-    return js::ToNumberSlow(cx, v, out);
-}
-
-
-inline double
-ToInteger(double d)
-{
-    if (d == 0)
-        return d;
-
-    if (!mozilla::IsFinite(d)) {
-        if (mozilla::IsNaN(d))
-            return 0;
-        return d;
-    }
-
-    return d < 0 ? ceil(d) : floor(d);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToInt32(JSContext* cx, JS::HandleValue v, int32_t* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = v.toInt32();
-        return true;
-    }
-    return js::ToInt32Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToUint32(JSContext* cx, HandleValue v, uint32_t* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = uint32_t(v.toInt32());
-        return true;
-    }
-    return js::ToUint32Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToInt16(JSContext *cx, JS::HandleValue v, int16_t *out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = int16_t(v.toInt32());
-        return true;
-    }
-    return js::ToInt16Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToUint16(JSContext* cx, HandleValue v, uint16_t* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = uint16_t(v.toInt32());
-        return true;
-    }
-    return js::ToUint16Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToInt8(JSContext *cx, JS::HandleValue v, int8_t *out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = int8_t(v.toInt32());
-        return true;
-    }
-    return js::ToInt8Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline bool
-ToUint8(JSContext *cx, JS::HandleValue v, uint8_t *out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = uint8_t(v.toInt32());
-        return true;
-    }
-    return js::ToUint8Slow(cx, v, out);
-}
-
-
-
-
-
-__attribute__((always_inline)) inline bool
-ToInt64(JSContext* cx, HandleValue v, int64_t* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = int64_t(v.toInt32());
-        return true;
-    }
-    return js::ToInt64Slow(cx, v, out);
-}
-
-
-
-
-
-__attribute__((always_inline)) inline bool
-ToUint64(JSContext* cx, HandleValue v, uint64_t* out)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isInt32()) {
-        *out = uint64_t(v.toInt32());
-        return true;
-    }
-    return js::ToUint64Slow(cx, v, out);
-}
-
-
-__attribute__((always_inline)) inline JSString*
-ToString(JSContext* cx, HandleValue v)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isString())
-        return v.toString();
-    return js::ToStringSlow(cx, v);
-}
-
-
-inline JSObject*
-ToObject(JSContext* cx, HandleValue v)
-{
-    detail::AssertArgumentsAreSane(cx, v);
-
-    if (v.isObject())
-        return &v.toObject();
-    return js::ToObjectSlow(cx, v, false);
-}
-
-namespace detail {
-# 304 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
-template<typename ResultType>
-inline ResultType
-ToUintWidth(double d)
-{
-    static_assert(mozilla::IsUnsigned<ResultType>::value,
-                  "ResultType must be an unsigned type");
-
-    uint64_t bits = mozilla::BitwiseCast<uint64_t>(d);
-    unsigned DoubleExponentShift = mozilla::FloatingPoint<double>::kExponentShift;
-
-
-
-    int_fast16_t exp =
-        int_fast16_t((bits & mozilla::FloatingPoint<double>::kExponentBits) >> DoubleExponentShift) -
-        int_fast16_t(mozilla::FloatingPoint<double>::kExponentBias);
-
-
-
-    if (exp < 0)
-        return 0;
-
-    uint_fast16_t exponent = mozilla::AssertedCast<uint_fast16_t>(exp);
-
-
-
-
-
-
-
-    const size_t ResultWidth = 8 * sizeof(ResultType);
-    if (exponent >= DoubleExponentShift + ResultWidth)
-        return 0;
-
-
-
-
-    static_assert(sizeof(ResultType) <= sizeof(uint64_t),
-                  "Left-shifting below would lose upper bits");
-    ResultType result = (exponent > DoubleExponentShift)
-                        ? ResultType(bits << (exponent - DoubleExponentShift))
-                        : ResultType(bits >> (DoubleExponentShift - exponent));
-# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
-    if (exponent < ResultWidth) {
-        ResultType implicitOne = ResultType(1) << exponent;
-        result &= implicitOne - 1;
-        result += implicitOne;
-    }
-
-
-    return (bits & mozilla::FloatingPoint<double>::kSignBit) ? ~result + 1 : result;
-}
-
-template<typename ResultType>
-inline ResultType
-ToIntWidth(double d)
-{
-    static_assert(mozilla::IsSigned<ResultType>::value,
-                  "ResultType must be a signed type");
-
-    const ResultType MaxValue = (1ULL << (8 * sizeof(ResultType) - 1)) - 1;
-    const ResultType MinValue = -MaxValue - 1;
-
-    typedef typename mozilla::MakeUnsigned<ResultType>::Type UnsignedResult;
-    UnsignedResult u = ToUintWidth<UnsignedResult>(d);
-    if (u <= UnsignedResult(MaxValue))
-        return static_cast<ResultType>(u);
-    return (MinValue + static_cast<ResultType>(u - MaxValue)) - 1;
-}
-
-}
-
-
-inline int32_t
-ToInt32(double d)
-{
-# 527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/Conversions.h"
-    return detail::ToIntWidth<int32_t>(d);
-
-}
-
-
-inline uint32_t
-ToUint32(double d)
-{
-    return detail::ToUintWidth<uint32_t>(d);
-}
-
-
-inline int8_t
-ToInt8(double d)
-{
-    return detail::ToIntWidth<int8_t>(d);
-}
-
-
-inline int8_t
-ToUint8(double d)
-{
-    return detail::ToUintWidth<uint8_t>(d);
-}
-
-
-inline int16_t
-ToInt16(double d)
-{
-    return detail::ToIntWidth<int16_t>(d);
-}
-
-inline uint16_t
-ToUint16(double d)
-{
-    return detail::ToUintWidth<uint16_t>(d);
-}
-
-
-inline int64_t
-ToInt64(double d)
-{
-    return detail::ToIntWidth<int64_t>(d);
-}
-
-
-inline uint64_t
-ToUint64(double d)
-{
-    return detail::ToUintWidth<uint64_t>(d);
-}
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 3
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<bool _TrivialValueTypes>
-    struct __uninitialized_copy
-    {
-      template<typename _InputIterator, typename _ForwardIterator>
-        static _ForwardIterator
-        __uninit_copy(_InputIterator __first, _InputIterator __last,
-        _ForwardIterator __result)
-        {
-   _ForwardIterator __cur = __result;
-   try
-     {
-       for (; __first != __last; ++__first, (void)++__cur)
-  std::_Construct(std::__addressof(*__cur), *__first);
-       return __cur;
-     }
-   catch(...)
-     {
-       std::_Destroy(__result, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_copy<true>
-    {
-      template<typename _InputIterator, typename _ForwardIterator>
-        static _ForwardIterator
-        __uninit_copy(_InputIterator __first, _InputIterator __last,
-        _ForwardIterator __result)
-        { return std::copy(__first, __last, __result); }
-    };
-# 105 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-  template<typename _InputIterator, typename _ForwardIterator>
-    inline _ForwardIterator
-    uninitialized_copy(_InputIterator __first, _InputIterator __last,
-         _ForwardIterator __result)
-    {
-      typedef typename iterator_traits<_InputIterator>::value_type
- _ValueType1;
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType2;
-
-
-
-
-      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
-      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
-      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
-
-
-      return std::__uninitialized_copy<__is_trivial(_ValueType1)
-           && __is_trivial(_ValueType2)
-           && __assignable>::
- __uninit_copy(__first, __last, __result);
-    }
-
-
-  template<bool _TrivialValueType>
-    struct __uninitialized_fill
-    {
-      template<typename _ForwardIterator, typename _Tp>
-        static void
-        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
-        const _Tp& __x)
-        {
-   _ForwardIterator __cur = __first;
-   try
-     {
-       for (; __cur != __last; ++__cur)
-  std::_Construct(std::__addressof(*__cur), __x);
-     }
-   catch(...)
-     {
-       std::_Destroy(__first, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_fill<true>
-    {
-      template<typename _ForwardIterator, typename _Tp>
-        static void
-        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
-        const _Tp& __x)
-        { std::fill(__first, __last, __x); }
-    };
-# 171 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline void
-    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
-         const _Tp& __x)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType;
-
-
-
-
-      const bool __assignable = is_copy_assignable<_ValueType>::value;
-
-
-      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
- __uninit_fill(__first, __last, __x);
-    }
-
-
-  template<bool _TrivialValueType>
-    struct __uninitialized_fill_n
-    {
-      template<typename _ForwardIterator, typename _Size, typename _Tp>
-        static _ForwardIterator
-        __uninit_fill_n(_ForwardIterator __first, _Size __n,
-   const _Tp& __x)
-        {
-   _ForwardIterator __cur = __first;
-   try
-     {
-       for (; __n > 0; --__n, ++__cur)
-  std::_Construct(std::__addressof(*__cur), __x);
-       return __cur;
-     }
-   catch(...)
-     {
-       std::_Destroy(__first, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_fill_n<true>
-    {
-      template<typename _ForwardIterator, typename _Size, typename _Tp>
-        static _ForwardIterator
-        __uninit_fill_n(_ForwardIterator __first, _Size __n,
-   const _Tp& __x)
-        { return std::fill_n(__first, __n, __x); }
-    };
-# 234 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-  template<typename _ForwardIterator, typename _Size, typename _Tp>
-    inline _ForwardIterator
-    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType;
-
-
-
-
-      const bool __assignable = is_copy_assignable<_ValueType>::value;
-
-      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
- __uninit_fill_n(__first, __n, __x);
-    }
-
-
-
-
-
-
-
-  template<typename _InputIterator, typename _ForwardIterator,
-    typename _Allocator>
-    _ForwardIterator
-    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
-      _ForwardIterator __result, _Allocator& __alloc)
-    {
-      _ForwardIterator __cur = __result;
-      try
- {
-   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-   for (; __first != __last; ++__first, (void)++__cur)
-     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
-   return __cur;
- }
-      catch(...)
- {
-   std::_Destroy(__result, __cur, __alloc);
-   throw;
- }
-    }
-
-  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
-    inline _ForwardIterator
-    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
-      _ForwardIterator __result, allocator<_Tp>&)
-    { return std::uninitialized_copy(__first, __last, __result); }
-
-  template<typename _InputIterator, typename _ForwardIterator,
-    typename _Allocator>
-    inline _ForwardIterator
-    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
-      _ForwardIterator __result, _Allocator& __alloc)
-    {
-      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
-      std::make_move_iterator(__last),
-      __result, __alloc);
-    }
-
-  template<typename _InputIterator, typename _ForwardIterator,
-    typename _Allocator>
-    inline _ForwardIterator
-    __uninitialized_move_if_noexcept_a(_InputIterator __first,
-           _InputIterator __last,
-           _ForwardIterator __result,
-           _Allocator& __alloc)
-    {
-      return std::__uninitialized_copy_a
- (std::__make_move_if_noexcept_iterator(__first),
-  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
-    void
-    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
-      const _Tp& __x, _Allocator& __alloc)
-    {
-      _ForwardIterator __cur = __first;
-      try
- {
-   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-   for (; __cur != __last; ++__cur)
-     __traits::construct(__alloc, std::__addressof(*__cur), __x);
- }
-      catch(...)
- {
-   std::_Destroy(__first, __cur, __alloc);
-   throw;
- }
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
-    inline void
-    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
-      const _Tp& __x, allocator<_Tp2>&)
-    { std::uninitialized_fill(__first, __last, __x); }
-
-  template<typename _ForwardIterator, typename _Size, typename _Tp,
-    typename _Allocator>
-    _ForwardIterator
-    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
-        const _Tp& __x, _Allocator& __alloc)
-    {
-      _ForwardIterator __cur = __first;
-      try
- {
-   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-   for (; __n > 0; --__n, ++__cur)
-     __traits::construct(__alloc, std::__addressof(*__cur), __x);
-   return __cur;
- }
-      catch(...)
- {
-   std::_Destroy(__first, __cur, __alloc);
-   throw;
- }
-    }
-
-  template<typename _ForwardIterator, typename _Size, typename _Tp,
-    typename _Tp2>
-    inline _ForwardIterator
-    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
-        const _Tp& __x, allocator<_Tp2>&)
-    { return std::uninitialized_fill_n(__first, __n, __x); }
-# 370 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _ForwardIterator, typename _Allocator>
-    inline _ForwardIterator
-    __uninitialized_copy_move(_InputIterator1 __first1,
-         _InputIterator1 __last1,
-         _InputIterator2 __first2,
-         _InputIterator2 __last2,
-         _ForwardIterator __result,
-         _Allocator& __alloc)
-    {
-      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
-          __result,
-          __alloc);
-      try
- {
-   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
- }
-      catch(...)
- {
-   std::_Destroy(__result, __mid, __alloc);
-   throw;
- }
-    }
-
-
-
-
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _ForwardIterator, typename _Allocator>
-    inline _ForwardIterator
-    __uninitialized_move_copy(_InputIterator1 __first1,
-         _InputIterator1 __last1,
-         _InputIterator2 __first2,
-         _InputIterator2 __last2,
-         _ForwardIterator __result,
-         _Allocator& __alloc)
-    {
-      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
-          __result,
-          __alloc);
-      try
- {
-   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
- }
-      catch(...)
- {
-   std::_Destroy(__result, __mid, __alloc);
-   throw;
- }
-    }
-
-
-
-
-  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
-    typename _Allocator>
-    inline _ForwardIterator
-    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
-         const _Tp& __x, _InputIterator __first,
-         _InputIterator __last, _Allocator& __alloc)
-    {
-      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
-      try
- {
-   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
- }
-      catch(...)
- {
-   std::_Destroy(__result, __mid, __alloc);
-   throw;
- }
-    }
-
-
-
-
-  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
-    typename _Allocator>
-    inline void
-    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
-         _ForwardIterator __first2,
-         _ForwardIterator __last2, const _Tp& __x,
-         _Allocator& __alloc)
-    {
-      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
-           __first2,
-           __alloc);
-      try
- {
-   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
- }
-      catch(...)
- {
-   std::_Destroy(__first2, __mid2, __alloc);
-   throw;
- }
-    }
-
-
-
-
-
-  template<bool _TrivialValueType>
-    struct __uninitialized_default_1
-    {
-      template<typename _ForwardIterator>
-        static void
-        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
-        {
-   _ForwardIterator __cur = __first;
-   try
-     {
-       for (; __cur != __last; ++__cur)
-  std::_Construct(std::__addressof(*__cur));
-     }
-   catch(...)
-     {
-       std::_Destroy(__first, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_default_1<true>
-    {
-      template<typename _ForwardIterator>
-        static void
-        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
-        {
-   typedef typename iterator_traits<_ForwardIterator>::value_type
-     _ValueType;
-
-   std::fill(__first, __last, _ValueType());
- }
-    };
-
-  template<bool _TrivialValueType>
-    struct __uninitialized_default_n_1
-    {
-      template<typename _ForwardIterator, typename _Size>
-        static _ForwardIterator
-        __uninit_default_n(_ForwardIterator __first, _Size __n)
-        {
-   _ForwardIterator __cur = __first;
-   try
-     {
-       for (; __n > 0; --__n, ++__cur)
-  std::_Construct(std::__addressof(*__cur));
-       return __cur;
-     }
-   catch(...)
-     {
-       std::_Destroy(__first, __cur);
-       throw;
-     }
- }
-    };
-
-  template<>
-    struct __uninitialized_default_n_1<true>
-    {
-      template<typename _ForwardIterator, typename _Size>
-        static _ForwardIterator
-        __uninit_default_n(_ForwardIterator __first, _Size __n)
-        {
-   typedef typename iterator_traits<_ForwardIterator>::value_type
-     _ValueType;
-
-   return std::fill_n(__first, __n, _ValueType());
- }
-    };
-
-
-
-
-  template<typename _ForwardIterator>
-    inline void
-    __uninitialized_default(_ForwardIterator __first,
-       _ForwardIterator __last)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType;
-
-      const bool __assignable = is_copy_assignable<_ValueType>::value;
-
-      std::__uninitialized_default_1<__is_trivial(_ValueType)
-         && __assignable>::
- __uninit_default(__first, __last);
-    }
-
-
-
-  template<typename _ForwardIterator, typename _Size>
-    inline _ForwardIterator
-    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::value_type
- _ValueType;
-
-      const bool __assignable = is_copy_assignable<_ValueType>::value;
-
-      return __uninitialized_default_n_1<__is_trivial(_ValueType)
-           && __assignable>::
- __uninit_default_n(__first, __n);
-    }
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Allocator>
-    void
-    __uninitialized_default_a(_ForwardIterator __first,
-         _ForwardIterator __last,
-         _Allocator& __alloc)
-    {
-      _ForwardIterator __cur = __first;
-      try
- {
-   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-   for (; __cur != __last; ++__cur)
-     __traits::construct(__alloc, std::__addressof(*__cur));
- }
-      catch(...)
- {
-   std::_Destroy(__first, __cur, __alloc);
-   throw;
- }
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline void
-    __uninitialized_default_a(_ForwardIterator __first,
-         _ForwardIterator __last,
-         allocator<_Tp>&)
-    { std::__uninitialized_default(__first, __last); }
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Size, typename _Allocator>
-    _ForwardIterator
-    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
-    _Allocator& __alloc)
-    {
-      _ForwardIterator __cur = __first;
-      try
- {
-   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
-   for (; __n > 0; --__n, ++__cur)
-     __traits::construct(__alloc, std::__addressof(*__cur));
-   return __cur;
- }
-      catch(...)
- {
-   std::_Destroy(__first, __cur, __alloc);
-   throw;
- }
-    }
-
-  template<typename _ForwardIterator, typename _Size, typename _Tp>
-    inline _ForwardIterator
-    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
-    allocator<_Tp>&)
-    { return std::__uninitialized_default_n(__first, __n); }
-
-
-  template<typename _InputIterator, typename _Size,
-    typename _ForwardIterator>
-    _ForwardIterator
-    __uninitialized_copy_n(_InputIterator __first, _Size __n,
-      _ForwardIterator __result, input_iterator_tag)
-    {
-      _ForwardIterator __cur = __result;
-      try
- {
-   for (; __n > 0; --__n, ++__first, ++__cur)
-     std::_Construct(std::__addressof(*__cur), *__first);
-   return __cur;
- }
-      catch(...)
- {
-   std::_Destroy(__result, __cur);
-   throw;
- }
-    }
-
-  template<typename _RandomAccessIterator, typename _Size,
-    typename _ForwardIterator>
-    inline _ForwardIterator
-    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
-      _ForwardIterator __result,
-      random_access_iterator_tag)
-    { return std::uninitialized_copy(__first, __first + __n, __result); }
-# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_uninitialized.h" 3
-  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
-    inline _ForwardIterator
-    uninitialized_copy_n(_InputIterator __first, _Size __n,
-    _ForwardIterator __result)
-    { return std::__uninitialized_copy_n(__first, __n, __result,
-      std::__iterator_category(__first)); }
-
-
-
-}
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 1 3
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 88 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  constexpr inline size_t
-  __deque_buf_size(size_t __size)
-  { return (__size < 512
-     ? size_t(512 / __size) : size_t(1)); }
-# 105 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    struct _Deque_iterator
-    {
-
-
-
-
-
-
-    private:
-      template<typename _Up>
- using __ptr_to = typename pointer_traits<_Ptr>::template rebind<_Up>;
-      template<typename _CvTp>
- using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
-    public:
-      typedef __iter<_Tp> iterator;
-      typedef __iter<const _Tp> const_iterator;
-      typedef __ptr_to<_Tp> _Elt_pointer;
-      typedef __ptr_to<_Elt_pointer> _Map_pointer;
-
-
-      static size_t _S_buffer_size() noexcept
-      { return __deque_buf_size(sizeof(_Tp)); }
-
-      typedef std::random_access_iterator_tag iterator_category;
-      typedef _Tp value_type;
-      typedef _Ptr pointer;
-      typedef _Ref reference;
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Deque_iterator _Self;
-
-      _Elt_pointer _M_cur;
-      _Elt_pointer _M_first;
-      _Elt_pointer _M_last;
-      _Map_pointer _M_node;
-
-      _Deque_iterator(_Elt_pointer __x, _Map_pointer __y) noexcept
-      : _M_cur(__x), _M_first(*__y),
-        _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
-
-      _Deque_iterator() noexcept
-      : _M_cur(), _M_first(), _M_last(), _M_node() { }
-
-      _Deque_iterator(const iterator& __x) noexcept
-      : _M_cur(__x._M_cur), _M_first(__x._M_first),
-        _M_last(__x._M_last), _M_node(__x._M_node) { }
-
-      iterator
-      _M_const_cast() const noexcept
-      { return iterator(_M_cur, _M_node); }
-
-      reference
-      operator*() const noexcept
-      { return *_M_cur; }
-
-      pointer
-      operator->() const noexcept
-      { return _M_cur; }
-
-      _Self&
-      operator++() noexcept
-      {
- ++_M_cur;
- if (_M_cur == _M_last)
-   {
-     _M_set_node(_M_node + 1);
-     _M_cur = _M_first;
-   }
- return *this;
-      }
-
-      _Self
-      operator++(int) noexcept
-      {
- _Self __tmp = *this;
- ++*this;
- return __tmp;
-      }
-
-      _Self&
-      operator--() noexcept
-      {
- if (_M_cur == _M_first)
-   {
-     _M_set_node(_M_node - 1);
-     _M_cur = _M_last;
-   }
- --_M_cur;
- return *this;
-      }
-
-      _Self
-      operator--(int) noexcept
-      {
- _Self __tmp = *this;
- --*this;
- return __tmp;
-      }
-
-      _Self&
-      operator+=(difference_type __n) noexcept
-      {
- const difference_type __offset = __n + (_M_cur - _M_first);
- if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
-   _M_cur += __n;
- else
-   {
-     const difference_type __node_offset =
-       __offset > 0 ? __offset / difference_type(_S_buffer_size())
-                    : -difference_type((-__offset - 1)
-           / _S_buffer_size()) - 1;
-     _M_set_node(_M_node + __node_offset);
-     _M_cur = _M_first + (__offset - __node_offset
-     * difference_type(_S_buffer_size()));
-   }
- return *this;
-      }
-
-      _Self
-      operator+(difference_type __n) const noexcept
-      {
- _Self __tmp = *this;
- return __tmp += __n;
-      }
-
-      _Self&
-      operator-=(difference_type __n) noexcept
-      { return *this += -__n; }
-
-      _Self
-      operator-(difference_type __n) const noexcept
-      {
- _Self __tmp = *this;
- return __tmp -= __n;
-      }
-
-      reference
-      operator[](difference_type __n) const noexcept
-      { return *(*this + __n); }
-
-
-
-
-
-
-      void
-      _M_set_node(_Map_pointer __new_node) noexcept
-      {
- _M_node = __new_node;
- _M_first = *__new_node;
- _M_last = _M_first + difference_type(_S_buffer_size());
-      }
-    };
-
-
-
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return __x._M_cur == __y._M_cur; }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return __x._M_cur == __y._M_cur; }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return !(__x == __y); }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return !(__x == __y); }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
-                                          : (__x._M_node < __y._M_node); }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
-                                   : (__x._M_node < __y._M_node); }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return __y < __x; }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return __y < __x; }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return !(__y < __x); }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return !(__y < __x); }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline bool
-    operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    { return !(__x < __y); }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline bool
-    operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    { return !(__x < __y); }
-
-
-
-
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
-    operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
-       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) noexcept
-    {
-      return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
- (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
- * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
- + (__y._M_last - __y._M_cur);
-    }
-
-  template<typename _Tp, typename _RefL, typename _PtrL,
-    typename _RefR, typename _PtrR>
-    inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
-    operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
-       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
-    {
-      return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
- (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
- * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
- + (__y._M_last - __y._M_cur);
-    }
-
-  template<typename _Tp, typename _Ref, typename _Ptr>
-    inline _Deque_iterator<_Tp, _Ref, _Ptr>
-    operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
-    noexcept
-    { return __x + __n; }
-
-  template<typename _Tp>
-    void
-    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
-  const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-  _Deque_iterator<_Tp, _Tp&, _Tp*>);
-
-  template<typename _Tp>
-    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
-         _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
-         __result); }
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-    _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-    _Deque_iterator<_Tp, _Tp&, _Tp*>);
-
-  template<typename _Tp>
-    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    { return std::copy_backward(_Deque_iterator<_Tp,
-    const _Tp&, const _Tp*>(__first),
-    _Deque_iterator<_Tp,
-    const _Tp&, const _Tp*>(__last),
-    __result); }
-
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-  _Deque_iterator<_Tp, _Tp&, _Tp*>);
-
-  template<typename _Tp>
-    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
-         _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
-         __result); }
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-    _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
-    _Deque_iterator<_Tp, _Tp&, _Tp*>);
-
-  template<typename _Tp>
-    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    { return std::move_backward(_Deque_iterator<_Tp,
-    const _Tp&, const _Tp*>(__first),
-    _Deque_iterator<_Tp,
-    const _Tp&, const _Tp*>(__last),
-    __result); }
-# 457 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Alloc>
-    class _Deque_base
-    {
-    protected:
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_Tp>::other _Tp_alloc_type;
-      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
-
-
-
-
-
-      typedef typename _Alloc_traits::pointer _Ptr;
-      typedef typename _Alloc_traits::const_pointer _Ptr_const;
-
-
-      typedef typename _Alloc_traits::template rebind<_Ptr>::other
- _Map_alloc_type;
-      typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits;
-
-    public:
-      typedef _Alloc allocator_type;
-      typedef typename _Alloc_traits::size_type size_type;
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_get_Tp_allocator()); }
-
-      typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
-      typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
-
-      _Deque_base()
-      : _M_impl()
-      { _M_initialize_map(0); }
-
-      _Deque_base(size_t __num_elements)
-      : _M_impl()
-      { _M_initialize_map(__num_elements); }
-
-      _Deque_base(const allocator_type& __a, size_t __num_elements)
-      : _M_impl(__a)
-      { _M_initialize_map(__num_elements); }
-
-      _Deque_base(const allocator_type& __a)
-      : _M_impl(__a)
-      { }
-
-
-      _Deque_base(_Deque_base&& __x, false_type)
-      : _M_impl(__x._M_move_impl())
-      { }
-
-      _Deque_base(_Deque_base&& __x, true_type)
-      : _M_impl(std::move(__x._M_get_Tp_allocator()))
-      {
- _M_initialize_map(0);
- if (__x._M_impl._M_map)
-   this->_M_impl._M_swap_data(__x._M_impl);
-      }
-
-      _Deque_base(_Deque_base&& __x)
-      : _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
-      { }
-
-      _Deque_base(_Deque_base&& __x, const allocator_type& __a, size_type __n)
-      : _M_impl(__a)
-      {
- if (__x.get_allocator() == __a)
-   {
-     if (__x._M_impl._M_map)
-       {
-  _M_initialize_map(0);
-  this->_M_impl._M_swap_data(__x._M_impl);
-       }
-   }
- else
-   {
-     _M_initialize_map(__n);
-   }
-      }
-
-
-      ~_Deque_base() noexcept;
-
-    protected:
-      typedef typename iterator::_Map_pointer _Map_pointer;
-
-
-
-
-      struct _Deque_impl
-      : public _Tp_alloc_type
-      {
- _Map_pointer _M_map;
- size_t _M_map_size;
- iterator _M_start;
- iterator _M_finish;
-
- _Deque_impl()
- : _Tp_alloc_type(), _M_map(), _M_map_size(0),
-   _M_start(), _M_finish()
- { }
-
- _Deque_impl(const _Tp_alloc_type& __a) noexcept
- : _Tp_alloc_type(__a), _M_map(), _M_map_size(0),
-   _M_start(), _M_finish()
- { }
-
-
- _Deque_impl(_Deque_impl&&) = default;
-
- _Deque_impl(_Tp_alloc_type&& __a) noexcept
- : _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
-   _M_start(), _M_finish()
- { }
-
-
- void _M_swap_data(_Deque_impl& __x) noexcept
- {
-   using std::swap;
-   swap(this->_M_start, __x._M_start);
-   swap(this->_M_finish, __x._M_finish);
-   swap(this->_M_map, __x._M_map);
-   swap(this->_M_map_size, __x._M_map_size);
- }
-      };
-
-      _Tp_alloc_type&
-      _M_get_Tp_allocator() noexcept
-      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
-
-      const _Tp_alloc_type&
-      _M_get_Tp_allocator() const noexcept
-      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
-
-      _Map_alloc_type
-      _M_get_map_allocator() const noexcept
-      { return _Map_alloc_type(_M_get_Tp_allocator()); }
-
-      _Ptr
-      _M_allocate_node()
-      {
- typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
- return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
-      }
-
-      void
-      _M_deallocate_node(_Ptr __p) noexcept
-      {
- typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
- _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
-      }
-
-      _Map_pointer
-      _M_allocate_map(size_t __n)
-      {
- _Map_alloc_type __map_alloc = _M_get_map_allocator();
- return _Map_alloc_traits::allocate(__map_alloc, __n);
-      }
-
-      void
-      _M_deallocate_map(_Map_pointer __p, size_t __n) noexcept
-      {
- _Map_alloc_type __map_alloc = _M_get_map_allocator();
- _Map_alloc_traits::deallocate(__map_alloc, __p, __n);
-      }
-
-    protected:
-      void _M_initialize_map(size_t);
-      void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish);
-      void _M_destroy_nodes(_Map_pointer __nstart,
-       _Map_pointer __nfinish) noexcept;
-      enum { _S_initial_map_size = 8 };
-
-      _Deque_impl _M_impl;
-
-
-    private:
-      _Deque_impl
-      _M_move_impl()
-      {
- if (!_M_impl._M_map)
-   return std::move(_M_impl);
-
-
- _Tp_alloc_type __alloc{_M_get_Tp_allocator()};
-
- _Tp_alloc_type __sink __attribute((__unused__)) {std::move(__alloc)};
-
- _Deque_base __empty{__alloc};
- __empty._M_initialize_map(0);
-
- _Deque_impl __ret{std::move(_M_get_Tp_allocator())};
- _M_impl._M_swap_data(__ret);
- _M_impl._M_swap_data(__empty._M_impl);
- return __ret;
-      }
-
-    };
-
-  template<typename _Tp, typename _Alloc>
-    _Deque_base<_Tp, _Alloc>::
-    ~_Deque_base() noexcept
-    {
-      if (this->_M_impl._M_map)
- {
-   _M_destroy_nodes(this->_M_impl._M_start._M_node,
-      this->_M_impl._M_finish._M_node + 1);
-   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
- }
-    }
-# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Alloc>
-    void
-    _Deque_base<_Tp, _Alloc>::
-    _M_initialize_map(size_t __num_elements)
-    {
-      const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
-      + 1);
-
-      this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
-        size_t(__num_nodes + 2));
-      this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
-
-
-
-
-
-
-      _Map_pointer __nstart = (this->_M_impl._M_map
-          + (this->_M_impl._M_map_size - __num_nodes) / 2);
-      _Map_pointer __nfinish = __nstart + __num_nodes;
-
-      try
- { _M_create_nodes(__nstart, __nfinish); }
-      catch(...)
- {
-   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
-   this->_M_impl._M_map = _Map_pointer();
-   this->_M_impl._M_map_size = 0;
-   throw;
- }
-
-      this->_M_impl._M_start._M_set_node(__nstart);
-      this->_M_impl._M_finish._M_set_node(__nfinish - 1);
-      this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
-      this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
-     + __num_elements
-     % __deque_buf_size(sizeof(_Tp)));
-    }
-
-  template<typename _Tp, typename _Alloc>
-    void
-    _Deque_base<_Tp, _Alloc>::
-    _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish)
-    {
-      _Map_pointer __cur;
-      try
- {
-   for (__cur = __nstart; __cur < __nfinish; ++__cur)
-     *__cur = this->_M_allocate_node();
- }
-      catch(...)
- {
-   _M_destroy_nodes(__nstart, __cur);
-   throw;
- }
-    }
-
-  template<typename _Tp, typename _Alloc>
-    void
-    _Deque_base<_Tp, _Alloc>::
-    _M_destroy_nodes(_Map_pointer __nstart,
-       _Map_pointer __nfinish) noexcept
-    {
-      for (_Map_pointer __n = __nstart; __n < __nfinish; ++__n)
- _M_deallocate_node(*__n);
-    }
-# 828 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
-    class deque : protected _Deque_base<_Tp, _Alloc>
-    {
-
-      typedef typename _Alloc::value_type _Alloc_value_type;
-
-
-
-
-
-      typedef _Deque_base<_Tp, _Alloc> _Base;
-      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
-      typedef typename _Base::_Alloc_traits _Alloc_traits;
-      typedef typename _Base::_Map_pointer _Map_pointer;
-
-    public:
-      typedef _Tp value_type;
-      typedef typename _Alloc_traits::pointer pointer;
-      typedef typename _Alloc_traits::const_pointer const_pointer;
-      typedef typename _Alloc_traits::reference reference;
-      typedef typename _Alloc_traits::const_reference const_reference;
-      typedef typename _Base::iterator iterator;
-      typedef typename _Base::const_iterator const_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Alloc allocator_type;
-
-    protected:
-      static size_t _S_buffer_size() noexcept
-      { return __deque_buf_size(sizeof(_Tp)); }
-
-
-      using _Base::_M_initialize_map;
-      using _Base::_M_create_nodes;
-      using _Base::_M_destroy_nodes;
-      using _Base::_M_allocate_node;
-      using _Base::_M_deallocate_node;
-      using _Base::_M_allocate_map;
-      using _Base::_M_deallocate_map;
-      using _Base::_M_get_Tp_allocator;
-
-
-
-
-
-      using _Base::_M_impl;
-
-    public:
-
-
-
-
-
-
-      deque() : _Base() { }
-
-
-
-
-
-      explicit
-      deque(const allocator_type& __a)
-      : _Base(__a, 0) { }
-# 903 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      explicit
-      deque(size_type __n, const allocator_type& __a = allocator_type())
-      : _Base(__a, __n)
-      { _M_default_initialize(); }
-# 916 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque(size_type __n, const value_type& __value,
-     const allocator_type& __a = allocator_type())
-      : _Base(__a, __n)
-      { _M_fill_initialize(__value); }
-# 943 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque(const deque& __x)
-      : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()),
-       __x.size())
-      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
-        this->_M_impl._M_start,
-        _M_get_Tp_allocator()); }
-# 958 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque(deque&& __x)
-      : _Base(std::move(__x)) { }
-
-
-      deque(const deque& __x, const allocator_type& __a)
-      : _Base(__a, __x.size())
-      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
-        this->_M_impl._M_start,
-        _M_get_Tp_allocator()); }
-
-
-      deque(deque&& __x, const allocator_type& __a)
-      : _Base(std::move(__x), __a, __x.size())
-      {
- if (__x.get_allocator() != __a)
-   {
-     std::__uninitialized_move_a(__x.begin(), __x.end(),
-     this->_M_impl._M_start,
-     _M_get_Tp_allocator());
-     __x.clear();
-   }
-      }
-# 992 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque(initializer_list<value_type> __l,
-     const allocator_type& __a = allocator_type())
-      : _Base(__a)
-      {
- _M_range_initialize(__l.begin(), __l.end(),
-       random_access_iterator_tag());
-      }
-# 1017 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        deque(_InputIterator __first, _InputIterator __last,
-       const allocator_type& __a = allocator_type())
- : _Base(__a)
-        { _M_initialize_dispatch(__first, __last, __false_type()); }
-# 1040 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      ~deque()
-      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
-# 1050 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque&
-      operator=(const deque& __x);
-# 1062 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque&
-      operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
-      {
- using __always_equal = typename _Alloc_traits::is_always_equal;
- _M_move_assign1(std::move(__x), __always_equal{});
- return *this;
-      }
-# 1081 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      deque&
-      operator=(initializer_list<value_type> __l)
-      {
- this->assign(__l.begin(), __l.end());
- return *this;
-      }
-# 1099 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      assign(size_type __n, const value_type& __val)
-      { _M_fill_assign(__n, __val); }
-# 1116 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        void
-        assign(_InputIterator __first, _InputIterator __last)
-        { _M_assign_dispatch(__first, __last, __false_type()); }
-# 1143 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      assign(initializer_list<value_type> __l)
-      { this->assign(__l.begin(), __l.end()); }
-
-
-
-      allocator_type
-      get_allocator() const noexcept
-      { return _Base::get_allocator(); }
-
-
-
-
-
-
-      iterator
-      begin() noexcept
-      { return this->_M_impl._M_start; }
-
-
-
-
-
-      const_iterator
-      begin() const noexcept
-      { return this->_M_impl._M_start; }
-
-
-
-
-
-
-      iterator
-      end() noexcept
-      { return this->_M_impl._M_finish; }
-
-
-
-
-
-
-      const_iterator
-      end() const noexcept
-      { return this->_M_impl._M_finish; }
-
-
-
-
-
-
-      reverse_iterator
-      rbegin() noexcept
-      { return reverse_iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rbegin() const noexcept
-      { return const_reverse_iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      reverse_iterator
-      rend() noexcept
-      { return reverse_iterator(this->_M_impl._M_start); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rend() const noexcept
-      { return const_reverse_iterator(this->_M_impl._M_start); }
-
-
-
-
-
-
-      const_iterator
-      cbegin() const noexcept
-      { return this->_M_impl._M_start; }
-
-
-
-
-
-
-      const_iterator
-      cend() const noexcept
-      { return this->_M_impl._M_finish; }
-
-
-
-
-
-
-      const_reverse_iterator
-      crbegin() const noexcept
-      { return const_reverse_iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      const_reverse_iterator
-      crend() const noexcept
-      { return const_reverse_iterator(this->_M_impl._M_start); }
-
-
-
-
-      size_type
-      size() const noexcept
-      { return this->_M_impl._M_finish - this->_M_impl._M_start; }
-
-
-      size_type
-      max_size() const noexcept
-      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
-# 1282 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      resize(size_type __new_size)
-      {
- const size_type __len = size();
- if (__new_size > __len)
-   _M_default_append(__new_size - __len);
- else if (__new_size < __len)
-   _M_erase_at_end(this->_M_impl._M_start
-     + difference_type(__new_size));
-      }
-# 1304 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      resize(size_type __new_size, const value_type& __x)
-      {
- const size_type __len = size();
- if (__new_size > __len)
-   insert(this->_M_impl._M_finish, __new_size - __len, __x);
- else if (__new_size < __len)
-   _M_erase_at_end(this->_M_impl._M_start
-     + difference_type(__new_size));
-      }
-# 1340 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      shrink_to_fit() noexcept
-      { _M_shrink_to_fit(); }
-
-
-
-
-
-
-      bool
-      empty() const noexcept
-      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
-# 1365 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      reference
-      operator[](size_type __n) noexcept
-      { return this->_M_impl._M_start[difference_type(__n)]; }
-# 1380 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      const_reference
-      operator[](size_type __n) const noexcept
-      { return this->_M_impl._M_start[difference_type(__n)]; }
-
-    protected:
-
-      void
-      _M_range_check(size_type __n) const
-      {
- if (__n >= this->size())
-   __throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)"),
-
-
-       __n, this->size());
-      }
-
-    public:
-# 1408 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      reference
-      at(size_type __n)
-      {
- _M_range_check(__n);
- return (*this)[__n];
-      }
-# 1426 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      const_reference
-      at(size_type __n) const
-      {
- _M_range_check(__n);
- return (*this)[__n];
-      }
-
-
-
-
-
-      reference
-      front() noexcept
-      { return *begin(); }
-
-
-
-
-
-      const_reference
-      front() const noexcept
-      { return *begin(); }
-
-
-
-
-
-      reference
-      back() noexcept
-      {
- iterator __tmp = end();
- --__tmp;
- return *__tmp;
-      }
-
-
-
-
-
-      const_reference
-      back() const noexcept
-      {
- const_iterator __tmp = end();
- --__tmp;
- return *__tmp;
-      }
-# 1483 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      push_front(const value_type& __x)
-      {
- if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
-   {
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_start._M_cur - 1,
-                              __x);
-     --this->_M_impl._M_start._M_cur;
-   }
- else
-   _M_push_front_aux(__x);
-      }
-
-
-      void
-      push_front(value_type&& __x)
-      { emplace_front(std::move(__x)); }
-
-      template<typename... _Args>
-        void
-        emplace_front(_Args&&... __args);
-# 1516 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      push_back(const value_type& __x)
-      {
- if (this->_M_impl._M_finish._M_cur
-     != this->_M_impl._M_finish._M_last - 1)
-   {
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_finish._M_cur, __x);
-     ++this->_M_impl._M_finish._M_cur;
-   }
- else
-   _M_push_back_aux(__x);
-      }
-
-
-      void
-      push_back(value_type&& __x)
-      { emplace_back(std::move(__x)); }
-
-      template<typename... _Args>
-        void
-        emplace_back(_Args&&... __args);
-# 1548 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      pop_front() noexcept
-      {
- if (this->_M_impl._M_start._M_cur
-     != this->_M_impl._M_start._M_last - 1)
-   {
-     _Alloc_traits::destroy(this->_M_impl,
-                            this->_M_impl._M_start._M_cur);
-     ++this->_M_impl._M_start._M_cur;
-   }
- else
-   _M_pop_front_aux();
-      }
-# 1570 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      pop_back() noexcept
-      {
- if (this->_M_impl._M_finish._M_cur
-     != this->_M_impl._M_finish._M_first)
-   {
-     --this->_M_impl._M_finish._M_cur;
-     _Alloc_traits::destroy(this->_M_impl,
-                            this->_M_impl._M_finish._M_cur);
-   }
- else
-   _M_pop_back_aux();
-      }
-# 1594 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename... _Args>
-        iterator
-        emplace(const_iterator __position, _Args&&... __args);
-# 1607 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-      insert(const_iterator __position, const value_type& __x);
-# 1633 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-      insert(const_iterator __position, value_type&& __x)
-      { return emplace(__position, std::move(__x)); }
-# 1646 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-      insert(const_iterator __p, initializer_list<value_type> __l)
-      { return this->insert(__p, __l.begin(), __l.end()); }
-# 1662 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-      insert(const_iterator __position, size_type __n, const value_type& __x)
-      {
- difference_type __offset = __position - cbegin();
- _M_fill_insert(__position._M_const_cast(), __n, __x);
- return begin() + __offset;
-      }
-# 1696 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        iterator
-        insert(const_iterator __position, _InputIterator __first,
-        _InputIterator __last)
-        {
-   difference_type __offset = __position - cbegin();
-   _M_insert_dispatch(__position._M_const_cast(),
-        __first, __last, __false_type());
-   return begin() + __offset;
- }
-# 1742 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-
-      erase(const_iterator __position)
-
-
-
-      { return _M_erase(__position._M_const_cast()); }
-# 1766 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      iterator
-
-      erase(const_iterator __first, const_iterator __last)
-
-
-
-      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
-# 1783 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      swap(deque& __x) noexcept
-      {
- _M_impl._M_swap_data(__x._M_impl);
- _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
-      __x._M_get_Tp_allocator());
-      }
-
-
-
-
-
-
-
-      void
-      clear() noexcept
-      { _M_erase_at_end(begin()); }
-
-    protected:
-
-
-
-
-
-
-      template<typename _Integer>
-        void
-        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
-        {
-   _M_initialize_map(static_cast<size_type>(__n));
-   _M_fill_initialize(__x);
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
-          __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-   _M_range_initialize(__first, __last, _IterCategory());
- }
-# 1839 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _InputIterator>
-        void
-        _M_range_initialize(_InputIterator __first, _InputIterator __last,
-       std::input_iterator_tag);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
-       std::forward_iterator_tag);
-# 1861 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      _M_fill_initialize(const value_type& __value);
-
-
-
-      void
-      _M_default_initialize();
-# 1877 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _Integer>
-        void
-        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
-        { _M_fill_assign(__n, __val); }
-
-
-      template<typename _InputIterator>
-        void
-        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
-      __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-   _M_assign_aux(__first, __last, _IterCategory());
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_assign_aux(_InputIterator __first, _InputIterator __last,
-        std::input_iterator_tag);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
-        std::forward_iterator_tag)
-        {
-   const size_type __len = std::distance(__first, __last);
-   if (__len > size())
-     {
-       _ForwardIterator __mid = __first;
-       std::advance(__mid, size());
-       std::copy(__first, __mid, begin());
-       insert(end(), __mid, __last);
-     }
-   else
-     _M_erase_at_end(std::copy(__first, __last, begin()));
- }
-
-
-
-      void
-      _M_fill_assign(size_type __n, const value_type& __val)
-      {
- if (__n > size())
-   {
-     std::fill(begin(), end(), __val);
-     insert(end(), __n - size(), __val);
-   }
- else
-   {
-     _M_erase_at_end(begin() + difference_type(__n));
-     std::fill(begin(), end(), __val);
-   }
-      }
-# 1941 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename... _Args>
-        void _M_push_back_aux(_Args&&... __args);
-
-      template<typename... _Args>
-        void _M_push_front_aux(_Args&&... __args);
-
-
-      void _M_pop_back_aux();
-
-      void _M_pop_front_aux();
-# 1960 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      template<typename _Integer>
-        void
-        _M_insert_dispatch(iterator __pos,
-      _Integer __n, _Integer __x, __true_type)
-        { _M_fill_insert(__pos, __n, __x); }
-
-
-      template<typename _InputIterator>
-        void
-        _M_insert_dispatch(iterator __pos,
-      _InputIterator __first, _InputIterator __last,
-      __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-          _M_range_insert_aux(__pos, __first, __last, _IterCategory());
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_range_insert_aux(iterator __pos, _InputIterator __first,
-       _InputIterator __last, std::input_iterator_tag);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
-       _ForwardIterator __last, std::forward_iterator_tag);
-
-
-
-
-      void
-      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
-
-
-
-
-
-
-      template<typename... _Args>
-        iterator
-        _M_insert_aux(iterator __pos, _Args&&... __args);
-
-
-
-      void
-      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_insert_aux(iterator __pos,
-        _ForwardIterator __first, _ForwardIterator __last,
-        size_type __n);
-
-
-
-
-      void
-      _M_destroy_data_aux(iterator __first, iterator __last);
-
-
-
-      template<typename _Alloc1>
-        void
-        _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
-        { _M_destroy_data_aux(__first, __last); }
-
-      void
-      _M_destroy_data(iterator __first, iterator __last,
-        const std::allocator<_Tp>&)
-      {
- if (!__has_trivial_destructor(value_type))
-   _M_destroy_data_aux(__first, __last);
-      }
-
-
-      void
-      _M_erase_at_begin(iterator __pos)
-      {
- _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
- _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
- this->_M_impl._M_start = __pos;
-      }
-
-
-
-      void
-      _M_erase_at_end(iterator __pos)
-      {
- _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
- _M_destroy_nodes(__pos._M_node + 1,
-    this->_M_impl._M_finish._M_node + 1);
- this->_M_impl._M_finish = __pos;
-      }
-
-      iterator
-      _M_erase(iterator __pos);
-
-      iterator
-      _M_erase(iterator __first, iterator __last);
-
-
-
-      void
-      _M_default_append(size_type __n);
-
-      bool
-      _M_shrink_to_fit();
-
-
-
-
-      iterator
-      _M_reserve_elements_at_front(size_type __n)
-      {
- const size_type __vacancies = this->_M_impl._M_start._M_cur
-                               - this->_M_impl._M_start._M_first;
- if (__n > __vacancies)
-   _M_new_elements_at_front(__n - __vacancies);
- return this->_M_impl._M_start - difference_type(__n);
-      }
-
-      iterator
-      _M_reserve_elements_at_back(size_type __n)
-      {
- const size_type __vacancies = (this->_M_impl._M_finish._M_last
-           - this->_M_impl._M_finish._M_cur) - 1;
- if (__n > __vacancies)
-   _M_new_elements_at_back(__n - __vacancies);
- return this->_M_impl._M_finish + difference_type(__n);
-      }
-
-      void
-      _M_new_elements_at_front(size_type __new_elements);
-
-      void
-      _M_new_elements_at_back(size_type __new_elements);
-# 2111 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-      void
-      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
-      {
- if (__nodes_to_add + 1 > this->_M_impl._M_map_size
-     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
-   _M_reallocate_map(__nodes_to_add, false);
-      }
-
-      void
-      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
-      {
- if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
-           - this->_M_impl._M_map))
-   _M_reallocate_map(__nodes_to_add, true);
-      }
-
-      void
-      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
-
-
-
-
-
-      void
-      _M_move_assign1(deque&& __x, true_type) noexcept
-      {
- this->_M_impl._M_swap_data(__x._M_impl);
- __x.clear();
- std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
-      }
-
-
-
-
-      void
-      _M_move_assign1(deque&& __x, false_type)
-      {
- constexpr bool __move_storage =
-   _Alloc_traits::_S_propagate_on_move_assign();
- _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
-      }
-
-
-
-      template<typename... _Args>
-      void
-      _M_replace_map(_Args&&... __args)
-      {
-
- deque __newobj(std::forward<_Args>(__args)...);
-
- clear();
- _M_deallocate_node(*begin()._M_node);
- _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
- this->_M_impl._M_map = nullptr;
- this->_M_impl._M_map_size = 0;
-
- this->_M_impl._M_swap_data(__newobj._M_impl);
-      }
-
-
-      void
-      _M_move_assign2(deque&& __x, true_type)
-      {
-
- auto __alloc = __x._M_get_Tp_allocator();
-
-
- _M_replace_map(std::move(__x));
-
- _M_get_Tp_allocator() = std::move(__alloc);
-      }
-
-
-
-      void
-      _M_move_assign2(deque&& __x, false_type)
-      {
- if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
-   {
-
-
-     _M_replace_map(std::move(__x), __x.get_allocator());
-   }
- else
-   {
-
-
-     this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
-    std::__make_move_if_noexcept_iterator(__x.end()));
-     __x.clear();
-   }
-      }
-
-    };
-# 2218 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator==(const deque<_Tp, _Alloc>& __x,
-                         const deque<_Tp, _Alloc>& __y)
-    { return __x.size() == __y.size()
-             && std::equal(__x.begin(), __x.end(), __y.begin()); }
-# 2236 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_deque.h" 3
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator<(const deque<_Tp, _Alloc>& __x,
-       const deque<_Tp, _Alloc>& __y)
-    { return std::lexicographical_compare(__x.begin(), __x.end(),
-       __y.begin(), __y.end()); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator!=(const deque<_Tp, _Alloc>& __x,
-        const deque<_Tp, _Alloc>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator>(const deque<_Tp, _Alloc>& __x,
-       const deque<_Tp, _Alloc>& __y)
-    { return __y < __x; }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator<=(const deque<_Tp, _Alloc>& __x,
-        const deque<_Tp, _Alloc>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator>=(const deque<_Tp, _Alloc>& __x,
-        const deque<_Tp, _Alloc>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline void
-    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-
-
-}
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/deque.tcc" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/deque.tcc" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_default_initialize()
-    {
-      _Map_pointer __cur;
-      try
-        {
-          for (__cur = this->_M_impl._M_start._M_node;
-        __cur < this->_M_impl._M_finish._M_node;
-        ++__cur)
-            std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
-        _M_get_Tp_allocator());
-          std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
-      this->_M_impl._M_finish._M_cur,
-      _M_get_Tp_allocator());
-        }
-      catch(...)
-        {
-          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
-   _M_get_Tp_allocator());
-          throw;
-        }
-    }
-
-
-  template <typename _Tp, typename _Alloc>
-    deque<_Tp, _Alloc>&
-    deque<_Tp, _Alloc>::
-    operator=(const deque& __x)
-    {
-      if (&__x != this)
- {
-
-   if (_Alloc_traits::_S_propagate_on_copy_assign())
-     {
-       if (!_Alloc_traits::_S_always_equal()
-           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
-         {
-
-
-    _M_replace_map(__x, __x.get_allocator());
-    std::__alloc_on_copy(_M_get_Tp_allocator(),
-           __x._M_get_Tp_allocator());
-    return *this;
-  }
-       std::__alloc_on_copy(_M_get_Tp_allocator(),
-       __x._M_get_Tp_allocator());
-     }
-
-   const size_type __len = size();
-   if (__len >= __x.size())
-     _M_erase_at_end(std::copy(__x.begin(), __x.end(),
-          this->_M_impl._M_start));
-   else
-     {
-       const_iterator __mid = __x.begin() + difference_type(__len);
-       std::copy(__x.begin(), __mid, this->_M_impl._M_start);
-       insert(this->_M_impl._M_finish, __mid, __x.end());
-     }
- }
-      return *this;
-    }
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      void
-      deque<_Tp, _Alloc>::
-      emplace_front(_Args&&... __args)
-      {
- if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
-   {
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_start._M_cur - 1,
-                std::forward<_Args>(__args)...);
-     --this->_M_impl._M_start._M_cur;
-   }
- else
-   _M_push_front_aux(std::forward<_Args>(__args)...);
-      }
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      void
-      deque<_Tp, _Alloc>::
-      emplace_back(_Args&&... __args)
-      {
- if (this->_M_impl._M_finish._M_cur
-     != this->_M_impl._M_finish._M_last - 1)
-   {
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_finish._M_cur,
-                std::forward<_Args>(__args)...);
-     ++this->_M_impl._M_finish._M_cur;
-   }
- else
-   _M_push_back_aux(std::forward<_Args>(__args)...);
-      }
-
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      typename deque<_Tp, _Alloc>::iterator
-      deque<_Tp, _Alloc>::
-      emplace(const_iterator __position, _Args&&... __args)
-      {
- if (__position._M_cur == this->_M_impl._M_start._M_cur)
-   {
-     emplace_front(std::forward<_Args>(__args)...);
-     return this->_M_impl._M_start;
-   }
- else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
-   {
-     emplace_back(std::forward<_Args>(__args)...);
-     iterator __tmp = this->_M_impl._M_finish;
-     --__tmp;
-     return __tmp;
-   }
- else
-   return _M_insert_aux(__position._M_const_cast(),
-          std::forward<_Args>(__args)...);
-      }
-
-
-  template <typename _Tp, typename _Alloc>
-    typename deque<_Tp, _Alloc>::iterator
-    deque<_Tp, _Alloc>::
-
-    insert(const_iterator __position, const value_type& __x)
-
-
-
-    {
-      if (__position._M_cur == this->_M_impl._M_start._M_cur)
- {
-   push_front(__x);
-   return this->_M_impl._M_start;
- }
-      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
- {
-   push_back(__x);
-   iterator __tmp = this->_M_impl._M_finish;
-   --__tmp;
-   return __tmp;
- }
-      else
- return _M_insert_aux(__position._M_const_cast(), __x);
-   }
-
-  template <typename _Tp, typename _Alloc>
-    typename deque<_Tp, _Alloc>::iterator
-    deque<_Tp, _Alloc>::
-    _M_erase(iterator __position)
-    {
-      iterator __next = __position;
-      ++__next;
-      const difference_type __index = __position - begin();
-      if (static_cast<size_type>(__index) < (size() >> 1))
- {
-   if (__position != begin())
-     std::move_backward(begin(), __position, __next);
-   pop_front();
- }
-      else
- {
-   if (__next != end())
-     std::move(__next, end(), __position);
-   pop_back();
- }
-      return begin() + __index;
-    }
-
-  template <typename _Tp, typename _Alloc>
-    typename deque<_Tp, _Alloc>::iterator
-    deque<_Tp, _Alloc>::
-    _M_erase(iterator __first, iterator __last)
-    {
-      if (__first == __last)
- return __first;
-      else if (__first == begin() && __last == end())
- {
-   clear();
-   return end();
- }
-      else
- {
-   const difference_type __n = __last - __first;
-   const difference_type __elems_before = __first - begin();
-   if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
-     {
-       if (__first != begin())
-  std::move_backward(begin(), __first, __last);
-       _M_erase_at_begin(begin() + __n);
-     }
-   else
-     {
-       if (__last != end())
-  std::move(__last, end(), __first);
-       _M_erase_at_end(end() - __n);
-     }
-   return begin() + __elems_before;
- }
-    }
-
-  template <typename _Tp, class _Alloc>
-    template <typename _InputIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_assign_aux(_InputIterator __first, _InputIterator __last,
-      std::input_iterator_tag)
-      {
-        iterator __cur = begin();
-        for (; __first != __last && __cur != end(); ++__cur, ++__first)
-          *__cur = *__first;
-        if (__first == __last)
-          _M_erase_at_end(__cur);
-        else
-          insert(end(), __first, __last);
-      }
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
-    {
-      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
- {
-   iterator __new_start = _M_reserve_elements_at_front(__n);
-   try
-     {
-       std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
-       __x, _M_get_Tp_allocator());
-       this->_M_impl._M_start = __new_start;
-     }
-   catch(...)
-     {
-       _M_destroy_nodes(__new_start._M_node,
-          this->_M_impl._M_start._M_node);
-       throw;
-     }
- }
-      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
- {
-   iterator __new_finish = _M_reserve_elements_at_back(__n);
-   try
-     {
-       std::__uninitialized_fill_a(this->_M_impl._M_finish,
-       __new_finish, __x,
-       _M_get_Tp_allocator());
-       this->_M_impl._M_finish = __new_finish;
-     }
-   catch(...)
-     {
-       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
-          __new_finish._M_node + 1);
-       throw;
-     }
- }
-      else
-        _M_insert_aux(__pos, __n, __x);
-    }
-
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_default_append(size_type __n)
-    {
-      if (__n)
- {
-   iterator __new_finish = _M_reserve_elements_at_back(__n);
-   try
-     {
-       std::__uninitialized_default_a(this->_M_impl._M_finish,
-          __new_finish,
-          _M_get_Tp_allocator());
-       this->_M_impl._M_finish = __new_finish;
-     }
-   catch(...)
-     {
-       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
-          __new_finish._M_node + 1);
-       throw;
-     }
- }
-    }
-
-  template <typename _Tp, typename _Alloc>
-    bool
-    deque<_Tp, _Alloc>::
-    _M_shrink_to_fit()
-    {
-      const difference_type __front_capacity
- = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
-      if (__front_capacity == 0)
- return false;
-
-      const difference_type __back_capacity
- = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
-      if (__front_capacity + __back_capacity < _S_buffer_size())
- return false;
-
-      return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
-    }
-
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_fill_initialize(const value_type& __value)
-    {
-      _Map_pointer __cur;
-      try
-        {
-          for (__cur = this->_M_impl._M_start._M_node;
-        __cur < this->_M_impl._M_finish._M_node;
-        ++__cur)
-            std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
-     __value, _M_get_Tp_allocator());
-          std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
-          this->_M_impl._M_finish._M_cur,
-          __value, _M_get_Tp_allocator());
-        }
-      catch(...)
-        {
-          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
-   _M_get_Tp_allocator());
-          throw;
-        }
-    }
-
-  template <typename _Tp, typename _Alloc>
-    template <typename _InputIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_range_initialize(_InputIterator __first, _InputIterator __last,
-                          std::input_iterator_tag)
-      {
-        this->_M_initialize_map(0);
-        try
-          {
-            for (; __first != __last; ++__first)
-
-       emplace_back(*__first);
-
-
-
-          }
-        catch(...)
-          {
-            clear();
-            throw;
-          }
-      }
-
-  template <typename _Tp, typename _Alloc>
-    template <typename _ForwardIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
-                          std::forward_iterator_tag)
-      {
-        const size_type __n = std::distance(__first, __last);
-        this->_M_initialize_map(__n);
-
-        _Map_pointer __cur_node;
-        try
-          {
-            for (__cur_node = this->_M_impl._M_start._M_node;
-                 __cur_node < this->_M_impl._M_finish._M_node;
-                 ++__cur_node)
-       {
-  _ForwardIterator __mid = __first;
-  std::advance(__mid, _S_buffer_size());
-  std::__uninitialized_copy_a(__first, __mid, *__cur_node,
-         _M_get_Tp_allocator());
-  __first = __mid;
-       }
-            std::__uninitialized_copy_a(__first, __last,
-     this->_M_impl._M_finish._M_first,
-     _M_get_Tp_allocator());
-          }
-        catch(...)
-          {
-            std::_Destroy(this->_M_impl._M_start,
-     iterator(*__cur_node, __cur_node),
-     _M_get_Tp_allocator());
-            throw;
-          }
-      }
-
-
-  template<typename _Tp, typename _Alloc>
-
-    template<typename... _Args>
-      void
-      deque<_Tp, _Alloc>::
-      _M_push_back_aux(_Args&&... __args)
-
-
-
-
-
-      {
- _M_reserve_map_at_back();
- *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
- try
-   {
-
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_finish._M_cur,
-                std::forward<_Args>(__args)...);
-
-
-
-     this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
-      + 1);
-     this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
-   }
- catch(...)
-   {
-     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
-     throw;
-   }
-      }
-
-
-  template<typename _Tp, typename _Alloc>
-
-    template<typename... _Args>
-      void
-      deque<_Tp, _Alloc>::
-      _M_push_front_aux(_Args&&... __args)
-
-
-
-
-
-      {
- _M_reserve_map_at_front();
- *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
- try
-   {
-     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
-            - 1);
-     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
-
-     _Alloc_traits::construct(this->_M_impl,
-                              this->_M_impl._M_start._M_cur,
-                std::forward<_Args>(__args)...);
-
-
-
-   }
- catch(...)
-   {
-     ++this->_M_impl._M_start;
-     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
-     throw;
-   }
-      }
-
-
-  template <typename _Tp, typename _Alloc>
-    void deque<_Tp, _Alloc>::
-    _M_pop_back_aux()
-    {
-      _M_deallocate_node(this->_M_impl._M_finish._M_first);
-      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
-      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
-      _Alloc_traits::destroy(_M_get_Tp_allocator(),
-        this->_M_impl._M_finish._M_cur);
-    }
-
-
-
-
-
-
-  template <typename _Tp, typename _Alloc>
-    void deque<_Tp, _Alloc>::
-    _M_pop_front_aux()
-    {
-      _Alloc_traits::destroy(_M_get_Tp_allocator(),
-        this->_M_impl._M_start._M_cur);
-      _M_deallocate_node(this->_M_impl._M_start._M_first);
-      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
-      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
-    }
-
-  template <typename _Tp, typename _Alloc>
-    template <typename _InputIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_range_insert_aux(iterator __pos,
-                          _InputIterator __first, _InputIterator __last,
-                          std::input_iterator_tag)
-      { std::copy(__first, __last, std::inserter(*this, __pos)); }
-
-  template <typename _Tp, typename _Alloc>
-    template <typename _ForwardIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_range_insert_aux(iterator __pos,
-                          _ForwardIterator __first, _ForwardIterator __last,
-                          std::forward_iterator_tag)
-      {
-        const size_type __n = std::distance(__first, __last);
-        if (__pos._M_cur == this->_M_impl._M_start._M_cur)
-   {
-     iterator __new_start = _M_reserve_elements_at_front(__n);
-     try
-       {
-  std::__uninitialized_copy_a(__first, __last, __new_start,
-         _M_get_Tp_allocator());
-  this->_M_impl._M_start = __new_start;
-       }
-     catch(...)
-       {
-  _M_destroy_nodes(__new_start._M_node,
-     this->_M_impl._M_start._M_node);
-  throw;
-       }
-   }
-        else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
-   {
-     iterator __new_finish = _M_reserve_elements_at_back(__n);
-     try
-       {
-  std::__uninitialized_copy_a(__first, __last,
-         this->_M_impl._M_finish,
-         _M_get_Tp_allocator());
-  this->_M_impl._M_finish = __new_finish;
-       }
-     catch(...)
-       {
-  _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
-     __new_finish._M_node + 1);
-  throw;
-       }
-   }
-        else
-          _M_insert_aux(__pos, __first, __last, __n);
-      }
-
-  template<typename _Tp, typename _Alloc>
-
-    template<typename... _Args>
-      typename deque<_Tp, _Alloc>::iterator
-      deque<_Tp, _Alloc>::
-      _M_insert_aux(iterator __pos, _Args&&... __args)
-      {
- value_type __x_copy(std::forward<_Args>(__args)...);
-
-
-
-
-
-
-
- difference_type __index = __pos - this->_M_impl._M_start;
- if (static_cast<size_type>(__index) < size() / 2)
-   {
-     push_front(std::move(front()));
-     iterator __front1 = this->_M_impl._M_start;
-     ++__front1;
-     iterator __front2 = __front1;
-     ++__front2;
-     __pos = this->_M_impl._M_start + __index;
-     iterator __pos1 = __pos;
-     ++__pos1;
-     std::move(__front2, __pos1, __front1);
-   }
- else
-   {
-     push_back(std::move(back()));
-     iterator __back1 = this->_M_impl._M_finish;
-     --__back1;
-     iterator __back2 = __back1;
-     --__back2;
-     __pos = this->_M_impl._M_start + __index;
-     std::move_backward(__pos, __back2, __back1);
-   }
- *__pos = std::move(__x_copy);
- return __pos;
-      }
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
-    {
-      const difference_type __elems_before = __pos - this->_M_impl._M_start;
-      const size_type __length = this->size();
-      value_type __x_copy = __x;
-      if (__elems_before < difference_type(__length / 2))
- {
-   iterator __new_start = _M_reserve_elements_at_front(__n);
-   iterator __old_start = this->_M_impl._M_start;
-   __pos = this->_M_impl._M_start + __elems_before;
-   try
-     {
-       if (__elems_before >= difference_type(__n))
-  {
-    iterator __start_n = (this->_M_impl._M_start
-     + difference_type(__n));
-    std::__uninitialized_move_a(this->_M_impl._M_start,
-           __start_n, __new_start,
-           _M_get_Tp_allocator());
-    this->_M_impl._M_start = __new_start;
-    std::move(__start_n, __pos, __old_start);
-    std::fill(__pos - difference_type(__n), __pos, __x_copy);
-  }
-       else
-  {
-    std::__uninitialized_move_fill(this->_M_impl._M_start,
-       __pos, __new_start,
-       this->_M_impl._M_start,
-       __x_copy,
-       _M_get_Tp_allocator());
-    this->_M_impl._M_start = __new_start;
-    std::fill(__old_start, __pos, __x_copy);
-  }
-     }
-   catch(...)
-     {
-       _M_destroy_nodes(__new_start._M_node,
-          this->_M_impl._M_start._M_node);
-       throw;
-     }
- }
-      else
- {
-   iterator __new_finish = _M_reserve_elements_at_back(__n);
-   iterator __old_finish = this->_M_impl._M_finish;
-   const difference_type __elems_after =
-     difference_type(__length) - __elems_before;
-   __pos = this->_M_impl._M_finish - __elems_after;
-   try
-     {
-       if (__elems_after > difference_type(__n))
-  {
-    iterator __finish_n = (this->_M_impl._M_finish
-      - difference_type(__n));
-    std::__uninitialized_move_a(__finish_n,
-           this->_M_impl._M_finish,
-           this->_M_impl._M_finish,
-           _M_get_Tp_allocator());
-    this->_M_impl._M_finish = __new_finish;
-    std::move_backward(__pos, __finish_n, __old_finish);
-    std::fill(__pos, __pos + difference_type(__n), __x_copy);
-  }
-       else
-  {
-    std::__uninitialized_fill_move(this->_M_impl._M_finish,
-       __pos + difference_type(__n),
-       __x_copy, __pos,
-       this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-    this->_M_impl._M_finish = __new_finish;
-    std::fill(__pos, __old_finish, __x_copy);
-  }
-     }
-   catch(...)
-     {
-       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
-          __new_finish._M_node + 1);
-       throw;
-     }
- }
-    }
-
-  template <typename _Tp, typename _Alloc>
-    template <typename _ForwardIterator>
-      void
-      deque<_Tp, _Alloc>::
-      _M_insert_aux(iterator __pos,
-                    _ForwardIterator __first, _ForwardIterator __last,
-                    size_type __n)
-      {
-        const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
-        const size_type __length = size();
-        if (static_cast<size_type>(__elemsbefore) < __length / 2)
-   {
-     iterator __new_start = _M_reserve_elements_at_front(__n);
-     iterator __old_start = this->_M_impl._M_start;
-     __pos = this->_M_impl._M_start + __elemsbefore;
-     try
-       {
-  if (__elemsbefore >= difference_type(__n))
-    {
-      iterator __start_n = (this->_M_impl._M_start
-       + difference_type(__n));
-      std::__uninitialized_move_a(this->_M_impl._M_start,
-      __start_n, __new_start,
-      _M_get_Tp_allocator());
-      this->_M_impl._M_start = __new_start;
-      std::move(__start_n, __pos, __old_start);
-      std::copy(__first, __last, __pos - difference_type(__n));
-    }
-  else
-    {
-      _ForwardIterator __mid = __first;
-      std::advance(__mid, difference_type(__n) - __elemsbefore);
-      std::__uninitialized_move_copy(this->_M_impl._M_start,
-         __pos, __first, __mid,
-         __new_start,
-         _M_get_Tp_allocator());
-      this->_M_impl._M_start = __new_start;
-      std::copy(__mid, __last, __old_start);
-    }
-       }
-     catch(...)
-       {
-  _M_destroy_nodes(__new_start._M_node,
-     this->_M_impl._M_start._M_node);
-  throw;
-       }
-   }
-        else
-        {
-          iterator __new_finish = _M_reserve_elements_at_back(__n);
-          iterator __old_finish = this->_M_impl._M_finish;
-          const difference_type __elemsafter =
-            difference_type(__length) - __elemsbefore;
-          __pos = this->_M_impl._M_finish - __elemsafter;
-          try
-            {
-              if (__elemsafter > difference_type(__n))
-  {
-    iterator __finish_n = (this->_M_impl._M_finish
-      - difference_type(__n));
-    std::__uninitialized_move_a(__finish_n,
-           this->_M_impl._M_finish,
-           this->_M_impl._M_finish,
-           _M_get_Tp_allocator());
-    this->_M_impl._M_finish = __new_finish;
-    std::move_backward(__pos, __finish_n, __old_finish);
-    std::copy(__first, __last, __pos);
-  }
-              else
-  {
-    _ForwardIterator __mid = __first;
-    std::advance(__mid, __elemsafter);
-    std::__uninitialized_copy_move(__mid, __last, __pos,
-       this->_M_impl._M_finish,
-       this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-    this->_M_impl._M_finish = __new_finish;
-    std::copy(__first, __mid, __pos);
-  }
-            }
-          catch(...)
-            {
-              _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
-          __new_finish._M_node + 1);
-              throw;
-            }
-        }
-      }
-
-   template<typename _Tp, typename _Alloc>
-     void
-     deque<_Tp, _Alloc>::
-     _M_destroy_data_aux(iterator __first, iterator __last)
-     {
-       for (_Map_pointer __node = __first._M_node + 1;
-     __node < __last._M_node; ++__node)
-  std::_Destroy(*__node, *__node + _S_buffer_size(),
-         _M_get_Tp_allocator());
-
-       if (__first._M_node != __last._M_node)
-  {
-    std::_Destroy(__first._M_cur, __first._M_last,
-    _M_get_Tp_allocator());
-    std::_Destroy(__last._M_first, __last._M_cur,
-    _M_get_Tp_allocator());
-  }
-       else
-  std::_Destroy(__first._M_cur, __last._M_cur,
-         _M_get_Tp_allocator());
-     }
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_new_elements_at_front(size_type __new_elems)
-    {
-      if (this->max_size() - this->size() < __new_elems)
- __throw_length_error(("deque::_M_new_elements_at_front"));
-
-      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
-         / _S_buffer_size());
-      _M_reserve_map_at_front(__new_nodes);
-      size_type __i;
-      try
-        {
-          for (__i = 1; __i <= __new_nodes; ++__i)
-            *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
-        }
-      catch(...)
-        {
-          for (size_type __j = 1; __j < __i; ++__j)
-            _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
-          throw;
-        }
-    }
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_new_elements_at_back(size_type __new_elems)
-    {
-      if (this->max_size() - this->size() < __new_elems)
- __throw_length_error(("deque::_M_new_elements_at_back"));
-
-      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
-         / _S_buffer_size());
-      _M_reserve_map_at_back(__new_nodes);
-      size_type __i;
-      try
-        {
-          for (__i = 1; __i <= __new_nodes; ++__i)
-            *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
-        }
-      catch(...)
-        {
-          for (size_type __j = 1; __j < __i; ++__j)
-            _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
-          throw;
-        }
-    }
-
-  template <typename _Tp, typename _Alloc>
-    void
-    deque<_Tp, _Alloc>::
-    _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
-    {
-      const size_type __old_num_nodes
- = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
-      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
-
-      _Map_pointer __new_nstart;
-      if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
- {
-   __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
-      - __new_num_nodes) / 2
-                  + (__add_at_front ? __nodes_to_add : 0);
-   if (__new_nstart < this->_M_impl._M_start._M_node)
-     std::copy(this->_M_impl._M_start._M_node,
-        this->_M_impl._M_finish._M_node + 1,
-        __new_nstart);
-   else
-     std::copy_backward(this->_M_impl._M_start._M_node,
-          this->_M_impl._M_finish._M_node + 1,
-          __new_nstart + __old_num_nodes);
- }
-      else
- {
-   size_type __new_map_size = this->_M_impl._M_map_size
-                              + std::max(this->_M_impl._M_map_size,
-      __nodes_to_add) + 2;
-
-   _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
-   __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
-                  + (__add_at_front ? __nodes_to_add : 0);
-   std::copy(this->_M_impl._M_start._M_node,
-      this->_M_impl._M_finish._M_node + 1,
-      __new_nstart);
-   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
-
-   this->_M_impl._M_map = __new_map;
-   this->_M_impl._M_map_size = __new_map_size;
- }
-
-      this->_M_impl._M_start._M_set_node(__new_nstart);
-      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
-    }
-
-
-
-  template<typename _Tp>
-    void
-    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
-  const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
-    {
-      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
-
-      for (typename _Self::_Map_pointer __node = __first._M_node + 1;
-           __node < __last._M_node; ++__node)
- std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
-
-      if (__first._M_node != __last._M_node)
- {
-   std::fill(__first._M_cur, __first._M_last, __value);
-   std::fill(__last._M_first, __last._M_cur, __value);
- }
-      else
- std::fill(__first._M_cur, __last._M_cur, __value);
-    }
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
-  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    {
-      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
-      typedef typename _Self::difference_type difference_type;
-
-      difference_type __len = __last - __first;
-      while (__len > 0)
- {
-   const difference_type __clen
-     = std::min(__len, std::min(__first._M_last - __first._M_cur,
-           __result._M_last - __result._M_cur));
-   std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
-   __first += __clen;
-   __result += __clen;
-   __len -= __clen;
- }
-      return __result;
-    }
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
-    _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    {
-      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
-      typedef typename _Self::difference_type difference_type;
-
-      difference_type __len = __last - __first;
-      while (__len > 0)
- {
-   difference_type __llen = __last._M_cur - __last._M_first;
-   _Tp* __lend = __last._M_cur;
-
-   difference_type __rlen = __result._M_cur - __result._M_first;
-   _Tp* __rend = __result._M_cur;
-
-   if (!__llen)
-     {
-       __llen = _Self::_S_buffer_size();
-       __lend = *(__last._M_node - 1) + __llen;
-     }
-   if (!__rlen)
-     {
-       __rlen = _Self::_S_buffer_size();
-       __rend = *(__result._M_node - 1) + __rlen;
-     }
-
-   const difference_type __clen = std::min(__len,
-        std::min(__llen, __rlen));
-   std::copy_backward(__lend - __clen, __lend, __rend);
-   __last -= __clen;
-   __result -= __clen;
-   __len -= __clen;
- }
-      return __result;
-    }
-
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
-  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
-  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    {
-      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
-      typedef typename _Self::difference_type difference_type;
-
-      difference_type __len = __last - __first;
-      while (__len > 0)
- {
-   const difference_type __clen
-     = std::min(__len, std::min(__first._M_last - __first._M_cur,
-           __result._M_last - __result._M_cur));
-   std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
-   __first += __clen;
-   __result += __clen;
-   __len -= __clen;
- }
-      return __result;
-    }
-
-  template<typename _Tp>
-    _Deque_iterator<_Tp, _Tp&, _Tp*>
-    move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
-    _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
-    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
-    {
-      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
-      typedef typename _Self::difference_type difference_type;
-
-      difference_type __len = __last - __first;
-      while (__len > 0)
- {
-   difference_type __llen = __last._M_cur - __last._M_first;
-   _Tp* __lend = __last._M_cur;
-
-   difference_type __rlen = __result._M_cur - __result._M_first;
-   _Tp* __rend = __result._M_cur;
-
-   if (!__llen)
-     {
-       __llen = _Self::_S_buffer_size();
-       __lend = *(__last._M_node - 1) + __llen;
-     }
-   if (!__rlen)
-     {
-       __rlen = _Self::_S_buffer_size();
-       __rend = *(__result._M_node - 1) + __rlen;
-     }
-
-   const difference_type __clen = std::min(__len,
-        std::min(__llen, __rlen));
-   std::move_backward(__lend - __clen, __lend, __rend);
-   __last -= __clen;
-   __result -= __clen;
-   __len -= __clen;
- }
-      return __result;
-    }
-
-
-
-}
-# 67 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/deque" 2 3
-# 61 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 3
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 1 3
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _Tp, typename _Alloc>
-    struct _Vector_base
-    {
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
-        rebind<_Tp>::other _Tp_alloc_type;
-      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
-        pointer;
-
-      struct _Vector_impl
-      : public _Tp_alloc_type
-      {
- pointer _M_start;
- pointer _M_finish;
- pointer _M_end_of_storage;
-
- _Vector_impl()
- : _Tp_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
- { }
-
- _Vector_impl(_Tp_alloc_type const& __a) noexcept
- : _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
- { }
-
-
- _Vector_impl(_Tp_alloc_type&& __a) noexcept
- : _Tp_alloc_type(std::move(__a)),
-   _M_start(), _M_finish(), _M_end_of_storage()
- { }
-
-
- void _M_swap_data(_Vector_impl& __x) noexcept
- {
-   std::swap(_M_start, __x._M_start);
-   std::swap(_M_finish, __x._M_finish);
-   std::swap(_M_end_of_storage, __x._M_end_of_storage);
- }
-      };
-
-    public:
-      typedef _Alloc allocator_type;
-
-      _Tp_alloc_type&
-      _M_get_Tp_allocator() noexcept
-      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
-
-      const _Tp_alloc_type&
-      _M_get_Tp_allocator() const noexcept
-      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_get_Tp_allocator()); }
-
-      _Vector_base()
-      : _M_impl() { }
-
-      _Vector_base(const allocator_type& __a) noexcept
-      : _M_impl(__a) { }
-
-      _Vector_base(size_t __n)
-      : _M_impl()
-      { _M_create_storage(__n); }
-
-      _Vector_base(size_t __n, const allocator_type& __a)
-      : _M_impl(__a)
-      { _M_create_storage(__n); }
-
-
-      _Vector_base(_Tp_alloc_type&& __a) noexcept
-      : _M_impl(std::move(__a)) { }
-
-      _Vector_base(_Vector_base&& __x) noexcept
-      : _M_impl(std::move(__x._M_get_Tp_allocator()))
-      { this->_M_impl._M_swap_data(__x._M_impl); }
-
-      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
-      : _M_impl(__a)
-      {
- if (__x.get_allocator() == __a)
-   this->_M_impl._M_swap_data(__x._M_impl);
- else
-   {
-     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
-     _M_create_storage(__n);
-   }
-      }
-
-
-      ~_Vector_base() noexcept
-      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
-        - this->_M_impl._M_start); }
-
-    public:
-      _Vector_impl _M_impl;
-
-      pointer
-      _M_allocate(size_t __n)
-      {
- typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
- return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
-      }
-
-      void
-      _M_deallocate(pointer __p, size_t __n)
-      {
- typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
- if (__p)
-   _Tr::deallocate(_M_impl, __p, __n);
-      }
-
-    private:
-      void
-      _M_create_storage(size_t __n)
-      {
- this->_M_impl._M_start = this->_M_allocate(__n);
- this->_M_impl._M_finish = this->_M_impl._M_start;
- this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
-      }
-    };
-# 213 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
-    class vector : protected _Vector_base<_Tp, _Alloc>
-    {
-
-      typedef typename _Alloc::value_type _Alloc_value_type;
-
-
-
-
-
-      typedef _Vector_base<_Tp, _Alloc> _Base;
-      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
-      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
-
-    public:
-      typedef _Tp value_type;
-      typedef typename _Base::pointer pointer;
-      typedef typename _Alloc_traits::const_pointer const_pointer;
-      typedef typename _Alloc_traits::reference reference;
-      typedef typename _Alloc_traits::const_reference const_reference;
-      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
-      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
-      const_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Alloc allocator_type;
-
-    protected:
-      using _Base::_M_allocate;
-      using _Base::_M_deallocate;
-      using _Base::_M_impl;
-      using _Base::_M_get_Tp_allocator;
-
-    public:
-
-
-
-
-
-
-      vector()
-
-      noexcept(is_nothrow_default_constructible<_Alloc>::value)
-
-      : _Base() { }
-
-
-
-
-
-      explicit
-      vector(const allocator_type& __a) noexcept
-      : _Base(__a) { }
-# 278 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      explicit
-      vector(size_type __n, const allocator_type& __a = allocator_type())
-      : _Base(__n, __a)
-      { _M_default_initialize(__n); }
-# 291 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector(size_type __n, const value_type& __value,
-      const allocator_type& __a = allocator_type())
-      : _Base(__n, __a)
-      { _M_fill_initialize(__n, __value); }
-# 320 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector(const vector& __x)
-      : _Base(__x.size(),
-        _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
-      { this->_M_impl._M_finish =
-   std::__uninitialized_copy_a(__x.begin(), __x.end(),
-          this->_M_impl._M_start,
-          _M_get_Tp_allocator());
-      }
-# 337 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector(vector&& __x) noexcept
-      : _Base(std::move(__x)) { }
-
-
-      vector(const vector& __x, const allocator_type& __a)
-      : _Base(__x.size(), __a)
-      { this->_M_impl._M_finish =
-   std::__uninitialized_copy_a(__x.begin(), __x.end(),
-          this->_M_impl._M_start,
-          _M_get_Tp_allocator());
-      }
-
-
-      vector(vector&& __rv, const allocator_type& __m)
-      noexcept(_Alloc_traits::_S_always_equal())
-      : _Base(std::move(__rv), __m)
-      {
- if (__rv.get_allocator() != __m)
-   {
-     this->_M_impl._M_finish =
-       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
-       this->_M_impl._M_start,
-       _M_get_Tp_allocator());
-     __rv.clear();
-   }
-      }
-# 375 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector(initializer_list<value_type> __l,
-      const allocator_type& __a = allocator_type())
-      : _Base(__a)
-      {
- _M_range_initialize(__l.begin(), __l.end(),
-       random_access_iterator_tag());
-      }
-# 401 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        vector(_InputIterator __first, _InputIterator __last,
-        const allocator_type& __a = allocator_type())
- : _Base(__a)
-        { _M_initialize_dispatch(__first, __last, __false_type()); }
-# 425 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      ~vector() noexcept
-      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-        _M_get_Tp_allocator()); }
-# 437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector&
-      operator=(const vector& __x);
-# 449 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector&
-      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
-      {
-        constexpr bool __move_storage =
-          _Alloc_traits::_S_propagate_on_move_assign()
-          || _Alloc_traits::_S_always_equal();
-        _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
- return *this;
-      }
-# 470 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      vector&
-      operator=(initializer_list<value_type> __l)
-      {
- this->assign(__l.begin(), __l.end());
- return *this;
-      }
-# 488 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      assign(size_type __n, const value_type& __val)
-      { _M_fill_assign(__n, __val); }
-# 505 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        void
-        assign(_InputIterator __first, _InputIterator __last)
-        { _M_assign_dispatch(__first, __last, __false_type()); }
-# 533 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      assign(initializer_list<value_type> __l)
-      { this->assign(__l.begin(), __l.end()); }
-
-
-
-      using _Base::get_allocator;
-
-
-
-
-
-
-
-      iterator
-      begin() noexcept
-      { return iterator(this->_M_impl._M_start); }
-
-
-
-
-
-
-      const_iterator
-      begin() const noexcept
-      { return const_iterator(this->_M_impl._M_start); }
-
-
-
-
-
-
-      iterator
-      end() noexcept
-      { return iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      const_iterator
-      end() const noexcept
-      { return const_iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      reverse_iterator
-      rbegin() noexcept
-      { return reverse_iterator(end()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-
-
-
-
-
-      reverse_iterator
-      rend() noexcept
-      { return reverse_iterator(begin()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      rend() const noexcept
-      { return const_reverse_iterator(begin()); }
-
-
-
-
-
-
-
-      const_iterator
-      cbegin() const noexcept
-      { return const_iterator(this->_M_impl._M_start); }
-
-
-
-
-
-
-      const_iterator
-      cend() const noexcept
-      { return const_iterator(this->_M_impl._M_finish); }
-
-
-
-
-
-
-      const_reverse_iterator
-      crbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-
-
-
-
-
-      const_reverse_iterator
-      crend() const noexcept
-      { return const_reverse_iterator(begin()); }
-
-
-
-
-      size_type
-      size() const noexcept
-      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
-
-
-      size_type
-      max_size() const noexcept
-      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
-# 673 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      resize(size_type __new_size)
-      {
- if (__new_size > size())
-   _M_default_append(__new_size - size());
- else if (__new_size < size())
-   _M_erase_at_end(this->_M_impl._M_start + __new_size);
-      }
-# 693 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      resize(size_type __new_size, const value_type& __x)
-      {
- if (__new_size > size())
-   insert(end(), __new_size - size(), __x);
- else if (__new_size < size())
-   _M_erase_at_end(this->_M_impl._M_start + __new_size);
-      }
-# 725 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      shrink_to_fit()
-      { _M_shrink_to_fit(); }
-
-
-
-
-
-
-      size_type
-      capacity() const noexcept
-      { return size_type(this->_M_impl._M_end_of_storage
-    - this->_M_impl._M_start); }
-
-
-
-
-
-      bool
-      empty() const noexcept
-      { return begin() == end(); }
-# 764 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      reserve(size_type __n);
-# 779 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      reference
-      operator[](size_type __n) noexcept
-      { return *(this->_M_impl._M_start + __n); }
-# 794 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      const_reference
-      operator[](size_type __n) const noexcept
-      { return *(this->_M_impl._M_start + __n); }
-
-    protected:
-
-      void
-      _M_range_check(size_type __n) const
-      {
- if (__n >= this->size())
-   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
-
-
-       __n, this->size());
-      }
-
-    public:
-# 822 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      reference
-      at(size_type __n)
-      {
- _M_range_check(__n);
- return (*this)[__n];
-      }
-# 840 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      const_reference
-      at(size_type __n) const
-      {
- _M_range_check(__n);
- return (*this)[__n];
-      }
-
-
-
-
-
-      reference
-      front() noexcept
-      { return *begin(); }
-
-
-
-
-
-      const_reference
-      front() const noexcept
-      { return *begin(); }
-
-
-
-
-
-      reference
-      back() noexcept
-      { return *(end() - 1); }
-
-
-
-
-
-      const_reference
-      back() const noexcept
-      { return *(end() - 1); }
-# 887 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      _Tp*
-
-
-
-      data() noexcept
-      { return _M_data_ptr(this->_M_impl._M_start); }
-
-
-      const _Tp*
-
-
-
-      data() const noexcept
-      { return _M_data_ptr(this->_M_impl._M_start); }
-# 913 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      push_back(const value_type& __x)
-      {
- if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
-   {
-     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
-                              __x);
-     ++this->_M_impl._M_finish;
-   }
- else
-
-   _M_emplace_back_aux(__x);
-
-
-
-      }
-
-
-      void
-      push_back(value_type&& __x)
-      { emplace_back(std::move(__x)); }
-
-      template<typename... _Args>
-        void
-        emplace_back(_Args&&... __args);
-# 949 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      pop_back() noexcept
-      {
- --this->_M_impl._M_finish;
- _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
-      }
-# 969 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename... _Args>
-        iterator
-        emplace(const_iterator __position, _Args&&... __args);
-# 984 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-      insert(const_iterator __position, const value_type& __x);
-# 1014 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-      insert(const_iterator __position, value_type&& __x)
-      { return emplace(__position, std::move(__x)); }
-# 1031 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-      insert(const_iterator __position, initializer_list<value_type> __l)
-      { return this->insert(__position, __l.begin(), __l.end()); }
-# 1051 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-      insert(const_iterator __position, size_type __n, const value_type& __x)
-      {
- difference_type __offset = __position - cbegin();
- _M_fill_insert(begin() + __offset, __n, __x);
- return begin() + __offset;
-      }
-# 1093 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _InputIterator,
-        typename = std::_RequireInputIter<_InputIterator>>
-        iterator
-        insert(const_iterator __position, _InputIterator __first,
-        _InputIterator __last)
-        {
-   difference_type __offset = __position - cbegin();
-   _M_insert_dispatch(begin() + __offset,
-        __first, __last, __false_type());
-   return begin() + __offset;
- }
-# 1145 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-
-      erase(const_iterator __position)
-      { return _M_erase(begin() + (__position - cbegin())); }
-# 1172 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      iterator
-
-      erase(const_iterator __first, const_iterator __last)
-      {
- const auto __beg = begin();
- const auto __cbeg = cbegin();
- return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
-      }
-# 1194 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      void
-      swap(vector& __x) noexcept
-      {
- this->_M_impl._M_swap_data(__x._M_impl);
- _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
-                           __x._M_get_Tp_allocator());
-      }
-
-
-
-
-
-
-
-      void
-      clear() noexcept
-      { _M_erase_at_end(this->_M_impl._M_start); }
-
-    protected:
-
-
-
-
-      template<typename _ForwardIterator>
-        pointer
-        _M_allocate_and_copy(size_type __n,
-        _ForwardIterator __first, _ForwardIterator __last)
-        {
-   pointer __result = this->_M_allocate(__n);
-   try
-     {
-       std::__uninitialized_copy_a(__first, __last, __result,
-       _M_get_Tp_allocator());
-       return __result;
-     }
-   catch(...)
-     {
-       _M_deallocate(__result, __n);
-       throw;
-     }
- }
-# 1243 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _Integer>
-        void
-        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
-        {
-   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
-   this->_M_impl._M_end_of_storage =
-     this->_M_impl._M_start + static_cast<size_type>(__n);
-   _M_fill_initialize(static_cast<size_type>(__n), __value);
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
-          __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-   _M_range_initialize(__first, __last, _IterCategory());
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_range_initialize(_InputIterator __first,
-       _InputIterator __last, std::input_iterator_tag)
-        {
-   for (; __first != __last; ++__first)
-
-     emplace_back(*__first);
-
-
-
- }
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_range_initialize(_ForwardIterator __first,
-       _ForwardIterator __last, std::forward_iterator_tag)
-        {
-   const size_type __n = std::distance(__first, __last);
-   this->_M_impl._M_start = this->_M_allocate(__n);
-   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
-   this->_M_impl._M_finish =
-     std::__uninitialized_copy_a(__first, __last,
-     this->_M_impl._M_start,
-     _M_get_Tp_allocator());
- }
-
-
-
-      void
-      _M_fill_initialize(size_type __n, const value_type& __value)
-      {
- this->_M_impl._M_finish =
-   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
-     _M_get_Tp_allocator());
-      }
-
-
-
-      void
-      _M_default_initialize(size_type __n)
-      {
- this->_M_impl._M_finish =
-   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
-        _M_get_Tp_allocator());
-      }
-# 1321 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _Integer>
-        void
-        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
-        { _M_fill_assign(__n, __val); }
-
-
-      template<typename _InputIterator>
-        void
-        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
-      __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-   _M_assign_aux(__first, __last, _IterCategory());
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_assign_aux(_InputIterator __first, _InputIterator __last,
-        std::input_iterator_tag);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
-        std::forward_iterator_tag);
-
-
-
-      void
-      _M_fill_assign(size_type __n, const value_type& __val);
-# 1361 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-      template<typename _Integer>
-        void
-        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
-      __true_type)
-        { _M_fill_insert(__pos, __n, __val); }
-
-
-      template<typename _InputIterator>
-        void
-        _M_insert_dispatch(iterator __pos, _InputIterator __first,
-      _InputIterator __last, __false_type)
-        {
-   typedef typename std::iterator_traits<_InputIterator>::
-     iterator_category _IterCategory;
-   _M_range_insert(__pos, __first, __last, _IterCategory());
- }
-
-
-      template<typename _InputIterator>
-        void
-        _M_range_insert(iterator __pos, _InputIterator __first,
-   _InputIterator __last, std::input_iterator_tag);
-
-
-      template<typename _ForwardIterator>
-        void
-        _M_range_insert(iterator __pos, _ForwardIterator __first,
-   _ForwardIterator __last, std::forward_iterator_tag);
-
-
-
-      void
-      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
-
-
-
-      void
-      _M_default_append(size_type __n);
-
-      bool
-      _M_shrink_to_fit();
-
-
-
-
-
-
-
-      template<typename... _Args>
-        void
-        _M_insert_aux(iterator __position, _Args&&... __args);
-
-      template<typename... _Args>
-        void
-        _M_emplace_back_aux(_Args&&... __args);
-
-
-
-      size_type
-      _M_check_len(size_type __n, const char* __s) const
-      {
- if (max_size() - size() < __n)
-   __throw_length_error((__s));
-
- const size_type __len = size() + std::max(size(), __n);
- return (__len < size() || __len > max_size()) ? max_size() : __len;
-      }
-
-
-
-
-
-      void
-      _M_erase_at_end(pointer __pos) noexcept
-      {
- std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
- this->_M_impl._M_finish = __pos;
-      }
-
-      iterator
-      _M_erase(iterator __position);
-
-      iterator
-      _M_erase(iterator __first, iterator __last);
-
-
-    private:
-
-
-
-      void
-      _M_move_assign(vector&& __x, std::true_type) noexcept
-      {
- vector __tmp(get_allocator());
- this->_M_impl._M_swap_data(__tmp._M_impl);
- this->_M_impl._M_swap_data(__x._M_impl);
- std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
-      }
-
-
-
-      void
-      _M_move_assign(vector&& __x, std::false_type)
-      {
- if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
-   _M_move_assign(std::move(__x), std::true_type());
- else
-   {
-
-
-     this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
-    std::__make_move_if_noexcept_iterator(__x.end()));
-     __x.clear();
-   }
-      }
-
-
-
-      template<typename _Up>
- _Up*
- _M_data_ptr(_Up* __ptr) const
- { return __ptr; }
-
-      template<typename _Ptr>
- typename std::pointer_traits<_Ptr>::element_type*
- _M_data_ptr(_Ptr __ptr) const
- { return empty() ? nullptr : std::__addressof(*__ptr); }
-
-
-
-
-
-
-    };
-# 1507 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return (__x.size() == __y.size()
-       && std::equal(__x.begin(), __x.end(), __y.begin())); }
-# 1524 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_vector.h" 3
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return std::lexicographical_compare(__x.begin(), __x.end(),
-       __y.begin(), __y.end()); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return __y < __x; }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline bool
-    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _Tp, typename _Alloc>
-    inline void
-    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-}
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 1 3
-# 63 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  typedef unsigned long _Bit_type;
-  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
-
-  struct _Bit_reference
-  {
-    _Bit_type * _M_p;
-    _Bit_type _M_mask;
-
-    _Bit_reference(_Bit_type * __x, _Bit_type __y)
-    : _M_p(__x), _M_mask(__y) { }
-
-    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
-
-    operator bool() const noexcept
-    { return !!(*_M_p & _M_mask); }
-
-    _Bit_reference&
-    operator=(bool __x) noexcept
-    {
-      if (__x)
- *_M_p |= _M_mask;
-      else
- *_M_p &= ~_M_mask;
-      return *this;
-    }
-
-    _Bit_reference&
-    operator=(const _Bit_reference& __x) noexcept
-    { return *this = bool(__x); }
-
-    bool
-    operator==(const _Bit_reference& __x) const
-    { return bool(*this) == bool(__x); }
-
-    bool
-    operator<(const _Bit_reference& __x) const
-    { return !bool(*this) && bool(__x); }
-
-    void
-    flip() noexcept
-    { *_M_p ^= _M_mask; }
-  };
-
-
-  inline void
-  swap(_Bit_reference __x, _Bit_reference __y) noexcept
-  {
-    bool __tmp = __x;
-    __x = __y;
-    __y = __tmp;
-  }
-
-  inline void
-  swap(_Bit_reference __x, bool& __y) noexcept
-  {
-    bool __tmp = __x;
-    __x = __y;
-    __y = __tmp;
-  }
-
-  inline void
-  swap(bool& __x, _Bit_reference __y) noexcept
-  {
-    bool __tmp = __x;
-    __x = __y;
-    __y = __tmp;
-  }
-
-
-  struct _Bit_iterator_base
-  : public std::iterator<std::random_access_iterator_tag, bool>
-  {
-    _Bit_type * _M_p;
-    unsigned int _M_offset;
-
-    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
-    : _M_p(__x), _M_offset(__y) { }
-
-    void
-    _M_bump_up()
-    {
-      if (_M_offset++ == int(_S_word_bit) - 1)
- {
-   _M_offset = 0;
-   ++_M_p;
- }
-    }
-
-    void
-    _M_bump_down()
-    {
-      if (_M_offset-- == 0)
- {
-   _M_offset = int(_S_word_bit) - 1;
-   --_M_p;
- }
-    }
-
-    void
-    _M_incr(ptrdiff_t __i)
-    {
-      difference_type __n = __i + _M_offset;
-      _M_p += __n / int(_S_word_bit);
-      __n = __n % int(_S_word_bit);
-      if (__n < 0)
- {
-   __n += int(_S_word_bit);
-   --_M_p;
- }
-      _M_offset = static_cast<unsigned int>(__n);
-    }
-
-    bool
-    operator==(const _Bit_iterator_base& __i) const
-    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
-
-    bool
-    operator<(const _Bit_iterator_base& __i) const
-    {
-      return _M_p < __i._M_p
-      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
-    }
-
-    bool
-    operator!=(const _Bit_iterator_base& __i) const
-    { return !(*this == __i); }
-
-    bool
-    operator>(const _Bit_iterator_base& __i) const
-    { return __i < *this; }
-
-    bool
-    operator<=(const _Bit_iterator_base& __i) const
-    { return !(__i < *this); }
-
-    bool
-    operator>=(const _Bit_iterator_base& __i) const
-    { return !(*this < __i); }
-  };
-
-  inline ptrdiff_t
-  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
-  {
-    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
-     + __x._M_offset - __y._M_offset);
-  }
-
-  struct _Bit_iterator : public _Bit_iterator_base
-  {
-    typedef _Bit_reference reference;
-    typedef _Bit_reference* pointer;
-    typedef _Bit_iterator iterator;
-
-    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
-
-    _Bit_iterator(_Bit_type * __x, unsigned int __y)
-    : _Bit_iterator_base(__x, __y) { }
-
-    iterator
-    _M_const_cast() const
-    { return *this; }
-
-    reference
-    operator*() const
-    { return reference(_M_p, 1UL << _M_offset); }
-
-    iterator&
-    operator++()
-    {
-      _M_bump_up();
-      return *this;
-    }
-
-    iterator
-    operator++(int)
-    {
-      iterator __tmp = *this;
-      _M_bump_up();
-      return __tmp;
-    }
-
-    iterator&
-    operator--()
-    {
-      _M_bump_down();
-      return *this;
-    }
-
-    iterator
-    operator--(int)
-    {
-      iterator __tmp = *this;
-      _M_bump_down();
-      return __tmp;
-    }
-
-    iterator&
-    operator+=(difference_type __i)
-    {
-      _M_incr(__i);
-      return *this;
-    }
-
-    iterator&
-    operator-=(difference_type __i)
-    {
-      *this += -__i;
-      return *this;
-    }
-
-    iterator
-    operator+(difference_type __i) const
-    {
-      iterator __tmp = *this;
-      return __tmp += __i;
-    }
-
-    iterator
-    operator-(difference_type __i) const
-    {
-      iterator __tmp = *this;
-      return __tmp -= __i;
-    }
-
-    reference
-    operator[](difference_type __i) const
-    { return *(*this + __i); }
-  };
-
-  inline _Bit_iterator
-  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
-  { return __x + __n; }
-
-  struct _Bit_const_iterator : public _Bit_iterator_base
-  {
-    typedef bool reference;
-    typedef bool const_reference;
-    typedef const bool* pointer;
-    typedef _Bit_const_iterator const_iterator;
-
-    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
-
-    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
-    : _Bit_iterator_base(__x, __y) { }
-
-    _Bit_const_iterator(const _Bit_iterator& __x)
-    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
-
-    _Bit_iterator
-    _M_const_cast() const
-    { return _Bit_iterator(_M_p, _M_offset); }
-
-    const_reference
-    operator*() const
-    { return _Bit_reference(_M_p, 1UL << _M_offset); }
-
-    const_iterator&
-    operator++()
-    {
-      _M_bump_up();
-      return *this;
-    }
-
-    const_iterator
-    operator++(int)
-    {
-      const_iterator __tmp = *this;
-      _M_bump_up();
-      return __tmp;
-    }
-
-    const_iterator&
-    operator--()
-    {
-      _M_bump_down();
-      return *this;
-    }
-
-    const_iterator
-    operator--(int)
-    {
-      const_iterator __tmp = *this;
-      _M_bump_down();
-      return __tmp;
-    }
-
-    const_iterator&
-    operator+=(difference_type __i)
-    {
-      _M_incr(__i);
-      return *this;
-    }
-
-    const_iterator&
-    operator-=(difference_type __i)
-    {
-      *this += -__i;
-      return *this;
-    }
-
-    const_iterator
-    operator+(difference_type __i) const
-    {
-      const_iterator __tmp = *this;
-      return __tmp += __i;
-    }
-
-    const_iterator
-    operator-(difference_type __i) const
-    {
-      const_iterator __tmp = *this;
-      return __tmp -= __i;
-    }
-
-    const_reference
-    operator[](difference_type __i) const
-    { return *(*this + __i); }
-  };
-
-  inline _Bit_const_iterator
-  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
-  { return __x + __n; }
-
-  inline void
-  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
-  {
-    for (; __first != __last; ++__first)
-      *__first = __x;
-  }
-
-  inline void
-  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
-  {
-    if (__first._M_p != __last._M_p)
-      {
- std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
- __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
- __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
-      }
-    else
-      __fill_bvector(__first, __last, __x);
-  }
-
-  template<typename _Alloc>
-    struct _Bvector_base
-    {
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
-        rebind<_Bit_type>::other _Bit_alloc_type;
-      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
- _Bit_alloc_traits;
-      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
-
-      struct _Bvector_impl
-      : public _Bit_alloc_type
-      {
- _Bit_iterator _M_start;
- _Bit_iterator _M_finish;
- _Bit_pointer _M_end_of_storage;
-
- _Bvector_impl()
- : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
- { }
-
- _Bvector_impl(const _Bit_alloc_type& __a)
- : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
- { }
-
-
- _Bvector_impl(_Bit_alloc_type&& __a)
- : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
-   _M_end_of_storage()
- { }
-
-
- _Bit_type*
- _M_end_addr() const noexcept
- {
-   if (_M_end_of_storage)
-     return std::__addressof(_M_end_of_storage[-1]) + 1;
-   return 0;
- }
-      };
-
-    public:
-      typedef _Alloc allocator_type;
-
-      _Bit_alloc_type&
-      _M_get_Bit_allocator() noexcept
-      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
-
-      const _Bit_alloc_type&
-      _M_get_Bit_allocator() const noexcept
-      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_get_Bit_allocator()); }
-
-      _Bvector_base()
-      : _M_impl() { }
-
-      _Bvector_base(const allocator_type& __a)
-      : _M_impl(__a) { }
-
-
-      _Bvector_base(_Bvector_base&& __x) noexcept
-      : _M_impl(std::move(__x._M_get_Bit_allocator()))
-      {
- this->_M_impl._M_start = __x._M_impl._M_start;
- this->_M_impl._M_finish = __x._M_impl._M_finish;
- this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
- __x._M_impl._M_start = _Bit_iterator();
- __x._M_impl._M_finish = _Bit_iterator();
- __x._M_impl._M_end_of_storage = nullptr;
-      }
-
-
-      ~_Bvector_base()
-      { this->_M_deallocate(); }
-
-    protected:
-      _Bvector_impl _M_impl;
-
-      _Bit_pointer
-      _M_allocate(size_t __n)
-      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
-
-      void
-      _M_deallocate()
-      {
- if (_M_impl._M_start._M_p)
-   {
-     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
-     _Bit_alloc_traits::deallocate(_M_impl,
-       _M_impl._M_end_of_storage - __n,
-       __n);
-   }
-      }
-
-      static size_t
-      _S_nword(size_t __n)
-      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
-    };
-
-
-}
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 540 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-template<typename _Alloc>
-  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
-  {
-    typedef _Bvector_base<_Alloc> _Base;
-    typedef typename _Base::_Bit_pointer _Bit_pointer;
-    typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
-
-
-    template<typename> friend struct hash;
-
-
-  public:
-    typedef bool value_type;
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Bit_reference reference;
-    typedef bool const_reference;
-    typedef _Bit_reference* pointer;
-    typedef const bool* const_pointer;
-    typedef _Bit_iterator iterator;
-    typedef _Bit_const_iterator const_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    typedef std::reverse_iterator<iterator> reverse_iterator;
-    typedef _Alloc allocator_type;
-
-    allocator_type get_allocator() const
-    { return _Base::get_allocator(); }
-
-  protected:
-    using _Base::_M_allocate;
-    using _Base::_M_deallocate;
-    using _Base::_S_nword;
-    using _Base::_M_get_Bit_allocator;
-
-  public:
-    vector()
-
-      noexcept(is_nothrow_default_constructible<allocator_type>::value)
-
-    : _Base() { }
-
-    explicit
-    vector(const allocator_type& __a)
-    : _Base(__a) { }
-
-
-    explicit
-    vector(size_type __n, const allocator_type& __a = allocator_type())
-    : vector(__n, false, __a)
-    { }
-
-    vector(size_type __n, const bool& __value,
-    const allocator_type& __a = allocator_type())
-    : _Base(__a)
-    {
-      _M_initialize(__n);
-      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
-  __value ? ~0 : 0);
-    }
-# 611 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-    vector(const vector& __x)
-    : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
-    {
-      _M_initialize(__x.size());
-      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
-    }
-
-
-    vector(vector&& __x) noexcept
-    : _Base(std::move(__x)) { }
-
-    vector(vector&& __x, const allocator_type& __a)
-    noexcept(_Bit_alloc_traits::_S_always_equal())
-    : _Base(__a)
-    {
-      if (__x.get_allocator() == __a)
- {
-   this->_M_impl._M_start = __x._M_impl._M_start;
-   this->_M_impl._M_finish = __x._M_impl._M_finish;
-   this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
-   __x._M_impl._M_start = _Bit_iterator();
-   __x._M_impl._M_finish = _Bit_iterator();
-   __x._M_impl._M_end_of_storage = nullptr;
- }
-      else
- {
-   _M_initialize(__x.size());
-   _M_copy_aligned(__x.begin(), __x.end(), begin());
-   __x.clear();
- }
-    }
-
-    vector(const vector& __x, const allocator_type& __a)
-    : _Base(__a)
-    {
-      _M_initialize(__x.size());
-      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
-    }
-
-    vector(initializer_list<bool> __l,
-    const allocator_type& __a = allocator_type())
-    : _Base(__a)
-    {
-      _M_initialize_range(__l.begin(), __l.end(),
-     random_access_iterator_tag());
-    }
-
-
-
-    template<typename _InputIterator,
-      typename = std::_RequireInputIter<_InputIterator>>
-      vector(_InputIterator __first, _InputIterator __last,
-      const allocator_type& __a = allocator_type())
-      : _Base(__a)
-      { _M_initialize_dispatch(__first, __last, __false_type()); }
-# 677 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-    ~vector() noexcept { }
-
-    vector&
-    operator=(const vector& __x)
-    {
-      if (&__x == this)
- return *this;
-
-      if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
- {
-   if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
-     {
-       this->_M_deallocate();
-       std::__alloc_on_copy(_M_get_Bit_allocator(),
-       __x._M_get_Bit_allocator());
-       _M_initialize(__x.size());
-     }
-   else
-     std::__alloc_on_copy(_M_get_Bit_allocator(),
-     __x._M_get_Bit_allocator());
- }
-
-      if (__x.size() > capacity())
- {
-   this->_M_deallocate();
-   _M_initialize(__x.size());
- }
-      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
-      begin());
-      return *this;
-    }
-
-
-    vector&
-    operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
-    {
-      if (_Bit_alloc_traits::_S_propagate_on_move_assign()
-   || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
- {
-   this->_M_deallocate();
-   this->_M_impl._M_start = __x._M_impl._M_start;
-   this->_M_impl._M_finish = __x._M_impl._M_finish;
-   this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
-   __x._M_impl._M_start = _Bit_iterator();
-   __x._M_impl._M_finish = _Bit_iterator();
-   __x._M_impl._M_end_of_storage = nullptr;
-   std::__alloc_on_move(_M_get_Bit_allocator(),
-          __x._M_get_Bit_allocator());
- }
-      else
- {
-   if (__x.size() > capacity())
-     {
-       this->_M_deallocate();
-       _M_initialize(__x.size());
-     }
-   this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
-          begin());
-   __x.clear();
- }
-      return *this;
-    }
-
-    vector&
-    operator=(initializer_list<bool> __l)
-    {
-      this->assign (__l.begin(), __l.end());
-      return *this;
-    }
-
-
-
-
-
-
-    void
-    assign(size_type __n, const bool& __x)
-    { _M_fill_assign(__n, __x); }
-
-
-    template<typename _InputIterator,
-      typename = std::_RequireInputIter<_InputIterator>>
-      void
-      assign(_InputIterator __first, _InputIterator __last)
-      { _M_assign_dispatch(__first, __last, __false_type()); }
-# 773 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-    void
-    assign(initializer_list<bool> __l)
-    { this->assign(__l.begin(), __l.end()); }
-
-
-    iterator
-    begin() noexcept
-    { return this->_M_impl._M_start; }
-
-    const_iterator
-    begin() const noexcept
-    { return this->_M_impl._M_start; }
-
-    iterator
-    end() noexcept
-    { return this->_M_impl._M_finish; }
-
-    const_iterator
-    end() const noexcept
-    { return this->_M_impl._M_finish; }
-
-    reverse_iterator
-    rbegin() noexcept
-    { return reverse_iterator(end()); }
-
-    const_reverse_iterator
-    rbegin() const noexcept
-    { return const_reverse_iterator(end()); }
-
-    reverse_iterator
-    rend() noexcept
-    { return reverse_iterator(begin()); }
-
-    const_reverse_iterator
-    rend() const noexcept
-    { return const_reverse_iterator(begin()); }
-
-
-    const_iterator
-    cbegin() const noexcept
-    { return this->_M_impl._M_start; }
-
-    const_iterator
-    cend() const noexcept
-    { return this->_M_impl._M_finish; }
-
-    const_reverse_iterator
-    crbegin() const noexcept
-    { return const_reverse_iterator(end()); }
-
-    const_reverse_iterator
-    crend() const noexcept
-    { return const_reverse_iterator(begin()); }
-
-
-    size_type
-    size() const noexcept
-    { return size_type(end() - begin()); }
-
-    size_type
-    max_size() const noexcept
-    {
-      const size_type __isize =
- __gnu_cxx::__numeric_traits<difference_type>::__max
- - int(_S_word_bit) + 1;
-      const size_type __asize
- = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
-      return (__asize <= __isize / int(_S_word_bit)
-       ? __asize * int(_S_word_bit) : __isize);
-    }
-
-    size_type
-    capacity() const noexcept
-    { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
-         - begin()); }
-
-    bool
-    empty() const noexcept
-    { return begin() == end(); }
-
-    reference
-    operator[](size_type __n)
-    {
-      return *iterator(this->_M_impl._M_start._M_p
-         + __n / int(_S_word_bit), __n % int(_S_word_bit));
-    }
-
-    const_reference
-    operator[](size_type __n) const
-    {
-      return *const_iterator(this->_M_impl._M_start._M_p
-        + __n / int(_S_word_bit), __n % int(_S_word_bit));
-    }
-
-  protected:
-    void
-    _M_range_check(size_type __n) const
-    {
-      if (__n >= this->size())
- __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
-
-
-     __n, this->size());
-    }
-
-  public:
-    reference
-    at(size_type __n)
-    { _M_range_check(__n); return (*this)[__n]; }
-
-    const_reference
-    at(size_type __n) const
-    { _M_range_check(__n); return (*this)[__n]; }
-
-    void
-    reserve(size_type __n)
-    {
-      if (__n > max_size())
- __throw_length_error(("vector::reserve"));
-      if (capacity() < __n)
- _M_reallocate(__n);
-    }
-
-    reference
-    front()
-    { return *begin(); }
-
-    const_reference
-    front() const
-    { return *begin(); }
-
-    reference
-    back()
-    { return *(end() - 1); }
-
-    const_reference
-    back() const
-    { return *(end() - 1); }
-
-
-
-
-
-
-    void
-    data() noexcept { }
-
-    void
-    push_back(bool __x)
-    {
-      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
-        *this->_M_impl._M_finish++ = __x;
-      else
-        _M_insert_aux(end(), __x);
-    }
-
-    void
-    swap(vector& __x) noexcept
-    {
-      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
-      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
-      std::swap(this->_M_impl._M_end_of_storage,
-  __x._M_impl._M_end_of_storage);
-      _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
-        __x._M_get_Bit_allocator());
-    }
-
-
-    static void
-    swap(reference __x, reference __y) noexcept
-    {
-      bool __tmp = __x;
-      __x = __y;
-      __y = __tmp;
-    }
-
-    iterator
-
-    insert(const_iterator __position, const bool& __x = bool())
-
-
-
-    {
-      const difference_type __n = __position - begin();
-      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
-   && __position == end())
-        *this->_M_impl._M_finish++ = __x;
-      else
-        _M_insert_aux(__position._M_const_cast(), __x);
-      return begin() + __n;
-    }
-
-
-    template<typename _InputIterator,
-      typename = std::_RequireInputIter<_InputIterator>>
-      iterator
-      insert(const_iterator __position,
-      _InputIterator __first, _InputIterator __last)
-      {
- difference_type __offset = __position - cbegin();
- _M_insert_dispatch(__position._M_const_cast(),
-      __first, __last, __false_type());
- return begin() + __offset;
-      }
-# 989 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_bvector.h" 3
-    iterator
-    insert(const_iterator __position, size_type __n, const bool& __x)
-    {
-      difference_type __offset = __position - cbegin();
-      _M_fill_insert(__position._M_const_cast(), __n, __x);
-      return begin() + __offset;
-    }
-
-
-
-
-
-
-
-    iterator
-    insert(const_iterator __p, initializer_list<bool> __l)
-    { return this->insert(__p, __l.begin(), __l.end()); }
-
-
-    void
-    pop_back()
-    { --this->_M_impl._M_finish; }
-
-    iterator
-
-    erase(const_iterator __position)
-
-
-
-    { return _M_erase(__position._M_const_cast()); }
-
-    iterator
-
-    erase(const_iterator __first, const_iterator __last)
-
-
-
-    { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
-
-    void
-    resize(size_type __new_size, bool __x = bool())
-    {
-      if (__new_size < size())
-        _M_erase_at_end(begin() + difference_type(__new_size));
-      else
-        insert(end(), __new_size - size(), __x);
-    }
-
-
-    void
-    shrink_to_fit()
-    { _M_shrink_to_fit(); }
-
-
-    void
-    flip() noexcept
-    {
-      _Bit_type * const __end = this->_M_impl._M_end_addr();
-      for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
-        *__p = ~*__p;
-    }
-
-    void
-    clear() noexcept
-    { _M_erase_at_end(begin()); }
-
-
-    template<typename... _Args>
-      void
-      emplace_back(_Args&&... __args)
-      { push_back(bool(__args...)); }
-
-    template<typename... _Args>
-      iterator
-      emplace(const_iterator __pos, _Args&&... __args)
-      { return insert(__pos, bool(__args...)); }
-
-
-  protected:
-
-    iterator
-    _M_copy_aligned(const_iterator __first, const_iterator __last,
-      iterator __result)
-    {
-      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
-      return std::copy(const_iterator(__last._M_p, 0), __last,
-         iterator(__q, 0));
-    }
-
-    void
-    _M_initialize(size_type __n)
-    {
-      _Bit_pointer __q = this->_M_allocate(__n);
-      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
-      this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
-      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
-    }
-
-    void
-    _M_reallocate(size_type __n);
-
-
-    bool
-    _M_shrink_to_fit();
-
-
-
-
-
-
-    template<typename _Integer>
-      void
-      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
-      {
- _M_initialize(static_cast<size_type>(__n));
- std::fill(this->_M_impl._M_start._M_p,
-    this->_M_impl._M_end_addr(), __x ? ~0 : 0);
-      }
-
-    template<typename _InputIterator>
-      void
-      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
-        __false_type)
-      { _M_initialize_range(__first, __last,
-       std::__iterator_category(__first)); }
-
-    template<typename _InputIterator>
-      void
-      _M_initialize_range(_InputIterator __first, _InputIterator __last,
-     std::input_iterator_tag)
-      {
- for (; __first != __last; ++__first)
-   push_back(*__first);
-      }
-
-    template<typename _ForwardIterator>
-      void
-      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
-     std::forward_iterator_tag)
-      {
- const size_type __n = std::distance(__first, __last);
- _M_initialize(__n);
- std::copy(__first, __last, this->_M_impl._M_start);
-      }
-
-
-
-    template<typename _Integer>
-      void
-      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
-      { _M_fill_assign(__n, __val); }
-
-    template<class _InputIterator>
-      void
-      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
-    __false_type)
-      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
-
-    void
-    _M_fill_assign(size_t __n, bool __x)
-    {
-      if (__n > size())
- {
-   std::fill(this->_M_impl._M_start._M_p,
-      this->_M_impl._M_end_addr(), __x ? ~0 : 0);
-   insert(end(), __n - size(), __x);
- }
-      else
- {
-   _M_erase_at_end(begin() + __n);
-   std::fill(this->_M_impl._M_start._M_p,
-      this->_M_impl._M_end_addr(), __x ? ~0 : 0);
- }
-    }
-
-    template<typename _InputIterator>
-      void
-      _M_assign_aux(_InputIterator __first, _InputIterator __last,
-      std::input_iterator_tag)
-      {
- iterator __cur = begin();
- for (; __first != __last && __cur != end(); ++__cur, ++__first)
-   *__cur = *__first;
- if (__first == __last)
-   _M_erase_at_end(__cur);
- else
-   insert(end(), __first, __last);
-      }
-
-    template<typename _ForwardIterator>
-      void
-      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
-      std::forward_iterator_tag)
-      {
- const size_type __len = std::distance(__first, __last);
- if (__len < size())
-   _M_erase_at_end(std::copy(__first, __last, begin()));
- else
-   {
-     _ForwardIterator __mid = __first;
-     std::advance(__mid, size());
-     std::copy(__first, __mid, begin());
-     insert(end(), __mid, __last);
-   }
-      }
-
-
-
-
-
-    template<typename _Integer>
-      void
-      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
-    __true_type)
-      { _M_fill_insert(__pos, __n, __x); }
-
-    template<typename _InputIterator>
-      void
-      _M_insert_dispatch(iterator __pos,
-    _InputIterator __first, _InputIterator __last,
-    __false_type)
-      { _M_insert_range(__pos, __first, __last,
-   std::__iterator_category(__first)); }
-
-    void
-    _M_fill_insert(iterator __position, size_type __n, bool __x);
-
-    template<typename _InputIterator>
-      void
-      _M_insert_range(iterator __pos, _InputIterator __first,
-        _InputIterator __last, std::input_iterator_tag)
-      {
- for (; __first != __last; ++__first)
-   {
-     __pos = insert(__pos, *__first);
-     ++__pos;
-   }
-      }
-
-    template<typename _ForwardIterator>
-      void
-      _M_insert_range(iterator __position, _ForwardIterator __first,
-        _ForwardIterator __last, std::forward_iterator_tag);
-
-    void
-    _M_insert_aux(iterator __position, bool __x);
-
-    size_type
-    _M_check_len(size_type __n, const char* __s) const
-    {
-      if (max_size() - size() < __n)
- __throw_length_error((__s));
-
-      const size_type __len = size() + std::max(size(), __n);
-      return (__len < size() || __len > max_size()) ? max_size() : __len;
-    }
-
-    void
-    _M_erase_at_end(iterator __pos)
-    { this->_M_impl._M_finish = __pos; }
-
-    iterator
-    _M_erase(iterator __pos);
-
-    iterator
-    _M_erase(iterator __first, iterator __last);
-  };
-
-
-}
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template<typename _Alloc>
-    struct hash<std::vector<bool, _Alloc>>
-    : public __hash_base<size_t, std::vector<bool, _Alloc>>
-    {
-      size_t
-      operator()(const std::vector<bool, _Alloc>&) const noexcept;
-    };
-
-
-}
-# 66 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/vector.tcc" 1 3
-# 59 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/vector.tcc" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Tp, typename _Alloc>
-    void
-    vector<_Tp, _Alloc>::
-    reserve(size_type __n)
-    {
-      if (__n > this->max_size())
- __throw_length_error(("vector::reserve"));
-      if (this->capacity() < __n)
- {
-   const size_type __old_size = size();
-   pointer __tmp = _M_allocate_and_copy(__n,
-     std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
-     std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
-   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-   _M_get_Tp_allocator());
-   _M_deallocate(this->_M_impl._M_start,
-   this->_M_impl._M_end_of_storage
-   - this->_M_impl._M_start);
-   this->_M_impl._M_start = __tmp;
-   this->_M_impl._M_finish = __tmp + __old_size;
-   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
- }
-    }
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      void
-      vector<_Tp, _Alloc>::
-      emplace_back(_Args&&... __args)
-      {
- if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
-   {
-     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
-         std::forward<_Args>(__args)...);
-     ++this->_M_impl._M_finish;
-   }
- else
-   _M_emplace_back_aux(std::forward<_Args>(__args)...);
-      }
-
-
-  template<typename _Tp, typename _Alloc>
-    typename vector<_Tp, _Alloc>::iterator
-    vector<_Tp, _Alloc>::
-
-    insert(const_iterator __position, const value_type& __x)
-
-
-
-    {
-      const size_type __n = __position - begin();
-      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
-   && __position == end())
- {
-   _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
-   ++this->_M_impl._M_finish;
- }
-      else
- {
-
-   const auto __pos = begin() + (__position - cbegin());
-   if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
-     {
-       _Tp __x_copy = __x;
-       _M_insert_aux(__pos, std::move(__x_copy));
-     }
-   else
-     _M_insert_aux(__pos, __x);
-
-
-
- }
-      return iterator(this->_M_impl._M_start + __n);
-    }
-
-  template<typename _Tp, typename _Alloc>
-    typename vector<_Tp, _Alloc>::iterator
-    vector<_Tp, _Alloc>::
-    _M_erase(iterator __position)
-    {
-      if (__position + 1 != end())
- std::move(__position + 1, end(), __position);
-      --this->_M_impl._M_finish;
-      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
-      return __position;
-    }
-
-  template<typename _Tp, typename _Alloc>
-    typename vector<_Tp, _Alloc>::iterator
-    vector<_Tp, _Alloc>::
-    _M_erase(iterator __first, iterator __last)
-    {
-      if (__first != __last)
- {
-   if (__last != end())
-     std::move(__last, end(), __first);
-   _M_erase_at_end(__first.base() + (end() - __last));
- }
-      return __first;
-    }
-
-  template<typename _Tp, typename _Alloc>
-    vector<_Tp, _Alloc>&
-    vector<_Tp, _Alloc>::
-    operator=(const vector<_Tp, _Alloc>& __x)
-    {
-      if (&__x != this)
- {
-
-   if (_Alloc_traits::_S_propagate_on_copy_assign())
-     {
-       if (!_Alloc_traits::_S_always_equal()
-           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
-         {
-
-    this->clear();
-    _M_deallocate(this->_M_impl._M_start,
-    this->_M_impl._M_end_of_storage
-    - this->_M_impl._M_start);
-    this->_M_impl._M_start = nullptr;
-    this->_M_impl._M_finish = nullptr;
-    this->_M_impl._M_end_of_storage = nullptr;
-  }
-       std::__alloc_on_copy(_M_get_Tp_allocator(),
-       __x._M_get_Tp_allocator());
-     }
-
-   const size_type __xlen = __x.size();
-   if (__xlen > capacity())
-     {
-       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
-         __x.end());
-       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-       _M_deallocate(this->_M_impl._M_start,
-       this->_M_impl._M_end_of_storage
-       - this->_M_impl._M_start);
-       this->_M_impl._M_start = __tmp;
-       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
-     }
-   else if (size() >= __xlen)
-     {
-       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
-       end(), _M_get_Tp_allocator());
-     }
-   else
-     {
-       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
-   this->_M_impl._M_start);
-       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
-       __x._M_impl._M_finish,
-       this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-     }
-   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
- }
-      return *this;
-    }
-
-  template<typename _Tp, typename _Alloc>
-    void
-    vector<_Tp, _Alloc>::
-    _M_fill_assign(size_t __n, const value_type& __val)
-    {
-      if (__n > capacity())
- {
-   vector __tmp(__n, __val, _M_get_Tp_allocator());
-   __tmp._M_impl._M_swap_data(this->_M_impl);
- }
-      else if (__n > size())
- {
-   std::fill(begin(), end(), __val);
-   this->_M_impl._M_finish =
-     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
-       __n - size(), __val,
-       _M_get_Tp_allocator());
- }
-      else
-        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
-    }
-
-  template<typename _Tp, typename _Alloc>
-    template<typename _InputIterator>
-      void
-      vector<_Tp, _Alloc>::
-      _M_assign_aux(_InputIterator __first, _InputIterator __last,
-      std::input_iterator_tag)
-      {
- pointer __cur(this->_M_impl._M_start);
- for (; __first != __last && __cur != this->_M_impl._M_finish;
-      ++__cur, ++__first)
-   *__cur = *__first;
- if (__first == __last)
-   _M_erase_at_end(__cur);
- else
-   insert(end(), __first, __last);
-      }
-
-  template<typename _Tp, typename _Alloc>
-    template<typename _ForwardIterator>
-      void
-      vector<_Tp, _Alloc>::
-      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
-      std::forward_iterator_tag)
-      {
- const size_type __len = std::distance(__first, __last);
-
- if (__len > capacity())
-   {
-     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
-     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-     _M_get_Tp_allocator());
-     _M_deallocate(this->_M_impl._M_start,
-     this->_M_impl._M_end_of_storage
-     - this->_M_impl._M_start);
-     this->_M_impl._M_start = __tmp;
-     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
-     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
-   }
- else if (size() >= __len)
-   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
- else
-   {
-     _ForwardIterator __mid = __first;
-     std::advance(__mid, size());
-     std::copy(__first, __mid, this->_M_impl._M_start);
-     this->_M_impl._M_finish =
-       std::__uninitialized_copy_a(__mid, __last,
-       this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-   }
-      }
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      typename vector<_Tp, _Alloc>::iterator
-      vector<_Tp, _Alloc>::
-      emplace(const_iterator __position, _Args&&... __args)
-      {
- const size_type __n = __position - begin();
- if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
-     && __position == end())
-   {
-     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
-         std::forward<_Args>(__args)...);
-     ++this->_M_impl._M_finish;
-   }
- else
-   _M_insert_aux(begin() + (__position - cbegin()),
-   std::forward<_Args>(__args)...);
- return iterator(this->_M_impl._M_start + __n);
-      }
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      void
-      vector<_Tp, _Alloc>::
-      _M_insert_aux(iterator __position, _Args&&... __args)
-
-
-
-
-
-
-    {
-      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
- {
-   _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
-              std::move(*(this->_M_impl._M_finish - 1)));
-
-   ++this->_M_impl._M_finish;
-
-
-
-   std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);
-
-
-
-
-
-   *__position = _Tp(std::forward<_Args>(__args)...);
-
- }
-      else
- {
-   const size_type __len =
-     _M_check_len(size_type(1), "vector::_M_insert_aux");
-   const size_type __elems_before = __position - begin();
-   pointer __new_start(this->_M_allocate(__len));
-   pointer __new_finish(__new_start);
-   try
-     {
-
-
-
-
-       _Alloc_traits::construct(this->_M_impl,
-                         __new_start + __elems_before,
-
-           std::forward<_Args>(__args)...);
-
-
-
-       __new_finish = pointer();
-
-       __new_finish
-  = std::__uninitialized_move_if_noexcept_a
-  (this->_M_impl._M_start, __position.base(),
-   __new_start, _M_get_Tp_allocator());
-
-       ++__new_finish;
-
-       __new_finish
-  = std::__uninitialized_move_if_noexcept_a
-  (__position.base(), this->_M_impl._M_finish,
-   __new_finish, _M_get_Tp_allocator());
-     }
-          catch(...)
-     {
-       if (!__new_finish)
-  _Alloc_traits::destroy(this->_M_impl,
-                         __new_start + __elems_before);
-       else
-  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
-       _M_deallocate(__new_start, __len);
-       throw;
-     }
-   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-   _M_get_Tp_allocator());
-   _M_deallocate(this->_M_impl._M_start,
-   this->_M_impl._M_end_of_storage
-   - this->_M_impl._M_start);
-   this->_M_impl._M_start = __new_start;
-   this->_M_impl._M_finish = __new_finish;
-   this->_M_impl._M_end_of_storage = __new_start + __len;
- }
-    }
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename... _Args>
-      void
-      vector<_Tp, _Alloc>::
-      _M_emplace_back_aux(_Args&&... __args)
-      {
- const size_type __len =
-   _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
- pointer __new_start(this->_M_allocate(__len));
- pointer __new_finish(__new_start);
- try
-   {
-     _Alloc_traits::construct(this->_M_impl, __new_start + size(),
-         std::forward<_Args>(__args)...);
-     __new_finish = pointer();
-
-     __new_finish
-       = std::__uninitialized_move_if_noexcept_a
-       (this->_M_impl._M_start, this->_M_impl._M_finish,
-        __new_start, _M_get_Tp_allocator());
-
-     ++__new_finish;
-   }
- catch(...)
-   {
-     if (!__new_finish)
-       _Alloc_traits::destroy(this->_M_impl, __new_start + size());
-     else
-       std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
-     _M_deallocate(__new_start, __len);
-     throw;
-   }
- std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-        _M_get_Tp_allocator());
- _M_deallocate(this->_M_impl._M_start,
-        this->_M_impl._M_end_of_storage
-        - this->_M_impl._M_start);
- this->_M_impl._M_start = __new_start;
- this->_M_impl._M_finish = __new_finish;
- this->_M_impl._M_end_of_storage = __new_start + __len;
-      }
-
-
-  template<typename _Tp, typename _Alloc>
-    void
-    vector<_Tp, _Alloc>::
-    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
-    {
-      if (__n != 0)
- {
-   if (size_type(this->_M_impl._M_end_of_storage
-   - this->_M_impl._M_finish) >= __n)
-     {
-       value_type __x_copy = __x;
-       const size_type __elems_after = end() - __position;
-       pointer __old_finish(this->_M_impl._M_finish);
-       if (__elems_after > __n)
-  {
-    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
-           this->_M_impl._M_finish,
-           this->_M_impl._M_finish,
-           _M_get_Tp_allocator());
-    this->_M_impl._M_finish += __n;
-    std::move_backward(__position.base(), __old_finish - __n, __old_finish);
-
-    std::fill(__position.base(), __position.base() + __n,
-       __x_copy);
-  }
-       else
-  {
-    this->_M_impl._M_finish =
-      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
-        __n - __elems_after,
-        __x_copy,
-        _M_get_Tp_allocator());
-    std::__uninitialized_move_a(__position.base(), __old_finish,
-           this->_M_impl._M_finish,
-           _M_get_Tp_allocator());
-    this->_M_impl._M_finish += __elems_after;
-    std::fill(__position.base(), __old_finish, __x_copy);
-  }
-     }
-   else
-     {
-       const size_type __len =
-  _M_check_len(__n, "vector::_M_fill_insert");
-       const size_type __elems_before = __position - begin();
-       pointer __new_start(this->_M_allocate(__len));
-       pointer __new_finish(__new_start);
-       try
-  {
-
-    std::__uninitialized_fill_n_a(__new_start + __elems_before,
-      __n, __x,
-      _M_get_Tp_allocator());
-    __new_finish = pointer();
-
-    __new_finish
-      = std::__uninitialized_move_if_noexcept_a
-      (this->_M_impl._M_start, __position.base(),
-       __new_start, _M_get_Tp_allocator());
-
-    __new_finish += __n;
-
-    __new_finish
-      = std::__uninitialized_move_if_noexcept_a
-      (__position.base(), this->_M_impl._M_finish,
-       __new_finish, _M_get_Tp_allocator());
-  }
-       catch(...)
-  {
-    if (!__new_finish)
-      std::_Destroy(__new_start + __elems_before,
-      __new_start + __elems_before + __n,
-      _M_get_Tp_allocator());
-    else
-      std::_Destroy(__new_start, __new_finish,
-      _M_get_Tp_allocator());
-    _M_deallocate(__new_start, __len);
-    throw;
-  }
-       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-       _M_deallocate(this->_M_impl._M_start,
-       this->_M_impl._M_end_of_storage
-       - this->_M_impl._M_start);
-       this->_M_impl._M_start = __new_start;
-       this->_M_impl._M_finish = __new_finish;
-       this->_M_impl._M_end_of_storage = __new_start + __len;
-     }
- }
-    }
-
-
-  template<typename _Tp, typename _Alloc>
-    void
-    vector<_Tp, _Alloc>::
-    _M_default_append(size_type __n)
-    {
-      if (__n != 0)
- {
-   if (size_type(this->_M_impl._M_end_of_storage
-   - this->_M_impl._M_finish) >= __n)
-     {
-       this->_M_impl._M_finish =
-  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
-       __n, _M_get_Tp_allocator());
-     }
-   else
-     {
-       const size_type __len =
-  _M_check_len(__n, "vector::_M_default_append");
-       const size_type __old_size = this->size();
-       pointer __new_start(this->_M_allocate(__len));
-       pointer __new_finish(__new_start);
-       try
-  {
-    __new_finish
-      = std::__uninitialized_move_if_noexcept_a
-      (this->_M_impl._M_start, this->_M_impl._M_finish,
-       __new_start, _M_get_Tp_allocator());
-    __new_finish =
-      std::__uninitialized_default_n_a(__new_finish, __n,
-           _M_get_Tp_allocator());
-  }
-       catch(...)
-  {
-    std::_Destroy(__new_start, __new_finish,
-    _M_get_Tp_allocator());
-    _M_deallocate(__new_start, __len);
-    throw;
-  }
-       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-       _M_get_Tp_allocator());
-       _M_deallocate(this->_M_impl._M_start,
-       this->_M_impl._M_end_of_storage
-       - this->_M_impl._M_start);
-       this->_M_impl._M_start = __new_start;
-       this->_M_impl._M_finish = __new_finish;
-       this->_M_impl._M_end_of_storage = __new_start + __len;
-     }
- }
-    }
-
-  template<typename _Tp, typename _Alloc>
-    bool
-    vector<_Tp, _Alloc>::
-    _M_shrink_to_fit()
-    {
-      if (capacity() == size())
- return false;
-      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
-    }
-
-
-  template<typename _Tp, typename _Alloc>
-    template<typename _InputIterator>
-      void
-      vector<_Tp, _Alloc>::
-      _M_range_insert(iterator __pos, _InputIterator __first,
-        _InputIterator __last, std::input_iterator_tag)
-      {
- for (; __first != __last; ++__first)
-   {
-     __pos = insert(__pos, *__first);
-     ++__pos;
-   }
-      }
-
-  template<typename _Tp, typename _Alloc>
-    template<typename _ForwardIterator>
-      void
-      vector<_Tp, _Alloc>::
-      _M_range_insert(iterator __position, _ForwardIterator __first,
-        _ForwardIterator __last, std::forward_iterator_tag)
-      {
- if (__first != __last)
-   {
-     const size_type __n = std::distance(__first, __last);
-     if (size_type(this->_M_impl._M_end_of_storage
-     - this->_M_impl._M_finish) >= __n)
-       {
-  const size_type __elems_after = end() - __position;
-  pointer __old_finish(this->_M_impl._M_finish);
-  if (__elems_after > __n)
-    {
-      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
-      this->_M_impl._M_finish,
-      this->_M_impl._M_finish,
-      _M_get_Tp_allocator());
-      this->_M_impl._M_finish += __n;
-      std::move_backward(__position.base(), __old_finish - __n, __old_finish);
-
-      std::copy(__first, __last, __position);
-    }
-  else
-    {
-      _ForwardIterator __mid = __first;
-      std::advance(__mid, __elems_after);
-      std::__uninitialized_copy_a(__mid, __last,
-      this->_M_impl._M_finish,
-      _M_get_Tp_allocator());
-      this->_M_impl._M_finish += __n - __elems_after;
-      std::__uninitialized_move_a(__position.base(),
-      __old_finish,
-      this->_M_impl._M_finish,
-      _M_get_Tp_allocator());
-      this->_M_impl._M_finish += __elems_after;
-      std::copy(__first, __mid, __position);
-    }
-       }
-     else
-       {
-  const size_type __len =
-    _M_check_len(__n, "vector::_M_range_insert");
-  pointer __new_start(this->_M_allocate(__len));
-  pointer __new_finish(__new_start);
-  try
-    {
-      __new_finish
-        = std::__uninitialized_move_if_noexcept_a
-        (this->_M_impl._M_start, __position.base(),
-         __new_start, _M_get_Tp_allocator());
-      __new_finish
-        = std::__uninitialized_copy_a(__first, __last,
-          __new_finish,
-          _M_get_Tp_allocator());
-      __new_finish
-        = std::__uninitialized_move_if_noexcept_a
-        (__position.base(), this->_M_impl._M_finish,
-         __new_finish, _M_get_Tp_allocator());
-    }
-  catch(...)
-    {
-      std::_Destroy(__new_start, __new_finish,
-      _M_get_Tp_allocator());
-      _M_deallocate(__new_start, __len);
-      throw;
-    }
-  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
-         _M_get_Tp_allocator());
-  _M_deallocate(this->_M_impl._M_start,
-         this->_M_impl._M_end_of_storage
-         - this->_M_impl._M_start);
-  this->_M_impl._M_start = __new_start;
-  this->_M_impl._M_finish = __new_finish;
-  this->_M_impl._M_end_of_storage = __new_start + __len;
-       }
-   }
-      }
-
-
-
-  template<typename _Alloc>
-    void
-    vector<bool, _Alloc>::
-    _M_reallocate(size_type __n)
-    {
-      _Bit_pointer __q = this->_M_allocate(__n);
-      iterator __start(std::__addressof(*__q), 0);
-      this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), __start);
-      this->_M_deallocate();
-      this->_M_impl._M_start = __start;
-      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
-    }
-
-  template<typename _Alloc>
-    void
-    vector<bool, _Alloc>::
-    _M_fill_insert(iterator __position, size_type __n, bool __x)
-    {
-      if (__n == 0)
- return;
-      if (capacity() - size() >= __n)
- {
-   std::copy_backward(__position, end(),
-        this->_M_impl._M_finish + difference_type(__n));
-   std::fill(__position, __position + difference_type(__n), __x);
-   this->_M_impl._M_finish += difference_type(__n);
- }
-      else
- {
-   const size_type __len =
-     _M_check_len(__n, "vector<bool>::_M_fill_insert");
-   _Bit_pointer __q = this->_M_allocate(__len);
-   iterator __start(std::__addressof(*__q), 0);
-   iterator __i = _M_copy_aligned(begin(), __position, __start);
-   std::fill(__i, __i + difference_type(__n), __x);
-   this->_M_impl._M_finish = std::copy(__position, end(),
-           __i + difference_type(__n));
-   this->_M_deallocate();
-   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
-   this->_M_impl._M_start = __start;
- }
-    }
-
-  template<typename _Alloc>
-    template<typename _ForwardIterator>
-      void
-      vector<bool, _Alloc>::
-      _M_insert_range(iterator __position, _ForwardIterator __first,
-        _ForwardIterator __last, std::forward_iterator_tag)
-      {
- if (__first != __last)
-   {
-     size_type __n = std::distance(__first, __last);
-     if (capacity() - size() >= __n)
-       {
-  std::copy_backward(__position, end(),
-       this->_M_impl._M_finish
-       + difference_type(__n));
-  std::copy(__first, __last, __position);
-  this->_M_impl._M_finish += difference_type(__n);
-       }
-     else
-       {
-  const size_type __len =
-    _M_check_len(__n, "vector<bool>::_M_insert_range");
-  _Bit_pointer __q = this->_M_allocate(__len);
-  iterator __start(std::__addressof(*__q), 0);
-  iterator __i = _M_copy_aligned(begin(), __position, __start);
-  __i = std::copy(__first, __last, __i);
-  this->_M_impl._M_finish = std::copy(__position, end(), __i);
-  this->_M_deallocate();
-  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
-  this->_M_impl._M_start = __start;
-       }
-   }
-      }
-
-  template<typename _Alloc>
-    void
-    vector<bool, _Alloc>::
-    _M_insert_aux(iterator __position, bool __x)
-    {
-      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
- {
-   std::copy_backward(__position, this->_M_impl._M_finish,
-        this->_M_impl._M_finish + 1);
-   *__position = __x;
-   ++this->_M_impl._M_finish;
- }
-      else
- {
-   const size_type __len =
-     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
-   _Bit_pointer __q = this->_M_allocate(__len);
-   iterator __start(std::__addressof(*__q), 0);
-   iterator __i = _M_copy_aligned(begin(), __position, __start);
-   *__i++ = __x;
-   this->_M_impl._M_finish = std::copy(__position, end(), __i);
-   this->_M_deallocate();
-   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
-   this->_M_impl._M_start = __start;
- }
-    }
-
-  template<typename _Alloc>
-    typename vector<bool, _Alloc>::iterator
-    vector<bool, _Alloc>::
-    _M_erase(iterator __position)
-    {
-      if (__position + 1 != end())
-        std::copy(__position + 1, end(), __position);
-      --this->_M_impl._M_finish;
-      return __position;
-    }
-
-  template<typename _Alloc>
-    typename vector<bool, _Alloc>::iterator
-    vector<bool, _Alloc>::
-    _M_erase(iterator __first, iterator __last)
-    {
-      if (__first != __last)
- _M_erase_at_end(std::copy(__last, end(), __first));
-      return __first;
-    }
-
-
-  template<typename _Alloc>
-    bool
-    vector<bool, _Alloc>::
-    _M_shrink_to_fit()
-    {
-      if (capacity() - size() < int(_S_word_bit))
- return false;
-      try
- {
-   _M_reallocate(size());
-   return true;
- }
-      catch(...)
- { return false; }
-    }
-
-
-
-}
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Alloc>
-    size_t
-    hash<std::vector<bool, _Alloc>>::
-    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
-    {
-      size_t __hash = 0;
-      using std::_S_word_bit;
-      using std::_Bit_type;
-
-      const size_t __words = __b.size() / _S_word_bit;
-      if (__words)
- {
-   const size_t __clength = __words * sizeof(_Bit_type);
-   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
- }
-
-      const size_t __extrabits = __b.size() % _S_word_bit;
-      if (__extrabits)
- {
-   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
-   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
-
-   const size_t __clength
-     = (__extrabits + 8 - 1) / 8;
-   if (__words)
-     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
-   else
-     __hash = std::_Hash_impl::hash(&__hiword, __clength);
- }
-
-      return __hash;
-    }
-
-
-}
-# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/vector" 2 3
-# 62 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 1 3
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 95 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-  template<typename _Tp, typename _Sequence = deque<_Tp> >
-    class queue
-    {
-
-      typedef typename _Sequence::value_type _Sequence_value_type;
-
-
-
-
-
-      template<typename _Tp1, typename _Seq1>
-        friend bool
-        operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
-
-      template<typename _Tp1, typename _Seq1>
-        friend bool
-        operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
-
-
-      template<typename _Alloc>
- using _Uses = typename
-   enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
-
-
-    public:
-      typedef typename _Sequence::value_type value_type;
-      typedef typename _Sequence::reference reference;
-      typedef typename _Sequence::const_reference const_reference;
-      typedef typename _Sequence::size_type size_type;
-      typedef _Sequence container_type;
-
-    protected:
-# 135 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      _Sequence c;
-
-    public:
-# 146 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      explicit
-      queue(const _Sequence& __c)
-      : c(__c) { }
-
-      explicit
-      queue(_Sequence&& __c = _Sequence())
-      : c(std::move(__c)) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- explicit
- queue(const _Alloc& __a)
- : c(__a) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- queue(const _Sequence& __c, const _Alloc& __a)
- : c(__c, __a) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- queue(_Sequence&& __c, const _Alloc& __a)
- : c(std::move(__c), __a) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- queue(const queue& __q, const _Alloc& __a)
- : c(__q.c, __a) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- queue(queue&& __q, const _Alloc& __a)
- : c(std::move(__q.c), __a) { }
-
-
-
-
-
-      bool
-      empty() const
-      { return c.empty(); }
-
-
-      size_type
-      size() const
-      { return c.size(); }
-
-
-
-
-
-      reference
-      front()
-      {
-                              ;
- return c.front();
-      }
-
-
-
-
-
-      const_reference
-      front() const
-      {
-                              ;
- return c.front();
-      }
-
-
-
-
-
-      reference
-      back()
-      {
-                              ;
- return c.back();
-      }
-
-
-
-
-
-      const_reference
-      back() const
-      {
-                              ;
- return c.back();
-      }
-# 241 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      void
-      push(const value_type& __x)
-      { c.push_back(__x); }
-
-
-      void
-      push(value_type&& __x)
-      { c.push_back(std::move(__x)); }
-
-      template<typename... _Args>
-        void
-        emplace(_Args&&... __args)
- { c.emplace_back(std::forward<_Args>(__args)...); }
-# 267 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      void
-      pop()
-      {
-                              ;
- c.pop_front();
-      }
-
-
-      void
-      swap(queue& __q)
-      noexcept(__is_nothrow_swappable<_Tp>::value)
-      {
- using std::swap;
- swap(c, __q.c);
-      }
-
-    };
-# 296 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return __x.c == __y.c; }
-# 314 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return __x.c < __y.c; }
-
-
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return __y < __x; }
-
-
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _Tp, typename _Seq>
-    inline bool
-    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _Tp, typename _Seq>
-    inline void
-    swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-  template<typename _Tp, typename _Seq, typename _Alloc>
-    struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
-    : public uses_allocator<_Seq, _Alloc>::type { };
-# 395 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-  template<typename _Tp, typename _Sequence = vector<_Tp>,
-    typename _Compare = less<typename _Sequence::value_type> >
-    class priority_queue
-    {
-
-      typedef typename _Sequence::value_type _Sequence_value_type;
-# 409 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      template<typename _Alloc>
- using _Uses = typename
-   enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
-
-
-    public:
-      typedef typename _Sequence::value_type value_type;
-      typedef typename _Sequence::reference reference;
-      typedef typename _Sequence::const_reference const_reference;
-      typedef typename _Sequence::size_type size_type;
-      typedef _Sequence container_type;
-
-    protected:
-
-      _Sequence c;
-      _Compare comp;
-
-    public:
-# 437 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      explicit
-      priority_queue(const _Compare& __x,
-       const _Sequence& __s)
-      : c(__s), comp(__x)
-      { std::make_heap(c.begin(), c.end(), comp); }
-
-      explicit
-      priority_queue(const _Compare& __x = _Compare(),
-       _Sequence&& __s = _Sequence())
-      : c(std::move(__s)), comp(__x)
-      { std::make_heap(c.begin(), c.end(), comp); }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- explicit
- priority_queue(const _Alloc& __a)
- : c(__a), comp() { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- priority_queue(const _Compare& __x, const _Alloc& __a)
- : c(__a), comp(__x) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- priority_queue(const _Compare& __x, const _Sequence& __c,
-         const _Alloc& __a)
- : c(__c, __a), comp(__x) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- priority_queue(const _Compare& __x, _Sequence&& __c, const _Alloc& __a)
- : c(std::move(__c), __a), comp(__x) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- priority_queue(const priority_queue& __q, const _Alloc& __a)
- : c(__q.c, __a), comp(__q.comp) { }
-
-      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
- priority_queue(priority_queue&& __q, const _Alloc& __a)
- : c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
-# 503 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      template<typename _InputIterator>
-        priority_queue(_InputIterator __first, _InputIterator __last,
-         const _Compare& __x,
-         const _Sequence& __s)
- : c(__s), comp(__x)
-        {
-                                                  ;
-   c.insert(c.end(), __first, __last);
-   std::make_heap(c.begin(), c.end(), comp);
- }
-
-      template<typename _InputIterator>
-        priority_queue(_InputIterator __first, _InputIterator __last,
-         const _Compare& __x = _Compare(),
-         _Sequence&& __s = _Sequence())
- : c(std::move(__s)), comp(__x)
-        {
-                                                  ;
-   c.insert(c.end(), __first, __last);
-   std::make_heap(c.begin(), c.end(), comp);
- }
-
-
-
-
-
-      bool
-      empty() const
-      { return c.empty(); }
-
-
-      size_type
-      size() const
-      { return c.size(); }
-
-
-
-
-
-      const_reference
-      top() const
-      {
-                              ;
- return c.front();
-      }
-# 557 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      void
-      push(const value_type& __x)
-      {
- c.push_back(__x);
- std::push_heap(c.begin(), c.end(), comp);
-      }
-
-
-      void
-      push(value_type&& __x)
-      {
- c.push_back(std::move(__x));
- std::push_heap(c.begin(), c.end(), comp);
-      }
-
-      template<typename... _Args>
-        void
-        emplace(_Args&&... __args)
- {
-   c.emplace_back(std::forward<_Args>(__args)...);
-   std::push_heap(c.begin(), c.end(), comp);
- }
-# 592 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/stl_queue.h" 3
-      void
-      pop()
-      {
-                              ;
- std::pop_heap(c.begin(), c.end(), comp);
- c.pop_back();
-      }
-
-
-      void
-      swap(priority_queue& __pq)
-      noexcept(__is_nothrow_swappable<_Tp>::value
-               && __is_nothrow_swappable<_Compare>::value)
-      {
- using std::swap;
- swap(c, __pq.c);
- swap(comp, __pq.comp);
-      }
-
-    };
-
-
-
-
-  template<typename _Tp, typename _Sequence, typename _Compare>
-    inline void
-    swap(priority_queue<_Tp, _Sequence, _Compare>& __x,
-  priority_queue<_Tp, _Sequence, _Compare>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-  template<typename _Tp, typename _Sequence, typename _Compare,
-    typename _Alloc>
-    struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
-    : public uses_allocator<_Sequence, _Alloc>::type { };
-
-
-
-}
-# 65 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/queue" 2 3
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DeferredFinalize.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/DeferredFinalize.h"
-class nsISupports;
-
-namespace mozilla {
-
-
-
-
-typedef void* (*DeferredFinalizeAppendFunction)(void* aPointers, void* aThing);
-
-
-
-
-
-typedef bool (*DeferredFinalizeFunction)(uint32_t aSlice, void* aData);
-
-void DeferredFinalize(DeferredFinalizeAppendFunction aAppendFunc,
-                      DeferredFinalizeFunction aFunc,
-                      void* aThing);
-
-void DeferredFinalize(nsISupports* aSupports);
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h" 1
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
-namespace mozilla {
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
-template<typename T,
-         size_t IdealSegmentSize = 4096,
-         typename AllocPolicy = MallocAllocPolicy>
-class SegmentedVector : private AllocPolicy
-{
-  template<size_t SegmentCapacity>
-  struct SegmentImpl
-    : public mozilla::LinkedListElement<SegmentImpl<SegmentCapacity>>
-  {
-    SegmentImpl() : mLength(0) {}
-
-    ~SegmentImpl()
-    {
-      for (uint32_t i = 0; i < mLength; i++) {
-        (*this)[i].~T();
-      }
-    }
-
-    uint32_t Length() const { return mLength; }
-
-    T* Elems() { return reinterpret_cast<T*>(&mStorage.mBuf); }
-
-    T& operator[](size_t aIndex)
-    {
-      do { } while (0);
-      return Elems()[aIndex];
-    }
-
-    const T& operator[](size_t aIndex) const
-    {
-      do { } while (0);
-      return Elems()[aIndex];
-    }
-
-    template<typename U>
-    void Append(U&& aU)
-    {
-      do { } while (0);
-
-      mLength++;
-      T* elem = &(*this)[mLength - 1];
-      new (elem) T(mozilla::Forward<U>(aU));
-    }
-
-    void PopLast()
-    {
-      do { } while (0);
-      (*this)[mLength - 1].~T();
-      mLength--;
-    }
-
-    uint32_t mLength;
-
-
-    union Storage
-    {
-      char mBuf[sizeof(T) * SegmentCapacity];
-      mozilla::AlignedElem<mozilla::AlignmentFinder<T>::alignment> mAlign;
-    } mStorage;
-
-    static_assert(mozilla::AlignmentFinder<T>::alignment == mozilla::AlignmentFinder<Storage>::alignment,
-                  "SegmentedVector provides incorrect alignment");
-  };
-
-
-
-
-  static const size_t kSingleElementSegmentSize = sizeof(SegmentImpl<1>);
-  static const size_t kSegmentCapacity =
-    kSingleElementSegmentSize <= IdealSegmentSize
-    ? (IdealSegmentSize - kSingleElementSegmentSize) / sizeof(T) + 1
-    : 1;
-
-  typedef SegmentImpl<kSegmentCapacity> Segment;
-
-public:
-
-
-
-
-  explicit SegmentedVector(size_t aIdealSegmentSize = 0)
-  {
-
-
-
-    do { } while (0);
-
-
-
-  }
-
-  ~SegmentedVector() { Clear(); }
-
-  bool IsEmpty() const { return !mSegments.getFirst(); }
-
-
-
-  size_t Length() const
-  {
-    size_t n = 0;
-    for (auto segment = mSegments.getFirst();
-         segment;
-         segment = segment->getNext()) {
-      n += segment->Length();
-    }
-    return n;
-  }
-
-
-
-  template<typename U>
-  __attribute__ ((warn_unused_result)) bool Append(U&& aU)
-  {
-    Segment* last = mSegments.getLast();
-    if (!last || last->Length() == kSegmentCapacity) {
-      last = this->template pod_malloc<Segment>(1);
-      if (!last) {
-        return false;
-      }
-      new (last) Segment();
-      mSegments.insertBack(last);
-    }
-    last->Append(mozilla::Forward<U>(aU));
-    return true;
-  }
-
-
-
-  template<typename U>
-  void InfallibleAppend(U&& aU)
-  {
-    bool ok = Append(mozilla::Forward<U>(aU));
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(ok)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ok))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "ok" ")"); do { *((volatile int*) __null) = 183; ::abort(); } while (0); } } while (0);
-  }
-
-  void Clear()
-  {
-    Segment* segment;
-    while ((segment = mSegments.popFirst())) {
-      segment->~Segment();
-      this->free_(segment);
-    }
-  }
-
-  T& GetLast()
-  {
-    do { } while (0);
-    Segment* last = mSegments.getLast();
-    return (*last)[last->Length() - 1];
-  }
-
-  const T& GetLast() const
-  {
-    do { } while (0);
-    Segment* last = mSegments.getLast();
-    return (*last)[last->Length() - 1];
-  }
-
-  void PopLast()
-  {
-    do { } while (0);
-    Segment* last = mSegments.getLast();
-    last->PopLast();
-    if (!last->Length()) {
-      mSegments.popLast();
-      last->~Segment();
-      this->free_(last);
-    }
-  }
-
-
-
-  void PopLastN(uint32_t aNumElements)
-  {
-    do { } while (0);
-
-    Segment* last;
-
-
-
-
-    do {
-      last = mSegments.getLast();
-
-
-      if (!last) {
-        return;
-      }
-
-
-
-      uint32_t segmentLen = last->Length();
-      if (segmentLen > aNumElements) {
-        break;
-      }
-
-
-      mSegments.popLast();
-      last->~Segment();
-      this->free_(last);
-
-      do { } while (0);
-      aNumElements -= segmentLen;
-      if (aNumElements == 0) {
-        return;
-      }
-    } while (true);
-
-
-
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-    for (uint32_t i = 0; i < aNumElements; ++i) {
-      last->PopLast();
-    }
-    do { } while (0);
-  }
-# 278 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SegmentedVector.h"
-  class IterImpl
-  {
-    friend class SegmentedVector;
-
-    Segment* mSegment;
-    size_t mIndex;
-
-    explicit IterImpl(SegmentedVector* aVector)
-      : mSegment(aVector->mSegments.getFirst())
-      , mIndex(0)
-    {}
-
-  public:
-    bool Done() const { return !mSegment; }
-
-    T& Get()
-    {
-      do { } while (0);
-      return (*mSegment)[mIndex];
-    }
-
-    const T& Get() const
-    {
-      do { } while (0);
-      return (*mSegment)[mIndex];
-    }
-
-    void Next()
-    {
-      do { } while (0);
-      mIndex++;
-      if (mIndex == mSegment->Length()) {
-        mSegment = mSegment->getNext();
-        mIndex = 0;
-      }
-    }
-  };
-
-  IterImpl Iter() { return IterImpl(this); }
-
-
-
-
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return mSegments.sizeOfExcludingThis(aMallocSizeOf);
-  }
-
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-  }
-
-private:
-  mozilla::LinkedList<Segment> mSegments;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
-class nsCycleCollectionNoteRootCallback;
-class nsIException;
-class nsIRunnable;
-class nsThread;
-class nsWrapperCache;
-
-namespace js {
-struct Class;
-}
-
-namespace mozilla {
-
-class JSGCThingParticipant: public nsCycleCollectionParticipant
-{
-public:
-  constexpr JSGCThingParticipant()
-    : nsCycleCollectionParticipant(false) {}
-
-  virtual void Root(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void Unlink(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void Unroot(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void DeleteCycleCollectable(void* aPtr) override
-  {
-    do { } while (0);
-  }
-
-  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
-    override;
-
-  virtual const char* ClassName() override { return "JSGCThingParticipant"; };
-};
-
-class JSZoneParticipant : public nsCycleCollectionParticipant
-{
-public:
-  constexpr JSZoneParticipant(): nsCycleCollectionParticipant(false)
-  {
-  }
-
-  virtual void Root(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void Unlink(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void Unroot(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual void DeleteCycleCollectable(void*) override
-  {
-    do { } while (0);
-  }
-
-  virtual nsresult TraverseNative(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
-    override;
-
-  virtual const char* ClassName() override { return "JSZoneParticipant"; };
-};
-
-class IncrementalFinalizeRunnable;
-
-
-struct CycleCollectorResults
-{
-  CycleCollectorResults()
-  {
-
-
-    Init();
-  }
-
-  void Init()
-  {
-    mForcedGC = false;
-    mMergedZones = false;
-    mAnyManual = false;
-    mVisitedRefCounted = 0;
-    mVisitedGCed = 0;
-    mFreedRefCounted = 0;
-    mFreedGCed = 0;
-    mFreedJSZones = 0;
-    mNumSlices = 1;
-
-
-  }
-
-  bool mForcedGC;
-  bool mMergedZones;
-  bool mAnyManual;
-  uint32_t mVisitedRefCounted;
-  uint32_t mVisitedGCed;
-  uint32_t mFreedRefCounted;
-  uint32_t mFreedGCed;
-  uint32_t mFreedJSZones;
-  uint32_t mNumSlices;
-};
-
-class CycleCollectedJSContext
-{
-  friend class JSGCThingParticipant;
-  friend class JSZoneParticipant;
-  friend class IncrementalFinalizeRunnable;
-protected:
-  CycleCollectedJSContext();
-  virtual ~CycleCollectedJSContext();
-
-
-  nsresult Initialize(JSRuntime* aParentRuntime,
-                      uint32_t aMaxBytes,
-                      uint32_t aMaxNurseryBytes);
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-  void UnmarkSkippableJSHolders();
-
-  virtual void
-  TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& aCb) {}
-  virtual void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) {}
-
-  virtual void CustomGCCallback(JSGCStatus aStatus) {}
-  virtual void CustomOutOfMemoryCallback() {}
-  virtual void CustomLargeAllocationFailureCallback() {}
-
-  std::queue<nsCOMPtr<nsIRunnable>> mPromiseMicroTaskQueue;
-  std::queue<nsCOMPtr<nsIRunnable>> mDebuggerPromiseMicroTaskQueue;
-
-private:
-  void
-  DescribeGCThing(bool aIsMarked, JS::GCCellPtr aThing,
-                  nsCycleCollectionTraversalCallback& aCb) const;
-
-  virtual bool
-  DescribeCustomObjects(JSObject* aObject, const js::Class* aClasp,
-                        char (&aName)[72]) const
-  {
-    return false;
-  }
-
-  void
-  NoteGCThingJSChildren(JS::GCCellPtr aThing,
-                        nsCycleCollectionTraversalCallback& aCb) const;
-
-  void
-  NoteGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
-                           nsCycleCollectionTraversalCallback& aCb) const;
-
-  virtual bool
-  NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
-                                 nsCycleCollectionTraversalCallback& aCb) const
-  {
-    return false;
-  }
-
-  enum TraverseSelect {
-    TRAVERSE_CPP,
-    TRAVERSE_FULL
-  };
-
-  void
-  TraverseGCThing(TraverseSelect aTs, JS::GCCellPtr aThing,
-                  nsCycleCollectionTraversalCallback& aCb);
-
-  void
-  TraverseZone(JS::Zone* aZone, nsCycleCollectionTraversalCallback& aCb);
-
-  static void
-  TraverseObjectShim(void* aData, JS::GCCellPtr aThing);
-
-  void TraverseNativeRoots(nsCycleCollectionNoteRootCallback& aCb);
-
-  static void TraceBlackJS(JSTracer* aTracer, void* aData);
-  static void TraceGrayJS(JSTracer* aTracer, void* aData);
-  static void GCCallback(JSContext* aContext, JSGCStatus aStatus, void* aData);
-  static void GCSliceCallback(JSContext* aContext, JS::GCProgress aProgress,
-                              const JS::GCDescription& aDesc);
-  static void GCNurseryCollectionCallback(JSContext* aContext,
-                                          JS::GCNurseryProgress aProgress,
-                                          JS::gcreason::Reason aReason);
-  static void OutOfMemoryCallback(JSContext* aContext, void* aData);
-  static void LargeAllocationFailureCallback(void* aData);
-
-
-
-  static size_t SizeofExternalStringCallback(JSString* aStr,
-                                             mozilla::MallocSizeOf aMallocSizeOf);
-
-  static bool ContextCallback(JSContext* aCx, unsigned aOperation,
-                              void* aData);
-  static JSObject* GetIncumbentGlobalCallback(JSContext* aCx);
-  static bool EnqueuePromiseJobCallback(JSContext* aCx,
-                                        JS::HandleObject aJob,
-                                        JS::HandleObject aAllocationSite,
-                                        JS::HandleObject aIncumbentGlobal,
-                                        void* aData);
-  static void PromiseRejectionTrackerCallback(JSContext* aCx,
-                                              JS::HandleObject aPromise,
-                                              PromiseRejectionHandlingState state,
-                                              void* aData);
-
-  virtual void TraceNativeBlackRoots(JSTracer* aTracer) { };
-  void TraceNativeGrayRoots(JSTracer* aTracer);
-
-  void AfterProcessMicrotask(uint32_t aRecursionDepth);
-public:
-  void ProcessStableStateQueue();
-private:
-  void ProcessMetastableStateQueue(uint32_t aRecursionDepth);
-
-public:
-  enum DeferredFinalizeType {
-    FinalizeIncrementally,
-    FinalizeNow,
-  };
-
-  void FinalizeDeferredThings(DeferredFinalizeType aType);
-
-
-
-  enum class OOMState : uint32_t {
-
-    OK,
-# 271 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
-    Reporting,
-# 281 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CycleCollectedJSContext.h"
-    Reported,
-
-
-
-
-
-    Recovered
-  };
-
-private:
-  void AnnotateAndSetOutOfMemory(OOMState* aStatePtr, OOMState aNewState);
-  void OnGC(JSGCStatus aStatus);
-  void OnOutOfMemory();
-  void OnLargeAllocationFailure();
-
-public:
-  void AddJSHolder(void* aHolder, nsScriptObjectTracer* aTracer);
-  void RemoveJSHolder(void* aHolder);
-
-
-
-
-
-  already_AddRefed<nsIException> GetPendingException() const;
-  void SetPendingException(nsIException* aException);
-
-  std::queue<nsCOMPtr<nsIRunnable>>& GetPromiseMicroTaskQueue();
-  std::queue<nsCOMPtr<nsIRunnable>>& GetDebuggerPromiseMicroTaskQueue();
-
-  nsCycleCollectionParticipant* GCThingParticipant();
-  nsCycleCollectionParticipant* ZoneParticipant();
-
-  nsresult TraverseRoots(nsCycleCollectionNoteRootCallback& aCb);
-  virtual bool UsefulToMergeZones() const;
-  void FixWeakMappingGrayBits() const;
-  void CheckGrayBits() const;
-  bool AreGCGrayBitsValid() const;
-  void GarbageCollect(uint32_t aReason) const;
-
-  void NurseryWrapperAdded(nsWrapperCache* aCache);
-  void NurseryWrapperPreserved(JSObject* aWrapper);
-  void JSObjectsTenured();
-
-  void DeferredFinalize(DeferredFinalizeAppendFunction aAppendFunc,
-                        DeferredFinalizeFunction aFunc,
-                        void* aThing);
-  void DeferredFinalize(nsISupports* aSupports);
-
-  void DumpJSHeap(FILE* aFile);
-
-  virtual void PrepareForForgetSkippable() = 0;
-  virtual void BeginCycleCollectionCallback() = 0;
-  virtual void EndCycleCollectionCallback(CycleCollectorResults& aResults) = 0;
-  virtual void DispatchDeferredDeletion(bool aContinuation, bool aPurge = false) = 0;
-
-  JSContext* Context() const
-  {
-    do { } while (0);
-    return mJSContext;
-  }
-
-  JS::RootingContext* RootingCx() const
-  {
-    do { } while (0);
-    return JS::RootingContext::get(mJSContext);
-  }
-
-  bool MicroTaskCheckpointDisabled() const
-  {
-    return mDisableMicroTaskCheckpoint;
-  }
-
-  void DisableMicroTaskCheckpoint(bool aDisable)
-  {
-    mDisableMicroTaskCheckpoint = aDisable;
-  }
-
-  class AutoDisableMicroTaskCheckpoint
-  {
-    public:
-    AutoDisableMicroTaskCheckpoint()
-    : mCCJSCX(CycleCollectedJSContext::Get())
-    {
-      mOldValue = mCCJSCX->MicroTaskCheckpointDisabled();
-      mCCJSCX->DisableMicroTaskCheckpoint(true);
-    }
-
-    ~AutoDisableMicroTaskCheckpoint()
-    {
-      mCCJSCX->DisableMicroTaskCheckpoint(mOldValue);
-    }
-
-    CycleCollectedJSContext* mCCJSCX;
-    bool mOldValue;
-  };
-
-protected:
-  JSContext* MaybeContext() const { return mJSContext; }
-
-public:
-
-  virtual void BeforeProcessTask(bool aMightBlock) { };
-  virtual void AfterProcessTask(uint32_t aRecursionDepth);
-
-
-  void AfterProcessMicrotask();
-
-  uint32_t RecursionDepth();
-
-
-  void RunInStableState(already_AddRefed<nsIRunnable>&& aRunnable);
-
-
-  void RunInMetastableState(already_AddRefed<nsIRunnable>&& aRunnable);
-
-
-
-  static CycleCollectedJSContext* Get();
-
-
-  void AddZoneWaitingForGC(JS::Zone* aZone)
-  {
-    mZonesWaitingForGC.PutEntry(aZone);
-  }
-
-
-
-
-
-  void PrepareWaitingZonesForGC();
-
-
-  virtual void DispatchToMicroTask(already_AddRefed<nsIRunnable> aRunnable);
-
-
-
-
-
-
-
-  JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mUncaughtRejections;
-
-
-
-
-  JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mConsumedRejections;
-  nsTArray<nsCOMPtr<nsISupports >> mUncaughtRejectionObservers;
-
-private:
-  JSGCThingParticipant mGCThingCycleCollectorGlobal;
-
-  JSZoneParticipant mJSZoneCycleCollectorGlobal;
-
-  JSContext* mJSContext;
-
-  JS::GCSliceCallback mPrevGCSliceCallback;
-  JS::GCNurseryCollectionCallback mPrevGCNurseryCollectionCallback;
-
-  nsDataHashtable<nsPtrHashKey<void>, nsScriptObjectTracer*> mJSHolders;
-
-  typedef nsDataHashtable<nsFuncPtrHashKey<DeferredFinalizeFunction>, void*>
-    DeferredFinalizerTable;
-  DeferredFinalizerTable mDeferredFinalizerTable;
-
-  RefPtr<IncrementalFinalizeRunnable> mFinalizeRunnable;
-
-  nsCOMPtr<nsIException> mPendingException;
-  nsThread* mOwningThread;
-
-  struct RunInMetastableStateData
-  {
-    nsCOMPtr<nsIRunnable> mRunnable;
-    uint32_t mRecursionDepth;
-  };
-
-  nsTArray<nsCOMPtr<nsIRunnable>> mStableStateEvents;
-  nsTArray<RunInMetastableStateData> mMetastableStateEvents;
-  uint32_t mBaseRecursionDepth;
-  bool mDoingStableStates;
-
-  bool mDisableMicroTaskCheckpoint;
-
-  OOMState mOutOfMemoryState;
-  OOMState mLargeAllocationFailureState;
-
-  static const size_t kSegmentSize = 512;
-  SegmentedVector<nsWrapperCache*, kSegmentSize, InfallibleAllocPolicy>
-    mNurseryObjects;
-  SegmentedVector<JS::PersistentRooted<JSObject*>, kSegmentSize,
-                  InfallibleAllocPolicy>
-    mPreservedNurseryObjects;
-
-  nsTHashtable<nsPtrHashKey<JS::Zone>> mZonesWaitingForGC;
-
-  struct EnvironmentPreparer : public js::ScriptEnvironmentPreparer {
-    void invoke(JS::HandleObject scope, Closure& closure) override;
-  };
-  EnvironmentPreparer mEnvironmentPreparer;
-};
-
-void TraceScriptHolder(nsISupports* aHolder, JSTracer* aTracer);
-
-
-inline bool AddToCCKind(JS::TraceKind aKind)
-{
-  return aKind == JS::TraceKind::Object ||
-         aKind == JS::TraceKind::Script ||
-         aKind == JS::TraceKind::Scope ||
-         aKind == JS::TraceKind::RegExpShared;
-}
-
-bool
-GetBuildId(JS::BuildIdCharVector* aBuildID);
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/PrototypeList.h" 1
-
-
-
-
-
-namespace mozilla {
-namespace dom {
-namespace prototypes {
-
-namespace id {
-
-enum ID : uint16_t
-{
-  _ID_Start = 0,
-  ANGLE_instanced_arrays = _ID_Start,
-  AccessibleNode,
-  Addon,
-  AddonEvent,
-  AddonInstall,
-  AddonManager,
-  AnalyserNode,
-  Animation,
-  AnimationEffectReadOnly,
-  AnimationEffectTiming,
-  AnimationEffectTimingReadOnly,
-  AnimationEvent,
-  AnimationPlaybackEvent,
-  AnimationTimeline,
-  AnonymousContent,
-  Attr,
-  AudioBuffer,
-  AudioBufferSourceNode,
-  AudioContext,
-  AudioDestinationNode,
-  AudioListener,
-  AudioNode,
-  AudioParam,
-  AudioProcessingEvent,
-  AudioScheduledSourceNode,
-  AudioStreamTrack,
-  AudioTrack,
-  AudioTrackList,
-  AudioWorkletGlobalScope,
-  AutocompleteErrorEvent,
-  BarProp,
-  BaseAudioContext,
-  BatteryManager,
-  BeforeUnloadEvent,
-  BiquadFilterNode,
-  Blob,
-  BlobEvent,
-  BoxObject,
-  BroadcastChannel,
-  BrowserElementAudioChannel,
-  BrowserFeedWriter,
-  CDATASection,
-  CSS2Properties,
-  CSSAnimation,
-  CSSConditionRule,
-  CSSCounterStyleRule,
-  CSSFontFaceRule,
-  CSSFontFeatureValuesRule,
-  CSSGroupingRule,
-  CSSImportRule,
-  CSSKeyframeRule,
-  CSSKeyframesRule,
-  CSSLexer,
-  CSSMediaRule,
-  CSSMozDocumentRule,
-  CSSNamespaceRule,
-  CSSPageRule,
-  CSSPrimitiveValue,
-  CSSPseudoElement,
-  CSSRule,
-  CSSRuleList,
-  CSSStyleDeclaration,
-  CSSStyleRule,
-  CSSStyleSheet,
-  CSSSupportsRule,
-  CSSTransition,
-  CSSValue,
-  CSSValueList,
-  Cache,
-  CacheStorage,
-  CanvasCaptureMediaStream,
-  CanvasGradient,
-  CanvasPattern,
-  CanvasRenderingContext2D,
-  CaretPosition,
-  CaretStateChangedEvent,
-  ChannelMergerNode,
-  ChannelSplitterNode,
-  CharacterData,
-  CheckerboardReportService,
-  ChromeNodeList,
-  ChromeWorker,
-  Client,
-  Clients,
-  ClipboardEvent,
-  CloseEvent,
-  CommandEvent,
-  Comment,
-  CompositionEvent,
-  ConstantSourceNode,
-  ContainerBoxObject,
-  ConvolverNode,
-  Coordinates,
-  CreateOfferRequest,
-  Crypto,
-  CryptoKey,
-  CustomElementRegistry,
-  CustomEvent,
-  DOMCursor,
-  DOMError,
-  DOMException,
-  DOMImplementation,
-  DOMMatrix,
-  DOMMatrixReadOnly,
-  DOMParser,
-  DOMPoint,
-  DOMPointReadOnly,
-  DOMQuad,
-  DOMRect,
-  DOMRectList,
-  DOMRectReadOnly,
-  DOMRequest,
-  DOMStringList,
-  DOMStringMap,
-  DOMTokenList,
-  DataChannel,
-  DataContainerEvent,
-  DataTransfer,
-  DataTransferItem,
-  DataTransferItemList,
-  DedicatedWorkerGlobalScope,
-  DelayNode,
-  DesktopNotification,
-  DesktopNotificationCenter,
-  DeviceAcceleration,
-  DeviceLightEvent,
-  DeviceMotionEvent,
-  DeviceOrientationEvent,
-  DeviceProximityEvent,
-  DeviceRotationRate,
-  Directory,
-  Document,
-  DocumentFragment,
-  DocumentTimeline,
-  DocumentType,
-  DominatorTree,
-  DragEvent,
-  DynamicsCompressorNode,
-  EXT_blend_minmax,
-  EXT_color_buffer_float,
-  EXT_color_buffer_half_float,
-  EXT_disjoint_timer_query,
-  EXT_frag_depth,
-  EXT_sRGB,
-  EXT_shader_texture_lod,
-  EXT_texture_filter_anisotropic,
-  Element,
-  ErrorEvent,
-  Event,
-  EventSource,
-  EventTarget,
-  Exception,
-  ExtendableEvent,
-  ExtendableMessageEvent,
-  External,
-  FetchController,
-  FetchEvent,
-  FetchObserver,
-  FetchSignal,
-  File,
-  FileList,
-  FileReader,
-  FileReaderSync,
-  FileSystem,
-  FileSystemDirectoryEntry,
-  FileSystemDirectoryReader,
-  FileSystemEntry,
-  FileSystemFileEntry,
-  FlyWebDiscoveryManager,
-  FlyWebFetchEvent,
-  FlyWebPublishedServer,
-  FlyWebWebSocketEvent,
-  FocusEvent,
-  FontFace,
-  FontFaceSet,
-  FontFaceSetIterator,
-  FontFaceSetLoadEvent,
-  FormData,
-  FormDataIterator,
-  GainNode,
-  Gamepad,
-  GamepadAxisMoveEvent,
-  GamepadButton,
-  GamepadButtonEvent,
-  GamepadEvent,
-  GamepadHapticActuator,
-  GamepadPose,
-  GamepadServiceTest,
-  Geolocation,
-  GetUserMediaRequest,
-  Grid,
-  GridArea,
-  GridDimension,
-  GridLine,
-  GridLines,
-  GridTrack,
-  GridTracks,
-  GroupedHistoryEvent,
-  HTMLAllCollection,
-  HTMLAnchorElement,
-  HTMLAppletElement,
-  HTMLAreaElement,
-  HTMLAudioElement,
-  HTMLBRElement,
-  HTMLBaseElement,
-  HTMLBodyElement,
-  HTMLButtonElement,
-  HTMLCanvasElement,
-  HTMLCollection,
-  HTMLContentElement,
-  HTMLDListElement,
-  HTMLDataElement,
-  HTMLDataListElement,
-  HTMLDetailsElement,
-  HTMLDialogElement,
-  HTMLDirectoryElement,
-  HTMLDivElement,
-  HTMLDocument,
-  HTMLElement,
-  HTMLEmbedElement,
-  HTMLFieldSetElement,
-  HTMLFontElement,
-  HTMLFormControlsCollection,
-  HTMLFormElement,
-  HTMLFrameElement,
-  HTMLFrameSetElement,
-  HTMLHRElement,
-  HTMLHeadElement,
-  HTMLHeadingElement,
-  HTMLHtmlElement,
-  HTMLIFrameElement,
-  HTMLImageElement,
-  HTMLInputElement,
-  HTMLLIElement,
-  HTMLLabelElement,
-  HTMLLegendElement,
-  HTMLLinkElement,
-  HTMLMapElement,
-  HTMLMediaElement,
-  HTMLMenuElement,
-  HTMLMenuItemElement,
-  HTMLMetaElement,
-  HTMLMeterElement,
-  HTMLModElement,
-  HTMLOListElement,
-  HTMLObjectElement,
-  HTMLOptGroupElement,
-  HTMLOptionElement,
-  HTMLOptionsCollection,
-  HTMLOutputElement,
-  HTMLParagraphElement,
-  HTMLParamElement,
-  HTMLPictureElement,
-  HTMLPreElement,
-  HTMLProgressElement,
-  HTMLQuoteElement,
-  HTMLScriptElement,
-  HTMLSelectElement,
-  HTMLShadowElement,
-  HTMLSourceElement,
-  HTMLSpanElement,
-  HTMLStyleElement,
-  HTMLTableCaptionElement,
-  HTMLTableCellElement,
-  HTMLTableColElement,
-  HTMLTableElement,
-  HTMLTableRowElement,
-  HTMLTableSectionElement,
-  HTMLTemplateElement,
-  HTMLTextAreaElement,
-  HTMLTimeElement,
-  HTMLTitleElement,
-  HTMLTrackElement,
-  HTMLUListElement,
-  HTMLUnknownElement,
-  HTMLVideoElement,
-  HashChangeEvent,
-  Headers,
-  HeadersIterator,
-  HeapSnapshot,
-  HiddenPluginEvent,
-  History,
-  IDBCursor,
-  IDBCursorWithValue,
-  IDBDatabase,
-  IDBFactory,
-  IDBFileHandle,
-  IDBFileRequest,
-  IDBIndex,
-  IDBKeyRange,
-  IDBLocaleAwareKeyRange,
-  IDBMutableFile,
-  IDBObjectStore,
-  IDBOpenDBRequest,
-  IDBRequest,
-  IDBTransaction,
-  IDBVersionChangeEvent,
-  IIRFilterNode,
-  IdleDeadline,
-  ImageBitmap,
-  ImageBitmapRenderingContext,
-  ImageCapture,
-  ImageCaptureError,
-  ImageCaptureErrorEvent,
-  ImageData,
-  ImageDocument,
-  InputEvent,
-  InstallTriggerImpl,
-  IntersectionObserver,
-  IntersectionObserverEntry,
-  IntlUtils,
-  KeyboardEvent,
-  KeyframeEffect,
-  KeyframeEffectReadOnly,
-  LegacyMozTCPSocket,
-  ListBoxObject,
-  LocalMediaStream,
-  Location,
-  MOZ_debug_get,
-  MediaDeviceInfo,
-  MediaDevices,
-  MediaElementAudioSourceNode,
-  MediaEncryptedEvent,
-  MediaError,
-  MediaKeyError,
-  MediaKeyMessageEvent,
-  MediaKeySession,
-  MediaKeyStatusMap,
-  MediaKeyStatusMapIterator,
-  MediaKeySystemAccess,
-  MediaKeys,
-  MediaList,
-  MediaQueryList,
-  MediaRecorder,
-  MediaSource,
-  MediaStream,
-  MediaStreamAudioDestinationNode,
-  MediaStreamAudioSourceNode,
-  MediaStreamError,
-  MediaStreamEvent,
-  MediaStreamList,
-  MediaStreamTrack,
-  MediaStreamTrackEvent,
-  MenuBoxObject,
-  MessageChannel,
-  MessageEvent,
-  MessagePort,
-  MimeType,
-  MimeTypeArray,
-  MouseEvent,
-  MouseScrollEvent,
-  MozCanvasPrintState,
-  MozPowerManager,
-  MozSelfSupport,
-  MozTimeManager,
-  MozWakeLock,
-  MutationEvent,
-  MutationObserver,
-  MutationRecord,
-  NamedNodeMap,
-  Navigator,
-  NetworkInformation,
-  Node,
-  NodeIterator,
-  NodeList,
-  Notification,
-  NotificationEvent,
-  NotifyPaintEvent,
-  OES_element_index_uint,
-  OES_standard_derivatives,
-  OES_texture_float,
-  OES_texture_float_linear,
-  OES_texture_half_float,
-  OES_texture_half_float_linear,
-  OES_vertex_array_object,
-  OfflineAudioCompletionEvent,
-  OfflineAudioContext,
-  OfflineResourceList,
-  OffscreenCanvas,
-  OnlyForUseInConstructor,
-  OscillatorNode,
-  PageTransitionEvent,
-  PaintRequest,
-  PaintRequestList,
-  PaintWorkletGlobalScope,
-  PannerNode,
-  Path2D,
-  PeerConnectionImpl,
-  PeerConnectionObserver,
-  Performance,
-  PerformanceEntry,
-  PerformanceEntryEvent,
-  PerformanceMark,
-  PerformanceMeasure,
-  PerformanceNavigation,
-  PerformanceObserver,
-  PerformanceObserverEntryList,
-  PerformanceResourceTiming,
-  PerformanceTiming,
-  PeriodicWave,
-  PermissionStatus,
-  Permissions,
-  Plugin,
-  PluginArray,
-  PluginCrashedEvent,
-  PointerEvent,
-  PopStateEvent,
-  PopupBlockedEvent,
-  PopupBoxObject,
-  Position,
-  PositionError,
-  PrecompiledScript,
-  Presentation,
-  PresentationAvailability,
-  PresentationConnection,
-  PresentationConnectionAvailableEvent,
-  PresentationConnectionCloseEvent,
-  PresentationConnectionList,
-  PresentationDeviceInfoManager,
-  PresentationReceiver,
-  PresentationRequest,
-  ProcessingInstruction,
-  ProgressEvent,
-  PromiseNativeHandler,
-  PushEvent,
-  PushManager,
-  PushManagerImpl,
-  PushMessageData,
-  PushSubscription,
-  PushSubscriptionOptions,
-  RGBColor,
-  RTCCertificate,
-  RTCDTMFSender,
-  RTCDTMFToneChangeEvent,
-  RTCDataChannelEvent,
-  RTCIceCandidate,
-  RTCIdentityProviderRegistrar,
-  RTCPeerConnection,
-  RTCPeerConnectionIceEvent,
-  RTCPeerConnectionStatic,
-  RTCRtpReceiver,
-  RTCRtpSender,
-  RTCSessionDescription,
-  RTCStatsReport,
-  RTCTrackEvent,
-  RadioNodeList,
-  Range,
-  RecordErrorEvent,
-  Rect,
-  Request,
-  Response,
-  SEChannel,
-  SEManager,
-  SEReader,
-  SEResponse,
-  SESession,
-  SVGAElement,
-  SVGAngle,
-  SVGAnimateElement,
-  SVGAnimateMotionElement,
-  SVGAnimateTransformElement,
-  SVGAnimatedAngle,
-  SVGAnimatedBoolean,
-  SVGAnimatedEnumeration,
-  SVGAnimatedInteger,
-  SVGAnimatedLength,
-  SVGAnimatedLengthList,
-  SVGAnimatedNumber,
-  SVGAnimatedNumberList,
-  SVGAnimatedPreserveAspectRatio,
-  SVGAnimatedRect,
-  SVGAnimatedString,
-  SVGAnimatedTransformList,
-  SVGAnimationElement,
-  SVGCircleElement,
-  SVGClipPathElement,
-  SVGComponentTransferFunctionElement,
-  SVGDefsElement,
-  SVGDescElement,
-  SVGElement,
-  SVGEllipseElement,
-  SVGFEBlendElement,
-  SVGFEColorMatrixElement,
-  SVGFEComponentTransferElement,
-  SVGFECompositeElement,
-  SVGFEConvolveMatrixElement,
-  SVGFEDiffuseLightingElement,
-  SVGFEDisplacementMapElement,
-  SVGFEDistantLightElement,
-  SVGFEDropShadowElement,
-  SVGFEFloodElement,
-  SVGFEFuncAElement,
-  SVGFEFuncBElement,
-  SVGFEFuncGElement,
-  SVGFEFuncRElement,
-  SVGFEGaussianBlurElement,
-  SVGFEImageElement,
-  SVGFEMergeElement,
-  SVGFEMergeNodeElement,
-  SVGFEMorphologyElement,
-  SVGFEOffsetElement,
-  SVGFEPointLightElement,
-  SVGFESpecularLightingElement,
-  SVGFESpotLightElement,
-  SVGFETileElement,
-  SVGFETurbulenceElement,
-  SVGFilterElement,
-  SVGForeignObjectElement,
-  SVGGElement,
-  SVGGeometryElement,
-  SVGGradientElement,
-  SVGGraphicsElement,
-  SVGImageElement,
-  SVGLength,
-  SVGLengthList,
-  SVGLineElement,
-  SVGLinearGradientElement,
-  SVGMPathElement,
-  SVGMarkerElement,
-  SVGMaskElement,
-  SVGMatrix,
-  SVGMetadataElement,
-  SVGNumber,
-  SVGNumberList,
-  SVGPathElement,
-  SVGPathSeg,
-  SVGPathSegArcAbs,
-  SVGPathSegArcRel,
-  SVGPathSegClosePath,
-  SVGPathSegCurvetoCubicAbs,
-  SVGPathSegCurvetoCubicRel,
-  SVGPathSegCurvetoCubicSmoothAbs,
-  SVGPathSegCurvetoCubicSmoothRel,
-  SVGPathSegCurvetoQuadraticAbs,
-  SVGPathSegCurvetoQuadraticRel,
-  SVGPathSegCurvetoQuadraticSmoothAbs,
-  SVGPathSegCurvetoQuadraticSmoothRel,
-  SVGPathSegLinetoAbs,
-  SVGPathSegLinetoHorizontalAbs,
-  SVGPathSegLinetoHorizontalRel,
-  SVGPathSegLinetoRel,
-  SVGPathSegLinetoVerticalAbs,
-  SVGPathSegLinetoVerticalRel,
-  SVGPathSegList,
-  SVGPathSegMovetoAbs,
-  SVGPathSegMovetoRel,
-  SVGPatternElement,
-  SVGPoint,
-  SVGPointList,
-  SVGPolygonElement,
-  SVGPolylineElement,
-  SVGPreserveAspectRatio,
-  SVGRadialGradientElement,
-  SVGRect,
-  SVGRectElement,
-  SVGSVGElement,
-  SVGScriptElement,
-  SVGSetElement,
-  SVGStopElement,
-  SVGStringList,
-  SVGStyleElement,
-  SVGSwitchElement,
-  SVGSymbolElement,
-  SVGTSpanElement,
-  SVGTextContentElement,
-  SVGTextElement,
-  SVGTextPathElement,
-  SVGTextPositioningElement,
-  SVGTitleElement,
-  SVGTransform,
-  SVGTransformList,
-  SVGUseElement,
-  SVGViewElement,
-  ScopedCredential,
-  ScopedCredentialInfo,
-  Screen,
-  ScreenOrientation,
-  ScriptProcessorNode,
-  ScrollAreaEvent,
-  ScrollBoxObject,
-  ScrollViewChangeEvent,
-  Selection,
-  ServiceWorker,
-  ServiceWorkerContainer,
-  ServiceWorkerGlobalScope,
-  ServiceWorkerRegistration,
-  ShadowRoot,
-  SharedWorker,
-  SharedWorkerGlobalScope,
-  SimpleGestureEvent,
-  SourceBuffer,
-  SourceBufferList,
-  SpeechGrammar,
-  SpeechGrammarList,
-  SpeechRecognition,
-  SpeechRecognitionAlternative,
-  SpeechRecognitionError,
-  SpeechRecognitionEvent,
-  SpeechRecognitionResult,
-  SpeechRecognitionResultList,
-  SpeechSynthesis,
-  SpeechSynthesisErrorEvent,
-  SpeechSynthesisEvent,
-  SpeechSynthesisUtterance,
-  SpeechSynthesisVoice,
-  StereoPannerNode,
-  Storage,
-  StorageEvent,
-  StorageManager,
-  StyleRuleChangeEvent,
-  StyleSheet,
-  StyleSheetApplicableStateChangeEvent,
-  StyleSheetChangeEvent,
-  StyleSheetList,
-  SubtleCrypto,
-  TCPServerSocket,
-  TCPServerSocketEvent,
-  TCPSocket,
-  TCPSocketErrorEvent,
-  TCPSocketEvent,
-  TestCImplementedInterface,
-  TestCImplementedInterface2,
-  TestChildInterface,
-  TestCppKeywordNamedMethodsInterface,
-  TestDeprecatedInterface,
-  TestExampleInterface,
-  TestExampleProxyInterface,
-  TestExampleWorkerInterface,
-  TestFunctions,
-  TestHTMLConstructorInterface,
-  TestIndexedAndNamedGetterAndSetterInterface,
-  TestIndexedAndNamedGetterInterface,
-  TestIndexedAndNamedSetterInterface,
-  TestIndexedGetterAndSetterAndNamedGetterInterface,
-  TestIndexedGetterInterface,
-  TestIndexedSetterInterface,
-  TestInterface,
-  TestInterfaceIterableDouble,
-  TestInterfaceIterableDoubleIterator,
-  TestInterfaceIterableDoubleUnion,
-  TestInterfaceIterableDoubleUnionIterator,
-  TestInterfaceIterableSingle,
-  TestInterfaceJS,
-  TestInterfaceJSMaplike,
-  TestInterfaceMaplike,
-  TestInterfaceMaplikeObject,
-  TestInterfaceSetlike,
-  TestInterfaceSetlikeNode,
-  TestInterfaceWithPromiseConstructorArg,
-  TestJSImplInterface,
-  TestJSImplInterface2,
-  TestJSImplInterface3,
-  TestJSImplInterface4,
-  TestJSImplInterface5,
-  TestJSImplInterface6,
-  TestJSImplNoInterfaceObject,
-  TestNamedDeleterInterface,
-  TestNamedDeleterWithRetvalInterface,
-  TestNamedGetterInterface,
-  TestNamedSetterInterface,
-  TestNavigator,
-  TestNavigatorWithConstructor,
-  TestNonWrapperCacheInterface,
-  TestParentInterface,
-  TestRenamedInterface,
-  TestSecureContextInterface,
-  TestWorkerExposedInterface,
-  Text,
-  TextClause,
-  TextDecoder,
-  TextEncoder,
-  TextMetrics,
-  TextTrack,
-  TextTrackCue,
-  TextTrackCueList,
-  TextTrackList,
-  TimeEvent,
-  TimeRanges,
-  Touch,
-  TouchEvent,
-  TouchList,
-  TrackEvent,
-  TransitionEvent,
-  TreeBoxObject,
-  TreeColumn,
-  TreeColumns,
-  TreeWalker,
-  U2F,
-  UDPMessageEvent,
-  UDPSocket,
-  UIEvent,
-  URL,
-  URLSearchParams,
-  URLSearchParamsIterator,
-  UserProximityEvent,
-  VRDisplay,
-  VRDisplayCapabilities,
-  VRDisplayEvent,
-  VREyeParameters,
-  VRFieldOfView,
-  VRFrameData,
-  VRMockController,
-  VRMockDisplay,
-  VRPose,
-  VRServiceTest,
-  VRStageParameters,
-  VTTCue,
-  VTTRegion,
-  ValidityState,
-  VideoPlaybackQuality,
-  VideoStreamTrack,
-  VideoTrack,
-  VideoTrackList,
-  WEBGL_color_buffer_float,
-  WEBGL_compressed_texture_astc,
-  WEBGL_compressed_texture_atc,
-  WEBGL_compressed_texture_etc,
-  WEBGL_compressed_texture_etc1,
-  WEBGL_compressed_texture_pvrtc,
-  WEBGL_compressed_texture_s3tc,
-  WEBGL_debug_renderer_info,
-  WEBGL_debug_shaders,
-  WEBGL_depth_texture,
-  WEBGL_draw_buffers,
-  WEBGL_lose_context,
-  WaveShaperNode,
-  WebAuthentication,
-  WebAuthnAssertion,
-  WebAuthnAttestation,
-  WebGL2RenderingContext,
-  WebGLActiveInfo,
-  WebGLBuffer,
-  WebGLContextEvent,
-  WebGLFramebuffer,
-  WebGLProgram,
-  WebGLQuery,
-  WebGLRenderbuffer,
-  WebGLRenderingContext,
-  WebGLSampler,
-  WebGLShader,
-  WebGLShaderPrecisionFormat,
-  WebGLSync,
-  WebGLTexture,
-  WebGLTransformFeedback,
-  WebGLUniformLocation,
-  WebGLVertexArrayObject,
-  WebKitCSSMatrix,
-  WebSocket,
-  WheelEvent,
-  Window,
-  WindowClient,
-  WindowRoot,
-  Worker,
-  WorkerDebuggerGlobalScope,
-  WorkerGlobalScope,
-  WorkerLocation,
-  WorkerNavigator,
-  Worklet,
-  WorkletGlobalScope,
-  XMLDocument,
-  XMLHttpRequest,
-  XMLHttpRequestEventTarget,
-  XMLHttpRequestUpload,
-  XMLSerializer,
-  XMLStylesheetProcessingInstruction,
-  XPathEvaluator,
-  XPathExpression,
-  XPathResult,
-  XSLTProcessor,
-  XULCommandEvent,
-  XULDocument,
-  XULElement,
-  mozRTCIceCandidate,
-  mozRTCPeerConnection,
-  mozRTCSessionDescription,
-  _ID_Count
-};
-
-}
-
-typedef id::ID ID;
-
-static_assert(id::_ID_Count < (uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->protoID) * 8)), "Too many prototypes!");
-
-}
-}
-}
-
-
-
-static_assert(8 < (uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->depth) * 8)), "Some inheritance chain is too long!");
-
-namespace mozilla {
-namespace dom {
-namespace constructors {
-
-namespace id {
-
-enum ID : uint16_t
-{
-  _ID_Start = prototypes::id::_ID_Count,
-  AccessibleNode = _ID_Start,
-  Addon,
-  AddonEvent,
-  AddonInstall,
-  AddonManager,
-  AddonManagerPermissions,
-  AnalyserNode,
-  Animation,
-  AnimationEffectReadOnly,
-  AnimationEffectTiming,
-  AnimationEffectTimingReadOnly,
-  AnimationEvent,
-  AnimationPlaybackEvent,
-  AnimationTimeline,
-  AnonymousContent,
-  Attr,
-  AudioBuffer,
-  AudioBufferSourceNode,
-  AudioContext,
-  AudioDestinationNode,
-  AudioListener,
-  AudioNode,
-  AudioParam,
-  AudioProcessingEvent,
-  AudioScheduledSourceNode,
-  AudioStreamTrack,
-  AudioTrack,
-  AudioTrackList,
-  AudioWorkletGlobalScope,
-  AutocompleteErrorEvent,
-  BarProp,
-  BaseAudioContext,
-  BatteryManager,
-  BeforeUnloadEvent,
-  BiquadFilterNode,
-  Blob,
-  BlobEvent,
-  BoxObject,
-  BroadcastChannel,
-  BrowserElementAudioChannel,
-  BrowserFeedWriter,
-  CDATASection,
-  CSS,
-  CSS2Properties,
-  CSSAnimation,
-  CSSConditionRule,
-  CSSCounterStyleRule,
-  CSSFontFaceRule,
-  CSSFontFeatureValuesRule,
-  CSSGroupingRule,
-  CSSImportRule,
-  CSSKeyframeRule,
-  CSSKeyframesRule,
-  CSSLexer,
-  CSSMediaRule,
-  CSSMozDocumentRule,
-  CSSNamespaceRule,
-  CSSPageRule,
-  CSSPrimitiveValue,
-  CSSPseudoElement,
-  CSSRule,
-  CSSRuleList,
-  CSSStyleDeclaration,
-  CSSStyleRule,
-  CSSStyleSheet,
-  CSSSupportsRule,
-  CSSTransition,
-  CSSValue,
-  CSSValueList,
-  Cache,
-  CacheStorage,
-  CanvasCaptureMediaStream,
-  CanvasGradient,
-  CanvasPattern,
-  CanvasRenderingContext2D,
-  CaretPosition,
-  CaretStateChangedEvent,
-  ChannelMergerNode,
-  ChannelSplitterNode,
-  CharacterData,
-  CheckerboardReportService,
-  ChromeNodeList,
-  ChromeUtils,
-  ChromeWindow,
-  ChromeWorker,
-  Client,
-  Clients,
-  ClipboardEvent,
-  CloseEvent,
-  CommandEvent,
-  Comment,
-  CompositionEvent,
-  ConstantSourceNode,
-  ConvolverNode,
-  CreateOfferRequest,
-  Crypto,
-  CryptoKey,
-  CustomElementRegistry,
-  CustomEvent,
-  DOMCursor,
-  DOMError,
-  DOMException,
-  DOMImplementation,
-  DOMMatrix,
-  DOMMatrixReadOnly,
-  DOMParser,
-  DOMPoint,
-  DOMPointReadOnly,
-  DOMQuad,
-  DOMRect,
-  DOMRectList,
-  DOMRectReadOnly,
-  DOMRequest,
-  DOMStringList,
-  DOMStringMap,
-  DOMTokenList,
-  DataChannel,
-  DataContainerEvent,
-  DataTransfer,
-  DataTransferItem,
-  DataTransferItemList,
-  DedicatedWorkerGlobalScope,
-  DelayNode,
-  DesktopNotification,
-  DesktopNotificationCenter,
-  DeviceLightEvent,
-  DeviceMotionEvent,
-  DeviceOrientationEvent,
-  DeviceProximityEvent,
-  Directory,
-  Document,
-  DocumentFragment,
-  DocumentTimeline,
-  DocumentType,
-  DominatorTree,
-  DragEvent,
-  DynamicsCompressorNode,
-  Element,
-  ErrorEvent,
-  Event,
-  EventSource,
-  EventTarget,
-  ExtendableEvent,
-  ExtendableMessageEvent,
-  External,
-  FetchController,
-  FetchEvent,
-  FetchObserver,
-  FetchSignal,
-  File,
-  FileList,
-  FileReader,
-  FileReaderSync,
-  FileSystem,
-  FileSystemDirectoryEntry,
-  FileSystemDirectoryReader,
-  FileSystemEntry,
-  FileSystemFileEntry,
-  FlyWebDiscoveryManager,
-  FlyWebFetchEvent,
-  FlyWebPublishedServer,
-  FlyWebWebSocketEvent,
-  FocusEvent,
-  FontFace,
-  FontFaceSet,
-  FontFaceSetLoadEvent,
-  FormData,
-  GainNode,
-  Gamepad,
-  GamepadAxisMoveEvent,
-  GamepadButton,
-  GamepadButtonEvent,
-  GamepadEvent,
-  GamepadHapticActuator,
-  GamepadPose,
-  GamepadServiceTest,
-  Grid,
-  GridArea,
-  GridDimension,
-  GridLine,
-  GridLines,
-  GridTrack,
-  GridTracks,
-  GroupedHistoryEvent,
-  HTMLAllCollection,
-  HTMLAnchorElement,
-  HTMLAppletElement,
-  HTMLAreaElement,
-  HTMLAudioElement,
-  HTMLBRElement,
-  HTMLBaseElement,
-  HTMLBodyElement,
-  HTMLButtonElement,
-  HTMLCanvasElement,
-  HTMLCollection,
-  HTMLContentElement,
-  HTMLDListElement,
-  HTMLDataElement,
-  HTMLDataListElement,
-  HTMLDetailsElement,
-  HTMLDialogElement,
-  HTMLDirectoryElement,
-  HTMLDivElement,
-  HTMLDocument,
-  HTMLElement,
-  HTMLEmbedElement,
-  HTMLFieldSetElement,
-  HTMLFontElement,
-  HTMLFormControlsCollection,
-  HTMLFormElement,
-  HTMLFrameElement,
-  HTMLFrameSetElement,
-  HTMLHRElement,
-  HTMLHeadElement,
-  HTMLHeadingElement,
-  HTMLHtmlElement,
-  HTMLIFrameElement,
-  HTMLImageElement,
-  HTMLInputElement,
-  HTMLLIElement,
-  HTMLLabelElement,
-  HTMLLegendElement,
-  HTMLLinkElement,
-  HTMLMapElement,
-  HTMLMediaElement,
-  HTMLMenuElement,
-  HTMLMenuItemElement,
-  HTMLMetaElement,
-  HTMLMeterElement,
-  HTMLModElement,
-  HTMLOListElement,
-  HTMLObjectElement,
-  HTMLOptGroupElement,
-  HTMLOptionElement,
-  HTMLOptionsCollection,
-  HTMLOutputElement,
-  HTMLParagraphElement,
-  HTMLParamElement,
-  HTMLPictureElement,
-  HTMLPreElement,
-  HTMLProgressElement,
-  HTMLQuoteElement,
-  HTMLScriptElement,
-  HTMLSelectElement,
-  HTMLShadowElement,
-  HTMLSourceElement,
-  HTMLSpanElement,
-  HTMLStyleElement,
-  HTMLTableCaptionElement,
-  HTMLTableCellElement,
-  HTMLTableColElement,
-  HTMLTableElement,
-  HTMLTableRowElement,
-  HTMLTableSectionElement,
-  HTMLTemplateElement,
-  HTMLTextAreaElement,
-  HTMLTimeElement,
-  HTMLTitleElement,
-  HTMLTrackElement,
-  HTMLUListElement,
-  HTMLUnknownElement,
-  HTMLVideoElement,
-  HashChangeEvent,
-  Headers,
-  HeapSnapshot,
-  HiddenPluginEvent,
-  History,
-  IDBCursor,
-  IDBCursorWithValue,
-  IDBDatabase,
-  IDBFactory,
-  IDBFileHandle,
-  IDBFileRequest,
-  IDBIndex,
-  IDBKeyRange,
-  IDBLocaleAwareKeyRange,
-  IDBMutableFile,
-  IDBObjectStore,
-  IDBOpenDBRequest,
-  IDBRequest,
-  IDBTransaction,
-  IDBVersionChangeEvent,
-  IIRFilterNode,
-  IdleDeadline,
-  ImageBitmap,
-  ImageBitmapRenderingContext,
-  ImageCapture,
-  ImageCaptureErrorEvent,
-  ImageData,
-  ImageDocument,
-  InputEvent,
-  InstallTriggerImpl,
-  IntersectionObserver,
-  IntersectionObserverEntry,
-  KeyEvent,
-  KeyboardEvent,
-  KeyframeEffect,
-  KeyframeEffectReadOnly,
-  LocalMediaStream,
-  Location,
-  MediaDeviceInfo,
-  MediaDevices,
-  MediaElementAudioSourceNode,
-  MediaEncryptedEvent,
-  MediaError,
-  MediaKeyError,
-  MediaKeyMessageEvent,
-  MediaKeySession,
-  MediaKeyStatusMap,
-  MediaKeySystemAccess,
-  MediaKeys,
-  MediaList,
-  MediaQueryList,
-  MediaRecorder,
-  MediaSource,
-  MediaStream,
-  MediaStreamAudioDestinationNode,
-  MediaStreamAudioSourceNode,
-  MediaStreamEvent,
-  MediaStreamList,
-  MediaStreamTrack,
-  MediaStreamTrackEvent,
-  MenuBoxObject,
-  MessageChannel,
-  MessageEvent,
-  MessagePort,
-  MimeType,
-  MimeTypeArray,
-  MouseEvent,
-  MouseScrollEvent,
-  MozCanvasPrintState,
-  MozPowerManager,
-  MozSelfSupport,
-  MozTimeManager,
-  MozWakeLock,
-  MutationEvent,
-  MutationObserver,
-  MutationRecord,
-  NamedNodeMap,
-  Navigator,
-  NetworkInformation,
-  Node,
-  NodeFilter,
-  NodeIterator,
-  NodeList,
-  Notification,
-  NotificationEvent,
-  NotifyPaintEvent,
-  OfflineAudioCompletionEvent,
-  OfflineAudioContext,
-  OfflineResourceList,
-  OffscreenCanvas,
-  OnlyForUseInConstructor,
-  OscillatorNode,
-  PageTransitionEvent,
-  PaintRequest,
-  PaintRequestList,
-  PaintWorkletGlobalScope,
-  PannerNode,
-  Path2D,
-  PeerConnectionImpl,
-  PeerConnectionObserver,
-  Performance,
-  PerformanceEntry,
-  PerformanceEntryEvent,
-  PerformanceMark,
-  PerformanceMeasure,
-  PerformanceNavigation,
-  PerformanceObserver,
-  PerformanceObserverEntryList,
-  PerformanceResourceTiming,
-  PerformanceTiming,
-  PeriodicWave,
-  PermissionStatus,
-  Permissions,
-  Plugin,
-  PluginArray,
-  PluginCrashedEvent,
-  PointerEvent,
-  PopStateEvent,
-  PopupBlockedEvent,
-  PopupBoxObject,
-  PrecompiledScript,
-  Presentation,
-  PresentationAvailability,
-  PresentationConnection,
-  PresentationConnectionAvailableEvent,
-  PresentationConnectionCloseEvent,
-  PresentationConnectionList,
-  PresentationDeviceInfoManager,
-  PresentationReceiver,
-  PresentationRequest,
-  ProcessingInstruction,
-  ProgressEvent,
-  PromiseDebugging,
-  PushEvent,
-  PushManager,
-  PushManagerImpl,
-  PushMessageData,
-  PushSubscription,
-  PushSubscriptionOptions,
-  RGBColor,
-  RTCCertificate,
-  RTCDTMFSender,
-  RTCDTMFToneChangeEvent,
-  RTCDataChannelEvent,
-  RTCIceCandidate,
-  RTCPeerConnection,
-  RTCPeerConnectionIceEvent,
-  RTCPeerConnectionStatic,
-  RTCRtpReceiver,
-  RTCRtpSender,
-  RTCSessionDescription,
-  RTCStatsReport,
-  RTCTrackEvent,
-  RadioNodeList,
-  Range,
-  RecordErrorEvent,
-  Rect,
-  Request,
-  Response,
-  SEChannel,
-  SEReader,
-  SEResponse,
-  SESession,
-  SVGAElement,
-  SVGAngle,
-  SVGAnimateElement,
-  SVGAnimateMotionElement,
-  SVGAnimateTransformElement,
-  SVGAnimatedAngle,
-  SVGAnimatedBoolean,
-  SVGAnimatedEnumeration,
-  SVGAnimatedInteger,
-  SVGAnimatedLength,
-  SVGAnimatedLengthList,
-  SVGAnimatedNumber,
-  SVGAnimatedNumberList,
-  SVGAnimatedPreserveAspectRatio,
-  SVGAnimatedRect,
-  SVGAnimatedString,
-  SVGAnimatedTransformList,
-  SVGAnimationElement,
-  SVGCircleElement,
-  SVGClipPathElement,
-  SVGComponentTransferFunctionElement,
-  SVGDefsElement,
-  SVGDescElement,
-  SVGElement,
-  SVGEllipseElement,
-  SVGFEBlendElement,
-  SVGFEColorMatrixElement,
-  SVGFEComponentTransferElement,
-  SVGFECompositeElement,
-  SVGFEConvolveMatrixElement,
-  SVGFEDiffuseLightingElement,
-  SVGFEDisplacementMapElement,
-  SVGFEDistantLightElement,
-  SVGFEDropShadowElement,
-  SVGFEFloodElement,
-  SVGFEFuncAElement,
-  SVGFEFuncBElement,
-  SVGFEFuncGElement,
-  SVGFEFuncRElement,
-  SVGFEGaussianBlurElement,
-  SVGFEImageElement,
-  SVGFEMergeElement,
-  SVGFEMergeNodeElement,
-  SVGFEMorphologyElement,
-  SVGFEOffsetElement,
-  SVGFEPointLightElement,
-  SVGFESpecularLightingElement,
-  SVGFESpotLightElement,
-  SVGFETileElement,
-  SVGFETurbulenceElement,
-  SVGFilterElement,
-  SVGForeignObjectElement,
-  SVGGElement,
-  SVGGeometryElement,
-  SVGGradientElement,
-  SVGGraphicsElement,
-  SVGImageElement,
-  SVGLength,
-  SVGLengthList,
-  SVGLineElement,
-  SVGLinearGradientElement,
-  SVGMPathElement,
-  SVGMarkerElement,
-  SVGMaskElement,
-  SVGMatrix,
-  SVGMetadataElement,
-  SVGNumber,
-  SVGNumberList,
-  SVGPathElement,
-  SVGPathSeg,
-  SVGPathSegArcAbs,
-  SVGPathSegArcRel,
-  SVGPathSegClosePath,
-  SVGPathSegCurvetoCubicAbs,
-  SVGPathSegCurvetoCubicRel,
-  SVGPathSegCurvetoCubicSmoothAbs,
-  SVGPathSegCurvetoCubicSmoothRel,
-  SVGPathSegCurvetoQuadraticAbs,
-  SVGPathSegCurvetoQuadraticRel,
-  SVGPathSegCurvetoQuadraticSmoothAbs,
-  SVGPathSegCurvetoQuadraticSmoothRel,
-  SVGPathSegLinetoAbs,
-  SVGPathSegLinetoHorizontalAbs,
-  SVGPathSegLinetoHorizontalRel,
-  SVGPathSegLinetoRel,
-  SVGPathSegLinetoVerticalAbs,
-  SVGPathSegLinetoVerticalRel,
-  SVGPathSegList,
-  SVGPathSegMovetoAbs,
-  SVGPathSegMovetoRel,
-  SVGPatternElement,
-  SVGPoint,
-  SVGPointList,
-  SVGPolygonElement,
-  SVGPolylineElement,
-  SVGPreserveAspectRatio,
-  SVGRadialGradientElement,
-  SVGRect,
-  SVGRectElement,
-  SVGSVGElement,
-  SVGScriptElement,
-  SVGSetElement,
-  SVGStopElement,
-  SVGStringList,
-  SVGStyleElement,
-  SVGSwitchElement,
-  SVGSymbolElement,
-  SVGTSpanElement,
-  SVGTextContentElement,
-  SVGTextElement,
-  SVGTextPathElement,
-  SVGTextPositioningElement,
-  SVGTitleElement,
-  SVGTransform,
-  SVGTransformList,
-  SVGUnitTypes,
-  SVGUseElement,
-  SVGViewElement,
-  SVGZoomAndPan,
-  ScopedCredential,
-  ScopedCredentialInfo,
-  Screen,
-  ScreenOrientation,
-  ScriptProcessorNode,
-  ScrollAreaEvent,
-  ScrollViewChangeEvent,
-  Selection,
-  ServiceWorker,
-  ServiceWorkerContainer,
-  ServiceWorkerGlobalScope,
-  ServiceWorkerRegistration,
-  ShadowRoot,
-  SharedWorker,
-  SharedWorkerGlobalScope,
-  SimpleGestureEvent,
-  SourceBuffer,
-  SourceBufferList,
-  SpeechGrammar,
-  SpeechGrammarList,
-  SpeechRecognition,
-  SpeechRecognitionAlternative,
-  SpeechRecognitionError,
-  SpeechRecognitionEvent,
-  SpeechRecognitionResult,
-  SpeechRecognitionResultList,
-  SpeechSynthesis,
-  SpeechSynthesisErrorEvent,
-  SpeechSynthesisEvent,
-  SpeechSynthesisUtterance,
-  SpeechSynthesisVoice,
-  StereoPannerNode,
-  Storage,
-  StorageEvent,
-  StorageManager,
-  StyleRuleChangeEvent,
-  StyleSheet,
-  StyleSheetApplicableStateChangeEvent,
-  StyleSheetChangeEvent,
-  StyleSheetList,
-  SubtleCrypto,
-  TCPServerSocket,
-  TCPServerSocketEvent,
-  TCPSocket,
-  TCPSocketErrorEvent,
-  TCPSocketEvent,
-  TestCImplementedInterface,
-  TestCImplementedInterface2,
-  TestChildInterface,
-  TestCppKeywordNamedMethodsInterface,
-  TestDeprecatedInterface,
-  TestExampleInterface,
-  TestExampleProxyInterface,
-  TestExampleWorkerInterface,
-  TestFunctions,
-  TestHTMLConstructorInterface,
-  TestIndexedAndNamedGetterAndSetterInterface,
-  TestIndexedAndNamedGetterInterface,
-  TestIndexedAndNamedSetterInterface,
-  TestIndexedGetterAndSetterAndNamedGetterInterface,
-  TestIndexedGetterInterface,
-  TestIndexedSetterInterface,
-  TestInterface,
-  TestInterfaceIterableDouble,
-  TestInterfaceIterableDoubleUnion,
-  TestInterfaceIterableSingle,
-  TestInterfaceJS,
-  TestInterfaceJSMaplike,
-  TestInterfaceMaplike,
-  TestInterfaceMaplikeObject,
-  TestInterfaceSetlike,
-  TestInterfaceSetlikeNode,
-  TestInterfaceWithPromiseConstructorArg,
-  TestJSImplInterface,
-  TestJSImplInterface2,
-  TestJSImplInterface3,
-  TestJSImplInterface4,
-  TestJSImplInterface5,
-  TestJSImplInterface6,
-  TestNamedDeleterInterface,
-  TestNamedDeleterWithRetvalInterface,
-  TestNamedGetterInterface,
-  TestNamedSetterInterface,
-  TestNamespace,
-  TestNavigator,
-  TestNavigatorWithConstructor,
-  TestNonWrapperCacheInterface,
-  TestParentInterface,
-  TestProtoObjectHackedNamespace,
-  TestRenamedInterface,
-  TestRenamedNamespace,
-  TestSecureContextInterface,
-  TestWorkerExposedInterface,
-  Text,
-  TextClause,
-  TextDecoder,
-  TextEncoder,
-  TextMetrics,
-  TextTrack,
-  TextTrackCue,
-  TextTrackCueList,
-  TextTrackList,
-  ThreadSafeChromeUtils,
-  TimeEvent,
-  TimeRanges,
-  Touch,
-  TouchEvent,
-  TouchList,
-  TrackEvent,
-  TransitionEvent,
-  TreeColumn,
-  TreeColumns,
-  TreeWalker,
-  U2F,
-  UDPMessageEvent,
-  UDPSocket,
-  UIEvent,
-  URL,
-  URLSearchParams,
-  UserProximityEvent,
-  VRDisplay,
-  VRDisplayCapabilities,
-  VRDisplayEvent,
-  VREyeParameters,
-  VRFieldOfView,
-  VRFrameData,
-  VRMockController,
-  VRMockDisplay,
-  VRPose,
-  VRServiceTest,
-  VRStageParameters,
-  VTTCue,
-  VTTRegion,
-  ValidityState,
-  VideoPlaybackQuality,
-  VideoStreamTrack,
-  VideoTrack,
-  VideoTrackList,
-  WaveShaperNode,
-  WebAuthentication,
-  WebAuthnAssertion,
-  WebAuthnAttestation,
-  WebGL2RenderingContext,
-  WebGLActiveInfo,
-  WebGLBuffer,
-  WebGLContextEvent,
-  WebGLFramebuffer,
-  WebGLProgram,
-  WebGLQuery,
-  WebGLRenderbuffer,
-  WebGLRenderingContext,
-  WebGLSampler,
-  WebGLShader,
-  WebGLShaderPrecisionFormat,
-  WebGLSync,
-  WebGLTexture,
-  WebGLTransformFeedback,
-  WebGLUniformLocation,
-  WebGLVertexArrayObject,
-  WebKitCSSMatrix,
-  WebSocket,
-  WebrtcGlobalInformation,
-  WheelEvent,
-  Window,
-  WindowClient,
-  WindowRoot,
-  Worker,
-  WorkerDebuggerGlobalScope,
-  WorkerGlobalScope,
-  WorkerLocation,
-  WorkerNavigator,
-  Worklet,
-  WorkletGlobalScope,
-  XMLDocument,
-  XMLHttpRequest,
-  XMLHttpRequestEventTarget,
-  XMLHttpRequestUpload,
-  XMLSerializer,
-  XMLStylesheetProcessingInstruction,
-  XPathEvaluator,
-  XPathExpression,
-  XPathResult,
-  XSLTProcessor,
-  XULCommandEvent,
-  XULDocument,
-  XULElement,
-  console,
-  mozRTCIceCandidate,
-  mozRTCPeerConnection,
-  mozRTCSessionDescription,
-  _ID_Count
-};
-
-}
-
-typedef id::ID ID;
-
-}
-}
-}
-
-namespace mozilla {
-namespace dom {
-namespace namedpropertiesobjects {
-
-namespace id {
-
-enum ID : uint16_t
-{
-  _ID_Start = constructors::id::_ID_Count,
-  Window = _ID_Start,
-  _ID_Count
-};
-
-}
-
-typedef id::ID ID;
-
-}
-}
-}
-
-namespace mozilla {
-namespace dom {
-template <prototypes::ID PrototypeID>
-struct PrototypeTraits;
-template <>
-struct PrototypeTraits<prototypes::id::ANGLE_instanced_arrays>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AccessibleNode>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Addon>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AddonEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AddonInstall>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AddonManager>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnalyserNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Animation>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationEffectReadOnly>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationEffectTiming>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationEffectTimingReadOnly>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationPlaybackEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnimationTimeline>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AnonymousContent>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Attr>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioBuffer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioBufferSourceNode>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioContext>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioDestinationNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioListener>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioNode>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioParam>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioProcessingEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioScheduledSourceNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioStreamTrack>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioTrack>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioTrackList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AudioWorkletGlobalScope>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::AutocompleteErrorEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BarProp>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BaseAudioContext>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BatteryManager>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BeforeUnloadEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BiquadFilterNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Blob>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BlobEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BoxObject>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BroadcastChannel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BrowserElementAudioChannel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::BrowserFeedWriter>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CDATASection>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSS2Properties>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSAnimation>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSConditionRule>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSCounterStyleRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSFontFaceRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSFontFeatureValuesRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSGroupingRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSImportRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSKeyframeRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSKeyframesRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSLexer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSMediaRule>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSMozDocumentRule>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSNamespaceRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSPageRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSPrimitiveValue>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSPseudoElement>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSRule>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSRuleList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSStyleDeclaration>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSStyleRule>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSStyleSheet>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSSupportsRule>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSTransition>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSValue>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CSSValueList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Cache>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CacheStorage>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CanvasCaptureMediaStream>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CanvasGradient>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CanvasPattern>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CanvasRenderingContext2D>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CaretPosition>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CaretStateChangedEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ChannelMergerNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ChannelSplitterNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CharacterData>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CheckerboardReportService>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ChromeNodeList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ChromeWorker>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Client>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Clients>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ClipboardEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CloseEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CommandEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Comment>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CompositionEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ConstantSourceNode>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ContainerBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ConvolverNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Coordinates>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CreateOfferRequest>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Crypto>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CryptoKey>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CustomElementRegistry>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::CustomEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMCursor>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMError>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMException>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMImplementation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMMatrix>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMMatrixReadOnly>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMParser>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMPoint>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMPointReadOnly>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMQuad>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMRect>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMRectList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMRectReadOnly>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMRequest>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMStringList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMStringMap>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DOMTokenList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DataChannel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DataContainerEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DataTransfer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DataTransferItem>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DataTransferItemList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DedicatedWorkerGlobalScope>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DelayNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DesktopNotification>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DesktopNotificationCenter>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceAcceleration>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceLightEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceMotionEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceOrientationEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceProximityEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DeviceRotationRate>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Directory>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Document>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DocumentFragment>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DocumentTimeline>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DocumentType>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DominatorTree>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DragEvent>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::DynamicsCompressorNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_blend_minmax>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_color_buffer_float>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_color_buffer_half_float>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_disjoint_timer_query>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_frag_depth>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_sRGB>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_shader_texture_lod>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EXT_texture_filter_anisotropic>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Element>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ErrorEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Event>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EventSource>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::EventTarget>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Exception>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ExtendableEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ExtendableMessageEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::External>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FetchController>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FetchEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FetchObserver>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FetchSignal>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::File>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileReader>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileReaderSync>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileSystem>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileSystemDirectoryEntry>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileSystemDirectoryReader>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileSystemEntry>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FileSystemFileEntry>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FlyWebDiscoveryManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FlyWebFetchEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FlyWebPublishedServer>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FlyWebWebSocketEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FocusEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FontFace>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FontFaceSet>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FontFaceSetIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FontFaceSetLoadEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FormData>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::FormDataIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GainNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Gamepad>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadAxisMoveEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadButton>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadButtonEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadHapticActuator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadPose>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GamepadServiceTest>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Geolocation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GetUserMediaRequest>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Grid>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridArea>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridDimension>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridLine>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridLines>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridTrack>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GridTracks>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::GroupedHistoryEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLAllCollection>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLAnchorElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLAppletElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLAreaElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLAudioElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLBRElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLBaseElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLBodyElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLButtonElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLCanvasElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLCollection>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLContentElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDListElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDataElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDataListElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDetailsElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDialogElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDirectoryElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDivElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLDocument>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLElement>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLEmbedElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFieldSetElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFontElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFormControlsCollection>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFormElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFrameElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLFrameSetElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLHRElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLHeadElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLHeadingElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLHtmlElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLIFrameElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLImageElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLInputElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLLIElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLLabelElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLLegendElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLLinkElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMapElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMediaElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMenuElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMenuItemElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMetaElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLMeterElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLModElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLOListElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLObjectElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLOptGroupElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLOptionElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLOptionsCollection>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLOutputElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLParagraphElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLParamElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLPictureElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLPreElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLProgressElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLQuoteElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLScriptElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLSelectElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLShadowElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLSourceElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLSpanElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLStyleElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableCaptionElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableCellElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableColElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableRowElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTableSectionElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTemplateElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTextAreaElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTimeElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTitleElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLTrackElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLUListElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLUnknownElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HTMLVideoElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HashChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Headers>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HeadersIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HeapSnapshot>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::HiddenPluginEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::History>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBCursor>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBCursorWithValue>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBDatabase>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBFactory>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBFileHandle>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBFileRequest>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBIndex>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBKeyRange>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBLocaleAwareKeyRange>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBMutableFile>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBObjectStore>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBOpenDBRequest>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBRequest>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBTransaction>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IDBVersionChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IIRFilterNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IdleDeadline>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageBitmap>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageBitmapRenderingContext>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageCapture>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageCaptureError>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageCaptureErrorEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageData>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ImageDocument>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::InputEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::InstallTriggerImpl>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IntersectionObserver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IntersectionObserverEntry>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::IntlUtils>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::KeyboardEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::KeyframeEffect>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::KeyframeEffectReadOnly>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::LegacyMozTCPSocket>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ListBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::LocalMediaStream>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Location>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MOZ_debug_get>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaDeviceInfo>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaDevices>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaElementAudioSourceNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaEncryptedEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaError>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeyError>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeyMessageEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeySession>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeyStatusMap>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeyStatusMapIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeySystemAccess>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaKeys>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaQueryList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaRecorder>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaSource>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStream>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamAudioDestinationNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamAudioSourceNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamError>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamTrack>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MediaStreamTrackEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MenuBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MessageChannel>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MessageEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MessagePort>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MimeType>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MimeTypeArray>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MouseEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MouseScrollEvent>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MozCanvasPrintState>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MozPowerManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MozSelfSupport>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MozTimeManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MozWakeLock>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MutationEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MutationObserver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::MutationRecord>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NamedNodeMap>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Navigator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NetworkInformation>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Node>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NodeIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NodeList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Notification>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NotificationEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::NotifyPaintEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_element_index_uint>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_standard_derivatives>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_texture_float>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_texture_float_linear>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_texture_half_float>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_texture_half_float_linear>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OES_vertex_array_object>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OfflineAudioCompletionEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OfflineAudioContext>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OfflineResourceList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OffscreenCanvas>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OnlyForUseInConstructor>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::OscillatorNode>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PageTransitionEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PaintRequest>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PaintRequestList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PaintWorkletGlobalScope>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PannerNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Path2D>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PeerConnectionImpl>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PeerConnectionObserver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Performance>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceEntry>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceEntryEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceMark>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceMeasure>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceNavigation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceObserver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceObserverEntryList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceResourceTiming>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PerformanceTiming>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PeriodicWave>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PermissionStatus>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Permissions>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Plugin>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PluginArray>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PluginCrashedEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PointerEvent>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PopStateEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PopupBlockedEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PopupBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Position>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PositionError>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PrecompiledScript>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Presentation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationAvailability>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationConnection>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationConnectionAvailableEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationConnectionCloseEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationConnectionList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationDeviceInfoManager>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationReceiver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PresentationRequest>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ProcessingInstruction>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ProgressEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PromiseNativeHandler>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushManagerImpl>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushMessageData>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushSubscription>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::PushSubscriptionOptions>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RGBColor>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCCertificate>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCDTMFSender>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCDTMFToneChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCDataChannelEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCIceCandidate>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCIdentityProviderRegistrar>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCPeerConnection>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCPeerConnectionIceEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCPeerConnectionStatic>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCRtpReceiver>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCRtpSender>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCSessionDescription>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCStatsReport>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RTCTrackEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RadioNodeList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Range>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::RecordErrorEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Rect>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Request>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Response>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SEChannel>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SEManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SEReader>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SEResponse>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SESession>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAngle>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimateElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimateMotionElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimateTransformElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedAngle>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedBoolean>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedEnumeration>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedInteger>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedLength>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedLengthList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedNumber>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedNumberList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedPreserveAspectRatio>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedRect>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedString>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimatedTransformList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGAnimationElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGCircleElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGClipPathElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGComponentTransferFunctionElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGDefsElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGDescElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGElement>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGEllipseElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEBlendElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEColorMatrixElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEComponentTransferElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFECompositeElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEConvolveMatrixElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEDiffuseLightingElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEDisplacementMapElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEDistantLightElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEDropShadowElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEFloodElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEFuncAElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEFuncBElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEFuncGElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEFuncRElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEGaussianBlurElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEImageElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEMergeElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEMergeNodeElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEMorphologyElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEOffsetElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFEPointLightElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFESpecularLightingElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFESpotLightElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFETileElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFETurbulenceElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGFilterElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGForeignObjectElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGGElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGGeometryElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGGradientElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGGraphicsElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGImageElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGLength>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGLengthList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGLineElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGLinearGradientElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGMPathElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGMarkerElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGMaskElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGMatrix>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGMetadataElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGNumber>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGNumberList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathElement>
-{
-  enum
-  {
-    Depth = 6
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSeg>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegArcAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegArcRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegClosePath>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicSmoothAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoCubicSmoothRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticSmoothAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegCurvetoQuadraticSmoothRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoHorizontalAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoHorizontalRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoVerticalAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegLinetoVerticalRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegMovetoAbs>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPathSegMovetoRel>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPatternElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPoint>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPointList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPolygonElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPolylineElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGPreserveAspectRatio>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGRadialGradientElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGRect>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGRectElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGSVGElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGScriptElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGSetElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGStopElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGStringList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGStyleElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGSwitchElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGSymbolElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTSpanElement>
-{
-  enum
-  {
-    Depth = 7
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTextContentElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTextElement>
-{
-  enum
-  {
-    Depth = 7
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTextPathElement>
-{
-  enum
-  {
-    Depth = 6
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTextPositioningElement>
-{
-  enum
-  {
-    Depth = 6
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTitleElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTransform>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGTransformList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGUseElement>
-{
-  enum
-  {
-    Depth = 5
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SVGViewElement>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScopedCredential>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScopedCredentialInfo>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Screen>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScreenOrientation>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScriptProcessorNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScrollAreaEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScrollBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ScrollViewChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Selection>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ServiceWorker>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ServiceWorkerContainer>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ServiceWorkerGlobalScope>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ServiceWorkerRegistration>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ShadowRoot>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SharedWorker>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SharedWorkerGlobalScope>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SimpleGestureEvent>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SourceBuffer>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SourceBufferList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechGrammar>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechGrammarList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognition>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognitionAlternative>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognitionError>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognitionEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognitionResult>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechRecognitionResultList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechSynthesis>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechSynthesisErrorEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechSynthesisEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechSynthesisUtterance>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SpeechSynthesisVoice>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StereoPannerNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Storage>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StorageEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StorageManager>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StyleRuleChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StyleSheet>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StyleSheetApplicableStateChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StyleSheetChangeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::StyleSheetList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::SubtleCrypto>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TCPServerSocket>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TCPServerSocketEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TCPSocket>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TCPSocketErrorEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TCPSocketEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestCImplementedInterface>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestCImplementedInterface2>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestChildInterface>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestCppKeywordNamedMethodsInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestDeprecatedInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestExampleInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestExampleProxyInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestExampleWorkerInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestFunctions>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestHTMLConstructorInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedAndNamedGetterAndSetterInterface>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedAndNamedGetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedAndNamedSetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedGetterAndSetterAndNamedGetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedGetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestIndexedSetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceIterableDouble>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleUnion>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceIterableDoubleUnionIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceIterableSingle>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceJS>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceJSMaplike>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceMaplike>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceMaplikeObject>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceSetlike>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceSetlikeNode>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestInterfaceWithPromiseConstructorArg>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface2>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface3>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface4>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface5>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplInterface6>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestJSImplNoInterfaceObject>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNamedDeleterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNamedDeleterWithRetvalInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNamedGetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNamedSetterInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNavigator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNavigatorWithConstructor>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestNonWrapperCacheInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestParentInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestRenamedInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestSecureContextInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TestWorkerExposedInterface>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Text>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextClause>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextDecoder>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextEncoder>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextMetrics>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextTrack>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextTrackCue>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextTrackCueList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TextTrackList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TimeEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TimeRanges>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Touch>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TouchEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TouchList>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TrackEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TransitionEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TreeBoxObject>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TreeColumn>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TreeColumns>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::TreeWalker>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::U2F>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::UDPMessageEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::UDPSocket>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::UIEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::URL>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::URLSearchParams>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::URLSearchParamsIterator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::UserProximityEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRDisplay>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRDisplayCapabilities>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRDisplayEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VREyeParameters>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRFieldOfView>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRFrameData>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRMockController>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRMockDisplay>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRPose>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRServiceTest>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VRStageParameters>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VTTCue>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VTTRegion>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::ValidityState>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VideoPlaybackQuality>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VideoStreamTrack>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VideoTrack>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::VideoTrackList>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_color_buffer_float>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_astc>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_atc>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_etc>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_etc1>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_pvrtc>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_compressed_texture_s3tc>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_debug_renderer_info>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_debug_shaders>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_depth_texture>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_draw_buffers>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WEBGL_lose_context>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WaveShaperNode>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebAuthentication>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebAuthnAssertion>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebAuthnAttestation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGL2RenderingContext>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLActiveInfo>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLBuffer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLContextEvent>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLFramebuffer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLProgram>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLQuery>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLRenderbuffer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLRenderingContext>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLSampler>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLShader>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLShaderPrecisionFormat>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLSync>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLTexture>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLTransformFeedback>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLUniformLocation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebGLVertexArrayObject>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebKitCSSMatrix>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WebSocket>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WheelEvent>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Window>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WindowClient>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WindowRoot>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Worker>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WorkerDebuggerGlobalScope>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WorkerGlobalScope>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WorkerLocation>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WorkerNavigator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::Worklet>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::WorkletGlobalScope>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLDocument>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLHttpRequest>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLHttpRequestEventTarget>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLHttpRequestUpload>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLSerializer>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XMLStylesheetProcessingInstruction>
-{
-  enum
-  {
-    Depth = 4
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XPathEvaluator>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XPathExpression>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XPathResult>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XSLTProcessor>
-{
-  enum
-  {
-    Depth = 0
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XULCommandEvent>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XULDocument>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::XULElement>
-{
-  enum
-  {
-    Depth = 3
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::mozRTCIceCandidate>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::mozRTCPeerConnection>
-{
-  enum
-  {
-    Depth = 2
-  };
-};
-template <>
-struct PrototypeTraits<prototypes::id::mozRTCSessionDescription>
-{
-  enum
-  {
-    Depth = 1
-  };
-};
-extern const char *NamesOfInterfacesWithProtos(unsigned int aIndex);
-}
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h" 2
-
-
-
-class nsCycleCollectionParticipant;
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-namespace mozilla {
-namespace dom {
-# 60 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-inline bool
-IsSecureContextOrObjectIsFromSecureContext(JSContext* aCx, JSObject* aObj)
-{
-  return JS::CompartmentCreationOptionsRef(js::GetContextCompartment(aCx)).secureContext() ||
-         JS::CompartmentCreationOptionsRef(js::GetObjectCompartment(aObj)).secureContext();
-}
-
-typedef bool
-(* ResolveOwnProperty)(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                       JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                       JS::MutableHandle<JS::PropertyDescriptor> desc);
-
-typedef bool
-(* EnumerateOwnProperties)(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                           JS::Handle<JSObject*> obj,
-                           JS::AutoIdVector& props);
-
-typedef bool
-(* DeleteNamedProperty)(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                        JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                        JS::ObjectOpResult& opresult);
-
-
-
-bool
-IsNonExposedGlobal(JSContext* aCx, JSObject* aGlobal,
-                   uint32_t aNonExposedGlobals);
-
-struct ConstantSpec
-{
-  const char* name;
-  JS::Value value;
-};
-
-typedef bool (*PropertyEnabled)(JSContext* cx, JSObject* global);
-
-namespace GlobalNames {
-
-
-
-static const uint32_t Window = 1u << 0;
-static const uint32_t BackstagePass = 1u << 1;
-static const uint32_t DedicatedWorkerGlobalScope = 1u << 2;
-static const uint32_t SharedWorkerGlobalScope = 1u << 3;
-static const uint32_t ServiceWorkerGlobalScope = 1u << 4;
-static const uint32_t WorkerDebuggerGlobalScope = 1u << 5;
-static const uint32_t WorkletGlobalScope = 1u << 6;
-}
-
-struct PrefableDisablers {
-  inline bool isEnabled(JSContext* cx, JS::Handle<JSObject*> obj) const {
-# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-    if (nonExposedGlobals &&
-        IsNonExposedGlobal(cx, js::GetGlobalForObjectCrossCompartment(obj),
-                           nonExposedGlobals)) {
-      return false;
-    }
-    if (!enabled) {
-      return false;
-    }
-    if (secureContext && !IsSecureContextOrObjectIsFromSecureContext(cx, obj)) {
-      return false;
-    }
-    if (enabledFunc &&
-        !enabledFunc(cx, js::GetGlobalForObjectCrossCompartment(obj))) {
-      return false;
-    }
-    return true;
-  }
-
-
-
-  bool enabled;
-
-
-  const bool secureContext;
-
-
-  const uint16_t nonExposedGlobals;
-
-
-
-
-  const PropertyEnabled enabledFunc;
-};
-
-template<typename T>
-struct Prefable {
-  inline bool isEnabled(JSContext* cx, JS::Handle<JSObject*> obj) const {
-    if ((__builtin_expect(!!(!disablers), 1))) {
-      return true;
-    }
-    return disablers->isEnabled(cx, obj);
-  }
-
-
-
-  PrefableDisablers* const disablers;
-
-
-
-
-  const T* const specs;
-};
-# 199 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-template <int N>
-struct NativePropertiesN {
-
-
-
-
-  struct Trio {
-    const void* const mPrefables;
-    const jsid* const mIds;
-    const void* const mSpecs;
-  };
-
-  const int32_t iteratorAliasMethodIndex;
-
-  constexpr const NativePropertiesN<7>* Upcast() const {
-    return reinterpret_cast<const NativePropertiesN<7>*>(this);
-  }
-# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-  public: const uint32_t mHasStaticMethods:1; const uint32_t mStaticMethodsOffset:3; private: const Trio* StaticMethodsTrio() const { do { } while (0); return &trios[mStaticMethodsOffset]; } public: bool HasStaticMethods() const { return mHasStaticMethods; } const Prefable<const JSFunctionSpec>* StaticMethods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( StaticMethodsTrio()->mPrefables); } const jsid* StaticMethodIds() const { return StaticMethodsTrio()->mIds; } const JSFunctionSpec* StaticMethodSpecs() const { return static_cast<const JSFunctionSpec*>( StaticMethodsTrio()->mSpecs); }
-  public: const uint32_t mHasStaticAttributes:1; const uint32_t mStaticAttributesOffset:3; private: const Trio* StaticAttributesTrio() const { do { } while (0); return &trios[mStaticAttributesOffset]; } public: bool HasStaticAttributes() const { return mHasStaticAttributes; } const Prefable<const JSPropertySpec>* StaticAttributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( StaticAttributesTrio()->mPrefables); } const jsid* StaticAttributeIds() const { return StaticAttributesTrio()->mIds; } const JSPropertySpec* StaticAttributeSpecs() const { return static_cast<const JSPropertySpec*>( StaticAttributesTrio()->mSpecs); }
-  public: const uint32_t mHasMethods:1; const uint32_t mMethodsOffset:3; private: const Trio* MethodsTrio() const { do { } while (0); return &trios[mMethodsOffset]; } public: bool HasMethods() const { return mHasMethods; } const Prefable<const JSFunctionSpec>* Methods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( MethodsTrio()->mPrefables); } const jsid* MethodIds() const { return MethodsTrio()->mIds; } const JSFunctionSpec* MethodSpecs() const { return static_cast<const JSFunctionSpec*>( MethodsTrio()->mSpecs); }
-  public: const uint32_t mHasAttributes:1; const uint32_t mAttributesOffset:3; private: const Trio* AttributesTrio() const { do { } while (0); return &trios[mAttributesOffset]; } public: bool HasAttributes() const { return mHasAttributes; } const Prefable<const JSPropertySpec>* Attributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( AttributesTrio()->mPrefables); } const jsid* AttributeIds() const { return AttributesTrio()->mIds; } const JSPropertySpec* AttributeSpecs() const { return static_cast<const JSPropertySpec*>( AttributesTrio()->mSpecs); }
-  public: const uint32_t mHasUnforgeableMethods:1; const uint32_t mUnforgeableMethodsOffset:3; private: const Trio* UnforgeableMethodsTrio() const { do { } while (0); return &trios[mUnforgeableMethodsOffset]; } public: bool HasUnforgeableMethods() const { return mHasUnforgeableMethods; } const Prefable<const JSFunctionSpec>* UnforgeableMethods() const { return static_cast<const Prefable<const JSFunctionSpec>*> ( UnforgeableMethodsTrio()->mPrefables); } const jsid* UnforgeableMethodIds() const { return UnforgeableMethodsTrio()->mIds; } const JSFunctionSpec* UnforgeableMethodSpecs() const { return static_cast<const JSFunctionSpec*>( UnforgeableMethodsTrio()->mSpecs); }
-  public: const uint32_t mHasUnforgeableAttributes:1; const uint32_t mUnforgeableAttributesOffset:3; private: const Trio* UnforgeableAttributesTrio() const { do { } while (0); return &trios[mUnforgeableAttributesOffset]; } public: bool HasUnforgeableAttributes() const { return mHasUnforgeableAttributes; } const Prefable<const JSPropertySpec>* UnforgeableAttributes() const { return static_cast<const Prefable<const JSPropertySpec>*> ( UnforgeableAttributesTrio()->mPrefables); } const jsid* UnforgeableAttributeIds() const { return UnforgeableAttributesTrio()->mIds; } const JSPropertySpec* UnforgeableAttributeSpecs() const { return static_cast<const JSPropertySpec*>( UnforgeableAttributesTrio()->mSpecs); }
-  public: const uint32_t mHasConstants:1; const uint32_t mConstantsOffset:3; private: const Trio* ConstantsTrio() const { do { } while (0); return &trios[mConstantsOffset]; } public: bool HasConstants() const { return mHasConstants; } const Prefable<const ConstantSpec>* Constants() const { return static_cast<const Prefable<const ConstantSpec>*> ( ConstantsTrio()->mPrefables); } const jsid* ConstantIds() const { return ConstantsTrio()->mIds; } const ConstantSpec* ConstantSpecs() const { return static_cast<const ConstantSpec*>( ConstantsTrio()->mSpecs); }
-
-
-
-  const Trio trios[N];
-};
-
-
-
-static_assert(sizeof(NativePropertiesN<1>) == 8 + 3*sizeof(void*), "1 size");
-static_assert(sizeof(NativePropertiesN<2>) == 8 + 6*sizeof(void*), "2 size");
-static_assert(sizeof(NativePropertiesN<3>) == 8 + 9*sizeof(void*), "3 size");
-static_assert(sizeof(NativePropertiesN<4>) == 8 + 12*sizeof(void*), "4 size");
-static_assert(sizeof(NativePropertiesN<5>) == 8 + 15*sizeof(void*), "5 size");
-static_assert(sizeof(NativePropertiesN<6>) == 8 + 18*sizeof(void*), "6 size");
-static_assert(sizeof(NativePropertiesN<7>) == 8 + 21*sizeof(void*), "7 size");
-
-
-typedef NativePropertiesN<7> NativeProperties;
-
-struct NativePropertiesHolder
-{
-  const NativeProperties* regular;
-  const NativeProperties* chromeOnly;
-};
-
-
-
-
-struct NativePropertyHooks
-{
-
-
-  ResolveOwnProperty mResolveOwnProperty;
-
-
-  EnumerateOwnProperties mEnumerateOwnProperties;
-# 293 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-  DeleteNamedProperty mDeleteNamedProperty;
-
-
-  NativePropertiesHolder mNativeProperties;
-
-
-
-
-  prototypes::ID mPrototypeID;
-
-
-
-
-  constructors::ID mConstructorID;
-
-
-
-  const NativePropertyHooks* mProtoHooks;
-
-
-
-  const JSClass* mXrayExpandoClass;
-};
-
-enum DOMObjectType : uint8_t {
-  eInstance,
-  eGlobalInstance,
-  eInterface,
-  eInterfacePrototype,
-  eGlobalInterfacePrototype,
-  eNamedPropertiesObject
-};
-
-inline
-bool
-IsInstance(DOMObjectType type)
-{
-  return type == eInstance || type == eGlobalInstance;
-}
-
-inline
-bool
-IsInterfacePrototype(DOMObjectType type)
-{
-  return type == eInterfacePrototype || type == eGlobalInterfacePrototype;
-}
-
-typedef JSObject* (*AssociatedGlobalGetter)(JSContext* aCx,
-                                            JS::Handle<JSObject*> aObj);
-
-typedef JSObject* (*ProtoGetter)(JSContext* aCx);
-# 352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSClass.h"
-typedef JS::Handle<JSObject*> (*ProtoHandleGetter)(JSContext* aCx);
-
-
-struct DOMJSClass
-{
-
-
-
-  const js::Class mBase;
-
-
-
-  const prototypes::ID mInterfaceChain[8];
-
-
-
-
-
-  const bool mDOMObjectIsISupports;
-
-  const NativePropertyHooks* mNativeHooks;
-
-
-
-
-  AssociatedGlobalGetter mGetAssociatedGlobal;
-  ProtoHandleGetter mGetProto;
-
-
-
-
-  nsCycleCollectionParticipant* mParticipant;
-
-  static const DOMJSClass* FromJSClass(const JSClass* base) {
-    do { } while (0);
-    return reinterpret_cast<const DOMJSClass*>(base);
-  }
-
-  static const DOMJSClass* FromJSClass(const js::Class* base) {
-    return FromJSClass(Jsvalify(base));
-  }
-
-  const JSClass* ToJSClass() const { return Jsvalify(&mBase); }
-};
-
-
-struct DOMIfaceAndProtoJSClass
-{
-
-
-
-
-  const js::Class mBase;
-
-
-
-  DOMObjectType mType;
-
-
-
-
-  bool wantsInterfaceHasInstance;
-
-  const prototypes::ID mPrototypeID;
-  const uint32_t mDepth;
-
-  const NativePropertyHooks* mNativeHooks;
-
-
-
-  const char* mToString;
-
-  ProtoGetter mGetParentProto;
-
-  static const DOMIfaceAndProtoJSClass* FromJSClass(const JSClass* base) {
-    do { } while (0);
-    return reinterpret_cast<const DOMIfaceAndProtoJSClass*>(base);
-  }
-  static const DOMIfaceAndProtoJSClass* FromJSClass(const js::Class* base) {
-    return FromJSClass(Jsvalify(base));
-  }
-
-  const JSClass* ToJSClass() const { return Jsvalify(&mBase); }
-};
-
-class ProtoAndIfaceCache;
-
-inline bool
-DOMGlobalHasProtoAndIFaceCache(JSObject* global)
-{
-  do { } while (0);
-
-  return !js::GetReservedSlot(global, (5 + JSProto_LIMIT * 2 + 46)).isUndefined();
-}
-
-inline bool
-HasProtoAndIfaceCache(JSObject* global)
-{
-  if (!(js::GetObjectClass(global)->flags & (1<<7))) {
-    return false;
-  }
-  return DOMGlobalHasProtoAndIFaceCache(global);
-}
-
-inline ProtoAndIfaceCache*
-GetProtoAndIfaceCache(JSObject* global)
-{
-  do { } while (0);
-  return static_cast<ProtoAndIfaceCache*>(
-    js::GetReservedSlot(global, (5 + JSProto_LIMIT * 2 + 46)).toPrivate());
-}
-
-}
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
-namespace mozilla {
-namespace dom {
-
-enum {
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
-  JSPROXYSLOT_EXPANDO = 0
-};
-
-template<typename T> struct Prefable;
-
-class BaseDOMProxyHandler : public js::BaseProxyHandler
-{
-public:
-  explicit constexpr BaseDOMProxyHandler(const void* aProxyFamily, bool aHasPrototype = false)
-    : js::BaseProxyHandler(aProxyFamily, aHasPrototype)
-  {}
-
-
-
-  bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> proxy,
-                                JS::Handle<jsid> id,
-                                JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
-  virtual bool ownPropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
-                               JS::AutoIdVector &props) const override;
-
-  virtual bool getPrototypeIfOrdinary(JSContext* cx, JS::Handle<JSObject*> proxy,
-                                      bool* isOrdinary,
-                                      JS::MutableHandle<JSObject*> proto) const override;
-
-
-
-
-
-  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
-                                            JS::AutoIdVector &props) const override;
-
-  bool watch(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-             JS::Handle<JSObject*> callable) const override;
-  bool unwatch(JSContext* cx, JS::Handle<JSObject*> proxy,
-               JS::Handle<jsid> id) const override;
-
-protected:
-
-
-
-
-  virtual bool ownPropNames(JSContext* cx, JS::Handle<JSObject*> proxy,
-                            unsigned flags,
-                            JS::AutoIdVector& props) const = 0;
-
-
-
-
-
-  virtual bool getOwnPropDescriptor(JSContext* cx,
-                                    JS::Handle<JSObject*> proxy,
-                                    JS::Handle<jsid> id,
-                                    bool ignoreNamedProps,
-                                    JS::MutableHandle<JS::PropertyDescriptor> desc) const = 0;
-};
-
-class DOMProxyHandler : public BaseDOMProxyHandler
-{
-public:
-  constexpr DOMProxyHandler()
-    : BaseDOMProxyHandler(&family)
-  {}
-
-  bool defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-                      JS::Handle<JS::PropertyDescriptor> desc,
-                      JS::ObjectOpResult &result) const override
-  {
-    bool unused;
-    return defineProperty(cx, proxy, id, desc, result, &unused);
-  }
-  virtual bool defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-                              JS::Handle<JS::PropertyDescriptor> desc,
-                              JS::ObjectOpResult &result, bool *defined) const;
-  bool delete_(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-               JS::ObjectOpResult &result) const override;
-  bool preventExtensions(JSContext* cx, JS::Handle<JSObject*> proxy,
-                         JS::ObjectOpResult& result) const override;
-  bool isExtensible(JSContext *cx, JS::Handle<JSObject*> proxy, bool *extensible)
-                    const override;
-  bool set(JSContext *cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-           JS::Handle<JS::Value> v, JS::Handle<JS::Value> receiver, JS::ObjectOpResult &result)
-           const override;
-
-
-
-
-
-
-  virtual bool setCustom(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
-                         JS::Handle<JS::Value> v, bool *done) const;
-
-
-
-
-  static JSObject* GetExpandoObject(JSObject* obj);
-# 148 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
-  static void ClearExternalRefsForWrapperRelease(JSObject* obj);
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMJSProxyHandler.h"
-  static JSObject* GetAndClearExpandoObject(JSObject* obj);
-
-
-
-
-
-  static JSObject* EnsureExpandoObject(JSContext* cx,
-                                       JS::Handle<JSObject*> obj);
-
-  static const char family;
-};
-
-
-
-class ShadowingDOMProxyHandler : public DOMProxyHandler
-{
-  virtual void trace(JSTracer* trc, JSObject* proxy) const override;
-};
-
-inline bool IsDOMProxy(JSObject *obj)
-{
-    const js::Class* clasp = js::GetObjectClass(obj);
-    return clasp->isProxy() &&
-           js::GetProxyHandler(obj)->family() == &DOMProxyHandler::family;
-}
-
-inline const DOMProxyHandler*
-GetDOMProxyHandler(JSObject* obj)
-{
-  do { } while (0);
-  return static_cast<const DOMProxyHandler*>(js::GetProxyHandler(obj));
-}
-
-extern jsid s_length_id;
-
-
-
-inline uint32_t
-GetArrayIndexFromId(JSContext* cx, JS::Handle<jsid> id)
-{
-
-
-
-  if ((__builtin_expect(!!(JSID_IS_INT(id)), 1))) {
-    return JSID_TO_INT(id);
-  }
-  if ((__builtin_expect(!!(id == s_length_id), 1))) {
-    return (4294967295U);
-  }
-  if ((__builtin_expect(!!(!JSID_IS_ATOM(id)), 0))) {
-    return (4294967295U);
-  }
-
-  JSLinearString* str = js::AtomToLinearString(JSID_TO_ATOM(id));
-  char16_t s;
-  {
-    JS::AutoCheckCannotGC nogc;
-    if (js::LinearStringHasLatin1Chars(str)) {
-      s = *js::GetLatin1LinearStringChars(nogc, str);
-    } else {
-      s = *js::GetTwoByteLinearStringChars(nogc, str);
-    }
-  }
-  if ((__builtin_expect(!!((unsigned)s >= 'a' && (unsigned)s <= 'z'), 1)))
-    return (4294967295U);
-
-  uint32_t i;
-  return js::StringIsArrayIndex(str, &i) ? i : (4294967295U);
-}
-
-inline bool
-IsArrayIndex(uint32_t index)
-{
-  return index < (4294967295U);
-}
-
-inline void
-FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
-                       JSObject* obj, bool readonly, bool enumerable = true)
-{
-  desc.object().set(obj);
-  desc.setAttributes((readonly ? 0x02 : 0) |
-                     (enumerable ? 0x01 : 0));
-  desc.setGetter(nullptr);
-  desc.setSetter(nullptr);
-}
-
-inline void
-FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
-                       JSObject* obj, const JS::Value& v,
-                       bool readonly, bool enumerable = true)
-{
-  desc.value().set(v);
-  FillPropertyDescriptor(desc, obj, readonly, enumerable);
-}
-
-inline void
-FillPropertyDescriptor(JS::MutableHandle<JS::PropertyDescriptor> desc,
-                       JSObject* obj, unsigned attributes, const JS::Value& v)
-{
-  desc.object().set(obj);
-  desc.value().set(v);
-  desc.setAttributes(attributes);
-  desc.setGetter(nullptr);
-  desc.setSetter(nullptr);
-}
-
-}
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h" 1
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h"
-class nsIStackFrame : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetLanguage(uint32_t *aLanguage) = 0;
-
-
-  virtual nsresult GetLanguageName(nsACString & aLanguageName) = 0;
-
-
-  virtual nsresult GetFilename(JSContext* cx, nsAString & aFilename) = 0;
-
-
-  virtual nsresult GetName(JSContext* cx, nsAString & aName) = 0;
-
-
-  virtual nsresult GetLineNumber(JSContext* cx, int32_t *aLineNumber) = 0;
-
-
-  virtual nsresult GetColumnNumber(JSContext* cx, int32_t *aColumnNumber) = 0;
-
-
-  virtual nsresult GetSourceLine(nsACString & aSourceLine) = 0;
-
-
-  virtual nsresult GetAsyncCause(JSContext* cx, nsAString & aAsyncCause) = 0;
-
-
-  virtual nsresult GetAsyncCaller(JSContext* cx, nsIStackFrame * *aAsyncCaller) = 0;
-
-
-  virtual nsresult GetCaller(JSContext* cx, nsIStackFrame * *aCaller) = 0;
-
-
-  virtual nsresult GetFormattedStack(JSContext* cx, nsAString & aFormattedStack) = 0;
-
-
-  virtual nsresult GetNativeSavedFrame(JS::MutableHandleValue aNativeSavedFrame) = 0;
-
-
-  virtual nsresult ToString(JSContext* cx, nsACString & _retval) = 0;
-
-};
-
-  template<typename T> struct nsIStackFrame::COMTypeInfo<nsIStackFrame, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStackFrame::COMTypeInfo<nsIStackFrame, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x28bfb2a2, 0x5ea6, 0x4738, { 0x91, 0x8b, 0x04, 0x9d, 0xc4, 0xd5, 0x1f, 0x0b }};
-# 261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIException.h"
-class nsIException : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetMessageMoz(nsACString & aMessage) = 0;
-
-
-  virtual nsresult GetResult(nsresult *aResult) = 0;
-
-
-  virtual nsresult GetName(nsACString & aName) = 0;
-
-
-  virtual nsresult GetFilename(JSContext* cx, nsAString & aFilename) = 0;
-
-
-  virtual nsresult GetLineNumber(JSContext* cx, uint32_t *aLineNumber) = 0;
-
-
-  virtual nsresult GetColumnNumber(uint32_t *aColumnNumber) = 0;
-
-
-  virtual nsresult GetLocation(nsIStackFrame * *aLocation) = 0;
-
-
-  virtual nsresult GetData(nsISupports * *aData) = 0;
-
-
-  virtual nsresult ToString(JSContext* cx, nsACString & _retval) = 0;
-
-};
-
-  template<typename T> struct nsIException::COMTypeInfo<nsIException, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIException::COMTypeInfo<nsIException, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4371b5bf, 0x6845, 0x487f, { 0x8d, 0x9d, 0x3f, 0x1e, 0x4a, 0x9b, 0xad, 0xd2 }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Exceptions.h" 2
-
-
-
-class nsIStackFrame;
-class nsPIDOMWindowInner;
-template <class T>
-struct already_AddRefed;
-
-namespace mozilla {
-namespace dom {
-
-class Exception;
-
-
-
-bool
-Throw(JSContext* cx, nsresult rv, const nsACString& message = EmptyCString());
-
-
-void
-ThrowAndReport(nsPIDOMWindowInner* aWindow, nsresult aRv);
-
-
-
-void
-ThrowExceptionObject(JSContext* aCx, Exception* aException);
-void
-ThrowExceptionObject(JSContext* aCx, nsIException* aException);
-
-
-
-
-
-
-already_AddRefed<Exception>
-CreateException(nsresult aRv, const nsACString& aMessage = EmptyCString());
-
-
-
-
-already_AddRefed<nsIStackFrame>
-GetCurrentJSStack(int32_t aMaxDepth = -1);
-
-
-namespace exceptions {
-
-already_AddRefed<nsIStackFrame>
-CreateStack(JSContext* aCx, JS::StackCapture&& aCaptureMode);
-
-}
-}
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NonRefcountedDOMObject.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/NonRefcountedDOMObject.h"
-namespace mozilla {
-namespace dom {
-
-
-
-
-
-
-
-class NonRefcountedDOMObject
-{
-protected:
-  NonRefcountedDOMObject()
-  {
-                                          ;
-  }
-  ~NonRefcountedDOMObject()
-  {
-                                          ;
-  }
-};
-
-}
-}
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/RootedDictionary.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/RootedDictionary.h"
-namespace mozilla {
-namespace dom {
-
-template<typename T>
-class RootedDictionary final : public T,
-                                         private JS::CustomAutoRooter
-{
-public:
-  template <typename CX>
-  explicit RootedDictionary(const CX& cx ) :
-    T(),
-    JS::CustomAutoRooter(cx )
-  {
-  }
-
-  virtual void trace(JSTracer *trc) override
-  {
-    this->TraceDictionary(trc);
-  }
-};
-
-template<typename T>
-class NullableRootedDictionary final : public Nullable<T>,
-                                                 private JS::CustomAutoRooter
-{
-public:
-  template <typename CX>
-  explicit NullableRootedDictionary(const CX& cx ) :
-    Nullable<T>(),
-    JS::CustomAutoRooter(cx )
-  {
-  }
-
-  virtual void trace(JSTracer *trc) override
-  {
-    if (!this->IsNull()) {
-      this->Value().TraceDictionary(trc);
-    }
-  }
-};
-
-}
-}
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCompatibility.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCompatibility.h"
-enum nsCompatibility {
-  eCompatibility_FullStandards = 1,
-  eCompatibility_AlmostStandards = 2,
-  eCompatibility_NavQuirks = 3
-};
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-class nsIContent;
-class nsIDocument;
-
-namespace mozilla {
-namespace css {
-class Rule;
-}
-}
-
-
-
-
-
-typedef uint32_t nsUpdateType;
-
-
-
-
-
-
-class nsIDocumentObserver : public nsIMutationObserver
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-  virtual void BeginUpdate(nsIDocument *aDocument,
-                           nsUpdateType aUpdateType) = 0;
-
-
-
-
-
-  virtual void EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType) = 0;
-
-
-
-
-  virtual void BeginLoad(nsIDocument *aDocument) = 0;
-
-
-
-
-
-
-  virtual void EndLoad(nsIDocument *aDocument) = 0;
-# 80 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void ContentStateChanged(nsIDocument* aDocument,
-                                   nsIContent* aContent,
-                                   mozilla::EventStates aStateMask) = 0;
-
-
-
-
-
-
-
-  virtual void DocumentStatesChanged(nsIDocument* aDocument,
-                                     mozilla::EventStates aStateMask) = 0;
-# 103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleSheetAdded(mozilla::StyleSheet* aStyleSheet,
-                               bool aDocumentSheet) = 0;
-# 116 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleSheetRemoved(mozilla::StyleSheet* aStyleSheet,
-                                 bool aDocumentSheet) = 0;
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleSheetApplicableStateChanged(mozilla::StyleSheet* aStyleSheet) = 0;
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet) = 0;
-# 150 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet) = 0;
-# 161 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocumentObserver.h"
-  virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet) = 0;
-};
-
-template<typename T> struct nsIDocumentObserver::COMTypeInfo<nsIDocumentObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDocumentObserver::COMTypeInfo<nsIDocumentObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x71041fa3, 0x6dd7, 0x4cde, { 0xbb, 0x76, 0xae, 0xcc, 0x69, 0xe1, 0x75, 0x78 } };
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h"
-class nsISimpleEnumerator;
-
-class nsIRequestObserver;
-
-class nsIInterfaceRequestor;
-
-class nsIRequestContext;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILoadGroup.h"
-class nsILoadGroup : public nsIRequest {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetGroupObserver(nsIRequestObserver * *aGroupObserver) = 0;
-  virtual nsresult SetGroupObserver(nsIRequestObserver *aGroupObserver) = 0;
-
-
-  virtual nsresult GetDefaultLoadRequest(nsIRequest * *aDefaultLoadRequest) = 0;
-  virtual nsresult SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest) = 0;
-
-
-  virtual nsresult AddRequest(nsIRequest *aRequest, nsISupports *aContext) = 0;
-
-
-  virtual nsresult RemoveRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatus) = 0;
-
-
-  virtual nsresult GetRequests(nsISimpleEnumerator * *aRequests) = 0;
-
-
-  virtual nsresult GetActiveCount(uint32_t *aActiveCount) = 0;
-
-
-  virtual nsresult GetNotificationCallbacks(nsIInterfaceRequestor * *aNotificationCallbacks) = 0;
-  virtual nsresult SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) = 0;
-
-
-  virtual nsresult GetRequestContextID(uint64_t *aRequestContextID) = 0;
-
-
-  virtual nsresult GetDefaultLoadFlags(nsLoadFlags *aDefaultLoadFlags) = 0;
-  virtual nsresult SetDefaultLoadFlags(nsLoadFlags aDefaultLoadFlags) = 0;
-
-
-  virtual nsresult GetUserAgentOverrideCache(nsACString & aUserAgentOverrideCache) = 0;
-  virtual nsresult SetUserAgentOverrideCache(const nsACString & aUserAgentOverrideCache) = 0;
-
-};
-
-  template<typename T> struct nsILoadGroup::COMTypeInfo<nsILoadGroup, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILoadGroup::COMTypeInfo<nsILoadGroup, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf0c87725, 0x7a35, 0x463c, { 0x9c, 0xeb, 0x2c, 0x07, 0xf2, 0x34, 0x06, 0xcc }};
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h"
-class nsIRequest;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIRequestObserver.h"
-class nsIRequestObserver : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) = 0;
-
-
-  virtual nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode) = 0;
-
-};
-
-  template<typename T> struct nsIRequestObserver::COMTypeInfo<nsIRequestObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIRequestObserver::COMTypeInfo<nsIRequestObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xfd91e2e0, 0x1481, 0x11d3, { 0x93, 0x33, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h" 2
-
-
-
-
-
-
-class nsIInputStream;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStreamListener.h"
-class nsIStreamListener : public nsIRequestObserver {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext, nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount) = 0;
-
-};
-
-  template<typename T> struct nsIStreamListener::COMTypeInfo<nsIStreamListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStreamListener::COMTypeInfo<nsIStreamListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x3b4c8a77, 0x76ba, 0x4610, { 0xb3, 0x16, 0x67, 0x8c, 0x73, 0xa3, 0xb8, 0x8c }};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h"
-class nsScanner;
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITokenizer.h"
-class nsITokenizer : public nsISupports {
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  virtual nsresult WillTokenize(bool aIsFinalChunk)=0;
-  virtual nsresult ConsumeToken(nsScanner& aScanner,bool& aFlushTokens)=0;
-};
-
-template<typename T> struct nsITokenizer::COMTypeInfo<nsITokenizer, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITokenizer::COMTypeInfo<nsITokenizer, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0Xae98a348, 0X5e91, 0X41a8, { 0Xa5, 0Xb4, 0Xd2, 0X20, 0Xf3, 0X1f, 0Xc4, 0Xab } };
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h" 2
-
-
-
-
-
-enum eAutoDetectResult {
-    eUnknownDetect,
-    eValidDetect,
-    ePrimaryDetect,
-    eInvalidDetect
-};
-
-enum nsDTDMode {
-    eDTDMode_unknown = 0,
-    eDTDMode_quirks,
-    eDTDMode_almost_standards,
-    eDTDMode_full_standards,
-    eDTDMode_autodetect,
-    eDTDMode_fragment
-};
-
-
-class nsIContentSink;
-class CParserContext;
-
-class nsIDTD : public nsISupports
-{
-public:
-
-    template<typename T, typename U> struct COMTypeInfo;
-
-    virtual nsresult WillBuildModel(const CParserContext& aParserContext,
-                              nsITokenizer* aTokenizer,
-                              nsIContentSink* aSink) = 0;
-
-
-
-
-
-
-
-    virtual nsresult DidBuildModel(nsresult anErrorCode) = 0;
-# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
-    virtual nsresult BuildModel(nsITokenizer* aTokenizer, nsIContentSink* aSink) = 0;
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
-    virtual bool CanContain(int32_t aParent,int32_t aChild) const = 0;
-# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
-    virtual bool IsContainer(int32_t aTag) const = 0;
-# 114 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDTD.h"
-    virtual void Terminate() = 0;
-
-    virtual int32_t GetType() = 0;
-
-
-
-
-
-    virtual nsDTDMode GetMode() const = 0;
-};
-
-template<typename T> struct nsIDTD::COMTypeInfo<nsIDTD, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDTD::COMTypeInfo<nsIDTD, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x3de05873, 0xefa7, 0x410d, { 0xa4, 0x61, 0x80, 0x33, 0xaf, 0xd9, 0xe3, 0x26 } };
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsParserBase.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsParserBase.h"
-class nsParserBase : public nsISupports
-{
-  public:
-    virtual bool IsParserEnabled() { return true; }
-    virtual nsresult GetChannel(nsIChannel** aChannel) {
-      *aChannel = nullptr;
-      return NS_OK;
-    }
-};
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h" 2
-
-
-
-
-
-class nsIContentSink;
-class nsIRequestObserver;
-class nsString;
-class nsIURI;
-class nsIChannel;
-
-enum eParserCommands {
-  eViewNormal,
-  eViewSource,
-  eViewFragment,
-  eViewErrors
-};
-
-enum eParserDocType {
-  ePlainText = 0,
-  eXML,
-  eHTML_Quirks,
-  eHTML_Strict
-};
-
-enum eStreamState {eNone,eOnStart,eOnDataAvail,eOnStop};
-# 65 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-class nsIParser : public nsParserBase {
-  public:
-
-    template<typename T, typename U> struct COMTypeInfo;
-
-
-
-
-
-
-
-    virtual void SetContentSink(nsIContentSink* aSink)=0;
-
-
-
-
-
-
-
-    virtual nsIContentSink* GetContentSink(void)=0;
-# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-    virtual void GetCommand(nsCString& aCommand)=0;
-    virtual void SetCommand(const char* aCommand)=0;
-    virtual void SetCommand(eParserCommands aParserCommand)=0;
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-    virtual void SetDocumentCharset(const nsACString& aCharset, int32_t aSource)=0;
-    virtual void GetDocumentCharset(nsACString& oCharset, int32_t& oSource)=0;
-
-
-
-
-
-
-
-    virtual nsresult GetChannel(nsIChannel** aChannel) override = 0;
-
-
-
-
-
-
-
-    virtual nsresult GetDTD(nsIDTD** aDTD) = 0;
-
-
-
-
-    virtual nsIStreamListener* GetStreamListener() = 0;
-# 144 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-    virtual nsresult ContinueInterruptedParsing() = 0;
-
-
-    virtual void BlockParser() = 0;
-
-
-
-
-
-    virtual void UnblockParser() = 0;
-
-
-
-
-    virtual void ContinueInterruptedParsingAsync() = 0;
-
-    virtual bool IsParserEnabled() override = 0;
-    virtual bool IsComplete() = 0;
-
-    virtual nsresult Parse(nsIURI* aURL,
-                     nsIRequestObserver* aListener = nullptr,
-                     void* aKey = 0,
-                     nsDTDMode aMode = eDTDMode_autodetect) = 0;
-
-    virtual nsresult Terminate(void) = 0;
-# 179 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-    virtual nsresult ParseFragment(const nsAString& aSourceBuffer,
-                             nsTArray<nsString>& aTagStack) = 0;
-
-
-
-
-
-
-
-    virtual nsresult BuildModel(void) = 0;
-# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIParser.h"
-    virtual nsresult CancelParsingEvents() = 0;
-
-    virtual void Reset() = 0;
-
-
-
-
-    virtual bool IsInsertionPointDefined() = 0;
-
-
-
-
-
-    virtual void PushDefinedInsertionPoint() = 0;
-
-
-
-
-
-
-    virtual void PopDefinedInsertionPoint() = 0;
-
-
-
-
-    virtual void MarkAsNotScriptCreated(const char* aCommand) = 0;
-
-
-
-
-    virtual bool IsScriptCreated() = 0;
-};
-
-template<typename T> struct nsIParser::COMTypeInfo<nsIParser, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIParser::COMTypeInfo<nsIParser, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x2c4ad90a, 0x740e, 0x4212, { 0xba, 0x3f, 0xfe, 0xac, 0xda, 0x4b, 0x92, 0x9e } };
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h"
-class nsIServiceManager : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetService(const nsCID & aClass, const nsIID & aIID, void **result) = 0;
-
-
-  virtual nsresult GetServiceByContractID(const char * aContractID, const nsIID & aIID, void **result) = 0;
-
-
-  virtual nsresult IsServiceInstantiated(const nsCID & aClass, const nsIID & aIID, bool *_retval) = 0;
-
-
-  virtual nsresult IsServiceInstantiatedByContractID(const char * aContractID, const nsIID & aIID, bool *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIServiceManager::COMTypeInfo<nsIServiceManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIServiceManager::COMTypeInfo<nsIServiceManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8bb35ed9, 0xe332, 0x462d, { 0x91, 0x55, 0x4a, 0x00, 0x2a, 0xb5, 0xc9, 0x58 }};
-# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFactory.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFactory.h"
-class nsIFactory : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult CreateInstance(nsISupports *aOuter, const nsIID & iid, void **result) = 0;
-
-
-  virtual nsresult LockFactory(bool lock) = 0;
-
-};
-
-  template<typename T> struct nsIFactory::COMTypeInfo<nsIFactory, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFactory::COMTypeInfo<nsIFactory, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x00000001, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 }};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h" 2
-
-
-nsresult CallCreateInstance(const nsCID& aClass, nsISupports* aDelegate,
-                            const nsIID& aIID, void** aResult);
-
-nsresult CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
-                            const nsIID& aIID, void** aResult);
-
-nsresult CallGetClassObject(const nsCID& aClass, const nsIID& aIID,
-                            void** aResult);
-
-nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
-                            void** aResult);
-
-
-class nsCreateInstanceByCID final : public nsCOMPtr_helper
-{
-public:
-  nsCreateInstanceByCID(const nsCID& aCID, nsresult* aErrorPtr)
-    : mCID(aCID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const
-    override;
-
-private:
-  const nsCID& mCID;
-  nsresult* mErrorPtr;
-};
-
-class nsCreateInstanceByContractID final : public nsCOMPtr_helper
-{
-public:
-  nsCreateInstanceByContractID(const char* aContractID, nsresult* aErrorPtr)
-    : mContractID(aContractID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const override;
-
-private:
-  const char* mContractID;
-  nsresult* mErrorPtr;
-};
-
-class nsCreateInstanceFromFactory final : public nsCOMPtr_helper
-{
-public:
-  nsCreateInstanceFromFactory(nsIFactory* aFactory, nsresult* aErrorPtr)
-    : mFactory(aFactory)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const override;
-
-private:
-  nsIFactory* mFactory;
-  nsresult* mErrorPtr;
-};
-
-
-inline const nsCreateInstanceByCID
-do_CreateInstance(const nsCID& aCID, nsresult* aError = 0)
-{
-  return nsCreateInstanceByCID(aCID, aError);
-}
-
-inline const nsCreateInstanceByContractID
-do_CreateInstance(const char* aContractID, nsresult* aError = 0)
-{
-  return nsCreateInstanceByContractID(aContractID, aError);
-}
-
-inline const nsCreateInstanceFromFactory
-do_CreateInstance(nsIFactory* aFactory, nsresult* aError = 0)
-{
-  return nsCreateInstanceFromFactory(aFactory, aError);
-}
-
-
-class nsGetClassObjectByCID final : public nsCOMPtr_helper
-{
-public:
-  nsGetClassObjectByCID(const nsCID& aCID, nsresult* aErrorPtr)
-    : mCID(aCID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const override;
-
-private:
-  const nsCID& mCID;
-  nsresult* mErrorPtr;
-};
-
-class nsGetClassObjectByContractID final : public nsCOMPtr_helper
-{
-public:
-  nsGetClassObjectByContractID(const char* aContractID, nsresult* aErrorPtr)
-    : mContractID(aContractID)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const override;
-
-private:
-  const char* mContractID;
-  nsresult* mErrorPtr;
-};
-# 137 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsComponentManagerUtils.h"
-inline const nsGetClassObjectByCID
-do_GetClassObject(const nsCID& aCID, nsresult* aError = 0)
-{
-  return nsGetClassObjectByCID(aCID, aError);
-}
-
-inline const nsGetClassObjectByContractID
-do_GetClassObject(const char* aContractID, nsresult* aError = 0)
-{
-  return nsGetClassObjectByContractID(aContractID, aError);
-}
-
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(const nsCID& aClass,
-                   nsISupports* aDelegate,
-                   DestinationType** aDestination)
-{
-  do { } while(0);
-
-  return CallCreateInstance(aClass, aDelegate,
-                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(const nsCID& aClass, DestinationType** aDestination)
-{
-  do { } while(0);
-
-  return CallCreateInstance(aClass, nullptr,
-                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(const char* aContractID,
-                   nsISupports* aDelegate,
-                   DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return CallCreateInstance(aContractID,
-                            aDelegate,
-                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(const char* aContractID, DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return CallCreateInstance(aContractID, nullptr,
-                            (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(nsIFactory* aFactory,
-                   nsISupports* aDelegate,
-                   DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return aFactory->CreateInstance(aDelegate,
-                                  (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                                  reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallCreateInstance(nsIFactory* aFactory, DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return aFactory->CreateInstance(nullptr,
-                                  (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                                  reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallGetClassObject(const nsCID& aClass, DestinationType** aDestination)
-{
-  do { } while(0);
-
-  return CallGetClassObject(aClass, (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallGetClassObject(const char* aContractID, DestinationType** aDestination)
-{
-  do { } while(0);
-
-  return CallGetClassObject(aContractID, (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                            reinterpret_cast<void**>(aDestination));
-}
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsServiceManagerUtils.h" 2
-
-
-inline const nsGetServiceByCID
-do_GetService(const nsCID& aCID)
-{
-  return nsGetServiceByCID(aCID);
-}
-
-inline const nsGetServiceByCIDWithError
-do_GetService(const nsCID& aCID, nsresult* aError)
-{
-  return nsGetServiceByCIDWithError(aCID, aError);
-}
-
-inline const nsGetServiceByContractID
-do_GetService(const char* aContractID)
-{
-  return nsGetServiceByContractID(aContractID);
-}
-
-inline const nsGetServiceByContractIDWithError
-do_GetService(const char* aContractID, nsresult* aError)
-{
-  return nsGetServiceByContractIDWithError(aContractID, aError);
-}
-
-class nsGetServiceFromCategory final : public nsCOMPtr_helper
-{
-public:
-  nsGetServiceFromCategory(const char* aCategory, const char* aEntry,
-                           nsresult* aErrorPtr)
-    : mCategory(aCategory)
-    , mEntry(aEntry)
-    , mErrorPtr(aErrorPtr)
-  {
-  }
-
-  virtual nsresult operator()(const nsIID&, void**) const
-    override;
-protected:
-  const char* mCategory;
-  const char* mEntry;
-  nsresult* mErrorPtr;
-};
-
-inline const nsGetServiceFromCategory
-do_GetServiceFromCategory(const char* aCategory, const char* aEntry,
-                          nsresult* aError = 0)
-{
-  return nsGetServiceFromCategory(aCategory, aEntry, aError);
-}
-
-nsresult CallGetService(const nsCID& aClass, const nsIID& aIID, void** aResult);
-
-nsresult CallGetService(const char* aContractID, const nsIID& aIID,
-                        void** aResult);
-
-
-template<class DestinationType>
-inline nsresult
-CallGetService(const nsCID& aClass,
-               DestinationType** aDestination)
-{
-  do { } while(0);
-
-  return CallGetService(aClass,
-                        (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                        reinterpret_cast<void**>(aDestination));
-}
-
-template<class DestinationType>
-inline nsresult
-CallGetService(const char* aContractID,
-               DestinationType** aDestination)
-{
-  do { } while(0);
-  do { } while(0);
-
-  return CallGetService(aContractID,
-                        (DestinationType::template COMTypeInfo<DestinationType, void>::kIID),
-                        reinterpret_cast<void**>(aDestination));
-}
-# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIServiceManager.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIUUIDGenerator.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIUUIDGenerator.h"
-class nsIUUIDGenerator : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GenerateUUID(nsID **_retval) = 0;
-
-
-  virtual nsresult GenerateUUIDInPlace(nsID *id) = 0;
-
-};
-
-  template<typename T> struct nsIUUIDGenerator::COMTypeInfo<nsIUUIDGenerator, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIUUIDGenerator::COMTypeInfo<nsIUUIDGenerator, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x138ad1b2, 0xc694, 0x41cc, { 0xb2, 0x01, 0x33, 0x3c, 0xe9, 0x36, 0xd8, 0xb8 }};
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsURIHashKey.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsURIHashKey.h"
-class nsURIHashKey : public PLDHashEntryHdr
-{
-public:
-    typedef nsIURI* KeyType;
-    typedef const nsIURI* KeyTypePointer;
-
-    explicit nsURIHashKey(const nsIURI* aKey) :
-        mKey(const_cast<nsIURI*>(aKey)) { ; }
-    nsURIHashKey(const nsURIHashKey& toCopy) :
-        mKey(toCopy.mKey) { ; }
-    ~nsURIHashKey() { ; }
-
-    nsIURI* GetKey() const { return mKey; }
-
-    bool KeyEquals(const nsIURI* aKey) const {
-        bool eq;
-        if (!mKey) {
-            return !aKey;
-        }
-        if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(mKey->Equals(const_cast<nsIURI*>(aKey), &eq))), 1)))) {
-            return eq;
-        }
-        return false;
-    }
-
-    static const nsIURI* KeyToPointer(nsIURI* aKey) { return aKey; }
-    static PLDHashNumber HashKey(const nsIURI* aKey) {
-        if (!aKey) {
-
-            return mozilla::HashString(EmptyCString());
-        }
-        nsAutoCString spec;
-
-
-        mozilla::Unused << const_cast<nsIURI*>(aKey)->GetSpec(spec);
-        return mozilla::HashString(spec);
-    }
-
-    enum { ALLOW_MEMMOVE = true };
-
-protected:
-    nsCOMPtr<nsIURI> mKey;
-};
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h"
-namespace mozilla {
-
-enum UseCounter : int16_t {
-  eUseCounter_UNKNOWN = -1,
-
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UseCounterList.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/UseCounterList.h"
-eUseCounter_SVGSVGElement_getElementById,
-eUseCounter_SVGSVGElement_currentScale_getter, eUseCounter_SVGSVGElement_currentScale_setter,
-eUseCounter_property_Fill,
-eUseCounter_property_FillOpacity,
-eUseCounter_PushManager_subscribe,
-eUseCounter_PushSubscription_unsubscribe,
-eUseCounter_Window_sidebar_getter, eUseCounter_Window_sidebar_setter,
-eUseCounter_External_addSearchEngine,
-eUseCounter_OfflineResourceList_swapCache,
-eUseCounter_OfflineResourceList_update,
-eUseCounter_OfflineResourceList_status_getter, eUseCounter_OfflineResourceList_status_setter,
-eUseCounter_OfflineResourceList_onchecking_getter, eUseCounter_OfflineResourceList_onchecking_setter,
-eUseCounter_OfflineResourceList_onerror_getter, eUseCounter_OfflineResourceList_onerror_setter,
-eUseCounter_OfflineResourceList_onnoupdate_getter, eUseCounter_OfflineResourceList_onnoupdate_setter,
-eUseCounter_OfflineResourceList_ondownloading_getter, eUseCounter_OfflineResourceList_ondownloading_setter,
-eUseCounter_OfflineResourceList_onprogress_getter, eUseCounter_OfflineResourceList_onprogress_setter,
-eUseCounter_OfflineResourceList_onupdateready_getter, eUseCounter_OfflineResourceList_onupdateready_setter,
-eUseCounter_OfflineResourceList_oncached_getter, eUseCounter_OfflineResourceList_oncached_setter,
-eUseCounter_OfflineResourceList_onobsolete_getter, eUseCounter_OfflineResourceList_onobsolete_setter,
-eUseCounter_IDBDatabase_createMutableFile,
-eUseCounter_IDBDatabase_mozCreateFileHandle,
-eUseCounter_IDBMutableFile_open,
-eUseCounter_IDBMutableFile_getFile,
-eUseCounter_DataTransfer_addElement,
-eUseCounter_DataTransfer_mozItemCount_getter, eUseCounter_DataTransfer_mozItemCount_setter,
-eUseCounter_DataTransfer_mozCursor_getter, eUseCounter_DataTransfer_mozCursor_setter,
-eUseCounter_DataTransfer_mozTypesAt,
-eUseCounter_DataTransfer_mozClearDataAt,
-eUseCounter_DataTransfer_mozSetDataAt,
-eUseCounter_DataTransfer_mozGetDataAt,
-eUseCounter_DataTransfer_mozUserCancelled_getter, eUseCounter_DataTransfer_mozUserCancelled_setter,
-eUseCounter_DataTransfer_mozSourceNode_getter, eUseCounter_DataTransfer_mozSourceNode_setter,
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h"
-eUseCounter_GetAttributeNode,
-eUseCounter_SetAttributeNode,
-eUseCounter_GetAttributeNodeNS,
-eUseCounter_SetAttributeNodeNS,
-eUseCounter_RemoveAttributeNode,
-eUseCounter_CreateAttribute,
-eUseCounter_CreateAttributeNS,
-eUseCounter_NodeValue,
-eUseCounter_TextContent,
-eUseCounter_EnablePrivilege,
-eUseCounter_DOMExceptionCode,
-eUseCounter_NoExposedProps,
-eUseCounter_MutationEvent,
-eUseCounter_Components,
-eUseCounter_PrefixedVisibilityAPI,
-eUseCounter_NodeIteratorDetach,
-eUseCounter_LenientThis,
-eUseCounter_GetPreventDefault,
-eUseCounter_GetSetUserData,
-eUseCounter_MozGetAsFile,
-eUseCounter_UseOfCaptureEvents,
-eUseCounter_UseOfReleaseEvents,
-eUseCounter_UseOfDOM3LoadMethod,
-eUseCounter_ChromeUseOfDOM3LoadMethod,
-eUseCounter_ShowModalDialog,
-eUseCounter_Window_Content,
-eUseCounter_SyncXMLHttpRequest,
-eUseCounter_DataContainerEvent,
-eUseCounter_Window_Controllers,
-eUseCounter_ImportXULIntoContent,
-eUseCounter_PannerNodeDoppler,
-eUseCounter_NavigatorGetUserMedia,
-eUseCounter_WebrtcDeprecatedPrefix,
-eUseCounter_RTCPeerConnectionGetStreams,
-eUseCounter_AppCache,
-eUseCounter_PrefixedImageSmoothingEnabled,
-eUseCounter_PrefixedFullscreenAPI,
-eUseCounter_LenientSetter,
-eUseCounter_FileLastModifiedDate,
-eUseCounter_ImageBitmapRenderingContext_TransferImageBitmap,
-eUseCounter_URLCreateObjectURL_MediaStream,
-eUseCounter_XMLBaseAttribute,
-eUseCounter_XMLBaseAttributeForStyleAttr,
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/UseCounter.h" 2
-
-
-  eUseCounter_Count
-};
-
-}
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h"
-class nsContentList;
-class nsIAtom;
-class nsIContent;
-class nsINode;
-
-class nsString;
-class nsAString;
-
-namespace mozilla {
-namespace dom {
-class Element;
-}
-}
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsContentListDeclarations.h"
-typedef bool (*nsContentListMatchFunc)(mozilla::dom::Element* aElement,
-                                       int32_t aNamespaceID,
-                                       nsIAtom* aAtom,
-                                       void* aData);
-
-typedef void (*nsContentListDestroyFunc)(void* aData);
-
-
-
-
-
-
-typedef void* (*nsFuncStringContentListDataAllocator)(nsINode* aRootNode,
-                                                      const nsString* aString);
-
-
-
-
-
-
-already_AddRefed<nsContentList>
-NS_GetContentList(nsINode* aRootNode,
-                  int32_t aMatchNameSpaceId,
-                  const nsAString& aTagname);
-
-already_AddRefed<nsContentList>
-NS_GetFuncStringNodeList(nsINode* aRootNode,
-                         nsContentListMatchFunc aFunc,
-                         nsContentListDestroyFunc aDestroyFunc,
-                         nsFuncStringContentListDataAllocator aDataAllocator,
-                         const nsAString& aString);
-already_AddRefed<nsContentList>
-NS_GetFuncStringHTMLCollection(nsINode* aRootNode,
-                               nsContentListMatchFunc aFunc,
-                               nsContentListDestroyFunc aDestroyFunc,
-                               nsFuncStringContentListDataAllocator aDataAllocator,
-                               const nsAString& aString);
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h" 1
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
-namespace mozilla {
-# 51 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
-enum class LogLevel {
-  Disabled = 0,
-  Error,
-  Warning,
-  Info,
-  Debug,
-  Verbose,
-};
-
-
-
-
-LogLevel ToLogLevel(int32_t aLevel);
-
-class LogModule
-{
-public:
-  ~LogModule() { ::free(mName); }
-# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
-  static LogModule* Get(const char* aName);
-
-  static void Init();
-
-
-
-
-  static void SetLogFile(const char* aFilename);
-
-
-
-
-
-
-
-  static uint32_t GetLogFile(char *aBuffer, size_t aLength);
-
-
-
-
-  static void SetAddTimestamp(bool aAddTimestamp);
-
-
-
-
-  static void SetIsSync(bool aIsSync);
-
-
-
-
-  bool ShouldLog(LogLevel aLevel) const { return mLevel >= aLevel; }
-
-
-
-
-  LogLevel Level() const { return mLevel; }
-
-
-
-
-  void SetLevel(LogLevel level) { mLevel = level; }
-
-
-
-
-  void Printv(LogLevel aLevel, const char* aFmt, va_list aArgs) const;
-
-
-
-
-  const char* Name() const { return mName; }
-
-private:
-  friend class LogModuleManager;
-
-  explicit LogModule(const char* aName, LogLevel aLevel)
-    : mName(strdup(aName)), mLevel(aLevel)
-  {
-  }
-
-  LogModule(LogModule&) = delete;
-  LogModule& operator=(const LogModule&) = delete;
-
-  char* mName;
-  Atomic<LogLevel, Relaxed> mLevel;
-};
-# 156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Logging.h"
-class LazyLogModule final
-{
-public:
-  explicit constexpr LazyLogModule(const char* aLogName)
-    : mLogName(aLogName)
-    , mLog(nullptr)
-  {
-  }
-
-  operator LogModule*()
-  {
-
-
-
-
-    LogModule* tmp = mLog;
-    if ((__builtin_expect(!!(!tmp), 0))) {
-      tmp = LogModule::Get(mLogName);
-      mLog = tmp;
-    }
-
-    return tmp;
-  }
-
-private:
-  const char* const mLogName;
-  Atomic<LogModule*, ReleaseAcquire> mLog;
-};
-
-namespace detail {
-
-inline bool log_test(const LogModule* module, LogLevel level) {
-  do { } while (0);
-  return module && module->ShouldLog(level);
-}
-
-void log_print(const LogModule* aModule,
-               LogLevel aLevel,
-               const char* aFmt, ...) __attribute__ ((format (printf, 3, 4)));
-}
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h"
-class nsIObserver;
-
-class nsISimpleEnumerator;
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIObserverService.h"
-class nsIObserverService : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult AddObserver(nsIObserver *anObserver, const char * aTopic, bool ownsWeak) = 0;
-
-
-  virtual nsresult RemoveObserver(nsIObserver *anObserver, const char * aTopic) = 0;
-
-
-  virtual nsresult NotifyObservers(nsISupports *aSubject, const char * aTopic, const char16_t * someData) = 0;
-
-
-  virtual nsresult EnumerateObservers(const char * aTopic, nsISimpleEnumerator * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIObserverService::COMTypeInfo<nsIObserverService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIObserverService::COMTypeInfo<nsIObserverService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xd07f5192, 0xe3d1, 0x11d2, { 0x8a, 0xcd, 0x00, 0x10, 0x5a, 0x1b, 0x88, 0x60 }};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServiceList.h" 1
-
-
-
-
-
-
-
-class nsIChromeRegistry;
-
-class nsIToolkitChromeRegistry;
-
-class nsIXULChromeRegistry;
-
-class nsIXULOverlayProvider;
-
-class nsIIOService;
-
-class nsIObserverService;
-
-class nsIStringBundleService;
-
-class nsIXPConnect;
-
-class inIDOMUtils;
-
-class nsIPermissionManager;;
-
-class nsIServiceWorkerManager;;
-
-class nsIAsyncShutdownService;
-
-class nsIUUIDGenerator;;
-
-class nsIGfxInfo;;
-
-
-
-namespace mozilla {
-
-
-class IHistory;
-
-
-
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 2
-
-
-
-namespace mozilla {
-namespace services {
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServiceList.h" 1
-
-
-
-
-
-
-
-already_AddRefed<nsIChromeRegistry> GetChromeRegistryService();
-
-already_AddRefed<nsIToolkitChromeRegistry> GetToolkitChromeRegistryService();
-
-already_AddRefed<nsIXULChromeRegistry> GetXULChromeRegistryService();
-
-already_AddRefed<nsIXULOverlayProvider> GetXULOverlayProviderService();
-
-already_AddRefed<nsIIOService> GetIOService();
-
-already_AddRefed<nsIObserverService> GetObserverService();
-
-already_AddRefed<nsIStringBundleService> GetStringBundleService();
-
-already_AddRefed<nsIXPConnect> GetXPConnect();
-
-already_AddRefed<inIDOMUtils> GetInDOMUtils();
-
-already_AddRefed<nsIPermissionManager> GetPermissionManager();;
-
-already_AddRefed<nsIServiceWorkerManager> GetServiceWorkerManager();;
-
-already_AddRefed<nsIAsyncShutdownService> GetAsyncShutdown();
-
-already_AddRefed<nsIUUIDGenerator> GetUUIDGenerator();;
-
-already_AddRefed<nsIGfxInfo> GetGfxInfo();;
-
-
-
-
-
-
-already_AddRefed<IHistory> GetHistoryService();
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Services.h" 2
-
-
-
-}
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h" 2
-
-
-
-
-
-
-struct nsExpirationState
-{
-  enum
-  {
-    NOT_TRACKED = (1U << 4) - 1,
-    MAX_INDEX_IN_GENERATION = (1U << 28) - 1
-  };
-
-  nsExpirationState() : mGeneration(NOT_TRACKED) {}
-  bool IsTracked() { return mGeneration != NOT_TRACKED; }
-
-
-
-
-  uint32_t mGeneration:4;
-  uint32_t mIndexInGeneration:28;
-};
-# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-template<typename T, uint32_t K, typename Mutex, typename AutoLock>
-class ExpirationTrackerImpl
-{
-public:
-# 106 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-  ExpirationTrackerImpl(uint32_t aTimerPeriod,
-                        const char* aName,
-                        nsIEventTarget* aEventTarget = nullptr)
-    : mTimerPeriod(aTimerPeriod)
-    , mNewestGeneration(0)
-    , mInAgeOneGeneration(false)
-    , mName(aName)
-    , mEventTarget(aEventTarget)
-  {
-    static_assert(K >= 2 && K <= nsExpirationState::NOT_TRACKED,
-                  "Unsupported number of generations (must be 2 <= K <= 15)");
-    do { } while (0);
-    if (mEventTarget) {
-      bool current = false;
-
-
-
-
-      if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(NS_FAILED_impl(mEventTarget->IsOnCurrentThread(&current))), 0))) || !current), 0))) {
-
-        do { AnnotateMozCrashReason("MOZ_CRASH(" "Provided event target must be on the main thread" ")"); do { *((volatile int*) __null) = 126; ::abort(); } while (0); } while (0);
-      }
-    }
-    mObserver = new ExpirationTrackerObserver();
-    mObserver->Init(this);
-  }
-
-  virtual ~ExpirationTrackerImpl()
-  {
-    do { } while (0);
-    if (mTimer) {
-      mTimer->Cancel();
-    }
-    mObserver->Destroy();
-  }
-
-
-
-
-
-
-  nsresult AddObjectLocked(T* aObj, const AutoLock& aAutoLock)
-  {
-    nsExpirationState* state = aObj->GetExpirationState();
-    do { } while(0);
-
-    nsTArray<T*>& generation = mGenerations[mNewestGeneration];
-    uint32_t index = generation.Length();
-    if (index > nsExpirationState::MAX_INDEX_IN_GENERATION) {
-      do { } while(0);
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-    if (index == 0) {
-
-      nsresult rv = CheckStartTimerLocked(aAutoLock);
-      if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
-        return rv;
-      }
-    }
-    if (!generation.AppendElement(aObj)) {
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-    state->mGeneration = mNewestGeneration;
-    state->mIndexInGeneration = index;
-    return NS_OK;
-  }
-
-
-
-
-  void RemoveObjectLocked(T* aObj, const AutoLock& aAutoLock)
-  {
-    nsExpirationState* state = aObj->GetExpirationState();
-    do { } while(0);
-    nsTArray<T*>& generation = mGenerations[state->mGeneration];
-    uint32_t index = state->mIndexInGeneration;
-    do { } while(0);
-
-
-    uint32_t last = generation.Length() - 1;
-    T* lastObj = generation[last];
-    generation[index] = lastObj;
-    lastObj->GetExpirationState()->mIndexInGeneration = index;
-    generation.RemoveElementAt(last);
-    state->mGeneration = nsExpirationState::NOT_TRACKED;
-
-
-
-
-
-  }
-
-
-
-
-
-  nsresult MarkUsedLocked(T* aObj, const AutoLock& aAutoLock)
-  {
-    nsExpirationState* state = aObj->GetExpirationState();
-    if (mNewestGeneration == state->mGeneration) {
-      return NS_OK;
-    }
-    RemoveObjectLocked(aObj, aAutoLock);
-    return AddObjectLocked(aObj, aAutoLock);
-  }
-
-
-
-
-
-  void AgeOneGenerationLocked(const AutoLock& aAutoLock)
-  {
-    if (mInAgeOneGeneration) {
-      do { } while(0);
-      return;
-    }
-
-    mInAgeOneGeneration = true;
-    uint32_t reapGeneration =
-      mNewestGeneration > 0 ? mNewestGeneration - 1 : K - 1;
-    nsTArray<T*>& generation = mGenerations[reapGeneration];
-# 235 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-    size_t index = generation.Length();
-    for (;;) {
-
-
-      index = XPCOM_MIN(index, generation.Length());
-      if (index == 0) {
-        break;
-      }
-      --index;
-      NotifyExpiredLocked(generation[index], aAutoLock);
-    }
-
-
-    if (!generation.IsEmpty()) {
-      do { } while(0);
-    }
-
-
-    generation.Compact();
-    mNewestGeneration = reapGeneration;
-    mInAgeOneGeneration = false;
-  }
-# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-  void AgeAllGenerationsLocked(const AutoLock& aAutoLock)
-  {
-    uint32_t i;
-    for (i = 0; i < K; ++i) {
-      AgeOneGenerationLocked(aAutoLock);
-    }
-  }
-
-  class Iterator
-  {
-  private:
-    ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mTracker;
-    uint32_t mGeneration;
-    uint32_t mIndex;
-  public:
-    Iterator(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aTracker,
-             AutoLock& aAutoLock)
-      : mTracker(aTracker)
-      , mGeneration(0)
-      , mIndex(0)
-    {
-    }
-
-    T* Next()
-    {
-      while (mGeneration < K) {
-        nsTArray<T*>* generation = &mTracker->mGenerations[mGeneration];
-        if (mIndex < generation->Length()) {
-          ++mIndex;
-          return (*generation)[mIndex - 1];
-        }
-        ++mGeneration;
-        mIndex = 0;
-      }
-      return nullptr;
-    }
-  };
-
-  friend class Iterator;
-
-  bool IsEmptyLocked(const AutoLock& aAutoLock)
-  {
-    for (uint32_t i = 0; i < K; ++i) {
-      if (!mGenerations[i].IsEmpty()) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-protected:
-# 342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsExpirationTracker.h"
-  virtual void NotifyExpiredLocked(T*, const AutoLock&) = 0;
-
-  virtual Mutex& GetMutex() = 0;
-
-private:
-  class ExpirationTrackerObserver;
-  RefPtr<ExpirationTrackerObserver> mObserver;
-  nsTArray<T*> mGenerations[K];
-  nsCOMPtr<nsITimer> mTimer;
-  uint32_t mTimerPeriod;
-  uint32_t mNewestGeneration;
-  bool mInAgeOneGeneration;
-  const char* const mName;
-  const nsCOMPtr<nsIEventTarget> mEventTarget;
-
-
-
-
-
-  class ExpirationTrackerObserver final : public nsIObserver
-  {
-  public:
-    void Init(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aObj)
-    {
-      mOwner = aObj;
-      nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-      if (obs) {
-        obs->AddObserver(this, "memory-pressure", false);
-      }
-    }
-    void Destroy()
-    {
-      mOwner = nullptr;
-      nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-      if (obs) {
-        obs->RemoveObserver(this, "memory-pressure");
-      }
-    }
-    public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-    virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
-  private:
-    ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mOwner;
-  };
-
-  void HandleLowMemory() {
-    AutoLock lock(GetMutex());
-    AgeAllGenerationsLocked(lock);
-  }
-
-  void HandleTimeout() {
-    AutoLock lock(GetMutex());
-    AgeOneGenerationLocked(lock);
-
-    if (IsEmptyLocked(lock)) {
-      mTimer->Cancel();
-      mTimer = nullptr;
-    }
-  }
-
-  static void TimerCallback(nsITimer* aTimer, void* aThis)
-  {
-    ExpirationTrackerImpl* tracker = static_cast<ExpirationTrackerImpl*>(aThis);
-    tracker->HandleTimeout();
-  }
-
-  nsresult CheckStartTimerLocked(const AutoLock& aAutoLock)
-  {
-    if (mTimer || !mTimerPeriod) {
-      return NS_OK;
-    }
-    mTimer = do_CreateInstance("@mozilla.org/timer;1");
-    if (!mTimer) {
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-    if (mEventTarget) {
-      mTimer->SetTarget(mEventTarget);
-    } else if (!NS_IsMainThread()) {
-
-
-      nsCOMPtr<nsIEventTarget> target = do_GetMainThread();
-      do { if ((__builtin_expect(!!(!(target)), 0))) { do { } while(0); return NS_ERROR_UNEXPECTED; } } while(0);
-      mTimer->SetTarget(target);
-    }
-    mTimer->InitWithNamedFuncCallback(TimerCallback, this, mTimerPeriod,
-                                      nsITimer::TYPE_REPEATING_SLACK, mName);
-    return NS_OK;
-  }
-};
-
-namespace detail {
-
-class PlaceholderLock {
-public:
-  void Lock() {}
-  void Unlock() {}
-};
-
-class PlaceholderAutoLock {
-public:
-  explicit PlaceholderAutoLock(PlaceholderLock&) { }
-  ~PlaceholderAutoLock() = default;
-
-};
-
-template<typename T, uint32_t K>
-using SingleThreadedExpirationTracker =
-  ExpirationTrackerImpl<T, K, PlaceholderLock, PlaceholderAutoLock>;
-
-}
-
-template<typename T, uint32_t K>
-class nsExpirationTracker : protected ::detail::SingleThreadedExpirationTracker<T, K>
-{
-  typedef ::detail::PlaceholderLock Lock;
-  typedef ::detail::PlaceholderAutoLock AutoLock;
-
-  Lock mLock;
-
-  AutoLock FakeLock() {
-    return AutoLock(mLock);
-  }
-
-  Lock& GetMutex() override
-  {
-    return mLock;
-  }
-
-  void NotifyExpiredLocked(T* aObject, const AutoLock&) override
-  {
-    NotifyExpired(aObject);
-  }
-
-protected:
-  virtual void NotifyExpired(T* aObj) = 0;
-
-public:
-  nsExpirationTracker(uint32_t aTimerPeriod,
-                      const char* aName,
-                      nsIEventTarget* aEventTarget = nullptr)
-    : ::detail::SingleThreadedExpirationTracker<T, K>(aTimerPeriod,
-                                                      aName,
-                                                      aEventTarget)
-  { }
-
-  virtual ~nsExpirationTracker()
-  { }
-
-  nsresult AddObject(T* aObj)
-  {
-    return this->AddObjectLocked(aObj, FakeLock());
-  }
-
-  void RemoveObject(T* aObj)
-  {
-    this->RemoveObjectLocked(aObj, FakeLock());
-  }
-
-  nsresult MarkUsed(T* aObj)
-  {
-    return this->MarkUsedLocked(aObj, FakeLock());
-  }
-
-  void AgeOneGeneration()
-  {
-    this->AgeOneGenerationLocked(FakeLock());
-  }
-
-  void AgeAllGenerations()
-  {
-    this->AgeAllGenerationsLocked(FakeLock());
-  }
-
-  class Iterator
-  {
-  private:
-    AutoLock mAutoLock;
-    typename ExpirationTrackerImpl<T, K, Lock, AutoLock>::Iterator mIterator;
-  public:
-    explicit Iterator(nsExpirationTracker<T, K>* aTracker)
-      : mAutoLock(aTracker->GetMutex())
-      , mIterator(aTracker, mAutoLock)
-    {
-    }
-
-    T* Next()
-    {
-      return mIterator.Next();
-    }
-  };
-
-  friend class Iterator;
-
-  bool IsEmpty()
-  {
-    return this->IsEmptyLocked(FakeLock());
-  }
-};
-
-template<typename T, uint32_t K, typename Mutex, typename AutoLock>
-nsresult
-ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
-ExpirationTrackerObserver::Observe(
-    nsISupports* aSubject, const char* aTopic, const char16_t* aData)
-{
-  if (!strcmp(aTopic, "memory-pressure") && mOwner) {
-    mOwner->HandleLowMemory();
-  }
-  return NS_OK;
-}
-
-template<class T, uint32_t K, typename Mutex, typename AutoLock>
-MozExternalRefCountType
-ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
-ExpirationTrackerObserver::AddRef(void)
-{
-  do { } while (0);
-  ((void)0);
-  ++mRefCnt;
-                                                                          ;
-  return mRefCnt;
-}
-
-template<class T, uint32_t K, typename Mutex, typename AutoLock>
-MozExternalRefCountType
-ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
-ExpirationTrackerObserver::Release(void)
-{
-  do { } while (0);
-  ((void)0);
-  --mRefCnt;
-                                                            ;
-  if (mRefCnt == 0) {
-    ((void)0);
-    mRefCnt = 1;
-    delete (this);
-    return 0;
-  }
-  return mRefCnt;
-}
-
-template<class T, uint32_t K, typename Mutex, typename AutoLock>
-nsresult
-ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
-ExpirationTrackerObserver::QueryInterface(
-    const nsIID& aIID, void** aInstancePtr)
-{
-  do { } while(0);
-
-  nsresult rv = NS_ERROR_FAILURE;
-  static_assert( sizeof("(nsIObserver)") != sizeof("()") && (11) > 10 && (int)(0.01) == 0, "MOZ_STATIC_ASSERT_VALID_ARG_COUNT requires 1 to 50 arguments"); static const QITableEntry table[] = { { &(nsIObserver::COMTypeInfo<nsIObserver, void>::kIID), int32_t(reinterpret_cast<char*>( static_cast<nsIObserver*>((ExpirationTrackerObserver*) 0x1000)) - reinterpret_cast<char*>((ExpirationTrackerObserver*) 0x1000)) }, { &(nsISupports::COMTypeInfo<nsISupports, void>::kIID), int32_t(reinterpret_cast<char*>( static_cast<nsISupports*>( static_cast<nsIObserver*>( (ExpirationTrackerObserver*) 0x1000))) - reinterpret_cast<char*>((ExpirationTrackerObserver*) 0x1000)) }, { nullptr, 0 } }; static_assert((sizeof(table)/sizeof(table[0])) > 1, "need at least 1 interface"); rv = NS_TableDrivenQI(static_cast<void*>(this), aIID, aInstancePtr, table);
-  return rv;
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 1 3
-# 46 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-# 60 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-# 70 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-  template<size_t _Nw>
-    struct _Base_bitset
-    {
-      typedef unsigned long _WordT;
-
-
-      _WordT _M_w[_Nw];
-
-      constexpr _Base_bitset() noexcept
-      : _M_w() { }
-
-
-      constexpr _Base_bitset(unsigned long long __val) noexcept
-      : _M_w{ _WordT(__val)
-
-
-
-       } { }
-
-
-
-
-
-
-      static constexpr size_t
-      _S_whichword(size_t __pos) noexcept
-      { return __pos / (8 * 8); }
-
-      static constexpr size_t
-      _S_whichbyte(size_t __pos) noexcept
-      { return (__pos % (8 * 8)) / 8; }
-
-      static constexpr size_t
-      _S_whichbit(size_t __pos) noexcept
-      { return __pos % (8 * 8); }
-
-      static constexpr _WordT
-      _S_maskbit(size_t __pos) noexcept
-      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
-
-      _WordT&
-      _M_getword(size_t __pos) noexcept
-      { return _M_w[_S_whichword(__pos)]; }
-
-      constexpr _WordT
-      _M_getword(size_t __pos) const noexcept
-      { return _M_w[_S_whichword(__pos)]; }
-
-
-      const _WordT*
-      _M_getdata() const noexcept
-      { return _M_w; }
-
-
-      _WordT&
-      _M_hiword() noexcept
-      { return _M_w[_Nw - 1]; }
-
-      constexpr _WordT
-      _M_hiword() const noexcept
-      { return _M_w[_Nw - 1]; }
-
-      void
-      _M_do_and(const _Base_bitset<_Nw>& __x) noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   _M_w[__i] &= __x._M_w[__i];
-      }
-
-      void
-      _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   _M_w[__i] |= __x._M_w[__i];
-      }
-
-      void
-      _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   _M_w[__i] ^= __x._M_w[__i];
-      }
-
-      void
-      _M_do_left_shift(size_t __shift) noexcept;
-
-      void
-      _M_do_right_shift(size_t __shift) noexcept;
-
-      void
-      _M_do_flip() noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   _M_w[__i] = ~_M_w[__i];
-      }
-
-      void
-      _M_do_set() noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   _M_w[__i] = ~static_cast<_WordT>(0);
-      }
-
-      void
-      _M_do_reset() noexcept
-      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
-
-      bool
-      _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
-      {
- for (size_t __i = 0; __i < _Nw; ++__i)
-   if (_M_w[__i] != __x._M_w[__i])
-     return false;
- return true;
-      }
-
-      template<size_t _Nb>
-        bool
-        _M_are_all() const noexcept
-        {
-   for (size_t __i = 0; __i < _Nw - 1; __i++)
-     if (_M_w[__i] != ~static_cast<_WordT>(0))
-       return false;
-   return _M_hiword() == (~static_cast<_WordT>(0)
-     >> (_Nw * (8 * 8)
-         - _Nb));
- }
-
-      bool
-      _M_is_any() const noexcept
-      {
- for (size_t __i = 0; __i < _Nw; __i++)
-   if (_M_w[__i] != static_cast<_WordT>(0))
-     return true;
- return false;
-      }
-
-      size_t
-      _M_do_count() const noexcept
-      {
- size_t __result = 0;
- for (size_t __i = 0; __i < _Nw; __i++)
-   __result += __builtin_popcountl(_M_w[__i]);
- return __result;
-      }
-
-      unsigned long
-      _M_do_to_ulong() const;
-
-
-      unsigned long long
-      _M_do_to_ullong() const;
-
-
-
-      size_t
-      _M_do_find_first(size_t) const noexcept;
-
-
-      size_t
-      _M_do_find_next(size_t, size_t) const noexcept;
-    };
-
-
-  template<size_t _Nw>
-    void
-    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept
-    {
-      if (__builtin_expect(__shift != 0, 1))
- {
-   const size_t __wshift = __shift / (8 * 8);
-   const size_t __offset = __shift % (8 * 8);
-
-   if (__offset == 0)
-     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
-       _M_w[__n] = _M_w[__n - __wshift];
-   else
-     {
-       const size_t __sub_offset = ((8 * 8)
-        - __offset);
-       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
-  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
-        | (_M_w[__n - __wshift - 1] >> __sub_offset));
-       _M_w[__wshift] = _M_w[0] << __offset;
-     }
-
-   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
- }
-    }
-
-  template<size_t _Nw>
-    void
-    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept
-    {
-      if (__builtin_expect(__shift != 0, 1))
- {
-   const size_t __wshift = __shift / (8 * 8);
-   const size_t __offset = __shift % (8 * 8);
-   const size_t __limit = _Nw - __wshift - 1;
-
-   if (__offset == 0)
-     for (size_t __n = 0; __n <= __limit; ++__n)
-       _M_w[__n] = _M_w[__n + __wshift];
-   else
-     {
-       const size_t __sub_offset = ((8 * 8)
-        - __offset);
-       for (size_t __n = 0; __n < __limit; ++__n)
-  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
-        | (_M_w[__n + __wshift + 1] << __sub_offset));
-       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
-     }
-
-   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
- }
-    }
-
-  template<size_t _Nw>
-    unsigned long
-    _Base_bitset<_Nw>::_M_do_to_ulong() const
-    {
-      for (size_t __i = 1; __i < _Nw; ++__i)
- if (_M_w[__i])
-   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
-      return _M_w[0];
-    }
-
-
-  template<size_t _Nw>
-    unsigned long long
-    _Base_bitset<_Nw>::_M_do_to_ullong() const
-    {
-      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
-      for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
- if (_M_w[__i])
-   __throw_overflow_error(("_Base_bitset::_M_do_to_ullong"));
-
-      if (__dw)
- return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
-     << (8 * 8));
-      return _M_w[0];
-    }
-
-
-  template<size_t _Nw>
-    size_t
-    _Base_bitset<_Nw>::
-    _M_do_find_first(size_t __not_found) const noexcept
-    {
-      for (size_t __i = 0; __i < _Nw; __i++)
- {
-   _WordT __thisword = _M_w[__i];
-   if (__thisword != static_cast<_WordT>(0))
-     return (__i * (8 * 8)
-      + __builtin_ctzl(__thisword));
- }
-
-      return __not_found;
-    }
-
-  template<size_t _Nw>
-    size_t
-    _Base_bitset<_Nw>::
-    _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
-    {
-
-      ++__prev;
-
-
-      if (__prev >= _Nw * (8 * 8))
- return __not_found;
-
-
-      size_t __i = _S_whichword(__prev);
-      _WordT __thisword = _M_w[__i];
-
-
-      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
-
-      if (__thisword != static_cast<_WordT>(0))
- return (__i * (8 * 8)
-  + __builtin_ctzl(__thisword));
-
-
-      __i++;
-      for (; __i < _Nw; __i++)
- {
-   __thisword = _M_w[__i];
-   if (__thisword != static_cast<_WordT>(0))
-     return (__i * (8 * 8)
-      + __builtin_ctzl(__thisword));
- }
-
-      return __not_found;
-    }
-
-
-
-
-
-
-  template<>
-    struct _Base_bitset<1>
-    {
-      typedef unsigned long _WordT;
-      _WordT _M_w;
-
-      constexpr _Base_bitset() noexcept
-      : _M_w(0)
-      { }
-
-
-      constexpr _Base_bitset(unsigned long long __val) noexcept
-
-
-
-      : _M_w(__val)
-      { }
-
-      static constexpr size_t
-      _S_whichword(size_t __pos) noexcept
-      { return __pos / (8 * 8); }
-
-      static constexpr size_t
-      _S_whichbyte(size_t __pos) noexcept
-      { return (__pos % (8 * 8)) / 8; }
-
-      static constexpr size_t
-      _S_whichbit(size_t __pos) noexcept
-      { return __pos % (8 * 8); }
-
-      static constexpr _WordT
-      _S_maskbit(size_t __pos) noexcept
-      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
-
-      _WordT&
-      _M_getword(size_t) noexcept
-      { return _M_w; }
-
-      constexpr _WordT
-      _M_getword(size_t) const noexcept
-      { return _M_w; }
-
-
-      const _WordT*
-      _M_getdata() const noexcept
-      { return &_M_w; }
-
-
-      _WordT&
-      _M_hiword() noexcept
-      { return _M_w; }
-
-      constexpr _WordT
-      _M_hiword() const noexcept
-      { return _M_w; }
-
-      void
-      _M_do_and(const _Base_bitset<1>& __x) noexcept
-      { _M_w &= __x._M_w; }
-
-      void
-      _M_do_or(const _Base_bitset<1>& __x) noexcept
-      { _M_w |= __x._M_w; }
-
-      void
-      _M_do_xor(const _Base_bitset<1>& __x) noexcept
-      { _M_w ^= __x._M_w; }
-
-      void
-      _M_do_left_shift(size_t __shift) noexcept
-      { _M_w <<= __shift; }
-
-      void
-      _M_do_right_shift(size_t __shift) noexcept
-      { _M_w >>= __shift; }
-
-      void
-      _M_do_flip() noexcept
-      { _M_w = ~_M_w; }
-
-      void
-      _M_do_set() noexcept
-      { _M_w = ~static_cast<_WordT>(0); }
-
-      void
-      _M_do_reset() noexcept
-      { _M_w = 0; }
-
-      bool
-      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
-      { return _M_w == __x._M_w; }
-
-      template<size_t _Nb>
-        bool
-        _M_are_all() const noexcept
-        { return _M_w == (~static_cast<_WordT>(0)
-     >> ((8 * 8) - _Nb)); }
-
-      bool
-      _M_is_any() const noexcept
-      { return _M_w != 0; }
-
-      size_t
-      _M_do_count() const noexcept
-      { return __builtin_popcountl(_M_w); }
-
-      unsigned long
-      _M_do_to_ulong() const noexcept
-      { return _M_w; }
-
-
-      unsigned long long
-      _M_do_to_ullong() const noexcept
-      { return _M_w; }
-
-
-      size_t
-      _M_do_find_first(size_t __not_found) const noexcept
-      {
-        if (_M_w != 0)
-          return __builtin_ctzl(_M_w);
-        else
-          return __not_found;
-      }
-
-
-      size_t
-      _M_do_find_next(size_t __prev, size_t __not_found) const
- noexcept
-      {
- ++__prev;
- if (__prev >= ((size_t) (8 * 8)))
-   return __not_found;
-
- _WordT __x = _M_w >> __prev;
- if (__x != 0)
-   return __builtin_ctzl(__x) + __prev;
- else
-   return __not_found;
-      }
-    };
-
-
-
-
-
-
-  template<>
-    struct _Base_bitset<0>
-    {
-      typedef unsigned long _WordT;
-
-      constexpr _Base_bitset() noexcept
-      { }
-
-
-      constexpr _Base_bitset(unsigned long long) noexcept
-
-
-
-      { }
-
-      static constexpr size_t
-      _S_whichword(size_t __pos) noexcept
-      { return __pos / (8 * 8); }
-
-      static constexpr size_t
-      _S_whichbyte(size_t __pos) noexcept
-      { return (__pos % (8 * 8)) / 8; }
-
-      static constexpr size_t
-      _S_whichbit(size_t __pos) noexcept
-      { return __pos % (8 * 8); }
-
-      static constexpr _WordT
-      _S_maskbit(size_t __pos) noexcept
-      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
-# 556 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      _WordT&
-      _M_getword(size_t) noexcept
-      {
- __throw_out_of_range(("_Base_bitset::_M_getword"));
- return *new _WordT;
-      }
-
-      constexpr _WordT
-      _M_getword(size_t __pos) const noexcept
-      { return 0; }
-
-      constexpr _WordT
-      _M_hiword() const noexcept
-      { return 0; }
-
-      void
-      _M_do_and(const _Base_bitset<0>&) noexcept
-      { }
-
-      void
-      _M_do_or(const _Base_bitset<0>&) noexcept
-      { }
-
-      void
-      _M_do_xor(const _Base_bitset<0>&) noexcept
-      { }
-
-      void
-      _M_do_left_shift(size_t) noexcept
-      { }
-
-      void
-      _M_do_right_shift(size_t) noexcept
-      { }
-
-      void
-      _M_do_flip() noexcept
-      { }
-
-      void
-      _M_do_set() noexcept
-      { }
-
-      void
-      _M_do_reset() noexcept
-      { }
-
-
-
-
-      bool
-      _M_is_equal(const _Base_bitset<0>&) const noexcept
-      { return true; }
-
-      template<size_t _Nb>
-        bool
-        _M_are_all() const noexcept
-        { return true; }
-
-      bool
-      _M_is_any() const noexcept
-      { return false; }
-
-      size_t
-      _M_do_count() const noexcept
-      { return 0; }
-
-      unsigned long
-      _M_do_to_ulong() const noexcept
-      { return 0; }
-
-
-      unsigned long long
-      _M_do_to_ullong() const noexcept
-      { return 0; }
-
-
-
-
-      size_t
-      _M_do_find_first(size_t) const noexcept
-      { return 0; }
-
-      size_t
-      _M_do_find_next(size_t, size_t) const noexcept
-      { return 0; }
-    };
-
-
-
-  template<size_t _Extrabits>
-    struct _Sanitize
-    {
-      typedef unsigned long _WordT;
-
-      static void
-      _S_do_sanitize(_WordT& __val) noexcept
-      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
-    };
-
-  template<>
-    struct _Sanitize<0>
-    {
-      typedef unsigned long _WordT;
-
-      static void
-      _S_do_sanitize(_WordT) noexcept { }
-    };
-
-
-  template<size_t _Nb, bool = (_Nb < (8 * 8))>
-    struct _Sanitize_val
-    {
-      static constexpr unsigned long long
-      _S_do_sanitize_val(unsigned long long __val)
-      { return __val; }
-    };
-
-  template<size_t _Nb>
-    struct _Sanitize_val<_Nb, true>
-    {
-      static constexpr unsigned long long
-      _S_do_sanitize_val(unsigned long long __val)
-      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
-    };
-# 746 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-  template<size_t _Nb>
-    class bitset
-    : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
-    {
-    private:
-      typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
-      typedef unsigned long _WordT;
-
-      template<class _CharT, class _Traits, class _Alloc>
-      void
-      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
-    size_t __position) const
-      {
- if (__position > __s.size())
-   __throw_out_of_range_fmt(("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)"),
-
-
-       __position, __s.size());
-      }
-
-      void _M_check(size_t __position, const char *__s) const
-      {
- if (__position >= _Nb)
-   __throw_out_of_range_fmt(("%s: __position (which is %zu) " ">= _Nb (which is %zu)"),
-
-       __s, __position, _Nb);
-      }
-
-      void
-      _M_do_sanitize() noexcept
-      {
- typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
- __sanitize_type::_S_do_sanitize(this->_M_hiword());
-      }
-
-
-      template<typename> friend struct hash;
-
-
-    public:
-# 798 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      class reference
-      {
- friend class bitset;
-
- _WordT* _M_wp;
- size_t _M_bpos;
-
-
- reference();
-
-      public:
- reference(bitset& __b, size_t __pos) noexcept
- {
-   _M_wp = &__b._M_getword(__pos);
-   _M_bpos = _Base::_S_whichbit(__pos);
- }
-
- ~reference() noexcept
- { }
-
-
- reference&
- operator=(bool __x) noexcept
- {
-   if (__x)
-     *_M_wp |= _Base::_S_maskbit(_M_bpos);
-   else
-     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
-   return *this;
- }
-
-
- reference&
- operator=(const reference& __j) noexcept
- {
-   if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
-     *_M_wp |= _Base::_S_maskbit(_M_bpos);
-   else
-     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
-   return *this;
- }
-
-
- bool
- operator~() const noexcept
- { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
-
-
- operator bool() const noexcept
- { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
-
-
- reference&
- flip() noexcept
- {
-   *_M_wp ^= _Base::_S_maskbit(_M_bpos);
-   return *this;
- }
-      };
-      friend class reference;
-
-
-
-      constexpr bitset() noexcept
-      { }
-
-
-
-      constexpr bitset(unsigned long long __val) noexcept
-      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
-# 883 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      template<class _CharT, class _Traits, class _Alloc>
- explicit
- bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
-        size_t __position = 0)
- : _Base()
- {
-   _M_check_initial_position(__s, __position);
-   _M_copy_from_string(__s, __position,
-         std::basic_string<_CharT, _Traits, _Alloc>::npos,
-         _CharT('0'), _CharT('1'));
- }
-# 905 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      template<class _CharT, class _Traits, class _Alloc>
- bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
-        size_t __position, size_t __n)
- : _Base()
- {
-   _M_check_initial_position(__s, __position);
-   _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
- }
-
-
-
-      template<class _CharT, class _Traits, class _Alloc>
- bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
-        size_t __position, size_t __n,
-        _CharT __zero, _CharT __one = _CharT('1'))
- : _Base()
- {
-   _M_check_initial_position(__s, __position);
-   _M_copy_from_string(__s, __position, __n, __zero, __one);
- }
-# 936 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      template<typename _CharT>
-        explicit
-        bitset(const _CharT* __str,
-        typename std::basic_string<_CharT>::size_type __n
-        = std::basic_string<_CharT>::npos,
-        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
-        : _Base()
-        {
-   if (!__str)
-     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));
-
-   if (__n == std::basic_string<_CharT>::npos)
-     __n = std::char_traits<_CharT>::length(__str);
-   _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
-            __n, __zero,
-            __one);
- }
-# 963 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      bitset<_Nb>&
-      operator&=(const bitset<_Nb>& __rhs) noexcept
-      {
- this->_M_do_and(__rhs);
- return *this;
-      }
-
-      bitset<_Nb>&
-      operator|=(const bitset<_Nb>& __rhs) noexcept
-      {
- this->_M_do_or(__rhs);
- return *this;
-      }
-
-      bitset<_Nb>&
-      operator^=(const bitset<_Nb>& __rhs) noexcept
-      {
- this->_M_do_xor(__rhs);
- return *this;
-      }
-# 992 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      bitset<_Nb>&
-      operator<<=(size_t __position) noexcept
-      {
- if (__builtin_expect(__position < _Nb, 1))
-   {
-     this->_M_do_left_shift(__position);
-     this->_M_do_sanitize();
-   }
- else
-   this->_M_do_reset();
- return *this;
-      }
-
-      bitset<_Nb>&
-      operator>>=(size_t __position) noexcept
-      {
- if (__builtin_expect(__position < _Nb, 1))
-   {
-     this->_M_do_right_shift(__position);
-     this->_M_do_sanitize();
-   }
- else
-   this->_M_do_reset();
- return *this;
-      }
-# 1025 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      bitset<_Nb>&
-      _Unchecked_set(size_t __pos) noexcept
-      {
- this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
- return *this;
-      }
-
-      bitset<_Nb>&
-      _Unchecked_set(size_t __pos, int __val) noexcept
-      {
- if (__val)
-   this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
- else
-   this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
- return *this;
-      }
-
-      bitset<_Nb>&
-      _Unchecked_reset(size_t __pos) noexcept
-      {
- this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
- return *this;
-      }
-
-      bitset<_Nb>&
-      _Unchecked_flip(size_t __pos) noexcept
-      {
- this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
- return *this;
-      }
-
-      constexpr bool
-      _Unchecked_test(size_t __pos) const noexcept
-      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
-  != static_cast<_WordT>(0)); }
-
-
-
-
-
-
-      bitset<_Nb>&
-      set() noexcept
-      {
- this->_M_do_set();
- this->_M_do_sanitize();
- return *this;
-      }
-
-
-
-
-
-
-
-      bitset<_Nb>&
-      set(size_t __position, bool __val = true)
-      {
- this->_M_check(__position, ("bitset::set"));
- return _Unchecked_set(__position, __val);
-      }
-
-
-
-
-      bitset<_Nb>&
-      reset() noexcept
-      {
- this->_M_do_reset();
- return *this;
-      }
-# 1104 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      bitset<_Nb>&
-      reset(size_t __position)
-      {
- this->_M_check(__position, ("bitset::reset"));
- return _Unchecked_reset(__position);
-      }
-
-
-
-
-      bitset<_Nb>&
-      flip() noexcept
-      {
- this->_M_do_flip();
- this->_M_do_sanitize();
- return *this;
-      }
-
-
-
-
-
-
-      bitset<_Nb>&
-      flip(size_t __position)
-      {
- this->_M_check(__position, ("bitset::flip"));
- return _Unchecked_flip(__position);
-      }
-
-
-      bitset<_Nb>
-      operator~() const noexcept
-      { return bitset<_Nb>(*this).flip(); }
-# 1154 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      reference
-      operator[](size_t __position)
-      { return reference(*this, __position); }
-
-      constexpr bool
-      operator[](size_t __position) const
-      { return _Unchecked_test(__position); }
-# 1169 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      unsigned long
-      to_ulong() const
-      { return this->_M_do_to_ulong(); }
-
-
-      unsigned long long
-      to_ullong() const
-      { return this->_M_do_to_ullong(); }
-# 1187 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      template<class _CharT, class _Traits, class _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string() const
- {
-   std::basic_string<_CharT, _Traits, _Alloc> __result;
-   _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
-   return __result;
- }
-
-
-
-      template<class _CharT, class _Traits, class _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
-   std::basic_string<_CharT, _Traits, _Alloc> __result;
-   _M_copy_to_string(__result, __zero, __one);
-   return __result;
- }
-
-
-
-      template<class _CharT, class _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string() const
- { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
-
-
-
-      template<class _CharT, class _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- { return to_string<_CharT, _Traits,
-                    std::allocator<_CharT> >(__zero, __one); }
-
-      template<class _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
-                   std::allocator<_CharT> >
- to_string() const
- {
-   return to_string<_CharT, std::char_traits<_CharT>,
-                    std::allocator<_CharT> >();
- }
-
-      template<class _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
-                   std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
-   return to_string<_CharT, std::char_traits<_CharT>,
-                    std::allocator<_CharT> >(__zero, __one);
- }
-
-      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
-      to_string() const
-      {
- return to_string<char, std::char_traits<char>,
-                  std::allocator<char> >();
-      }
-
-      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
-      to_string(char __zero, char __one = '1') const
-      {
- return to_string<char, std::char_traits<char>,
-                  std::allocator<char> >(__zero, __one);
-      }
-
-
-      template<class _CharT, class _Traits>
-        void
-        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
-    _CharT, _CharT);
-
-      template<class _CharT, class _Traits, class _Alloc>
- void
- _M_copy_from_string(const std::basic_string<_CharT,
-       _Traits, _Alloc>& __s, size_t __pos, size_t __n,
-       _CharT __zero, _CharT __one)
- { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
-         __zero, __one); }
-
-      template<class _CharT, class _Traits, class _Alloc>
- void
-        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
-     _CharT, _CharT) const;
-
-
-      template<class _CharT, class _Traits, class _Alloc>
- void
- _M_copy_from_string(const std::basic_string<_CharT,
-       _Traits, _Alloc>& __s, size_t __pos, size_t __n)
- { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
-
-      template<class _CharT, class _Traits, class _Alloc>
- void
-        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
- { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
-
-
-      size_t
-      count() const noexcept
-      { return this->_M_do_count(); }
-
-
-      constexpr size_t
-      size() const noexcept
-      { return _Nb; }
-
-
-
-      bool
-      operator==(const bitset<_Nb>& __rhs) const noexcept
-      { return this->_M_is_equal(__rhs); }
-
-      bool
-      operator!=(const bitset<_Nb>& __rhs) const noexcept
-      { return !this->_M_is_equal(__rhs); }
-# 1312 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      bool
-      test(size_t __position) const
-      {
- this->_M_check(__position, ("bitset::test"));
- return _Unchecked_test(__position);
-      }
-
-
-
-
-
-
-
-      bool
-      all() const noexcept
-      { return this->template _M_are_all<_Nb>(); }
-
-
-
-
-
-      bool
-      any() const noexcept
-      { return this->_M_is_any(); }
-
-
-
-
-
-      bool
-      none() const noexcept
-      { return !this->_M_is_any(); }
-
-
-
-      bitset<_Nb>
-      operator<<(size_t __position) const noexcept
-      { return bitset<_Nb>(*this) <<= __position; }
-
-      bitset<_Nb>
-      operator>>(size_t __position) const noexcept
-      { return bitset<_Nb>(*this) >>= __position; }
-# 1362 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      size_t
-      _Find_first() const noexcept
-      { return this->_M_do_find_first(_Nb); }
-# 1373 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-      size_t
-      _Find_next(size_t __prev) const noexcept
-      { return this->_M_do_find_next(__prev, _Nb); }
-    };
-
-
-  template<size_t _Nb>
-    template<class _CharT, class _Traits>
-      void
-      bitset<_Nb>::
-      _M_copy_from_ptr(const _CharT* __s, size_t __len,
-         size_t __pos, size_t __n, _CharT __zero, _CharT __one)
-      {
- reset();
- const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
- for (size_t __i = __nbits; __i > 0; --__i)
-   {
-     const _CharT __c = __s[__pos + __nbits - __i];
-     if (_Traits::eq(__c, __zero))
-       ;
-     else if (_Traits::eq(__c, __one))
-       _Unchecked_set(__i - 1);
-     else
-       __throw_invalid_argument(("bitset::_M_copy_from_ptr"));
-   }
-      }
-
-  template<size_t _Nb>
-    template<class _CharT, class _Traits, class _Alloc>
-      void
-      bitset<_Nb>::
-      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
-   _CharT __zero, _CharT __one) const
-      {
- __s.assign(_Nb, __zero);
- for (size_t __i = _Nb; __i > 0; --__i)
-   if (_Unchecked_test(__i - 1))
-     _Traits::assign(__s[_Nb - __i], __one);
-      }
-# 1423 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-  template<size_t _Nb>
-    inline bitset<_Nb>
-    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
-    {
-      bitset<_Nb> __result(__x);
-      __result &= __y;
-      return __result;
-    }
-
-  template<size_t _Nb>
-    inline bitset<_Nb>
-    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
-    {
-      bitset<_Nb> __result(__x);
-      __result |= __y;
-      return __result;
-    }
-
-  template <size_t _Nb>
-    inline bitset<_Nb>
-    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
-    {
-      bitset<_Nb> __result(__x);
-      __result ^= __y;
-      return __result;
-    }
-# 1460 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-  template<class _CharT, class _Traits, size_t _Nb>
-    std::basic_istream<_CharT, _Traits>&
-    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
-    {
-      typedef typename _Traits::char_type char_type;
-      typedef std::basic_istream<_CharT, _Traits> __istream_type;
-      typedef typename __istream_type::ios_base __ios_base;
-
-      std::basic_string<_CharT, _Traits> __tmp;
-      __tmp.reserve(_Nb);
-
-
-
-      const char_type __zero = __is.widen('0');
-      const char_type __one = __is.widen('1');
-
-      typename __ios_base::iostate __state = __ios_base::goodbit;
-      typename __istream_type::sentry __sentry(__is);
-      if (__sentry)
- {
-   try
-     {
-       for (size_t __i = _Nb; __i > 0; --__i)
-  {
-    static typename _Traits::int_type __eof = _Traits::eof();
-
-    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
-    if (_Traits::eq_int_type(__c1, __eof))
-      {
-        __state |= __ios_base::eofbit;
-        break;
-      }
-    else
-      {
-        const char_type __c2 = _Traits::to_char_type(__c1);
-        if (_Traits::eq(__c2, __zero))
-   __tmp.push_back(__zero);
-        else if (_Traits::eq(__c2, __one))
-   __tmp.push_back(__one);
-        else if (_Traits::
-          eq_int_type(__is.rdbuf()->sputbackc(__c2),
-        __eof))
-   {
-     __state |= __ios_base::failbit;
-     break;
-   }
-      }
-  }
-     }
-   catch(__cxxabiv1::__forced_unwind&)
-     {
-       __is._M_setstate(__ios_base::badbit);
-       throw;
-     }
-   catch(...)
-     { __is._M_setstate(__ios_base::badbit); }
- }
-
-      if (__tmp.empty() && _Nb)
- __state |= __ios_base::failbit;
-      else
- __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
-    __zero, __one);
-      if (__state)
- __is.setstate(__state);
-      return __is;
-    }
-
-  template <class _CharT, class _Traits, size_t _Nb>
-    std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
-        const bitset<_Nb>& __x)
-    {
-      std::basic_string<_CharT, _Traits> __tmp;
-
-
-
-      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
-      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
-      return __os << __tmp;
-    }
-
-
-
-}
-# 1554 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bitset" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template<size_t _Nb>
-    struct hash<std::bitset<_Nb>>
-    : public __hash_base<size_t, std::bitset<_Nb>>
-    {
-      size_t
-      operator()(const std::bitset<_Nb>& __b) const noexcept
-      {
- const size_t __clength = (_Nb + 8 - 1) / 8;
- return std::_Hash_impl::hash(__b._M_getdata(), __clength);
-      }
-    };
-
-  template<>
-    struct hash<std::bitset<0>>
-    : public __hash_base<size_t, std::bitset<0>>
-    {
-      size_t
-      operator()(const std::bitset<0>&) const noexcept
-      { return 0; }
-    };
-
-
-}
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h"
-class nsIDocument;
-struct nsIDocumentAtoms;
-
-namespace mozilla {
-namespace dom {
-
-struct ElementCreationOptionsAtoms;
-struct NativePropertyHooks;
-class ProtoAndIfaceCache;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class VisibilityState : uint8_t {
-  Hidden,
-  Visible,
-  Prerender,
-  EndGuard_
-};
-
-namespace VisibilityStateValues {
-extern const EnumEntry strings[4];
-}
-
-bool
-ToJSValue(JSContext* aCx, VisibilityState aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-enum class FlashClassification : uint8_t {
-  Unclassified,
-  Unknown,
-  Allowed,
-  Denied,
-  EndGuard_
-};
-
-namespace FlashClassificationValues {
-extern const EnumEntry strings[5];
-}
-
-bool
-ToJSValue(JSContext* aCx, FlashClassification aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-struct ElementCreationOptions : public DictionaryBase
-{
-                        Optional<nsString> mIs;
-                        Optional<nsString> mPseudo;
-
-  ElementCreationOptions();
-
-  explicit inline ElementCreationOptions(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline ElementCreationOptions(const ElementCreationOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  ElementCreationOptions&
-  operator=(const ElementCreationOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, ElementCreationOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastElementCreationOptions : public ElementCreationOptions
-{
-  inline FastElementCreationOptions()
-    : ElementCreationOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-class ElementCreationOptionsOrString
-{
-  friend class ElementCreationOptionsOrStringArgument;
-  enum Type
-  {
-    eUninitialized,
-    eElementCreationOptions,
-    eString
-  };
-
-  union Value
-  {
-    UnionMember<binding_detail::FastElementCreationOptions > mElementCreationOptions;
-    UnionMember<binding_detail::FakeString > mString;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-  ElementCreationOptionsOrString(const ElementCreationOptionsOrString&) = delete;
-  ElementCreationOptionsOrString& operator=(const ElementCreationOptionsOrString&) = delete;
-public:
-  explicit inline ElementCreationOptionsOrString()
-    : mType(eUninitialized)
-  {
-  }
-
-  inline ~ElementCreationOptionsOrString()
-  {
-    Uninit();
-  }
-
-  inline binding_detail::FastElementCreationOptions&
-  RawSetAsElementCreationOptions()
-  {
-    if (mType == eElementCreationOptions) {
-      return mValue.mElementCreationOptions.Value();
-    }
-    do { } while (0);
-    mType = eElementCreationOptions;
-    return mValue.mElementCreationOptions.SetValue();
-  }
-
-  inline binding_detail::FastElementCreationOptions&
-  SetAsElementCreationOptions()
-  {
-    if (mType == eElementCreationOptions) {
-      return mValue.mElementCreationOptions.Value();
-    }
-    Uninit();
-    mType = eElementCreationOptions;
-    return mValue.mElementCreationOptions.SetValue();
-  }
-
-  inline bool
-  IsElementCreationOptions() const
-  {
-    return mType == eElementCreationOptions;
-  }
-
-  inline binding_detail::FastElementCreationOptions&
-  GetAsElementCreationOptions()
-  {
-    do { } while (0);
-    return mValue.mElementCreationOptions.Value();
-  }
-
-  inline const ElementCreationOptions&
-  GetAsElementCreationOptions() const
-  {
-    do { } while (0);
-    return mValue.mElementCreationOptions.Value();
-  }
-
-  inline binding_detail::FakeString&
-  RawSetAsString()
-  {
-    if (mType == eString) {
-      return mValue.mString.Value();
-    }
-    do { } while (0);
-    mType = eString;
-    return mValue.mString.SetValue();
-  }
-
-  inline binding_detail::FakeString&
-  SetAsString()
-  {
-    if (mType == eString) {
-      return mValue.mString.Value();
-    }
-    Uninit();
-    mType = eString;
-    return mValue.mString.SetValue();
-  }
-
-  inline bool
-  IsString() const
-  {
-    return mType == eString;
-  }
-
-  inline binding_detail::FakeString&
-  GetAsString()
-  {
-    do { } while (0);
-    return mValue.mString.Value();
-  }
-
-  inline const nsAString&
-  GetAsString() const
-  {
-    do { } while (0);
-    return mValue.mString.Value();
-  }
-
-  inline void
-  Uninit()
-  {
-    switch (mType) {
-      case eUninitialized: {
-        break;
-      }
-      case eElementCreationOptions: {
-        DestroyElementCreationOptions();
-        break;
-      }
-      case eString: {
-        DestroyString();
-        break;
-      }
-    }
-  }
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-private:
-  inline void
-  DestroyElementCreationOptions()
-  {
-    do { } while (0);
-    mValue.mElementCreationOptions.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyString()
-  {
-    do { } while (0);
-    mValue.mString.Destroy();
-    mType = eUninitialized;
-  }
-};
-
-
-class OwningElementCreationOptionsOrString : public AllOwningUnionBase
-{
-  friend void ImplCycleCollectionUnlink(OwningElementCreationOptionsOrString& aUnion);
-  enum Type
-  {
-    eUninitialized,
-    eElementCreationOptions,
-    eString
-  };
-
-  union Value
-  {
-    UnionMember<ElementCreationOptions > mElementCreationOptions;
-    UnionMember<nsString > mString;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-public:
-  explicit inline OwningElementCreationOptionsOrString()
-    : mType(eUninitialized)
-  {
-  }
-
-  explicit inline OwningElementCreationOptionsOrString(const OwningElementCreationOptionsOrString& aOther)
-    : mType(eUninitialized)
-  {
-    *this = aOther;
-  }
-
-  inline ~OwningElementCreationOptionsOrString()
-  {
-    Uninit();
-  }
-
-  ElementCreationOptions&
-  RawSetAsElementCreationOptions();
-
-  ElementCreationOptions&
-  SetAsElementCreationOptions();
-
-  bool
-  TrySetToElementCreationOptions(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsElementCreationOptions() const
-  {
-    return mType == eElementCreationOptions;
-  }
-
-  inline ElementCreationOptions&
-  GetAsElementCreationOptions()
-  {
-    do { } while (0);
-    return mValue.mElementCreationOptions.Value();
-  }
-
-  inline ElementCreationOptions const &
-  GetAsElementCreationOptions() const
-  {
-    do { } while (0);
-    return mValue.mElementCreationOptions.Value();
-  }
-
-  nsString&
-  RawSetAsString();
-
-  nsString&
-  SetAsString();
-
-  bool
-  TrySetToString(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline void
-  SetStringData(const nsString::char_type* aData, nsString::size_type aLength)
-  {
-    RawSetAsString().Assign(aData, aLength);
-  }
-
-  inline bool
-  IsString() const
-  {
-    return mType == eString;
-  }
-
-  inline nsString&
-  GetAsString()
-  {
-    do { } while (0);
-    return mValue.mString.Value();
-  }
-
-  inline nsString const &
-  GetAsString() const
-  {
-    do { } while (0);
-    return mValue.mString.Value();
-  }
-
-  void
-  Uninit();
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceUnion(JSTracer* trc);
-
-  OwningElementCreationOptionsOrString&
-  operator=(const OwningElementCreationOptionsOrString& aOther);
-
-private:
-  void
-  DestroyElementCreationOptions();
-
-  void
-  DestroyString();
-};
-
-
-namespace DocumentBinding {
-
-  typedef nsIDocument NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, nsIDocument* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 419 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DocumentBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JSObject*
-  GetProtoObject(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
-
-
-
-
-
-
-
-
-class gfxUserFontSet;
-class imgIRequest;
-class nsAString;
-class nsBindingManager;
-class nsIDocShell;
-class nsDocShell;
-class nsDOMNavigationTiming;
-class nsFrameLoader;
-class nsHTMLCSSStyleSheet;
-class nsHTMLDocument;
-class nsHTMLStyleSheet;
-class nsIAtom;
-class nsIBFCacheEntry;
-class nsIChannel;
-class nsIContent;
-class nsIContentSink;
-class nsIDocShell;
-class nsIDocShellTreeItem;
-class nsIDocumentEncoder;
-class nsIDocumentObserver;
-class nsIDOMDocument;
-class nsIDOMDocumentType;
-class nsIDOMElement;
-class nsIDOMNodeFilter;
-class nsIDOMNodeList;
-class nsIHTMLCollection;
-class nsILayoutHistoryState;
-class nsILoadContext;
-class nsIObjectLoadingContent;
-class nsIObserver;
-class nsIPresShell;
-class nsIPrincipal;
-class nsIRequest;
-class nsIRunnable;
-class nsIStreamListener;
-class nsIStructuredCloneContainer;
-class nsIURI;
-class nsIVariant;
-class nsViewManager;
-class nsPresContext;
-class nsRange;
-class nsScriptLoader;
-class nsSMILAnimationController;
-class nsSVGElement;
-class nsTextNode;
-class nsWindowSizes;
-class nsDOMCaretPosition;
-class nsViewportInfo;
-class nsIGlobalObject;
-struct nsCSSSelectorList;
-
-namespace mozilla {
-class AbstractThread;
-class CSSStyleSheet;
-class ErrorResult;
-class EventStates;
-class PendingAnimationTracker;
-class StyleSetHandle;
-template<typename> class OwningNonNull;
-
-namespace css {
-class Loader;
-class ImageLoader;
-class Rule;
-}
-
-namespace dom {
-class Animation;
-class AnonymousContent;
-class Attr;
-class BoxObject;
-class CDATASection;
-class Comment;
-struct CustomElementDefinition;
-class DocGroup;
-class DocumentFragment;
-class DocumentTimeline;
-class DocumentType;
-class DOMImplementation;
-class DOMIntersectionObserver;
-class DOMStringList;
-class Element;
-struct ElementCreationOptions;
-struct ElementRegistrationOptions;
-class Event;
-class EventTarget;
-class FontFaceSet;
-class FrameRequestCallback;
-struct FullscreenRequest;
-class ImageTracker;
-class ImportManager;
-class HTMLBodyElement;
-struct LifecycleCallbackArgs;
-class Link;
-class Location;
-class MediaQueryList;
-class GlobalObject;
-class NodeFilter;
-class NodeIterator;
-enum class OrientationType : uint8_t;
-class ProcessingInstruction;
-class Promise;
-class StyleSheetList;
-class SVGDocument;
-class SVGSVGElement;
-class Touch;
-class TouchList;
-class TreeWalker;
-class XPathEvaluator;
-class XPathExpression;
-class XPathNSResolver;
-class XPathResult;
-template<typename> class Sequence;
-
-template<typename, typename> class CallbackObjectHolder;
-typedef CallbackObjectHolder<NodeFilter, nsIDOMNodeFilter> NodeFilterHolder;
-
-enum class CallerType : uint32_t;
-
-}
-}
-
-
-
-
-
-
-enum DocumentFlavor {
-  DocumentFlavorLegacyGuess,
-  DocumentFlavorHTML,
-  DocumentFlavorSVG,
-  DocumentFlavorPlain,
-};
-
-
-enum class HSTSPrimingState {
-  eNO_HSTS_PRIMING = 0,
-  eHSTS_PRIMING_ALLOW = 1,
-  eHSTS_PRIMING_BLOCK = 2
-};
-# 203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-class nsContentList;
-
-
-
-
-
-class nsIDocument : public nsINode,
-                    public mozilla::dom::DispatcherTrait
-{
-  typedef mozilla::dom::GlobalObject GlobalObject;
-
-public:
-  typedef mozilla::net::ReferrerPolicy ReferrerPolicyEnum;
-  typedef mozilla::dom::Element Element;
-  typedef mozilla::dom::FullscreenRequest FullscreenRequest;
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  nsIDocument();
-
-
-
-
-  class PageUnloadingEventTimeStamp
-  {
-    nsCOMPtr<nsIDocument> mDocument;
-    bool mSet;
-
-  public:
-    explicit PageUnloadingEventTimeStamp(nsIDocument* aDocument)
-      : mDocument(aDocument)
-      , mSet(false)
-    {
-      do { } while (0);
-      if (mDocument->mPageUnloadingEventTimeStamp.IsNull()) {
-        mDocument->SetPageUnloadingEventTimeStamp();
-        mSet = true;
-      }
-    }
-
-    ~PageUnloadingEventTimeStamp()
-    {
-      if (mSet) {
-        mDocument->CleanUnloadEventsTimeStamp();
-      }
-    }
-  };
-# 285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual nsresult StartDocumentLoad(const char* aCommand,
-                                     nsIChannel* aChannel,
-                                     nsILoadGroup* aLoadGroup,
-                                     nsISupports* aContainer,
-                                     nsIStreamListener **aDocListener,
-                                     bool aReset,
-                                     nsIContentSink* aSink = nullptr) = 0;
-  virtual void StopDocumentLoad() = 0;
-
-  virtual void SetSuppressParserErrorElement(bool aSuppress) {}
-  virtual bool SuppressParserErrorElement() { return false; }
-
-  virtual void SetSuppressParserErrorConsoleMessages(bool aSuppress) {}
-  virtual bool SuppressParserErrorConsoleMessages() { return false; }
-
-
-
-
-
-
-
-  virtual void NotifyPossibleTitleChange(bool aBoundTitleElement) = 0;
-# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsIURI* GetDocumentURI() const
-  {
-    return mDocumentURI;
-  }
-# 334 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsIURI* GetOriginalURI() const
-  {
-    return mOriginalURI;
-  }
-
-
-
-
-
-  virtual void SetDocumentURI(nsIURI* aURI) = 0;
-
-
-
-
-
-  virtual void SetChromeXHRDocURI(nsIURI* aURI) = 0;
-
-
-
-
-
-  virtual void SetChromeXHRDocBaseURI(nsIURI* aURI) = 0;
-
-
-
-
-  virtual void ApplySettingsFromCSP(bool aSpeculative) = 0;
-
-  virtual already_AddRefed<nsIParser> CreatorParserOrNull() = 0;
-
-
-
-
-
-  ReferrerPolicyEnum GetReferrerPolicy() const
-  {
-    return mReferrerPolicy;
-  }
-
-
-
-
-  uint32_t ReferrerPolicy() const
-  {
-    return GetReferrerPolicy();
-  }
-
-
-
-
-
-
-  bool GetBlockAllMixedContent(bool aPreload) const
-  {
-    if (aPreload) {
-      return mBlockAllMixedContentPreloads;
-    }
-    return mBlockAllMixedContent;
-  }
-# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  bool GetUpgradeInsecureRequests(bool aPreload) const
-  {
-    if (aPreload) {
-      return mUpgradeInsecurePreloads;
-    }
-    return mUpgradeInsecureRequests;
-  }
-
-  void SetReferrer(const nsACString& aReferrer) {
-    mReferrer = aReferrer;
-  }
-
-
-
-
-
-  HSTSPrimingState GetHSTSPrimingStateForLocation(nsIURI* aContentLocation) const
-  {
-    HSTSPrimingState state;
-    if (mHSTSPrimingURIList.Get(aContentLocation, &state)) {
-      return state;
-    }
-    return HSTSPrimingState::eNO_HSTS_PRIMING;
-  }
-
-
-
-
-
-
-  void AddHSTSPrimingLocation(nsIURI* aContentLocation, HSTSPrimingState aState)
-  {
-    mHSTSPrimingURIList.Put(aContentLocation, aState);
-  }
-
-  void ClearHSTSPrimingLocation(nsIURI* aContentLocation)
-  {
-    mHSTSPrimingURIList.Remove(aContentLocation);
-  }
-
-
-
-
-  virtual void SetPrincipal(nsIPrincipal *aPrincipal) = 0;
-
-
-
-
-  already_AddRefed<nsILoadGroup> GetDocumentLoadGroup() const
-  {
-    nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
-    return group.forget();
-  }
-
-
-
-
-
-
-
-  nsIURI* GetFallbackBaseURI() const
-  {
-    if (mIsSrcdocDocument && mParentDocument) {
-      return mParentDocument->GetDocBaseURI();
-    }
-    return mDocumentURI;
-  }
-# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsIURI* GetDocBaseURI() const
-  {
-    if (mDocumentBaseURI) {
-      return mDocumentBaseURI;
-    }
-    return GetFallbackBaseURI();
-  }
-  virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
-
-  virtual void SetBaseURI(nsIURI* aURI) = 0;
-
-
-
-
-  virtual void GetBaseTarget(nsAString &aBaseTarget) = 0;
-  void SetBaseTarget(const nsString& aBaseTarget) {
-    mBaseTarget = aBaseTarget;
-  }
-
-
-
-
-  const nsCString& GetDocumentCharacterSet() const
-  {
-    return mCharacterSet;
-  }
-
-
-
-
-
-  virtual void SetDocumentCharacterSet(const nsACString& aCharSetID) = 0;
-
-  int32_t GetDocumentCharacterSetSource() const
-  {
-    return mCharacterSetSource;
-  }
-
-
-
-  void SetDocumentCharacterSetSource(int32_t aCharsetSource)
-  {
-    mCharacterSetSource = aCharsetSource;
-  }
-
-
-
-
-  virtual nsresult AddCharSetObserver(nsIObserver* aObserver) = 0;
-
-
-
-
-  virtual void RemoveCharSetObserver(nsIObserver* aObserver) = 0;
-# 539 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  typedef bool (* IDTargetObserver)(Element* aOldElement,
-                                      Element* aNewelement, void* aData);
-# 553 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual Element* AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
-                                       void* aData, bool aForImage) = 0;
-
-
-
-
-  virtual void RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
-                                      void* aData, bool aForImage) = 0;
-
-
-
-
-
-
-  virtual nsresult GetContentType(nsAString& aContentType) = 0;
-
-
-
-
-  virtual void SetContentType(const nsAString& aContentType) = 0;
-
-
-
-
-  void GetContentLanguage(nsAString& aContentLanguage) const
-  {
-    CopyASCIItoUTF16(mContentLanguage, aContentLanguage);
-  }
-# 589 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  bool GetBidiEnabled() const
-  {
-    return mBidiEnabled;
-  }
-
-
-
-
-
-
-
-  void SetBidiEnabled()
-  {
-    mBidiEnabled = true;
-  }
-
-
-
-
-  bool GetMathMLEnabled() const
-  {
-    return mMathMLEnabled;
-  }
-
-  void SetMathMLEnabled()
-  {
-    mMathMLEnabled = true;
-  }
-
-
-
-
-  bool IsInitialDocument() const
-  {
-    return mIsInitialDocumentInWindow;
-  }
-
-
-
-
-
-  void SetIsInitialDocument(bool aIsInitialDocument)
-  {
-    mIsInitialDocumentInWindow = aIsInitialDocument;
-  }
-
-
-
-
-
-
-  void IgnoreDocGroupMismatches()
-  {
-    mIgnoreDocGroupMismatches = true;
-  }
-
-
-
-
-
-  uint32_t GetBidiOptions() const
-  {
-    return mBidiOptions;
-  }
-
-
-
-
-
-
-
-  void SetBidiOptions(uint32_t aBidiOptions)
-  {
-    mBidiOptions = aBidiOptions;
-  }
-
-
-
-
-  bool GetHasMixedActiveContentLoaded()
-  {
-    return mHasMixedActiveContentLoaded;
-  }
-
-
-
-
-  void SetHasMixedActiveContentLoaded(bool aHasMixedActiveContentLoaded)
-  {
-    mHasMixedActiveContentLoaded = aHasMixedActiveContentLoaded;
-  }
-
-
-
-
-  bool GetHasMixedActiveContentBlocked()
-  {
-    return mHasMixedActiveContentBlocked;
-  }
-
-
-
-
-  void SetHasMixedActiveContentBlocked(bool aHasMixedActiveContentBlocked)
-  {
-    mHasMixedActiveContentBlocked = aHasMixedActiveContentBlocked;
-  }
-
-
-
-
-  bool GetHasMixedDisplayContentLoaded()
-  {
-    return mHasMixedDisplayContentLoaded;
-  }
-
-
-
-
-  void SetHasMixedDisplayContentLoaded(bool aHasMixedDisplayContentLoaded)
-  {
-    mHasMixedDisplayContentLoaded = aHasMixedDisplayContentLoaded;
-  }
-
-
-
-
-  bool GetHasMixedDisplayContentBlocked()
-  {
-    return mHasMixedDisplayContentBlocked;
-  }
-
-
-
-
-  void SetHasReferrerPolicyCSP(bool aHasReferrerPolicyCSP)
-  {
-    mHasReferrerPolicyCSP = aHasReferrerPolicyCSP;
-  }
-
-
-
-
-  void SetHasMixedDisplayContentBlocked(bool aHasMixedDisplayContentBlocked)
-  {
-    mHasMixedDisplayContentBlocked = aHasMixedDisplayContentBlocked;
-  }
-
-
-
-
-  void SetHasMixedContentObjectSubrequest(bool aHasMixedContentObjectSubrequest)
-  {
-    mHasMixedContentObjectSubrequest = aHasMixedContentObjectSubrequest;
-  }
-
-
-
-
-  void SetHasCSP(bool aHasCSP)
-  {
-    mHasCSP = aHasCSP;
-  }
-
-
-
-
-  void SetHasUnsafeInlineCSP(bool aHasUnsafeInlineCSP)
-  {
-    mHasUnsafeInlineCSP = aHasUnsafeInlineCSP;
-  }
-
-
-
-
-  void SetHasUnsafeEvalCSP(bool aHasUnsafeEvalCSP)
-  {
-    mHasUnsafeEvalCSP = aHasUnsafeEvalCSP;
-  }
-
-
-
-
-  bool GetHasTrackingContentBlocked()
-  {
-    return mHasTrackingContentBlocked;
-  }
-
-
-
-
-  void SetHasTrackingContentBlocked(bool aHasTrackingContentBlocked)
-  {
-    mHasTrackingContentBlocked = aHasTrackingContentBlocked;
-  }
-
-
-
-
-  bool GetHasTrackingContentLoaded()
-  {
-    return mHasTrackingContentLoaded;
-  }
-
-
-
-
-  void SetHasTrackingContentLoaded(bool aHasTrackingContentLoaded)
-  {
-    mHasTrackingContentLoaded = aHasTrackingContentLoaded;
-  }
-
-
-
-
-
-  uint32_t GetSandboxFlags() const
-  {
-    return mSandboxFlags;
-  }
-
-
-
-
-  void GetSandboxFlagsAsString(nsAString& aFlags);
-
-
-
-
-
-  void SetSandboxFlags(uint32_t sandboxFlags)
-  {
-    mSandboxFlags = sandboxFlags;
-  }
-
-
-
-
-
-  virtual void GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const = 0;
-  virtual void SetHeaderData(nsIAtom* aheaderField, const nsAString& aData) = 0;
-# 838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual already_AddRefed<nsIPresShell> CreateShell(
-      nsPresContext* aContext,
-      nsViewManager* aViewManager,
-      mozilla::StyleSetHandle aStyleSet) = 0;
-  virtual void DeleteShell() = 0;
-
-  nsIPresShell* GetShell() const
-  {
-    return GetBFCacheEntry() ? nullptr : mPresShell;
-  }
-
-
-
-  void DisallowBFCaching()
-  {
-    do { } while(0);
-    mBFCacheDisallowed = true;
-  }
-
-  bool IsBFCachingAllowed() const
-  {
-    return !mBFCacheDisallowed;
-  }
-
-  void SetBFCacheEntry(nsIBFCacheEntry* aEntry)
-  {
-    do { } while(0);
-
-
-    mBFCacheEntry = aEntry;
-  }
-
-  nsIBFCacheEntry* GetBFCacheEntry() const
-  {
-    return mBFCacheEntry;
-  }
-
-
-
-
-
-
-  nsIDocument *GetParentDocument() const
-  {
-    return mParentDocument;
-  }
-
-
-
-
-  void SetParentDocument(nsIDocument* aParent)
-  {
-    mParentDocument = aParent;
-    if (aParent) {
-      mIgnoreDocGroupMismatches = aParent->mIgnoreDocGroupMismatches;
-    }
-  }
-
-
-
-
-  virtual bool GetAllowPlugins () = 0;
-
-
-
-
-  virtual nsresult SetSubDocumentFor(Element* aContent,
-                                     nsIDocument* aSubDoc) = 0;
-
-
-
-
-  virtual nsIDocument *GetSubDocumentFor(nsIContent *aContent) const = 0;
-
-
-
-
-  virtual Element* FindContentForSubDocument(nsIDocument* aDocument) const = 0;
-
-
-
-
-  mozilla::dom::DocumentType* GetDoctype() const;
-
-
-
-
-  Element* GetRootElement() const;
-# 940 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual nsViewportInfo GetViewportInfo(const mozilla::ScreenIntSize& aDisplaySize) = 0;
-
-
-
-
-  virtual bool WillIgnoreCharsetOverride() {
-    return true;
-  }
-
-
-
-
-  bool IsSrcdocDocument() const {
-    return mIsSrcdocDocument;
-  }
-
-
-
-
-  void SetIsSrcdocDocument(bool aIsSrcdocDocument) {
-    mIsSrcdocDocument = aIsSrcdocDocument;
-  }
-
-
-
-
-
-
-  nsresult GetSrcdocData(nsAString& aSrcdocData);
-
-  bool DidDocumentOpen() {
-    return mDidDocumentOpen;
-  }
-
-  already_AddRefed<mozilla::dom::AnonymousContent>
-  InsertAnonymousContent(mozilla::dom::Element& aElement,
-                         mozilla::ErrorResult& aError);
-  void RemoveAnonymousContent(mozilla::dom::AnonymousContent& aContent,
-                              mozilla::ErrorResult& aError);
-
-
-
-
-
-
-  Element* GetAnonRootIfInAnonymousContentContainer(nsINode* aNode) const;
-  nsTArray<RefPtr<mozilla::dom::AnonymousContent>>& GetAnonymousContents() {
-    return mAnonymousContents;
-  }
-
-  static nsresult GenerateDocumentId(nsAString& aId);
-  nsresult GetOrCreateId(nsAString& aId);
-  void SetId(const nsAString& aId);
-
-  mozilla::TimeStamp GetPageUnloadingEventTimeStamp() const
-  {
-    if (!mParentDocument) {
-      return mPageUnloadingEventTimeStamp;
-    }
-
-    mozilla::TimeStamp parentTimeStamp(mParentDocument->GetPageUnloadingEventTimeStamp());
-    if (parentTimeStamp.IsNull()) {
-      return mPageUnloadingEventTimeStamp;
-    }
-
-    if (!mPageUnloadingEventTimeStamp ||
-        parentTimeStamp < mPageUnloadingEventTimeStamp) {
-      return parentTimeStamp;
-    }
-
-    return mPageUnloadingEventTimeStamp;
-  }
-
-  virtual void NotifyLayerManagerRecreated() = 0;
-# 1022 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void ScheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG) = 0;
-
-  virtual void UnscheduleSVGForPresAttrEvaluation(nsSVGElement* aSVG) = 0;
-
-
-  virtual void ResolveScheduledSVGPresAttrs() = 0;
-
-protected:
-  virtual Element *GetRootElementInternal() const = 0;
-
-  void SetPageUnloadingEventTimeStamp()
-  {
-    do { } while (0);
-    mPageUnloadingEventTimeStamp = mozilla::TimeStamp::NowLoRes();
-  }
-
-  void CleanUnloadEventsTimeStamp()
-  {
-    do { } while (0);
-    mPageUnloadingEventTimeStamp = mozilla::TimeStamp();
-  }
-
-private:
-  class SelectorCacheKey
-  {
-    public:
-      explicit SelectorCacheKey(const nsAString& aString) : mKey(aString)
-      {
-                                        ;
-      }
-
-      nsString mKey;
-      nsExpirationState mState;
-
-      nsExpirationState* GetExpirationState() { return &mState; }
-
-      ~SelectorCacheKey()
-      {
-                                        ;
-      }
-  };
-
-  class SelectorCacheKeyDeleter;
-
-public:
-  class SelectorCache final
-    : public nsExpirationTracker<SelectorCacheKey, 4>
-  {
-    public:
-      explicit SelectorCache(nsIEventTarget* aEventTarget);
-
-
-      void CacheList(const nsAString& aSelector, nsCSSSelectorList* aSelectorList);
-
-      virtual void NotifyExpired(SelectorCacheKey* aSelector) override;
-
-
-
-
-
-
-      bool GetList(const nsAString& aSelector, nsCSSSelectorList** aList)
-      {
-        return mTable.Get(aSelector, aList);
-      }
-
-      ~SelectorCache();
-
-    private:
-      nsClassHashtable<nsStringHashKey, nsCSSSelectorList> mTable;
-  };
-
-  SelectorCache& GetSelectorCache() {
-    if (!mSelectorCache) {
-      mSelectorCache =
-        new SelectorCache(EventTargetFor(mozilla::TaskCategory::Other));
-    }
-    return *mSelectorCache;
-  }
-
-
-  Element* GetHtmlElement() const;
-
-
-  Element* GetHtmlChildElement(nsIAtom* aTag);
-
-
-  mozilla::dom::HTMLBodyElement* GetBodyElement();
-
-
-  Element* GetHeadElement() {
-    return GetHtmlChildElement(nsGkAtoms::head);
-  }
-# 1141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet) = 0;
-
-
-
-
-
-
-
-  virtual int32_t GetNumberOfStyleSheets() const = 0;
-
-
-
-
-
-
-
-  virtual mozilla::StyleSheet* GetStyleSheetAt(int32_t aIndex) const = 0;
-# 1166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void InsertStyleSheetAt(mozilla::StyleSheet* aSheet,
-                                  int32_t aIndex) = 0;
-
-
-
-
-
-
-
-  virtual int32_t GetIndexOfStyleSheet(
-      const mozilla::StyleSheet* aSheet) const = 0;
-# 1186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void UpdateStyleSheets(
-      nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets,
-      nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets) = 0;
-
-
-
-
-  virtual void AddStyleSheet(mozilla::StyleSheet* aSheet) = 0;
-
-
-
-
-  virtual void RemoveStyleSheet(mozilla::StyleSheet* aSheet) = 0;
-
-
-
-
-
-  virtual void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet,
-                                            bool aApplicable) = 0;
-
-  enum additionalSheetType {
-    eAgentSheet,
-    eUserSheet,
-    eAuthorSheet,
-    AdditionalSheetTypeCount
-  };
-
-  virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType,
-                                            nsIURI* aSheetURI) = 0;
-  virtual nsresult AddAdditionalStyleSheet(additionalSheetType aType,
-                                           mozilla::StyleSheet* aSheet) = 0;
-  virtual void RemoveAdditionalStyleSheet(additionalSheetType aType,
-                                          nsIURI* sheetURI) = 0;
-  virtual mozilla::StyleSheet* GetFirstAdditionalAuthorSheet() = 0;
-# 1229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  template<typename T>
-  size_t FindDocStyleSheetInsertionPoint(const nsTArray<RefPtr<T>>& aDocSheets,
-                                         T* aSheet);
-
-
-
-
-  mozilla::css::Loader* CSSLoader() const {
-    return mCSSLoader;
-  }
-
-  mozilla::StyleBackendType GetStyleBackendType() const {
-    if (mStyleBackendType == mozilla::StyleBackendType::None) {
-      const_cast<nsIDocument*>(this)->UpdateStyleBackendType();
-    }
-    do { } while (0);
-    return mStyleBackendType;
-  }
-
-  void UpdateStyleBackendType();
-
-  bool IsStyledByServo() const {
-    return GetStyleBackendType() == mozilla::StyleBackendType::Servo;
-  }
-
-
-
-
-  mozilla::css::ImageLoader* StyleImageLoader() const {
-    return mStyleImageLoader;
-  }
-
-
-
-
-
-
-  virtual nsIChannel* GetChannel() const = 0;
-
-
-
-
-
-  nsHTMLStyleSheet* GetAttributeStyleSheet() const {
-    return mAttrStyleSheet;
-  }
-
-
-
-
-
-  nsHTMLCSSStyleSheet* GetInlineStyleSheet() const {
-    return mStyleAttrStyleSheet;
-  }
-
-  virtual void SetScriptGlobalObject(nsIScriptGlobalObject* aGlobalObject) = 0;
-# 1295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsIScriptGlobalObject*
-    GetScriptHandlingObject(bool& aHasHadScriptHandlingObject) const
-  {
-    aHasHadScriptHandlingObject = mHasHadScriptHandlingObject;
-    return mScriptGlobalObject ? mScriptGlobalObject.get() :
-                                 GetScriptHandlingObjectInternal();
-  }
-  virtual void SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) = 0;
-# 1311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual nsIGlobalObject* GetScopeObject() const = 0;
-  virtual void SetScopeObject(nsIGlobalObject* aGlobal) = 0;
-
-
-
-
-  nsPIDOMWindowOuter *GetWindow() const
-  {
-    return mWindow ? mWindow->GetOuterWindow() : GetWindowInternal();
-  }
-
-  bool IsInBackgroundWindow() const
-  {
-    auto* outer = mWindow ? mWindow->GetOuterWindow() : nullptr;
-    return outer && outer->IsBackground();
-  }
-
-
-
-
-
-
-  nsPIDOMWindowInner* GetInnerWindow() const
-  {
-    return mRemovedFromDocShell ? nullptr : mWindow;
-  }
-
-
-
-
-  uint64_t OuterWindowID() const
-  {
-    nsPIDOMWindowOuter* window = GetWindow();
-    return window ? window->WindowID() : 0;
-  }
-
-
-
-
-  uint64_t InnerWindowID() const
-  {
-    nsPIDOMWindowInner* window = GetInnerWindow();
-    return window ? window->WindowID() : 0;
-  }
-
-
-
-
-  virtual nsScriptLoader* ScriptLoader() = 0;
-
-
-
-
-  virtual void AddToIdTable(Element* aElement, nsIAtom* aId) = 0;
-  virtual void RemoveFromIdTable(Element* aElement, nsIAtom* aId) = 0;
-  virtual void AddToNameTable(Element* aElement, nsIAtom* aName) = 0;
-  virtual void RemoveFromNameTable(Element* aElement, nsIAtom* aName) = 0;
-
-
-
-
-  virtual nsTArray<Element*> GetFullscreenStack() const = 0;
-# 1385 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void AsyncRequestFullScreen(
-    mozilla::UniquePtr<FullscreenRequest>&& aRequest) = 0;
-
-
-
-
-
-
-
-  virtual nsresult
-    RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement) = 0;
-# 1406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-   virtual nsresult RemoteFrameFullscreenReverted() = 0;
-
-
-
-
-
-
-  virtual void RestorePreviousFullScreenState() = 0;
-
-
-
-
-
-  virtual bool IsFullscreenLeaf() = 0;
-
-
-
-
-
-
-  virtual nsIDocument* GetFullscreenRoot() = 0;
-
-
-
-
-
-  virtual void SetFullscreenRoot(nsIDocument* aRoot) = 0;
-# 1446 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  static void ExitFullscreenInDocTree(nsIDocument* aDocument);
-# 1457 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  static void AsyncExitFullscreen(nsIDocument* aDocument);
-
-
-
-
-
-
-  static bool HandlePendingFullscreenRequests(nsIDocument* aDocument);
-
-
-
-
-
-  void DispatchFullscreenError(const char* aMessage);
-
-  virtual void RequestPointerLock(Element* aElement,
-                                  mozilla::dom::CallerType aCallerType) = 0;
-
-  static void UnlockPointer(nsIDocument* aDoc = nullptr);
-
-
-
-  virtual void SetCurrentOrientation(mozilla::dom::OrientationType aType,
-                                     uint16_t aAngle) = 0;
-  virtual uint16_t CurrentOrientationAngle() const = 0;
-  virtual mozilla::dom::OrientationType CurrentOrientationType() const = 0;
-  virtual void SetOrientationPendingPromise(mozilla::dom::Promise* aPromise) = 0;
-  virtual mozilla::dom::Promise* GetOrientationPendingPromise() const = 0;
-# 1496 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void AddObserver(nsIDocumentObserver* aObserver) = 0;
-
-
-
-
-
-  virtual bool RemoveObserver(nsIDocumentObserver* aObserver) = 0;
-
-
-
-
-
-  virtual void BeginUpdate(nsUpdateType aUpdateType) = 0;
-  virtual void EndUpdate(nsUpdateType aUpdateType) = 0;
-  virtual void BeginLoad() = 0;
-  virtual void EndLoad() = 0;
-
-  enum ReadyState { READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4};
-  virtual void SetReadyStateInternal(ReadyState rs) = 0;
-  ReadyState GetReadyStateEnum()
-  {
-    return mReadyState;
-  }
-
-
-
-  virtual void ContentStateChanged(nsIContent* aContent,
-                                   mozilla::EventStates aStateMask) = 0;
-
-
-
-
-  virtual void DocumentStatesChanged(mozilla::EventStates aStateMask) = 0;
-
-
-
-  virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet,
-                                mozilla::css::Rule* aStyleRule) = 0;
-  virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet,
-                              mozilla::css::Rule* aStyleRule) = 0;
-  virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet,
-                                mozilla::css::Rule* aStyleRule) = 0;
-
-
-
-
-
-  virtual void FlushPendingNotifications(mozilla::FlushType aType) = 0;
-
-
-
-
-
-
-
-  virtual void FlushExternalResources(mozilla::FlushType aType) = 0;
-
-  nsBindingManager* BindingManager() const
-  {
-    return mNodeInfoManager->GetBindingManager();
-  }
-
-
-
-
-
-  nsNodeInfoManager* NodeInfoManager() const
-  {
-    return mNodeInfoManager;
-  }
-
-
-
-
-
-
-  virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) = 0;
-
-
-
-
-
-
-  virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,
-                          nsIPrincipal* aPrincipal) = 0;
-
-
-
-
-
-  virtual void SetContainer(nsDocShell* aContainer);
-
-
-
-
-  virtual nsISupports* GetContainer() const;
-
-
-
-
-  nsILoadContext* GetLoadContext() const;
-
-
-
-
-  nsIDocShell* GetDocShell() const;
-
-
-
-
-
-
-
-  virtual void SetXMLDeclaration(const char16_t *aVersion,
-                                 const char16_t *aEncoding,
-                                 const int32_t aStandalone) = 0;
-  virtual void GetXMLDeclaration(nsAString& aVersion,
-                                 nsAString& aEncoding,
-                                 nsAString& Standalone) = 0;
-
-
-
-
-
-
-
-  bool IsHTMLDocument() const
-  {
-    return mType == eHTML;
-  }
-  bool IsHTMLOrXHTML() const
-  {
-    return mType == eHTML || mType == eXHTML;
-  }
-  bool IsXMLDocument() const
-  {
-    return !IsHTMLDocument();
-  }
-  bool IsSVGDocument() const
-  {
-    return mType == eSVG;
-  }
-  bool IsXULDocument() const
-  {
-    return mType == eXUL;
-  }
-  bool IsUnstyledDocument()
-  {
-    return IsLoadedAsData() || IsLoadedAsInteractiveData();
-  }
-  bool LoadsFullXULStyleSheetUpFront()
-  {
-    return IsXULDocument() || AllowXULXBL();
-  }
-
-  virtual bool IsScriptEnabled() = 0;
-
-
-
-
-
-  virtual already_AddRefed<Element> CreateElem(const nsAString& aName,
-                                               nsIAtom* aPrefix,
-                                               int32_t aNamespaceID,
-                                               const nsAString* aIs = nullptr) = 0;
-# 1669 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsISupports *GetSecurityInfo()
-  {
-    return mSecurityInfo;
-  }
-
-
-
-
-
-  virtual nsIChannel* GetFailedChannel() const = 0;
-
-
-
-
-
-  virtual void SetFailedChannel(nsIChannel* aChannel) = 0;
-
-
-
-
-
-  int32_t GetDefaultNamespaceID() const
-  {
-    return mDefaultElementType;
-  }
-
-  void DeleteAllProperties();
-  void DeleteAllPropertiesFor(nsINode* aNode);
-
-  nsPropertyTable* PropertyTable(uint16_t aCategory) {
-    if (aCategory == 0)
-      return &mPropertyTable;
-    return GetExtraPropertyTable(aCategory);
-  }
-  uint32_t GetPropertyTableCount()
-  { return mExtraPropertyTables.Length() + 1; }
-
-
-
-
-  void SetPartID(uint32_t aID) {
-    mPartID = aID;
-  }
-
-
-
-
-  uint32_t GetPartID() const {
-    return mPartID;
-  }
-
-
-
-
-
-  virtual void Sanitize() = 0;
-
-
-
-
-
-
-  typedef bool (*nsSubDocEnumFunc)(nsIDocument *aDocument, void *aData);
-  virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
-                                     void *aData) = 0;
-# 1752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual bool CanSavePresentation(nsIRequest *aNewRequest) = 0;
-
-
-
-
-
-
-  virtual void Destroy() = 0;
-
-
-
-
-
-
-
-  virtual void RemovedFromDocShell() = 0;
-
-
-
-
-
-
-  virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const = 0;
-# 1783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void BlockOnload() = 0;
-
-
-
-
-
-
-  virtual void UnblockOnload(bool aFireSync) = 0;
-
-  void BlockDOMContentLoaded()
-  {
-    ++mBlockDOMContentLoaded;
-  }
-
-  virtual void UnblockDOMContentLoaded() = 0;
-# 1811 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void OnPageShow(bool aPersisted,
-                          mozilla::dom::EventTarget* aDispatchStartTarget) = 0;
-# 1826 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void OnPageHide(bool aPersisted,
-                          mozilla::dom::EventTarget* aDispatchStartTarget) = 0;
-# 1836 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) = 0;
-
-
-
-
-
-
-  virtual void ForgetLink(mozilla::dom::Link* aLink) = 0;
-
-
-
-
-
-
-  virtual void ClearBoxObjectFor(nsIContent *aContent) = 0;
-
-
-
-
-
-  virtual already_AddRefed<mozilla::dom::BoxObject>
-    GetBoxObjectFor(mozilla::dom::Element* aElement,
-                    mozilla::ErrorResult& aRv) = 0;
-
-
-
-
-
-  already_AddRefed<mozilla::dom::MediaQueryList>
-    MatchMedia(const nsAString& aMediaQueryList);
-
-  const PRCList* MediaQueryLists() const {
-    return &mDOMMediaQueryLists;
-  }
-
-
-
-
-  nsCompatibility GetCompatibilityMode() const {
-    return mCompatMode;
-  }
-
-
-
-
-
-  bool HaveFiredDOMTitleChange() const {
-    return mHaveFiredTitleChange;
-  }
-
-
-
-
-  virtual Element*
-    GetAnonymousElementByAttribute(nsIContent* aElement,
-                                   nsIAtom* aAttrName,
-                                   const nsAString& aAttrValue) const = 0;
-
-
-
-
-
-
-
-  virtual Element* ElementFromPointHelper(float aX, float aY,
-                                          bool aIgnoreRootScrollFrame,
-                                          bool aFlushLayout) = 0;
-
-  enum ElementsFromPointFlags {
-    IGNORE_ROOT_SCROLL_FRAME = 1,
-    FLUSH_LAYOUT = 2,
-    IS_ELEMENT_FROM_POINT = 4
-  };
-
-  virtual void ElementsFromPointHelper(float aX, float aY,
-                                       uint32_t aFlags,
-                                       nsTArray<RefPtr<mozilla::dom::Element>>& aElements) = 0;
-
-  virtual nsresult NodesFromRectHelper(float aX, float aY,
-                                       float aTopSize, float aRightSize,
-                                       float aBottomSize, float aLeftSize,
-                                       bool aIgnoreRootScrollFrame,
-                                       bool aFlushLayout,
-                                       nsIDOMNodeList** aReturn) = 0;
-
-
-
-
-  virtual void FlushSkinBindings() = 0;
-# 1933 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  void MayDispatchMutationEvent(nsINode* aTarget)
-  {
-    if (mSubtreeModifiedDepth > 0) {
-      mSubtreeModifiedTargets.AppendObject(aTarget);
-    }
-  }
-
-
-
-
-
-  void MarkUncollectableForCCGeneration(uint32_t aGeneration)
-  {
-    mMarkedCCGeneration = aGeneration;
-  }
-
-
-
-
-  uint32_t GetMarkedCCGeneration()
-  {
-    return mMarkedCCGeneration;
-  }
-
-  bool IsLoadedAsData()
-  {
-    return mLoadedAsData;
-  }
-
-  bool IsLoadedAsInteractiveData()
-  {
-    return mLoadedAsInteractiveData;
-  }
-
-  bool MayStartLayout()
-  {
-    return mMayStartLayout;
-  }
-
-  virtual void SetMayStartLayout(bool aMayStartLayout)
-  {
-    mMayStartLayout = aMayStartLayout;
-  }
-
-  already_AddRefed<nsIDocumentEncoder> GetCachedEncoder();
-
-  void SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder);
-
-
-  virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) = 0;
-
-
-  virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader, nsIRunnable* aFinalizer) = 0;
-
-  virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) = 0;
-
-
-
-
-
-  bool IsRootDisplayDocument() const
-  {
-    return !mParentDocument && !mDisplayDocument;
-  }
-
-  bool IsBeingUsedAsImage() const {
-    return mIsBeingUsedAsImage;
-  }
-
-  void SetIsBeingUsedAsImage() {
-    mIsBeingUsedAsImage = true;
-  }
-
-  bool IsResourceDoc() const {
-    return IsBeingUsedAsImage() ||
-      mHasDisplayDocument;
-  }
-
-
-
-
-
-
-
-  nsIDocument* GetDisplayDocument() const
-  {
-    return mDisplayDocument;
-  }
-
-
-
-
-
-  void SetDisplayDocument(nsIDocument* aDisplayDocument)
-  {
-    do { } while (0);
-
-
-
-
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-
-    mDisplayDocument = aDisplayDocument;
-    mHasDisplayDocument = !!aDisplayDocument;
-  }
-# 2051 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  class ExternalResourceLoad : public nsISupports
-  {
-  public:
-    virtual ~ExternalResourceLoad() {}
-
-    void AddObserver(nsIObserver* aObserver) {
-      do { } while (0);
-      mObservers.AppendElement(aObserver);
-    }
-
-    const nsTArray< nsCOMPtr<nsIObserver> > & Observers() {
-      return mObservers;
-    }
-  protected:
-    AutoTArray< nsCOMPtr<nsIObserver>, 8 > mObservers;
-  };
-# 2081 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual nsIDocument*
-    RequestExternalResource(nsIURI* aURI,
-                            nsINode* aRequestingNode,
-                            ExternalResourceLoad** aPendingLoad) = 0;
-
-
-
-
-
-
-  virtual void EnumerateExternalResources(nsSubDocEnumFunc aCallback,
-                                          void* aData) = 0;
-
-
-
-
-
-
-  bool IsShowing() const { return mIsShowing; }
-
-
-
-
-  bool IsVisible() const { return mVisible; }
-
-
-
-
-
-  bool IsVisibleConsideringAncestors() const;
-
-
-
-
-
-
-
-  bool IsActive() const { return mDocumentContainer && !mRemovedFromDocShell; }
-# 2127 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  bool IsCurrentActiveDocument() const
-  {
-    nsPIDOMWindowInner* inner = GetInnerWindow();
-    return inner && inner->IsCurrentInnerWindow() && inner->GetDoc() == this;
-  }
-
-
-
-
-
-
-
-  void RegisterActivityObserver(nsISupports* aSupports);
-  bool UnregisterActivityObserver(nsISupports* aSupports);
-
-  typedef void (* ActivityObserverEnumerator)(nsISupports*, void*);
-  void EnumerateActivityObservers(ActivityObserverEnumerator aEnumerator,
-                                  void* aData);
-
-
-
-
-  bool HasAnimationController() { return !!mAnimationController; }
-
-
-
-
-  virtual nsSMILAnimationController* GetAnimationController() = 0;
-
-
-
-
-
-  virtual mozilla::PendingAnimationTracker* GetPendingAnimationTracker() = 0;
-
-
-
-
-  virtual mozilla::PendingAnimationTracker*
-  GetOrCreatePendingAnimationTracker() = 0;
-
-
-
-
-
-  virtual void SuppressEventHandling(uint32_t aIncrease = 1) = 0;
-
-
-
-
-
-
-  virtual void UnsuppressEventHandlingAndFireEvents(bool aFireEvents) = 0;
-
-  uint32_t EventHandlingSuppressed() const { return mEventsSuppressed; }
-
-  bool IsEventHandlingEnabled() {
-    return !EventHandlingSuppressed() && mScriptGlobalObject;
-  }
-
-
-
-
-  void BeginEvaluatingExternalScript() { ++mExternalScriptsBeingEvaluated; }
-
-
-
-
-  void EndEvaluatingExternalScript() { --mExternalScriptsBeingEvaluated; }
-
-  bool IsDNSPrefetchAllowed() const { return mAllowDNSPrefetch; }
-
-
-
-
-
-  bool AllowXULXBL() {
-    return mAllowXULXBL == eTriTrue ? true :
-           mAllowXULXBL == eTriFalse ? false :
-           InternalAllowXULXBL();
-  }
-
-  void ForceEnableXULXBL() {
-    mAllowXULXBL = eTriTrue;
-  }
-
-
-
-
-
-  virtual nsIDocument* GetTemplateContentsOwner() = 0;
-# 2228 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  bool IsStaticDocument() { return mIsStaticDocument; }
-# 2241 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual already_AddRefed<nsIDocument>
-  CreateStaticClone(nsIDocShell* aCloneContainer);
-
-
-
-
-
-  nsIDocument* GetOriginalDocument()
-  {
-    do { } while (0);
-    return mOriginalDocument;
-  }
-
-
-
-
-
-  void UnlinkOriginalDocumentIfStatic();
-# 2272 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual void PreloadPictureOpened() = 0;
-
-  virtual void PreloadPictureClosed() = 0;
-
-  virtual void PreloadPictureImageSource(const nsAString& aSrcsetAttr,
-                                         const nsAString& aSizesAttr,
-                                         const nsAString& aTypeAttr,
-                                         const nsAString& aMediaAttr) = 0;
-# 2288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual already_AddRefed<nsIURI>
-    ResolvePreloadImage(nsIURI *aBaseURI,
-                        const nsAString& aSrcAttr,
-                        const nsAString& aSrcsetAttr,
-                        const nsAString& aSizesAttr) = 0;
-
-
-
-
-
-
-  virtual void MaybePreLoadImage(nsIURI* uri,
-                                 const nsAString& aCrossOriginAttr,
-                                 ReferrerPolicyEnum aReferrerPolicy) = 0;
-
-
-
-
-
-  virtual void ForgetImagePreload(nsIURI* aURI) = 0;
-
-
-
-
-
-
-  virtual void PreloadStyle(nsIURI* aURI, const nsAString& aCharset,
-                            const nsAString& aCrossOriginAttr,
-                            ReferrerPolicyEnum aReferrerPolicy,
-                            const nsAString& aIntegrity) = 0;
-# 2327 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
-                                       RefPtr<mozilla::StyleSheet>* aSheet) = 0;
-# 2337 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual bool IsDocumentRightToLeft() { return false; }
-
-
-
-
-  virtual void MaybePreconnect(nsIURI* uri,
-                               mozilla::CORSMode aCORSMode) = 0;
-
-  enum DocumentTheme {
-    Doc_Theme_Uninitialized,
-    Doc_Theme_None,
-    Doc_Theme_Neutral,
-    Doc_Theme_Dark,
-    Doc_Theme_Bright
-  };
-
-
-
-
-
-  void SetStateObject(nsIStructuredCloneContainer *scContainer);
-
-
-
-
-
-
-
-  virtual int GetDocumentLWTheme() { return Doc_Theme_None; }
-
-
-
-
-
-
-  virtual mozilla::EventStates GetDocumentState() = 0;
-  virtual mozilla::EventStates ThreadSafeGetDocumentState() const = 0;
-
-  virtual nsISupports* GetCurrentContentSink() = 0;
-
-  virtual void SetScrollToRef(nsIURI *aDocumentURI) = 0;
-  virtual void ScrollToRef() = 0;
-  virtual void ResetScrolledToRefAlready() = 0;
-  virtual void SetChangeScrollPosWhenScrollingToRef(bool aValue) = 0;
-
-
-
-
-
-
-
-  virtual Element* GetElementById(const nsAString& aElementId) = 0;
-
-
-
-
-
-  virtual const nsTArray<Element*>* GetAllElementsForId(const nsAString& aElementId) const = 0;
-# 2403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  virtual Element* LookupImageElement(const nsAString& aElementId) = 0;
-
-  virtual mozilla::dom::DocumentTimeline* Timeline() = 0;
-  virtual mozilla::LinkedList<mozilla::dom::DocumentTimeline>& Timelines() = 0;
-
-  virtual void GetAnimations(
-      nsTArray<RefPtr<mozilla::dom::Animation>>& aAnimations) = 0;
-
-  mozilla::dom::SVGSVGElement* GetSVGRootElement() const;
-
-  nsresult ScheduleFrameRequestCallback(mozilla::dom::FrameRequestCallback& aCallback,
-                                        int32_t *aHandle);
-  void CancelFrameRequestCallback(int32_t aHandle);
-
-  typedef nsTArray<RefPtr<mozilla::dom::FrameRequestCallback>> FrameRequestCallbackList;
-
-
-
-
-  void TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks);
-
-
-
-
-
-
-  bool ShouldThrottleFrameRequests();
-
-
-  bool InUnlinkOrDeletion() { return mInUnlinkOrDeletion; }
-
-  mozilla::dom::ImageTracker* ImageTracker();
-
-  virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) = 0;
-  virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) = 0;
-  virtual void GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins) = 0;
-
-  virtual nsresult AddResponsiveContent(nsIContent* aContent) = 0;
-  virtual void RemoveResponsiveContent(nsIContent* aContent) = 0;
-  virtual void NotifyMediaFeatureValuesChanged() = 0;
-
-  virtual nsresult GetStateObject(nsIVariant** aResult) = 0;
-
-  virtual nsDOMNavigationTiming* GetNavigationTiming() const = 0;
-
-  virtual nsresult SetNavigationTiming(nsDOMNavigationTiming* aTiming) = 0;
-
-  virtual Element* FindImageMap(const nsAString& aNormalizedMapName) = 0;
-
-
-  void RegisterPendingLinkUpdate(mozilla::dom::Link* aLink);
-
-
-
-  void UnregisterPendingLinkUpdate(mozilla::dom::Link* aElement);
-
-
-
-  void FlushPendingLinkUpdates();
-
-
-  enum DeprecatedOperations {
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDeprecatedOperationList.h"
-eGetAttributeNode,
-eSetAttributeNode,
-eGetAttributeNodeNS,
-eSetAttributeNodeNS,
-eRemoveAttributeNode,
-eCreateAttribute,
-eCreateAttributeNS,
-eNodeValue,
-eTextContent,
-eEnablePrivilege,
-eDOMExceptionCode,
-eNoExposedProps,
-eMutationEvent,
-eComponents,
-ePrefixedVisibilityAPI,
-eNodeIteratorDetach,
-eLenientThis,
-eGetPreventDefault,
-eGetSetUserData,
-eMozGetAsFile,
-eUseOfCaptureEvents,
-eUseOfReleaseEvents,
-eUseOfDOM3LoadMethod,
-eChromeUseOfDOM3LoadMethod,
-eShowModalDialog,
-eWindow_Content,
-eSyncXMLHttpRequest,
-eDataContainerEvent,
-eWindow_Controllers,
-eImportXULIntoContent,
-ePannerNodeDoppler,
-eNavigatorGetUserMedia,
-eWebrtcDeprecatedPrefix,
-eRTCPeerConnectionGetStreams,
-eAppCache,
-ePrefixedImageSmoothingEnabled,
-ePrefixedFullscreenAPI,
-eLenientSetter,
-eFileLastModifiedDate,
-eImageBitmapRenderingContext_TransferImageBitmap,
-eURLCreateObjectURL_MediaStream,
-eXMLBaseAttribute,
-eXMLBaseAttributeForStyleAttr,
-# 2466 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
- eDeprecatedOperationCount
-  };
-
-  bool HasWarnedAbout(DeprecatedOperations aOperation) const;
-  void WarnOnceAbout(DeprecatedOperations aOperation,
-                     bool asError = false) const;
-
-
-  enum DocumentWarnings {
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDocumentWarningList.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDocumentWarningList.h"
-eIgnoringWillChangeOverBudget,
-ePreventDefaultFromPassiveListener,
-eSVGReferenceLoop,
-eSVGReferenceChainLengthExceeded,
-# 2476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h" 2
- eDocumentWarningCount
-  };
-
-  bool HasWarnedAbout(DocumentWarnings aWarning) const;
-  void WarnOnceAbout(DocumentWarnings aWarning,
-                     bool asError = false,
-                     const char16_t **aParams = nullptr,
-                     uint32_t aParamsLength = 0) const;
-
-  virtual void PostVisibilityUpdateEvent() = 0;
-
-  bool IsSyntheticDocument() const { return mIsSyntheticDocument; }
-
-
-
-
-
-  virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const;
-
-
-
-  virtual void DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const;
-
-  bool MayHaveDOMMutationObservers()
-  {
-    return mMayHaveDOMMutationObservers;
-  }
-
-  void SetMayHaveDOMMutationObservers()
-  {
-    mMayHaveDOMMutationObservers = true;
-  }
-
-  bool MayHaveAnimationObservers()
-  {
-    return mMayHaveAnimationObservers;
-  }
-
-  void SetMayHaveAnimationObservers()
-  {
-    mMayHaveAnimationObservers = true;
-  }
-
-  bool IsInSyncOperation()
-  {
-    return mInSyncOperationCount != 0;
-  }
-
-  void SetIsInSyncOperation(bool aSync)
-  {
-    if (aSync) {
-      ++mInSyncOperationCount;
-    } else {
-      --mInSyncOperationCount;
-    }
-  }
-
-  bool CreatingStaticClone() const
-  {
-    return mCreatingStaticClone;
-  }
-
-
-
-
-
-  already_AddRefed<Element> CreateHTMLElement(nsIAtom* aTag);
-
-
-  nsIGlobalObject* GetParentObject() const
-  {
-    return GetScopeObject();
-  }
-  static already_AddRefed<nsIDocument>
-    Constructor(const GlobalObject& aGlobal,
-                mozilla::ErrorResult& rv);
-  virtual mozilla::dom::DOMImplementation*
-    GetImplementation(mozilla::ErrorResult& rv) = 0;
-  __attribute__ ((warn_unused_result)) nsresult GetURL(nsString& retval) const;
-  __attribute__ ((warn_unused_result)) nsresult GetDocumentURI(nsString& retval) const;
-
-
-
-
-  void GetDocumentURIFromJS(nsString& aDocumentURI,
-                            mozilla::dom::CallerType aCallerType,
-                            mozilla::ErrorResult& aRv) const;
-  void GetCompatMode(nsString& retval) const;
-  void GetCharacterSet(nsAString& retval) const;
-
-
-  Element* GetDocumentElement() const
-  {
-    return GetRootElement();
-  }
-
-  enum ElementCallbackType {
-    eCreated,
-    eAttached,
-    eDetached,
-    eAttributeChanged
-  };
-
-  nsIDocument* GetTopLevelContentDocument();
-
-  virtual void
-    RegisterElement(JSContext* aCx, const nsAString& aName,
-                    const mozilla::dom::ElementRegistrationOptions& aOptions,
-                    JS::MutableHandle<JSObject*> aRetval,
-                    mozilla::ErrorResult& rv) = 0;
-  virtual already_AddRefed<mozilla::dom::CustomElementRegistry>
-    GetCustomElementRegistry() = 0;
-
-  already_AddRefed<nsContentList>
-  GetElementsByTagName(const nsAString& aTagName)
-  {
-    return NS_GetContentList(this, -1, aTagName);
-  }
-  already_AddRefed<nsContentList>
-    GetElementsByTagNameNS(const nsAString& aNamespaceURI,
-                           const nsAString& aLocalName,
-                           mozilla::ErrorResult& aResult);
-  already_AddRefed<nsContentList>
-    GetElementsByClassName(const nsAString& aClasses);
-
-  virtual already_AddRefed<Element>
-    CreateElement(const nsAString& aTagName,
-                  const mozilla::dom::ElementCreationOptionsOrString& aOptions,
-                  mozilla::ErrorResult& rv) = 0;
-  virtual already_AddRefed<Element>
-    CreateElementNS(const nsAString& aNamespaceURI,
-                    const nsAString& aQualifiedName,
-                    const mozilla::dom::ElementCreationOptionsOrString& aOptions,
-                    mozilla::ErrorResult& rv) = 0;
-  already_AddRefed<mozilla::dom::DocumentFragment>
-    CreateDocumentFragment() const;
-  already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData) const;
-  already_AddRefed<mozilla::dom::Comment>
-    CreateComment(const nsAString& aData) const;
-  already_AddRefed<mozilla::dom::ProcessingInstruction>
-    CreateProcessingInstruction(const nsAString& target, const nsAString& data,
-                                mozilla::ErrorResult& rv) const;
-  already_AddRefed<nsINode>
-    ImportNode(nsINode& aNode, bool aDeep, mozilla::ErrorResult& rv) const;
-  nsINode* AdoptNode(nsINode& aNode, mozilla::ErrorResult& rv);
-  already_AddRefed<mozilla::dom::Event>
-    CreateEvent(const nsAString& aEventType, mozilla::ErrorResult& rv) const;
-  already_AddRefed<nsRange> CreateRange(mozilla::ErrorResult& rv);
-  already_AddRefed<mozilla::dom::NodeIterator>
-    CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
-                       mozilla::dom::NodeFilter* aFilter,
-                       mozilla::ErrorResult& rv) const;
-  already_AddRefed<mozilla::dom::NodeIterator>
-    CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
-                       mozilla::dom::NodeFilterHolder aFilter,
-                       mozilla::ErrorResult& rv) const;
-  already_AddRefed<mozilla::dom::TreeWalker>
-    CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
-                     mozilla::dom::NodeFilter* aFilter, mozilla::ErrorResult& rv) const;
-  already_AddRefed<mozilla::dom::TreeWalker>
-    CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
-                     mozilla::dom::NodeFilterHolder aFilter,
-                     mozilla::ErrorResult& rv) const;
-
-
-  already_AddRefed<mozilla::dom::CDATASection>
-    CreateCDATASection(const nsAString& aData, mozilla::ErrorResult& rv);
-  already_AddRefed<mozilla::dom::Attr>
-    CreateAttribute(const nsAString& aName, mozilla::ErrorResult& rv);
-  already_AddRefed<mozilla::dom::Attr>
-    CreateAttributeNS(const nsAString& aNamespaceURI,
-                      const nsAString& aQualifiedName,
-                      mozilla::ErrorResult& rv);
-  void GetInputEncoding(nsAString& aInputEncoding) const;
-  already_AddRefed<mozilla::dom::Location> GetLocation() const;
-  void GetReferrer(nsAString& aReferrer) const;
-  void GetLastModified(nsAString& aLastModified) const;
-  void GetReadyState(nsAString& aReadyState) const;
-
-
-
-  virtual void GetTitle(nsString& aTitle) = 0;
-  virtual void SetTitle(const nsAString& aTitle, mozilla::ErrorResult& rv) = 0;
-  void GetDir(nsAString& aDirection) const;
-  void SetDir(const nsAString& aDirection);
-  nsPIDOMWindowOuter* GetDefaultView() const
-  {
-    return GetWindow();
-  }
-  Element* GetActiveElement();
-  bool HasFocus(mozilla::ErrorResult& rv) const;
-  mozilla::TimeStamp LastFocusTime() const;
-  void SetLastFocusTime(const mozilla::TimeStamp& aFocusTime);
-
-  bool MozSyntheticDocument() const
-  {
-    return IsSyntheticDocument();
-  }
-  Element* GetCurrentScript();
-  void ReleaseCapture() const;
-  virtual void MozSetImageElement(const nsAString& aImageElementId,
-                                  Element* aElement) = 0;
-  nsIURI* GetDocumentURIObject() const;
-
-  virtual bool FullscreenEnabled(mozilla::dom::CallerType aCallerType) = 0;
-  virtual Element* GetFullscreenElement() = 0;
-  bool Fullscreen()
-  {
-    return !!GetFullscreenElement();
-  }
-  void ExitFullscreen();
-  Element* GetPointerLockElement();
-  void ExitPointerLock()
-  {
-    UnlockPointer(this);
-  }
-
-  bool Hidden() const
-  {
-    return mVisibilityState != mozilla::dom::VisibilityState::Visible;
-  }
-  mozilla::dom::VisibilityState VisibilityState() const
-  {
-    return mVisibilityState;
-  }
-
-  virtual mozilla::dom::StyleSheetList* StyleSheets() = 0;
-  void GetSelectedStyleSheetSet(nsAString& aSheetSet);
-  virtual void SetSelectedStyleSheetSet(const nsAString& aSheetSet) = 0;
-  virtual void GetLastStyleSheetSet(nsString& aSheetSet) = 0;
-  void GetPreferredStyleSheetSet(nsAString& aSheetSet);
-  virtual mozilla::dom::DOMStringList* StyleSheetSets() = 0;
-  virtual void EnableStyleSheetsForSet(const nsAString& aSheetSet) = 0;
-  Element* ElementFromPoint(float aX, float aY);
-  void ElementsFromPoint(float aX,
-                         float aY,
-                         nsTArray<RefPtr<mozilla::dom::Element>>& aElements);
-# 2723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  already_AddRefed<nsDOMCaretPosition>
-    CaretPositionFromPoint(float aX, float aY);
-
-  Element* GetScrollingElement();
-
-
-  nsINodeList* GetAnonymousNodes(Element& aElement);
-  Element* GetAnonymousElementByAttribute(Element& aElement,
-                                          const nsAString& aAttrName,
-                                          const nsAString& aAttrValue);
-  Element* GetBindingParent(nsINode& aNode);
-  void LoadBindingDocument(const nsAString& aURI,
-                           nsIPrincipal& aSubjectPrincipal,
-                           mozilla::ErrorResult& rv);
-  void LoadBindingDocument(const nsAString& aURI,
-                           const mozilla::Maybe<nsIPrincipal*>& aSubjectPrincipal,
-                           mozilla::ErrorResult& rv);
-  mozilla::dom::XPathExpression*
-    CreateExpression(const nsAString& aExpression,
-                     mozilla::dom::XPathNSResolver* aResolver,
-                     mozilla::ErrorResult& rv);
-  nsINode* CreateNSResolver(nsINode& aNodeResolver);
-  already_AddRefed<mozilla::dom::XPathResult>
-    Evaluate(JSContext* aCx, const nsAString& aExpression, nsINode& aContextNode,
-             mozilla::dom::XPathNSResolver* aResolver, uint16_t aType,
-             JS::Handle<JSObject*> aResult, mozilla::ErrorResult& rv);
-
-  already_AddRefed<mozilla::dom::Touch>
-    CreateTouch(nsGlobalWindow* aView, mozilla::dom::EventTarget* aTarget,
-                int32_t aIdentifier, int32_t aPageX, int32_t aPageY,
-                int32_t aScreenX, int32_t aScreenY, int32_t aClientX,
-                int32_t aClientY, int32_t aRadiusX, int32_t aRadiusY,
-                float aRotationAngle, float aForce);
-  already_AddRefed<mozilla::dom::TouchList> CreateTouchList();
-  already_AddRefed<mozilla::dom::TouchList>
-    CreateTouchList(mozilla::dom::Touch& aTouch,
-                    const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches);
-  already_AddRefed<mozilla::dom::TouchList>
-    CreateTouchList(const mozilla::dom::Sequence<mozilla::OwningNonNull<mozilla::dom::Touch> >& aTouches);
-
-  void SetStyleSheetChangeEventsEnabled(bool aValue)
-  {
-    mStyleSheetChangeEventsEnabled = aValue;
-  }
-
-  bool StyleSheetChangeEventsEnabled() const
-  {
-    return mStyleSheetChangeEventsEnabled;
-  }
-
-  void ObsoleteSheet(nsIURI *aSheetURI, mozilla::ErrorResult& rv);
-
-  void ObsoleteSheet(const nsAString& aSheetURI, mozilla::ErrorResult& rv);
-
-  already_AddRefed<mozilla::dom::Promise> BlockParsing(mozilla::dom::Promise& aPromise,
-                                                       mozilla::ErrorResult& aRv);
-
-  already_AddRefed<nsIURI> GetMozDocumentURIIfNotForErrorPages();
-
-
-  nsIHTMLCollection* Children();
-  uint32_t ChildElementCount();
-
-  virtual nsHTMLDocument* AsHTMLDocument() { return nullptr; }
-  virtual mozilla::dom::SVGDocument* AsSVGDocument() { return nullptr; }
-
-
-
-  virtual nsIDocument* MasterDocument() = 0;
-  virtual void SetMasterDocument(nsIDocument* master) = 0;
-  virtual bool IsMasterDocument() = 0;
-  virtual mozilla::dom::ImportManager* ImportManager() = 0;
-
-  virtual bool HasSubImportLink(nsINode* aLink) = 0;
-  virtual uint32_t IndexOfSubImportLink(nsINode* aLink) = 0;
-  virtual void AddSubImportLink(nsINode* aLink) = 0;
-  virtual nsINode* GetSubImportLink(uint32_t aIdx) = 0;
-
-
-
-
-
-
-  void AddBlockedTrackingNode(nsINode *node)
-  {
-    if (!node) {
-      return;
-    }
-
-    nsWeakPtr weakNode = do_GetWeakReference(node);
-
-    if (weakNode) {
-      mBlockedTrackingNodes.AppendElement(weakNode);
-    }
-  }
-
-  gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true);
-  void FlushUserFontSet();
-  void RebuildUserFontSet();
-  mozilla::dom::FontFaceSet* GetFonts() { return mFontFaceSet; }
-
-
-  mozilla::dom::FontFaceSet* Fonts();
-
-  bool DidFireDOMContentLoaded() const { return mDidFireDOMContentLoaded; }
-
-  void SetDocumentUseCounter(mozilla::UseCounter aUseCounter)
-  {
-    if (!mUseCounters[aUseCounter]) {
-      mUseCounters[aUseCounter] = true;
-    }
-  }
-
-  void SetPageUseCounter(mozilla::UseCounter aUseCounter);
-
-  void SetDocumentAndPageUseCounter(mozilla::UseCounter aUseCounter)
-  {
-    SetDocumentUseCounter(aUseCounter);
-    SetPageUseCounter(aUseCounter);
-  }
-
-  void PropagateUseCounters(nsIDocument* aParentDocument);
-
-  void SetUserHasInteracted(bool aUserHasInteracted)
-  {
-    mUserHasInteracted = aUserHasInteracted;
-  }
-
-  bool UserHasInteracted()
-  {
-    return mUserHasInteracted;
-  }
-
-  bool HasScriptsBlockedBySandbox();
-
-  bool InlineScriptAllowedByCSP();
-
-  void ReportHasScrollLinkedEffect();
-  bool HasScrollLinkedEffect() const
-  {
-    return mHasScrollLinkedEffect;
-  }
-
-  mozilla::dom::DocGroup* GetDocGroup() const;
-
-  virtual void AddIntersectionObserver(
-    mozilla::dom::DOMIntersectionObserver* aObserver) = 0;
-  virtual void RemoveIntersectionObserver(
-    mozilla::dom::DOMIntersectionObserver* aObserver) = 0;
-
-  virtual void UpdateIntersectionObservations() = 0;
-  virtual void ScheduleIntersectionObserverNotification() = 0;
-  virtual void NotifyIntersectionObservers() = 0;
-
-
-  virtual nsresult Dispatch(const char* aName,
-                            mozilla::TaskCategory aCategory,
-                            already_AddRefed<nsIRunnable>&& aRunnable) override;
-
-  virtual nsIEventTarget*
-  EventTargetFor(mozilla::TaskCategory aCategory) const override;
-
-  virtual mozilla::AbstractThread*
-  AbstractMainThreadFor(mozilla::TaskCategory aCategory) override;
-
-
-
-
-  void NoteScriptTrackingStatus(const nsACString& aURL, bool isTracking);
-  bool IsScriptTracking(const nsACString& aURL) const;
-
-  bool PrerenderHref(nsIURI* aHref);
-
-
-
-  virtual mozilla::dom::FlashClassification DocumentFlashClassification() = 0;
-  virtual bool IsThirdParty() = 0;
-
-protected:
-  bool GetUseCounter(mozilla::UseCounter aUseCounter)
-  {
-    return mUseCounters[aUseCounter];
-  }
-
-  void SetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
-  {
-    if (!mChildDocumentUseCounters[aUseCounter]) {
-      mChildDocumentUseCounters[aUseCounter] = true;
-    }
-  }
-
-  bool GetChildDocumentUseCounter(mozilla::UseCounter aUseCounter)
-  {
-    return mChildDocumentUseCounters[aUseCounter];
-  }
-
-private:
-  mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout;
-  mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout;
-
-  nsAutoPtr<SelectorCache> mSelectorCache;
-
-protected:
-  ~nsIDocument();
-  nsPropertyTable* GetExtraPropertyTable(uint16_t aCategory);
-
-
-  virtual nsPIDOMWindowOuter* GetWindowInternal() const = 0;
-
-
-  virtual nsIScriptGlobalObject* GetScriptHandlingObjectInternal() const = 0;
-
-
-  virtual bool InternalAllowXULXBL() = 0;
-
-
-
-
-
-
-  virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0;
-  virtual void MutationEventDispatched(nsINode* aTarget) = 0;
-  friend class mozAutoSubtreeModified;
-
-  virtual Element* GetNameSpaceElement() override
-  {
-    return GetRootElement();
-  }
-
-  void SetContentTypeInternal(const nsACString& aType);
-
-  nsCString GetContentTypeInternal() const
-  {
-    return mContentType;
-  }
-
-  mozilla::dom::XPathEvaluator* XPathEvaluator();
-
-  void HandleRebuildUserFontSet() {
-    mPostedFlushUserFontSet = false;
-    FlushUserFontSet();
-  }
-
-  const nsString& GetId() const
-  {
-    return mId;
-  }
-
-
-
-
-
-
-  void UpdateFrameRequestCallbackSchedulingState(nsIPresShell* aOldShell = nullptr);
-
-  nsCString mReferrer;
-  nsString mLastModified;
-
-  nsCOMPtr<nsIURI> mDocumentURI;
-  nsCOMPtr<nsIURI> mOriginalURI;
-  nsCOMPtr<nsIURI> mChromeXHRDocURI;
-  nsCOMPtr<nsIURI> mDocumentBaseURI;
-  nsCOMPtr<nsIURI> mChromeXHRDocBaseURI;
-
-  nsWeakPtr mDocumentLoadGroup;
-
-  bool mReferrerPolicySet;
-  ReferrerPolicyEnum mReferrerPolicy;
-
-  bool mBlockAllMixedContent;
-  bool mBlockAllMixedContentPreloads;
-  bool mUpgradeInsecureRequests;
-  bool mUpgradeInsecurePreloads;
-
-
-
-
-  nsDataHashtable<nsURIHashKey, HSTSPrimingState> mHSTSPrimingURIList;
-
-  mozilla::WeakPtr<nsDocShell> mDocumentContainer;
-
-  nsCString mCharacterSet;
-  int32_t mCharacterSetSource;
-
-
-  nsIDocument* mParentDocument;
-
-
-  mozilla::dom::Element* mCachedRootElement;
-
-
-
-  nsNodeInfoManager* mNodeInfoManager;
-  RefPtr<mozilla::css::Loader> mCSSLoader;
-  RefPtr<mozilla::css::ImageLoader> mStyleImageLoader;
-  RefPtr<nsHTMLStyleSheet> mAttrStyleSheet;
-  RefPtr<nsHTMLCSSStyleSheet> mStyleAttrStyleSheet;
-
-
-  RefPtr<mozilla::dom::ImageTracker> mImageTracker;
-
-
-
-
-
-
-  nsAutoPtr<nsTHashtable<nsPtrHashKey<nsISupports> > > mActivityObservers;
-
-
-
-
-  nsTHashtable<nsPtrHashKey<mozilla::dom::Link> > mLinksToUpdate;
-
-
-  RefPtr<nsSMILAnimationController> mAnimationController;
-
-
-  nsPropertyTable mPropertyTable;
-  nsTArray<nsAutoPtr<nsPropertyTable> > mExtraPropertyTables;
-
-
-  nsCOMPtr<nsIHTMLCollection> mChildrenCollection;
-
-
-  RefPtr<mozilla::dom::FontFaceSet> mFontFaceSet;
-
-
-
-  mozilla::TimeStamp mLastFocusTime;
-
-
-  bool mBidiEnabled : 1;
-
-  bool mMathMLEnabled : 1;
-
-
-
-
-
-  bool mIsInitialDocumentInWindow : 1;
-
-  bool mIgnoreDocGroupMismatches : 1;
-
-
-
-  bool mLoadedAsData : 1;
-
-
-
-
-  bool mLoadedAsInteractiveData : 1;
-
-
-
-  bool mMayStartLayout : 1;
-
-
-  bool mHaveFiredTitleChange : 1;
-
-
-
-
-
-  bool mIsShowing : 1;
-
-
-
-
-  bool mVisible : 1;
-
-
-  bool mHasReferrerPolicyCSP : 1;
-
-
-
-
-  bool mRemovedFromDocShell : 1;
-
-
-
-  bool mAllowDNSPrefetch : 1;
-
-
-  bool mIsStaticDocument : 1;
-
-
-  bool mCreatingStaticClone : 1;
-
-
-  bool mInUnlinkOrDeletion : 1;
-
-
-  bool mHasHadScriptHandlingObject : 1;
-
-
-  bool mIsBeingUsedAsImage : 1;
-
-
-
-  bool mIsSyntheticDocument : 1;
-
-
-  bool mHasLinksToUpdate : 1;
-
-
-  bool mMayHaveDOMMutationObservers : 1;
-
-
-  bool mMayHaveAnimationObservers : 1;
-
-
-  bool mHasMixedActiveContentLoaded : 1;
-
-
-  bool mHasMixedActiveContentBlocked : 1;
-
-
-  bool mHasMixedDisplayContentLoaded : 1;
-
-
-  bool mHasMixedDisplayContentBlocked : 1;
-
-
-  bool mHasMixedContentObjectSubrequest : 1;
-
-
-  bool mHasCSP : 1;
-
-
-  bool mHasUnsafeEvalCSP : 1;
-
-
-  bool mHasUnsafeInlineCSP : 1;
-
-
-  bool mHasTrackingContentBlocked : 1;
-
-
-  bool mHasTrackingContentLoaded : 1;
-
-
-  bool mBFCacheDisallowed : 1;
-
-  bool mHasHadDefaultView : 1;
-
-
-  bool mStyleSheetChangeEventsEnabled : 1;
-
-
-  bool mIsSrcdocDocument : 1;
-
-
-
-
-  bool mDidDocumentOpen : 1;
-
-
-
-
-
-  bool mHasDisplayDocument : 1;
-
-
-  bool mFontFaceSetDirty : 1;
-
-
-  bool mGetUserFontSetCalled : 1;
-
-
-  bool mPostedFlushUserFontSet : 1;
-
-
-
-  bool mDidFireDOMContentLoaded : 1;
-
-
-  bool mHasScrollLinkedEffect : 1;
-
-
-
-
-  bool mFrameRequestCallbacksScheduled : 1;
-
-
-  nsCompatibility mCompatMode;
-
-
-  ReadyState mReadyState;
-
-
-
-  mozilla::StyleBackendType mStyleBackendType;
-
-
-
-  mozilla::dom::VisibilityState mVisibilityState;
-  static_assert(sizeof(mozilla::dom::VisibilityState) == sizeof(uint8_t),
-                "Error size of mVisibilityState and mDummy");
-
-
-
-
-  enum Type {
-    eUnknown,
-    eHTML,
-    eXHTML,
-    eGenericXML,
-    eSVG,
-    eXUL
-  };
-
-  Type mType;
-
-  uint8_t mDefaultElementType;
-
-  enum Tri {
-    eTriUnset = 0,
-    eTriFalse,
-    eTriTrue
-  };
-
-  Tri mAllowXULXBL;
-# 3257 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDocument.h"
-  nsCOMPtr<nsIScriptGlobalObject> mScriptGlobalObject;
-
-
-
-  nsCOMPtr<nsIDocument> mOriginalDocument;
-
-
-
-  uint32_t mBidiOptions;
-
-
-
-
-  uint32_t mSandboxFlags;
-
-  nsCString mContentLanguage;
-
-
-  nsCOMPtr<nsIChannel> mChannel;
-private:
-  nsCString mContentType;
-  nsString mId;
-protected:
-
-
-  nsCOMPtr<nsISupports> mSecurityInfo;
-
-
-
-  nsCOMPtr<nsIChannel> mFailedChannel;
-
-
-
-  uint32_t mPartID;
-
-
-
-  uint32_t mMarkedCCGeneration;
-
-  nsIPresShell* mPresShell;
-
-  nsCOMArray<nsINode> mSubtreeModifiedTargets;
-  uint32_t mSubtreeModifiedDepth;
-
-
-
-
-  nsCOMPtr<nsIDocument> mDisplayDocument;
-
-  uint32_t mEventsSuppressed;
-
-
-
-
-
-  uint32_t mExternalScriptsBeingEvaluated;
-
-
-
-
-  int32_t mFrameRequestCallbackCounter;
-
-
-  uint32_t mStaticCloneCount;
-
-
-
-
-
-
-  nsTArray<nsWeakPtr> mBlockedTrackingNodes;
-
-
-
-  nsPIDOMWindowInner* mWindow;
-
-  nsCOMPtr<nsIDocumentEncoder> mCachedEncoder;
-
-  struct FrameRequest;
-
-  nsTArray<FrameRequest> mFrameRequestCallbacks;
-
-
-
-  nsIBFCacheEntry *mBFCacheEntry;
-
-
-  nsString mBaseTarget;
-
-  nsCOMPtr<nsIStructuredCloneContainer> mStateObjectContainer;
-  nsCOMPtr<nsIVariant> mStateObjectCached;
-
-  uint32_t mInSyncOperationCount;
-
-  RefPtr<mozilla::dom::XPathEvaluator> mXPathEvaluator;
-
-  nsTArray<RefPtr<mozilla::dom::AnonymousContent>> mAnonymousContents;
-
-  uint32_t mBlockDOMContentLoaded;
-
-
-  PRCList mDOMMediaQueryLists;
-
-
-  std::bitset<mozilla::eUseCounter_Count> mUseCounters;
-
-  std::bitset<mozilla::eUseCounter_Count> mChildDocumentUseCounters;
-
-
-  std::bitset<mozilla::eUseCounter_Count> mNotifiedPageForUseCounter;
-
-
-  bool mUserHasInteracted;
-
-  mozilla::TimeStamp mPageUnloadingEventTimeStamp;
-
-  RefPtr<mozilla::dom::DocGroup> mDocGroup;
-
-
-
-
-  nsTHashtable<nsCStringHashKey> mTrackingScripts;
-};
-
-template<typename T> struct nsIDocument::COMTypeInfo<nsIDocument, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDocument::COMTypeInfo<nsIDocument, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xce1f7627, 0x7109, 0x4977, { 0xba, 0x77, 0x49, 0x0f, 0xfd, 0xe0, 0x7a, 0xaa } };
-
-
-
-
-
-
-class mozAutoSubtreeModified
-{
-public:
-
-
-
-
-
-
-  mozAutoSubtreeModified(nsIDocument* aSubtreeOwner, nsINode* aTarget)
-  {
-    UpdateTarget(aSubtreeOwner, aTarget);
-  }
-
-  ~mozAutoSubtreeModified()
-  {
-    UpdateTarget(nullptr, nullptr);
-  }
-
-  void UpdateTarget(nsIDocument* aSubtreeOwner, nsINode* aTarget)
-  {
-    if (mSubtreeOwner) {
-      mSubtreeOwner->MutationEventDispatched(mTarget);
-    }
-
-    mTarget = aTarget;
-    mSubtreeOwner = aSubtreeOwner;
-    if (mSubtreeOwner) {
-      mSubtreeOwner->WillDispatchMutationEvent(mTarget);
-    }
-  }
-
-private:
-  nsCOMPtr<nsINode> mTarget;
-  nsCOMPtr<nsIDocument> mSubtreeOwner;
-};
-
-class nsAutoSyncOperation
-{
-public:
-  explicit nsAutoSyncOperation(nsIDocument* aDocument);
-  ~nsAutoSyncOperation();
-private:
-  nsCOMArray<nsIDocument> mDocuments;
-  uint32_t mMicroTaskLevel;
-};
-
-
-nsresult
-NS_NewHTMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false);
-
-nsresult
-NS_NewXMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData = false,
-                  bool aIsPlainDocument = false);
-
-nsresult
-NS_NewSVGDocument(nsIDocument** aInstancePtrResult);
-
-nsresult
-NS_NewImageDocument(nsIDocument** aInstancePtrResult);
-
-nsresult
-NS_NewVideoDocument(nsIDocument** aInstancePtrResult);
-
-
-
-
-nsresult
-NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
-                  const nsAString& aNamespaceURI,
-                  const nsAString& aQualifiedName,
-                  nsIDOMDocumentType* aDoctype,
-                  nsIURI* aDocumentURI,
-                  nsIURI* aBaseURI,
-                  nsIPrincipal* aPrincipal,
-                  bool aLoadedAsData,
-                  nsIGlobalObject* aEventObject,
-                  DocumentFlavor aFlavor);
-
-
-
-nsresult
-NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult,
-                  nsIURI* aDocumentURI,
-                  nsIURI* aBaseURI,
-                  nsIPrincipal* aPrincipal);
-
-nsresult
-NS_NewPluginDocument(nsIDocument** aInstancePtrResult);
-
-inline nsIDocument*
-nsINode::GetOwnerDocument() const
-{
-  nsIDocument* ownerDoc = OwnerDoc();
-
-  return ownerDoc != this ? ownerDoc : nullptr;
-}
-
-inline nsINode*
-nsINode::OwnerDocAsNode() const
-{
-  return OwnerDoc();
-}
-
-inline mozilla::dom::ParentObject
-nsINode::GetParentObject() const
-{
-  mozilla::dom::ParentObject p(OwnerDoc());
-
-
-  p.mUseXBLScope = IsInAnonymousSubtree() && !IsAnonymousContentInSVGUseSubtree();
-  return p;
-}
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 1
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-namespace mozilla {
-class TimeStamp;
-
-namespace dom {
-class Promise;
-}
-
-}
-
-class nsIProfilerStartParams;
-
-enum TracingKind {
-  TRACING_EVENT,
-  TRACING_INTERVAL_START,
-  TRACING_INTERVAL_END,
-};
-
-class ProfilerBacktrace;
-
-struct ProfilerBacktraceDestructor
-{
-  void operator()(ProfilerBacktrace*);
-};
-using UniqueProfilerBacktrace =
-  mozilla::UniquePtr<ProfilerBacktrace, ProfilerBacktraceDestructor>;
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-void profiler_tracing(const char* aCategory, const char* aInfo, TracingKind aKind = TRACING_EVENT);
-
-void profiler_tracing(const char* aCategory, const char* aInfo, UniqueProfilerBacktrace aCause, TracingKind aKind = TRACING_EVENT);
-
-
-
-
-
-
-void profiler_init(void* stackTop);
-
-
-
-
-void profiler_shutdown();
-
-
-
-
-
-
-
-void profiler_start(int aEntries, double aInterval, const char** aFeatures, uint32_t aFeatureCount, const char** aThreadNameFilters, uint32_t aFilterCount);
-
-
-
-
-
-
-
-void profiler_stop();
-
-
-
-
-
-
-
-void profiler_pause();
-void profiler_resume();
-
-
-bool profiler_is_paused();
-
-
-
-UniqueProfilerBacktrace profiler_get_backtrace();
-
-void profiler_get_backtrace_noalloc(char *output, size_t outputSize);
-# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-bool profiler_is_active();
-
-
-
-
-
-bool profiler_feature_active(const char*);
-
-
-
-void profiler_set_frame_number(int frameNumber);
-
-
-
-mozilla::UniquePtr<char[]> profiler_get_profile(double aSinceTime = 0);
-
-
-
-
-JSObject* profiler_get_profile_jsobject(JSContext* aCx, double aSinceTime = 0);
-
-
-
-
-
-void profiler_get_profile_jsobject_async(double aSinceTime = 0, mozilla::dom::Promise* = 0);
-
-
-
-
-void profiler_get_start_params(int* aEntrySize, double* aInterval, mozilla::Vector<const char*>* aFeatures, mozilla::Vector<const char*>* aFilters);
-# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-extern "C" {
-void profiler_save_profile_to_file(const char* aFilename);
-}
-
-
-
-
-const char** profiler_get_features();
-
-
-
-
-void profiler_get_buffer_info_helper(uint32_t* aCurrentPosition, uint32_t* aEntries, uint32_t* aGeneration);
-# 265 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-static inline void profiler_get_buffer_info(uint32_t* aCurrentPosition,
-                                            uint32_t* aEntries,
-                                            uint32_t* aGeneration)
-{
-  *aCurrentPosition = 0;
-  *aEntries = 0;
-  *aGeneration = 0;
-
-  profiler_get_buffer_info_helper(aCurrentPosition, aEntries, aGeneration);
-}
-
-
-
-void profiler_register_thread(const char* name, void* guessStackTop);
-
-void profiler_unregister_thread();
-
-
-
-
-
-void profiler_thread_sleep();
-void profiler_thread_wake();
-bool profiler_thread_is_sleeping();
-
-
-
-
-void profiler_js_interrupt_callback();
-
-
-
-double profiler_time();
-
-void profiler_log(const char *str);
-
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 306 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h"
-struct JSRuntime;
-class JSTracer;
-
-namespace js {
-
-
-
-
-
-
-class ProfileEntry
-{
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/js/ProfilingStack.h"
-    const char * volatile string;
-
-
-    const char * volatile dynamicString;
-
-
-    void * volatile spOrScript;
-
-
-    int32_t volatile lineOrPcOffset;
-
-
-    uint32_t volatile flags_;
-
-  public:
-
-    enum Flags : uint32_t {
-
-
-
-
-        IS_CPP_ENTRY = 0x01,
-
-
-
-        FRAME_LABEL_COPY = 0x02,
-
-
-
-        BEGIN_PSEUDO_JS = 0x04,
-
-
-
-        OSR = 0x08,
-
-
-        ALL = IS_CPP_ENTRY|FRAME_LABEL_COPY|BEGIN_PSEUDO_JS|OSR,
-
-
-        CATEGORY_MASK = ~ALL
-    };
-
-
-    enum class Category : uint32_t {
-        OTHER = 0x10,
-        CSS = 0x20,
-        JS = 0x40,
-        GC = 0x80,
-        CC = 0x100,
-        NETWORK = 0x200,
-        GRAPHICS = 0x400,
-        STORAGE = 0x800,
-        EVENTS = 0x1000,
-
-        FIRST = OTHER,
-        LAST = EVENTS
-    };
-
-    static_assert((static_cast<int>(Category::FIRST) & Flags::ALL) == 0,
-                  "The category bitflags should not intersect with the other flags!");
-
-
-
-
-
-
-    bool isCpp() const volatile { return hasFlag(IS_CPP_ENTRY); }
-    bool isJs() const volatile { return !isCpp(); }
-
-    bool isCopyLabel() const volatile { return hasFlag(FRAME_LABEL_COPY); }
-
-    void setLabel(const char* aString) volatile { string = aString; }
-    const char* label() const volatile { return string; }
-
-    void setDynamicString(const char* aDynamicString) volatile { dynamicString = aDynamicString; }
-    const char* getDynamicString() const volatile { return dynamicString; }
-
-    void initJsFrame(JSScript* aScript, jsbytecode* aPc) volatile {
-        flags_ = 0;
-        spOrScript = aScript;
-        setPC(aPc);
-    }
-    void initCppFrame(void* aSp, uint32_t aLine) volatile {
-        flags_ = IS_CPP_ENTRY;
-        spOrScript = aSp;
-        lineOrPcOffset = static_cast<int32_t>(aLine);
-    }
-
-    void setFlag(uint32_t flag) volatile {
-        do { } while (0);
-        flags_ |= flag;
-    }
-    void unsetFlag(uint32_t flag) volatile {
-        do { } while (0);
-        flags_ &= ~flag;
-    }
-    bool hasFlag(uint32_t flag) const volatile {
-        return bool(flags_ & flag);
-    }
-
-    uint32_t flags() const volatile {
-        return flags_;
-    }
-
-    uint32_t category() const volatile {
-        return flags_ & CATEGORY_MASK;
-    }
-    void setCategory(Category c) volatile {
-        do { } while (0);
-        do { } while (0);
-        flags_ &= ~CATEGORY_MASK;
-        setFlag(static_cast<uint32_t>(c));
-    }
-
-    void setOSR() volatile {
-        do { } while (0);
-        setFlag(OSR);
-    }
-    void unsetOSR() volatile {
-        do { } while (0);
-        unsetFlag(OSR);
-    }
-    bool isOSR() const volatile {
-        return hasFlag(OSR);
-    }
-
-    void* stackAddress() const volatile {
-        do { } while (0);
-        return spOrScript;
-    }
-    JSScript* script() const volatile;
-    uint32_t line() const volatile {
-        do { } while (0);
-        return static_cast<uint32_t>(lineOrPcOffset);
-    }
-
-
-    JSScript* rawScript() const volatile {
-        do { } while (0);
-        return (JSScript*)spOrScript;
-    }
-
-
-    jsbytecode* pc() const volatile;
-    void setPC(jsbytecode* pc) volatile;
-
-    void trace(JSTracer* trc);
-
-
-
-
-    static const int32_t NullPCOffset = -1;
-
-    static size_t offsetOfLabel() { return __builtin_offsetof(ProfileEntry, string); }
-    static size_t offsetOfSpOrScript() { return __builtin_offsetof(ProfileEntry, spOrScript); }
-    static size_t offsetOfLineOrPcOffset() { return __builtin_offsetof(ProfileEntry, lineOrPcOffset); }
-    static size_t offsetOfFlags() { return __builtin_offsetof(ProfileEntry, flags_); }
-};
-
-void
-SetContextProfilingStack(JSContext* cx, ProfileEntry* stack, uint32_t* size,
-                         uint32_t max);
-
-void
-EnableContextProfilingStack(JSContext* cx, bool enabled);
-
-void
-RegisterContextProfilingEventMarker(JSContext* cx, void (*fn)(const char*));
-
-jsbytecode*
-ProfilingGetPC(JSContext* cx, JSScript* script, void* ip);
-
-}
-# 308 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Sprintf.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Sprintf.h"
-template <size_t N>
-int VsprintfLiteral(char (&buffer)[N], const char* format, va_list args)
-{
-    do { } while (0);
-    int result = vsnprintf(buffer, N, format, args);
-    buffer[N - 1] = '\0';
-    return result;
-}
-
-template <size_t N>
-__attribute__ ((format (printf, 2, 3)))
-int SprintfLiteral(char (&buffer)[N], const char* format, ...)
-{
-  va_list args;
-  __builtin_va_start(args, format);
-  int result = VsprintfLiteral(buffer, format, args);
-  __builtin_va_end(args);
-  return result;
-}
-# 309 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h" 1
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-namespace mozilla {
-
-
-
-
-
-
-
-typedef sig_atomic_t sig_safe_t;
-
-
-namespace detail {
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-template<typename T>
-class ThreadLocal
-{
-# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-  bool initialized() const {
-
-    return true;
-
-
-
-  }
-
-public:
-# 134 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-  __attribute__ ((warn_unused_result)) inline bool init();
-
-  inline T get() const;
-
-  inline void set(const T aValue);
-
-private:
-
-  T mValue;
-
-
-
-
-};
-
-template<typename T>
-inline bool
-ThreadLocal<T>::init()
-{
-  static_assert(mozilla::IsPointer<T>::value || mozilla::IsIntegral<T>::value,
-                "mozilla::ThreadLocal must be used with a pointer or "
-                "integral type");
-  static_assert(sizeof(T) <= sizeof(void*),
-                "mozilla::ThreadLocal can't be used for types larger than "
-                "a pointer");
-
-
-  return true;
-# 173 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-}
-
-template<typename T>
-inline T
-ThreadLocal<T>::get() const
-{
-
-  return mValue;
-# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-}
-
-template<typename T>
-inline void
-ThreadLocal<T>::set(const T aValue)
-{
-
-  mValue = aValue;
-# 211 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ThreadLocal.h"
-}
-
-
-
-
-
-
-
-}
-}
-# 310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 2
-
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/stdlib.h" 1 3
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h" 2
-# 52 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-class ProfilerMarkerPayload;
-template<typename T>
-class ProfilerLinkedList;
-class SpliceableJSONWriter;
-class UniqueStacks;
-
-class ProfilerMarker
-{
-  friend class ProfilerLinkedList<ProfilerMarker>;
-
-public:
-  explicit ProfilerMarker(const char* aMarkerName,
-                          ProfilerMarkerPayload* aPayload = nullptr,
-                          double aTime = 0);
-  ~ProfilerMarker();
-
-  const char* GetMarkerName() const { return mMarkerName; }
-
-  void StreamJSON(SpliceableJSONWriter& aWriter,
-                  const mozilla::TimeStamp& aStartTime,
-                  UniqueStacks& aUniqueStacks) const;
-
-  void SetGeneration(uint32_t aGenID);
-
-  bool HasExpired(uint32_t aGenID) const { return mGenID + 2 <= aGenID; }
-
-  double GetTime() const;
-
-private:
-  char* mMarkerName;
-  ProfilerMarkerPayload* mPayload;
-  ProfilerMarker* mNext;
-  double mTime;
-  uint32_t mGenID;
-};
-
-template<typename T>
-class ProfilerLinkedList
-{
-public:
-  ProfilerLinkedList()
-    : mHead(nullptr)
-    , mTail(nullptr)
-  {}
-
-  void insert(T* aElem)
-  {
-    if (!mTail) {
-      mHead = aElem;
-      mTail = aElem;
-    } else {
-      mTail->mNext = aElem;
-      mTail = aElem;
-    }
-    aElem->mNext = nullptr;
-  }
-
-  T* popHead()
-  {
-    if (!mHead) {
-      do { } while (0);
-      return nullptr;
-    }
-
-    T* head = mHead;
-
-    mHead = head->mNext;
-    if (!mHead) {
-      mTail = nullptr;
-    }
-
-    return head;
-  }
-
-  const T* peek() {
-    return mHead;
-  }
-
-private:
-  T* mHead;
-  T* mTail;
-};
-
-typedef ProfilerLinkedList<ProfilerMarker> ProfilerMarkerLinkedList;
-
-template<typename T>
-class ProfilerSignalSafeLinkedList {
-public:
-  ProfilerSignalSafeLinkedList()
-    : mSignalLock(false)
-  {}
-
-  ~ProfilerSignalSafeLinkedList()
-  {
-    if (mSignalLock) {
-
-
-      abort();
-    }
-
-    while (mList.peek()) {
-      delete mList.popHead();
-    }
-  }
-
-
-
-
-
-
-  void insert(T* aElement)
-  {
-    do { } while (0);
-
-    mSignalLock = true;
-    asm volatile("" ::: "memory");;
-
-    mList.insert(aElement);
-
-    asm volatile("" ::: "memory");;
-    mSignalLock = false;
-  }
-
-
-
-
-
-  ProfilerLinkedList<T>* accessList()
-  {
-    return mSignalLock ? nullptr : &mList;
-  }
-
-private:
-  ProfilerLinkedList<T> mList;
-
-
-
-  volatile bool mSignalLock;
-};
-
-
-void ProfilerJSEventMarker(const char* aEvent);
-
-
-
-
-
-
-struct PseudoStack
-{
-public:
-  PseudoStack()
-    : mStackPointer(0)
-    , mSleep(AWAKE)
-    , mContext(nullptr)
-    , mJSSampling(INACTIVE)
-  {
-                               ;
-  }
-
-  ~PseudoStack()
-  {
-                               ;
-
-
-
-
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mStackPointer == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mStackPointer == 0))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mStackPointer == 0" ")"); do { *((volatile int*) __null) = 219; ::abort(); } while (0); } } while (0);
-  }
-
-
-
-  void reinitializeOnResume()
-  {
-
-
-
-
-    (void)mSleep.compareExchange(SLEEPING_OBSERVED, SLEEPING_NOT_OBSERVED);
-  }
-
-  void addMarker(const char* aMarkerStr, ProfilerMarkerPayload* aPayload,
-                 double aTime)
-  {
-    ProfilerMarker* marker = new ProfilerMarker(aMarkerStr, aPayload, aTime);
-    mPendingMarkers.insert(marker);
-  }
-
-
-  ProfilerMarkerLinkedList* getPendingMarkers()
-  {
-
-
-
-    return mPendingMarkers.accessList();
-  }
-
-  void push(const char* aName, js::ProfileEntry::Category aCategory,
-            uint32_t line)
-  {
-    push(aName, aCategory, nullptr, false, line, nullptr);
-  }
-
-  void push(const char* aName, js::ProfileEntry::Category aCategory,
-            void* aStackAddress, bool aCopy, uint32_t line,
-            const char* aDynamicString)
-  {
-    if (size_t(mStackPointer) >= mozilla::ArrayLength(mStack)) {
-      mStackPointer++;
-      return;
-    }
-
-    volatile js::ProfileEntry& entry = mStack[mStackPointer];
-
-
-
-    entry.initCppFrame(aStackAddress, line);
-    entry.setLabel(aName);
-    entry.setDynamicString(aDynamicString);
-    do { } while (0);
-    entry.setCategory(aCategory);
-
-
-    if (aCopy) {
-      entry.setFlag(js::ProfileEntry::FRAME_LABEL_COPY);
-    } else {
-      entry.unsetFlag(js::ProfileEntry::FRAME_LABEL_COPY);
-    }
-
-
-    asm volatile("" ::: "memory");;
-    mStackPointer++;
-  }
-
-
-  void pop() { mStackPointer--; }
-
-  uint32_t stackSize() const
-  {
-    return std::min(mStackPointer,
-                    mozilla::sig_safe_t(mozilla::ArrayLength(mStack)));
-  }
-
-
-
-  void setJSContext(JSContext* aContext)
-  {
-
-
-    do { } while (0);
-
-    mContext = aContext;
-
-    js::SetContextProfilingStack(aContext,
-                                 (js::ProfileEntry*) mStack,
-                                 (uint32_t*) &mStackPointer,
-                                 (uint32_t) mozilla::ArrayLength(mStack));
-    pollJSSampling();
-  }
-
-
-
-
-  void startJSSampling()
-  {
-
-
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mJSSampling == INACTIVE || mJSSampling == INACTIVE_REQUESTED" ")"); do { *((volatile int*) __null) = 320; ::abort(); } while (0); } } while (0);
-
-    mJSSampling = ACTIVE_REQUESTED;
-  }
-
-
-
-  void stopJSSampling()
-  {
-
-
-    do { static_assert(mozilla::detail::AssertionConditionType<decltype(mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "mJSSampling == ACTIVE || mJSSampling == ACTIVE_REQUESTED" ")"); do { *((volatile int*) __null) = 331; ::abort(); } while (0); } } while (0);
-
-    mJSSampling = INACTIVE_REQUESTED;
-  }
-
-
-  void pollJSSampling()
-  {
-
-
-
-    if (mContext) {
-# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-      if (mJSSampling.compareExchange(ACTIVE_REQUESTED, ACTIVE)) {
-        js::EnableContextProfilingStack(mContext, true);
-        js::RegisterContextProfilingEventMarker(mContext,
-                                                &ProfilerJSEventMarker);
-
-      } else if (mJSSampling.compareExchange(INACTIVE_REQUESTED, INACTIVE)) {
-        js::EnableContextProfilingStack(mContext, false);
-      }
-    }
-  }
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-  {
-    size_t n = aMallocSizeOf(this);
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-    return n;
-  }
-
-
-  bool CanDuplicateLastSampleDueToSleep()
-  {
-    if (mSleep == AWAKE) {
-      return false;
-    }
-
-    if (mSleep.compareExchange(SLEEPING_NOT_OBSERVED, SLEEPING_OBSERVED)) {
-      return false;
-    }
-
-    return true;
-  }
-
-
-
-  void setSleeping()
-  {
-    do { } while (0);
-    mSleep = SLEEPING_NOT_OBSERVED;
-  }
-
-
-
-  void setAwake()
-  {
-    do { } while (0);
-    mSleep = AWAKE;
-  }
-
-  bool isSleeping() { return mSleep != AWAKE; }
-
-private:
-
-  PseudoStack(const PseudoStack&) = delete;
-  void operator=(const PseudoStack&) = delete;
-
-  void flushSamplerOnJSShutdown();
-
-public:
-
-  js::ProfileEntry volatile mStack[1024];
-
-private:
-
-  ProfilerSignalSafeLinkedList<ProfilerMarker> mPendingMarkers;
-
-
-
-  mozilla::sig_safe_t mStackPointer;
-# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-  static const int AWAKE = 0;
-  static const int SLEEPING_NOT_OBSERVED = 1;
-  static const int SLEEPING_OBSERVED = 2;
-  mozilla::Atomic<int> mSleep;
-
-public:
-
-
-  JSContext* mContext;
-
-private:
-# 514 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/PseudoStack.h"
-  static const int INACTIVE = 0;
-  static const int ACTIVE_REQUESTED = 1;
-  static const int ACTIVE = 2;
-  static const int INACTIVE_REQUESTED = 3;
-  mozilla::Atomic<int> mJSSampling;
-};
-# 312 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class mozIDOMWindowProxy;
-
-class nsIRunnable;
-
-class nsISimpleEnumerator;
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class nsIMemoryReporterCallback : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Callback(const nsACString & process, const nsACString & path, int32_t kind, int32_t units, int64_t amount, const nsACString & description, nsISupports *data) = 0;
-
-};
-
-  template<typename T> struct nsIMemoryReporterCallback::COMTypeInfo<nsIMemoryReporterCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporterCallback::COMTypeInfo<nsIMemoryReporterCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x62ef0e1c, 0xdbd6, 0x11e3, { 0xaa, 0x75, 0x3c, 0x97, 0x0e, 0x9f, 0x42, 0x38 }};
-# 113 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class nsIMemoryReporter : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult CollectReports(nsIMemoryReporterCallback *callback, nsISupports *data, bool anonymize) = 0;
-
-  enum {
-    KIND_NONHEAP = 0,
-    KIND_HEAP = 1,
-    KIND_OTHER = 2,
-    UNITS_BYTES = 0,
-    UNITS_COUNT = 1,
-    UNITS_COUNT_CUMULATIVE = 2,
-    UNITS_PERCENTAGE = 3
-  };
-
-};
-
-  template<typename T> struct nsIMemoryReporter::COMTypeInfo<nsIMemoryReporter, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporter::COMTypeInfo<nsIMemoryReporter, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x92a36db1, 0x46bd, 0x4fe6, { 0x98, 0x8e, 0x47, 0xdb, 0x47, 0x23, 0x6d, 0x8b }};
-# 201 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class nsIFinishReportingCallback : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Callback(nsISupports *data) = 0;
-
-};
-
-  template<typename T> struct nsIFinishReportingCallback::COMTypeInfo<nsIFinishReportingCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFinishReportingCallback::COMTypeInfo<nsIFinishReportingCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x548b3909, 0xc04d, 0x4ca6, { 0x84, 0x66, 0xb8, 0xbe, 0xe3, 0x83, 0x74, 0x57 }};
-# 279 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class nsIMemoryReporterManager : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult Init(void) = 0;
-
-
-  virtual nsresult RegisterStrongReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult RegisterStrongAsyncReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult RegisterWeakReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult RegisterWeakAsyncReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult UnregisterStrongReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult UnregisterWeakReporter(nsIMemoryReporter *reporter) = 0;
-
-
-  virtual nsresult BlockRegistrationAndHideExistingReporters(void) = 0;
-
-
-  virtual nsresult UnblockRegistrationAndRestoreOriginalReporters(void) = 0;
-
-
-  virtual nsresult RegisterStrongReporterEvenIfBlocked(nsIMemoryReporter *aReporter) = 0;
-
-
-  virtual nsresult GetReports(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData, bool anonymize) = 0;
-
-
-  virtual nsresult GetReportsExtended(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData, bool anonymize, bool minimizeMemoryUsage, const nsAString & DMDDumpIdent) = 0;
-
-
-  virtual nsresult GetReportsForThisProcessExtended(nsIMemoryReporterCallback *handleReport, nsISupports *handleReportData, bool anonymize, FILE *DMDFile, nsIFinishReportingCallback *finishReporting, nsISupports *finishReportingData) = 0;
-
-
-  virtual nsresult EndReport(void) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetVsize(int64_t *aVsize) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetVsizeMaxContiguous(int64_t *aVsizeMaxContiguous) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResident(int64_t *aResident) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentFast(int64_t *aResidentFast) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentPeak(int64_t *aResidentPeak) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetResidentUnique(int64_t *aResidentUnique) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetHeapAllocated(int64_t *aHeapAllocated) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetHeapOverheadFraction(int64_t *aHeapOverheadFraction) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeGCHeap(int64_t *aJSMainRuntimeGCHeap) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeTemporaryPeak(int64_t *aJSMainRuntimeTemporaryPeak) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeCompartmentsSystem(int64_t *aJSMainRuntimeCompartmentsSystem) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetJSMainRuntimeCompartmentsUser(int64_t *aJSMainRuntimeCompartmentsUser) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetImagesContentUsedUncompressed(int64_t *aImagesContentUsedUncompressed) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetStorageSQLite(int64_t *aStorageSQLite) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetLowMemoryEventsVirtual(int64_t *aLowMemoryEventsVirtual) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetLowMemoryEventsPhysical(int64_t *aLowMemoryEventsPhysical) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetGhostWindows(int64_t *aGhostWindows) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetPageFaultsHard(int64_t *aPageFaultsHard) = 0;
-
-
-  virtual nsresult GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize) = 0;
-  inline bool GetHasMozMallocUsableSize()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetHasMozMallocUsableSize(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsDMDEnabled(bool *aIsDMDEnabled) = 0;
-  inline bool GetIsDMDEnabled()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsDMDEnabled(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  virtual nsresult GetIsDMDRunning(bool *aIsDMDRunning) = 0;
-  inline bool GetIsDMDRunning()
-  {
-    bool result;
-    mozilla::DebugOnly<nsresult> rv = GetIsDMDRunning(&result);
-    do { } while (0);
-    return result;
-  }
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult MinimizeMemoryUsage(nsIRunnable *callback) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SizeOfTab(mozIDOMWindowProxy *window, int64_t *jsObjectsSize, int64_t *jsStringsSize, int64_t *jsOtherSize, int64_t *domSize, int64_t *styleSize, int64_t *otherSize, int64_t *totalSize, double *jsMilliseconds, double *nonJSMilliseconds) = 0;
-
-};
-
-  template<typename T> struct nsIMemoryReporterManager::COMTypeInfo<nsIMemoryReporterManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMemoryReporterManager::COMTypeInfo<nsIMemoryReporterManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2998574d, 0x8993, 0x407a, { 0xb1, 0xa5, 0x8a, 0xd7, 0x41, 0x76, 0x53, 0xe1 }};
-# 851 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMemoryReporter.h"
-class nsPIDOMWindowOuter;
-
-
-typedef nsIMemoryReporterCallback nsIHandleReportCallback;
-namespace mozilla {
-
-
-
-
-extern "C" nsresult RegisterStrongMemoryReporter(nsIMemoryReporter* aReporter);
-extern "C" nsresult RegisterStrongAsyncMemoryReporter(nsIMemoryReporter* aReporter);
-
-
-extern "C" nsresult RegisterWeakMemoryReporter(nsIMemoryReporter* aReporter);
-extern "C" nsresult RegisterWeakAsyncMemoryReporter(nsIMemoryReporter* aReporter);
-
-extern "C" nsresult UnregisterStrongMemoryReporter(nsIMemoryReporter* aReporter);
-
-extern "C" nsresult UnregisterWeakMemoryReporter(nsIMemoryReporter* aReporter);
-
-
-
-
-
-typedef int64_t (*InfallibleAmountFn)();
-
-
-
-
-nsresult RegisterJSMainRuntimeGCHeapDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterJSMainRuntimeTemporaryPeakDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterJSMainRuntimeCompartmentsSystemDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterJSMainRuntimeCompartmentsUserDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterImagesContentUsedUncompressedDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult UnregisterImagesContentUsedUncompressedDistinguishedAmount();
-nsresult RegisterStorageSQLiteDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult UnregisterStorageSQLiteDistinguishedAmount();
-nsresult RegisterLowMemoryEventsVirtualDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterLowMemoryEventsPhysicalDistinguishedAmount(InfallibleAmountFn aAmountFn);
-nsresult RegisterGhostWindowsDistinguishedAmount(InfallibleAmountFn aAmountFn);
-
-
-
-typedef __attribute__ ((warn_unused_result)) nsresult (*JSSizeOfTabFn)(JSObject* aObj,
-                                               size_t* aJsObjectsSize,
-                                               size_t* aJsStringSize,
-                                               size_t* aJsPrivateSize,
-                                               size_t* aJsOtherSize);
-typedef __attribute__ ((warn_unused_result)) nsresult (*NonJSSizeOfTabFn)(nsPIDOMWindowOuter* aWindow,
-                                                  size_t* aDomSize,
-                                                  size_t* aStyleSize,
-                                                  size_t* aOtherSize);
-nsresult RegisterJSSizeOfTab(JSSizeOfTabFn aSizeOfTabFn);
-nsresult RegisterNonJSSizeOfTab(NonJSSizeOfTabFn aSizeOfTabFn);
-}
-# 313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h" 2
-
-
-
-
-
-
-class nsISupports;
-class ProfilerMarkerPayload;
-# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-extern __thread mozilla::detail::ThreadLocal<PseudoStack*> tlsPseudoStack;
-
-class ProfilerState;
-
-
-
-
-
-extern ProfilerState* gPS;
-# 353 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-static inline void*
-profiler_call_enter(const char* aInfo,
-                    js::ProfileEntry::Category aCategory,
-                    void *aFrameAddress, bool aCopy, uint32_t line,
-                    const char* aDynamicString = nullptr)
-{
-
-
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 361; ::abort(); } while (0); } } while (0);
-
-  PseudoStack* stack = tlsPseudoStack.get();
-  if (!stack) {
-    return stack;
-  }
-  stack->push(aInfo, aCategory, aFrameAddress, aCopy, line, aDynamicString);
-
-
-
-  return stack;
-}
-
-static inline void
-profiler_call_exit(void* aHandle)
-{
-
-
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 379; ::abort(); } while (0); } } while (0);
-
-  if (!aHandle) {
-    return;
-  }
-
-  PseudoStack *stack = (PseudoStack*)aHandle;
-  stack->pop();
-}
-
-
-
-void profiler_add_marker(const char *aMarker,
-                         ProfilerMarkerPayload *aPayload = nullptr);
-
-
-
-__attribute__((visibility("default")))
-void profiler_save_profile_to_file_async(double aSinceTime,
-                                         const char* aFileName);
-
-
-
-void profiler_will_gather_OOP_profile();
-void profiler_gathered_OOP_profile();
-void profiler_OOP_exit_profile(const nsCString& aProfile);
-# 470 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/GeckoProfiler.h"
-namespace mozilla {
-
-class SamplerStackFrameRAII {
-public:
-
-
-  SamplerStackFrameRAII(const char *aInfo,
-    js::ProfileEntry::Category aCategory, uint32_t line
-                                   )
-  {
-    do { } while (0);
-    mHandle = profiler_call_enter(aInfo, aCategory, this, false, line);
-  }
-  ~SamplerStackFrameRAII() {
-    profiler_call_exit(mHandle);
-  }
-private:
-
-  void* mHandle;
-};
-
-class SamplerStackFrameDynamicRAII {
-public:
-  SamplerStackFrameDynamicRAII(const char* aInfo,
-    js::ProfileEntry::Category aCategory, uint32_t aLine,
-    const char* aDynamicString)
-  {
-    mHandle = profiler_call_enter(aInfo, aCategory, this, true, aLine,
-                                  aDynamicString);
-  }
-
-  ~SamplerStackFrameDynamicRAII() {
-    profiler_call_exit(mHandle);
-  }
-
-private:
-  void* mHandle;
-};
-
-}
-
-inline PseudoStack*
-profiler_get_pseudo_stack(void)
-{
-
-
-  do { static_assert(mozilla::detail::AssertionConditionType<decltype(gPS)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(gPS))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "gPS" ")"); do { *((volatile int*) __null) = 516; ::abort(); } while (0); } } while (0);
-
-  return tlsPseudoStack.get();
-}
-
-void profiler_set_js_context(JSContext* aCx);
-void profiler_clear_js_context();
-
-class GeckoProfilerReporter final : public nsIMemoryReporter
-{
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  GeckoProfilerReporter() {}
-
-  virtual nsresult
-  CollectReports(nsIHandleReportCallback* aHandleReport,
-                 nsISupports* aData, bool aAnonymize) override;
-
-private:
-  ~GeckoProfilerReporter() {}
-};
-
-
-
-namespace mozilla {
-
-class GeckoProfilerInitRAII {
-public:
-  explicit GeckoProfilerInitRAII(void* stackTop) {
-    profiler_init(stackTop);
-  }
-  ~GeckoProfilerInitRAII() {
-    profiler_shutdown();
-  }
-};
-
-class GeckoProfilerThreadSleepRAII {
-public:
-  GeckoProfilerThreadSleepRAII() {
-    profiler_thread_sleep();
-  }
-  ~GeckoProfilerThreadSleepRAII() {
-    profiler_thread_wake();
-  }
-};
-
-
-
-class GeckoProfilerThreadWakeRAII {
-public:
-  GeckoProfilerThreadWakeRAII()
-    : mIssuedWake(profiler_thread_is_sleeping())
-  {
-    if (mIssuedWake) {
-      profiler_thread_wake();
-    }
-  }
-  ~GeckoProfilerThreadWakeRAII() {
-    if (mIssuedWake) {
-      do { } while (0);
-      profiler_thread_sleep();
-    }
-  }
-private:
-  bool mIssuedWake;
-};
-
-class GeckoProfilerTracingRAII {
-public:
-  GeckoProfilerTracingRAII(const char* aCategory, const char* aInfo,
-                           UniqueProfilerBacktrace aBacktrace
-                                                          )
-    : mCategory(aCategory)
-    , mInfo(aInfo)
-  {
-    do { } while (0);
-    profiler_tracing(mCategory, mInfo, Move(aBacktrace), TRACING_INTERVAL_START);
-  }
-
-  GeckoProfilerTracingRAII(const char* aCategory, const char* aInfo
-                                                          )
-    : mCategory(aCategory)
-    , mInfo(aInfo)
-  {
-    do { } while (0);
-    profiler_tracing(mCategory, mInfo, TRACING_INTERVAL_START);
-  }
-
-  ~GeckoProfilerTracingRAII() {
-    profiler_tracing(mCategory, mInfo, TRACING_INTERVAL_END);
-  }
-
-protected:
-
-  const char* mCategory;
-  const char* mInfo;
-};
-
-
-
-class AutoProfilerRegister final
-{
-public:
-  explicit AutoProfilerRegister(const char* aName)
-  {
-    profiler_register_thread(aName, this);
-  }
-  ~AutoProfilerRegister()
-  {
-    profiler_unregister_thread();
-  }
-private:
-  AutoProfilerRegister(const AutoProfilerRegister&) = delete;
-  AutoProfilerRegister& operator=(const AutoProfilerRegister&) = delete;
-};
-
-}
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h" 2
-
-
-
-
-
-class nsIScriptContext;
-class nsIScriptGlobalObject;
-
-namespace mozilla {
-namespace dom {
-class AutoJSAPI;
-class Element;
-}
-}
-
-class nsJSUtils
-{
-public:
-  static bool GetCallingLocation(JSContext* aContext, nsACString& aFilename,
-                                 uint32_t* aLineno = nullptr,
-                                 uint32_t* aColumn = nullptr);
-  static bool GetCallingLocation(JSContext* aContext, nsAString& aFilename,
-                                 uint32_t* aLineno = nullptr,
-                                 uint32_t* aColumn = nullptr);
-
-  static nsIScriptGlobalObject *GetStaticScriptGlobal(JSObject* aObj);
-
-  static nsIScriptContext *GetStaticScriptContext(JSObject* aObj);
-# 57 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
-  static uint64_t GetCurrentlyRunningCodeInnerWindowID(JSContext *aContext);
-
-  static nsresult CompileFunction(mozilla::dom::AutoJSAPI& jsapi,
-                                  JS::AutoObjectVector& aScopeChain,
-                                  JS::CompileOptions& aOptions,
-                                  const nsACString& aName,
-                                  uint32_t aArgCount,
-                                  const char** aArgArray,
-                                  const nsAString& aBody,
-                                  JSObject** aFunctionObject);
-
-
-
-  class ExecutionContext {
-
-
-    mozilla::SamplerStackFrameRAII mSamplerRAII;
-
-
-    JSContext* mCx;
-
-
-    JSAutoCompartment mCompartment;
-
-
-    JS::Rooted<JS::Value> mRetValue;
-
-
-    JS::AutoObjectVector mScopeChain;
-
-
-
-    nsresult mRv;
-
-
-
-    bool mSkip;
-
-
-    bool mCoerceToString;
-# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
-   public:
-
-
-
-
-    ExecutionContext(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
-
-    ExecutionContext(const ExecutionContext&) = delete;
-    ExecutionContext(ExecutionContext&&) = delete;
-
-    ~ExecutionContext() {
-
-      do { } while (0);
-    }
-
-
-
-    ExecutionContext& SetCoerceToString(bool aCoerceToString) {
-      mCoerceToString = aCoerceToString;
-      return *this;
-    }
-
-
-    void SetScopeChain(const JS::AutoObjectVector& aScopeChain);
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsJSUtils.h"
-    __attribute__ ((warn_unused_result)) nsresult
-    ExtractReturnValue(JS::MutableHandle<JS::Value> aRetValue);
-
-
-
-
-
-
-    __attribute__ ((warn_unused_result)) nsresult SyncAndExec(void **aOffThreadToken,
-                                      JS::MutableHandle<JSScript*> aScript);
-
-
-    nsresult CompileAndExec(JS::CompileOptions& aCompileOptions,
-                            JS::SourceBufferHolder& aSrcBuf);
-
-
-    nsresult CompileAndExec(JS::CompileOptions& aCompileOptions,
-                            const nsAString& aScript);
-  };
-
-  static nsresult CompileModule(JSContext* aCx,
-                                JS::SourceBufferHolder& aSrcBuf,
-                                JS::Handle<JSObject*> aEvaluationGlobal,
-                                JS::CompileOptions &aCompileOptions,
-                                JS::MutableHandle<JSObject*> aModule);
-
-  static nsresult ModuleDeclarationInstantiation(JSContext* aCx,
-                                                 JS::Handle<JSObject*> aModule);
-
-  static nsresult ModuleEvaluation(JSContext* aCx,
-                                   JS::Handle<JSObject*> aModule);
-
-
-
-  static bool GetScopeChainForElement(JSContext* aCx,
-                                      mozilla::dom::Element* aElement,
-                                      JS::AutoObjectVector& aScopeChain);
-
-  static void ResetTimeZone();
-};
-
-template<typename T>
-inline bool
-AssignJSString(JSContext *cx, T &dest, JSString *s)
-{
-  size_t len = js::GetStringLength(s);
-  static_assert(js::MaxStringLength < (1 << 28),
-                "Shouldn't overflow here or in SetCapacity");
-  if ((__builtin_expect(!!(!dest.SetLength(len, mozilla::fallible)), 0))) {
-    JS_ReportOutOfMemory(cx);
-    return false;
-  }
-  return js::CopyStringChars(cx, dest.BeginWriting(), s, len);
-}
-
-inline void
-AssignJSFlatString(nsAString &dest, JSFlatString *s)
-{
-  size_t len = js::GetFlatStringLength(s);
-  static_assert(js::MaxStringLength < (1 << 28),
-                "Shouldn't overflow here or in SetCapacity");
-  dest.SetLength(len);
-  js::CopyFlatStringChars(dest.BeginWriting(), s, len);
-}
-
-class nsAutoJSString : public nsAutoString
-{
-public:
-
-
-
-
-
-  nsAutoJSString() {}
-
-  bool init(JSContext* aContext, JSString* str)
-  {
-    return AssignJSString(aContext, *this, str);
-  }
-
-  bool init(JSContext* aContext, const JS::Value &v)
-  {
-    if (v.isString()) {
-      return init(aContext, v.toString());
-    }
-
-
-    JS::Rooted<JSString*> str(aContext);
-    if (v.isObject()) {
-      str = JS_NewStringCopyZ(aContext, "[Object]");
-    } else {
-      JS::Rooted<JS::Value> rootedVal(aContext, v);
-      str = JS::ToString(aContext, rootedVal);
-    }
-
-    return str && init(aContext, str);
-  }
-
-  bool init(JSContext* aContext, jsid id)
-  {
-    JS::Rooted<JS::Value> v(aContext);
-    return JS_IdToValue(aContext, id, &v) && init(aContext, v);
-  }
-
-  bool init(const JS::Value &v);
-
-  ~nsAutoJSString() {}
-};
-# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h"
-class nsIXPCScriptable;
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIClassInfo.h"
-class nsIClassInfo : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetInterfaces(uint32_t *count, nsIID ***array) = 0;
-
-
-  virtual nsresult GetScriptableHelper(nsIXPCScriptable * *_retval) = 0;
-
-
-  virtual nsresult GetContractID(char * *aContractID) = 0;
-
-
-  virtual nsresult GetClassDescription(char * *aClassDescription) = 0;
-
-
-  virtual nsresult GetClassID(nsCID **aClassID) = 0;
-
-  enum {
-    SINGLETON = 1U,
-    THREADSAFE = 2U,
-    MAIN_THREAD_ONLY = 4U,
-    DOM_OBJECT = 8U,
-    PLUGIN_OBJECT = 16U,
-    SINGLETON_CLASSINFO = 32U,
-    CONTENT_NODE = 64U,
-    RESERVED = 2147483648U
-  };
-
-
-  virtual nsresult GetFlags(uint32_t *aFlags) = 0;
-
-
-  virtual nsresult GetClassIDNoAlloc(nsCID *aClassIDNoAlloc) = 0;
-
-};
-
-  template<typename T> struct nsIClassInfo::COMTypeInfo<nsIClassInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIClassInfo::COMTypeInfo<nsIClassInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xa60569d7, 0xd401, 0x4677, { 0xba, 0x63, 0x2a, 0xa5, 0x97, 0x1a, 0xf2, 0x5d }};
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h" 1
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
-struct JSFreeOp;
-namespace js {
-struct Class;
-}
-class nsIXPConnectWrappedNative;
-# 63 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
-class nsIXPCScriptable : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetClassName(char * *aClassName) = 0;
-
-
-  virtual uint32_t GetScriptableFlags(void) = 0;
-
-
-  virtual const js::Class * GetClass(void) = 0;
-
-
-  virtual const JSClass * GetJSClass(void) = 0;
-
-
-  virtual nsresult PreCreate(nsISupports *nativeObj, JSContext *cx, JSObject *globalObj, JSObject **parentObj) = 0;
-
-
-  virtual nsresult GetProperty(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, JS::Value *vp, bool *_retval) = 0;
-
-
-  virtual nsresult SetProperty(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, JS::Value *vp, bool *_retval) = 0;
-
-
-  virtual nsresult Enumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, bool *_retval) = 0;
-
-
-  virtual nsresult NewEnumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, JS::AutoIdVector & properties, bool *_retval) = 0;
-
-
-  virtual nsresult Resolve(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, jsid id, bool *resolvedp, bool *_retval) = 0;
-
-
-  virtual nsresult Finalize(nsIXPConnectWrappedNative *wrapper, JSFreeOp *fop, JSObject *obj) = 0;
-
-
-  virtual nsresult Call(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, const JS::CallArgs & args, bool *_retval) = 0;
-
-
-  virtual nsresult Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, const JS::CallArgs & args, bool *_retval) = 0;
-
-
-  virtual nsresult HasInstance(nsIXPConnectWrappedNative *wrapper, JSContext *cx, JSObject *obj, JS::HandleValue val, bool *bp, bool *_retval) = 0;
-
-
-  virtual nsresult PostCreatePrototype(JSContext *cx, JSObject *proto) = 0;
-
-
-
-
-
-    bool WantPreCreate() { return 0 != (GetScriptableFlags() & (1 << 0)); }
-    bool WantGetProperty() { return 0 != (GetScriptableFlags() & (1 << 1)); }
-    bool WantSetProperty() { return 0 != (GetScriptableFlags() & (1 << 2)); }
-    bool WantEnumerate() { return 0 != (GetScriptableFlags() & (1 << 3)); }
-    bool WantNewEnumerate() { return 0 != (GetScriptableFlags() & (1 << 4)); }
-    bool WantResolve() { return 0 != (GetScriptableFlags() & (1 << 5)); }
-    bool WantFinalize() { return 0 != (GetScriptableFlags() & (1 << 6)); }
-    bool WantCall() { return 0 != (GetScriptableFlags() & (1 << 7)); }
-    bool WantConstruct() { return 0 != (GetScriptableFlags() & (1 << 8)); }
-    bool WantHasInstance() { return 0 != (GetScriptableFlags() & (1 << 9)); }
-    bool UseJSStubForAddProperty() { return 0 != (GetScriptableFlags() & (1 << 10)); }
-    bool UseJSStubForDelProperty() { return 0 != (GetScriptableFlags() & (1 << 11)); }
-    bool UseJSStubForSetProperty() { return 0 != (GetScriptableFlags() & (1 << 12)); }
-    bool DontEnumQueryInterface() { return 0 != (GetScriptableFlags() & (1 << 13)); }
-    bool DontAskInstanceForScriptable() { return 0 != (GetScriptableFlags() & (1 << 14)); }
-    bool ClassInfoInterfacesOnly() { return 0 != (GetScriptableFlags() & (1 << 15)); }
-    bool AllowPropModsDuringResolve() { return 0 != (GetScriptableFlags() & (1 << 16)); }
-    bool AllowPropModsToPrototype() { return 0 != (GetScriptableFlags() & (1 << 17)); }
-    bool IsGlobalObject() { return 0 != (GetScriptableFlags() & (1 << 18)); }
-    bool DontReflectInterfaceNames() { return 0 != (GetScriptableFlags() & (1 << 19)); }
-
-};
-
-  template<typename T> struct nsIXPCScriptable::COMTypeInfo<nsIXPCScriptable, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIXPCScriptable::COMTypeInfo<nsIXPCScriptable, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x19b70b26, 0x7c3f, 0x437f, { 0xa0, 0x4a, 0x2a, 0x8f, 0x9e, 0x28, 0xb6, 0x17 }};
-# 345 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIXPCScriptable.h"
-class nsXPCClassInfo : public nsIClassInfo,
-                                    public nsIXPCScriptable
-{
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-  virtual MozExternalRefCountType AddRef() override = 0;
-  virtual MozExternalRefCountType Release() override = 0;
-  virtual void PreserveWrapper(nsISupports *aNative) = 0;
-};
-template<typename T> struct nsXPCClassInfo::COMTypeInfo<nsXPCClassInfo, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsXPCClassInfo::COMTypeInfo<nsXPCClassInfo, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x43b67f01, 0xd4ce, 0x4b82, { 0xb3, 0xf8, 0xeb, 0xf2, 0x13, 0x60, 0xfb, 0x7e } };
-inline
-nsresult
-CallQueryInterface(nsISupports* aSourcePtr,
-                   RefPtrGetterAddRefs<nsXPCClassInfo> aDestPtr)
-{
-  return CallQueryInterface(aSourcePtr,
-                            static_cast<nsXPCClassInfo**>(aDestPtr));
-}
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xpcObjectHelper.h" 2
-
-
-class xpcObjectHelper
-{
-public:
-    explicit xpcObjectHelper(nsISupports* aObject, nsWrapperCache* aCache = nullptr)
-      : mCanonical(nullptr)
-      , mObject(aObject)
-      , mCache(aCache)
-    {
-        if (!mCache) {
-            if (aObject)
-                CallQueryInterface(aObject, &mCache);
-            else
-                mCache = nullptr;
-        }
-    }
-
-    nsISupports* Object()
-    {
-        return mObject;
-    }
-
-    nsISupports* GetCanonical()
-    {
-        if (!mCanonical) {
-            mCanonicalStrong = do_QueryInterface(mObject);
-            mCanonical = mCanonicalStrong;
-        }
-        return mCanonical;
-    }
-
-    already_AddRefed<nsISupports> forgetCanonical()
-    {
-        do { } while (0);
-
-        if (!mCanonicalStrong)
-            mCanonicalStrong = mCanonical;
-        mCanonical = nullptr;
-        return mCanonicalStrong.forget();
-    }
-
-    nsIClassInfo* GetClassInfo()
-    {
-        if (mXPCClassInfo)
-          return mXPCClassInfo;
-        if (!mClassInfo)
-            mClassInfo = do_QueryInterface(mObject);
-        return mClassInfo;
-    }
-    nsXPCClassInfo* GetXPCClassInfo()
-    {
-        if (!mXPCClassInfo) {
-            CallQueryInterface(mObject, getter_AddRefs(mXPCClassInfo));
-        }
-        return mXPCClassInfo;
-    }
-
-    already_AddRefed<nsXPCClassInfo> forgetXPCClassInfo()
-    {
-        GetXPCClassInfo();
-
-        return mXPCClassInfo.forget();
-    }
-
-
-    uint32_t GetScriptableFlags()
-    {
-
-        nsCOMPtr<nsIXPCScriptable> sinfo = GetXPCClassInfo();
-
-
-        if (!sinfo)
-            sinfo = do_QueryInterface(GetCanonical());
-
-
-        do { } while (0);
-
-
-        return sinfo->GetScriptableFlags();
-    }
-
-    nsWrapperCache* GetWrapperCache()
-    {
-        return mCache;
-    }
-
-protected:
-    xpcObjectHelper(nsISupports* aObject, nsISupports* aCanonical,
-                    nsWrapperCache* aCache)
-      : mCanonical(aCanonical)
-      , mObject(aObject)
-      , mCache(aCache)
-    {
-        if (!mCache && aObject)
-            CallQueryInterface(aObject, &mCache);
-    }
-
-    nsCOMPtr<nsISupports> mCanonicalStrong;
-    nsISupports* mCanonical;
-
-
-
-private:
-    xpcObjectHelper(xpcObjectHelper& aOther) = delete;
-
-    nsISupports* mObject;
-
-
-    nsWrapperCache* mCache;
-    nsCOMPtr<nsIClassInfo> mClassInfo;
-    RefPtr<nsXPCClassInfo> mXPCClassInfo;
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/qsObjectHelper.h" 2
-
-
-
-
-
-class qsObjectHelper : public xpcObjectHelper
-{
-public:
-    template <class T>
-    inline
-    qsObjectHelper(T* aObject, nsWrapperCache* aCache)
-        : xpcObjectHelper(ToSupports(aObject), ToCanonicalSupports(aObject),
-                          aCache)
-    {}
-
-    template <class T>
-    inline
-    qsObjectHelper(nsCOMPtr<T>& aObject, nsWrapperCache* aCache)
-        : xpcObjectHelper(ToSupports(aObject.get()),
-                          ToCanonicalSupports(aObject.get()), aCache)
-    {
-        if (mCanonical) {
-
-            mCanonicalStrong = dont_AddRef(mCanonical);
-            aObject.forget();
-        }
-    }
-
-    template <class T>
-    inline
-    qsObjectHelper(RefPtr<T>& aObject, nsWrapperCache* aCache)
-        : xpcObjectHelper(ToSupports(aObject.get()),
-                          ToCanonicalSupports(aObject.get()), aCache)
-    {
-        if (mCanonical) {
-
-            mCanonicalStrong = dont_AddRef(mCanonical);
-            aObject.forget();
-        }
-    }
-};
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCacheInlines.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsWrapperCacheInlines.h"
-inline JSObject*
-nsWrapperCache::GetWrapper() const
-{
-    JSObject* obj = GetWrapperPreserveColor();
-    if (obj) {
-      JS::ExposeObjectToActiveJS(obj);
-    }
-    return obj;
-}
-
-inline bool
-nsWrapperCache::HasKnownLiveWrapper() const
-{
-
-
-
-
-
-  JSObject* o = GetWrapperPreserveColor();
-  return o && !JS::ObjectIsMarkedGray(o);
-}
-
-static void
-SearchGray(JS::GCCellPtr aGCThing, const char* aName, void* aClosure)
-{
-  bool* hasGrayObjects = static_cast<bool*>(aClosure);
-  if (!*hasGrayObjects && aGCThing && JS::GCThingIsMarkedGray(aGCThing)) {
-    *hasGrayObjects = true;
-  }
-}
-
-inline bool
-nsWrapperCache::HasNothingToTrace(nsISupports* aThis)
-{
-  nsXPCOMCycleCollectionParticipant* participant = nullptr;
-  CallQueryInterface(aThis, &participant);
-  bool hasGrayObjects = false;
-  participant->Trace(aThis, TraceCallbackFunc(SearchGray), &hasGrayObjects);
-  return !hasGrayObjects;
-}
-
-inline bool
-nsWrapperCache::HasKnownLiveWrapperAndDoesNotNeedTracing(nsISupports* aThis)
-{
-  return HasKnownLiveWrapper() && HasNothingToTrace(aThis);
-}
-
-inline void
-nsWrapperCache::MarkWrapperLive()
-{
-
-
-  GetWrapper();
-}
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h" 2
-
-class nsGenericHTMLElement;
-class nsIJSID;
-
-namespace mozilla {
-
-enum UseCounter : int16_t;
-
-namespace dom {
-template<typename KeyType, typename ValueType> class Record;
-
-nsresult
-UnwrapArgImpl(JSContext* cx, JS::Handle<JSObject*> src, const nsIID& iid,
-              void** ppArg);
-
-nsresult
-UnwrapWindowProxyImpl(JSContext* cx, JS::Handle<JSObject*> src,
-                      nsPIDOMWindowOuter** ppArg);
-
-
-template <class Interface>
-inline nsresult
-UnwrapArg(JSContext* cx, JS::Handle<JSObject*> src, Interface** ppArg)
-{
-  return UnwrapArgImpl(cx, src, (Interface::template COMTypeInfo<Interface, void>::kIID),
-                       reinterpret_cast<void**>(ppArg));
-}
-
-template <>
-inline nsresult
-UnwrapArg<nsPIDOMWindowOuter>(JSContext* cx, JS::Handle<JSObject*> src,
-                              nsPIDOMWindowOuter** ppArg)
-{
-  return UnwrapWindowProxyImpl(cx, src, ppArg);
-}
-
-bool
-ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
-                 bool aSecurityError, const char* aInterfaceName);
-
-bool
-ThrowInvalidThis(JSContext* aCx, const JS::CallArgs& aArgs,
-                 bool aSecurityError, prototypes::ID aProtoId);
-
-
-inline bool
-IsDOMClass(const JSClass* clasp)
-{
-  return clasp->flags & (1<<4);
-}
-
-inline bool
-IsDOMClass(const js::Class* clasp)
-{
-  return IsDOMClass(Jsvalify(clasp));
-}
-
-
-inline bool
-IsNonProxyDOMClass(const js::Class* clasp)
-{
-  return IsDOMClass(clasp) && !clasp->isProxy();
-}
-
-inline bool
-IsNonProxyDOMClass(const JSClass* clasp)
-{
-  return IsNonProxyDOMClass(js::Valueify(clasp));
-}
-
-
-
-inline bool
-IsDOMIfaceAndProtoClass(const JSClass* clasp)
-{
-  return clasp->flags & (1<<((8 + 8)+6));
-}
-
-inline bool
-IsDOMIfaceAndProtoClass(const js::Class* clasp)
-{
-  return IsDOMIfaceAndProtoClass(Jsvalify(clasp));
-}
-
-static_assert(0 == 0,
-              "DOM_OBJECT_SLOT doesn't match the proxy private slot.  "
-              "Expect bad things");
-template <class T>
-inline T*
-UnwrapDOMObject(JSObject* obj)
-{
-  do { } while (0);
-
-
-  JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, 0);
-  return static_cast<T*>(val.toPrivate());
-}
-
-template <class T>
-inline T*
-UnwrapPossiblyNotInitializedDOMObject(JSObject* obj)
-{
-
-
-
-
-  do { } while (0);
-
-
-  JS::Value val = js::GetReservedOrProxyPrivateSlot(obj, 0);
-  if (val.isUndefined()) {
-    return nullptr;
-  }
-  return static_cast<T*>(val.toPrivate());
-}
-
-inline const DOMJSClass*
-GetDOMClass(const js::Class* clasp)
-{
-  return IsDOMClass(clasp) ? DOMJSClass::FromJSClass(clasp) : nullptr;
-}
-
-inline const DOMJSClass*
-GetDOMClass(JSObject* obj)
-{
-  return GetDOMClass(js::GetObjectClass(obj));
-}
-
-inline nsISupports*
-UnwrapDOMObjectToISupports(JSObject* aObject)
-{
-  const DOMJSClass* clasp = GetDOMClass(aObject);
-  if (!clasp || !clasp->mDOMObjectIsISupports) {
-    return nullptr;
-  }
-
-  return UnwrapPossiblyNotInitializedDOMObject<nsISupports>(aObject);
-}
-
-inline bool
-IsDOMObject(JSObject* obj)
-{
-  return IsDOMClass(js::GetObjectClass(obj));
-}
-# 196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template <class T, typename U>
-__attribute__((always_inline)) inline nsresult
-UnwrapObject(JSObject* obj, U& value, prototypes::ID protoID,
-             uint32_t protoDepth)
-{
-
-  const DOMJSClass* domClass = GetDOMClass(obj);
-  if (!domClass) {
-
-    if (!js::IsWrapper(obj)) {
-
-      return NS_ERROR_XPC_BAD_CONVERT_JS;
-    }
-
-    obj = js::CheckedUnwrap(obj, false);
-    if (!obj) {
-      return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
-    }
-    do { } while (0);
-    domClass = GetDOMClass(obj);
-    if (!domClass) {
-
-      return NS_ERROR_XPC_BAD_CONVERT_JS;
-    }
-  }
-
-
-
-
-  if (domClass->mInterfaceChain[protoDepth] == protoID) {
-    value = UnwrapDOMObject<T>(obj);
-    return NS_OK;
-  }
-
-
-  return NS_ERROR_XPC_BAD_CONVERT_JS;
-}
-
-template <prototypes::ID PrototypeID, class T, typename U>
-__attribute__((always_inline)) inline nsresult
-UnwrapObject(JSObject* obj, U& value)
-{
-  return UnwrapObject<T>(obj, value, PrototypeID,
-                         PrototypeTraits<PrototypeID>::Depth);
-}
-
-__attribute__((always_inline)) inline bool
-IsConvertibleToDictionary(JS::Handle<JS::Value> val)
-{
-  return val.isNullOrUndefined() || val.isObject();
-}
-
-
-
-
-
-
-static_assert((size_t)constructors::id::_ID_Start ==
-              (size_t)prototypes::id::_ID_Count &&
-              (size_t)namedpropertiesobjects::id::_ID_Start ==
-              (size_t)constructors::id::_ID_Count,
-              "Overlapping or discontiguous indexes.");
-const size_t kProtoAndIfaceCacheCount = namedpropertiesobjects::id::_ID_Count;
-
-class ProtoAndIfaceCache
-{
-
-
-
-
-
-
-  class ArrayCache : public Array<JS::Heap<JSObject*>, kProtoAndIfaceCacheCount>
-  {
-  public:
-    JSObject* EntrySlotIfExists(size_t i) {
-      return (*this)[i];
-    }
-
-    JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
-      return (*this)[i];
-    }
-
-    JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
-      return (*this)[i];
-    }
-
-    void Trace(JSTracer* aTracer) {
-      for (size_t i = 0; i < ArrayLength(*this); ++i) {
-        JS::TraceEdge(aTracer, &(*this)[i], "protoAndIfaceCache[i]");
-      }
-    }
-
-    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
-      return aMallocSizeOf(this);
-    }
-  };
-
-  class PageTableCache
-  {
-  public:
-    PageTableCache() {
-      memset(&mPages, 0, sizeof(mPages));
-    }
-
-    ~PageTableCache() {
-      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
-        delete mPages[i];
-      }
-    }
-
-    JSObject* EntrySlotIfExists(size_t i) {
-      do { } while (0);
-      size_t pageIndex = i / kPageSize;
-      size_t leafIndex = i % kPageSize;
-      Page* p = mPages[pageIndex];
-      if (!p) {
-        return nullptr;
-      }
-      return (*p)[leafIndex];
-    }
-
-    JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
-      do { } while (0);
-      size_t pageIndex = i / kPageSize;
-      size_t leafIndex = i % kPageSize;
-      Page* p = mPages[pageIndex];
-      if (!p) {
-        p = new Page;
-        mPages[pageIndex] = p;
-      }
-      return (*p)[leafIndex];
-    }
-
-    JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
-      do { } while (0);
-      size_t pageIndex = i / kPageSize;
-      size_t leafIndex = i % kPageSize;
-      Page* p = mPages[pageIndex];
-      do { } while (0);
-      return (*p)[leafIndex];
-    }
-
-    void Trace(JSTracer* trc) {
-      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
-        Page* p = mPages[i];
-        if (p) {
-          for (size_t j = 0; j < ArrayLength(*p); ++j) {
-            JS::TraceEdge(trc, &(*p)[j], "protoAndIfaceCache[i]");
-          }
-        }
-      }
-    }
-
-    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
-      size_t n = aMallocSizeOf(this);
-      for (size_t i = 0; i < ArrayLength(mPages); ++i) {
-        n += aMallocSizeOf(mPages[i]);
-      }
-      return n;
-    }
-
-  private:
-    static const size_t kPageSize = 16;
-    typedef Array<JS::Heap<JSObject*>, kPageSize> Page;
-    static const size_t kNPages = kProtoAndIfaceCacheCount / kPageSize +
-      size_t(bool(kProtoAndIfaceCacheCount % kPageSize));
-    Array<Page*, kNPages> mPages;
-  };
-
-public:
-  enum Kind {
-    WindowLike,
-    NonWindowLike
-  };
-
-  explicit ProtoAndIfaceCache(Kind aKind) : mKind(aKind) {
-                                      ;
-    if (aKind == WindowLike) {
-      mArrayCache = new ArrayCache();
-    } else {
-      mPageTableCache = new PageTableCache();
-    }
-  }
-
-  ~ProtoAndIfaceCache() {
-    if (mKind == WindowLike) {
-      delete mArrayCache;
-    } else {
-      delete mPageTableCache;
-    }
-                                      ;
-  }
-# 401 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-  JSObject* EntrySlotIfExists(size_t i) {
-    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotIfExists (i); } else { return mPageTableCache->EntrySlotIfExists (i); } } while(0);
-  }
-
-
-
-  JS::Heap<JSObject*>& EntrySlotOrCreate(size_t i) {
-    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotOrCreate (i); } else { return mPageTableCache->EntrySlotOrCreate (i); } } while(0);
-  }
-
-
-
-
-  JS::Heap<JSObject*>& EntrySlotMustExist(size_t i) {
-    do { if (mKind == WindowLike) { return mArrayCache->EntrySlotMustExist (i); } else { return mPageTableCache->EntrySlotMustExist (i); } } while(0);
-  }
-
-  void Trace(JSTracer *aTracer) {
-    do { if (mKind == WindowLike) { return mArrayCache->Trace (aTracer); } else { return mPageTableCache->Trace (aTracer); } } while(0);
-  }
-
-  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
-    size_t n = aMallocSizeOf(this);
-    n += (mKind == WindowLike
-          ? mArrayCache->SizeOfIncludingThis(aMallocSizeOf)
-          : mPageTableCache->SizeOfIncludingThis(aMallocSizeOf));
-    return n;
-  }
-
-
-private:
-  union {
-    ArrayCache *mArrayCache;
-    PageTableCache *mPageTableCache;
-  };
-  Kind mKind;
-};
-
-inline void
-AllocateProtoAndIfaceCache(JSObject* obj, ProtoAndIfaceCache::Kind aKind)
-{
-  do { } while (0);
-  do { } while (0);
-
-  ProtoAndIfaceCache* protoAndIfaceCache = new ProtoAndIfaceCache(aKind);
-
-  js::SetReservedSlot(obj, (5 + JSProto_LIMIT * 2 + 46),
-                      JS::PrivateValue(protoAndIfaceCache));
-}
-# 469 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-inline void
-TraceProtoAndIfaceCache(JSTracer* trc, JSObject* obj)
-{
-  do { } while (0);
-# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-  if (!DOMGlobalHasProtoAndIFaceCache(obj))
-    return;
-  ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
-  protoAndIfaceCache->Trace(trc);
-}
-
-inline void
-DestroyProtoAndIfaceCache(JSObject* obj)
-{
-  do { } while (0);
-
-  if (!DOMGlobalHasProtoAndIFaceCache(obj)) {
-    return;
-  }
-
-  ProtoAndIfaceCache* protoAndIfaceCache = GetProtoAndIfaceCache(obj);
-
-  delete protoAndIfaceCache;
-}
-
-
-
-
-bool
-DefineConstants(JSContext* cx, JS::Handle<JSObject*> obj,
-                const ConstantSpec* cs);
-
-struct JSNativeHolder
-{
-  JSNative mNative;
-  const NativePropertyHooks* mPropertyHooks;
-};
-
-struct NamedConstructor
-{
-  const char* mName;
-  const JSNativeHolder mHolder;
-  unsigned mNargs;
-};
-# 575 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-void
-CreateInterfaceObjects(JSContext* cx, JS::Handle<JSObject*> global,
-                       JS::Handle<JSObject*> protoProto,
-                       const js::Class* protoClass, JS::Heap<JSObject*>* protoCache,
-                       JS::Handle<JSObject*> interfaceProto,
-                       const js::Class* constructorClass,
-                       unsigned ctorNargs, const NamedConstructor* namedConstructors,
-                       JS::Heap<JSObject*>* constructorCache,
-                       const NativeProperties* regularProperties,
-                       const NativeProperties* chromeOnlyProperties,
-                       const char* name, bool defineOnGlobal,
-                       const char* const* unscopableNames,
-                       bool isGlobal);
-# 602 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-DefineProperties(JSContext* cx, JS::Handle<JSObject*> obj,
-                 const NativeProperties* properties,
-                 const NativeProperties* chromeOnlyProperties);
-
-
-
-
-bool
-DefineUnforgeableMethods(JSContext* cx, JS::Handle<JSObject*> obj,
-                         const Prefable<const JSFunctionSpec>* props);
-
-
-
-
-bool
-DefineUnforgeableAttributes(JSContext* cx, JS::Handle<JSObject*> obj,
-                            const Prefable<const JSPropertySpec>* props);
-# 643 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template<class T>
-struct NativeHasMember
-{
-  private: typedef char yes[1]; typedef char no[2];
-
-  private: template<typename V> static yes& CheckGetParentObject(char (*)[sizeof(&V::GetParentObject) + 1]); template<typename V> static no& CheckGetParentObject(...); public: static bool const GetParentObject = sizeof(CheckGetParentObject<T>(nullptr)) == sizeof(yes);
-  private: template<typename V> static yes& CheckWrapObject(char (*)[sizeof(&V::WrapObject) + 1]); template<typename V> static no& CheckWrapObject(...); public: static bool const WrapObject = sizeof(CheckWrapObject<T>(nullptr)) == sizeof(yes);
-};
-
-template<class T>
-struct IsSmartPtr
-{
-  private: typedef char yes[1]; typedef char no[2];
-
-  private: template<typename V> static yes& Checkget(char (*)[sizeof(&V::get) + 1]); template<typename V> static no& Checkget(...); public: static bool const value = sizeof(Checkget<T>(nullptr)) == sizeof(yes);
-};
-
-template<class T>
-struct IsRefcounted
-{
-  private: typedef char yes[1]; typedef char no[2];
-
-  private: template<typename V> static yes& CheckAddRef(char (*)[sizeof(&V::AddRef) + 1]); template<typename V> static no& CheckAddRef(...); public: static bool const HasAddref = sizeof(CheckAddRef<T>(nullptr)) == sizeof(yes);
-  private: template<typename V> static yes& CheckRelease(char (*)[sizeof(&V::Release) + 1]); template<typename V> static no& CheckRelease(...); public: static bool const HasRelease = sizeof(CheckRelease<T>(nullptr)) == sizeof(yes);
-
-public:
-  static bool const value = HasAddref && HasRelease;
-
-private:
-
-
-
-  static_assert(!IsBaseOf<nsISupports, T>::value || IsRefcounted::value,
-                "Classes derived from nsISupports are refcounted!");
-
-};
-# 707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-__attribute__((always_inline)) inline bool
-CouldBeDOMBinding(void*)
-{
-  return true;
-}
-
-__attribute__((always_inline)) inline bool
-CouldBeDOMBinding(nsWrapperCache* aCache)
-{
-  return aCache->IsDOMBinding();
-}
-
-inline bool
-TryToOuterize(JS::MutableHandle<JS::Value> rval)
-{
-  if (js::IsWindow(&rval.toObject())) {
-    JSObject* obj = js::ToWindowProxyIfWindow(&rval.toObject());
-    do { } while (0);
-    rval.set(JS::ObjectValue(*obj));
-  }
-
-  return true;
-}
-
-
-
-__attribute__((always_inline)) inline
-bool
-MaybeWrapStringValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  JSString* str = rval.toString();
-  if (JS::GetStringZone(str) != js::GetContextZone(cx)) {
-    return JS_WrapValue(cx, rval);
-  }
-  return true;
-}
-
-
-
-__attribute__((always_inline)) inline
-bool
-MaybeWrapObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-
-
-  JSObject* obj = &rval.toObject();
-  if (js::GetObjectCompartment(obj) != js::GetContextCompartment(cx)) {
-    return JS_WrapValue(cx, rval);
-  }
-
-
-
-  if (IsDOMObject(obj)) {
-    return TryToOuterize(rval);
-  }
-
-
-
-  return true;
-}
-
-
-__attribute__((always_inline)) inline
-bool
-MaybeWrapObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  if (rval.isNull()) {
-    return true;
-  }
-  return MaybeWrapObjectValue(cx, rval);
-}
-
-
-__attribute__((always_inline)) inline
-bool
-MaybeWrapNonDOMObjectValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  do { } while (0);
-  do { } while (0);
-
-
-  JSObject* obj = &rval.toObject();
-  if (js::GetObjectCompartment(obj) == js::GetContextCompartment(cx)) {
-    return true;
-  }
-  return JS_WrapValue(cx, rval);
-}
-
-
-__attribute__((always_inline)) inline
-bool
-MaybeWrapNonDOMObjectOrNullValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  if (rval.isNull()) {
-    return true;
-  }
-  return MaybeWrapNonDOMObjectValue(cx, rval);
-}
-
-
-
-
-__attribute__((always_inline)) inline bool
-MaybeWrapValue(JSContext* cx, JS::MutableHandle<JS::Value> rval)
-{
-  if (rval.isGCThing()) {
-    if (rval.isString()) {
-      return MaybeWrapStringValue(cx, rval);
-    }
-    if (rval.isObject()) {
-      return MaybeWrapObjectValue(cx, rval);
-    }
-    do { } while (0);
-    JS_MarkCrossZoneId(cx, SYMBOL_TO_JSID(rval.toSymbol()));
-  }
-  return true;
-}
-
-namespace binding_detail {
-enum GetOrCreateReflectorWrapBehavior {
-  eWrapIntoContextCompartment,
-  eDontWrapIntoContextCompartment
-};
-
-template <class T>
-struct TypeNeedsOuterization
-{
-
-
-  static const bool value =
-    IsBaseOf<nsGlobalWindow, T>::value || IsSame<EventTarget, T>::value;
-};
-# 898 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template <class T, GetOrCreateReflectorWrapBehavior wrapBehavior>
-__attribute__((always_inline)) inline bool
-DoGetOrCreateDOMReflector(JSContext* cx, T* value,
-                          JS::Handle<JSObject*> givenProto,
-                          JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  do { } while (0);
-
-  bool couldBeDOMBinding = CouldBeDOMBinding(value);
-  JSObject* obj = value->GetWrapper();
-  if (obj) {
-
-
-
-
-
-
-  } else {
-
-    if (!couldBeDOMBinding) {
-      return false;
-    }
-
-    obj = value->WrapObject(cx, givenProto);
-    if (!obj) {
-
-
-
-      return false;
-    }
-
-
-
-
-
-
-  }
-# 953 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-  rval.set(JS::ObjectValue(*obj));
-
-  bool sameCompartment =
-    js::GetObjectCompartment(obj) == js::GetContextCompartment(cx);
-  if (sameCompartment && couldBeDOMBinding) {
-    return TypeNeedsOuterization<T>::value ? TryToOuterize(rval) : true;
-  }
-
-  if (wrapBehavior == eDontWrapIntoContextCompartment) {
-    if (TypeNeedsOuterization<T>::value) {
-      JSAutoCompartment ac(cx, obj);
-      return TryToOuterize(rval);
-    }
-
-    return true;
-  }
-
-  return JS_WrapValue(cx, rval);
-}
-
-}
-# 984 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template <class T>
-__attribute__((always_inline)) inline bool
-GetOrCreateDOMReflector(JSContext* cx, T* value,
-                        JS::MutableHandle<JS::Value> rval,
-                        JS::Handle<JSObject*> givenProto = nullptr)
-{
-  using namespace binding_detail;
-  return DoGetOrCreateDOMReflector<T, eWrapIntoContextCompartment>(cx, value,
-                                                                   givenProto,
-                                                                   rval);
-}
-
-
-
-template <class T>
-__attribute__((always_inline)) inline bool
-GetOrCreateDOMReflectorNoWrap(JSContext* cx, T* value,
-                              JS::MutableHandle<JS::Value> rval)
-{
-  using namespace binding_detail;
-  return DoGetOrCreateDOMReflector<T, eDontWrapIntoContextCompartment>(cx,
-                                                                       value,
-                                                                       nullptr,
-                                                                       rval);
-}
-
-
-
-
-template <class T>
-inline bool
-WrapNewBindingNonWrapperCachedObject(JSContext* cx,
-                                     JS::Handle<JSObject*> scopeArg,
-                                     T* value,
-                                     JS::MutableHandle<JS::Value> rval,
-                                     JS::Handle<JSObject*> givenProto = nullptr)
-{
-  static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
-  do { } while (0);
-
-  JS::Rooted<JSObject*> obj(cx);
-  {
-
-
-    Maybe<JSAutoCompartment> ac;
-
-
-
-    JS::Rooted<JSObject*> scope(cx, scopeArg);
-    JS::Rooted<JSObject*> proto(cx, givenProto);
-    if (js::IsWrapper(scope)) {
-      scope = js::CheckedUnwrap(scope, false);
-      if (!scope)
-        return false;
-      ac.emplace(cx, scope);
-      if (!JS_WrapObject(cx, &proto)) {
-        return false;
-      }
-    }
-
-    do { } while (0);
-    if (!value->WrapObject(cx, proto, &obj)) {
-      return false;
-    }
-  }
-
-
-
-  rval.set(JS::ObjectValue(*obj));
-  return MaybeWrapObjectValue(cx, rval);
-}
-
-
-
-
-
-template <class T>
-inline bool
-WrapNewBindingNonWrapperCachedObject(JSContext* cx,
-                                     JS::Handle<JSObject*> scopeArg,
-                                     nsAutoPtr<T>& value,
-                                     JS::MutableHandle<JS::Value> rval,
-                                     JS::Handle<JSObject*> givenProto = nullptr)
-{
-  static_assert(!IsRefcounted<T>::value, "Only pass owned classes in here.");
-
-
-  if (!value) {
-    do { AnnotateMozCrashReason("MOZ_CRASH(" "Don't try to wrap null objects" ")"); do { *((volatile int*) __null) = 1072; ::abort(); } while (0); } while (0);
-  }
-
-  JS::Rooted<JSObject*> obj(cx);
-  {
-
-
-    Maybe<JSAutoCompartment> ac;
-
-
-
-    JS::Rooted<JSObject*> scope(cx, scopeArg);
-    JS::Rooted<JSObject*> proto(cx, givenProto);
-    if (js::IsWrapper(scope)) {
-      scope = js::CheckedUnwrap(scope, false);
-      if (!scope)
-        return false;
-      ac.emplace(cx, scope);
-      if (!JS_WrapObject(cx, &proto)) {
-        return false;
-      }
-    }
-
-    do { } while (0);
-    if (!value->WrapObject(cx, proto, &obj)) {
-      return false;
-    }
-
-    value.forget();
-  }
-
-
-
-  rval.set(JS::ObjectValue(*obj));
-  return MaybeWrapObjectValue(cx, rval);
-}
-
-
-template <template <typename> class SmartPtr, typename T,
-          typename U=typename EnableIf<IsRefcounted<T>::value, T>::Type,
-          typename V=typename EnableIf<IsSmartPtr<SmartPtr<T>>::value, T>::Type>
-inline bool
-WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
-                                     const SmartPtr<T>& value,
-                                     JS::MutableHandle<JS::Value> rval,
-                                     JS::Handle<JSObject*> givenProto = nullptr)
-{
-  return WrapNewBindingNonWrapperCachedObject(cx, scope, value.get(), rval,
-                                              givenProto);
-}
-
-
-template <typename T,
-          typename U=typename EnableIf<!IsSmartPtr<T>::value, T>::Type>
-inline bool
-WrapNewBindingNonWrapperCachedObject(JSContext* cx, JS::Handle<JSObject*> scope,
-                                     T& value,
-                                     JS::MutableHandle<JS::Value> rval,
-                                     JS::Handle<JSObject*> givenProto = nullptr)
-{
-  return WrapNewBindingNonWrapperCachedObject(cx, scope, &value, rval,
-                                              givenProto);
-}
-
-
-
-bool
-NativeInterface2JSObjectAndThrowIfFailed(JSContext* aCx,
-                                         JS::Handle<JSObject*> aScope,
-                                         JS::MutableHandle<JS::Value> aRetval,
-                                         xpcObjectHelper& aHelper,
-                                         const nsIID* aIID,
-                                         bool aAllowNativeWrapper);
-
-
-
-
-
-template <class T>
-__attribute__((always_inline)) inline bool
-HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
-                                T* value, JS::MutableHandle<JS::Value> rval)
-{
-  if (JS_IsExceptionPending(cx)) {
-    return false;
-  }
-
-  qsObjectHelper helper(value, GetWrapperCache(value));
-  return NativeInterface2JSObjectAndThrowIfFailed(cx, scope, rval,
-                                                  helper, nullptr, true);
-}
-
-
-
-
-template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
-struct HandleNewBindingWrappingFailureHelper
-{
-  static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope,
-                          const T& value, JS::MutableHandle<JS::Value> rval)
-  {
-    return HandleNewBindingWrappingFailure(cx, scope, value.get(), rval);
-  }
-};
-
-template <class T>
-struct HandleNewBindingWrappingFailureHelper<T, false>
-{
-  static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
-                          JS::MutableHandle<JS::Value> rval)
-  {
-    return HandleNewBindingWrappingFailure(cx, scope, &value, rval);
-  }
-};
-
-template<class T>
-inline bool
-HandleNewBindingWrappingFailure(JSContext* cx, JS::Handle<JSObject*> scope,
-                                T& value, JS::MutableHandle<JS::Value> rval)
-{
-  return HandleNewBindingWrappingFailureHelper<T>::Wrap(cx, scope, value, rval);
-}
-
-template<bool Fatal>
-inline bool
-EnumValueNotFound(JSContext* cx, JS::HandleString str, const char* type,
-                  const char* sourceDescription);
-
-template<>
-inline bool
-EnumValueNotFound<false>(JSContext* cx, JS::HandleString str, const char* type,
-                         const char* sourceDescription)
-{
-
-  return true;
-}
-
-template<>
-inline bool
-EnumValueNotFound<true>(JSContext* cx, JS::HandleString str, const char* type,
-                        const char* sourceDescription)
-{
-  JSAutoByteString deflated;
-  if (!deflated.encodeUtf8(cx, str)) {
-    return false;
-  }
-  return ThrowErrorMessage(cx, MSG_INVALID_ENUM_VALUE, sourceDescription,
-                           deflated.ptr(), type);
-}
-
-template<typename CharT>
-inline int
-FindEnumStringIndexImpl(const CharT* chars, size_t length, const EnumEntry* values)
-{
-  int i = 0;
-  for (const EnumEntry* value = values; value->value; ++value, ++i) {
-    if (length != value->length) {
-      continue;
-    }
-
-    bool equal = true;
-    const char* val = value->value;
-    for (size_t j = 0; j != length; ++j) {
-      if (unsigned(val[j]) != unsigned(chars[j])) {
-        equal = false;
-        break;
-      }
-    }
-
-    if (equal) {
-      return i;
-    }
-  }
-
-  return -1;
-}
-
-template<bool InvalidValueFatal>
-inline bool
-FindEnumStringIndex(JSContext* cx, JS::Handle<JS::Value> v, const EnumEntry* values,
-                    const char* type, const char* sourceDescription, int* index)
-{
-
-  JS::RootedString str(cx, JS::ToString(cx, v));
-  if (!str) {
-    return false;
-  }
-
-  {
-    size_t length;
-    JS::AutoCheckCannotGC nogc;
-    if (js::StringHasLatin1Chars(str)) {
-      const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, str,
-                                                                     &length);
-      if (!chars) {
-        return false;
-      }
-      *index = FindEnumStringIndexImpl(chars, length, values);
-    } else {
-      const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, str,
-                                                                &length);
-      if (!chars) {
-        return false;
-      }
-      *index = FindEnumStringIndexImpl(chars, length, values);
-    }
-    if (*index >= 0) {
-      return true;
-    }
-  }
-
-  return EnumValueNotFound<InvalidValueFatal>(cx, str, type, sourceDescription);
-}
-
-inline nsWrapperCache*
-GetWrapperCache(const ParentObject& aParentObject)
-{
-  return aParentObject.mWrapperCache;
-}
-
-template<class T>
-inline T*
-GetParentPointer(T* aObject)
-{
-  return aObject;
-}
-
-inline nsISupports*
-GetParentPointer(const ParentObject& aObject)
-{
-  return aObject.mObject;
-}
-
-template <typename T>
-inline bool
-GetUseXBLScope(T* aParentObject)
-{
-  return false;
-}
-
-inline bool
-GetUseXBLScope(const ParentObject& aParentObject)
-{
-  return aParentObject.mUseXBLScope;
-}
-
-template<class T>
-inline void
-ClearWrapper(T* p, nsWrapperCache* cache)
-{
-  cache->ClearWrapper();
-}
-
-template<class T>
-inline void
-ClearWrapper(T* p, void*)
-{
-  nsWrapperCache* cache;
-  CallQueryInterface(p, &cache);
-  ClearWrapper(p, cache);
-}
-
-template<class T>
-inline void
-UpdateWrapper(T* p, nsWrapperCache* cache, JSObject* obj, const JSObject* old)
-{
-  JS::AutoAssertGCCallback inCallback(obj);
-  cache->UpdateWrapper(obj, old);
-}
-
-template<class T>
-inline void
-UpdateWrapper(T* p, void*, JSObject* obj, const JSObject* old)
-{
-  JS::AutoAssertGCCallback inCallback(obj);
-  nsWrapperCache* cache;
-  CallQueryInterface(p, &cache);
-  UpdateWrapper(p, cache, obj, old);
-}
-# 1360 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-TryPreserveWrapper(JSObject* obj);
-
-
-bool
-InstanceClassHasProtoAtDepth(const js::Class* clasp,
-                             uint32_t protoID, uint32_t depth);
-
-
-
-bool
-XPCOMObjectToJsval(JSContext* cx, JS::Handle<JSObject*> scope,
-                   xpcObjectHelper& helper, const nsIID* iid,
-                   bool allowNativeWrapper, JS::MutableHandle<JS::Value> rval);
-
-
-bool
-VariantToJsval(JSContext* aCx, nsIVariant* aVariant,
-               JS::MutableHandle<JS::Value> aRetval);
-
-
-
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, T* p, nsWrapperCache* cache, const nsIID* iid,
-           JS::MutableHandle<JS::Value> rval)
-{
-  if (xpc_FastGetCachedWrapper(cx, cache, rval))
-    return true;
-  qsObjectHelper helper(p, cache);
-  JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
-  return XPCOMObjectToJsval(cx, scope, helper, iid, true, rval);
-}
-
-
-
-template<>
-inline bool
-WrapObject<nsIVariant>(JSContext* cx, nsIVariant* p,
-                       nsWrapperCache* cache, const nsIID* iid,
-                       JS::MutableHandle<JS::Value> rval)
-{
-  do { } while (0);
-  do { } while (0);
-  return VariantToJsval(cx, p, rval);
-}
-
-
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, T* p, const nsIID* iid,
-           JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p, GetWrapperCache(p), iid, rval);
-}
-
-
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, T* p, JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p, nullptr, rval);
-}
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
-           const nsIID* iid, JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p.get(), iid, rval);
-}
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, const nsCOMPtr<T>& p,
-           JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p, nullptr, rval);
-}
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, const RefPtr<T>& p,
-           const nsIID* iid, JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p.get(), iid, rval);
-}
-
-
-template<class T>
-inline bool
-WrapObject(JSContext* cx, const RefPtr<T>& p,
-           JS::MutableHandle<JS::Value> rval)
-{
-  return WrapObject(cx, p, nullptr, rval);
-}
-
-
-template<>
-inline bool
-WrapObject<JSObject>(JSContext* cx, JSObject* p,
-                     JS::MutableHandle<JS::Value> rval)
-{
-  rval.set(JS::ObjectOrNullValue(p));
-  return true;
-}
-
-inline bool
-WrapObject(JSContext* cx, JSObject& p, JS::MutableHandle<JS::Value> rval)
-{
-  rval.set(JS::ObjectValue(p));
-  return true;
-}
-
-
-
-
-
-template<typename T>
-static inline JSObject*
-WrapNativeISupports(JSContext* cx, T* p, nsWrapperCache* cache)
-{
-  qsObjectHelper helper(ToSupports(p), cache);
-  JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
-  JS::Rooted<JS::Value> v(cx);
-  return XPCOMObjectToJsval(cx, scope, helper, nullptr, false, &v) ?
-         v.toObjectOrNull() :
-         nullptr;
-}
-
-
-
-template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
-struct WrapNativeFallback
-{
-  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
-  {
-    return nullptr;
-  }
-};
-
-
-
-template<typename T >
-struct WrapNativeFallback<T, true >
-{
-  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
-  {
-    return WrapNativeISupports(cx, parent, cache);
-  }
-};
-
-
-
-template<typename T, bool hasWrapObject=NativeHasMember<T>::WrapObject>
-struct WrapNativeHelper
-{
-  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
-  {
-    do { } while (0);
-
-    JSObject* obj;
-    if ((obj = cache->GetWrapper())) {
-
-      do { } while (0);
-      return obj;
-    }
-
-
-    if (!CouldBeDOMBinding(parent)) {
-
-      obj = WrapNativeFallback<T>::Wrap(cx, parent, cache);
-      do { } while (0);
-    } else {
-
-      obj = parent->WrapObject(cx, nullptr);
-      do { } while (0);
-    }
-
-    return obj;
-  }
-};
-
-
-
-template<typename T>
-struct WrapNativeHelper<T, false>
-{
-  static inline JSObject* Wrap(JSContext* cx, T* parent, nsWrapperCache* cache)
-  {
-    JSObject* obj;
-    if (cache && (obj = cache->GetWrapper())) {
-
-
-
-
-
-
-      do { } while (0);
-      return obj;
-    }
-
-    obj = WrapNativeISupports(cx, parent, cache);
-    do { } while (0);
-    return obj;
-  }
-};
-
-
-template<typename T>
-static inline JSObject*
-FindAssociatedGlobal(JSContext* cx, T* p, nsWrapperCache* cache,
-                     bool useXBLScope = false)
-{
-  if (!p) {
-    return JS::CurrentGlobalOrNull(cx);
-  }
-
-  JSObject* obj = WrapNativeHelper<T>::Wrap(cx, p, cache);
-  if (!obj) {
-    return nullptr;
-  }
-  do { } while (0);
-
-  obj = js::GetGlobalForObjectCrossCompartment(obj);
-
-  if (!useXBLScope) {
-    return obj;
-  }
-
-
-
-
-  if (xpc::IsInContentXBLScope(obj)) {
-    return obj;
-  }
-  JS::Rooted<JSObject*> rootedObj(cx, obj);
-  JSObject* xblScope = xpc::GetXBLScope(cx, rootedObj);
-  do { } while (0);
-  do { } while (0);
-  return xblScope;
-}
-
-
-
-template<typename T>
-static inline JSObject*
-FindAssociatedGlobal(JSContext* cx, const T& p)
-{
-  return FindAssociatedGlobal(cx, GetParentPointer(p), GetWrapperCache(p), GetUseXBLScope(p));
-}
-
-
-
-template<>
-inline JSObject*
-FindAssociatedGlobal(JSContext* cx, nsIGlobalObject* const& p)
-{
-  if (!p) {
-    return JS::CurrentGlobalOrNull(cx);
-  }
-
-  JSObject* global = p->GetGlobalJSObject();
-  if (!global) {
-    return nullptr;
-  }
-
-  do { } while (0);
-
-
-  JS::ExposeObjectToActiveJS(global);
-  return global;
-}
-
-template<typename T,
-         bool hasAssociatedGlobal=NativeHasMember<T>::GetParentObject>
-struct FindAssociatedGlobalForNative
-{
-  static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
-  {
-    do { } while (0);
-    T* native = UnwrapDOMObject<T>(obj);
-    return FindAssociatedGlobal(cx, native->GetParentObject());
-  }
-};
-
-template<typename T>
-struct FindAssociatedGlobalForNative<T, false>
-{
-  static JSObject* Get(JSContext* cx, JS::Handle<JSObject*> obj)
-  {
-    do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 1660; ::abort(); } while (0); } while (0);
-    return nullptr;
-  }
-};
-
-
-
-template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
-struct GetOrCreateDOMReflectorHelper
-{
-  static inline bool GetOrCreate(JSContext* cx, const T& value,
-                                 JS::Handle<JSObject*> givenProto,
-                                 JS::MutableHandle<JS::Value> rval)
-  {
-    return GetOrCreateDOMReflector(cx, value.get(), rval, givenProto);
-  }
-};
-
-template <class T>
-struct GetOrCreateDOMReflectorHelper<T, false>
-{
-  static inline bool GetOrCreate(JSContext* cx, T& value,
-                                 JS::Handle<JSObject*> givenProto,
-                                 JS::MutableHandle<JS::Value> rval)
-  {
-    static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
-    return GetOrCreateDOMReflector(cx, &value, rval, givenProto);
-  }
-};
-
-template<class T>
-inline bool
-GetOrCreateDOMReflector(JSContext* cx, T& value,
-                        JS::MutableHandle<JS::Value> rval,
-                        JS::Handle<JSObject*> givenProto = nullptr)
-{
-  return GetOrCreateDOMReflectorHelper<T>::GetOrCreate(cx, value, givenProto,
-                                                       rval);
-}
-
-
-
-template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
-struct GetOrCreateDOMReflectorNoWrapHelper
-{
-  static inline bool GetOrCreate(JSContext* cx, const T& value,
-                                 JS::MutableHandle<JS::Value> rval)
-  {
-    return GetOrCreateDOMReflectorNoWrap(cx, value.get(), rval);
-  }
-};
-
-template <class T>
-struct GetOrCreateDOMReflectorNoWrapHelper<T, false>
-{
-  static inline bool GetOrCreate(JSContext* cx, T& value,
-                                 JS::MutableHandle<JS::Value> rval)
-  {
-    return GetOrCreateDOMReflectorNoWrap(cx, &value, rval);
-  }
-};
-
-template<class T>
-inline bool
-GetOrCreateDOMReflectorNoWrap(JSContext* cx, T& value,
-                              JS::MutableHandle<JS::Value> rval)
-{
-  return
-    GetOrCreateDOMReflectorNoWrapHelper<T>::GetOrCreate(cx, value, rval);
-}
-
-template <class T>
-inline JSObject*
-GetCallbackFromCallbackObject(T* aObj)
-{
-  return aObj->CallbackOrNull();
-}
-
-
-
-
-template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
-struct GetCallbackFromCallbackObjectHelper
-{
-  static inline JSObject* Get(const T& aObj)
-  {
-    return GetCallbackFromCallbackObject(aObj.get());
-  }
-};
-
-template <class T>
-struct GetCallbackFromCallbackObjectHelper<T, false>
-{
-  static inline JSObject* Get(T& aObj)
-  {
-    return GetCallbackFromCallbackObject(&aObj);
-  }
-};
-
-template<class T>
-inline JSObject*
-GetCallbackFromCallbackObject(T& aObj)
-{
-  return GetCallbackFromCallbackObjectHelper<T>::Get(aObj);
-}
-
-static inline bool
-AtomizeAndPinJSString(JSContext* cx, jsid& id, const char* chars)
-{
-  if (JSString *str = ::JS_AtomizeAndPinString(cx, chars)) {
-    id = INTERNED_STRING_TO_JSID(cx, str);
-    return true;
-  }
-  return false;
-}
-
-
-template <typename Spec>
-static bool
-InitIds(JSContext* cx, const Prefable<Spec>* prefableSpecs, jsid* ids)
-{
-  do { } while (0);
-  do { } while (0);
-  do {
-
-
-    Spec* spec = prefableSpecs->specs;
-    do {
-      if (!JS::PropertySpecNameToPermanentId(cx, spec->name, ids)) {
-        return false;
-      }
-    } while (++ids, (++spec)->name);
-
-
-
-    *ids = JSID_VOID;
-    ++ids;
-  } while ((++prefableSpecs)->specs);
-
-  return true;
-}
-
-bool
-QueryInterface(JSContext* cx, unsigned argc, JS::Value* vp);
-
-template <class T>
-struct
-WantsQueryInterface
-{
-  static_assert(IsBaseOf<nsISupports, T>::value,
-                "QueryInterface can't work without an nsISupports.");
-  static bool Enabled(JSContext* aCx, JSObject* aGlobal)
-  {
-    return NS_IsMainThread() && IsChromeOrXBL(aCx, aGlobal);
-  }
-};
-
-void
-GetInterfaceImpl(JSContext* aCx, nsIInterfaceRequestor* aRequestor,
-                 nsWrapperCache* aCache, nsIJSID* aIID,
-                 JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError);
-
-template<class T>
-void
-GetInterface(JSContext* aCx, T* aThis, nsIJSID* aIID,
-             JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError)
-{
-  GetInterfaceImpl(aCx, aThis, aThis, aIID, aRetval, aError);
-}
-
-bool
-ThrowingConstructor(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-ThrowConstructorWithoutNew(JSContext* cx, const char* name);
-
-bool
-GetPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
-                       JS::Handle<JS::Value> receiver, JS::Handle<jsid> id,
-                       bool* found, JS::MutableHandle<JS::Value> vp);
-
-
-bool
-HasPropertyOnPrototype(JSContext* cx, JS::Handle<JSObject*> proxy,
-                       JS::Handle<jsid> id, bool* has);
-
-
-
-
-
-
-bool
-AppendNamedPropertyIds(JSContext* cx, JS::Handle<JSObject*> proxy,
-                       nsTArray<nsString>& names,
-                       bool shadowPrototypeProperties, JS::AutoIdVector& props);
-
-enum StringificationBehavior {
-  eStringify,
-  eEmpty,
-  eNull
-};
-
-template<typename T>
-static inline bool
-ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v,
-                       StringificationBehavior nullBehavior,
-                       StringificationBehavior undefinedBehavior,
-                       T& result)
-{
-  JSString *s;
-  if (v.isString()) {
-    s = v.toString();
-  } else {
-    StringificationBehavior behavior;
-    if (v.isNull()) {
-      behavior = nullBehavior;
-    } else if (v.isUndefined()) {
-      behavior = undefinedBehavior;
-    } else {
-      behavior = eStringify;
-    }
-
-    if (behavior != eStringify) {
-      if (behavior == eEmpty) {
-        result.Truncate();
-      } else {
-        result.SetIsVoid(true);
-      }
-      return true;
-    }
-
-    s = JS::ToString(cx, v);
-    if (!s) {
-      return false;
-    }
-  }
-
-  return AssignJSString(cx, result, s);
-}
-
-template<typename T>
-static inline bool
-ConvertJSValueToString(JSContext* cx, JS::Handle<JS::Value> v, T& result)
-{
-  return ConvertJSValueToString(cx, v, eStringify, eStringify, result);
-}
-
-void
-NormalizeUSVString(nsAString& aString);
-
-void
-NormalizeUSVString(binding_detail::FakeString& aString);
-
-template<typename T>
-static inline bool
-ConvertJSValueToUSVString(JSContext* cx, JS::Handle<JS::Value> v, T& result)
-{
-  if (!ConvertJSValueToString(cx, v, eStringify, eStringify, result)) {
-    return false;
-  }
-
-  NormalizeUSVString(result);
-  return true;
-}
-
-template<typename T>
-inline bool
-ConvertIdToString(JSContext* cx, JS::HandleId id, T& result, bool& isSymbol)
-{
-  if ((__builtin_expect(!!(JSID_IS_STRING(id)), 1))) {
-    if (!AssignJSString(cx, result, JSID_TO_STRING(id))) {
-      return false;
-    }
-  } else if (JSID_IS_SYMBOL(id)) {
-    isSymbol = true;
-    return true;
-  } else {
-    JS::RootedValue nameVal(cx, js::IdToValue(id));
-    if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify, result)) {
-      return false;
-    }
-  }
-  isSymbol = false;
-  return true;
-}
-
-bool
-ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
-                           bool nullable, nsACString& result);
-
-inline bool
-ConvertJSValueToByteString(JSContext* cx, JS::Handle<JS::Value> v,
-                           nsACString& result)
-{
-  return ConvertJSValueToByteString(cx, v, false, result);
-}
-
-template<typename T>
-void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq);
-template<typename T>
-void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq);
-
-
-
-template<typename T,
-         bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
-         bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
-         bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
-class SequenceTracer
-{
-  explicit SequenceTracer() = delete;
-};
-
-
-template<>
-class SequenceTracer<JSObject*, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, JSObject** objp, JSObject** end) {
-    for (; objp != end; ++objp) {
-      JS::UnsafeTraceRoot(trc, objp, "sequence<object>");
-    }
-  }
-};
-
-
-template<>
-class SequenceTracer<JS::Value, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, JS::Value* valp, JS::Value* end) {
-    for (; valp != end; ++valp) {
-      JS::UnsafeTraceRoot(trc, valp, "sequence<any>");
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<Sequence<T>, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, Sequence<T>* seqp, Sequence<T>* end) {
-    for (; seqp != end; ++seqp) {
-      DoTraceSequence(trc, *seqp);
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<nsTArray<T>, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, nsTArray<T>* seqp, nsTArray<T>* end) {
-    for (; seqp != end; ++seqp) {
-      DoTraceSequence(trc, *seqp);
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<T, true, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, T* dictp, T* end) {
-    for (; dictp != end; ++dictp) {
-      dictp->TraceDictionary(trc);
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<T, false, true, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
-    for (; arrayp != end; ++arrayp) {
-      arrayp->TraceSelf(trc);
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<T, false, false, true>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
-    for (; arrayp != end; ++arrayp) {
-      arrayp->TraceUnion(trc);
-    }
-  }
-};
-
-
-template<typename T>
-class SequenceTracer<Nullable<T>, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, Nullable<T>* seqp,
-                            Nullable<T>* end) {
-    for (; seqp != end; ++seqp) {
-      if (!seqp->IsNull()) {
-
-
-        T& val = seqp->Value();
-        T* ptr = &val;
-        SequenceTracer<T>::TraceSequence(trc, ptr, ptr+1);
-      }
-    }
-  }
-};
-
-template<typename K, typename V>
-void TraceRecord(JSTracer* trc, Record<K, V>& record)
-{
-  for (auto& entry : record.Entries()) {
-
-    SequenceTracer<V>::TraceSequence(trc, &entry.mValue, &entry.mValue + 1);
-  }
-}
-
-
-template<typename K, typename V>
-class SequenceTracer<Record<K, V>, false, false, false>
-{
-  explicit SequenceTracer() = delete;
-
-public:
-  static void TraceSequence(JSTracer* trc, Record<K, V>* seqp,
-                            Record<K, V>* end) {
-    for (; seqp != end; ++seqp) {
-      TraceRecord(trc, *seqp);
-    }
-  }
-};
-
-template<typename T>
-void DoTraceSequence(JSTracer* trc, FallibleTArray<T>& seq)
-{
-  SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
-                                   seq.Elements() + seq.Length());
-}
-
-template<typename T>
-void DoTraceSequence(JSTracer* trc, InfallibleTArray<T>& seq)
-{
-  SequenceTracer<T>::TraceSequence(trc, seq.Elements(),
-                                   seq.Elements() + seq.Length());
-}
-
-
-template<typename T>
-class SequenceRooter final : private JS::CustomAutoRooter
-{
-public:
-  SequenceRooter(JSContext *aCx, FallibleTArray<T>* aSequence
-                                                )
-    : JS::CustomAutoRooter(aCx ),
-      mFallibleArray(aSequence),
-      mSequenceType(eFallibleArray)
-  {
-  }
-
-  SequenceRooter(JSContext *aCx, InfallibleTArray<T>* aSequence
-                                                )
-    : JS::CustomAutoRooter(aCx ),
-      mInfallibleArray(aSequence),
-      mSequenceType(eInfallibleArray)
-  {
-  }
-
-  SequenceRooter(JSContext *aCx, Nullable<nsTArray<T> >* aSequence
-                                                )
-    : JS::CustomAutoRooter(aCx ),
-      mNullableArray(aSequence),
-      mSequenceType(eNullableArray)
-  {
-  }
-
- private:
-  enum SequenceType {
-    eInfallibleArray,
-    eFallibleArray,
-    eNullableArray
-  };
-
-  virtual void trace(JSTracer *trc) override
-  {
-    if (mSequenceType == eFallibleArray) {
-      DoTraceSequence(trc, *mFallibleArray);
-    } else if (mSequenceType == eInfallibleArray) {
-      DoTraceSequence(trc, *mInfallibleArray);
-    } else {
-      do { } while (0);
-      if (!mNullableArray->IsNull()) {
-        DoTraceSequence(trc, mNullableArray->Value());
-      }
-    }
-  }
-
-  union {
-    InfallibleTArray<T>* mInfallibleArray;
-    FallibleTArray<T>* mFallibleArray;
-    Nullable<nsTArray<T> >* mNullableArray;
-  };
-
-  SequenceType mSequenceType;
-};
-
-
-template<typename K, typename V>
-class RecordRooter final : private JS::CustomAutoRooter
-{
-public:
-  RecordRooter(JSContext *aCx, Record<K, V>* aRecord
-                                              )
-    : JS::CustomAutoRooter(aCx ),
-      mRecord(aRecord),
-      mRecordType(eRecord)
-  {
-  }
-
-  RecordRooter(JSContext *aCx, Nullable<Record<K, V>>* aRecord
-                                                )
-    : JS::CustomAutoRooter(aCx ),
-      mNullableRecord(aRecord),
-      mRecordType(eNullableRecord)
-  {
-  }
-
-private:
-  enum RecordType {
-    eRecord,
-    eNullableRecord
-  };
-
-  virtual void trace(JSTracer *trc) override
-  {
-    if (mRecordType == eRecord) {
-      TraceRecord(trc, *mRecord);
-    } else {
-      do { } while (0);
-      if (!mNullableRecord->IsNull()) {
-        TraceRecord(trc, mNullableRecord->Value());
-      }
-    }
-  }
-
-  union {
-    Record<K, V>* mRecord;
-    Nullable<Record<K, V>>* mNullableRecord;
-  };
-
-  RecordType mRecordType;
-};
-
-template<typename T>
-class RootedUnion : public T,
-                             private JS::CustomAutoRooter
-{
-public:
-  explicit RootedUnion(JSContext* cx ) :
-    T(),
-    JS::CustomAutoRooter(cx )
-  {
-  }
-
-  virtual void trace(JSTracer *trc) override
-  {
-    this->TraceUnion(trc);
-  }
-};
-
-template<typename T>
-class NullableRootedUnion : public Nullable<T>,
-                                            private JS::CustomAutoRooter
-{
-public:
-  explicit NullableRootedUnion(JSContext* cx ) :
-    Nullable<T>(),
-    JS::CustomAutoRooter(cx )
-  {
-  }
-
-  virtual void trace(JSTracer *trc) override
-  {
-    if (!this->IsNull()) {
-      this->Value().TraceUnion(trc);
-    }
-  }
-};
-
-inline bool
-IdEquals(jsid id, const char* string)
-{
-  return JSID_IS_STRING(id) &&
-         JS_FlatStringEqualsAscii(JSID_TO_FLAT_STRING(id), string);
-}
-
-inline bool
-AddStringToIDVector(JSContext* cx, JS::AutoIdVector& vector, const char* name)
-{
-  return vector.growBy(1) &&
-         AtomizeAndPinJSString(cx, *(vector[vector.length() - 1]).address(), name);
-}
-# 2295 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-enum {
-  CONSTRUCTOR_NATIVE_HOLDER_RESERVED_SLOT = 0
-};
-
-bool
-Constructor(JSContext* cx, unsigned argc, JS::Value* vp);
-# 2311 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-XrayResolveOwnProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                       JS::Handle<JSObject*> obj,
-                       JS::Handle<jsid> id,
-                       JS::MutableHandle<JS::PropertyDescriptor> desc,
-                       bool& cacheOnHolder);
-# 2329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-XrayDefineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                   JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                   JS::Handle<JS::PropertyDescriptor> desc,
-                   JS::ObjectOpResult &result,
-                   bool *defined);
-# 2345 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-XrayOwnPropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                    JS::Handle<JSObject*> obj,
-                    unsigned flags, JS::AutoIdVector& props);
-# 2360 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-inline bool
-XrayGetNativeProto(JSContext* cx, JS::Handle<JSObject*> obj,
-                   JS::MutableHandle<JSObject*> protop)
-{
-  JS::Rooted<JSObject*> global(cx, js::GetGlobalForObjectCrossCompartment(obj));
-  {
-    JSAutoCompartment ac(cx, global);
-    const DOMJSClass* domClass = GetDOMClass(obj);
-    if (domClass) {
-      ProtoHandleGetter protoGetter = domClass->mGetProto;
-      if (protoGetter) {
-        protop.set(protoGetter(cx));
-      } else {
-        protop.set(JS::GetRealmObjectPrototype(cx));
-      }
-    } else if (JS_ObjectIsFunction(cx, obj)) {
-      do { } while (0);
-      protop.set(JS::GetRealmFunctionPrototype(cx));
-    } else {
-      const js::Class* clasp = js::GetObjectClass(obj);
-      do { } while (0);
-      ProtoGetter protoGetter =
-        DOMIfaceAndProtoJSClass::FromJSClass(clasp)->mGetParentProto;
-      protop.set(protoGetter(cx));
-    }
-  }
-
-  return JS_WrapObject(cx, protop);
-}
-
-
-
-
-const JSClass*
-XrayGetExpandoClass(JSContext* cx, JS::Handle<JSObject*> obj);
-# 2404 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-XrayDeleteNamedProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
-                        JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                        JS::ObjectOpResult& opresult);
-# 2423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-JSObject*
-GetCachedSlotStorageObjectSlow(JSContext* cx, JS::Handle<JSObject*> obj,
-                               bool* isXray);
-
-inline JSObject*
-GetCachedSlotStorageObject(JSContext* cx, JS::Handle<JSObject*> obj,
-                           bool* isXray) {
-  if (IsDOMObject(obj)) {
-    *isXray = false;
-    return obj;
-  }
-
-  return GetCachedSlotStorageObjectSlow(cx, obj, isXray);
-}
-
-extern NativePropertyHooks sEmptyNativePropertyHooks;
-
-extern const js::ClassOps sBoringInterfaceObjectClassClassOps;
-
-extern const js::ObjectOps sInterfaceObjectClassObjectOps;
-
-inline bool
-UseDOMXray(JSObject* obj)
-{
-  const js::Class* clasp = js::GetObjectClass(obj);
-  return IsDOMClass(clasp) ||
-         JS_IsNativeFunction(obj, Constructor) ||
-         IsDOMIfaceAndProtoClass(clasp);
-}
-# 2463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template<typename T>
-const T& Constify(T& arg)
-{
-  return arg;
-}
-
-
-template<typename T>
-T& NonNullHelper(T& aArg)
-{
-  return aArg;
-}
-
-template<typename T>
-T& NonNullHelper(NonNull<T>& aArg)
-{
-  return aArg;
-}
-
-template<typename T>
-const T& NonNullHelper(const NonNull<T>& aArg)
-{
-  return aArg;
-}
-
-template<typename T>
-T& NonNullHelper(OwningNonNull<T>& aArg)
-{
-  return aArg;
-}
-
-template<typename T>
-const T& NonNullHelper(const OwningNonNull<T>& aArg)
-{
-  return aArg;
-}
-
-inline
-void NonNullHelper(NonNull<binding_detail::FakeString>& aArg)
-{
-
-
-
-
-}
-
-inline
-void NonNullHelper(const NonNull<binding_detail::FakeString>& aArg)
-{
-
-
-
-
-}
-
-inline
-void NonNullHelper(binding_detail::FakeString& aArg)
-{
-
-
-
-
-}
-
-__attribute__((always_inline)) inline
-const nsAString& NonNullHelper(const binding_detail::FakeString& aArg)
-{
-  return aArg;
-}
-
-
-
-nsresult
-ReparentWrapper(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-
-
-
-bool
-InterfaceHasInstance(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-InterfaceHasInstance(JSContext* cx, int prototypeID, int depth,
-                     JS::Handle<JSObject*> instance,
-                     bool* bp);
-
-
-
-bool
-ReportLenientThisUnwrappingFailure(JSContext* cx, JSObject* obj);
-
-
-
-
-bool
-GetContentGlobalForJSImplementedObject(JSContext* cx, JS::Handle<JSObject*> obj,
-                                       nsIGlobalObject** global);
-
-void
-ConstructJSImplementation(const char* aContractId,
-                          nsIGlobalObject* aGlobal,
-                          JS::MutableHandle<JSObject*> aObject,
-                          ErrorResult& aRv);
-
-already_AddRefed<nsIGlobalObject>
-ConstructJSImplementation(const char* aContractId,
-                          const GlobalObject& aGlobal,
-                          JS::MutableHandle<JSObject*> aObject,
-                          ErrorResult& aRv);
-
-
-
-
-
-
-
-bool NonVoidByteStringToJsval(JSContext *cx, const nsACString &str,
-                              JS::MutableHandle<JS::Value> rval);
-inline bool ByteStringToJsval(JSContext *cx, const nsACString &str,
-                              JS::MutableHandle<JS::Value> rval)
-{
-    if (str.IsVoid()) {
-        rval.setNull();
-        return true;
-    }
-    return NonVoidByteStringToJsval(cx, str, rval);
-}
-
-template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
-struct PreserveWrapperHelper
-{
-  static void PreserveWrapper(T* aObject)
-  {
-    aObject->PreserveWrapper(aObject, T::cycleCollection::GetParticipant());
-  }
-};
-
-template<class T>
-struct PreserveWrapperHelper<T, true>
-{
-  static void PreserveWrapper(T* aObject)
-  {
-    aObject->PreserveWrapper(reinterpret_cast<nsISupports*>(aObject));
-  }
-};
-
-template<class T>
-void PreserveWrapper(T* aObject)
-{
-  PreserveWrapperHelper<T>::PreserveWrapper(aObject);
-}
-
-template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
-struct CastingAssertions
-{
-  static bool ToSupportsIsCorrect(T*)
-  {
-    return true;
-  }
-  static bool ToSupportsIsOnPrimaryInheritanceChain(T*, nsWrapperCache*)
-  {
-    return true;
-  }
-};
-
-template<class T>
-struct CastingAssertions<T, true>
-{
-  static bool ToSupportsIsCorrect(T* aObject)
-  {
-    return ToSupports(aObject) == reinterpret_cast<nsISupports*>(aObject);
-  }
-  static bool ToSupportsIsOnPrimaryInheritanceChain(T* aObject,
-                                                    nsWrapperCache* aCache)
-  {
-    return reinterpret_cast<void*>(aObject) != aCache;
-  }
-};
-
-template<class T>
-bool
-ToSupportsIsCorrect(T* aObject)
-{
-  return CastingAssertions<T>::ToSupportsIsCorrect(aObject);
-}
-
-template<class T>
-bool
-ToSupportsIsOnPrimaryInheritanceChain(T* aObject, nsWrapperCache* aCache)
-{
-  return CastingAssertions<T>::ToSupportsIsOnPrimaryInheritanceChain(aObject,
-                                                                     aCache);
-}
-# 2667 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template<class T>
-class BindingJSObjectCreator
-{
-public:
-  explicit BindingJSObjectCreator(JSContext* aCx)
-    : mReflector(aCx)
-  {
-  }
-
-  ~BindingJSObjectCreator()
-  {
-    if (mReflector) {
-      js::SetReservedOrProxyPrivateSlot(mReflector, 0,
-                                        JS::UndefinedValue());
-    }
-  }
-
-  void
-  CreateProxyObject(JSContext* aCx, const js::Class* aClass,
-                    const DOMProxyHandler* aHandler,
-                    JS::Handle<JSObject*> aProto, T* aNative,
-                    JS::MutableHandle<JSObject*> aReflector)
-  {
-    js::ProxyOptions options;
-    options.setClass(aClass);
-    JS::Rooted<JS::Value> proxyPrivateVal(aCx, JS::PrivateValue(aNative));
-    aReflector.set(js::NewProxyObject(aCx, aHandler, proxyPrivateVal, aProto,
-                                      options));
-    if (aReflector) {
-      mNative = aNative;
-      mReflector = aReflector;
-    }
-  }
-
-  void
-  CreateObject(JSContext* aCx, const JSClass* aClass,
-               JS::Handle<JSObject*> aProto,
-               T* aNative, JS::MutableHandle<JSObject*> aReflector)
-  {
-    aReflector.set(JS_NewObjectWithGivenProto(aCx, aClass, aProto));
-    if (aReflector) {
-      js::SetReservedSlot(aReflector, 0, JS::PrivateValue(aNative));
-      mNative = aNative;
-      mReflector = aReflector;
-    }
-  }
-
-  void
-  InitializationSucceeded()
-  {
-    void* dummy;
-    mNative.forget(&dummy);
-    mReflector = nullptr;
-  }
-
-private:
-  struct OwnedNative
-  {
-
-
-    static_assert(IsBaseOf<NonRefcountedDOMObject, T>::value,
-                  "Non-refcounted objects with DOM bindings should inherit "
-                  "from NonRefcountedDOMObject.");
-
-    OwnedNative&
-    operator=(T* aNative)
-    {
-      return *this;
-    }
-
-
-
-    void
-    forget(void**)
-    {
-    }
-  };
-
-  JS::Rooted<JSObject*> mReflector;
-  typename Conditional<IsRefcounted<T>::value, RefPtr<T>, OwnedNative>::Type mNative;
-};
-
-template<class T>
-struct DeferredFinalizerImpl
-{
-  typedef typename Conditional<IsSame<T, nsISupports>::value,
-                               nsCOMPtr<T>,
-                               typename Conditional<IsRefcounted<T>::value,
-                                                    RefPtr<T>,
-                                                    nsAutoPtr<T>>::Type>::Type SmartPtr;
-  typedef SegmentedVector<SmartPtr> SmartPtrArray;
-
-  static_assert(IsSame<T, nsISupports>::value || !IsBaseOf<nsISupports, T>::value,
-                "nsISupports classes should all use the nsISupports instantiation");
-
-  static inline void
-  AppendAndTake(SegmentedVector<nsCOMPtr<nsISupports>>& smartPtrArray, nsISupports* ptr)
-  {
-    smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
-  }
-  template<class U>
-  static inline void
-  AppendAndTake(SegmentedVector<RefPtr<U>>& smartPtrArray, U* ptr)
-  {
-    smartPtrArray.InfallibleAppend(dont_AddRef(ptr));
-  }
-  template<class U>
-  static inline void
-  AppendAndTake(SegmentedVector<nsAutoPtr<U>>& smartPtrArray, U* ptr)
-  {
-    smartPtrArray.InfallibleAppend(ptr);
-  }
-
-  static void*
-  AppendDeferredFinalizePointer(void* aData, void* aObject)
-  {
-    SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
-    if (!pointers) {
-      pointers = new SmartPtrArray();
-    }
-    AppendAndTake(*pointers, static_cast<T*>(aObject));
-    return pointers;
-  }
-  static bool
-  DeferredFinalize(uint32_t aSlice, void* aData)
-  {
-    do { } while (0);
-    SmartPtrArray* pointers = static_cast<SmartPtrArray*>(aData);
-    uint32_t oldLen = pointers->Length();
-    if (oldLen < aSlice) {
-      aSlice = oldLen;
-    }
-    uint32_t newLen = oldLen - aSlice;
-    pointers->PopLastN(aSlice);
-    if (newLen == 0) {
-      delete pointers;
-      return true;
-    }
-    return false;
-  }
-};
-
-template<class T,
-         bool isISupports=IsBaseOf<nsISupports, T>::value>
-struct DeferredFinalizer
-{
-  static void
-  AddForDeferredFinalization(T* aObject)
-  {
-    typedef DeferredFinalizerImpl<T> Impl;
-    DeferredFinalize(Impl::AppendDeferredFinalizePointer,
-                     Impl::DeferredFinalize, aObject);
-  }
-};
-
-template<class T>
-struct DeferredFinalizer<T, true>
-{
-  static void
-  AddForDeferredFinalization(T* aObject)
-  {
-    DeferredFinalize(reinterpret_cast<nsISupports*>(aObject));
-  }
-};
-
-template<class T>
-static void
-AddForDeferredFinalization(T* aObject)
-{
-  DeferredFinalizer<T>::AddForDeferredFinalization(aObject);
-}
-
-
-
-
-template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
-class GetCCParticipant
-{
-
-  template<class U>
-  static constexpr nsCycleCollectionParticipant*
-  GetHelper(int, typename U::cycleCollection* dummy=nullptr)
-  {
-    return T::cycleCollection::GetParticipant();
-  }
-
-  template<class U>
-  static constexpr nsCycleCollectionParticipant*
-  GetHelper(double)
-  {
-    return nullptr;
-  }
-
-public:
-  static constexpr nsCycleCollectionParticipant*
-  Get()
-  {
-
-
-
-
-    return GetHelper<T>(int());
-  }
-};
-
-template<class T>
-class GetCCParticipant<T, true>
-{
-public:
-  static constexpr nsCycleCollectionParticipant*
-  Get()
-  {
-    return nullptr;
-  }
-};
-
-void
-FinalizeGlobal(JSFreeOp* aFop, JSObject* aObj);
-
-bool
-ResolveGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
-              JS::Handle<jsid> aId, bool* aResolvedp);
-
-bool
-MayResolveGlobal(const JSAtomState& aNames, jsid aId, JSObject* aMaybeObj);
-
-bool
-EnumerateGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-template <class T>
-struct CreateGlobalOptions
-{
-  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
-    ProtoAndIfaceCache::NonWindowLike;
-  static void TraceGlobal(JSTracer* aTrc, JSObject* aObj)
-  {
-    mozilla::dom::TraceProtoAndIfaceCache(aTrc, aObj);
-  }
-  static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
-  {
-    do { if ((TryPreserveWrapper(aGlobal))) { } } while (0);
-
-    return true;
-  }
-};
-
-template <>
-struct CreateGlobalOptions<nsGlobalWindow>
-{
-  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
-    ProtoAndIfaceCache::WindowLike;
-  static void TraceGlobal(JSTracer* aTrc, JSObject* aObj);
-  static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
-};
-
-nsresult
-RegisterDOMNames();
-# 2932 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-template <class T, ProtoHandleGetter GetProto>
-bool
-CreateGlobal(JSContext* aCx, T* aNative, nsWrapperCache* aCache,
-             const JSClass* aClass, JS::CompartmentOptions& aOptions,
-             JSPrincipals* aPrincipal, bool aInitStandardClasses,
-             JS::MutableHandle<JSObject*> aGlobal)
-{
-  aOptions.creationOptions().setTrace(CreateGlobalOptions<T>::TraceGlobal);
-  if (xpc::SharedMemoryEnabled()) {
-    aOptions.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
-  }
-
-  aGlobal.set(JS_NewGlobalObject(aCx, aClass, aPrincipal,
-                                 JS::DontFireOnNewGlobalHook, aOptions));
-  if (!aGlobal) {
-    do { } while(0);
-    return false;
-  }
-
-  JSAutoCompartment ac(aCx, aGlobal);
-
-  {
-    js::SetReservedSlot(aGlobal, 0, JS::PrivateValue(aNative));
-    (aNative)->AddRef();
-
-    aCache->SetWrapper(aGlobal);
-
-    dom::AllocateProtoAndIfaceCache(aGlobal,
-                                    CreateGlobalOptions<T>::ProtoAndIfaceCacheKind);
-
-    if (!CreateGlobalOptions<T>::PostCreateGlobal(aCx, aGlobal)) {
-      return false;
-    }
-  }
-
-  if (aInitStandardClasses &&
-      !JS_InitStandardClasses(aCx, aGlobal)) {
-    do { } while(0);
-    return false;
-  }
-
-  JS::Handle<JSObject*> proto = GetProto(aCx);
-  if (!proto || !JS_SplicePrototype(aCx, aGlobal, proto)) {
-    do { } while(0);
-    return false;
-  }
-
-  bool succeeded;
-  if (!JS_SetImmutablePrototype(aCx, aGlobal, &succeeded)) {
-    return false;
-  }
-  do { } while (0);
-
-
-
-  return true;
-}
-
-
-
-
-
-class PinnedStringId
-{
-  jsid id;
-
- public:
-  PinnedStringId() : id(JSID_VOID) {}
-
-  bool init(JSContext *cx, const char *string) {
-    JSString* str = JS_AtomizeAndPinString(cx, string);
-    if (!str)
-      return false;
-    id = INTERNED_STRING_TO_JSID(cx, str);
-    return true;
-  }
-
-  operator const jsid& () {
-    return id;
-  }
-
-  operator JS::Handle<jsid> () {
-
-    return JS::Handle<jsid>::fromMarkedLocation(&id);
-  }
-};
-
-bool
-GenericBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-GenericPromiseReturningBindingGetter(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-GenericBindingSetter(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-GenericBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-GenericPromiseReturningBindingMethod(JSContext* cx, unsigned argc, JS::Value* vp);
-
-bool
-StaticMethodPromiseWrapper(JSContext* cx, unsigned argc, JS::Value* vp);
-# 3045 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-ConvertExceptionToPromise(JSContext* cx,
-                          JSObject* promiseScope,
-                          JS::MutableHandle<JS::Value> rval);
-# 3062 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool
-EnforceNotInPrerendering(JSContext* aCx, JSObject* aObj);
-
-
-
-
-void
-HandlePrerenderingViolation(nsPIDOMWindowInner* aWindow);
-
-bool
-CallerSubsumes(JSObject* aObject);
-
-__attribute__((always_inline)) inline bool
-CallerSubsumes(JS::Handle<JS::Value> aValue)
-{
-  if (!aValue.isObject()) {
-    return true;
-  }
-  return CallerSubsumes(&aValue.toObject());
-}
-
-template<class T>
-inline bool
-WrappedJSToDictionary(JSContext* aCx, nsISupports* aObject, T& aDictionary)
-{
-  nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
-  if (!wrappedObj) {
-    return false;
-  }
-
-  JS::Rooted<JSObject*> obj(aCx, wrappedObj->GetJSObject());
-  if (!obj) {
-    return false;
-  }
-
-  JSAutoCompartment ac(aCx, obj);
-  JS::Rooted<JS::Value> v(aCx, JS::ObjectValue(*obj));
-  return aDictionary.Init(aCx, v);
-}
-
-template<class T>
-inline bool
-WrappedJSToDictionary(nsISupports* aObject, T& aDictionary)
-{
-  nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
-  do { if ((__builtin_expect(!!(!(wrappedObj)), 0))) { do { } while(0); return false; } } while(0);
-  JS::Rooted<JSObject*> obj(RootingCx(), wrappedObj->GetJSObject());
-  do { if ((__builtin_expect(!!(!(obj)), 0))) { do { } while(0); return false; } } while(0);
-
-  nsIGlobalObject* global = xpc::NativeGlobal(obj);
-  do { if ((__builtin_expect(!!(!(global)), 0))) { do { } while(0); return false; } } while(0);
-
-
-
-  AutoEntryScript aes(global, "WebIDL dictionary creation");
-
-  JS::Rooted<JS::Value> v(aes.cx(), JS::ObjectValue(*obj));
-  return aDictionary.Init(aes.cx(), v);
-}
-
-
-template<class T, class S>
-inline RefPtr<T>
-StrongOrRawPtr(already_AddRefed<S>&& aPtr)
-{
-  return aPtr.template downcast<T>();
-}
-
-template<class T,
-         class ReturnType=typename Conditional<IsRefcounted<T>::value, T*,
-                                               nsAutoPtr<T>>::Type>
-inline ReturnType
-StrongOrRawPtr(T* aPtr)
-{
-  return ReturnType(aPtr);
-}
-
-template<class T, template<typename> class SmartPtr, class S>
-inline void
-StrongOrRawPtr(SmartPtr<S>&& aPtr) = delete;
-
-template<class T>
-struct StrongPtrForMember
-{
-  typedef typename Conditional<IsRefcounted<T>::value,
-                               RefPtr<T>, nsAutoPtr<T>>::Type Type;
-};
-
-namespace binding_detail {
-inline
-JSObject*
-GetHackedNamespaceProtoObject(JSContext* aCx)
-{
-  return JS_NewPlainObject(aCx);
-}
-}
-
-
-
-
-bool SystemGlobalResolve(JSContext* cx, JS::Handle<JSObject*> obj,
-                         JS::Handle<jsid> id, bool* resolvedp);
-
-
-
-
-bool SystemGlobalEnumerate(JSContext* cx, JS::Handle<JSObject*> obj);
-# 3177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-bool ForEachHandler(JSContext* aCx, unsigned aArgc, JS::Value* aVp);
-
-
-
-
-
-
-bool GetMaplikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
-                             size_t aSlotIndex,
-                             JS::MutableHandle<JSObject*> aBackingObj,
-                             bool* aBackingObjCreated);
-bool GetSetlikeBackingObject(JSContext* aCx, JS::Handle<JSObject*> aObj,
-                             size_t aSlotIndex,
-                             JS::MutableHandle<JSObject*> aBackingObj,
-                             bool* aBackingObjCreated);
-
-
-
-bool
-GetDesiredProto(JSContext* aCx, const JS::CallArgs& aCallArgs,
-                JS::MutableHandle<JSObject*> aDesiredProto);
-
-
-
-
-already_AddRefed<nsGenericHTMLElement>
-CreateHTMLElement(const GlobalObject& aGlobal, const JS::CallArgs& aCallArgs,
-                  ErrorResult& aRv);
-
-void
-SetDocumentAndPageUseCounter(JSContext* aCx, JSObject* aObject,
-                             UseCounter aUseCounter);
-
-
-void
-DeprecationWarning(JSContext* aCx, JSObject* aObject,
-                   nsIDocument::DeprecatedOperations aOperation);
-
-void
-DeprecationWarning(const GlobalObject& aGlobal,
-                   nsIDocument::DeprecatedOperations aOperation);
-
-
-JSString*
-InterfaceObjectToString(JSContext* aCx, JS::Handle<JSObject*> aObject,
-                        unsigned );
-
-namespace binding_detail {
-# 3240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/BindingUtils.h"
-JSObject* UnprivilegedJunkScopeOrWorkerGlobal();
-}
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ToJSValue.h" 2
-
-
-
-
-
-
-namespace mozilla {
-namespace dom {
-
-class Promise;
-
-
-
-
-
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const nsAString& aArgument,
-          JS::MutableHandle<JS::Value> aValue);
-
-
-
-
-
-
-template<typename T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsSame<T, bool>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          T aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setBoolean(aArgument);
-  return true;
-}
-
-
-inline bool
-ToJSValue(JSContext* aCx,
-          int32_t aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setInt32(aArgument);
-  return true;
-}
-
-inline bool
-ToJSValue(JSContext* aCx,
-          uint32_t aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setNumber(aArgument);
-  return true;
-}
-
-inline bool
-ToJSValue(JSContext* aCx,
-          int64_t aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setNumber(double(aArgument));
-  return true;
-}
-
-inline bool
-ToJSValue(JSContext* aCx,
-          uint64_t aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setNumber(double(aArgument));
-  return true;
-}
-
-
-inline bool
-ToJSValue(JSContext* aCx,
-          float aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setNumber(aArgument);
-  return true;
-}
-
-inline bool
-ToJSValue(JSContext* aCx,
-          double aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setNumber(aArgument);
-  return true;
-}
-
-
-__attribute__ ((warn_unused_result)) inline bool
-ToJSValue(JSContext* aCx,
-          CallbackObject& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  aValue.setObjectOrNull(aArgument.CallbackOrNull());
-
-  return MaybeWrapValue(aCx, aValue);
-}
-
-
-
-template <class T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsBaseOf<nsWrapperCache, T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          T& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  do { } while (0);
-
-  return GetOrCreateDOMReflector(aCx, aArgument, aValue);
-}
-
-
-template<typename T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsBaseOf<AllTypedArraysBase, T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          const TypedArrayCreator<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  JSObject* obj = aArgument.Create(aCx);
-  if (!obj) {
-    return false;
-  }
-  aValue.setObject(*obj);
-  return true;
-}
-
-
-
-template <class T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<!IsBaseOf<nsWrapperCache, T>::value &&
-                  !IsBaseOf<CallbackObject, T>::value &&
-                  IsBaseOf<nsISupports, T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          T& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  qsObjectHelper helper(ToSupports(&aArgument), nullptr);
-  JS::Rooted<JSObject*> scope(aCx, JS::CurrentGlobalOrNull(aCx));
-  return XPCOMObjectToJsval(aCx, scope, helper, nullptr, true, aValue);
-}
-
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const nsCOMPtr<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, *aArgument.get(), aValue);
-}
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const RefPtr<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, *aArgument.get(), aValue);
-}
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const NonNull<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, *aArgument.get(), aValue);
-}
-
-
-template <class T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsBaseOf<DictionaryBase, T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          const T& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return aArgument.ToObjectInternal(aCx, aValue);
-}
-
-
-__attribute__ ((warn_unused_result)) inline bool
-ToJSValue(JSContext* aCx, JS::Handle<JS::Value> aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  aValue.set(aArgument);
-  return MaybeWrapValue(aCx, aValue);
-}
-
-
-__attribute__ ((warn_unused_result)) inline bool
-ToJSValue(JSContext* aCx, const JS::Heap<JS::Value>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  aValue.set(aArgument);
-  return MaybeWrapValue(aCx, aValue);
-}
-
-
-__attribute__ ((warn_unused_result)) inline bool
-ToJSValue(JSContext* aCx, const JS::Rooted<JS::Value>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  aValue.set(aArgument);
-  return MaybeWrapValue(aCx, aValue);
-}
-
-
-
-__attribute__ ((warn_unused_result)) inline bool
-ToJSValue(JSContext* aCx, const JS::Rooted<JSObject*>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  aValue.setObjectOrNull(aArgument);
-  return MaybeWrapObjectOrNullValue(aCx, aValue);
-}
-
-
-
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          nsresult aArgument,
-          JS::MutableHandle<JS::Value> aValue);
-
-
-
-
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          ErrorResult& aArgument,
-          JS::MutableHandle<JS::Value> aValue);
-
-
-template <typename T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsBaseOf<AllOwningUnionBase, T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          const T& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
-  return aArgument.ToJSVal(aCx, global, aValue);
-}
-
-
-template <typename T>
-__attribute__ ((warn_unused_result))
-typename EnableIf<IsPointer<T>::value, bool>::Type
-ToJSValue(JSContext* aCx,
-          T aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, *aArgument, aValue);
-}
-
-
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          Promise& aArgument,
-          JS::MutableHandle<JS::Value> aValue);
-
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          T* aArguments,
-          size_t aLength,
-          JS::MutableHandle<JS::Value> aValue)
-{
-
-  do { } while (0);
-
-  JS::AutoValueVector v(aCx);
-  if (!v.resize(aLength)) {
-    return false;
-  }
-  for (size_t i = 0; i < aLength; ++i) {
-    if (!ToJSValue(aCx, aArguments[i], v[i])) {
-      return false;
-    }
-  }
-  JSObject* arrayObj = JS_NewArrayObject(aCx, v);
-  if (!arrayObj) {
-    return false;
-  }
-  aValue.setObject(*arrayObj);
-  return true;
-}
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const nsTArray<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, aArgument.Elements(),
-                   aArgument.Length(), aValue);
-}
-
-template <typename T>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const FallibleTArray<T>& aArgument,
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, aArgument.Elements(),
-                   aArgument.Length(), aValue);
-}
-
-template <typename T, int N>
-__attribute__ ((warn_unused_result)) bool
-ToJSValue(JSContext* aCx,
-          const T(&aArgument)[N],
-          JS::MutableHandle<JS::Value> aValue)
-{
-  return ToJSValue(aCx, aArgument, N, aValue);
-}
-
-}
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h" 2
-
-
-class nsGlobalWindow;
-struct nsGlobalWindowAtoms;
-class nsPIDOMWindowOuter;
-
-namespace mozilla {
-namespace dom {
-
-class ChromeWindow;
-struct ChromeWindowAtoms;
-class External;
-class FrameRequestCallback;
-class IdleDeadline;
-class IdleRequestCallback;
-struct IdleRequestOptionsAtoms;
-struct NativePropertyHooks;
-class OwningExternalOrWindowProxy;
-class ProtoAndIfaceCache;
-struct ScrollOptionsAtoms;
-struct ScrollToOptionsAtoms;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class ScrollBehavior : uint8_t {
-  Auto,
-  Instant,
-  Smooth,
-  EndGuard_
-};
-
-namespace ScrollBehaviorValues {
-extern const EnumEntry strings[4];
-}
-
-bool
-ToJSValue(JSContext* aCx, ScrollBehavior aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback, OwningExternalOrWindowProxy& aUnion, const char* aName, uint32_t aFlags = 0);
-
-
-void
-ImplCycleCollectionUnlink(OwningExternalOrWindowProxy& aUnion);
-
-
-class ExternalOrWindowProxy
-{
-  friend class ExternalOrWindowProxyArgument;
-  enum Type
-  {
-    eUninitialized,
-    eExternal,
-    eWindowProxy
-  };
-
-  union Value
-  {
-    UnionMember<NonNull<mozilla::dom::External> > mExternal;
-    UnionMember<nsPIDOMWindowOuter* > mWindowProxy;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-  ExternalOrWindowProxy(const ExternalOrWindowProxy&) = delete;
-  ExternalOrWindowProxy& operator=(const ExternalOrWindowProxy&) = delete;
-public:
-  explicit inline ExternalOrWindowProxy()
-    : mType(eUninitialized)
-  {
-  }
-
-  inline ~ExternalOrWindowProxy()
-  {
-    Uninit();
-  }
-
-  inline NonNull<mozilla::dom::External>&
-  RawSetAsExternal()
-  {
-    if (mType == eExternal) {
-      return mValue.mExternal.Value();
-    }
-    do { } while (0);
-    mType = eExternal;
-    return mValue.mExternal.SetValue();
-  }
-
-  inline NonNull<mozilla::dom::External>&
-  SetAsExternal()
-  {
-    if (mType == eExternal) {
-      return mValue.mExternal.Value();
-    }
-    Uninit();
-    mType = eExternal;
-    return mValue.mExternal.SetValue();
-  }
-
-  inline bool
-  IsExternal() const
-  {
-    return mType == eExternal;
-  }
-
-  inline NonNull<mozilla::dom::External>&
-  GetAsExternal()
-  {
-    do { } while (0);
-    return mValue.mExternal.Value();
-  }
-
-  inline mozilla::dom::External&
-  GetAsExternal() const
-  {
-    do { } while (0);
-    return mValue.mExternal.Value();
-  }
-
-  inline nsPIDOMWindowOuter*&
-  RawSetAsWindowProxy()
-  {
-    if (mType == eWindowProxy) {
-      return mValue.mWindowProxy.Value();
-    }
-    do { } while (0);
-    mType = eWindowProxy;
-    return mValue.mWindowProxy.SetValue();
-  }
-
-  inline nsPIDOMWindowOuter*&
-  SetAsWindowProxy()
-  {
-    if (mType == eWindowProxy) {
-      return mValue.mWindowProxy.Value();
-    }
-    Uninit();
-    mType = eWindowProxy;
-    return mValue.mWindowProxy.SetValue();
-  }
-
-  inline bool
-  IsWindowProxy() const
-  {
-    return mType == eWindowProxy;
-  }
-
-  inline nsPIDOMWindowOuter*&
-  GetAsWindowProxy()
-  {
-    do { } while (0);
-    return mValue.mWindowProxy.Value();
-  }
-
-  inline nsPIDOMWindowOuter*
-  GetAsWindowProxy() const
-  {
-    do { } while (0);
-    return mValue.mWindowProxy.Value();
-  }
-
-  inline void
-  Uninit()
-  {
-    switch (mType) {
-      case eUninitialized: {
-        break;
-      }
-      case eExternal: {
-        DestroyExternal();
-        break;
-      }
-      case eWindowProxy: {
-        DestroyWindowProxy();
-        break;
-      }
-    }
-  }
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-private:
-  inline void
-  DestroyExternal()
-  {
-    do { } while (0);
-    mValue.mExternal.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyWindowProxy()
-  {
-    do { } while (0);
-    mValue.mWindowProxy.Destroy();
-    mType = eUninitialized;
-  }
-};
-
-
-class OwningExternalOrWindowProxy : public AllOwningUnionBase
-{
-  friend void ImplCycleCollectionUnlink(OwningExternalOrWindowProxy& aUnion);
-  enum Type
-  {
-    eUninitialized,
-    eExternal,
-    eWindowProxy
-  };
-
-  union Value
-  {
-    UnionMember<OwningNonNull<mozilla::dom::External> > mExternal;
-    UnionMember<RefPtr<nsPIDOMWindowOuter> > mWindowProxy;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-public:
-  explicit inline OwningExternalOrWindowProxy()
-    : mType(eUninitialized)
-  {
-  }
-
-  explicit inline OwningExternalOrWindowProxy(const OwningExternalOrWindowProxy& aOther)
-    : mType(eUninitialized)
-  {
-    *this = aOther;
-  }
-
-  inline ~OwningExternalOrWindowProxy()
-  {
-    Uninit();
-  }
-
-  OwningNonNull<mozilla::dom::External>&
-  RawSetAsExternal();
-
-  OwningNonNull<mozilla::dom::External>&
-  SetAsExternal();
-
-  bool
-  TrySetToExternal(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsExternal() const
-  {
-    return mType == eExternal;
-  }
-
-  inline OwningNonNull<mozilla::dom::External>&
-  GetAsExternal()
-  {
-    do { } while (0);
-    return mValue.mExternal.Value();
-  }
-
-  inline OwningNonNull<mozilla::dom::External> const &
-  GetAsExternal() const
-  {
-    do { } while (0);
-    return mValue.mExternal.Value();
-  }
-
-  RefPtr<nsPIDOMWindowOuter>&
-  RawSetAsWindowProxy();
-
-  RefPtr<nsPIDOMWindowOuter>&
-  SetAsWindowProxy();
-
-  bool
-  TrySetToWindowProxy(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsWindowProxy() const
-  {
-    return mType == eWindowProxy;
-  }
-
-  inline RefPtr<nsPIDOMWindowOuter>&
-  GetAsWindowProxy()
-  {
-    do { } while (0);
-    return mValue.mWindowProxy.Value();
-  }
-
-  inline RefPtr<nsPIDOMWindowOuter> const &
-  GetAsWindowProxy() const
-  {
-    do { } while (0);
-    return mValue.mWindowProxy.Value();
-  }
-
-  void
-  Uninit();
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceUnion(JSTracer* trc);
-
-  OwningExternalOrWindowProxy&
-  operator=(const OwningExternalOrWindowProxy& aOther);
-
-private:
-  void
-  DestroyExternal();
-
-  void
-  DestroyWindowProxy();
-};
-
-
-struct IdleRequestOptions : public DictionaryBase
-{
-                        Optional<uint32_t> mTimeout;
-
-  IdleRequestOptions();
-
-  explicit inline IdleRequestOptions(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline IdleRequestOptions(const IdleRequestOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  IdleRequestOptions&
-  operator=(const IdleRequestOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, IdleRequestOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastIdleRequestOptions : public IdleRequestOptions
-{
-  inline FastIdleRequestOptions()
-    : IdleRequestOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct ScrollOptions : public DictionaryBase
-{
-                        ScrollBehavior mBehavior;
-
-  ScrollOptions();
-
-  explicit inline ScrollOptions(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline ScrollOptions(const ScrollOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  ScrollOptions&
-  operator=(const ScrollOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, ScrollOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastScrollOptions : public ScrollOptions
-{
-  inline FastScrollOptions()
-    : ScrollOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct ScrollToOptions : public ScrollOptions
-{
-                        Optional<double> mLeft;
-                        Optional<double> mTop;
-
-  ScrollToOptions();
-
-  explicit inline ScrollToOptions(const FastDictionaryInitializer& )
-    : ScrollOptions(FastDictionaryInitializer())
-  {
-
-  }
-
-  explicit inline ScrollToOptions(const ScrollToOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  ScrollToOptions&
-  operator=(const ScrollToOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, ScrollToOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastScrollToOptions : public ScrollToOptions
-{
-  inline FastScrollToOptions()
-    : ScrollToOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-class FrameRequestCallback : public CallbackFunction
-{
-public:
-  explicit inline FrameRequestCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline FrameRequestCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
-    : CallbackFunction(aCallback, FastCallbackConstructor())
-  {
-    do { } while (0);
-  }
-
-  explicit inline FrameRequestCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline FrameRequestCallback(CallbackFunction* aOther)
-    : CallbackFunction(aOther)
-  {
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, double time, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "FrameRequestCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    JS::Rooted<JS::Value> thisValJS(s.GetContext());
-    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-    return Call(s.GetContext(), thisValJS, time, aRv);
-  }
-
-  inline void
-  Call(double time, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "FrameRequestCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    return Call(s.GetContext(), JS::UndefinedHandleValue, time, aRv);
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, double time, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(thisVal, time, rv, aExecutionReason);
-  }
-
-  inline void
-  Call(double time, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(time, rv, aExecutionReason, eReportExceptions, nullptr);
-  }
-
-  inline bool
-  operator==(const FrameRequestCallback& aOther) const
-  {
-    return CallbackFunction::operator==(aOther);
-  }
-
-private:
-  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, double time, ErrorResult& aRv);
-};
-
-
-class IdleRequestCallback : public CallbackFunction
-{
-public:
-  explicit inline IdleRequestCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline IdleRequestCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
-    : CallbackFunction(aCallback, FastCallbackConstructor())
-  {
-    do { } while (0);
-  }
-
-  explicit inline IdleRequestCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline IdleRequestCallback(CallbackFunction* aOther)
-    : CallbackFunction(aOther)
-  {
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, IdleDeadline& deadline, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "IdleRequestCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    JS::Rooted<JS::Value> thisValJS(s.GetContext());
-    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-    return Call(s.GetContext(), thisValJS, deadline, aRv);
-  }
-
-  inline void
-  Call(IdleDeadline& deadline, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "IdleRequestCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    return Call(s.GetContext(), JS::UndefinedHandleValue, deadline, aRv);
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, IdleDeadline& deadline, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(thisVal, deadline, rv, aExecutionReason);
-  }
-
-  inline void
-  Call(IdleDeadline& deadline, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(deadline, rv, aExecutionReason, eReportExceptions, nullptr);
-  }
-
-  inline bool
-  operator==(const IdleRequestCallback& aOther) const
-  {
-    return CallbackFunction::operator==(aOther);
-  }
-
-private:
-  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, IdleDeadline& deadline, ErrorResult& aRv);
-};
-
-
-namespace binding_detail {
-class FastFrameRequestCallback : public FrameRequestCallback
-{
-public:
-  explicit inline FastFrameRequestCallback(JS::Handle<JSObject*> aCallback)
-    : FrameRequestCallback(aCallback, FastCallbackConstructor())
-  {
-  }
-
-  inline void
-  Trace(JSTracer* aTracer)
-  {
-    FrameRequestCallback::Trace(aTracer);
-  }
-
-  inline void
-  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
-  {
-    FrameRequestCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
-  }
-};
-}
-
-
-namespace binding_detail {
-class FastIdleRequestCallback : public IdleRequestCallback
-{
-public:
-  explicit inline FastIdleRequestCallback(JS::Handle<JSObject*> aCallback)
-    : IdleRequestCallback(aCallback, FastCallbackConstructor())
-  {
-  }
-
-  inline void
-  Trace(JSTracer* aTracer)
-  {
-    IdleRequestCallback::Trace(aTracer);
-  }
-
-  inline void
-  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
-  {
-    IdleRequestCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
-  }
-};
-}
-
-
-namespace ChromeWindowBinding {
-
-  typedef mozilla::dom::ChromeWindow NativeType;
-
-  bool
-  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-# 729 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-namespace WindowBinding {
-
-  typedef nsGlobalWindow NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, nsGlobalWindow* aObject, nsWrapperCache* aCache, JS::CompartmentOptions& aOptions, JSPrincipals* aPrincipal, bool aInitStandardClasses, JS::MutableHandle<JSObject*> aReflector);
-# 764 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/WindowBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  bool
-  ClearCachedDocumentValue(JSContext* aCx, nsGlobalWindow* aObject);
-
-  bool
-  ClearCachedPerformanceValue(JSContext* aCx, nsGlobalWindow* aObject);
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-  inline bool IsPermitted(JSFlatString* prop, char16_t propFirstChar, bool set)
-  {
-    switch (propFirstChar) {
-      case 'b': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "blur")) {
-          return true;
-        }
-        break;
-      }
-      case 'c': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "close")) {
-          return true;
-        }
-        if (!set && JS_FlatStringEqualsAscii(prop, "closed")) {
-          return true;
-        }
-        break;
-      }
-      case 'f': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "focus")) {
-          return true;
-        }
-        if (!set && JS_FlatStringEqualsAscii(prop, "frames")) {
-          return true;
-        }
-        break;
-      }
-      case 'l': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "length")) {
-          return true;
-        }
-        if (JS_FlatStringEqualsAscii(prop, "location")) {
-          return true;
-        }
-        break;
-      }
-      case 'o': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "opener")) {
-          return true;
-        }
-        break;
-      }
-      case 'p': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "parent")) {
-          return true;
-        }
-        if (!set && JS_FlatStringEqualsAscii(prop, "postMessage")) {
-          return true;
-        }
-        break;
-      }
-      case 's': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "self")) {
-          return true;
-        }
-        break;
-      }
-      case 't': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "top")) {
-          return true;
-        }
-        break;
-      }
-      case 'w': {
-        if (!set && JS_FlatStringEqualsAscii(prop, "window")) {
-          return true;
-        }
-        break;
-      }
-    }
-
-    return false;
-  }
-
-}
-
-
-
-}
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ScrollbarStyles.h" 2
-
-
-struct nsStyleDisplay;
-
-namespace mozilla {
-
-struct ScrollbarStyles
-{
-
-
-  uint8_t mHorizontal;
-  uint8_t mVertical;
-
-
-  uint8_t mScrollBehavior;
-
-
-  uint8_t mScrollSnapTypeX;
-  uint8_t mScrollSnapTypeY;
-  nsStyleCoord mScrollSnapPointsX;
-  nsStyleCoord mScrollSnapPointsY;
-  nsStyleCoord::CalcValue mScrollSnapDestinationX;
-  nsStyleCoord::CalcValue mScrollSnapDestinationY;
-
-  ScrollbarStyles(uint8_t aH, uint8_t aV)
-    : mHorizontal(aH), mVertical(aV),
-      mScrollBehavior(0),
-      mScrollSnapTypeX(0),
-      mScrollSnapTypeY(0),
-      mScrollSnapPointsX(nsStyleCoord(eStyleUnit_None)),
-      mScrollSnapPointsY(nsStyleCoord(eStyleUnit_None)) {
-
-    mScrollSnapDestinationX.mPercent = 0;
-    mScrollSnapDestinationX.mLength = nscoord(0.0f);
-    mScrollSnapDestinationX.mHasPercent = false;
-    mScrollSnapDestinationY.mPercent = 0;
-    mScrollSnapDestinationY.mLength = nscoord(0.0f);
-    mScrollSnapDestinationY.mHasPercent = false;
-  }
-
-  explicit ScrollbarStyles(const nsStyleDisplay* aDisplay);
-  ScrollbarStyles(uint8_t aH, uint8_t aV, const nsStyleDisplay* aDisplay);
-  ScrollbarStyles() {}
-  bool operator==(const ScrollbarStyles& aStyles) const {
-    return aStyles.mHorizontal == mHorizontal && aStyles.mVertical == mVertical &&
-           aStyles.mScrollBehavior == mScrollBehavior &&
-           aStyles.mScrollSnapTypeX == mScrollSnapTypeX &&
-           aStyles.mScrollSnapTypeY == mScrollSnapTypeY &&
-           aStyles.mScrollSnapPointsX == mScrollSnapPointsX &&
-           aStyles.mScrollSnapPointsY == mScrollSnapPointsY &&
-           aStyles.mScrollSnapDestinationX == mScrollSnapDestinationX &&
-           aStyles.mScrollSnapDestinationY == mScrollSnapDestinationY;
-  }
-  bool operator!=(const ScrollbarStyles& aStyles) const {
-    return !(*this == aStyles);
-  }
-  bool IsHiddenInBothDirections() const {
-    return mHorizontal == 1 &&
-           mVertical == 1;
-  }
-  bool IsSmoothScroll(dom::ScrollBehavior aBehavior) const {
-    return aBehavior == dom::ScrollBehavior::Smooth ||
-             (aBehavior == dom::ScrollBehavior::Auto &&
-               mScrollBehavior == 1);
-  }
-};
-
-}
-# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class mozIDOMWindowProxy;
-
-class nsIDocShell;
-
-class nsIContent;
-
-class nsIFrameLoader;
-
-class nsIPrincipal;
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIMessageListener : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult ReceiveMessage(void) = 0;
-
-};
-
-  template<typename T> struct nsIMessageListener::COMTypeInfo<nsIMessageListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageListener::COMTypeInfo<nsIMessageListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2b44eb57, 0xa9c6, 0x4773, { 0x9a, 0x1e, 0xfe, 0x08, 0x18, 0x73, 0x9a, 0x4c }};
-# 115 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIMessageListenerManager : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult AddMessageListener(const nsAString & messageName, nsIMessageListener *listener, bool listenWhenClosed) = 0;
-
-
-  virtual nsresult RemoveMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
-
-
-  virtual nsresult AddWeakMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
-
-
-  virtual nsresult RemoveWeakMessageListener(const nsAString & messageName, nsIMessageListener *listener) = 0;
-
-
-  virtual bool MarkForCC(void) = 0;
-
-};
-
-  template<typename T> struct nsIMessageListenerManager::COMTypeInfo<nsIMessageListenerManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageListenerManager::COMTypeInfo<nsIMessageListenerManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb949bfec, 0xbb7d, 0x47bc, { 0xb3, 0x87, 0xac, 0x6a, 0x9b, 0x65, 0x50, 0x72 }};
-# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIMessageSender : public nsIMessageListenerManager {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult SendAsyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JS::HandleValue transfers, JSContext* cx, uint8_t _argc) = 0;
-
-
-  virtual nsresult GetProcessMessageManager(nsIMessageSender * *aProcessMessageManager) = 0;
-
-};
-
-  template<typename T> struct nsIMessageSender::COMTypeInfo<nsIMessageSender, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageSender::COMTypeInfo<nsIMessageSender, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbb5d79e4, 0xe73c, 0x45e7, { 0x96, 0x51, 0x4d, 0x71, 0x8f, 0x4b, 0x99, 0x4c }};
-# 336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIMessageBroadcaster : public nsIMessageListenerManager {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult BroadcastAsyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, JSContext* cx, uint8_t _argc) = 0;
-
-
-  virtual nsresult GetChildCount(uint32_t *aChildCount) = 0;
-
-
-  virtual nsresult GetChildAt(uint32_t aIndex, nsIMessageListenerManager * *_retval) = 0;
-
-
-  virtual nsresult ReleaseCachedProcesses(void) = 0;
-
-};
-
-  template<typename T> struct nsIMessageBroadcaster::COMTypeInfo<nsIMessageBroadcaster, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageBroadcaster::COMTypeInfo<nsIMessageBroadcaster, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x4d7d62ad, 0x4725, 0x4f39, { 0x86, 0xcf, 0x8f, 0xb2, 0x2b, 0xf9, 0xc1, 0xd8 }};
-# 453 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsISyncMessageSender : public nsIMessageSender {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult SendSyncMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JSContext* cx, uint8_t _argc, JS::MutableHandleValue _retval) = 0;
-
-
-  virtual nsresult SendRpcMessage(const nsAString & messageName, JS::HandleValue obj, JS::HandleValue objects, nsIPrincipal *principal, JSContext* cx, uint8_t _argc, JS::MutableHandleValue _retval) = 0;
-
-};
-
-  template<typename T> struct nsISyncMessageSender::COMTypeInfo<nsISyncMessageSender, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISyncMessageSender::COMTypeInfo<nsISyncMessageSender, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0e602c9e, 0x1977, 0x422a, { 0xa8, 0xe4, 0xfe, 0x0d, 0x4a, 0x4f, 0x78, 0xd0 }};
-# 544 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIMessageManagerGlobal : public nsISyncMessageSender {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Dump(const nsAString & aStr) = 0;
-
-
-  virtual nsresult PrivateNoteIntentionalCrash(void) = 0;
-
-
-  virtual nsresult Atob(const nsAString & aAsciiString, nsAString & _retval) = 0;
-
-
-  virtual nsresult Btoa(const nsAString & aBase64Data, nsAString & _retval) = 0;
-
-};
-
-  template<typename T> struct nsIMessageManagerGlobal::COMTypeInfo<nsIMessageManagerGlobal, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIMessageManagerGlobal::COMTypeInfo<nsIMessageManagerGlobal, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x13f3555f, 0x769e, 0x44ea, { 0xb6, 0x07, 0x52, 0x39, 0x23, 0x0c, 0x31, 0x62 }};
-# 661 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIContentFrameMessageManager : public nsIMessageManagerGlobal {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetContent(mozIDOMWindowProxy * *aContent) = 0;
-
-
-  virtual nsresult GetDocShell(nsIDocShell * *aDocShell) = 0;
-
-};
-
-  template<typename T> struct nsIContentFrameMessageManager::COMTypeInfo<nsIContentFrameMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentFrameMessageManager::COMTypeInfo<nsIContentFrameMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x694e367c, 0xaa25, 0x4446, { 0x84, 0x99, 0x2c, 0x52, 0x7c, 0x4b, 0xd8, 0x38 }};
-# 752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIInProcessContentFrameMessageManager : public nsIContentFrameMessageManager {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsIContent * GetOwnerContent(void) = 0;
-
-
-  virtual void CacheFrameLoader(nsIFrameLoader *aFrameLoader) = 0;
-
-};
-
-  template<typename T> struct nsIInProcessContentFrameMessageManager::COMTypeInfo<nsIInProcessContentFrameMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIInProcessContentFrameMessageManager::COMTypeInfo<nsIInProcessContentFrameMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb39a3324, 0xb574, 0x4f85, { 0x8c, 0xdb, 0x27, 0x4d, 0x04, 0xf8, 0x07, 0xef }};
-# 843 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIContentProcessMessageManager : public nsIMessageManagerGlobal {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetInitialProcessData(JSContext* cx, JS::MutableHandleValue aInitialProcessData) = 0;
-
-};
-
-  template<typename T> struct nsIContentProcessMessageManager::COMTypeInfo<nsIContentProcessMessageManager, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIContentProcessMessageManager::COMTypeInfo<nsIContentProcessMessageManager, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x6d12e467, 0x2446, 0x46db, { 0x99, 0x65, 0xe4, 0xe9, 0x3c, 0xb8, 0x7c, 0xa5 }};
-# 921 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIFrameScriptLoader : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad, bool aRunInGlobalScope) = 0;
-
-
-  virtual nsresult RemoveDelayedFrameScript(const nsAString & aURL) = 0;
-
-
-  virtual nsresult GetDelayedFrameScripts(JSContext* cx, JS::MutableHandleValue _retval) = 0;
-
-};
-
-  template<typename T> struct nsIFrameScriptLoader::COMTypeInfo<nsIFrameScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFrameScriptLoader::COMTypeInfo<nsIFrameScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xbf61446b, 0xba24, 0x4b1d, { 0x88, 0xc7, 0x4f, 0x94, 0x72, 0x4b, 0x9c, 0xe1 }};
-# 1025 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIProcessScriptLoader : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult LoadProcessScript(const nsAString & aURL, bool aAllowDelayedLoad) = 0;
-
-
-  virtual nsresult RemoveDelayedProcessScript(const nsAString & aURL) = 0;
-
-
-  virtual nsresult GetDelayedProcessScripts(JSContext* cx, JS::MutableHandleValue _retval) = 0;
-
-};
-
-  template<typename T> struct nsIProcessScriptLoader::COMTypeInfo<nsIProcessScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIProcessScriptLoader::COMTypeInfo<nsIProcessScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x7e1e1a20, 0xb24f, 0x11e4, { 0xab, 0x27, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 }};
-# 1129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIMessageManager.h"
-class nsIGlobalProcessScriptLoader : public nsIProcessScriptLoader {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetInitialProcessData(JSContext* cx, JS::MutableHandleValue aInitialProcessData) = 0;
-
-};
-
-  template<typename T> struct nsIGlobalProcessScriptLoader::COMTypeInfo<nsIGlobalProcessScriptLoader, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIGlobalProcessScriptLoader::COMTypeInfo<nsIGlobalProcessScriptLoader, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x5b390753, 0xabb3, 0x49b0, { 0xae, 0x3b, 0xb8, 0x03, 0xda, 0xb5, 0x81, 0x44 }};
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h"
-namespace mozilla {
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AutoRestore.h"
-template<class T>
-class AutoRestore
-{
-private:
-  T& mLocation;
-  T mValue;
-
-public:
-  explicit AutoRestore(T& aValue )
-    : mLocation(aValue)
-    , mValue(aValue)
-  {
-    do { } while (0);
-  }
-  ~AutoRestore()
-  {
-    mLocation = mValue;
-  }
-  T SavedValue() const
-  {
-    return mValue;
-  }
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RestyleLogging.h" 2
-# 42 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
-extern "C" {
-# 91 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
-extern __attribute__((visibility("default"))) char* PR_GetEnv(const char *var);
-# 105 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
-extern __attribute__((visibility("default"))) char* PR_GetEnvSecure(const char *var);
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
-extern __attribute__((visibility("default"))) PRStatus PR_SetEnv(const char *string);
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nspr/prenv.h"
-extern __attribute__((visibility("default"))) char ** PR_DuplicateEnvironment(void);
-
-}
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILanguageAtomService.h" 1
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsILanguageAtomService.h"
-class nsILanguageAtomService : public nsISupports
-{
- public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-  virtual nsIAtom* LookupLanguage(const nsACString &aLanguage,
-                                  nsresult *aError = nullptr) = 0;
-  virtual already_AddRefed<nsIAtom>
-  LookupCharSet(const nsACString& aCharSet) = 0;
-
-  virtual nsIAtom* GetLocaleLanguage() = 0;
-
-  virtual nsIAtom* GetLanguageGroup(nsIAtom *aLanguage,
-                                    nsresult *aError = nullptr) = 0;
-};
-
-template<typename T> struct nsILanguageAtomService::COMTypeInfo<nsILanguageAtomService, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsILanguageAtomService::COMTypeInfo<nsILanguageAtomService, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xcb3892a0, 0x6a76, 0x461c, { 0xb0, 0x24, 0x23, 0x0e, 0xe3, 0xe0, 0x81, 0x1a }};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h" 2
-
-namespace mozilla {
-
-struct LangGroupFontPrefs {
-
-  LangGroupFontPrefs()
-    : mLangGroup(nullptr)
-    , mMinimumFontSize(0)
-    , mDefaultVariableFont(mozilla::eFamily_serif, 0)
-    , mDefaultFixedFont(mozilla::eFamily_monospace, 0)
-    , mDefaultSerifFont(mozilla::eFamily_serif, 0)
-    , mDefaultSansSerifFont(mozilla::eFamily_sans_serif, 0)
-    , mDefaultMonospaceFont(mozilla::eFamily_monospace, 0)
-    , mDefaultCursiveFont(mozilla::eFamily_cursive, 0)
-    , mDefaultFantasyFont(mozilla::eFamily_fantasy, 0)
-  {}
-
-  void Reset()
-  {
-
-    mNext = nullptr;
-
-
-    mLangGroup = nullptr;
-  }
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-    size_t n = 0;
-    LangGroupFontPrefs* curr = mNext;
-    while (curr) {
-      n += aMallocSizeOf(curr);
-
-
-
-
-
-
-      curr = curr->mNext;
-    }
-    return n;
-  }
-
-  nsCOMPtr<nsIAtom> mLangGroup;
-  nscoord mMinimumFontSize;
-  nsFont mDefaultVariableFont;
-  nsFont mDefaultFixedFont;
-  nsFont mDefaultSerifFont;
-  nsFont mDefaultSansSerifFont;
-  nsFont mDefaultMonospaceFont;
-  nsFont mDefaultCursiveFont;
-  nsFont mDefaultFantasyFont;
-  nsAutoPtr<LangGroupFontPrefs> mNext;
-};
-
-
-
-
-
-
-
-class StaticPresData
-{
-public:
-
-  static void Init();
-  static void Shutdown();
-
-
-
-  static StaticPresData* Get();
-
-
-
-
-
-  const nscoord* GetBorderWidthTable() { return mBorderWidthTable; }
-# 107 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
-  const LangGroupFontPrefs* GetFontPrefsForLangHelper(nsIAtom* aLanguage,
-                                                      const LangGroupFontPrefs* aPrefs) const;
-# 128 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StaticPresData.h"
-  const nsFont* GetDefaultFontHelper(uint8_t aFontID,
-                                     nsIAtom* aLanguage,
-                                     const LangGroupFontPrefs* aPrefs) const;
-
-
-
-
-
-  const nsFont* GetDefaultFont(uint8_t aFontID, nsIAtom* aLanguage) const
-  {
-    do { } while (0);
-    return GetDefaultFontHelper(aFontID, aLanguage, GetFontPrefsForLang(aLanguage));
-  }
-  const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom* aLanguage) const
-  {
-    do { } while (0);
-    return GetFontPrefsForLangHelper(aLanguage, &mStaticLangGroupFontPrefs);
-  }
-
-  void ResetCachedFontPrefs() { mStaticLangGroupFontPrefs.Reset(); }
-
-private:
-  StaticPresData();
-  ~StaticPresData() {}
-
-  nsCOMPtr<nsILanguageAtomService> mLangService;
-  nscoord mBorderWidthTable[3];
-  LangGroupFontPrefs mStaticLangGroupFontPrefs;
-};
-
-}
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h" 2
-
-
-class nsAString;
-class nsIPrintSettings;
-class nsDocShell;
-class nsIDocShell;
-class nsIDocument;
-class nsILanguageAtomService;
-class nsITheme;
-class nsIContent;
-class nsIFrame;
-class nsFrameManager;
-class nsILinkHandler;
-class nsIAtom;
-class nsIRunnable;
-class gfxUserFontEntry;
-class gfxUserFontSet;
-class gfxTextPerfMetrics;
-class nsPluginFrame;
-class nsTransitionManager;
-class nsAnimationManager;
-class nsRefreshDriver;
-class nsIWidget;
-class nsDeviceContext;
-class gfxMissingFontRecorder;
-
-namespace mozilla {
-class EffectCompositor;
-class EventStateManager;
-class CounterStyleManager;
-class RestyleManager;
-namespace layers {
-class ContainerLayer;
-class LayerManager;
-}
-namespace dom {
-class Element;
-}
-}
-
-
-enum nsPresContext_CachedBoolPrefType {
-  kPresContext_UseDocumentFonts = 1,
-  kPresContext_UnderlineLinks
-};
-
-
-enum nsPresContext_CachedIntPrefType {
-  kPresContext_ScrollbarSide = 1,
-  kPresContext_BidiDirection
-};
-
-
-
-const uint8_t kPresContext_DefaultVariableFont_ID = 0x00;
-const uint8_t kPresContext_DefaultFixedFont_ID = 0x01;
-# 119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-class nsRootPresContext;
-
-
-
-
-class nsPresContext : public nsIObserver,
-                      public mozilla::SupportsWeakPtr<nsPresContext> {
-public:
-  typedef mozilla::FramePropertyTable FramePropertyTable;
-  typedef mozilla::LangGroupFontPrefs LangGroupFontPrefs;
-  typedef mozilla::ScrollbarStyles ScrollbarStyles;
-  typedef mozilla::StaticPresData StaticPresData;
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  virtual nsresult Observe(nsISupports *aSubject, const char * aTopic, const char16_t * aData) override;
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "nsPresContext"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<nsPresContext>(p)->DeleteCycleCollectable(); } static nsPresContext* Downcast(nsISupports* s) { return static_cast<nsPresContext*>(static_cast<nsPresContext*>(s)); } static nsISupports* Upcast(nsPresContext *p) { return static_cast<nsISupports*>(static_cast<nsPresContext*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &nsPresContext::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  enum nsPresContextType {
-    eContext_Galley,
-    eContext_PrintPreview,
-    eContext_Print,
-    eContext_PageLayout
-  };
-
-  nsPresContext(nsIDocument* aDocument, nsPresContextType aType);
-
-
-
-
-  nsresult Init(nsDeviceContext* aDeviceContext);
-
-
-
-
-
-  void AttachShell(nsIPresShell* aShell, mozilla::StyleBackendType aBackendType);
-  void DetachShell();
-
-
-  nsPresContextType Type() const { return mType; }
-
-
-
-
-  nsIPresShell* PresShell() const
-  {
-    do { } while(0);
-    return mShell;
-  }
-
-  nsIPresShell* GetPresShell() const { return mShell; }
-
-
-
-
-
-  nsPresContext* GetParentPresContext();
-
-
-
-
-
-  nsPresContext* GetToplevelContentDocumentPresContext();
-# 192 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  nsIWidget* GetNearestWidget(nsPoint* aOffset = nullptr);
-
-
-
-
-
-  nsIWidget* GetRootWidget();
-
-
-
-
-
-
-  nsRootPresContext* GetRootPresContext();
-
-  virtual bool IsRoot() { return false; }
-
-  nsIDocument* Document() const
-  {
-      do { } while(0);
-
-
-      return mDocument;
-  }
-
-
-  mozilla::StyleSetHandle StyleSet() const { return GetPresShell()->StyleSet(); }
-
-  nsFrameManager* FrameManager()
-    { return PresShell()->FrameManager(); }
-
-  nsCSSFrameConstructor* FrameConstructor()
-    { return PresShell()->FrameConstructor(); }
-
-  mozilla::EffectCompositor* EffectCompositor() { return mEffectCompositor; }
-  nsTransitionManager* TransitionManager() { return mTransitionManager; }
-  nsAnimationManager* AnimationManager() { return mAnimationManager; }
-
-  nsRefreshDriver* RefreshDriver() { return mRefreshDriver; }
-
-  mozilla::RestyleManager* RestyleManager() {
-    do { } while (0);
-    return mRestyleManager;
-  }
-
-  mozilla::CounterStyleManager* CounterStyleManager() const {
-    return mCounterStyleManager;
-  }
-# 249 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void RebuildAllStyleData(nsChangeHint aExtraHint, nsRestyleHint aRestyleHint);
-
-
-
-
-  void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint,
-                                    nsRestyleHint aRestyleHint);
-# 277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void MediaFeatureValuesChanged(nsRestyleHint aRestyleHint,
-                                 nsChangeHint aChangeHint = nsChangeHint(0));
-
-
-
-
-
-  void MediaFeatureValuesChangedAllDocuments(nsRestyleHint aRestyleHint,
-                                             nsChangeHint aChangeHint = nsChangeHint(0));
-
-  void PostMediaFeatureValuesChangedEvent();
-  void HandleMediaFeatureValuesChangedEvent();
-  void FlushPendingMediaFeatureValuesChanged() {
-    if (mPendingMediaFeatureValuesChanged)
-      MediaFeatureValuesChanged(nsRestyleHint(0));
-  }
-
-
-
-
-
-
-  void SizeModeChanged(nsSizeMode aSizeMode);
-
-
-
-
-
-  nsCompatibility CompatibilityMode() const;
-
-
-
-
-  void CompatibilityModeChanged();
-
-
-
-
-  uint16_t ImageAnimationMode() const { return mImageAnimationMode; }
-  virtual void SetImageAnimationModeExternal(uint16_t aMode);
-  void SetImageAnimationModeInternal(uint16_t aMode);
-
-  void SetImageAnimationMode(uint16_t aMode)
-  { SetImageAnimationModeInternal(aMode); }
-# 329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  nsIAtom* Medium() {
-    if (!mIsEmulatingMedia)
-      return mMedium;
-    return mMediaEmulated;
-  }
-
-
-
-
-
-  void EmulateMedium(const nsAString& aMediaType);
-
-
-
-
-  void StopEmulatingMedium();
-
-  void* AllocateFromShell(size_t aSize)
-  {
-    if (mShell)
-      return mShell->AllocateMisc(aSize);
-    return nullptr;
-  }
-
-  void FreeToShell(size_t aSize, void* aFreeChunk)
-  {
-    do { } while(0);
-    if (mShell)
-      mShell->FreeMisc(aSize, aFreeChunk);
-  }
-
-
-
-
-
-
-
-  const nsFont* GetDefaultFont(uint8_t aFontID,
-                               nsIAtom *aLanguage) const
-  {
-    nsIAtom* lang = aLanguage ? aLanguage : mLanguage.get();
-    return StaticPresData::Get()->GetDefaultFontHelper(aFontID, lang,
-                                                       GetFontPrefsForLang(lang));
-  }
-
-
-
-  bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const
-  {
-
-
-    switch (aPrefType) {
-    case kPresContext_UseDocumentFonts:
-      return mUseDocumentFonts;
-    case kPresContext_UnderlineLinks:
-      return mUnderlineLinks;
-    default:
-      do { } while(0);
-    }
-
-    return false;
-  }
-
-
-
-  int32_t GetCachedIntPref(nsPresContext_CachedIntPrefType aPrefType) const
-  {
-
-
-    switch (aPrefType) {
-    case kPresContext_ScrollbarSide:
-      return mPrefScrollbarSide;
-    case kPresContext_BidiDirection:
-      return mPrefBidiDirection;
-    default:
-      do { } while(0);
-    }
-
-    return false;
-  }
-
-
-
-
-  nscolor DefaultColor() const { return mDefaultColor; }
-  nscolor DefaultBackgroundColor() const { return mBackgroundColor; }
-  nscolor DefaultLinkColor() const { return mLinkColor; }
-  nscolor DefaultActiveLinkColor() const { return mActiveLinkColor; }
-  nscolor DefaultVisitedLinkColor() const { return mVisitedLinkColor; }
-  nscolor FocusBackgroundColor() const { return mFocusBackgroundColor; }
-  nscolor FocusTextColor() const { return mFocusTextColor; }
-
-
-
-
-  nscolor BodyTextColor() const { return mBodyTextColor; }
-  void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }
-
-  bool GetUseFocusColors() const { return mUseFocusColors; }
-  uint8_t FocusRingWidth() const { return mFocusRingWidth; }
-  bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }
-  uint8_t GetFocusRingStyle() const { return mFocusRingStyle; }
-
-  void SetContainer(nsIDocShell* aContainer);
-
-  virtual nsISupports* GetContainerWeakExternal() const;
-  nsISupports* GetContainerWeakInternal() const;
-
-  nsISupports* GetContainerWeak() const
-  { return GetContainerWeakInternal(); }
-
-
-
-
-
-  nsIDocShell* GetDocShell() const;
-
-
-  void SetLinkHandler(nsILinkHandler* aHandler) { mLinkHandler = aHandler; }
-  nsILinkHandler* GetLinkHandler() { return mLinkHandler; }
-
-
-
-
-
-
-  virtual void Detach();
-
-
-
-
-
-
-
-  nsRect GetVisibleArea() const { return mVisibleArea; }
-
-
-
-
-
-  void SetVisibleArea(const nsRect& r) {
-    if (!r.IsEqualEdges(mVisibleArea)) {
-      mVisibleArea = r;
-
-      if (!IsPaginated() && HasCachedStyleData()) {
-        mPendingViewportChange = true;
-        PostMediaFeatureValuesChangedEvent();
-      }
-    }
-  }
-
-
-
-
-
-  bool IsPaginated() const { return mPaginated; }
-
-
-
-
-
-  void SetPaginatedScrolling(bool aResult);
-
-
-
-
-
-  bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }
-
-
-
-
-  nsSize GetPageSize() { return mPageSize; }
-  void SetPageSize(nsSize aSize) { mPageSize = aSize; }
-
-
-
-
-
-
-  bool IsRootPaginatedDocument() { return mIsRootPaginatedDocument; }
-  void SetIsRootPaginatedDocument(bool aIsRootPaginatedDocument)
-    { mIsRootPaginatedDocument = aIsRootPaginatedDocument; }
-
-
-
-
-
-
-
-  float GetPageScale() { return mPageScale; }
-  void SetPageScale(float aScale) { mPageScale = aScale; }
-# 530 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  float GetPrintPreviewScale() { return mPPScale; }
-  void SetPrintPreviewScale(float aScale) { mPPScale = aScale; }
-
-  nsDeviceContext* DeviceContext() const { return mDeviceContext; }
-  mozilla::EventStateManager* EventStateManager() { return mEventManager; }
-  nsIAtom* GetLanguageFromCharset() const { return mLanguage; }
-  already_AddRefed<nsIAtom> GetContentLanguage() const;
-
-
-
-
-
-  float GetSystemFontScale() const { return mSystemFontScale; }
-  void SetSystemFontScale(float aFontScale) {
-    do { } while (0);
-    if (aFontScale == mSystemFontScale || IsPrintingOrPrintPreview()) {
-      return;
-    }
-
-    mSystemFontScale = aFontScale;
-    UpdateEffectiveTextZoom();
-  }
-# 562 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  float TextZoom() const { return mTextZoom; }
-  void SetTextZoom(float aZoom) {
-    do { } while (0);
-    if (aZoom == mTextZoom)
-      return;
-
-    mTextZoom = aZoom;
-    UpdateEffectiveTextZoom();
-  }
-
-protected:
-  void UpdateEffectiveTextZoom();
-
-public:
-# 584 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  float EffectiveTextZoom() const { return mEffectiveTextZoom; }
-
-
-
-
-
-
-
-  int32_t MinFontSize(nsIAtom *aLanguage) const {
-    const LangGroupFontPrefs *prefs = GetFontPrefsForLang(aLanguage);
-    return std::max(mBaseMinFontSize, prefs->mMinimumFontSize);
-  }
-
-
-
-
-
-  int32_t BaseMinFontSize() const {
-    return mBaseMinFontSize;
-  }
-
-
-
-
-
-  void SetBaseMinFontSize(int32_t aMinFontSize) {
-    if (aMinFontSize == mBaseMinFontSize)
-      return;
-
-    mBaseMinFontSize = aMinFontSize;
-    if (HasCachedStyleData()) {
-
-
-      MediaFeatureValuesChanged(eRestyle_ForceDescendants,
-                                nsChangeHint(nsChangeHint(nsChangeHint_RepaintFrame | nsChangeHint_SyncFrameView | nsChangeHint_SchedulePaint) | nsChangeHint(nsChangeHint_NeedReflow | nsChangeHint_ReflowChangesSizeOrPosition| nsChangeHint_ClearAncestorIntrinsics | nsChangeHint_ClearDescendantIntrinsics | nsChangeHint_NeedDirtyReflow)));
-    }
-  }
-
-  float GetFullZoom() { return mFullZoom; }
-  void SetFullZoom(float aZoom);
-
-  float GetOverrideDPPX() { return mOverrideDPPX; }
-  void SetOverrideDPPX(float aDPPX);
-
-  nscoord GetAutoQualityMinFontSize() {
-    return DevPixelsToAppUnits(mAutoQualityMinFontSizePixelsPref);
-  }
-# 641 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  gfxSize ScreenSizeInchesForFontInflation(bool* aChanged = nullptr);
-
-  static int32_t AppUnitsPerCSSPixel() { return mozilla::AppUnitsPerCSSPixel(); }
-  int32_t AppUnitsPerDevPixel() const;
-  static int32_t AppUnitsPerCSSInch() { return mozilla::AppUnitsPerCSSInch(); }
-
-  static nscoord CSSPixelsToAppUnits(int32_t aPixels)
-  { return NSToCoordRoundWithClamp(float(aPixels) *
-             float(AppUnitsPerCSSPixel())); }
-
-  static nscoord CSSPixelsToAppUnits(float aPixels)
-  { return NSToCoordRoundWithClamp(aPixels *
-             float(AppUnitsPerCSSPixel())); }
-
-  static int32_t AppUnitsToIntCSSPixels(nscoord aAppUnits)
-  { return NSAppUnitsToIntPixels(aAppUnits,
-             float(AppUnitsPerCSSPixel())); }
-
-  static float AppUnitsToFloatCSSPixels(nscoord aAppUnits)
-  { return NSAppUnitsToFloatPixels(aAppUnits,
-             float(AppUnitsPerCSSPixel())); }
-
-  static double AppUnitsToDoubleCSSPixels(nscoord aAppUnits)
-  { return NSAppUnitsToDoublePixels(aAppUnits,
-             double(AppUnitsPerCSSPixel())); }
-
-  nscoord DevPixelsToAppUnits(int32_t aPixels) const
-  { return NSIntPixelsToAppUnits(aPixels, AppUnitsPerDevPixel()); }
-
-  int32_t AppUnitsToDevPixels(nscoord aAppUnits) const
-  { return NSAppUnitsToIntPixels(aAppUnits,
-             float(AppUnitsPerDevPixel())); }
-
-  float AppUnitsToFloatDevPixels(nscoord aAppUnits)
-  { return aAppUnits / float(AppUnitsPerDevPixel()); }
-
-  int32_t CSSPixelsToDevPixels(int32_t aPixels)
-  { return AppUnitsToDevPixels(CSSPixelsToAppUnits(aPixels)); }
-
-  float CSSPixelsToDevPixels(float aPixels)
-  {
-    return NSAppUnitsToFloatPixels(CSSPixelsToAppUnits(aPixels),
-                                   float(AppUnitsPerDevPixel()));
-  }
-
-  int32_t DevPixelsToIntCSSPixels(int32_t aPixels)
-  { return AppUnitsToIntCSSPixels(DevPixelsToAppUnits(aPixels)); }
-
-  float DevPixelsToFloatCSSPixels(int32_t aPixels)
-  { return AppUnitsToFloatCSSPixels(DevPixelsToAppUnits(aPixels)); }
-
-  mozilla::CSSToLayoutDeviceScale CSSToDevPixelScale() const
-  {
-    return mozilla::CSSToLayoutDeviceScale(
-        float(AppUnitsPerCSSPixel()) / float(AppUnitsPerDevPixel()));
-  }
-
-
-  nscoord GfxUnitsToAppUnits(gfxFloat aGfxUnits) const;
-
-  gfxFloat AppUnitsToGfxUnits(nscoord aAppUnits) const;
-
-  gfxRect AppUnitsToGfxUnits(const nsRect& aAppRect) const
-  { return gfxRect(AppUnitsToGfxUnits(aAppRect.x),
-                   AppUnitsToGfxUnits(aAppRect.y),
-                   AppUnitsToGfxUnits(aAppRect.width),
-                   AppUnitsToGfxUnits(aAppRect.height)); }
-
-  static nscoord CSSTwipsToAppUnits(float aTwips)
-  { return NSToCoordRoundWithClamp(
-      mozilla::AppUnitsPerCSSInch() * NSTwipsToUnits((aTwips), 1.0f / 72.0f)); }
-
-
-  static nsMargin CSSTwipsToAppUnits(const nsIntMargin &marginInTwips)
-  { return nsMargin(CSSTwipsToAppUnits(float(marginInTwips.top)),
-                    CSSTwipsToAppUnits(float(marginInTwips.right)),
-                    CSSTwipsToAppUnits(float(marginInTwips.bottom)),
-                    CSSTwipsToAppUnits(float(marginInTwips.left))); }
-
-  static nscoord CSSPointsToAppUnits(float aPoints)
-  { return NSToCoordRound(aPoints * mozilla::AppUnitsPerCSSInch() /
-                          72.0f); }
-
-  nscoord RoundAppUnitsToNearestDevPixels(nscoord aAppUnits) const
-  { return DevPixelsToAppUnits(AppUnitsToDevPixels(aAppUnits)); }
-# 737 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  nsIContent* UpdateViewportScrollbarStylesOverride();
-  const ScrollbarStyles& GetViewportScrollbarStylesOverride()
-  {
-    return mViewportStyleScrollbar;
-  }
-
-
-
-
-
-  bool ElementWouldPropagateScrollbarStyles(mozilla::dom::Element* aElement);
-
-
-
-
-  bool GetBackgroundImageDraw() const { return mDrawImageBackground; }
-  void SetBackgroundImageDraw(bool aCanDraw)
-  {
-    mDrawImageBackground = aCanDraw;
-  }
-
-  bool GetBackgroundColorDraw() const { return mDrawColorBackground; }
-  void SetBackgroundColorDraw(bool aCanDraw)
-  {
-    mDrawColorBackground = aCanDraw;
-  }
-# 772 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  bool BidiEnabled() const { return BidiEnabledInternal(); }
-
-
-
-  virtual bool BidiEnabledExternal() const;
-  bool BidiEnabledInternal() const;
-
-
-
-
-
-
-  void SetBidiEnabled() const;
-# 800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void SetVisualMode(bool aIsVisual)
-  {
-    mIsVisual = aIsVisual;
-  }
-
-
-
-
-
-
-  bool IsVisualMode() const { return mIsVisual; }
-
-  enum class InteractionType : uint32_t {
-    eClickInteraction,
-    eKeyInteraction,
-    eMouseMoveInteraction,
-    eScrollInteraction
-  };
-
-  void RecordInteractionTime(InteractionType aType,
-                             const mozilla::TimeStamp& aTimeStamp);
-
-  void DisableInteractionTimeRecording()
-  {
-    mInteractionTimeEnabled = false;
-  }
-
-
-
-
-
-
-  void SetBidi(uint32_t aBidiOptions,
-                           bool aForceRestyle = false);
-
-
-
-
-
-
-  uint32_t GetBidi() const;
-
-
-
-
-  void SetIsRenderingOnlySelection(bool aResult)
-  {
-    mIsRenderingOnlySelection = aResult;
-  }
-
-  bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }
-
-  bool IsTopLevelWindowInactive();
-
-
-
-
-  nsITheme* GetTheme();
-
-
-
-
-
-
-
-  void ThemeChanged();
-
-
-
-
-
-
-
-  void UIResolutionChanged();
-
-
-
-
-  void UIResolutionChangedSync();
-
-
-
-
-  void SysColorChanged();
-
-
-  void SetPrintSettings(nsIPrintSettings *aPrintSettings);
-
-  nsIPrintSettings* GetPrintSettings() { return mPrintSettings; }
-
-
-  FramePropertyTable* PropertyTable() { return &mPropertyTable; }
-
-
-
-
-
-  bool EnsureVisible();
-
-
-  void CountReflows(const char * aName,
-                                nsIFrame * aFrame);
-
-
-  void RestyledElement() {
-    ++mElementsRestyled;
-  }
-  void ConstructedFrame() {
-    ++mFramesConstructed;
-  }
-  void ReflowedFrame() {
-    ++mFramesReflowed;
-  }
-
-  uint64_t ElementsRestyledCount() {
-    return mElementsRestyled;
-  }
-  uint64_t FramesConstructedCount() {
-    return mFramesConstructed;
-  }
-  uint64_t FramesReflowedCount() {
-    return mFramesReflowed;
-  }
-
-
-
-
-
-  void SetTelemetryScrollY(nscoord aScrollY)
-  {
-    nscoord delta = abs(aScrollY - mTelemetryScrollLastY);
-    mTelemetryScrollLastY = aScrollY;
-
-    mTelemetryScrollTotalY += delta;
-    if (aScrollY > mTelemetryScrollMaxY) {
-      mTelemetryScrollMaxY = aScrollY;
-    }
-  }
-  nscoord TelemetryScrollMaxY() const
-  {
-    return mTelemetryScrollMaxY;
-  }
-  nscoord TelemetryScrollTotalY() const
-  {
-    return mTelemetryScrollTotalY;
-  }
-
-  static nscoord GetBorderWidthForKeyword(unsigned int aBorderWidthKeyword)
-  {
-
-
-    static const nscoord kBorderWidths[] = {
-      CSSPixelsToAppUnits(1),
-      CSSPixelsToAppUnits(3),
-      CSSPixelsToAppUnits(5)
-    };
-    do { } while (0);
-
-    return kBorderWidths[aBorderWidthKeyword];
-  }
-
-  gfxTextPerfMetrics *GetTextPerfMetrics() { return mTextPerf; }
-
-  bool IsDynamic() { return (mType == eContext_PageLayout || mType == eContext_Galley); }
-  bool IsScreen() { return (mMedium == nsGkAtoms::screen ||
-                              mType == eContext_PageLayout ||
-                              mType == eContext_PrintPreview); }
-  bool IsPrintingOrPrintPreview() { return (mType == eContext_Print || mType == eContext_PrintPreview); }
-
-
-  bool IsChrome() const { return mIsChrome; }
-  bool IsChromeOriginImage() const { return mIsChromeOriginImage; }
-  void UpdateIsChrome();
-
-
-  bool HasAuthorSpecifiedRules(const nsIFrame *aFrame,
-                               uint32_t ruleTypeMask) const;
-
-
-  bool UseDocumentColors() const {
-    do { } while (0);
-
-    return mUseDocumentColors;
-  }
-
-
-  void SetPaintFlashing(bool aPaintFlashing) {
-    mPaintFlashing = aPaintFlashing;
-    mPaintFlashingInitialized = true;
-  }
-
-
-
-  bool GetPaintFlashing() const;
-
-  bool SuppressingResizeReflow() const { return mSuppressResizeReflow; }
-
-  gfxUserFontSet* GetUserFontSet(bool aFlushUserFontSet = true);
-
-
-
-
-  void UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont = nullptr);
-
-  gfxMissingFontRecorder *MissingFontRecorder() { return mMissingFonts; }
-  void NotifyMissingFonts();
-
-  void FlushCounterStyles();
-  void RebuildCounterStyles();
-
-
-
-
-  void EnsureSafeToHandOutCSSRules();
-
-
-
-
-
-  void NotifyInvalidation(uint64_t aTransactionId, const nsRect& aRect);
-
-  void NotifyInvalidation(uint64_t aTransactionId, const nsIntRect& aRect);
-  void NotifyDidPaintForSubtree(uint64_t aTransactionId = 0,
-                                const mozilla::TimeStamp& aTimeStamp = mozilla::TimeStamp());
-  void FireDOMPaintEvent(nsTArray<nsRect>* aList, uint64_t aTransactionId,
-                         mozilla::TimeStamp aTimeStamp = mozilla::TimeStamp());
-
-
-
-  static void NotifySubDocInvalidation(mozilla::layers::ContainerLayer* aContainer,
-                                       const nsIntRegion& aRegion);
-  void SetNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
-  static void ClearNotifySubDocInvalidationData(mozilla::layers::ContainerLayer* aContainer);
-  bool IsDOMPaintEventPending();
-
-
-
-
-  uint64_t GetRestyleGeneration() const;
-
-
-
-
-  bool HasPendingRestyleOrReflow();
-
-
-
-
-
-  void NotifyFontFaceSetOnRefresh();
-# 1060 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void ReflowStarted(bool aInterruptible);
-
-
-
-
-  class InterruptPreventer;
-  friend class InterruptPreventer;
-  class InterruptPreventer {
-  public:
-    explicit InterruptPreventer(nsPresContext* aCtx) :
-      mCtx(aCtx),
-      mInterruptsEnabled(aCtx->mInterruptsEnabled),
-      mHasPendingInterrupt(aCtx->mHasPendingInterrupt)
-    {
-      mCtx->mInterruptsEnabled = false;
-      mCtx->mHasPendingInterrupt = false;
-    }
-    ~InterruptPreventer() {
-      mCtx->mInterruptsEnabled = mInterruptsEnabled;
-      mCtx->mHasPendingInterrupt = mHasPendingInterrupt;
-    }
-
-  private:
-    nsPresContext* mCtx;
-    bool mInterruptsEnabled;
-    bool mHasPendingInterrupt;
-  };
-# 1096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  bool CheckForInterrupt(nsIFrame* aFrame);
-
-
-
-
-  bool HasPendingInterrupt() { return mHasPendingInterrupt; }
-
-
-
-
-
-  void SetPendingInterruptFromTest() { mPendingInterruptFromTest = true; }
-
-
-
-
-
-
-
-  nsIFrame* GetPrimaryFrameFor(nsIContent* aContent);
-
-  void NotifyDestroyingFrame(nsIFrame* aFrame)
-  {
-    PropertyTable()->DeleteAllFor(aFrame);
-  }
-
-  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
-    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-  }
-
-  bool IsRootContentDocument() const;
-
-  bool HadNonBlankPaint() const {
-    return mHadNonBlankPaint;
-  }
-
-  void NotifyNonBlankPaint();
-
-  bool IsGlyph() const {
-    return mIsGlyph;
-  }
-
-  void SetIsGlyph(bool aValue) {
-    mIsGlyph = aValue;
-  }
-
-  bool UsesRootEMUnits() const {
-    return mUsesRootEMUnits;
-  }
-
-  void SetUsesRootEMUnits(bool aValue) {
-    mUsesRootEMUnits = aValue;
-  }
-
-  bool UsesExChUnits() const {
-    return mUsesExChUnits;
-  }
-
-  void SetUsesExChUnits(bool aValue) {
-    mUsesExChUnits = aValue;
-  }
-
-  bool UsesViewportUnits() const {
-    return mUsesViewportUnits;
-  }
-
-  void SetUsesViewportUnits(bool aValue) {
-    mUsesViewportUnits = aValue;
-  }
-
-
-
-
-  bool ExistThrottledUpdates() const {
-    return mExistThrottledUpdates;
-  }
-
-  void SetExistThrottledUpdates(bool aExistThrottledUpdates) {
-    mExistThrottledUpdates = aExistThrottledUpdates;
-  }
-
-  bool IsDeviceSizePageSize();
-
-  bool HasWarnedAboutPositionedTableParts() const {
-    return mHasWarnedAboutPositionedTableParts;
-  }
-
-  void SetHasWarnedAboutPositionedTableParts() {
-    mHasWarnedAboutPositionedTableParts = true;
-  }
-
-  bool HasWarnedAboutTooLargeDashedOrDottedRadius() const {
-    return mHasWarnedAboutTooLargeDashedOrDottedRadius;
-  }
-
-  void SetHasWarnedAboutTooLargeDashedOrDottedRadius() {
-    mHasWarnedAboutTooLargeDashedOrDottedRadius = true;
-  }
-
-protected:
-  friend class nsRunnableMethod<nsPresContext>;
-  void ThemeChangedInternal();
-  void SysColorChangedInternal();
-
-
-  void UIResolutionChangedInternal();
-
-
-
-  void UIResolutionChangedInternalScale(double aScale);
-
-
-
-
-  static bool
-  UIResolutionChangedSubdocumentCallback(nsIDocument* aDocument, void* aData);
-
-  void SetImgAnimations(nsIContent *aParent, uint16_t aMode);
-  void SetSMILAnimations(nsIDocument *aDoc, uint16_t aNewMode,
-                                     uint16_t aOldMode);
-  void GetDocumentColorPreferences();
-
-  void PreferenceChanged(const char* aPrefName);
-  static void PrefChangedCallback(const char*, void*);
-
-  void UpdateAfterPreferencesChanged();
-  static void PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
-
-  void GetUserPreferences();
-
-
-
-
-
-  const LangGroupFontPrefs* GetFontPrefsForLang(nsIAtom *aLanguage) const
-  {
-    nsIAtom* lang = aLanguage ? aLanguage : mLanguage.get();
-    return StaticPresData::Get()->GetFontPrefsForLangHelper(lang, &mLangGroupFontPrefs);
-  }
-
-  void UpdateCharSet(const nsCString& aCharSet);
-
-  static bool NotifyDidPaintSubdocumentCallback(nsIDocument* aDocument, void* aData);
-
-public:
-  void DoChangeCharSet(const nsCString& aCharSet);
-
-
-
-
-  bool MayHavePaintEventListener();
-
-
-
-
-
-
-  bool MayHavePaintEventListenerInSubDocument();
-# 1264 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void InvalidatePaintedLayers();
-
-protected:
-
-  void Destroy();
-
-  void AppUnitsPerDevPixelChanged();
-
-  void HandleRebuildCounterStyles() {
-    mPostedFlushCounterStyles = false;
-    FlushCounterStyles();
-  }
-
-  bool HavePendingInputEvent();
-
-
-  bool HasCachedStyleData();
-
-
-
-  already_AddRefed<nsITimer> CreateTimer(nsTimerCallbackFunc aCallback,
-                                         const char* aName,
-                                         uint32_t aDelay);
-
-
-
-
-
-  nsPresContextType mType;
-
-
-  nsIPresShell* mShell;
-  nsCOMPtr<nsIDocument> mDocument;
-  RefPtr<nsDeviceContext> mDeviceContext;
-
-
-
-
-  RefPtr<mozilla::EventStateManager> mEventManager;
-  RefPtr<nsRefreshDriver> mRefreshDriver;
-  RefPtr<mozilla::EffectCompositor> mEffectCompositor;
-  RefPtr<nsTransitionManager> mTransitionManager;
-  RefPtr<nsAnimationManager> mAnimationManager;
-  RefPtr<mozilla::RestyleManager> mRestyleManager;
-  RefPtr<mozilla::CounterStyleManager> mCounterStyleManager;
-  nsIAtom* mMedium;
-  nsCOMPtr<nsIAtom> mMediaEmulated;
-
-
-
-  nsILinkHandler* mLinkHandler;
-
-
-
-
-
-
-  nsCOMPtr<nsIAtom> mLanguage;
-
-public:
-
-
-
-
-
-  bool mInflationDisabledForShrinkWrap;
-
-protected:
-
-  mozilla::WeakPtr<nsDocShell> mContainer;
-
-
-  int32_t mBaseMinFontSize;
-  float mSystemFontScale;
-  float mTextZoom;
-  float mEffectiveTextZoom;
-  float mFullZoom;
-  float mOverrideDPPX;
-  gfxSize mLastFontInflationScreenSize;
-
-  int32_t mCurAppUnitsPerDevPixel;
-  int32_t mAutoQualityMinFontSizePixelsPref;
-
-  nsCOMPtr<nsITheme> mTheme;
-  nsCOMPtr<nsILanguageAtomService> mLangService;
-  nsCOMPtr<nsIPrintSettings> mPrintSettings;
-  nsCOMPtr<nsITimer> mPrefChangedTimer;
-
-  FramePropertyTable mPropertyTable;
-
-  struct TransactionInvalidations {
-    uint64_t mTransactionId;
-    nsTArray<nsRect> mInvalidations;
-  };
-  AutoTArray<TransactionInvalidations, 4> mTransactions;
-
-
-  nsAutoPtr<gfxTextPerfMetrics> mTextPerf;
-
-  nsAutoPtr<gfxMissingFontRecorder> mMissingFonts;
-
-  nsRect mVisibleArea;
-  nsSize mPageSize;
-  float mPageScale;
-  float mPPScale;
-
-  nscolor mDefaultColor;
-  nscolor mBackgroundColor;
-
-  nscolor mLinkColor;
-  nscolor mActiveLinkColor;
-  nscolor mVisitedLinkColor;
-
-  nscolor mFocusBackgroundColor;
-  nscolor mFocusTextColor;
-
-  nscolor mBodyTextColor;
-
-  ScrollbarStyles mViewportStyleScrollbar;
-  uint8_t mFocusRingWidth;
-
-  bool mExistThrottledUpdates;
-
-  uint16_t mImageAnimationMode;
-  uint16_t mImageAnimationModePref;
-
-
-
-
-
-
-  LangGroupFontPrefs mLangGroupFontPrefs;
-
-  nscoord mBorderWidthTable[3];
-
-  uint32_t mInterruptChecksToSkip;
-
-
-
-  uint64_t mElementsRestyled;
-  uint64_t mFramesConstructed;
-  uint64_t mFramesReflowed;
-
-  mozilla::TimeStamp mReflowStartTime;
-
-
-
-  mozilla::TimeStamp mFirstNonBlankPaintTime;
-  mozilla::TimeStamp mFirstClickTime;
-  mozilla::TimeStamp mFirstKeyTime;
-  mozilla::TimeStamp mFirstMouseMoveTime;
-  mozilla::TimeStamp mFirstScrollTime;
-  bool mInteractionTimeEnabled;
-
-
-  mozilla::TimeStamp mLastStyleUpdateForAllAnimations;
-
-  nscoord mTelemetryScrollLastY;
-  nscoord mTelemetryScrollMaxY;
-  nscoord mTelemetryScrollTotalY;
-
-  unsigned mHasPendingInterrupt : 1;
-  unsigned mPendingInterruptFromTest : 1;
-  unsigned mInterruptsEnabled : 1;
-  unsigned mUseDocumentFonts : 1;
-  unsigned mUseDocumentColors : 1;
-  unsigned mUnderlineLinks : 1;
-  unsigned mSendAfterPaintToContent : 1;
-  unsigned mUseFocusColors : 1;
-  unsigned mFocusRingOnAnything : 1;
-  unsigned mFocusRingStyle : 1;
-  unsigned mDrawImageBackground : 1;
-  unsigned mDrawColorBackground : 1;
-  unsigned mNeverAnimate : 1;
-  unsigned mIsRenderingOnlySelection : 1;
-  unsigned mPaginated : 1;
-  unsigned mCanPaginatedScroll : 1;
-  unsigned mDoScaledTwips : 1;
-  unsigned mIsRootPaginatedDocument : 1;
-  unsigned mPrefBidiDirection : 1;
-  unsigned mPrefScrollbarSide : 2;
-  unsigned mPendingSysColorChanged : 1;
-  unsigned mPendingThemeChanged : 1;
-  unsigned mPendingUIResolutionChanged : 1;
-  unsigned mPendingMediaFeatureValuesChanged : 1;
-  unsigned mPrefChangePendingNeedsReflow : 1;
-  unsigned mIsEmulatingMedia : 1;
-
-
-  unsigned mIsGlyph : 1;
-
-
-  unsigned mUsesRootEMUnits : 1;
-
-  unsigned mUsesExChUnits : 1;
-
-  unsigned mUsesViewportUnits : 1;
-
-
-  unsigned mPendingViewportChange : 1;
-
-
-  unsigned mCounterStylesDirty : 1;
-
-  unsigned mPostedFlushCounterStyles: 1;
-
-
-
-  unsigned mSuppressResizeReflow : 1;
-
-  unsigned mIsVisual : 1;
-
-  unsigned mFireAfterPaintEvents : 1;
-
-  unsigned mIsChrome : 1;
-  unsigned mIsChromeOriginImage : 1;
-
-
-
-  mutable unsigned mPaintFlashing : 1;
-  mutable unsigned mPaintFlashingInitialized : 1;
-
-  unsigned mHasWarnedAboutPositionedTableParts : 1;
-
-  unsigned mHasWarnedAboutTooLargeDashedOrDottedRadius : 1;
-
-
-  unsigned mQuirkSheetAdded : 1;
-
-
-  unsigned mNeedsPrefUpdate : 1;
-
-
-  unsigned mHadNonBlankPaint : 1;
-# 1509 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-protected:
-
-  virtual ~nsPresContext();
-
-  nscolor MakeColorPref(const nsString& aColor);
-
-  void LastRelease();
-# 1527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-};
-
-class nsRootPresContext final : public nsPresContext {
-public:
-  nsRootPresContext(nsIDocument* aDocument, nsPresContextType aType);
-  virtual ~nsRootPresContext();
-  virtual void Detach() override;
-
-
-
-
-
-  void EnsureEventualDidPaintEvent(uint64_t aTransactionId);
-
-
-
-
-
-  void CancelDidPaintTimers(uint64_t aTransactionId);
-
-
-
-
-  void CancelAllDidPaintTimers();
-
-
-
-
-
-
-
-  void RegisterPluginForGeometryUpdates(nsIContent* aPlugin);
-
-
-
-
-
-  void UnregisterPluginForGeometryUpdates(nsIContent* aPlugin);
-
-  bool NeedToComputePluginGeometryUpdates()
-  {
-    return mRegisteredPlugins.Count() > 0;
-  }
-# 1581 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsPresContext.h"
-  void ComputePluginGeometryUpdates(nsIFrame* aFrame,
-                                    nsDisplayListBuilder* aBuilder,
-                                    nsDisplayList* aList);
-
-
-
-
-
-
-  void ApplyPluginGeometryUpdates();
-
-
-
-
-
-  void CollectPluginGeometryUpdates(mozilla::layers::LayerManager* aLayerManager);
-
-  virtual bool IsRoot() override { return true; }
-
-
-
-
-
-
-  void IncrementDOMGeneration() { mDOMGeneration++; }
-
-
-
-
-  uint32_t GetDOMGeneration() { return mDOMGeneration; }
-
-
-
-
-
-
-  void AddWillPaintObserver(nsIRunnable* aRunnable);
-
-
-
-
-  void FlushWillPaintObservers();
-
-  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
-
-protected:
-
-
-
-  void InitApplyPluginGeometryTimer();
-
-
-
-  void CancelApplyPluginGeometryTimer();
-
-  class RunWillPaintObservers : public mozilla::Runnable {
-  public:
-    explicit RunWillPaintObservers(nsRootPresContext* aPresContext)
-      : Runnable("nsPresContextType::RunWillPaintObservers")
-      , mPresContext(aPresContext) {}
-    void Revoke() { mPresContext = nullptr; }
-    virtual nsresult Run() override
-    {
-      if (mPresContext) {
-        mPresContext->FlushWillPaintObservers();
-      }
-      return NS_OK;
-    }
-
-    nsRootPresContext* mPresContext;
-  };
-
-  friend class nsPresContext;
-
-  struct NotifyDidPaintTimer {
-    uint64_t mTransactionId;
-    nsCOMPtr<nsITimer> mTimer;
-  };
-  AutoTArray<NotifyDidPaintTimer, 4> mNotifyDidPaintTimers;
-
-  nsCOMPtr<nsITimer> mApplyPluginGeometryTimer;
-  nsTHashtable<nsRefPtrHashKey<nsIContent> > mRegisteredPlugins;
-  nsTArray<nsCOMPtr<nsIRunnable> > mWillPaintObservers;
-  nsRevocableEventPtr<RunWillPaintObservers> mWillPaintFallbackEvent;
-  uint32_t mDOMGeneration;
-};
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h"
-class gfxContext;
-class nsPresContext;
-class nsRegion;
-
-namespace mozilla {
-namespace gfx {
-class DrawTarget;
-class Path;
-}
-}
-
-namespace mozilla {
-
-
-
-
-
-
-
-class DisplayItemClip {
-  typedef mozilla::gfx::Color Color;
-  typedef mozilla::gfx::DrawTarget DrawTarget;
-  typedef mozilla::gfx::Path Path;
-
-public:
-  struct RoundedRect {
-    nsRect mRect;
-
-    nscoord mRadii[8];
-
-    RoundedRect operator+(const nsPoint& aOffset) const {
-      RoundedRect r = *this;
-      r.mRect += aOffset;
-      return r;
-    }
-    bool operator==(const RoundedRect& aOther) const {
-      if (!mRect.IsEqualInterior(aOther.mRect)) {
-        return false;
-      }
-
-      int32_t corner54 = mozilla::eCornerTopLeftX; for (mozilla::HalfCorner corner; corner54 <= mozilla::eCornerBottomLeftY && (corner = mozilla::HalfCorner(corner54), true); ++corner54) {
-        if (mRadii[corner] != aOther.mRadii[corner]) {
-          return false;
-        }
-      }
-      return true;
-    }
-    bool operator!=(const RoundedRect& aOther) const {
-      return !(*this == aOther);
-    }
-  };
-
-
-  DisplayItemClip() : mHaveClipRect(false) {}
-
-  void SetTo(const nsRect& aRect);
-  void SetTo(const nsRect& aRect, const nscoord* aRadii);
-  void SetTo(const nsRect& aRect, const nsRect& aRoundedRect, const nscoord* aRadii);
-  void IntersectWith(const DisplayItemClip& aOther);
-
-
-
-
-  void ApplyTo(gfxContext* aContext, nsPresContext* aPresContext,
-               uint32_t aBegin = 0, uint32_t aEnd = (4294967295U));
-
-  void ApplyRectTo(gfxContext* aContext, int32_t A2D) const;
-
-
-
-  void ApplyRoundedRectClipsTo(gfxContext* aContext, int32_t A2DPRInt32,
-                               uint32_t aBegin, uint32_t aEnd) const;
-
-
-  void FillIntersectionOfRoundedRectClips(gfxContext* aContext,
-                                          const Color& aColor,
-                                          int32_t aAppUnitsPerDevPixel,
-                                          uint32_t aBegin,
-                                          uint32_t aEnd) const;
-
-  already_AddRefed<Path> MakeRoundedRectPath(DrawTarget& aDrawTarget,
-                                                  int32_t A2D,
-                                                  const RoundedRect &aRoundRect) const;
-
-
-
-
-
-
-  bool MayIntersect(const nsRect& aRect) const;
-
-
-
-
-  nsRect ApproximateIntersectInward(const nsRect& aRect) const;
-# 117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/DisplayItemClip.h"
-  bool ComputeRegionInClips(DisplayItemClip* aOldClip,
-                            const nsPoint& aShift,
-                            nsRegion* aCombined) const;
-
-
-
-
-
-  bool IsRectClippedByRoundedCorner(const nsRect& aRect) const;
-
-
-
-  bool IsRectAffectedByClip(const nsRect& aRect) const;
-  bool IsRectAffectedByClip(const nsIntRect& aRect, float aXScale, float aYScale, int32_t A2D) const;
-
-
-  nsRect NonRoundedIntersection() const;
-
-
-
-  nsRect ApplyNonRoundedIntersection(const nsRect& aRect) const;
-
-
-  void RemoveRoundedCorners();
-
-
-
-  void AddOffsetAndComputeDifference(uint32_t aStart, const nsPoint& aPoint, const nsRect& aBounds,
-                                     const DisplayItemClip& aOther, uint32_t aOtherStart, const nsRect& aOtherBounds,
-                                     nsRegion* aDifference);
-
-  bool operator==(const DisplayItemClip& aOther) const {
-    return mHaveClipRect == aOther.mHaveClipRect &&
-           (!mHaveClipRect || mClipRect.IsEqualInterior(aOther.mClipRect)) &&
-           mRoundedClipRects == aOther.mRoundedClipRects;
-  }
-  bool operator!=(const DisplayItemClip& aOther) const {
-    return !(*this == aOther);
-  }
-
-  bool HasClip() const { return mHaveClipRect; }
-  const nsRect& GetClipRect() const
-  {
-    do { } while(0);
-    return mClipRect;
-  }
-
-  void MoveBy(nsPoint aPoint);
-
-  nsCString ToString() const;
-
-
-
-
-
-  uint32_t GetCommonRoundedRectCount(const DisplayItemClip& aOther,
-                                     uint32_t aMax) const;
-  uint32_t GetRoundedRectCount() const { return mRoundedClipRects.Length(); }
-  void AppendRoundedRects(nsTArray<RoundedRect>* aArray, uint32_t aCount) const;
-
-  static const DisplayItemClip& NoClip();
-
-  static void Shutdown();
-
-private:
-  nsRect mClipRect;
-  nsTArray<RoundedRect> mRoundedClipRects;
-
-
-  bool mHaveClipRect;
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h"
-class nsScrollbarFrame;
-class nsIFrame;
-
-class nsIScrollbarMediator : public nsQueryFrame
-{
-public:
-  static const nsQueryFrame::FrameIID kFrameIID = nsQueryFrame::nsIScrollbarMediator_id; typedef nsIScrollbarMediator Has_NS_DECL_QUERYFRAME_TARGET;
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollbarMediator.h"
-  enum ScrollSnapMode { DISABLE_SNAP, ENABLE_SNAP };
-
-
-
-
-
-
-  virtual void ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection,
-                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
-  virtual void ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection,
-                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
-  virtual void ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection,
-                            ScrollSnapMode aSnap = DISABLE_SNAP) = 0;
-
-
-
-
-
-
-  virtual void RepeatButtonScroll(nsScrollbarFrame* aScrollbar) = 0;
-
-
-
-
-
-
-
-  virtual void ThumbMoved(nsScrollbarFrame* aScrollbar,
-                          nscoord aOldPos,
-                          nscoord aNewPos) = 0;
-
-
-
-
-  virtual void ScrollbarReleased(nsScrollbarFrame* aScrollbar) = 0;
-  virtual void VisibilityChanged(bool aVisible) = 0;
-
-
-
-
-
-  virtual nsIFrame* GetScrollbarBox(bool aVertical) = 0;
-
-
-
-
-  virtual void ScrollbarActivityStarted() const = 0;
-  virtual void ScrollbarActivityStopped() const = 0;
-
-  virtual bool IsScrollbarOnRight() const = 0;
-
-
-
-
-
-  virtual bool ShouldSuppressScrollbarRepaints() const = 0;
-};
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 1 3
-# 37 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-namespace __cxx11 {
-# 64 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
-    {
-      struct __xfer_bufptrs;
-    public:
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-
-
-      typedef _Alloc allocator_type;
-      typedef typename traits_type::int_type int_type;
-      typedef typename traits_type::pos_type pos_type;
-      typedef typename traits_type::off_type off_type;
-
-      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
-      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
-      typedef typename __string_type::size_type __size_type;
-
-    protected:
-
-      ios_base::openmode _M_mode;
-
-
-      __string_type _M_string;
-
-    public:
-# 99 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
-      : __streambuf_type(), _M_mode(__mode), _M_string()
-      { }
-# 112 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_stringbuf(const __string_type& __str,
-        ios_base::openmode __mode = ios_base::in | ios_base::out)
-      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
-      { _M_stringbuf_init(__mode); }
-
-
-      basic_stringbuf(const basic_stringbuf&) = delete;
-
-      basic_stringbuf(basic_stringbuf&& __rhs)
-      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
-      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
-
-
-
-      basic_stringbuf&
-      operator=(const basic_stringbuf&) = delete;
-
-      basic_stringbuf&
-      operator=(basic_stringbuf&& __rhs)
-      {
- __xfer_bufptrs __st{__rhs, this};
- const __streambuf_type& __base = __rhs;
- __streambuf_type::operator=(__base);
- this->pubimbue(__rhs.getloc());
- _M_mode = __rhs._M_mode;
- _M_string = std::move(__rhs._M_string);
- __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
- return *this;
-      }
-
-      void
-      swap(basic_stringbuf& __rhs)
-      {
- __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
- __xfer_bufptrs __r_st{__rhs, this};
- __streambuf_type& __base = __rhs;
- __streambuf_type::swap(__base);
- __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
- std::swap(_M_mode, __rhs._M_mode);
- std::swap(_M_string, __rhs._M_string);
-      }
-# 165 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      __string_type
-      str() const
-      {
- __string_type __ret;
- if (this->pptr())
-   {
-
-     if (this->pptr() > this->egptr())
-       __ret = __string_type(this->pbase(), this->pptr());
-     else
-        __ret = __string_type(this->pbase(), this->egptr());
-   }
- else
-   __ret = _M_string;
- return __ret;
-      }
-# 189 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      void
-      str(const __string_type& __s)
-      {
-
-
- _M_string.assign(__s.data(), __s.size());
- _M_stringbuf_init(_M_mode);
-      }
-
-    protected:
-
-      void
-      _M_stringbuf_init(ios_base::openmode __mode)
-      {
- _M_mode = __mode;
- __size_type __len = 0;
- if (_M_mode & (ios_base::ate | ios_base::app))
-   __len = _M_string.size();
- _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
-      }
-
-      virtual streamsize
-      showmanyc()
-      {
- streamsize __ret = -1;
- if (_M_mode & ios_base::in)
-   {
-     _M_update_egptr();
-     __ret = this->egptr() - this->gptr();
-   }
- return __ret;
-      }
-
-      virtual int_type
-      underflow();
-
-      virtual int_type
-      pbackfail(int_type __c = traits_type::eof());
-
-      virtual int_type
-      overflow(int_type __c = traits_type::eof());
-# 242 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      virtual __streambuf_type*
-      setbuf(char_type* __s, streamsize __n)
-      {
- if (__s && __n >= 0)
-   {
-
-
-
-
-
-
-     _M_string.clear();
-
-
-     _M_sync(__s, __n, 0);
-   }
- return this;
-      }
-
-      virtual pos_type
-      seekoff(off_type __off, ios_base::seekdir __way,
-       ios_base::openmode __mode = ios_base::in | ios_base::out);
-
-      virtual pos_type
-      seekpos(pos_type __sp,
-       ios_base::openmode __mode = ios_base::in | ios_base::out);
-
-
-
-
-      void
-      _M_sync(char_type* __base, __size_type __i, __size_type __o);
-
-
-
-      void
-      _M_update_egptr()
-      {
- const bool __testin = _M_mode & ios_base::in;
- if (this->pptr() && this->pptr() > this->egptr())
-   {
-     if (__testin)
-       this->setg(this->eback(), this->gptr(), this->pptr());
-     else
-       this->setg(this->pptr(), this->pptr(), this->pptr());
-   }
-      }
-
-
-
-      void
-      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
-
-    private:
-
-
-
-
-      struct __xfer_bufptrs
-      {
- __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
- : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
- {
-   const _CharT* __str = __from._M_string.data();
-   if (__from.eback())
-     {
-     _M_goff[0] = __from.eback() - __str;
-     _M_goff[1] = __from.gptr() - __str;
-     _M_goff[2] = __from.egptr() - __str;
-     }
-   if (__from.pbase())
-     {
-       _M_poff[0] = __from.pbase() - __str;
-       _M_poff[1] = __from.pptr() - __from.pbase();
-       _M_poff[2] = __from.epptr() - __str;
-     }
- }
-
- ~__xfer_bufptrs()
- {
-   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
-   if (_M_goff[0] != -1)
-     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
-   if (_M_poff[0] != -1)
-     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
- }
-
- basic_stringbuf* _M_to;
- off_type _M_goff[3];
- off_type _M_poff[3];
-      };
-# 343 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
-      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
-      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
-      { }
-
-    };
-# 366 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    class basic_istringstream : public basic_istream<_CharT, _Traits>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-
-
-      typedef _Alloc allocator_type;
-      typedef typename traits_type::int_type int_type;
-      typedef typename traits_type::pos_type pos_type;
-      typedef typename traits_type::off_type off_type;
-
-
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
-      typedef basic_istream<char_type, traits_type> __istream_type;
-
-    private:
-      __stringbuf_type _M_stringbuf;
-
-    public:
-# 402 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_istringstream(ios_base::openmode __mode = ios_base::in)
-      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
-      { this->init(&_M_stringbuf); }
-# 420 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_istringstream(const __string_type& __str,
-     ios_base::openmode __mode = ios_base::in)
-      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
-      { this->init(&_M_stringbuf); }
-
-
-
-
-
-
-
-      ~basic_istringstream()
-      { }
-
-
-      basic_istringstream(const basic_istringstream&) = delete;
-
-      basic_istringstream(basic_istringstream&& __rhs)
-      : __istream_type(std::move(__rhs)),
-      _M_stringbuf(std::move(__rhs._M_stringbuf))
-      { __istream_type::set_rdbuf(&_M_stringbuf); }
-
-
-
-      basic_istringstream&
-      operator=(const basic_istringstream&) = delete;
-
-      basic_istringstream&
-      operator=(basic_istringstream&& __rhs)
-      {
- __istream_type::operator=(std::move(__rhs));
- _M_stringbuf = std::move(__rhs._M_stringbuf);
- return *this;
-      }
-
-      void
-      swap(basic_istringstream& __rhs)
-      {
- __istream_type::swap(__rhs);
- _M_stringbuf.swap(__rhs._M_stringbuf);
-      }
-# 471 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      __stringbuf_type*
-      rdbuf() const
-      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
-
-
-
-
-
-      __string_type
-      str() const
-      { return _M_stringbuf.str(); }
-
-
-
-
-
-
-
-      void
-      str(const __string_type& __s)
-      { _M_stringbuf.str(__s); }
-    };
-# 510 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-  template <typename _CharT, typename _Traits, typename _Alloc>
-    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-
-
-      typedef _Alloc allocator_type;
-      typedef typename traits_type::int_type int_type;
-      typedef typename traits_type::pos_type pos_type;
-      typedef typename traits_type::off_type off_type;
-
-
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
-      typedef basic_ostream<char_type, traits_type> __ostream_type;
-
-    private:
-      __stringbuf_type _M_stringbuf;
-
-    public:
-# 546 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
-      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
-      { this->init(&_M_stringbuf); }
-# 564 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_ostringstream(const __string_type& __str,
-     ios_base::openmode __mode = ios_base::out)
-      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
-      { this->init(&_M_stringbuf); }
-
-
-
-
-
-
-
-      ~basic_ostringstream()
-      { }
-
-
-      basic_ostringstream(const basic_ostringstream&) = delete;
-
-      basic_ostringstream(basic_ostringstream&& __rhs)
-      : __ostream_type(std::move(__rhs)),
-      _M_stringbuf(std::move(__rhs._M_stringbuf))
-      { __ostream_type::set_rdbuf(&_M_stringbuf); }
-
-
-
-      basic_ostringstream&
-      operator=(const basic_ostringstream&) = delete;
-
-      basic_ostringstream&
-      operator=(basic_ostringstream&& __rhs)
-      {
- __ostream_type::operator=(std::move(__rhs));
- _M_stringbuf = std::move(__rhs._M_stringbuf);
- return *this;
-      }
-
-      void
-      swap(basic_ostringstream& __rhs)
-      {
- __ostream_type::swap(__rhs);
- _M_stringbuf.swap(__rhs._M_stringbuf);
-      }
-# 615 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      __stringbuf_type*
-      rdbuf() const
-      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
-
-
-
-
-
-      __string_type
-      str() const
-      { return _M_stringbuf.str(); }
-
-
-
-
-
-
-
-      void
-      str(const __string_type& __s)
-      { _M_stringbuf.str(__s); }
-    };
-# 654 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-  template <typename _CharT, typename _Traits, typename _Alloc>
-    class basic_stringstream : public basic_iostream<_CharT, _Traits>
-    {
-    public:
-
-      typedef _CharT char_type;
-      typedef _Traits traits_type;
-
-
-      typedef _Alloc allocator_type;
-      typedef typename traits_type::int_type int_type;
-      typedef typename traits_type::pos_type pos_type;
-      typedef typename traits_type::off_type off_type;
-
-
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
-      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
-      typedef basic_iostream<char_type, traits_type> __iostream_type;
-
-    private:
-      __stringbuf_type _M_stringbuf;
-
-    public:
-# 689 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
-      : __iostream_type(), _M_stringbuf(__m)
-      { this->init(&_M_stringbuf); }
-# 705 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      explicit
-      basic_stringstream(const __string_type& __str,
-    ios_base::openmode __m = ios_base::out | ios_base::in)
-      : __iostream_type(), _M_stringbuf(__str, __m)
-      { this->init(&_M_stringbuf); }
-
-
-
-
-
-
-
-      ~basic_stringstream()
-      { }
-
-
-      basic_stringstream(const basic_stringstream&) = delete;
-
-      basic_stringstream(basic_stringstream&& __rhs)
-      : __iostream_type(std::move(__rhs)),
-      _M_stringbuf(std::move(__rhs._M_stringbuf))
-      { __iostream_type::set_rdbuf(&_M_stringbuf); }
-
-
-
-      basic_stringstream&
-      operator=(const basic_stringstream&) = delete;
-
-      basic_stringstream&
-      operator=(basic_stringstream&& __rhs)
-      {
- __iostream_type::operator=(std::move(__rhs));
- _M_stringbuf = std::move(__rhs._M_stringbuf);
- return *this;
-      }
-
-      void
-      swap(basic_stringstream& __rhs)
-      {
- __iostream_type::swap(__rhs);
- _M_stringbuf.swap(__rhs._M_stringbuf);
-      }
-# 756 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 3
-      __stringbuf_type*
-      rdbuf() const
-      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
-
-
-
-
-
-      __string_type
-      str() const
-      { return _M_stringbuf.str(); }
-
-
-
-
-
-
-
-      void
-      str(const __string_type& __s)
-      { _M_stringbuf.str(__s); }
-    };
-
-
-
-  template <class _CharT, class _Traits, class _Allocator>
-    inline void
-    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
-  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
-    { __x.swap(__y); }
-
-
-  template <class _CharT, class _Traits, class _Allocator>
-    inline void
-    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
-  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
-    { __x.swap(__y); }
-
-
-  template <class _CharT, class _Traits, class _Allocator>
-    inline void
-    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
-  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
-    { __x.swap(__y); }
-
-
-  template <class _CharT, class _Traits, class _Allocator>
-    inline void
-    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
-  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
-    { __x.swap(__y); }
-
-
-}
-
-}
-
-
-# 1 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 1 3
-# 38 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template <class _CharT, class _Traits, class _Alloc>
-    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    pbackfail(int_type __c)
-    {
-      int_type __ret = traits_type::eof();
-      if (this->eback() < this->gptr())
- {
-
-
-   const bool __testeof = traits_type::eq_int_type(__c, __ret);
-   if (!__testeof)
-     {
-       const bool __testeq = traits_type::eq(traits_type::
-          to_char_type(__c),
-          this->gptr()[-1]);
-       const bool __testout = this->_M_mode & ios_base::out;
-       if (__testeq || __testout)
-  {
-    this->gbump(-1);
-    if (!__testeq)
-      *this->gptr() = traits_type::to_char_type(__c);
-    __ret = __c;
-  }
-     }
-   else
-     {
-       this->gbump(-1);
-       __ret = traits_type::not_eof(__c);
-     }
- }
-      return __ret;
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    overflow(int_type __c)
-    {
-      const bool __testout = this->_M_mode & ios_base::out;
-      if (__builtin_expect(!__testout, false))
- return traits_type::eof();
-
-      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
-      if (__builtin_expect(__testeof, false))
- return traits_type::not_eof(__c);
-
-      const __size_type __capacity = _M_string.capacity();
-      const __size_type __max_size = _M_string.max_size();
-      const bool __testput = this->pptr() < this->epptr();
-      if (__builtin_expect(!__testput && __capacity == __max_size, false))
- return traits_type::eof();
-
-
-
-      const char_type __conv = traits_type::to_char_type(__c);
-      if (!__testput)
- {
-# 110 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/bits/sstream.tcc" 3
-   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
-       __size_type(512));
-   const __size_type __len = std::min(__opt_len, __max_size);
-   __string_type __tmp;
-   __tmp.reserve(__len);
-   if (this->pbase())
-     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
-   __tmp.push_back(__conv);
-   _M_string.swap(__tmp);
-   _M_sync(const_cast<char_type*>(_M_string.data()),
-    this->gptr() - this->eback(), this->pptr() - this->pbase());
- }
-      else
- *this->pptr() = __conv;
-      this->pbump(1);
-      return __c;
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    underflow()
-    {
-      int_type __ret = traits_type::eof();
-      const bool __testin = this->_M_mode & ios_base::in;
-      if (__testin)
- {
-
-   _M_update_egptr();
-
-   if (this->gptr() < this->egptr())
-     __ret = traits_type::to_int_type(*this->gptr());
- }
-      return __ret;
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
-    {
-      pos_type __ret = pos_type(off_type(-1));
-      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
-      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
-      const bool __testboth = __testin && __testout && __way != ios_base::cur;
-      __testin &= !(__mode & ios_base::out);
-      __testout &= !(__mode & ios_base::in);
-
-
-
-      const char_type* __beg = __testin ? this->eback() : this->pbase();
-      if ((__beg || !__off) && (__testin || __testout || __testboth))
- {
-   _M_update_egptr();
-
-   off_type __newoffi = __off;
-   off_type __newoffo = __newoffi;
-   if (__way == ios_base::cur)
-     {
-       __newoffi += this->gptr() - __beg;
-       __newoffo += this->pptr() - __beg;
-     }
-   else if (__way == ios_base::end)
-     __newoffo = __newoffi += this->egptr() - __beg;
-
-   if ((__testin || __testboth)
-       && __newoffi >= 0
-       && this->egptr() - __beg >= __newoffi)
-     {
-       this->setg(this->eback(), this->eback() + __newoffi,
-    this->egptr());
-       __ret = pos_type(__newoffi);
-     }
-   if ((__testout || __testboth)
-       && __newoffo >= 0
-       && this->egptr() - __beg >= __newoffo)
-     {
-       _M_pbump(this->pbase(), this->epptr(), __newoffo);
-       __ret = pos_type(__newoffo);
-     }
- }
-      return __ret;
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    seekpos(pos_type __sp, ios_base::openmode __mode)
-    {
-      pos_type __ret = pos_type(off_type(-1));
-      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
-      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
-
-      const char_type* __beg = __testin ? this->eback() : this->pbase();
-      if ((__beg || !off_type(__sp)) && (__testin || __testout))
- {
-   _M_update_egptr();
-
-   const off_type __pos(__sp);
-   const bool __testpos = (0 <= __pos
-      && __pos <= this->egptr() - __beg);
-   if (__testpos)
-     {
-       if (__testin)
-  this->setg(this->eback(), this->eback() + __pos,
-      this->egptr());
-       if (__testout)
-  _M_pbump(this->pbase(), this->epptr(), __pos);
-       __ret = __sp;
-     }
- }
-      return __ret;
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    void
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    _M_sync(char_type* __base, __size_type __i, __size_type __o)
-    {
-      const bool __testin = _M_mode & ios_base::in;
-      const bool __testout = _M_mode & ios_base::out;
-      char_type* __endg = __base + _M_string.size();
-      char_type* __endp = __base + _M_string.capacity();
-
-      if (__base != _M_string.data())
- {
-
-   __endg += __i;
-   __i = 0;
-   __endp = __endg;
- }
-
-      if (__testin)
- this->setg(__base, __base + __i, __endg);
-      if (__testout)
- {
-   _M_pbump(__base, __endp, __o);
-
-
-
-   if (!__testin)
-     this->setg(__endg, __endg, __endg);
- }
-    }
-
-  template <class _CharT, class _Traits, class _Alloc>
-    void
-    basic_stringbuf<_CharT, _Traits, _Alloc>::
-    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
-    {
-      this->setp(__pbeg, __pend);
-      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
- {
-   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
-   __off -= __gnu_cxx::__numeric_traits<int>::__max;
- }
-      this->pbump(__off);
-    }
-
-
-
-
-  extern template class basic_stringbuf<char>;
-  extern template class basic_istringstream<char>;
-  extern template class basic_ostringstream<char>;
-  extern template class basic_stringstream<char>;
-
-
-  extern template class basic_stringbuf<wchar_t>;
-  extern template class basic_istringstream<wchar_t>;
-  extern template class basic_ostringstream<wchar_t>;
-  extern template class basic_stringstream<wchar_t>;
-
-
-
-
-}
-# 814 "/usr/lib/gcc/x86_64-redhat-linux/6.3.1/../../../../include/c++/6.3.1/sstream" 2 3
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 2
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/LoggingConstants.h" 1
-
-
-
-
-
-
-
-
-namespace mozilla {
-namespace gfx {
-
-
-
-
-const int LOG_CRITICAL = 1;
-const int LOG_WARNING = 2;
-const int LOG_DEBUG = 3;
-const int LOG_DEBUG_PRLOG = 4;
-const int LOG_EVERYTHING = 5;
-
-
-
-
-const int LOG_DEFAULT = LOG_CRITICAL;
-
-
-}
-}
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h" 2
-
-
-extern mozilla::LogModule* GetGFX2DLog();
-
-
-namespace mozilla {
-namespace gfx {
-
-
-inline mozilla::LogLevel PRLogLevelForLevel(int aLevel) {
-  switch (aLevel) {
-  case LOG_CRITICAL:
-    return LogLevel::Error;
-  case LOG_WARNING:
-    return LogLevel::Warning;
-  case LOG_DEBUG:
-    return LogLevel::Debug;
-  case LOG_DEBUG_PRLOG:
-    return LogLevel::Debug;
-  case LOG_EVERYTHING:
-    return LogLevel::Error;
-  }
-  return LogLevel::Debug;
-}
-
-
-class LoggingPrefs
-{
-public:
-
-
-
-
-
-  static int32_t sGfxLogLevel;
-};
-# 92 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-enum class LogReason : int {
-  MustBeMoreThanThis = -1,
-
-
-  D3D11InvalidCallDeviceRemoved = 0,
-  D3D11InvalidCall,
-  D3DLockTimeout,
-  D3D10FinalizeFrame,
-  D3D11FinalizeFrame,
-  D3D10SyncLock,
-  D3D11SyncLock,
-  D2D1NoWriteMap,
-  JobStatusError,
-  FilterInputError,
-  FilterInputData,
-  FilterInputRect,
-  FilterInputSet,
-  FilterInputFormat,
-  FilterNodeD2D1Target,
-  FilterNodeD2D1Backend,
-  SourceSurfaceIncompatible,
-  GlyphAllocFailedCairo,
-  GlyphAllocFailedCG,
-  InvalidRect,
-  CannotDraw3D,
-  IncompatibleBasicTexturedEffect,
-  InvalidFont,
-  PAllocTextureBackendMismatch,
-  GetFontFileDataFailed,
-  MessageChannelCloseFailure,
-  MessageChannelInvalidHandle,
-  TextureAliveAfterShutdown,
-  InvalidContext,
-  InvalidCommandList,
-  AsyncTransactionTimeout,
-  TextureCreation,
-  InvalidCacheSurface,
-  AlphaWithBasicClient,
-  UnbalancedClipStack,
-  ProcessingError,
-  InvalidDrawTarget,
-  NativeFontResourceNotFound,
-
-  MustBeLessThanThis = 101,
-};
-
-struct BasicLogger
-{
-
-
-
-  static bool ShouldOutputMessage(int aLevel) {
-    if (LoggingPrefs::sGfxLogLevel >= aLevel) {
-
-
-
-
-      if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
-        return true;
-      } else
-
-      if ((LoggingPrefs::sGfxLogLevel >= LOG_DEBUG_PRLOG) ||
-                 (aLevel < LOG_DEBUG)) {
-        return true;
-      }
-
-    }
-    return false;
-  }
-
-
-  static void CrashAction(LogReason aReason) {}
-
-  static void OutputMessage(const std::string &aString,
-                            int aLevel,
-                            bool aNoNewline) {
-# 177 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-    if (LoggingPrefs::sGfxLogLevel >= aLevel) {
-
-
-
-
-      if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) {
-        do { if (mozilla::detail::log_test(GetGFX2DLog(), PRLogLevelForLevel(aLevel))) { mozilla::detail::log_print(GetGFX2DLog(), PRLogLevelForLevel(aLevel), "%s%s", aString.c_str(), aNoNewline ? "" : "\n"); } } while (0);
-      } else
-
-      if ((LoggingPrefs::sGfxLogLevel >= LOG_DEBUG_PRLOG) ||
-                 (aLevel < LOG_DEBUG)) {
-        printf("%s%s", aString.c_str(), aNoNewline ? "" : "\n");
-      }
-
-    }
-  }
-};
-
-struct CriticalLogger {
-  static void OutputMessage(const std::string &aString, int aLevel, bool aNoNewline);
-  static void CrashAction(LogReason aReason);
-};
-
-
-
-
-
-typedef mozilla::Tuple<int32_t,std::string,double> LoggingRecordEntry;
-
-
-
-typedef std::vector<LoggingRecordEntry> LoggingRecord;
-class LogForwarder {
-public:
-  virtual ~LogForwarder() {}
-  virtual void Log(const std::string &aString) = 0;
-  virtual void CrashAction(LogReason aReason) = 0;
-  virtual bool UpdateStringsVector(const std::string& aString) = 0;
-
-
-  virtual LoggingRecord LoggingRecordCopy() = 0;
-};
-
-class NoLog
-{
-public:
-  NoLog() {}
-  ~NoLog() {}
-
-
-               NoLog(const NoLog&) {}
-
-  template<typename T>
-  NoLog &operator <<(const T &aLogText) { return *this; }
-};
-
-enum class LogOptions : int {
-  NoNewline = 0x01,
-  AutoPrefix = 0x02,
-  AssertOnCall = 0x04,
-  CrashAction = 0x08,
-};
-
-template<typename T>
-struct Hexa {
-  explicit Hexa(T aVal) : mVal(aVal) {}
-  T mVal;
-};
-template<typename T>
-Hexa<T> hexa(T val) { return Hexa<T>(val); }
-
-template<int L, typename Logger = BasicLogger>
-class Log
-{
-public:
-
-
-  static int DefaultOptions(bool aWithAssert = true) {
-    return (int(LogOptions::AutoPrefix) |
-            (aWithAssert ? int(LogOptions::AssertOnCall) : 0));
-  }
-
-
-
-
-
-  explicit Log(int aOptions = Log::DefaultOptions(L == LOG_CRITICAL),
-               LogReason aReason = LogReason::MustBeMoreThanThis)
-  : mOptions(0)
-  , mLogIt(false)
-  {
-    Init(aOptions, BasicLogger::ShouldOutputMessage(L), aReason);
-  }
-
-  ~Log() {
-    Flush();
-  }
-
-  void Flush() {
-    if ((__builtin_expect(!!(!LogIt()), 1))) return;
-
-    std::string str = mMessage.str();
-    if (!str.empty()) {
-      WriteLog(str);
-    }
-    mMessage.str("");
-  }
-
-  Log &operator <<(char aChar) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aChar;
-    }
-    return *this;
-  }
-  Log &operator <<(const std::string &aLogText) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aLogText;
-    }
-    return *this;
-  }
-  Log &operator <<(const char aStr[]) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << static_cast<const char*>(aStr);
-    }
-    return *this;
-  }
-  Log &operator <<(bool aBool) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << (aBool ? "true" : "false");
-    }
-    return *this;
-  }
-  Log &operator <<(int aInt) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aInt;
-    }
-    return *this;
-  }
-  Log &operator <<(unsigned int aInt) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aInt;
-    }
-    return *this;
-  }
-  Log &operator <<(long aLong) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aLong;
-    }
-    return *this;
-  }
-  Log &operator <<(unsigned long aLong) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aLong;
-    }
-    return *this;
-  }
-  Log &operator <<(long long aLong) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aLong;
-    }
-    return *this;
-  }
-  Log &operator <<(unsigned long long aLong) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aLong;
-    }
-    return *this;
-  }
-  Log &operator <<(Float aFloat) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aFloat;
-    }
-    return *this;
-  }
-  Log &operator <<(double aDouble) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << aDouble;
-    }
-    return *this;
-  }
-  template <typename T, typename Sub, typename Coord>
-  Log &operator <<(const BasePoint<T, Sub, Coord>& aPoint) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << "Point" << aPoint;
-    }
-    return *this;
-  }
-  template <typename T, typename Sub>
-  Log &operator <<(const BaseSize<T, Sub>& aSize) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << "Size(" << aSize.width << "," << aSize.height << ")";
-    }
-    return *this;
-  }
-  template <typename T, typename Sub, typename Point, typename SizeT, typename Margin>
-  Log &operator <<(const BaseRect<T, Sub, Point, SizeT, Margin>& aRect) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << "Rect" << aRect;
-    }
-    return *this;
-  }
-  Log &operator<<(const Matrix& aMatrix) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << "Matrix(" << aMatrix._11 << " " << aMatrix._12 << " ; " << aMatrix._21 << " " << aMatrix._22 << " ; " << aMatrix._31 << " " << aMatrix._32 << ")";
-    }
-    return *this;
-  }
-  template<typename T>
-  Log &operator<<(Hexa<T> aHex) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      mMessage << std::showbase << std::hex
-               << aHex.mVal
-               << std::noshowbase << std::dec;
-    }
-    return *this;
-  }
-
-  Log& operator<<(SurfaceFormat aFormat) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      switch(aFormat) {
-        case SurfaceFormat::B8G8R8A8:
-          mMessage << "SurfaceFormat::B8G8R8A8";
-          break;
-        case SurfaceFormat::B8G8R8X8:
-          mMessage << "SurfaceFormat::B8G8R8X8";
-          break;
-        case SurfaceFormat::R8G8B8A8:
-          mMessage << "SurfaceFormat::R8G8B8A8";
-          break;
-        case SurfaceFormat::R8G8B8X8:
-          mMessage << "SurfaceFormat::R8G8B8X8";
-          break;
-        case SurfaceFormat::R5G6B5_UINT16:
-          mMessage << "SurfaceFormat::R5G6B5_UINT16";
-          break;
-        case SurfaceFormat::A8:
-          mMessage << "SurfaceFormat::A8";
-          break;
-        case SurfaceFormat::YUV:
-          mMessage << "SurfaceFormat::YUV";
-          break;
-        case SurfaceFormat::UNKNOWN:
-          mMessage << "SurfaceFormat::UNKNOWN";
-          break;
-        default:
-          mMessage << "Invalid SurfaceFormat (" << (int)aFormat << ")";
-          break;
-      }
-    }
-    return *this;
-  }
-
-  Log& operator<<(SurfaceType aType) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      switch(aType) {
-        case SurfaceType::DATA:
-          mMessage << "SurfaceType::DATA";
-          break;
-        case SurfaceType::D2D1_BITMAP:
-          mMessage << "SurfaceType::D2D1_BITMAP";
-          break;
-        case SurfaceType::D2D1_DRAWTARGET:
-          mMessage << "SurfaceType::D2D1_DRAWTARGET";
-          break;
-        case SurfaceType::CAIRO:
-          mMessage << "SurfaceType::CAIRO";
-          break;
-        case SurfaceType::CAIRO_IMAGE:
-          mMessage << "SurfaceType::CAIRO_IMAGE";
-          break;
-        case SurfaceType::COREGRAPHICS_IMAGE:
-          mMessage << "SurfaceType::COREGRAPHICS_IMAGE";
-          break;
-        case SurfaceType::COREGRAPHICS_CGCONTEXT:
-          mMessage << "SurfaceType::COREGRAPHICS_CGCONTEXT";
-          break;
-        case SurfaceType::SKIA:
-          mMessage << "SurfaceType::SKIA";
-          break;
-        case SurfaceType::DUAL_DT:
-          mMessage << "SurfaceType::DUAL_DT";
-          break;
-        case SurfaceType::D2D1_1_IMAGE:
-          mMessage << "SurfaceType::D2D1_1_IMAGE";
-          break;
-        case SurfaceType::RECORDING:
-          mMessage << "SurfaceType::RECORDING";
-          break;
-        case SurfaceType::TILED:
-          mMessage << "SurfaceType::TILED";
-          break;
-        case SurfaceType::DATA_SHARED:
-          mMessage << "SurfaceType::DATA_SHARED";
-          break;
-        default:
-          mMessage << "Invalid SurfaceType (" << (int)aType << ")";
-          break;
-      }
-    }
-    return *this;
-  }
-
-  inline bool LogIt() const { return mLogIt; }
-  inline bool NoNewline() const { return mOptions & int(LogOptions::NoNewline); }
-  inline bool AutoPrefix() const { return mOptions & int(LogOptions::AutoPrefix); }
-  inline bool ValidReason() const { return (int)mReason > (int)LogReason::MustBeMoreThanThis && (int)mReason < (int)LogReason::MustBeLessThanThis; }
-
-
-
-               Log(const Log& log) { Init(log.mOptions, false, log.mReason); }
-
-private:
-
-  void Init(int aOptions, bool aLogIt, LogReason aReason) {
-    mOptions = aOptions;
-    mReason = aReason;
-    mLogIt = aLogIt;
-    if (mLogIt) {
-      if (AutoPrefix()) {
-        if (mOptions & int(LogOptions::AssertOnCall)) {
-          mMessage << "[GFX" << L;
-        } else {
-          mMessage << "[GFX" << L << "-";
-        }
-      }
-      if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
-        mMessage << " " << (int)mReason;
-      }
-      if (AutoPrefix()) {
-        mMessage << "]: ";
-      }
-    }
-  }
-
-  void WriteLog(const std::string &aString) {
-    if ((__builtin_expect(!!(LogIt()), 0))) {
-      Logger::OutputMessage(aString, L, NoNewline());
-# 522 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-      if ((mOptions & int(LogOptions::CrashAction)) && ValidReason()) {
-        Logger::CrashAction(mReason);
-      }
-    }
-  }
-
-  std::stringstream mMessage;
-  int mOptions;
-  LogReason mReason;
-  bool mLogIt;
-};
-
-typedef Log<LOG_DEBUG> DebugLog;
-typedef Log<LOG_WARNING> WarningLog;
-typedef Log<LOG_CRITICAL, CriticalLogger> CriticalLog;
-# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-inline bool MOZ2D_error_if_impl(bool aCondition, const char* aExpr,
-                                const char* aFile, int32_t aLine)
-{
-  if ((__builtin_expect(!!(aCondition), 0))) {
-    mozilla::gfx::CriticalLog() << aExpr << " at " << aFile << ":" << aLine;
-  }
-  return aCondition;
-}
-# 618 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/gfx/Logging.h"
-const int INDENT_PER_LEVEL = 2;
-
-class TreeLog
-{
-public:
-  explicit TreeLog(const std::string& aPrefix = "")
-        : mLog(int(LogOptions::NoNewline)),
-          mPrefix(aPrefix),
-          mDepth(0),
-          mStartOfLine(true),
-          mConditionedOnPref(false),
-          mPrefFunction(nullptr) {}
-
-  template <typename T>
-  TreeLog& operator<<(const T& aObject) {
-    if (mConditionedOnPref && !mPrefFunction()) {
-      return *this;
-    }
-    if (mStartOfLine) {
-      mLog << '[' << mPrefix << "] " << std::string(mDepth * INDENT_PER_LEVEL, ' ');
-      mStartOfLine = false;
-    }
-    mLog << aObject;
-    if (EndsInNewline(aObject)) {
-
-
-      mLog.Flush();
-      mStartOfLine = true;
-    }
-    return *this;
-  }
-
-  void IncreaseIndent() { ++mDepth; }
-  void DecreaseIndent() {
-    do { } while (0);
-    --mDepth;
-  }
-
-  void ConditionOnPrefFunction(bool(*aPrefFunction)()) {
-    mConditionedOnPref = true;
-    mPrefFunction = aPrefFunction;
-  }
-private:
-  Log<LOG_DEBUG> mLog;
-  std::string mPrefix;
-  uint32_t mDepth;
-  bool mStartOfLine;
-  bool mConditionedOnPref;
-  bool (*mPrefFunction)();
-
-  template <typename T>
-  static bool EndsInNewline(const T& aObject) {
-    return false;
-  }
-
-  static bool EndsInNewline(const std::string& aString) {
-    return !aString.empty() && aString[aString.length() - 1] == '\n';
-  }
-
-  static bool EndsInNewline(char aChar) {
-    return aChar == '\n';
-  }
-
-  static bool EndsInNewline(const char* aString) {
-    return EndsInNewline(std::string(aString));
-  }
-};
-
-class TreeAutoIndent
-{
-public:
-  explicit TreeAutoIndent(TreeLog& aTreeLog) : mTreeLog(aTreeLog) {
-    mTreeLog.IncreaseIndent();
-  }
-
-  TreeAutoIndent(const TreeAutoIndent& aTreeAutoIndent) :
-      TreeAutoIndent(aTreeAutoIndent.mTreeLog) {
-    mTreeLog.IncreaseIndent();
-  }
-
-  TreeAutoIndent& operator=(const TreeAutoIndent& aTreeAutoIndent) = delete;
-
-  ~TreeAutoIndent() {
-    mTreeLog.DecreaseIndent();
-  }
-private:
-  TreeLog& mTreeLog;
-};
-
-}
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h" 2
-
-
-
-
-
-namespace IPC {
-template <typename T> struct ParamTraits;
-}
-
-namespace mozilla {
-namespace layers {
-
-
-
-
-
-struct ScrollUpdateInfo {
-  uint32_t mScrollGeneration;
-  CSSPoint mScrollOffset;
-};
-
-
-
-
-
-
-
-struct FrameMetrics {
-  friend struct IPC::ParamTraits<mozilla::layers::FrameMetrics>;
-public:
-
-  typedef uint64_t ViewID;
-  static const ViewID NULL_SCROLL_ID;
-  static const ViewID START_SCROLL_ID = 2;
-
-
-  enum ScrollOffsetUpdateType : uint8_t {
-    eNone,
-    eMainThread,
-    ePending,
-
-
-    eUserAction,
-
-
-
-    eRestore,
-
-
-
-
-    eSentinel
-  };
-
-  FrameMetrics()
-    : mScrollId(NULL_SCROLL_ID)
-    , mPresShellResolution(1)
-    , mCompositionBounds(0, 0, 0, 0)
-    , mDisplayPort(0, 0, 0, 0)
-    , mCriticalDisplayPort(0, 0, 0, 0)
-    , mScrollableRect(0, 0, 0, 0)
-    , mCumulativeResolution()
-    , mDevPixelsPerCSSPixel(1)
-    , mScrollOffset(0, 0)
-    , mZoom()
-    , mScrollGeneration(0)
-    , mSmoothScrollOffset(0, 0)
-    , mRootCompositionSize(0, 0)
-    , mDisplayPortMargins(0, 0, 0, 0)
-    , mPresShellId(-1)
-    , mViewport(0, 0, 0, 0)
-    , mExtraResolution()
-    , mPaintRequestTime()
-    , mScrollUpdateType(eNone)
-    , mIsRootContent(false)
-    , mDoSmoothScroll(false)
-    , mUseDisplayPortMargins(false)
-    , mIsScrollInfoLayer(false)
-  {
-  }
-
-
-
-  bool operator==(const FrameMetrics& aOther) const
-  {
-
-    return mScrollId == aOther.mScrollId &&
-           mPresShellResolution == aOther.mPresShellResolution &&
-           mCompositionBounds.IsEqualEdges(aOther.mCompositionBounds) &&
-           mDisplayPort.IsEqualEdges(aOther.mDisplayPort) &&
-           mCriticalDisplayPort.IsEqualEdges(aOther.mCriticalDisplayPort) &&
-           mScrollableRect.IsEqualEdges(aOther.mScrollableRect) &&
-           mCumulativeResolution == aOther.mCumulativeResolution &&
-           mDevPixelsPerCSSPixel == aOther.mDevPixelsPerCSSPixel &&
-           mScrollOffset == aOther.mScrollOffset &&
-
-           mScrollGeneration == aOther.mScrollGeneration &&
-           mSmoothScrollOffset == aOther.mSmoothScrollOffset &&
-           mRootCompositionSize == aOther.mRootCompositionSize &&
-           mDisplayPortMargins == aOther.mDisplayPortMargins &&
-           mPresShellId == aOther.mPresShellId &&
-           mViewport.IsEqualEdges(aOther.mViewport) &&
-           mExtraResolution == aOther.mExtraResolution &&
-           mPaintRequestTime == aOther.mPaintRequestTime &&
-           mScrollUpdateType == aOther.mScrollUpdateType &&
-           mIsRootContent == aOther.mIsRootContent &&
-           mDoSmoothScroll == aOther.mDoSmoothScroll &&
-           mUseDisplayPortMargins == aOther.mUseDisplayPortMargins &&
-           mIsScrollInfoLayer == aOther.mIsScrollInfoLayer;
-  }
-
-  bool operator!=(const FrameMetrics& aOther) const
-  {
-    return !operator==(aOther);
-  }
-
-  bool IsScrollable() const
-  {
-    return mScrollId != NULL_SCROLL_ID;
-  }
-
-  CSSToScreenScale2D DisplayportPixelsPerCSSPixel() const
-  {
-
-
-
-
-
-
-
-    return mZoom * ParentLayerToLayerScale(1.0f) / mExtraResolution;
-  }
-
-  CSSToLayerScale2D LayersPixelsPerCSSPixel() const
-  {
-    return mDevPixelsPerCSSPixel * mCumulativeResolution;
-  }
-
-
-  LayerToParentLayerScale GetAsyncZoom() const
-  {
-
-
-    return (mZoom / LayersPixelsPerCSSPixel()).ToScaleFactor();
-  }
-
-
-
-
-
-
-
-  CSSRect GetExpandedScrollableRect() const
-  {
-    CSSRect scrollableRect = mScrollableRect;
-    CSSSize compSize = CalculateCompositedSizeInCssPixels();
-    if (scrollableRect.width < compSize.width) {
-      scrollableRect.x = std::max(0.f,
-                                  scrollableRect.x - (compSize.width - scrollableRect.width));
-      scrollableRect.width = compSize.width;
-    }
-
-    if (scrollableRect.height < compSize.height) {
-      scrollableRect.y = std::max(0.f,
-                                  scrollableRect.y - (compSize.height - scrollableRect.height));
-      scrollableRect.height = compSize.height;
-    }
-
-    return scrollableRect;
-  }
-
-  CSSSize CalculateCompositedSizeInCssPixels() const
-  {
-    if (GetZoom() == CSSToParentLayerScale2D(0, 0)) {
-      return CSSSize();
-    }
-    return mCompositionBounds.Size() / GetZoom();
-  }
-
-  CSSRect CalculateCompositedRectInCssPixels() const
-  {
-    if (GetZoom() == CSSToParentLayerScale2D(0, 0)) {
-      return CSSRect();
-    }
-    return mCompositionBounds / GetZoom();
-  }
-
-  CSSSize CalculateBoundedCompositedSizeInCssPixels() const
-  {
-    CSSSize size = CalculateCompositedSizeInCssPixels();
-    size.width = std::min(size.width, mRootCompositionSize.width);
-    size.height = std::min(size.height, mRootCompositionSize.height);
-    return size;
-  }
-
-  CSSRect CalculateScrollRange() const
-  {
-    CSSSize scrollPortSize = CalculateCompositedSizeInCssPixels();
-    CSSRect scrollRange = mScrollableRect;
-    scrollRange.width = std::max(scrollRange.width - scrollPortSize.width, 0.0f);
-    scrollRange.height = std::max(scrollRange.height - scrollPortSize.height, 0.0f);
-    return scrollRange;
-  }
-
-  void ScrollBy(const CSSPoint& aPoint)
-  {
-    mScrollOffset += aPoint;
-  }
-
-  void ZoomBy(float aScale)
-  {
-    ZoomBy(gfxSize(aScale, aScale));
-  }
-
-  void ZoomBy(const gfxSize& aScale)
-  {
-    mZoom.xScale *= aScale.width;
-    mZoom.yScale *= aScale.height;
-  }
-
-  void CopyScrollInfoFrom(const FrameMetrics& aOther)
-  {
-    mScrollOffset = aOther.mScrollOffset;
-    mScrollGeneration = aOther.mScrollGeneration;
-  }
-
-  void CopySmoothScrollInfoFrom(const FrameMetrics& aOther)
-  {
-    mSmoothScrollOffset = aOther.mSmoothScrollOffset;
-    mScrollGeneration = aOther.mScrollGeneration;
-    mDoSmoothScroll = aOther.mDoSmoothScroll;
-  }
-
-  void UpdatePendingScrollInfo(const ScrollUpdateInfo& aInfo)
-  {
-    mScrollOffset = aInfo.mScrollOffset;
-    mScrollGeneration = aInfo.mScrollGeneration;
-    mScrollUpdateType = ePending;
-  }
-
-  void SetRepaintDrivenByUserAction(bool aUserAction)
-  {
-    mScrollUpdateType = aUserAction ? eUserAction : eNone;
-  }
-
-public:
-  void SetPresShellResolution(float aPresShellResolution)
-  {
-    mPresShellResolution = aPresShellResolution;
-  }
-
-  float GetPresShellResolution() const
-  {
-    return mPresShellResolution;
-  }
-
-  void SetCompositionBounds(const ParentLayerRect& aCompositionBounds)
-  {
-    mCompositionBounds = aCompositionBounds;
-  }
-
-  const ParentLayerRect& GetCompositionBounds() const
-  {
-    return mCompositionBounds;
-  }
-
-  void SetDisplayPort(const CSSRect& aDisplayPort)
-  {
-    mDisplayPort = aDisplayPort;
-  }
-
-  const CSSRect& GetDisplayPort() const
-  {
-    return mDisplayPort;
-  }
-
-  void SetCriticalDisplayPort(const CSSRect& aCriticalDisplayPort)
-  {
-    mCriticalDisplayPort = aCriticalDisplayPort;
-  }
-
-  const CSSRect& GetCriticalDisplayPort() const
-  {
-    return mCriticalDisplayPort;
-  }
-
-  void SetCumulativeResolution(const LayoutDeviceToLayerScale2D& aCumulativeResolution)
-  {
-    mCumulativeResolution = aCumulativeResolution;
-  }
-
-  const LayoutDeviceToLayerScale2D& GetCumulativeResolution() const
-  {
-    return mCumulativeResolution;
-  }
-
-  void SetDevPixelsPerCSSPixel(const CSSToLayoutDeviceScale& aDevPixelsPerCSSPixel)
-  {
-    mDevPixelsPerCSSPixel = aDevPixelsPerCSSPixel;
-  }
-
-  const CSSToLayoutDeviceScale& GetDevPixelsPerCSSPixel() const
-  {
-    return mDevPixelsPerCSSPixel;
-  }
-
-  void SetIsRootContent(bool aIsRootContent)
-  {
-    mIsRootContent = aIsRootContent;
-  }
-
-  bool IsRootContent() const
-  {
-    return mIsRootContent;
-  }
-
-  void SetScrollOffset(const CSSPoint& aScrollOffset)
-  {
-    mScrollOffset = aScrollOffset;
-  }
-
-  const CSSPoint& GetScrollOffset() const
-  {
-    return mScrollOffset;
-  }
-
-  void SetSmoothScrollOffset(const CSSPoint& aSmoothScrollDestination)
-  {
-    mSmoothScrollOffset = aSmoothScrollDestination;
-  }
-
-  const CSSPoint& GetSmoothScrollOffset() const
-  {
-    return mSmoothScrollOffset;
-  }
-
-  void SetZoom(const CSSToParentLayerScale2D& aZoom)
-  {
-    mZoom = aZoom;
-  }
-
-  const CSSToParentLayerScale2D& GetZoom() const
-  {
-    return mZoom;
-  }
-
-  void SetScrollOffsetUpdated(uint32_t aScrollGeneration)
-  {
-    mScrollUpdateType = eMainThread;
-    mScrollGeneration = aScrollGeneration;
-  }
-
-  void SetScrollOffsetRestored(uint32_t aScrollGeneration)
-  {
-    mScrollUpdateType = eRestore;
-    mScrollGeneration = aScrollGeneration;
-  }
-
-  void SetSmoothScrollOffsetUpdated(int32_t aScrollGeneration)
-  {
-    mDoSmoothScroll = true;
-    mScrollGeneration = aScrollGeneration;
-  }
-
-  ScrollOffsetUpdateType GetScrollUpdateType() const
-  {
-    return mScrollUpdateType;
-  }
-
-  bool GetScrollOffsetUpdated() const
-  {
-    return mScrollUpdateType != eNone;
-  }
-
-  bool GetDoSmoothScroll() const
-  {
-    return mDoSmoothScroll;
-  }
-
-  uint32_t GetScrollGeneration() const
-  {
-    return mScrollGeneration;
-  }
-
-  ViewID GetScrollId() const
-  {
-    return mScrollId;
-  }
-
-  void SetScrollId(ViewID scrollId)
-  {
-    mScrollId = scrollId;
-  }
-
-  void SetRootCompositionSize(const CSSSize& aRootCompositionSize)
-  {
-    mRootCompositionSize = aRootCompositionSize;
-  }
-
-  const CSSSize& GetRootCompositionSize() const
-  {
-    return mRootCompositionSize;
-  }
-
-  void SetDisplayPortMargins(const ScreenMargin& aDisplayPortMargins)
-  {
-    mDisplayPortMargins = aDisplayPortMargins;
-  }
-
-  const ScreenMargin& GetDisplayPortMargins() const
-  {
-    return mDisplayPortMargins;
-  }
-
-  void SetUseDisplayPortMargins(bool aValue)
-  {
-    mUseDisplayPortMargins = aValue;
-  }
-
-  bool GetUseDisplayPortMargins() const
-  {
-    return mUseDisplayPortMargins;
-  }
-
-  uint32_t GetPresShellId() const
-  {
-    return mPresShellId;
-  }
-
-  void SetPresShellId(uint32_t aPresShellId)
-  {
-    mPresShellId = aPresShellId;
-  }
-
-  void SetViewport(const CSSRect& aViewport)
-  {
-    mViewport = aViewport;
-  }
-
-  const CSSRect& GetViewport() const
-  {
-    return mViewport;
-  }
-
-  void SetExtraResolution(const ScreenToLayerScale2D& aExtraResolution)
-  {
-    mExtraResolution = aExtraResolution;
-  }
-
-  const ScreenToLayerScale2D& GetExtraResolution() const
-  {
-    return mExtraResolution;
-  }
-
-  const CSSRect& GetScrollableRect() const
-  {
-    return mScrollableRect;
-  }
-
-  void SetScrollableRect(const CSSRect& aScrollableRect)
-  {
-    mScrollableRect = aScrollableRect;
-  }
-
-  void SetPaintRequestTime(const TimeStamp& aTime) {
-    mPaintRequestTime = aTime;
-  }
-  const TimeStamp& GetPaintRequestTime() const {
-    return mPaintRequestTime;
-  }
-
-  void SetIsScrollInfoLayer(bool aIsScrollInfoLayer) {
-    mIsScrollInfoLayer = aIsScrollInfoLayer;
-  }
-  bool IsScrollInfoLayer() const {
-    return mIsScrollInfoLayer;
-  }
-
-private:
-
-  ViewID mScrollId;
-# 506 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  float mPresShellResolution;
-# 523 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  ParentLayerRect mCompositionBounds;
-# 536 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  CSSRect mDisplayPort;
-
-
-
-
-
-
-
-  CSSRect mCriticalDisplayPort;
-# 557 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  CSSRect mScrollableRect;
-# 566 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  LayoutDeviceToLayerScale2D mCumulativeResolution;
-# 575 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  CSSToLayoutDeviceScale mDevPixelsPerCSSPixel;
-# 592 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  CSSPoint mScrollOffset;
-
-
-
-
-
-  CSSToParentLayerScale2D mZoom;
-
-
-  uint32_t mScrollGeneration;
-
-
-
-  CSSPoint mSmoothScrollOffset;
-
-
-  CSSSize mRootCompositionSize;
-
-
-
-  ScreenMargin mDisplayPortMargins;
-
-  uint32_t mPresShellId;
-# 625 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  CSSRect mViewport;
-
-
-
-  ScreenToLayerScale2D mExtraResolution;
-
-
-  TimeStamp mPaintRequestTime;
-
-
-
-  ScrollOffsetUpdateType mScrollUpdateType;
-
-
-  bool mIsRootContent:1;
-
-
-
-  bool mDoSmoothScroll:1;
-
-
-
-  bool mUseDisplayPortMargins:1;
-
-
-  bool mIsScrollInfoLayer:1;
-# 668 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-  void SetDoSmoothScroll(bool aValue) {
-    mDoSmoothScroll = aValue;
-  }
-};
-
-struct ScrollSnapInfo {
-  ScrollSnapInfo()
-    : mScrollSnapTypeX(0)
-    , mScrollSnapTypeY(0)
-  {}
-
-  bool operator==(const ScrollSnapInfo& aOther) const
-  {
-    return mScrollSnapTypeX == aOther.mScrollSnapTypeX &&
-           mScrollSnapTypeY == aOther.mScrollSnapTypeY &&
-           mScrollSnapIntervalX == aOther.mScrollSnapIntervalX &&
-           mScrollSnapIntervalY == aOther.mScrollSnapIntervalY &&
-           mScrollSnapDestination == aOther.mScrollSnapDestination &&
-           mScrollSnapCoordinates == aOther.mScrollSnapCoordinates;
-  }
-
-
-
-  uint8_t mScrollSnapTypeX;
-  uint8_t mScrollSnapTypeY;
-
-
-  Maybe<nscoord> mScrollSnapIntervalX;
-  Maybe<nscoord> mScrollSnapIntervalY;
-
-
-
-  nsPoint mScrollSnapDestination;
-
-
-
-  nsTArray<nsPoint> mScrollSnapCoordinates;
-};
-
-
-
-
-
-struct LayerClip {
-  friend struct IPC::ParamTraits<mozilla::layers::LayerClip>;
-
-public:
-  LayerClip()
-    : mClipRect()
-    , mMaskLayerIndex()
-  {}
-
-  explicit LayerClip(const ParentLayerIntRect& aClipRect)
-    : mClipRect(aClipRect)
-    , mMaskLayerIndex()
-  {}
-
-  bool operator==(const LayerClip& aOther) const
-  {
-    return mClipRect == aOther.mClipRect &&
-           mMaskLayerIndex == aOther.mMaskLayerIndex;
-  }
-
-  void SetClipRect(const ParentLayerIntRect& aClipRect) {
-    mClipRect = aClipRect;
-  }
-  const ParentLayerIntRect& GetClipRect() const {
-    return mClipRect;
-  }
-
-  void SetMaskLayerIndex(const Maybe<size_t>& aIndex) {
-    mMaskLayerIndex = aIndex;
-  }
-  const Maybe<size_t>& GetMaskLayerIndex() const {
-    return mMaskLayerIndex;
-  }
-
-private:
-  ParentLayerIntRect mClipRect;
-
-
-
-  Maybe<size_t> mMaskLayerIndex;
-};
-
-typedef Maybe<LayerClip> MaybeLayerClip;
-# 762 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-struct ScrollMetadata {
-  friend struct IPC::ParamTraits<mozilla::layers::ScrollMetadata>;
-
-  typedef FrameMetrics::ViewID ViewID;
-public:
-  static StaticAutoPtr<const ScrollMetadata> sNullMetadata;
-
-  ScrollMetadata()
-    : mMetrics()
-    , mSnapInfo()
-    , mScrollParentId(FrameMetrics::NULL_SCROLL_ID)
-    , mBackgroundColor()
-    , mContentDescription()
-    , mLineScrollAmount(0, 0)
-    , mPageScrollAmount(0, 0)
-    , mScrollClip()
-    , mHasScrollgrab(false)
-    , mAllowVerticalScrollWithWheel(false)
-    , mIsLayersIdRoot(false)
-    , mUsesContainerScrolling(false)
-    , mForceDisableApz(false)
-  {}
-
-  bool operator==(const ScrollMetadata& aOther) const
-  {
-    return mMetrics == aOther.mMetrics &&
-           mSnapInfo == aOther.mSnapInfo &&
-           mScrollParentId == aOther.mScrollParentId &&
-           mBackgroundColor == aOther.mBackgroundColor &&
-
-           mLineScrollAmount == aOther.mLineScrollAmount &&
-           mPageScrollAmount == aOther.mPageScrollAmount &&
-           mScrollClip == aOther.mScrollClip &&
-           mHasScrollgrab == aOther.mHasScrollgrab &&
-           mAllowVerticalScrollWithWheel == aOther.mAllowVerticalScrollWithWheel &&
-           mIsLayersIdRoot == aOther.mIsLayersIdRoot &&
-           mUsesContainerScrolling == aOther.mUsesContainerScrolling &&
-           mForceDisableApz == aOther.mForceDisableApz;
-  }
-
-  bool operator!=(const ScrollMetadata& aOther) const
-  {
-    return !operator==(aOther);
-  }
-
-  bool IsDefault() const
-  {
-    ScrollMetadata def;
-
-    def.mMetrics.SetPresShellId(mMetrics.GetPresShellId());
-    return (def == *this);
-  }
-
-  FrameMetrics& GetMetrics() { return mMetrics; }
-  const FrameMetrics& GetMetrics() const { return mMetrics; }
-
-  void SetSnapInfo(ScrollSnapInfo&& aSnapInfo) {
-    mSnapInfo = Move(aSnapInfo);
-  }
-  const ScrollSnapInfo& GetSnapInfo() const { return mSnapInfo; }
-
-  ViewID GetScrollParentId() const {
-    return mScrollParentId;
-  }
-
-  void SetScrollParentId(ViewID aParentId) {
-    mScrollParentId = aParentId;
-  }
-  const gfx::Color& GetBackgroundColor() const {
-    return mBackgroundColor;
-  }
-  void SetBackgroundColor(const gfx::Color& aBackgroundColor) {
-    mBackgroundColor = aBackgroundColor;
-  }
-  const nsCString& GetContentDescription() const {
-    return mContentDescription;
-  }
-  void SetContentDescription(const nsCString& aContentDescription) {
-    mContentDescription = aContentDescription;
-  }
-  const LayoutDeviceIntSize& GetLineScrollAmount() const {
-    return mLineScrollAmount;
-  }
-  void SetLineScrollAmount(const LayoutDeviceIntSize& size) {
-    mLineScrollAmount = size;
-  }
-  const LayoutDeviceIntSize& GetPageScrollAmount() const {
-    return mPageScrollAmount;
-  }
-  void SetPageScrollAmount(const LayoutDeviceIntSize& size) {
-    mPageScrollAmount = size;
-  }
-
-  void SetScrollClip(const Maybe<LayerClip>& aScrollClip) {
-    mScrollClip = aScrollClip;
-  }
-  const Maybe<LayerClip>& GetScrollClip() const {
-    return mScrollClip;
-  }
-  bool HasScrollClip() const {
-    return mScrollClip.isSome();
-  }
-  const LayerClip& ScrollClip() const {
-    return mScrollClip.ref();
-  }
-  LayerClip& ScrollClip() {
-    return mScrollClip.ref();
-  }
-
-  bool HasMaskLayer() const {
-    return HasScrollClip() && ScrollClip().GetMaskLayerIndex();
-  }
-  Maybe<ParentLayerIntRect> GetClipRect() const {
-    return mScrollClip.isSome() ? Some(mScrollClip->GetClipRect()) : Nothing();
-  }
-
-  void SetHasScrollgrab(bool aHasScrollgrab) {
-    mHasScrollgrab = aHasScrollgrab;
-  }
-  bool GetHasScrollgrab() const {
-    return mHasScrollgrab;
-  }
-  bool AllowVerticalScrollWithWheel() const {
-    return mAllowVerticalScrollWithWheel;
-  }
-  void SetAllowVerticalScrollWithWheel(bool aValue) {
-    mAllowVerticalScrollWithWheel = aValue;
-  }
-  void SetIsLayersIdRoot(bool aValue) {
-    mIsLayersIdRoot = aValue;
-  }
-  bool IsLayersIdRoot() const {
-    return mIsLayersIdRoot;
-  }
-
-
-  void SetUsesContainerScrolling(bool aValue);
-  bool UsesContainerScrolling() const {
-    return mUsesContainerScrolling;
-  }
-  void SetForceDisableApz(bool aForceDisable) {
-    mForceDisableApz = aForceDisable;
-  }
-  bool IsApzForceDisabled() const {
-    return mForceDisableApz;
-  }
-
-private:
-  FrameMetrics mMetrics;
-
-
-  ScrollSnapInfo mSnapInfo;
-
-
-  ViewID mScrollParentId;
-
-
-  gfx::Color mBackgroundColor;
-
-
-
-
-  nsCString mContentDescription;
-
-
-  LayoutDeviceIntSize mLineScrollAmount;
-
-
-  LayoutDeviceIntSize mPageScrollAmount;
-
-
-
-
-
-
-
-  Maybe<LayerClip> mScrollClip;
-
-
-  bool mHasScrollgrab:1;
-
-
-  bool mAllowVerticalScrollWithWheel:1;
-
-
-
-  bool mIsLayersIdRoot:1;
-
-
-
-  bool mUsesContainerScrolling:1;
-
-
-
-  bool mForceDisableApz:1;
-# 967 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-};
-# 977 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/FrameMetrics.h"
-struct ScrollableLayerGuid {
-  uint64_t mLayersId;
-  uint32_t mPresShellId;
-  FrameMetrics::ViewID mScrollId;
-
-  ScrollableLayerGuid()
-    : mLayersId(0)
-    , mPresShellId(0)
-    , mScrollId(0)
-  {
-  }
-
-  ScrollableLayerGuid(uint64_t aLayersId, uint32_t aPresShellId,
-                      FrameMetrics::ViewID aScrollId)
-    : mLayersId(aLayersId)
-    , mPresShellId(aPresShellId)
-    , mScrollId(aScrollId)
-  {
-  }
-
-  ScrollableLayerGuid(uint64_t aLayersId, const FrameMetrics& aMetrics)
-    : mLayersId(aLayersId)
-    , mPresShellId(aMetrics.GetPresShellId())
-    , mScrollId(aMetrics.GetScrollId())
-  {
-  }
-
-  ScrollableLayerGuid(const ScrollableLayerGuid& other)
-    : mLayersId(other.mLayersId)
-    , mPresShellId(other.mPresShellId)
-    , mScrollId(other.mScrollId)
-  {
-  }
-
-  ~ScrollableLayerGuid()
-  {
-  }
-
-  bool operator==(const ScrollableLayerGuid& other) const
-  {
-    return mLayersId == other.mLayersId
-        && mPresShellId == other.mPresShellId
-        && mScrollId == other.mScrollId;
-  }
-
-  bool operator!=(const ScrollableLayerGuid& other) const
-  {
-    return !(*this == other);
-  }
-
-  bool operator<(const ScrollableLayerGuid& other) const
-  {
-    if (mLayersId < other.mLayersId) {
-      return true;
-    }
-    if (mLayersId == other.mLayersId) {
-      if (mPresShellId < other.mPresShellId) {
-        return true;
-      }
-      if (mPresShellId == other.mPresShellId) {
-        return mScrollId < other.mScrollId;
-      }
-    }
-    return false;
-  }
-
-  uint32_t Hash() const
-  {
-    return HashGeneric(mLayersId, mPresShellId, mScrollId);
-  }
-};
-
-template <int LogLevel>
-gfx::Log<LogLevel>& operator<<(gfx::Log<LogLevel>& log, const ScrollableLayerGuid& aGuid) {
-  return log << '(' << aGuid.mLayersId << ',' << aGuid.mPresShellId << ',' << aGuid.mScrollId << ')';
-}
-
-struct ZoomConstraints {
-  bool mAllowZoom;
-  bool mAllowDoubleTapZoom;
-  CSSToParentLayerScale mMinZoom;
-  CSSToParentLayerScale mMaxZoom;
-
-  ZoomConstraints()
-    : mAllowZoom(true)
-    , mAllowDoubleTapZoom(true)
-  {
-                                   ;
-  }
-
-  ZoomConstraints(bool aAllowZoom,
-                  bool aAllowDoubleTapZoom,
-                  const CSSToParentLayerScale& aMinZoom,
-                  const CSSToParentLayerScale& aMaxZoom)
-    : mAllowZoom(aAllowZoom)
-    , mAllowDoubleTapZoom(aAllowDoubleTapZoom)
-    , mMinZoom(aMinZoom)
-    , mMaxZoom(aMaxZoom)
-  {
-                                   ;
-  }
-
-  ZoomConstraints(const ZoomConstraints& other)
-    : mAllowZoom(other.mAllowZoom)
-    , mAllowDoubleTapZoom(other.mAllowDoubleTapZoom)
-    , mMinZoom(other.mMinZoom)
-    , mMaxZoom(other.mMaxZoom)
-  {
-                                   ;
-  }
-
-  ~ZoomConstraints()
-  {
-                                   ;
-  }
-
-  bool operator==(const ZoomConstraints& other) const
-  {
-    return mAllowZoom == other.mAllowZoom
-        && mAllowDoubleTapZoom == other.mAllowDoubleTapZoom
-        && mMinZoom == other.mMinZoom
-        && mMaxZoom == other.mMaxZoom;
-  }
-
-  bool operator!=(const ZoomConstraints& other) const
-  {
-    return !(*this == other);
-  }
-};
-
-typedef Maybe<ZoomConstraints> MaybeZoomConstraints;
-
-}
-}
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h" 2
-
-
-
-
-class nsBoxLayoutState;
-class nsIScrollPositionListener;
-class nsIFrame;
-class nsPresContext;
-class nsIContent;
-class nsRenderingContext;
-class nsIAtom;
-class nsDisplayListBuilder;
-
-namespace mozilla {
-struct ContainerLayerParameters;
-namespace layers {
-class Layer;
-}
-}
-
-
-
-
-
-
-class nsIScrollableFrame : public nsIScrollbarMediator {
-public:
-  typedef mozilla::CSSIntPoint CSSIntPoint;
-  typedef mozilla::ContainerLayerParameters ContainerLayerParameters;
-  typedef mozilla::layers::FrameMetrics FrameMetrics;
-  typedef mozilla::layers::ScrollSnapInfo ScrollSnapInfo;
-
-  static const nsQueryFrame::FrameIID kFrameIID = nsQueryFrame::nsIScrollableFrame_id; typedef nsIScrollableFrame Has_NS_DECL_QUERYFRAME_TARGET;
-
-
-
-
-
-  virtual nsIFrame* GetScrolledFrame() const = 0;
-
-
-
-
-
-
-  virtual mozilla::ScrollbarStyles GetScrollbarStyles() const = 0;
-
-  enum { HORIZONTAL = 0x01, VERTICAL = 0x02 };
-
-
-
-
-
-  virtual uint32_t GetScrollbarVisibility() const = 0;
-
-
-
-
-
-  uint32_t GetPerceivedScrollingDirections() const;
-
-
-
-
-
-
-  virtual nsMargin GetActualScrollbarSizes() const = 0;
-
-
-
-
-
-  virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) = 0;
-
-
-
-
-
-  virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
-                                            nsRenderingContext* aRC) = 0;
-
-
-
-  virtual nscoord
-  GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
-                                   nsRenderingContext* aRC,
-                                   mozilla::WritingMode aWM) = 0;
-# 122 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual nsRect GetScrolledRect() const = 0;
-
-
-
-
-
-  virtual nsRect GetScrollPortRect() const = 0;
-
-
-
-
-
-  virtual nsPoint GetScrollPosition() const = 0;
-
-
-
-  virtual nsPoint GetLogicalScrollPosition() const = 0;
-# 147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual nsRect GetScrollRange() const = 0;
-
-
-
-
-  virtual nsSize GetScrollPositionClampingScrollPortSize() const = 0;
-
-
-
-
-  virtual nsSize GetLineScrollAmount() const = 0;
-
-
-
-
-  virtual nsSize GetPageScrollAmount() const = 0;
-# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  enum ScrollMode { INSTANT, SMOOTH, SMOOTH_MSD, NORMAL };
-# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  enum ScrollMomentum { NOT_MOMENTUM, SYNTHESIZED_MOMENTUM_EVENT };
-# 210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void ScrollTo(nsPoint aScrollPosition, ScrollMode aMode,
-                        const nsRect* aRange = nullptr,
-                        nsIScrollbarMediator::ScrollSnapMode aSnap
-                          = nsIScrollbarMediator::DISABLE_SNAP) = 0;
-# 231 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void ScrollToCSSPixels(const CSSIntPoint& aScrollPosition,
-                                 nsIScrollableFrame::ScrollMode aMode
-                                   = nsIScrollableFrame::INSTANT) = 0;
-# 242 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void ScrollToCSSPixelsApproximate(const mozilla::CSSPoint& aScrollPosition,
-                                            nsIAtom *aOrigin = nullptr) = 0;
-
-
-
-
-
-  virtual CSSIntPoint GetScrollPositionCSSPixels() = 0;
-
-
-
-  enum ScrollUnit { DEVICE_PIXELS, LINES, PAGES, WHOLE };
-# 264 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void ScrollBy(nsIntPoint aDelta, ScrollUnit aUnit, ScrollMode aMode,
-                        nsIntPoint* aOverflow = nullptr,
-                        nsIAtom* aOrigin = nullptr,
-                        ScrollMomentum aMomentum = NOT_MOMENTUM,
-                        nsIScrollbarMediator::ScrollSnapMode aSnap
-                          = nsIScrollbarMediator::DISABLE_SNAP) = 0;
-
-
-
-
-
-
-
-  virtual void ScrollSnap() = 0;
-# 288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void ScrollToRestoredPosition() = 0;
-
-
-
-
-
-  virtual void AddScrollPositionListener(nsIScrollPositionListener* aListener) = 0;
-
-
-
-  virtual void RemoveScrollPositionListener(nsIScrollPositionListener* aListener) = 0;
-
-
-
-
-
-  virtual void CurPosAttributeChanged(nsIContent* aChild) = 0;
-
-
-
-
-
-  virtual nsresult PostScrolledAreaEventForCurrentArea() = 0;
-
-
-
-
-
-
-  virtual bool IsScrollingActive(nsDisplayListBuilder* aBuilder) = 0;
-
-
-
-
-  virtual bool IsProcessingAsyncScroll() = 0;
-
-
-
-
-  virtual void ResetScrollPositionForLayerPixelAlignment() = 0;
-
-
-
-  virtual bool DidHistoryRestore() const = 0;
-
-
-
-
-
-  virtual void ClearDidHistoryRestore() = 0;
-
-
-
-
-  virtual bool IsRectNearlyVisible(const nsRect& aRect) = 0;
-
-
-
-
-  virtual nsRect ExpandRectToNearlyVisible(const nsRect& aRect) const = 0;
-
-
-
-
-
-  virtual nsIAtom* LastScrollOrigin() = 0;
-# 362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual void AllowScrollOriginDowngrade() = 0;
-# 377 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual nsIAtom* LastSmoothScrollOrigin() = 0;
-
-
-
-
-  virtual uint32_t CurrentScrollGeneration() = 0;
-
-
-
-
-  virtual nsPoint LastScrollDestination() = 0;
-
-
-
-
-
-  virtual void ResetScrollInfoIfGeneration(uint32_t aGeneration) = 0;
-
-
-
-
-  virtual bool WantAsyncScroll() const = 0;
-
-
-
-
-  virtual mozilla::Maybe<mozilla::layers::ScrollMetadata> ComputeScrollMetadata(
-    mozilla::layers::Layer* aLayer,
-    nsIFrame* aContainerReferenceFrame,
-    const ContainerLayerParameters& aParameters,
-    const mozilla::DisplayItemClip* aClip) const = 0;
-
-
-
-
-  virtual bool IsIgnoringViewportClipping() const = 0;
-
-
-
-
-  virtual void MarkScrollbarsDirtyForReflow() const = 0;
-
-  virtual void SetTransformingByAPZ(bool aTransforming) = 0;
-  virtual bool IsTransformingByAPZ() const = 0;
-
-
-
-
-
-
-
-  virtual void SetScrollableByAPZ(bool aScrollable) = 0;
-
-
-
-
-  virtual void SetZoomableByAPZ(bool aZoomable) = 0;
-
-
-
-
-  virtual bool UsesContainerScrolling() const = 0;
-# 449 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIScrollableFrame.h"
-  virtual bool DecideScrollableLayer(nsDisplayListBuilder* aBuilder,
-                                     nsRect* aDirtyRect,
-                                     bool aAllowCreateDisplayPort) = 0;
-
-
-
-
-
-
-  virtual void NotifyApproximateFrameVisibilityUpdate(bool aIgnoreDisplayPort) = 0;
-
-
-
-
-
-
-  virtual bool GetDisplayPortAtLastApproximateFrameVisibilityUpdate(nsRect* aDisplayPort) = 0;
-
-
-
-
-
-
-  virtual void TriggerDisplayPortExpiration() = 0;
-
-
-
-
-  virtual ScrollSnapInfo GetScrollSnapInfo() const = 0;
-
-
-
-
-
-
-
-  virtual bool DragScroll(mozilla::WidgetEvent* aEvent) = 0;
-
-  virtual void AsyncScrollbarDragRejected() = 0;
-
-
-
-
-
-
-  virtual bool IsRootScrollFrameOfDocument() const = 0;
-};
-# 32 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
-class nsSMILValue;
-class nsIContent;
-class nsAString;
-
-namespace mozilla {
-namespace dom {
-class SVGAnimationElement;
-}
-}
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
-class nsISMILAttr
-{
-public:
-# 53 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
-  virtual nsresult ValueFromString(const nsAString& aStr,
-                                   const mozilla::dom::SVGAnimationElement* aSrcElement,
-                                   nsSMILValue& aValue,
-                                   bool& aPreventCachingOfSandwich) const = 0;
-
-
-
-
-
-
-
-  virtual nsSMILValue GetBaseValue() const = 0;
-
-
-
-
-
-
-
-  virtual void ClearAnimValue() = 0;
-
-
-
-
-
-
-
-  virtual nsresult SetAnimValue(const nsSMILValue& aValue) = 0;
-# 90 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISMILAttr.h"
-  virtual const nsIContent* GetTargetNode() const { return nullptr; }
-
-
-
-
-  virtual ~nsISMILAttr() {}
-};
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRect.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRect.h"
-class nsIDOMClientRect : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetLeft(float *aLeft) = 0;
-
-
-  virtual nsresult GetTop(float *aTop) = 0;
-
-
-  virtual nsresult GetRight(float *aRight) = 0;
-
-
-  virtual nsresult GetBottom(float *aBottom) = 0;
-
-
-  virtual nsresult GetWidth(float *aWidth) = 0;
-
-
-  virtual nsresult GetHeight(float *aHeight) = 0;
-
-};
-
-  template<typename T> struct nsIDOMClientRect::COMTypeInfo<nsIDOMClientRect, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMClientRect::COMTypeInfo<nsIDOMClientRect, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb2f824c4, 0xd9d3, 0x499b, { 0x8d, 0x3b, 0x45, 0xc8, 0x24, 0x54, 0x97, 0xc6 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRectList.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIDOMClientRectList.h"
-class nsIDOMClientRectList : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetLength(uint32_t *aLength) = 0;
-
-
-  virtual nsresult Item(uint32_t index, nsIDOMClientRect * *_retval) = 0;
-
-};
-
-  template<typename T> struct nsIDOMClientRectList::COMTypeInfo<nsIDOMClientRectList, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIDOMClientRectList::COMTypeInfo<nsIDOMClientRectList, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xf474c567, 0xcbcb, 0x458f, { 0xab, 0xad, 0xae, 0x42, 0x36, 0x3d, 0xa2, 0x87 }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h" 2
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
-struct nsRect;
-
-namespace mozilla {
-namespace dom {
-
-class DOMRectReadOnly : public nsISupports
-                      , public nsWrapperCache
-{
-protected:
-  virtual ~DOMRectReadOnly() {}
-
-public:
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMRectReadOnly"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMRectReadOnly>(p)->DeleteCycleCollectable(); } static DOMRectReadOnly* Downcast(nsISupports* s) { return static_cast<DOMRectReadOnly*>(static_cast<DOMRectReadOnly*>(s)); } static nsISupports* Upcast(DOMRectReadOnly *p) { return static_cast<nsISupports*>(static_cast<DOMRectReadOnly*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMRectReadOnly::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-  explicit DOMRectReadOnly(nsISupports* aParent)
-    : mParent(aParent)
-  {
-  }
-
-  nsISupports* GetParentObject() const
-  {
-    do { } while (0);
-    return mParent;
-  }
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
-
-  virtual double X() const = 0;
-  virtual double Y() const = 0;
-  virtual double Width() const = 0;
-  virtual double Height() const = 0;
-
-  double Left() const
-  {
-    double x = X(), w = Width();
-    return std::min(x, x + w);
-  }
-  double Top() const
-  {
-    double y = Y(), h = Height();
-    return std::min(y, y + h);
-  }
-  double Right() const
-  {
-    double x = X(), w = Width();
-    return std::max(x, x + w);
-  }
-  double Bottom() const
-  {
-    double y = Y(), h = Height();
-    return std::max(y, y + h);
-  }
-
-protected:
-  nsCOMPtr<nsISupports> mParent;
-};
-
-class DOMRect final : public DOMRectReadOnly
-                    , public nsIDOMClientRect
-{
-public:
-  explicit DOMRect(nsISupports* aParent, double aX = 0, double aY = 0,
-                   double aWidth = 0, double aHeight = 0)
-    : DOMRectReadOnly(aParent)
-    , mX(aX)
-    , mY(aY)
-    , mWidth(aWidth)
-    , mHeight(aHeight)
-  {
-  }
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override;
-  virtual nsresult GetLeft(float *aLeft) override; virtual nsresult GetTop(float *aTop) override; virtual nsresult GetRight(float *aRight) override; virtual nsresult GetBottom(float *aBottom) override; virtual nsresult GetWidth(float *aWidth) override; virtual nsresult GetHeight(float *aHeight) override;
-
-  static already_AddRefed<DOMRect>
-  Constructor(const GlobalObject& aGlobal, ErrorResult& aRV);
-  static already_AddRefed<DOMRect>
-  Constructor(const GlobalObject& aGlobal, double aX, double aY,
-              double aWidth, double aHeight, ErrorResult& aRV);
-
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
-
-  void SetRect(float aX, float aY, float aWidth, float aHeight) {
-    mX = aX; mY = aY; mWidth = aWidth; mHeight = aHeight;
-  }
-  void SetLayoutRect(const nsRect& aLayoutRect);
-
-  virtual double X() const override
-  {
-    return mX;
-  }
-  virtual double Y() const override
-  {
-    return mY;
-  }
-  virtual double Width() const override
-  {
-    return mWidth;
-  }
-  virtual double Height() const override
-  {
-    return mHeight;
-  }
-
-  void SetX(double aX)
-  {
-    mX = aX;
-  }
-  void SetY(double aY)
-  {
-    mY = aY;
-  }
-  void SetWidth(double aWidth)
-  {
-    mWidth = aWidth;
-  }
-  void SetHeight(double aHeight)
-  {
-    mHeight = aHeight;
-  }
-
-protected:
-  double mX, mY, mWidth, mHeight;
-
-private:
-  ~DOMRect() {};
-};
-
-class DOMRectList final : public nsIDOMClientRectList,
-                          public nsWrapperCache
-{
-  ~DOMRectList() {}
-
-public:
-  explicit DOMRectList(nsISupports *aParent) : mParent(aParent)
-  {
-  }
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMRectList"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMRectList>(p)->DeleteCycleCollectable(); } static DOMRectList* Downcast(nsISupports* s) { return static_cast<DOMRectList*>(static_cast<DOMRectList*>(s)); } static nsISupports* Upcast(DOMRectList *p) { return static_cast<nsISupports*>(static_cast<DOMRectList*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMRectList::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-  virtual nsresult GetLength(uint32_t *aLength) override; virtual nsresult Item(uint32_t index, nsIDOMClientRect * *_retval) override;
-
-  virtual JSObject* WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
-
-  nsISupports* GetParentObject()
-  {
-    return mParent;
-  }
-
-  void Append(DOMRect* aElement) { mArray.AppendElement(aElement); }
-
-  static DOMRectList* FromSupports(nsISupports* aSupports)
-  {
-# 187 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRect.h"
-    return static_cast<DOMRectList*>(aSupports);
-  }
-
-  uint32_t Length()
-  {
-    return mArray.Length();
-  }
-  DOMRect* Item(uint32_t aIndex)
-  {
-    return mArray.SafeElementAt(aIndex);
-  }
-  DOMRect* IndexedGetter(uint32_t aIndex, bool& aFound)
-  {
-    aFound = aIndex < mArray.Length();
-    if (!aFound) {
-      return nullptr;
-    }
-    return mArray[aIndex];
-  }
-
-protected:
-  nsTArray<RefPtr<DOMRect> > mArray;
-  nsCOMPtr<nsISupports> mParent;
-};
-
-}
-}
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMTokenListSupportedTokens.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMTokenListSupportedTokens.h"
-namespace mozilla {
-namespace dom {
-
-
-typedef const char* const DOMTokenListSupportedToken;
-
-
-
-
-
-
-typedef DOMTokenListSupportedToken* DOMTokenListSupportedTokenArray;
-
-}
-}
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h"
-namespace mozilla {
-namespace dom {
-
-class Element;
-struct ElementAtoms;
-struct NativePropertyHooks;
-class ProtoAndIfaceCache;
-struct ScrollIntoViewOptionsAtoms;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-enum class ScrollLogicalPosition : uint8_t {
-  Start,
-  End,
-  EndGuard_
-};
-
-namespace ScrollLogicalPositionValues {
-extern const EnumEntry strings[3];
-}
-
-bool
-ToJSValue(JSContext* aCx, ScrollLogicalPosition aArgument, JS::MutableHandle<JS::Value> aValue);
-
-
-struct ScrollIntoViewOptions : public ScrollOptions
-{
-                        ScrollLogicalPosition mBlock;
-
-  ScrollIntoViewOptions();
-
-  explicit inline ScrollIntoViewOptions(const FastDictionaryInitializer& )
-    : ScrollOptions(FastDictionaryInitializer())
-  {
-
-  }
-
-  explicit inline ScrollIntoViewOptions(const ScrollIntoViewOptions& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  Init(const nsAString& aJSON);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  bool
-  ToJSON(nsAString& aJSON) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  ScrollIntoViewOptions&
-  operator=(const ScrollIntoViewOptions& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, ScrollIntoViewOptionsAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastScrollIntoViewOptions : public ScrollIntoViewOptions
-{
-  inline FastScrollIntoViewOptions()
-    : ScrollIntoViewOptions(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-namespace ElementBinding {
-
-  typedef mozilla::dom::Element NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::Element* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 121 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/ElementBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JSObject*
-  GetProtoObject(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 41 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 1
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
-namespace mozilla {
-namespace dom {
-
-class DOMRect;
-struct DOMRectAtoms;
-struct DOMRectInitAtoms;
-class DOMRectReadOnly;
-struct DOMRectReadOnlyAtoms;
-struct NativePropertyHooks;
-class ProtoAndIfaceCache;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-struct DOMRectInit : public DictionaryBase
-{
-                        double mHeight;
-                        double mWidth;
-                        double mX;
-                        double mY;
-
-  DOMRectInit();
-
-  explicit inline DOMRectInit(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline DOMRectInit(const DOMRectInit& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  DOMRectInit&
-  operator=(const DOMRectInit& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, DOMRectInitAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastDOMRectInit : public DOMRectInit
-{
-  inline FastDOMRectInit()
-    : DOMRectInit(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-namespace DOMRectBinding {
-
-  typedef mozilla::dom::DOMRect NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::DOMRect* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 104 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-namespace DOMRectReadOnlyBinding {
-
-  typedef mozilla::dom::DOMRectReadOnly NativeType;
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::DOMRectReadOnly* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMRectBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JSObject*
-  GetProtoObject(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 7 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h" 2
-
-
-
-
-
-namespace mozilla {
-namespace dom {
-
-class DOMIntersectionObserver;
-struct DOMIntersectionObserverAtoms;
-class DOMIntersectionObserverEntry;
-struct DOMIntersectionObserverEntryAtoms;
-struct DOMRectInit;
-class DoubleOrDoubleSequence;
-class Element;
-class IntersectionCallback;
-struct IntersectionObserverEntryInitAtoms;
-struct IntersectionObserverInitAtoms;
-struct NativePropertyHooks;
-class OwningDoubleOrDoubleSequence;
-class ProtoAndIfaceCache;
-
-}
-}
-
-namespace mozilla {
-namespace dom {
-
-class DoubleOrDoubleSequence
-{
-  friend class DoubleOrDoubleSequenceArgument;
-  enum Type
-  {
-    eUninitialized,
-    eDouble,
-    eDoubleSequence
-  };
-
-  union Value
-  {
-    UnionMember<double > mDouble;
-    UnionMember<binding_detail::AutoSequence<double> > mDoubleSequence;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-  DoubleOrDoubleSequence(const DoubleOrDoubleSequence&) = delete;
-  DoubleOrDoubleSequence& operator=(const DoubleOrDoubleSequence&) = delete;
-public:
-  explicit inline DoubleOrDoubleSequence()
-    : mType(eUninitialized)
-  {
-  }
-
-  inline ~DoubleOrDoubleSequence()
-  {
-    Uninit();
-  }
-
-  inline double&
-  RawSetAsDouble()
-  {
-    if (mType == eDouble) {
-      return mValue.mDouble.Value();
-    }
-    do { } while (0);
-    mType = eDouble;
-    return mValue.mDouble.SetValue();
-  }
-
-  inline double&
-  SetAsDouble()
-  {
-    if (mType == eDouble) {
-      return mValue.mDouble.Value();
-    }
-    Uninit();
-    mType = eDouble;
-    return mValue.mDouble.SetValue();
-  }
-
-  inline bool
-  IsDouble() const
-  {
-    return mType == eDouble;
-  }
-
-  inline double&
-  GetAsDouble()
-  {
-    do { } while (0);
-    return mValue.mDouble.Value();
-  }
-
-  inline double
-  GetAsDouble() const
-  {
-    do { } while (0);
-    return mValue.mDouble.Value();
-  }
-
-  inline binding_detail::AutoSequence<double>&
-  RawSetAsDoubleSequence()
-  {
-    if (mType == eDoubleSequence) {
-      return mValue.mDoubleSequence.Value();
-    }
-    do { } while (0);
-    mType = eDoubleSequence;
-    return mValue.mDoubleSequence.SetValue();
-  }
-
-  inline binding_detail::AutoSequence<double>&
-  SetAsDoubleSequence()
-  {
-    if (mType == eDoubleSequence) {
-      return mValue.mDoubleSequence.Value();
-    }
-    Uninit();
-    mType = eDoubleSequence;
-    return mValue.mDoubleSequence.SetValue();
-  }
-
-  inline bool
-  IsDoubleSequence() const
-  {
-    return mType == eDoubleSequence;
-  }
-
-  inline binding_detail::AutoSequence<double>&
-  GetAsDoubleSequence()
-  {
-    do { } while (0);
-    return mValue.mDoubleSequence.Value();
-  }
-
-  inline const Sequence<double>&
-  GetAsDoubleSequence() const
-  {
-    do { } while (0);
-    return mValue.mDoubleSequence.Value();
-  }
-
-  inline void
-  Uninit()
-  {
-    switch (mType) {
-      case eUninitialized: {
-        break;
-      }
-      case eDouble: {
-        DestroyDouble();
-        break;
-      }
-      case eDoubleSequence: {
-        DestroyDoubleSequence();
-        break;
-      }
-    }
-  }
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-private:
-  inline void
-  DestroyDouble()
-  {
-    do { } while (0);
-    mValue.mDouble.Destroy();
-    mType = eUninitialized;
-  }
-
-  inline void
-  DestroyDoubleSequence()
-  {
-    do { } while (0);
-    mValue.mDoubleSequence.Destroy();
-    mType = eUninitialized;
-  }
-};
-
-
-class OwningDoubleOrDoubleSequence : public AllOwningUnionBase
-{
-  friend void ImplCycleCollectionUnlink(OwningDoubleOrDoubleSequence& aUnion);
-  enum Type
-  {
-    eUninitialized,
-    eDouble,
-    eDoubleSequence
-  };
-
-  union Value
-  {
-    UnionMember<double > mDouble;
-    UnionMember<Sequence<double> > mDoubleSequence;
-
-  };
-
-  Type mType;
-  Value mValue;
-
-public:
-  explicit inline OwningDoubleOrDoubleSequence()
-    : mType(eUninitialized)
-  {
-  }
-
-  explicit inline OwningDoubleOrDoubleSequence(const OwningDoubleOrDoubleSequence& aOther)
-    : mType(eUninitialized)
-  {
-    *this = aOther;
-  }
-
-  inline ~OwningDoubleOrDoubleSequence()
-  {
-    Uninit();
-  }
-
-  double&
-  RawSetAsDouble();
-
-  double&
-  SetAsDouble();
-
-  bool
-  TrySetToDouble(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsDouble() const
-  {
-    return mType == eDouble;
-  }
-
-  inline double&
-  GetAsDouble()
-  {
-    do { } while (0);
-    return mValue.mDouble.Value();
-  }
-
-  inline double const &
-  GetAsDouble() const
-  {
-    do { } while (0);
-    return mValue.mDouble.Value();
-  }
-
-  Sequence<double>&
-  RawSetAsDoubleSequence();
-
-  Sequence<double>&
-  SetAsDoubleSequence();
-
-  bool
-  TrySetToDoubleSequence(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
-
-  inline bool
-  IsDoubleSequence() const
-  {
-    return mType == eDoubleSequence;
-  }
-
-  inline Sequence<double>&
-  GetAsDoubleSequence()
-  {
-    do { } while (0);
-    return mValue.mDoubleSequence.Value();
-  }
-
-  inline Sequence<double> const &
-  GetAsDoubleSequence() const
-  {
-    do { } while (0);
-    return mValue.mDoubleSequence.Value();
-  }
-
-  void
-  Uninit();
-
-  bool
-  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceUnion(JSTracer* trc);
-
-  OwningDoubleOrDoubleSequence&
-  operator=(const OwningDoubleOrDoubleSequence& aOther);
-
-private:
-  void
-  DestroyDouble();
-
-  void
-  DestroyDoubleSequence();
-};
-
-
-struct IntersectionObserverEntryInit : public DictionaryBase
-{
-                        DOMRectInit mBoundingClientRect;
-                        DOMRectInit mIntersectionRect;
-                        DOMRectInit mRootBounds;
-                        OwningNonNull<mozilla::dom::Element> mTarget;
-                        double mTime;
-
-  IntersectionObserverEntryInit();
-
-  explicit inline IntersectionObserverEntryInit(const FastDictionaryInitializer& )
-    : mBoundingClientRect(FastDictionaryInitializer()),
-      mIntersectionRect(FastDictionaryInitializer()),
-      mRootBounds(FastDictionaryInitializer())
-  {
-
-  }
-
-  explicit inline IntersectionObserverEntryInit(const IntersectionObserverEntryInit& aOther)
-    : mBoundingClientRect(FastDictionaryInitializer()),
-      mIntersectionRect(FastDictionaryInitializer()),
-      mRootBounds(FastDictionaryInitializer())
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  IntersectionObserverEntryInit&
-  operator=(const IntersectionObserverEntryInit& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, IntersectionObserverEntryInitAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastIntersectionObserverEntryInit : public IntersectionObserverEntryInit
-{
-  inline FastIntersectionObserverEntryInit()
-    : IntersectionObserverEntryInit(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-struct IntersectionObserverInit : public DictionaryBase
-{
-                        RefPtr<mozilla::dom::Element> mRoot;
-                        nsString mRootMargin;
-                        OwningDoubleOrDoubleSequence mThreshold;
-
-  IntersectionObserverInit();
-
-  explicit inline IntersectionObserverInit(const FastDictionaryInitializer& )
-  {
-
-  }
-
-  explicit inline IntersectionObserverInit(const IntersectionObserverInit& aOther)
-  {
-    *this = aOther;
-  }
-
-  bool
-  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
-
-  bool
-  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
-
-  void
-  TraceDictionary(JSTracer* trc);
-
-  IntersectionObserverInit&
-  operator=(const IntersectionObserverInit& aOther);
-
-private:
-  static bool
-  InitIds(JSContext* cx, IntersectionObserverInitAtoms* atomsCache);
-};
-
-namespace binding_detail {
-struct FastIntersectionObserverInit : public IntersectionObserverInit
-{
-  inline FastIntersectionObserverInit()
-    : IntersectionObserverInit(FastDictionaryInitializer())
-  {
-
-  }
-};
-}
-
-
-class IntersectionCallback : public CallbackFunction
-{
-public:
-  explicit inline IntersectionCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline IntersectionCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
-    : CallbackFunction(aCallback, FastCallbackConstructor())
-  {
-    do { } while (0);
-  }
-
-  explicit inline IntersectionCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
-    : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
-  {
-    do { } while (0);
-  }
-
-  explicit inline IntersectionCallback(CallbackFunction* aOther)
-    : CallbackFunction(aOther)
-  {
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "IntersectionCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    JS::Rooted<JS::Value> thisValJS(s.GetContext());
-    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
-      aRv.Throw(NS_ERROR_FAILURE);
-      return;
-    }
-    return Call(s.GetContext(), thisValJS, entries, observer, aRv);
-  }
-
-  inline void
-  Call(const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
-  {
-    do { } while (0);
-    if (!aExecutionReason) {
-      aExecutionReason = "IntersectionCallback";
-    }
-    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
-    if (!s.GetContext()) {
-      do { } while (0);
-      return;
-    }
-    return Call(s.GetContext(), JS::UndefinedHandleValue, entries, observer, aRv);
-  }
-
-  template <typename T>
-  inline void
-  Call(const T& thisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(thisVal, entries, observer, rv, aExecutionReason);
-  }
-
-  inline void
-  Call(const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, const char* aExecutionReason = nullptr)
-  {
-    IgnoredErrorResult rv;
-    return Call(entries, observer, rv, aExecutionReason, eReportExceptions, nullptr);
-  }
-
-  inline bool
-  operator==(const IntersectionCallback& aOther) const
-  {
-    return CallbackFunction::operator==(aOther);
-  }
-
-private:
-  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& entries, DOMIntersectionObserver& observer, ErrorResult& aRv);
-};
-
-
-namespace binding_detail {
-class FastIntersectionCallback : public IntersectionCallback
-{
-public:
-  explicit inline FastIntersectionCallback(JS::Handle<JSObject*> aCallback)
-    : IntersectionCallback(aCallback, FastCallbackConstructor())
-  {
-  }
-
-  inline void
-  Trace(JSTracer* aTracer)
-  {
-    IntersectionCallback::Trace(aTracer);
-  }
-
-  inline void
-  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
-  {
-    IntersectionCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
-  }
-};
-}
-
-
-namespace IntersectionObserverBinding {
-
-  typedef mozilla::dom::DOMIntersectionObserver NativeType;
-
-  bool
-  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::DOMIntersectionObserver* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 558 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-namespace IntersectionObserverEntryBinding {
-
-  typedef mozilla::dom::DOMIntersectionObserverEntry NativeType;
-
-  bool
-  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
-
-  JSObject*
-  DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
-
-  const JSClass*
-  GetJSClass();
-
-  bool
-  Wrap(JSContext* aCx, mozilla::dom::DOMIntersectionObserverEntry* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
-
-  template <class T>
-  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
-  {
-    JS::Rooted<JSObject*> reflector(aCx);
-    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
-  }
-# 606 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/IntersectionObserverBinding.h"
-  extern const NativePropertyHooks sNativePropertyHooks[];
-
-  void
-  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
-
-  JS::Handle<JSObject*>
-  GetProtoObjectHandle(JSContext* aCx);
-
-  JS::Handle<JSObject*>
-  GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
-
-  JSObject*
-  GetConstructorObject(JSContext* aCx);
-
-}
-
-
-
-}
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h"
-namespace mozilla {
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/StyleComplexColor.h"
-struct StyleComplexColor
-{
-  nscolor mColor;
-  uint8_t mForegroundRatio;
-
-
-
-
-  bool mIsAuto;
-
-  static StyleComplexColor FromColor(nscolor aColor) {
-    return {aColor, 0, false};
-  }
-  static StyleComplexColor CurrentColor() {
-    return {((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))), 255, false};
-  }
-  static StyleComplexColor Auto() {
-    return {((nscolor) (((0) << 24) | ((0)<<16) | ((0)<<8) | (0))), 255, true};
-  }
-
-  bool IsNumericColor() const { return mForegroundRatio == 0; }
-  bool IsCurrentColor() const { return mForegroundRatio == 255; }
-
-  bool operator==(const StyleComplexColor& aOther) const {
-    return mForegroundRatio == aOther.mForegroundRatio &&
-           (IsCurrentColor() || mColor == aOther.mColor) &&
-           mIsAuto == aOther.mIsAuto;
-  }
-  bool operator!=(const StyleComplexColor& aOther) const {
-    return !(*this == aOther);
-  }
-};
-
-}
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h"
-enum nsCSSKeyword : int16_t {
-  eCSSKeyword_UNKNOWN = -1,
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywordList.h" 1
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywordList.h"
-eCSSKeyword__moz_activehyperlinktext,
-eCSSKeyword__moz_all,
-eCSSKeyword__moz_alt_content,
-eCSSKeyword__moz_anchor_decoration,
-eCSSKeyword__moz_available,
-eCSSKeyword__moz_box,
-eCSSKeyword__moz_button,
-eCSSKeyword__moz_buttondefault,
-eCSSKeyword__moz_buttonhoverface,
-eCSSKeyword__moz_buttonhovertext,
-eCSSKeyword__moz_cellhighlight,
-eCSSKeyword__moz_cellhighlighttext,
-eCSSKeyword__moz_center,
-eCSSKeyword__moz_combobox,
-eCSSKeyword__moz_comboboxtext,
-eCSSKeyword__moz_block_height,
-eCSSKeyword__moz_deck,
-eCSSKeyword__moz_default_background_color,
-eCSSKeyword__moz_default_color,
-eCSSKeyword__moz_desktop,
-eCSSKeyword__moz_dialog,
-eCSSKeyword__moz_dialogtext,
-eCSSKeyword__moz_document,
-eCSSKeyword__moz_dragtargetzone,
-eCSSKeyword__moz_element,
-eCSSKeyword__moz_eventreerow,
-eCSSKeyword__moz_field,
-eCSSKeyword__moz_fieldtext,
-eCSSKeyword__moz_fit_content,
-eCSSKeyword__moz_fixed,
-eCSSKeyword__moz_grabbing,
-eCSSKeyword__moz_grab,
-eCSSKeyword__moz_grid_group,
-eCSSKeyword__moz_grid_line,
-eCSSKeyword__moz_grid,
-eCSSKeyword__moz_groupbox,
-eCSSKeyword__moz_gtk_info_bar,
-eCSSKeyword__moz_gtk_info_bar_text,
-eCSSKeyword__moz_hidden_unscrollable,
-eCSSKeyword__moz_hyperlinktext,
-eCSSKeyword__moz_html_cellhighlight,
-eCSSKeyword__moz_html_cellhighlighttext,
-eCSSKeyword__moz_image_rect,
-eCSSKeyword__moz_info,
-eCSSKeyword__moz_inline_box,
-eCSSKeyword__moz_inline_grid,
-eCSSKeyword__moz_inline_stack,
-eCSSKeyword__moz_left,
-eCSSKeyword__moz_list,
-eCSSKeyword__moz_mac_buttonactivetext,
-eCSSKeyword__moz_mac_chrome_active,
-eCSSKeyword__moz_mac_chrome_inactive,
-eCSSKeyword__moz_mac_defaultbuttontext,
-eCSSKeyword__moz_mac_focusring,
-eCSSKeyword__moz_mac_fullscreen_button,
-eCSSKeyword__moz_mac_menuselect,
-eCSSKeyword__moz_mac_menushadow,
-eCSSKeyword__moz_mac_menutextdisable,
-eCSSKeyword__moz_mac_menutextselect,
-eCSSKeyword__moz_mac_disabledtoolbartext,
-eCSSKeyword__moz_mac_secondaryhighlight,
-eCSSKeyword__moz_max_content,
-eCSSKeyword__moz_menuhover,
-eCSSKeyword__moz_menuhovertext,
-eCSSKeyword__moz_menubartext,
-eCSSKeyword__moz_menubarhovertext,
-eCSSKeyword__moz_middle_with_baseline,
-eCSSKeyword__moz_min_content,
-eCSSKeyword__moz_nativehyperlinktext,
-eCSSKeyword__moz_none,
-eCSSKeyword__moz_oddtreerow,
-eCSSKeyword__moz_popup,
-eCSSKeyword__moz_pre_space,
-eCSSKeyword__moz_pull_down_menu,
-eCSSKeyword__moz_right,
-eCSSKeyword__moz_scrollbars_horizontal,
-eCSSKeyword__moz_scrollbars_none,
-eCSSKeyword__moz_scrollbars_vertical,
-eCSSKeyword__moz_stack,
-eCSSKeyword__moz_text,
-eCSSKeyword__moz_use_system_font,
-eCSSKeyword__moz_visitedhyperlinktext,
-eCSSKeyword__moz_window,
-eCSSKeyword__moz_workspace,
-eCSSKeyword__moz_zoom_in,
-eCSSKeyword__moz_zoom_out,
-eCSSKeyword__webkit_box,
-eCSSKeyword__webkit_flex,
-eCSSKeyword__webkit_inline_box,
-eCSSKeyword__webkit_inline_flex,
-eCSSKeyword_absolute,
-eCSSKeyword_active,
-eCSSKeyword_activeborder,
-eCSSKeyword_activecaption,
-eCSSKeyword_add,
-eCSSKeyword_additive,
-eCSSKeyword_alias,
-eCSSKeyword_all,
-eCSSKeyword_all_petite_caps,
-eCSSKeyword_all_scroll,
-eCSSKeyword_all_small_caps,
-eCSSKeyword_alpha,
-eCSSKeyword_alternate,
-eCSSKeyword_alternate_reverse,
-eCSSKeyword_always,
-eCSSKeyword_annotation,
-eCSSKeyword_appworkspace,
-eCSSKeyword_auto,
-eCSSKeyword_auto_fill,
-eCSSKeyword_auto_fit,
-eCSSKeyword_auto_flow,
-eCSSKeyword_avoid,
-eCSSKeyword_background,
-eCSSKeyword_backwards,
-eCSSKeyword_balance,
-eCSSKeyword_baseline,
-eCSSKeyword_bidi_override,
-eCSSKeyword_blink,
-eCSSKeyword_block,
-eCSSKeyword_block_axis,
-eCSSKeyword_blur,
-eCSSKeyword_bold,
-eCSSKeyword_bold_fraktur,
-eCSSKeyword_bold_italic,
-eCSSKeyword_bold_sans_serif,
-eCSSKeyword_bold_script,
-eCSSKeyword_bolder,
-eCSSKeyword_border_box,
-eCSSKeyword_both,
-eCSSKeyword_bottom,
-eCSSKeyword_bottom_outside,
-eCSSKeyword_break_all,
-eCSSKeyword_break_word,
-eCSSKeyword_brightness,
-eCSSKeyword_browser,
-eCSSKeyword_bullets,
-eCSSKeyword_button,
-eCSSKeyword_buttonface,
-eCSSKeyword_buttonhighlight,
-eCSSKeyword_buttonshadow,
-eCSSKeyword_buttontext,
-eCSSKeyword_capitalize,
-eCSSKeyword_caption,
-eCSSKeyword_captiontext,
-eCSSKeyword_cell,
-eCSSKeyword_center,
-eCSSKeyword_ch,
-eCSSKeyword_character_variant,
-eCSSKeyword_circle,
-eCSSKeyword_cjk_decimal,
-eCSSKeyword_clip,
-eCSSKeyword_clone,
-eCSSKeyword_close_quote,
-eCSSKeyword_closest_corner,
-eCSSKeyword_closest_side,
-eCSSKeyword_cm,
-eCSSKeyword_col_resize,
-eCSSKeyword_collapse,
-eCSSKeyword_color,
-eCSSKeyword_color_burn,
-eCSSKeyword_color_dodge,
-eCSSKeyword_common_ligatures,
-eCSSKeyword_column,
-eCSSKeyword_column_reverse,
-eCSSKeyword_condensed,
-eCSSKeyword_contain,
-eCSSKeyword_content_box,
-eCSSKeyword_contents,
-eCSSKeyword_context_fill,
-eCSSKeyword_context_fill_opacity,
-eCSSKeyword_context_menu,
-eCSSKeyword_context_stroke,
-eCSSKeyword_context_stroke_opacity,
-eCSSKeyword_context_value,
-eCSSKeyword_continuous,
-eCSSKeyword_contrast,
-eCSSKeyword_copy,
-eCSSKeyword_contextual,
-eCSSKeyword_cover,
-eCSSKeyword_crop,
-eCSSKeyword_cross,
-eCSSKeyword_crosshair,
-eCSSKeyword_currentcolor,
-eCSSKeyword_cursive,
-eCSSKeyword_cyclic,
-eCSSKeyword_darken,
-eCSSKeyword_dashed,
-eCSSKeyword_dense,
-eCSSKeyword_decimal,
-eCSSKeyword_default,
-eCSSKeyword_deg,
-eCSSKeyword_diagonal_fractions,
-eCSSKeyword_dialog,
-eCSSKeyword_difference,
-eCSSKeyword_digits,
-eCSSKeyword_disabled,
-eCSSKeyword_disc,
-eCSSKeyword_disclosure_closed,
-eCSSKeyword_disclosure_open,
-eCSSKeyword_discretionary_ligatures,
-eCSSKeyword_distribute,
-eCSSKeyword_dot,
-eCSSKeyword_dotted,
-eCSSKeyword_double,
-eCSSKeyword_double_circle,
-eCSSKeyword_double_struck,
-eCSSKeyword_drag,
-eCSSKeyword_drop_shadow,
-eCSSKeyword_e_resize,
-eCSSKeyword_ease,
-eCSSKeyword_ease_in,
-eCSSKeyword_ease_in_out,
-eCSSKeyword_ease_out,
-eCSSKeyword_economy,
-eCSSKeyword_element,
-eCSSKeyword_elements,
-eCSSKeyword_ellipse,
-eCSSKeyword_ellipsis,
-eCSSKeyword_em,
-eCSSKeyword_embed,
-eCSSKeyword_enabled,
-eCSSKeyword_end,
-eCSSKeyword_ethiopic_numeric,
-eCSSKeyword_ex,
-eCSSKeyword_exact,
-eCSSKeyword_exclude,
-eCSSKeyword_exclusion,
-eCSSKeyword_expanded,
-eCSSKeyword_extends,
-eCSSKeyword_extra_condensed,
-eCSSKeyword_extra_expanded,
-eCSSKeyword_ew_resize,
-eCSSKeyword_fallback,
-eCSSKeyword_fantasy,
-eCSSKeyword_farthest_side,
-eCSSKeyword_farthest_corner,
-eCSSKeyword_fill,
-eCSSKeyword_filled,
-eCSSKeyword_fill_box,
-eCSSKeyword_first,
-eCSSKeyword_fit_content,
-eCSSKeyword_fixed,
-eCSSKeyword_flat,
-eCSSKeyword_flex,
-eCSSKeyword_flex_end,
-eCSSKeyword_flex_start,
-eCSSKeyword_flip,
-eCSSKeyword_flow_root,
-eCSSKeyword_forwards,
-eCSSKeyword_fraktur,
-eCSSKeyword_frames,
-eCSSKeyword_from_image,
-eCSSKeyword_full_width,
-eCSSKeyword_fullscreen,
-eCSSKeyword_grab,
-eCSSKeyword_grabbing,
-eCSSKeyword_grad,
-eCSSKeyword_grayscale,
-eCSSKeyword_graytext,
-eCSSKeyword_grid,
-eCSSKeyword_groove,
-eCSSKeyword_hard_light,
-eCSSKeyword_hebrew,
-eCSSKeyword_help,
-eCSSKeyword_hidden,
-eCSSKeyword_hide,
-eCSSKeyword_highlight,
-eCSSKeyword_highlighttext,
-eCSSKeyword_historical_forms,
-eCSSKeyword_historical_ligatures,
-eCSSKeyword_horizontal,
-eCSSKeyword_horizontal_tb,
-eCSSKeyword_hue,
-eCSSKeyword_hue_rotate,
-eCSSKeyword_hz,
-eCSSKeyword_icon,
-eCSSKeyword_ignore,
-eCSSKeyword_in,
-eCSSKeyword_interlace,
-eCSSKeyword_inactive,
-eCSSKeyword_inactiveborder,
-eCSSKeyword_inactivecaption,
-eCSSKeyword_inactivecaptiontext,
-eCSSKeyword_infinite,
-eCSSKeyword_infobackground,
-eCSSKeyword_infotext,
-eCSSKeyword_inherit,
-eCSSKeyword_initial,
-eCSSKeyword_inline,
-eCSSKeyword_inline_axis,
-eCSSKeyword_inline_block,
-eCSSKeyword_inline_end,
-eCSSKeyword_inline_flex,
-eCSSKeyword_inline_grid,
-eCSSKeyword_inline_start,
-eCSSKeyword_inline_table,
-eCSSKeyword_inset,
-eCSSKeyword_inside,
-eCSSKeyword_inter_character,
-eCSSKeyword_inter_word,
-eCSSKeyword_interpolatematrix,
-eCSSKeyword_accumulatematrix,
-eCSSKeyword_intersect,
-eCSSKeyword_isolate,
-eCSSKeyword_isolate_override,
-eCSSKeyword_invert,
-eCSSKeyword_italic,
-eCSSKeyword_japanese_formal,
-eCSSKeyword_japanese_informal,
-eCSSKeyword_jis78,
-eCSSKeyword_jis83,
-eCSSKeyword_jis90,
-eCSSKeyword_jis04,
-eCSSKeyword_justify,
-eCSSKeyword_keep_all,
-eCSSKeyword_khz,
-eCSSKeyword_korean_hangul_formal,
-eCSSKeyword_korean_hanja_formal,
-eCSSKeyword_korean_hanja_informal,
-eCSSKeyword_landscape,
-eCSSKeyword_large,
-eCSSKeyword_larger,
-eCSSKeyword_last,
-eCSSKeyword_last_baseline,
-eCSSKeyword_layout,
-eCSSKeyword_left,
-eCSSKeyword_legacy,
-eCSSKeyword_lighten,
-eCSSKeyword_lighter,
-eCSSKeyword_line_through,
-eCSSKeyword_linear,
-eCSSKeyword_lining_nums,
-eCSSKeyword_list_item,
-eCSSKeyword_local,
-eCSSKeyword_logical,
-eCSSKeyword_looped,
-eCSSKeyword_lowercase,
-eCSSKeyword_lr,
-eCSSKeyword_lr_tb,
-eCSSKeyword_ltr,
-eCSSKeyword_luminance,
-eCSSKeyword_luminosity,
-eCSSKeyword_mandatory,
-eCSSKeyword_manipulation,
-eCSSKeyword_manual,
-eCSSKeyword_margin_box,
-eCSSKeyword_markers,
-eCSSKeyword_match_parent,
-eCSSKeyword_match_source,
-eCSSKeyword_matrix,
-eCSSKeyword_matrix3d,
-eCSSKeyword_max_content,
-eCSSKeyword_medium,
-eCSSKeyword_menu,
-eCSSKeyword_menutext,
-eCSSKeyword_message_box,
-eCSSKeyword_middle,
-eCSSKeyword_min_content,
-eCSSKeyword_minmax,
-eCSSKeyword_mix,
-eCSSKeyword_mixed,
-eCSSKeyword_mm,
-eCSSKeyword_monospace,
-eCSSKeyword_move,
-eCSSKeyword_ms,
-eCSSKeyword_multiply,
-eCSSKeyword_n_resize,
-eCSSKeyword_narrower,
-eCSSKeyword_ne_resize,
-eCSSKeyword_nesw_resize,
-eCSSKeyword_no_clip,
-eCSSKeyword_no_close_quote,
-eCSSKeyword_no_common_ligatures,
-eCSSKeyword_no_contextual,
-eCSSKeyword_no_discretionary_ligatures,
-eCSSKeyword_no_drag,
-eCSSKeyword_no_drop,
-eCSSKeyword_no_historical_ligatures,
-eCSSKeyword_no_open_quote,
-eCSSKeyword_no_repeat,
-eCSSKeyword_none,
-eCSSKeyword_normal,
-eCSSKeyword_not_allowed,
-eCSSKeyword_nowrap,
-eCSSKeyword_numeric,
-eCSSKeyword_ns_resize,
-eCSSKeyword_nw_resize,
-eCSSKeyword_nwse_resize,
-eCSSKeyword_oblique,
-eCSSKeyword_oldstyle_nums,
-eCSSKeyword_opacity,
-eCSSKeyword_open,
-eCSSKeyword_open_quote,
-eCSSKeyword_optional,
-eCSSKeyword_ordinal,
-eCSSKeyword_ornaments,
-eCSSKeyword_outset,
-eCSSKeyword_outside,
-eCSSKeyword_over,
-eCSSKeyword_overlay,
-eCSSKeyword_overline,
-eCSSKeyword_paint,
-eCSSKeyword_padding_box,
-eCSSKeyword_painted,
-eCSSKeyword_pan_x,
-eCSSKeyword_pan_y,
-eCSSKeyword_paused,
-eCSSKeyword_pc,
-eCSSKeyword_perspective,
-eCSSKeyword_petite_caps,
-eCSSKeyword_physical,
-eCSSKeyword_plaintext,
-eCSSKeyword_pointer,
-eCSSKeyword_polygon,
-eCSSKeyword_portrait,
-eCSSKeyword_pre,
-eCSSKeyword_pre_wrap,
-eCSSKeyword_pre_line,
-eCSSKeyword_preserve_3d,
-eCSSKeyword_progress,
-eCSSKeyword_progressive,
-eCSSKeyword_proportional_nums,
-eCSSKeyword_proportional_width,
-eCSSKeyword_proximity,
-eCSSKeyword_pt,
-eCSSKeyword_px,
-eCSSKeyword_rad,
-eCSSKeyword_read_only,
-eCSSKeyword_read_write,
-eCSSKeyword_relative,
-eCSSKeyword_repeat,
-eCSSKeyword_repeat_x,
-eCSSKeyword_repeat_y,
-eCSSKeyword_reverse,
-eCSSKeyword_ridge,
-eCSSKeyword_right,
-eCSSKeyword_rl,
-eCSSKeyword_rl_tb,
-eCSSKeyword_rotate,
-eCSSKeyword_rotate3d,
-eCSSKeyword_rotatex,
-eCSSKeyword_rotatey,
-eCSSKeyword_rotatez,
-eCSSKeyword_round,
-eCSSKeyword_row,
-eCSSKeyword_row_resize,
-eCSSKeyword_row_reverse,
-eCSSKeyword_rtl,
-eCSSKeyword_ruby,
-eCSSKeyword_ruby_base,
-eCSSKeyword_ruby_base_container,
-eCSSKeyword_ruby_text,
-eCSSKeyword_ruby_text_container,
-eCSSKeyword_running,
-eCSSKeyword_s,
-eCSSKeyword_s_resize,
-eCSSKeyword_safe,
-eCSSKeyword_saturate,
-eCSSKeyword_saturation,
-eCSSKeyword_scale,
-eCSSKeyword_scale_down,
-eCSSKeyword_scale3d,
-eCSSKeyword_scalex,
-eCSSKeyword_scaley,
-eCSSKeyword_scalez,
-eCSSKeyword_screen,
-eCSSKeyword_script,
-eCSSKeyword_scroll,
-eCSSKeyword_scrollbar,
-eCSSKeyword_scrollbar_small,
-eCSSKeyword_scrollbar_horizontal,
-eCSSKeyword_scrollbar_vertical,
-eCSSKeyword_se_resize,
-eCSSKeyword_select_after,
-eCSSKeyword_select_all,
-eCSSKeyword_select_before,
-eCSSKeyword_select_menu,
-eCSSKeyword_select_same,
-eCSSKeyword_self_end,
-eCSSKeyword_self_start,
-eCSSKeyword_semi_condensed,
-eCSSKeyword_semi_expanded,
-eCSSKeyword_separate,
-eCSSKeyword_sepia,
-eCSSKeyword_serif,
-eCSSKeyword_sesame,
-eCSSKeyword_show,
-eCSSKeyword_sideways,
-eCSSKeyword_sideways_lr,
-eCSSKeyword_sideways_right,
-eCSSKeyword_sideways_rl,
-eCSSKeyword_simp_chinese_formal,
-eCSSKeyword_simp_chinese_informal,
-eCSSKeyword_simplified,
-eCSSKeyword_skew,
-eCSSKeyword_skewx,
-eCSSKeyword_skewy,
-eCSSKeyword_slashed_zero,
-eCSSKeyword_slice,
-eCSSKeyword_small,
-eCSSKeyword_small_caps,
-eCSSKeyword_small_caption,
-eCSSKeyword_smaller,
-eCSSKeyword_smooth,
-eCSSKeyword_soft,
-eCSSKeyword_soft_light,
-eCSSKeyword_solid,
-eCSSKeyword_space_around,
-eCSSKeyword_space_between,
-eCSSKeyword_space_evenly,
-eCSSKeyword_span,
-eCSSKeyword_spell_out,
-eCSSKeyword_square,
-eCSSKeyword_stacked_fractions,
-eCSSKeyword_start,
-eCSSKeyword_static,
-eCSSKeyword_standalone,
-eCSSKeyword_status_bar,
-eCSSKeyword_step_end,
-eCSSKeyword_step_start,
-eCSSKeyword_sticky,
-eCSSKeyword_stretch,
-eCSSKeyword_stretch_to_fit,
-eCSSKeyword_stretched,
-eCSSKeyword_strict,
-eCSSKeyword_stroke,
-eCSSKeyword_stroke_box,
-eCSSKeyword_style,
-eCSSKeyword_styleset,
-eCSSKeyword_stylistic,
-eCSSKeyword_sub,
-eCSSKeyword_subgrid,
-eCSSKeyword_subtract,
-eCSSKeyword_super,
-eCSSKeyword_sw_resize,
-eCSSKeyword_swash,
-eCSSKeyword_swap,
-eCSSKeyword_table,
-eCSSKeyword_table_caption,
-eCSSKeyword_table_cell,
-eCSSKeyword_table_column,
-eCSSKeyword_table_column_group,
-eCSSKeyword_table_footer_group,
-eCSSKeyword_table_header_group,
-eCSSKeyword_table_row,
-eCSSKeyword_table_row_group,
-eCSSKeyword_tabular_nums,
-eCSSKeyword_tailed,
-eCSSKeyword_tb,
-eCSSKeyword_tb_rl,
-eCSSKeyword_text,
-eCSSKeyword_text_bottom,
-eCSSKeyword_text_top,
-eCSSKeyword_thick,
-eCSSKeyword_thin,
-eCSSKeyword_threeddarkshadow,
-eCSSKeyword_threedface,
-eCSSKeyword_threedhighlight,
-eCSSKeyword_threedlightshadow,
-eCSSKeyword_threedshadow,
-eCSSKeyword_titling_caps,
-eCSSKeyword_toggle,
-eCSSKeyword_top,
-eCSSKeyword_top_outside,
-eCSSKeyword_trad_chinese_formal,
-eCSSKeyword_trad_chinese_informal,
-eCSSKeyword_traditional,
-eCSSKeyword_translate,
-eCSSKeyword_translate3d,
-eCSSKeyword_translatex,
-eCSSKeyword_translatey,
-eCSSKeyword_translatez,
-eCSSKeyword_transparent,
-eCSSKeyword_triangle,
-eCSSKeyword_tri_state,
-eCSSKeyword_ultra_condensed,
-eCSSKeyword_ultra_expanded,
-eCSSKeyword_under,
-eCSSKeyword_underline,
-eCSSKeyword_unicase,
-eCSSKeyword_unsafe,
-eCSSKeyword_unset,
-eCSSKeyword_uppercase,
-eCSSKeyword_upright,
-eCSSKeyword_vertical,
-eCSSKeyword_vertical_lr,
-eCSSKeyword_vertical_rl,
-eCSSKeyword_vertical_text,
-eCSSKeyword_view_box,
-eCSSKeyword_visible,
-eCSSKeyword_visiblefill,
-eCSSKeyword_visiblepainted,
-eCSSKeyword_visiblestroke,
-eCSSKeyword_w_resize,
-eCSSKeyword_wait,
-eCSSKeyword_wavy,
-eCSSKeyword_weight,
-eCSSKeyword_wider,
-eCSSKeyword_window,
-eCSSKeyword_windowframe,
-eCSSKeyword_windowtext,
-eCSSKeyword_words,
-eCSSKeyword_wrap,
-eCSSKeyword_wrap_reverse,
-eCSSKeyword_write_only,
-eCSSKeyword_x_large,
-eCSSKeyword_x_small,
-eCSSKeyword_xx_large,
-eCSSKeyword_xx_small,
-eCSSKeyword_zoom_in,
-eCSSKeyword_zoom_out,
-
-
-eCSSKeyword_radio,
-eCSSKeyword_checkbox,
-eCSSKeyword_button_bevel,
-eCSSKeyword_toolbox,
-eCSSKeyword_toolbar,
-eCSSKeyword_toolbarbutton,
-eCSSKeyword_toolbargripper,
-eCSSKeyword_dualbutton,
-eCSSKeyword_toolbarbutton_dropdown,
-eCSSKeyword_button_arrow_up,
-eCSSKeyword_button_arrow_down,
-eCSSKeyword_button_arrow_next,
-eCSSKeyword_button_arrow_previous,
-eCSSKeyword_separator,
-eCSSKeyword_splitter,
-eCSSKeyword_statusbar,
-eCSSKeyword_statusbarpanel,
-eCSSKeyword_resizerpanel,
-eCSSKeyword_resizer,
-eCSSKeyword_listbox,
-eCSSKeyword_listitem,
-eCSSKeyword_numbers,
-eCSSKeyword_number_input,
-eCSSKeyword_treeview,
-eCSSKeyword_treeitem,
-eCSSKeyword_treetwisty,
-eCSSKeyword_treetwistyopen,
-eCSSKeyword_treeline,
-eCSSKeyword_treeheader,
-eCSSKeyword_treeheadercell,
-eCSSKeyword_treeheadersortarrow,
-eCSSKeyword_progressbar,
-eCSSKeyword_progressbar_vertical,
-eCSSKeyword_progresschunk,
-eCSSKeyword_progresschunk_vertical,
-eCSSKeyword_tab,
-eCSSKeyword_tabpanels,
-eCSSKeyword_tabpanel,
-eCSSKeyword_tab_scroll_arrow_back,
-eCSSKeyword_tab_scroll_arrow_forward,
-eCSSKeyword_tooltip,
-eCSSKeyword_spinner,
-eCSSKeyword_spinner_upbutton,
-eCSSKeyword_spinner_downbutton,
-eCSSKeyword_spinner_textfield,
-eCSSKeyword_scrollbarbutton_up,
-eCSSKeyword_scrollbarbutton_down,
-eCSSKeyword_scrollbarbutton_left,
-eCSSKeyword_scrollbarbutton_right,
-eCSSKeyword_scrollbartrack_horizontal,
-eCSSKeyword_scrollbartrack_vertical,
-eCSSKeyword_scrollbarthumb_horizontal,
-eCSSKeyword_scrollbarthumb_vertical,
-eCSSKeyword_sheet,
-eCSSKeyword_textfield,
-eCSSKeyword_textfield_multiline,
-eCSSKeyword_caret,
-eCSSKeyword_searchfield,
-eCSSKeyword_menubar,
-eCSSKeyword_menupopup,
-eCSSKeyword_menuitem,
-eCSSKeyword_checkmenuitem,
-eCSSKeyword_radiomenuitem,
-eCSSKeyword_menucheckbox,
-eCSSKeyword_menuradio,
-eCSSKeyword_menuseparator,
-eCSSKeyword_menuarrow,
-eCSSKeyword_menuimage,
-eCSSKeyword_menuitemtext,
-eCSSKeyword_menulist,
-eCSSKeyword_menulist_button,
-eCSSKeyword_menulist_text,
-eCSSKeyword_menulist_textfield,
-eCSSKeyword_meterbar,
-eCSSKeyword_meterchunk,
-eCSSKeyword_minimal_ui,
-eCSSKeyword_range,
-eCSSKeyword_range_thumb,
-eCSSKeyword_sans_serif,
-eCSSKeyword_sans_serif_bold_italic,
-eCSSKeyword_sans_serif_italic,
-eCSSKeyword_scale_horizontal,
-eCSSKeyword_scale_vertical,
-eCSSKeyword_scalethumb_horizontal,
-eCSSKeyword_scalethumb_vertical,
-eCSSKeyword_scalethumbstart,
-eCSSKeyword_scalethumbend,
-eCSSKeyword_scalethumbtick,
-eCSSKeyword_groupbox,
-eCSSKeyword_checkbox_container,
-eCSSKeyword_radio_container,
-eCSSKeyword_checkbox_label,
-eCSSKeyword_radio_label,
-eCSSKeyword_button_focus,
-eCSSKeyword__moz_win_media_toolbox,
-eCSSKeyword__moz_win_communications_toolbox,
-eCSSKeyword__moz_win_browsertabbar_toolbox,
-eCSSKeyword__moz_win_mediatext,
-eCSSKeyword__moz_win_communicationstext,
-eCSSKeyword__moz_win_glass,
-eCSSKeyword__moz_win_borderless_glass,
-eCSSKeyword__moz_window_titlebar,
-eCSSKeyword__moz_window_titlebar_maximized,
-eCSSKeyword__moz_window_frame_left,
-eCSSKeyword__moz_window_frame_right,
-eCSSKeyword__moz_window_frame_bottom,
-eCSSKeyword__moz_window_button_close,
-eCSSKeyword__moz_window_button_minimize,
-eCSSKeyword__moz_window_button_maximize,
-eCSSKeyword__moz_window_button_restore,
-eCSSKeyword__moz_window_button_box,
-eCSSKeyword__moz_window_button_box_maximized,
-eCSSKeyword__moz_mac_help_button,
-eCSSKeyword__moz_win_exclude_glass,
-eCSSKeyword__moz_mac_vibrancy_light,
-eCSSKeyword__moz_mac_vibrancy_dark,
-eCSSKeyword__moz_mac_disclosure_button_closed,
-eCSSKeyword__moz_mac_disclosure_button_open,
-eCSSKeyword__moz_mac_source_list,
-eCSSKeyword__moz_mac_source_list_selection,
-eCSSKeyword__moz_mac_active_source_list_selection,
-eCSSKeyword_alphabetic,
-eCSSKeyword_bevel,
-eCSSKeyword_butt,
-eCSSKeyword_central,
-eCSSKeyword_crispedges,
-eCSSKeyword_evenodd,
-eCSSKeyword_geometricprecision,
-eCSSKeyword_hanging,
-eCSSKeyword_ideographic,
-eCSSKeyword_linearrgb,
-eCSSKeyword_mathematical,
-
-eCSSKeyword_miter,
-eCSSKeyword_no_change,
-eCSSKeyword_non_scaling_stroke,
-eCSSKeyword_nonzero,
-eCSSKeyword_optimizelegibility,
-eCSSKeyword_optimizequality,
-eCSSKeyword_optimizespeed,
-eCSSKeyword_reset_size,
-
-
-eCSSKeyword_srgb,
-eCSSKeyword_symbolic,
-eCSSKeyword_symbols,
-eCSSKeyword_text_after_edge,
-eCSSKeyword_text_before_edge,
-eCSSKeyword_use_script,
-eCSSKeyword__moz_crisp_edges,
-eCSSKeyword_space,
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSKeywords.h" 2
- eCSSKeyword_COUNT
-};
-
-
-
-class nsCSSKeywords {
-public:
-  static void AddRefTable(void);
-  static void ReleaseTable(void);
-
-
-  static nsCSSKeyword LookupKeyword(const nsACString& aKeyword);
-  static nsCSSKeyword LookupKeyword(const nsAString& aKeyword);
-
-
-  static const nsAFlatCString& GetStringValue(nsCSSKeyword aKeyword);
-};
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 1
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h"
-enum nsCSSPropertyID {
-  eCSSProperty_UNKNOWN = -1,
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h" 1
-# 328 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_align_content,
-# 338 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_align_items,
-# 348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_align_self,
-# 370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_delay,
-# 381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_direction,
-# 392 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_duration,
-# 403 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_fill_mode,
-# 414 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_iteration_count,
-# 428 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_name,
-# 441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_play_state,
-# 452 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_animation_timing_function,
-# 463 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_appearance,
-# 474 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_appearance,
-# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_backface_visibility,
-# 501 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_attachment,
-# 514 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_blend_mode,
-# 527 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_clip,
-# 540 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_color,
-# 554 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_image,
-# 569 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_origin,
-# 589 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_position_x,
-# 603 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_position_y,
-# 617 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_repeat,
-# 630 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_size,
-# 645 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_binding,
-# 655 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_block_size,
-# 685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_end_color,
-# 701 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_end_style,
-# 717 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_end_width,
-# 741 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_start_color,
-# 756 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_start_style,
-# 771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_start_width,
-# 794 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom_color,
-# 807 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_border_bottom_colors,
-# 819 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom_left_radius,
-# 832 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom_right_radius,
-# 845 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom_style,
-# 856 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom_width,
-# 870 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_collapse,
-# 893 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_image_outset,
-# 904 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_image_repeat,
-# 915 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_image_slice,
-# 926 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_image_source,
-# 938 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_image_width,
-# 955 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_end_color,
-# 970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_end_style,
-# 985 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_end_width,
-# 1008 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_start_color,
-# 1022 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_start_style,
-# 1036 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_start_width,
-# 1058 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_left_color,
-# 1071 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_border_left_colors,
-# 1083 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_left_style,
-# 1094 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_left_width,
-# 1120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_right_color,
-# 1133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_border_right_colors,
-# 1145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_right_style,
-# 1156 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_right_width,
-# 1170 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_spacing,
-# 1194 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_top_color,
-# 1207 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_border_top_colors,
-# 1219 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_top_left_radius,
-# 1232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_top_right_radius,
-# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_top_style,
-# 1256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_top_width,
-# 1277 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_bottom,
-# 1290 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_align,
-# 1300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_box_decoration_break,
-# 1310 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_direction,
-# 1320 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_flex,
-# 1331 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_ordinal_group,
-# 1342 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_orient,
-# 1352 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_box_pack,
-# 1362 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_box_shadow,
-# 1376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_box_sizing,
-# 1386 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_caption_side,
-# 1396 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_caret_color,
-# 1407 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_clear,
-# 1417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_clip,
-# 1428 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_clip_path,
-# 1441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_clip_rule,
-# 1451 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_color,
-# 1465 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_color_adjust,
-# 1475 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_color_interpolation,
-# 1485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_color_interpolation_filters,
-# 1495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_count,
-# 1508 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_fill,
-# 1518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_gap,
-# 1535 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_rule_color,
-# 1546 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_rule_style,
-# 1556 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_rule_width,
-# 1567 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_span,
-# 1577 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_width,
-# 1594 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_contain,
-# 1607 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_content,
-# 1619 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_control_character_visibility,
-# 1631 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_counter_increment,
-# 1641 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_counter_reset,
-# 1651 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_cursor,
-# 1665 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_direction,
-# 1676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_display,
-# 1690 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_dominant_baseline,
-# 1700 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_empty_cells,
-# 1710 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_fill,
-# 1720 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_fill_opacity,
-# 1730 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_fill_rule,
-# 1740 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_filter,
-# 1758 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_basis,
-# 1773 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_direction,
-# 1789 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_grow,
-# 1803 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_shrink,
-# 1817 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_wrap,
-# 1827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_float_,
-# 1838 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_float_edge,
-# 1848 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flood_color,
-# 1858 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flood_opacity,
-# 1874 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_family,
-# 1887 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_feature_settings,
-# 1900 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_kerning,
-# 1912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_language_override,
-# 1924 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_size,
-# 1940 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_size_adjust,
-# 1953 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_stretch,
-# 1965 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_style,
-# 1977 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_synthesis,
-# 1996 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_alternates,
-# 2009 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_caps,
-# 2021 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_east_asian,
-# 2034 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_ligatures,
-# 2047 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_numeric,
-# 2060 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant_position,
-# 2072 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variation_settings,
-# 2086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_weight,
-# 2100 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_force_broken_image_icon,
-# 2123 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_auto_columns,
-# 2135 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_auto_flow,
-# 2146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_auto_rows,
-# 2164 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_column_end,
-# 2174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_column_gap,
-# 2186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_column_start,
-# 2208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_row_end,
-# 2218 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_row_gap,
-# 2230 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_row_start,
-# 2246 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_template_areas,
-# 2257 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_template_columns,
-# 2270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_template_rows,
-# 2283 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_height,
-# 2297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_hyphens,
-# 2307 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_initial_letter,
-# 2318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_image_orientation,
-# 2329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_image_region,
-# 2339 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_image_rendering,
-# 2349 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_ime_mode,
-# 2359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_inline_size,
-# 2376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_isolation,
-# 2387 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_justify_content,
-# 2397 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_justify_items,
-# 2408 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_justify_self,
-# 2420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__x_lang,
-# 2433 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_left,
-# 2446 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_letter_spacing,
-# 2459 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_lighting_color,
-# 2469 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_line_height,
-# 2489 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_list_style_image,
-# 2500 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_list_style_position,
-# 2510 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_list_style_type,
-# 2529 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_block_end,
-# 2548 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_block_start,
-# 2566 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_bottom,
-# 2581 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_inline_end,
-# 2598 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_inline_start,
-# 2614 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_left,
-# 2629 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_right,
-# 2644 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin_top,
-# 2665 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_marker_end,
-# 2675 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_marker_mid,
-# 2685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_marker_start,
-# 2714 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_clip,
-# 2725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_composite,
-# 2736 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_image,
-# 2749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_mode,
-# 2760 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_origin,
-# 2778 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_position_x,
-# 2790 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_position_y,
-# 2802 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_repeat,
-# 2813 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_size,
-# 2827 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_type,
-# 2839 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_math_display,
-# 2851 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_math_variant,
-# 2864 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_max_block_size,
-# 2882 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_max_height,
-# 2895 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_max_inline_size,
-# 2912 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_max_width,
-# 2925 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_min_block_size,
-# 2944 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_min_font_size_ratio,
-# 2957 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_min_height,
-# 2970 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_min_inline_size,
-# 2987 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_min_width,
-# 3000 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mix_blend_mode,
-# 3011 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_object_fit,
-# 3021 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_object_position,
-# 3032 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_offset_block_end,
-# 3049 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_offset_block_start,
-# 3065 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_offset_inline_end,
-# 3081 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_offset_inline_start,
-# 3096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_opacity,
-# 3109 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_order,
-# 3119 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_orient,
-# 3129 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_osx_font_smoothing,
-# 3147 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_outline_color,
-# 3158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_outline_offset,
-# 3174 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_outline_radius_bottomleft,
-# 3186 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_outline_radius_bottomright,
-# 3198 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_outline_radius_topleft,
-# 3210 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_outline_radius_topright,
-# 3222 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_outline_style,
-# 3232 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_outline_width,
-# 3249 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_overflow_clip_box,
-# 3261 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_overflow_x,
-# 3273 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_overflow_y,
-# 3292 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_block_end,
-# 3313 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_block_start,
-# 3333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_bottom,
-# 3350 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_inline_end,
-# 3370 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_inline_start,
-# 3389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_left,
-# 3406 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_right,
-# 3423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding_top,
-# 3440 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_page_break_after,
-# 3450 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_page_break_before,
-# 3460 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_page_break_inside,
-# 3470 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_paint_order,
-# 3480 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_perspective,
-# 3493 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_perspective_origin,
-# 3523 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_pointer_events,
-# 3534 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_position,
-# 3547 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_quotes,
-# 3557 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_resize,
-# 3571 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_right,
-# 3584 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_ruby_align,
-# 3594 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_ruby_position,
-# 3606 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_script_level,
-# 3624 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_script_min_size,
-# 3635 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_script_size_multiplier,
-# 3648 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_behavior,
-# 3658 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_coordinate,
-# 3671 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_destination,
-# 3683 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_points_x,
-# 3695 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_points_y,
-# 3713 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_type_x,
-# 3723 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_type_y,
-# 3733 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_shape_outside,
-# 3745 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_shape_rendering,
-# 3757 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__x_span,
-# 3770 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_stack_sizing,
-# 3780 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stop_color,
-# 3790 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stop_opacity,
-# 3800 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke,
-# 3810 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_dasharray,
-# 3823 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_dashoffset,
-# 3834 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_linecap,
-# 3844 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_linejoin,
-# 3854 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_miterlimit,
-# 3865 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_opacity,
-# 3875 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_stroke_width,
-# 3888 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__x_system_font,
-# 3902 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_tab_size,
-# 3913 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_table_layout,
-# 3923 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_align,
-# 3936 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_align_last,
-# 3946 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_anchor,
-# 3956 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_combine_upright,
-# 3973 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_decoration_color,
-# 3986 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_decoration_line,
-# 3999 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_decoration_style,
-# 4017 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_emphasis_color,
-# 4028 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_emphasis_position,
-# 4039 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_emphasis_style,
-# 4050 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__webkit_text_fill_color,
-# 4063 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_indent,
-# 4075 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_justify,
-# 4086 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_orientation,
-# 4096 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_overflow,
-# 4108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_rendering,
-# 4118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_shadow,
-# 4133 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_text_size_adjust,
-# 4149 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__webkit_text_stroke_color,
-# 4162 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__webkit_text_stroke_width,
-# 4175 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_transform,
-# 4189 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__x_text_zoom,
-# 4202 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_top,
-# 4216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_top_layer,
-# 4229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_touch_action,
-# 4240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transform,
-# 4263 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transform_box,
-# 4273 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transform_origin,
-# 4285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transform_style,
-# 4303 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transition_delay,
-# 4314 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transition_duration,
-# 4325 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transition_property,
-# 4336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transition_timing_function,
-# 4348 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_unicode_bidi,
-# 4359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_user_focus,
-# 4369 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_user_input,
-# 4379 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_user_modify,
-# 4389 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_user_select,
-# 4399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_vector_effect,
-# 4412 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_vertical_align,
-# 4426 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_visibility,
-# 4436 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_white_space,
-# 4448 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_width,
-# 4462 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_will_change,
-# 4473 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_window_dragging,
-# 4484 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_window_shadow,
-# 4497 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_word_break,
-# 4507 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_word_spacing,
-# 4521 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_overflow_wrap,
-# 4531 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_writing_mode,
-# 4541 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_z_index,
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-
-
-  eCSSProperty_COUNT_no_shorthands,
-
-  eCSSProperty_COUNT_DUMMY = eCSSProperty_COUNT_no_shorthands - 1,
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h" 1
-# 358 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_all,
-
-
-
-
-
-eCSSProperty_animation,
-# 495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background,
-# 582 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_background_position,
-# 673 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border,
-
-
-
-
-
-eCSSProperty_border_block_end,
-# 735 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_block_start,
-# 788 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_bottom,
-# 880 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_color,
-
-
-
-
-
-
-eCSSProperty_border_image,
-# 949 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_end,
-# 1002 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_inline_start,
-# 1052 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_left,
-# 1108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_radius,
-
-
-
-
-
-eCSSProperty_border_right,
-# 1182 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_style,
-
-
-
-
-
-eCSSProperty_border_top,
-# 1270 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_border_width,
-# 1529 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_column_rule,
-# 1588 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_columns,
-# 1752 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex,
-# 1783 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_flex_flow,
-# 1868 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font,
-# 1990 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_font_variant,
-# 2111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid,
-
-
-
-
-
-eCSSProperty_grid_area,
-# 2158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_column,
-# 2196 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_gap,
-
-
-
-
-
-eCSSProperty_grid_row,
-# 2240 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_grid_template,
-# 2483 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_list_style,
-# 2521 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_margin,
-# 2659 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_marker,
-# 2708 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask,
-# 2771 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_mask_position,
-# 3141 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_outline,
-# 3168 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_outline_radius,
-# 3243 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_overflow,
-# 3285 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_padding,
-# 3505 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_place_content,
-
-
-
-
-
-eCSSProperty_place_items,
-
-
-
-
-
-eCSSProperty_place_self,
-# 3707 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_scroll_snap_type,
-# 3967 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_decoration,
-# 4011 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_text_emphasis,
-# 4143 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__webkit_text_stroke,
-# 4256 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty__moz_transform,
-# 4297 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropList.h"
-eCSSProperty_transition,
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-
-  eCSSProperty_COUNT,
-
-  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1,
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h" 1
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h"
-eCSSPropertyAlias_WordWrap,
-
-
-
-eCSSPropertyAlias_MozTransformOrigin,
-
-
-
-eCSSPropertyAlias_MozPerspectiveOrigin,
-
-
-
-eCSSPropertyAlias_MozPerspective,
-
-
-
-eCSSPropertyAlias_MozTransformStyle,
-
-
-
-eCSSPropertyAlias_MozBackfaceVisibility,
-
-
-
-eCSSPropertyAlias_MozBorderImage,
-
-
-
-eCSSPropertyAlias_MozTransition,
-
-
-
-eCSSPropertyAlias_MozTransitionDelay,
-
-
-
-eCSSPropertyAlias_MozTransitionDuration,
-
-
-
-eCSSPropertyAlias_MozTransitionProperty,
-
-
-
-eCSSPropertyAlias_MozTransitionTimingFunction,
-
-
-
-eCSSPropertyAlias_MozAnimation,
-
-
-
-eCSSPropertyAlias_MozAnimationDelay,
-
-
-
-eCSSPropertyAlias_MozAnimationDirection,
-
-
-
-eCSSPropertyAlias_MozAnimationDuration,
-
-
-
-eCSSPropertyAlias_MozAnimationFillMode,
-
-
-
-eCSSPropertyAlias_MozAnimationIterationCount,
-
-
-
-eCSSPropertyAlias_MozAnimationName,
-
-
-
-eCSSPropertyAlias_MozAnimationPlayState,
-
-
-
-eCSSPropertyAlias_MozAnimationTimingFunction,
-
-
-
-eCSSPropertyAlias_MozBoxSizing,
-
-
-
-eCSSPropertyAlias_MozFontFeatureSettings,
-
-
-
-eCSSPropertyAlias_MozFontLanguageOverride,
-
-
-
-eCSSPropertyAlias_MozPaddingEnd,
-
-
-
-eCSSPropertyAlias_MozPaddingStart,
-
-
-
-eCSSPropertyAlias_MozMarginEnd,
-
-
-
-eCSSPropertyAlias_MozMarginStart,
-
-
-
-eCSSPropertyAlias_MozBorderEnd,
-
-
-
-eCSSPropertyAlias_MozBorderEndColor,
-
-
-
-eCSSPropertyAlias_MozBorderEndStyle,
-
-
-
-eCSSPropertyAlias_MozBorderEndWidth,
-
-
-
-eCSSPropertyAlias_MozBorderStart,
-
-
-
-eCSSPropertyAlias_MozBorderStartColor,
-
-
-
-eCSSPropertyAlias_MozBorderStartStyle,
-
-
-
-eCSSPropertyAlias_MozBorderStartWidth,
-
-
-
-eCSSPropertyAlias_MozHyphens,
-
-
-
-eCSSPropertyAlias_MozColumnCount,
-
-
-
-eCSSPropertyAlias_MozColumnFill,
-
-
-
-eCSSPropertyAlias_MozColumnGap,
-
-
-
-eCSSPropertyAlias_MozColumnRule,
-
-
-
-eCSSPropertyAlias_MozColumnRuleColor,
-
-
-
-eCSSPropertyAlias_MozColumnRuleStyle,
-
-
-
-eCSSPropertyAlias_MozColumnRuleWidth,
-
-
-
-eCSSPropertyAlias_MozColumnWidth,
-
-
-
-eCSSPropertyAlias_MozColumns,
-
-
-
-
-
-
-
-eCSSPropertyAlias_WebkitAnimation,
-
-
-
-eCSSPropertyAlias_WebkitAnimationDelay,
-
-
-
-eCSSPropertyAlias_WebkitAnimationDirection,
-
-
-
-eCSSPropertyAlias_WebkitAnimationDuration,
-
-
-
-eCSSPropertyAlias_WebkitAnimationFillMode,
-
-
-
-eCSSPropertyAlias_WebkitAnimationIterationCount,
-
-
-
-eCSSPropertyAlias_WebkitAnimationName,
-
-
-
-eCSSPropertyAlias_WebkitAnimationPlayState,
-
-
-
-eCSSPropertyAlias_WebkitAnimationTimingFunction,
-
-
-
-
-eCSSPropertyAlias_WebkitAppearance,
-
-
-
-
-eCSSPropertyAlias_WebkitFilter,
-
-
-
-eCSSPropertyAlias_WebkitTextSizeAdjust,
-
-
-
-
-eCSSPropertyAlias_WebkitTransform,
-
-
-
-eCSSPropertyAlias_WebkitTransformOrigin,
-
-
-
-eCSSPropertyAlias_WebkitTransformStyle,
-
-
-
-eCSSPropertyAlias_WebkitBackfaceVisibility,
-
-
-
-eCSSPropertyAlias_WebkitPerspective,
-
-
-
-eCSSPropertyAlias_WebkitPerspectiveOrigin,
-
-
-
-
-eCSSPropertyAlias_WebkitTransition,
-
-
-
-eCSSPropertyAlias_WebkitTransitionDelay,
-
-
-
-eCSSPropertyAlias_WebkitTransitionDuration,
-
-
-
-eCSSPropertyAlias_WebkitTransitionProperty,
-
-
-
-eCSSPropertyAlias_WebkitTransitionTimingFunction,
-
-
-
-
-eCSSPropertyAlias_WebkitBorderRadius,
-
-
-
-eCSSPropertyAlias_WebkitBorderTopLeftRadius,
-
-
-
-eCSSPropertyAlias_WebkitBorderTopRightRadius,
-
-
-
-eCSSPropertyAlias_WebkitBorderBottomLeftRadius,
-
-
-
-eCSSPropertyAlias_WebkitBorderBottomRightRadius,
-
-
-
-
-eCSSPropertyAlias_WebkitBackgroundClip,
-
-
-
-eCSSPropertyAlias_WebkitBackgroundOrigin,
-
-
-
-eCSSPropertyAlias_WebkitBackgroundSize,
-
-
-
-
-eCSSPropertyAlias_WebkitBorderImage,
-
-
-
-
-eCSSPropertyAlias_WebkitBoxShadow,
-
-
-
-eCSSPropertyAlias_WebkitBoxSizing,
-# 376 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropAliasList.h"
-eCSSPropertyAlias_WebkitBoxFlex,
-
-
-
-eCSSPropertyAlias_WebkitBoxOrdinalGroup,
-
-
-
-eCSSPropertyAlias_WebkitBoxOrient,
-
-
-
-eCSSPropertyAlias_WebkitBoxDirection,
-
-
-
-eCSSPropertyAlias_WebkitBoxAlign,
-
-
-
-eCSSPropertyAlias_WebkitBoxPack,
-
-
-
-
-
-
-eCSSPropertyAlias_WebkitFlexDirection,
-
-
-
-eCSSPropertyAlias_WebkitFlexWrap,
-
-
-
-eCSSPropertyAlias_WebkitFlexFlow,
-
-
-
-eCSSPropertyAlias_WebkitOrder,
-
-
-
-eCSSPropertyAlias_WebkitFlex,
-
-
-
-eCSSPropertyAlias_WebkitFlexGrow,
-
-
-
-eCSSPropertyAlias_WebkitFlexShrink,
-
-
-
-eCSSPropertyAlias_WebkitFlexBasis,
-
-
-
-eCSSPropertyAlias_WebkitJustifyContent,
-
-
-
-eCSSPropertyAlias_WebkitAlignItems,
-
-
-
-eCSSPropertyAlias_WebkitAlignSelf,
-
-
-
-eCSSPropertyAlias_WebkitAlignContent,
-
-
-
-
-eCSSPropertyAlias_WebkitUserSelect,
-
-
-
-
-
-eCSSPropertyAlias_WebkitMask,
-
-
-
-eCSSPropertyAlias_WebkitMaskClip,
-
-
-
-eCSSPropertyAlias_WebkitMaskComposite,
-
-
-
-eCSSPropertyAlias_WebkitMaskImage,
-
-
-
-eCSSPropertyAlias_WebkitMaskOrigin,
-
-
-
-eCSSPropertyAlias_WebkitMaskPosition,
-
-
-
-eCSSPropertyAlias_WebkitMaskPositionX,
-
-
-
-eCSSPropertyAlias_WebkitMaskPositionY,
-
-
-
-eCSSPropertyAlias_WebkitMaskRepeat,
-
-
-
-eCSSPropertyAlias_WebkitMaskSize,
-# 47 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-
-  eCSSProperty_COUNT_with_aliases,
-
-  eCSSProperty_COUNT_DUMMY3 = eCSSProperty_COUNT_with_aliases - 1,
-
-
-
-
-
-
-  eCSSPropertyExtra_no_properties,
-  eCSSPropertyExtra_all_properties,
-
-
-  eCSSPropertyExtra_x_none_value,
-  eCSSPropertyExtra_x_auto_value,
-
-
-  eCSSPropertyExtra_variable,
-
-
-  eCSSProperty_DOM
-};
-
-namespace mozilla {
-
-template<>
-inline PLDHashNumber
-Hash<nsCSSPropertyID>(const nsCSSPropertyID& aValue)
-{
-  return uint32_t(aValue);
-}
-
-}
-
-
-
-enum nsCSSFontDesc {
-  eCSSFontDesc_UNKNOWN = -1,
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSFontDescList.h" 1
-
-
-
-
-
-eCSSFontDesc_Family,
-eCSSFontDesc_Style,
-eCSSFontDesc_Weight,
-eCSSFontDesc_Stretch,
-eCSSFontDesc_Src,
-eCSSFontDesc_UnicodeRange,
-eCSSFontDesc_FontFeatureSettings,
-eCSSFontDesc_FontLanguageOverride,
-eCSSFontDesc_Display,
-# 89 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-  eCSSFontDesc_COUNT
-};
-
-
-
-enum nsCSSCounterDesc {
-  eCSSCounterDesc_UNKNOWN = -1,
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSCounterDescList.h" 1
-
-
-
-
-
-eCSSCounterDesc_System,
-eCSSCounterDesc_Symbols,
-eCSSCounterDesc_AdditiveSymbols,
-eCSSCounterDesc_Negative,
-eCSSCounterDesc_Prefix,
-eCSSCounterDesc_Suffix,
-eCSSCounterDesc_Range,
-eCSSCounterDesc_Pad,
-eCSSCounterDesc_Fallback,
-eCSSCounterDesc_SpeakAs,
-# 99 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-  eCSSCounterDesc_COUNT
-};
-
-enum nsCSSPropertyLogicalGroup {
-  eCSSPropertyLogicalGroup_UNKNOWN = -1,
-
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropLogicalGroupList.h" 1
-# 48 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropLogicalGroupList.h"
-eCSSPropertyLogicalGroup_BorderColor,
-eCSSPropertyLogicalGroup_BorderStyle,
-eCSSPropertyLogicalGroup_BorderWidth,
-eCSSPropertyLogicalGroup_Margin,
-eCSSPropertyLogicalGroup_MaxSize,
-eCSSPropertyLogicalGroup_Offset,
-eCSSPropertyLogicalGroup_Padding,
-eCSSPropertyLogicalGroup_MinSize,
-eCSSPropertyLogicalGroup_Size,
-# 112 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPropertyID.h" 2
-
-
-
-  eCSSPropertyLogicalGroup_COUNT
-};
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h"
-enum nsStyleStructID {
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h"
-nsStyleStructID_None = -1,
-nsStyleStructID_Inherited_Start = 0,
-
-nsStyleStructID_DUMMY1 = nsStyleStructID_Inherited_Start - 1,
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
-eStyleStruct_Font,
-
-
-
-eStyleStruct_Color,
-
-
-eStyleStruct_List,
-
-
-
-
-eStyleStruct_Text,
-
-
-
-
-
-eStyleStruct_Visibility,
-
-
-eStyleStruct_UserInterface,
-
-
-eStyleStruct_TableBorder,
-
-
-
-
-eStyleStruct_SVG,
-
-
-
-
-
-eStyleStruct_Variables,
-# 35 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 2
-
-
-
-nsStyleStructID_Reset_Start,
-
-nsStyleStructID_DUMMY2 = nsStyleStructID_Reset_Start - 1,
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
-# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
-eStyleStruct_Background,
-
-
-
-
-
-eStyleStruct_Position,
-
-
-
-
-eStyleStruct_TextReset,
-
-
-
-
-
-eStyleStruct_Display,
-
-
-
-
-eStyleStruct_Content,
-
-
-
-
-eStyleStruct_UIReset,
-
-
-eStyleStruct_Table,
-
-
-eStyleStruct_Margin,
-
-
-
-
-eStyleStruct_Padding,
-
-
-
-
-eStyleStruct_Border,
-
-
-
-
-
-eStyleStruct_Outline,
-
-
-
-
-
-eStyleStruct_XUL,
-
-
-eStyleStruct_SVGReset,
-
-
-
-
-
-eStyleStruct_Column,
-
-
-
-
-
-eStyleStruct_Effects,
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructFwd.h" 2
-
-
-
-
-nsStyleStructID_Length,
-
-nsStyleStructID_Inherited_Count =
-  nsStyleStructID_Reset_Start - nsStyleStructID_Inherited_Start,
-nsStyleStructID_Reset_Count =
-  nsStyleStructID_Length - nsStyleStructID_Reset_Start,
-
-};
-
-
-
-
-typedef decltype(nsStyleStructID(0) + nsStyleStructID(0)) nsStyleStructID_size_t;
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 2
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/xrecore.h" 1
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h" 1
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
-struct PRFileDesc;
-struct PRLibrary;
-
-class nsISimpleEnumerator;
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
-class nsIFile : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    NORMAL_FILE_TYPE = 0U,
-    DIRECTORY_TYPE = 1U
-  };
-
-
-  virtual nsresult Append(const nsAString & node) = 0;
-
-
-  virtual nsresult AppendNative(const nsACString & node) = 0;
-
-
-  virtual nsresult Normalize(void) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult Create(uint32_t type, uint32_t permissions) = 0;
-
-
-  virtual nsresult GetLeafName(nsAString & aLeafName) = 0;
-  virtual nsresult SetLeafName(const nsAString & aLeafName) = 0;
-
-
-  virtual nsresult GetNativeLeafName(nsACString & aNativeLeafName) = 0;
-  virtual nsresult SetNativeLeafName(const nsACString & aNativeLeafName) = 0;
-
-
-  virtual nsresult CopyTo(nsIFile *newParentDir, const nsAString & newName) = 0;
-
-
-  virtual nsresult CopyToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
-
-
-  virtual nsresult CopyToFollowingLinks(nsIFile *newParentDir, const nsAString & newName) = 0;
-
-
-  virtual nsresult CopyToFollowingLinksNative(nsIFile *newParentDir, const nsACString & newName) = 0;
-
-
-  virtual nsresult MoveTo(nsIFile *newParentDir, const nsAString & newName) = 0;
-
-
-  virtual nsresult MoveToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
-
-
-  virtual nsresult RenameTo(nsIFile *newParentDir, const nsAString & newName) = 0;
-
-
-  virtual nsresult RenameToNative(nsIFile *newParentDir, const nsACString & newName) = 0;
-
-
-  virtual nsresult Remove(bool recursive) = 0;
-
-
-  virtual nsresult GetPermissions(uint32_t *aPermissions) = 0;
-  virtual nsresult SetPermissions(uint32_t aPermissions) = 0;
-
-
-  virtual nsresult GetPermissionsOfLink(uint32_t *aPermissionsOfLink) = 0;
-  virtual nsresult SetPermissionsOfLink(uint32_t aPermissionsOfLink) = 0;
-
-
-  virtual nsresult GetLastModifiedTime(PRTime *aLastModifiedTime) = 0;
-  virtual nsresult SetLastModifiedTime(PRTime aLastModifiedTime) = 0;
-
-
-  virtual nsresult GetLastModifiedTimeOfLink(PRTime *aLastModifiedTimeOfLink) = 0;
-  virtual nsresult SetLastModifiedTimeOfLink(PRTime aLastModifiedTimeOfLink) = 0;
-
-
-  virtual nsresult GetFileSize(int64_t *aFileSize) = 0;
-  virtual nsresult SetFileSize(int64_t aFileSize) = 0;
-
-
-  virtual nsresult GetFileSizeOfLink(int64_t *aFileSizeOfLink) = 0;
-
-
-  virtual nsresult GetTarget(nsAString & aTarget) = 0;
-
-
-  virtual nsresult GetNativeTarget(nsACString & aNativeTarget) = 0;
-
-
-  virtual nsresult GetPath(nsAString & aPath) = 0;
-
-
-  virtual nsresult GetNativePath(nsACString & aNativePath) = 0;
-
-
-  virtual nsresult Exists(bool *_retval) = 0;
-
-
-  virtual nsresult IsWritable(bool *_retval) = 0;
-
-
-  virtual nsresult IsReadable(bool *_retval) = 0;
-
-
-  virtual nsresult IsExecutable(bool *_retval) = 0;
-
-
-  virtual nsresult IsHidden(bool *_retval) = 0;
-
-
-  virtual nsresult IsDirectory(bool *_retval) = 0;
-
-
-  virtual nsresult IsFile(bool *_retval) = 0;
-
-
-  virtual nsresult IsSymlink(bool *_retval) = 0;
-
-
-  virtual nsresult IsSpecial(bool *_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult CreateUnique(uint32_t type, uint32_t permissions) = 0;
-
-
-  virtual nsresult Clone(nsIFile * *_retval) = 0;
-
-
-  virtual nsresult Equals(nsIFile *inFile, bool *_retval) = 0;
-
-
-  virtual nsresult Contains(nsIFile *inFile, bool *_retval) = 0;
-
-
-  virtual nsresult GetParent(nsIFile * *aParent) = 0;
-
-
-  virtual nsresult GetDirectoryEntries(nsISimpleEnumerator * *aDirectoryEntries) = 0;
-
-
-  virtual nsresult InitWithPath(const nsAString & filePath) = 0;
-
-
-  virtual nsresult InitWithNativePath(const nsACString & filePath) = 0;
-
-
-  virtual nsresult InitWithFile(nsIFile *aFile) = 0;
-
-
-  virtual nsresult GetFollowLinks(bool *aFollowLinks) = 0;
-  virtual nsresult SetFollowLinks(bool aFollowLinks) = 0;
-
-  enum {
-    OS_READAHEAD = 1073741824U,
-    DELETE_ON_CLOSE = 2147483648U
-  };
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult OpenNSPRFileDesc(int32_t flags, int32_t mode, PRFileDesc **_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult OpenANSIFileDesc(const char * mode, FILE **_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult Load(PRLibrary **_retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable) = 0;
-
-
-  virtual nsresult AppendRelativePath(const nsAString & relativeFilePath) = 0;
-
-
-  virtual nsresult AppendRelativeNativePath(const nsACString & relativeFilePath) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetPersistentDescriptor(nsACString & aPersistentDescriptor) = 0;
-  __attribute__ ((warn_unused_result)) virtual nsresult SetPersistentDescriptor(const nsACString & aPersistentDescriptor) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult Reveal(void) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult Launch(void) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRelativeDescriptor(nsIFile *fromFile, nsACString & _retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRelativeDescriptor(nsIFile *fromFile, const nsACString & relativeDesc) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult GetRelativePath(nsIFile *fromFile, nsACString & _retval) = 0;
-
-
-  __attribute__ ((warn_unused_result)) virtual nsresult SetRelativePath(nsIFile *fromFile, const nsACString & relativeDesc) = 0;
-
-};
-
-  template<typename T> struct nsIFile::COMTypeInfo<nsIFile, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIFile::COMTypeInfo<nsIFile, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x2fa6884a, 0xae65, 0x412a, { 0x9d, 0x4c, 0xce, 0x6e, 0x34, 0x54, 0x4b, 0xa1 }};
-# 920 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIProperties.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIProperties.h"
-class nsIProperties : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult Get(const char * prop, const nsIID & iid, void **result) = 0;
-
-
-  virtual nsresult Set(const char * prop, nsISupports *value) = 0;
-
-
-  virtual nsresult Has(const char * prop, bool *_retval) = 0;
-
-
-  virtual nsresult Undefine(const char * prop) = 0;
-
-
-  virtual nsresult GetKeys(uint32_t *count, char * **keys) = 0;
-
-};
-
-  template<typename T> struct nsIProperties::COMTypeInfo<nsIProperties, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIProperties::COMTypeInfo<nsIProperties, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x78650582, 0x4e93, 0x4b60, { 0x8e, 0x85, 0x26, 0xeb, 0xd3, 0xeb, 0x14, 0xca }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 2
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsDirectoryServiceUtils.h" 2
-
-inline nsresult
-NS_GetSpecialDirectory(const char* aSpecialDirName, nsIFile** aResult)
-{
-  nsresult rv;
-  nsCOMPtr<nsIProperties> serv(do_GetService("@mozilla.org/file/directory_service;1",
-                                             &rv));
-  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
-    return rv;
-  }
-
-  return serv->Get(aSpecialDirName, (nsIFile::COMTypeInfo<nsIFile, void>::kIID),
-                   reinterpret_cast<void**>(aResult));
-}
-# 921 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIFile.h" 2
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h" 2
-# 27 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-namespace mozilla {
-
-struct StaticXREAppData;
-
-
-
-
-class XREAppData
-{
-public:
-  XREAppData() { }
-  ~XREAppData() { }
-  XREAppData(const XREAppData& aOther)
-  {
-    *this = aOther;
-  }
-
-  explicit XREAppData(const StaticXREAppData& aOther)
-  {
-    *this = aOther;
-  }
-
-  XREAppData& operator=(const StaticXREAppData& aOther);
-  XREAppData& operator=(const XREAppData& aOther);
-  XREAppData& operator=(XREAppData&& aOther) = default;
-
-  struct NSFreePolicy
-  {
-    void operator()(const void* ptr) {
-      free(const_cast<void*>(ptr));
-    }
-  };
-
-
-
-  class CharPtr
-  {
-  public:
-    explicit CharPtr() = default;
-    explicit CharPtr(const char* v)
-    {
-      *this = v;
-    }
-    CharPtr(CharPtr&&) = default;
-    ~CharPtr() = default;
-
-    CharPtr& operator=(const char* v)
-    {
-      if (v) {
-        mValue.reset(NS_strdup(v));
-      } else {
-        mValue = nullptr;
-      }
-      return *this;
-    }
-    CharPtr& operator=(const CharPtr& v)
-    {
-      *this = (const char*) v;
-      return *this;
-    }
-
-    operator const char*() const {
-      return mValue.get();
-    }
-
-  private:
-    UniquePtr<const char, NSFreePolicy> mValue;
-  };
-
-
-
-
-
-  nsCOMPtr<nsIFile> directory;
-
-
-
-
-
-
-  CharPtr vendor;
-
-
-
-
-
-
-  CharPtr name;
-
-
-
-
-
-
-  CharPtr remotingName;
-
-
-
-
-
-
-  CharPtr version;
-
-
-
-
-  CharPtr buildID;
-# 145 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-  CharPtr ID;
-
-
-
-
-
-  CharPtr copyright;
-
-
-
-
-  uint32_t flags = 0;
-
-
-
-
-
-  nsCOMPtr<nsIFile> xreDirectory;
-
-
-
-
-  CharPtr minVersion;
-  CharPtr maxVersion;
-
-
-
-
-  CharPtr crashReporterURL;
-# 190 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-  CharPtr profile;
-
-
-
-
-  CharPtr UAName;
-# 204 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-};
-# 223 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/XREAppData.h"
-struct StaticXREAppData
-{
-  const char* vendor;
-  const char* name;
-  const char* remotingName;
-  const char* version;
-  const char* buildID;
-  const char* ID;
-  const char* copyright;
-  uint32_t flags;
-  const char* minVersion;
-  const char* maxVersion;
-  const char* crashReporterURL;
-  const char* profile;
-  const char* UAName;
-};
-
-}
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h" 1
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h"
-struct XREChildData
-{
-# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREChildData.h"
-};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREShellData.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/XREShellData.h"
-struct XREShellData
-{
-
-
-
-
-
-
-};
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h" 2
-# 208 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-namespace mozilla {
-struct BootstrapConfig;
-}
-int XRE_main (int argc, char* argv[], const mozilla::BootstrapConfig& aConfig);
-# 220 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_GetFileFromPath (const char* aPath, nsIFile** aResult);
-# 229 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_GetBinaryPath (const char* aArgv0, nsIFile** aResult);
-
-
-
-
-
-const mozilla::Module* XRE_GetStaticModule ();
-# 245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_LockProfileDirectory (nsIFile* aDirectory, nsISupports** aLockObject);
-# 269 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_InitEmbedding2 (nsIFile* aLibXULDirectory, nsIFile* aAppDirectory, nsIDirectoryServiceProvider* aAppDirProvider);
-# 279 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_AddStaticComponent (const mozilla::Module* aComponent);
-# 300 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-enum NSLocationType
-{
-  NS_APP_LOCATION,
-  NS_EXTENSION_LOCATION,
-  NS_SKIN_LOCATION,
-  NS_BOOTSTRAPPED_LOCATION
-};
-
-nsresult XRE_AddManifestLocation (NSLocationType aType, nsIFile* aLocation);
-# 329 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_AddJarManifestLocation (NSLocationType aType, nsIFile* aLocation);
-# 359 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-void XRE_NotifyProfile ();
-
-
-
-
-
-void XRE_TermEmbedding ();
-# 375 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsXULAppAPI.h"
-nsresult XRE_ParseAppData (nsIFile* aINIFile, mozilla::XREAppData& aAppData);
-
-
-
-enum GeckoProcessType
-{
-  GeckoProcessType_Default = 0,
-
-  GeckoProcessType_Plugin,
-  GeckoProcessType_Content,
-
-  GeckoProcessType_IPDLUnitTest,
-
-  GeckoProcessType_GMPlugin,
-
-  GeckoProcessType_GPU,
-
-  GeckoProcessType_End,
-  GeckoProcessType_Invalid = GeckoProcessType_End
-};
-
-static const char* const kGeckoProcessTypeString[] = {
-  "default",
-  "plugin",
-  "tab",
-  "ipdlunittest",
-  "geckomediaplugin",
-  "gpu"
-};
-
-static_assert(sizeof(mozilla::detail::ArrayLengthHelper(kGeckoProcessTypeString)) ==
-              GeckoProcessType_End,
-              "Array length mismatch");
-
-const char* XRE_ChildProcessTypeToString (GeckoProcessType aProcessType);
-
-
-
-
-
-
-
-void XRE_SetProcessType (const char* aProcessTypeString);
-
-
-
-
-bool XRE_TakeMinidumpForChild (uint32_t aChildPid, nsIFile** aDump, uint32_t* aSequence);
-
-
-
-
-bool XRE_SetRemoteExceptionHandler (const char* aPipe);
-
-
-
-namespace mozilla {
-namespace gmp {
-class GMPLoader;
-}
-}
-
-nsresult XRE_InitChildProcess (int aArgc, char* aArgv[], const XREChildData* aChildData);
-
-
-
-
-GeckoProcessType XRE_GetProcessType ();
-
-
-bool XRE_IsParentProcess ();
-
-
-bool XRE_IsContentProcess ();
-
-
-bool XRE_IsGPUProcess ();
-
-
-typedef void (*MainFunction)(void* aData);
-
-nsresult XRE_InitParentProcess (int aArgc, char* aArgv[], MainFunction aMainFunction, void* aMainFunctionExtraData);
-
-
-
-
-
-int XRE_RunIPDLTest (int aArgc, char* aArgv[]);
-
-
-
-nsresult XRE_RunAppShell ();
-
-
-nsresult XRE_InitCommandLine (int aArgc, char* aArgv[]);
-
-
-nsresult XRE_DeinitCommandLine ();
-
-
-class MessageLoop;
-
-void XRE_ShutdownChildProcess ();
-
-
-MessageLoop* XRE_GetIOMessageLoop ();
-
-
-bool XRE_SendTestShellCommand (JSContext* aCx, JSString* aCommand, void* aCallback);
-
-
-
-bool XRE_ShutdownTestShell ();
-
-
-void XRE_InstallX11ErrorHandler ();
-
-
-void XRE_TelemetryAccumulate (int aID, uint32_t aSample);
-
-
-void XRE_StartupTimelineRecord (int aEvent, mozilla::TimeStamp aWhen);
-
-
-void XRE_InitOmnijar (nsIFile* aGreOmni, nsIFile* aAppOmni);
-
-
-void XRE_StopLateWriteChecks (void);
-
-
-void XRE_EnableSameExecutableForContentProc ();
-
-
-int XRE_XPCShellMain (int argc, char** argv, char** envp, const XREShellData* aShellData);
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h" 2
-# 188 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-static_assert(((7<<9) &
-               (1<<12)) == 0,
-              "didn't leave enough room for the parse property constants");
-# 289 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-enum nsStyleAnimType {
-
-
-  eStyleAnimType_Custom,
-
-
-  eStyleAnimType_Coord,
-
-
-
-  eStyleAnimType_Sides_Top,
-  eStyleAnimType_Sides_Right,
-  eStyleAnimType_Sides_Bottom,
-  eStyleAnimType_Sides_Left,
-
-
-
-  eStyleAnimType_Corner_TopLeft,
-  eStyleAnimType_Corner_TopRight,
-  eStyleAnimType_Corner_BottomRight,
-  eStyleAnimType_Corner_BottomLeft,
-
-
-  eStyleAnimType_nscoord,
-
-
-  eStyleAnimType_float,
-
-
-  eStyleAnimType_Color,
-
-
-  eStyleAnimType_ComplexColor,
-
-
-  eStyleAnimType_PaintServer,
-
-
-  eStyleAnimType_Shadow,
-
-
-  eStyleAnimType_Discrete,
-
-
-  eStyleAnimType_None
-};
-
-class nsCSSProps {
-public:
-  typedef mozilla::CSSEnabledState EnabledState;
-
-  struct KTableEntry
-  {
-
-
-
-    constexpr KTableEntry(nsCSSKeyword aKeyword, int16_t aValue)
-      : mKeyword(aKeyword)
-      , mValue(aValue)
-    {
-    }
-
-    template<typename T,
-             typename = typename std::enable_if<std::is_enum<T>::value>::type>
-    constexpr KTableEntry(nsCSSKeyword aKeyword, T aValue)
-      : mKeyword(aKeyword)
-      , mValue(static_cast<int16_t>(aValue))
-    {
-      static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
-                    "aValue must be an enum that fits within mValue");
-    }
-
-    nsCSSKeyword mKeyword;
-    int16_t mValue;
-  };
-
-  static void AddRefTable(void);
-  static void ReleaseTable(void);
-
-
-
-
-  static nsCSSPropertyID LookupProperty(const nsAString& aProperty,
-                                      EnabledState aEnabled);
-  static nsCSSPropertyID LookupProperty(const nsACString& aProperty,
-                                      EnabledState aEnabled);
-
-
-  static nsCSSPropertyID LookupPropertyByIDLName(
-      const nsAString& aPropertyIDLName,
-      EnabledState aEnabled);
-  static nsCSSPropertyID LookupPropertyByIDLName(
-      const nsACString& aPropertyIDLName,
-      EnabledState aEnabled);
-
-
-
-  static bool IsCustomPropertyName(const nsAString& aProperty);
-  static bool IsCustomPropertyName(const nsACString& aProperty);
-
-  static inline bool IsShorthand(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-    return (aProperty >= eCSSProperty_COUNT_no_shorthands);
-  }
-
-
-  static bool IsInherited(nsCSSPropertyID aProperty);
-
-
-  static nsCSSFontDesc LookupFontDesc(const nsAString& aProperty);
-  static nsCSSFontDesc LookupFontDesc(const nsACString& aProperty);
-
-
-  static nsCSSCounterDesc LookupCounterDesc(const nsAString& aProperty);
-  static nsCSSCounterDesc LookupCounterDesc(const nsACString& aProperty);
-
-
-  static bool IsPredefinedCounterStyle(const nsAString& aStyle);
-  static bool IsPredefinedCounterStyle(const nsACString& aStyle);
-
-
-  static const nsAFlatCString& GetStringValue(nsCSSPropertyID aProperty);
-  static const nsAFlatCString& GetStringValue(nsCSSFontDesc aFontDesc);
-  static const nsAFlatCString& GetStringValue(nsCSSCounterDesc aCounterDesc);
-
-
-
-
-  static const nsAFlatCString& LookupPropertyValue(nsCSSPropertyID aProperty, int32_t aValue);
-
-
-
-  static bool GetColorName(int32_t aPropID, nsCString &aStr);
-
-
-
-
-  static int32_t FindIndexOfKeyword(nsCSSKeyword aKeyword,
-                                    const KTableEntry aTable[]);
-
-
-
-  static bool FindKeyword(nsCSSKeyword aKeyword, const KTableEntry aTable[],
-                          int32_t& aValue);
-
-
-  static nsCSSKeyword ValueToKeywordEnum(int32_t aValue,
-                                         const KTableEntry aTable[]);
-  template<typename T,
-           typename = typename std::enable_if<std::is_enum<T>::value>::type>
-  static nsCSSKeyword ValueToKeywordEnum(T aValue,
-                                         const KTableEntry aTable[])
-  {
-    static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
-                  "aValue must be an enum that fits within KTableEntry::mValue");
-    return ValueToKeywordEnum(static_cast<int16_t>(aValue), aTable);
-  }
-
-  static const nsAFlatCString& ValueToKeyword(int32_t aValue,
-                                              const KTableEntry aTable[]);
-  template<typename T,
-           typename = typename std::enable_if<std::is_enum<T>::value>::type>
-  static const nsAFlatCString& ValueToKeyword(T aValue,
-                                              const KTableEntry aTable[])
-  {
-    static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
-                  "aValue must be an enum that fits within KTableEntry::mValue");
-    return ValueToKeyword(static_cast<int16_t>(aValue), aTable);
-  }
-
-  static const nsStyleStructID kSIDTable[eCSSProperty_COUNT_no_shorthands];
-  static const KTableEntry* const kKeywordTableTable[eCSSProperty_COUNT_no_shorthands];
-  static const nsStyleAnimType kAnimTypeTable[eCSSProperty_COUNT_no_shorthands];
-  static const ptrdiff_t
-    kStyleStructOffsetTable[eCSSProperty_COUNT_no_shorthands];
-
-private:
-  static const uint32_t kFlagsTable[eCSSProperty_COUNT];
-
-public:
-  static inline bool PropHasFlags(nsCSSPropertyID aProperty, uint32_t aFlags)
-  {
-    do { } while (0);
-
-    do { } while (0);
-
-
-
-    return (nsCSSProps::kFlagsTable[aProperty] & aFlags) == aFlags;
-  }
-
-  static inline uint32_t PropertyParseType(nsCSSPropertyID aProperty)
-  {
-    do { } while (0);
-
-    return nsCSSProps::kFlagsTable[aProperty] &
-           (7<<9);
-  }
-
-  static inline uint32_t ValueRestrictions(nsCSSPropertyID aProperty)
-  {
-    do { } while (0);
-
-    return nsCSSProps::kFlagsTable[aProperty] &
-           (3<<13);
-  }
-
-private:
-
-  static const uint32_t kParserVariantTable[eCSSProperty_COUNT_no_shorthands];
-
-public:
-  static inline uint32_t ParserVariant(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-    return nsCSSProps::kParserVariantTable[aProperty];
-  }
-
-private:
-
-
-  static const nsCSSPropertyID *const
-    kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands];
-
-public:
-  static inline
-  const nsCSSPropertyID * SubpropertyEntryFor(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-
-    return nsCSSProps::kSubpropertyTable[aProperty -
-                                         eCSSProperty_COUNT_no_shorthands];
-  }
-
-
-
-
-  static const nsCSSPropertyID * ShorthandsContaining(nsCSSPropertyID aProperty) {
-    do { } while (0);
-    do { } while (0);
-
-    return gShorthandsContainingTable[aProperty];
-  }
-private:
-
-
-
-
-
-  static nsCSSPropertyID *gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
-  static nsCSSPropertyID* gShorthandsContainingPool;
-  static bool BuildShorthandsContainingTable();
-
-private:
-  static const size_t gPropertyCountInStruct[nsStyleStructID_Length];
-  static const size_t gPropertyIndexInStruct[eCSSProperty_COUNT_no_shorthands];
-public:
-
-
-
-
-  static size_t PropertyCountInStruct(nsStyleStructID aSID) {
-    do { } while (0);
-
-    return gPropertyCountInStruct[aSID];
-  }
-
-
-
-
-  static size_t PropertyIndexInStruct(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-    return gPropertyIndexInStruct[aProperty];
-  }
-
-private:
-
-
-  static const nsCSSPropertyID* const
-    kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT];
-
-public:
-# 591 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-  static const nsCSSPropertyID* LogicalGroup(nsCSSPropertyID aProperty);
-
-private:
-  static bool gPropertyEnabled[eCSSProperty_COUNT_with_aliases];
-
-private:
-
-  static const char* const kIDLNameTable[eCSSProperty_COUNT];
-
-public:
-# 611 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-  static const char* PropertyIDLName(nsCSSPropertyID aProperty)
-  {
-    do { } while (0);
-
-    return kIDLNameTable[aProperty];
-  }
-
-private:
-  static const int32_t kIDLNameSortPositionTable[eCSSProperty_COUNT];
-
-public:
-
-
-
-
-  static int32_t PropertyIDLNameSortPosition(nsCSSPropertyID aProperty)
-  {
-    do { } while (0);
-
-    return kIDLNameSortPositionTable[aProperty];
-  }
-
-  static bool IsEnabled(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-
-
-
-    do { } while (0);
-
-
-    return gPropertyEnabled[aProperty];
-  }
-
-
-
-
-  static const mozilla::UseCounter gPropertyUseCounter[eCSSProperty_COUNT_no_shorthands];
-
-public:
-
-  static mozilla::UseCounter UseCounterFor(nsCSSPropertyID aProperty) {
-    do { } while (0);
-
-    return gPropertyUseCounter[aProperty];
-  }
-
-  static bool IsEnabled(nsCSSPropertyID aProperty, EnabledState aEnabled)
-  {
-    if (IsEnabled(aProperty)) {
-      return true;
-    }
-    if (aEnabled == EnabledState::eIgnoreEnabledState) {
-      return true;
-    }
-    if ((aEnabled & EnabledState::eInUASheets) &&
-        PropHasFlags(aProperty, (1<<22)))
-    {
-      return true;
-    }
-    if ((aEnabled & EnabledState::eInChrome) &&
-        PropHasFlags(aProperty, (1<<23)))
-    {
-      return true;
-    }
-    return false;
-  }
-
-public:
-# 693 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSProps.h"
-  static const KTableEntry kAnimationDirectionKTable[];
-  static const KTableEntry kAnimationFillModeKTable[];
-  static const KTableEntry kAnimationIterationCountKTable[];
-  static const KTableEntry kAnimationPlayStateKTable[];
-  static const KTableEntry kAnimationTimingFunctionKTable[];
-  static const KTableEntry kAppearanceKTable[];
-  static const KTableEntry kMozAppearanceKTable[];
-  static const KTableEntry kAzimuthKTable[];
-  static const KTableEntry kBackfaceVisibilityKTable[];
-  static const KTableEntry kTransformStyleKTable[];
-  static const KTableEntry kImageLayerAttachmentKTable[];
-  static const KTableEntry kBackgroundOriginKTable[];
-  static const KTableEntry kMaskOriginKTable[];
-  static const KTableEntry kImageLayerPositionKTable[];
-  static const KTableEntry kImageLayerRepeatKTable[];
-  static const KTableEntry kImageLayerRepeatPartKTable[];
-  static const KTableEntry kImageLayerSizeKTable[];
-  static const KTableEntry kImageLayerCompositeKTable[];
-  static const KTableEntry kImageLayerModeKTable[];
-
-
-  static KTableEntry kBackgroundClipKTable[];
-  static const KTableEntry kMaskClipKTable[];
-  static const KTableEntry kBlendModeKTable[];
-  static const KTableEntry kBorderCollapseKTable[];
-  static const KTableEntry kBorderImageRepeatKTable[];
-  static const KTableEntry kBorderImageSliceKTable[];
-  static const KTableEntry kBorderStyleKTable[];
-  static const KTableEntry kBorderWidthKTable[];
-  static const KTableEntry kBoxAlignKTable[];
-  static const KTableEntry kBoxDecorationBreakKTable[];
-  static const KTableEntry kBoxDirectionKTable[];
-  static const KTableEntry kBoxOrientKTable[];
-  static const KTableEntry kBoxPackKTable[];
-  static const KTableEntry kClipPathGeometryBoxKTable[];
-  static const KTableEntry kCounterRangeKTable[];
-  static const KTableEntry kCounterSpeakAsKTable[];
-  static const KTableEntry kCounterSymbolsSystemKTable[];
-  static const KTableEntry kCounterSystemKTable[];
-  static const KTableEntry kDominantBaselineKTable[];
-  static const KTableEntry kShapeRadiusKTable[];
-  static const KTableEntry kFillRuleKTable[];
-  static const KTableEntry kFilterFunctionKTable[];
-  static const KTableEntry kImageRenderingKTable[];
-  static const KTableEntry kShapeOutsideShapeBoxKTable[];
-  static const KTableEntry kShapeRenderingKTable[];
-  static const KTableEntry kStrokeLinecapKTable[];
-  static const KTableEntry kStrokeLinejoinKTable[];
-  static const KTableEntry kStrokeContextValueKTable[];
-  static const KTableEntry kVectorEffectKTable[];
-  static const KTableEntry kTextAnchorKTable[];
-  static const KTableEntry kTextRenderingKTable[];
-  static const KTableEntry kColorAdjustKTable[];
-  static const KTableEntry kColorInterpolationKTable[];
-  static const KTableEntry kColumnFillKTable[];
-  static const KTableEntry kColumnSpanKTable[];
-  static const KTableEntry kBoxPropSourceKTable[];
-  static const KTableEntry kBoxShadowTypeKTable[];
-  static const KTableEntry kBoxSizingKTable[];
-  static const KTableEntry kCaptionSideKTable[];
-
-
-  static KTableEntry kClearKTable[];
-  static const KTableEntry kColorKTable[];
-  static const KTableEntry kContentKTable[];
-  static const KTableEntry kControlCharacterVisibilityKTable[];
-  static const KTableEntry kCursorKTable[];
-  static const KTableEntry kDirectionKTable[];
-
-
-  static KTableEntry kDisplayKTable[];
-  static const KTableEntry kElevationKTable[];
-  static const KTableEntry kEmptyCellsKTable[];
-
-  static const KTableEntry kAlignAllKeywords[];
-  static const KTableEntry kAlignOverflowPosition[];
-  static const KTableEntry kAlignSelfPosition[];
-  static const KTableEntry kAlignLegacy[];
-  static const KTableEntry kAlignLegacyPosition[];
-  static const KTableEntry kAlignAutoNormalStretchBaseline[];
-  static const KTableEntry kAlignNormalStretchBaseline[];
-  static const KTableEntry kAlignNormalBaseline[];
-  static const KTableEntry kAlignContentDistribution[];
-  static const KTableEntry kAlignContentPosition[];
-
-  static const KTableEntry kAutoCompletionAlignJustifySelf[];
-  static const KTableEntry kAutoCompletionAlignItems[];
-  static const KTableEntry kAutoCompletionAlignJustifyContent[];
-
-  static const KTableEntry kFlexDirectionKTable[];
-  static const KTableEntry kFlexWrapKTable[];
-
-
-  static KTableEntry kFloatKTable[];
-  static const KTableEntry kFloatEdgeKTable[];
-  static const KTableEntry kFontDisplayKTable[];
-  static const KTableEntry kFontKTable[];
-  static const KTableEntry kFontKerningKTable[];
-  static const KTableEntry kFontSizeKTable[];
-  static const KTableEntry kFontSmoothingKTable[];
-  static const KTableEntry kFontStretchKTable[];
-  static const KTableEntry kFontStyleKTable[];
-  static const KTableEntry kFontSynthesisKTable[];
-  static const KTableEntry kFontVariantKTable[];
-  static const KTableEntry kFontVariantAlternatesKTable[];
-  static const KTableEntry kFontVariantAlternatesFuncsKTable[];
-  static const KTableEntry kFontVariantCapsKTable[];
-  static const KTableEntry kFontVariantEastAsianKTable[];
-  static const KTableEntry kFontVariantLigaturesKTable[];
-  static const KTableEntry kFontVariantNumericKTable[];
-  static const KTableEntry kFontVariantPositionKTable[];
-  static const KTableEntry kFontWeightKTable[];
-  static const KTableEntry kGridAutoFlowKTable[];
-  static const KTableEntry kGridTrackBreadthKTable[];
-  static const KTableEntry kHyphensKTable[];
-  static const KTableEntry kImageOrientationKTable[];
-  static const KTableEntry kImageOrientationFlipKTable[];
-  static const KTableEntry kIsolationKTable[];
-  static const KTableEntry kIMEModeKTable[];
-  static const KTableEntry kLineHeightKTable[];
-  static const KTableEntry kListStylePositionKTable[];
-  static const KTableEntry kListStyleKTable[];
-  static const KTableEntry kMaskTypeKTable[];
-  static const KTableEntry kMathVariantKTable[];
-  static const KTableEntry kMathDisplayKTable[];
-  static const KTableEntry kContainKTable[];
-  static const KTableEntry kContextOpacityKTable[];
-  static const KTableEntry kContextPatternKTable[];
-  static const KTableEntry kObjectFitKTable[];
-  static const KTableEntry kOrientKTable[];
-  static const KTableEntry kOutlineStyleKTable[];
-  static const KTableEntry kOverflowKTable[];
-  static const KTableEntry kOverflowSubKTable[];
-  static const KTableEntry kOverflowClipBoxKTable[];
-  static const KTableEntry kOverflowWrapKTable[];
-  static const KTableEntry kPageBreakKTable[];
-  static const KTableEntry kPageBreakInsideKTable[];
-  static const KTableEntry kPageMarksKTable[];
-  static const KTableEntry kPageSizeKTable[];
-  static const KTableEntry kPitchKTable[];
-  static const KTableEntry kPointerEventsKTable[];
-  static const KTableEntry kPositionKTable[];
-  static const KTableEntry kRadialGradientShapeKTable[];
-  static const KTableEntry kRadialGradientSizeKTable[];
-  static const KTableEntry kRadialGradientLegacySizeKTable[];
-  static const KTableEntry kResizeKTable[];
-  static const KTableEntry kRubyAlignKTable[];
-  static const KTableEntry kRubyPositionKTable[];
-  static const KTableEntry kScrollBehaviorKTable[];
-  static const KTableEntry kScrollSnapTypeKTable[];
-  static const KTableEntry kSpeakKTable[];
-  static const KTableEntry kSpeakHeaderKTable[];
-  static const KTableEntry kSpeakNumeralKTable[];
-  static const KTableEntry kSpeakPunctuationKTable[];
-  static const KTableEntry kSpeechRateKTable[];
-  static const KTableEntry kStackSizingKTable[];
-  static const KTableEntry kTableLayoutKTable[];
-
-
-  static KTableEntry kTextAlignKTable[];
-  static KTableEntry kTextAlignLastKTable[];
-  static const KTableEntry kTextCombineUprightKTable[];
-  static const KTableEntry kTextDecorationLineKTable[];
-  static const KTableEntry kTextDecorationStyleKTable[];
-  static const KTableEntry kTextEmphasisPositionKTable[];
-  static const KTableEntry kTextEmphasisStyleFillKTable[];
-  static const KTableEntry kTextEmphasisStyleShapeKTable[];
-  static const KTableEntry kTextJustifyKTable[];
-  static const KTableEntry kTextOrientationKTable[];
-  static const KTableEntry kTextOverflowKTable[];
-  static const KTableEntry kTextSizeAdjustKTable[];
-  static const KTableEntry kTextTransformKTable[];
-  static const KTableEntry kTouchActionKTable[];
-  static const KTableEntry kTopLayerKTable[];
-  static const KTableEntry kTransformBoxKTable[];
-  static const KTableEntry kTransitionTimingFunctionKTable[];
-  static const KTableEntry kUnicodeBidiKTable[];
-  static const KTableEntry kUserFocusKTable[];
-  static const KTableEntry kUserInputKTable[];
-  static const KTableEntry kUserModifyKTable[];
-  static const KTableEntry kUserSelectKTable[];
-  static const KTableEntry kVerticalAlignKTable[];
-  static const KTableEntry kVisibilityKTable[];
-  static const KTableEntry kVolumeKTable[];
-  static const KTableEntry kWhitespaceKTable[];
-  static const KTableEntry kWidthKTable[];
-  static const KTableEntry kWindowDraggingKTable[];
-  static const KTableEntry kWindowShadowKTable[];
-  static const KTableEntry kWordBreakKTable[];
-  static const KTableEntry kWritingModeKTable[];
-};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h" 1
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h"
-class nsIEventTarget;
-class nsIRunnable;
-
-namespace mozilla {
-class AbstractThread;
-namespace dom {
-class TabGroup;
-}
-# 34 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Dispatcher.h"
-class Dispatcher
-{
-public:
-  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
-
-
-  virtual nsresult Dispatch(const char* aName,
-                            TaskCategory aCategory,
-                            already_AddRefed<nsIRunnable>&& aRunnable) = 0;
-
-
-
-  virtual nsIEventTarget* EventTargetFor(TaskCategory aCategory) const = 0;
-
-
-
-  AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
-
-
-
-  virtual dom::TabGroup* AsTabGroup() { return nullptr; }
-
-  static nsresult UnlabeledDispatch(const char* aName,
-                                    TaskCategory aCategory,
-                                    already_AddRefed<nsIRunnable>&& aRunnable);
-
-protected:
-
-
-  virtual AbstractThread* AbstractMainThreadForImpl(TaskCategory aCategory) = 0;
-};
-
-class ValidatingDispatcher : public Dispatcher
-{
-public:
-  ValidatingDispatcher();
-
-  class AutoProcessEvent final {
-  public:
-    AutoProcessEvent();
-    ~AutoProcessEvent();
-
-  private:
-    ValidatingDispatcher* mPrevRunningDispatcher;
-  };
-
-
-  bool AccessAllowed() const
-  {
-    return !sRunningDispatcher || mAccessValid;
-  }
-
-
-  void ValidateAccess() const
-  {
-    do { } while (0);
-  }
-
-  class Runnable;
-  friend class Runnable;
-
-  bool* GetValidAccessPtr() { return &mAccessValid; }
-
-  nsresult Dispatch(const char* aName,
-                    TaskCategory aCategory,
-                    already_AddRefed<nsIRunnable>&& aRunnable) override;
-
-  nsIEventTarget* EventTargetFor(TaskCategory aCategory) const override;
-
-protected:
-
-
-  AbstractThread* AbstractMainThreadForImpl(TaskCategory aCategory) override;
-
-
-  virtual already_AddRefed<nsIEventTarget>
-  CreateEventTargetFor(TaskCategory aCategory);
-
-
-
-  static ValidatingDispatcher* FromEventTarget(nsIEventTarget* aEventTarget);
-
-  nsresult LabeledDispatch(const char* aName,
-                           TaskCategory aCategory,
-                           already_AddRefed<nsIRunnable>&& aRunnable);
-
-  void CreateEventTargets(bool aNeedValidation);
-
-
-
-  void Shutdown(bool aXPCOMShutdown);
-
-  enum ValidationType {
-    StartValidation,
-    EndValidation,
-  };
-  void SetValidatingAccess(ValidationType aType);
-
-  static ValidatingDispatcher* sRunningDispatcher;
-  bool mAccessValid;
-
-  nsCOMPtr<nsIEventTarget> mEventTargets[size_t(TaskCategory::Count)];
-  RefPtr<AbstractThread> mAbstractThreads[size_t(TaskCategory::Count)];
-};
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/SystemGroup.h" 2
-
-
-
-
-
-
-namespace mozilla {
-
-class SystemGroup
-{
- public:
-
-  static nsresult Dispatch(const char* aName,
-                           TaskCategory aCategory,
-                           already_AddRefed<nsIRunnable>&& aRunnable);
-
-
-  static nsIEventTarget* EventTargetFor(TaskCategory aCategory);
-
-
-
-  static AbstractThread* AbstractMainThreadFor(TaskCategory aCategory);
-
-  static void InitStatic();
-  static void Shutdown();
-};
-
-}
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h" 2
-
-
-
-
-
-
-
-namespace detail {
-
-template<typename T>
-class ProxyReleaseEvent : public mozilla::Runnable
-{
-public:
-  explicit ProxyReleaseEvent(already_AddRefed<T> aDoomed)
-  : Runnable("ProxyReleaseEvent"), mDoomed(aDoomed.take()) {}
-
-  virtual nsresult Run() override
-  {
-    do { if (mDoomed) { (mDoomed)->Release(); (mDoomed) = 0; } } while (0);
-    return NS_OK;
-  }
-
-private:
-  T* mDoomed;
-};
-
-template<typename T>
-void
-ProxyRelease(nsIEventTarget* aTarget, already_AddRefed<T> aDoomed, bool aAlwaysProxy)
-{
-
-  RefPtr<T> doomed = aDoomed;
-  nsresult rv;
-
-  if (!doomed || !aTarget) {
-    return;
-  }
-
-  if (!aAlwaysProxy) {
-    bool onCurrentThread = false;
-    rv = aTarget->IsOnCurrentThread(&onCurrentThread);
-    if (((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))) && onCurrentThread) {
-      return;
-    }
-  }
-
-  nsCOMPtr<nsIRunnable> ev = new ProxyReleaseEvent<T>(doomed.forget());
-
-  rv = aTarget->Dispatch(ev, nsIEventTarget::DISPATCH_NORMAL);
-  if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
-    do { } while(0);
-
-
-  }
-}
-
-template<bool nsISupportsBased>
-struct ProxyReleaseChooser
-{
-  template<typename T>
-  static void ProxyRelease(nsIEventTarget* aTarget,
-                           already_AddRefed<T> aDoomed,
-                           bool aAlwaysProxy)
-  {
-    ::detail::ProxyRelease(aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
-  }
-};
-
-template<>
-struct ProxyReleaseChooser<true>
-{
-
-
-  template<typename T>
-  static void ProxyRelease(nsIEventTarget* aTarget,
-                           already_AddRefed<T> aDoomed,
-                           bool aAlwaysProxy)
-  {
-    ProxyReleaseISupports(aTarget, ToSupports(aDoomed.take()), aAlwaysProxy);
-  }
-
-  static void ProxyReleaseISupports(nsIEventTarget* aTarget,
-                                    nsISupports* aDoomed,
-                                    bool aAlwaysProxy);
-};
-
-}
-# 120 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
-template<class T>
-inline __attribute__ ((visibility ("hidden"))) void
-NS_ProxyRelease(nsIEventTarget* aTarget, already_AddRefed<T> aDoomed,
-                bool aAlwaysProxy = false)
-{
-  ::detail::ProxyReleaseChooser<mozilla::IsBaseOf<nsISupports, T>::value>
-    ::ProxyRelease(aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
-}
-# 140 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
-template<class T>
-inline __attribute__ ((visibility ("hidden"))) void
-NS_ReleaseOnMainThread(already_AddRefed<T> aDoomed,
-                       bool aAlwaysProxy = false)
-{
-
-
-
-  nsCOMPtr<nsIThread> mainThread;
-  if (!NS_IsMainThread() || aAlwaysProxy) {
-    nsresult rv = NS_GetMainThread(getter_AddRefs(mainThread));
-
-    if (((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
-      do { } while (0);
-      mozilla::Unused << aDoomed.take();
-      return;
-    }
-  }
-
-  NS_ProxyRelease(mainThread, mozilla::Move(aDoomed), aAlwaysProxy);
-}
-
-
-
-
-
-template<class T>
-inline __attribute__ ((visibility ("hidden"))) void
-NS_ReleaseOnMainThreadSystemGroup(already_AddRefed<T> aDoomed,
-                                  bool aAlwaysProxy = false)
-{
-
-
-
-  nsCOMPtr<nsIEventTarget> systemGroupEventTarget;
-  if (!NS_IsMainThread() || aAlwaysProxy) {
-    systemGroupEventTarget = mozilla::SystemGroup::EventTargetFor(mozilla::TaskCategory::Other);
-
-    if (!systemGroupEventTarget) {
-      do { } while (0);
-      mozilla::Unused << aDoomed.take();
-      return;
-    }
-  }
-
-  NS_ProxyRelease(systemGroupEventTarget, mozilla::Move(aDoomed), aAlwaysProxy);
-}
-# 226 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsProxyRelease.h"
-template<class T>
-class nsMainThreadPtrHolder final
-{
-public:
-
-
-
-
-
-  explicit nsMainThreadPtrHolder(T* aPtr, bool aStrict = true)
-    : mRawPtr(nullptr)
-    , mStrict(aStrict)
-  {
-
-
-    do { } while (0);
-    ns_if_addref(mRawPtr = aPtr);
-  }
-  explicit nsMainThreadPtrHolder(already_AddRefed<T> aPtr, bool aString = true)
-    : mRawPtr(aPtr.take())
-    , mStrict(aString)
-  {
-
-
-  }
-
-private:
-
-  ~nsMainThreadPtrHolder()
-  {
-    if (NS_IsMainThread()) {
-      do { if (mRawPtr) { (mRawPtr)->Release(); (mRawPtr) = 0; } } while (0);
-    } else if (mRawPtr) {
-      NS_ReleaseOnMainThread(dont_AddRef(mRawPtr));
-    }
-  }
-
-public:
-  T* get()
-  {
-
-    if (mStrict && (__builtin_expect(!!(!NS_IsMainThread()), 0))) {
-      do { } while(0);
-      do { AnnotateMozCrashReason("MOZ_CRASH(" ")"); do { *((volatile int*) __null) = 269; ::abort(); } while (0); } while (0);
-    }
-    return mRawPtr;
-  }
-
-  bool operator==(const nsMainThreadPtrHolder<T>& aOther) const
-  {
-    return mRawPtr == aOther.mRawPtr;
-  }
-  bool operator!() const
-  {
-    return !mRawPtr;
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsMainThreadPtrHolder<T> >::value, "Reference-counted class " "nsMainThreadPtrHolder<T>" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-private:
-
-  T* mRawPtr;
-
-
-  bool mStrict;
-
-
-
-  T& operator=(nsMainThreadPtrHolder& aOther);
-  nsMainThreadPtrHolder(const nsMainThreadPtrHolder& aOther);
-};
-
-template<class T>
-class nsMainThreadPtrHandle
-{
-  RefPtr<nsMainThreadPtrHolder<T>> mPtr;
-
-public:
-  nsMainThreadPtrHandle() : mPtr(nullptr) {}
-               nsMainThreadPtrHandle(decltype(nullptr)) : mPtr(nullptr) {}
-  explicit nsMainThreadPtrHandle(nsMainThreadPtrHolder<T>* aHolder)
-    : mPtr(aHolder)
-  {
-  }
-  explicit nsMainThreadPtrHandle(
-      already_AddRefed<nsMainThreadPtrHolder<T>> aHolder)
-    : mPtr(aHolder)
-  {
-  }
-  nsMainThreadPtrHandle(const nsMainThreadPtrHandle& aOther)
-    : mPtr(aOther.mPtr)
-  {
-  }
-  nsMainThreadPtrHandle& operator=(const nsMainThreadPtrHandle& aOther)
-  {
-    mPtr = aOther.mPtr;
-    return *this;
-  }
-  nsMainThreadPtrHandle& operator=(nsMainThreadPtrHolder<T>* aHolder)
-  {
-    mPtr = aHolder;
-    return *this;
-  }
-
-
-
-
-  T* get()
-  {
-    if (mPtr) {
-      return mPtr.get()->get();
-    }
-    return nullptr;
-  }
-  const T* get() const
-  {
-    if (mPtr) {
-      return mPtr.get()->get();
-    }
-    return nullptr;
-  }
-
-  operator T*() { return get(); }
-  T* operator->() { return get(); }
-
-
-  bool operator==(const nsMainThreadPtrHandle<T>& aOther) const
-  {
-    if (!mPtr || !aOther.mPtr) {
-      return mPtr == aOther.mPtr;
-    }
-    return *mPtr == *aOther.mPtr;
-  }
-  bool operator!=(const nsMainThreadPtrHandle<T>& aOther) const
-  {
-    return !operator==(aOther);
-  }
-  bool operator==(decltype(nullptr)) const { return mPtr == nullptr; }
-  bool operator!=(decltype(nullptr)) const { return mPtr != nullptr; }
-  bool operator!() const {
-    return !mPtr || !*mPtr;
-  }
-};
-
-namespace mozilla {
-
-template<typename T>
-using PtrHolder = nsMainThreadPtrHolder<T>;
-
-template<typename T>
-using PtrHandle = nsMainThreadPtrHandle<T>;
-
-}
-# 26 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h" 2
-# 36 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-class imgRequestProxy;
-class nsIAtom;
-class nsIContent;
-class nsIDocument;
-class nsIPrincipal;
-class nsIURI;
-class nsPresContext;
-template <class T>
-class nsPtrHashKey;
-
-namespace mozilla {
-class CSSStyleSheet;
-}
-# 93 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-namespace mozilla {
-namespace css {
-
-struct URLExtraData
-{
-  URLExtraData(already_AddRefed<nsIURI> aBaseURI,
-               already_AddRefed<nsIURI> aReferrer,
-               already_AddRefed<nsIPrincipal> aPrincipal)
-    : mBaseURI(Move(aBaseURI))
-    , mReferrer(Move(aReferrer))
-    , mPrincipal(Move(aPrincipal))
-  {
-    do { } while (0);
-  }
-
-  URLExtraData(nsIURI* aBaseURI, nsIURI* aReferrer, nsIPrincipal* aPrincipal)
-    : URLExtraData(do_AddRef(aBaseURI),
-                   do_AddRef(aReferrer),
-                   do_AddRef(aPrincipal)) {}
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLExtraData>::value, "Reference-counted class " "URLExtraData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-  nsIURI* BaseURI() const { return mBaseURI; }
-  nsIURI* GetReferrer() const { return mReferrer; }
-  nsIPrincipal* GetPrincipal() const { return mPrincipal; }
-
-private:
-  ~URLExtraData();
-
-  RefPtr<nsIURI> mBaseURI;
-  RefPtr<nsIURI> mReferrer;
-  RefPtr<nsIPrincipal> mPrincipal;
-};
-
-struct URLValueData
-{
-protected:
-# 138 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  URLValueData(nsStringBuffer* aString,
-               already_AddRefed<URLExtraData> aExtraData);
-
-  URLValueData(already_AddRefed<PtrHolder<nsIURI>> aURI,
-               nsStringBuffer* aString,
-               already_AddRefed<URLExtraData> aExtraData);
-
-public:
-
-
-
-
-  bool Equals(const URLValueData& aOther) const;
-# 159 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  bool DefinitelyEqualURIs(const URLValueData& aOther) const;
-
-
-
-  bool DefinitelyEqualURIsAndPrincipal(const URLValueData& aOther) const;
-
-  nsIURI* GetURI() const;
-
-  bool IsLocalRef() const { return mIsLocalRef; }
-
-  bool HasRef() const;
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLValueData>::value, "Reference-counted class " "URLValueData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-
-
-  already_AddRefed<nsIURI> ResolveLocalRef(nsIURI* aURI) const;
-  already_AddRefed<nsIURI> ResolveLocalRef(nsIContent* aContent) const;
-
-
-
-  void GetSourceString(nsString& aRef) const;
-
-  bool EqualsExceptRef(nsIURI* aURI) const;
-
-private:
-
-
-  mutable PtrHandle<nsIURI> mURI;
-public:
-  RefPtr<nsStringBuffer> mString;
-  RefPtr<URLExtraData> mExtraData;
-private:
-  mutable bool mURIResolved;
-
-  bool mIsLocalRef;
-
-protected:
-  virtual ~URLValueData() = default;
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-  URLValueData(const URLValueData& aOther) = delete;
-  URLValueData& operator=(const URLValueData& aOther) = delete;
-};
-
-struct URLValue final : public URLValueData
-{
-
-  URLValue(nsStringBuffer* aString, nsIURI* aBaseURI, nsIURI* aReferrer,
-           nsIPrincipal* aOriginPrincipal);
-  URLValue(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aBaseURI,
-           nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal);
-
-
-  URLValue(nsStringBuffer* aString,
-           already_AddRefed<URLExtraData> aExtraData)
-    : URLValueData(aString, Move(aExtraData)) {}
-
-  URLValue(const URLValue&) = delete;
-  URLValue& operator=(const URLValue&) = delete;
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-};
-
-struct ImageValue final : public URLValueData
-{
-
-
-
-
-
-
-  ImageValue(nsIURI* aURI, nsStringBuffer* aString,
-             already_AddRefed<URLExtraData> aExtraData,
-             nsIDocument* aDocument);
-
-
-
-  ImageValue(nsStringBuffer* aString,
-             already_AddRefed<URLExtraData> aExtraData);
-
-  ImageValue(const ImageValue&) = delete;
-  ImageValue& operator=(const ImageValue&) = delete;
-
-  void Initialize(nsIDocument* aDocument);
-
-
-
-protected:
-  ~ImageValue();
-
-public:
-
-
-  nsRefPtrHashtable<nsPtrHashKey<nsIDocument>, imgRequestProxy> mRequests;
-
-private:
-
-
-
-};
-
-struct GridNamedArea {
-  nsString mName;
-  uint32_t mColumnStart;
-  uint32_t mColumnEnd;
-  uint32_t mRowStart;
-  uint32_t mRowEnd;
-};
-
-struct GridTemplateAreasValue final {
-
-  nsTArray<GridNamedArea> mNamedAreas;
-
-
-
-  nsTArray<nsString> mTemplates;
-
-
-
-  uint32_t mNColumns;
-
-
-
-  uint32_t NRows() const {
-    return mTemplates.Length();
-  }
-
-  GridTemplateAreasValue()
-    : mNColumns(0)
-
-  {
-  }
-
-  bool operator==(const GridTemplateAreasValue& aOther) const
-  {
-    return mTemplates == aOther.mTemplates;
-  }
-
-  bool operator!=(const GridTemplateAreasValue& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<GridTemplateAreasValue>::value, "Reference-counted class " "GridTemplateAreasValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-
-  ~GridTemplateAreasValue()
-  {
-  }
-
-  GridTemplateAreasValue(const GridTemplateAreasValue& aOther) = delete;
-  GridTemplateAreasValue&
-  operator=(const GridTemplateAreasValue& aOther) = delete;
-};
-
-class FontFamilyListRefCnt final : public FontFamilyList {
-public:
-    FontFamilyListRefCnt()
-        : FontFamilyList()
-    {}
-
-    explicit FontFamilyListRefCnt(FontFamilyType aGenericType)
-        : FontFamilyList(aGenericType)
-    {}
-
-    FontFamilyListRefCnt(const nsAString& aFamilyName,
-                         QuotedName aQuoted)
-        : FontFamilyList(aFamilyName, aQuoted)
-    {}
-
-    FontFamilyListRefCnt(const FontFamilyListRefCnt& aOther)
-        : FontFamilyList(aOther)
-    {}
-
-    public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<FontFamilyListRefCnt>::value, "Reference-counted class " "FontFamilyListRefCnt" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:;
-
-private:
-    ~FontFamilyListRefCnt() {}
-};
-
-struct RGBAColorData
-{
-
-
-
-  float mR;
-  float mG;
-  float mB;
-  float mA;
-
-  RGBAColorData() = default;
-               RGBAColorData(nscolor aColor)
-    : mR(((uint8_t) ((aColor) & 0xff)) * (1.0f / 255.0f))
-    , mG(((uint8_t) (((aColor) >> 8) & 0xff)) * (1.0f / 255.0f))
-    , mB(((uint8_t) (((aColor) >> 16) & 0xff)) * (1.0f / 255.0f))
-    , mA(((uint8_t) (((aColor) >> 24) & 0xff)) * (1.0f / 255.0f))
-  {}
-  RGBAColorData(float aR, float aG, float aB, float aA)
-    : mR(aR), mG(aG), mB(aB), mA(aA) {}
-
-  bool operator==(const RGBAColorData& aOther) const
-  {
-    return mR == aOther.mR && mG == aOther.mG &&
-           mB == aOther.mB && mA == aOther.mA;
-  }
-  bool operator!=(const RGBAColorData& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  nscolor ToColor() const
-  {
-    return ((nscolor) (((ClampColor(mA * 255.0f)) << 24) | ((ClampColor(mB * 255.0f))<<16) | ((ClampColor(mG * 255.0f))<<8) | (ClampColor(mR * 255.0f))));
-
-
-
-  }
-
-  RGBAColorData WithAlpha(float aAlpha) const
-  {
-    RGBAColorData result = *this;
-    result.mA = aAlpha;
-    return result;
-  }
-};
-
-struct ComplexColorData
-{
-  RGBAColorData mColor;
-  float mForegroundRatio;
-
-  ComplexColorData() = default;
-  ComplexColorData(const RGBAColorData& aColor, float aForegroundRatio)
-    : mColor(aColor), mForegroundRatio(aForegroundRatio) {}
-  ComplexColorData(nscolor aColor, float aForegroundRatio)
-    : mColor(aColor), mForegroundRatio(aForegroundRatio) {}
-  explicit ComplexColorData(const StyleComplexColor& aColor)
-    : mColor(aColor.mColor)
-    , mForegroundRatio(aColor.mForegroundRatio * (1.0f / 255.0f)) {}
-
-  bool operator==(const ComplexColorData& aOther) const
-  {
-    return mForegroundRatio == aOther.mForegroundRatio &&
-           (IsCurrentColor() || mColor == aOther.mColor);
-  }
-  bool operator!=(const ComplexColorData& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  bool IsCurrentColor() const { return mForegroundRatio >= 1.0f; }
-  bool IsNumericColor() const { return mForegroundRatio <= 0.0f; }
-
-  StyleComplexColor ToComplexColor() const
-  {
-    return {mColor.ToColor(), ClampColor(mForegroundRatio * 255.0f)};
-  }
-};
-
-struct ComplexColorValue final : public ComplexColorData
-{
-
-  template<typename... Args>
-  explicit ComplexColorValue(Args&&... aArgs)
-    : ComplexColorData(Forward<Args>(aArgs)...) {}
-  ComplexColorValue(const ComplexColorValue&) = delete;
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ComplexColorValue>::value, "Reference-counted class " "ComplexColorValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
-
-private:
-  ~ComplexColorValue() {}
-};
-
-}
-}
-
-enum nsCSSUnit {
-  eCSSUnit_Null = 0,
-  eCSSUnit_Auto = 1,
-  eCSSUnit_Inherit = 2,
-  eCSSUnit_Initial = 3,
-  eCSSUnit_Unset = 4,
-  eCSSUnit_None = 5,
-  eCSSUnit_Normal = 6,
-  eCSSUnit_System_Font = 7,
-  eCSSUnit_All = 8,
-  eCSSUnit_Dummy = 9,
-
-  eCSSUnit_DummyInherit = 10,
-
-
-  eCSSUnit_String = 11,
-  eCSSUnit_Ident = 12,
-  eCSSUnit_Attr = 14,
-  eCSSUnit_Local_Font = 15,
-  eCSSUnit_Font_Format = 16,
-  eCSSUnit_Element = 17,
-
-  eCSSUnit_Array = 20,
-  eCSSUnit_Counter = 21,
-  eCSSUnit_Counters = 22,
-  eCSSUnit_Cubic_Bezier = 23,
-  eCSSUnit_Steps = 24,
-  eCSSUnit_Symbols = 25,
-  eCSSUnit_Function = 26,
-# 485 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  eCSSUnit_Calc = 30,
-
-
-  eCSSUnit_Calc_Plus = 31,
-  eCSSUnit_Calc_Minus = 32,
-  eCSSUnit_Calc_Times_L = 33,
-  eCSSUnit_Calc_Times_R = 34,
-  eCSSUnit_Calc_Divided = 35,
-
-  eCSSUnit_URL = 40,
-  eCSSUnit_Image = 41,
-  eCSSUnit_Gradient = 42,
-  eCSSUnit_TokenStream = 43,
-  eCSSUnit_GridTemplateAreas = 44,
-
-
-  eCSSUnit_Pair = 50,
-  eCSSUnit_Triplet = 51,
-  eCSSUnit_Rect = 52,
-  eCSSUnit_List = 53,
-  eCSSUnit_ListDep = 54,
-
-  eCSSUnit_SharedList = 55,
-
-  eCSSUnit_PairList = 56,
-  eCSSUnit_PairListDep = 57,
-
-
-  eCSSUnit_FontFamilyList = 58,
-
-
-  eCSSUnit_AtomIdent = 60,
-
-  eCSSUnit_Integer = 70,
-  eCSSUnit_Enumerated = 71,
-
-  eCSSUnit_EnumColor = 80,
-  eCSSUnit_RGBColor = 81,
-  eCSSUnit_RGBAColor = 82,
-  eCSSUnit_HexColor = 83,
-  eCSSUnit_ShortHexColor = 84,
-  eCSSUnit_HexColorAlpha = 85,
-  eCSSUnit_ShortHexColorAlpha = 86,
-  eCSSUnit_PercentageRGBColor = 87,
-
-
-
-  eCSSUnit_PercentageRGBAColor = 88,
-
-
-
-  eCSSUnit_HSLColor = 89,
-  eCSSUnit_HSLAColor = 90,
-  eCSSUnit_ComplexColor = 91,
-
-  eCSSUnit_Percent = 100,
-  eCSSUnit_Number = 101,
-
-
-  eCSSUnit_PhysicalMillimeter = 200,
-
-
-
-  eCSSUnit_ViewportWidth = 700,
-  eCSSUnit_ViewportHeight = 701,
-  eCSSUnit_ViewportMin = 702,
-  eCSSUnit_ViewportMax = 703,
-
-
-  eCSSUnit_EM = 800,
-  eCSSUnit_XHeight = 801,
-  eCSSUnit_Char = 802,
-  eCSSUnit_RootEM = 803,
-
-
-  eCSSUnit_Point = 900,
-  eCSSUnit_Inch = 901,
-  eCSSUnit_Millimeter = 902,
-  eCSSUnit_Centimeter = 903,
-  eCSSUnit_Pica = 904,
-  eCSSUnit_Quarter = 905,
-  eCSSUnit_Pixel = 906,
-
-
-  eCSSUnit_Degree = 1000,
-  eCSSUnit_Grad = 1001,
-  eCSSUnit_Radian = 1002,
-  eCSSUnit_Turn = 1003,
-
-
-  eCSSUnit_Hertz = 2000,
-  eCSSUnit_Kilohertz = 2001,
-
-
-  eCSSUnit_Seconds = 3000,
-  eCSSUnit_Milliseconds = 3001,
-
-
-  eCSSUnit_FlexFraction = 4000
-};
-
-struct nsCSSValueGradient;
-struct nsCSSValuePair;
-struct nsCSSValuePair_heap;
-struct nsCSSValueTokenStream;
-struct nsCSSRect;
-struct nsCSSRect_heap;
-struct nsCSSValueList;
-struct nsCSSValueList_heap;
-struct nsCSSValueSharedList;
-struct nsCSSValuePairList;
-struct nsCSSValuePairList_heap;
-struct nsCSSValueTriplet;
-struct nsCSSValueTriplet_heap;
-class nsCSSValueFloatColor;
-
-class nsCSSValue {
-public:
-  struct Array;
-  friend struct Array;
-
-  friend struct mozilla::css::URLValueData;
-
-  friend struct mozilla::css::ImageValue;
-
-
-  explicit nsCSSValue(nsCSSUnit aUnit = eCSSUnit_Null)
-    : mUnit(aUnit)
-  {
-    do { } while (0);
-  }
-
-  nsCSSValue(int32_t aValue, nsCSSUnit aUnit);
-  nsCSSValue(float aValue, nsCSSUnit aUnit);
-  nsCSSValue(const nsString& aValue, nsCSSUnit aUnit);
-  nsCSSValue(Array* aArray, nsCSSUnit aUnit);
-  explicit nsCSSValue(mozilla::css::URLValue* aValue);
-  explicit nsCSSValue(mozilla::css::ImageValue* aValue);
-  explicit nsCSSValue(nsCSSValueGradient* aValue);
-  explicit nsCSSValue(nsCSSValueTokenStream* aValue);
-  explicit nsCSSValue(mozilla::css::GridTemplateAreasValue* aValue);
-  explicit nsCSSValue(mozilla::css::FontFamilyListRefCnt* aValue);
-  nsCSSValue(const nsCSSValue& aCopy);
-  nsCSSValue(nsCSSValue&& aOther)
-    : mUnit(aOther.mUnit)
-    , mValue(aOther.mValue)
-  {
-    aOther.mUnit = eCSSUnit_Null;
-  }
-  ~nsCSSValue() { Reset(); }
-
-  nsCSSValue& operator=(const nsCSSValue& aCopy);
-  nsCSSValue& operator=(nsCSSValue&& aCopy);
-  bool operator==(const nsCSSValue& aOther) const;
-
-  bool operator!=(const nsCSSValue& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-
-  enum Serialization { eNormalized, eAuthorSpecified };
-
-
-
-
-
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      Serialization aValueSerialization) const;
-
-  nsCSSUnit GetUnit() const { return mUnit; }
-  bool IsLengthUnit() const
-    { return eCSSUnit_PhysicalMillimeter <= mUnit && mUnit <= eCSSUnit_Pixel; }
-  bool IsLengthPercentCalcUnit() const
-    { return IsLengthUnit() || mUnit == eCSSUnit_Percent || IsCalcUnit(); }
-
-
-
-
-
-  bool IsFixedLengthUnit() const
-    { return mUnit == eCSSUnit_PhysicalMillimeter; }
-# 676 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  bool IsRelativeLengthUnit() const
-    { return eCSSUnit_EM <= mUnit && mUnit <= eCSSUnit_RootEM; }
-
-
-
-  static bool IsPixelLengthUnit(nsCSSUnit aUnit)
-    { return eCSSUnit_Point <= aUnit && aUnit <= eCSSUnit_Pixel; }
-  bool IsPixelLengthUnit() const
-    { return IsPixelLengthUnit(mUnit); }
-  static bool IsPercentLengthUnit(nsCSSUnit aUnit)
-    { return aUnit == eCSSUnit_Percent; }
-  bool IsPercentLengthUnit()
-    { return IsPercentLengthUnit(mUnit); }
-  static bool IsFloatUnit(nsCSSUnit aUnit)
-    { return eCSSUnit_Number <= aUnit; }
-  bool IsAngularUnit() const
-    { return eCSSUnit_Degree <= mUnit && mUnit <= eCSSUnit_Turn; }
-  bool IsFrequencyUnit() const
-    { return eCSSUnit_Hertz <= mUnit && mUnit <= eCSSUnit_Kilohertz; }
-  bool IsTimeUnit() const
-    { return eCSSUnit_Seconds <= mUnit && mUnit <= eCSSUnit_Milliseconds; }
-  bool IsCalcUnit() const
-    { return eCSSUnit_Calc <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
-
-  bool UnitHasStringValue() const
-    { return eCSSUnit_String <= mUnit && mUnit <= eCSSUnit_Element; }
-  bool UnitHasArrayValue() const
-    { return eCSSUnit_Array <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
-# 725 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  bool IsIntegerColorUnit() const { return IsIntegerColorUnit(mUnit); }
-  bool IsFloatColorUnit() const { return IsFloatColorUnit(mUnit); }
-  bool IsNumericColorUnit() const { return IsNumericColorUnit(mUnit); }
-  static bool IsIntegerColorUnit(nsCSSUnit aUnit)
-  { return eCSSUnit_RGBColor <= aUnit && aUnit <= eCSSUnit_ShortHexColorAlpha; }
-  static bool IsFloatColorUnit(nsCSSUnit aUnit)
-  { return eCSSUnit_PercentageRGBColor <= aUnit &&
-           aUnit <= eCSSUnit_HSLAColor; }
-  static bool IsNumericColorUnit(nsCSSUnit aUnit)
-  { return IsIntegerColorUnit(aUnit) || IsFloatColorUnit(aUnit); }
-
-  int32_t GetIntValue() const
-  {
-    do { } while (0);
-
-
-
-    return mValue.mInt;
-  }
-
-  nsCSSKeyword GetKeywordValue() const
-  {
-    do { } while (0);
-    return static_cast<nsCSSKeyword>(mValue.mInt);
-  }
-
-  float GetPercentValue() const
-  {
-    do { } while (0);
-    return mValue.mFloat;
-  }
-
-  float GetFloatValue() const
-  {
-    do { } while (0);
-    do { } while (0);
-    return mValue.mFloat;
-  }
-
-  float GetAngleValue() const
-  {
-    do { } while (0);
-
-    return mValue.mFloat;
-  }
-
-
-  double GetAngleValueInRadians() const;
-
-
-  double GetAngleValueInDegrees() const;
-
-  nsAString& GetStringValue(nsAString& aBuffer) const
-  {
-    do { } while (0);
-    aBuffer.Truncate();
-    uint32_t len = NS_strlen(GetBufferValue(mValue.mString));
-    mValue.mString->ToString(len, aBuffer);
-    return aBuffer;
-  }
-
-  const char16_t* GetStringBufferValue() const
-  {
-    do { } while (0);
-    return GetBufferValue(mValue.mString);
-  }
-
-  nscolor GetColorValue() const;
-  bool IsNonTransparentColor() const;
-  mozilla::StyleComplexColor GetStyleComplexColorValue() const
-  {
-    do { } while (0);
-    return mValue.mComplexColor->ToComplexColor();
-  }
-
-  Array* GetArrayValue() const
-  {
-    do { } while (0);
-    return mValue.mArray;
-  }
-
-  nsIURI* GetURLValue() const
-  {
-    do { } while (0);
-
-    return mUnit == eCSSUnit_URL ?
-      mValue.mURL->GetURI() : mValue.mImage->GetURI();
-  }
-
-  nsCSSValueGradient* GetGradientValue() const
-  {
-    do { } while (0);
-    return mValue.mGradient;
-  }
-
-  nsCSSValueTokenStream* GetTokenStreamValue() const
-  {
-    do { } while (0);
-    return mValue.mTokenStream;
-  }
-
-  nsCSSValueSharedList* GetSharedListValue() const
-  {
-    do { } while (0);
-    return mValue.mSharedList;
-  }
-
-  mozilla::FontFamilyList* GetFontFamilyListValue() const
-  {
-    do { } while (0);
-
-    do { } while(0);
-
-    return mValue.mFontFamilyList;
-  }
-
-
-  inline nsCSSValuePair& GetPairValue();
-  inline const nsCSSValuePair& GetPairValue() const;
-
-  inline nsCSSRect& GetRectValue();
-  inline const nsCSSRect& GetRectValue() const;
-
-  inline nsCSSValueList* GetListValue();
-  inline const nsCSSValueList* GetListValue() const;
-
-  inline nsCSSValuePairList* GetPairListValue();
-  inline const nsCSSValuePairList* GetPairListValue() const;
-
-  inline nsCSSValueTriplet& GetTripletValue();
-  inline const nsCSSValueTriplet& GetTripletValue() const;
-
-
-  mozilla::css::URLValue* GetURLStructValue() const
-  {
-
-
-    do { } while (0);
-    return mValue.mURL;
-  }
-
-  mozilla::css::ImageValue* GetImageStructValue() const
-  {
-    do { } while (0);
-    return mValue.mImage;
-  }
-
-  mozilla::css::GridTemplateAreasValue* GetGridTemplateAreas() const
-  {
-    do { } while (0);
-
-    return mValue.mGridTemplateAreas;
-  }
-
-  const char16_t* GetOriginalURLValue() const
-  {
-    do { } while (0);
-
-    return GetBufferValue(mUnit == eCSSUnit_URL ?
-                            mValue.mURL->mString :
-                            mValue.mImage->mString);
-  }
-
-
-
-
-  imgRequestProxy* GetImageValue(nsIDocument* aDocument) const;
-
-
-
-  already_AddRefed<imgRequestProxy> GetPossiblyStaticImageValue(
-      nsIDocument* aDocument, nsPresContext* aPresContext) const;
-
-  nscoord GetFixedLength(nsPresContext* aPresContext) const;
-  nscoord GetPixelLength() const;
-
-  nsCSSValueFloatColor* GetFloatColorValue() const
-  {
-    do { } while (0);
-    return mValue.mFloatColor;
-  }
-
-  nsIAtom* GetAtomValue() const {
-    do { } while (0);
-    return mValue.mAtom;
-  }
-
-  void Reset()
-  {
-    if (mUnit != eCSSUnit_Null)
-      DoReset();
-  }
-private:
-  void DoReset();
-
-public:
-  void SetIntValue(int32_t aValue, nsCSSUnit aUnit);
-  template<typename T,
-           typename = typename std::enable_if<std::is_enum<T>::value>::type>
-  void SetEnumValue(T aValue)
-  {
-    static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
-                  "aValue must be an enum that fits within mValue.mInt");
-    SetIntValue(static_cast<int32_t>(aValue), eCSSUnit_Enumerated);
-  }
-  void SetPercentValue(float aValue);
-  void SetFloatValue(float aValue, nsCSSUnit aUnit);
-  void SetStringValue(const nsString& aValue, nsCSSUnit aUnit);
-  void SetColorValue(nscolor aValue);
-  void SetIntegerColorValue(nscolor aValue, nsCSSUnit aUnit);
-
-  void SetIntegerCoordValue(nscoord aCoord);
-  void SetFloatColorValue(float aComponent1,
-                          float aComponent2,
-                          float aComponent3,
-                          float aAlpha, nsCSSUnit aUnit);
-  void SetRGBAColorValue(const mozilla::css::RGBAColorData& aValue);
-  void SetComplexColorValue(
-    already_AddRefed<mozilla::css::ComplexColorValue> aValue);
-  void SetArrayValue(nsCSSValue::Array* aArray, nsCSSUnit aUnit);
-  void SetURLValue(mozilla::css::URLValue* aURI);
-  void SetImageValue(mozilla::css::ImageValue* aImage);
-  void SetGradientValue(nsCSSValueGradient* aGradient);
-  void SetTokenStreamValue(nsCSSValueTokenStream* aTokenStream);
-  void SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue* aValue);
-  void SetFontFamilyListValue(mozilla::css::FontFamilyListRefCnt* aFontListValue);
-  void SetPairValue(const nsCSSValuePair* aPair);
-  void SetPairValue(const nsCSSValue& xValue, const nsCSSValue& yValue);
-  void SetSharedListValue(nsCSSValueSharedList* aList);
-  void SetDependentListValue(nsCSSValueList* aList);
-  void SetDependentPairListValue(nsCSSValuePairList* aList);
-  void SetTripletValue(const nsCSSValueTriplet* aTriplet);
-  void SetTripletValue(const nsCSSValue& xValue, const nsCSSValue& yValue, const nsCSSValue& zValue);
-  void SetAutoValue();
-  void SetInheritValue();
-  void SetInitialValue();
-  void SetUnsetValue();
-  void SetNoneValue();
-  void SetAllValue();
-  void SetNormalValue();
-  void SetSystemFontValue();
-  void SetDummyValue();
-  void SetDummyInheritValue();
-
-
-  void SetCalcValue(const nsStyleCoord::CalcValue* aCalc);
-
-  nsStyleCoord::CalcValue GetCalcValue() const;
-
-
-
-  nsCSSRect& SetRectValue();
-  nsCSSValueList* SetListValue();
-  nsCSSValuePairList* SetPairListValue();
-
-
-  void AdoptListValue(mozilla::UniquePtr<nsCSSValueList> aValue);
-  void AdoptPairListValue(mozilla::UniquePtr<nsCSSValuePairList> aValue);
-
-  void StartImageLoad(nsIDocument* aDocument) const;
-
-
-  Array* InitFunction(nsCSSKeyword aFunctionId, uint32_t aNumArgs);
-
-  bool EqualsFunction(nsCSSKeyword aFunctionId) const;
-
-
-
-  static already_AddRefed<nsStringBuffer>
-    BufferFromString(const nsString& aValue);
-
-
-  void AtomizeIdentValue();
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  static void
-  AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],
-                               const nsCSSValue* aValues[],
-                               nsAString& aString,
-                               Serialization aSerialization);
-  static void
-  AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],
-                                 const nsCSSValue* aValues[],
-                                 nsAString& aResult,
-                                 Serialization aValueSerialization);
-  static void
-  AppendAlignJustifyValueToString(int32_t aValue, nsAString& aResult);
-
-private:
-  static const char16_t* GetBufferValue(nsStringBuffer* aBuffer) {
-    return static_cast<char16_t*>(aBuffer->Data());
-  }
-
-  void AppendPolygonToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                             Serialization aValueSerialization) const;
-  void AppendPositionCoordinateToString(const nsCSSValue& aValue,
-                                        nsCSSPropertyID aProperty,
-                                        nsAString& aResult,
-                                        Serialization aSerialization) const;
-  void AppendCircleOrEllipseToString(
-           nsCSSKeyword aFunctionId,
-           nsCSSPropertyID aProperty, nsAString& aResult,
-           Serialization aValueSerialization) const;
-  void AppendBasicShapePositionToString(
-           nsAString& aResult,
-           Serialization aValueSerialization) const;
-  void AppendInsetToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                           Serialization aValueSerialization) const;
-protected:
-  nsCSSUnit mUnit;
-  union {
-    int32_t mInt;
-    float mFloat;
-
-
-    nsStringBuffer* mString;
-    nscolor mColor;
-    nsIAtom* mAtom;
-    Array* mArray;
-    mozilla::css::URLValue* mURL;
-    mozilla::css::ImageValue* mImage;
-    mozilla::css::GridTemplateAreasValue* mGridTemplateAreas;
-    nsCSSValueGradient* mGradient;
-    nsCSSValueTokenStream* mTokenStream;
-    nsCSSValuePair_heap* mPair;
-    nsCSSRect_heap* mRect;
-    nsCSSValueTriplet_heap* mTriplet;
-    nsCSSValueList_heap* mList;
-    nsCSSValueList* mListDependent;
-    nsCSSValueSharedList* mSharedList;
-    nsCSSValuePairList_heap* mPairList;
-    nsCSSValuePairList* mPairListDependent;
-    nsCSSValueFloatColor* mFloatColor;
-    mozilla::css::FontFamilyListRefCnt* mFontFamilyList;
-    mozilla::css::ComplexColorValue* mComplexColor;
-  } mValue;
-};
-
-struct nsCSSValue::Array final {
-
-
-  static Array* Create(size_t aItemCount) {
-    return new (aItemCount) Array(aItemCount);
-  }
-
-  nsCSSValue& operator[](size_t aIndex) {
-    do { } while (0);
-    return mArray[aIndex];
-  }
-
-  const nsCSSValue& operator[](size_t aIndex) const {
-    do { } while (0);
-    return mArray[aIndex];
-  }
-
-  nsCSSValue& Item(size_t aIndex) { return (*this)[aIndex]; }
-  const nsCSSValue& Item(size_t aIndex) const { return (*this)[aIndex]; }
-
-  size_t Count() const { return mCount; }
-
-
-  nsCSSValue* ItemStorage() {
-    return this->First();
-  }
-
-  bool operator==(const Array& aOther) const
-  {
-    if (mCount != aOther.mCount)
-      return false;
-    for (size_t i = 0; i < mCount; ++i)
-      if ((*this)[i] != aOther[i])
-        return false;
-    return true;
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Array>::value, "Reference-counted class " "Array" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
-private:
-
-  const size_t mCount;
-
-
-
-  nsCSSValue mArray[1];
-
-  void* operator new(size_t aSelfSize, size_t aItemCount) throw() {
-    do { } while (0);
-    return ::operator new(aSelfSize + sizeof(nsCSSValue) * (aItemCount - 1));
-  }
-
-  void operator delete(void* aPtr) { ::operator delete(aPtr); }
-
-  nsCSSValue* First() { return mArray; }
-
-  const nsCSSValue* First() const { return mArray; }
-
-
-
-
-
-  explicit Array(size_t aItemCount)
-    : mRefCnt(0)
-    , mCount(aItemCount)
-  {
-    for (nsCSSValue *val = First() + 1, *val_end = First() + mCount; val != val_end; ++val) {
-      new (val) nsCSSValue();
-    }
-  }
-
-  ~Array()
-  {
-    for (nsCSSValue *val = First() + 1, *val_end = First() + mCount; val != val_end; ++val) {
-      val->~nsCSSValue();
-    }
-  }
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-
-
-private:
-  Array(const Array& aOther) = delete;
-  Array& operator=(const Array& aOther) = delete;
-};
-
-
-struct nsCSSValueList {
-  nsCSSValueList() : mNext(nullptr) { ; }
-  ~nsCSSValueList();
-
-  nsCSSValueList* Clone() const;
-  void CloneInto(nsCSSValueList* aList) const;
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      nsCSSValue::Serialization aValueSerialization) const;
-
-  static bool Equal(const nsCSSValueList* aList1,
-                    const nsCSSValueList* aList2);
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  nsCSSValue mValue;
-  nsCSSValueList* mNext;
-
-private:
-  nsCSSValueList(const nsCSSValueList& aCopy)
-    : mValue(aCopy.mValue), mNext(nullptr)
-  {
-                                  ;
-  }
-
-
-
-
-  bool operator==(nsCSSValueList const& aOther) const = delete;
-  bool operator!=(const nsCSSValueList& aOther) const = delete;
-};
-
-
-
-
-struct nsCSSValueList_heap final : public nsCSSValueList {
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueList_heap>::value, "Reference-counted class " "nsCSSValueList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSValueList_heap()
-  {
-  }
-};
-
-
-
-
-
-struct nsCSSValueSharedList final {
-  nsCSSValueSharedList()
-    : mHead(nullptr)
-  {
-  }
-
-
-  explicit nsCSSValueSharedList(nsCSSValueList* aList)
-    : mHead(aList)
-  {
-  }
-
-private:
-
-  ~nsCSSValueSharedList();
-
-public:
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueSharedList>::value, "Reference-counted class " "nsCSSValueSharedList" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      nsCSSValue::Serialization aValueSerialization) const;
-
-  bool operator==(nsCSSValueSharedList const& aOther) const;
-  bool operator!=(const nsCSSValueSharedList& aOther) const
-  { return !(*this == aOther); }
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  nsCSSValueList* mHead;
-};
-
-
-
-inline nsCSSValueList*
-nsCSSValue::GetListValue()
-{
-  if (mUnit == eCSSUnit_List)
-    return mValue.mList;
-  else {
-    do { } while (0);
-    return mValue.mListDependent;
-  }
-}
-
-inline const nsCSSValueList*
-nsCSSValue::GetListValue() const
-{
-  if (mUnit == eCSSUnit_List)
-    return mValue.mList;
-  else {
-    do { } while (0);
-    return mValue.mListDependent;
-  }
-}
-
-struct nsCSSRect {
-  nsCSSRect(void);
-  nsCSSRect(const nsCSSRect& aCopy);
-  ~nsCSSRect();
-
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      nsCSSValue::Serialization aValueSerialization) const;
-
-  bool operator==(const nsCSSRect& aOther) const {
-    return mTop == aOther.mTop &&
-           mRight == aOther.mRight &&
-           mBottom == aOther.mBottom &&
-           mLeft == aOther.mLeft;
-  }
-
-  bool operator!=(const nsCSSRect& aOther) const {
-    return mTop != aOther.mTop ||
-           mRight != aOther.mRight ||
-           mBottom != aOther.mBottom ||
-           mLeft != aOther.mLeft;
-  }
-
-  void SetAllSidesTo(const nsCSSValue& aValue);
-
-  bool AllSidesEqualTo(const nsCSSValue& aValue) const {
-    return mTop == aValue &&
-           mRight == aValue &&
-           mBottom == aValue &&
-           mLeft == aValue;
-  }
-
-  void Reset() {
-    mTop.Reset();
-    mRight.Reset();
-    mBottom.Reset();
-    mLeft.Reset();
-  }
-
-  bool HasValue() const {
-    return
-      mTop.GetUnit() != eCSSUnit_Null ||
-      mRight.GetUnit() != eCSSUnit_Null ||
-      mBottom.GetUnit() != eCSSUnit_Null ||
-      mLeft.GetUnit() != eCSSUnit_Null;
-  }
-
-  nsCSSValue mTop;
-  nsCSSValue mRight;
-  nsCSSValue mBottom;
-  nsCSSValue mLeft;
-
-  typedef nsCSSValue nsCSSRect::*side_type;
-  static const side_type sides[4];
-};
-
-
-
-
-struct nsCSSRect_heap final : public nsCSSRect {
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSRect_heap>::value, "Reference-counted class " "nsCSSRect_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSRect_heap()
-  {
-  }
-};
-
-
-
-inline nsCSSRect&
-nsCSSValue::GetRectValue()
-{
-  do { } while (0);
-  return *mValue.mRect;
-}
-
-inline const nsCSSRect&
-nsCSSValue::GetRectValue() const
-{
-  do { } while (0);
-  return *mValue.mRect;
-}
-
-struct nsCSSValuePair {
-  nsCSSValuePair()
-  {
-                                  ;
-  }
-  explicit nsCSSValuePair(nsCSSUnit aUnit)
-    : mXValue(aUnit), mYValue(aUnit)
-  {
-                                  ;
-  }
-  nsCSSValuePair(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
-    : mXValue(aXValue), mYValue(aYValue)
-  {
-                                  ;
-  }
-  nsCSSValuePair(const nsCSSValuePair& aCopy)
-    : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue)
-  {
-                                  ;
-  }
-  ~nsCSSValuePair()
-  {
-                                  ;
-  }
-
-  nsCSSValuePair& operator=(const nsCSSValuePair& aOther) {
-    mXValue = aOther.mXValue;
-    mYValue = aOther.mYValue;
-    return *this;
-  }
-
-  bool operator==(const nsCSSValuePair& aOther) const {
-    return mXValue == aOther.mXValue &&
-           mYValue == aOther.mYValue;
-  }
-
-  bool operator!=(const nsCSSValuePair& aOther) const {
-    return mXValue != aOther.mXValue ||
-           mYValue != aOther.mYValue;
-  }
-
-  bool BothValuesEqualTo(const nsCSSValue& aValue) const {
-    return mXValue == aValue &&
-           mYValue == aValue;
-  }
-
-  void SetBothValuesTo(const nsCSSValue& aValue) {
-    mXValue = aValue;
-    mYValue = aValue;
-  }
-
-  void Reset() {
-    mXValue.Reset();
-    mYValue.Reset();
-  }
-
-  bool HasValue() const {
-    return mXValue.GetUnit() != eCSSUnit_Null ||
-           mYValue.GetUnit() != eCSSUnit_Null;
-  }
-
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      nsCSSValue::Serialization aValueSerialization) const;
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  nsCSSValue mXValue;
-  nsCSSValue mYValue;
-};
-
-
-
-
-struct nsCSSValuePair_heap final : public nsCSSValuePair {
-
-  nsCSSValuePair_heap(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
-      : nsCSSValuePair(aXValue, aYValue)
-  {}
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePair_heap>::value, "Reference-counted class " "nsCSSValuePair_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSValuePair_heap()
-  {
-  }
-};
-
-struct nsCSSValueTriplet {
-    nsCSSValueTriplet()
-    {
-                                         ;
-    }
-    explicit nsCSSValueTriplet(nsCSSUnit aUnit)
-        : mXValue(aUnit), mYValue(aUnit), mZValue(aUnit)
-    {
-                                         ;
-    }
-    nsCSSValueTriplet(const nsCSSValue& aXValue,
-                      const nsCSSValue& aYValue,
-                      const nsCSSValue& aZValue)
-        : mXValue(aXValue), mYValue(aYValue), mZValue(aZValue)
-    {
-                                         ;
-    }
-    nsCSSValueTriplet(const nsCSSValueTriplet& aCopy)
-        : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mZValue(aCopy.mZValue)
-    {
-                                         ;
-    }
-    ~nsCSSValueTriplet()
-    {
-                                         ;
-    }
-
-    bool operator==(const nsCSSValueTriplet& aOther) const {
-        return mXValue == aOther.mXValue &&
-               mYValue == aOther.mYValue &&
-               mZValue == aOther.mZValue;
-    }
-
-    bool operator!=(const nsCSSValueTriplet& aOther) const {
-        return mXValue != aOther.mXValue ||
-               mYValue != aOther.mYValue ||
-               mZValue != aOther.mZValue;
-    }
-
-    bool AllValuesEqualTo(const nsCSSValue& aValue) const {
-        return mXValue == aValue &&
-               mYValue == aValue &&
-               mZValue == aValue;
-    }
-
-    void SetAllValuesTo(const nsCSSValue& aValue) {
-        mXValue = aValue;
-        mYValue = aValue;
-        mZValue = aValue;
-    }
-
-    void Reset() {
-        mXValue.Reset();
-        mYValue.Reset();
-        mZValue.Reset();
-    }
-
-    bool HasValue() const {
-        return mXValue.GetUnit() != eCSSUnit_Null ||
-               mYValue.GetUnit() != eCSSUnit_Null ||
-               mZValue.GetUnit() != eCSSUnit_Null;
-    }
-
-    void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                        nsCSSValue::Serialization aValueSerialization) const;
-
-    nsCSSValue mXValue;
-    nsCSSValue mYValue;
-    nsCSSValue mZValue;
-};
-
-
-
-
-struct nsCSSValueTriplet_heap final : public nsCSSValueTriplet {
-
-  nsCSSValueTriplet_heap(const nsCSSValue& aXValue, const nsCSSValue& aYValue, const nsCSSValue& aZValue)
-    : nsCSSValueTriplet(aXValue, aYValue, aZValue)
-  {}
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTriplet_heap>::value, "Reference-counted class " "nsCSSValueTriplet_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSValueTriplet_heap()
-  {
-  }
-};
-
-
-
-inline nsCSSValuePair&
-nsCSSValue::GetPairValue()
-{
-  do { } while (0);
-  return *mValue.mPair;
-}
-
-inline const nsCSSValuePair&
-nsCSSValue::GetPairValue() const
-{
-  do { } while (0);
-  return *mValue.mPair;
-}
-
-inline nsCSSValueTriplet&
-nsCSSValue::GetTripletValue()
-{
-    do { } while (0);
-    return *mValue.mTriplet;
-}
-
-inline const nsCSSValueTriplet&
-nsCSSValue::GetTripletValue() const
-{
-    do { } while (0);
-    return *mValue.mTriplet;
-}
-
-
-struct nsCSSValuePairList {
-  nsCSSValuePairList() : mNext(nullptr) { ; }
-  ~nsCSSValuePairList();
-
-  nsCSSValuePairList* Clone() const;
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
-                      nsCSSValue::Serialization aValueSerialization) const;
-
-  static bool Equal(const nsCSSValuePairList* aList1,
-                    const nsCSSValuePairList* aList2);
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  nsCSSValue mXValue;
-  nsCSSValue mYValue;
-  nsCSSValuePairList* mNext;
-
-private:
-  nsCSSValuePairList(const nsCSSValuePairList& aCopy)
-    : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mNext(nullptr)
-  {
-                                      ;
-  }
-
-
-
-
-  bool operator==(const nsCSSValuePairList& aOther) const = delete;
-  bool operator!=(const nsCSSValuePairList& aOther) const = delete;
-};
-
-
-
-
-struct nsCSSValuePairList_heap final : public nsCSSValuePairList {
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePairList_heap>::value, "Reference-counted class " "nsCSSValuePairList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSValuePairList_heap()
-  {
-  }
-};
-
-
-
-inline nsCSSValuePairList*
-nsCSSValue::GetPairListValue()
-{
-  if (mUnit == eCSSUnit_PairList)
-    return mValue.mPairList;
-  else {
-    do { } while (0);
-    return mValue.mPairListDependent;
-  }
-}
-
-inline const nsCSSValuePairList*
-nsCSSValue::GetPairListValue() const
-{
-  if (mUnit == eCSSUnit_PairList)
-    return mValue.mPairList;
-  else {
-    do { } while (0);
-    return mValue.mPairListDependent;
-  }
-}
-
-struct nsCSSValueGradientStop {
-public:
-  nsCSSValueGradientStop();
-
-
-  nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther);
-  ~nsCSSValueGradientStop();
-
-  nsCSSValue mLocation;
-  nsCSSValue mColor;
-
-
-  bool mIsInterpolationHint;
-
-  bool operator==(const nsCSSValueGradientStop& aOther) const
-  {
-    return (mLocation == aOther.mLocation &&
-            mIsInterpolationHint == aOther.mIsInterpolationHint &&
-            (mIsInterpolationHint || mColor == aOther.mColor));
-  }
-
-  bool operator!=(const nsCSSValueGradientStop& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-};
-
-struct nsCSSValueGradient final {
-  nsCSSValueGradient(bool aIsRadial, bool aIsRepeating);
-
-
-  bool mIsRadial;
-  bool mIsRepeating;
-  bool mIsLegacySyntax;
-  bool mIsExplicitSize;
-
-  nsCSSValuePair mBgPos;
-  nsCSSValue mAngle;
-
-
-private:
-  nsCSSValue mRadialValues[2];
-public:
-  nsCSSValue& GetRadialShape()
-  {
-    do { } while (0);
-    return mRadialValues[0];
-  }
-  const nsCSSValue& GetRadialShape() const
-  {
-    do { } while (0);
-    return mRadialValues[0];
-  }
-  nsCSSValue& GetRadialSize()
-  {
-    do { } while (0);
-    return mRadialValues[1];
-  }
-  const nsCSSValue& GetRadialSize() const
-  {
-    do { } while (0);
-    return mRadialValues[1];
-  }
-  nsCSSValue& GetRadiusX()
-  {
-    do { } while (0);
-    return mRadialValues[0];
-  }
-  const nsCSSValue& GetRadiusX() const
-  {
-    do { } while (0);
-    return mRadialValues[0];
-  }
-  nsCSSValue& GetRadiusY()
-  {
-    do { } while (0);
-    return mRadialValues[1];
-  }
-  const nsCSSValue& GetRadiusY() const
-  {
-    do { } while (0);
-    return mRadialValues[1];
-  }
-
-  InfallibleTArray<nsCSSValueGradientStop> mStops;
-
-  bool operator==(const nsCSSValueGradient& aOther) const
-  {
-    if (mIsRadial != aOther.mIsRadial ||
-        mIsRepeating != aOther.mIsRepeating ||
-        mIsLegacySyntax != aOther.mIsLegacySyntax ||
-        mIsExplicitSize != aOther.mIsExplicitSize ||
-        mBgPos != aOther.mBgPos ||
-        mAngle != aOther.mAngle ||
-        mRadialValues[0] != aOther.mRadialValues[0] ||
-        mRadialValues[1] != aOther.mRadialValues[1])
-      return false;
-
-    if (mStops.Length() != aOther.mStops.Length())
-      return false;
-
-    for (uint32_t i = 0; i < mStops.Length(); i++) {
-      if (mStops[i] != aOther.mStops[i])
-        return false;
-    }
-
-    return true;
-  }
-
-  bool operator!=(const nsCSSValueGradient& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueGradient>::value, "Reference-counted class " "nsCSSValueGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-private:
-
-  ~nsCSSValueGradient()
-  {
-  }
-
-  nsCSSValueGradient(const nsCSSValueGradient& aOther) = delete;
-  nsCSSValueGradient& operator=(const nsCSSValueGradient& aOther) = delete;
-};
-# 1769 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-struct nsCSSValueTokenStream final {
-  nsCSSValueTokenStream();
-
-private:
-
-  ~nsCSSValueTokenStream();
-
-public:
-  bool operator==(const nsCSSValueTokenStream& aOther) const
-  {
-    bool eq;
-    return mPropertyID == aOther.mPropertyID &&
-           mShorthandPropertyID == aOther.mShorthandPropertyID &&
-           mTokenStream.Equals(aOther.mTokenStream) &&
-           mLevel == aOther.mLevel &&
-           (mBaseURI == aOther.mBaseURI ||
-            (mBaseURI && aOther.mBaseURI &&
-             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mBaseURI->Equals(aOther.mBaseURI, &eq))), 1))) &&
-             eq)) &&
-           (mSheetURI == aOther.mSheetURI ||
-            (mSheetURI && aOther.mSheetURI &&
-             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mSheetURI->Equals(aOther.mSheetURI, &eq))), 1))) &&
-             eq)) &&
-           (mSheetPrincipal == aOther.mSheetPrincipal ||
-            (mSheetPrincipal && aOther.mSheetPrincipal &&
-             ((bool)(__builtin_expect(!!(!NS_FAILED_impl(mSheetPrincipal->Equals(aOther.mSheetPrincipal, &eq))), 1))) &&
-
-             eq));
-  }
-
-  bool operator!=(const nsCSSValueTokenStream& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTokenStream>::value, "Reference-counted class " "nsCSSValueTokenStream" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-
-
-
-
-  nsCSSPropertyID mPropertyID;
-
-
-
-
-  nsCSSPropertyID mShorthandPropertyID;
-
-
-
-
-
-  nsString mTokenStream;
-
-  nsCOMPtr<nsIURI> mBaseURI;
-  nsCOMPtr<nsIURI> mSheetURI;
-  nsCOMPtr<nsIPrincipal> mSheetPrincipal;
-
-
-  uint32_t mLineNumber;
-  uint32_t mLineOffset;
-  mozilla::SheetType mLevel;
-
-private:
-  nsCSSValueTokenStream(const nsCSSValueTokenStream& aOther) = delete;
-  nsCSSValueTokenStream& operator=(const nsCSSValueTokenStream& aOther) = delete;
-};
-
-class nsCSSValueFloatColor final {
-public:
-  nsCSSValueFloatColor(float aComponent1, float aComponent2, float aComponent3,
-                       float aAlpha)
-    : mComponent1(aComponent1)
-    , mComponent2(aComponent2)
-    , mComponent3(aComponent3)
-    , mAlpha(aAlpha)
-  {}
-
-private:
-
-  ~nsCSSValueFloatColor()
-  {}
-
-public:
-  bool operator==(nsCSSValueFloatColor& aOther) const;
-
-  nscolor GetColorValue(nsCSSUnit aUnit) const;
-  float Comp1() const { return mComponent1; }
-  float Comp2() const { return mComponent2; }
-  float Comp3() const { return mComponent3; }
-  float Alpha() const { return mAlpha; }
-  bool IsNonTransparentColor() const;
-
-  void AppendToString(nsCSSUnit aUnit, nsAString& aResult) const;
-
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueFloatColor>::value, "Reference-counted class " "nsCSSValueFloatColor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-private:
-# 1881 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSValue.h"
-  float mComponent1;
-  float mComponent2;
-  float mComponent3;
-  float mAlpha;
-
-  nsCSSValueFloatColor(const nsCSSValueFloatColor& aOther) = delete;
-  nsCSSValueFloatColor& operator=(const nsCSSValueFloatColor& aOther)
-                                                                   = delete;
-};
-
-struct nsCSSCornerSizes {
-  nsCSSCornerSizes(void);
-  nsCSSCornerSizes(const nsCSSCornerSizes& aCopy);
-  ~nsCSSCornerSizes();
-
-
-  nsCSSValue const & GetCorner(uint32_t aCorner) const {
-    return this->*corners[aCorner];
-  }
-  nsCSSValue & GetCorner(uint32_t aCorner) {
-    return this->*corners[aCorner];
-  }
-
-  bool operator==(const nsCSSCornerSizes& aOther) const {
-    int32_t corner1905 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1905 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1905), true); ++corner1905) {
-      if (this->GetCorner(corner) != aOther.GetCorner(corner))
-        return false;
-    }
-    return true;
-  }
-
-  bool operator!=(const nsCSSCornerSizes& aOther) const {
-    int32_t corner1913 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1913 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1913), true); ++corner1913) {
-      if (this->GetCorner(corner) != aOther.GetCorner(corner))
-        return true;
-    }
-    return false;
-  }
-
-  bool HasValue() const {
-    int32_t corner1921 = mozilla::eCornerTopLeft; for (mozilla::Corner corner; corner1921 <= mozilla::eCornerBottomLeft && (corner = mozilla::Corner(corner1921), true); ++corner1921) {
-      if (this->GetCorner(corner).GetUnit() != eCSSUnit_Null)
-        return true;
-    }
-    return false;
-  }
-
-  void Reset();
-
-  nsCSSValue mTopLeft;
-  nsCSSValue mTopRight;
-  nsCSSValue mBottomRight;
-  nsCSSValue mBottomLeft;
-
-protected:
-  typedef nsCSSValue nsCSSCornerSizes::*corner_type;
-  static const corner_type corners[4];
-};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/DOMIntersectionObserver.h" 2
-
-
-using mozilla::dom::DOMRect;
-using mozilla::dom::Element;
-
-namespace mozilla {
-namespace dom {
-
-class DOMIntersectionObserver;
-
-class DOMIntersectionObserverEntry final : public nsISupports,
-                                           public nsWrapperCache
-{
-  ~DOMIntersectionObserverEntry() {}
-
-public:
-  DOMIntersectionObserverEntry(nsISupports* aOwner,
-                               DOMHighResTimeStamp aTime,
-                               RefPtr<DOMRect> aRootBounds,
-                               RefPtr<DOMRect> aBoundingClientRect,
-                               RefPtr<DOMRect> aIntersectionRect,
-                               bool aIsIntersecting,
-                               Element* aTarget,
-                               double aIntersectionRatio)
-  : mOwner(aOwner),
-    mTime(aTime),
-    mRootBounds(aRootBounds),
-    mBoundingClientRect(aBoundingClientRect),
-    mIntersectionRect(aIntersectionRect),
-    mIsIntersecting(aIsIntersecting),
-    mTarget(aTarget),
-    mIntersectionRatio(aIntersectionRatio)
-  {
-  }
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMIntersectionObserverEntry"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMIntersectionObserverEntry>(p)->DeleteCycleCollectable(); } static DOMIntersectionObserverEntry* Downcast(nsISupports* s) { return static_cast<DOMIntersectionObserverEntry*>(static_cast<DOMIntersectionObserverEntry*>(s)); } static nsISupports* Upcast(DOMIntersectionObserverEntry *p) { return static_cast<nsISupports*>(static_cast<DOMIntersectionObserverEntry*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMIntersectionObserverEntry::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-  nsISupports* GetParentObject() const
-  {
-    return mOwner;
-  }
-
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
-  {
-    return mozilla::dom::IntersectionObserverEntryBinding::Wrap(aCx, this, aGivenProto);
-  }
-
-  DOMHighResTimeStamp Time()
-  {
-    return mTime;
-  }
-
-  DOMRect* GetRootBounds()
-  {
-    return mRootBounds;
-  }
-
-  DOMRect* BoundingClientRect()
-  {
-    return mBoundingClientRect;
-  }
-
-  DOMRect* IntersectionRect()
-  {
-    return mIntersectionRect;
-  }
-
-  bool IsIntersecting()
-  {
-    return mIsIntersecting;
-  }
-
-  double IntersectionRatio()
-  {
-    return mIntersectionRatio;
-  }
-
-  Element* Target()
-  {
-    return mTarget;
-  }
-
-protected:
-  nsCOMPtr<nsISupports> mOwner;
-  DOMHighResTimeStamp mTime;
-  RefPtr<DOMRect> mRootBounds;
-  RefPtr<DOMRect> mBoundingClientRect;
-  RefPtr<DOMRect> mIntersectionRect;
-  bool mIsIntersecting;
-  RefPtr<Element> mTarget;
-  double mIntersectionRatio;
-};
-
-
-
-
-
-class DOMIntersectionObserver final : public nsISupports,
-                                      public nsWrapperCache
-{
-  virtual ~DOMIntersectionObserver() {
-    Disconnect();
-  }
-
-public:
-  DOMIntersectionObserver(already_AddRefed<nsPIDOMWindowInner>&& aOwner,
-                          mozilla::dom::IntersectionCallback& aCb)
-  : mOwner(aOwner), mDocument(mOwner->GetExtantDoc()), mCallback(&aCb), mConnected(false)
-  {
-  }
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DOMIntersectionObserver"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DOMIntersectionObserver>(p)->DeleteCycleCollectable(); } static DOMIntersectionObserver* Downcast(nsISupports* s) { return static_cast<DOMIntersectionObserver*>(static_cast<DOMIntersectionObserver*>(s)); } static nsISupports* Upcast(DOMIntersectionObserver *p) { return static_cast<nsISupports*>(static_cast<DOMIntersectionObserver*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DOMIntersectionObserver::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-  template<typename T, typename U> struct COMTypeInfo;
-
-  static already_AddRefed<DOMIntersectionObserver>
-  Constructor(const mozilla::dom::GlobalObject& aGlobal,
-              mozilla::dom::IntersectionCallback& aCb,
-              mozilla::ErrorResult& aRv);
-  static already_AddRefed<DOMIntersectionObserver>
-  Constructor(const mozilla::dom::GlobalObject& aGlobal,
-              mozilla::dom::IntersectionCallback& aCb,
-              const mozilla::dom::IntersectionObserverInit& aOptions,
-              mozilla::ErrorResult& aRv);
-
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
-  {
-    return mozilla::dom::IntersectionObserverBinding::Wrap(aCx, this, aGivenProto);
-  }
-
-  nsISupports* GetParentObject() const
-  {
-    return mOwner;
-  }
-
-  Element* GetRoot() const {
-    return mRoot;
-  }
-
-  void GetRootMargin(mozilla::dom::DOMString& aRetVal);
-  void GetThresholds(nsTArray<double>& aRetVal);
-  void Observe(Element& aTarget);
-  void Unobserve(Element& aTarget);
-
-  void UnlinkTarget(Element& aTarget);
-  void Disconnect();
-
-  void TakeRecords(nsTArray<RefPtr<DOMIntersectionObserverEntry>>& aRetVal);
-
-  mozilla::dom::IntersectionCallback* IntersectionCallback() { return mCallback; }
-
-  bool SetRootMargin(const nsAString& aString);
-
-  void Update(nsIDocument* aDocument, DOMHighResTimeStamp time);
-  void Notify();
-
-protected:
-  void Connect();
-  void QueueIntersectionObserverEntry(Element* aTarget,
-                                      DOMHighResTimeStamp time,
-                                      const Maybe<nsRect>& aRootRect,
-                                      const nsRect& aTargetRect,
-                                      const Maybe<nsRect>& aIntersectionRect,
-                                      double aIntersectionRatio);
-
-  nsCOMPtr<nsPIDOMWindowInner> mOwner;
-  RefPtr<nsIDocument> mDocument;
-  RefPtr<mozilla::dom::IntersectionCallback> mCallback;
-  RefPtr<Element> mRoot;
-  nsCSSRect mRootMargin;
-  nsTArray<double> mThresholds;
-  nsTHashtable<nsPtrHashKey<Element>> mObservationTargets;
-  nsTArray<RefPtr<DOMIntersectionObserverEntry>> mQueuedEntries;
-  bool mConnected;
-};
-
-template<typename T> struct DOMIntersectionObserver::COMTypeInfo<DOMIntersectionObserver, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID DOMIntersectionObserver::COMTypeInfo<DOMIntersectionObserver, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0x8570a575, 0xe303, 0x4d18, { 0xb6, 0xb1, 0x4d, 0x2b, 0x49, 0xd8, 0xef, 0x94 } };
-
-}
-}
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h" 2
-
-class mozAutoDocUpdate;
-class nsIFrame;
-class nsIDOMMozNamedAttrMap;
-class nsIMozBrowserFrame;
-class nsIURI;
-class nsIScrollableFrame;
-class nsAttrValueOrString;
-class nsContentList;
-class nsDOMTokenList;
-struct nsRect;
-class nsFocusManager;
-class nsGlobalWindow;
-class nsICSSDeclaration;
-class nsISMILAttr;
-class nsDocument;
-class nsDOMStringMap;
-
-namespace mozilla {
-class DeclarationBlock;
-namespace dom {
-  struct AnimationFilter;
-  struct ScrollIntoViewOptions;
-  struct ScrollToOptions;
-  class DOMIntersectionObserver;
-  class ElementOrCSSPseudoElement;
-  class UnrestrictedDoubleOrKeyframeAnimationOptions;
-  enum class CallerType : uint32_t;
-}
-}
-
-
-already_AddRefed<nsContentList>
-NS_GetContentList(nsINode* aRootNode,
-                  int32_t aMatchNameSpaceId,
-                  const nsAString& aTagname);
-
-
-
-
-enum {
-
-  ELEMENT_HAS_PENDING_RESTYLE = NODE_SHARED_RESTYLE_BIT_1,
-
-
-
-
-  ELEMENT_IS_POTENTIAL_RESTYLE_ROOT = NODE_SHARED_RESTYLE_BIT_2,
-
-
-
-
-
-  ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (0)))),
-
-
-
-
-  ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (1)))),
-
-
-
-  ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (2)))),
-
-
-  ELEMENT_PENDING_RESTYLE_FLAGS =
-    ELEMENT_HAS_PENDING_RESTYLE |
-    ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE,
-
-
-  ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS =
-    ELEMENT_IS_POTENTIAL_RESTYLE_ROOT |
-    ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT,
-
-
-  ELEMENT_ALL_RESTYLE_FLAGS = ELEMENT_PENDING_RESTYLE_FLAGS |
-                              ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS |
-                              ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR,
-
-
-  ELEMENT_HAS_SCROLLGRAB = (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (NODE_TYPE_SPECIFIC_BITS_OFFSET + (3)))),
-
-
-  ELEMENT_TYPE_SPECIFIC_BITS_OFFSET = NODE_TYPE_SPECIFIC_BITS_OFFSET + 4
-};
-
-
-
-
-static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (ELEMENT_TYPE_SPECIFIC_BITS_OFFSET) <= sizeof(nsWrapperCache::FlagsType) * 8, "Not enough space for our bits");
-
-namespace mozilla {
-enum class CSSPseudoElementType : uint8_t;
-class EventChainPostVisitor;
-class EventChainPreVisitor;
-class EventChainVisitor;
-class EventListenerManager;
-class EventStateManager;
-
-namespace dom {
-
-class Animation;
-class CustomElementRegistry;
-class Link;
-class DOMRect;
-class DOMRectList;
-class DestinationInsertionPointList;
-class Grid;
-
-
-
-
-
-
-class Element : public FragmentOrElement
-{
-public:
-
-  explicit Element(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo) :
-    FragmentOrElement(aNodeInfo),
-    mState((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 29)))
-  {
-    do { } while (0);
-
-    SetIsElement();
-  }
-
-  ~Element()
-  {
-
-    do { } while(0);
-
-  }
-
-
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override;
-
-
-
-
-
-  EventStates State() const
-  {
-
-
-    return mState;
-  }
-# 206 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  void UpdateState(bool aNotify);
-
-
-
-
-  void UpdateLinkState(EventStates aState);
-
-  virtual int32_t TabIndexDefault()
-  {
-    return -1;
-  }
-
-
-
-
-  int32_t TabIndex();
-
-
-
-
-  void SetTabIndex(int32_t aTabIndex, mozilla::ErrorResult& aError);
-
-
-
-
-  virtual void Focus(mozilla::ErrorResult& aError);
-
-
-
-
-  virtual void Blur(mozilla::ErrorResult& aError);
-
-
-
-
-
-  EventStates StyleState() const
-  {
-    if (!HasLockedStyleStates()) {
-      return mState;
-    }
-    return StyleStateFromLocks();
-  }
-
-
-
-
-
-  struct StyleStateLocks {
-
-    EventStates mLocks;
-
-    EventStates mValues;
-  };
-
-
-
-
-  StyleStateLocks LockedStyleStates() const;
-
-
-
-
-
-  void LockStyleStates(EventStates aStates, bool aEnabled);
-
-
-
-
-  void UnlockStyleStates(EventStates aStates);
-
-
-
-
-  void ClearStyleStateLocks();
-
-
-
-
-  DeclarationBlock* GetInlineStyleDeclaration() const;
-
-
-
-
-  const nsMappedAttributes* GetMappedAttributes() const;
-
-  void ClearMappedServoStyle() {
-    mAttrsAndChildren.ClearMappedServoStyle();
-  }
-
-
-
-
-
-  virtual nsresult SetInlineStyleDeclaration(DeclarationBlock* aDeclaration,
-                                             const nsAString* aSerialized,
-                                             bool aNotify);
-
-
-
-
-
-  virtual DeclarationBlock* GetSMILOverrideStyleDeclaration();
-
-
-
-
-
-
-  virtual nsresult SetSMILOverrideStyleDeclaration(
-    DeclarationBlock* aDeclaration, bool aNotify);
-
-
-
-
-
-  virtual UniquePtr<nsISMILAttr> GetAnimatedAttr(int32_t aNamespaceID,
-                                                 nsIAtom* aName)
-  {
-    return nullptr;
-  }
-# 336 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual nsICSSDeclaration* GetSMILOverrideStyle();
-
-
-
-
-  virtual bool IsLabelable() const;
-
-
-
-
-  virtual bool IsInteractiveHTMLContent(bool aIgnoreTabindex) const;
-# 356 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual nsIMozBrowserFrame* GetAsMozBrowserFrame() { return nullptr; }
-# 365 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual bool IsAttributeMapped(const nsIAtom* aAttribute) const;
-
-
-
-
-
-
-
-  virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
-                                              int32_t aModType) const;
-
-  inline Directionality GetDirectionality() const {
-    if (HasFlag(NODE_HAS_DIRECTION_RTL)) {
-      return eDir_RTL;
-    }
-
-    if (HasFlag(NODE_HAS_DIRECTION_LTR)) {
-      return eDir_LTR;
-    }
-
-    return eDir_NotSet;
-  }
-
-  inline void SetDirectionality(Directionality aDir, bool aNotify) {
-    UnsetFlags(NODE_ALL_DIRECTION_FLAGS);
-    if (!aNotify) {
-      RemoveStatesSilently(((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 44)) | (mozilla::EventStates(mozilla::EventStates::InternalType(1) << 45))));
-    }
-
-    switch (aDir) {
-      case (eDir_RTL):
-        SetFlags(NODE_HAS_DIRECTION_RTL);
-        if (!aNotify) {
-          AddStatesSilently((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 45)));
-        }
-        break;
-
-      case(eDir_LTR):
-        SetFlags(NODE_HAS_DIRECTION_LTR);
-        if (!aNotify) {
-          AddStatesSilently((mozilla::EventStates(mozilla::EventStates::InternalType(1) << 44)));
-        }
-        break;
-
-      default:
-        break;
-    }
-
-
-
-
-
-
-    if (aNotify) {
-      UpdateState(true);
-    }
-  }
-
-  bool GetBindingURL(nsIDocument* aDocument, css::URLValue **aResult);
-
-
-
-
-
-  inline bool HasDirAuto() const {
-    return (!HasFixedDir() &&
-            (HasValidDir() || IsHTMLElement(nsGkAtoms::bdi)));
-  }
-
-  Directionality GetComputedDirectionality() const;
-
-  inline Element* GetFlattenedTreeParentElement() const;
-  inline Element* GetFlattenedTreeParentElementForStyle() const;
-
-  bool HasDirtyDescendantsForServo() const
-  {
-    do { } while (0);
-    return HasFlag(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
-  }
-
-  void SetHasDirtyDescendantsForServo() {
-    do { } while (0);
-    SetFlags(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
-  }
-
-  void UnsetHasDirtyDescendantsForServo() {
-    do { } while (0);
-    UnsetFlags(NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
-  }
-
-  inline void NoteDirtyDescendantsForServo();
-
-
-
-
-
-  bool HasServoData() const {
-
-    return !!mServoData.Get();
-
-
-
-  }
-
-  void ClearServoData();
-
-
-
-
-
-
-
-  inline CustomElementData* GetCustomElementData() const
-  {
-    nsDOMSlots *slots = GetExistingDOMSlots();
-    if (slots) {
-      return slots->mCustomElementData;
-    }
-    return nullptr;
-  }
-
-
-
-
-
-
-
-  void SetCustomElementData(CustomElementData* aData);
-
-protected:
-
-
-
-
-
-
-  virtual EventStates IntrinsicState() const;
-
-
-
-
-
-
-
-  void AddStatesSilently(EventStates aStates)
-  {
-    mState |= aStates;
-  }
-
-
-
-
-
-
-
-  void RemoveStatesSilently(EventStates aStates)
-  {
-    mState &= ~aStates;
-  }
-
-private:
-
-
-  friend class mozilla::EventStateManager;
-  friend class ::nsGlobalWindow;
-  friend class ::nsFocusManager;
-
-
-  friend class CustomElementRegistry;
-
-
-  friend class Link;
-
-  void NotifyStateChange(EventStates aStates);
-
-  void NotifyStyleStateChange(EventStates aStates);
-
-
-  EventStates StyleStateFromLocks() const;
-
-protected:
-
-
-
-
-  virtual void AddStates(EventStates aStates)
-  {
-    do { } while(0);
-
-    AddStatesSilently(aStates);
-    NotifyStateChange(aStates);
-  }
-  virtual void RemoveStates(EventStates aStates)
-  {
-    do { } while(0);
-
-    RemoveStatesSilently(aStates);
-    NotifyStateChange(aStates);
-  }
-public:
-
-  void AddManuallyManagedStates(EventStates aStates)
-  {
-    do { } while (0);
-
-    AddStates(aStates);
-  }
-  void RemoveManuallyManagedStates(EventStates aStates)
-  {
-    do { } while (0);
-
-    RemoveStates(aStates);
-  }
-
-  virtual void UpdateEditableState(bool aNotify) override;
-
-  virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
-                              nsIContent* aBindingParent,
-                              bool aCompileEventHandlers) override;
-  virtual void UnbindFromTree(bool aDeep = true,
-                              bool aNullParent = true) override;
-# 597 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  already_AddRefed<mozilla::dom::NodeInfo>
-  GetExistingAttrNameFromQName(const nsAString& aStr) const;
-
-  nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-                   const nsAString& aValue, bool aNotify)
-  {
-    return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
-  }
-# 622 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  bool MaybeCheckSameAttrVal(int32_t aNamespaceID, nsIAtom* aName,
-                             nsIAtom* aPrefix,
-                             const nsAttrValueOrString& aValue,
-                             bool aNotify, nsAttrValue& aOldValue,
-                             uint8_t* aModType, bool* aHasListeners);
-
-  bool OnlyNotifySameValueSet(int32_t aNamespaceID, nsIAtom* aName,
-                              nsIAtom* aPrefix,
-                              const nsAttrValueOrString& aValue,
-                              bool aNotify, nsAttrValue& aOldValue,
-                              uint8_t* aModType, bool* aHasListeners);
-
-  virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
-                           const nsAString& aValue, bool aNotify) override;
-
-
-  nsresult SetParsedAttr(int32_t aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
-                         nsAttrValue& aParsedValue, bool aNotify);
-
-
-  bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-               nsAString& aResult) const;
-  inline bool HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const;
-
-  inline bool AttrValueIs(int32_t aNameSpaceID, nsIAtom* aName,
-                          const nsAString& aValue,
-                          nsCaseTreatment aCaseSensitive) const;
-  inline bool AttrValueIs(int32_t aNameSpaceID, nsIAtom* aName,
-                          nsIAtom* aValue,
-                          nsCaseTreatment aCaseSensitive) const;
-  virtual int32_t FindAttrValueIn(int32_t aNameSpaceID,
-                                  nsIAtom* aName,
-                                  AttrValuesArray* aValues,
-                                  nsCaseTreatment aCaseSensitive) const override;
-  virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
-                             bool aNotify) override;
-  virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const override;
-  virtual BorrowedAttrInfo GetAttrInfoAt(uint32_t aIndex) const override;
-  virtual uint32_t GetAttrCount() const override;
-  virtual bool IsNodeOfType(uint32_t aFlags) const override;
-
-
-
-
-
-
-  const nsAttrValue* GetClasses() const {
-    if (MayHaveClass()) {
-      return DoGetClasses();
-    }
-    return nullptr;
-  }
-# 685 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  void Describe(nsAString& aOutDescription) const override;
-
-
-
-
-  struct MappedAttributeEntry {
-    nsIAtom** attribute;
-  };
-
-
-
-
-
-
-
-  template<size_t N>
-  static bool
-  FindAttributeDependence(const nsIAtom* aAttribute,
-                          const MappedAttributeEntry* const (&aMaps)[N])
-  {
-    return FindAttributeDependence(aAttribute, aMaps, N);
-  }
-
-  static nsIAtom*** HTMLSVGPropertiesToTraverseAndUnlink();
-
-private:
-  void DescribeAttribute(uint32_t index, nsAString& aOutDescription) const;
-
-  static bool
-  FindAttributeDependence(const nsIAtom* aAttribute,
-                          const MappedAttributeEntry* const aMaps[],
-                          uint32_t aMapCount);
-
-protected:
-  inline bool GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
-                      DOMString& aResult) const
-  {
-    do { } while(0);
-    do { } while(0);
-
-    do { } while (0);
-
-    const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
-    if (val) {
-      val->ToString(aResult);
-      return true;
-    }
-
-    return false;
-  }
-
-public:
-  bool HasAttrs() const { return mAttrsAndChildren.HasAttrs(); }
-
-  inline bool GetAttr(const nsAString& aName, DOMString& aResult) const
-  {
-    do { } while (0);
-
-    const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName);
-    if (val) {
-      val->ToString(aResult);
-      return true;
-    }
-
-    return false;
-  }
-
-  void GetTagName(nsAString& aTagName) const
-  {
-    aTagName = NodeName();
-  }
-  void GetId(nsAString& aId) const
-  {
-    GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
-  }
-  void GetId(DOMString& aId) const
-  {
-    GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
-  }
-  void SetId(const nsAString& aId)
-  {
-    SetAttr(kNameSpaceID_None, nsGkAtoms::id, aId, true);
-  }
-  void GetClassName(nsAString& aClassName)
-  {
-    GetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName);
-  }
-  void GetClassName(DOMString& aClassName)
-  {
-    GetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName);
-  }
-  void SetClassName(const nsAString& aClassName)
-  {
-    SetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName, true);
-  }
-
-  nsDOMTokenList* ClassList();
-  nsDOMAttributeMap* Attributes()
-  {
-    nsDOMSlots* slots = DOMSlots();
-    if (!slots->mAttributeMap) {
-      slots->mAttributeMap = new nsDOMAttributeMap(this);
-    }
-
-    return slots->mAttributeMap;
-  }
-
-  void GetAttributeNames(nsTArray<nsString>& aResult);
-
-  void GetAttribute(const nsAString& aName, nsString& aReturn)
-  {
-    DOMString str;
-    GetAttribute(aName, str);
-    str.ToString(aReturn);
-  }
-
-  void GetAttribute(const nsAString& aName, DOMString& aReturn);
-  void GetAttributeNS(const nsAString& aNamespaceURI,
-                      const nsAString& aLocalName,
-                      nsAString& aReturn);
-  void SetAttribute(const nsAString& aName, const nsAString& aValue,
-                    ErrorResult& aError);
-  void SetAttributeNS(const nsAString& aNamespaceURI,
-                      const nsAString& aLocalName,
-                      const nsAString& aValue,
-                      ErrorResult& aError);
-  void RemoveAttribute(const nsAString& aName,
-                       ErrorResult& aError);
-  void RemoveAttributeNS(const nsAString& aNamespaceURI,
-                         const nsAString& aLocalName,
-                         ErrorResult& aError);
-  bool HasAttribute(const nsAString& aName) const
-  {
-    return InternalGetAttrNameFromQName(aName) != nullptr;
-  }
-  bool HasAttributeNS(const nsAString& aNamespaceURI,
-                      const nsAString& aLocalName) const;
-  bool HasAttributes() const
-  {
-    return HasAttrs();
-  }
-  Element* Closest(const nsAString& aSelector,
-                   ErrorResult& aResult);
-  bool Matches(const nsAString& aSelector,
-               ErrorResult& aError);
-  already_AddRefed<nsIHTMLCollection>
-    GetElementsByTagName(const nsAString& aQualifiedName);
-  already_AddRefed<nsIHTMLCollection>
-    GetElementsByTagNameNS(const nsAString& aNamespaceURI,
-                           const nsAString& aLocalName,
-                           ErrorResult& aError);
-  already_AddRefed<nsIHTMLCollection>
-    GetElementsByClassName(const nsAString& aClassNames);
-
-  CSSPseudoElementType GetPseudoElementType() const {
-    if (!HasProperties()) {
-      return CSSPseudoElementType::NotPseudo;
-    }
-    nsresult rv = NS_OK;
-    auto raw = GetProperty(nsGkAtoms::pseudoProperty, &rv);
-    if (rv == NS_PROPTABLE_PROP_NOT_THERE) {
-      return CSSPseudoElementType::NotPseudo;
-    }
-    return CSSPseudoElementType(reinterpret_cast<uintptr_t>(raw));
-  }
-
-  void SetPseudoElementType(CSSPseudoElementType aPseudo) {
-    static_assert(sizeof(CSSPseudoElementType) <= sizeof(uintptr_t),
-                  "Need to be able to store this in a void*");
-    do { } while (0);
-    SetProperty(nsGkAtoms::pseudoProperty, reinterpret_cast<void*>(aPseudo));
-  }
-
-private:
-
-
-
-
-
-  nsINode* InsertAdjacent(const nsAString& aWhere,
-                          nsINode* aNode,
-                          ErrorResult& aError);
-
-public:
-  Element* InsertAdjacentElement(const nsAString& aWhere,
-                                 Element& aElement,
-                                 ErrorResult& aError);
-
-  void InsertAdjacentText(const nsAString& aWhere,
-                          const nsAString& aData,
-                          ErrorResult& aError);
-
-  void SetPointerCapture(int32_t aPointerId, ErrorResult& aError)
-  {
-    bool activeState = false;
-    if (!nsIPresShell::GetPointerInfo(aPointerId, activeState)) {
-      aError.Throw(NS_ERROR_DOM_INVALID_POINTER_ERR);
-      return;
-    }
-    if (!IsInUncomposedDoc()) {
-      aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
-      return;
-    }
-    if (!activeState) {
-      return;
-    }
-    nsIPresShell::SetPointerCapturingContent(aPointerId, this);
-  }
-  void ReleasePointerCapture(int32_t aPointerId, ErrorResult& aError)
-  {
-    bool activeState = false;
-    if (!nsIPresShell::GetPointerInfo(aPointerId, activeState)) {
-      aError.Throw(NS_ERROR_DOM_INVALID_POINTER_ERR);
-      return;
-    }
-    if (HasPointerCapture(aPointerId)) {
-      nsIPresShell::ReleasePointerCapturingContent(aPointerId);
-    }
-  }
-  bool HasPointerCapture(long aPointerId)
-  {
-    nsIPresShell::PointerCaptureInfo* pointerCaptureInfo =
-      nsIPresShell::GetPointerCaptureInfo(aPointerId);
-    if (pointerCaptureInfo && pointerCaptureInfo->mPendingContent == this) {
-      return true;
-    }
-    return false;
-  }
-  void SetCapture(bool aRetargetToElement)
-  {
-
-
-
-    if (!nsIPresShell::GetCapturingContent()) {
-      nsIPresShell::SetCapturingContent(this, 4 |
-        (aRetargetToElement ? 2 : 0));
-    }
-  }
-
-  void SetCaptureAlways(bool aRetargetToElement)
-  {
-    nsIPresShell::SetCapturingContent(this,
-        4 | 1 |
-        (aRetargetToElement ? 2 : 0));
-  }
-
-  void ReleaseCapture()
-  {
-    if (nsIPresShell::GetCapturingContent() == this) {
-      nsIPresShell::SetCapturingContent(nullptr, 0);
-    }
-  }
-
-  void RequestFullscreen(CallerType aCallerType, ErrorResult& aError);
-  void RequestPointerLock(CallerType aCallerType);
-  Attr* GetAttributeNode(const nsAString& aName);
-  already_AddRefed<Attr> SetAttributeNode(Attr& aNewAttr,
-                                          ErrorResult& aError);
-  already_AddRefed<Attr> RemoveAttributeNode(Attr& aOldAttr,
-                                             ErrorResult& aError);
-  Attr* GetAttributeNodeNS(const nsAString& aNamespaceURI,
-                           const nsAString& aLocalName);
-  already_AddRefed<Attr> SetAttributeNodeNS(Attr& aNewAttr,
-                                            ErrorResult& aError);
-
-  already_AddRefed<DOMRectList> GetClientRects();
-  already_AddRefed<DOMRect> GetBoundingClientRect();
-
-  already_AddRefed<ShadowRoot> CreateShadowRoot(ErrorResult& aError);
-  already_AddRefed<DestinationInsertionPointList> GetDestinationInsertionPoints();
-
-  ShadowRoot *FastGetShadowRoot() const
-  {
-    nsDOMSlots* slots = GetExistingDOMSlots();
-    return slots ? slots->mShadowRoot.get() : nullptr;
-  }
-
-  void ScrollIntoView();
-  void ScrollIntoView(bool aTop);
-  void ScrollIntoView(const ScrollIntoViewOptions &aOptions);
-  void Scroll(double aXScroll, double aYScroll);
-  void Scroll(const ScrollToOptions& aOptions);
-  void ScrollTo(double aXScroll, double aYScroll);
-  void ScrollTo(const ScrollToOptions& aOptions);
-  void ScrollBy(double aXScrollDif, double aYScrollDif);
-  void ScrollBy(const ScrollToOptions& aOptions);
-
-
-
-
-  bool ScrollByNoFlush(int32_t aDx, int32_t aDy);
-  int32_t ScrollTop();
-  void SetScrollTop(int32_t aScrollTop);
-  int32_t ScrollLeft();
-  void SetScrollLeft(int32_t aScrollLeft);
-  int32_t ScrollWidth();
-  int32_t ScrollHeight();
-  void MozScrollSnap();
-  int32_t ClientTop()
-  {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().y);
-  }
-  int32_t ClientLeft()
-  {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().x);
-  }
-  int32_t ClientWidth()
-  {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().width);
-  }
-  int32_t ClientHeight()
-  {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().height);
-  }
-  int32_t ScrollTopMin()
-  {
-    nsIScrollableFrame* sf = GetScrollFrame();
-    return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().y) : 0;
-  }
-  int32_t ScrollTopMax()
-  {
-    nsIScrollableFrame* sf = GetScrollFrame();
-    return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().YMost()) :
-           0;
-  }
-  int32_t ScrollLeftMin()
-  {
-    nsIScrollableFrame* sf = GetScrollFrame();
-    return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().x) : 0;
-  }
-  int32_t ScrollLeftMax()
-  {
-    nsIScrollableFrame* sf = GetScrollFrame();
-    return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().XMost()) :
-           0;
-  }
-
-  void GetGridFragments(nsTArray<RefPtr<Grid>>& aResult);
-
-  already_AddRefed<Animation>
-  Animate(JSContext* aContext,
-          JS::Handle<JSObject*> aKeyframes,
-          const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
-          ErrorResult& aError);
-
-
-
-  static already_AddRefed<Animation>
-  Animate(const Nullable<ElementOrCSSPseudoElement>& aTarget,
-          JSContext* aContext,
-          JS::Handle<JSObject*> aKeyframes,
-          const UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
-          ErrorResult& aError);
-
-
-
-
-  void GetAnimations(const AnimationFilter& filter,
-                     nsTArray<RefPtr<Animation>>& aAnimations);
-  static void GetAnimationsUnsorted(Element* aElement,
-                                    CSSPseudoElementType aPseudoType,
-                                    nsTArray<RefPtr<Animation>>& aAnimations);
-
-  virtual nsresult GetInnerHTML(nsAString& aInnerHTML);
-  virtual void SetInnerHTML(const nsAString& aInnerHTML, ErrorResult& aError);
-  void GetOuterHTML(nsAString& aOuterHTML);
-  void SetOuterHTML(const nsAString& aOuterHTML, ErrorResult& aError);
-  void InsertAdjacentHTML(const nsAString& aPosition, const nsAString& aText,
-                          ErrorResult& aError);
-# 1068 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  nsresult SetEventHandler(nsIAtom* aEventName,
-                           const nsAString& aValue,
-                           bool aDefer = true);
-
-
-
-
-  nsresult LeaveLink(nsPresContext* aPresContext);
-
-  static bool ShouldBlur(nsIContent *aContent);
-# 1089 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  static nsresult DispatchClickEvent(nsPresContext* aPresContext,
-                                     WidgetInputEvent* aSourceEvent,
-                                     nsIContent* aTarget,
-                                     bool aFullDispatch,
-                                     const EventFlags* aFlags,
-                                     nsEventStatus* aStatus);
-# 1103 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  using nsIContent::DispatchEvent;
-  static nsresult DispatchEvent(nsPresContext* aPresContext,
-                                WidgetEvent* aEvent,
-                                nsIContent* aTarget,
-                                bool aFullDispatch,
-                                nsEventStatus* aStatus);
-# 1117 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  nsIFrame* GetPrimaryFrame(FlushType aType);
-
-  nsIFrame* GetPrimaryFrame() const { return nsIContent::GetPrimaryFrame(); }
-
-  const nsAttrValue* GetParsedAttr(nsIAtom* aAttr) const
-  {
-    return mAttrsAndChildren.GetAttr(aAttr);
-  }
-
-  const nsAttrValue* GetParsedAttr(nsIAtom* aAttr, int32_t aNameSpaceID) const
-  {
-    return mAttrsAndChildren.GetAttr(aAttr, aNameSpaceID);
-  }
-
-
-
-
-
-
-  nsDOMAttributeMap *GetAttributeMap()
-  {
-    nsDOMSlots *slots = GetExistingDOMSlots();
-
-    return slots ? slots->mAttributeMap.get() : nullptr;
-  }
-
-  virtual void RecompileScriptEventListeners()
-  {
-  }
-# 1155 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual BorrowedAttrInfo GetAttrInfo(int32_t aNamespaceID, nsIAtom* aName) const;
-# 1166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual void NodeInfoChanged(nsIDocument* aOldDoc) {}
-
-
-
-
-
-
-  static void ParseCORSValue(const nsAString& aValue, nsAttrValue& aResult);
-
-
-
-
-  static CORSMode StringToCORSMode(const nsAString& aValue);
-
-
-
-
-
-  static CORSMode AttrValueToCORSMode(const nsAttrValue* aValue);
-
-  virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) final override;
-
-  nsINode* GetScopeChainParent() const override;
-
-
-
-
-  nsIEditor* GetEditorInternal();
-# 1203 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  bool GetBoolAttr(nsIAtom* aAttr) const
-  {
-    return HasAttr(kNameSpaceID_None, aAttr);
-  }
-# 1216 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  nsresult SetBoolAttr(nsIAtom* aAttr, bool aValue);
-# 1227 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  void GetEnumAttr(nsIAtom* aAttr,
-                   const char* aDefault,
-                   nsAString& aResult) const;
-# 1245 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  void GetEnumAttr(nsIAtom* aAttr,
-                   const char* aDefaultMissing,
-                   const char* aDefaultInvalid,
-                   nsAString& aResult) const;
-
-
-
-
-  void UnsetAttr(nsIAtom* aAttr, ErrorResult& aError)
-  {
-    aError = UnsetAttr(kNameSpaceID_None, aAttr, true);
-  }
-
-
-
-
-  void SetAttr(nsIAtom* aAttr, const nsAString& aValue, ErrorResult& aError)
-  {
-    aError = SetAttr(kNameSpaceID_None, aAttr, aValue, true);
-  }
-
-
-
-
-
-
-  void SetOrRemoveNullableStringAttr(nsIAtom* aName, const nsAString& aValue,
-                                     ErrorResult& aError);
-# 1288 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  float FontSizeInflation();
-
-  net::ReferrerPolicy GetReferrerPolicyAsEnum();
-
-
-
-
-
-
-  already_AddRefed<nsDOMStringMap> Dataset();
-
-
-  void ClearDataset();
-
-  void RegisterIntersectionObserver(DOMIntersectionObserver* aObserver);
-  void UnregisterIntersectionObserver(DOMIntersectionObserver* aObserver);
-  bool UpdateIntersectionObservation(DOMIntersectionObserver* aObserver, int32_t threshold);
-
-protected:
-
-
-
-
-  static const bool kFireMutationEvent = true;
-  static const bool kDontFireMutationEvent = false;
-  static const bool kNotifyDocumentObservers = true;
-  static const bool kDontNotifyDocumentObservers = false;
-  static const bool kCallAfterSetAttr = true;
-  static const bool kDontCallAfterSetAttr = false;
-# 1347 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  nsresult SetAttrAndNotify(int32_t aNamespaceID,
-                            nsIAtom* aName,
-                            nsIAtom* aPrefix,
-                            const nsAttrValue& aOldValue,
-                            nsAttrValue& aParsedValue,
-                            uint8_t aModType,
-                            bool aFireMutation,
-                            bool aNotify,
-                            bool aCallAfterSetAttr,
-                            nsIDocument* aComposedDocument,
-                            const mozAutoDocUpdate& aGuard);
-# 1368 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  void Scroll(const CSSIntPoint& aScroll, const ScrollOptions& aOptions);
-# 1381 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual bool ParseAttribute(int32_t aNamespaceID,
-                                nsIAtom* aAttribute,
-                                const nsAString& aValue,
-                                nsAttrValue& aResult);
-# 1399 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual bool SetMappedAttribute(nsIDocument* aDocument,
-                                    nsIAtom* aName,
-                                    nsAttrValue& aValue,
-                                    nsresult* aRetval);
-# 1420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsIAtom* aName,
-                                 const nsAttrValueOrString* aValue,
-                                 bool aNotify)
-  {
-    return NS_OK;
-  }
-# 1441 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
-                                const nsAttrValue* aValue, bool aNotify)
-  {
-    return NS_OK;
-  }
-
-
-
-
-
-  virtual EventListenerManager*
-    GetEventListenerManagerForAttr(nsIAtom* aAttrName, bool* aDefer);
-
-
-
-
-
-
-  const nsAttrName*
-  InternalGetAttrNameFromQName(const nsAString& aStr,
-                               nsAutoString* aNameToUse = nullptr) const;
-
-  nsIFrame* GetStyledFrame();
-
-  virtual Element* GetNameSpaceElement() override
-  {
-    return this;
-  }
-
-  Attr* GetAttributeNodeNSInternal(const nsAString& aNamespaceURI,
-                                   const nsAString& aLocalName);
-
-  inline void RegisterActivityObserver();
-  inline void UnregisterActivityObserver();
-
-
-
-
-  void AddToIdTable(nsIAtom* aId);
-  void RemoveFromIdTable();
-# 1495 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  bool CheckHandleEventForLinksPrecondition(EventChainVisitor& aVisitor,
-                                            nsIURI** aURI) const;
-
-
-
-
-  nsresult GetEventTargetParentForLinks(EventChainPreVisitor& aVisitor);
-
-
-
-
-  nsresult PostHandleEventForLinks(EventChainPostVisitor& aVisitor);
-# 1518 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom/Element.h"
-  virtual void GetLinkTarget(nsAString& aTarget);
-
-  nsDOMTokenList* GetTokenList(nsIAtom* aAtom,
-                               const DOMTokenListSupportedTokenArray aSupportedTokens = nullptr);
-
-  nsDataHashtable<nsRefPtrHashKey<DOMIntersectionObserver>, int32_t>*
-    RegisteredIntersectionObservers();
-
-private:
-
-
-
-
-  const nsAttrValue* DoGetClasses() const;
-
-
-
-
-
-  nsRect GetClientAreaRect();
-
-  nsIScrollableFrame* GetScrollFrame(nsIFrame **aStyledFrame = nullptr,
-                                     bool aFlushLayout = true);
-
-
-  EventStates mState;
-
-
-  mozilla::ServoCell<ServoNodeData*> mServoData;
-
-};
-
-class RemoveFromBindingManagerRunnable : public mozilla::Runnable
-{
-public:
-  RemoveFromBindingManagerRunnable(nsBindingManager* aManager,
-                                   nsIContent* aContent,
-                                   nsIDocument* aDoc);
-
-  virtual nsresult Run() override;
-private:
-  virtual ~RemoveFromBindingManagerRunnable();
-  RefPtr<nsBindingManager> mManager;
-  RefPtr<nsIContent> mContent;
-  nsCOMPtr<nsIDocument> mDoc;
-};
-
-class DestinationInsertionPointList : public nsINodeList
-{
-public:
-  explicit DestinationInsertionPointList(Element* aElement);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; virtual void DeleteCycleCollectable(void); typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  class cycleCollection : public nsXPCOMCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsXPCOMCycleCollectionParticipant(aSkip) {} private: public: virtual nsresult TraverseNative(void *p, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "DestinationInsertionPointList"; }; virtual void DeleteCycleCollectable(void *p) override { DowncastCCParticipant<DestinationInsertionPointList>(p)->DeleteCycleCollectable(); } static DestinationInsertionPointList* Downcast(nsISupports* s) { return static_cast<DestinationInsertionPointList*>(static_cast<DestinationInsertionPointList*>(s)); } static nsISupports* Upcast(DestinationInsertionPointList *p) { return static_cast<nsISupports*>(static_cast<DestinationInsertionPointList*>(p)); } template<typename T> friend nsISupports* ToSupports(T* p, cycleCollection* dummy); virtual void Unlink(void *p) override; virtual void Trace(void *p, const TraceCallbacks &cb, void *closure) override; static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant() { return &DestinationInsertionPointList::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-
-  virtual nsresult Item(uint32_t index, nsIDOMNode * *_retval) override; virtual nsresult GetLength(uint32_t *aLength) override;
-
-
-  virtual nsIContent* Item(uint32_t aIndex) override;
-  virtual int32_t IndexOf(nsIContent* aContent) override;
-  virtual nsINode* GetParentObject() override { return mParent; }
-  virtual uint32_t Length() const;
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
-protected:
-  virtual ~DestinationInsertionPointList();
-
-  RefPtr<Element> mParent;
-  nsCOMArray<nsIContent> mDestinationPoints;
-};
-
-template<typename T> struct Element::COMTypeInfo<Element, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID Element::COMTypeInfo<Element, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc67ed254, 0xfd3b, 0x4b10, { 0x96, 0xa2, 0xc5, 0x8b, 0x7b, 0x64, 0x97, 0xd1 } };
-
-inline bool
-Element::HasAttr(int32_t aNameSpaceID, nsIAtom* aName) const
-{
-  do { } while(0);
-  do { } while(0);
-
-
-  return mAttrsAndChildren.IndexOfAttr(aName, aNameSpaceID) >= 0;
-}
-
-inline bool
-Element::AttrValueIs(int32_t aNameSpaceID,
-                     nsIAtom* aName,
-                     const nsAString& aValue,
-                     nsCaseTreatment aCaseSensitive) const
-{
-  do { } while(0);
-  do { } while(0);
-
-  const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
-  return val && val->Equals(aValue, aCaseSensitive);
-}
-
-inline bool
-Element::AttrValueIs(int32_t aNameSpaceID,
-                     nsIAtom* aName,
-                     nsIAtom* aValue,
-                     nsCaseTreatment aCaseSensitive) const
-{
-  do { } while(0);
-  do { } while(0);
-  do { } while(0);
-
-  const nsAttrValue* val = mAttrsAndChildren.GetAttr(aName, aNameSpaceID);
-  return val && val->Equals(aValue, aCaseSensitive);
-}
-
-}
-}
-
-inline mozilla::dom::Element* nsINode::AsElement()
-{
-  do { } while (0);
-  return static_cast<mozilla::dom::Element*>(this);
-}
-
-inline const mozilla::dom::Element* nsINode::AsElement() const
-{
-  do { } while (0);
-  return static_cast<const mozilla::dom::Element*>(this);
-}
-
-inline void nsINode::UnsetRestyleFlagsIfGecko()
-{
-  if (IsElement() && !AsElement()->IsStyledByServo()) {
-    UnsetFlags(ELEMENT_ALL_RESTYLE_FLAGS);
-  }
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AnimationTarget.h" 1
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/AnimationTarget.h"
-namespace mozilla {
-
-namespace dom {
-class Element;
-}
-
-struct OwningAnimationTarget
-{
-  OwningAnimationTarget(dom::Element* aElement, CSSPseudoElementType aType)
-    : mElement(aElement), mPseudoType(aType) { }
-
-  explicit OwningAnimationTarget(dom::Element* aElement)
-    : mElement(aElement) { }
-
-  bool operator==(const OwningAnimationTarget& aOther) const
-  {
-     return mElement == aOther.mElement &&
-            mPseudoType == aOther.mPseudoType;
-  }
-
-
-
-  RefPtr<dom::Element> mElement;
-  CSSPseudoElementType mPseudoType = CSSPseudoElementType::NotPseudo;
-};
-
-struct NonOwningAnimationTarget
-{
-  NonOwningAnimationTarget() = default;
-
-  NonOwningAnimationTarget(dom::Element* aElement, CSSPseudoElementType aType)
-    : mElement(aElement), mPseudoType(aType) { }
-
-  explicit NonOwningAnimationTarget(const OwningAnimationTarget& aOther)
-    : mElement(aOther.mElement), mPseudoType(aOther.mPseudoType) { }
-
-  bool operator==(const NonOwningAnimationTarget& aOther) const
-  {
-    return mElement == aOther.mElement &&
-           mPseudoType == aOther.mPseudoType;
-  }
-
-
-
-  dom::Element* mElement = nullptr;
-  CSSPseudoElementType mPseudoType = CSSPseudoElementType::NotPseudo;
-};
-
-
-
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            Maybe<OwningAnimationTarget>& aTarget,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  if (aTarget) {
-    ImplCycleCollectionTraverse(aCallback, aTarget->mElement, aName, aFlags);
-  }
-}
-
-inline void
-ImplCycleCollectionUnlink(Maybe<OwningAnimationTarget>& aTarget)
-{
-  if (aTarget) {
-    ImplCycleCollectionUnlink(aTarget->mElement);
-  }
-}
-
-}
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PseudoElementHashEntry.h" 2
-
-
-
-namespace mozilla {
-
-
-class PseudoElementHashEntry : public PLDHashEntryHdr
-{
-public:
-  typedef NonOwningAnimationTarget KeyType;
-  typedef const NonOwningAnimationTarget* KeyTypePointer;
-
-  explicit PseudoElementHashEntry(KeyTypePointer aKey)
-    : mElement(aKey->mElement)
-    , mPseudoType(aKey->mPseudoType) { }
-  explicit PseudoElementHashEntry(const PseudoElementHashEntry& aCopy)=default;
-
-  ~PseudoElementHashEntry() = default;
-
-  KeyType GetKey() const { return { mElement, mPseudoType }; }
-  bool KeyEquals(KeyTypePointer aKey) const
-  {
-    return mElement == aKey->mElement &&
-           mPseudoType == aKey->mPseudoType;
-  }
-
-  static KeyTypePointer KeyToPointer(KeyType& aKey) { return &aKey; }
-  static PLDHashNumber HashKey(KeyTypePointer aKey)
-  {
-    if (!aKey)
-      return 0;
-
-
-
-
-    return mozilla::HashGeneric(aKey->mElement,
-                                static_cast<uint8_t>(aKey->mPseudoType));
-  }
-  enum { ALLOW_MEMMOVE = true };
-
-  RefPtr<dom::Element> mElement;
-  CSSPseudoElementType mPseudoType;
-};
-
-}
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 2
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
-struct RuleProcessorData;
-struct ElementRuleProcessorData;
-struct PseudoElementRuleProcessorData;
-struct AnonBoxRuleProcessorData;
-
-struct XULTreeRuleProcessorData;
-
-struct StateRuleProcessorData;
-struct PseudoElementStateRuleProcessorData;
-struct AttributeRuleProcessorData;
-class nsPresContext;
-# 46 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
-class nsIStyleRuleProcessor : public nsISupports {
-public:
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-
-  typedef bool (* EnumFunc)(nsIStyleRuleProcessor*, void*);
-
-
-
-
-
-
-
-  virtual void RulesMatching(ElementRuleProcessorData* aData) = 0;
-
-
-
-
-
-  virtual void RulesMatching(PseudoElementRuleProcessorData* aData) = 0;
-
-
-
-
-  virtual void RulesMatching(AnonBoxRuleProcessorData* aData) = 0;
-
-
-
-
-
-
-  virtual void RulesMatching(XULTreeRuleProcessorData* aData) = 0;
-
-
-
-
-
-
-
-  virtual bool
-    HasDocumentStateDependentStyle(StateRuleProcessorData* aData) = 0;
-# 97 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
-  virtual nsRestyleHint
-    HasStateDependentStyle(StateRuleProcessorData* aData) = 0;
-  virtual nsRestyleHint
-    HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData) = 0;
-# 118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIStyleRuleProcessor.h"
-  virtual nsRestyleHint HasAttributeDependentStyle(
-      AttributeRuleProcessorData* aData,
-      mozilla::RestyleHintData& aRestyleHintDataResult) = 0;
-
-
-
-
-
-
-  virtual bool MediumFeaturesChanged(nsPresContext* aPresContext) = 0;
-
-
-
-
-
-  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const = 0;
-  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const = 0;
-};
-
-template<typename T> struct nsIStyleRuleProcessor::COMTypeInfo<nsIStyleRuleProcessor, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIStyleRuleProcessor::COMTypeInfo<nsIStyleRuleProcessor, T>::kIID __attribute__ ((visibility ("hidden"))) = { 0xc1d6001e, 0x4fcb, 0x4c40, {0xbc, 0xe1, 0x5e, 0xba, 0x80, 0xbf, 0xd8, 0xf3} };
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h" 2
-
-
-class nsCSSPropertyIDSet;
-class nsIAtom;
-class nsIFrame;
-class nsIStyleRule;
-class nsPresContext;
-class nsStyleContext;
-struct RawServoAnimationValueMap;
-typedef RawServoAnimationValueMap const* RawServoAnimationValueMapBorrowed;
-
-namespace mozilla {
-
-class EffectSet;
-class RestyleTracker;
-class StyleAnimationValue;
-struct AnimationPerformanceWarning;
-struct AnimationProperty;
-struct NonOwningAnimationTarget;
-
-namespace dom {
-class Animation;
-class Element;
-}
-
-class EffectCompositor
-{
-public:
-  explicit EffectCompositor(nsPresContext* aPresContext)
-    : mPresContext(aPresContext)
-  {
-    for (size_t i = 0; i < kCascadeLevelCount; i++) {
-      CascadeLevel cascadeLevel = CascadeLevel(i);
-      mRuleProcessors[cascadeLevel] =
-        new AnimationStyleRuleProcessor(this, cascadeLevel);
-    }
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<EffectCompositor>::value, "Reference-counted class " "EffectCompositor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
-  void DeleteCycleCollectable(void) { delete this; } class cycleCollection : public nsCycleCollectionParticipant { public: constexpr explicit cycleCollection (bool aSkip = false) : nsCycleCollectionParticipant(aSkip) {} private: public: virtual void Root(void *n) override; virtual void Unlink(void *n) override; virtual void Unroot(void *n) override; virtual nsresult TraverseNative(void *n, nsCycleCollectionTraversalCallback &cb) override; virtual const char* ClassName() override { return "EffectCompositor"; }; virtual void DeleteCycleCollectable(void *n) override { DowncastCCParticipant<EffectCompositor>(n)->DeleteCycleCollectable(); } static EffectCompositor* Downcast(void* s) { return DowncastCCParticipant<EffectCompositor>(s); } static void* Upcast(EffectCompositor *p) { return static_cast<void*>(p); } static constexpr nsCycleCollectionParticipant* GetParticipant() { return &EffectCompositor::_cycleCollectorGlobal; } }; static cycleCollection _cycleCollectorGlobal;
-
-  void Disconnect() {
-    mPresContext = nullptr;
-  }
-
-
-  enum class CascadeLevel : uint32_t {
-
-
-    Animations = 0,
-
-    Transitions = 1
-  };
-
-
-  static const size_t kCascadeLevelCount =
-    static_cast<size_t>(CascadeLevel::Transitions) + 1;
-
-
-  nsPresContext* PresContext() const { return mPresContext; }
-
-  enum class RestyleType {
-
-
-
-    Throttled,
-
-    Standard,
-
-
-
-
-
-
-
-    Layer
-  };
-
-
-
-
-
-  void RequestRestyle(dom::Element* aElement,
-                      CSSPseudoElementType aPseudoType,
-                      RestyleType aRestyleType,
-                      CascadeLevel aCascadeLevel);
-
-
-
-
-
-  void PostRestyleForAnimation(dom::Element* aElement,
-                               CSSPseudoElementType aPseudoType,
-                               CascadeLevel aCascadeLevel);
-
-
-
-
-  void PostRestyleForThrottledAnimations();
-
-
-
-
-
-  template<typename StyleType>
-  void UpdateEffectProperties(StyleType&& aStyleType,
-                              dom::Element* aElement,
-                              CSSPseudoElementType aPseudoType);
-# 139 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
-  void MaybeUpdateAnimationRule(dom::Element* aElement,
-                                CSSPseudoElementType aPseudoType,
-                                CascadeLevel aCascadeLevel,
-                                nsStyleContext *aStyleContext);
-# 152 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
-  nsIStyleRule* GetAnimationRule(dom::Element* aElement,
-                                 CSSPseudoElementType aPseudoType,
-                                 CascadeLevel aCascadeLevel,
-                                 nsStyleContext* aStyleContext);
-
-
-
-
-
-
-  bool GetServoAnimationRule(
-    const dom::Element* aElement,
-    CSSPseudoElementType aPseudoType,
-    CascadeLevel aCascadeLevel,
-    RawServoAnimationValueMapBorrowed aAnimationValues);
-
-  bool HasPendingStyleUpdates() const;
-  bool HasThrottledStyleUpdates() const;
-
-
-
-
-  void AddStyleUpdatesTo(RestyleTracker& aTracker);
-
-  nsIStyleRuleProcessor* RuleProcessor(CascadeLevel aCascadeLevel) const
-  {
-    return mRuleProcessors[aCascadeLevel];
-  }
-
-  static bool HasAnimationsForCompositor(const nsIFrame* aFrame,
-                                         nsCSSPropertyID aProperty);
-
-  static nsTArray<RefPtr<dom::Animation>>
-  GetAnimationsForCompositor(const nsIFrame* aFrame,
-                             nsCSSPropertyID aProperty);
-
-  static void ClearIsRunningOnCompositor(const nsIFrame* aFrame,
-                                         nsCSSPropertyID aProperty);
-# 200 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
-  static void
-  MaybeUpdateCascadeResults(dom::Element* aElement,
-                            CSSPseudoElementType aPseudoType,
-                            nsStyleContext* aStyleContext);
-
-
-
-
-
-  static void
-  MaybeUpdateCascadeResults(dom::Element* aElement,
-                            CSSPseudoElementType aPseudoType);
-
-
-
-
-
-
-
-  static void
-  UpdateCascadeResults(dom::Element* aElement,
-                       CSSPseudoElementType aPseudoType,
-                       nsStyleContext* aStyleContext);
-# 233 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/EffectCompositor.h"
-  static Maybe<NonOwningAnimationTarget>
-  GetAnimationElementAndPseudoForFrame(const nsIFrame* aFrame);
-
-
-
-  static void SetPerformanceWarning(
-    const nsIFrame* aFrame,
-    nsCSSPropertyID aProperty,
-    const AnimationPerformanceWarning& aWarning);
-
-
-
-
-
-  bool PreTraverse();
-
-
-  bool PreTraverse(dom::Element* aElement, nsIAtom* aPseudoTagOrNull);
-
-private:
-  ~EffectCompositor() = default;
-
-
-
-  static void ComposeAnimationRule(dom::Element* aElement,
-                                   CSSPseudoElementType aPseudoType,
-                                   CascadeLevel aCascadeLevel);
-
-  static dom::Element* GetElementToRestyle(dom::Element* aElement,
-                                           CSSPseudoElementType
-                                             aPseudoType);
-
-
-
-
-  static void
-  GetOverriddenProperties(nsStyleContext* aStyleContext,
-                          EffectSet& aEffectSet,
-                          nsCSSPropertyIDSet& aPropertiesOverridden);
-
-  static void
-  UpdateCascadeResults(EffectSet& aEffectSet,
-                       dom::Element* aElement,
-                       CSSPseudoElementType aPseudoType,
-                       nsStyleContext* aStyleContext);
-
-  static nsPresContext* GetPresContext(dom::Element* aElement);
-
-  nsPresContext* mPresContext;
-
-
-
-
-
-
-  EnumeratedArray<CascadeLevel, CascadeLevel(kCascadeLevelCount),
-                  nsDataHashtable<PseudoElementHashEntry, bool>>
-                    mElementsToRestyle;
-
-  class AnimationStyleRuleProcessor final : public nsIStyleRuleProcessor
-  {
-  public:
-    AnimationStyleRuleProcessor(EffectCompositor* aCompositor,
-                                CascadeLevel aCascadeLevel)
-      : mCompositor(aCompositor)
-      , mCascadeLevel(aCascadeLevel)
-    {
-      do { } while (0);
-    }
-
-    public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-
-    nsRestyleHint HasStateDependentStyle(
-                        StateRuleProcessorData* aData) override;
-    nsRestyleHint HasStateDependentStyle(
-                        PseudoElementStateRuleProcessorData* aData) override;
-    bool HasDocumentStateDependentStyle(StateRuleProcessorData* aData) override;
-    nsRestyleHint HasAttributeDependentStyle(
-                        AttributeRuleProcessorData* aData,
-                        RestyleHintData& aRestyleHintDataResult) override;
-    bool MediumFeaturesChanged(nsPresContext* aPresContext) override;
-    void RulesMatching(ElementRuleProcessorData* aData) override;
-    void RulesMatching(PseudoElementRuleProcessorData* aData) override;
-    void RulesMatching(AnonBoxRuleProcessorData* aData) override;
-
-    void RulesMatching(XULTreeRuleProcessorData* aData) override;
-
-    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf)
-      const override;
-    size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf)
-      const override;
-
-  private:
-    ~AnimationStyleRuleProcessor() = default;
-
-    EffectCompositor* mCompositor;
-    CascadeLevel mCascadeLevel;
-  };
-
-  EnumeratedArray<CascadeLevel, CascadeLevel(kCascadeLevelCount),
-                  OwningNonNull<AnimationStyleRuleProcessor>>
-                    mRuleProcessors;
-};
-
-}
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSMILKeySpline.h" 1
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsSMILKeySpline.h"
-class nsSMILKeySpline
-{
-public:
-  nsSMILKeySpline() { }
-
-
-
-
-
-
-
-  nsSMILKeySpline(double aX1, double aY1,
-                  double aX2, double aY2)
-  {
-    Init(aX1, aY1, aX2, aY2);
-  }
-
-  double X1() const { return mX1; }
-  double Y1() const { return mY1; }
-  double X2() const { return mX2; }
-  double Y2() const { return mY2; }
-
-  void Init(double aX1, double aY1,
-            double aX2, double aY2);
-
-
-
-
-
-
-
-  double GetSplineValue(double aX) const;
-
-  void GetSplineDerivativeValues(double aX, double& aDX, double& aDY) const;
-
-  bool operator==(const nsSMILKeySpline& aOther) const {
-    return mX1 == aOther.mX1 &&
-           mY1 == aOther.mY1 &&
-           mX2 == aOther.mX2 &&
-           mY2 == aOther.mY2;
-  }
-  bool operator!=(const nsSMILKeySpline& aOther) const {
-    return !(*this == aOther);
-  }
-  int32_t Compare(const nsSMILKeySpline& aRhs) const {
-    if (mX1 != aRhs.mX1) return mX1 < aRhs.mX1 ? -1 : 1;
-    if (mY1 != aRhs.mY1) return mY1 < aRhs.mY1 ? -1 : 1;
-    if (mX2 != aRhs.mX2) return mX2 < aRhs.mX2 ? -1 : 1;
-    if (mY2 != aRhs.mY2) return mY2 < aRhs.mY2 ? -1 : 1;
-    return 0;
-  }
-
-private:
-  void
-  CalcSampleValues();
-
-
-
-
-  static double
-  CalcBezier(double aT, double aA1, double aA2);
-
-
-
-
-  static double
-  GetSlope(double aT, double aA1, double aA2);
-
-  double
-  GetTForX(double aX) const;
-
-  double
-  NewtonRaphsonIterate(double aX, double aGuessT) const;
-
-  double
-  BinarySubdivide(double aX, double aA, double aB) const;
-
-  static double
-  A(double aA1, double aA2)
-  {
-    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
-  }
-
-  static double
-  B(double aA1, double aA2)
-  {
-    return 3.0 * aA2 - 6.0 * aA1;
-  }
-
-  static double
-  C(double aA1)
-  {
-    return 3.0 * aA1;
-  }
-
-  double mX1;
-  double mY1;
-  double mX2;
-  double mY2;
-
-  enum { kSplineTableSize = 11 };
-  double mSampleValues[kSplineTableSize];
-
-  static const double kSampleStepSize;
-};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
-namespace mozilla {
-namespace css {
-class ErrorReporter;
-}
-}
-
-
-
-
-
-
-
-enum nsCSSTokenType {
-
-
-
-  eCSSToken_Whitespace,
-
-  eCSSToken_Comment,
-
-
-
-
-
-
-  eCSSToken_Ident,
-  eCSSToken_Function,
-  eCSSToken_AtKeyword,
-  eCSSToken_ID,
-  eCSSToken_Hash,
-# 54 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
-  eCSSToken_Number,
-  eCSSToken_Dimension,
-  eCSSToken_Percentage,
-
-
-
-
-
-
-  eCSSToken_String,
-  eCSSToken_Bad_String,
-  eCSSToken_URL,
-  eCSSToken_Bad_URL,
-
-
-  eCSSToken_Symbol,
-
-
-
-
-
-  eCSSToken_Includes,
-  eCSSToken_Dashmatch,
-  eCSSToken_Beginsmatch,
-  eCSSToken_Endsmatch,
-  eCSSToken_Containsmatch,
-# 89 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
-  eCSSToken_URange,
-
-
-
-
-
-
-
-  eCSSToken_HTMLComment,
-};
-# 108 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
-enum nsCSSTokenSerializationType {
-  eCSSTokenSerialization_Nothing,
-  eCSSTokenSerialization_Whitespace,
-  eCSSTokenSerialization_AtKeyword_or_Hash,
-  eCSSTokenSerialization_Number,
-  eCSSTokenSerialization_Dimension,
-  eCSSTokenSerialization_Percentage,
-  eCSSTokenSerialization_URange,
-  eCSSTokenSerialization_URL_or_BadURL,
-  eCSSTokenSerialization_Function,
-  eCSSTokenSerialization_Ident,
-  eCSSTokenSerialization_CDC,
-  eCSSTokenSerialization_DashMatch,
-  eCSSTokenSerialization_ContainsMatch,
-  eCSSTokenSerialization_Symbol_Hash,
-  eCSSTokenSerialization_Symbol_At,
-  eCSSTokenSerialization_Symbol_Dot_or_Plus,
-  eCSSTokenSerialization_Symbol_Minus,
-  eCSSTokenSerialization_Symbol_OpenParen,
-  eCSSTokenSerialization_Symbol_Question,
-  eCSSTokenSerialization_Symbol_Assorted,
-  eCSSTokenSerialization_Symbol_Equals,
-  eCSSTokenSerialization_Symbol_Bar,
-  eCSSTokenSerialization_Symbol_Slash,
-  eCSSTokenSerialization_Symbol_Asterisk,
-  eCSSTokenSerialization_Other
-};
-
-
-
-
-struct nsCSSToken {
-  nsAutoString mIdent;
-  float mNumber;
-  int32_t mInteger;
-  int32_t mInteger2;
-  nsCSSTokenType mType;
-  char16_t mSymbol;
-  bool mIntegerValid;
-  bool mHasSign;
-
-  nsCSSToken()
-    : mNumber(0), mInteger(0), mInteger2(0), mType(eCSSToken_Whitespace),
-      mSymbol('\0'), mIntegerValid(false), mHasSign(false)
-  {}
-
-  bool IsSymbol(char16_t aSymbol) const {
-    return mType == eCSSToken_Symbol && mSymbol == aSymbol;
-  }
-
-  void AppendToString(nsString& aBuffer) const;
-};
-
-
-class nsCSSScannerPosition {
-  friend class nsCSSScanner;
-public:
-  nsCSSScannerPosition() : mInitialized(false) { }
-
-  uint32_t LineNumber() {
-    do { } while (0);
-    return mLineNumber;
-  }
-
-  uint32_t LineOffset() {
-    do { } while (0);
-    return mLineOffset;
-  }
-
-private:
-  uint32_t mOffset;
-  uint32_t mLineNumber;
-  uint32_t mLineOffset;
-  uint32_t mTokenLineNumber;
-  uint32_t mTokenLineOffset;
-  uint32_t mTokenOffset;
-  bool mInitialized;
-};
-
-enum nsCSSScannerExclude {
-
-  eCSSScannerExclude_None,
-
-  eCSSScannerExclude_Comments,
-
-  eCSSScannerExclude_WhitespaceAndComments
-};
-
-
-
-
-class nsCSSScanner {
-  public:
-
-
-
-
-  nsCSSScanner(const nsAString& aBuffer, uint32_t aLineNumber);
-  ~nsCSSScanner();
-
-  void SetErrorReporter(mozilla::css::ErrorReporter* aReporter) {
-    mReporter = aReporter;
-  }
-
-
-  void ClearSeenBadToken() { mSeenBadToken = false; }
-  bool SeenBadToken() const { return mSeenBadToken; }
-
-
-  void ClearSeenVariableReference() { mSeenVariableReference = false; }
-  bool SeenVariableReference() const { return mSeenVariableReference; }
-
-
-
-  uint32_t GetLineNumber() const { return mTokenLineNumber; }
-
-
-
-  uint32_t GetColumnNumber() const
-  { return mTokenOffset - mTokenLineOffset; }
-
-  uint32_t GetTokenOffset() const
-  { return mTokenOffset; }
-
-  uint32_t GetTokenEndOffset() const
-  { return mOffset; }
-
-
-
-  nsDependentSubstring GetCurrentLine() const;
-
-
-
-
-  bool Next(nsCSSToken& aTokenResult, nsCSSScannerExclude aSkip);
-
-
-
-
-
-
-  void NextURL(nsCSSToken& aTokenResult);
-# 258 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSScanner.h"
-  void Backup(uint32_t n);
-
-
-  void StartRecording();
-
-
-  void StopRecording();
-
-
-
-  void StopRecording(nsString& aBuffer);
-
-
-  uint32_t RecordingLength() const;
-
-
-
-
-
-
-  void SavePosition(nsCSSScannerPosition& aState);
-
-
-  void RestoreSavedPosition(const nsCSSScannerPosition& aState);
-
-  enum EOFCharacters {
-    eEOFCharacters_None = 0x0000,
-
-
-    eEOFCharacters_DropBackslash = 0x0001,
-
-
-    eEOFCharacters_ReplacementChar = 0x0002,
-
-
-    eEOFCharacters_Asterisk = 0x0004,
-    eEOFCharacters_Slash = 0x0008,
-
-
-    eEOFCharacters_DoubleQuote = 0x0010,
-
-
-    eEOFCharacters_SingleQuote = 0x0020,
-
-
-    eEOFCharacters_CloseParen = 0x0040,
-  };
-
-
-
-
-
-  static void AppendImpliedEOFCharacters(EOFCharacters aEOFCharacters,
-                                         nsAString& aString);
-
-  EOFCharacters GetEOFCharacters() const {
-
-
-
-    return mEOFCharacters;
-  }
-
-
-
-
-
-protected:
-  int32_t Peek(uint32_t n = 0);
-  void Advance(uint32_t n = 1);
-  void AdvanceLine();
-
-  void SkipWhitespace();
-  void SkipComment();
-
-  bool GatherEscape(nsString& aOutput, bool aInString);
-  bool GatherText(uint8_t aClass, nsString& aIdent);
-
-  bool ScanIdent(nsCSSToken& aResult);
-  bool ScanAtKeyword(nsCSSToken& aResult);
-  bool ScanHash(nsCSSToken& aResult);
-  bool ScanNumber(nsCSSToken& aResult);
-  bool ScanString(nsCSSToken& aResult);
-  bool ScanURange(nsCSSToken& aResult);
-
-  void SetEOFCharacters(uint32_t aEOFCharacters);
-  void AddEOFCharacters(uint32_t aEOFCharacters);
-
-  const char16_t *mBuffer;
-  uint32_t mOffset;
-  uint32_t mCount;
-
-  uint32_t mLineNumber;
-  uint32_t mLineOffset;
-
-  uint32_t mTokenLineNumber;
-  uint32_t mTokenLineOffset;
-  uint32_t mTokenOffset;
-
-  uint32_t mRecordStartOffset;
-  EOFCharacters mEOFCharacters;
-
-  mozilla::css::ErrorReporter *mReporter;
-
-  bool mRecording;
-  bool mSeenBadToken;
-  bool mSeenVariableReference;
-};
-
-
-
-struct nsCSSGridTemplateAreaToken {
-  nsAutoString mName;
-  bool isTrash;
-};
-
-
-class nsCSSGridTemplateAreaScanner {
-public:
-  explicit nsCSSGridTemplateAreaScanner(const nsAString& aBuffer);
-
-
-
-  bool Next(nsCSSGridTemplateAreaToken& aTokenResult);
-
-private:
-  const char16_t *mBuffer;
-  uint32_t mOffset;
-  uint32_t mCount;
-};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h" 2
-
-
-
-namespace mozilla {
-
-class CSSVariableResolver;
-
-class CSSVariableValues
-{
-public:
-  CSSVariableValues();
-  CSSVariableValues(const CSSVariableValues& aOther);
-
-
-
-  CSSVariableValues& operator=(const CSSVariableValues& aOther);
-
-  bool operator==(const CSSVariableValues& aOther) const;
-  bool operator!=(const CSSVariableValues& aOther) const
-    { return !(*this == aOther); }
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
-  bool Get(const nsAString& aName, nsString& aValue) const;
-# 59 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
-  bool Get(const nsAString& aName,
-           nsString& aValue,
-           nsCSSTokenSerializationType& aFirstToken,
-           nsCSSTokenSerializationType& aLastToken) const;
-# 77 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
-  void GetVariableAt(size_t aIndex, nsAString& aName) const;
-
-
-
-
-  size_t Count() const;
-# 93 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/CSSVariableValues.h"
-  void Put(const nsAString& aName,
-           nsString aValue,
-           nsCSSTokenSerializationType aFirstToken,
-           nsCSSTokenSerializationType aLastToken);
-
-
-
-
-
-  void AddVariablesToResolver(CSSVariableResolver* aResolver) const;
-
-private:
-  struct Variable
-  {
-    Variable()
-      : mFirstToken(eCSSTokenSerialization_Nothing)
-      , mLastToken(eCSSTokenSerialization_Nothing)
-    {}
-
-    Variable(const nsAString& aVariableName,
-             nsString aValue,
-             nsCSSTokenSerializationType aFirstToken,
-             nsCSSTokenSerializationType aLastToken)
-      : mVariableName(aVariableName)
-      , mValue(aValue)
-      , mFirstToken(aFirstToken)
-      , mLastToken(aLastToken)
-    {}
-
-    nsString mVariableName;
-    nsString mValue;
-    nsCSSTokenSerializationType mFirstToken;
-    nsCSSTokenSerializationType mLastToken;
-  };
-
-
-
-
-  void CopyVariablesFrom(const CSSVariableValues& aOther);
-
-
-
-
-
-  nsDataHashtable<nsStringHashKey, size_t> mVariableIDs;
-
-
-
-
-  nsTArray<Variable> mVariables;
-};
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsThemeConstants.h" 1
-# 31 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h" 1
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h"
-class imgIContainer;
-
-class imgINotificationObserver;
-
-class nsIURI;
-
-class nsIPrincipal;
-# 37 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgIRequest.h"
-class imgIRequest : public nsIRequest {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetImage(imgIContainer * *aImage) = 0;
-
-  enum {
-    STATUS_NONE = 0,
-    STATUS_SIZE_AVAILABLE = 1,
-    STATUS_LOAD_COMPLETE = 2,
-    STATUS_ERROR = 4,
-    STATUS_FRAME_COMPLETE = 8,
-    STATUS_DECODE_COMPLETE = 16,
-    STATUS_IS_ANIMATED = 32,
-    STATUS_HAS_TRANSPARENCY = 64
-  };
-
-
-  virtual nsresult GetImageStatus(uint32_t *aImageStatus) = 0;
-
-
-  virtual nsresult GetImageErrorCode(nsresult *aImageErrorCode) = 0;
-
-
-  virtual nsresult GetURI(nsIURI * *aURI) = 0;
-
-
-  virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) = 0;
-
-
-  virtual nsresult GetNotificationObserver(imgINotificationObserver * *aNotificationObserver) = 0;
-
-
-  virtual nsresult GetMimeType(char * *aMimeType) = 0;
-
-
-  virtual nsresult Clone(imgINotificationObserver *aObserver, imgIRequest * *_retval) = 0;
-
-
-  virtual nsresult GetImagePrincipal(nsIPrincipal * *aImagePrincipal) = 0;
-
-
-  virtual nsresult GetMultipart(bool *aMultipart) = 0;
-
-  enum {
-    CORS_NONE = 1,
-    CORS_ANONYMOUS = 2,
-    CORS_USE_CREDENTIALS = 3
-  };
-
-
-  virtual nsresult GetCORSMode(int32_t *aCORSMode) = 0;
-
-
-  virtual nsresult CancelAndForgetObserver(nsresult aStatus) = 0;
-
-
-  virtual nsresult StartDecoding(uint32_t aFlags) = 0;
-
-
-  virtual bool StartDecodingWithResult(uint32_t aFlags) = 0;
-
-
-  virtual nsresult LockImage(void) = 0;
-
-
-  virtual nsresult UnlockImage(void) = 0;
-
-
-  virtual nsresult RequestDiscard(void) = 0;
-
-
-  virtual nsresult GetStaticRequest(imgIRequest * *_retval) = 0;
-
-
-  virtual nsresult IncrementAnimationConsumers(void) = 0;
-
-
-  virtual nsresult DecrementAnimationConsumers(void) = 0;
-
-};
-
-  template<typename T> struct imgIRequest::COMTypeInfo<imgIRequest, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID imgIRequest::COMTypeInfo<imgIRequest, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xdb0a945c, 0x3883, 0x424a, { 0x98, 0xd0, 0x2e, 0xe0, 0x52, 0x3b, 0x02, 0x55 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISecurityInfoProvider.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISecurityInfoProvider.h"
-class nsISecurityInfoProvider : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
-
-
-  virtual nsresult GetHasTransferredData(bool *aHasTransferredData) = 0;
-
-};
-
-  template<typename T> struct nsISecurityInfoProvider::COMTypeInfo<nsISecurityInfoProvider, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISecurityInfoProvider::COMTypeInfo<nsISecurityInfoProvider, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xb8cc9126, 0x9319, 0x4415, { 0xaf, 0xd9, 0xb8, 0x22, 0x20, 0xd4, 0x53, 0xed }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsPriority.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsISupportsPriority.h"
-class nsISupportsPriority : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    PRIORITY_HIGHEST = -20,
-    PRIORITY_HIGH = -10,
-    PRIORITY_NORMAL = 0,
-    PRIORITY_LOW = 10,
-    PRIORITY_LOWEST = 20
-  };
-
-
-  virtual nsresult GetPriority(int32_t *aPriority) = 0;
-  virtual nsresult SetPriority(int32_t aPriority) = 0;
-
-
-  virtual nsresult AdjustPriority(int32_t delta) = 0;
-
-};
-
-  template<typename T> struct nsISupportsPriority::COMTypeInfo<nsISupportsPriority, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsISupportsPriority::COMTypeInfo<nsISupportsPriority, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xaa578b44, 0xabd5, 0x4c19, { 0x8b, 0x14, 0x36, 0xd4, 0xde, 0x6f, 0xdc, 0x36 }};
-# 15 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h"
-class nsIPrincipal;
-
-namespace mozilla {
-class TimeStamp;
-}
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsITimedChannel.h"
-class nsITimedChannel : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetTimingEnabled(bool *aTimingEnabled) = 0;
-  virtual nsresult SetTimingEnabled(bool aTimingEnabled) = 0;
-
-
-  virtual nsresult GetRedirectCount(uint16_t *aRedirectCount) = 0;
-  virtual nsresult SetRedirectCount(uint16_t aRedirectCount) = 0;
-
-
-  virtual nsresult GetChannelCreation(mozilla::TimeStamp *aChannelCreation) = 0;
-
-
-  virtual nsresult GetAsyncOpen(mozilla::TimeStamp *aAsyncOpen) = 0;
-
-
-  virtual nsresult GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) = 0;
-
-
-  virtual nsresult GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) = 0;
-
-
-  virtual nsresult GetConnectStart(mozilla::TimeStamp *aConnectStart) = 0;
-
-
-  virtual nsresult GetConnectEnd(mozilla::TimeStamp *aConnectEnd) = 0;
-
-
-  virtual nsresult GetRequestStart(mozilla::TimeStamp *aRequestStart) = 0;
-
-
-  virtual nsresult GetResponseStart(mozilla::TimeStamp *aResponseStart) = 0;
-
-
-  virtual nsresult GetResponseEnd(mozilla::TimeStamp *aResponseEnd) = 0;
-
-
-  virtual nsresult GetRedirectStart(mozilla::TimeStamp *aRedirectStart) = 0;
-  virtual nsresult SetRedirectStart(mozilla::TimeStamp aRedirectStart) = 0;
-
-
-  virtual nsresult GetRedirectEnd(mozilla::TimeStamp *aRedirectEnd) = 0;
-  virtual nsresult SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) = 0;
-
-
-  virtual nsresult GetInitiatorType(nsAString & aInitiatorType) = 0;
-  virtual nsresult SetInitiatorType(const nsAString & aInitiatorType) = 0;
-
-
-  virtual nsresult GetAllRedirectsSameOrigin(bool *aAllRedirectsSameOrigin) = 0;
-  virtual nsresult SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) = 0;
-
-
-  virtual nsresult GetAllRedirectsPassTimingAllowCheck(bool *aAllRedirectsPassTimingAllowCheck) = 0;
-  virtual nsresult SetAllRedirectsPassTimingAllowCheck(bool aAllRedirectsPassTimingAllowCheck) = 0;
-
-
-  virtual nsresult TimingAllowCheck(nsIPrincipal *origin, bool *_retval) = 0;
-
-   inline bool TimingAllowCheck(nsIPrincipal* aOrigin) {
-    bool allowed = false;
-    return ((bool)(__builtin_expect(!!(!NS_FAILED_impl(TimingAllowCheck(aOrigin, &allowed))), 1))) && allowed;
-  }
-
-  virtual nsresult GetCacheReadStart(mozilla::TimeStamp *aCacheReadStart) = 0;
-
-
-  virtual nsresult GetCacheReadEnd(mozilla::TimeStamp *aCacheReadEnd) = 0;
-
-
-  virtual nsresult GetChannelCreationTime(PRTime *aChannelCreationTime) = 0;
-
-
-  virtual nsresult GetAsyncOpenTime(PRTime *aAsyncOpenTime) = 0;
-
-
-  virtual nsresult GetDomainLookupStartTime(PRTime *aDomainLookupStartTime) = 0;
-
-
-  virtual nsresult GetDomainLookupEndTime(PRTime *aDomainLookupEndTime) = 0;
-
-
-  virtual nsresult GetConnectStartTime(PRTime *aConnectStartTime) = 0;
-
-
-  virtual nsresult GetConnectEndTime(PRTime *aConnectEndTime) = 0;
-
-
-  virtual nsresult GetRequestStartTime(PRTime *aRequestStartTime) = 0;
-
-
-  virtual nsresult GetResponseStartTime(PRTime *aResponseStartTime) = 0;
-
-
-  virtual nsresult GetResponseEndTime(PRTime *aResponseEndTime) = 0;
-
-
-  virtual nsresult GetCacheReadStartTime(PRTime *aCacheReadStartTime) = 0;
-
-
-  virtual nsresult GetCacheReadEndTime(PRTime *aCacheReadEndTime) = 0;
-
-
-  virtual nsresult GetRedirectStartTime(PRTime *aRedirectStartTime) = 0;
-
-
-  virtual nsresult GetRedirectEndTime(PRTime *aRedirectEndTime) = 0;
-
-};
-
-  template<typename T> struct nsITimedChannel::COMTypeInfo<nsITimedChannel, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsITimedChannel::COMTypeInfo<nsITimedChannel, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xca63784d, 0x959c, 0x4c3a, { 0x9a, 0x59, 0x23, 0x4a, 0x2a, 0x52, 0x0d, 0xe0 }};
-# 16 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h"
-class nsIChannel;
-
-class nsIAsyncVerifyRedirectCallback;
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIChannelEventSink.h"
-class nsIChannelEventSink : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-  enum {
-    REDIRECT_TEMPORARY = 1U,
-    REDIRECT_PERMANENT = 2U,
-    REDIRECT_INTERNAL = 4U,
-    REDIRECT_STS_UPGRADE = 8U
-  };
-
-
-  virtual nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags, nsIAsyncVerifyRedirectCallback *callback) = 0;
-
-};
-
-  template<typename T> struct nsIChannelEventSink::COMTypeInfo<nsIChannelEventSink, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIChannelEventSink::COMTypeInfo<nsIChannelEventSink, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x0197720d, 0x37ed, 0x4e75, { 0x89, 0x56, 0xd0, 0xd2, 0x96, 0xe4, 0xd8, 0xa6 }};
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIInterfaceRequestor.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIInterfaceRequestor.h"
-class nsIInterfaceRequestor : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult GetInterface(const nsIID & uuid, void **result) = 0;
-
-};
-
-  template<typename T> struct nsIInterfaceRequestor::COMTypeInfo<nsIInterfaceRequestor, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIInterfaceRequestor::COMTypeInfo<nsIInterfaceRequestor, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x033a1470, 0x8b2a, 0x11d3, { 0xaf, 0x88, 0x00, 0xa0, 0x24, 0xff, 0xc0, 0x8c }};
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadRetargetableStreamListener.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIThreadRetargetableStreamListener.h"
-class nsIThreadRetargetableStreamListener : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult CheckListenerChain(void) = 0;
-
-};
-
-  template<typename T> struct nsIThreadRetargetableStreamListener::COMTypeInfo<nsIThreadRetargetableStreamListener, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIThreadRetargetableStreamListener::COMTypeInfo<nsIThreadRetargetableStreamListener, T>::kIID __attribute__ ((visibility ("hidden"))) = {0xfb2304b8, 0xf82f, 0x4433, { 0xaf, 0x68, 0xd8, 0x74, 0xa2, 0xeb, 0xbd, 0xc1 }};
-# 14 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAsyncVerifyRedirectCallback.h" 1
-# 25 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsIAsyncVerifyRedirectCallback.h"
-class nsIAsyncVerifyRedirectCallback : public nsISupports {
- public:
-
-  template<typename T, typename U> struct COMTypeInfo;
-
-
-  virtual nsresult OnRedirectVerifyCallback(nsresult result) = 0;
-
-};
-
-  template<typename T> struct nsIAsyncVerifyRedirectCallback::COMTypeInfo<nsIAsyncVerifyRedirectCallback, T> { static const nsIID kIID __attribute__ ((visibility ("hidden"))); }; template<typename T> const nsIID nsIAsyncVerifyRedirectCallback::COMTypeInfo<nsIAsyncVerifyRedirectCallback, T>::kIID __attribute__ ((visibility ("hidden"))) = {0x8d171460, 0xa716, 0x41f1, { 0x92, 0xbe, 0x8c, 0x65, 0x9d, 0xb3, 0x9b, 0x45 }};
-# 21 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 1
-# 10 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h" 1
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
-namespace mozilla {
-# 49 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
-class BlockingResourceBase
-{
-public:
-
-  enum BlockingResourceType { eMutex, eReentrantMonitor, eCondVar };
-
-
-
-
-
-  static const char* const kResourceTypeName[];
-# 333 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/BlockingResourceBase.h"
-  BlockingResourceBase(const char* aName, BlockingResourceType aType) {}
-
-  ~BlockingResourceBase() {}
-
-
-};
-
-
-}
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PlatformMutex.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/PlatformMutex.h"
-namespace mozilla {
-
-namespace detail {
-
-class ConditionVariableImpl;
-
-class MutexImpl
-{
-public:
-  struct PlatformData;
-
-  __attribute__((weak)) __attribute__((visibility("default"))) MutexImpl();
-  __attribute__((weak)) __attribute__((visibility("default"))) ~MutexImpl();
-
-  bool operator==(const MutexImpl& rhs) {
-    return platformData_ == rhs.platformData_;
-  }
-
-protected:
-  __attribute__((weak)) __attribute__((visibility("default"))) void lock();
-  __attribute__((weak)) __attribute__((visibility("default"))) void unlock();
-
-private:
-  MutexImpl(const MutexImpl&) = delete;
-  void operator=(const MutexImpl&) = delete;
-  MutexImpl(MutexImpl&&) = delete;
-  void operator=(MutexImpl&&) = delete;
-
-  PlatformData* platformData();
-
-
-  void* platformData_[sizeof(pthread_mutex_t) / sizeof(void*)];
-  static_assert(sizeof(pthread_mutex_t) / sizeof(void*) != 0 &&
-                sizeof(pthread_mutex_t) % sizeof(void*) == 0,
-                "pthread_mutex_t must have pointer alignment");
-
-
-
-
-  friend class mozilla::detail::ConditionVariableImpl;
-};
-
-}
-
-}
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h" 2
-# 29 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-namespace mozilla {
-
-
-
-
-
-
-class OffTheBooksMutex : public detail::MutexImpl, BlockingResourceBase
-{
-public:
-
-
-
-
-
-
-  explicit OffTheBooksMutex(const char* aName)
-    : detail::MutexImpl()
-    , BlockingResourceBase(aName, eMutex)
-
-
-
-  {
-  }
-
-  ~OffTheBooksMutex()
-  {
-
-
-
-  }
-
-
-
-
-
-  void Lock() { this->lock(); }
-
-
-
-
-  void Unlock() { this->unlock(); }
-
-
-
-
-
-
-  void AssertCurrentThreadOwns() const {}
-# 87 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-  void AssertNotCurrentThreadOwns() const {}
-# 102 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-private:
-  OffTheBooksMutex();
-  OffTheBooksMutex(const OffTheBooksMutex&);
-  OffTheBooksMutex& operator=(const OffTheBooksMutex&);
-
-  friend class CondVar;
-
-
-
-
-};
-
-
-
-
-
-
-class Mutex : public OffTheBooksMutex
-{
-public:
-  explicit Mutex(const char* aName)
-    : OffTheBooksMutex(aName)
-  {
-                         ;
-  }
-
-  ~Mutex()
-  {
-                         ;
-  }
-
-private:
-  Mutex();
-  Mutex(const Mutex&);
-  Mutex& operator=(const Mutex&);
-};
-# 146 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-template<typename T>
-class BaseAutoLock
-{
-public:
-# 158 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-  explicit BaseAutoLock(T& aLock )
-    : mLock(&aLock)
-  {
-    do { } while (0);
-    do { } while(0);
-    mLock->Lock();
-  }
-
-  ~BaseAutoLock(void)
-  {
-    mLock->Unlock();
-  }
-
-private:
-  BaseAutoLock();
-  BaseAutoLock(BaseAutoLock&);
-  BaseAutoLock& operator=(BaseAutoLock&);
-  static void* operator new(size_t) throw();
-
-  T* mLock;
-
-};
-
-typedef BaseAutoLock<Mutex> MutexAutoLock;
-typedef BaseAutoLock<OffTheBooksMutex> OffTheBooksMutexAutoLock;
-# 191 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Mutex.h"
-template<typename T>
-class BaseAutoUnlock
-{
-public:
-  explicit BaseAutoUnlock(T& aLock )
-    : mLock(&aLock)
-  {
-    do { } while (0);
-    do { } while(0);
-    mLock->Unlock();
-  }
-
-  ~BaseAutoUnlock()
-  {
-    mLock->Lock();
-  }
-
-private:
-  BaseAutoUnlock();
-  BaseAutoUnlock(BaseAutoUnlock&);
-  BaseAutoUnlock& operator=(BaseAutoUnlock&);
-  static void* operator new(size_t) throw();
-
-  T* mLock;
-
-};
-
-typedef BaseAutoUnlock<Mutex> MutexAutoUnlock;
-typedef BaseAutoUnlock<OffTheBooksMutex> OffTheBooksMutexAutoUnlock;
-
-}
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h" 1
-# 17 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h"
-class nsIDocument;
-class nsIURI;
-
-namespace mozilla {
-namespace image {
-
-class ImageURL;
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/ImageCacheKey.h"
-class ImageCacheKey final
-{
-public:
-  ImageCacheKey(nsIURI* aURI, const OriginAttributes& aAttrs,
-                nsIDocument* aDocument, nsresult& aRv);
-  ImageCacheKey(ImageURL* aURI, const OriginAttributes& aAttrs,
-                nsIDocument* aDocument);
-
-  ImageCacheKey(const ImageCacheKey& aOther);
-  ImageCacheKey(ImageCacheKey&& aOther);
-
-  bool operator==(const ImageCacheKey& aOther) const;
-  uint32_t Hash() const { return mHash; }
-
-
-  const char* Spec() const;
-
-
-  bool IsChrome() const { return mIsChrome; }
-
-
-
-  void* ControlledDocument() const { return mControlledDocument; }
-
-private:
-  static uint32_t ComputeHash(ImageURL* aURI,
-                              const Maybe<uint64_t>& aBlobSerial,
-                              const OriginAttributes& aAttrs,
-                              void* aControlledDocument);
-  static void* GetControlledDocumentToken(nsIDocument* aDocument);
-
-  RefPtr<ImageURL> mURI;
-  Maybe<uint64_t> mBlobSerial;
-  OriginAttributes mOriginAttributes;
-  void* mControlledDocument;
-  uint32_t mHash;
-  bool mIsChrome;
-};
-
-}
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequest.h" 2
-
-class imgCacheValidator;
-class imgLoader;
-class imgRequestProxy;
-class imgCacheEntry;
-class nsIApplicationCache;
-class nsIProperties;
-class nsIRequest;
-class nsITimedChannel;
-class nsIURI;
-
-namespace mozilla {
-namespace image {
-class Image;
-class ImageURL;
-class ProgressTracker;
-}
-}
-
-struct NewPartResult;
-
-class imgRequest final : public nsIStreamListener,
-                         public nsIThreadRetargetableStreamListener,
-                         public nsIChannelEventSink,
-                         public nsIInterfaceRequestor,
-                         public nsIAsyncVerifyRedirectCallback
-{
-  typedef mozilla::image::Image Image;
-  typedef mozilla::image::ImageCacheKey ImageCacheKey;
-  typedef mozilla::image::ImageURL ImageURL;
-  typedef mozilla::image::ProgressTracker ProgressTracker;
-  typedef mozilla::net::ReferrerPolicy ReferrerPolicy;
-
-public:
-  imgRequest(imgLoader* aLoader, const ImageCacheKey& aCacheKey);
-
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-  virtual nsresult OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext, nsIInputStream *aInputStream, uint64_t aOffset, uint32_t aCount) override;
-  virtual nsresult CheckListenerChain(void) override;
-  virtual nsresult OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) override; virtual nsresult OnStopRequest(nsIRequest *aRequest, nsISupports *aContext, nsresult aStatusCode) override;
-  virtual nsresult AsyncOnChannelRedirect(nsIChannel *oldChannel, nsIChannel *newChannel, uint32_t flags, nsIAsyncVerifyRedirectCallback *callback) override;
-  virtual nsresult GetInterface(const nsIID & uuid, void **result) override;
-  virtual nsresult OnRedirectVerifyCallback(nsresult result) override;
-
-  __attribute__ ((warn_unused_result)) nsresult Init(nsIURI* aURI,
-                             nsIURI* aCurrentURI,
-                             bool aHadInsecureRedirect,
-                             nsIRequest* aRequest,
-                             nsIChannel* aChannel,
-                             imgCacheEntry* aCacheEntry,
-                             nsISupports* aCX,
-                             nsIPrincipal* aLoadingPrincipal,
-                             int32_t aCORSMode,
-                             ReferrerPolicy aReferrerPolicy);
-
-  void ClearLoader();
-
-
-  void AddProxy(imgRequestProxy* proxy);
-
-  nsresult RemoveProxy(imgRequestProxy* proxy, nsresult aStatus);
-
-
-
-
-  void CancelAndAbort(nsresult aStatus);
-
-
-  void ContinueCancel(nsresult aStatus);
-
-
-  void ContinueEvict();
-
-
-  void StartDecoding();
-
-  inline uint64_t InnerWindowID() const {
-    return mInnerWindowId;
-  }
-
-
-
-
-
-  static void SetCacheValidation(imgCacheEntry* aEntry, nsIRequest* aRequest);
-
-
-
-
-
-  bool CacheChanged(nsIRequest* aNewRequest);
-
-  bool GetMultipart() const;
-
-
-
-  bool HadInsecureRedirect() const;
-
-
-  int32_t GetCORSMode() const { return mCORSMode; }
-
-
-  ReferrerPolicy GetReferrerPolicy() const { return mReferrerPolicy; }
-
-
-
-  already_AddRefed<nsIPrincipal> GetLoadingPrincipal() const
-  {
-    nsCOMPtr<nsIPrincipal> principal = mLoadingPrincipal;
-    return principal.forget();
-  }
-
-
-
-
-  already_AddRefed<ProgressTracker> GetProgressTracker() const;
-
-
-  already_AddRefed<Image> GetImage() const;
-
-
-  inline nsIPrincipal* GetPrincipal() const { return mPrincipal.get(); }
-
-
-  const ImageCacheKey& CacheKey() const { return mCacheKey; }
-
-
-  void ResetCacheEntry();
-
-
-  nsresult GetURI(ImageURL** aURI);
-  nsresult GetCurrentURI(nsIURI** aURI);
-  bool IsChrome() const;
-
-  nsresult GetImageErrorCode(void);
-
-
-  bool HasTransferredData() const;
-
-
-  const char* GetMimeType() const { return mContentType.get(); }
-
-
-
-  int32_t Priority() const;
-
-
-
-  void AdjustPriority(imgRequestProxy* aProxy, int32_t aDelta);
-
-
-  nsIRequest* GetRequest() const { return mRequest; }
-
-  nsITimedChannel* GetTimedChannel() const { return mTimedChannel; }
-
-  nsresult GetSecurityInfo(nsISupports** aSecurityInfoOut);
-
-  imgCacheValidator* GetValidator() const { return mValidator; }
-  void SetValidator(imgCacheValidator* aValidator) { mValidator = aValidator; }
-
-  void* LoadId() const { return mLoadId; }
-  void SetLoadId(void* aLoadId) { mLoadId = aLoadId; }
-
-
-
-
-  void SetCacheEntry(imgCacheEntry* aEntry);
-
-
-  bool HasCacheEntry() const;
-
-
-
-
-  void SetIsInCache(bool aCacheable);
-
-  void EvictFromCache();
-  void RemoveFromCache();
-
-
-  void SetProperties(const nsACString& aContentType,
-                     const nsACString& aContentDisposition);
-
-  nsIProperties* Properties() const { return mProperties; }
-
-  bool HasConsumers() const;
-
-private:
-  friend class FinishPreparingForNewPartRunnable;
-
-  virtual ~imgRequest();
-
-  void FinishPreparingForNewPart(const NewPartResult& aResult);
-
-  void Cancel(nsresult aStatus);
-
-
-  void UpdateCacheEntrySize();
-
-
-  bool IsDecodeRequested() const;
-
-
-  imgLoader* mLoader;
-  nsCOMPtr<nsIRequest> mRequest;
-
-
-
-  RefPtr<ImageURL> mURI;
-
-  nsCOMPtr<nsIURI> mCurrentURI;
-
-
-  nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
-
-  nsCOMPtr<nsIPrincipal> mPrincipal;
-  nsCOMPtr<nsIProperties> mProperties;
-  nsCOMPtr<nsISupports> mSecurityInfo;
-  nsCOMPtr<nsIChannel> mChannel;
-  nsCOMPtr<nsIInterfaceRequestor> mPrevChannelSink;
-  nsCOMPtr<nsIApplicationCache> mApplicationCache;
-
-  nsCOMPtr<nsITimedChannel> mTimedChannel;
-
-  nsCString mContentType;
-
-
-  RefPtr<imgCacheEntry> mCacheEntry;
-
-
-  ImageCacheKey mCacheKey;
-
-  void* mLoadId;
-
-
-
-  void* mFirstProxy;
-
-  imgCacheValidator* mValidator;
-  nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
-  nsCOMPtr<nsIChannel> mNewRedirectChannel;
-
-
-  uint64_t mInnerWindowId;
-
-
-
-  int32_t mCORSMode;
-
-
-  ReferrerPolicy mReferrerPolicy;
-
-  nsresult mImageErrorCode;
-
-  mutable mozilla::Mutex mMutex;
-
-
-
-
-  RefPtr<ProgressTracker> mProgressTracker;
-  RefPtr<Image> mImage;
-  bool mIsMultiPartChannel : 1;
-  bool mGotData : 1;
-  bool mIsInCache : 1;
-  bool mDecodeRequested : 1;
-  bool mNewPartPending : 1;
-  bool mHadInsecureRedirect : 1;
-};
-# 23 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h" 1
-# 13 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h"
-namespace mozilla {
-namespace image {
-# 28 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/IProgressObserver.h"
-class IProgressObserver : public SupportsWeakPtr<IProgressObserver>
-{
-public:
-
-
-
-
-  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
-
-
-  virtual void Notify(int32_t aType, const nsIntRect* aRect = nullptr) = 0;
-  virtual void OnLoadComplete(bool aLastPart) = 0;
-
-
-  virtual void BlockOnload() = 0;
-  virtual void UnblockOnload() = 0;
-
-
-  virtual void SetHasImage() = 0;
-  virtual bool NotificationsDeferred() const = 0;
-  virtual void SetNotificationsDeferred(bool aDeferNotifications) = 0;
-
-protected:
-  virtual ~IProgressObserver() { }
-};
-
-}
-}
-# 24 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h" 2
-# 33 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/imgRequestProxy.h"
-class imgINotificationObserver;
-class imgStatusNotifyRunnable;
-class ProxyBehaviour;
-
-namespace mozilla {
-namespace image {
-class Image;
-class ImageURL;
-class ProgressTracker;
-}
-}
-
-class imgRequestProxy : public imgIRequest,
-                        public mozilla::image::IProgressObserver,
-                        public nsISupportsPriority,
-                        public nsISecurityInfoProvider,
-                        public nsITimedChannel
-{
-protected:
-  virtual ~imgRequestProxy();
-
-public:
-  typedef mozilla::image::Image Image;
-  typedef mozilla::image::ImageURL ImageURL;
-  typedef mozilla::image::ProgressTracker ProgressTracker;
-
-  const char* typeName() const { return "imgRequestProxy"; } size_t typeSize() const { return sizeof(*this); }
-  public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release(void) override; typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-  virtual nsresult GetImage(imgIContainer * *aImage) override; virtual nsresult GetImageStatus(uint32_t *aImageStatus) override; virtual nsresult GetImageErrorCode(nsresult *aImageErrorCode) override; virtual nsresult GetURI(nsIURI * *aURI) override; virtual nsresult GetCurrentURI(nsIURI * *aCurrentURI) override; virtual nsresult GetNotificationObserver(imgINotificationObserver * *aNotificationObserver) override; virtual nsresult GetMimeType(char * *aMimeType) override; virtual nsresult Clone(imgINotificationObserver *aObserver, imgIRequest * *_retval) override; virtual nsresult GetImagePrincipal(nsIPrincipal * *aImagePrincipal) override; virtual nsresult GetMultipart(bool *aMultipart) override; virtual nsresult GetCORSMode(int32_t *aCORSMode) override; virtual nsresult CancelAndForgetObserver(nsresult aStatus) override; virtual nsresult StartDecoding(uint32_t aFlags) override; virtual bool StartDecodingWithResult(uint32_t aFlags) override; virtual nsresult LockImage(void) override; virtual nsresult UnlockImage(void) override; virtual nsresult RequestDiscard(void) override; virtual nsresult GetStaticRequest(imgIRequest * *_retval) override; virtual nsresult IncrementAnimationConsumers(void) override; virtual nsresult DecrementAnimationConsumers(void) override;
-  virtual nsresult GetName(nsACString & aName) override; virtual nsresult IsPending(bool *_retval) override; virtual nsresult GetStatus(nsresult *aStatus) override; virtual nsresult Cancel(nsresult aStatus) override; virtual nsresult Suspend(void) override; virtual nsresult Resume(void) override; virtual nsresult GetLoadGroup(nsILoadGroup * *aLoadGroup) override; virtual nsresult SetLoadGroup(nsILoadGroup *aLoadGroup) override; virtual nsresult GetLoadFlags(nsLoadFlags *aLoadFlags) override; virtual nsresult SetLoadFlags(nsLoadFlags aLoadFlags) override;
-  virtual nsresult GetPriority(int32_t *aPriority) override; virtual nsresult SetPriority(int32_t aPriority) override; virtual nsresult AdjustPriority(int32_t delta) override;
-  virtual nsresult GetSecurityInfo(nsISupports * *aSecurityInfo) override; virtual nsresult GetHasTransferredData(bool *aHasTransferredData) override;
-
-
-  imgRequestProxy();
-
-
-
-  nsresult Init(imgRequest* aOwner,
-                nsILoadGroup* aLoadGroup,
-                ImageURL* aURI,
-                imgINotificationObserver* aObserver);
-
-  nsresult ChangeOwner(imgRequest* aNewOwner);
-
-
-
-
-  void AddToLoadGroup();
-  void RemoveFromLoadGroup(bool releaseLoadGroup);
-
-  inline bool HasObserver() const {
-    return mListener != nullptr;
-  }
-
-
-
-
-
-  void NotifyListener();
-
-
-
-
-  void SyncNotifyListener();
-
-
-  virtual void Notify(int32_t aType,
-                      const mozilla::gfx::IntRect* aRect = nullptr) override;
-  virtual void OnLoadComplete(bool aLastPart) override;
-
-
-  virtual void BlockOnload() override;
-  virtual void UnblockOnload() override;
-
-
-  virtual void SetHasImage() override;
-
-
-
-  virtual bool NotificationsDeferred() const override
-  {
-    return mDeferNotifications;
-  }
-  virtual void SetNotificationsDeferred(bool aDeferNotifications) override
-  {
-    mDeferNotifications = aDeferNotifications;
-  }
-
-
-
-
-
-  void ClearAnimationConsumers();
-
-  virtual nsresult Clone(imgINotificationObserver* aObserver,
-                         imgRequestProxy** aClone);
-  nsresult GetStaticRequest(imgRequestProxy** aReturn);
-
-  nsresult GetURI(ImageURL** aURI);
-
-protected:
-  friend class mozilla::image::ProgressTracker;
-  friend class imgStatusNotifyRunnable;
-
-  class imgCancelRunnable;
-  friend class imgCancelRunnable;
-
-  class imgCancelRunnable : public mozilla::Runnable
-  {
-    public:
-      imgCancelRunnable(imgRequestProxy* owner, nsresult status)
-        : Runnable("imgCancelRunnable"), mOwner(owner), mStatus(status)
-      { }
-
-      virtual nsresult Run() override {
-        mOwner->DoCancel(mStatus);
-        return NS_OK;
-      }
-
-    private:
-      RefPtr<imgRequestProxy> mOwner;
-      nsresult mStatus;
-  };
-
-
-  void DoCancel(nsresult status);
-
-
-  void NullOutListener();
-
-  void DoRemoveFromLoadGroup() {
-    RemoveFromLoadGroup(true);
-  }
-
-
-
-
-
-  already_AddRefed<ProgressTracker> GetProgressTracker() const;
-
-  nsITimedChannel* TimedChannel()
-  {
-    if (!GetOwner()) {
-      return nullptr;
-    }
-    return GetOwner()->GetTimedChannel();
-  }
-
-  already_AddRefed<Image> GetImage() const;
-  bool HasImage() const;
-  imgRequest* GetOwner() const;
-
-  nsresult PerformClone(imgINotificationObserver* aObserver,
-                        imgRequestProxy* (aAllocFn)(imgRequestProxy*),
-                        imgRequestProxy** aClone);
-
-public:
-  virtual nsresult GetTimingEnabled(bool *aTimingEnabled) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetTimingEnabled(aTimingEnabled); } virtual nsresult SetTimingEnabled(bool aTimingEnabled) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetTimingEnabled(aTimingEnabled); } virtual nsresult GetRedirectCount(uint16_t *aRedirectCount) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectCount(aRedirectCount); } virtual nsresult SetRedirectCount(uint16_t aRedirectCount) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectCount(aRedirectCount); } virtual nsresult GetChannelCreation(mozilla::TimeStamp *aChannelCreation) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetChannelCreation(aChannelCreation); } virtual nsresult GetAsyncOpen(mozilla::TimeStamp *aAsyncOpen) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAsyncOpen(aAsyncOpen); } virtual nsresult GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupStart(aDomainLookupStart); } virtual nsresult GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupEnd(aDomainLookupEnd); } virtual nsresult GetConnectStart(mozilla::TimeStamp *aConnectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectStart(aConnectStart); } virtual nsresult GetConnectEnd(mozilla::TimeStamp *aConnectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectEnd(aConnectEnd); } virtual nsresult GetRequestStart(mozilla::TimeStamp *aRequestStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRequestStart(aRequestStart); } virtual nsresult GetResponseStart(mozilla::TimeStamp *aResponseStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseStart(aResponseStart); } virtual nsresult GetResponseEnd(mozilla::TimeStamp *aResponseEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseEnd(aResponseEnd); } virtual nsresult GetRedirectStart(mozilla::TimeStamp *aRedirectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectStart(aRedirectStart); } virtual nsresult SetRedirectStart(mozilla::TimeStamp aRedirectStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectStart(aRedirectStart); } virtual nsresult GetRedirectEnd(mozilla::TimeStamp *aRedirectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectEnd(aRedirectEnd); } virtual nsresult SetRedirectEnd(mozilla::TimeStamp aRedirectEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetRedirectEnd(aRedirectEnd); } virtual nsresult GetInitiatorType(nsAString & aInitiatorType) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetInitiatorType(aInitiatorType); } virtual nsresult SetInitiatorType(const nsAString & aInitiatorType) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetInitiatorType(aInitiatorType); } virtual nsresult GetAllRedirectsSameOrigin(bool *aAllRedirectsSameOrigin) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAllRedirectsSameOrigin(aAllRedirectsSameOrigin); } virtual nsresult SetAllRedirectsSameOrigin(bool aAllRedirectsSameOrigin) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetAllRedirectsSameOrigin(aAllRedirectsSameOrigin); } virtual nsresult GetAllRedirectsPassTimingAllowCheck(bool *aAllRedirectsPassTimingAllowCheck) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAllRedirectsPassTimingAllowCheck(aAllRedirectsPassTimingAllowCheck); } virtual nsresult SetAllRedirectsPassTimingAllowCheck(bool aAllRedirectsPassTimingAllowCheck) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->SetAllRedirectsPassTimingAllowCheck(aAllRedirectsPassTimingAllowCheck); } virtual nsresult TimingAllowCheck(nsIPrincipal *origin, bool *_retval) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->TimingAllowCheck(origin, _retval); } virtual nsresult GetCacheReadStart(mozilla::TimeStamp *aCacheReadStart) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadStart(aCacheReadStart); } virtual nsresult GetCacheReadEnd(mozilla::TimeStamp *aCacheReadEnd) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadEnd(aCacheReadEnd); } virtual nsresult GetChannelCreationTime(PRTime *aChannelCreationTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetChannelCreationTime(aChannelCreationTime); } virtual nsresult GetAsyncOpenTime(PRTime *aAsyncOpenTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetAsyncOpenTime(aAsyncOpenTime); } virtual nsresult GetDomainLookupStartTime(PRTime *aDomainLookupStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupStartTime(aDomainLookupStartTime); } virtual nsresult GetDomainLookupEndTime(PRTime *aDomainLookupEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetDomainLookupEndTime(aDomainLookupEndTime); } virtual nsresult GetConnectStartTime(PRTime *aConnectStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectStartTime(aConnectStartTime); } virtual nsresult GetConnectEndTime(PRTime *aConnectEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetConnectEndTime(aConnectEndTime); } virtual nsresult GetRequestStartTime(PRTime *aRequestStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRequestStartTime(aRequestStartTime); } virtual nsresult GetResponseStartTime(PRTime *aResponseStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseStartTime(aResponseStartTime); } virtual nsresult GetResponseEndTime(PRTime *aResponseEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetResponseEndTime(aResponseEndTime); } virtual nsresult GetCacheReadStartTime(PRTime *aCacheReadStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadStartTime(aCacheReadStartTime); } virtual nsresult GetCacheReadEndTime(PRTime *aCacheReadEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetCacheReadEndTime(aCacheReadEndTime); } virtual nsresult GetRedirectStartTime(PRTime *aRedirectStartTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectStartTime(aRedirectStartTime); } virtual nsresult GetRedirectEndTime(PRTime *aRedirectEndTime) override { return !TimedChannel() ? NS_ERROR_NULL_POINTER : TimedChannel()->GetRedirectEndTime(aRedirectEndTime); }
-
-protected:
-  mozilla::UniquePtr<ProxyBehaviour> mBehaviour;
-
-private:
-  friend class imgCacheValidator;
-  friend imgRequestProxy* NewStaticProxy(imgRequestProxy* aThis);
-
-
-  RefPtr<ImageURL> mURI;
-
-
-
-
-  imgINotificationObserver* mListener;
-
-
-
-  nsCOMPtr<nsILoadGroup> mLoadGroup;
-
-  nsLoadFlags mLoadFlags;
-  uint32_t mLockCount;
-  uint32_t mAnimationConsumers;
-  bool mCanceled;
-  bool mIsInLoadGroup;
-  bool mListenerIsStrongRef;
-  bool mDecodeRequested;
-
-
-
-  bool mDeferNotifications;
-};
-
-
-
-class imgRequestProxyStatic : public imgRequestProxy
-{
-
-public:
-  imgRequestProxyStatic(Image* aImage, nsIPrincipal* aPrincipal);
-
-  virtual nsresult GetImagePrincipal(nsIPrincipal** aPrincipal) override;
-
-  using imgRequestProxy::Clone;
-
-  virtual nsresult Clone(imgINotificationObserver* aObserver,
-                         imgRequestProxy** aClone) override;
-
-protected:
-  friend imgRequestProxy* NewStaticProxy(imgRequestProxy*);
-
-
-
-  nsCOMPtr<nsIPrincipal> mPrincipal;
-};
-# 38 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Orientation.h" 1
-# 11 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/Orientation.h"
-namespace mozilla {
-namespace image {
-
-enum class Angle : uint8_t {
-  D0,
-  D90,
-  D180,
-  D270
-};
-
-enum class Flip : uint8_t {
-  Unflipped,
-  Horizontal
-};
-
-
-
-
-
-
-struct Orientation
-{
-  explicit Orientation(Angle aRotation = Angle::D0,
-                       Flip mFlip = Flip::Unflipped)
-    : rotation(aRotation)
-    , flip(mFlip)
-  { }
-
-  bool IsIdentity() const {
-    return (rotation == Angle::D0) && (flip == Flip::Unflipped);
-  }
-
-  bool SwapsWidthAndHeight() const {
-    return (rotation == Angle::D90) || (rotation == Angle::D270);
-  }
-
-  bool operator==(const Orientation& aOther) const {
-    return (rotation == aOther.rotation) && (flip == aOther.flip);
-  }
-
-  bool operator!=(const Orientation& aOther) const {
-    return !(*this == aOther);
-  }
-
-  Angle rotation;
-  Flip flip;
-};
-
-}
-}
-# 39 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/CounterStyleManager.h" 1
-# 19 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/CounterStyleManager.h"
-class nsPresContext;
-
-namespace mozilla {
-
-class WritingMode;
-
-typedef int32_t CounterValue;
-
-class CounterStyleManager;
-class AnonymousCounterStyle;
-
-struct NegativeType;
-struct PadType;
-
-class CounterStyle
-{
-protected:
-  explicit constexpr CounterStyle(int32_t aStyle)
-    : mStyle(aStyle)
-  {
-  }
-
-private:
-  CounterStyle(const CounterStyle& aOther) = delete;
-  void operator=(const CounterStyle& other) = delete;
-
-public:
-  int32_t GetStyle() const { return mStyle; }
-  bool IsNone() const { return mStyle == 0; }
-  bool IsCustomStyle() const { return mStyle == -1; }
-
-
-
-  bool IsDependentStyle() const;
-
-  virtual void GetStyleName(nsSubstring& aResult) = 0;
-  virtual void GetPrefix(nsSubstring& aResult) = 0;
-  virtual void GetSuffix(nsSubstring& aResult) = 0;
-  void GetCounterText(CounterValue aOrdinal,
-                      WritingMode aWritingMode,
-                      nsSubstring& aResult,
-                      bool& aIsRTL);
-  virtual void GetSpokenCounterText(CounterValue aOrdinal,
-                                    WritingMode aWritingMode,
-                                    nsSubstring& aResult,
-                                    bool& aIsBullet);
-
-
-
-  virtual bool IsBullet() = 0;
-
-  virtual void GetNegative(NegativeType& aResult) = 0;
-
-
-
-
-
-  virtual bool IsOrdinalInRange(CounterValue aOrdinal) = 0;
-
-
-
-
-
-  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) = 0;
-  virtual void GetPad(PadType& aResult) = 0;
-  virtual CounterStyle* GetFallback() = 0;
-  virtual uint8_t GetSpeakAs() = 0;
-  virtual bool UseNegativeSign() = 0;
-
-  virtual void CallFallbackStyle(CounterValue aOrdinal,
-                                 WritingMode aWritingMode,
-                                 nsSubstring& aResult,
-                                 bool& aIsRTL);
-  virtual bool GetInitialCounterText(CounterValue aOrdinal,
-                                     WritingMode aWritingMode,
-                                     nsSubstring& aResult,
-                                     bool& aIsRTL) = 0;
-
-  virtual AnonymousCounterStyle* AsAnonymous() { return nullptr; }
-
-  public: virtual MozExternalRefCountType AddRef(void) = 0; virtual MozExternalRefCountType Release(void) = 0; public:
-
-protected:
-  int32_t mStyle;
-};
-
-class AnonymousCounterStyle final : public CounterStyle
-{
-public:
-  explicit AnonymousCounterStyle(const nsSubstring& aContent);
-  explicit AnonymousCounterStyle(const nsCSSValue::Array* aValue);
-
-  virtual void GetStyleName(nsAString& aResult) override;
-  virtual void GetPrefix(nsAString& aResult) override;
-  virtual void GetSuffix(nsAString& aResult) override;
-  virtual bool IsBullet() override;
-
-  virtual void GetNegative(NegativeType& aResult) override;
-  virtual bool IsOrdinalInRange(CounterValue aOrdinal) override;
-  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) override;
-  virtual void GetPad(PadType& aResult) override;
-  virtual CounterStyle* GetFallback() override;
-  virtual uint8_t GetSpeakAs() override;
-  virtual bool UseNegativeSign() override;
-
-  virtual bool GetInitialCounterText(CounterValue aOrdinal,
-                                     WritingMode aWritingMode,
-                                     nsSubstring& aResult,
-                                     bool& aIsRTL) override;
-
-  virtual AnonymousCounterStyle* AsAnonymous() override { return this; }
-
-  bool IsSingleString() const { return mSingleString; }
-  uint8_t GetSystem() const { return mSystem; }
-  const nsTArray<nsString>& GetSymbols() const { return mSymbols; }
-
-  public: MozExternalRefCountType AddRef(void) override { static_assert(!mozilla::IsDestructible<AnonymousCounterStyle>::value, "Reference-counted class " "AnonymousCounterStyle" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) override { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-private:
-  ~AnonymousCounterStyle() {}
-
-  bool mSingleString;
-  uint8_t mSystem;
-  nsTArray<nsString> mSymbols;
-};
-
-class CounterStyleManager final
-{
-private:
-  ~CounterStyleManager();
-public:
-  explicit CounterStyleManager(nsPresContext* aPresContext);
-
-  static void InitializeBuiltinCounterStyles();
-
-  void Disconnect();
-
-  bool IsInitial() const
-  {
-
-    return mCacheTable.Count() == 2;
-  }
-
-  CounterStyle* BuildCounterStyle(const nsSubstring& aName);
-
-  static CounterStyle* GetBuiltinStyle(int32_t aStyle);
-  static CounterStyle* GetNoneStyle()
-  {
-    return GetBuiltinStyle(0);
-  }
-  static CounterStyle* GetDecimalStyle()
-  {
-    return GetBuiltinStyle(4);
-  }
-
-
-
-
-
-  bool NotifyRuleChanged();
-
-  nsPresContext* PresContext() const { return mPresContext; }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<CounterStyleManager>::value, "Reference-counted class " "CounterStyleManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
-
-private:
-  nsPresContext* mPresContext;
-  nsRefPtrHashtable<nsStringHashKey, CounterStyle> mCacheTable;
-};
-
-}
-# 40 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/X11UndefineNone.h" 1
-# 43 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h" 2
-
-class nsIFrame;
-class nsIURI;
-class nsStyleContext;
-class nsTextFrame;
-class imgIContainer;
-struct nsStyleVisibility;
-namespace mozilla {
-namespace dom {
-class ImageTracker;
-}
-}
-# 111 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-static_assert(int(mozilla::SheetType::Count) - 1 <=
-                (0xf0000000 >> 28),
-              "NS_RULE_NODE_LEVEL_MASK cannot fit SheetType");
-
-static_assert(0x000ffffff == (1 << nsStyleStructID_Length) - 1,
-              "NS_STYLE_INHERIT_MASK is not correct");
-
-static_assert((0x01000000 & 0x000ffffff) == 0,
-  "NS_RULE_NODE_IS_ANIMATION_RULE must not overlap the style struct bits.");
-
-namespace mozilla {
-
-struct Position {
-  using Coord = nsStyleCoord::CalcValue;
-
-  Coord mXPosition, mYPosition;
-
-
-  Position() {}
-
-
-
-  void SetInitialPercentValues(float aPercentVal);
-
-
-
-  void SetInitialZeroValues();
-
-
-
-  bool DependsOnPositioningAreaSize() const {
-    return mXPosition.mPercent != 0.0f || mYPosition.mPercent != 0.0f;
-  }
-
-  bool operator==(const Position& aOther) const {
-    return mXPosition == aOther.mXPosition &&
-      mYPosition == aOther.mYPosition;
-  }
-  bool operator!=(const Position& aOther) const {
-    return !(*this == aOther);
-  }
-};
-
-}
-
-
-struct nsStyleFont
-{
-  nsStyleFont(const nsFont& aFont, const nsPresContext* aContext);
-  nsStyleFont(const nsStyleFont& aStyleFont);
-  explicit nsStyleFont(const nsPresContext* aContext);
-  ~nsStyleFont() {
-                               ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  nsChangeHint CalcDifference(const nsStyleFont& aNewData) const;
-
-
-
-
-
-
-  static nscoord ZoomText(const nsPresContext* aPresContext, nscoord aSize);
-
-
-
-
-
-  static nscoord UnZoomText(nsPresContext* aPresContext, nscoord aSize);
-  static already_AddRefed<nsIAtom> GetLanguage(const nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleFont* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleFont, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  void EnableZoom(nsPresContext* aContext, bool aEnable);
-
-  nsFont mFont;
-  nscoord mSize;
-
-
-
-
-
-  uint8_t mGenericID;
-
-
-
-  int8_t mScriptLevel;
-
-  uint8_t mMathVariant;
-
-  uint8_t mMathDisplay;
-
-
-  uint8_t mMinFontSizeRatio;
-
-
-  bool mExplicitLanguage;
-
-
-
-  bool mAllowZoom;
-
-
-  nscoord mScriptUnconstrainedSize;
-  nscoord mScriptMinSize;
-  float mScriptSizeMultiplier;
-  nsCOMPtr<nsIAtom> mLanguage;
-};
-
-struct nsStyleGradientStop
-{
-  nsStyleCoord mLocation;
-  nscolor mColor;
-  bool mIsInterpolationHint;
-
-
-  bool operator==(const nsStyleGradientStop&) const = delete;
-  bool operator!=(const nsStyleGradientStop&) const = delete;
-};
-
-class nsStyleGradient final
-{
-public:
-  nsStyleGradient();
-  uint8_t mShape;
-  uint8_t mSize;
-
-  bool mRepeating;
-  bool mLegacySyntax;
-
-  nsStyleCoord mBgPosX;
-  nsStyleCoord mBgPosY;
-  nsStyleCoord mAngle;
-
-  nsStyleCoord mRadiusX;
-  nsStyleCoord mRadiusY;
-
-
-  nsTArray<nsStyleGradientStop> mStops;
-
-  bool operator==(const nsStyleGradient& aOther) const;
-  bool operator!=(const nsStyleGradient& aOther) const {
-    return !(*this == aOther);
-  }
-
-  bool IsOpaque();
-  bool HasCalc();
-  uint32_t Hash(PLDHashNumber aHash);
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleGradient>::value, "Reference-counted class " "nsStyleGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-private:
-
-  ~nsStyleGradient() {}
-
-  nsStyleGradient(const nsStyleGradient& aOther) = delete;
-  nsStyleGradient& operator=(const nsStyleGradient& aOther) = delete;
-};
-# 305 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-class nsStyleImageRequest
-{
-public:
-
-
-
-
-  enum class Mode : uint8_t {
-
-
-
-
-
-
-
-    Track = 0x1,
-
-
-
-
-
-    Discard = 0x2,
-  };
-
-
-
-
-  nsStyleImageRequest(Mode aModeFlags,
-                      imgRequestProxy* aRequestProxy,
-                      mozilla::css::ImageValue* aImageValue,
-                      mozilla::dom::ImageTracker* aImageTracker);
-
-
-
-  nsStyleImageRequest(
-      Mode aModeFlags,
-      nsStringBuffer* aURLBuffer,
-      already_AddRefed<mozilla::css::URLExtraData> aExtraData);
-
-  bool Resolve(nsPresContext* aPresContext);
-  bool IsResolved() const { return mResolved; }
-
-  imgRequestProxy* get() {
-    do { } while (0);
-    do { } while (0);
-    return mRequestProxy.get();
-  }
-  const imgRequestProxy* get() const {
-    return const_cast<nsStyleImageRequest*>(this)->get();
-  }
-
-
-
-  bool DefinitelyEquals(const nsStyleImageRequest& aOther) const;
-
-  mozilla::css::ImageValue* GetImageValue() const { return mImageValue; }
-
-  already_AddRefed<nsIURI> GetImageURI() const;
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleImageRequest>::value, "Reference-counted class " "nsStyleImageRequest" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
-
-private:
-  ~nsStyleImageRequest();
-  nsStyleImageRequest& operator=(const nsStyleImageRequest& aOther) = delete;
-
-  void MaybeTrackAndLock();
-
-  RefPtr<imgRequestProxy> mRequestProxy;
-  RefPtr<mozilla::css::ImageValue> mImageValue;
-  RefPtr<mozilla::dom::ImageTracker> mImageTracker;
-
-
-  RefPtr<mozilla::dom::DocGroup> mDocGroup;
-
-  Mode mModeFlags;
-  bool mResolved;
-};
-
-inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator |(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) | U(b))); } inline nsStyleImageRequest::Mode& operator |=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a | b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator &(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) & U(b))); } inline nsStyleImageRequest::Mode& operator &=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a & b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator ^(nsStyleImageRequest::Mode a, nsStyleImageRequest::Mode b) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(U(a) ^ U(b))); } inline nsStyleImageRequest::Mode& operator ^=(nsStyleImageRequest::Mode& a, nsStyleImageRequest::Mode b) { return a = a ^ b; } inline constexpr mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> operator~(nsStyleImageRequest::Mode a) { typedef mozilla::CastableTypedEnumResult<nsStyleImageRequest::Mode> Result; typedef mozilla::detail::UnsignedIntegerTypeForEnum<nsStyleImageRequest::Mode>::Type U; return Result(nsStyleImageRequest::Mode(~(U(a)))); }
-
-enum nsStyleImageType {
-  eStyleImageType_Null,
-  eStyleImageType_Image,
-  eStyleImageType_Gradient,
-  eStyleImageType_Element
-};
-
-struct CachedBorderImageData
-{
-
-
-  void SetCachedSVGViewportSize(const mozilla::Maybe<nsSize>& aSVGViewportSize);
-  const mozilla::Maybe<nsSize>& GetCachedSVGViewportSize();
-  void PurgeCachedImages();
-  void SetSubImage(uint8_t aIndex, imgIContainer* aSubImage);
-  imgIContainer* GetSubImage(uint8_t aIndex);
-
-private:
-
-
-
-  mozilla::Maybe<nsSize> mCachedSVGViewportSize;
-  nsCOMArray<imgIContainer> mSubImages;
-};
-# 420 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-struct nsStyleImage
-{
-  nsStyleImage();
-  ~nsStyleImage();
-  nsStyleImage(const nsStyleImage& aOther);
-  nsStyleImage& operator=(const nsStyleImage& aOther);
-
-  void SetNull();
-  void SetImageRequest(already_AddRefed<nsStyleImageRequest> aImage);
-  void SetGradientData(nsStyleGradient* aGradient);
-  void SetElementId(const char16_t* aElementId);
-  void SetCropRect(mozilla::UniquePtr<nsStyleSides> aCropRect);
-
-  void ResolveImage(nsPresContext* aContext) {
-    do { } while (0);
-    if (mType == eStyleImageType_Image && !mImage->IsResolved()) {
-      mImage->Resolve(aContext);
-    }
-  }
-
-  nsStyleImageType GetType() const {
-    return mType;
-  }
-  nsStyleImageRequest* GetImageRequest() const {
-    do { } while (0);
-    do { } while (0);
-    return mImage;
-  }
-  imgRequestProxy* GetImageData() const {
-    return GetImageRequest()->get();
-  }
-  nsStyleGradient* GetGradientData() const {
-    do { } while(0);
-    return mGradient;
-  }
-  const char16_t* GetElementId() const {
-    do { } while(0);
-    return mElementId;
-  }
-  const mozilla::UniquePtr<nsStyleSides>& GetCropRect() const {
-    do { } while(0);
-
-    return mCropRect;
-  }
-
-  already_AddRefed<nsIURI> GetImageURI() const;
-# 476 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  bool ComputeActualCropRect(nsIntRect& aActualCropRect,
-                               bool* aIsEntireImage = nullptr) const;
-
-
-
-
-
-
-
-  bool StartDecoding() const;
-
-
-
-
-  bool IsOpaque() const;
-
-
-
-
-
-  bool IsComplete() const;
-
-
-
-
-
-  bool IsLoaded() const;
-
-
-
-
-  bool IsEmpty() const {
-
-
-
-
-
-
-
-    return mType == eStyleImageType_Null;
-  }
-
-  bool operator==(const nsStyleImage& aOther) const;
-  bool operator!=(const nsStyleImage& aOther) const {
-    return !(*this == aOther);
-  }
-
-  bool ImageDataEquals(const nsStyleImage& aOther) const
-  {
-    return GetType() == eStyleImageType_Image &&
-           aOther.GetType() == eStyleImageType_Image &&
-           GetImageData() == aOther.GetImageData();
-  }
-
-
-
-  inline void SetSubImage(uint8_t aIndex, imgIContainer* aSubImage) const;
-  inline imgIContainer* GetSubImage(uint8_t aIndex) const;
-  void PurgeCacheForViewportChange(
-    const mozilla::Maybe<nsSize>& aSVGViewportSize,
-    const bool aHasIntrinsicRatio) const;
-
-private:
-  void DoCopy(const nsStyleImage& aOther);
-  void EnsureCachedBIData() const;
-
-
-
-  mozilla::UniquePtr<CachedBorderImageData> mCachedBIData;
-
-  nsStyleImageType mType;
-  union {
-    nsStyleImageRequest* mImage;
-    nsStyleGradient* mGradient;
-    char16_t* mElementId;
-  };
-
-
-  mozilla::UniquePtr<nsStyleSides> mCropRect;
-};
-
-struct nsStyleColor
-{
-  explicit nsStyleColor(const nsPresContext* aContext);
-  nsStyleColor(const nsStyleColor& aOther);
-  ~nsStyleColor() {
-                                ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  nscolor CalcComplexColor(const mozilla::StyleComplexColor& aColor) const {
-    return mozilla::LinearBlendColors(aColor.mColor, mColor,
-                                      aColor.mForegroundRatio);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleColor& aNewData) const;
-
-  void* operator new(size_t sz, nsStyleColor* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleColor, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleColor();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleColor, this);
-  }
-
-
-
-  nscolor mColor;
-};
-
-struct nsStyleImageLayers {
-
-  enum {
-    shorthand = 0,
-    color,
-    image,
-    repeat,
-    positionX,
-    positionY,
-    clip,
-    origin,
-    size,
-    attachment,
-    maskMode,
-    composite
-  };
-
-  enum class LayerType : uint8_t {
-    Background = 0,
-    Mask
-  };
-
-  explicit nsStyleImageLayers(LayerType aType);
-  nsStyleImageLayers(const nsStyleImageLayers &aSource);
-  ~nsStyleImageLayers() {
-                                      ;
-  }
-
-  static bool IsInitialPositionForLayerType(mozilla::Position aPosition, LayerType aType);
-
-  struct Size;
-  friend struct Size;
-  struct Size {
-    struct Dimension : public nsStyleCoord::CalcValue {
-      nscoord ResolveLengthPercentage(nscoord aAvailable) const {
-        double d = double(mPercent) * double(aAvailable) + double(mLength);
-        if (d < 0.0) {
-          return 0;
-        }
-        return NSToCoordRoundWithClamp(float(d));
-      }
-    };
-    Dimension mWidth, mHeight;
-
-    bool IsInitialValue() const {
-      return mWidthType == eAuto && mHeightType == eAuto;
-    }
-
-    nscoord ResolveWidthLengthPercentage(const nsSize& aBgPositioningArea) const {
-      do { } while (0);
-
-      return mWidth.ResolveLengthPercentage(aBgPositioningArea.width);
-    }
-
-    nscoord ResolveHeightLengthPercentage(const nsSize& aBgPositioningArea) const {
-      do { } while (0);
-
-      return mHeight.ResolveLengthPercentage(aBgPositioningArea.height);
-    }
-
-
-
-
-
-    enum DimensionType {
-
-
-
-      eContain, eCover,
-
-      eAuto,
-      eLengthPercentage,
-      eDimensionType_COUNT
-    };
-    uint8_t mWidthType, mHeightType;
-
-
-
-
-    bool DependsOnPositioningAreaSize(const nsStyleImage& aImage) const;
-
-
-    Size() {}
-
-
-    void SetInitialValues();
-
-    bool operator==(const Size& aOther) const;
-    bool operator!=(const Size& aOther) const {
-      return !(*this == aOther);
-    }
-  };
-
-  struct Repeat;
-  friend struct Repeat;
-  struct Repeat {
-    uint8_t mXRepeat, mYRepeat;
-
-
-    Repeat() {}
-
-    bool IsInitialValue() const {
-      return mXRepeat == 0x03 &&
-             mYRepeat == 0x03;
-    }
-
-    bool DependsOnPositioningAreaSize() const {
-      return mXRepeat == 0x04 ||
-             mYRepeat == 0x04;
-    }
-
-
-    void SetInitialValues() {
-      mXRepeat = 0x03;
-      mYRepeat = 0x03;
-    }
-
-    bool operator==(const Repeat& aOther) const {
-      return mXRepeat == aOther.mXRepeat &&
-             mYRepeat == aOther.mYRepeat;
-    }
-    bool operator!=(const Repeat& aOther) const {
-      return !(*this == aOther);
-    }
-  };
-
-  struct Layer;
-  friend struct Layer;
-  struct Layer {
-    typedef mozilla::StyleGeometryBox StyleGeometryBox;
-
-    nsStyleImage mImage;
-    RefPtr<mozilla::css::URLValueData> mSourceURI;
-
-
-
-
-
-
-
-    mozilla::Position mPosition;
-    Size mSize;
-    StyleGeometryBox mClip;
-
-      StyleGeometryBox mOrigin;
-    uint8_t mAttachment;
-
-
-
-
-
-    uint8_t mBlendMode;
-
-
-
-
-
-    uint8_t mComposite;
-
-
-
-
-
-    uint8_t mMaskMode;
-
-
-
-
-
-    Repeat mRepeat;
-
-
-
-    Layer();
-    ~Layer();
-
-
-    void Initialize(LayerType aType);
-
-    void ResolveImage(nsPresContext* aContext) {
-      if (mImage.GetType() == eStyleImageType_Image) {
-        mImage.ResolveImage(aContext);
-      }
-    }
-
-
-
-
-
-
-    bool RenderingMightDependOnPositioningAreaSizeChange() const;
-
-
-    nsChangeHint CalcDifference(const Layer& aNewLayer) const;
-
-
-
-    bool operator==(const Layer& aOther) const;
-    bool operator!=(const Layer& aOther) const {
-      return !(*this == aOther);
-    }
-  };
-
-
-
-  uint32_t mAttachmentCount,
-           mClipCount,
-           mOriginCount,
-           mRepeatCount,
-           mPositionXCount,
-           mPositionYCount,
-           mImageCount,
-           mSizeCount,
-           mMaskModeCount,
-           mBlendModeCount,
-           mCompositeCount;
-# 816 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  nsStyleAutoArray<Layer> mLayers;
-
-  const Layer& BottomLayer() const { return mLayers[mImageCount - 1]; }
-
-  void ResolveImages(nsPresContext* aContext) {
-    for (uint32_t i = 0; i < mImageCount; ++i) {
-      mLayers[i].ResolveImage(aContext);
-    }
-  }
-
-  nsChangeHint CalcDifference(const nsStyleImageLayers& aNewLayers,
-                              nsStyleImageLayers::LayerType aType) const;
-
-  nsStyleImageLayers& operator=(const nsStyleImageLayers& aOther);
-  nsStyleImageLayers& operator=(nsStyleImageLayers&& aOther);
-  bool operator==(const nsStyleImageLayers& aOther) const;
-
-  static const nsCSSPropertyID kBackgroundLayerTable[];
-  static const nsCSSPropertyID kMaskLayerTable[];
-
-
-
-
-
-
-
-};
-
-struct nsStyleBackground {
-  explicit nsStyleBackground(const nsPresContext* aContext);
-  nsStyleBackground(const nsStyleBackground& aOther);
-  ~nsStyleBackground();
-
-
-
-
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleBackground* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleBackground, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStyleBackground& aNewData) const;
-
-
-  nscolor BackgroundColor(const nsIFrame* aFrame) const;
-  nscolor BackgroundColor(nsStyleContext* aContext) const;
-
-
-  bool IsTransparent(const nsIFrame* aFrame) const;
-  bool IsTransparent(nsStyleContext* aContext) const;
-
-
-
-
-
-  bool HasFixedBackground(nsIFrame* aFrame) const;
-
-
-
-  inline bool HasLocalBackground() const;
-
-  const nsStyleImageLayers::Layer& BottomLayer() const { return mImage.BottomLayer(); }
-
-  nsStyleImageLayers mImage;
-  mozilla::StyleComplexColor mBackgroundColor;
-};
-
-
-
-
-
-
-struct nsStyleMargin
-{
-  explicit nsStyleMargin(const nsPresContext* aContext);
-  nsStyleMargin(const nsStyleMargin& aMargin);
-  ~nsStyleMargin() {
-                                 ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleMargin* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleMargin, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStyleMargin& aNewData) const;
-
-  bool GetMargin(nsMargin& aMargin) const
-  {
-    if (!mMargin.ConvertsToLength()) {
-      return false;
-    }
-
-    int32_t side916 = mozilla::eSideTop; for (mozilla::Side side; side916 <= mozilla::eSideLeft && ((side = mozilla::Side(side916)), true); ++side916) {
-      aMargin.Side(side) = mMargin.ToLength(side);
-    }
-    return true;
-  }
-
-
-
-  inline bool HasBlockAxisAuto(mozilla::WritingMode aWM) const;
-  inline bool HasInlineAxisAuto(mozilla::WritingMode aWM) const;
-
-  nsStyleSides mMargin;
-};
-
-struct nsStylePadding
-{
-  explicit nsStylePadding(const nsPresContext* aContext);
-  nsStylePadding(const nsStylePadding& aPadding);
-  ~nsStylePadding() {
-                                  ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStylePadding* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStylePadding, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStylePadding& aNewData) const;
-
-  nsStyleSides mPadding;
-
-  bool IsWidthDependent() const {
-    return !mPadding.ConvertsToLength();
-  }
-
-  bool GetPadding(nsMargin& aPadding) const
-  {
-    if (!mPadding.ConvertsToLength()) {
-      return false;
-    }
-
-    int32_t side960 = mozilla::eSideTop; for (mozilla::Side side; side960 <= mozilla::eSideLeft && ((side = mozilla::Side(side960)), true); ++side960) {
-
-      aPadding.Side(side) = std::max(mPadding.ToLength(side), 0);
-    }
-    return true;
-  }
-};
-
-struct nsBorderColors
-{
-  nsBorderColors* mNext;
-  nscolor mColor;
-
-  nsBorderColors() : mNext(nullptr), mColor(((nscolor) ((255 << 24) | ((0)<<16) | ((0)<<8) | (0)))) {}
-  explicit nsBorderColors(const nscolor& aColor) : mNext(nullptr), mColor(aColor) {}
-  ~nsBorderColors();
-
-  nsBorderColors* Clone() const { return Clone(true); }
-
-  static bool Equal(const nsBorderColors* c1,
-                      const nsBorderColors* c2) {
-    if (c1 == c2) {
-      return true;
-    }
-    while (c1 && c2) {
-      if (c1->mColor != c2->mColor) {
-        return false;
-      }
-      c1 = c1->mNext;
-      c2 = c2->mNext;
-    }
-
-
-    return !c1 && !c2;
-  }
-
-private:
-  nsBorderColors* Clone(bool aDeep) const;
-};
-
-struct nsCSSShadowItem
-{
-  nscoord mXOffset;
-  nscoord mYOffset;
-  nscoord mRadius;
-  nscoord mSpread;
-
-  nscolor mColor;
-  bool mHasColor;
-  bool mInset;
-
-  nsCSSShadowItem() : mHasColor(false) {
-                                   ;
-  }
-  ~nsCSSShadowItem() {
-                                   ;
-  }
-
-  bool operator==(const nsCSSShadowItem& aOther) const {
-    return (mXOffset == aOther.mXOffset &&
-            mYOffset == aOther.mYOffset &&
-            mRadius == aOther.mRadius &&
-            mHasColor == aOther.mHasColor &&
-            mSpread == aOther.mSpread &&
-            mInset == aOther.mInset &&
-            (!mHasColor || mColor == aOther.mColor));
-  }
-  bool operator!=(const nsCSSShadowItem& aOther) const {
-    return !(*this == aOther);
-  }
-};
-
-class nsCSSShadowArray final
-{
-public:
-  void* operator new(size_t aBaseSize, uint32_t aArrayLen) {
-
-
-
-
-
-    return ::operator new(aBaseSize +
-                          (aArrayLen - 1) * sizeof(nsCSSShadowItem));
-  }
-
-  explicit nsCSSShadowArray(uint32_t aArrayLen) :
-    mLength(aArrayLen)
-  {
-    for (uint32_t i = 1; i < mLength; ++i) {
-
-
-      new (&mArray[i]) nsCSSShadowItem();
-    }
-  }
-
-private:
-
-  ~nsCSSShadowArray() {
-    for (uint32_t i = 1; i < mLength; ++i) {
-      mArray[i].~nsCSSShadowItem();
-    }
-  }
-
-public:
-  uint32_t Length() const { return mLength; }
-  nsCSSShadowItem* ShadowAt(uint32_t i) {
-    do { } while (0);
-    return &mArray[i];
-  }
-  const nsCSSShadowItem* ShadowAt(uint32_t i) const {
-    do { } while (0);
-    return &mArray[i];
-  }
-
-  bool HasShadowWithInset(bool aInset) {
-    for (uint32_t i = 0; i < mLength; ++i) {
-      if (mArray[i].mInset == aInset) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool operator==(const nsCSSShadowArray& aOther) const {
-    if (mLength != aOther.Length()) {
-      return false;
-    }
-
-    for (uint32_t i = 0; i < mLength; ++i) {
-      if (ShadowAt(i) != aOther.ShadowAt(i)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSShadowArray>::value, "Reference-counted class " "nsCSSShadowArray" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
-
-private:
-  uint32_t mLength;
-  nsCSSShadowItem mArray[1];
-};
-# 1118 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-static bool IsVisibleBorderStyle(uint8_t aStyle)
-{
-  return (aStyle != 0 &&
-          aStyle != 9);
-}
-
-struct nsStyleBorder
-{
-  explicit nsStyleBorder(const nsPresContext* aContext);
-  nsStyleBorder(const nsStyleBorder& aBorder);
-  ~nsStyleBorder();
-
-
-
-
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleBorder* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleBorder, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStyleBorder& aNewData) const;
-
-  void EnsureBorderColors() {
-    if (!mBorderColors) {
-      mBorderColors = new nsBorderColors*[4];
-      if (mBorderColors) {
-        for (int32_t i = 0; i < 4; i++) {
-          mBorderColors[i] = nullptr;
-        }
-      }
-    }
-  }
-
-  void ClearBorderColors(mozilla::Side aSide) {
-    if (mBorderColors && mBorderColors[aSide]) {
-      delete mBorderColors[aSide];
-      mBorderColors[aSide] = nullptr;
-    }
-  }
-
-
-
-
-
-
-  bool HasVisibleStyle(mozilla::Side aSide) const
-  {
-    return IsVisibleBorderStyle(mBorderStyle[aSide]);
-  }
-
-
-  void SetBorderWidth(mozilla::Side aSide, nscoord aBorderWidth)
-  {
-    nscoord roundedWidth =
-      ((aBorderWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aBorderWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));
-    mBorder.Side(aSide) = roundedWidth;
-    if (HasVisibleStyle(aSide)) {
-      mComputedBorder.Side(aSide) = roundedWidth;
-    }
-  }
-
-
-
-
-  const nsMargin& GetComputedBorder() const
-  {
-    return mComputedBorder;
-  }
-
-  bool HasBorder() const
-  {
-    return mComputedBorder != nsMargin(0,0,0,0) || !mBorderImageSource.IsEmpty();
-  }
-
-
-
-
-
-  nscoord GetComputedBorderWidth(mozilla::Side aSide) const
-  {
-    return GetComputedBorder().Side(aSide);
-  }
-
-  uint8_t GetBorderStyle(mozilla::Side aSide) const
-  {
-    do { } while(0);
-    return mBorderStyle[aSide];
-  }
-
-  void SetBorderStyle(mozilla::Side aSide, uint8_t aStyle)
-  {
-    do { } while(0);
-    mBorderStyle[aSide] = aStyle;
-    mComputedBorder.Side(aSide) =
-      (HasVisibleStyle(aSide) ? mBorder.Side(aSide) : 0);
-  }
-
-  inline bool IsBorderImageLoaded() const
-  {
-    return mBorderImageSource.IsLoaded();
-  }
-
-  void ResolveImage(nsPresContext* aContext)
-  {
-    if (mBorderImageSource.GetType() == eStyleImageType_Image) {
-      mBorderImageSource.ResolveImage(aContext);
-    }
-  }
-
-  nsMargin GetImageOutset() const;
-
-  void GetCompositeColors(int32_t aIndex, nsBorderColors** aColors) const
-  {
-    if (!mBorderColors) {
-      *aColors = nullptr;
-    } else {
-      *aColors = mBorderColors[aIndex];
-    }
-  }
-
-  void AppendBorderColor(int32_t aIndex, nscolor aColor)
-  {
-    do { } while(0);
-    nsBorderColors* colorEntry = new nsBorderColors(aColor);
-    if (!mBorderColors[aIndex]) {
-      mBorderColors[aIndex] = colorEntry;
-    } else {
-      nsBorderColors* last = mBorderColors[aIndex];
-      while (last->mNext) {
-        last = last->mNext;
-      }
-      last->mNext = colorEntry;
-    }
-  }
-
-  imgIRequest* GetBorderImageRequest() const
-  {
-    if (mBorderImageSource.GetType() == eStyleImageType_Image) {
-      return mBorderImageSource.GetImageData();
-    }
-    return nullptr;
-  }
-
-public:
-  nsBorderColors** mBorderColors;
-  nsStyleCorners mBorderRadius;
-  nsStyleImage mBorderImageSource;
-  nsStyleSides mBorderImageSlice;
-  nsStyleSides mBorderImageWidth;
-  nsStyleSides mBorderImageOutset;
-
-  uint8_t mBorderImageFill;
-  uint8_t mBorderImageRepeatH;
-  uint8_t mBorderImageRepeatV;
-  mozilla::StyleFloatEdge mFloatEdge;
-  mozilla::StyleBoxDecorationBreak mBoxDecorationBreak;
-
-protected:
-  uint8_t mBorderStyle[4];
-
-public:
-
-
-  union {
-    struct {
-      mozilla::StyleComplexColor mBorderTopColor;
-      mozilla::StyleComplexColor mBorderRightColor;
-      mozilla::StyleComplexColor mBorderBottomColor;
-      mozilla::StyleComplexColor mBorderLeftColor;
-    };
-    mozilla::StyleComplexColor mBorderColor[4];
-  };
-
-  static mozilla::StyleComplexColor nsStyleBorder::*
-  BorderColorFieldFor(mozilla::Side aSide) {
-    switch (aSide) {
-      case mozilla::eSideTop:
-        return &nsStyleBorder::mBorderTopColor;
-      case mozilla::eSideRight:
-        return &nsStyleBorder::mBorderRightColor;
-      case mozilla::eSideBottom:
-        return &nsStyleBorder::mBorderBottomColor;
-      case mozilla::eSideLeft:
-        return &nsStyleBorder::mBorderLeftColor;
-    }
-    do { } while (0);
-    return nullptr;
-  }
-
-protected:
-
-
-
-
-
-
-  nsMargin mComputedBorder;
-# 1331 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  nsMargin mBorder;
-
-private:
-  nscoord mTwipsPerPixel;
-
-  nsStyleBorder& operator=(const nsStyleBorder& aOther) = delete;
-};
-# 1346 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-static_assert(__builtin_offsetof(nsStyleBorder, mBorderTopColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideTop) * sizeof(mozilla::StyleComplexColor), "mBorder" "Top" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Top" "]");
-static_assert(__builtin_offsetof(nsStyleBorder, mBorderRightColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideRight) * sizeof(mozilla::StyleComplexColor), "mBorder" "Right" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Right" "]");
-static_assert(__builtin_offsetof(nsStyleBorder, mBorderBottomColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideBottom) * sizeof(mozilla::StyleComplexColor), "mBorder" "Bottom" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Bottom" "]");
-static_assert(__builtin_offsetof(nsStyleBorder, mBorderLeftColor) == __builtin_offsetof(nsStyleBorder, mBorderColor) + size_t(mozilla::eSideLeft) * sizeof(mozilla::StyleComplexColor), "mBorder" "Left" "Color must be at same offset " "as mBorderColor[mozilla::eSide" "Left" "]");
-
-
-
-struct nsStyleOutline
-{
-  explicit nsStyleOutline(const nsPresContext* aContext);
-  nsStyleOutline(const nsStyleOutline& aOutline);
-  ~nsStyleOutline() {
-                                  ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleOutline* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleOutline, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleOutline();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleOutline, this);
-  }
-
-  void RecalcData();
-  nsChangeHint CalcDifference(const nsStyleOutline& aNewData) const;
-
-  nsStyleCorners mOutlineRadius;
-
-
-
-
-
-
-  nscoord mOutlineWidth;
-  nscoord mOutlineOffset;
-  mozilla::StyleComplexColor mOutlineColor;
-  uint8_t mOutlineStyle;
-
-  nscoord GetOutlineWidth() const
-  {
-    return mActualOutlineWidth;
-  }
-
-  bool ShouldPaintOutline() const
-  {
-    return mOutlineStyle == 10 ||
-           (GetOutlineWidth() > 0 &&
-            mOutlineStyle != 0);
-  }
-
-protected:
-
-
-
-  nscoord mActualOutlineWidth;
-  nscoord mTwipsPerPixel;
-};
-
-
-
-
-
-
-
-class nsStyleQuoteValues
-{
-public:
-  typedef nsTArray<std::pair<nsString, nsString>> QuotePairArray;
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleQuoteValues>::value, "Reference-counted class " "nsStyleQuoteValues" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
-  QuotePairArray mQuotePairs;
-
-private:
-  ~nsStyleQuoteValues() {}
-};
-
-struct nsStyleList
-{
-  explicit nsStyleList(const nsPresContext* aContext);
-  nsStyleList(const nsStyleList& aStyleList);
-  ~nsStyleList();
-
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleList* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleList, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleList();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleList, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleList& aNewData) const;
-
-  static void Shutdown() {
-    sInitialQuotes = nullptr;
-    sNoneQuotes = nullptr;
-  }
-
-  imgRequestProxy* GetListStyleImage() const
-  {
-    return mListStyleImage ? mListStyleImage->get() : nullptr;
-  }
-
-  already_AddRefed<nsIURI> GetListStyleImageURI() const;
-
-  void GetListStyleType(nsSubstring& aType) const { mCounterStyle->GetStyleName(aType); }
-  mozilla::CounterStyle* GetCounterStyle() const
-  {
-    return mCounterStyle.get();
-  }
-  void SetCounterStyle(mozilla::CounterStyle* aStyle)
-  {
-
-
-    do { } while (0);
-    mCounterStyle = aStyle;
-  }
-  void SetListStyleType(const nsSubstring& aType,
-                        nsPresContext* aPresContext)
-  {
-    SetCounterStyle(aPresContext->CounterStyleManager()->BuildCounterStyle(aType));
-  }
-
-  const nsStyleQuoteValues::QuotePairArray& GetQuotePairs() const;
-
-  void SetQuotesInherit(const nsStyleList* aOther);
-  void SetQuotesInitial();
-  void SetQuotesNone();
-  void SetQuotes(nsStyleQuoteValues::QuotePairArray&& aValues);
-
-  uint8_t mListStylePosition;
-  RefPtr<nsStyleImageRequest> mListStyleImage;
-private:
-  RefPtr<mozilla::CounterStyle> mCounterStyle;
-  RefPtr<nsStyleQuoteValues> mQuotes;
-  nsStyleList& operator=(const nsStyleList& aOther) = delete;
-public:
-  nsRect mImageRegion;
-
-private:
-
-  static mozilla::StaticRefPtr<nsStyleQuoteValues> sInitialQuotes;
-  static mozilla::StaticRefPtr<nsStyleQuoteValues> sNoneQuotes;
-};
-
-struct nsStyleGridLine
-{
-
-
-  bool mHasSpan;
-  int32_t mInteger;
-  nsString mLineName;
-
-
-
-
-  static const int32_t kMinLine = -10000;
-  static const int32_t kMaxLine = 10000;
-
-  nsStyleGridLine()
-    : mHasSpan(false)
-    , mInteger(0)
-
-  {
-  }
-
-  nsStyleGridLine(const nsStyleGridLine& aOther)
-  {
-    (*this) = aOther;
-  }
-
-  void operator=(const nsStyleGridLine& aOther)
-  {
-    mHasSpan = aOther.mHasSpan;
-    mInteger = aOther.mInteger;
-    mLineName = aOther.mLineName;
-  }
-
-  bool operator!=(const nsStyleGridLine& aOther) const
-  {
-    return mHasSpan != aOther.mHasSpan ||
-           mInteger != aOther.mInteger ||
-           mLineName != aOther.mLineName;
-  }
-
-  void SetToInteger(uint32_t value)
-  {
-    mHasSpan = false;
-    mInteger = value;
-    mLineName.Truncate();
-  }
-
-  void SetAuto()
-  {
-    mHasSpan = false;
-    mInteger = 0;
-    mLineName.Truncate();
-  }
-
-  bool IsAuto() const
-  {
-    bool haveInitialValues = mInteger == 0 && mLineName.IsEmpty();
-    do { } while (0);
-
-
-    return haveInitialValues;
-  }
-};
-# 1602 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-struct nsStyleGridTemplate
-{
-  nsTArray<nsTArray<nsString>> mLineNameLists;
-  nsTArray<nsStyleCoord> mMinTrackSizingFunctions;
-  nsTArray<nsStyleCoord> mMaxTrackSizingFunctions;
-  nsTArray<nsString> mRepeatAutoLineNameListBefore;
-  nsTArray<nsString> mRepeatAutoLineNameListAfter;
-  int16_t mRepeatAutoIndex;
-  bool mIsAutoFill : 1;
-  bool mIsSubgrid : 1;
-
-  nsStyleGridTemplate()
-    : mRepeatAutoIndex(-1)
-    , mIsAutoFill(false)
-    , mIsSubgrid(false)
-  {
-  }
-
-  inline bool operator!=(const nsStyleGridTemplate& aOther) const {
-    return
-      mIsSubgrid != aOther.mIsSubgrid ||
-      mLineNameLists != aOther.mLineNameLists ||
-      mMinTrackSizingFunctions != aOther.mMinTrackSizingFunctions ||
-      mMaxTrackSizingFunctions != aOther.mMaxTrackSizingFunctions ||
-      mIsAutoFill != aOther.mIsAutoFill ||
-      mRepeatAutoIndex != aOther.mRepeatAutoIndex ||
-      mRepeatAutoLineNameListBefore != aOther.mRepeatAutoLineNameListBefore ||
-      mRepeatAutoLineNameListAfter != aOther.mRepeatAutoLineNameListAfter;
-  }
-
-  bool HasRepeatAuto() const {
-    return mRepeatAutoIndex != -1;
-  }
-
-  bool IsRepeatAutoIndex(uint32_t aIndex) const {
-    do { } while (0);
-    return int32_t(aIndex) == mRepeatAutoIndex;
-  }
-};
-
-struct nsStylePosition
-{
-  explicit nsStylePosition(const nsPresContext* aContext);
-  nsStylePosition(const nsStylePosition& aOther);
-  ~nsStylePosition();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStylePosition* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStylePosition, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStylePosition();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStylePosition, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStylePosition& aNewData,
-                              const nsStyleVisibility* aOldStyleVisibility) const;
-
-
-
-
-
-  uint8_t UsedAlignSelf(nsStyleContext* aParent) const;
-
-
-
-
-
-  uint8_t ComputedJustifyItems(nsStyleContext* aParent) const;
-
-
-
-
-
-  uint8_t UsedJustifySelf(nsStyleContext* aParent) const;
-
-  mozilla::Position mObjectPosition;
-  nsStyleSides mOffset;
-  nsStyleCoord mWidth;
-  nsStyleCoord mMinWidth;
-  nsStyleCoord mMaxWidth;
-  nsStyleCoord mHeight;
-  nsStyleCoord mMinHeight;
-  nsStyleCoord mMaxHeight;
-  nsStyleCoord mFlexBasis;
-  nsStyleCoord mGridAutoColumnsMin;
-  nsStyleCoord mGridAutoColumnsMax;
-  nsStyleCoord mGridAutoRowsMin;
-  nsStyleCoord mGridAutoRowsMax;
-  uint8_t mGridAutoFlow;
-  mozilla::StyleBoxSizing mBoxSizing;
-
-  uint16_t mAlignContent;
-  uint8_t mAlignItems;
-  uint8_t mAlignSelf;
-  uint16_t mJustifyContent;
-private:
-  friend class nsRuleNode;
-
-
-
-
-  uint8_t mJustifyItems;
-public:
-  uint8_t mJustifySelf;
-  uint8_t mFlexDirection;
-  uint8_t mFlexWrap;
-  uint8_t mObjectFit;
-  int32_t mOrder;
-  float mFlexGrow;
-  float mFlexShrink;
-  nsStyleCoord mZIndex;
-  nsStyleGridTemplate mGridTemplateColumns;
-  nsStyleGridTemplate mGridTemplateRows;
-
-
-  RefPtr<mozilla::css::GridTemplateAreasValue> mGridTemplateAreas;
-
-  nsStyleGridLine mGridColumnStart;
-  nsStyleGridLine mGridColumnEnd;
-  nsStyleGridLine mGridRowStart;
-  nsStyleGridLine mGridRowEnd;
-  nsStyleCoord mGridColumnGap;
-  nsStyleCoord mGridRowGap;
-
-
-
-
-
-
-  bool WidthDependsOnContainer() const
-    {
-      return mWidth.GetUnit() == eStyleUnit_Auto ||
-        WidthCoordDependsOnContainer(mWidth);
-    }
-# 1749 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  bool MinWidthDependsOnContainer() const
-    { return WidthCoordDependsOnContainer(mMinWidth); }
-  bool MaxWidthDependsOnContainer() const
-    { return WidthCoordDependsOnContainer(mMaxWidth); }
-# 1761 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  bool HeightDependsOnContainer() const
-    {
-      return mHeight.GetUnit() == eStyleUnit_Auto ||
-        HeightCoordDependsOnContainer(mHeight);
-    }
-
-
-
-  bool MinHeightDependsOnContainer() const
-    { return HeightCoordDependsOnContainer(mMinHeight); }
-  bool MaxHeightDependsOnContainer() const
-    { return HeightCoordDependsOnContainer(mMaxHeight); }
-
-  bool OffsetHasPercent(mozilla::Side aSide) const
-  {
-    return mOffset.Get(aSide).HasPercent();
-  }
-
-
-
-
-
-  inline nsStyleCoord& ISize(mozilla::WritingMode aWM);
-  inline nsStyleCoord& MinISize(mozilla::WritingMode aWM);
-  inline nsStyleCoord& MaxISize(mozilla::WritingMode aWM);
-  inline nsStyleCoord& BSize(mozilla::WritingMode aWM);
-  inline nsStyleCoord& MinBSize(mozilla::WritingMode aWM);
-  inline nsStyleCoord& MaxBSize(mozilla::WritingMode aWM);
-  inline const nsStyleCoord& ISize(mozilla::WritingMode aWM) const;
-  inline const nsStyleCoord& MinISize(mozilla::WritingMode aWM) const;
-  inline const nsStyleCoord& MaxISize(mozilla::WritingMode aWM) const;
-  inline const nsStyleCoord& BSize(mozilla::WritingMode aWM) const;
-  inline const nsStyleCoord& MinBSize(mozilla::WritingMode aWM) const;
-  inline const nsStyleCoord& MaxBSize(mozilla::WritingMode aWM) const;
-  inline bool ISizeDependsOnContainer(mozilla::WritingMode aWM) const;
-  inline bool MinISizeDependsOnContainer(mozilla::WritingMode aWM) const;
-  inline bool MaxISizeDependsOnContainer(mozilla::WritingMode aWM) const;
-  inline bool BSizeDependsOnContainer(mozilla::WritingMode aWM) const;
-  inline bool MinBSizeDependsOnContainer(mozilla::WritingMode aWM) const;
-  inline bool MaxBSizeDependsOnContainer(mozilla::WritingMode aWM) const;
-
-private:
-  static bool WidthCoordDependsOnContainer(const nsStyleCoord &aCoord);
-  static bool HeightCoordDependsOnContainer(const nsStyleCoord &aCoord)
-    { return aCoord.HasPercent(); }
-};
-
-struct nsStyleTextOverflowSide
-{
-  nsStyleTextOverflowSide() : mType(0) {}
-
-  bool operator==(const nsStyleTextOverflowSide& aOther) const {
-    return mType == aOther.mType &&
-           (mType != 2 ||
-            mString == aOther.mString);
-  }
-  bool operator!=(const nsStyleTextOverflowSide& aOther) const {
-    return !(*this == aOther);
-  }
-
-  nsString mString;
-  uint8_t mType;
-};
-
-struct nsStyleTextOverflow
-{
-  nsStyleTextOverflow() : mLogicalDirections(true) {}
-  bool operator==(const nsStyleTextOverflow& aOther) const {
-    return mLeft == aOther.mLeft && mRight == aOther.mRight;
-  }
-  bool operator!=(const nsStyleTextOverflow& aOther) const {
-    return !(*this == aOther);
-  }
-
-
-  const nsStyleTextOverflowSide& GetLeft(uint8_t aDirection) const {
-    do { } while(0);
-
-    return !mLogicalDirections || aDirection == 0 ?
-             mLeft : mRight;
-  }
-
-
-  const nsStyleTextOverflowSide& GetRight(uint8_t aDirection) const {
-    do { } while(0);
-
-    return !mLogicalDirections || aDirection == 0 ?
-             mRight : mLeft;
-  }
-
-
-  const nsStyleTextOverflowSide* GetFirstValue() const {
-    return mLogicalDirections ? &mRight : &mLeft;
-  }
-
-
-  const nsStyleTextOverflowSide* GetSecondValue() const {
-    return mLogicalDirections ? nullptr : &mRight;
-  }
-
-  nsStyleTextOverflowSide mLeft;
-  nsStyleTextOverflowSide mRight;
-  bool mLogicalDirections;
-};
-
-struct nsStyleTextReset
-{
-  explicit nsStyleTextReset(const nsPresContext* aContext);
-  nsStyleTextReset(const nsStyleTextReset& aOther);
-  ~nsStyleTextReset();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleTextReset* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTextReset, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleTextReset();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTextReset, this);
-  }
-
-
-
-  bool HasTextDecorationLines() const {
-    return mTextDecorationLine != 0 &&
-           mTextDecorationLine != 0x20;
-  }
-
-  nsChangeHint CalcDifference(const nsStyleTextReset& aNewData) const;
-
-  nsStyleTextOverflow mTextOverflow;
-
-  uint8_t mTextDecorationLine;
-  uint8_t mTextDecorationStyle;
-  uint8_t mUnicodeBidi;
-  nscoord mInitialLetterSink;
-  float mInitialLetterSize;
-  mozilla::StyleComplexColor mTextDecorationColor;
-};
-
-struct nsStyleText
-{
-  explicit nsStyleText(const nsPresContext* aContext);
-  nsStyleText(const nsStyleText& aOther);
-  ~nsStyleText();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleText* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleText, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleText();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleText, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleText& aNewData) const;
-
-  uint8_t mTextAlign;
-  uint8_t mTextAlignLast;
-  bool mTextAlignTrue : 1;
-  bool mTextAlignLastTrue : 1;
-  mozilla::StyleTextJustify mTextJustify;
-  uint8_t mTextTransform;
-  uint8_t mWhiteSpace;
-  uint8_t mWordBreak;
-  uint8_t mOverflowWrap;
-  mozilla::StyleHyphens mHyphens;
-  uint8_t mRubyAlign;
-  uint8_t mRubyPosition;
-  uint8_t mTextSizeAdjust;
-  uint8_t mTextCombineUpright;
-  uint8_t mControlCharacterVisibility;
-  uint8_t mTextEmphasisPosition;
-  uint8_t mTextEmphasisStyle;
-  uint8_t mTextRendering;
-  mozilla::StyleComplexColor mTextEmphasisColor;
-  mozilla::StyleComplexColor mWebkitTextFillColor;
-  mozilla::StyleComplexColor mWebkitTextStrokeColor;
-
-  nsStyleCoord mTabSize;
-  nsStyleCoord mWordSpacing;
-  nsStyleCoord mLetterSpacing;
-  nsStyleCoord mLineHeight;
-  nsStyleCoord mTextIndent;
-  nscoord mWebkitTextStrokeWidth;
-
-  RefPtr<nsCSSShadowArray> mTextShadow;
-
-  nsString mTextEmphasisStyleString;
-
-  bool WhiteSpaceIsSignificant() const {
-    return mWhiteSpace == 1 ||
-           mWhiteSpace == 3 ||
-           mWhiteSpace == 5;
-  }
-
-  bool NewlineIsSignificantStyle() const {
-    return mWhiteSpace == 1 ||
-           mWhiteSpace == 3 ||
-           mWhiteSpace == 4;
-  }
-
-  bool WhiteSpaceOrNewlineIsSignificant() const {
-    return mWhiteSpace == 1 ||
-           mWhiteSpace == 3 ||
-           mWhiteSpace == 4 ||
-           mWhiteSpace == 5;
-  }
-
-  bool TabIsSignificant() const {
-    return mWhiteSpace == 1 ||
-           mWhiteSpace == 3;
-  }
-
-  bool WhiteSpaceCanWrapStyle() const {
-    return mWhiteSpace == 0 ||
-           mWhiteSpace == 3 ||
-           mWhiteSpace == 4;
-  }
-
-  bool WordCanWrapStyle() const {
-    return WhiteSpaceCanWrapStyle() &&
-           mOverflowWrap == 1;
-  }
-
-  bool HasTextEmphasis() const {
-    return !mTextEmphasisStyleString.IsEmpty();
-  }
-
-  bool HasWebkitTextStroke() const {
-    return mWebkitTextStrokeWidth > 0;
-  }
-
-
-  inline bool HasTextShadow() const;
-  inline nsCSSShadowArray* GetTextShadow() const;
-
-
-
-
-
-  inline bool NewlineIsSignificant(const nsTextFrame* aContextFrame) const;
-  inline bool WhiteSpaceCanWrap(const nsIFrame* aContextFrame) const;
-  inline bool WordCanWrap(const nsIFrame* aContextFrame) const;
-
-  mozilla::LogicalSide TextEmphasisSide(mozilla::WritingMode aWM) const;
-};
-
-struct nsStyleImageOrientation
-{
-  static nsStyleImageOrientation CreateAsAngleAndFlip(double aRadians,
-                                                      bool aFlip) {
-    uint8_t orientation(0);
-
-
-    double roundedAngle = fmod(aRadians, 2 * 3.14159265358979323846);
-    if (roundedAngle < 0.25 * 3.14159265358979323846) { orientation = ANGLE_0; }
-    else if (roundedAngle < 0.75 * 3.14159265358979323846) { orientation = ANGLE_90; }
-    else if (roundedAngle < 1.25 * 3.14159265358979323846) { orientation = ANGLE_180;}
-    else if (roundedAngle < 1.75 * 3.14159265358979323846) { orientation = ANGLE_270;}
-    else { orientation = ANGLE_0; }
-
-
-    if (aFlip) {
-      orientation |= FLIP_MASK;
-    }
-
-    return nsStyleImageOrientation(orientation);
-  }
-
-  static nsStyleImageOrientation CreateAsFlip() {
-    return nsStyleImageOrientation(FLIP_MASK);
-  }
-
-  static nsStyleImageOrientation CreateAsFromImage() {
-    return nsStyleImageOrientation(FROM_IMAGE_MASK);
-  }
-
-
-  nsStyleImageOrientation() : mOrientation(0) { }
-
-  bool IsDefault() const { return mOrientation == 0; }
-  bool IsFlipped() const { return mOrientation & FLIP_MASK; }
-  bool IsFromImage() const { return mOrientation & FROM_IMAGE_MASK; }
-  bool SwapsWidthAndHeight() const {
-    uint8_t angle = mOrientation & ORIENTATION_MASK;
-    return (angle == ANGLE_90) || (angle == ANGLE_270);
-  }
-
-  mozilla::image::Angle Angle() const {
-    switch (mOrientation & ORIENTATION_MASK) {
-      case ANGLE_0: return mozilla::image::Angle::D0;
-      case ANGLE_90: return mozilla::image::Angle::D90;
-      case ANGLE_180: return mozilla::image::Angle::D180;
-      case ANGLE_270: return mozilla::image::Angle::D270;
-      default:
-        do { } while(0);
-        return mozilla::image::Angle::D0;
-    }
-  }
-
-  nsStyleCoord AngleAsCoord() const {
-    switch (mOrientation & ORIENTATION_MASK) {
-      case ANGLE_0: return nsStyleCoord(0.0f, eStyleUnit_Degree);
-      case ANGLE_90: return nsStyleCoord(90.0f, eStyleUnit_Degree);
-      case ANGLE_180: return nsStyleCoord(180.0f, eStyleUnit_Degree);
-      case ANGLE_270: return nsStyleCoord(270.0f, eStyleUnit_Degree);
-      default:
-        do { } while(0);
-        return nsStyleCoord();
-    }
-  }
-
-  bool operator==(const nsStyleImageOrientation& aOther) const {
-    return aOther.mOrientation == mOrientation;
-  }
-
-  bool operator!=(const nsStyleImageOrientation& aOther) const {
-    return !(*this == aOther);
-  }
-
-protected:
-  enum Bits {
-    ORIENTATION_MASK = 0x1 | 0x2,
-    FLIP_MASK = 0x4,
-    FROM_IMAGE_MASK = 0x8,
-  };
-
-  enum Angles {
-    ANGLE_0 = 0,
-    ANGLE_90 = 1,
-    ANGLE_180 = 2,
-    ANGLE_270 = 3,
-  };
-
-  explicit nsStyleImageOrientation(uint8_t aOrientation)
-    : mOrientation(aOrientation)
-  { }
-
-  uint8_t mOrientation;
-};
-
-struct nsStyleVisibility
-{
-  explicit nsStyleVisibility(const nsPresContext* aContext);
-  nsStyleVisibility(const nsStyleVisibility& aVisibility);
-  ~nsStyleVisibility() {
-                                     ;
-  }
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleVisibility* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleVisibility, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleVisibility();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleVisibility, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleVisibility& aNewData) const;
-
-  nsStyleImageOrientation mImageOrientation;
-  uint8_t mDirection;
-  uint8_t mVisible;
-  uint8_t mImageRendering;
-  uint8_t mWritingMode;
-  uint8_t mTextOrientation;
-  uint8_t mColorAdjust;
-
-  bool IsVisible() const {
-    return (mVisible == 1);
-  }
-
-  bool IsVisibleOrCollapsed() const {
-    return ((mVisible == 1) ||
-            (mVisible == 2));
-  }
-};
-
-struct nsTimingFunction
-{
-
-  enum class Type {
-    Ease,
-    Linear,
-    EaseIn,
-    EaseOut,
-    EaseInOut,
-    StepStart,
-    StepEnd,
-    CubicBezier,
-    Frames,
-  };
-
-
-
-  static bool IsSplineType(Type aType)
-  {
-    return aType != Type::StepStart &&
-           aType != Type::StepEnd &&
-           aType != Type::Frames;
-  }
-
-  explicit nsTimingFunction(int32_t aTimingFunctionType
-                              = 0)
-  {
-    AssignFromKeyword(aTimingFunctionType);
-  }
-
-  nsTimingFunction(float x1, float y1, float x2, float y2)
-    : mType(Type::CubicBezier)
-  {
-    mFunc.mX1 = x1;
-    mFunc.mY1 = y1;
-    mFunc.mX2 = x2;
-    mFunc.mY2 = y2;
-  }
-
-  enum class Keyword { Implicit, Explicit };
-
-  nsTimingFunction(Type aType, uint32_t aStepsOrFrames)
-    : mType(aType)
-  {
-    do { } while (0);
-
-
-
-    mStepsOrFrames = aStepsOrFrames;
-  }
-
-  nsTimingFunction(const nsTimingFunction& aOther)
-  {
-    *this = aOther;
-  }
-
-  Type mType;
-  union {
-    struct {
-      float mX1;
-      float mY1;
-      float mX2;
-      float mY2;
-    } mFunc;
-    struct {
-      uint32_t mStepsOrFrames;
-    };
-  };
-
-  nsTimingFunction&
-  operator=(const nsTimingFunction& aOther)
-  {
-    if (&aOther == this) {
-      return *this;
-    }
-
-    mType = aOther.mType;
-
-    if (HasSpline()) {
-      mFunc.mX1 = aOther.mFunc.mX1;
-      mFunc.mY1 = aOther.mFunc.mY1;
-      mFunc.mX2 = aOther.mFunc.mX2;
-      mFunc.mY2 = aOther.mFunc.mY2;
-    } else {
-      mStepsOrFrames = aOther.mStepsOrFrames;
-    }
-
-    return *this;
-  }
-
-  bool operator==(const nsTimingFunction& aOther) const
-  {
-    if (mType != aOther.mType) {
-      return false;
-    }
-    if (HasSpline()) {
-      return mFunc.mX1 == aOther.mFunc.mX1 && mFunc.mY1 == aOther.mFunc.mY1 &&
-             mFunc.mX2 == aOther.mFunc.mX2 && mFunc.mY2 == aOther.mFunc.mY2;
-    }
-    return mStepsOrFrames == aOther.mStepsOrFrames;
-  }
-
-  bool operator!=(const nsTimingFunction& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  bool HasSpline() const { return IsSplineType(mType); }
-
-private:
-  void AssignFromKeyword(int32_t aTimingFunctionType);
-};
-
-namespace mozilla {
-
-struct StyleTransition
-{
-  StyleTransition() { }
-  explicit StyleTransition(const StyleTransition& aCopy);
-
-  void SetInitialValues();
-
-
-
-  const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
-  float GetDelay() const { return mDelay; }
-  float GetDuration() const { return mDuration; }
-  nsCSSPropertyID GetProperty() const { return mProperty; }
-  nsIAtom* GetUnknownProperty() const { return mUnknownProperty; }
-
-  float GetCombinedDuration() const {
-
-    return std::max(mDuration, 0.0f) + mDelay;
-  }
-
-  void SetTimingFunction(const nsTimingFunction& aTimingFunction)
-    { mTimingFunction = aTimingFunction; }
-  void SetDelay(float aDelay) { mDelay = aDelay; }
-  void SetDuration(float aDuration) { mDuration = aDuration; }
-  void SetProperty(nsCSSPropertyID aProperty)
-    {
-      do { } while(0);
-
-
-      mProperty = aProperty;
-    }
-  void SetUnknownProperty(nsCSSPropertyID aProperty,
-                          const nsAString& aPropertyString);
-  void CopyPropertyFrom(const StyleTransition& aOther)
-    {
-      mProperty = aOther.mProperty;
-      mUnknownProperty = aOther.mUnknownProperty;
-    }
-
-  nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
-
-  bool operator==(const StyleTransition& aOther) const;
-  bool operator!=(const StyleTransition& aOther) const
-    { return !(*this == aOther); }
-
-private:
-  nsTimingFunction mTimingFunction;
-  float mDuration;
-  float mDelay;
-  nsCSSPropertyID mProperty;
-  nsCOMPtr<nsIAtom> mUnknownProperty;
-
-
-};
-
-struct StyleAnimation
-{
-  StyleAnimation() { }
-  explicit StyleAnimation(const StyleAnimation& aCopy);
-
-  void SetInitialValues();
-
-
-
-  const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
-  float GetDelay() const { return mDelay; }
-  float GetDuration() const { return mDuration; }
-  const nsString& GetName() const { return mName; }
-  dom::PlaybackDirection GetDirection() const { return mDirection; }
-  dom::FillMode GetFillMode() const { return mFillMode; }
-  uint8_t GetPlayState() const { return mPlayState; }
-  float GetIterationCount() const { return mIterationCount; }
-
-  void SetTimingFunction(const nsTimingFunction& aTimingFunction)
-    { mTimingFunction = aTimingFunction; }
-  void SetDelay(float aDelay) { mDelay = aDelay; }
-  void SetDuration(float aDuration) { mDuration = aDuration; }
-  void SetName(const nsSubstring& aName) { mName = aName; }
-  void SetDirection(dom::PlaybackDirection aDirection) { mDirection = aDirection; }
-  void SetFillMode(dom::FillMode aFillMode) { mFillMode = aFillMode; }
-  void SetPlayState(uint8_t aPlayState) { mPlayState = aPlayState; }
-  void SetIterationCount(float aIterationCount)
-    { mIterationCount = aIterationCount; }
-
-  nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
-
-  bool operator==(const StyleAnimation& aOther) const;
-  bool operator!=(const StyleAnimation& aOther) const
-    { return !(*this == aOther); }
-
-private:
-  nsTimingFunction mTimingFunction;
-  float mDuration;
-  float mDelay;
-  nsString mName;
-  dom::PlaybackDirection mDirection;
-  dom::FillMode mFillMode;
-  uint8_t mPlayState;
-  float mIterationCount;
-};
-
-class StyleBasicShape final
-{
-public:
-  explicit StyleBasicShape(StyleBasicShapeType type)
-    : mType(type),
-      mFillRule(StyleFillRule::Nonzero)
-  {
-    mPosition.SetInitialPercentValues(0.5f);
-  }
-
-  StyleBasicShapeType GetShapeType() const { return mType; }
-  nsCSSKeyword GetShapeTypeName() const;
-
-  StyleFillRule GetFillRule() const { return mFillRule; }
-  void SetFillRule(StyleFillRule aFillRule)
-  {
-    do { } while (0);
-    mFillRule = aFillRule;
-  }
-
-  Position& GetPosition() {
-    do { } while (0);
-
-
-    return mPosition;
-  }
-  const Position& GetPosition() const {
-    do { } while (0);
-
-
-    return mPosition;
-  }
-
-  bool HasRadius() const {
-    do { } while (0);
-    nsStyleCoord zero;
-    zero.SetCoordValue(0);
-    int32_t corner2401 = mozilla::eCornerTopLeftX; for (mozilla::HalfCorner corner; corner2401 <= mozilla::eCornerBottomLeftY && (corner = mozilla::HalfCorner(corner2401), true); ++corner2401) {
-      if (mRadius.Get(corner) != zero) {
-        return true;
-      }
-    }
-    return false;
-  }
-  nsStyleCorners& GetRadius() {
-    do { } while (0);
-    return mRadius;
-  }
-  const nsStyleCorners& GetRadius() const {
-    do { } while (0);
-    return mRadius;
-  }
-
-
-
-  nsTArray<nsStyleCoord>& Coordinates()
-  {
-    return mCoordinates;
-  }
-
-  const nsTArray<nsStyleCoord>& Coordinates() const
-  {
-    return mCoordinates;
-  }
-
-  bool operator==(const StyleBasicShape& aOther) const
-  {
-    return mType == aOther.mType &&
-           mFillRule == aOther.mFillRule &&
-           mCoordinates == aOther.mCoordinates &&
-           mPosition == aOther.mPosition &&
-           mRadius == aOther.mRadius;
-  }
-  bool operator!=(const StyleBasicShape& aOther) const {
-    return !(*this == aOther);
-  }
-
-  public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<StyleBasicShape>::value, "Reference-counted class " "StyleBasicShape" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
-
-private:
-  ~StyleBasicShape() {}
-
-  StyleBasicShapeType mType;
-  StyleFillRule mFillRule;
-
-
-
-
-  nsTArray<nsStyleCoord> mCoordinates;
-
-  Position mPosition;
-
-  nsStyleCorners mRadius;
-};
-
-struct StyleShapeSource
-{
-  StyleShapeSource()
-    : mURL(nullptr)
-  {}
-
-  StyleShapeSource(const StyleShapeSource& aSource)
-    : StyleShapeSource()
-  {
-    if (aSource.mType == StyleShapeSourceType::URL) {
-      SetURL(aSource.mURL);
-    } else if (aSource.mType == StyleShapeSourceType::Shape) {
-      SetBasicShape(aSource.mBasicShape, aSource.mReferenceBox);
-    } else if (aSource.mType == StyleShapeSourceType::Box) {
-      SetReferenceBox(aSource.mReferenceBox);
-    }
-  }
-
-  ~StyleShapeSource()
-  {
-    ReleaseRef();
-  }
-
-  StyleShapeSource& operator=(const StyleShapeSource& aOther)
-  {
-    if (this == &aOther) {
-      return *this;
-    }
-
-    if (aOther.mType == StyleShapeSourceType::URL) {
-      SetURL(aOther.mURL);
-    } else if (aOther.mType == StyleShapeSourceType::Shape) {
-      SetBasicShape(aOther.mBasicShape, aOther.mReferenceBox);
-    } else if (aOther.mType == StyleShapeSourceType::Box) {
-      SetReferenceBox(aOther.mReferenceBox);
-    } else {
-      ReleaseRef();
-      mReferenceBox = StyleGeometryBox::NoBox;
-      mType = StyleShapeSourceType::None;
-    }
-    return *this;
-  }
-
-  bool operator==(const StyleShapeSource& aOther) const
-  {
-    return EqualsInternal<true>(aOther);
-  }
-
-  bool DefinitelyEquals(const StyleShapeSource& aOther) const
-  {
-    return EqualsInternal<false>(aOther);
-  }
-
-  template<bool aPrecise>
-  bool EqualsInternal(const StyleShapeSource& aOther) const
-  {
-    if (mType != aOther.mType) {
-      return false;
-    }
-
-    if (mType == StyleShapeSourceType::URL) {
-      return aPrecise ? mURL->Equals(*aOther.mURL)
-                      : mURL->DefinitelyEqualURIs(*aOther.mURL);
-    } else if (mType == StyleShapeSourceType::Shape) {
-      return *mBasicShape == *aOther.mBasicShape &&
-             mReferenceBox == aOther.mReferenceBox;
-    } else if (mType == StyleShapeSourceType::Box) {
-      return mReferenceBox == aOther.mReferenceBox;
-    }
-
-    return true;
-  }
-
-  bool operator!=(const StyleShapeSource& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  StyleShapeSourceType GetType() const
-  {
-    return mType;
-  }
-
-  css::URLValue* GetURL() const
-  {
-    do { } while (0);
-    return mURL;
-  }
-
-  bool SetURL(css::URLValue* aValue)
-  {
-    do { } while (0);
-    ReleaseRef();
-    mURL = aValue;
-    mURL->AddRef();
-    mType = StyleShapeSourceType::URL;
-    return true;
-  }
-
-  StyleBasicShape* GetBasicShape() const
-  {
-    do { } while (0);
-    return mBasicShape;
-  }
-
-  void SetBasicShape(StyleBasicShape* aBasicShape,
-                     StyleGeometryBox aReferenceBox)
-  {
-    do { } while(0);
-    ReleaseRef();
-    mBasicShape = aBasicShape;
-    mBasicShape->AddRef();
-    mReferenceBox = aReferenceBox;
-    mType = StyleShapeSourceType::Shape;
-  }
-
-  StyleGeometryBox GetReferenceBox() const
-  {
-    do { } while (0);
-
-
-    return mReferenceBox;
-  }
-
-  void SetReferenceBox(StyleGeometryBox aReferenceBox)
-  {
-    ReleaseRef();
-    mReferenceBox = aReferenceBox;
-    mType = StyleShapeSourceType::Box;
-  }
-
-private:
-  void ReleaseRef()
-  {
-    if (mType == StyleShapeSourceType::Shape) {
-      do { } while(0);
-      mBasicShape->Release();
-    } else if (mType == StyleShapeSourceType::URL) {
-      do { } while(0);
-      mURL->Release();
-    }
-
-
-    mURL = nullptr;
-  }
-
-  void* operator new(size_t) = delete;
-
-  union {
-    StyleBasicShape* mBasicShape;
-    css::URLValue* mURL;
-  };
-  StyleShapeSourceType mType = StyleShapeSourceType::None;
-  StyleGeometryBox mReferenceBox = StyleGeometryBox::NoBox;
-};
-
-}
-
-
-
-
-
-
-class BindingHolder {
-public:
-  BindingHolder() {}
-  explicit BindingHolder(mozilla::css::URLValue* aPtr) : mPtr(aPtr) {}
-  operator mozilla::css::URLValue*() const { return Get(); }
-  mozilla::css::URLValue* operator->() const { return Get(); }
-  mozilla::css::URLValue* Get() const { return (mPtr && mPtr->GetURI()) ? mPtr.get() : nullptr; }
-  mozilla::css::URLValue* ForceGet() const { return mPtr.get(); }
-  void Set(mozilla::css::URLValue* aPtr) { mPtr = aPtr; }
-private:
-  RefPtr<mozilla::css::URLValue> mPtr;
-};
-
-struct nsStyleDisplay
-{
-  typedef mozilla::StyleGeometryBox StyleGeometryBox;
-
-  explicit nsStyleDisplay(const nsPresContext* aContext);
-  nsStyleDisplay(const nsStyleDisplay& aOther);
-  ~nsStyleDisplay();
-
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleDisplay* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleDisplay, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleDisplay();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleDisplay, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleDisplay& aNewData) const;
-
-
-
-  BindingHolder mBinding;
-  mozilla::StyleDisplay mDisplay;
-  mozilla::StyleDisplay mOriginalDisplay;
-
-
-
-
-  uint8_t mContain;
-private:
-  friend class nsComputedDOMStyle;
-  friend class nsRuleNode;
-  uint8_t mMozAppearance;
-  uint8_t mAppearance;
-public:
-  __attribute__ ((warn_unused_result)) uint8_t UsedAppearance() const {
-    if (mAppearance == 0) {
-      return 0;
-    }
-    do { } while (0);
-    return mMozAppearance;
-  }
-
-  uint8_t mPosition;
-
-
-  mozilla::StyleFloat mFloat;
-
-  mozilla::StyleFloat mOriginalFloat;
-
-  mozilla::StyleClear mBreakType;
-  uint8_t mBreakInside;
-  bool mBreakBefore;
-  bool mBreakAfter;
-  uint8_t mOverflowX;
-  uint8_t mOverflowY;
-  uint8_t mOverflowClipBox;
-  uint8_t mResize;
-  mozilla::StyleOrient mOrient;
-  uint8_t mIsolation;
-  uint8_t mTopLayer;
-  uint8_t mWillChangeBitField;
-
-
-
-
-
-  nsCOMArray<nsIAtom> mWillChange;
-
-  uint8_t mTouchAction;
-  uint8_t mScrollBehavior;
-  uint8_t mScrollSnapTypeX;
-  uint8_t mScrollSnapTypeY;
-  nsStyleCoord mScrollSnapPointsX;
-  nsStyleCoord mScrollSnapPointsY;
-  mozilla::Position mScrollSnapDestination;
-  nsTArray<mozilla::Position> mScrollSnapCoordinate;
-
-
-
-
-
-  uint8_t mBackfaceVisibility;
-  uint8_t mTransformStyle;
-  StyleGeometryBox mTransformBox;
-  RefPtr<nsCSSValueSharedList> mSpecifiedTransform;
-  nsStyleCoord mTransformOrigin[3];
-  nsStyleCoord mChildPerspective;
-  nsStyleCoord mPerspectiveOrigin[2];
-
-  nsStyleCoord mVerticalAlign;
-
-  nsStyleAutoArray<mozilla::StyleTransition> mTransitions;
-
-
-
-  uint32_t mTransitionTimingFunctionCount,
-           mTransitionDurationCount,
-           mTransitionDelayCount,
-           mTransitionPropertyCount;
-
-  nsStyleAutoArray<mozilla::StyleAnimation> mAnimations;
-
-
-
-  uint32_t mAnimationTimingFunctionCount,
-           mAnimationDurationCount,
-           mAnimationDelayCount,
-           mAnimationNameCount,
-           mAnimationDirectionCount,
-           mAnimationFillModeCount,
-           mAnimationPlayStateCount,
-           mAnimationIterationCountCount;
-
-  mozilla::StyleShapeSource mShapeOutside;
-
-  bool IsBlockInsideStyle() const {
-    return mozilla::StyleDisplay::Block == mDisplay ||
-           mozilla::StyleDisplay::ListItem == mDisplay ||
-           mozilla::StyleDisplay::InlineBlock == mDisplay ||
-           mozilla::StyleDisplay::TableCaption == mDisplay ||
-           mozilla::StyleDisplay::FlowRoot == mDisplay;
-
-
-
-  }
-
-  bool IsBlockOutsideStyle() const {
-    return mozilla::StyleDisplay::Block == mDisplay ||
-           mozilla::StyleDisplay::Flex == mDisplay ||
-           mozilla::StyleDisplay::WebkitBox == mDisplay ||
-           mozilla::StyleDisplay::Grid == mDisplay ||
-           mozilla::StyleDisplay::ListItem == mDisplay ||
-           mozilla::StyleDisplay::Table == mDisplay ||
-           mozilla::StyleDisplay::FlowRoot == mDisplay;
-  }
-
-  static bool IsDisplayTypeInlineOutside(mozilla::StyleDisplay aDisplay) {
-    return mozilla::StyleDisplay::Inline == aDisplay ||
-           mozilla::StyleDisplay::InlineBlock == aDisplay ||
-           mozilla::StyleDisplay::InlineTable == aDisplay ||
-           mozilla::StyleDisplay::MozInlineBox == aDisplay ||
-           mozilla::StyleDisplay::InlineFlex == aDisplay ||
-           mozilla::StyleDisplay::WebkitInlineBox == aDisplay ||
-           mozilla::StyleDisplay::InlineGrid == aDisplay ||
-           mozilla::StyleDisplay::MozInlineGrid == aDisplay ||
-           mozilla::StyleDisplay::MozInlineStack == aDisplay ||
-           mozilla::StyleDisplay::Ruby == aDisplay ||
-           mozilla::StyleDisplay::RubyBase == aDisplay ||
-           mozilla::StyleDisplay::RubyBaseContainer == aDisplay ||
-           mozilla::StyleDisplay::RubyText == aDisplay ||
-           mozilla::StyleDisplay::RubyTextContainer == aDisplay ||
-           mozilla::StyleDisplay::Contents == aDisplay;
-  }
-
-  bool IsInlineOutsideStyle() const {
-    return IsDisplayTypeInlineOutside(mDisplay);
-  }
-
-  bool IsOriginalDisplayInlineOutsideStyle() const {
-    return IsDisplayTypeInlineOutside(mOriginalDisplay);
-  }
-
-  bool IsInnerTableStyle() const {
-    return mozilla::StyleDisplay::TableCaption == mDisplay ||
-           mozilla::StyleDisplay::TableCell == mDisplay ||
-           mozilla::StyleDisplay::TableRow == mDisplay ||
-           mozilla::StyleDisplay::TableRowGroup == mDisplay ||
-           mozilla::StyleDisplay::TableHeaderGroup == mDisplay ||
-           mozilla::StyleDisplay::TableFooterGroup == mDisplay ||
-           mozilla::StyleDisplay::TableColumn == mDisplay ||
-           mozilla::StyleDisplay::TableColumnGroup == mDisplay;
-  }
-
-  bool IsFloatingStyle() const {
-    return mozilla::StyleFloat::None != mFloat;
-  }
-
-  bool IsAbsolutelyPositionedStyle() const {
-    return 2 == mPosition ||
-           3 == mPosition;
-  }
-
-  bool IsRelativelyPositionedStyle() const {
-    return 1 == mPosition ||
-           4 == mPosition;
-  }
-  bool IsPositionForcingStackingContext() const {
-    return 4 == mPosition ||
-           3 == mPosition;
-  }
-
-  static bool IsRubyDisplayType(mozilla::StyleDisplay aDisplay) {
-    return mozilla::StyleDisplay::Ruby == aDisplay ||
-           mozilla::StyleDisplay::RubyBase == aDisplay ||
-           mozilla::StyleDisplay::RubyBaseContainer == aDisplay ||
-           mozilla::StyleDisplay::RubyText == aDisplay ||
-           mozilla::StyleDisplay::RubyTextContainer == aDisplay;
-  }
-
-  bool IsRubyDisplayType() const {
-    return IsRubyDisplayType(mDisplay);
-  }
-
-  bool IsOutOfFlowStyle() const {
-    return (IsAbsolutelyPositionedStyle() || IsFloatingStyle());
-  }
-
-  bool IsScrollableOverflow() const {
-
-
-    return mOverflowX != 0 &&
-           mOverflowX != 4;
-  }
-
-  bool IsContainPaint() const {
-    return 0x8 & mContain;
-  }
-
-
-
-  bool HasTransformStyle() const {
-    return mSpecifiedTransform != nullptr ||
-           mTransformStyle == 1 ||
-           (mWillChangeBitField & (1<<1));
-  }
-
-  bool HasPerspectiveStyle() const {
-    return mChildPerspective.GetUnit() == eStyleUnit_Coord;
-  }
-
-  bool BackfaceIsHidden() const {
-    return mBackfaceVisibility == 0;
-  }
-
-
-
-
-
-
-
-  inline bool IsBlockInside(const nsIFrame* aContextFrame) const;
-  inline bool IsBlockOutside(const nsIFrame* aContextFrame) const;
-  inline bool IsInlineOutside(const nsIFrame* aContextFrame) const;
-  inline bool IsOriginalDisplayInlineOutside(const nsIFrame* aContextFrame) const;
-  inline mozilla::StyleDisplay GetDisplay(const nsIFrame* aContextFrame) const;
-  inline bool IsFloating(const nsIFrame* aContextFrame) const;
-  inline bool IsRelativelyPositioned(const nsIFrame* aContextFrame) const;
-  inline bool IsAbsolutelyPositioned(const nsIFrame* aContextFrame) const;
-# 2896 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-  inline bool IsAbsPosContainingBlock(const nsIFrame* aContextFrame) const;
-
-
-
-
-
-
-  template<class StyleContextLike>
-  inline bool IsAbsPosContainingBlockForAppropriateFrame(
-                StyleContextLike* aStyleContext) const;
-
-
-
-
-
-
-  inline bool HasTransform(const nsIFrame* aContextFrame) const;
-
-
-
-
-
-
-  inline bool IsFixedPosContainingBlock(const nsIFrame* aContextFrame) const;
-
-
-
-
-
-
-  template<class StyleContextLike>
-  inline bool IsFixedPosContainingBlockForAppropriateFrame(
-                StyleContextLike* aStyleContext) const;
-
-private:
-
-
-  template<class StyleContextLike>
-  inline bool HasAbsPosContainingBlockStyleInternal(
-                StyleContextLike* aStyleContext) const;
-  template<class StyleContextLike>
-  inline bool HasFixedPosContainingBlockStyleInternal(
-                StyleContextLike* aStyleContext) const;
-
-public:
-
-
-
-  inline mozilla::StyleFloat PhysicalFloats(mozilla::WritingMode aWM) const;
-  inline mozilla::StyleClear PhysicalBreakType(mozilla::WritingMode aWM) const;
-};
-
-struct nsStyleTable
-{
-  explicit nsStyleTable(const nsPresContext* aContext);
-  nsStyleTable(const nsStyleTable& aOther);
-  ~nsStyleTable();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleTable* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTable, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleTable();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTable, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleTable& aNewData) const;
-
-  uint8_t mLayoutStrategy;
-  int32_t mSpan;
-};
-
-struct nsStyleTableBorder
-{
-  explicit nsStyleTableBorder(const nsPresContext* aContext);
-  nsStyleTableBorder(const nsStyleTableBorder& aOther);
-  ~nsStyleTableBorder();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleTableBorder* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleTableBorder, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleTableBorder();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleTableBorder, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleTableBorder& aNewData) const;
-
-  nscoord mBorderSpacingCol;
-  nscoord mBorderSpacingRow;
-  uint8_t mBorderCollapse;
-  uint8_t mCaptionSide;
-  uint8_t mEmptyCells;
-};
-
-enum nsStyleContentType {
-  eStyleContentType_String = 1,
-  eStyleContentType_Image = 10,
-  eStyleContentType_Attr = 20,
-  eStyleContentType_Counter = 30,
-  eStyleContentType_Counters = 31,
-  eStyleContentType_OpenQuote = 40,
-  eStyleContentType_CloseQuote = 41,
-  eStyleContentType_NoOpenQuote = 42,
-  eStyleContentType_NoCloseQuote = 43,
-  eStyleContentType_AltContent = 50,
-  eStyleContentType_Uninitialized
-};
-
-class nsStyleContentData
-{
-public:
-  nsStyleContentData()
-    : mType(eStyleContentType_Uninitialized)
-  {
-                                      ;
-    mContent.mString = nullptr;
-  }
-  nsStyleContentData(const nsStyleContentData&);
-
-  ~nsStyleContentData();
-  nsStyleContentData& operator=(const nsStyleContentData& aOther);
-  bool operator==(const nsStyleContentData& aOther) const;
-
-  bool operator!=(const nsStyleContentData& aOther) const {
-    return !(*this == aOther);
-  }
-
-  nsStyleContentType GetType() const { return mType; }
-
-  char16_t* GetString() const
-  {
-    do { } while (0);
-
-    return mContent.mString;
-  }
-
-  nsCSSValue::Array* GetCounters() const
-  {
-    do { } while (0);
-
-    return mContent.mCounters;
-  }
-
-  nsStyleImageRequest* GetImageRequest() const
-  {
-    do { } while (0);
-    return mContent.mImage;
-  }
-
-  imgRequestProxy* GetImage() const
-  {
-    return GetImageRequest()->get();
-  }
-
-  void SetKeyword(nsStyleContentType aType)
-  {
-    do { } while (0);
-
-
-
-
-    do { } while (0);
-
-    mType = aType;
-  }
-
-  void SetString(nsStyleContentType aType, const char16_t* aString)
-  {
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-
-    mType = aType;
-    mContent.mString = NS_strdup(aString);
-  }
-
-  void SetCounters(nsStyleContentType aType, nsCSSValue::Array* aCounters)
-  {
-    do { } while (0);
-
-    do { } while (0);
-    do { } while (0);
-    do { } while (0);
-
-    mType = aType;
-    mContent.mCounters = aCounters;
-    mContent.mCounters->AddRef();
-  }
-
-  void SetImageRequest(already_AddRefed<nsStyleImageRequest> aRequest)
-  {
-    do { } while (0);
-
-    mType = eStyleContentType_Image;
-    mContent.mImage = aRequest.take();
-    do { } while (0);
-  }
-
-  void Resolve(nsPresContext* aPresContext) {
-    if (mType == eStyleContentType_Image && !mContent.mImage->IsResolved()) {
-      mContent.mImage->Resolve(aPresContext);
-    }
-  }
-
-private:
-  nsStyleContentType mType;
-  union {
-    char16_t *mString;
-    nsStyleImageRequest* mImage;
-    nsCSSValue::Array* mCounters;
-  } mContent;
-};
-
-struct nsStyleCounterData
-{
-  nsString mCounter;
-  int32_t mValue;
-
-  bool operator==(const nsStyleCounterData& aOther) const {
-    return mValue == aOther.mValue && mCounter == aOther.mCounter;
-  }
-
-  bool operator!=(const nsStyleCounterData& aOther) const {
-    return !(*this == aOther);
-  }
-};
-
-struct nsStyleContent
-{
-  explicit nsStyleContent(const nsPresContext* aContext);
-  nsStyleContent(const nsStyleContent& aContent);
-  ~nsStyleContent();
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleContent* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleContent, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStyleContent& aNewData) const;
-
-  uint32_t ContentCount() const { return mContents.Length(); }
-
-  const nsStyleContentData& ContentAt(uint32_t aIndex) const {
-    return mContents[aIndex];
-  }
-
-  nsStyleContentData& ContentAt(uint32_t aIndex) { return mContents[aIndex]; }
-
-  void AllocateContents(uint32_t aCount) {
-
-
-
-
-
-    mContents.Clear();
-    mContents.SetLength(aCount);
-  }
-
-  uint32_t CounterIncrementCount() const { return mIncrements.Length(); }
-  const nsStyleCounterData& CounterIncrementAt(uint32_t aIndex) const {
-    return mIncrements[aIndex];
-  }
-
-  void AllocateCounterIncrements(uint32_t aCount) {
-    mIncrements.Clear();
-    mIncrements.SetLength(aCount);
-  }
-
-  void SetCounterIncrementAt(uint32_t aIndex, const nsString& aCounter, int32_t aIncrement) {
-    mIncrements[aIndex].mCounter = aCounter;
-    mIncrements[aIndex].mValue = aIncrement;
-  }
-
-  uint32_t CounterResetCount() const { return mResets.Length(); }
-  const nsStyleCounterData& CounterResetAt(uint32_t aIndex) const {
-    return mResets[aIndex];
-  }
-
-  void AllocateCounterResets(uint32_t aCount) {
-    mResets.Clear();
-    mResets.SetLength(aCount);
-  }
-
-  void SetCounterResetAt(uint32_t aIndex, const nsString& aCounter, int32_t aValue) {
-    mResets[aIndex].mCounter = aCounter;
-    mResets[aIndex].mValue = aValue;
-  }
-
-protected:
-  nsTArray<nsStyleContentData> mContents;
-  nsTArray<nsStyleCounterData> mIncrements;
-  nsTArray<nsStyleCounterData> mResets;
-};
-
-struct nsStyleUIReset
-{
-  explicit nsStyleUIReset(const nsPresContext* aContext);
-  nsStyleUIReset(const nsStyleUIReset& aOther);
-  ~nsStyleUIReset();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleUIReset* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleUIReset, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleUIReset();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleUIReset, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleUIReset& aNewData) const;
-
-  mozilla::StyleUserSelect mUserSelect;
-  uint8_t mForceBrokenImageIcon;
-  uint8_t mIMEMode;
-  mozilla::StyleWindowDragging mWindowDragging;
-  uint8_t mWindowShadow;
-};
-
-struct nsCursorImage
-{
-  bool mHaveHotspot;
-  float mHotspotX, mHotspotY;
-  RefPtr<nsStyleImageRequest> mImage;
-
-  nsCursorImage();
-  nsCursorImage(const nsCursorImage& aOther);
-
-  nsCursorImage& operator=(const nsCursorImage& aOther);
-
-  bool operator==(const nsCursorImage& aOther) const;
-  bool operator!=(const nsCursorImage& aOther) const
-  {
-    return !(*this == aOther);
-  }
-
-  imgRequestProxy* GetImage() const {
-    return mImage->get();
-  }
-};
-
-struct nsStyleUserInterface
-{
-  explicit nsStyleUserInterface(const nsPresContext* aContext);
-  nsStyleUserInterface(const nsStyleUserInterface& aOther);
-  ~nsStyleUserInterface();
-
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleUserInterface* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleUserInterface, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleUserInterface();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleUserInterface, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleUserInterface& aNewData) const;
-
-  mozilla::StyleUserInput mUserInput;
-  mozilla::StyleUserModify mUserModify;
-  mozilla::StyleUserFocus mUserFocus;
-  uint8_t mPointerEvents;
-
-  uint8_t mCursor;
-  nsTArray<nsCursorImage> mCursorImages;
-  mozilla::StyleComplexColor mCaretColor;
-
-  inline uint8_t GetEffectivePointerEvents(nsIFrame* aFrame) const;
-};
-
-struct nsStyleXUL
-{
-  explicit nsStyleXUL(const nsPresContext* aContext);
-  nsStyleXUL(const nsStyleXUL& aSource);
-  ~nsStyleXUL();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleXUL* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleXUL, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleXUL();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleXUL, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleXUL& aNewData) const;
-
-  float mBoxFlex;
-  uint32_t mBoxOrdinal;
-  mozilla::StyleBoxAlign mBoxAlign;
-  mozilla::StyleBoxDirection mBoxDirection;
-  mozilla::StyleBoxOrient mBoxOrient;
-  mozilla::StyleBoxPack mBoxPack;
-  bool mStretchStack;
-};
-
-struct nsStyleColumn
-{
-  explicit nsStyleColumn(const nsPresContext* aContext);
-  nsStyleColumn(const nsStyleColumn& aSource);
-  ~nsStyleColumn();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleColumn* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleColumn, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleColumn();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleColumn, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleColumn& aNewData) const;
-
-
-
-
-
-  static const uint32_t kMaxColumnCount = 1000;
-
-  uint32_t mColumnCount;
-  nsStyleCoord mColumnWidth;
-  nsStyleCoord mColumnGap;
-
-  mozilla::StyleComplexColor mColumnRuleColor;
-  uint8_t mColumnRuleStyle;
-  uint8_t mColumnFill;
-  uint8_t mColumnSpan;
-
-  void SetColumnRuleWidth(nscoord aWidth) {
-    mColumnRuleWidth = ((aWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));
-  }
-
-  nscoord GetComputedColumnRuleWidth() const {
-    return (IsVisibleBorderStyle(mColumnRuleStyle) ? mColumnRuleWidth : 0);
-  }
-
-protected:
-  nscoord mColumnRuleWidth;
-  nscoord mTwipsPerPixel;
-};
-
-enum nsStyleSVGPaintType {
-  eStyleSVGPaintType_None = 1,
-  eStyleSVGPaintType_Color,
-  eStyleSVGPaintType_Server,
-  eStyleSVGPaintType_ContextFill,
-  eStyleSVGPaintType_ContextStroke
-};
-
-enum nsStyleSVGOpacitySource : uint8_t {
-  eStyleSVGOpacitySource_Normal,
-  eStyleSVGOpacitySource_ContextFillOpacity,
-  eStyleSVGOpacitySource_ContextStrokeOpacity
-};
-
-class nsStyleSVGPaint
-{
-public:
-  explicit nsStyleSVGPaint(nsStyleSVGPaintType aType = nsStyleSVGPaintType(0));
-  nsStyleSVGPaint(const nsStyleSVGPaint& aSource);
-  ~nsStyleSVGPaint();
-
-  nsStyleSVGPaint& operator=(const nsStyleSVGPaint& aOther);
-
-  nsStyleSVGPaintType Type() const { return mType; }
-
-  void SetNone();
-  void SetColor(nscolor aColor);
-  void SetPaintServer(mozilla::css::URLValue* aPaintServer,
-                      nscolor aFallbackColor);
-  void SetContextValue(nsStyleSVGPaintType aType,
-                       nscolor aFallbackColor);
-
-  nscolor GetColor() const {
-    do { } while (0);
-    return mPaint.mColor;
-  }
-
-  mozilla::css::URLValue* GetPaintServer() const {
-    do { } while (0);
-    return mPaint.mPaintServer;
-  }
-
-  nscolor GetFallbackColor() const {
-    do { } while (0);
-
-
-    return mFallbackColor;
-  }
-
-  bool operator==(const nsStyleSVGPaint& aOther) const;
-  bool operator!=(const nsStyleSVGPaint& aOther) const {
-    return !(*this == aOther);
-  }
-
-private:
-  void Reset();
-  void Assign(const nsStyleSVGPaint& aOther);
-
-  union {
-    nscolor mColor;
-    mozilla::css::URLValue* mPaintServer;
-  } mPaint;
-  nsStyleSVGPaintType mType;
-  nscolor mFallbackColor;
-};
-
-struct nsStyleSVG
-{
-  explicit nsStyleSVG(const nsPresContext* aContext);
-  nsStyleSVG(const nsStyleSVG& aSource);
-  ~nsStyleSVG();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleSVG* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleSVG, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleSVG();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleSVG, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleSVG& aNewData) const;
-
-  nsStyleSVGPaint mFill;
-  nsStyleSVGPaint mStroke;
-  RefPtr<mozilla::css::URLValue> mMarkerEnd;
-  RefPtr<mozilla::css::URLValue> mMarkerMid;
-  RefPtr<mozilla::css::URLValue> mMarkerStart;
-  nsTArray<nsStyleCoord> mStrokeDasharray;
-
-  nsStyleCoord mStrokeDashoffset;
-  nsStyleCoord mStrokeWidth;
-
-  float mFillOpacity;
-  float mStrokeMiterlimit;
-  float mStrokeOpacity;
-
-  mozilla::StyleFillRule mClipRule;
-  uint8_t mColorInterpolation;
-  uint8_t mColorInterpolationFilters;
-  mozilla::StyleFillRule mFillRule;
-  uint8_t mPaintOrder;
-  uint8_t mShapeRendering;
-  uint8_t mStrokeLinecap;
-  uint8_t mStrokeLinejoin;
-  uint8_t mTextAnchor;
-
-  nsStyleSVGOpacitySource FillOpacitySource() const {
-    uint8_t value = (mContextFlags & FILL_OPACITY_SOURCE_MASK) >>
-                    FILL_OPACITY_SOURCE_SHIFT;
-    return nsStyleSVGOpacitySource(value);
-  }
-  nsStyleSVGOpacitySource StrokeOpacitySource() const {
-    uint8_t value = (mContextFlags & STROKE_OPACITY_SOURCE_MASK) >>
-                    STROKE_OPACITY_SOURCE_SHIFT;
-    return nsStyleSVGOpacitySource(value);
-  }
-  bool StrokeDasharrayFromObject() const {
-    return mContextFlags & STROKE_DASHARRAY_CONTEXT;
-  }
-  bool StrokeDashoffsetFromObject() const {
-    return mContextFlags & STROKE_DASHOFFSET_CONTEXT;
-  }
-  bool StrokeWidthFromObject() const {
-    return mContextFlags & STROKE_WIDTH_CONTEXT;
-  }
-
-  void SetFillOpacitySource(nsStyleSVGOpacitySource aValue) {
-    mContextFlags = (mContextFlags & ~FILL_OPACITY_SOURCE_MASK) |
-                    (aValue << FILL_OPACITY_SOURCE_SHIFT);
-  }
-  void SetStrokeOpacitySource(nsStyleSVGOpacitySource aValue) {
-    mContextFlags = (mContextFlags & ~STROKE_OPACITY_SOURCE_MASK) |
-                    (aValue << STROKE_OPACITY_SOURCE_SHIFT);
-  }
-  void SetStrokeDasharrayFromObject(bool aValue) {
-    mContextFlags = (mContextFlags & ~STROKE_DASHARRAY_CONTEXT) |
-                    (aValue ? STROKE_DASHARRAY_CONTEXT : 0);
-  }
-  void SetStrokeDashoffsetFromObject(bool aValue) {
-    mContextFlags = (mContextFlags & ~STROKE_DASHOFFSET_CONTEXT) |
-                    (aValue ? STROKE_DASHOFFSET_CONTEXT : 0);
-  }
-  void SetStrokeWidthFromObject(bool aValue) {
-    mContextFlags = (mContextFlags & ~STROKE_WIDTH_CONTEXT) |
-                    (aValue ? STROKE_WIDTH_CONTEXT : 0);
-  }
-
-  bool HasMarker() const {
-    return mMarkerStart || mMarkerMid || mMarkerEnd;
-  }
-
-
-
-
-
-  bool HasStroke() const {
-    return mStroke.Type() != eStyleSVGPaintType_None && mStrokeOpacity > 0;
-  }
-
-
-
-
-
-  bool HasFill() const {
-    return mFill.Type() != eStyleSVGPaintType_None && mFillOpacity > 0;
-  }
-
-private:
-
-
-
-  enum {
-    FILL_OPACITY_SOURCE_MASK = 0x03,
-    STROKE_OPACITY_SOURCE_MASK = 0x0C,
-    STROKE_DASHARRAY_CONTEXT = 0x10,
-    STROKE_DASHOFFSET_CONTEXT = 0x20,
-    STROKE_WIDTH_CONTEXT = 0x40,
-    FILL_OPACITY_SOURCE_SHIFT = 0,
-    STROKE_OPACITY_SOURCE_SHIFT = 2,
-  };
-
-  uint8_t mContextFlags;
-};
-
-struct nsStyleFilter
-{
-  nsStyleFilter();
-  nsStyleFilter(const nsStyleFilter& aSource);
-  ~nsStyleFilter();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  nsStyleFilter& operator=(const nsStyleFilter& aOther);
-
-  bool operator==(const nsStyleFilter& aOther) const;
-  bool operator!=(const nsStyleFilter& aOther) const {
-    return !(*this == aOther);
-  }
-
-  uint32_t GetType() const {
-    return mType;
-  }
-
-  const nsStyleCoord& GetFilterParameter() const {
-    do { } while(0);
-
-
-    return mFilterParameter;
-  }
-  void SetFilterParameter(const nsStyleCoord& aFilterParameter,
-                          int32_t aType);
-
-  mozilla::css::URLValue* GetURL() const {
-    do { } while (0);
-    return mURL;
-  }
-
-  bool SetURL(mozilla::css::URLValue* aValue);
-
-  nsCSSShadowArray* GetDropShadow() const {
-    do { } while(0);
-    return mDropShadow;
-  }
-  void SetDropShadow(nsCSSShadowArray* aDropShadow);
-
-private:
-  void ReleaseRef();
-
-  uint32_t mType;
-  nsStyleCoord mFilterParameter;
-  union {
-    mozilla::css::URLValue* mURL;
-    nsCSSShadowArray* mDropShadow;
-  };
-};
-
-template<>
-struct nsTArray_CopyChooser<nsStyleFilter>
-{
-  typedef nsTArray_CopyWithConstructors<nsStyleFilter> Type;
-};
-
-struct nsStyleSVGReset
-{
-  explicit nsStyleSVGReset(const nsPresContext* aContext);
-  nsStyleSVGReset(const nsStyleSVGReset& aSource);
-  ~nsStyleSVGReset();
-
-
-
-
-  void FinishStyle(nsPresContext* aPresContext);
-
-  void* operator new(size_t sz, nsStyleSVGReset* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleSVGReset, sz);
-  }
-  void Destroy(nsPresContext* aContext);
-
-  nsChangeHint CalcDifference(const nsStyleSVGReset& aNewData) const;
-
-  bool HasClipPath() const {
-    return mClipPath.GetType() != mozilla::StyleShapeSourceType::None;
-  }
-
-  bool HasMask() const;
-
-  bool HasNonScalingStroke() const {
-    return mVectorEffect == 1;
-  }
-
-  nsStyleImageLayers mMask;
-  mozilla::StyleShapeSource mClipPath;
-  nscolor mStopColor;
-  nscolor mFloodColor;
-  nscolor mLightingColor;
-
-  float mStopOpacity;
-  float mFloodOpacity;
-
-  uint8_t mDominantBaseline;
-  uint8_t mVectorEffect;
-  uint8_t mMaskType;
-};
-
-struct nsStyleVariables
-{
-  nsStyleVariables();
-  explicit nsStyleVariables(const nsPresContext* aContext);
-  nsStyleVariables(const nsStyleVariables& aSource);
-  ~nsStyleVariables();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleVariables* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleVariables, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleVariables();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleVariables, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleVariables& aNewData) const;
-
-  mozilla::CSSVariableValues mVariables;
-};
-
-struct nsStyleEffects
-{
-  explicit nsStyleEffects(const nsPresContext* aContext);
-  nsStyleEffects(const nsStyleEffects& aSource);
-  ~nsStyleEffects();
-  void FinishStyle(nsPresContext* aPresContext) {}
-
-  void* operator new(size_t sz, nsStyleEffects* aSelf) { return aSelf; }
-  void* operator new(size_t sz, nsPresContext* aContext) {
-    return aContext->PresShell()->
-      AllocateByObjectID(mozilla::eArenaObjectID_nsStyleEffects, sz);
-  }
-  void Destroy(nsPresContext* aContext) {
-    this->~nsStyleEffects();
-    aContext->PresShell()->
-      FreeByObjectID(mozilla::eArenaObjectID_nsStyleEffects, this);
-  }
-
-  nsChangeHint CalcDifference(const nsStyleEffects& aNewData) const;
-
-  bool HasFilters() const {
-    return !mFilters.IsEmpty();
-  }
-
-  nsTArray<nsStyleFilter> mFilters;
-  RefPtr<nsCSSShadowArray> mBoxShadow;
-  nsRect mClip;
-  float mOpacity;
-  uint8_t mClipFlags;
-  uint8_t mMixBlendMode;
-};
-# 3726 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStruct.h"
-struct nsPoint_Simple {
-  nscoord x, y;
-};
-
-static_assert(sizeof(nsPoint) == sizeof(nsPoint_Simple), "Size mismatch between " "nsPoint" " and " "nsPoint_Simple"); static_assert(alignof(nsPoint) == alignof(nsPoint_Simple), "Align mismatch between " "nsPoint" " and " "nsPoint_Simple");;
-static_assert(__builtin_offsetof(nsPoint, x) == __builtin_offsetof(nsPoint_Simple, x), "Field offset mismatch of " "x" " between " "nsPoint" " and " "nsPoint_Simple");;
-static_assert(__builtin_offsetof(nsPoint, y) == __builtin_offsetof(nsPoint_Simple, y), "Field offset mismatch of " "y" " between " "nsPoint" " and " "nsPoint_Simple");;
-
-
-
-
-struct nsMargin_Simple {
-  nscoord top, right, bottom, left;
-};
-
-static_assert(sizeof(nsMargin) == sizeof(nsMargin_Simple), "Size mismatch between " "nsMargin" " and " "nsMargin_Simple"); static_assert(alignof(nsMargin) == alignof(nsMargin_Simple), "Align mismatch between " "nsMargin" " and " "nsMargin_Simple");;
-static_assert(__builtin_offsetof(nsMargin, top) == __builtin_offsetof(nsMargin_Simple, top), "Field offset mismatch of " "top" " between " "nsMargin" " and " "nsMargin_Simple");;
-static_assert(__builtin_offsetof(nsMargin, right) == __builtin_offsetof(nsMargin_Simple, right), "Field offset mismatch of " "right" " between " "nsMargin" " and " "nsMargin_Simple");;
-static_assert(__builtin_offsetof(nsMargin, bottom) == __builtin_offsetof(nsMargin_Simple, bottom), "Field offset mismatch of " "bottom" " between " "nsMargin" " and " "nsMargin_Simple");;
-static_assert(__builtin_offsetof(nsMargin, left) == __builtin_offsetof(nsMargin_Simple, left), "Field offset mismatch of " "left" " between " "nsMargin" " and " "nsMargin_Simple");;
-
-
-
-
-struct nsRect_Simple {
-  nscoord x, y, width, height;
-};
-
-static_assert(sizeof(nsRect) == sizeof(nsRect_Simple), "Size mismatch between " "nsRect" " and " "nsRect_Simple"); static_assert(alignof(nsRect) == alignof(nsRect_Simple), "Align mismatch between " "nsRect" " and " "nsRect_Simple");;
-static_assert(__builtin_offsetof(nsRect, x) == __builtin_offsetof(nsRect_Simple, x), "Field offset mismatch of " "x" " between " "nsRect" " and " "nsRect_Simple");;
-static_assert(__builtin_offsetof(nsRect, y) == __builtin_offsetof(nsRect_Simple, y), "Field offset mismatch of " "y" " between " "nsRect" " and " "nsRect_Simple");;
-static_assert(__builtin_offsetof(nsRect, width) == __builtin_offsetof(nsRect_Simple, width), "Field offset mismatch of " "width" " between " "nsRect" " and " "nsRect_Simple");;
-static_assert(__builtin_offsetof(nsRect, height) == __builtin_offsetof(nsRect_Simple, height), "Field offset mismatch of " "height" " between " "nsRect" " and " "nsRect_Simple");;
-
-
-
-
-struct nsSize_Simple {
-  nscoord width, height;
-};
-
-static_assert(sizeof(nsSize) == sizeof(nsSize_Simple), "Size mismatch between " "nsSize" " and " "nsSize_Simple"); static_assert(alignof(nsSize) == alignof(nsSize_Simple), "Align mismatch between " "nsSize" " and " "nsSize_Simple");;
-static_assert(__builtin_offsetof(nsSize, width) == __builtin_offsetof(nsSize_Simple, width), "Field offset mismatch of " "width" " between " "nsSize" " and " "nsSize_Simple");;
-static_assert(__builtin_offsetof(nsSize, height) == __builtin_offsetof(nsSize_Simple, height), "Field offset mismatch of " "height" " between " "nsSize" " and " "nsSize_Simple");;
-
-
-
-
-
-
-
-template<typename T, typename Deleter = mozilla::DefaultDelete<T>>
-struct UniquePtr_Simple {
-  T* mPtr;
-};
-
-static_assert(sizeof(mozilla::UniquePtr<int>) == sizeof(UniquePtr_Simple<int>), "Size mismatch between " "mozilla::UniquePtr<int>" " and " "UniquePtr_Simple<int>"); static_assert(alignof(mozilla::UniquePtr<int>) == alignof(UniquePtr_Simple<int>), "Align mismatch between " "mozilla::UniquePtr<int>" " and " "UniquePtr_Simple<int>");;
-
-
-
-
-template<typename T>
-class nsTArray_Simple {
-  T* mBuffer;
-public:
-
-
-  ~nsTArray_Simple() {};
-};
-
-static_assert(sizeof(nsTArray<nsStyleImageLayers::Layer>) == sizeof(nsTArray_Simple<nsStyleImageLayers::Layer>), "Size mismatch between " "nsTArray<nsStyleImageLayers::Layer>" " and " "nsTArray_Simple<nsStyleImageLayers::Layer>"); static_assert(alignof(nsTArray<nsStyleImageLayers::Layer>) == alignof(nsTArray_Simple<nsStyleImageLayers::Layer>), "Align mismatch between " "nsTArray<nsStyleImageLayers::Layer>" " and " "nsTArray_Simple<nsStyleImageLayers::Layer>");;
-
-static_assert(sizeof(nsTArray<mozilla::StyleTransition>) == sizeof(nsTArray_Simple<mozilla::StyleTransition>), "Size mismatch between " "nsTArray<mozilla::StyleTransition>" " and " "nsTArray_Simple<mozilla::StyleTransition>"); static_assert(alignof(nsTArray<mozilla::StyleTransition>) == alignof(nsTArray_Simple<mozilla::StyleTransition>), "Align mismatch between " "nsTArray<mozilla::StyleTransition>" " and " "nsTArray_Simple<mozilla::StyleTransition>");;
-
-static_assert(sizeof(nsTArray<mozilla::StyleAnimation>) == sizeof(nsTArray_Simple<mozilla::StyleAnimation>), "Size mismatch between " "nsTArray<mozilla::StyleAnimation>" " and " "nsTArray_Simple<mozilla::StyleAnimation>"); static_assert(alignof(nsTArray<mozilla::StyleAnimation>) == alignof(nsTArray_Simple<mozilla::StyleAnimation>), "Align mismatch between " "nsTArray<mozilla::StyleAnimation>" " and " "nsTArray_Simple<mozilla::StyleAnimation>");;
-
-
-
-
-
-
-
-template<typename T>
-class nsCOMArray_Simple {
-  nsTArray<nsISupports*> mBuffer;
-};
-
-static_assert(sizeof(nsCOMArray<nsIContent>) == sizeof(nsCOMArray_Simple<nsIContent>), "Size mismatch between " "nsCOMArray<nsIContent>" " and " "nsCOMArray_Simple<nsIContent>"); static_assert(alignof(nsCOMArray<nsIContent>) == alignof(nsCOMArray_Simple<nsIContent>), "Align mismatch between " "nsCOMArray<nsIContent>" " and " "nsCOMArray_Simple<nsIContent>");;
-
-static_assert(sizeof(nsCOMArray<nsINode>) == sizeof(nsCOMArray_Simple<nsINode>), "Size mismatch between " "nsCOMArray<nsINode>" " and " "nsCOMArray_Simple<nsINode>"); static_assert(alignof(nsCOMArray<nsINode>) == alignof(nsCOMArray_Simple<nsINode>), "Align mismatch between " "nsCOMArray<nsINode>" " and " "nsCOMArray_Simple<nsINode>");;
-
-static_assert(sizeof(nsCOMArray<imgIContainer>) == sizeof(nsCOMArray_Simple<imgIContainer>), "Size mismatch between " "nsCOMArray<imgIContainer>" " and " "nsCOMArray_Simple<imgIContainer>"); static_assert(alignof(nsCOMArray<imgIContainer>) == alignof(nsCOMArray_Simple<imgIContainer>), "Align mismatch between " "nsCOMArray<imgIContainer>" " and " "nsCOMArray_Simple<imgIContainer>");;
-# 12 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ComputedTimingFunction.h" 2
-
-namespace mozilla {
-
-class ComputedTimingFunction
-{
-public:
-  static ComputedTimingFunction
-  CubicBezier(double x1, double y1, double x2, double y2)
-  {
-    return ComputedTimingFunction(x1, y1, x2, y2);
-  }
-  static ComputedTimingFunction
-  Steps(nsTimingFunction::Type aType, uint32_t aSteps)
-  {
-    do { } while (0);
-
-
-
-    do { } while (0);
-    return ComputedTimingFunction(aType, aSteps);
-  }
-  static ComputedTimingFunction
-  Frames(uint32_t aFrames)
-  {
-    do { } while (0);
-    return ComputedTimingFunction(nsTimingFunction::Type::Frames, aFrames);
-  }
-
-  ComputedTimingFunction() = default;
-  explicit ComputedTimingFunction(const nsTimingFunction& aFunction)
-  {
-    Init(aFunction);
-  }
-  void Init(const nsTimingFunction& aFunction);
-
-
-
-  enum class BeforeFlag {
-    Unset,
-    Set
-  };
-  double GetValue(double aPortion, BeforeFlag aBeforeFlag) const;
-  const nsSMILKeySpline* GetFunction() const
-  {
-    do { } while(0);
-    return &mTimingFunction;
-  }
-  nsTimingFunction::Type GetType() const { return mType; }
-  bool HasSpline() const { return nsTimingFunction::IsSplineType(mType); }
-  uint32_t GetSteps() const
-  {
-    do { } while (0);
-
-    return mStepsOrFrames;
-  }
-  uint32_t GetFrames() const
-  {
-    do { } while (0);
-    return mStepsOrFrames;
-  }
-  bool operator==(const ComputedTimingFunction& aOther) const
-  {
-    return mType == aOther.mType &&
-           (HasSpline() ?
-            mTimingFunction == aOther.mTimingFunction :
-            mStepsOrFrames == aOther.mStepsOrFrames);
-  }
-  bool operator!=(const ComputedTimingFunction& aOther) const
-  {
-    return !(*this == aOther);
-  }
-  int32_t Compare(const ComputedTimingFunction& aRhs) const;
-  void AppendToString(nsAString& aResult) const;
-
-  static double GetPortion(const Maybe<ComputedTimingFunction>& aFunction,
-                           double aPortion,
-                           BeforeFlag aBeforeFlag)
-  {
-    return aFunction ? aFunction->GetValue(aPortion, aBeforeFlag) : aPortion;
-  }
-  static int32_t Compare(const Maybe<ComputedTimingFunction>& aLhs,
-                         const Maybe<ComputedTimingFunction>& aRhs);
-
-private:
-  ComputedTimingFunction(double x1, double y1, double x2, double y2)
-    : mType(nsTimingFunction::Type::CubicBezier)
-    , mTimingFunction(x1, y1, x2, y2) { }
-  ComputedTimingFunction(nsTimingFunction::Type aType, uint32_t aStepsOrFrames)
-    : mType(aType)
-    , mStepsOrFrames(aStepsOrFrames) { }
-
-  nsTimingFunction::Type mType = nsTimingFunction::Type::Linear;
-  nsSMILKeySpline mTimingFunction;
-  uint32_t mStepsOrFrames;
-};
-
-}
-# 18 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h" 1
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h"
-class nsIAtom;
-
-namespace mozilla {
-namespace dom {
-class Element;
-}
-
-
-
-typedef uint8_t CSSPseudoClassTypeBase;
-enum class CSSPseudoClassType : CSSPseudoClassTypeBase
-{
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClassList.h" 1
-# 69 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClassList.h"
-empty,
-mozOnlyWhitespace,
-mozEmptyExceptChildrenWithLocalname,
-lang,
-root,
-any,
-
-firstChild,
-firstNode,
-lastChild,
-lastNode,
-onlyChild,
-firstOfType,
-lastOfType,
-onlyOfType,
-nthChild,
-nthLastChild,
-nthOfType,
-nthLastOfType,
-
-
-mozIsHTML,
-
-
- unresolved,
-
-
-
-
-mozNativeAnonymous,
-
-
-
-mozSystemMetric,
-
-
-
-mozLocaleDir,
-
-
-mozLWTheme,
-
-
-mozLWThemeBrightText,
-
-
-mozLWThemeDarkText,
-
-
-mozWindowInactive,
-
-
-
-mozTableBorderNonzero,
-
-
-
-mozBrowserFrame,
-
-
-
-
-scope,
-
-
-
-negation,
-
-
-
-dir,
-
-
-link,
-
-mozAnyLink,
-
-anyLink,
-
-visited,
-
-active,
-checked,
-disabled,
-enabled,
-focus,
-focusWithin,
-hover,
-mozDragOver,
-target,
-indeterminate,
-
-
-mozDevtoolsHighlighted,
-
-mozStyleeditorTransitioning,
-
-
-
-
-fullscreen,
-
-
-
-mozFullScreen,
-
-
-mozFocusRing,
-
-
-mozBroken,
-mozLoading,
-
-mozUserDisabled,
-
-
-mozSuppressed,
-
-
-mozHandlerClickToPlay,
-
-
-mozHandlerVulnerableUpdatable,
-
-
-mozHandlerVulnerableNoUpdate,
-
-
-mozHandlerDisabled,
-
-
-mozHandlerBlocked,
-
-
-mozHandlerCrashed,
-
-
-
-mozMathIncrementScriptLevel,
-
-
-
-
-
-required,
-optional,
-valid,
-invalid,
-inRange,
-outOfRange,
-defaultPseudo,
-placeholderShown,
-
-mozReadOnly,
-
-mozReadWrite,
-
-mozSubmitInvalid,
-
-mozUIInvalid,
-
-mozUIValid,
-
-mozMeterOptimum,
-
-mozMeterSubOptimum,
-
-mozMeterSubSubOptimum,
-
-
-
-mozPlaceholder,
-# 45 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsCSSPseudoClasses.h" 2
-
-  Count,
-  NotPseudo,
-  MAX
-};
-
-}
-
-class nsCSSPseudoClasses
-{
-  typedef mozilla::CSSPseudoClassType Type;
-  typedef mozilla::CSSEnabledState EnabledState;
-
-public:
-  static void AddRefAtoms();
-
-  static Type GetPseudoType(nsIAtom* aAtom, EnabledState aEnabledState);
-  static bool HasStringArg(Type aType);
-  static bool HasNthPairArg(Type aType);
-  static bool HasSelectorListArg(Type aType) {
-    return aType == Type::any;
-  }
-  static bool IsUserActionPseudoClass(Type aType);
-
-
-  static void PseudoTypeToString(Type aType, nsAString& aString);
-
-  static bool IsEnabled(Type aType, EnabledState aEnabledState)
-  {
-    auto index = static_cast<size_t>(aType);
-    do { } while (0);
-    if (sPseudoClassEnabled[index] ||
-        aEnabledState == EnabledState::eIgnoreEnabledState) {
-      return true;
-    }
-    auto flags = kPseudoClassFlags[index];
-    if (((aEnabledState & EnabledState::eInChrome) &&
-         (flags & (1<<1))) ||
-        ((aEnabledState & EnabledState::eInUASheets) &&
-         (flags & (1<<0)))) {
-      return true;
-    }
-    return false;
-  }
-
-
-
-
-  static mozilla::Maybe<bool>
-    MatchesElement(Type aType, const mozilla::dom::Element* aElement);
-
-private:
-  static const uint32_t kPseudoClassFlags[size_t(Type::Count)];
-  static bool sPseudoClassEnabled[size_t(Type::Count)];
-};
-# 20 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-# 30 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
-class nsIAtom;
-class nsIPrincipal;
-class nsIURI;
-struct nsFont;
-namespace mozilla {
-  class ServoStyleSheet;
-  class FontFamilyList;
-  enum FontFamilyType : uint32_t;
-  struct Keyframe;
-  namespace css {
-    struct URLValue;
-  };
-  enum class UpdateAnimationsTasks : uint8_t;
-}
-using mozilla::FontFamilyList;
-using mozilla::FontFamilyType;
-using mozilla::ServoElementSnapshot;
-class nsCSSFontFaceRule;
-struct nsMediaFeature;
-struct nsStyleList;
-struct nsStyleImage;
-struct nsStyleGradientStop;
-class nsStyleGradient;
-class nsStyleCoord;
-struct nsStyleDisplay;
-# 81 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
-struct nsTArrayBorrowed_uintptr_t { nsTArray<uintptr_t>* mArray; nsTArrayBorrowed_uintptr_t(nsTArray<uintptr_t>* aArray) : mArray(aArray) {} };
-
-
-extern "C" {
-
-class ServoBundledURI
-{
-public:
-  already_AddRefed<mozilla::css::URLValue> IntoCssUrl();
-  const uint8_t* mURLString;
-  uint32_t mURLStringLength;
-  mozilla::css::URLExtraData* mExtraData;
-};
-
-
-uint32_t Gecko_ChildrenCount(RawGeckoNodeBorrowed node);
-bool Gecko_NodeIsElement(RawGeckoNodeBorrowed node);
-bool Gecko_IsInDocument(RawGeckoNodeBorrowed node);
-bool Gecko_FlattenedTreeParentIsParent(RawGeckoNodeBorrowed node);
-bool Gecko_IsSignificantChild(RawGeckoNodeBorrowed node,
-                              bool text_is_significant,
-                              bool whitespace_is_significant);
-RawGeckoNodeBorrowedOrNull Gecko_GetParentNode(RawGeckoNodeBorrowed node);
-RawGeckoNodeBorrowedOrNull Gecko_GetFirstChild(RawGeckoNodeBorrowed node);
-RawGeckoNodeBorrowedOrNull Gecko_GetLastChild(RawGeckoNodeBorrowed node);
-RawGeckoNodeBorrowedOrNull Gecko_GetPrevSibling(RawGeckoNodeBorrowed node);
-RawGeckoNodeBorrowedOrNull Gecko_GetNextSibling(RawGeckoNodeBorrowed node);
-RawGeckoElementBorrowedOrNull Gecko_GetFirstChildElement(RawGeckoElementBorrowed element);
-RawGeckoElementBorrowedOrNull Gecko_GetLastChildElement(RawGeckoElementBorrowed element);
-RawGeckoElementBorrowedOrNull Gecko_GetPrevSiblingElement(RawGeckoElementBorrowed element);
-RawGeckoElementBorrowedOrNull Gecko_GetNextSiblingElement(RawGeckoElementBorrowed element);
-RawGeckoElementBorrowedOrNull Gecko_GetDocumentElement(RawGeckoDocumentBorrowed document);
-void Gecko_LoadStyleSheet(mozilla::css::Loader* loader,
-                          mozilla::ServoStyleSheet* parent,
-                          RawServoStyleSheetBorrowed child_sheet,
-                          RawGeckoURLExtraData* base_url_data,
-                          const uint8_t* url_bytes,
-                          uint32_t url_length,
-                          const uint8_t* media_bytes,
-                          uint32_t media_length);
-
-
-
-RawGeckoURLExtraData* Gecko_URLExtraData_CreateDummy();
-
-
-
-
-
-
-
-StyleChildrenIteratorOwnedOrNull Gecko_MaybeCreateStyleChildrenIterator(RawGeckoNodeBorrowed node);
-void Gecko_DropStyleChildrenIterator(StyleChildrenIteratorOwned it);
-RawGeckoNodeBorrowedOrNull Gecko_GetNextStyleChild(StyleChildrenIteratorBorrowedMut it);
-
-
-uint64_t Gecko_ElementState(RawGeckoElementBorrowed element);
-bool Gecko_IsTextNode(RawGeckoNodeBorrowed node);
-bool Gecko_IsRootElement(RawGeckoElementBorrowed element);
-bool Gecko_MatchesElement(mozilla::CSSPseudoClassType type, RawGeckoElementBorrowed element);
-nsIAtom* Gecko_LocalName(RawGeckoElementBorrowed element);
-nsIAtom* Gecko_Namespace(RawGeckoElementBorrowed element);
-nsIAtom* Gecko_GetElementId(RawGeckoElementBorrowed element);
-
-nsIAtom* Gecko_GetXMLLangValue(RawGeckoElementBorrowed element);
-# 166 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
-nsIAtom* Gecko_AtomAttrValue(RawGeckoElementBorrowed element, nsIAtom* attribute); bool Gecko_HasAttr(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name); bool Gecko_AttrEquals(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str, bool ignoreCase); bool Gecko_AttrDashEquals(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrIncludes(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasSubstring(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasPrefix(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_AttrHasSuffix(RawGeckoElementBorrowed element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); uint32_t Gecko_ClassOrClassList(RawGeckoElementBorrowed element, nsIAtom** class_, nsIAtom*** classList);
-nsIAtom* Gecko_SnapshotAtomAttrValue(const ServoElementSnapshot* element, nsIAtom* attribute); bool Gecko_SnapshotHasAttr(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name); bool Gecko_SnapshotAttrEquals(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str, bool ignoreCase); bool Gecko_SnapshotAttrDashEquals(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrIncludes(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasSubstring(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasPrefix(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); bool Gecko_SnapshotAttrHasSuffix(const ServoElementSnapshot* element, nsIAtom* ns, nsIAtom* name, nsIAtom* str); uint32_t Gecko_SnapshotClassOrClassList(const ServoElementSnapshot* element, nsIAtom** class_, nsIAtom*** classList);
-
-
-
-
-
-RawServoDeclarationBlockStrongBorrowedOrNull
-Gecko_GetStyleAttrDeclarationBlock(RawGeckoElementBorrowed element);
-RawServoDeclarationBlockStrongBorrowedOrNull
-Gecko_GetHTMLPresentationAttrDeclarationBlock(RawGeckoElementBorrowed element);
-RawServoDeclarationBlockStrongBorrowedOrNull
-Gecko_GetExtraContentStyleDeclarations(RawGeckoElementBorrowed element);
-
-
-bool
-Gecko_GetAnimationRule(RawGeckoElementBorrowed aElement,
-                       nsIAtom* aPseudoTag,
-                       mozilla::EffectCompositor::CascadeLevel aCascadeLevel,
-                       RawServoAnimationValueMapBorrowed aAnimationValues);
-bool Gecko_StyleAnimationsEquals(RawGeckoStyleAnimationListBorrowed,
-                                 RawGeckoStyleAnimationListBorrowed);
-void Gecko_UpdateAnimations(RawGeckoElementBorrowed aElement,
-                            nsIAtom* aPseudoTagOrNull,
-                            ServoComputedValuesBorrowedOrNull aComputedValues,
-                            ServoComputedValuesBorrowedOrNull aParentComputedValues,
-                            mozilla::UpdateAnimationsTasks aTaskBits);
-bool Gecko_ElementHasAnimations(RawGeckoElementBorrowed aElement,
-                                nsIAtom* aPseudoTagOrNull);
-bool Gecko_ElementHasCSSAnimations(RawGeckoElementBorrowed aElement,
-                                   nsIAtom* aPseudoTagOrNull);
-double Gecko_GetProgressFromComputedTiming(RawGeckoComputedTimingBorrowed aComputedTiming);
-double Gecko_GetPositionInSegment(
-  RawGeckoAnimationPropertySegmentBorrowed aSegment,
-  double aProgress,
-  mozilla::ComputedTimingFunction::BeforeFlag aBeforeFlag);
-
-
-
-
-RawServoAnimationValueBorrowedOrNull Gecko_AnimationGetBaseStyle(
-  void* aBaseStyles,
-  nsCSSPropertyID aProperty);
-
-
-nsIAtom* Gecko_Atomize(const char* aString, uint32_t aLength);
-void Gecko_AddRefAtom(nsIAtom* aAtom);
-void Gecko_ReleaseAtom(nsIAtom* aAtom);
-const uint16_t* Gecko_GetAtomAsUTF16(nsIAtom* aAtom, uint32_t* aLength);
-bool Gecko_AtomEqualsUTF8(nsIAtom* aAtom, const char* aString, uint32_t aLength);
-bool Gecko_AtomEqualsUTF8IgnoreCase(nsIAtom* aAtom, const char* aString, uint32_t aLength);
-
-
-void Gecko_FontFamilyList_Clear(FontFamilyList* aList);
-void Gecko_FontFamilyList_AppendNamed(FontFamilyList* aList, nsIAtom* aName, bool aQuoted);
-void Gecko_FontFamilyList_AppendGeneric(FontFamilyList* list, FontFamilyType familyType);
-void Gecko_CopyFontFamilyFrom(nsFont* dst, const nsFont* src);
-
-
-void Gecko_SetListStyleType(nsStyleList* style_struct, uint32_t type);
-void Gecko_CopyListStyleTypeFrom(nsStyleList* dst, const nsStyleList* src);
-
-
-
-void Gecko_SetNullImageValue(nsStyleImage* image);
-void Gecko_SetGradientImageValue(nsStyleImage* image, nsStyleGradient* gradient);
-void Gecko_SetUrlImageValue(nsStyleImage* image,
-                            ServoBundledURI uri);
-void Gecko_CopyImageValueFrom(nsStyleImage* image, const nsStyleImage* other);
-void Gecko_InitializeImageCropRect(nsStyleImage* image);
-
-nsStyleGradient* Gecko_CreateGradient(uint8_t shape,
-                                      uint8_t size,
-                                      bool repeating,
-                                      bool legacy_syntax,
-                                      uint32_t stops);
-
-
-void Gecko_SetListStyleImageNone(nsStyleList* style_struct);
-void Gecko_SetListStyleImage(nsStyleList* style_struct,
-                             ServoBundledURI uri);
-void Gecko_CopyListStyleImageFrom(nsStyleList* dest, const nsStyleList* src);
-
-
-void Gecko_SetCursorArrayLength(nsStyleUserInterface* ui, size_t len);
-void Gecko_SetCursorImage(nsCursorImage* cursor,
-                          ServoBundledURI uri);
-void Gecko_CopyCursorArrayFrom(nsStyleUserInterface* dest,
-                               const nsStyleUserInterface* src);
-
-void Gecko_SetContentDataImage(nsStyleContentData* content_data, ServoBundledURI uri);
-void Gecko_SetContentDataArray(nsStyleContentData* content_data, nsStyleContentType type, uint32_t len);
-
-
-uint32_t Gecko_GetNodeFlags(RawGeckoNodeBorrowed node);
-void Gecko_SetNodeFlags(RawGeckoNodeBorrowed node, uint32_t flags);
-void Gecko_UnsetNodeFlags(RawGeckoNodeBorrowed node, uint32_t flags);
-void Gecko_SetOwnerDocumentNeedsStyleFlush(RawGeckoElementBorrowed element);
-
-
-
-
-nsStyleContext* Gecko_GetStyleContext(RawGeckoNodeBorrowed node,
-                                      nsIAtom* aPseudoTagOrNull);
-nsChangeHint Gecko_CalcStyleDifference(nsStyleContext* oldstyle,
-                                       ServoComputedValuesBorrowed newstyle);
-nsChangeHint Gecko_HintsHandledForDescendants(nsChangeHint aHint);
-
-
-ServoElementSnapshotOwned Gecko_CreateElementSnapshot(RawGeckoElementBorrowed element);
-void Gecko_DropElementSnapshot(ServoElementSnapshotOwned snapshot);
-
-
-
-
-void Gecko_EnsureTArrayCapacity(void* array, size_t capacity, size_t elem_size);
-
-
-
-
-
-void Gecko_ClearPODTArray(void* array, size_t elem_size, size_t elem_align);
-
-
-
-void Gecko_ClearAndResizeStyleContents(nsStyleContent* content,
-                                       uint32_t how_many);
-void Gecko_ClearAndResizeCounterIncrements(nsStyleContent* content,
-                                           uint32_t how_many);
-void Gecko_ClearAndResizeCounterResets(nsStyleContent* content,
-                                       uint32_t how_many);
-void Gecko_CopyStyleContentsFrom(nsStyleContent* content, const nsStyleContent* other);
-void Gecko_CopyCounterResetsFrom(nsStyleContent* content, const nsStyleContent* other);
-void Gecko_CopyCounterIncrementsFrom(nsStyleContent* content, const nsStyleContent* other);
-
-void Gecko_EnsureImageLayersLength(nsStyleImageLayers* layers, size_t len,
-                                   nsStyleImageLayers::LayerType layer_type);
-
-void Gecko_EnsureStyleAnimationArrayLength(void* array, size_t len);
-void Gecko_EnsureStyleTransitionArrayLength(void* array, size_t len);
-
-void Gecko_ClearWillChange(nsStyleDisplay* display, size_t length);
-void Gecko_AppendWillChange(nsStyleDisplay* display, nsIAtom* atom);
-void Gecko_CopyWillChangeFrom(nsStyleDisplay* dest, nsStyleDisplay* src);
-
-mozilla::Keyframe* Gecko_AnimationAppendKeyframe(RawGeckoKeyframeListBorrowedMut keyframes,
-                                                 float offset,
-                                                 const nsTimingFunction* timingFunction);
-
-
-void Gecko_ResetStyleCoord(nsStyleUnit* unit, nsStyleUnion* value);
-
-
-void Gecko_SetStyleCoordCalcValue(nsStyleUnit* unit, nsStyleUnion* value, nsStyleCoord::CalcValue calc);
-
-void Gecko_CopyClipPathValueFrom(mozilla::StyleShapeSource* dst, const mozilla::StyleShapeSource* src);
-
-void Gecko_DestroyClipPath(mozilla::StyleShapeSource* clip);
-mozilla::StyleBasicShape* Gecko_NewBasicShape(mozilla::StyleBasicShapeType type);
-void Gecko_StyleClipPath_SetURLValue(mozilla::StyleShapeSource* clip, ServoBundledURI uri);
-
-void Gecko_ResetFilters(nsStyleEffects* effects, size_t new_len);
-void Gecko_CopyFiltersFrom(nsStyleEffects* aSrc, nsStyleEffects* aDest);
-void Gecko_nsStyleFilter_SetURLValue(nsStyleFilter* effects, ServoBundledURI uri);
-
-void Gecko_nsStyleSVGPaint_CopyFrom(nsStyleSVGPaint* dest, const nsStyleSVGPaint* src);
-void Gecko_nsStyleSVGPaint_SetURLValue(nsStyleSVGPaint* paint, ServoBundledURI uri);
-void Gecko_nsStyleSVGPaint_Reset(nsStyleSVGPaint* paint);
-
-void Gecko_nsStyleSVG_SetDashArrayLength(nsStyleSVG* svg, uint32_t len);
-void Gecko_nsStyleSVG_CopyDashArray(nsStyleSVG* dst, const nsStyleSVG* src);
-
-mozilla::css::URLValue* Gecko_NewURLValue(ServoBundledURI uri);
-void Gecko_AddRefCSSURLValueArbitraryThread(mozilla::css::URLValue* aPtr); void Gecko_ReleaseCSSURLValueArbitraryThread(mozilla::css::URLValue* aPtr);;
-void Gecko_AddRefURLExtraDataArbitraryThread(RawGeckoURLExtraData* aPtr); void Gecko_ReleaseURLExtraDataArbitraryThread(RawGeckoURLExtraData* aPtr);;
-
-void Gecko_FillAllBackgroundLists(nsStyleImageLayers* layers, uint32_t max_len);
-void Gecko_FillAllMaskLists(nsStyleImageLayers* layers, uint32_t max_len);
-void Gecko_AddRefCalcArbitraryThread(nsStyleCoord::Calc* aPtr); void Gecko_ReleaseCalcArbitraryThread(nsStyleCoord::Calc* aPtr);;
-
-nsCSSShadowArray* Gecko_NewCSSShadowArray(uint32_t len);
-void Gecko_AddRefCSSShadowArrayArbitraryThread(nsCSSShadowArray* aPtr); void Gecko_ReleaseCSSShadowArrayArbitraryThread(nsCSSShadowArray* aPtr);;
-
-nsStyleQuoteValues* Gecko_NewStyleQuoteValues(uint32_t len);
-void Gecko_AddRefQuoteValuesArbitraryThread(nsStyleQuoteValues* aPtr); void Gecko_ReleaseQuoteValuesArbitraryThread(nsStyleQuoteValues* aPtr);;
-
-nsCSSValueSharedList* Gecko_NewCSSValueSharedList(uint32_t len);
-
-
-nsCSSValueBorrowedMut Gecko_CSSValue_GetArrayItem(nsCSSValueBorrowedMut css_value, int32_t index);
-
-nsCSSValueBorrowed Gecko_CSSValue_GetArrayItemConst(nsCSSValueBorrowed css_value, int32_t index);
-nscoord Gecko_CSSValue_GetAbsoluteLength(nsCSSValueBorrowed css_value);
-float Gecko_CSSValue_GetAngle(nsCSSValueBorrowed css_value);
-nsCSSKeyword Gecko_CSSValue_GetKeyword(nsCSSValueBorrowed aCSSValue);
-float Gecko_CSSValue_GetNumber(nsCSSValueBorrowed css_value);
-float Gecko_CSSValue_GetPercentage(nsCSSValueBorrowed css_value);
-nsStyleCoord::CalcValue Gecko_CSSValue_GetCalc(nsCSSValueBorrowed aCSSValue);
-
-void Gecko_CSSValue_SetAbsoluteLength(nsCSSValueBorrowedMut css_value, nscoord len);
-void Gecko_CSSValue_SetNormal(nsCSSValueBorrowedMut css_value);
-void Gecko_CSSValue_SetNumber(nsCSSValueBorrowedMut css_value, float number);
-void Gecko_CSSValue_SetKeyword(nsCSSValueBorrowedMut css_value, nsCSSKeyword keyword);
-void Gecko_CSSValue_SetPercentage(nsCSSValueBorrowedMut css_value, float percent);
-void Gecko_CSSValue_SetAngle(nsCSSValueBorrowedMut css_value, float radians);
-void Gecko_CSSValue_SetCalc(nsCSSValueBorrowedMut css_value, nsStyleCoord::CalcValue calc);
-void Gecko_CSSValue_SetFunction(nsCSSValueBorrowedMut css_value, int32_t len);
-void Gecko_CSSValue_SetString(nsCSSValueBorrowedMut css_value,
-                              const uint8_t* string, uint32_t len, nsCSSUnit unit);
-void Gecko_CSSValue_SetStringFromAtom(nsCSSValueBorrowedMut css_value,
-                                      nsIAtom* atom, nsCSSUnit unit);
-void Gecko_CSSValue_SetArray(nsCSSValueBorrowedMut css_value, int32_t len);
-void Gecko_CSSValue_SetURL(nsCSSValueBorrowedMut css_value, ServoBundledURI uri);
-void Gecko_CSSValue_SetInt(nsCSSValueBorrowedMut css_value, int32_t integer, nsCSSUnit unit);
-void Gecko_CSSValue_Drop(nsCSSValueBorrowedMut css_value);
-void Gecko_AddRefCSSValueSharedListArbitraryThread(nsCSSValueSharedList* aPtr); void Gecko_ReleaseCSSValueSharedListArbitraryThread(nsCSSValueSharedList* aPtr);;
-bool Gecko_PropertyId_IsPrefEnabled(nsCSSPropertyID id);
-
-void Gecko_nsStyleFont_SetLang(nsStyleFont* font, nsIAtom* atom);
-void Gecko_nsStyleFont_CopyLangFrom(nsStyleFont* aFont, const nsStyleFont* aSource);
-nscoord Gecko_nsStyleFont_GetBaseSize(const nsStyleFont* font, RawGeckoPresContextBorrowed pres_context);
-
-const nsMediaFeature* Gecko_GetMediaFeatures();
-
-
-
-nsCSSFontFaceRule* Gecko_CSSFontFaceRule_Create();
-void Gecko_CSSFontFaceRule_GetCssText(const nsCSSFontFaceRule* rule, nsAString* result);
-void Gecko_CSSFontFaceRule_AddRef(nsCSSFontFaceRule* aPtr); void Gecko_CSSFontFaceRule_Release(nsCSSFontFaceRule* aPtr);;
-
-RawGeckoElementBorrowedOrNull Gecko_GetBody(RawGeckoPresContextBorrowed pres_context);
-
-
-
-nscolor Gecko_GetLookAndFeelSystemColor(int32_t color_id,
-                                        RawGeckoPresContextBorrowed pres_context);
-
-bool Gecko_MatchStringArgPseudo(RawGeckoElementBorrowed element,
-                                mozilla::CSSPseudoClassType type,
-                                const char16_t* ident,
-                                bool* set_slow_selector);
-# 416 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
-void Gecko_Construct_Default_nsStyleFont( nsStyleFont* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleFont(nsStyleFont* ptr, const nsStyleFont* other); void Gecko_Destroy_nsStyleFont(nsStyleFont* ptr);
-
-
-
-void Gecko_Construct_Default_nsStyleColor( nsStyleColor* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleColor(nsStyleColor* ptr, const nsStyleColor* other); void Gecko_Destroy_nsStyleColor(nsStyleColor* ptr);
-
-
-void Gecko_Construct_Default_nsStyleList( nsStyleList* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleList(nsStyleList* ptr, const nsStyleList* other); void Gecko_Destroy_nsStyleList(nsStyleList* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleText( nsStyleText* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleText(nsStyleText* ptr, const nsStyleText* other); void Gecko_Destroy_nsStyleText(nsStyleText* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleVisibility( nsStyleVisibility* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleVisibility(nsStyleVisibility* ptr, const nsStyleVisibility* other); void Gecko_Destroy_nsStyleVisibility(nsStyleVisibility* ptr);
-
-
-void Gecko_Construct_Default_nsStyleUserInterface( nsStyleUserInterface* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleUserInterface(nsStyleUserInterface* ptr, const nsStyleUserInterface* other); void Gecko_Destroy_nsStyleUserInterface(nsStyleUserInterface* ptr);
-
-
-void Gecko_Construct_Default_nsStyleTableBorder( nsStyleTableBorder* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTableBorder(nsStyleTableBorder* ptr, const nsStyleTableBorder* other); void Gecko_Destroy_nsStyleTableBorder(nsStyleTableBorder* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleSVG( nsStyleSVG* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleSVG(nsStyleSVG* ptr, const nsStyleSVG* other); void Gecko_Destroy_nsStyleSVG(nsStyleSVG* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleVariables( nsStyleVariables* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleVariables(nsStyleVariables* ptr, const nsStyleVariables* other); void Gecko_Destroy_nsStyleVariables(nsStyleVariables* ptr);
-
-void Gecko_Construct_Default_nsStyleBackground( nsStyleBackground* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleBackground(nsStyleBackground* ptr, const nsStyleBackground* other); void Gecko_Destroy_nsStyleBackground(nsStyleBackground* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStylePosition( nsStylePosition* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStylePosition(nsStylePosition* ptr, const nsStylePosition* other); void Gecko_Destroy_nsStylePosition(nsStylePosition* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleTextReset( nsStyleTextReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTextReset(nsStyleTextReset* ptr, const nsStyleTextReset* other); void Gecko_Destroy_nsStyleTextReset(nsStyleTextReset* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleDisplay( nsStyleDisplay* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleDisplay(nsStyleDisplay* ptr, const nsStyleDisplay* other); void Gecko_Destroy_nsStyleDisplay(nsStyleDisplay* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleContent( nsStyleContent* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleContent(nsStyleContent* ptr, const nsStyleContent* other); void Gecko_Destroy_nsStyleContent(nsStyleContent* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleUIReset( nsStyleUIReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleUIReset(nsStyleUIReset* ptr, const nsStyleUIReset* other); void Gecko_Destroy_nsStyleUIReset(nsStyleUIReset* ptr);
-
-
-void Gecko_Construct_Default_nsStyleTable( nsStyleTable* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleTable(nsStyleTable* ptr, const nsStyleTable* other); void Gecko_Destroy_nsStyleTable(nsStyleTable* ptr);
-
-
-void Gecko_Construct_Default_nsStyleMargin( nsStyleMargin* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleMargin(nsStyleMargin* ptr, const nsStyleMargin* other); void Gecko_Destroy_nsStyleMargin(nsStyleMargin* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStylePadding( nsStylePadding* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStylePadding(nsStylePadding* ptr, const nsStylePadding* other); void Gecko_Destroy_nsStylePadding(nsStylePadding* ptr);
-
-
-
-
-void Gecko_Construct_Default_nsStyleBorder( nsStyleBorder* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleBorder(nsStyleBorder* ptr, const nsStyleBorder* other); void Gecko_Destroy_nsStyleBorder(nsStyleBorder* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleOutline( nsStyleOutline* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleOutline(nsStyleOutline* ptr, const nsStyleOutline* other); void Gecko_Destroy_nsStyleOutline(nsStyleOutline* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleXUL( nsStyleXUL* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleXUL(nsStyleXUL* ptr, const nsStyleXUL* other); void Gecko_Destroy_nsStyleXUL(nsStyleXUL* ptr);
-
-
-void Gecko_Construct_Default_nsStyleSVGReset( nsStyleSVGReset* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleSVGReset(nsStyleSVGReset* ptr, const nsStyleSVGReset* other); void Gecko_Destroy_nsStyleSVGReset(nsStyleSVGReset* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleColumn( nsStyleColumn* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleColumn(nsStyleColumn* ptr, const nsStyleColumn* other); void Gecko_Destroy_nsStyleColumn(nsStyleColumn* ptr);
-
-
-
-
-
-void Gecko_Construct_Default_nsStyleEffects( nsStyleEffects* ptr, RawGeckoPresContextBorrowed pres_context); void Gecko_CopyConstruct_nsStyleEffects(nsStyleEffects* ptr, const nsStyleEffects* other); void Gecko_Destroy_nsStyleEffects(nsStyleEffects* ptr);
-# 417 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-
-
-void Gecko_Construct_nsStyleVariables(nsStyleVariables* ptr);
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 1
-# 22 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
-void Servo_Element_ClearData(RawGeckoElementBorrowed node);
-
-
-RawServoStyleSheetStrong Servo_StyleSheet_Empty(mozilla::css::SheetParsingMode parsing_mode);
-
-RawServoStyleSheetStrong Servo_StyleSheet_FromUTF8Bytes(mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, const nsACString* data, mozilla::css::SheetParsingMode parsing_mode, RawGeckoURLExtraData* extra_data);
-
-
-
-
-
-RawServoStyleSheetStrong Servo_ImportRule_GetSheet(const RawServoImportRuleBorrowed import_rule);
-
-
-void Servo_StyleSheet_ClearAndUpdate(RawServoStyleSheetBorrowed stylesheet, mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, const nsACString* data, RawGeckoURLExtraData* extra_data);
-
-
-
-
-
-
-bool Servo_StyleSheet_HasRules(RawServoStyleSheetBorrowed sheet);
-
-ServoCssRulesStrong Servo_StyleSheet_GetRules(RawServoStyleSheetBorrowed sheet);
-
-RawServoStyleSetOwned Servo_StyleSet_Init(RawGeckoPresContextOwned pres_context);
-void Servo_StyleSet_RebuildData(RawServoStyleSetBorrowed set);
-
-void Servo_StyleSet_Drop(RawServoStyleSetOwned set);
-void Servo_StyleSet_AppendStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
-
-void Servo_StyleSet_PrependStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
-
-void Servo_StyleSet_RemoveStyleSheet(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, bool flush);
-
-void Servo_StyleSet_InsertStyleSheetBefore(RawServoStyleSetBorrowed set, RawServoStyleSheetBorrowed sheet, RawServoStyleSheetBorrowed reference, bool flush);
-
-
-void Servo_StyleSet_FlushStyleSheets(RawServoStyleSetBorrowed set);
-void Servo_StyleSet_NoteStyleSheetsChanged(RawServoStyleSetBorrowed set);
-
-bool Servo_StyleSet_FillKeyframesForName(RawServoStyleSetBorrowed set, const nsACString* property, nsTimingFunctionBorrowed timing_function, ServoComputedValuesBorrowed computed_values, RawGeckoKeyframeListBorrowedMut keyframe_list);
-
-
-
-
-
-void Servo_StyleSet_GetFontFaceRules(RawServoStyleSetBorrowed set, RawGeckoFontFaceRuleListBorrowedMut list);
-
-
-
-
-void Servo_CssRules_ListTypes(ServoCssRulesBorrowed rules, nsTArrayBorrowed_uintptr_t result);
-
-
-nsresult Servo_CssRules_InsertRule(ServoCssRulesBorrowed rules, RawServoStyleSheetBorrowed sheet, const nsACString* rule, uint32_t index, bool nested, mozilla::css::Loader* loader, mozilla::ServoStyleSheet* gecko_stylesheet, uint16_t* rule_type);
-
-
-
-
-
-nsresult Servo_CssRules_DeleteRule(ServoCssRulesBorrowed rules, uint32_t index);
-# 95 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
-RawServoStyleRuleStrong Servo_CssRules_GetStyleRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_StyleRule_Debug(RawServoStyleRuleBorrowed rule, nsACString* result); void Servo_StyleRule_GetCssText(RawServoStyleRuleBorrowed rule, nsAString* result);
-RawServoMediaRuleStrong Servo_CssRules_GetMediaRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_MediaRule_Debug(RawServoMediaRuleBorrowed rule, nsACString* result); void Servo_MediaRule_GetCssText(RawServoMediaRuleBorrowed rule, nsAString* result);
-RawServoNamespaceRuleStrong Servo_CssRules_GetNamespaceRuleAt(ServoCssRulesBorrowed rules, uint32_t index); void Servo_NamespaceRule_Debug(RawServoNamespaceRuleBorrowed rule, nsACString* result); void Servo_NamespaceRule_GetCssText(RawServoNamespaceRuleBorrowed rule, nsAString* result);
-
-nsCSSFontFaceRule* Servo_CssRules_GetFontFaceRuleAt(ServoCssRulesBorrowed rules, uint32_t index);
-
-RawServoDeclarationBlockStrong Servo_StyleRule_GetStyle(RawServoStyleRuleBorrowed rule);
-
-void Servo_StyleRule_SetStyle(RawServoStyleRuleBorrowed rule, RawServoDeclarationBlockBorrowed declarations);
-
-
-void Servo_StyleRule_GetSelectorText(RawServoStyleRuleBorrowed rule, nsAString* result);
-
-RawServoMediaListStrong Servo_MediaRule_GetMedia(RawServoMediaRuleBorrowed rule);
-
-ServoCssRulesStrong Servo_MediaRule_GetRules(RawServoMediaRuleBorrowed rule);
-
-nsIAtom* Servo_NamespaceRule_GetPrefix(RawServoNamespaceRuleBorrowed rule);
-
-nsIAtom* Servo_NamespaceRule_GetURI(RawServoNamespaceRuleBorrowed rule);
-
-
-
-RawServoDeclarationBlockStrong Servo_ParseProperty(const nsACString* property, const nsACString* value, RawGeckoURLExtraData* data);
-
-
-
-bool Servo_ParseEasing(const nsAString* easing, RawGeckoURLExtraData* data, nsTimingFunctionBorrowedMut output);
-
-
-
-void Servo_GetComputedKeyframeValues(RawGeckoKeyframeListBorrowed keyframes, ServoComputedValuesBorrowed style, ServoComputedValuesBorrowedOrNull parent_style, RawServoStyleSetBorrowed set, RawGeckoComputedKeyframeValuesListBorrowedMut result);
-
-
-
-
-
-void Servo_AnimationValueMap_Push(RawServoAnimationValueMapBorrowed, nsCSSPropertyID property, RawServoAnimationValueBorrowed value);
-
-
-
-RawServoAnimationValueStrong Servo_ComputedValues_ExtractAnimationValue(ServoComputedValuesBorrowed computed_values, nsCSSPropertyID property);
-
-
-
-
-
-RawServoAnimationValueStrong Servo_AnimationValues_Interpolate(RawServoAnimationValueBorrowed from, RawServoAnimationValueBorrowed to, double progress);
-
-
-
-
-void Servo_AnimationValue_Serialize(RawServoAnimationValueBorrowed value, nsCSSPropertyID property, nsAString* buffer);
-
-
-
-float Servo_AnimationValue_GetOpacity(RawServoAnimationValueBorrowed value);
-
-void Servo_AnimationValue_GetTransform(RawServoAnimationValueBorrowed value, RefPtr<nsCSSValueSharedList>* list);
-
-
-bool Servo_AnimationValue_DeepEqual(RawServoAnimationValueBorrowed, RawServoAnimationValueBorrowed);
-
-
-
-
-RawServoDeclarationBlockStrong Servo_ParseStyleAttribute(const nsACString* data, RawGeckoURLExtraData* extra_data);
-
-
-RawServoDeclarationBlockStrong Servo_DeclarationBlock_CreateEmpty();
-
-RawServoDeclarationBlockStrong Servo_DeclarationBlock_Clone(RawServoDeclarationBlockBorrowed declarations);
-
-bool Servo_DeclarationBlock_Equals(RawServoDeclarationBlockBorrowed a, RawServoDeclarationBlockBorrowed b);
-
-
-void Servo_DeclarationBlock_GetCssText(RawServoDeclarationBlockBorrowed declarations, nsAString* result);
-
-
-void Servo_DeclarationBlock_SerializeOneValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsAString* buffer);
-
-
-uint32_t Servo_DeclarationBlock_Count(RawServoDeclarationBlockBorrowed declarations);
-
-bool Servo_DeclarationBlock_GetNthProperty(RawServoDeclarationBlockBorrowed declarations, uint32_t index, nsAString* result);
-
-
-void Servo_DeclarationBlock_GetPropertyValue(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, nsAString* value);
-
-
-void Servo_DeclarationBlock_GetPropertyValueById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsAString* value);
-
-
-bool Servo_DeclarationBlock_GetPropertyIsImportant(RawServoDeclarationBlockBorrowed declarations, const nsACString* property);
-
-
-bool Servo_DeclarationBlock_SetProperty(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
-
-
-
-
-bool Servo_DeclarationBlock_SetPropertyById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
-
-
-
-
-void Servo_DeclarationBlock_RemoveProperty(RawServoDeclarationBlockBorrowed declarations, const nsACString* property);
-
-
-void Servo_DeclarationBlock_RemovePropertyById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
-
-
-
-
-
-void Servo_AnimationCompose(RawServoAnimationValueMapBorrowed animation_values, void* base_values, nsCSSPropertyID property, RawGeckoAnimationPropertySegmentBorrowed animation_segment, RawGeckoComputedTimingBorrowed computed_timing);
-
-
-
-
-
-
-
-bool Servo_DeclarationBlock_PropertyIsSet(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
-
-
-void Servo_DeclarationBlock_SetIdentStringValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsIAtom* value);
-
-
-
-void Servo_DeclarationBlock_SetKeywordValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
-
-
-
-void Servo_DeclarationBlock_SetIntValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
-
-
-
-void Servo_DeclarationBlock_SetPixelValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
-
-
-
-void Servo_DeclarationBlock_SetPercentValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
-
-
-
-void Servo_DeclarationBlock_SetAutoValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
-
-
-void Servo_DeclarationBlock_SetCurrentColor(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property);
-
-
-void Servo_DeclarationBlock_SetColorValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nscolor value);
-
-
-
-void Servo_DeclarationBlock_SetFontFamily(RawServoDeclarationBlockBorrowed declarations, const nsAString& value);
-
-
-void Servo_DeclarationBlock_SetTextDecorationColorOverride(RawServoDeclarationBlockBorrowed declarations);
-
-
-
-void Servo_MediaList_GetText(RawServoMediaListBorrowed list, nsAString* result);
-
-void Servo_MediaList_SetText(RawServoMediaListBorrowed list, const nsACString* text);
-
-uint32_t Servo_MediaList_GetLength(RawServoMediaListBorrowed list);
-
-bool Servo_MediaList_GetMediumAt(RawServoMediaListBorrowed list, uint32_t index, nsAString* result);
-
-
-void Servo_MediaList_AppendMedium(RawServoMediaListBorrowed list, const nsACString* new_medium);
-
-bool Servo_MediaList_DeleteMedium(RawServoMediaListBorrowed list, const nsACString* old_medium);
-
-
-
-bool Servo_CSSSupports2(const nsACString* name, const nsACString* value);
-
-bool Servo_CSSSupports(const nsACString* cond);
-
-
-
-ServoComputedValuesStrong Servo_ComputedValues_GetForAnonymousBox(ServoComputedValuesBorrowedOrNull parent_style_or_null, nsIAtom* pseudoTag, bool skip_display_fixup, RawServoStyleSetBorrowed set);
-
-
-
-
-ServoComputedValuesStrong Servo_ComputedValues_Inherit(RawServoStyleSetBorrowed set, ServoComputedValuesBorrowedOrNull parent_style);
-
-
-
-
-void Servo_Initialize();
-
-void Servo_Shutdown();
-
-
-
-ServoElementSnapshot* Servo_Element_GetSnapshot(RawGeckoElementBorrowed element);
-
-
-
-void Servo_NoteExplicitHints(RawGeckoElementBorrowed element, nsRestyleHint restyle_hint, nsChangeHint change_hint);
-
-nsChangeHint Servo_TakeChangeHint(RawGeckoElementBorrowed element);
-ServoComputedValuesStrong Servo_ResolveStyle(RawGeckoElementBorrowed element, RawServoStyleSetBorrowed set, bool allow_stale);
-
-
-
-ServoComputedValuesStrong Servo_ResolvePseudoStyle(RawGeckoElementBorrowed element, nsIAtom* pseudo_tag, bool is_probe, RawServoStyleSetBorrowed set);
-# 318 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
-ServoComputedValuesStrong Servo_ResolveStyleLazily(RawGeckoElementBorrowed element, nsIAtom* pseudo_tag, RawServoStyleSetBorrowed set);
-
-
-
-
-
-bool Servo_TraverseSubtree(RawGeckoElementBorrowed root, RawServoStyleSetBorrowed set, mozilla::TraversalRootBehavior root_behavior);
-
-
-
-
-void Servo_AssertTreeIsClean(RawGeckoElementBorrowed root);
-
-
-ServoComputedValuesStrong Servo_StyleSet_GetBaseComputedValuesForElement(RawServoStyleSetBorrowed set, RawGeckoElementBorrowed element, nsIAtom* pseudo_tag);
-# 343 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h"
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h" 1
-# 44 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/nsStyleStructList.h"
-struct nsStyleFont; const nsStyleFont* Servo_GetStyleFont(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-struct nsStyleColor; const nsStyleColor* Servo_GetStyleColor(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleList; const nsStyleList* Servo_GetStyleList(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleText; const nsStyleText* Servo_GetStyleText(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleVisibility; const nsStyleVisibility* Servo_GetStyleVisibility(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleUserInterface; const nsStyleUserInterface* Servo_GetStyleUserInterface(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleTableBorder; const nsStyleTableBorder* Servo_GetStyleTableBorder(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleSVG; const nsStyleSVG* Servo_GetStyleSVG(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleVariables; const nsStyleVariables* Servo_GetStyleVariables(ServoComputedValuesBorrowedOrNull computed_values);
-
-struct nsStyleBackground; const nsStyleBackground* Servo_GetStyleBackground(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStylePosition; const nsStylePosition* Servo_GetStylePosition(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleTextReset; const nsStyleTextReset* Servo_GetStyleTextReset(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleDisplay; const nsStyleDisplay* Servo_GetStyleDisplay(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleContent; const nsStyleContent* Servo_GetStyleContent(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleUIReset; const nsStyleUIReset* Servo_GetStyleUIReset(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleTable; const nsStyleTable* Servo_GetStyleTable(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleMargin; const nsStyleMargin* Servo_GetStyleMargin(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStylePadding; const nsStylePadding* Servo_GetStylePadding(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-struct nsStyleBorder; const nsStyleBorder* Servo_GetStyleBorder(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleOutline; const nsStyleOutline* Servo_GetStyleOutline(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleXUL; const nsStyleXUL* Servo_GetStyleXUL(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-struct nsStyleSVGReset; const nsStyleSVGReset* Servo_GetStyleSVGReset(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleColumn; const nsStyleColumn* Servo_GetStyleColumn(ServoComputedValuesBorrowedOrNull computed_values);
-
-
-
-
-
-struct nsStyleEffects; const nsStyleEffects* Servo_GetStyleEffects(ServoComputedValuesBorrowedOrNull computed_values);
-# 344 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 2
-
-
-
-
-
-
-# 1 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoArcTypeList.h" 1
-
-
-
-
-
-
-
-
-void Servo_CssRules_AddRef(ServoCssRulesBorrowed); void Servo_CssRules_Release(ServoCssRulesBorrowed);
-void Servo_StyleSheet_AddRef(RawServoStyleSheetBorrowed); void Servo_StyleSheet_Release(RawServoStyleSheetBorrowed);
-void Servo_ComputedValues_AddRef(ServoComputedValuesBorrowed); void Servo_ComputedValues_Release(ServoComputedValuesBorrowed);
-void Servo_DeclarationBlock_AddRef(RawServoDeclarationBlockBorrowed); void Servo_DeclarationBlock_Release(RawServoDeclarationBlockBorrowed);
-void Servo_StyleRule_AddRef(RawServoStyleRuleBorrowed); void Servo_StyleRule_Release(RawServoStyleRuleBorrowed);
-void Servo_ImportRule_AddRef(RawServoImportRuleBorrowed); void Servo_ImportRule_Release(RawServoImportRuleBorrowed);
-void Servo_AnimationValue_AddRef(RawServoAnimationValueBorrowed); void Servo_AnimationValue_Release(RawServoAnimationValueBorrowed);
-void Servo_AnimationValueMap_AddRef(RawServoAnimationValueMapBorrowed); void Servo_AnimationValueMap_Release(RawServoAnimationValueMapBorrowed);
-void Servo_MediaList_AddRef(RawServoMediaListBorrowed); void Servo_MediaList_Release(RawServoMediaListBorrowed);
-void Servo_MediaRule_AddRef(RawServoMediaRuleBorrowed); void Servo_MediaRule_Release(RawServoMediaRuleBorrowed);
-void Servo_NamespaceRule_AddRef(RawServoNamespaceRuleBorrowed); void Servo_NamespaceRule_Release(RawServoNamespaceRuleBorrowed);
-# 351 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindingList.h" 2
-# 423 "/home/fitzgen/stylo/obj-x86_64-pc-linux-gnu/dist/include/mozilla/ServoBindings.h" 2
-
-
-}
-# 2 "stylo.cpp" 2
-
diff --git a/tests/stylo_sanity.rs b/tests/stylo_sanity.rs
deleted file mode 100755
index 52b96355..00000000
--- a/tests/stylo_sanity.rs
+++ /dev/null
@@ -1,556 +0,0 @@
-// Don't want to copy that nasty `cfg` below...
-#[allow(unused_extern_crates)]
-extern crate bindgen;
-
-/// A sanity test that we can generate bindings for Stylo.
-///
-/// We don't assert on expected output because its just too big. The output will
-/// change too often, and it won't be clear what is going on at a glance, unlike
-/// the other tests with smaller input headers.
-///
-/// This test is relatively slow, so we also only run it in release mode.
-///
-/// Finally, uncomment the `panic!` at the bottom of the test to get logs timing
-/// how long bindings generation takes for Stylo. Stylo bindings generation
-/// takes too long to be a proper `#[bench]`.
-#[test]
-#[cfg(not(any(debug_assertions, feature = "testing_only_extra_assertions",)))]
-#[cfg(any(
-    feature = "testing_only_libclang_5",
-    feature = "testing_only_libclang_9"
-))]
-fn sanity_check_can_generate_stylo_bindings() {
-    use std::time::Instant;
-
-    let then = Instant::now();
-
-    bindgen::builder()
-        .time_phases(true)
-        .disable_header_comment()
-        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/stylo.hpp"))
-        .allowlist_function("Servo_.*")
-        .allowlist_function("Gecko_.*")
-        .blocklist_type("nsACString_internal")
-        .blocklist_type("nsAString_internal")
-        .blocklist_type("mozilla::css::URLValue")
-        .blocklist_type("RawGeckoAnimationPropertySegment")
-        .blocklist_type("RawGeckoComputedTiming")
-        .blocklist_type("RawGeckoDocument")
-        .blocklist_type("RawGeckoElement")
-        .blocklist_type("RawGeckoKeyframeList")
-        .blocklist_type("RawGeckoComputedKeyframeValuesList")
-        .blocklist_type("RawGeckoFontFaceRuleList")
-        .blocklist_type("RawGeckoNode")
-        .blocklist_type("RawGeckoAnimationValueList")
-        .blocklist_type("RawServoAnimationValue")
-        .blocklist_type("RawServoAnimationValueMap")
-        .blocklist_type("RawServoDeclarationBlock")
-        .blocklist_type("RawGeckoPresContext")
-        .blocklist_type("RawGeckoPresContextOwned")
-        .blocklist_type("RawGeckoStyleAnimationList")
-        .blocklist_type("RawGeckoURLExtraData")
-        .blocklist_type("RefPtr")
-        .blocklist_type("CSSPseudoClassType")
-        .blocklist_type("TraversalRootBehavior")
-        .blocklist_type("ComputedTimingFunction_BeforeFlag")
-        .blocklist_type("FontFamilyList")
-        .blocklist_type("FontFamilyType")
-        .blocklist_type("Keyframe")
-        .blocklist_type("ServoBundledURI")
-        .blocklist_type("ServoElementSnapshot")
-        .blocklist_type("SheetParsingMode")
-        .blocklist_type("StyleBasicShape")
-        .blocklist_type("StyleBasicShapeType")
-        .blocklist_type("StyleShapeSource")
-        .blocklist_type("nsCSSFontFaceRule")
-        .blocklist_type("nsCSSKeyword")
-        .blocklist_type("nsCSSPropertyID")
-        .blocklist_type("nsCSSShadowArray")
-        .blocklist_type("nsCSSUnit")
-        .blocklist_type("nsCSSValue")
-        .blocklist_type("nsCSSValueSharedList")
-        .blocklist_type("nsChangeHint")
-        .blocklist_type("nsCursorImage")
-        .blocklist_type("nsFont")
-        .blocklist_type("nsIAtom")
-        .blocklist_type("nsMediaFeature")
-        .blocklist_type("nsRestyleHint")
-        .blocklist_type("nsStyleBackground")
-        .blocklist_type("nsStyleBorder")
-        .blocklist_type("nsStyleColor")
-        .blocklist_type("nsStyleColumn")
-        .blocklist_type("nsStyleContent")
-        .blocklist_type("nsStyleContentData")
-        .blocklist_type("nsStyleContentType")
-        .blocklist_type("nsStyleContext")
-        .blocklist_type("nsStyleCoord")
-        .blocklist_type("nsStyleCoord_Calc")
-        .blocklist_type("nsStyleCoord_CalcValue")
-        .blocklist_type("nsStyleDisplay")
-        .blocklist_type("nsStyleEffects")
-        .blocklist_type("nsStyleFilter")
-        .blocklist_type("nsStyleFont")
-        .blocklist_type("nsStyleGradient")
-        .blocklist_type("nsStyleGradientStop")
-        .blocklist_type("nsStyleImage")
-        .blocklist_type("nsStyleImageLayers")
-        .blocklist_type("nsStyleImageLayers_Layer")
-        .blocklist_type("nsStyleImageLayers_LayerType")
-        .blocklist_type("nsStyleImageRequest")
-        .blocklist_type("nsStyleList")
-        .blocklist_type("nsStyleMargin")
-        .blocklist_type("nsStyleOutline")
-        .blocklist_type("nsStylePadding")
-        .blocklist_type("nsStylePosition")
-        .blocklist_type("nsStyleQuoteValues")
-        .blocklist_type("nsStyleSVG")
-        .blocklist_type("nsStyleSVGPaint")
-        .blocklist_type("nsStyleSVGReset")
-        .blocklist_type("nsStyleTable")
-        .blocklist_type("nsStyleTableBorder")
-        .blocklist_type("nsStyleText")
-        .blocklist_type("nsStyleTextReset")
-        .blocklist_type("nsStyleUIReset")
-        .blocklist_type("nsStyleUnion")
-        .blocklist_type("nsStyleUnit")
-        .blocklist_type("nsStyleUserInterface")
-        .blocklist_type("nsStyleVariables")
-        .blocklist_type("nsStyleVisibility")
-        .blocklist_type("nsStyleXUL")
-        .blocklist_type("nsTimingFunction")
-        .blocklist_type("nscolor")
-        .blocklist_type("nscoord")
-        .blocklist_type("nsresult")
-        .blocklist_type("Loader")
-        .blocklist_type("ServoStyleSheet")
-        .blocklist_type("EffectCompositor_CascadeLevel")
-        .blocklist_type("UpdateAnimationsTasks")
-        .blocklist_type("nsTArrayBorrowed_uintptr_t")
-        .blocklist_type("ServoCssRulesStrong")
-        .blocklist_type("ServoCssRulesBorrowed")
-        .blocklist_type("ServoCssRulesBorrowedOrNull")
-        .blocklist_type("ServoCssRules")
-        .blocklist_type("RawServoStyleSheetStrong")
-        .blocklist_type("RawServoStyleSheetBorrowed")
-        .blocklist_type("RawServoStyleSheetBorrowedOrNull")
-        .blocklist_type("RawServoStyleSheet")
-        .blocklist_type("ServoComputedValuesStrong")
-        .blocklist_type("ServoComputedValuesBorrowed")
-        .blocklist_type("ServoComputedValuesBorrowedOrNull")
-        .blocklist_type("ServoComputedValues")
-        .blocklist_type("RawServoDeclarationBlockStrong")
-        .blocklist_type("RawServoDeclarationBlockBorrowed")
-        .blocklist_type("RawServoDeclarationBlockBorrowedOrNull")
-        .blocklist_type("RawServoStyleRuleStrong")
-        .blocklist_type("RawServoStyleRuleBorrowed")
-        .blocklist_type("RawServoStyleRuleBorrowedOrNull")
-        .blocklist_type("RawServoStyleRule")
-        .blocklist_type("RawServoImportRuleStrong")
-        .blocklist_type("RawServoImportRuleBorrowed")
-        .blocklist_type("RawServoImportRuleBorrowedOrNull")
-        .blocklist_type("RawServoImportRule")
-        .blocklist_type("RawServoAnimationValueStrong")
-        .blocklist_type("RawServoAnimationValueBorrowed")
-        .blocklist_type("RawServoAnimationValueBorrowedOrNull")
-        .blocklist_type("RawServoAnimationValueMapStrong")
-        .blocklist_type("RawServoAnimationValueMapBorrowed")
-        .blocklist_type("RawServoAnimationValueMapBorrowedOrNull")
-        .blocklist_type("RawServoMediaListStrong")
-        .blocklist_type("RawServoMediaListBorrowed")
-        .blocklist_type("RawServoMediaListBorrowedOrNull")
-        .blocklist_type("RawServoMediaList")
-        .blocklist_type("RawServoMediaRuleStrong")
-        .blocklist_type("RawServoMediaRuleBorrowed")
-        .blocklist_type("RawServoMediaRuleBorrowedOrNull")
-        .blocklist_type("RawServoMediaRule")
-        .blocklist_type("RawServoNamespaceRuleStrong")
-        .blocklist_type("RawServoNamespaceRuleBorrowed")
-        .blocklist_type("RawServoNamespaceRuleBorrowedOrNull")
-        .blocklist_type("RawServoNamespaceRule")
-        .blocklist_type("RawServoStyleSetOwned")
-        .blocklist_type("RawServoStyleSetOwnedOrNull")
-        .blocklist_type("RawServoStyleSetBorrowed")
-        .blocklist_type("RawServoStyleSetBorrowedOrNull")
-        .blocklist_type("RawServoStyleSetBorrowedMut")
-        .blocklist_type("RawServoStyleSetBorrowedMutOrNull")
-        .blocklist_type("RawServoStyleSet")
-        .blocklist_type("StyleChildrenIteratorOwned")
-        .blocklist_type("StyleChildrenIteratorOwnedOrNull")
-        .blocklist_type("StyleChildrenIteratorBorrowed")
-        .blocklist_type("StyleChildrenIteratorBorrowedOrNull")
-        .blocklist_type("StyleChildrenIteratorBorrowedMut")
-        .blocklist_type("StyleChildrenIteratorBorrowedMutOrNull")
-        .blocklist_type("StyleChildrenIterator")
-        .blocklist_type("ServoElementSnapshotOwned")
-        .blocklist_type("ServoElementSnapshotOwnedOrNull")
-        .blocklist_type("ServoElementSnapshotBorrowed")
-        .blocklist_type("ServoElementSnapshotBorrowedOrNull")
-        .blocklist_type("ServoElementSnapshotBorrowedMut")
-        .blocklist_type("ServoElementSnapshotBorrowedMutOrNull")
-        .blocklist_type("RawGeckoNodeBorrowed")
-        .blocklist_type("RawGeckoNodeBorrowedOrNull")
-        .blocklist_type("RawGeckoElementBorrowed")
-        .blocklist_type("RawGeckoElementBorrowedOrNull")
-        .blocklist_type("RawGeckoDocumentBorrowed")
-        .blocklist_type("RawGeckoDocumentBorrowedOrNull")
-        .blocklist_type("RawServoDeclarationBlockStrongBorrowed")
-        .blocklist_type("RawServoDeclarationBlockStrongBorrowedOrNull")
-        .blocklist_type("RawGeckoPresContextBorrowed")
-        .blocklist_type("RawGeckoPresContextBorrowedOrNull")
-        .blocklist_type("RawGeckoStyleAnimationListBorrowed")
-        .blocklist_type("RawGeckoStyleAnimationListBorrowedOrNull")
-        .blocklist_type("nsCSSValueBorrowed")
-        .blocklist_type("nsCSSValueBorrowedOrNull")
-        .blocklist_type("nsCSSValueBorrowedMut")
-        .blocklist_type("nsCSSValueBorrowedMutOrNull")
-        .blocklist_type("nsTimingFunctionBorrowed")
-        .blocklist_type("nsTimingFunctionBorrowedOrNull")
-        .blocklist_type("nsTimingFunctionBorrowedMut")
-        .blocklist_type("nsTimingFunctionBorrowedMutOrNull")
-        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowed")
-        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedOrNull")
-        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedMut")
-        .blocklist_type("RawGeckoAnimationPropertySegmentBorrowedMutOrNull")
-        .blocklist_type("RawGeckoAnimationValueListBorrowed")
-        .blocklist_type("RawGeckoAnimationValueListBorrowedOrNull")
-        .blocklist_type("RawGeckoAnimationValueListBorrowedMut")
-        .blocklist_type("RawGeckoAnimationValueListBorrowedMutOrNull")
-        .blocklist_type("RawGeckoComputedTimingBorrowed")
-        .blocklist_type("RawGeckoComputedTimingBorrowedOrNull")
-        .blocklist_type("RawGeckoComputedTimingBorrowedMut")
-        .blocklist_type("RawGeckoComputedTimingBorrowedMutOrNull")
-        .blocklist_type("RawGeckoKeyframeListBorrowed")
-        .blocklist_type("RawGeckoKeyframeListBorrowedOrNull")
-        .blocklist_type("RawGeckoKeyframeListBorrowedMut")
-        .blocklist_type("RawGeckoKeyframeListBorrowedMutOrNull")
-        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowed")
-        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedOrNull")
-        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedMut")
-        .blocklist_type("RawGeckoComputedKeyframeValuesListBorrowedMutOrNull")
-        .blocklist_type("RawGeckoFontFaceRuleListBorrowed")
-        .blocklist_type("RawGeckoFontFaceRuleListBorrowedOrNull")
-        .blocklist_type("RawGeckoFontFaceRuleListBorrowedMut")
-        .blocklist_type("RawGeckoFontFaceRuleListBorrowedMutOrNull")
-        .raw_line(r#"pub use nsstring::{nsACString, nsAString, nsString};"#)
-        .raw_line(r#"type nsACString_internal = nsACString;"#)
-        .raw_line(r#"type nsAString_internal = nsAString;"#)
-        .raw_line(r#"use gecko_bindings::structs::mozilla::css::URLValue;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoAnimationPropertySegment;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoComputedTiming;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoDocument;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoElement;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoKeyframeList;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoComputedKeyframeValuesList;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoFontFaceRuleList;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoNode;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoAnimationValueList;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawServoAnimationValue;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawServoAnimationValueMap;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawServoDeclarationBlock;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoPresContext;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoPresContextOwned;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoStyleAnimationList;"#)
-        .raw_line(r#"use gecko_bindings::structs::RawGeckoURLExtraData;"#)
-        .raw_line(r#"use gecko_bindings::structs::RefPtr;"#)
-        .raw_line(r#"use gecko_bindings::structs::CSSPseudoClassType;"#)
-        .raw_line(r#"use gecko_bindings::structs::TraversalRootBehavior;"#)
-        .raw_line(r#"use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;"#)
-        .raw_line(r#"use gecko_bindings::structs::FontFamilyList;"#)
-        .raw_line(r#"use gecko_bindings::structs::FontFamilyType;"#)
-        .raw_line(r#"use gecko_bindings::structs::Keyframe;"#)
-        .raw_line(r#"use gecko_bindings::structs::ServoBundledURI;"#)
-        .raw_line(r#"use gecko_bindings::structs::ServoElementSnapshot;"#)
-        .raw_line(r#"use gecko_bindings::structs::SheetParsingMode;"#)
-        .raw_line(r#"use gecko_bindings::structs::StyleBasicShape;"#)
-        .raw_line(r#"use gecko_bindings::structs::StyleBasicShapeType;"#)
-        .raw_line(r#"use gecko_bindings::structs::StyleShapeSource;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSFontFaceRule;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSKeyword;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSPropertyID;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSShadowArray;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSUnit;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSValue;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCSSValueSharedList;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsChangeHint;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsCursorImage;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsFont;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsIAtom;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsMediaFeature;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsRestyleHint;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleBackground;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleBackground {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleBackground {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleBorder;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleBorder {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleBorder {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleColor;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleColor {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleColor {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleColumn;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleColumn {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleColumn {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleContent;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleContent {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleContent {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleContentData;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleContentData {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleContentData {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleContentType;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleContentType {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleContentType {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleContext;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleContext {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleContext {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleCoord {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleCoord {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord_Calc;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleCoord_Calc {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleCoord_Calc {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleCoord_CalcValue;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleCoord_CalcValue {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleCoord_CalcValue {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleDisplay;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleDisplay {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleDisplay {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleEffects;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleEffects {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleEffects {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleFilter;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleFilter {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleFilter {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleFont;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleFont {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleFont {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleGradient;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleGradient {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleGradient {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleGradientStop;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleGradientStop {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleGradientStop {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleImage;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleImage {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleImage {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleImageLayers {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers_Layer;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleImageLayers_Layer {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers_Layer {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleImageLayers_LayerType;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleImageLayers_LayerType {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleImageLayers_LayerType {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleImageRequest;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleImageRequest {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleImageRequest {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleList;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleList {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleList {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleMargin;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleMargin {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleMargin {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleOutline;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleOutline {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleOutline {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStylePadding;"#)
-        .raw_line(r#"unsafe impl Send for nsStylePadding {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStylePadding {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStylePosition;"#)
-        .raw_line(r#"unsafe impl Send for nsStylePosition {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStylePosition {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleQuoteValues;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleQuoteValues {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleQuoteValues {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleSVG;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleSVG {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleSVG {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleSVGPaint;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleSVGPaint {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleSVGPaint {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleSVGReset;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleSVGReset {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleSVGReset {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleTable;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleTable {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleTable {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleTableBorder;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleTableBorder {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleTableBorder {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleText;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleText {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleText {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleTextReset;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleTextReset {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleTextReset {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleUIReset;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleUIReset {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleUIReset {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleUnion;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleUnion {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleUnion {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleUnit;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleUnit {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleUnit {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleUserInterface;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleUserInterface {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleUserInterface {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleVariables;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleVariables {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleVariables {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleVisibility;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleVisibility {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleVisibility {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsStyleXUL;"#)
-        .raw_line(r#"unsafe impl Send for nsStyleXUL {}"#)
-        .raw_line(r#"unsafe impl Sync for nsStyleXUL {}"#)
-        .raw_line(r#"use gecko_bindings::structs::nsTimingFunction;"#)
-        .raw_line(r#"use gecko_bindings::structs::nscolor;"#)
-        .raw_line(r#"use gecko_bindings::structs::nscoord;"#)
-        .raw_line(r#"use gecko_bindings::structs::nsresult;"#)
-        .raw_line(r#"use gecko_bindings::structs::Loader;"#)
-        .raw_line(r#"use gecko_bindings::structs::ServoStyleSheet;"#)
-        .raw_line(r#"use gecko_bindings::structs::EffectCompositor_CascadeLevel;"#)
-        .raw_line(r#"use gecko_bindings::structs::UpdateAnimationsTasks;"#)
-        .raw_line(r#"pub type nsTArrayBorrowed_uintptr_t<'a> = &'a mut ::gecko_bindings::structs::nsTArray<usize>;"#)
-        .raw_line(r#"pub type ServoCssRulesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoCssRules>;"#)
-        .raw_line(r#"pub type ServoCssRulesBorrowed<'a> = &'a ServoCssRules;"#)
-        .raw_line(r#"pub type ServoCssRulesBorrowedOrNull<'a> = Option<&'a ServoCssRules>;"#)
-        .raw_line(r#"enum ServoCssRulesVoid { }"#)
-        .raw_line(r#"pub struct ServoCssRules(ServoCssRulesVoid);"#)
-        .raw_line(r#"pub type RawServoStyleSheetStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleSheet>;"#)
-        .raw_line(r#"pub type RawServoStyleSheetBorrowed<'a> = &'a RawServoStyleSheet;"#)
-        .raw_line(r#"pub type RawServoStyleSheetBorrowedOrNull<'a> = Option<&'a RawServoStyleSheet>;"#)
-        .raw_line(r#"enum RawServoStyleSheetVoid { }"#)
-        .raw_line(r#"pub struct RawServoStyleSheet(RawServoStyleSheetVoid);"#)
-        .raw_line(r#"pub type ServoComputedValuesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoComputedValues>;"#)
-        .raw_line(r#"pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;"#)
-        .raw_line(r#"pub type ServoComputedValuesBorrowedOrNull<'a> = Option<&'a ServoComputedValues>;"#)
-        .raw_line(r#"enum ServoComputedValuesVoid { }"#)
-        .raw_line(r#"pub struct ServoComputedValues(ServoComputedValuesVoid);"#)
-        .raw_line(r#"pub type RawServoDeclarationBlockStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoDeclarationBlock>;"#)
-        .raw_line(r#"pub type RawServoDeclarationBlockBorrowed<'a> = &'a RawServoDeclarationBlock;"#)
-        .raw_line(r#"pub type RawServoDeclarationBlockBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlock>;"#)
-        .raw_line(r#"pub type RawServoStyleRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleRule>;"#)
-        .raw_line(r#"pub type RawServoStyleRuleBorrowed<'a> = &'a RawServoStyleRule;"#)
-        .raw_line(r#"pub type RawServoStyleRuleBorrowedOrNull<'a> = Option<&'a RawServoStyleRule>;"#)
-        .raw_line(r#"enum RawServoStyleRuleVoid { }"#)
-        .raw_line(r#"pub struct RawServoStyleRule(RawServoStyleRuleVoid);"#)
-        .raw_line(r#"pub type RawServoImportRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoImportRule>;"#)
-        .raw_line(r#"pub type RawServoImportRuleBorrowed<'a> = &'a RawServoImportRule;"#)
-        .raw_line(r#"pub type RawServoImportRuleBorrowedOrNull<'a> = Option<&'a RawServoImportRule>;"#)
-        .raw_line(r#"enum RawServoImportRuleVoid { }"#)
-        .raw_line(r#"pub struct RawServoImportRule(RawServoImportRuleVoid);"#)
-        .raw_line(r#"pub type RawServoAnimationValueStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoAnimationValue>;"#)
-        .raw_line(r#"pub type RawServoAnimationValueBorrowed<'a> = &'a RawServoAnimationValue;"#)
-        .raw_line(r#"pub type RawServoAnimationValueBorrowedOrNull<'a> = Option<&'a RawServoAnimationValue>;"#)
-        .raw_line(r#"pub type RawServoAnimationValueMapStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoAnimationValueMap>;"#)
-        .raw_line(r#"pub type RawServoAnimationValueMapBorrowed<'a> = &'a RawServoAnimationValueMap;"#)
-        .raw_line(r#"pub type RawServoAnimationValueMapBorrowedOrNull<'a> = Option<&'a RawServoAnimationValueMap>;"#)
-        .raw_line(r#"pub type RawServoMediaListStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaList>;"#)
-        .raw_line(r#"pub type RawServoMediaListBorrowed<'a> = &'a RawServoMediaList;"#)
-        .raw_line(r#"pub type RawServoMediaListBorrowedOrNull<'a> = Option<&'a RawServoMediaList>;"#)
-        .raw_line(r#"enum RawServoMediaListVoid { }"#)
-        .raw_line(r#"pub struct RawServoMediaList(RawServoMediaListVoid);"#)
-        .raw_line(r#"pub type RawServoMediaRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoMediaRule>;"#)
-        .raw_line(r#"pub type RawServoMediaRuleBorrowed<'a> = &'a RawServoMediaRule;"#)
-        .raw_line(r#"pub type RawServoMediaRuleBorrowedOrNull<'a> = Option<&'a RawServoMediaRule>;"#)
-        .raw_line(r#"enum RawServoMediaRuleVoid { }"#)
-        .raw_line(r#"pub struct RawServoMediaRule(RawServoMediaRuleVoid);"#)
-        .raw_line(r#"pub type RawServoNamespaceRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoNamespaceRule>;"#)
-        .raw_line(r#"pub type RawServoNamespaceRuleBorrowed<'a> = &'a RawServoNamespaceRule;"#)
-        .raw_line(r#"pub type RawServoNamespaceRuleBorrowedOrNull<'a> = Option<&'a RawServoNamespaceRule>;"#)
-        .raw_line(r#"enum RawServoNamespaceRuleVoid { }"#)
-        .raw_line(r#"pub struct RawServoNamespaceRule(RawServoNamespaceRuleVoid);"#)
-        .raw_line(r#"pub type RawServoStyleSetOwned = ::gecko_bindings::sugar::ownership::Owned<RawServoStyleSet>;"#)
-        .raw_line(r#"pub type RawServoStyleSetOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<RawServoStyleSet>;"#)
-        .raw_line(r#"pub type RawServoStyleSetBorrowed<'a> = &'a RawServoStyleSet;"#)
-        .raw_line(r#"pub type RawServoStyleSetBorrowedOrNull<'a> = Option<&'a RawServoStyleSet>;"#)
-        .raw_line(r#"pub type RawServoStyleSetBorrowedMut<'a> = &'a mut RawServoStyleSet;"#)
-        .raw_line(r#"pub type RawServoStyleSetBorrowedMutOrNull<'a> = Option<&'a mut RawServoStyleSet>;"#)
-        .raw_line(r#"enum RawServoStyleSetVoid { }"#)
-        .raw_line(r#"pub struct RawServoStyleSet(RawServoStyleSetVoid);"#)
-        .raw_line(r#"pub type StyleChildrenIteratorOwned = ::gecko_bindings::sugar::ownership::Owned<StyleChildrenIterator>;"#)
-        .raw_line(r#"pub type StyleChildrenIteratorOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<StyleChildrenIterator>;"#)
-        .raw_line(r#"pub type StyleChildrenIteratorBorrowed<'a> = &'a StyleChildrenIterator;"#)
-        .raw_line(r#"pub type StyleChildrenIteratorBorrowedOrNull<'a> = Option<&'a StyleChildrenIterator>;"#)
-        .raw_line(r#"pub type StyleChildrenIteratorBorrowedMut<'a> = &'a mut StyleChildrenIterator;"#)
-        .raw_line(r#"pub type StyleChildrenIteratorBorrowedMutOrNull<'a> = Option<&'a mut StyleChildrenIterator>;"#)
-        .raw_line(r#"enum StyleChildrenIteratorVoid { }"#)
-        .raw_line(r#"pub struct StyleChildrenIterator(StyleChildrenIteratorVoid);"#)
-        .raw_line(r#"pub type ServoElementSnapshotOwned = ::gecko_bindings::sugar::ownership::Owned<ServoElementSnapshot>;"#)
-        .raw_line(r#"pub type ServoElementSnapshotOwnedOrNull = ::gecko_bindings::sugar::ownership::OwnedOrNull<ServoElementSnapshot>;"#)
-        .raw_line(r#"pub type ServoElementSnapshotBorrowed<'a> = &'a ServoElementSnapshot;"#)
-        .raw_line(r#"pub type ServoElementSnapshotBorrowedOrNull<'a> = Option<&'a ServoElementSnapshot>;"#)
-        .raw_line(r#"pub type ServoElementSnapshotBorrowedMut<'a> = &'a mut ServoElementSnapshot;"#)
-        .raw_line(r#"pub type ServoElementSnapshotBorrowedMutOrNull<'a> = Option<&'a mut ServoElementSnapshot>;"#)
-        .raw_line(r#"pub type RawGeckoNodeBorrowed<'a> = &'a RawGeckoNode;"#)
-        .raw_line(r#"pub type RawGeckoNodeBorrowedOrNull<'a> = Option<&'a RawGeckoNode>;"#)
-        .raw_line(r#"pub type RawGeckoElementBorrowed<'a> = &'a RawGeckoElement;"#)
-        .raw_line(r#"pub type RawGeckoElementBorrowedOrNull<'a> = Option<&'a RawGeckoElement>;"#)
-        .raw_line(r#"pub type RawGeckoDocumentBorrowed<'a> = &'a RawGeckoDocument;"#)
-        .raw_line(r#"pub type RawGeckoDocumentBorrowedOrNull<'a> = Option<&'a RawGeckoDocument>;"#)
-        .raw_line(r#"pub type RawServoDeclarationBlockStrongBorrowed<'a> = &'a RawServoDeclarationBlockStrong;"#)
-        .raw_line(r#"pub type RawServoDeclarationBlockStrongBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlockStrong>;"#)
-        .raw_line(r#"pub type RawGeckoPresContextBorrowed<'a> = &'a RawGeckoPresContext;"#)
-        .raw_line(r#"pub type RawGeckoPresContextBorrowedOrNull<'a> = Option<&'a RawGeckoPresContext>;"#)
-        .raw_line(r#"pub type RawGeckoStyleAnimationListBorrowed<'a> = &'a RawGeckoStyleAnimationList;"#)
-        .raw_line(r#"pub type RawGeckoStyleAnimationListBorrowedOrNull<'a> = Option<&'a RawGeckoStyleAnimationList>;"#)
-        .raw_line(r#"pub type nsCSSValueBorrowed<'a> = &'a nsCSSValue;"#)
-        .raw_line(r#"pub type nsCSSValueBorrowedOrNull<'a> = Option<&'a nsCSSValue>;"#)
-        .raw_line(r#"pub type nsCSSValueBorrowedMut<'a> = &'a mut nsCSSValue;"#)
-        .raw_line(r#"pub type nsCSSValueBorrowedMutOrNull<'a> = Option<&'a mut nsCSSValue>;"#)
-        .raw_line(r#"pub type nsTimingFunctionBorrowed<'a> = &'a nsTimingFunction;"#)
-        .raw_line(r#"pub type nsTimingFunctionBorrowedOrNull<'a> = Option<&'a nsTimingFunction>;"#)
-        .raw_line(r#"pub type nsTimingFunctionBorrowedMut<'a> = &'a mut nsTimingFunction;"#)
-        .raw_line(r#"pub type nsTimingFunctionBorrowedMutOrNull<'a> = Option<&'a mut nsTimingFunction>;"#)
-        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowed<'a> = &'a RawGeckoAnimationPropertySegment;"#)
-        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationPropertySegment>;"#)
-        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedMut<'a> = &'a mut RawGeckoAnimationPropertySegment;"#)
-        .raw_line(r#"pub type RawGeckoAnimationPropertySegmentBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationPropertySegment>;"#)
-        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowed<'a> = &'a RawGeckoAnimationValueList;"#)
-        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedOrNull<'a> = Option<&'a RawGeckoAnimationValueList>;"#)
-        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedMut<'a> = &'a mut RawGeckoAnimationValueList;"#)
-        .raw_line(r#"pub type RawGeckoAnimationValueListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoAnimationValueList>;"#)
-        .raw_line(r#"pub type RawGeckoComputedTimingBorrowed<'a> = &'a RawGeckoComputedTiming;"#)
-        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedOrNull<'a> = Option<&'a RawGeckoComputedTiming>;"#)
-        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedMut<'a> = &'a mut RawGeckoComputedTiming;"#)
-        .raw_line(r#"pub type RawGeckoComputedTimingBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedTiming>;"#)
-        .raw_line(r#"pub type RawGeckoKeyframeListBorrowed<'a> = &'a RawGeckoKeyframeList;"#)
-        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedOrNull<'a> = Option<&'a RawGeckoKeyframeList>;"#)
-        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedMut<'a> = &'a mut RawGeckoKeyframeList;"#)
-        .raw_line(r#"pub type RawGeckoKeyframeListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoKeyframeList>;"#)
-        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowed<'a> = &'a RawGeckoComputedKeyframeValuesList;"#)
-        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedOrNull<'a> = Option<&'a RawGeckoComputedKeyframeValuesList>;"#)
-        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedMut<'a> = &'a mut RawGeckoComputedKeyframeValuesList;"#)
-        .raw_line(r#"pub type RawGeckoComputedKeyframeValuesListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoComputedKeyframeValuesList>;"#)
-        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowed<'a> = &'a RawGeckoFontFaceRuleList;"#)
-        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedOrNull<'a> = Option<&'a RawGeckoFontFaceRuleList>;"#)
-        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedMut<'a> = &'a mut RawGeckoFontFaceRuleList;"#)
-        .raw_line(r#"pub type RawGeckoFontFaceRuleListBorrowedMutOrNull<'a> = Option<&'a mut RawGeckoFontFaceRuleList>;"#)
-        .clang_arg("-x")
-        .clang_arg("c++")
-        .clang_arg("-std=c++14")
-        .clang_arg("-DTRACING=1")
-        .clang_arg("-DIMPL_LIBXUL")
-        .clang_arg("-DMOZ_STYLO_BINDINGS=1")
-        .clang_arg("-DMOZILLA_INTERNAL_API")
-        .clang_arg("-DRUST_BINDGEN")
-        .clang_arg("-DMOZ_STYLO")
-        .clang_arg("-DOS_POSIX=1")
-        .clang_arg("-DOS_LINUX=1")
-        .generate()
-        .expect("Should generate stylo bindings");
-
-    let now = Instant::now();
-
-    println!();
-    println!();
-    println!(
-        "Generated Stylo bindings in: {:?}",
-        now.duration_since(then)
-    );
-    println!();
-    println!();
-
-    // panic!("Uncomment this line to get timing logs");
-}
diff --git a/tests/test-one.sh b/tests/test-one.sh
deleted file mode 100755
index 91da55b1..00000000
--- a/tests/test-one.sh
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env bash
-
-# Usage:
-#
-#     ./tests/test-one.sh <fuzzy-name>
-#
-# Generate bindings for the first match of `./tests/headers/*<fuzzy-name>*`, use
-# `rustc` to compile the bindings with unit tests enabled, and run the generated
-# layout tests.
-
-set -eu
-
-if [ $# -ne 1 ]; then
-    echo "Usage: $0 <fuzzy-name>"
-    exit 1
-fi
-
-cd "$(dirname "$0")"
-cd ..
-
-export RUST_BACKTRACE=1
-
-unique_fuzzy_file() {
-    local pattern="$1"
-    local results="$(find ./tests/headers -type f | egrep -i "$pattern")"
-    local num_results=$(echo "$results" | wc -l)
-
-    if [[ -z "$results" ]]; then
-        >&2 echo "ERROR: no files found with pattern \"$pattern\""
-        exit 1
-    elif [[ "$num_results" -ne 1 ]]; then
-        >&2 echo "ERROR: Expected exactly 1 result, got $num_results:"
-        >&2 echo "$results"
-        exit 1
-    fi
-
-    echo "$results"
-}
-
-TEST="$(unique_fuzzy_file "$1")"
-
-BINDINGS=$(mktemp -t bindings.rs.XXXXXX)
-TEST_BINDINGS_BINARY=$(mktemp -t bindings.XXXXXX)
-
-FLAGS="$(grep "// bindgen-flags: " "$TEST" || echo)"
-FLAGS="${FLAGS/\/\/ bindgen\-flags:/}"
-# Prepend the default flags added in test.rs's `create_bindgen_builder`.
-FLAGS="--rustfmt-bindings --with-derive-default --raw-line '' --raw-line '#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]' --raw-line '' $FLAGS"
-
-
-eval ./target/debug/bindgen \
-    "\"$TEST\"" \
-    --emit-ir \
-    --emit-ir-graphviz ir.dot \
-    --emit-clang-ast \
-    -o "\"$BINDINGS\"" \
-    $FLAGS
-
-rustup run nightly rustfmt "$BINDINGS" || true
-
-dot -Tpng ir.dot -o ir.png
-
-echo
-echo "=== Input header ========================================================"
-echo
-
-cat "$TEST"
-
-echo
-echo "=== Generated bindings =================================================="
-echo
-
-cat "$BINDINGS"
-
-echo
-echo "=== Diff w/ expected bindings ==========================================="
-echo
-
-EXPECTED=${TEST/headers/expectations\/tests}
-EXPECTED=${EXPECTED/.hpp/.rs}
-EXPECTED=${EXPECTED/.h/.rs}
-
-rustup run nightly rustfmt "$EXPECTED" || true
-
-# Don't exit early if there is a diff.
-diff -U8 "$EXPECTED" "$BINDINGS" || true
-
-echo
-echo "=== Building bindings ==================================================="
-echo
-
-rustc --test -o "$TEST_BINDINGS_BINARY" "$BINDINGS" --crate-name bindgen_test_one
-
-echo
-echo "=== Testing bindings ===================================================="
-echo
-
-"$TEST_BINDINGS_BINARY"
diff --git a/tests/tests.rs b/tests/tests.rs
deleted file mode 100644
index ac53d739..00000000
--- a/tests/tests.rs
+++ /dev/null
@@ -1,688 +0,0 @@
-extern crate bindgen;
-extern crate clap;
-extern crate diff;
-#[cfg(feature = "logging")]
-extern crate env_logger;
-extern crate shlex;
-
-use bindgen::{clang_version, Builder};
-use std::env;
-use std::fs;
-use std::io::{self, BufRead, BufReader, Error, ErrorKind, Read, Write};
-use std::path::{Path, PathBuf};
-use std::process;
-use std::sync::Once;
-
-#[path = "../src/options.rs"]
-mod options;
-use crate::options::builder_from_flags;
-
-mod parse_callbacks;
-
-// Run `rustfmt` on the given source string and return a tuple of the formatted
-// bindings, and rustfmt's stderr.
-fn rustfmt(source: String) -> (String, String) {
-    static CHECK_RUSTFMT: Once = Once::new();
-
-    CHECK_RUSTFMT.call_once(|| {
-        if env::var_os("RUSTFMT").is_some() {
-            return;
-        }
-
-        let mut rustfmt = {
-            let mut p = process::Command::new("rustup");
-            p.args(["run", "nightly", "rustfmt", "--version"]);
-            p
-        };
-
-        let have_working_rustfmt = rustfmt
-            .stdout(process::Stdio::null())
-            .stderr(process::Stdio::null())
-            .status()
-            .ok()
-            .map_or(false, |status| status.success());
-
-        if !have_working_rustfmt {
-            panic!(
-                "
-The latest `rustfmt` is required to run the `bindgen` test suite. Install
-`rustfmt` with:
-
-    $ rustup update nightly
-    $ rustup component add rustfmt --toolchain nightly
-"
-            );
-        }
-    });
-
-    let mut child = match env::var_os("RUSTFMT") {
-        Some(r) => process::Command::new(r),
-        None => {
-            let mut p = process::Command::new("rustup");
-            p.args(["run", "nightly", "rustfmt"]);
-            p
-        }
-    };
-
-    let mut child = child
-        .args([
-            "--config-path",
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/rustfmt.toml"),
-        ])
-        .stdin(process::Stdio::piped())
-        .stdout(process::Stdio::piped())
-        .stderr(process::Stdio::piped())
-        .spawn()
-        .expect("should spawn `rustup run nightly rustfmt`");
-
-    let mut stdin = child.stdin.take().unwrap();
-    let mut stdout = child.stdout.take().unwrap();
-    let mut stderr = child.stderr.take().unwrap();
-
-    // Write to stdin in a new thread, so that we can read from stdout on this
-    // thread. This keeps the child from blocking on writing to its stdout which
-    // might block us from writing to its stdin.
-    let stdin_handle =
-        ::std::thread::spawn(move || stdin.write_all(source.as_bytes()));
-
-    // Read stderr on a new thread for similar reasons.
-    let stderr_handle = ::std::thread::spawn(move || {
-        let mut output = vec![];
-        io::copy(&mut stderr, &mut output)
-            .map(|_| String::from_utf8_lossy(&output).to_string())
-    });
-
-    let mut output = vec![];
-    io::copy(&mut stdout, &mut output).expect("Should copy stdout into vec OK");
-
-    // Ignore actual rustfmt status because it is often non-zero for trivial
-    // things.
-    let _ = child.wait().expect("should wait on rustfmt child OK");
-
-    stdin_handle
-        .join()
-        .expect("writer thread should not have panicked")
-        .expect("should have written to child rustfmt's stdin OK");
-
-    let bindings = String::from_utf8(output)
-        .expect("rustfmt should only emit valid utf-8");
-
-    let stderr = stderr_handle
-        .join()
-        .expect("stderr reader thread should not have panicked")
-        .expect("should have read child rustfmt's stderr OK");
-
-    (bindings, stderr)
-}
-
-fn should_overwrite_expected() -> bool {
-    if let Some(var) = env::var_os("BINDGEN_OVERWRITE_EXPECTED") {
-        if var == "1" {
-            return true;
-        }
-        if var != "0" && var != "" {
-            panic!("Invalid value of BINDGEN_OVERWRITE_EXPECTED");
-        }
-    }
-    false
-}
-
-fn error_diff_mismatch(
-    actual: &str,
-    expected: &str,
-    header: Option<&Path>,
-    filename: &Path,
-) -> Result<(), Error> {
-    println!("diff expected generated");
-    println!("--- expected: {:?}", filename);
-    if let Some(header) = header {
-        println!("+++ generated from: {:?}", header);
-    }
-
-    for diff in diff::lines(expected, actual) {
-        match diff {
-            diff::Result::Left(l) => println!("-{}", l),
-            diff::Result::Both(l, _) => println!(" {}", l),
-            diff::Result::Right(r) => println!("+{}", r),
-        }
-    }
-
-    if should_overwrite_expected() {
-        // Overwrite the expectation with actual output.
-        let mut expectation_file = fs::File::create(filename)?;
-        expectation_file.write_all(actual.as_bytes())?;
-    }
-
-    if let Some(var) = env::var_os("BINDGEN_TESTS_DIFFTOOL") {
-        //usecase: var = "meld" -> You can hand check differences
-        let name = match filename.components().last() {
-            Some(std::path::Component::Normal(name)) => name,
-            _ => panic!("Why is the header variable so weird?"),
-        };
-        let actual_result_path =
-            PathBuf::from(env::var("OUT_DIR").unwrap()).join(name);
-        let mut actual_result_file = fs::File::create(&actual_result_path)?;
-        actual_result_file.write_all(actual.as_bytes())?;
-        std::process::Command::new(var)
-            .args([filename, &actual_result_path])
-            .output()?;
-    }
-
-    Err(Error::new(ErrorKind::Other, "Header and binding differ! Run with BINDGEN_OVERWRITE_EXPECTED=1 in the environment to automatically overwrite the expectation or with BINDGEN_TESTS_DIFFTOOL=meld to do this manually."))
-}
-
-fn compare_generated_header(
-    header: &Path,
-    builder: BuilderState,
-    check_roundtrip: bool,
-) -> Result<(), Error> {
-    let file_name = header.file_name().ok_or_else(|| {
-        Error::new(ErrorKind::Other, "compare_generated_header expects a file")
-    })?;
-
-    let mut expectation = PathBuf::from(header);
-    expectation.pop();
-    expectation.pop();
-    expectation.push("expectations");
-    expectation.push("tests");
-
-    let mut looked_at = vec![];
-    let mut expectation_file;
-
-    // Try more specific expectations first.
-    {
-        let mut expectation = expectation.clone();
-
-        if cfg!(feature = "testing_only_libclang_9") {
-            expectation.push("libclang-9");
-        } else if cfg!(feature = "testing_only_libclang_5") {
-            expectation.push("libclang-5");
-        } else {
-            match clang_version().parsed {
-                None => expectation.push("libclang-9"),
-                Some(version) => {
-                    let (maj, min) = version;
-                    let version_str = if maj >= 9 {
-                        "9".to_owned()
-                    } else if maj >= 5 {
-                        "5".to_owned()
-                    } else if maj >= 4 {
-                        "4".to_owned()
-                    } else {
-                        format!("{}.{}", maj, min)
-                    };
-                    expectation.push(format!("libclang-{}", version_str));
-                }
-            }
-        }
-
-        expectation.push(file_name);
-        expectation.set_extension("rs");
-        expectation_file = fs::File::open(&expectation).ok();
-        looked_at.push(expectation);
-    }
-
-    // Try the default path otherwise.
-    if expectation_file.is_none() {
-        expectation.push(file_name);
-        expectation.set_extension("rs");
-        expectation_file = fs::File::open(&expectation).ok();
-        looked_at.push(expectation.clone());
-    }
-
-    let mut expected = String::new();
-    match expectation_file {
-        Some(f) => {
-            BufReader::new(f).read_to_string(&mut expected)?;
-        }
-        None => panic!(
-            "missing test expectation file and/or 'testing_only_libclang_$VERSION' \
-             feature for header '{}'; looking for expectation file at '{:?}'",
-            header.display(),
-            looked_at,
-        ),
-    };
-
-    let (builder, roundtrip_builder) = builder.into_builder(check_roundtrip)?;
-
-    // We skip the generate() error here so we get a full diff below
-    let (actual, rustfmt_stderr) = match builder.generate() {
-        Ok(bindings) => {
-            let actual = bindings.to_string();
-            rustfmt(actual)
-        }
-        Err(_) => ("<error generating bindings>".to_string(), "".to_string()),
-    };
-    println!("{}", rustfmt_stderr);
-
-    let (expected, rustfmt_stderr) = rustfmt(expected);
-    println!("{}", rustfmt_stderr);
-
-    if actual.is_empty() {
-        return Err(Error::new(
-            ErrorKind::Other,
-            "Something's gone really wrong!",
-        ));
-    }
-
-    if actual != expected {
-        println!("{}", rustfmt_stderr);
-        return error_diff_mismatch(
-            &actual,
-            &expected,
-            Some(header),
-            looked_at.last().unwrap(),
-        );
-    }
-
-    if let Some(roundtrip_builder) = roundtrip_builder {
-        if let Err(e) =
-            compare_generated_header(header, roundtrip_builder, false)
-        {
-            return Err(Error::new(ErrorKind::Other, format!("Checking CLI flags roundtrip errored! You probably need to fix Builder::command_line_flags. {}", e)));
-        }
-    }
-
-    Ok(())
-}
-
-fn builder() -> Builder {
-    #[cfg(feature = "logging")]
-    let _ = env_logger::try_init();
-
-    bindgen::builder().disable_header_comment()
-}
-
-struct BuilderState {
-    builder: Builder,
-    parse_callbacks: Option<String>,
-}
-
-impl BuilderState {
-    fn into_builder(
-        self,
-        with_roundtrip_builder: bool,
-    ) -> Result<(Builder, Option<BuilderState>), Error> {
-        let roundtrip_builder = if with_roundtrip_builder {
-            let mut flags = self.builder.command_line_flags();
-            flags.insert(0, "bindgen".into());
-            let mut builder = builder_from_flags(flags.into_iter())?.0;
-            if let Some(ref parse_cb) = self.parse_callbacks {
-                builder =
-                    builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
-            }
-            Some(BuilderState {
-                builder,
-                parse_callbacks: self.parse_callbacks,
-            })
-        } else {
-            None
-        };
-        Ok((self.builder, roundtrip_builder))
-    }
-}
-
-fn create_bindgen_builder(header: &Path) -> Result<BuilderState, Error> {
-    #[cfg(feature = "logging")]
-    let _ = env_logger::try_init();
-
-    let source = fs::File::open(header)?;
-    let reader = BufReader::new(source);
-
-    // Scoop up bindgen-flags from test header
-    let mut flags = Vec::with_capacity(2);
-    let mut parse_callbacks = None;
-
-    for line in reader.lines() {
-        let line = line?;
-        if !line.starts_with("// bindgen") {
-            continue;
-        }
-
-        if line.contains("bindgen-flags: ") {
-            let extra_flags = line
-                .split("bindgen-flags: ")
-                .last()
-                .and_then(shlex::split)
-                .unwrap();
-            flags.extend(extra_flags.into_iter());
-        } else if line.contains("bindgen-osx-only") {
-            let prepend_flags = ["--raw-line", "#![cfg(target_os=\"macos\")]"];
-            flags = prepend_flags
-                .iter()
-                .map(ToString::to_string)
-                .chain(flags)
-                .collect();
-        } else if line.contains("bindgen-parse-callbacks: ") {
-            let parse_cb =
-                line.split("bindgen-parse-callbacks: ").last().unwrap();
-            parse_callbacks = Some(parse_cb.to_owned());
-        }
-    }
-
-    // Different platforms have various different conventions like struct padding, mangling, etc.
-    // We make the default target as x86_64-unknown-linux
-    if flags.iter().all(|flag| !flag.starts_with("--target=")) {
-        if !flags.iter().any(|flag| flag == "--") {
-            flags.push("--".into());
-        }
-        flags.push("--target=x86_64-unknown-linux".into());
-    }
-
-    // Fool builder_from_flags() into believing it has real env::args_os...
-    // - add "bindgen" as executable name 0th element
-    // - add header filename as 1st element
-    // - prepend raw lines so they're in the right order for expected output
-    // - append the test header's bindgen flags
-    let header_str = header.to_str().ok_or_else(|| {
-        Error::new(ErrorKind::Other, "Invalid header file name")
-    })?;
-
-    let prepend = [
-        "bindgen",
-        // We format in `compare_generated_header` ourselves to have a little
-        // more control.
-        "--no-rustfmt-bindings",
-        "--with-derive-default",
-        "--disable-header-comment",
-        "--vtable-generation",
-        header_str,
-        "--raw-line",
-        "",
-        "--raw-line",
-        "#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]",
-        "--raw-line",
-        "",
-    ];
-
-    let args = prepend
-        .iter()
-        .map(ToString::to_string)
-        .chain(flags.into_iter());
-
-    let mut builder = builder_from_flags(args)?.0;
-    if let Some(ref parse_cb) = parse_callbacks {
-        builder = builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
-    }
-    Ok(BuilderState {
-        builder,
-        parse_callbacks,
-    })
-}
-
-macro_rules! test_header {
-    ($function:ident, $header:expr) => {
-        #[test]
-        fn $function() {
-            let header = PathBuf::from($header);
-            let result = create_bindgen_builder(&header).and_then(|builder| {
-                let check_roundtrip =
-                    env::var_os("BINDGEN_DISABLE_ROUNDTRIP_TEST").is_none();
-                compare_generated_header(&header, builder, check_roundtrip)
-            });
-
-            if let Err(err) = result {
-                panic!("{}", err);
-            }
-        }
-    };
-}
-
-// This file is generated by build.rs
-include!(concat!(env!("OUT_DIR"), "/tests.rs"));
-
-#[test]
-#[cfg_attr(target_os = "windows", ignore)]
-fn test_clang_env_args() {
-    std::env::set_var(
-        "BINDGEN_EXTRA_CLANG_ARGS",
-        "-D_ENV_ONE=1 -D_ENV_TWO=\"2 -DNOT_THREE=1\"",
-    );
-    let actual = builder()
-        .disable_header_comment()
-        .header_contents(
-            "test.hpp",
-            "#ifdef _ENV_ONE\nextern const int x[] = { 42 };\n#endif\n\
-             #ifdef _ENV_TWO\nextern const int y[] = { 42 };\n#endif\n\
-             #ifdef NOT_THREE\nextern const int z[] = { 42 };\n#endif\n",
-        )
-        .generate()
-        .unwrap()
-        .to_string();
-
-    let (actual, stderr) = rustfmt(actual);
-    println!("{}", stderr);
-
-    let (expected, _) = rustfmt(
-        "extern \"C\" {
-    pub static x: [::std::os::raw::c_int; 1usize];
-}
-extern \"C\" {
-    pub static y: [::std::os::raw::c_int; 1usize];
-}
-"
-        .to_string(),
-    );
-
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn test_header_contents() {
-    let actual = builder()
-        .disable_header_comment()
-        .header_contents("test.h", "int foo(const char* a);")
-        .clang_arg("--target=x86_64-unknown-linux")
-        .generate()
-        .unwrap()
-        .to_string();
-
-    let (actual, stderr) = rustfmt(actual);
-    println!("{}", stderr);
-
-    let (expected, _) = rustfmt(
-        "extern \"C\" {
-    pub fn foo(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
-}
-"
-        .to_string(),
-    );
-
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn test_multiple_header_calls_in_builder() {
-    let actual = builder()
-        .header(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/headers/func_ptr.h"
-        ))
-        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h"))
-        .clang_arg("--target=x86_64-unknown-linux")
-        .generate()
-        .unwrap()
-        .to_string();
-
-    let (actual, stderr) = rustfmt(actual);
-    println!("{}", stderr);
-
-    let expected_filename = concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/expectations/tests/test_multiple_header_calls_in_builder.rs"
-    );
-    let expected = include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/expectations/tests/test_multiple_header_calls_in_builder.rs"
-    ));
-    let (expected, _) = rustfmt(expected.to_string());
-
-    if actual != expected {
-        println!("Generated bindings differ from expected!");
-        error_diff_mismatch(
-            &actual,
-            &expected,
-            None,
-            Path::new(expected_filename),
-        )
-        .unwrap();
-    }
-}
-
-#[test]
-fn test_multiple_header_contents() {
-    let actual = builder()
-        .header_contents("test.h", "int foo(const char* a);")
-        .header_contents("test2.h", "float foo2(const char* b);")
-        .clang_arg("--target=x86_64-unknown-linux")
-        .generate()
-        .unwrap()
-        .to_string();
-
-    let (actual, stderr) = rustfmt(actual);
-    println!("{}", stderr);
-
-    let (expected, _) = rustfmt(
-        "extern \"C\" {
-    pub fn foo2(b: *const ::std::os::raw::c_char) -> f32;
-}
-extern \"C\" {
-    pub fn foo(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
-}
-"
-        .to_string(),
-    );
-
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn test_mixed_header_and_header_contents() {
-    let actual = builder()
-        .header(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/headers/func_ptr.h"
-        ))
-        .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h"))
-        .header_contents("test.h", "int bar(const char* a);")
-        .header_contents("test2.h", "float bar2(const char* b);")
-        .clang_arg("--target=x86_64-unknown-linux")
-        .generate()
-        .unwrap()
-        .to_string();
-
-    let (actual, stderr) = rustfmt(actual);
-    println!("{}", stderr);
-
-    let expected_filename = concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/expectations/tests/test_mixed_header_and_header_contents.rs"
-    );
-    let expected = include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/expectations/tests/test_mixed_header_and_header_contents.rs"
-    ));
-    let (expected, _) = rustfmt(expected.to_string());
-    if expected != actual {
-        error_diff_mismatch(
-            &actual,
-            &expected,
-            None,
-            Path::new(expected_filename),
-        )
-        .unwrap();
-    }
-}
-
-#[test]
-// Doesn't support executing sh file on Windows.
-// We may want to implement it in Rust so that we support all systems.
-#[cfg(not(target_os = "windows"))]
-fn no_system_header_includes() {
-    use std::process::Command;
-    assert!(Command::new("./ci/no-includes.sh")
-        .current_dir(env!("CARGO_MANIFEST_DIR"))
-        .spawn()
-        .expect("should spawn ./ci/no-includes.sh OK")
-        .wait()
-        .expect("should wait for ./ci/no-includes OK")
-        .success());
-}
-
-#[test]
-fn emit_depfile() {
-    let header = PathBuf::from("tests/headers/enum-default-rust.h");
-    let expected_depfile = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("tests")
-        .join("expectations")
-        .join("tests")
-        .join("enum-default-rust.d");
-    let observed_depfile = tempfile::NamedTempFile::new().unwrap();
-    let mut builder = create_bindgen_builder(&header).unwrap();
-    builder.builder = builder.builder.depfile(
-        "tests/expectations/tests/enum-default-rust.rs",
-        observed_depfile.path(),
-    );
-
-    let check_roundtrip =
-        env::var_os("BINDGEN_DISABLE_ROUNDTRIP_TEST").is_none();
-    let (builder, _roundtrip_builder) =
-        builder.into_builder(check_roundtrip).unwrap();
-    let _bindings = builder.generate().unwrap();
-
-    let observed = std::fs::read_to_string(observed_depfile).unwrap();
-    let expected = std::fs::read_to_string(expected_depfile).unwrap();
-    assert_eq!(observed.trim(), expected.trim());
-}
-
-#[test]
-fn dump_preprocessed_input() {
-    let arg_keyword =
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/arg_keyword.hpp");
-    let empty_layout = concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/headers/cpp-empty-layout.hpp"
-    );
-
-    builder()
-        .header(arg_keyword)
-        .header(empty_layout)
-        .dump_preprocessed_input()
-        .expect("should dump preprocessed input");
-
-    fn slurp(p: &str) -> String {
-        let mut contents = String::new();
-        let mut file = fs::File::open(p).unwrap();
-        file.read_to_string(&mut contents).unwrap();
-        contents
-    }
-
-    let bindgen_ii = slurp("__bindgen.ii");
-    let arg_keyword = slurp(arg_keyword);
-    let empty_layout = slurp(empty_layout);
-
-    assert!(
-        bindgen_ii.contains(&arg_keyword),
-        "arg_keyword.hpp is in the preprocessed file"
-    );
-    assert!(
-        bindgen_ii.contains(&empty_layout),
-        "cpp-empty-layout.hpp is in the preprocessed file"
-    );
-}
-
-#[test]
-fn allowlist_warnings() {
-    let header = concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/headers/allowlist_warnings.h"
-    );
-
-    let bindings = builder()
-        .header(header)
-        .allowlist_function("doesnt_match_anything")
-        .generate()
-        .expect("unable to generate bindings");
-
-    assert_eq!(1, bindings.warnings().len());
-}
diff --git a/tests/uses/.gitignore b/tests/uses/.gitignore
deleted file mode 100644
index 40d7cb4c..00000000
--- a/tests/uses/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.c
-*.cpp
-- 
cgit v1.2.3


From 576fd8d424c8248726542b0951c594a9734cd02a Mon Sep 17 00:00:00 2001
From: Emilio Cobos Álvarez <emilio@crisal.io>
Date: Wed, 5 Oct 2022 05:00:28 +0200
Subject: context: Fix tokenization of C++20 inline namespace. (#2294)

Fixes #2293
---
 .../expectations/tests/inline_namespace_nested.rs  | 21 +++++++
 .../tests/libclang-5/inline_namespace_nested.rs    |  1 +
 .../tests/headers/inline_namespace_nested.hpp      |  5 ++
 bindgen-tests/tests/tests.rs                       |  2 +-
 bindgen/ir/context.rs                              | 71 +++++++++++-----------
 5 files changed, 63 insertions(+), 37 deletions(-)
 create mode 100644 bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs
 create mode 100644 bindgen-tests/tests/expectations/tests/libclang-5/inline_namespace_nested.rs
 create mode 100644 bindgen-tests/tests/headers/inline_namespace_nested.hpp

diff --git a/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs b/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs
new file mode 100644
index 00000000..29b5b35f
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/inline_namespace_nested.rs
@@ -0,0 +1,21 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod ranges {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub mod bar {
+            #[allow(unused_imports)]
+            use self::super::super::super::root;
+            pub const bar: ::std::os::raw::c_int = 0;
+        }
+    }
+}
diff --git a/bindgen-tests/tests/expectations/tests/libclang-5/inline_namespace_nested.rs b/bindgen-tests/tests/expectations/tests/libclang-5/inline_namespace_nested.rs
new file mode 100644
index 00000000..996b877e
--- /dev/null
+++ b/bindgen-tests/tests/expectations/tests/libclang-5/inline_namespace_nested.rs
@@ -0,0 +1 @@
+/* error generating bindings */
diff --git a/bindgen-tests/tests/headers/inline_namespace_nested.hpp b/bindgen-tests/tests/headers/inline_namespace_nested.hpp
new file mode 100644
index 00000000..5c542e19
--- /dev/null
+++ b/bindgen-tests/tests/headers/inline_namespace_nested.hpp
@@ -0,0 +1,5 @@
+// bindgen-flags: --enable-cxx-namespaces -- -std=c++2a
+
+namespace ranges::inline foo::bar {
+  static int bar = 0;
+}
diff --git a/bindgen-tests/tests/tests.rs b/bindgen-tests/tests/tests.rs
index ca081e26..25c073cc 100644
--- a/bindgen-tests/tests/tests.rs
+++ b/bindgen-tests/tests/tests.rs
@@ -252,7 +252,7 @@ fn compare_generated_header(
             let actual = bindings.to_string();
             rustfmt(actual)
         }
-        Err(_) => ("<error generating bindings>".to_string(), "".to_string()),
+        Err(_) => ("/* error generating bindings */\n".into(), "".to_string()),
     };
     println!("{}", rustfmt_stderr);
 
diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs
index 12373952..e2a13b8d 100644
--- a/bindgen/ir/context.rs
+++ b/bindgen/ir/context.rs
@@ -2107,13 +2107,18 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         }
 
         let mut kind = ModuleKind::Normal;
-        let mut found_namespace_keyword = false;
+        let mut looking_for_name = false;
         for token in cursor.tokens().iter() {
             match token.spelling() {
                 b"inline" => {
-                    assert!(!found_namespace_keyword);
-                    assert!(kind != ModuleKind::Inline);
+                    debug_assert!(
+                        kind != ModuleKind::Inline,
+                        "Multiple inline keywords?"
+                    );
                     kind = ModuleKind::Inline;
+                    // When hitting a nested inline namespace we get a spelling
+                    // that looks like ["inline", "foo"]. Deal with it properly.
+                    looking_for_name = true;
                 }
                 // The double colon allows us to handle nested namespaces like
                 // namespace foo::bar { }
@@ -2122,45 +2127,39 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                 // but the tokenization of the second begins with the double
                 // colon. That's ok, so we only need to handle the weird
                 // tokenization here.
-                //
-                // Fortunately enough, inline nested namespace specifiers aren't
-                // a thing, and are invalid C++ :)
                 b"namespace" | b"::" => {
-                    found_namespace_keyword = true;
+                    looking_for_name = true;
                 }
                 b"{" => {
-                    assert!(found_namespace_keyword);
+                    // This should be an anonymous namespace.
+                    assert!(looking_for_name);
                     break;
                 }
-                name if found_namespace_keyword => {
-                    if module_name.is_none() {
-                        module_name =
-                            Some(String::from_utf8_lossy(name).into_owned());
+                name => {
+                    if looking_for_name {
+                        if module_name.is_none() {
+                            module_name = Some(
+                                String::from_utf8_lossy(name).into_owned(),
+                            );
+                        }
+                        break;
+                    } else {
+                        // This is _likely_, but not certainly, a macro that's
+                        // been placed just before the namespace keyword.
+                        // Unfortunately, clang tokens don't let us easily see
+                        // through the ifdef tokens, so we don't know what this
+                        // token should really be. Instead of panicking though,
+                        // we warn the user that we assumed the token was blank,
+                        // and then move on.
+                        //
+                        // See also https://github.com/rust-lang/rust-bindgen/issues/1676.
+                        warn!(
+                            "Ignored unknown namespace prefix '{}' at {:?} in {:?}",
+                            String::from_utf8_lossy(name),
+                            token,
+                            cursor
+                        );
                     }
-                    break;
-                }
-                spelling if !found_namespace_keyword => {
-                    // This is _likely_, but not certainly, a macro that's been placed just before
-                    // the namespace keyword. Unfortunately, clang tokens don't let us easily see
-                    // through the ifdef tokens, so we don't know what this token should really be.
-                    // Instead of panicking though, we warn the user that we assumed the token was
-                    // blank, and then move on.
-                    //
-                    // See also https://github.com/rust-lang/rust-bindgen/issues/1676.
-                    warn!(
-                        "Ignored unknown namespace prefix '{}' at {:?} in {:?}",
-                        String::from_utf8_lossy(spelling),
-                        token,
-                        cursor
-                    );
-                }
-                spelling => {
-                    panic!(
-                        "Unknown token '{}' while processing namespace at {:?} in {:?}",
-                        String::from_utf8_lossy(spelling),
-                        token,
-                        cursor
-                    );
                 }
             }
         }
-- 
cgit v1.2.3